Add decompiled APK source code (JADX)

- 28,932 files
- Full Java source code
- Smali files
- Resources

Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com>

decompiled/sources/androidx/core/content/res/CamColor.java

@@ -0,0 +1,287 @@
+package androidx.core.content.res;
+
+import androidx.annotation.ColorInt;
+import androidx.annotation.FloatRange;
+import androidx.annotation.NonNull;
+import androidx.annotation.Nullable;
+import androidx.annotation.RestrictTo;
+import androidx.annotation.Size;
+import androidx.core.graphics.ColorUtils;
+import kotlin.jvm.internal.DoubleCompanionObject;
+
+@RestrictTo({RestrictTo.Scope.LIBRARY_GROUP})
+/* loaded from: classes.dex */
+public class CamColor {
+    private static final float CHROMA_SEARCH_ENDPOINT = 0.4f;
+    private static final float DE_MAX = 1.0f;
+    private static final float DL_MAX = 0.2f;
+    private static final float LIGHTNESS_SEARCH_ENDPOINT = 0.01f;
+    private final float mAstar;
+    private final float mBstar;
+    private final float mChroma;
+    private final float mHue;
+    private final float mJ;
+    private final float mJstar;
+    private final float mM;
+    private final float mQ;
+    private final float mS;
+
+    @FloatRange(from = DoubleCompanionObject.NEGATIVE_INFINITY, fromInclusive = false, to = DoubleCompanionObject.POSITIVE_INFINITY, toInclusive = false)
+    public float getAStar() {
+        return this.mAstar;
+    }
+
+    @FloatRange(from = DoubleCompanionObject.NEGATIVE_INFINITY, fromInclusive = false, to = DoubleCompanionObject.POSITIVE_INFINITY, toInclusive = false)
+    public float getBStar() {
+        return this.mBstar;
+    }
+
+    @FloatRange(from = 0.0d, to = DoubleCompanionObject.POSITIVE_INFINITY, toInclusive = false)
+    public float getChroma() {
+        return this.mChroma;
+    }
+
+    @FloatRange(from = 0.0d, to = 360.0d, toInclusive = false)
+    public float getHue() {
+        return this.mHue;
+    }
+
+    @FloatRange(from = 0.0d, to = 100.0d)
+    public float getJ() {
+        return this.mJ;
+    }
+
+    @FloatRange(from = 0.0d, to = 100.0d)
+    public float getJStar() {
+        return this.mJstar;
+    }
+
+    @FloatRange(from = 0.0d, to = DoubleCompanionObject.POSITIVE_INFINITY, toInclusive = false)
+    public float getM() {
+        return this.mM;
+    }
+
+    @FloatRange(from = 0.0d, to = DoubleCompanionObject.POSITIVE_INFINITY, toInclusive = false)
+    public float getQ() {
+        return this.mQ;
+    }
+
+    @FloatRange(from = 0.0d, to = DoubleCompanionObject.POSITIVE_INFINITY, toInclusive = false)
+    public float getS() {
+        return this.mS;
+    }
+
+    public CamColor(float f, float f2, float f3, float f4, float f5, float f6, float f7, float f8, float f9) {
+        this.mHue = f;
+        this.mChroma = f2;
+        this.mJ = f3;
+        this.mQ = f4;
+        this.mM = f5;
+        this.mS = f6;
+        this.mJstar = f7;
+        this.mAstar = f8;
+        this.mBstar = f9;
+    }
+
+    public static int toColor(@FloatRange(from = 0.0d, to = 360.0d) float f, @FloatRange(from = 0.0d, to = Double.POSITIVE_INFINITY, toInclusive = false) float f2, @FloatRange(from = 0.0d, to = 100.0d) float f3) {
+        return toColor(f, f2, f3, ViewingConditions.DEFAULT);
+    }
+
+    @NonNull
+    public static CamColor fromColor(@ColorInt int i) {
+        float[] fArr = new float[7];
+        float[] fArr2 = new float[3];
+        fromColorInViewingConditions(i, ViewingConditions.DEFAULT, fArr, fArr2);
+        return new CamColor(fArr2[0], fArr2[1], fArr[0], fArr[1], fArr[2], fArr[3], fArr[4], fArr[5], fArr[6]);
+    }
+
+    public static void getM3HCTfromColor(@ColorInt int i, @NonNull @Size(3) float[] fArr) {
+        fromColorInViewingConditions(i, ViewingConditions.DEFAULT, null, fArr);
+        fArr[2] = CamUtils.lStarFromInt(i);
+    }
+
+    public static void fromColorInViewingConditions(@ColorInt int i, @NonNull ViewingConditions viewingConditions, @Nullable @Size(7) float[] fArr, @NonNull @Size(3) float[] fArr2) {
+        CamUtils.xyzFromInt(i, fArr2);
+        float[][] fArr3 = CamUtils.XYZ_TO_CAM16RGB;
+        float f = fArr2[0];
+        float[] fArr4 = fArr3[0];
+        float f2 = fArr4[0] * f;
+        float f3 = fArr2[1];
+        float f4 = f2 + (fArr4[1] * f3);
+        float f5 = fArr2[2];
+        float f6 = f4 + (fArr4[2] * f5);
+        float[] fArr5 = fArr3[1];
+        float f7 = (fArr5[0] * f) + (fArr5[1] * f3) + (fArr5[2] * f5);
+        float[] fArr6 = fArr3[2];
+        float f8 = (f * fArr6[0]) + (f3 * fArr6[1]) + (f5 * fArr6[2]);
+        float f9 = viewingConditions.getRgbD()[0] * f6;
+        float f10 = viewingConditions.getRgbD()[1] * f7;
+        float f11 = viewingConditions.getRgbD()[2] * f8;
+        float pow = (float) Math.pow((viewingConditions.getFl() * Math.abs(f9)) / 100.0d, 0.42d);
+        float pow2 = (float) Math.pow((viewingConditions.getFl() * Math.abs(f10)) / 100.0d, 0.42d);
+        float pow3 = (float) Math.pow((viewingConditions.getFl() * Math.abs(f11)) / 100.0d, 0.42d);
+        float signum = ((Math.signum(f9) * 400.0f) * pow) / (pow + 27.13f);
+        float signum2 = ((Math.signum(f10) * 400.0f) * pow2) / (pow2 + 27.13f);
+        float signum3 = ((Math.signum(f11) * 400.0f) * pow3) / (pow3 + 27.13f);
+        double d = signum3;
+        float f12 = ((float) (((signum * 11.0d) + (signum2 * (-12.0d))) + d)) / 11.0f;
+        float f13 = ((float) ((signum + signum2) - (d * 2.0d))) / 9.0f;
+        float f14 = signum2 * 20.0f;
+        float f15 = (((signum * 20.0f) + f14) + (21.0f * signum3)) / 20.0f;
+        float f16 = (((signum * 40.0f) + f14) + signum3) / 20.0f;
+        float atan2 = (((float) Math.atan2(f13, f12)) * 180.0f) / 3.1415927f;
+        if (atan2 < 0.0f) {
+            atan2 += 360.0f;
+        } else if (atan2 >= 360.0f) {
+            atan2 -= 360.0f;
+        }
+        float f17 = (3.1415927f * atan2) / 180.0f;
+        float pow4 = ((float) Math.pow((f16 * viewingConditions.getNbb()) / viewingConditions.getAw(), viewingConditions.getC() * viewingConditions.getZ())) * 100.0f;
+        float c = (4.0f / viewingConditions.getC()) * ((float) Math.sqrt(pow4 / 100.0f)) * (viewingConditions.getAw() + 4.0f) * viewingConditions.getFlRoot();
+        float sqrt = ((float) Math.sqrt(pow4 / 100.0d)) * ((float) Math.pow(1.64d - Math.pow(0.29d, viewingConditions.getN()), 0.73d)) * ((float) Math.pow((((((((float) (Math.cos((((((double) atan2) < 20.14d ? 360.0f + atan2 : atan2) * 3.141592653589793d) / 180.0d) + 2.0d) + 3.8d)) * 0.25f) * 3846.1538f) * viewingConditions.getNc()) * viewingConditions.getNcb()) * ((float) Math.sqrt((f12 * f12) + (f13 * f13)))) / (f15 + 0.305f), 0.9d));
+        float flRoot = viewingConditions.getFlRoot() * sqrt;
+        float sqrt2 = ((float) Math.sqrt((r7 * viewingConditions.getC()) / (viewingConditions.getAw() + 4.0f))) * 50.0f;
+        float f18 = (1.7f * pow4) / ((0.007f * pow4) + DE_MAX);
+        float log = ((float) Math.log((0.0228f * flRoot) + DE_MAX)) * 43.85965f;
+        double d2 = f17;
+        float cos = ((float) Math.cos(d2)) * log;
+        float sin = log * ((float) Math.sin(d2));
+        fArr2[0] = atan2;
+        fArr2[1] = sqrt;
+        if (fArr != null) {
+            fArr[0] = pow4;
+            fArr[1] = c;
+            fArr[2] = flRoot;
+            fArr[3] = sqrt2;
+            fArr[4] = f18;
+            fArr[5] = cos;
+            fArr[6] = sin;
+        }
+    }
+
+    @NonNull
+    private static CamColor fromJch(@FloatRange(from = 0.0d, to = 100.0d) float f, @FloatRange(from = 0.0d, to = Double.POSITIVE_INFINITY, toInclusive = false) float f2, @FloatRange(from = 0.0d, to = 360.0d) float f3) {
+        return fromJchInFrame(f, f2, f3, ViewingConditions.DEFAULT);
+    }
+
+    @NonNull
+    private static CamColor fromJchInFrame(@FloatRange(from = 0.0d, to = 100.0d) float f, @FloatRange(from = 0.0d, to = Double.POSITIVE_INFINITY, toInclusive = false) float f2, @FloatRange(from = 0.0d, to = 360.0d) float f3, ViewingConditions viewingConditions) {
+        float c = (4.0f / viewingConditions.getC()) * ((float) Math.sqrt(f / 100.0d)) * (viewingConditions.getAw() + 4.0f) * viewingConditions.getFlRoot();
+        float flRoot = f2 * viewingConditions.getFlRoot();
+        float sqrt = ((float) Math.sqrt(((f2 / ((float) Math.sqrt(r4))) * viewingConditions.getC()) / (viewingConditions.getAw() + 4.0f))) * 50.0f;
+        float f4 = (1.7f * f) / ((0.007f * f) + DE_MAX);
+        float log = ((float) Math.log((flRoot * 0.0228d) + 1.0d)) * 43.85965f;
+        double d = (3.1415927f * f3) / 180.0f;
+        return new CamColor(f3, f2, f, c, flRoot, sqrt, f4, log * ((float) Math.cos(d)), log * ((float) Math.sin(d)));
+    }
+
+    public float distance(@NonNull CamColor camColor) {
+        float jStar = getJStar() - camColor.getJStar();
+        float aStar = getAStar() - camColor.getAStar();
+        float bStar = getBStar() - camColor.getBStar();
+        return (float) (Math.pow(Math.sqrt((jStar * jStar) + (aStar * aStar) + (bStar * bStar)), 0.63d) * 1.41d);
+    }
+
+    @ColorInt
+    public int viewedInSrgb() {
+        return viewed(ViewingConditions.DEFAULT);
+    }
+
+    @ColorInt
+    public int viewed(@NonNull ViewingConditions viewingConditions) {
+        float pow = (float) Math.pow(((((double) getChroma()) == 0.0d || ((double) getJ()) == 0.0d) ? 0.0f : getChroma() / ((float) Math.sqrt(getJ() / 100.0d))) / Math.pow(1.64d - Math.pow(0.29d, viewingConditions.getN()), 0.73d), 1.1111111111111112d);
+        double hue = (getHue() * 3.1415927f) / 180.0f;
+        float cos = ((float) (Math.cos(2.0d + hue) + 3.8d)) * 0.25f;
+        float aw = viewingConditions.getAw() * ((float) Math.pow(getJ() / 100.0d, (1.0d / viewingConditions.getC()) / viewingConditions.getZ()));
+        float nc = cos * 3846.1538f * viewingConditions.getNc() * viewingConditions.getNcb();
+        float nbb = aw / viewingConditions.getNbb();
+        float sin = (float) Math.sin(hue);
+        float cos2 = (float) Math.cos(hue);
+        float f = (((0.305f + nbb) * 23.0f) * pow) / (((nc * 23.0f) + ((11.0f * pow) * cos2)) + ((pow * 108.0f) * sin));
+        float f2 = cos2 * f;
+        float f3 = f * sin;
+        float f4 = nbb * 460.0f;
+        float f5 = (((451.0f * f2) + f4) + (288.0f * f3)) / 1403.0f;
+        float f6 = ((f4 - (891.0f * f2)) - (261.0f * f3)) / 1403.0f;
+        float signum = Math.signum(f5) * (100.0f / viewingConditions.getFl()) * ((float) Math.pow((float) Math.max(0.0d, (Math.abs(f5) * 27.13d) / (400.0d - Math.abs(f5))), 2.380952380952381d));
+        float signum2 = Math.signum(f6) * (100.0f / viewingConditions.getFl()) * ((float) Math.pow((float) Math.max(0.0d, (Math.abs(f6) * 27.13d) / (400.0d - Math.abs(f6))), 2.380952380952381d));
+        float signum3 = Math.signum(((f4 - (f2 * 220.0f)) - (f3 * 6300.0f)) / 1403.0f) * (100.0f / viewingConditions.getFl()) * ((float) Math.pow((float) Math.max(0.0d, (Math.abs(r8) * 27.13d) / (400.0d - Math.abs(r8))), 2.380952380952381d));
+        float f7 = signum / viewingConditions.getRgbD()[0];
+        float f8 = signum2 / viewingConditions.getRgbD()[1];
+        float f9 = signum3 / viewingConditions.getRgbD()[2];
+        float[][] fArr = CamUtils.CAM16RGB_TO_XYZ;
+        float[] fArr2 = fArr[0];
+        float f10 = (fArr2[0] * f7) + (fArr2[1] * f8) + (fArr2[2] * f9);
+        float[] fArr3 = fArr[1];
+        float f11 = (fArr3[0] * f7) + (fArr3[1] * f8) + (fArr3[2] * f9);
+        float[] fArr4 = fArr[2];
+        return ColorUtils.XYZToColor(f10, f11, (f7 * fArr4[0]) + (f8 * fArr4[1]) + (f9 * fArr4[2]));
+    }
+
+    @ColorInt
+    public static int toColor(@FloatRange(from = 0.0d, to = 360.0d) float f, @FloatRange(from = 0.0d, to = Double.POSITIVE_INFINITY, toInclusive = false) float f2, @FloatRange(from = 0.0d, to = 100.0d) float f3, @NonNull ViewingConditions viewingConditions) {
+        if (f2 < 1.0d || Math.round(f3) <= 0.0d || Math.round(f3) >= 100.0d) {
+            return CamUtils.intFromLStar(f3);
+        }
+        float min = f < 0.0f ? 0.0f : Math.min(360.0f, f);
+        CamColor camColor = null;
+        boolean z = true;
+        float f4 = 0.0f;
+        float f5 = f2;
+        while (Math.abs(f4 - f2) >= CHROMA_SEARCH_ENDPOINT) {
+            CamColor findCamByJ = findCamByJ(min, f5, f3);
+            if (!z) {
+                if (findCamByJ == null) {
+                    f2 = f5;
+                } else {
+                    f4 = f5;
+                    camColor = findCamByJ;
+                }
+                f5 = ((f2 - f4) / 2.0f) + f4;
+            } else {
+                if (findCamByJ != null) {
+                    return findCamByJ.viewed(viewingConditions);
+                }
+                f5 = ((f2 - f4) / 2.0f) + f4;
+                z = false;
+            }
+        }
+        if (camColor == null) {
+            return CamUtils.intFromLStar(f3);
+        }
+        return camColor.viewed(viewingConditions);
+    }
+
+    @Nullable
+    private static CamColor findCamByJ(@FloatRange(from = 0.0d, to = 360.0d) float f, @FloatRange(from = 0.0d, to = Double.POSITIVE_INFINITY, toInclusive = false) float f2, @FloatRange(from = 0.0d, to = 100.0d) float f3) {
+        float f4 = 100.0f;
+        float f5 = 1000.0f;
+        float f6 = 0.0f;
+        CamColor camColor = null;
+        float f7 = 1000.0f;
+        while (Math.abs(f6 - f4) > LIGHTNESS_SEARCH_ENDPOINT) {
+            float f8 = ((f4 - f6) / 2.0f) + f6;
+            int viewedInSrgb = fromJch(f8, f2, f).viewedInSrgb();
+            float lStarFromInt = CamUtils.lStarFromInt(viewedInSrgb);
+            float abs = Math.abs(f3 - lStarFromInt);
+            if (abs < DL_MAX) {
+                CamColor fromColor = fromColor(viewedInSrgb);
+                float distance = fromColor.distance(fromJch(fromColor.getJ(), fromColor.getChroma(), f));
+                if (distance <= DE_MAX) {
+                    camColor = fromColor;
+                    f5 = abs;
+                    f7 = distance;
+                }
+            }
+            if (f5 == 0.0f && f7 == 0.0f) {
+                break;
+            }
+            if (lStarFromInt < f3) {
+                f6 = f8;
+            } else {
+                f4 = f8;
+            }
+        }
+        return camColor;
+    }
+}

