Initial import of ADIF API reverse-engineering toolkit

apk_decompiled/sources/dagger/internal/AbstractMapFactory.java

@@ -0,0 +1,42 @@
+package dagger.internal;
+
+import java.util.Collections;
+import java.util.LinkedHashMap;
+import java.util.Map;
+
+/* JADX INFO: Access modifiers changed from: package-private */
+/* loaded from: classes3.dex */
+public abstract class AbstractMapFactory<K, V, V2> implements Factory<Map<K, V2>> {
+    private final Map<K, Provider<V>> contributingMap;
+
+    /* loaded from: classes3.dex */
+    public static abstract class Builder<K, V, V2> {
+        final LinkedHashMap<K, Provider<V>> map;
+
+        public Builder(int i) {
+            this.map = DaggerCollections.newLinkedHashMapWithExpectedSize(i);
+        }
+
+        /* JADX WARN: Multi-variable type inference failed */
+        public Builder<K, V, V2> put(K k4, Provider<V> provider) {
+            this.map.put(Preconditions.checkNotNull(k4, "key"), Preconditions.checkNotNull(provider, "provider"));
+            return this;
+        }
+
+        public Builder<K, V, V2> putAll(Provider<Map<K, V2>> provider) {
+            if (provider instanceof DelegateFactory) {
+                return putAll(((DelegateFactory) provider).getDelegate());
+            }
+            this.map.putAll(((AbstractMapFactory) provider).contributingMap);
+            return this;
+        }
+    }
+
+    public AbstractMapFactory(Map<K, Provider<V>> map) {
+        this.contributingMap = Collections.unmodifiableMap(map);
+    }
+
+    public final Map<K, Provider<V>> contributingMap() {
+        return this.contributingMap;
+    }
+}

apk_decompiled/sources/dagger/internal/Beta.java

@@ -0,0 +1,11 @@
+package dagger.internal;
+
+import java.lang.annotation.Documented;
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+
+@Documented
+@Retention(RetentionPolicy.SOURCE)
+/* loaded from: classes3.dex */
+public @interface Beta {
+}

apk_decompiled/sources/dagger/internal/ComponentDefinitionType.java

@@ -0,0 +1,10 @@
+package dagger.internal;
+
+import java.lang.annotation.ElementType;
+import java.lang.annotation.Target;
+
+@Target({ElementType.TYPE})
+/* loaded from: classes3.dex */
+public @interface ComponentDefinitionType {
+    Class<?> value();
+}

apk_decompiled/sources/dagger/internal/DaggerCollections.java

@@ -0,0 +1,44 @@
+package dagger.internal;
+
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.HashSet;
+import java.util.LinkedHashMap;
+import java.util.List;
+
+/* loaded from: classes3.dex */
+public final class DaggerCollections {
+    private static final int MAX_POWER_OF_TWO = 1073741824;
+
+    private DaggerCollections() {
+    }
+
+    private static int calculateInitialCapacity(int i) {
+        if (i < 3) {
+            return i + 1;
+        }
+        if (i < MAX_POWER_OF_TWO) {
+            return (int) ((i / 0.75f) + 1.0f);
+        }
+        return Integer.MAX_VALUE;
+    }
+
+    public static boolean hasDuplicates(List<?> list) {
+        if (list.size() < 2) {
+            return false;
+        }
+        return list.size() != new HashSet(list).size();
+    }
+
+    public static <T> HashSet<T> newHashSetWithExpectedSize(int i) {
+        return new HashSet<>(calculateInitialCapacity(i));
+    }
+
+    public static <K, V> LinkedHashMap<K, V> newLinkedHashMapWithExpectedSize(int i) {
+        return new LinkedHashMap<>(calculateInitialCapacity(i));
+    }
+
+    public static <T> List<T> presizedList(int i) {
+        return i == 0 ? Collections.EMPTY_LIST : new ArrayList(i);
+    }
+}

apk_decompiled/sources/dagger/internal/DaggerGenerated.java

@@ -0,0 +1,14 @@
+package dagger.internal;
+
+import java.lang.annotation.Documented;
+import java.lang.annotation.ElementType;
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+import java.lang.annotation.Target;
+
+@Target({ElementType.TYPE})
+@Documented
+@Retention(RetentionPolicy.CLASS)
+/* loaded from: classes3.dex */
+public @interface DaggerGenerated {
+}

