extended_point_test.go

package ed448

import (
	"encoding/hex"

	. "gopkg.in/check.v1"
)

func (s *Ed448Suite) Test_IsValidPoint(c *C) {
	p := &twExtendedPoint{
		&bigNumber{
			0x034365c8, 0x06b2a874, 0x0eb875d7, 0x0ae4c7a7,
			0x0785df04, 0x09929351, 0x01fe8c3b, 0x0f2a0e5f,
			0x0111d39c, 0x07ab52ba, 0x01df4552, 0x01d87566,
			0x0f297be2, 0x027c090f, 0x0a81b155, 0x0d1a562b,
		},
		&bigNumber{
			0x00da9708, 0x0e7d583e, 0x0dbcc099, 0x0d2dad89,
			0x05a49ce4, 0x01cb4ddc, 0x0928d395, 0x0098d91d,
			0x0bff16ce, 0x06f02f9a, 0x0ce27cc1, 0x0dab5783,
			0x0b553d94, 0x03251a0c, 0x064d70fb, 0x07fe3a2f,
		},
		&bigNumber{
			0x0d5237cc, 0x0319d105, 0x02ab2df5, 0x022e9736,
			0x0d79742f, 0x00688712, 0x012d3a65, 0x0ef4925e,
			0x0bd0d260, 0x0832b532, 0x05faef27, 0x01ffe567,
			0x0161ce73, 0x07bda0f5, 0x035d04f1, 0x0930f532,
		},

		&bigNumber{
			0x01f6cc27, 0x09be7b8a, 0x0226da79, 0x0f6202f1,
			0x0e7264dc, 0x0d25aeb1, 0x06c81f07, 0x03c32cdc,
			0x0923c854, 0x0cfc9865, 0x055b2fed, 0x05bdcc90,
			0x01a99835, 0x0ea08056, 0x0abbf763, 0x03826c2f,
		},
	}

	//non-valid point
	q := &twExtendedPoint{
		&bigNumber{
			0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff,
			0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff,
			0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff,
			0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff,
		},
		&bigNumber{
			0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff,
			0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff,
			0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff,
			0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff,
		},
		&bigNumber{
			0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff,
			0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff,
			0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff,
			0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff,
		},
		&bigNumber{
			0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff,
			0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff,
			0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff,
			0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff,
		},
	}

	c.Assert(p.isOnCurve(), Equals, true)
	c.Assert(q.isOnCurve(), Equals, false)
}

func (s *Ed448Suite) Test_PointEquality(c *C) {
	p := &twExtendedPoint{
		&bigNumber{
			0x0e0fbf9e, 0x0ba1bcd7, 0x01cc6d39, 0x053b56e8,
			0x0635d142, 0x0383307a, 0x0f8a159b, 0x097fd2cf,
			0x0fa310f6, 0x05522bde, 0x0b981703, 0x0b095b1e,
			0x042d4780, 0x05ae11df, 0x0934fe80, 0x0dc6474d,
		},
		&bigNumber{
			0x02c1149c, 0x0e72febf, 0x05259893, 0x0723e184,
			0x0f7232ff, 0x019a5600, 0x05581d2c, 0x07331444,
			0x04e0124a, 0x09c3c5e5, 0x0945536e, 0x0b786a20,
			0x0f75623f, 0x00ba30e8, 0x0cc589a3, 0x04a2eea8,
		},
		&bigNumber{
			0x02406c71, 0x0b2fdb67, 0x02591aa2, 0x085fc24e,
			0x0dc50d09, 0x08692c5b, 0x0ba917d7, 0x0aefea74,
			0x037d0084, 0x04d5defa, 0x08bbe7ad, 0x050da977,
			0x08adf827, 0x05425cdd, 0x037d816d, 0x0d59cd0a,
		},
		&bigNumber{
			0x0baf8c30, 0x06686ad3, 0x0c149bac, 0x0f57f68d,
			0x05cd321a, 0x02ff8d60, 0x09dcc4bd, 0x0f731ec2,
			0x0cd7ea75, 0x0be970e4, 0x043d30e0, 0x0dd64b9b,
			0x04f78bf1, 0x0d1fde20, 0x05c88e97, 0x026ce314,
		},
	}

	q := &twExtendedPoint{
		&bigNumber{
			0x06172a44, 0x0731d576, 0x0da247e0, 0x0d9fd318,
			0x072d1c77, 0x073e77aa, 0x09a004b5, 0x012507b9,
			0x09a684c3, 0x08b559f8, 0x0d445c85, 0x07941c89,
			0x0c942cd4, 0x02bcfe3e, 0x022ccaaa, 0x0be3a6b3,
		},
		&bigNumber{
			0x03294fb1, 0x0e4336b5, 0x0fe125d6, 0x08c09f34,
			0x0f04e3ce, 0x0eac940d, 0x09c38a23, 0x0a2ec035,
			0x06545488, 0x0355e18f, 0x0522a0ec, 0x0ce0fd60,
			0x0bd3a6ce, 0x03fe9d85, 0x06e5c4f3, 0x018cf1e5,
		},
		&bigNumber{
			0x0e957107, 0x0f672aa2, 0x049b0276, 0x07a7ecf2,
			0x0e9a1c69, 0x04067d01, 0x03f2ddee, 0x0ffebccb,
			0x0d58b6cf, 0x0d95fb9c, 0x077d5935, 0x078ddbc3,
			0x085093f2, 0x03015d2f, 0x019d8e0a, 0x0388a2ac,
		},
		&bigNumber{
			0x0bf26ccb, 0x0b930dcd, 0x0e207a77, 0x0d8fdde5,
			0x04e2452b, 0x099e9922, 0x0ec0b62c, 0x04f9d73b,
			0x03811a2a, 0x0871aefb, 0x00f5e028, 0x0b6aa04c,
			0x0226cb55, 0x0b6e4ee0, 0x0f3eba42, 0x04409402,
		},
	}

	c.Assert(p.equals(p), Equals, decafTrue)
	c.Assert(p.equals(q), Equals, decafFalse)
}

func (s *Ed448Suite) Test_PointAdd(c *C) {
	p := &twExtendedPoint{
		&bigNumber{},
		&bigNumber{},
		&bigNumber{},
		&bigNumber{},
	}

	q := &twExtendedPoint{
		&bigNumber{
			0x0a7f964a, 0x0db033f8, 0x062b9f0b, 0x07bff7d6,
			0x05e755a2, 0x013b6f8b, 0x0f080bdc, 0x0a112ac0,
			0x0416988a, 0x03404b2f, 0x00561ea3, 0x01df752c,
			0x070e0b1c, 0x0e73a0c4, 0x078245d5, 0x09a42df0,
		},
		&bigNumber{
			0x0c2e6c3d, 0x0a03c3f2, 0x0fd16e97, 0x0bab4ec6,
			0x08ddba78, 0x091638ef, 0x0b0add85, 0x070c212d,
			0x04bcd337, 0x0c828579, 0x0712cfff, 0x09c1534a,
			0x0119cafe, 0x08e72ee0, 0x0f14ff19, 0x0d0c7e25,
		},
		&bigNumber{
			0x0a0d6be1, 0x0bcd9788, 0x00f9ca8a, 0x038cf839,
			0x00912da2, 0x0a3c503a, 0x056fe7e0, 0x03db9a49,
			0x0f19d062, 0x052ac631, 0x01cbda35, 0x02967214,
			0x0eed2db2, 0x0a948ce0, 0x05f7a3a7, 0x0fa35bc2,
		},
		&bigNumber{
			0x0fc9f32d, 0x0e442931, 0x065e50ff, 0x04be230d,
			0x0dc923c2, 0x0000467c, 0x08fc8902, 0x0e034cfb,
			0x0126370c, 0x06ec706d, 0x06ff07ad, 0x0a27cd65,
			0x060f214f, 0x0eb7756d, 0x0b694dc7, 0x015705ad,
		},
	}

	r := &twExtendedPoint{
		&bigNumber{
			0x075ee82f, 0x0078024b, 0x0a72cc37, 0x07b7b942,
			0x01dc37cd, 0x05b2ca96, 0x0fa5deaf, 0x071020de,
			0x09122cbe, 0x01bdbe1d, 0x0eeb69f3, 0x073d88cf,
			0x0777b71a, 0x0aa1660a, 0x0c4476bf, 0x08e2cf30,
		},
		&bigNumber{
			0x0aab8840, 0x0f0932b3, 0x0088be9e, 0x0c4d55d6,
			0x01926f40, 0x01c112e0, 0x0884dc6d, 0x0e66b50b,
			0x09120ee4, 0x0750ee39, 0x048c6ce2, 0x00f9fe35,
			0x0f74988e, 0x05693a13, 0x0c1d267c, 0x052d5ba0,
		},
		&bigNumber{
			0x043efd14, 0x07ce59a0, 0x0f9b7154, 0x05663cbd,
			0x055ba08f, 0x0525f2b7, 0x0e1d908d, 0x06d7d26a,
			0x0c4cee28, 0x02039ee7, 0x0a733b28, 0x01be5db0,
			0x056e9a37, 0x0db1b9b6, 0x088880cd, 0x03d26863,
		},
		&bigNumber{
			0x0b3765ab, 0x0ed3e150, 0x02134041, 0x0ec8f519,
			0x0acb91c3, 0x0f916fd5, 0x099a9e35, 0x0e44da01,
			0x0c16e971, 0x0c1b213b, 0x0e824448, 0x0b197385,
			0x07988fd4, 0x0ab877a6, 0x0d658e39, 0x0cf66684,
		},
	}

	exp := &twExtendedPoint{
		&bigNumber{
			0x0d6a2637, 0x0cee14c7, 0x0b626f81, 0x02a8151b,
			0x01d9b4a2, 0x00c23d77, 0x0859f8bc, 0x0e02e853,
			0x0314bf95, 0x04447761, 0x09fb76bd, 0x0dd35230,
			0x03b3f440, 0x017dc316, 0x09bf7799, 0x054f1cc4,
		},
		&bigNumber{
			0x021dd329, 0x019d887a, 0x0029b32a, 0x06a01e7d,
			0x06081030, 0x036080a2, 0x05c8240b, 0x0c11a3bc,
			0x00a2ecfe, 0x045ecf89, 0x08e0d084, 0x06f80067,
			0x0b9d1318, 0x0b8bfeb3, 0x07487524, 0x04e1609a,
		},
		&bigNumber{
			0x067eb923, 0x0d7bbefe, 0x0cf769ff, 0x05725ec8,
			0x0c23c0ad, 0x091bcba2, 0x0de48aec, 0x02c71185,
			0x0e607ca2, 0x042ba874, 0x08a195fa, 0x04386d91,
			0x079778f4, 0x045ecac6, 0x02c493ab, 0x050614a7,
		},
		&bigNumber{
			0x0f69cb7d, 0x0b9c1d3c, 0x087a352c, 0x06c4b483,
			0x025fb591, 0x0bf2bd90, 0x08f3ffa4, 0x008659f1,
			0x062cc1fd, 0x0892fc5b, 0x05f37db7, 0x017d17a8,
			0x01b92f20, 0x088ba2bd, 0x00e3ed5f, 0x0230bb39,
		},
	}

	p.add(q, r)
	c.Assert(p, DeepEquals, exp)

	//commute
	a := p.copy()
	a.add(q, r)
	b := p.copy()
	b.add(r, q)

	c.Assert(a, DeepEquals, b)
}