decompiled/sources/androidx/core/content/res/CamUtils.java

@@ -0,0 +1,79 @@
+package androidx.core.content.res;
+
+import android.graphics.Color;
+import androidx.annotation.NonNull;
+import androidx.core.graphics.ColorUtils;
+import androidx.core.view.ViewCompat;
+
+/* loaded from: classes.dex */
+final class CamUtils {
+    static final float[][] XYZ_TO_CAM16RGB = {new float[]{0.401288f, 0.650173f, -0.051461f}, new float[]{-0.250268f, 1.204414f, 0.045854f}, new float[]{-0.002079f, 0.048952f, 0.953127f}};
+    static final float[][] CAM16RGB_TO_XYZ = {new float[]{1.8620678f, -1.0112547f, 0.14918678f}, new float[]{0.38752654f, 0.62144744f, -0.00897398f}, new float[]{-0.0158415f, -0.03412294f, 1.0499644f}};
+    static final float[] WHITE_POINT_D65 = {95.047f, 100.0f, 108.883f};
+    static final float[][] SRGB_TO_XYZ = {new float[]{0.41233894f, 0.35762063f, 0.18051042f}, new float[]{0.2126f, 0.7152f, 0.0722f}, new float[]{0.01932141f, 0.11916382f, 0.9503448f}};
+
+    public static float lerp(float f, float f2, float f3) {
+        return f + ((f2 - f) * f3);
+    }
+
+    private CamUtils() {
+    }
+
+    public static int intFromLStar(float f) {
+        if (f < 1.0f) {
+            return ViewCompat.MEASURED_STATE_MASK;
+        }
+        if (f > 99.0f) {
+            return -1;
+        }
+        float f2 = (f + 16.0f) / 116.0f;
+        float f3 = f > 8.0f ? f2 * f2 * f2 : f / 903.2963f;
+        float f4 = f2 * f2 * f2;
+        boolean z = f4 > 0.008856452f;
+        float f5 = z ? f4 : ((f2 * 116.0f) - 16.0f) / 903.2963f;
+        if (!z) {
+            f4 = ((f2 * 116.0f) - 16.0f) / 903.2963f;
+        }
+        float[] fArr = WHITE_POINT_D65;
+        return ColorUtils.XYZToColor(f5 * fArr[0], f3 * fArr[1], f4 * fArr[2]);
+    }
+
+    public static float lStarFromInt(int i) {
+        return lStarFromY(yFromInt(i));
+    }
+
+    public static float lStarFromY(float f) {
+        float f2 = f / 100.0f;
+        return f2 <= 0.008856452f ? f2 * 903.2963f : (((float) Math.cbrt(f2)) * 116.0f) - 16.0f;
+    }
+
+    public static float yFromInt(int i) {
+        float linearized = linearized(Color.red(i));
+        float linearized2 = linearized(Color.green(i));
+        float linearized3 = linearized(Color.blue(i));
+        float[] fArr = SRGB_TO_XYZ[1];
+        return (linearized * fArr[0]) + (linearized2 * fArr[1]) + (linearized3 * fArr[2]);
+    }
+
+    public static void xyzFromInt(int i, @NonNull float[] fArr) {
+        float linearized = linearized(Color.red(i));
+        float linearized2 = linearized(Color.green(i));
+        float linearized3 = linearized(Color.blue(i));
+        float[][] fArr2 = SRGB_TO_XYZ;
+        float[] fArr3 = fArr2[0];
+        fArr[0] = (fArr3[0] * linearized) + (fArr3[1] * linearized2) + (fArr3[2] * linearized3);
+        float[] fArr4 = fArr2[1];
+        fArr[1] = (fArr4[0] * linearized) + (fArr4[1] * linearized2) + (fArr4[2] * linearized3);
+        float[] fArr5 = fArr2[2];
+        fArr[2] = (linearized * fArr5[0]) + (linearized2 * fArr5[1]) + (linearized3 * fArr5[2]);
+    }
+
+    public static float yFromLStar(float f) {
+        return (f > 8.0f ? (float) Math.pow((f + 16.0d) / 116.0d, 3.0d) : f / 903.2963f) * 100.0f;
+    }
+
+    public static float linearized(int i) {
+        float f = i / 255.0f;
+        return (f <= 0.04045f ? f / 12.92f : (float) Math.pow((f + 0.055f) / 1.055f, 2.4000000953674316d)) * 100.0f;
+    }
+}

decompiled/sources/androidx/core/content/res/ColorStateListInflaterCompat.java

