Initial import of ADIF API reverse-engineering toolkit

apk_decompiled/sources/C0/a.java

@@ -0,0 +1,25 @@
+package C0;
+
+import android.R;
+
+/* loaded from: classes.dex */
+public abstract class a {
+
+    /* renamed from: a, reason: collision with root package name */
+    public static final int[] f268a = {R.attr.name, R.attr.tint, R.attr.height, R.attr.width, R.attr.alpha, R.attr.autoMirrored, R.attr.tintMode, R.attr.viewportWidth, R.attr.viewportHeight};
+
+    /* renamed from: b, reason: collision with root package name */
+    public static final int[] f269b = {R.attr.name, R.attr.pivotX, R.attr.pivotY, R.attr.scaleX, R.attr.scaleY, R.attr.rotation, R.attr.translateX, R.attr.translateY};
+
+    /* renamed from: c, reason: collision with root package name */
+    public static final int[] f270c = {R.attr.name, R.attr.fillColor, R.attr.pathData, R.attr.strokeColor, R.attr.strokeWidth, R.attr.trimPathStart, R.attr.trimPathEnd, R.attr.trimPathOffset, R.attr.strokeLineCap, R.attr.strokeLineJoin, R.attr.strokeMiterLimit, R.attr.strokeAlpha, R.attr.fillAlpha, R.attr.fillType};
+
+    /* renamed from: d, reason: collision with root package name */
+    public static final int[] f271d = {R.attr.name, R.attr.pathData, R.attr.fillType};
+
+    /* renamed from: e, reason: collision with root package name */
+    public static final int[] f272e = {R.attr.drawable};
+
+    /* renamed from: f, reason: collision with root package name */
+    public static final int[] f273f = {R.attr.name, R.attr.animation};
+}

apk_decompiled/sources/C0/b.java

@@ -0,0 +1,30 @@
+package C0;
+
+import android.content.res.ColorStateList;
+import android.graphics.drawable.Animatable2;
+import android.graphics.drawable.Drawable;
+import r2.C0567a;
+
+/* loaded from: classes.dex */
+public final class b extends Animatable2.AnimationCallback {
+
+    /* renamed from: a, reason: collision with root package name */
+    public final /* synthetic */ C0567a f274a;
+
+    public b(C0567a c0567a) {
+        this.f274a = c0567a;
+    }
+
+    @Override // android.graphics.drawable.Animatable2.AnimationCallback
+    public final void onAnimationEnd(Drawable drawable) {
+        ColorStateList colorStateList = this.f274a.f8213b.f8227o;
+        if (colorStateList != null) {
+            H.a.h(drawable, colorStateList);
+        }
+    }
+
+    @Override // android.graphics.drawable.Animatable2.AnimationCallback
+    public final void onAnimationStart(Drawable drawable) {
+        this.f274a.a(drawable);
+    }
+}

apk_decompiled/sources/C0/c.java

@@ -0,0 +1,29 @@
+package C0;
+
+import android.graphics.drawable.Drawable;
+
+/* loaded from: classes.dex */
+public final class c implements Drawable.Callback {
+
+    /* renamed from: a, reason: collision with root package name */
+    public final /* synthetic */ f f275a;
+
+    public c(f fVar) {
+        this.f275a = fVar;
+    }
+
+    @Override // android.graphics.drawable.Drawable.Callback
+    public final void invalidateDrawable(Drawable drawable) {
+        this.f275a.invalidateSelf();
+    }
+
+    @Override // android.graphics.drawable.Drawable.Callback
+    public final void scheduleDrawable(Drawable drawable, Runnable runnable, long j4) {
+        this.f275a.scheduleSelf(runnable, j4);
+    }
+
+    @Override // android.graphics.drawable.Drawable.Callback
+    public final void unscheduleDrawable(Drawable drawable, Runnable runnable) {
+        this.f275a.unscheduleSelf(runnable);
+    }
+}

apk_decompiled/sources/C0/d.java

@@ -0,0 +1,37 @@
+package C0;
+
+import android.animation.AnimatorSet;
+import android.content.res.Resources;
+import android.graphics.drawable.Drawable;
+import java.util.ArrayList;
+
+/* loaded from: classes.dex */
+public final class d extends Drawable.ConstantState {
+
+    /* renamed from: a, reason: collision with root package name */
+    public p f276a;
+
+    /* renamed from: b, reason: collision with root package name */
+    public AnimatorSet f277b;
+
+    /* renamed from: c, reason: collision with root package name */
+    public ArrayList f278c;
+
+    /* renamed from: d, reason: collision with root package name */
+    public s.e f279d;
+
+    @Override // android.graphics.drawable.Drawable.ConstantState
+    public final int getChangingConfigurations() {
+        return 0;
+    }
+
+    @Override // android.graphics.drawable.Drawable.ConstantState
+    public final Drawable newDrawable() {
+        throw new IllegalStateException("No constant state support for SDK < 24.");
+    }
+
+    @Override // android.graphics.drawable.Drawable.ConstantState
+    public final Drawable newDrawable(Resources resources) {
+        throw new IllegalStateException("No constant state support for SDK < 24.");
+    }
+}

apk_decompiled/sources/C0/e.java

@@ -0,0 +1,52 @@
+package C0;
+
+import android.content.res.Resources;
+import android.graphics.drawable.Drawable;
+
+/* loaded from: classes.dex */
+public final class e extends Drawable.ConstantState {
+
+    /* renamed from: a, reason: collision with root package name */
+    public final Drawable.ConstantState f280a;
+
+    public e(Drawable.ConstantState constantState) {
+        this.f280a = constantState;
+    }
+
+    @Override // android.graphics.drawable.Drawable.ConstantState
+    public final boolean canApplyTheme() {
+        return this.f280a.canApplyTheme();
+    }
+
+    @Override // android.graphics.drawable.Drawable.ConstantState
+    public final int getChangingConfigurations() {
+        return this.f280a.getChangingConfigurations();
+    }
+
+    @Override // android.graphics.drawable.Drawable.ConstantState
+    public final Drawable newDrawable() {
+        f fVar = new f(null);
+        Drawable newDrawable = this.f280a.newDrawable();
+        fVar.f286a = newDrawable;
+        newDrawable.setCallback(fVar.f285f);
+        return fVar;
+    }
+
+    @Override // android.graphics.drawable.Drawable.ConstantState
+    public final Drawable newDrawable(Resources resources) {
+        f fVar = new f(null);
+        Drawable newDrawable = this.f280a.newDrawable(resources);
+        fVar.f286a = newDrawable;
+        newDrawable.setCallback(fVar.f285f);
+        return fVar;
+    }
+
+    @Override // android.graphics.drawable.Drawable.ConstantState
+    public final Drawable newDrawable(Resources resources, Resources.Theme theme) {
+        f fVar = new f(null);
+        Drawable newDrawable = this.f280a.newDrawable(resources, theme);
+        fVar.f286a = newDrawable;
+        newDrawable.setCallback(fVar.f285f);
+        return fVar;
+    }
+}

apk_decompiled/sources/C0/f.java

