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

	v2 := [2]int32{-1, 99}
	if v1 == v2 {
		panic("bad comparison")
	}

	w1 := [2]int16{-1, 88}
	w2 := [2]int16{-1, 99}
	if w1 == w2 {
		panic("bad comparison")
	}
	x1 := [4]int16{-1, 88, 88, 88}
	x2 := [4]int16{-1, 99, 99, 99}
	if x1 == x2 {
		panic("bad comparison")
	}

	a1 := [2]int8{-1, 88}
	a2 := [2]int8{-1, 99}
	if a1 == a2 {
		panic("bad comparison")
	}
	b1 := [4]int8{-1, 88, 88, 88}

	VPERMI2B X15, X1, K7, X31                          // 6242750f75ff
	VPERMI2B X0, X1, K7, X31                           // 6262750f75f8
	VPERMI2B X16, X1, K7, X31                          // 6222750f75f8
	VPERMI2B 17(SP), X1, K7, X31                       // 6262750f75bc2411000000
	VPERMI2B -17(BP)(SI*4), X1, K7, X31                // 6262750f75bcb5efffffff

replace (
	a v0.0.0 => ./a
	b v0.0.0 => ./b
	i v0.0.0 => ./i
	x v0.1.0 => ./x1
	x v0.2.0 => ./x2
)
-- main.go --
package main

import _ "a"

func main() {}
-- a/go.mod --
module a
go 1.13
require (
	x v0.2.0
	b v0.0.0
)
-- a/a.go --
package a
-- b/go.mod --
module b
go 1.13
require x v0.1.0
-- x1/go.mod --
module x
go 1.13
require (
	b v0.0.0
	i v0.0.0
)

 * 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)

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}}
}

(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])

		// 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)

	VCVTPS2QQ X19, K3, X1                              // 62b17d0b7bcb
	VCVTPS2QQ X13, K3, X1                              // 62d17d0b7bcd
	VCVTPS2QQ X2, K3, X1                               // 62f17d0b7bca
	VCVTPS2QQ (BX), K3, X1                             // 62f17d0b7b0b
	VCVTPS2QQ -17(BP)(SI*1), K3, X1                    // 62f17d0b7b8c35efffffff