@@ -0,0 +1,177 @@
+package androidx.core.content.res;
+
+import android.content.res.ColorStateList;
+import android.content.res.Resources;
+import android.content.res.TypedArray;
+import android.graphics.Color;
+import android.os.Build;
+import android.util.AttributeSet;
+import android.util.Log;
+import android.util.StateSet;
+import android.util.TypedValue;
+import android.util.Xml;
+import androidx.annotation.ColorInt;
+import androidx.annotation.ColorRes;
+import androidx.annotation.FloatRange;
+import androidx.annotation.NonNull;
+import androidx.annotation.Nullable;
+import androidx.annotation.RestrictTo;
+import androidx.annotation.XmlRes;
+import androidx.core.R;
+import androidx.core.math.MathUtils;
+import androidx.core.view.ViewCompat;
+import java.io.IOException;
+import org.xmlpull.v1.XmlPullParser;
+import org.xmlpull.v1.XmlPullParserException;
+
+@RestrictTo({RestrictTo.Scope.LIBRARY_GROUP_PREFIX})
+/* loaded from: classes.dex */
+public final class ColorStateListInflaterCompat {
+    private static final ThreadLocal<TypedValue> sTempTypedValue = new ThreadLocal<>();
+
+    private ColorStateListInflaterCompat() {
+    }
+
+    @Nullable
+    public static ColorStateList inflate(@NonNull Resources resources, @XmlRes int i, @Nullable Resources.Theme theme) {
+        try {
+            return createFromXml(resources, resources.getXml(i), theme);
+        } catch (Exception e) {
+            Log.e("CSLCompat", "Failed to inflate ColorStateList.", e);
+            return null;
+        }
+    }
+
+    @NonNull
+    public static ColorStateList createFromXml(@NonNull Resources resources, @NonNull XmlPullParser xmlPullParser, @Nullable Resources.Theme theme) throws XmlPullParserException, IOException {
+        int next;
+        AttributeSet asAttributeSet = Xml.asAttributeSet(xmlPullParser);
+        do {
+            next = xmlPullParser.next();
+            if (next == 2) {
+                break;
+            }
+        } while (next != 1);
+        if (next != 2) {
+            throw new XmlPullParserException("No start tag found");
+        }
+        return createFromXmlInner(resources, xmlPullParser, asAttributeSet, theme);
+    }
+
+    @NonNull
+    public static ColorStateList createFromXmlInner(@NonNull Resources resources, @NonNull XmlPullParser xmlPullParser, @NonNull AttributeSet attributeSet, @Nullable Resources.Theme theme) throws XmlPullParserException, IOException {
+        String name = xmlPullParser.getName();
+        if (!name.equals("selector")) {
+            throw new XmlPullParserException(xmlPullParser.getPositionDescription() + ": invalid color state list tag " + name);
+        }
+        return inflate(resources, xmlPullParser, attributeSet, theme);
+    }
+
+    private static ColorStateList inflate(@NonNull Resources resources, @NonNull XmlPullParser xmlPullParser, @NonNull AttributeSet attributeSet, @Nullable Resources.Theme theme) throws XmlPullParserException, IOException {
+        int depth;
+        int color;
+        float f;
+        Resources resources2 = resources;
+        int i = 1;
+        int depth2 = xmlPullParser.getDepth() + 1;
+        int[][] iArr = new int[20][];
+        int[] iArr2 = new int[20];
+        int i2 = 0;
+        while (true) {
+            int next = xmlPullParser.next();
+            if (next == i || ((depth = xmlPullParser.getDepth()) < depth2 && next == 3)) {
+                break;
+            }
+            if (next == 2 && depth <= depth2 && xmlPullParser.getName().equals("item")) {
+                TypedArray obtainAttributes = obtainAttributes(resources2, theme, attributeSet, R.styleable.ColorStateListItem);
+                int resourceId = obtainAttributes.getResourceId(R.styleable.ColorStateListItem_android_color, -1);
+                if (resourceId != -1 && !isColorInt(resources2, resourceId)) {
+                    try {
+                        color = createFromXml(resources2, resources2.getXml(resourceId), theme).getDefaultColor();
+                    } catch (Exception unused) {
+                        color = obtainAttributes.getColor(R.styleable.ColorStateListItem_android_color, -65281);
+                    }
+                } else {
+                    color = obtainAttributes.getColor(R.styleable.ColorStateListItem_android_color, -65281);
+                }
+                float f2 = 1.0f;
+                if (obtainAttributes.hasValue(R.styleable.ColorStateListItem_android_alpha)) {
+                    f2 = obtainAttributes.getFloat(R.styleable.ColorStateListItem_android_alpha, 1.0f);
+                } else if (obtainAttributes.hasValue(R.styleable.ColorStateListItem_alpha)) {
+                    f2 = obtainAttributes.getFloat(R.styleable.ColorStateListItem_alpha, 1.0f);
+                }
+                if (Build.VERSION.SDK_INT >= 31 && obtainAttributes.hasValue(R.styleable.ColorStateListItem_android_lStar)) {
+                    f = obtainAttributes.getFloat(R.styleable.ColorStateListItem_android_lStar, -1.0f);
+                } else {
+                    f = obtainAttributes.getFloat(R.styleable.ColorStateListItem_lStar, -1.0f);
+                }
+                obtainAttributes.recycle();
+                int attributeCount = attributeSet.getAttributeCount();
+                int[] iArr3 = new int[attributeCount];
+                int i3 = 0;
+                for (int i4 = 0; i4 < attributeCount; i4++) {
+                    int attributeNameResource = attributeSet.getAttributeNameResource(i4);
+                    if (attributeNameResource != 16843173 && attributeNameResource != 16843551 && attributeNameResource != R.attr.alpha && attributeNameResource != R.attr.lStar) {
+                        int i5 = i3 + 1;
+                        if (!attributeSet.getAttributeBooleanValue(i4, false)) {
+                            attributeNameResource = -attributeNameResource;
+                        }
+                        iArr3[i3] = attributeNameResource;
+                        i3 = i5;
+                    }
+                }
+                int[] trimStateSet = StateSet.trimStateSet(iArr3, i3);
+                iArr2 = GrowingArrayUtils.append(iArr2, i2, modulateColorAlpha(color, f2, f));
+                iArr = (int[][]) GrowingArrayUtils.append(iArr, i2, trimStateSet);
+                i2++;
+            }
+            i = 1;
+            resources2 = resources;
+        }
+        int[] iArr4 = new int[i2];
+        int[][] iArr5 = new int[i2][];
+        System.arraycopy(iArr2, 0, iArr4, 0, i2);
+        System.arraycopy(iArr, 0, iArr5, 0, i2);
+        return new ColorStateList(iArr5, iArr4);
+    }
+
+    private static boolean isColorInt(@NonNull Resources resources, @ColorRes int i) {
+        TypedValue typedValue = getTypedValue();
+        resources.getValue(i, typedValue, true);
+        int i2 = typedValue.type;
+        return i2 >= 28 && i2 <= 31;
+    }
+
+    @NonNull
+    private static TypedValue getTypedValue() {
+        ThreadLocal<TypedValue> threadLocal = sTempTypedValue;
+        TypedValue typedValue = threadLocal.get();
+        if (typedValue != null) {
+            return typedValue;
+        }
+        TypedValue typedValue2 = new TypedValue();
+        threadLocal.set(typedValue2);
+        return typedValue2;
+    }
+
+    private static TypedArray obtainAttributes(Resources resources, Resources.Theme theme, AttributeSet attributeSet, int[] iArr) {
+        if (theme == null) {
+            return resources.obtainAttributes(attributeSet, iArr);
+        }
+        return theme.obtainStyledAttributes(attributeSet, iArr, 0, 0);
+    }
+
+    @ColorInt
+    private static int modulateColorAlpha(@ColorInt int i, @FloatRange(from = 0.0d, to = 1.0d) float f, @FloatRange(from = 0.0d, to = 100.0d) float f2) {
+        boolean z = f2 >= 0.0f && f2 <= 100.0f;
+        if (f == 1.0f && !z) {
+            return i;
+        }
+        int clamp = MathUtils.clamp((int) ((Color.alpha(i) * f) + 0.5f), 0, 255);
+        if (z) {
+            CamColor fromColor = CamColor.fromColor(i);
+            i = CamColor.toColor(fromColor.getHue(), fromColor.getChroma(), f2);
+        }
+        return (i & ViewCompat.MEASURED_SIZE_MASK) | (clamp << 24);
+    }
+}

decompiled/sources/androidx/core/content/res/ComplexColorCompat.java

@@ -0,0 +1,117 @@
+package androidx.core.content.res;
+
+import android.content.res.ColorStateList;
+import android.content.res.Resources;
+import android.content.res.XmlResourceParser;
+import android.graphics.Shader;
+import android.util.AttributeSet;
+import android.util.Log;
+import android.util.Xml;
+import androidx.annotation.ColorInt;
+import androidx.annotation.ColorRes;
+import androidx.annotation.NonNull;
+import androidx.annotation.Nullable;
+import androidx.annotation.RestrictTo;
+import java.io.IOException;
+import org.xmlpull.v1.XmlPullParserException;
+
+@RestrictTo({RestrictTo.Scope.LIBRARY_GROUP_PREFIX})
+/* loaded from: classes.dex */
+public final class ComplexColorCompat {
+    private static final String LOG_TAG = "ComplexColorCompat";
+    private int mColor;
+    private final ColorStateList mColorStateList;
+    private final Shader mShader;
+
+    @ColorInt
+    public int getColor() {
+        return this.mColor;
+    }
+
+    @Nullable
+    public Shader getShader() {
+        return this.mShader;
+    }
+
+    public boolean isGradient() {
+        return this.mShader != null;
+    }
+
+    public void setColor(@ColorInt int i) {
+        this.mColor = i;
+    }
+
+    private ComplexColorCompat(Shader shader, ColorStateList colorStateList, @ColorInt int i) {
+        this.mShader = shader;
+        this.mColorStateList = colorStateList;
+        this.mColor = i;
+    }
+
+    public static ComplexColorCompat from(@NonNull Shader shader) {
+        return new ComplexColorCompat(shader, null, 0);
+    }
+
+    public static ComplexColorCompat from(@NonNull ColorStateList colorStateList) {
+        return new ComplexColorCompat(null, colorStateList, colorStateList.getDefaultColor());
+    }
+
+    public static ComplexColorCompat from(@ColorInt int i) {
+        return new ComplexColorCompat(null, null, i);
+    }
+
+    public boolean isStateful() {
+        ColorStateList colorStateList;
+        return this.mShader == null && (colorStateList = this.mColorStateList) != null && colorStateList.isStateful();
+    }
+
+    public boolean onStateChanged(int[] iArr) {
+        if (isStateful()) {
+            ColorStateList colorStateList = this.mColorStateList;
+            int colorForState = colorStateList.getColorForState(iArr, colorStateList.getDefaultColor());
+            if (colorForState != this.mColor) {
+                this.mColor = colorForState;
+                return true;
+            }
+        }
+        return false;
+    }
+
+    public boolean willDraw() {
+        return isGradient() || this.mColor != 0;
+    }
+
+    @Nullable
+    public static ComplexColorCompat inflate(@NonNull Resources resources, @ColorRes int i, @Nullable Resources.Theme theme) {
+        try {
+            return createFromXml(resources, i, theme);
+        } catch (Exception e) {
+            Log.e(LOG_TAG, "Failed to inflate ComplexColor.", e);
+            return null;
+        }
+    }
+
+    @NonNull
+    private static ComplexColorCompat createFromXml(@NonNull Resources resources, @ColorRes int i, @Nullable Resources.Theme theme) throws IOException, XmlPullParserException {
+        int next;
+        XmlResourceParser xml = resources.getXml(i);
+        AttributeSet asAttributeSet = Xml.asAttributeSet(xml);
+        do {
+            next = xml.next();
+            if (next == 2) {
+                break;
+            }
+        } while (next != 1);
+        if (next != 2) {
+            throw new XmlPullParserException("No start tag found");
+        }
+        String name = xml.getName();
+        name.hashCode();
+        if (name.equals("gradient")) {
+            return from(GradientColorInflaterCompat.createFromXmlInner(resources, xml, asAttributeSet, theme));
+        }
+        if (name.equals("selector")) {
+            return from(ColorStateListInflaterCompat.createFromXmlInner(resources, xml, asAttributeSet, theme));
+        }
+        throw new XmlPullParserException(xml.getPositionDescription() + ": unsupported complex color tag " + name);
+    }
+}

decompiled/sources/androidx/core/content/res/ConfigurationHelper.java

@@ -0,0 +1,14 @@
+package androidx.core.content.res;
+
+import android.content.res.Resources;
+import androidx.annotation.NonNull;
+
+/* loaded from: classes.dex */
+public final class ConfigurationHelper {
+    private ConfigurationHelper() {
+    }
+
+    public static int getDensityDpi(@NonNull Resources resources) {
+        return resources.getConfiguration().densityDpi;
+    }
+}

decompiled/sources/androidx/core/content/res/FontResourcesParserCompat.java