@@ -0,0 +1,341 @@
+package C0;
+
+import B0.q;
+import android.animation.Animator;
+import android.animation.AnimatorInflater;
+import android.animation.AnimatorSet;
+import android.content.Context;
+import android.content.res.ColorStateList;
+import android.content.res.Resources;
+import android.content.res.TypedArray;
+import android.graphics.Canvas;
+import android.graphics.ColorFilter;
+import android.graphics.PorterDuff;
+import android.graphics.Rect;
+import android.graphics.drawable.Animatable;
+import android.graphics.drawable.AnimatedVectorDrawable;
+import android.graphics.drawable.Drawable;
+import android.util.AttributeSet;
+import java.util.ArrayList;
+import org.xmlpull.v1.XmlPullParser;
+
+/* loaded from: classes.dex */
+public final class f extends g implements Animatable {
+
+    /* renamed from: c, reason: collision with root package name */
+    public final Context f282c;
+
+    /* renamed from: d, reason: collision with root package name */
+    public q f283d = null;
+
+    /* renamed from: e, reason: collision with root package name */
+    public ArrayList f284e = null;
+
+    /* renamed from: f, reason: collision with root package name */
+    public final c f285f = new c(this);
+
+    /* renamed from: b, reason: collision with root package name */
+    public final d f281b = new Drawable.ConstantState();
+
+    /* JADX WARN: Type inference failed for: r2v1, types: [android.graphics.drawable.Drawable$ConstantState, C0.d] */
+    public f(Context context) {
+        this.f282c = context;
+    }
+
+    @Override // C0.g, android.graphics.drawable.Drawable
+    public final void applyTheme(Resources.Theme theme) {
+        Drawable drawable = this.f286a;
+        if (drawable != null) {
+            H.a.a(drawable, theme);
+        }
+    }
+
+    @Override // android.graphics.drawable.Drawable
+    public final boolean canApplyTheme() {
+        Drawable drawable = this.f286a;
+        if (drawable != null) {
+            return H.a.b(drawable);
+        }
+        return false;
+    }
+
+    @Override // android.graphics.drawable.Drawable
+    public final void draw(Canvas canvas) {
+        Drawable drawable = this.f286a;
+        if (drawable != null) {
+            drawable.draw(canvas);
+            return;
+        }
+        d dVar = this.f281b;
+        dVar.f276a.draw(canvas);
+        if (dVar.f277b.isStarted()) {
+            invalidateSelf();
+        }
+    }
+
+    @Override // android.graphics.drawable.Drawable
+    public final int getAlpha() {
+        Drawable drawable = this.f286a;
+        return drawable != null ? drawable.getAlpha() : this.f281b.f276a.getAlpha();
+    }
+
+    @Override // android.graphics.drawable.Drawable
+    public final int getChangingConfigurations() {
+        Drawable drawable = this.f286a;
+        if (drawable != null) {
+            return drawable.getChangingConfigurations();
+        }
+        int changingConfigurations = super.getChangingConfigurations();
+        this.f281b.getClass();
+        return changingConfigurations;
+    }
+
+    @Override // android.graphics.drawable.Drawable
+    public final ColorFilter getColorFilter() {
+        Drawable drawable = this.f286a;
+        return drawable != null ? H.a.c(drawable) : this.f281b.f276a.getColorFilter();
+    }
+
+    @Override // android.graphics.drawable.Drawable
+    public final Drawable.ConstantState getConstantState() {
+        if (this.f286a != null) {
+            return new e(this.f286a.getConstantState());
+        }
+        return null;
+    }
+
+    @Override // android.graphics.drawable.Drawable
+    public final int getIntrinsicHeight() {
+        Drawable drawable = this.f286a;
+        return drawable != null ? drawable.getIntrinsicHeight() : this.f281b.f276a.getIntrinsicHeight();
+    }
+
+    @Override // android.graphics.drawable.Drawable
+    public final int getIntrinsicWidth() {
+        Drawable drawable = this.f286a;
+        return drawable != null ? drawable.getIntrinsicWidth() : this.f281b.f276a.getIntrinsicWidth();
+    }
+
+    @Override // android.graphics.drawable.Drawable
+    public final int getOpacity() {
+        Drawable drawable = this.f286a;
+        return drawable != null ? drawable.getOpacity() : this.f281b.f276a.getOpacity();
+    }
+
+    /* JADX WARN: Type inference failed for: r7v8, types: [s.e, s.j] */
+    @Override // android.graphics.drawable.Drawable
+    public final void inflate(Resources resources, XmlPullParser xmlPullParser, AttributeSet attributeSet, Resources.Theme theme) {
+        d dVar;
+        Drawable drawable = this.f286a;
+        if (drawable != null) {
+            H.a.d(drawable, resources, xmlPullParser, attributeSet, theme);
+            return;
+        }
+        int eventType = xmlPullParser.getEventType();
+        int depth = xmlPullParser.getDepth() + 1;
+        while (true) {
+            dVar = this.f281b;
+            if (eventType == 1 || (xmlPullParser.getDepth() < depth && eventType == 3)) {
+                break;
+            }
+            if (eventType == 2) {
+                String name = xmlPullParser.getName();
+                if ("animated-vector".equals(name)) {
+                    TypedArray f2 = F.b.f(resources, theme, attributeSet, a.f272e);
+                    int resourceId = f2.getResourceId(0, 0);
+                    if (resourceId != 0) {
+                        p pVar = new p();
+                        ThreadLocal threadLocal = F.q.f503a;
+                        pVar.f286a = F.j.a(resources, resourceId, theme);
+                        new o(pVar.f286a.getConstantState());
+                        pVar.f337f = false;
+                        pVar.setCallback(this.f285f);
+                        p pVar2 = dVar.f276a;
+                        if (pVar2 != null) {
+                            pVar2.setCallback(null);
+                        }
+                        dVar.f276a = pVar;
+                    }
+                    f2.recycle();
+                } else if ("target".equals(name)) {
+                    TypedArray obtainAttributes = resources.obtainAttributes(attributeSet, a.f273f);
+                    String string = obtainAttributes.getString(0);
+                    int resourceId2 = obtainAttributes.getResourceId(1, 0);
+                    if (resourceId2 != 0) {
+                        Context context = this.f282c;
+                        if (context != null) {
+                            Animator loadAnimator = AnimatorInflater.loadAnimator(context, resourceId2);
+                            loadAnimator.setTarget(dVar.f276a.f333b.f322b.f320o.get(string));
+                            if (dVar.f278c == null) {
+                                dVar.f278c = new ArrayList();
+                                dVar.f279d = new s.j(0);
+                            }
+                            dVar.f278c.add(loadAnimator);
+                            dVar.f279d.put(loadAnimator, string);
+                        } else {
+                            obtainAttributes.recycle();
+                            throw new IllegalStateException("Context can't be null when inflating animators");
+                        }
+                    }
+                    obtainAttributes.recycle();
+                } else {
+                    continue;
+                }
+            }
+            eventType = xmlPullParser.next();
+        }
+        if (dVar.f277b == null) {
+            dVar.f277b = new AnimatorSet();
+        }
+        dVar.f277b.playTogether(dVar.f278c);
+    }
+
+    @Override // android.graphics.drawable.Drawable
+    public final boolean isAutoMirrored() {
+        Drawable drawable = this.f286a;
+        return drawable != null ? drawable.isAutoMirrored() : this.f281b.f276a.isAutoMirrored();
+    }
+
+    @Override // android.graphics.drawable.Animatable
+    public final boolean isRunning() {
+        Drawable drawable = this.f286a;
+        return drawable != null ? ((AnimatedVectorDrawable) drawable).isRunning() : this.f281b.f277b.isRunning();
+    }
+
+    @Override // android.graphics.drawable.Drawable
+    public final boolean isStateful() {
+        Drawable drawable = this.f286a;
+        return drawable != null ? drawable.isStateful() : this.f281b.f276a.isStateful();
+    }
+
+    @Override // android.graphics.drawable.Drawable
+    public final Drawable mutate() {
+        Drawable drawable = this.f286a;
+        if (drawable != null) {
+            drawable.mutate();
+        }
+        return this;
+    }
+
+    @Override // android.graphics.drawable.Drawable
+    public final void onBoundsChange(Rect rect) {
+        Drawable drawable = this.f286a;
+        if (drawable != null) {
+            drawable.setBounds(rect);
+        } else {
+            this.f281b.f276a.setBounds(rect);
+        }
+    }
+
+    @Override // C0.g, android.graphics.drawable.Drawable
+    public final boolean onLevelChange(int i) {
+        Drawable drawable = this.f286a;
+        return drawable != null ? drawable.setLevel(i) : this.f281b.f276a.setLevel(i);
+    }
+
+    @Override // android.graphics.drawable.Drawable
+    public final boolean onStateChange(int[] iArr) {
+        Drawable drawable = this.f286a;
+        return drawable != null ? drawable.setState(iArr) : this.f281b.f276a.setState(iArr);
+    }
+
+    @Override // android.graphics.drawable.Drawable
+    public final void setAlpha(int i) {
+        Drawable drawable = this.f286a;
+        if (drawable != null) {
+            drawable.setAlpha(i);
+        } else {
+            this.f281b.f276a.setAlpha(i);
+        }
+    }
+
+    @Override // android.graphics.drawable.Drawable
+    public final void setAutoMirrored(boolean z3) {
+        Drawable drawable = this.f286a;
+        if (drawable != null) {
+            drawable.setAutoMirrored(z3);
+        } else {
+            this.f281b.f276a.setAutoMirrored(z3);
+        }
+    }
+
+    @Override // android.graphics.drawable.Drawable
+    public final void setColorFilter(ColorFilter colorFilter) {
+        Drawable drawable = this.f286a;
+        if (drawable != null) {
+            drawable.setColorFilter(colorFilter);
+        } else {
+            this.f281b.f276a.setColorFilter(colorFilter);
+        }
+    }
+
+    @Override // android.graphics.drawable.Drawable
+    public final void setTint(int i) {
+        Drawable drawable = this.f286a;
+        if (drawable != null) {
+            m3.d.J(drawable, i);
+        } else {
+            this.f281b.f276a.setTint(i);
+        }
+    }
+
+    @Override // android.graphics.drawable.Drawable
+    public final void setTintList(ColorStateList colorStateList) {
+        Drawable drawable = this.f286a;
+        if (drawable != null) {
+            H.a.h(drawable, colorStateList);
+        } else {
+            this.f281b.f276a.setTintList(colorStateList);
+        }
+    }
+
+    @Override // android.graphics.drawable.Drawable
+    public final void setTintMode(PorterDuff.Mode mode) {
+        Drawable drawable = this.f286a;
+        if (drawable != null) {
+            H.a.i(drawable, mode);
+        } else {
+            this.f281b.f276a.setTintMode(mode);
+        }
+    }
+
+    @Override // android.graphics.drawable.Drawable
+    public final boolean setVisible(boolean z3, boolean z4) {
+        Drawable drawable = this.f286a;
+        if (drawable != null) {
+            return drawable.setVisible(z3, z4);
+        }
+        this.f281b.f276a.setVisible(z3, z4);
+        return super.setVisible(z3, z4);
+    }
+
+    @Override // android.graphics.drawable.Animatable
+    public final void start() {
+        Drawable drawable = this.f286a;
+        if (drawable != null) {
+            ((AnimatedVectorDrawable) drawable).start();
+            return;
+        }
+        d dVar = this.f281b;
+        if (dVar.f277b.isStarted()) {
+            return;
+        }
+        dVar.f277b.start();
+        invalidateSelf();
+    }
+
+    @Override // android.graphics.drawable.Animatable
+    public final void stop() {
+        Drawable drawable = this.f286a;
+        if (drawable != null) {
+            ((AnimatedVectorDrawable) drawable).stop();
+        } else {
+            this.f281b.f277b.end();
+        }
+    }
+
+    @Override // android.graphics.drawable.Drawable
+    public final void inflate(Resources resources, XmlPullParser xmlPullParser, AttributeSet attributeSet) {
+        inflate(resources, xmlPullParser, attributeSet, null);
+    }
+}

apk_decompiled/sources/C0/g.java

