*

app/build/kspCaches/debug/backups/java/byRounds/1/com/stec/cmd/CollectFragment_GeneratedInjector.java

@@ -0,0 +1,17 @@
+package com.stec.cmd;
+
+import dagger.hilt.InstallIn;
+import dagger.hilt.android.components.FragmentComponent;
+import dagger.hilt.codegen.OriginatingElement;
+import dagger.hilt.internal.GeneratedEntryPoint;
+import javax.annotation.processing.Generated;
+
+@OriginatingElement(
+    topLevelClass = CollectFragment.class
+)
+@GeneratedEntryPoint
+@InstallIn(FragmentComponent.class)
+@Generated("dagger.hilt.android.processor.internal.androidentrypoint.InjectorEntryPointGenerator")
+public interface CollectFragment_GeneratedInjector {
+  void injectCollectFragment(CollectFragment collectFragment);
+}

app/build/kspCaches/debug/backups/java/byRounds/1/com/stec/cmd/Hilt_CollectFragment.java

@@ -0,0 +1,111 @@
+package com.stec.cmd;
+
+import android.app.Activity;
+import android.content.Context;
+import android.content.ContextWrapper;
+import android.os.Bundle;
+import android.view.LayoutInflater;
+import androidx.annotation.CallSuper;
+import androidx.annotation.MainThread;
+import androidx.lifecycle.ViewModelProvider;
+import dagger.hilt.android.flags.FragmentGetContextFix;
+import dagger.hilt.android.internal.lifecycle.DefaultViewModelFactories;
+import dagger.hilt.android.internal.managers.FragmentComponentManager;
+import dagger.hilt.internal.GeneratedComponentManagerHolder;
+import dagger.hilt.internal.Preconditions;
+import dagger.hilt.internal.UnsafeCasts;
+import java.lang.Object;
+import java.lang.Override;
+import java.lang.SuppressWarnings;
+import javax.annotation.processing.Generated;
+
+/**
+ * A generated base class to be extended by the @dagger.hilt.android.AndroidEntryPoint annotated class. If using the Gradle plugin, this is swapped as the base class via bytecode transformation.
+ */
+@Generated("dagger.hilt.android.processor.internal.androidentrypoint.FragmentGenerator")
+public abstract class Hilt_CollectFragment extends PlaceholderFragment implements GeneratedComponentManagerHolder {
+  private ContextWrapper componentContext;
+
+  private boolean disableGetContextFix;
+
+  private volatile FragmentComponentManager componentManager;
+
+  private final Object componentManagerLock = new Object();
+
+  private boolean injected = false;
+
+  @Override
+  @CallSuper
+  public void onAttach(Context context) {
+    super.onAttach(context);
+    initializeComponentContext();
+    inject();
+  }
+
+  @Override
+  @SuppressWarnings("deprecation")
+  @CallSuper
+  @MainThread
+  public void onAttach(Activity activity) {
+    super.onAttach(activity);
+    Preconditions.checkState(componentContext == null || FragmentComponentManager.findActivity(componentContext) == activity, "onAttach called multiple times with different Context! Hilt Fragments should not be retained.");
+    initializeComponentContext();
+    inject();
+  }
+
+  private void initializeComponentContext() {
+    if (componentContext == null) {
+      // Note: The LayoutInflater provided by this componentContext may be different from super Fragment's because we getting it from base context instead of cloning from the super Fragment's LayoutInflater.
+      componentContext = FragmentComponentManager.createContextWrapper(super.getContext(), this);
+      disableGetContextFix = FragmentGetContextFix.isFragmentGetContextFixDisabled(super.getContext());
+    }
+  }
+
+  @Override
+  public Context getContext() {
+    if (super.getContext() == null && !disableGetContextFix) {
+      return null;
+    }
+    initializeComponentContext();
+    return componentContext;
+  }
+
+  @Override
+  public LayoutInflater onGetLayoutInflater(Bundle savedInstanceState) {
+    LayoutInflater inflater = super.onGetLayoutInflater(savedInstanceState);
+    return inflater.cloneInContext(FragmentComponentManager.createContextWrapper(inflater, this));
+  }
+
+  @Override
+  public final Object generatedComponent() {
+    return this.componentManager().generatedComponent();
+  }
+
+  protected FragmentComponentManager createComponentManager() {
+    return new FragmentComponentManager(this);
+  }
+
+  @Override
+  public final FragmentComponentManager componentManager() {
+    if (componentManager == null) {
+      synchronized (componentManagerLock) {
+        if (componentManager == null) {
+          componentManager = createComponentManager();
+        }
+      }
+    }
+    return componentManager;
+  }
+
+  protected void inject() {
+    if (!injected) {
+      injected = true;
+      ((CollectFragment_GeneratedInjector) this.generatedComponent()).injectCollectFragment(UnsafeCasts.<CollectFragment>unsafeCast(this));
+    }
+  }
+
+  @Override
+  public ViewModelProvider.Factory getDefaultViewModelProviderFactory() {
+    return DefaultViewModelFactories.getFragmentFactory(this, super.getDefaultViewModelProviderFactory());
+  }
+}

app/build/kspCaches/debug/backups/java/byRounds/1/com/stec/cmd/Hilt_HomeFragment.java

@@ -0,0 +1,111 @@
+package com.stec.cmd;
+
+import android.app.Activity;
+import android.content.Context;
+import android.content.ContextWrapper;
+import android.os.Bundle;
+import android.view.LayoutInflater;
+import androidx.annotation.CallSuper;
+import androidx.annotation.MainThread;
+import androidx.lifecycle.ViewModelProvider;
+import dagger.hilt.android.flags.FragmentGetContextFix;
+import dagger.hilt.android.internal.lifecycle.DefaultViewModelFactories;
+import dagger.hilt.android.internal.managers.FragmentComponentManager;
+import dagger.hilt.internal.GeneratedComponentManagerHolder;
+import dagger.hilt.internal.Preconditions;
+import dagger.hilt.internal.UnsafeCasts;
+import java.lang.Object;
+import java.lang.Override;
+import java.lang.SuppressWarnings;
+import javax.annotation.processing.Generated;
+
+/**
+ * A generated base class to be extended by the @dagger.hilt.android.AndroidEntryPoint annotated class. If using the Gradle plugin, this is swapped as the base class via bytecode transformation.
+ */
+@Generated("dagger.hilt.android.processor.internal.androidentrypoint.FragmentGenerator")
+public abstract class Hilt_HomeFragment extends PlaceholderFragment implements GeneratedComponentManagerHolder {
+  private ContextWrapper componentContext;
+
+  private boolean disableGetContextFix;
+
+  private volatile FragmentComponentManager componentManager;
+
+  private final Object componentManagerLock = new Object();
+
+  private boolean injected = false;
+
+  @Override
+  @CallSuper
+  public void onAttach(Context context) {
+    super.onAttach(context);
+    initializeComponentContext();
+    inject();
+  }
+
+  @Override
+  @SuppressWarnings("deprecation")
+  @CallSuper
+  @MainThread
+  public void onAttach(Activity activity) {
+    super.onAttach(activity);
+    Preconditions.checkState(componentContext == null || FragmentComponentManager.findActivity(componentContext) == activity, "onAttach called multiple times with different Context! Hilt Fragments should not be retained.");
+    initializeComponentContext();
+    inject();
+  }
+
+  private void initializeComponentContext() {
+    if (componentContext == null) {
+      // Note: The LayoutInflater provided by this componentContext may be different from super Fragment's because we getting it from base context instead of cloning from the super Fragment's LayoutInflater.
+      componentContext = FragmentComponentManager.createContextWrapper(super.getContext(), this);
+      disableGetContextFix = FragmentGetContextFix.isFragmentGetContextFixDisabled(super.getContext());
+    }
+  }
+
+  @Override
+  public Context getContext() {
+    if (super.getContext() == null && !disableGetContextFix) {
+      return null;
+    }
+    initializeComponentContext();
+    return componentContext;
+  }
+
+  @Override
+  public LayoutInflater onGetLayoutInflater(Bundle savedInstanceState) {
+    LayoutInflater inflater = super.onGetLayoutInflater(savedInstanceState);
+    return inflater.cloneInContext(FragmentComponentManager.createContextWrapper(inflater, this));
+  }
+
+  @Override
+  public final Object generatedComponent() {
+    return this.componentManager().generatedComponent();
+  }
+
+  protected FragmentComponentManager createComponentManager() {
+    return new FragmentComponentManager(this);
+  }
+
+  @Override
+  public final FragmentComponentManager componentManager() {
+    if (componentManager == null) {
+      synchronized (componentManagerLock) {
+        if (componentManager == null) {
+          componentManager = createComponentManager();
+        }
+      }
+    }
+    return componentManager;
+  }
+
+  protected void inject() {
+    if (!injected) {
+      injected = true;
+      ((HomeFragment_GeneratedInjector) this.generatedComponent()).injectHomeFragment(UnsafeCasts.<HomeFragment>unsafeCast(this));
+    }
+  }
+
+  @Override
+  public ViewModelProvider.Factory getDefaultViewModelProviderFactory() {
+    return DefaultViewModelFactories.getFragmentFactory(this, super.getDefaultViewModelProviderFactory());
+  }
+}

app/build/kspCaches/debug/backups/java/byRounds/1/com/stec/cmd/Hilt_MainActivity.java

@@ -0,0 +1,107 @@
+package com.stec.cmd;
+
+import android.content.Context;
+import android.os.Bundle;
+import androidx.activity.contextaware.OnContextAvailableListener;
+import androidx.annotation.CallSuper;
+import androidx.appcompat.app.AppCompatActivity;
+import androidx.lifecycle.ViewModelProvider;
+import dagger.hilt.android.internal.lifecycle.DefaultViewModelFactories;
+import dagger.hilt.android.internal.managers.ActivityComponentManager;
+import dagger.hilt.android.internal.managers.SavedStateHandleHolder;
+import dagger.hilt.internal.GeneratedComponentManager;
+import dagger.hilt.internal.GeneratedComponentManagerHolder;
+import dagger.hilt.internal.UnsafeCasts;
+import java.lang.Object;
+import java.lang.Override;
+import javax.annotation.processing.Generated;
+
+/**
+ * A generated base class to be extended by the @dagger.hilt.android.AndroidEntryPoint annotated class. If using the Gradle plugin, this is swapped as the base class via bytecode transformation.
+ */
+@Generated("dagger.hilt.android.processor.internal.androidentrypoint.ActivityGenerator")
+public abstract class Hilt_MainActivity extends AppCompatActivity implements GeneratedComponentManagerHolder {
+  private SavedStateHandleHolder savedStateHandleHolder;
+
+  private volatile ActivityComponentManager componentManager;
+
+  private final Object componentManagerLock = new Object();
+
+  private boolean injected = false;
+
+  Hilt_MainActivity() {
+    super();
+    _initHiltInternal();
+  }
+
+  Hilt_MainActivity(int p0) {
+    super(p0);
+    _initHiltInternal();
+  }
+
+  private void _initHiltInternal() {
+    addOnContextAvailableListener(new OnContextAvailableListener() {
+      @Override
+      public void onContextAvailable(Context context) {
+        inject();
+      }
+    });
+  }
+
+  private void initSavedStateHandleHolder() {
+    if (getApplication() instanceof GeneratedComponentManager) {
+      savedStateHandleHolder = componentManager().getSavedStateHandleHolder();
+      if (savedStateHandleHolder.isInvalid()) {
+        savedStateHandleHolder.setExtras(getDefaultViewModelCreationExtras());
+      }
+    }
+  }
+
+  @CallSuper
+  @Override
+  protected void onCreate(Bundle savedInstanceState) {
+    super.onCreate(savedInstanceState);
+    initSavedStateHandleHolder();
+  }
+
+  @Override
+  protected void onDestroy() {
+    super.onDestroy();
+    if (savedStateHandleHolder != null) {
+      savedStateHandleHolder.clear();
+    }
+  }
+
+  @Override
+  public final Object generatedComponent() {
+    return this.componentManager().generatedComponent();
+  }
+
+  protected ActivityComponentManager createComponentManager() {
+    return new ActivityComponentManager(this);
+  }
+
+  @Override
+  public final ActivityComponentManager componentManager() {
+    if (componentManager == null) {
+      synchronized (componentManagerLock) {
+        if (componentManager == null) {
+          componentManager = createComponentManager();
+        }
+      }
+    }
+    return componentManager;
+  }
+
+  protected void inject() {
+    if (!injected) {
+      injected = true;
+      ((MainActivity_GeneratedInjector) this.generatedComponent()).injectMainActivity(UnsafeCasts.<MainActivity>unsafeCast(this));
+    }
+  }
+
+  @Override
+  public ViewModelProvider.Factory getDefaultViewModelProviderFactory() {
+    return DefaultViewModelFactories.getActivityFactory(this, super.getDefaultViewModelProviderFactory());
+  }
+}