@@ -0,0 +1,320 @@
+package androidx.core.content.res;
+
+import android.content.res.Resources;
+import android.content.res.TypedArray;
+import android.util.Base64;
+import android.util.Xml;
+import androidx.annotation.ArrayRes;
+import androidx.annotation.NonNull;
+import androidx.annotation.Nullable;
+import androidx.annotation.RequiresApi;
+import androidx.annotation.RestrictTo;
+import androidx.core.R;
+import androidx.core.provider.FontRequest;
+import java.io.IOException;
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.List;
+import org.xmlpull.v1.XmlPullParser;
+import org.xmlpull.v1.XmlPullParserException;
+
+@RestrictTo({RestrictTo.Scope.LIBRARY_GROUP_PREFIX})
+/* loaded from: classes.dex */
+public class FontResourcesParserCompat {
+    private static final int DEFAULT_TIMEOUT_MILLIS = 500;
+    public static final int FETCH_STRATEGY_ASYNC = 1;
+    public static final int FETCH_STRATEGY_BLOCKING = 0;
+    public static final int INFINITE_TIMEOUT_VALUE = -1;
+    private static final int ITALIC = 1;
+    private static final int NORMAL_WEIGHT = 400;
+
+    public interface FamilyResourceEntry {
+    }
+
+    @Retention(RetentionPolicy.SOURCE)
+    public @interface FetchStrategy {
+    }
+
+    public static final class ProviderResourceEntry implements FamilyResourceEntry {
+
+        @Nullable
+        private final FontRequest mFallbackRequest;
+
+        @NonNull
+        private final FontRequest mRequest;
+        private final int mStrategy;
+
+        @Nullable
+        private final String mSystemFontFamilyName;
+        private final int mTimeoutMs;
+
+        @Nullable
+        public FontRequest getFallbackRequest() {
+            return this.mFallbackRequest;
+        }
+
+        public int getFetchStrategy() {
+            return this.mStrategy;
+        }
+
+        @NonNull
+        public FontRequest getRequest() {
+            return this.mRequest;
+        }
+
+        @Nullable
+        @RestrictTo({RestrictTo.Scope.LIBRARY})
+        public String getSystemFontFamilyName() {
+            return this.mSystemFontFamilyName;
+        }
+
+        public int getTimeout() {
+            return this.mTimeoutMs;
+        }
+
+        @RestrictTo({RestrictTo.Scope.LIBRARY})
+        public ProviderResourceEntry(@NonNull FontRequest fontRequest, @Nullable FontRequest fontRequest2, int i, int i2, @Nullable String str) {
+            this.mRequest = fontRequest;
+            this.mFallbackRequest = fontRequest2;
+            this.mStrategy = i;
+            this.mTimeoutMs = i2;
+            this.mSystemFontFamilyName = str;
+        }
+
+        public ProviderResourceEntry(@NonNull FontRequest fontRequest, int i, int i2) {
+            this(fontRequest, null, i, i2, null);
+        }
+    }
+
+    public static final class FontFileResourceEntry {
+
+        @NonNull
+        private final String mFileName;
+        private final boolean mItalic;
+        private final int mResourceId;
+        private final int mTtcIndex;
+        private final String mVariationSettings;
+        private final int mWeight;
+
+        @NonNull
+        public String getFileName() {
+            return this.mFileName;
+        }
+
+        public int getResourceId() {
+            return this.mResourceId;
+        }
+
+        public int getTtcIndex() {
+            return this.mTtcIndex;
+        }
+
+        @Nullable
+        public String getVariationSettings() {
+            return this.mVariationSettings;
+        }
+
+        public int getWeight() {
+            return this.mWeight;
+        }
+
+        public boolean isItalic() {
+            return this.mItalic;
+        }
+
+        public FontFileResourceEntry(@NonNull String str, int i, boolean z, @Nullable String str2, int i2, int i3) {
+            this.mFileName = str;
+            this.mWeight = i;
+            this.mItalic = z;
+            this.mVariationSettings = str2;
+            this.mTtcIndex = i2;
+            this.mResourceId = i3;
+        }
+    }
+
+    public static final class FontFamilyFilesResourceEntry implements FamilyResourceEntry {
+
+        @NonNull
+        private final FontFileResourceEntry[] mEntries;
+
+        @NonNull
+        public FontFileResourceEntry[] getEntries() {
+            return this.mEntries;
+        }
+
+        public FontFamilyFilesResourceEntry(@NonNull FontFileResourceEntry[] fontFileResourceEntryArr) {
+            this.mEntries = fontFileResourceEntryArr;
+        }
+    }
+
+    @Nullable
+    public static FamilyResourceEntry parse(@NonNull XmlPullParser xmlPullParser, @NonNull Resources resources) throws XmlPullParserException, IOException {
+        int next;
+        do {
+            next = xmlPullParser.next();
+            if (next == 2) {
+                break;
+            }
+        } while (next != 1);
+        if (next != 2) {
+            throw new XmlPullParserException("No start tag found");
+        }
+        return readFamilies(xmlPullParser, resources);
+    }
+
+    @Nullable
+    private static FamilyResourceEntry readFamilies(XmlPullParser xmlPullParser, Resources resources) throws XmlPullParserException, IOException {
+        xmlPullParser.require(2, null, "font-family");
+        if (xmlPullParser.getName().equals("font-family")) {
+            return readFamily(xmlPullParser, resources);
+        }
+        skip(xmlPullParser);
+        return null;
+    }
+
+    @Nullable
+    private static FamilyResourceEntry readFamily(XmlPullParser xmlPullParser, Resources resources) throws XmlPullParserException, IOException {
+        TypedArray obtainAttributes = resources.obtainAttributes(Xml.asAttributeSet(xmlPullParser), R.styleable.FontFamily);
+        String string = obtainAttributes.getString(R.styleable.FontFamily_fontProviderAuthority);
+        String string2 = obtainAttributes.getString(R.styleable.FontFamily_fontProviderPackage);
+        String string3 = obtainAttributes.getString(R.styleable.FontFamily_fontProviderQuery);
+        String string4 = obtainAttributes.getString(R.styleable.FontFamily_fontProviderFallbackQuery);
+        int resourceId = obtainAttributes.getResourceId(R.styleable.FontFamily_fontProviderCerts, 0);
+        int integer = obtainAttributes.getInteger(R.styleable.FontFamily_fontProviderFetchStrategy, 1);
+        int integer2 = obtainAttributes.getInteger(R.styleable.FontFamily_fontProviderFetchTimeout, 500);
+        String string5 = obtainAttributes.getString(R.styleable.FontFamily_fontProviderSystemFontFamily);
+        obtainAttributes.recycle();
+        if (string != null && string2 != null && string3 != null) {
+            while (xmlPullParser.next() != 3) {
+                skip(xmlPullParser);
+            }
+            List<List<byte[]>> readCerts = readCerts(resources, resourceId);
+            return new ProviderResourceEntry(new FontRequest(string, string2, string3, readCerts), string4 != null ? new FontRequest(string, string2, string4, readCerts) : null, integer, integer2, string5);
+        }
+        ArrayList arrayList = new ArrayList();
+        while (xmlPullParser.next() != 3) {
+            if (xmlPullParser.getEventType() == 2) {
+                if (xmlPullParser.getName().equals("font")) {
+                    arrayList.add(readFont(xmlPullParser, resources));
+                } else {
+                    skip(xmlPullParser);
+                }
+            }
+        }
+        if (arrayList.isEmpty()) {
+            return null;
+        }
+        return new FontFamilyFilesResourceEntry((FontFileResourceEntry[]) arrayList.toArray(new FontFileResourceEntry[0]));
+    }
+
+    private static int getType(TypedArray typedArray, int i) {
+        return Api21Impl.getType(typedArray, i);
+    }
+
+    @NonNull
+    public static List<List<byte[]>> readCerts(@NonNull Resources resources, @ArrayRes int i) {
+        if (i == 0) {
+            return Collections.emptyList();
+        }
+        TypedArray obtainTypedArray = resources.obtainTypedArray(i);
+        try {
+            if (obtainTypedArray.length() == 0) {
+                return Collections.emptyList();
+            }
+            ArrayList arrayList = new ArrayList();
+            if (getType(obtainTypedArray, 0) == 1) {
+                for (int i2 = 0; i2 < obtainTypedArray.length(); i2++) {
+                    int resourceId = obtainTypedArray.getResourceId(i2, 0);
+                    if (resourceId != 0) {
+                        arrayList.add(toByteArrayList(resources.getStringArray(resourceId)));
+                    }
+                }
+            } else {
+                arrayList.add(toByteArrayList(resources.getStringArray(i)));
+            }
+            return arrayList;
+        } finally {
+            obtainTypedArray.recycle();
+        }
+    }
+
+    private static List<byte[]> toByteArrayList(String[] strArr) {
+        ArrayList arrayList = new ArrayList();
+        for (String str : strArr) {
+            arrayList.add(Base64.decode(str, 0));
+        }
+        return arrayList;
+    }
+
+    private static FontFileResourceEntry readFont(XmlPullParser xmlPullParser, Resources resources) throws XmlPullParserException, IOException {
+        int i;
+        int i2;
+        int i3;
+        int i4;
+        int i5;
+        TypedArray obtainAttributes = resources.obtainAttributes(Xml.asAttributeSet(xmlPullParser), R.styleable.FontFamilyFont);
+        if (obtainAttributes.hasValue(R.styleable.FontFamilyFont_fontWeight)) {
+            i = R.styleable.FontFamilyFont_fontWeight;
+        } else {
+            i = R.styleable.FontFamilyFont_android_fontWeight;
+        }
+        int i6 = obtainAttributes.getInt(i, 400);
+        if (obtainAttributes.hasValue(R.styleable.FontFamilyFont_fontStyle)) {
+            i2 = R.styleable.FontFamilyFont_fontStyle;
+        } else {
+            i2 = R.styleable.FontFamilyFont_android_fontStyle;
+        }
+        boolean z = 1 == obtainAttributes.getInt(i2, 0);
+        if (obtainAttributes.hasValue(R.styleable.FontFamilyFont_ttcIndex)) {
+            i3 = R.styleable.FontFamilyFont_ttcIndex;
+        } else {
+            i3 = R.styleable.FontFamilyFont_android_ttcIndex;
+        }
+        if (obtainAttributes.hasValue(R.styleable.FontFamilyFont_fontVariationSettings)) {
+            i4 = R.styleable.FontFamilyFont_fontVariationSettings;
+        } else {
+            i4 = R.styleable.FontFamilyFont_android_fontVariationSettings;
+        }
+        String string = obtainAttributes.getString(i4);
+        int i7 = obtainAttributes.getInt(i3, 0);
+        if (obtainAttributes.hasValue(R.styleable.FontFamilyFont_font)) {
+            i5 = R.styleable.FontFamilyFont_font;
+        } else {
+            i5 = R.styleable.FontFamilyFont_android_font;
+        }
+        int resourceId = obtainAttributes.getResourceId(i5, 0);
+        String string2 = obtainAttributes.getString(i5);
+        obtainAttributes.recycle();
+        while (xmlPullParser.next() != 3) {
+            skip(xmlPullParser);
+        }
+        return new FontFileResourceEntry(string2, i6, z, string, i7, resourceId);
+    }
+
+    private static void skip(XmlPullParser xmlPullParser) throws XmlPullParserException, IOException {
+        int i = 1;
+        while (i > 0) {
+            int next = xmlPullParser.next();
+            if (next == 2) {
+                i++;
+            } else if (next == 3) {
+                i--;
+            }
+        }
+    }
+
+    private FontResourcesParserCompat() {
+    }
+
+    @RequiresApi(21)
+    public static class Api21Impl {
+        private Api21Impl() {
+        }
+
+        public static int getType(TypedArray typedArray, int i) {
+            return typedArray.getType(i);
+        }
+    }
+}

decompiled/sources/androidx/core/content/res/GradientColorInflaterCompat.java