apk_decompiled/sources/dagger/internal/DelegateFactory.java

@@ -0,0 +1,46 @@
+package dagger.internal;
+
+/* loaded from: classes3.dex */
+public final class DelegateFactory<T> implements Factory<T> {
+    private Provider<T> delegate;
+
+    public static <T> void setDelegate(Provider<T> provider, Provider<T> provider2) {
+        setDelegateInternal((DelegateFactory) provider, provider2);
+    }
+
+    private static <T> void setDelegateInternal(DelegateFactory<T> delegateFactory, Provider<T> provider) {
+        Preconditions.checkNotNull(provider);
+        if (((DelegateFactory) delegateFactory).delegate != null) {
+            throw new IllegalStateException();
+        }
+        ((DelegateFactory) delegateFactory).delegate = provider;
+    }
+
+    @Override // javax.inject.Provider
+    public T get() {
+        Provider<T> provider = this.delegate;
+        if (provider != null) {
+            return provider.get();
+        }
+        throw new IllegalStateException();
+    }
+
+    public Provider<T> getDelegate() {
+        return (Provider) Preconditions.checkNotNull(this.delegate);
+    }
+
+    @Deprecated
+    public void setDelegatedProvider(Provider<T> provider) {
+        setDelegate((Provider) this, (Provider) provider);
+    }
+
+    @Deprecated
+    public void setDelegatedProvider(javax.inject.Provider<T> provider) {
+        setDelegatedProvider((Provider) Providers.asDaggerProvider(provider));
+    }
+
+    @Deprecated
+    public static <T> void setDelegate(javax.inject.Provider<T> provider, javax.inject.Provider<T> provider2) {
+        setDelegateInternal((DelegateFactory) provider, Providers.asDaggerProvider(provider2));
+    }
+}

apk_decompiled/sources/dagger/internal/DoubleCheck.java

@@ -0,0 +1,67 @@
+package dagger.internal;
+
+import dagger.Lazy;
+
+/* loaded from: classes3.dex */
+public final class DoubleCheck<T> implements Provider<T>, Lazy<T> {
+    static final /* synthetic */ boolean $assertionsDisabled = false;
+    private static final Object UNINITIALIZED = new Object();
+    private volatile Object instance = UNINITIALIZED;
+    private volatile Provider<T> provider;
+
+    private DoubleCheck(Provider<T> provider) {
+        this.provider = provider;
+    }
+
+    public static <P extends Provider<T>, T> Lazy<T> lazy(P p) {
+        if (p instanceof Lazy) {
+            return (Lazy) p;
+        }
+        return new DoubleCheck((Provider) Preconditions.checkNotNull(p));
+    }
+
+    public static <P extends Provider<T>, T> Provider<T> provider(P p) {
+        Preconditions.checkNotNull(p);
+        return p instanceof DoubleCheck ? p : new DoubleCheck(p);
+    }
+
+    private static Object reentrantCheck(Object obj, Object obj2) {
+        if (obj == UNINITIALIZED || obj == obj2) {
+            return obj2;
+        }
+        throw new IllegalStateException("Scoped provider was invoked recursively returning different results: " + obj + " & " + obj2 + ". This is likely due to a circular dependency.");
+    }
+
+    @Override // javax.inject.Provider
+    public T get() {
+        T t2;
+        T t4 = (T) this.instance;
+        Object obj = UNINITIALIZED;
+        if (t4 != obj) {
+            return t4;
+        }
+        synchronized (this) {
+            try {
+                t2 = (T) this.instance;
+                if (t2 == obj) {
+                    t2 = this.provider.get();
+                    this.instance = reentrantCheck(this.instance, t2);
+                    this.provider = null;
+                }
+            } catch (Throwable th) {
+                throw th;
+            }
+        }
+        return t2;
+    }
+
+    @Deprecated
+    public static <P extends javax.inject.Provider<T>, T> Lazy<T> lazy(P p) {
+        return lazy(Providers.asDaggerProvider(p));
+    }
+
+    @Deprecated
+    public static <P extends javax.inject.Provider<T>, T> javax.inject.Provider<T> provider(P p) {
+        return provider(Providers.asDaggerProvider(p));
+    }
+}

apk_decompiled/sources/dagger/internal/Factory.java