app/build/kspCaches/debug/backups/java/byRounds/1/com/stec/cmd/Hilt_StatsFragment.java

@@ -0,0 +1,111 @@
+package com.stec.cmd;
+
+import android.app.Activity;
+import android.content.Context;
+import android.content.ContextWrapper;
+import android.os.Bundle;
+import android.view.LayoutInflater;
+import androidx.annotation.CallSuper;
+import androidx.annotation.MainThread;
+import androidx.lifecycle.ViewModelProvider;
+import dagger.hilt.android.flags.FragmentGetContextFix;
+import dagger.hilt.android.internal.lifecycle.DefaultViewModelFactories;
+import dagger.hilt.android.internal.managers.FragmentComponentManager;
+import dagger.hilt.internal.GeneratedComponentManagerHolder;
+import dagger.hilt.internal.Preconditions;
+import dagger.hilt.internal.UnsafeCasts;
+import java.lang.Object;
+import java.lang.Override;
+import java.lang.SuppressWarnings;
+import javax.annotation.processing.Generated;
+
+/**
+ * A generated base class to be extended by the @dagger.hilt.android.AndroidEntryPoint annotated class. If using the Gradle plugin, this is swapped as the base class via bytecode transformation.
+ */
+@Generated("dagger.hilt.android.processor.internal.androidentrypoint.FragmentGenerator")
+public abstract class Hilt_StatsFragment extends PlaceholderFragment implements GeneratedComponentManagerHolder {
+  private ContextWrapper componentContext;
+
+  private boolean disableGetContextFix;
+
+  private volatile FragmentComponentManager componentManager;
+
+  private final Object componentManagerLock = new Object();
+
+  private boolean injected = false;
+
+  @Override
+  @CallSuper
+  public void onAttach(Context context) {
+    super.onAttach(context);
+    initializeComponentContext();
+    inject();
+  }
+
+  @Override
+  @SuppressWarnings("deprecation")
+  @CallSuper
+  @MainThread
+  public void onAttach(Activity activity) {
+    super.onAttach(activity);
+    Preconditions.checkState(componentContext == null || FragmentComponentManager.findActivity(componentContext) == activity, "onAttach called multiple times with different Context! Hilt Fragments should not be retained.");
+    initializeComponentContext();
+    inject();
+  }
+
+  private void initializeComponentContext() {
+    if (componentContext == null) {
+      // Note: The LayoutInflater provided by this componentContext may be different from super Fragment's because we getting it from base context instead of cloning from the super Fragment's LayoutInflater.
+      componentContext = FragmentComponentManager.createContextWrapper(super.getContext(), this);
+      disableGetContextFix = FragmentGetContextFix.isFragmentGetContextFixDisabled(super.getContext());
+    }
+  }
+
+  @Override
+  public Context getContext() {
+    if (super.getContext() == null && !disableGetContextFix) {
+      return null;
+    }
+    initializeComponentContext();
+    return componentContext;
+  }
+
+  @Override
+  public LayoutInflater onGetLayoutInflater(Bundle savedInstanceState) {
+    LayoutInflater inflater = super.onGetLayoutInflater(savedInstanceState);
+    return inflater.cloneInContext(FragmentComponentManager.createContextWrapper(inflater, this));
+  }
+
+  @Override
+  public final Object generatedComponent() {
+    return this.componentManager().generatedComponent();
+  }
+
+  protected FragmentComponentManager createComponentManager() {
+    return new FragmentComponentManager(this);
+  }
+
+  @Override
+  public final FragmentComponentManager componentManager() {
+    if (componentManager == null) {
+      synchronized (componentManagerLock) {
+        if (componentManager == null) {
+          componentManager = createComponentManager();
+        }
+      }
+    }
+    return componentManager;
+  }
+
+  protected void inject() {
+    if (!injected) {
+      injected = true;
+      ((StatsFragment_GeneratedInjector) this.generatedComponent()).injectStatsFragment(UnsafeCasts.<StatsFragment>unsafeCast(this));
+    }
+  }
+
+  @Override
+  public ViewModelProvider.Factory getDefaultViewModelProviderFactory() {
+    return DefaultViewModelFactories.getFragmentFactory(this, super.getDefaultViewModelProviderFactory());
+  }
+}

app/build/kspCaches/debug/backups/java/byRounds/1/com/stec/cmd/Hilt_TaskFragment.java

@@ -0,0 +1,111 @@
+package com.stec.cmd;
+
+import android.app.Activity;
+import android.content.Context;
+import android.content.ContextWrapper;
+import android.os.Bundle;
+import android.view.LayoutInflater;
+import androidx.annotation.CallSuper;
+import androidx.annotation.MainThread;
+import androidx.lifecycle.ViewModelProvider;
+import dagger.hilt.android.flags.FragmentGetContextFix;
+import dagger.hilt.android.internal.lifecycle.DefaultViewModelFactories;
+import dagger.hilt.android.internal.managers.FragmentComponentManager;
+import dagger.hilt.internal.GeneratedComponentManagerHolder;
+import dagger.hilt.internal.Preconditions;
+import dagger.hilt.internal.UnsafeCasts;
+import java.lang.Object;
+import java.lang.Override;
+import java.lang.SuppressWarnings;
+import javax.annotation.processing.Generated;
+
+/**
+ * A generated base class to be extended by the @dagger.hilt.android.AndroidEntryPoint annotated class. If using the Gradle plugin, this is swapped as the base class via bytecode transformation.
+ */
+@Generated("dagger.hilt.android.processor.internal.androidentrypoint.FragmentGenerator")
+public abstract class Hilt_TaskFragment extends PlaceholderFragment implements GeneratedComponentManagerHolder {
+  private ContextWrapper componentContext;
+
+  private boolean disableGetContextFix;
+
+  private volatile FragmentComponentManager componentManager;
+
+  private final Object componentManagerLock = new Object();
+
+  private boolean injected = false;
+
+  @Override
+  @CallSuper
+  public void onAttach(Context context) {
+    super.onAttach(context);
+    initializeComponentContext();
+    inject();
+  }
+
+  @Override
+  @SuppressWarnings("deprecation")
+  @CallSuper
+  @MainThread
+  public void onAttach(Activity activity) {
+    super.onAttach(activity);
+    Preconditions.checkState(componentContext == null || FragmentComponentManager.findActivity(componentContext) == activity, "onAttach called multiple times with different Context! Hilt Fragments should not be retained.");
+    initializeComponentContext();
+    inject();
+  }
+
+  private void initializeComponentContext() {
+    if (componentContext == null) {
+      // Note: The LayoutInflater provided by this componentContext may be different from super Fragment's because we getting it from base context instead of cloning from the super Fragment's LayoutInflater.
+      componentContext = FragmentComponentManager.createContextWrapper(super.getContext(), this);
+      disableGetContextFix = FragmentGetContextFix.isFragmentGetContextFixDisabled(super.getContext());
+    }
+  }
+
+  @Override
+  public Context getContext() {
+    if (super.getContext() == null && !disableGetContextFix) {
+      return null;
+    }
+    initializeComponentContext();
+    return componentContext;
+  }
+
+  @Override
+  public LayoutInflater onGetLayoutInflater(Bundle savedInstanceState) {
+    LayoutInflater inflater = super.onGetLayoutInflater(savedInstanceState);
+    return inflater.cloneInContext(FragmentComponentManager.createContextWrapper(inflater, this));
+  }
+
+  @Override
+  public final Object generatedComponent() {
+    return this.componentManager().generatedComponent();
+  }
+
+  protected FragmentComponentManager createComponentManager() {
+    return new FragmentComponentManager(this);
+  }
+
+  @Override
+  public final FragmentComponentManager componentManager() {
+    if (componentManager == null) {
+      synchronized (componentManagerLock) {
+        if (componentManager == null) {
+          componentManager = createComponentManager();
+        }
+      }
+    }
+    return componentManager;
+  }
+
+  protected void inject() {
+    if (!injected) {
+      injected = true;
+      ((TaskFragment_GeneratedInjector) this.generatedComponent()).injectTaskFragment(UnsafeCasts.<TaskFragment>unsafeCast(this));
+    }
+  }
+
+  @Override
+  public ViewModelProvider.Factory getDefaultViewModelProviderFactory() {
+    return DefaultViewModelFactories.getFragmentFactory(this, super.getDefaultViewModelProviderFactory());
+  }
+}

app/build/kspCaches/debug/backups/java/byRounds/1/com/stec/cmd/HomeFragment_GeneratedInjector.java

@@ -0,0 +1,17 @@
+package com.stec.cmd;
+
+import dagger.hilt.InstallIn;
+import dagger.hilt.android.components.FragmentComponent;
+import dagger.hilt.codegen.OriginatingElement;
+import dagger.hilt.internal.GeneratedEntryPoint;
+import javax.annotation.processing.Generated;
+
+@OriginatingElement(
+    topLevelClass = HomeFragment.class
+)
+@GeneratedEntryPoint
+@InstallIn(FragmentComponent.class)
+@Generated("dagger.hilt.android.processor.internal.androidentrypoint.InjectorEntryPointGenerator")
+public interface HomeFragment_GeneratedInjector {
+  void injectHomeFragment(HomeFragment homeFragment);
+}

app/build/kspCaches/debug/backups/java/byRounds/1/com/stec/cmd/MainActivity_GeneratedInjector.java

@@ -0,0 +1,17 @@
+package com.stec.cmd;
+
+import dagger.hilt.InstallIn;
+import dagger.hilt.android.components.ActivityComponent;
+import dagger.hilt.codegen.OriginatingElement;
+import dagger.hilt.internal.GeneratedEntryPoint;
+import javax.annotation.processing.Generated;
+
+@OriginatingElement(
+    topLevelClass = MainActivity.class
+)
+@GeneratedEntryPoint
+@InstallIn(ActivityComponent.class)
+@Generated("dagger.hilt.android.processor.internal.androidentrypoint.InjectorEntryPointGenerator")
+public interface MainActivity_GeneratedInjector {
+  void injectMainActivity(MainActivity mainActivity);
+}

app/build/kspCaches/debug/backups/java/byRounds/1/com/stec/cmd/StatsFragment_GeneratedInjector.java

