package defpackage;

import j$.util.Map;
import java.io.Serializable;
import java.util.Map;
import java.util.Set;
import java.util.SortedMap;
import java.util.function.BiConsumer;
import java.util.function.BiFunction;
import java.util.function.Function;

/* JADX INFO: renamed from: ᵤˇˋᵙ, reason: contains not printable characters */
/* JADX INFO: loaded from: classes.dex */
public abstract class AbstractC3409 implements Map, Serializable, j$.util.Map {

    /* JADX INFO: renamed from: ˌᴵ, reason: contains not printable characters */
    public transient C1172 f13130;

    /* JADX INFO: renamed from: ᵔᵖᵹᵫ, reason: contains not printable characters */
    public transient C3027 f13131;

    /* JADX INFO: renamed from: ᵜᵪʾ, reason: contains not printable characters */
    public transient C0224 f13132;

    /* JADX INFO: renamed from: ʽˈˋ, reason: contains not printable characters */
    public static AbstractC3409 m7804(Map map) {
        if ((map instanceof AbstractC3409) && !(map instanceof SortedMap)) {
            return (AbstractC3409) map;
        }
        Set setEntrySet = map.entrySet();
        C1404 c1404 = new C1404(setEntrySet != null ? setEntrySet.size() : 4);
        c1404.m4041(setEntrySet);
        return c1404.m4052(true);
    }

    /* JADX INFO: renamed from: ᵲᵶᵳˈ, reason: contains not printable characters */
    public static C1404 m7805() {
        return new C1404(4);
    }

    @Override // java.util.Map
    public final void clear() {
        throw new UnsupportedOperationException();
    }

    @Override // java.util.Map, j$.util.Map, java.util.concurrent.ConcurrentMap
    public /* synthetic */ Object compute(Object obj, BiFunction biFunction) {
        return Map.CC.$default$compute(this, obj, biFunction);
    }

    @Override // java.util.Map, j$.util.Map, java.util.concurrent.ConcurrentMap
    public /* synthetic */ Object computeIfAbsent(Object obj, Function function) {
        return Map.CC.$default$computeIfAbsent(this, obj, function);
    }

    @Override // java.util.Map, j$.util.Map, java.util.concurrent.ConcurrentMap
    public /* synthetic */ Object computeIfPresent(Object obj, BiFunction biFunction) {
        return Map.CC.$default$computeIfPresent(this, obj, biFunction);
    }

    @Override // java.util.Map
    public final boolean containsKey(Object obj) {
        return get(obj) != null;
    }

    @Override // java.util.Map
    public final boolean containsValue(Object obj) {
        return values().contains(obj);
    }

    @Override // java.util.Map
    public final boolean equals(Object obj) {
        return AbstractC3481.m7943(this, obj);
    }

    @Override // java.util.Map, j$.util.Map, java.util.concurrent.ConcurrentMap
    public /* synthetic */ void forEach(BiConsumer biConsumer) {
        Map.CC.$default$forEach(this, biConsumer);
    }

    @Override // java.util.Map
    public abstract Object get(Object obj);

    @Override // java.util.Map, j$.util.Map, java.util.concurrent.ConcurrentMap
    public final Object getOrDefault(Object obj, Object obj2) {
        Object obj3 = get(obj);
        return obj3 != null ? obj3 : obj2;
    }

    @Override // java.util.Map
    public final int hashCode() {
        return ᵥˈᵛ.ˊᵡᵗʨ(entrySet());
    }

    @Override // java.util.Map
    public final boolean isEmpty() {
        return ((C1323) this).size() == 0;
    }

    @Override // java.util.Map, j$.util.Map, java.util.concurrent.ConcurrentMap
    public /* synthetic */ Object merge(Object obj, Object obj2, BiFunction biFunction) {
        return Map.CC.$default$merge(this, obj, obj2, biFunction);
    }