@@ -0,0 +1,204 @@
+package androidx.core.content.res;
+
+import android.content.res.Resources;
+import android.content.res.TypedArray;
+import android.graphics.LinearGradient;
+import android.graphics.RadialGradient;
+import android.graphics.Shader;
+import android.graphics.SweepGradient;
+import android.util.AttributeSet;
+import android.util.Xml;
+import androidx.annotation.ColorInt;
+import androidx.annotation.NonNull;
+import androidx.annotation.Nullable;
+import androidx.annotation.RestrictTo;
+import androidx.core.R;
+import java.io.IOException;
+import java.util.List;
+import org.xmlpull.v1.XmlPullParser;
+import org.xmlpull.v1.XmlPullParserException;
+
+@RestrictTo({RestrictTo.Scope.LIBRARY_GROUP_PREFIX})
+/* loaded from: classes.dex */
+final class GradientColorInflaterCompat {
+    private static final int TILE_MODE_CLAMP = 0;
+    private static final int TILE_MODE_MIRROR = 2;
+    private static final int TILE_MODE_REPEAT = 1;
+
+    private GradientColorInflaterCompat() {
+    }
+
+    public static Shader createFromXml(@NonNull Resources resources, @NonNull XmlPullParser xmlPullParser, @Nullable Resources.Theme theme) throws XmlPullParserException, IOException {
+        int next;
+        AttributeSet asAttributeSet = Xml.asAttributeSet(xmlPullParser);
+        do {
+            next = xmlPullParser.next();
+            if (next == 2) {
+                break;
+            }
+        } while (next != 1);
+        if (next != 2) {
+            throw new XmlPullParserException("No start tag found");
+        }
+        return createFromXmlInner(resources, xmlPullParser, asAttributeSet, theme);
+    }
+
+    public static Shader createFromXmlInner(@NonNull Resources resources, @NonNull XmlPullParser xmlPullParser, @NonNull AttributeSet attributeSet, @Nullable Resources.Theme theme) throws IOException, XmlPullParserException {
+        String name = xmlPullParser.getName();
+        if (!name.equals("gradient")) {
+            throw new XmlPullParserException(xmlPullParser.getPositionDescription() + ": invalid gradient color tag " + name);
+        }
+        TypedArray obtainAttributes = TypedArrayUtils.obtainAttributes(resources, theme, attributeSet, R.styleable.GradientColor);
+        float namedFloat = TypedArrayUtils.getNamedFloat(obtainAttributes, xmlPullParser, "startX", R.styleable.GradientColor_android_startX, 0.0f);
+        float namedFloat2 = TypedArrayUtils.getNamedFloat(obtainAttributes, xmlPullParser, "startY", R.styleable.GradientColor_android_startY, 0.0f);
+        float namedFloat3 = TypedArrayUtils.getNamedFloat(obtainAttributes, xmlPullParser, "endX", R.styleable.GradientColor_android_endX, 0.0f);
+        float namedFloat4 = TypedArrayUtils.getNamedFloat(obtainAttributes, xmlPullParser, "endY", R.styleable.GradientColor_android_endY, 0.0f);
+        float namedFloat5 = TypedArrayUtils.getNamedFloat(obtainAttributes, xmlPullParser, "centerX", R.styleable.GradientColor_android_centerX, 0.0f);
+        float namedFloat6 = TypedArrayUtils.getNamedFloat(obtainAttributes, xmlPullParser, "centerY", R.styleable.GradientColor_android_centerY, 0.0f);
+        int namedInt = TypedArrayUtils.getNamedInt(obtainAttributes, xmlPullParser, "type", R.styleable.GradientColor_android_type, 0);
+        int namedColor = TypedArrayUtils.getNamedColor(obtainAttributes, xmlPullParser, "startColor", R.styleable.GradientColor_android_startColor, 0);
+        boolean hasAttribute = TypedArrayUtils.hasAttribute(xmlPullParser, "centerColor");
+        int namedColor2 = TypedArrayUtils.getNamedColor(obtainAttributes, xmlPullParser, "centerColor", R.styleable.GradientColor_android_centerColor, 0);
+        int namedColor3 = TypedArrayUtils.getNamedColor(obtainAttributes, xmlPullParser, "endColor", R.styleable.GradientColor_android_endColor, 0);
+        int namedInt2 = TypedArrayUtils.getNamedInt(obtainAttributes, xmlPullParser, "tileMode", R.styleable.GradientColor_android_tileMode, 0);
+        float namedFloat7 = TypedArrayUtils.getNamedFloat(obtainAttributes, xmlPullParser, "gradientRadius", R.styleable.GradientColor_android_gradientRadius, 0.0f);
+        obtainAttributes.recycle();
+        ColorStops checkColors = checkColors(inflateChildElements(resources, xmlPullParser, attributeSet, theme), namedColor, namedColor3, hasAttribute, namedColor2);
+        if (namedInt != 1) {
+            if (namedInt == 2) {
+                return new SweepGradient(namedFloat5, namedFloat6, checkColors.mColors, checkColors.mOffsets);
+            }
+            return new LinearGradient(namedFloat, namedFloat2, namedFloat3, namedFloat4, checkColors.mColors, checkColors.mOffsets, parseTileMode(namedInt2));
+        }
+        if (namedFloat7 <= 0.0f) {
+            throw new XmlPullParserException("<gradient> tag requires 'gradientRadius' attribute with radial type");
+        }
+        return new RadialGradient(namedFloat5, namedFloat6, namedFloat7, checkColors.mColors, checkColors.mOffsets, parseTileMode(namedInt2));
+    }
+
+    /* JADX WARN: Code restructure failed: missing block: B:31:0x0084, code lost:
+    
+        throw new org.xmlpull.v1.XmlPullParserException(r9.getPositionDescription() + ": <item> tag requires a 'color' attribute and a 'offset' attribute!");
+     */
+    /*
+        Code decompiled incorrectly, please refer to instructions dump.
+        To view partially-correct add '--show-bad-code' argument
+    */
+    private static androidx.core.content.res.GradientColorInflaterCompat.ColorStops inflateChildElements(@androidx.annotation.NonNull android.content.res.Resources r8, @androidx.annotation.NonNull org.xmlpull.v1.XmlPullParser r9, @androidx.annotation.NonNull android.util.AttributeSet r10, @androidx.annotation.Nullable android.content.res.Resources.Theme r11) throws org.xmlpull.v1.XmlPullParserException, java.io.IOException {
+        /*
+            int r0 = r9.getDepth()
+            r1 = 1
+            int r0 = r0 + r1
+            java.util.ArrayList r2 = new java.util.ArrayList
+            r3 = 20
+            r2.<init>(r3)
+            java.util.ArrayList r4 = new java.util.ArrayList
+            r4.<init>(r3)
+        L12:
+            int r3 = r9.next()
+            if (r3 == r1) goto L85
+            int r5 = r9.getDepth()
+            if (r5 >= r0) goto L21
+            r6 = 3
+            if (r3 == r6) goto L85
+        L21:
+            r6 = 2
+            if (r3 == r6) goto L25
+            goto L12
+        L25:
+            if (r5 > r0) goto L12
+            java.lang.String r3 = r9.getName()
+            java.lang.String r5 = "item"
+            boolean r3 = r3.equals(r5)
+            if (r3 != 0) goto L34
+            goto L12
+        L34:
+            int[] r3 = androidx.core.R.styleable.GradientColorItem
+            android.content.res.TypedArray r3 = androidx.core.content.res.TypedArrayUtils.obtainAttributes(r8, r11, r10, r3)
+            int r5 = androidx.core.R.styleable.GradientColorItem_android_color
+            boolean r5 = r3.hasValue(r5)
+            int r6 = androidx.core.R.styleable.GradientColorItem_android_offset
+            boolean r6 = r3.hasValue(r6)
+            if (r5 == 0) goto L6a
+            if (r6 == 0) goto L6a
+            int r5 = androidx.core.R.styleable.GradientColorItem_android_color
+            r6 = 0
+            int r5 = r3.getColor(r5, r6)
+            int r6 = androidx.core.R.styleable.GradientColorItem_android_offset
+            r7 = 0
+            float r6 = r3.getFloat(r6, r7)
+            r3.recycle()
+            java.lang.Integer r3 = java.lang.Integer.valueOf(r5)
+            r4.add(r3)
+            java.lang.Float r3 = java.lang.Float.valueOf(r6)
+            r2.add(r3)
+            goto L12
+        L6a:
+            org.xmlpull.v1.XmlPullParserException r8 = new org.xmlpull.v1.XmlPullParserException
+            java.lang.StringBuilder r10 = new java.lang.StringBuilder
+            r10.<init>()
+            java.lang.String r9 = r9.getPositionDescription()
+            r10.append(r9)
+            java.lang.String r9 = ": <item> tag requires a 'color' attribute and a 'offset' attribute!"
+            r10.append(r9)
+            java.lang.String r9 = r10.toString()
+            r8.<init>(r9)
+            throw r8
+        L85:
+            int r8 = r4.size()
+            if (r8 <= 0) goto L91
+            androidx.core.content.res.GradientColorInflaterCompat$ColorStops r8 = new androidx.core.content.res.GradientColorInflaterCompat$ColorStops
+            r8.<init>(r4, r2)
+            return r8
+        L91:
+            r8 = 0
+            return r8
+        */
+        throw new UnsupportedOperationException("Method not decompiled: androidx.core.content.res.GradientColorInflaterCompat.inflateChildElements(android.content.res.Resources, org.xmlpull.v1.XmlPullParser, android.util.AttributeSet, android.content.res.Resources$Theme):androidx.core.content.res.GradientColorInflaterCompat$ColorStops");
+    }
+
+    private static ColorStops checkColors(@Nullable ColorStops colorStops, @ColorInt int i, @ColorInt int i2, boolean z, @ColorInt int i3) {
+        if (colorStops != null) {
+            return colorStops;
+        }
+        if (z) {
+            return new ColorStops(i, i3, i2);
+        }
+        return new ColorStops(i, i2);
+    }
+
+    private static Shader.TileMode parseTileMode(int i) {
+        if (i == 1) {
+            return Shader.TileMode.REPEAT;
+        }
+        if (i == 2) {
+            return Shader.TileMode.MIRROR;
+        }
+        return Shader.TileMode.CLAMP;
+    }
+
+    public static final class ColorStops {
+        final int[] mColors;
+        final float[] mOffsets;
+
+        public ColorStops(@NonNull List<Integer> list, @NonNull List<Float> list2) {
+            int size = list.size();
+            this.mColors = new int[size];
+            this.mOffsets = new float[size];
+            for (int i = 0; i < size; i++) {
+                this.mColors[i] = list.get(i).intValue();
+                this.mOffsets[i] = list2.get(i).floatValue();
+            }
+        }
+
+        public ColorStops(@ColorInt int i, @ColorInt int i2) {
+            this.mColors = new int[]{i, i2};
+            this.mOffsets = new float[]{0.0f, 1.0f};
+        }
+
+        public ColorStops(@ColorInt int i, @ColorInt int i2, @ColorInt int i3) {
+            this.mColors = new int[]{i, i2, i3};
+            this.mOffsets = new float[]{0.0f, 0.5f, 1.0f};
+        }
+    }
+}

decompiled/sources/androidx/core/content/res/GrowingArrayUtils.java

@@ -0,0 +1,110 @@
+package androidx.core.content.res;
+
+import java.lang.reflect.Array;
+
+/* loaded from: classes.dex */
+final class GrowingArrayUtils {
+    public static int growSize(int i) {
+        if (i <= 4) {
+            return 8;
+        }
+        return i * 2;
+    }
+
+    /* JADX WARN: Multi-variable type inference failed */
+    /* JADX WARN: Type inference failed for: r0v4, types: [java.lang.Object, java.lang.Object[]] */
+    public static <T> T[] append(T[] tArr, int i, T t) {
+        if (i + 1 > tArr.length) {
+            ?? r0 = (Object[]) Array.newInstance(tArr.getClass().getComponentType(), growSize(i));
+            System.arraycopy(tArr, 0, r0, 0, i);
+            tArr = r0;
+        }
+        tArr[i] = t;
+        return tArr;
+    }
+
+    public static int[] append(int[] iArr, int i, int i2) {
+        if (i + 1 > iArr.length) {
+            int[] iArr2 = new int[growSize(i)];
+            System.arraycopy(iArr, 0, iArr2, 0, i);
+            iArr = iArr2;
+        }
+        iArr[i] = i2;
+        return iArr;
+    }
+
+    public static long[] append(long[] jArr, int i, long j) {
+        if (i + 1 > jArr.length) {
+            long[] jArr2 = new long[growSize(i)];
+            System.arraycopy(jArr, 0, jArr2, 0, i);
+            jArr = jArr2;
+        }
+        jArr[i] = j;
+        return jArr;
+    }
+
+    public static boolean[] append(boolean[] zArr, int i, boolean z) {
+        if (i + 1 > zArr.length) {
+            boolean[] zArr2 = new boolean[growSize(i)];
+            System.arraycopy(zArr, 0, zArr2, 0, i);
+            zArr = zArr2;
+        }
+        zArr[i] = z;
+        return zArr;
+    }
+
+    public static <T> T[] insert(T[] tArr, int i, int i2, T t) {
+        if (i + 1 <= tArr.length) {
+            System.arraycopy(tArr, i2, tArr, i2 + 1, i - i2);
+            tArr[i2] = t;
+            return tArr;
+        }
+        T[] tArr2 = (T[]) ((Object[]) Array.newInstance(tArr.getClass().getComponentType(), growSize(i)));
+        System.arraycopy(tArr, 0, tArr2, 0, i2);
+        tArr2[i2] = t;
+        System.arraycopy(tArr, i2, tArr2, i2 + 1, tArr.length - i2);
+        return tArr2;
+    }
+
+    public static int[] insert(int[] iArr, int i, int i2, int i3) {
+        if (i + 1 <= iArr.length) {
+            System.arraycopy(iArr, i2, iArr, i2 + 1, i - i2);
+            iArr[i2] = i3;
+            return iArr;
+        }
+        int[] iArr2 = new int[growSize(i)];
+        System.arraycopy(iArr, 0, iArr2, 0, i2);
+        iArr2[i2] = i3;
+        System.arraycopy(iArr, i2, iArr2, i2 + 1, iArr.length - i2);
+        return iArr2;
+    }
+
+    public static long[] insert(long[] jArr, int i, int i2, long j) {
+        if (i + 1 <= jArr.length) {
+            System.arraycopy(jArr, i2, jArr, i2 + 1, i - i2);
+            jArr[i2] = j;
+            return jArr;
+        }
+        long[] jArr2 = new long[growSize(i)];
+        System.arraycopy(jArr, 0, jArr2, 0, i2);
+        jArr2[i2] = j;
+        System.arraycopy(jArr, i2, jArr2, i2 + 1, jArr.length - i2);
+        return jArr2;
+    }
+
+    public static boolean[] insert(boolean[] zArr, int i, int i2, boolean z) {
+        if (i + 1 <= zArr.length) {
+            System.arraycopy(zArr, i2, zArr, i2 + 1, i - i2);
+            zArr[i2] = z;
+            return zArr;
+        }
+        boolean[] zArr2 = new boolean[growSize(i)];
+        System.arraycopy(zArr, 0, zArr2, 0, i2);
+        zArr2[i2] = z;
+        System.arraycopy(zArr, i2, zArr2, i2 + 1, zArr.length - i2);
+        return zArr2;
+    }
+
+    private GrowingArrayUtils() {
+    }
+}

decompiled/sources/androidx/core/content/res/ResourcesCompat.java