@@ -0,0 +1,132 @@
+package C0;
+
+import android.content.res.Resources;
+import android.graphics.PorterDuff;
+import android.graphics.Rect;
+import android.graphics.Region;
+import android.graphics.drawable.Drawable;
+
+/* loaded from: classes.dex */
+public abstract class g extends Drawable {
+
+    /* renamed from: a, reason: collision with root package name */
+    public Drawable f286a;
+
+    @Override // android.graphics.drawable.Drawable
+    public void applyTheme(Resources.Theme theme) {
+        Drawable drawable = this.f286a;
+        if (drawable != null) {
+            H.a.a(drawable, theme);
+        }
+    }
+
+    @Override // android.graphics.drawable.Drawable
+    public final void clearColorFilter() {
+        Drawable drawable = this.f286a;
+        if (drawable != null) {
+            drawable.clearColorFilter();
+        } else {
+            super.clearColorFilter();
+        }
+    }
+
+    @Override // android.graphics.drawable.Drawable
+    public final Drawable getCurrent() {
+        Drawable drawable = this.f286a;
+        return drawable != null ? drawable.getCurrent() : super.getCurrent();
+    }
+
+    @Override // android.graphics.drawable.Drawable
+    public final int getMinimumHeight() {
+        Drawable drawable = this.f286a;
+        return drawable != null ? drawable.getMinimumHeight() : super.getMinimumHeight();
+    }
+
+    @Override // android.graphics.drawable.Drawable
+    public final int getMinimumWidth() {
+        Drawable drawable = this.f286a;
+        return drawable != null ? drawable.getMinimumWidth() : super.getMinimumWidth();
+    }
+
+    @Override // android.graphics.drawable.Drawable
+    public final boolean getPadding(Rect rect) {
+        Drawable drawable = this.f286a;
+        return drawable != null ? drawable.getPadding(rect) : super.getPadding(rect);
+    }
+
+    @Override // android.graphics.drawable.Drawable
+    public final int[] getState() {
+        Drawable drawable = this.f286a;
+        return drawable != null ? drawable.getState() : super.getState();
+    }
+
+    @Override // android.graphics.drawable.Drawable
+    public final Region getTransparentRegion() {
+        Drawable drawable = this.f286a;
+        return drawable != null ? drawable.getTransparentRegion() : super.getTransparentRegion();
+    }
+
+    @Override // android.graphics.drawable.Drawable
+    public final void jumpToCurrentState() {
+        Drawable drawable = this.f286a;
+        if (drawable != null) {
+            drawable.jumpToCurrentState();
+        }
+    }
+
+    @Override // android.graphics.drawable.Drawable
+    public boolean onLevelChange(int i) {
+        Drawable drawable = this.f286a;
+        return drawable != null ? drawable.setLevel(i) : super.onLevelChange(i);
+    }
+
+    @Override // android.graphics.drawable.Drawable
+    public final void setChangingConfigurations(int i) {
+        Drawable drawable = this.f286a;
+        if (drawable != null) {
+            drawable.setChangingConfigurations(i);
+        } else {
+            super.setChangingConfigurations(i);
+        }
+    }
+
+    @Override // android.graphics.drawable.Drawable
+    public final void setColorFilter(int i, PorterDuff.Mode mode) {
+        Drawable drawable = this.f286a;
+        if (drawable != null) {
+            drawable.setColorFilter(i, mode);
+        } else {
+            super.setColorFilter(i, mode);
+        }
+    }
+
+    @Override // android.graphics.drawable.Drawable
+    public final void setFilterBitmap(boolean z3) {
+        Drawable drawable = this.f286a;
+        if (drawable != null) {
+            drawable.setFilterBitmap(z3);
+        }
+    }
+
+    @Override // android.graphics.drawable.Drawable
+    public final void setHotspot(float f2, float f4) {
+        Drawable drawable = this.f286a;
+        if (drawable != null) {
+            H.a.e(drawable, f2, f4);
+        }
+    }
+
+    @Override // android.graphics.drawable.Drawable
+    public final void setHotspotBounds(int i, int i4, int i5, int i6) {
+        Drawable drawable = this.f286a;
+        if (drawable != null) {
+            H.a.f(drawable, i, i4, i5, i6);
+        }
+    }
+
+    @Override // android.graphics.drawable.Drawable
+    public final boolean setState(int[] iArr) {
+        Drawable drawable = this.f286a;
+        return drawable != null ? drawable.setState(iArr) : super.setState(iArr);
+    }
+}

apk_decompiled/sources/C0/h.java

@@ -0,0 +1,5 @@
+package C0;
+
+/* loaded from: classes.dex */
+public final class h extends l {
+}

apk_decompiled/sources/C0/i.java

@@ -0,0 +1,150 @@
+package C0;
+
+import B0.G;
+import android.graphics.Paint;
+
+/* loaded from: classes.dex */
+public final class i extends l {
+
+    /* renamed from: d, reason: collision with root package name */
+    public G f287d;
+
+    /* renamed from: e, reason: collision with root package name */
+    public float f288e;
+
+    /* renamed from: f, reason: collision with root package name */
+    public G f289f;
+
+    /* renamed from: g, reason: collision with root package name */
+    public float f290g;
+    public float h;
+    public float i;
+
+    /* renamed from: j, reason: collision with root package name */
+    public float f291j;
+
+    /* renamed from: k, reason: collision with root package name */
+    public float f292k;
+
+    /* renamed from: l, reason: collision with root package name */
+    public Paint.Cap f293l;
+
+    /* renamed from: m, reason: collision with root package name */
+    public Paint.Join f294m;
+
+    /* renamed from: n, reason: collision with root package name */
+    public float f295n;
+
+    @Override // C0.k
+    public final boolean a() {
+        return this.f289f.d() || this.f287d.d();
+    }
+
+    /* JADX WARN: Removed duplicated region for block: B:8:0x0027  */
+    @Override // C0.k
+    /*
+        Code decompiled incorrectly, please refer to instructions dump.
+        To view partially-correct add '--show-bad-code' argument
+    */
+    public final boolean b(int[] r6) {
+        /*
+            r5 = this;
+            B0.G r0 = r5.f289f
+            boolean r1 = r0.d()
+            r2 = 0
+            r3 = 1
+            if (r1 == 0) goto L1e
+            java.lang.Object r1 = r0.f104d
+            android.content.res.ColorStateList r1 = (android.content.res.ColorStateList) r1
+            int r4 = r1.getDefaultColor()
+            int r1 = r1.getColorForState(r6, r4)
+            int r4 = r0.f102b
+            if (r1 == r4) goto L1e
+            r0.f102b = r1
+            r0 = r3
+            goto L1f
+        L1e:
+            r0 = r2
+        L1f:
+            B0.G r5 = r5.f287d
+            boolean r1 = r5.d()
+            if (r1 == 0) goto L3a
+            java.lang.Object r1 = r5.f104d
+            android.content.res.ColorStateList r1 = (android.content.res.ColorStateList) r1
+            int r4 = r1.getDefaultColor()
+            int r6 = r1.getColorForState(r6, r4)
+            int r1 = r5.f102b
+            if (r6 == r1) goto L3a
+            r5.f102b = r6
+            r2 = r3
+        L3a:
+            r5 = r0 | r2
+            return r5
+        */
+        throw new UnsupportedOperationException("Method not decompiled: C0.i.b(int[]):boolean");
+    }
+
+    public float getFillAlpha() {
+        return this.h;
+    }
+
+    public int getFillColor() {
+        return this.f289f.f102b;
+    }
+
+    public float getStrokeAlpha() {
+        return this.f290g;
+    }
+
+    public int getStrokeColor() {
+        return this.f287d.f102b;
+    }
+
+    public float getStrokeWidth() {
+        return this.f288e;
+    }
+
+    public float getTrimPathEnd() {
+        return this.f291j;
+    }
+
+    public float getTrimPathOffset() {
+        return this.f292k;
+    }
+
+    public float getTrimPathStart() {
+        return this.i;
+    }
+
+    public void setFillAlpha(float f2) {
+        this.h = f2;
+    }
+
+    public void setFillColor(int i) {
+        this.f289f.f102b = i;
+    }
+
+    public void setStrokeAlpha(float f2) {
+        this.f290g = f2;
+    }
+
+    public void setStrokeColor(int i) {
+        this.f287d.f102b = i;
+    }
+
+    public void setStrokeWidth(float f2) {
+        this.f288e = f2;
+    }
+
+    public void setTrimPathEnd(float f2) {
+        this.f291j = f2;
+    }
+
+    public void setTrimPathOffset(float f2) {
+        this.f292k = f2;
+    }
+
+    public void setTrimPathStart(float f2) {
+        this.i = f2;
+    }
+}

apk_decompiled/sources/C0/j.java

