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