@@ -0,0 +1,5 @@
+package dagger.internal;
+
+/* loaded from: classes3.dex */
+public interface Factory<T> extends Provider<T> {
+}

apk_decompiled/sources/dagger/internal/GwtIncompatible.java

@@ -0,0 +1,5 @@
+package dagger.internal;
+
+/* loaded from: classes3.dex */
+public @interface GwtIncompatible {
+}

apk_decompiled/sources/dagger/internal/InjectedFieldSignature.java

@@ -0,0 +1,13 @@
+package dagger.internal;
+
+import java.lang.annotation.ElementType;
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+import java.lang.annotation.Target;
+
+@Target({ElementType.METHOD})
+@Retention(RetentionPolicy.CLASS)
+/* loaded from: classes3.dex */
+public @interface InjectedFieldSignature {
+    String value();
+}

apk_decompiled/sources/dagger/internal/InstanceFactory.java

@@ -0,0 +1,30 @@
+package dagger.internal;
+
+import dagger.Lazy;
+
+/* loaded from: classes3.dex */
+public final class InstanceFactory<T> implements Factory<T>, Lazy<T> {
+    private static final InstanceFactory<Object> NULL_INSTANCE_FACTORY = new InstanceFactory<>(null);
+    private final T instance;
+
+    private InstanceFactory(T t2) {
+        this.instance = t2;
+    }
+
+    public static <T> Factory<T> create(T t2) {
+        return new InstanceFactory(Preconditions.checkNotNull(t2, "instance cannot be null"));
+    }
+
+    public static <T> Factory<T> createNullable(T t2) {
+        return t2 == null ? nullInstanceFactory() : new InstanceFactory(t2);
+    }
+
+    private static <T> InstanceFactory<T> nullInstanceFactory() {
+        return (InstanceFactory<T>) NULL_INSTANCE_FACTORY;
+    }
+
+    @Override // javax.inject.Provider
+    public T get() {
+        return this.instance;
+    }
+}

apk_decompiled/sources/dagger/internal/MapBuilder.java

@@ -0,0 +1,31 @@
+package dagger.internal;
+
+import java.util.Collections;
+import java.util.Map;
+
+/* loaded from: classes3.dex */
+public final class MapBuilder<K, V> {
+    private final Map<K, V> contributions;
+
+    private MapBuilder(int i) {
+        this.contributions = DaggerCollections.newLinkedHashMapWithExpectedSize(i);
+    }
+
+    public static <K, V> MapBuilder<K, V> newMapBuilder(int i) {
+        return new MapBuilder<>(i);
+    }
+
+    public Map<K, V> build() {
+        return this.contributions.isEmpty() ? Collections.EMPTY_MAP : Collections.unmodifiableMap(this.contributions);
+    }
+
+    public MapBuilder<K, V> put(K k4, V v3) {
+        this.contributions.put(k4, v3);
+        return this;
+    }
+
+    public MapBuilder<K, V> putAll(Map<K, V> map) {
+        this.contributions.putAll(map);
+        return this;
+    }
+}

apk_decompiled/sources/dagger/internal/MapFactory.java

