abstract Provider<FileSystemLocation> getInput()

                void transform(TransformOutputs outputs) {
                    def inputFile = input.get().asFile
                    println "Transforming " + inputFile.name
                    def outputFile = outputs.file(inputFile.name + ".green")
                    outputFile.text = "green"
                }
            }
        """

        buildFile << """

            }

            // swap cost/newcost arrays
            int[] swap = cost; cost = newcost; newcost = swap;
        }

        // the distance is the cost for transforming all letters in both strings
        return cost[len0 - 1];
    }

 * for equality with the argument passed to {@code leaveDynamicCall}.
 * <p>
 * The implementations should be thread-safe and should support tracking the context in multiple threads.
 */
// TODO: consider transforming this to a more generic tool for tracking the events
//       of entering and leaving some generic context (marked with a key?)
@ServiceScope(Scope.CrossBuildSession.class)
public interface DynamicCallContextTracker {
    /**

                }
            }
        """

        when:
        run(":app:toBeFinalized", "withDependency")

        def lib1Message = "Transforming lib1.jar with MakeGreen"
        def lib2Message = "Transforming lib2.jar with MakeGreen"

        then:
        if (!GradleContextualExecuter.configCache) {

            // Not supported on Java 6
        }
    }

    public GroovyCompileTransformingClassLoader(ClassLoader parent, ClassPath classPath) {
        super("groovy-compile-transforming-loader", parent, classPath);
    }

    @Override
    protected byte[] transform(String className, byte[] bytes) {
        // First scan for annotation, and short circuit transformation if not present

#include "tensorflow/compiler/mlir/tf2xla/api/v2/device_type.pb.h"
#include "tensorflow/core/lib/core/status.h"

namespace tensorflow {
namespace tf2xla {
namespace v2 {

// Run all the passes involved in transforming the graph before execution so
// that it is suitable for targeting devices when called with the TF 2 Function
// API. Users that need clustering with the Session API should use the v1 Bridge

        if (LOGGER.isInfoEnabled()) {
            LOGGER.info("Transforming {} with {}", subjectToTransform.getDisplayName(), transform.getDisplayName());
        }

        InputFingerprinter inputFingerprinter = context != null ? context.getService(InputFingerprinter.class) : globalInputFingerprinter;

// Writer wraps another io.Writer by transforming the bytes read.
// The user needs to call Close to flush unwritten bytes that may
// be buffered.
type Writer struct {
	w   io.Writer
	t   Transformer
	dst []byte

	// src[:n] contains bytes that have not yet passed through t.
	src []byte
	n   int
}

// NewWriter returns a new Writer that wraps w by transforming the bytes written
// via t. It calls Reset on t.

                }
        }

    override val visibility: Visibility
        get() = withValidityAssertion {
            // TODO: We should use resolvedStatus, because it can be altered by status-transforming compiler plugins. See KT-58572
            when (val possiblyRawVisibility = firSymbol.fir.visibility) {
                Visibilities.Unknown -> if (firSymbol.fir.isLocal) Visibilities.Local else Visibilities.Public

// Writer wraps another io.Writer by transforming the bytes read.
// The user needs to call Close to flush unwritten bytes that may
// be buffered.
type Writer struct {
	w   io.Writer
	t   Transformer
	dst []byte

	// src[:n] contains bytes that have not yet passed through t.
	src []byte
	n   int
}

// NewWriter returns a new Writer that wraps w by transforming the bytes written
// via t. It calls Reset on t.