int ms_usage = mapArcfourMD5KeyUsage(keyusage);
        Mac mac = Mac.getInstance("HmacMD5");
        MessageDigest md = MessageDigest.getInstance("MD5");
        mac.init(key);
        byte[] dk = mac.doFinal(MD5_CONSTANT);
        try {
            // little endian
            md.update((byte) ( ms_usage & 0xFF ));

    } catch (IllegalStateException expected) {
    } finally {
      Providers.setProviderList(providers);
    }
  }

  public void testMultipleUpdates() throws Exception {
    Mac mac = Mac.getInstance("HmacSHA1");
    mac.init(SHA1_KEY);
    mac.update("hello".getBytes(UTF_8));
    mac.update("world".getBytes(UTF_8));

    assertEquals(
        HashCode.fromBytes(mac.doFinal()),

    <T> Injector bindInstance(Class<T> cls, T instance);

    //
    // Bean access
    //

    <T> void injectInstance(T instance);

    <T> T getInstance(Class<T> key);

    <T> T getInstance(Key<T> key);

        KaAnalysisPermissionRegistry.getInstance()
    }

    /**
     * Caches [KotlinAnalysisPermissionOptions] to avoid repeated `getService` calls in [analyze][org.jetbrains.kotlin.analysis.api.analyze]
     * and validity assertions.
     */
    @KaCachedService
    private val permissionOptions by lazy(LazyThreadSafetyMode.PUBLICATION) {
        KotlinAnalysisPermissionOptions.getInstance()
    }

            JvmClassFileBasedSymbolProvider(
                session,
                moduleDataProvider,
                kotlinScopeProvider,
                packagePartProvider,
                VirtualFileFinderFactory.getInstance(project).create(scope),
                firJavaFacade
            )
        )
    }

    override fun createCommonLibrarySymbolProvider(
        session: FirSession,
        moduleData: LLFirModuleData,

        KaAnalysisPermissionRegistry.getInstance().isAnalysisAllowedInWriteAction &&
        ApplicationManager.getApplication().isWriteAccessAllowed
    ) {
        // We must flush modifications to publish local modifications into FIR tree
        @OptIn(LLFirInternals::class)
        LLFirDeclarationModificationService.getInstance(project).flushModifications()
    }

	}

	if config.Initialized {
		tx = tx.getInstance()
	}

	return tx
}

// WithContext change current instance db's context to ctx
func (db *DB) WithContext(ctx context.Context) *DB {
	return db.Session(&Session{Context: ctx})
}

// Debug start debug mode
func (db *DB) Debug() (tx *DB) {
	tx = db.getInstance()
	return tx.Session(&Session{

    override val token: KaLifetimeToken
) : KaPackageSymbol(), KaLifetimeOwner {
    override val psi: PsiElement? by cached {
        JavaPsiFacade.getInstance(project).findPackage(fqName.asString())
            ?: KtPackage(PsiManager.getInstance(project), fqName, GlobalSearchScope.allScope(project)/*TODO*/)
    }

    override val origin: KaSymbolOrigin
        get() = withValidityAssertion { KaSymbolOrigin.SOURCE } // TODO

        KaAnalysisPermissionChecker.getInstance(project)
    }

    /**
     * Caches [KaBaseLifetimeTracker] to avoid repeated [Project.getService] calls in [analyze].
     */
    @KaCachedService
    private val lifetimeTracker by lazy(LazyThreadSafetyMode.PUBLICATION) {
        KaBaseLifetimeTracker.getInstance(project)
    }

        return KaFe10AnalysisHandlerExtension.getInstance(project, ktModule)
    }

    private fun <T : Any> T?.orThrowResolutionNotPerformedError(): T =
        this ?: error("Resolution is not performed")
}

class KaFe10AnalysisHandlerExtension(
    private val useSiteModule: KtSourceModule? = null
) : AnalysisHandlerExtension {
    internal companion object {