@@ -0,0 +1,72 @@
+package dagger.internal;
+
+import dagger.internal.AbstractMapFactory;
+import java.util.Collections;
+import java.util.LinkedHashMap;
+import java.util.Map;
+
+/* loaded from: classes3.dex */
+public final class MapFactory<K, V> extends AbstractMapFactory<K, V, V> {
+    private static final Provider<Map<Object, Object>> EMPTY = InstanceFactory.create(Collections.EMPTY_MAP);
+
+    /* loaded from: classes3.dex */
+    public static final class Builder<K, V> extends AbstractMapFactory.Builder<K, V, V> {
+        public MapFactory<K, V> build() {
+            return new MapFactory<>(this.map);
+        }
+
+        /* JADX WARN: Multi-variable type inference failed */
+        @Override // dagger.internal.AbstractMapFactory.Builder
+        public /* bridge */ /* synthetic */ AbstractMapFactory.Builder put(Object obj, Provider provider) {
+            return put((Builder<K, V>) obj, provider);
+        }
+
+        private Builder(int i) {
+            super(i);
+        }
+
+        @Override // dagger.internal.AbstractMapFactory.Builder
+        public Builder<K, V> put(K k4, Provider<V> provider) {
+            super.put((Builder<K, V>) k4, (Provider) provider);
+            return this;
+        }
+
+        /* JADX WARN: Multi-variable type inference failed */
+        @Override // dagger.internal.AbstractMapFactory.Builder
+        public Builder<K, V> putAll(Provider<Map<K, V>> provider) {
+            super.putAll((Provider) provider);
+            return this;
+        }
+
+        @Deprecated
+        public Builder<K, V> put(K k4, javax.inject.Provider<V> provider) {
+            return put((Builder<K, V>) k4, (Provider) Providers.asDaggerProvider(provider));
+        }
+
+        @Deprecated
+        public Builder<K, V> putAll(javax.inject.Provider<Map<K, V>> provider) {
+            return putAll((Provider) Providers.asDaggerProvider(provider));
+        }
+    }
+
+    public static <K, V> Builder<K, V> builder(int i) {
+        return new Builder<>(i);
+    }
+
+    public static <K, V> Provider<Map<K, V>> emptyMapProvider() {
+        return (Provider<Map<K, V>>) EMPTY;
+    }
+
+    private MapFactory(Map<K, Provider<V>> map) {
+        super(map);
+    }
+
+    @Override // javax.inject.Provider
+    public Map<K, V> get() {
+        LinkedHashMap newLinkedHashMapWithExpectedSize = DaggerCollections.newLinkedHashMapWithExpectedSize(contributingMap().size());
+        for (Map.Entry<K, Provider<V>> entry : contributingMap().entrySet()) {
+            newLinkedHashMapWithExpectedSize.put(entry.getKey(), entry.getValue().get());
+        }
+        return Collections.unmodifiableMap(newLinkedHashMapWithExpectedSize);
+    }
+}

apk_decompiled/sources/dagger/internal/MapProviderFactory.java

@@ -0,0 +1,77 @@
+package dagger.internal;
+
+import dagger.Lazy;
+import dagger.internal.AbstractMapFactory;
+import java.util.Collections;
+import java.util.LinkedHashMap;
+import java.util.Map;
+
+/* loaded from: classes3.dex */
+public final class MapProviderFactory<K, V> extends AbstractMapFactory<K, V, Provider<V>> implements Lazy<Map<K, Provider<V>>> {
+
+    /* loaded from: classes3.dex */
+    public static final class Builder<K, V> extends AbstractMapFactory.Builder<K, V, Provider<V>> {
+        public MapProviderFactory<K, V> build() {
+            return new MapProviderFactory<>(this.map);
+        }
+
+        /* JADX WARN: Multi-variable type inference failed */
+        @Override // dagger.internal.AbstractMapFactory.Builder
+        public /* bridge */ /* synthetic */ AbstractMapFactory.Builder put(Object obj, Provider provider) {
+            return put((Builder<K, V>) obj, provider);
+        }
+
+        private Builder(int i) {
+            super(i);
+        }
+
+        @Override // dagger.internal.AbstractMapFactory.Builder
+        public Builder<K, V> put(K k4, Provider<V> provider) {
+            super.put((Builder<K, V>) k4, (Provider) provider);
+            return this;
+        }
+
+        /* JADX WARN: Multi-variable type inference failed */
+        @Override // dagger.internal.AbstractMapFactory.Builder
+        public Builder<K, V> putAll(Provider<Map<K, Provider<V>>> provider) {
+            super.putAll((Provider) provider);
+            return this;
+        }
+
+        @Deprecated
+        public Builder<K, V> put(K k4, javax.inject.Provider<V> provider) {
+            return put((Builder<K, V>) k4, (Provider) Providers.asDaggerProvider(provider));
+        }
+
+        @Deprecated
+        public Builder<K, V> putAll(final javax.inject.Provider<Map<K, javax.inject.Provider<V>>> provider) {
+            return putAll((Provider) new Provider<Map<K, Provider<V>>>() { // from class: dagger.internal.MapProviderFactory.Builder.1
+                @Override // javax.inject.Provider
+                public Map<K, Provider<V>> get() {
+                    Map map = (Map) provider.get();
+                    if (map.isEmpty()) {
+                        return Collections.EMPTY_MAP;
+                    }
+                    LinkedHashMap newLinkedHashMapWithExpectedSize = DaggerCollections.newLinkedHashMapWithExpectedSize(map.size());
+                    for (Map.Entry<K, V> entry : map.entrySet()) {
+                        newLinkedHashMapWithExpectedSize.put(entry.getKey(), Providers.asDaggerProvider((javax.inject.Provider) entry.getValue()));
+                    }
+                    return Collections.unmodifiableMap(newLinkedHashMapWithExpectedSize);
+                }
+            });
+        }
+    }
+
+    public static <K, V> Builder<K, V> builder(int i) {
+        return new Builder<>(i);
+    }
+
+    private MapProviderFactory(Map<K, Provider<V>> map) {
+        super(map);
+    }
+
+    @Override // javax.inject.Provider
+    public Map<K, Provider<V>> get() {
+        return contributingMap();
+    }
+}

