std::vector<Output>* outputs) {
    DCHECK_EQ(inputs.size(), 1);
    outputs->emplace_back(ops::Subtract(scope, inputs[0], 1));
    return scope.status();
  };

  string frame_name = BackPropFrameName(while_ctx->frame_name());
  std::vector<Output> outputs;
  TF_RETURN_IF_ERROR(BuildWhileLoop(
      scope, {loop_count}, cond_fn, body_fn, frame_name, &outputs,

        run "compileGroovy"

        when:
        outputs.snapshot { applyGroovyFileSet(firstChange) }
        run "compileGroovy", "--info"

        then: 'first build'
        upToDateOrMessage(firstBuildMessage)
        outputs.recompiledClasses(firstCompiledClasses as String[])

        when: 'second build'
        outputs.snapshot { applyGroovyFileSet(secondChange) }
        run "compileGroovy", "--info"

        buildFile << """
            task first {
                outputs.file file("first.txt")
                outputs.cacheIf { true }
                doFirst {
                    file("first.txt").text = "Hello from the first task"
                }
            }

            task second {
                outputs.file file("second.txt")
                outputs.cacheIf { true }
                doFirst {

					reflect.ValueOf(a.GetObject()),
				})
			}
		}
	}
	for i := 1; i < len(outputs); i++ {
		if !apiequality.Semantic.DeepEqual(outputs[0], outputs[i]) {
			r.t.Errorf("expected mutating admission plugin to be idempontent, but got different results on reinvocation, diff:\n%s", cmp.Diff(outputs[0], outputs[i]))
		}
	}
	return nil
}

		reg: regInfo{
			outputs: []outputInfo{
				{0, 239}, // AX CX DX BX BP SI DI
			},
		},
	},
	{
		name:   "SETNE",
		argLen: 1,
		asm:    x86.ASETNE,
		reg: regInfo{
			outputs: []outputInfo{
				{0, 239}, // AX CX DX BX BP SI DI
			},
		},
	},
	{
		name:   "SETL",
		argLen: 1,
		asm:    x86.ASETLT,
		reg: regInfo{
			outputs: []outputInfo{

                          std::vector<Tensor>* outputs) const {
  return Run(FeedType{}, fetch_outputs, {}, outputs);
}

Status ClientSession::Run(const FeedType& inputs,
                          const std::vector<Output>& fetch_outputs,
                          std::vector<Tensor>* outputs) const {
  return Run(inputs, fetch_outputs, {}, outputs);
}

Status ClientSession::Run(const FeedType& inputs,

// CHECK:             buffer: 3,
// CHECK:             name: "outputs",
// CHECK:             quantization: {
// CHECK:             },
// CHECK:             has_rank: true
// CHECK:           } ],
// CHECK:           inputs: [ 0 ],
// CHECK:           outputs: [ 2 ],
// CHECK:           operators: [ {
// CHECK:             inputs: [ 1, 0 ],
// CHECK:             outputs: [ 2 ],
// CHECK:             builtin_options_type: AddOptions,

    }

    @get:PathSensitive(PathSensitivity.NONE)
    @get:InputArtifact
    abstract val input: Provider<FileSystemLocation>

    override fun transform(outputs: TransformOutputs) {
        val outputDirectory = outputs.dir("shadedClasses")
        val classesDir = outputDirectory.resolve(relocatedClassesDirName)
        classesDir.mkdir()
        val manifestFile = outputDirectory.resolve(manifestFileName)

        void transform(TransformOutputs outputs) {
            INVOCATION_COUNT.incrementAndGet()
            outputs.file(new File(inputArtifact.get().asFile, SELECTED_PATH))
            outputs.file("produced-file-1.txt").text = "produced1"
            outputs.dir(inputArtifact)
            outputs.file("produced-file-2.txt").text = "produced2"
        }
    }

// CHECK-NEXT:      shape: [  ],
// CHECK-NEXT:      buffer: 2,
// CHECK-NEXT:      name: "outputs",
// CHECK-NEXT:      quantization: {
// CHECK:           }
// CHECK-NEXT:    } ],
// CHECK-NEXT:    inputs: [ 0 ],
// CHECK-NEXT:    outputs: [ 1 ],
// CHECK-NEXT:    operators: [ {
// CHECK-NEXT:      inputs: [ 0, 0 ],
// CHECK-NEXT:      outputs: [ 1 ],
// CHECK-NEXT:      builtin_options_type: AddOptions,