package defpackage;

import java.io.Serializable;
import java.util.AbstractCollection;
import java.util.AbstractMap;
import java.util.AbstractSet;
import java.util.Arrays;
import java.util.Collection;
import java.util.ConcurrentModificationException;
import java.util.Iterator;
import java.util.LinkedHashMap;
import java.util.Map;
import java.util.NoSuchElementException;
import java.util.Objects;
import java.util.Set;

/* JADX INFO: loaded from: classes2.dex */
@dz3
@li2
class h71<K, V> extends AbstractMap<K, V> implements Serializable {
    public static final Object l = new Object();
    public transient Object a;
    public transient int[] b;
    public transient Object[] c;
    public transient Object[] d;
    public transient int e;
    public transient int f;
    public transient Set i;
    public transient Set j;
    public transient Collection k;

    public class a extends AbstractSet<Map.Entry<K, V>> {
        public a() {
        }

        @Override // java.util.AbstractCollection, java.util.Collection, java.util.Set
        public final void clear() {
            h71.this.clear();
        }

        @Override // java.util.AbstractCollection, java.util.Collection, java.util.Set
        public final boolean contains(Object obj) {
            h71 h71Var = h71.this;
            Map mapG = h71Var.g();
            if (mapG != null) {
                return mapG.entrySet().contains(obj);
            }
            if (obj instanceof Map.Entry) {
                Map.Entry entry = (Map.Entry) obj;
                int iL = h71Var.l(entry.getKey());
                if (iL != -1 && ts6.a(h71Var.t()[iL], entry.getValue())) {
                    return true;
                }
            }
            return false;
        }

        @Override // java.util.AbstractCollection, java.util.Collection, java.lang.Iterable, java.util.Set
        public final Iterator iterator() {
            h71 h71Var = h71.this;
            Map mapG = h71Var.g();
            return mapG != null ? mapG.entrySet().iterator() : new f71(h71Var);
        }

        @Override // java.util.AbstractCollection, java.util.Collection, java.util.Set
        public final boolean remove(Object obj) {
            h71 h71Var = h71.this;
            Map mapG = h71Var.g();
            if (mapG != null) {
                return mapG.entrySet().remove(obj);
            }
            if (!(obj instanceof Map.Entry)) {
                return false;
            }
            Map.Entry entry = (Map.Entry) obj;
            if (h71Var.p()) {
                return false;
            }
            int iJ = h71Var.j();
            Object key = entry.getKey();
            Object value = entry.getValue();
            Object obj2 = h71Var.a;
            Objects.requireNonNull(obj2);
            int iD = k71.d(key, value, iJ, obj2, h71Var.r(), h71Var.s(), h71Var.t());
            if (iD == -1) {
                return false;
            }
            h71Var.o(iD, iJ);
            h71Var.f--;
            h71Var.k();
            return true;
        }

        @Override // java.util.AbstractCollection, java.util.Collection, java.util.Set
        public final int size() {
            return h71.this.size();
        }
    }

    public abstract class b<T> implements Iterator<T> {
        public int a;
        public int b;
        public int c = -1;

        public b() {
            this.a = h71.this.e;
            this.b = h71.this.h();
        }

        public abstract Object a(int i);

        @Override // java.util.Iterator
        public final boolean hasNext() {
            return this.b >= 0;
        }

        @Override // java.util.Iterator
        public final Object next() {
            h71 h71Var = h71.this;
            if (h71Var.e != this.a) {
                throw new ConcurrentModificationException();
            }
            if (!hasNext()) {
                throw new NoSuchElementException();
            }
            int i = this.b;
            this.c = i;
            Object objA = a(i);
            this.b = h71Var.i(this.b);
            return objA;
        }

        @Override // java.util.Iterator
        public final void remove() {
            h71 h71Var = h71.this;
            if (h71Var.e != this.a) {
                throw new ConcurrentModificationException();
            }
            k41.d(this.c >= 0);
            this.a += 32;
            h71Var.remove(h71Var.s()[this.c]);
            this.b = h71Var.b(this.b, this.c);
            this.c = -1;
        }
    }

    public class c extends AbstractSet<K> {
        public c() {
        }

        @Override // java.util.AbstractCollection, java.util.Collection, java.util.Set
        public final void clear() {
            h71.this.clear();
        }

        @Override // java.util.AbstractCollection, java.util.Collection, java.util.Set
        public final boolean contains(Object obj) {
            return h71.this.containsKey(obj);
        }

        @Override // java.util.AbstractCollection, java.util.Collection, java.lang.Iterable, java.util.Set
        public final Iterator iterator() {
            h71 h71Var = h71.this;
            Map mapG = h71Var.g();
            return mapG != null ? mapG.keySet().iterator() : new e71(h71Var);
        }

