public void TestMultiply2()
        {
            int COUNT = 100;
            ECFieldElement[] inputs = new ECFieldElement[COUNT];
            BigInteger[] INPUTS = new BigInteger[COUNT];

            for (int i = 0; i < inputs.Length; ++i)
            {
                inputs[i] = GenerateMultiplyInput_Random();
                INPUTS[i] = inputs[i].ToBigInteger();
            }

            for (int j = 0; j < inputs.Length; ++j)
            {
                for (int k = 0; k < inputs.Length; ++k)
                {
                    BigInteger R = INPUTS[j].Multiply(INPUTS[k]).Mod(Q);

                    ECFieldElement z = inputs[j].Multiply(inputs[k]);
                    BigInteger Z = z.ToBigInteger();

                    Assert.AreEqual(R, Z);
                }
            }
        }

 public override ECFieldElement Divide(ECFieldElement b)
 {
     //return Multiply(b.Invert());
     uint[] z = Nat256.Create();
     Mod.Invert(Curve25519Field.P, ((Curve25519FieldElement)b).x, z);
     Curve25519Field.Multiply(z, x, z);
     return new Curve25519FieldElement(z);
 }

 public override ECFieldElement Divide(ECFieldElement b)
 {
     //return Multiply(b.Invert());
     uint[] z = Nat.Create(12);
     Mod.Invert(SecP384R1Field.P, ((SecP384R1FieldElement)b).x, z);
     SecP384R1Field.Multiply(z, x, z);
     return new SecP384R1FieldElement(z);
 }

 private ECCurve(BigInteger Q, BigInteger A, BigInteger B, BigInteger N, byte[] G)
 {
     this.Q = Q;
     this.A = new ECFieldElement(A, this);
     this.B = new ECFieldElement(B, this);
     this.N = N;
     this.Infinity = new ECPoint(null, null, this);
     this.G = ECPoint.DecodePoint(G, this);
 }

 protected internal override ECPoint CreateRawPoint(ECFieldElement x, ECFieldElement y, bool withCompression)
 {
     return new SecT163R2Point(this, x, y, withCompression);
 }

 public override ECFieldElement Multiply(ECFieldElement b)
 {
     uint[] z = Nat.Create(12);
     SecP384R1Field.Multiply(x, ((SecP384R1FieldElement)b).x, z);
     return new SecP384R1FieldElement(z);
 }

 public override bool Equals(ECFieldElement other)
 {
     return Equals(other as SecP384R1FieldElement);
 }

 public override ECFieldElement MultiplyMinusProduct(ECFieldElement b, ECFieldElement x, ECFieldElement y)
 {
     return MultiplyPlusProduct(b, x, y);
 }

 public override ECFieldElement Subtract(ECFieldElement b)
 {
     // Addition and Subtraction are the same in F2m
     return Add(b);
 }

 public override ECFieldElement Divide(ECFieldElement b)
 {
     return Multiply(b.Invert());
 }

