strings::StrAppend(&body, "  ", return_on_error, "\n");

  for (int i = 0; i < op_info.graph_op_def.input_arg_size(); ++i) {
    const auto& arg(op_info.graph_op_def.input_arg(i));
    const auto& api_def_arg(op_info.api_def.in_arg(i));
    strings::StrAppend(
        &body, "  auto _", api_def_arg.rename_to(), " = ::tensorflow::ops::",
        ArgIsList(arg) ? "AsNodeOutList" : "AsNodeOut", "(", scope_str, ", ",

      "    tensorflow::ops::$0(scope.WithOpName(\"output\")$1);\n",
      op_info.op_name,
      strings::StrCat(
          op_info.api_def.arg_order().empty()
              ? absl::StrJoin(op_info.api_def.in_arg(), "",
                              [](string* out, const auto api_def_arg) {
                                strings::StrAppend(out, ", ",
                                                   api_def_arg.name());

// license that can be found in the LICENSE file.

#include "textflag.h"

TEXT _rt0_amd64_plan9(SB),NOSPLIT,$24
	MOVQ	AX, _tos(SB)
	LEAQ	16(SP), AX
	MOVQ	AX, _privates(SB)
	MOVL	$1, _nprivates(SB)
	MOVL	inargc-8(FP), DI
	LEAQ	inargv+0(FP), SI
	MOVQ	$runtime·rt0_go(SB), AX
	JMP	AX

GLOBL _tos(SB), NOPTR, $8
GLOBL _privates(SB), NOPTR, $8

#include "textflag.h"

TEXT _rt0_386_plan9(SB),NOSPLIT,$12
	MOVL	AX, _tos(SB)
	LEAL	8(SP), AX
	MOVL	AX, _privates(SB)
	MOVL	$1, _nprivates(SB)
	CALL	runtime·asminit(SB)
	MOVL	inargc-4(FP), AX
	MOVL	AX, 0(SP)
	LEAL	inargv+0(FP), AX
	MOVL	AX, 4(SP)
	JMP	runtime·rt0_go(SB)

GLOBL _tos(SB), NOPTR, $4
GLOBL _privates(SB), NOPTR, $4

				fmt.Fprintf(&buf, "%s%s", sep, gnuArg(inst, -1, Reg(i)))
				sep = ", "
			}
		}
		fmt.Fprintf(&buf, "}")
		return buf.String()

	case RegShift:
		if arg.Shift == ShiftLeft && arg.Count == 0 {
			return gnuArg(inst, -1, arg.Reg)
		}
		if arg.Shift == RotateRightExt {
			return gnuArg(inst, -1, arg.Reg) + ", rrx"
		}

			name := []string{"pli", "pla"}
			str = fmt.Sprintf("%s %s,%s",
				name[r&1],
				gnuArg(&inst, 0, inst.Args[0], PC),
				gnuArg(&inst, 2, inst.Args[2], PC))
			startArg = 4
		} else {
			str = fmt.Sprintf("%s %s,%s,%s", opName,
				gnuArg(&inst, 0, inst.Args[0], PC),
				gnuArg(&inst, 1, inst.Args[1], PC),
				gnuArg(&inst, 2, inst.Args[2], PC))
			startArg = 4
			if r == 1 {

        boolean inPara = false;
        if (node instanceof Element) {
            Element element = (Element) node;
            if (element.getTagName().equals("para") && stack.getFirst().getTagName().equals("para")) {
                pop();
                inPara = true;
            }
        }
        stack.getFirst().appendChild(node);
        if (inPara) {

type Label uint32

func (Label) IsArg() {}
func (l Label) String() string {
	return fmt.Sprintf("%#x", uint32(l))
}

// Imm represents an immediate number.
type Imm int64

func (Imm) IsArg() {}
func (i Imm) String() string {
	return fmt.Sprintf("%d", int32(i))
}

// Offset represents a memory offset immediate.
type Offset int64

func (Offset) IsArg() {}
func (o Offset) String() string {

    }
  }

  public void testNonStaticOneArgMethodsThatShouldPass() throws Exception {
    OneArg foo = new OneArg();
    for (String methodName : NONSTATIC_ONE_ARG_METHODS_SHOULD_PASS) {
      Method method = OneArg.class.getMethod(methodName, String.class);
      try {
        new NullPointerTester().testMethodParameter(foo, method, 0);
      } catch (AssertionError unexpected) {

	{"variable declared by template", `{{template "nested" $x:=.SI}},{{index $x 1}}`, "[3 4 5],4", tVal, true},

	// User-defined function: test argument evaluator.
	{"testFunc literal", `{{oneArg "joe"}}`, "oneArg=joe", tVal, true},
	{"testFunc .", `{{oneArg .}}`, "oneArg=joe", "joe", true},
}

// These strings are also in testdata/*.
const multiText1 = `
	{{define "x"}}TEXT{{end}}
	{{define "dotV"}}{{.V}}{{end}}
`

const multiText2 = `