        @Override // java.util.AbstractCollection, java.util.Collection, java.util.Set
        public final boolean remove(Object obj) {
            h71 h71Var = h71.this;
            Map mapG = h71Var.g();
            return mapG != null ? mapG.keySet().remove(obj) : h71Var.q(obj) != h71.l;
        }

        @Override // java.util.AbstractCollection, java.util.Collection, java.util.Set
        public final int size() {
            return h71.this.size();
        }
    }

    public final class d extends m0<K, V> {
        public final Object a;
        public int b;

        public d(int i) {
            Object obj = h71.l;
            this.a = h71.this.s()[i];
            this.b = i;
        }

        public final void d() {
            int i = this.b;
            Object obj = this.a;
            h71 h71Var = h71.this;
            if (i != -1 && i < h71Var.size()) {
                if (ts6.a(obj, h71Var.s()[this.b])) {
                    return;
                }
            }
            Object obj2 = h71.l;
            this.b = h71Var.l(obj);
        }

        @Override // java.util.Map.Entry
        public final Object getKey() {
            return this.a;
        }

        @Override // java.util.Map.Entry
        public final Object getValue() {
            h71 h71Var = h71.this;
            Map mapG = h71Var.g();
            if (mapG != null) {
                return mapG.get(this.a);
            }
            d();
            int i = this.b;
            if (i == -1) {
                return null;
            }
            return h71Var.t()[i];
        }

        /* JADX WARN: Multi-variable type inference failed */
        @Override // defpackage.m0, java.util.Map.Entry
        public final Object setValue(Object obj) {
            h71 h71Var = h71.this;
            Map mapG = h71Var.g();
            Object obj2 = this.a;
            if (mapG != 0) {
                return mapG.put(obj2, obj);
            }
            d();
            int i = this.b;
            if (i == -1) {
                h71Var.put(obj2, obj);
                return null;
            }
            Object obj3 = h71Var.t()[i];
            h71Var.t()[this.b] = obj;
            return obj3;
        }
    }

    public class e extends AbstractCollection<V> {
        public e() {
        }

        @Override // java.util.AbstractCollection, java.util.Collection
        public final void clear() {
            h71.this.clear();
        }

        @Override // java.util.AbstractCollection, java.util.Collection, java.lang.Iterable
        public final Iterator iterator() {
            h71 h71Var = h71.this;
            Map mapG = h71Var.g();
            return mapG != null ? mapG.values().iterator() : new g71(h71Var);
        }

        @Override // java.util.AbstractCollection, java.util.Collection
        public final int size() {
            return h71.this.size();
        }
    }

    public h71(int i) {
        m(i);
    }

    public static h71 e() {
        h71 h71Var = new h71();
        h71Var.m(3);
        return h71Var;
    }

    public void a(int i) {
    }

    public int b(int i, int i2) {
        return i - 1;
    }

    public int c() {
        if7.p(p(), "Arrays already allocated");
        int i = this.e;
        int iMax = Math.max(4, v04.a(i + 1, 1.0d));
        this.a = k71.a(iMax);
        this.e = k71.b(this.e, 32 - Integer.numberOfLeadingZeros(iMax - 1), 31);
        this.b = new int[i];
        this.c = new Object[i];
        this.d = new Object[i];
        return i;
    }

    @Override // java.util.AbstractMap, java.util.Map
    public void clear() {
        if (p()) {
            return;
        }
        k();
        Map mapG = g();
        if (mapG != null) {
            this.e = pr4.c(size(), 3);
            mapG.clear();
            this.a = null;
            this.f = 0;
            return;
        }
        Arrays.fill(s(), 0, this.f, (Object) null);
        Arrays.fill(t(), 0, this.f, (Object) null);
        Object obj = this.a;
        Objects.requireNonNull(obj);
        if (obj instanceof byte[]) {
            Arrays.fill((byte[]) obj, (byte) 0);
        } else if (obj instanceof short[]) {
            Arrays.fill((short[]) obj, (short) 0);
        } else {
            Arrays.fill((int[]) obj, 0);
        }
        Arrays.fill(r(), 0, this.f, 0);
        this.f = 0;
    }

    @Override // java.util.AbstractMap, java.util.Map
    public final boolean containsKey(Object obj) {
        Map mapG = g();
        return mapG != null ? mapG.containsKey(obj) : l(obj) != -1;
    }

    @Override // java.util.AbstractMap, java.util.Map
    public final boolean containsValue(Object obj) {
        Map mapG = g();
        if (mapG != null) {
            return mapG.containsValue(obj);
        }
        for (int i = 0; i < this.f; i++) {
            if (ts6.a(obj, t()[i])) {
                return true;
            }
        }
        return false;
    }