func (s *Ed448Suite) Test_PointSub(c *C) {
	p := &twExtendedPoint{
		&bigNumber{},
		&bigNumber{},
		&bigNumber{},
		&bigNumber{},
	}

	q := &twExtendedPoint{
		&bigNumber{
			0x0a7f964a, 0x0db033f8, 0x062b9f0b, 0x07bff7d6,
			0x05e755a2, 0x013b6f8b, 0x0f080bdc, 0x0a112ac0,
			0x0416988a, 0x03404b2f, 0x00561ea3, 0x01df752c,
			0x070e0b1c, 0x0e73a0c4, 0x078245d5, 0x09a42df0,
		},
		&bigNumber{
			0x0c2e6c3d, 0x0a03c3f2, 0x0fd16e97, 0x0bab4ec6,
			0x08ddba78, 0x091638ef, 0x0b0add85, 0x070c212d,
			0x04bcd337, 0x0c828579, 0x0712cfff, 0x09c1534a,
			0x0119cafe, 0x08e72ee0, 0x0f14ff19, 0x0d0c7e25,
		},
		&bigNumber{
			0x0a0d6be1, 0x0bcd9788, 0x00f9ca8a, 0x038cf839,
			0x00912da2, 0x0a3c503a, 0x056fe7e0, 0x03db9a49,
			0x0f19d062, 0x052ac631, 0x01cbda35, 0x02967214,
			0x0eed2db2, 0x0a948ce0, 0x05f7a3a7, 0x0fa35bc2,
		},
		&bigNumber{
			0x0fc9f32d, 0x0e442931, 0x065e50ff, 0x04be230d,
			0x0dc923c2, 0x0000467c, 0x08fc8902, 0x0e034cfb,
			0x0126370c, 0x06ec706d, 0x06ff07ad, 0x0a27cd65,
			0x060f214f, 0x0eb7756d, 0x0b694dc7, 0x015705ad,
		},
	}

	r := &twExtendedPoint{
		&bigNumber{
			0x075ee82f, 0x0078024b, 0x0a72cc37, 0x07b7b942,
			0x01dc37cd, 0x05b2ca96, 0x0fa5deaf, 0x071020de,
			0x09122cbe, 0x01bdbe1d, 0x0eeb69f3, 0x073d88cf,
			0x0777b71a, 0x0aa1660a, 0x0c4476bf, 0x08e2cf30,
		},
		&bigNumber{
			0x0aab8840, 0x0f0932b3, 0x0088be9e, 0x0c4d55d6,
			0x01926f40, 0x01c112e0, 0x0884dc6d, 0x0e66b50b,
			0x09120ee4, 0x0750ee39, 0x048c6ce2, 0x00f9fe35,
			0x0f74988e, 0x05693a13, 0x0c1d267c, 0x052d5ba0,
		},
		&bigNumber{
			0x043efd14, 0x07ce59a0, 0x0f9b7154, 0x05663cbd,
			0x055ba08f, 0x0525f2b7, 0x0e1d908d, 0x06d7d26a,
			0x0c4cee28, 0x02039ee7, 0x0a733b28, 0x01be5db0,
			0x056e9a37, 0x0db1b9b6, 0x088880cd, 0x03d26863,
		},
		&bigNumber{
			0x0b3765ab, 0x0ed3e150, 0x02134041, 0x0ec8f519,
			0x0acb91c3, 0x0f916fd5, 0x099a9e35, 0x0e44da01,
			0x0c16e971, 0x0c1b213b, 0x0e824448, 0x0b197385,
			0x07988fd4, 0x0ab877a6, 0x0d658e39, 0x0cf66684,
		},
	}

	exp := &twExtendedPoint{
		&bigNumber{
			0x0e264012, 0x0c218ff9, 0x06393c0f, 0x0864e62d,
			0x05f0e534, 0x0267756d, 0x0ce40403, 0x0e9e240d,
			0x09597584, 0x027844b2, 0x0f8842bf, 0x01b5f03d,
			0x05fbfd9a, 0x0e4ed5e3, 0x07087964, 0x07dc52d0,
		},

		&bigNumber{
			0x05484245, 0x0f3c416d, 0x083a1e46, 0x05e6a9d8,
			0x05bfedad, 0x0a9a7379, 0x00b489c3, 0x0de89d6b,
			0x04e7709d, 0x0149bd11, 0x017eb71a, 0x0223de4a,
			0x00d9bd0d, 0x093c76a6, 0x072fe435, 0x0d6fd2c5,
		},
		&bigNumber{
			0x067eb923, 0x0d7bbefe, 0x0cf769ff, 0x05725ec8,
			0x0c23c0ad, 0x091bcba2, 0x0de48aec, 0x02c71185,
			0x0e607ca2, 0x042ba874, 0x08a195fa, 0x04386d91,
			0x079778f4, 0x045ecac6, 0x02c493ab, 0x050614a7,
		},
		&bigNumber{
			0x0455a73b, 0x0cfbe5f2, 0x0cdb56a2, 0x06477b21,
			0x0fda6909, 0x07f6faeb, 0x04ebea8b, 0x0d1e04b7,
			0x00307c2a, 0x0e926e5c, 0x0efdf04c, 0x038841bb,
			0x09be04e8, 0x001137e1, 0x0515b17d, 0x0ea27de2,
		},
	}

	p.sub(q, r)
	c.Assert(p, DeepEquals, exp)
}

func (s *Ed448Suite) Test_PointNegate(c *C) {
	p := &twExtendedPoint{
		&bigNumber{},
		&bigNumber{},
		&bigNumber{},
		&bigNumber{},
	}

	q := &twExtendedPoint{
		&bigNumber{
			0x0a7f964a, 0x0db033f8, 0x062b9f0b, 0x07bff7d6,
			0x05e755a2, 0x013b6f8b, 0x0f080bdc, 0x0a112ac0,
			0x0416988a, 0x03404b2f, 0x00561ea3, 0x01df752c,
			0x070e0b1c, 0x0e73a0c4, 0x078245d5, 0x09a42df0,
		},
		&bigNumber{
			0x0c2e6c3d, 0x0a03c3f2, 0x0fd16e97, 0x0bab4ec6,
			0x08ddba78, 0x091638ef, 0x0b0add85, 0x070c212d,
			0x04bcd337, 0x0c828579, 0x0712cfff, 0x09c1534a,
			0x0119cafe, 0x08e72ee0, 0x0f14ff19, 0x0d0c7e25,
		},
		&bigNumber{
			0x0a0d6be1, 0x0bcd9788, 0x00f9ca8a, 0x038cf839,
			0x00912da2, 0x0a3c503a, 0x056fe7e0, 0x03db9a49,
			0x0f19d062, 0x052ac631, 0x01cbda35, 0x02967214,
			0x0eed2db2, 0x0a948ce0, 0x05f7a3a7, 0x0fa35bc2,
		},
		&bigNumber{
			0x0fc9f32d, 0x0e442931, 0x065e50ff, 0x04be230d,
			0x0dc923c2, 0x0000467c, 0x08fc8902, 0x0e034cfb,
			0x0126370c, 0x06ec706d, 0x06ff07ad, 0x0a27cd65,
			0x060f214f, 0x0eb7756d, 0x0b694dc7, 0x015705ad,
		},
	}

	exp := &twExtendedPoint{
		&bigNumber{
			0x058069b5, 0x024fcc07, 0x09d460f4, 0x08400829,
			0x0a18aa5d, 0x0ec49074, 0x00f7f423, 0x05eed53f,
			0x0be96774, 0x0cbfb4d0, 0x0fa9e15c, 0x0e208ad3,
			0x08f1f4e3, 0x018c5f3b, 0x087dba2a, 0x065bd20f,
		},
		&bigNumber{
			0x0c2e6c3d, 0x0a03c3f2, 0x0fd16e97, 0x0bab4ec6,
			0x08ddba78, 0x091638ef, 0x0b0add85, 0x070c212d,
			0x04bcd337, 0x0c828579, 0x0712cfff, 0x09c1534a,
			0x0119cafe, 0x08e72ee0, 0x0f14ff19, 0x0d0c7e25,
		},
		&bigNumber{
			0x0a0d6be1, 0x0bcd9788, 0x00f9ca8a, 0x038cf839,
			0x00912da2, 0x0a3c503a, 0x056fe7e0, 0x03db9a49,
			0x0f19d062, 0x052ac631, 0x01cbda35, 0x02967214,
			0x0eed2db2, 0x0a948ce0, 0x05f7a3a7, 0x0fa35bc2,
		},
		&bigNumber{
			0x00360cd2, 0x01bbd6ce, 0x09a1af00, 0x0b41dcf2,
			0x0236dc3d, 0x0fffb983, 0x070376fd, 0x01fcb304,
			0x0ed9c8f2, 0x09138f92, 0x0900f852, 0x05d8329a,
			0x09f0deb0, 0x01488a92, 0x0496b238, 0x0ea8fa52,
		},
	}

	p.negate(q)
	c.Assert(p, DeepEquals, exp)
}

func (s *Ed448Suite) Test_PointTorque(c *C) {
	p := &twExtendedPoint{
		&bigNumber{},
		&bigNumber{},
		&bigNumber{},
		&bigNumber{},
	}

	q := &twExtendedPoint{
		&bigNumber{
			0x0a7f964a, 0x0db033f8, 0x062b9f0b, 0x07bff7d6,
			0x05e755a2, 0x013b6f8b, 0x0f080bdc, 0x0a112ac0,
			0x0416988a, 0x03404b2f, 0x00561ea3, 0x01df752c,
			0x070e0b1c, 0x0e73a0c4, 0x078245d5, 0x09a42df0,
		},
		&bigNumber{
			0x0c2e6c3d, 0x0a03c3f2, 0x0fd16e97, 0x0bab4ec6,
			0x08ddba78, 0x091638ef, 0x0b0add85, 0x070c212d,
			0x04bcd337, 0x0c828579, 0x0712cfff, 0x09c1534a,
			0x0119cafe, 0x08e72ee0, 0x0f14ff19, 0x0d0c7e25,
		},
		&bigNumber{
			0x0a0d6be1, 0x0bcd9788, 0x00f9ca8a, 0x038cf839,
			0x00912da2, 0x0a3c503a, 0x056fe7e0, 0x03db9a49,
			0x0f19d062, 0x052ac631, 0x01cbda35, 0x02967214,
			0x0eed2db2, 0x0a948ce0, 0x05f7a3a7, 0x0fa35bc2,
		},
		&bigNumber{
			0x0fc9f32d, 0x0e442931, 0x065e50ff, 0x04be230d,
			0x0dc923c2, 0x0000467c, 0x08fc8902, 0x0e034cfb,
			0x0126370c, 0x06ec706d, 0x06ff07ad, 0x0a27cd65,
			0x060f214f, 0x0eb7756d, 0x0b694dc7, 0x015705ad,
		},
	}

	exp := &twExtendedPoint{
		&bigNumber{
			0x058069b5, 0x024fcc07, 0x09d460f4, 0x08400829,
			0x0a18aa5d, 0x0ec49074, 0x00f7f423, 0x05eed53f,
			0x0be96774, 0x0cbfb4d0, 0x0fa9e15c, 0x0e208ad3,
			0x08f1f4e3, 0x018c5f3b, 0x087dba2a, 0x065bd20f,
		},
		&bigNumber{
			0x03d193c2, 0x05fc3c0d, 0x002e9168, 0x0454b139,
			0x07224587, 0x06e9c710, 0x04f5227a, 0x08f3ded2,
			0x0b432cc7, 0x037d7a86, 0x08ed3000, 0x063eacb5,
			0x0ee63501, 0x0718d11f, 0x00eb00e6, 0x02f381da,
		},
		&bigNumber{
			0x0a0d6be1, 0x0bcd9788, 0x00f9ca8a, 0x038cf839,
			0x00912da2, 0x0a3c503a, 0x056fe7e0, 0x03db9a49,
			0x0f19d062, 0x052ac631, 0x01cbda35, 0x02967214,
			0x0eed2db2, 0x0a948ce0, 0x05f7a3a7, 0x0fa35bc2,
		},
		&bigNumber{
			0x0fc9f32d, 0x0e442931, 0x065e50ff, 0x04be230d,
			0x0dc923c2, 0x0000467c, 0x08fc8902, 0x0e034cfb,
			0x0126370c, 0x06ec706d, 0x06ff07ad, 0x0a27cd65,
			0x060f214f, 0x0eb7756d, 0x0b694dc7, 0x015705ad,
		},
	}

	p.torque(q)
	c.Assert(p, DeepEquals, exp)
}