apk_decompiled/sources/dagger/internal/MembersInjectors.java

@@ -0,0 +1,24 @@
+package dagger.internal;
+
+import dagger.MembersInjector;
+
+/* loaded from: classes3.dex */
+public final class MembersInjectors {
+
+    /* loaded from: classes3.dex */
+    public enum NoOpMembersInjector implements MembersInjector<Object> {
+        INSTANCE;
+
+        @Override // dagger.MembersInjector
+        public void injectMembers(Object obj) {
+            Preconditions.checkNotNull(obj, "Cannot inject members into a null reference");
+        }
+    }
+
+    private MembersInjectors() {
+    }
+
+    public static <T> MembersInjector<T> noOp() {
+        return NoOpMembersInjector.INSTANCE;
+    }
+}

apk_decompiled/sources/dagger/internal/Preconditions.java

@@ -0,0 +1,59 @@
+package dagger.internal;
+
+/* loaded from: classes3.dex */
+public final class Preconditions {
+    private Preconditions() {
+    }
+
+    public static <T> void checkBuilderRequirement(T t2, Class<T> cls) {
+        if (t2 != null) {
+            return;
+        }
+        throw new IllegalStateException(cls.getCanonicalName() + " must be set");
+    }
+
+    public static <T> T checkNotNull(T t2) {
+        t2.getClass();
+        return t2;
+    }
+
+    public static <T> T checkNotNullFromComponent(T t2) {
+        if (t2 != null) {
+            return t2;
+        }
+        throw new NullPointerException("Cannot return null from a non-@Nullable component method");
+    }
+
+    public static <T> T checkNotNullFromProvides(T t2) {
+        if (t2 != null) {
+            return t2;
+        }
+        throw new NullPointerException("Cannot return null from a non-@Nullable @Provides method");
+    }
+
+    public static <T> T checkNotNull(T t2, String str) {
+        if (t2 != null) {
+            return t2;
+        }
+        throw new NullPointerException(str);
+    }
+
+    public static <T> T checkNotNull(T t2, String str, Object obj) {
+        String valueOf;
+        if (t2 != null) {
+            return t2;
+        }
+        if (str.contains("%s")) {
+            if (str.indexOf("%s") == str.lastIndexOf("%s")) {
+                if (obj instanceof Class) {
+                    valueOf = ((Class) obj).getCanonicalName();
+                } else {
+                    valueOf = String.valueOf(obj);
+                }
+                throw new NullPointerException(str.replace("%s", valueOf));
+            }
+            throw new IllegalArgumentException("errorMessageTemplate has more than one format specifier");
+        }
+        throw new IllegalArgumentException("errorMessageTemplate has no format specifiers");
+    }
+}

apk_decompiled/sources/dagger/internal/Provider.java

@@ -0,0 +1,5 @@
+package dagger.internal;
+
+/* loaded from: classes3.dex */
+public interface Provider<T> extends javax.inject.Provider<T> {
+}

apk_decompiled/sources/dagger/internal/ProviderOfLazy.java

@@ -0,0 +1,27 @@
+package dagger.internal;
+
+import dagger.Lazy;
+
+/* loaded from: classes3.dex */
+public final class ProviderOfLazy<T> implements Provider<Lazy<T>> {
+    static final /* synthetic */ boolean $assertionsDisabled = false;
+    private final Provider<T> provider;
+
+    private ProviderOfLazy(Provider<T> provider) {
+        this.provider = provider;
+    }
+
+    public static <T> Provider<Lazy<T>> create(Provider<T> provider) {
+        return new ProviderOfLazy((Provider) Preconditions.checkNotNull(provider));
+    }
+
+    @Deprecated
+    public static <T> Provider<Lazy<T>> create(javax.inject.Provider<T> provider) {
+        return create(Providers.asDaggerProvider(provider));
+    }
+
+    @Override // javax.inject.Provider
+    public Lazy<T> get() {
+        return DoubleCheck.lazy(this.provider);
+    }
+}