    @Override // java.util.Map
    public final Object put(Object obj, Object obj2) {
        throw new UnsupportedOperationException();
    }

    @Override // java.util.Map
    public final void putAll(java.util.Map map) {
        throw new UnsupportedOperationException();
    }

    @Override // java.util.Map, j$.util.Map, java.util.concurrent.ConcurrentMap
    public /* synthetic */ Object putIfAbsent(Object obj, Object obj2) {
        return Map.CC.$default$putIfAbsent(this, obj, obj2);
    }

    @Override // java.util.Map
    public final Object remove(Object obj) {
        throw new UnsupportedOperationException();
    }

    @Override // java.util.Map, j$.util.Map, java.util.concurrent.ConcurrentMap
    public /* synthetic */ boolean remove(Object obj, Object obj2) {
        return Map.CC.$default$remove(this, obj, obj2);
    }

    @Override // java.util.Map, j$.util.Map, java.util.concurrent.ConcurrentMap
    public /* synthetic */ Object replace(Object obj, Object obj2) {
        return Map.CC.$default$replace(this, obj, obj2);
    }

    @Override // java.util.Map, j$.util.Map, java.util.concurrent.ConcurrentMap
    public /* synthetic */ boolean replace(Object obj, Object obj2, Object obj3) {
        return Map.CC.$default$replace(this, obj, obj2, obj3);
    }

    @Override // java.util.Map, j$.util.Map, java.util.concurrent.ConcurrentMap
    public /* synthetic */ void replaceAll(BiFunction biFunction) {
        Map.CC.$default$replaceAll(this, biFunction);
    }

    public final String toString() {
        int i = ((C1323) this).f5513;
        ˑᵕʾ.ːˏᵟᵯ(i, "size");
        StringBuilder sb = new StringBuilder((int) Math.min(((long) i) * 8, 1073741824L));
        sb.append('{');
        AbstractC0228 it = ((C1172) entrySet()).iterator();
        boolean z = true;
        while (true) {
            AbstractC3171 abstractC3171 = (AbstractC3171) it;
            if (!abstractC3171.hasNext()) {
                sb.append('}');
                return sb.toString();
            }
            Map.Entry entry = (Map.Entry) abstractC3171.next();
            if (!z) {
                sb.append(", ");
            }
            sb.append(entry.getKey());
            sb.append('=');
            sb.append(entry.getValue());
            z = false;
        }
    }

    @Override // java.util.Map
    /* JADX INFO: renamed from: ːˏᵟᵯ, reason: contains not printable characters and merged with bridge method [inline-methods] */
    public final AbstractC5291 entrySet() {
        C1172 c1172 = this.f13130;
        if (c1172 != null) {
            return c1172;
        }
        C1323 c1323 = (C1323) this;
        C1172 c11722 = new C1172(c1323, c1323.f5512, c1323.f5513);
        this.f13130 = c11722;
        return c11722;
    }

    @Override // java.util.Map
    /* JADX INFO: renamed from: ᵨᵣ, reason: contains not printable characters and merged with bridge method [inline-methods] */
    public final AbstractC5055 values() {
        C3027 c3027 = this.f13131;
        if (c3027 != null) {
            return c3027;
        }
        C1323 c1323 = (C1323) this;
        C3027 c30272 = new C3027(c1323.f5512, 1, c1323.f5513);
        this.f13131 = c30272;
        return c30272;
    }

    @Override // java.util.Map
    /* JADX INFO: renamed from: ᵷᵺʾᵖ, reason: contains not printable characters and merged with bridge method [inline-methods] */
    public final AbstractC5291 keySet() {
        C0224 c0224 = this.f13132;
        if (c0224 != null) {
            return c0224;
        }
        C1323 c1323 = (C1323) this;
        C0224 c02242 = new C0224(c1323, new C3027(c1323.f5512, 0, c1323.f5513));
        this.f13132 = c02242;
        return c02242;
    }
}