currentImplementation, currentAdditionalImplementations,
            executable);

        // Capture non-file input changes
        ChangeContainer inputPropertyChanges = new PropertyChanges(
            lastExecution.getInputProperties().keySet(),
            thisExecution.getInputProperties().keySet(),
            "Input",
            executable);
        ChangeContainer inputPropertyValueChanges = new InputValueChanges(

    @Override
    public void transform(TransformOutputs outputs) {
        File input = getInput().get().getAsFile();
        doTransform(input, outputs);
        if (getParameters().getAgentSupported().get()) {
            doOutputOriginalArtifact(input, outputs);
        }
    }

    @Override
    protected InterceptorTypeRegistryAndFilter provideInterceptorTypeRegistryAndFilter() {

LogicalResult FoldOperation(OpBuilder& builder, Operation* op,
                            SmallVector<Value>& results) {
  SmallVector<ElementsAttr> inputs;
  for (auto operand : op->getOperands()) {
    auto preceding_const_op = operand.getDefiningOp<TF::ConstOp>();
    if (preceding_const_op) {
      inputs.push_back(preceding_const_op.getValue());
      continue;
    }

    Operation* preceding_op = operand.getDefiningOp();

        }
    }

    @OutputDirectory
    public File getOutputDir() {
        return outputDir;
    }

    @Input
    public int getOutputSize() {
        return outputSize;
    }

    public void setOutputSize(int outputSize) {
        this.outputSize = outputSize;
    }

    @Input
    public IsolationMode getIsolationMode() {
        return isolationMode;
    }

  // Tensors: Vector of tensors that back the TensorValue inputs
  // Inputs: Vector of inputs that are backed by tensors.
  mlir::LogicalResult PrepareKernelInputs(
      const llvm::SmallDenseSet<int>& required_consts,
      std::vector<tensorflow::XlaExpression>& expressions,
      std::vector<tensorflow::Tensor>& tensors,
      std::vector<tensorflow::TensorValue>& inputs);

    }

    def "can capture user input if standard input was provided"() {
        when:
        withConnection { ProjectConnection connection ->
            runBuildWithStandardInput(connection)
        }

        then:
        output.contains(PROMPT)
        output.contains(answerOutput(true))
    }

    def "cannot capture user input if standard input was not provided"() {
        when:

    }

    def "after failed unpacking error is propagated and output is not removed"() {
        def input = temporaryFolder.createFile("input")
        def outputFile = temporaryFolder.file("output.txt")
        def entity = this.entity(prop("output", FILE, outputFile))

        when:
        packOperationExecutor.unpack(key, entity, input)

        then:

        [new ThisIsAThingTypeAnnotationHandler()],
        [
            new SimplePropertyAnnotationHandler(TestNested, INPUT, [ItDepends]),
            new SimplePropertyAnnotationHandler(Long, INPUT, [ItDepends, Tint]),
            new SimplePropertyAnnotationHandler(Short, INPUT, [Tint]),
        ],
        [ItDepends, Tint],
        typeAnnotationMetadataStore,

	zDump.WorkloadState = rawDump.WorkloadState
	c.ztunnelDump = zDump
	return nil
}

func unmarshalListOrMap[T any](input json.RawMessage, i *[]T) error {
	if len(input) == 0 {
		return nil
	}
	if input[0] == '[' {
		return json.Unmarshal(input, i)
	}
	m := make(map[string]T)
	if err := json.Unmarshal(input, &m); err != nil {
		return err
	}
	*i = maps.Values(m)
	return nil
}

        return failure();
      }
    }

    // Input rhs must be a constant with rank 2.
    if (constant.getType().getRank() != 2) return failure();

    // Create a tfl.transpose op that performs ZX transpose on `input`.
    auto create_z_x_transpose_op = [&](Value input) -> Value {
      RankedTensorType input_type =
          mlir::cast<RankedTensorType>(input.getType());
      const int input_rank = input_type.getRank();