//.........这里部分代码省略.........
            bool Z1IsOne = Z1.IsOne;
            uint[] U2, S2;
            if (Z1IsOne)
            {
                U2 = X2.x;
                S2 = Y2.x;
            }
            else
            {
                S2 = t3;
                Curve25519Field.Square(Z1.x, S2);

                U2 = t2;
                Curve25519Field.Multiply(S2, X2.x, U2);

                Curve25519Field.Multiply(S2, Z1.x, S2);
                Curve25519Field.Multiply(S2, Y2.x, S2);
            }

            bool Z2IsOne = Z2.IsOne;
            uint[] U1, S1;
            if (Z2IsOne)
            {
                U1 = X1.x;
                S1 = Y1.x;
            }
            else
            {
                S1 = t4;
                Curve25519Field.Square(Z2.x, S1);

                U1 = tt1;
                Curve25519Field.Multiply(S1, X1.x, U1);

                Curve25519Field.Multiply(S1, Z2.x, S1);
                Curve25519Field.Multiply(S1, Y1.x, S1);
            }

            uint[] H = Nat256.Create();
            Curve25519Field.Subtract(U1, U2, H);

            uint[] R = t2;
            Curve25519Field.Subtract(S1, S2, R);

            // Check if b == this or b == -this
            if (Nat256.IsZero(H))
            {
                if (Nat256.IsZero(R))
                {
                    // this == b, i.e. this must be doubled
                    return this.Twice();
                }

                // this == -b, i.e. the result is the point at infinity
                return curve.Infinity;
            }

            uint[] HSquared = Nat256.Create();
            Curve25519Field.Square(H, HSquared);

            uint[] G = Nat256.Create();
            Curve25519Field.Multiply(HSquared, H, G);

            uint[] V = t3;
            Curve25519Field.Multiply(HSquared, U1, V);

            Curve25519Field.Negate(G, G);
            Nat256.Mul(S1, G, tt1);

            c = Nat256.AddBothTo(V, V, G);
            Curve25519Field.Reduce27(c, G);

            Curve25519FieldElement X3 = new Curve25519FieldElement(t4);
            Curve25519Field.Square(R, X3.x);
            Curve25519Field.Subtract(X3.x, G, X3.x);

            Curve25519FieldElement Y3 = new Curve25519FieldElement(G);
            Curve25519Field.Subtract(V, X3.x, Y3.x);
            Curve25519Field.MultiplyAddToExt(Y3.x, R, tt1);
            Curve25519Field.Reduce(tt1, Y3.x);

            Curve25519FieldElement Z3 = new Curve25519FieldElement(H);
            if (!Z1IsOne)
            {
                Curve25519Field.Multiply(Z3.x, Z1.x, Z3.x);
            }
            if (!Z2IsOne)
            {
                Curve25519Field.Multiply(Z3.x, Z2.x, Z3.x);
            }

            uint[] Z3Squared = (Z1IsOne && Z2IsOne) ? HSquared : null;

            // TODO If the result will only be used in a subsequent addition, we don't need W3
            Curve25519FieldElement W3 = CalculateJacobianModifiedW((Curve25519FieldElement)Z3, Z3Squared);

            ECFieldElement[] zs = new ECFieldElement[] { Z3, W3 };

            return new Curve25519Point(curve, X3, Y3, zs, IsCompressed);
        }

 /**
  * Create a point which encodes with point compression.
  *
  * @param curve the curve to use
  * @param x affine x co-ordinate
  * @param y affine y co-ordinate
  *
  * @deprecated Use ECCurve.CreatePoint to construct points
  */
 public Curve25519Point(ECCurve curve, ECFieldElement x, ECFieldElement y)
     : this(curve, x, y, false)
 {
 }

		public SecP256K1Point(ECCurve curve, ECFieldElement x, ECFieldElement y, ECFieldElement[] zs,
			bool withCompression)
			: base(curve, x, y, zs, withCompression)
		{
		}

 public override ECFieldElement Multiply(ECFieldElement b)
 {
     uint[] z = Nat256.Create();
     SecP256K1Field.Multiply(x, ((SecP256K1FieldElement)b).x, z);
     return new SecP256K1FieldElement(z);
 }

 public override ECFieldElement Subtract(ECFieldElement b)
 {
     uint[] z = Nat256.Create();
     SecP256K1Field.Subtract(x, ((SecP256K1FieldElement)b).x, z);
     return new SecP256K1FieldElement(z);
 }

        public override ECFieldElement SquarePlusProduct(ECFieldElement x, ECFieldElement y)
        {
            ulong[] ax = this.x;
            ulong[] xx = ((SecT233FieldElement)x).x, yx = ((SecT233FieldElement)y).x;

            ulong[] tt = Nat256.CreateExt64();
            SecT233Field.SquareAddToExt(ax, tt);
            SecT233Field.MultiplyAddToExt(xx, yx, tt);

            ulong[] z = Nat256.Create64();
            SecT233Field.Reduce(tt, z);
            return new SecT233FieldElement(z);
        }

 public override ECFieldElement Add(ECFieldElement b)
 {
     ulong[] z = Nat256.Create64();
     SecT233Field.Add(x, ((SecT233FieldElement)b).x, z);
     return new SecT233FieldElement(z);
 }

		public ScaleXPointMap(ECFieldElement scale)
		{
			this.scale = scale;
		}

 public override ECFieldElement SquareMinusProduct(ECFieldElement x, ECFieldElement y)
 {
     return SquarePlusProduct(x, y);
 }

 public override ECFieldElement Add(ECFieldElement b)
 {
     uint[] z = Nat.Create(17);
     SecP521R1Field.Add(x, ((SecP521R1FieldElement)b).x, z);
     return new SecP521R1FieldElement(z);
 }