@@ -0,0 +1,436 @@
+package androidx.core.content.res;
+
+import android.annotation.SuppressLint;
+import android.content.Context;
+import android.content.res.ColorStateList;
+import android.content.res.Configuration;
+import android.content.res.Resources;
+import android.graphics.Typeface;
+import android.graphics.drawable.Drawable;
+import android.os.Build;
+import android.os.Handler;
+import android.os.Looper;
+import android.util.Log;
+import android.util.SparseArray;
+import android.util.TypedValue;
+import androidx.annotation.AnyRes;
+import androidx.annotation.ColorInt;
+import androidx.annotation.ColorRes;
+import androidx.annotation.DimenRes;
+import androidx.annotation.DrawableRes;
+import androidx.annotation.FontRes;
+import androidx.annotation.GuardedBy;
+import androidx.annotation.NonNull;
+import androidx.annotation.Nullable;
+import androidx.annotation.RequiresApi;
+import androidx.annotation.RestrictTo;
+import androidx.core.content.res.ResourcesCompat;
+import androidx.core.util.ObjectsCompat;
+import androidx.core.util.Preconditions;
+import java.lang.reflect.InvocationTargetException;
+import java.lang.reflect.Method;
+import java.util.Iterator;
+import java.util.WeakHashMap;
+
+/* loaded from: classes.dex */
+public final class ResourcesCompat {
+
+    @AnyRes
+    public static final int ID_NULL = 0;
+    private static final String TAG = "ResourcesCompat";
+    private static final ThreadLocal<TypedValue> sTempTypedValue = new ThreadLocal<>();
+
+    @GuardedBy("sColorStateCacheLock")
+    private static final WeakHashMap<ColorStateListCacheKey, SparseArray<ColorStateListCacheEntry>> sColorStateCaches = new WeakHashMap<>(0);
+    private static final Object sColorStateCacheLock = new Object();
+
+    public static void clearCachesForTheme(@NonNull Resources.Theme theme) {
+        synchronized (sColorStateCacheLock) {
+            try {
+                Iterator<ColorStateListCacheKey> it = sColorStateCaches.keySet().iterator();
+                while (it.hasNext()) {
+                    ColorStateListCacheKey next = it.next();
+                    if (next != null && theme.equals(next.mTheme)) {
+                        it.remove();
+                    }
+                }
+            } catch (Throwable th) {
+                throw th;
+            }
+        }
+    }
+
+    @Nullable
+    public static Drawable getDrawable(@NonNull Resources resources, @DrawableRes int i, @Nullable Resources.Theme theme) throws Resources.NotFoundException {
+        return Api21Impl.getDrawable(resources, i, theme);
+    }
+
+    @Nullable
+    public static Drawable getDrawableForDensity(@NonNull Resources resources, @DrawableRes int i, int i2, @Nullable Resources.Theme theme) throws Resources.NotFoundException {
+        return Api21Impl.getDrawableForDensity(resources, i, i2, theme);
+    }
+
+    @ColorInt
+    public static int getColor(@NonNull Resources resources, @ColorRes int i, @Nullable Resources.Theme theme) throws Resources.NotFoundException {
+        return Api23Impl.getColor(resources, i, theme);
+    }
+
+    @Nullable
+    public static ColorStateList getColorStateList(@NonNull Resources resources, @ColorRes int i, @Nullable Resources.Theme theme) throws Resources.NotFoundException {
+        ColorStateListCacheKey colorStateListCacheKey = new ColorStateListCacheKey(resources, theme);
+        ColorStateList cachedColorStateList = getCachedColorStateList(colorStateListCacheKey, i);
+        if (cachedColorStateList != null) {
+            return cachedColorStateList;
+        }
+        ColorStateList inflateColorStateList = inflateColorStateList(resources, i, theme);
+        if (inflateColorStateList != null) {
+            addColorStateListToCache(colorStateListCacheKey, i, inflateColorStateList, theme);
+            return inflateColorStateList;
+        }
+        return Api23Impl.getColorStateList(resources, i, theme);
+    }
+
+    @Nullable
+    private static ColorStateList inflateColorStateList(Resources resources, int i, @Nullable Resources.Theme theme) {
+        if (isColorInt(resources, i)) {
+            return null;
+        }
+        try {
+            return ColorStateListInflaterCompat.createFromXml(resources, resources.getXml(i), theme);
+        } catch (Exception e) {
+            Log.w(TAG, "Failed to inflate ColorStateList, leaving it to the framework", e);
+            return null;
+        }
+    }
+
+    /* JADX WARN: Code restructure failed: missing block: B:23:0x003c, code lost:
+    
+        if (r2.mThemeHash == r5.hashCode()) goto L22;
+     */
+    @androidx.annotation.Nullable
+    /*
+        Code decompiled incorrectly, please refer to instructions dump.
+        To view partially-correct add '--show-bad-code' argument
+    */
+    private static android.content.res.ColorStateList getCachedColorStateList(@androidx.annotation.NonNull androidx.core.content.res.ResourcesCompat.ColorStateListCacheKey r5, @androidx.annotation.ColorRes int r6) {
+        /*
+            java.lang.Object r0 = androidx.core.content.res.ResourcesCompat.sColorStateCacheLock
+            monitor-enter(r0)
+            java.util.WeakHashMap<androidx.core.content.res.ResourcesCompat$ColorStateListCacheKey, android.util.SparseArray<androidx.core.content.res.ResourcesCompat$ColorStateListCacheEntry>> r1 = androidx.core.content.res.ResourcesCompat.sColorStateCaches     // Catch: java.lang.Throwable -> L32
+            java.lang.Object r1 = r1.get(r5)     // Catch: java.lang.Throwable -> L32
+            android.util.SparseArray r1 = (android.util.SparseArray) r1     // Catch: java.lang.Throwable -> L32
+            if (r1 == 0) goto L45
+            int r2 = r1.size()     // Catch: java.lang.Throwable -> L32
+            if (r2 <= 0) goto L45
+            java.lang.Object r2 = r1.get(r6)     // Catch: java.lang.Throwable -> L32
+            androidx.core.content.res.ResourcesCompat$ColorStateListCacheEntry r2 = (androidx.core.content.res.ResourcesCompat.ColorStateListCacheEntry) r2     // Catch: java.lang.Throwable -> L32
+            if (r2 == 0) goto L45
+            android.content.res.Configuration r3 = r2.mConfiguration     // Catch: java.lang.Throwable -> L32
+            android.content.res.Resources r4 = r5.mResources     // Catch: java.lang.Throwable -> L32
+            android.content.res.Configuration r4 = r4.getConfiguration()     // Catch: java.lang.Throwable -> L32
+            boolean r3 = r3.equals(r4)     // Catch: java.lang.Throwable -> L32
+            if (r3 == 0) goto L42
+            android.content.res.Resources$Theme r5 = r5.mTheme     // Catch: java.lang.Throwable -> L32
+            if (r5 != 0) goto L34
+            int r3 = r2.mThemeHash     // Catch: java.lang.Throwable -> L32
+            if (r3 == 0) goto L3e
+            goto L34
+        L32:
+            r5 = move-exception
+            goto L48
+        L34:
+            if (r5 == 0) goto L42
+            int r3 = r2.mThemeHash     // Catch: java.lang.Throwable -> L32
+            int r5 = r5.hashCode()     // Catch: java.lang.Throwable -> L32
+            if (r3 != r5) goto L42
+        L3e:
+            android.content.res.ColorStateList r5 = r2.mValue     // Catch: java.lang.Throwable -> L32
+            monitor-exit(r0)     // Catch: java.lang.Throwable -> L32
+            return r5
+        L42:
+            r1.remove(r6)     // Catch: java.lang.Throwable -> L32
+        L45:
+            monitor-exit(r0)     // Catch: java.lang.Throwable -> L32
+            r5 = 0
+            return r5
+        L48:
+            monitor-exit(r0)     // Catch: java.lang.Throwable -> L32
+            throw r5
+        */
+        throw new UnsupportedOperationException("Method not decompiled: androidx.core.content.res.ResourcesCompat.getCachedColorStateList(androidx.core.content.res.ResourcesCompat$ColorStateListCacheKey, int):android.content.res.ColorStateList");
+    }
+
+    private static void addColorStateListToCache(@NonNull ColorStateListCacheKey colorStateListCacheKey, @ColorRes int i, @NonNull ColorStateList colorStateList, @Nullable Resources.Theme theme) {
+        synchronized (sColorStateCacheLock) {
+            try {
+                WeakHashMap<ColorStateListCacheKey, SparseArray<ColorStateListCacheEntry>> weakHashMap = sColorStateCaches;
+                SparseArray<ColorStateListCacheEntry> sparseArray = weakHashMap.get(colorStateListCacheKey);
+                if (sparseArray == null) {
+                    sparseArray = new SparseArray<>();
+                    weakHashMap.put(colorStateListCacheKey, sparseArray);
+                }
+                sparseArray.append(i, new ColorStateListCacheEntry(colorStateList, colorStateListCacheKey.mResources.getConfiguration(), theme));
+            } catch (Throwable th) {
+                throw th;
+            }
+        }
+    }
+
+    private static boolean isColorInt(@NonNull Resources resources, @ColorRes int i) {
+        TypedValue typedValue = getTypedValue();
+        resources.getValue(i, typedValue, true);
+        int i2 = typedValue.type;
+        return i2 >= 28 && i2 <= 31;
+    }
+
+    @NonNull
+    private static TypedValue getTypedValue() {
+        ThreadLocal<TypedValue> threadLocal = sTempTypedValue;
+        TypedValue typedValue = threadLocal.get();
+        if (typedValue != null) {
+            return typedValue;
+        }
+        TypedValue typedValue2 = new TypedValue();
+        threadLocal.set(typedValue2);
+        return typedValue2;
+    }
+
+    public static final class ColorStateListCacheKey {
+        final Resources mResources;
+        final Resources.Theme mTheme;
+
+        public ColorStateListCacheKey(@NonNull Resources resources, @Nullable Resources.Theme theme) {
+            this.mResources = resources;
+            this.mTheme = theme;
+        }
+
+        public boolean equals(Object obj) {
+            if (this == obj) {
+                return true;
+            }
+            if (obj == null || ColorStateListCacheKey.class != obj.getClass()) {
+                return false;
+            }
+            ColorStateListCacheKey colorStateListCacheKey = (ColorStateListCacheKey) obj;
+            return this.mResources.equals(colorStateListCacheKey.mResources) && ObjectsCompat.equals(this.mTheme, colorStateListCacheKey.mTheme);
+        }
+
+        public int hashCode() {
+            return ObjectsCompat.hash(this.mResources, this.mTheme);
+        }
+    }
+
+    public static class ColorStateListCacheEntry {
+        final Configuration mConfiguration;
+        final int mThemeHash;
+        final ColorStateList mValue;
+
+        public ColorStateListCacheEntry(@NonNull ColorStateList colorStateList, @NonNull Configuration configuration, @Nullable Resources.Theme theme) {
+            this.mValue = colorStateList;
+            this.mConfiguration = configuration;
+            this.mThemeHash = theme == null ? 0 : theme.hashCode();
+        }
+    }
+
+    public static float getFloat(@NonNull Resources resources, @DimenRes int i) {
+        if (Build.VERSION.SDK_INT >= 29) {
+            return Api29Impl.getFloat(resources, i);
+        }
+        TypedValue typedValue = getTypedValue();
+        resources.getValue(i, typedValue, true);
+        if (typedValue.type == 4) {
+            return typedValue.getFloat();
+        }
+        throw new Resources.NotFoundException("Resource ID #0x" + Integer.toHexString(i) + " type #0x" + Integer.toHexString(typedValue.type) + " is not valid");
+    }
+
+    @Nullable
+    public static Typeface getFont(@NonNull Context context, @FontRes int i) throws Resources.NotFoundException {
+        if (context.isRestricted()) {
+            return null;
+        }
+        return loadFont(context, i, new TypedValue(), 0, null, null, false, false);
+    }
+
+    @Nullable
+    public static Typeface getCachedFont(@NonNull Context context, @FontRes int i) throws Resources.NotFoundException {
+        if (context.isRestricted()) {
+            return null;
+        }
+        return loadFont(context, i, new TypedValue(), 0, null, null, false, true);
+    }
+
+    public static abstract class FontCallback {
+        /* renamed from: onFontRetrievalFailed, reason: merged with bridge method [inline-methods] */
+        public abstract void lambda$callbackFailAsync$1(int i);
+
+        /* renamed from: onFontRetrieved, reason: merged with bridge method [inline-methods] */
+        public abstract void lambda$callbackSuccessAsync$0(@NonNull Typeface typeface);
+
+        @RestrictTo({RestrictTo.Scope.LIBRARY_GROUP_PREFIX})
+        public final void callbackSuccessAsync(@NonNull final Typeface typeface, @Nullable Handler handler) {
+            getHandler(handler).post(new Runnable() { // from class: androidx.core.content.res.ResourcesCompat$FontCallback$$ExternalSyntheticLambda0
+                @Override // java.lang.Runnable
+                public final void run() {
+                    ResourcesCompat.FontCallback.this.lambda$callbackSuccessAsync$0(typeface);
+                }
+            });
+        }
+
+        @RestrictTo({RestrictTo.Scope.LIBRARY_GROUP_PREFIX})
+        public final void callbackFailAsync(final int i, @Nullable Handler handler) {
+            getHandler(handler).post(new Runnable() { // from class: androidx.core.content.res.ResourcesCompat$FontCallback$$ExternalSyntheticLambda1
+                @Override // java.lang.Runnable
+                public final void run() {
+                    ResourcesCompat.FontCallback.this.lambda$callbackFailAsync$1(i);
+                }
+            });
+        }
+
+        @NonNull
+        @RestrictTo({RestrictTo.Scope.LIBRARY})
+        public static Handler getHandler(@Nullable Handler handler) {
+            return handler == null ? new Handler(Looper.getMainLooper()) : handler;
+        }
+    }
+
+    public static void getFont(@NonNull Context context, @FontRes int i, @NonNull FontCallback fontCallback, @Nullable Handler handler) throws Resources.NotFoundException {
+        Preconditions.checkNotNull(fontCallback);
+        if (context.isRestricted()) {
+            fontCallback.callbackFailAsync(-4, handler);
+        } else {
+            loadFont(context, i, new TypedValue(), 0, fontCallback, handler, false, false);
+        }
+    }
+
+    @Nullable
+    @RestrictTo({RestrictTo.Scope.LIBRARY_GROUP_PREFIX})
+    public static Typeface getFont(@NonNull Context context, @FontRes int i, @NonNull TypedValue typedValue, int i2, @Nullable FontCallback fontCallback) throws Resources.NotFoundException {
+        if (context.isRestricted()) {
+            return null;
+        }
+        return loadFont(context, i, typedValue, i2, fontCallback, null, true, false);
+    }
+
+    private static Typeface loadFont(@NonNull Context context, int i, @NonNull TypedValue typedValue, int i2, @Nullable FontCallback fontCallback, @Nullable Handler handler, boolean z, boolean z2) {
+        Resources resources = context.getResources();
+        resources.getValue(i, typedValue, true);
+        Typeface loadFont = loadFont(context, resources, typedValue, i, i2, fontCallback, handler, z, z2);
+        if (loadFont != null || fontCallback != null || z2) {
+            return loadFont;
+        }
+        throw new Resources.NotFoundException("Font resource ID #0x" + Integer.toHexString(i) + " could not be retrieved.");
+    }
+
+    /* JADX WARN: Removed duplicated region for block: B:40:0x00c1  */
+    /* JADX WARN: Removed duplicated region for block: B:42:? A[RETURN, SYNTHETIC] */
+    /*
+        Code decompiled incorrectly, please refer to instructions dump.
+        To view partially-correct add '--show-bad-code' argument
+    */
+    private static android.graphics.Typeface loadFont(@androidx.annotation.NonNull android.content.Context r16, android.content.res.Resources r17, @androidx.annotation.NonNull android.util.TypedValue r18, int r19, int r20, @androidx.annotation.Nullable androidx.core.content.res.ResourcesCompat.FontCallback r21, @androidx.annotation.Nullable android.os.Handler r22, boolean r23, boolean r24) {
+        /*
+            Method dump skipped, instructions count: 245
+            To view this dump add '--comments-level debug' option
+        */
+        throw new UnsupportedOperationException("Method not decompiled: androidx.core.content.res.ResourcesCompat.loadFont(android.content.Context, android.content.res.Resources, android.util.TypedValue, int, int, androidx.core.content.res.ResourcesCompat$FontCallback, android.os.Handler, boolean, boolean):android.graphics.Typeface");
+    }
+
+    @RequiresApi(29)
+    public static class Api29Impl {
+        private Api29Impl() {
+        }
+
+        public static float getFloat(@NonNull Resources resources, @DimenRes int i) {
+            return resources.getFloat(i);
+        }
+    }
+
+    @RequiresApi(23)
+    public static class Api23Impl {
+        private Api23Impl() {
+        }
+
+        @NonNull
+        public static ColorStateList getColorStateList(@NonNull Resources resources, @ColorRes int i, @Nullable Resources.Theme theme) {
+            return resources.getColorStateList(i, theme);
+        }
+
+        public static int getColor(Resources resources, int i, Resources.Theme theme) {
+            return resources.getColor(i, theme);
+        }
+    }
+
+    @RequiresApi(21)
+    public static class Api21Impl {
+        private Api21Impl() {
+        }
+
+        public static Drawable getDrawable(Resources resources, int i, Resources.Theme theme) {
+            return resources.getDrawable(i, theme);
+        }
+
+        public static Drawable getDrawableForDensity(Resources resources, int i, int i2, Resources.Theme theme) {
+            return resources.getDrawableForDensity(i, i2, theme);
+        }
+    }
+
+    private ResourcesCompat() {
+    }
+
+    public static final class ThemeCompat {
+        private ThemeCompat() {
+        }
+
+        public static void rebase(@NonNull Resources.Theme theme) {
+            if (Build.VERSION.SDK_INT >= 29) {
+                Api29Impl.rebase(theme);
+            } else {
+                Api23Impl.rebase(theme);
+            }
+        }
+
+        @RequiresApi(29)
+        public static class Api29Impl {
+            private Api29Impl() {
+            }
+
+            public static void rebase(@NonNull Resources.Theme theme) {
+                theme.rebase();
+            }
+        }
+
+        @RequiresApi(23)
+        public static class Api23Impl {
+            private static Method sRebaseMethod;
+            private static boolean sRebaseMethodFetched;
+            private static final Object sRebaseMethodLock = new Object();
+
+            private Api23Impl() {
+            }
+
+            @SuppressLint({"BanUncheckedReflection"})
+            public static void rebase(@NonNull Resources.Theme theme) {
+                synchronized (sRebaseMethodLock) {
+                    if (!sRebaseMethodFetched) {
+                        try {
+                            Method declaredMethod = Resources.Theme.class.getDeclaredMethod("rebase", new Class[0]);
+                            sRebaseMethod = declaredMethod;
+                            declaredMethod.setAccessible(true);
+                        } catch (NoSuchMethodException unused) {
+                        }
+                        sRebaseMethodFetched = true;
+                    }
+                    Method method = sRebaseMethod;
+                    if (method != null) {
+                        try {
+                            method.invoke(theme, new Object[0]);
+                        } catch (IllegalAccessException | InvocationTargetException unused2) {
+                            sRebaseMethod = null;
+                        }
+                    }
+                }
+            }
+        }
+    }
+}

