{"(*PrivateKey).PublicKey", Method, 20},
		{"(*PublicKey).Bytes", Method, 20},
		{"(*PublicKey).Curve", Method, 20},
		{"(*PublicKey).Equal", Method, 20},
		{"Curve", Type, 20},
		{"P256", Func, 20},
		{"P384", Func, 20},
		{"P521", Func, 20},
		{"PrivateKey", Type, 20},
		{"PublicKey", Type, 20},
		{"X25519", Func, 20},
	},
	"crypto/ecdsa": {
		{"(*PrivateKey).ECDH", Method, 20},

	/*  79 */ {_SigNotify, "signal 79"},
	/*  80 */ {_SigNotify, "signal 80"},
	/*  81 */ {_SigNotify, "signal 81"},
	/*  82 */ {_SigNotify, "signal 82"},
	/*  83 */ {_SigNotify, "signal 83"},
	/*  84 */ {_SigNotify, "signal 84"},
	/*  85 */ {_SigNotify, "signal 85"},
	/*  86 */ {_SigNotify, "signal 86"},
	/*  87 */ {_SigNotify, "signal 87"},
	/*  88 */ {_SigNotify, "signal 88"},
	/*  89 */ {_SigNotify, "signal 89"},

          .put("sHa-1", Hashing.sha1()) // Not the official name, but still works
          .put("SHA-1", Hashing.sha1())
          .put("SHA-256", Hashing.sha256())
          .put("SHA-384", Hashing.sha384())
          .put("SHA-512", Hashing.sha512())
          .build();

  public void testHashing() {
    for (String stringToTest : INPUTS) {
      for (String algorithmToTest : ALGORITHMS.keySet()) {

	case ASB:
		return &inst{0x23, 0x0, 0x0, 0, 0x0}
	case ASBREAK:
		return &inst{0x73, 0x0, 0x1, 1, 0x0}
	case ASCD:
		return &inst{0x2f, 0x3, 0x0, 384, 0xc}
	case ASCW:
		return &inst{0x2f, 0x2, 0x0, 384, 0xc}
	case ASCALL:
		return &inst{0x73, 0x0, 0x0, 0, 0x0}
	case ASD:
		return &inst{0x23, 0x3, 0x0, 0, 0x0}
	case ASEXTB:
		return &inst{0x13, 0x1, 0x4, 1540, 0x30}
	case ASEXTH:

00000340  dc d0 b9 9a 46 42 34 e2  be 43 0f 67 bc f6 dd bc  |....FB4..C.g....|
00000350  ab cd 44 79 77 1a 1a c3  03 4c 1f 4a ff 7e 27 3b  |..Dyw....L.J.~';|
00000360  e1 83 84 a6 30 cf 53 ba  d9 f6 1e ae 1c 9b c3 28  |....0.S........(|
00000370  96 17 03 03 00 35 3b b4  72 13 ca b8 f1 2f dd 42  |.....5;.r..../.B|
00000380  5d f1 a4 93 b5 25 2b fb  12 5b dd 90 7e cb 45 3a  |]....%+..[..~.E:|

(1) Argument order is the same as in the GNU ARM64 syntax: cbz, cbnz and some store instructions,
such as str, stur, strb, sturb, strh, sturh stlr, stlrb. stlrh, st1.

Examples:

	MOVD R29, 384(R19)    <=>    str x29, [x19,#384]
	MOVB.P R30, 30(R4)    <=>    strb w30, [x4],#30
	STLRH R21, (R19)      <=>    stlrh w21, [x19]

(2) MADD, MADDW, MSUB, MSUBW, SMADDL, SMSUBL, UMADDL, UMSUBL <Rm>, <Ra>, <Rn>, <Rd>

Examples:

DATA ·IEEEConst+1360(SB)/8,$0x00000000ebcaae4c
DATA ·IEEEConst+1368(SB)/8,$0x0000000030cdb032

	/* x^173120 mod p(x), x^173056 mod p(x) */
DATA ·IEEEConst+1376(SB)/8,$0x000000013ee532a6
DATA ·IEEEConst+1384(SB)/8,$0x000000013e09fc32

	/* x^172096 mod p(x), x^172032 mod p(x) */
DATA ·IEEEConst+1392(SB)/8,$0x00000001bf0cbc7e
DATA ·IEEEConst+1400(SB)/8,$0x000000001ed624d2

	/* x^171072 mod p(x), x^171008 mod p(x) */

func jsonFloat(f float64) string {
	var tmp [32]byte
	dst := tmp[:0]

	// Convert as if by ES6 number to string conversion.
	// This matches most other JSON generators.
	// See golang.org/issue/6384 and golang.org/issue/14135.
	// Like fmt %g, but the exponent cutoffs are different
	// and exponents themselves are not padded to two digits.
	abs := math.Abs(f)
	fmt := byte('f')
	if abs != 0 {

            (FLADLE_PLUGIN_ID): Versions.of('0.17.4'),
            // https://plugins.gradle.org/plugin/com.github.triplet.play
            (TRIPLET_PLAY_PLUGIN_ID): Versions.of('3.8.4'),
            // https://mvnrepository.com/artifact/androidx.navigation.safeargs/androidx.navigation.safeargs.gradle.plugin
            (SAFEARGS_PLUGIN_ID): Versions.of('2.6.0'),

func curveNID(curve string) (C.int, error) {
	switch curve {
	case "P-224":
		return C.GO_NID_secp224r1, nil
	case "P-256":
		return C.GO_NID_X9_62_prime256v1, nil
	case "P-384":
		return C.GO_NID_secp384r1, nil
	case "P-521":
		return C.GO_NID_secp521r1, nil
	}
	return 0, errUnknownCurve
}

func NewPublicKeyECDSA(curve string, X, Y BigInt) (*PublicKeyECDSA, error) {