func (s *Ed448Suite) Test_PointDoubleInternal(c *C) {
	p := &twExtendedPoint{
		&bigNumber{
			0x08354b7a, 0x0895b3e8, 0x06ae5175, 0x0644b394,
			0x0b7faf9e, 0x0c5237db, 0x013a0c90, 0x08f5bce0,
			0x09a3d79b, 0x00f17559, 0x0de8f041, 0x073e222f,
			0x0dc2b7ee, 0x005ac354, 0x0766db38, 0x065631fe,
		},
		&bigNumber{
			0x00398885, 0x055c9bed, 0x0ae443ca, 0x0fd70ea4,
			0x09e2a7d2, 0x04ac2e9d, 0x00678287, 0x0294768e,
			0x0b604cea, 0x07b49317, 0x0dc2a6d9, 0x0e44a6fb,
			0x09db3965, 0x049d3bf5, 0x03e655fe, 0x003a9c02,
		},
		&bigNumber{
			0x0fd57162, 0x0a39f768, 0x03009756, 0x065d735f,
			0x0d1da282, 0x0589ecd7, 0x003196b1, 0x0c001dfe,
			0x019f1050, 0x0152e8d2, 0x0c14ff38, 0x00f7a446,
			0x028053f6, 0x0f8a91e9, 0x05a8d694, 0x09d5ae86,
		},
		&bigNumber{
			0x04198f2e, 0x0d82440f, 0x0fce100e, 0x0af4829d,
			0x0d5c3516, 0x0094a0da, 0x078cdb39, 0x0e738836,
			0x01ec536d, 0x06dfd1e9, 0x0ee16173, 0x0addc8c0,
			0x0797fb1d, 0x059741a3, 0x0a7f9c34, 0x088fe0a6,
		},
	}

	exp := &twExtendedPoint{
		&bigNumber{
			0x00d8f04c, 0x03e54689, 0x0eb4db2b, 0x0887ba34,
			0x0a5b4ebc, 0x0f6c0261, 0x03bfa803, 0x0408ff02,
			0x03b4ef26, 0x0465c028, 0x0cd47378, 0x064c55b4,
			0x08245850, 0x01912682, 0x0dcbf92c, 0x07a7fa30,
		},
		&bigNumber{
			0x0d94d1a6, 0x0f7306e8, 0x0278b336, 0x04362b7b,
			0x0faf02b9, 0x06b01d18, 0x07a597da, 0x0bd6add0,
			0x047afa98, 0x0e64e897, 0x0bbf88e6, 0x01d0a534,
			0x04a52b9d, 0x0af374e0, 0x05091d54, 0x00fcf1a5,
		},
		&bigNumber{
			0x042318ce, 0x04aecdae, 0x0e8f196b, 0x0019d2e3,
			0x045d147c, 0x060b153e, 0x0adf2c37, 0x0419cdd8,
			0x06d19046, 0x00d18821, 0x06c7b9c2, 0x0c0ffd68,
			0x0b7e4ca2, 0x06da0d56, 0x0952b40f, 0x03008395,
		},
		&bigNumber{
			0x04643593, 0x000e0fdd, 0x013f29f3, 0x0bb8992d,
			0x0a30d344, 0x09151eec, 0x0d12bb82, 0x05c7a054,
			0x0103c2c6, 0x08a61fe2, 0x0aced4bf, 0x0f76d481,
			0x0db774be, 0x065ef8a8, 0x0ff47a71, 0x0f49f73e,
		},
	}

	p.doubleInternal(false)

	c.Assert(p, DeepEquals, exp)

	q := &twExtendedPoint{
		&bigNumber{0x01},
		&bigNumber{0x02},
		&bigNumber{0x03},
		&bigNumber{0x04},
	}

	exp = &twExtendedPoint{
		&bigNumber{
			0x0000003b, 0x10000000, 0x0fffffff, 0x0fffffff,
			0x0fffffff, 0x0fffffff, 0x0fffffff, 0x0fffffff,
			0x0ffffffe, 0x0fffffff, 0x0fffffff, 0x0fffffff,
			0x0fffffff, 0x0fffffff, 0x0fffffff, 0x0fffffff,
		},
		&bigNumber{
			0x0000000e, 0x00000000, 0x00000000, 0x00000000,
			0x00000000, 0x00000000, 0x00000000, 0x00000000,
			0x0fffffff, 0x0fffffff, 0x0fffffff, 0x0fffffff,
			0x0fffffff, 0x0fffffff, 0x0fffffff, 0x0fffffff,
		},
		&bigNumber{
			0x0000002c, 0x10000000, 0x0fffffff, 0x0fffffff,
			0x0fffffff, 0x0fffffff, 0x0fffffff, 0x0fffffff,
			0x0ffffffe, 0x0fffffff, 0x0fffffff, 0x0fffffff,
			0x0fffffff, 0x0fffffff, 0x0fffffff, 0x0fffffff,
		},
		&bigNumber{
			0x00000002, 0x10000000, 0x0fffffff, 0x0fffffff,
			0x0fffffff, 0x0fffffff, 0x0fffffff, 0x0fffffff,
			0x0ffffffe, 0x0fffffff, 0x0fffffff, 0x0fffffff,
			0x0fffffff, 0x0fffffff, 0x0fffffff, 0x0fffffff,
		},
	}

	q.doubleInternal(true)

	c.Assert(q, DeepEquals, exp)
}

func (s *Ed448Suite) Test_Deisogenize(c *C) {
	inv1, inv2 := &bigNumber{}, &bigNumber{}

	p := &twExtendedPoint{
		&bigNumber{
			0x0fffffff, 0x0fffffff, 0x0fffffff, 0x0fffffff,
			0x0fffffff, 0x0fffffff, 0x0fffffff, 0x0fffffff,
			0x0ffffffe, 0x0fffffff, 0x0fffffff, 0x0fffffff,
			0x0fffffff, 0x0fffffff, 0x0fffffff, 0x0fffffff,
		},
		&bigNumber{
			0x00000000, 0x01000000, 0x0fffffff, 0x0fffffff,
			0x0fffffff, 0x0fffffff, 0x0fffffff, 0x0fffffff,
			0x0ffffffe, 0x0fffffff, 0x0fffffff, 0x0fffffff,
			0x0fffffff, 0x0fffffff, 0x0fffffff, 0x0fffffff,
		},
		&bigNumber{
			0x0ffffffe, 0x0fffffff, 0x0fffffff, 0x0fffffff,
			0x0fffffff, 0x0fffffff, 0x0fffffff, 0x0fffffff,
			0x0ffffffe, 0x0fffffff, 0x0fffffff, 0x0fffffff,
			0x0fffffff, 0x0fffffff, 0x0fffffff, 0x0fffffff,
		},
		&bigNumber{
			0x0fffffff, 0x0fffffff, 0x0fffffff, 0x0fffffff,
			0x0fffffff, 0x0fffffff, 0x0fffffff, 0x0fffffff,
			0x0ffffffe, 0x0fffffff, 0x0fffffff, 0x0fffffff,
			0x0fffffff, 0x0fffffff, 0x0fffffff, 0x0fffffff,
		},
	}

	toggleS, toggleAltX := word(0), word(0)

	sc := p.deisogenizeNew(inv1, inv2, toggleS, toggleAltX)

	exp := &bigNumber{
		0x0fffffff, 0x0fffffff, 0x0fffffff, 0x0fffffff,
		0x0fffffff, 0x0fffffff, 0x0fffffff, 0x0fffffff,
		0x0ffffffe, 0x0fffffff, 0x0fffffff, 0x0fffffff,
		0x0fffffff, 0x0fffffff, 0x0fffffff, 0x0fffffff,
	}

	c.Assert(sc, DeepEquals, exp)

	inv11, inv21 :=
		&bigNumber{
			0x0fffffff, 0x0fffffff, 0x0fffffff, 0x0fffffff,
			0x0fffffff, 0x0fffffff, 0x0fffffff, 0x0fffffff,
			0x0ffffffe, 0x0fffffff, 0x0fffffff, 0x0fffffff,
			0x0fffffff, 0x0fffffff, 0x0fffffff, 0x0fffffff,
		},
		&bigNumber{
			0x0fffffff, 0x0fffffff, 0x0fffffff, 0x0fffffff,
			0x0fffffff, 0x0fffffff, 0x0fffffff, 0x0fffffff,
			0x0ffffffe, 0x0fffffff, 0x0fffffff, 0x0fffffff,
			0x0fffffff, 0x0fffffff, 0x0fffffff, 0x0fffffff,
		}

	q := &twExtendedPoint{
		&bigNumber{
			0x0fffffff, 0x0fffffff, 0x0fffffff, 0x0fffffff,
			0x0fffffff, 0x0fffffff, 0x0fffffff, 0x0fffffff,
			0x0ffffffe, 0x0fffffff, 0x0fffffff, 0x0fffffff,
			0x0fffffff, 0x0fffffff, 0x0fffffff, 0x0fffffff,
		},
		&bigNumber{
			0x01ff5b2b, 0x06b9b14c, 0x0bdb2bc2, 0x0256b19a,
			0x0dd7ef78, 0x05a7cb30, 0x04df2bcc, 0x0d68d3a0,
			0x0c2ed8b7, 0x0a578406, 0x06d564ae, 0x0fd10109,
			0x017e32b0, 0x02c29749, 0x0dbc3031, 0x047c349a,
		},
		&bigNumber{
			0x0e00a4d4, 0x09464eb3, 0x0424d43d, 0x0da94e65,
			0x02281087, 0x0a5834cf, 0x0b20d433, 0x02972c5f,
			0x03d12747, 0x05a87bf9, 0x092a9b51, 0x002efef6,
			0x0e81cd4f, 0x0d3d68b6, 0x0243cfce, 0x0b83cb65,
		},
		&bigNumber{
			0x0fffffff, 0x0fffffff, 0x0fffffff, 0x0fffffff,
			0x0fffffff, 0x0fffffff, 0x0fffffff, 0x0fffffff,
			0x0ffffffe, 0x0fffffff, 0x0fffffff, 0x0fffffff,
			0x0fffffff, 0x0fffffff, 0x0fffffff, 0x0fffffff,
		},
	}

	sc = q.deisogenizeNew(inv11, inv21, toggleS, toggleAltX)

	exp = &bigNumber{
		0x0fffffff, 0x0fffffff, 0x0fffffff, 0x0fffffff,
		0x0fffffff, 0x0fffffff, 0x0fffffff, 0x0fffffff,
		0x0ffffffe, 0x0fffffff, 0x0fffffff, 0x0fffffff,
		0x0fffffff, 0x0fffffff, 0x0fffffff, 0x0fffffff,
	}

	c.Assert(sc, DeepEquals, exp)

	inv12, inv22 :=
		&bigNumber{
			0x0ffffffe, 0x0fffffff, 0x0fffffff, 0x0fffffff,
			0x0fffffff, 0x0fffffff, 0x0fffffff, 0x0fffffff,
			0x0ffffffe, 0x0fffffff, 0x0fffffff, 0x0fffffff,
			0x0fffffff, 0x0fffffff, 0x0fffffff, 0x0fffffff,
		},
		&bigNumber{
			0x00000000, 0x01000000, 0x0fffffff, 0x0fffffff,
			0x0fffffff, 0x0fffffff, 0x0fffffff, 0x0fffffff,
			0x0ffffffe, 0x0fffffff, 0x0fffffff, 0x0fffffff,
			0x0fffffff, 0x0fffffff, 0x0fffffff, 0x0fffffff,
		}

	sc = q.deisogenizeNew(inv12, inv22, word(0xff), toggleAltX)

	exp = &bigNumber{
		0x0fffffff, 0x0fffffff, 0x0fffffff, 0x0fffffff,
		0x0fffffff, 0x0fffffff, 0x0fffffff, 0x0fffffff,
		0x0ffffffe, 0x0fffffff, 0x0fffffff, 0x0fffffff,
		0x0fffffff, 0x0fffffff, 0x0fffffff, 0x0fffffff,
	}

	c.Assert(sc, DeepEquals, exp)
}

func (s *Ed448Suite) Test_DecafEncode(c *C) {
	p := &twExtendedPoint{
		&bigNumber{
			0x0d9a309b, 0x000289cb, 0x02d19f65, 0x0b622ac4,
			0x05e6807f, 0x0a08b7f8, 0x0a2a124a, 0x00be3938,
			0x08475ec5, 0x00682935, 0x0ab32a89, 0x08377f34,
			0x075f359d, 0x0f12f2dc, 0x08d30bbc, 0x04c9b187,
		},
		&bigNumber{
			0x0627d6a6, 0x0d4bd92c, 0x0a91b860, 0x0209d8f9,
			0x0acef183, 0x038a181b, 0x01a80ca4, 0x036550a0,
			0x0810b32f, 0x0697d168, 0x01832b57, 0x0a92e97a,
			0x0c59385b, 0x085ebf7e, 0x035e4c9b, 0x01d4a5ce,
		},
		&bigNumber{
			0x02c059ed, 0x0a48a55e, 0x0c8728bd, 0x09bf85c1,
			0x0d10487f, 0x0dad01c8, 0x0ec8b362, 0x067d381b,
			0x0bd55d03, 0x0fa6172f, 0x0da14dd1, 0x00bd1e8d,
			0x0d7d1137, 0x073a3e0c, 0x0418d0cb, 0x0eaeb008,
		},
		&bigNumber{
			0x0ce390f7, 0x00deca5e, 0x02f49eb1, 0x0f1bdd2b,
			0x0440bb6a, 0x04a99c96, 0x086d3a76, 0x035d2358,
			0x0f89d14b, 0x0ccb0445, 0x0dfbf181, 0x05c26d7b,
			0x09185fba, 0x0dc1a6e0, 0x04f24b49, 0x0b419134,
		},
	}

	b, _ := hex.DecodeString("e4b2a1a14395b5eb3a5c3f3d265782efc28b9a94cc1d46fff8725079cee988d0955a3da9a2ef30abc30ef1bd947f48e093aad8405db1d268")

	dst := [fieldBytes]byte{}

	p.decafEncode(dst[:])

	c.Assert(dst[:], DeepEquals, b)
}

