protected AssertionUtil() {
    }

    /**
     * Asserts that the argument is not <code>null</code>.
     *
     * @param argName
     *            The name of the argument that must not be {@code null}.
     * @param argValue
     *            The value of the argument.
     * @throws NullArgumentException
     *             If the argument is <code>null</code>.
     */

		name:   name,
		args:   args,
		tokens: tokens,
	}
}

// macroDefinition returns the list of formals and the tokens of the definition.
// The argument list is nil for no parens on the definition; otherwise a list of
// formal argument names.
func (in *Input) macroDefinition(name string) ([]string, []Token) {
	prevCol := in.Stack.Col()
	tok := in.Stack.Next()
	if tok == '\n' || tok == scanner.EOF {

// arguments of [cmp.Ordered] types. There must be at least one argument.
// If T is a floating-point type and any of the arguments are NaNs,
// max will return NaN.
func max[T cmp.Ordered](x T, y ...T) T

// The min built-in function returns the smallest value of a fixed number of
// arguments of [cmp.Ordered] types. There must be at least one argument.

    }

    /**
     * Returns the element type of the parameterized collection declared as the method's argument type.
     *
     * @param method
     *            The method. Cannot be {@literal null}
     * @param position
     *            The position of the parameterized collection in the method's argument list
     * @return The element type of the parameterized collection
     */

   *     "192.168.0.1"} or {@code "2001:db8::1"} or with a scope ID, e.g. {@code "2001:db8::1%eth0"}
   * @return {@link InetAddress} representing the argument
   * @throws IllegalArgumentException if the argument is not a valid IP string literal or if the
   *     address has a scope ID that fails validation against the interfaces on the machine (as
   *     required by Java's {@link InetAddress})
   */

		case sys.PPC64:
			if arch.IsPPC64CMP(op) {
				// CMPW etc.; third argument is a CR register that goes into prog.Reg.
				prog.From = a[0]
				prog.Reg = p.getRegister(prog, op, &a[2])
				prog.To = a[1]
				break
			}

			prog.From = a[0]
			prog.To = a[2]

			// If the second argument is not a register argument, it must be
			// passed RestArgs/AddRestSource
			switch a[1].Type {

   *     "192.168.0.1"} or {@code "2001:db8::1"} or with a scope ID, e.g. {@code "2001:db8::1%eth0"}
   * @return {@link InetAddress} representing the argument
   * @throws IllegalArgumentException if the argument is not a valid IP string literal or if the
   *     address has a scope ID that fails validation against the interfaces on the machine (as
   *     required by Java's {@link InetAddress})
   */

    }

    /**
     * If the argument type at the specified position is a number, converts the argument to match the type.
     *
     * @param paramTypes
     *            array of parameter types
     * @param args
     *            array of arguments
     * @param index
     *            index of the argument to operate on
     * @return {@literal true} if the argument was converted to match the type
     */

   *     null} is treated as the four-character string {@code "null"}.
   * @param args the arguments to be substituted into the message template. The first argument
   *     specified is substituted for the first occurrence of {@code "%s"} in the template, and so
   *     forth. A {@code null} argument is converted to the four-character string {@code "null"};

     * <li>If <code>type</code> is an array, the actual class of its elements is returned.</li>
     * <li>Otherwise, <code>null</code> is returned.</li>
     * </ul>
     *
     * @param type
     *            the type to analyze
     * @param map
     *            the map that contains the type variables and type arguments