package j$.com.android.tools.r8;

import j$.time.ZoneId;
import j$.time.ZoneOffset;
import j$.time.chrono.ChronoLocalDate;
import j$.time.chrono.ChronoLocalDateTime;
import j$.time.chrono.ChronoZonedDateTime;
import j$.time.chrono.e0;
import j$.time.chrono.j;
import j$.time.chrono.m;
import j$.time.chrono.q;
import j$.time.chrono.t;
import j$.time.g;
import j$.time.temporal.ChronoUnit;
import j$.time.temporal.Temporal;
import j$.time.temporal.TemporalAccessor;
import j$.time.temporal.o;
import j$.time.temporal.p;
import j$.util.Collection;
import j$.util.Objects;
import j$.util.Optional;
import j$.util.Spliterator;
import j$.util.Spliterators;
import j$.util.a0;
import j$.util.b0;
import j$.util.c0;
import j$.util.concurrent.ConcurrentHashMap;
import j$.util.concurrent.k;
import j$.util.concurrent.s;
import j$.util.d0;
import j$.util.function.b;
import j$.util.function.e;
import j$.util.function.f;
import j$.util.h0;
import j$.util.l0;
import j$.util.q0;
import j$.util.s1;
import j$.util.stream.Stream;
import j$.util.t0;
import j$.util.w0;
import j$.util.y;
import j$.util.z0;
import java.text.SimpleDateFormat;
import java.util.AbstractMap;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Calendar;
import java.util.Collection;
import java.util.Collections;
import java.util.Iterator;
import java.util.LinkedHashSet;
import java.util.List;
import java.util.Locale;
import java.util.Map;
import java.util.NoSuchElementException;
import java.util.OptionalDouble;
import java.util.OptionalInt;
import java.util.OptionalLong;
import java.util.RandomAccess;
import java.util.ServiceConfigurationError;
import java.util.ServiceLoader;
import java.util.Set;
import java.util.SortedSet;
import java.util.TimeZone;
import java.util.concurrent.ConcurrentMap;
import java.util.function.BiConsumer;
import java.util.function.BiFunction;
import java.util.function.Consumer;
import java.util.function.DoubleConsumer;
import java.util.function.IntConsumer;
import java.util.function.LongConsumer;
import java.util.function.Predicate;
import sun.misc.Unsafe;

