Output init_value = ops::Placeholder(root.WithOpName("init"), DT_FLOAT);
  Output loop_cond = ops::Placeholder(root.WithOpName("init"), DT_BOOL);
  Output enter_value =
      ops::internal::Enter(root.WithOpName("enter"), init_value, "fr");
  ops::Merge iv(root.WithOpName("iv"), {enter_value, enter_value});
  ops::Switch latch(root.WithOpName("latch"), iv.output, loop_cond);

		&metrics.HistogramOpts{
			Subsystem: SchedulerSubsystem,
			Name:      "pod_scheduling_sli_duration_seconds",
			Help:      "E2e latency for a pod being scheduled, from the time the pod enters the scheduling queue and might involve multiple scheduling attempts.",
			// Start with 10ms with the last bucket being [~88m, Inf).
			Buckets:        metrics.ExponentialBuckets(0.01, 2, 20),
			StabilityLevel: metrics.BETA,

func.func @testEnterOp(%arg0: tensor<i64> {tf.device = "/job:localhost/replica:0/task:0/device:TPU:0"}) -> tensor<i64> {
  %0 = tf_executor.graph {
    // CHECK:      tf_executor.Enter
    // CHECK-SAME: device = "/job:localhost/replica:0/task:0/device:TPU:0"
    %1:2 = tf_executor.Enter %arg0 frame "frame" : tensor<i64>
    tf_executor.fetch %1#0 : tensor<i64>
  }
  func.return %0 : tensor<i64>
}

// CHECK-LABEL: func @testExitOp

        this.session = session.withLocalRepository(localRepository)
                .withRemoteRepositories(Collections.singletonList(remoteRepository));
        InternalSession.associate(rss, this.session);
        sessionScope.enter();
        sessionScope.seed(InternalMavenSession.class, InternalMavenSession.from(this.session));
    }

    private Project project(Artifact artifact) {
        return session.getService(ProjectBuilder.class)

        }

        //
        // We enter the session scope right after the MavenSession creation and before any of the
        // AbstractLifecycleParticipant lookups
        // so that @SessionScoped components can be @Injected into AbstractLifecycleParticipants.
        //
        sessionScope.enter();
        MavenChainedWorkspaceReader chainedWorkspaceReader =

        Thread.currentThread().setContextClassLoader(pluginRealm);

        MavenSession oldSession = legacySupport.getSession();

        scope.enter();

        try {
            scope.seed(MavenProject.class, project);
            scope.seed(MojoExecution.class, mojoExecution);
            scope.seed(
                    org.apache.maven.api.plugin.Log.class,

	}
	for _, relations := range embeddedRelations.EmbeddedRelations {
		names = append(names, embeddedValues(relations)...)
	}
	return names
}

// preloadEntryPoint enters layer by layer. It will call real preload if it finds the right entry point.
// If the current relationship is embedded or joined, current query will be ignored.
//
//nolint:cyclop

	c.tinyAllocs = 0
	memstats.heapStats.release()

	// Update heapLive and heapScan.
	gcController.update(dHeapLive, scanAlloc)
}

// prepareForSweep flushes c if the system has entered a new sweep phase
// since c was populated. This must happen between the sweep phase
// starting and the first allocation from c.
func (c *mcache) prepareForSweep() {

        session.setAllProjects(session.getProjects());
        session.setSession(defaultSessionFactory.newSession(session));

        SessionScope sessionScope = getContainer().lookup(SessionScope.class);
        sessionScope.enter();
        sessionScope.seed(MavenSession.class, session);
        sessionScope.seed(Session.class, session.getSession());
        sessionScope.seed(InternalMavenSession.class, InternalMavenSession.from(session.getSession()));

    absl::flat_hash_set<Operation*> last_writes = GetLastWrites(resource);
    stack_down_.back()[resource] = last_writes;
  }
  Enter();
}

void SideEffectAnalysisInfo::Lateral() {
  Exit();
  Enter();
}

void SideEffectAnalysisInfo::Up() {
  Exit();
  for (const auto& [resource, last_writes] : stack_up_.back()) {
    SetLastWrites(resource, last_writes);
  }