Primer paso de la investigacion. Se aportan el .apk, las carpetas con el apk extraido y el apk descompilado. El archivo API_DOCUMENTATION.md es un archivo donde se anotaran los descubrimientos del funcionamiento de la API, y los .py son scripts para probar la funcionalidad de la API con los métodos que vayamos encontrando. Finalmente, los archivos .js son scripts de Frida para extraer informacion de la APP durante la ejecucion.

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);
+    }
+}