func (s *Ed448Suite) Test_DecafDecode(c *C) {
	p := &twExtendedPoint{
		x: &bigNumber{},
		y: &bigNumber{},
		z: &bigNumber{},
		t: &bigNumber{},
	}

	ok, err := decafDecodeOld(p, serialized{
		0xe4, 0xb2, 0xa1, 0xa1, 0x43, 0x95, 0xb5,
		0xeb, 0x3a, 0x5c, 0x3f, 0x3d, 0x26, 0x57,
		0x82, 0xef, 0xc2, 0x8b, 0x9a, 0x94, 0xcc,
		0x1d, 0x46, 0xff, 0xf8, 0x72, 0x50, 0x79,
		0xce, 0xe9, 0x88, 0xd0, 0x95, 0x5a, 0x3d,
		0xa9, 0xa2, 0xef, 0x30, 0xab, 0xc3, 0x0e,
		0xf1, 0xbd, 0x94, 0x7f, 0x48, 0xe0, 0x93,
		0xaa, 0xd8, 0x40, 0x5d, 0xb1, 0xd2, 0x68,
	}, false)

	exp := &twExtendedPoint{
		&bigNumber{
			0x034365c8, 0x06b2a874, 0x0eb875d7, 0x0ae4c7a7,
			0x0785df04, 0x09929351, 0x01fe8c3b, 0x0f2a0e5f,
			0x0111d39c, 0x07ab52ba, 0x01df4552, 0x01d87566,
			0x0f297be2, 0x027c090f, 0x0a81b155, 0x0d1a562b,
		},
		&bigNumber{
			0x00da9708, 0x0e7d583e, 0x0dbcc099, 0x0d2dad89,
			0x05a49ce4, 0x01cb4ddc, 0x0928d395, 0x0098d91d,
			0x0bff16ce, 0x06f02f9a, 0x0ce27cc1, 0x0dab5783,
			0x0b553d94, 0x03251a0c, 0x064d70fb, 0x07fe3a2f,
		},
		&bigNumber{
			0x0d5237cc, 0x0319d105, 0x02ab2df5, 0x022e9736,
			0x0d79742f, 0x00688712, 0x012d3a65, 0x0ef4925e,
			0x0bd0d260, 0x0832b532, 0x05faef27, 0x01ffe567,
			0x0161ce73, 0x07bda0f5, 0x035d04f1, 0x0930f532,
		},
		&bigNumber{
			0x01f6cc27, 0x09be7b8a, 0x0226da79, 0x0f6202f1,
			0x0e7264dc, 0x0d25aeb1, 0x06c81f07, 0x03c32cdc,
			0x0923c854, 0x0cfc9865, 0x055b2fed, 0x05bdcc90,
			0x01a99835, 0x0ea08056, 0x0abbf763, 0x03826c2f,
		},
	}

	c.Assert(p, DeepEquals, exp)
	c.Assert(ok, Equals, word(lmask))
	c.Assert(err, IsNil)

	//allow identity
	q := &twExtendedPoint{
		x: &bigNumber{},
		y: &bigNumber{},
		z: &bigNumber{},
		t: &bigNumber{},
	}

	ok, err = decafDecodeOld(q, serialized{
		0xe4, 0xb2, 0xa1, 0xa1, 0x43, 0x95, 0xb5,
		0xeb, 0x3a, 0x5c, 0x3f, 0x3d, 0x26, 0x57,
		0x82, 0xef, 0xc2, 0x8b, 0x9a, 0x94, 0xcc,
		0x1d, 0x46, 0xff, 0xf8, 0x72, 0x50, 0x79,
		0xce, 0xe9, 0x88, 0xd0, 0x95, 0x5a, 0x3d,
		0xa9, 0xa2, 0xef, 0x30, 0xab, 0xc3, 0x0e,
		0xf1, 0xbd, 0x94, 0x7f, 0x48, 0xe0, 0x93,
		0xaa, 0xd8, 0x40, 0x5d, 0xb1, 0xd2, 0x68,
	}, true)

	exp = &twExtendedPoint{
		&bigNumber{
			0x034365c8, 0x06b2a874, 0x0eb875d7, 0x0ae4c7a7,
			0x0785df04, 0x09929351, 0x01fe8c3b, 0x0f2a0e5f,
			0x0111d39c, 0x07ab52ba, 0x01df4552, 0x01d87566,
			0x0f297be2, 0x027c090f, 0x0a81b155, 0x0d1a562b,
		},
		&bigNumber{
			0x00da9708, 0x0e7d583e, 0x0dbcc099, 0x0d2dad89,
			0x05a49ce4, 0x01cb4ddc, 0x0928d395, 0x0098d91d,
			0x0bff16ce, 0x06f02f9a, 0x0ce27cc1, 0x0dab5783,
			0x0b553d94, 0x03251a0c, 0x064d70fb, 0x07fe3a2f,
		},
		&bigNumber{
			0x0d5237cc, 0x0319d105, 0x02ab2df5, 0x022e9736,
			0x0d79742f, 0x00688712, 0x012d3a65, 0x0ef4925e,
			0x0bd0d260, 0x0832b532, 0x05faef27, 0x01ffe567,
			0x0161ce73, 0x07bda0f5, 0x035d04f1, 0x0930f532,
		},
		&bigNumber{
			0x01f6cc27, 0x09be7b8a, 0x0226da79, 0x0f6202f1,
			0x0e7264dc, 0x0d25aeb1, 0x06c81f07, 0x03c32cdc,
			0x0923c854, 0x0cfc9865, 0x055b2fed, 0x05bdcc90,
			0x01a99835, 0x0ea08056, 0x0abbf763, 0x03826c2f,
		},
	}

	c.Assert(q, DeepEquals, exp)
	c.Assert(ok, Equals, decafTrue)
	c.Assert(err, IsNil)

	// invalid input
	ok, err = decafDecodeOld(p, serialized{
		0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
		0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
		0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
		0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
		0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
		0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
		0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
		0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
	}, false)

	c.Assert(ok, Equals, decafFalse)
	c.Assert(err, ErrorMatches, "unable to decode given point")
}

func (s *Ed448Suite) Test_EdDSALikeEncode(c *C) {
	p := &twExtendedPoint{
		&bigNumber{
			0x07278dc5, 0x0e614a9f, 0x004c5124, 0x02e454ad,
			0x0e1436f3, 0x0d8f58ce, 0x0e4180ec, 0x0c83ed46,
			0x074a38fa, 0x0a41e932, 0x0257771e, 0x0c1e7e53,
			0x03c0392f, 0x043e0ff0, 0x05ce61df, 0x02c7c640,
		},
		&bigNumber{
			0x0c990b33, 0x033c4f9d, 0x0ceb55c3, 0x0c291cb1,
			0x0ade88b2, 0x02ae3f58, 0x01395474, 0x06b1f9f1,
			0x0b27ff7c, 0x02ded6e4, 0x04aa10e1, 0x041012ed,
			0x0a36bae7, 0x03c22d20, 0x0d472b19, 0x01f584ee,
		},
		&bigNumber{
			0x09ee6f60, 0x0c351477, 0x03b20c2b, 0x01574c87,
			0x0a5a5e65, 0x04cd6a46, 0x0eb4204a, 0x059a068a,
			0x08bc354d, 0x04c61045, 0x079d02d2, 0x0e945674,
			0x0d118e28, 0x0feaf77e, 0x0115eeb5, 0x0f58a8bf,
		},
		&bigNumber{
			0x08fcb20f, 0x04611087, 0x01cc6f32, 0x0df43db2,
			0x04516644, 0x0ffdde9f, 0x091686b9, 0x05199177,
			0x0fd34473, 0x0b72b441, 0x0cb1c72b, 0x08d45684,
			0x00fc17a5, 0x01518137, 0x007f74d3, 0x0a456d13,
		},
	}

	var out [57]byte
	p.edDSALikeEncode(out[:])

	exp := [57]byte{
		0xa5, 0xd9, 0xce, 0xa4, 0x06, 0x89, 0xa4, 0x13,
		0x94, 0xf0, 0x69, 0x32, 0xfe, 0xe0, 0xdb, 0x11,
		0x7b, 0xe0, 0x75, 0x78, 0x68, 0x2c, 0x48, 0x44,
		0x70, 0x3b, 0xe9, 0xc6, 0x64, 0xde, 0x6c, 0xe0,
		0xd6, 0xa5, 0xa3, 0x4e, 0xe7, 0x38, 0xd9, 0xb3,
		0x0c, 0x93, 0x75, 0x75, 0x8d, 0xe8, 0x50, 0xde,
		0x06, 0x2c, 0xb9, 0x75, 0x50, 0x7d, 0x24, 0x85,
		0x00,
	}

	c.Assert(out, DeepEquals, exp)

	var invalid [56]byte

	c.Assert(func() { p.edDSALikeEncode(invalid[:]) }, Panics, "Attempted to encode with a destination that is not 57 bytes")
}

func (s *Ed448Suite) Test_EdDSALikeDecode(c *C) {
	ser := [57]byte{
		0xa5, 0xd9, 0xce, 0xa4, 0x06, 0x89, 0xa4, 0x13,
		0x94, 0xf0, 0x69, 0x32, 0xfe, 0xe0, 0xdb, 0x11,
		0x7b, 0xe0, 0x75, 0x78, 0x68, 0x2c, 0x48, 0x44,
		0x70, 0x3b, 0xe9, 0xc6, 0x64, 0xde, 0x6c, 0xe0,
		0xd6, 0xa5, 0xa3, 0x4e, 0xe7, 0x38, 0xd9, 0xb3,
		0x0c, 0x93, 0x75, 0x75, 0x8d, 0xe8, 0x50, 0xde,
		0x06, 0x2c, 0xb9, 0x75, 0x50, 0x7d, 0x24, 0x85,
		0x00,
	}

	p := &twExtendedPoint{
		&bigNumber{},
		&bigNumber{},
		&bigNumber{},
		&bigNumber{},
	}

	exp := &twExtendedPoint{
		&bigNumber{
			0x0c7e3738, 0x0cbdc97c, 0x0d8e25f0, 0x03332483,
			0x0111e7fc, 0x0c4b6cc7, 0x0f8f792c, 0x0bfabfc9,
			0x06401561, 0x008bed52, 0x029a6321, 0x0093629d,
			0x07cc65ec, 0x0a0306c6, 0x09cdac09, 0x01124131,
		},
		&bigNumber{
			0x0c35f413, 0x0bea33bb, 0x0a35ff5e, 0x0db8b320,
			0x0decf793, 0x0ce8a106, 0x0b6ca51d, 0x0454dc1c,
			0x005424ab, 0x0e976ae4, 0x091a6deb, 0x0780e161,
			0x0384d250, 0x00c5041e, 0x0bef5512, 0x0d39b7a4,
		},
		&bigNumber{
			0x01bff100, 0x01ba8567, 0x078a886e, 0x01a59234,
			0x0f7c2f29, 0x0507cdc8, 0x03211d38, 0x0ecf7fb8,
			0x08d25fe3, 0x0445a223, 0x039c7188, 0x0d6f989c,
			0x0722cff6, 0x0f0beee0, 0x0438ebd1, 0x0f3114e2,
		},
		&bigNumber{
			0x059c1192, 0x0a24f740, 0x09f8d723, 0x0db5fd8b,
			0x08e6159b, 0x00b004e2, 0x06f2f030, 0x035c4c38,
			0x01387946, 0x0355e067, 0x07d3e614, 0x09d57b9c,
			0x03b0c3d7, 0x07002ba2, 0x0f4e320f, 0x03eafa71,
		},
	}
	exp = pointScalarMul(exp, scalarOneFourth.(*scalar))

	succ := edDSALikeDecode(p, ser[:])

	c.Assert(p, DeepEquals, exp)
	c.Assert(succ, DeepEquals, decafTrue)

	invalid := make([]byte, 56)

	c.Assert(func() { edDSALikeDecode(p, invalid) }, Panics, "Attempted to decode with a source that is not 57 bytes")
}

func (s *Ed448Suite) Test_EdDSALikeDecodeAndEncode(c *C) {
	basePoint := &twExtendedPoint{
		&bigNumber{
			0x0ffffffe, 0x0fffffff, 0x0fffffff, 0x0fffffff,
			0x0fffffff, 0x0fffffff, 0x0fffffff, 0x0fffffff,
			0x00000003, 0x00000000, 0x00000000, 0x00000000,
			0x00000000, 0x00000000, 0x00000000, 0x00000000,
		},
		&bigNumber{
			0x0f752992, 0x081e6d37, 0x01c28721, 0x03078ead,
			0x0394666c, 0x0135cfd2, 0x00506061, 0x041149c5,
			0x0f5490b3, 0x031d30e4, 0x090dc141, 0x09020149,
			0x04c1e328, 0x052341b0, 0x03c10a1b, 0x01423785,
		},
		&bigNumber{
			0x0ffffffb, 0x0fffffff, 0x0fffffff, 0x0fffffff,
			0x0fffffff, 0x0fffffff, 0x0fffffff, 0x0fffffff,
			0x0ffffffe, 0x0fffffff, 0x0fffffff, 0x0fffffff,
			0x0fffffff, 0x0fffffff, 0x0fffffff, 0x0fffffff,
		},
		&bigNumber{
			0x00660415, 0x08f205b7, 0x0fd3824f, 0x0881c60c,
			0x0d08500d, 0x0377a638, 0x04672615, 0x08c66d5d,
			0x08e08e13, 0x0e52fa55, 0x01b6983d, 0x087770ae,
			0x0a0aa7ff, 0x04388f55, 0x05cf1a91, 0x0b4d9a78,
		},
	}

	var enc [57]byte
	basePoint.edDSALikeEncode(enc[:])
	dec := &twExtendedPoint{
		&bigNumber{},
		&bigNumber{},
		&bigNumber{},
		&bigNumber{},
	}

	valid := edDSALikeDecode(dec, enc[:])
	valid &= dec.equals(basePoint)

	c.Assert(valid, DeepEquals, decafTrue)
}