@@ -0,0 +1,17 @@
+package com.stec.cmd;
+
+import dagger.hilt.InstallIn;
+import dagger.hilt.android.components.FragmentComponent;
+import dagger.hilt.codegen.OriginatingElement;
+import dagger.hilt.internal.GeneratedEntryPoint;
+import javax.annotation.processing.Generated;
+
+@OriginatingElement(
+    topLevelClass = StatsFragment.class
+)
+@GeneratedEntryPoint
+@InstallIn(FragmentComponent.class)
+@Generated("dagger.hilt.android.processor.internal.androidentrypoint.InjectorEntryPointGenerator")
+public interface StatsFragment_GeneratedInjector {
+  void injectStatsFragment(StatsFragment statsFragment);
+}

app/build/kspCaches/debug/backups/java/byRounds/1/com/stec/cmd/SteCmdApplication_GeneratedInjector.java

@@ -0,0 +1,17 @@
+package com.stec.cmd;
+
+import dagger.hilt.InstallIn;
+import dagger.hilt.codegen.OriginatingElement;
+import dagger.hilt.components.SingletonComponent;
+import dagger.hilt.internal.GeneratedEntryPoint;
+import javax.annotation.processing.Generated;
+
+@OriginatingElement(
+    topLevelClass = SteCmdApplication.class
+)
+@GeneratedEntryPoint
+@InstallIn(SingletonComponent.class)
+@Generated("dagger.hilt.android.processor.internal.androidentrypoint.InjectorEntryPointGenerator")
+public interface SteCmdApplication_GeneratedInjector {
+  void injectSteCmdApplication(SteCmdApplication steCmdApplication);
+}

app/build/kspCaches/debug/backups/java/byRounds/1/com/stec/cmd/TaskFragment_GeneratedInjector.java

@@ -0,0 +1,17 @@
+package com.stec.cmd;
+
+import dagger.hilt.InstallIn;
+import dagger.hilt.android.components.FragmentComponent;
+import dagger.hilt.codegen.OriginatingElement;
+import dagger.hilt.internal.GeneratedEntryPoint;
+import javax.annotation.processing.Generated;
+
+@OriginatingElement(
+    topLevelClass = TaskFragment.class
+)
+@GeneratedEntryPoint
+@InstallIn(FragmentComponent.class)
+@Generated("dagger.hilt.android.processor.internal.androidentrypoint.InjectorEntryPointGenerator")
+public interface TaskFragment_GeneratedInjector {
+  void injectTaskFragment(TaskFragment taskFragment);
+}

app/build/kspCaches/debug/backups/java/byRounds/1/com/stec/cmd/config/AppModule_ProvideConfigDataStoreFactory.java

@@ -0,0 +1,48 @@
+package com.stec.cmd.config;
+
+import android.content.Context;
+import androidx.datastore.core.DataStore;
+import androidx.datastore.preferences.core.Preferences;
+import dagger.internal.DaggerGenerated;
+import dagger.internal.Factory;
+import dagger.internal.Preconditions;
+import dagger.internal.QualifierMetadata;
+import dagger.internal.ScopeMetadata;
+import javax.annotation.processing.Generated;
+import javax.inject.Provider;
+
+@ScopeMetadata("javax.inject.Singleton")
+@QualifierMetadata("dagger.hilt.android.qualifiers.ApplicationContext")
+@DaggerGenerated
+@Generated(
+    value = "dagger.internal.codegen.ComponentProcessor",
+    comments = "https://dagger.dev"
+)
+@SuppressWarnings({
+    "unchecked",
+    "rawtypes",
+    "KotlinInternal",
+    "KotlinInternalInJava",
+    "cast",
+    "deprecation"
+})
+public final class AppModule_ProvideConfigDataStoreFactory implements Factory<DataStore<Preferences>> {
+  private final Provider<Context> contextProvider;
+
+  public AppModule_ProvideConfigDataStoreFactory(Provider<Context> contextProvider) {
+    this.contextProvider = contextProvider;
+  }
+
+  @Override
+  public DataStore<Preferences> get() {
+    return provideConfigDataStore(contextProvider.get());
+  }
+
+  public static AppModule_ProvideConfigDataStoreFactory create(Provider<Context> contextProvider) {
+    return new AppModule_ProvideConfigDataStoreFactory(contextProvider);
+  }
+
+  public static DataStore<Preferences> provideConfigDataStore(Context context) {
+    return Preconditions.checkNotNullFromProvides(AppModule.INSTANCE.provideConfigDataStore(context));
+  }
+}

app/build/kspCaches/debug/backups/java/byRounds/1/com/stec/cmd/config/ConfigRepository_Factory.java

@@ -0,0 +1,47 @@
+package com.stec.cmd.config;
+
+import androidx.datastore.core.DataStore;
+import androidx.datastore.preferences.core.Preferences;
+import dagger.internal.DaggerGenerated;
+import dagger.internal.Factory;
+import dagger.internal.QualifierMetadata;
+import dagger.internal.ScopeMetadata;
+import javax.annotation.processing.Generated;
+import javax.inject.Provider;
+
+@ScopeMetadata("javax.inject.Singleton")
+@QualifierMetadata
+@DaggerGenerated
+@Generated(
+    value = "dagger.internal.codegen.ComponentProcessor",
+    comments = "https://dagger.dev"
+)
+@SuppressWarnings({
+    "unchecked",
+    "rawtypes",
+    "KotlinInternal",
+    "KotlinInternalInJava",
+    "cast",
+    "deprecation"
+})
+public final class ConfigRepository_Factory implements Factory<ConfigRepository> {
+  private final Provider<DataStore<Preferences>> dataStoreProvider;
+
+  public ConfigRepository_Factory(Provider<DataStore<Preferences>> dataStoreProvider) {
+    this.dataStoreProvider = dataStoreProvider;
+  }
+
+  @Override
+  public ConfigRepository get() {
+    return newInstance(dataStoreProvider.get());
+  }
+
+  public static ConfigRepository_Factory create(
+      Provider<DataStore<Preferences>> dataStoreProvider) {
+    return new ConfigRepository_Factory(dataStoreProvider);
+  }
+
+  public static ConfigRepository newInstance(DataStore<Preferences> dataStore) {
+    return new ConfigRepository(dataStore);
+  }
+}

app/build/kspCaches/debug/backups/java/byRounds/1/com/stec/cmd/feature/mine/ChangePasswordFragment_GeneratedInjector.java

@@ -0,0 +1,17 @@
+package com.stec.cmd.feature.mine;
+
+import dagger.hilt.InstallIn;
+import dagger.hilt.android.components.FragmentComponent;
+import dagger.hilt.codegen.OriginatingElement;
+import dagger.hilt.internal.GeneratedEntryPoint;
+import javax.annotation.processing.Generated;
+
+@OriginatingElement(
+    topLevelClass = ChangePasswordFragment.class
+)
+@GeneratedEntryPoint
+@InstallIn(FragmentComponent.class)
+@Generated("dagger.hilt.android.processor.internal.androidentrypoint.InjectorEntryPointGenerator")
+public interface ChangePasswordFragment_GeneratedInjector {
+  void injectChangePasswordFragment(ChangePasswordFragment changePasswordFragment);
+}

app/build/kspCaches/debug/backups/java/byRounds/1/com/stec/cmd/feature/mine/ChangePasswordViewModel_Factory.java

@@ -0,0 +1,46 @@
+package com.stec.cmd.feature.mine;
+
+import com.stec.cmd.session.SessionRepository;
+import dagger.internal.DaggerGenerated;
+import dagger.internal.Factory;
+import dagger.internal.QualifierMetadata;
+import dagger.internal.ScopeMetadata;
+import javax.annotation.processing.Generated;
+import javax.inject.Provider;
+
+@ScopeMetadata
+@QualifierMetadata
+@DaggerGenerated
+@Generated(
+    value = "dagger.internal.codegen.ComponentProcessor",
+    comments = "https://dagger.dev"
+)
+@SuppressWarnings({
+    "unchecked",
+    "rawtypes",
+    "KotlinInternal",
+    "KotlinInternalInJava",
+    "cast",
+    "deprecation"
+})
+public final class ChangePasswordViewModel_Factory implements Factory<ChangePasswordViewModel> {
+  private final Provider<SessionRepository> sessionRepositoryProvider;
+
+  public ChangePasswordViewModel_Factory(Provider<SessionRepository> sessionRepositoryProvider) {
+    this.sessionRepositoryProvider = sessionRepositoryProvider;
+  }
+
+  @Override
+  public ChangePasswordViewModel get() {
+    return newInstance(sessionRepositoryProvider.get());
+  }
+
+  public static ChangePasswordViewModel_Factory create(
+      Provider<SessionRepository> sessionRepositoryProvider) {
+    return new ChangePasswordViewModel_Factory(sessionRepositoryProvider);
+  }
+
+  public static ChangePasswordViewModel newInstance(SessionRepository sessionRepository) {
+    return new ChangePasswordViewModel(sessionRepository);
+  }
+}

app/build/kspCaches/debug/backups/java/byRounds/1/com/stec/cmd/feature/mine/ChangePasswordViewModel_HiltModules.java

@@ -0,0 +1,51 @@
+package com.stec.cmd.feature.mine;
+
+import androidx.lifecycle.ViewModel;
+import dagger.Binds;
+import dagger.Module;
+import dagger.Provides;
+import dagger.hilt.InstallIn;
+import dagger.hilt.android.components.ActivityRetainedComponent;
+import dagger.hilt.android.components.ViewModelComponent;
+import dagger.hilt.android.internal.lifecycle.HiltViewModelMap;
+import dagger.hilt.codegen.OriginatingElement;
+import dagger.multibindings.IntoMap;
+import dagger.multibindings.LazyClassKey;
+import javax.annotation.processing.Generated;
+
+@Generated("dagger.hilt.android.processor.internal.viewmodel.ViewModelProcessor")
+@OriginatingElement(
+    topLevelClass = ChangePasswordViewModel.class
+)
+public final class ChangePasswordViewModel_HiltModules {
+  private ChangePasswordViewModel_HiltModules() {
+  }
+
+  @Module
+  @InstallIn(ViewModelComponent.class)
+  public abstract static class BindsModule {
+    private BindsModule() {
+    }
+
+    @Binds
+    @IntoMap
+    @LazyClassKey(ChangePasswordViewModel.class)
+    @HiltViewModelMap
+    public abstract ViewModel binds(ChangePasswordViewModel vm);
+  }
+
+  @Module
+  @InstallIn(ActivityRetainedComponent.class)
+  public static final class KeyModule {
+    private KeyModule() {
+    }
+
+    @Provides
+    @IntoMap
+    @LazyClassKey(ChangePasswordViewModel.class)
+    @HiltViewModelMap.KeySet
+    public static boolean provide() {
+      return true;
+    }
+  }
+}

app/build/kspCaches/debug/backups/java/byRounds/1/com/stec/cmd/feature/mine/ConfigFragment_GeneratedInjector.java

@@ -0,0 +1,17 @@
+package com.stec.cmd.feature.mine;
+
+import dagger.hilt.InstallIn;
+import dagger.hilt.android.components.FragmentComponent;
+import dagger.hilt.codegen.OriginatingElement;
+import dagger.hilt.internal.GeneratedEntryPoint;
+import javax.annotation.processing.Generated;
+
+@OriginatingElement(
+    topLevelClass = ConfigFragment.class
+)
+@GeneratedEntryPoint
+@InstallIn(FragmentComponent.class)
+@Generated("dagger.hilt.android.processor.internal.androidentrypoint.InjectorEntryPointGenerator")
+public interface ConfigFragment_GeneratedInjector {
+  void injectConfigFragment(ConfigFragment configFragment);
+}

app/build/kspCaches/debug/backups/java/byRounds/1/com/stec/cmd/feature/mine/ConfigViewModel_Factory.java

