return func(v, x Element) bool {
		x1, v1 := x, x

		// Calculate a reference f(x) without aliasing.
		if out := f(&v, &x); out != &v && isInBounds(out) {
			return false
		}

		// Test aliasing the argument and the receiver.
		if out := f(&v1, &v1); out != &v1 || v1 != v {
			return false
		}

		// Ensure the arguments was not modified.
		return x == x1
	}
}

package issue26213

/*
#include "jni.h"
*/
import "C"
import (
	"testing"
)

func Test26213(t *testing.T) {
	var x1 C.jobject = 0 // Note: 0, not nil. That makes sure we use uintptr for these types.
	_ = x1
	var x2 C.jclass = 0
	_ = x2
	var x3 C.jthrowable = 0
	_ = x3
	var x4 C.jstring = 0
	_ = x4
	var x5 C.jarray = 0
	_ = x5
	var x6 C.jbooleanArray = 0
	_ = x6

 * Called from standard RISCV ELF psABI, where x8-x9, x18-x27, f8-f9 and
 * f18-f27 are callee-save, so they must be saved explicitly, along with
 * x1 (LR).
 */
.globl crosscall1
crosscall1:
	sd	x1, -200(sp)
	addi	sp, sp, -200
	sd	x8, 8(sp)
	sd	x9, 16(sp)
	sd	x18, 24(sp)
	sd	x19, 32(sp)
	sd	x20, 40(sp)
	sd	x21, 48(sp)
	sd	x22, 56(sp)
	sd	x23, 64(sp)
	sd	x24, 72(sp)

(BIC x0 x1:(SLLconst [c] y)) && clobberIfDead(x1) => (BICshiftLL x0 y [c])
(BIC x0 x1:(SRLconst [c] y)) && clobberIfDead(x1) => (BICshiftRL x0 y [c])
(BIC x0 x1:(SRAconst [c] y)) && clobberIfDead(x1) => (BICshiftRA x0 y [c])
(BIC x0 x1:(RORconst [c] y)) && clobberIfDead(x1) => (BICshiftRO x0 y [c])
(ORN x0 x1:(SLLconst [c] y)) && clobberIfDead(x1) => (ORNshiftLL x0 y [c])

var ZR Rectangle

// Rect is shorthand for [Rectangle]{Pt(x0, y0), [Pt](x1, y1)}. The returned
// rectangle has minimum and maximum coordinates swapped if necessary so that
// it is well-formed.
func Rect(x0, y0, x1, y1 int) Rectangle {
	if x0 > x1 {
		x0, x1 = x1, x0
	}
	if y0 > y1 {
		y0, y1 = y1, y0
	}
	return Rectangle{Point{x0, y0}, Point{x1, y1}}
}

  TensorShape shape({3, 2, 5});
  auto x1 = Placeholder(scope_, DT_FLOAT, Placeholder::Shape(shape));
  // Test with x2 = 1 + |x1| to avoid regions where the gradient
  // is unstable and might cause problems for the numeric estimator.
  auto x2 =
      Div(scope_, x1, Add(scope_, Const<float>(scope_, 1), Abs(scope_, x1)));
  auto y = Atan2(scope_, x1, x2);
  RunTest({x1}, {shape}, {y}, {shape});
}

		// Diagonal round.
		x0, x4, x8, x12 = quarterRound(x0, x4, x8, x12)
		x1, x5, x9, x13 = quarterRound(x1, x5, x9, x13)
		x2, x6, x10, x14 = quarterRound(x2, x6, x10, x14)
		x3, x7, x11, x15 = quarterRound(x3, x7, x11, x15)

		// Column round.
		x0, x5, x10, x15 = quarterRound(x0, x5, x10, x15)
		x1, x6, x11, x12 = quarterRound(x1, x6, x11, x12)
		x2, x7, x8, x13 = quarterRound(x2, x7, x8, x13)

		PAND X12, X8
		PAND X12, X9
		PAND X12, X10
		PAND X12, X11

		PXOR X4, X0
		PXOR X5, X1
		PXOR X6, X2
		PXOR X7, X3

		PXOR X8, X0
		PXOR X9, X1
		PXOR X10, X2
		PXOR X11, X3

		DECQ AX
		JNE loop_select_base

	MOVOU X0, (16*0)(DX)
	MOVOU X1, (16*1)(DX)
	MOVOU X2, (16*2)(DX)
	MOVOU X3, (16*3)(DX)

	RET
/* ---------------------------------------*/

		f2 := func(v1 T) string {
			return Stringer(v1).String()
		}
		x4 := f2(v)

		if x1 != x2 || x2 != x3 || x3 != x4 {
			panic(fmt.Sprintf("Mismatched values %v, %v, %v, %v\n", x1, x2, x3, x4))
		}

		ret = append(ret, v.String())
	}
	return ret
}

type Ints interface {
	~int32 | ~int
}

	MOVUPS X0, 28(SP)
	MOVUPS X1, 44(SP)
	MOVUPS X2, 60(SP)
	MOVUPS X3, 76(SP)
	MOVUPS X4, 92(SP)
	MOVUPS X5, 108(SP)
	MOVUPS X6, 124(SP)
	MOVUPS X7, 140(SP)
	#endif
	CALL ·asyncPreempt2(SB)
	#ifndef GO386_softfloat
	MOVUPS 140(SP), X7
	MOVUPS 124(SP), X6
	MOVUPS 108(SP), X5
	MOVUPS 92(SP), X4
	MOVUPS 76(SP), X3
	MOVUPS 60(SP), X2
	MOVUPS 44(SP), X1
	MOVUPS 28(SP), X0
	#endif
	MOVL 24(SP), DI