@@ -0,0 +1,249 @@
+package C0;
+
+import android.graphics.Matrix;
+import android.graphics.Paint;
+import com.google.android.gms.maps.model.BitmapDescriptorFactory;
+import java.util.ArrayList;
+
+/* loaded from: classes.dex */
+public final class j extends k {
+
+    /* renamed from: a, reason: collision with root package name */
+    public final Matrix f296a;
+
+    /* renamed from: b, reason: collision with root package name */
+    public final ArrayList f297b;
+
+    /* renamed from: c, reason: collision with root package name */
+    public float f298c;
+
+    /* renamed from: d, reason: collision with root package name */
+    public float f299d;
+
+    /* renamed from: e, reason: collision with root package name */
+    public float f300e;
+
+    /* renamed from: f, reason: collision with root package name */
+    public float f301f;
+
+    /* renamed from: g, reason: collision with root package name */
+    public float f302g;
+    public float h;
+    public float i;
+
+    /* renamed from: j, reason: collision with root package name */
+    public final Matrix f303j;
+
+    /* renamed from: k, reason: collision with root package name */
+    public String f304k;
+
+    public j() {
+        this.f296a = new Matrix();
+        this.f297b = new ArrayList();
+        this.f298c = BitmapDescriptorFactory.HUE_RED;
+        this.f299d = BitmapDescriptorFactory.HUE_RED;
+        this.f300e = BitmapDescriptorFactory.HUE_RED;
+        this.f301f = 1.0f;
+        this.f302g = 1.0f;
+        this.h = BitmapDescriptorFactory.HUE_RED;
+        this.i = BitmapDescriptorFactory.HUE_RED;
+        this.f303j = new Matrix();
+        this.f304k = null;
+    }
+
+    @Override // C0.k
+    public final boolean a() {
+        int i = 0;
+        while (true) {
+            ArrayList arrayList = this.f297b;
+            if (i >= arrayList.size()) {
+                return false;
+            }
+            if (((k) arrayList.get(i)).a()) {
+                return true;
+            }
+            i++;
+        }
+    }
+
+    @Override // C0.k
+    public final boolean b(int[] iArr) {
+        int i = 0;
+        boolean z3 = false;
+        while (true) {
+            ArrayList arrayList = this.f297b;
+            if (i >= arrayList.size()) {
+                return z3;
+            }
+            z3 |= ((k) arrayList.get(i)).b(iArr);
+            i++;
+        }
+    }
+
+    public final void c() {
+        Matrix matrix = this.f303j;
+        matrix.reset();
+        matrix.postTranslate(-this.f299d, -this.f300e);
+        matrix.postScale(this.f301f, this.f302g);
+        matrix.postRotate(this.f298c, BitmapDescriptorFactory.HUE_RED, BitmapDescriptorFactory.HUE_RED);
+        matrix.postTranslate(this.h + this.f299d, this.i + this.f300e);
+    }
+
+    public String getGroupName() {
+        return this.f304k;
+    }
+
+    public Matrix getLocalMatrix() {
+        return this.f303j;
+    }
+
+    public float getPivotX() {
+        return this.f299d;
+    }
+
+    public float getPivotY() {
+        return this.f300e;
+    }
+
+    public float getRotation() {
+        return this.f298c;
+    }
+
+    public float getScaleX() {
+        return this.f301f;
+    }
+
+    public float getScaleY() {
+        return this.f302g;
+    }
+
+    public float getTranslateX() {
+        return this.h;
+    }
+
+    public float getTranslateY() {
+        return this.i;
+    }
+
+    public void setPivotX(float f2) {
+        if (f2 != this.f299d) {
+            this.f299d = f2;
+            c();
+        }
+    }
+
+    public void setPivotY(float f2) {
+        if (f2 != this.f300e) {
+            this.f300e = f2;
+            c();
+        }
+    }
+
+    public void setRotation(float f2) {
+        if (f2 != this.f298c) {
+            this.f298c = f2;
+            c();
+        }
+    }
+
+    public void setScaleX(float f2) {
+        if (f2 != this.f301f) {
+            this.f301f = f2;
+            c();
+        }
+    }
+
+    public void setScaleY(float f2) {
+        if (f2 != this.f302g) {
+            this.f302g = f2;
+            c();
+        }
+    }
+
+    public void setTranslateX(float f2) {
+        if (f2 != this.h) {
+            this.h = f2;
+            c();
+        }
+    }
+
+    public void setTranslateY(float f2) {
+        if (f2 != this.i) {
+            this.i = f2;
+            c();
+        }
+    }
+
+    /* JADX WARN: Type inference failed for: r4v5, types: [C0.l, C0.i] */
+    public j(j jVar, s.e eVar) {
+        l lVar;
+        this.f296a = new Matrix();
+        this.f297b = new ArrayList();
+        this.f298c = BitmapDescriptorFactory.HUE_RED;
+        this.f299d = BitmapDescriptorFactory.HUE_RED;
+        this.f300e = BitmapDescriptorFactory.HUE_RED;
+        this.f301f = 1.0f;
+        this.f302g = 1.0f;
+        this.h = BitmapDescriptorFactory.HUE_RED;
+        this.i = BitmapDescriptorFactory.HUE_RED;
+        Matrix matrix = new Matrix();
+        this.f303j = matrix;
+        this.f304k = null;
+        this.f298c = jVar.f298c;
+        this.f299d = jVar.f299d;
+        this.f300e = jVar.f300e;
+        this.f301f = jVar.f301f;
+        this.f302g = jVar.f302g;
+        this.h = jVar.h;
+        this.i = jVar.i;
+        String str = jVar.f304k;
+        this.f304k = str;
+        if (str != null) {
+            eVar.put(str, this);
+        }
+        matrix.set(jVar.f303j);
+        ArrayList arrayList = jVar.f297b;
+        for (int i = 0; i < arrayList.size(); i++) {
+            Object obj = arrayList.get(i);
+            if (obj instanceof j) {
+                this.f297b.add(new j((j) obj, eVar));
+            } else {
+                if (obj instanceof i) {
+                    i iVar = (i) obj;
+                    ?? lVar2 = new l(iVar);
+                    lVar2.f288e = BitmapDescriptorFactory.HUE_RED;
+                    lVar2.f290g = 1.0f;
+                    lVar2.h = 1.0f;
+                    lVar2.i = BitmapDescriptorFactory.HUE_RED;
+                    lVar2.f291j = 1.0f;
+                    lVar2.f292k = BitmapDescriptorFactory.HUE_RED;
+                    lVar2.f293l = Paint.Cap.BUTT;
+                    lVar2.f294m = Paint.Join.MITER;
+                    lVar2.f295n = 4.0f;
+                    lVar2.f287d = iVar.f287d;
+                    lVar2.f288e = iVar.f288e;
+                    lVar2.f290g = iVar.f290g;
+                    lVar2.f289f = iVar.f289f;
+                    lVar2.f307c = iVar.f307c;
+                    lVar2.h = iVar.h;
+                    lVar2.i = iVar.i;
+                    lVar2.f291j = iVar.f291j;
+                    lVar2.f292k = iVar.f292k;
+                    lVar2.f293l = iVar.f293l;
+                    lVar2.f294m = iVar.f294m;
+                    lVar2.f295n = iVar.f295n;
+                    lVar = lVar2;
+                } else if (obj instanceof h) {
+                    lVar = new l((h) obj);
+                } else {
+                    throw new IllegalStateException("Unknown object in the tree!");
+                }
+                this.f297b.add(lVar);
+                Object obj2 = lVar.f306b;
+                if (obj2 != null) {
+                    eVar.put(obj2, lVar);
+                }
+            }
+        }
+    }
+}

apk_decompiled/sources/C0/k.java

@@ -0,0 +1,12 @@
+package C0;
+
+/* loaded from: classes.dex */
+public abstract class k {
+    public boolean a() {
+        return false;
+    }
+
+    public boolean b(int[] iArr) {
+        return false;
+    }
+}

apk_decompiled/sources/C0/l.java

@@ -0,0 +1,74 @@
+package C0;
+
+import a.AbstractC0105a;
+
+/* loaded from: classes.dex */
+public abstract class l extends k {
+
+    /* renamed from: a, reason: collision with root package name */
+    public G.f[] f305a;
+
+    /* renamed from: b, reason: collision with root package name */
+    public String f306b;
+
+    /* renamed from: c, reason: collision with root package name */
+    public int f307c;
+
+    public l() {
+        this.f305a = null;
+        this.f307c = 0;
+    }
+
+    public G.f[] getPathData() {
+        return this.f305a;
+    }
+
+    public String getPathName() {
+        return this.f306b;
+    }
+
+    public void setPathData(G.f[] fVarArr) {
+        G.f[] fVarArr2 = this.f305a;
+        boolean z3 = false;
+        if (fVarArr2 != null && fVarArr != null && fVarArr2.length == fVarArr.length) {
+            int i = 0;
+            while (true) {
+                if (i >= fVarArr2.length) {
+                    z3 = true;
+                    break;
+                }
+                G.f fVar = fVarArr2[i];
+                char c4 = fVar.f563a;
+                G.f fVar2 = fVarArr[i];
+                if (c4 != fVar2.f563a || fVar.f564b.length != fVar2.f564b.length) {
+                    break;
+                } else {
+                    i++;
+                }
+            }
+        }
+        if (!z3) {
+            this.f305a = AbstractC0105a.q(fVarArr);
+            return;
+        }
+        G.f[] fVarArr3 = this.f305a;
+        for (int i4 = 0; i4 < fVarArr.length; i4++) {
+            fVarArr3[i4].f563a = fVarArr[i4].f563a;
+            int i5 = 0;
+            while (true) {
+                float[] fArr = fVarArr[i4].f564b;
+                if (i5 < fArr.length) {
+                    fVarArr3[i4].f564b[i5] = fArr[i5];
+                    i5++;
+                }
+            }
+        }
+    }
+
+    public l(l lVar) {
+        this.f305a = null;
+        this.f307c = 0;
+        this.f306b = lVar.f306b;
+        this.f305a = AbstractC0105a.q(lVar.f305a);
+    }
+}

apk_decompiled/sources/C0/m.java