@@ -0,0 +1,46 @@
+package com.stec.cmd.feature.mine;
+
+import com.stec.cmd.config.ConfigRepository;
+import dagger.internal.DaggerGenerated;
+import dagger.internal.Factory;
+import dagger.internal.QualifierMetadata;
+import dagger.internal.ScopeMetadata;
+import javax.annotation.processing.Generated;
+import javax.inject.Provider;
+
+@ScopeMetadata
+@QualifierMetadata
+@DaggerGenerated
+@Generated(
+    value = "dagger.internal.codegen.ComponentProcessor",
+    comments = "https://dagger.dev"
+)
+@SuppressWarnings({
+    "unchecked",
+    "rawtypes",
+    "KotlinInternal",
+    "KotlinInternalInJava",
+    "cast",
+    "deprecation"
+})
+public final class ConfigViewModel_Factory implements Factory<ConfigViewModel> {
+  private final Provider<ConfigRepository> configRepositoryProvider;
+
+  public ConfigViewModel_Factory(Provider<ConfigRepository> configRepositoryProvider) {
+    this.configRepositoryProvider = configRepositoryProvider;
+  }
+
+  @Override
+  public ConfigViewModel get() {
+    return newInstance(configRepositoryProvider.get());
+  }
+
+  public static ConfigViewModel_Factory create(
+      Provider<ConfigRepository> configRepositoryProvider) {
+    return new ConfigViewModel_Factory(configRepositoryProvider);
+  }
+
+  public static ConfigViewModel newInstance(ConfigRepository configRepository) {
+    return new ConfigViewModel(configRepository);
+  }
+}

app/build/kspCaches/debug/backups/java/byRounds/1/com/stec/cmd/feature/mine/ConfigViewModel_HiltModules.java

@@ -0,0 +1,51 @@
+package com.stec.cmd.feature.mine;
+
+import androidx.lifecycle.ViewModel;
+import dagger.Binds;
+import dagger.Module;
+import dagger.Provides;
+import dagger.hilt.InstallIn;
+import dagger.hilt.android.components.ActivityRetainedComponent;
+import dagger.hilt.android.components.ViewModelComponent;
+import dagger.hilt.android.internal.lifecycle.HiltViewModelMap;
+import dagger.hilt.codegen.OriginatingElement;
+import dagger.multibindings.IntoMap;
+import dagger.multibindings.LazyClassKey;
+import javax.annotation.processing.Generated;
+
+@Generated("dagger.hilt.android.processor.internal.viewmodel.ViewModelProcessor")
+@OriginatingElement(
+    topLevelClass = ConfigViewModel.class
+)
+public final class ConfigViewModel_HiltModules {
+  private ConfigViewModel_HiltModules() {
+  }
+
+  @Module
+  @InstallIn(ViewModelComponent.class)
+  public abstract static class BindsModule {
+    private BindsModule() {
+    }
+
+    @Binds
+    @IntoMap
+    @LazyClassKey(ConfigViewModel.class)
+    @HiltViewModelMap
+    public abstract ViewModel binds(ConfigViewModel vm);
+  }
+
+  @Module
+  @InstallIn(ActivityRetainedComponent.class)
+  public static final class KeyModule {
+    private KeyModule() {
+    }
+
+    @Provides
+    @IntoMap
+    @LazyClassKey(ConfigViewModel.class)
+    @HiltViewModelMap.KeySet
+    public static boolean provide() {
+      return true;
+    }
+  }
+}

app/build/kspCaches/debug/backups/java/byRounds/1/com/stec/cmd/feature/mine/Hilt_ChangePasswordFragment.java

@@ -0,0 +1,120 @@
+package com.stec.cmd.feature.mine;
+
+import android.app.Activity;
+import android.content.Context;
+import android.content.ContextWrapper;
+import android.os.Bundle;
+import android.view.LayoutInflater;
+import androidx.annotation.CallSuper;
+import androidx.annotation.MainThread;
+import androidx.fragment.app.Fragment;
+import androidx.lifecycle.ViewModelProvider;
+import dagger.hilt.android.flags.FragmentGetContextFix;
+import dagger.hilt.android.internal.lifecycle.DefaultViewModelFactories;
+import dagger.hilt.android.internal.managers.FragmentComponentManager;
+import dagger.hilt.internal.GeneratedComponentManagerHolder;
+import dagger.hilt.internal.Preconditions;
+import dagger.hilt.internal.UnsafeCasts;
+import java.lang.Object;
+import java.lang.Override;
+import java.lang.SuppressWarnings;
+import javax.annotation.processing.Generated;
+
+/**
+ * A generated base class to be extended by the @dagger.hilt.android.AndroidEntryPoint annotated class. If using the Gradle plugin, this is swapped as the base class via bytecode transformation.
+ */
+@Generated("dagger.hilt.android.processor.internal.androidentrypoint.FragmentGenerator")
+public abstract class Hilt_ChangePasswordFragment extends Fragment implements GeneratedComponentManagerHolder {
+  private ContextWrapper componentContext;
+
+  private boolean disableGetContextFix;
+
+  private volatile FragmentComponentManager componentManager;
+
+  private final Object componentManagerLock = new Object();
+
+  private boolean injected = false;
+
+  Hilt_ChangePasswordFragment() {
+    super();
+  }
+
+  Hilt_ChangePasswordFragment(int p0) {
+    super(p0);
+  }
+
+  @Override
+  @CallSuper
+  public void onAttach(Context context) {
+    super.onAttach(context);
+    initializeComponentContext();
+    inject();
+  }
+
+  @Override
+  @SuppressWarnings("deprecation")
+  @CallSuper
+  @MainThread
+  public void onAttach(Activity activity) {
+    super.onAttach(activity);
+    Preconditions.checkState(componentContext == null || FragmentComponentManager.findActivity(componentContext) == activity, "onAttach called multiple times with different Context! Hilt Fragments should not be retained.");
+    initializeComponentContext();
+    inject();
+  }
+
+  private void initializeComponentContext() {
+    if (componentContext == null) {
+      // Note: The LayoutInflater provided by this componentContext may be different from super Fragment's because we getting it from base context instead of cloning from the super Fragment's LayoutInflater.
+      componentContext = FragmentComponentManager.createContextWrapper(super.getContext(), this);
+      disableGetContextFix = FragmentGetContextFix.isFragmentGetContextFixDisabled(super.getContext());
+    }
+  }
+
+  @Override
+  public Context getContext() {
+    if (super.getContext() == null && !disableGetContextFix) {
+      return null;
+    }
+    initializeComponentContext();
+    return componentContext;
+  }
+
+  @Override
+  public LayoutInflater onGetLayoutInflater(Bundle savedInstanceState) {
+    LayoutInflater inflater = super.onGetLayoutInflater(savedInstanceState);
+    return inflater.cloneInContext(FragmentComponentManager.createContextWrapper(inflater, this));
+  }
+
+  @Override
+  public final Object generatedComponent() {
+    return this.componentManager().generatedComponent();
+  }
+
+  protected FragmentComponentManager createComponentManager() {
+    return new FragmentComponentManager(this);
+  }
+
+  @Override
+  public final FragmentComponentManager componentManager() {
+    if (componentManager == null) {
+      synchronized (componentManagerLock) {
+        if (componentManager == null) {
+          componentManager = createComponentManager();
+        }
+      }
+    }
+    return componentManager;
+  }
+
+  protected void inject() {
+    if (!injected) {
+      injected = true;
+      ((ChangePasswordFragment_GeneratedInjector) this.generatedComponent()).injectChangePasswordFragment(UnsafeCasts.<ChangePasswordFragment>unsafeCast(this));
+    }
+  }
+
+  @Override
+  public ViewModelProvider.Factory getDefaultViewModelProviderFactory() {
+    return DefaultViewModelFactories.getFragmentFactory(this, super.getDefaultViewModelProviderFactory());
+  }
+}

app/build/kspCaches/debug/backups/java/byRounds/1/com/stec/cmd/feature/mine/Hilt_ConfigFragment.java

@@ -0,0 +1,120 @@
+package com.stec.cmd.feature.mine;
+
+import android.app.Activity;
+import android.content.Context;
+import android.content.ContextWrapper;
+import android.os.Bundle;
+import android.view.LayoutInflater;
+import androidx.annotation.CallSuper;
+import androidx.annotation.MainThread;
+import androidx.fragment.app.Fragment;
+import androidx.lifecycle.ViewModelProvider;
+import dagger.hilt.android.flags.FragmentGetContextFix;
+import dagger.hilt.android.internal.lifecycle.DefaultViewModelFactories;
+import dagger.hilt.android.internal.managers.FragmentComponentManager;
+import dagger.hilt.internal.GeneratedComponentManagerHolder;
+import dagger.hilt.internal.Preconditions;
+import dagger.hilt.internal.UnsafeCasts;
+import java.lang.Object;
+import java.lang.Override;
+import java.lang.SuppressWarnings;
+import javax.annotation.processing.Generated;
+
+/**
+ * A generated base class to be extended by the @dagger.hilt.android.AndroidEntryPoint annotated class. If using the Gradle plugin, this is swapped as the base class via bytecode transformation.
+ */
+@Generated("dagger.hilt.android.processor.internal.androidentrypoint.FragmentGenerator")
+public abstract class Hilt_ConfigFragment extends Fragment implements GeneratedComponentManagerHolder {
+  private ContextWrapper componentContext;
+
+  private boolean disableGetContextFix;
+
+  private volatile FragmentComponentManager componentManager;
+
+  private final Object componentManagerLock = new Object();
+
+  private boolean injected = false;
+
+  Hilt_ConfigFragment() {
+    super();
+  }
+
+  Hilt_ConfigFragment(int p0) {
+    super(p0);
+  }
+
+  @Override
+  @CallSuper
+  public void onAttach(Context context) {
+    super.onAttach(context);
+    initializeComponentContext();
+    inject();
+  }
+
+  @Override
+  @SuppressWarnings("deprecation")
+  @CallSuper
+  @MainThread
+  public void onAttach(Activity activity) {
+    super.onAttach(activity);
+    Preconditions.checkState(componentContext == null || FragmentComponentManager.findActivity(componentContext) == activity, "onAttach called multiple times with different Context! Hilt Fragments should not be retained.");
+    initializeComponentContext();
+    inject();
+  }
+
+  private void initializeComponentContext() {
+    if (componentContext == null) {
+      // Note: The LayoutInflater provided by this componentContext may be different from super Fragment's because we getting it from base context instead of cloning from the super Fragment's LayoutInflater.
+      componentContext = FragmentComponentManager.createContextWrapper(super.getContext(), this);
+      disableGetContextFix = FragmentGetContextFix.isFragmentGetContextFixDisabled(super.getContext());
+    }
+  }
+
+  @Override
+  public Context getContext() {
+    if (super.getContext() == null && !disableGetContextFix) {
+      return null;
+    }
+    initializeComponentContext();
+    return componentContext;
+  }
+
+  @Override
+  public LayoutInflater onGetLayoutInflater(Bundle savedInstanceState) {
+    LayoutInflater inflater = super.onGetLayoutInflater(savedInstanceState);
+    return inflater.cloneInContext(FragmentComponentManager.createContextWrapper(inflater, this));
+  }
+
+  @Override
+  public final Object generatedComponent() {
+    return this.componentManager().generatedComponent();
+  }
+
+  protected FragmentComponentManager createComponentManager() {
+    return new FragmentComponentManager(this);
+  }
+
+  @Override
+  public final FragmentComponentManager componentManager() {
+    if (componentManager == null) {
+      synchronized (componentManagerLock) {
+        if (componentManager == null) {
+          componentManager = createComponentManager();
+        }
+      }
+    }
+    return componentManager;
+  }
+
+  protected void inject() {
+    if (!injected) {
+      injected = true;
+      ((ConfigFragment_GeneratedInjector) this.generatedComponent()).injectConfigFragment(UnsafeCasts.<ConfigFragment>unsafeCast(this));
+    }
+  }
+
+  @Override
+  public ViewModelProvider.Factory getDefaultViewModelProviderFactory() {
+    return DefaultViewModelFactories.getFragmentFactory(this, super.getDefaultViewModelProviderFactory());
+  }
+}