func (s *Ed448Suite) Test_AddNielsToExtended(c *C) {
	p := &twExtendedPoint{
		&bigNumber{0x00},
		&bigNumber{0x01},
		&bigNumber{0x01},
		&bigNumber{0x00},
	}
	q := &twNiels{
		&bigNumber{0x068d5b74},
		&bigNumber{0x068d5b74},
		&bigNumber{0x068d5b74},
	}

	exp := &twExtendedPoint{
		&bigNumber{
			0x0fffffff, 0x0fffffff, 0x0fffffff, 0x0fffffff,
			0x0fffffff, 0x0fffffff, 0x0fffffff, 0x0fffffff,
			0x0ffffffe, 0x0fffffff, 0x0fffffff, 0x0fffffff,
			0x0fffffff, 0x0fffffff, 0x0fffffff, 0x0fffffff,
		},
		&bigNumber{
			0x0d1ab6e7, 0x00000000, 0x00000000, 0x00000000,
			0x00000000, 0x00000000, 0x00000000, 0x00000000,
			0x0fffffff, 0x0fffffff, 0x0fffffff, 0x0fffffff,
			0x0fffffff, 0x0fffffff, 0x0fffffff, 0x0fffffff,
		},
		&bigNumber{
			0x00000000, 0x00000000, 0x00000000, 0x00000000,
			0x00000000, 0x00000000, 0x00000000, 0x00000000,
			0x0fffffff, 0x0fffffff, 0x0fffffff, 0x0fffffff,
			0x0fffffff, 0x0fffffff, 0x0fffffff, 0x0fffffff,
		},
		&bigNumber{0x00},
	}

	p.addNielsToExtended(q, true)

	c.Assert(p, DeepEquals, exp)

	r := twExtendedPoint{
		&bigNumber{
			0x00d8f04c, 0x03e54689, 0x0eb4db2b, 0x0887ba34,
			0x0a5b4ebc, 0x0f6c0261, 0x03bfa803, 0x0408ff02,
			0x03b4ef26, 0x0465c028, 0x0cd47378, 0x064c55b4,
			0x08245850, 0x01912682, 0x0dcbf92c, 0x07a7fa30,
		},
		&bigNumber{
			0x0d94d1a6, 0x0f7306e8, 0x0278b336, 0x04362b7b,
			0x0faf02b9, 0x06b01d18, 0x07a597da, 0x0bd6add0,
			0x047afa98, 0x0e64e897, 0x0bbf88e6, 0x01d0a534,
			0x04a52b9d, 0x0af374e0, 0x05091d54, 0x00fcf1a5,
		},
		&bigNumber{
			0x042318ce, 0x04aecdae, 0x0e8f196b, 0x0019d2e3,
			0x045d147c, 0x060b153e, 0x0adf2c37, 0x0419cdd8,
			0x06d19046, 0x00d18821, 0x06c7b9c2, 0x0c0ffd68,
			0x0b7e4ca2, 0x06da0d56, 0x0952b40f, 0x03008395,
		},
		&bigNumber{
			0x04643593, 0x000e0fdd, 0x013f29f3, 0x0bb8992d,
			0x0a30d344, 0x09151eec, 0x0d12bb82, 0x05c7a054,
			0x0103c2c6, 0x08a61fe2, 0x0aced4bf, 0x0f76d481,
			0x0db774be, 0x065ef8a8, 0x0ff47a71, 0x0f49f73e,
		},
	}

	np := &twNiels{
		&bigNumber{
			0x08fcb20f, 0x04611087, 0x01cc6f32, 0x0df43db2,
			0x04516644, 0x0ffdde9f, 0x091686b9, 0x05199177,
			0x0fd34473, 0x0b72b441, 0x0cb1c72b, 0x08d45684,
			0x00fc17a5, 0x01518137, 0x007f74d3, 0x0a456d13,
		},
		&bigNumber{
			0x09b607dc, 0x01430f14, 0x016715fc, 0x0e992ccd,
			0x00a32a09, 0x0a62209b, 0x0c26b8e4, 0x0b889ced,
			0x0ac109cf, 0x059bf9a3, 0x0b7feac2, 0x06871bb3,
			0x0d9a0e6b, 0x0f4a4d5f, 0x00cd69a5, 0x0b95db46,
		},
		&bigNumber{
			0x08bda702, 0x03630441, 0x01561558, 0x07bc5686,
			0x0e30416f, 0x0f344bc8, 0x080f59d7, 0x0a645370,
			0x07d00ace, 0x0b4c2007, 0x0b26f8cc, 0x0ee79620,
			0x00b5403d, 0x0a6a558e, 0x066f3d19, 0x08f1d2c7,
		},
	}

	exp = &twExtendedPoint{
		&bigNumber{
			0x0662c9a5, 0x0e2bc383, 0x09b2fc38, 0x0042d545,
			0x0431bbe8, 0x09e2a364, 0x03b8e92e, 0x0df6d043,
			0x07136f20, 0x00bde4fe, 0x0ca79859, 0x0c484320,
			0x099507c4, 0x0ef683e6, 0x09f8221d, 0x0b1fdcb8,
		},
		&bigNumber{
			0x0aaf871f, 0x08fcadaf, 0x0974aaea, 0x07d73c92,
			0x0bdaba0c, 0x069d1bf6, 0x0906e75c, 0x0020e493,
			0x07a2e1ec, 0x06e27878, 0x00e9c9d2, 0x08e429f5,
			0x026f7c86, 0x0420e6c5, 0x0304fccb, 0x0599fe0e,
		},
		&bigNumber{
			0x01b26129, 0x071c89cf, 0x0b012391, 0x0074b87c,
			0x0331b5fb, 0x0a2cbc8d, 0x0d1a4729, 0x0ab451d3,
			0x0308cad6, 0x0e086c2b, 0x03bd396c, 0x0cd2bd87,
			0x0910f41c, 0x090be75a, 0x0a8d7a0e, 0x07ec7ea8,
		},
		&bigNumber{
			0x08b7d023, 0x05bc6276, 0x03e2082d, 0x09d3eba3,
			0x0ecc2af3, 0x07a4c7be, 0x08ca49b8, 0x0ebe1040,
			0x0cf6ddeb, 0x015ec1ff, 0x010eed61, 0x0882e84d,
			0x07fefb78, 0x0d97e204, 0x02e940a1, 0x0537d7c0,
		},
	}

	r.addNielsToExtended(np, false)

	// TODO: this fails when not compared one by one
	c.Assert(r.x, DeepEquals, exp.x)
	c.Assert(r.y, DeepEquals, exp.y)
	c.Assert(r.z, DeepEquals, exp.z)
	c.Assert(r.t, DeepEquals, exp.t)
}

func (s *Ed448Suite) Test_SubNielsFromExtendedPoint(c *C) {
	np := &twNiels{
		&bigNumber{
			0x08db85c2, 0x0fd2361e, 0x0ce2105d, 0x06a17729,
			0x0a137aa5, 0x0e3ca84d, 0x0985ee61, 0x05a26d64,
			0x0734c5f3, 0x0da853af, 0x01d955b7, 0x03160ecd,
			0x0a59046d, 0x0c32cf71, 0x98dce72d, 0x00007fff,
		},
		&bigNumber{
			0x08db85c2, 0x0fd2361e, 0x0ce2105d, 0x06a17729,
			0x0a137aa5, 0x0e3ca84d, 0x0985ee61, 0x05a26d64,
			0x0734c5f3, 0x0da853af, 0x01d955b7, 0x03160ecd,
			0x0a59046d, 0x0c32cf71, 0x98dce72d, 0x00007fff,
		},
		&bigNumber{
			0x08db85c2, 0x0fd2361e, 0x0ce2105d, 0x06a17729,
			0x0a137aa5, 0x0e3ca84d, 0x0985ee61, 0x05a26d64,
			0x0734c5f3, 0x0da853af, 0x01d955b7, 0x03160ecd,
			0x0a59046d, 0x0c32cf71, 0x98dce72d, 0x00007fff,
		},
	}

	p := &twExtendedPoint{
		&bigNumber{
			0x0f82ee02, 0x01e3b10f, 0x0ed7bfcc, 0x081bc4be,
			0x05aacbbd, 0x07fe70d8, 0x01f83cca, 0x0f1e12ee,
			0x08d6e8b4, 0x02ab7e49, 0x04755d5b, 0x0cf43119,
			0x0ce99cfa, 0x094028b2, 0x09413391, 0x07f46d51,
		},
		&bigNumber{
			0x011a56ef, 0x0b24090d, 0x0e216f59, 0x04bfd7f8,
			0x0cdcadc7, 0x0767fa4b, 0x077ebfb0, 0x0c66e6d6,
			0x057264a6, 0x0aaf5008, 0x0c37bf6e, 0x0c12e6e7,
			0x05882f0c, 0x0ac50cde, 0x0c2507cd, 0x01d0da8b,
		},
		&bigNumber{
			0x07eb7a9a, 0x0a99ca0f, 0x00d9ff62, 0x020ca3d8,
			0x00879e44, 0x0f70e0b6, 0x00ef90a2, 0x0b92a557,
			0x0494775a, 0x0a1da091, 0x0d8d2aaa, 0x05a7f9ac,
			0x0425963f, 0x049aafa3, 0x07a98de2, 0x0d90bd06,
		},
		&bigNumber{
			0x05179579, 0x0afa355d, 0x0a4f356e, 0x0dfb98d1,
			0x07696685, 0x0a19ebbf, 0x01f88924, 0x0edb238d,
			0x004741e3, 0x07f9c522, 0x09f2a2cf, 0x0fc28c0f,
			0x0c58b41e, 0x02e8182c, 0x0110c9a5, 0x01a97390,
		},
	}

	exp := &twExtendedPoint{
		&bigNumber{
			0x0559456a, 0x0000a48a, 0x0be4db53, 0x08f3c380,
			0x06ec1aeb, 0x0412f1ec, 0x0820c387, 0x00cb334e,
			0x001e4e1c, 0x0e04d4db, 0x05c26f8a, 0x0cd016b3,
			0x04b854da, 0x0280cdc7, 0x07d114da, 0x01ca86f0,
		},
		&bigNumber{
			0x0fba123c, 0x0c853639, 0x03dd98eb, 0x01f2ade9,
			0x09ce8374, 0x006a4a7c, 0x0ee9b203, 0x0a148275,
			0x0e51f89c, 0x04383590, 0x0dfc5a57, 0x01cd1a4c,
			0x0a0ce93f, 0x0fe3d3d1, 0x0891d8b6, 0x0c030a9a,
		},
		&bigNumber{
			0x0b1a6ae2, 0x01e6c938, 0x06d670f6, 0x0a9455b3,
			0x0a7b5ad7, 0x0100a5b2, 0x00d4dbc0, 0x04cf6afa,
			0x0905706d, 0x0c59d1c3, 0x0d37b997, 0x0d37c41d,
			0x0f2a766e, 0x0add64fe, 0x03eb80e7, 0x0615a882,
		},
		&bigNumber{
			0x08f5eec2, 0x02a36bf9, 0x0e652ff4, 0x0471ce66,
			0x0ba0a7b5, 0x030f4520, 0x047d370a, 0x062802e2,
			0x0580f436, 0x02044dc5, 0x0b116834, 0x0e0e1f92,
			0x0710c6df, 0x07576902, 0x0fc511fc, 0x01e3338d,
		},
	}

	p.subNielsFromExtendedPoint(np, false)

	c.Assert(p, DeepEquals, exp)

	np = &twNiels{
		&bigNumber{
			0x08fcb20f, 0x04611087, 0x01cc6f32, 0x0df43db2,
			0x04516644, 0x0ffdde9f, 0x091686b9, 0x05199177,
			0x0fd34473, 0x0b72b441, 0x0cb1c72b, 0x08d45684,
			0x00fc17a5, 0x01518137, 0x007f74d3, 0x0a456d13,
		},
		&bigNumber{
			0x09b607dc, 0x01430f14, 0x016715fc, 0x0e992ccd,
			0x00a32a09, 0x0a62209b, 0x0c26b8e4, 0x0b889ced,
			0x0ac109cf, 0x059bf9a3, 0x0b7feac2, 0x06871bb3,
			0x0d9a0e6b, 0x0f4a4d5f, 0x00cd69a5, 0x0b95db46,
		},
		&bigNumber{
			0x08bda702, 0x03630441, 0x01561558, 0x07bc5686,
			0x0e30416f, 0x0f344bc8, 0x080f59d7, 0x0a645370,
			0x07d00ace, 0x0b4c2007, 0x0b26f8cc, 0x0ee79620,
			0x00b5403d, 0x0a6a558e, 0x066f3d19, 0x08f1d2c7,
		},
	}

	q := &twExtendedPoint{
		&bigNumber{
			0x0f82ee02, 0x01e3b10f, 0x0ed7bfcc, 0x081bc4be,
			0x05aacbbd, 0x07fe70d8, 0x01f83cca, 0x0f1e12ee,
			0x08d6e8b4, 0x02ab7e49, 0x04755d5b, 0x0cf43119,
			0x0ce99cfa, 0x094028b2, 0x09413391, 0x07f46d51,
		},
		&bigNumber{
			0x011a56ef, 0x0b24090d, 0x0e216f59, 0x04bfd7f8,
			0x0cdcadc7, 0x0767fa4b, 0x077ebfb0, 0x0c66e6d6,
			0x057264a6, 0x0aaf5008, 0x0c37bf6e, 0x0c12e6e7,
			0x05882f0c, 0x0ac50cde, 0x0c2507cd, 0x01d0da8b,
		},
		&bigNumber{
			0x07eb7a9a, 0x0a99ca0f, 0x00d9ff62, 0x020ca3d8,
			0x00879e44, 0x0f70e0b6, 0x00ef90a2, 0x0b92a557,
			0x0494775a, 0x0a1da091, 0x0d8d2aaa, 0x05a7f9ac,
			0x0425963f, 0x049aafa3, 0x07a98de2, 0x0d90bd06,
		},
		&bigNumber{
			0x05179579, 0x0afa355d, 0x0a4f356e, 0x0dfb98d1,
			0x07696685, 0x0a19ebbf, 0x01f88924, 0x0edb238d,
			0x004741e3, 0x07f9c522, 0x09f2a2cf, 0x0fc28c0f,
			0x0c58b41e, 0x02e8182c, 0x0110c9a5, 0x01a97390,
		},
	}

	exp = &twExtendedPoint{
		&bigNumber{
			0x0ad0c84b, 0x00e86ec2, 0x0e48374d, 0x07bd7121,
			0x09087d3c, 0x0e306794, 0x0bfbf8e4, 0x0ab91657,
			0x0187baca, 0x01e18d64, 0x0c90770f, 0x0c079ef8,
			0x0e264c1f, 0x0eb244f6, 0x092e5769, 0x0b8c7e0b,
		},
		&bigNumber{
			0x06fe7330, 0x0e8e5339, 0x0aaa6e4e, 0x078c24c1,
			0x099ac1b7, 0x08b57975, 0x0dc25e9f, 0x050ba301,
			0x09cdf171, 0x00b06738, 0x02472317, 0x00064dbf,
			0x026ae17a, 0x01f0b29d, 0x0c6c1f13, 0x027fa09c,
		},
		&bigNumber{
			0x0badc2c0, 0x0d6516ed, 0x0c9adfe6, 0x0e8f676d,
			0x059792ce, 0x02d8e641, 0x0b7bb000, 0x0bac1821,
			0x09c6b420, 0x048526db, 0x06c630e3, 0x05f7c244,
			0x08abfbbe, 0x008da47f, 0x0aa32ea5, 0x0ccd7d78,
		},
		&bigNumber{
			0x05179579, 0x0afa355d, 0x0a4f356e, 0x0dfb98d1,
			0x07696685, 0x0a19ebbf, 0x01f88924, 0x0edb238d,
			0x004741e3, 0x07f9c522, 0x09f2a2cf, 0x0fc28c0f,
			0x0c58b41e, 0x02e8182c, 0x0110c9a5, 0x01a97390,
		},
	}

	//doubling
	q.subNielsFromExtendedPoint(np, true)

	c.Assert(q, DeepEquals, exp)
}