    /* JADX WARN: Multi-variable type inference failed */
    public Map d() {
        LinkedHashMap linkedHashMapF = f(j() + 1);
        int iH = h();
        while (iH >= 0) {
            linkedHashMapF.put(s()[iH], t()[iH]);
            iH = i(iH);
        }
        this.a = linkedHashMapF;
        this.b = null;
        this.c = null;
        this.d = null;
        k();
        return linkedHashMapF;
    }

    @Override // java.util.AbstractMap, java.util.Map
    public final Set entrySet() {
        Set set = this.j;
        if (set != null) {
            return set;
        }
        a aVar = new a();
        this.j = aVar;
        return aVar;
    }

    public LinkedHashMap f(int i) {
        return new LinkedHashMap(i, 1.0f);
    }

    public final Map g() {
        Object obj = this.a;
        if (obj instanceof Map) {
            return (Map) obj;
        }
        return null;
    }

    @Override // java.util.AbstractMap, java.util.Map
    public final Object get(Object obj) {
        Map mapG = g();
        if (mapG != null) {
            return mapG.get(obj);
        }
        int iL = l(obj);
        if (iL == -1) {
            return null;
        }
        a(iL);
        return t()[iL];
    }

    public int h() {
        return isEmpty() ? -1 : 0;
    }

    public int i(int i) {
        int i2 = i + 1;
        if (i2 < this.f) {
            return i2;
        }
        return -1;
    }

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

    public final int j() {
        return (1 << (this.e & 31)) - 1;
    }

    public final void k() {
        this.e += 32;
    }

    @Override // java.util.AbstractMap, java.util.Map
    public final Set keySet() {
        Set set = this.i;
        if (set != null) {
            return set;
        }
        c cVar = new c();
        this.i = cVar;
        return cVar;
    }

    public final int l(Object obj) {
        if (p()) {
            return -1;
        }
        int iC = v04.c(obj);
        int iJ = j();
        Object obj2 = this.a;
        Objects.requireNonNull(obj2);
        int iE = k71.e(iC & iJ, obj2);
        if (iE == 0) {
            return -1;
        }
        int i = ~iJ;
        int i2 = iC & i;
        do {
            int i3 = iE - 1;
            int i4 = r()[i3];
            if ((i4 & i) == i2 && ts6.a(obj, s()[i3])) {
                return i3;
            }
            iE = i4 & iJ;
        } while (iE != 0);
        return -1;
    }

    public void m(int i) {
        if7.f(i >= 0, "Expected size must be >= 0");
        this.e = pr4.c(i, 1);
    }

    public void n(int i, int i2, int i3, Object obj, Object obj2) {
        r()[i] = k71.b(i2, 0, i3);
        s()[i] = obj;
        t()[i] = obj2;
    }

    public void o(int i, int i2) {
        Object obj = this.a;
        Objects.requireNonNull(obj);
        int[] iArrR = r();
        Object[] objArrS = s();
        Object[] objArrT = t();
        int size = size();
        int i3 = size - 1;
        if (i >= i3) {
            objArrS[i] = null;
            objArrT[i] = null;
            iArrR[i] = 0;
            return;
        }
        Object obj2 = objArrS[i3];
        objArrS[i] = obj2;
        objArrT[i] = objArrT[i3];
        objArrS[i3] = null;
        objArrT[i3] = null;
        iArrR[i] = iArrR[i3];
        iArrR[i3] = 0;
        int iC = v04.c(obj2) & i2;
        int iE = k71.e(iC, obj);
        if (iE == size) {
            k71.f(iC, i + 1, obj);
            return;
        }
        while (true) {
            int i4 = iE - 1;
            int i5 = iArrR[i4];
            int i6 = i5 & i2;
            if (i6 == size) {
                iArrR[i4] = k71.b(i5, i + 1, i2);
                return;
            }
            iE = i6;
        }
    }

    public final boolean p() {
        return this.a == null;
    }