app/build/kspCaches/debug/backups/java/byRounds/1/com/stec/cmd/feature/mine/Hilt_LoginFragment.java

@@ -0,0 +1,120 @@
+package com.stec.cmd.feature.mine;
+
+import android.app.Activity;
+import android.content.Context;
+import android.content.ContextWrapper;
+import android.os.Bundle;
+import android.view.LayoutInflater;
+import androidx.annotation.CallSuper;
+import androidx.annotation.MainThread;
+import androidx.fragment.app.Fragment;
+import androidx.lifecycle.ViewModelProvider;
+import dagger.hilt.android.flags.FragmentGetContextFix;
+import dagger.hilt.android.internal.lifecycle.DefaultViewModelFactories;
+import dagger.hilt.android.internal.managers.FragmentComponentManager;
+import dagger.hilt.internal.GeneratedComponentManagerHolder;
+import dagger.hilt.internal.Preconditions;
+import dagger.hilt.internal.UnsafeCasts;
+import java.lang.Object;
+import java.lang.Override;
+import java.lang.SuppressWarnings;
+import javax.annotation.processing.Generated;
+
+/**
+ * A generated base class to be extended by the @dagger.hilt.android.AndroidEntryPoint annotated class. If using the Gradle plugin, this is swapped as the base class via bytecode transformation.
+ */
+@Generated("dagger.hilt.android.processor.internal.androidentrypoint.FragmentGenerator")
+public abstract class Hilt_LoginFragment extends Fragment implements GeneratedComponentManagerHolder {
+  private ContextWrapper componentContext;
+
+  private boolean disableGetContextFix;
+
+  private volatile FragmentComponentManager componentManager;
+
+  private final Object componentManagerLock = new Object();
+
+  private boolean injected = false;
+
+  Hilt_LoginFragment() {
+    super();
+  }
+
+  Hilt_LoginFragment(int p0) {
+    super(p0);
+  }
+
+  @Override
+  @CallSuper
+  public void onAttach(Context context) {
+    super.onAttach(context);
+    initializeComponentContext();
+    inject();
+  }
+
+  @Override
+  @SuppressWarnings("deprecation")
+  @CallSuper
+  @MainThread
+  public void onAttach(Activity activity) {
+    super.onAttach(activity);
+    Preconditions.checkState(componentContext == null || FragmentComponentManager.findActivity(componentContext) == activity, "onAttach called multiple times with different Context! Hilt Fragments should not be retained.");
+    initializeComponentContext();
+    inject();
+  }
+
+  private void initializeComponentContext() {
+    if (componentContext == null) {
+      // Note: The LayoutInflater provided by this componentContext may be different from super Fragment's because we getting it from base context instead of cloning from the super Fragment's LayoutInflater.
+      componentContext = FragmentComponentManager.createContextWrapper(super.getContext(), this);
+      disableGetContextFix = FragmentGetContextFix.isFragmentGetContextFixDisabled(super.getContext());
+    }
+  }
+
+  @Override
+  public Context getContext() {
+    if (super.getContext() == null && !disableGetContextFix) {
+      return null;
+    }
+    initializeComponentContext();
+    return componentContext;
+  }
+
+  @Override
+  public LayoutInflater onGetLayoutInflater(Bundle savedInstanceState) {
+    LayoutInflater inflater = super.onGetLayoutInflater(savedInstanceState);
+    return inflater.cloneInContext(FragmentComponentManager.createContextWrapper(inflater, this));
+  }
+
+  @Override
+  public final Object generatedComponent() {
+    return this.componentManager().generatedComponent();
+  }
+
+  protected FragmentComponentManager createComponentManager() {
+    return new FragmentComponentManager(this);
+  }
+
+  @Override
+  public final FragmentComponentManager componentManager() {
+    if (componentManager == null) {
+      synchronized (componentManagerLock) {
+        if (componentManager == null) {
+          componentManager = createComponentManager();
+        }
+      }
+    }
+    return componentManager;
+  }
+
+  protected void inject() {
+    if (!injected) {
+      injected = true;
+      ((LoginFragment_GeneratedInjector) this.generatedComponent()).injectLoginFragment(UnsafeCasts.<LoginFragment>unsafeCast(this));
+    }
+  }
+
+  @Override
+  public ViewModelProvider.Factory getDefaultViewModelProviderFactory() {
+    return DefaultViewModelFactories.getFragmentFactory(this, super.getDefaultViewModelProviderFactory());
+  }
+}

app/build/kspCaches/debug/backups/java/byRounds/1/com/stec/cmd/feature/mine/Hilt_MineFragment.java

@@ -0,0 +1,120 @@
+package com.stec.cmd.feature.mine;
+
+import android.app.Activity;
+import android.content.Context;
+import android.content.ContextWrapper;
+import android.os.Bundle;
+import android.view.LayoutInflater;
+import androidx.annotation.CallSuper;
+import androidx.annotation.MainThread;
+import androidx.fragment.app.Fragment;
+import androidx.lifecycle.ViewModelProvider;
+import dagger.hilt.android.flags.FragmentGetContextFix;
+import dagger.hilt.android.internal.lifecycle.DefaultViewModelFactories;
+import dagger.hilt.android.internal.managers.FragmentComponentManager;
+import dagger.hilt.internal.GeneratedComponentManagerHolder;
+import dagger.hilt.internal.Preconditions;
+import dagger.hilt.internal.UnsafeCasts;
+import java.lang.Object;
+import java.lang.Override;
+import java.lang.SuppressWarnings;
+import javax.annotation.processing.Generated;
+
+/**
+ * A generated base class to be extended by the @dagger.hilt.android.AndroidEntryPoint annotated class. If using the Gradle plugin, this is swapped as the base class via bytecode transformation.
+ */
+@Generated("dagger.hilt.android.processor.internal.androidentrypoint.FragmentGenerator")
+public abstract class Hilt_MineFragment extends Fragment implements GeneratedComponentManagerHolder {
+  private ContextWrapper componentContext;
+
+  private boolean disableGetContextFix;
+
+  private volatile FragmentComponentManager componentManager;
+
+  private final Object componentManagerLock = new Object();
+
+  private boolean injected = false;
+
+  Hilt_MineFragment() {
+    super();
+  }
+
+  Hilt_MineFragment(int p0) {
+    super(p0);
+  }
+
+  @Override
+  @CallSuper
+  public void onAttach(Context context) {
+    super.onAttach(context);
+    initializeComponentContext();
+    inject();
+  }
+
+  @Override
+  @SuppressWarnings("deprecation")
+  @CallSuper
+  @MainThread
+  public void onAttach(Activity activity) {
+    super.onAttach(activity);
+    Preconditions.checkState(componentContext == null || FragmentComponentManager.findActivity(componentContext) == activity, "onAttach called multiple times with different Context! Hilt Fragments should not be retained.");
+    initializeComponentContext();
+    inject();
+  }
+
+  private void initializeComponentContext() {
+    if (componentContext == null) {
+      // Note: The LayoutInflater provided by this componentContext may be different from super Fragment's because we getting it from base context instead of cloning from the super Fragment's LayoutInflater.
+      componentContext = FragmentComponentManager.createContextWrapper(super.getContext(), this);
+      disableGetContextFix = FragmentGetContextFix.isFragmentGetContextFixDisabled(super.getContext());
+    }
+  }
+
+  @Override
+  public Context getContext() {
+    if (super.getContext() == null && !disableGetContextFix) {
+      return null;
+    }
+    initializeComponentContext();
+    return componentContext;
+  }
+
+  @Override
+  public LayoutInflater onGetLayoutInflater(Bundle savedInstanceState) {
+    LayoutInflater inflater = super.onGetLayoutInflater(savedInstanceState);
+    return inflater.cloneInContext(FragmentComponentManager.createContextWrapper(inflater, this));
+  }
+
+  @Override
+  public final Object generatedComponent() {
+    return this.componentManager().generatedComponent();
+  }
+
+  protected FragmentComponentManager createComponentManager() {
+    return new FragmentComponentManager(this);
+  }
+
+  @Override
+  public final FragmentComponentManager componentManager() {
+    if (componentManager == null) {
+      synchronized (componentManagerLock) {
+        if (componentManager == null) {
+          componentManager = createComponentManager();
+        }
+      }
+    }
+    return componentManager;
+  }
+
+  protected void inject() {
+    if (!injected) {
+      injected = true;
+      ((MineFragment_GeneratedInjector) this.generatedComponent()).injectMineFragment(UnsafeCasts.<MineFragment>unsafeCast(this));
+    }
+  }
+
+  @Override
+  public ViewModelProvider.Factory getDefaultViewModelProviderFactory() {
+    return DefaultViewModelFactories.getFragmentFactory(this, super.getDefaultViewModelProviderFactory());
+  }
+}

app/build/kspCaches/debug/backups/java/byRounds/1/com/stec/cmd/feature/mine/LoginFragment_GeneratedInjector.java

@@ -0,0 +1,17 @@
+package com.stec.cmd.feature.mine;
+
+import dagger.hilt.InstallIn;
+import dagger.hilt.android.components.FragmentComponent;
+import dagger.hilt.codegen.OriginatingElement;
+import dagger.hilt.internal.GeneratedEntryPoint;
+import javax.annotation.processing.Generated;
+
+@OriginatingElement(
+    topLevelClass = LoginFragment.class
+)
+@GeneratedEntryPoint
+@InstallIn(FragmentComponent.class)
+@Generated("dagger.hilt.android.processor.internal.androidentrypoint.InjectorEntryPointGenerator")
+public interface LoginFragment_GeneratedInjector {
+  void injectLoginFragment(LoginFragment loginFragment);
+}

app/build/kspCaches/debug/backups/java/byRounds/1/com/stec/cmd/feature/mine/LoginViewModel_Factory.java

@@ -0,0 +1,52 @@
+package com.stec.cmd.feature.mine;
+
+import com.stec.cmd.config.ConfigRepository;
+import com.stec.cmd.session.SessionRepository;
+import dagger.internal.DaggerGenerated;
+import dagger.internal.Factory;
+import dagger.internal.QualifierMetadata;
+import dagger.internal.ScopeMetadata;
+import javax.annotation.processing.Generated;
+import javax.inject.Provider;
+
+@ScopeMetadata
+@QualifierMetadata
+@DaggerGenerated
+@Generated(
+    value = "dagger.internal.codegen.ComponentProcessor",
+    comments = "https://dagger.dev"
+)
+@SuppressWarnings({
+    "unchecked",
+    "rawtypes",
+    "KotlinInternal",
+    "KotlinInternalInJava",
+    "cast",
+    "deprecation"
+})
+public final class LoginViewModel_Factory implements Factory<LoginViewModel> {
+  private final Provider<SessionRepository> sessionRepositoryProvider;
+
+  private final Provider<ConfigRepository> configRepositoryProvider;
+
+  public LoginViewModel_Factory(Provider<SessionRepository> sessionRepositoryProvider,
+      Provider<ConfigRepository> configRepositoryProvider) {
+    this.sessionRepositoryProvider = sessionRepositoryProvider;
+    this.configRepositoryProvider = configRepositoryProvider;
+  }
+
+  @Override
+  public LoginViewModel get() {
+    return newInstance(sessionRepositoryProvider.get(), configRepositoryProvider.get());
+  }
+
+  public static LoginViewModel_Factory create(Provider<SessionRepository> sessionRepositoryProvider,
+      Provider<ConfigRepository> configRepositoryProvider) {
+    return new LoginViewModel_Factory(sessionRepositoryProvider, configRepositoryProvider);
+  }
+
+  public static LoginViewModel newInstance(SessionRepository sessionRepository,
+      ConfigRepository configRepository) {
+    return new LoginViewModel(sessionRepository, configRepository);
+  }
+}