apk_decompiled/sources/dagger/internal/Providers.java

@@ -0,0 +1,17 @@
+package dagger.internal;
+
+/* loaded from: classes3.dex */
+public final class Providers {
+    private Providers() {
+    }
+
+    public static <T> Provider<T> asDaggerProvider(final javax.inject.Provider<T> provider) {
+        Preconditions.checkNotNull(provider);
+        return new Provider<T>() { // from class: dagger.internal.Providers.1
+            @Override // javax.inject.Provider
+            public T get() {
+                return (T) javax.inject.Provider.this.get();
+            }
+        };
+    }
+}

apk_decompiled/sources/dagger/internal/QualifierMetadata.java

@@ -0,0 +1,13 @@
+package dagger.internal;
+
+import java.lang.annotation.ElementType;
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+import java.lang.annotation.Target;
+
+@Target({ElementType.TYPE})
+@Retention(RetentionPolicy.CLASS)
+/* loaded from: classes3.dex */
+public @interface QualifierMetadata {
+    String[] value() default {};
+}

apk_decompiled/sources/dagger/internal/ScopeMetadata.java

@@ -0,0 +1,13 @@
+package dagger.internal;
+
+import java.lang.annotation.ElementType;
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+import java.lang.annotation.Target;
+
+@Target({ElementType.TYPE})
+@Retention(RetentionPolicy.CLASS)
+/* loaded from: classes3.dex */
+public @interface ScopeMetadata {
+    String value() default "";
+}

apk_decompiled/sources/dagger/internal/SetBuilder.java

@@ -0,0 +1,41 @@
+package dagger.internal;
+
+import java.util.ArrayList;
+import java.util.Collection;
+import java.util.Collections;
+import java.util.HashSet;
+import java.util.Iterator;
+import java.util.List;
+import java.util.Set;
+
+/* loaded from: classes3.dex */
+public final class SetBuilder<T> {
+    private static final String SET_CONTRIBUTIONS_CANNOT_BE_NULL = "Set contributions cannot be null";
+    private final List<T> contributions;
+
+    private SetBuilder(int i) {
+        this.contributions = new ArrayList(i);
+    }
+
+    public static <T> SetBuilder<T> newSetBuilder(int i) {
+        return new SetBuilder<>(i);
+    }
+
+    public SetBuilder<T> add(T t2) {
+        this.contributions.add(Preconditions.checkNotNull(t2, SET_CONTRIBUTIONS_CANNOT_BE_NULL));
+        return this;
+    }
+
+    public SetBuilder<T> addAll(Collection<? extends T> collection) {
+        Iterator<? extends T> it = collection.iterator();
+        while (it.hasNext()) {
+            Preconditions.checkNotNull(it.next(), SET_CONTRIBUTIONS_CANNOT_BE_NULL);
+        }
+        this.contributions.addAll(collection);
+        return this;
+    }
+
+    public Set<T> build() {
+        return this.contributions.isEmpty() ? Collections.EMPTY_SET : this.contributions.size() == 1 ? Collections.singleton(this.contributions.get(0)) : Collections.unmodifiableSet(new HashSet(this.contributions));
+    }
+}

apk_decompiled/sources/dagger/internal/SetFactory.java

