ADD week 5

02-Easy5/E5/sources/com/google/android/material/carousel/Arrangement.java

@@ -0,0 +1,131 @@
+package com.google.android.material.carousel;
+
+import androidx.core.math.MathUtils;
+
+/* loaded from: classes.dex */
+final class Arrangement {
+    private static final float MEDIUM_ITEM_FLEX_PERCENTAGE = 0.1f;
+    final float cost;
+    final int largeCount;
+    float largeSize;
+    int mediumCount;
+    float mediumSize;
+    final int priority;
+    int smallCount;
+    float smallSize;
+
+    private float calculateLargeSize(float f, int i, float f2, int i2, int i3) {
+        if (i <= 0) {
+            f2 = 0.0f;
+        }
+        float f3 = i2 / 2.0f;
+        return (f - ((i + f3) * f2)) / (i3 + f3);
+    }
+
+    private float getSpace() {
+        return (this.largeSize * this.largeCount) + (this.mediumSize * this.mediumCount) + (this.smallSize * this.smallCount);
+    }
+
+    private boolean isValid() {
+        int i = this.largeCount;
+        if (i <= 0 || this.smallCount <= 0 || this.mediumCount <= 0) {
+            return i <= 0 || this.smallCount <= 0 || this.largeSize > this.smallSize;
+        }
+        float f = this.largeSize;
+        float f2 = this.mediumSize;
+        return f > f2 && f2 > this.smallSize;
+    }
+
+    int getItemCount() {
+        return this.smallCount + this.mediumCount + this.largeCount;
+    }
+
+    Arrangement(int i, float f, float f2, float f3, int i2, float f4, int i3, float f5, int i4, float f6) {
+        this.priority = i;
+        this.smallSize = MathUtils.clamp(f, f2, f3);
+        this.smallCount = i2;
+        this.mediumSize = f4;
+        this.mediumCount = i3;
+        this.largeSize = f5;
+        this.largeCount = i4;
+        fit(f6, f2, f3, f5);
+        this.cost = cost(f5);
+    }
+
+    public String toString() {
+        return "Arrangement [priority=" + this.priority + ", smallCount=" + this.smallCount + ", smallSize=" + this.smallSize + ", mediumCount=" + this.mediumCount + ", mediumSize=" + this.mediumSize + ", largeCount=" + this.largeCount + ", largeSize=" + this.largeSize + ", cost=" + this.cost + "]";
+    }
+
+    private void fit(float f, float f2, float f3, float f4) {
+        float space = f - getSpace();
+        int i = this.smallCount;
+        if (i > 0 && space > 0.0f) {
+            float f5 = this.smallSize;
+            this.smallSize = f5 + Math.min(space / i, f3 - f5);
+        } else if (i > 0 && space < 0.0f) {
+            float f6 = this.smallSize;
+            this.smallSize = f6 + Math.max(space / i, f2 - f6);
+        }
+        int i2 = this.smallCount;
+        float f7 = i2 > 0 ? this.smallSize : 0.0f;
+        this.smallSize = f7;
+        float calculateLargeSize = calculateLargeSize(f, i2, f7, this.mediumCount, this.largeCount);
+        this.largeSize = calculateLargeSize;
+        float f8 = (this.smallSize + calculateLargeSize) / 2.0f;
+        this.mediumSize = f8;
+        int i3 = this.mediumCount;
+        if (i3 <= 0 || calculateLargeSize == f4) {
+            return;
+        }
+        float f9 = (f4 - calculateLargeSize) * this.largeCount;
+        float min = Math.min(Math.abs(f9), f8 * 0.1f * i3);
+        if (f9 > 0.0f) {
+            this.mediumSize -= min / this.mediumCount;
+            this.largeSize += min / this.largeCount;
+        } else {
+            this.mediumSize += min / this.mediumCount;
+            this.largeSize -= min / this.largeCount;
+        }
+    }
+
+    private float cost(float f) {
+        if (isValid()) {
+            return Math.abs(f - this.largeSize) * this.priority;
+        }
+        return Float.MAX_VALUE;
+    }
+
+    static Arrangement findLowestCostArrangement(float f, float f2, float f3, float f4, int[] iArr, float f5, int[] iArr2, float f6, int[] iArr3) {
+        Arrangement arrangement = null;
+        int i = 1;
+        for (int i2 : iArr3) {
+            int length = iArr2.length;
+            int i3 = 0;
+            while (i3 < length) {
+                int i4 = iArr2[i3];
+                int length2 = iArr.length;
+                int i5 = 0;
+                while (i5 < length2) {
+                    int i6 = i5;
+                    int i7 = length2;
+                    int i8 = i3;
+                    int i9 = length;
+                    Arrangement arrangement2 = new Arrangement(i, f2, f3, f4, iArr[i5], f5, i4, f6, i2, f);
+                    if (arrangement == null || arrangement2.cost < arrangement.cost) {
+                        if (arrangement2.cost == 0.0f) {
+                            return arrangement2;
+                        }
+                        arrangement = arrangement2;
+                    }
+                    i++;
+                    i5 = i6 + 1;
+                    length2 = i7;
+                    i3 = i8;
+                    length = i9;
+                }
+                i3++;
+            }
+        }
+        return arrangement;
+    }
+}

02-Easy5/E5/sources/com/google/android/material/carousel/Carousel.java

@@ -0,0 +1,14 @@
+package com.google.android.material.carousel;
+
+/* loaded from: classes.dex */
+interface Carousel {
+    int getCarouselAlignment();
+
+    int getContainerHeight();
+
+    int getContainerWidth();
+
+    int getItemCount();
+
+    boolean isHorizontal();
+}

02-Easy5/E5/sources/com/google/android/material/carousel/CarouselLayoutManager.java