app/build/kspCaches/debug/backups/java/byRounds/1/com/stec/cmd/feature/mine/LoginViewModel_HiltModules.java

@@ -0,0 +1,51 @@
+package com.stec.cmd.feature.mine;
+
+import androidx.lifecycle.ViewModel;
+import dagger.Binds;
+import dagger.Module;
+import dagger.Provides;
+import dagger.hilt.InstallIn;
+import dagger.hilt.android.components.ActivityRetainedComponent;
+import dagger.hilt.android.components.ViewModelComponent;
+import dagger.hilt.android.internal.lifecycle.HiltViewModelMap;
+import dagger.hilt.codegen.OriginatingElement;
+import dagger.multibindings.IntoMap;
+import dagger.multibindings.LazyClassKey;
+import javax.annotation.processing.Generated;
+
+@Generated("dagger.hilt.android.processor.internal.viewmodel.ViewModelProcessor")
+@OriginatingElement(
+    topLevelClass = LoginViewModel.class
+)
+public final class LoginViewModel_HiltModules {
+  private LoginViewModel_HiltModules() {
+  }
+
+  @Module
+  @InstallIn(ViewModelComponent.class)
+  public abstract static class BindsModule {
+    private BindsModule() {
+    }
+
+    @Binds
+    @IntoMap
+    @LazyClassKey(LoginViewModel.class)
+    @HiltViewModelMap
+    public abstract ViewModel binds(LoginViewModel vm);
+  }
+
+  @Module
+  @InstallIn(ActivityRetainedComponent.class)
+  public static final class KeyModule {
+    private KeyModule() {
+    }
+
+    @Provides
+    @IntoMap
+    @LazyClassKey(LoginViewModel.class)
+    @HiltViewModelMap.KeySet
+    public static boolean provide() {
+      return true;
+    }
+  }
+}

app/build/kspCaches/debug/backups/java/byRounds/1/com/stec/cmd/feature/mine/MineFragment_GeneratedInjector.java

@@ -0,0 +1,17 @@
+package com.stec.cmd.feature.mine;
+
+import dagger.hilt.InstallIn;
+import dagger.hilt.android.components.FragmentComponent;
+import dagger.hilt.codegen.OriginatingElement;
+import dagger.hilt.internal.GeneratedEntryPoint;
+import javax.annotation.processing.Generated;
+
+@OriginatingElement(
+    topLevelClass = MineFragment.class
+)
+@GeneratedEntryPoint
+@InstallIn(FragmentComponent.class)
+@Generated("dagger.hilt.android.processor.internal.androidentrypoint.InjectorEntryPointGenerator")
+public interface MineFragment_GeneratedInjector {
+  void injectMineFragment(MineFragment mineFragment);
+}

app/build/kspCaches/debug/backups/java/byRounds/1/com/stec/cmd/feature/mine/MineViewModel_Factory.java

@@ -0,0 +1,52 @@
+package com.stec.cmd.feature.mine;
+
+import com.stec.cmd.config.ConfigRepository;
+import com.stec.cmd.session.SessionRepository;
+import dagger.internal.DaggerGenerated;
+import dagger.internal.Factory;
+import dagger.internal.QualifierMetadata;
+import dagger.internal.ScopeMetadata;
+import javax.annotation.processing.Generated;
+import javax.inject.Provider;
+
+@ScopeMetadata
+@QualifierMetadata
+@DaggerGenerated
+@Generated(
+    value = "dagger.internal.codegen.ComponentProcessor",
+    comments = "https://dagger.dev"
+)
+@SuppressWarnings({
+    "unchecked",
+    "rawtypes",
+    "KotlinInternal",
+    "KotlinInternalInJava",
+    "cast",
+    "deprecation"
+})
+public final class MineViewModel_Factory implements Factory<MineViewModel> {
+  private final Provider<SessionRepository> sessionRepositoryProvider;
+
+  private final Provider<ConfigRepository> configRepositoryProvider;
+
+  public MineViewModel_Factory(Provider<SessionRepository> sessionRepositoryProvider,
+      Provider<ConfigRepository> configRepositoryProvider) {
+    this.sessionRepositoryProvider = sessionRepositoryProvider;
+    this.configRepositoryProvider = configRepositoryProvider;
+  }
+
+  @Override
+  public MineViewModel get() {
+    return newInstance(sessionRepositoryProvider.get(), configRepositoryProvider.get());
+  }
+
+  public static MineViewModel_Factory create(Provider<SessionRepository> sessionRepositoryProvider,
+      Provider<ConfigRepository> configRepositoryProvider) {
+    return new MineViewModel_Factory(sessionRepositoryProvider, configRepositoryProvider);
+  }
+
+  public static MineViewModel newInstance(SessionRepository sessionRepository,
+      ConfigRepository configRepository) {
+    return new MineViewModel(sessionRepository, configRepository);
+  }
+}

app/build/kspCaches/debug/backups/java/byRounds/1/com/stec/cmd/feature/mine/MineViewModel_HiltModules.java

@@ -0,0 +1,51 @@
+package com.stec.cmd.feature.mine;
+
+import androidx.lifecycle.ViewModel;
+import dagger.Binds;
+import dagger.Module;
+import dagger.Provides;
+import dagger.hilt.InstallIn;
+import dagger.hilt.android.components.ActivityRetainedComponent;
+import dagger.hilt.android.components.ViewModelComponent;
+import dagger.hilt.android.internal.lifecycle.HiltViewModelMap;
+import dagger.hilt.codegen.OriginatingElement;
+import dagger.multibindings.IntoMap;
+import dagger.multibindings.LazyClassKey;
+import javax.annotation.processing.Generated;
+
+@Generated("dagger.hilt.android.processor.internal.viewmodel.ViewModelProcessor")
+@OriginatingElement(
+    topLevelClass = MineViewModel.class
+)
+public final class MineViewModel_HiltModules {
+  private MineViewModel_HiltModules() {
+  }
+
+  @Module
+  @InstallIn(ViewModelComponent.class)
+  public abstract static class BindsModule {
+    private BindsModule() {
+    }
+
+    @Binds
+    @IntoMap
+    @LazyClassKey(MineViewModel.class)
+    @HiltViewModelMap
+    public abstract ViewModel binds(MineViewModel vm);
+  }
+
+  @Module
+  @InstallIn(ActivityRetainedComponent.class)
+  public static final class KeyModule {
+    private KeyModule() {
+    }
+
+    @Provides
+    @IntoMap
+    @LazyClassKey(MineViewModel.class)
+    @HiltViewModelMap.KeySet
+    public static boolean provide() {
+      return true;
+    }
+  }
+}

app/build/kspCaches/debug/backups/java/byRounds/1/com/stec/cmd/session/SessionRepository_Factory.java

@@ -0,0 +1,62 @@
+package com.stec.cmd.session;
+
+import com.stec.cmd.config.ConfigRepository;
+import com.stec.cmd.core.network.ApiCaller;
+import com.stec.cmd.core.network.api.AuthApi;
+import dagger.internal.DaggerGenerated;
+import dagger.internal.Factory;
+import dagger.internal.QualifierMetadata;
+import dagger.internal.ScopeMetadata;
+import javax.annotation.processing.Generated;
+import javax.inject.Provider;
+import kotlinx.serialization.json.Json;
+
+@ScopeMetadata("javax.inject.Singleton")
+@QualifierMetadata
+@DaggerGenerated
+@Generated(
+    value = "dagger.internal.codegen.ComponentProcessor",
+    comments = "https://dagger.dev"
+)
+@SuppressWarnings({
+    "unchecked",
+    "rawtypes",
+    "KotlinInternal",
+    "KotlinInternalInJava",
+    "cast",
+    "deprecation"
+})
+public final class SessionRepository_Factory implements Factory<SessionRepository> {
+  private final Provider<AuthApi> authApiProvider;
+
+  private final Provider<ApiCaller> apiCallerProvider;
+
+  private final Provider<ConfigRepository> configRepositoryProvider;
+
+  private final Provider<Json> jsonProvider;
+
+  public SessionRepository_Factory(Provider<AuthApi> authApiProvider,
+      Provider<ApiCaller> apiCallerProvider, Provider<ConfigRepository> configRepositoryProvider,
+      Provider<Json> jsonProvider) {
+    this.authApiProvider = authApiProvider;
+    this.apiCallerProvider = apiCallerProvider;
+    this.configRepositoryProvider = configRepositoryProvider;
+    this.jsonProvider = jsonProvider;
+  }
+
+  @Override
+  public SessionRepository get() {
+    return newInstance(authApiProvider.get(), apiCallerProvider.get(), configRepositoryProvider.get(), jsonProvider.get());
+  }
+
+  public static SessionRepository_Factory create(Provider<AuthApi> authApiProvider,
+      Provider<ApiCaller> apiCallerProvider, Provider<ConfigRepository> configRepositoryProvider,
+      Provider<Json> jsonProvider) {
+    return new SessionRepository_Factory(authApiProvider, apiCallerProvider, configRepositoryProvider, jsonProvider);
+  }
+
+  public static SessionRepository newInstance(AuthApi authApi, ApiCaller apiCaller,
+      ConfigRepository configRepository, Json json) {
+    return new SessionRepository(authApi, apiCaller, configRepository, json);
+  }
+}

app/build/kspCaches/debug/backups/java/byRounds/1/dagger/hilt/internal/aggregatedroot/codegen/_com_stec_cmd_SteCmdApplication.java

@@ -0,0 +1,21 @@
+package dagger.hilt.internal.aggregatedroot.codegen;
+
+import dagger.hilt.android.HiltAndroidApp;
+import dagger.hilt.internal.aggregatedroot.AggregatedRoot;
+import javax.annotation.processing.Generated;
+
+/**
+ * This class should only be referenced by generated code! This class aggregates information across multiple compilations.
+ */
+@AggregatedRoot(
+    root = "com.stec.cmd.SteCmdApplication",
+    rootPackage = "com.stec.cmd",
+    originatingRoot = "com.stec.cmd.SteCmdApplication",
+    originatingRootPackage = "com.stec.cmd",
+    rootAnnotation = HiltAndroidApp.class,
+    rootSimpleNames = "SteCmdApplication",
+    originatingRootSimpleNames = "SteCmdApplication"
+)
+@Generated("dagger.hilt.processor.internal.root.AggregatedRootGenerator")
+public class _com_stec_cmd_SteCmdApplication {
+}

app/build/kspCaches/debug/backups/java/byRounds/1/hilt_aggregated_deps/_com_stec_cmd_config_AppModule.java

@@ -0,0 +1,15 @@
+package hilt_aggregated_deps;
+
+import dagger.hilt.processor.internal.aggregateddeps.AggregatedDeps;
+import javax.annotation.processing.Generated;
+
+/**
+ * This class should only be referenced by generated code! This class aggregates information across multiple compilations.
+ */
+@AggregatedDeps(
+    components = "dagger.hilt.components.SingletonComponent",
+    modules = "com.stec.cmd.config.AppModule"
+)
+@Generated("dagger.hilt.processor.internal.aggregateddeps.AggregatedDepsGenerator")
+public class _com_stec_cmd_config_AppModule {
+}

