"VACC",
	"VACCB",
	"VACCH",
	"VACCF",
	"VACCG",
	"VACCQ",
	"VAC",
	"VACQ",
	"VACCC",
	"VACCCQ",
	"VN",
	"VNC",
	"VAVG",
	"VAVGB",
	"VAVGH",
	"VAVGF",
	"VAVGG",
	"VAVGL",
	"VAVGLB",
	"VAVGLH",
	"VAVGLF",
	"VAVGLG",
	"VCKSM",
	"VCEQ",
	"VCEQB",
	"VCEQH",
	"VCEQF",
	"VCEQG",
	"VCEQBS",
	"VCEQHS",
	"VCEQFS",
	"VCEQGS",
	"VCH",

	VADDUWM:        "vadduwm",
	VADDUWS:        "vadduws",
	VAND:           "vand",
	VANDC:          "vandc",
	VAVGSB:         "vavgsb",
	VAVGSH:         "vavgsh",
	VAVGSW:         "vavgsw",
	VAVGUB:         "vavgub",
	VAVGUH:         "vavguh",
	VAVGUW:         "vavguw",
	VCFSX:          "vcfsx",
	VCFUX:          "vcfux",
	VCMPBFP:        "vcmpbfp",
	VCMPBFPCC:      "vcmpbfp.",

	AVAH
	AVAF
	AVAG
	AVAQ
	AVACC
	AVACCB
	AVACCH
	AVACCF
	AVACCG
	AVACCQ
	AVAC
	AVACQ
	AVACCC
	AVACCCQ
	AVN
	AVNC
	AVAVG
	AVAVGB
	AVAVGH
	AVAVGF
	AVAVGG
	AVAVGL
	AVAVGLB
	AVAVGLH
	AVAVGLF
	AVAVGLG
	AVCKSM
	AVCEQ
	AVCEQB
	AVCEQH
	AVCEQF
	AVCEQG
	AVCEQBS
	AVCEQHS
	AVCEQFS
	AVCEQGS
	AVCH
	AVCHB
	AVCHH

	case AVN:
		return op_VN, 0, 0
	case AVNC:
		return op_VNC, 0, 0
	case AVAVG:
		return op_VAVG, 0, 0
	case AVAVGB:
		return op_VAVG, 0, 0
	case AVAVGH:
		return op_VAVG, 1, 0
	case AVAVGF:
		return op_VAVG, 2, 0
	case AVAVGG:
		return op_VAVG, 3, 0
	case AVAVGL:
		return op_VAVGL, 0, 0
	case AVAVGLB:
		return op_VAVGL, 0, 0
	case AVAVGLH:
		return op_VAVGL, 1, 0
	case AVAVGLF:
		return op_VAVGL, 2, 0

	VPAVGB X16, X7, K1, X19                            // 62a14509e0d8 or 62a1c509e0d8
	VPAVGB (SI), X7, K1, X19                           // 62e14509e01e or 62e1c509e01e
	VPAVGB 7(SI)(DI*2), X7, K1, X19                    // 62e14509e09c7e07000000 or 62e1c509e09c7e07000000
	VPAVGB Y14, Y19, K3, Y23                           // 62c16523e0fe or 62c1e523e0fe

vectorimpl:
	//if the address is not 16byte aligned, use loop for the header
	MOVD	R3, R8
	AND	$15, R8
	CMPBGT	R8, $0, notaligned

aligned:
	ADD	R6, R4, R8
	MOVD	R8, R7
	AND	$-16, R7
	// replicate c across V17
	VLVGB	$0, R5, V19
	VREPB	$0, V19, V17

vectorloop:
	CMPBGE	R3, R7, residual
	VL	0(R3), V16    // load string to be searched into V16
	ADD	$16, R3

	// Set R_LEN to be the length mod 16 minus 1 to use as an index for
	// vector 'load with length' (VLL). It will be in the range [-1,14].
	// Also replicate c across a 16-byte vector and initialize V_ZERO.
	ANDW  $0xf, R_LEN
	VLVGB $0, R_CHAR, V_CHAR // V_CHAR = [16]byte{c, 0, ..., 0, 0}
	VZERO V_ZERO             // V_ZERO = [1]uint128{0}
	ADDW  $-1, R_LEN
	VREPB $0, V_CHAR, V_CHAR // V_CHAR = [16]byte{c, c, ..., c, c}

	AVINSWVRX
	AVINSWVLX
	AVINSWRX
	AVINSWLX
	AVINSW
	AVINSHVRX
	AVINSHVLX
	AVINSHRX
	AVINSHLX
	AVINSDRX
	AVINSDLX
	AVINSD
	AVINSBVRX
	AVINSBVLX
	AVINSBRX
	AVINSBLX
	AVGNB
	AVEXTSD2Q
	AVEXTRACTWM
	AVEXTRACTQM
	AVEXTRACTHM
	AVEXTRACTDM
	AVEXTRACTBM
	AVEXTDUWVRX
	AVEXTDUWVLX
	AVEXTDUHVRX
	AVEXTDUHVLX
	AVEXTDUBVRX
	AVEXTDUBVLX
	AVEXTDDVRX

    private val DASHDASH = byteArrayOf('-'.code.toByte(), '-'.code.toByte())

    /**
     * Appends a quoted-string to a StringBuilder.
     *
     * RFC 2388 is rather vague about how one should escape special characters in form-data
     * parameters, and as it turns out Firefox and Chrome actually do rather different things, and

	}

	return encrypt(pub, em)
}

// ErrDecryption represents a failure to decrypt a message.
// It is deliberately vague to avoid adaptive attacks.
var ErrDecryption = errors.New("crypto/rsa: decryption error")

// ErrVerification represents a failure to verify a signature.
// It is deliberately vague to avoid adaptive attacks.
var ErrVerification = errors.New("crypto/rsa: verification error")