@@ -0,0 +1,965 @@
+package com.google.android.material.carousel;
+
+import android.content.Context;
+import android.content.res.TypedArray;
+import android.graphics.Canvas;
+import android.graphics.Paint;
+import android.graphics.PointF;
+import android.graphics.Rect;
+import android.graphics.RectF;
+import android.util.AttributeSet;
+import android.util.Log;
+import android.view.View;
+import android.view.accessibility.AccessibilityEvent;
+import androidx.core.graphics.ColorUtils;
+import androidx.core.math.MathUtils;
+import androidx.core.util.Preconditions;
+import androidx.recyclerview.widget.LinearSmoothScroller;
+import androidx.recyclerview.widget.RecyclerView;
+import com.google.android.material.R;
+import com.google.android.material.animation.AnimationUtils;
+import com.google.android.material.carousel.KeylineState;
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.List;
+import java.util.Map;
+
+/* loaded from: classes.dex */
+public class CarouselLayoutManager extends RecyclerView.LayoutManager implements Carousel, RecyclerView.SmoothScroller.ScrollVectorProvider {
+    public static final int ALIGNMENT_CENTER = 1;
+    public static final int ALIGNMENT_START = 0;
+    public static final int HORIZONTAL = 0;
+    private static final String TAG = "CarouselLayoutManager";
+    public static final int VERTICAL = 1;
+    private int carouselAlignment;
+    private CarouselStrategy carouselStrategy;
+    private int currentEstimatedPosition;
+    private int currentFillStartPosition;
+    private KeylineState currentKeylineState;
+    private final DebugItemDecoration debugItemDecoration;
+    private boolean isDebuggingEnabled;
+    private KeylineStateList keylineStateList;
+    private Map<Integer, KeylineState> keylineStatePositionMap;
+    private int lastItemCount;
+    int maxScroll;
+    int minScroll;
+    private CarouselOrientationHelper orientationHelper;
+    private final View.OnLayoutChangeListener recyclerViewSizeChangeListener;
+    int scrollOffset;
+
+    private static int calculateShouldScrollBy(int i, int i2, int i3, int i4) {
+        int i5 = i2 + i;
+        return i5 < i3 ? i3 - i2 : i5 > i4 ? i4 - i2 : i;
+    }
+
+    @Override // androidx.recyclerview.widget.RecyclerView.LayoutManager
+    public int computeHorizontalScrollOffset(RecyclerView.State state) {
+        return this.scrollOffset;
+    }
+
+    @Override // androidx.recyclerview.widget.RecyclerView.LayoutManager
+    public int computeHorizontalScrollRange(RecyclerView.State state) {
+        return this.maxScroll - this.minScroll;
+    }
+
+    @Override // androidx.recyclerview.widget.RecyclerView.LayoutManager
+    public int computeVerticalScrollOffset(RecyclerView.State state) {
+        return this.scrollOffset;
+    }
+
+    @Override // androidx.recyclerview.widget.RecyclerView.LayoutManager
+    public int computeVerticalScrollRange(RecyclerView.State state) {
+        return this.maxScroll - this.minScroll;
+    }
+
+    @Override // com.google.android.material.carousel.Carousel
+    public int getCarouselAlignment() {
+        return this.carouselAlignment;
+    }
+
+    /* renamed from: lambda$new$0$com-google-android-material-carousel-CarouselLayoutManager, reason: not valid java name */
+    /* synthetic */ void m195x2ff337cb(View view, int i, int i2, int i3, int i4, int i5, int i6, int i7, int i8) {
+        if (i == i5 && i2 == i6 && i3 == i7 && i4 == i8) {
+            return;
+        }
+        view.post(new Runnable() { // from class: com.google.android.material.carousel.CarouselLayoutManager$$ExternalSyntheticLambda0
+            @Override // java.lang.Runnable
+            public final void run() {
+                CarouselLayoutManager.this.refreshKeylineState();
+            }
+        });
+    }
+
+    private static final class ChildCalculations {
+        final float center;
+        final View child;
+        final float offsetCenter;
+        final KeylineRange range;
+
+        ChildCalculations(View view, float f, float f2, KeylineRange keylineRange) {
+            this.child = view;
+            this.center = f;
+            this.offsetCenter = f2;
+            this.range = keylineRange;
+        }
+    }
+
+    public CarouselLayoutManager() {
+        this(new MultiBrowseCarouselStrategy());
+    }
+
+    public CarouselLayoutManager(CarouselStrategy carouselStrategy) {
+        this(carouselStrategy, 0);
+    }
+
+    public CarouselLayoutManager(CarouselStrategy carouselStrategy, int i) {
+        this.isDebuggingEnabled = false;
+        this.debugItemDecoration = new DebugItemDecoration();
+        this.currentFillStartPosition = 0;
+        this.recyclerViewSizeChangeListener = new View.OnLayoutChangeListener() { // from class: com.google.android.material.carousel.CarouselLayoutManager$$ExternalSyntheticLambda1
+            @Override // android.view.View.OnLayoutChangeListener
+            public final void onLayoutChange(View view, int i2, int i3, int i4, int i5, int i6, int i7, int i8, int i9) {
+                CarouselLayoutManager.this.m195x2ff337cb(view, i2, i3, i4, i5, i6, i7, i8, i9);
+            }
+        };
+        this.currentEstimatedPosition = -1;
+        this.carouselAlignment = 0;
+        setCarouselStrategy(carouselStrategy);
+        setOrientation(i);
+    }
+
+    public CarouselLayoutManager(Context context, AttributeSet attributeSet, int i, int i2) {
+        this.isDebuggingEnabled = false;
+        this.debugItemDecoration = new DebugItemDecoration();
+        this.currentFillStartPosition = 0;
+        this.recyclerViewSizeChangeListener = new View.OnLayoutChangeListener() { // from class: com.google.android.material.carousel.CarouselLayoutManager$$ExternalSyntheticLambda1
+            @Override // android.view.View.OnLayoutChangeListener
+            public final void onLayoutChange(View view, int i22, int i3, int i4, int i5, int i6, int i7, int i8, int i9) {
+                CarouselLayoutManager.this.m195x2ff337cb(view, i22, i3, i4, i5, i6, i7, i8, i9);
+            }
+        };
+        this.currentEstimatedPosition = -1;
+        this.carouselAlignment = 0;
+        setCarouselStrategy(new MultiBrowseCarouselStrategy());
+        setCarouselAttributes(context, attributeSet);
+    }
+
+    private void setCarouselAttributes(Context context, AttributeSet attributeSet) {
+        if (attributeSet != null) {
+            TypedArray obtainStyledAttributes = context.obtainStyledAttributes(attributeSet, R.styleable.Carousel);
+            setCarouselAlignment(obtainStyledAttributes.getInt(R.styleable.Carousel_carousel_alignment, 0));
+            setOrientation(obtainStyledAttributes.getInt(R.styleable.RecyclerView_android_orientation, 0));
+            obtainStyledAttributes.recycle();
+        }
+    }
+
+    public void setCarouselAlignment(int i) {
+        this.carouselAlignment = i;
+        refreshKeylineState();
+    }
+
+    @Override // androidx.recyclerview.widget.RecyclerView.LayoutManager
+    public RecyclerView.LayoutParams generateDefaultLayoutParams() {
+        return new RecyclerView.LayoutParams(-2, -2);
+    }
+
+    public void setCarouselStrategy(CarouselStrategy carouselStrategy) {
+        this.carouselStrategy = carouselStrategy;
+        refreshKeylineState();
+    }
+
+    @Override // androidx.recyclerview.widget.RecyclerView.LayoutManager
+    public void onAttachedToWindow(RecyclerView recyclerView) {
+        super.onAttachedToWindow(recyclerView);
+        refreshKeylineState();
+        recyclerView.addOnLayoutChangeListener(this.recyclerViewSizeChangeListener);
+    }
+
+    @Override // androidx.recyclerview.widget.RecyclerView.LayoutManager
+    public void onDetachedFromWindow(RecyclerView recyclerView, RecyclerView.Recycler recycler) {
+        super.onDetachedFromWindow(recyclerView, recycler);
+        recyclerView.removeOnLayoutChangeListener(this.recyclerViewSizeChangeListener);
+    }
+
+    @Override // androidx.recyclerview.widget.RecyclerView.LayoutManager
+    public void onLayoutChildren(RecyclerView.Recycler recycler, RecyclerView.State state) {
+        if (state.getItemCount() <= 0 || getContainerSize() <= 0.0f) {
+            removeAndRecycleAllViews(recycler);
+            this.currentFillStartPosition = 0;
+            return;
+        }
+        boolean isLayoutRtl = isLayoutRtl();
+        boolean z = this.keylineStateList == null;
+        if (z) {
+            recalculateKeylineStateList(recycler);
+        }
+        int calculateStartScroll = calculateStartScroll(this.keylineStateList);
+        int calculateEndScroll = calculateEndScroll(state, this.keylineStateList);
+        this.minScroll = isLayoutRtl ? calculateEndScroll : calculateStartScroll;
+        if (isLayoutRtl) {
+            calculateEndScroll = calculateStartScroll;
+        }
+        this.maxScroll = calculateEndScroll;
+        if (z) {
+            this.scrollOffset = calculateStartScroll;
+            this.keylineStatePositionMap = this.keylineStateList.getKeylineStateForPositionMap(getItemCount(), this.minScroll, this.maxScroll, isLayoutRtl());
+            int i = this.currentEstimatedPosition;
+            if (i != -1) {
+                this.scrollOffset = getScrollOffsetForPosition(i, getKeylineStateForPosition(i));
+            }
+        }
+        int i2 = this.scrollOffset;
+        this.scrollOffset = i2 + calculateShouldScrollBy(0, i2, this.minScroll, this.maxScroll);
+        this.currentFillStartPosition = MathUtils.clamp(this.currentFillStartPosition, 0, state.getItemCount());
+        updateCurrentKeylineStateForScrollOffset(this.keylineStateList);
+        detachAndScrapAttachedViews(recycler);
+        fill(recycler, state);
+        this.lastItemCount = getItemCount();
+    }
+
+    private void recalculateKeylineStateList(RecyclerView.Recycler recycler) {
+        View viewForPosition = recycler.getViewForPosition(0);
+        measureChildWithMargins(viewForPosition, 0, 0);
+        KeylineState onFirstChildMeasuredWithMargins = this.carouselStrategy.onFirstChildMeasuredWithMargins(this, viewForPosition);
+        if (isLayoutRtl()) {
+            onFirstChildMeasuredWithMargins = KeylineState.reverse(onFirstChildMeasuredWithMargins, getContainerSize());
+        }
+        this.keylineStateList = KeylineStateList.from(this, onFirstChildMeasuredWithMargins);
+    }
+
+    /* JADX INFO: Access modifiers changed from: private */
+    public void refreshKeylineState() {
+        this.keylineStateList = null;
+        requestLayout();
+    }
+
+    private void fill(RecyclerView.Recycler recycler, RecyclerView.State state) {
+        removeAndRecycleOutOfBoundsViews(recycler);
+        if (getChildCount() == 0) {
+            addViewsStart(recycler, this.currentFillStartPosition - 1);
+            addViewsEnd(recycler, state, this.currentFillStartPosition);
+        } else {
+            int position = getPosition(getChildAt(0));
+            int position2 = getPosition(getChildAt(getChildCount() - 1));
+            addViewsStart(recycler, position - 1);
+            addViewsEnd(recycler, state, position2 + 1);
+        }
+        validateChildOrderIfDebugging();
+    }
+
+    @Override // androidx.recyclerview.widget.RecyclerView.LayoutManager
+    public void onLayoutCompleted(RecyclerView.State state) {
+        super.onLayoutCompleted(state);
+        if (getChildCount() == 0) {
+            this.currentFillStartPosition = 0;
+        } else {
+            this.currentFillStartPosition = getPosition(getChildAt(0));
+        }
+        validateChildOrderIfDebugging();
+    }
+
+    private void addViewsStart(RecyclerView.Recycler recycler, int i) {
+        float calculateChildStartForFill = calculateChildStartForFill(i);
+        while (i >= 0) {
+            ChildCalculations makeChildCalculations = makeChildCalculations(recycler, calculateChildStartForFill, i);
+            if (isLocOffsetOutOfFillBoundsStart(makeChildCalculations.offsetCenter, makeChildCalculations.range)) {
+                return;
+            }
+            calculateChildStartForFill = addStart(calculateChildStartForFill, this.currentKeylineState.getItemSize());
+            if (!isLocOffsetOutOfFillBoundsEnd(makeChildCalculations.offsetCenter, makeChildCalculations.range)) {
+                addAndLayoutView(makeChildCalculations.child, 0, makeChildCalculations);
+            }
+            i--;
+        }
+    }
+
+    private void addViewAtPosition(RecyclerView.Recycler recycler, int i, int i2) {
+        if (i < 0 || i >= getItemCount()) {
+            return;
+        }
+        ChildCalculations makeChildCalculations = makeChildCalculations(recycler, calculateChildStartForFill(i), i);
+        addAndLayoutView(makeChildCalculations.child, i2, makeChildCalculations);
+    }
+
+    private void addViewsEnd(RecyclerView.Recycler recycler, RecyclerView.State state, int i) {
+        float calculateChildStartForFill = calculateChildStartForFill(i);
+        while (i < state.getItemCount()) {
+            ChildCalculations makeChildCalculations = makeChildCalculations(recycler, calculateChildStartForFill, i);
+            if (isLocOffsetOutOfFillBoundsEnd(makeChildCalculations.offsetCenter, makeChildCalculations.range)) {
+                return;
+            }
+            calculateChildStartForFill = addEnd(calculateChildStartForFill, this.currentKeylineState.getItemSize());
+            if (!isLocOffsetOutOfFillBoundsStart(makeChildCalculations.offsetCenter, makeChildCalculations.range)) {
+                addAndLayoutView(makeChildCalculations.child, -1, makeChildCalculations);
+            }
+            i++;
+        }
+    }
+
+    private void logChildrenIfDebugging() {
+        if (this.isDebuggingEnabled && Log.isLoggable(TAG, 3)) {
+            Log.d(TAG, "internal representation of views on the screen");
+            for (int i = 0; i < getChildCount(); i++) {
+                View childAt = getChildAt(i);
+                Log.d(TAG, "item position " + getPosition(childAt) + ", center:" + getDecoratedCenterWithMargins(childAt) + ", child index:" + i);
+            }
+            Log.d(TAG, "==============");
+        }
+    }
+
+    private void validateChildOrderIfDebugging() {
+        if (!this.isDebuggingEnabled || getChildCount() < 1) {
+            return;
+        }
+        int i = 0;
+        while (i < getChildCount() - 1) {
+            int position = getPosition(getChildAt(i));
+            int i2 = i + 1;
+            int position2 = getPosition(getChildAt(i2));
+            if (position > position2) {
+                logChildrenIfDebugging();
+                throw new IllegalStateException("Detected invalid child order. Child at index [" + i + "] had adapter position [" + position + "] and child at index [" + i2 + "] had adapter position [" + position2 + "].");
+            }
+            i = i2;
+        }
+    }
+
+    private ChildCalculations makeChildCalculations(RecyclerView.Recycler recycler, float f, int i) {
+        View viewForPosition = recycler.getViewForPosition(i);
+        measureChildWithMargins(viewForPosition, 0, 0);
+        float addEnd = addEnd(f, this.currentKeylineState.getItemSize() / 2.0f);
+        KeylineRange surroundingKeylineRange = getSurroundingKeylineRange(this.currentKeylineState.getKeylines(), addEnd, false);
+        return new ChildCalculations(viewForPosition, addEnd, calculateChildOffsetCenterForLocation(viewForPosition, addEnd, surroundingKeylineRange), surroundingKeylineRange);
+    }
+
+    private void addAndLayoutView(View view, int i, ChildCalculations childCalculations) {
+        float itemSize = this.currentKeylineState.getItemSize() / 2.0f;
+        addView(view, i);
+        this.orientationHelper.layoutDecoratedWithMargins(view, (int) (childCalculations.offsetCenter - itemSize), (int) (childCalculations.offsetCenter + itemSize));
+        updateChildMaskForLocation(view, childCalculations.center, childCalculations.range);
+    }
+
+    private boolean isLocOffsetOutOfFillBoundsStart(float f, KeylineRange keylineRange) {
+        float addEnd = addEnd(f, getMaskedItemSizeForLocOffset(f, keylineRange) / 2.0f);
+        if (isLayoutRtl()) {
+            if (addEnd > getContainerSize()) {
+                return true;
+            }
+        } else if (addEnd < 0.0f) {
+            return true;
+        }
+        return false;
+    }
+
+    @Override // com.google.android.material.carousel.Carousel
+    public boolean isHorizontal() {
+        return this.orientationHelper.orientation == 0;
+    }
+
+    private boolean isLocOffsetOutOfFillBoundsEnd(float f, KeylineRange keylineRange) {
+        float addStart = addStart(f, getMaskedItemSizeForLocOffset(f, keylineRange) / 2.0f);
+        if (isLayoutRtl()) {
+            if (addStart < 0.0f) {
+                return true;
+            }
+        } else if (addStart > getContainerSize()) {
+            return true;
+        }
+        return false;
+    }
+
+    @Override // androidx.recyclerview.widget.RecyclerView.LayoutManager
+    public void getDecoratedBoundsWithMargins(View view, Rect rect) {
+        super.getDecoratedBoundsWithMargins(view, rect);
+        float centerY = rect.centerY();
+        if (isHorizontal()) {
+            centerY = rect.centerX();
+        }
+        float maskedItemSizeForLocOffset = getMaskedItemSizeForLocOffset(centerY, getSurroundingKeylineRange(this.currentKeylineState.getKeylines(), centerY, true));
+        float width = isHorizontal() ? (rect.width() - maskedItemSizeForLocOffset) / 2.0f : 0.0f;
+        float height = isHorizontal() ? 0.0f : (rect.height() - maskedItemSizeForLocOffset) / 2.0f;
+        rect.set((int) (rect.left + width), (int) (rect.top + height), (int) (rect.right - width), (int) (rect.bottom - height));
+    }
+
+    private float getDecoratedCenterWithMargins(View view) {
+        int centerY;
+        Rect rect = new Rect();
+        super.getDecoratedBoundsWithMargins(view, rect);
+        if (isHorizontal()) {
+            centerY = rect.centerX();
+        } else {
+            centerY = rect.centerY();
+        }
+        return centerY;
+    }
+
+    private void removeAndRecycleOutOfBoundsViews(RecyclerView.Recycler recycler) {
+        while (getChildCount() > 0) {
+            View childAt = getChildAt(0);
+            float decoratedCenterWithMargins = getDecoratedCenterWithMargins(childAt);
+            if (!isLocOffsetOutOfFillBoundsStart(decoratedCenterWithMargins, getSurroundingKeylineRange(this.currentKeylineState.getKeylines(), decoratedCenterWithMargins, true))) {
+                break;
+            } else {
+                removeAndRecycleView(childAt, recycler);
+            }
+        }
+        while (getChildCount() - 1 >= 0) {
+            View childAt2 = getChildAt(getChildCount() - 1);
+            float decoratedCenterWithMargins2 = getDecoratedCenterWithMargins(childAt2);
+            if (!isLocOffsetOutOfFillBoundsEnd(decoratedCenterWithMargins2, getSurroundingKeylineRange(this.currentKeylineState.getKeylines(), decoratedCenterWithMargins2, true))) {
+                return;
+            } else {
+                removeAndRecycleView(childAt2, recycler);
+            }
+        }
+    }
+
+    private static KeylineRange getSurroundingKeylineRange(List<KeylineState.Keyline> list, float f, boolean z) {
+        float f2 = Float.MAX_VALUE;
+        float f3 = Float.MAX_VALUE;
+        float f4 = Float.MAX_VALUE;
+        float f5 = -3.4028235E38f;
+        int i = -1;
+        int i2 = -1;
+        int i3 = -1;
+        int i4 = -1;
+        for (int i5 = 0; i5 < list.size(); i5++) {
+            KeylineState.Keyline keyline = list.get(i5);
+            float f6 = z ? keyline.locOffset : keyline.loc;
+            float abs = Math.abs(f6 - f);
+            if (f6 <= f && abs <= f2) {
+                i = i5;
+                f2 = abs;
+            }
+            if (f6 > f && abs <= f3) {
+                i3 = i5;
+                f3 = abs;
+            }
+            if (f6 <= f4) {
+                i2 = i5;
+                f4 = f6;
+            }
+            if (f6 > f5) {
+                i4 = i5;
+                f5 = f6;
+            }
+        }
+        if (i == -1) {
+            i = i2;
+        }
+        if (i3 == -1) {
+            i3 = i4;
+        }
+        return new KeylineRange(list.get(i), list.get(i3));
+    }
+
+    private void updateCurrentKeylineStateForScrollOffset(KeylineStateList keylineStateList) {
+        int i = this.maxScroll;
+        int i2 = this.minScroll;
+        if (i <= i2) {
+            this.currentKeylineState = isLayoutRtl() ? keylineStateList.getEndState() : keylineStateList.getStartState();
+        } else {
+            this.currentKeylineState = keylineStateList.getShiftedState(this.scrollOffset, i2, i);
+        }
+        this.debugItemDecoration.setKeylines(this.currentKeylineState.getKeylines());
+    }
+
+    private int calculateStartScroll(KeylineStateList keylineStateList) {
+        boolean isLayoutRtl = isLayoutRtl();
+        KeylineState endState = isLayoutRtl ? keylineStateList.getEndState() : keylineStateList.getStartState();
+        return (int) (((getPaddingStart() * (isLayoutRtl ? 1 : -1)) + getParentStart()) - addStart((isLayoutRtl ? endState.getLastFocalKeyline() : endState.getFirstFocalKeyline()).loc, endState.getItemSize() / 2.0f));
+    }
+
+    private int calculateEndScroll(RecyclerView.State state, KeylineStateList keylineStateList) {
+        boolean isLayoutRtl = isLayoutRtl();
+        KeylineState startState = isLayoutRtl ? keylineStateList.getStartState() : keylineStateList.getEndState();
+        KeylineState.Keyline firstFocalKeyline = isLayoutRtl ? startState.getFirstFocalKeyline() : startState.getLastFocalKeyline();
+        int itemCount = (int) ((((((state.getItemCount() - 1) * startState.getItemSize()) + getPaddingEnd()) * (isLayoutRtl ? -1.0f : 1.0f)) - (firstFocalKeyline.loc - getParentStart())) + (getParentEnd() - firstFocalKeyline.loc));
+        return isLayoutRtl ? Math.min(0, itemCount) : Math.max(0, itemCount);
+    }
+
+    private float calculateChildStartForFill(int i) {
+        return addEnd(getParentStart() - this.scrollOffset, this.currentKeylineState.getItemSize() * i);
+    }
+
+    private float calculateChildOffsetCenterForLocation(View view, float f, KeylineRange keylineRange) {
+        float lerp = AnimationUtils.lerp(keylineRange.leftOrTop.locOffset, keylineRange.rightOrBottom.locOffset, keylineRange.leftOrTop.loc, keylineRange.rightOrBottom.loc, f);
+        if (keylineRange.rightOrBottom != this.currentKeylineState.getFirstKeyline() && keylineRange.leftOrTop != this.currentKeylineState.getLastKeyline()) {
+            return lerp;
+        }
+        return lerp + ((f - keylineRange.rightOrBottom.loc) * ((1.0f - keylineRange.rightOrBottom.mask) + (this.orientationHelper.getMaskMargins((RecyclerView.LayoutParams) view.getLayoutParams()) / this.currentKeylineState.getItemSize())));
+    }
+
+    private float getMaskedItemSizeForLocOffset(float f, KeylineRange keylineRange) {
+        return AnimationUtils.lerp(keylineRange.leftOrTop.maskedItemSize, keylineRange.rightOrBottom.maskedItemSize, keylineRange.leftOrTop.locOffset, keylineRange.rightOrBottom.locOffset, f);
+    }
+
+    /* JADX WARN: Multi-variable type inference failed */
+    private void updateChildMaskForLocation(View view, float f, KeylineRange keylineRange) {
+        if (view instanceof Maskable) {
+            float lerp = AnimationUtils.lerp(keylineRange.leftOrTop.mask, keylineRange.rightOrBottom.mask, keylineRange.leftOrTop.loc, keylineRange.rightOrBottom.loc, f);
+            float height = view.getHeight();
+            float width = view.getWidth();
+            RectF maskRect = this.orientationHelper.getMaskRect(height, width, AnimationUtils.lerp(0.0f, height / 2.0f, 0.0f, 1.0f, lerp), AnimationUtils.lerp(0.0f, width / 2.0f, 0.0f, 1.0f, lerp));
+            float calculateChildOffsetCenterForLocation = calculateChildOffsetCenterForLocation(view, f, keylineRange);
+            RectF rectF = new RectF(calculateChildOffsetCenterForLocation - (maskRect.width() / 2.0f), calculateChildOffsetCenterForLocation - (maskRect.height() / 2.0f), calculateChildOffsetCenterForLocation + (maskRect.width() / 2.0f), (maskRect.height() / 2.0f) + calculateChildOffsetCenterForLocation);
+            RectF rectF2 = new RectF(getParentLeft(), getParentTop(), getParentRight(), getParentBottom());
+            if (this.carouselStrategy.isContained()) {
+                this.orientationHelper.containMaskWithinBounds(maskRect, rectF, rectF2);
+            }
+            this.orientationHelper.moveMaskOnEdgeOutsideBounds(maskRect, rectF, rectF2);
+            ((Maskable) view).setMaskRectF(maskRect);
+        }
+    }
+
+    @Override // androidx.recyclerview.widget.RecyclerView.LayoutManager
+    public void measureChildWithMargins(View view, int i, int i2) {
+        float f;
+        float f2;
+        if (!(view instanceof Maskable)) {
+            throw new IllegalStateException("All children of a RecyclerView using CarouselLayoutManager must use MaskableFrameLayout as their root ViewGroup.");
+        }
+        RecyclerView.LayoutParams layoutParams = (RecyclerView.LayoutParams) view.getLayoutParams();
+        Rect rect = new Rect();
+        calculateItemDecorationsForChild(view, rect);
+        int i3 = i + rect.left + rect.right;
+        int i4 = i2 + rect.top + rect.bottom;
+        if (this.keylineStateList != null && this.orientationHelper.orientation == 0) {
+            f = this.keylineStateList.getDefaultState().getItemSize();
+        } else {
+            f = layoutParams.width;
+        }
+        if (this.keylineStateList != null && this.orientationHelper.orientation == 1) {
+            f2 = this.keylineStateList.getDefaultState().getItemSize();
+        } else {
+            f2 = layoutParams.height;
+        }
+        view.measure(getChildMeasureSpec(getWidth(), getWidthMode(), getPaddingLeft() + getPaddingRight() + layoutParams.leftMargin + layoutParams.rightMargin + i3, (int) f, canScrollHorizontally()), getChildMeasureSpec(getHeight(), getHeightMode(), getPaddingTop() + getPaddingBottom() + layoutParams.topMargin + layoutParams.bottomMargin + i4, (int) f2, canScrollVertically()));
+    }
+
+    /* JADX INFO: Access modifiers changed from: private */
+    public int getParentLeft() {
+        return this.orientationHelper.getParentLeft();
+    }
+
+    private int getParentStart() {
+        return this.orientationHelper.getParentStart();
+    }
+
+    /* JADX INFO: Access modifiers changed from: private */
+    public int getParentRight() {
+        return this.orientationHelper.getParentRight();
+    }
+
+    private int getParentEnd() {
+        return this.orientationHelper.getParentEnd();
+    }
+
+    /* JADX INFO: Access modifiers changed from: private */
+    public int getParentTop() {
+        return this.orientationHelper.getParentTop();
+    }
+
+    /* JADX INFO: Access modifiers changed from: private */
+    public int getParentBottom() {
+        return this.orientationHelper.getParentBottom();
+    }
+
+    @Override // com.google.android.material.carousel.Carousel
+    public int getContainerWidth() {
+        return getWidth();
+    }
+
+    @Override // com.google.android.material.carousel.Carousel
+    public int getContainerHeight() {
+        return getHeight();
+    }
+
+    private int getContainerSize() {
+        if (isHorizontal()) {
+            return getContainerWidth();
+        }
+        return getContainerHeight();
+    }
+
+    boolean isLayoutRtl() {
+        return isHorizontal() && getLayoutDirection() == 1;
+    }
+
+    private float addStart(float f, float f2) {
+        return isLayoutRtl() ? f + f2 : f - f2;
+    }
+
+    private float addEnd(float f, float f2) {
+        return isLayoutRtl() ? f - f2 : f + f2;
+    }
+
+    @Override // androidx.recyclerview.widget.RecyclerView.LayoutManager
+    public void onInitializeAccessibilityEvent(AccessibilityEvent accessibilityEvent) {
+        super.onInitializeAccessibilityEvent(accessibilityEvent);
+        if (getChildCount() > 0) {
+            accessibilityEvent.setFromIndex(getPosition(getChildAt(0)));
+            accessibilityEvent.setToIndex(getPosition(getChildAt(getChildCount() - 1)));
+        }
+    }
+
+    private int getScrollOffsetForPosition(int i, KeylineState keylineState) {
+        if (isLayoutRtl()) {
+            return (int) (((getContainerSize() - keylineState.getLastFocalKeyline().loc) - (i * keylineState.getItemSize())) - (keylineState.getItemSize() / 2.0f));
+        }
+        return (int) (((i * keylineState.getItemSize()) - keylineState.getFirstFocalKeyline().loc) + (keylineState.getItemSize() / 2.0f));
+    }
+
+    private int getSmallestScrollOffsetToFocalKeyline(int i, KeylineState keylineState) {
+        int i2;
+        int i3 = Integer.MAX_VALUE;
+        for (KeylineState.Keyline keyline : keylineState.getFocalKeylines()) {
+            float itemSize = (i * keylineState.getItemSize()) + (keylineState.getItemSize() / 2.0f);
+            if (isLayoutRtl()) {
+                i2 = (int) ((getContainerSize() - keyline.loc) - itemSize);
+            } else {
+                i2 = (int) (itemSize - keyline.loc);
+            }
+            int i4 = i2 - this.scrollOffset;
+            if (Math.abs(i3) > Math.abs(i4)) {
+                i3 = i4;
+            }
+        }
+        return i3;
+    }
+
+    @Override // androidx.recyclerview.widget.RecyclerView.SmoothScroller.ScrollVectorProvider
+    public PointF computeScrollVectorForPosition(int i) {
+        if (this.keylineStateList == null) {
+            return null;
+        }
+        int offsetToScrollToPosition = getOffsetToScrollToPosition(i, getKeylineStateForPosition(i));
+        if (isHorizontal()) {
+            return new PointF(offsetToScrollToPosition, 0.0f);
+        }
+        return new PointF(0.0f, offsetToScrollToPosition);
+    }
+
+    int getOffsetToScrollToPosition(int i, KeylineState keylineState) {
+        return getScrollOffsetForPosition(i, keylineState) - this.scrollOffset;
+    }
+
+    int getOffsetToScrollToPositionForSnap(int i, boolean z) {
+        int offsetToScrollToPosition = getOffsetToScrollToPosition(i, this.keylineStateList.getShiftedState(this.scrollOffset, this.minScroll, this.maxScroll, true));
+        int offsetToScrollToPosition2 = this.keylineStatePositionMap != null ? getOffsetToScrollToPosition(i, getKeylineStateForPosition(i)) : offsetToScrollToPosition;
+        return (!z || Math.abs(offsetToScrollToPosition2) >= Math.abs(offsetToScrollToPosition)) ? offsetToScrollToPosition : offsetToScrollToPosition2;
+    }
+
+    private KeylineState getKeylineStateForPosition(int i) {
+        KeylineState keylineState;
+        Map<Integer, KeylineState> map = this.keylineStatePositionMap;
+        return (map == null || (keylineState = map.get(Integer.valueOf(MathUtils.clamp(i, 0, Math.max(0, getItemCount() + (-1)))))) == null) ? this.keylineStateList.getDefaultState() : keylineState;
+    }
+
+    @Override // androidx.recyclerview.widget.RecyclerView.LayoutManager
+    public void scrollToPosition(int i) {
+        this.currentEstimatedPosition = i;
+        if (this.keylineStateList == null) {
+            return;
+        }
+        this.scrollOffset = getScrollOffsetForPosition(i, getKeylineStateForPosition(i));
+        this.currentFillStartPosition = MathUtils.clamp(i, 0, Math.max(0, getItemCount() - 1));
+        updateCurrentKeylineStateForScrollOffset(this.keylineStateList);
+        requestLayout();
+    }
+
+    @Override // androidx.recyclerview.widget.RecyclerView.LayoutManager
+    public void smoothScrollToPosition(RecyclerView recyclerView, RecyclerView.State state, int i) {
+        LinearSmoothScroller linearSmoothScroller = new LinearSmoothScroller(recyclerView.getContext()) { // from class: com.google.android.material.carousel.CarouselLayoutManager.1
+            @Override // androidx.recyclerview.widget.RecyclerView.SmoothScroller
+            public PointF computeScrollVectorForPosition(int i2) {
+                return CarouselLayoutManager.this.computeScrollVectorForPosition(i2);
+            }
+
+            @Override // androidx.recyclerview.widget.LinearSmoothScroller
+            public int calculateDxToMakeVisible(View view, int i2) {
+                if (CarouselLayoutManager.this.keylineStateList == null || !CarouselLayoutManager.this.isHorizontal()) {
+                    return 0;
+                }
+                CarouselLayoutManager carouselLayoutManager = CarouselLayoutManager.this;
+                return carouselLayoutManager.calculateScrollDeltaToMakePositionVisible(carouselLayoutManager.getPosition(view));
+            }
+
+            @Override // androidx.recyclerview.widget.LinearSmoothScroller
+            public int calculateDyToMakeVisible(View view, int i2) {
+                if (CarouselLayoutManager.this.keylineStateList == null || CarouselLayoutManager.this.isHorizontal()) {
+                    return 0;
+                }
+                CarouselLayoutManager carouselLayoutManager = CarouselLayoutManager.this;
+                return carouselLayoutManager.calculateScrollDeltaToMakePositionVisible(carouselLayoutManager.getPosition(view));
+            }
+        };
+        linearSmoothScroller.setTargetPosition(i);
+        startSmoothScroll(linearSmoothScroller);
+    }
+
+    int calculateScrollDeltaToMakePositionVisible(int i) {
+        return (int) (this.scrollOffset - getScrollOffsetForPosition(i, getKeylineStateForPosition(i)));
+    }
+
+    @Override // androidx.recyclerview.widget.RecyclerView.LayoutManager
+    public boolean canScrollHorizontally() {
+        return isHorizontal();
+    }
+
+    @Override // androidx.recyclerview.widget.RecyclerView.LayoutManager
+    public int scrollHorizontallyBy(int i, RecyclerView.Recycler recycler, RecyclerView.State state) {
+        if (canScrollHorizontally()) {
+            return scrollBy(i, recycler, state);
+        }
+        return 0;
+    }
+
+    @Override // androidx.recyclerview.widget.RecyclerView.LayoutManager
+    public boolean canScrollVertically() {
+        return !isHorizontal();
+    }
+
+    @Override // androidx.recyclerview.widget.RecyclerView.LayoutManager
+    public int scrollVerticallyBy(int i, RecyclerView.Recycler recycler, RecyclerView.State state) {
+        if (canScrollVertically()) {
+            return scrollBy(i, recycler, state);
+        }
+        return 0;
+    }
+
+    private static class LayoutDirection {
+        private static final int INVALID_LAYOUT = Integer.MIN_VALUE;
+        private static final int LAYOUT_END = 1;
+        private static final int LAYOUT_START = -1;
+
+        private LayoutDirection() {
+        }
+    }
+
+    private int convertFocusDirectionToLayoutDirection(int i) {
+        int orientation = getOrientation();
+        if (i == 1) {
+            return -1;
+        }
+        if (i == 2) {
+            return 1;
+        }
+        if (i == 17) {
+            if (orientation == 0) {
+                return isLayoutRtl() ? 1 : -1;
+            }
+            return Integer.MIN_VALUE;
+        }
+        if (i == 33) {
+            return orientation == 1 ? -1 : Integer.MIN_VALUE;
+        }
+        if (i == 66) {
+            if (orientation == 0) {
+                return isLayoutRtl() ? -1 : 1;
+            }
+            return Integer.MIN_VALUE;
+        }
+        if (i == 130) {
+            return orientation == 1 ? 1 : Integer.MIN_VALUE;
+        }
+        Log.d(TAG, "Unknown focus request:" + i);
+        return Integer.MIN_VALUE;
+    }
+
+    @Override // androidx.recyclerview.widget.RecyclerView.LayoutManager
+    public View onFocusSearchFailed(View view, int i, RecyclerView.Recycler recycler, RecyclerView.State state) {
+        int convertFocusDirectionToLayoutDirection;
+        if (getChildCount() == 0 || (convertFocusDirectionToLayoutDirection = convertFocusDirectionToLayoutDirection(i)) == Integer.MIN_VALUE) {
+            return null;
+        }
+        if (convertFocusDirectionToLayoutDirection == -1) {
+            if (getPosition(view) == 0) {
+                return null;
+            }
+            addViewAtPosition(recycler, getPosition(getChildAt(0)) - 1, 0);
+            return getChildClosestToStart();
+        }
+        if (getPosition(view) == getItemCount() - 1) {
+            return null;
+        }
+        addViewAtPosition(recycler, getPosition(getChildAt(getChildCount() - 1)) + 1, -1);
+        return getChildClosestToEnd();
+    }
+
+    private View getChildClosestToStart() {
+        return getChildAt(isLayoutRtl() ? getChildCount() - 1 : 0);
+    }
+
+    private View getChildClosestToEnd() {
+        return getChildAt(isLayoutRtl() ? 0 : getChildCount() - 1);
+    }
+
+    @Override // androidx.recyclerview.widget.RecyclerView.LayoutManager
+    public boolean requestChildRectangleOnScreen(RecyclerView recyclerView, View view, Rect rect, boolean z, boolean z2) {
+        int smallestScrollOffsetToFocalKeyline;
+        if (this.keylineStateList == null || (smallestScrollOffsetToFocalKeyline = getSmallestScrollOffsetToFocalKeyline(getPosition(view), getKeylineStateForPosition(getPosition(view)))) == 0) {
+            return false;
+        }
+        scrollBy(recyclerView, getSmallestScrollOffsetToFocalKeyline(getPosition(view), this.keylineStateList.getShiftedState(this.scrollOffset + calculateShouldScrollBy(smallestScrollOffsetToFocalKeyline, this.scrollOffset, this.minScroll, this.maxScroll), this.minScroll, this.maxScroll)));
+        return true;
+    }
+
+    private void scrollBy(RecyclerView recyclerView, int i) {
+        if (isHorizontal()) {
+            recyclerView.scrollBy(i, 0);
+        } else {
+            recyclerView.scrollBy(0, i);
+        }
+    }
+
+    private int scrollBy(int i, RecyclerView.Recycler recycler, RecyclerView.State state) {
+        float f;
+        if (getChildCount() == 0 || i == 0) {
+            return 0;
+        }
+        if (this.keylineStateList == null) {
+            recalculateKeylineStateList(recycler);
+        }
+        int calculateShouldScrollBy = calculateShouldScrollBy(i, this.scrollOffset, this.minScroll, this.maxScroll);
+        this.scrollOffset += calculateShouldScrollBy;
+        updateCurrentKeylineStateForScrollOffset(this.keylineStateList);
+        float itemSize = this.currentKeylineState.getItemSize() / 2.0f;
+        float calculateChildStartForFill = calculateChildStartForFill(getPosition(getChildAt(0)));
+        Rect rect = new Rect();
+        if (isLayoutRtl()) {
+            f = this.currentKeylineState.getLastFocalKeyline().locOffset;
+        } else {
+            f = this.currentKeylineState.getFirstFocalKeyline().locOffset;
+        }
+        float f2 = Float.MAX_VALUE;
+        for (int i2 = 0; i2 < getChildCount(); i2++) {
+            View childAt = getChildAt(i2);
+            float abs = Math.abs(f - offsetChild(childAt, calculateChildStartForFill, itemSize, rect));
+            if (childAt != null && abs < f2) {
+                this.currentEstimatedPosition = getPosition(childAt);
+                f2 = abs;
+            }
+            calculateChildStartForFill = addEnd(calculateChildStartForFill, this.currentKeylineState.getItemSize());
+        }
+        fill(recycler, state);
+        return calculateShouldScrollBy;
+    }
+
+    private float offsetChild(View view, float f, float f2, Rect rect) {
+        float addEnd = addEnd(f, f2);
+        KeylineRange surroundingKeylineRange = getSurroundingKeylineRange(this.currentKeylineState.getKeylines(), addEnd, false);
+        float calculateChildOffsetCenterForLocation = calculateChildOffsetCenterForLocation(view, addEnd, surroundingKeylineRange);
+        super.getDecoratedBoundsWithMargins(view, rect);
+        updateChildMaskForLocation(view, addEnd, surroundingKeylineRange);
+        this.orientationHelper.offsetChild(view, rect, f2, calculateChildOffsetCenterForLocation);
+        return calculateChildOffsetCenterForLocation;
+    }
+
+    @Override // androidx.recyclerview.widget.RecyclerView.LayoutManager
+    public int computeHorizontalScrollExtent(RecyclerView.State state) {
+        if (getChildCount() == 0 || this.keylineStateList == null || getItemCount() <= 1) {
+            return 0;
+        }
+        return (int) (getWidth() * (this.keylineStateList.getDefaultState().getItemSize() / computeHorizontalScrollRange(state)));
+    }
+
+    @Override // androidx.recyclerview.widget.RecyclerView.LayoutManager
+    public int computeVerticalScrollExtent(RecyclerView.State state) {
+        if (getChildCount() == 0 || this.keylineStateList == null || getItemCount() <= 1) {
+            return 0;
+        }
+        return (int) (getHeight() * (this.keylineStateList.getDefaultState().getItemSize() / computeVerticalScrollRange(state)));
+    }
+
+    public int getOrientation() {
+        return this.orientationHelper.orientation;
+    }
+
+    public void setOrientation(int i) {
+        if (i != 0 && i != 1) {
+            throw new IllegalArgumentException("invalid orientation:" + i);
+        }
+        assertNotInLayoutOrScroll(null);
+        CarouselOrientationHelper carouselOrientationHelper = this.orientationHelper;
+        if (carouselOrientationHelper == null || i != carouselOrientationHelper.orientation) {
+            this.orientationHelper = CarouselOrientationHelper.createOrientationHelper(this, i);
+            refreshKeylineState();
+        }
+    }
+
+    @Override // androidx.recyclerview.widget.RecyclerView.LayoutManager
+    public void onItemsAdded(RecyclerView recyclerView, int i, int i2) {
+        super.onItemsAdded(recyclerView, i, i2);
+        updateItemCount();
+    }
+
+    @Override // androidx.recyclerview.widget.RecyclerView.LayoutManager
+    public void onItemsRemoved(RecyclerView recyclerView, int i, int i2) {
+        super.onItemsRemoved(recyclerView, i, i2);
+        updateItemCount();
+    }
+
+    private void updateItemCount() {
+        int itemCount = getItemCount();
+        int i = this.lastItemCount;
+        if (itemCount == i || this.keylineStateList == null) {
+            return;
+        }
+        if (this.carouselStrategy.shouldRefreshKeylineState(this, i)) {
+            refreshKeylineState();
+        }
+        this.lastItemCount = itemCount;
+    }
+
+    public void setDebuggingEnabled(RecyclerView recyclerView, boolean z) {
+        this.isDebuggingEnabled = z;
+        recyclerView.removeItemDecoration(this.debugItemDecoration);
+        if (z) {
+            recyclerView.addItemDecoration(this.debugItemDecoration);
+        }
+        recyclerView.invalidateItemDecorations();
+    }
+
+    private static class KeylineRange {
+        final KeylineState.Keyline leftOrTop;
+        final KeylineState.Keyline rightOrBottom;
+
+        KeylineRange(KeylineState.Keyline keyline, KeylineState.Keyline keyline2) {
+            Preconditions.checkArgument(keyline.loc <= keyline2.loc);
+            this.leftOrTop = keyline;
+            this.rightOrBottom = keyline2;
+        }
+    }
+
+    private static class DebugItemDecoration extends RecyclerView.ItemDecoration {
+        private List<KeylineState.Keyline> keylines;
+        private final Paint linePaint;
+
+        DebugItemDecoration() {
+            Paint paint = new Paint();
+            this.linePaint = paint;
+            this.keylines = Collections.unmodifiableList(new ArrayList());
+            paint.setStrokeWidth(5.0f);
+            paint.setColor(-65281);
+        }
+
+        void setKeylines(List<KeylineState.Keyline> list) {
+            this.keylines = Collections.unmodifiableList(list);
+        }
+
+        @Override // androidx.recyclerview.widget.RecyclerView.ItemDecoration
+        public void onDrawOver(Canvas canvas, RecyclerView recyclerView, RecyclerView.State state) {
+            super.onDrawOver(canvas, recyclerView, state);
+            this.linePaint.setStrokeWidth(recyclerView.getResources().getDimension(R.dimen.m3_carousel_debug_keyline_width));
+            for (KeylineState.Keyline keyline : this.keylines) {
+                this.linePaint.setColor(ColorUtils.blendARGB(-65281, -16776961, keyline.mask));
+                if (((CarouselLayoutManager) recyclerView.getLayoutManager()).isHorizontal()) {
+                    canvas.drawLine(keyline.locOffset, ((CarouselLayoutManager) recyclerView.getLayoutManager()).getParentTop(), keyline.locOffset, ((CarouselLayoutManager) recyclerView.getLayoutManager()).getParentBottom(), this.linePaint);
+                } else {
+                    canvas.drawLine(((CarouselLayoutManager) recyclerView.getLayoutManager()).getParentLeft(), keyline.locOffset, ((CarouselLayoutManager) recyclerView.getLayoutManager()).getParentRight(), keyline.locOffset, this.linePaint);
+                }
+            }
+        }
+    }
+}

