t4 := Must(t0.Clone())
	if _, err := t4.Parse(`{{define "lhs"}} OK {{end}}`); err != nil {
		t.Errorf(`redefine "lhs": got err %v want nil`, err)
	}
	// Cloning t1 should fail as it has been executed.
	if _, err := t1.Clone(); err == nil {
		t.Error("cloning t1: got nil err want non-nil")
	}
	// Redefining the "lhs" template in t1 should fail as it has been executed.
	if _, err := t1.Parse(`{{define "lhs"}} OK {{end}}`); err == nil {

  // negative sizes of the deallocations that are possible after the previous
  // operation.
  //
  // If we modify the operation sequence by cloning an operation range, that
  // memory profile will change--cloning makes it necessary to extend the
  // lifetime of some tensors, while other tensors can be deallocated early and
  // rematerialized later.
  //

  // Operation along with its respective operands and result Values(s).
  // The semantic of `Operation::clone` is copying given entity *into* this
  // entity. The new FuncOp body is populated by cloning partitioned ops into
  // it. Cloning Operation(s) will create cloned Value(s) for the results of a
  // cloned op, but it needs a reference to the new operand Value(s) which are

import (
	"internal/abi"
	"internal/stringslite"
	"unsafe"
)

// clone makes a copy of value, and may update string values found in value
// with a cloned version of those strings. The purpose of explicitly cloning
// strings is to avoid accidentally giving a large string a long lifetime.
//
// Note that this will clone strings in structs and arrays found in value,

//    will block us from clustering GPU_0_X and GPU_0_Y together since that
//    would increase the amount of work on GPU 0 waiting on work on GPU 1.
//    However, cloning Const into two copies, one for GPU_0_Y and one for GPU_1
//    will let us create one cluster containing {Const/copy_0, GPU_1} and
//    another containing {Const/copy_1, GPU_0_X, GPU_0_Y}.
//

                    dependencies {
                        compile 'test:test:1.2'
                    }
                    tasks.register('resolve') {
                        // Not a dependency, so that cloning happens at execution time (in parallel)
                        doLast {
                            configurations.compile.each { }
                        }
                    }
                }
            }

	// the drivers, then add a definition of T2 to the template name space.

	// 1. Clone the helper set to create a new name space from which to run them.
	first, err := drivers.Clone()
	if err != nil {
		log.Fatal("cloning helpers: ", err)
	}
	// 2. Define T2, version A, and parse it.
	_, err = first.Parse("{{define `T2`}}T2, version A{{end}}")
	if err != nil {
		log.Fatal("parsing T2: ", err)
	}

	// the drivers, then add a definition of T2 to the template name space.

	// 1. Clone the helper set to create a new name space from which to run them.
	first, err := drivers.Clone()
	if err != nil {
		log.Fatal("cloning helpers: ", err)
	}
	// 2. Define T2, version A, and parse it.
	_, err = first.Parse("{{define `T2`}}T2, version A{{end}}")
	if err != nil {
		log.Fatal("parsing T2: ", err)
	}

        absl::StrCat(GetInitializerType(src_func_op), "_", src_arg_idx, ":0");

    AddEntryFunctionInput(new_input_name, main_func_op);

    // During cloning, let it know that the source function's argument
    // corresponds to the main function's newly created argument when cloning
    // ops from src -> main.
    BlockArgument main_arg = main_func_op.getArgument(main_arg_idx);
    mapper.map(src_arg, main_arg);
  }

// to this pass:
//
// 1. TF currently relies on "sufficiently good shape inference" for
// correctness so for now the cost of doing this seems acceptable since
// pathological cases haven't hit us yet.
//
// 2. Cloning functions can help by allowing code to be specialized (much as
// inlining does). In fact, tf-shape-inference attempts to do specialization
// of callees which is difficult if callees have multiple uses.
class GuaranteeAllFuncsOneUse