@@ -0,0 +1,283 @@
+package C0;
+
+import B0.G;
+import android.graphics.Canvas;
+import android.graphics.Color;
+import android.graphics.Matrix;
+import android.graphics.Paint;
+import android.graphics.Path;
+import android.graphics.PathMeasure;
+import android.graphics.PorterDuff;
+import android.graphics.Shader;
+import com.google.android.gms.maps.model.BitmapDescriptorFactory;
+import java.util.ArrayList;
+import kotlin.KotlinVersion;
+
+/* loaded from: classes.dex */
+public final class m {
+    public static final Matrix p = new Matrix();
+
+    /* renamed from: a, reason: collision with root package name */
+    public final Path f308a;
+
+    /* renamed from: b, reason: collision with root package name */
+    public final Path f309b;
+
+    /* renamed from: c, reason: collision with root package name */
+    public final Matrix f310c;
+
+    /* renamed from: d, reason: collision with root package name */
+    public Paint f311d;
+
+    /* renamed from: e, reason: collision with root package name */
+    public Paint f312e;
+
+    /* renamed from: f, reason: collision with root package name */
+    public PathMeasure f313f;
+
+    /* renamed from: g, reason: collision with root package name */
+    public final j f314g;
+    public float h;
+    public float i;
+
+    /* renamed from: j, reason: collision with root package name */
+    public float f315j;
+
+    /* renamed from: k, reason: collision with root package name */
+    public float f316k;
+
+    /* renamed from: l, reason: collision with root package name */
+    public int f317l;
+
+    /* renamed from: m, reason: collision with root package name */
+    public String f318m;
+
+    /* renamed from: n, reason: collision with root package name */
+    public Boolean f319n;
+
+    /* renamed from: o, reason: collision with root package name */
+    public final s.e f320o;
+
+    /* JADX WARN: Type inference failed for: r0v4, types: [s.e, s.j] */
+    public m() {
+        this.f310c = new Matrix();
+        this.h = BitmapDescriptorFactory.HUE_RED;
+        this.i = BitmapDescriptorFactory.HUE_RED;
+        this.f315j = BitmapDescriptorFactory.HUE_RED;
+        this.f316k = BitmapDescriptorFactory.HUE_RED;
+        this.f317l = KotlinVersion.MAX_COMPONENT_VALUE;
+        this.f318m = null;
+        this.f319n = null;
+        this.f320o = new s.j(0);
+        this.f314g = new j();
+        this.f308a = new Path();
+        this.f309b = new Path();
+    }
+
+    /* JADX WARN: Multi-variable type inference failed */
+    public final void a(j jVar, Matrix matrix, Canvas canvas, int i, int i4) {
+        char c4;
+        float f2;
+        float f4;
+        int i5;
+        j jVar2 = jVar;
+        char c5 = 1;
+        jVar2.f296a.set(matrix);
+        Matrix matrix2 = jVar2.f296a;
+        matrix2.preConcat(jVar2.f303j);
+        canvas.save();
+        char c6 = 0;
+        int i6 = 0;
+        while (true) {
+            ArrayList arrayList = jVar2.f297b;
+            if (i6 >= arrayList.size()) {
+                canvas.restore();
+                return;
+            }
+            k kVar = (k) arrayList.get(i6);
+            if (kVar instanceof j) {
+                a((j) kVar, matrix2, canvas, i, i4);
+            } else if (kVar instanceof l) {
+                l lVar = (l) kVar;
+                float f5 = i / this.f315j;
+                float f6 = i4 / this.f316k;
+                float min = Math.min(f5, f6);
+                Matrix matrix3 = this.f310c;
+                matrix3.set(matrix2);
+                matrix3.postScale(f5, f6);
+                float[] fArr = {BitmapDescriptorFactory.HUE_RED, 1.0f, 1.0f, BitmapDescriptorFactory.HUE_RED};
+                matrix2.mapVectors(fArr);
+                float hypot = (float) Math.hypot(fArr[c6], fArr[c5]);
+                boolean z3 = c5;
+                boolean z4 = c6;
+                float hypot2 = (float) Math.hypot(fArr[2], fArr[3]);
+                float f7 = (fArr[z4 ? 1 : 0] * fArr[3]) - (fArr[z3 ? 1 : 0] * fArr[2]);
+                float max = Math.max(hypot, hypot2);
+                float abs = max > BitmapDescriptorFactory.HUE_RED ? Math.abs(f7) / max : 0.0f;
+                if (abs != BitmapDescriptorFactory.HUE_RED) {
+                    Path path = this.f308a;
+                    lVar.getClass();
+                    path.reset();
+                    G.f[] fVarArr = lVar.f305a;
+                    if (fVarArr != null) {
+                        G.f.b(fVarArr, path);
+                    }
+                    Path path2 = this.f309b;
+                    path2.reset();
+                    if (lVar instanceof h) {
+                        path2.setFillType(lVar.f307c == 0 ? Path.FillType.WINDING : Path.FillType.EVEN_ODD);
+                        path2.addPath(path, matrix3);
+                        canvas.clipPath(path2);
+                    } else {
+                        i iVar = (i) lVar;
+                        float f8 = iVar.i;
+                        if (f8 != BitmapDescriptorFactory.HUE_RED || iVar.f291j != 1.0f) {
+                            float f9 = iVar.f292k;
+                            float f10 = (f8 + f9) % 1.0f;
+                            float f11 = (iVar.f291j + f9) % 1.0f;
+                            if (this.f313f == null) {
+                                this.f313f = new PathMeasure();
+                            }
+                            this.f313f.setPath(path, z4);
+                            float length = this.f313f.getLength();
+                            float f12 = f10 * length;
+                            float f13 = f11 * length;
+                            path.reset();
+                            if (f12 > f13) {
+                                this.f313f.getSegment(f12, length, path, z3);
+                                f2 = 0.0f;
+                                this.f313f.getSegment(BitmapDescriptorFactory.HUE_RED, f13, path, z3);
+                            } else {
+                                f2 = 0.0f;
+                                this.f313f.getSegment(f12, f13, path, z3);
+                            }
+                            path.rLineTo(f2, f2);
+                        }
+                        path2.addPath(path, matrix3);
+                        G g4 = iVar.f289f;
+                        if ((((Shader) g4.f103c) == null && g4.f102b == 0) ? false : true) {
+                            if (this.f312e == null) {
+                                i5 = 16777215;
+                                Paint paint = new Paint(1);
+                                this.f312e = paint;
+                                paint.setStyle(Paint.Style.FILL);
+                            } else {
+                                i5 = 16777215;
+                            }
+                            Paint paint2 = this.f312e;
+                            Shader shader = (Shader) g4.f103c;
+                            if (shader != null) {
+                                shader.setLocalMatrix(matrix3);
+                                paint2.setShader(shader);
+                                paint2.setAlpha(Math.round(iVar.h * 255.0f));
+                                f4 = 255.0f;
+                            } else {
+                                paint2.setShader(null);
+                                paint2.setAlpha(KotlinVersion.MAX_COMPONENT_VALUE);
+                                int i7 = g4.f102b;
+                                float f14 = iVar.h;
+                                PorterDuff.Mode mode = p.f332j;
+                                f4 = 255.0f;
+                                paint2.setColor((i7 & i5) | (((int) (Color.alpha(i7) * f14)) << 24));
+                            }
+                            paint2.setColorFilter(null);
+                            path2.setFillType(iVar.f307c == 0 ? Path.FillType.WINDING : Path.FillType.EVEN_ODD);
+                            canvas.drawPath(path2, paint2);
+                        } else {
+                            f4 = 255.0f;
+                            i5 = 16777215;
+                        }
+                        G g5 = iVar.f287d;
+                        if (((Shader) g5.f103c) != null || g5.f102b != 0) {
+                            if (this.f311d == null) {
+                                Paint paint3 = new Paint(1);
+                                this.f311d = paint3;
+                                paint3.setStyle(Paint.Style.STROKE);
+                            }
+                            Paint paint4 = this.f311d;
+                            Paint.Join join = iVar.f294m;
+                            if (join != null) {
+                                paint4.setStrokeJoin(join);
+                            }
+                            Paint.Cap cap = iVar.f293l;
+                            if (cap != null) {
+                                paint4.setStrokeCap(cap);
+                            }
+                            paint4.setStrokeMiter(iVar.f295n);
+                            Shader shader2 = (Shader) g5.f103c;
+                            if (shader2 != null) {
+                                shader2.setLocalMatrix(matrix3);
+                                paint4.setShader(shader2);
+                                paint4.setAlpha(Math.round(iVar.f290g * f4));
+                            } else {
+                                paint4.setShader(null);
+                                paint4.setAlpha(KotlinVersion.MAX_COMPONENT_VALUE);
+                                int i8 = g5.f102b;
+                                float f15 = iVar.f290g;
+                                PorterDuff.Mode mode2 = p.f332j;
+                                paint4.setColor((i8 & i5) | (((int) (Color.alpha(i8) * f15)) << 24));
+                            }
+                            paint4.setColorFilter(null);
+                            paint4.setStrokeWidth(iVar.f288e * min * abs);
+                            canvas.drawPath(path2, paint4);
+                        }
+                    }
+                }
+                c4 = 1;
+                i6++;
+                jVar2 = jVar;
+                c5 = c4;
+                c6 = 0;
+            }
+            c4 = c5;
+            i6++;
+            jVar2 = jVar;
+            c5 = c4;
+            c6 = 0;
+        }
+    }
+
+    public float getAlpha() {
+        return getRootAlpha() / 255.0f;
+    }
+
+    public int getRootAlpha() {
+        return this.f317l;
+    }
+
+    public void setAlpha(float f2) {
+        setRootAlpha((int) (f2 * 255.0f));
+    }
+
+    public void setRootAlpha(int i) {
+        this.f317l = i;
+    }
+
+    /* JADX WARN: Type inference failed for: r0v4, types: [s.e, s.j] */
+    public m(m mVar) {
+        this.f310c = new Matrix();
+        this.h = BitmapDescriptorFactory.HUE_RED;
+        this.i = BitmapDescriptorFactory.HUE_RED;
+        this.f315j = BitmapDescriptorFactory.HUE_RED;
+        this.f316k = BitmapDescriptorFactory.HUE_RED;
+        this.f317l = KotlinVersion.MAX_COMPONENT_VALUE;
+        this.f318m = null;
+        this.f319n = null;
+        ?? jVar = new s.j(0);
+        this.f320o = jVar;
+        this.f314g = new j(mVar.f314g, jVar);
+        this.f308a = new Path(mVar.f308a);
+        this.f309b = new Path(mVar.f309b);
+        this.h = mVar.h;
+        this.i = mVar.i;
+        this.f315j = mVar.f315j;
+        this.f316k = mVar.f316k;
+        this.f317l = mVar.f317l;
+        this.f318m = mVar.f318m;
+        String str = mVar.f318m;
+        if (str != null) {
+            jVar.put(str, this);
+        }
+        this.f319n = mVar.f319n;
+    }
+}

apk_decompiled/sources/C0/n.java

@@ -0,0 +1,59 @@
+package C0;
+
+import android.content.res.ColorStateList;
+import android.content.res.Resources;
+import android.graphics.Bitmap;
+import android.graphics.Paint;
+import android.graphics.PorterDuff;
+import android.graphics.drawable.Drawable;
+
+/* loaded from: classes.dex */
+public final class n extends Drawable.ConstantState {
+
+    /* renamed from: a, reason: collision with root package name */
+    public int f321a;
+
+    /* renamed from: b, reason: collision with root package name */
+    public m f322b;
+
+    /* renamed from: c, reason: collision with root package name */
+    public ColorStateList f323c;
+
+    /* renamed from: d, reason: collision with root package name */
+    public PorterDuff.Mode f324d;
+
+    /* renamed from: e, reason: collision with root package name */
+    public boolean f325e;
+
+    /* renamed from: f, reason: collision with root package name */
+    public Bitmap f326f;
+
+    /* renamed from: g, reason: collision with root package name */
+    public ColorStateList f327g;
+    public PorterDuff.Mode h;
+    public int i;
+
+    /* renamed from: j, reason: collision with root package name */
+    public boolean f328j;
+
+    /* renamed from: k, reason: collision with root package name */
+    public boolean f329k;
+
+    /* renamed from: l, reason: collision with root package name */
+    public Paint f330l;
+
+    @Override // android.graphics.drawable.Drawable.ConstantState
+    public int getChangingConfigurations() {
+        return this.f321a;
+    }
+
+    @Override // android.graphics.drawable.Drawable.ConstantState
+    public final Drawable newDrawable() {
+        return new p(this);
+    }
+
+    @Override // android.graphics.drawable.Drawable.ConstantState
+    public final Drawable newDrawable(Resources resources) {
+        return new p(this);
+    }
+}

apk_decompiled/sources/C0/o.java

@@ -0,0 +1,47 @@
+package C0;
+
+import android.content.res.Resources;
+import android.graphics.drawable.Drawable;
+import android.graphics.drawable.VectorDrawable;
+
+/* loaded from: classes.dex */
+public final class o extends Drawable.ConstantState {
+
+    /* renamed from: a, reason: collision with root package name */
+    public final Drawable.ConstantState f331a;
+
+    public o(Drawable.ConstantState constantState) {
+        this.f331a = constantState;
+    }
+
+    @Override // android.graphics.drawable.Drawable.ConstantState
+    public final boolean canApplyTheme() {
+        return this.f331a.canApplyTheme();
+    }
+
+    @Override // android.graphics.drawable.Drawable.ConstantState
+    public int getChangingConfigurations() {
+        return this.f331a.getChangingConfigurations();
+    }
+
+    @Override // android.graphics.drawable.Drawable.ConstantState
+    public final Drawable newDrawable() {
+        p pVar = new p();
+        pVar.f286a = (VectorDrawable) this.f331a.newDrawable();
+        return pVar;
+    }
+
+    @Override // android.graphics.drawable.Drawable.ConstantState
+    public final Drawable newDrawable(Resources resources) {
+        p pVar = new p();
+        pVar.f286a = (VectorDrawable) this.f331a.newDrawable(resources);
+        return pVar;
+    }
+
+    @Override // android.graphics.drawable.Drawable.ConstantState
+    public final Drawable newDrawable(Resources resources, Resources.Theme theme) {
+        p pVar = new p();
+        pVar.f286a = (VectorDrawable) this.f331a.newDrawable(resources, theme);
+        return pVar;
+    }
+}