02-Easy5/E5/sources/com/google/android/material/carousel/CarouselOrientationHelper.java

@@ -0,0 +1,211 @@
+package com.google.android.material.carousel;
+
+import android.graphics.Rect;
+import android.graphics.RectF;
+import android.view.View;
+import androidx.recyclerview.widget.RecyclerView;
+
+/* loaded from: classes.dex */
+abstract class CarouselOrientationHelper {
+    final int orientation;
+
+    abstract void containMaskWithinBounds(RectF rectF, RectF rectF2, RectF rectF3);
+
+    abstract float getMaskMargins(RecyclerView.LayoutParams layoutParams);
+
+    abstract RectF getMaskRect(float f, float f2, float f3, float f4);
+
+    abstract int getParentBottom();
+
+    abstract int getParentEnd();
+
+    abstract int getParentLeft();
+
+    abstract int getParentRight();
+
+    abstract int getParentStart();
+
+    abstract int getParentTop();
+
+    abstract void layoutDecoratedWithMargins(View view, int i, int i2);
+
+    abstract void moveMaskOnEdgeOutsideBounds(RectF rectF, RectF rectF2, RectF rectF3);
+
+    abstract void offsetChild(View view, Rect rect, float f, float f2);
+
+    private CarouselOrientationHelper(int i) {
+        this.orientation = i;
+    }
+
+    static CarouselOrientationHelper createOrientationHelper(CarouselLayoutManager carouselLayoutManager, int i) {
+        if (i == 0) {
+            return createHorizontalHelper(carouselLayoutManager);
+        }
+        if (i == 1) {
+            return createVerticalHelper(carouselLayoutManager);
+        }
+        throw new IllegalArgumentException("invalid orientation");
+    }
+
+    private static CarouselOrientationHelper createVerticalHelper(final CarouselLayoutManager carouselLayoutManager) {
+        return new CarouselOrientationHelper(1) { // from class: com.google.android.material.carousel.CarouselOrientationHelper.1
+            @Override // com.google.android.material.carousel.CarouselOrientationHelper
+            int getParentTop() {
+                return 0;
+            }
+
+            @Override // com.google.android.material.carousel.CarouselOrientationHelper
+            int getParentLeft() {
+                return carouselLayoutManager.getPaddingLeft();
+            }
+
+            @Override // com.google.android.material.carousel.CarouselOrientationHelper
+            int getParentStart() {
+                return getParentTop();
+            }
+
+            @Override // com.google.android.material.carousel.CarouselOrientationHelper
+            int getParentRight() {
+                return carouselLayoutManager.getWidth() - carouselLayoutManager.getPaddingRight();
+            }
+
+            @Override // com.google.android.material.carousel.CarouselOrientationHelper
+            int getParentEnd() {
+                return getParentBottom();
+            }
+
+            @Override // com.google.android.material.carousel.CarouselOrientationHelper
+            int getParentBottom() {
+                return carouselLayoutManager.getHeight();
+            }
+
+            @Override // com.google.android.material.carousel.CarouselOrientationHelper
+            public void layoutDecoratedWithMargins(View view, int i, int i2) {
+                carouselLayoutManager.layoutDecoratedWithMargins(view, getParentLeft(), i, getParentRight(), i2);
+            }
+
+            @Override // com.google.android.material.carousel.CarouselOrientationHelper
+            public float getMaskMargins(RecyclerView.LayoutParams layoutParams) {
+                return layoutParams.topMargin + layoutParams.bottomMargin;
+            }
+
+            @Override // com.google.android.material.carousel.CarouselOrientationHelper
+            public RectF getMaskRect(float f, float f2, float f3, float f4) {
+                return new RectF(0.0f, f3, f2, f - f3);
+            }
+
+            @Override // com.google.android.material.carousel.CarouselOrientationHelper
+            public void containMaskWithinBounds(RectF rectF, RectF rectF2, RectF rectF3) {
+                if (rectF2.top < rectF3.top && rectF2.bottom > rectF3.top) {
+                    float f = rectF3.top - rectF2.top;
+                    rectF.top += f;
+                    rectF3.top += f;
+                }
+                if (rectF2.bottom <= rectF3.bottom || rectF2.top >= rectF3.bottom) {
+                    return;
+                }
+                float f2 = rectF2.bottom - rectF3.bottom;
+                rectF.bottom = Math.max(rectF.bottom - f2, rectF.top);
+                rectF2.bottom = Math.max(rectF2.bottom - f2, rectF2.top);
+            }
+
+            @Override // com.google.android.material.carousel.CarouselOrientationHelper
+            public void moveMaskOnEdgeOutsideBounds(RectF rectF, RectF rectF2, RectF rectF3) {
+                if (rectF2.bottom <= rectF3.top) {
+                    rectF.bottom = ((float) Math.floor(rectF.bottom)) - 1.0f;
+                    rectF.top = Math.min(rectF.top, rectF.bottom);
+                }
+                if (rectF2.top >= rectF3.bottom) {
+                    rectF.top = ((float) Math.ceil(rectF.top)) + 1.0f;
+                    rectF.bottom = Math.max(rectF.top, rectF.bottom);
+                }
+            }
+
+            @Override // com.google.android.material.carousel.CarouselOrientationHelper
+            public void offsetChild(View view, Rect rect, float f, float f2) {
+                view.offsetTopAndBottom((int) (f2 - (rect.top + f)));
+            }
+        };
+    }
+
+    private static CarouselOrientationHelper createHorizontalHelper(final CarouselLayoutManager carouselLayoutManager) {
+        return new CarouselOrientationHelper(0) { // from class: com.google.android.material.carousel.CarouselOrientationHelper.2
+            @Override // com.google.android.material.carousel.CarouselOrientationHelper
+            int getParentLeft() {
+                return 0;
+            }
+
+            @Override // com.google.android.material.carousel.CarouselOrientationHelper
+            int getParentStart() {
+                return carouselLayoutManager.isLayoutRtl() ? getParentRight() : getParentLeft();
+            }
+
+            @Override // com.google.android.material.carousel.CarouselOrientationHelper
+            int getParentRight() {
+                return carouselLayoutManager.getWidth();
+            }
+
+            @Override // com.google.android.material.carousel.CarouselOrientationHelper
+            int getParentEnd() {
+                return carouselLayoutManager.isLayoutRtl() ? getParentLeft() : getParentRight();
+            }
+
+            @Override // com.google.android.material.carousel.CarouselOrientationHelper
+            int getParentTop() {
+                return carouselLayoutManager.getPaddingTop();
+            }
+
+            @Override // com.google.android.material.carousel.CarouselOrientationHelper
+            int getParentBottom() {
+                return carouselLayoutManager.getHeight() - carouselLayoutManager.getPaddingBottom();
+            }
+
+            @Override // com.google.android.material.carousel.CarouselOrientationHelper
+            public void layoutDecoratedWithMargins(View view, int i, int i2) {
+                carouselLayoutManager.layoutDecoratedWithMargins(view, i, getParentTop(), i2, getParentBottom());
+            }
+
+            @Override // com.google.android.material.carousel.CarouselOrientationHelper
+            public float getMaskMargins(RecyclerView.LayoutParams layoutParams) {
+                return layoutParams.rightMargin + layoutParams.leftMargin;
+            }
+
+            @Override // com.google.android.material.carousel.CarouselOrientationHelper
+            public RectF getMaskRect(float f, float f2, float f3, float f4) {
+                return new RectF(f4, 0.0f, f2 - f4, f);
+            }
+
+            @Override // com.google.android.material.carousel.CarouselOrientationHelper
+            public void containMaskWithinBounds(RectF rectF, RectF rectF2, RectF rectF3) {
+                if (rectF2.left < rectF3.left && rectF2.right > rectF3.left) {
+                    float f = rectF3.left - rectF2.left;
+                    rectF.left += f;
+                    rectF2.left += f;
+                }
+                if (rectF2.right <= rectF3.right || rectF2.left >= rectF3.right) {
+                    return;
+                }
+                float f2 = rectF2.right - rectF3.right;
+                rectF.right = Math.max(rectF.right - f2, rectF.left);
+                rectF2.right = Math.max(rectF2.right - f2, rectF2.left);
+            }
+
+            @Override // com.google.android.material.carousel.CarouselOrientationHelper
+            public void moveMaskOnEdgeOutsideBounds(RectF rectF, RectF rectF2, RectF rectF3) {
+                if (rectF2.right <= rectF3.left) {
+                    rectF.right = ((float) Math.floor(rectF.right)) - 1.0f;
+                    rectF.left = Math.min(rectF.left, rectF.right);
+                }
+                if (rectF2.left >= rectF3.right) {
+                    rectF.left = ((float) Math.ceil(rectF.left)) + 1.0f;
+                    rectF.right = Math.max(rectF.left, rectF.right);
+                }
+            }
+
+            @Override // com.google.android.material.carousel.CarouselOrientationHelper
+            public void offsetChild(View view, Rect rect, float f, float f2) {
+                view.offsetLeftAndRight((int) (f2 - (rect.left + f)));
+            }
+        };
+    }
+}