    /* JADX WARN: Multi-variable type inference failed */
    /* JADX WARN: Removed duplicated region for block: B:33:0x00a5  */
    @Override // java.util.AbstractMap, java.util.Map
    /*
        Code decompiled incorrectly, please refer to instructions dump.
    */
    public final Object put(Object obj, Object obj2) {
        int i;
        int iV;
        int length;
        Object obj3 = obj;
        Object obj4 = obj2;
        if (p()) {
            c();
        }
        Map mapG = g();
        if (mapG != 0) {
            return mapG.put(obj3, obj4);
        }
        int[] iArrR = r();
        Object[] objArrS = s();
        Object[] objArrT = t();
        int i2 = this.f;
        int i3 = i2 + 1;
        int iC = v04.c(obj3);
        int iJ = j();
        int i4 = iC & iJ;
        Object obj5 = this.a;
        Objects.requireNonNull(obj5);
        int iE = k71.e(i4, obj5);
        int i5 = 1;
        if (iE != 0) {
            int i6 = ~iJ;
            int i7 = iC & i6;
            int i8 = 0;
            while (true) {
                int i9 = iE - i5;
                int i10 = iArrR[i9];
                i = i5;
                if ((i10 & i6) == i7 && ts6.a(obj3, objArrS[i9])) {
                    Object obj6 = objArrT[i9];
                    objArrT[i9] = obj4;
                    a(i9);
                    return obj6;
                }
                int i11 = i10 & iJ;
                i8++;
                if (i11 != 0) {
                    obj3 = obj;
                    obj4 = obj2;
                    iE = i11;
                    i5 = i;
                } else {
                    if (i8 >= 9) {
                        return d().put(obj3, obj4);
                    }
                    if (i3 > iJ) {
                        iJ = v(iJ, k71.c(iJ), iC, i2);
                    } else {
                        iArrR[i9] = k71.b(i10, i3, iJ);
                    }
                }
            }
        } else {
            if (i3 > iJ) {
                iV = v(iJ, k71.c(iJ), iC, i2);
                i = 1;
                length = r().length;
                if (i3 > length) {
                    int i12 = i;
                    int iMin = Math.min(1073741823, (Math.max(i12, length >>> 1) + length) | i12);
                    if (iMin != length) {
                        u(iMin);
                    }
                }
                n(i2, iC, iV, obj3, obj4);
                this.f = i3;
                k();
                return null;
            }
            Object obj7 = this.a;
            Objects.requireNonNull(obj7);
            k71.f(i4, i3, obj7);
            i = 1;
        }
        iV = iJ;
        length = r().length;
        if (i3 > length) {
        }
        n(i2, iC, iV, obj3, obj4);
        this.f = i3;
        k();
        return null;
    }

    public final Object q(Object obj) {
        boolean zP = p();
        Object obj2 = l;
        if (zP) {
            return obj2;
        }
        int iJ = j();
        Object obj3 = this.a;
        Objects.requireNonNull(obj3);
        int iD = k71.d(obj, null, iJ, obj3, r(), s(), null);
        if (iD == -1) {
            return obj2;
        }
        Object obj4 = t()[iD];
        o(iD, iJ);
        this.f--;
        k();
        return obj4;
    }

    public final int[] r() {
        int[] iArr = this.b;
        Objects.requireNonNull(iArr);
        return iArr;
    }

    @Override // java.util.AbstractMap, java.util.Map
    public final Object remove(Object obj) {
        Map mapG = g();
        if (mapG != null) {
            return mapG.remove(obj);
        }
        Object objQ = q(obj);
        if (objQ == l) {
            return null;
        }
        return objQ;
    }

    public final Object[] s() {
        Object[] objArr = this.c;
        Objects.requireNonNull(objArr);
        return objArr;
    }

    @Override // java.util.AbstractMap, java.util.Map
    public final int size() {
        Map mapG = g();
        return mapG != null ? mapG.size() : this.f;
    }

    public final Object[] t() {
        Object[] objArr = this.d;
        Objects.requireNonNull(objArr);
        return objArr;
    }

    public void u(int i) {
        this.b = Arrays.copyOf(r(), i);
        this.c = Arrays.copyOf(s(), i);
        this.d = Arrays.copyOf(t(), i);
    }

    public final int v(int i, int i2, int i3, int i4) {
        Object objA = k71.a(i2);
        int i5 = i2 - 1;
        if (i4 != 0) {
            k71.f(i3 & i5, i4 + 1, objA);
        }
        Object obj = this.a;
        Objects.requireNonNull(obj);
        int[] iArrR = r();
        for (int i6 = 0; i6 <= i; i6++) {
            int iE = k71.e(i6, obj);
            while (iE != 0) {
                int i7 = iE - 1;
                int i8 = iArrR[i7];
                int i9 = ((~i) & i8) | i6;
                int i10 = i9 & i5;
                int iE2 = k71.e(i10, objA);
                k71.f(i10, iE, objA);
                iArrR[i7] = k71.b(i9, iE2, i5);
                iE = i8 & i;
            }
        }
        this.a = objA;
        this.e = k71.b(this.e, 32 - Integer.numberOfLeadingZeros(i5), 31);
        return i5;
    }

    @Override // java.util.AbstractMap, java.util.Map
    public final Collection values() {
        Collection collection = this.k;
        if (collection != null) {
            return collection;
        }
        e eVar = new e();
        this.k = eVar;
        return eVar;
    }
}