@@ -0,0 +1,90 @@
+package dagger.internal;
+
+import java.util.ArrayList;
+import java.util.Collection;
+import java.util.Collections;
+import java.util.HashSet;
+import java.util.Iterator;
+import java.util.List;
+import java.util.Set;
+
+/* loaded from: classes3.dex */
+public final class SetFactory<T> implements Factory<Set<T>> {
+    private static final Factory<Set<Object>> EMPTY_FACTORY = InstanceFactory.create(Collections.EMPTY_SET);
+    private final List<Provider<Collection<T>>> collectionProviders;
+    private final List<Provider<T>> individualProviders;
+
+    /* loaded from: classes3.dex */
+    public static final class Builder<T> {
+        static final /* synthetic */ boolean $assertionsDisabled = false;
+        private final List<Provider<Collection<T>>> collectionProviders;
+        private final List<Provider<T>> individualProviders;
+
+        public Builder<T> addCollectionProvider(Provider<? extends Collection<? extends T>> provider) {
+            this.collectionProviders.add(provider);
+            return this;
+        }
+
+        public Builder<T> addProvider(Provider<? extends T> provider) {
+            this.individualProviders.add(provider);
+            return this;
+        }
+
+        public SetFactory<T> build() {
+            return new SetFactory<>(this.individualProviders, this.collectionProviders);
+        }
+
+        private Builder(int i, int i4) {
+            this.individualProviders = DaggerCollections.presizedList(i);
+            this.collectionProviders = DaggerCollections.presizedList(i4);
+        }
+
+        @Deprecated
+        public Builder<T> addCollectionProvider(javax.inject.Provider<? extends Collection<? extends T>> provider) {
+            return addCollectionProvider((Provider) Providers.asDaggerProvider(provider));
+        }
+
+        @Deprecated
+        public Builder<T> addProvider(javax.inject.Provider<? extends T> provider) {
+            return addProvider((Provider) Providers.asDaggerProvider(provider));
+        }
+    }
+
+    public static <T> Builder<T> builder(int i, int i4) {
+        return new Builder<>(i, i4);
+    }
+
+    public static <T> Factory<Set<T>> empty() {
+        return (Factory<Set<T>>) EMPTY_FACTORY;
+    }
+
+    private SetFactory(List<Provider<T>> list, List<Provider<Collection<T>>> list2) {
+        this.individualProviders = list;
+        this.collectionProviders = list2;
+    }
+
+    @Override // javax.inject.Provider
+    public Set<T> get() {
+        int size = this.individualProviders.size();
+        ArrayList arrayList = new ArrayList(this.collectionProviders.size());
+        int size2 = this.collectionProviders.size();
+        for (int i = 0; i < size2; i++) {
+            Collection<T> collection = this.collectionProviders.get(i).get();
+            size += collection.size();
+            arrayList.add(collection);
+        }
+        HashSet newHashSetWithExpectedSize = DaggerCollections.newHashSetWithExpectedSize(size);
+        int size3 = this.individualProviders.size();
+        for (int i4 = 0; i4 < size3; i4++) {
+            newHashSetWithExpectedSize.add(Preconditions.checkNotNull(this.individualProviders.get(i4).get()));
+        }
+        int size4 = arrayList.size();
+        for (int i5 = 0; i5 < size4; i5++) {
+            Iterator it = ((Collection) arrayList.get(i5)).iterator();
+            while (it.hasNext()) {
+                newHashSetWithExpectedSize.add(Preconditions.checkNotNull(it.next()));
+            }
+        }
+        return Collections.unmodifiableSet(newHashSetWithExpectedSize);
+    }
+}

apk_decompiled/sources/dagger/internal/SingleCheck.java

@@ -0,0 +1,37 @@
+package dagger.internal;
+
+/* loaded from: classes3.dex */
+public final class SingleCheck<T> implements Provider<T> {
+    static final /* synthetic */ boolean $assertionsDisabled = false;
+    private static final Object UNINITIALIZED = new Object();
+    private volatile Object instance = UNINITIALIZED;
+    private volatile Provider<T> provider;
+
+    private SingleCheck(Provider<T> provider) {
+        this.provider = provider;
+    }
+
+    public static <P extends Provider<T>, T> Provider<T> provider(P p) {
+        return ((p instanceof SingleCheck) || (p instanceof DoubleCheck)) ? p : new SingleCheck((Provider) Preconditions.checkNotNull(p));
+    }
+
+    @Override // javax.inject.Provider
+    public T get() {
+        T t2 = (T) this.instance;
+        if (t2 != UNINITIALIZED) {
+            return t2;
+        }
+        Provider<T> provider = this.provider;
+        if (provider == null) {
+            return (T) this.instance;
+        }
+        T t4 = provider.get();
+        this.instance = t4;
+        this.provider = null;
+        return t4;
+    }
+
+    public static <P extends javax.inject.Provider<T>, T> javax.inject.Provider<T> provider(P p) {
+        return provider(Providers.asDaggerProvider(p));
+    }
+}