package androidx.core.util;

import android.util.LruCache;
import kotlin.jvm.internal.l;
import kotlin.jvm.internal.m;
import n1.s;
import y1.p;
import y1.r;

/* JADX INFO: loaded from: classes.dex */
public final class LruCacheKt {

    /* JADX INFO: renamed from: androidx.core.util.LruCacheKt$lruCache$1, reason: invalid class name */
    public static final class AnonymousClass1 extends m implements p {
        public static final AnonymousClass1 INSTANCE = new AnonymousClass1();

        public AnonymousClass1() {
            super(2);
        }

        @Override // y1.p
        public final Integer invoke(Object obj, Object obj2) {
            l.e(obj, "<anonymous parameter 0>");
            l.e(obj2, "<anonymous parameter 1>");
            return 1;
        }
    }

    /* JADX INFO: renamed from: androidx.core.util.LruCacheKt$lruCache$2, reason: invalid class name */
    public static final class AnonymousClass2 extends m implements y1.l {
        public static final AnonymousClass2 INSTANCE = new AnonymousClass2();

        public AnonymousClass2() {
            super(1);
        }

        @Override // y1.l
        public final Object invoke(Object it) {
            l.e(it, "it");
            return null;
        }
    }

    /* JADX INFO: renamed from: androidx.core.util.LruCacheKt$lruCache$3, reason: invalid class name */
    public static final class AnonymousClass3 extends m implements r {
        public static final AnonymousClass3 INSTANCE = new AnonymousClass3();

        public AnonymousClass3() {
            super(4);
        }

        public final void invoke(boolean z2, Object obj, Object obj2, Object obj3) {
            l.e(obj, "<anonymous parameter 1>");
            l.e(obj2, "<anonymous parameter 2>");
        }

        @Override // y1.r
        public /* bridge */ /* synthetic */ Object invoke(Object obj, Object obj2, Object obj3, Object obj4) {
            invoke(((Boolean) obj).booleanValue(), obj2, obj3, obj4);
            return s.f5871a;
        }
    }

    /* JADX INFO: Add missing generic type declarations: [V, K] */
    /* JADX INFO: renamed from: androidx.core.util.LruCacheKt$lruCache$4, reason: invalid class name */
    public static final class AnonymousClass4<K, V> extends LruCache<K, V> {
        final /* synthetic */ y1.l $create;
        final /* synthetic */ r $onEntryRemoved;
        final /* synthetic */ p $sizeOf;

        /* JADX WARN: 'super' call moved to the top of the method (can break code semantics) */
        public AnonymousClass4(int i2, p pVar, y1.l lVar, r rVar) {
            super(i2);
            this.$sizeOf = pVar;
            this.$create = lVar;
            this.$onEntryRemoved = rVar;
        }

        @Override // android.util.LruCache
        protected V create(K key) {
            l.e(key, "key");
            return (V) this.$create.invoke(key);
        }

        @Override // android.util.LruCache
        protected void entryRemoved(boolean z2, K key, V oldValue, V v2) {
            l.e(key, "key");
            l.e(oldValue, "oldValue");
            this.$onEntryRemoved.invoke(Boolean.valueOf(z2), key, oldValue, v2);
        }

        @Override // android.util.LruCache
        protected int sizeOf(K key, V value) {
            l.e(key, "key");
            l.e(value, "value");
            return ((Number) this.$sizeOf.invoke(key, value)).intValue();
        }
    }

    public static final <K, V> LruCache<K, V> lruCache(int i2, p sizeOf, y1.l create, r onEntryRemoved) {
        l.e(sizeOf, "sizeOf");
        l.e(create, "create");
        l.e(onEntryRemoved, "onEntryRemoved");
        return new AnonymousClass4(i2, sizeOf, create, onEntryRemoved);
    }

    public static /* synthetic */ LruCache lruCache$default(int i2, p sizeOf, y1.l create, r onEntryRemoved, int i3, Object obj) {
        if ((i3 & 2) != 0) {
            sizeOf = AnonymousClass1.INSTANCE;
        }
        if ((i3 & 4) != 0) {
            create = AnonymousClass2.INSTANCE;
        }
        if ((i3 & 8) != 0) {
            onEntryRemoved = AnonymousClass3.INSTANCE;
        }
        l.e(sizeOf, "sizeOf");
        l.e(create, "create");
        l.e(onEntryRemoved, "onEntryRemoved");
        return new AnonymousClass4(i2, sizeOf, create, onEntryRemoved);
    }
}