02-Easy5/E5/sources/com/google/android/material/carousel/CarouselSnapHelper.java

@@ -0,0 +1,166 @@
+package com.google.android.material.carousel;
+
+import android.graphics.PointF;
+import android.util.DisplayMetrics;
+import android.view.View;
+import androidx.recyclerview.widget.LinearSmoothScroller;
+import androidx.recyclerview.widget.RecyclerView;
+import androidx.recyclerview.widget.SnapHelper;
+
+/* loaded from: classes.dex */
+public class CarouselSnapHelper extends SnapHelper {
+    private static final float HORIZONTAL_SNAP_SPEED = 100.0f;
+    private static final float VERTICAL_SNAP_SPEED = 50.0f;
+    private final boolean disableFling;
+    private RecyclerView recyclerView;
+
+    public CarouselSnapHelper() {
+        this(true);
+    }
+
+    public CarouselSnapHelper(boolean z) {
+        this.disableFling = z;
+    }
+
+    @Override // androidx.recyclerview.widget.SnapHelper
+    public void attachToRecyclerView(RecyclerView recyclerView) {
+        super.attachToRecyclerView(recyclerView);
+        this.recyclerView = recyclerView;
+    }
+
+    @Override // androidx.recyclerview.widget.SnapHelper
+    public int[] calculateDistanceToFinalSnap(RecyclerView.LayoutManager layoutManager, View view) {
+        return calculateDistanceToSnap(layoutManager, view, false);
+    }
+
+    /* JADX INFO: Access modifiers changed from: private */
+    public int[] calculateDistanceToSnap(RecyclerView.LayoutManager layoutManager, View view, boolean z) {
+        if (!(layoutManager instanceof CarouselLayoutManager)) {
+            return new int[]{0, 0};
+        }
+        int distanceToFirstFocalKeyline = distanceToFirstFocalKeyline(view, (CarouselLayoutManager) layoutManager, z);
+        return layoutManager.canScrollHorizontally() ? new int[]{distanceToFirstFocalKeyline, 0} : layoutManager.canScrollVertically() ? new int[]{0, distanceToFirstFocalKeyline} : new int[]{0, 0};
+    }
+
+    private int distanceToFirstFocalKeyline(View view, CarouselLayoutManager carouselLayoutManager, boolean z) {
+        return carouselLayoutManager.getOffsetToScrollToPositionForSnap(carouselLayoutManager.getPosition(view), z);
+    }
+
+    @Override // androidx.recyclerview.widget.SnapHelper
+    public View findSnapView(RecyclerView.LayoutManager layoutManager) {
+        return findViewNearestFirstKeyline(layoutManager);
+    }
+
+    private View findViewNearestFirstKeyline(RecyclerView.LayoutManager layoutManager) {
+        int childCount = layoutManager.getChildCount();
+        View view = null;
+        if (childCount != 0 && (layoutManager instanceof CarouselLayoutManager)) {
+            CarouselLayoutManager carouselLayoutManager = (CarouselLayoutManager) layoutManager;
+            int i = Integer.MAX_VALUE;
+            for (int i2 = 0; i2 < childCount; i2++) {
+                View childAt = layoutManager.getChildAt(i2);
+                int abs = Math.abs(carouselLayoutManager.getOffsetToScrollToPositionForSnap(layoutManager.getPosition(childAt), false));
+                if (abs < i) {
+                    view = childAt;
+                    i = abs;
+                }
+            }
+        }
+        return view;
+    }
+
+    @Override // androidx.recyclerview.widget.SnapHelper
+    public int findTargetSnapPosition(RecyclerView.LayoutManager layoutManager, int i, int i2) {
+        int itemCount;
+        if (!this.disableFling || (itemCount = layoutManager.getItemCount()) == 0) {
+            return -1;
+        }
+        int childCount = layoutManager.getChildCount();
+        View view = null;
+        View view2 = null;
+        int i3 = Integer.MIN_VALUE;
+        int i4 = Integer.MAX_VALUE;
+        for (int i5 = 0; i5 < childCount; i5++) {
+            View childAt = layoutManager.getChildAt(i5);
+            if (childAt != null) {
+                int distanceToFirstFocalKeyline = distanceToFirstFocalKeyline(childAt, (CarouselLayoutManager) layoutManager, false);
+                if (distanceToFirstFocalKeyline <= 0 && distanceToFirstFocalKeyline > i3) {
+                    view2 = childAt;
+                    i3 = distanceToFirstFocalKeyline;
+                }
+                if (distanceToFirstFocalKeyline >= 0 && distanceToFirstFocalKeyline < i4) {
+                    view = childAt;
+                    i4 = distanceToFirstFocalKeyline;
+                }
+            }
+        }
+        boolean isForwardFling = isForwardFling(layoutManager, i, i2);
+        if (isForwardFling && view != null) {
+            return layoutManager.getPosition(view);
+        }
+        if (!isForwardFling && view2 != null) {
+            return layoutManager.getPosition(view2);
+        }
+        if (isForwardFling) {
+            view = view2;
+        }
+        if (view == null) {
+            return -1;
+        }
+        int position = layoutManager.getPosition(view) + (isReverseLayout(layoutManager) == isForwardFling ? -1 : 1);
+        if (position < 0 || position >= itemCount) {
+            return -1;
+        }
+        return position;
+    }
+
+    private boolean isForwardFling(RecyclerView.LayoutManager layoutManager, int i, int i2) {
+        return layoutManager.canScrollHorizontally() ? i > 0 : i2 > 0;
+    }
+
+    /* JADX WARN: Multi-variable type inference failed */
+    private boolean isReverseLayout(RecyclerView.LayoutManager layoutManager) {
+        PointF computeScrollVectorForPosition;
+        int itemCount = layoutManager.getItemCount();
+        if (!(layoutManager instanceof RecyclerView.SmoothScroller.ScrollVectorProvider) || (computeScrollVectorForPosition = ((RecyclerView.SmoothScroller.ScrollVectorProvider) layoutManager).computeScrollVectorForPosition(itemCount - 1)) == null) {
+            return false;
+        }
+        return computeScrollVectorForPosition.x < 0.0f || computeScrollVectorForPosition.y < 0.0f;
+    }
+
+    @Override // androidx.recyclerview.widget.SnapHelper
+    protected RecyclerView.SmoothScroller createScroller(final RecyclerView.LayoutManager layoutManager) {
+        if (layoutManager instanceof RecyclerView.SmoothScroller.ScrollVectorProvider) {
+            return new LinearSmoothScroller(this.recyclerView.getContext()) { // from class: com.google.android.material.carousel.CarouselSnapHelper.1
+                @Override // androidx.recyclerview.widget.LinearSmoothScroller, androidx.recyclerview.widget.RecyclerView.SmoothScroller
+                protected void onTargetFound(View view, RecyclerView.State state, RecyclerView.SmoothScroller.Action action) {
+                    if (CarouselSnapHelper.this.recyclerView != null) {
+                        CarouselSnapHelper carouselSnapHelper = CarouselSnapHelper.this;
+                        int[] calculateDistanceToSnap = carouselSnapHelper.calculateDistanceToSnap(carouselSnapHelper.recyclerView.getLayoutManager(), view, true);
+                        int i = calculateDistanceToSnap[0];
+                        int i2 = calculateDistanceToSnap[1];
+                        int calculateTimeForDeceleration = calculateTimeForDeceleration(Math.max(Math.abs(i), Math.abs(i2)));
+                        if (calculateTimeForDeceleration > 0) {
+                            action.update(i, i2, calculateTimeForDeceleration, this.mDecelerateInterpolator);
+                        }
+                    }
+                }
+
+                @Override // androidx.recyclerview.widget.LinearSmoothScroller
+                protected float calculateSpeedPerPixel(DisplayMetrics displayMetrics) {
+                    float f;
+                    float f2;
+                    if (layoutManager.canScrollVertically()) {
+                        f = displayMetrics.densityDpi;
+                        f2 = 50.0f;
+                    } else {
+                        f = displayMetrics.densityDpi;
+                        f2 = CarouselSnapHelper.HORIZONTAL_SNAP_SPEED;
+                    }
+                    return f2 / f;
+                }
+            };
+        }
+        return null;
+    }
+}