app/build/kspCaches/debug/backups/java/byRounds/1/hilt_aggregated_deps/_com_stec_cmd_config_ConfigBindModule.java

@@ -0,0 +1,15 @@
+package hilt_aggregated_deps;
+
+import dagger.hilt.processor.internal.aggregateddeps.AggregatedDeps;
+import javax.annotation.processing.Generated;
+
+/**
+ * This class should only be referenced by generated code! This class aggregates information across multiple compilations.
+ */
+@AggregatedDeps(
+    components = "dagger.hilt.components.SingletonComponent",
+    modules = "com.stec.cmd.config.ConfigBindModule"
+)
+@Generated("dagger.hilt.processor.internal.aggregateddeps.AggregatedDepsGenerator")
+public class _com_stec_cmd_config_ConfigBindModule {
+}

app/build/kspCaches/debug/backups/java/byRounds/2/com/stec/cmd/feature/mine/ChangePasswordViewModel_HiltModules_KeyModule_ProvideFactory.java

@@ -0,0 +1,41 @@
+package com.stec.cmd.feature.mine;
+
+import dagger.internal.DaggerGenerated;
+import dagger.internal.Factory;
+import dagger.internal.QualifierMetadata;
+import dagger.internal.ScopeMetadata;
+import javax.annotation.processing.Generated;
+
+@ScopeMetadata
+@QualifierMetadata("dagger.hilt.android.internal.lifecycle.HiltViewModelMap.KeySet")
+@DaggerGenerated
+@Generated(
+    value = "dagger.internal.codegen.ComponentProcessor",
+    comments = "https://dagger.dev"
+)
+@SuppressWarnings({
+    "unchecked",
+    "rawtypes",
+    "KotlinInternal",
+    "KotlinInternalInJava",
+    "cast",
+    "deprecation"
+})
+public final class ChangePasswordViewModel_HiltModules_KeyModule_ProvideFactory implements Factory<Boolean> {
+  @Override
+  public Boolean get() {
+    return provide();
+  }
+
+  public static ChangePasswordViewModel_HiltModules_KeyModule_ProvideFactory create() {
+    return InstanceHolder.INSTANCE;
+  }
+
+  public static boolean provide() {
+    return ChangePasswordViewModel_HiltModules.KeyModule.provide();
+  }
+
+  private static final class InstanceHolder {
+    private static final ChangePasswordViewModel_HiltModules_KeyModule_ProvideFactory INSTANCE = new ChangePasswordViewModel_HiltModules_KeyModule_ProvideFactory();
+  }
+}

app/build/kspCaches/debug/backups/java/byRounds/2/com/stec/cmd/feature/mine/ConfigViewModel_HiltModules_KeyModule_ProvideFactory.java

@@ -0,0 +1,41 @@
+package com.stec.cmd.feature.mine;
+
+import dagger.internal.DaggerGenerated;
+import dagger.internal.Factory;
+import dagger.internal.QualifierMetadata;
+import dagger.internal.ScopeMetadata;
+import javax.annotation.processing.Generated;
+
+@ScopeMetadata
+@QualifierMetadata("dagger.hilt.android.internal.lifecycle.HiltViewModelMap.KeySet")
+@DaggerGenerated
+@Generated(
+    value = "dagger.internal.codegen.ComponentProcessor",
+    comments = "https://dagger.dev"
+)
+@SuppressWarnings({
+    "unchecked",
+    "rawtypes",
+    "KotlinInternal",
+    "KotlinInternalInJava",
+    "cast",
+    "deprecation"
+})
+public final class ConfigViewModel_HiltModules_KeyModule_ProvideFactory implements Factory<Boolean> {
+  @Override
+  public Boolean get() {
+    return provide();
+  }
+
+  public static ConfigViewModel_HiltModules_KeyModule_ProvideFactory create() {
+    return InstanceHolder.INSTANCE;
+  }
+
+  public static boolean provide() {
+    return ConfigViewModel_HiltModules.KeyModule.provide();
+  }
+
+  private static final class InstanceHolder {
+    private static final ConfigViewModel_HiltModules_KeyModule_ProvideFactory INSTANCE = new ConfigViewModel_HiltModules_KeyModule_ProvideFactory();
+  }
+}

app/build/kspCaches/debug/backups/java/byRounds/2/com/stec/cmd/feature/mine/LoginViewModel_HiltModules_KeyModule_ProvideFactory.java

@@ -0,0 +1,41 @@
+package com.stec.cmd.feature.mine;
+
+import dagger.internal.DaggerGenerated;
+import dagger.internal.Factory;
+import dagger.internal.QualifierMetadata;
+import dagger.internal.ScopeMetadata;
+import javax.annotation.processing.Generated;
+
+@ScopeMetadata
+@QualifierMetadata("dagger.hilt.android.internal.lifecycle.HiltViewModelMap.KeySet")
+@DaggerGenerated
+@Generated(
+    value = "dagger.internal.codegen.ComponentProcessor",
+    comments = "https://dagger.dev"
+)
+@SuppressWarnings({
+    "unchecked",
+    "rawtypes",
+    "KotlinInternal",
+    "KotlinInternalInJava",
+    "cast",
+    "deprecation"
+})
+public final class LoginViewModel_HiltModules_KeyModule_ProvideFactory implements Factory<Boolean> {
+  @Override
+  public Boolean get() {
+    return provide();
+  }
+
+  public static LoginViewModel_HiltModules_KeyModule_ProvideFactory create() {
+    return InstanceHolder.INSTANCE;
+  }
+
+  public static boolean provide() {
+    return LoginViewModel_HiltModules.KeyModule.provide();
+  }
+
+  private static final class InstanceHolder {
+    private static final LoginViewModel_HiltModules_KeyModule_ProvideFactory INSTANCE = new LoginViewModel_HiltModules_KeyModule_ProvideFactory();
+  }
+}

app/build/kspCaches/debug/backups/java/byRounds/2/com/stec/cmd/feature/mine/MineViewModel_HiltModules_KeyModule_ProvideFactory.java

@@ -0,0 +1,41 @@
+package com.stec.cmd.feature.mine;
+
+import dagger.internal.DaggerGenerated;
+import dagger.internal.Factory;
+import dagger.internal.QualifierMetadata;
+import dagger.internal.ScopeMetadata;
+import javax.annotation.processing.Generated;
+
+@ScopeMetadata
+@QualifierMetadata("dagger.hilt.android.internal.lifecycle.HiltViewModelMap.KeySet")
+@DaggerGenerated
+@Generated(
+    value = "dagger.internal.codegen.ComponentProcessor",
+    comments = "https://dagger.dev"
+)
+@SuppressWarnings({
+    "unchecked",
+    "rawtypes",
+    "KotlinInternal",
+    "KotlinInternalInJava",
+    "cast",
+    "deprecation"
+})
+public final class MineViewModel_HiltModules_KeyModule_ProvideFactory implements Factory<Boolean> {
+  @Override
+  public Boolean get() {
+    return provide();
+  }
+
+  public static MineViewModel_HiltModules_KeyModule_ProvideFactory create() {
+    return InstanceHolder.INSTANCE;
+  }
+
+  public static boolean provide() {
+    return MineViewModel_HiltModules.KeyModule.provide();
+  }
+
+  private static final class InstanceHolder {
+    private static final MineViewModel_HiltModules_KeyModule_ProvideFactory INSTANCE = new MineViewModel_HiltModules_KeyModule_ProvideFactory();
+  }
+}

app/build/kspCaches/debug/backups/java/byRounds/2/hilt_aggregated_deps/_com_stec_cmd_CollectFragment_GeneratedInjector.java

@@ -0,0 +1,15 @@
+package hilt_aggregated_deps;
+
+import dagger.hilt.processor.internal.aggregateddeps.AggregatedDeps;
+import javax.annotation.processing.Generated;
+
+/**
+ * This class should only be referenced by generated code! This class aggregates information across multiple compilations.
+ */
+@AggregatedDeps(
+    components = "dagger.hilt.android.components.FragmentComponent",
+    entryPoints = "com.stec.cmd.CollectFragment_GeneratedInjector"
+)
+@Generated("dagger.hilt.processor.internal.aggregateddeps.AggregatedDepsGenerator")
+public class _com_stec_cmd_CollectFragment_GeneratedInjector {
+}

app/build/kspCaches/debug/backups/java/byRounds/2/hilt_aggregated_deps/_com_stec_cmd_HomeFragment_GeneratedInjector.java

@@ -0,0 +1,15 @@
+package hilt_aggregated_deps;
+
+import dagger.hilt.processor.internal.aggregateddeps.AggregatedDeps;
+import javax.annotation.processing.Generated;
+
+/**
+ * This class should only be referenced by generated code! This class aggregates information across multiple compilations.
+ */
+@AggregatedDeps(
+    components = "dagger.hilt.android.components.FragmentComponent",
+    entryPoints = "com.stec.cmd.HomeFragment_GeneratedInjector"
+)
+@Generated("dagger.hilt.processor.internal.aggregateddeps.AggregatedDepsGenerator")
+public class _com_stec_cmd_HomeFragment_GeneratedInjector {
+}

app/build/kspCaches/debug/backups/java/byRounds/2/hilt_aggregated_deps/_com_stec_cmd_MainActivity_GeneratedInjector.java

@@ -0,0 +1,15 @@
+package hilt_aggregated_deps;
+
+import dagger.hilt.processor.internal.aggregateddeps.AggregatedDeps;
+import javax.annotation.processing.Generated;
+
+/**
+ * This class should only be referenced by generated code! This class aggregates information across multiple compilations.
+ */
+@AggregatedDeps(
+    components = "dagger.hilt.android.components.ActivityComponent",
+    entryPoints = "com.stec.cmd.MainActivity_GeneratedInjector"
+)
+@Generated("dagger.hilt.processor.internal.aggregateddeps.AggregatedDepsGenerator")
+public class _com_stec_cmd_MainActivity_GeneratedInjector {
+}

app/build/kspCaches/debug/backups/java/byRounds/2/hilt_aggregated_deps/_com_stec_cmd_StatsFragment_GeneratedInjector.java

@@ -0,0 +1,15 @@
+package hilt_aggregated_deps;
+
+import dagger.hilt.processor.internal.aggregateddeps.AggregatedDeps;
+import javax.annotation.processing.Generated;
+
+/**
+ * This class should only be referenced by generated code! This class aggregates information across multiple compilations.
+ */
+@AggregatedDeps(
+    components = "dagger.hilt.android.components.FragmentComponent",
+    entryPoints = "com.stec.cmd.StatsFragment_GeneratedInjector"
+)
+@Generated("dagger.hilt.processor.internal.aggregateddeps.AggregatedDepsGenerator")
+public class _com_stec_cmd_StatsFragment_GeneratedInjector {
+}

app/build/kspCaches/debug/backups/java/byRounds/2/hilt_aggregated_deps/_com_stec_cmd_SteCmdApplication_GeneratedInjector.java

@@ -0,0 +1,15 @@
+package hilt_aggregated_deps;
+
+import dagger.hilt.processor.internal.aggregateddeps.AggregatedDeps;
+import javax.annotation.processing.Generated;
+
+/**
+ * This class should only be referenced by generated code! This class aggregates information across multiple compilations.
+ */
+@AggregatedDeps(
+    components = "dagger.hilt.components.SingletonComponent",
+    entryPoints = "com.stec.cmd.SteCmdApplication_GeneratedInjector"
+)
+@Generated("dagger.hilt.processor.internal.aggregateddeps.AggregatedDepsGenerator")
+public class _com_stec_cmd_SteCmdApplication_GeneratedInjector {
+}

app/build/kspCaches/debug/backups/java/byRounds/2/hilt_aggregated_deps/_com_stec_cmd_TaskFragment_GeneratedInjector.java