decompiled/sources/androidx/core/content/res/TypedArrayApi26ImplKt.java

@@ -0,0 +1,22 @@
+package androidx.core.content.res;
+
+import android.content.res.TypedArray;
+import android.graphics.Typeface;
+import androidx.annotation.RequiresApi;
+import androidx.annotation.StyleableRes;
+import kotlin.jvm.internal.Intrinsics;
+
+@RequiresApi(26)
+/* loaded from: classes.dex */
+final class TypedArrayApi26ImplKt {
+    public static final TypedArrayApi26ImplKt INSTANCE = new TypedArrayApi26ImplKt();
+
+    private TypedArrayApi26ImplKt() {
+    }
+
+    public static final Typeface getFont(TypedArray typedArray, @StyleableRes int i) {
+        Typeface font = typedArray.getFont(i);
+        Intrinsics.checkNotNull(font);
+        return font;
+    }
+}

decompiled/sources/androidx/core/content/res/TypedArrayKt.java

@@ -0,0 +1,124 @@
+package androidx.core.content.res;
+
+import android.content.res.ColorStateList;
+import android.content.res.TypedArray;
+import android.graphics.Typeface;
+import android.graphics.drawable.Drawable;
+import androidx.annotation.AnyRes;
+import androidx.annotation.ColorInt;
+import androidx.annotation.Dimension;
+import androidx.annotation.RequiresApi;
+import androidx.annotation.StyleableRes;
+import kotlin.jvm.functions.Function1;
+import kotlin.jvm.internal.Intrinsics;
+import kotlin.jvm.internal.SourceDebugExtension;
+
+@SourceDebugExtension({"SMAP\nTypedArray.kt\nKotlin\n*S Kotlin\n*F\n+ 1 TypedArray.kt\nandroidx/core/content/res/TypedArrayKt\n+ 2 fake.kt\nkotlin/jvm/internal/FakeKt\n*L\n1#1,238:1\n1#2:239\n*E\n"})
+/* loaded from: classes.dex */
+public final class TypedArrayKt {
+    private static final void checkAttribute(TypedArray typedArray, @StyleableRes int i) {
+        if (!typedArray.hasValue(i)) {
+            throw new IllegalArgumentException("Attribute not defined in set.");
+        }
+    }
+
+    public static final boolean getBooleanOrThrow(TypedArray typedArray, @StyleableRes int i) {
+        checkAttribute(typedArray, i);
+        return typedArray.getBoolean(i, false);
+    }
+
+    @ColorInt
+    public static final int getColorOrThrow(TypedArray typedArray, @StyleableRes int i) {
+        checkAttribute(typedArray, i);
+        return typedArray.getColor(i, 0);
+    }
+
+    public static final ColorStateList getColorStateListOrThrow(TypedArray typedArray, @StyleableRes int i) {
+        checkAttribute(typedArray, i);
+        ColorStateList colorStateList = typedArray.getColorStateList(i);
+        if (colorStateList != null) {
+            return colorStateList;
+        }
+        throw new IllegalStateException("Attribute value was not a color or color state list.".toString());
+    }
+
+    public static final float getDimensionOrThrow(TypedArray typedArray, @StyleableRes int i) {
+        checkAttribute(typedArray, i);
+        return typedArray.getDimension(i, 0.0f);
+    }
+
+    @Dimension
+    public static final int getDimensionPixelOffsetOrThrow(TypedArray typedArray, @StyleableRes int i) {
+        checkAttribute(typedArray, i);
+        return typedArray.getDimensionPixelOffset(i, 0);
+    }
+
+    @Dimension
+    public static final int getDimensionPixelSizeOrThrow(TypedArray typedArray, @StyleableRes int i) {
+        checkAttribute(typedArray, i);
+        return typedArray.getDimensionPixelSize(i, 0);
+    }
+
+    public static final Drawable getDrawableOrThrow(TypedArray typedArray, @StyleableRes int i) {
+        checkAttribute(typedArray, i);
+        Drawable drawable = typedArray.getDrawable(i);
+        Intrinsics.checkNotNull(drawable);
+        return drawable;
+    }
+
+    public static final float getFloatOrThrow(TypedArray typedArray, @StyleableRes int i) {
+        checkAttribute(typedArray, i);
+        return typedArray.getFloat(i, 0.0f);
+    }
+
+    @RequiresApi(26)
+    public static final Typeface getFontOrThrow(TypedArray typedArray, @StyleableRes int i) {
+        checkAttribute(typedArray, i);
+        return TypedArrayApi26ImplKt.getFont(typedArray, i);
+    }
+
+    public static final int getIntOrThrow(TypedArray typedArray, @StyleableRes int i) {
+        checkAttribute(typedArray, i);
+        return typedArray.getInt(i, 0);
+    }
+
+    public static final int getIntegerOrThrow(TypedArray typedArray, @StyleableRes int i) {
+        checkAttribute(typedArray, i);
+        return typedArray.getInteger(i, 0);
+    }
+
+    @AnyRes
+    public static final int getResourceIdOrThrow(TypedArray typedArray, @StyleableRes int i) {
+        checkAttribute(typedArray, i);
+        return typedArray.getResourceId(i, 0);
+    }
+
+    public static final String getStringOrThrow(TypedArray typedArray, @StyleableRes int i) {
+        checkAttribute(typedArray, i);
+        String string = typedArray.getString(i);
+        if (string != null) {
+            return string;
+        }
+        throw new IllegalStateException("Attribute value could not be coerced to String.".toString());
+    }
+
+    public static final CharSequence getTextOrThrow(TypedArray typedArray, @StyleableRes int i) {
+        checkAttribute(typedArray, i);
+        CharSequence text = typedArray.getText(i);
+        if (text != null) {
+            return text;
+        }
+        throw new IllegalStateException("Attribute value could not be coerced to CharSequence.".toString());
+    }
+
+    public static final CharSequence[] getTextArrayOrThrow(TypedArray typedArray, @StyleableRes int i) {
+        checkAttribute(typedArray, i);
+        return typedArray.getTextArray(i);
+    }
+
+    public static final <R> R use(TypedArray typedArray, Function1 function1) {
+        R r = (R) function1.invoke(typedArray);
+        typedArray.recycle();
+        return r;
+    }
+}

decompiled/sources/androidx/core/content/res/TypedArrayUtils.java