02-Easy5/E5/sources/com/google/android/material/carousel/CarouselStrategy.java

@@ -0,0 +1,29 @@
+package com.google.android.material.carousel;
+
+import android.view.View;
+
+/* loaded from: classes.dex */
+public abstract class CarouselStrategy {
+    static float getChildMaskPercentage(float f, float f2, float f3) {
+        return 1.0f - ((f - f3) / (f2 - f3));
+    }
+
+    boolean isContained() {
+        return true;
+    }
+
+    abstract KeylineState onFirstChildMeasuredWithMargins(Carousel carousel, View view);
+
+    boolean shouldRefreshKeylineState(Carousel carousel, int i) {
+        return false;
+    }
+
+    static int[] doubleCounts(int[] iArr) {
+        int length = iArr.length;
+        int[] iArr2 = new int[length];
+        for (int i = 0; i < length; i++) {
+            iArr2[i] = iArr[i] * 2;
+        }
+        return iArr2;
+    }
+}

02-Easy5/E5/sources/com/google/android/material/carousel/CarouselStrategyHelper.java

@@ -0,0 +1,113 @@
+package com.google.android.material.carousel;
+
+import android.content.Context;
+import com.google.android.material.R;
+import com.google.android.material.carousel.KeylineState;
+
+/* loaded from: classes.dex */
+final class CarouselStrategyHelper {
+    static float addStart(float f, float f2, int i) {
+        return i > 0 ? f + (f2 / 2.0f) : f;
+    }
+
+    static float updateCurPosition(float f, float f2, float f3, int i) {
+        return i > 0 ? f2 + (f3 / 2.0f) : f;
+    }
+
+    private CarouselStrategyHelper() {
+    }
+
+    static float getExtraSmallSize(Context context) {
+        return context.getResources().getDimension(R.dimen.m3_carousel_gone_size);
+    }
+
+    static float getSmallSizeMin(Context context) {
+        return context.getResources().getDimension(R.dimen.m3_carousel_small_item_size_min);
+    }
+
+    static float getSmallSizeMax(Context context) {
+        return context.getResources().getDimension(R.dimen.m3_carousel_small_item_size_max);
+    }
+
+    static KeylineState createKeylineState(Context context, float f, float f2, Arrangement arrangement, int i) {
+        if (i == 1) {
+            return createCenterAlignedKeylineState(context, f, f2, arrangement);
+        }
+        return createLeftAlignedKeylineState(context, f, f2, arrangement);
+    }
+
+    static KeylineState createLeftAlignedKeylineState(Context context, float f, float f2, Arrangement arrangement) {
+        float min = Math.min(getExtraSmallSize(context) + f, arrangement.largeSize);
+        float f3 = min / 2.0f;
+        float f4 = 0.0f - f3;
+        float addStart = addStart(0.0f, arrangement.largeSize, arrangement.largeCount);
+        float updateCurPosition = updateCurPosition(0.0f, addEnd(addStart, arrangement.largeSize, arrangement.largeCount), arrangement.largeSize, arrangement.largeCount);
+        float addStart2 = addStart(updateCurPosition, arrangement.mediumSize, arrangement.mediumCount);
+        float addStart3 = addStart(updateCurPosition(updateCurPosition, addStart2, arrangement.mediumSize, arrangement.mediumCount), arrangement.smallSize, arrangement.smallCount);
+        float f5 = f3 + f2;
+        float childMaskPercentage = CarouselStrategy.getChildMaskPercentage(min, arrangement.largeSize, f);
+        float childMaskPercentage2 = CarouselStrategy.getChildMaskPercentage(arrangement.smallSize, arrangement.largeSize, f);
+        float childMaskPercentage3 = CarouselStrategy.getChildMaskPercentage(arrangement.mediumSize, arrangement.largeSize, f);
+        KeylineState.Builder addKeylineRange = new KeylineState.Builder(arrangement.largeSize, f2).addAnchorKeyline(f4, childMaskPercentage, min).addKeylineRange(addStart, 0.0f, arrangement.largeSize, arrangement.largeCount, true);
+        if (arrangement.mediumCount > 0) {
+            addKeylineRange.addKeyline(addStart2, childMaskPercentage3, arrangement.mediumSize);
+        }
+        if (arrangement.smallCount > 0) {
+            addKeylineRange.addKeylineRange(addStart3, childMaskPercentage2, arrangement.smallSize, arrangement.smallCount);
+        }
+        addKeylineRange.addAnchorKeyline(f5, childMaskPercentage, min);
+        return addKeylineRange.build();
+    }
+
+    static KeylineState createCenterAlignedKeylineState(Context context, float f, float f2, Arrangement arrangement) {
+        float f3;
+        float min = Math.min(getExtraSmallSize(context) + f, arrangement.largeSize);
+        float f4 = min / 2.0f;
+        float f5 = 0.0f - f4;
+        float addStart = addStart(0.0f, arrangement.smallSize, arrangement.smallCount);
+        float updateCurPosition = updateCurPosition(0.0f, addEnd(addStart, arrangement.smallSize, (int) Math.floor(arrangement.smallCount / 2.0f)), arrangement.smallSize, arrangement.smallCount);
+        float addStart2 = addStart(updateCurPosition, arrangement.mediumSize, arrangement.mediumCount);
+        float updateCurPosition2 = updateCurPosition(updateCurPosition, addEnd(addStart2, arrangement.mediumSize, (int) Math.floor(arrangement.mediumCount / 2.0f)), arrangement.mediumSize, arrangement.mediumCount);
+        float addStart3 = addStart(updateCurPosition2, arrangement.largeSize, arrangement.largeCount);
+        float updateCurPosition3 = updateCurPosition(updateCurPosition2, addEnd(addStart3, arrangement.largeSize, arrangement.largeCount), arrangement.largeSize, arrangement.largeCount);
+        float addStart4 = addStart(updateCurPosition3, arrangement.mediumSize, arrangement.mediumCount);
+        float addStart5 = addStart(updateCurPosition(updateCurPosition3, addEnd(addStart4, arrangement.mediumSize, (int) Math.ceil(arrangement.mediumCount / 2.0f)), arrangement.mediumSize, arrangement.mediumCount), arrangement.smallSize, arrangement.smallCount);
+        float f6 = f4 + f2;
+        float childMaskPercentage = CarouselStrategy.getChildMaskPercentage(min, arrangement.largeSize, f);
+        float childMaskPercentage2 = CarouselStrategy.getChildMaskPercentage(arrangement.smallSize, arrangement.largeSize, f);
+        float childMaskPercentage3 = CarouselStrategy.getChildMaskPercentage(arrangement.mediumSize, arrangement.largeSize, f);
+        KeylineState.Builder addAnchorKeyline = new KeylineState.Builder(arrangement.largeSize, f2).addAnchorKeyline(f5, childMaskPercentage, min);
+        if (arrangement.smallCount > 0) {
+            f3 = f6;
+            addAnchorKeyline.addKeylineRange(addStart, childMaskPercentage2, arrangement.smallSize, (int) Math.floor(arrangement.smallCount / 2.0f));
+        } else {
+            f3 = f6;
+        }
+        if (arrangement.mediumCount > 0) {
+            addAnchorKeyline.addKeylineRange(addStart2, childMaskPercentage3, arrangement.mediumSize, (int) Math.floor(arrangement.mediumCount / 2.0f));
+        }
+        addAnchorKeyline.addKeylineRange(addStart3, 0.0f, arrangement.largeSize, arrangement.largeCount, true);
+        if (arrangement.mediumCount > 0) {
+            addAnchorKeyline.addKeylineRange(addStart4, childMaskPercentage3, arrangement.mediumSize, (int) Math.ceil(arrangement.mediumCount / 2.0f));
+        }
+        if (arrangement.smallCount > 0) {
+            addAnchorKeyline.addKeylineRange(addStart5, childMaskPercentage2, arrangement.smallSize, (int) Math.ceil(arrangement.smallCount / 2.0f));
+        }
+        addAnchorKeyline.addAnchorKeyline(f3, childMaskPercentage, min);
+        return addAnchorKeyline.build();
+    }
+
+    static int maxValue(int[] iArr) {
+        int i = Integer.MIN_VALUE;
+        for (int i2 : iArr) {
+            if (i2 > i) {
+                i = i2;
+            }
+        }
+        return i;
+    }
+
+    static float addEnd(float f, float f2, int i) {
+        return f + (Math.max(0, i - 1) * f2);
+    }
+}

02-Easy5/E5/sources/com/google/android/material/carousel/FullScreenCarouselStrategy.java

@@ -0,0 +1,26 @@
+package com.google.android.material.carousel;
+
+import android.view.View;
+import androidx.recyclerview.widget.RecyclerView;
+
+/* loaded from: classes.dex */
+public class FullScreenCarouselStrategy extends CarouselStrategy {
+    @Override // com.google.android.material.carousel.CarouselStrategy
+    KeylineState onFirstChildMeasuredWithMargins(Carousel carousel, View view) {
+        float containerHeight;
+        int i;
+        int i2;
+        RecyclerView.LayoutParams layoutParams = (RecyclerView.LayoutParams) view.getLayoutParams();
+        if (carousel.isHorizontal()) {
+            containerHeight = carousel.getContainerWidth();
+            i = layoutParams.leftMargin;
+            i2 = layoutParams.rightMargin;
+        } else {
+            containerHeight = carousel.getContainerHeight();
+            i = layoutParams.topMargin;
+            i2 = layoutParams.bottomMargin;
+        }
+        float f = i + i2;
+        return CarouselStrategyHelper.createLeftAlignedKeylineState(view.getContext(), f, containerHeight, new Arrangement(0, 0.0f, 0.0f, 0.0f, 0, 0.0f, 0, Math.min(containerHeight + f, containerHeight), 1, containerHeight));
+    }
+}

