Primer paso de la investigacion. Se aportan el .apk, las carpetas con el apk extraido y el apk descompilado. El archivo API_DOCUMENTATION.md es un archivo donde se anotaran los descubrimientos del funcionamiento de la API, y los .py son scripts para probar la funcionalidad de la API con los métodos que vayamos encontrando. Finalmente, los archivos .js son scripts de Frida para extraer informacion de la APP durante la ejecucion.

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));
+    }
+}