apk_decompiled/sources/C0/p.java

@@ -0,0 +1,763 @@
+package C0;
+
+import a.AbstractC0105a;
+import android.content.res.ColorStateList;
+import android.content.res.Resources;
+import android.content.res.TypedArray;
+import android.graphics.Bitmap;
+import android.graphics.Canvas;
+import android.graphics.ColorFilter;
+import android.graphics.Matrix;
+import android.graphics.Paint;
+import android.graphics.PorterDuff;
+import android.graphics.PorterDuffColorFilter;
+import android.graphics.Rect;
+import android.graphics.drawable.Drawable;
+import android.util.AttributeSet;
+import android.util.Log;
+import android.util.TypedValue;
+import com.adif.elcanomovil.commonNavGraph.arguments.NavArguments;
+import com.google.android.gms.maps.model.BitmapDescriptorFactory;
+import java.util.ArrayDeque;
+import org.xmlpull.v1.XmlPullParser;
+import org.xmlpull.v1.XmlPullParserException;
+
+/* loaded from: classes.dex */
+public final class p extends g {
+
+    /* renamed from: j, reason: collision with root package name */
+    public static final PorterDuff.Mode f332j = PorterDuff.Mode.SRC_IN;
+
+    /* renamed from: b, reason: collision with root package name */
+    public n f333b;
+
+    /* renamed from: c, reason: collision with root package name */
+    public PorterDuffColorFilter f334c;
+
+    /* renamed from: d, reason: collision with root package name */
+    public ColorFilter f335d;
+
+    /* renamed from: e, reason: collision with root package name */
+    public boolean f336e;
+
+    /* renamed from: f, reason: collision with root package name */
+    public boolean f337f;
+
+    /* renamed from: g, reason: collision with root package name */
+    public final float[] f338g;
+    public final Matrix h;
+    public final Rect i;
+
+    /* JADX WARN: Type inference failed for: r0v5, types: [android.graphics.drawable.Drawable$ConstantState, C0.n] */
+    public p() {
+        this.f337f = true;
+        this.f338g = new float[9];
+        this.h = new Matrix();
+        this.i = new Rect();
+        ?? constantState = new Drawable.ConstantState();
+        constantState.f323c = null;
+        constantState.f324d = f332j;
+        constantState.f322b = new m();
+        this.f333b = constantState;
+    }
+
+    public final PorterDuffColorFilter a(ColorStateList colorStateList, PorterDuff.Mode mode) {
+        if (colorStateList == null || mode == null) {
+            return null;
+        }
+        return new PorterDuffColorFilter(colorStateList.getColorForState(getState(), 0), mode);
+    }
+
+    @Override // android.graphics.drawable.Drawable
+    public final boolean canApplyTheme() {
+        Drawable drawable = this.f286a;
+        if (drawable == null) {
+            return false;
+        }
+        H.a.b(drawable);
+        return false;
+    }
+
+    @Override // android.graphics.drawable.Drawable
+    public final void draw(Canvas canvas) {
+        Paint paint;
+        Drawable drawable = this.f286a;
+        if (drawable != null) {
+            drawable.draw(canvas);
+            return;
+        }
+        Rect rect = this.i;
+        copyBounds(rect);
+        if (rect.width() <= 0 || rect.height() <= 0) {
+            return;
+        }
+        ColorFilter colorFilter = this.f335d;
+        if (colorFilter == null) {
+            colorFilter = this.f334c;
+        }
+        Matrix matrix = this.h;
+        canvas.getMatrix(matrix);
+        float[] fArr = this.f338g;
+        matrix.getValues(fArr);
+        float abs = Math.abs(fArr[0]);
+        float abs2 = Math.abs(fArr[4]);
+        float abs3 = Math.abs(fArr[1]);
+        float abs4 = Math.abs(fArr[3]);
+        if (abs3 != BitmapDescriptorFactory.HUE_RED || abs4 != BitmapDescriptorFactory.HUE_RED) {
+            abs = 1.0f;
+            abs2 = 1.0f;
+        }
+        int width = (int) (rect.width() * abs);
+        int min = Math.min(2048, width);
+        int min2 = Math.min(2048, (int) (rect.height() * abs2));
+        if (min <= 0 || min2 <= 0) {
+            return;
+        }
+        int save = canvas.save();
+        canvas.translate(rect.left, rect.top);
+        if (isAutoMirrored() && H.b.a(this) == 1) {
+            canvas.translate(rect.width(), BitmapDescriptorFactory.HUE_RED);
+            canvas.scale(-1.0f, 1.0f);
+        }
+        rect.offsetTo(0, 0);
+        n nVar = this.f333b;
+        Bitmap bitmap = nVar.f326f;
+        if (bitmap == null || min != bitmap.getWidth() || min2 != nVar.f326f.getHeight()) {
+            nVar.f326f = Bitmap.createBitmap(min, min2, Bitmap.Config.ARGB_8888);
+            nVar.f329k = true;
+        }
+        if (this.f337f) {
+            n nVar2 = this.f333b;
+            if (nVar2.f329k || nVar2.f327g != nVar2.f323c || nVar2.h != nVar2.f324d || nVar2.f328j != nVar2.f325e || nVar2.i != nVar2.f322b.getRootAlpha()) {
+                n nVar3 = this.f333b;
+                nVar3.f326f.eraseColor(0);
+                Canvas canvas2 = new Canvas(nVar3.f326f);
+                m mVar = nVar3.f322b;
+                mVar.a(mVar.f314g, m.p, canvas2, min, min2);
+                n nVar4 = this.f333b;
+                nVar4.f327g = nVar4.f323c;
+                nVar4.h = nVar4.f324d;
+                nVar4.i = nVar4.f322b.getRootAlpha();
+                nVar4.f328j = nVar4.f325e;
+                nVar4.f329k = false;
+            }
+        } else {
+            n nVar5 = this.f333b;
+            nVar5.f326f.eraseColor(0);
+            Canvas canvas3 = new Canvas(nVar5.f326f);
+            m mVar2 = nVar5.f322b;
+            mVar2.a(mVar2.f314g, m.p, canvas3, min, min2);
+        }
+        n nVar6 = this.f333b;
+        if (nVar6.f322b.getRootAlpha() >= 255 && colorFilter == null) {
+            paint = null;
+        } else {
+            if (nVar6.f330l == null) {
+                Paint paint2 = new Paint();
+                nVar6.f330l = paint2;
+                paint2.setFilterBitmap(true);
+            }
+            nVar6.f330l.setAlpha(nVar6.f322b.getRootAlpha());
+            nVar6.f330l.setColorFilter(colorFilter);
+            paint = nVar6.f330l;
+        }
+        canvas.drawBitmap(nVar6.f326f, (Rect) null, rect, paint);
+        canvas.restoreToCount(save);
+    }
+
+    @Override // android.graphics.drawable.Drawable
+    public final int getAlpha() {
+        Drawable drawable = this.f286a;
+        return drawable != null ? drawable.getAlpha() : this.f333b.f322b.getRootAlpha();
+    }
+
+    @Override // android.graphics.drawable.Drawable
+    public final int getChangingConfigurations() {
+        Drawable drawable = this.f286a;
+        if (drawable != null) {
+            return drawable.getChangingConfigurations();
+        }
+        return this.f333b.getChangingConfigurations() | super.getChangingConfigurations();
+    }
+
+    @Override // android.graphics.drawable.Drawable
+    public final ColorFilter getColorFilter() {
+        Drawable drawable = this.f286a;
+        return drawable != null ? H.a.c(drawable) : this.f335d;
+    }
+
+    @Override // android.graphics.drawable.Drawable
+    public final Drawable.ConstantState getConstantState() {
+        if (this.f286a != null) {
+            return new o(this.f286a.getConstantState());
+        }
+        this.f333b.f321a = getChangingConfigurations();
+        return this.f333b;
+    }
+
+    @Override // android.graphics.drawable.Drawable
+    public final int getIntrinsicHeight() {
+        Drawable drawable = this.f286a;
+        return drawable != null ? drawable.getIntrinsicHeight() : (int) this.f333b.f322b.i;
+    }
+
+    @Override // android.graphics.drawable.Drawable
+    public final int getIntrinsicWidth() {
+        Drawable drawable = this.f286a;
+        return drawable != null ? drawable.getIntrinsicWidth() : (int) this.f333b.f322b.h;
+    }
+
+    @Override // android.graphics.drawable.Drawable
+    public final int getOpacity() {
+        Drawable drawable = this.f286a;
+        if (drawable != null) {
+            return drawable.getOpacity();
+        }
+        return -3;
+    }
+
+    @Override // android.graphics.drawable.Drawable
+    public final void inflate(Resources resources, XmlPullParser xmlPullParser, AttributeSet attributeSet) {
+        Drawable drawable = this.f286a;
+        if (drawable != null) {
+            drawable.inflate(resources, xmlPullParser, attributeSet);
+        } else {
+            inflate(resources, xmlPullParser, attributeSet, null);
+        }
+    }
+
+    @Override // android.graphics.drawable.Drawable
+    public final void invalidateSelf() {
+        Drawable drawable = this.f286a;
+        if (drawable != null) {
+            drawable.invalidateSelf();
+        } else {
+            super.invalidateSelf();
+        }
+    }
+
+    @Override // android.graphics.drawable.Drawable
+    public final boolean isAutoMirrored() {
+        Drawable drawable = this.f286a;
+        return drawable != null ? drawable.isAutoMirrored() : this.f333b.f325e;
+    }
+
+    @Override // android.graphics.drawable.Drawable
+    public final boolean isStateful() {
+        Drawable drawable = this.f286a;
+        if (drawable != null) {
+            return drawable.isStateful();
+        }
+        if (super.isStateful()) {
+            return true;
+        }
+        n nVar = this.f333b;
+        if (nVar == null) {
+            return false;
+        }
+        m mVar = nVar.f322b;
+        if (mVar.f319n == null) {
+            mVar.f319n = Boolean.valueOf(mVar.f314g.a());
+        }
+        if (mVar.f319n.booleanValue()) {
+            return true;
+        }
+        ColorStateList colorStateList = this.f333b.f323c;
+        return colorStateList != null && colorStateList.isStateful();
+    }
+
+    /* JADX WARN: Type inference failed for: r0v3, types: [android.graphics.drawable.Drawable$ConstantState, C0.n] */
+    @Override // android.graphics.drawable.Drawable
+    public final Drawable mutate() {
+        Drawable drawable = this.f286a;
+        if (drawable != null) {
+            drawable.mutate();
+            return this;
+        }
+        if (!this.f336e && super.mutate() == this) {
+            n nVar = this.f333b;
+            ?? constantState = new Drawable.ConstantState();
+            constantState.f323c = null;
+            constantState.f324d = f332j;
+            if (nVar != null) {
+                constantState.f321a = nVar.f321a;
+                m mVar = new m(nVar.f322b);
+                constantState.f322b = mVar;
+                if (nVar.f322b.f312e != null) {
+                    mVar.f312e = new Paint(nVar.f322b.f312e);
+                }
+                if (nVar.f322b.f311d != null) {
+                    constantState.f322b.f311d = new Paint(nVar.f322b.f311d);
+                }
+                constantState.f323c = nVar.f323c;
+                constantState.f324d = nVar.f324d;
+                constantState.f325e = nVar.f325e;
+            }
+            this.f333b = constantState;
+            this.f336e = true;
+        }
+        return this;
+    }
+
+    @Override // android.graphics.drawable.Drawable
+    public final void onBoundsChange(Rect rect) {
+        Drawable drawable = this.f286a;
+        if (drawable != null) {
+            drawable.setBounds(rect);
+        }
+    }
+
+    @Override // android.graphics.drawable.Drawable
+    public final boolean onStateChange(int[] iArr) {
+        boolean z3;
+        PorterDuff.Mode mode;
+        Drawable drawable = this.f286a;
+        if (drawable != null) {
+            return drawable.setState(iArr);
+        }
+        n nVar = this.f333b;
+        ColorStateList colorStateList = nVar.f323c;
+        if (colorStateList == null || (mode = nVar.f324d) == null) {
+            z3 = false;
+        } else {
+            this.f334c = a(colorStateList, mode);
+            invalidateSelf();
+            z3 = true;
+        }
+        m mVar = nVar.f322b;
+        if (mVar.f319n == null) {
+            mVar.f319n = Boolean.valueOf(mVar.f314g.a());
+        }
+        if (mVar.f319n.booleanValue()) {
+            boolean b4 = nVar.f322b.f314g.b(iArr);
+            nVar.f329k |= b4;
+            if (b4) {
+                invalidateSelf();
+                return true;
+            }
+        }
+        return z3;
+    }
+
+    @Override // android.graphics.drawable.Drawable
+    public final void scheduleSelf(Runnable runnable, long j4) {
+        Drawable drawable = this.f286a;
+        if (drawable != null) {
+            drawable.scheduleSelf(runnable, j4);
+        } else {
+            super.scheduleSelf(runnable, j4);
+        }
+    }
+
+    @Override // android.graphics.drawable.Drawable
+    public final void setAlpha(int i) {
+        Drawable drawable = this.f286a;
+        if (drawable != null) {
+            drawable.setAlpha(i);
+        } else if (this.f333b.f322b.getRootAlpha() != i) {
+            this.f333b.f322b.setRootAlpha(i);
+            invalidateSelf();
+        }
+    }
+
+    @Override // android.graphics.drawable.Drawable
+    public final void setAutoMirrored(boolean z3) {
+        Drawable drawable = this.f286a;
+        if (drawable != null) {
+            drawable.setAutoMirrored(z3);
+        } else {
+            this.f333b.f325e = z3;
+        }
+    }
+
+    @Override // android.graphics.drawable.Drawable
+    public final void setColorFilter(ColorFilter colorFilter) {
+        Drawable drawable = this.f286a;
+        if (drawable != null) {
+            drawable.setColorFilter(colorFilter);
+        } else {
+            this.f335d = colorFilter;
+            invalidateSelf();
+        }
+    }
+
+    @Override // android.graphics.drawable.Drawable
+    public final void setTint(int i) {
+        Drawable drawable = this.f286a;
+        if (drawable != null) {
+            m3.d.J(drawable, i);
+        } else {
+            setTintList(ColorStateList.valueOf(i));
+        }
+    }
+
+    @Override // android.graphics.drawable.Drawable
+    public final void setTintList(ColorStateList colorStateList) {
+        Drawable drawable = this.f286a;
+        if (drawable != null) {
+            H.a.h(drawable, colorStateList);
+            return;
+        }
+        n nVar = this.f333b;
+        if (nVar.f323c != colorStateList) {
+            nVar.f323c = colorStateList;
+            this.f334c = a(colorStateList, nVar.f324d);
+            invalidateSelf();
+        }
+    }
+
+    @Override // android.graphics.drawable.Drawable
+    public final void setTintMode(PorterDuff.Mode mode) {
+        Drawable drawable = this.f286a;
+        if (drawable != null) {
+            H.a.i(drawable, mode);
+            return;
+        }
+        n nVar = this.f333b;
+        if (nVar.f324d != mode) {
+            nVar.f324d = mode;
+            this.f334c = a(nVar.f323c, mode);
+            invalidateSelf();
+        }
+    }
+
+    @Override // android.graphics.drawable.Drawable
+    public final boolean setVisible(boolean z3, boolean z4) {
+        Drawable drawable = this.f286a;
+        return drawable != null ? drawable.setVisible(z3, z4) : super.setVisible(z3, z4);
+    }
+
+    @Override // android.graphics.drawable.Drawable
+    public final void unscheduleSelf(Runnable runnable) {
+        Drawable drawable = this.f286a;
+        if (drawable != null) {
+            drawable.unscheduleSelf(runnable);
+        } else {
+            super.unscheduleSelf(runnable);
+        }
+    }
+
+    /* JADX WARN: Multi-variable type inference failed */
+    /* JADX WARN: Type inference failed for: r9v19, types: [C0.l, C0.i, java.lang.Object] */
+    @Override // android.graphics.drawable.Drawable
+    public final void inflate(Resources resources, XmlPullParser xmlPullParser, AttributeSet attributeSet, Resources.Theme theme) {
+        m mVar;
+        int i;
+        boolean z3;
+        char c4;
+        int i4;
+        Paint.Cap cap;
+        Paint.Join join;
+        Drawable drawable = this.f286a;
+        if (drawable != null) {
+            H.a.d(drawable, resources, xmlPullParser, attributeSet, theme);
+            return;
+        }
+        n nVar = this.f333b;
+        nVar.f322b = new m();
+        TypedArray f2 = F.b.f(resources, theme, attributeSet, a.f268a);
+        n nVar2 = this.f333b;
+        m mVar2 = nVar2.f322b;
+        int i5 = !F.b.c(xmlPullParser, "tintMode") ? -1 : f2.getInt(6, -1);
+        PorterDuff.Mode mode = PorterDuff.Mode.SRC_IN;
+        if (i5 == 3) {
+            mode = PorterDuff.Mode.SRC_OVER;
+        } else if (i5 != 5) {
+            if (i5 != 9) {
+                switch (i5) {
+                    case 14:
+                        mode = PorterDuff.Mode.MULTIPLY;
+                        break;
+                    case 15:
+                        mode = PorterDuff.Mode.SCREEN;
+                        break;
+                    case 16:
+                        mode = PorterDuff.Mode.ADD;
+                        break;
+                }
+            } else {
+                mode = PorterDuff.Mode.SRC_ATOP;
+            }
+        }
+        nVar2.f324d = mode;
+        int i6 = 1;
+        ColorStateList colorStateList = null;
+        if (xmlPullParser.getAttributeValue("http://schemas.android.com/apk/res/android", "tint") != null) {
+            TypedValue typedValue = new TypedValue();
+            f2.getValue(1, typedValue);
+            int i7 = typedValue.type;
+            if (i7 == 2) {
+                throw new UnsupportedOperationException("Failed to resolve attribute at index 1: " + typedValue);
+            }
+            if (i7 >= 28 && i7 <= 31) {
+                colorStateList = ColorStateList.valueOf(typedValue.data);
+            } else {
+                Resources resources2 = f2.getResources();
+                int resourceId = f2.getResourceId(1, 0);
+                ThreadLocal threadLocal = F.c.f478a;
+                try {
+                    colorStateList = F.c.a(resources2, resources2.getXml(resourceId), theme);
+                } catch (Exception e4) {
+                    Log.e("CSLCompat", "Failed to inflate ColorStateList.", e4);
+                }
+            }
+        }
+        ColorStateList colorStateList2 = colorStateList;
+        if (colorStateList2 != null) {
+            nVar2.f323c = colorStateList2;
+        }
+        boolean z4 = nVar2.f325e;
+        if (xmlPullParser.getAttributeValue("http://schemas.android.com/apk/res/android", "autoMirrored") != null) {
+            z4 = f2.getBoolean(5, z4);
+        }
+        nVar2.f325e = z4;
+        float f4 = mVar2.f315j;
+        if (xmlPullParser.getAttributeValue("http://schemas.android.com/apk/res/android", "viewportWidth") != null) {
+            f4 = f2.getFloat(7, f4);
+        }
+        mVar2.f315j = f4;
+        float f5 = mVar2.f316k;
+        if (xmlPullParser.getAttributeValue("http://schemas.android.com/apk/res/android", "viewportHeight") != null) {
+            f5 = f2.getFloat(8, f5);
+        }
+        mVar2.f316k = f5;
+        boolean z5 = false;
+        if (mVar2.f315j <= BitmapDescriptorFactory.HUE_RED) {
+            throw new XmlPullParserException(f2.getPositionDescription() + "<vector> tag requires viewportWidth > 0");
+        }
+        if (f5 > BitmapDescriptorFactory.HUE_RED) {
+            mVar2.h = f2.getDimension(3, mVar2.h);
+            float dimension = f2.getDimension(2, mVar2.i);
+            mVar2.i = dimension;
+            if (mVar2.h <= BitmapDescriptorFactory.HUE_RED) {
+                throw new XmlPullParserException(f2.getPositionDescription() + "<vector> tag requires width > 0");
+            }
+            if (dimension > BitmapDescriptorFactory.HUE_RED) {
+                float alpha = mVar2.getAlpha();
+                if (xmlPullParser.getAttributeValue("http://schemas.android.com/apk/res/android", "alpha") != null) {
+                    alpha = f2.getFloat(4, alpha);
+                }
+                mVar2.setAlpha(alpha);
+                String string = f2.getString(0);
+                if (string != null) {
+                    mVar2.f318m = string;
+                    mVar2.f320o.put(string, mVar2);
+                }
+                f2.recycle();
+                nVar.f321a = getChangingConfigurations();
+                nVar.f329k = true;
+                n nVar3 = this.f333b;
+                m mVar3 = nVar3.f322b;
+                ArrayDeque arrayDeque = new ArrayDeque();
+                arrayDeque.push(mVar3.f314g);
+                int eventType = xmlPullParser.getEventType();
+                int depth = xmlPullParser.getDepth() + 1;
+                boolean z6 = true;
+                while (eventType != i6 && (xmlPullParser.getDepth() >= depth || eventType != 3)) {
+                    if (eventType == 2) {
+                        String name = xmlPullParser.getName();
+                        j jVar = (j) arrayDeque.peek();
+                        boolean equals = NavArguments.ARG_DYNAMIC_LINKS_TAB.equals(name);
+                        i = depth;
+                        s.e eVar = mVar3.f320o;
+                        if (equals) {
+                            ?? lVar = new l();
+                            lVar.f288e = BitmapDescriptorFactory.HUE_RED;
+                            lVar.f290g = 1.0f;
+                            lVar.h = 1.0f;
+                            mVar = mVar3;
+                            lVar.i = BitmapDescriptorFactory.HUE_RED;
+                            lVar.f291j = 1.0f;
+                            lVar.f292k = BitmapDescriptorFactory.HUE_RED;
+                            Paint.Cap cap2 = Paint.Cap.BUTT;
+                            lVar.f293l = cap2;
+                            Paint.Join join2 = Paint.Join.MITER;
+                            lVar.f294m = join2;
+                            lVar.f295n = 4.0f;
+                            TypedArray f6 = F.b.f(resources, theme, attributeSet, a.f270c);
+                            if (xmlPullParser.getAttributeValue("http://schemas.android.com/apk/res/android", "pathData") != null) {
+                                String string2 = f6.getString(0);
+                                if (string2 != null) {
+                                    lVar.f306b = string2;
+                                }
+                                String string3 = f6.getString(2);
+                                if (string3 != null) {
+                                    lVar.f305a = AbstractC0105a.o(string3);
+                                }
+                                lVar.f289f = F.b.b(f6, xmlPullParser, theme, "fillColor", 1);
+                                float f7 = lVar.h;
+                                if (xmlPullParser.getAttributeValue("http://schemas.android.com/apk/res/android", "fillAlpha") != null) {
+                                    f7 = f6.getFloat(12, f7);
+                                }
+                                lVar.h = f7;
+                                int i8 = xmlPullParser.getAttributeValue("http://schemas.android.com/apk/res/android", "strokeLineCap") != null ? f6.getInt(8, -1) : -1;
+                                Paint.Cap cap3 = lVar.f293l;
+                                if (i8 == 0) {
+                                    cap = cap2;
+                                } else if (i8 != 1) {
+                                    cap = i8 != 2 ? cap3 : Paint.Cap.SQUARE;
+                                } else {
+                                    cap = Paint.Cap.ROUND;
+                                }
+                                lVar.f293l = cap;
+                                int i9 = xmlPullParser.getAttributeValue("http://schemas.android.com/apk/res/android", "strokeLineJoin") != null ? f6.getInt(9, -1) : -1;
+                                Paint.Join join3 = lVar.f294m;
+                                if (i9 == 0) {
+                                    join = join2;
+                                } else if (i9 != 1) {
+                                    join = i9 != 2 ? join3 : Paint.Join.BEVEL;
+                                } else {
+                                    join = Paint.Join.ROUND;
+                                }
+                                lVar.f294m = join;
+                                float f8 = lVar.f295n;
+                                if (xmlPullParser.getAttributeValue("http://schemas.android.com/apk/res/android", "strokeMiterLimit") != null) {
+                                    f8 = f6.getFloat(10, f8);
+                                }
+                                lVar.f295n = f8;
+                                lVar.f287d = F.b.b(f6, xmlPullParser, theme, "strokeColor", 3);
+                                float f9 = lVar.f290g;
+                                if (xmlPullParser.getAttributeValue("http://schemas.android.com/apk/res/android", "strokeAlpha") != null) {
+                                    f9 = f6.getFloat(11, f9);
+                                }
+                                lVar.f290g = f9;
+                                float f10 = lVar.f288e;
+                                if (xmlPullParser.getAttributeValue("http://schemas.android.com/apk/res/android", "strokeWidth") != null) {
+                                    f10 = f6.getFloat(4, f10);
+                                }
+                                lVar.f288e = f10;
+                                float f11 = lVar.f291j;
+                                if (xmlPullParser.getAttributeValue("http://schemas.android.com/apk/res/android", "trimPathEnd") != null) {
+                                    f11 = f6.getFloat(6, f11);
+                                }
+                                lVar.f291j = f11;
+                                float f12 = lVar.f292k;
+                                if (xmlPullParser.getAttributeValue("http://schemas.android.com/apk/res/android", "trimPathOffset") != null) {
+                                    f12 = f6.getFloat(7, f12);
+                                }
+                                lVar.f292k = f12;
+                                float f13 = lVar.i;
+                                if (xmlPullParser.getAttributeValue("http://schemas.android.com/apk/res/android", "trimPathStart") != null) {
+                                    f13 = f6.getFloat(5, f13);
+                                }
+                                lVar.i = f13;
+                                int i10 = lVar.f307c;
+                                if (xmlPullParser.getAttributeValue("http://schemas.android.com/apk/res/android", "fillType") != null) {
+                                    i10 = f6.getInt(13, i10);
+                                }
+                                lVar.f307c = i10;
+                            }
+                            f6.recycle();
+                            jVar.f297b.add(lVar);
+                            if (lVar.getPathName() != null) {
+                                eVar.put(lVar.getPathName(), lVar);
+                            }
+                            nVar3.f321a = nVar3.f321a;
+                            z6 = false;
+                            c4 = '\b';
+                            z3 = false;
+                        } else {
+                            mVar = mVar3;
+                            c4 = '\b';
+                            z3 = false;
+                            if ("clip-path".equals(name)) {
+                                l lVar2 = new l();
+                                if (xmlPullParser.getAttributeValue("http://schemas.android.com/apk/res/android", "pathData") != null) {
+                                    TypedArray f14 = F.b.f(resources, theme, attributeSet, a.f271d);
+                                    String string4 = f14.getString(0);
+                                    if (string4 != null) {
+                                        lVar2.f306b = string4;
+                                    }
+                                    String string5 = f14.getString(1);
+                                    if (string5 != null) {
+                                        lVar2.f305a = AbstractC0105a.o(string5);
+                                    }
+                                    lVar2.f307c = !F.b.c(xmlPullParser, "fillType") ? 0 : f14.getInt(2, 0);
+                                    f14.recycle();
+                                }
+                                jVar.f297b.add(lVar2);
+                                if (lVar2.getPathName() != null) {
+                                    eVar.put(lVar2.getPathName(), lVar2);
+                                }
+                                nVar3.f321a = nVar3.f321a;
+                            } else if ("group".equals(name)) {
+                                j jVar2 = new j();
+                                TypedArray f15 = F.b.f(resources, theme, attributeSet, a.f269b);
+                                float f16 = jVar2.f298c;
+                                if (F.b.c(xmlPullParser, "rotation")) {
+                                    f16 = f15.getFloat(5, f16);
+                                }
+                                jVar2.f298c = f16;
+                                jVar2.f299d = f15.getFloat(1, jVar2.f299d);
+                                jVar2.f300e = f15.getFloat(2, jVar2.f300e);
+                                float f17 = jVar2.f301f;
+                                if (xmlPullParser.getAttributeValue("http://schemas.android.com/apk/res/android", "scaleX") != null) {
+                                    f17 = f15.getFloat(3, f17);
+                                }
+                                jVar2.f301f = f17;
+                                float f18 = jVar2.f302g;
+                                if (xmlPullParser.getAttributeValue("http://schemas.android.com/apk/res/android", "scaleY") != null) {
+                                    f18 = f15.getFloat(4, f18);
+                                }
+                                jVar2.f302g = f18;
+                                float f19 = jVar2.h;
+                                if (xmlPullParser.getAttributeValue("http://schemas.android.com/apk/res/android", "translateX") != null) {
+                                    f19 = f15.getFloat(6, f19);
+                                }
+                                jVar2.h = f19;
+                                float f20 = jVar2.i;
+                                if (xmlPullParser.getAttributeValue("http://schemas.android.com/apk/res/android", "translateY") != null) {
+                                    f20 = f15.getFloat(7, f20);
+                                }
+                                jVar2.i = f20;
+                                String string6 = f15.getString(0);
+                                if (string6 != null) {
+                                    jVar2.f304k = string6;
+                                }
+                                jVar2.c();
+                                f15.recycle();
+                                jVar.f297b.add(jVar2);
+                                arrayDeque.push(jVar2);
+                                if (jVar2.getGroupName() != null) {
+                                    eVar.put(jVar2.getGroupName(), jVar2);
+                                }
+                                nVar3.f321a = nVar3.f321a;
+                            }
+                        }
+                        i4 = 1;
+                    } else {
+                        mVar = mVar3;
+                        i = depth;
+                        z3 = z5;
+                        c4 = '\b';
+                        i4 = 1;
+                        if (eventType == 3 && "group".equals(xmlPullParser.getName())) {
+                            arrayDeque.pop();
+                        }
+                    }
+                    eventType = xmlPullParser.next();
+                    i6 = i4;
+                    z5 = z3;
+                    mVar3 = mVar;
+                    depth = i;
+                }
+                if (!z6) {
+                    this.f334c = a(nVar.f323c, nVar.f324d);
+                    return;
+                }
+                throw new XmlPullParserException("no path defined");
+            }
+            throw new XmlPullParserException(f2.getPositionDescription() + "<vector> tag requires height > 0");
+        }
+        throw new XmlPullParserException(f2.getPositionDescription() + "<vector> tag requires viewportHeight > 0");
+    }
+
+    public p(n nVar) {
+        this.f337f = true;
+        this.f338g = new float[9];
+        this.h = new Matrix();
+        this.i = new Rect();
+        this.f333b = nVar;
+        this.f334c = a(nVar.f323c, nVar.f324d);
+    }
+}