@@ -0,0 +1,156 @@
+package androidx.core.content.res;
+
+import android.content.Context;
+import android.content.res.ColorStateList;
+import android.content.res.Resources;
+import android.content.res.TypedArray;
+import android.graphics.drawable.Drawable;
+import android.util.AttributeSet;
+import android.util.TypedValue;
+import androidx.annotation.AnyRes;
+import androidx.annotation.ColorInt;
+import androidx.annotation.NonNull;
+import androidx.annotation.Nullable;
+import androidx.annotation.RestrictTo;
+import androidx.annotation.StyleableRes;
+import org.xmlpull.v1.XmlPullParser;
+
+@RestrictTo({RestrictTo.Scope.LIBRARY_GROUP_PREFIX})
+/* loaded from: classes.dex */
+public class TypedArrayUtils {
+    private static final String NAMESPACE = "http://schemas.android.com/apk/res/android";
+
+    public static boolean hasAttribute(@NonNull XmlPullParser xmlPullParser, @NonNull String str) {
+        return xmlPullParser.getAttributeValue(NAMESPACE, str) != null;
+    }
+
+    public static float getNamedFloat(@NonNull TypedArray typedArray, @NonNull XmlPullParser xmlPullParser, @NonNull String str, @StyleableRes int i, float f) {
+        return !hasAttribute(xmlPullParser, str) ? f : typedArray.getFloat(i, f);
+    }
+
+    public static boolean getNamedBoolean(@NonNull TypedArray typedArray, @NonNull XmlPullParser xmlPullParser, @NonNull String str, @StyleableRes int i, boolean z) {
+        return !hasAttribute(xmlPullParser, str) ? z : typedArray.getBoolean(i, z);
+    }
+
+    public static int getNamedInt(@NonNull TypedArray typedArray, @NonNull XmlPullParser xmlPullParser, @NonNull String str, @StyleableRes int i, int i2) {
+        return !hasAttribute(xmlPullParser, str) ? i2 : typedArray.getInt(i, i2);
+    }
+
+    @ColorInt
+    public static int getNamedColor(@NonNull TypedArray typedArray, @NonNull XmlPullParser xmlPullParser, @NonNull String str, @StyleableRes int i, @ColorInt int i2) {
+        return !hasAttribute(xmlPullParser, str) ? i2 : typedArray.getColor(i, i2);
+    }
+
+    public static ComplexColorCompat getNamedComplexColor(@NonNull TypedArray typedArray, @NonNull XmlPullParser xmlPullParser, @Nullable Resources.Theme theme, @NonNull String str, @StyleableRes int i, @ColorInt int i2) {
+        if (hasAttribute(xmlPullParser, str)) {
+            TypedValue typedValue = new TypedValue();
+            typedArray.getValue(i, typedValue);
+            int i3 = typedValue.type;
+            if (i3 >= 28 && i3 <= 31) {
+                return ComplexColorCompat.from(typedValue.data);
+            }
+            ComplexColorCompat inflate = ComplexColorCompat.inflate(typedArray.getResources(), typedArray.getResourceId(i, 0), theme);
+            if (inflate != null) {
+                return inflate;
+            }
+        }
+        return ComplexColorCompat.from(i2);
+    }
+
+    @Nullable
+    public static ColorStateList getNamedColorStateList(@NonNull TypedArray typedArray, @NonNull XmlPullParser xmlPullParser, @Nullable Resources.Theme theme, @NonNull String str, @StyleableRes int i) {
+        if (!hasAttribute(xmlPullParser, str)) {
+            return null;
+        }
+        TypedValue typedValue = new TypedValue();
+        typedArray.getValue(i, typedValue);
+        int i2 = typedValue.type;
+        if (i2 != 2) {
+            if (i2 >= 28 && i2 <= 31) {
+                return getNamedColorStateListFromInt(typedValue);
+            }
+            return ColorStateListInflaterCompat.inflate(typedArray.getResources(), typedArray.getResourceId(i, 0), theme);
+        }
+        throw new UnsupportedOperationException("Failed to resolve attribute at index " + i + ": " + typedValue);
+    }
+
+    @NonNull
+    private static ColorStateList getNamedColorStateListFromInt(@NonNull TypedValue typedValue) {
+        return ColorStateList.valueOf(typedValue.data);
+    }
+
+    @AnyRes
+    public static int getNamedResourceId(@NonNull TypedArray typedArray, @NonNull XmlPullParser xmlPullParser, @NonNull String str, @StyleableRes int i, @AnyRes int i2) {
+        return !hasAttribute(xmlPullParser, str) ? i2 : typedArray.getResourceId(i, i2);
+    }
+
+    @Nullable
+    public static String getNamedString(@NonNull TypedArray typedArray, @NonNull XmlPullParser xmlPullParser, @NonNull String str, @StyleableRes int i) {
+        if (hasAttribute(xmlPullParser, str)) {
+            return typedArray.getString(i);
+        }
+        return null;
+    }
+
+    @Nullable
+    public static TypedValue peekNamedValue(@NonNull TypedArray typedArray, @NonNull XmlPullParser xmlPullParser, @NonNull String str, int i) {
+        if (hasAttribute(xmlPullParser, str)) {
+            return typedArray.peekValue(i);
+        }
+        return null;
+    }
+
+    @NonNull
+    public static TypedArray obtainAttributes(@NonNull Resources resources, @Nullable Resources.Theme theme, @NonNull AttributeSet attributeSet, @NonNull int[] iArr) {
+        if (theme == null) {
+            return resources.obtainAttributes(attributeSet, iArr);
+        }
+        return theme.obtainStyledAttributes(attributeSet, iArr, 0, 0);
+    }
+
+    public static boolean getBoolean(@NonNull TypedArray typedArray, @StyleableRes int i, @StyleableRes int i2, boolean z) {
+        return typedArray.getBoolean(i, typedArray.getBoolean(i2, z));
+    }
+
+    @Nullable
+    public static Drawable getDrawable(@NonNull TypedArray typedArray, @StyleableRes int i, @StyleableRes int i2) {
+        Drawable drawable = typedArray.getDrawable(i);
+        return drawable == null ? typedArray.getDrawable(i2) : drawable;
+    }
+
+    public static int getInt(@NonNull TypedArray typedArray, @StyleableRes int i, @StyleableRes int i2, int i3) {
+        return typedArray.getInt(i, typedArray.getInt(i2, i3));
+    }
+
+    @AnyRes
+    public static int getResourceId(@NonNull TypedArray typedArray, @StyleableRes int i, @StyleableRes int i2, @AnyRes int i3) {
+        return typedArray.getResourceId(i, typedArray.getResourceId(i2, i3));
+    }
+
+    @Nullable
+    public static String getString(@NonNull TypedArray typedArray, @StyleableRes int i, @StyleableRes int i2) {
+        String string = typedArray.getString(i);
+        return string == null ? typedArray.getString(i2) : string;
+    }
+
+    @Nullable
+    public static CharSequence getText(@NonNull TypedArray typedArray, @StyleableRes int i, @StyleableRes int i2) {
+        CharSequence text = typedArray.getText(i);
+        return text == null ? typedArray.getText(i2) : text;
+    }
+
+    @Nullable
+    public static CharSequence[] getTextArray(@NonNull TypedArray typedArray, @StyleableRes int i, @StyleableRes int i2) {
+        CharSequence[] textArray = typedArray.getTextArray(i);
+        return textArray == null ? typedArray.getTextArray(i2) : textArray;
+    }
+
+    public static int getAttr(@NonNull Context context, int i, int i2) {
+        TypedValue typedValue = new TypedValue();
+        context.getTheme().resolveAttribute(i, typedValue, true);
+        return typedValue.resourceId != 0 ? i : i2;
+    }
+
+    private TypedArrayUtils() {
+    }
+}

decompiled/sources/androidx/core/content/res/ViewingConditions.java

@@ -0,0 +1,111 @@
+package androidx.core.content.res;
+
+import androidx.annotation.NonNull;
+
+/* loaded from: classes.dex */
+final class ViewingConditions {
+    static final ViewingConditions DEFAULT = make(CamUtils.WHITE_POINT_D65, (float) ((CamUtils.yFromLStar(50.0f) * 63.66197723675813d) / 100.0d), 50.0f, 2.0f, false);
+    private final float mAw;
+    private final float mC;
+    private final float mFl;
+    private final float mFlRoot;
+    private final float mN;
+    private final float mNbb;
+    private final float mNc;
+    private final float mNcb;
+    private final float[] mRgbD;
+    private final float mZ;
+
+    public float getAw() {
+        return this.mAw;
+    }
+
+    public float getC() {
+        return this.mC;
+    }
+
+    public float getFl() {
+        return this.mFl;
+    }
+
+    public float getFlRoot() {
+        return this.mFlRoot;
+    }
+
+    public float getN() {
+        return this.mN;
+    }
+
+    public float getNbb() {
+        return this.mNbb;
+    }
+
+    public float getNc() {
+        return this.mNc;
+    }
+
+    public float getNcb() {
+        return this.mNcb;
+    }
+
+    @NonNull
+    public float[] getRgbD() {
+        return this.mRgbD;
+    }
+
+    public float getZ() {
+        return this.mZ;
+    }
+
+    private ViewingConditions(float f, float f2, float f3, float f4, float f5, float f6, float[] fArr, float f7, float f8, float f9) {
+        this.mN = f;
+        this.mAw = f2;
+        this.mNbb = f3;
+        this.mNcb = f4;
+        this.mC = f5;
+        this.mNc = f6;
+        this.mRgbD = fArr;
+        this.mFl = f7;
+        this.mFlRoot = f8;
+        this.mZ = f9;
+    }
+
+    @NonNull
+    public static ViewingConditions make(@NonNull float[] fArr, float f, float f2, float f3, boolean z) {
+        float[][] fArr2 = CamUtils.XYZ_TO_CAM16RGB;
+        float f4 = fArr[0];
+        float[] fArr3 = fArr2[0];
+        float f5 = fArr3[0] * f4;
+        float f6 = fArr[1];
+        float f7 = f5 + (fArr3[1] * f6);
+        float f8 = fArr[2];
+        float f9 = f7 + (fArr3[2] * f8);
+        float[] fArr4 = fArr2[1];
+        float f10 = (fArr4[0] * f4) + (fArr4[1] * f6) + (fArr4[2] * f8);
+        float[] fArr5 = fArr2[2];
+        float f11 = (f4 * fArr5[0]) + (f6 * fArr5[1]) + (f8 * fArr5[2]);
+        float f12 = (f3 / 10.0f) + 0.8f;
+        float lerp = ((double) f12) >= 0.9d ? CamUtils.lerp(0.59f, 0.69f, (f12 - 0.9f) * 10.0f) : CamUtils.lerp(0.525f, 0.59f, (f12 - 0.8f) * 10.0f);
+        float exp = z ? 1.0f : (1.0f - (((float) Math.exp(((-f) - 42.0f) / 92.0f)) * 0.2777778f)) * f12;
+        double d = exp;
+        if (d > 1.0d) {
+            exp = 1.0f;
+        } else if (d < 0.0d) {
+            exp = 0.0f;
+        }
+        float[] fArr6 = {(((100.0f / f9) * exp) + 1.0f) - exp, (((100.0f / f10) * exp) + 1.0f) - exp, (((100.0f / f11) * exp) + 1.0f) - exp};
+        float f13 = 1.0f / ((5.0f * f) + 1.0f);
+        float f14 = f13 * f13 * f13 * f13;
+        float f15 = 1.0f - f14;
+        float cbrt = (f14 * f) + (0.1f * f15 * f15 * ((float) Math.cbrt(f * 5.0d)));
+        float yFromLStar = CamUtils.yFromLStar(f2) / fArr[1];
+        double d2 = yFromLStar;
+        float sqrt = ((float) Math.sqrt(d2)) + 1.48f;
+        float pow = 0.725f / ((float) Math.pow(d2, 0.2d));
+        float pow2 = (float) Math.pow(((fArr6[2] * cbrt) * f11) / 100.0d, 0.42d);
+        float[] fArr7 = {(float) Math.pow(((fArr6[0] * cbrt) * f9) / 100.0d, 0.42d), (float) Math.pow(((fArr6[1] * cbrt) * f10) / 100.0d, 0.42d), pow2};
+        float f16 = fArr7[0];
+        float f17 = fArr7[1];
+        return new ViewingConditions(yFromLStar, ((((f16 * 400.0f) / (f16 + 27.13f)) * 2.0f) + ((f17 * 400.0f) / (f17 + 27.13f)) + (((400.0f * pow2) / (pow2 + 27.13f)) * 0.05f)) * pow, pow, pow, lerp, f12, fArr6, cbrt, (float) Math.pow(cbrt, 0.25d), sqrt);
+    }
+}