// Copyright (c) 2026 Petr Balvín <opensource@petrbalvin.org> (https://petrbalvin.org)
// SPDX-License-Identifier: BSD-3-Clause

package asm

import (
	"os"
	"path/filepath"
	"testing"
)

// TestRISCVVecArith_Differential proves the vector arithmetic families
// against the toolchain: sections 31.11 through 31.16 of the "V"
// specification's arithmetic, reductions, mask, slide, gather, compress and
// whole-register-move material plus the Zvbb bit-manipulation and Zvbc
// carryless-multiplication extensions, in the toolchain's own testdata
// wording with every masked and unmasked form, assembled by gasm and by
// go tool asm must agree word for word.
func TestRISCVVecArith_Differential(t *testing.T) {
	src := `#include "textflag.h"

TEXT ·vecarith(SB), NOSPLIT, $0
	// 31.11.1: Vector Single-Width Integer Add and Subtract
	VADDVV		V1, V2, V3			// d7812002
	VADDVV		V1, V2, V0, V3			// d7812000
	VADDVX		X10, V2, V3			// d7412502
	VADDVX		X10, V2, V0, V3			// d7412500
	VADDVI		$15, V2, V3			// d7b12702
	VADDVI		$15, V2, V0, V3			// d7b12700
	VADDVI		$-16, V2, V3			// d7312802
	VADDVI		$-16, V2, V0, V3		// d7312800
	VSUBVV		V1, V2, V3			// d781200a
	VSUBVV		V1, V2, V0, V3			// d7812008
	VSUBVX		X10, V2, V3			// d741250a
	VSUBVX		X10, V2, V0, V3			// d7412508
	VRSUBVX		X10, V2, V3			// d741250e
	VRSUBVX		X10, V2, V0, V3			// d741250c
	VRSUBVI		$15, V2, V0, V3			// d7b1270c
	VRSUBVI		$-16, V2, V0, V3		// d731280c
	VNEGV		V2, V3				// d741200e
	VNEGV		V2, V0, V3			// d741200c

	// 31.11.2: Vector Widening Integer Add/Subtract
	VWADDUVV	V1, V2, V3			// d7a120c2
	VWADDUVV	V1, V2, V0, V3			// d7a120c0
	VWADDUVX	X10, V2, V3			// d76125c2
	VWADDUVX	X10, V2, V0, V3			// d76125c0
	VWSUBUVV	V1, V2, V3			// d7a120ca
	VWSUBUVV	V1, V2, V0, V3			// d7a120c8
	VWSUBUVX	X10, V2, V3			// d76125ca
	VWSUBUVX	X10, V2, V0, V3			// d76125c8
	VWADDVV		V1, V2, V3			// d7a120c6
	VWADDVV		V1, V2, V0, V3			// d7a120c4
	VWADDVX		X10, V2, V3			// d76125c6
	VWADDVX		X10, V2, V0, V3			// d76125c4
	VWSUBVV		V1, V2, V3			// d7a120ce
	VWSUBVV		V1, V2, V0, V3			// d7a120cc
	VWSUBVX		X10, V2, V3			// d76125ce
	VWSUBVX		X10, V2, V0, V3			// d76125cc
	VWADDUWV	V1, V2, V3			// d7a120d2
	VWADDUWV	V1, V2, V0, V3			// d7a120d0
	VWADDUWX	X10, V2, V3			// d76125d2
	VWADDUWX	X10, V2, V0, V3			// d76125d0
	VWSUBUWV	V1, V2, V3			// d7a120da
	VWSUBUWV	V1, V2, V0, V3			// d7a120d8
	VWSUBUWX	X10, V2, V3			// d76125da
	VWSUBUWX	X10, V2, V0, V3			// d76125d8
	VWADDWV		V1, V2, V3			// d7a120d6
	VWADDWV		V1, V2, V0, V3			// d7a120d4
	VWADDWX		X10, V2, V3			// d76125d6
	VWADDWX		X10, V2, V0, V3			// d76125d4
	VWSUBWV		V1, V2, V3			// d7a120de
	VWSUBWV		V1, V2, V0, V3			// d7a120dc
	VWSUBWX		X10, V2, V3			// d76125de
	VWSUBWX		X10, V2, V0, V3			// d76125dc
	VWCVTXXV	V2, V3				// d76120c6
	VWCVTXXV	V2, V0, V3			// d76120c4
	VWCVTUXXV	V2, V3				// d76120c2
	VWCVTUXXV	V2, V0, V3			// d76120c0

	// 31.11.3: Vector Integer Extension
	VZEXTVF2	V2, V3				// d721234a
	VZEXTVF2	V2, V0, V3			// d7212348
	VSEXTVF2	V2, V3				// d7a1234a
	VSEXTVF2	V2, V0, V3			// d7a12348
	VZEXTVF4	V2, V3				// d721224a
	VZEXTVF4	V2, V0, V3			// d7212248
	VSEXTVF4	V2, V3				// d7a1224a
	VSEXTVF4	V2, V0, V3			// d7a12248
	VZEXTVF8	V2, V3				// d721214a
	VZEXTVF8	V2, V0, V3			// d7212148
	VSEXTVF8	V2, V3				// d7a1214a
	VSEXTVF8	V2, V0, V3			// d7a12148

	// 31.11.4: Vector Integer Add-with-Carry / Subtract-with-Borrow Instructions
	VADCVVM		V1, V2, V0, V3			// d7812040
	VADCVXM		X11, V2, V0, V3			// d7c12540
	VADCVIM		$15, V2, V0, V3			// d7b12740
	VMADCVVM	V1, V2, V0, V3			// d7812044
	VMADCVVM	V1, V2, V0, V0			// 57802044
	VMADCVXM	X11, V2, V0, V3			// d7c12544
	VMADCVXM	X11, V2, V0, V0			// 57c02544
	VMADCVIM	$15, V2, V0, V3			// d7b12744
	VMADCVIM	$15, V2, V0, V0			// 57b02744
	VMADCVV		V1, V2, V3			// d7812046
	VMADCVV		V1, V2, V0			// 57802046
	VMADCVX		X11, V2, V3			// d7c12546
	VMADCVX		X11, V2, V0			// 57c02546
	VMADCVI		$15, V2, V3			// d7b12746
	VMADCVI		$15, V2, V0			// 57b02746
	VSBCVVM		V1, V2, V0, V3			// d7812048
	VSBCVXM		X11, V2, V0, V3			// d7c12548
	VMSBCVVM	V1, V2, V0, V3			// d781204c
	VMSBCVVM	V1, V2, V0, V0			// 5780204c
	VMSBCVXM	X11, V2, V0, V3			// d7c1254c
	VMSBCVXM	X11, V2, V0, V0			// 57c0254c
	VMSBCVV		V1, V2, V3			// d781204e
	VMSBCVV		V1, V2, V0			// 5780204e
	VMSBCVX		X11, V2, V3			// d7c1254e
	VMSBCVX		X11, V2, V0			// 57c0254e

	// 31.11.5: Vector Bitwise Logical Instructions
	VANDVV		V1, V2, V3			// d7812026
	VANDVV		V1, V2, V0, V3			// d7812024
	VANDVX		X11, V2, V3			// d7c12526
	VANDVX		X11, V2, V0, V3			// d7c12524
	VANDVI		$15, V2, V3			// d7b12726
	VANDVI		$15, V2, V0, V3			// d7b12724
	VORVV		V1, V2, V3			// d781202a
	VORVV		V1, V2, V0, V3			// d7812028
	VORVX		X11, V2, V3			// d7c1252a
	VORVX		X11, V2, V0, V3			// d7c12528
	VORVI		$15, V2, V3			// d7b1272a
	VORVI		$15, V2, V0, V3			// d7b12728
	VXORVV		V1, V2, V3			// d781202e
	VXORVV		V1, V2, V0, V3			// d781202c
	VXORVX		X11, V2, V3			// d7c1252e
	VXORVX		X11, V2, V0, V3			// d7c1252c
	VXORVI		$15, V2, V3			// d7b1272e
	VXORVI		$15, V2, V0, V3			// d7b1272c
	VNOTV		V2, V3				// d7b12f2e
	VNOTV		V2, V0, V3			// d7b12f2c

	// 31.11.6: Vector Single-Width Shift Instructions
	VSLLVV		V1, V2, V3			// d7812096
	VSLLVV		V1, V2, V0, V3			// d7812094
	VSLLVX		X11, V2, V3			// d7c12596
	VSLLVX		X11, V2, V0, V3			// d7c12594
	VSLLVI		$15, V2, V3			// d7b12796
	VSLLVI		$15, V2, V0, V3			// d7b12794
	VSRLVV		V1, V2, V3			// d78120a2
	VSRLVV		V1, V2, V0, V3			// d78120a0
	VSRLVX		X11, V2, V3			// d7c125a2
	VSRLVX		X11, V2, V0, V3			// d7c125a0
	VSRLVI		$15, V2, V3			// d7b127a2
	VSRLVI		$15, V2, V0, V3			// d7b127a0
	VSRAVV		V1, V2, V3			// d78120a6
	VSRAVV		V1, V2, V0, V3			// d78120a4
	VSRAVX		X11, V2, V3			// d7c125a6
	VSRAVX		X11, V2, V0, V3			// d7c125a4
	VSRAVI		$15, V2, V3			// d7b127a6
	VSRAVI		$15, V2, V0, V3			// d7b127a4

	// 31.11.7: Vector Narrowing Integer Right Shift Instructions
	VNSRLWV		V1, V2, V3			// d78120b2
	VNSRLWV		V1, V2, V0, V3			// d78120b0
	VNSRLWX		X10, V2, V3			// d74125b2
	VNSRLWX		X10, V2, V0, V3			// d74125b0
	VNSRLWI		$31, V2, V3			// d7b12fb2
	VNSRLWI		$31, V2, V0, V3			// d7b12fb0
	VNSRAWV		V1, V2, V3			// d78120b6
	VNSRAWV		V1, V2, V0, V3			// d78120b4
	VNSRAWX		X10, V2, V3			// d74125b6
	VNSRAWX		X10, V2, V0, V3			// d74125b4
	VNSRAWI		$31, V2, V3			// d7b12fb6
	VNSRAWI		$31, V2, V0, V3			// d7b12fb4
	VNCVTXXW	V2, V3				// d74120b2
	VNCVTXXW	V2, V0, V3			// d74120b0

	// 31.11.8: Vector Integer Compare Instructions
	VMSEQVV		V1, V2, V3			// d7812062
	VMSEQVV		V1, V2, V0, V3			// d7812060
	VMSEQVX		X10, V2, V3			// d7412562
	VMSEQVX		X10, V2, V0, V3			// d7412560
	VMSEQVI		$15, V2, V3			// d7b12762
	VMSEQVI		$15, V2, V0, V3			// d7b12760
	VMSNEVV		V1, V2, V3			// d7812066
	VMSNEVV		V1, V2, V0, V3			// d7812064
	VMSNEVX		X10, V2, V3			// d7412566
	VMSNEVX		X10, V2, V0, V3			// d7412564
	VMSNEVI		$15, V2, V3			// d7b12766
	VMSNEVI		$15, V2, V0, V3			// d7b12764
	VMSLTUVV	V1, V2, V3			// d781206a
	VMSLTUVV	V1, V2, V0, V3			// d7812068
	VMSLTUVX	X10, V2, V3			// d741256a
	VMSLTUVX	X10, V2, V0, V3			// d7412568
	VMSLTVV		V1, V2, V3			// d781206e
	VMSLTVV		V1, V2, V0, V3			// d781206c
	VMSLTVX		X10, V2, V3			// d741256e
	VMSLTVX		X10, V2, V0, V3			// d741256c
	VMSLEUVV	V1, V2, V3			// d7812072
	VMSLEUVV	V1, V2, V0, V3			// d7812070
	VMSLEUVX	X10, V2, V3			// d7412572
	VMSLEUVX	X10, V2, V0, V3			// d7412570
	VMSLEUVI	$15, V2, V3			// d7b12772
	VMSLEUVI	$15, V2, V0, V3			// d7b12770
	VMSLEVV		V1, V2, V3			// d7812076
	VMSLEVV		V1, V2, V0, V3			// d7812074
	VMSLEVX		X10, V2, V3			// d7412576
	VMSLEVX		X10, V2, V0, V3			// d7412574
	VMSLEVI		$15, V2, V3			// d7b12776
	VMSLEVI		$15, V2, V0, V3			// d7b12774
	VMSGTUVX	X10, V2, V3			// d741257a
	VMSGTUVX	X10, V2, V0, V3			// d7412578
	VMSGTUVI	$15, V2, V3			// d7b1277a
	VMSGTUVI	$15, V2, V0, V3			// d7b12778
	VMSGTVX		X10, V2, V3			// d741257e
	VMSGTVX		X10, V2, V0, V3			// d741257c
	VMSGTVI		$15, V2, V3			// d7b1277e
	VMSGTVI		$15, V2, V0, V3			// d7b1277c
	VMSGTVV		V1, V2, V3			// d701116e
	VMSGTVV		V1, V2, V0, V3			// d701116c
	VMSGTUVV	V1, V2, V3			// d701116a
	VMSGTUVV	V1, V2, V0, V3			// d7011168
	VMSGEVV		V1, V2, V3			// d7011176
	VMSGEVV		V1, V2, V0, V3			// d7011174
	VMSGEUVV	V1, V2, V3			// d7011172
	VMSGEUVV	V1, V2, V0, V3			// d7011170
	VMSLTVI		$15, V2, V3			// d7312776
	VMSLTVI		$15, V2, V0, V3			// d7312774
	VMSLTUVI	$15, V2, V3			// d7312772
	VMSLTUVI	$15, V2, V0, V3			// d7312770
	VMSGEVI		$15, V2, V3			// d731277e
	VMSGEVI		$15, V2, V0, V3			// d731277c
	VMSGEUVI	$15, V2, V3			// d731277a
	VMSGEUVI	$15, V2, V0, V3			// d7312778

	// 31.11.9: Vector Integer Min/Max Instructions
	VMINUVV		V1, V2, V3			// d7812012
	VMINUVV		V1, V2, V0, V3			// d7812010
	VMINUVX		X10, V2, V3			// d7412512
	VMINUVX		X10, V2, V0, V3			// d7412510
	VMINVV		V1, V2, V3			// d7812016
	VMINVV		V1, V2, V0, V3			// d7812014
	VMINVX		X10, V2, V3			// d7412516
	VMINVX		X10, V2, V0, V3			// d7412514
	VMAXUVV		V1, V2, V3			// d781201a
	VMAXUVV		V1, V2, V0, V3			// d7812018
	VMAXUVX		X10, V2, V3			// d741251a
	VMAXUVX		X10, V2, V0, V3			// d7412518
	VMAXVV		V1, V2, V3			// d781201e
	VMAXVV		V1, V2, V0, V3			// d781201c
	VMAXVX		X10, V2, V3			// d741251e
	VMAXVX		X10, V2, V0, V3			// d741251c

	// 31.11.10: Vector Single-Width Integer Multiply Instructions
	VMULVV		V1, V2, V3			// d7a12096
	VMULVV		V1, V2, V0, V3			// d7a12094
	VMULVX		X10, V2, V3			// d7612596
	VMULVX		X10, V2, V0, V3			// d7612594
	VMULHVV		V1, V2, V3			// d7a1209e
	VMULHVV		V1, V2, V0, V3			// d7a1209c
	VMULHVX		X10, V2, V3			// d761259e
	VMULHVX		X10, V2, V0, V3			// d761259c
	VMULHUVV	V1, V2, V3			// d7a12092
	VMULHUVV	V1, V2, V0, V3			// d7a12090
	VMULHUVX	X10, V2, V3			// d7612592
	VMULHUVX	X10, V2, V0, V3			// d7612590
	VMULHSUVV	V1, V2, V3			// d7a1209a
	VMULHSUVV	V1, V2, V0, V3			// d7a12098
	VMULHSUVX	X10, V2, V3			// d761259a
	VMULHSUVX	X10, V2, V0, V3			// d7612598

	// 31.11.11: Vector Integer Divide Instructions
	VDIVUVV		V1, V2, V3			// d7a12082
	VDIVUVV		V1, V2, V0, V3			// d7a12080
	VDIVUVX		X10, V2, V3			// d7612582
	VDIVUVX		X10, V2, V0, V3			// d7612580
	VDIVVV		V1, V2, V3			// d7a12086
	VDIVVV		V1, V2, V0, V3			// d7a12084
	VDIVVX		X10, V2, V3			// d7612586
	VDIVVX		X10, V2, V0, V3			// d7612584
	VREMUVV		V1, V2, V3			// d7a1208a
	VREMUVV		V1, V2, V0, V3			// d7a12088
	VREMUVX		X10, V2, V3			// d761258a
	VREMUVX		X10, V2, V0, V3			// d7612588
	VREMVV		V1, V2, V3			// d7a1208e
	VREMVV		V1, V2, V0, V3			// d7a1208c
	VREMVX		X10, V2, V3			// d761258e
	VREMVX		X10, V2, V0, V3			// d761258c

	// 31.11.12: Vector Widening Integer Multiply Instructions
	VWMULVV		V1, V2, V3			// d7a120ee
	VWMULVV		V1, V2, V0, V3			// d7a120ec
	VWMULVX		X10, V2, V3			// d76125ee
	VWMULVX		X10, V2, V0, V3			// d76125ec
	VWMULUVV	V1, V2, V3			// d7a120e2
	VWMULUVV	V1, V2, V0, V3			// d7a120e0
	VWMULUVX	X10, V2, V3			// d76125e2
	VWMULUVX	X10, V2, V0, V3			// d76125e0
	VWMULSUVV	V1, V2, V3			// d7a120ea
	VWMULSUVV	V1, V2, V0, V3			// d7a120e8
	VWMULSUVX	X10, V2, V3			// d76125ea
	VWMULSUVX	X10, V2, V0, V3			// d76125e8

	// 31.11.13: Vector Single-Width Integer Multiply-Add Instructions
	VMACCVV		V2, V1, V3			// d7a120b6
	VMACCVV		V2, V1, V0, V3			// d7a120b4
	VMACCVX		V2, X10, V3			// d76125b6
	VMACCVX		V2, X10, V0, V3			// d76125b4
	VNMSACVV	V2, V1, V3			// d7a120be
	VNMSACVV	V2, V1, V0, V3			// d7a120bc
	VNMSACVX	V2, X10, V3			// d76125be
	VNMSACVX	V2, X10, V0, V3			// d76125bc
	VMADDVV		V2, V1, V3			// d7a120a6
	VMADDVV		V2, V1, V0, V3			// d7a120a4
	VMADDVX		V2, X10, V3			// d76125a6
	VMADDVX		V2, X10, V0, V3			// d76125a4
	VNMSUBVV	V2, V1, V3			// d7a120ae
	VNMSUBVV	V2, V1, V0, V3			// d7a120ac
	VNMSUBVX	V2, X10, V3			// d76125ae
	VNMSUBVX	V2, X10, V0, V3			// d76125ac

	// 31.11.14: Vector Widening Integer Multiply-Add Instructions
	VWMACCUVV	V2, V1, V3			// d7a120f2
	VWMACCUVV	V2, V1, V0, V3			// d7a120f0
	VWMACCUVX	V2, X10, V3			// d76125f2
	VWMACCUVX	V2, X10, V0, V3			// d76125f0
	VWMACCVV	V2, V1, V3			// d7a120f6
	VWMACCVV	V2, V1, V0, V3			// d7a120f4
	VWMACCVX	V2, X10, V3			// d76125f6
	VWMACCVX	V2, X10, V0, V3			// d76125f4
	VWMACCSUVV	V2, V1, V3			// d7a120fe
	VWMACCSUVV	V2, V1, V0, V3			// d7a120fc
	VWMACCSUVX	V2, X10, V3			// d76125fe
	VWMACCSUVX	V2, X10, V0, V3			// d76125fc
	VWMACCUSVX	V2, X10, V3			// d76125fa
	VWMACCUSVX	V2, X10, V0, V3			// d76125f8

	// 31.11.15: Vector Integer Merge Instructions
	VMERGEVVM	V1, V2, V0, V3			// d781205c
	VMERGEVXM	X10, V2, V0, V3			// d741255c
	VMERGEVIM	$15, V2, V0, V3			// d7b1275c

	// 31.11.16: Vector Integer Move Instructions
	VMVVV		V2, V3				// d701015e
	VMVVX		X10, V3				// d741055e
	VMVVI		$15, V3				// d7b1075e

	// 31.12.1: Vector Single-Width Saturating Add and Subtract
	VSADDUVV	V1, V2, V3			// d7812082
	VSADDUVV	V1, V2, V0, V3			// d7812080
	VSADDUVX	X10, V2, V3			// d7412582
	VSADDUVX	X10, V2, V0, V3			// d7412580
	VSADDUVI	$15, V2, V3			// d7b12782
	VSADDUVI	$15, V2, V0, V3			// d7b12780
	VSADDVV		V1, V2, V3			// d7812086
	VSADDVV		V1, V2, V0, V3			// d7812084
	VSADDVX		X10, V2, V3			// d7412586
	VSADDVX		X10, V2, V0, V3			// d7412584
	VSADDVI		$15, V2, V3			// d7b12786
	VSADDVI		$15, V2, V0, V3			// d7b12784
	VSSUBUVV	V1, V2, V3			// d781208a
	VSSUBUVV	V1, V2, V0, V3			// d7812088
	VSSUBUVX	X10, V2, V3			// d741258a
	VSSUBUVX	X10, V2, V0, V3			// d7412588
	VSSUBVV		V1, V2, V3			// d781208e
	VSSUBVV		V1, V2, V0, V3			// d781208c
	VSSUBVX		X10, V2, V3			// d741258e
	VSSUBVX		X10, V2, V0, V3			// d741258c

	// 31.12.2: Vector Single-Width Averaging Add and Subtract
	VAADDUVV	V1, V2, V3			// d7a12022
	VAADDUVV	V1, V2, V0, V3			// d7a12020
	VAADDUVX	X10, V2, V3			// d7612522
	VAADDUVX	X10, V2, V0, V3			// d7612520
	VAADDVV		V1, V2, V3			// d7a12026
	VAADDVV		V1, V2, V0, V3			// d7a12024
	VAADDVX		X10, V2, V3			// d7612526
	VAADDVX		X10, V2, V0, V3			// d7612524
	VASUBUVV	V1, V2, V3			// d7a1202a
	VASUBUVV	V1, V2, V0, V3			// d7a12028
	VASUBUVX	X10, V2, V3			// d761252a
	VASUBUVX	X10, V2, V0, V3			// d7612528
	VASUBVV		V1, V2, V3			// d7a1202e
	VASUBVV		V1, V2, V0, V3			// d7a1202c
	VASUBVX		X10, V2, V3			// d761252e
	VASUBVX		X10, V2, V0, V3			// d761252c

	// 31.12.3: Vector Single-Width Fractional Multiply with Rounding and Saturation
	VSMULVV		V1, V2, V3			// d781209e
	VSMULVV		V1, V2, V0, V3			// d781209c
	VSMULVX		X10, V2, V3			// d741259e
	VSMULVX		X10, V2, V0, V3			// d741259c

	// 31.12.4: Vector Single-Width Scaling Shift Instructions
	VSSRLVV		V1, V2, V3			// d78120aa
	VSSRLVV		V1, V2, V0, V3			// d78120a8
	VSSRLVX		X10, V2, V3			// d74125aa
	VSSRLVX		X10, V2, V0, V3			// d74125a8
	VSSRLVI		$15, V2, V3			// d7b127aa
	VSSRLVI		$15, V2, V0, V3			// d7b127a8
	VSSRAVV		V1, V2, V3			// d78120ae
	VSSRAVV		V1, V2, V0, V3			// d78120ac
	VSSRAVX		X10, V2, V3			// d74125ae
	VSSRAVX		X10, V2, V0, V3			// d74125ac
	VSSRAVI		$16, V2, V3			// d73128ae
	VSSRAVI		$16, V2, V0, V3			// d73128ac

	// 31.12.5: Vector Narrowing Fixed-Point Clip Instructions
	VNCLIPUWV	V1, V2, V3			// d78120ba
	VNCLIPUWV	V1, V2, V0, V3			// d78120b8
	VNCLIPUWX	X10, V2, V3			// d74125ba
	VNCLIPUWX	X10, V2, V0, V3			// d74125b8
	VNCLIPUWI	$16, V2, V3			// d73128ba
	VNCLIPUWI	$16, V2, V0, V3			// d73128b8
	VNCLIPWV	V1, V2, V3			// d78120be
	VNCLIPWV	V1, V2, V0, V3			// d78120bc
	VNCLIPWX	X10, V2, V3			// d74125be
	VNCLIPWX	X10, V2, V0, V3			// d74125bc
	VNCLIPWI	$16, V2, V3			// d73128be
	VNCLIPWI	$16, V2, V0, V3			// d73128bc

	// 31.13.2: Vector Single-Width Floating-Point Add/Subtract Instructions
	VFADDVV		V1, V2, V3			// d7912002
	VFADDVV		V1, V2, V0, V3			// d7912000
	VFADDVF		F10, V2, V3			// d7512502
	VFADDVF		F10, V2, V0, V3			// d7512500
	VFSUBVV		V1, V2, V3			// d791200a
	VFSUBVV		V1, V2, V0, V3			// d7912008
	VFSUBVF		F10, V2, V3			// d751250a
	VFSUBVF		F10, V2, V0, V3			// d7512508
	VFRSUBVF	F10, V2, V3			// d751259e
	VFRSUBVF	F10, V2, V0, V3			// d751259c

	// 31.13.3: Vector Widening Floating-Point Add/Subtract Instructions
	VFWADDVV	V1, V2, V3			// d79120c2
	VFWADDVV	V1, V2, V0, V3			// d79120c0
	VFWADDVF	F10, V2, V3			// d75125c2
	VFWADDVF	F10, V2, V0, V3			// d75125c0
	VFWSUBVV	V1, V2, V3			// d79120ca
	VFWSUBVV	V1, V2, V0, V3			// d79120c8
	VFWSUBVF	F10, V2, V3			// d75125ca
	VFWSUBVF	F10, V2, V0, V3			// d75125c8
	VFWADDWV	V1, V2, V3			// d79120d2
	VFWADDWV	V1, V2, V0, V3			// d79120d0
	VFWADDWF	F10, V2, V3			// d75125d2
	VFWADDWF	F10, V2, V0, V3			// d75125d0
	VFWSUBWV	V1, V2, V3			// d79120da
	VFWSUBWV	V1, V2, V0, V3			// d79120d8
	VFWSUBWF	F10, V2, V3			// d75125da
	VFWSUBWF	F10, V2, V0, V3			// d75125d8

	// 31.13.4: Vector Single-Width Floating-Point Multiply/Divide Instructions
	VFMULVV		V1, V2, V3			// d7912092
	VFMULVV		V1, V2, V0, V3			// d7912090
	VFMULVF		F10, V2, V3			// d7512592
	VFMULVF		F10, V2, V0, V3			// d7512590
	VFDIVVV		V1, V2, V3			// d7912082
	VFDIVVV		V1, V2, V0, V3			// d7912080
	VFDIVVF		F10, V2, V3			// d7512582
	VFDIVVF		F10, V2, V0, V3			// d7512580
	VFRDIVVF	F10, V2, V3			// d7512586
	VFRDIVVF	F10, V2, V0, V3			// d7512584

	// 31.13.5: Vector Widening Floating-Point Multiply
	VFWMULVV	V1, V2, V3			// d79120e2
	VFWMULVV	V1, V2, V0, V3			// d79120e0
	VFWMULVF	F10, V2, V3			// d75125e2
	VFWMULVF	F10, V2, V0, V3			// d75125e0

	// 31.13.6: Vector Single-Width Floating-Point Fused Multiply-Add Instructions
	VFMACCVV	V2, V1, V3			// d79120b2
	VFMACCVV	V2, V1, V0, V3			// d79120b0
	VFMACCVF	V2, F10, V3			// d75125b2
	VFMACCVF	V2, F10, V0, V3			// d75125b0
	VFNMACCVV	V2, V1, V3			// d79120b6
	VFNMACCVV	V2, V1, V0, V3			// d79120b4
	VFNMACCVF	V2, F10, V3			// d75125b6
	VFNMACCVF	V2, F10, V0, V3			// d75125b4
	VFMSACVV	V2, V1, V3			// d79120ba
	VFMSACVV	V2, V1, V0, V3			// d79120b8
	VFMSACVF	V2, F10, V3			// d75125ba
	VFMSACVF	V2, F10, V0, V3			// d75125b8
	VFNMSACVV	V2, V1, V3			// d79120be
	VFNMSACVV	V2, V1, V0, V3			// d79120bc
	VFNMSACVF	V2, F10, V3			// d75125be
	VFNMSACVF	V2, F10, V0, V3			// d75125bc
	VFMADDVV	V2, V1, V3			// d79120a2
	VFMADDVV	V2, V1, V0, V3			// d79120a0
	VFMADDVF	V2, F10, V3			// d75125a2
	VFMADDVF	V2, F10, V0, V3			// d75125a0
	VFNMADDVV	V2, V1, V3			// d79120a6
	VFNMADDVV	V2, V1, V0, V3			// d79120a4
	VFNMADDVF	V2, F10, V3			// d75125a6
	VFNMADDVF	V2, F10, V0, V3			// d75125a4
	VFMSUBVV	V2, V1, V3			// d79120aa
	VFMSUBVV	V2, V1, V0, V3			// d79120a8
	VFMSUBVF	V2, F10, V3			// d75125aa
	VFMSUBVF	V2, F10, V0, V3			// d75125a8
	VFNMSUBVV	V2, V1, V3			// d79120ae
	VFNMSUBVV	V2, V1, V0, V3			// d79120ac
	VFNMSUBVF	V2, F10, V3			// d75125ae
	VFNMSUBVF	V2, F10, V0, V3			// d75125ac

	// 31.13.7: Vector Widening Floating-Point Fused Multiply-Add Instructions
	VFWMACCVV	V2, V1, V3			// d79120f2
	VFWMACCVV	V2, V1, V0, V3			// d79120f0
	VFWMACCVF	V2, F10, V3			// d75125f2
	VFWMACCVF	V2, F10, V0, V3			// d75125f0
	VFWNMACCVV	V2, V1, V3			// d79120f6
	VFWNMACCVV	V2, V1, V0, V3			// d79120f4
	VFWNMACCVF	V2, F10, V3			// d75125f6
	VFWNMACCVF	V2, F10, V0, V3			// d75125f4
	VFWMSACVV	V2, V1, V3			// d79120fa
	VFWMSACVV	V2, V1, V0, V3			// d79120f8
	VFWMSACVF	V2, F10, V3			// d75125fa
	VFWMSACVF	V2, F10, V0, V3			// d75125f8
	VFWNMSACVV	V2, V1, V3			// d79120fe
	VFWNMSACVV	V2, V1, V0, V3			// d79120fc
	VFWNMSACVF	V2, F10, V3			// d75125fe
	VFWNMSACVF	V2, F10, V0, V3			// d75125fc

	// 31.13.8: Vector Floating-Point Square-Root Instruction
	VFSQRTV		V2, V3				// d711204e
	VFSQRTV		V2, V0, V3			// d711204c

	// 31.13.9: Vector Floating-Point Reciprocal Square-Root Estimate Instruction
	VFRSQRT7V	V2, V3				// d711224e
	VFRSQRT7V	V2, V0, V3			// d711224c

	// 31.13.10: Vector Floating-Point Reciprocal Estimate Instruction
	VFREC7V		V2, V3				// d791224e
	VFREC7V		V2, V0, V3			// d791224c

	// 31.13.11: Vector Floating-Point MIN/MAX Instructions
	VFMINVV		V1, V2, V3			// d7912012
	VFMINVV		V1, V2, V0, V3			// d7912010
	VFMINVF		F10, V2, V3			// d7512512
	VFMINVF		F10, V2, V0, V3			// d7512510
	VFMAXVV		V1, V2, V3			// d791201a
	VFMAXVV		V1, V2, V0, V3			// d7912018
	VFMAXVF		F10, V2, V3			// d751251a
	VFMAXVF		F10, V2, V0, V3			// d7512518

	// 31.13.12: Vector Floating-Point Sign-Injection Instructions
	VFSGNJVV	V1, V2, V3			// d7912022
	VFSGNJVV	V1, V2, V0, V3			// d7912020
	VFSGNJVF	F10, V2, V3			// d7512522
	VFSGNJVF	F10, V2, V0, V3			// d7512520
	VFSGNJNVV	V1, V2, V3			// d7912026
	VFSGNJNVV	V1, V2, V0, V3			// d7912024
	VFSGNJNVF	F10, V2, V3			// d7512526
	VFSGNJNVF	F10, V2, V0, V3			// d7512524
	VFSGNJXVV	V1, V2, V3			// d791202a
	VFSGNJXVV	V1, V2, V0, V3			// d7912028
	VFSGNJXVF	F10, V2, V3			// d751252a
	VFSGNJXVF	F10, V2, V0, V3			// d7512528
	VFNEGV		V2, V3				// d7112126
	VFNEGV		V2, V0, V3			// d7112124
	VFABSV		V2, V3				// d711212a
	VFABSV		V2, V0, V3			// d7112128

	// 31.13.13: Vector Floating-Point Compare Instructions
	VMFEQVV		V1, V2, V3			// d7912062
	VMFEQVV		V1, V2, V0, V3			// d7912060
	VMFEQVF		F10, V2, V3			// d7512562
	VMFEQVF		F10, V2, V0, V3			// d7512560
	VMFNEVV		V1, V2, V3			// d7912072
	VMFNEVV		V1, V2, V0, V3			// d7912070
	VMFNEVF		F10, V2, V3			// d7512572
	VMFNEVF		F10, V2, V0, V3			// d7512570
	VMFLTVV		V1, V2, V3			// d791206e
	VMFLTVV		V1, V2, V0, V3			// d791206c
	VMFLTVF		F10, V2, V3			// d751256e
	VMFLTVF		F10, V2, V0, V3			// d751256c
	VMFLEVV		V1, V2, V3			// d7912066
	VMFLEVV		V1, V2, V0, V3			// d7912064
	VMFLEVF		F10, V2, V3			// d7512566
	VMFLEVF		F10, V2, V0, V3			// d7512564
	VMFGTVF		F10, V2, V3			// d7512576
	VMFGTVF		F10, V2, V0, V3			// d7512574
	VMFGEVF		F10, V2, V3			// d751257e
	VMFGEVF		F10, V2, V0, V3			// d751257c
	VMFGTVV		V1, V2, V3			// d711116e
	VMFGTVV		V1, V2, V0, V3			// d711116c
	VMFGEVV		V1, V2, V3			// d7111166
	VMFGEVV		V1, V2, V0, V3			// d7111164

	// 31.13.14: Vector Floating-Point Classify Instruction
	VFCLASSV	V2, V3				// d711284e
	VFCLASSV	V2, V0, V3			// d711284c

	// 31.13.15: Vector Floating-Point Merge Instruction
	VFMERGEVFM	F10, V2, V0, V3			// d751255c

	// 31.13.16: Vector Floating-Point Move Instruction
	VFMVVF		F10, V3				// d751055e

	// 31.13.17: Single-Width Floating-Point/Integer Type-Convert Instructions
	VFCVTXUFV	V2, V3				// d711204a
	VFCVTXUFV	V2, V0, V3			// d7112048
	VFCVTXFV	V2, V3				// d791204a
	VFCVTXFV	V2, V0, V3			// d7912048
	VFCVTRTZXUFV	V2, V3				// d711234a
	VFCVTRTZXUFV	V2, V0, V3			// d7112348
	VFCVTRTZXFV	V2, V3				// d791234a
	VFCVTRTZXFV	V2, V0, V3			// d7912348
	VFCVTFXUV	V2, V3				// d711214a
	VFCVTFXUV	V2, V0, V3			// d7112148
	VFCVTFXV	V2, V3				// d791214a
	VFCVTFXV	V2, V0, V3			// d7912148

	// 31.13.18: Widening Floating-Point/Integer Type-Convert Instructions
	VFWCVTXUFV	V2, V3				// d711244a
	VFWCVTXUFV	V2, V0, V3			// d7112448
	VFWCVTXFV	V2, V3				// d791244a
	VFWCVTXFV	V2, V0, V3			// d7912448
	VFWCVTRTZXUFV	V2, V3				// d711274a
	VFWCVTRTZXUFV	V2, V0, V3			// d7112748
	VFWCVTRTZXFV	V2, V3				// d791274a
	VFWCVTRTZXFV	V2, V0, V3			// d7912748
	VFWCVTFXUV	V2, V3				// d711254a
	VFWCVTFXUV	V2, V0, V3			// d7112548
	VFWCVTFXV	V2, V3				// d791254a
	VFWCVTFXV	V2, V0, V3			// d7912548
	VFWCVTFFV	V2, V3				// d711264a
	VFWCVTFFV	V2, V0, V3			// d7112648

	// 31.13.19: Narrowing Floating-Point/Integer Type-Convert Instructions
	VFNCVTXUFW	V2, V3				// d711284a
	VFNCVTXUFW	V2, V0, V3			// d7112848
	VFNCVTXFW	V2, V3				// d791284a
	VFNCVTXFW	V2, V0, V3			// d7912848
	VFNCVTRTZXUFW	V2, V3				// d7112b4a
	VFNCVTRTZXUFW	V2, V0, V3			// d7112b48
	VFNCVTRTZXFW	V2, V3				// d7912b4a
	VFNCVTRTZXFW	V2, V0, V3			// d7912b48
	VFNCVTFXUW	V2, V3				// d711294a
	VFNCVTFXUW	V2, V0, V3			// d7112948
	VFNCVTFXW	V2, V3				// d791294a
	VFNCVTFXW	V2, V0, V3			// d7912948
	VFNCVTFFW	V2, V3				// d7112a4a
	VFNCVTFFW	V2, V0, V3			// d7112a48
	VFNCVTRODFFW	V2, V3				// d7912a4a
	VFNCVTRODFFW	V2, V0, V3			// d7912a48

	// 31.14.1: Vector Single-Width Integer Reduction Instructions
	VREDSUMVS	V1, V2, V3			// d7a12002
	VREDSUMVS	V1, V2, V0, V3			// d7a12000
	VREDMAXUVS	V1, V2, V3			// d7a1201a
	VREDMAXUVS	V1, V2, V0, V3			// d7a12018
	VREDMAXVS	V1, V2, V3			// d7a1201e
	VREDMAXVS	V1, V2, V0, V3			// d7a1201c
	VREDMINUVS	V1, V2, V3			// d7a12012
	VREDMINUVS	V1, V2, V0, V3			// d7a12010
	VREDMINVS	V1, V2, V3			// d7a12016
	VREDMINVS	V1, V2, V0, V3			// d7a12014
	VREDANDVS	V1, V2, V3			// d7a12006
	VREDANDVS	V1, V2, V0, V3			// d7a12004
	VREDORVS	V1, V2, V3			// d7a1200a
	VREDORVS	V1, V2, V0, V3			// d7a12008
	VREDXORVS	V1, V2, V3			// d7a1200e
	VREDXORVS	V1, V2, V0, V3			// d7a1200c

	// 31.14.2: Vector Widening Integer Reduction Instructions
	VWREDSUMUVS	V1, V2, V3			// d78120c2
	VWREDSUMUVS	V1, V2, V0, V3			// d78120c0
	VWREDSUMVS	V1, V2, V3			// d78120c6
	VWREDSUMVS	V1, V2, V0, V3			// d78120c4

	// 31.14.3: Vector Single-Width Floating-Point Reduction Instructions
	VFREDOSUMVS	V1, V2, V3			// d791200e
	VFREDOSUMVS	V1, V2, V0, V3			// d791200c
	VFREDUSUMVS	V1, V2, V3			// d7912006
	VFREDUSUMVS	V1, V2, V0, V3			// d7912004
	VFREDMAXVS	V1, V2, V3			// d791201e
	VFREDMAXVS	V1, V2, V0, V3			// d791201c
	VFREDMINVS	V1, V2, V3			// d7912016
	VFREDMINVS	V1, V2, V0, V3			// d7912014

	// 31.14.4: Vector Widening Floating-Point Reduction Instructions
	VFWREDOSUMVS	V1, V2, V3			// d79120ce
	VFWREDOSUMVS	V1, V2, V0, V3			// d79120cc
	VFWREDUSUMVS	V1, V2, V3			// d79120c6
	VFWREDUSUMVS	V1, V2, V0, V3			// d79120c4

	// 31.15: Vector Mask Instructions
	VMANDMM		V1, V2, V3			// d7a12066
	VMNANDMM	V1, V2, V3			// d7a12076
	VMANDNMM	V1, V2, V3			// d7a12062
	VMXORMM		V1, V2, V3			// d7a1206e
	VMORMM		V1, V2, V3			// d7a1206a
	VMNORMM		V1, V2, V3			// d7a1207a
	VMORNMM		V1, V2, V3			// d7a12072
	VMXNORMM	V1, V2, V3			// d7a1207e
	VMMVM		V2, V3				// d7212166
	VMCLRM		V3				// d7a1316e
	VMSETM		V3				// d7a1317e
	VMNOTM		V2, V3				// d7212176
	VCPOPM		V2, X10				// 57252842
	VCPOPM		V2, V0, X10			// 57252840
	VFIRSTM		V2, X10				// 57a52842
	VFIRSTM		V2, V0, X10			// 57a52840
	VMSBFM		V2, V3				// d7a12052
	VMSBFM		V2, V0, V3			// d7a12050
	VMSIFM		V2, V3				// d7a12152
	VMSIFM		V2, V0, V3			// d7a12150
	VMSOFM		V2, V3				// d7212152
	VMSOFM		V2, V0, V3			// d7212150
	VIOTAM		V2, V3				// d7212852
	VIOTAM		V2, V0, V3			// d7212850
	VIDV		V3				// d7a10852
	VIDV		V0, V3				// d7a10850

	// 31.16.1: Integer Scalar Move Instructions
	VMVXS		V2, X10				// 57252042
	VMVSX		X10, V2				// 57610542

	// 31.16.2: Floating-Point Scalar Move Instructions
	VFMVFS		V2, F10				// 57152042
	VFMVSF		F10, V2				// 57510542

	// 31.16.3: Vector Slide Instructions
	VSLIDEUPVX	X10, V2, V3			// d741253a
	VSLIDEUPVX	X10, V2, V0, V3			// d7412538
	VSLIDEUPVI	$16, V2, V3			// d731283a
	VSLIDEUPVI	$16, V2, V0, V3			// d7312838
	VSLIDEDOWNVX	X10, V2, V3			// d741253e
	VSLIDEDOWNVX	X10, V2, V0, V3			// d741253c
	VSLIDEDOWNVI	$16, V2, V3			// d731283e
	VSLIDEDOWNVI	$16, V2, V0, V3			// d731283c
	VSLIDE1UPVX	X10, V2, V3			// d761253a
	VSLIDE1UPVX	X10, V2, V0, V3			// d7612538
	VFSLIDE1UPVF	F10, V2, V3			// d751253a
	VFSLIDE1UPVF	F10, V2, V0, V3			// d7512538
	VSLIDE1DOWNVX	X10, V2, V3			// d761253e
	VSLIDE1DOWNVX	X10, V2, V0, V3			// d761253c
	VFSLIDE1DOWNVF	F10, V2, V3			// d751253e
	VFSLIDE1DOWNVF	F10, V2, V0, V3			// d751253c

	// 31.16.4: Vector Register Gather Instructions
	VRGATHERVV	V1, V2, V3			// d7812032
	VRGATHERVV	V1, V2, V0, V3			// d7812030
	VRGATHEREI16VV	V1, V2, V3			// d781203a
	VRGATHEREI16VV	V1, V2, V0, V3			// d7812038
	VRGATHERVX	X10, V2, V3			// d7412532
	VRGATHERVX	X10, V2, V0, V3			// d7412530
	VRGATHERVI	$16, V2, V3			// d7312832
	VRGATHERVI	$16, V2, V0, V3			// d7312830

	// 31.16.5: Vector Compress Instruction
	VCOMPRESSVM	V1, V2, V3			// d7a1205e

	// 31.16.6: Whole Vector Register Move
	VMV1RV		V2, V1				// d730209e
	VMV2RV		V12, V10			// 57b5c09e
	VMV4RV		V8, V4				// 57b2819e
	VMV8RV		V8, V0				// 57b0839e

	// 33.2.1: Vector Basic Bit-manipulation (Zvbb)
	VANDNVV		V1, V2, V3			// d7812006
	VANDNVV		V1, V2, V0, V3			// d7812004
	VANDNVX		X10, V2, V3			// d7412506
	VANDNVX		X10, V2, V0, V3			// d7412504
	VBREVV		V2, V3				// d721254a
	VBREVV		V2, V0, V3			// d7212548
	VBREV8V		V2, V3				// d721244a
	VBREV8V		V2, V0, V3			// d7212448
	VREV8V		V2, V3				// d7a1244a
	VREV8V		V2, V0, V3			// d7a12448
	VCLZV		V2, V3				// d721264a
	VCLZV		V2, V0, V3			// d7212648
	VCTZV		V2, V3				// d7a1264a
	VCTZV		V2, V0, V3			// d7a12648
	VCPOPV		V2, V3				// d721274a
	VCPOPV		V2, V0, V3			// d7212748
	VROLVV		V1, V2, V3			// d7812056
	VROLVV		V1, V2, V0, V3			// d7812054
	VROLVX		X10, V2, V3			// d7412556
	VROLVX		X10, V2, V0, V3			// d7412554
	VRORVV		V1, V2, V3			// d7812052
	VRORVV		V1, V2, V0, V3			// d7812050
	VRORVX		X10, V2, V3			// d7412552
	VRORVX		X10, V2, V0, V3			// d7412550
	VRORVI		$16, V2, V3			// d7312852
	VRORVI		$16, V2, V0, V3			// d7312850
	VWSLLVV		V1, V2, V3			// d78120d6
	VWSLLVV		V1, V2, V0, V3			// d78120d4
	VWSLLVX		X10, V2, V3			// d74125d6
	VWSLLVX		X10, V2, V0, V3			// d74125d4
	VWSLLVI		$16, V2, V3			// d73128d6
	VWSLLVI		$16, V2, V0, V3			// d73128d4

	// 33.2.2: Vector Carryless Multiplication (Zvbc)
	VCLMULVV	V1, V2, V3			// d7a12032
	VCLMULVV	V1, V2, V0, V3			// d7a12030
	VCLMULVX	X10, V2, V3			// d7612532
	VCLMULVX	X10, V2, V0, V3			// d7612530
	VCLMULHVV	V1, V2, V3			// d7a12036
	VCLMULHVV	V1, V2, V0, V3			// d7a12034
	VCLMULHVX	X10, V2, V3			// d7612536
	VCLMULHVX	X10, V2, V0, V3			// d7612534
	RET
`
	dir := t.TempDir()
	path := filepath.Join(dir, "vecarith_riscv64.s")
	if err := os.WriteFile(path, []byte(src), 0o644); err != nil {
		t.Fatal(err)
	}
	assertRISCVDifferential(t, path, src, "vecarith")
}

// TestRISCVScalarPseudos_Differential proves the scalar pseudo tail against
// the toolchain: the NEG/NEGW and SEQZ/SNEZ one- and two-operand forms, the
// sign-injection pseudos and the two-word not-equal expansions, exactly as
// the toolchain's own testdata spells them.
func TestRISCVScalarPseudos_Differential(t *testing.T) {
	src := `#include "textflag.h"

TEXT ·pseudos(SB), NOSPLIT, $0-8
	NEG	X5
	NEG	X5, X6
	NEGW	X5
	NEGW	X5, X6
	SEQZ	X14, X15
	SNEZ	X14, X15
	FABSS	F0, F1
	FNEGS	F0, F1
	FNES	F0, F1, X7
	FABSD	F0, F1
	FNEGD	F0, F1
	FNED	F0, F1, X5
	FLTD	F0, F1, X5
	FLED	F0, F1, X5
	FEQD	F0, F1, X5
	RET
`
	dir := t.TempDir()
	path := filepath.Join(dir, "pseudos_riscv64.s")
	if err := os.WriteFile(path, []byte(src), 0o644); err != nil {
		t.Fatal(err)
	}
	assertRISCVDifferential(t, path, src, "pseudos")
}