}
}
// end::publish-modify-component[]

// tag::repo-url-from-variable[]
// tag::repo-url-from-project-property[]
publishing {
    repositories {
        maven {
            def releasesRepoUrl = layout.buildDirectory.dir('repos/releases')
            def snapshotsRepoUrl = layout.buildDirectory.dir('repos/snapshots')
// end::repo-url-from-variable[]

  DataType dtype = std::get<0>(test_params);
  std::vector<int64_t> shape_vector = std::get<1>(test_params);
  TensorShape shape(shape_vector);

  // Create the variable.
  Status status;
  std::unique_ptr<Variable> var;
  TF_EXPECT_OK(Variable::CreateUninitialized(context(), dtype, shape,
                                             absl::nullopt, nullptr, {}, &var));

  // Create a TensorHandle

			opts: []VersionedOptions{
				{IntroducedVersion: version.MajorMinor(1, 28), EnvOptions: []cel.EnvOption{cel.Variable("fizz", cel.StringType)}},
			},
		},
		{
			name: "user defined variable enabled",
			typeVersionCombinations: []envTypeAndVersion{
				{version.MajorMinor(1, 28), NewExpressions},
				{version.MajorMinor(1, 27), StoredExpressions},
			},

// Snapshot of resource variables for a TF kernel invocation, mapping from
// parameter number to values at execution time. If the resource variable is not
// initialized, the value will not be present.
using ResourceVarsSnapshot = absl::flat_hash_map<int, std::optional<Tensor>>;

// Takes a snapshot of the values of resource variable arguments, whose indices
// are specified in `variable_indices` argument. We snapshot tensors that back

    }
}
// end::publish-modify-component[]

// tag::repo-url-from-variable[]
// tag::repo-url-from-project-property[]
publishing {
    repositories {
        maven {
            val releasesRepoUrl = layout.buildDirectory.dir("repos/releases")
            val snapshotsRepoUrl = layout.buildDirectory.dir("repos/snapshots")
// end::repo-url-from-variable[]

	for i := 0; i < n; i++ { // ERROR "Induction variable: limits \[0,\?\), increment 1"
		s[i] = 1 // ERROR "Proved IsInBounds$"
	}
	return s
}

func make2(n int) []int {
	s := make([]int, n)
	for i := range s { // ERROR "Induction variable: limits \[0,\?\), increment 1"
		s[i] = 1 // ERROR "Proved IsInBounds$"
	}
	return s
}

// The range tests below test the index variable of range loops.

class EnvironmentVariableValueSourceTest extends ValueSourceBasedSpec {

    def "environment variable has no value when variable name has no value"() {
        given:
        def provider = createProviderOf(EnvironmentVariableValueSource) {
            // give variable name no value
        }

        expect:
        !provider.isPresent()
    }

	t1 int = i + j
	t2 int = i /* ERROR "mismatched types" */ + x
	t3 int = c /* ERRORx `cannot use .* variable declaration` */ + d
	t4 string = s + t
	t5 string = s /* ERROR "invalid operation" */ / t
	t6 byte = array[t1]
	t7 byte = array[x /* ERROR "must be integer" */]
	t8 *int = & /* ERRORx `cannot use .* variable declaration` */ a
	t10 *int = &42 /* ERROR "cannot take address" */
	t11 *complex64 = &v

// placed in 'filepath'.
//
// If the TF_DUMP_GRAPH_PREFIX environment variable is kCrashReproducerStdErr,
// then the LOG(INFO) macro is used instead.
//
// This will create a file name via prefixing `name` with the value of the
// TF_DUMP_GRAPH_PREFIX environment variable if `dirname` is empty and
// suffixing `name` with ".mlir".
Status CreateFileForDumping(llvm::StringRef name,

    )

    /**
     * Represents a local variable reassignment.
     */
    public class VariableReassignment(
        /** The reassignment expression. */
        public val expression: KtExpression,

        /** Reassigned variable symbol. */
        public val variable: KaVariableLikeSymbol,

        /** `true` if the variable is both read and set (as in `x += y` or `x++`). */