package androidx.datastore.preferences.protobuf;

import java.util.AbstractMap;
import java.util.AbstractSet;
import java.util.ArrayList;
import java.util.Collections;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
import java.util.Set;
import java.util.SortedMap;
import java.util.TreeMap;

/* JADX INFO: loaded from: classes.dex */
public final class W extends AbstractMap {

    /* JADX INFO: renamed from: v, reason: collision with root package name */
    public static final /* synthetic */ int f8037v = 0;

    /* JADX INFO: renamed from: q, reason: collision with root package name */
    public List f8038q;

    /* JADX INFO: renamed from: r, reason: collision with root package name */
    public Map f8039r;

    /* JADX INFO: renamed from: s, reason: collision with root package name */
    public boolean f8040s;

    /* JADX INFO: renamed from: t, reason: collision with root package name */
    public volatile Z f8041t;

    /* JADX INFO: renamed from: u, reason: collision with root package name */
    public Map f8042u;

    public static W f() {
        W w4 = new W();
        w4.f8038q = Collections.EMPTY_LIST;
        Map map = Collections.EMPTY_MAP;
        w4.f8039r = map;
        w4.f8042u = map;
        return w4;
    }

    /* JADX WARN: Removed duplicated region for block: B:13:0x0024  */
    /*
        Code decompiled incorrectly, please refer to instructions dump.
    */
    public final int a(Comparable comparable) {
        int i;
        int i5;
        int size = this.f8038q.size();
        int i8 = size - 1;
        if (i8 < 0) {
            i = 0;
            while (i <= i8) {
                int i9 = (i + i8) / 2;
                int iCompareTo = comparable.compareTo(((X) this.f8038q.get(i9)).f8043q);
                if (iCompareTo < 0) {
                    i8 = i9 - 1;
                } else {
                    if (iCompareTo <= 0) {
                        return i9;
                    }
                    i = i9 + 1;
                }
            }
            i5 = i + 1;
        } else {
            int iCompareTo2 = comparable.compareTo(((X) this.f8038q.get(i8)).f8043q);
            if (iCompareTo2 > 0) {
                i5 = size + 1;
            } else {
                if (iCompareTo2 == 0) {
                    return i8;
                }
                i = 0;
                while (i <= i8) {
                }
                i5 = i + 1;
            }
        }
        return -i5;
    }

    public final void b() {
        if (this.f8040s) {
            throw new UnsupportedOperationException();
        }
    }

    public final Map.Entry c(int i) {
        return (Map.Entry) this.f8038q.get(i);
    }

    @Override // java.util.AbstractMap, java.util.Map
    public final void clear() {
        b();
        if (!this.f8038q.isEmpty()) {
            this.f8038q.clear();
        }
        if (this.f8039r.isEmpty()) {
            return;
        }
        this.f8039r.clear();
    }

    @Override // java.util.AbstractMap, java.util.Map
    public final boolean containsKey(Object obj) {
        Comparable comparable = (Comparable) obj;
        return a(comparable) >= 0 || this.f8039r.containsKey(comparable);
    }

    public final Set d() {
        return this.f8039r.isEmpty() ? Collections.EMPTY_SET : this.f8039r.entrySet();
    }

    public final SortedMap e() {
        b();
        if (this.f8039r.isEmpty() && !(this.f8039r instanceof TreeMap)) {
            TreeMap treeMap = new TreeMap();
            this.f8039r = treeMap;
            this.f8042u = treeMap.descendingMap();
        }
        return (SortedMap) this.f8039r;
    }

    @Override // java.util.AbstractMap, java.util.Map
    public final Set entrySet() {
        if (this.f8041t == null) {
            this.f8041t = new Z(this, 0);
        }
        return this.f8041t;
    }

    @Override // java.util.AbstractMap, java.util.Map
    public final boolean equals(Object obj) {
        if (this == obj) {
            return true;
        }
        if (!(obj instanceof W)) {
            return super.equals(obj);
        }
        W w4 = (W) obj;
        int size = size();
        if (size == w4.size()) {
            int size2 = this.f8038q.size();
            if (size2 != w4.f8038q.size()) {
                return ((AbstractSet) entrySet()).equals(w4.entrySet());
            }
            for (int i = 0; i < size2; i++) {
                if (c(i).equals(w4.c(i))) {
                }
            }
            if (size2 != size) {
                return this.f8039r.equals(w4.f8039r);
            }
            return true;
        }
        return false;
    }

    @Override // java.util.AbstractMap, java.util.Map
    /* JADX INFO: renamed from: g, reason: merged with bridge method [inline-methods] */
    public final Object put(Comparable comparable, Object obj) {
        b();
        int iA = a(comparable);
        if (iA >= 0) {
            return ((X) this.f8038q.get(iA)).setValue(obj);
        }
        b();
        if (this.f8038q.isEmpty() && !(this.f8038q instanceof ArrayList)) {
            this.f8038q = new ArrayList(16);
        }
        int i = -(iA + 1);
        if (i >= 16) {
            return e().put(comparable, obj);
        }
        if (this.f8038q.size() == 16) {
            X x8 = (X) this.f8038q.remove(15);
            e().put(x8.f8043q, x8.f8044r);
        }
        this.f8038q.add(i, new X(this, comparable, obj));
        return null;
    }

    @Override // java.util.AbstractMap, java.util.Map
    public final Object get(Object obj) {
        Comparable comparable = (Comparable) obj;
        int iA = a(comparable);
        return iA >= 0 ? ((X) this.f8038q.get(iA)).f8044r : this.f8039r.get(comparable);
    }

    public final Object h(int i) {
        b();
        Object obj = ((X) this.f8038q.remove(i)).f8044r;
        if (!this.f8039r.isEmpty()) {
            Iterator it = e().entrySet().iterator();
            List list = this.f8038q;
            Map.Entry entry = (Map.Entry) it.next();
            list.add(new X(this, (Comparable) entry.getKey(), entry.getValue()));
            it.remove();
        }
        return obj;
    }

    @Override // java.util.AbstractMap, java.util.Map
    public final int hashCode() {
        int size = this.f8038q.size();
        int iHashCode = 0;
        for (int i = 0; i < size; i++) {
            iHashCode += ((X) this.f8038q.get(i)).hashCode();
        }
        return this.f8039r.size() > 0 ? this.f8039r.hashCode() + iHashCode : iHashCode;
    }

    @Override // java.util.AbstractMap, java.util.Map
    public final Object remove(Object obj) {
        b();
        Comparable comparable = (Comparable) obj;
        int iA = a(comparable);
        if (iA >= 0) {
            return h(iA);
        }
        if (this.f8039r.isEmpty()) {
            return null;
        }
        return this.f8039r.remove(comparable);
    }

    @Override // java.util.AbstractMap, java.util.Map
    public final int size() {
        return this.f8039r.size() + this.f8038q.size();
    }
}