func (s *Ed448Suite) Test_AddProjectiveNielsToExtendedCoordinates(c *C) {
	p := &twExtendedPoint{
		&bigNumber{
			0x065fe00e, 0x070a5e7e, 0x0bfd74eb, 0x08eee5a2,
			0x01eb1d18, 0x06978a30, 0x0e05687d, 0x0332d83d,
			0x029bfaa5, 0x01d55025, 0x01a04e4d, 0x03387c04,
			0x0bfe9dbe, 0x0052df1b, 0x0adf7ef5, 0x0f7738e9,
		},
		&bigNumber{
			0x0e896a5f, 0x0e551bba, 0x0363107c, 0x0ad5faf3,
			0x00d4bdd0, 0x0025431b, 0x0a96726f, 0x06450cae,
			0x06e879ac, 0x076c4a06, 0x04816d63, 0x072fda21,
			0x02fc227b, 0x0548ed7b, 0x062e39e8, 0x07635ec5,
		},
		&bigNumber{
			0x0a9cb59b, 0x0e8e9c67, 0x08ab4927, 0x039fd088,
			0x05bafdda, 0x0010c3bf, 0x0621a18e, 0x0288d330,
			0x0e39f617, 0x0cf20409, 0x050aa964, 0x037696d0,
			0x0197ecc8, 0x0098a718, 0x039ab7ce, 0x0ccac870,
		},
		&bigNumber{
			0x003a81bc, 0x05aec25f, 0x0352215e, 0x03ef1e1e,
			0x0c216e7b, 0x0ff5ee46, 0x0c5784fd, 0x0f377ed9,
			0x0cd2678a, 0x0583af4e, 0x04da9308, 0x00eeaf60,
			0x043e4dc8, 0x0e77b786, 0x06aab96c, 0x0fe963f3,
		},
	}

	np := &twPNiels{
		&twNiels{
			&bigNumber{
				0x0dffcb31, 0x0426f81c, 0x00faf45c, 0x06c50175,
				0x0b4d7ba0, 0x04bac22f, 0x0b0d28b6, 0x0b542495,
				0x04e4c5b6, 0x08405b7e, 0x0e2cc773, 0x0ef5cf36,
				0x0015a008, 0x056cdf03, 0x0f0b952e, 0x09ac1df4,
			},
			&bigNumber{
				0x0d598e52, 0x0ea2ac0e, 0x02b8d2d9, 0x068f2906,
				0x005ebdfc, 0x01f67a03, 0x052cc96f, 0x065635dd,
				0x044ca0b5, 0x087e7c65, 0x02b8e2cd, 0x05f826b9,
				0x0bdb6d31, 0x07119d4b, 0x07909767, 0x02c7692f,
			},
			&bigNumber{
				0x0c789450, 0x09efcd8a, 0x0917d143, 0x0eddc9f9,
				0x0c135cd5, 0x034d7893, 0x022ea365, 0x0999b447,
				0x06951972, 0x0925c008, 0x0fe1cd6c, 0x0f55a3fd,
				0x0081cfcf, 0x000a9eb6, 0x02bacafd, 0x0b8a3daf,
			},
		},
		&bigNumber{
			0x0154741b, 0x084a4939, 0x071479d1, 0x01c5a7d6,
			0x0e77458b, 0x0b209c54, 0x05f90c8d, 0x01e562a7,
			0x07f0fe64, 0x071b3d33, 0x042b13a2, 0x023bca1b,
			0x0f4a5e74, 0x0b19b036, 0x03b187a0, 0x008b6799,
		},
	}

	p.addProjectiveNielsToExtended(np, false)

	exp := &twExtendedPoint{
		&bigNumber{
			0x0229a19b, 0x07640779, 0x0cd5c825, 0x00a542fe,
			0x0bb2362b, 0x0261d1af, 0x015db410, 0x0ca63130,
			0x00e9a7e4, 0x00a06584, 0x01029e89, 0x025cdd0e,
			0x0a11b601, 0x0c592ed0, 0x0b1854d2, 0x0c374936,
		},
		&bigNumber{
			0x045e9fe6, 0x09017d4c, 0x077f92d8, 0x079e77d5,
			0x081ea883, 0x0ad757f3, 0x088b186c, 0x03d4ae18,
			0x01f422c7, 0x048c7fc1, 0x052d50d6, 0x0b310d2d,
			0x0f98c559, 0x0ce135a0, 0x02cdff0e, 0x06c117fd,
		},
		&bigNumber{
			0x0ac69c60, 0x0fa58fee, 0x0e0b93bd, 0x0c5887dc,
			0x0dc231b4, 0x08d5bd5a, 0x0cbaa909, 0x06cda8c7,
			0x064c5ba3, 0x0b7a44bc, 0x0e076348, 0x008976ff,
			0x04ae0ed6, 0x03735252, 0x04c09fca, 0x075120c2,
		},
		&bigNumber{
			0x0f5f78ac, 0x0f2f972b, 0x0c7b74b5, 0x084ae55c,
			0x03fe0c33, 0x02441814, 0x0b335997, 0x052cd9d7,
			0x00af1474, 0x0d285ac9, 0x0ea87209, 0x087cd8a3,
			0x03d9718e, 0x0b8f00f3, 0x003d8c42, 0x0345b1a8,
		},
	}

	c.Assert(p, DeepEquals, exp)
}

func (s *Ed448Suite) Test_SubProjectiveNielsFromExtendedPoint(c *C) {
	np := &twPNiels{
		&twNiels{
			&bigNumber{
				0x08fcb20f, 0x04611087, 0x01cc6f32, 0x0df43db2,
				0x04516644, 0x0ffdde9f, 0x091686b9, 0x05199177,
				0x0fd34473, 0x0b72b441, 0x0cb1c72b, 0x08d45684,
				0x00fc17a5, 0x01518137, 0x007f74d3, 0x0a456d13,
			},
			&bigNumber{
				0x09b607dc, 0x01430f14, 0x016715fc, 0x0e992ccd,
				0x00a32a09, 0x0a62209b, 0x0c26b8e4, 0x0b889ced,
				0x0ac109cf, 0x059bf9a3, 0x0b7feac2, 0x06871bb3,
				0x0d9a0e6b, 0x0f4a4d5f, 0x00cd69a5, 0x0b95db46,
			},
			&bigNumber{
				0x08bda702, 0x03630441, 0x01561558, 0x07bc5686,
				0x0e30416f, 0x0f344bc8, 0x080f59d7, 0x0a645370,
				0x07d00ace, 0x0b4c2007, 0x0b26f8cc, 0x0ee79620,
				0x00b5403d, 0x0a6a558e, 0x066f3d19, 0x08f1d2c7,
			},
		},
		&bigNumber{
			0x08fcb20f, 0x04611087, 0x01cc6f32, 0x0df43db2,
			0x04516644, 0x0ffdde9f, 0x091686b9, 0x05199177,
			0x0fd34473, 0x0b72b441, 0x0cb1c72b, 0x08d45684,
			0x00fc17a5, 0x01518137, 0x007f74d3, 0x0a456d13,
		},
	}

	p := &twExtendedPoint{
		&bigNumber{
			0x0f82ee02, 0x01e3b10f, 0x0ed7bfcc, 0x081bc4be,
			0x05aacbbd, 0x07fe70d8, 0x01f83cca, 0x0f1e12ee,
			0x08d6e8b4, 0x02ab7e49, 0x04755d5b, 0x0cf43119,
			0x0ce99cfa, 0x094028b2, 0x09413391, 0x07f46d51,
		},
		&bigNumber{
			0x011a56ef, 0x0b24090d, 0x0e216f59, 0x04bfd7f8,
			0x0cdcadc7, 0x0767fa4b, 0x077ebfb0, 0x0c66e6d6,
			0x057264a6, 0x0aaf5008, 0x0c37bf6e, 0x0c12e6e7,
			0x05882f0c, 0x0ac50cde, 0x0c2507cd, 0x01d0da8b,
		},
		&bigNumber{
			0x07eb7a9a, 0x0a99ca0f, 0x00d9ff62, 0x020ca3d8,
			0x00879e44, 0x0f70e0b6, 0x00ef90a2, 0x0b92a557,
			0x0494775a, 0x0a1da091, 0x0d8d2aaa, 0x05a7f9ac,
			0x0425963f, 0x049aafa3, 0x07a98de2, 0x0d90bd06,
		},
		&bigNumber{
			0x05179579, 0x0afa355d, 0x0a4f356e, 0x0dfb98d1,
			0x07696685, 0x0a19ebbf, 0x01f88924, 0x0edb238d,
			0x004741e3, 0x07f9c522, 0x09f2a2cf, 0x0fc28c0f,
			0x0c58b41e, 0x02e8182c, 0x0110c9a5, 0x01a97390,
		},
	}

	exp := &twExtendedPoint{
		&bigNumber{
			0x0219ec8c, 0x0582cb83, 0x0604bada, 0x094bb514,
			0x0657d086, 0x0e1bb3eb, 0x0357bb2e, 0x0276644d,
			0x0b48f89e, 0x08a134e7, 0x0f019587, 0x0760eed1,
			0x04bdd4fd, 0x056ad7fa, 0x0ac36777, 0x08804ae2,
		},
		&bigNumber{
			0x0236a7a2, 0x052dd438, 0x0515cbbc, 0x092ba2bc,
			0x0a88736f, 0x08279ba8, 0x05848b64, 0x0ca9a994,
			0x063083a4, 0x021cce70, 0x0390af55, 0x024dd769,
			0x0557e516, 0x01fc2e71, 0x014512d3, 0x0db2e28d,
		},
		&bigNumber{
			0x0810a95c, 0x0c729dc3, 0x0fed0297, 0x03bab06e,
			0x01c71da5, 0x0d55d72f, 0x02ed2707, 0x022bf539,
			0x00d37809, 0x05337538, 0x0fae2a46, 0x09d137e7,
			0x0f670848, 0x05e0ef76, 0x0d23c081, 0x0c2c43d2,
		},
		&bigNumber{
			0x07351435, 0x08116fe9, 0x09496edc, 0x0ae65d1a,
			0x0991a790, 0x0ded364a, 0x028ede97, 0x0619af37,
			0x04bb808d, 0x03f0ea82, 0x048b7e82, 0x0084fed5,
			0x01bec8d1, 0x0bde1040, 0x0fd87b36, 0x0adc7c4d,
		},
	}

	p.subProjectiveNielsFromExtendedPoint(np, false)
	c.Assert(p, DeepEquals, exp)
}

