One such optimization is called _incremental builds_.

An _incremental build_ is a build that avoids running tasks whose inputs did not change since the previous build, making the execution of such tasks unnecessary.

For incremental builds to work, tasks must define their inputs and outputs. At build time, Gradle will determine whether the input or outputs have changed. If they have changed, Gradle will execute the task. Otherwise, it will skip execution.

            try {
                String location = System.getProperty("input.file");
                BufferedReader reader = new BufferedReader(new FileReader(location));
                String input = reader.readLine();
                reader.close();
                FileWriter out = new FileWriter(args[args.length - 1], false);
                out.write(input);
                out.close();
            } catch (IOException e) {

// Returns the tf.Equal/tf.NotEqual result type given `x` and `y` and inputs. If
// `incompatible_shape_error` is true, reports error if `x` and `y` has
// incompatible shapes. Otherwise, returns a tensor type with unknown rank.
Type DeduceEqualCmpOpType(Builder *builder, Location loc, Value x, Value y,
                          BoolAttr incompatible_shape_error);

Type InferReductionOpType(Value input, Value reduction_indices,

	if len(a) != len(b) {
		panic("crypto/ecdh: internal error: mismatched isLess inputs")
	}

	// Copy the values into a fixed-size preallocated little-endian buffer.
	// 72 bytes is enough for every scalar in this package, and having a fixed
	// size lets us avoid heap allocations.
	if len(a) > 72 {
		panic("crypto/ecdh: internal error: isLess input too large")
	}
	bufA, bufB := make([]byte, 72), make([]byte, 72)

    if (op.getAdjX()) std::swap(equation[3], equation[4]);
    if (op.getAdjY()) std::swap(equation[6 + 3], equation[6 + 4]);

    rewriter.replaceOpWithNewOp<TF::EinsumOp>(
        op, op.getType(),
        /*inputs=*/ValueRange({input_lhs, input_rhs}),
        /*equation=*/equation);

    return success();
  }
};

#define GEN_PASS_DEF_BATCHMATMULTOEINSUMPASS

== Incremental builds

An *incremental build* is a build that avoids running tasks whose inputs have not changed since the previous build.
Re-executing such tasks is unnecessary if they would only re-produce the same output.

For incremental builds to work, tasks must define their inputs and outputs.
Gradle will determine whether the input or outputs have changed at build time.
If they have changed, Gradle will execute the task.

#define GEN_PASS_DEF_ANNOTATEPARAMETERREPLICATIONPASS
#include "tensorflow/compiler/mlir/tensorflow/transforms/tf_device_passes.h.inc"

// Analyzes the inputs to ClusterFuncOps in the module, and annotates their
// invoked functions whether each input has the same data across replicas.
struct AnnotateParameterReplicationPass
    : public impl::AnnotateParameterReplicationPassBase<
          AnnotateParameterReplicationPass> {

// RUN: stablehlo-quant-opt %s -stablehlo-test-post-calibration-component \
// RUN:   -split-input-file | FileCheck %s
// RUN: stablehlo-quant-opt %s -stablehlo-test-post-calibration-component='unpack-quantized-types=false' \
// RUN:   -split-input-file | FileCheck %s --check-prefix=CHECK-NO-UNPACK

// Tests that a simple dot_general (lifted as a function) with CustomAggregators
// around it is quantized. The resulting graph has quantized types unpacked into
// int ops.

        val gradleUserHomeDir: File,
        val jvm: String,
        val startParameterProperties: Map<String, Any?>,
        /**
         * Whether the undeclared inputs accessed while serializing the task graph will be
         * excluded from input tracking. This is a temporary opt-out flag after a change
         * was made in that behavior.
         */
        val ignoreInputsInConfigurationCacheTaskGraphWriting: Boolean,

func.func @while_main(%arg0: tensor<?x256x256xf32>) -> (tensor<i32>, tensor<256x256xf32>, tensor<?x256x256xf32>) attributes {tf.entry_function = {inputs = "input", outputs = "Identity,Identity_1,Identity_2"}} {
  %cst = arith.constant dense<1.000000e+00> : tensor<256x256xf32>
  %cst_0 = arith.constant dense<0> : tensor<i32>
  %cst_1 = arith.constant dense<-1> : tensor<i32>