STXVD2X	STAGE, (R0+OUTENC)
	STXVD2X	STAGE, (R0+OUTDEC)
	VCIPHERLAST	KEY, RCON, KEY           // vcipherlast 3,3,4
	ADD	$16, OUTENC, OUTENC
	ADD	$-16, OUTDEC, OUTDEC

	VSLDOI	$8, IN0, IN1, STAGE              // vsldoi 7,1,2,8
	VXOR	IN0, TMP, IN0                    // vxor 1,1,6
	VSLDOI	$12, ZERO, TMP, TMP              // vsldoi 6,0,6,12
	STXVD2X	STAGE, (R0+OUTENC)
	STXVD2X	STAGE, (R0+OUTDEC)

                    val name = "Compile script ${scriptPath.substringAfterLast(File.separator)} ($stage)"
                    return BuildOperationDescriptor.displayName(name).name(name).details(object : Details {
                        override fun getStage(): String = stage
                        override fun getLanguage(): String = "KOTLIN"
                    })
                }
            })

        given:
        file("src/main/java/compile/test/FxApp.java") << """
            import javafx.application.Application;
            import javafx.stage.Stage;

            public class FxApp extends Application {
                public void start(Stage stage) {
                }
            }
        """

        expect:
        succeeds("compileJava")
    }

	want := map[string]string{"pandas": "are awesome", "dogs": "are okay"}
	for _, event := range backend.events {
		if event.Stage != auditinternal.StageResponseComplete {
			t.Errorf("expected event stage to be complete, got: %s", event.Stage)
		}

		for wantK, wantV := range want {
			gotV, ok := event.Annotations[wantK]
			if !ok {

            if (state == null) {
                // This shouldn't be the case, however, start and complete events are filtered in the prior stage when the logging level is > lifecycle
                // Should instead move the filtering after this stage
                break;
            }
            if (state instanceof OperationGroup) {
                return (OperationGroup) state;
            }

message Event {
  // AuditLevel at which event was generated
  optional string level = 1;

  // Unique audit ID, generated for each request.
  optional string auditID = 2;

  // Stage of the request handling when this event instance was generated.
  optional string stage = 3;

  // RequestURI is the request URI as sent by the client to a server.
  optional string requestURI = 4;

  // Verb is the kubernetes verb associated with the request.

                "\npluginManagement { repositories {} }; include(\"stage-2\")"
            )

        val pluginManagementFragment =
            Program.PluginManagement(originalSource.fragment(1..15, 17..36))

        val scriptSource =
            originalSource.map { text("\n                               ; include(\"stage-2\")") }

        assertThat(

  bool strict_clusters =
      tensorflow::GetMlirCommonFlags()->tf_mlir_enable_strict_clusters;
  pm.addNestedPass<FuncOp>(
      mlir::tf_executor::CreateTFExecutorGraphPruningPass(ops_to_preserve));
  // It is assumed at this stage there are no V1 control flow ops as Graph
  // functionalization is ran before import. Ops can be lifted out of
  // tf_executor dialect islands/graphs.
  pm.addNestedPass<FuncOp>(

func (n name) tag() string {
	if !n.hasTag() {
		return ""
	}
	i, l := n.readVarint(1)
	i2, l2 := n.readVarint(1 + i + l)
	return unsafe.String(n.data(1+i+l+i2, "non-empty string"), l2)
}

func pkgPath(n abi.Name) string {
	if n.Bytes == nil || *n.DataChecked(0, "name flag field")&(1<<2) == 0 {
		return ""
	}
	i, l := n.ReadVarint(1)
	off := 1 + i + l
	if n.HasTag() {
		i2, l2 := n.ReadVarint(off)

				if auditEventGot == nil {
					t.Fatal("expected an audit event object but got nil")
				}
				if auditEventGot.Stage != auditinternal.StageResponseStarted {
					t.Errorf("expected audit event Stage: %s, but got: %s", auditinternal.StageResponseStarted, auditEventGot.Stage)
				}
				if auditEventGot.ResponseStatus == nil {
					t.Fatal("expected a ResponseStatus field of the audit event object, but got nil")
				}