func.func @testInvalidWhileRegionConditionOutputType(%arg : tensor<i32>) -> (tensor<i32>) {
  // expected-error @+1 {{'tf.WhileRegion' op condition should have a single tensor<i1> result}}
  %0 = "tf.WhileRegion"(%arg) (
     {
       ^bb0(%carg: tensor<i32>):
        "tf.Yield"(%carg) : (tensor<i32>) -> ()
     },
     {
       ^bb0(%barg: tensor<i32>):
        "tf.Yield"(%barg) : (tensor<i32>) -> ()
     }

                                      data_types, outside_compilation_nodes, g,
                                      n);

  // In body_graph, create new _Arg/_Retval nodes, and replace lifted arg
  // nodes with the new _Arg nodes.
  std::vector<Node*> lifted_arg_nodes;
  lifted_arg_nodes.reserve(
      lifted_arg_nodes_and_outside_compilation_nodes.size());
  std::transform(

tsushima.nagasaki.jp
unzen.nagasaki.jp
ando.nara.jp
gose.nara.jp
heguri.nara.jp
higashiyoshino.nara.jp
ikaruga.nara.jp
ikoma.nara.jp
kamikitayama.nara.jp
kanmaki.nara.jp
kashiba.nara.jp
kashihara.nara.jp
katsuragi.nara.jp
kawai.nara.jp
kawakami.nara.jp
kawanishi.nara.jp
koryo.nara.jp
kurotaki.nara.jp
mitsue.nara.jp
miyake.nara.jp
nara.nara.jp
nosegawa.nara.jp
oji.nara.jp

		if x.Kind() == Invalid {
			panic("reflect: " + op + " using zero Value argument")
		}
	}
	for i := 0; i < n; i++ {
		if xt, targ := in[i].Type(), t.In(i); !xt.AssignableTo(toRType(targ)) {
			panic("reflect: " + op + " using " + xt.String() + " as type " + stringFor(targ))
		}
	}
	if !isSlice && isVariadic {
		// prepare slice for remaining values
		m := len(in) - n
		slice := MakeSlice(toRType(t.In(n)), m, m)

      // expected-remark@above {{ID: 11}}
        {
          ^bb0(%carg: tensor<i1>):
            %graph = tf_executor.graph {
            // expected-remark@above {{ID: 4}}
              %island:2 = tf_executor.island {
              // expected-remark@above {{ID: 2}}
                tf_executor.yield %carg : tensor<i1>
                // expected-remark@above {{ID: 1}}
              }

                                                       old_type, arg);
          arg.replaceAllUsesWith(arg_with_original_type);
          // The RAUW replaces the arg with itself, so we need to set it back.
          arg_with_original_type.setOperand(arg);
        }
      }
      new_input_types.push_back(arg.getType());
    }

  node_builder.Input(inputs);
  return opts.FinalizeBuilder(&node_builder);
}

Node* ArgOp(int index, DataType type, const GraphDefBuilder::Options& opts) {
  return ops::SourceOp("_Arg",
                       opts.WithAttr("T", type).WithAttr("index", index));
}

Node* RetOp(int index, ops::NodeOut a, const GraphDefBuilder::Options& opts) {
  if (opts.HaveError()) return nullptr;

	"⊯":                          "\u22af",
	"⊮":                          "\u22ae",
	"∇":                           "\u2207",
	"ń":                          "\u0144",
	"∠⃒":                            "\u2220\u20d2",
	"≉":                             "\u2249",
	"⩰̸":                            "\u2a70\u0338",
	"≋̸":                           "\u224b\u0338",

		"nGg;":                     {'\u22D9', '\u0338'},
		"nGtv;":                    {'\u226B', '\u0338'},
		"nLl;":                     {'\u22D8', '\u0338'},
		"nLtv;":                    {'\u226A', '\u0338'},
		"nang;":                    {'\u2220', '\u20D2'},
		"napE;":                    {'\u2A70', '\u0338'},
		"napid;":                   {'\u224B', '\u0338'},
		"nbump;":                   {'\u224E', '\u0338'},

	var firstPath string
	for _, arg := range args {
		if i := strings.Index(arg, "@"); i >= 0 {
			firstPath, version = arg[:i], arg[i+1:]
			if version == "" {
				return nil, fmt.Errorf("%s: version must not be empty", arg)
			}
			break
		}
	}
	patterns := make([]string, len(args))
	for i, arg := range args {
		p, found := strings.CutSuffix(arg, "@"+version)
		if !found {