/* JADX INFO: compiled from: r8-map-id-da1bda724d8b26dc30f90d2ccf434f42461d6c82e7dbdeb074f412e5504de99c */
/* JADX INFO: loaded from: classes2.dex */
public abstract /* synthetic */ class a {
    public static long A(ChronoZonedDateTime chronoZonedDateTime) {
        return ((chronoZonedDateTime.f().F() * 86400) + ((long) chronoZonedDateTime.b().f0())) - ((long) chronoZonedDateTime.g().b);
    }

    public static boolean B(t0 t0Var, Consumer consumer) {
        if (consumer instanceof DoubleConsumer) {
            return t0Var.tryAdvance((DoubleConsumer) consumer);
        }
        if (s1.a) {
            s1.a(t0Var.getClass(), "{0} calling Spliterator.OfDouble.tryAdvance((DoubleConsumer) action::accept)");
            throw null;
        }
        Objects.requireNonNull(consumer);
        return t0Var.tryAdvance((DoubleConsumer) new d0(consumer, 0));
    }

    public static boolean C(w0 w0Var, Consumer consumer) {
        if (consumer instanceof IntConsumer) {
            return w0Var.tryAdvance((IntConsumer) consumer);
        }
        if (s1.a) {
            s1.a(w0Var.getClass(), "{0} calling Spliterator.OfInt.tryAdvance((IntConsumer) action::accept)");
            throw null;
        }
        Objects.requireNonNull(consumer);
        return w0Var.tryAdvance((IntConsumer) new h0(consumer, 0));
    }

    public static boolean D(z0 z0Var, Consumer consumer) {
        if (consumer instanceof LongConsumer) {
            return z0Var.tryAdvance((LongConsumer) consumer);
        }
        if (s1.a) {
            s1.a(z0Var.getClass(), "{0} calling Spliterator.OfLong.tryAdvance((LongConsumer) action::accept)");
            throw null;
        }
        Objects.requireNonNull(consumer);
        return z0Var.tryAdvance((LongConsumer) new l0(consumer, 0));
    }

    public static String E(long j, String str, Locale locale) {
        TimeZone timeZone = TimeZone.getTimeZone("UTC");
        SimpleDateFormat simpleDateFormat = new SimpleDateFormat(str, locale);
        simpleDateFormat.setTimeZone(timeZone);
        Calendar calendar = Calendar.getInstance();
        calendar.setTimeZone(timeZone);
        calendar.set(2016, 1, (int) j, 0, 0, 0);
        return simpleDateFormat.format(calendar.getTime());
    }

    public static String F(long j, String str, Locale locale) {
        TimeZone timeZone = TimeZone.getTimeZone("UTC");
        SimpleDateFormat simpleDateFormat = new SimpleDateFormat(str, locale);
        simpleDateFormat.setTimeZone(timeZone);
        Calendar calendar = Calendar.getInstance();
        calendar.setTimeZone(timeZone);
        calendar.set(0, (int) j, 0, 0, 0, 0);
        return simpleDateFormat.format(calendar.getTime());
    }

    public static Optional G(java.util.Optional optional) {
        if (optional == null) {
            return null;
        }
        return optional.isPresent() ? new Optional(optional.get()) : Optional.b;
    }

    public static a0 H(OptionalDouble optionalDouble) {
        if (optionalDouble == null) {
            return null;
        }
        return optionalDouble.isPresent() ? new a0(optionalDouble.getAsDouble()) : a0.c;
    }

    public static b0 I(OptionalInt optionalInt) {
        if (optionalInt == null) {
            return null;
        }
        return optionalInt.isPresent() ? new b0(optionalInt.getAsInt()) : b0.c;
    }

    public static c0 J(OptionalLong optionalLong) {
        if (optionalLong == null) {
            return null;
        }
        return optionalLong.isPresent() ? new c0(optionalLong.getAsLong()) : c0.c;
    }

    public static java.util.Optional K(Optional optional) {
        if (optional == null) {
            return null;
        }
        Object obj = optional.a;
        if (obj == null) {
            return java.util.Optional.empty();
        }
        if (obj != null) {
            return java.util.Optional.of(obj);
        }
        throw new NoSuchElementException("No value present");
    }

    public static OptionalDouble L(a0 a0Var) {
        if (a0Var == null) {
            return null;
        }
        boolean z = a0Var.a;
        if (!z) {
            return OptionalDouble.empty();
        }
        if (z) {
            return OptionalDouble.of(a0Var.b);
        }
        throw new NoSuchElementException("No value present");
    }

    public static OptionalInt M(b0 b0Var) {
        if (b0Var == null) {
            return null;
        }
        boolean z = b0Var.a;
        if (!z) {
            return OptionalInt.empty();
        }
        if (z) {
            return OptionalInt.of(b0Var.b);
        }
        throw new NoSuchElementException("No value present");
    }

    public static OptionalLong N(c0 c0Var) {
        if (c0Var == null) {
            return null;
        }
        boolean z = c0Var.a;
        if (!z) {
            return OptionalLong.empty();
        }
        if (z) {
            return OptionalLong.of(c0Var.b);
        }
        throw new NoSuchElementException("No value present");
    }

    public static void O(Collection collection, Consumer consumer) {
        if (collection instanceof j$.util.Collection) {
            ((j$.util.Collection) collection).forEach(consumer);
            return;
        }
        Objects.requireNonNull(consumer);
        Iterator it = collection.iterator();
        while (it.hasNext()) {
            consumer.accept(it.next());
        }
    }

    public static void P(Iterator it, Consumer consumer) {
        if (it instanceof y) {
            ((y) it).forEachRemaining(consumer);
            return;
        }
        Objects.requireNonNull(consumer);
        while (it.hasNext()) {
            consumer.accept(it.next());
        }
    }

    public static j Q(TemporalAccessor temporalAccessor) {
        Objects.requireNonNull(temporalAccessor, "temporal");
        Object objRequireNonNull = (j) temporalAccessor.G(p.b);
        q qVar = q.c;
        if (objRequireNonNull == null) {
            objRequireNonNull = Objects.requireNonNull(qVar, "defaultObj");
        }
        return (j) objRequireNonNull;
    }

    public static /* synthetic */ int R(long j) {
        int i = (int) j;
        if (j == i) {
            return i;
        }
        throw new ArithmeticException();
    }

    public static /* synthetic */ long S(long j, long j2) {
        long j3 = j + j2;
        if (((j2 ^ j) < 0) || ((j ^ j3) >= 0)) {
            return j3;
        }
        throw new ArithmeticException();
    }

    public static /* synthetic */ List T(Object[] objArr) {
        ArrayList arrayList = new ArrayList(objArr.length);
        for (Object obj : objArr) {
            arrayList.add(Objects.requireNonNull(obj));
        }
        return Collections.unmodifiableList(arrayList);
    }

    public static /* synthetic */ Map.Entry U(Object obj, Object obj2) {
        return new AbstractMap.SimpleImmutableEntry(Objects.requireNonNull(obj), Objects.requireNonNull(obj2));
    }

    public static /* synthetic */ boolean V(Unsafe unsafe, Object obj, long j, k kVar) {
        while (true) {
            Unsafe unsafe2 = unsafe;
            Object obj2 = obj;
            long j2 = j;
            k kVar2 = kVar;
            if (unsafe2.compareAndSwapObject(obj2, j2, (Object) null, kVar2)) {
                return true;
            }
            if (unsafe2.getObject(obj2, j2) != null) {
                return false;
            }
            unsafe = unsafe2;
            obj = obj2;
            j = j2;
            kVar = kVar2;
        }
    }

    public static /* synthetic */ long W(long j, long j2) {
        long j3 = j % j2;
        if (j3 == 0) {
            return 0L;
        }
        return (((j ^ j2) >> 63) | 1) > 0 ? j3 : j3 + j2;
    }

    public static /* synthetic */ long X(long j, long j2) {
        long j3 = j / j2;
        return (j - (j2 * j3) != 0 && (((j ^ j2) >> 63) | 1) < 0) ? j3 - 1 : j3;
    }

    public static /* synthetic */ long Y(long j, long j2) {
        int iNumberOfLeadingZeros = Long.numberOfLeadingZeros(~j2) + Long.numberOfLeadingZeros(j2) + Long.numberOfLeadingZeros(~j) + Long.numberOfLeadingZeros(j);
        if (iNumberOfLeadingZeros > 65) {
            return j * j2;
        }
        if (iNumberOfLeadingZeros >= 64) {
            if ((j2 != Long.MIN_VALUE) | (j >= 0)) {
                long j3 = j * j2;
                if (j == 0 || j3 / j == j2) {
                    return j3;
                }
            }
        }
        throw new ArithmeticException();
    }

    public static /* synthetic */ long Z(long j, long j2) {
        long j3 = j - j2;
        if (((j2 ^ j) >= 0) || ((j ^ j3) >= 0)) {
            return j3;
        }
        throw new ArithmeticException();
    }

    public static Temporal a(ChronoLocalDate chronoLocalDate, Temporal temporal) {
        return temporal.c(chronoLocalDate.F(), j$.time.temporal.a.EPOCH_DAY);
    }

    public static String a0(Object obj, Object obj2) {
        String string;
        String string2;
        String str = "null";
        if (obj == null || (string = obj.toString()) == null) {
            string = "null";
        }
        int length = string.length();
        if (obj2 != null && (string2 = obj2.toString()) != null) {
            str = string2;
        }
        int length2 = str.length();
        char[] cArr = new char[length + length2 + 1];
        string.getChars(0, length, cArr, 0);
        cArr[length] = '=';
        str.getChars(0, length2, cArr, length + 1);
        return new String(cArr);
    }

    public static f b(Predicate predicate, Predicate predicate2) {
        Objects.requireNonNull(predicate2);
        return new f(predicate, predicate2, 0);
    }

    public static j b0(String str) {
        ConcurrentHashMap concurrentHashMap = j$.time.chrono.a.a;
        Objects.requireNonNull(str, "id");
        while (true) {
            ConcurrentHashMap concurrentHashMap2 = j$.time.chrono.a.a;
            j jVar = (j) concurrentHashMap2.get(str);
            if (jVar == null) {
                jVar = (j) j$.time.chrono.a.b.get(str);
            }
            if (jVar != null) {
                return jVar;
            }
            if (concurrentHashMap2.get("ISO") != null) {
                for (j jVar2 : ServiceLoader.load(j.class)) {
                    if (str.equals(jVar2.j()) || str.equals(jVar2.n())) {
                        return jVar2;
                    }
                }
                g.j(str, "Unknown chronology: ");
                return null;
            }
            m mVar = m.l;
            mVar.getClass();
            j$.time.chrono.a.m(mVar, "Hijrah-umalqura");
            t tVar = t.c;
            tVar.getClass();
            j$.time.chrono.a.m(tVar, "Japanese");
            j$.time.chrono.y yVar = j$.time.chrono.y.c;
            yVar.getClass();
            j$.time.chrono.a.m(yVar, "Minguo");
            e0 e0Var = e0.c;
            e0Var.getClass();
            j$.time.chrono.a.m(e0Var, "ThaiBuddhist");
            try {
                for (j$.time.chrono.a aVar : Arrays.asList(new j$.time.chrono.a[0])) {
                    if (!aVar.j().equals("ISO")) {
                        j$.time.chrono.a.m(aVar, aVar.j());
                    }
                }
                q qVar = q.c;
                qVar.getClass();
                j$.time.chrono.a.m(qVar, "ISO");
            } catch (Throwable th) {
                throw new ServiceConfigurationError(th.getMessage(), th);
            }
        }
    }

    public static s c(BiConsumer biConsumer, BiConsumer biConsumer2) {
        Objects.requireNonNull(biConsumer2);
        return new s(1, biConsumer, biConsumer2);
    }

    public static /* synthetic */ Stream c0(Collection collection) {
        return collection instanceof j$.util.Collection ? ((j$.util.Collection) collection).parallelStream() : Collection.CC.$default$parallelStream(collection);
    }

    /* JADX WARN: Type inference failed for: r0v0, types: [j$.util.function.b] */
    public static b d(final DoubleConsumer doubleConsumer, final DoubleConsumer doubleConsumer2) {
        Objects.requireNonNull(doubleConsumer2);
        return new DoubleConsumer() { // from class: j$.util.function.b
            @Override // java.util.function.DoubleConsumer
            public final void accept(double d) {
                doubleConsumer.accept(d);
                doubleConsumer2.accept(d);
            }

            public final /* synthetic */ DoubleConsumer andThen(DoubleConsumer doubleConsumer3) {
                return j$.com.android.tools.r8.a.d(this, doubleConsumer3);
            }
        };
    }

    public static Spliterator d0(java.util.Collection collection) {
        if (collection instanceof j$.util.Collection) {
            return ((j$.util.Collection) collection).spliterator();
        }
        if (collection instanceof LinkedHashSet) {
            return Spliterators.spliterator((LinkedHashSet) collection, 17);
        }
        if (collection instanceof SortedSet) {
            SortedSet sortedSet = (SortedSet) collection;
            return new q0(sortedSet, sortedSet);
        }
        if (collection instanceof Set) {
            return Spliterators.spliterator((Set) collection, 1);
        }
        if (!(collection instanceof List)) {
            return Spliterators.spliterator(collection, 0);
        }
        List list = (List) collection;
        return list instanceof RandomAccess ? new j$.util.a(list) : Spliterators.spliterator(list, 16);
    }

    /* JADX WARN: Type inference failed for: r0v0, types: [j$.util.function.e] */
    public static e e(final LongConsumer longConsumer, final LongConsumer longConsumer2) {
        Objects.requireNonNull(longConsumer2);
        return new LongConsumer() { // from class: j$.util.function.e
            @Override // java.util.function.LongConsumer
            public final void accept(long j) {
                longConsumer.accept(j);
                longConsumer2.accept(j);
            }

            public final /* synthetic */ LongConsumer andThen(LongConsumer longConsumer3) {
                return j$.com.android.tools.r8.a.e(this, longConsumer3);
            }
        };
    }

    public static /* synthetic */ Stream e0(java.util.Collection collection) {
        return collection instanceof j$.util.Collection ? ((j$.util.Collection) collection).stream() : Collection.CC.$default$stream(collection);
    }

    public static int f(ChronoLocalDate chronoLocalDate, ChronoLocalDate chronoLocalDate2) {
        int iCompare = Long.compare(chronoLocalDate.F(), chronoLocalDate2.F());
        if (iCompare != 0) {
            return iCompare;
        }
        return ((j$.time.chrono.a) chronoLocalDate.a()).j().compareTo(chronoLocalDate2.a().j());
    }

    public static j$.time.a f0() {
        return new j$.time.a(ZoneId.systemDefault());
    }

    public static int g(ChronoLocalDateTime chronoLocalDateTime, ChronoLocalDateTime chronoLocalDateTime2) {
        int iQ = chronoLocalDateTime.f().compareTo(chronoLocalDateTime2.f());
        return (iQ == 0 && (iQ = chronoLocalDateTime.b().compareTo(chronoLocalDateTime2.b())) == 0) ? ((j$.time.chrono.a) chronoLocalDateTime.a()).j().compareTo(chronoLocalDateTime2.a().j()) : iQ;
    }

    public static int h(ChronoZonedDateTime chronoZonedDateTime, ChronoZonedDateTime chronoZonedDateTime2) {
        int iCompare = Long.compare(chronoZonedDateTime.toEpochSecond(), chronoZonedDateTime2.toEpochSecond());
        return (iCompare == 0 && (iCompare = chronoZonedDateTime.b().d - chronoZonedDateTime2.b().d) == 0 && (iCompare = chronoZonedDateTime.r().K(chronoZonedDateTime2.r())) == 0 && (iCompare = chronoZonedDateTime.D().j().compareTo(chronoZonedDateTime2.D().j())) == 0) ? ((j$.time.chrono.a) chronoZonedDateTime.a()).j().compareTo(chronoZonedDateTime2.a().j()) : iCompare;
    }

    /* JADX WARN: Code restructure failed: missing block: B:11:0x0019, code lost:
    
        return r1;
     */
    /*
        Code decompiled incorrectly, please refer to instructions dump.
    */
    public static Object i(ConcurrentMap concurrentMap, Object obj, BiFunction biFunction) {
        loop0: while (true) {
            Object objPutIfAbsent = concurrentMap.get(obj);
            while (true) {
                Object objApply = biFunction.apply(obj, objPutIfAbsent);
                if (objApply != null) {
                    if (objPutIfAbsent == null) {
                        objPutIfAbsent = concurrentMap.putIfAbsent(obj, objApply);
                        if (objPutIfAbsent == null) {
                            break loop0;
                        }
                    } else if (concurrentMap.replace(obj, objPutIfAbsent, objApply)) {
                        break;
                    }
                } else if (objPutIfAbsent == null || concurrentMap.remove(obj, objPutIfAbsent)) {
                    return null;
                }
            }
        }
    }

    public static void j(ConcurrentMap concurrentMap, BiConsumer biConsumer) {
        Objects.requireNonNull(biConsumer);
        for (Map.Entry entry : concurrentMap.entrySet()) {
            try {
                biConsumer.accept(entry.getKey(), entry.getValue());
            } catch (IllegalStateException unused) {
            }
        }
    }

    public static void k(t0 t0Var, Consumer consumer) {
        if (consumer instanceof DoubleConsumer) {
            t0Var.forEachRemaining((DoubleConsumer) consumer);
        } else {
            if (s1.a) {
                s1.a(t0Var.getClass(), "{0} calling Spliterator.OfDouble.forEachRemaining((DoubleConsumer) action::accept)");
                throw null;
            }
            Objects.requireNonNull(consumer);
            t0Var.forEachRemaining((DoubleConsumer) new d0(consumer, 0));
        }
    }

    public static void l(w0 w0Var, Consumer consumer) {
        if (consumer instanceof IntConsumer) {
            w0Var.forEachRemaining((IntConsumer) consumer);
        } else {
            if (s1.a) {
                s1.a(w0Var.getClass(), "{0} calling Spliterator.OfInt.forEachRemaining((IntConsumer) action::accept)");
                throw null;
            }
            Objects.requireNonNull(consumer);
            w0Var.forEachRemaining((IntConsumer) new h0(consumer, 0));
        }
    }

    public static void m(z0 z0Var, Consumer consumer) {
        if (consumer instanceof LongConsumer) {
            z0Var.forEachRemaining((LongConsumer) consumer);
        } else {
            if (s1.a) {
                s1.a(z0Var.getClass(), "{0} calling Spliterator.OfLong.forEachRemaining((LongConsumer) action::accept)");
                throw null;
            }
            Objects.requireNonNull(consumer);
            z0Var.forEachRemaining((LongConsumer) new l0(consumer, 0));
        }
    }

    public static int n(ChronoZonedDateTime chronoZonedDateTime, o oVar) {
        if (!(oVar instanceof j$.time.temporal.a)) {
            return p.a(chronoZonedDateTime, oVar);
        }
        int i = j$.time.chrono.g.a[((j$.time.temporal.a) oVar).ordinal()];
        if (i != 1) {
            return i != 2 ? chronoZonedDateTime.r().k(oVar) : chronoZonedDateTime.g().b;
        }
        throw new j$.time.temporal.q("Invalid field 'InstantSeconds' for get() method, use getLong() instead");
    }

    public static int o(j$.time.chrono.k kVar, o oVar) {
        return oVar == j$.time.temporal.a.ERA ? kVar.getValue() : p.a(kVar, oVar);
    }

    public static long p(Spliterator spliterator) {
        if ((spliterator.characteristics() & 64) == 0) {
            return -1L;
        }
        return spliterator.estimateSize();
    }

    public static long q(j$.time.chrono.k kVar, o oVar) {
        if (oVar == j$.time.temporal.a.ERA) {
            return kVar.getValue();
        }
        if (oVar instanceof j$.time.temporal.a) {
            throw new j$.time.temporal.q(j$.time.b.a("Unsupported field: ", oVar));
        }
        return oVar.A(kVar);
    }

    public static boolean r(Spliterator spliterator, int i) {
        return (spliterator.characteristics() & i) == i;
    }

    public static boolean s(ChronoLocalDate chronoLocalDate, o oVar) {
        return oVar instanceof j$.time.temporal.a ? ((j$.time.temporal.a) oVar).isDateBased() : oVar != null && oVar.k(chronoLocalDate);
    }

    public static boolean t(j$.time.chrono.k kVar, o oVar) {
        return oVar instanceof j$.time.temporal.a ? oVar == j$.time.temporal.a.ERA : oVar != null && oVar.k(kVar);
    }

    public static f u(Predicate predicate, Predicate predicate2) {
        Objects.requireNonNull(predicate2);
        return new f(predicate, predicate2, 1);
    }

    public static Object v(ChronoLocalDate chronoLocalDate, j$.time.f fVar) {
        if (fVar == p.a || fVar == p.e || fVar == p.d || fVar == p.g) {
            return null;
        }
        return fVar == p.b ? chronoLocalDate.a() : fVar == p.c ? ChronoUnit.DAYS : fVar.g(chronoLocalDate);
    }

    public static Object w(ChronoLocalDateTime chronoLocalDateTime, j$.time.f fVar) {
        if (fVar == p.a || fVar == p.e || fVar == p.d) {
            return null;
        }
        return fVar == p.g ? chronoLocalDateTime.b() : fVar == p.b ? chronoLocalDateTime.a() : fVar == p.c ? ChronoUnit.NANOS : fVar.g(chronoLocalDateTime);
    }

    public static Object x(ChronoZonedDateTime chronoZonedDateTime, j$.time.f fVar) {
        return (fVar == p.e || fVar == p.a) ? chronoZonedDateTime.D() : fVar == p.d ? chronoZonedDateTime.g() : fVar == p.g ? chronoZonedDateTime.b() : fVar == p.b ? chronoZonedDateTime.a() : fVar == p.c ? ChronoUnit.NANOS : fVar.g(chronoZonedDateTime);
    }

    public static Object y(j$.time.chrono.k kVar, j$.time.f fVar) {
        return fVar == p.c ? ChronoUnit.ERAS : p.c(kVar, fVar);
    }

    public static long z(ChronoLocalDateTime chronoLocalDateTime, ZoneOffset zoneOffset) {
        Objects.requireNonNull(zoneOffset, "offset");
        return ((chronoLocalDateTime.f().F() * 86400) + ((long) chronoLocalDateTime.b().f0())) - ((long) zoneOffset.b);
    }

    public int characteristics() {
        return 16448;
    }

    public long estimateSize() {
        return 0L;
    }

    public void forEachRemaining(Object obj) {
        Objects.requireNonNull(obj);
    }

    public boolean tryAdvance(Object obj) {
        Objects.requireNonNull(obj);
        return false;
    }

    public Spliterator trySplit() {
        return null;
    }
}