attributes {tf_saved_model.exported_names = ["read_from_global"]} {
    // CHECK: [[name:%.*]] = "tf.VarHandleOp"
    // CHECK: "tf.ReadVariableOp"([[name]])
    %cond = builtin.unrealized_conversion_cast to tensor<i1>
    %0 = "tf.IfRegion"(%cond) ({
      "tf.Yield"(%arg0) : (tensor<!tf_type.resource<tensor<10xf32>>>) -> ()
    }, {
      "tf.Yield"(%arg0) : (tensor<!tf_type.resource<tensor<10xf32>>>) -> ()

				body = append(body, rangeAssign(nrange, hv1t))
			}
		}
	}

	typecheck.Stmts(init)

	nfor.PtrInit().Append(init...)

	typecheck.Stmts(nfor.Cond.Init())

	nfor.Cond = typecheck.Expr(nfor.Cond)
	nfor.Cond = typecheck.DefaultLit(nfor.Cond, nil)
	nfor.Post = typecheck.Stmt(nfor.Post)
	typecheck.Stmts(body)
	nfor.Body.Append(body...)
	nfor.Body.Append(nrange.Body...)

	var n ir.Node = nfor

	//
	// (previously, pkg.goVersion was mutated here: go.dev/issue/61212)

	// In go/types, conf._EnableAlias is controlled by gotypesalias.
	conf._EnableAlias = gotypesalias.Value() != "0"

	return &Checker{
		conf:    conf,
		ctxt:    conf.Context,
		fset:    fset,
		pkg:     pkg,
		Info:    info,
		version: asGoVersion(conf.GoVersion),
		objMap:  make(map[Object]*declInfo),
		impMap:  make(map[importKey]*Package),

                        assert project(":api").configurations.conf.state == Configuration.State.UNRESOLVED

                        configurations.conf.resolve()

                        assert configurations.conf.state == Configuration.State.RESOLVED
                        assert project(":api").configurations.conf.state == Configuration.State.UNRESOLVED

        for (SoftwareComponentVariant variant : component.getUsages()) {
            String conf = mapVariantNameToIvyConfiguration(variant.getName());
            configurations.maybeCreate(conf);
            if (defaultShouldExtend(variant)) {
                defaultConfiguration.extend(conf);
            }
        }

        return configurations;
    }

    /**

			}
		} else {
			impl = e.Conds[cond.tag]
			if impl == nil {
				return false, fmt.Errorf("unknown condition %q", cond.tag)
			}
			if impl.Usage().Prefix {
				return false, fmt.Errorf("condition %q requires a suffix", cond.tag)
			}
		}
		active, err := impl.Eval(s, suffix)

		if err != nil {
			return false, fmt.Errorf("evaluating condition %q: %w", cond.tag, err)
		}
		if active != cond.want {

    %cst = "tf.Const"() {value = dense<1> : tensor<i1>} : () -> tensor<i1>
    %0 = "tf.While"(%cst) {body = @while_body, cond = @while_cond, is_stateless = false} : (tensor<i1>) -> (tensor<i1>)
    return
  }
  func.func private @while_body(%arg0: tensor<i1>) -> (tensor<i1>) {
    // metadata ops

				"--leader-elect=true",
				"--kubeconfig=" + filepath.Join(kubeadmconstants.KubernetesDir, "scheduler.conf"),
				"--authentication-kubeconfig=" + filepath.Join(kubeadmconstants.KubernetesDir, "scheduler.conf"),
				"--authorization-kubeconfig=" + filepath.Join(kubeadmconstants.KubernetesDir, "scheduler.conf"),
			},
		},
	}

	for _, rt := range tests {
		t.Run(rt.name, func(t *testing.T) {

        settingsFile << 'rootProject.name = "test"'
        buildFile << """
            configurations { conf }
            repositories {
                maven { url "${mavenRepo.uri}" }
            }
            task resolvedFiles {
                dependsOn 'dependencies'
                def files = configurations.conf

                doLast {
                    println "resolved files=" + files*.name.toSorted()

		// for more information
		if cond.error != nil {
			existingConditions = setter(existingConditions, metav1.Condition{
				Type:               k,
				Status:             kstatus.InvertStatus(cond.status),
				ObservedGeneration: generation,
				LastTransitionTime: metav1.Now(),
				Reason:             cond.error.Reason,
				Message:            cond.error.Message,
			})
		} else {
			status := cond.status