func (s *Ed448Suite) Test_ConvertExtendedToAffine(c *C) {
	p := &twExtendedPoint{
		&bigNumber{
			0x0cf14237, 0x0ac97f43, 0x0a9543bc, 0x0dc98db8,
			0x0bcca6a6, 0x07874a17, 0x021af78f, 0x0fffa763,
			0x0cf2ac0b, 0x074f2a89, 0x0f89f88d, 0x0356a31e,
			0x09f61e5a, 0x00c01083, 0x0c84b7a5, 0x00bf3b5c,
		},

		&bigNumber{
			0x00c9a64c, 0x06b775bc, 0x026148bb, 0x0ee0c3e1,
			0x0303aa98, 0x04fad09b, 0x0efaf59d, 0x03008555,
			0x072a0bf6, 0x023bc0fa, 0x0c52ee5b, 0x0f0f61f9,
			0x05cf8d7f, 0x0b8b7f38, 0x018a4398, 0x06a9849a,
		},

		&bigNumber{
			0x014e2fce, 0x0198c24c, 0x0b74b290, 0x0080f748,
			0x0fb60b6e, 0x08ab2f53, 0x06c32b60, 0x06979188,
			0x0e87a66d, 0x087ecac7, 0x0f354ebd, 0x035faebf,
			0x0e30d07f, 0x0c96f513, 0x0fab82ed, 0x0da28e58,
		},

		&bigNumber{
			0x0702239a, 0x05c67537, 0x0ce76a54, 0x0fae388e,
			0x034bcae9, 0x06b5fe3d, 0x0d3c37ae, 0x09cac77d,
			0x0761a657, 0x0a02246f, 0x06490757, 0x09448b04,
			0x05281bbe, 0x0e0bd3d4, 0x0abc5ecb, 0x07c655f9,
		},
	}

	exp := &affineCoordinates{
		&bigNumber{
			0x0a6862a1, 0x0b9509e3, 0x0f633a09, 0x01bbe8fd,
			0x0055bfe7, 0x04b7a267, 0x098fec7a, 0x02b43bdb,
			0x038728f3, 0x0e50a54c, 0x06da2f47, 0x0b1844b2,
			0x03e1ddfe, 0x03f84a5f, 0x0517a1cc, 0x0bc8e0e4,
		},

		&bigNumber{
			0x0b002bae, 0x046b63b0, 0x00e0f577, 0x093028d2,
			0x04ae3673, 0x0cb031e4, 0x0a1b1455, 0x0ef16821,
			0x0505815a, 0x0c83cd8d, 0x0753d9cc, 0x06691155,
			0x0cfa1242, 0x0bcee146, 0x03335bee, 0x0dfe21fd,
		},
	}

	// is the identity
	q := p.toAffine()
	c.Assert(q, DeepEquals, exp)

	q = identity.toAffine()

	exp = &affineCoordinates{
		&bigNumber{0x00},
		&bigNumber{0x00},
	}

	c.Assert(q, DeepEquals, exp)

	// Z is zero
	p = &twExtendedPoint{
		&bigNumber{0x0c},
		&bigNumber{0x0c},
		&bigNumber{0x00},
		&bigNumber{0x0c},
	}

	q = p.toAffine()

	c.Assert(q, DeepEquals, exp)
}

func (s *Ed448Suite) Test_ConvertNielsToExtended(c *C) {
	pn := &twNiels{
		&bigNumber{0x068d5b74},
		&bigNumber{0x068d5b74},
		&bigNumber{0x068d5b74}}

	exp := &twExtendedPoint{
		&bigNumber{
			0x0fffffff, 0x0fffffff, 0x0fffffff, 0x0fffffff,
			0x0fffffff, 0x0fffffff, 0x0fffffff, 0x0fffffff,
			0x0ffffffe, 0x0fffffff, 0x0fffffff, 0x0fffffff,
			0x0fffffff, 0x0fffffff, 0x0fffffff, 0x0fffffff,
		},
		&bigNumber{0x0d1ab6e8},
		&bigNumber{0x00000001},
		&bigNumber{
			0x0fffffff, 0x0fffffff, 0x0fffffff, 0x0fffffff,
			0x0fffffff, 0x0fffffff, 0x0fffffff, 0x0fffffff,
			0x0ffffffe, 0x0fffffff, 0x0fffffff, 0x0fffffff,
			0x0fffffff, 0x0fffffff, 0x0fffffff, 0x0fffffff,
		},
	}

	p := pn.toExtended()

	c.Assert(p, DeepEquals, exp)
}

func (s *Ed448Suite) Test_ConvertExtendedToProjectiveNielsCoordinates(c *C) {
	p := &twExtendedPoint{
		&bigNumber{
			0x0cbc0465, 0x0ae92226, 0x091cf2c2, 0x06088c39,
			0x06adcba9, 0x02b78bc6, 0x06b0b2aa, 0x0d1b1697,
			0x0cf760b0, 0x09cc4ae8, 0x06ff4c95, 0x06f9eaff,
			0x03f88cb2, 0x0dfe1f47, 0x015828d5, 0x003f26ff,
		},
		&bigNumber{
			0x0f73319b, 0x007fa279, 0x0c6ab58a, 0x0224b18c,
			0x0bbc2c00, 0x012c8b76, 0x07428968, 0x06047979,
			0x0a19d606, 0x0cf6c1c8, 0x06a83f0d, 0x0725b63c,
			0x0bc33839, 0x0d9114a0, 0x07eec286, 0x0908447d,
		},
		&bigNumber{
			0x01e2013d, 0x0287266b, 0x0f434216, 0x08bac041,
			0x03321096, 0x096004ef, 0x0c9f384c, 0x0ae584aa,
			0x02a4d456, 0x02d20148, 0x0df9a8dd, 0x051a0acf,
			0x0b3886b1, 0x00ad3c7f, 0x06f0b032, 0x0e09bf7e,
		},
		&bigNumber{
			0x0419dfec, 0x0723fb8c, 0x00f6c661, 0x045419d4,
			0x00449ef9, 0x09f3003d, 0x0d77bd3d, 0x03aabfcb,
			0x05f1ad37, 0x018339b6, 0x0e4963f2, 0x0060cbfc,
			0x078b53f3, 0x023457ac, 0x048d759c, 0x02a6c760,
		},
	}

	exp := &twPNiels{
		&twNiels{
			&bigNumber{
				0x02b72d36, 0x05968053, 0x034dc2c7, 0x0c1c2553,
				0x050e6056, 0x0e74ffb0, 0x0091d6bd, 0x08e962e2,
				0x0d227555, 0x032a76df, 0x0fa8f278, 0x002bcb3c,
				0x07caab87, 0x0f92f559, 0x069699b0, 0x08c91d7e,
			},
			&bigNumber{
				0x0c2f3600, 0x0b68c4a0, 0x0587a84c, 0x082d3dc6,
				0x0269f7a9, 0x03e4173d, 0x0df33c12, 0x031f9010,
				0x071136b7, 0x06c30cb1, 0x0da78ba3, 0x0e1fa13b,
				0x0fbbc4eb, 0x0b8f33e7, 0x0946eb5c, 0x09476b7c,
			},
			&bigNumber{
				0x03ba27f6, 0x097f5bcd, 0x0caccee8, 0x01a1e00a,
				0x0814dab2, 0x08fb39de, 0x0c3f7d1f, 0x0d773562,
				0x0d542a5f, 0x092ec8d9, 0x0fd7c5ba, 0x0d34c4ad,
				0x0743ea0c, 0x0a5ebf98, 0x087662be, 0x0dbcdd9f,
			},
		},
		&bigNumber{
			0x03c4027b, 0x050e4cd6, 0x0e86842c, 0x01758083,
			0x0664212d, 0x02c009de, 0x093e7099, 0x05cb0955,
			0x0549a8ae, 0x05a40290, 0x0bf351ba, 0x0a34159f,
			0x06710d62, 0x015a78ff, 0x0de16064, 0x0c137efc,
		},
	}

	projP := p.toPNiels()

	c.Assert(projP, DeepEquals, exp)
}

func (s *Ed448Suite) Test_IsogenizeToMontgomery(c *C) {
	p := &twExtendedPoint{
		&bigNumber{
			0x01f7eb33, 0x015c4a76,
			0x03b0f639, 0x01e0e6b0,
			0x03e0650d, 0x07704dfa,
			0x08335fc8, 0x08306f42,
			0x0ef172c7, 0x0a594a5f,
			0x0ce2edb6, 0x022d5eae,
			0x0b4cbc85, 0x081b5ff3,
			0x0ba29f03, 0x0bab5894,
		},
		&bigNumber{
			0x0ad4e12f, 0x06d5c054,
			0x015b6c72, 0x02ba7a30,
			0x0e94d29a, 0x04ac1ee2,
			0x09f5dee1, 0x08cd1ef8,
			0x0acc50d2, 0x0fafc7e9,
			0x04cb8a5d, 0x0e372b94,
			0x0303c710, 0x08fa6eb1,
			0x05c27f7e, 0x0bf77a23,
		},
		&bigNumber{
			0x06551eb7, 0x060efba5,
			0x03811c38, 0x0bfb975a,
			0x08f4e10d, 0x0bfd720a,
			0x0c70d6cd, 0x039695d9,
			0x0e26a87b, 0x018628ae,
			0x0d8d4bc8, 0x04e92240,
			0x071be15b, 0x0bd51707,
			0x07a32b99, 0x01f1ba7a,
		},
		&bigNumber{
			0x036babb8, 0x0a3c7bbe,
			0x0f81d702, 0x06842fbd,
			0x025f67a3, 0x0efa5f54,
			0x0dc6abcc, 0x0e20af9d,
			0x072b80d5, 0x0d86a6a8,
			0x035c4c67, 0x0d3beef2,
			0x0e8dcc73, 0x019fd93d,
			0x062f96c7, 0x0b6d38c2,
		},
	}

	exp := []byte{
		0x44, 0x43, 0x6d, 0x7d, 0xd8, 0x75, 0x42, 0x89,
		0x44, 0x41, 0xf1, 0x95, 0xd8, 0xec, 0x1a, 0xca,
		0x4e, 0xe0, 0x82, 0xce, 0x52, 0xd0, 0x32, 0x28,
		0x7f, 0xb1, 0x28, 0x6b, 0x0f, 0xe9, 0xe7, 0xc7,
		0x9b, 0xc2, 0x42, 0x90, 0xe6, 0xaa, 0xc0, 0x92,
		0x7a, 0xcc, 0x1a, 0xe1, 0x7c, 0x1e, 0xc3, 0xa0,
		0x6c, 0x30, 0xef, 0x89, 0xf9, 0x0e, 0x46, 0xca,
	}

	rsl := p.isogenizeToMontgomery()

	c.Assert(rsl, DeepEquals, exp)
}