02-Easy5/E5/sources/com/google/android/material/carousel/HeroCarouselStrategy.java

@@ -0,0 +1,64 @@
+package com.google.android.material.carousel;
+
+import android.view.View;
+import androidx.core.math.MathUtils;
+import androidx.recyclerview.widget.RecyclerView;
+
+/* loaded from: classes.dex */
+public class HeroCarouselStrategy extends CarouselStrategy {
+    private int keylineCount = 0;
+    private static final int[] SMALL_COUNTS = {1};
+    private static final int[] MEDIUM_COUNTS = {0, 1};
+
+    @Override // com.google.android.material.carousel.CarouselStrategy
+    KeylineState onFirstChildMeasuredWithMargins(Carousel carousel, View view) {
+        int i;
+        int containerHeight = carousel.getContainerHeight();
+        if (carousel.isHorizontal()) {
+            containerHeight = carousel.getContainerWidth();
+        }
+        RecyclerView.LayoutParams layoutParams = (RecyclerView.LayoutParams) view.getLayoutParams();
+        float f = layoutParams.topMargin + layoutParams.bottomMargin;
+        float measuredWidth = view.getMeasuredWidth() * 2;
+        if (carousel.isHorizontal()) {
+            f = layoutParams.leftMargin + layoutParams.rightMargin;
+            measuredWidth = view.getMeasuredHeight() * 2;
+        }
+        float smallSizeMin = CarouselStrategyHelper.getSmallSizeMin(view.getContext()) + f;
+        float smallSizeMax = CarouselStrategyHelper.getSmallSizeMax(view.getContext()) + f;
+        float f2 = containerHeight;
+        float min = Math.min(measuredWidth + f, f2);
+        float clamp = MathUtils.clamp((measuredWidth / 3.0f) + f, CarouselStrategyHelper.getSmallSizeMin(view.getContext()) + f, CarouselStrategyHelper.getSmallSizeMax(view.getContext()) + f);
+        float f3 = (min + clamp) / 2.0f;
+        int[] iArr = f2 < 2.0f * smallSizeMin ? new int[]{0} : SMALL_COUNTS;
+        int max = (int) Math.max(1.0d, Math.floor((f2 - (CarouselStrategyHelper.maxValue(r4) * smallSizeMax)) / min));
+        int ceil = (((int) Math.ceil(f2 / min)) - max) + 1;
+        int[] iArr2 = new int[ceil];
+        for (int i2 = 0; i2 < ceil; i2++) {
+            iArr2[i2] = max + i2;
+        }
+        int i3 = carousel.getCarouselAlignment() == 1 ? 1 : 0;
+        Arrangement findLowestCostArrangement = Arrangement.findLowestCostArrangement(f2, clamp, smallSizeMin, smallSizeMax, i3 != 0 ? doubleCounts(iArr) : iArr, f3, i3 != 0 ? doubleCounts(MEDIUM_COUNTS) : MEDIUM_COUNTS, min, iArr2);
+        this.keylineCount = findLowestCostArrangement.getItemCount();
+        if (findLowestCostArrangement.getItemCount() > carousel.getItemCount()) {
+            findLowestCostArrangement = Arrangement.findLowestCostArrangement(f2, clamp, smallSizeMin, smallSizeMax, iArr, f3, MEDIUM_COUNTS, min, iArr2);
+            i = 0;
+        } else {
+            i = i3;
+        }
+        return CarouselStrategyHelper.createKeylineState(view.getContext(), f, f2, findLowestCostArrangement, i);
+    }
+
+    @Override // com.google.android.material.carousel.CarouselStrategy
+    boolean shouldRefreshKeylineState(Carousel carousel, int i) {
+        if (carousel.getCarouselAlignment() == 1) {
+            if (i < this.keylineCount && carousel.getItemCount() >= this.keylineCount) {
+                return true;
+            }
+            if (i >= this.keylineCount && carousel.getItemCount() < this.keylineCount) {
+                return true;
+            }
+        }
+        return false;
+    }
+}

02-Easy5/E5/sources/com/google/android/material/carousel/KeylineState.java

@@ -0,0 +1,252 @@
+package com.google.android.material.carousel;
+
+import com.google.android.material.animation.AnimationUtils;
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.List;
+
+/* loaded from: classes.dex */
+final class KeylineState {
+    private final int firstFocalKeylineIndex;
+    private final float itemSize;
+    private final List<Keyline> keylines;
+    private final int lastFocalKeylineIndex;
+
+    int getFirstFocalKeylineIndex() {
+        return this.firstFocalKeylineIndex;
+    }
+
+    float getItemSize() {
+        return this.itemSize;
+    }
+
+    List<Keyline> getKeylines() {
+        return this.keylines;
+    }
+
+    int getLastFocalKeylineIndex() {
+        return this.lastFocalKeylineIndex;
+    }
+
+    private KeylineState(float f, List<Keyline> list, int i, int i2) {
+        this.itemSize = f;
+        this.keylines = Collections.unmodifiableList(list);
+        this.firstFocalKeylineIndex = i;
+        this.lastFocalKeylineIndex = i2;
+    }
+
+    Keyline getFirstFocalKeyline() {
+        return this.keylines.get(this.firstFocalKeylineIndex);
+    }
+
+    Keyline getLastFocalKeyline() {
+        return this.keylines.get(this.lastFocalKeylineIndex);
+    }
+
+    List<Keyline> getFocalKeylines() {
+        return this.keylines.subList(this.firstFocalKeylineIndex, this.lastFocalKeylineIndex + 1);
+    }
+
+    Keyline getFirstKeyline() {
+        return this.keylines.get(0);
+    }
+
+    Keyline getLastKeyline() {
+        return this.keylines.get(r0.size() - 1);
+    }
+
+    Keyline getFirstNonAnchorKeyline() {
+        for (int i = 0; i < this.keylines.size(); i++) {
+            Keyline keyline = this.keylines.get(i);
+            if (!keyline.isAnchor) {
+                return keyline;
+            }
+        }
+        return null;
+    }
+
+    Keyline getLastNonAnchorKeyline() {
+        for (int size = this.keylines.size() - 1; size >= 0; size--) {
+            Keyline keyline = this.keylines.get(size);
+            if (!keyline.isAnchor) {
+                return keyline;
+            }
+        }
+        return null;
+    }
+
+    static KeylineState lerp(KeylineState keylineState, KeylineState keylineState2, float f) {
+        if (keylineState.getItemSize() != keylineState2.getItemSize()) {
+            throw new IllegalArgumentException("Keylines being linearly interpolated must have the same item size.");
+        }
+        List<Keyline> keylines = keylineState.getKeylines();
+        List<Keyline> keylines2 = keylineState2.getKeylines();
+        if (keylines.size() != keylines2.size()) {
+            throw new IllegalArgumentException("Keylines being linearly interpolated must have the same number of keylines.");
+        }
+        ArrayList arrayList = new ArrayList();
+        for (int i = 0; i < keylineState.getKeylines().size(); i++) {
+            arrayList.add(Keyline.lerp(keylines.get(i), keylines2.get(i), f));
+        }
+        return new KeylineState(keylineState.getItemSize(), arrayList, AnimationUtils.lerp(keylineState.getFirstFocalKeylineIndex(), keylineState2.getFirstFocalKeylineIndex(), f), AnimationUtils.lerp(keylineState.getLastFocalKeylineIndex(), keylineState2.getLastFocalKeylineIndex(), f));
+    }
+
+    static KeylineState reverse(KeylineState keylineState, float f) {
+        Builder builder = new Builder(keylineState.getItemSize(), f);
+        float f2 = (f - keylineState.getLastKeyline().locOffset) - (keylineState.getLastKeyline().maskedItemSize / 2.0f);
+        int size = keylineState.getKeylines().size() - 1;
+        while (size >= 0) {
+            Keyline keyline = keylineState.getKeylines().get(size);
+            builder.addKeyline(f2 + (keyline.maskedItemSize / 2.0f), keyline.mask, keyline.maskedItemSize, size >= keylineState.getFirstFocalKeylineIndex() && size <= keylineState.getLastFocalKeylineIndex(), keyline.isAnchor);
+            f2 += keyline.maskedItemSize;
+            size--;
+        }
+        return builder.build();
+    }
+
+    static final class Builder {
+        private static final int NO_INDEX = -1;
+        private static final float UNKNOWN_LOC = Float.MIN_VALUE;
+        private final float availableSpace;
+        private final float itemSize;
+        private Keyline tmpFirstFocalKeyline;
+        private Keyline tmpLastFocalKeyline;
+        private final List<Keyline> tmpKeylines = new ArrayList();
+        private int firstFocalKeylineIndex = -1;
+        private int lastFocalKeylineIndex = -1;
+        private float lastKeylineMaskedSize = 0.0f;
+        private int latestAnchorKeylineIndex = -1;
+
+        private static float calculateKeylineLocationForItemPosition(float f, float f2, int i, int i2) {
+            return (f - (i * f2)) + (i2 * f2);
+        }
+
+        Builder(float f, float f2) {
+            this.itemSize = f;
+            this.availableSpace = f2;
+        }
+
+        Builder addKeyline(float f, float f2, float f3, boolean z) {
+            return addKeyline(f, f2, f3, z, false);
+        }
+
+        Builder addKeyline(float f, float f2, float f3) {
+            return addKeyline(f, f2, f3, false);
+        }
+
+        Builder addKeyline(float f, float f2, float f3, boolean z, boolean z2, float f4) {
+            if (f3 <= 0.0f) {
+                return this;
+            }
+            if (z2) {
+                if (z) {
+                    throw new IllegalArgumentException("Anchor keylines cannot be focal.");
+                }
+                int i = this.latestAnchorKeylineIndex;
+                if (i != -1 && i != 0) {
+                    throw new IllegalArgumentException("Anchor keylines must be either the first or last keyline.");
+                }
+                this.latestAnchorKeylineIndex = this.tmpKeylines.size();
+            }
+            Keyline keyline = new Keyline(Float.MIN_VALUE, f, f2, f3, z2, f4);
+            if (z) {
+                if (this.tmpFirstFocalKeyline == null) {
+                    this.tmpFirstFocalKeyline = keyline;
+                    this.firstFocalKeylineIndex = this.tmpKeylines.size();
+                }
+                if (this.lastFocalKeylineIndex != -1 && this.tmpKeylines.size() - this.lastFocalKeylineIndex > 1) {
+                    throw new IllegalArgumentException("Keylines marked as focal must be placed next to each other. There cannot be non-focal keylines between focal keylines.");
+                }
+                if (f3 != this.tmpFirstFocalKeyline.maskedItemSize) {
+                    throw new IllegalArgumentException("Keylines that are marked as focal must all have the same masked item size.");
+                }
+                this.tmpLastFocalKeyline = keyline;
+                this.lastFocalKeylineIndex = this.tmpKeylines.size();
+            } else {
+                if (this.tmpFirstFocalKeyline == null && keyline.maskedItemSize < this.lastKeylineMaskedSize) {
+                    throw new IllegalArgumentException("Keylines before the first focal keyline must be ordered by incrementing masked item size.");
+                }
+                if (this.tmpLastFocalKeyline != null && keyline.maskedItemSize > this.lastKeylineMaskedSize) {
+                    throw new IllegalArgumentException("Keylines after the last focal keyline must be ordered by decreasing masked item size.");
+                }
+            }
+            this.lastKeylineMaskedSize = keyline.maskedItemSize;
+            this.tmpKeylines.add(keyline);
+            return this;
+        }
+
+        Builder addKeyline(float f, float f2, float f3, boolean z, boolean z2) {
+            float f4;
+            float abs;
+            float f5 = f3 / 2.0f;
+            float f6 = f - f5;
+            float f7 = f5 + f;
+            float f8 = this.availableSpace;
+            if (f7 > f8) {
+                abs = Math.abs(f7 - Math.max(f7 - f3, f8));
+            } else if (f6 < 0.0f) {
+                abs = Math.abs(f6 - Math.min(f6 + f3, 0.0f));
+            } else {
+                f4 = 0.0f;
+                return addKeyline(f, f2, f3, z, z2, f4);
+            }
+            f4 = abs;
+            return addKeyline(f, f2, f3, z, z2, f4);
+        }
+
+        Builder addAnchorKeyline(float f, float f2, float f3) {
+            return addKeyline(f, f2, f3, false, true);
+        }
+
+        Builder addKeylineRange(float f, float f2, float f3, int i) {
+            return addKeylineRange(f, f2, f3, i, false);
+        }
+
+        Builder addKeylineRange(float f, float f2, float f3, int i, boolean z) {
+            if (i > 0 && f3 > 0.0f) {
+                for (int i2 = 0; i2 < i; i2++) {
+                    addKeyline((i2 * f3) + f, f2, f3, z);
+                }
+            }
+            return this;
+        }
+
+        KeylineState build() {
+            if (this.tmpFirstFocalKeyline == null) {
+                throw new IllegalStateException("There must be a keyline marked as focal.");
+            }
+            ArrayList arrayList = new ArrayList();
+            for (int i = 0; i < this.tmpKeylines.size(); i++) {
+                Keyline keyline = this.tmpKeylines.get(i);
+                arrayList.add(new Keyline(calculateKeylineLocationForItemPosition(this.tmpFirstFocalKeyline.locOffset, this.itemSize, this.firstFocalKeylineIndex, i), keyline.locOffset, keyline.mask, keyline.maskedItemSize, keyline.isAnchor, keyline.cutoff));
+            }
+            return new KeylineState(this.itemSize, arrayList, this.firstFocalKeylineIndex, this.lastFocalKeylineIndex);
+        }
+    }
+
+    static final class Keyline {
+        final float cutoff;
+        final boolean isAnchor;
+        final float loc;
+        final float locOffset;
+        final float mask;
+        final float maskedItemSize;
+
+        Keyline(float f, float f2, float f3, float f4) {
+            this(f, f2, f3, f4, false, 0.0f);
+        }
+
+        Keyline(float f, float f2, float f3, float f4, boolean z, float f5) {
+            this.loc = f;
+            this.locOffset = f2;
+            this.mask = f3;
+            this.maskedItemSize = f4;
+            this.isAnchor = z;
+            this.cutoff = f5;
+        }
+
+        static Keyline lerp(Keyline keyline, Keyline keyline2, float f) {
+            return new Keyline(AnimationUtils.lerp(keyline.loc, keyline2.loc, f), AnimationUtils.lerp(keyline.locOffset, keyline2.locOffset, f), AnimationUtils.lerp(keyline.mask, keyline2.mask, f), AnimationUtils.lerp(keyline.maskedItemSize, keyline2.maskedItemSize, f));
+        }
+    }
+}

02-Easy5/E5/sources/com/google/android/material/carousel/KeylineStateList.java