@@ -0,0 +1,15 @@
+package hilt_aggregated_deps;
+
+import dagger.hilt.processor.internal.aggregateddeps.AggregatedDeps;
+import javax.annotation.processing.Generated;
+
+/**
+ * This class should only be referenced by generated code! This class aggregates information across multiple compilations.
+ */
+@AggregatedDeps(
+    components = "dagger.hilt.android.components.FragmentComponent",
+    entryPoints = "com.stec.cmd.TaskFragment_GeneratedInjector"
+)
+@Generated("dagger.hilt.processor.internal.aggregateddeps.AggregatedDepsGenerator")
+public class _com_stec_cmd_TaskFragment_GeneratedInjector {
+}

app/build/kspCaches/debug/backups/java/byRounds/2/hilt_aggregated_deps/_com_stec_cmd_feature_mine_ChangePasswordFragment_GeneratedInjector.java

@@ -0,0 +1,15 @@
+package hilt_aggregated_deps;
+
+import dagger.hilt.processor.internal.aggregateddeps.AggregatedDeps;
+import javax.annotation.processing.Generated;
+
+/**
+ * This class should only be referenced by generated code! This class aggregates information across multiple compilations.
+ */
+@AggregatedDeps(
+    components = "dagger.hilt.android.components.FragmentComponent",
+    entryPoints = "com.stec.cmd.feature.mine.ChangePasswordFragment_GeneratedInjector"
+)
+@Generated("dagger.hilt.processor.internal.aggregateddeps.AggregatedDepsGenerator")
+public class _com_stec_cmd_feature_mine_ChangePasswordFragment_GeneratedInjector {
+}

app/build/kspCaches/debug/backups/java/byRounds/2/hilt_aggregated_deps/_com_stec_cmd_feature_mine_ChangePasswordViewModel_HiltModules_BindsModule.java

@@ -0,0 +1,15 @@
+package hilt_aggregated_deps;
+
+import dagger.hilt.processor.internal.aggregateddeps.AggregatedDeps;
+import javax.annotation.processing.Generated;
+
+/**
+ * This class should only be referenced by generated code! This class aggregates information across multiple compilations.
+ */
+@AggregatedDeps(
+    components = "dagger.hilt.android.components.ViewModelComponent",
+    modules = "com.stec.cmd.feature.mine.ChangePasswordViewModel_HiltModules.BindsModule"
+)
+@Generated("dagger.hilt.processor.internal.aggregateddeps.AggregatedDepsGenerator")
+public class _com_stec_cmd_feature_mine_ChangePasswordViewModel_HiltModules_BindsModule {
+}

app/build/kspCaches/debug/backups/java/byRounds/2/hilt_aggregated_deps/_com_stec_cmd_feature_mine_ChangePasswordViewModel_HiltModules_KeyModule.java

@@ -0,0 +1,15 @@
+package hilt_aggregated_deps;
+
+import dagger.hilt.processor.internal.aggregateddeps.AggregatedDeps;
+import javax.annotation.processing.Generated;
+
+/**
+ * This class should only be referenced by generated code! This class aggregates information across multiple compilations.
+ */
+@AggregatedDeps(
+    components = "dagger.hilt.android.components.ActivityRetainedComponent",
+    modules = "com.stec.cmd.feature.mine.ChangePasswordViewModel_HiltModules.KeyModule"
+)
+@Generated("dagger.hilt.processor.internal.aggregateddeps.AggregatedDepsGenerator")
+public class _com_stec_cmd_feature_mine_ChangePasswordViewModel_HiltModules_KeyModule {
+}

app/build/kspCaches/debug/backups/java/byRounds/2/hilt_aggregated_deps/_com_stec_cmd_feature_mine_ConfigFragment_GeneratedInjector.java

@@ -0,0 +1,15 @@
+package hilt_aggregated_deps;
+
+import dagger.hilt.processor.internal.aggregateddeps.AggregatedDeps;
+import javax.annotation.processing.Generated;
+
+/**
+ * This class should only be referenced by generated code! This class aggregates information across multiple compilations.
+ */
+@AggregatedDeps(
+    components = "dagger.hilt.android.components.FragmentComponent",
+    entryPoints = "com.stec.cmd.feature.mine.ConfigFragment_GeneratedInjector"
+)
+@Generated("dagger.hilt.processor.internal.aggregateddeps.AggregatedDepsGenerator")
+public class _com_stec_cmd_feature_mine_ConfigFragment_GeneratedInjector {
+}

app/build/kspCaches/debug/backups/java/byRounds/2/hilt_aggregated_deps/_com_stec_cmd_feature_mine_ConfigViewModel_HiltModules_BindsModule.java

@@ -0,0 +1,15 @@
+package hilt_aggregated_deps;
+
+import dagger.hilt.processor.internal.aggregateddeps.AggregatedDeps;
+import javax.annotation.processing.Generated;
+
+/**
+ * This class should only be referenced by generated code! This class aggregates information across multiple compilations.
+ */
+@AggregatedDeps(
+    components = "dagger.hilt.android.components.ViewModelComponent",
+    modules = "com.stec.cmd.feature.mine.ConfigViewModel_HiltModules.BindsModule"
+)
+@Generated("dagger.hilt.processor.internal.aggregateddeps.AggregatedDepsGenerator")
+public class _com_stec_cmd_feature_mine_ConfigViewModel_HiltModules_BindsModule {
+}

app/build/kspCaches/debug/backups/java/byRounds/2/hilt_aggregated_deps/_com_stec_cmd_feature_mine_ConfigViewModel_HiltModules_KeyModule.java

@@ -0,0 +1,15 @@
+package hilt_aggregated_deps;
+
+import dagger.hilt.processor.internal.aggregateddeps.AggregatedDeps;
+import javax.annotation.processing.Generated;
+
+/**
+ * This class should only be referenced by generated code! This class aggregates information across multiple compilations.
+ */
+@AggregatedDeps(
+    components = "dagger.hilt.android.components.ActivityRetainedComponent",
+    modules = "com.stec.cmd.feature.mine.ConfigViewModel_HiltModules.KeyModule"
+)
+@Generated("dagger.hilt.processor.internal.aggregateddeps.AggregatedDepsGenerator")
+public class _com_stec_cmd_feature_mine_ConfigViewModel_HiltModules_KeyModule {
+}

app/build/kspCaches/debug/backups/java/byRounds/2/hilt_aggregated_deps/_com_stec_cmd_feature_mine_LoginFragment_GeneratedInjector.java

@@ -0,0 +1,15 @@
+package hilt_aggregated_deps;
+
+import dagger.hilt.processor.internal.aggregateddeps.AggregatedDeps;
+import javax.annotation.processing.Generated;
+
+/**
+ * This class should only be referenced by generated code! This class aggregates information across multiple compilations.
+ */
+@AggregatedDeps(
+    components = "dagger.hilt.android.components.FragmentComponent",
+    entryPoints = "com.stec.cmd.feature.mine.LoginFragment_GeneratedInjector"
+)
+@Generated("dagger.hilt.processor.internal.aggregateddeps.AggregatedDepsGenerator")
+public class _com_stec_cmd_feature_mine_LoginFragment_GeneratedInjector {
+}

app/build/kspCaches/debug/backups/java/byRounds/2/hilt_aggregated_deps/_com_stec_cmd_feature_mine_LoginViewModel_HiltModules_BindsModule.java

@@ -0,0 +1,15 @@
+package hilt_aggregated_deps;
+
+import dagger.hilt.processor.internal.aggregateddeps.AggregatedDeps;
+import javax.annotation.processing.Generated;
+
+/**
+ * This class should only be referenced by generated code! This class aggregates information across multiple compilations.
+ */
+@AggregatedDeps(
+    components = "dagger.hilt.android.components.ViewModelComponent",
+    modules = "com.stec.cmd.feature.mine.LoginViewModel_HiltModules.BindsModule"
+)
+@Generated("dagger.hilt.processor.internal.aggregateddeps.AggregatedDepsGenerator")
+public class _com_stec_cmd_feature_mine_LoginViewModel_HiltModules_BindsModule {
+}

app/build/kspCaches/debug/backups/java/byRounds/2/hilt_aggregated_deps/_com_stec_cmd_feature_mine_LoginViewModel_HiltModules_KeyModule.java

@@ -0,0 +1,15 @@
+package hilt_aggregated_deps;
+
+import dagger.hilt.processor.internal.aggregateddeps.AggregatedDeps;
+import javax.annotation.processing.Generated;
+
+/**
+ * This class should only be referenced by generated code! This class aggregates information across multiple compilations.
+ */
+@AggregatedDeps(
+    components = "dagger.hilt.android.components.ActivityRetainedComponent",
+    modules = "com.stec.cmd.feature.mine.LoginViewModel_HiltModules.KeyModule"
+)
+@Generated("dagger.hilt.processor.internal.aggregateddeps.AggregatedDepsGenerator")
+public class _com_stec_cmd_feature_mine_LoginViewModel_HiltModules_KeyModule {
+}

app/build/kspCaches/debug/backups/java/byRounds/2/hilt_aggregated_deps/_com_stec_cmd_feature_mine_MineFragment_GeneratedInjector.java

@@ -0,0 +1,15 @@
+package hilt_aggregated_deps;
+
+import dagger.hilt.processor.internal.aggregateddeps.AggregatedDeps;
+import javax.annotation.processing.Generated;
+
+/**
+ * This class should only be referenced by generated code! This class aggregates information across multiple compilations.
+ */
+@AggregatedDeps(
+    components = "dagger.hilt.android.components.FragmentComponent",
+    entryPoints = "com.stec.cmd.feature.mine.MineFragment_GeneratedInjector"
+)
+@Generated("dagger.hilt.processor.internal.aggregateddeps.AggregatedDepsGenerator")
+public class _com_stec_cmd_feature_mine_MineFragment_GeneratedInjector {
+}

app/build/kspCaches/debug/backups/java/byRounds/2/hilt_aggregated_deps/_com_stec_cmd_feature_mine_MineViewModel_HiltModules_BindsModule.java

@@ -0,0 +1,15 @@
+package hilt_aggregated_deps;
+
+import dagger.hilt.processor.internal.aggregateddeps.AggregatedDeps;
+import javax.annotation.processing.Generated;
+
+/**
+ * This class should only be referenced by generated code! This class aggregates information across multiple compilations.
+ */
+@AggregatedDeps(
+    components = "dagger.hilt.android.components.ViewModelComponent",
+    modules = "com.stec.cmd.feature.mine.MineViewModel_HiltModules.BindsModule"
+)
+@Generated("dagger.hilt.processor.internal.aggregateddeps.AggregatedDepsGenerator")
+public class _com_stec_cmd_feature_mine_MineViewModel_HiltModules_BindsModule {
+}

app/build/kspCaches/debug/backups/java/byRounds/2/hilt_aggregated_deps/_com_stec_cmd_feature_mine_MineViewModel_HiltModules_KeyModule.java

@@ -0,0 +1,15 @@
+package hilt_aggregated_deps;
+
+import dagger.hilt.processor.internal.aggregateddeps.AggregatedDeps;
+import javax.annotation.processing.Generated;
+
+/**
+ * This class should only be referenced by generated code! This class aggregates information across multiple compilations.
+ */
+@AggregatedDeps(
+    components = "dagger.hilt.android.components.ActivityRetainedComponent",
+    modules = "com.stec.cmd.feature.mine.MineViewModel_HiltModules.KeyModule"
+)
+@Generated("dagger.hilt.processor.internal.aggregateddeps.AggregatedDepsGenerator")
+public class _com_stec_cmd_feature_mine_MineViewModel_HiltModules_KeyModule {
+}