// TODO: add assoc mul and distributive
func (s *Ed448Suite) Test_PointScalarMul(c *C) {
	p := &twExtendedPoint{
		&bigNumber{
			0x0a7f964a, 0x0db033f8, 0x062b9f0b, 0x07bff7d6,
			0x05e755a2, 0x013b6f8b, 0x0f080bdc, 0x0a112ac0,
			0x0416988a, 0x03404b2f, 0x00561ea3, 0x01df752c,
			0x070e0b1c, 0x0e73a0c4, 0x078245d5, 0x09a42df0,
		},
		&bigNumber{
			0x0c2e6c3d, 0x0a03c3f2, 0x0fd16e97, 0x0bab4ec6,
			0x08ddba78, 0x091638ef, 0x0b0add85, 0x070c212d,
			0x04bcd337, 0x0c828579, 0x0712cfff, 0x09c1534a,
			0x0119cafe, 0x08e72ee0, 0x0f14ff19, 0x0d0c7e25,
		},
		&bigNumber{
			0x0a0d6be1, 0x0bcd9788, 0x00f9ca8a, 0x038cf839,
			0x00912da2, 0x0a3c503a, 0x056fe7e0, 0x03db9a49,
			0x0f19d062, 0x052ac631, 0x01cbda35, 0x02967214,
			0x0eed2db2, 0x0a948ce0, 0x05f7a3a7, 0x0fa35bc2,
		},
		&bigNumber{
			0x0fc9f32d, 0x0e442931, 0x065e50ff, 0x04be230d,
			0x0dc923c2, 0x0000467c, 0x08fc8902, 0x0e034cfb,
			0x0126370c, 0x06ec706d, 0x06ff07ad, 0x0a27cd65,
			0x060f214f, 0x0eb7756d, 0x0b694dc7, 0x015705ad,
		},
	}

	scalar := &scalar{
		0x6ee372b7, 0xe128ae78, 0x1533427c, 0xad0b7015,
		0x307f665e, 0xde8026c1, 0xb64629d1, 0xab454c66,
		0x3fe5bf1a, 0x083f8304, 0x3c003777, 0xdef437f6,
		0xee2e1b73, 0x05ca185a,
	}

	exp := &twExtendedPoint{
		&bigNumber{
			0x08630007, 0x0bd755e6, 0x0f76b928, 0x070d9694,
			0x0b952009, 0x0cf85b12, 0x0c3a6e9c, 0x0e2d860e,
			0x02fd2901, 0x09a73726, 0x02aa2d4c, 0x06913ea9,
			0x090da66d, 0x06a5c6f1, 0x04cc7a13, 0x0eb24ed8,
		},
		&bigNumber{
			0x0bb37152, 0x0a3a36b3, 0x0a720c7f, 0x0e29095f,
			0x04e76cf4, 0x0cfad965, 0x07439798, 0x0f4b7ba4,
			0x0316ba61, 0x09389566, 0x07f96104, 0x07bdc39c,
			0x0f019987, 0x05416850, 0x0612c6c8, 0x0e231baa,
		},
		&bigNumber{
			0x0179c756, 0x04130eef, 0x07f43255, 0x0cc1534d,
			0x03e347fd, 0x0c745e4d, 0x068d7bf5, 0x020b8465,
			0x0356d2f1, 0x069b22fd, 0x0b6cf87f, 0x0edf9761,
			0x034f512f, 0x0411b43f, 0x033f0755, 0x06195e97,
		},
		&bigNumber{
			0x0866187a, 0x035622be, 0x0b9e2e78, 0x0cae26c6,
			0x041c2c41, 0x07296c68, 0x03343d3e, 0x062c0927,
			0x0cf5d263, 0x08db465d, 0x033382d6, 0x0c5e6eff,
			0x0c0ded8d, 0x037837bf, 0x03780cc6, 0x0e2360df,
		},
	}

	q := pointScalarMul(p, scalar)

	c.Assert(q.x, DeepEquals, exp.x)
}

func (s *Ed448Suite) Test_PrecomputedScalarMultiplication(c *C) {
	scalar := &scalar{0x00}

	p := precomputedScalarMul(scalar)

	exp := &twExtendedPoint{
		&bigNumber{
			0x0fffffff, 0x0fffffff, 0x0fffffff, 0x0fffffff,
			0x0fffffff, 0x0fffffff, 0x0fffffff, 0x0fffffff,
			0x0ffffffe, 0x0fffffff, 0x0fffffff, 0x0fffffff,
			0x0fffffff, 0x0fffffff, 0x0fffffff, 0x0fffffff,
		},
		&bigNumber{
			0x0b1ff82e, 0x05e98b74, 0x000cecf1, 0x0277711a,
			0x0f9b17c5, 0x0c98aadc, 0x05b06211, 0x0bc17782,
			0x0809fef2, 0x08bb648f, 0x0323239f, 0x0d37d81d,
			0x0389402c, 0x0cbabc81, 0x087aaae9, 0x01b50b05,
		},
		&bigNumber{
			0x04e007d1, 0x0a16748b, 0x0ff3130e, 0x0d888ee5,
			0x0064e83a, 0x03675523, 0x0a4f9dee, 0x043e887d,
			0x07f6010c, 0x07449b70, 0x0cdcdc60, 0x02c827e2,
			0x0c76bfd3, 0x0345437e, 0x07855516, 0x0e4af4fa,
		},
		&bigNumber{
			0x0fffffff, 0x0fffffff, 0x0fffffff, 0x0fffffff,
			0x0fffffff, 0x0fffffff, 0x0fffffff, 0x0fffffff,
			0x0ffffffe, 0x0fffffff, 0x0fffffff, 0x0fffffff,
			0x0fffffff, 0x0fffffff, 0x0fffffff, 0x0fffffff,
		},
	}

	c.Assert(p, DeepEquals, exp)
}

func (s *Ed448Suite) Test_DirectPointScalarMul(c *C) {
	p := [fieldBytes]byte{
		0xac, 0x1a, 0xb7, 0xbe, 0xdf, 0x28, 0xb3, 0x3c,
		0x5c, 0xbd, 0x2d, 0xa2, 0xb6, 0x38, 0x51, 0xe3,
		0x1f, 0xd1, 0x60, 0x64, 0x43, 0x90, 0x71, 0xce,
		0xe1, 0xab, 0x87, 0xb0, 0xd8, 0xb1, 0x39, 0x00,
		0x0e, 0xd7, 0x82, 0xa9, 0x41, 0x36, 0xf2, 0xbc,
		0x44, 0x0b, 0x3c, 0x7e, 0xc4, 0x6b, 0x09, 0x18,
		0x07, 0x95, 0x47, 0x40, 0x8a, 0x04, 0x70, 0xf9,
	}

	a := &scalar{
		0x453f802c, 0x7e2d5889, 0xa70126da, 0x61a6a678,
		0x0b5c56a3, 0xea09aee0, 0x1709ce56, 0x40d598c0,
		0xdf189be8, 0xc34478b7, 0x856266c9, 0x10d7a6ae,
		0x40f0147b, 0x2b9272d7,
	}

	exp := [fieldBytes]byte{
		0xc8, 0x7c, 0x6b, 0x4d, 0x3c, 0xbe, 0x9e, 0x1d,
		0xfe, 0x21, 0xde, 0xcd, 0x76, 0x87, 0x0d, 0x91,
		0xa0, 0xcd, 0x9d, 0xa9, 0xe9, 0x6b, 0x94, 0xd2,
		0x97, 0x9d, 0x12, 0x5a, 0x72, 0x49, 0x6f, 0x61,
		0xe3, 0x34, 0x7c, 0x3c, 0x5e, 0xfe, 0xf3, 0x52,
		0x8d, 0x42, 0x46, 0xe0, 0x6e, 0x4d, 0x48, 0x5b,
		0x2c, 0x9b, 0x37, 0xac, 0xdc, 0x41, 0xa3, 0x15,
	}

	q, valid := directPointScalarMul(p, a, decafFalse)

	c.Assert(q, DeepEquals, exp)
	c.Assert(valid, DeepEquals, decafFalse)
}

//Exported functions
func (s *Ed448Suite) Test_NewPoint(c *C) {
	x := [nLimbs]uint32{
		0x034365c8, 0x06b2a874, 0x0eb875d7, 0x0ae4c7a7,
		0x0785df04, 0x09929351, 0x01fe8c3b, 0x0f2a0e5f,
		0x0111d39c, 0x07ab52ba, 0x01df4552, 0x01d87566,
		0x0f297be2, 0x027c090f, 0x0a81b155, 0x0d1a562b,
	}
	y := [nLimbs]uint32{
		0x00da9708, 0x0e7d583e, 0x0dbcc099, 0x0d2dad89,
		0x05a49ce4, 0x01cb4ddc, 0x0928d395, 0x0098d91d,
		0x0bff16ce, 0x06f02f9a, 0x0ce27cc1, 0x0dab5783,
		0x0b553d94, 0x03251a0c, 0x064d70fb, 0x07fe3a2f,
	}
	z := [nLimbs]uint32{
		0x0d5237cc, 0x0319d105, 0x02ab2df5, 0x022e9736,
		0x0d79742f, 0x00688712, 0x012d3a65, 0x0ef4925e,
		0x0bd0d260, 0x0832b532, 0x05faef27, 0x01ffe567,
		0x0161ce73, 0x07bda0f5, 0x035d04f1, 0x0930f532,
	}
	t := [nLimbs]uint32{
		0x01f6cc27, 0x09be7b8a, 0x0226da79, 0x0f6202f1,
		0x0e7264dc, 0x0d25aeb1, 0x06c81f07, 0x03c32cdc,
		0x0923c854, 0x0cfc9865, 0x055b2fed, 0x05bdcc90,
		0x01a99835, 0x0ea08056, 0x0abbf763, 0x03826c2f,
	}

	exp := &twExtendedPoint{
		&bigNumber{
			0x034365c8, 0x06b2a874, 0x0eb875d7, 0x0ae4c7a7,
			0x0785df04, 0x09929351, 0x01fe8c3b, 0x0f2a0e5f,
			0x0111d39c, 0x07ab52ba, 0x01df4552, 0x01d87566,
			0x0f297be2, 0x027c090f, 0x0a81b155, 0x0d1a562b,
		},
		&bigNumber{
			0x00da9708, 0x0e7d583e, 0x0dbcc099, 0x0d2dad89,
			0x05a49ce4, 0x01cb4ddc, 0x0928d395, 0x0098d91d,
			0x0bff16ce, 0x06f02f9a, 0x0ce27cc1, 0x0dab5783,
			0x0b553d94, 0x03251a0c, 0x064d70fb, 0x07fe3a2f,
		},
		&bigNumber{
			0x0d5237cc, 0x0319d105, 0x02ab2df5, 0x022e9736,
			0x0d79742f, 0x00688712, 0x012d3a65, 0x0ef4925e,
			0x0bd0d260, 0x0832b532, 0x05faef27, 0x01ffe567,
			0x0161ce73, 0x07bda0f5, 0x035d04f1, 0x0930f532,
		},
		&bigNumber{
			0x01f6cc27, 0x09be7b8a, 0x0226da79, 0x0f6202f1,
			0x0e7264dc, 0x0d25aeb1, 0x06c81f07, 0x03c32cdc,
			0x0923c854, 0x0cfc9865, 0x055b2fed, 0x05bdcc90,
			0x01a99835, 0x0ea08056, 0x0abbf763, 0x03826c2f,
		},
	}

	p := NewPoint(x, y, z, t)

	// from bigNumber
	c.Assert(p, DeepEquals, exp)

	q := NewPointFromBytes()

	exp = &twExtendedPoint{
		&bigNumber{},
		&bigNumber{},
		&bigNumber{},
		&bigNumber{},
	}

	// from nil
	c.Assert(q, DeepEquals, exp)

	bytes := []byte{
		0x5d, 0xf1, 0x18, 0xbf, 0x8e, 0x3f, 0xfe, 0xcd,
		0x95, 0xd3, 0x49, 0xda, 0xcd, 0xac, 0x2c, 0xdf,
		0x72, 0x5e, 0xb7, 0x61, 0x44, 0xf1, 0x93, 0xa6,
		0x70, 0x8e, 0x64, 0xff, 0x7c, 0xec, 0x6c, 0xe5,
		0xc6, 0x8d, 0x8f, 0xa0, 0x43, 0x23, 0x45, 0x33,
		0x73, 0x71, 0xe6, 0x2f, 0x57, 0xbb, 0x0f, 0x70,
		0x11, 0x8c, 0x62, 0x26, 0x9e, 0x17, 0x5d, 0x22,
	}

	r := NewPointFromBytes(bytes)

	exp = &twExtendedPoint{
		&bigNumber{
			0x0e31e2ba, 0x0fc7f1d7, 0x03a72b9b, 0x0599bb49,
			0x0ce5be59, 0x088c36eb, 0x014d27e2, 0x0fec91ce,
			0x0ad9d8f9, 0x01f1b8dc, 0x0a468741, 0x0e2e6668,
			0x06ae5fcc, 0x022e01f7, 0x0c4cc518, 0x044ba2f3,
		},
		&bigNumber{
			0x0994e812, 0x0e1ff707, 0x01ba2d54, 0x033afb0c,
			0x0c767d5e, 0x0c9dbaa0, 0x0fdd9b15, 0x0f932d54,
			0x037d31c1, 0x09c9d014, 0x00930691, 0x092fc558,
			0x0cf86392, 0x08b3c2d0, 0x071861ca, 0x0429dedc,
		},
		&bigNumber{
			0x0029d068, 0x048bee98, 0x010330cd, 0x049c941a,
			0x0d957b5e, 0x096dfaaf, 0x03b7f141, 0x0a05d444,
			0x018a2a16, 0x070f3a9a, 0x06596ab8, 0x054b887b,
			0x00c447f8, 0x022e7f89, 0x096ad471, 0x0810cdde,
		},
		&bigNumber{
			0x09431642, 0x021dbbf4, 0x092aaf6c, 0x043cea4e,
			0x06c85c5b, 0x0fdb1f83, 0x070e1477, 0x0eb61fa3,
			0x0373c32d, 0x0ba00156, 0x09e1ffd1, 0x06049056,
			0x0dfe7a48, 0x077bf062, 0x00178806, 0x079ce50a,
		},
	}

	// from bytes
	c.Assert(r, DeepEquals, exp)
}