@@ -0,0 +1,277 @@
+package com.google.android.material.carousel;
+
+import androidx.core.math.MathUtils;
+import com.google.android.material.animation.AnimationUtils;
+import com.google.android.material.carousel.KeylineState;
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+
+/* loaded from: classes.dex */
+class KeylineStateList {
+    private static final int NO_INDEX = -1;
+    private final KeylineState defaultState;
+    private final float endShiftRange;
+    private final List<KeylineState> endStateSteps;
+    private final float[] endStateStepsInterpolationPoints;
+    private final float startShiftRange;
+    private final List<KeylineState> startStateSteps;
+    private final float[] startStateStepsInterpolationPoints;
+
+    KeylineState getDefaultState() {
+        return this.defaultState;
+    }
+
+    private KeylineStateList(KeylineState keylineState, List<KeylineState> list, List<KeylineState> list2) {
+        this.defaultState = keylineState;
+        this.startStateSteps = Collections.unmodifiableList(list);
+        this.endStateSteps = Collections.unmodifiableList(list2);
+        float f = list.get(list.size() - 1).getFirstKeyline().loc - keylineState.getFirstKeyline().loc;
+        this.startShiftRange = f;
+        float f2 = keylineState.getLastKeyline().loc - list2.get(list2.size() - 1).getLastKeyline().loc;
+        this.endShiftRange = f2;
+        this.startStateStepsInterpolationPoints = getStateStepInterpolationPoints(f, list, true);
+        this.endStateStepsInterpolationPoints = getStateStepInterpolationPoints(f2, list2, false);
+    }
+
+    static KeylineStateList from(Carousel carousel, KeylineState keylineState) {
+        return new KeylineStateList(keylineState, getStateStepsStart(carousel, keylineState), getStateStepsEnd(carousel, keylineState));
+    }
+
+    KeylineState getStartState() {
+        return this.startStateSteps.get(r0.size() - 1);
+    }
+
+    KeylineState getEndState() {
+        return this.endStateSteps.get(r0.size() - 1);
+    }
+
+    public KeylineState getShiftedState(float f, float f2, float f3) {
+        return getShiftedState(f, f2, f3, false);
+    }
+
+    KeylineState getShiftedState(float f, float f2, float f3, boolean z) {
+        float lerp;
+        List<KeylineState> list;
+        float[] fArr;
+        float f4 = this.startShiftRange + f2;
+        float f5 = f3 - this.endShiftRange;
+        if (f < f4) {
+            lerp = AnimationUtils.lerp(1.0f, 0.0f, f2, f4, f);
+            list = this.startStateSteps;
+            fArr = this.startStateStepsInterpolationPoints;
+        } else {
+            if (f <= f5) {
+                return this.defaultState;
+            }
+            lerp = AnimationUtils.lerp(0.0f, 1.0f, f5, f3, f);
+            list = this.endStateSteps;
+            fArr = this.endStateStepsInterpolationPoints;
+        }
+        if (z) {
+            return closestStateStepFromInterpolation(list, lerp, fArr);
+        }
+        return lerp(list, lerp, fArr);
+    }
+
+    private static KeylineState lerp(List<KeylineState> list, float f, float[] fArr) {
+        float[] stateStepsRange = getStateStepsRange(list, f, fArr);
+        return KeylineState.lerp(list.get((int) stateStepsRange[1]), list.get((int) stateStepsRange[2]), stateStepsRange[0]);
+    }
+
+    private static float[] getStateStepsRange(List<KeylineState> list, float f, float[] fArr) {
+        int size = list.size();
+        float f2 = fArr[0];
+        int i = 1;
+        while (i < size) {
+            float f3 = fArr[i];
+            if (f <= f3) {
+                return new float[]{AnimationUtils.lerp(0.0f, 1.0f, f2, f3, f), i - 1, i};
+            }
+            i++;
+            f2 = f3;
+        }
+        return new float[]{0.0f, 0.0f, 0.0f};
+    }
+
+    private KeylineState closestStateStepFromInterpolation(List<KeylineState> list, float f, float[] fArr) {
+        float[] stateStepsRange = getStateStepsRange(list, f, fArr);
+        if (stateStepsRange[0] > 0.5f) {
+            return list.get((int) stateStepsRange[2]);
+        }
+        return list.get((int) stateStepsRange[1]);
+    }
+
+    private static float[] getStateStepInterpolationPoints(float f, List<KeylineState> list, boolean z) {
+        float f2;
+        int size = list.size();
+        float[] fArr = new float[size];
+        int i = 1;
+        while (i < size) {
+            int i2 = i - 1;
+            KeylineState keylineState = list.get(i2);
+            KeylineState keylineState2 = list.get(i);
+            if (z) {
+                f2 = keylineState2.getFirstKeyline().loc - keylineState.getFirstKeyline().loc;
+            } else {
+                f2 = keylineState.getLastKeyline().loc - keylineState2.getLastKeyline().loc;
+            }
+            fArr[i] = i == size + (-1) ? 1.0f : fArr[i2] + (f2 / f);
+            i++;
+        }
+        return fArr;
+    }
+
+    private static boolean isFirstFocalItemAtLeftOfContainer(KeylineState keylineState) {
+        return keylineState.getFirstFocalKeyline().locOffset - (keylineState.getFirstFocalKeyline().maskedItemSize / 2.0f) >= 0.0f && keylineState.getFirstFocalKeyline() == keylineState.getFirstNonAnchorKeyline();
+    }
+
+    private static boolean isLastFocalItemVisibleAtRightOfContainer(Carousel carousel, KeylineState keylineState) {
+        int containerHeight = carousel.getContainerHeight();
+        if (carousel.isHorizontal()) {
+            containerHeight = carousel.getContainerWidth();
+        }
+        return keylineState.getLastFocalKeyline().locOffset + (keylineState.getLastFocalKeyline().maskedItemSize / 2.0f) <= ((float) containerHeight) && keylineState.getLastFocalKeyline() == keylineState.getLastNonAnchorKeyline();
+    }
+
+    private static List<KeylineState> getStateStepsStart(Carousel carousel, KeylineState keylineState) {
+        ArrayList arrayList = new ArrayList();
+        arrayList.add(keylineState);
+        int findFirstNonAnchorKeylineIndex = findFirstNonAnchorKeylineIndex(keylineState);
+        if (!isFirstFocalItemAtLeftOfContainer(keylineState) && findFirstNonAnchorKeylineIndex != -1) {
+            int firstFocalKeylineIndex = keylineState.getFirstFocalKeylineIndex() - findFirstNonAnchorKeylineIndex;
+            float containerWidth = carousel.isHorizontal() ? carousel.getContainerWidth() : carousel.getContainerHeight();
+            float f = keylineState.getFirstKeyline().locOffset - (keylineState.getFirstKeyline().maskedItemSize / 2.0f);
+            float f2 = 0.0f;
+            if (firstFocalKeylineIndex <= 0 && keylineState.getFirstFocalKeyline().cutoff > 0.0f) {
+                arrayList.add(shiftKeylinesAndCreateKeylineState(keylineState, f + keylineState.getFirstFocalKeyline().cutoff, containerWidth));
+                return arrayList;
+            }
+            int i = 0;
+            while (i < firstFocalKeylineIndex) {
+                KeylineState keylineState2 = (KeylineState) arrayList.get(arrayList.size() - 1);
+                int i2 = findFirstNonAnchorKeylineIndex + i;
+                int size = keylineState.getKeylines().size() - 1;
+                float f3 = f2 + keylineState.getKeylines().get(i2).cutoff;
+                arrayList.add(moveKeylineAndCreateKeylineState(keylineState2, findFirstNonAnchorKeylineIndex, i2 - 1 >= 0 ? findFirstIndexAfterLastFocalKeylineWithMask(keylineState2, keylineState.getKeylines().get(r3).mask) - 1 : size, f + f3, (keylineState.getFirstFocalKeylineIndex() - i) - 1, (keylineState.getLastFocalKeylineIndex() - i) - 1, containerWidth));
+                i++;
+                f2 = f3;
+            }
+        }
+        return arrayList;
+    }
+
+    private static List<KeylineState> getStateStepsEnd(Carousel carousel, KeylineState keylineState) {
+        ArrayList arrayList = new ArrayList();
+        arrayList.add(keylineState);
+        int findLastNonAnchorKeylineIndex = findLastNonAnchorKeylineIndex(keylineState);
+        if (!isLastFocalItemVisibleAtRightOfContainer(carousel, keylineState) && findLastNonAnchorKeylineIndex != -1) {
+            int lastFocalKeylineIndex = findLastNonAnchorKeylineIndex - keylineState.getLastFocalKeylineIndex();
+            float containerWidth = carousel.isHorizontal() ? carousel.getContainerWidth() : carousel.getContainerHeight();
+            float f = keylineState.getFirstKeyline().locOffset - (keylineState.getFirstKeyline().maskedItemSize / 2.0f);
+            float f2 = 0.0f;
+            if (lastFocalKeylineIndex <= 0 && keylineState.getLastFocalKeyline().cutoff > 0.0f) {
+                arrayList.add(shiftKeylinesAndCreateKeylineState(keylineState, f - keylineState.getLastFocalKeyline().cutoff, containerWidth));
+                return arrayList;
+            }
+            int i = 0;
+            while (i < lastFocalKeylineIndex) {
+                KeylineState keylineState2 = (KeylineState) arrayList.get(arrayList.size() - 1);
+                int i2 = findLastNonAnchorKeylineIndex - i;
+                float f3 = f2 + keylineState.getKeylines().get(i2).cutoff;
+                int i3 = i2 + 1;
+                arrayList.add(moveKeylineAndCreateKeylineState(keylineState2, findLastNonAnchorKeylineIndex, i3 < keylineState.getKeylines().size() ? findLastIndexBeforeFirstFocalKeylineWithMask(keylineState2, keylineState.getKeylines().get(i3).mask) + 1 : 0, f - f3, keylineState.getFirstFocalKeylineIndex() + i + 1, keylineState.getLastFocalKeylineIndex() + i + 1, containerWidth));
+                i++;
+                f2 = f3;
+            }
+        }
+        return arrayList;
+    }
+
+    private static KeylineState shiftKeylinesAndCreateKeylineState(KeylineState keylineState, float f, float f2) {
+        return moveKeylineAndCreateKeylineState(keylineState, 0, 0, f, keylineState.getFirstFocalKeylineIndex(), keylineState.getLastFocalKeylineIndex(), f2);
+    }
+
+    private static KeylineState moveKeylineAndCreateKeylineState(KeylineState keylineState, int i, int i2, float f, int i3, int i4, float f2) {
+        ArrayList arrayList = new ArrayList(keylineState.getKeylines());
+        arrayList.add(i2, (KeylineState.Keyline) arrayList.remove(i));
+        KeylineState.Builder builder = new KeylineState.Builder(keylineState.getItemSize(), f2);
+        int i5 = 0;
+        while (i5 < arrayList.size()) {
+            KeylineState.Keyline keyline = (KeylineState.Keyline) arrayList.get(i5);
+            builder.addKeyline(f + (keyline.maskedItemSize / 2.0f), keyline.mask, keyline.maskedItemSize, i5 >= i3 && i5 <= i4, keyline.isAnchor, keyline.cutoff);
+            f += keyline.maskedItemSize;
+            i5++;
+        }
+        return builder.build();
+    }
+
+    private static int findFirstIndexAfterLastFocalKeylineWithMask(KeylineState keylineState, float f) {
+        for (int lastFocalKeylineIndex = keylineState.getLastFocalKeylineIndex(); lastFocalKeylineIndex < keylineState.getKeylines().size(); lastFocalKeylineIndex++) {
+            if (f == keylineState.getKeylines().get(lastFocalKeylineIndex).mask) {
+                return lastFocalKeylineIndex;
+            }
+        }
+        return keylineState.getKeylines().size() - 1;
+    }
+
+    private static int findLastIndexBeforeFirstFocalKeylineWithMask(KeylineState keylineState, float f) {
+        for (int firstFocalKeylineIndex = keylineState.getFirstFocalKeylineIndex() - 1; firstFocalKeylineIndex >= 0; firstFocalKeylineIndex--) {
+            if (f == keylineState.getKeylines().get(firstFocalKeylineIndex).mask) {
+                return firstFocalKeylineIndex;
+            }
+        }
+        return 0;
+    }
+
+    private static int findFirstNonAnchorKeylineIndex(KeylineState keylineState) {
+        for (int i = 0; i < keylineState.getKeylines().size(); i++) {
+            if (!keylineState.getKeylines().get(i).isAnchor) {
+                return i;
+            }
+        }
+        return -1;
+    }
+
+    private static int findLastNonAnchorKeylineIndex(KeylineState keylineState) {
+        for (int size = keylineState.getKeylines().size() - 1; size >= 0; size--) {
+            if (!keylineState.getKeylines().get(size).isAnchor) {
+                return size;
+            }
+        }
+        return -1;
+    }
+
+    Map<Integer, KeylineState> getKeylineStateForPositionMap(int i, int i2, int i3, boolean z) {
+        float itemSize = this.defaultState.getItemSize();
+        HashMap hashMap = new HashMap();
+        int i4 = 0;
+        int i5 = 0;
+        while (true) {
+            if (i4 >= i) {
+                break;
+            }
+            int i6 = z ? (i - i4) - 1 : i4;
+            if (i6 * itemSize * (z ? -1 : 1) > i3 - this.endShiftRange || i4 >= i - this.endStateSteps.size()) {
+                Integer valueOf = Integer.valueOf(i6);
+                List<KeylineState> list = this.endStateSteps;
+                hashMap.put(valueOf, list.get(MathUtils.clamp(i5, 0, list.size() - 1)));
+                i5++;
+            }
+            i4++;
+        }
+        int i7 = 0;
+        for (int i8 = i - 1; i8 >= 0; i8--) {
+            int i9 = z ? (i - i8) - 1 : i8;
+            if (i9 * itemSize * (z ? -1 : 1) < i2 + this.startShiftRange || i8 < this.startStateSteps.size()) {
+                Integer valueOf2 = Integer.valueOf(i9);
+                List<KeylineState> list2 = this.startStateSteps;
+                hashMap.put(valueOf2, list2.get(MathUtils.clamp(i7, 0, list2.size() - 1)));
+                i7++;
+            }
+        }
+        return hashMap;
+    }
+}

02-Easy5/E5/sources/com/google/android/material/carousel/Maskable.java

@@ -0,0 +1,18 @@
+package com.google.android.material.carousel;
+
+import android.graphics.RectF;
+
+/* loaded from: classes.dex */
+interface Maskable {
+    RectF getMaskRectF();
+
+    @Deprecated
+    float getMaskXPercentage();
+
+    void setMaskRectF(RectF rectF);
+
+    @Deprecated
+    void setMaskXPercentage(float f);
+
+    void setOnMaskChangedListener(OnMaskChangedListener onMaskChangedListener);
+}

02-Easy5/E5/sources/com/google/android/material/carousel/MaskableFrameLayout.java

@@ -0,0 +1,172 @@
+package com.google.android.material.carousel;
+
+import android.content.Context;
+import android.graphics.Canvas;
+import android.graphics.Rect;
+import android.graphics.RectF;
+import android.util.AttributeSet;
+import android.view.MotionEvent;
+import android.widget.FrameLayout;
+import androidx.core.math.MathUtils;
+import com.google.android.material.animation.AnimationUtils;
+import com.google.android.material.canvas.CanvasCompat;
+import com.google.android.material.shape.AbsoluteCornerSize;
+import com.google.android.material.shape.ClampedCornerSize;
+import com.google.android.material.shape.CornerSize;
+import com.google.android.material.shape.ShapeAppearanceModel;
+import com.google.android.material.shape.Shapeable;
+import com.google.android.material.shape.ShapeableDelegate;
+
+/* loaded from: classes.dex */
+public class MaskableFrameLayout extends FrameLayout implements Maskable, Shapeable {
+    private static final int NOT_SET = -1;
+    private final RectF maskRect;
+    private float maskXPercentage;
+    private OnMaskChangedListener onMaskChangedListener;
+    private Boolean savedForceCompatClippingEnabled;
+    private ShapeAppearanceModel shapeAppearanceModel;
+    private final ShapeableDelegate shapeableDelegate;
+
+    @Override // com.google.android.material.carousel.Maskable
+    public RectF getMaskRectF() {
+        return this.maskRect;
+    }
+
+    @Override // com.google.android.material.carousel.Maskable
+    @Deprecated
+    public float getMaskXPercentage() {
+        return this.maskXPercentage;
+    }
+
+    @Override // com.google.android.material.shape.Shapeable
+    public ShapeAppearanceModel getShapeAppearanceModel() {
+        return this.shapeAppearanceModel;
+    }
+
+    @Override // com.google.android.material.carousel.Maskable
+    public void setOnMaskChangedListener(OnMaskChangedListener onMaskChangedListener) {
+        this.onMaskChangedListener = onMaskChangedListener;
+    }
+
+    public MaskableFrameLayout(Context context) {
+        this(context, null);
+    }
+
+    public MaskableFrameLayout(Context context, AttributeSet attributeSet) {
+        this(context, attributeSet, 0);
+    }
+
+    public MaskableFrameLayout(Context context, AttributeSet attributeSet, int i) {
+        super(context, attributeSet, i);
+        this.maskXPercentage = -1.0f;
+        this.maskRect = new RectF();
+        this.shapeableDelegate = ShapeableDelegate.create(this);
+        this.savedForceCompatClippingEnabled = null;
+        setShapeAppearanceModel(ShapeAppearanceModel.builder(context, attributeSet, i, 0, 0).build());
+    }
+
+    @Override // android.view.View
+    protected void onSizeChanged(int i, int i2, int i3, int i4) {
+        super.onSizeChanged(i, i2, i3, i4);
+        if (this.maskXPercentage != -1.0f) {
+            updateMaskRectForMaskXPercentage();
+        }
+    }
+
+    @Override // android.view.View
+    public void getFocusedRect(Rect rect) {
+        rect.set((int) this.maskRect.left, (int) this.maskRect.top, (int) this.maskRect.right, (int) this.maskRect.bottom);
+    }
+
+    @Override // android.view.ViewGroup, android.view.View
+    protected void onAttachedToWindow() {
+        super.onAttachedToWindow();
+        Boolean bool = this.savedForceCompatClippingEnabled;
+        if (bool != null) {
+            this.shapeableDelegate.setForceCompatClippingEnabled(this, bool.booleanValue());
+        }
+    }
+
+    @Override // android.view.ViewGroup, android.view.View
+    protected void onDetachedFromWindow() {
+        this.savedForceCompatClippingEnabled = Boolean.valueOf(this.shapeableDelegate.isForceCompatClippingEnabled());
+        this.shapeableDelegate.setForceCompatClippingEnabled(this, true);
+        super.onDetachedFromWindow();
+    }
+
+    @Override // com.google.android.material.shape.Shapeable
+    public void setShapeAppearanceModel(ShapeAppearanceModel shapeAppearanceModel) {
+        ShapeAppearanceModel withTransformedCornerSizes = shapeAppearanceModel.withTransformedCornerSizes(new ShapeAppearanceModel.CornerSizeUnaryOperator() { // from class: com.google.android.material.carousel.MaskableFrameLayout$$ExternalSyntheticLambda1
+            @Override // com.google.android.material.shape.ShapeAppearanceModel.CornerSizeUnaryOperator
+            public final CornerSize apply(CornerSize cornerSize) {
+                return MaskableFrameLayout.lambda$setShapeAppearanceModel$0(cornerSize);
+            }
+        });
+        this.shapeAppearanceModel = withTransformedCornerSizes;
+        this.shapeableDelegate.onShapeAppearanceChanged(this, withTransformedCornerSizes);
+    }
+
+    static /* synthetic */ CornerSize lambda$setShapeAppearanceModel$0(CornerSize cornerSize) {
+        return cornerSize instanceof AbsoluteCornerSize ? ClampedCornerSize.createFromCornerSize((AbsoluteCornerSize) cornerSize) : cornerSize;
+    }
+
+    @Override // com.google.android.material.carousel.Maskable
+    @Deprecated
+    public void setMaskXPercentage(float f) {
+        float clamp = MathUtils.clamp(f, 0.0f, 1.0f);
+        if (this.maskXPercentage != clamp) {
+            this.maskXPercentage = clamp;
+            updateMaskRectForMaskXPercentage();
+        }
+    }
+
+    private void updateMaskRectForMaskXPercentage() {
+        if (this.maskXPercentage != -1.0f) {
+            float lerp = AnimationUtils.lerp(0.0f, getWidth() / 2.0f, 0.0f, 1.0f, this.maskXPercentage);
+            setMaskRectF(new RectF(lerp, 0.0f, getWidth() - lerp, getHeight()));
+        }
+    }
+
+    @Override // com.google.android.material.carousel.Maskable
+    public void setMaskRectF(RectF rectF) {
+        this.maskRect.set(rectF);
+        onMaskChanged();
+    }
+
+    private void onMaskChanged() {
+        this.shapeableDelegate.onMaskChanged(this, this.maskRect);
+        OnMaskChangedListener onMaskChangedListener = this.onMaskChangedListener;
+        if (onMaskChangedListener != null) {
+            onMaskChangedListener.onMaskChanged(this.maskRect);
+        }
+    }
+
+    public void setForceCompatClipping(boolean z) {
+        this.shapeableDelegate.setForceCompatClippingEnabled(this, z);
+    }
+
+    @Override // android.view.View
+    public boolean onTouchEvent(MotionEvent motionEvent) {
+        if (!this.maskRect.isEmpty() && motionEvent.getAction() == 0) {
+            if (!this.maskRect.contains(motionEvent.getX(), motionEvent.getY())) {
+                return false;
+            }
+        }
+        return super.onTouchEvent(motionEvent);
+    }
+
+    @Override // android.view.ViewGroup, android.view.View
+    protected void dispatchDraw(Canvas canvas) {
+        this.shapeableDelegate.maybeClip(canvas, new CanvasCompat.CanvasOperation() { // from class: com.google.android.material.carousel.MaskableFrameLayout$$ExternalSyntheticLambda0
+            @Override // com.google.android.material.canvas.CanvasCompat.CanvasOperation
+            public final void run(Canvas canvas2) {
+                MaskableFrameLayout.this.m196x418c47c0(canvas2);
+            }
+        });
+    }
+
+    /* renamed from: lambda$dispatchDraw$1$com-google-android-material-carousel-MaskableFrameLayout, reason: not valid java name */
+    /* synthetic */ void m196x418c47c0(Canvas canvas) {
+        super.dispatchDraw(canvas);
+    }
+}

02-Easy5/E5/sources/com/google/android/material/carousel/MultiBrowseCarouselStrategy.java

@@ -0,0 +1,76 @@
+package com.google.android.material.carousel;
+
+import android.view.View;
+import androidx.core.math.MathUtils;
+import androidx.recyclerview.widget.RecyclerView;
+
+/* loaded from: classes.dex */
+public final class MultiBrowseCarouselStrategy extends CarouselStrategy {
+    private int keylineCount = 0;
+    private static final int[] SMALL_COUNTS = {1};
+    private static final int[] MEDIUM_COUNTS = {1, 0};
+
+    @Override // com.google.android.material.carousel.CarouselStrategy
+    KeylineState onFirstChildMeasuredWithMargins(Carousel carousel, View view) {
+        float containerHeight = carousel.getContainerHeight();
+        if (carousel.isHorizontal()) {
+            containerHeight = carousel.getContainerWidth();
+        }
+        RecyclerView.LayoutParams layoutParams = (RecyclerView.LayoutParams) view.getLayoutParams();
+        float f = layoutParams.topMargin + layoutParams.bottomMargin;
+        float measuredHeight = view.getMeasuredHeight();
+        if (carousel.isHorizontal()) {
+            f = layoutParams.leftMargin + layoutParams.rightMargin;
+            measuredHeight = view.getMeasuredWidth();
+        }
+        float f2 = f;
+        float smallSizeMin = CarouselStrategyHelper.getSmallSizeMin(view.getContext()) + f2;
+        float smallSizeMax = CarouselStrategyHelper.getSmallSizeMax(view.getContext()) + f2;
+        float min = Math.min(measuredHeight + f2, containerHeight);
+        float clamp = MathUtils.clamp((measuredHeight / 3.0f) + f2, CarouselStrategyHelper.getSmallSizeMin(view.getContext()) + f2, CarouselStrategyHelper.getSmallSizeMax(view.getContext()) + f2);
+        float f3 = (min + clamp) / 2.0f;
+        int[] iArr = SMALL_COUNTS;
+        if (containerHeight < 2.0f * smallSizeMin) {
+            iArr = new int[]{0};
+        }
+        int[] iArr2 = MEDIUM_COUNTS;
+        if (carousel.getCarouselAlignment() == 1) {
+            iArr = doubleCounts(iArr);
+            iArr2 = doubleCounts(iArr2);
+        }
+        int[] iArr3 = iArr;
+        int[] iArr4 = iArr2;
+        int max = (int) Math.max(1.0d, Math.floor(((containerHeight - (CarouselStrategyHelper.maxValue(iArr4) * f3)) - (CarouselStrategyHelper.maxValue(iArr3) * smallSizeMax)) / min));
+        int ceil = (int) Math.ceil(containerHeight / min);
+        int i = (ceil - max) + 1;
+        int[] iArr5 = new int[i];
+        for (int i2 = 0; i2 < i; i2++) {
+            iArr5[i2] = ceil - i2;
+        }
+        Arrangement findLowestCostArrangement = Arrangement.findLowestCostArrangement(containerHeight, clamp, smallSizeMin, smallSizeMax, iArr3, f3, iArr4, min, iArr5);
+        this.keylineCount = findLowestCostArrangement.getItemCount();
+        if (ensureArrangementFitsItemCount(findLowestCostArrangement, carousel.getItemCount())) {
+            findLowestCostArrangement = Arrangement.findLowestCostArrangement(containerHeight, clamp, smallSizeMin, smallSizeMax, new int[]{findLowestCostArrangement.smallCount}, f3, new int[]{findLowestCostArrangement.mediumCount}, min, new int[]{findLowestCostArrangement.largeCount});
+        }
+        return CarouselStrategyHelper.createKeylineState(view.getContext(), f2, containerHeight, findLowestCostArrangement, carousel.getCarouselAlignment());
+    }
+
+    boolean ensureArrangementFitsItemCount(Arrangement arrangement, int i) {
+        int itemCount = arrangement.getItemCount() - i;
+        boolean z = itemCount > 0 && (arrangement.smallCount > 0 || arrangement.mediumCount > 1);
+        while (itemCount > 0) {
+            if (arrangement.smallCount > 0) {
+                arrangement.smallCount--;
+            } else if (arrangement.mediumCount > 1) {
+                arrangement.mediumCount--;
+            }
+            itemCount--;
+        }
+        return z;
+    }
+
+    @Override // com.google.android.material.carousel.CarouselStrategy
+    boolean shouldRefreshKeylineState(Carousel carousel, int i) {
+        return (i < this.keylineCount && carousel.getItemCount() >= this.keylineCount) || (i >= this.keylineCount && carousel.getItemCount() < this.keylineCount);
+    }
+}

02-Easy5/E5/sources/com/google/android/material/carousel/OnMaskChangedListener.java

@@ -0,0 +1,8 @@
+package com.google.android.material.carousel;
+
+import android.graphics.RectF;
+
+/* loaded from: classes.dex */
+public interface OnMaskChangedListener {
+    void onMaskChanged(RectF rectF);
+}

02-Easy5/E5/sources/com/google/android/material/carousel/UncontainedCarouselStrategy.java

@@ -0,0 +1,83 @@
+package com.google.android.material.carousel;
+
+import android.content.Context;
+import android.view.View;
+import androidx.recyclerview.widget.RecyclerView;
+import com.google.android.material.carousel.KeylineState;
+
+/* loaded from: classes.dex */
+public final class UncontainedCarouselStrategy extends CarouselStrategy {
+    private static final float MEDIUM_LARGE_ITEM_PERCENTAGE_THRESHOLD = 0.85f;
+
+    @Override // com.google.android.material.carousel.CarouselStrategy
+    boolean isContained() {
+        return false;
+    }
+
+    @Override // com.google.android.material.carousel.CarouselStrategy
+    KeylineState onFirstChildMeasuredWithMargins(Carousel carousel, View view) {
+        float f;
+        float containerWidth = carousel.isHorizontal() ? carousel.getContainerWidth() : carousel.getContainerHeight();
+        RecyclerView.LayoutParams layoutParams = (RecyclerView.LayoutParams) view.getLayoutParams();
+        float f2 = layoutParams.topMargin + layoutParams.bottomMargin;
+        float measuredHeight = view.getMeasuredHeight();
+        if (carousel.isHorizontal()) {
+            float f3 = layoutParams.leftMargin + layoutParams.rightMargin;
+            measuredHeight = view.getMeasuredWidth();
+            f = f3;
+        } else {
+            f = f2;
+        }
+        float f4 = measuredHeight + f;
+        float extraSmallSize = CarouselStrategyHelper.getExtraSmallSize(view.getContext()) + f;
+        float extraSmallSize2 = CarouselStrategyHelper.getExtraSmallSize(view.getContext()) + f;
+        int max = Math.max(1, (int) Math.floor(containerWidth / f4));
+        float f5 = containerWidth - (max * f4);
+        if (carousel.getCarouselAlignment() == 1) {
+            float f6 = f5 / 2.0f;
+            return createCenterAlignedKeylineState(containerWidth, f, f4, max, Math.max(Math.min(3.0f * f6, f4), CarouselStrategyHelper.getSmallSizeMin(view.getContext()) + f), extraSmallSize2, f6);
+        }
+        return createLeftAlignedKeylineState(view.getContext(), f, containerWidth, f4, max, calculateMediumChildSize(extraSmallSize, f4, f5), f5 > 0.0f ? 1 : 0, extraSmallSize2);
+    }
+
+    private float calculateMediumChildSize(float f, float f2, float f3) {
+        float max = Math.max(1.5f * f3, f);
+        float f4 = MEDIUM_LARGE_ITEM_PERCENTAGE_THRESHOLD * f2;
+        if (max > f4) {
+            max = Math.max(f4, f3 * 1.2f);
+        }
+        return Math.min(f2, max);
+    }
+
+    private KeylineState createCenterAlignedKeylineState(float f, float f2, float f3, int i, float f4, float f5, float f6) {
+        float min = Math.min(f5, f3);
+        float childMaskPercentage = getChildMaskPercentage(min, f3, f2);
+        float childMaskPercentage2 = getChildMaskPercentage(f4, f3, f2);
+        float f7 = f4 / 2.0f;
+        float f8 = (f6 + 0.0f) - f7;
+        float f9 = f8 + f7;
+        float f10 = min / 2.0f;
+        float f11 = (i * f3) + f9;
+        KeylineState.Builder addKeylineRange = new KeylineState.Builder(f3, f).addAnchorKeyline((f8 - f7) - f10, childMaskPercentage, min).addKeyline(f8, childMaskPercentage2, f4, false).addKeylineRange((f3 / 2.0f) + f9, 0.0f, f3, i, true);
+        addKeylineRange.addKeyline(f7 + f11, childMaskPercentage2, f4, false);
+        addKeylineRange.addAnchorKeyline(f11 + f4 + f10, childMaskPercentage, min);
+        return addKeylineRange.build();
+    }
+
+    private KeylineState createLeftAlignedKeylineState(Context context, float f, float f2, float f3, int i, float f4, int i2, float f5) {
+        float min = Math.min(f5, f3);
+        float max = Math.max(min, 0.5f * f4);
+        float childMaskPercentage = getChildMaskPercentage(max, f3, f);
+        float childMaskPercentage2 = getChildMaskPercentage(min, f3, f);
+        float childMaskPercentage3 = getChildMaskPercentage(f4, f3, f);
+        float f6 = (i * f3) + 0.0f;
+        KeylineState.Builder addKeylineRange = new KeylineState.Builder(f3, f2).addAnchorKeyline(0.0f - (max / 2.0f), childMaskPercentage, max).addKeylineRange(f3 / 2.0f, 0.0f, f3, i, true);
+        if (i2 > 0) {
+            float f7 = (f4 / 2.0f) + f6;
+            f6 += f4;
+            addKeylineRange.addKeyline(f7, childMaskPercentage3, f4, false);
+        }
+        addKeylineRange.addAnchorKeyline(f6 + (CarouselStrategyHelper.getExtraSmallSize(context) / 2.0f), childMaskPercentage2, min);
+        return addKeylineRange.build();
+    }
+}