Bump github.com/hashicorp/terraform-plugin-sdk/v2 from 2.26.1 to 2.27.0
Bumps [github.com/hashicorp/terraform-plugin-sdk/v2](https://github.com/hashicorp/terraform-plugin-sdk) from 2.26.1 to 2.27.0. - [Release notes](https://github.com/hashicorp/terraform-plugin-sdk/releases) - [Changelog](https://github.com/hashicorp/terraform-plugin-sdk/blob/main/CHANGELOG.md) - [Commits](https://github.com/hashicorp/terraform-plugin-sdk/compare/v2.26.1...v2.27.0) --- updated-dependencies: - dependency-name: github.com/hashicorp/terraform-plugin-sdk/v2 dependency-type: direct:production update-type: version-update:semver-minor ... Signed-off-by: dependabot[bot] <support@github.com>
This commit is contained in:
dependabot[bot]
GitHub
57
vendor/github.com/cloudflare/circl/LICENSE
generated
vendored
Normal file
57
vendor/github.com/cloudflare/circl/LICENSE
generated
vendored
Normal file
@ -0,0 +1,57 @@
|
||||
Copyright (c) 2019 Cloudflare. All rights reserved.
|
||||
|
||||
Redistribution and use in source and binary forms, with or without
|
||||
modification, are permitted provided that the following conditions are
|
||||
met:
|
||||
|
||||
* Redistributions of source code must retain the above copyright
|
||||
notice, this list of conditions and the following disclaimer.
|
||||
* Redistributions in binary form must reproduce the above
|
||||
copyright notice, this list of conditions and the following disclaimer
|
||||
in the documentation and/or other materials provided with the
|
||||
distribution.
|
||||
* Neither the name of Cloudflare nor the names of its
|
||||
contributors may be used to endorse or promote products derived from
|
||||
this software without specific prior written permission.
|
||||
|
||||
THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
|
||||
"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
|
||||
LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
|
||||
A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
|
||||
OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
|
||||
SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
|
||||
LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
|
||||
DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
|
||||
THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
|
||||
(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
|
||||
OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
||||
|
||||
========================================================================
|
||||
|
||||
Copyright (c) 2009 The Go Authors. All rights reserved.
|
||||
|
||||
Redistribution and use in source and binary forms, with or without
|
||||
modification, are permitted provided that the following conditions are
|
||||
met:
|
||||
|
||||
* Redistributions of source code must retain the above copyright
|
||||
notice, this list of conditions and the following disclaimer.
|
||||
* Redistributions in binary form must reproduce the above
|
||||
copyright notice, this list of conditions and the following disclaimer
|
||||
in the documentation and/or other materials provided with the
|
||||
distribution.
|
||||
* Neither the name of Google Inc. nor the names of its
|
||||
contributors may be used to endorse or promote products derived from
|
||||
this software without specific prior written permission.
|
||||
|
||||
THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
|
||||
"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
|
||||
LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
|
||||
A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
|
||||
OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
|
||||
SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
|
||||
LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
|
||||
DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
|
||||
THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
|
||||
(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
|
||||
OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
||||
96
vendor/github.com/cloudflare/circl/dh/x25519/curve.go
generated
vendored
Normal file
96
vendor/github.com/cloudflare/circl/dh/x25519/curve.go
generated
vendored
Normal file
@ -0,0 +1,96 @@
|
||||
package x25519
|
||||
|
||||
import (
|
||||
fp "github.com/cloudflare/circl/math/fp25519"
|
||||
)
|
||||
|
||||
// ladderJoye calculates a fixed-point multiplication with the generator point.
|
||||
// The algorithm is the right-to-left Joye's ladder as described
|
||||
// in "How to precompute a ladder" in SAC'2017.
|
||||
func ladderJoye(k *Key) {
|
||||
w := [5]fp.Elt{} // [mu,x1,z1,x2,z2] order must be preserved.
|
||||
fp.SetOne(&w[1]) // x1 = 1
|
||||
fp.SetOne(&w[2]) // z1 = 1
|
||||
w[3] = fp.Elt{ // x2 = G-S
|
||||
0xbd, 0xaa, 0x2f, 0xc8, 0xfe, 0xe1, 0x94, 0x7e,
|
||||
0xf8, 0xed, 0xb2, 0x14, 0xae, 0x95, 0xf0, 0xbb,
|
||||
0xe2, 0x48, 0x5d, 0x23, 0xb9, 0xa0, 0xc7, 0xad,
|
||||
0x34, 0xab, 0x7c, 0xe2, 0xee, 0xcd, 0xae, 0x1e,
|
||||
}
|
||||
fp.SetOne(&w[4]) // z2 = 1
|
||||
|
||||
const n = 255
|
||||
const h = 3
|
||||
swap := uint(1)
|
||||
for s := 0; s < n-h; s++ {
|
||||
i := (s + h) / 8
|
||||
j := (s + h) % 8
|
||||
bit := uint((k[i] >> uint(j)) & 1)
|
||||
copy(w[0][:], tableGenerator[s*Size:(s+1)*Size])
|
||||
diffAdd(&w, swap^bit)
|
||||
swap = bit
|
||||
}
|
||||
for s := 0; s < h; s++ {
|
||||
double(&w[1], &w[2])
|
||||
}
|
||||
toAffine((*[fp.Size]byte)(k), &w[1], &w[2])
|
||||
}
|
||||
|
||||
// ladderMontgomery calculates a generic scalar point multiplication
|
||||
// The algorithm implemented is the left-to-right Montgomery's ladder.
|
||||
func ladderMontgomery(k, xP *Key) {
|
||||
w := [5]fp.Elt{} // [x1, x2, z2, x3, z3] order must be preserved.
|
||||
w[0] = *(*fp.Elt)(xP) // x1 = xP
|
||||
fp.SetOne(&w[1]) // x2 = 1
|
||||
w[3] = *(*fp.Elt)(xP) // x3 = xP
|
||||
fp.SetOne(&w[4]) // z3 = 1
|
||||
|
||||
move := uint(0)
|
||||
for s := 255 - 1; s >= 0; s-- {
|
||||
i := s / 8
|
||||
j := s % 8
|
||||
bit := uint((k[i] >> uint(j)) & 1)
|
||||
ladderStep(&w, move^bit)
|
||||
move = bit
|
||||
}
|
||||
toAffine((*[fp.Size]byte)(k), &w[1], &w[2])
|
||||
}
|
||||
|
||||
func toAffine(k *[fp.Size]byte, x, z *fp.Elt) {
|
||||
fp.Inv(z, z)
|
||||
fp.Mul(x, x, z)
|
||||
_ = fp.ToBytes(k[:], x)
|
||||
}
|
||||
|
||||
var lowOrderPoints = [5]fp.Elt{
|
||||
{ /* (0,_,1) point of order 2 on Curve25519 */
|
||||
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
|
||||
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
|
||||
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
|
||||
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
|
||||
},
|
||||
{ /* (1,_,1) point of order 4 on Curve25519 */
|
||||
0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
|
||||
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
|
||||
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
|
||||
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
|
||||
},
|
||||
{ /* (x,_,1) first point of order 8 on Curve25519 */
|
||||
0xe0, 0xeb, 0x7a, 0x7c, 0x3b, 0x41, 0xb8, 0xae,
|
||||
0x16, 0x56, 0xe3, 0xfa, 0xf1, 0x9f, 0xc4, 0x6a,
|
||||
0xda, 0x09, 0x8d, 0xeb, 0x9c, 0x32, 0xb1, 0xfd,
|
||||
0x86, 0x62, 0x05, 0x16, 0x5f, 0x49, 0xb8, 0x00,
|
||||
},
|
||||
{ /* (x,_,1) second point of order 8 on Curve25519 */
|
||||
0x5f, 0x9c, 0x95, 0xbc, 0xa3, 0x50, 0x8c, 0x24,
|
||||
0xb1, 0xd0, 0xb1, 0x55, 0x9c, 0x83, 0xef, 0x5b,
|
||||
0x04, 0x44, 0x5c, 0xc4, 0x58, 0x1c, 0x8e, 0x86,
|
||||
0xd8, 0x22, 0x4e, 0xdd, 0xd0, 0x9f, 0x11, 0x57,
|
||||
},
|
||||
{ /* (-1,_,1) a point of order 4 on the twist of Curve25519 */
|
||||
0xec, 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, 0x7f,
|
||||
},
|
||||
}
|
||||
30
vendor/github.com/cloudflare/circl/dh/x25519/curve_amd64.go
generated
vendored
Normal file
30
vendor/github.com/cloudflare/circl/dh/x25519/curve_amd64.go
generated
vendored
Normal file
@ -0,0 +1,30 @@
|
||||
//go:build amd64 && !purego
|
||||
// +build amd64,!purego
|
||||
|
||||
package x25519
|
||||
|
||||
import (
|
||||
fp "github.com/cloudflare/circl/math/fp25519"
|
||||
"golang.org/x/sys/cpu"
|
||||
)
|
||||
|
||||
var hasBmi2Adx = cpu.X86.HasBMI2 && cpu.X86.HasADX
|
||||
|
||||
var _ = hasBmi2Adx
|
||||
|
||||
func double(x, z *fp.Elt) { doubleAmd64(x, z) }
|
||||
func diffAdd(w *[5]fp.Elt, b uint) { diffAddAmd64(w, b) }
|
||||
func ladderStep(w *[5]fp.Elt, b uint) { ladderStepAmd64(w, b) }
|
||||
func mulA24(z, x *fp.Elt) { mulA24Amd64(z, x) }
|
||||
|
||||
//go:noescape
|
||||
func ladderStepAmd64(w *[5]fp.Elt, b uint)
|
||||
|
||||
//go:noescape
|
||||
func diffAddAmd64(w *[5]fp.Elt, b uint)
|
||||
|
||||
//go:noescape
|
||||
func doubleAmd64(x, z *fp.Elt)
|
||||
|
||||
//go:noescape
|
||||
func mulA24Amd64(z, x *fp.Elt)
|
||||
111
vendor/github.com/cloudflare/circl/dh/x25519/curve_amd64.h
generated
vendored
Normal file
111
vendor/github.com/cloudflare/circl/dh/x25519/curve_amd64.h
generated
vendored
Normal file
@ -0,0 +1,111 @@
|
||||
#define ladderStepLeg \
|
||||
addSub(x2,z2) \
|
||||
addSub(x3,z3) \
|
||||
integerMulLeg(b0,x2,z3) \
|
||||
integerMulLeg(b1,x3,z2) \
|
||||
reduceFromDoubleLeg(t0,b0) \
|
||||
reduceFromDoubleLeg(t1,b1) \
|
||||
addSub(t0,t1) \
|
||||
cselect(x2,x3,regMove) \
|
||||
cselect(z2,z3,regMove) \
|
||||
integerSqrLeg(b0,t0) \
|
||||
integerSqrLeg(b1,t1) \
|
||||
reduceFromDoubleLeg(x3,b0) \
|
||||
reduceFromDoubleLeg(z3,b1) \
|
||||
integerMulLeg(b0,x1,z3) \
|
||||
reduceFromDoubleLeg(z3,b0) \
|
||||
integerSqrLeg(b0,x2) \
|
||||
integerSqrLeg(b1,z2) \
|
||||
reduceFromDoubleLeg(x2,b0) \
|
||||
reduceFromDoubleLeg(z2,b1) \
|
||||
subtraction(t0,x2,z2) \
|
||||
multiplyA24Leg(t1,t0) \
|
||||
additionLeg(t1,t1,z2) \
|
||||
integerMulLeg(b0,x2,z2) \
|
||||
integerMulLeg(b1,t0,t1) \
|
||||
reduceFromDoubleLeg(x2,b0) \
|
||||
reduceFromDoubleLeg(z2,b1)
|
||||
|
||||
#define ladderStepBmi2Adx \
|
||||
addSub(x2,z2) \
|
||||
addSub(x3,z3) \
|
||||
integerMulAdx(b0,x2,z3) \
|
||||
integerMulAdx(b1,x3,z2) \
|
||||
reduceFromDoubleAdx(t0,b0) \
|
||||
reduceFromDoubleAdx(t1,b1) \
|
||||
addSub(t0,t1) \
|
||||
cselect(x2,x3,regMove) \
|
||||
cselect(z2,z3,regMove) \
|
||||
integerSqrAdx(b0,t0) \
|
||||
integerSqrAdx(b1,t1) \
|
||||
reduceFromDoubleAdx(x3,b0) \
|
||||
reduceFromDoubleAdx(z3,b1) \
|
||||
integerMulAdx(b0,x1,z3) \
|
||||
reduceFromDoubleAdx(z3,b0) \
|
||||
integerSqrAdx(b0,x2) \
|
||||
integerSqrAdx(b1,z2) \
|
||||
reduceFromDoubleAdx(x2,b0) \
|
||||
reduceFromDoubleAdx(z2,b1) \
|
||||
subtraction(t0,x2,z2) \
|
||||
multiplyA24Adx(t1,t0) \
|
||||
additionAdx(t1,t1,z2) \
|
||||
integerMulAdx(b0,x2,z2) \
|
||||
integerMulAdx(b1,t0,t1) \
|
||||
reduceFromDoubleAdx(x2,b0) \
|
||||
reduceFromDoubleAdx(z2,b1)
|
||||
|
||||
#define difAddLeg \
|
||||
addSub(x1,z1) \
|
||||
integerMulLeg(b0,z1,ui) \
|
||||
reduceFromDoubleLeg(z1,b0) \
|
||||
addSub(x1,z1) \
|
||||
integerSqrLeg(b0,x1) \
|
||||
integerSqrLeg(b1,z1) \
|
||||
reduceFromDoubleLeg(x1,b0) \
|
||||
reduceFromDoubleLeg(z1,b1) \
|
||||
integerMulLeg(b0,x1,z2) \
|
||||
integerMulLeg(b1,z1,x2) \
|
||||
reduceFromDoubleLeg(x1,b0) \
|
||||
reduceFromDoubleLeg(z1,b1)
|
||||
|
||||
#define difAddBmi2Adx \
|
||||
addSub(x1,z1) \
|
||||
integerMulAdx(b0,z1,ui) \
|
||||
reduceFromDoubleAdx(z1,b0) \
|
||||
addSub(x1,z1) \
|
||||
integerSqrAdx(b0,x1) \
|
||||
integerSqrAdx(b1,z1) \
|
||||
reduceFromDoubleAdx(x1,b0) \
|
||||
reduceFromDoubleAdx(z1,b1) \
|
||||
integerMulAdx(b0,x1,z2) \
|
||||
integerMulAdx(b1,z1,x2) \
|
||||
reduceFromDoubleAdx(x1,b0) \
|
||||
reduceFromDoubleAdx(z1,b1)
|
||||
|
||||
#define doubleLeg \
|
||||
addSub(x1,z1) \
|
||||
integerSqrLeg(b0,x1) \
|
||||
integerSqrLeg(b1,z1) \
|
||||
reduceFromDoubleLeg(x1,b0) \
|
||||
reduceFromDoubleLeg(z1,b1) \
|
||||
subtraction(t0,x1,z1) \
|
||||
multiplyA24Leg(t1,t0) \
|
||||
additionLeg(t1,t1,z1) \
|
||||
integerMulLeg(b0,x1,z1) \
|
||||
integerMulLeg(b1,t0,t1) \
|
||||
reduceFromDoubleLeg(x1,b0) \
|
||||
reduceFromDoubleLeg(z1,b1)
|
||||
|
||||
#define doubleBmi2Adx \
|
||||
addSub(x1,z1) \
|
||||
integerSqrAdx(b0,x1) \
|
||||
integerSqrAdx(b1,z1) \
|
||||
reduceFromDoubleAdx(x1,b0) \
|
||||
reduceFromDoubleAdx(z1,b1) \
|
||||
subtraction(t0,x1,z1) \
|
||||
multiplyA24Adx(t1,t0) \
|
||||
additionAdx(t1,t1,z1) \
|
||||
integerMulAdx(b0,x1,z1) \
|
||||
integerMulAdx(b1,t0,t1) \
|
||||
reduceFromDoubleAdx(x1,b0) \
|
||||
reduceFromDoubleAdx(z1,b1)
|
||||
156
vendor/github.com/cloudflare/circl/dh/x25519/curve_amd64.s
generated
vendored
Normal file
156
vendor/github.com/cloudflare/circl/dh/x25519/curve_amd64.s
generated
vendored
Normal file
@ -0,0 +1,156 @@
|
||||
// +build amd64
|
||||
|
||||
#include "textflag.h"
|
||||
|
||||
// Depends on circl/math/fp25519 package
|
||||
#include "../../math/fp25519/fp_amd64.h"
|
||||
#include "curve_amd64.h"
|
||||
|
||||
// CTE_A24 is (A+2)/4 from Curve25519
|
||||
#define CTE_A24 121666
|
||||
|
||||
#define Size 32
|
||||
|
||||
// multiplyA24Leg multiplies x times CTE_A24 and stores in z
|
||||
// Uses: AX, DX, R8-R13, FLAGS
|
||||
// Instr: x86_64, cmov
|
||||
#define multiplyA24Leg(z,x) \
|
||||
MOVL $CTE_A24, AX; MULQ 0+x; MOVQ AX, R8; MOVQ DX, R9; \
|
||||
MOVL $CTE_A24, AX; MULQ 8+x; MOVQ AX, R12; MOVQ DX, R10; \
|
||||
MOVL $CTE_A24, AX; MULQ 16+x; MOVQ AX, R13; MOVQ DX, R11; \
|
||||
MOVL $CTE_A24, AX; MULQ 24+x; \
|
||||
ADDQ R12, R9; \
|
||||
ADCQ R13, R10; \
|
||||
ADCQ AX, R11; \
|
||||
ADCQ $0, DX; \
|
||||
MOVL $38, AX; /* 2*C = 38 = 2^256 MOD 2^255-19*/ \
|
||||
IMULQ AX, DX; \
|
||||
ADDQ DX, R8; \
|
||||
ADCQ $0, R9; MOVQ R9, 8+z; \
|
||||
ADCQ $0, R10; MOVQ R10, 16+z; \
|
||||
ADCQ $0, R11; MOVQ R11, 24+z; \
|
||||
MOVQ $0, DX; \
|
||||
CMOVQCS AX, DX; \
|
||||
ADDQ DX, R8; MOVQ R8, 0+z;
|
||||
|
||||
// multiplyA24Adx multiplies x times CTE_A24 and stores in z
|
||||
// Uses: AX, DX, R8-R12, FLAGS
|
||||
// Instr: x86_64, cmov, bmi2
|
||||
#define multiplyA24Adx(z,x) \
|
||||
MOVQ $CTE_A24, DX; \
|
||||
MULXQ 0+x, R8, R10; \
|
||||
MULXQ 8+x, R9, R11; ADDQ R10, R9; \
|
||||
MULXQ 16+x, R10, AX; ADCQ R11, R10; \
|
||||
MULXQ 24+x, R11, R12; ADCQ AX, R11; \
|
||||
;;;;;;;;;;;;;;;;;;;;; ADCQ $0, R12; \
|
||||
MOVL $38, DX; /* 2*C = 38 = 2^256 MOD 2^255-19*/ \
|
||||
IMULQ DX, R12; \
|
||||
ADDQ R12, R8; \
|
||||
ADCQ $0, R9; MOVQ R9, 8+z; \
|
||||
ADCQ $0, R10; MOVQ R10, 16+z; \
|
||||
ADCQ $0, R11; MOVQ R11, 24+z; \
|
||||
MOVQ $0, R12; \
|
||||
CMOVQCS DX, R12; \
|
||||
ADDQ R12, R8; MOVQ R8, 0+z;
|
||||
|
||||
#define mulA24Legacy \
|
||||
multiplyA24Leg(0(DI),0(SI))
|
||||
#define mulA24Bmi2Adx \
|
||||
multiplyA24Adx(0(DI),0(SI))
|
||||
|
||||
// func mulA24Amd64(z, x *fp255.Elt)
|
||||
TEXT ·mulA24Amd64(SB),NOSPLIT,$0-16
|
||||
MOVQ z+0(FP), DI
|
||||
MOVQ x+8(FP), SI
|
||||
CHECK_BMI2ADX(LMA24, mulA24Legacy, mulA24Bmi2Adx)
|
||||
|
||||
|
||||
// func ladderStepAmd64(w *[5]fp255.Elt, b uint)
|
||||
// ladderStepAmd64 calculates a point addition and doubling as follows:
|
||||
// (x2,z2) = 2*(x2,z2) and (x3,z3) = (x2,z2)+(x3,z3) using as a difference (x1,-).
|
||||
// work = (x1,x2,z2,x3,z3) are five fp255.Elt of 32 bytes.
|
||||
// stack = (t0,t1) are two fp.Elt of fp.Size bytes, and
|
||||
// (b0,b1) are two-double precision fp.Elt of 2*fp.Size bytes.
|
||||
TEXT ·ladderStepAmd64(SB),NOSPLIT,$192-16
|
||||
// Parameters
|
||||
#define regWork DI
|
||||
#define regMove SI
|
||||
#define x1 0*Size(regWork)
|
||||
#define x2 1*Size(regWork)
|
||||
#define z2 2*Size(regWork)
|
||||
#define x3 3*Size(regWork)
|
||||
#define z3 4*Size(regWork)
|
||||
// Local variables
|
||||
#define t0 0*Size(SP)
|
||||
#define t1 1*Size(SP)
|
||||
#define b0 2*Size(SP)
|
||||
#define b1 4*Size(SP)
|
||||
MOVQ w+0(FP), regWork
|
||||
MOVQ b+8(FP), regMove
|
||||
CHECK_BMI2ADX(LLADSTEP, ladderStepLeg, ladderStepBmi2Adx)
|
||||
#undef regWork
|
||||
#undef regMove
|
||||
#undef x1
|
||||
#undef x2
|
||||
#undef z2
|
||||
#undef x3
|
||||
#undef z3
|
||||
#undef t0
|
||||
#undef t1
|
||||
#undef b0
|
||||
#undef b1
|
||||
|
||||
// func diffAddAmd64(w *[5]fp255.Elt, b uint)
|
||||
// diffAddAmd64 calculates a differential point addition using a precomputed point.
|
||||
// (x1,z1) = (x1,z1)+(mu) using a difference point (x2,z2)
|
||||
// w = (mu,x1,z1,x2,z2) are five fp.Elt, and
|
||||
// stack = (b0,b1) are two-double precision fp.Elt of 2*fp.Size bytes.
|
||||
TEXT ·diffAddAmd64(SB),NOSPLIT,$128-16
|
||||
// Parameters
|
||||
#define regWork DI
|
||||
#define regSwap SI
|
||||
#define ui 0*Size(regWork)
|
||||
#define x1 1*Size(regWork)
|
||||
#define z1 2*Size(regWork)
|
||||
#define x2 3*Size(regWork)
|
||||
#define z2 4*Size(regWork)
|
||||
// Local variables
|
||||
#define b0 0*Size(SP)
|
||||
#define b1 2*Size(SP)
|
||||
MOVQ w+0(FP), regWork
|
||||
MOVQ b+8(FP), regSwap
|
||||
cswap(x1,x2,regSwap)
|
||||
cswap(z1,z2,regSwap)
|
||||
CHECK_BMI2ADX(LDIFADD, difAddLeg, difAddBmi2Adx)
|
||||
#undef regWork
|
||||
#undef regSwap
|
||||
#undef ui
|
||||
#undef x1
|
||||
#undef z1
|
||||
#undef x2
|
||||
#undef z2
|
||||
#undef b0
|
||||
#undef b1
|
||||
|
||||
// func doubleAmd64(x, z *fp255.Elt)
|
||||
// doubleAmd64 calculates a point doubling (x1,z1) = 2*(x1,z1).
|
||||
// stack = (t0,t1) are two fp.Elt of fp.Size bytes, and
|
||||
// (b0,b1) are two-double precision fp.Elt of 2*fp.Size bytes.
|
||||
TEXT ·doubleAmd64(SB),NOSPLIT,$192-16
|
||||
// Parameters
|
||||
#define x1 0(DI)
|
||||
#define z1 0(SI)
|
||||
// Local variables
|
||||
#define t0 0*Size(SP)
|
||||
#define t1 1*Size(SP)
|
||||
#define b0 2*Size(SP)
|
||||
#define b1 4*Size(SP)
|
||||
MOVQ x+0(FP), DI
|
||||
MOVQ z+8(FP), SI
|
||||
CHECK_BMI2ADX(LDOUB,doubleLeg,doubleBmi2Adx)
|
||||
#undef x1
|
||||
#undef z1
|
||||
#undef t0
|
||||
#undef t1
|
||||
#undef b0
|
||||
#undef b1
|
||||
85
vendor/github.com/cloudflare/circl/dh/x25519/curve_generic.go
generated
vendored
Normal file
85
vendor/github.com/cloudflare/circl/dh/x25519/curve_generic.go
generated
vendored
Normal file
@ -0,0 +1,85 @@
|
||||
package x25519
|
||||
|
||||
import (
|
||||
"encoding/binary"
|
||||
"math/bits"
|
||||
|
||||
fp "github.com/cloudflare/circl/math/fp25519"
|
||||
)
|
||||
|
||||
func doubleGeneric(x, z *fp.Elt) {
|
||||
t0, t1 := &fp.Elt{}, &fp.Elt{}
|
||||
fp.AddSub(x, z)
|
||||
fp.Sqr(x, x)
|
||||
fp.Sqr(z, z)
|
||||
fp.Sub(t0, x, z)
|
||||
mulA24Generic(t1, t0)
|
||||
fp.Add(t1, t1, z)
|
||||
fp.Mul(x, x, z)
|
||||
fp.Mul(z, t0, t1)
|
||||
}
|
||||
|
||||
func diffAddGeneric(w *[5]fp.Elt, b uint) {
|
||||
mu, x1, z1, x2, z2 := &w[0], &w[1], &w[2], &w[3], &w[4]
|
||||
fp.Cswap(x1, x2, b)
|
||||
fp.Cswap(z1, z2, b)
|
||||
fp.AddSub(x1, z1)
|
||||
fp.Mul(z1, z1, mu)
|
||||
fp.AddSub(x1, z1)
|
||||
fp.Sqr(x1, x1)
|
||||
fp.Sqr(z1, z1)
|
||||
fp.Mul(x1, x1, z2)
|
||||
fp.Mul(z1, z1, x2)
|
||||
}
|
||||
|
||||
func ladderStepGeneric(w *[5]fp.Elt, b uint) {
|
||||
x1, x2, z2, x3, z3 := &w[0], &w[1], &w[2], &w[3], &w[4]
|
||||
t0 := &fp.Elt{}
|
||||
t1 := &fp.Elt{}
|
||||
fp.AddSub(x2, z2)
|
||||
fp.AddSub(x3, z3)
|
||||
fp.Mul(t0, x2, z3)
|
||||
fp.Mul(t1, x3, z2)
|
||||
fp.AddSub(t0, t1)
|
||||
fp.Cmov(x2, x3, b)
|
||||
fp.Cmov(z2, z3, b)
|
||||
fp.Sqr(x3, t0)
|
||||
fp.Sqr(z3, t1)
|
||||
fp.Mul(z3, x1, z3)
|
||||
fp.Sqr(x2, x2)
|
||||
fp.Sqr(z2, z2)
|
||||
fp.Sub(t0, x2, z2)
|
||||
mulA24Generic(t1, t0)
|
||||
fp.Add(t1, t1, z2)
|
||||
fp.Mul(x2, x2, z2)
|
||||
fp.Mul(z2, t0, t1)
|
||||
}
|
||||
|
||||
func mulA24Generic(z, x *fp.Elt) {
|
||||
const A24 = 121666
|
||||
const n = 8
|
||||
var xx [4]uint64
|
||||
for i := range xx {
|
||||
xx[i] = binary.LittleEndian.Uint64(x[i*n : (i+1)*n])
|
||||
}
|
||||
|
||||
h0, l0 := bits.Mul64(xx[0], A24)
|
||||
h1, l1 := bits.Mul64(xx[1], A24)
|
||||
h2, l2 := bits.Mul64(xx[2], A24)
|
||||
h3, l3 := bits.Mul64(xx[3], A24)
|
||||
|
||||
var c3 uint64
|
||||
l1, c0 := bits.Add64(h0, l1, 0)
|
||||
l2, c1 := bits.Add64(h1, l2, c0)
|
||||
l3, c2 := bits.Add64(h2, l3, c1)
|
||||
l4, _ := bits.Add64(h3, 0, c2)
|
||||
_, l4 = bits.Mul64(l4, 38)
|
||||
l0, c0 = bits.Add64(l0, l4, 0)
|
||||
xx[1], c1 = bits.Add64(l1, 0, c0)
|
||||
xx[2], c2 = bits.Add64(l2, 0, c1)
|
||||
xx[3], c3 = bits.Add64(l3, 0, c2)
|
||||
xx[0], _ = bits.Add64(l0, (-c3)&38, 0)
|
||||
for i := range xx {
|
||||
binary.LittleEndian.PutUint64(z[i*n:(i+1)*n], xx[i])
|
||||
}
|
||||
}
|
||||
11
vendor/github.com/cloudflare/circl/dh/x25519/curve_noasm.go
generated
vendored
Normal file
11
vendor/github.com/cloudflare/circl/dh/x25519/curve_noasm.go
generated
vendored
Normal file
@ -0,0 +1,11 @@
|
||||
//go:build !amd64 || purego
|
||||
// +build !amd64 purego
|
||||
|
||||
package x25519
|
||||
|
||||
import fp "github.com/cloudflare/circl/math/fp25519"
|
||||
|
||||
func double(x, z *fp.Elt) { doubleGeneric(x, z) }
|
||||
func diffAdd(w *[5]fp.Elt, b uint) { diffAddGeneric(w, b) }
|
||||
func ladderStep(w *[5]fp.Elt, b uint) { ladderStepGeneric(w, b) }
|
||||
func mulA24(z, x *fp.Elt) { mulA24Generic(z, x) }
|
||||
19
vendor/github.com/cloudflare/circl/dh/x25519/doc.go
generated
vendored
Normal file
19
vendor/github.com/cloudflare/circl/dh/x25519/doc.go
generated
vendored
Normal file
@ -0,0 +1,19 @@
|
||||
/*
|
||||
Package x25519 provides Diffie-Hellman functions as specified in RFC-7748.
|
||||
|
||||
Validation of public keys.
|
||||
|
||||
The Diffie-Hellman function, as described in RFC-7748 [1], works for any
|
||||
public key. However, if a different protocol requires contributory
|
||||
behaviour [2,3], then the public keys must be validated against low-order
|
||||
points [3,4]. To do that, the Shared function performs this validation
|
||||
internally and returns false when the public key is invalid (i.e., it
|
||||
is a low-order point).
|
||||
|
||||
References:
|
||||
- [1] RFC7748 by Langley, Hamburg, Turner (https://rfc-editor.org/rfc/rfc7748.txt)
|
||||
- [2] Curve25519 by Bernstein (https://cr.yp.to/ecdh.html)
|
||||
- [3] Bernstein (https://cr.yp.to/ecdh.html#validate)
|
||||
- [4] Cremers&Jackson (https://eprint.iacr.org/2019/526)
|
||||
*/
|
||||
package x25519
|
||||
47
vendor/github.com/cloudflare/circl/dh/x25519/key.go
generated
vendored
Normal file
47
vendor/github.com/cloudflare/circl/dh/x25519/key.go
generated
vendored
Normal file
@ -0,0 +1,47 @@
|
||||
package x25519
|
||||
|
||||
import (
|
||||
"crypto/subtle"
|
||||
|
||||
fp "github.com/cloudflare/circl/math/fp25519"
|
||||
)
|
||||
|
||||
// Size is the length in bytes of a X25519 key.
|
||||
const Size = 32
|
||||
|
||||
// Key represents a X25519 key.
|
||||
type Key [Size]byte
|
||||
|
||||
func (k *Key) clamp(in *Key) *Key {
|
||||
*k = *in
|
||||
k[0] &= 248
|
||||
k[31] = (k[31] & 127) | 64
|
||||
return k
|
||||
}
|
||||
|
||||
// isValidPubKey verifies if the public key is not a low-order point.
|
||||
func (k *Key) isValidPubKey() bool {
|
||||
fp.Modp((*fp.Elt)(k))
|
||||
var isLowOrder int
|
||||
for _, P := range lowOrderPoints {
|
||||
isLowOrder |= subtle.ConstantTimeCompare(P[:], k[:])
|
||||
}
|
||||
return isLowOrder == 0
|
||||
}
|
||||
|
||||
// KeyGen obtains a public key given a secret key.
|
||||
func KeyGen(public, secret *Key) {
|
||||
ladderJoye(public.clamp(secret))
|
||||
}
|
||||
|
||||
// Shared calculates Alice's shared key from Alice's secret key and Bob's
|
||||
// public key returning true on success. A failure case happens when the public
|
||||
// key is a low-order point, thus the shared key is all-zeros and the function
|
||||
// returns false.
|
||||
func Shared(shared, secret, public *Key) bool {
|
||||
validPk := *public
|
||||
validPk[31] &= (1 << (255 % 8)) - 1
|
||||
ok := validPk.isValidPubKey()
|
||||
ladderMontgomery(shared.clamp(secret), &validPk)
|
||||
return ok
|
||||
}
|
||||
268
vendor/github.com/cloudflare/circl/dh/x25519/table.go
generated
vendored
Normal file
268
vendor/github.com/cloudflare/circl/dh/x25519/table.go
generated
vendored
Normal file
@ -0,0 +1,268 @@
|
||||
package x25519
|
||||
|
||||
import "github.com/cloudflare/circl/math/fp25519"
|
||||
|
||||
// tableGenerator contains the set of points:
|
||||
//
|
||||
// t[i] = (xi+1)/(xi-1),
|
||||
//
|
||||
// where (xi,yi) = 2^iG and G is the generator point
|
||||
// Size = (256)*(256/8) = 8192 bytes.
|
||||
var tableGenerator = [256 * fp25519.Size]byte{
|
||||
/* (2^ 0)P */ 0xf3, 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, 0x5f,
|
||||
/* (2^ 1)P */ 0x96, 0xfe, 0xaa, 0x16, 0xf4, 0x20, 0x82, 0x6b, 0x34, 0x6a, 0x56, 0x4f, 0x2b, 0xeb, 0xeb, 0x82, 0x0f, 0x95, 0xa5, 0x75, 0xb0, 0xa5, 0xa9, 0xd5, 0xf4, 0x88, 0x24, 0x4b, 0xcf, 0xb2, 0x42, 0x51,
|
||||
/* (2^ 2)P */ 0x0c, 0x68, 0x69, 0x00, 0x75, 0xbc, 0xae, 0x6a, 0x41, 0x9c, 0xf9, 0xa0, 0x20, 0x78, 0xcf, 0x89, 0xf4, 0xd0, 0x56, 0x3b, 0x18, 0xd9, 0x58, 0x2a, 0xa4, 0x11, 0x60, 0xe3, 0x80, 0xca, 0x5a, 0x4b,
|
||||
/* (2^ 3)P */ 0x5d, 0x74, 0x29, 0x8c, 0x34, 0x32, 0x91, 0x32, 0xd7, 0x2f, 0x64, 0xe1, 0x16, 0xe6, 0xa2, 0xf4, 0x34, 0xbc, 0x67, 0xff, 0x03, 0xbb, 0x45, 0x1e, 0x4a, 0x9b, 0x2a, 0xf4, 0xd0, 0x12, 0x69, 0x30,
|
||||
/* (2^ 4)P */ 0x54, 0x71, 0xaf, 0xe6, 0x07, 0x65, 0x88, 0xff, 0x2f, 0xc8, 0xee, 0xdf, 0x13, 0x0e, 0xf5, 0x04, 0xce, 0xb5, 0xba, 0x2a, 0xe8, 0x2f, 0x51, 0xaa, 0x22, 0xf2, 0xd5, 0x68, 0x1a, 0x25, 0x4e, 0x17,
|
||||
/* (2^ 5)P */ 0x98, 0x88, 0x02, 0x82, 0x0d, 0x70, 0x96, 0xcf, 0xc5, 0x02, 0x2c, 0x0a, 0x37, 0xe3, 0x43, 0x17, 0xaa, 0x6e, 0xe8, 0xb4, 0x98, 0xec, 0x9e, 0x37, 0x2e, 0x48, 0xe0, 0x51, 0x8a, 0x88, 0x59, 0x0c,
|
||||
/* (2^ 6)P */ 0x89, 0xd1, 0xb5, 0x99, 0xd6, 0xf1, 0xcb, 0xfb, 0x84, 0xdc, 0x9f, 0x8e, 0xd5, 0xf0, 0xae, 0xac, 0x14, 0x76, 0x1f, 0x23, 0x06, 0x0d, 0xc2, 0xc1, 0x72, 0xf9, 0x74, 0xa2, 0x8d, 0x21, 0x38, 0x29,
|
||||
/* (2^ 7)P */ 0x18, 0x7f, 0x1d, 0xff, 0xbe, 0x49, 0xaf, 0xf6, 0xc2, 0xc9, 0x7a, 0x38, 0x22, 0x1c, 0x54, 0xcc, 0x6b, 0xc5, 0x15, 0x40, 0xef, 0xc9, 0xfc, 0x96, 0xa9, 0x13, 0x09, 0x69, 0x7c, 0x62, 0xc1, 0x69,
|
||||
/* (2^ 8)P */ 0x0e, 0xdb, 0x33, 0x47, 0x2f, 0xfd, 0x86, 0x7a, 0xe9, 0x7d, 0x08, 0x9e, 0xf2, 0xc4, 0xb8, 0xfd, 0x29, 0xa2, 0xa2, 0x8e, 0x1a, 0x4b, 0x5e, 0x09, 0x79, 0x7a, 0xb3, 0x29, 0xc8, 0xa7, 0xd7, 0x1a,
|
||||
/* (2^ 9)P */ 0xc0, 0xa0, 0x7e, 0xd1, 0xca, 0x89, 0x2d, 0x34, 0x51, 0x20, 0xed, 0xcc, 0xa6, 0xdd, 0xbe, 0x67, 0x74, 0x2f, 0xb4, 0x2b, 0xbf, 0x31, 0xca, 0x19, 0xbb, 0xac, 0x80, 0x49, 0xc8, 0xb4, 0xf7, 0x3d,
|
||||
/* (2^ 10)P */ 0x83, 0xd8, 0x0a, 0xc8, 0x4d, 0x44, 0xc6, 0xa8, 0x85, 0xab, 0xe3, 0x66, 0x03, 0x44, 0x1e, 0xb9, 0xd8, 0xf6, 0x64, 0x01, 0xa0, 0xcd, 0x15, 0xc2, 0x68, 0xe6, 0x47, 0xf2, 0x6e, 0x7c, 0x86, 0x3d,
|
||||
/* (2^ 11)P */ 0x8c, 0x65, 0x3e, 0xcc, 0x2b, 0x58, 0xdd, 0xc7, 0x28, 0x55, 0x0e, 0xee, 0x48, 0x47, 0x2c, 0xfd, 0x71, 0x4f, 0x9f, 0xcc, 0x95, 0x9b, 0xfd, 0xa0, 0xdf, 0x5d, 0x67, 0xb0, 0x71, 0xd8, 0x29, 0x75,
|
||||
/* (2^ 12)P */ 0x78, 0xbd, 0x3c, 0x2d, 0xb4, 0x68, 0xf5, 0xb8, 0x82, 0xda, 0xf3, 0x91, 0x1b, 0x01, 0x33, 0x12, 0x62, 0x3b, 0x7c, 0x4a, 0xcd, 0x6c, 0xce, 0x2d, 0x03, 0x86, 0x49, 0x9e, 0x8e, 0xfc, 0xe7, 0x75,
|
||||
/* (2^ 13)P */ 0xec, 0xb6, 0xd0, 0xfc, 0xf1, 0x13, 0x4f, 0x2f, 0x45, 0x7a, 0xff, 0x29, 0x1f, 0xca, 0xa8, 0xf1, 0x9b, 0xe2, 0x81, 0x29, 0xa7, 0xc1, 0x49, 0xc2, 0x6a, 0xb5, 0x83, 0x8c, 0xbb, 0x0d, 0xbe, 0x6e,
|
||||
/* (2^ 14)P */ 0x22, 0xb2, 0x0b, 0x17, 0x8d, 0xfa, 0x14, 0x71, 0x5f, 0x93, 0x93, 0xbf, 0xd5, 0xdc, 0xa2, 0x65, 0x9a, 0x97, 0x9c, 0xb5, 0x68, 0x1f, 0xc4, 0xbd, 0x89, 0x92, 0xce, 0xa2, 0x79, 0xef, 0x0e, 0x2f,
|
||||
/* (2^ 15)P */ 0xce, 0x37, 0x3c, 0x08, 0x0c, 0xbf, 0xec, 0x42, 0x22, 0x63, 0x49, 0xec, 0x09, 0xbc, 0x30, 0x29, 0x0d, 0xac, 0xfe, 0x9c, 0xc1, 0xb0, 0x94, 0xf2, 0x80, 0xbb, 0xfa, 0xed, 0x4b, 0xaa, 0x80, 0x37,
|
||||
/* (2^ 16)P */ 0x29, 0xd9, 0xea, 0x7c, 0x3e, 0x7d, 0xc1, 0x56, 0xc5, 0x22, 0x57, 0x2e, 0xeb, 0x4b, 0xcb, 0xe7, 0x5a, 0xe1, 0xbf, 0x2d, 0x73, 0x31, 0xe9, 0x0c, 0xf8, 0x52, 0x10, 0x62, 0xc7, 0x83, 0xb8, 0x41,
|
||||
/* (2^ 17)P */ 0x50, 0x53, 0xd2, 0xc3, 0xa0, 0x5c, 0xf7, 0xdb, 0x51, 0xe3, 0xb1, 0x6e, 0x08, 0xbe, 0x36, 0x29, 0x12, 0xb2, 0xa9, 0xb4, 0x3c, 0xe0, 0x36, 0xc9, 0xaa, 0x25, 0x22, 0x32, 0x82, 0xbf, 0x45, 0x1d,
|
||||
/* (2^ 18)P */ 0xc5, 0x4c, 0x02, 0x6a, 0x03, 0xb1, 0x1a, 0xe8, 0x72, 0x9a, 0x4c, 0x30, 0x1c, 0x20, 0x12, 0xe2, 0xfc, 0xb1, 0x32, 0x68, 0xba, 0x3f, 0xd7, 0xc5, 0x81, 0x95, 0x83, 0x4d, 0x5a, 0xdb, 0xff, 0x20,
|
||||
/* (2^ 19)P */ 0xad, 0x0f, 0x5d, 0xbe, 0x67, 0xd3, 0x83, 0xa2, 0x75, 0x44, 0x16, 0x8b, 0xca, 0x25, 0x2b, 0x6c, 0x2e, 0xf2, 0xaa, 0x7c, 0x46, 0x35, 0x49, 0x9d, 0x49, 0xff, 0x85, 0xee, 0x8e, 0x40, 0x66, 0x51,
|
||||
/* (2^ 20)P */ 0x61, 0xe3, 0xb4, 0xfa, 0xa2, 0xba, 0x67, 0x3c, 0xef, 0x5c, 0xf3, 0x7e, 0xc6, 0x33, 0xe4, 0xb3, 0x1c, 0x9b, 0x15, 0x41, 0x92, 0x72, 0x59, 0x52, 0x33, 0xab, 0xb0, 0xd5, 0x92, 0x18, 0x62, 0x6a,
|
||||
/* (2^ 21)P */ 0xcb, 0xcd, 0x55, 0x75, 0x38, 0x4a, 0xb7, 0x20, 0x3f, 0x92, 0x08, 0x12, 0x0e, 0xa1, 0x2a, 0x53, 0xd1, 0x1d, 0x28, 0x62, 0x77, 0x7b, 0xa1, 0xea, 0xbf, 0x44, 0x5c, 0xf0, 0x43, 0x34, 0xab, 0x61,
|
||||
/* (2^ 22)P */ 0xf8, 0xde, 0x24, 0x23, 0x42, 0x6c, 0x7a, 0x25, 0x7f, 0xcf, 0xe3, 0x17, 0x10, 0x6c, 0x1c, 0x13, 0x57, 0xa2, 0x30, 0xf6, 0x39, 0x87, 0x75, 0x23, 0x80, 0x85, 0xa7, 0x01, 0x7a, 0x40, 0x5a, 0x29,
|
||||
/* (2^ 23)P */ 0xd9, 0xa8, 0x5d, 0x6d, 0x24, 0x43, 0xc4, 0xf8, 0x5d, 0xfa, 0x52, 0x0c, 0x45, 0x75, 0xd7, 0x19, 0x3d, 0xf8, 0x1b, 0x73, 0x92, 0xfc, 0xfc, 0x2a, 0x00, 0x47, 0x2b, 0x1b, 0xe8, 0xc8, 0x10, 0x7d,
|
||||
/* (2^ 24)P */ 0x0b, 0xa2, 0xba, 0x70, 0x1f, 0x27, 0xe0, 0xc8, 0x57, 0x39, 0xa6, 0x7c, 0x86, 0x48, 0x37, 0x99, 0xbb, 0xd4, 0x7e, 0xcb, 0xb3, 0xef, 0x12, 0x54, 0x75, 0x29, 0xe6, 0x73, 0x61, 0xd3, 0x96, 0x31,
|
||||
/* (2^ 25)P */ 0xfc, 0xdf, 0xc7, 0x41, 0xd1, 0xca, 0x5b, 0xde, 0x48, 0xc8, 0x95, 0xb3, 0xd2, 0x8c, 0xcc, 0x47, 0xcb, 0xf3, 0x1a, 0xe1, 0x42, 0xd9, 0x4c, 0xa3, 0xc2, 0xce, 0x4e, 0xd0, 0xf2, 0xdb, 0x56, 0x02,
|
||||
/* (2^ 26)P */ 0x7f, 0x66, 0x0e, 0x4b, 0xe9, 0xb7, 0x5a, 0x87, 0x10, 0x0d, 0x85, 0xc0, 0x83, 0xdd, 0xd4, 0xca, 0x9f, 0xc7, 0x72, 0x4e, 0x8f, 0x2e, 0xf1, 0x47, 0x9b, 0xb1, 0x85, 0x8c, 0xbb, 0x87, 0x1a, 0x5f,
|
||||
/* (2^ 27)P */ 0xb8, 0x51, 0x7f, 0x43, 0xb6, 0xd0, 0xe9, 0x7a, 0x65, 0x90, 0x87, 0x18, 0x55, 0xce, 0xc7, 0x12, 0xee, 0x7a, 0xf7, 0x5c, 0xfe, 0x09, 0xde, 0x2a, 0x27, 0x56, 0x2c, 0x7d, 0x2f, 0x5a, 0xa0, 0x23,
|
||||
/* (2^ 28)P */ 0x9a, 0x16, 0x7c, 0xf1, 0x28, 0xe1, 0x08, 0x59, 0x2d, 0x85, 0xd0, 0x8a, 0xdd, 0x98, 0x74, 0xf7, 0x64, 0x2f, 0x10, 0xab, 0xce, 0xc4, 0xb4, 0x74, 0x45, 0x98, 0x13, 0x10, 0xdd, 0xba, 0x3a, 0x18,
|
||||
/* (2^ 29)P */ 0xac, 0xaa, 0x92, 0xaa, 0x8d, 0xba, 0x65, 0xb1, 0x05, 0x67, 0x38, 0x99, 0x95, 0xef, 0xc5, 0xd5, 0xd1, 0x40, 0xfc, 0xf8, 0x0c, 0x8f, 0x2f, 0xbe, 0x14, 0x45, 0x20, 0xee, 0x35, 0xe6, 0x01, 0x27,
|
||||
/* (2^ 30)P */ 0x14, 0x65, 0x15, 0x20, 0x00, 0xa8, 0x9f, 0x62, 0xce, 0xc1, 0xa8, 0x64, 0x87, 0x86, 0x23, 0xf2, 0x0e, 0x06, 0x3f, 0x0b, 0xff, 0x4f, 0x89, 0x5b, 0xfa, 0xa3, 0x08, 0xf7, 0x4c, 0x94, 0xd9, 0x60,
|
||||
/* (2^ 31)P */ 0x1f, 0x20, 0x7a, 0x1c, 0x1a, 0x00, 0xea, 0xae, 0x63, 0xce, 0xe2, 0x3e, 0x63, 0x6a, 0xf1, 0xeb, 0xe1, 0x07, 0x7a, 0x4c, 0x59, 0x09, 0x77, 0x6f, 0xcb, 0x08, 0x02, 0x0d, 0x15, 0x58, 0xb9, 0x79,
|
||||
/* (2^ 32)P */ 0xe7, 0x10, 0xd4, 0x01, 0x53, 0x5e, 0xb5, 0x24, 0x4d, 0xc8, 0xfd, 0xf3, 0xdf, 0x4e, 0xa3, 0xe3, 0xd8, 0x32, 0x40, 0x90, 0xe4, 0x68, 0x87, 0xd8, 0xec, 0xae, 0x3a, 0x7b, 0x42, 0x84, 0x13, 0x13,
|
||||
/* (2^ 33)P */ 0x14, 0x4f, 0x23, 0x86, 0x12, 0xe5, 0x05, 0x84, 0x29, 0xc5, 0xb4, 0xad, 0x39, 0x47, 0xdc, 0x14, 0xfd, 0x4f, 0x63, 0x50, 0xb2, 0xb5, 0xa2, 0xb8, 0x93, 0xff, 0xa7, 0xd8, 0x4a, 0xa9, 0xe2, 0x2f,
|
||||
/* (2^ 34)P */ 0xdd, 0xfa, 0x43, 0xe8, 0xef, 0x57, 0x5c, 0xec, 0x18, 0x99, 0xbb, 0xf0, 0x40, 0xce, 0x43, 0x28, 0x05, 0x63, 0x3d, 0xcf, 0xd6, 0x61, 0xb5, 0xa4, 0x7e, 0x77, 0xfb, 0xe8, 0xbd, 0x29, 0x36, 0x74,
|
||||
/* (2^ 35)P */ 0x8f, 0x73, 0xaf, 0xbb, 0x46, 0xdd, 0x3e, 0x34, 0x51, 0xa6, 0x01, 0xb1, 0x28, 0x18, 0x98, 0xed, 0x7a, 0x79, 0x2c, 0x88, 0x0b, 0x76, 0x01, 0xa4, 0x30, 0x87, 0xc8, 0x8d, 0xe2, 0x23, 0xc2, 0x1f,
|
||||
/* (2^ 36)P */ 0x0e, 0xba, 0x0f, 0xfc, 0x91, 0x4e, 0x60, 0x48, 0xa4, 0x6f, 0x2c, 0x05, 0x8f, 0xf7, 0x37, 0xb6, 0x9c, 0x23, 0xe9, 0x09, 0x3d, 0xac, 0xcc, 0x91, 0x7c, 0x68, 0x7a, 0x43, 0xd4, 0xee, 0xf7, 0x23,
|
||||
/* (2^ 37)P */ 0x00, 0xd8, 0x9b, 0x8d, 0x11, 0xb1, 0x73, 0x51, 0xa7, 0xd4, 0x89, 0x31, 0xb6, 0x41, 0xd6, 0x29, 0x86, 0xc5, 0xbb, 0x88, 0x79, 0x17, 0xbf, 0xfd, 0xf5, 0x1d, 0xd8, 0xca, 0x4f, 0x89, 0x59, 0x29,
|
||||
/* (2^ 38)P */ 0x99, 0xc8, 0xbb, 0xb4, 0xf3, 0x8e, 0xbc, 0xae, 0xb9, 0x92, 0x69, 0xb2, 0x5a, 0x99, 0x48, 0x41, 0xfb, 0x2c, 0xf9, 0x34, 0x01, 0x0b, 0xe2, 0x24, 0xe8, 0xde, 0x05, 0x4a, 0x89, 0x58, 0xd1, 0x40,
|
||||
/* (2^ 39)P */ 0xf6, 0x76, 0xaf, 0x85, 0x11, 0x0b, 0xb0, 0x46, 0x79, 0x7a, 0x18, 0x73, 0x78, 0xc7, 0xba, 0x26, 0x5f, 0xff, 0x8f, 0xab, 0x95, 0xbf, 0xc0, 0x3d, 0xd7, 0x24, 0x55, 0x94, 0xd8, 0x8b, 0x60, 0x2a,
|
||||
/* (2^ 40)P */ 0x02, 0x63, 0x44, 0xbd, 0x88, 0x95, 0x44, 0x26, 0x9c, 0x43, 0x88, 0x03, 0x1c, 0xc2, 0x4b, 0x7c, 0xb2, 0x11, 0xbd, 0x83, 0xf3, 0xa4, 0x98, 0x8e, 0xb9, 0x76, 0xd8, 0xc9, 0x7b, 0x8d, 0x21, 0x26,
|
||||
/* (2^ 41)P */ 0x8a, 0x17, 0x7c, 0x99, 0x42, 0x15, 0x08, 0xe3, 0x6f, 0x60, 0xb6, 0x6f, 0xa8, 0x29, 0x2d, 0x3c, 0x74, 0x93, 0x27, 0xfa, 0x36, 0x77, 0x21, 0x5c, 0xfa, 0xb1, 0xfe, 0x4a, 0x73, 0x05, 0xde, 0x7d,
|
||||
/* (2^ 42)P */ 0xab, 0x2b, 0xd4, 0x06, 0x39, 0x0e, 0xf1, 0x3b, 0x9c, 0x64, 0x80, 0x19, 0x3e, 0x80, 0xf7, 0xe4, 0x7a, 0xbf, 0x95, 0x95, 0xf8, 0x3b, 0x05, 0xe6, 0x30, 0x55, 0x24, 0xda, 0x38, 0xaf, 0x4f, 0x39,
|
||||
/* (2^ 43)P */ 0xf4, 0x28, 0x69, 0x89, 0x58, 0xfb, 0x8e, 0x7a, 0x3c, 0x11, 0x6a, 0xcc, 0xe9, 0x78, 0xc7, 0xfb, 0x6f, 0x59, 0xaf, 0x30, 0xe3, 0x0c, 0x67, 0x72, 0xf7, 0x6c, 0x3d, 0x1d, 0xa8, 0x22, 0xf2, 0x48,
|
||||
/* (2^ 44)P */ 0xa7, 0xca, 0x72, 0x0d, 0x41, 0xce, 0x1f, 0xf0, 0x95, 0x55, 0x3b, 0x21, 0xc7, 0xec, 0x20, 0x5a, 0x83, 0x14, 0xfa, 0xc1, 0x65, 0x11, 0xc2, 0x7b, 0x41, 0xa7, 0xa8, 0x1d, 0xe3, 0x9a, 0xf8, 0x07,
|
||||
/* (2^ 45)P */ 0xf9, 0x0f, 0x83, 0xc6, 0xb4, 0xc2, 0xd2, 0x05, 0x93, 0x62, 0x31, 0xc6, 0x0f, 0x33, 0x3e, 0xd4, 0x04, 0xa9, 0xd3, 0x96, 0x0a, 0x59, 0xa5, 0xa5, 0xb6, 0x33, 0x53, 0xa6, 0x91, 0xdb, 0x5e, 0x70,
|
||||
/* (2^ 46)P */ 0xf7, 0xa5, 0xb9, 0x0b, 0x5e, 0xe1, 0x8e, 0x04, 0x5d, 0xaf, 0x0a, 0x9e, 0xca, 0xcf, 0x40, 0x32, 0x0b, 0xa4, 0xc4, 0xed, 0xce, 0x71, 0x4b, 0x8f, 0x6d, 0x4a, 0x54, 0xde, 0xa3, 0x0d, 0x1c, 0x62,
|
||||
/* (2^ 47)P */ 0x91, 0x40, 0x8c, 0xa0, 0x36, 0x28, 0x87, 0x92, 0x45, 0x14, 0xc9, 0x10, 0xb0, 0x75, 0x83, 0xce, 0x94, 0x63, 0x27, 0x4f, 0x52, 0xeb, 0x72, 0x8a, 0x35, 0x36, 0xc8, 0x7e, 0xfa, 0xfc, 0x67, 0x26,
|
||||
/* (2^ 48)P */ 0x2a, 0x75, 0xe8, 0x45, 0x33, 0x17, 0x4c, 0x7f, 0xa5, 0x79, 0x70, 0xee, 0xfe, 0x47, 0x1b, 0x06, 0x34, 0xff, 0x86, 0x9f, 0xfa, 0x9a, 0xdd, 0x25, 0x9c, 0xc8, 0x5d, 0x42, 0xf5, 0xce, 0x80, 0x37,
|
||||
/* (2^ 49)P */ 0xe9, 0xb4, 0x3b, 0x51, 0x5a, 0x03, 0x46, 0x1a, 0xda, 0x5a, 0x57, 0xac, 0x79, 0xf3, 0x1e, 0x3e, 0x50, 0x4b, 0xa2, 0x5f, 0x1c, 0x5f, 0x8c, 0xc7, 0x22, 0x9f, 0xfd, 0x34, 0x76, 0x96, 0x1a, 0x32,
|
||||
/* (2^ 50)P */ 0xfa, 0x27, 0x6e, 0x82, 0xb8, 0x07, 0x67, 0x94, 0xd0, 0x6f, 0x50, 0x4c, 0xd6, 0x84, 0xca, 0x3d, 0x36, 0x14, 0xe9, 0x75, 0x80, 0x21, 0x89, 0xc1, 0x84, 0x84, 0x3b, 0x9b, 0x16, 0x84, 0x92, 0x6d,
|
||||
/* (2^ 51)P */ 0xdf, 0x2d, 0x3f, 0x38, 0x40, 0xe8, 0x67, 0x3a, 0x75, 0x9b, 0x4f, 0x0c, 0xa3, 0xc9, 0xee, 0x33, 0x47, 0xef, 0x83, 0xa7, 0x6f, 0xc8, 0xc7, 0x3e, 0xc4, 0xfb, 0xc9, 0xba, 0x9f, 0x44, 0xec, 0x26,
|
||||
/* (2^ 52)P */ 0x7d, 0x9e, 0x9b, 0xa0, 0xcb, 0x38, 0x0f, 0x5c, 0x8c, 0x47, 0xa3, 0x62, 0xc7, 0x8c, 0x16, 0x81, 0x1c, 0x12, 0xfc, 0x06, 0xd3, 0xb0, 0x23, 0x3e, 0xdd, 0xdc, 0xef, 0xa5, 0xa0, 0x8a, 0x23, 0x5a,
|
||||
/* (2^ 53)P */ 0xff, 0x43, 0xea, 0xc4, 0x21, 0x61, 0xa2, 0x1b, 0xb5, 0x32, 0x88, 0x7c, 0x7f, 0xc7, 0xf8, 0x36, 0x9a, 0xf9, 0xdc, 0x0a, 0x0b, 0xea, 0xfb, 0x88, 0xf9, 0xeb, 0x5b, 0xc2, 0x8e, 0x93, 0xa9, 0x5c,
|
||||
/* (2^ 54)P */ 0xa0, 0xcd, 0xfc, 0x51, 0x5e, 0x6a, 0x43, 0xd5, 0x3b, 0x89, 0xcd, 0xc2, 0x97, 0x47, 0xbc, 0x1d, 0x08, 0x4a, 0x22, 0xd3, 0x65, 0x6a, 0x34, 0x19, 0x66, 0xf4, 0x9a, 0x9b, 0xe4, 0x34, 0x50, 0x0f,
|
||||
/* (2^ 55)P */ 0x6e, 0xb9, 0xe0, 0xa1, 0x67, 0x39, 0x3c, 0xf2, 0x88, 0x4d, 0x7a, 0x86, 0xfa, 0x08, 0x8b, 0xe5, 0x79, 0x16, 0x34, 0xa7, 0xc6, 0xab, 0x2f, 0xfb, 0x46, 0x69, 0x02, 0xb6, 0x1e, 0x38, 0x75, 0x2a,
|
||||
/* (2^ 56)P */ 0xac, 0x20, 0x94, 0xc1, 0xe4, 0x3b, 0x0a, 0xc8, 0xdc, 0xb6, 0xf2, 0x81, 0xc6, 0xf6, 0xb1, 0x66, 0x88, 0x33, 0xe9, 0x61, 0x67, 0x03, 0xf7, 0x7c, 0xc4, 0xa4, 0x60, 0xa6, 0xd8, 0xbb, 0xab, 0x25,
|
||||
/* (2^ 57)P */ 0x98, 0x51, 0xfd, 0x14, 0xba, 0x12, 0xea, 0x91, 0xa9, 0xff, 0x3c, 0x4a, 0xfc, 0x50, 0x49, 0x68, 0x28, 0xad, 0xf5, 0x30, 0x21, 0x84, 0x26, 0xf8, 0x41, 0xa4, 0x01, 0x53, 0xf7, 0x88, 0xa9, 0x3e,
|
||||
/* (2^ 58)P */ 0x6f, 0x8c, 0x5f, 0x69, 0x9a, 0x10, 0x78, 0xc9, 0xf3, 0xc3, 0x30, 0x05, 0x4a, 0xeb, 0x46, 0x17, 0x95, 0x99, 0x45, 0xb4, 0x77, 0x6d, 0x4d, 0x44, 0xc7, 0x5c, 0x4e, 0x05, 0x8c, 0x2b, 0x95, 0x75,
|
||||
/* (2^ 59)P */ 0xaa, 0xd6, 0xf4, 0x15, 0x79, 0x3f, 0x70, 0xa3, 0xd8, 0x47, 0x26, 0x2f, 0x20, 0x46, 0xc3, 0x66, 0x4b, 0x64, 0x1d, 0x81, 0xdf, 0x69, 0x14, 0xd0, 0x1f, 0xd7, 0xa5, 0x81, 0x7d, 0xa4, 0xfe, 0x77,
|
||||
/* (2^ 60)P */ 0x81, 0xa3, 0x7c, 0xf5, 0x9e, 0x52, 0xe9, 0xc5, 0x1a, 0x88, 0x2f, 0xce, 0xb9, 0xb4, 0xee, 0x6e, 0xd6, 0x9b, 0x00, 0xe8, 0x28, 0x1a, 0xe9, 0xb6, 0xec, 0x3f, 0xfc, 0x9a, 0x3e, 0xbe, 0x80, 0x4b,
|
||||
/* (2^ 61)P */ 0xc5, 0xd2, 0xae, 0x26, 0xc5, 0x73, 0x37, 0x7e, 0x9d, 0xa4, 0xc9, 0x53, 0xb4, 0xfc, 0x4a, 0x1b, 0x4d, 0xb2, 0xff, 0xba, 0xd7, 0xbd, 0x20, 0xa9, 0x0e, 0x40, 0x2d, 0x12, 0x9f, 0x69, 0x54, 0x7c,
|
||||
/* (2^ 62)P */ 0xc8, 0x4b, 0xa9, 0x4f, 0xe1, 0xc8, 0x46, 0xef, 0x5e, 0xed, 0x52, 0x29, 0xce, 0x74, 0xb0, 0xe0, 0xd5, 0x85, 0xd8, 0xdb, 0xe1, 0x50, 0xa4, 0xbe, 0x2c, 0x71, 0x0f, 0x32, 0x49, 0x86, 0xb6, 0x61,
|
||||
/* (2^ 63)P */ 0xd1, 0xbd, 0xcc, 0x09, 0x73, 0x5f, 0x48, 0x8a, 0x2d, 0x1a, 0x4d, 0x7d, 0x0d, 0x32, 0x06, 0xbd, 0xf4, 0xbe, 0x2d, 0x32, 0x73, 0x29, 0x23, 0x25, 0x70, 0xf7, 0x17, 0x8c, 0x75, 0xc4, 0x5d, 0x44,
|
||||
/* (2^ 64)P */ 0x3c, 0x93, 0xc8, 0x7c, 0x17, 0x34, 0x04, 0xdb, 0x9f, 0x05, 0xea, 0x75, 0x21, 0xe8, 0x6f, 0xed, 0x34, 0xdb, 0x53, 0xc0, 0xfd, 0xbe, 0xfe, 0x1e, 0x99, 0xaf, 0x5d, 0xc6, 0x67, 0xe8, 0xdb, 0x4a,
|
||||
/* (2^ 65)P */ 0xdf, 0x09, 0x06, 0xa9, 0xa2, 0x71, 0xcd, 0x3a, 0x50, 0x40, 0xd0, 0x6d, 0x85, 0x91, 0xe9, 0xe5, 0x3c, 0xc2, 0x57, 0x81, 0x68, 0x9b, 0xc6, 0x1e, 0x4d, 0xfe, 0x5c, 0x88, 0xf6, 0x27, 0x74, 0x69,
|
||||
/* (2^ 66)P */ 0x51, 0xa8, 0xe1, 0x65, 0x9b, 0x7b, 0xbe, 0xd7, 0xdd, 0x36, 0xc5, 0x22, 0xd5, 0x28, 0x3d, 0xa0, 0x45, 0xb6, 0xd2, 0x8f, 0x65, 0x9d, 0x39, 0x28, 0xe1, 0x41, 0x26, 0x7c, 0xe1, 0xb7, 0xe5, 0x49,
|
||||
/* (2^ 67)P */ 0xa4, 0x57, 0x04, 0x70, 0x98, 0x3a, 0x8c, 0x6f, 0x78, 0x67, 0xbb, 0x5e, 0xa2, 0xf0, 0x78, 0x50, 0x0f, 0x96, 0x82, 0xc3, 0xcb, 0x3c, 0x3c, 0xd1, 0xb1, 0x84, 0xdf, 0xa7, 0x58, 0x32, 0x00, 0x2e,
|
||||
/* (2^ 68)P */ 0x1c, 0x6a, 0x29, 0xe6, 0x9b, 0xf3, 0xd1, 0x8a, 0xb2, 0xbf, 0x5f, 0x2a, 0x65, 0xaa, 0xee, 0xc1, 0xcb, 0xf3, 0x26, 0xfd, 0x73, 0x06, 0xee, 0x33, 0xcc, 0x2c, 0x9d, 0xa6, 0x73, 0x61, 0x25, 0x59,
|
||||
/* (2^ 69)P */ 0x41, 0xfc, 0x18, 0x4e, 0xaa, 0x07, 0xea, 0x41, 0x1e, 0xa5, 0x87, 0x7c, 0x52, 0x19, 0xfc, 0xd9, 0x6f, 0xca, 0x31, 0x58, 0x80, 0xcb, 0xaa, 0xbd, 0x4f, 0x69, 0x16, 0xc9, 0x2d, 0x65, 0x5b, 0x44,
|
||||
/* (2^ 70)P */ 0x15, 0x23, 0x17, 0xf2, 0xa7, 0xa3, 0x92, 0xce, 0x64, 0x99, 0x1b, 0xe1, 0x2d, 0x28, 0xdc, 0x1e, 0x4a, 0x31, 0x4c, 0xe0, 0xaf, 0x3a, 0x82, 0xa1, 0x86, 0xf5, 0x7c, 0x43, 0x94, 0x2d, 0x0a, 0x79,
|
||||
/* (2^ 71)P */ 0x09, 0xe0, 0xf6, 0x93, 0xfb, 0x47, 0xc4, 0x71, 0x76, 0x52, 0x84, 0x22, 0x67, 0xa5, 0x22, 0x89, 0x69, 0x51, 0x4f, 0x20, 0x3b, 0x90, 0x70, 0xbf, 0xfe, 0x19, 0xa3, 0x1b, 0x89, 0x89, 0x7a, 0x2f,
|
||||
/* (2^ 72)P */ 0x0c, 0x14, 0xe2, 0x77, 0xb5, 0x8e, 0xa0, 0x02, 0xf4, 0xdc, 0x7b, 0x42, 0xd4, 0x4e, 0x9a, 0xed, 0xd1, 0x3c, 0x32, 0xe4, 0x44, 0xec, 0x53, 0x52, 0x5b, 0x35, 0xe9, 0x14, 0x3c, 0x36, 0x88, 0x3e,
|
||||
/* (2^ 73)P */ 0x8c, 0x0b, 0x11, 0x77, 0x42, 0xc1, 0x66, 0xaa, 0x90, 0x33, 0xa2, 0x10, 0x16, 0x39, 0xe0, 0x1a, 0xa2, 0xc2, 0x3f, 0xc9, 0x12, 0xbd, 0x30, 0x20, 0xab, 0xc7, 0x55, 0x95, 0x57, 0x41, 0xe1, 0x3e,
|
||||
/* (2^ 74)P */ 0x41, 0x7d, 0x6e, 0x6d, 0x3a, 0xde, 0x14, 0x92, 0xfe, 0x7e, 0xf1, 0x07, 0x86, 0xd8, 0xcd, 0x3c, 0x17, 0x12, 0xe1, 0xf8, 0x88, 0x12, 0x4f, 0x67, 0xd0, 0x93, 0x9f, 0x32, 0x0f, 0x25, 0x82, 0x56,
|
||||
/* (2^ 75)P */ 0x6e, 0x39, 0x2e, 0x6d, 0x13, 0x0b, 0xf0, 0x6c, 0xbf, 0xde, 0x14, 0x10, 0x6f, 0xf8, 0x4c, 0x6e, 0x83, 0x4e, 0xcc, 0xbf, 0xb5, 0xb1, 0x30, 0x59, 0xb6, 0x16, 0xba, 0x8a, 0xb4, 0x69, 0x70, 0x04,
|
||||
/* (2^ 76)P */ 0x93, 0x07, 0xb2, 0x69, 0xab, 0xe4, 0x4c, 0x0d, 0x9e, 0xfb, 0xd0, 0x97, 0x1a, 0xb9, 0x4d, 0xb2, 0x1d, 0xd0, 0x00, 0x4e, 0xf5, 0x50, 0xfa, 0xcd, 0xb5, 0xdd, 0x8b, 0x36, 0x85, 0x10, 0x1b, 0x22,
|
||||
/* (2^ 77)P */ 0xd2, 0xd8, 0xe3, 0xb1, 0x68, 0x94, 0xe5, 0xe7, 0x93, 0x2f, 0x12, 0xbd, 0x63, 0x65, 0xc5, 0x53, 0x09, 0x3f, 0x66, 0xe0, 0x03, 0xa9, 0xe8, 0xee, 0x42, 0x3d, 0xbe, 0xcb, 0x62, 0xa6, 0xef, 0x61,
|
||||
/* (2^ 78)P */ 0x2a, 0xab, 0x6e, 0xde, 0xdd, 0xdd, 0xf8, 0x2c, 0x31, 0xf2, 0x35, 0x14, 0xd5, 0x0a, 0xf8, 0x9b, 0x73, 0x49, 0xf0, 0xc9, 0xce, 0xda, 0xea, 0x5d, 0x27, 0x9b, 0xd2, 0x41, 0x5d, 0x5b, 0x27, 0x29,
|
||||
/* (2^ 79)P */ 0x4f, 0xf1, 0xeb, 0x95, 0x08, 0x0f, 0xde, 0xcf, 0xa7, 0x05, 0x49, 0x05, 0x6b, 0xb9, 0xaa, 0xb9, 0xfd, 0x20, 0xc4, 0xa1, 0xd9, 0x0d, 0xe8, 0xca, 0xc7, 0xbb, 0x73, 0x16, 0x2f, 0xbf, 0x63, 0x0a,
|
||||
/* (2^ 80)P */ 0x8c, 0xbc, 0x8f, 0x95, 0x11, 0x6e, 0x2f, 0x09, 0xad, 0x2f, 0x82, 0x04, 0xe8, 0x81, 0x2a, 0x67, 0x17, 0x25, 0xd5, 0x60, 0x15, 0x35, 0xc8, 0xca, 0xf8, 0x92, 0xf1, 0xc8, 0x22, 0x77, 0x3f, 0x6f,
|
||||
/* (2^ 81)P */ 0xb7, 0x94, 0xe8, 0xc2, 0xcc, 0x90, 0xba, 0xf8, 0x0d, 0x9f, 0xff, 0x38, 0xa4, 0x57, 0x75, 0x2c, 0x59, 0x23, 0xe5, 0x5a, 0x85, 0x1d, 0x4d, 0x89, 0x69, 0x3d, 0x74, 0x7b, 0x15, 0x22, 0xe1, 0x68,
|
||||
/* (2^ 82)P */ 0xf3, 0x19, 0xb9, 0xcf, 0x70, 0x55, 0x7e, 0xd8, 0xb9, 0x8d, 0x79, 0x95, 0xcd, 0xde, 0x2c, 0x3f, 0xce, 0xa2, 0xc0, 0x10, 0x47, 0x15, 0x21, 0x21, 0xb2, 0xc5, 0x6d, 0x24, 0x15, 0xa1, 0x66, 0x3c,
|
||||
/* (2^ 83)P */ 0x72, 0xcb, 0x4e, 0x29, 0x62, 0xc5, 0xed, 0xcb, 0x16, 0x0b, 0x28, 0x6a, 0xc3, 0x43, 0x71, 0xba, 0x67, 0x8b, 0x07, 0xd4, 0xef, 0xc2, 0x10, 0x96, 0x1e, 0x4b, 0x6a, 0x94, 0x5d, 0x73, 0x44, 0x61,
|
||||
/* (2^ 84)P */ 0x50, 0x33, 0x5b, 0xd7, 0x1e, 0x11, 0x6f, 0x53, 0x1b, 0xd8, 0x41, 0x20, 0x8c, 0xdb, 0x11, 0x02, 0x3c, 0x41, 0x10, 0x0e, 0x00, 0xb1, 0x3c, 0xf9, 0x76, 0x88, 0x9e, 0x03, 0x3c, 0xfd, 0x9d, 0x14,
|
||||
/* (2^ 85)P */ 0x5b, 0x15, 0x63, 0x6b, 0xe4, 0xdd, 0x79, 0xd4, 0x76, 0x79, 0x83, 0x3c, 0xe9, 0x15, 0x6e, 0xb6, 0x38, 0xe0, 0x13, 0x1f, 0x3b, 0xe4, 0xfd, 0xda, 0x35, 0x0b, 0x4b, 0x2e, 0x1a, 0xda, 0xaf, 0x5f,
|
||||
/* (2^ 86)P */ 0x81, 0x75, 0x19, 0x17, 0xdf, 0xbb, 0x00, 0x36, 0xc2, 0xd2, 0x3c, 0xbe, 0x0b, 0x05, 0x72, 0x39, 0x86, 0xbe, 0xd5, 0xbd, 0x6d, 0x90, 0x38, 0x59, 0x0f, 0x86, 0x9b, 0x3f, 0xe4, 0xe5, 0xfc, 0x34,
|
||||
/* (2^ 87)P */ 0x02, 0x4d, 0xd1, 0x42, 0xcd, 0xa4, 0xa8, 0x75, 0x65, 0xdf, 0x41, 0x34, 0xc5, 0xab, 0x8d, 0x82, 0xd3, 0x31, 0xe1, 0xd2, 0xed, 0xab, 0xdc, 0x33, 0x5f, 0xd2, 0x14, 0xb8, 0x6f, 0xd7, 0xba, 0x3e,
|
||||
/* (2^ 88)P */ 0x0f, 0xe1, 0x70, 0x6f, 0x56, 0x6f, 0x90, 0xd4, 0x5a, 0x0f, 0x69, 0x51, 0xaa, 0xf7, 0x12, 0x5d, 0xf2, 0xfc, 0xce, 0x76, 0x6e, 0xb1, 0xad, 0x45, 0x99, 0x29, 0x23, 0xad, 0xae, 0x68, 0xf7, 0x01,
|
||||
/* (2^ 89)P */ 0xbd, 0xfe, 0x48, 0x62, 0x7b, 0xc7, 0x6c, 0x2b, 0xfd, 0xaf, 0x3a, 0xec, 0x28, 0x06, 0xd3, 0x3c, 0x6a, 0x48, 0xef, 0xd4, 0x80, 0x0b, 0x1c, 0xce, 0x23, 0x6c, 0xf6, 0xa6, 0x2e, 0xff, 0x3b, 0x4c,
|
||||
/* (2^ 90)P */ 0x5f, 0xeb, 0xea, 0x4a, 0x09, 0xc4, 0x2e, 0x3f, 0xa7, 0x2c, 0x37, 0x6e, 0x28, 0x9b, 0xb1, 0x61, 0x1d, 0x70, 0x2a, 0xde, 0x66, 0xa9, 0xef, 0x5e, 0xef, 0xe3, 0x55, 0xde, 0x65, 0x05, 0xb2, 0x23,
|
||||
/* (2^ 91)P */ 0x57, 0x85, 0xd5, 0x79, 0x52, 0xca, 0x01, 0xe3, 0x4f, 0x87, 0xc2, 0x27, 0xce, 0xd4, 0xb2, 0x07, 0x67, 0x1d, 0xcf, 0x9d, 0x8a, 0xcd, 0x32, 0xa5, 0x56, 0xff, 0x2b, 0x3f, 0xe2, 0xfe, 0x52, 0x2a,
|
||||
/* (2^ 92)P */ 0x3d, 0x66, 0xd8, 0x7c, 0xb3, 0xef, 0x24, 0x86, 0x94, 0x75, 0xbd, 0xff, 0x20, 0xac, 0xc7, 0xbb, 0x45, 0x74, 0xd3, 0x82, 0x9c, 0x5e, 0xb8, 0x57, 0x66, 0xec, 0xa6, 0x86, 0xcb, 0x52, 0x30, 0x7b,
|
||||
/* (2^ 93)P */ 0x1e, 0xe9, 0x25, 0x25, 0xad, 0xf0, 0x82, 0x34, 0xa0, 0xdc, 0x8e, 0xd2, 0x43, 0x80, 0xb6, 0x2c, 0x3a, 0x00, 0x1b, 0x2e, 0x05, 0x6d, 0x4f, 0xaf, 0x0a, 0x1b, 0x78, 0x29, 0x25, 0x8c, 0x5f, 0x18,
|
||||
/* (2^ 94)P */ 0xd6, 0xe0, 0x0c, 0xd8, 0x5b, 0xde, 0x41, 0xaa, 0xd6, 0xe9, 0x53, 0x68, 0x41, 0xb2, 0x07, 0x94, 0x3a, 0x4c, 0x7f, 0x35, 0x6e, 0xc3, 0x3e, 0x56, 0xce, 0x7b, 0x29, 0x0e, 0xdd, 0xb8, 0xc4, 0x4c,
|
||||
/* (2^ 95)P */ 0x0e, 0x73, 0xb8, 0xff, 0x52, 0x1a, 0xfc, 0xa2, 0x37, 0x8e, 0x05, 0x67, 0x6e, 0xf1, 0x11, 0x18, 0xe1, 0x4e, 0xdf, 0xcd, 0x66, 0xa3, 0xf9, 0x10, 0x99, 0xf0, 0xb9, 0xa0, 0xc4, 0xa0, 0xf4, 0x72,
|
||||
/* (2^ 96)P */ 0xa7, 0x4e, 0x3f, 0x66, 0x6f, 0xc0, 0x16, 0x8c, 0xba, 0x0f, 0x97, 0x4e, 0xf7, 0x3a, 0x3b, 0x69, 0x45, 0xc3, 0x9e, 0xd6, 0xf1, 0xe7, 0x02, 0x21, 0x89, 0x80, 0x8a, 0x96, 0xbc, 0x3c, 0xa5, 0x0b,
|
||||
/* (2^ 97)P */ 0x37, 0x55, 0xa1, 0xfe, 0xc7, 0x9d, 0x3d, 0xca, 0x93, 0x64, 0x53, 0x51, 0xbb, 0x24, 0x68, 0x4c, 0xb1, 0x06, 0x40, 0x84, 0x14, 0x63, 0x88, 0xb9, 0x60, 0xcc, 0x54, 0xb4, 0x2a, 0xa7, 0xd2, 0x40,
|
||||
/* (2^ 98)P */ 0x75, 0x09, 0x57, 0x12, 0xb7, 0xa1, 0x36, 0x59, 0x57, 0xa6, 0xbd, 0xde, 0x48, 0xd6, 0xb9, 0x91, 0xea, 0x30, 0x43, 0xb6, 0x4b, 0x09, 0x44, 0x33, 0xd0, 0x51, 0xee, 0x12, 0x0d, 0xa1, 0x6b, 0x00,
|
||||
/* (2^ 99)P */ 0x58, 0x5d, 0xde, 0xf5, 0x68, 0x84, 0x22, 0x19, 0xb0, 0x05, 0xcc, 0x38, 0x4c, 0x2f, 0xb1, 0x0e, 0x90, 0x19, 0x60, 0xd5, 0x9d, 0x9f, 0x03, 0xa1, 0x0b, 0x0e, 0xff, 0x4f, 0xce, 0xd4, 0x02, 0x45,
|
||||
/* (2^100)P */ 0x89, 0xc1, 0x37, 0x68, 0x10, 0x54, 0x20, 0xeb, 0x3c, 0xb9, 0xd3, 0x6d, 0x4c, 0x54, 0xf6, 0xd0, 0x4f, 0xd7, 0x16, 0xc4, 0x64, 0x70, 0x72, 0x40, 0xf0, 0x2e, 0x50, 0x4b, 0x11, 0xc6, 0x15, 0x6e,
|
||||
/* (2^101)P */ 0x6b, 0xa7, 0xb1, 0xcf, 0x98, 0xa3, 0xf2, 0x4d, 0xb1, 0xf6, 0xf2, 0x19, 0x74, 0x6c, 0x25, 0x11, 0x43, 0x60, 0x6e, 0x06, 0x62, 0x79, 0x49, 0x4a, 0x44, 0x5b, 0x35, 0x41, 0xab, 0x3a, 0x5b, 0x70,
|
||||
/* (2^102)P */ 0xd8, 0xb1, 0x97, 0xd7, 0x36, 0xf5, 0x5e, 0x36, 0xdb, 0xf0, 0xdd, 0x22, 0xd6, 0x6b, 0x07, 0x00, 0x88, 0x5a, 0x57, 0xe0, 0xb0, 0x33, 0xbf, 0x3b, 0x4d, 0xca, 0xe4, 0xc8, 0x05, 0xaa, 0x77, 0x37,
|
||||
/* (2^103)P */ 0x5f, 0xdb, 0x78, 0x55, 0xc8, 0x45, 0x27, 0x39, 0xe2, 0x5a, 0xae, 0xdb, 0x49, 0x41, 0xda, 0x6f, 0x67, 0x98, 0xdc, 0x8a, 0x0b, 0xb0, 0xf0, 0xb1, 0xa3, 0x1d, 0x6f, 0xd3, 0x37, 0x34, 0x96, 0x09,
|
||||
/* (2^104)P */ 0x53, 0x38, 0xdc, 0xa5, 0x90, 0x4e, 0x82, 0x7e, 0xbd, 0x5c, 0x13, 0x1f, 0x64, 0xf6, 0xb5, 0xcc, 0xcc, 0x8f, 0xce, 0x87, 0x6c, 0xd8, 0x36, 0x67, 0x9f, 0x24, 0x04, 0x66, 0xe2, 0x3c, 0x5f, 0x62,
|
||||
/* (2^105)P */ 0x3f, 0xf6, 0x02, 0x95, 0x05, 0xc8, 0x8a, 0xaf, 0x69, 0x14, 0x35, 0x2e, 0x0a, 0xe7, 0x05, 0x0c, 0x05, 0x63, 0x4b, 0x76, 0x9c, 0x2e, 0x29, 0x35, 0xc3, 0x3a, 0xe2, 0xc7, 0x60, 0x43, 0x39, 0x1a,
|
||||
/* (2^106)P */ 0x64, 0x32, 0x18, 0x51, 0x32, 0xd5, 0xc6, 0xd5, 0x4f, 0xb7, 0xc2, 0x43, 0xbd, 0x5a, 0x06, 0x62, 0x9b, 0x3f, 0x97, 0x3b, 0xd0, 0xf5, 0xfb, 0xb5, 0x5e, 0x6e, 0x20, 0x61, 0x36, 0xda, 0xa3, 0x13,
|
||||
/* (2^107)P */ 0xe5, 0x94, 0x5d, 0x72, 0x37, 0x58, 0xbd, 0xc6, 0xc5, 0x16, 0x50, 0x20, 0x12, 0x09, 0xe3, 0x18, 0x68, 0x3c, 0x03, 0x70, 0x15, 0xce, 0x88, 0x20, 0x87, 0x79, 0x83, 0x5c, 0x49, 0x1f, 0xba, 0x7f,
|
||||
/* (2^108)P */ 0x9d, 0x07, 0xf9, 0xf2, 0x23, 0x74, 0x8c, 0x5a, 0xc5, 0x3f, 0x02, 0x34, 0x7b, 0x15, 0x35, 0x17, 0x51, 0xb3, 0xfa, 0xd2, 0x9a, 0xb4, 0xf9, 0xe4, 0x3c, 0xe3, 0x78, 0xc8, 0x72, 0xff, 0x91, 0x66,
|
||||
/* (2^109)P */ 0x3e, 0xff, 0x5e, 0xdc, 0xde, 0x2a, 0x2c, 0x12, 0xf4, 0x6c, 0x95, 0xd8, 0xf1, 0x4b, 0xdd, 0xf8, 0xda, 0x5b, 0x9e, 0x9e, 0x5d, 0x20, 0x86, 0xeb, 0x43, 0xc7, 0x75, 0xd9, 0xb9, 0x92, 0x9b, 0x04,
|
||||
/* (2^110)P */ 0x5a, 0xc0, 0xf6, 0xb0, 0x30, 0x97, 0x37, 0xa5, 0x53, 0xa5, 0xf3, 0xc6, 0xac, 0xff, 0xa0, 0x72, 0x6d, 0xcd, 0x0d, 0xb2, 0x34, 0x2c, 0x03, 0xb0, 0x4a, 0x16, 0xd5, 0x88, 0xbc, 0x9d, 0x0e, 0x47,
|
||||
/* (2^111)P */ 0x47, 0xc0, 0x37, 0xa2, 0x0c, 0xf1, 0x9c, 0xb1, 0xa2, 0x81, 0x6c, 0x1f, 0x71, 0x66, 0x54, 0xb6, 0x43, 0x0b, 0xd8, 0x6d, 0xd1, 0x1b, 0x32, 0xb3, 0x8e, 0xbe, 0x5f, 0x0c, 0x60, 0x4f, 0xc1, 0x48,
|
||||
/* (2^112)P */ 0x03, 0xc8, 0xa6, 0x4a, 0x26, 0x1c, 0x45, 0x66, 0xa6, 0x7d, 0xfa, 0xa4, 0x04, 0x39, 0x6e, 0xb6, 0x95, 0x83, 0x12, 0xb3, 0xb0, 0x19, 0x5f, 0xd4, 0x10, 0xbc, 0xc9, 0xc3, 0x27, 0x26, 0x60, 0x31,
|
||||
/* (2^113)P */ 0x0d, 0xe1, 0xe4, 0x32, 0x48, 0xdc, 0x20, 0x31, 0xf7, 0x17, 0xc7, 0x56, 0x67, 0xc4, 0x20, 0xeb, 0x94, 0x02, 0x28, 0x67, 0x3f, 0x2e, 0xf5, 0x00, 0x09, 0xc5, 0x30, 0x47, 0xc1, 0x4f, 0x6d, 0x56,
|
||||
/* (2^114)P */ 0x06, 0x72, 0x83, 0xfd, 0x40, 0x5d, 0x3a, 0x7e, 0x7a, 0x54, 0x59, 0x71, 0xdc, 0x26, 0xe9, 0xc1, 0x95, 0x60, 0x8d, 0xa6, 0xfb, 0x30, 0x67, 0x21, 0xa7, 0xce, 0x69, 0x3f, 0x84, 0xc3, 0xe8, 0x22,
|
||||
/* (2^115)P */ 0x2b, 0x4b, 0x0e, 0x93, 0xe8, 0x74, 0xd0, 0x33, 0x16, 0x58, 0xd1, 0x84, 0x0e, 0x35, 0xe4, 0xb6, 0x65, 0x23, 0xba, 0xd6, 0x6a, 0xc2, 0x34, 0x55, 0xf3, 0xf3, 0xf1, 0x89, 0x2f, 0xc1, 0x73, 0x77,
|
||||
/* (2^116)P */ 0xaa, 0x62, 0x79, 0xa5, 0x4d, 0x40, 0xba, 0x8c, 0x56, 0xce, 0x99, 0x19, 0xa8, 0x97, 0x98, 0x5b, 0xfc, 0x92, 0x16, 0x12, 0x2f, 0x86, 0x8e, 0x50, 0x91, 0xc2, 0x93, 0xa0, 0x7f, 0x90, 0x81, 0x3a,
|
||||
/* (2^117)P */ 0x10, 0xa5, 0x25, 0x47, 0xff, 0xd0, 0xde, 0x0d, 0x03, 0xc5, 0x3f, 0x67, 0x10, 0xcc, 0xd8, 0x10, 0x89, 0x4e, 0x1f, 0x9f, 0x1c, 0x15, 0x9d, 0x5b, 0x4c, 0xa4, 0x09, 0xcb, 0xd5, 0xc1, 0xa5, 0x32,
|
||||
/* (2^118)P */ 0xfb, 0x41, 0x05, 0xb9, 0x42, 0xa4, 0x0a, 0x1e, 0xdb, 0x85, 0xb4, 0xc1, 0x7c, 0xeb, 0x85, 0x5f, 0xe5, 0xf2, 0x9d, 0x8a, 0xce, 0x95, 0xe5, 0xbe, 0x36, 0x22, 0x42, 0x22, 0xc7, 0x96, 0xe4, 0x25,
|
||||
/* (2^119)P */ 0xb9, 0xe5, 0x0f, 0xcd, 0x46, 0x3c, 0xdf, 0x5e, 0x88, 0x33, 0xa4, 0xd2, 0x7e, 0x5a, 0xe7, 0x34, 0x52, 0xe3, 0x61, 0xd7, 0x11, 0xde, 0x88, 0xe4, 0x5c, 0x54, 0x85, 0xa0, 0x01, 0x8a, 0x87, 0x0e,
|
||||
/* (2^120)P */ 0x04, 0xbb, 0x21, 0xe0, 0x77, 0x3c, 0x49, 0xba, 0x9a, 0x89, 0xdf, 0xc7, 0x43, 0x18, 0x4d, 0x2b, 0x67, 0x0d, 0xe8, 0x7a, 0x48, 0x7a, 0xa3, 0x9e, 0x94, 0x17, 0xe4, 0x11, 0x80, 0x95, 0xa9, 0x67,
|
||||
/* (2^121)P */ 0x65, 0xb0, 0x97, 0x66, 0x1a, 0x05, 0x58, 0x4b, 0xd4, 0xa6, 0x6b, 0x8d, 0x7d, 0x3f, 0xe3, 0x47, 0xc1, 0x46, 0xca, 0x83, 0xd4, 0xa8, 0x4d, 0xbb, 0x0d, 0xdb, 0xc2, 0x81, 0xa1, 0xca, 0xbe, 0x68,
|
||||
/* (2^122)P */ 0xa5, 0x9a, 0x98, 0x0b, 0xe9, 0x80, 0x89, 0x8d, 0x9b, 0xc9, 0x93, 0x2c, 0x4a, 0xb1, 0x5e, 0xf9, 0xa2, 0x73, 0x6e, 0x79, 0xc4, 0xc7, 0xc6, 0x51, 0x69, 0xb5, 0xef, 0xb5, 0x63, 0x83, 0x22, 0x6e,
|
||||
/* (2^123)P */ 0xc8, 0x24, 0xd6, 0x2d, 0xb0, 0xc0, 0xbb, 0xc6, 0xee, 0x70, 0x81, 0xec, 0x7d, 0xb4, 0x7e, 0x77, 0xa9, 0xaf, 0xcf, 0x04, 0xa0, 0x15, 0xde, 0x3c, 0x9b, 0xbf, 0x60, 0x71, 0x08, 0xbc, 0xc6, 0x1d,
|
||||
/* (2^124)P */ 0x02, 0x40, 0xc3, 0xee, 0x43, 0xe0, 0x07, 0x2e, 0x7f, 0xdc, 0x68, 0x7a, 0x67, 0xfc, 0xe9, 0x18, 0x9a, 0x5b, 0xd1, 0x8b, 0x18, 0x03, 0xda, 0xd8, 0x53, 0x82, 0x56, 0x00, 0xbb, 0xc3, 0xfb, 0x48,
|
||||
/* (2^125)P */ 0xe1, 0x4c, 0x65, 0xfb, 0x4c, 0x7d, 0x54, 0x57, 0xad, 0xe2, 0x58, 0xa0, 0x82, 0x5b, 0x56, 0xd3, 0x78, 0x44, 0x15, 0xbf, 0x0b, 0xaf, 0x3e, 0xf6, 0x18, 0xbb, 0xdf, 0x14, 0xf1, 0x1e, 0x53, 0x47,
|
||||
/* (2^126)P */ 0x87, 0xc5, 0x78, 0x42, 0x0a, 0x63, 0xec, 0xe1, 0xf3, 0x83, 0x8e, 0xca, 0x46, 0xd5, 0x07, 0x55, 0x2b, 0x0c, 0xdc, 0x3a, 0xc6, 0x35, 0xe1, 0x85, 0x4e, 0x84, 0x82, 0x56, 0xa8, 0xef, 0xa7, 0x0a,
|
||||
/* (2^127)P */ 0x15, 0xf6, 0xe1, 0xb3, 0xa8, 0x1b, 0x69, 0x72, 0xfa, 0x3f, 0xbe, 0x1f, 0x70, 0xe9, 0xb4, 0x32, 0x68, 0x78, 0xbb, 0x39, 0x2e, 0xd9, 0xb6, 0x97, 0xe8, 0x39, 0x2e, 0xa0, 0xde, 0x53, 0xfe, 0x2c,
|
||||
/* (2^128)P */ 0xb0, 0x52, 0xcd, 0x85, 0xcd, 0x92, 0x73, 0x68, 0x31, 0x98, 0xe2, 0x10, 0xc9, 0x66, 0xff, 0x27, 0x06, 0x2d, 0x83, 0xa9, 0x56, 0x45, 0x13, 0x97, 0xa0, 0xf8, 0x84, 0x0a, 0x36, 0xb0, 0x9b, 0x26,
|
||||
/* (2^129)P */ 0x5c, 0xf8, 0x43, 0x76, 0x45, 0x55, 0x6e, 0x70, 0x1b, 0x7d, 0x59, 0x9b, 0x8c, 0xa4, 0x34, 0x37, 0x72, 0xa4, 0xef, 0xc6, 0xe8, 0x91, 0xee, 0x7a, 0xe0, 0xd9, 0xa9, 0x98, 0xc1, 0xab, 0xd6, 0x5c,
|
||||
/* (2^130)P */ 0x1a, 0xe4, 0x3c, 0xcb, 0x06, 0xde, 0x04, 0x0e, 0x38, 0xe1, 0x02, 0x34, 0x89, 0xeb, 0xc6, 0xd8, 0x72, 0x37, 0x6e, 0x68, 0xbb, 0x59, 0x46, 0x90, 0xc8, 0xa8, 0x6b, 0x74, 0x71, 0xc3, 0x15, 0x72,
|
||||
/* (2^131)P */ 0xd9, 0xa2, 0xe4, 0xea, 0x7e, 0xa9, 0x12, 0xfd, 0xc5, 0xf2, 0x94, 0x63, 0x51, 0xb7, 0x14, 0x95, 0x94, 0xf2, 0x08, 0x92, 0x80, 0xd5, 0x6f, 0x26, 0xb9, 0x26, 0x9a, 0x61, 0x85, 0x70, 0x84, 0x5c,
|
||||
/* (2^132)P */ 0xea, 0x94, 0xd6, 0xfe, 0x10, 0x54, 0x98, 0x52, 0x54, 0xd2, 0x2e, 0x4a, 0x93, 0x5b, 0x90, 0x3c, 0x67, 0xe4, 0x3b, 0x2d, 0x69, 0x47, 0xbb, 0x10, 0xe1, 0xe9, 0xe5, 0x69, 0x2d, 0x3d, 0x3b, 0x06,
|
||||
/* (2^133)P */ 0xeb, 0x7d, 0xa5, 0xdd, 0xee, 0x26, 0x27, 0x47, 0x91, 0x18, 0xf4, 0x10, 0xae, 0xc4, 0xb6, 0xef, 0x14, 0x76, 0x30, 0x7b, 0x91, 0x41, 0x16, 0x2b, 0x7c, 0x5b, 0xf4, 0xc4, 0x4f, 0x55, 0x7c, 0x11,
|
||||
/* (2^134)P */ 0x12, 0x88, 0x9d, 0x8f, 0x11, 0xf3, 0x7c, 0xc0, 0x39, 0x79, 0x01, 0x50, 0x20, 0xd8, 0xdb, 0x01, 0x27, 0x28, 0x1b, 0x17, 0xf4, 0x03, 0xe8, 0xd7, 0xea, 0x25, 0xd2, 0x87, 0x74, 0xe8, 0x15, 0x10,
|
||||
/* (2^135)P */ 0x4d, 0xcc, 0x3a, 0xd2, 0xfe, 0xe3, 0x8d, 0xc5, 0x2d, 0xbe, 0xa7, 0x94, 0xc2, 0x91, 0xdb, 0x50, 0x57, 0xf4, 0x9c, 0x1c, 0x3d, 0xd4, 0x94, 0x0b, 0x4a, 0x52, 0x37, 0x6e, 0xfa, 0x40, 0x16, 0x6b,
|
||||
/* (2^136)P */ 0x09, 0x0d, 0xda, 0x5f, 0x6c, 0x34, 0x2f, 0x69, 0x51, 0x31, 0x4d, 0xfa, 0x59, 0x1c, 0x0b, 0x20, 0x96, 0xa2, 0x77, 0x07, 0x76, 0x6f, 0xc4, 0xb8, 0xcf, 0xfb, 0xfd, 0x3f, 0x5f, 0x39, 0x38, 0x4b,
|
||||
/* (2^137)P */ 0x71, 0xd6, 0x54, 0xbe, 0x00, 0x5e, 0xd2, 0x18, 0xa6, 0xab, 0xc8, 0xbe, 0x82, 0x05, 0xd5, 0x60, 0x82, 0xb9, 0x78, 0x3b, 0x26, 0x8f, 0xad, 0x87, 0x32, 0x04, 0xda, 0x9c, 0x4e, 0xf6, 0xfd, 0x50,
|
||||
/* (2^138)P */ 0xf0, 0xdc, 0x78, 0xc5, 0xaa, 0x67, 0xf5, 0x90, 0x3b, 0x13, 0xa3, 0xf2, 0x0e, 0x9b, 0x1e, 0xef, 0x71, 0xde, 0xd9, 0x42, 0x92, 0xba, 0xeb, 0x0e, 0xc7, 0x01, 0x31, 0xf0, 0x9b, 0x3c, 0x47, 0x15,
|
||||
/* (2^139)P */ 0x95, 0x80, 0xb7, 0x56, 0xae, 0xe8, 0x77, 0x7c, 0x8e, 0x07, 0x6f, 0x6e, 0x66, 0xe7, 0x78, 0xb6, 0x1f, 0xba, 0x48, 0x53, 0x61, 0xb9, 0xa0, 0x2d, 0x0b, 0x3f, 0x73, 0xff, 0xc1, 0x31, 0xf9, 0x7c,
|
||||
/* (2^140)P */ 0x6c, 0x36, 0x0a, 0x0a, 0xf5, 0x57, 0xb3, 0x26, 0x32, 0xd7, 0x87, 0x2b, 0xf4, 0x8c, 0x70, 0xe9, 0xc0, 0xb2, 0x1c, 0xf9, 0xa5, 0xee, 0x3a, 0xc1, 0x4c, 0xbb, 0x43, 0x11, 0x99, 0x0c, 0xd9, 0x35,
|
||||
/* (2^141)P */ 0xdc, 0xd9, 0xa0, 0xa9, 0x04, 0xc4, 0xc1, 0x47, 0x51, 0xd2, 0x72, 0x19, 0x45, 0x58, 0x9e, 0x65, 0x31, 0x8c, 0xb3, 0x73, 0xc4, 0xa8, 0x75, 0x38, 0x24, 0x1f, 0x56, 0x79, 0xd3, 0x9e, 0xbd, 0x1f,
|
||||
/* (2^142)P */ 0x8d, 0xc2, 0x1e, 0xd4, 0x6f, 0xbc, 0xfa, 0x11, 0xca, 0x2d, 0x2a, 0xcd, 0xe3, 0xdf, 0xf8, 0x7e, 0x95, 0x45, 0x40, 0x8c, 0x5d, 0x3b, 0xe7, 0x72, 0x27, 0x2f, 0xb7, 0x54, 0x49, 0xfa, 0x35, 0x61,
|
||||
/* (2^143)P */ 0x9c, 0xb6, 0x24, 0xde, 0xa2, 0x32, 0xfc, 0xcc, 0x88, 0x5d, 0x09, 0x1f, 0x8c, 0x69, 0x55, 0x3f, 0x29, 0xf9, 0xc3, 0x5a, 0xed, 0x50, 0x33, 0xbe, 0xeb, 0x7e, 0x47, 0xca, 0x06, 0xf8, 0x9b, 0x5e,
|
||||
/* (2^144)P */ 0x68, 0x9f, 0x30, 0x3c, 0xb6, 0x8f, 0xce, 0xe9, 0xf4, 0xf9, 0xe1, 0x65, 0x35, 0xf6, 0x76, 0x53, 0xf1, 0x93, 0x63, 0x5a, 0xb3, 0xcf, 0xaf, 0xd1, 0x06, 0x35, 0x62, 0xe5, 0xed, 0xa1, 0x32, 0x66,
|
||||
/* (2^145)P */ 0x4c, 0xed, 0x2d, 0x0c, 0x39, 0x6c, 0x7d, 0x0b, 0x1f, 0xcb, 0x04, 0xdf, 0x81, 0x32, 0xcb, 0x56, 0xc7, 0xc3, 0xec, 0x49, 0x12, 0x5a, 0x30, 0x66, 0x2a, 0xa7, 0x8c, 0xa3, 0x60, 0x8b, 0x58, 0x5d,
|
||||
/* (2^146)P */ 0x2d, 0xf4, 0xe5, 0xe8, 0x78, 0xbf, 0xec, 0xa6, 0xec, 0x3e, 0x8a, 0x3c, 0x4b, 0xb4, 0xee, 0x86, 0x04, 0x16, 0xd2, 0xfb, 0x48, 0x9c, 0x21, 0xec, 0x31, 0x67, 0xc3, 0x17, 0xf5, 0x1a, 0xaf, 0x1a,
|
||||
/* (2^147)P */ 0xe7, 0xbd, 0x69, 0x67, 0x83, 0xa2, 0x06, 0xc3, 0xdb, 0x2a, 0x1e, 0x2b, 0x62, 0x80, 0x82, 0x20, 0xa6, 0x94, 0xff, 0xfb, 0x1f, 0xf5, 0x27, 0x80, 0x6b, 0xf2, 0x24, 0x11, 0xce, 0xa1, 0xcf, 0x76,
|
||||
/* (2^148)P */ 0xb6, 0xab, 0x22, 0x24, 0x56, 0x00, 0xeb, 0x18, 0xc3, 0x29, 0x8c, 0x8f, 0xd5, 0xc4, 0x77, 0xf3, 0x1a, 0x56, 0x31, 0xf5, 0x07, 0xc2, 0xbb, 0x4d, 0x27, 0x8a, 0x12, 0x82, 0xf0, 0xb7, 0x53, 0x02,
|
||||
/* (2^149)P */ 0xe0, 0x17, 0x2c, 0xb6, 0x1c, 0x09, 0x1f, 0x3d, 0xa9, 0x28, 0x46, 0xd6, 0xab, 0xe1, 0x60, 0x48, 0x53, 0x42, 0x9d, 0x30, 0x36, 0x74, 0xd1, 0x52, 0x76, 0xe5, 0xfa, 0x3e, 0xe1, 0x97, 0x6f, 0x35,
|
||||
/* (2^150)P */ 0x5b, 0x53, 0x50, 0xa1, 0x1a, 0xe1, 0x51, 0xd3, 0xcc, 0x78, 0xd8, 0x1d, 0xbb, 0x45, 0x6b, 0x3e, 0x98, 0x2c, 0xd9, 0xbe, 0x28, 0x61, 0x77, 0x0c, 0xb8, 0x85, 0x28, 0x03, 0x93, 0xae, 0x34, 0x1d,
|
||||
/* (2^151)P */ 0xc3, 0xa4, 0x5b, 0xa8, 0x8c, 0x48, 0xa0, 0x4b, 0xce, 0xe6, 0x9c, 0x3c, 0xc3, 0x48, 0x53, 0x98, 0x70, 0xa7, 0xbd, 0x97, 0x6f, 0x4c, 0x12, 0x66, 0x4a, 0x12, 0x54, 0x06, 0x29, 0xa0, 0x81, 0x0f,
|
||||
/* (2^152)P */ 0xfd, 0x86, 0x9b, 0x56, 0xa6, 0x9c, 0xd0, 0x9e, 0x2d, 0x9a, 0xaf, 0x18, 0xfd, 0x09, 0x10, 0x81, 0x0a, 0xc2, 0xd8, 0x93, 0x3f, 0xd0, 0x08, 0xff, 0x6b, 0xf2, 0xae, 0x9f, 0x19, 0x48, 0xa1, 0x52,
|
||||
/* (2^153)P */ 0x73, 0x1b, 0x8d, 0x2d, 0xdc, 0xf9, 0x03, 0x3e, 0x70, 0x1a, 0x96, 0x73, 0x18, 0x80, 0x05, 0x42, 0x70, 0x59, 0xa3, 0x41, 0xf0, 0x87, 0xd9, 0xc0, 0x49, 0xd5, 0xc0, 0xa1, 0x15, 0x1f, 0xaa, 0x07,
|
||||
/* (2^154)P */ 0x24, 0x72, 0xd2, 0x8c, 0xe0, 0x6c, 0xd4, 0xdf, 0x39, 0x42, 0x4e, 0x93, 0x4f, 0x02, 0x0a, 0x6d, 0x59, 0x7b, 0x89, 0x99, 0x63, 0x7a, 0x8a, 0x80, 0xa2, 0x95, 0x3d, 0xe1, 0xe9, 0x56, 0x45, 0x0a,
|
||||
/* (2^155)P */ 0x45, 0x30, 0xc1, 0xe9, 0x1f, 0x99, 0x1a, 0xd2, 0xb8, 0x51, 0x77, 0xfe, 0x48, 0x85, 0x0e, 0x9b, 0x35, 0x00, 0xf3, 0x4b, 0xcb, 0x43, 0xa6, 0x5d, 0x21, 0xf7, 0x40, 0x39, 0xd6, 0x28, 0xdb, 0x77,
|
||||
/* (2^156)P */ 0x11, 0x90, 0xdc, 0x4a, 0x61, 0xeb, 0x5e, 0xfc, 0xeb, 0x11, 0xc4, 0xe8, 0x9a, 0x41, 0x29, 0x52, 0x74, 0xcf, 0x1d, 0x7d, 0x78, 0xe7, 0xc3, 0x9e, 0xb5, 0x4c, 0x6e, 0x21, 0x3e, 0x05, 0x0d, 0x34,
|
||||
/* (2^157)P */ 0xb4, 0xf2, 0x8d, 0xb4, 0x39, 0xaf, 0xc7, 0xca, 0x94, 0x0a, 0xa1, 0x71, 0x28, 0xec, 0xfa, 0xc0, 0xed, 0x75, 0xa5, 0x5c, 0x24, 0x69, 0x0a, 0x14, 0x4c, 0x3a, 0x27, 0x34, 0x71, 0xc3, 0xf1, 0x0c,
|
||||
/* (2^158)P */ 0xa5, 0xb8, 0x24, 0xc2, 0x6a, 0x30, 0xee, 0xc8, 0xb0, 0x30, 0x49, 0xcb, 0x7c, 0xee, 0xea, 0x57, 0x4f, 0xe7, 0xcb, 0xaa, 0xbd, 0x06, 0xe8, 0xa1, 0x7d, 0x65, 0xeb, 0x2e, 0x74, 0x62, 0x9a, 0x7d,
|
||||
/* (2^159)P */ 0x30, 0x48, 0x6c, 0x54, 0xef, 0xb6, 0xb6, 0x9e, 0x2e, 0x6e, 0xb3, 0xdd, 0x1f, 0xca, 0x5c, 0x88, 0x05, 0x71, 0x0d, 0xef, 0x83, 0xf3, 0xb9, 0xe6, 0x12, 0x04, 0x2e, 0x9d, 0xef, 0x4f, 0x65, 0x58,
|
||||
/* (2^160)P */ 0x26, 0x8e, 0x0e, 0xbe, 0xff, 0xc4, 0x05, 0xa9, 0x6e, 0x81, 0x31, 0x9b, 0xdf, 0xe5, 0x2d, 0x94, 0xe1, 0x88, 0x2e, 0x80, 0x3f, 0x72, 0x7d, 0x49, 0x8d, 0x40, 0x2f, 0x60, 0xea, 0x4d, 0x68, 0x30,
|
||||
/* (2^161)P */ 0x34, 0xcb, 0xe6, 0xa3, 0x78, 0xa2, 0xe5, 0x21, 0xc4, 0x1d, 0x15, 0x5b, 0x6f, 0x6e, 0xfb, 0xae, 0x15, 0xca, 0x77, 0x9d, 0x04, 0x8e, 0x0b, 0xb3, 0x81, 0x89, 0xb9, 0x53, 0xcf, 0xc9, 0xc3, 0x28,
|
||||
/* (2^162)P */ 0x2a, 0xdd, 0x6c, 0x55, 0x21, 0xb7, 0x7f, 0x28, 0x74, 0x22, 0x02, 0x97, 0xa8, 0x7c, 0x31, 0x0d, 0x58, 0x32, 0x54, 0x3a, 0x42, 0xc7, 0x68, 0x74, 0x2f, 0x64, 0xb5, 0x4e, 0x46, 0x11, 0x7f, 0x4a,
|
||||
/* (2^163)P */ 0xa6, 0x3a, 0x19, 0x4d, 0x77, 0xa4, 0x37, 0xa2, 0xa1, 0x29, 0x21, 0xa9, 0x6e, 0x98, 0x65, 0xd8, 0x88, 0x1a, 0x7c, 0xf8, 0xec, 0x15, 0xc5, 0x24, 0xeb, 0xf5, 0x39, 0x5f, 0x57, 0x03, 0x40, 0x60,
|
||||
/* (2^164)P */ 0x27, 0x9b, 0x0a, 0x57, 0x89, 0xf1, 0xb9, 0x47, 0x78, 0x4b, 0x5e, 0x46, 0xde, 0xce, 0x98, 0x2b, 0x20, 0x5c, 0xb8, 0xdb, 0x51, 0xf5, 0x6d, 0x02, 0x01, 0x19, 0xe2, 0x47, 0x10, 0xd9, 0xfc, 0x74,
|
||||
/* (2^165)P */ 0xa3, 0xbf, 0xc1, 0x23, 0x0a, 0xa9, 0xe2, 0x13, 0xf6, 0x19, 0x85, 0x47, 0x4e, 0x07, 0xb0, 0x0c, 0x44, 0xcf, 0xf6, 0x3a, 0xbe, 0xcb, 0xf1, 0x5f, 0xbe, 0x2d, 0x81, 0xbe, 0x38, 0x54, 0xfe, 0x67,
|
||||
/* (2^166)P */ 0xb0, 0x05, 0x0f, 0xa4, 0x4f, 0xf6, 0x3c, 0xd1, 0x87, 0x37, 0x28, 0x32, 0x2f, 0xfb, 0x4d, 0x05, 0xea, 0x2a, 0x0d, 0x7f, 0x5b, 0x91, 0x73, 0x41, 0x4e, 0x0d, 0x61, 0x1f, 0x4f, 0x14, 0x2f, 0x48,
|
||||
/* (2^167)P */ 0x34, 0x82, 0x7f, 0xb4, 0x01, 0x02, 0x21, 0xf6, 0x90, 0xb9, 0x70, 0x9e, 0x92, 0xe1, 0x0a, 0x5d, 0x7c, 0x56, 0x49, 0xb0, 0x55, 0xf4, 0xd7, 0xdc, 0x01, 0x6f, 0x91, 0xf0, 0xf1, 0xd0, 0x93, 0x7e,
|
||||
/* (2^168)P */ 0xfa, 0xb4, 0x7d, 0x8a, 0xf1, 0xcb, 0x79, 0xdd, 0x2f, 0xc6, 0x74, 0x6f, 0xbf, 0x91, 0x83, 0xbe, 0xbd, 0x91, 0x82, 0x4b, 0xd1, 0x45, 0x71, 0x02, 0x05, 0x17, 0xbf, 0x2c, 0xea, 0x73, 0x5a, 0x58,
|
||||
/* (2^169)P */ 0xb2, 0x0d, 0x8a, 0x92, 0x3e, 0xa0, 0x5c, 0x48, 0xe7, 0x57, 0x28, 0x74, 0xa5, 0x01, 0xfc, 0x10, 0xa7, 0x51, 0xd5, 0xd6, 0xdb, 0x2e, 0x48, 0x2f, 0x8a, 0xdb, 0x8f, 0x04, 0xb5, 0x33, 0x04, 0x0f,
|
||||
/* (2^170)P */ 0x47, 0x62, 0xdc, 0xd7, 0x8d, 0x2e, 0xda, 0x60, 0x9a, 0x81, 0xd4, 0x8c, 0xd3, 0xc9, 0xb4, 0x88, 0x97, 0x66, 0xf6, 0x01, 0xc0, 0x3a, 0x03, 0x13, 0x75, 0x7d, 0x36, 0x3b, 0xfe, 0x24, 0x3b, 0x27,
|
||||
/* (2^171)P */ 0xd4, 0xb9, 0xb3, 0x31, 0x6a, 0xf6, 0xe8, 0xc6, 0xd5, 0x49, 0xdf, 0x94, 0xa4, 0x14, 0x15, 0x28, 0xa7, 0x3d, 0xb2, 0xc8, 0xdf, 0x6f, 0x72, 0xd1, 0x48, 0xe5, 0xde, 0x03, 0xd1, 0xe7, 0x3a, 0x4b,
|
||||
/* (2^172)P */ 0x7e, 0x9d, 0x4b, 0xce, 0x19, 0x6e, 0x25, 0xc6, 0x1c, 0xc6, 0xe3, 0x86, 0xf1, 0x5c, 0x5c, 0xff, 0x45, 0xc1, 0x8e, 0x4b, 0xa3, 0x3c, 0xc6, 0xac, 0x74, 0x65, 0xe6, 0xfe, 0x88, 0x18, 0x62, 0x74,
|
||||
/* (2^173)P */ 0x1e, 0x0a, 0x29, 0x45, 0x96, 0x40, 0x6f, 0x95, 0x2e, 0x96, 0x3a, 0x26, 0xe3, 0xf8, 0x0b, 0xef, 0x7b, 0x64, 0xc2, 0x5e, 0xeb, 0x50, 0x6a, 0xed, 0x02, 0x75, 0xca, 0x9d, 0x3a, 0x28, 0x94, 0x06,
|
||||
/* (2^174)P */ 0xd1, 0xdc, 0xa2, 0x43, 0x36, 0x96, 0x9b, 0x76, 0x53, 0x53, 0xfc, 0x09, 0xea, 0xc8, 0xb7, 0x42, 0xab, 0x7e, 0x39, 0x13, 0xee, 0x2a, 0x00, 0x4f, 0x3a, 0xd6, 0xb7, 0x19, 0x2c, 0x5e, 0x00, 0x63,
|
||||
/* (2^175)P */ 0xea, 0x3b, 0x02, 0x63, 0xda, 0x36, 0x67, 0xca, 0xb7, 0x99, 0x2a, 0xb1, 0x6d, 0x7f, 0x6c, 0x96, 0xe1, 0xc5, 0x37, 0xc5, 0x90, 0x93, 0xe0, 0xac, 0xee, 0x89, 0xaa, 0xa1, 0x63, 0x60, 0x69, 0x0b,
|
||||
/* (2^176)P */ 0xe5, 0x56, 0x8c, 0x28, 0x97, 0x3e, 0xb0, 0xeb, 0xe8, 0x8b, 0x8c, 0x93, 0x9f, 0x9f, 0x2a, 0x43, 0x71, 0x7f, 0x71, 0x5b, 0x3d, 0xa9, 0xa5, 0xa6, 0x97, 0x9d, 0x8f, 0xe1, 0xc3, 0xb4, 0x5f, 0x1a,
|
||||
/* (2^177)P */ 0xce, 0xcd, 0x60, 0x1c, 0xad, 0xe7, 0x94, 0x1c, 0xa0, 0xc4, 0x02, 0xfc, 0x43, 0x2a, 0x20, 0xee, 0x20, 0x6a, 0xc4, 0x67, 0xd8, 0xe4, 0xaf, 0x8d, 0x58, 0x7b, 0xc2, 0x8a, 0x3c, 0x26, 0x10, 0x0a,
|
||||
/* (2^178)P */ 0x4a, 0x2a, 0x43, 0xe4, 0xdf, 0xa9, 0xde, 0xd0, 0xc5, 0x77, 0x92, 0xbe, 0x7b, 0xf8, 0x6a, 0x85, 0x1a, 0xc7, 0x12, 0xc2, 0xac, 0x72, 0x84, 0xce, 0x91, 0x1e, 0xbb, 0x9b, 0x6d, 0x1b, 0x15, 0x6f,
|
||||
/* (2^179)P */ 0x6a, 0xd5, 0xee, 0x7c, 0x52, 0x6c, 0x77, 0x26, 0xec, 0xfa, 0xf8, 0xfb, 0xb7, 0x1c, 0x21, 0x7d, 0xcc, 0x09, 0x46, 0xfd, 0xa6, 0x66, 0xae, 0x37, 0x42, 0x0c, 0x77, 0xd2, 0x02, 0xb7, 0x81, 0x1f,
|
||||
/* (2^180)P */ 0x92, 0x83, 0xc5, 0xea, 0x57, 0xb0, 0xb0, 0x2f, 0x9d, 0x4e, 0x74, 0x29, 0xfe, 0x89, 0xdd, 0xe1, 0xf8, 0xb4, 0xbe, 0x17, 0xeb, 0xf8, 0x64, 0xc9, 0x1e, 0xd4, 0xa2, 0xc9, 0x73, 0x10, 0x57, 0x29,
|
||||
/* (2^181)P */ 0x54, 0xe2, 0xc0, 0x81, 0x89, 0xa1, 0x48, 0xa9, 0x30, 0x28, 0xb2, 0x65, 0x9b, 0x36, 0xf6, 0x2d, 0xc6, 0xd3, 0xcf, 0x5f, 0xd7, 0xb2, 0x3e, 0xa3, 0x1f, 0xa0, 0x99, 0x41, 0xec, 0xd6, 0x8c, 0x07,
|
||||
/* (2^182)P */ 0x2f, 0x0d, 0x90, 0xad, 0x41, 0x4a, 0x58, 0x4a, 0x52, 0x4c, 0xc7, 0xe2, 0x78, 0x2b, 0x14, 0x32, 0x78, 0xc9, 0x31, 0x84, 0x33, 0xe8, 0xc4, 0x68, 0xc2, 0x9f, 0x68, 0x08, 0x90, 0xea, 0x69, 0x7f,
|
||||
/* (2^183)P */ 0x65, 0x82, 0xa3, 0x46, 0x1e, 0xc8, 0xf2, 0x52, 0xfd, 0x32, 0xa8, 0x04, 0x2d, 0x07, 0x78, 0xfd, 0x94, 0x9e, 0x35, 0x25, 0xfa, 0xd5, 0xd7, 0x8c, 0xd2, 0x29, 0xcc, 0x54, 0x74, 0x1b, 0xe7, 0x4d,
|
||||
/* (2^184)P */ 0xc9, 0x6a, 0xda, 0x1e, 0xad, 0x60, 0xeb, 0x42, 0x3a, 0x9c, 0xc0, 0xdb, 0xdf, 0x37, 0xad, 0x0a, 0x91, 0xc1, 0x3c, 0xe3, 0x71, 0x4b, 0x00, 0x81, 0x3c, 0x80, 0x22, 0x51, 0x34, 0xbe, 0xe6, 0x44,
|
||||
/* (2^185)P */ 0xdb, 0x20, 0x19, 0xba, 0x88, 0x83, 0xfe, 0x03, 0x08, 0xb0, 0x0d, 0x15, 0x32, 0x7c, 0xd5, 0xf5, 0x29, 0x0c, 0xf6, 0x1a, 0x28, 0xc4, 0xc8, 0x49, 0xee, 0x1a, 0x70, 0xde, 0x18, 0xb5, 0xed, 0x21,
|
||||
/* (2^186)P */ 0x99, 0xdc, 0x06, 0x8f, 0x41, 0x3e, 0xb6, 0x7f, 0xb8, 0xd7, 0x66, 0xc1, 0x99, 0x0d, 0x46, 0xa4, 0x83, 0x0a, 0x52, 0xce, 0x48, 0x52, 0xdd, 0x24, 0x58, 0x83, 0x92, 0x2b, 0x71, 0xad, 0xc3, 0x5e,
|
||||
/* (2^187)P */ 0x0f, 0x93, 0x17, 0xbd, 0x5f, 0x2a, 0x02, 0x15, 0xe3, 0x70, 0x25, 0xd8, 0x77, 0x4a, 0xf6, 0xa4, 0x12, 0x37, 0x78, 0x15, 0x69, 0x8d, 0xbc, 0x12, 0xbb, 0x0a, 0x62, 0xfc, 0xc0, 0x94, 0x81, 0x49,
|
||||
/* (2^188)P */ 0x82, 0x6c, 0x68, 0x55, 0xd2, 0xd9, 0xa2, 0x38, 0xf0, 0x21, 0x3e, 0x19, 0xd9, 0x6b, 0x5c, 0x78, 0x84, 0x54, 0x4a, 0xb2, 0x1a, 0xc8, 0xd5, 0xe4, 0x89, 0x09, 0xe2, 0xb2, 0x60, 0x78, 0x30, 0x56,
|
||||
/* (2^189)P */ 0xc4, 0x74, 0x4d, 0x8b, 0xf7, 0x55, 0x9d, 0x42, 0x31, 0x01, 0x35, 0x43, 0x46, 0x83, 0xf1, 0x22, 0xff, 0x1f, 0xc7, 0x98, 0x45, 0xc2, 0x60, 0x1e, 0xef, 0x83, 0x99, 0x97, 0x14, 0xf0, 0xf2, 0x59,
|
||||
/* (2^190)P */ 0x44, 0x4a, 0x49, 0xeb, 0x56, 0x7d, 0xa4, 0x46, 0x8e, 0xa1, 0x36, 0xd6, 0x54, 0xa8, 0x22, 0x3e, 0x3b, 0x1c, 0x49, 0x74, 0x52, 0xe1, 0x46, 0xb3, 0xe7, 0xcd, 0x90, 0x53, 0x4e, 0xfd, 0xea, 0x2c,
|
||||
/* (2^191)P */ 0x75, 0x66, 0x0d, 0xbe, 0x38, 0x85, 0x8a, 0xba, 0x23, 0x8e, 0x81, 0x50, 0xbb, 0x74, 0x90, 0x4b, 0xc3, 0x04, 0xd3, 0x85, 0x90, 0xb8, 0xda, 0xcb, 0xc4, 0x92, 0x61, 0xe5, 0xe0, 0x4f, 0xa2, 0x61,
|
||||
/* (2^192)P */ 0xcb, 0x5b, 0x52, 0xdb, 0xe6, 0x15, 0x76, 0xcb, 0xca, 0xe4, 0x67, 0xa5, 0x35, 0x8c, 0x7d, 0xdd, 0x69, 0xdd, 0xfc, 0xca, 0x3a, 0x15, 0xb4, 0xe6, 0x66, 0x97, 0x3c, 0x7f, 0x09, 0x8e, 0x66, 0x2d,
|
||||
/* (2^193)P */ 0xf0, 0x5e, 0xe5, 0x5c, 0x26, 0x7e, 0x7e, 0xa5, 0x67, 0xb9, 0xd4, 0x7c, 0x52, 0x4e, 0x9f, 0x5d, 0xe5, 0xd1, 0x2f, 0x49, 0x06, 0x36, 0xc8, 0xfb, 0xae, 0xf7, 0xc3, 0xb7, 0xbe, 0x52, 0x0d, 0x09,
|
||||
/* (2^194)P */ 0x7c, 0x4d, 0x7b, 0x1e, 0x5a, 0x51, 0xb9, 0x09, 0xc0, 0x44, 0xda, 0x99, 0x25, 0x6a, 0x26, 0x1f, 0x04, 0x55, 0xc5, 0xe2, 0x48, 0x95, 0xc4, 0xa1, 0xcc, 0x15, 0x6f, 0x12, 0x87, 0x42, 0xf0, 0x7e,
|
||||
/* (2^195)P */ 0x15, 0xef, 0x30, 0xbd, 0x9d, 0x65, 0xd1, 0xfe, 0x7b, 0x27, 0xe0, 0xc4, 0xee, 0xb9, 0x4a, 0x8b, 0x91, 0x32, 0xdf, 0xa5, 0x36, 0x62, 0x4d, 0x88, 0x88, 0xf7, 0x5c, 0xbf, 0xa6, 0x6e, 0xd9, 0x1f,
|
||||
/* (2^196)P */ 0x9a, 0x0d, 0x19, 0x1f, 0x98, 0x61, 0xa1, 0x42, 0xc1, 0x52, 0x60, 0x7e, 0x50, 0x49, 0xd8, 0x61, 0xd5, 0x2c, 0x5a, 0x28, 0xbf, 0x13, 0xe1, 0x9f, 0xd8, 0x85, 0xad, 0xdb, 0x76, 0xd6, 0x22, 0x7c,
|
||||
/* (2^197)P */ 0x7d, 0xd2, 0xfb, 0x2b, 0xed, 0x70, 0xe7, 0x82, 0xa5, 0xf5, 0x96, 0xe9, 0xec, 0xb2, 0x05, 0x4c, 0x50, 0x01, 0x90, 0xb0, 0xc2, 0xa9, 0x40, 0xcd, 0x64, 0xbf, 0xd9, 0x13, 0x92, 0x31, 0x95, 0x58,
|
||||
/* (2^198)P */ 0x08, 0x2e, 0xea, 0x3f, 0x70, 0x5d, 0xcc, 0xe7, 0x8c, 0x18, 0xe2, 0x58, 0x12, 0x49, 0x0c, 0xb5, 0xf0, 0x5b, 0x20, 0x48, 0xaa, 0x0b, 0xe3, 0xcc, 0x62, 0x2d, 0xa3, 0xcf, 0x9c, 0x65, 0x7c, 0x53,
|
||||
/* (2^199)P */ 0x88, 0xc0, 0xcf, 0x98, 0x3a, 0x62, 0xb6, 0x37, 0xa4, 0xac, 0xd6, 0xa4, 0x1f, 0xed, 0x9b, 0xfe, 0xb0, 0xd1, 0xa8, 0x56, 0x8e, 0x9b, 0xd2, 0x04, 0x75, 0x95, 0x51, 0x0b, 0xc4, 0x71, 0x5f, 0x72,
|
||||
/* (2^200)P */ 0xe6, 0x9c, 0x33, 0xd0, 0x9c, 0xf8, 0xc7, 0x28, 0x8b, 0xc1, 0xdd, 0x69, 0x44, 0xb1, 0x67, 0x83, 0x2c, 0x65, 0xa1, 0xa6, 0x83, 0xda, 0x3a, 0x88, 0x17, 0x6c, 0x4d, 0x03, 0x74, 0x19, 0x5f, 0x58,
|
||||
/* (2^201)P */ 0x88, 0x91, 0xb1, 0xf1, 0x66, 0xb2, 0xcf, 0x89, 0x17, 0x52, 0xc3, 0xe7, 0x63, 0x48, 0x3b, 0xe6, 0x6a, 0x52, 0xc0, 0xb4, 0xa6, 0x9d, 0x8c, 0xd8, 0x35, 0x46, 0x95, 0xf0, 0x9d, 0x5c, 0x03, 0x3e,
|
||||
/* (2^202)P */ 0x9d, 0xde, 0x45, 0xfb, 0x12, 0x54, 0x9d, 0xdd, 0x0d, 0xf4, 0xcf, 0xe4, 0x32, 0x45, 0x68, 0xdd, 0x1c, 0x67, 0x1d, 0x15, 0x9b, 0x99, 0x5c, 0x4b, 0x90, 0xf6, 0xe7, 0x11, 0xc8, 0x2c, 0x8c, 0x2d,
|
||||
/* (2^203)P */ 0x40, 0x5d, 0x05, 0x90, 0x1d, 0xbe, 0x54, 0x7f, 0x40, 0xaf, 0x4a, 0x46, 0xdf, 0xc5, 0x64, 0xa4, 0xbe, 0x17, 0xe9, 0xf0, 0x24, 0x96, 0x97, 0x33, 0x30, 0x6b, 0x35, 0x27, 0xc5, 0x8d, 0x01, 0x2c,
|
||||
/* (2^204)P */ 0xd4, 0xb3, 0x30, 0xe3, 0x24, 0x50, 0x41, 0xa5, 0xd3, 0x52, 0x16, 0x69, 0x96, 0x3d, 0xff, 0x73, 0xf1, 0x59, 0x9b, 0xef, 0xc4, 0x42, 0xec, 0x94, 0x5a, 0x8e, 0xd0, 0x18, 0x16, 0x20, 0x47, 0x07,
|
||||
/* (2^205)P */ 0x53, 0x1c, 0x41, 0xca, 0x8a, 0xa4, 0x6c, 0x4d, 0x19, 0x61, 0xa6, 0xcf, 0x2f, 0x5f, 0x41, 0x66, 0xff, 0x27, 0xe2, 0x51, 0x00, 0xd4, 0x4d, 0x9c, 0xeb, 0xf7, 0x02, 0x9a, 0xc0, 0x0b, 0x81, 0x59,
|
||||
/* (2^206)P */ 0x1d, 0x10, 0xdc, 0xb3, 0x71, 0xb1, 0x7e, 0x2a, 0x8e, 0xf6, 0xfe, 0x9f, 0xb9, 0x5a, 0x1c, 0x44, 0xea, 0x59, 0xb3, 0x93, 0x9b, 0x5c, 0x02, 0x32, 0x2f, 0x11, 0x9d, 0x1e, 0xa7, 0xe0, 0x8c, 0x5e,
|
||||
/* (2^207)P */ 0xfd, 0x03, 0x95, 0x42, 0x92, 0xcb, 0xcc, 0xbf, 0x55, 0x5d, 0x09, 0x2f, 0x75, 0xba, 0x71, 0xd2, 0x1e, 0x09, 0x2d, 0x97, 0x5e, 0xad, 0x5e, 0x34, 0xba, 0x03, 0x31, 0xa8, 0x11, 0xdf, 0xc8, 0x18,
|
||||
/* (2^208)P */ 0x4c, 0x0f, 0xed, 0x9a, 0x9a, 0x94, 0xcd, 0x90, 0x7e, 0xe3, 0x60, 0x66, 0xcb, 0xf4, 0xd1, 0xc5, 0x0b, 0x2e, 0xc5, 0x56, 0x2d, 0xc5, 0xca, 0xb8, 0x0d, 0x8e, 0x80, 0xc5, 0x00, 0xe4, 0x42, 0x6e,
|
||||
/* (2^209)P */ 0x23, 0xfd, 0xae, 0xee, 0x66, 0x69, 0xb4, 0xa3, 0xca, 0xcd, 0x9e, 0xe3, 0x0b, 0x1f, 0x4f, 0x0c, 0x1d, 0xa5, 0x83, 0xd6, 0xc9, 0xc8, 0x9d, 0x18, 0x1b, 0x35, 0x09, 0x4c, 0x05, 0x7f, 0xf2, 0x51,
|
||||
/* (2^210)P */ 0x82, 0x06, 0x32, 0x2a, 0xcd, 0x7c, 0x48, 0x4c, 0x96, 0x1c, 0xdf, 0xb3, 0x5b, 0xa9, 0x7e, 0x58, 0xe8, 0xb8, 0x5c, 0x55, 0x9e, 0xf7, 0xcc, 0xc8, 0x3d, 0xd7, 0x06, 0xa2, 0x29, 0xc8, 0x7d, 0x54,
|
||||
/* (2^211)P */ 0x06, 0x9b, 0xc3, 0x80, 0xcd, 0xa6, 0x22, 0xb8, 0xc6, 0xd4, 0x00, 0x20, 0x73, 0x54, 0x6d, 0xe9, 0x4d, 0x3b, 0x46, 0x91, 0x6f, 0x5b, 0x53, 0x28, 0x1d, 0x6e, 0x48, 0xe2, 0x60, 0x46, 0x8f, 0x22,
|
||||
/* (2^212)P */ 0xbf, 0x3a, 0x8d, 0xde, 0x38, 0x95, 0x79, 0x98, 0x6e, 0xca, 0xeb, 0x45, 0x00, 0x33, 0xd8, 0x8c, 0x38, 0xe7, 0x21, 0x82, 0x00, 0x2a, 0x95, 0x79, 0xbb, 0xd2, 0x5c, 0x53, 0xa7, 0xe1, 0x22, 0x43,
|
||||
/* (2^213)P */ 0x1c, 0x80, 0xd1, 0x19, 0x18, 0xc1, 0x14, 0xb1, 0xc7, 0x5e, 0x3f, 0x4f, 0xd8, 0xe4, 0x16, 0x20, 0x4c, 0x0f, 0x26, 0x09, 0xf4, 0x2d, 0x0e, 0xdd, 0x66, 0x72, 0x5f, 0xae, 0xc0, 0x62, 0xc3, 0x5e,
|
||||
/* (2^214)P */ 0xee, 0xb4, 0xb2, 0xb8, 0x18, 0x2b, 0x46, 0xc0, 0xfb, 0x1a, 0x4d, 0x27, 0x50, 0xd9, 0xc8, 0x7c, 0xd2, 0x02, 0x6b, 0x43, 0x05, 0x71, 0x5f, 0xf2, 0xd3, 0xcc, 0xf9, 0xbf, 0xdc, 0xf8, 0xbb, 0x43,
|
||||
/* (2^215)P */ 0xdf, 0xe9, 0x39, 0xa0, 0x67, 0x17, 0xad, 0xb6, 0x83, 0x35, 0x9d, 0xf6, 0xa8, 0x4d, 0x71, 0xb0, 0xf5, 0x31, 0x29, 0xb4, 0x18, 0xfa, 0x55, 0x5e, 0x61, 0x09, 0xc6, 0x33, 0x8f, 0x55, 0xd5, 0x4e,
|
||||
/* (2^216)P */ 0xdd, 0xa5, 0x47, 0xc6, 0x01, 0x79, 0xe3, 0x1f, 0x57, 0xd3, 0x81, 0x80, 0x1f, 0xdf, 0x3d, 0x59, 0xa6, 0xd7, 0x3f, 0x81, 0xfd, 0xa4, 0x49, 0x02, 0x61, 0xaf, 0x9c, 0x4e, 0x27, 0xca, 0xac, 0x69,
|
||||
/* (2^217)P */ 0xc9, 0x21, 0x07, 0x33, 0xea, 0xa3, 0x7b, 0x04, 0xa0, 0x1e, 0x7e, 0x0e, 0xc2, 0x3f, 0x42, 0x83, 0x60, 0x4a, 0x31, 0x01, 0xaf, 0xc0, 0xf4, 0x1d, 0x27, 0x95, 0x28, 0x89, 0xab, 0x2d, 0xa6, 0x09,
|
||||
/* (2^218)P */ 0x00, 0xcb, 0xc6, 0x9c, 0xa4, 0x25, 0xb3, 0xa5, 0xb6, 0x6c, 0xb5, 0x54, 0xc6, 0x5d, 0x4b, 0xe9, 0xa0, 0x94, 0xc9, 0xad, 0x79, 0x87, 0xe2, 0x3b, 0xad, 0x4a, 0x3a, 0xba, 0xf8, 0xe8, 0x96, 0x42,
|
||||
/* (2^219)P */ 0xab, 0x1e, 0x45, 0x1e, 0x76, 0x89, 0x86, 0x32, 0x4a, 0x59, 0x59, 0xff, 0x8b, 0x59, 0x4d, 0x2e, 0x4a, 0x08, 0xa7, 0xd7, 0x53, 0x68, 0xb9, 0x49, 0xa8, 0x20, 0x14, 0x60, 0x19, 0xa3, 0x80, 0x49,
|
||||
/* (2^220)P */ 0x42, 0x2c, 0x55, 0x2f, 0xe1, 0xb9, 0x65, 0x95, 0x96, 0xfe, 0x00, 0x71, 0xdb, 0x18, 0x53, 0x8a, 0xd7, 0xd0, 0xad, 0x43, 0x4d, 0x0b, 0xc9, 0x05, 0xda, 0x4e, 0x5d, 0x6a, 0xd6, 0x4c, 0x8b, 0x53,
|
||||
/* (2^221)P */ 0x9f, 0x03, 0x9f, 0xe8, 0xc3, 0x4f, 0xe9, 0xf4, 0x45, 0x80, 0x61, 0x6f, 0xf2, 0x9a, 0x2c, 0x59, 0x50, 0x95, 0x4b, 0xfd, 0xb5, 0x6e, 0xa3, 0x08, 0x19, 0x14, 0xed, 0xc2, 0xf6, 0xfa, 0xff, 0x25,
|
||||
/* (2^222)P */ 0x54, 0xd3, 0x79, 0xcc, 0x59, 0x44, 0x43, 0x34, 0x6b, 0x47, 0xd5, 0xb1, 0xb4, 0xbf, 0xec, 0xee, 0x99, 0x5d, 0x61, 0x61, 0xa0, 0x34, 0xeb, 0xdd, 0x73, 0xb7, 0x64, 0xeb, 0xcc, 0xce, 0x29, 0x51,
|
||||
/* (2^223)P */ 0x20, 0x35, 0x99, 0x94, 0x58, 0x21, 0x43, 0xee, 0x3b, 0x0b, 0x4c, 0xf1, 0x7c, 0x9c, 0x2f, 0x77, 0xd5, 0xda, 0xbe, 0x06, 0xe3, 0xfc, 0xe2, 0xd2, 0x97, 0x6a, 0xf0, 0x46, 0xb5, 0x42, 0x5f, 0x71,
|
||||
/* (2^224)P */ 0x1a, 0x5f, 0x5b, 0xda, 0xce, 0xcd, 0x4e, 0x43, 0xa9, 0x41, 0x97, 0xa4, 0x15, 0x71, 0xa1, 0x0d, 0x2e, 0xad, 0xed, 0x73, 0x7c, 0xd7, 0x0b, 0x68, 0x41, 0x90, 0xdd, 0x4e, 0x35, 0x02, 0x7c, 0x48,
|
||||
/* (2^225)P */ 0xc4, 0xd9, 0x0e, 0xa7, 0xf3, 0xef, 0xef, 0xb8, 0x02, 0xe3, 0x57, 0xe8, 0xa3, 0x2a, 0xa3, 0x56, 0xa0, 0xa5, 0xa2, 0x48, 0xbd, 0x68, 0x3a, 0xdf, 0x44, 0xc4, 0x76, 0x31, 0xb7, 0x50, 0xf6, 0x07,
|
||||
/* (2^226)P */ 0xb1, 0xcc, 0xe0, 0x26, 0x16, 0x9b, 0x8b, 0xe3, 0x36, 0xfb, 0x09, 0x8b, 0xc1, 0x53, 0xe0, 0x79, 0x64, 0x49, 0xf9, 0xc9, 0x19, 0x03, 0xd9, 0x56, 0xc4, 0xf5, 0x9f, 0xac, 0xe7, 0x41, 0xa9, 0x1c,
|
||||
/* (2^227)P */ 0xbb, 0xa0, 0x2f, 0x16, 0x29, 0xdf, 0xc4, 0x49, 0x05, 0x33, 0xb3, 0x82, 0x32, 0xcf, 0x88, 0x84, 0x7d, 0x43, 0xbb, 0xca, 0x14, 0xda, 0xdf, 0x95, 0x86, 0xad, 0xd5, 0x64, 0x82, 0xf7, 0x91, 0x33,
|
||||
/* (2^228)P */ 0x5d, 0x09, 0xb5, 0xe2, 0x6a, 0xe0, 0x9a, 0x72, 0x46, 0xa9, 0x59, 0x32, 0xd7, 0x58, 0x8a, 0xd5, 0xed, 0x21, 0x39, 0xd1, 0x62, 0x42, 0x83, 0xe9, 0x92, 0xb5, 0x4b, 0xa5, 0xfa, 0xda, 0xfe, 0x27,
|
||||
/* (2^229)P */ 0xbb, 0x48, 0xad, 0x29, 0xb8, 0xc5, 0x9d, 0xa9, 0x60, 0xe2, 0x9e, 0x49, 0x42, 0x57, 0x02, 0x5f, 0xfd, 0x13, 0x75, 0x5d, 0xcd, 0x8e, 0x2c, 0x80, 0x38, 0xd9, 0x6d, 0x3f, 0xef, 0xb3, 0xce, 0x78,
|
||||
/* (2^230)P */ 0x94, 0x5d, 0x13, 0x8a, 0x4f, 0xf4, 0x42, 0xc3, 0xa3, 0xdd, 0x8c, 0x82, 0x44, 0xdb, 0x9e, 0x7b, 0xe7, 0xcf, 0x37, 0x05, 0x1a, 0xd1, 0x36, 0x94, 0xc8, 0xb4, 0x1a, 0xec, 0x64, 0xb1, 0x64, 0x50,
|
||||
/* (2^231)P */ 0xfc, 0xb2, 0x7e, 0xd3, 0xcf, 0xec, 0x20, 0x70, 0xfc, 0x25, 0x0d, 0xd9, 0x3e, 0xea, 0x31, 0x1f, 0x34, 0xbb, 0xa1, 0xdf, 0x7b, 0x0d, 0x93, 0x1b, 0x44, 0x30, 0x11, 0x48, 0x7a, 0x46, 0x44, 0x53,
|
||||
/* (2^232)P */ 0xfb, 0x6d, 0x5e, 0xf2, 0x70, 0x31, 0x07, 0x70, 0xc8, 0x4c, 0x11, 0x50, 0x1a, 0xdc, 0x85, 0xe3, 0x00, 0x4f, 0xfc, 0xc8, 0x8a, 0x69, 0x48, 0x23, 0xd8, 0x40, 0xdd, 0x84, 0x52, 0xa5, 0x77, 0x2a,
|
||||
/* (2^233)P */ 0xe4, 0x6c, 0x8c, 0xc9, 0xe0, 0xaf, 0x06, 0xfe, 0xe4, 0xd6, 0xdf, 0xdd, 0x96, 0xdf, 0x35, 0xc2, 0xd3, 0x1e, 0xbf, 0x33, 0x1e, 0xd0, 0x28, 0x14, 0xaf, 0xbd, 0x00, 0x93, 0xec, 0x68, 0x57, 0x78,
|
||||
/* (2^234)P */ 0x3b, 0xb6, 0xde, 0x91, 0x7a, 0xe5, 0x02, 0x97, 0x80, 0x8b, 0xce, 0xe5, 0xbf, 0xb8, 0xbd, 0x61, 0xac, 0x58, 0x1d, 0x3d, 0x6f, 0x42, 0x5b, 0x64, 0xbc, 0x57, 0xa5, 0x27, 0x22, 0xa8, 0x04, 0x48,
|
||||
/* (2^235)P */ 0x01, 0x26, 0x4d, 0xb4, 0x8a, 0x04, 0x57, 0x8e, 0x35, 0x69, 0x3a, 0x4b, 0x1a, 0x50, 0xd6, 0x68, 0x93, 0xc2, 0xe1, 0xf9, 0xc3, 0x9e, 0x9c, 0xc3, 0xe2, 0x63, 0xde, 0xd4, 0x57, 0xf2, 0x72, 0x41,
|
||||
/* (2^236)P */ 0x01, 0x64, 0x0c, 0x33, 0x50, 0xb4, 0x68, 0xd3, 0x91, 0x23, 0x8f, 0x41, 0x17, 0x30, 0x0d, 0x04, 0x0d, 0xd9, 0xb7, 0x90, 0x60, 0xbb, 0x34, 0x2c, 0x1f, 0xd5, 0xdf, 0x8f, 0x22, 0x49, 0xf6, 0x16,
|
||||
/* (2^237)P */ 0xf5, 0x8e, 0x92, 0x2b, 0x8e, 0x81, 0xa6, 0xbe, 0x72, 0x1e, 0xc1, 0xcd, 0x91, 0xcf, 0x8c, 0xe2, 0xcd, 0x36, 0x7a, 0xe7, 0x68, 0xaa, 0x4a, 0x59, 0x0f, 0xfd, 0x7f, 0x6c, 0x80, 0x34, 0x30, 0x31,
|
||||
/* (2^238)P */ 0x65, 0xbd, 0x49, 0x22, 0xac, 0x27, 0x9d, 0x8a, 0x12, 0x95, 0x8e, 0x01, 0x64, 0xb4, 0xa3, 0x19, 0xc7, 0x7e, 0xb3, 0x52, 0xf3, 0xcf, 0x6c, 0xc2, 0x21, 0x7b, 0x79, 0x1d, 0x34, 0x68, 0x6f, 0x05,
|
||||
/* (2^239)P */ 0x27, 0x23, 0xfd, 0x7e, 0x75, 0xd6, 0x79, 0x5e, 0x15, 0xfe, 0x3a, 0x55, 0xb6, 0xbc, 0xbd, 0xfa, 0x60, 0x5a, 0xaf, 0x6e, 0x2c, 0x22, 0xe7, 0xd3, 0x3b, 0x74, 0xae, 0x4d, 0x6d, 0xc7, 0x46, 0x70,
|
||||
/* (2^240)P */ 0x55, 0x4a, 0x8d, 0xb1, 0x72, 0xe8, 0x0b, 0x66, 0x96, 0x14, 0x4e, 0x57, 0x18, 0x25, 0x99, 0x19, 0xbb, 0xdc, 0x2b, 0x30, 0x3a, 0x05, 0x03, 0xc1, 0x8e, 0x8e, 0x21, 0x0b, 0x80, 0xe9, 0xd8, 0x3e,
|
||||
/* (2^241)P */ 0x3e, 0xe0, 0x75, 0xfa, 0x39, 0x92, 0x0b, 0x7b, 0x83, 0xc0, 0x33, 0x46, 0x68, 0xfb, 0xe9, 0xef, 0x93, 0x77, 0x1a, 0x39, 0xbe, 0x5f, 0xa3, 0x98, 0x34, 0xfe, 0xd0, 0xe2, 0x0f, 0x51, 0x65, 0x60,
|
||||
/* (2^242)P */ 0x0c, 0xad, 0xab, 0x48, 0x85, 0x66, 0xcb, 0x55, 0x27, 0xe5, 0x87, 0xda, 0x48, 0x45, 0x58, 0xb4, 0xdd, 0xc1, 0x07, 0x01, 0xea, 0xec, 0x43, 0x2c, 0x35, 0xde, 0x72, 0x93, 0x80, 0x28, 0x60, 0x52,
|
||||
/* (2^243)P */ 0x1f, 0x3b, 0x21, 0xf9, 0x6a, 0xc5, 0x15, 0x34, 0xdb, 0x98, 0x7e, 0x01, 0x4d, 0x1a, 0xee, 0x5b, 0x9b, 0x70, 0xcf, 0xb5, 0x05, 0xb1, 0xf6, 0x13, 0xb6, 0x9a, 0xb2, 0x82, 0x34, 0x0e, 0xf2, 0x5f,
|
||||
/* (2^244)P */ 0x90, 0x6c, 0x2e, 0xcc, 0x75, 0x9c, 0xa2, 0x0a, 0x06, 0xe2, 0x70, 0x3a, 0xca, 0x73, 0x7d, 0xfc, 0x15, 0xc5, 0xb5, 0xc4, 0x8f, 0xc3, 0x9f, 0x89, 0x07, 0xc2, 0xff, 0x24, 0xb1, 0x86, 0x03, 0x25,
|
||||
/* (2^245)P */ 0x56, 0x2b, 0x3d, 0xae, 0xd5, 0x28, 0xea, 0x54, 0xce, 0x60, 0xde, 0xd6, 0x9d, 0x14, 0x13, 0x99, 0xc1, 0xd6, 0x06, 0x8f, 0xc5, 0x4f, 0x69, 0x16, 0xc7, 0x8f, 0x01, 0xeb, 0x75, 0x39, 0xb2, 0x46,
|
||||
/* (2^246)P */ 0xe2, 0xb4, 0xb7, 0xb4, 0x0f, 0x6a, 0x0a, 0x47, 0xde, 0x53, 0x72, 0x8f, 0x5a, 0x47, 0x92, 0x5d, 0xdb, 0x3a, 0xbd, 0x2f, 0xb5, 0xe5, 0xee, 0xab, 0x68, 0x69, 0x80, 0xa0, 0x01, 0x08, 0xa2, 0x7f,
|
||||
/* (2^247)P */ 0xd2, 0x14, 0x77, 0x9f, 0xf1, 0xfa, 0xf3, 0x76, 0xc3, 0x60, 0x46, 0x2f, 0xc1, 0x40, 0xe8, 0xb3, 0x4e, 0x74, 0x12, 0xf2, 0x8d, 0xcd, 0xb4, 0x0f, 0xd2, 0x2d, 0x3a, 0x1d, 0x25, 0x5a, 0x06, 0x4b,
|
||||
/* (2^248)P */ 0x4a, 0xcd, 0x77, 0x3d, 0x38, 0xde, 0xeb, 0x5c, 0xb1, 0x9c, 0x2c, 0x88, 0xdf, 0x39, 0xdf, 0x6a, 0x59, 0xf7, 0x9a, 0xb0, 0x2e, 0x24, 0xdd, 0xa2, 0x22, 0x64, 0x5f, 0x0e, 0xe5, 0xc0, 0x47, 0x31,
|
||||
/* (2^249)P */ 0xdb, 0x50, 0x13, 0x1d, 0x10, 0xa5, 0x4c, 0x16, 0x62, 0xc9, 0x3f, 0xc3, 0x79, 0x34, 0xd1, 0xf8, 0x08, 0xda, 0xe5, 0x13, 0x4d, 0xce, 0x40, 0xe6, 0xba, 0xf8, 0x61, 0x50, 0xc4, 0xe0, 0xde, 0x4b,
|
||||
/* (2^250)P */ 0xc9, 0xb1, 0xed, 0xa4, 0xc1, 0x6d, 0xc4, 0xd7, 0x8a, 0xd9, 0x7f, 0x43, 0xb6, 0xd7, 0x14, 0x55, 0x0b, 0xc0, 0xa1, 0xb2, 0x6b, 0x2f, 0x94, 0x58, 0x0e, 0x71, 0x70, 0x1d, 0xab, 0xb2, 0xff, 0x2d,
|
||||
/* (2^251)P */ 0x68, 0x6d, 0x8b, 0xc1, 0x2f, 0xcf, 0xdf, 0xcc, 0x67, 0x61, 0x80, 0xb7, 0xa8, 0xcb, 0xeb, 0xa8, 0xe3, 0x37, 0x29, 0x5e, 0xf9, 0x97, 0x06, 0x98, 0x8c, 0x6e, 0x12, 0xd0, 0x1c, 0xba, 0xfb, 0x02,
|
||||
/* (2^252)P */ 0x65, 0x45, 0xff, 0xad, 0x60, 0xc3, 0x98, 0xcb, 0x19, 0x15, 0xdb, 0x4b, 0xd2, 0x01, 0x71, 0x44, 0xd5, 0x15, 0xfb, 0x75, 0x74, 0xc8, 0xc4, 0x98, 0x7d, 0xa2, 0x22, 0x6e, 0x6d, 0xc7, 0xf8, 0x05,
|
||||
/* (2^253)P */ 0x94, 0xf4, 0xb9, 0xfe, 0xdf, 0xe5, 0x69, 0xab, 0x75, 0x6b, 0x40, 0x18, 0x9d, 0xc7, 0x09, 0xae, 0x1d, 0x2d, 0xa4, 0x94, 0xfb, 0x45, 0x9b, 0x19, 0x84, 0xfa, 0x2a, 0xae, 0xeb, 0x0a, 0x71, 0x79,
|
||||
/* (2^254)P */ 0xdf, 0xd2, 0x34, 0xf3, 0xa7, 0xed, 0xad, 0xa6, 0xb4, 0x57, 0x2a, 0xaf, 0x51, 0x9c, 0xde, 0x7b, 0xa8, 0xea, 0xdc, 0x86, 0x4f, 0xc6, 0x8f, 0xa9, 0x7b, 0xd0, 0x0e, 0xc2, 0x35, 0x03, 0xbe, 0x6b,
|
||||
/* (2^255)P */ 0x44, 0x43, 0x98, 0x53, 0xbe, 0xdc, 0x7f, 0x66, 0xa8, 0x49, 0x59, 0x00, 0x1c, 0xbc, 0x72, 0x07, 0x8e, 0xd6, 0xbe, 0x4e, 0x9f, 0xa4, 0x07, 0xba, 0xbf, 0x30, 0xdf, 0xba, 0x85, 0xb0, 0xa7, 0x1f,
|
||||
}
|
||||
104
vendor/github.com/cloudflare/circl/dh/x448/curve.go
generated
vendored
Normal file
104
vendor/github.com/cloudflare/circl/dh/x448/curve.go
generated
vendored
Normal file
@ -0,0 +1,104 @@
|
||||
package x448
|
||||
|
||||
import (
|
||||
fp "github.com/cloudflare/circl/math/fp448"
|
||||
)
|
||||
|
||||
// ladderJoye calculates a fixed-point multiplication with the generator point.
|
||||
// The algorithm is the right-to-left Joye's ladder as described
|
||||
// in "How to precompute a ladder" in SAC'2017.
|
||||
func ladderJoye(k *Key) {
|
||||
w := [5]fp.Elt{} // [mu,x1,z1,x2,z2] order must be preserved.
|
||||
w[1] = fp.Elt{ // x1 = S
|
||||
0xfe, 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, 0xfe, 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,
|
||||
}
|
||||
fp.SetOne(&w[2]) // z1 = 1
|
||||
w[3] = fp.Elt{ // x2 = G-S
|
||||
0x20, 0x27, 0x9d, 0xc9, 0x7d, 0x19, 0xb1, 0xac,
|
||||
0xf8, 0xba, 0x69, 0x1c, 0xff, 0x33, 0xac, 0x23,
|
||||
0x51, 0x1b, 0xce, 0x3a, 0x64, 0x65, 0xbd, 0xf1,
|
||||
0x23, 0xf8, 0xc1, 0x84, 0x9d, 0x45, 0x54, 0x29,
|
||||
0x67, 0xb9, 0x81, 0x1c, 0x03, 0xd1, 0xcd, 0xda,
|
||||
0x7b, 0xeb, 0xff, 0x1a, 0x88, 0x03, 0xcf, 0x3a,
|
||||
0x42, 0x44, 0x32, 0x01, 0x25, 0xb7, 0xfa, 0xf0,
|
||||
}
|
||||
fp.SetOne(&w[4]) // z2 = 1
|
||||
|
||||
const n = 448
|
||||
const h = 2
|
||||
swap := uint(1)
|
||||
for s := 0; s < n-h; s++ {
|
||||
i := (s + h) / 8
|
||||
j := (s + h) % 8
|
||||
bit := uint((k[i] >> uint(j)) & 1)
|
||||
copy(w[0][:], tableGenerator[s*Size:(s+1)*Size])
|
||||
diffAdd(&w, swap^bit)
|
||||
swap = bit
|
||||
}
|
||||
for s := 0; s < h; s++ {
|
||||
double(&w[1], &w[2])
|
||||
}
|
||||
toAffine((*[fp.Size]byte)(k), &w[1], &w[2])
|
||||
}
|
||||
|
||||
// ladderMontgomery calculates a generic scalar point multiplication
|
||||
// The algorithm implemented is the left-to-right Montgomery's ladder.
|
||||
func ladderMontgomery(k, xP *Key) {
|
||||
w := [5]fp.Elt{} // [x1, x2, z2, x3, z3] order must be preserved.
|
||||
w[0] = *(*fp.Elt)(xP) // x1 = xP
|
||||
fp.SetOne(&w[1]) // x2 = 1
|
||||
w[3] = *(*fp.Elt)(xP) // x3 = xP
|
||||
fp.SetOne(&w[4]) // z3 = 1
|
||||
|
||||
move := uint(0)
|
||||
for s := 448 - 1; s >= 0; s-- {
|
||||
i := s / 8
|
||||
j := s % 8
|
||||
bit := uint((k[i] >> uint(j)) & 1)
|
||||
ladderStep(&w, move^bit)
|
||||
move = bit
|
||||
}
|
||||
toAffine((*[fp.Size]byte)(k), &w[1], &w[2])
|
||||
}
|
||||
|
||||
func toAffine(k *[fp.Size]byte, x, z *fp.Elt) {
|
||||
fp.Inv(z, z)
|
||||
fp.Mul(x, x, z)
|
||||
_ = fp.ToBytes(k[:], x)
|
||||
}
|
||||
|
||||
var lowOrderPoints = [3]fp.Elt{
|
||||
{ /* (0,_,1) point of order 2 on Curve448 */
|
||||
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
|
||||
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
|
||||
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
|
||||
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
|
||||
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
|
||||
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
|
||||
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
|
||||
},
|
||||
{ /* (1,_,1) a point of order 4 on the twist of Curve448 */
|
||||
0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
|
||||
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
|
||||
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
|
||||
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
|
||||
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
|
||||
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
|
||||
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
|
||||
},
|
||||
{ /* (-1,_,1) point of order 4 on Curve448 */
|
||||
0xfe, 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, 0xfe, 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,
|
||||
},
|
||||
}
|
||||
30
vendor/github.com/cloudflare/circl/dh/x448/curve_amd64.go
generated
vendored
Normal file
30
vendor/github.com/cloudflare/circl/dh/x448/curve_amd64.go
generated
vendored
Normal file
@ -0,0 +1,30 @@
|
||||
//go:build amd64 && !purego
|
||||
// +build amd64,!purego
|
||||
|
||||
package x448
|
||||
|
||||
import (
|
||||
fp "github.com/cloudflare/circl/math/fp448"
|
||||
"golang.org/x/sys/cpu"
|
||||
)
|
||||
|
||||
var hasBmi2Adx = cpu.X86.HasBMI2 && cpu.X86.HasADX
|
||||
|
||||
var _ = hasBmi2Adx
|
||||
|
||||
func double(x, z *fp.Elt) { doubleAmd64(x, z) }
|
||||
func diffAdd(w *[5]fp.Elt, b uint) { diffAddAmd64(w, b) }
|
||||
func ladderStep(w *[5]fp.Elt, b uint) { ladderStepAmd64(w, b) }
|
||||
func mulA24(z, x *fp.Elt) { mulA24Amd64(z, x) }
|
||||
|
||||
//go:noescape
|
||||
func doubleAmd64(x, z *fp.Elt)
|
||||
|
||||
//go:noescape
|
||||
func diffAddAmd64(w *[5]fp.Elt, b uint)
|
||||
|
||||
//go:noescape
|
||||
func ladderStepAmd64(w *[5]fp.Elt, b uint)
|
||||
|
||||
//go:noescape
|
||||
func mulA24Amd64(z, x *fp.Elt)
|
||||
111
vendor/github.com/cloudflare/circl/dh/x448/curve_amd64.h
generated
vendored
Normal file
111
vendor/github.com/cloudflare/circl/dh/x448/curve_amd64.h
generated
vendored
Normal file
@ -0,0 +1,111 @@
|
||||
#define ladderStepLeg \
|
||||
addSub(x2,z2) \
|
||||
addSub(x3,z3) \
|
||||
integerMulLeg(b0,x2,z3) \
|
||||
integerMulLeg(b1,x3,z2) \
|
||||
reduceFromDoubleLeg(t0,b0) \
|
||||
reduceFromDoubleLeg(t1,b1) \
|
||||
addSub(t0,t1) \
|
||||
cselect(x2,x3,regMove) \
|
||||
cselect(z2,z3,regMove) \
|
||||
integerSqrLeg(b0,t0) \
|
||||
integerSqrLeg(b1,t1) \
|
||||
reduceFromDoubleLeg(x3,b0) \
|
||||
reduceFromDoubleLeg(z3,b1) \
|
||||
integerMulLeg(b0,x1,z3) \
|
||||
reduceFromDoubleLeg(z3,b0) \
|
||||
integerSqrLeg(b0,x2) \
|
||||
integerSqrLeg(b1,z2) \
|
||||
reduceFromDoubleLeg(x2,b0) \
|
||||
reduceFromDoubleLeg(z2,b1) \
|
||||
subtraction(t0,x2,z2) \
|
||||
multiplyA24Leg(t1,t0) \
|
||||
additionLeg(t1,t1,z2) \
|
||||
integerMulLeg(b0,x2,z2) \
|
||||
integerMulLeg(b1,t0,t1) \
|
||||
reduceFromDoubleLeg(x2,b0) \
|
||||
reduceFromDoubleLeg(z2,b1)
|
||||
|
||||
#define ladderStepBmi2Adx \
|
||||
addSub(x2,z2) \
|
||||
addSub(x3,z3) \
|
||||
integerMulAdx(b0,x2,z3) \
|
||||
integerMulAdx(b1,x3,z2) \
|
||||
reduceFromDoubleAdx(t0,b0) \
|
||||
reduceFromDoubleAdx(t1,b1) \
|
||||
addSub(t0,t1) \
|
||||
cselect(x2,x3,regMove) \
|
||||
cselect(z2,z3,regMove) \
|
||||
integerSqrAdx(b0,t0) \
|
||||
integerSqrAdx(b1,t1) \
|
||||
reduceFromDoubleAdx(x3,b0) \
|
||||
reduceFromDoubleAdx(z3,b1) \
|
||||
integerMulAdx(b0,x1,z3) \
|
||||
reduceFromDoubleAdx(z3,b0) \
|
||||
integerSqrAdx(b0,x2) \
|
||||
integerSqrAdx(b1,z2) \
|
||||
reduceFromDoubleAdx(x2,b0) \
|
||||
reduceFromDoubleAdx(z2,b1) \
|
||||
subtraction(t0,x2,z2) \
|
||||
multiplyA24Adx(t1,t0) \
|
||||
additionAdx(t1,t1,z2) \
|
||||
integerMulAdx(b0,x2,z2) \
|
||||
integerMulAdx(b1,t0,t1) \
|
||||
reduceFromDoubleAdx(x2,b0) \
|
||||
reduceFromDoubleAdx(z2,b1)
|
||||
|
||||
#define difAddLeg \
|
||||
addSub(x1,z1) \
|
||||
integerMulLeg(b0,z1,ui) \
|
||||
reduceFromDoubleLeg(z1,b0) \
|
||||
addSub(x1,z1) \
|
||||
integerSqrLeg(b0,x1) \
|
||||
integerSqrLeg(b1,z1) \
|
||||
reduceFromDoubleLeg(x1,b0) \
|
||||
reduceFromDoubleLeg(z1,b1) \
|
||||
integerMulLeg(b0,x1,z2) \
|
||||
integerMulLeg(b1,z1,x2) \
|
||||
reduceFromDoubleLeg(x1,b0) \
|
||||
reduceFromDoubleLeg(z1,b1)
|
||||
|
||||
#define difAddBmi2Adx \
|
||||
addSub(x1,z1) \
|
||||
integerMulAdx(b0,z1,ui) \
|
||||
reduceFromDoubleAdx(z1,b0) \
|
||||
addSub(x1,z1) \
|
||||
integerSqrAdx(b0,x1) \
|
||||
integerSqrAdx(b1,z1) \
|
||||
reduceFromDoubleAdx(x1,b0) \
|
||||
reduceFromDoubleAdx(z1,b1) \
|
||||
integerMulAdx(b0,x1,z2) \
|
||||
integerMulAdx(b1,z1,x2) \
|
||||
reduceFromDoubleAdx(x1,b0) \
|
||||
reduceFromDoubleAdx(z1,b1)
|
||||
|
||||
#define doubleLeg \
|
||||
addSub(x1,z1) \
|
||||
integerSqrLeg(b0,x1) \
|
||||
integerSqrLeg(b1,z1) \
|
||||
reduceFromDoubleLeg(x1,b0) \
|
||||
reduceFromDoubleLeg(z1,b1) \
|
||||
subtraction(t0,x1,z1) \
|
||||
multiplyA24Leg(t1,t0) \
|
||||
additionLeg(t1,t1,z1) \
|
||||
integerMulLeg(b0,x1,z1) \
|
||||
integerMulLeg(b1,t0,t1) \
|
||||
reduceFromDoubleLeg(x1,b0) \
|
||||
reduceFromDoubleLeg(z1,b1)
|
||||
|
||||
#define doubleBmi2Adx \
|
||||
addSub(x1,z1) \
|
||||
integerSqrAdx(b0,x1) \
|
||||
integerSqrAdx(b1,z1) \
|
||||
reduceFromDoubleAdx(x1,b0) \
|
||||
reduceFromDoubleAdx(z1,b1) \
|
||||
subtraction(t0,x1,z1) \
|
||||
multiplyA24Adx(t1,t0) \
|
||||
additionAdx(t1,t1,z1) \
|
||||
integerMulAdx(b0,x1,z1) \
|
||||
integerMulAdx(b1,t0,t1) \
|
||||
reduceFromDoubleAdx(x1,b0) \
|
||||
reduceFromDoubleAdx(z1,b1)
|
||||
193
vendor/github.com/cloudflare/circl/dh/x448/curve_amd64.s
generated
vendored
Normal file
193
vendor/github.com/cloudflare/circl/dh/x448/curve_amd64.s
generated
vendored
Normal file
@ -0,0 +1,193 @@
|
||||
// +build amd64
|
||||
|
||||
#include "textflag.h"
|
||||
|
||||
// Depends on circl/math/fp448 package
|
||||
#include "../../math/fp448/fp_amd64.h"
|
||||
#include "curve_amd64.h"
|
||||
|
||||
// CTE_A24 is (A+2)/4 from Curve448
|
||||
#define CTE_A24 39082
|
||||
|
||||
#define Size 56
|
||||
|
||||
// multiplyA24Leg multiplies x times CTE_A24 and stores in z
|
||||
// Uses: AX, DX, R8-R15, FLAGS
|
||||
// Instr: x86_64, cmov, adx
|
||||
#define multiplyA24Leg(z,x) \
|
||||
MOVQ $CTE_A24, R15; \
|
||||
MOVQ 0+x, AX; MULQ R15; MOVQ AX, R8; ;;;;;;;;;;;; MOVQ DX, R9; \
|
||||
MOVQ 8+x, AX; MULQ R15; ADDQ AX, R9; ADCQ $0, DX; MOVQ DX, R10; \
|
||||
MOVQ 16+x, AX; MULQ R15; ADDQ AX, R10; ADCQ $0, DX; MOVQ DX, R11; \
|
||||
MOVQ 24+x, AX; MULQ R15; ADDQ AX, R11; ADCQ $0, DX; MOVQ DX, R12; \
|
||||
MOVQ 32+x, AX; MULQ R15; ADDQ AX, R12; ADCQ $0, DX; MOVQ DX, R13; \
|
||||
MOVQ 40+x, AX; MULQ R15; ADDQ AX, R13; ADCQ $0, DX; MOVQ DX, R14; \
|
||||
MOVQ 48+x, AX; MULQ R15; ADDQ AX, R14; ADCQ $0, DX; \
|
||||
MOVQ DX, AX; \
|
||||
SHLQ $32, AX; \
|
||||
ADDQ DX, R8; MOVQ $0, DX; \
|
||||
ADCQ $0, R9; \
|
||||
ADCQ $0, R10; \
|
||||
ADCQ AX, R11; \
|
||||
ADCQ $0, R12; \
|
||||
ADCQ $0, R13; \
|
||||
ADCQ $0, R14; \
|
||||
ADCQ $0, DX; \
|
||||
MOVQ DX, AX; \
|
||||
SHLQ $32, AX; \
|
||||
ADDQ DX, R8; \
|
||||
ADCQ $0, R9; \
|
||||
ADCQ $0, R10; \
|
||||
ADCQ AX, R11; \
|
||||
ADCQ $0, R12; \
|
||||
ADCQ $0, R13; \
|
||||
ADCQ $0, R14; \
|
||||
MOVQ R8, 0+z; \
|
||||
MOVQ R9, 8+z; \
|
||||
MOVQ R10, 16+z; \
|
||||
MOVQ R11, 24+z; \
|
||||
MOVQ R12, 32+z; \
|
||||
MOVQ R13, 40+z; \
|
||||
MOVQ R14, 48+z;
|
||||
|
||||
// multiplyA24Adx multiplies x times CTE_A24 and stores in z
|
||||
// Uses: AX, DX, R8-R14, FLAGS
|
||||
// Instr: x86_64, bmi2
|
||||
#define multiplyA24Adx(z,x) \
|
||||
MOVQ $CTE_A24, DX; \
|
||||
MULXQ 0+x, R8, R9; \
|
||||
MULXQ 8+x, AX, R10; ADDQ AX, R9; \
|
||||
MULXQ 16+x, AX, R11; ADCQ AX, R10; \
|
||||
MULXQ 24+x, AX, R12; ADCQ AX, R11; \
|
||||
MULXQ 32+x, AX, R13; ADCQ AX, R12; \
|
||||
MULXQ 40+x, AX, R14; ADCQ AX, R13; \
|
||||
MULXQ 48+x, AX, DX; ADCQ AX, R14; \
|
||||
;;;;;;;;;;;;;;;;;;;; ADCQ $0, DX; \
|
||||
MOVQ DX, AX; \
|
||||
SHLQ $32, AX; \
|
||||
ADDQ DX, R8; MOVQ $0, DX; \
|
||||
ADCQ $0, R9; \
|
||||
ADCQ $0, R10; \
|
||||
ADCQ AX, R11; \
|
||||
ADCQ $0, R12; \
|
||||
ADCQ $0, R13; \
|
||||
ADCQ $0, R14; \
|
||||
ADCQ $0, DX; \
|
||||
MOVQ DX, AX; \
|
||||
SHLQ $32, AX; \
|
||||
ADDQ DX, R8; \
|
||||
ADCQ $0, R9; \
|
||||
ADCQ $0, R10; \
|
||||
ADCQ AX, R11; \
|
||||
ADCQ $0, R12; \
|
||||
ADCQ $0, R13; \
|
||||
ADCQ $0, R14; \
|
||||
MOVQ R8, 0+z; \
|
||||
MOVQ R9, 8+z; \
|
||||
MOVQ R10, 16+z; \
|
||||
MOVQ R11, 24+z; \
|
||||
MOVQ R12, 32+z; \
|
||||
MOVQ R13, 40+z; \
|
||||
MOVQ R14, 48+z;
|
||||
|
||||
#define mulA24Legacy \
|
||||
multiplyA24Leg(0(DI),0(SI))
|
||||
#define mulA24Bmi2Adx \
|
||||
multiplyA24Adx(0(DI),0(SI))
|
||||
|
||||
// func mulA24Amd64(z, x *fp448.Elt)
|
||||
TEXT ·mulA24Amd64(SB),NOSPLIT,$0-16
|
||||
MOVQ z+0(FP), DI
|
||||
MOVQ x+8(FP), SI
|
||||
CHECK_BMI2ADX(LMA24, mulA24Legacy, mulA24Bmi2Adx)
|
||||
|
||||
// func ladderStepAmd64(w *[5]fp448.Elt, b uint)
|
||||
// ladderStepAmd64 calculates a point addition and doubling as follows:
|
||||
// (x2,z2) = 2*(x2,z2) and (x3,z3) = (x2,z2)+(x3,z3) using as a difference (x1,-).
|
||||
// w = {x1,x2,z2,x3,z4} are five fp255.Elt of 56 bytes.
|
||||
// stack = (t0,t1) are two fp.Elt of fp.Size bytes, and
|
||||
// (b0,b1) are two-double precision fp.Elt of 2*fp.Size bytes.
|
||||
TEXT ·ladderStepAmd64(SB),NOSPLIT,$336-16
|
||||
// Parameters
|
||||
#define regWork DI
|
||||
#define regMove SI
|
||||
#define x1 0*Size(regWork)
|
||||
#define x2 1*Size(regWork)
|
||||
#define z2 2*Size(regWork)
|
||||
#define x3 3*Size(regWork)
|
||||
#define z3 4*Size(regWork)
|
||||
// Local variables
|
||||
#define t0 0*Size(SP)
|
||||
#define t1 1*Size(SP)
|
||||
#define b0 2*Size(SP)
|
||||
#define b1 4*Size(SP)
|
||||
MOVQ w+0(FP), regWork
|
||||
MOVQ b+8(FP), regMove
|
||||
CHECK_BMI2ADX(LLADSTEP, ladderStepLeg, ladderStepBmi2Adx)
|
||||
#undef regWork
|
||||
#undef regMove
|
||||
#undef x1
|
||||
#undef x2
|
||||
#undef z2
|
||||
#undef x3
|
||||
#undef z3
|
||||
#undef t0
|
||||
#undef t1
|
||||
#undef b0
|
||||
#undef b1
|
||||
|
||||
// func diffAddAmd64(work *[5]fp.Elt, swap uint)
|
||||
// diffAddAmd64 calculates a differential point addition using a precomputed point.
|
||||
// (x1,z1) = (x1,z1)+(mu) using a difference point (x2,z2)
|
||||
// work = {mu,x1,z1,x2,z2} are five fp448.Elt of 56 bytes, and
|
||||
// stack = (b0,b1) are two-double precision fp.Elt of 2*fp.Size bytes.
|
||||
// This is Equation 7 at https://eprint.iacr.org/2017/264.
|
||||
TEXT ·diffAddAmd64(SB),NOSPLIT,$224-16
|
||||
// Parameters
|
||||
#define regWork DI
|
||||
#define regSwap SI
|
||||
#define ui 0*Size(regWork)
|
||||
#define x1 1*Size(regWork)
|
||||
#define z1 2*Size(regWork)
|
||||
#define x2 3*Size(regWork)
|
||||
#define z2 4*Size(regWork)
|
||||
// Local variables
|
||||
#define b0 0*Size(SP)
|
||||
#define b1 2*Size(SP)
|
||||
MOVQ w+0(FP), regWork
|
||||
MOVQ b+8(FP), regSwap
|
||||
cswap(x1,x2,regSwap)
|
||||
cswap(z1,z2,regSwap)
|
||||
CHECK_BMI2ADX(LDIFADD, difAddLeg, difAddBmi2Adx)
|
||||
#undef regWork
|
||||
#undef regSwap
|
||||
#undef ui
|
||||
#undef x1
|
||||
#undef z1
|
||||
#undef x2
|
||||
#undef z2
|
||||
#undef b0
|
||||
#undef b1
|
||||
|
||||
// func doubleAmd64(x, z *fp448.Elt)
|
||||
// doubleAmd64 calculates a point doubling (x1,z1) = 2*(x1,z1).
|
||||
// stack = (t0,t1) are two fp.Elt of fp.Size bytes, and
|
||||
// (b0,b1) are two-double precision fp.Elt of 2*fp.Size bytes.
|
||||
TEXT ·doubleAmd64(SB),NOSPLIT,$336-16
|
||||
// Parameters
|
||||
#define x1 0(DI)
|
||||
#define z1 0(SI)
|
||||
// Local variables
|
||||
#define t0 0*Size(SP)
|
||||
#define t1 1*Size(SP)
|
||||
#define b0 2*Size(SP)
|
||||
#define b1 4*Size(SP)
|
||||
MOVQ x+0(FP), DI
|
||||
MOVQ z+8(FP), SI
|
||||
CHECK_BMI2ADX(LDOUB,doubleLeg,doubleBmi2Adx)
|
||||
#undef x1
|
||||
#undef z1
|
||||
#undef t0
|
||||
#undef t1
|
||||
#undef b0
|
||||
#undef b1
|
||||
100
vendor/github.com/cloudflare/circl/dh/x448/curve_generic.go
generated
vendored
Normal file
100
vendor/github.com/cloudflare/circl/dh/x448/curve_generic.go
generated
vendored
Normal file
@ -0,0 +1,100 @@
|
||||
package x448
|
||||
|
||||
import (
|
||||
"encoding/binary"
|
||||
"math/bits"
|
||||
|
||||
"github.com/cloudflare/circl/math/fp448"
|
||||
)
|
||||
|
||||
func doubleGeneric(x, z *fp448.Elt) {
|
||||
t0, t1 := &fp448.Elt{}, &fp448.Elt{}
|
||||
fp448.AddSub(x, z)
|
||||
fp448.Sqr(x, x)
|
||||
fp448.Sqr(z, z)
|
||||
fp448.Sub(t0, x, z)
|
||||
mulA24Generic(t1, t0)
|
||||
fp448.Add(t1, t1, z)
|
||||
fp448.Mul(x, x, z)
|
||||
fp448.Mul(z, t0, t1)
|
||||
}
|
||||
|
||||
func diffAddGeneric(w *[5]fp448.Elt, b uint) {
|
||||
mu, x1, z1, x2, z2 := &w[0], &w[1], &w[2], &w[3], &w[4]
|
||||
fp448.Cswap(x1, x2, b)
|
||||
fp448.Cswap(z1, z2, b)
|
||||
fp448.AddSub(x1, z1)
|
||||
fp448.Mul(z1, z1, mu)
|
||||
fp448.AddSub(x1, z1)
|
||||
fp448.Sqr(x1, x1)
|
||||
fp448.Sqr(z1, z1)
|
||||
fp448.Mul(x1, x1, z2)
|
||||
fp448.Mul(z1, z1, x2)
|
||||
}
|
||||
|
||||
func ladderStepGeneric(w *[5]fp448.Elt, b uint) {
|
||||
x1, x2, z2, x3, z3 := &w[0], &w[1], &w[2], &w[3], &w[4]
|
||||
t0 := &fp448.Elt{}
|
||||
t1 := &fp448.Elt{}
|
||||
fp448.AddSub(x2, z2)
|
||||
fp448.AddSub(x3, z3)
|
||||
fp448.Mul(t0, x2, z3)
|
||||
fp448.Mul(t1, x3, z2)
|
||||
fp448.AddSub(t0, t1)
|
||||
fp448.Cmov(x2, x3, b)
|
||||
fp448.Cmov(z2, z3, b)
|
||||
fp448.Sqr(x3, t0)
|
||||
fp448.Sqr(z3, t1)
|
||||
fp448.Mul(z3, x1, z3)
|
||||
fp448.Sqr(x2, x2)
|
||||
fp448.Sqr(z2, z2)
|
||||
fp448.Sub(t0, x2, z2)
|
||||
mulA24Generic(t1, t0)
|
||||
fp448.Add(t1, t1, z2)
|
||||
fp448.Mul(x2, x2, z2)
|
||||
fp448.Mul(z2, t0, t1)
|
||||
}
|
||||
|
||||
func mulA24Generic(z, x *fp448.Elt) {
|
||||
const A24 = 39082
|
||||
const n = 8
|
||||
var xx [7]uint64
|
||||
for i := range xx {
|
||||
xx[i] = binary.LittleEndian.Uint64(x[i*n : (i+1)*n])
|
||||
}
|
||||
h0, l0 := bits.Mul64(xx[0], A24)
|
||||
h1, l1 := bits.Mul64(xx[1], A24)
|
||||
h2, l2 := bits.Mul64(xx[2], A24)
|
||||
h3, l3 := bits.Mul64(xx[3], A24)
|
||||
h4, l4 := bits.Mul64(xx[4], A24)
|
||||
h5, l5 := bits.Mul64(xx[5], A24)
|
||||
h6, l6 := bits.Mul64(xx[6], A24)
|
||||
|
||||
l1, c0 := bits.Add64(h0, l1, 0)
|
||||
l2, c1 := bits.Add64(h1, l2, c0)
|
||||
l3, c2 := bits.Add64(h2, l3, c1)
|
||||
l4, c3 := bits.Add64(h3, l4, c2)
|
||||
l5, c4 := bits.Add64(h4, l5, c3)
|
||||
l6, c5 := bits.Add64(h5, l6, c4)
|
||||
l7, _ := bits.Add64(h6, 0, c5)
|
||||
|
||||
l0, c0 = bits.Add64(l0, l7, 0)
|
||||
l1, c1 = bits.Add64(l1, 0, c0)
|
||||
l2, c2 = bits.Add64(l2, 0, c1)
|
||||
l3, c3 = bits.Add64(l3, l7<<32, c2)
|
||||
l4, c4 = bits.Add64(l4, 0, c3)
|
||||
l5, c5 = bits.Add64(l5, 0, c4)
|
||||
l6, l7 = bits.Add64(l6, 0, c5)
|
||||
|
||||
xx[0], c0 = bits.Add64(l0, l7, 0)
|
||||
xx[1], c1 = bits.Add64(l1, 0, c0)
|
||||
xx[2], c2 = bits.Add64(l2, 0, c1)
|
||||
xx[3], c3 = bits.Add64(l3, l7<<32, c2)
|
||||
xx[4], c4 = bits.Add64(l4, 0, c3)
|
||||
xx[5], c5 = bits.Add64(l5, 0, c4)
|
||||
xx[6], _ = bits.Add64(l6, 0, c5)
|
||||
|
||||
for i := range xx {
|
||||
binary.LittleEndian.PutUint64(z[i*n:(i+1)*n], xx[i])
|
||||
}
|
||||
}
|
||||
11
vendor/github.com/cloudflare/circl/dh/x448/curve_noasm.go
generated
vendored
Normal file
11
vendor/github.com/cloudflare/circl/dh/x448/curve_noasm.go
generated
vendored
Normal file
@ -0,0 +1,11 @@
|
||||
//go:build !amd64 || purego
|
||||
// +build !amd64 purego
|
||||
|
||||
package x448
|
||||
|
||||
import fp "github.com/cloudflare/circl/math/fp448"
|
||||
|
||||
func double(x, z *fp.Elt) { doubleGeneric(x, z) }
|
||||
func diffAdd(w *[5]fp.Elt, b uint) { diffAddGeneric(w, b) }
|
||||
func ladderStep(w *[5]fp.Elt, b uint) { ladderStepGeneric(w, b) }
|
||||
func mulA24(z, x *fp.Elt) { mulA24Generic(z, x) }
|
||||
19
vendor/github.com/cloudflare/circl/dh/x448/doc.go
generated
vendored
Normal file
19
vendor/github.com/cloudflare/circl/dh/x448/doc.go
generated
vendored
Normal file
@ -0,0 +1,19 @@
|
||||
/*
|
||||
Package x448 provides Diffie-Hellman functions as specified in RFC-7748.
|
||||
|
||||
Validation of public keys.
|
||||
|
||||
The Diffie-Hellman function, as described in RFC-7748 [1], works for any
|
||||
public key. However, if a different protocol requires contributory
|
||||
behaviour [2,3], then the public keys must be validated against low-order
|
||||
points [3,4]. To do that, the Shared function performs this validation
|
||||
internally and returns false when the public key is invalid (i.e., it
|
||||
is a low-order point).
|
||||
|
||||
References:
|
||||
- [1] RFC7748 by Langley, Hamburg, Turner (https://rfc-editor.org/rfc/rfc7748.txt)
|
||||
- [2] Curve25519 by Bernstein (https://cr.yp.to/ecdh.html)
|
||||
- [3] Bernstein (https://cr.yp.to/ecdh.html#validate)
|
||||
- [4] Cremers&Jackson (https://eprint.iacr.org/2019/526)
|
||||
*/
|
||||
package x448
|
||||
46
vendor/github.com/cloudflare/circl/dh/x448/key.go
generated
vendored
Normal file
46
vendor/github.com/cloudflare/circl/dh/x448/key.go
generated
vendored
Normal file
@ -0,0 +1,46 @@
|
||||
package x448
|
||||
|
||||
import (
|
||||
"crypto/subtle"
|
||||
|
||||
fp "github.com/cloudflare/circl/math/fp448"
|
||||
)
|
||||
|
||||
// Size is the length in bytes of a X448 key.
|
||||
const Size = 56
|
||||
|
||||
// Key represents a X448 key.
|
||||
type Key [Size]byte
|
||||
|
||||
func (k *Key) clamp(in *Key) *Key {
|
||||
*k = *in
|
||||
k[0] &= 252
|
||||
k[55] |= 128
|
||||
return k
|
||||
}
|
||||
|
||||
// isValidPubKey verifies if the public key is not a low-order point.
|
||||
func (k *Key) isValidPubKey() bool {
|
||||
fp.Modp((*fp.Elt)(k))
|
||||
var isLowOrder int
|
||||
for _, P := range lowOrderPoints {
|
||||
isLowOrder |= subtle.ConstantTimeCompare(P[:], k[:])
|
||||
}
|
||||
return isLowOrder == 0
|
||||
}
|
||||
|
||||
// KeyGen obtains a public key given a secret key.
|
||||
func KeyGen(public, secret *Key) {
|
||||
ladderJoye(public.clamp(secret))
|
||||
}
|
||||
|
||||
// Shared calculates Alice's shared key from Alice's secret key and Bob's
|
||||
// public key returning true on success. A failure case happens when the public
|
||||
// key is a low-order point, thus the shared key is all-zeros and the function
|
||||
// returns false.
|
||||
func Shared(shared, secret, public *Key) bool {
|
||||
validPk := *public
|
||||
ok := validPk.isValidPubKey()
|
||||
ladderMontgomery(shared.clamp(secret), &validPk)
|
||||
return ok
|
||||
}
|
||||
460
vendor/github.com/cloudflare/circl/dh/x448/table.go
generated
vendored
Normal file
460
vendor/github.com/cloudflare/circl/dh/x448/table.go
generated
vendored
Normal file
@ -0,0 +1,460 @@
|
||||
package x448
|
||||
|
||||
import fp "github.com/cloudflare/circl/math/fp448"
|
||||
|
||||
// tableGenerator contains the set of points:
|
||||
//
|
||||
// t[i] = (xi+1)/(xi-1),
|
||||
//
|
||||
// where (xi,yi) = 2^iG and G is the generator point
|
||||
// Size = (448)*(448/8) = 25088 bytes.
|
||||
var tableGenerator = [448 * fp.Size]byte{
|
||||
/* (2^ 0)P */ 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x80, 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, 0x7f,
|
||||
/* (2^ 1)P */ 0x37, 0xfa, 0xaa, 0x0d, 0x86, 0xa6, 0x24, 0xe9, 0x6c, 0x95, 0x08, 0x34, 0xba, 0x1a, 0x81, 0x3a, 0xae, 0x01, 0xa5, 0xa7, 0x05, 0x85, 0x96, 0x00, 0x06, 0x5a, 0xd7, 0xff, 0xee, 0x8e, 0x8f, 0x94, 0xd2, 0xdc, 0xd7, 0xfc, 0xe7, 0xe5, 0x99, 0x1d, 0x05, 0x46, 0x43, 0xe8, 0xbc, 0x12, 0xb7, 0xeb, 0x30, 0x5e, 0x7a, 0x85, 0x68, 0xed, 0x9d, 0x28,
|
||||
/* (2^ 2)P */ 0xf1, 0x7d, 0x08, 0x2b, 0x32, 0x4a, 0x62, 0x80, 0x36, 0xe7, 0xa4, 0x76, 0x5a, 0x2a, 0x1e, 0xf7, 0x9e, 0x3c, 0x40, 0x46, 0x9a, 0x1b, 0x61, 0xc1, 0xbf, 0x1a, 0x1b, 0xae, 0x91, 0x80, 0xa3, 0x76, 0x6c, 0xd4, 0x8f, 0xa4, 0xee, 0x26, 0x39, 0x23, 0xa4, 0x80, 0xf4, 0x66, 0x92, 0xe4, 0xe1, 0x18, 0x76, 0xc5, 0xe2, 0x19, 0x87, 0xd5, 0xc3, 0xe8,
|
||||
/* (2^ 3)P */ 0xfb, 0xc9, 0xf0, 0x07, 0xf2, 0x93, 0xd8, 0x50, 0x36, 0xed, 0xfb, 0xbd, 0xb2, 0xd3, 0xfc, 0xdf, 0xd5, 0x2a, 0x6e, 0x26, 0x09, 0xce, 0xd4, 0x07, 0x64, 0x9f, 0x40, 0x74, 0xad, 0x98, 0x2f, 0x1c, 0xb6, 0xdc, 0x2d, 0x42, 0xff, 0xbf, 0x97, 0xd8, 0xdb, 0xef, 0x99, 0xca, 0x73, 0x99, 0x1a, 0x04, 0x3b, 0x56, 0x2c, 0x1f, 0x87, 0x9d, 0x9f, 0x03,
|
||||
/* (2^ 4)P */ 0x4c, 0x35, 0x97, 0xf7, 0x81, 0x2c, 0x84, 0xa6, 0xe0, 0xcb, 0xce, 0x37, 0x4c, 0x21, 0x1c, 0x67, 0xfa, 0xab, 0x18, 0x4d, 0xef, 0xd0, 0xf0, 0x44, 0xa9, 0xfb, 0xc0, 0x8e, 0xda, 0x57, 0xa1, 0xd8, 0xeb, 0x87, 0xf4, 0x17, 0xea, 0x66, 0x0f, 0x16, 0xea, 0xcd, 0x5f, 0x3e, 0x88, 0xea, 0x09, 0x68, 0x40, 0xdf, 0x43, 0xcc, 0x54, 0x61, 0x58, 0xaa,
|
||||
/* (2^ 5)P */ 0x8d, 0xe7, 0x59, 0xd7, 0x5e, 0x63, 0x37, 0xa7, 0x3f, 0xd1, 0x49, 0x85, 0x01, 0xdd, 0x5e, 0xb3, 0xe6, 0x29, 0xcb, 0x25, 0x93, 0xdd, 0x08, 0x96, 0x83, 0x52, 0x76, 0x85, 0xf5, 0x5d, 0x02, 0xbf, 0xe9, 0x6d, 0x15, 0x27, 0xc1, 0x09, 0xd1, 0x14, 0x4d, 0x6e, 0xe8, 0xaf, 0x59, 0x58, 0x34, 0x9d, 0x2a, 0x99, 0x85, 0x26, 0xbe, 0x4b, 0x1e, 0xb9,
|
||||
/* (2^ 6)P */ 0x8d, 0xce, 0x94, 0xe2, 0x18, 0x56, 0x0d, 0x82, 0x8e, 0xdf, 0x85, 0x01, 0x8f, 0x93, 0x3c, 0xc6, 0xbd, 0x61, 0xfb, 0xf4, 0x22, 0xc5, 0x16, 0x87, 0xd1, 0xb1, 0x9e, 0x09, 0xc5, 0x83, 0x2e, 0x4a, 0x07, 0x88, 0xee, 0xe0, 0x29, 0x8d, 0x2e, 0x1f, 0x88, 0xad, 0xfd, 0x18, 0x93, 0xb7, 0xed, 0x42, 0x86, 0x78, 0xf0, 0xb8, 0x70, 0xbe, 0x01, 0x67,
|
||||
/* (2^ 7)P */ 0xdf, 0x62, 0x2d, 0x94, 0xc7, 0x35, 0x23, 0xda, 0x27, 0xbb, 0x2b, 0xdb, 0x30, 0x80, 0x68, 0x16, 0xa3, 0xae, 0xd7, 0xd2, 0xa7, 0x7c, 0xbf, 0x6a, 0x1d, 0x83, 0xde, 0x96, 0x0a, 0x43, 0xb6, 0x30, 0x37, 0xd6, 0xee, 0x63, 0x59, 0x9a, 0xbf, 0xa3, 0x30, 0x6c, 0xaf, 0x0c, 0xee, 0x3d, 0xcb, 0x35, 0x4b, 0x55, 0x5f, 0x84, 0x85, 0xcb, 0x4f, 0x1e,
|
||||
/* (2^ 8)P */ 0x9d, 0x04, 0x68, 0x89, 0xa4, 0xa9, 0x0d, 0x87, 0xc1, 0x70, 0xf1, 0xeb, 0xfb, 0x47, 0x0a, 0xf0, 0xde, 0x67, 0xb7, 0x94, 0xcd, 0x36, 0x43, 0xa5, 0x49, 0x43, 0x67, 0xc3, 0xee, 0x3c, 0x6b, 0xec, 0xd0, 0x1a, 0xf4, 0xad, 0xef, 0x06, 0x4a, 0xe8, 0x46, 0x24, 0xd7, 0x93, 0xbf, 0xf0, 0xe3, 0x81, 0x61, 0xec, 0xea, 0x64, 0xfe, 0x67, 0xeb, 0xc7,
|
||||
/* (2^ 9)P */ 0x95, 0x45, 0x79, 0xcf, 0x2c, 0xfd, 0x9b, 0xfe, 0x84, 0x46, 0x4b, 0x8f, 0xa1, 0xcf, 0xc3, 0x04, 0x94, 0x78, 0xdb, 0xc9, 0xa6, 0x01, 0x75, 0xa4, 0xb4, 0x93, 0x72, 0x43, 0xa7, 0x7d, 0xda, 0x31, 0x38, 0x54, 0xab, 0x4e, 0x3f, 0x89, 0xa6, 0xab, 0x57, 0xc0, 0x16, 0x65, 0xdb, 0x92, 0x96, 0xe4, 0xc8, 0xae, 0xe7, 0x4c, 0x7a, 0xeb, 0xbb, 0x5a,
|
||||
/* (2^ 10)P */ 0xbe, 0xfe, 0x86, 0xc3, 0x97, 0xe0, 0x6a, 0x18, 0x20, 0x21, 0xca, 0x22, 0x55, 0xa1, 0xeb, 0xf5, 0x74, 0xe5, 0xc9, 0x59, 0xa7, 0x92, 0x65, 0x15, 0x08, 0x71, 0xd1, 0x09, 0x7e, 0x83, 0xfc, 0xbc, 0x5a, 0x93, 0x38, 0x0d, 0x43, 0x42, 0xfd, 0x76, 0x30, 0xe8, 0x63, 0x60, 0x09, 0x8d, 0x6c, 0xd3, 0xf8, 0x56, 0x3d, 0x68, 0x47, 0xab, 0xa0, 0x1d,
|
||||
/* (2^ 11)P */ 0x38, 0x50, 0x1c, 0xb1, 0xac, 0x88, 0x8f, 0x38, 0xe3, 0x69, 0xe6, 0xfc, 0x4f, 0x8f, 0xe1, 0x9b, 0xb1, 0x1a, 0x09, 0x39, 0x19, 0xdf, 0xcd, 0x98, 0x7b, 0x64, 0x42, 0xf6, 0x11, 0xea, 0xc7, 0xe8, 0x92, 0x65, 0x00, 0x2c, 0x75, 0xb5, 0x94, 0x1e, 0x5b, 0xa6, 0x66, 0x81, 0x77, 0xf3, 0x39, 0x94, 0xac, 0xbd, 0xe4, 0x2a, 0x66, 0x84, 0x9c, 0x60,
|
||||
/* (2^ 12)P */ 0xb5, 0xb6, 0xd9, 0x03, 0x67, 0xa4, 0xa8, 0x0a, 0x4a, 0x2b, 0x9d, 0xfa, 0x13, 0xe1, 0x99, 0x25, 0x4a, 0x5c, 0x67, 0xb9, 0xb2, 0xb7, 0xdd, 0x1e, 0xaf, 0xeb, 0x63, 0x41, 0xb6, 0xb9, 0xa0, 0x87, 0x0a, 0xe0, 0x06, 0x07, 0xaa, 0x97, 0xf8, 0xf9, 0x38, 0x4f, 0xdf, 0x0c, 0x40, 0x7c, 0xc3, 0x98, 0xa9, 0x74, 0xf1, 0x5d, 0xda, 0xd1, 0xc0, 0x0a,
|
||||
/* (2^ 13)P */ 0xf2, 0x0a, 0xab, 0xab, 0x94, 0x50, 0xf0, 0xa3, 0x6f, 0xc6, 0x66, 0xba, 0xa6, 0xdc, 0x44, 0xdd, 0xd6, 0x08, 0xf4, 0xd3, 0xed, 0xb1, 0x40, 0x93, 0xee, 0xf6, 0xb8, 0x8e, 0xb4, 0x7c, 0xb9, 0x82, 0xc9, 0x9d, 0x45, 0x3b, 0x8e, 0x10, 0xcb, 0x70, 0x1e, 0xba, 0x3c, 0x62, 0x50, 0xda, 0xa9, 0x93, 0xb5, 0xd7, 0xd0, 0x6f, 0x29, 0x52, 0x95, 0xae,
|
||||
/* (2^ 14)P */ 0x14, 0x68, 0x69, 0x23, 0xa8, 0x44, 0x87, 0x9e, 0x22, 0x91, 0xe8, 0x92, 0xdf, 0xf7, 0xae, 0xba, 0x1c, 0x96, 0xe1, 0xc3, 0x94, 0xed, 0x6c, 0x95, 0xae, 0x96, 0xa7, 0x15, 0x9f, 0xf1, 0x17, 0x11, 0x92, 0x42, 0xd5, 0xcd, 0x18, 0xe7, 0xa9, 0xb5, 0x2f, 0xcd, 0xde, 0x6c, 0xc9, 0x7d, 0xfc, 0x7e, 0xbd, 0x7f, 0x10, 0x3d, 0x01, 0x00, 0x8d, 0x95,
|
||||
/* (2^ 15)P */ 0x3b, 0x76, 0x72, 0xae, 0xaf, 0x84, 0xf2, 0xf7, 0xd1, 0x6d, 0x13, 0x9c, 0x47, 0xe1, 0xb7, 0xa3, 0x19, 0x16, 0xee, 0x75, 0x45, 0xf6, 0x1a, 0x7b, 0x78, 0x49, 0x79, 0x05, 0x86, 0xf0, 0x7f, 0x9f, 0xfc, 0xc4, 0xbd, 0x86, 0xf3, 0x41, 0xa7, 0xfe, 0x01, 0xd5, 0x67, 0x16, 0x10, 0x5b, 0xa5, 0x16, 0xf3, 0x7f, 0x60, 0xce, 0xd2, 0x0c, 0x8e, 0x4b,
|
||||
/* (2^ 16)P */ 0x4a, 0x07, 0x99, 0x4a, 0x0f, 0x74, 0x91, 0x14, 0x68, 0xb9, 0x48, 0xb7, 0x44, 0x77, 0x9b, 0x4a, 0xe0, 0x68, 0x0e, 0x43, 0x4d, 0x98, 0x98, 0xbf, 0xa8, 0x3a, 0xb7, 0x6d, 0x2a, 0x9a, 0x77, 0x5f, 0x62, 0xf5, 0x6b, 0x4a, 0xb7, 0x7d, 0xe5, 0x09, 0x6b, 0xc0, 0x8b, 0x9c, 0x88, 0x37, 0x33, 0xf2, 0x41, 0xac, 0x22, 0x1f, 0xcf, 0x3b, 0x82, 0x34,
|
||||
/* (2^ 17)P */ 0x00, 0xc3, 0x78, 0x42, 0x32, 0x2e, 0xdc, 0xda, 0xb1, 0x96, 0x21, 0xa4, 0xe4, 0xbb, 0xe9, 0x9d, 0xbb, 0x0f, 0x93, 0xed, 0x26, 0x3d, 0xb5, 0xdb, 0x94, 0x31, 0x37, 0x07, 0xa2, 0xb2, 0xd5, 0x99, 0x0d, 0x93, 0xe1, 0xce, 0x3f, 0x0b, 0x96, 0x82, 0x47, 0xfe, 0x60, 0x6f, 0x8f, 0x61, 0x88, 0xd7, 0x05, 0x95, 0x0b, 0x46, 0x06, 0xb7, 0x32, 0x06,
|
||||
/* (2^ 18)P */ 0x44, 0xf5, 0x34, 0xdf, 0x2f, 0x9c, 0x5d, 0x9f, 0x53, 0x5c, 0x42, 0x8f, 0xc9, 0xdc, 0xd8, 0x40, 0xa2, 0xe7, 0x6a, 0x4a, 0x05, 0xf7, 0x86, 0x77, 0x2b, 0xae, 0x37, 0xed, 0x48, 0xfb, 0xf7, 0x62, 0x7c, 0x17, 0x59, 0x92, 0x41, 0x61, 0x93, 0x38, 0x30, 0xd1, 0xef, 0x54, 0x54, 0x03, 0x17, 0x57, 0x91, 0x15, 0x11, 0x33, 0xb5, 0xfa, 0xfb, 0x17,
|
||||
/* (2^ 19)P */ 0x29, 0xbb, 0xd4, 0xb4, 0x9c, 0xf1, 0x72, 0x94, 0xce, 0x6a, 0x29, 0xa8, 0x89, 0x18, 0x19, 0xf7, 0xb7, 0xcc, 0xee, 0x9a, 0x02, 0xe3, 0xc0, 0xb1, 0xe0, 0xee, 0x83, 0x78, 0xb4, 0x9e, 0x07, 0x87, 0xdf, 0xb0, 0x82, 0x26, 0x4e, 0xa4, 0x0c, 0x33, 0xaf, 0x40, 0x59, 0xb6, 0xdd, 0x52, 0x45, 0xf0, 0xb4, 0xf6, 0xe8, 0x4e, 0x4e, 0x79, 0x1a, 0x5d,
|
||||
/* (2^ 20)P */ 0x27, 0x33, 0x4d, 0x4c, 0x6b, 0x4f, 0x75, 0xb1, 0xbc, 0x1f, 0xab, 0x5b, 0x2b, 0xf0, 0x1c, 0x57, 0x86, 0xdd, 0xfd, 0x60, 0xb0, 0x8c, 0xe7, 0x9a, 0xe5, 0x5c, 0xeb, 0x11, 0x3a, 0xda, 0x22, 0x25, 0x99, 0x06, 0x8d, 0xf4, 0xaf, 0x29, 0x7a, 0xc9, 0xe5, 0xd2, 0x16, 0x9e, 0xd4, 0x63, 0x1d, 0x64, 0xa6, 0x47, 0x96, 0x37, 0x6f, 0x93, 0x2c, 0xcc,
|
||||
/* (2^ 21)P */ 0xc1, 0x94, 0x74, 0x86, 0x75, 0xf2, 0x91, 0x58, 0x23, 0x85, 0x63, 0x76, 0x54, 0xc7, 0xb4, 0x8c, 0xbc, 0x4e, 0xc4, 0xa7, 0xba, 0xa0, 0x55, 0x26, 0x71, 0xd5, 0x33, 0x72, 0xc9, 0xad, 0x1e, 0xf9, 0x5d, 0x78, 0x70, 0x93, 0x4e, 0x85, 0xfc, 0x39, 0x06, 0x73, 0x76, 0xff, 0xe8, 0x64, 0x69, 0x42, 0x45, 0xb2, 0x69, 0xb5, 0x32, 0xe7, 0x2c, 0xde,
|
||||
/* (2^ 22)P */ 0xde, 0x16, 0xd8, 0x33, 0x49, 0x32, 0xe9, 0x0e, 0x3a, 0x60, 0xee, 0x2e, 0x24, 0x75, 0xe3, 0x9c, 0x92, 0x07, 0xdb, 0xad, 0x92, 0xf5, 0x11, 0xdf, 0xdb, 0xb0, 0x17, 0x5c, 0xd6, 0x1a, 0x70, 0x00, 0xb7, 0xe2, 0x18, 0xec, 0xdc, 0xc2, 0x02, 0x93, 0xb3, 0xc8, 0x3f, 0x4f, 0x1b, 0x96, 0xe6, 0x33, 0x8c, 0xfb, 0xcc, 0xa5, 0x4e, 0xe8, 0xe7, 0x11,
|
||||
/* (2^ 23)P */ 0x05, 0x7a, 0x74, 0x52, 0xf8, 0xdf, 0x0d, 0x7c, 0x6a, 0x1a, 0x4e, 0x9a, 0x02, 0x1d, 0xae, 0x77, 0xf8, 0x8e, 0xf9, 0xa2, 0x38, 0x54, 0x50, 0xb2, 0x2c, 0x08, 0x9d, 0x9b, 0x9f, 0xfb, 0x2b, 0x06, 0xde, 0x9d, 0xc2, 0x03, 0x0b, 0x22, 0x2b, 0x10, 0x5b, 0x3a, 0x73, 0x29, 0x8e, 0x3e, 0x37, 0x08, 0x2c, 0x3b, 0xf8, 0x80, 0xc1, 0x66, 0x1e, 0x98,
|
||||
/* (2^ 24)P */ 0xd8, 0xd6, 0x3e, 0xcd, 0x63, 0x8c, 0x2b, 0x41, 0x81, 0xc0, 0x0c, 0x06, 0x87, 0xd6, 0xe7, 0x92, 0xfe, 0xf1, 0x0c, 0x4a, 0x84, 0x5b, 0xaf, 0x40, 0x53, 0x6f, 0x60, 0xd6, 0x6b, 0x76, 0x4b, 0xc2, 0xad, 0xc9, 0xb6, 0xb6, 0x6a, 0xa2, 0xb3, 0xf5, 0xf5, 0xc2, 0x55, 0x83, 0xb2, 0xd3, 0xe9, 0x41, 0x6c, 0x63, 0x51, 0xb8, 0x81, 0x74, 0xc8, 0x2c,
|
||||
/* (2^ 25)P */ 0xb2, 0xaf, 0x1c, 0xee, 0x07, 0xb0, 0x58, 0xa8, 0x2c, 0x6a, 0xc9, 0x2d, 0x62, 0x28, 0x75, 0x0c, 0x40, 0xb6, 0x11, 0x33, 0x96, 0x80, 0x28, 0x6d, 0xd5, 0x9e, 0x87, 0x90, 0x01, 0x66, 0x1d, 0x1c, 0xf8, 0xb4, 0x92, 0xac, 0x38, 0x18, 0x05, 0xc2, 0x4c, 0x4b, 0x54, 0x7d, 0x80, 0x46, 0x87, 0x2d, 0x99, 0x8e, 0x70, 0x80, 0x69, 0x71, 0x8b, 0xed,
|
||||
/* (2^ 26)P */ 0x37, 0xa7, 0x6b, 0x71, 0x36, 0x75, 0x8e, 0xff, 0x0f, 0x42, 0xda, 0x5a, 0x46, 0xa6, 0x97, 0x79, 0x7e, 0x30, 0xb3, 0x8f, 0xc7, 0x3a, 0xa0, 0xcb, 0x1d, 0x9c, 0x78, 0x77, 0x36, 0xc2, 0xe7, 0xf4, 0x2f, 0x29, 0x07, 0xb1, 0x07, 0xfd, 0xed, 0x1b, 0x39, 0x77, 0x06, 0x38, 0x77, 0x0f, 0x50, 0x31, 0x12, 0xbf, 0x92, 0xbf, 0x72, 0x79, 0x54, 0xa9,
|
||||
/* (2^ 27)P */ 0xbd, 0x4d, 0x46, 0x6b, 0x1a, 0x80, 0x46, 0x2d, 0xed, 0xfd, 0x64, 0x6d, 0x94, 0xbc, 0x4a, 0x6e, 0x0c, 0x12, 0xf6, 0x12, 0xab, 0x54, 0x88, 0xd3, 0x85, 0xac, 0x51, 0xae, 0x6f, 0xca, 0xc4, 0xb7, 0xec, 0x22, 0x54, 0x6d, 0x80, 0xb2, 0x1c, 0x63, 0x33, 0x76, 0x6b, 0x8e, 0x6d, 0x59, 0xcd, 0x73, 0x92, 0x5f, 0xff, 0xad, 0x10, 0x35, 0x70, 0x5f,
|
||||
/* (2^ 28)P */ 0xb3, 0x84, 0xde, 0xc8, 0x04, 0x43, 0x63, 0xfa, 0x29, 0xd9, 0xf0, 0x69, 0x65, 0x5a, 0x0c, 0xe8, 0x2e, 0x0b, 0xfe, 0xb0, 0x7a, 0x42, 0xb3, 0xc3, 0xfc, 0xe6, 0xb8, 0x92, 0x29, 0xae, 0xed, 0xec, 0xd5, 0xe8, 0x4a, 0xa1, 0xbd, 0x3b, 0xd3, 0xc0, 0x07, 0xab, 0x65, 0x65, 0x35, 0x9a, 0xa6, 0x5e, 0x78, 0x18, 0x76, 0x1c, 0x15, 0x49, 0xe6, 0x75,
|
||||
/* (2^ 29)P */ 0x45, 0xb3, 0x92, 0xa9, 0xc3, 0xb8, 0x11, 0x68, 0x64, 0x3a, 0x83, 0x5d, 0xa8, 0x94, 0x6a, 0x9d, 0xaa, 0x27, 0x9f, 0x98, 0x5d, 0xc0, 0x29, 0xf0, 0xc0, 0x4b, 0x14, 0x3c, 0x05, 0xe7, 0xf8, 0xbd, 0x38, 0x22, 0x96, 0x75, 0x65, 0x5e, 0x0d, 0x3f, 0xbb, 0x6f, 0xe8, 0x3f, 0x96, 0x76, 0x9f, 0xba, 0xd9, 0x44, 0x92, 0x96, 0x22, 0xe7, 0x52, 0xe7,
|
||||
/* (2^ 30)P */ 0xf4, 0xa3, 0x95, 0x90, 0x47, 0xdf, 0x7d, 0xdc, 0xf4, 0x13, 0x87, 0x67, 0x7d, 0x4f, 0x9d, 0xa0, 0x00, 0x46, 0x72, 0x08, 0xc3, 0xa2, 0x7a, 0x3e, 0xe7, 0x6d, 0x52, 0x7c, 0x11, 0x36, 0x50, 0x83, 0x89, 0x64, 0xcb, 0x1f, 0x08, 0x83, 0x46, 0xcb, 0xac, 0xa6, 0xd8, 0x9c, 0x1b, 0xe8, 0x05, 0x47, 0xc7, 0x26, 0x06, 0x83, 0x39, 0xe9, 0xb1, 0x1c,
|
||||
/* (2^ 31)P */ 0x11, 0xe8, 0xc8, 0x42, 0xbf, 0x30, 0x9c, 0xa3, 0xf1, 0x85, 0x96, 0x95, 0x4f, 0x4f, 0x52, 0xa2, 0xf5, 0x8b, 0x68, 0x24, 0x16, 0xac, 0x9b, 0xa9, 0x27, 0x28, 0x0e, 0x84, 0x03, 0x46, 0x22, 0x5f, 0xf7, 0x0d, 0xa6, 0x85, 0x88, 0xc1, 0x45, 0x4b, 0x85, 0x1a, 0x10, 0x7f, 0xc9, 0x94, 0x20, 0xb0, 0x04, 0x28, 0x12, 0x30, 0xb9, 0xe6, 0x40, 0x6b,
|
||||
/* (2^ 32)P */ 0xac, 0x1b, 0x57, 0xb6, 0x42, 0xdb, 0x81, 0x8d, 0x76, 0xfd, 0x9b, 0x1c, 0x29, 0x30, 0xd5, 0x3a, 0xcc, 0x53, 0xd9, 0x26, 0x7a, 0x0f, 0x9c, 0x2e, 0x79, 0xf5, 0x62, 0xeb, 0x61, 0x9d, 0x9b, 0x80, 0x39, 0xcd, 0x60, 0x2e, 0x1f, 0x08, 0x22, 0xbc, 0x19, 0xb3, 0x2a, 0x43, 0x44, 0xf2, 0x4e, 0x66, 0xf4, 0x36, 0xa6, 0xa7, 0xbc, 0xa4, 0x15, 0x7e,
|
||||
/* (2^ 33)P */ 0xc1, 0x90, 0x8a, 0xde, 0xff, 0x78, 0xc3, 0x73, 0x16, 0xee, 0x76, 0xa0, 0x84, 0x60, 0x8d, 0xe6, 0x82, 0x0f, 0xde, 0x4e, 0xc5, 0x99, 0x34, 0x06, 0x90, 0x44, 0x55, 0xf8, 0x91, 0xd8, 0xe1, 0xe4, 0x2c, 0x8a, 0xde, 0x94, 0x1e, 0x78, 0x25, 0x3d, 0xfd, 0xd8, 0x59, 0x7d, 0xaf, 0x6e, 0xbe, 0x96, 0xbe, 0x3c, 0x16, 0x23, 0x0f, 0x4c, 0xa4, 0x28,
|
||||
/* (2^ 34)P */ 0xba, 0x11, 0x35, 0x57, 0x03, 0xb6, 0xf4, 0x24, 0x89, 0xb8, 0x5a, 0x0d, 0x50, 0x9c, 0xaa, 0x51, 0x7f, 0xa4, 0x0e, 0xfc, 0x71, 0xb3, 0x3b, 0xf1, 0x96, 0x50, 0x23, 0x15, 0xf5, 0xf5, 0xd4, 0x23, 0xdc, 0x8b, 0x26, 0x9e, 0xae, 0xb7, 0x50, 0xcd, 0xc4, 0x25, 0xf6, 0x75, 0x40, 0x9c, 0x37, 0x79, 0x33, 0x60, 0xd4, 0x4b, 0x13, 0x32, 0xee, 0xe2,
|
||||
/* (2^ 35)P */ 0x43, 0xb8, 0x56, 0x59, 0xf0, 0x68, 0x23, 0xb3, 0xea, 0x70, 0x58, 0x4c, 0x1e, 0x5a, 0x16, 0x54, 0x03, 0xb2, 0xf4, 0x73, 0xb6, 0xd9, 0x5c, 0x9c, 0x6f, 0xcf, 0x82, 0x2e, 0x54, 0x15, 0x46, 0x2c, 0xa3, 0xda, 0x4e, 0x87, 0xf5, 0x2b, 0xba, 0x91, 0xa3, 0xa0, 0x89, 0xba, 0x48, 0x2b, 0xfa, 0x64, 0x02, 0x7f, 0x78, 0x03, 0xd1, 0xe8, 0x3b, 0xe9,
|
||||
/* (2^ 36)P */ 0x15, 0xa4, 0x71, 0xd4, 0x0c, 0x24, 0xe9, 0x07, 0xa1, 0x43, 0xf4, 0x7f, 0xbb, 0xa2, 0xa6, 0x6b, 0xfa, 0xb7, 0xea, 0x58, 0xd1, 0x96, 0xb0, 0x24, 0x5c, 0xc7, 0x37, 0x4e, 0x60, 0x0f, 0x40, 0xf2, 0x2f, 0x44, 0x70, 0xea, 0x80, 0x63, 0xfe, 0xfc, 0x46, 0x59, 0x12, 0x27, 0xb5, 0x27, 0xfd, 0xb7, 0x73, 0x0b, 0xca, 0x8b, 0xc2, 0xd3, 0x71, 0x08,
|
||||
/* (2^ 37)P */ 0x26, 0x0e, 0xd7, 0x52, 0x6f, 0xf1, 0xf2, 0x9d, 0xb8, 0x3d, 0xbd, 0xd4, 0x75, 0x97, 0xd8, 0xbf, 0xa8, 0x86, 0x96, 0xa5, 0x80, 0xa0, 0x45, 0x75, 0xf6, 0x77, 0x71, 0xdb, 0x77, 0x96, 0x55, 0x99, 0x31, 0xd0, 0x4f, 0x34, 0xf4, 0x35, 0x39, 0x41, 0xd3, 0x7d, 0xf7, 0xe2, 0x74, 0xde, 0xbe, 0x5b, 0x1f, 0x39, 0x10, 0x21, 0xa3, 0x4d, 0x3b, 0xc8,
|
||||
/* (2^ 38)P */ 0x04, 0x00, 0x2a, 0x45, 0xb2, 0xaf, 0x9b, 0x18, 0x6a, 0xeb, 0x96, 0x28, 0xa4, 0x77, 0xd0, 0x13, 0xcf, 0x17, 0x65, 0xe8, 0xc5, 0x81, 0x28, 0xad, 0x39, 0x7a, 0x0b, 0xaa, 0x55, 0x2b, 0xf3, 0xfc, 0x86, 0x40, 0xad, 0x0d, 0x1e, 0x28, 0xa2, 0x2d, 0xc5, 0xd6, 0x04, 0x15, 0xa2, 0x30, 0x3d, 0x12, 0x8e, 0xd6, 0xb5, 0xf7, 0x69, 0xbb, 0x84, 0x20,
|
||||
/* (2^ 39)P */ 0xd7, 0x7a, 0x77, 0x2c, 0xfb, 0x81, 0x80, 0xe9, 0x1e, 0xc6, 0x36, 0x31, 0x79, 0xc3, 0x7c, 0xa9, 0x57, 0x6b, 0xb5, 0x70, 0xfb, 0xe4, 0xa1, 0xff, 0xfd, 0x21, 0xa5, 0x7c, 0xfa, 0x44, 0xba, 0x0d, 0x96, 0x3d, 0xc4, 0x5c, 0x39, 0x52, 0x87, 0xd7, 0x22, 0x0f, 0x52, 0x88, 0x91, 0x87, 0x96, 0xac, 0xfa, 0x3b, 0xdf, 0xdc, 0x83, 0x8c, 0x99, 0x29,
|
||||
/* (2^ 40)P */ 0x98, 0x6b, 0x3a, 0x8d, 0x83, 0x17, 0xe1, 0x62, 0xd8, 0x80, 0x4c, 0x97, 0xce, 0x6b, 0xaa, 0x10, 0xa7, 0xc4, 0xe9, 0xeb, 0xa5, 0xfb, 0xc9, 0xdd, 0x2d, 0xeb, 0xfc, 0x9a, 0x71, 0xcd, 0x68, 0x6e, 0xc0, 0x35, 0x64, 0x62, 0x1b, 0x95, 0x12, 0xe8, 0x53, 0xec, 0xf0, 0xf4, 0x86, 0x86, 0x78, 0x18, 0xc4, 0xc6, 0xbc, 0x5a, 0x59, 0x8f, 0x7c, 0x7e,
|
||||
/* (2^ 41)P */ 0x7f, 0xd7, 0x1e, 0xc5, 0x83, 0xdc, 0x1f, 0xbe, 0x0b, 0xcf, 0x2e, 0x01, 0x01, 0xed, 0xac, 0x17, 0x3b, 0xed, 0xa4, 0x30, 0x96, 0x0e, 0x14, 0x7e, 0x19, 0x2b, 0xa5, 0x67, 0x1e, 0xb3, 0x34, 0x03, 0xa8, 0xbb, 0x0a, 0x7d, 0x08, 0x2d, 0xd5, 0x53, 0x19, 0x6f, 0x13, 0xd5, 0xc0, 0x90, 0x8a, 0xcc, 0xc9, 0x5c, 0xab, 0x24, 0xd7, 0x03, 0xf6, 0x57,
|
||||
/* (2^ 42)P */ 0x49, 0xcb, 0xb4, 0x96, 0x5f, 0xa6, 0xf8, 0x71, 0x6f, 0x59, 0xad, 0x05, 0x24, 0x2d, 0xaf, 0x67, 0xa8, 0xbe, 0x95, 0xdf, 0x0d, 0x28, 0x5a, 0x7f, 0x6e, 0x87, 0x8c, 0x6e, 0x67, 0x0c, 0xf4, 0xe0, 0x1c, 0x30, 0xc2, 0x66, 0xae, 0x20, 0xa1, 0x34, 0xec, 0x9c, 0xbc, 0xae, 0x3d, 0xa1, 0x28, 0x28, 0x95, 0x1d, 0xc9, 0x3a, 0xa8, 0xfd, 0xfc, 0xa1,
|
||||
/* (2^ 43)P */ 0xe2, 0x2b, 0x9d, 0xed, 0x02, 0x99, 0x67, 0xbb, 0x2e, 0x16, 0x62, 0x05, 0x70, 0xc7, 0x27, 0xb9, 0x1c, 0x3f, 0xf2, 0x11, 0x01, 0xd8, 0x51, 0xa4, 0x18, 0x92, 0xa9, 0x5d, 0xfb, 0xa9, 0xe4, 0x42, 0xba, 0x38, 0x34, 0x1a, 0x4a, 0xc5, 0x6a, 0x37, 0xde, 0xa7, 0x0c, 0xb4, 0x7e, 0x7f, 0xde, 0xa6, 0xee, 0xcd, 0x55, 0x57, 0x05, 0x06, 0xfd, 0x5d,
|
||||
/* (2^ 44)P */ 0x2f, 0x32, 0xcf, 0x2e, 0x2c, 0x7b, 0xbe, 0x9a, 0x0c, 0x57, 0x35, 0xf8, 0x87, 0xda, 0x9c, 0xec, 0x48, 0xf2, 0xbb, 0xe2, 0xda, 0x10, 0x58, 0x20, 0xc6, 0xd3, 0x87, 0xe9, 0xc7, 0x26, 0xd1, 0x9a, 0x46, 0x87, 0x90, 0xda, 0xdc, 0xde, 0xc3, 0xb3, 0xf2, 0xe8, 0x6f, 0x4a, 0xe6, 0xe8, 0x9d, 0x98, 0x36, 0x20, 0x03, 0x47, 0x15, 0x3f, 0x64, 0x59,
|
||||
/* (2^ 45)P */ 0xd4, 0x71, 0x49, 0x0a, 0x67, 0x97, 0xaa, 0x3f, 0xf4, 0x1b, 0x3a, 0x6e, 0x5e, 0x17, 0xcc, 0x0a, 0x8f, 0x81, 0x6a, 0x41, 0x38, 0x77, 0x40, 0x8a, 0x11, 0x42, 0x62, 0xd2, 0x50, 0x32, 0x79, 0x78, 0x28, 0xc2, 0x2e, 0x10, 0x01, 0x94, 0x30, 0x4f, 0x7f, 0x18, 0x17, 0x56, 0x85, 0x4e, 0xad, 0xf7, 0xcb, 0x87, 0x3c, 0x3f, 0x50, 0x2c, 0xc0, 0xba,
|
||||
/* (2^ 46)P */ 0xbc, 0x30, 0x8e, 0x65, 0x8e, 0x57, 0x5b, 0x38, 0x7a, 0xd4, 0x95, 0x52, 0x7a, 0x32, 0x59, 0x69, 0xcd, 0x9d, 0x47, 0x34, 0x5b, 0x55, 0xa5, 0x24, 0x60, 0xdd, 0xc0, 0xc1, 0x62, 0x73, 0x44, 0xae, 0x4c, 0x9c, 0x65, 0x55, 0x1b, 0x9d, 0x8a, 0x29, 0xb0, 0x1a, 0x52, 0xa8, 0xf1, 0xe6, 0x9a, 0xb3, 0xf6, 0xa3, 0xc9, 0x0a, 0x70, 0x7d, 0x0f, 0xee,
|
||||
/* (2^ 47)P */ 0x77, 0xd3, 0xe5, 0x8e, 0xfa, 0x00, 0xeb, 0x1b, 0x7f, 0xdc, 0x68, 0x3f, 0x92, 0xbd, 0xb7, 0x0b, 0xb7, 0xb5, 0x24, 0xdf, 0xc5, 0x67, 0x53, 0xd4, 0x36, 0x79, 0xc4, 0x7b, 0x57, 0xbc, 0x99, 0x97, 0x60, 0xef, 0xe4, 0x01, 0xa1, 0xa7, 0xaa, 0x12, 0x36, 0x29, 0xb1, 0x03, 0xc2, 0x83, 0x1c, 0x2b, 0x83, 0xef, 0x2e, 0x2c, 0x23, 0x92, 0xfd, 0xd1,
|
||||
/* (2^ 48)P */ 0x94, 0xef, 0x03, 0x59, 0xfa, 0x8a, 0x18, 0x76, 0xee, 0x58, 0x08, 0x4d, 0x44, 0xce, 0xf1, 0x52, 0x33, 0x49, 0xf6, 0x69, 0x71, 0xe3, 0xa9, 0xbc, 0x86, 0xe3, 0x43, 0xde, 0x33, 0x7b, 0x90, 0x8b, 0x3e, 0x7d, 0xd5, 0x4a, 0xf0, 0x23, 0x99, 0xa6, 0xea, 0x5f, 0x08, 0xe5, 0xb9, 0x49, 0x8b, 0x0d, 0x6a, 0x21, 0xab, 0x07, 0x62, 0xcd, 0xc4, 0xbe,
|
||||
/* (2^ 49)P */ 0x61, 0xbf, 0x70, 0x14, 0xfa, 0x4e, 0x9e, 0x7c, 0x0c, 0xf8, 0xb2, 0x48, 0x71, 0x62, 0x83, 0xd6, 0xd1, 0xdc, 0x9c, 0x29, 0x66, 0xb1, 0x34, 0x9c, 0x8d, 0xe6, 0x88, 0xaf, 0xbe, 0xdc, 0x4d, 0xeb, 0xb0, 0xe7, 0x28, 0xae, 0xb2, 0x05, 0x56, 0xc6, 0x0e, 0x10, 0x26, 0xab, 0x2c, 0x59, 0x72, 0x03, 0x66, 0xfe, 0x8f, 0x2c, 0x51, 0x2d, 0xdc, 0xae,
|
||||
/* (2^ 50)P */ 0xdc, 0x63, 0xf1, 0x8b, 0x5c, 0x65, 0x0b, 0xf1, 0xa6, 0x22, 0xe2, 0xd9, 0xdb, 0x49, 0xb1, 0x3c, 0x47, 0xc2, 0xfe, 0xac, 0x86, 0x07, 0x52, 0xec, 0xb0, 0x08, 0x69, 0xfb, 0xd1, 0x06, 0xdc, 0x48, 0x5c, 0x3d, 0xb2, 0x4d, 0xb8, 0x1a, 0x4e, 0xda, 0xb9, 0xc1, 0x2b, 0xab, 0x4b, 0x62, 0x81, 0x21, 0x9a, 0xfc, 0x3d, 0x39, 0x83, 0x11, 0x36, 0xeb,
|
||||
/* (2^ 51)P */ 0x94, 0xf3, 0x17, 0xef, 0xf9, 0x60, 0x54, 0xc3, 0xd7, 0x27, 0x35, 0xc5, 0x98, 0x5e, 0xf6, 0x63, 0x6c, 0xa0, 0x4a, 0xd3, 0xa3, 0x98, 0xd9, 0x42, 0xe3, 0xf1, 0xf8, 0x81, 0x96, 0xa9, 0xea, 0x6d, 0x4b, 0x8e, 0x33, 0xca, 0x94, 0x0d, 0xa0, 0xf7, 0xbb, 0x64, 0xa3, 0x36, 0x6f, 0xdc, 0x5a, 0x94, 0x42, 0xca, 0x06, 0xb2, 0x2b, 0x9a, 0x9f, 0x71,
|
||||
/* (2^ 52)P */ 0xec, 0xdb, 0xa6, 0x1f, 0xdf, 0x15, 0x36, 0xa3, 0xda, 0x8a, 0x7a, 0xb6, 0xa7, 0xe3, 0xaf, 0x52, 0xe0, 0x8d, 0xe8, 0xf2, 0x44, 0x20, 0xeb, 0xa1, 0x20, 0xc4, 0x65, 0x3c, 0x7c, 0x6c, 0x49, 0xed, 0x2f, 0x66, 0x23, 0x68, 0x61, 0x91, 0x40, 0x9f, 0x50, 0x19, 0xd1, 0x84, 0xa7, 0xe2, 0xed, 0x34, 0x37, 0xe3, 0xe4, 0x11, 0x7f, 0x87, 0x55, 0x0f,
|
||||
/* (2^ 53)P */ 0xb3, 0xa1, 0x0f, 0xb0, 0x48, 0xc0, 0x4d, 0x96, 0xa7, 0xcf, 0x5a, 0x81, 0xb8, 0x4a, 0x46, 0xef, 0x0a, 0xd3, 0x40, 0x7e, 0x02, 0xe3, 0x63, 0xaa, 0x50, 0xd1, 0x2a, 0x37, 0x22, 0x4a, 0x7f, 0x4f, 0xb6, 0xf9, 0x01, 0x82, 0x78, 0x3d, 0x93, 0x14, 0x11, 0x8a, 0x90, 0x60, 0xcd, 0x45, 0x4e, 0x7b, 0x42, 0xb9, 0x3e, 0x6e, 0x68, 0x1f, 0x36, 0x41,
|
||||
/* (2^ 54)P */ 0x13, 0x73, 0x0e, 0x4f, 0x79, 0x93, 0x9e, 0x29, 0x70, 0x7b, 0x4a, 0x59, 0x1a, 0x9a, 0xf4, 0x55, 0x08, 0xf0, 0xdb, 0x17, 0x58, 0xec, 0x64, 0xad, 0x7f, 0x29, 0xeb, 0x3f, 0x85, 0x4e, 0x60, 0x28, 0x98, 0x1f, 0x73, 0x4e, 0xe6, 0xa8, 0xab, 0xd5, 0xd6, 0xfc, 0xa1, 0x36, 0x6d, 0x15, 0xc6, 0x13, 0x83, 0xa0, 0xc2, 0x6e, 0xd9, 0xdb, 0xc9, 0xcc,
|
||||
/* (2^ 55)P */ 0xff, 0xd8, 0x52, 0xa3, 0xdc, 0x99, 0xcf, 0x3e, 0x19, 0xb3, 0x68, 0xd0, 0xb5, 0x0d, 0xb8, 0xee, 0x3f, 0xef, 0x6e, 0xc0, 0x38, 0x28, 0x44, 0x92, 0x78, 0x91, 0x1a, 0x08, 0x78, 0x6c, 0x65, 0x24, 0xf3, 0xa2, 0x3d, 0xf2, 0xe5, 0x79, 0x62, 0x69, 0x29, 0xf4, 0x22, 0xc5, 0xdb, 0x6a, 0xae, 0xf4, 0x44, 0xa3, 0x6f, 0xc7, 0x86, 0xab, 0xef, 0xef,
|
||||
/* (2^ 56)P */ 0xbf, 0x54, 0x9a, 0x09, 0x5d, 0x17, 0xd0, 0xde, 0xfb, 0xf5, 0xca, 0xff, 0x13, 0x20, 0x88, 0x82, 0x3a, 0xe2, 0xd0, 0x3b, 0xfb, 0x05, 0x76, 0xd1, 0xc0, 0x02, 0x71, 0x3b, 0x94, 0xe8, 0xc9, 0x84, 0xcf, 0xa4, 0xe9, 0x28, 0x7b, 0xf5, 0x09, 0xc3, 0x2b, 0x22, 0x40, 0xf1, 0x68, 0x24, 0x24, 0x7d, 0x9f, 0x6e, 0xcd, 0xfe, 0xb0, 0x19, 0x61, 0xf5,
|
||||
/* (2^ 57)P */ 0xe8, 0x63, 0x51, 0xb3, 0x95, 0x6b, 0x7b, 0x74, 0x92, 0x52, 0x45, 0xa4, 0xed, 0xea, 0x0e, 0x0d, 0x2b, 0x01, 0x1e, 0x2c, 0xbc, 0x91, 0x06, 0x69, 0xdb, 0x1f, 0xb5, 0x77, 0x1d, 0x56, 0xf5, 0xb4, 0x02, 0x80, 0x49, 0x56, 0x12, 0xce, 0x86, 0x05, 0xc9, 0xd9, 0xae, 0xf3, 0x6d, 0xe6, 0x3f, 0x40, 0x52, 0xe9, 0x49, 0x2b, 0x31, 0x06, 0x86, 0x14,
|
||||
/* (2^ 58)P */ 0xf5, 0x09, 0x3b, 0xd2, 0xff, 0xdf, 0x11, 0xa5, 0x1c, 0x99, 0xe8, 0x1b, 0xa4, 0x2c, 0x7d, 0x8e, 0xc8, 0xf7, 0x03, 0x46, 0xfa, 0xb6, 0xde, 0x73, 0x91, 0x7e, 0x5a, 0x7a, 0xd7, 0x9a, 0x5b, 0x80, 0x24, 0x62, 0x5e, 0x92, 0xf1, 0xa3, 0x45, 0xa3, 0x43, 0x92, 0x8a, 0x2a, 0x5b, 0x0c, 0xb4, 0xc8, 0xad, 0x1c, 0xb6, 0x6c, 0x5e, 0x81, 0x18, 0x91,
|
||||
/* (2^ 59)P */ 0x96, 0xb3, 0xca, 0x2b, 0xe3, 0x7a, 0x59, 0x72, 0x17, 0x74, 0x29, 0x21, 0xe7, 0x78, 0x07, 0xad, 0xda, 0xb6, 0xcd, 0xf9, 0x27, 0x4d, 0xc8, 0xf2, 0x98, 0x22, 0xca, 0xf2, 0x33, 0x74, 0x7a, 0xdd, 0x1e, 0x71, 0xec, 0xe3, 0x3f, 0xe2, 0xa2, 0xd2, 0x38, 0x75, 0xb0, 0xd0, 0x0a, 0xcf, 0x7d, 0x36, 0xdc, 0x49, 0x38, 0x25, 0x34, 0x4f, 0x20, 0x9a,
|
||||
/* (2^ 60)P */ 0x2b, 0x6e, 0x04, 0x0d, 0x4f, 0x3d, 0x3b, 0x24, 0xf6, 0x4e, 0x5e, 0x0a, 0xbd, 0x48, 0x96, 0xba, 0x81, 0x8f, 0x39, 0x82, 0x13, 0xe6, 0x72, 0xf3, 0x0f, 0xb6, 0x94, 0xf4, 0xc5, 0x90, 0x74, 0x91, 0xa8, 0xf2, 0xc9, 0xca, 0x9a, 0x4d, 0x98, 0xf2, 0xdf, 0x52, 0x4e, 0x97, 0x2f, 0xeb, 0x84, 0xd3, 0xaf, 0xc2, 0xcc, 0xfb, 0x4c, 0x26, 0x4b, 0xe4,
|
||||
/* (2^ 61)P */ 0x12, 0x9e, 0xfb, 0x9d, 0x78, 0x79, 0x99, 0xdd, 0xb3, 0x0b, 0x2e, 0x56, 0x41, 0x8e, 0x3f, 0x39, 0xb8, 0x97, 0x89, 0x53, 0x9b, 0x8a, 0x3c, 0x40, 0x9d, 0xa4, 0x6c, 0x2e, 0x31, 0x71, 0xc6, 0x0a, 0x41, 0xd4, 0x95, 0x06, 0x5e, 0xc1, 0xab, 0xc2, 0x14, 0xc4, 0xc7, 0x15, 0x08, 0x3a, 0xad, 0x7a, 0xb4, 0x62, 0xa3, 0x0c, 0x90, 0xf4, 0x47, 0x08,
|
||||
/* (2^ 62)P */ 0x7f, 0xec, 0x09, 0x82, 0xf5, 0x94, 0x09, 0x93, 0x32, 0xd3, 0xdc, 0x56, 0x80, 0x7b, 0x5b, 0x22, 0x80, 0x6a, 0x96, 0x72, 0xb1, 0xc2, 0xd9, 0xa1, 0x8b, 0x66, 0x42, 0x16, 0xe2, 0x07, 0xb3, 0x2d, 0xf1, 0x75, 0x35, 0x72, 0xc7, 0x98, 0xbe, 0x63, 0x3b, 0x20, 0x75, 0x05, 0xc1, 0x3e, 0x31, 0x5a, 0xf7, 0xaa, 0xae, 0x4b, 0xdb, 0x1d, 0xd0, 0x74,
|
||||
/* (2^ 63)P */ 0x36, 0x5c, 0x74, 0xe6, 0x5d, 0x59, 0x3f, 0x15, 0x4b, 0x4d, 0x4e, 0x67, 0x41, 0xfe, 0x98, 0x1f, 0x49, 0x76, 0x91, 0x0f, 0x9b, 0xf4, 0xaf, 0x86, 0xaf, 0x66, 0x19, 0xed, 0x46, 0xf1, 0x05, 0x9a, 0xcc, 0xd1, 0x14, 0x1f, 0x82, 0x12, 0x8e, 0xe6, 0xf4, 0xc3, 0x42, 0x5c, 0x4e, 0x33, 0x93, 0xbe, 0x30, 0xe7, 0x64, 0xa9, 0x35, 0x00, 0x4d, 0xf9,
|
||||
/* (2^ 64)P */ 0x1f, 0xc1, 0x1e, 0xb7, 0xe3, 0x7c, 0xfa, 0xa3, 0x6b, 0x76, 0xaf, 0x9c, 0x05, 0x85, 0x4a, 0xa9, 0xfb, 0xe3, 0x7e, 0xf2, 0x49, 0x56, 0xdc, 0x2f, 0x57, 0x10, 0xba, 0x37, 0xb2, 0x62, 0xf5, 0x6b, 0xe5, 0x8f, 0x0a, 0x87, 0xd1, 0x6a, 0xcb, 0x9d, 0x07, 0xd0, 0xf6, 0x38, 0x99, 0x2c, 0x61, 0x4a, 0x4e, 0xd8, 0xd2, 0x88, 0x29, 0x99, 0x11, 0x95,
|
||||
/* (2^ 65)P */ 0x6f, 0xdc, 0xd5, 0xd6, 0xd6, 0xa7, 0x4c, 0x46, 0x93, 0x65, 0x62, 0x23, 0x95, 0x32, 0x9c, 0xde, 0x40, 0x41, 0x68, 0x2c, 0x18, 0x4e, 0x5a, 0x8c, 0xc0, 0xc5, 0xc5, 0xea, 0x5c, 0x45, 0x0f, 0x60, 0x78, 0x39, 0xb6, 0x36, 0x23, 0x12, 0xbc, 0x21, 0x9a, 0xf8, 0x91, 0xac, 0xc4, 0x70, 0xdf, 0x85, 0x8e, 0x3c, 0xec, 0x22, 0x04, 0x98, 0xa8, 0xaa,
|
||||
/* (2^ 66)P */ 0xcc, 0x52, 0x10, 0x5b, 0x4b, 0x6c, 0xc5, 0xfa, 0x3e, 0xd4, 0xf8, 0x1c, 0x04, 0x14, 0x48, 0x33, 0xd9, 0xfc, 0x5f, 0xb0, 0xa5, 0x48, 0x8c, 0x45, 0x8a, 0xee, 0x3e, 0xa7, 0xc1, 0x2e, 0x34, 0xca, 0xf6, 0xc9, 0xeb, 0x10, 0xbb, 0xe1, 0x59, 0x84, 0x25, 0xe8, 0x81, 0x70, 0xc0, 0x09, 0x42, 0xa7, 0x3b, 0x0d, 0x33, 0x00, 0xb5, 0x77, 0xbe, 0x25,
|
||||
/* (2^ 67)P */ 0xcd, 0x1f, 0xbc, 0x7d, 0xef, 0xe5, 0xca, 0x91, 0xaf, 0xa9, 0x59, 0x6a, 0x09, 0xca, 0xd6, 0x1b, 0x3d, 0x55, 0xde, 0xa2, 0x6a, 0x80, 0xd6, 0x95, 0x47, 0xe4, 0x5f, 0x68, 0x54, 0x08, 0xdf, 0x29, 0xba, 0x2a, 0x02, 0x84, 0xe8, 0xe9, 0x00, 0x77, 0x99, 0x36, 0x03, 0xf6, 0x4a, 0x3e, 0x21, 0x81, 0x7d, 0xb8, 0xa4, 0x8a, 0xa2, 0x05, 0xef, 0xbc,
|
||||
/* (2^ 68)P */ 0x7c, 0x59, 0x5f, 0x66, 0xd9, 0xb7, 0x83, 0x43, 0x8a, 0xa1, 0x8d, 0x51, 0x70, 0xba, 0xf2, 0x9b, 0x95, 0xc0, 0x4b, 0x4c, 0xa0, 0x14, 0xd3, 0xa4, 0x5d, 0x4a, 0x37, 0x36, 0x97, 0x31, 0x1e, 0x12, 0xe7, 0xbb, 0x08, 0x67, 0xa5, 0x23, 0xd7, 0xfb, 0x97, 0xd8, 0x6a, 0x03, 0xb1, 0xf8, 0x7f, 0xda, 0x58, 0xd9, 0x3f, 0x73, 0x4a, 0x53, 0xe1, 0x7b,
|
||||
/* (2^ 69)P */ 0x55, 0x83, 0x98, 0x78, 0x6c, 0x56, 0x5e, 0xed, 0xf7, 0x23, 0x3e, 0x4c, 0x7d, 0x09, 0x2d, 0x09, 0x9c, 0x58, 0x8b, 0x32, 0xca, 0xfe, 0xbf, 0x47, 0x03, 0xeb, 0x4d, 0xe7, 0xeb, 0x9c, 0x83, 0x05, 0x68, 0xaa, 0x80, 0x89, 0x44, 0xf9, 0xd4, 0xdc, 0xdb, 0xb1, 0xdb, 0x77, 0xac, 0xf9, 0x2a, 0xae, 0x35, 0xac, 0x74, 0xb5, 0x95, 0x62, 0x18, 0x85,
|
||||
/* (2^ 70)P */ 0xab, 0x82, 0x7e, 0x10, 0xd7, 0xe6, 0x57, 0xd1, 0x66, 0x12, 0x31, 0x9c, 0x9c, 0xa6, 0x27, 0x59, 0x71, 0x2e, 0xeb, 0xa0, 0x68, 0xc5, 0x87, 0x51, 0xf4, 0xca, 0x3f, 0x98, 0x56, 0xb0, 0x89, 0xb1, 0xc7, 0x7b, 0x46, 0xb3, 0xae, 0x36, 0xf2, 0xee, 0x15, 0x1a, 0x60, 0xf4, 0x50, 0x76, 0x4f, 0xc4, 0x53, 0x0d, 0x36, 0x4d, 0x31, 0xb1, 0x20, 0x51,
|
||||
/* (2^ 71)P */ 0xf7, 0x1d, 0x8c, 0x1b, 0x5e, 0xe5, 0x02, 0x6f, 0xc5, 0xa5, 0xe0, 0x5f, 0xc6, 0xb6, 0x63, 0x43, 0xaf, 0x3c, 0x19, 0x6c, 0xf4, 0xaf, 0xa4, 0x33, 0xb1, 0x0a, 0x37, 0x3d, 0xd9, 0x4d, 0xe2, 0x29, 0x24, 0x26, 0x94, 0x7c, 0x02, 0xe4, 0xe2, 0xf2, 0xbe, 0xbd, 0xac, 0x1b, 0x48, 0xb8, 0xdd, 0xe9, 0x0d, 0x9a, 0x50, 0x1a, 0x98, 0x71, 0x6e, 0xdc,
|
||||
/* (2^ 72)P */ 0x9f, 0x40, 0xb1, 0xb3, 0x66, 0x28, 0x6c, 0xfe, 0xa6, 0x7d, 0xf8, 0x3e, 0xb8, 0xf3, 0xde, 0x52, 0x76, 0x52, 0xa3, 0x92, 0x98, 0x23, 0xab, 0x4f, 0x88, 0x97, 0xfc, 0x22, 0xe1, 0x6b, 0x67, 0xcd, 0x13, 0x95, 0xda, 0x65, 0xdd, 0x3b, 0x67, 0x3f, 0x5f, 0x4c, 0xf2, 0x8a, 0xad, 0x98, 0xa7, 0x94, 0x24, 0x45, 0x87, 0x11, 0x7c, 0x75, 0x79, 0x85,
|
||||
/* (2^ 73)P */ 0x70, 0xbf, 0xf9, 0x3b, 0xa9, 0x44, 0x57, 0x72, 0x96, 0xc9, 0xa4, 0x98, 0x65, 0xbf, 0x87, 0xb3, 0x3a, 0x39, 0x12, 0xde, 0xe5, 0x39, 0x01, 0x4f, 0xf7, 0xc0, 0x71, 0x52, 0x36, 0x85, 0xb3, 0x18, 0xf8, 0x14, 0xc0, 0x6d, 0xae, 0x9e, 0x4f, 0xb0, 0x72, 0x87, 0xac, 0x5c, 0xd1, 0x6c, 0x41, 0x6c, 0x90, 0x9d, 0x22, 0x81, 0xe4, 0x2b, 0xea, 0xe5,
|
||||
/* (2^ 74)P */ 0xfc, 0xea, 0x1a, 0x65, 0xd9, 0x49, 0x6a, 0x39, 0xb5, 0x96, 0x72, 0x7b, 0x32, 0xf1, 0xd0, 0xe9, 0x45, 0xd9, 0x31, 0x55, 0xc7, 0x34, 0xe9, 0x5a, 0xec, 0x73, 0x0b, 0x03, 0xc4, 0xb3, 0xe6, 0xc9, 0x5e, 0x0a, 0x17, 0xfe, 0x53, 0x66, 0x7f, 0x21, 0x18, 0x74, 0x54, 0x1b, 0xc9, 0x49, 0x16, 0xd2, 0x48, 0xaf, 0x5b, 0x47, 0x7b, 0xeb, 0xaa, 0xc9,
|
||||
/* (2^ 75)P */ 0x47, 0x04, 0xf5, 0x5a, 0x87, 0x77, 0x9e, 0x21, 0x34, 0x4e, 0x83, 0x88, 0xaf, 0x02, 0x1d, 0xb0, 0x5a, 0x1d, 0x1d, 0x7d, 0x8d, 0x2c, 0xd3, 0x8d, 0x63, 0xa9, 0x45, 0xfb, 0x15, 0x6d, 0x86, 0x45, 0xcd, 0x38, 0x0e, 0xf7, 0x37, 0x79, 0xed, 0x6d, 0x5a, 0xbc, 0x32, 0xcc, 0x66, 0xf1, 0x3a, 0xb2, 0x87, 0x6f, 0x70, 0x71, 0xd9, 0xf2, 0xfa, 0x7b,
|
||||
/* (2^ 76)P */ 0x68, 0x07, 0xdc, 0x61, 0x40, 0xe4, 0xec, 0x32, 0xc8, 0xbe, 0x66, 0x30, 0x54, 0x80, 0xfd, 0x13, 0x7a, 0xef, 0xae, 0xed, 0x2e, 0x00, 0x6d, 0x3f, 0xbd, 0xfc, 0x91, 0x24, 0x53, 0x7f, 0x63, 0x9d, 0x2e, 0xe3, 0x76, 0xe0, 0xf3, 0xe1, 0x8f, 0x7a, 0xc4, 0x77, 0x0c, 0x91, 0xc0, 0xc2, 0x18, 0x6b, 0x04, 0xad, 0xb6, 0x70, 0x9a, 0x64, 0xc5, 0x82,
|
||||
/* (2^ 77)P */ 0x7f, 0xea, 0x13, 0xd8, 0x9e, 0xfc, 0x5b, 0x06, 0xb5, 0x4f, 0xda, 0x38, 0xe0, 0x9c, 0xd2, 0x3a, 0xc1, 0x1c, 0x62, 0x70, 0x7f, 0xc6, 0x24, 0x0a, 0x47, 0x04, 0x01, 0xc4, 0x55, 0x09, 0xd1, 0x7a, 0x07, 0xba, 0xa3, 0x80, 0x4f, 0xc1, 0x65, 0x36, 0x6d, 0xc0, 0x10, 0xcf, 0x94, 0xa9, 0xa2, 0x01, 0x44, 0xd1, 0xf9, 0x1c, 0x4c, 0xfb, 0xf8, 0x99,
|
||||
/* (2^ 78)P */ 0x6c, 0xb9, 0x6b, 0xee, 0x43, 0x5b, 0xb9, 0xbb, 0xee, 0x2e, 0x52, 0xc1, 0xc6, 0xb9, 0x61, 0xd2, 0x93, 0xa5, 0xaf, 0x52, 0xf4, 0xa4, 0x1a, 0x51, 0x61, 0xa7, 0xcb, 0x9e, 0xbb, 0x56, 0x65, 0xe2, 0xbf, 0x75, 0xb9, 0x9c, 0x50, 0x96, 0x60, 0x81, 0x74, 0x47, 0xc0, 0x04, 0x88, 0x71, 0x76, 0x39, 0x9a, 0xa7, 0xb1, 0x4e, 0x43, 0x15, 0xe0, 0xbb,
|
||||
/* (2^ 79)P */ 0xbb, 0xce, 0xe2, 0xbb, 0xf9, 0x17, 0x0f, 0x82, 0x40, 0xad, 0x73, 0xe3, 0xeb, 0x3b, 0x06, 0x1a, 0xcf, 0x8e, 0x6e, 0x28, 0xb8, 0x26, 0xd9, 0x5b, 0xb7, 0xb3, 0xcf, 0xb4, 0x6a, 0x1c, 0xbf, 0x7f, 0xb8, 0xb5, 0x79, 0xcf, 0x45, 0x68, 0x7d, 0xc5, 0xeb, 0xf3, 0xbe, 0x39, 0x40, 0xfc, 0x07, 0x90, 0x7a, 0x62, 0xad, 0x86, 0x08, 0x71, 0x25, 0xe1,
|
||||
/* (2^ 80)P */ 0x9b, 0x46, 0xac, 0xef, 0xc1, 0x4e, 0xa1, 0x97, 0x95, 0x76, 0xf9, 0x1b, 0xc2, 0xb2, 0x6a, 0x41, 0xea, 0x80, 0x3d, 0xe9, 0x08, 0x52, 0x5a, 0xe3, 0xf2, 0x08, 0xc5, 0xea, 0x39, 0x3f, 0x44, 0x71, 0x4d, 0xea, 0x0d, 0x05, 0x23, 0xe4, 0x2e, 0x3c, 0x89, 0xfe, 0x12, 0x8a, 0x95, 0x42, 0x0a, 0x68, 0xea, 0x5a, 0x28, 0x06, 0x9e, 0xe3, 0x5f, 0xe0,
|
||||
/* (2^ 81)P */ 0x00, 0x61, 0x6c, 0x98, 0x9b, 0xe7, 0xb9, 0x06, 0x1c, 0xc5, 0x1b, 0xed, 0xbe, 0xc8, 0xb3, 0xea, 0x87, 0xf0, 0xc4, 0x24, 0x7d, 0xbb, 0x5d, 0xa4, 0x1d, 0x7a, 0x16, 0x00, 0x55, 0x94, 0x67, 0x78, 0xbd, 0x58, 0x02, 0x82, 0x90, 0x53, 0x76, 0xd4, 0x72, 0x99, 0x51, 0x6f, 0x7b, 0xcf, 0x80, 0x30, 0x31, 0x3b, 0x01, 0xc7, 0xc1, 0xef, 0xe6, 0x42,
|
||||
/* (2^ 82)P */ 0xe2, 0x35, 0xaf, 0x4b, 0x79, 0xc6, 0x12, 0x24, 0x99, 0xc0, 0x68, 0xb0, 0x43, 0x3e, 0xe5, 0xef, 0xe2, 0x29, 0xea, 0xb8, 0xb3, 0xbc, 0x6a, 0x53, 0x2c, 0x69, 0x18, 0x5a, 0xf9, 0x15, 0xae, 0x66, 0x58, 0x18, 0xd3, 0x2d, 0x4b, 0x00, 0xfd, 0x84, 0xab, 0x4f, 0xae, 0x70, 0x6b, 0x9e, 0x9a, 0xdf, 0x83, 0xfd, 0x2e, 0x3c, 0xcf, 0xf8, 0x88, 0x5b,
|
||||
/* (2^ 83)P */ 0xa4, 0x90, 0x31, 0x85, 0x13, 0xcd, 0xdf, 0x64, 0xc9, 0xa1, 0x0b, 0xe7, 0xb6, 0x73, 0x8a, 0x1b, 0x22, 0x78, 0x4c, 0xd4, 0xae, 0x48, 0x18, 0x00, 0x00, 0xa8, 0x9f, 0x06, 0xf9, 0xfb, 0x2d, 0xc3, 0xb1, 0x2a, 0xbc, 0x13, 0x99, 0x57, 0xaf, 0xf0, 0x8d, 0x61, 0x54, 0x29, 0xd5, 0xf2, 0x72, 0x00, 0x96, 0xd1, 0x85, 0x12, 0x8a, 0xf0, 0x23, 0xfb,
|
||||
/* (2^ 84)P */ 0x69, 0xc7, 0xdb, 0xd9, 0x92, 0x75, 0x08, 0x9b, 0xeb, 0xa5, 0x93, 0xd1, 0x1a, 0xf4, 0xf5, 0xaf, 0xe6, 0xc4, 0x4a, 0x0d, 0x35, 0x26, 0x39, 0x9d, 0xd3, 0x17, 0x3e, 0xae, 0x2d, 0xbf, 0x73, 0x9f, 0xb7, 0x74, 0x91, 0xd1, 0xd8, 0x5c, 0x14, 0xf9, 0x75, 0xdf, 0xeb, 0xc2, 0x22, 0xd8, 0x14, 0x8d, 0x86, 0x23, 0x4d, 0xd1, 0x2d, 0xdb, 0x6b, 0x42,
|
||||
/* (2^ 85)P */ 0x8c, 0xda, 0xc6, 0xf8, 0x71, 0xba, 0x2b, 0x06, 0x78, 0xae, 0xcc, 0x3a, 0xe3, 0xe3, 0xa1, 0x8b, 0xe2, 0x34, 0x6d, 0x28, 0x9e, 0x46, 0x13, 0x4d, 0x9e, 0xa6, 0x73, 0x49, 0x65, 0x79, 0x88, 0xb9, 0x3a, 0xd1, 0x6d, 0x2f, 0x48, 0x2b, 0x0a, 0x7f, 0x58, 0x20, 0x37, 0xf4, 0x0e, 0xbb, 0x4a, 0x95, 0x58, 0x0c, 0x88, 0x30, 0xc4, 0x74, 0xdd, 0xfd,
|
||||
/* (2^ 86)P */ 0x6d, 0x13, 0x4e, 0x89, 0x2d, 0xa9, 0xa3, 0xed, 0x09, 0xe3, 0x0e, 0x71, 0x3e, 0x4a, 0xab, 0x90, 0xde, 0x03, 0xeb, 0x56, 0x46, 0x60, 0x06, 0xf5, 0x71, 0xe5, 0xee, 0x9b, 0xef, 0xff, 0xc4, 0x2c, 0x9f, 0x37, 0x48, 0x45, 0x94, 0x12, 0x41, 0x81, 0x15, 0x70, 0x91, 0x99, 0x5e, 0x56, 0x6b, 0xf4, 0xa6, 0xc9, 0xf5, 0x69, 0x9d, 0x78, 0x37, 0x57,
|
||||
/* (2^ 87)P */ 0xf3, 0x51, 0x57, 0x7e, 0x43, 0x6f, 0xc6, 0x67, 0x59, 0x0c, 0xcf, 0x94, 0xe6, 0x3d, 0xb5, 0x07, 0xc9, 0x77, 0x48, 0xc9, 0x68, 0x0d, 0x98, 0x36, 0x62, 0x35, 0x38, 0x1c, 0xf5, 0xc5, 0xec, 0x66, 0x78, 0xfe, 0x47, 0xab, 0x26, 0xd6, 0x44, 0xb6, 0x06, 0x0f, 0x89, 0xe3, 0x19, 0x40, 0x1a, 0xe7, 0xd8, 0x65, 0x55, 0xf7, 0x1a, 0xfc, 0xa3, 0x0e,
|
||||
/* (2^ 88)P */ 0x0e, 0x30, 0xa6, 0xb7, 0x58, 0x60, 0x62, 0x2a, 0x6c, 0x13, 0xa8, 0x14, 0x9b, 0xb8, 0xf2, 0x70, 0xd8, 0xb1, 0x71, 0x88, 0x8c, 0x18, 0x31, 0x25, 0x93, 0x90, 0xb4, 0xc7, 0x49, 0xd8, 0xd4, 0xdb, 0x1e, 0x1e, 0x7f, 0xaa, 0xba, 0xc9, 0xf2, 0x5d, 0xa9, 0x3a, 0x43, 0xb4, 0x5c, 0xee, 0x7b, 0xc7, 0x97, 0xb7, 0x66, 0xd7, 0x23, 0xd9, 0x22, 0x59,
|
||||
/* (2^ 89)P */ 0x28, 0x19, 0xa6, 0xf9, 0x89, 0x20, 0x78, 0xd4, 0x6d, 0xcb, 0x79, 0x8f, 0x61, 0x6f, 0xb2, 0x5c, 0x4f, 0xa6, 0x54, 0x84, 0x95, 0x24, 0x36, 0x64, 0xcb, 0x39, 0xe7, 0x8f, 0x97, 0x9c, 0x5c, 0x3c, 0xfb, 0x51, 0x11, 0x01, 0x17, 0xdb, 0xc9, 0x9b, 0x51, 0x03, 0x9a, 0xe9, 0xe5, 0x24, 0x1e, 0xf5, 0xda, 0xe0, 0x48, 0x02, 0x23, 0xd0, 0x2c, 0x81,
|
||||
/* (2^ 90)P */ 0x42, 0x1b, 0xe4, 0x91, 0x85, 0x2a, 0x0c, 0xd2, 0x28, 0x66, 0x57, 0x9e, 0x33, 0x8d, 0x25, 0x71, 0x10, 0x65, 0x76, 0xa2, 0x8c, 0x21, 0x86, 0x81, 0x15, 0xc2, 0x27, 0xeb, 0x54, 0x2d, 0x4f, 0x6c, 0xe6, 0xd6, 0x24, 0x9c, 0x1a, 0x12, 0xb8, 0x81, 0xe2, 0x0a, 0xf3, 0xd3, 0xf0, 0xd3, 0xe1, 0x74, 0x1f, 0x9b, 0x11, 0x47, 0xd0, 0xcf, 0xb6, 0x54,
|
||||
/* (2^ 91)P */ 0x26, 0x45, 0xa2, 0x10, 0xd4, 0x2d, 0xae, 0xc0, 0xb0, 0xe8, 0x86, 0xb3, 0xc7, 0xea, 0x70, 0x87, 0x61, 0xb5, 0xa5, 0x55, 0xbe, 0x88, 0x1d, 0x7a, 0xd9, 0x6f, 0xeb, 0x83, 0xe2, 0x44, 0x7f, 0x98, 0x04, 0xd6, 0x50, 0x9d, 0xa7, 0x86, 0x66, 0x09, 0x63, 0xe1, 0xed, 0x72, 0xb1, 0xe4, 0x1d, 0x3a, 0xfd, 0x47, 0xce, 0x1c, 0xaa, 0x3b, 0x8f, 0x1b,
|
||||
/* (2^ 92)P */ 0xf4, 0x3c, 0x4a, 0xb6, 0xc2, 0x9c, 0xe0, 0x2e, 0xb7, 0x38, 0xea, 0x61, 0x35, 0x97, 0x10, 0x90, 0xae, 0x22, 0x48, 0xb3, 0xa9, 0xc6, 0x7a, 0xbb, 0x23, 0xf2, 0xf8, 0x1b, 0xa7, 0xa1, 0x79, 0xcc, 0xc4, 0xf8, 0x08, 0x76, 0x8a, 0x5a, 0x1c, 0x1b, 0xc5, 0x33, 0x91, 0xa9, 0xb8, 0xb9, 0xd3, 0xf8, 0x49, 0xcd, 0xe5, 0x82, 0x43, 0xf7, 0xca, 0x68,
|
||||
/* (2^ 93)P */ 0x38, 0xba, 0xae, 0x44, 0xfe, 0x57, 0x64, 0x56, 0x7c, 0x0e, 0x9c, 0xca, 0xff, 0xa9, 0x82, 0xbb, 0x38, 0x4a, 0xa7, 0xf7, 0x47, 0xab, 0xbe, 0x6d, 0x23, 0x0b, 0x8a, 0xed, 0xc2, 0xb9, 0x8f, 0xf1, 0xec, 0x91, 0x44, 0x73, 0x64, 0xba, 0xd5, 0x8f, 0x37, 0x38, 0x0d, 0xd5, 0xf8, 0x73, 0x57, 0xb6, 0xc2, 0x45, 0xdc, 0x25, 0xb2, 0xb6, 0xea, 0xd9,
|
||||
/* (2^ 94)P */ 0xbf, 0xe9, 0x1a, 0x40, 0x4d, 0xcc, 0xe6, 0x1d, 0x70, 0x1a, 0x65, 0xcc, 0x34, 0x2c, 0x37, 0x2c, 0x2d, 0x6b, 0x6d, 0xe5, 0x2f, 0x19, 0x9e, 0xe4, 0xe1, 0xaa, 0xd4, 0xab, 0x54, 0xf4, 0xa8, 0xe4, 0x69, 0x2d, 0x8e, 0x4d, 0xd7, 0xac, 0xb0, 0x5b, 0xfe, 0xe3, 0x26, 0x07, 0xc3, 0xf8, 0x1b, 0x43, 0xa8, 0x1d, 0x64, 0xa5, 0x25, 0x88, 0xbb, 0x77,
|
||||
/* (2^ 95)P */ 0x92, 0xcd, 0x6e, 0xa0, 0x79, 0x04, 0x18, 0xf4, 0x11, 0x58, 0x48, 0xb5, 0x3c, 0x7b, 0xd1, 0xcc, 0xd3, 0x14, 0x2c, 0xa0, 0xdd, 0x04, 0x44, 0x11, 0xb3, 0x6d, 0x2f, 0x0d, 0xf5, 0x2a, 0x75, 0x5d, 0x1d, 0xda, 0x86, 0x8d, 0x7d, 0x6b, 0x32, 0x68, 0xb6, 0x6c, 0x64, 0x9e, 0xde, 0x80, 0x88, 0xce, 0x08, 0xbf, 0x0b, 0xe5, 0x8e, 0x4f, 0x1d, 0xfb,
|
||||
/* (2^ 96)P */ 0xaf, 0xe8, 0x85, 0xbf, 0x7f, 0x37, 0x8d, 0x66, 0x7c, 0xd5, 0xd3, 0x96, 0xa5, 0x81, 0x67, 0x95, 0xff, 0x48, 0xde, 0xde, 0xd7, 0x7a, 0x46, 0x34, 0xb1, 0x13, 0x70, 0x29, 0xed, 0x87, 0x90, 0xb0, 0x40, 0x2c, 0xa6, 0x43, 0x6e, 0xb6, 0xbc, 0x48, 0x8a, 0xc1, 0xae, 0xb8, 0xd4, 0xe2, 0xc0, 0x32, 0xb2, 0xa6, 0x2a, 0x8f, 0xb5, 0x16, 0x9e, 0xc3,
|
||||
/* (2^ 97)P */ 0xff, 0x4d, 0xd2, 0xd6, 0x74, 0xef, 0x2c, 0x96, 0xc1, 0x11, 0xa8, 0xb8, 0xfe, 0x94, 0x87, 0x3e, 0xa0, 0xfb, 0x57, 0xa3, 0xfc, 0x7a, 0x7e, 0x6a, 0x59, 0x6c, 0x54, 0xbb, 0xbb, 0xa2, 0x25, 0x38, 0x1b, 0xdf, 0x5d, 0x7b, 0x94, 0x14, 0xde, 0x07, 0x6e, 0xd3, 0xab, 0x02, 0x26, 0x74, 0x16, 0x12, 0xdf, 0x2e, 0x2a, 0xa7, 0xb0, 0xe8, 0x29, 0xc0,
|
||||
/* (2^ 98)P */ 0x6a, 0x38, 0x0b, 0xd3, 0xba, 0x45, 0x23, 0xe0, 0x04, 0x3b, 0x83, 0x39, 0xc5, 0x11, 0xe6, 0xcf, 0x39, 0x0a, 0xb3, 0xb0, 0x3b, 0x27, 0x29, 0x63, 0x1c, 0xf3, 0x00, 0xe6, 0xd2, 0x55, 0x21, 0x1f, 0x84, 0x97, 0x9f, 0x01, 0x49, 0x43, 0x30, 0x5f, 0xe0, 0x1d, 0x24, 0xc4, 0x4e, 0xa0, 0x2b, 0x0b, 0x12, 0x55, 0xc3, 0x27, 0xae, 0x08, 0x83, 0x7c,
|
||||
/* (2^ 99)P */ 0x5d, 0x1a, 0xb7, 0xa9, 0xf5, 0xfd, 0xec, 0xad, 0xb7, 0x87, 0x02, 0x5f, 0x0d, 0x30, 0x4d, 0xe2, 0x65, 0x87, 0xa4, 0x41, 0x45, 0x1d, 0x67, 0xe0, 0x30, 0x5c, 0x13, 0x87, 0xf6, 0x2e, 0x08, 0xc1, 0xc7, 0x12, 0x45, 0xc8, 0x9b, 0xad, 0xb8, 0xd5, 0x57, 0xbb, 0x5c, 0x48, 0x3a, 0xe1, 0x91, 0x5e, 0xf6, 0x4d, 0x8a, 0x63, 0x75, 0x69, 0x0c, 0x01,
|
||||
/* (2^100)P */ 0x8f, 0x53, 0x2d, 0xa0, 0x71, 0x3d, 0xfc, 0x45, 0x10, 0x96, 0xcf, 0x56, 0xf9, 0xbb, 0x40, 0x3c, 0x86, 0x52, 0x76, 0xbe, 0x84, 0xf9, 0xa6, 0x9d, 0x3d, 0x27, 0xbe, 0xb4, 0x00, 0x49, 0x94, 0xf5, 0x5d, 0xe1, 0x62, 0x85, 0x66, 0xe5, 0xb8, 0x20, 0x2c, 0x09, 0x7d, 0x9d, 0x3d, 0x6e, 0x74, 0x39, 0xab, 0xad, 0xa0, 0x90, 0x97, 0x5f, 0xbb, 0xa7,
|
||||
/* (2^101)P */ 0xdb, 0x2d, 0x99, 0x08, 0x16, 0x46, 0x83, 0x7a, 0xa8, 0xea, 0x3d, 0x28, 0x5b, 0x49, 0xfc, 0xb9, 0x6d, 0x00, 0x9e, 0x54, 0x4f, 0x47, 0x64, 0x9b, 0x58, 0x4d, 0x07, 0x0c, 0x6f, 0x29, 0x56, 0x0b, 0x00, 0x14, 0x85, 0x96, 0x41, 0x04, 0xb9, 0x5c, 0xa4, 0xf6, 0x16, 0x73, 0x6a, 0xc7, 0x62, 0x0c, 0x65, 0x2f, 0x93, 0xbf, 0xf7, 0xb9, 0xb7, 0xf1,
|
||||
/* (2^102)P */ 0xeb, 0x6d, 0xb3, 0x46, 0x32, 0xd2, 0xcb, 0x08, 0x94, 0x14, 0xbf, 0x3f, 0xc5, 0xcb, 0x5f, 0x9f, 0x8a, 0x89, 0x0c, 0x1b, 0x45, 0xad, 0x4c, 0x50, 0xb4, 0xe1, 0xa0, 0x6b, 0x11, 0x92, 0xaf, 0x1f, 0x00, 0xcc, 0xe5, 0x13, 0x7e, 0xe4, 0x2e, 0xa0, 0x57, 0xf3, 0xa7, 0x84, 0x79, 0x7a, 0xc2, 0xb7, 0xb7, 0xfc, 0x5d, 0xa5, 0xa9, 0x64, 0xcc, 0xd8,
|
||||
/* (2^103)P */ 0xa9, 0xc4, 0x12, 0x8b, 0x34, 0x78, 0x3e, 0x38, 0xfd, 0x3f, 0x87, 0xfa, 0x88, 0x94, 0xd5, 0xd9, 0x7f, 0xeb, 0x58, 0xff, 0xb9, 0x45, 0xdb, 0xa1, 0xed, 0x22, 0x28, 0x1d, 0x00, 0x6d, 0x79, 0x85, 0x7a, 0x75, 0x5d, 0xf0, 0xb1, 0x9e, 0x47, 0x28, 0x8c, 0x62, 0xdf, 0xfb, 0x4c, 0x7b, 0xc5, 0x1a, 0x42, 0x95, 0xef, 0x9a, 0xb7, 0x27, 0x7e, 0xda,
|
||||
/* (2^104)P */ 0xca, 0xd5, 0xc0, 0x17, 0xa1, 0x66, 0x79, 0x9c, 0x2a, 0xb7, 0x0a, 0xfe, 0x62, 0xe4, 0x26, 0x78, 0x90, 0xa7, 0xcb, 0xb0, 0x4f, 0x6d, 0xf9, 0x8f, 0xf7, 0x7d, 0xac, 0xb8, 0x78, 0x1f, 0x41, 0xea, 0x97, 0x1e, 0x62, 0x97, 0x43, 0x80, 0x58, 0x80, 0xb6, 0x69, 0x7d, 0xee, 0x16, 0xd2, 0xa1, 0x81, 0xd7, 0xb1, 0x27, 0x03, 0x48, 0xda, 0xab, 0xec,
|
||||
/* (2^105)P */ 0x5b, 0xed, 0x40, 0x8e, 0x8c, 0xc1, 0x66, 0x90, 0x7f, 0x0c, 0xb2, 0xfc, 0xbd, 0x16, 0xac, 0x7d, 0x4c, 0x6a, 0xf9, 0xae, 0xe7, 0x4e, 0x11, 0x12, 0xe9, 0xbe, 0x17, 0x09, 0xc6, 0xc1, 0x5e, 0xb5, 0x7b, 0x50, 0x5c, 0x27, 0xfb, 0x80, 0xab, 0x01, 0xfa, 0x5b, 0x9b, 0x75, 0x16, 0x6e, 0xb2, 0x5c, 0x8c, 0x2f, 0xa5, 0x6a, 0x1a, 0x68, 0xa6, 0x90,
|
||||
/* (2^106)P */ 0x75, 0xfe, 0xb6, 0x96, 0x96, 0x87, 0x4c, 0x12, 0xa9, 0xd1, 0xd8, 0x03, 0xa3, 0xc1, 0x15, 0x96, 0xe8, 0xa0, 0x75, 0x82, 0xa0, 0x6d, 0xea, 0x54, 0xdc, 0x5f, 0x0d, 0x7e, 0xf6, 0x70, 0xb5, 0xdc, 0x7a, 0xf6, 0xc4, 0xd4, 0x21, 0x49, 0xf5, 0xd4, 0x14, 0x6d, 0x48, 0x1d, 0x7c, 0x99, 0x42, 0xdf, 0x78, 0x6b, 0x9d, 0xb9, 0x30, 0x3c, 0xd0, 0x29,
|
||||
/* (2^107)P */ 0x85, 0xd6, 0xd8, 0xf3, 0x91, 0x74, 0xdd, 0xbd, 0x72, 0x96, 0x10, 0xe4, 0x76, 0x02, 0x5a, 0x72, 0x67, 0xd3, 0x17, 0x72, 0x14, 0x9a, 0x20, 0x5b, 0x0f, 0x8d, 0xed, 0x6d, 0x4e, 0xe3, 0xd9, 0x82, 0xc2, 0x99, 0xee, 0x39, 0x61, 0x69, 0x8a, 0x24, 0x01, 0x92, 0x15, 0xe7, 0xfc, 0xf9, 0x4d, 0xac, 0xf1, 0x30, 0x49, 0x01, 0x0b, 0x6e, 0x0f, 0x20,
|
||||
/* (2^108)P */ 0xd8, 0x25, 0x94, 0x5e, 0x43, 0x29, 0xf5, 0xcc, 0xe8, 0xe3, 0x55, 0x41, 0x3c, 0x9f, 0x58, 0x5b, 0x00, 0xeb, 0xc5, 0xdf, 0xcf, 0xfb, 0xfd, 0x6e, 0x92, 0xec, 0x99, 0x30, 0xd6, 0x05, 0xdd, 0x80, 0x7a, 0x5d, 0x6d, 0x16, 0x85, 0xd8, 0x9d, 0x43, 0x65, 0xd8, 0x2c, 0x33, 0x2f, 0x5c, 0x41, 0xea, 0xb7, 0x95, 0x77, 0xf2, 0x9e, 0x59, 0x09, 0xe8,
|
||||
/* (2^109)P */ 0x00, 0xa0, 0x03, 0x80, 0xcd, 0x60, 0xe5, 0x17, 0xd4, 0x15, 0x99, 0xdd, 0x4f, 0xbf, 0x66, 0xb8, 0xc0, 0xf5, 0xf9, 0xfc, 0x6d, 0x42, 0x18, 0x34, 0x1c, 0x7d, 0x5b, 0xb5, 0x09, 0xd0, 0x99, 0x57, 0x81, 0x0b, 0x62, 0xb3, 0xa2, 0xf9, 0x0b, 0xae, 0x95, 0xb8, 0xc2, 0x3b, 0x0d, 0x5b, 0x00, 0xf1, 0xed, 0xbc, 0x05, 0x9d, 0x61, 0xbc, 0x73, 0x9d,
|
||||
/* (2^110)P */ 0xd4, 0xdb, 0x29, 0xe5, 0x85, 0xe9, 0xc6, 0x89, 0x2a, 0xa8, 0x54, 0xab, 0xb3, 0x7f, 0x88, 0xc0, 0x4d, 0xe0, 0xd1, 0x74, 0x6e, 0xa3, 0xa7, 0x39, 0xd5, 0xcc, 0xa1, 0x8a, 0xcb, 0x5b, 0x34, 0xad, 0x92, 0xb4, 0xd8, 0xd5, 0x17, 0xf6, 0x77, 0x18, 0x9e, 0xaf, 0x45, 0x3b, 0x03, 0xe2, 0xf8, 0x52, 0x60, 0xdc, 0x15, 0x20, 0x9e, 0xdf, 0xd8, 0x5d,
|
||||
/* (2^111)P */ 0x02, 0xc1, 0xac, 0x1a, 0x15, 0x8e, 0x6c, 0xf5, 0x1e, 0x1e, 0xba, 0x7e, 0xc2, 0xda, 0x7d, 0x02, 0xda, 0x43, 0xae, 0x04, 0x70, 0x28, 0x54, 0x78, 0x94, 0xf5, 0x4f, 0x07, 0x84, 0x8f, 0xed, 0xaa, 0xc0, 0xb8, 0xcd, 0x7f, 0x7e, 0x33, 0xa3, 0xbe, 0x21, 0x29, 0xc8, 0x56, 0x34, 0xc0, 0x76, 0x87, 0x8f, 0xc7, 0x73, 0x58, 0x90, 0x16, 0xfc, 0xd6,
|
||||
/* (2^112)P */ 0xb8, 0x3f, 0xe1, 0xdf, 0x3a, 0x91, 0x25, 0x0c, 0xf6, 0x47, 0xa8, 0x89, 0xc4, 0xc6, 0x61, 0xec, 0x86, 0x2c, 0xfd, 0xbe, 0xa4, 0x6f, 0xc2, 0xd4, 0x46, 0x19, 0x70, 0x5d, 0x09, 0x02, 0x86, 0xd3, 0x4b, 0xe9, 0x16, 0x7b, 0xf0, 0x0d, 0x6c, 0xff, 0x91, 0x05, 0xbf, 0x55, 0xb4, 0x00, 0x8d, 0xe5, 0x6d, 0x68, 0x20, 0x90, 0x12, 0xb5, 0x5c, 0x32,
|
||||
/* (2^113)P */ 0x80, 0x45, 0xc8, 0x51, 0x87, 0xba, 0x1c, 0x5c, 0xcf, 0x5f, 0x4b, 0x3c, 0x9e, 0x3b, 0x36, 0xd2, 0x26, 0xa2, 0x7f, 0xab, 0xb7, 0xbf, 0xda, 0x68, 0x23, 0x8f, 0xc3, 0xa0, 0xfd, 0xad, 0xf1, 0x56, 0x3b, 0xd0, 0x75, 0x2b, 0x44, 0x61, 0xd8, 0xf4, 0xf1, 0x05, 0x49, 0x53, 0x07, 0xee, 0x47, 0xef, 0xc0, 0x7c, 0x9d, 0xe4, 0x15, 0x88, 0xc5, 0x47,
|
||||
/* (2^114)P */ 0x2d, 0xb5, 0x09, 0x80, 0xb9, 0xd3, 0xd8, 0xfe, 0x4c, 0xd2, 0xa6, 0x6e, 0xd3, 0x75, 0xcf, 0xb0, 0x99, 0xcb, 0x50, 0x8d, 0xe9, 0x67, 0x9b, 0x20, 0xe8, 0x57, 0xd8, 0x14, 0x85, 0x73, 0x6a, 0x74, 0xe0, 0x99, 0xf0, 0x6b, 0x6e, 0x59, 0x30, 0x31, 0x33, 0x96, 0x5f, 0xa1, 0x0c, 0x1b, 0xf4, 0xca, 0x09, 0xe1, 0x9b, 0xb5, 0xcf, 0x6d, 0x0b, 0xeb,
|
||||
/* (2^115)P */ 0x1a, 0xde, 0x50, 0xa9, 0xac, 0x3e, 0x10, 0x43, 0x4f, 0x82, 0x4f, 0xc0, 0xfe, 0x3f, 0x33, 0xd2, 0x64, 0x86, 0x50, 0xa9, 0x51, 0x76, 0x5e, 0x50, 0x97, 0x6c, 0x73, 0x8d, 0x77, 0xa3, 0x75, 0x03, 0xbc, 0xc9, 0xfb, 0x50, 0xd9, 0x6d, 0x16, 0xad, 0x5d, 0x32, 0x3d, 0xac, 0x44, 0xdf, 0x51, 0xf7, 0x19, 0xd4, 0x0b, 0x57, 0x78, 0x0b, 0x81, 0x4e,
|
||||
/* (2^116)P */ 0x32, 0x24, 0xf1, 0x6c, 0x55, 0x62, 0x1d, 0xb3, 0x1f, 0xda, 0xfa, 0x6a, 0x8f, 0x98, 0x01, 0x16, 0xde, 0x44, 0x50, 0x0d, 0x2e, 0x6c, 0x0b, 0xa2, 0xd3, 0x74, 0x0e, 0xa9, 0xbf, 0x8d, 0xa9, 0xc8, 0xc8, 0x2f, 0x62, 0xc1, 0x35, 0x5e, 0xfd, 0x3a, 0xb3, 0x83, 0x2d, 0xee, 0x4e, 0xfd, 0x5c, 0x5e, 0xad, 0x85, 0xa5, 0x10, 0xb5, 0x4f, 0x34, 0xa7,
|
||||
/* (2^117)P */ 0xd1, 0x58, 0x6f, 0xe6, 0x54, 0x2c, 0xc2, 0xcd, 0xcf, 0x83, 0xdc, 0x88, 0x0c, 0xb9, 0xb4, 0x62, 0x18, 0x89, 0x65, 0x28, 0xe9, 0x72, 0x4b, 0x65, 0xcf, 0xd6, 0x90, 0x88, 0xd7, 0x76, 0x17, 0x4f, 0x74, 0x64, 0x1e, 0xcb, 0xd3, 0xf5, 0x4b, 0xaa, 0x2e, 0x4d, 0x2d, 0x7c, 0x13, 0x1f, 0xfd, 0xd9, 0x60, 0x83, 0x7e, 0xda, 0x64, 0x1c, 0xdc, 0x9f,
|
||||
/* (2^118)P */ 0xad, 0xef, 0xac, 0x1b, 0xc1, 0x30, 0x5a, 0x15, 0xc9, 0x1f, 0xac, 0xf1, 0xca, 0x44, 0x95, 0x95, 0xea, 0xf2, 0x22, 0xe7, 0x8d, 0x25, 0xf0, 0xff, 0xd8, 0x71, 0xf7, 0xf8, 0x8f, 0x8f, 0xcd, 0xf4, 0x1e, 0xfe, 0x6c, 0x68, 0x04, 0xb8, 0x78, 0xa1, 0x5f, 0xa6, 0x5d, 0x5e, 0xf9, 0x8d, 0xea, 0x80, 0xcb, 0xf3, 0x17, 0xa6, 0x03, 0xc9, 0x38, 0xd5,
|
||||
/* (2^119)P */ 0x79, 0x14, 0x31, 0xc3, 0x38, 0xe5, 0xaa, 0xbf, 0x17, 0xa3, 0x04, 0x4e, 0x80, 0x59, 0x9c, 0x9f, 0x19, 0x39, 0xe4, 0x2d, 0x23, 0x54, 0x4a, 0x7f, 0x3e, 0xf3, 0xd9, 0xc7, 0xba, 0x6c, 0x8f, 0x6b, 0xfa, 0x34, 0xb5, 0x23, 0x17, 0x1d, 0xff, 0x1d, 0xea, 0x1f, 0xd7, 0xba, 0x61, 0xb2, 0xe0, 0x38, 0x6a, 0xe9, 0xcf, 0x48, 0x5d, 0x6a, 0x10, 0x9c,
|
||||
/* (2^120)P */ 0xc8, 0xbb, 0x13, 0x1c, 0x3f, 0x3c, 0x34, 0xfd, 0xac, 0x37, 0x52, 0x44, 0x25, 0xa8, 0xde, 0x1d, 0x63, 0xf4, 0x81, 0x9a, 0xbe, 0x0b, 0x74, 0x2e, 0xc8, 0x51, 0x16, 0xd3, 0xac, 0x4a, 0xaf, 0xe2, 0x5f, 0x3a, 0x89, 0x32, 0xd1, 0x9b, 0x7c, 0x90, 0x0d, 0xac, 0xdc, 0x8b, 0x73, 0x45, 0x45, 0x97, 0xb1, 0x90, 0x2c, 0x1b, 0x31, 0xca, 0xb1, 0x94,
|
||||
/* (2^121)P */ 0x07, 0x28, 0xdd, 0x10, 0x14, 0xa5, 0x95, 0x7e, 0xf3, 0xe4, 0xd4, 0x14, 0xb4, 0x7e, 0x76, 0xdb, 0x42, 0xd6, 0x94, 0x3e, 0xeb, 0x44, 0x64, 0x88, 0x0d, 0xec, 0xc1, 0x21, 0xf0, 0x79, 0xe0, 0x83, 0x67, 0x55, 0x53, 0xc2, 0xf6, 0xc5, 0xc5, 0x89, 0x39, 0xe8, 0x42, 0xd0, 0x17, 0xbd, 0xff, 0x35, 0x59, 0x0e, 0xc3, 0x06, 0x86, 0xd4, 0x64, 0xcf,
|
||||
/* (2^122)P */ 0x91, 0xa8, 0xdb, 0x57, 0x9b, 0xe2, 0x96, 0x31, 0x10, 0x6e, 0xd7, 0x9a, 0x97, 0xb3, 0xab, 0xb5, 0x15, 0x66, 0xbe, 0xcc, 0x6d, 0x9a, 0xac, 0x06, 0xb3, 0x0d, 0xaa, 0x4b, 0x9c, 0x96, 0x79, 0x6c, 0x34, 0xee, 0x9e, 0x53, 0x4d, 0x6e, 0xbd, 0x88, 0x02, 0xbf, 0x50, 0x54, 0x12, 0x5d, 0x01, 0x02, 0x46, 0xc6, 0x74, 0x02, 0x8c, 0x24, 0xae, 0xb1,
|
||||
/* (2^123)P */ 0xf5, 0x22, 0xea, 0xac, 0x7d, 0x9c, 0x33, 0x8a, 0xa5, 0x36, 0x79, 0x6a, 0x4f, 0xa4, 0xdc, 0xa5, 0x73, 0x64, 0xc4, 0x6f, 0x43, 0x02, 0x3b, 0x94, 0x66, 0xd2, 0x4b, 0x4f, 0xf6, 0x45, 0x33, 0x5d, 0x10, 0x33, 0x18, 0x1e, 0xa3, 0xfc, 0xf7, 0xd2, 0xb8, 0xc8, 0xa7, 0xe0, 0x76, 0x8a, 0xcd, 0xff, 0x4f, 0x99, 0x34, 0x47, 0x84, 0x91, 0x96, 0x9f,
|
||||
/* (2^124)P */ 0x8a, 0x48, 0x3b, 0x48, 0x4a, 0xbc, 0xac, 0xe2, 0x80, 0xd6, 0xd2, 0x35, 0xde, 0xd0, 0x56, 0x42, 0x33, 0xb3, 0x56, 0x5a, 0xcd, 0xb8, 0x3d, 0xb5, 0x25, 0xc1, 0xed, 0xff, 0x87, 0x0b, 0x79, 0xff, 0xf2, 0x62, 0xe1, 0x76, 0xc6, 0xa2, 0x0f, 0xa8, 0x9b, 0x0d, 0xcc, 0x3f, 0x3d, 0x35, 0x27, 0x8d, 0x0b, 0x74, 0xb0, 0xc3, 0x78, 0x8c, 0xcc, 0xc8,
|
||||
/* (2^125)P */ 0xfc, 0x9a, 0x0c, 0xa8, 0x49, 0x42, 0xb8, 0xdf, 0xcf, 0xb3, 0x19, 0xa6, 0x64, 0x57, 0xfe, 0xe8, 0xf8, 0xa6, 0x4b, 0x86, 0xa1, 0xd5, 0x83, 0x7f, 0x14, 0x99, 0x18, 0x0c, 0x7d, 0x5b, 0xf7, 0x3d, 0xf9, 0x4b, 0x79, 0xb1, 0x86, 0x30, 0xb4, 0x5e, 0x6a, 0xe8, 0x9d, 0xfa, 0x8a, 0x41, 0xc4, 0x30, 0xfc, 0x56, 0x74, 0x14, 0x42, 0xc8, 0x96, 0x0e,
|
||||
/* (2^126)P */ 0xdf, 0x66, 0xec, 0xbc, 0x44, 0xdb, 0x19, 0xce, 0xd4, 0xb5, 0x49, 0x40, 0x07, 0x49, 0xe0, 0x3a, 0x61, 0x10, 0xfb, 0x7d, 0xba, 0xb1, 0xe0, 0x28, 0x5b, 0x99, 0x59, 0x96, 0xa2, 0xee, 0xe0, 0x23, 0x37, 0x39, 0x1f, 0xe6, 0x57, 0x9f, 0xf8, 0xf8, 0xdc, 0x74, 0xf6, 0x8f, 0x4f, 0x5e, 0x51, 0xa4, 0x12, 0xac, 0xbe, 0xe4, 0xf3, 0xd1, 0xf0, 0x24,
|
||||
/* (2^127)P */ 0x1e, 0x3e, 0x9a, 0x5f, 0xdf, 0x9f, 0xd6, 0x4e, 0x8a, 0x28, 0xc3, 0xcd, 0x96, 0x9d, 0x57, 0xc7, 0x61, 0x81, 0x90, 0xff, 0xae, 0xb1, 0x4f, 0xc2, 0x96, 0x8b, 0x1a, 0x18, 0xf4, 0x50, 0xcb, 0x31, 0xe1, 0x57, 0xf4, 0x90, 0xa8, 0xea, 0xac, 0xe7, 0x61, 0x98, 0xb6, 0x15, 0xc1, 0x7b, 0x29, 0xa4, 0xc3, 0x18, 0xef, 0xb9, 0xd8, 0xdf, 0xf6, 0xac,
|
||||
/* (2^128)P */ 0xca, 0xa8, 0x6c, 0xf1, 0xb4, 0xca, 0xfe, 0x31, 0xee, 0x48, 0x38, 0x8b, 0x0e, 0xbb, 0x7a, 0x30, 0xaa, 0xf9, 0xee, 0x27, 0x53, 0x24, 0xdc, 0x2e, 0x15, 0xa6, 0x48, 0x8f, 0xa0, 0x7e, 0xf1, 0xdc, 0x93, 0x87, 0x39, 0xeb, 0x7f, 0x38, 0x92, 0x92, 0x4c, 0x29, 0xe9, 0x57, 0xd8, 0x59, 0xfc, 0xe9, 0x9c, 0x44, 0xc0, 0x65, 0xcf, 0xac, 0x4b, 0xdc,
|
||||
/* (2^129)P */ 0xa3, 0xd0, 0x37, 0x8f, 0x86, 0x2f, 0xc6, 0x47, 0x55, 0x46, 0x65, 0x26, 0x4b, 0x91, 0xe2, 0x18, 0x5c, 0x4f, 0x23, 0xc1, 0x37, 0x29, 0xb9, 0xc1, 0x27, 0xc5, 0x3c, 0xbf, 0x7e, 0x23, 0xdb, 0x73, 0x99, 0xbd, 0x1b, 0xb2, 0x31, 0x68, 0x3a, 0xad, 0xb7, 0xb0, 0x10, 0xc5, 0xe5, 0x11, 0x51, 0xba, 0xa7, 0x60, 0x66, 0x54, 0xf0, 0x08, 0xd7, 0x69,
|
||||
/* (2^130)P */ 0x89, 0x41, 0x79, 0xcc, 0xeb, 0x0a, 0xf5, 0x4b, 0xa3, 0x4c, 0xce, 0x52, 0xb0, 0xa7, 0xe4, 0x41, 0x75, 0x7d, 0x04, 0xbb, 0x09, 0x4c, 0x50, 0x9f, 0xdf, 0xea, 0x74, 0x61, 0x02, 0xad, 0xb4, 0x9d, 0xb7, 0x05, 0xb9, 0xea, 0xeb, 0x91, 0x35, 0xe7, 0x49, 0xea, 0xd3, 0x4f, 0x3c, 0x60, 0x21, 0x7a, 0xde, 0xc7, 0xe2, 0x5a, 0xee, 0x8e, 0x93, 0xc7,
|
||||
/* (2^131)P */ 0x00, 0xe8, 0xed, 0xd0, 0xb3, 0x0d, 0xaf, 0xb2, 0xde, 0x2c, 0xf6, 0x00, 0xe2, 0xea, 0x6d, 0xf8, 0x0e, 0xd9, 0x67, 0x59, 0xa9, 0x50, 0xbb, 0x17, 0x8f, 0xff, 0xb1, 0x9f, 0x17, 0xb6, 0xf2, 0xb5, 0xba, 0x80, 0xf7, 0x0f, 0xba, 0xd5, 0x09, 0x43, 0xaa, 0x4e, 0x3a, 0x67, 0x6a, 0x89, 0x9b, 0x18, 0x65, 0x35, 0xf8, 0x3a, 0x49, 0x91, 0x30, 0x51,
|
||||
/* (2^132)P */ 0x8d, 0x25, 0xe9, 0x0e, 0x7d, 0x50, 0x76, 0xe4, 0x58, 0x7e, 0xb9, 0x33, 0xe6, 0x65, 0x90, 0xc2, 0x50, 0x9d, 0x50, 0x2e, 0x11, 0xad, 0xd5, 0x43, 0x52, 0x32, 0x41, 0x4f, 0x7b, 0xb6, 0xa0, 0xec, 0x81, 0x75, 0x36, 0x7c, 0x77, 0x85, 0x59, 0x70, 0xe4, 0xf9, 0xef, 0x66, 0x8d, 0x35, 0xc8, 0x2a, 0x6e, 0x5b, 0xc6, 0x0d, 0x0b, 0x29, 0x60, 0x68,
|
||||
/* (2^133)P */ 0xf8, 0xce, 0xb0, 0x3a, 0x56, 0x7d, 0x51, 0x9a, 0x25, 0x73, 0xea, 0xdd, 0xe4, 0xe0, 0x0e, 0xf0, 0x07, 0xc0, 0x31, 0x00, 0x73, 0x35, 0xd0, 0x39, 0xc4, 0x9b, 0xb7, 0x95, 0xe0, 0x62, 0x70, 0x36, 0x0b, 0xcb, 0xa0, 0x42, 0xde, 0x51, 0xcf, 0x41, 0xe0, 0xb8, 0xb4, 0xc0, 0xe5, 0x46, 0x99, 0x9f, 0x02, 0x7f, 0x14, 0x8c, 0xc1, 0x4e, 0xef, 0xe8,
|
||||
/* (2^134)P */ 0x10, 0x01, 0x57, 0x0a, 0xbe, 0x8b, 0x18, 0xc8, 0xca, 0x00, 0x28, 0x77, 0x4a, 0x9a, 0xc7, 0x55, 0x2a, 0xcc, 0x0c, 0x7b, 0xb9, 0xe9, 0xc8, 0x97, 0x7c, 0x02, 0xe3, 0x09, 0x2f, 0x62, 0x30, 0xb8, 0x40, 0x09, 0x65, 0xe9, 0x55, 0x63, 0xb5, 0x07, 0xca, 0x9f, 0x00, 0xdf, 0x9d, 0x5c, 0xc7, 0xee, 0x57, 0xa5, 0x90, 0x15, 0x1e, 0x22, 0xa0, 0x12,
|
||||
/* (2^135)P */ 0x71, 0x2d, 0xc9, 0xef, 0x27, 0xb9, 0xd8, 0x12, 0x43, 0x6b, 0xa8, 0xce, 0x3b, 0x6d, 0x6e, 0x91, 0x43, 0x23, 0xbc, 0x32, 0xb3, 0xbf, 0xe1, 0xc7, 0x39, 0xcf, 0x7c, 0x42, 0x4c, 0xb1, 0x30, 0xe2, 0xdd, 0x69, 0x06, 0xe5, 0xea, 0xf0, 0x2a, 0x16, 0x50, 0x71, 0xca, 0x92, 0xdf, 0xc1, 0xcc, 0xec, 0xe6, 0x54, 0x07, 0xf3, 0x18, 0x8d, 0xd8, 0x29,
|
||||
/* (2^136)P */ 0x98, 0x51, 0x48, 0x8f, 0xfa, 0x2e, 0x5e, 0x67, 0xb0, 0xc6, 0x17, 0x12, 0xb6, 0x7d, 0xc9, 0xad, 0x81, 0x11, 0xad, 0x0c, 0x1c, 0x2d, 0x45, 0xdf, 0xac, 0x66, 0xbd, 0x08, 0x6f, 0x7c, 0xc7, 0x06, 0x6e, 0x19, 0x08, 0x39, 0x64, 0xd7, 0xe4, 0xd1, 0x11, 0x5f, 0x1c, 0xf4, 0x67, 0xc3, 0x88, 0x6a, 0xe6, 0x07, 0xa3, 0x83, 0xd7, 0xfd, 0x2a, 0xf9,
|
||||
/* (2^137)P */ 0x87, 0xed, 0xeb, 0xd9, 0xdf, 0xff, 0x43, 0x8b, 0xaa, 0x20, 0x58, 0xb0, 0xb4, 0x6b, 0x14, 0xb8, 0x02, 0xc5, 0x40, 0x20, 0x22, 0xbb, 0xf7, 0xb4, 0xf3, 0x05, 0x1e, 0x4d, 0x94, 0xff, 0xe3, 0xc5, 0x22, 0x82, 0xfe, 0xaf, 0x90, 0x42, 0x98, 0x6b, 0x76, 0x8b, 0x3e, 0x89, 0x3f, 0x42, 0x2a, 0xa7, 0x26, 0x00, 0xda, 0x5c, 0xa2, 0x2b, 0xec, 0xdd,
|
||||
/* (2^138)P */ 0x5c, 0x21, 0x16, 0x0d, 0x46, 0xb8, 0xd0, 0xa7, 0x88, 0xe7, 0x25, 0xcb, 0x3e, 0x50, 0x73, 0x61, 0xe7, 0xaf, 0x5a, 0x3f, 0x47, 0x8b, 0x3d, 0x97, 0x79, 0x2c, 0xe6, 0x6d, 0x95, 0x74, 0x65, 0x70, 0x36, 0xfd, 0xd1, 0x9e, 0x13, 0x18, 0x63, 0xb1, 0x2d, 0x0b, 0xb5, 0x36, 0x3e, 0xe7, 0x35, 0x42, 0x3b, 0xe6, 0x1f, 0x4d, 0x9d, 0x59, 0xa2, 0x43,
|
||||
/* (2^139)P */ 0x8c, 0x0c, 0x7c, 0x24, 0x9e, 0xe0, 0xf8, 0x05, 0x1c, 0x9e, 0x1f, 0x31, 0xc0, 0x70, 0xb3, 0xfb, 0x4e, 0xf8, 0x0a, 0x57, 0xb7, 0x49, 0xb5, 0x73, 0xa1, 0x5f, 0x9b, 0x6a, 0x07, 0x6c, 0x87, 0x71, 0x87, 0xd4, 0xbe, 0x98, 0x1e, 0x98, 0xee, 0x52, 0xc1, 0x7b, 0x95, 0x0f, 0x28, 0x32, 0x36, 0x28, 0xd0, 0x3a, 0x0f, 0x7d, 0x2a, 0xa9, 0x62, 0xb9,
|
||||
/* (2^140)P */ 0x97, 0xe6, 0x18, 0x77, 0xf9, 0x34, 0xac, 0xbc, 0xe0, 0x62, 0x9f, 0x42, 0xde, 0xbd, 0x2f, 0xf7, 0x1f, 0xb7, 0x14, 0x52, 0x8a, 0x79, 0xb2, 0x3f, 0xd2, 0x95, 0x71, 0x01, 0xe8, 0xaf, 0x8c, 0xa4, 0xa4, 0xa7, 0x27, 0xf3, 0x5c, 0xdf, 0x3e, 0x57, 0x7a, 0xf1, 0x76, 0x49, 0xe6, 0x42, 0x3f, 0x8f, 0x1e, 0x63, 0x4a, 0x65, 0xb5, 0x41, 0xf5, 0x02,
|
||||
/* (2^141)P */ 0x72, 0x85, 0xc5, 0x0b, 0xe1, 0x47, 0x64, 0x02, 0xc5, 0x4d, 0x81, 0x69, 0xb2, 0xcf, 0x0f, 0x6c, 0xd4, 0x6d, 0xd0, 0xc7, 0xb4, 0x1c, 0xd0, 0x32, 0x59, 0x89, 0xe2, 0xe0, 0x96, 0x8b, 0x12, 0x98, 0xbf, 0x63, 0x7a, 0x4c, 0x76, 0x7e, 0x58, 0x17, 0x8f, 0x5b, 0x0a, 0x59, 0x65, 0x75, 0xbc, 0x61, 0x1f, 0xbe, 0xc5, 0x6e, 0x0a, 0x57, 0x52, 0x70,
|
||||
/* (2^142)P */ 0x92, 0x1c, 0x77, 0xbb, 0x62, 0x02, 0x6c, 0x25, 0x9c, 0x66, 0x07, 0x83, 0xab, 0xcc, 0x80, 0x5d, 0xd2, 0x76, 0x0c, 0xa4, 0xc5, 0xb4, 0x8a, 0x68, 0x23, 0x31, 0x32, 0x29, 0x8a, 0x47, 0x92, 0x12, 0x80, 0xb3, 0xfa, 0x18, 0xe4, 0x8d, 0xc0, 0x4d, 0xfe, 0x97, 0x5f, 0x72, 0x41, 0xb5, 0x5c, 0x7a, 0xbd, 0xf0, 0xcf, 0x5e, 0x97, 0xaa, 0x64, 0x32,
|
||||
/* (2^143)P */ 0x35, 0x3f, 0x75, 0xc1, 0x7a, 0x75, 0x7e, 0xa9, 0xc6, 0x0b, 0x4e, 0x32, 0x62, 0xec, 0xe3, 0x5c, 0xfb, 0x01, 0x43, 0xb6, 0xd4, 0x5b, 0x75, 0xd2, 0xee, 0x7f, 0x5d, 0x23, 0x2b, 0xb3, 0x54, 0x34, 0x4c, 0xd3, 0xb4, 0x32, 0x84, 0x81, 0xb5, 0x09, 0x76, 0x19, 0xda, 0x58, 0xda, 0x7c, 0xdb, 0x2e, 0xdd, 0x4c, 0x8e, 0xdd, 0x5d, 0x89, 0x10, 0x10,
|
||||
/* (2^144)P */ 0x57, 0x25, 0x6a, 0x08, 0x37, 0x92, 0xa8, 0xdf, 0x24, 0xef, 0x8f, 0x33, 0x34, 0x52, 0xa4, 0x4c, 0xf0, 0x77, 0x9f, 0x69, 0x77, 0xd5, 0x8f, 0xd2, 0x9a, 0xb3, 0xb6, 0x1d, 0x2d, 0xa6, 0xf7, 0x1f, 0xda, 0xd7, 0xcb, 0x75, 0x11, 0xc3, 0x6b, 0xc0, 0x38, 0xb1, 0xd5, 0x2d, 0x96, 0x84, 0x16, 0xfa, 0x26, 0xb9, 0xcc, 0x3f, 0x16, 0x47, 0x23, 0x74,
|
||||
/* (2^145)P */ 0x9b, 0x61, 0x2a, 0x1c, 0xdd, 0x39, 0xa5, 0xfa, 0x1c, 0x7d, 0x63, 0x50, 0xca, 0xe6, 0x9d, 0xfa, 0xb7, 0xc4, 0x4c, 0x6a, 0x97, 0x5f, 0x36, 0x4e, 0x47, 0xdd, 0x17, 0xf7, 0xf9, 0x19, 0xce, 0x75, 0x17, 0xad, 0xce, 0x2a, 0xf3, 0xfe, 0x27, 0x8f, 0x3e, 0x48, 0xc0, 0x60, 0x87, 0x24, 0x19, 0xae, 0x59, 0xe4, 0x5a, 0x00, 0x2a, 0xba, 0xa2, 0x1f,
|
||||
/* (2^146)P */ 0x26, 0x88, 0x42, 0x60, 0x9f, 0x6e, 0x2c, 0x7c, 0x39, 0x0f, 0x47, 0x6a, 0x0e, 0x02, 0xbb, 0x4b, 0x34, 0x29, 0x55, 0x18, 0x36, 0xcf, 0x3b, 0x47, 0xf1, 0x2e, 0xfc, 0x6e, 0x94, 0xff, 0xe8, 0x6b, 0x06, 0xd2, 0xba, 0x77, 0x5e, 0x60, 0xd7, 0x19, 0xef, 0x02, 0x9d, 0x3a, 0xc2, 0xb7, 0xa9, 0xd8, 0x57, 0xee, 0x7e, 0x2b, 0xf2, 0x6d, 0x28, 0xda,
|
||||
/* (2^147)P */ 0xdf, 0xd9, 0x92, 0x11, 0x98, 0x23, 0xe2, 0x45, 0x2f, 0x74, 0x70, 0xee, 0x0e, 0x55, 0x65, 0x79, 0x86, 0x38, 0x17, 0x92, 0x85, 0x87, 0x99, 0x50, 0xd9, 0x7c, 0xdb, 0xa1, 0x10, 0xec, 0x30, 0xb7, 0x40, 0xa3, 0x23, 0x9b, 0x0e, 0x27, 0x49, 0x29, 0x03, 0x94, 0xff, 0x53, 0xdc, 0xd7, 0xed, 0x49, 0xa9, 0x5a, 0x3b, 0xee, 0xd7, 0xc7, 0x65, 0xaf,
|
||||
/* (2^148)P */ 0xa0, 0xbd, 0xbe, 0x03, 0xee, 0x0c, 0xbe, 0x32, 0x00, 0x7b, 0x52, 0xcb, 0x92, 0x29, 0xbf, 0xa0, 0xc6, 0xd9, 0xd2, 0xd6, 0x15, 0xe8, 0x3a, 0x75, 0x61, 0x65, 0x56, 0xae, 0xad, 0x3c, 0x2a, 0x64, 0x14, 0x3f, 0x8e, 0xc1, 0x2d, 0x0c, 0x8d, 0x20, 0xdb, 0x58, 0x4b, 0xe5, 0x40, 0x15, 0x4b, 0xdc, 0xa8, 0xbd, 0xef, 0x08, 0xa7, 0xd1, 0xf4, 0xb0,
|
||||
/* (2^149)P */ 0xa9, 0x0f, 0x05, 0x94, 0x66, 0xac, 0x1f, 0x65, 0x3f, 0xe1, 0xb8, 0xe1, 0x34, 0x5e, 0x1d, 0x8f, 0xe3, 0x93, 0x03, 0x15, 0xff, 0xb6, 0x65, 0xb6, 0x6e, 0xc0, 0x2f, 0xd4, 0x2e, 0xb9, 0x2c, 0x13, 0x3c, 0x99, 0x1c, 0xb5, 0x87, 0xba, 0x79, 0xcb, 0xf0, 0x18, 0x06, 0x86, 0x04, 0x14, 0x25, 0x09, 0xcd, 0x1c, 0x14, 0xda, 0x35, 0xd0, 0x38, 0x3b,
|
||||
/* (2^150)P */ 0x1b, 0x04, 0xa3, 0x27, 0xb4, 0xd3, 0x37, 0x48, 0x1e, 0x8f, 0x69, 0xd3, 0x5a, 0x2f, 0x20, 0x02, 0x36, 0xbe, 0x06, 0x7b, 0x6b, 0x6c, 0x12, 0x5b, 0x80, 0x74, 0x44, 0xe6, 0xf8, 0xf5, 0x95, 0x59, 0x29, 0xab, 0x51, 0x47, 0x83, 0x28, 0xe0, 0xad, 0xde, 0xaa, 0xd3, 0xb1, 0x1a, 0xcb, 0xa3, 0xcd, 0x8b, 0x6a, 0xb1, 0xa7, 0x0a, 0xd1, 0xf9, 0xbe,
|
||||
/* (2^151)P */ 0xce, 0x2f, 0x85, 0xca, 0x74, 0x6d, 0x49, 0xb8, 0xce, 0x80, 0x44, 0xe0, 0xda, 0x5b, 0xcf, 0x2f, 0x79, 0x74, 0xfe, 0xb4, 0x2c, 0x99, 0x20, 0x6e, 0x09, 0x04, 0xfb, 0x6d, 0x57, 0x5b, 0x95, 0x0c, 0x45, 0xda, 0x4f, 0x7f, 0x63, 0xcc, 0x85, 0x5a, 0x67, 0x50, 0x68, 0x71, 0xb4, 0x67, 0xb1, 0x2e, 0xc1, 0x1c, 0xdc, 0xff, 0x2a, 0x7c, 0x10, 0x5e,
|
||||
/* (2^152)P */ 0xa6, 0xde, 0xf3, 0xd4, 0x22, 0x30, 0x24, 0x9e, 0x0b, 0x30, 0x54, 0x59, 0x7e, 0xa2, 0xeb, 0x89, 0x54, 0x65, 0x3e, 0x40, 0xd1, 0xde, 0xe6, 0xee, 0x4d, 0xbf, 0x5e, 0x40, 0x1d, 0xee, 0x4f, 0x68, 0xd9, 0xa7, 0x2f, 0xb3, 0x64, 0xb3, 0xf5, 0xc8, 0xd3, 0xaa, 0x70, 0x70, 0x3d, 0xef, 0xd3, 0x95, 0x54, 0xdb, 0x3e, 0x94, 0x95, 0x92, 0x1f, 0x45,
|
||||
/* (2^153)P */ 0x22, 0x80, 0x1d, 0x9d, 0x96, 0xa5, 0x78, 0x6f, 0xe0, 0x1e, 0x1b, 0x66, 0x42, 0xc8, 0xae, 0x9e, 0x46, 0x45, 0x08, 0x41, 0xdf, 0x80, 0xae, 0x6f, 0xdb, 0x15, 0x5a, 0x21, 0x31, 0x7a, 0xd0, 0xf2, 0x54, 0x15, 0x88, 0xd3, 0x0f, 0x7f, 0x14, 0x5a, 0x14, 0x97, 0xab, 0xf4, 0x58, 0x6a, 0x9f, 0xea, 0x74, 0xe5, 0x6b, 0x90, 0x59, 0x2b, 0x48, 0xd9,
|
||||
/* (2^154)P */ 0x12, 0x24, 0x04, 0xf5, 0x50, 0xc2, 0x8c, 0xb0, 0x7c, 0x46, 0x98, 0xd5, 0x24, 0xad, 0xf6, 0x72, 0xdc, 0x82, 0x1a, 0x60, 0xc1, 0xeb, 0x48, 0xef, 0x7f, 0x6e, 0xe6, 0xcc, 0xdb, 0x7b, 0xae, 0xbe, 0x5e, 0x1e, 0x5c, 0xe6, 0x0a, 0x70, 0xdf, 0xa4, 0xa3, 0x85, 0x1b, 0x1b, 0x7f, 0x72, 0xb9, 0x96, 0x6f, 0xdc, 0x03, 0x76, 0x66, 0xfb, 0xa0, 0x33,
|
||||
/* (2^155)P */ 0x37, 0x40, 0xbb, 0xbc, 0x68, 0x58, 0x86, 0xca, 0xbb, 0xa5, 0x24, 0x76, 0x3d, 0x48, 0xd1, 0xad, 0xb4, 0xa8, 0xcf, 0xc3, 0xb6, 0xa8, 0xba, 0x1a, 0x3a, 0xbe, 0x33, 0x75, 0x04, 0x5c, 0x13, 0x8c, 0x0d, 0x70, 0x8d, 0xa6, 0x4e, 0x2a, 0xeb, 0x17, 0x3c, 0x22, 0xdd, 0x3e, 0x96, 0x40, 0x11, 0x9e, 0x4e, 0xae, 0x3d, 0xf8, 0x91, 0xd7, 0x50, 0xc8,
|
||||
/* (2^156)P */ 0xd8, 0xca, 0xde, 0x19, 0xcf, 0x00, 0xe4, 0x73, 0x18, 0x7f, 0x9b, 0x9f, 0xf4, 0x5b, 0x49, 0x49, 0x99, 0xdc, 0xa4, 0x46, 0x21, 0xb5, 0xd7, 0x3e, 0xb7, 0x47, 0x1b, 0xa9, 0x9f, 0x4c, 0x69, 0x7d, 0xec, 0x33, 0xd6, 0x1c, 0x51, 0x7f, 0x47, 0x74, 0x7a, 0x6c, 0xf3, 0xd2, 0x2e, 0xbf, 0xdf, 0x6c, 0x9e, 0x77, 0x3b, 0x34, 0xf6, 0x73, 0x80, 0xed,
|
||||
/* (2^157)P */ 0x16, 0xfb, 0x16, 0xc3, 0xc2, 0x83, 0xe4, 0xf4, 0x03, 0x7f, 0x52, 0xb0, 0x67, 0x51, 0x7b, 0x24, 0x5a, 0x51, 0xd3, 0xb6, 0x4e, 0x59, 0x76, 0xcd, 0x08, 0x7b, 0x1d, 0x7a, 0x9c, 0x65, 0xae, 0xce, 0xaa, 0xd2, 0x1c, 0x85, 0x66, 0x68, 0x06, 0x15, 0xa8, 0x06, 0xe6, 0x16, 0x37, 0xf4, 0x49, 0x9e, 0x0f, 0x50, 0x37, 0xb1, 0xb2, 0x93, 0x70, 0x43,
|
||||
/* (2^158)P */ 0x18, 0x3a, 0x16, 0xe5, 0x8d, 0xc8, 0x35, 0xd6, 0x7b, 0x09, 0xec, 0x61, 0x5f, 0x5c, 0x2a, 0x19, 0x96, 0x2e, 0xc3, 0xfd, 0xab, 0xe6, 0x23, 0xae, 0xab, 0xc5, 0xcb, 0xb9, 0x7b, 0x2d, 0x34, 0x51, 0xb9, 0x41, 0x9e, 0x7d, 0xca, 0xda, 0x25, 0x45, 0x14, 0xb0, 0xc7, 0x4d, 0x26, 0x2b, 0xfe, 0x43, 0xb0, 0x21, 0x5e, 0xfa, 0xdc, 0x7c, 0xf9, 0x5a,
|
||||
/* (2^159)P */ 0x94, 0xad, 0x42, 0x17, 0xf5, 0xcd, 0x1c, 0x0d, 0xf6, 0x41, 0xd2, 0x55, 0xbb, 0x50, 0xf1, 0xc6, 0xbc, 0xa6, 0xc5, 0x3a, 0xfd, 0x9b, 0x75, 0x3e, 0xf6, 0x1a, 0xa7, 0xb2, 0x6e, 0x64, 0x12, 0xdc, 0x3c, 0xe5, 0xf6, 0xfc, 0x3b, 0xfa, 0x43, 0x81, 0xd4, 0xa5, 0xee, 0xf5, 0x9c, 0x47, 0x2f, 0xd0, 0x9c, 0xde, 0xa1, 0x48, 0x91, 0x9a, 0x34, 0xc1,
|
||||
/* (2^160)P */ 0x37, 0x1b, 0xb3, 0x88, 0xc9, 0x98, 0x4e, 0xfb, 0x84, 0x4f, 0x2b, 0x0a, 0xb6, 0x8f, 0x35, 0x15, 0xcd, 0x61, 0x7a, 0x5f, 0x5c, 0xa0, 0xca, 0x23, 0xa0, 0x93, 0x1f, 0xcc, 0x3c, 0x39, 0x3a, 0x24, 0xa7, 0x49, 0xad, 0x8d, 0x59, 0xcc, 0x94, 0x5a, 0x16, 0xf5, 0x70, 0xe8, 0x52, 0x1e, 0xee, 0x20, 0x30, 0x17, 0x7e, 0xf0, 0x4c, 0x93, 0x06, 0x5a,
|
||||
/* (2^161)P */ 0x81, 0xba, 0x3b, 0xd7, 0x3e, 0xb4, 0x32, 0x3a, 0x22, 0x39, 0x2a, 0xfc, 0x19, 0xd9, 0xd2, 0xf6, 0xc5, 0x79, 0x6c, 0x0e, 0xde, 0xda, 0x01, 0xff, 0x52, 0xfb, 0xb6, 0x95, 0x4e, 0x7a, 0x10, 0xb8, 0x06, 0x86, 0x3c, 0xcd, 0x56, 0xd6, 0x15, 0xbf, 0x6e, 0x3e, 0x4f, 0x35, 0x5e, 0xca, 0xbc, 0xa5, 0x95, 0xa2, 0xdf, 0x2d, 0x1d, 0xaf, 0x59, 0xf9,
|
||||
/* (2^162)P */ 0x69, 0xe5, 0xe2, 0xfa, 0xc9, 0x7f, 0xdd, 0x09, 0xf5, 0x6b, 0x4e, 0x2e, 0xbe, 0xb4, 0xbf, 0x3e, 0xb2, 0xf2, 0x81, 0x30, 0xe1, 0x07, 0xa8, 0x0d, 0x2b, 0xd2, 0x5a, 0x55, 0xbe, 0x4b, 0x86, 0x5d, 0xb0, 0x5e, 0x7c, 0x8f, 0xc1, 0x3c, 0x81, 0x4c, 0xf7, 0x6d, 0x7d, 0xe6, 0x4f, 0x8a, 0x85, 0xc2, 0x2f, 0x28, 0xef, 0x8c, 0x69, 0xc2, 0xc2, 0x1a,
|
||||
/* (2^163)P */ 0xd9, 0xe4, 0x0e, 0x1e, 0xc2, 0xf7, 0x2f, 0x9f, 0xa1, 0x40, 0xfe, 0x46, 0x16, 0xaf, 0x2e, 0xd1, 0xec, 0x15, 0x9b, 0x61, 0x92, 0xce, 0xfc, 0x10, 0x43, 0x1d, 0x00, 0xf6, 0xbe, 0x20, 0x80, 0x80, 0x6f, 0x3c, 0x16, 0x94, 0x59, 0xba, 0x03, 0x53, 0x6e, 0xb6, 0xdd, 0x25, 0x7b, 0x86, 0xbf, 0x96, 0xf4, 0x2f, 0xa1, 0x96, 0x8d, 0xf9, 0xb3, 0x29,
|
||||
/* (2^164)P */ 0x3b, 0x04, 0x60, 0x6e, 0xce, 0xab, 0xd2, 0x63, 0x18, 0x53, 0x88, 0x16, 0x4a, 0x6a, 0xab, 0x72, 0x03, 0x68, 0xa5, 0xd4, 0x0d, 0xb2, 0x82, 0x81, 0x1f, 0x2b, 0x5c, 0x75, 0xe8, 0xd2, 0x1d, 0x7f, 0xe7, 0x1b, 0x35, 0x02, 0xde, 0xec, 0xbd, 0xcb, 0xc7, 0x01, 0xd3, 0x95, 0x61, 0xfe, 0xb2, 0x7a, 0x66, 0x09, 0x4c, 0x6d, 0xfd, 0x39, 0xf7, 0x52,
|
||||
/* (2^165)P */ 0x42, 0xc1, 0x5f, 0xf8, 0x35, 0x52, 0xc1, 0xfe, 0xc5, 0x11, 0x80, 0x1c, 0x11, 0x46, 0x31, 0x11, 0xbe, 0xd0, 0xc4, 0xb6, 0x07, 0x13, 0x38, 0xa0, 0x8d, 0x65, 0xf0, 0x56, 0x9e, 0x16, 0xbf, 0x9d, 0xcd, 0x51, 0x34, 0xf9, 0x08, 0x48, 0x7b, 0x76, 0x0c, 0x7b, 0x30, 0x07, 0xa8, 0x76, 0xaf, 0xa3, 0x29, 0x38, 0xb0, 0x58, 0xde, 0x72, 0x4b, 0x45,
|
||||
/* (2^166)P */ 0xd4, 0x16, 0xa7, 0xc0, 0xb4, 0x9f, 0xdf, 0x1a, 0x37, 0xc8, 0x35, 0xed, 0xc5, 0x85, 0x74, 0x64, 0x09, 0x22, 0xef, 0xe9, 0x0c, 0xaf, 0x12, 0x4c, 0x9e, 0xf8, 0x47, 0x56, 0xe0, 0x7f, 0x4e, 0x24, 0x6b, 0x0c, 0xe7, 0xad, 0xc6, 0x47, 0x1d, 0xa4, 0x0d, 0x86, 0x89, 0x65, 0xe8, 0x5f, 0x71, 0xc7, 0xe9, 0xcd, 0xec, 0x6c, 0x62, 0xc7, 0xe3, 0xb3,
|
||||
/* (2^167)P */ 0xb5, 0xea, 0x86, 0xe3, 0x15, 0x18, 0x3f, 0x6d, 0x7b, 0x05, 0x95, 0x15, 0x53, 0x26, 0x1c, 0xeb, 0xbe, 0x7e, 0x16, 0x42, 0x4b, 0xa2, 0x3d, 0xdd, 0x0e, 0xff, 0xba, 0x67, 0xb5, 0xae, 0x7a, 0x17, 0xde, 0x23, 0xad, 0x14, 0xcc, 0xd7, 0xaf, 0x57, 0x01, 0xe0, 0xdd, 0x48, 0xdd, 0xd7, 0xe3, 0xdf, 0xe9, 0x2d, 0xda, 0x67, 0xa4, 0x9f, 0x29, 0x04,
|
||||
/* (2^168)P */ 0x16, 0x53, 0xe6, 0x9c, 0x4e, 0xe5, 0x1e, 0x70, 0x81, 0x25, 0x02, 0x9b, 0x47, 0x6d, 0xd2, 0x08, 0x73, 0xbe, 0x0a, 0xf1, 0x7b, 0xeb, 0x24, 0xeb, 0x38, 0x23, 0x5c, 0xb6, 0x3e, 0xce, 0x1e, 0xe3, 0xbc, 0x82, 0x35, 0x1f, 0xaf, 0x3a, 0x3a, 0xe5, 0x4e, 0xc1, 0xca, 0xbf, 0x47, 0xb4, 0xbb, 0xbc, 0x5f, 0xea, 0xc6, 0xca, 0xf3, 0xa0, 0xa2, 0x73,
|
||||
/* (2^169)P */ 0xef, 0xa4, 0x7a, 0x4e, 0xe4, 0xc7, 0xb6, 0x43, 0x2e, 0xa5, 0xe4, 0xa5, 0xba, 0x1e, 0xa5, 0xfe, 0x9e, 0xce, 0xa9, 0x80, 0x04, 0xcb, 0x4f, 0xd8, 0x74, 0x05, 0x48, 0xfa, 0x99, 0x11, 0x5d, 0x97, 0x3b, 0x07, 0x0d, 0xdd, 0xe6, 0xb1, 0x74, 0x87, 0x1a, 0xd3, 0x26, 0xb7, 0x8f, 0xe1, 0x63, 0x3d, 0xec, 0x53, 0x93, 0xb0, 0x81, 0x78, 0x34, 0xa4,
|
||||
/* (2^170)P */ 0xe1, 0xe7, 0xd4, 0x58, 0x9d, 0x0e, 0x8b, 0x65, 0x66, 0x37, 0x16, 0x48, 0x6f, 0xaa, 0x42, 0x37, 0x77, 0xad, 0xb1, 0x56, 0x48, 0xdf, 0x65, 0x36, 0x30, 0xb8, 0x00, 0x12, 0xd8, 0x32, 0x28, 0x7f, 0xc1, 0x71, 0xeb, 0x93, 0x0f, 0x48, 0x04, 0xe1, 0x5a, 0x6a, 0x96, 0xc1, 0xca, 0x89, 0x6d, 0x1b, 0x82, 0x4c, 0x18, 0x6d, 0x55, 0x4b, 0xea, 0xfd,
|
||||
/* (2^171)P */ 0x62, 0x1a, 0x53, 0xb4, 0xb1, 0xbe, 0x6f, 0x15, 0x18, 0x88, 0xd4, 0x66, 0x61, 0xc7, 0x12, 0x69, 0x02, 0xbd, 0x03, 0x23, 0x2b, 0xef, 0xf9, 0x54, 0xa4, 0x85, 0xa8, 0xe3, 0xb7, 0xbd, 0xa9, 0xa3, 0xf3, 0x2a, 0xdd, 0xf1, 0xd4, 0x03, 0x0f, 0xa9, 0xa1, 0xd8, 0xa3, 0xcd, 0xb2, 0x71, 0x90, 0x4b, 0x35, 0x62, 0xf2, 0x2f, 0xce, 0x67, 0x1f, 0xaa,
|
||||
/* (2^172)P */ 0x9e, 0x1e, 0xcd, 0x43, 0x7e, 0x87, 0x37, 0x94, 0x3a, 0x97, 0x4c, 0x7e, 0xee, 0xc9, 0x37, 0x85, 0xf1, 0xd9, 0x4f, 0xbf, 0xf9, 0x6f, 0x39, 0x9a, 0x39, 0x87, 0x2e, 0x25, 0x84, 0x42, 0xc3, 0x80, 0xcb, 0x07, 0x22, 0xae, 0x30, 0xd5, 0x50, 0xa1, 0x23, 0xcc, 0x31, 0x81, 0x9d, 0xf1, 0x30, 0xd9, 0x2b, 0x73, 0x41, 0x16, 0x50, 0xab, 0x2d, 0xa2,
|
||||
/* (2^173)P */ 0xa4, 0x69, 0x4f, 0xa1, 0x4e, 0xb9, 0xbf, 0x14, 0xe8, 0x2b, 0x04, 0x93, 0xb7, 0x6e, 0x9f, 0x7d, 0x73, 0x0a, 0xc5, 0x14, 0xb8, 0xde, 0x8c, 0xc1, 0xfe, 0xc0, 0xa7, 0xa4, 0xcc, 0x42, 0x42, 0x81, 0x15, 0x65, 0x8a, 0x80, 0xb9, 0xde, 0x1f, 0x60, 0x33, 0x0e, 0xcb, 0xfc, 0xe0, 0xdb, 0x83, 0xa1, 0xe5, 0xd0, 0x16, 0x86, 0x2c, 0xe2, 0x87, 0xed,
|
||||
/* (2^174)P */ 0x7a, 0xc0, 0xeb, 0x6b, 0xf6, 0x0d, 0x4c, 0x6d, 0x1e, 0xdb, 0xab, 0xe7, 0x19, 0x45, 0xc6, 0xe3, 0xb2, 0x06, 0xbb, 0xbc, 0x70, 0x99, 0x83, 0x33, 0xeb, 0x28, 0xc8, 0x77, 0xf6, 0x4d, 0x01, 0xb7, 0x59, 0xa0, 0xd2, 0xb3, 0x2a, 0x72, 0x30, 0xe7, 0x11, 0x39, 0xb6, 0x41, 0x29, 0x65, 0x5a, 0x14, 0xb9, 0x86, 0x08, 0xe0, 0x7d, 0x32, 0x8c, 0xf0,
|
||||
/* (2^175)P */ 0x5c, 0x11, 0x30, 0x9e, 0x05, 0x27, 0xf5, 0x45, 0x0f, 0xb3, 0xc9, 0x75, 0xc3, 0xd7, 0xe1, 0x82, 0x3b, 0x8e, 0x87, 0x23, 0x00, 0x15, 0x19, 0x07, 0xd9, 0x21, 0x53, 0xc7, 0xf1, 0xa3, 0xbf, 0x70, 0x64, 0x15, 0x18, 0xca, 0x23, 0x9e, 0xd3, 0x08, 0xc3, 0x2a, 0x8b, 0xe5, 0x83, 0x04, 0x89, 0x14, 0xfd, 0x28, 0x25, 0x1c, 0xe3, 0x26, 0xa7, 0x22,
|
||||
/* (2^176)P */ 0xdc, 0xd4, 0x75, 0x60, 0x99, 0x94, 0xea, 0x09, 0x8e, 0x8a, 0x3c, 0x1b, 0xf9, 0xbd, 0x33, 0x0d, 0x51, 0x3d, 0x12, 0x6f, 0x4e, 0x72, 0xe0, 0x17, 0x20, 0xe9, 0x75, 0xe6, 0x3a, 0xb2, 0x13, 0x83, 0x4e, 0x7a, 0x08, 0x9e, 0xd1, 0x04, 0x5f, 0x6b, 0x42, 0x0b, 0x76, 0x2a, 0x2d, 0x77, 0x53, 0x6c, 0x65, 0x6d, 0x8e, 0x25, 0x3c, 0xb6, 0x8b, 0x69,
|
||||
/* (2^177)P */ 0xb9, 0x49, 0x28, 0xd0, 0xdc, 0x6c, 0x8f, 0x4c, 0xc9, 0x14, 0x8a, 0x38, 0xa3, 0xcb, 0xc4, 0x9d, 0x53, 0xcf, 0xe9, 0xe3, 0xcf, 0xe0, 0xb1, 0xf2, 0x1b, 0x4c, 0x7f, 0x83, 0x2a, 0x7a, 0xe9, 0x8b, 0x3b, 0x86, 0x61, 0x30, 0xe9, 0x99, 0xbd, 0xba, 0x19, 0x6e, 0x65, 0x2a, 0x12, 0x3e, 0x9c, 0xa8, 0xaf, 0xc3, 0xcf, 0xf8, 0x1f, 0x77, 0x86, 0xea,
|
||||
/* (2^178)P */ 0x30, 0xde, 0xe7, 0xff, 0x54, 0xf7, 0xa2, 0x59, 0xf6, 0x0b, 0xfb, 0x7a, 0xf2, 0x39, 0xf0, 0xdb, 0x39, 0xbc, 0xf0, 0xfa, 0x60, 0xeb, 0x6b, 0x4f, 0x47, 0x17, 0xc8, 0x00, 0x65, 0x6d, 0x25, 0x1c, 0xd0, 0x48, 0x56, 0x53, 0x45, 0x11, 0x30, 0x02, 0x49, 0x20, 0x27, 0xac, 0xf2, 0x4c, 0xac, 0x64, 0x3d, 0x52, 0xb8, 0x89, 0xe0, 0x93, 0x16, 0x0f,
|
||||
/* (2^179)P */ 0x84, 0x09, 0xba, 0x40, 0xb2, 0x2f, 0xa3, 0xa8, 0xc2, 0xba, 0x46, 0x33, 0x05, 0x9d, 0x62, 0xad, 0xa1, 0x3c, 0x33, 0xef, 0x0d, 0xeb, 0xf0, 0x77, 0x11, 0x5a, 0xb0, 0x21, 0x9c, 0xdf, 0x55, 0x24, 0x25, 0x35, 0x51, 0x61, 0x92, 0xf0, 0xb1, 0xce, 0xf5, 0xd4, 0x7b, 0x6c, 0x21, 0x9d, 0x56, 0x52, 0xf8, 0xa1, 0x4c, 0xe9, 0x27, 0x55, 0xac, 0x91,
|
||||
/* (2^180)P */ 0x03, 0x3e, 0x30, 0xd2, 0x0a, 0xfa, 0x7d, 0x82, 0x3d, 0x1f, 0x8b, 0xcb, 0xb6, 0x04, 0x5c, 0xcc, 0x8b, 0xda, 0xe2, 0x68, 0x74, 0x08, 0x8c, 0x44, 0x83, 0x57, 0x6d, 0x6f, 0x80, 0xb0, 0x7e, 0xa9, 0x82, 0x91, 0x7b, 0x4c, 0x37, 0x97, 0xd1, 0x63, 0xd1, 0xbd, 0x45, 0xe6, 0x8a, 0x86, 0xd6, 0x89, 0x54, 0xfd, 0xd2, 0xb1, 0xd7, 0x54, 0xad, 0xaf,
|
||||
/* (2^181)P */ 0x8b, 0x33, 0x62, 0x49, 0x9f, 0x63, 0xf9, 0x87, 0x42, 0x58, 0xbf, 0xb3, 0xe6, 0x68, 0x02, 0x60, 0x5c, 0x76, 0x62, 0xf7, 0x61, 0xd7, 0x36, 0x31, 0xf7, 0x9c, 0xb5, 0xe5, 0x13, 0x6c, 0xea, 0x78, 0xae, 0xcf, 0xde, 0xbf, 0xb6, 0xeb, 0x4f, 0xc8, 0x2a, 0xb4, 0x9a, 0x9f, 0xf3, 0xd1, 0x6a, 0xec, 0x0c, 0xbd, 0x85, 0x98, 0x40, 0x06, 0x1c, 0x2a,
|
||||
/* (2^182)P */ 0x74, 0x3b, 0xe7, 0x81, 0xd5, 0xae, 0x54, 0x56, 0x03, 0xe8, 0x97, 0x16, 0x76, 0xcf, 0x24, 0x96, 0x96, 0x5b, 0xcc, 0x09, 0xab, 0x23, 0x6f, 0x54, 0xae, 0x8f, 0xe4, 0x12, 0xcb, 0xfd, 0xbc, 0xac, 0x93, 0x45, 0x3d, 0x68, 0x08, 0x22, 0x59, 0xc6, 0xf0, 0x47, 0x19, 0x8c, 0x79, 0x93, 0x1e, 0x0e, 0x30, 0xb0, 0x94, 0xfb, 0x17, 0x1d, 0x5a, 0x12,
|
||||
/* (2^183)P */ 0x85, 0xff, 0x40, 0x18, 0x85, 0xff, 0x44, 0x37, 0x69, 0x23, 0x4d, 0x34, 0xe1, 0xeb, 0xa3, 0x1b, 0x55, 0x40, 0xc1, 0x64, 0xf4, 0xd4, 0x13, 0x0a, 0x9f, 0xb9, 0x19, 0xfc, 0x88, 0x7d, 0xc0, 0x72, 0xcf, 0x69, 0x2f, 0xd2, 0x0c, 0x82, 0x0f, 0xda, 0x08, 0xba, 0x0f, 0xaa, 0x3b, 0xe9, 0xe5, 0x83, 0x7a, 0x06, 0xe8, 0x1b, 0x38, 0x43, 0xc3, 0x54,
|
||||
/* (2^184)P */ 0x14, 0xaa, 0xb3, 0x6e, 0xe6, 0x28, 0xee, 0xc5, 0x22, 0x6c, 0x7c, 0xf9, 0xa8, 0x71, 0xcc, 0xfe, 0x68, 0x7e, 0xd3, 0xb8, 0x37, 0x96, 0xca, 0x0b, 0xd9, 0xb6, 0x06, 0xa9, 0xf6, 0x71, 0xe8, 0x31, 0xf7, 0xd8, 0xf1, 0x5d, 0xab, 0xb9, 0xf0, 0x5c, 0x98, 0xcf, 0x22, 0xa2, 0x2a, 0xf6, 0xd0, 0x59, 0xf0, 0x9d, 0xd9, 0x6a, 0x4f, 0x59, 0x57, 0xad,
|
||||
/* (2^185)P */ 0xd7, 0x2b, 0x3d, 0x38, 0x4c, 0x2e, 0x23, 0x4d, 0x49, 0xa2, 0x62, 0x62, 0xf9, 0x0f, 0xde, 0x08, 0xf3, 0x86, 0x71, 0xb6, 0xc7, 0xf9, 0x85, 0x9c, 0x33, 0xa1, 0xcf, 0x16, 0xaa, 0x60, 0xb9, 0xb7, 0xea, 0xed, 0x01, 0x1c, 0x59, 0xdb, 0x3f, 0x3f, 0x97, 0x2e, 0xf0, 0x09, 0x9f, 0x10, 0x85, 0x5f, 0x53, 0x39, 0xf3, 0x13, 0x40, 0x56, 0x95, 0xf9,
|
||||
/* (2^186)P */ 0xb4, 0xe3, 0xda, 0xc6, 0x1f, 0x78, 0x8e, 0xac, 0xd4, 0x20, 0x1d, 0xa0, 0xbf, 0x4c, 0x09, 0x16, 0xa7, 0x30, 0xb5, 0x8d, 0x9e, 0xa1, 0x5f, 0x6d, 0x52, 0xf4, 0x71, 0xb6, 0x32, 0x2d, 0x21, 0x51, 0xc6, 0xfc, 0x2f, 0x08, 0xf4, 0x13, 0x6c, 0x55, 0xba, 0x72, 0x81, 0x24, 0x49, 0x0e, 0x4f, 0x06, 0x36, 0x39, 0x6a, 0xc5, 0x81, 0xfc, 0xeb, 0xb2,
|
||||
/* (2^187)P */ 0x7d, 0x8d, 0xc8, 0x6c, 0xea, 0xb4, 0xb9, 0xe8, 0x40, 0xc9, 0x69, 0xc9, 0x30, 0x05, 0xfd, 0x34, 0x46, 0xfd, 0x94, 0x05, 0x16, 0xf5, 0x4b, 0x13, 0x3d, 0x24, 0x1a, 0xd6, 0x64, 0x2b, 0x9c, 0xe2, 0xa5, 0xd9, 0x98, 0xe0, 0xe8, 0xf4, 0xbc, 0x2c, 0xbd, 0xa2, 0x56, 0xe3, 0x9e, 0x14, 0xdb, 0xbf, 0x05, 0xbf, 0x9a, 0x13, 0x5d, 0xf7, 0x91, 0xa3,
|
||||
/* (2^188)P */ 0x8b, 0xcb, 0x27, 0xf3, 0x15, 0x26, 0x05, 0x40, 0x0f, 0xa6, 0x15, 0x13, 0x71, 0x95, 0xa2, 0xc6, 0x38, 0x04, 0x67, 0xf8, 0x9a, 0x83, 0x06, 0xaa, 0x25, 0x36, 0x72, 0x01, 0x6f, 0x74, 0x5f, 0xe5, 0x6e, 0x44, 0x99, 0xce, 0x13, 0xbc, 0x82, 0xc2, 0x0d, 0xa4, 0x98, 0x50, 0x38, 0xf3, 0xa2, 0xc5, 0xe5, 0x24, 0x1f, 0x6f, 0x56, 0x3e, 0x07, 0xb2,
|
||||
/* (2^189)P */ 0xbd, 0x0f, 0x32, 0x60, 0x07, 0xb1, 0xd7, 0x0b, 0x11, 0x07, 0x57, 0x02, 0x89, 0xe8, 0x8b, 0xe8, 0x5a, 0x1f, 0xee, 0x54, 0x6b, 0xff, 0xb3, 0x04, 0x07, 0x57, 0x13, 0x0b, 0x94, 0xa8, 0x4d, 0x81, 0xe2, 0x17, 0x16, 0x45, 0xd4, 0x4b, 0xf7, 0x7e, 0x64, 0x66, 0x20, 0xe8, 0x0b, 0x26, 0xfd, 0xa9, 0x8a, 0x47, 0x52, 0x89, 0x14, 0xd0, 0xd1, 0xa1,
|
||||
/* (2^190)P */ 0xdc, 0x03, 0xe6, 0x20, 0x44, 0x47, 0x8f, 0x04, 0x16, 0x24, 0x22, 0xc1, 0x55, 0x5c, 0xbe, 0x43, 0xc3, 0x92, 0xc5, 0x54, 0x3d, 0x5d, 0xd1, 0x05, 0x9c, 0xc6, 0x7c, 0xbf, 0x23, 0x84, 0x1a, 0xba, 0x4f, 0x1f, 0xfc, 0xa1, 0xae, 0x1a, 0x64, 0x02, 0x51, 0xf1, 0xcb, 0x7a, 0x20, 0xce, 0xb2, 0x34, 0x3c, 0xca, 0xe0, 0xe4, 0xba, 0x22, 0xd4, 0x7b,
|
||||
/* (2^191)P */ 0xca, 0xfd, 0xca, 0xd7, 0xde, 0x61, 0xae, 0xf0, 0x79, 0x0c, 0x20, 0xab, 0xbc, 0x6f, 0x4d, 0x61, 0xf0, 0xc7, 0x9c, 0x8d, 0x4b, 0x52, 0xf3, 0xb9, 0x48, 0x63, 0x0b, 0xb6, 0xd2, 0x25, 0x9a, 0x96, 0x72, 0xc1, 0x6b, 0x0c, 0xb5, 0xfb, 0x71, 0xaa, 0xad, 0x47, 0x5b, 0xe7, 0xc0, 0x0a, 0x55, 0xb2, 0xd4, 0x16, 0x2f, 0xb1, 0x01, 0xfd, 0xce, 0x27,
|
||||
/* (2^192)P */ 0x64, 0x11, 0x4b, 0xab, 0x57, 0x09, 0xc6, 0x49, 0x4a, 0x37, 0xc3, 0x36, 0xc4, 0x7b, 0x81, 0x1f, 0x42, 0xed, 0xbb, 0xe0, 0xa0, 0x8d, 0x51, 0xe6, 0xca, 0x8b, 0xb9, 0xcd, 0x99, 0x2d, 0x91, 0x53, 0xa9, 0x47, 0xcb, 0x32, 0xc7, 0xa4, 0x92, 0xec, 0x46, 0x74, 0x44, 0x6d, 0x71, 0x9f, 0x6d, 0x0c, 0x69, 0xa4, 0xf8, 0xbe, 0x9f, 0x7f, 0xa0, 0xd7,
|
||||
/* (2^193)P */ 0x5f, 0x33, 0xb6, 0x91, 0xc8, 0xa5, 0x3f, 0x5d, 0x7f, 0x38, 0x6e, 0x74, 0x20, 0x4a, 0xd6, 0x2b, 0x98, 0x2a, 0x41, 0x4b, 0x83, 0x64, 0x0b, 0x92, 0x7a, 0x06, 0x1e, 0xc6, 0x2c, 0xf6, 0xe4, 0x91, 0xe5, 0xb1, 0x2e, 0x6e, 0x4e, 0xa8, 0xc8, 0x14, 0x32, 0x57, 0x44, 0x1c, 0xe4, 0xb9, 0x7f, 0x54, 0x51, 0x08, 0x81, 0xaa, 0x4e, 0xce, 0xa1, 0x5d,
|
||||
/* (2^194)P */ 0x5c, 0xd5, 0x9b, 0x5e, 0x7c, 0xb5, 0xb1, 0x52, 0x73, 0x00, 0x41, 0x56, 0x79, 0x08, 0x7e, 0x07, 0x28, 0x06, 0xa6, 0xfb, 0x7f, 0x69, 0xbd, 0x7a, 0x3c, 0xae, 0x9f, 0x39, 0xbb, 0x54, 0xa2, 0x79, 0xb9, 0x0e, 0x7f, 0xbb, 0xe0, 0xe6, 0xb7, 0x27, 0x64, 0x38, 0x45, 0xdb, 0x84, 0xe4, 0x61, 0x72, 0x3f, 0xe2, 0x24, 0xfe, 0x7a, 0x31, 0x9a, 0xc9,
|
||||
/* (2^195)P */ 0xa1, 0xd2, 0xa4, 0xee, 0x24, 0x96, 0xe5, 0x5b, 0x79, 0x78, 0x3c, 0x7b, 0x82, 0x3b, 0x8b, 0x58, 0x0b, 0xa3, 0x63, 0x2d, 0xbc, 0x75, 0x46, 0xe8, 0x83, 0x1a, 0xc0, 0x2a, 0x92, 0x61, 0xa8, 0x75, 0x37, 0x3c, 0xbf, 0x0f, 0xef, 0x8f, 0x6c, 0x97, 0x75, 0x10, 0x05, 0x7a, 0xde, 0x23, 0xe8, 0x2a, 0x35, 0xeb, 0x41, 0x64, 0x7d, 0xcf, 0xe0, 0x52,
|
||||
/* (2^196)P */ 0x4a, 0xd0, 0x49, 0x93, 0xae, 0xf3, 0x24, 0x8c, 0xe1, 0x09, 0x98, 0x45, 0xd8, 0xb9, 0xfe, 0x8e, 0x8c, 0xa8, 0x2c, 0xc9, 0x9f, 0xce, 0x01, 0xdc, 0x38, 0x11, 0xab, 0x85, 0xb9, 0xe8, 0x00, 0x51, 0xfd, 0x82, 0xe1, 0x9b, 0x4e, 0xfc, 0xb5, 0x2a, 0x0f, 0x8b, 0xda, 0x4e, 0x02, 0xca, 0xcc, 0xe3, 0x91, 0xc4, 0xe0, 0xcf, 0x7b, 0xd6, 0xe6, 0x6a,
|
||||
/* (2^197)P */ 0xfe, 0x11, 0xd7, 0xaa, 0xe3, 0x0c, 0x52, 0x2e, 0x04, 0xe0, 0xe0, 0x61, 0xc8, 0x05, 0xd7, 0x31, 0x4c, 0xc3, 0x9b, 0x2d, 0xce, 0x59, 0xbe, 0x12, 0xb7, 0x30, 0x21, 0xfc, 0x81, 0xb8, 0x5e, 0x57, 0x73, 0xd0, 0xad, 0x8e, 0x9e, 0xe4, 0xeb, 0xcd, 0xcf, 0xd2, 0x0f, 0x01, 0x35, 0x16, 0xed, 0x7a, 0x43, 0x8e, 0x42, 0xdc, 0xea, 0x4c, 0xa8, 0x7c,
|
||||
/* (2^198)P */ 0x37, 0x26, 0xcc, 0x76, 0x0b, 0xe5, 0x76, 0xdd, 0x3e, 0x19, 0x3c, 0xc4, 0x6c, 0x7f, 0xd0, 0x03, 0xc1, 0xb8, 0x59, 0x82, 0xca, 0x36, 0xc1, 0xe4, 0xc8, 0xb2, 0x83, 0x69, 0x9c, 0xc5, 0x9d, 0x12, 0x82, 0x1c, 0xea, 0xb2, 0x84, 0x9f, 0xf3, 0x52, 0x6b, 0xbb, 0xd8, 0x81, 0x56, 0x83, 0x04, 0x66, 0x05, 0x22, 0x49, 0x37, 0x93, 0xb1, 0xfd, 0xd5,
|
||||
/* (2^199)P */ 0xaf, 0x96, 0xbf, 0x03, 0xbe, 0xe6, 0x5d, 0x78, 0x19, 0xba, 0x37, 0x46, 0x0a, 0x2b, 0x52, 0x7c, 0xd8, 0x51, 0x9e, 0x3d, 0x29, 0x42, 0xdb, 0x0e, 0x31, 0x20, 0x94, 0xf8, 0x43, 0x9a, 0x2d, 0x22, 0xd3, 0xe3, 0xa1, 0x79, 0x68, 0xfb, 0x2d, 0x7e, 0xd6, 0x79, 0xda, 0x0b, 0xc6, 0x5b, 0x76, 0x68, 0xf0, 0xfe, 0x72, 0x59, 0xbb, 0xa1, 0x9c, 0x74,
|
||||
/* (2^200)P */ 0x0a, 0xd9, 0xec, 0xc5, 0xbd, 0xf0, 0xda, 0xcf, 0x82, 0xab, 0x46, 0xc5, 0x32, 0x13, 0xdc, 0x5b, 0xac, 0xc3, 0x53, 0x9a, 0x7f, 0xef, 0xa5, 0x40, 0x5a, 0x1f, 0xc1, 0x12, 0x91, 0x54, 0x83, 0x6a, 0xb0, 0x9a, 0x85, 0x4d, 0xbf, 0x36, 0x8e, 0xd3, 0xa2, 0x2b, 0xe5, 0xd6, 0xc6, 0xe1, 0x58, 0x5b, 0x82, 0x9b, 0xc8, 0xf2, 0x03, 0xba, 0xf5, 0x92,
|
||||
/* (2^201)P */ 0xfb, 0x21, 0x7e, 0xde, 0xe7, 0xb4, 0xc0, 0x56, 0x86, 0x3a, 0x5b, 0x78, 0xf8, 0xf0, 0xf4, 0xe7, 0x5c, 0x00, 0xd2, 0xd7, 0xd6, 0xf8, 0x75, 0x5e, 0x0f, 0x3e, 0xd1, 0x4b, 0x77, 0xd8, 0xad, 0xb0, 0xc9, 0x8b, 0x59, 0x7d, 0x30, 0x76, 0x64, 0x7a, 0x76, 0xd9, 0x51, 0x69, 0xfc, 0xbd, 0x8e, 0xb5, 0x55, 0xe0, 0xd2, 0x07, 0x15, 0xa9, 0xf7, 0xa4,
|
||||
/* (2^202)P */ 0xaa, 0x2d, 0x2f, 0x2b, 0x3c, 0x15, 0xdd, 0xcd, 0xe9, 0x28, 0x82, 0x4f, 0xa2, 0xaa, 0x31, 0x48, 0xcc, 0xfa, 0x07, 0x73, 0x8a, 0x34, 0x74, 0x0d, 0xab, 0x1a, 0xca, 0xd2, 0xbf, 0x3a, 0xdb, 0x1a, 0x5f, 0x50, 0x62, 0xf4, 0x6b, 0x83, 0x38, 0x43, 0x96, 0xee, 0x6b, 0x39, 0x1e, 0xf0, 0x17, 0x80, 0x1e, 0x9b, 0xed, 0x2b, 0x2f, 0xcc, 0x65, 0xf7,
|
||||
/* (2^203)P */ 0x03, 0xb3, 0x23, 0x9c, 0x0d, 0xd1, 0xeb, 0x7e, 0x34, 0x17, 0x8a, 0x4c, 0xde, 0x54, 0x39, 0xc4, 0x11, 0x82, 0xd3, 0xa4, 0x00, 0x32, 0x95, 0x9c, 0xa6, 0x64, 0x76, 0x6e, 0xd6, 0x53, 0x27, 0xb4, 0x6a, 0x14, 0x8c, 0x54, 0xf6, 0x58, 0x9e, 0x22, 0x4a, 0x55, 0x18, 0x77, 0xd0, 0x08, 0x6b, 0x19, 0x8a, 0xb5, 0xe7, 0x19, 0xb8, 0x60, 0x92, 0xb1,
|
||||
/* (2^204)P */ 0x66, 0xec, 0xf3, 0x12, 0xde, 0x67, 0x7f, 0xd4, 0x5b, 0xf6, 0x70, 0x64, 0x0a, 0xb5, 0xc2, 0xf9, 0xb3, 0x64, 0xab, 0x56, 0x46, 0xc7, 0x93, 0xc2, 0x8b, 0x2d, 0xd0, 0xd6, 0x39, 0x3b, 0x1f, 0xcd, 0xb3, 0xac, 0xcc, 0x2c, 0x27, 0x6a, 0xbc, 0xb3, 0x4b, 0xa8, 0x3c, 0x69, 0x20, 0xe2, 0x18, 0x35, 0x17, 0xe1, 0x8a, 0xd3, 0x11, 0x74, 0xaa, 0x4d,
|
||||
/* (2^205)P */ 0x96, 0xc4, 0x16, 0x7e, 0xfd, 0xf5, 0xd0, 0x7d, 0x1f, 0x32, 0x1b, 0xdb, 0xa6, 0xfd, 0x51, 0x75, 0x4d, 0xd7, 0x00, 0xe5, 0x7f, 0x58, 0x5b, 0xeb, 0x4b, 0x6a, 0x78, 0xfe, 0xe5, 0xd6, 0x8f, 0x99, 0x17, 0xca, 0x96, 0x45, 0xf7, 0x52, 0xdf, 0x84, 0x06, 0x77, 0xb9, 0x05, 0x63, 0x5d, 0xe9, 0x91, 0xb1, 0x4b, 0x82, 0x5a, 0xdb, 0xd7, 0xca, 0x69,
|
||||
/* (2^206)P */ 0x02, 0xd3, 0x38, 0x38, 0x87, 0xea, 0xbd, 0x9f, 0x11, 0xca, 0xf3, 0x21, 0xf1, 0x9b, 0x35, 0x97, 0x98, 0xff, 0x8e, 0x6d, 0x3d, 0xd6, 0xb2, 0xfa, 0x68, 0xcb, 0x7e, 0x62, 0x85, 0xbb, 0xc7, 0x5d, 0xee, 0x32, 0x30, 0x2e, 0x71, 0x96, 0x63, 0x43, 0x98, 0xc4, 0xa7, 0xde, 0x60, 0xb2, 0xd9, 0x43, 0x4a, 0xfa, 0x97, 0x2d, 0x5f, 0x21, 0xd4, 0xfe,
|
||||
/* (2^207)P */ 0x3b, 0x20, 0x29, 0x07, 0x07, 0xb5, 0x78, 0xc3, 0xc7, 0xab, 0x56, 0xba, 0x40, 0xde, 0x1d, 0xcf, 0xc3, 0x00, 0x56, 0x21, 0x0c, 0xc8, 0x42, 0xd9, 0x0e, 0xcd, 0x02, 0x7c, 0x07, 0xb9, 0x11, 0xd7, 0x96, 0xaf, 0xff, 0xad, 0xc5, 0xba, 0x30, 0x6d, 0x82, 0x3a, 0xbf, 0xef, 0x7b, 0xf7, 0x0a, 0x74, 0xbd, 0x31, 0x0c, 0xe4, 0xec, 0x1a, 0xe5, 0xc5,
|
||||
/* (2^208)P */ 0xcc, 0xf2, 0x28, 0x16, 0x12, 0xbf, 0xef, 0x85, 0xbc, 0xf7, 0xcb, 0x9f, 0xdb, 0xa8, 0xb2, 0x49, 0x53, 0x48, 0xa8, 0x24, 0xa8, 0x68, 0x8d, 0xbb, 0x21, 0x0a, 0x5a, 0xbd, 0xb2, 0x91, 0x61, 0x47, 0xc4, 0x43, 0x08, 0xa6, 0x19, 0xef, 0x8e, 0x88, 0x39, 0xc6, 0x33, 0x30, 0xf3, 0x0e, 0xc5, 0x92, 0x66, 0xd6, 0xfe, 0xc5, 0x12, 0xd9, 0x4c, 0x2d,
|
||||
/* (2^209)P */ 0x30, 0x34, 0x07, 0xbf, 0x9c, 0x5a, 0x4e, 0x65, 0xf1, 0x39, 0x35, 0x38, 0xae, 0x7b, 0x55, 0xac, 0x6a, 0x92, 0x24, 0x7e, 0x50, 0xd3, 0xba, 0x78, 0x51, 0xfe, 0x4d, 0x32, 0x05, 0x11, 0xf5, 0x52, 0xf1, 0x31, 0x45, 0x39, 0x98, 0x7b, 0x28, 0x56, 0xc3, 0x5d, 0x4f, 0x07, 0x6f, 0x84, 0xb8, 0x1a, 0x58, 0x0b, 0xc4, 0x7c, 0xc4, 0x8d, 0x32, 0x8e,
|
||||
/* (2^210)P */ 0x7e, 0xaf, 0x98, 0xce, 0xc5, 0x2b, 0x9d, 0xf6, 0xfa, 0x2c, 0xb6, 0x2a, 0x5a, 0x1d, 0xc0, 0x24, 0x8d, 0xa4, 0xce, 0xb1, 0x12, 0x01, 0xf9, 0x79, 0xc6, 0x79, 0x38, 0x0c, 0xd4, 0x07, 0xc9, 0xf7, 0x37, 0xa1, 0x0b, 0xfe, 0x72, 0xec, 0x5d, 0xd6, 0xb0, 0x1c, 0x70, 0xbe, 0x70, 0x01, 0x13, 0xe0, 0x86, 0x95, 0xc7, 0x2e, 0x12, 0x3b, 0xe6, 0xa6,
|
||||
/* (2^211)P */ 0x24, 0x82, 0x67, 0xe0, 0x14, 0x7b, 0x56, 0x08, 0x38, 0x44, 0xdb, 0xa0, 0x3a, 0x05, 0x47, 0xb2, 0xc0, 0xac, 0xd1, 0xcc, 0x3f, 0x82, 0xb8, 0x8a, 0x88, 0xbc, 0xf5, 0x33, 0xa1, 0x35, 0x0f, 0xf6, 0xe2, 0xef, 0x6c, 0xf7, 0x37, 0x9e, 0xe8, 0x10, 0xca, 0xb0, 0x8e, 0x80, 0x86, 0x00, 0x23, 0xd0, 0x4a, 0x76, 0x9f, 0xf7, 0x2c, 0x52, 0x15, 0x0e,
|
||||
/* (2^212)P */ 0x5e, 0x49, 0xe1, 0x2c, 0x9a, 0x01, 0x76, 0xa6, 0xb3, 0x07, 0x5b, 0xa4, 0x07, 0xef, 0x1d, 0xc3, 0x6a, 0xbb, 0x64, 0xbe, 0x71, 0x15, 0x6e, 0x32, 0x31, 0x46, 0x9a, 0x9e, 0x8f, 0x45, 0x73, 0xce, 0x0b, 0x94, 0x1a, 0x52, 0x07, 0xf4, 0x50, 0x30, 0x49, 0x53, 0x50, 0xfb, 0x71, 0x1f, 0x5a, 0x03, 0xa9, 0x76, 0xf2, 0x8f, 0x42, 0xff, 0xed, 0xed,
|
||||
/* (2^213)P */ 0xed, 0x08, 0xdb, 0x91, 0x1c, 0xee, 0xa2, 0xb4, 0x47, 0xa2, 0xfa, 0xcb, 0x03, 0xd1, 0xff, 0x8c, 0xad, 0x64, 0x50, 0x61, 0xcd, 0xfc, 0x88, 0xa0, 0x31, 0x95, 0x30, 0xb9, 0x58, 0xdd, 0xd7, 0x43, 0xe4, 0x46, 0xc2, 0x16, 0xd9, 0x72, 0x4a, 0x56, 0x51, 0x70, 0x85, 0xf1, 0xa1, 0x80, 0x40, 0xd5, 0xba, 0x67, 0x81, 0xda, 0xcd, 0x03, 0xea, 0x51,
|
||||
/* (2^214)P */ 0x42, 0x50, 0xf0, 0xef, 0x37, 0x61, 0x72, 0x85, 0xe1, 0xf1, 0xff, 0x6f, 0x3d, 0xe8, 0x7b, 0x21, 0x5c, 0xe5, 0x50, 0x03, 0xde, 0x00, 0xc1, 0xf7, 0x3a, 0x55, 0x12, 0x1c, 0x9e, 0x1e, 0xce, 0xd1, 0x2f, 0xaf, 0x05, 0x70, 0x5b, 0x47, 0xf2, 0x04, 0x7a, 0x89, 0xbc, 0x78, 0xa6, 0x65, 0x6c, 0xaa, 0x3c, 0xa2, 0x3c, 0x8b, 0x5c, 0xa9, 0x22, 0x48,
|
||||
/* (2^215)P */ 0x7e, 0x8c, 0x8f, 0x2f, 0x60, 0xe3, 0x5a, 0x94, 0xd4, 0xce, 0xdd, 0x9d, 0x83, 0x3b, 0x77, 0x78, 0x43, 0x1d, 0xfd, 0x8f, 0xc8, 0xe8, 0x02, 0x90, 0xab, 0xf6, 0xc9, 0xfc, 0xf1, 0x63, 0xaa, 0x5f, 0x42, 0xf1, 0x78, 0x34, 0x64, 0x16, 0x75, 0x9c, 0x7d, 0xd0, 0xe4, 0x74, 0x5a, 0xa8, 0xfb, 0xcb, 0xac, 0x20, 0xa3, 0xc2, 0xa6, 0x20, 0xf8, 0x1b,
|
||||
/* (2^216)P */ 0x00, 0x4f, 0x1e, 0x56, 0xb5, 0x34, 0xb2, 0x87, 0x31, 0xe5, 0xee, 0x8d, 0xf1, 0x41, 0x67, 0xb7, 0x67, 0x3a, 0x54, 0x86, 0x5c, 0xf0, 0x0b, 0x37, 0x2f, 0x1b, 0x92, 0x5d, 0x58, 0x93, 0xdc, 0xd8, 0x58, 0xcc, 0x9e, 0x67, 0xd0, 0x97, 0x3a, 0xaf, 0x49, 0x39, 0x2d, 0x3b, 0xd8, 0x98, 0xfb, 0x76, 0x6b, 0xe7, 0xaf, 0xc3, 0x45, 0x44, 0x53, 0x94,
|
||||
/* (2^217)P */ 0x30, 0xbd, 0x90, 0x75, 0xd3, 0xbd, 0x3b, 0x58, 0x27, 0x14, 0x9f, 0x6b, 0xd4, 0x31, 0x99, 0xcd, 0xde, 0x3a, 0x21, 0x1e, 0xb4, 0x02, 0xe4, 0x33, 0x04, 0x02, 0xb0, 0x50, 0x66, 0x68, 0x90, 0xdd, 0x7b, 0x69, 0x31, 0xd9, 0xcf, 0x68, 0x73, 0xf1, 0x60, 0xdd, 0xc8, 0x1d, 0x5d, 0xe3, 0xd6, 0x5b, 0x2a, 0xa4, 0xea, 0xc4, 0x3f, 0x08, 0xcd, 0x9c,
|
||||
/* (2^218)P */ 0x6b, 0x1a, 0xbf, 0x55, 0xc1, 0x1b, 0x0c, 0x05, 0x09, 0xdf, 0xf5, 0x5e, 0xa3, 0x77, 0x95, 0xe9, 0xdf, 0x19, 0xdd, 0xc7, 0x94, 0xcb, 0x06, 0x73, 0xd0, 0x88, 0x02, 0x33, 0x94, 0xca, 0x7a, 0x2f, 0x8e, 0x3d, 0x72, 0x61, 0x2d, 0x4d, 0xa6, 0x61, 0x1f, 0x32, 0x5e, 0x87, 0x53, 0x36, 0x11, 0x15, 0x20, 0xb3, 0x5a, 0x57, 0x51, 0x93, 0x20, 0xd8,
|
||||
/* (2^219)P */ 0xb7, 0x56, 0xf4, 0xab, 0x7d, 0x0c, 0xfb, 0x99, 0x1a, 0x30, 0x29, 0xb0, 0x75, 0x2a, 0xf8, 0x53, 0x71, 0x23, 0xbd, 0xa7, 0xd8, 0x0a, 0xe2, 0x27, 0x65, 0xe9, 0x74, 0x26, 0x98, 0x4a, 0x69, 0x19, 0xb2, 0x4d, 0x0a, 0x17, 0x98, 0xb2, 0xa9, 0x57, 0x4e, 0xf6, 0x86, 0xc8, 0x01, 0xa4, 0xc6, 0x98, 0xad, 0x5a, 0x90, 0x2c, 0x05, 0x46, 0x64, 0xb7,
|
||||
/* (2^220)P */ 0x7b, 0x91, 0xdf, 0xfc, 0xf8, 0x1c, 0x8c, 0x15, 0x9e, 0xf7, 0xd5, 0xa8, 0xe8, 0xe7, 0xe3, 0xa3, 0xb0, 0x04, 0x74, 0xfa, 0x78, 0xfb, 0x26, 0xbf, 0x67, 0x42, 0xf9, 0x8c, 0x9b, 0xb4, 0x69, 0x5b, 0x02, 0x13, 0x6d, 0x09, 0x6c, 0xd6, 0x99, 0x61, 0x7b, 0x89, 0x4a, 0x67, 0x75, 0xa3, 0x98, 0x13, 0x23, 0x1d, 0x18, 0x24, 0x0e, 0xef, 0x41, 0x79,
|
||||
/* (2^221)P */ 0x86, 0x33, 0xab, 0x08, 0xcb, 0xbf, 0x1e, 0x76, 0x3c, 0x0b, 0xbd, 0x30, 0xdb, 0xe9, 0xa3, 0x35, 0x87, 0x1b, 0xe9, 0x07, 0x00, 0x66, 0x7f, 0x3b, 0x35, 0x0c, 0x8a, 0x3f, 0x61, 0xbc, 0xe0, 0xae, 0xf6, 0xcc, 0x54, 0xe1, 0x72, 0x36, 0x2d, 0xee, 0x93, 0x24, 0xf8, 0xd7, 0xc5, 0xf9, 0xcb, 0xb0, 0xe5, 0x88, 0x0d, 0x23, 0x4b, 0x76, 0x15, 0xa2,
|
||||
/* (2^222)P */ 0x37, 0xdb, 0x83, 0xd5, 0x6d, 0x06, 0x24, 0x37, 0x1b, 0x15, 0x85, 0x15, 0xe2, 0xc0, 0x4e, 0x02, 0xa9, 0x6d, 0x0a, 0x3a, 0x94, 0x4a, 0x6f, 0x49, 0x00, 0x01, 0x72, 0xbb, 0x60, 0x14, 0x35, 0xae, 0xb4, 0xc6, 0x01, 0x0a, 0x00, 0x9e, 0xc3, 0x58, 0xc5, 0xd1, 0x5e, 0x30, 0x73, 0x96, 0x24, 0x85, 0x9d, 0xf0, 0xf9, 0xec, 0x09, 0xd3, 0xe7, 0x70,
|
||||
/* (2^223)P */ 0xf3, 0xbd, 0x96, 0x87, 0xe9, 0x71, 0xbd, 0xd6, 0xa2, 0x45, 0xeb, 0x0a, 0xcd, 0x2c, 0xf1, 0x72, 0xa6, 0x31, 0xa9, 0x6f, 0x09, 0xa1, 0x5e, 0xdd, 0xc8, 0x8d, 0x0d, 0xbc, 0x5a, 0x8d, 0xb1, 0x2c, 0x9a, 0xcc, 0x37, 0x74, 0xc2, 0xa9, 0x4e, 0xd6, 0xc0, 0x3c, 0xa0, 0x23, 0xb0, 0xa0, 0x77, 0x14, 0x80, 0x45, 0x71, 0x6a, 0x2d, 0x41, 0xc3, 0x82,
|
||||
/* (2^224)P */ 0x37, 0x44, 0xec, 0x8a, 0x3e, 0xc1, 0x0c, 0xa9, 0x12, 0x9c, 0x08, 0x88, 0xcb, 0xd9, 0xf8, 0xba, 0x00, 0xd6, 0xc3, 0xdf, 0xef, 0x7a, 0x44, 0x7e, 0x25, 0x69, 0xc9, 0xc1, 0x46, 0xe5, 0x20, 0x9e, 0xcc, 0x0b, 0x05, 0x3e, 0xf4, 0x78, 0x43, 0x0c, 0xa6, 0x2f, 0xc1, 0xfa, 0x70, 0xb2, 0x3c, 0x31, 0x7a, 0x63, 0x58, 0xab, 0x17, 0xcf, 0x4c, 0x4f,
|
||||
/* (2^225)P */ 0x2b, 0x08, 0x31, 0x59, 0x75, 0x8b, 0xec, 0x0a, 0xa9, 0x79, 0x70, 0xdd, 0xf1, 0x11, 0xc3, 0x11, 0x1f, 0xab, 0x37, 0xaa, 0x26, 0xea, 0x53, 0xc4, 0x79, 0xa7, 0x91, 0x00, 0xaa, 0x08, 0x42, 0xeb, 0x8b, 0x8b, 0xe8, 0xc3, 0x2f, 0xb8, 0x78, 0x90, 0x38, 0x0e, 0x8a, 0x42, 0x0c, 0x0f, 0xbf, 0x3e, 0xf8, 0xd8, 0x07, 0xcf, 0x6a, 0x34, 0xc9, 0xfa,
|
||||
/* (2^226)P */ 0x11, 0xe0, 0x76, 0x4d, 0x23, 0xc5, 0xa6, 0xcc, 0x9f, 0x9a, 0x2a, 0xde, 0x3a, 0xb5, 0x92, 0x39, 0x19, 0x8a, 0xf1, 0x8d, 0xf9, 0x4d, 0xc9, 0xb4, 0x39, 0x9f, 0x57, 0xd8, 0x72, 0xab, 0x1d, 0x61, 0x6a, 0xb2, 0xff, 0x52, 0xba, 0x54, 0x0e, 0xfb, 0x83, 0x30, 0x8a, 0xf7, 0x3b, 0xf4, 0xd8, 0xae, 0x1a, 0x94, 0x3a, 0xec, 0x63, 0xfe, 0x6e, 0x7c,
|
||||
/* (2^227)P */ 0xdc, 0x70, 0x8e, 0x55, 0x44, 0xbf, 0xd2, 0x6a, 0xa0, 0x14, 0x61, 0x89, 0xd5, 0x55, 0x45, 0x3c, 0xf6, 0x40, 0x0d, 0x83, 0x85, 0x44, 0xb4, 0x62, 0x56, 0xfe, 0x60, 0xd7, 0x07, 0x1d, 0x47, 0x30, 0x3b, 0x73, 0xa4, 0xb5, 0xb7, 0xea, 0xac, 0xda, 0xf1, 0x17, 0xaa, 0x60, 0xdf, 0xe9, 0x84, 0xda, 0x31, 0x32, 0x61, 0xbf, 0xd0, 0x7e, 0x8a, 0x02,
|
||||
/* (2^228)P */ 0xb9, 0x51, 0xb3, 0x89, 0x21, 0x5d, 0xa2, 0xfe, 0x79, 0x2a, 0xb3, 0x2a, 0x3b, 0xe6, 0x6f, 0x2b, 0x22, 0x03, 0xea, 0x7b, 0x1f, 0xaf, 0x85, 0xc3, 0x38, 0x55, 0x5b, 0x8e, 0xb4, 0xaa, 0x77, 0xfe, 0x03, 0x6e, 0xda, 0x91, 0x24, 0x0c, 0x48, 0x39, 0x27, 0x43, 0x16, 0xd2, 0x0a, 0x0d, 0x43, 0xa3, 0x0e, 0xca, 0x45, 0xd1, 0x7f, 0xf5, 0xd3, 0x16,
|
||||
/* (2^229)P */ 0x3d, 0x32, 0x9b, 0x38, 0xf8, 0x06, 0x93, 0x78, 0x5b, 0x50, 0x2b, 0x06, 0xd8, 0x66, 0xfe, 0xab, 0x9b, 0x58, 0xc7, 0xd1, 0x4d, 0xd5, 0xf8, 0x3b, 0x10, 0x7e, 0x85, 0xde, 0x58, 0x4e, 0xdf, 0x53, 0xd9, 0x58, 0xe0, 0x15, 0x81, 0x9f, 0x1a, 0x78, 0xfc, 0x9f, 0x10, 0xc2, 0x23, 0xd6, 0x78, 0xd1, 0x9d, 0xd2, 0xd5, 0x1c, 0x53, 0xe2, 0xc9, 0x76,
|
||||
/* (2^230)P */ 0x98, 0x1e, 0x38, 0x7b, 0x71, 0x18, 0x4b, 0x15, 0xaf, 0xa1, 0xa6, 0x98, 0xcb, 0x26, 0xa3, 0xc8, 0x07, 0x46, 0xda, 0x3b, 0x70, 0x65, 0xec, 0x7a, 0x2b, 0x34, 0x94, 0xa8, 0xb6, 0x14, 0xf8, 0x1a, 0xce, 0xf7, 0xc8, 0x60, 0xf3, 0x88, 0xf4, 0x33, 0x60, 0x7b, 0xd1, 0x02, 0xe7, 0xda, 0x00, 0x4a, 0xea, 0xd2, 0xfd, 0x88, 0xd2, 0x99, 0x28, 0xf3,
|
||||
/* (2^231)P */ 0x28, 0x24, 0x1d, 0x26, 0xc2, 0xeb, 0x8b, 0x3b, 0xb4, 0x6b, 0xbe, 0x6b, 0x77, 0xff, 0xf3, 0x21, 0x3b, 0x26, 0x6a, 0x8c, 0x8e, 0x2a, 0x44, 0xa8, 0x01, 0x2b, 0x71, 0xea, 0x64, 0x30, 0xfd, 0xfd, 0x95, 0xcb, 0x39, 0x38, 0x48, 0xfa, 0x96, 0x97, 0x8c, 0x2f, 0x33, 0xca, 0x03, 0xe6, 0xd7, 0x94, 0x55, 0x6c, 0xc3, 0xb3, 0xa8, 0xf7, 0xae, 0x8c,
|
||||
/* (2^232)P */ 0xea, 0x62, 0x8a, 0xb4, 0xeb, 0x74, 0xf7, 0xb8, 0xae, 0xc5, 0x20, 0x71, 0x06, 0xd6, 0x7c, 0x62, 0x9b, 0x69, 0x74, 0xef, 0xa7, 0x6d, 0xd6, 0x8c, 0x37, 0xb9, 0xbf, 0xcf, 0xeb, 0xe4, 0x2f, 0x04, 0x02, 0x21, 0x7d, 0x75, 0x6b, 0x92, 0x48, 0xf8, 0x70, 0xad, 0x69, 0xe2, 0xea, 0x0e, 0x88, 0x67, 0x72, 0xcc, 0x2d, 0x10, 0xce, 0x2d, 0xcf, 0x65,
|
||||
/* (2^233)P */ 0x49, 0xf3, 0x57, 0x64, 0xe5, 0x5c, 0xc5, 0x65, 0x49, 0x97, 0xc4, 0x8a, 0xcc, 0xa9, 0xca, 0x94, 0x7b, 0x86, 0x88, 0xb6, 0x51, 0x27, 0x69, 0xa5, 0x0f, 0x8b, 0x06, 0x59, 0xa0, 0x94, 0xef, 0x63, 0x1a, 0x01, 0x9e, 0x4f, 0xd2, 0x5a, 0x93, 0xc0, 0x7c, 0xe6, 0x61, 0x77, 0xb6, 0xf5, 0x40, 0xd9, 0x98, 0x43, 0x5b, 0x56, 0x68, 0xe9, 0x37, 0x8f,
|
||||
/* (2^234)P */ 0xee, 0x87, 0xd2, 0x05, 0x1b, 0x39, 0x89, 0x10, 0x07, 0x6d, 0xe8, 0xfd, 0x8b, 0x4d, 0xb2, 0xa7, 0x7b, 0x1e, 0xa0, 0x6c, 0x0d, 0x3d, 0x3d, 0x49, 0xba, 0x61, 0x36, 0x1f, 0xc2, 0x84, 0x4a, 0xcc, 0x87, 0xa9, 0x1b, 0x23, 0x04, 0xe2, 0x3e, 0x97, 0xe1, 0xdb, 0xd5, 0x5a, 0xe8, 0x41, 0x6b, 0xe5, 0x5a, 0xa1, 0x99, 0xe5, 0x7b, 0xa7, 0xe0, 0x3b,
|
||||
/* (2^235)P */ 0xea, 0xa3, 0x6a, 0xdd, 0x77, 0x7f, 0x77, 0x41, 0xc5, 0x6a, 0xe4, 0xaf, 0x11, 0x5f, 0x88, 0xa5, 0x10, 0xee, 0xd0, 0x8c, 0x0c, 0xb4, 0xa5, 0x2a, 0xd0, 0xd8, 0x1d, 0x47, 0x06, 0xc0, 0xd5, 0xce, 0x51, 0x54, 0x9b, 0x2b, 0xe6, 0x2f, 0xe7, 0xe7, 0x31, 0x5f, 0x5c, 0x23, 0x81, 0x3e, 0x03, 0x93, 0xaa, 0x2d, 0x71, 0x84, 0xa0, 0x89, 0x32, 0xa6,
|
||||
/* (2^236)P */ 0x55, 0xa3, 0x13, 0x92, 0x4e, 0x93, 0x7d, 0xec, 0xca, 0x57, 0xfb, 0x37, 0xae, 0xd2, 0x18, 0x2e, 0x54, 0x05, 0x6c, 0xd1, 0x28, 0xca, 0x90, 0x40, 0x82, 0x2e, 0x79, 0xc6, 0x5a, 0xc7, 0xdd, 0x84, 0x93, 0xdf, 0x15, 0xb8, 0x1f, 0xb1, 0xf9, 0xaf, 0x2c, 0xe5, 0x32, 0xcd, 0xc2, 0x99, 0x6d, 0xac, 0x85, 0x5c, 0x63, 0xd3, 0xe2, 0xff, 0x24, 0xda,
|
||||
/* (2^237)P */ 0x2d, 0x8d, 0xfd, 0x65, 0xcc, 0xe5, 0x02, 0xa0, 0xe5, 0xb9, 0xec, 0x59, 0x09, 0x50, 0x27, 0xb7, 0x3d, 0x2a, 0x79, 0xb2, 0x76, 0x5d, 0x64, 0x95, 0xf8, 0xc5, 0xaf, 0x8a, 0x62, 0x11, 0x5c, 0x56, 0x1c, 0x05, 0x64, 0x9e, 0x5e, 0xbd, 0x54, 0x04, 0xe6, 0x9e, 0xab, 0xe6, 0x22, 0x7e, 0x42, 0x54, 0xb5, 0xa5, 0xd0, 0x8d, 0x28, 0x6b, 0x0f, 0x0b,
|
||||
/* (2^238)P */ 0x2d, 0xb2, 0x8c, 0x59, 0x10, 0x37, 0x84, 0x3b, 0x9b, 0x65, 0x1b, 0x0f, 0x10, 0xf9, 0xea, 0x60, 0x1b, 0x02, 0xf5, 0xee, 0x8b, 0xe6, 0x32, 0x7d, 0x10, 0x7f, 0x5f, 0x8c, 0x72, 0x09, 0x4e, 0x1f, 0x29, 0xff, 0x65, 0xcb, 0x3e, 0x3a, 0xd2, 0x96, 0x50, 0x1e, 0xea, 0x64, 0x99, 0xb5, 0x4c, 0x7a, 0x69, 0xb8, 0x95, 0xae, 0x48, 0xc0, 0x7c, 0xb1,
|
||||
/* (2^239)P */ 0xcd, 0x7c, 0x4f, 0x3e, 0xea, 0xf3, 0x90, 0xcb, 0x12, 0x76, 0xd1, 0x17, 0xdc, 0x0d, 0x13, 0x0f, 0xfd, 0x4d, 0xb5, 0x1f, 0xe4, 0xdd, 0xf2, 0x4d, 0x58, 0xea, 0xa5, 0x66, 0x92, 0xcf, 0xe5, 0x54, 0xea, 0x9b, 0x35, 0x83, 0x1a, 0x44, 0x8e, 0x62, 0x73, 0x45, 0x98, 0xa3, 0x89, 0x95, 0x52, 0x93, 0x1a, 0x8d, 0x63, 0x0f, 0xc2, 0x57, 0x3c, 0xb1,
|
||||
/* (2^240)P */ 0x72, 0xb4, 0xdf, 0x51, 0xb7, 0xf6, 0x52, 0xa2, 0x14, 0x56, 0xe5, 0x0a, 0x2e, 0x75, 0x81, 0x02, 0xee, 0x93, 0x48, 0x0a, 0x92, 0x4e, 0x0c, 0x0f, 0xdf, 0x09, 0x89, 0x99, 0xf6, 0xf9, 0x22, 0xa2, 0x32, 0xf8, 0xb0, 0x76, 0x0c, 0xb2, 0x4d, 0x6e, 0xbe, 0x83, 0x35, 0x61, 0x44, 0xd2, 0x58, 0xc7, 0xdd, 0x14, 0xcf, 0xc3, 0x4b, 0x7c, 0x07, 0xee,
|
||||
/* (2^241)P */ 0x8b, 0x03, 0xee, 0xcb, 0xa7, 0x2e, 0x28, 0xbd, 0x97, 0xd1, 0x4c, 0x2b, 0xd1, 0x92, 0x67, 0x5b, 0x5a, 0x12, 0xbf, 0x29, 0x17, 0xfc, 0x50, 0x09, 0x74, 0x76, 0xa2, 0xd4, 0x82, 0xfd, 0x2c, 0x0c, 0x90, 0xf7, 0xe7, 0xe5, 0x9a, 0x2c, 0x16, 0x40, 0xb9, 0x6c, 0xd9, 0xe0, 0x22, 0x9e, 0xf8, 0xdd, 0x73, 0xe4, 0x7b, 0x9e, 0xbe, 0x4f, 0x66, 0x22,
|
||||
/* (2^242)P */ 0xa4, 0x10, 0xbe, 0xb8, 0x83, 0x3a, 0x77, 0x8e, 0xea, 0x0a, 0xc4, 0x97, 0x3e, 0xb6, 0x6c, 0x81, 0xd7, 0x65, 0xd9, 0xf7, 0xae, 0xe6, 0xbe, 0xab, 0x59, 0x81, 0x29, 0x4b, 0xff, 0xe1, 0x0f, 0xc3, 0x2b, 0xad, 0x4b, 0xef, 0xc4, 0x50, 0x9f, 0x88, 0x31, 0xf2, 0xde, 0x80, 0xd6, 0xf4, 0x20, 0x9c, 0x77, 0x9b, 0xbe, 0xbe, 0x08, 0xf5, 0xf0, 0x95,
|
||||
/* (2^243)P */ 0x0e, 0x7c, 0x7b, 0x7c, 0xb3, 0xd8, 0x83, 0xfc, 0x8c, 0x75, 0x51, 0x74, 0x1b, 0xe1, 0x6d, 0x11, 0x05, 0x46, 0x24, 0x0d, 0xa4, 0x2b, 0x32, 0xfd, 0x2c, 0x4e, 0x21, 0xdf, 0x39, 0x6b, 0x96, 0xfc, 0xff, 0x92, 0xfc, 0x35, 0x0d, 0x9a, 0x4b, 0xc0, 0x70, 0x46, 0x32, 0x7d, 0xc0, 0xc4, 0x04, 0xe0, 0x2d, 0x83, 0xa7, 0x00, 0xc7, 0xcb, 0xb4, 0x8f,
|
||||
/* (2^244)P */ 0xa9, 0x5a, 0x7f, 0x0e, 0xdd, 0x2c, 0x85, 0xaa, 0x4d, 0xac, 0xde, 0xb3, 0xb6, 0xaf, 0xe6, 0xd1, 0x06, 0x7b, 0x2c, 0xa4, 0x01, 0x19, 0x22, 0x7d, 0x78, 0xf0, 0x3a, 0xea, 0x89, 0xfe, 0x21, 0x61, 0x6d, 0xb8, 0xfe, 0xa5, 0x2a, 0xab, 0x0d, 0x7b, 0x51, 0x39, 0xb6, 0xde, 0xbc, 0xf0, 0xc5, 0x48, 0xd7, 0x09, 0x82, 0x6e, 0x66, 0x75, 0xc5, 0xcd,
|
||||
/* (2^245)P */ 0xee, 0xdf, 0x2b, 0x6c, 0xa8, 0xde, 0x61, 0xe1, 0x27, 0xfa, 0x2a, 0x0f, 0x68, 0xe7, 0x7a, 0x9b, 0x13, 0xe9, 0x56, 0xd2, 0x1c, 0x3d, 0x2f, 0x3c, 0x7a, 0xf6, 0x6f, 0x45, 0xee, 0xe8, 0xf4, 0xa0, 0xa6, 0xe8, 0xa5, 0x27, 0xee, 0xf2, 0x85, 0xa9, 0xd5, 0x0e, 0xa9, 0x26, 0x60, 0xfe, 0xee, 0xc7, 0x59, 0x99, 0x5e, 0xa3, 0xdf, 0x23, 0x36, 0xd5,
|
||||
/* (2^246)P */ 0x15, 0x66, 0x6f, 0xd5, 0x78, 0xa4, 0x0a, 0xf7, 0xb1, 0xe8, 0x75, 0x6b, 0x48, 0x7d, 0xa6, 0x4d, 0x3d, 0x36, 0x9b, 0xc7, 0xcc, 0x68, 0x9a, 0xfe, 0x2f, 0x39, 0x2a, 0x51, 0x31, 0x39, 0x7d, 0x73, 0x6f, 0xc8, 0x74, 0x72, 0x6f, 0x6e, 0xda, 0x5f, 0xad, 0x48, 0xc8, 0x40, 0xe1, 0x06, 0x01, 0x36, 0xa1, 0x88, 0xc8, 0x99, 0x9c, 0xd1, 0x11, 0x8f,
|
||||
/* (2^247)P */ 0xab, 0xc5, 0xcb, 0xcf, 0xbd, 0x73, 0x21, 0xd0, 0x82, 0xb1, 0x2e, 0x2d, 0xd4, 0x36, 0x1b, 0xed, 0xa9, 0x8a, 0x26, 0x79, 0xc4, 0x17, 0xae, 0xe5, 0x09, 0x0a, 0x0c, 0xa4, 0x21, 0xa0, 0x6e, 0xdd, 0x62, 0x8e, 0x44, 0x62, 0xcc, 0x50, 0xff, 0x93, 0xb3, 0x9a, 0x72, 0x8c, 0x3f, 0xa1, 0xa6, 0x4d, 0x87, 0xd5, 0x1c, 0x5a, 0xc0, 0x0b, 0x1a, 0xd6,
|
||||
/* (2^248)P */ 0x67, 0x36, 0x6a, 0x1f, 0x96, 0xe5, 0x80, 0x20, 0xa9, 0xe8, 0x0b, 0x0e, 0x21, 0x29, 0x3f, 0xc8, 0x0a, 0x6d, 0x27, 0x47, 0xca, 0xd9, 0x05, 0x55, 0xbf, 0x11, 0xcf, 0x31, 0x7a, 0x37, 0xc7, 0x90, 0xa9, 0xf4, 0x07, 0x5e, 0xd5, 0xc3, 0x92, 0xaa, 0x95, 0xc8, 0x23, 0x2a, 0x53, 0x45, 0xe3, 0x3a, 0x24, 0xe9, 0x67, 0x97, 0x3a, 0x82, 0xf9, 0xa6,
|
||||
/* (2^249)P */ 0x92, 0x9e, 0x6d, 0x82, 0x67, 0xe9, 0xf9, 0x17, 0x96, 0x2c, 0xa7, 0xd3, 0x89, 0xf9, 0xdb, 0xd8, 0x20, 0xc6, 0x2e, 0xec, 0x4a, 0x76, 0x64, 0xbf, 0x27, 0x40, 0xe2, 0xb4, 0xdf, 0x1f, 0xa0, 0xef, 0x07, 0x80, 0xfb, 0x8e, 0x12, 0xf8, 0xb8, 0xe1, 0xc6, 0xdf, 0x7c, 0x69, 0x35, 0x5a, 0xe1, 0x8e, 0x5d, 0x69, 0x84, 0x56, 0xb6, 0x31, 0x1c, 0x0b,
|
||||
/* (2^250)P */ 0xd6, 0x94, 0x5c, 0xef, 0xbb, 0x46, 0x45, 0x44, 0x5b, 0xa1, 0xae, 0x03, 0x65, 0xdd, 0xb5, 0x66, 0x88, 0x35, 0x29, 0x95, 0x16, 0x54, 0xa6, 0xf5, 0xc9, 0x78, 0x34, 0xe6, 0x0f, 0xc4, 0x2b, 0x5b, 0x79, 0x51, 0x68, 0x48, 0x3a, 0x26, 0x87, 0x05, 0x70, 0xaf, 0x8b, 0xa6, 0xc7, 0x2e, 0xb3, 0xa9, 0x10, 0x01, 0xb0, 0xb9, 0x31, 0xfd, 0xdc, 0x80,
|
||||
/* (2^251)P */ 0x25, 0xf2, 0xad, 0xd6, 0x75, 0xa3, 0x04, 0x05, 0x64, 0x8a, 0x97, 0x60, 0x27, 0x2a, 0xe5, 0x6d, 0xb0, 0x73, 0xf4, 0x07, 0x2a, 0x9d, 0xe9, 0x46, 0xb4, 0x1c, 0x51, 0xf8, 0x63, 0x98, 0x7e, 0xe5, 0x13, 0x51, 0xed, 0x98, 0x65, 0x98, 0x4f, 0x8f, 0xe7, 0x7e, 0x72, 0xd7, 0x64, 0x11, 0x2f, 0xcd, 0x12, 0xf8, 0xc4, 0x63, 0x52, 0x0f, 0x7f, 0xc4,
|
||||
/* (2^252)P */ 0x5c, 0xd9, 0x85, 0x63, 0xc7, 0x8a, 0x65, 0x9a, 0x25, 0x83, 0x31, 0x73, 0x49, 0xf0, 0x93, 0x96, 0x70, 0x67, 0x6d, 0xb1, 0xff, 0x95, 0x54, 0xe4, 0xf8, 0x15, 0x6c, 0x5f, 0xbd, 0xf6, 0x0f, 0x38, 0x7b, 0x68, 0x7d, 0xd9, 0x3d, 0xf0, 0xa9, 0xa0, 0xe4, 0xd1, 0xb6, 0x34, 0x6d, 0x14, 0x16, 0xc2, 0x4c, 0x30, 0x0e, 0x67, 0xd3, 0xbe, 0x2e, 0xc0,
|
||||
/* (2^253)P */ 0x06, 0x6b, 0x52, 0xc8, 0x14, 0xcd, 0xae, 0x03, 0x93, 0xea, 0xc1, 0xf2, 0xf6, 0x8b, 0xc5, 0xb6, 0xdc, 0x82, 0x42, 0x29, 0x94, 0xe0, 0x25, 0x6c, 0x3f, 0x9f, 0x5d, 0xe4, 0x96, 0xf6, 0x8e, 0x3f, 0xf9, 0x72, 0xc4, 0x77, 0x60, 0x8b, 0xa4, 0xf9, 0xa8, 0xc3, 0x0a, 0x81, 0xb1, 0x97, 0x70, 0x18, 0xab, 0xea, 0x37, 0x8a, 0x08, 0xc7, 0xe2, 0x95,
|
||||
/* (2^254)P */ 0x94, 0x49, 0xd9, 0x5f, 0x76, 0x72, 0x82, 0xad, 0x2d, 0x50, 0x1a, 0x7a, 0x5b, 0xe6, 0x95, 0x1e, 0x95, 0x65, 0x87, 0x1c, 0x52, 0xd7, 0x44, 0xe6, 0x9b, 0x56, 0xcd, 0x6f, 0x05, 0xff, 0x67, 0xc5, 0xdb, 0xa2, 0xac, 0xe4, 0xa2, 0x28, 0x63, 0x5f, 0xfb, 0x0c, 0x3b, 0xf1, 0x87, 0xc3, 0x36, 0x78, 0x3f, 0x77, 0xfa, 0x50, 0x85, 0xf9, 0xd7, 0x82,
|
||||
/* (2^255)P */ 0x64, 0xc0, 0xe0, 0xd8, 0x2d, 0xed, 0xcb, 0x6a, 0xfd, 0xcd, 0xbc, 0x7e, 0x9f, 0xc8, 0x85, 0xe9, 0xc1, 0x7c, 0x0f, 0xe5, 0x18, 0xea, 0xd4, 0x51, 0xad, 0x59, 0x13, 0x75, 0xd9, 0x3d, 0xd4, 0x8a, 0xb2, 0xbe, 0x78, 0x52, 0x2b, 0x52, 0x94, 0x37, 0x41, 0xd6, 0xb4, 0xb6, 0x45, 0x20, 0x76, 0xe0, 0x1f, 0x31, 0xdb, 0xb1, 0xa1, 0x43, 0xf0, 0x18,
|
||||
/* (2^256)P */ 0x74, 0xa9, 0xa4, 0xa9, 0xdd, 0x6e, 0x3e, 0x68, 0xe5, 0xc3, 0x2e, 0x92, 0x17, 0xa4, 0xcb, 0x80, 0xb1, 0xf0, 0x06, 0x93, 0xef, 0xe6, 0x00, 0xe6, 0x3b, 0xb1, 0x32, 0x65, 0x7b, 0x83, 0xb6, 0x8a, 0x49, 0x1b, 0x14, 0x89, 0xee, 0xba, 0xf5, 0x6a, 0x8d, 0x36, 0xef, 0xb0, 0xd8, 0xb2, 0x16, 0x99, 0x17, 0x35, 0x02, 0x16, 0x55, 0x58, 0xdd, 0x82,
|
||||
/* (2^257)P */ 0x36, 0x95, 0xe8, 0xf4, 0x36, 0x42, 0xbb, 0xc5, 0x3e, 0xfa, 0x30, 0x84, 0x9e, 0x59, 0xfd, 0xd2, 0x95, 0x42, 0xf8, 0x64, 0xd9, 0xb9, 0x0e, 0x9f, 0xfa, 0xd0, 0x7b, 0x20, 0x31, 0x77, 0x48, 0x29, 0x4d, 0xd0, 0x32, 0x57, 0x56, 0x30, 0xa6, 0x17, 0x53, 0x04, 0xbf, 0x08, 0x28, 0xec, 0xb8, 0x46, 0xc1, 0x03, 0x89, 0xdc, 0xed, 0xa0, 0x35, 0x53,
|
||||
/* (2^258)P */ 0xc5, 0x7f, 0x9e, 0xd8, 0xc5, 0xba, 0x5f, 0x68, 0xc8, 0x23, 0x75, 0xea, 0x0d, 0xd9, 0x5a, 0xfd, 0x61, 0x1a, 0xa3, 0x2e, 0x45, 0x63, 0x14, 0x55, 0x86, 0x21, 0x29, 0xbe, 0xef, 0x5e, 0x50, 0xe5, 0x18, 0x59, 0xe7, 0xe3, 0xce, 0x4d, 0x8c, 0x15, 0x8f, 0x89, 0x66, 0x44, 0x52, 0x3d, 0xfa, 0xc7, 0x9a, 0x59, 0x90, 0x8e, 0xc0, 0x06, 0x3f, 0xc9,
|
||||
/* (2^259)P */ 0x8e, 0x04, 0xd9, 0x16, 0x50, 0x1d, 0x8c, 0x9f, 0xd5, 0xe3, 0xce, 0xfd, 0x47, 0x04, 0x27, 0x4d, 0xc2, 0xfa, 0x71, 0xd9, 0x0b, 0xb8, 0x65, 0xf4, 0x11, 0xf3, 0x08, 0xee, 0x81, 0xc8, 0x67, 0x99, 0x0b, 0x8d, 0x77, 0xa3, 0x4f, 0xb5, 0x9b, 0xdb, 0x26, 0xf1, 0x97, 0xeb, 0x04, 0x54, 0xeb, 0x80, 0x08, 0x1d, 0x1d, 0xf6, 0x3d, 0x1f, 0x5a, 0xb8,
|
||||
/* (2^260)P */ 0xb7, 0x9c, 0x9d, 0xee, 0xb9, 0x5c, 0xad, 0x0d, 0x9e, 0xfd, 0x60, 0x3c, 0x27, 0x4e, 0xa2, 0x95, 0xfb, 0x64, 0x7e, 0x79, 0x64, 0x87, 0x10, 0xb4, 0x73, 0xe0, 0x9d, 0x46, 0x4d, 0x3d, 0xee, 0x83, 0xe4, 0x16, 0x88, 0x97, 0xe6, 0x4d, 0xba, 0x70, 0xb6, 0x96, 0x7b, 0xff, 0x4b, 0xc8, 0xcf, 0x72, 0x83, 0x3e, 0x5b, 0x24, 0x2e, 0x57, 0xf1, 0x82,
|
||||
/* (2^261)P */ 0x30, 0x71, 0x40, 0x51, 0x4f, 0x44, 0xbb, 0xc7, 0xf0, 0x54, 0x6e, 0x9d, 0xeb, 0x15, 0xad, 0xf8, 0x61, 0x43, 0x5a, 0xef, 0xc0, 0xb1, 0x57, 0xae, 0x03, 0x40, 0xe8, 0x68, 0x6f, 0x03, 0x20, 0x4f, 0x8a, 0x51, 0x2a, 0x9e, 0xd2, 0x45, 0xaf, 0xb4, 0xf5, 0xd4, 0x95, 0x7f, 0x3d, 0x3d, 0xb7, 0xb6, 0x28, 0xc5, 0x08, 0x8b, 0x44, 0xd6, 0x3f, 0xe7,
|
||||
/* (2^262)P */ 0xa9, 0x52, 0x04, 0x67, 0xcb, 0x20, 0x63, 0xf8, 0x18, 0x01, 0x44, 0x21, 0x6a, 0x8a, 0x83, 0x48, 0xd4, 0xaf, 0x23, 0x0f, 0x35, 0x8d, 0xe5, 0x5a, 0xc4, 0x7c, 0x55, 0x46, 0x19, 0x5f, 0x35, 0xe0, 0x5d, 0x97, 0x4c, 0x2d, 0x04, 0xed, 0x59, 0xd4, 0xb0, 0xb2, 0xc6, 0xe3, 0x51, 0xe1, 0x38, 0xc6, 0x30, 0x49, 0x8f, 0xae, 0x61, 0x64, 0xce, 0xa8,
|
||||
/* (2^263)P */ 0x9b, 0x64, 0x83, 0x3c, 0xd3, 0xdf, 0xb9, 0x27, 0xe7, 0x5b, 0x7f, 0xeb, 0xf3, 0x26, 0xcf, 0xb1, 0x8f, 0xaf, 0x26, 0xc8, 0x48, 0xce, 0xa1, 0xac, 0x7d, 0x10, 0x34, 0x28, 0xe1, 0x1f, 0x69, 0x03, 0x64, 0x77, 0x61, 0xdd, 0x4a, 0x9b, 0x18, 0x47, 0xf8, 0xca, 0x63, 0xc9, 0x03, 0x2d, 0x20, 0x2a, 0x69, 0x6e, 0x42, 0xd0, 0xe7, 0xaa, 0xb5, 0xf3,
|
||||
/* (2^264)P */ 0xea, 0x31, 0x0c, 0x57, 0x0f, 0x3e, 0xe3, 0x35, 0xd8, 0x30, 0xa5, 0x6f, 0xdd, 0x95, 0x43, 0xc6, 0x66, 0x07, 0x4f, 0x34, 0xc3, 0x7e, 0x04, 0x10, 0x2d, 0xc4, 0x1c, 0x94, 0x52, 0x2e, 0x5b, 0x9a, 0x65, 0x2f, 0x91, 0xaa, 0x4f, 0x3c, 0xdc, 0x23, 0x18, 0xe1, 0x4f, 0x85, 0xcd, 0xf4, 0x8c, 0x51, 0xf7, 0xab, 0x4f, 0xdc, 0x15, 0x5c, 0x9e, 0xc5,
|
||||
/* (2^265)P */ 0x54, 0x57, 0x23, 0x17, 0xe7, 0x82, 0x2f, 0x04, 0x7d, 0xfe, 0xe7, 0x1f, 0xa2, 0x57, 0x79, 0xe9, 0x58, 0x9b, 0xbe, 0xc6, 0x16, 0x4a, 0x17, 0x50, 0x90, 0x4a, 0x34, 0x70, 0x87, 0x37, 0x01, 0x26, 0xd8, 0xa3, 0x5f, 0x07, 0x7c, 0xd0, 0x7d, 0x05, 0x8a, 0x93, 0x51, 0x2f, 0x99, 0xea, 0xcf, 0x00, 0xd8, 0xc7, 0xe6, 0x9b, 0x8c, 0x62, 0x45, 0x87,
|
||||
/* (2^266)P */ 0xc3, 0xfd, 0x29, 0x66, 0xe7, 0x30, 0x29, 0x77, 0xe0, 0x0d, 0x63, 0x5b, 0xe6, 0x90, 0x1a, 0x1e, 0x99, 0xc2, 0xa7, 0xab, 0xff, 0xa7, 0xbd, 0x79, 0x01, 0x97, 0xfd, 0x27, 0x1b, 0x43, 0x2b, 0xe6, 0xfe, 0x5e, 0xf1, 0xb9, 0x35, 0x38, 0x08, 0x25, 0x55, 0x90, 0x68, 0x2e, 0xc3, 0x67, 0x39, 0x9f, 0x2b, 0x2c, 0x70, 0x48, 0x8c, 0x47, 0xee, 0x56,
|
||||
/* (2^267)P */ 0xf7, 0x32, 0x70, 0xb5, 0xe6, 0x42, 0xfd, 0x0a, 0x39, 0x9b, 0x07, 0xfe, 0x0e, 0xf4, 0x47, 0xba, 0x6a, 0x3f, 0xf5, 0x2c, 0x15, 0xf3, 0x60, 0x3f, 0xb1, 0x83, 0x7b, 0x2e, 0x34, 0x58, 0x1a, 0x6e, 0x4a, 0x49, 0x05, 0x45, 0xca, 0xdb, 0x00, 0x01, 0x0c, 0x42, 0x5e, 0x60, 0x40, 0x5f, 0xd9, 0xc7, 0x3a, 0x9e, 0x1c, 0x8d, 0xab, 0x11, 0x55, 0x65,
|
||||
/* (2^268)P */ 0x87, 0x40, 0xb7, 0x0d, 0xaa, 0x34, 0x89, 0x90, 0x75, 0x6d, 0xa2, 0xfe, 0x3b, 0x6d, 0x5c, 0x39, 0x98, 0x10, 0x9e, 0x15, 0xc5, 0x35, 0xa2, 0x27, 0x23, 0x0a, 0x2d, 0x60, 0xe2, 0xa8, 0x7f, 0x3e, 0x77, 0x8f, 0xcc, 0x44, 0xcc, 0x30, 0x28, 0xe2, 0xf0, 0x04, 0x8c, 0xee, 0xe4, 0x5f, 0x68, 0x8c, 0xdf, 0x70, 0xbf, 0x31, 0xee, 0x2a, 0xfc, 0xce,
|
||||
/* (2^269)P */ 0x92, 0xf2, 0xa0, 0xd9, 0x58, 0x3b, 0x7c, 0x1a, 0x99, 0x46, 0x59, 0x54, 0x60, 0x06, 0x8d, 0x5e, 0xf0, 0x22, 0xa1, 0xed, 0x92, 0x8a, 0x4d, 0x76, 0x95, 0x05, 0x0b, 0xff, 0xfc, 0x9a, 0xd1, 0xcc, 0x05, 0xb9, 0x5e, 0x99, 0xe8, 0x2a, 0x76, 0x7b, 0xfd, 0xa6, 0xe2, 0xd1, 0x1a, 0xd6, 0x76, 0x9f, 0x2f, 0x0e, 0xd1, 0xa8, 0x77, 0x5a, 0x40, 0x5a,
|
||||
/* (2^270)P */ 0xff, 0xf9, 0x3f, 0xa9, 0xa6, 0x6c, 0x6d, 0x03, 0x8b, 0xa7, 0x10, 0x5d, 0x3f, 0xec, 0x3e, 0x1c, 0x0b, 0x6b, 0xa2, 0x6a, 0x22, 0xa9, 0x28, 0xd0, 0x66, 0xc9, 0xc2, 0x3d, 0x47, 0x20, 0x7d, 0xa6, 0x1d, 0xd8, 0x25, 0xb5, 0xf2, 0xf9, 0x70, 0x19, 0x6b, 0xf8, 0x43, 0x36, 0xc5, 0x1f, 0xe4, 0x5a, 0x4c, 0x13, 0xe4, 0x6d, 0x08, 0x0b, 0x1d, 0xb1,
|
||||
/* (2^271)P */ 0x3f, 0x20, 0x9b, 0xfb, 0xec, 0x7d, 0x31, 0xc5, 0xfc, 0x88, 0x0b, 0x30, 0xed, 0x36, 0xc0, 0x63, 0xb1, 0x7d, 0x10, 0xda, 0xb6, 0x2e, 0xad, 0xf3, 0xec, 0x94, 0xe7, 0xec, 0xb5, 0x9c, 0xfe, 0xf5, 0x35, 0xf0, 0xa2, 0x2d, 0x7f, 0xca, 0x6b, 0x67, 0x1a, 0xf6, 0xb3, 0xda, 0x09, 0x2a, 0xaa, 0xdf, 0xb1, 0xca, 0x9b, 0xfb, 0xeb, 0xb3, 0xcd, 0xc0,
|
||||
/* (2^272)P */ 0xcd, 0x4d, 0x89, 0x00, 0xa4, 0x3b, 0x48, 0xf0, 0x76, 0x91, 0x35, 0xa5, 0xf8, 0xc9, 0xb6, 0x46, 0xbc, 0xf6, 0x9a, 0x45, 0x47, 0x17, 0x96, 0x80, 0x5b, 0x3a, 0x28, 0x33, 0xf9, 0x5a, 0xef, 0x43, 0x07, 0xfe, 0x3b, 0xf4, 0x8e, 0x19, 0xce, 0xd2, 0x94, 0x4b, 0x6d, 0x8e, 0x67, 0x20, 0xc7, 0x4f, 0x2f, 0x59, 0x8e, 0xe1, 0xa1, 0xa9, 0xf9, 0x0e,
|
||||
/* (2^273)P */ 0xdc, 0x7b, 0xb5, 0x50, 0x2e, 0xe9, 0x7e, 0x8b, 0x78, 0xa1, 0x38, 0x96, 0x22, 0xc3, 0x61, 0x67, 0x6d, 0xc8, 0x58, 0xed, 0x41, 0x1d, 0x5d, 0x86, 0x98, 0x7f, 0x2f, 0x1b, 0x8d, 0x3e, 0xaa, 0xc1, 0xd2, 0x0a, 0xf3, 0xbf, 0x95, 0x04, 0xf3, 0x10, 0x3c, 0x2b, 0x7f, 0x90, 0x46, 0x04, 0xaa, 0x6a, 0xa9, 0x35, 0x76, 0xac, 0x49, 0xb5, 0x00, 0x45,
|
||||
/* (2^274)P */ 0xb1, 0x93, 0x79, 0x84, 0x4a, 0x2a, 0x30, 0x78, 0x16, 0xaa, 0xc5, 0x74, 0x06, 0xce, 0xa5, 0xa7, 0x32, 0x86, 0xe0, 0xf9, 0x10, 0xd2, 0x58, 0x76, 0xfb, 0x66, 0x49, 0x76, 0x3a, 0x90, 0xba, 0xb5, 0xcc, 0x99, 0xcd, 0x09, 0xc1, 0x9a, 0x74, 0x23, 0xdf, 0x0c, 0xfe, 0x99, 0x52, 0x80, 0xa3, 0x7c, 0x1c, 0x71, 0x5f, 0x2c, 0x49, 0x57, 0xf4, 0xf9,
|
||||
/* (2^275)P */ 0x6d, 0xbf, 0x52, 0xe6, 0x25, 0x98, 0xed, 0xcf, 0xe3, 0xbc, 0x08, 0xa2, 0x1a, 0x90, 0xae, 0xa0, 0xbf, 0x07, 0x15, 0xad, 0x0a, 0x9f, 0x3e, 0x47, 0x44, 0xc2, 0x10, 0x46, 0xa6, 0x7a, 0x9e, 0x2f, 0x57, 0xbc, 0xe2, 0xf0, 0x1d, 0xd6, 0x9a, 0x06, 0xed, 0xfc, 0x54, 0x95, 0x92, 0x15, 0xa2, 0xf7, 0x8d, 0x6b, 0xef, 0xb2, 0x05, 0xed, 0x5c, 0x63,
|
||||
/* (2^276)P */ 0xbc, 0x0b, 0x27, 0x3a, 0x3a, 0xf8, 0xe1, 0x48, 0x02, 0x7e, 0x27, 0xe6, 0x81, 0x62, 0x07, 0x73, 0x74, 0xe5, 0x52, 0xd7, 0xf8, 0x26, 0xca, 0x93, 0x4d, 0x3e, 0x9b, 0x55, 0x09, 0x8e, 0xe3, 0xd7, 0xa6, 0xe3, 0xb6, 0x2a, 0xa9, 0xb3, 0xb0, 0xa0, 0x8c, 0x01, 0xbb, 0x07, 0x90, 0x78, 0x6d, 0x6d, 0xe9, 0xf0, 0x7a, 0x90, 0xbd, 0xdc, 0x0c, 0x36,
|
||||
/* (2^277)P */ 0x7f, 0x20, 0x12, 0x0f, 0x40, 0x00, 0x53, 0xd8, 0x0c, 0x27, 0x47, 0x47, 0x22, 0x80, 0xfb, 0x62, 0xe4, 0xa7, 0xf7, 0xbd, 0x42, 0xa5, 0xc3, 0x2b, 0xb2, 0x7f, 0x50, 0xcc, 0xe2, 0xfb, 0xd5, 0xc0, 0x63, 0xdd, 0x24, 0x5f, 0x7c, 0x08, 0x91, 0xbf, 0x6e, 0x47, 0x44, 0xd4, 0x6a, 0xc0, 0xc3, 0x09, 0x39, 0x27, 0xdd, 0xc7, 0xca, 0x06, 0x29, 0x55,
|
||||
/* (2^278)P */ 0x76, 0x28, 0x58, 0xb0, 0xd2, 0xf3, 0x0f, 0x04, 0xe9, 0xc9, 0xab, 0x66, 0x5b, 0x75, 0x51, 0xdc, 0xe5, 0x8f, 0xe8, 0x1f, 0xdb, 0x03, 0x0f, 0xb0, 0x7d, 0xf9, 0x20, 0x64, 0x89, 0xe9, 0xdc, 0xe6, 0x24, 0xc3, 0xd5, 0xd2, 0x41, 0xa6, 0xe4, 0xe3, 0xc4, 0x79, 0x7c, 0x0f, 0xa1, 0x61, 0x2f, 0xda, 0xa4, 0xc9, 0xfd, 0xad, 0x5c, 0x65, 0x6a, 0xf3,
|
||||
/* (2^279)P */ 0xd5, 0xab, 0x72, 0x7a, 0x3b, 0x59, 0xea, 0xcf, 0xd5, 0x17, 0xd2, 0xb2, 0x5f, 0x2d, 0xab, 0xad, 0x9e, 0x88, 0x64, 0x55, 0x96, 0x6e, 0xf3, 0x44, 0xa9, 0x11, 0xf5, 0xf8, 0x3a, 0xf1, 0xcd, 0x79, 0x4c, 0x99, 0x6d, 0x23, 0x6a, 0xa0, 0xc2, 0x1a, 0x19, 0x45, 0xb5, 0xd8, 0x95, 0x2f, 0x49, 0xe9, 0x46, 0x39, 0x26, 0x60, 0x04, 0x15, 0x8b, 0xcc,
|
||||
/* (2^280)P */ 0x66, 0x0c, 0xf0, 0x54, 0x41, 0x02, 0x91, 0xab, 0xe5, 0x85, 0x8a, 0x44, 0xa6, 0x34, 0x96, 0x32, 0xc0, 0xdf, 0x6c, 0x41, 0x39, 0xd4, 0xc6, 0xe1, 0xe3, 0x81, 0xb0, 0x4c, 0x34, 0x4f, 0xe5, 0xf4, 0x35, 0x46, 0x1f, 0xeb, 0x75, 0xfd, 0x43, 0x37, 0x50, 0x99, 0xab, 0xad, 0xb7, 0x8c, 0xa1, 0x57, 0xcb, 0xe6, 0xce, 0x16, 0x2e, 0x85, 0xcc, 0xf9,
|
||||
/* (2^281)P */ 0x63, 0xd1, 0x3f, 0x9e, 0xa2, 0x17, 0x2e, 0x1d, 0x3e, 0xce, 0x48, 0x2d, 0xbb, 0x8f, 0x69, 0xc9, 0xa6, 0x3d, 0x4e, 0xfe, 0x09, 0x56, 0xb3, 0x02, 0x5f, 0x99, 0x97, 0x0c, 0x54, 0xda, 0x32, 0x97, 0x9b, 0xf4, 0x95, 0xf1, 0xad, 0xe3, 0x2b, 0x04, 0xa7, 0x9b, 0x3f, 0xbb, 0xe7, 0x87, 0x2e, 0x1f, 0x8b, 0x4b, 0x7a, 0xa4, 0x43, 0x0c, 0x0f, 0x35,
|
||||
/* (2^282)P */ 0x05, 0xdc, 0xe0, 0x2c, 0xa1, 0xc1, 0xd0, 0xf1, 0x1f, 0x4e, 0xc0, 0x6c, 0x35, 0x7b, 0xca, 0x8f, 0x8b, 0x02, 0xb1, 0xf7, 0xd6, 0x2e, 0xe7, 0x93, 0x80, 0x85, 0x18, 0x88, 0x19, 0xb9, 0xb4, 0x4a, 0xbc, 0xeb, 0x5a, 0x78, 0x38, 0xed, 0xc6, 0x27, 0x2a, 0x74, 0x76, 0xf0, 0x1b, 0x79, 0x92, 0x2f, 0xd2, 0x81, 0x98, 0xdf, 0xa9, 0x50, 0x19, 0xeb,
|
||||
/* (2^283)P */ 0xb5, 0xe7, 0xb4, 0x11, 0x3a, 0x81, 0xb6, 0xb4, 0xf8, 0xa2, 0xb3, 0x6c, 0xfc, 0x9d, 0xe0, 0xc0, 0xe0, 0x59, 0x7f, 0x05, 0x37, 0xef, 0x2c, 0xa9, 0x3a, 0x24, 0xac, 0x7b, 0x25, 0xa0, 0x55, 0xd2, 0x44, 0x82, 0x82, 0x6e, 0x64, 0xa3, 0x58, 0xc8, 0x67, 0xae, 0x26, 0xa7, 0x0f, 0x42, 0x63, 0xe1, 0x93, 0x01, 0x52, 0x19, 0xaf, 0x49, 0x3e, 0x33,
|
||||
/* (2^284)P */ 0x05, 0x85, 0xe6, 0x66, 0xaf, 0x5f, 0xdf, 0xbf, 0x9d, 0x24, 0x62, 0x60, 0x90, 0xe2, 0x4c, 0x7d, 0x4e, 0xc3, 0x74, 0x5d, 0x4f, 0x53, 0xf3, 0x63, 0x13, 0xf4, 0x74, 0x28, 0x6b, 0x7d, 0x57, 0x0c, 0x9d, 0x84, 0xa7, 0x1a, 0xff, 0xa0, 0x79, 0xdf, 0xfc, 0x65, 0x98, 0x8e, 0x22, 0x0d, 0x62, 0x7e, 0xf2, 0x34, 0x60, 0x83, 0x05, 0x14, 0xb1, 0xc1,
|
||||
/* (2^285)P */ 0x64, 0x22, 0xcc, 0xdf, 0x5c, 0xbc, 0x88, 0x68, 0x4c, 0xd9, 0xbc, 0x0e, 0xc9, 0x8b, 0xb4, 0x23, 0x52, 0xad, 0xb0, 0xb3, 0xf1, 0x17, 0xd8, 0x15, 0x04, 0x6b, 0x99, 0xf0, 0xc4, 0x7d, 0x48, 0x22, 0x4a, 0xf8, 0x6f, 0xaa, 0x88, 0x0d, 0xc5, 0x5e, 0xa9, 0x1c, 0x61, 0x3d, 0x95, 0xa9, 0x7b, 0x6a, 0x79, 0x33, 0x0a, 0x2b, 0x99, 0xe3, 0x4e, 0x48,
|
||||
/* (2^286)P */ 0x6b, 0x9b, 0x6a, 0x2a, 0xf1, 0x60, 0x31, 0xb4, 0x73, 0xd1, 0x87, 0x45, 0x9c, 0x15, 0x58, 0x4b, 0x91, 0x6d, 0x94, 0x1c, 0x41, 0x11, 0x4a, 0x83, 0xec, 0xaf, 0x65, 0xbc, 0x34, 0xaa, 0x26, 0xe2, 0xaf, 0xed, 0x46, 0x05, 0x4e, 0xdb, 0xc6, 0x4e, 0x10, 0x28, 0x4e, 0x72, 0xe5, 0x31, 0xa3, 0x20, 0xd7, 0xb1, 0x96, 0x64, 0xf6, 0xce, 0x08, 0x08,
|
||||
/* (2^287)P */ 0x16, 0xa9, 0x5c, 0x9f, 0x9a, 0xb4, 0xb8, 0xc8, 0x32, 0x78, 0xc0, 0x3a, 0xd9, 0x5f, 0x94, 0xac, 0x3a, 0x42, 0x1f, 0x43, 0xd6, 0x80, 0x47, 0x2c, 0xdc, 0x76, 0x27, 0xfa, 0x50, 0xe5, 0xa1, 0xe4, 0xc3, 0xcb, 0x61, 0x31, 0xe1, 0x2e, 0xde, 0x81, 0x3b, 0x77, 0x1c, 0x39, 0x3c, 0xdb, 0xda, 0x87, 0x4b, 0x84, 0x12, 0xeb, 0xdd, 0x54, 0xbf, 0xe7,
|
||||
/* (2^288)P */ 0xbf, 0xcb, 0x73, 0x21, 0x3d, 0x7e, 0x13, 0x8c, 0xa6, 0x34, 0x21, 0x2b, 0xa5, 0xe4, 0x9f, 0x8e, 0x9c, 0x01, 0x9c, 0x43, 0xd9, 0xc7, 0xb9, 0xf1, 0xbe, 0x7f, 0x45, 0x51, 0x97, 0xa1, 0x8e, 0x01, 0xf8, 0xbd, 0xd2, 0xbf, 0x81, 0x3a, 0x8b, 0xab, 0xe4, 0x89, 0xb7, 0xbd, 0xf2, 0xcd, 0xa9, 0x8a, 0x8a, 0xde, 0xfb, 0x8a, 0x55, 0x12, 0x7b, 0x17,
|
||||
/* (2^289)P */ 0x1b, 0x95, 0x58, 0x4d, 0xe6, 0x51, 0x31, 0x52, 0x1c, 0xd8, 0x15, 0x84, 0xb1, 0x0d, 0x36, 0x25, 0x88, 0x91, 0x46, 0x71, 0x42, 0x56, 0xe2, 0x90, 0x08, 0x9e, 0x77, 0x1b, 0xee, 0x22, 0x3f, 0xec, 0xee, 0x8c, 0x7b, 0x2e, 0x79, 0xc4, 0x6c, 0x07, 0xa1, 0x7e, 0x52, 0xf5, 0x26, 0x5c, 0x84, 0x2a, 0x50, 0x6e, 0x82, 0xb3, 0x76, 0xda, 0x35, 0x16,
|
||||
/* (2^290)P */ 0x0a, 0x6f, 0x99, 0x87, 0xc0, 0x7d, 0x8a, 0xb2, 0xca, 0xae, 0xe8, 0x65, 0x98, 0x0f, 0xb3, 0x44, 0xe1, 0xdc, 0x52, 0x79, 0x75, 0xec, 0x8f, 0x95, 0x87, 0x45, 0xd1, 0x32, 0x18, 0x55, 0x15, 0xce, 0x64, 0x9b, 0x08, 0x4f, 0x2c, 0xea, 0xba, 0x1c, 0x57, 0x06, 0x63, 0xc8, 0xb1, 0xfd, 0xc5, 0x67, 0xe7, 0x1f, 0x87, 0x9e, 0xde, 0x72, 0x7d, 0xec,
|
||||
/* (2^291)P */ 0x36, 0x8b, 0x4d, 0x2c, 0xc2, 0x46, 0xe8, 0x96, 0xac, 0x0b, 0x8c, 0xc5, 0x09, 0x10, 0xfc, 0xf2, 0xda, 0xea, 0x22, 0xb2, 0xd3, 0x89, 0xeb, 0xb2, 0x85, 0x0f, 0xff, 0x59, 0x50, 0x2c, 0x99, 0x5a, 0x1f, 0xec, 0x2a, 0x6f, 0xec, 0xcf, 0xe9, 0xce, 0x12, 0x6b, 0x19, 0xd8, 0xde, 0x9b, 0xce, 0x0e, 0x6a, 0xaa, 0xe1, 0x32, 0xea, 0x4c, 0xfe, 0x92,
|
||||
/* (2^292)P */ 0x5f, 0x17, 0x70, 0x53, 0x26, 0x03, 0x0b, 0xab, 0xd1, 0xc1, 0x42, 0x0b, 0xab, 0x2b, 0x3d, 0x31, 0xa4, 0xd5, 0x2b, 0x5e, 0x00, 0xd5, 0x9a, 0x22, 0x34, 0xe0, 0x53, 0x3f, 0x59, 0x7f, 0x2c, 0x6d, 0x72, 0x9a, 0xa4, 0xbe, 0x3d, 0x42, 0x05, 0x1b, 0xf2, 0x7f, 0x88, 0x56, 0xd1, 0x7c, 0x7d, 0x6b, 0x9f, 0x43, 0xfe, 0x65, 0x19, 0xae, 0x9c, 0x4c,
|
||||
/* (2^293)P */ 0xf3, 0x7c, 0x20, 0xa9, 0xfc, 0xf2, 0xf2, 0x3b, 0x3c, 0x57, 0x41, 0x94, 0xe5, 0xcc, 0x6a, 0x37, 0x5d, 0x09, 0xf2, 0xab, 0xc2, 0xca, 0x60, 0x38, 0x6b, 0x7a, 0xe1, 0x78, 0x2b, 0xc1, 0x1d, 0xe8, 0xfd, 0xbc, 0x3d, 0x5c, 0xa2, 0xdb, 0x49, 0x20, 0x79, 0xe6, 0x1b, 0x9b, 0x65, 0xd9, 0x6d, 0xec, 0x57, 0x1d, 0xd2, 0xe9, 0x90, 0xeb, 0x43, 0x7b,
|
||||
/* (2^294)P */ 0x2a, 0x8b, 0x2e, 0x19, 0x18, 0x10, 0xb8, 0x83, 0xe7, 0x7d, 0x2d, 0x9a, 0x3a, 0xe5, 0xd1, 0xe4, 0x7c, 0x38, 0xe5, 0x59, 0x2a, 0x6e, 0xd9, 0x01, 0x29, 0x3d, 0x23, 0xf7, 0x52, 0xba, 0x61, 0x04, 0x9a, 0xde, 0xc4, 0x31, 0x50, 0xeb, 0x1b, 0xaa, 0xde, 0x39, 0x58, 0xd8, 0x1b, 0x1e, 0xfc, 0x57, 0x9a, 0x28, 0x43, 0x9e, 0x97, 0x5e, 0xaa, 0xa3,
|
||||
/* (2^295)P */ 0x97, 0x0a, 0x74, 0xc4, 0x39, 0x99, 0x6b, 0x40, 0xc7, 0x3e, 0x8c, 0xa7, 0xb1, 0x4e, 0x9a, 0x59, 0x6e, 0x1c, 0xfe, 0xfc, 0x2a, 0x5e, 0x73, 0x2b, 0x8c, 0xa9, 0x71, 0xf5, 0xda, 0x6b, 0x15, 0xab, 0xf7, 0xbe, 0x2a, 0x44, 0x5f, 0xba, 0xae, 0x67, 0x93, 0xc5, 0x86, 0xc1, 0xb8, 0xdf, 0xdc, 0xcb, 0xd7, 0xff, 0xb1, 0x71, 0x7c, 0x6f, 0x88, 0xf8,
|
||||
/* (2^296)P */ 0x3f, 0x89, 0xb1, 0xbf, 0x24, 0x16, 0xac, 0x56, 0xfe, 0xdf, 0x94, 0x71, 0xbf, 0xd6, 0x57, 0x0c, 0xb4, 0x77, 0x37, 0xaa, 0x2a, 0x70, 0x76, 0x49, 0xaf, 0x0c, 0x97, 0x8e, 0x78, 0x2a, 0x67, 0xc9, 0x3b, 0x3d, 0x5b, 0x01, 0x2f, 0xda, 0xd5, 0xa8, 0xde, 0x02, 0xa9, 0xac, 0x76, 0x00, 0x0b, 0x46, 0xc6, 0x2d, 0xdc, 0x08, 0xf4, 0x10, 0x2c, 0xbe,
|
||||
/* (2^297)P */ 0xcb, 0x07, 0xf9, 0x91, 0xc6, 0xd5, 0x3e, 0x54, 0x63, 0xae, 0xfc, 0x10, 0xbe, 0x3a, 0x20, 0x73, 0x4e, 0x65, 0x0e, 0x2d, 0x86, 0x77, 0x83, 0x9d, 0xe2, 0x0a, 0xe9, 0xac, 0x22, 0x52, 0x76, 0xd4, 0x6e, 0xfa, 0xe0, 0x09, 0xef, 0x78, 0x82, 0x9f, 0x26, 0xf9, 0x06, 0xb5, 0xe7, 0x05, 0x0e, 0xf2, 0x46, 0x72, 0x93, 0xd3, 0x24, 0xbd, 0x87, 0x60,
|
||||
/* (2^298)P */ 0x14, 0x55, 0x84, 0x7b, 0x6c, 0x60, 0x80, 0x73, 0x8c, 0xbe, 0x2d, 0xd6, 0x69, 0xd6, 0x17, 0x26, 0x44, 0x9f, 0x88, 0xa2, 0x39, 0x7c, 0x89, 0xbc, 0x6d, 0x9e, 0x46, 0xb6, 0x68, 0x66, 0xea, 0xdc, 0x31, 0xd6, 0x21, 0x51, 0x9f, 0x28, 0x28, 0xaf, 0x9e, 0x47, 0x2c, 0x4c, 0x8f, 0xf3, 0xaf, 0x1f, 0xe4, 0xab, 0xac, 0xe9, 0x0c, 0x91, 0x3a, 0x61,
|
||||
/* (2^299)P */ 0xb0, 0x37, 0x55, 0x4b, 0xe9, 0xc3, 0xb1, 0xce, 0x42, 0xe6, 0xc5, 0x11, 0x7f, 0x2c, 0x11, 0xfc, 0x4e, 0x71, 0x17, 0x00, 0x74, 0x7f, 0xbf, 0x07, 0x4d, 0xfd, 0x40, 0xb2, 0x87, 0xb0, 0xef, 0x1f, 0x35, 0x2c, 0x2d, 0xd7, 0xe1, 0xe4, 0xad, 0x0e, 0x7f, 0x63, 0x66, 0x62, 0x23, 0x41, 0xf6, 0xc1, 0x14, 0xa6, 0xd7, 0xa9, 0x11, 0x56, 0x9d, 0x1b,
|
||||
/* (2^300)P */ 0x02, 0x82, 0x42, 0x18, 0x4f, 0x1b, 0xc9, 0x5d, 0x78, 0x5f, 0xee, 0xed, 0x01, 0x49, 0x8f, 0xf2, 0xa0, 0xe2, 0x6e, 0xbb, 0x6b, 0x04, 0x8d, 0xb2, 0x41, 0xae, 0xc8, 0x1b, 0x59, 0x34, 0xb8, 0x2a, 0xdb, 0x1f, 0xd2, 0x52, 0xdf, 0x3f, 0x35, 0x00, 0x8b, 0x61, 0xbc, 0x97, 0xa0, 0xc4, 0x77, 0xd1, 0xe4, 0x2c, 0x59, 0x68, 0xff, 0x30, 0xf2, 0xe2,
|
||||
/* (2^301)P */ 0x79, 0x08, 0xb1, 0xdb, 0x55, 0xae, 0xd0, 0xed, 0xda, 0xa0, 0xec, 0x6c, 0xae, 0x68, 0xf2, 0x0b, 0x61, 0xb3, 0xf5, 0x21, 0x69, 0x87, 0x0b, 0x03, 0xea, 0x8a, 0x15, 0xd9, 0x7e, 0xca, 0xf7, 0xcd, 0xf3, 0x33, 0xb3, 0x4c, 0x5b, 0x23, 0x4e, 0x6f, 0x90, 0xad, 0x91, 0x4b, 0x4f, 0x46, 0x37, 0xe5, 0xe8, 0xb7, 0xeb, 0xd5, 0xca, 0x34, 0x4e, 0x23,
|
||||
/* (2^302)P */ 0x09, 0x02, 0xdd, 0xfd, 0x70, 0xac, 0x56, 0x80, 0x36, 0x5e, 0x49, 0xd0, 0x3f, 0xc2, 0xe0, 0xba, 0x46, 0x7f, 0x5c, 0xf7, 0xc5, 0xbd, 0xd5, 0x55, 0x7d, 0x3f, 0xd5, 0x7d, 0x06, 0xdf, 0x27, 0x20, 0x4f, 0xe9, 0x30, 0xec, 0x1b, 0xa0, 0x0c, 0xd4, 0x2c, 0xe1, 0x2b, 0x65, 0x73, 0xea, 0x75, 0x35, 0xe8, 0xe6, 0x56, 0xd6, 0x07, 0x15, 0x99, 0xdf,
|
||||
/* (2^303)P */ 0x4e, 0x10, 0xb7, 0xd0, 0x63, 0x8c, 0xcf, 0x16, 0x00, 0x7c, 0x58, 0xdf, 0x86, 0xdc, 0x4e, 0xca, 0x9c, 0x40, 0x5a, 0x42, 0xfd, 0xec, 0x98, 0xa4, 0x42, 0x53, 0xae, 0x16, 0x9d, 0xfd, 0x75, 0x5a, 0x12, 0x56, 0x1e, 0xc6, 0x57, 0xcc, 0x79, 0x27, 0x96, 0x00, 0xcf, 0x80, 0x4f, 0x8a, 0x36, 0x5c, 0xbb, 0xe9, 0x12, 0xdb, 0xb6, 0x2b, 0xad, 0x96,
|
||||
/* (2^304)P */ 0x92, 0x32, 0x1f, 0xfd, 0xc6, 0x02, 0x94, 0x08, 0x1b, 0x60, 0x6a, 0x9f, 0x8b, 0xd6, 0xc8, 0xad, 0xd5, 0x1b, 0x27, 0x4e, 0xa4, 0x4d, 0x4a, 0x00, 0x10, 0x5f, 0x86, 0x11, 0xf5, 0xe3, 0x14, 0x32, 0x43, 0xee, 0xb9, 0xc7, 0xab, 0xf4, 0x6f, 0xe5, 0x66, 0x0c, 0x06, 0x0d, 0x96, 0x79, 0x28, 0xaf, 0x45, 0x2b, 0x56, 0xbe, 0xe4, 0x4a, 0x52, 0xd6,
|
||||
/* (2^305)P */ 0x15, 0x16, 0x69, 0xef, 0x60, 0xca, 0x82, 0x25, 0x0f, 0xc6, 0x30, 0xa0, 0x0a, 0xd1, 0x83, 0x29, 0xcd, 0xb6, 0x89, 0x6c, 0xf5, 0xb2, 0x08, 0x38, 0xe6, 0xca, 0x6b, 0x19, 0x93, 0xc6, 0x5f, 0x75, 0x8e, 0x60, 0x34, 0x23, 0xc4, 0x13, 0x17, 0x69, 0x55, 0xcc, 0x72, 0x9c, 0x2b, 0x6c, 0x80, 0xf4, 0x4b, 0x8b, 0xb6, 0x97, 0x65, 0x07, 0xb6, 0xfb,
|
||||
/* (2^306)P */ 0x01, 0x99, 0x74, 0x28, 0xa6, 0x67, 0xa3, 0xe5, 0x25, 0xfb, 0xdf, 0x82, 0x93, 0xe7, 0x35, 0x74, 0xce, 0xe3, 0x15, 0x1c, 0x1d, 0x79, 0x52, 0x84, 0x08, 0x04, 0x2f, 0x5c, 0xb8, 0xcd, 0x7f, 0x89, 0xb0, 0x39, 0x93, 0x63, 0xc9, 0x5d, 0x06, 0x01, 0x59, 0xf7, 0x7e, 0xf1, 0x4c, 0x3d, 0x12, 0x8d, 0x69, 0x1d, 0xb7, 0x21, 0x5e, 0x88, 0x82, 0xa2,
|
||||
/* (2^307)P */ 0x8e, 0x69, 0xaf, 0x9a, 0x41, 0x0d, 0x9d, 0xcf, 0x8e, 0x8d, 0x5c, 0x51, 0x6e, 0xde, 0x0e, 0x48, 0x23, 0x89, 0xe5, 0x37, 0x80, 0xd6, 0x9d, 0x72, 0x32, 0x26, 0x38, 0x2d, 0x63, 0xa0, 0xfa, 0xd3, 0x40, 0xc0, 0x8c, 0x68, 0x6f, 0x2b, 0x1e, 0x9a, 0x39, 0x51, 0x78, 0x74, 0x9a, 0x7b, 0x4a, 0x8f, 0x0c, 0xa0, 0x88, 0x60, 0xa5, 0x21, 0xcd, 0xc7,
|
||||
/* (2^308)P */ 0x3a, 0x7f, 0x73, 0x14, 0xbf, 0x89, 0x6a, 0x4c, 0x09, 0x5d, 0xf2, 0x93, 0x20, 0x2d, 0xc4, 0x29, 0x86, 0x06, 0x95, 0xab, 0x22, 0x76, 0x4c, 0x54, 0xe1, 0x7e, 0x80, 0x6d, 0xab, 0x29, 0x61, 0x87, 0x77, 0xf6, 0xc0, 0x3e, 0xda, 0xab, 0x65, 0x7e, 0x39, 0x12, 0xa1, 0x6b, 0x42, 0xf7, 0xc5, 0x97, 0x77, 0xec, 0x6f, 0x22, 0xbe, 0x44, 0xc7, 0x03,
|
||||
/* (2^309)P */ 0xa5, 0x23, 0x90, 0x41, 0xa3, 0xc5, 0x3e, 0xe0, 0xa5, 0x32, 0x49, 0x1f, 0x39, 0x78, 0xb1, 0xd8, 0x24, 0xea, 0xd4, 0x87, 0x53, 0x42, 0x51, 0xf4, 0xd9, 0x46, 0x25, 0x2f, 0x62, 0xa9, 0x90, 0x9a, 0x4a, 0x25, 0x8a, 0xd2, 0x10, 0xe7, 0x3c, 0xbc, 0x58, 0x8d, 0x16, 0x14, 0x96, 0xa4, 0x6f, 0xf8, 0x12, 0x69, 0x91, 0x73, 0xe2, 0xfa, 0xf4, 0x57,
|
||||
/* (2^310)P */ 0x51, 0x45, 0x3f, 0x96, 0xdc, 0x97, 0x38, 0xa6, 0x01, 0x63, 0x09, 0xea, 0xc2, 0x13, 0x30, 0xb0, 0x00, 0xb8, 0x0a, 0xce, 0xd1, 0x8f, 0x3e, 0x69, 0x62, 0x46, 0x33, 0x9c, 0xbf, 0x4b, 0xcb, 0x0c, 0x90, 0x1c, 0x45, 0xcf, 0x37, 0x5b, 0xf7, 0x4b, 0x5e, 0x95, 0xc3, 0x28, 0x9f, 0x08, 0x83, 0x53, 0x74, 0xab, 0x0c, 0xb4, 0xc0, 0xa1, 0xbc, 0x89,
|
||||
/* (2^311)P */ 0x06, 0xb1, 0x51, 0x15, 0x65, 0x60, 0x21, 0x17, 0x7a, 0x20, 0x65, 0xee, 0x12, 0x35, 0x4d, 0x46, 0xf4, 0xf8, 0xd0, 0xb1, 0xca, 0x09, 0x30, 0x08, 0x89, 0x23, 0x3b, 0xe7, 0xab, 0x8b, 0x77, 0xa6, 0xad, 0x25, 0xdd, 0xea, 0x3c, 0x7d, 0xa5, 0x24, 0xb3, 0xe8, 0xfa, 0xfb, 0xc9, 0xf2, 0x71, 0xe9, 0xfa, 0xf2, 0xdc, 0x54, 0xdd, 0x55, 0x2e, 0x2f,
|
||||
/* (2^312)P */ 0x7f, 0x96, 0x96, 0xfb, 0x52, 0x86, 0xcf, 0xea, 0x62, 0x18, 0xf1, 0x53, 0x1f, 0x61, 0x2a, 0x9f, 0x8c, 0x51, 0xca, 0x2c, 0xde, 0x6d, 0xce, 0xab, 0x58, 0x32, 0x0b, 0x33, 0x9b, 0x99, 0xb4, 0x5c, 0x88, 0x2a, 0x76, 0xcc, 0x3e, 0x54, 0x1e, 0x9d, 0xa2, 0x89, 0xe4, 0x19, 0xba, 0x80, 0xc8, 0x39, 0x32, 0x7f, 0x0f, 0xc7, 0x84, 0xbb, 0x43, 0x56,
|
||||
/* (2^313)P */ 0x9b, 0x07, 0xb4, 0x42, 0xa9, 0xa0, 0x78, 0x4f, 0x28, 0x70, 0x2b, 0x7e, 0x61, 0xe0, 0xdd, 0x02, 0x98, 0xfc, 0xed, 0x31, 0x80, 0xf1, 0x15, 0x52, 0x89, 0x23, 0xcd, 0x5d, 0x2b, 0xc5, 0x19, 0x32, 0xfb, 0x70, 0x50, 0x7a, 0x97, 0x6b, 0x42, 0xdb, 0xca, 0xdb, 0xc4, 0x59, 0x99, 0xe0, 0x12, 0x1f, 0x17, 0xba, 0x8b, 0xf0, 0xc4, 0x38, 0x5d, 0x27,
|
||||
/* (2^314)P */ 0x29, 0x1d, 0xdc, 0x2b, 0xf6, 0x5b, 0x04, 0x61, 0x36, 0x76, 0xa0, 0x56, 0x36, 0x6e, 0xd7, 0x24, 0x4d, 0xe7, 0xef, 0x44, 0xd2, 0xd5, 0x07, 0xcd, 0xc4, 0x9d, 0x80, 0x48, 0xc3, 0x38, 0xcf, 0xd8, 0xa3, 0xdd, 0xb2, 0x5e, 0xb5, 0x70, 0x15, 0xbb, 0x36, 0x85, 0x8a, 0xd7, 0xfb, 0x56, 0x94, 0x73, 0x9c, 0x81, 0xbe, 0xb1, 0x44, 0x28, 0xf1, 0x37,
|
||||
/* (2^315)P */ 0xbf, 0xcf, 0x5c, 0xd2, 0xe2, 0xea, 0xc2, 0xcd, 0x70, 0x7a, 0x9d, 0xcb, 0x81, 0xc1, 0xe9, 0xf1, 0x56, 0x71, 0x52, 0xf7, 0x1b, 0x87, 0xc6, 0xd8, 0xcc, 0xb2, 0x69, 0xf3, 0xb0, 0xbd, 0xba, 0x83, 0x12, 0x26, 0xc4, 0xce, 0x72, 0xde, 0x3b, 0x21, 0x28, 0x9e, 0x5a, 0x94, 0xf5, 0x04, 0xa3, 0xc8, 0x0f, 0x5e, 0xbc, 0x71, 0xf9, 0x0d, 0xce, 0xf5,
|
||||
/* (2^316)P */ 0x93, 0x97, 0x00, 0x85, 0xf4, 0xb4, 0x40, 0xec, 0xd9, 0x2b, 0x6c, 0xd6, 0x63, 0x9e, 0x93, 0x0a, 0x5a, 0xf4, 0xa7, 0x9a, 0xe3, 0x3c, 0xf0, 0x55, 0xd1, 0x96, 0x6c, 0xf5, 0x2a, 0xce, 0xd7, 0x95, 0x72, 0xbf, 0xc5, 0x0c, 0xce, 0x79, 0xa2, 0x0a, 0x78, 0xe0, 0x72, 0xd0, 0x66, 0x28, 0x05, 0x75, 0xd3, 0x23, 0x09, 0x91, 0xed, 0x7e, 0xc4, 0xbc,
|
||||
/* (2^317)P */ 0x77, 0xc2, 0x9a, 0xf7, 0xa6, 0xe6, 0x18, 0xb4, 0xe7, 0xf6, 0xda, 0xec, 0x44, 0x6d, 0xfb, 0x08, 0xee, 0x65, 0xa8, 0x92, 0x85, 0x1f, 0xba, 0x38, 0x93, 0x20, 0x5c, 0x4d, 0xd2, 0x18, 0x0f, 0x24, 0xbe, 0x1a, 0x96, 0x44, 0x7d, 0xeb, 0xb3, 0xda, 0x95, 0xf4, 0xaf, 0x6c, 0x06, 0x0f, 0x47, 0x37, 0xc8, 0x77, 0x63, 0xe1, 0x29, 0xef, 0xff, 0xa5,
|
||||
/* (2^318)P */ 0x16, 0x12, 0xd9, 0x47, 0x90, 0x22, 0x9b, 0x05, 0xf2, 0xa5, 0x9a, 0xae, 0x83, 0x98, 0xb5, 0xac, 0xab, 0x29, 0xaa, 0xdc, 0x5f, 0xde, 0xcd, 0xf7, 0x42, 0xad, 0x3b, 0x96, 0xd6, 0x3e, 0x6e, 0x52, 0x47, 0xb1, 0xab, 0x51, 0xde, 0x49, 0x7c, 0x87, 0x8d, 0x86, 0xe2, 0x70, 0x13, 0x21, 0x51, 0x1c, 0x0c, 0x25, 0xc1, 0xb0, 0xe6, 0x19, 0xcf, 0x12,
|
||||
/* (2^319)P */ 0xf0, 0xbc, 0x97, 0x8f, 0x4b, 0x2f, 0xd1, 0x1f, 0x8c, 0x57, 0xed, 0x3c, 0xf4, 0x26, 0x19, 0xbb, 0x60, 0xca, 0x24, 0xc5, 0xd9, 0x97, 0xe2, 0x5f, 0x76, 0x49, 0x39, 0x7e, 0x2d, 0x12, 0x21, 0x98, 0xda, 0xe6, 0xdb, 0xd2, 0xd8, 0x9f, 0x18, 0xd8, 0x83, 0x6c, 0xba, 0x89, 0x8d, 0x29, 0xfa, 0x46, 0x33, 0x8c, 0x28, 0xdf, 0x6a, 0xb3, 0x69, 0x28,
|
||||
/* (2^320)P */ 0x86, 0x17, 0xbc, 0xd6, 0x7c, 0xba, 0x1e, 0x83, 0xbb, 0x84, 0xb5, 0x8c, 0xad, 0xdf, 0xa1, 0x24, 0x81, 0x70, 0x40, 0x0f, 0xad, 0xad, 0x3b, 0x23, 0xd0, 0x93, 0xa0, 0x49, 0x5c, 0x4b, 0x51, 0xbe, 0x20, 0x49, 0x4e, 0xda, 0x2d, 0xd3, 0xad, 0x1b, 0x74, 0x08, 0x41, 0xf0, 0xef, 0x19, 0xe9, 0x45, 0x5d, 0x02, 0xae, 0x26, 0x25, 0xd9, 0xd1, 0xc2,
|
||||
/* (2^321)P */ 0x48, 0x81, 0x3e, 0xb2, 0x83, 0xf8, 0x4d, 0xb3, 0xd0, 0x4c, 0x75, 0xb3, 0xa0, 0x52, 0x26, 0xf2, 0xaf, 0x5d, 0x36, 0x70, 0x72, 0xd6, 0xb7, 0x88, 0x08, 0x69, 0xbd, 0x15, 0x25, 0xb1, 0x45, 0x1b, 0xb7, 0x0b, 0x5f, 0x71, 0x5d, 0x83, 0x49, 0xb9, 0x84, 0x3b, 0x7c, 0xc1, 0x50, 0x93, 0x05, 0x53, 0xe0, 0x61, 0xea, 0xc1, 0xef, 0xdb, 0x82, 0x97,
|
||||
/* (2^322)P */ 0x00, 0xd5, 0xc3, 0x3a, 0x4d, 0x8a, 0x23, 0x7a, 0xef, 0xff, 0x37, 0xef, 0xf3, 0xbc, 0xa9, 0xb6, 0xae, 0xd7, 0x3a, 0x7b, 0xfd, 0x3e, 0x8e, 0x9b, 0xab, 0x44, 0x54, 0x60, 0x28, 0x6c, 0xbf, 0x15, 0x24, 0x4a, 0x56, 0x60, 0x7f, 0xa9, 0x7a, 0x28, 0x59, 0x2c, 0x8a, 0xd1, 0x7d, 0x6b, 0x00, 0xfd, 0xa5, 0xad, 0xbc, 0x19, 0x3f, 0xcb, 0x73, 0xe0,
|
||||
/* (2^323)P */ 0xcf, 0x9e, 0x66, 0x06, 0x4d, 0x2b, 0xf5, 0x9c, 0xc2, 0x9d, 0x9e, 0xed, 0x5a, 0x5c, 0x2d, 0x00, 0xbf, 0x29, 0x90, 0x88, 0xe4, 0x5d, 0xfd, 0xe2, 0xf0, 0x38, 0xec, 0x4d, 0x26, 0xea, 0x54, 0xf0, 0x3c, 0x84, 0x10, 0x6a, 0xf9, 0x66, 0x9c, 0xe7, 0x21, 0xfd, 0x0f, 0xc7, 0x13, 0x50, 0x81, 0xb6, 0x50, 0xf9, 0x04, 0x7f, 0xa4, 0x37, 0x85, 0x14,
|
||||
/* (2^324)P */ 0xdb, 0x87, 0x49, 0xc7, 0xa8, 0x39, 0x0c, 0x32, 0x98, 0x0c, 0xb9, 0x1a, 0x1b, 0x4d, 0xe0, 0x8a, 0x9a, 0x8e, 0x8f, 0xab, 0x5a, 0x17, 0x3d, 0x04, 0x21, 0xce, 0x3e, 0x2c, 0xf9, 0xa3, 0x97, 0xe4, 0x77, 0x95, 0x0e, 0xb6, 0xa5, 0x15, 0xad, 0x3a, 0x1e, 0x46, 0x53, 0x17, 0x09, 0x83, 0x71, 0x4e, 0x86, 0x38, 0xd5, 0x23, 0x44, 0x16, 0x8d, 0xc8,
|
||||
/* (2^325)P */ 0x05, 0x5e, 0x99, 0x08, 0xbb, 0xc3, 0xc0, 0xb7, 0x6c, 0x12, 0xf2, 0xf3, 0xf4, 0x7c, 0x6a, 0x4d, 0x9e, 0xeb, 0x3d, 0xb9, 0x63, 0x94, 0xce, 0x81, 0xd8, 0x11, 0xcb, 0x55, 0x69, 0x4a, 0x20, 0x0b, 0x4c, 0x2e, 0x14, 0xb8, 0xd4, 0x6a, 0x7c, 0xf0, 0xed, 0xfc, 0x8f, 0xef, 0xa0, 0xeb, 0x6c, 0x01, 0xe2, 0xdc, 0x10, 0x22, 0xa2, 0x01, 0x85, 0x64,
|
||||
/* (2^326)P */ 0x58, 0xe1, 0x9c, 0x27, 0x55, 0xc6, 0x25, 0xa6, 0x7d, 0x67, 0x88, 0x65, 0x99, 0x6c, 0xcb, 0xdb, 0x27, 0x4f, 0x44, 0x29, 0xf5, 0x4a, 0x23, 0x10, 0xbc, 0x03, 0x3f, 0x36, 0x1e, 0xef, 0xb0, 0xba, 0x75, 0xe8, 0x74, 0x5f, 0x69, 0x3e, 0x26, 0x40, 0xb4, 0x2f, 0xdc, 0x43, 0xbf, 0xa1, 0x8b, 0xbd, 0xca, 0x6e, 0xc1, 0x6e, 0x21, 0x79, 0xa0, 0xd0,
|
||||
/* (2^327)P */ 0x78, 0x93, 0x4a, 0x2d, 0x22, 0x6e, 0x6e, 0x7d, 0x74, 0xd2, 0x66, 0x58, 0xce, 0x7b, 0x1d, 0x97, 0xb1, 0xf2, 0xda, 0x1c, 0x79, 0xfb, 0xba, 0xd1, 0xc0, 0xc5, 0x6e, 0xc9, 0x11, 0x89, 0xd2, 0x41, 0x8d, 0x70, 0xb9, 0xcc, 0xea, 0x6a, 0xb3, 0x45, 0xb6, 0x05, 0x2e, 0xf2, 0x17, 0xf1, 0x27, 0xb8, 0xed, 0x06, 0x1f, 0xdb, 0x9d, 0x1f, 0x69, 0x28,
|
||||
/* (2^328)P */ 0x93, 0x12, 0xa8, 0x11, 0xe1, 0x92, 0x30, 0x8d, 0xac, 0xe1, 0x1c, 0x60, 0x7c, 0xed, 0x2d, 0x2e, 0xd3, 0x03, 0x5c, 0x9c, 0xc5, 0xbd, 0x64, 0x4a, 0x8c, 0xba, 0x76, 0xfe, 0xc6, 0xc1, 0xea, 0xc2, 0x4f, 0xbe, 0x70, 0x3d, 0x64, 0xcf, 0x8e, 0x18, 0xcb, 0xcd, 0x57, 0xa7, 0xf7, 0x36, 0xa9, 0x6b, 0x3e, 0xb8, 0x69, 0xee, 0x47, 0xa2, 0x7e, 0xb2,
|
||||
/* (2^329)P */ 0x96, 0xaf, 0x3a, 0xf5, 0xed, 0xcd, 0xaf, 0xf7, 0x82, 0xaf, 0x59, 0x62, 0x0b, 0x36, 0x85, 0xf9, 0xaf, 0xd6, 0x38, 0xff, 0x87, 0x2e, 0x1d, 0x6c, 0x8b, 0xaf, 0x3b, 0xdf, 0x28, 0xa2, 0xd6, 0x4d, 0x80, 0x92, 0xc3, 0x0f, 0x34, 0xa8, 0xae, 0x69, 0x5d, 0x7b, 0x9d, 0xbc, 0xf5, 0xfd, 0x1d, 0xb1, 0x96, 0x55, 0x86, 0xe1, 0x5c, 0xb6, 0xac, 0xb9,
|
||||
/* (2^330)P */ 0x50, 0x9e, 0x37, 0x28, 0x7d, 0xa8, 0x33, 0x63, 0xda, 0x3f, 0x20, 0x98, 0x0e, 0x09, 0xa8, 0x77, 0x3b, 0x7a, 0xfc, 0x16, 0x85, 0x44, 0x64, 0x77, 0x65, 0x68, 0x92, 0x41, 0xc6, 0x1f, 0xdf, 0x27, 0xf9, 0xec, 0xa0, 0x61, 0x22, 0xea, 0x19, 0xe7, 0x75, 0x8b, 0x4e, 0xe5, 0x0f, 0xb7, 0xf7, 0xd2, 0x53, 0xf4, 0xdd, 0x4a, 0xaa, 0x78, 0x40, 0xb7,
|
||||
/* (2^331)P */ 0xd4, 0x89, 0xe3, 0x79, 0xba, 0xb6, 0xc3, 0xda, 0xe6, 0x78, 0x65, 0x7d, 0x6e, 0x22, 0x62, 0xb1, 0x3d, 0xea, 0x90, 0x84, 0x30, 0x5e, 0xd4, 0x39, 0x84, 0x78, 0xd9, 0x75, 0xd6, 0xce, 0x2a, 0x11, 0x29, 0x69, 0xa4, 0x5e, 0xaa, 0x2a, 0x98, 0x5a, 0xe5, 0x91, 0x8f, 0xb2, 0xfb, 0xda, 0x97, 0xe8, 0x83, 0x6f, 0x04, 0xb9, 0x5d, 0xaf, 0xe1, 0x9b,
|
||||
/* (2^332)P */ 0x8b, 0xe4, 0xe1, 0x48, 0x9c, 0xc4, 0x83, 0x89, 0xdf, 0x65, 0xd3, 0x35, 0x55, 0x13, 0xf4, 0x1f, 0x36, 0x92, 0x33, 0x38, 0xcb, 0xed, 0x15, 0xe6, 0x60, 0x2d, 0x25, 0xf5, 0x36, 0x60, 0x3a, 0x37, 0x9b, 0x71, 0x9d, 0x42, 0xb0, 0x14, 0xc8, 0xba, 0x62, 0xa3, 0x49, 0xb0, 0x88, 0xc1, 0x72, 0x73, 0xdd, 0x62, 0x40, 0xa9, 0x62, 0x88, 0x99, 0xca,
|
||||
/* (2^333)P */ 0x47, 0x7b, 0xea, 0xda, 0x46, 0x2f, 0x45, 0xc6, 0xe3, 0xb4, 0x4d, 0x8d, 0xac, 0x0b, 0x54, 0x22, 0x06, 0x31, 0x16, 0x66, 0x3e, 0xe4, 0x38, 0x12, 0xcd, 0xf3, 0xe7, 0x99, 0x37, 0xd9, 0x62, 0x24, 0x4b, 0x05, 0xf2, 0x58, 0xe6, 0x29, 0x4b, 0x0d, 0xf6, 0xc1, 0xba, 0xa0, 0x1e, 0x0f, 0xcb, 0x1f, 0xc6, 0x2b, 0x19, 0xfc, 0x82, 0x01, 0xd0, 0x86,
|
||||
/* (2^334)P */ 0xa2, 0xae, 0x77, 0x20, 0xfb, 0xa8, 0x18, 0xb4, 0x61, 0xef, 0xe8, 0x52, 0x79, 0xbb, 0x86, 0x90, 0x5d, 0x2e, 0x76, 0xed, 0x66, 0x60, 0x5d, 0x00, 0xb5, 0xa4, 0x00, 0x40, 0x89, 0xec, 0xd1, 0xd2, 0x0d, 0x26, 0xb9, 0x30, 0xb2, 0xd2, 0xb8, 0xe8, 0x0e, 0x56, 0xf9, 0x67, 0x94, 0x2e, 0x62, 0xe1, 0x79, 0x48, 0x2b, 0xa9, 0xfa, 0xea, 0xdb, 0x28,
|
||||
/* (2^335)P */ 0x35, 0xf1, 0xb0, 0x43, 0xbd, 0x27, 0xef, 0x18, 0x44, 0xa2, 0x04, 0xb4, 0x69, 0xa1, 0x97, 0x1f, 0x8c, 0x04, 0x82, 0x9b, 0x00, 0x6d, 0xf8, 0xbf, 0x7d, 0xc1, 0x5b, 0xab, 0xe8, 0xb2, 0x34, 0xbd, 0xaf, 0x7f, 0xb2, 0x0d, 0xf3, 0xed, 0xfc, 0x5b, 0x50, 0xee, 0xe7, 0x4a, 0x20, 0xd9, 0xf5, 0xc6, 0x9a, 0x97, 0x6d, 0x07, 0x2f, 0xb9, 0x31, 0x02,
|
||||
/* (2^336)P */ 0xf9, 0x54, 0x4a, 0xc5, 0x61, 0x7e, 0x1d, 0xa6, 0x0e, 0x1a, 0xa8, 0xd3, 0x8c, 0x36, 0x7d, 0xf1, 0x06, 0xb1, 0xac, 0x93, 0xcd, 0xe9, 0x8f, 0x61, 0x6c, 0x5d, 0x03, 0x23, 0xdf, 0x85, 0x53, 0x39, 0x63, 0x5e, 0xeb, 0xf3, 0xd3, 0xd3, 0x75, 0x97, 0x9b, 0x62, 0x9b, 0x01, 0xb3, 0x19, 0xd8, 0x2b, 0x36, 0xf2, 0x2c, 0x2c, 0x6f, 0x36, 0xc6, 0x3c,
|
||||
/* (2^337)P */ 0x05, 0x74, 0x43, 0x10, 0xb6, 0xb0, 0xf8, 0xbf, 0x02, 0x46, 0x9a, 0xee, 0xc1, 0xaf, 0xc1, 0xe5, 0x5a, 0x2e, 0xbb, 0xe1, 0xdc, 0xc6, 0xce, 0x51, 0x29, 0x50, 0xbf, 0x1b, 0xde, 0xff, 0xba, 0x4d, 0x8d, 0x8b, 0x7e, 0xe7, 0xbd, 0x5b, 0x8f, 0xbe, 0xe3, 0x75, 0x71, 0xff, 0x37, 0x05, 0x5a, 0x10, 0xeb, 0x54, 0x7e, 0x44, 0x72, 0x2c, 0xd4, 0xfc,
|
||||
/* (2^338)P */ 0x03, 0x12, 0x1c, 0xb2, 0x08, 0x90, 0xa1, 0x2d, 0x50, 0xa0, 0xad, 0x7f, 0x8d, 0xa6, 0x97, 0xc1, 0xbd, 0xdc, 0xc3, 0xa7, 0xad, 0x31, 0xdf, 0xb8, 0x03, 0x84, 0xc3, 0xb9, 0x29, 0x3d, 0x92, 0x2e, 0xc3, 0x90, 0x07, 0xe8, 0xa7, 0xc7, 0xbc, 0x61, 0xe9, 0x3e, 0xa0, 0x35, 0xda, 0x1d, 0xab, 0x48, 0xfe, 0x50, 0xc9, 0x25, 0x59, 0x23, 0x69, 0x3f,
|
||||
/* (2^339)P */ 0x8e, 0x91, 0xab, 0x6b, 0x91, 0x4f, 0x89, 0x76, 0x67, 0xad, 0xb2, 0x65, 0x9d, 0xad, 0x02, 0x36, 0xdc, 0xac, 0x96, 0x93, 0x97, 0x21, 0x14, 0xd0, 0xe8, 0x11, 0x60, 0x1e, 0xeb, 0x96, 0x06, 0xf2, 0x53, 0xf2, 0x6d, 0xb7, 0x93, 0x6f, 0x26, 0x91, 0x23, 0xe3, 0x34, 0x04, 0x92, 0x91, 0x37, 0x08, 0x50, 0xd6, 0x28, 0x09, 0x27, 0xa1, 0x0c, 0x00,
|
||||
/* (2^340)P */ 0x1f, 0xbb, 0x21, 0x26, 0x33, 0xcb, 0xa4, 0xd1, 0xee, 0x85, 0xf9, 0xd9, 0x3c, 0x90, 0xc3, 0xd1, 0x26, 0xa2, 0x25, 0x93, 0x43, 0x61, 0xed, 0x91, 0x6e, 0x54, 0x03, 0x2e, 0x42, 0x9d, 0xf7, 0xa6, 0x02, 0x0f, 0x2f, 0x9c, 0x7a, 0x8d, 0x12, 0xc2, 0x18, 0xfc, 0x41, 0xff, 0x85, 0x26, 0x1a, 0x44, 0x55, 0x0b, 0x89, 0xab, 0x6f, 0x62, 0x33, 0x8c,
|
||||
/* (2^341)P */ 0xe0, 0x3c, 0x5d, 0x70, 0x64, 0x87, 0x81, 0x35, 0xf2, 0x37, 0xa6, 0x24, 0x3e, 0xe0, 0x62, 0xd5, 0x71, 0xe7, 0x93, 0xfb, 0xac, 0xc3, 0xe7, 0xc7, 0x04, 0xe2, 0x70, 0xd3, 0x29, 0x5b, 0x21, 0xbf, 0xf4, 0x26, 0x5d, 0xf3, 0x95, 0xb4, 0x2a, 0x6a, 0x07, 0x55, 0xa6, 0x4b, 0x3b, 0x15, 0xf2, 0x25, 0x8a, 0x95, 0x3f, 0x63, 0x2f, 0x7a, 0x23, 0x96,
|
||||
/* (2^342)P */ 0x0d, 0x3d, 0xd9, 0x13, 0xa7, 0xb3, 0x5e, 0x67, 0xf7, 0x02, 0x23, 0xee, 0x84, 0xff, 0x99, 0xda, 0xb9, 0x53, 0xf8, 0xf0, 0x0e, 0x39, 0x2f, 0x3c, 0x64, 0x34, 0xe3, 0x09, 0xfd, 0x2b, 0x33, 0xc7, 0xfe, 0x62, 0x2b, 0x84, 0xdf, 0x2b, 0xd2, 0x7c, 0x26, 0x01, 0x70, 0x66, 0x5b, 0x85, 0xc2, 0xbe, 0x88, 0x37, 0xf1, 0x30, 0xac, 0xb8, 0x76, 0xa3,
|
||||
/* (2^343)P */ 0x6e, 0x01, 0xf0, 0x55, 0x35, 0xe4, 0xbd, 0x43, 0x62, 0x9d, 0xd6, 0x11, 0xef, 0x6f, 0xb8, 0x8c, 0xaa, 0x98, 0x87, 0xc6, 0x6d, 0xc4, 0xcc, 0x74, 0x92, 0x53, 0x4a, 0xdf, 0xe4, 0x08, 0x89, 0x17, 0xd0, 0x0f, 0xf4, 0x00, 0x60, 0x78, 0x08, 0x44, 0xb5, 0xda, 0x18, 0xed, 0x98, 0xc8, 0x61, 0x3d, 0x39, 0xdb, 0xcf, 0x1d, 0x49, 0x40, 0x65, 0x75,
|
||||
/* (2^344)P */ 0x8e, 0x10, 0xae, 0x5f, 0x06, 0xd2, 0x95, 0xfd, 0x20, 0x16, 0x49, 0x5b, 0x57, 0xbe, 0x22, 0x8b, 0x43, 0xfb, 0xe6, 0xcc, 0x26, 0xa5, 0x5d, 0xd3, 0x68, 0xc5, 0xf9, 0x5a, 0x86, 0x24, 0x87, 0x27, 0x05, 0xfd, 0xe2, 0xff, 0xb3, 0xa3, 0x7b, 0x37, 0x59, 0xc5, 0x4e, 0x14, 0x94, 0xf9, 0x3b, 0xcb, 0x7c, 0xed, 0xca, 0x1d, 0xb2, 0xac, 0x05, 0x4a,
|
||||
/* (2^345)P */ 0xf4, 0xd1, 0x81, 0xeb, 0x89, 0xbf, 0xfe, 0x1e, 0x41, 0x92, 0x29, 0xee, 0xe1, 0x43, 0xf5, 0x86, 0x1d, 0x2f, 0xbb, 0x1e, 0x84, 0x5d, 0x7b, 0x8d, 0xd5, 0xda, 0xee, 0x1e, 0x8a, 0xd0, 0x27, 0xf2, 0x60, 0x51, 0x59, 0x82, 0xf4, 0x84, 0x2b, 0x5b, 0x14, 0x2d, 0x81, 0x82, 0x3e, 0x2b, 0xb4, 0x6d, 0x51, 0x4f, 0xc5, 0xcb, 0xbf, 0x74, 0xe3, 0xb4,
|
||||
/* (2^346)P */ 0x19, 0x2f, 0x22, 0xb3, 0x04, 0x5f, 0x81, 0xca, 0x05, 0x60, 0xb9, 0xaa, 0xee, 0x0e, 0x2f, 0x48, 0x38, 0xf9, 0x91, 0xb4, 0x66, 0xe4, 0x57, 0x28, 0x54, 0x10, 0xe9, 0x61, 0x9d, 0xd4, 0x90, 0x75, 0xb1, 0x39, 0x23, 0xb6, 0xfc, 0x82, 0xe0, 0xfa, 0xbb, 0x5c, 0x6e, 0xc3, 0x44, 0x13, 0x00, 0x83, 0x55, 0x9e, 0x8e, 0x10, 0x61, 0x81, 0x91, 0x04,
|
||||
/* (2^347)P */ 0x5f, 0x2a, 0xd7, 0x81, 0xd9, 0x9c, 0xbb, 0x79, 0xbc, 0x62, 0x56, 0x98, 0x03, 0x5a, 0x18, 0x85, 0x2a, 0x9c, 0xd0, 0xfb, 0xd2, 0xb1, 0xaf, 0xef, 0x0d, 0x24, 0xc5, 0xfa, 0x39, 0xbb, 0x6b, 0xed, 0xa4, 0xdf, 0xe4, 0x87, 0xcd, 0x41, 0xd3, 0x72, 0x32, 0xc6, 0x28, 0x21, 0xb1, 0xba, 0x8b, 0xa3, 0x91, 0x79, 0x76, 0x22, 0x25, 0x10, 0x61, 0xd1,
|
||||
/* (2^348)P */ 0x73, 0xb5, 0x32, 0x97, 0xdd, 0xeb, 0xdd, 0x22, 0x22, 0xf1, 0x33, 0x3c, 0x77, 0x56, 0x7d, 0x6b, 0x48, 0x2b, 0x05, 0x81, 0x03, 0x03, 0x91, 0x9a, 0xe3, 0x5e, 0xd4, 0xee, 0x3f, 0xf8, 0xbb, 0x50, 0x21, 0x32, 0x4c, 0x4a, 0x58, 0x49, 0xde, 0x0c, 0xde, 0x30, 0x82, 0x3d, 0x92, 0xf0, 0x6c, 0xcc, 0x32, 0x3e, 0xd2, 0x78, 0x8a, 0x6e, 0x2c, 0xd0,
|
||||
/* (2^349)P */ 0xf0, 0xf7, 0xa1, 0x0b, 0xc1, 0x74, 0x85, 0xa8, 0xe9, 0xdd, 0x48, 0xa1, 0xc0, 0x16, 0xd8, 0x2b, 0x61, 0x08, 0xc2, 0x2b, 0x30, 0x26, 0x79, 0xce, 0x9e, 0xfd, 0x39, 0xd7, 0x81, 0xa4, 0x63, 0x8c, 0xd5, 0x74, 0xa0, 0x88, 0xfa, 0x03, 0x30, 0xe9, 0x7f, 0x2b, 0xc6, 0x02, 0xc9, 0x5e, 0xe4, 0xd5, 0x4d, 0x92, 0xd0, 0xf6, 0xf2, 0x5b, 0x79, 0x08,
|
||||
/* (2^350)P */ 0x34, 0x89, 0x81, 0x43, 0xd1, 0x94, 0x2c, 0x10, 0x54, 0x9b, 0xa0, 0xe5, 0x44, 0xe8, 0xc2, 0x2f, 0x3e, 0x0e, 0x74, 0xae, 0xba, 0xe2, 0xac, 0x85, 0x6b, 0xd3, 0x5c, 0x97, 0xf7, 0x90, 0xf1, 0x12, 0xc0, 0x03, 0xc8, 0x1f, 0x37, 0x72, 0x8c, 0x9b, 0x9c, 0x17, 0x96, 0x9d, 0xc7, 0xbf, 0xa3, 0x3f, 0x44, 0x3d, 0x87, 0x81, 0xbd, 0x81, 0xa6, 0x5f,
|
||||
/* (2^351)P */ 0xe4, 0xff, 0x78, 0x62, 0x82, 0x5b, 0x76, 0x58, 0xf5, 0x5b, 0xa6, 0xc4, 0x53, 0x11, 0x3b, 0x7b, 0xaa, 0x67, 0xf8, 0xea, 0x3b, 0x5d, 0x9a, 0x2e, 0x04, 0xeb, 0x4a, 0x24, 0xfb, 0x56, 0xf0, 0xa8, 0xd4, 0x14, 0xed, 0x0f, 0xfd, 0xc5, 0x26, 0x17, 0x2a, 0xf0, 0xb9, 0x13, 0x8c, 0xbd, 0x65, 0x14, 0x24, 0x95, 0x27, 0x12, 0x63, 0x2a, 0x09, 0x18,
|
||||
/* (2^352)P */ 0xe1, 0x5c, 0xe7, 0xe0, 0x00, 0x6a, 0x96, 0xf2, 0x49, 0x6a, 0x39, 0xa5, 0xe0, 0x17, 0x79, 0x4a, 0x63, 0x07, 0x62, 0x09, 0x61, 0x1b, 0x6e, 0xa9, 0xb5, 0x62, 0xb7, 0xde, 0xdf, 0x80, 0x4c, 0x5a, 0x99, 0x73, 0x59, 0x9d, 0xfb, 0xb1, 0x5e, 0xbe, 0xb8, 0xb7, 0x63, 0x93, 0xe8, 0xad, 0x5e, 0x1f, 0xae, 0x59, 0x1c, 0xcd, 0xb4, 0xc2, 0xb3, 0x8a,
|
||||
/* (2^353)P */ 0x78, 0x53, 0xa1, 0x4c, 0x70, 0x9c, 0x63, 0x7e, 0xb3, 0x12, 0x40, 0x5f, 0xbb, 0x23, 0xa7, 0xf7, 0x77, 0x96, 0x5b, 0x4d, 0x91, 0x10, 0x52, 0x85, 0x9e, 0xa5, 0x38, 0x0b, 0xfd, 0x25, 0x01, 0x4b, 0xfa, 0x4d, 0xd3, 0x3f, 0x78, 0x74, 0x42, 0xff, 0x62, 0x2d, 0x27, 0xdc, 0x9d, 0xd1, 0x29, 0x76, 0x2e, 0x78, 0xb3, 0x35, 0xfa, 0x15, 0xd5, 0x38,
|
||||
/* (2^354)P */ 0x8b, 0xc7, 0x43, 0xce, 0xf0, 0x5e, 0xf1, 0x0d, 0x02, 0x38, 0xe8, 0x82, 0xc9, 0x25, 0xad, 0x2d, 0x27, 0xa4, 0x54, 0x18, 0xb2, 0x30, 0x73, 0xa4, 0x41, 0x08, 0xe4, 0x86, 0xe6, 0x8c, 0xe9, 0x2a, 0x34, 0xb3, 0xd6, 0x61, 0x8f, 0x66, 0x26, 0x08, 0xb6, 0x06, 0x33, 0xaa, 0x12, 0xac, 0x72, 0xec, 0x2e, 0x52, 0xa3, 0x25, 0x3e, 0xd7, 0x62, 0xe8,
|
||||
/* (2^355)P */ 0xc4, 0xbb, 0x89, 0xc8, 0x40, 0xcc, 0x84, 0xec, 0x4a, 0xd9, 0xc4, 0x55, 0x78, 0x00, 0xcf, 0xd8, 0xe9, 0x24, 0x59, 0xdc, 0x5e, 0xf0, 0x66, 0xa1, 0x83, 0xae, 0x97, 0x18, 0xc5, 0x54, 0x27, 0xa2, 0x21, 0x52, 0x03, 0x31, 0x5b, 0x11, 0x67, 0xf6, 0x12, 0x00, 0x87, 0x2f, 0xff, 0x59, 0x70, 0x8f, 0x6d, 0x71, 0xab, 0xab, 0x24, 0xb8, 0xba, 0x35,
|
||||
/* (2^356)P */ 0x69, 0x43, 0xa7, 0x14, 0x06, 0x96, 0xe9, 0xc2, 0xe3, 0x2b, 0x45, 0x22, 0xc0, 0xd0, 0x2f, 0x34, 0xd1, 0x01, 0x99, 0xfc, 0x99, 0x38, 0xa1, 0x25, 0x2e, 0x59, 0x6c, 0x27, 0xc9, 0xeb, 0x7b, 0xdc, 0x4e, 0x26, 0x68, 0xba, 0xfa, 0xec, 0x02, 0x05, 0x64, 0x80, 0x30, 0x20, 0x5c, 0x26, 0x7f, 0xaf, 0x95, 0x17, 0x3d, 0x5c, 0x9e, 0x96, 0x96, 0xaf,
|
||||
/* (2^357)P */ 0xa6, 0xba, 0x21, 0x29, 0x32, 0xe2, 0x98, 0xde, 0x9b, 0x6d, 0x0b, 0x44, 0x91, 0xa8, 0x3e, 0xd4, 0xb8, 0x04, 0x6c, 0xf6, 0x04, 0x39, 0xbd, 0x52, 0x05, 0x15, 0x27, 0x78, 0x8e, 0x55, 0xac, 0x79, 0xc5, 0xe6, 0x00, 0x7f, 0x90, 0xa2, 0xdd, 0x07, 0x13, 0xe0, 0x24, 0x70, 0x5c, 0x0f, 0x4d, 0xa9, 0xf9, 0xae, 0xcb, 0x34, 0x10, 0x9d, 0x89, 0x9d,
|
||||
/* (2^358)P */ 0x12, 0xe0, 0xb3, 0x9f, 0xc4, 0x96, 0x1d, 0xcf, 0xed, 0x99, 0x64, 0x28, 0x8d, 0xc7, 0x31, 0x82, 0xee, 0x5e, 0x75, 0x48, 0xff, 0x3a, 0xf2, 0x09, 0x34, 0x03, 0x93, 0x52, 0x19, 0xb2, 0xc5, 0x81, 0x93, 0x45, 0x5e, 0x59, 0x21, 0x2b, 0xec, 0x89, 0xba, 0x36, 0x6e, 0xf9, 0x82, 0x75, 0x7e, 0x82, 0x3f, 0xaa, 0xe2, 0xe3, 0x3b, 0x94, 0xfd, 0x98,
|
||||
/* (2^359)P */ 0x7c, 0xdb, 0x75, 0x31, 0x61, 0xfb, 0x15, 0x28, 0x94, 0xd7, 0xc3, 0x5a, 0xa9, 0xa1, 0x0a, 0x66, 0x0f, 0x2b, 0x13, 0x3e, 0x42, 0xb5, 0x28, 0x3a, 0xca, 0x83, 0xf3, 0x61, 0x22, 0xf4, 0x40, 0xc5, 0xdf, 0xe7, 0x31, 0x9f, 0x7e, 0x51, 0x75, 0x06, 0x9d, 0x51, 0xc8, 0xe7, 0x9f, 0xc3, 0x71, 0x4f, 0x3d, 0x5b, 0xfb, 0xe9, 0x8e, 0x08, 0x40, 0x8e,
|
||||
/* (2^360)P */ 0xf7, 0x31, 0xad, 0x50, 0x5d, 0x25, 0x93, 0x73, 0x68, 0xf6, 0x7c, 0x89, 0x5a, 0x3d, 0x9f, 0x9b, 0x05, 0x82, 0xe7, 0x70, 0x4b, 0x19, 0xaa, 0xcf, 0xff, 0xde, 0x50, 0x8f, 0x2f, 0x69, 0xd3, 0xf0, 0x99, 0x51, 0x6b, 0x9d, 0xb6, 0x56, 0x6f, 0xf8, 0x4c, 0x74, 0x8b, 0x4c, 0x91, 0xf9, 0xa9, 0xb1, 0x3e, 0x07, 0xdf, 0x0b, 0x27, 0x8a, 0xb1, 0xed,
|
||||
/* (2^361)P */ 0xfb, 0x67, 0xd9, 0x48, 0xd2, 0xe4, 0x44, 0x9b, 0x43, 0x15, 0x8a, 0xeb, 0x00, 0x53, 0xad, 0x25, 0xc7, 0x7e, 0x19, 0x30, 0x87, 0xb7, 0xd5, 0x5f, 0x04, 0xf8, 0xaa, 0xdd, 0x57, 0xae, 0x34, 0x75, 0xe2, 0x84, 0x4b, 0x54, 0x60, 0x37, 0x95, 0xe4, 0xd3, 0xec, 0xac, 0xef, 0x47, 0x31, 0xa3, 0xc8, 0x31, 0x22, 0xdb, 0x26, 0xe7, 0x6a, 0xb5, 0xad,
|
||||
/* (2^362)P */ 0x44, 0x09, 0x5c, 0x95, 0xe4, 0x72, 0x3c, 0x1a, 0xd1, 0xac, 0x42, 0x51, 0x99, 0x6f, 0xfa, 0x1f, 0xf2, 0x22, 0xbe, 0xff, 0x7b, 0x66, 0xf5, 0x6c, 0xb3, 0x66, 0xc7, 0x4d, 0x78, 0x31, 0x83, 0x80, 0xf5, 0x41, 0xe9, 0x7f, 0xbe, 0xf7, 0x23, 0x49, 0x6b, 0x84, 0x4e, 0x7e, 0x47, 0x07, 0x6e, 0x74, 0xdf, 0xe5, 0x9d, 0x9e, 0x56, 0x2a, 0xc0, 0xbc,
|
||||
/* (2^363)P */ 0xac, 0x10, 0x80, 0x8c, 0x7c, 0xfa, 0x83, 0xdf, 0xb3, 0xd0, 0xc4, 0xbe, 0xfb, 0x9f, 0xac, 0xc9, 0xc3, 0x40, 0x95, 0x0b, 0x09, 0x23, 0xda, 0x63, 0x67, 0xcf, 0xe7, 0x9f, 0x7d, 0x7b, 0x6b, 0xe2, 0xe6, 0x6d, 0xdb, 0x87, 0x9e, 0xa6, 0xff, 0x6d, 0xab, 0xbd, 0xfb, 0x54, 0x84, 0x68, 0xcf, 0x89, 0xf1, 0xd0, 0xe2, 0x85, 0x61, 0xdc, 0x22, 0xd1,
|
||||
/* (2^364)P */ 0xa8, 0x48, 0xfb, 0x8c, 0x6a, 0x63, 0x01, 0x72, 0x43, 0x43, 0xeb, 0x21, 0xa3, 0x00, 0x8a, 0xc0, 0x87, 0x51, 0x9e, 0x86, 0x75, 0x16, 0x79, 0xf9, 0x6b, 0x11, 0x80, 0x62, 0xc2, 0x9d, 0xb8, 0x8c, 0x30, 0x8e, 0x8d, 0x03, 0x52, 0x7e, 0x31, 0x59, 0x38, 0xf9, 0x25, 0xc7, 0x0f, 0xc7, 0xa8, 0x2b, 0x5c, 0x80, 0xfa, 0x90, 0xa2, 0x63, 0xca, 0xe7,
|
||||
/* (2^365)P */ 0xf1, 0x5d, 0xb5, 0xd9, 0x20, 0x10, 0x7d, 0x0f, 0xc5, 0x50, 0x46, 0x07, 0xff, 0x02, 0x75, 0x2b, 0x4a, 0xf3, 0x39, 0x91, 0x72, 0xb7, 0xd5, 0xcc, 0x38, 0xb8, 0xe7, 0x36, 0x26, 0x5e, 0x11, 0x97, 0x25, 0xfb, 0x49, 0x68, 0xdc, 0xb4, 0x46, 0x87, 0x5c, 0xc2, 0x7f, 0xaa, 0x7d, 0x36, 0x23, 0xa6, 0xc6, 0x53, 0xec, 0xbc, 0x57, 0x47, 0xc1, 0x2b,
|
||||
/* (2^366)P */ 0x25, 0x5d, 0x7d, 0x95, 0xda, 0x0b, 0x8f, 0x78, 0x1e, 0x19, 0x09, 0xfa, 0x67, 0xe0, 0xa0, 0x17, 0x24, 0x76, 0x6c, 0x30, 0x1f, 0x62, 0x3d, 0xbe, 0x45, 0x70, 0xcc, 0xb6, 0x1e, 0x68, 0x06, 0x25, 0x68, 0x16, 0x1a, 0x33, 0x3f, 0x90, 0xc7, 0x78, 0x2d, 0x98, 0x3c, 0x2f, 0xb9, 0x2d, 0x94, 0x0b, 0xfb, 0x49, 0x56, 0x30, 0xd7, 0xc1, 0xe6, 0x48,
|
||||
/* (2^367)P */ 0x7a, 0xd1, 0xe0, 0x8e, 0x67, 0xfc, 0x0b, 0x50, 0x1f, 0x84, 0x98, 0xfa, 0xaf, 0xae, 0x2e, 0x31, 0x27, 0xcf, 0x3f, 0xf2, 0x6e, 0x8d, 0x81, 0x8f, 0xd2, 0x5f, 0xde, 0xd3, 0x5e, 0xe9, 0xe7, 0x13, 0x48, 0x83, 0x5a, 0x4e, 0x84, 0xd1, 0x58, 0xcf, 0x6b, 0x84, 0xdf, 0x13, 0x1d, 0x91, 0x85, 0xe8, 0xcb, 0x29, 0x79, 0xd2, 0xca, 0xac, 0x6a, 0x93,
|
||||
/* (2^368)P */ 0x53, 0x82, 0xce, 0x61, 0x96, 0x88, 0x6f, 0xe1, 0x4a, 0x4c, 0x1e, 0x30, 0x73, 0xe8, 0x74, 0xde, 0x40, 0x2b, 0xe0, 0xc4, 0xb5, 0xd8, 0x7c, 0x15, 0xe7, 0xe1, 0xb1, 0xe0, 0xd6, 0x88, 0xb1, 0x6a, 0x57, 0x19, 0x6a, 0x22, 0x66, 0x57, 0xf6, 0x8d, 0xfd, 0xc0, 0xf2, 0xa3, 0x03, 0x56, 0xfb, 0x2e, 0x75, 0x5e, 0xc7, 0x8e, 0x22, 0x96, 0x5c, 0x06,
|
||||
/* (2^369)P */ 0x98, 0x7e, 0xbf, 0x3e, 0xbf, 0x24, 0x9d, 0x15, 0xd3, 0xf6, 0xd3, 0xd2, 0xf0, 0x11, 0xf2, 0xdb, 0x36, 0x23, 0x38, 0xf7, 0x1d, 0x71, 0x20, 0xd2, 0x54, 0x7f, 0x1e, 0x24, 0x8f, 0xe2, 0xaa, 0xf7, 0x3f, 0x6b, 0x41, 0x4e, 0xdc, 0x0e, 0xec, 0xe8, 0x35, 0x0a, 0x08, 0x6d, 0x89, 0x5b, 0x32, 0x91, 0x01, 0xb6, 0xe0, 0x2c, 0xc6, 0xa1, 0xbe, 0xb4,
|
||||
/* (2^370)P */ 0x29, 0xf2, 0x1e, 0x1c, 0xdc, 0x68, 0x8a, 0x43, 0x87, 0x2c, 0x48, 0xb3, 0x9e, 0xed, 0xd2, 0x82, 0x46, 0xac, 0x2f, 0xef, 0x93, 0x34, 0x37, 0xca, 0x64, 0x8d, 0xc9, 0x06, 0x90, 0xbb, 0x78, 0x0a, 0x3c, 0x4c, 0xcf, 0x35, 0x7a, 0x0f, 0xf7, 0xa7, 0xf4, 0x2f, 0x45, 0x69, 0x3f, 0xa9, 0x5d, 0xce, 0x7b, 0x8a, 0x84, 0xc3, 0xae, 0xf4, 0xda, 0xd5,
|
||||
/* (2^371)P */ 0xca, 0xba, 0x95, 0x43, 0x05, 0x7b, 0x06, 0xd9, 0x5c, 0x0a, 0x18, 0x5f, 0x6a, 0x6a, 0xce, 0xc0, 0x3d, 0x95, 0x51, 0x0e, 0x1a, 0xbe, 0x85, 0x7a, 0xf2, 0x69, 0xec, 0xc0, 0x8c, 0xca, 0xa3, 0x32, 0x0a, 0x76, 0x50, 0xc6, 0x76, 0x61, 0x00, 0x89, 0xbf, 0x6e, 0x0f, 0x48, 0x90, 0x31, 0x93, 0xec, 0x34, 0x70, 0xf0, 0xc3, 0x8d, 0xf0, 0x0f, 0xb5,
|
||||
/* (2^372)P */ 0xbe, 0x23, 0xe2, 0x18, 0x99, 0xf1, 0xed, 0x8a, 0xf6, 0xc9, 0xac, 0xb8, 0x1e, 0x9a, 0x3c, 0x15, 0xae, 0xd7, 0x6d, 0xb3, 0x04, 0xee, 0x5b, 0x0d, 0x1e, 0x79, 0xb7, 0xf9, 0xf9, 0x8d, 0xad, 0xf9, 0x8f, 0x5a, 0x6a, 0x7b, 0xd7, 0x9b, 0xca, 0x62, 0xfe, 0x9c, 0xc0, 0x6f, 0x6d, 0x9d, 0x76, 0xa3, 0x69, 0xb9, 0x4c, 0xa1, 0xc4, 0x0c, 0x76, 0xaa,
|
||||
/* (2^373)P */ 0x1c, 0x06, 0xfe, 0x3f, 0x45, 0x70, 0xcd, 0x97, 0xa9, 0xa2, 0xb1, 0xd3, 0xf2, 0xa5, 0x0c, 0x49, 0x2c, 0x75, 0x73, 0x1f, 0xcf, 0x00, 0xaf, 0xd5, 0x2e, 0xde, 0x0d, 0x8f, 0x8f, 0x7c, 0xc4, 0x58, 0xce, 0xd4, 0xf6, 0x24, 0x19, 0x2e, 0xd8, 0xc5, 0x1d, 0x1a, 0x3f, 0xb8, 0x4f, 0xbc, 0x7d, 0xbd, 0x68, 0xe3, 0x81, 0x98, 0x1b, 0xa8, 0xc9, 0xd9,
|
||||
/* (2^374)P */ 0x39, 0x95, 0x78, 0x24, 0x6c, 0x38, 0xe4, 0xe7, 0xd0, 0x8d, 0xb9, 0x38, 0x71, 0x5e, 0xc1, 0x62, 0x80, 0xcc, 0xcb, 0x8c, 0x97, 0xca, 0xf8, 0xb9, 0xd9, 0x9c, 0xce, 0x72, 0x7b, 0x70, 0xee, 0x5f, 0xea, 0xa2, 0xdf, 0xa9, 0x14, 0x10, 0xf9, 0x6e, 0x59, 0x9f, 0x9c, 0xe0, 0x0c, 0xb2, 0x07, 0x97, 0xcd, 0xd2, 0x89, 0x16, 0xfd, 0x9c, 0xa8, 0xa5,
|
||||
/* (2^375)P */ 0x5a, 0x61, 0xf1, 0x59, 0x7c, 0x38, 0xda, 0xe2, 0x85, 0x99, 0x68, 0xe9, 0xc9, 0xf7, 0x32, 0x7e, 0xc4, 0xca, 0xb7, 0x11, 0x08, 0x69, 0x2b, 0x66, 0x02, 0xf7, 0x2e, 0x18, 0xc3, 0x8e, 0xe1, 0xf9, 0xc5, 0x19, 0x9a, 0x0a, 0x9c, 0x07, 0xba, 0xc7, 0x9c, 0x03, 0x34, 0x89, 0x99, 0x67, 0x0b, 0x16, 0x4b, 0x07, 0x36, 0x16, 0x36, 0x2c, 0xe2, 0xa1,
|
||||
/* (2^376)P */ 0x70, 0x10, 0x91, 0x27, 0xa8, 0x24, 0x8e, 0x29, 0x04, 0x6f, 0x79, 0x1f, 0xd3, 0xa5, 0x68, 0xd3, 0x0b, 0x7d, 0x56, 0x4d, 0x14, 0x57, 0x7b, 0x2e, 0x00, 0x9f, 0x9a, 0xfd, 0x6c, 0x63, 0x18, 0x81, 0xdb, 0x9d, 0xb7, 0xd7, 0xa4, 0x1e, 0xe8, 0x40, 0xf1, 0x4c, 0xa3, 0x01, 0xd5, 0x4b, 0x75, 0xea, 0xdd, 0x97, 0xfd, 0x5b, 0xb2, 0x66, 0x6a, 0x24,
|
||||
/* (2^377)P */ 0x72, 0x11, 0xfe, 0x73, 0x1b, 0xd3, 0xea, 0x7f, 0x93, 0x15, 0x15, 0x05, 0xfe, 0x40, 0xe8, 0x28, 0xd8, 0x50, 0x47, 0x66, 0xfa, 0xb7, 0xb5, 0x04, 0xba, 0x35, 0x1e, 0x32, 0x9f, 0x5f, 0x32, 0xba, 0x3d, 0xd1, 0xed, 0x9a, 0x76, 0xca, 0xa3, 0x3e, 0x77, 0xd8, 0xd8, 0x7c, 0x5f, 0x68, 0x42, 0xb5, 0x86, 0x7f, 0x3b, 0xc9, 0xc1, 0x89, 0x64, 0xda,
|
||||
/* (2^378)P */ 0xd5, 0xd4, 0x17, 0x31, 0xfc, 0x6a, 0xfd, 0xb8, 0xe8, 0xe5, 0x3e, 0x39, 0x06, 0xe4, 0xd1, 0x90, 0x2a, 0xca, 0xf6, 0x54, 0x6c, 0x1b, 0x2f, 0x49, 0x97, 0xb1, 0x2a, 0x82, 0x43, 0x3d, 0x1f, 0x8b, 0xe2, 0x47, 0xc5, 0x24, 0xa8, 0xd5, 0x53, 0x29, 0x7d, 0xc6, 0x87, 0xa6, 0x25, 0x3a, 0x64, 0xdd, 0x71, 0x08, 0x9e, 0xcd, 0xe9, 0x45, 0xc7, 0xba,
|
||||
/* (2^379)P */ 0x37, 0x72, 0x6d, 0x13, 0x7a, 0x8d, 0x04, 0x31, 0xe6, 0xe3, 0x9e, 0x36, 0x71, 0x3e, 0xc0, 0x1e, 0xe3, 0x71, 0xd3, 0x49, 0x4e, 0x4a, 0x36, 0x42, 0x68, 0x68, 0x61, 0xc7, 0x3c, 0xdb, 0x81, 0x49, 0xf7, 0x91, 0x4d, 0xea, 0x4c, 0x4f, 0x98, 0xc6, 0x7e, 0x60, 0x84, 0x4b, 0x6a, 0x37, 0xbb, 0x52, 0xf7, 0xce, 0x02, 0xe4, 0xad, 0xd1, 0x3c, 0xa7,
|
||||
/* (2^380)P */ 0x51, 0x06, 0x2d, 0xf8, 0x08, 0xe8, 0xf1, 0x0c, 0xe5, 0xa9, 0xac, 0x29, 0x73, 0x3b, 0xed, 0x98, 0x5f, 0x55, 0x08, 0x38, 0x51, 0x44, 0x36, 0x5d, 0xea, 0xc3, 0xb8, 0x0e, 0xa0, 0x4f, 0xd2, 0x79, 0xe9, 0x98, 0xc3, 0xf5, 0x00, 0xb9, 0x26, 0x27, 0x42, 0xa8, 0x07, 0xc1, 0x12, 0x31, 0xc1, 0xc3, 0x3c, 0x3b, 0x7a, 0x72, 0x97, 0xc2, 0x70, 0x3a,
|
||||
/* (2^381)P */ 0xf4, 0xb2, 0xba, 0x32, 0xbc, 0xa9, 0x2f, 0x87, 0xc7, 0x3c, 0x45, 0xcd, 0xae, 0xe2, 0x13, 0x6d, 0x3a, 0xf2, 0xf5, 0x66, 0x97, 0x29, 0xaf, 0x53, 0x9f, 0xda, 0xea, 0x14, 0xdf, 0x04, 0x98, 0x19, 0x95, 0x9e, 0x2a, 0x00, 0x5c, 0x9d, 0x1d, 0xf0, 0x39, 0x23, 0xff, 0xfc, 0xca, 0x36, 0xb7, 0xde, 0xdf, 0x37, 0x78, 0x52, 0x21, 0xfa, 0x19, 0x10,
|
||||
/* (2^382)P */ 0x50, 0x20, 0x73, 0x74, 0x62, 0x21, 0xf2, 0xf7, 0x9b, 0x66, 0x85, 0x34, 0x74, 0xd4, 0x9d, 0x60, 0xd7, 0xbc, 0xc8, 0x46, 0x3b, 0xb8, 0x80, 0x42, 0x15, 0x0a, 0x6c, 0x35, 0x1a, 0x69, 0xf0, 0x1d, 0x4b, 0x29, 0x54, 0x5a, 0x9a, 0x48, 0xec, 0x9f, 0x37, 0x74, 0x91, 0xd0, 0xd1, 0x9e, 0x00, 0xc2, 0x76, 0x56, 0xd6, 0xa0, 0x15, 0x14, 0x83, 0x59,
|
||||
/* (2^383)P */ 0xc2, 0xf8, 0x22, 0x20, 0x23, 0x07, 0xbd, 0x1d, 0x6f, 0x1e, 0x8c, 0x56, 0x06, 0x6a, 0x4b, 0x9f, 0xe2, 0xa9, 0x92, 0x46, 0x4b, 0x46, 0x59, 0xd7, 0xe1, 0xda, 0x14, 0x98, 0x07, 0x65, 0x7e, 0x28, 0x20, 0xf2, 0x9d, 0x4f, 0x36, 0x5c, 0x92, 0xe0, 0x9d, 0xfe, 0x3e, 0xda, 0xe4, 0x47, 0x19, 0x3c, 0x00, 0x7f, 0x22, 0xf2, 0x9e, 0x51, 0xae, 0x4d,
|
||||
/* (2^384)P */ 0xbe, 0x8c, 0x1b, 0x10, 0xb6, 0xad, 0xcc, 0xcc, 0xd8, 0x5e, 0x21, 0xa6, 0xfb, 0xf1, 0xf6, 0xbd, 0x0a, 0x24, 0x67, 0xb4, 0x57, 0x7a, 0xbc, 0xe8, 0xe9, 0xff, 0xee, 0x0a, 0x1f, 0xee, 0xbd, 0xc8, 0x44, 0xed, 0x2b, 0xbb, 0x55, 0x1f, 0xdd, 0x7c, 0xb3, 0xeb, 0x3f, 0x63, 0xa1, 0x28, 0x91, 0x21, 0xab, 0x71, 0xc6, 0x4c, 0xd0, 0xe9, 0xb0, 0x21,
|
||||
/* (2^385)P */ 0xad, 0xc9, 0x77, 0x2b, 0xee, 0x89, 0xa4, 0x7b, 0xfd, 0xf9, 0xf6, 0x14, 0xe4, 0xed, 0x1a, 0x16, 0x9b, 0x78, 0x41, 0x43, 0xa8, 0x83, 0x72, 0x06, 0x2e, 0x7c, 0xdf, 0xeb, 0x7e, 0xdd, 0xd7, 0x8b, 0xea, 0x9a, 0x2b, 0x03, 0xba, 0x57, 0xf3, 0xf1, 0xd9, 0xe5, 0x09, 0xc5, 0x98, 0x61, 0x1c, 0x51, 0x6d, 0x5d, 0x6e, 0xfb, 0x5e, 0x95, 0x9f, 0xb5,
|
||||
/* (2^386)P */ 0x23, 0xe2, 0x1e, 0x95, 0xa3, 0x5e, 0x42, 0x10, 0xc7, 0xc3, 0x70, 0xbf, 0x4b, 0x6b, 0x83, 0x36, 0x93, 0xb7, 0x68, 0x47, 0x88, 0x3a, 0x10, 0x88, 0x48, 0x7f, 0x8c, 0xae, 0x54, 0x10, 0x02, 0xa4, 0x52, 0x8f, 0x8d, 0xf7, 0x26, 0x4f, 0x50, 0xc3, 0x6a, 0xe2, 0x4e, 0x3b, 0x4c, 0xb9, 0x8a, 0x14, 0x15, 0x6d, 0x21, 0x29, 0xb3, 0x6e, 0x4e, 0xd0,
|
||||
/* (2^387)P */ 0x4c, 0x8a, 0x18, 0x3f, 0xb7, 0x20, 0xfd, 0x3e, 0x54, 0xca, 0x68, 0x3c, 0xea, 0x6f, 0xf4, 0x6b, 0xa2, 0xbd, 0x01, 0xbd, 0xfe, 0x08, 0xa8, 0xd8, 0xc2, 0x20, 0x36, 0x05, 0xcd, 0xe9, 0xf3, 0x9e, 0xfa, 0x85, 0x66, 0x8f, 0x4b, 0x1d, 0x8c, 0x64, 0x4f, 0xb8, 0xc6, 0x0f, 0x5b, 0x57, 0xd8, 0x24, 0x19, 0x5a, 0x14, 0x4b, 0x92, 0xd3, 0x96, 0xbc,
|
||||
/* (2^388)P */ 0xa9, 0x3f, 0xc9, 0x6c, 0xca, 0x64, 0x1e, 0x6f, 0xdf, 0x65, 0x7f, 0x9a, 0x47, 0x6b, 0x8a, 0x60, 0x31, 0xa6, 0x06, 0xac, 0x69, 0x30, 0xe6, 0xea, 0x63, 0x42, 0x26, 0x5f, 0xdb, 0xd0, 0xf2, 0x8e, 0x34, 0x0a, 0x3a, 0xeb, 0xf3, 0x79, 0xc8, 0xb7, 0x60, 0x56, 0x5c, 0x37, 0x95, 0x71, 0xf8, 0x7f, 0x49, 0x3e, 0x9e, 0x01, 0x26, 0x1e, 0x80, 0x9f,
|
||||
/* (2^389)P */ 0xf8, 0x16, 0x9a, 0xaa, 0xb0, 0x28, 0xb5, 0x8e, 0xd0, 0x60, 0xe5, 0x26, 0xa9, 0x47, 0xc4, 0x5c, 0xa9, 0x39, 0xfe, 0x0a, 0xd8, 0x07, 0x2b, 0xb3, 0xce, 0xf1, 0xea, 0x1a, 0xf4, 0x7b, 0x98, 0x31, 0x3d, 0x13, 0x29, 0x80, 0xe8, 0x0d, 0xcf, 0x56, 0x39, 0x86, 0x50, 0x0c, 0xb3, 0x18, 0xf4, 0xc5, 0xca, 0xf2, 0x6f, 0xcd, 0x8d, 0xd5, 0x02, 0xb0,
|
||||
/* (2^390)P */ 0xbf, 0x39, 0x3f, 0xac, 0x6d, 0x1a, 0x6a, 0xe4, 0x42, 0x24, 0xd6, 0x41, 0x9d, 0xb9, 0x5b, 0x46, 0x73, 0x93, 0x76, 0xaa, 0xb7, 0x37, 0x36, 0xa6, 0x09, 0xe5, 0x04, 0x3b, 0x66, 0xc4, 0x29, 0x3e, 0x41, 0xc2, 0xcb, 0xe5, 0x17, 0xd7, 0x34, 0x67, 0x1d, 0x2c, 0x12, 0xec, 0x24, 0x7a, 0x40, 0xa2, 0x45, 0x41, 0xf0, 0x75, 0xed, 0x43, 0x30, 0xc9,
|
||||
/* (2^391)P */ 0x80, 0xf6, 0x47, 0x5b, 0xad, 0x54, 0x02, 0xbc, 0xdd, 0xa4, 0xb2, 0xd7, 0x42, 0x95, 0xf2, 0x0d, 0x1b, 0xef, 0x37, 0xa7, 0xb4, 0x34, 0x04, 0x08, 0x71, 0x1b, 0xd3, 0xdf, 0xa1, 0xf0, 0x2b, 0xfa, 0xc0, 0x1f, 0xf3, 0x44, 0xb5, 0xc6, 0x47, 0x3d, 0x65, 0x67, 0x45, 0x4d, 0x2f, 0xde, 0x52, 0x73, 0xfc, 0x30, 0x01, 0x6b, 0xc1, 0x03, 0xd8, 0xd7,
|
||||
/* (2^392)P */ 0x1c, 0x67, 0x55, 0x3e, 0x01, 0x17, 0x0f, 0x3e, 0xe5, 0x34, 0x58, 0xfc, 0xcb, 0x71, 0x24, 0x74, 0x5d, 0x36, 0x1e, 0x89, 0x2a, 0x63, 0xf8, 0xf8, 0x9f, 0x50, 0x9f, 0x32, 0x92, 0x29, 0xd8, 0x1a, 0xec, 0x76, 0x57, 0x6c, 0x67, 0x12, 0x6a, 0x6e, 0xef, 0x97, 0x1f, 0xc3, 0x77, 0x60, 0x3c, 0x22, 0xcb, 0xc7, 0x04, 0x1a, 0x89, 0x2d, 0x10, 0xa6,
|
||||
/* (2^393)P */ 0x12, 0xf5, 0xa9, 0x26, 0x16, 0xd9, 0x3c, 0x65, 0x5d, 0x83, 0xab, 0xd1, 0x70, 0x6b, 0x1c, 0xdb, 0xe7, 0x86, 0x0d, 0xfb, 0xe7, 0xf8, 0x2a, 0x58, 0x6e, 0x7a, 0x66, 0x13, 0x53, 0x3a, 0x6f, 0x8d, 0x43, 0x5f, 0x14, 0x23, 0x14, 0xff, 0x3d, 0x52, 0x7f, 0xee, 0xbd, 0x7a, 0x34, 0x8b, 0x35, 0x24, 0xc3, 0x7a, 0xdb, 0xcf, 0x22, 0x74, 0x9a, 0x8f,
|
||||
/* (2^394)P */ 0xdb, 0x20, 0xfc, 0xe5, 0x39, 0x4e, 0x7d, 0x78, 0xee, 0x0b, 0xbf, 0x1d, 0x80, 0xd4, 0x05, 0x4f, 0xb9, 0xd7, 0x4e, 0x94, 0x88, 0x9a, 0x50, 0x78, 0x1a, 0x70, 0x8c, 0xcc, 0x25, 0xb6, 0x61, 0x09, 0xdc, 0x7b, 0xea, 0x3f, 0x7f, 0xea, 0x2a, 0x0d, 0x47, 0x1c, 0x8e, 0xa6, 0x5b, 0xd2, 0xa3, 0x61, 0x93, 0x3c, 0x68, 0x9f, 0x8b, 0xea, 0xb0, 0xcb,
|
||||
/* (2^395)P */ 0xff, 0x54, 0x02, 0x19, 0xae, 0x8b, 0x4c, 0x2c, 0x3a, 0xe0, 0xe4, 0xac, 0x87, 0xf7, 0x51, 0x45, 0x41, 0x43, 0xdc, 0xaa, 0xcd, 0xcb, 0xdc, 0x40, 0xe3, 0x44, 0x3b, 0x1d, 0x9e, 0x3d, 0xb9, 0x82, 0xcc, 0x7a, 0xc5, 0x12, 0xf8, 0x1e, 0xdd, 0xdb, 0x8d, 0xb0, 0x2a, 0xe8, 0xe6, 0x6c, 0x94, 0x3b, 0xb7, 0x2d, 0xba, 0x79, 0x3b, 0xb5, 0x86, 0xfb,
|
||||
/* (2^396)P */ 0x82, 0x88, 0x13, 0xdd, 0x6c, 0xcd, 0x85, 0x2b, 0x90, 0x86, 0xb7, 0xac, 0x16, 0xa6, 0x6e, 0x6a, 0x94, 0xd8, 0x1e, 0x4e, 0x41, 0x0f, 0xce, 0x81, 0x6a, 0xa8, 0x26, 0x56, 0x43, 0x52, 0x52, 0xe6, 0xff, 0x88, 0xcf, 0x47, 0x05, 0x1d, 0xff, 0xf3, 0xa0, 0x10, 0xb2, 0x97, 0x87, 0xeb, 0x47, 0xbb, 0xfa, 0x1f, 0xe8, 0x4c, 0xce, 0xc4, 0xcd, 0x93,
|
||||
/* (2^397)P */ 0xf4, 0x11, 0xf5, 0x8d, 0x89, 0x29, 0x79, 0xb3, 0x59, 0x0b, 0x29, 0x7d, 0x9c, 0x12, 0x4a, 0x65, 0x72, 0x3a, 0xf9, 0xec, 0x37, 0x18, 0x86, 0xef, 0x44, 0x07, 0x25, 0x74, 0x76, 0x53, 0xed, 0x51, 0x01, 0xc6, 0x28, 0xc5, 0xc3, 0x4a, 0x0f, 0x99, 0xec, 0xc8, 0x40, 0x5a, 0x83, 0x30, 0x79, 0xa2, 0x3e, 0x63, 0x09, 0x2d, 0x6f, 0x23, 0x54, 0x1c,
|
||||
/* (2^398)P */ 0x5c, 0x6f, 0x3b, 0x1c, 0x30, 0x77, 0x7e, 0x87, 0x66, 0x83, 0x2e, 0x7e, 0x85, 0x50, 0xfd, 0xa0, 0x7a, 0xc2, 0xf5, 0x0f, 0xc1, 0x64, 0xe7, 0x0b, 0xbd, 0x59, 0xa7, 0xe7, 0x65, 0x53, 0xc3, 0xf5, 0x55, 0x5b, 0xe1, 0x82, 0x30, 0x5a, 0x61, 0xcd, 0xa0, 0x89, 0x32, 0xdb, 0x87, 0xfc, 0x21, 0x8a, 0xab, 0x6d, 0x82, 0xa8, 0x42, 0x81, 0x4f, 0xf2,
|
||||
/* (2^399)P */ 0xb3, 0xeb, 0x88, 0x18, 0xf6, 0x56, 0x96, 0xbf, 0xba, 0x5d, 0x71, 0xa1, 0x5a, 0xd1, 0x04, 0x7b, 0xd5, 0x46, 0x01, 0x74, 0xfe, 0x15, 0x25, 0xb7, 0xff, 0x0c, 0x24, 0x47, 0xac, 0xfd, 0xab, 0x47, 0x32, 0xe1, 0x6a, 0x4e, 0xca, 0xcf, 0x7f, 0xdd, 0xf8, 0xd2, 0x4b, 0x3b, 0xf5, 0x17, 0xba, 0xba, 0x8b, 0xa1, 0xec, 0x28, 0x3f, 0x97, 0xab, 0x2a,
|
||||
/* (2^400)P */ 0x51, 0x38, 0xc9, 0x5e, 0xc6, 0xb3, 0x64, 0xf2, 0x24, 0x4d, 0x04, 0x7d, 0xc8, 0x39, 0x0c, 0x4a, 0xc9, 0x73, 0x74, 0x1b, 0x5c, 0xb2, 0xc5, 0x41, 0x62, 0xa0, 0x4c, 0x6d, 0x8d, 0x91, 0x9a, 0x7b, 0x88, 0xab, 0x9c, 0x7e, 0x23, 0xdb, 0x6f, 0xb5, 0x72, 0xd6, 0x47, 0x40, 0xef, 0x22, 0x58, 0x62, 0x19, 0x6c, 0x38, 0xba, 0x5b, 0x00, 0x30, 0x9f,
|
||||
/* (2^401)P */ 0x65, 0xbb, 0x3b, 0x9b, 0xe9, 0xae, 0xbf, 0xbe, 0xe4, 0x13, 0x95, 0xf3, 0xe3, 0x77, 0xcb, 0xe4, 0x9a, 0x22, 0xb5, 0x4a, 0x08, 0x9d, 0xb3, 0x9e, 0x27, 0xe0, 0x15, 0x6c, 0x9f, 0x7e, 0x9a, 0x5e, 0x15, 0x45, 0x25, 0x8d, 0x01, 0x0a, 0xd2, 0x2b, 0xbd, 0x48, 0x06, 0x0d, 0x18, 0x97, 0x4b, 0xdc, 0xbc, 0xf0, 0xcd, 0xb2, 0x52, 0x3c, 0xac, 0xf5,
|
||||
/* (2^402)P */ 0x3e, 0xed, 0x47, 0x6b, 0x5c, 0xf6, 0x76, 0xd0, 0xe9, 0x15, 0xa3, 0xcb, 0x36, 0x00, 0x21, 0xa3, 0x79, 0x20, 0xa5, 0x3e, 0x88, 0x03, 0xcb, 0x7e, 0x63, 0xbb, 0xed, 0xa9, 0x13, 0x35, 0x16, 0xaf, 0x2e, 0xb4, 0x70, 0x14, 0x93, 0xfb, 0xc4, 0x9b, 0xd8, 0xb1, 0xbe, 0x43, 0xd1, 0x85, 0xb8, 0x97, 0xef, 0xea, 0x88, 0xa1, 0x25, 0x52, 0x62, 0x75,
|
||||
/* (2^403)P */ 0x8e, 0x4f, 0xaa, 0x23, 0x62, 0x7e, 0x2b, 0x37, 0x89, 0x00, 0x11, 0x30, 0xc5, 0x33, 0x4a, 0x89, 0x8a, 0xe2, 0xfc, 0x5c, 0x6a, 0x75, 0xe5, 0xf7, 0x02, 0x4a, 0x9b, 0xf7, 0xb5, 0x6a, 0x85, 0x31, 0xd3, 0x5a, 0xcf, 0xc3, 0xf8, 0xde, 0x2f, 0xcf, 0xb5, 0x24, 0xf4, 0xe3, 0xa1, 0xad, 0x42, 0xae, 0x09, 0xb9, 0x2e, 0x04, 0x2d, 0x01, 0x22, 0x3f,
|
||||
/* (2^404)P */ 0x41, 0x16, 0xfb, 0x7d, 0x50, 0xfd, 0xb5, 0xba, 0x88, 0x24, 0xba, 0xfd, 0x3d, 0xb2, 0x90, 0x15, 0xb7, 0xfa, 0xa2, 0xe1, 0x4c, 0x7d, 0xb9, 0xc6, 0xff, 0x81, 0x57, 0xb6, 0xc2, 0x9e, 0xcb, 0xc4, 0x35, 0xbd, 0x01, 0xb7, 0xaa, 0xce, 0xd0, 0xe9, 0xb5, 0xd6, 0x72, 0xbf, 0xd2, 0xee, 0xc7, 0xac, 0x94, 0xff, 0x29, 0x57, 0x02, 0x49, 0x09, 0xad,
|
||||
/* (2^405)P */ 0x27, 0xa5, 0x78, 0x1b, 0xbf, 0x6b, 0xaf, 0x0b, 0x8c, 0xd9, 0xa8, 0x37, 0xb0, 0x67, 0x18, 0xb6, 0xc7, 0x05, 0x8a, 0x67, 0x03, 0x30, 0x62, 0x6e, 0x56, 0x82, 0xa9, 0x54, 0x3e, 0x0c, 0x4e, 0x07, 0xe1, 0x5a, 0x38, 0xed, 0xfa, 0xc8, 0x55, 0x6b, 0x08, 0xa3, 0x6b, 0x64, 0x2a, 0x15, 0xd6, 0x39, 0x6f, 0x47, 0x99, 0x42, 0x3f, 0x33, 0x84, 0x8f,
|
||||
/* (2^406)P */ 0xbc, 0x45, 0x29, 0x81, 0x0e, 0xa4, 0xc5, 0x72, 0x3a, 0x10, 0xe1, 0xc4, 0x1e, 0xda, 0xc3, 0xfe, 0xb0, 0xce, 0xd2, 0x13, 0x34, 0x67, 0x21, 0xc6, 0x7e, 0xf9, 0x8c, 0xff, 0x39, 0x50, 0xae, 0x92, 0x60, 0x35, 0x2f, 0x8b, 0x6e, 0xc9, 0xc1, 0x27, 0x3a, 0x94, 0x66, 0x3e, 0x26, 0x84, 0x93, 0xc8, 0x6c, 0xcf, 0xd2, 0x03, 0xa1, 0x10, 0xcf, 0xb7,
|
||||
/* (2^407)P */ 0x64, 0xda, 0x19, 0xf6, 0xc5, 0x73, 0x17, 0x44, 0x88, 0x81, 0x07, 0x0d, 0x34, 0xb2, 0x75, 0xf9, 0xd9, 0xe2, 0xe0, 0x8b, 0x71, 0xcf, 0x72, 0x34, 0x83, 0xb4, 0xce, 0xfc, 0xd7, 0x29, 0x09, 0x5a, 0x98, 0xbf, 0x14, 0xac, 0x77, 0x55, 0x38, 0x47, 0x5b, 0x0f, 0x40, 0x24, 0xe5, 0xa5, 0xa6, 0xac, 0x2d, 0xa6, 0xff, 0x9c, 0x73, 0xfe, 0x5c, 0x7e,
|
||||
/* (2^408)P */ 0x1e, 0x33, 0xcc, 0x68, 0xb2, 0xbc, 0x8c, 0x93, 0xaf, 0xcc, 0x38, 0xf8, 0xd9, 0x16, 0x72, 0x50, 0xac, 0xd9, 0xb5, 0x0b, 0x9a, 0xbe, 0x46, 0x7a, 0xf1, 0xee, 0xf1, 0xad, 0xec, 0x5b, 0x59, 0x27, 0x9c, 0x05, 0xa3, 0x87, 0xe0, 0x37, 0x2c, 0x83, 0xce, 0xb3, 0x65, 0x09, 0x8e, 0xc3, 0x9c, 0xbf, 0x6a, 0xa2, 0x00, 0xcc, 0x12, 0x36, 0xc5, 0x95,
|
||||
/* (2^409)P */ 0x36, 0x11, 0x02, 0x14, 0x9c, 0x3c, 0xeb, 0x2f, 0x23, 0x5b, 0x6b, 0x2b, 0x08, 0x54, 0x53, 0xac, 0xb2, 0xa3, 0xe0, 0x26, 0x62, 0x3c, 0xe4, 0xe1, 0x81, 0xee, 0x13, 0x3e, 0xa4, 0x97, 0xef, 0xf9, 0x92, 0x27, 0x01, 0xce, 0x54, 0x8b, 0x3e, 0x31, 0xbe, 0xa7, 0x88, 0xcf, 0x47, 0x99, 0x3c, 0x10, 0x6f, 0x60, 0xb3, 0x06, 0x4e, 0xee, 0x1b, 0xf0,
|
||||
/* (2^410)P */ 0x59, 0x49, 0x66, 0xcf, 0x22, 0xe6, 0xf6, 0x73, 0xfe, 0xa3, 0x1c, 0x09, 0xfa, 0x5f, 0x65, 0xa8, 0xf0, 0x82, 0xc2, 0xef, 0x16, 0x63, 0x6e, 0x79, 0x69, 0x51, 0x39, 0x07, 0x65, 0xc4, 0x81, 0xec, 0x73, 0x0f, 0x15, 0x93, 0xe1, 0x30, 0x33, 0xe9, 0x37, 0x86, 0x42, 0x4c, 0x1f, 0x9b, 0xad, 0xee, 0x3f, 0xf1, 0x2a, 0x8e, 0x6a, 0xa3, 0xc8, 0x35,
|
||||
/* (2^411)P */ 0x1e, 0x49, 0xf1, 0xdd, 0xd2, 0x9c, 0x8e, 0x78, 0xb2, 0x06, 0xe4, 0x6a, 0xab, 0x3a, 0xdc, 0xcd, 0xf4, 0xeb, 0xe1, 0xe7, 0x2f, 0xaa, 0xeb, 0x40, 0x31, 0x9f, 0xb9, 0xab, 0x13, 0xa9, 0x78, 0xbf, 0x38, 0x89, 0x0e, 0x85, 0x14, 0x8b, 0x46, 0x76, 0x14, 0xda, 0xcf, 0x33, 0xc8, 0x79, 0xd3, 0xd5, 0xa3, 0x6a, 0x69, 0x45, 0x70, 0x34, 0xc3, 0xe9,
|
||||
/* (2^412)P */ 0x5e, 0xe7, 0x78, 0xe9, 0x24, 0xcc, 0xe9, 0xf4, 0xc8, 0x6b, 0xe0, 0xfb, 0x3a, 0xbe, 0xcc, 0x42, 0x4a, 0x00, 0x22, 0xf8, 0xe6, 0x32, 0xbe, 0x6d, 0x18, 0x55, 0x60, 0xe9, 0x72, 0x69, 0x50, 0x56, 0xca, 0x04, 0x18, 0x38, 0xa1, 0xee, 0xd8, 0x38, 0x3c, 0xa7, 0x70, 0xe2, 0xb9, 0x4c, 0xa0, 0xc8, 0x89, 0x72, 0xcf, 0x49, 0x7f, 0xdf, 0xbc, 0x67,
|
||||
/* (2^413)P */ 0x1d, 0x17, 0xcb, 0x0b, 0xbd, 0xb2, 0x36, 0xe3, 0xa8, 0x99, 0x31, 0xb6, 0x26, 0x9c, 0x0c, 0x74, 0xaf, 0x4d, 0x24, 0x61, 0xcf, 0x31, 0x7b, 0xed, 0xdd, 0xc3, 0xf6, 0x32, 0x70, 0xfe, 0x17, 0xf6, 0x51, 0x37, 0x65, 0xce, 0x5d, 0xaf, 0xa5, 0x2f, 0x2a, 0xfe, 0x00, 0x71, 0x7c, 0x50, 0xbe, 0x21, 0xc7, 0xed, 0xc6, 0xfc, 0x67, 0xcf, 0x9c, 0xdd,
|
||||
/* (2^414)P */ 0x26, 0x3e, 0xf8, 0xbb, 0xd0, 0xb1, 0x01, 0xd8, 0xeb, 0x0b, 0x62, 0x87, 0x35, 0x4c, 0xde, 0xca, 0x99, 0x9c, 0x6d, 0xf7, 0xb6, 0xf0, 0x57, 0x0a, 0x52, 0x29, 0x6a, 0x3f, 0x26, 0x31, 0x04, 0x07, 0x2a, 0xc9, 0xfa, 0x9b, 0x0e, 0x62, 0x8e, 0x72, 0xf2, 0xad, 0xce, 0xb6, 0x35, 0x7a, 0xc1, 0xae, 0x35, 0xc7, 0xa3, 0x14, 0xcf, 0x0c, 0x28, 0xb7,
|
||||
/* (2^415)P */ 0xa6, 0xf1, 0x32, 0x3a, 0x20, 0xd2, 0x24, 0x97, 0xcf, 0x5d, 0x37, 0x99, 0xaf, 0x33, 0x7a, 0x5b, 0x7a, 0xcc, 0x4e, 0x41, 0x38, 0xb1, 0x4e, 0xad, 0xc9, 0xd9, 0x71, 0x7e, 0xb2, 0xf5, 0xd5, 0x01, 0x6c, 0x4d, 0xfd, 0xa1, 0xda, 0x03, 0x38, 0x9b, 0x3d, 0x92, 0x92, 0xf2, 0xca, 0xbf, 0x1f, 0x24, 0xa4, 0xbb, 0x30, 0x6a, 0x74, 0x56, 0xc8, 0xce,
|
||||
/* (2^416)P */ 0x27, 0xf4, 0xed, 0xc9, 0xc3, 0xb1, 0x79, 0x85, 0xbe, 0xf6, 0xeb, 0xf3, 0x55, 0xc7, 0xaa, 0xa6, 0xe9, 0x07, 0x5d, 0xf4, 0xeb, 0xa6, 0x81, 0xe3, 0x0e, 0xcf, 0xa3, 0xc1, 0xef, 0xe7, 0x34, 0xb2, 0x03, 0x73, 0x8a, 0x91, 0xf1, 0xad, 0x05, 0xc7, 0x0b, 0x43, 0x99, 0x12, 0x31, 0xc8, 0xc7, 0xc5, 0xa4, 0x3d, 0xcd, 0xe5, 0x4e, 0x6d, 0x24, 0xdd,
|
||||
/* (2^417)P */ 0x61, 0x54, 0xd0, 0x95, 0x2c, 0x45, 0x75, 0xac, 0xb5, 0x1a, 0x9d, 0x11, 0xeb, 0xed, 0x6b, 0x57, 0xa3, 0xe6, 0xcd, 0x77, 0xd4, 0x83, 0x8e, 0x39, 0xf1, 0x0f, 0x98, 0xcb, 0x40, 0x02, 0x6e, 0x10, 0x82, 0x9e, 0xb4, 0x93, 0x76, 0xd7, 0x97, 0xa3, 0x53, 0x12, 0x86, 0xc6, 0x15, 0x78, 0x73, 0x93, 0xe7, 0x7f, 0xcf, 0x1f, 0xbf, 0xcd, 0xd2, 0x7a,
|
||||
/* (2^418)P */ 0xc2, 0x21, 0xdc, 0xd5, 0x69, 0xff, 0xca, 0x49, 0x3a, 0xe1, 0xc3, 0x69, 0x41, 0x56, 0xc1, 0x76, 0x63, 0x24, 0xbd, 0x64, 0x1b, 0x3d, 0x92, 0xf9, 0x13, 0x04, 0x25, 0xeb, 0x27, 0xa6, 0xef, 0x39, 0x3a, 0x80, 0xe0, 0xf8, 0x27, 0xee, 0xc9, 0x49, 0x77, 0xef, 0x3f, 0x29, 0x3d, 0x5e, 0xe6, 0x66, 0x83, 0xd1, 0xf6, 0xfe, 0x9d, 0xbc, 0xf1, 0x96,
|
||||
/* (2^419)P */ 0x6b, 0xc6, 0x99, 0x26, 0x3c, 0xf3, 0x63, 0xf9, 0xc7, 0x29, 0x8c, 0x52, 0x62, 0x2d, 0xdc, 0x8a, 0x66, 0xce, 0x2c, 0xa7, 0xe4, 0xf0, 0xd7, 0x37, 0x17, 0x1e, 0xe4, 0xa3, 0x53, 0x7b, 0x29, 0x8e, 0x60, 0x99, 0xf9, 0x0c, 0x7c, 0x6f, 0xa2, 0xcc, 0x9f, 0x80, 0xdd, 0x5e, 0x46, 0xaa, 0x0d, 0x6c, 0xc9, 0x6c, 0xf7, 0x78, 0x5b, 0x38, 0xe3, 0x24,
|
||||
/* (2^420)P */ 0x4b, 0x75, 0x6a, 0x2f, 0x08, 0xe1, 0x72, 0x76, 0xab, 0x82, 0x96, 0xdf, 0x3b, 0x1f, 0x9b, 0xd8, 0xed, 0xdb, 0xcd, 0x15, 0x09, 0x5a, 0x1e, 0xb7, 0xc5, 0x26, 0x72, 0x07, 0x0c, 0x50, 0xcd, 0x3b, 0x4d, 0x3f, 0xa2, 0x67, 0xc2, 0x02, 0x61, 0x2e, 0x68, 0xe9, 0x6f, 0xf0, 0x21, 0x2a, 0xa7, 0x3b, 0x88, 0x04, 0x11, 0x64, 0x49, 0x0d, 0xb4, 0x46,
|
||||
/* (2^421)P */ 0x63, 0x85, 0xf3, 0xc5, 0x2b, 0x5a, 0x9f, 0xf0, 0x17, 0xcb, 0x45, 0x0a, 0xf3, 0x6e, 0x7e, 0xb0, 0x7c, 0xbc, 0xf0, 0x4f, 0x3a, 0xb0, 0xbc, 0x36, 0x36, 0x52, 0x51, 0xcb, 0xfe, 0x9a, 0xcb, 0xe8, 0x7e, 0x4b, 0x06, 0x7f, 0xaa, 0x35, 0xc8, 0x0e, 0x7a, 0x30, 0xa3, 0xb1, 0x09, 0xbb, 0x86, 0x4c, 0xbe, 0xb8, 0xbd, 0xe0, 0x32, 0xa5, 0xd4, 0xf7,
|
||||
/* (2^422)P */ 0x7d, 0x50, 0x37, 0x68, 0x4e, 0x22, 0xb2, 0x2c, 0xd5, 0x0f, 0x2b, 0x6d, 0xb1, 0x51, 0xf2, 0x82, 0xe9, 0x98, 0x7c, 0x50, 0xc7, 0x96, 0x7e, 0x0e, 0xdc, 0xb1, 0x0e, 0xb2, 0x63, 0x8c, 0x30, 0x37, 0x72, 0x21, 0x9c, 0x61, 0xc2, 0xa7, 0x33, 0xd9, 0xb2, 0x63, 0x93, 0xd1, 0x6b, 0x6a, 0x73, 0xa5, 0x58, 0x80, 0xff, 0x04, 0xc7, 0x83, 0x21, 0x29,
|
||||
/* (2^423)P */ 0x29, 0x04, 0xbc, 0x99, 0x39, 0xc9, 0x58, 0xc9, 0x6b, 0x17, 0xe8, 0x90, 0xb3, 0xe6, 0xa9, 0xb6, 0x28, 0x9b, 0xcb, 0x3b, 0x28, 0x90, 0x68, 0x71, 0xff, 0xcf, 0x08, 0x78, 0xc9, 0x8d, 0xa8, 0x4e, 0x43, 0xd1, 0x1c, 0x9e, 0xa4, 0xe3, 0xdf, 0xbf, 0x92, 0xf4, 0xf9, 0x41, 0xba, 0x4d, 0x1c, 0xf9, 0xdd, 0x74, 0x76, 0x1c, 0x6e, 0x3e, 0x94, 0x87,
|
||||
/* (2^424)P */ 0xe4, 0xda, 0xc5, 0xd7, 0xfb, 0x87, 0xc5, 0x4d, 0x6b, 0x19, 0xaa, 0xb9, 0xbc, 0x8c, 0xf2, 0x8a, 0xd8, 0x5d, 0xdb, 0x4d, 0xef, 0xa6, 0xf2, 0x65, 0xf1, 0x22, 0x9c, 0xf1, 0x46, 0x30, 0x71, 0x7c, 0xe4, 0x53, 0x8e, 0x55, 0x2e, 0x9c, 0x9a, 0x31, 0x2a, 0xc3, 0xab, 0x0f, 0xde, 0xe4, 0xbe, 0xd8, 0x96, 0x50, 0x6e, 0x0c, 0x54, 0x49, 0xe6, 0xec,
|
||||
/* (2^425)P */ 0x3c, 0x1d, 0x5a, 0xa5, 0xda, 0xad, 0xdd, 0xc2, 0xae, 0xac, 0x6f, 0x86, 0x75, 0x31, 0x91, 0x64, 0x45, 0x9d, 0xa4, 0xf0, 0x81, 0xf1, 0x0e, 0xba, 0x74, 0xaf, 0x7b, 0xcd, 0x6f, 0xfe, 0xac, 0x4e, 0xdb, 0x4e, 0x45, 0x35, 0x36, 0xc5, 0xc0, 0x6c, 0x3d, 0x64, 0xf4, 0xd8, 0x07, 0x62, 0xd1, 0xec, 0xf3, 0xfc, 0x93, 0xc9, 0x28, 0x0c, 0x2c, 0xf3,
|
||||
/* (2^426)P */ 0x0c, 0x69, 0x2b, 0x5c, 0xb6, 0x41, 0x69, 0xf1, 0xa4, 0xf1, 0x5b, 0x75, 0x4c, 0x42, 0x8b, 0x47, 0xeb, 0x69, 0xfb, 0xa8, 0xe6, 0xf9, 0x7b, 0x48, 0x50, 0xaf, 0xd3, 0xda, 0xb2, 0x35, 0x10, 0xb5, 0x5b, 0x40, 0x90, 0x39, 0xc9, 0x07, 0x06, 0x73, 0x26, 0x20, 0x95, 0x01, 0xa4, 0x2d, 0xf0, 0xe7, 0x2e, 0x00, 0x7d, 0x41, 0x09, 0x68, 0x13, 0xc4,
|
||||
/* (2^427)P */ 0xbe, 0x38, 0x78, 0xcf, 0xc9, 0x4f, 0x36, 0xca, 0x09, 0x61, 0x31, 0x3c, 0x57, 0x2e, 0xec, 0x17, 0xa4, 0x7d, 0x19, 0x2b, 0x9b, 0x5b, 0xbe, 0x8f, 0xd6, 0xc5, 0x2f, 0x86, 0xf2, 0x64, 0x76, 0x17, 0x00, 0x6e, 0x1a, 0x8c, 0x67, 0x1b, 0x68, 0xeb, 0x15, 0xa2, 0xd6, 0x09, 0x91, 0xdd, 0x23, 0x0d, 0x98, 0xb2, 0x10, 0x19, 0x55, 0x9b, 0x63, 0xf2,
|
||||
/* (2^428)P */ 0x51, 0x1f, 0x93, 0xea, 0x2a, 0x3a, 0xfa, 0x41, 0xc0, 0x57, 0xfb, 0x74, 0xa6, 0x65, 0x09, 0x56, 0x14, 0xb6, 0x12, 0xaa, 0xb3, 0x1a, 0x8d, 0x3b, 0x76, 0x91, 0x7a, 0x23, 0x56, 0x9c, 0x6a, 0xc0, 0xe0, 0x3c, 0x3f, 0xb5, 0x1a, 0xf4, 0x57, 0x71, 0x93, 0x2b, 0xb1, 0xa7, 0x70, 0x57, 0x22, 0x80, 0xf5, 0xb8, 0x07, 0x77, 0x87, 0x0c, 0xbe, 0x83,
|
||||
/* (2^429)P */ 0x07, 0x9b, 0x0e, 0x52, 0x38, 0x63, 0x13, 0x86, 0x6a, 0xa6, 0xb4, 0xd2, 0x60, 0x68, 0x9a, 0x99, 0x82, 0x0a, 0x04, 0x5f, 0x89, 0x7a, 0x1a, 0x2a, 0xae, 0x2d, 0x35, 0x0c, 0x1e, 0xad, 0xef, 0x4f, 0x9a, 0xfc, 0xc8, 0xd9, 0xcf, 0x9d, 0x48, 0x71, 0xa5, 0x55, 0x79, 0x73, 0x39, 0x1b, 0xd8, 0x73, 0xec, 0x9b, 0x03, 0x16, 0xd8, 0x82, 0xf7, 0x67,
|
||||
/* (2^430)P */ 0x52, 0x67, 0x42, 0x21, 0xc9, 0x40, 0x78, 0x82, 0x2b, 0x95, 0x2d, 0x20, 0x92, 0xd1, 0xe2, 0x61, 0x25, 0xb0, 0xc6, 0x9c, 0x20, 0x59, 0x8e, 0x28, 0x6f, 0xf3, 0xfd, 0xd3, 0xc1, 0x32, 0x43, 0xc9, 0xa6, 0x08, 0x7a, 0x77, 0x9c, 0x4c, 0x8c, 0x33, 0x71, 0x13, 0x69, 0xe3, 0x52, 0x30, 0xa7, 0xf5, 0x07, 0x67, 0xac, 0xad, 0x46, 0x8a, 0x26, 0x25,
|
||||
/* (2^431)P */ 0xda, 0x86, 0xc4, 0xa2, 0x71, 0x56, 0xdd, 0xd2, 0x48, 0xd3, 0xde, 0x42, 0x63, 0x01, 0xa7, 0x2c, 0x92, 0x83, 0x6f, 0x2e, 0xd8, 0x1e, 0x3f, 0xc1, 0xc5, 0x42, 0x4e, 0x34, 0x19, 0x54, 0x6e, 0x35, 0x2c, 0x51, 0x2e, 0xfd, 0x0f, 0x9a, 0x45, 0x66, 0x5e, 0x4a, 0x83, 0xda, 0x0a, 0x53, 0x68, 0x63, 0xfa, 0xce, 0x47, 0x20, 0xd3, 0x34, 0xba, 0x0d,
|
||||
/* (2^432)P */ 0xd0, 0xe9, 0x64, 0xa4, 0x61, 0x4b, 0x86, 0xe5, 0x93, 0x6f, 0xda, 0x0e, 0x31, 0x7e, 0x6e, 0xe3, 0xc6, 0x73, 0xd8, 0xa3, 0x08, 0x57, 0x52, 0xcd, 0x51, 0x63, 0x1d, 0x9f, 0x93, 0x00, 0x62, 0x91, 0x26, 0x21, 0xa7, 0xdd, 0x25, 0x0f, 0x09, 0x0d, 0x35, 0xad, 0xcf, 0x11, 0x8e, 0x6e, 0xe8, 0xae, 0x1d, 0x95, 0xcb, 0x88, 0xf8, 0x70, 0x7b, 0x91,
|
||||
/* (2^433)P */ 0x0c, 0x19, 0x5c, 0xd9, 0x8d, 0xda, 0x9d, 0x2c, 0x90, 0x54, 0x65, 0xe8, 0xb6, 0x35, 0x50, 0xae, 0xea, 0xae, 0x43, 0xb7, 0x1e, 0x99, 0x8b, 0x4c, 0x36, 0x4e, 0xe4, 0x1e, 0xc4, 0x64, 0x43, 0xb6, 0xeb, 0xd4, 0xe9, 0x60, 0x22, 0xee, 0xcf, 0xb8, 0x52, 0x1b, 0xf0, 0x04, 0xce, 0xbc, 0x2b, 0xf0, 0xbe, 0xcd, 0x44, 0x74, 0x1e, 0x1f, 0x63, 0xf9,
|
||||
/* (2^434)P */ 0xe1, 0x3f, 0x95, 0x94, 0xb2, 0xb6, 0x31, 0xa9, 0x1b, 0xdb, 0xfd, 0x0e, 0xdb, 0xdd, 0x1a, 0x22, 0x78, 0x60, 0x9f, 0x75, 0x5f, 0x93, 0x06, 0x0c, 0xd8, 0xbb, 0xa2, 0x85, 0x2b, 0x5e, 0xc0, 0x9b, 0xa8, 0x5d, 0xaf, 0x93, 0x91, 0x91, 0x47, 0x41, 0x1a, 0xfc, 0xb4, 0x51, 0x85, 0xad, 0x69, 0x4d, 0x73, 0x69, 0xd5, 0x4e, 0x82, 0xfb, 0x66, 0xcb,
|
||||
/* (2^435)P */ 0x7c, 0xbe, 0xc7, 0x51, 0xc4, 0x74, 0x6e, 0xab, 0xfd, 0x41, 0x4f, 0x76, 0x4f, 0x24, 0x03, 0xd6, 0x2a, 0xb7, 0x42, 0xb4, 0xda, 0x41, 0x2c, 0x82, 0x48, 0x4c, 0x7f, 0x6f, 0x25, 0x5d, 0x36, 0xd4, 0x69, 0xf5, 0xef, 0x02, 0x81, 0xea, 0x6f, 0x19, 0x69, 0xe8, 0x6f, 0x5b, 0x2f, 0x14, 0x0e, 0x6f, 0x89, 0xb4, 0xb5, 0xd8, 0xae, 0xef, 0x7b, 0x87,
|
||||
/* (2^436)P */ 0xe9, 0x91, 0xa0, 0x8b, 0xc9, 0xe0, 0x01, 0x90, 0x37, 0xc1, 0x6f, 0xdc, 0x5e, 0xf7, 0xbf, 0x43, 0x00, 0xaa, 0x10, 0x76, 0x76, 0x18, 0x6e, 0x19, 0x1e, 0x94, 0x50, 0x11, 0x0a, 0xd1, 0xe2, 0xdb, 0x08, 0x21, 0xa0, 0x1f, 0xdb, 0x54, 0xfe, 0xea, 0x6e, 0xa3, 0x68, 0x56, 0x87, 0x0b, 0x22, 0x4e, 0x66, 0xf3, 0x82, 0x82, 0x00, 0xcd, 0xd4, 0x12,
|
||||
/* (2^437)P */ 0x25, 0x8e, 0x24, 0x77, 0x64, 0x4c, 0xe0, 0xf8, 0x18, 0xc0, 0xdc, 0xc7, 0x1b, 0x35, 0x65, 0xde, 0x67, 0x41, 0x5e, 0x6f, 0x90, 0x82, 0xa7, 0x2e, 0x6d, 0xf1, 0x47, 0xb4, 0x92, 0x9c, 0xfd, 0x6a, 0x9a, 0x41, 0x36, 0x20, 0x24, 0x58, 0xc3, 0x59, 0x07, 0x9a, 0xfa, 0x9f, 0x03, 0xcb, 0xc7, 0x69, 0x37, 0x60, 0xe1, 0xab, 0x13, 0x72, 0xee, 0xa2,
|
||||
/* (2^438)P */ 0x74, 0x78, 0xfb, 0x13, 0xcb, 0x8e, 0x37, 0x1a, 0xf6, 0x1d, 0x17, 0x83, 0x06, 0xd4, 0x27, 0x06, 0x21, 0xe8, 0xda, 0xdf, 0x6b, 0xf3, 0x83, 0x6b, 0x34, 0x8a, 0x8c, 0xee, 0x01, 0x05, 0x5b, 0xed, 0xd3, 0x1b, 0xc9, 0x64, 0x83, 0xc9, 0x49, 0xc2, 0x57, 0x1b, 0xdd, 0xcf, 0xf1, 0x9d, 0x63, 0xee, 0x1c, 0x0d, 0xa0, 0x0a, 0x73, 0x1f, 0x5b, 0x32,
|
||||
/* (2^439)P */ 0x29, 0xce, 0x1e, 0xc0, 0x6a, 0xf5, 0xeb, 0x99, 0x5a, 0x39, 0x23, 0xe9, 0xdd, 0xac, 0x44, 0x88, 0xbc, 0x80, 0x22, 0xde, 0x2c, 0xcb, 0xa8, 0x3b, 0xff, 0xf7, 0x6f, 0xc7, 0x71, 0x72, 0xa8, 0xa3, 0xf6, 0x4d, 0xc6, 0x75, 0xda, 0x80, 0xdc, 0xd9, 0x30, 0xd9, 0x07, 0x50, 0x5a, 0x54, 0x7d, 0xda, 0x39, 0x6f, 0x78, 0x94, 0xbf, 0x25, 0x98, 0xdc,
|
||||
/* (2^440)P */ 0x01, 0x26, 0x62, 0x44, 0xfb, 0x0f, 0x11, 0x72, 0x73, 0x0a, 0x16, 0xc7, 0x16, 0x9c, 0x9b, 0x37, 0xd8, 0xff, 0x4f, 0xfe, 0x57, 0xdb, 0xae, 0xef, 0x7d, 0x94, 0x30, 0x04, 0x70, 0x83, 0xde, 0x3c, 0xd4, 0xb5, 0x70, 0xda, 0xa7, 0x55, 0xc8, 0x19, 0xe1, 0x36, 0x15, 0x61, 0xe7, 0x3b, 0x7d, 0x85, 0xbb, 0xf3, 0x42, 0x5a, 0x94, 0xf4, 0x53, 0x2a,
|
||||
/* (2^441)P */ 0x14, 0x60, 0xa6, 0x0b, 0x83, 0xe1, 0x23, 0x77, 0xc0, 0xce, 0x50, 0xed, 0x35, 0x8d, 0x98, 0x99, 0x7d, 0xf5, 0x8d, 0xce, 0x94, 0x25, 0xc8, 0x0f, 0x6d, 0xfa, 0x4a, 0xa4, 0x3a, 0x1f, 0x66, 0xfb, 0x5a, 0x64, 0xaf, 0x8b, 0x54, 0x54, 0x44, 0x3f, 0x5b, 0x88, 0x61, 0xe4, 0x48, 0x45, 0x26, 0x20, 0xbe, 0x0d, 0x06, 0xbb, 0x65, 0x59, 0xe1, 0x36,
|
||||
/* (2^442)P */ 0xb7, 0x98, 0xce, 0xa3, 0xe3, 0xee, 0x11, 0x1b, 0x9e, 0x24, 0x59, 0x75, 0x31, 0x37, 0x44, 0x6f, 0x6b, 0x9e, 0xec, 0xb7, 0x44, 0x01, 0x7e, 0xab, 0xbb, 0x69, 0x5d, 0x11, 0xb0, 0x30, 0x64, 0xea, 0x91, 0xb4, 0x7a, 0x8c, 0x02, 0x4c, 0xb9, 0x10, 0xa7, 0xc7, 0x79, 0xe6, 0xdc, 0x77, 0xe3, 0xc8, 0xef, 0x3e, 0xf9, 0x38, 0x81, 0xce, 0x9a, 0xb2,
|
||||
/* (2^443)P */ 0x91, 0x12, 0x76, 0xd0, 0x10, 0xb4, 0xaf, 0xe1, 0x89, 0x3a, 0x93, 0x6b, 0x5c, 0x19, 0x5f, 0x24, 0xed, 0x04, 0x92, 0xc7, 0xf0, 0x00, 0x08, 0xc1, 0x92, 0xff, 0x90, 0xdb, 0xb2, 0xbf, 0xdf, 0x49, 0xcd, 0xbd, 0x5c, 0x6e, 0xbf, 0x16, 0xbb, 0x61, 0xf9, 0x20, 0x33, 0x35, 0x93, 0x11, 0xbc, 0x59, 0x69, 0xce, 0x18, 0x9f, 0xf8, 0x7b, 0xa1, 0x6e,
|
||||
/* (2^444)P */ 0xa1, 0xf4, 0xaf, 0xad, 0xf8, 0xe6, 0x99, 0xd2, 0xa1, 0x4d, 0xde, 0x56, 0xc9, 0x7b, 0x0b, 0x11, 0x3e, 0xbf, 0x89, 0x1a, 0x9a, 0x90, 0xe5, 0xe2, 0xa6, 0x37, 0x88, 0xa1, 0x68, 0x59, 0xae, 0x8c, 0xec, 0x02, 0x14, 0x8d, 0xb7, 0x2e, 0x25, 0x75, 0x7f, 0x76, 0x1a, 0xd3, 0x4d, 0xad, 0x8a, 0x00, 0x6c, 0x96, 0x49, 0xa4, 0xc3, 0x2e, 0x5c, 0x7b,
|
||||
/* (2^445)P */ 0x26, 0x53, 0xf7, 0xda, 0xa8, 0x01, 0x14, 0xb1, 0x63, 0xe3, 0xc3, 0x89, 0x88, 0xb0, 0x85, 0x40, 0x2b, 0x26, 0x9a, 0x10, 0x1a, 0x70, 0x33, 0xf4, 0x50, 0x9d, 0x4d, 0xd8, 0x64, 0xc6, 0x0f, 0xe1, 0x17, 0xc8, 0x10, 0x4b, 0xfc, 0xa0, 0xc9, 0xba, 0x2c, 0x98, 0x09, 0xf5, 0x84, 0xb6, 0x7c, 0x4e, 0xa3, 0xe3, 0x81, 0x1b, 0x32, 0x60, 0x02, 0xdd,
|
||||
/* (2^446)P */ 0xa3, 0xe5, 0x86, 0xd4, 0x43, 0xa8, 0xd1, 0x98, 0x9d, 0x9d, 0xdb, 0x04, 0xcf, 0x6e, 0x35, 0x05, 0x30, 0x53, 0x3b, 0xbc, 0x90, 0x00, 0x4a, 0xc5, 0x40, 0x2a, 0x0f, 0xde, 0x1a, 0xd7, 0x36, 0x27, 0x44, 0x62, 0xa6, 0xac, 0x9d, 0xd2, 0x70, 0x69, 0x14, 0x39, 0x9b, 0xd1, 0xc3, 0x0a, 0x3a, 0x82, 0x0e, 0xf1, 0x94, 0xd7, 0x42, 0x94, 0xd5, 0x7d,
|
||||
/* (2^447)P */ 0x04, 0xc0, 0x6e, 0x12, 0x90, 0x70, 0xf9, 0xdf, 0xf7, 0xc9, 0x86, 0xc0, 0xe6, 0x92, 0x8b, 0x0a, 0xa1, 0xc1, 0x3b, 0xcc, 0x33, 0xb7, 0xf0, 0xeb, 0x51, 0x50, 0x80, 0x20, 0x69, 0x1c, 0x4f, 0x89, 0x05, 0x1e, 0xe4, 0x7a, 0x0a, 0xc2, 0xf0, 0xf5, 0x78, 0x91, 0x76, 0x34, 0x45, 0xdc, 0x24, 0x53, 0x24, 0x98, 0xe2, 0x73, 0x6f, 0xe6, 0x46, 0x67,
|
||||
}
|
||||
71
vendor/github.com/cloudflare/circl/ecc/goldilocks/constants.go
generated
vendored
Normal file
71
vendor/github.com/cloudflare/circl/ecc/goldilocks/constants.go
generated
vendored
Normal file
@ -0,0 +1,71 @@
|
||||
package goldilocks
|
||||
|
||||
import fp "github.com/cloudflare/circl/math/fp448"
|
||||
|
||||
var (
|
||||
// genX is the x-coordinate of the generator of Goldilocks curve.
|
||||
genX = fp.Elt{
|
||||
0x5e, 0xc0, 0x0c, 0xc7, 0x2b, 0xa8, 0x26, 0x26,
|
||||
0x8e, 0x93, 0x00, 0x8b, 0xe1, 0x80, 0x3b, 0x43,
|
||||
0x11, 0x65, 0xb6, 0x2a, 0xf7, 0x1a, 0xae, 0x12,
|
||||
0x64, 0xa4, 0xd3, 0xa3, 0x24, 0xe3, 0x6d, 0xea,
|
||||
0x67, 0x17, 0x0f, 0x47, 0x70, 0x65, 0x14, 0x9e,
|
||||
0xda, 0x36, 0xbf, 0x22, 0xa6, 0x15, 0x1d, 0x22,
|
||||
0xed, 0x0d, 0xed, 0x6b, 0xc6, 0x70, 0x19, 0x4f,
|
||||
}
|
||||
// genY is the y-coordinate of the generator of Goldilocks curve.
|
||||
genY = fp.Elt{
|
||||
0x14, 0xfa, 0x30, 0xf2, 0x5b, 0x79, 0x08, 0x98,
|
||||
0xad, 0xc8, 0xd7, 0x4e, 0x2c, 0x13, 0xbd, 0xfd,
|
||||
0xc4, 0x39, 0x7c, 0xe6, 0x1c, 0xff, 0xd3, 0x3a,
|
||||
0xd7, 0xc2, 0xa0, 0x05, 0x1e, 0x9c, 0x78, 0x87,
|
||||
0x40, 0x98, 0xa3, 0x6c, 0x73, 0x73, 0xea, 0x4b,
|
||||
0x62, 0xc7, 0xc9, 0x56, 0x37, 0x20, 0x76, 0x88,
|
||||
0x24, 0xbc, 0xb6, 0x6e, 0x71, 0x46, 0x3f, 0x69,
|
||||
}
|
||||
// paramD is -39081 in Fp.
|
||||
paramD = fp.Elt{
|
||||
0x56, 0x67, 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, 0xfe, 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,
|
||||
}
|
||||
// order is 2^446-0x8335dc163bb124b65129c96fde933d8d723a70aadc873d6d54a7bb0d,
|
||||
// which is the number of points in the prime subgroup.
|
||||
order = Scalar{
|
||||
0xf3, 0x44, 0x58, 0xab, 0x92, 0xc2, 0x78, 0x23,
|
||||
0x55, 0x8f, 0xc5, 0x8d, 0x72, 0xc2, 0x6c, 0x21,
|
||||
0x90, 0x36, 0xd6, 0xae, 0x49, 0xdb, 0x4e, 0xc4,
|
||||
0xe9, 0x23, 0xca, 0x7c, 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, 0x3f,
|
||||
}
|
||||
// residue448 is 2^448 mod order.
|
||||
residue448 = [4]uint64{
|
||||
0x721cf5b5529eec34, 0x7a4cf635c8e9c2ab, 0xeec492d944a725bf, 0x20cd77058,
|
||||
}
|
||||
// invFour is 1/4 mod order.
|
||||
invFour = Scalar{
|
||||
0x3d, 0x11, 0xd6, 0xaa, 0xa4, 0x30, 0xde, 0x48,
|
||||
0xd5, 0x63, 0x71, 0xa3, 0x9c, 0x30, 0x5b, 0x08,
|
||||
0xa4, 0x8d, 0xb5, 0x6b, 0xd2, 0xb6, 0x13, 0x71,
|
||||
0xfa, 0x88, 0x32, 0xdf, 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, 0x0f,
|
||||
}
|
||||
// paramDTwist is -39082 in Fp. The D parameter of the twist curve.
|
||||
paramDTwist = fp.Elt{
|
||||
0x55, 0x67, 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, 0xfe, 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,
|
||||
}
|
||||
)
|
||||
80
vendor/github.com/cloudflare/circl/ecc/goldilocks/curve.go
generated
vendored
Normal file
80
vendor/github.com/cloudflare/circl/ecc/goldilocks/curve.go
generated
vendored
Normal file
@ -0,0 +1,80 @@
|
||||
// Package goldilocks provides elliptic curve operations over the goldilocks curve.
|
||||
package goldilocks
|
||||
|
||||
import fp "github.com/cloudflare/circl/math/fp448"
|
||||
|
||||
// Curve is the Goldilocks curve x^2+y^2=z^2-39081x^2y^2.
|
||||
type Curve struct{}
|
||||
|
||||
// Identity returns the identity point.
|
||||
func (Curve) Identity() *Point {
|
||||
return &Point{
|
||||
y: fp.One(),
|
||||
z: fp.One(),
|
||||
}
|
||||
}
|
||||
|
||||
// IsOnCurve returns true if the point lies on the curve.
|
||||
func (Curve) IsOnCurve(P *Point) bool {
|
||||
x2, y2, t, t2, z2 := &fp.Elt{}, &fp.Elt{}, &fp.Elt{}, &fp.Elt{}, &fp.Elt{}
|
||||
rhs, lhs := &fp.Elt{}, &fp.Elt{}
|
||||
fp.Mul(t, &P.ta, &P.tb) // t = ta*tb
|
||||
fp.Sqr(x2, &P.x) // x^2
|
||||
fp.Sqr(y2, &P.y) // y^2
|
||||
fp.Sqr(z2, &P.z) // z^2
|
||||
fp.Sqr(t2, t) // t^2
|
||||
fp.Add(lhs, x2, y2) // x^2 + y^2
|
||||
fp.Mul(rhs, t2, ¶mD) // dt^2
|
||||
fp.Add(rhs, rhs, z2) // z^2 + dt^2
|
||||
fp.Sub(lhs, lhs, rhs) // x^2 + y^2 - (z^2 + dt^2)
|
||||
eq0 := fp.IsZero(lhs)
|
||||
|
||||
fp.Mul(lhs, &P.x, &P.y) // xy
|
||||
fp.Mul(rhs, t, &P.z) // tz
|
||||
fp.Sub(lhs, lhs, rhs) // xy - tz
|
||||
eq1 := fp.IsZero(lhs)
|
||||
return eq0 && eq1
|
||||
}
|
||||
|
||||
// Generator returns the generator point.
|
||||
func (Curve) Generator() *Point {
|
||||
return &Point{
|
||||
x: genX,
|
||||
y: genY,
|
||||
z: fp.One(),
|
||||
ta: genX,
|
||||
tb: genY,
|
||||
}
|
||||
}
|
||||
|
||||
// Order returns the number of points in the prime subgroup.
|
||||
func (Curve) Order() Scalar { return order }
|
||||
|
||||
// Double returns 2P.
|
||||
func (Curve) Double(P *Point) *Point { R := *P; R.Double(); return &R }
|
||||
|
||||
// Add returns P+Q.
|
||||
func (Curve) Add(P, Q *Point) *Point { R := *P; R.Add(Q); return &R }
|
||||
|
||||
// ScalarMult returns kP. This function runs in constant time.
|
||||
func (e Curve) ScalarMult(k *Scalar, P *Point) *Point {
|
||||
k4 := &Scalar{}
|
||||
k4.divBy4(k)
|
||||
return e.pull(twistCurve{}.ScalarMult(k4, e.push(P)))
|
||||
}
|
||||
|
||||
// ScalarBaseMult returns kG where G is the generator point. This function runs in constant time.
|
||||
func (e Curve) ScalarBaseMult(k *Scalar) *Point {
|
||||
k4 := &Scalar{}
|
||||
k4.divBy4(k)
|
||||
return e.pull(twistCurve{}.ScalarBaseMult(k4))
|
||||
}
|
||||
|
||||
// CombinedMult returns mG+nP, where G is the generator point. This function is non-constant time.
|
||||
func (e Curve) CombinedMult(m, n *Scalar, P *Point) *Point {
|
||||
m4 := &Scalar{}
|
||||
n4 := &Scalar{}
|
||||
m4.divBy4(m)
|
||||
n4.divBy4(n)
|
||||
return e.pull(twistCurve{}.CombinedMult(m4, n4, twistCurve{}.pull(P)))
|
||||
}
|
||||
52
vendor/github.com/cloudflare/circl/ecc/goldilocks/isogeny.go
generated
vendored
Normal file
52
vendor/github.com/cloudflare/circl/ecc/goldilocks/isogeny.go
generated
vendored
Normal file
@ -0,0 +1,52 @@
|
||||
package goldilocks
|
||||
|
||||
import fp "github.com/cloudflare/circl/math/fp448"
|
||||
|
||||
func (Curve) pull(P *twistPoint) *Point { return twistCurve{}.push(P) }
|
||||
func (twistCurve) pull(P *Point) *twistPoint { return Curve{}.push(P) }
|
||||
|
||||
// push sends a point on the Goldilocks curve to a point on the twist curve.
|
||||
func (Curve) push(P *Point) *twistPoint {
|
||||
Q := &twistPoint{}
|
||||
Px, Py, Pz := &P.x, &P.y, &P.z
|
||||
a, b, c, d, e, f, g, h := &Q.x, &Q.y, &Q.z, &fp.Elt{}, &Q.ta, &Q.x, &Q.y, &Q.tb
|
||||
fp.Add(e, Px, Py) // x+y
|
||||
fp.Sqr(a, Px) // A = x^2
|
||||
fp.Sqr(b, Py) // B = y^2
|
||||
fp.Sqr(c, Pz) // z^2
|
||||
fp.Add(c, c, c) // C = 2*z^2
|
||||
*d = *a // D = A
|
||||
fp.Sqr(e, e) // (x+y)^2
|
||||
fp.Sub(e, e, a) // (x+y)^2-A
|
||||
fp.Sub(e, e, b) // E = (x+y)^2-A-B
|
||||
fp.Add(h, b, d) // H = B+D
|
||||
fp.Sub(g, b, d) // G = B-D
|
||||
fp.Sub(f, c, h) // F = C-H
|
||||
fp.Mul(&Q.z, f, g) // Z = F * G
|
||||
fp.Mul(&Q.x, e, f) // X = E * F
|
||||
fp.Mul(&Q.y, g, h) // Y = G * H, // T = E * H
|
||||
return Q
|
||||
}
|
||||
|
||||
// push sends a point on the twist curve to a point on the Goldilocks curve.
|
||||
func (twistCurve) push(P *twistPoint) *Point {
|
||||
Q := &Point{}
|
||||
Px, Py, Pz := &P.x, &P.y, &P.z
|
||||
a, b, c, d, e, f, g, h := &Q.x, &Q.y, &Q.z, &fp.Elt{}, &Q.ta, &Q.x, &Q.y, &Q.tb
|
||||
fp.Add(e, Px, Py) // x+y
|
||||
fp.Sqr(a, Px) // A = x^2
|
||||
fp.Sqr(b, Py) // B = y^2
|
||||
fp.Sqr(c, Pz) // z^2
|
||||
fp.Add(c, c, c) // C = 2*z^2
|
||||
fp.Neg(d, a) // D = -A
|
||||
fp.Sqr(e, e) // (x+y)^2
|
||||
fp.Sub(e, e, a) // (x+y)^2-A
|
||||
fp.Sub(e, e, b) // E = (x+y)^2-A-B
|
||||
fp.Add(h, b, d) // H = B+D
|
||||
fp.Sub(g, b, d) // G = B-D
|
||||
fp.Sub(f, c, h) // F = C-H
|
||||
fp.Mul(&Q.z, f, g) // Z = F * G
|
||||
fp.Mul(&Q.x, e, f) // X = E * F
|
||||
fp.Mul(&Q.y, g, h) // Y = G * H, // T = E * H
|
||||
return Q
|
||||
}
|
||||
171
vendor/github.com/cloudflare/circl/ecc/goldilocks/point.go
generated
vendored
Normal file
171
vendor/github.com/cloudflare/circl/ecc/goldilocks/point.go
generated
vendored
Normal file
@ -0,0 +1,171 @@
|
||||
package goldilocks
|
||||
|
||||
import (
|
||||
"errors"
|
||||
"fmt"
|
||||
|
||||
fp "github.com/cloudflare/circl/math/fp448"
|
||||
)
|
||||
|
||||
// Point is a point on the Goldilocks Curve.
|
||||
type Point struct{ x, y, z, ta, tb fp.Elt }
|
||||
|
||||
func (P Point) String() string {
|
||||
return fmt.Sprintf("x: %v\ny: %v\nz: %v\nta: %v\ntb: %v", P.x, P.y, P.z, P.ta, P.tb)
|
||||
}
|
||||
|
||||
// FromAffine creates a point from affine coordinates.
|
||||
func FromAffine(x, y *fp.Elt) (*Point, error) {
|
||||
P := &Point{
|
||||
x: *x,
|
||||
y: *y,
|
||||
z: fp.One(),
|
||||
ta: *x,
|
||||
tb: *y,
|
||||
}
|
||||
if !(Curve{}).IsOnCurve(P) {
|
||||
return P, errors.New("point not on curve")
|
||||
}
|
||||
return P, nil
|
||||
}
|
||||
|
||||
// isLessThan returns true if 0 <= x < y, and assumes that slices are of the
|
||||
// same length and are interpreted in little-endian order.
|
||||
func isLessThan(x, y []byte) bool {
|
||||
i := len(x) - 1
|
||||
for i > 0 && x[i] == y[i] {
|
||||
i--
|
||||
}
|
||||
return x[i] < y[i]
|
||||
}
|
||||
|
||||
// FromBytes returns a point from the input buffer.
|
||||
func FromBytes(in []byte) (*Point, error) {
|
||||
if len(in) < fp.Size+1 {
|
||||
return nil, errors.New("wrong input length")
|
||||
}
|
||||
err := errors.New("invalid decoding")
|
||||
P := &Point{}
|
||||
signX := in[fp.Size] >> 7
|
||||
copy(P.y[:], in[:fp.Size])
|
||||
p := fp.P()
|
||||
if !isLessThan(P.y[:], p[:]) {
|
||||
return nil, err
|
||||
}
|
||||
|
||||
u, v := &fp.Elt{}, &fp.Elt{}
|
||||
one := fp.One()
|
||||
fp.Sqr(u, &P.y) // u = y^2
|
||||
fp.Mul(v, u, ¶mD) // v = dy^2
|
||||
fp.Sub(u, u, &one) // u = y^2-1
|
||||
fp.Sub(v, v, &one) // v = dy^2-1
|
||||
isQR := fp.InvSqrt(&P.x, u, v) // x = sqrt(u/v)
|
||||
if !isQR {
|
||||
return nil, err
|
||||
}
|
||||
fp.Modp(&P.x) // x = x mod p
|
||||
if fp.IsZero(&P.x) && signX == 1 {
|
||||
return nil, err
|
||||
}
|
||||
if signX != (P.x[0] & 1) {
|
||||
fp.Neg(&P.x, &P.x)
|
||||
}
|
||||
P.ta = P.x
|
||||
P.tb = P.y
|
||||
P.z = fp.One()
|
||||
return P, nil
|
||||
}
|
||||
|
||||
// IsIdentity returns true is P is the identity Point.
|
||||
func (P *Point) IsIdentity() bool {
|
||||
return fp.IsZero(&P.x) && !fp.IsZero(&P.y) && !fp.IsZero(&P.z) && P.y == P.z
|
||||
}
|
||||
|
||||
// IsEqual returns true if P is equivalent to Q.
|
||||
func (P *Point) IsEqual(Q *Point) bool {
|
||||
l, r := &fp.Elt{}, &fp.Elt{}
|
||||
fp.Mul(l, &P.x, &Q.z)
|
||||
fp.Mul(r, &Q.x, &P.z)
|
||||
fp.Sub(l, l, r)
|
||||
b := fp.IsZero(l)
|
||||
fp.Mul(l, &P.y, &Q.z)
|
||||
fp.Mul(r, &Q.y, &P.z)
|
||||
fp.Sub(l, l, r)
|
||||
b = b && fp.IsZero(l)
|
||||
fp.Mul(l, &P.ta, &P.tb)
|
||||
fp.Mul(l, l, &Q.z)
|
||||
fp.Mul(r, &Q.ta, &Q.tb)
|
||||
fp.Mul(r, r, &P.z)
|
||||
fp.Sub(l, l, r)
|
||||
b = b && fp.IsZero(l)
|
||||
return b
|
||||
}
|
||||
|
||||
// Neg obtains the inverse of the Point.
|
||||
func (P *Point) Neg() { fp.Neg(&P.x, &P.x); fp.Neg(&P.ta, &P.ta) }
|
||||
|
||||
// ToAffine returns the x,y affine coordinates of P.
|
||||
func (P *Point) ToAffine() (x, y fp.Elt) {
|
||||
fp.Inv(&P.z, &P.z) // 1/z
|
||||
fp.Mul(&P.x, &P.x, &P.z) // x/z
|
||||
fp.Mul(&P.y, &P.y, &P.z) // y/z
|
||||
fp.Modp(&P.x)
|
||||
fp.Modp(&P.y)
|
||||
fp.SetOne(&P.z)
|
||||
P.ta = P.x
|
||||
P.tb = P.y
|
||||
return P.x, P.y
|
||||
}
|
||||
|
||||
// ToBytes stores P into a slice of bytes.
|
||||
func (P *Point) ToBytes(out []byte) error {
|
||||
if len(out) < fp.Size+1 {
|
||||
return errors.New("invalid decoding")
|
||||
}
|
||||
x, y := P.ToAffine()
|
||||
out[fp.Size] = (x[0] & 1) << 7
|
||||
return fp.ToBytes(out[:fp.Size], &y)
|
||||
}
|
||||
|
||||
// MarshalBinary encodes the receiver into a binary form and returns the result.
|
||||
func (P *Point) MarshalBinary() (data []byte, err error) {
|
||||
data = make([]byte, fp.Size+1)
|
||||
err = P.ToBytes(data[:fp.Size+1])
|
||||
return data, err
|
||||
}
|
||||
|
||||
// UnmarshalBinary must be able to decode the form generated by MarshalBinary.
|
||||
func (P *Point) UnmarshalBinary(data []byte) error { Q, err := FromBytes(data); *P = *Q; return err }
|
||||
|
||||
// Double sets P = 2Q.
|
||||
func (P *Point) Double() { P.Add(P) }
|
||||
|
||||
// Add sets P =P+Q..
|
||||
func (P *Point) Add(Q *Point) {
|
||||
// This is formula (5) from "Twisted Edwards Curves Revisited" by
|
||||
// Hisil H., Wong K.KH., Carter G., Dawson E. (2008)
|
||||
// https://doi.org/10.1007/978-3-540-89255-7_20
|
||||
x1, y1, z1, ta1, tb1 := &P.x, &P.y, &P.z, &P.ta, &P.tb
|
||||
x2, y2, z2, ta2, tb2 := &Q.x, &Q.y, &Q.z, &Q.ta, &Q.tb
|
||||
x3, y3, z3, E, H := &P.x, &P.y, &P.z, &P.ta, &P.tb
|
||||
A, B, C, D := &fp.Elt{}, &fp.Elt{}, &fp.Elt{}, &fp.Elt{}
|
||||
t1, t2, F, G := C, D, &fp.Elt{}, &fp.Elt{}
|
||||
fp.Mul(t1, ta1, tb1) // t1 = ta1*tb1
|
||||
fp.Mul(t2, ta2, tb2) // t2 = ta2*tb2
|
||||
fp.Mul(A, x1, x2) // A = x1*x2
|
||||
fp.Mul(B, y1, y2) // B = y1*y2
|
||||
fp.Mul(C, t1, t2) // t1*t2
|
||||
fp.Mul(C, C, ¶mD) // C = d*t1*t2
|
||||
fp.Mul(D, z1, z2) // D = z1*z2
|
||||
fp.Add(F, x1, y1) // x1+y1
|
||||
fp.Add(E, x2, y2) // x2+y2
|
||||
fp.Mul(E, E, F) // (x1+y1)*(x2+y2)
|
||||
fp.Sub(E, E, A) // (x1+y1)*(x2+y2)-A
|
||||
fp.Sub(E, E, B) // E = (x1+y1)*(x2+y2)-A-B
|
||||
fp.Sub(F, D, C) // F = D-C
|
||||
fp.Add(G, D, C) // G = D+C
|
||||
fp.Sub(H, B, A) // H = B-A
|
||||
fp.Mul(z3, F, G) // Z = F * G
|
||||
fp.Mul(x3, E, F) // X = E * F
|
||||
fp.Mul(y3, G, H) // Y = G * H, T = E * H
|
||||
}
|
||||
203
vendor/github.com/cloudflare/circl/ecc/goldilocks/scalar.go
generated
vendored
Normal file
203
vendor/github.com/cloudflare/circl/ecc/goldilocks/scalar.go
generated
vendored
Normal file
@ -0,0 +1,203 @@
|
||||
package goldilocks
|
||||
|
||||
import (
|
||||
"encoding/binary"
|
||||
"math/bits"
|
||||
)
|
||||
|
||||
// ScalarSize is the size (in bytes) of scalars.
|
||||
const ScalarSize = 56 // 448 / 8
|
||||
|
||||
// _N is the number of 64-bit words to store scalars.
|
||||
const _N = 7 // 448 / 64
|
||||
|
||||
// Scalar represents a positive integer stored in little-endian order.
|
||||
type Scalar [ScalarSize]byte
|
||||
|
||||
type scalar64 [_N]uint64
|
||||
|
||||
func (z *scalar64) fromScalar(x *Scalar) {
|
||||
z[0] = binary.LittleEndian.Uint64(x[0*8 : 1*8])
|
||||
z[1] = binary.LittleEndian.Uint64(x[1*8 : 2*8])
|
||||
z[2] = binary.LittleEndian.Uint64(x[2*8 : 3*8])
|
||||
z[3] = binary.LittleEndian.Uint64(x[3*8 : 4*8])
|
||||
z[4] = binary.LittleEndian.Uint64(x[4*8 : 5*8])
|
||||
z[5] = binary.LittleEndian.Uint64(x[5*8 : 6*8])
|
||||
z[6] = binary.LittleEndian.Uint64(x[6*8 : 7*8])
|
||||
}
|
||||
|
||||
func (z *scalar64) toScalar(x *Scalar) {
|
||||
binary.LittleEndian.PutUint64(x[0*8:1*8], z[0])
|
||||
binary.LittleEndian.PutUint64(x[1*8:2*8], z[1])
|
||||
binary.LittleEndian.PutUint64(x[2*8:3*8], z[2])
|
||||
binary.LittleEndian.PutUint64(x[3*8:4*8], z[3])
|
||||
binary.LittleEndian.PutUint64(x[4*8:5*8], z[4])
|
||||
binary.LittleEndian.PutUint64(x[5*8:6*8], z[5])
|
||||
binary.LittleEndian.PutUint64(x[6*8:7*8], z[6])
|
||||
}
|
||||
|
||||
// add calculates z = x + y. Assumes len(z) > max(len(x),len(y)).
|
||||
func add(z, x, y []uint64) uint64 {
|
||||
l, L, zz := len(x), len(y), y
|
||||
if l > L {
|
||||
l, L, zz = L, l, x
|
||||
}
|
||||
c := uint64(0)
|
||||
for i := 0; i < l; i++ {
|
||||
z[i], c = bits.Add64(x[i], y[i], c)
|
||||
}
|
||||
for i := l; i < L; i++ {
|
||||
z[i], c = bits.Add64(zz[i], 0, c)
|
||||
}
|
||||
return c
|
||||
}
|
||||
|
||||
// sub calculates z = x - y. Assumes len(z) > max(len(x),len(y)).
|
||||
func sub(z, x, y []uint64) uint64 {
|
||||
l, L, zz := len(x), len(y), y
|
||||
if l > L {
|
||||
l, L, zz = L, l, x
|
||||
}
|
||||
c := uint64(0)
|
||||
for i := 0; i < l; i++ {
|
||||
z[i], c = bits.Sub64(x[i], y[i], c)
|
||||
}
|
||||
for i := l; i < L; i++ {
|
||||
z[i], c = bits.Sub64(zz[i], 0, c)
|
||||
}
|
||||
return c
|
||||
}
|
||||
|
||||
// mulWord calculates z = x * y. Assumes len(z) >= len(x)+1.
|
||||
func mulWord(z, x []uint64, y uint64) {
|
||||
for i := range z {
|
||||
z[i] = 0
|
||||
}
|
||||
carry := uint64(0)
|
||||
for i := range x {
|
||||
hi, lo := bits.Mul64(x[i], y)
|
||||
lo, cc := bits.Add64(lo, z[i], 0)
|
||||
hi, _ = bits.Add64(hi, 0, cc)
|
||||
z[i], cc = bits.Add64(lo, carry, 0)
|
||||
carry, _ = bits.Add64(hi, 0, cc)
|
||||
}
|
||||
z[len(x)] = carry
|
||||
}
|
||||
|
||||
// Cmov moves x into z if b=1.
|
||||
func (z *scalar64) Cmov(b uint64, x *scalar64) {
|
||||
m := uint64(0) - b
|
||||
for i := range z {
|
||||
z[i] = (z[i] &^ m) | (x[i] & m)
|
||||
}
|
||||
}
|
||||
|
||||
// leftShift shifts to the left the words of z returning the more significant word.
|
||||
func (z *scalar64) leftShift(low uint64) uint64 {
|
||||
high := z[_N-1]
|
||||
for i := _N - 1; i > 0; i-- {
|
||||
z[i] = z[i-1]
|
||||
}
|
||||
z[0] = low
|
||||
return high
|
||||
}
|
||||
|
||||
// reduceOneWord calculates z = z + 2^448*x such that the result fits in a Scalar.
|
||||
func (z *scalar64) reduceOneWord(x uint64) {
|
||||
prod := (&scalar64{})[:]
|
||||
mulWord(prod, residue448[:], x)
|
||||
cc := add(z[:], z[:], prod)
|
||||
mulWord(prod, residue448[:], cc)
|
||||
add(z[:], z[:], prod)
|
||||
}
|
||||
|
||||
// modOrder reduces z mod order.
|
||||
func (z *scalar64) modOrder() {
|
||||
var o64, x scalar64
|
||||
o64.fromScalar(&order)
|
||||
// Performs: while (z >= order) { z = z-order }
|
||||
// At most 8 (eight) iterations reduce 3 bits by subtracting.
|
||||
for i := 0; i < 8; i++ {
|
||||
c := sub(x[:], z[:], o64[:]) // (c || x) = z-order
|
||||
z.Cmov(1-c, &x) // if c != 0 { z = x }
|
||||
}
|
||||
}
|
||||
|
||||
// FromBytes stores z = x mod order, where x is a number stored in little-endian order.
|
||||
func (z *Scalar) FromBytes(x []byte) {
|
||||
n := len(x)
|
||||
nCeil := (n + 7) >> 3
|
||||
for i := range z {
|
||||
z[i] = 0
|
||||
}
|
||||
if nCeil < _N {
|
||||
copy(z[:], x)
|
||||
return
|
||||
}
|
||||
copy(z[:], x[8*(nCeil-_N):])
|
||||
var z64 scalar64
|
||||
z64.fromScalar(z)
|
||||
for i := nCeil - _N - 1; i >= 0; i-- {
|
||||
low := binary.LittleEndian.Uint64(x[8*i:])
|
||||
high := z64.leftShift(low)
|
||||
z64.reduceOneWord(high)
|
||||
}
|
||||
z64.modOrder()
|
||||
z64.toScalar(z)
|
||||
}
|
||||
|
||||
// divBy4 calculates z = x/4 mod order.
|
||||
func (z *Scalar) divBy4(x *Scalar) { z.Mul(x, &invFour) }
|
||||
|
||||
// Red reduces z mod order.
|
||||
func (z *Scalar) Red() { var t scalar64; t.fromScalar(z); t.modOrder(); t.toScalar(z) }
|
||||
|
||||
// Neg calculates z = -z mod order.
|
||||
func (z *Scalar) Neg() { z.Sub(&order, z) }
|
||||
|
||||
// Add calculates z = x+y mod order.
|
||||
func (z *Scalar) Add(x, y *Scalar) {
|
||||
var z64, x64, y64, t scalar64
|
||||
x64.fromScalar(x)
|
||||
y64.fromScalar(y)
|
||||
c := add(z64[:], x64[:], y64[:])
|
||||
add(t[:], z64[:], residue448[:])
|
||||
z64.Cmov(c, &t)
|
||||
z64.modOrder()
|
||||
z64.toScalar(z)
|
||||
}
|
||||
|
||||
// Sub calculates z = x-y mod order.
|
||||
func (z *Scalar) Sub(x, y *Scalar) {
|
||||
var z64, x64, y64, t scalar64
|
||||
x64.fromScalar(x)
|
||||
y64.fromScalar(y)
|
||||
c := sub(z64[:], x64[:], y64[:])
|
||||
sub(t[:], z64[:], residue448[:])
|
||||
z64.Cmov(c, &t)
|
||||
z64.modOrder()
|
||||
z64.toScalar(z)
|
||||
}
|
||||
|
||||
// Mul calculates z = x*y mod order.
|
||||
func (z *Scalar) Mul(x, y *Scalar) {
|
||||
var z64, x64, y64 scalar64
|
||||
prod := (&[_N + 1]uint64{})[:]
|
||||
x64.fromScalar(x)
|
||||
y64.fromScalar(y)
|
||||
mulWord(prod, x64[:], y64[_N-1])
|
||||
copy(z64[:], prod[:_N])
|
||||
z64.reduceOneWord(prod[_N])
|
||||
for i := _N - 2; i >= 0; i-- {
|
||||
h := z64.leftShift(0)
|
||||
z64.reduceOneWord(h)
|
||||
mulWord(prod, x64[:], y64[i])
|
||||
c := add(z64[:], z64[:], prod[:_N])
|
||||
z64.reduceOneWord(prod[_N] + c)
|
||||
}
|
||||
z64.modOrder()
|
||||
z64.toScalar(z)
|
||||
}
|
||||
|
||||
// IsZero returns true if z=0.
|
||||
func (z *Scalar) IsZero() bool { z.Red(); return *z == Scalar{} }
|
||||
138
vendor/github.com/cloudflare/circl/ecc/goldilocks/twist.go
generated
vendored
Normal file
138
vendor/github.com/cloudflare/circl/ecc/goldilocks/twist.go
generated
vendored
Normal file
@ -0,0 +1,138 @@
|
||||
package goldilocks
|
||||
|
||||
import (
|
||||
"crypto/subtle"
|
||||
"math/bits"
|
||||
|
||||
"github.com/cloudflare/circl/internal/conv"
|
||||
"github.com/cloudflare/circl/math"
|
||||
fp "github.com/cloudflare/circl/math/fp448"
|
||||
)
|
||||
|
||||
// twistCurve is -x^2+y^2=1-39082x^2y^2 and is 4-isogeneous to Goldilocks.
|
||||
type twistCurve struct{}
|
||||
|
||||
// Identity returns the identity point.
|
||||
func (twistCurve) Identity() *twistPoint {
|
||||
return &twistPoint{
|
||||
y: fp.One(),
|
||||
z: fp.One(),
|
||||
}
|
||||
}
|
||||
|
||||
// subYDiv16 update x = (x - y) / 16.
|
||||
func subYDiv16(x *scalar64, y int64) {
|
||||
s := uint64(y >> 63)
|
||||
x0, b0 := bits.Sub64((*x)[0], uint64(y), 0)
|
||||
x1, b1 := bits.Sub64((*x)[1], s, b0)
|
||||
x2, b2 := bits.Sub64((*x)[2], s, b1)
|
||||
x3, b3 := bits.Sub64((*x)[3], s, b2)
|
||||
x4, b4 := bits.Sub64((*x)[4], s, b3)
|
||||
x5, b5 := bits.Sub64((*x)[5], s, b4)
|
||||
x6, _ := bits.Sub64((*x)[6], s, b5)
|
||||
x[0] = (x0 >> 4) | (x1 << 60)
|
||||
x[1] = (x1 >> 4) | (x2 << 60)
|
||||
x[2] = (x2 >> 4) | (x3 << 60)
|
||||
x[3] = (x3 >> 4) | (x4 << 60)
|
||||
x[4] = (x4 >> 4) | (x5 << 60)
|
||||
x[5] = (x5 >> 4) | (x6 << 60)
|
||||
x[6] = (x6 >> 4)
|
||||
}
|
||||
|
||||
func recodeScalar(d *[113]int8, k *Scalar) {
|
||||
var k64 scalar64
|
||||
k64.fromScalar(k)
|
||||
for i := 0; i < 112; i++ {
|
||||
d[i] = int8((k64[0] & 0x1f) - 16)
|
||||
subYDiv16(&k64, int64(d[i]))
|
||||
}
|
||||
d[112] = int8(k64[0])
|
||||
}
|
||||
|
||||
// ScalarMult returns kP.
|
||||
func (e twistCurve) ScalarMult(k *Scalar, P *twistPoint) *twistPoint {
|
||||
var TabP [8]preTwistPointProy
|
||||
var S preTwistPointProy
|
||||
var d [113]int8
|
||||
|
||||
var isZero int
|
||||
if k.IsZero() {
|
||||
isZero = 1
|
||||
}
|
||||
subtle.ConstantTimeCopy(isZero, k[:], order[:])
|
||||
|
||||
minusK := *k
|
||||
isEven := 1 - int(k[0]&0x1)
|
||||
minusK.Neg()
|
||||
subtle.ConstantTimeCopy(isEven, k[:], minusK[:])
|
||||
recodeScalar(&d, k)
|
||||
|
||||
P.oddMultiples(TabP[:])
|
||||
Q := e.Identity()
|
||||
for i := 112; i >= 0; i-- {
|
||||
Q.Double()
|
||||
Q.Double()
|
||||
Q.Double()
|
||||
Q.Double()
|
||||
mask := d[i] >> 7
|
||||
absDi := (d[i] + mask) ^ mask
|
||||
inx := int32((absDi - 1) >> 1)
|
||||
sig := int((d[i] >> 7) & 0x1)
|
||||
for j := range TabP {
|
||||
S.cmov(&TabP[j], uint(subtle.ConstantTimeEq(inx, int32(j))))
|
||||
}
|
||||
S.cneg(sig)
|
||||
Q.mixAdd(&S)
|
||||
}
|
||||
Q.cneg(uint(isEven))
|
||||
return Q
|
||||
}
|
||||
|
||||
const (
|
||||
omegaFix = 7
|
||||
omegaVar = 5
|
||||
)
|
||||
|
||||
// CombinedMult returns mG+nP.
|
||||
func (e twistCurve) CombinedMult(m, n *Scalar, P *twistPoint) *twistPoint {
|
||||
nafFix := math.OmegaNAF(conv.BytesLe2BigInt(m[:]), omegaFix)
|
||||
nafVar := math.OmegaNAF(conv.BytesLe2BigInt(n[:]), omegaVar)
|
||||
|
||||
if len(nafFix) > len(nafVar) {
|
||||
nafVar = append(nafVar, make([]int32, len(nafFix)-len(nafVar))...)
|
||||
} else if len(nafFix) < len(nafVar) {
|
||||
nafFix = append(nafFix, make([]int32, len(nafVar)-len(nafFix))...)
|
||||
}
|
||||
|
||||
var TabQ [1 << (omegaVar - 2)]preTwistPointProy
|
||||
P.oddMultiples(TabQ[:])
|
||||
Q := e.Identity()
|
||||
for i := len(nafFix) - 1; i >= 0; i-- {
|
||||
Q.Double()
|
||||
// Generator point
|
||||
if nafFix[i] != 0 {
|
||||
idxM := absolute(nafFix[i]) >> 1
|
||||
R := tabVerif[idxM]
|
||||
if nafFix[i] < 0 {
|
||||
R.neg()
|
||||
}
|
||||
Q.mixAddZ1(&R)
|
||||
}
|
||||
// Variable input point
|
||||
if nafVar[i] != 0 {
|
||||
idxN := absolute(nafVar[i]) >> 1
|
||||
S := TabQ[idxN]
|
||||
if nafVar[i] < 0 {
|
||||
S.neg()
|
||||
}
|
||||
Q.mixAdd(&S)
|
||||
}
|
||||
}
|
||||
return Q
|
||||
}
|
||||
|
||||
// absolute returns always a positive value.
|
||||
func absolute(x int32) int32 {
|
||||
mask := x >> 31
|
||||
return (x + mask) ^ mask
|
||||
}
|
||||
135
vendor/github.com/cloudflare/circl/ecc/goldilocks/twistPoint.go
generated
vendored
Normal file
135
vendor/github.com/cloudflare/circl/ecc/goldilocks/twistPoint.go
generated
vendored
Normal file
@ -0,0 +1,135 @@
|
||||
package goldilocks
|
||||
|
||||
import (
|
||||
"fmt"
|
||||
|
||||
fp "github.com/cloudflare/circl/math/fp448"
|
||||
)
|
||||
|
||||
type twistPoint struct{ x, y, z, ta, tb fp.Elt }
|
||||
|
||||
type preTwistPointAffine struct{ addYX, subYX, dt2 fp.Elt }
|
||||
|
||||
type preTwistPointProy struct {
|
||||
preTwistPointAffine
|
||||
z2 fp.Elt
|
||||
}
|
||||
|
||||
func (P *twistPoint) String() string {
|
||||
return fmt.Sprintf("x: %v\ny: %v\nz: %v\nta: %v\ntb: %v", P.x, P.y, P.z, P.ta, P.tb)
|
||||
}
|
||||
|
||||
// cneg conditionally negates the point if b=1.
|
||||
func (P *twistPoint) cneg(b uint) {
|
||||
t := &fp.Elt{}
|
||||
fp.Neg(t, &P.x)
|
||||
fp.Cmov(&P.x, t, b)
|
||||
fp.Neg(t, &P.ta)
|
||||
fp.Cmov(&P.ta, t, b)
|
||||
}
|
||||
|
||||
// Double updates P with 2P.
|
||||
func (P *twistPoint) Double() {
|
||||
// This is formula (7) from "Twisted Edwards Curves Revisited" by
|
||||
// Hisil H., Wong K.KH., Carter G., Dawson E. (2008)
|
||||
// https://doi.org/10.1007/978-3-540-89255-7_20
|
||||
Px, Py, Pz, Pta, Ptb := &P.x, &P.y, &P.z, &P.ta, &P.tb
|
||||
a, b, c, e, f, g, h := Px, Py, Pz, Pta, Px, Py, Ptb
|
||||
fp.Add(e, Px, Py) // x+y
|
||||
fp.Sqr(a, Px) // A = x^2
|
||||
fp.Sqr(b, Py) // B = y^2
|
||||
fp.Sqr(c, Pz) // z^2
|
||||
fp.Add(c, c, c) // C = 2*z^2
|
||||
fp.Add(h, a, b) // H = A+B
|
||||
fp.Sqr(e, e) // (x+y)^2
|
||||
fp.Sub(e, e, h) // E = (x+y)^2-A-B
|
||||
fp.Sub(g, b, a) // G = B-A
|
||||
fp.Sub(f, c, g) // F = C-G
|
||||
fp.Mul(Pz, f, g) // Z = F * G
|
||||
fp.Mul(Px, e, f) // X = E * F
|
||||
fp.Mul(Py, g, h) // Y = G * H, T = E * H
|
||||
}
|
||||
|
||||
// mixAdd calculates P= P+Q, where Q is a precomputed point with Z_Q = 1.
|
||||
func (P *twistPoint) mixAddZ1(Q *preTwistPointAffine) {
|
||||
fp.Add(&P.z, &P.z, &P.z) // D = 2*z1 (z2=1)
|
||||
P.coreAddition(Q)
|
||||
}
|
||||
|
||||
// coreAddition calculates P=P+Q for curves with A=-1.
|
||||
func (P *twistPoint) coreAddition(Q *preTwistPointAffine) {
|
||||
// This is the formula following (5) from "Twisted Edwards Curves Revisited" by
|
||||
// Hisil H., Wong K.KH., Carter G., Dawson E. (2008)
|
||||
// https://doi.org/10.1007/978-3-540-89255-7_20
|
||||
Px, Py, Pz, Pta, Ptb := &P.x, &P.y, &P.z, &P.ta, &P.tb
|
||||
addYX2, subYX2, dt2 := &Q.addYX, &Q.subYX, &Q.dt2
|
||||
a, b, c, d, e, f, g, h := Px, Py, &fp.Elt{}, Pz, Pta, Px, Py, Ptb
|
||||
fp.Mul(c, Pta, Ptb) // t1 = ta*tb
|
||||
fp.Sub(h, Py, Px) // y1-x1
|
||||
fp.Add(b, Py, Px) // y1+x1
|
||||
fp.Mul(a, h, subYX2) // A = (y1-x1)*(y2-x2)
|
||||
fp.Mul(b, b, addYX2) // B = (y1+x1)*(y2+x2)
|
||||
fp.Mul(c, c, dt2) // C = 2*D*t1*t2
|
||||
fp.Sub(e, b, a) // E = B-A
|
||||
fp.Add(h, b, a) // H = B+A
|
||||
fp.Sub(f, d, c) // F = D-C
|
||||
fp.Add(g, d, c) // G = D+C
|
||||
fp.Mul(Pz, f, g) // Z = F * G
|
||||
fp.Mul(Px, e, f) // X = E * F
|
||||
fp.Mul(Py, g, h) // Y = G * H, T = E * H
|
||||
}
|
||||
|
||||
func (P *preTwistPointAffine) neg() {
|
||||
P.addYX, P.subYX = P.subYX, P.addYX
|
||||
fp.Neg(&P.dt2, &P.dt2)
|
||||
}
|
||||
|
||||
func (P *preTwistPointAffine) cneg(b int) {
|
||||
t := &fp.Elt{}
|
||||
fp.Cswap(&P.addYX, &P.subYX, uint(b))
|
||||
fp.Neg(t, &P.dt2)
|
||||
fp.Cmov(&P.dt2, t, uint(b))
|
||||
}
|
||||
|
||||
func (P *preTwistPointAffine) cmov(Q *preTwistPointAffine, b uint) {
|
||||
fp.Cmov(&P.addYX, &Q.addYX, b)
|
||||
fp.Cmov(&P.subYX, &Q.subYX, b)
|
||||
fp.Cmov(&P.dt2, &Q.dt2, b)
|
||||
}
|
||||
|
||||
// mixAdd calculates P= P+Q, where Q is a precomputed point with Z_Q != 1.
|
||||
func (P *twistPoint) mixAdd(Q *preTwistPointProy) {
|
||||
fp.Mul(&P.z, &P.z, &Q.z2) // D = 2*z1*z2
|
||||
P.coreAddition(&Q.preTwistPointAffine)
|
||||
}
|
||||
|
||||
// oddMultiples calculates T[i] = (2*i-1)P for 0 < i < len(T).
|
||||
func (P *twistPoint) oddMultiples(T []preTwistPointProy) {
|
||||
if n := len(T); n > 0 {
|
||||
T[0].FromTwistPoint(P)
|
||||
_2P := *P
|
||||
_2P.Double()
|
||||
R := &preTwistPointProy{}
|
||||
R.FromTwistPoint(&_2P)
|
||||
for i := 1; i < n; i++ {
|
||||
P.mixAdd(R)
|
||||
T[i].FromTwistPoint(P)
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// cmov conditionally moves Q into P if b=1.
|
||||
func (P *preTwistPointProy) cmov(Q *preTwistPointProy, b uint) {
|
||||
P.preTwistPointAffine.cmov(&Q.preTwistPointAffine, b)
|
||||
fp.Cmov(&P.z2, &Q.z2, b)
|
||||
}
|
||||
|
||||
// FromTwistPoint precomputes some coordinates of Q for missed addition.
|
||||
func (P *preTwistPointProy) FromTwistPoint(Q *twistPoint) {
|
||||
fp.Add(&P.addYX, &Q.y, &Q.x) // addYX = X + Y
|
||||
fp.Sub(&P.subYX, &Q.y, &Q.x) // subYX = Y - X
|
||||
fp.Mul(&P.dt2, &Q.ta, &Q.tb) // T = ta*tb
|
||||
fp.Mul(&P.dt2, &P.dt2, ¶mDTwist) // D*T
|
||||
fp.Add(&P.dt2, &P.dt2, &P.dt2) // dt2 = 2*D*T
|
||||
fp.Add(&P.z2, &Q.z, &Q.z) // z2 = 2*Z
|
||||
}
|
||||
216
vendor/github.com/cloudflare/circl/ecc/goldilocks/twistTables.go
generated
vendored
Normal file
216
vendor/github.com/cloudflare/circl/ecc/goldilocks/twistTables.go
generated
vendored
Normal file
@ -0,0 +1,216 @@
|
||||
package goldilocks
|
||||
|
||||
import fp "github.com/cloudflare/circl/math/fp448"
|
||||
|
||||
var tabFixMult = [fxV][fx2w1]preTwistPointAffine{
|
||||
{
|
||||
{
|
||||
addYX: fp.Elt{0x65, 0x4a, 0xdd, 0xdf, 0xb4, 0x79, 0x60, 0xc8, 0xa1, 0x70, 0xb4, 0x3a, 0x1e, 0x0c, 0x9b, 0x19, 0xe5, 0x48, 0x3f, 0xd7, 0x44, 0x18, 0x18, 0x14, 0x14, 0x27, 0x45, 0xd0, 0x2b, 0x24, 0xd5, 0x93, 0xc3, 0x74, 0x4c, 0x50, 0x70, 0x43, 0x26, 0x05, 0x08, 0x24, 0xca, 0x78, 0x30, 0xc1, 0x06, 0x8d, 0xd4, 0x86, 0x42, 0xf0, 0x14, 0xde, 0x08, 0x05},
|
||||
subYX: fp.Elt{0x64, 0x4a, 0xdd, 0xdf, 0xb4, 0x79, 0x60, 0xc8, 0xa1, 0x70, 0xb4, 0x3a, 0x1e, 0x0c, 0x9b, 0x19, 0xe5, 0x48, 0x3f, 0xd7, 0x44, 0x18, 0x18, 0x14, 0x14, 0x27, 0x45, 0xd0, 0x2d, 0x24, 0xd5, 0x93, 0xc3, 0x74, 0x4c, 0x50, 0x70, 0x43, 0x26, 0x05, 0x08, 0x24, 0xca, 0x78, 0x30, 0xc1, 0x06, 0x8d, 0xd4, 0x86, 0x42, 0xf0, 0x14, 0xde, 0x08, 0x05},
|
||||
dt2: fp.Elt{0x1a, 0x33, 0xea, 0x64, 0x45, 0x1c, 0xdf, 0x17, 0x1d, 0x16, 0x34, 0x28, 0xd6, 0x61, 0x19, 0x67, 0x79, 0xb4, 0x13, 0xcf, 0x3e, 0x7c, 0x0e, 0x72, 0xda, 0xf1, 0x5f, 0xda, 0xe6, 0xcf, 0x42, 0xd3, 0xb6, 0x17, 0xc2, 0x68, 0x13, 0x2d, 0xd9, 0x60, 0x3e, 0xae, 0xf0, 0x5b, 0x96, 0xf0, 0xcd, 0xaf, 0xea, 0xb7, 0x0d, 0x59, 0x16, 0xa7, 0xff, 0x55},
|
||||
},
|
||||
{
|
||||
addYX: fp.Elt{0xca, 0xd8, 0x7d, 0x86, 0x1a, 0xef, 0xad, 0x11, 0xe3, 0x27, 0x41, 0x7e, 0x7f, 0x3e, 0xa9, 0xd2, 0xb5, 0x4e, 0x50, 0xe0, 0x77, 0x91, 0xc2, 0x13, 0x52, 0x73, 0x41, 0x09, 0xa6, 0x57, 0x9a, 0xc8, 0xa8, 0x90, 0x9d, 0x26, 0x14, 0xbb, 0xa1, 0x2a, 0xf7, 0x45, 0x43, 0x4e, 0xea, 0x35, 0x62, 0xe1, 0x08, 0x85, 0x46, 0xb8, 0x24, 0x05, 0x2d, 0xab},
|
||||
subYX: fp.Elt{0x9b, 0xe6, 0xd3, 0xe5, 0xfe, 0x50, 0x36, 0x3c, 0x3c, 0x6d, 0x74, 0x1d, 0x74, 0xc0, 0xde, 0x5b, 0x45, 0x27, 0xe5, 0x12, 0xee, 0x63, 0x35, 0x6b, 0x13, 0xe2, 0x41, 0x6b, 0x3a, 0x05, 0x2b, 0xb1, 0x89, 0x26, 0xb6, 0xc6, 0xd1, 0x84, 0xff, 0x0e, 0x9b, 0xa3, 0xfb, 0x21, 0x36, 0x6b, 0x01, 0xf7, 0x9f, 0x7c, 0xeb, 0xf5, 0x18, 0x7a, 0x2a, 0x70},
|
||||
dt2: fp.Elt{0x09, 0xad, 0x99, 0x1a, 0x38, 0xd3, 0xdf, 0x22, 0x37, 0x32, 0x61, 0x8b, 0xf3, 0x19, 0x48, 0x08, 0xe8, 0x49, 0xb6, 0x4a, 0xa7, 0xed, 0xa4, 0xa2, 0xee, 0x86, 0xd7, 0x31, 0x5e, 0xce, 0x95, 0x76, 0x86, 0x42, 0x1c, 0x9d, 0x07, 0x14, 0x8c, 0x34, 0x18, 0x9c, 0x6d, 0x3a, 0xdf, 0xa9, 0xe8, 0x36, 0x7e, 0xe4, 0x95, 0xbe, 0xb5, 0x09, 0xf8, 0x9c},
|
||||
},
|
||||
{
|
||||
addYX: fp.Elt{0x51, 0xdb, 0x49, 0xa8, 0x9f, 0xe3, 0xd7, 0xec, 0x0d, 0x0f, 0x49, 0xe8, 0xb6, 0xc5, 0x0f, 0x5a, 0x1c, 0xce, 0x54, 0x0d, 0xb1, 0x8d, 0x5b, 0xbf, 0xf4, 0xaa, 0x34, 0x77, 0xc4, 0x5d, 0x59, 0xb6, 0xc5, 0x0e, 0x5a, 0xd8, 0x5b, 0x30, 0xc2, 0x1d, 0xec, 0x85, 0x1c, 0x42, 0xbe, 0x24, 0x2e, 0x50, 0x55, 0x44, 0xb2, 0x3a, 0x01, 0xaa, 0x98, 0xfb},
|
||||
subYX: fp.Elt{0xe7, 0x29, 0xb7, 0xd0, 0xaa, 0x4f, 0x32, 0x53, 0x56, 0xde, 0xbc, 0xd1, 0x92, 0x5d, 0x19, 0xbe, 0xa3, 0xe3, 0x75, 0x48, 0xe0, 0x7a, 0x1b, 0x54, 0x7a, 0xb7, 0x41, 0x77, 0x84, 0x38, 0xdd, 0x14, 0x9f, 0xca, 0x3f, 0xa3, 0xc8, 0xa7, 0x04, 0x70, 0xf1, 0x4d, 0x3d, 0xb3, 0x84, 0x79, 0xcb, 0xdb, 0xe4, 0xc5, 0x42, 0x9b, 0x57, 0x19, 0xf1, 0x2d},
|
||||
dt2: fp.Elt{0x20, 0xb4, 0x94, 0x9e, 0xdf, 0x31, 0x44, 0x0b, 0xc9, 0x7b, 0x75, 0x40, 0x9d, 0xd1, 0x96, 0x39, 0x70, 0x71, 0x15, 0xc8, 0x93, 0xd5, 0xc5, 0xe5, 0xba, 0xfe, 0xee, 0x08, 0x6a, 0x98, 0x0a, 0x1b, 0xb2, 0xaa, 0x3a, 0xf4, 0xa4, 0x79, 0xf9, 0x8e, 0x4d, 0x65, 0x10, 0x9b, 0x3a, 0x6e, 0x7c, 0x87, 0x94, 0x92, 0x11, 0x65, 0xbf, 0x1a, 0x09, 0xde},
|
||||
},
|
||||
{
|
||||
addYX: fp.Elt{0xf3, 0x84, 0x76, 0x77, 0xa5, 0x6b, 0x27, 0x3b, 0x83, 0x3d, 0xdf, 0xa0, 0xeb, 0x32, 0x6d, 0x58, 0x81, 0x57, 0x64, 0xc2, 0x21, 0x7c, 0x9b, 0xea, 0xe6, 0xb0, 0x93, 0xf9, 0xe7, 0xc3, 0xed, 0x5a, 0x8e, 0xe2, 0xb4, 0x72, 0x76, 0x66, 0x0f, 0x22, 0x29, 0x94, 0x3e, 0x63, 0x48, 0x5e, 0x80, 0xcb, 0xac, 0xfa, 0x95, 0xb6, 0x4b, 0xc4, 0x95, 0x33},
|
||||
subYX: fp.Elt{0x0c, 0x55, 0xd1, 0x5e, 0x5f, 0xbf, 0xbf, 0xe2, 0x4c, 0xfc, 0x37, 0x4a, 0xc4, 0xb1, 0xf4, 0x83, 0x61, 0x93, 0x60, 0x8e, 0x9f, 0x31, 0xf0, 0xa0, 0x41, 0xff, 0x1d, 0xe2, 0x7f, 0xca, 0x40, 0xd6, 0x88, 0xe8, 0x91, 0x61, 0xe2, 0x11, 0x18, 0x83, 0xf3, 0x25, 0x2f, 0x3f, 0x49, 0x40, 0xd4, 0x83, 0xe2, 0xd7, 0x74, 0x6a, 0x16, 0x86, 0x4e, 0xab},
|
||||
dt2: fp.Elt{0xdd, 0x58, 0x65, 0xd8, 0x9f, 0xdd, 0x70, 0x7f, 0x0f, 0xec, 0xbd, 0x5c, 0x5c, 0x9b, 0x7e, 0x1b, 0x9f, 0x79, 0x36, 0x1f, 0xfd, 0x79, 0x10, 0x1c, 0x52, 0xf3, 0x22, 0xa4, 0x1f, 0x71, 0x6e, 0x63, 0x14, 0xf4, 0xa7, 0x3e, 0xbe, 0xad, 0x43, 0x30, 0x38, 0x8c, 0x29, 0xc6, 0xcf, 0x50, 0x75, 0x21, 0xe5, 0x78, 0xfd, 0xb0, 0x9a, 0xc4, 0x6d, 0xd4},
|
||||
},
|
||||
},
|
||||
{
|
||||
{
|
||||
addYX: fp.Elt{0x7a, 0xa1, 0x38, 0xa6, 0xfd, 0x0e, 0x96, 0xd5, 0x26, 0x76, 0x86, 0x70, 0x80, 0x30, 0xa6, 0x67, 0xeb, 0xf4, 0x39, 0xdb, 0x22, 0xf5, 0x9f, 0x98, 0xe4, 0xb5, 0x3a, 0x0c, 0x59, 0xbf, 0x85, 0xc6, 0xf0, 0x0b, 0x1c, 0x41, 0x38, 0x09, 0x01, 0xdb, 0xd6, 0x3c, 0xb7, 0xf1, 0x08, 0x6b, 0x4b, 0x9e, 0x63, 0x53, 0x83, 0xd3, 0xab, 0xa3, 0x72, 0x0d},
|
||||
subYX: fp.Elt{0x84, 0x68, 0x25, 0xe8, 0xe9, 0x8f, 0x91, 0xbf, 0xf7, 0xa4, 0x30, 0xae, 0xea, 0x9f, 0xdd, 0x56, 0x64, 0x09, 0xc9, 0x54, 0x68, 0x4e, 0x33, 0xc5, 0x6f, 0x7b, 0x2d, 0x52, 0x2e, 0x42, 0xbe, 0xbe, 0xf5, 0x64, 0xbf, 0x77, 0x54, 0xdf, 0xb0, 0x10, 0xd2, 0x16, 0x5d, 0xce, 0xaf, 0x9f, 0xfb, 0xa3, 0x63, 0x50, 0xcb, 0xc0, 0xd0, 0x88, 0x44, 0xa3},
|
||||
dt2: fp.Elt{0xc3, 0x8b, 0xa5, 0xf1, 0x44, 0xe4, 0x41, 0xcd, 0x75, 0xe3, 0x17, 0x69, 0x5b, 0xb9, 0xbb, 0xee, 0x82, 0xbb, 0xce, 0x57, 0xdf, 0x2a, 0x9c, 0x12, 0xab, 0x66, 0x08, 0x68, 0x05, 0x1b, 0x87, 0xee, 0x5d, 0x1e, 0x18, 0x14, 0x22, 0x4b, 0x99, 0x61, 0x75, 0x28, 0xe7, 0x65, 0x1c, 0x36, 0xb6, 0x18, 0x09, 0xa8, 0xdf, 0xef, 0x30, 0x35, 0xbc, 0x58},
|
||||
},
|
||||
{
|
||||
addYX: fp.Elt{0xc5, 0xd3, 0x0e, 0x6f, 0xaf, 0x06, 0x69, 0xc4, 0x07, 0x9e, 0x58, 0x6e, 0x3f, 0x49, 0xd9, 0x0a, 0x3c, 0x2c, 0x37, 0xcd, 0x27, 0x4d, 0x87, 0x91, 0x7a, 0xb0, 0x28, 0xad, 0x2f, 0x68, 0x92, 0x05, 0x97, 0xf1, 0x30, 0x5f, 0x4c, 0x10, 0x20, 0x30, 0xd3, 0x08, 0x3f, 0xc1, 0xc6, 0xb7, 0xb5, 0xd1, 0x71, 0x7b, 0xa8, 0x0a, 0xd8, 0xf5, 0x17, 0xcf},
|
||||
subYX: fp.Elt{0x64, 0xd4, 0x8f, 0x91, 0x40, 0xab, 0x6e, 0x1a, 0x62, 0x83, 0xdc, 0xd7, 0x30, 0x1a, 0x4a, 0x2a, 0x4c, 0x54, 0x86, 0x19, 0x81, 0x5d, 0x04, 0x52, 0xa3, 0xca, 0x82, 0x38, 0xdc, 0x1e, 0xf0, 0x7a, 0x78, 0x76, 0x49, 0x4f, 0x71, 0xc4, 0x74, 0x2f, 0xf0, 0x5b, 0x2e, 0x5e, 0xac, 0xef, 0x17, 0xe4, 0x8e, 0x6e, 0xed, 0x43, 0x23, 0x61, 0x99, 0x49},
|
||||
dt2: fp.Elt{0x64, 0x90, 0x72, 0x76, 0xf8, 0x2c, 0x7d, 0x57, 0xf9, 0x30, 0x5e, 0x7a, 0x10, 0x74, 0x19, 0x39, 0xd9, 0xaf, 0x0a, 0xf1, 0x43, 0xed, 0x88, 0x9c, 0x8b, 0xdc, 0x9b, 0x1c, 0x90, 0xe7, 0xf7, 0xa3, 0xa5, 0x0d, 0xc6, 0xbc, 0x30, 0xfb, 0x91, 0x1a, 0x51, 0xba, 0x2d, 0xbe, 0x89, 0xdf, 0x1d, 0xdc, 0x53, 0xa8, 0x82, 0x8a, 0xd3, 0x8d, 0x16, 0x68},
|
||||
},
|
||||
{
|
||||
addYX: fp.Elt{0xef, 0x5c, 0xe3, 0x74, 0xbf, 0x13, 0x4a, 0xbf, 0x66, 0x73, 0x64, 0xb7, 0xd4, 0xce, 0x98, 0x82, 0x05, 0xfa, 0x98, 0x0c, 0x0a, 0xae, 0xe5, 0x6b, 0x9f, 0xac, 0xbb, 0x6e, 0x1f, 0xcf, 0xff, 0xa6, 0x71, 0x9a, 0xa8, 0x7a, 0x9e, 0x64, 0x1f, 0x20, 0x4a, 0x61, 0xa2, 0xd6, 0x50, 0xe3, 0xba, 0x81, 0x0c, 0x50, 0x59, 0x69, 0x59, 0x15, 0x55, 0xdb},
|
||||
subYX: fp.Elt{0xe8, 0x77, 0x4d, 0xe8, 0x66, 0x3d, 0xc1, 0x00, 0x3c, 0xf2, 0x25, 0x00, 0xdc, 0xb2, 0xe5, 0x9b, 0x12, 0x89, 0xf3, 0xd6, 0xea, 0x85, 0x60, 0xfe, 0x67, 0x91, 0xfd, 0x04, 0x7c, 0xe0, 0xf1, 0x86, 0x06, 0x11, 0x66, 0xee, 0xd4, 0xd5, 0xbe, 0x3b, 0x0f, 0xe3, 0x59, 0xb3, 0x4f, 0x00, 0xb6, 0xce, 0x80, 0xc1, 0x61, 0xf7, 0xaf, 0x04, 0x6a, 0x3c},
|
||||
dt2: fp.Elt{0x00, 0xd7, 0x32, 0x93, 0x67, 0x70, 0x6f, 0xd7, 0x69, 0xab, 0xb1, 0xd3, 0xdc, 0xd6, 0xa8, 0xdd, 0x35, 0x25, 0xca, 0xd3, 0x8a, 0x6d, 0xce, 0xfb, 0xfd, 0x2b, 0x83, 0xf0, 0xd4, 0xac, 0x66, 0xfb, 0x72, 0x87, 0x7e, 0x55, 0xb7, 0x91, 0x58, 0x10, 0xc3, 0x11, 0x7e, 0x15, 0xfe, 0x7c, 0x55, 0x90, 0xa3, 0x9e, 0xed, 0x9a, 0x7f, 0xa7, 0xb7, 0xeb},
|
||||
},
|
||||
{
|
||||
addYX: fp.Elt{0x25, 0x0f, 0xc2, 0x09, 0x9c, 0x10, 0xc8, 0x7c, 0x93, 0xa7, 0xbe, 0xe9, 0x26, 0x25, 0x7c, 0x21, 0xfe, 0xe7, 0x5f, 0x3c, 0x02, 0x83, 0xa7, 0x9e, 0xdf, 0xc0, 0x94, 0x2b, 0x7d, 0x1a, 0xd0, 0x1d, 0xcc, 0x2e, 0x7d, 0xd4, 0x85, 0xe7, 0xc1, 0x15, 0x66, 0xd6, 0xd6, 0x32, 0xb8, 0xf7, 0x63, 0xaa, 0x3b, 0xa5, 0xea, 0x49, 0xad, 0x88, 0x9b, 0x66},
|
||||
subYX: fp.Elt{0x09, 0x97, 0x79, 0x36, 0x41, 0x56, 0x9b, 0xdf, 0x15, 0xd8, 0x43, 0x28, 0x17, 0x5b, 0x96, 0xc9, 0xcf, 0x39, 0x1f, 0x13, 0xf7, 0x4d, 0x1d, 0x1f, 0xda, 0x51, 0x56, 0xe7, 0x0a, 0x5a, 0x65, 0xb6, 0x2a, 0x87, 0x49, 0x86, 0xc2, 0x2b, 0xcd, 0xfe, 0x07, 0xf6, 0x4c, 0xe2, 0x1d, 0x9b, 0xd8, 0x82, 0x09, 0x5b, 0x11, 0x10, 0x62, 0x56, 0x89, 0xbd},
|
||||
dt2: fp.Elt{0xd9, 0x15, 0x73, 0xf2, 0x96, 0x35, 0x53, 0xb0, 0xe7, 0xa8, 0x0b, 0x93, 0x35, 0x0b, 0x3a, 0x00, 0xf5, 0x18, 0xb1, 0xc3, 0x12, 0x3f, 0x91, 0x17, 0xc1, 0x4c, 0x15, 0x5a, 0x86, 0x92, 0x11, 0xbd, 0x44, 0x40, 0x5a, 0x7b, 0x15, 0x89, 0xba, 0xc1, 0xc1, 0xbc, 0x43, 0x45, 0xe6, 0x52, 0x02, 0x73, 0x0a, 0xd0, 0x2a, 0x19, 0xda, 0x47, 0xa8, 0xff},
|
||||
},
|
||||
},
|
||||
}
|
||||
|
||||
// tabVerif contains the odd multiples of P. The entry T[i] = (2i+1)P, where
|
||||
// P = phi(G) and G is the generator of the Goldilocks curve, and phi is a
|
||||
// 4-degree isogeny.
|
||||
var tabVerif = [1 << (omegaFix - 2)]preTwistPointAffine{
|
||||
{ /* 1P*/
|
||||
addYX: fp.Elt{0x65, 0x4a, 0xdd, 0xdf, 0xb4, 0x79, 0x60, 0xc8, 0xa1, 0x70, 0xb4, 0x3a, 0x1e, 0x0c, 0x9b, 0x19, 0xe5, 0x48, 0x3f, 0xd7, 0x44, 0x18, 0x18, 0x14, 0x14, 0x27, 0x45, 0xd0, 0x2b, 0x24, 0xd5, 0x93, 0xc3, 0x74, 0x4c, 0x50, 0x70, 0x43, 0x26, 0x05, 0x08, 0x24, 0xca, 0x78, 0x30, 0xc1, 0x06, 0x8d, 0xd4, 0x86, 0x42, 0xf0, 0x14, 0xde, 0x08, 0x05},
|
||||
subYX: fp.Elt{0x64, 0x4a, 0xdd, 0xdf, 0xb4, 0x79, 0x60, 0xc8, 0xa1, 0x70, 0xb4, 0x3a, 0x1e, 0x0c, 0x9b, 0x19, 0xe5, 0x48, 0x3f, 0xd7, 0x44, 0x18, 0x18, 0x14, 0x14, 0x27, 0x45, 0xd0, 0x2d, 0x24, 0xd5, 0x93, 0xc3, 0x74, 0x4c, 0x50, 0x70, 0x43, 0x26, 0x05, 0x08, 0x24, 0xca, 0x78, 0x30, 0xc1, 0x06, 0x8d, 0xd4, 0x86, 0x42, 0xf0, 0x14, 0xde, 0x08, 0x05},
|
||||
dt2: fp.Elt{0x1a, 0x33, 0xea, 0x64, 0x45, 0x1c, 0xdf, 0x17, 0x1d, 0x16, 0x34, 0x28, 0xd6, 0x61, 0x19, 0x67, 0x79, 0xb4, 0x13, 0xcf, 0x3e, 0x7c, 0x0e, 0x72, 0xda, 0xf1, 0x5f, 0xda, 0xe6, 0xcf, 0x42, 0xd3, 0xb6, 0x17, 0xc2, 0x68, 0x13, 0x2d, 0xd9, 0x60, 0x3e, 0xae, 0xf0, 0x5b, 0x96, 0xf0, 0xcd, 0xaf, 0xea, 0xb7, 0x0d, 0x59, 0x16, 0xa7, 0xff, 0x55},
|
||||
},
|
||||
{ /* 3P*/
|
||||
addYX: fp.Elt{0xd1, 0xe9, 0xa8, 0x33, 0x20, 0x76, 0x18, 0x08, 0x45, 0x2a, 0xc9, 0x67, 0x2a, 0xc3, 0x15, 0x24, 0xf9, 0x74, 0x21, 0x30, 0x99, 0x59, 0x8b, 0xb2, 0xf0, 0xa4, 0x07, 0xe2, 0x6a, 0x36, 0x8d, 0xd9, 0xd2, 0x4a, 0x7f, 0x73, 0x50, 0x39, 0x3d, 0xaa, 0xa7, 0x51, 0x73, 0x0d, 0x2b, 0x8b, 0x96, 0x47, 0xac, 0x3c, 0x5d, 0xaa, 0x39, 0x9c, 0xcf, 0xd5},
|
||||
subYX: fp.Elt{0x6b, 0x11, 0x5d, 0x1a, 0xf9, 0x41, 0x9d, 0xc5, 0x30, 0x3e, 0xad, 0x25, 0x2c, 0x04, 0x45, 0xea, 0xcc, 0x67, 0x07, 0x85, 0xe9, 0xda, 0x0e, 0xb5, 0x40, 0xb7, 0x32, 0xb4, 0x49, 0xdd, 0xff, 0xaa, 0xfc, 0xbb, 0x19, 0xca, 0x8b, 0x79, 0x2b, 0x8f, 0x8d, 0x00, 0x33, 0xc2, 0xad, 0xe9, 0xd3, 0x12, 0xa8, 0xaa, 0x87, 0x62, 0xad, 0x2d, 0xff, 0xa4},
|
||||
dt2: fp.Elt{0xb0, 0xaf, 0x3b, 0xea, 0xf0, 0x42, 0x0b, 0x5e, 0x88, 0xd3, 0x98, 0x08, 0x87, 0x59, 0x72, 0x0a, 0xc2, 0xdf, 0xcb, 0x7f, 0x59, 0xb5, 0x4c, 0x63, 0x68, 0xe8, 0x41, 0x38, 0x67, 0x4f, 0xe9, 0xc6, 0xb2, 0x6b, 0x08, 0xa7, 0xf7, 0x0e, 0xcd, 0xea, 0xca, 0x3d, 0xaf, 0x8e, 0xda, 0x4b, 0x2e, 0xd2, 0x88, 0x64, 0x8d, 0xc5, 0x5f, 0x76, 0x0f, 0x3d},
|
||||
},
|
||||
{ /* 5P*/
|
||||
addYX: fp.Elt{0xe5, 0x65, 0xc9, 0xe2, 0x75, 0xf0, 0x7d, 0x1a, 0xba, 0xa4, 0x40, 0x4b, 0x93, 0x12, 0xa2, 0x80, 0x95, 0x0d, 0x03, 0x93, 0xe8, 0xa5, 0x4d, 0xe2, 0x3d, 0x81, 0xf5, 0xce, 0xd4, 0x2d, 0x25, 0x59, 0x16, 0x5c, 0xe7, 0xda, 0xc7, 0x45, 0xd2, 0x7e, 0x2c, 0x38, 0xd4, 0x37, 0x64, 0xb2, 0xc2, 0x28, 0xc5, 0x72, 0x16, 0x32, 0x45, 0x36, 0x6f, 0x9f},
|
||||
subYX: fp.Elt{0x09, 0xf4, 0x7e, 0xbd, 0x89, 0xdb, 0x19, 0x58, 0xe1, 0x08, 0x00, 0x8a, 0xf4, 0x5f, 0x2a, 0x32, 0x40, 0xf0, 0x2c, 0x3f, 0x5d, 0xe4, 0xfc, 0x89, 0x11, 0x24, 0xb4, 0x2f, 0x97, 0xad, 0xac, 0x8f, 0x19, 0xab, 0xfa, 0x12, 0xe5, 0xf9, 0x50, 0x4e, 0x50, 0x6f, 0x32, 0x30, 0x88, 0xa6, 0xe5, 0x48, 0x28, 0xa2, 0x1b, 0x9f, 0xcd, 0xe2, 0x43, 0x38},
|
||||
dt2: fp.Elt{0xa9, 0xcc, 0x53, 0x39, 0x86, 0x02, 0x60, 0x75, 0x34, 0x99, 0x57, 0xbd, 0xfc, 0x5a, 0x8e, 0xce, 0x5e, 0x98, 0x22, 0xd0, 0xa5, 0x24, 0xff, 0x90, 0x28, 0x9f, 0x58, 0xf3, 0x39, 0xe9, 0xba, 0x36, 0x23, 0xfb, 0x7f, 0x41, 0xcc, 0x2b, 0x5a, 0x25, 0x3f, 0x4c, 0x2a, 0xf1, 0x52, 0x6f, 0x2f, 0x07, 0xe3, 0x88, 0x81, 0x77, 0xdd, 0x7c, 0x88, 0x82},
|
||||
},
|
||||
{ /* 7P*/
|
||||
addYX: fp.Elt{0xf7, 0xee, 0x88, 0xfd, 0x3a, 0xbf, 0x7e, 0x28, 0x39, 0x23, 0x79, 0xe6, 0x5c, 0x56, 0xcb, 0xb5, 0x48, 0x6a, 0x80, 0x6d, 0x37, 0x60, 0x6c, 0x10, 0x35, 0x49, 0x4b, 0x46, 0x60, 0xd4, 0x79, 0xd4, 0x53, 0xd3, 0x67, 0x88, 0xd0, 0x41, 0xd5, 0x43, 0x85, 0xc8, 0x71, 0xe3, 0x1c, 0xb6, 0xda, 0x22, 0x64, 0x8f, 0x80, 0xac, 0xad, 0x7d, 0xd5, 0x82},
|
||||
subYX: fp.Elt{0x92, 0x40, 0xc1, 0x83, 0x21, 0x9b, 0xd5, 0x7d, 0x3f, 0x29, 0xb6, 0x26, 0xef, 0x12, 0xb9, 0x27, 0x39, 0x42, 0x37, 0x97, 0x09, 0x9a, 0x08, 0xe1, 0x68, 0xb6, 0x7a, 0x3f, 0x9f, 0x45, 0xf8, 0x37, 0x19, 0x83, 0x97, 0xe6, 0x73, 0x30, 0x32, 0x35, 0xcf, 0xae, 0x5c, 0x12, 0x68, 0xdf, 0x6e, 0x2b, 0xde, 0x83, 0xa0, 0x44, 0x74, 0x2e, 0x4a, 0xe9},
|
||||
dt2: fp.Elt{0xcb, 0x22, 0x0a, 0xda, 0x6b, 0xc1, 0x8a, 0x29, 0xa1, 0xac, 0x8b, 0x5b, 0x8b, 0x32, 0x20, 0xf2, 0x21, 0xae, 0x0c, 0x43, 0xc4, 0xd7, 0x19, 0x37, 0x3d, 0x79, 0x25, 0x98, 0x6c, 0x9c, 0x22, 0x31, 0x2a, 0x55, 0x9f, 0xda, 0x5e, 0xa8, 0x13, 0xdb, 0x8e, 0x2e, 0x16, 0x39, 0xf4, 0x91, 0x6f, 0xec, 0x71, 0x71, 0xc9, 0x10, 0xf2, 0xa4, 0x8f, 0x11},
|
||||
},
|
||||
{ /* 9P*/
|
||||
addYX: fp.Elt{0x85, 0xdd, 0x37, 0x62, 0x74, 0x8e, 0x33, 0x5b, 0x25, 0x12, 0x1b, 0xe7, 0xdf, 0x47, 0xe5, 0x12, 0xfd, 0x3a, 0x3a, 0xf5, 0x5d, 0x4c, 0xa2, 0x29, 0x3c, 0x5c, 0x2f, 0xee, 0x18, 0x19, 0x0a, 0x2b, 0xef, 0x67, 0x50, 0x7a, 0x0d, 0x29, 0xae, 0x55, 0x82, 0xcd, 0xd6, 0x41, 0x90, 0xb4, 0x13, 0x31, 0x5d, 0x11, 0xb8, 0xaa, 0x12, 0x86, 0x08, 0xac},
|
||||
subYX: fp.Elt{0xcc, 0x37, 0x8d, 0x83, 0x5f, 0xfd, 0xde, 0xd5, 0xf7, 0xf1, 0xae, 0x0a, 0xa7, 0x0b, 0xeb, 0x6d, 0x19, 0x8a, 0xb6, 0x1a, 0x59, 0xd8, 0xff, 0x3c, 0xbc, 0xbc, 0xef, 0x9c, 0xda, 0x7b, 0x75, 0x12, 0xaf, 0x80, 0x8f, 0x2c, 0x3c, 0xaa, 0x0b, 0x17, 0x86, 0x36, 0x78, 0x18, 0xc8, 0x8a, 0xf6, 0xb8, 0x2c, 0x2f, 0x57, 0x2c, 0x62, 0x57, 0xf6, 0x90},
|
||||
dt2: fp.Elt{0x83, 0xbc, 0xa2, 0x07, 0xa5, 0x38, 0x96, 0xea, 0xfe, 0x11, 0x46, 0x1d, 0x3b, 0xcd, 0x42, 0xc5, 0xee, 0x67, 0x04, 0x72, 0x08, 0xd8, 0xd9, 0x96, 0x07, 0xf7, 0xac, 0xc3, 0x64, 0xf1, 0x98, 0x2c, 0x55, 0xd7, 0x7d, 0xc8, 0x6c, 0xbd, 0x2c, 0xff, 0x15, 0xd6, 0x6e, 0xb8, 0x17, 0x8e, 0xa8, 0x27, 0x66, 0xb1, 0x73, 0x79, 0x96, 0xff, 0x29, 0x10},
|
||||
},
|
||||
{ /* 11P*/
|
||||
addYX: fp.Elt{0x76, 0xcb, 0x9b, 0x0c, 0x5b, 0xfe, 0xe1, 0x2a, 0xdd, 0x6f, 0x6c, 0xdd, 0x6f, 0xb4, 0xc0, 0xc2, 0x1b, 0x4b, 0x38, 0xe8, 0x66, 0x8c, 0x1e, 0x31, 0x63, 0xb9, 0x94, 0xcd, 0xc3, 0x8c, 0x44, 0x25, 0x7b, 0xd5, 0x39, 0x80, 0xfc, 0x01, 0xaa, 0xf7, 0x2a, 0x61, 0x8a, 0x25, 0xd2, 0x5f, 0xc5, 0x66, 0x38, 0xa4, 0x17, 0xcf, 0x3e, 0x11, 0x0f, 0xa3},
|
||||
subYX: fp.Elt{0xe0, 0xb6, 0xd1, 0x9c, 0x71, 0x49, 0x2e, 0x7b, 0xde, 0x00, 0xda, 0x6b, 0xf1, 0xec, 0xe6, 0x7a, 0x15, 0x38, 0x71, 0xe9, 0x7b, 0xdb, 0xf8, 0x98, 0xc0, 0x91, 0x2e, 0x53, 0xee, 0x92, 0x87, 0x25, 0xc9, 0xb0, 0xbb, 0x33, 0x15, 0x46, 0x7f, 0xfd, 0x4f, 0x8b, 0x77, 0x05, 0x96, 0xb6, 0xe2, 0x08, 0xdb, 0x0d, 0x09, 0xee, 0x5b, 0xd1, 0x2a, 0x63},
|
||||
dt2: fp.Elt{0x8f, 0x7b, 0x57, 0x8c, 0xbf, 0x06, 0x0d, 0x43, 0x21, 0x92, 0x94, 0x2d, 0x6a, 0x38, 0x07, 0x0f, 0xa0, 0xf1, 0xe3, 0xd8, 0x2a, 0xbf, 0x46, 0xc6, 0x9e, 0x1f, 0x8f, 0x2b, 0x46, 0x84, 0x0b, 0x74, 0xed, 0xff, 0xf8, 0xa5, 0x94, 0xae, 0xf1, 0x67, 0xb1, 0x9b, 0xdd, 0x4a, 0xd0, 0xdb, 0xc2, 0xb5, 0x58, 0x49, 0x0c, 0xa9, 0x1d, 0x7d, 0xa9, 0xd3},
|
||||
},
|
||||
{ /* 13P*/
|
||||
addYX: fp.Elt{0x73, 0x84, 0x2e, 0x31, 0x1f, 0xdc, 0xed, 0x9f, 0x74, 0xfa, 0xe0, 0x35, 0xb1, 0x85, 0x6a, 0x8d, 0x86, 0xd0, 0xff, 0xd6, 0x08, 0x43, 0x73, 0x1a, 0xd5, 0xf8, 0x43, 0xd4, 0xb3, 0xe5, 0x3f, 0xa8, 0x84, 0x17, 0x59, 0x65, 0x4e, 0xe6, 0xee, 0x54, 0x9c, 0xda, 0x5e, 0x7e, 0x98, 0x29, 0x6d, 0x73, 0x34, 0x1f, 0x99, 0x80, 0x54, 0x54, 0x81, 0x0b},
|
||||
subYX: fp.Elt{0xb1, 0xe5, 0xbb, 0x80, 0x22, 0x9c, 0x81, 0x6d, 0xaf, 0x27, 0x65, 0x6f, 0x7e, 0x9c, 0xb6, 0x8d, 0x35, 0x5c, 0x2e, 0x20, 0x48, 0x7a, 0x28, 0xf0, 0x97, 0xfe, 0xb7, 0x71, 0xce, 0xd6, 0xad, 0x3a, 0x81, 0xf6, 0x74, 0x5e, 0xf3, 0xfd, 0x1b, 0xd4, 0x1e, 0x7c, 0xc2, 0xb7, 0xc8, 0xa6, 0xc9, 0x89, 0x03, 0x47, 0xec, 0x24, 0xd6, 0x0e, 0xec, 0x9c},
|
||||
dt2: fp.Elt{0x91, 0x0a, 0x43, 0x34, 0x20, 0xc2, 0x64, 0xf7, 0x4e, 0x48, 0xc8, 0xd2, 0x95, 0x83, 0xd1, 0xa4, 0xfb, 0x4e, 0x41, 0x3b, 0x0d, 0xd5, 0x07, 0xd9, 0xf1, 0x13, 0x16, 0x78, 0x54, 0x57, 0xd0, 0xf1, 0x4f, 0x20, 0xac, 0xcf, 0x9c, 0x3b, 0x33, 0x0b, 0x99, 0x54, 0xc3, 0x7f, 0x3e, 0x57, 0x26, 0x86, 0xd5, 0xa5, 0x2b, 0x8d, 0xe3, 0x19, 0x36, 0xf7},
|
||||
},
|
||||
{ /* 15P*/
|
||||
addYX: fp.Elt{0x23, 0x69, 0x47, 0x14, 0xf9, 0x9a, 0x50, 0xff, 0x64, 0xd1, 0x50, 0x35, 0xc3, 0x11, 0xd3, 0x19, 0xcf, 0x87, 0xda, 0x30, 0x0b, 0x50, 0xda, 0xc0, 0xe0, 0x25, 0x00, 0xe5, 0x68, 0x93, 0x04, 0xc2, 0xaf, 0xbd, 0x2f, 0x36, 0x5f, 0x47, 0x96, 0x10, 0xa8, 0xbd, 0xe4, 0x88, 0xac, 0x80, 0x52, 0x61, 0x73, 0xe9, 0x63, 0xdd, 0x99, 0xad, 0x20, 0x5b},
|
||||
subYX: fp.Elt{0x1b, 0x5e, 0xa2, 0x2a, 0x25, 0x0f, 0x86, 0xc0, 0xb1, 0x2e, 0x0c, 0x13, 0x40, 0x8d, 0xf0, 0xe6, 0x00, 0x55, 0x08, 0xc5, 0x7d, 0xf4, 0xc9, 0x31, 0x25, 0x3a, 0x99, 0x69, 0xdd, 0x67, 0x63, 0x9a, 0xd6, 0x89, 0x2e, 0xa1, 0x19, 0xca, 0x2c, 0xd9, 0x59, 0x5f, 0x5d, 0xc3, 0x6e, 0x62, 0x36, 0x12, 0x59, 0x15, 0xe1, 0xdc, 0xa4, 0xad, 0xc9, 0xd0},
|
||||
dt2: fp.Elt{0xbc, 0xea, 0xfc, 0xaf, 0x66, 0x23, 0xb7, 0x39, 0x6b, 0x2a, 0x96, 0xa8, 0x54, 0x43, 0xe9, 0xaa, 0x32, 0x40, 0x63, 0x92, 0x5e, 0xdf, 0x35, 0xc2, 0x9f, 0x24, 0x0c, 0xed, 0xfc, 0xde, 0x73, 0x8f, 0xa7, 0xd5, 0xa3, 0x2b, 0x18, 0x1f, 0xb0, 0xf8, 0xeb, 0x55, 0xd9, 0xc3, 0xfd, 0x28, 0x7c, 0x4f, 0xce, 0x0d, 0xf7, 0xae, 0xc2, 0x83, 0xc3, 0x78},
|
||||
},
|
||||
{ /* 17P*/
|
||||
addYX: fp.Elt{0x71, 0xe6, 0x60, 0x93, 0x37, 0xdb, 0x01, 0xa5, 0x4c, 0xba, 0xe8, 0x8e, 0xd5, 0xf9, 0xd3, 0x98, 0xe5, 0xeb, 0xab, 0x3a, 0x15, 0x8b, 0x35, 0x60, 0xbe, 0xe5, 0x9c, 0x2d, 0x10, 0x9b, 0x2e, 0xcf, 0x65, 0x64, 0xea, 0x8f, 0x72, 0xce, 0xf5, 0x18, 0xe5, 0xe2, 0xf0, 0x0e, 0xae, 0x04, 0xec, 0xa0, 0x20, 0x65, 0x63, 0x07, 0xb1, 0x9f, 0x03, 0x97},
|
||||
subYX: fp.Elt{0x9e, 0x41, 0x64, 0x30, 0x95, 0x7f, 0x3a, 0x89, 0x7b, 0x0a, 0x79, 0x59, 0x23, 0x9a, 0x3b, 0xfe, 0xa4, 0x13, 0x08, 0xb2, 0x2e, 0x04, 0x50, 0x10, 0x30, 0xcd, 0x2e, 0xa4, 0x91, 0x71, 0x50, 0x36, 0x4a, 0x02, 0xf4, 0x8d, 0xa3, 0x36, 0x1b, 0xf4, 0x52, 0xba, 0x15, 0x04, 0x8b, 0x80, 0x25, 0xd9, 0xae, 0x67, 0x20, 0xd9, 0x88, 0x8f, 0x97, 0xa6},
|
||||
dt2: fp.Elt{0xb5, 0xe7, 0x46, 0xbd, 0x55, 0x23, 0xa0, 0x68, 0xc0, 0x12, 0xd9, 0xf1, 0x0a, 0x75, 0xe2, 0xda, 0xf4, 0x6b, 0xca, 0x14, 0xe4, 0x9f, 0x0f, 0xb5, 0x3c, 0xa6, 0xa5, 0xa2, 0x63, 0x94, 0xd1, 0x1c, 0x39, 0x58, 0x57, 0x02, 0x27, 0x98, 0xb6, 0x47, 0xc6, 0x61, 0x4b, 0x5c, 0xab, 0x6f, 0x2d, 0xab, 0xe3, 0xc1, 0x69, 0xf9, 0x12, 0xb0, 0xc8, 0xd5},
|
||||
},
|
||||
{ /* 19P*/
|
||||
addYX: fp.Elt{0x19, 0x7d, 0xd5, 0xac, 0x79, 0xa2, 0x82, 0x9b, 0x28, 0x31, 0x22, 0xc0, 0x73, 0x02, 0x76, 0x17, 0x10, 0x70, 0x79, 0x57, 0xc9, 0x84, 0x62, 0x8e, 0x04, 0x04, 0x61, 0x67, 0x08, 0x48, 0xb4, 0x4b, 0xde, 0x53, 0x8c, 0xff, 0x36, 0x1b, 0x62, 0x86, 0x5d, 0xe1, 0x9b, 0xb1, 0xe5, 0xe8, 0x44, 0x64, 0xa1, 0x68, 0x3f, 0xa8, 0x45, 0x52, 0x91, 0xed},
|
||||
subYX: fp.Elt{0x42, 0x1a, 0x36, 0x1f, 0x90, 0x15, 0x24, 0x8d, 0x24, 0x80, 0xe6, 0xfe, 0x1e, 0xf0, 0xad, 0xaf, 0x6a, 0x93, 0xf0, 0xa6, 0x0d, 0x5d, 0xea, 0xf6, 0x62, 0x96, 0x7a, 0x05, 0x76, 0x85, 0x74, 0x32, 0xc7, 0xc8, 0x64, 0x53, 0x62, 0xe7, 0x54, 0x84, 0xe0, 0x40, 0x66, 0x19, 0x70, 0x40, 0x95, 0x35, 0x68, 0x64, 0x43, 0xcd, 0xba, 0x29, 0x32, 0xa8},
|
||||
dt2: fp.Elt{0x3e, 0xf6, 0xd6, 0xe4, 0x99, 0xeb, 0x20, 0x66, 0x08, 0x2e, 0x26, 0x64, 0xd7, 0x76, 0xf3, 0xb4, 0xc5, 0xa4, 0x35, 0x92, 0xd2, 0x99, 0x70, 0x5a, 0x1a, 0xe9, 0xe9, 0x3d, 0x3b, 0xe1, 0xcd, 0x0e, 0xee, 0x24, 0x13, 0x03, 0x22, 0xd6, 0xd6, 0x72, 0x08, 0x2b, 0xde, 0xfd, 0x93, 0xed, 0x0c, 0x7f, 0x5e, 0x31, 0x22, 0x4d, 0x80, 0x78, 0xc0, 0x48},
|
||||
},
|
||||
{ /* 21P*/
|
||||
addYX: fp.Elt{0x8f, 0x72, 0xd2, 0x9e, 0xc4, 0xcd, 0x2c, 0xbf, 0xa8, 0xd3, 0x24, 0x62, 0x28, 0xee, 0x39, 0x0a, 0x19, 0x3a, 0x58, 0xff, 0x21, 0x2e, 0x69, 0x6c, 0x6e, 0x18, 0xd0, 0xcd, 0x61, 0xc1, 0x18, 0x02, 0x5a, 0xe9, 0xe3, 0xef, 0x1f, 0x8e, 0x10, 0xe8, 0x90, 0x2b, 0x48, 0xcd, 0xee, 0x38, 0xbd, 0x3a, 0xca, 0xbc, 0x2d, 0xe2, 0x3a, 0x03, 0x71, 0x02},
|
||||
subYX: fp.Elt{0xf8, 0xa4, 0x32, 0x26, 0x66, 0xaf, 0x3b, 0x53, 0xe7, 0xb0, 0x91, 0x92, 0xf5, 0x3c, 0x74, 0xce, 0xf2, 0xdd, 0x68, 0xa9, 0xf4, 0xcd, 0x5f, 0x60, 0xab, 0x71, 0xdf, 0xcd, 0x5c, 0x5d, 0x51, 0x72, 0x3a, 0x96, 0xea, 0xd6, 0xde, 0x54, 0x8e, 0x55, 0x4c, 0x08, 0x4c, 0x60, 0xdd, 0x34, 0xa9, 0x6f, 0xf3, 0x04, 0x02, 0xa8, 0xa6, 0x4e, 0x4d, 0x62},
|
||||
dt2: fp.Elt{0x76, 0x4a, 0xae, 0x38, 0x62, 0x69, 0x72, 0xdc, 0xe8, 0x43, 0xbe, 0x1d, 0x61, 0xde, 0x31, 0xc3, 0x42, 0x8f, 0x33, 0x9d, 0xca, 0xc7, 0x9c, 0xec, 0x6a, 0xe2, 0xaa, 0x01, 0x49, 0x78, 0x8d, 0x72, 0x4f, 0x38, 0xea, 0x52, 0xc2, 0xd3, 0xc9, 0x39, 0x71, 0xba, 0xb9, 0x09, 0x9b, 0xa3, 0x7f, 0x45, 0x43, 0x65, 0x36, 0x29, 0xca, 0xe7, 0x5c, 0x5f},
|
||||
},
|
||||
{ /* 23P*/
|
||||
addYX: fp.Elt{0x89, 0x42, 0x35, 0x48, 0x6d, 0x74, 0xe5, 0x1f, 0xc3, 0xdd, 0x28, 0x5b, 0x84, 0x41, 0x33, 0x9f, 0x42, 0xf3, 0x1d, 0x5d, 0x15, 0x6d, 0x76, 0x33, 0x36, 0xaf, 0xe9, 0xdd, 0xfa, 0x63, 0x4f, 0x7a, 0x9c, 0xeb, 0x1c, 0x4f, 0x34, 0x65, 0x07, 0x54, 0xbb, 0x4c, 0x8b, 0x62, 0x9d, 0xd0, 0x06, 0x99, 0xb3, 0xe9, 0xda, 0x85, 0x19, 0xb0, 0x3d, 0x3c},
|
||||
subYX: fp.Elt{0xbb, 0x99, 0xf6, 0xbf, 0xaf, 0x2c, 0x22, 0x0d, 0x7a, 0xaa, 0x98, 0x6f, 0x01, 0x82, 0x99, 0xcf, 0x88, 0xbd, 0x0e, 0x3a, 0x89, 0xe0, 0x9c, 0x8c, 0x17, 0x20, 0xc4, 0xe0, 0xcf, 0x43, 0x7a, 0xef, 0x0d, 0x9f, 0x87, 0xd4, 0xfb, 0xf2, 0x96, 0xb8, 0x03, 0xe8, 0xcb, 0x5c, 0xec, 0x65, 0x5f, 0x49, 0xa4, 0x7c, 0x85, 0xb4, 0xf6, 0xc7, 0xdb, 0xa3},
|
||||
dt2: fp.Elt{0x11, 0xf3, 0x32, 0xa3, 0xa7, 0xb2, 0x7d, 0x51, 0x82, 0x44, 0xeb, 0xa2, 0x7d, 0x72, 0xcb, 0xc6, 0xf6, 0xc7, 0xb2, 0x38, 0x0e, 0x0f, 0x4f, 0x29, 0x00, 0xe4, 0x5b, 0x94, 0x46, 0x86, 0x66, 0xa1, 0x83, 0xb3, 0xeb, 0x15, 0xb6, 0x31, 0x50, 0x28, 0xeb, 0xed, 0x0d, 0x32, 0x39, 0xe9, 0x23, 0x81, 0x99, 0x3e, 0xff, 0x17, 0x4c, 0x11, 0x43, 0xd1},
|
||||
},
|
||||
{ /* 25P*/
|
||||
addYX: fp.Elt{0xce, 0xe7, 0xf8, 0x94, 0x8f, 0x96, 0xf8, 0x96, 0xe6, 0x72, 0x20, 0x44, 0x2c, 0xa7, 0xfc, 0xba, 0xc8, 0xe1, 0xbb, 0xc9, 0x16, 0x85, 0xcd, 0x0b, 0xe5, 0xb5, 0x5a, 0x7f, 0x51, 0x43, 0x63, 0x8b, 0x23, 0x8e, 0x1d, 0x31, 0xff, 0x46, 0x02, 0x66, 0xcc, 0x9e, 0x4d, 0xa2, 0xca, 0xe2, 0xc7, 0xfd, 0x22, 0xb1, 0xdb, 0xdf, 0x6f, 0xe6, 0xa5, 0x82},
|
||||
subYX: fp.Elt{0xd0, 0xf5, 0x65, 0x40, 0xec, 0x8e, 0x65, 0x42, 0x78, 0xc1, 0x65, 0xe4, 0x10, 0xc8, 0x0b, 0x1b, 0xdd, 0x96, 0x68, 0xce, 0xee, 0x45, 0x55, 0xd8, 0x6e, 0xd3, 0xe6, 0x77, 0x19, 0xae, 0xc2, 0x8d, 0x8d, 0x3e, 0x14, 0x3f, 0x6d, 0x00, 0x2f, 0x9b, 0xd1, 0x26, 0x60, 0x28, 0x0f, 0x3a, 0x47, 0xb3, 0xe6, 0x68, 0x28, 0x24, 0x25, 0xca, 0xc8, 0x06},
|
||||
dt2: fp.Elt{0x54, 0xbb, 0x60, 0x92, 0xdb, 0x8f, 0x0f, 0x38, 0xe0, 0xe6, 0xe4, 0xc9, 0xcc, 0x14, 0x62, 0x01, 0xc4, 0x2b, 0x0f, 0xcf, 0xed, 0x7d, 0x8e, 0xa4, 0xd9, 0x73, 0x0b, 0xba, 0x0c, 0xaf, 0x0c, 0xf9, 0xe2, 0xeb, 0x29, 0x2a, 0x53, 0xdf, 0x2c, 0x5a, 0xfa, 0x8f, 0xc1, 0x01, 0xd7, 0xb1, 0x45, 0x73, 0x92, 0x32, 0x83, 0x85, 0x12, 0x74, 0x89, 0x44},
|
||||
},
|
||||
{ /* 27P*/
|
||||
addYX: fp.Elt{0x0b, 0x73, 0x3c, 0xc2, 0xb1, 0x2e, 0xe1, 0xa7, 0xf5, 0xc9, 0x7a, 0xfb, 0x3d, 0x2d, 0xac, 0x59, 0xdb, 0xfa, 0x36, 0x11, 0xd1, 0x13, 0x04, 0x51, 0x1d, 0xab, 0x9b, 0x6b, 0x93, 0xfe, 0xda, 0xb0, 0x8e, 0xb4, 0x79, 0x11, 0x21, 0x0f, 0x65, 0xb9, 0xbb, 0x79, 0x96, 0x2a, 0xfd, 0x30, 0xe0, 0xb4, 0x2d, 0x9a, 0x55, 0x25, 0x5d, 0xd4, 0xad, 0x2a},
|
||||
subYX: fp.Elt{0x9e, 0xc5, 0x04, 0xfe, 0xec, 0x3c, 0x64, 0x1c, 0xed, 0x95, 0xed, 0xae, 0xaf, 0x5c, 0x6e, 0x08, 0x9e, 0x02, 0x29, 0x59, 0x7e, 0x5f, 0xc4, 0x9a, 0xd5, 0x32, 0x72, 0x86, 0xe1, 0x4e, 0x3c, 0xce, 0x99, 0x69, 0x3b, 0xc4, 0xdd, 0x4d, 0xb7, 0xbb, 0xda, 0x3b, 0x1a, 0x99, 0xaa, 0x62, 0x15, 0xc1, 0xf0, 0xb6, 0x6c, 0xec, 0x56, 0xc1, 0xff, 0x0c},
|
||||
dt2: fp.Elt{0x2f, 0xf1, 0x3f, 0x7a, 0x2d, 0x56, 0x19, 0x7f, 0xea, 0xbe, 0x59, 0x2e, 0x13, 0x67, 0x81, 0xfb, 0xdb, 0xc8, 0xa3, 0x1d, 0xd5, 0xe9, 0x13, 0x8b, 0x29, 0xdf, 0xcf, 0x9f, 0xe7, 0xd9, 0x0b, 0x70, 0xd3, 0x15, 0x57, 0x4a, 0xe9, 0x50, 0x12, 0x1b, 0x81, 0x4b, 0x98, 0x98, 0xa8, 0x31, 0x1d, 0x27, 0x47, 0x38, 0xed, 0x57, 0x99, 0x26, 0xb2, 0xee},
|
||||
},
|
||||
{ /* 29P*/
|
||||
addYX: fp.Elt{0x1c, 0xb2, 0xb2, 0x67, 0x3b, 0x8b, 0x3d, 0x5a, 0x30, 0x7e, 0x38, 0x7e, 0x3c, 0x3d, 0x28, 0x56, 0x59, 0xd8, 0x87, 0x53, 0x8b, 0xe6, 0x6c, 0x5d, 0xe5, 0x0a, 0x33, 0x10, 0xce, 0xa2, 0x17, 0x0d, 0xe8, 0x76, 0xee, 0x68, 0xa8, 0x72, 0x54, 0xbd, 0xa6, 0x24, 0x94, 0x6e, 0x77, 0xc7, 0x53, 0xb7, 0x89, 0x1c, 0x7a, 0xe9, 0x78, 0x9a, 0x74, 0x5f},
|
||||
subYX: fp.Elt{0x76, 0x96, 0x1c, 0xcf, 0x08, 0x55, 0xd8, 0x1e, 0x0d, 0xa3, 0x59, 0x95, 0x32, 0xf4, 0xc2, 0x8e, 0x84, 0x5e, 0x4b, 0x04, 0xda, 0x71, 0xc9, 0x78, 0x52, 0xde, 0x14, 0xb4, 0x31, 0xf4, 0xd4, 0xb8, 0x58, 0xc5, 0x20, 0xe8, 0xdd, 0x15, 0xb5, 0xee, 0xea, 0x61, 0xe0, 0xf5, 0xd6, 0xae, 0x55, 0x59, 0x05, 0x3e, 0xaf, 0x74, 0xac, 0x1f, 0x17, 0x82},
|
||||
dt2: fp.Elt{0x59, 0x24, 0xcd, 0xfc, 0x11, 0x7e, 0x85, 0x18, 0x3d, 0x69, 0xf7, 0x71, 0x31, 0x66, 0x98, 0x42, 0x95, 0x00, 0x8c, 0xb2, 0xae, 0x39, 0x7e, 0x85, 0xd6, 0xb0, 0x02, 0xec, 0xce, 0xfc, 0x25, 0xb2, 0xe3, 0x99, 0x8e, 0x5b, 0x61, 0x96, 0x2e, 0x6d, 0x96, 0x57, 0x71, 0xa5, 0x93, 0x41, 0x0e, 0x6f, 0xfd, 0x0a, 0xbf, 0xa9, 0xf7, 0x56, 0xa9, 0x3e},
|
||||
},
|
||||
{ /* 31P*/
|
||||
addYX: fp.Elt{0xa2, 0x2e, 0x0c, 0x17, 0x4d, 0xcc, 0x85, 0x2c, 0x18, 0xa0, 0xd2, 0x08, 0xba, 0x11, 0xfa, 0x47, 0x71, 0x86, 0xaf, 0x36, 0x6a, 0xd7, 0xfe, 0xb9, 0xb0, 0x2f, 0x89, 0x98, 0x49, 0x69, 0xf8, 0x6a, 0xad, 0x27, 0x5e, 0x0a, 0x22, 0x60, 0x5e, 0x5d, 0xca, 0x06, 0x51, 0x27, 0x99, 0x29, 0x85, 0x68, 0x98, 0xe1, 0xc4, 0x21, 0x50, 0xa0, 0xe9, 0xc1},
|
||||
subYX: fp.Elt{0x4d, 0x70, 0xee, 0x91, 0x92, 0x3f, 0xb7, 0xd3, 0x1d, 0xdb, 0x8d, 0x6e, 0x16, 0xf5, 0x65, 0x7d, 0x5f, 0xb5, 0x6c, 0x59, 0x26, 0x70, 0x4b, 0xf2, 0xfc, 0xe7, 0xdf, 0x86, 0xfe, 0xa5, 0xa7, 0xa6, 0x5d, 0xfb, 0x06, 0xe9, 0xf9, 0xcc, 0xc0, 0x37, 0xcc, 0xd8, 0x09, 0x04, 0xd2, 0xa5, 0x1d, 0xd7, 0xb7, 0xce, 0x92, 0xac, 0x3c, 0xad, 0xfb, 0xae},
|
||||
dt2: fp.Elt{0x17, 0xa3, 0x9a, 0xc7, 0x86, 0x2a, 0x51, 0xf7, 0x96, 0x79, 0x49, 0x22, 0x2e, 0x5a, 0x01, 0x5c, 0xb5, 0x95, 0xd4, 0xe8, 0xcb, 0x00, 0xca, 0x2d, 0x55, 0xb6, 0x34, 0x36, 0x0b, 0x65, 0x46, 0xf0, 0x49, 0xfc, 0x87, 0x86, 0xe5, 0xc3, 0x15, 0xdb, 0x32, 0xcd, 0xf2, 0xd3, 0x82, 0x4c, 0xe6, 0x61, 0x8a, 0xaf, 0xd4, 0x9e, 0x0f, 0x5a, 0xf2, 0x81},
|
||||
},
|
||||
{ /* 33P*/
|
||||
addYX: fp.Elt{0x88, 0x10, 0xc0, 0xcb, 0xf5, 0x77, 0xae, 0xa5, 0xbe, 0xf6, 0xcd, 0x2e, 0x8b, 0x7e, 0xbd, 0x79, 0x62, 0x4a, 0xeb, 0x69, 0xc3, 0x28, 0xaa, 0x72, 0x87, 0xa9, 0x25, 0x87, 0x46, 0xea, 0x0e, 0x62, 0xa3, 0x6a, 0x1a, 0xe2, 0xba, 0xdc, 0x81, 0x10, 0x33, 0x01, 0xf6, 0x16, 0x89, 0x80, 0xc6, 0xcd, 0xdb, 0xdc, 0xba, 0x0e, 0x09, 0x4a, 0x35, 0x4a},
|
||||
subYX: fp.Elt{0x86, 0xb2, 0x2b, 0xd0, 0xb8, 0x4a, 0x6d, 0x66, 0x7b, 0x32, 0xdf, 0x3b, 0x1a, 0x19, 0x1f, 0x63, 0xee, 0x1f, 0x3d, 0x1c, 0x5c, 0x14, 0x60, 0x5b, 0x72, 0x49, 0x07, 0xb1, 0x0d, 0x72, 0xc6, 0x35, 0xf0, 0xbc, 0x5e, 0xda, 0x80, 0x6b, 0x64, 0x5b, 0xe5, 0x34, 0x54, 0x39, 0xdd, 0xe6, 0x3c, 0xcb, 0xe5, 0x29, 0x32, 0x06, 0xc6, 0xb1, 0x96, 0x34},
|
||||
dt2: fp.Elt{0x85, 0x86, 0xf5, 0x84, 0x86, 0xe6, 0x77, 0x8a, 0x71, 0x85, 0x0c, 0x4f, 0x81, 0x5b, 0x29, 0x06, 0xb5, 0x2e, 0x26, 0x71, 0x07, 0x78, 0x07, 0xae, 0xbc, 0x95, 0x46, 0xc3, 0x65, 0xac, 0xe3, 0x76, 0x51, 0x7d, 0xd4, 0x85, 0x31, 0xe3, 0x43, 0xf3, 0x1b, 0x7c, 0xf7, 0x6b, 0x2c, 0xf8, 0x1c, 0xbb, 0x8d, 0xca, 0xab, 0x4b, 0xba, 0x7f, 0xa4, 0xe2},
|
||||
},
|
||||
{ /* 35P*/
|
||||
addYX: fp.Elt{0x1a, 0xee, 0xe7, 0xa4, 0x8a, 0x9d, 0x53, 0x80, 0xc6, 0xb8, 0x4e, 0xdc, 0x89, 0xe0, 0xc4, 0x2b, 0x60, 0x52, 0x6f, 0xec, 0x81, 0xd2, 0x55, 0x6b, 0x1b, 0x6f, 0x17, 0x67, 0x8e, 0x42, 0x26, 0x4c, 0x65, 0x23, 0x29, 0xc6, 0x7b, 0xcd, 0x9f, 0xad, 0x4b, 0x42, 0xd3, 0x0c, 0x75, 0xc3, 0x8a, 0xf5, 0xbe, 0x9e, 0x55, 0xf7, 0x47, 0x5d, 0xbd, 0x3a},
|
||||
subYX: fp.Elt{0x0d, 0xa8, 0x3b, 0xf9, 0xc7, 0x7e, 0xc6, 0x86, 0x94, 0xc0, 0x01, 0xff, 0x27, 0xce, 0x43, 0xac, 0xe5, 0xe1, 0xd2, 0x8d, 0xc1, 0x22, 0x31, 0xbe, 0xe1, 0xaf, 0xf9, 0x4a, 0x78, 0xa1, 0x0c, 0xaa, 0xd4, 0x80, 0xe4, 0x09, 0x8d, 0xfb, 0x1d, 0x52, 0xc8, 0x60, 0x2d, 0xf2, 0xa2, 0x89, 0x02, 0x56, 0x3d, 0x56, 0x27, 0x85, 0xc7, 0xf0, 0x2b, 0x9a},
|
||||
dt2: fp.Elt{0x62, 0x7c, 0xc7, 0x6b, 0x2c, 0x9d, 0x0a, 0x7c, 0xe5, 0x50, 0x3c, 0xe6, 0x87, 0x1c, 0x82, 0x30, 0x67, 0x3c, 0x39, 0xb6, 0xa0, 0x31, 0xfb, 0x03, 0x7b, 0xa1, 0x58, 0xdf, 0x12, 0x76, 0x5d, 0x5d, 0x0a, 0x8f, 0x9b, 0x37, 0x32, 0xc3, 0x60, 0x33, 0xea, 0x9f, 0x0a, 0x99, 0xfa, 0x20, 0xd0, 0x33, 0x21, 0xc3, 0x94, 0xd4, 0x86, 0x49, 0x7c, 0x4e},
|
||||
},
|
||||
{ /* 37P*/
|
||||
addYX: fp.Elt{0xc7, 0x0c, 0x71, 0xfe, 0x55, 0xd1, 0x95, 0x8f, 0x43, 0xbb, 0x6b, 0x74, 0x30, 0xbd, 0xe8, 0x6f, 0x1c, 0x1b, 0x06, 0x62, 0xf5, 0xfc, 0x65, 0xa0, 0xeb, 0x81, 0x12, 0xc9, 0x64, 0x66, 0x61, 0xde, 0xf3, 0x6d, 0xd4, 0xae, 0x8e, 0xb1, 0x72, 0xe0, 0xcd, 0x37, 0x01, 0x28, 0x52, 0xd7, 0x39, 0x46, 0x0c, 0x55, 0xcf, 0x47, 0x70, 0xef, 0xa1, 0x17},
|
||||
subYX: fp.Elt{0x8d, 0x58, 0xde, 0x83, 0x88, 0x16, 0x0e, 0x12, 0x42, 0x03, 0x50, 0x60, 0x4b, 0xdf, 0xbf, 0x95, 0xcc, 0x7d, 0x18, 0x17, 0x7e, 0x31, 0x5d, 0x8a, 0x66, 0xc1, 0xcf, 0x14, 0xea, 0xf4, 0xf4, 0xe5, 0x63, 0x2d, 0x32, 0x86, 0x9b, 0xed, 0x1f, 0x4f, 0x03, 0xaf, 0x33, 0x92, 0xcb, 0xaf, 0x9c, 0x05, 0x0d, 0x47, 0x1b, 0x42, 0xba, 0x13, 0x22, 0x98},
|
||||
dt2: fp.Elt{0xb5, 0x48, 0xeb, 0x7d, 0x3d, 0x10, 0x9f, 0x59, 0xde, 0xf8, 0x1c, 0x4f, 0x7d, 0x9d, 0x40, 0x4d, 0x9e, 0x13, 0x24, 0xb5, 0x21, 0x09, 0xb7, 0xee, 0x98, 0x5c, 0x56, 0xbc, 0x5e, 0x2b, 0x78, 0x38, 0x06, 0xac, 0xe3, 0xe0, 0xfa, 0x2e, 0xde, 0x4f, 0xd2, 0xb3, 0xfb, 0x2d, 0x71, 0x84, 0xd1, 0x9d, 0x12, 0x5b, 0x35, 0xc8, 0x03, 0x68, 0x67, 0xc7},
|
||||
},
|
||||
{ /* 39P*/
|
||||
addYX: fp.Elt{0xb6, 0x65, 0xfb, 0xa7, 0x06, 0x35, 0xbb, 0xe0, 0x31, 0x8d, 0x91, 0x40, 0x98, 0xab, 0x30, 0xe4, 0xca, 0x12, 0x59, 0x89, 0xed, 0x65, 0x5d, 0x7f, 0xae, 0x69, 0xa0, 0xa4, 0xfa, 0x78, 0xb4, 0xf7, 0xed, 0xae, 0x86, 0x78, 0x79, 0x64, 0x24, 0xa6, 0xd4, 0xe1, 0xf6, 0xd3, 0xa0, 0x89, 0xba, 0x20, 0xf4, 0x54, 0x0d, 0x8f, 0xdb, 0x1a, 0x79, 0xdb},
|
||||
subYX: fp.Elt{0xe1, 0x82, 0x0c, 0x4d, 0xde, 0x9f, 0x40, 0xf0, 0xc1, 0xbd, 0x8b, 0xd3, 0x24, 0x03, 0xcd, 0xf2, 0x92, 0x7d, 0xe2, 0x68, 0x7f, 0xf1, 0xbe, 0x69, 0xde, 0x34, 0x67, 0x4c, 0x85, 0x3b, 0xec, 0x98, 0xcc, 0x4d, 0x3e, 0xc0, 0x96, 0x27, 0xe6, 0x75, 0xfc, 0xdf, 0x37, 0xc0, 0x1e, 0x27, 0xe0, 0xf6, 0xc2, 0xbd, 0xbc, 0x3d, 0x9b, 0x39, 0xdc, 0xe2},
|
||||
dt2: fp.Elt{0xd8, 0x29, 0xa7, 0x39, 0xe3, 0x9f, 0x2f, 0x0e, 0x4b, 0x24, 0x21, 0x70, 0xef, 0xfd, 0x91, 0xea, 0xbf, 0xe1, 0x72, 0x90, 0xcc, 0xc9, 0x84, 0x0e, 0xad, 0xd5, 0xe6, 0xbb, 0xc5, 0x99, 0x7f, 0xa4, 0xf0, 0x2e, 0xcc, 0x95, 0x64, 0x27, 0x19, 0xd8, 0x4c, 0x27, 0x0d, 0xff, 0xb6, 0x29, 0xe2, 0x6c, 0xfa, 0xbb, 0x4d, 0x9c, 0xbb, 0xaf, 0xa5, 0xec},
|
||||
},
|
||||
{ /* 41P*/
|
||||
addYX: fp.Elt{0xd6, 0x33, 0x3f, 0x9f, 0xcf, 0xfd, 0x4c, 0xd1, 0xfe, 0xe5, 0xeb, 0x64, 0x27, 0xae, 0x7a, 0xa2, 0x82, 0x50, 0x6d, 0xaa, 0xe3, 0x5d, 0xe2, 0x48, 0x60, 0xb3, 0x76, 0x04, 0xd9, 0x19, 0xa7, 0xa1, 0x73, 0x8d, 0x38, 0xa9, 0xaf, 0x45, 0xb5, 0xb2, 0x62, 0x9b, 0xf1, 0x35, 0x7b, 0x84, 0x66, 0xeb, 0x06, 0xef, 0xf1, 0xb2, 0x2d, 0x6a, 0x61, 0x15},
|
||||
subYX: fp.Elt{0x86, 0x50, 0x42, 0xf7, 0xda, 0x59, 0xb2, 0xcf, 0x0d, 0x3d, 0xee, 0x8e, 0x53, 0x5d, 0xf7, 0x9e, 0x6a, 0x26, 0x2d, 0xc7, 0x8c, 0x8e, 0x18, 0x50, 0x6d, 0xb7, 0x51, 0x4c, 0xa7, 0x52, 0x6e, 0x0e, 0x0a, 0x16, 0x74, 0xb2, 0x81, 0x8b, 0x56, 0x27, 0x22, 0x84, 0xf4, 0x56, 0xc5, 0x06, 0xe1, 0x8b, 0xca, 0x2d, 0xdb, 0x9a, 0xf6, 0x10, 0x9c, 0x51},
|
||||
dt2: fp.Elt{0x1f, 0x16, 0xa2, 0x78, 0x96, 0x1b, 0x85, 0x9c, 0x76, 0x49, 0xd4, 0x0f, 0xac, 0xb0, 0xf4, 0xd0, 0x06, 0x2c, 0x7e, 0x6d, 0x6e, 0x8e, 0xc7, 0x9f, 0x18, 0xad, 0xfc, 0x88, 0x0c, 0x0c, 0x09, 0x05, 0x05, 0xa0, 0x79, 0x72, 0x32, 0x72, 0x87, 0x0f, 0x49, 0x87, 0x0c, 0xb4, 0x12, 0xc2, 0x09, 0xf8, 0x9f, 0x30, 0x72, 0xa9, 0x47, 0x13, 0x93, 0x49},
|
||||
},
|
||||
{ /* 43P*/
|
||||
addYX: fp.Elt{0xcc, 0xb1, 0x4c, 0xd3, 0xc0, 0x9e, 0x9e, 0x4d, 0x6d, 0x28, 0x0b, 0xa5, 0x94, 0xa7, 0x2e, 0xc2, 0xc7, 0xaf, 0x29, 0x73, 0xc9, 0x68, 0xea, 0x0f, 0x34, 0x37, 0x8d, 0x96, 0x8f, 0x3a, 0x3d, 0x73, 0x1e, 0x6d, 0x9f, 0xcf, 0x8d, 0x83, 0xb5, 0x71, 0xb9, 0xe1, 0x4b, 0x67, 0x71, 0xea, 0xcf, 0x56, 0xe5, 0xeb, 0x72, 0x15, 0x2f, 0x9e, 0xa8, 0xaa},
|
||||
subYX: fp.Elt{0xf4, 0x3e, 0x85, 0x1c, 0x1a, 0xef, 0x50, 0xd1, 0xb4, 0x20, 0xb2, 0x60, 0x05, 0x98, 0xfe, 0x47, 0x3b, 0xc1, 0x76, 0xca, 0x2c, 0x4e, 0x5a, 0x42, 0xa3, 0xf7, 0x20, 0xaa, 0x57, 0x39, 0xee, 0x34, 0x1f, 0xe1, 0x68, 0xd3, 0x7e, 0x06, 0xc4, 0x6c, 0xc7, 0x76, 0x2b, 0xe4, 0x1c, 0x48, 0x44, 0xe6, 0xe5, 0x44, 0x24, 0x8d, 0xb3, 0xb6, 0x88, 0x32},
|
||||
dt2: fp.Elt{0x18, 0xa7, 0xba, 0xd0, 0x44, 0x6f, 0x33, 0x31, 0x00, 0xf8, 0xf6, 0x12, 0xe3, 0xc5, 0xc7, 0xb5, 0x91, 0x9c, 0x91, 0xb5, 0x75, 0x18, 0x18, 0x8a, 0xab, 0xed, 0x24, 0x11, 0x2e, 0xce, 0x5a, 0x0f, 0x94, 0x5f, 0x2e, 0xca, 0xd3, 0x80, 0xea, 0xe5, 0x34, 0x96, 0x67, 0x8b, 0x6a, 0x26, 0x5e, 0xc8, 0x9d, 0x2c, 0x5e, 0x6c, 0xa2, 0x0c, 0xbf, 0xf0},
|
||||
},
|
||||
{ /* 45P*/
|
||||
addYX: fp.Elt{0xb3, 0xbf, 0xa3, 0x85, 0xee, 0xf6, 0x58, 0x02, 0x78, 0xc4, 0x30, 0xd6, 0x57, 0x59, 0x8c, 0x88, 0x08, 0x7c, 0xbc, 0xbe, 0x0a, 0x74, 0xa9, 0xde, 0x69, 0xe7, 0x41, 0xd8, 0xbf, 0x66, 0x8d, 0x3d, 0x28, 0x00, 0x8c, 0x47, 0x65, 0x34, 0xfe, 0x86, 0x9e, 0x6a, 0xf2, 0x41, 0x6a, 0x94, 0xc4, 0x88, 0x75, 0x23, 0x0d, 0x52, 0x69, 0xee, 0x07, 0x89},
|
||||
subYX: fp.Elt{0x22, 0x3c, 0xa1, 0x70, 0x58, 0x97, 0x93, 0xbe, 0x59, 0xa8, 0x0b, 0x8a, 0x46, 0x2a, 0x38, 0x1e, 0x08, 0x6b, 0x61, 0x9f, 0xf2, 0x4a, 0x8b, 0x80, 0x68, 0x6e, 0xc8, 0x92, 0x60, 0xf3, 0xc9, 0x89, 0xb2, 0x6d, 0x63, 0xb0, 0xeb, 0x83, 0x15, 0x63, 0x0e, 0x64, 0xbb, 0xb8, 0xfe, 0xb4, 0x81, 0x90, 0x01, 0x28, 0x10, 0xb9, 0x74, 0x6e, 0xde, 0xa4},
|
||||
dt2: fp.Elt{0x1a, 0x23, 0x45, 0xa8, 0x6f, 0x4e, 0xa7, 0x4a, 0x0c, 0xeb, 0xb0, 0x43, 0xf9, 0xef, 0x99, 0x60, 0x5b, 0xdb, 0x66, 0xc0, 0x86, 0x71, 0x43, 0xb1, 0x22, 0x7b, 0x1c, 0xe7, 0x8d, 0x09, 0x1d, 0x83, 0x76, 0x9c, 0xd3, 0x5a, 0xdd, 0x42, 0xd9, 0x2f, 0x2d, 0xba, 0x7a, 0xc2, 0xd9, 0x6b, 0xd4, 0x7a, 0xf1, 0xd5, 0x5f, 0x6b, 0x85, 0xbf, 0x0b, 0xf1},
|
||||
},
|
||||
{ /* 47P*/
|
||||
addYX: fp.Elt{0xb2, 0x83, 0xfa, 0x1f, 0xd2, 0xce, 0xb6, 0xf2, 0x2d, 0xea, 0x1b, 0xe5, 0x29, 0xa5, 0x72, 0xf9, 0x25, 0x48, 0x4e, 0xf2, 0x50, 0x1b, 0x39, 0xda, 0x34, 0xc5, 0x16, 0x13, 0xb4, 0x0c, 0xa1, 0x00, 0x79, 0x7a, 0xf5, 0x8b, 0xf3, 0x70, 0x14, 0xb6, 0xfc, 0x9a, 0x47, 0x68, 0x1e, 0x42, 0x70, 0x64, 0x2a, 0x84, 0x3e, 0x3d, 0x20, 0x58, 0xf9, 0x6a},
|
||||
subYX: fp.Elt{0xd9, 0xee, 0xc0, 0xc4, 0xf5, 0xc2, 0x86, 0xaf, 0x45, 0xd2, 0xd2, 0x87, 0x1b, 0x64, 0xd5, 0xe0, 0x8c, 0x44, 0x00, 0x4f, 0x43, 0x89, 0x04, 0x48, 0x4a, 0x0b, 0xca, 0x94, 0x06, 0x2f, 0x23, 0x5b, 0x6c, 0x8d, 0x44, 0x66, 0x53, 0xf5, 0x5a, 0x20, 0x72, 0x28, 0x58, 0x84, 0xcc, 0x73, 0x22, 0x5e, 0xd1, 0x0b, 0x56, 0x5e, 0x6a, 0xa3, 0x11, 0x91},
|
||||
dt2: fp.Elt{0x6e, 0x9f, 0x88, 0xa8, 0x68, 0x2f, 0x12, 0x37, 0x88, 0xfc, 0x92, 0x8f, 0x24, 0xeb, 0x5b, 0x2a, 0x2a, 0xd0, 0x14, 0x40, 0x4c, 0xa9, 0xa4, 0x03, 0x0c, 0x45, 0x48, 0x13, 0xe8, 0xa6, 0x37, 0xab, 0xc0, 0x06, 0x38, 0x6c, 0x96, 0x73, 0x40, 0x6c, 0xc6, 0xea, 0x56, 0xc6, 0xe9, 0x1a, 0x69, 0xeb, 0x7a, 0xd1, 0x33, 0x69, 0x58, 0x2b, 0xea, 0x2f},
|
||||
},
|
||||
{ /* 49P*/
|
||||
addYX: fp.Elt{0x58, 0xa8, 0x05, 0x41, 0x00, 0x9d, 0xaa, 0xd9, 0x98, 0xcf, 0xb9, 0x41, 0xb5, 0x4a, 0x8d, 0xe2, 0xe7, 0xc0, 0x72, 0xef, 0xc8, 0x28, 0x6b, 0x68, 0x9d, 0xc9, 0xdf, 0x05, 0x8b, 0xd0, 0x04, 0x74, 0x79, 0x45, 0x52, 0x05, 0xa3, 0x6e, 0x35, 0x3a, 0xe3, 0xef, 0xb2, 0xdc, 0x08, 0x6f, 0x4e, 0x76, 0x85, 0x67, 0xba, 0x23, 0x8f, 0xdd, 0xaf, 0x09},
|
||||
subYX: fp.Elt{0xb4, 0x38, 0xc8, 0xff, 0x4f, 0x65, 0x2a, 0x7e, 0xad, 0xb1, 0xc6, 0xb9, 0x3d, 0xd6, 0xf7, 0x14, 0xcf, 0xf6, 0x98, 0x75, 0xbb, 0x47, 0x83, 0x90, 0xe7, 0xe1, 0xf6, 0x14, 0x99, 0x7e, 0xfa, 0xe4, 0x77, 0x24, 0xe3, 0xe7, 0xf0, 0x1e, 0xdb, 0x27, 0x4e, 0x16, 0x04, 0xf2, 0x08, 0x52, 0xfc, 0xec, 0x55, 0xdb, 0x2e, 0x67, 0xe1, 0x94, 0x32, 0x89},
|
||||
dt2: fp.Elt{0x00, 0xad, 0x03, 0x35, 0x1a, 0xb1, 0x88, 0xf0, 0xc9, 0x11, 0xe4, 0x12, 0x52, 0x61, 0xfd, 0x8a, 0x1b, 0x6a, 0x0a, 0x4c, 0x42, 0x46, 0x22, 0x0e, 0xa5, 0xf9, 0xe2, 0x50, 0xf2, 0xb2, 0x1f, 0x20, 0x78, 0x10, 0xf6, 0xbf, 0x7f, 0x0c, 0x9c, 0xad, 0x40, 0x8b, 0x82, 0xd4, 0xba, 0x69, 0x09, 0xac, 0x4b, 0x6d, 0xc4, 0x49, 0x17, 0x81, 0x57, 0x3b},
|
||||
},
|
||||
{ /* 51P*/
|
||||
addYX: fp.Elt{0x0d, 0xfe, 0xb4, 0x35, 0x11, 0xbd, 0x1d, 0x6b, 0xc2, 0xc5, 0x3b, 0xd2, 0x23, 0x2c, 0x72, 0xe3, 0x48, 0xb1, 0x48, 0x73, 0xfb, 0xa3, 0x21, 0x6e, 0xc0, 0x09, 0x69, 0xac, 0xe1, 0x60, 0xbc, 0x24, 0x03, 0x99, 0x63, 0x0a, 0x00, 0xf0, 0x75, 0xf6, 0x92, 0xc5, 0xd6, 0xdb, 0x51, 0xd4, 0x7d, 0xe6, 0xf4, 0x11, 0x79, 0xd7, 0xc3, 0xaf, 0x48, 0xd0},
|
||||
subYX: fp.Elt{0xf4, 0x4f, 0xaf, 0x31, 0xe3, 0x10, 0x89, 0x95, 0xf0, 0x8a, 0xf6, 0x31, 0x9f, 0x48, 0x02, 0xba, 0x42, 0x2b, 0x3c, 0x22, 0x8b, 0xcc, 0x12, 0x98, 0x6e, 0x7a, 0x64, 0x3a, 0xc4, 0xca, 0x32, 0x2a, 0x72, 0xf8, 0x2c, 0xcf, 0x78, 0x5e, 0x7a, 0x75, 0x6e, 0x72, 0x46, 0x48, 0x62, 0x28, 0xac, 0x58, 0x1a, 0xc6, 0x59, 0x88, 0x2a, 0x44, 0x9e, 0x83},
|
||||
dt2: fp.Elt{0xb3, 0xde, 0x36, 0xfd, 0xeb, 0x1b, 0xd4, 0x24, 0x1b, 0x08, 0x8c, 0xfe, 0xa9, 0x41, 0xa1, 0x64, 0xf2, 0x6d, 0xdb, 0xf9, 0x94, 0xae, 0x86, 0x71, 0xab, 0x10, 0xbf, 0xa3, 0xb2, 0xa0, 0xdf, 0x10, 0x8c, 0x74, 0xce, 0xb3, 0xfc, 0xdb, 0xba, 0x15, 0xf6, 0x91, 0x7a, 0x9c, 0x36, 0x1e, 0x45, 0x07, 0x3c, 0xec, 0x1a, 0x61, 0x26, 0x93, 0xe3, 0x50},
|
||||
},
|
||||
{ /* 53P*/
|
||||
addYX: fp.Elt{0xc5, 0x50, 0xc5, 0x83, 0xb0, 0xbd, 0xd9, 0xf6, 0x6d, 0x15, 0x5e, 0xc1, 0x1a, 0x33, 0xa0, 0xce, 0x13, 0x70, 0x3b, 0xe1, 0x31, 0xc6, 0xc4, 0x02, 0xec, 0x8c, 0xd5, 0x9c, 0x97, 0xd3, 0x12, 0xc4, 0xa2, 0xf9, 0xd5, 0xfb, 0x22, 0x69, 0x94, 0x09, 0x2f, 0x59, 0xce, 0xdb, 0xf2, 0xf2, 0x00, 0xe0, 0xa9, 0x08, 0x44, 0x2e, 0x8b, 0x6b, 0xf5, 0xb3},
|
||||
subYX: fp.Elt{0x90, 0xdd, 0xec, 0xa2, 0x65, 0xb7, 0x61, 0xbc, 0xaa, 0x70, 0xa2, 0x15, 0xd8, 0xb0, 0xf8, 0x8e, 0x23, 0x3d, 0x9f, 0x46, 0xa3, 0x29, 0x20, 0xd1, 0xa1, 0x15, 0x81, 0xc6, 0xb6, 0xde, 0xbe, 0x60, 0x63, 0x24, 0xac, 0x15, 0xfb, 0xeb, 0xd3, 0xea, 0x57, 0x13, 0x86, 0x38, 0x1e, 0x22, 0xf4, 0x8c, 0x5d, 0xaf, 0x1b, 0x27, 0x21, 0x4f, 0xa3, 0x63},
|
||||
dt2: fp.Elt{0x07, 0x15, 0x87, 0xc4, 0xfd, 0xa1, 0x97, 0x7a, 0x07, 0x1f, 0x56, 0xcc, 0xe3, 0x6a, 0x01, 0x90, 0xce, 0xf9, 0xfa, 0x50, 0xb2, 0xe0, 0x87, 0x8b, 0x6c, 0x63, 0x6c, 0xf6, 0x2a, 0x09, 0xef, 0xef, 0xd2, 0x31, 0x40, 0x25, 0xf6, 0x84, 0xcb, 0xe0, 0xc4, 0x23, 0xc1, 0xcb, 0xe2, 0x02, 0x83, 0x2d, 0xed, 0x74, 0x74, 0x8b, 0xf8, 0x7c, 0x81, 0x18},
|
||||
},
|
||||
{ /* 55P*/
|
||||
addYX: fp.Elt{0x9e, 0xe5, 0x59, 0x95, 0x63, 0x2e, 0xac, 0x8b, 0x03, 0x3c, 0xc1, 0x8e, 0xe1, 0x5b, 0x56, 0x3c, 0x16, 0x41, 0xe4, 0xc2, 0x60, 0x0c, 0x6d, 0x65, 0x9f, 0xfc, 0x27, 0x68, 0x43, 0x44, 0x05, 0x12, 0x6c, 0xda, 0x04, 0xef, 0xcf, 0xcf, 0xdc, 0x0a, 0x1a, 0x7f, 0x12, 0xd3, 0xeb, 0x02, 0xb6, 0x04, 0xca, 0xd6, 0xcb, 0xf0, 0x22, 0xba, 0x35, 0x6d},
|
||||
subYX: fp.Elt{0x09, 0x6d, 0xf9, 0x64, 0x4c, 0xe6, 0x41, 0xff, 0x01, 0x4d, 0xce, 0x1e, 0xfa, 0x38, 0xa2, 0x25, 0x62, 0xff, 0x03, 0x39, 0x18, 0x91, 0xbb, 0x9d, 0xce, 0x02, 0xf0, 0xf1, 0x3c, 0x55, 0x18, 0xa9, 0xab, 0x4d, 0xd2, 0x35, 0xfd, 0x8d, 0xa9, 0xb2, 0xad, 0xb7, 0x06, 0x6e, 0xc6, 0x69, 0x49, 0xd6, 0x98, 0x98, 0x0b, 0x22, 0x81, 0x6b, 0xbd, 0xa0},
|
||||
dt2: fp.Elt{0x22, 0xf4, 0x85, 0x5d, 0x2b, 0xf1, 0x55, 0xa5, 0xd6, 0x27, 0x86, 0x57, 0x12, 0x1f, 0x16, 0x0a, 0x5a, 0x9b, 0xf2, 0x38, 0xb6, 0x28, 0xd8, 0x99, 0x0c, 0x89, 0x1d, 0x7f, 0xca, 0x21, 0x17, 0x1a, 0x0b, 0x02, 0x5f, 0x77, 0x2f, 0x73, 0x30, 0x7c, 0xc8, 0xd7, 0x2b, 0xcc, 0xe7, 0xf3, 0x21, 0xac, 0x53, 0xa7, 0x11, 0x5d, 0xd8, 0x1d, 0x9b, 0xf5},
|
||||
},
|
||||
{ /* 57P*/
|
||||
addYX: fp.Elt{0x94, 0x63, 0x5d, 0xef, 0xfd, 0x6d, 0x25, 0x4e, 0x6d, 0x29, 0x03, 0xed, 0x24, 0x28, 0x27, 0x57, 0x47, 0x3e, 0x6a, 0x1a, 0xfe, 0x37, 0xee, 0x5f, 0x83, 0x29, 0x14, 0xfd, 0x78, 0x25, 0x8a, 0xe1, 0x02, 0x38, 0xd8, 0xca, 0x65, 0x55, 0x40, 0x7d, 0x48, 0x2c, 0x7c, 0x7e, 0x60, 0xb6, 0x0c, 0x6d, 0xf7, 0xe8, 0xb3, 0x62, 0x53, 0xd6, 0x9c, 0x2b},
|
||||
subYX: fp.Elt{0x47, 0x25, 0x70, 0x62, 0xf5, 0x65, 0x93, 0x62, 0x08, 0xac, 0x59, 0x66, 0xdb, 0x08, 0xd9, 0x1a, 0x19, 0xaf, 0xf4, 0xef, 0x02, 0xa2, 0x78, 0xa9, 0x55, 0x1c, 0xfa, 0x08, 0x11, 0xcb, 0xa3, 0x71, 0x74, 0xb1, 0x62, 0xe7, 0xc7, 0xf3, 0x5a, 0xb5, 0x8b, 0xd4, 0xf6, 0x10, 0x57, 0x79, 0x72, 0x2f, 0x13, 0x86, 0x7b, 0x44, 0x5f, 0x48, 0xfd, 0x88},
|
||||
dt2: fp.Elt{0x10, 0x02, 0xcd, 0x05, 0x9a, 0xc3, 0x32, 0x6d, 0x10, 0x3a, 0x74, 0xba, 0x06, 0xc4, 0x3b, 0x34, 0xbc, 0x36, 0xed, 0xa3, 0xba, 0x9a, 0xdb, 0x6d, 0xd4, 0x69, 0x99, 0x97, 0xd0, 0xe4, 0xdd, 0xf5, 0xd4, 0x7c, 0xd3, 0x4e, 0xab, 0xd1, 0x3b, 0xbb, 0xe9, 0xc7, 0x6a, 0x94, 0x25, 0x61, 0xf0, 0x06, 0xc5, 0x12, 0xa8, 0x86, 0xe5, 0x35, 0x46, 0xeb},
|
||||
},
|
||||
{ /* 59P*/
|
||||
addYX: fp.Elt{0x9e, 0x95, 0x11, 0xc6, 0xc7, 0xe8, 0xee, 0x5a, 0x26, 0xa0, 0x72, 0x72, 0x59, 0x91, 0x59, 0x16, 0x49, 0x99, 0x7e, 0xbb, 0xd7, 0x15, 0xb4, 0xf2, 0x40, 0xf9, 0x5a, 0x4d, 0xc8, 0xa0, 0xe2, 0x34, 0x7b, 0x34, 0xf3, 0x99, 0xbf, 0xa9, 0xf3, 0x79, 0xc1, 0x1a, 0x0c, 0xf4, 0x86, 0x74, 0x4e, 0xcb, 0xbc, 0x90, 0xad, 0xb6, 0x51, 0x6d, 0xaa, 0x33},
|
||||
subYX: fp.Elt{0x9f, 0xd1, 0xc5, 0xa2, 0x6c, 0x24, 0x88, 0x15, 0x71, 0x68, 0xf6, 0x07, 0x45, 0x02, 0xc4, 0x73, 0x7e, 0x75, 0x87, 0xca, 0x7c, 0xf0, 0x92, 0x00, 0x75, 0xd6, 0x5a, 0xdd, 0xe0, 0x64, 0x16, 0x9d, 0x62, 0x80, 0x33, 0x9f, 0xf4, 0x8e, 0x1a, 0x15, 0x1c, 0xd3, 0x0f, 0x4d, 0x4f, 0x62, 0x2d, 0xd7, 0xa5, 0x77, 0xe3, 0xea, 0xf0, 0xfb, 0x1a, 0xdb},
|
||||
dt2: fp.Elt{0x6a, 0xa2, 0xb1, 0xaa, 0xfb, 0x5a, 0x32, 0x4e, 0xff, 0x47, 0x06, 0xd5, 0x9a, 0x4f, 0xce, 0x83, 0x5b, 0x82, 0x34, 0x3e, 0x47, 0xb8, 0xf8, 0xe9, 0x7c, 0x67, 0x69, 0x8d, 0x9c, 0xb7, 0xde, 0x57, 0xf4, 0x88, 0x41, 0x56, 0x0c, 0x87, 0x1e, 0xc9, 0x2f, 0x54, 0xbf, 0x5c, 0x68, 0x2c, 0xd9, 0xc4, 0xef, 0x53, 0x73, 0x1e, 0xa6, 0x38, 0x02, 0x10},
|
||||
},
|
||||
{ /* 61P*/
|
||||
addYX: fp.Elt{0x08, 0x80, 0x4a, 0xc9, 0xb7, 0xa8, 0x88, 0xd9, 0xfc, 0x6a, 0xc0, 0x3e, 0xc2, 0x33, 0x4d, 0x2b, 0x2a, 0xa3, 0x6d, 0x72, 0x3e, 0xdc, 0x34, 0x68, 0x08, 0xbf, 0x27, 0xef, 0xf4, 0xff, 0xe2, 0x0c, 0x31, 0x0c, 0xa2, 0x0a, 0x1f, 0x65, 0xc1, 0x4c, 0x61, 0xd3, 0x1b, 0xbc, 0x25, 0xb1, 0xd0, 0xd4, 0x89, 0xb2, 0x53, 0xfb, 0x43, 0xa5, 0xaf, 0x04},
|
||||
subYX: fp.Elt{0xe3, 0xe1, 0x37, 0xad, 0x58, 0xa9, 0x55, 0x81, 0xee, 0x64, 0x21, 0xb9, 0xf5, 0x4c, 0x35, 0xea, 0x4a, 0xd3, 0x26, 0xaa, 0x90, 0xd4, 0x60, 0x46, 0x09, 0x4b, 0x4a, 0x62, 0xf9, 0xcd, 0xe1, 0xee, 0xbb, 0xc2, 0x09, 0x0b, 0xb0, 0x96, 0x8e, 0x43, 0x77, 0xaf, 0x25, 0x20, 0x5e, 0x47, 0xe4, 0x1d, 0x50, 0x69, 0x74, 0x08, 0xd7, 0xb9, 0x90, 0x13},
|
||||
dt2: fp.Elt{0x51, 0x91, 0x95, 0x64, 0x03, 0x16, 0xfd, 0x6e, 0x26, 0x94, 0x6b, 0x61, 0xe7, 0xd9, 0xe0, 0x4a, 0x6d, 0x7c, 0xfa, 0xc0, 0xe2, 0x43, 0x23, 0x53, 0x70, 0xf5, 0x6f, 0x73, 0x8b, 0x81, 0xb0, 0x0c, 0xee, 0x2e, 0x46, 0xf2, 0x8d, 0xa6, 0xfb, 0xb5, 0x1c, 0x33, 0xbf, 0x90, 0x59, 0xc9, 0x7c, 0xb8, 0x6f, 0xad, 0x75, 0x02, 0x90, 0x8e, 0x59, 0x75},
|
||||
},
|
||||
{ /* 63P*/
|
||||
addYX: fp.Elt{0x36, 0x4d, 0x77, 0x04, 0xb8, 0x7d, 0x4a, 0xd1, 0xc5, 0xbb, 0x7b, 0x50, 0x5f, 0x8d, 0x9d, 0x62, 0x0f, 0x66, 0x71, 0xec, 0x87, 0xc5, 0x80, 0x82, 0xc8, 0xf4, 0x6a, 0x94, 0x92, 0x5b, 0xb0, 0x16, 0x9b, 0xb2, 0xc9, 0x6f, 0x2b, 0x2d, 0xee, 0x95, 0x73, 0x2e, 0xc2, 0x1b, 0xc5, 0x55, 0x36, 0x86, 0x24, 0xf8, 0x20, 0x05, 0x0d, 0x93, 0xd7, 0x76},
|
||||
subYX: fp.Elt{0x7f, 0x01, 0xeb, 0x2e, 0x48, 0x4d, 0x1d, 0xf1, 0x06, 0x7e, 0x7c, 0x2a, 0x43, 0xbf, 0x28, 0xac, 0xe9, 0x58, 0x13, 0xc8, 0xbf, 0x8e, 0xc0, 0xef, 0xe8, 0x4f, 0x46, 0x8a, 0xe7, 0xc0, 0xf6, 0x0f, 0x0a, 0x03, 0x48, 0x91, 0x55, 0x39, 0x2a, 0xe3, 0xdc, 0xf6, 0x22, 0x9d, 0x4d, 0x71, 0x55, 0x68, 0x25, 0x6e, 0x95, 0x52, 0xee, 0x4c, 0xd9, 0x01},
|
||||
dt2: fp.Elt{0xac, 0x33, 0x3f, 0x7c, 0x27, 0x35, 0x15, 0x91, 0x33, 0x8d, 0xf9, 0xc4, 0xf4, 0xf3, 0x90, 0x09, 0x75, 0x69, 0x62, 0x9f, 0x61, 0x35, 0x83, 0x92, 0x04, 0xef, 0x96, 0x38, 0x80, 0x9e, 0x88, 0xb3, 0x67, 0x95, 0xbe, 0x79, 0x3c, 0x35, 0xd8, 0xdc, 0xb2, 0x3e, 0x2d, 0xe6, 0x46, 0xbe, 0x81, 0xf3, 0x32, 0x0e, 0x37, 0x23, 0x75, 0x2a, 0x3d, 0xa0},
|
||||
},
|
||||
}
|
||||
62
vendor/github.com/cloudflare/circl/ecc/goldilocks/twist_basemult.go
generated
vendored
Normal file
62
vendor/github.com/cloudflare/circl/ecc/goldilocks/twist_basemult.go
generated
vendored
Normal file
@ -0,0 +1,62 @@
|
||||
package goldilocks
|
||||
|
||||
import (
|
||||
"crypto/subtle"
|
||||
|
||||
mlsb "github.com/cloudflare/circl/math/mlsbset"
|
||||
)
|
||||
|
||||
const (
|
||||
// MLSBRecoding parameters
|
||||
fxT = 448
|
||||
fxV = 2
|
||||
fxW = 3
|
||||
fx2w1 = 1 << (uint(fxW) - 1)
|
||||
)
|
||||
|
||||
// ScalarBaseMult returns kG where G is the generator point.
|
||||
func (e twistCurve) ScalarBaseMult(k *Scalar) *twistPoint {
|
||||
m, err := mlsb.New(fxT, fxV, fxW)
|
||||
if err != nil {
|
||||
panic(err)
|
||||
}
|
||||
if m.IsExtended() {
|
||||
panic("not extended")
|
||||
}
|
||||
|
||||
var isZero int
|
||||
if k.IsZero() {
|
||||
isZero = 1
|
||||
}
|
||||
subtle.ConstantTimeCopy(isZero, k[:], order[:])
|
||||
|
||||
minusK := *k
|
||||
isEven := 1 - int(k[0]&0x1)
|
||||
minusK.Neg()
|
||||
subtle.ConstantTimeCopy(isEven, k[:], minusK[:])
|
||||
c, err := m.Encode(k[:])
|
||||
if err != nil {
|
||||
panic(err)
|
||||
}
|
||||
|
||||
gP := c.Exp(groupMLSB{})
|
||||
P := gP.(*twistPoint)
|
||||
P.cneg(uint(isEven))
|
||||
return P
|
||||
}
|
||||
|
||||
type groupMLSB struct{}
|
||||
|
||||
func (e groupMLSB) ExtendedEltP() mlsb.EltP { return nil }
|
||||
func (e groupMLSB) Sqr(x mlsb.EltG) { x.(*twistPoint).Double() }
|
||||
func (e groupMLSB) Mul(x mlsb.EltG, y mlsb.EltP) { x.(*twistPoint).mixAddZ1(y.(*preTwistPointAffine)) }
|
||||
func (e groupMLSB) Identity() mlsb.EltG { return twistCurve{}.Identity() }
|
||||
func (e groupMLSB) NewEltP() mlsb.EltP { return &preTwistPointAffine{} }
|
||||
func (e groupMLSB) Lookup(a mlsb.EltP, v uint, s, u int32) {
|
||||
Tabj := &tabFixMult[v]
|
||||
P := a.(*preTwistPointAffine)
|
||||
for k := range Tabj {
|
||||
P.cmov(&Tabj[k], uint(subtle.ConstantTimeEq(int32(k), u)))
|
||||
}
|
||||
P.cneg(int(s >> 31))
|
||||
}
|
||||
140
vendor/github.com/cloudflare/circl/internal/conv/conv.go
generated
vendored
Normal file
140
vendor/github.com/cloudflare/circl/internal/conv/conv.go
generated
vendored
Normal file
@ -0,0 +1,140 @@
|
||||
package conv
|
||||
|
||||
import (
|
||||
"encoding/binary"
|
||||
"fmt"
|
||||
"math/big"
|
||||
"strings"
|
||||
)
|
||||
|
||||
// BytesLe2Hex returns an hexadecimal string of a number stored in a
|
||||
// little-endian order slice x.
|
||||
func BytesLe2Hex(x []byte) string {
|
||||
b := &strings.Builder{}
|
||||
b.Grow(2*len(x) + 2)
|
||||
fmt.Fprint(b, "0x")
|
||||
if len(x) == 0 {
|
||||
fmt.Fprint(b, "00")
|
||||
}
|
||||
for i := len(x) - 1; i >= 0; i-- {
|
||||
fmt.Fprintf(b, "%02x", x[i])
|
||||
}
|
||||
return b.String()
|
||||
}
|
||||
|
||||
// BytesLe2BigInt converts a little-endian slice x into a big-endian
|
||||
// math/big.Int.
|
||||
func BytesLe2BigInt(x []byte) *big.Int {
|
||||
n := len(x)
|
||||
b := new(big.Int)
|
||||
if len(x) > 0 {
|
||||
y := make([]byte, n)
|
||||
for i := 0; i < n; i++ {
|
||||
y[n-1-i] = x[i]
|
||||
}
|
||||
b.SetBytes(y)
|
||||
}
|
||||
return b
|
||||
}
|
||||
|
||||
// BytesBe2Uint64Le converts a big-endian slice x to a little-endian slice of uint64.
|
||||
func BytesBe2Uint64Le(x []byte) []uint64 {
|
||||
l := len(x)
|
||||
z := make([]uint64, (l+7)/8)
|
||||
blocks := l / 8
|
||||
for i := 0; i < blocks; i++ {
|
||||
z[i] = binary.BigEndian.Uint64(x[l-8*(i+1):])
|
||||
}
|
||||
remBytes := l % 8
|
||||
for i := 0; i < remBytes; i++ {
|
||||
z[blocks] |= uint64(x[l-1-8*blocks-i]) << uint(8*i)
|
||||
}
|
||||
return z
|
||||
}
|
||||
|
||||
// BigInt2BytesLe stores a positive big.Int number x into a little-endian slice z.
|
||||
// The slice is modified if the bitlength of x <= 8*len(z) (padding with zeros).
|
||||
// If x does not fit in the slice or is negative, z is not modified.
|
||||
func BigInt2BytesLe(z []byte, x *big.Int) {
|
||||
xLen := (x.BitLen() + 7) >> 3
|
||||
zLen := len(z)
|
||||
if zLen >= xLen && x.Sign() >= 0 {
|
||||
y := x.Bytes()
|
||||
for i := 0; i < xLen; i++ {
|
||||
z[i] = y[xLen-1-i]
|
||||
}
|
||||
for i := xLen; i < zLen; i++ {
|
||||
z[i] = 0
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// Uint64Le2BigInt converts a little-endian slice x into a big number.
|
||||
func Uint64Le2BigInt(x []uint64) *big.Int {
|
||||
n := len(x)
|
||||
b := new(big.Int)
|
||||
var bi big.Int
|
||||
for i := n - 1; i >= 0; i-- {
|
||||
bi.SetUint64(x[i])
|
||||
b.Lsh(b, 64)
|
||||
b.Add(b, &bi)
|
||||
}
|
||||
return b
|
||||
}
|
||||
|
||||
// Uint64Le2BytesLe converts a little-endian slice x to a little-endian slice of bytes.
|
||||
func Uint64Le2BytesLe(x []uint64) []byte {
|
||||
b := make([]byte, 8*len(x))
|
||||
n := len(x)
|
||||
for i := 0; i < n; i++ {
|
||||
binary.LittleEndian.PutUint64(b[i*8:], x[i])
|
||||
}
|
||||
return b
|
||||
}
|
||||
|
||||
// Uint64Le2BytesBe converts a little-endian slice x to a big-endian slice of bytes.
|
||||
func Uint64Le2BytesBe(x []uint64) []byte {
|
||||
b := make([]byte, 8*len(x))
|
||||
n := len(x)
|
||||
for i := 0; i < n; i++ {
|
||||
binary.BigEndian.PutUint64(b[i*8:], x[n-1-i])
|
||||
}
|
||||
return b
|
||||
}
|
||||
|
||||
// Uint64Le2Hex returns an hexadecimal string of a number stored in a
|
||||
// little-endian order slice x.
|
||||
func Uint64Le2Hex(x []uint64) string {
|
||||
b := new(strings.Builder)
|
||||
b.Grow(16*len(x) + 2)
|
||||
fmt.Fprint(b, "0x")
|
||||
if len(x) == 0 {
|
||||
fmt.Fprint(b, "00")
|
||||
}
|
||||
for i := len(x) - 1; i >= 0; i-- {
|
||||
fmt.Fprintf(b, "%016x", x[i])
|
||||
}
|
||||
return b.String()
|
||||
}
|
||||
|
||||
// BigInt2Uint64Le stores a positive big.Int number x into a little-endian slice z.
|
||||
// The slice is modified if the bitlength of x <= 8*len(z) (padding with zeros).
|
||||
// If x does not fit in the slice or is negative, z is not modified.
|
||||
func BigInt2Uint64Le(z []uint64, x *big.Int) {
|
||||
xLen := (x.BitLen() + 63) >> 6 // number of 64-bit words
|
||||
zLen := len(z)
|
||||
if zLen >= xLen && x.Sign() > 0 {
|
||||
var y, yi big.Int
|
||||
y.Set(x)
|
||||
two64 := big.NewInt(1)
|
||||
two64.Lsh(two64, 64).Sub(two64, big.NewInt(1))
|
||||
for i := 0; i < xLen; i++ {
|
||||
yi.And(&y, two64)
|
||||
z[i] = yi.Uint64()
|
||||
y.Rsh(&y, 64)
|
||||
}
|
||||
}
|
||||
for i := xLen; i < zLen; i++ {
|
||||
z[i] = 0
|
||||
}
|
||||
}
|
||||
62
vendor/github.com/cloudflare/circl/internal/sha3/doc.go
generated
vendored
Normal file
62
vendor/github.com/cloudflare/circl/internal/sha3/doc.go
generated
vendored
Normal file
@ -0,0 +1,62 @@
|
||||
// Copyright 2014 The Go Authors. All rights reserved.
|
||||
// Use of this source code is governed by a BSD-style
|
||||
// license that can be found in the LICENSE file.
|
||||
|
||||
// Package sha3 implements the SHA-3 fixed-output-length hash functions and
|
||||
// the SHAKE variable-output-length hash functions defined by FIPS-202.
|
||||
//
|
||||
// Both types of hash function use the "sponge" construction and the Keccak
|
||||
// permutation. For a detailed specification see http://keccak.noekeon.org/
|
||||
//
|
||||
// # Guidance
|
||||
//
|
||||
// If you aren't sure what function you need, use SHAKE256 with at least 64
|
||||
// bytes of output. The SHAKE instances are faster than the SHA3 instances;
|
||||
// the latter have to allocate memory to conform to the hash.Hash interface.
|
||||
//
|
||||
// If you need a secret-key MAC (message authentication code), prepend the
|
||||
// secret key to the input, hash with SHAKE256 and read at least 32 bytes of
|
||||
// output.
|
||||
//
|
||||
// # Security strengths
|
||||
//
|
||||
// The SHA3-x (x equals 224, 256, 384, or 512) functions have a security
|
||||
// strength against preimage attacks of x bits. Since they only produce "x"
|
||||
// bits of output, their collision-resistance is only "x/2" bits.
|
||||
//
|
||||
// The SHAKE-256 and -128 functions have a generic security strength of 256 and
|
||||
// 128 bits against all attacks, provided that at least 2x bits of their output
|
||||
// is used. Requesting more than 64 or 32 bytes of output, respectively, does
|
||||
// not increase the collision-resistance of the SHAKE functions.
|
||||
//
|
||||
// # The sponge construction
|
||||
//
|
||||
// A sponge builds a pseudo-random function from a public pseudo-random
|
||||
// permutation, by applying the permutation to a state of "rate + capacity"
|
||||
// bytes, but hiding "capacity" of the bytes.
|
||||
//
|
||||
// A sponge starts out with a zero state. To hash an input using a sponge, up
|
||||
// to "rate" bytes of the input are XORed into the sponge's state. The sponge
|
||||
// is then "full" and the permutation is applied to "empty" it. This process is
|
||||
// repeated until all the input has been "absorbed". The input is then padded.
|
||||
// The digest is "squeezed" from the sponge in the same way, except that output
|
||||
// is copied out instead of input being XORed in.
|
||||
//
|
||||
// A sponge is parameterized by its generic security strength, which is equal
|
||||
// to half its capacity; capacity + rate is equal to the permutation's width.
|
||||
// Since the KeccakF-1600 permutation is 1600 bits (200 bytes) wide, this means
|
||||
// that the security strength of a sponge instance is equal to (1600 - bitrate) / 2.
|
||||
//
|
||||
// # Recommendations
|
||||
//
|
||||
// The SHAKE functions are recommended for most new uses. They can produce
|
||||
// output of arbitrary length. SHAKE256, with an output length of at least
|
||||
// 64 bytes, provides 256-bit security against all attacks. The Keccak team
|
||||
// recommends it for most applications upgrading from SHA2-512. (NIST chose a
|
||||
// much stronger, but much slower, sponge instance for SHA3-512.)
|
||||
//
|
||||
// The SHA-3 functions are "drop-in" replacements for the SHA-2 functions.
|
||||
// They produce output of the same length, with the same security strengths
|
||||
// against all attacks. This means, in particular, that SHA3-256 only has
|
||||
// 128-bit collision resistance, because its output length is 32 bytes.
|
||||
package sha3
|
||||
69
vendor/github.com/cloudflare/circl/internal/sha3/hashes.go
generated
vendored
Normal file
69
vendor/github.com/cloudflare/circl/internal/sha3/hashes.go
generated
vendored
Normal file
@ -0,0 +1,69 @@
|
||||
// Copyright 2014 The Go Authors. All rights reserved.
|
||||
// Use of this source code is governed by a BSD-style
|
||||
// license that can be found in the LICENSE file.
|
||||
|
||||
package sha3
|
||||
|
||||
// This file provides functions for creating instances of the SHA-3
|
||||
// and SHAKE hash functions, as well as utility functions for hashing
|
||||
// bytes.
|
||||
|
||||
// New224 creates a new SHA3-224 hash.
|
||||
// Its generic security strength is 224 bits against preimage attacks,
|
||||
// and 112 bits against collision attacks.
|
||||
func New224() State {
|
||||
return State{rate: 144, outputLen: 28, dsbyte: 0x06}
|
||||
}
|
||||
|
||||
// New256 creates a new SHA3-256 hash.
|
||||
// Its generic security strength is 256 bits against preimage attacks,
|
||||
// and 128 bits against collision attacks.
|
||||
func New256() State {
|
||||
return State{rate: 136, outputLen: 32, dsbyte: 0x06}
|
||||
}
|
||||
|
||||
// New384 creates a new SHA3-384 hash.
|
||||
// Its generic security strength is 384 bits against preimage attacks,
|
||||
// and 192 bits against collision attacks.
|
||||
func New384() State {
|
||||
return State{rate: 104, outputLen: 48, dsbyte: 0x06}
|
||||
}
|
||||
|
||||
// New512 creates a new SHA3-512 hash.
|
||||
// Its generic security strength is 512 bits against preimage attacks,
|
||||
// and 256 bits against collision attacks.
|
||||
func New512() State {
|
||||
return State{rate: 72, outputLen: 64, dsbyte: 0x06}
|
||||
}
|
||||
|
||||
// Sum224 returns the SHA3-224 digest of the data.
|
||||
func Sum224(data []byte) (digest [28]byte) {
|
||||
h := New224()
|
||||
_, _ = h.Write(data)
|
||||
h.Sum(digest[:0])
|
||||
return
|
||||
}
|
||||
|
||||
// Sum256 returns the SHA3-256 digest of the data.
|
||||
func Sum256(data []byte) (digest [32]byte) {
|
||||
h := New256()
|
||||
_, _ = h.Write(data)
|
||||
h.Sum(digest[:0])
|
||||
return
|
||||
}
|
||||
|
||||
// Sum384 returns the SHA3-384 digest of the data.
|
||||
func Sum384(data []byte) (digest [48]byte) {
|
||||
h := New384()
|
||||
_, _ = h.Write(data)
|
||||
h.Sum(digest[:0])
|
||||
return
|
||||
}
|
||||
|
||||
// Sum512 returns the SHA3-512 digest of the data.
|
||||
func Sum512(data []byte) (digest [64]byte) {
|
||||
h := New512()
|
||||
_, _ = h.Write(data)
|
||||
h.Sum(digest[:0])
|
||||
return
|
||||
}
|
||||
383
vendor/github.com/cloudflare/circl/internal/sha3/keccakf.go
generated
vendored
Normal file
383
vendor/github.com/cloudflare/circl/internal/sha3/keccakf.go
generated
vendored
Normal file
@ -0,0 +1,383 @@
|
||||
// Copyright 2014 The Go Authors. All rights reserved.
|
||||
// Use of this source code is governed by a BSD-style
|
||||
// license that can be found in the LICENSE file.
|
||||
|
||||
package sha3
|
||||
|
||||
// KeccakF1600 applies the Keccak permutation to a 1600b-wide
|
||||
// state represented as a slice of 25 uint64s.
|
||||
// nolint:funlen
|
||||
func KeccakF1600(a *[25]uint64) {
|
||||
// Implementation translated from Keccak-inplace.c
|
||||
// in the keccak reference code.
|
||||
var t, bc0, bc1, bc2, bc3, bc4, d0, d1, d2, d3, d4 uint64
|
||||
|
||||
for i := 0; i < 24; i += 4 {
|
||||
// Combines the 5 steps in each round into 2 steps.
|
||||
// Unrolls 4 rounds per loop and spreads some steps across rounds.
|
||||
|
||||
// Round 1
|
||||
bc0 = a[0] ^ a[5] ^ a[10] ^ a[15] ^ a[20]
|
||||
bc1 = a[1] ^ a[6] ^ a[11] ^ a[16] ^ a[21]
|
||||
bc2 = a[2] ^ a[7] ^ a[12] ^ a[17] ^ a[22]
|
||||
bc3 = a[3] ^ a[8] ^ a[13] ^ a[18] ^ a[23]
|
||||
bc4 = a[4] ^ a[9] ^ a[14] ^ a[19] ^ a[24]
|
||||
d0 = bc4 ^ (bc1<<1 | bc1>>63)
|
||||
d1 = bc0 ^ (bc2<<1 | bc2>>63)
|
||||
d2 = bc1 ^ (bc3<<1 | bc3>>63)
|
||||
d3 = bc2 ^ (bc4<<1 | bc4>>63)
|
||||
d4 = bc3 ^ (bc0<<1 | bc0>>63)
|
||||
|
||||
bc0 = a[0] ^ d0
|
||||
t = a[6] ^ d1
|
||||
bc1 = t<<44 | t>>(64-44)
|
||||
t = a[12] ^ d2
|
||||
bc2 = t<<43 | t>>(64-43)
|
||||
t = a[18] ^ d3
|
||||
bc3 = t<<21 | t>>(64-21)
|
||||
t = a[24] ^ d4
|
||||
bc4 = t<<14 | t>>(64-14)
|
||||
a[0] = bc0 ^ (bc2 &^ bc1) ^ RC[i]
|
||||
a[6] = bc1 ^ (bc3 &^ bc2)
|
||||
a[12] = bc2 ^ (bc4 &^ bc3)
|
||||
a[18] = bc3 ^ (bc0 &^ bc4)
|
||||
a[24] = bc4 ^ (bc1 &^ bc0)
|
||||
|
||||
t = a[10] ^ d0
|
||||
bc2 = t<<3 | t>>(64-3)
|
||||
t = a[16] ^ d1
|
||||
bc3 = t<<45 | t>>(64-45)
|
||||
t = a[22] ^ d2
|
||||
bc4 = t<<61 | t>>(64-61)
|
||||
t = a[3] ^ d3
|
||||
bc0 = t<<28 | t>>(64-28)
|
||||
t = a[9] ^ d4
|
||||
bc1 = t<<20 | t>>(64-20)
|
||||
a[10] = bc0 ^ (bc2 &^ bc1)
|
||||
a[16] = bc1 ^ (bc3 &^ bc2)
|
||||
a[22] = bc2 ^ (bc4 &^ bc3)
|
||||
a[3] = bc3 ^ (bc0 &^ bc4)
|
||||
a[9] = bc4 ^ (bc1 &^ bc0)
|
||||
|
||||
t = a[20] ^ d0
|
||||
bc4 = t<<18 | t>>(64-18)
|
||||
t = a[1] ^ d1
|
||||
bc0 = t<<1 | t>>(64-1)
|
||||
t = a[7] ^ d2
|
||||
bc1 = t<<6 | t>>(64-6)
|
||||
t = a[13] ^ d3
|
||||
bc2 = t<<25 | t>>(64-25)
|
||||
t = a[19] ^ d4
|
||||
bc3 = t<<8 | t>>(64-8)
|
||||
a[20] = bc0 ^ (bc2 &^ bc1)
|
||||
a[1] = bc1 ^ (bc3 &^ bc2)
|
||||
a[7] = bc2 ^ (bc4 &^ bc3)
|
||||
a[13] = bc3 ^ (bc0 &^ bc4)
|
||||
a[19] = bc4 ^ (bc1 &^ bc0)
|
||||
|
||||
t = a[5] ^ d0
|
||||
bc1 = t<<36 | t>>(64-36)
|
||||
t = a[11] ^ d1
|
||||
bc2 = t<<10 | t>>(64-10)
|
||||
t = a[17] ^ d2
|
||||
bc3 = t<<15 | t>>(64-15)
|
||||
t = a[23] ^ d3
|
||||
bc4 = t<<56 | t>>(64-56)
|
||||
t = a[4] ^ d4
|
||||
bc0 = t<<27 | t>>(64-27)
|
||||
a[5] = bc0 ^ (bc2 &^ bc1)
|
||||
a[11] = bc1 ^ (bc3 &^ bc2)
|
||||
a[17] = bc2 ^ (bc4 &^ bc3)
|
||||
a[23] = bc3 ^ (bc0 &^ bc4)
|
||||
a[4] = bc4 ^ (bc1 &^ bc0)
|
||||
|
||||
t = a[15] ^ d0
|
||||
bc3 = t<<41 | t>>(64-41)
|
||||
t = a[21] ^ d1
|
||||
bc4 = t<<2 | t>>(64-2)
|
||||
t = a[2] ^ d2
|
||||
bc0 = t<<62 | t>>(64-62)
|
||||
t = a[8] ^ d3
|
||||
bc1 = t<<55 | t>>(64-55)
|
||||
t = a[14] ^ d4
|
||||
bc2 = t<<39 | t>>(64-39)
|
||||
a[15] = bc0 ^ (bc2 &^ bc1)
|
||||
a[21] = bc1 ^ (bc3 &^ bc2)
|
||||
a[2] = bc2 ^ (bc4 &^ bc3)
|
||||
a[8] = bc3 ^ (bc0 &^ bc4)
|
||||
a[14] = bc4 ^ (bc1 &^ bc0)
|
||||
|
||||
// Round 2
|
||||
bc0 = a[0] ^ a[5] ^ a[10] ^ a[15] ^ a[20]
|
||||
bc1 = a[1] ^ a[6] ^ a[11] ^ a[16] ^ a[21]
|
||||
bc2 = a[2] ^ a[7] ^ a[12] ^ a[17] ^ a[22]
|
||||
bc3 = a[3] ^ a[8] ^ a[13] ^ a[18] ^ a[23]
|
||||
bc4 = a[4] ^ a[9] ^ a[14] ^ a[19] ^ a[24]
|
||||
d0 = bc4 ^ (bc1<<1 | bc1>>63)
|
||||
d1 = bc0 ^ (bc2<<1 | bc2>>63)
|
||||
d2 = bc1 ^ (bc3<<1 | bc3>>63)
|
||||
d3 = bc2 ^ (bc4<<1 | bc4>>63)
|
||||
d4 = bc3 ^ (bc0<<1 | bc0>>63)
|
||||
|
||||
bc0 = a[0] ^ d0
|
||||
t = a[16] ^ d1
|
||||
bc1 = t<<44 | t>>(64-44)
|
||||
t = a[7] ^ d2
|
||||
bc2 = t<<43 | t>>(64-43)
|
||||
t = a[23] ^ d3
|
||||
bc3 = t<<21 | t>>(64-21)
|
||||
t = a[14] ^ d4
|
||||
bc4 = t<<14 | t>>(64-14)
|
||||
a[0] = bc0 ^ (bc2 &^ bc1) ^ RC[i+1]
|
||||
a[16] = bc1 ^ (bc3 &^ bc2)
|
||||
a[7] = bc2 ^ (bc4 &^ bc3)
|
||||
a[23] = bc3 ^ (bc0 &^ bc4)
|
||||
a[14] = bc4 ^ (bc1 &^ bc0)
|
||||
|
||||
t = a[20] ^ d0
|
||||
bc2 = t<<3 | t>>(64-3)
|
||||
t = a[11] ^ d1
|
||||
bc3 = t<<45 | t>>(64-45)
|
||||
t = a[2] ^ d2
|
||||
bc4 = t<<61 | t>>(64-61)
|
||||
t = a[18] ^ d3
|
||||
bc0 = t<<28 | t>>(64-28)
|
||||
t = a[9] ^ d4
|
||||
bc1 = t<<20 | t>>(64-20)
|
||||
a[20] = bc0 ^ (bc2 &^ bc1)
|
||||
a[11] = bc1 ^ (bc3 &^ bc2)
|
||||
a[2] = bc2 ^ (bc4 &^ bc3)
|
||||
a[18] = bc3 ^ (bc0 &^ bc4)
|
||||
a[9] = bc4 ^ (bc1 &^ bc0)
|
||||
|
||||
t = a[15] ^ d0
|
||||
bc4 = t<<18 | t>>(64-18)
|
||||
t = a[6] ^ d1
|
||||
bc0 = t<<1 | t>>(64-1)
|
||||
t = a[22] ^ d2
|
||||
bc1 = t<<6 | t>>(64-6)
|
||||
t = a[13] ^ d3
|
||||
bc2 = t<<25 | t>>(64-25)
|
||||
t = a[4] ^ d4
|
||||
bc3 = t<<8 | t>>(64-8)
|
||||
a[15] = bc0 ^ (bc2 &^ bc1)
|
||||
a[6] = bc1 ^ (bc3 &^ bc2)
|
||||
a[22] = bc2 ^ (bc4 &^ bc3)
|
||||
a[13] = bc3 ^ (bc0 &^ bc4)
|
||||
a[4] = bc4 ^ (bc1 &^ bc0)
|
||||
|
||||
t = a[10] ^ d0
|
||||
bc1 = t<<36 | t>>(64-36)
|
||||
t = a[1] ^ d1
|
||||
bc2 = t<<10 | t>>(64-10)
|
||||
t = a[17] ^ d2
|
||||
bc3 = t<<15 | t>>(64-15)
|
||||
t = a[8] ^ d3
|
||||
bc4 = t<<56 | t>>(64-56)
|
||||
t = a[24] ^ d4
|
||||
bc0 = t<<27 | t>>(64-27)
|
||||
a[10] = bc0 ^ (bc2 &^ bc1)
|
||||
a[1] = bc1 ^ (bc3 &^ bc2)
|
||||
a[17] = bc2 ^ (bc4 &^ bc3)
|
||||
a[8] = bc3 ^ (bc0 &^ bc4)
|
||||
a[24] = bc4 ^ (bc1 &^ bc0)
|
||||
|
||||
t = a[5] ^ d0
|
||||
bc3 = t<<41 | t>>(64-41)
|
||||
t = a[21] ^ d1
|
||||
bc4 = t<<2 | t>>(64-2)
|
||||
t = a[12] ^ d2
|
||||
bc0 = t<<62 | t>>(64-62)
|
||||
t = a[3] ^ d3
|
||||
bc1 = t<<55 | t>>(64-55)
|
||||
t = a[19] ^ d4
|
||||
bc2 = t<<39 | t>>(64-39)
|
||||
a[5] = bc0 ^ (bc2 &^ bc1)
|
||||
a[21] = bc1 ^ (bc3 &^ bc2)
|
||||
a[12] = bc2 ^ (bc4 &^ bc3)
|
||||
a[3] = bc3 ^ (bc0 &^ bc4)
|
||||
a[19] = bc4 ^ (bc1 &^ bc0)
|
||||
|
||||
// Round 3
|
||||
bc0 = a[0] ^ a[5] ^ a[10] ^ a[15] ^ a[20]
|
||||
bc1 = a[1] ^ a[6] ^ a[11] ^ a[16] ^ a[21]
|
||||
bc2 = a[2] ^ a[7] ^ a[12] ^ a[17] ^ a[22]
|
||||
bc3 = a[3] ^ a[8] ^ a[13] ^ a[18] ^ a[23]
|
||||
bc4 = a[4] ^ a[9] ^ a[14] ^ a[19] ^ a[24]
|
||||
d0 = bc4 ^ (bc1<<1 | bc1>>63)
|
||||
d1 = bc0 ^ (bc2<<1 | bc2>>63)
|
||||
d2 = bc1 ^ (bc3<<1 | bc3>>63)
|
||||
d3 = bc2 ^ (bc4<<1 | bc4>>63)
|
||||
d4 = bc3 ^ (bc0<<1 | bc0>>63)
|
||||
|
||||
bc0 = a[0] ^ d0
|
||||
t = a[11] ^ d1
|
||||
bc1 = t<<44 | t>>(64-44)
|
||||
t = a[22] ^ d2
|
||||
bc2 = t<<43 | t>>(64-43)
|
||||
t = a[8] ^ d3
|
||||
bc3 = t<<21 | t>>(64-21)
|
||||
t = a[19] ^ d4
|
||||
bc4 = t<<14 | t>>(64-14)
|
||||
a[0] = bc0 ^ (bc2 &^ bc1) ^ RC[i+2]
|
||||
a[11] = bc1 ^ (bc3 &^ bc2)
|
||||
a[22] = bc2 ^ (bc4 &^ bc3)
|
||||
a[8] = bc3 ^ (bc0 &^ bc4)
|
||||
a[19] = bc4 ^ (bc1 &^ bc0)
|
||||
|
||||
t = a[15] ^ d0
|
||||
bc2 = t<<3 | t>>(64-3)
|
||||
t = a[1] ^ d1
|
||||
bc3 = t<<45 | t>>(64-45)
|
||||
t = a[12] ^ d2
|
||||
bc4 = t<<61 | t>>(64-61)
|
||||
t = a[23] ^ d3
|
||||
bc0 = t<<28 | t>>(64-28)
|
||||
t = a[9] ^ d4
|
||||
bc1 = t<<20 | t>>(64-20)
|
||||
a[15] = bc0 ^ (bc2 &^ bc1)
|
||||
a[1] = bc1 ^ (bc3 &^ bc2)
|
||||
a[12] = bc2 ^ (bc4 &^ bc3)
|
||||
a[23] = bc3 ^ (bc0 &^ bc4)
|
||||
a[9] = bc4 ^ (bc1 &^ bc0)
|
||||
|
||||
t = a[5] ^ d0
|
||||
bc4 = t<<18 | t>>(64-18)
|
||||
t = a[16] ^ d1
|
||||
bc0 = t<<1 | t>>(64-1)
|
||||
t = a[2] ^ d2
|
||||
bc1 = t<<6 | t>>(64-6)
|
||||
t = a[13] ^ d3
|
||||
bc2 = t<<25 | t>>(64-25)
|
||||
t = a[24] ^ d4
|
||||
bc3 = t<<8 | t>>(64-8)
|
||||
a[5] = bc0 ^ (bc2 &^ bc1)
|
||||
a[16] = bc1 ^ (bc3 &^ bc2)
|
||||
a[2] = bc2 ^ (bc4 &^ bc3)
|
||||
a[13] = bc3 ^ (bc0 &^ bc4)
|
||||
a[24] = bc4 ^ (bc1 &^ bc0)
|
||||
|
||||
t = a[20] ^ d0
|
||||
bc1 = t<<36 | t>>(64-36)
|
||||
t = a[6] ^ d1
|
||||
bc2 = t<<10 | t>>(64-10)
|
||||
t = a[17] ^ d2
|
||||
bc3 = t<<15 | t>>(64-15)
|
||||
t = a[3] ^ d3
|
||||
bc4 = t<<56 | t>>(64-56)
|
||||
t = a[14] ^ d4
|
||||
bc0 = t<<27 | t>>(64-27)
|
||||
a[20] = bc0 ^ (bc2 &^ bc1)
|
||||
a[6] = bc1 ^ (bc3 &^ bc2)
|
||||
a[17] = bc2 ^ (bc4 &^ bc3)
|
||||
a[3] = bc3 ^ (bc0 &^ bc4)
|
||||
a[14] = bc4 ^ (bc1 &^ bc0)
|
||||
|
||||
t = a[10] ^ d0
|
||||
bc3 = t<<41 | t>>(64-41)
|
||||
t = a[21] ^ d1
|
||||
bc4 = t<<2 | t>>(64-2)
|
||||
t = a[7] ^ d2
|
||||
bc0 = t<<62 | t>>(64-62)
|
||||
t = a[18] ^ d3
|
||||
bc1 = t<<55 | t>>(64-55)
|
||||
t = a[4] ^ d4
|
||||
bc2 = t<<39 | t>>(64-39)
|
||||
a[10] = bc0 ^ (bc2 &^ bc1)
|
||||
a[21] = bc1 ^ (bc3 &^ bc2)
|
||||
a[7] = bc2 ^ (bc4 &^ bc3)
|
||||
a[18] = bc3 ^ (bc0 &^ bc4)
|
||||
a[4] = bc4 ^ (bc1 &^ bc0)
|
||||
|
||||
// Round 4
|
||||
bc0 = a[0] ^ a[5] ^ a[10] ^ a[15] ^ a[20]
|
||||
bc1 = a[1] ^ a[6] ^ a[11] ^ a[16] ^ a[21]
|
||||
bc2 = a[2] ^ a[7] ^ a[12] ^ a[17] ^ a[22]
|
||||
bc3 = a[3] ^ a[8] ^ a[13] ^ a[18] ^ a[23]
|
||||
bc4 = a[4] ^ a[9] ^ a[14] ^ a[19] ^ a[24]
|
||||
d0 = bc4 ^ (bc1<<1 | bc1>>63)
|
||||
d1 = bc0 ^ (bc2<<1 | bc2>>63)
|
||||
d2 = bc1 ^ (bc3<<1 | bc3>>63)
|
||||
d3 = bc2 ^ (bc4<<1 | bc4>>63)
|
||||
d4 = bc3 ^ (bc0<<1 | bc0>>63)
|
||||
|
||||
bc0 = a[0] ^ d0
|
||||
t = a[1] ^ d1
|
||||
bc1 = t<<44 | t>>(64-44)
|
||||
t = a[2] ^ d2
|
||||
bc2 = t<<43 | t>>(64-43)
|
||||
t = a[3] ^ d3
|
||||
bc3 = t<<21 | t>>(64-21)
|
||||
t = a[4] ^ d4
|
||||
bc4 = t<<14 | t>>(64-14)
|
||||
a[0] = bc0 ^ (bc2 &^ bc1) ^ RC[i+3]
|
||||
a[1] = bc1 ^ (bc3 &^ bc2)
|
||||
a[2] = bc2 ^ (bc4 &^ bc3)
|
||||
a[3] = bc3 ^ (bc0 &^ bc4)
|
||||
a[4] = bc4 ^ (bc1 &^ bc0)
|
||||
|
||||
t = a[5] ^ d0
|
||||
bc2 = t<<3 | t>>(64-3)
|
||||
t = a[6] ^ d1
|
||||
bc3 = t<<45 | t>>(64-45)
|
||||
t = a[7] ^ d2
|
||||
bc4 = t<<61 | t>>(64-61)
|
||||
t = a[8] ^ d3
|
||||
bc0 = t<<28 | t>>(64-28)
|
||||
t = a[9] ^ d4
|
||||
bc1 = t<<20 | t>>(64-20)
|
||||
a[5] = bc0 ^ (bc2 &^ bc1)
|
||||
a[6] = bc1 ^ (bc3 &^ bc2)
|
||||
a[7] = bc2 ^ (bc4 &^ bc3)
|
||||
a[8] = bc3 ^ (bc0 &^ bc4)
|
||||
a[9] = bc4 ^ (bc1 &^ bc0)
|
||||
|
||||
t = a[10] ^ d0
|
||||
bc4 = t<<18 | t>>(64-18)
|
||||
t = a[11] ^ d1
|
||||
bc0 = t<<1 | t>>(64-1)
|
||||
t = a[12] ^ d2
|
||||
bc1 = t<<6 | t>>(64-6)
|
||||
t = a[13] ^ d3
|
||||
bc2 = t<<25 | t>>(64-25)
|
||||
t = a[14] ^ d4
|
||||
bc3 = t<<8 | t>>(64-8)
|
||||
a[10] = bc0 ^ (bc2 &^ bc1)
|
||||
a[11] = bc1 ^ (bc3 &^ bc2)
|
||||
a[12] = bc2 ^ (bc4 &^ bc3)
|
||||
a[13] = bc3 ^ (bc0 &^ bc4)
|
||||
a[14] = bc4 ^ (bc1 &^ bc0)
|
||||
|
||||
t = a[15] ^ d0
|
||||
bc1 = t<<36 | t>>(64-36)
|
||||
t = a[16] ^ d1
|
||||
bc2 = t<<10 | t>>(64-10)
|
||||
t = a[17] ^ d2
|
||||
bc3 = t<<15 | t>>(64-15)
|
||||
t = a[18] ^ d3
|
||||
bc4 = t<<56 | t>>(64-56)
|
||||
t = a[19] ^ d4
|
||||
bc0 = t<<27 | t>>(64-27)
|
||||
a[15] = bc0 ^ (bc2 &^ bc1)
|
||||
a[16] = bc1 ^ (bc3 &^ bc2)
|
||||
a[17] = bc2 ^ (bc4 &^ bc3)
|
||||
a[18] = bc3 ^ (bc0 &^ bc4)
|
||||
a[19] = bc4 ^ (bc1 &^ bc0)
|
||||
|
||||
t = a[20] ^ d0
|
||||
bc3 = t<<41 | t>>(64-41)
|
||||
t = a[21] ^ d1
|
||||
bc4 = t<<2 | t>>(64-2)
|
||||
t = a[22] ^ d2
|
||||
bc0 = t<<62 | t>>(64-62)
|
||||
t = a[23] ^ d3
|
||||
bc1 = t<<55 | t>>(64-55)
|
||||
t = a[24] ^ d4
|
||||
bc2 = t<<39 | t>>(64-39)
|
||||
a[20] = bc0 ^ (bc2 &^ bc1)
|
||||
a[21] = bc1 ^ (bc3 &^ bc2)
|
||||
a[22] = bc2 ^ (bc4 &^ bc3)
|
||||
a[23] = bc3 ^ (bc0 &^ bc4)
|
||||
a[24] = bc4 ^ (bc1 &^ bc0)
|
||||
}
|
||||
}
|
||||
29
vendor/github.com/cloudflare/circl/internal/sha3/rc.go
generated
vendored
Normal file
29
vendor/github.com/cloudflare/circl/internal/sha3/rc.go
generated
vendored
Normal file
@ -0,0 +1,29 @@
|
||||
package sha3
|
||||
|
||||
// RC stores the round constants for use in the ι step.
|
||||
var RC = [24]uint64{
|
||||
0x0000000000000001,
|
||||
0x0000000000008082,
|
||||
0x800000000000808A,
|
||||
0x8000000080008000,
|
||||
0x000000000000808B,
|
||||
0x0000000080000001,
|
||||
0x8000000080008081,
|
||||
0x8000000000008009,
|
||||
0x000000000000008A,
|
||||
0x0000000000000088,
|
||||
0x0000000080008009,
|
||||
0x000000008000000A,
|
||||
0x000000008000808B,
|
||||
0x800000000000008B,
|
||||
0x8000000000008089,
|
||||
0x8000000000008003,
|
||||
0x8000000000008002,
|
||||
0x8000000000000080,
|
||||
0x000000000000800A,
|
||||
0x800000008000000A,
|
||||
0x8000000080008081,
|
||||
0x8000000000008080,
|
||||
0x0000000080000001,
|
||||
0x8000000080008008,
|
||||
}
|
||||
195
vendor/github.com/cloudflare/circl/internal/sha3/sha3.go
generated
vendored
Normal file
195
vendor/github.com/cloudflare/circl/internal/sha3/sha3.go
generated
vendored
Normal file
@ -0,0 +1,195 @@
|
||||
// Copyright 2014 The Go Authors. All rights reserved.
|
||||
// Use of this source code is governed by a BSD-style
|
||||
// license that can be found in the LICENSE file.
|
||||
|
||||
package sha3
|
||||
|
||||
// spongeDirection indicates the direction bytes are flowing through the sponge.
|
||||
type spongeDirection int
|
||||
|
||||
const (
|
||||
// spongeAbsorbing indicates that the sponge is absorbing input.
|
||||
spongeAbsorbing spongeDirection = iota
|
||||
// spongeSqueezing indicates that the sponge is being squeezed.
|
||||
spongeSqueezing
|
||||
)
|
||||
|
||||
const (
|
||||
// maxRate is the maximum size of the internal buffer. SHAKE-256
|
||||
// currently needs the largest buffer.
|
||||
maxRate = 168
|
||||
)
|
||||
|
||||
func (d *State) buf() []byte {
|
||||
return d.storage.asBytes()[d.bufo:d.bufe]
|
||||
}
|
||||
|
||||
type State struct {
|
||||
// Generic sponge components.
|
||||
a [25]uint64 // main state of the hash
|
||||
rate int // the number of bytes of state to use
|
||||
|
||||
bufo int // offset of buffer in storage
|
||||
bufe int // end of buffer in storage
|
||||
|
||||
// dsbyte contains the "domain separation" bits and the first bit of
|
||||
// the padding. Sections 6.1 and 6.2 of [1] separate the outputs of the
|
||||
// SHA-3 and SHAKE functions by appending bitstrings to the message.
|
||||
// Using a little-endian bit-ordering convention, these are "01" for SHA-3
|
||||
// and "1111" for SHAKE, or 00000010b and 00001111b, respectively. Then the
|
||||
// padding rule from section 5.1 is applied to pad the message to a multiple
|
||||
// of the rate, which involves adding a "1" bit, zero or more "0" bits, and
|
||||
// a final "1" bit. We merge the first "1" bit from the padding into dsbyte,
|
||||
// giving 00000110b (0x06) and 00011111b (0x1f).
|
||||
// [1] http://csrc.nist.gov/publications/drafts/fips-202/fips_202_draft.pdf
|
||||
// "Draft FIPS 202: SHA-3 Standard: Permutation-Based Hash and
|
||||
// Extendable-Output Functions (May 2014)"
|
||||
dsbyte byte
|
||||
|
||||
storage storageBuf
|
||||
|
||||
// Specific to SHA-3 and SHAKE.
|
||||
outputLen int // the default output size in bytes
|
||||
state spongeDirection // whether the sponge is absorbing or squeezing
|
||||
}
|
||||
|
||||
// BlockSize returns the rate of sponge underlying this hash function.
|
||||
func (d *State) BlockSize() int { return d.rate }
|
||||
|
||||
// Size returns the output size of the hash function in bytes.
|
||||
func (d *State) Size() int { return d.outputLen }
|
||||
|
||||
// Reset clears the internal state by zeroing the sponge state and
|
||||
// the byte buffer, and setting Sponge.state to absorbing.
|
||||
func (d *State) Reset() {
|
||||
// Zero the permutation's state.
|
||||
for i := range d.a {
|
||||
d.a[i] = 0
|
||||
}
|
||||
d.state = spongeAbsorbing
|
||||
d.bufo = 0
|
||||
d.bufe = 0
|
||||
}
|
||||
|
||||
func (d *State) clone() *State {
|
||||
ret := *d
|
||||
return &ret
|
||||
}
|
||||
|
||||
// permute applies the KeccakF-1600 permutation. It handles
|
||||
// any input-output buffering.
|
||||
func (d *State) permute() {
|
||||
switch d.state {
|
||||
case spongeAbsorbing:
|
||||
// If we're absorbing, we need to xor the input into the state
|
||||
// before applying the permutation.
|
||||
xorIn(d, d.buf())
|
||||
d.bufe = 0
|
||||
d.bufo = 0
|
||||
KeccakF1600(&d.a)
|
||||
case spongeSqueezing:
|
||||
// If we're squeezing, we need to apply the permutation before
|
||||
// copying more output.
|
||||
KeccakF1600(&d.a)
|
||||
d.bufe = d.rate
|
||||
d.bufo = 0
|
||||
copyOut(d, d.buf())
|
||||
}
|
||||
}
|
||||
|
||||
// pads appends the domain separation bits in dsbyte, applies
|
||||
// the multi-bitrate 10..1 padding rule, and permutes the state.
|
||||
func (d *State) padAndPermute(dsbyte byte) {
|
||||
// Pad with this instance's domain-separator bits. We know that there's
|
||||
// at least one byte of space in d.buf() because, if it were full,
|
||||
// permute would have been called to empty it. dsbyte also contains the
|
||||
// first one bit for the padding. See the comment in the state struct.
|
||||
zerosStart := d.bufe + 1
|
||||
d.bufe = d.rate
|
||||
buf := d.buf()
|
||||
buf[zerosStart-1] = dsbyte
|
||||
for i := zerosStart; i < d.rate; i++ {
|
||||
buf[i] = 0
|
||||
}
|
||||
// This adds the final one bit for the padding. Because of the way that
|
||||
// bits are numbered from the LSB upwards, the final bit is the MSB of
|
||||
// the last byte.
|
||||
buf[d.rate-1] ^= 0x80
|
||||
// Apply the permutation
|
||||
d.permute()
|
||||
d.state = spongeSqueezing
|
||||
d.bufe = d.rate
|
||||
copyOut(d, buf)
|
||||
}
|
||||
|
||||
// Write absorbs more data into the hash's state. It produces an error
|
||||
// if more data is written to the ShakeHash after writing
|
||||
func (d *State) Write(p []byte) (written int, err error) {
|
||||
if d.state != spongeAbsorbing {
|
||||
panic("sha3: write to sponge after read")
|
||||
}
|
||||
written = len(p)
|
||||
|
||||
for len(p) > 0 {
|
||||
bufl := d.bufe - d.bufo
|
||||
if bufl == 0 && len(p) >= d.rate {
|
||||
// The fast path; absorb a full "rate" bytes of input and apply the permutation.
|
||||
xorIn(d, p[:d.rate])
|
||||
p = p[d.rate:]
|
||||
KeccakF1600(&d.a)
|
||||
} else {
|
||||
// The slow path; buffer the input until we can fill the sponge, and then xor it in.
|
||||
todo := d.rate - bufl
|
||||
if todo > len(p) {
|
||||
todo = len(p)
|
||||
}
|
||||
d.bufe += todo
|
||||
buf := d.buf()
|
||||
copy(buf[bufl:], p[:todo])
|
||||
p = p[todo:]
|
||||
|
||||
// If the sponge is full, apply the permutation.
|
||||
if d.bufe == d.rate {
|
||||
d.permute()
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
return written, nil
|
||||
}
|
||||
|
||||
// Read squeezes an arbitrary number of bytes from the sponge.
|
||||
func (d *State) Read(out []byte) (n int, err error) {
|
||||
// If we're still absorbing, pad and apply the permutation.
|
||||
if d.state == spongeAbsorbing {
|
||||
d.padAndPermute(d.dsbyte)
|
||||
}
|
||||
|
||||
n = len(out)
|
||||
|
||||
// Now, do the squeezing.
|
||||
for len(out) > 0 {
|
||||
buf := d.buf()
|
||||
n := copy(out, buf)
|
||||
d.bufo += n
|
||||
out = out[n:]
|
||||
|
||||
// Apply the permutation if we've squeezed the sponge dry.
|
||||
if d.bufo == d.bufe {
|
||||
d.permute()
|
||||
}
|
||||
}
|
||||
|
||||
return
|
||||
}
|
||||
|
||||
// Sum applies padding to the hash state and then squeezes out the desired
|
||||
// number of output bytes.
|
||||
func (d *State) Sum(in []byte) []byte {
|
||||
// Make a copy of the original hash so that caller can keep writing
|
||||
// and summing.
|
||||
dup := d.clone()
|
||||
hash := make([]byte, dup.outputLen)
|
||||
_, _ = dup.Read(hash)
|
||||
return append(in, hash...)
|
||||
}
|
||||
33
vendor/github.com/cloudflare/circl/internal/sha3/sha3_s390x.s
generated
vendored
Normal file
33
vendor/github.com/cloudflare/circl/internal/sha3/sha3_s390x.s
generated
vendored
Normal file
@ -0,0 +1,33 @@
|
||||
// Copyright 2017 The Go Authors. All rights reserved.
|
||||
// Use of this source code is governed by a BSD-style
|
||||
// license that can be found in the LICENSE file.
|
||||
|
||||
// +build !gccgo,!appengine
|
||||
|
||||
#include "textflag.h"
|
||||
|
||||
// func kimd(function code, chain *[200]byte, src []byte)
|
||||
TEXT ·kimd(SB), NOFRAME|NOSPLIT, $0-40
|
||||
MOVD function+0(FP), R0
|
||||
MOVD chain+8(FP), R1
|
||||
LMG src+16(FP), R2, R3 // R2=base, R3=len
|
||||
|
||||
continue:
|
||||
WORD $0xB93E0002 // KIMD --, R2
|
||||
BVS continue // continue if interrupted
|
||||
MOVD $0, R0 // reset R0 for pre-go1.8 compilers
|
||||
RET
|
||||
|
||||
// func klmd(function code, chain *[200]byte, dst, src []byte)
|
||||
TEXT ·klmd(SB), NOFRAME|NOSPLIT, $0-64
|
||||
// TODO: SHAKE support
|
||||
MOVD function+0(FP), R0
|
||||
MOVD chain+8(FP), R1
|
||||
LMG dst+16(FP), R2, R3 // R2=base, R3=len
|
||||
LMG src+40(FP), R4, R5 // R4=base, R5=len
|
||||
|
||||
continue:
|
||||
WORD $0xB93F0024 // KLMD R2, R4
|
||||
BVS continue // continue if interrupted
|
||||
MOVD $0, R0 // reset R0 for pre-go1.8 compilers
|
||||
RET
|
||||
79
vendor/github.com/cloudflare/circl/internal/sha3/shake.go
generated
vendored
Normal file
79
vendor/github.com/cloudflare/circl/internal/sha3/shake.go
generated
vendored
Normal file
@ -0,0 +1,79 @@
|
||||
// Copyright 2014 The Go Authors. All rights reserved.
|
||||
// Use of this source code is governed by a BSD-style
|
||||
// license that can be found in the LICENSE file.
|
||||
|
||||
package sha3
|
||||
|
||||
// This file defines the ShakeHash interface, and provides
|
||||
// functions for creating SHAKE and cSHAKE instances, as well as utility
|
||||
// functions for hashing bytes to arbitrary-length output.
|
||||
//
|
||||
//
|
||||
// SHAKE implementation is based on FIPS PUB 202 [1]
|
||||
// cSHAKE implementations is based on NIST SP 800-185 [2]
|
||||
//
|
||||
// [1] https://nvlpubs.nist.gov/nistpubs/FIPS/NIST.FIPS.202.pdf
|
||||
// [2] https://doi.org/10.6028/NIST.SP.800-185
|
||||
|
||||
import (
|
||||
"io"
|
||||
)
|
||||
|
||||
// ShakeHash defines the interface to hash functions that
|
||||
// support arbitrary-length output.
|
||||
type ShakeHash interface {
|
||||
// Write absorbs more data into the hash's state. It panics if input is
|
||||
// written to it after output has been read from it.
|
||||
io.Writer
|
||||
|
||||
// Read reads more output from the hash; reading affects the hash's
|
||||
// state. (ShakeHash.Read is thus very different from Hash.Sum)
|
||||
// It never returns an error.
|
||||
io.Reader
|
||||
|
||||
// Clone returns a copy of the ShakeHash in its current state.
|
||||
Clone() ShakeHash
|
||||
|
||||
// Reset resets the ShakeHash to its initial state.
|
||||
Reset()
|
||||
}
|
||||
|
||||
// Consts for configuring initial SHA-3 state
|
||||
const (
|
||||
dsbyteShake = 0x1f
|
||||
rate128 = 168
|
||||
rate256 = 136
|
||||
)
|
||||
|
||||
// Clone returns copy of SHAKE context within its current state.
|
||||
func (d *State) Clone() ShakeHash {
|
||||
return d.clone()
|
||||
}
|
||||
|
||||
// NewShake128 creates a new SHAKE128 variable-output-length ShakeHash.
|
||||
// Its generic security strength is 128 bits against all attacks if at
|
||||
// least 32 bytes of its output are used.
|
||||
func NewShake128() State {
|
||||
return State{rate: rate128, dsbyte: dsbyteShake}
|
||||
}
|
||||
|
||||
// NewShake256 creates a new SHAKE256 variable-output-length ShakeHash.
|
||||
// Its generic security strength is 256 bits against all attacks if
|
||||
// at least 64 bytes of its output are used.
|
||||
func NewShake256() State {
|
||||
return State{rate: rate256, dsbyte: dsbyteShake}
|
||||
}
|
||||
|
||||
// ShakeSum128 writes an arbitrary-length digest of data into hash.
|
||||
func ShakeSum128(hash, data []byte) {
|
||||
h := NewShake128()
|
||||
_, _ = h.Write(data)
|
||||
_, _ = h.Read(hash)
|
||||
}
|
||||
|
||||
// ShakeSum256 writes an arbitrary-length digest of data into hash.
|
||||
func ShakeSum256(hash, data []byte) {
|
||||
h := NewShake256()
|
||||
_, _ = h.Write(data)
|
||||
_, _ = h.Read(hash)
|
||||
}
|
||||
15
vendor/github.com/cloudflare/circl/internal/sha3/xor.go
generated
vendored
Normal file
15
vendor/github.com/cloudflare/circl/internal/sha3/xor.go
generated
vendored
Normal file
@ -0,0 +1,15 @@
|
||||
// Copyright 2015 The Go Authors. All rights reserved.
|
||||
// Use of this source code is governed by a BSD-style
|
||||
// license that can be found in the LICENSE file.
|
||||
|
||||
//go:build (!amd64 && !386 && !ppc64le) || appengine
|
||||
// +build !amd64,!386,!ppc64le appengine
|
||||
|
||||
package sha3
|
||||
|
||||
// A storageBuf is an aligned array of maxRate bytes.
|
||||
type storageBuf [maxRate]byte
|
||||
|
||||
func (b *storageBuf) asBytes() *[maxRate]byte {
|
||||
return (*[maxRate]byte)(b)
|
||||
}
|
||||
33
vendor/github.com/cloudflare/circl/internal/sha3/xor_generic.go
generated
vendored
Normal file
33
vendor/github.com/cloudflare/circl/internal/sha3/xor_generic.go
generated
vendored
Normal file
@ -0,0 +1,33 @@
|
||||
// Copyright 2015 The Go Authors. All rights reserved.
|
||||
// Use of this source code is governed by a BSD-style
|
||||
// license that can be found in the LICENSE file.
|
||||
|
||||
//go:build (!amd64 || appengine) && (!386 || appengine) && (!ppc64le || appengine)
|
||||
// +build !amd64 appengine
|
||||
// +build !386 appengine
|
||||
// +build !ppc64le appengine
|
||||
|
||||
package sha3
|
||||
|
||||
import "encoding/binary"
|
||||
|
||||
// xorIn xors the bytes in buf into the state; it
|
||||
// makes no non-portable assumptions about memory layout
|
||||
// or alignment.
|
||||
func xorIn(d *State, buf []byte) {
|
||||
n := len(buf) / 8
|
||||
|
||||
for i := 0; i < n; i++ {
|
||||
a := binary.LittleEndian.Uint64(buf)
|
||||
d.a[i] ^= a
|
||||
buf = buf[8:]
|
||||
}
|
||||
}
|
||||
|
||||
// copyOut copies ulint64s to a byte buffer.
|
||||
func copyOut(d *State, b []byte) {
|
||||
for i := 0; len(b) >= 8; i++ {
|
||||
binary.LittleEndian.PutUint64(b, d.a[i])
|
||||
b = b[8:]
|
||||
}
|
||||
}
|
||||
61
vendor/github.com/cloudflare/circl/internal/sha3/xor_unaligned.go
generated
vendored
Normal file
61
vendor/github.com/cloudflare/circl/internal/sha3/xor_unaligned.go
generated
vendored
Normal file
@ -0,0 +1,61 @@
|
||||
// Copyright 2015 The Go Authors. All rights reserved.
|
||||
// Use of this source code is governed by a BSD-style
|
||||
// license that can be found in the LICENSE file.
|
||||
|
||||
//go:build (amd64 || 386 || ppc64le) && !appengine
|
||||
// +build amd64 386 ppc64le
|
||||
// +build !appengine
|
||||
|
||||
package sha3
|
||||
|
||||
import "unsafe"
|
||||
|
||||
// A storageBuf is an aligned array of maxRate bytes.
|
||||
type storageBuf [maxRate / 8]uint64
|
||||
|
||||
func (b *storageBuf) asBytes() *[maxRate]byte {
|
||||
return (*[maxRate]byte)(unsafe.Pointer(b))
|
||||
}
|
||||
|
||||
// xorInuses unaligned reads and writes to update d.a to contain d.a
|
||||
// XOR buf.
|
||||
func xorIn(d *State, buf []byte) {
|
||||
n := len(buf)
|
||||
bw := (*[maxRate / 8]uint64)(unsafe.Pointer(&buf[0]))[: n/8 : n/8]
|
||||
if n >= 72 {
|
||||
d.a[0] ^= bw[0]
|
||||
d.a[1] ^= bw[1]
|
||||
d.a[2] ^= bw[2]
|
||||
d.a[3] ^= bw[3]
|
||||
d.a[4] ^= bw[4]
|
||||
d.a[5] ^= bw[5]
|
||||
d.a[6] ^= bw[6]
|
||||
d.a[7] ^= bw[7]
|
||||
d.a[8] ^= bw[8]
|
||||
}
|
||||
if n >= 104 {
|
||||
d.a[9] ^= bw[9]
|
||||
d.a[10] ^= bw[10]
|
||||
d.a[11] ^= bw[11]
|
||||
d.a[12] ^= bw[12]
|
||||
}
|
||||
if n >= 136 {
|
||||
d.a[13] ^= bw[13]
|
||||
d.a[14] ^= bw[14]
|
||||
d.a[15] ^= bw[15]
|
||||
d.a[16] ^= bw[16]
|
||||
}
|
||||
if n >= 144 {
|
||||
d.a[17] ^= bw[17]
|
||||
}
|
||||
if n >= 168 {
|
||||
d.a[18] ^= bw[18]
|
||||
d.a[19] ^= bw[19]
|
||||
d.a[20] ^= bw[20]
|
||||
}
|
||||
}
|
||||
|
||||
func copyOut(d *State, buf []byte) {
|
||||
ab := (*[maxRate]uint8)(unsafe.Pointer(&d.a[0]))
|
||||
copy(buf, ab[:])
|
||||
}
|
||||
205
vendor/github.com/cloudflare/circl/math/fp25519/fp.go
generated
vendored
Normal file
205
vendor/github.com/cloudflare/circl/math/fp25519/fp.go
generated
vendored
Normal file
@ -0,0 +1,205 @@
|
||||
// Package fp25519 provides prime field arithmetic over GF(2^255-19).
|
||||
package fp25519
|
||||
|
||||
import (
|
||||
"errors"
|
||||
|
||||
"github.com/cloudflare/circl/internal/conv"
|
||||
)
|
||||
|
||||
// Size in bytes of an element.
|
||||
const Size = 32
|
||||
|
||||
// Elt is a prime field element.
|
||||
type Elt [Size]byte
|
||||
|
||||
func (e Elt) String() string { return conv.BytesLe2Hex(e[:]) }
|
||||
|
||||
// p is the prime modulus 2^255-19.
|
||||
var p = Elt{
|
||||
0xed, 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, 0x7f,
|
||||
}
|
||||
|
||||
// P returns the prime modulus 2^255-19.
|
||||
func P() Elt { return p }
|
||||
|
||||
// ToBytes stores in b the little-endian byte representation of x.
|
||||
func ToBytes(b []byte, x *Elt) error {
|
||||
if len(b) != Size {
|
||||
return errors.New("wrong size")
|
||||
}
|
||||
Modp(x)
|
||||
copy(b, x[:])
|
||||
return nil
|
||||
}
|
||||
|
||||
// IsZero returns true if x is equal to 0.
|
||||
func IsZero(x *Elt) bool { Modp(x); return *x == Elt{} }
|
||||
|
||||
// SetOne assigns x=1.
|
||||
func SetOne(x *Elt) { *x = Elt{}; x[0] = 1 }
|
||||
|
||||
// Neg calculates z = -x.
|
||||
func Neg(z, x *Elt) { Sub(z, &p, x) }
|
||||
|
||||
// InvSqrt calculates z = sqrt(x/y) iff x/y is a quadratic-residue, which is
|
||||
// indicated by returning isQR = true. Otherwise, when x/y is a quadratic
|
||||
// non-residue, z will have an undetermined value and isQR = false.
|
||||
func InvSqrt(z, x, y *Elt) (isQR bool) {
|
||||
sqrtMinusOne := &Elt{
|
||||
0xb0, 0xa0, 0x0e, 0x4a, 0x27, 0x1b, 0xee, 0xc4,
|
||||
0x78, 0xe4, 0x2f, 0xad, 0x06, 0x18, 0x43, 0x2f,
|
||||
0xa7, 0xd7, 0xfb, 0x3d, 0x99, 0x00, 0x4d, 0x2b,
|
||||
0x0b, 0xdf, 0xc1, 0x4f, 0x80, 0x24, 0x83, 0x2b,
|
||||
}
|
||||
t0, t1, t2, t3 := &Elt{}, &Elt{}, &Elt{}, &Elt{}
|
||||
|
||||
Mul(t0, x, y) // t0 = u*v
|
||||
Sqr(t1, y) // t1 = v^2
|
||||
Mul(t2, t0, t1) // t2 = u*v^3
|
||||
Sqr(t0, t1) // t0 = v^4
|
||||
Mul(t1, t0, t2) // t1 = u*v^7
|
||||
|
||||
var Tab [4]*Elt
|
||||
Tab[0] = &Elt{}
|
||||
Tab[1] = &Elt{}
|
||||
Tab[2] = t3
|
||||
Tab[3] = t1
|
||||
|
||||
*Tab[0] = *t1
|
||||
Sqr(Tab[0], Tab[0])
|
||||
Sqr(Tab[1], Tab[0])
|
||||
Sqr(Tab[1], Tab[1])
|
||||
Mul(Tab[1], Tab[1], Tab[3])
|
||||
Mul(Tab[0], Tab[0], Tab[1])
|
||||
Sqr(Tab[0], Tab[0])
|
||||
Mul(Tab[0], Tab[0], Tab[1])
|
||||
Sqr(Tab[1], Tab[0])
|
||||
for i := 0; i < 4; i++ {
|
||||
Sqr(Tab[1], Tab[1])
|
||||
}
|
||||
Mul(Tab[1], Tab[1], Tab[0])
|
||||
Sqr(Tab[2], Tab[1])
|
||||
for i := 0; i < 4; i++ {
|
||||
Sqr(Tab[2], Tab[2])
|
||||
}
|
||||
Mul(Tab[2], Tab[2], Tab[0])
|
||||
Sqr(Tab[1], Tab[2])
|
||||
for i := 0; i < 14; i++ {
|
||||
Sqr(Tab[1], Tab[1])
|
||||
}
|
||||
Mul(Tab[1], Tab[1], Tab[2])
|
||||
Sqr(Tab[2], Tab[1])
|
||||
for i := 0; i < 29; i++ {
|
||||
Sqr(Tab[2], Tab[2])
|
||||
}
|
||||
Mul(Tab[2], Tab[2], Tab[1])
|
||||
Sqr(Tab[1], Tab[2])
|
||||
for i := 0; i < 59; i++ {
|
||||
Sqr(Tab[1], Tab[1])
|
||||
}
|
||||
Mul(Tab[1], Tab[1], Tab[2])
|
||||
for i := 0; i < 5; i++ {
|
||||
Sqr(Tab[1], Tab[1])
|
||||
}
|
||||
Mul(Tab[1], Tab[1], Tab[0])
|
||||
Sqr(Tab[2], Tab[1])
|
||||
for i := 0; i < 124; i++ {
|
||||
Sqr(Tab[2], Tab[2])
|
||||
}
|
||||
Mul(Tab[2], Tab[2], Tab[1])
|
||||
Sqr(Tab[2], Tab[2])
|
||||
Sqr(Tab[2], Tab[2])
|
||||
Mul(Tab[2], Tab[2], Tab[3])
|
||||
|
||||
Mul(z, t3, t2) // z = xy^(p+3)/8 = xy^3*(xy^7)^(p-5)/8
|
||||
// Checking whether y z^2 == x
|
||||
Sqr(t0, z) // t0 = z^2
|
||||
Mul(t0, t0, y) // t0 = yz^2
|
||||
Sub(t1, t0, x) // t1 = t0-u
|
||||
Add(t2, t0, x) // t2 = t0+u
|
||||
if IsZero(t1) {
|
||||
return true
|
||||
} else if IsZero(t2) {
|
||||
Mul(z, z, sqrtMinusOne) // z = z*sqrt(-1)
|
||||
return true
|
||||
} else {
|
||||
return false
|
||||
}
|
||||
}
|
||||
|
||||
// Inv calculates z = 1/x mod p.
|
||||
func Inv(z, x *Elt) {
|
||||
x0, x1, x2 := &Elt{}, &Elt{}, &Elt{}
|
||||
Sqr(x1, x)
|
||||
Sqr(x0, x1)
|
||||
Sqr(x0, x0)
|
||||
Mul(x0, x0, x)
|
||||
Mul(z, x0, x1)
|
||||
Sqr(x1, z)
|
||||
Mul(x0, x0, x1)
|
||||
Sqr(x1, x0)
|
||||
for i := 0; i < 4; i++ {
|
||||
Sqr(x1, x1)
|
||||
}
|
||||
Mul(x0, x0, x1)
|
||||
Sqr(x1, x0)
|
||||
for i := 0; i < 9; i++ {
|
||||
Sqr(x1, x1)
|
||||
}
|
||||
Mul(x1, x1, x0)
|
||||
Sqr(x2, x1)
|
||||
for i := 0; i < 19; i++ {
|
||||
Sqr(x2, x2)
|
||||
}
|
||||
Mul(x2, x2, x1)
|
||||
for i := 0; i < 10; i++ {
|
||||
Sqr(x2, x2)
|
||||
}
|
||||
Mul(x2, x2, x0)
|
||||
Sqr(x0, x2)
|
||||
for i := 0; i < 49; i++ {
|
||||
Sqr(x0, x0)
|
||||
}
|
||||
Mul(x0, x0, x2)
|
||||
Sqr(x1, x0)
|
||||
for i := 0; i < 99; i++ {
|
||||
Sqr(x1, x1)
|
||||
}
|
||||
Mul(x1, x1, x0)
|
||||
for i := 0; i < 50; i++ {
|
||||
Sqr(x1, x1)
|
||||
}
|
||||
Mul(x1, x1, x2)
|
||||
for i := 0; i < 5; i++ {
|
||||
Sqr(x1, x1)
|
||||
}
|
||||
Mul(z, z, x1)
|
||||
}
|
||||
|
||||
// Cmov assigns y to x if n is 1.
|
||||
func Cmov(x, y *Elt, n uint) { cmov(x, y, n) }
|
||||
|
||||
// Cswap interchanges x and y if n is 1.
|
||||
func Cswap(x, y *Elt, n uint) { cswap(x, y, n) }
|
||||
|
||||
// Add calculates z = x+y mod p.
|
||||
func Add(z, x, y *Elt) { add(z, x, y) }
|
||||
|
||||
// Sub calculates z = x-y mod p.
|
||||
func Sub(z, x, y *Elt) { sub(z, x, y) }
|
||||
|
||||
// AddSub calculates (x,y) = (x+y mod p, x-y mod p).
|
||||
func AddSub(x, y *Elt) { addsub(x, y) }
|
||||
|
||||
// Mul calculates z = x*y mod p.
|
||||
func Mul(z, x, y *Elt) { mul(z, x, y) }
|
||||
|
||||
// Sqr calculates z = x^2 mod p.
|
||||
func Sqr(z, x *Elt) { sqr(z, x) }
|
||||
|
||||
// Modp ensures that z is between [0,p-1].
|
||||
func Modp(z *Elt) { modp(z) }
|
||||
45
vendor/github.com/cloudflare/circl/math/fp25519/fp_amd64.go
generated
vendored
Normal file
45
vendor/github.com/cloudflare/circl/math/fp25519/fp_amd64.go
generated
vendored
Normal file
@ -0,0 +1,45 @@
|
||||
//go:build amd64 && !purego
|
||||
// +build amd64,!purego
|
||||
|
||||
package fp25519
|
||||
|
||||
import (
|
||||
"golang.org/x/sys/cpu"
|
||||
)
|
||||
|
||||
var hasBmi2Adx = cpu.X86.HasBMI2 && cpu.X86.HasADX
|
||||
|
||||
var _ = hasBmi2Adx
|
||||
|
||||
func cmov(x, y *Elt, n uint) { cmovAmd64(x, y, n) }
|
||||
func cswap(x, y *Elt, n uint) { cswapAmd64(x, y, n) }
|
||||
func add(z, x, y *Elt) { addAmd64(z, x, y) }
|
||||
func sub(z, x, y *Elt) { subAmd64(z, x, y) }
|
||||
func addsub(x, y *Elt) { addsubAmd64(x, y) }
|
||||
func mul(z, x, y *Elt) { mulAmd64(z, x, y) }
|
||||
func sqr(z, x *Elt) { sqrAmd64(z, x) }
|
||||
func modp(z *Elt) { modpAmd64(z) }
|
||||
|
||||
//go:noescape
|
||||
func cmovAmd64(x, y *Elt, n uint)
|
||||
|
||||
//go:noescape
|
||||
func cswapAmd64(x, y *Elt, n uint)
|
||||
|
||||
//go:noescape
|
||||
func addAmd64(z, x, y *Elt)
|
||||
|
||||
//go:noescape
|
||||
func subAmd64(z, x, y *Elt)
|
||||
|
||||
//go:noescape
|
||||
func addsubAmd64(x, y *Elt)
|
||||
|
||||
//go:noescape
|
||||
func mulAmd64(z, x, y *Elt)
|
||||
|
||||
//go:noescape
|
||||
func sqrAmd64(z, x *Elt)
|
||||
|
||||
//go:noescape
|
||||
func modpAmd64(z *Elt)
|
||||
351
vendor/github.com/cloudflare/circl/math/fp25519/fp_amd64.h
generated
vendored
Normal file
351
vendor/github.com/cloudflare/circl/math/fp25519/fp_amd64.h
generated
vendored
Normal file
@ -0,0 +1,351 @@
|
||||
// This code was imported from https://github.com/armfazh/rfc7748_precomputed
|
||||
|
||||
// CHECK_BMI2ADX triggers bmi2adx if supported,
|
||||
// otherwise it fallbacks to legacy code.
|
||||
#define CHECK_BMI2ADX(label, legacy, bmi2adx) \
|
||||
CMPB ·hasBmi2Adx(SB), $0 \
|
||||
JE label \
|
||||
bmi2adx \
|
||||
RET \
|
||||
label: \
|
||||
legacy \
|
||||
RET
|
||||
|
||||
// cselect is a conditional move
|
||||
// if b=1: it copies y into x;
|
||||
// if b=0: x remains with the same value;
|
||||
// if b<> 0,1: undefined.
|
||||
// Uses: AX, DX, FLAGS
|
||||
// Instr: x86_64, cmov
|
||||
#define cselect(x,y,b) \
|
||||
TESTQ b, b \
|
||||
MOVQ 0+x, AX; MOVQ 0+y, DX; CMOVQNE DX, AX; MOVQ AX, 0+x; \
|
||||
MOVQ 8+x, AX; MOVQ 8+y, DX; CMOVQNE DX, AX; MOVQ AX, 8+x; \
|
||||
MOVQ 16+x, AX; MOVQ 16+y, DX; CMOVQNE DX, AX; MOVQ AX, 16+x; \
|
||||
MOVQ 24+x, AX; MOVQ 24+y, DX; CMOVQNE DX, AX; MOVQ AX, 24+x;
|
||||
|
||||
// cswap is a conditional swap
|
||||
// if b=1: x,y <- y,x;
|
||||
// if b=0: x,y remain with the same values;
|
||||
// if b<> 0,1: undefined.
|
||||
// Uses: AX, DX, R8, FLAGS
|
||||
// Instr: x86_64, cmov
|
||||
#define cswap(x,y,b) \
|
||||
TESTQ b, b \
|
||||
MOVQ 0+x, AX; MOVQ AX, R8; MOVQ 0+y, DX; CMOVQNE DX, AX; CMOVQNE R8, DX; MOVQ AX, 0+x; MOVQ DX, 0+y; \
|
||||
MOVQ 8+x, AX; MOVQ AX, R8; MOVQ 8+y, DX; CMOVQNE DX, AX; CMOVQNE R8, DX; MOVQ AX, 8+x; MOVQ DX, 8+y; \
|
||||
MOVQ 16+x, AX; MOVQ AX, R8; MOVQ 16+y, DX; CMOVQNE DX, AX; CMOVQNE R8, DX; MOVQ AX, 16+x; MOVQ DX, 16+y; \
|
||||
MOVQ 24+x, AX; MOVQ AX, R8; MOVQ 24+y, DX; CMOVQNE DX, AX; CMOVQNE R8, DX; MOVQ AX, 24+x; MOVQ DX, 24+y;
|
||||
|
||||
// additionLeg adds x and y and stores in z
|
||||
// Uses: AX, DX, R8-R11, FLAGS
|
||||
// Instr: x86_64, cmov
|
||||
#define additionLeg(z,x,y) \
|
||||
MOVL $38, AX; \
|
||||
MOVL $0, DX; \
|
||||
MOVQ 0+x, R8; ADDQ 0+y, R8; \
|
||||
MOVQ 8+x, R9; ADCQ 8+y, R9; \
|
||||
MOVQ 16+x, R10; ADCQ 16+y, R10; \
|
||||
MOVQ 24+x, R11; ADCQ 24+y, R11; \
|
||||
CMOVQCS AX, DX; \
|
||||
ADDQ DX, R8; \
|
||||
ADCQ $0, R9; MOVQ R9, 8+z; \
|
||||
ADCQ $0, R10; MOVQ R10, 16+z; \
|
||||
ADCQ $0, R11; MOVQ R11, 24+z; \
|
||||
MOVL $0, DX; \
|
||||
CMOVQCS AX, DX; \
|
||||
ADDQ DX, R8; MOVQ R8, 0+z;
|
||||
|
||||
// additionAdx adds x and y and stores in z
|
||||
// Uses: AX, DX, R8-R11, FLAGS
|
||||
// Instr: x86_64, cmov, adx
|
||||
#define additionAdx(z,x,y) \
|
||||
MOVL $38, AX; \
|
||||
XORL DX, DX; \
|
||||
MOVQ 0+x, R8; ADCXQ 0+y, R8; \
|
||||
MOVQ 8+x, R9; ADCXQ 8+y, R9; \
|
||||
MOVQ 16+x, R10; ADCXQ 16+y, R10; \
|
||||
MOVQ 24+x, R11; ADCXQ 24+y, R11; \
|
||||
CMOVQCS AX, DX ; \
|
||||
XORL AX, AX; \
|
||||
ADCXQ DX, R8; \
|
||||
ADCXQ AX, R9; MOVQ R9, 8+z; \
|
||||
ADCXQ AX, R10; MOVQ R10, 16+z; \
|
||||
ADCXQ AX, R11; MOVQ R11, 24+z; \
|
||||
MOVL $38, DX; \
|
||||
CMOVQCS DX, AX; \
|
||||
ADDQ AX, R8; MOVQ R8, 0+z;
|
||||
|
||||
// subtraction subtracts y from x and stores in z
|
||||
// Uses: AX, DX, R8-R11, FLAGS
|
||||
// Instr: x86_64, cmov
|
||||
#define subtraction(z,x,y) \
|
||||
MOVL $38, AX; \
|
||||
MOVQ 0+x, R8; SUBQ 0+y, R8; \
|
||||
MOVQ 8+x, R9; SBBQ 8+y, R9; \
|
||||
MOVQ 16+x, R10; SBBQ 16+y, R10; \
|
||||
MOVQ 24+x, R11; SBBQ 24+y, R11; \
|
||||
MOVL $0, DX; \
|
||||
CMOVQCS AX, DX; \
|
||||
SUBQ DX, R8; \
|
||||
SBBQ $0, R9; MOVQ R9, 8+z; \
|
||||
SBBQ $0, R10; MOVQ R10, 16+z; \
|
||||
SBBQ $0, R11; MOVQ R11, 24+z; \
|
||||
MOVL $0, DX; \
|
||||
CMOVQCS AX, DX; \
|
||||
SUBQ DX, R8; MOVQ R8, 0+z;
|
||||
|
||||
// integerMulAdx multiplies x and y and stores in z
|
||||
// Uses: AX, DX, R8-R15, FLAGS
|
||||
// Instr: x86_64, bmi2, adx
|
||||
#define integerMulAdx(z,x,y) \
|
||||
MOVL $0,R15; \
|
||||
MOVQ 0+y, DX; XORL AX, AX; \
|
||||
MULXQ 0+x, AX, R8; MOVQ AX, 0+z; \
|
||||
MULXQ 8+x, AX, R9; ADCXQ AX, R8; \
|
||||
MULXQ 16+x, AX, R10; ADCXQ AX, R9; \
|
||||
MULXQ 24+x, AX, R11; ADCXQ AX, R10; \
|
||||
MOVL $0, AX;;;;;;;;; ADCXQ AX, R11; \
|
||||
MOVQ 8+y, DX; XORL AX, AX; \
|
||||
MULXQ 0+x, AX, R12; ADCXQ R8, AX; MOVQ AX, 8+z; \
|
||||
MULXQ 8+x, AX, R13; ADCXQ R9, R12; ADOXQ AX, R12; \
|
||||
MULXQ 16+x, AX, R14; ADCXQ R10, R13; ADOXQ AX, R13; \
|
||||
MULXQ 24+x, AX, R15; ADCXQ R11, R14; ADOXQ AX, R14; \
|
||||
MOVL $0, AX;;;;;;;;; ADCXQ AX, R15; ADOXQ AX, R15; \
|
||||
MOVQ 16+y, DX; XORL AX, AX; \
|
||||
MULXQ 0+x, AX, R8; ADCXQ R12, AX; MOVQ AX, 16+z; \
|
||||
MULXQ 8+x, AX, R9; ADCXQ R13, R8; ADOXQ AX, R8; \
|
||||
MULXQ 16+x, AX, R10; ADCXQ R14, R9; ADOXQ AX, R9; \
|
||||
MULXQ 24+x, AX, R11; ADCXQ R15, R10; ADOXQ AX, R10; \
|
||||
MOVL $0, AX;;;;;;;;; ADCXQ AX, R11; ADOXQ AX, R11; \
|
||||
MOVQ 24+y, DX; XORL AX, AX; \
|
||||
MULXQ 0+x, AX, R12; ADCXQ R8, AX; MOVQ AX, 24+z; \
|
||||
MULXQ 8+x, AX, R13; ADCXQ R9, R12; ADOXQ AX, R12; MOVQ R12, 32+z; \
|
||||
MULXQ 16+x, AX, R14; ADCXQ R10, R13; ADOXQ AX, R13; MOVQ R13, 40+z; \
|
||||
MULXQ 24+x, AX, R15; ADCXQ R11, R14; ADOXQ AX, R14; MOVQ R14, 48+z; \
|
||||
MOVL $0, AX;;;;;;;;; ADCXQ AX, R15; ADOXQ AX, R15; MOVQ R15, 56+z;
|
||||
|
||||
// integerMulLeg multiplies x and y and stores in z
|
||||
// Uses: AX, DX, R8-R15, FLAGS
|
||||
// Instr: x86_64
|
||||
#define integerMulLeg(z,x,y) \
|
||||
MOVQ 0+y, R8; \
|
||||
MOVQ 0+x, AX; MULQ R8; MOVQ AX, 0+z; MOVQ DX, R15; \
|
||||
MOVQ 8+x, AX; MULQ R8; MOVQ AX, R13; MOVQ DX, R10; \
|
||||
MOVQ 16+x, AX; MULQ R8; MOVQ AX, R14; MOVQ DX, R11; \
|
||||
MOVQ 24+x, AX; MULQ R8; \
|
||||
ADDQ R13, R15; \
|
||||
ADCQ R14, R10; MOVQ R10, 16+z; \
|
||||
ADCQ AX, R11; MOVQ R11, 24+z; \
|
||||
ADCQ $0, DX; MOVQ DX, 32+z; \
|
||||
MOVQ 8+y, R8; \
|
||||
MOVQ 0+x, AX; MULQ R8; MOVQ AX, R12; MOVQ DX, R9; \
|
||||
MOVQ 8+x, AX; MULQ R8; MOVQ AX, R13; MOVQ DX, R10; \
|
||||
MOVQ 16+x, AX; MULQ R8; MOVQ AX, R14; MOVQ DX, R11; \
|
||||
MOVQ 24+x, AX; MULQ R8; \
|
||||
ADDQ R12, R15; MOVQ R15, 8+z; \
|
||||
ADCQ R13, R9; \
|
||||
ADCQ R14, R10; \
|
||||
ADCQ AX, R11; \
|
||||
ADCQ $0, DX; \
|
||||
ADCQ 16+z, R9; MOVQ R9, R15; \
|
||||
ADCQ 24+z, R10; MOVQ R10, 24+z; \
|
||||
ADCQ 32+z, R11; MOVQ R11, 32+z; \
|
||||
ADCQ $0, DX; MOVQ DX, 40+z; \
|
||||
MOVQ 16+y, R8; \
|
||||
MOVQ 0+x, AX; MULQ R8; MOVQ AX, R12; MOVQ DX, R9; \
|
||||
MOVQ 8+x, AX; MULQ R8; MOVQ AX, R13; MOVQ DX, R10; \
|
||||
MOVQ 16+x, AX; MULQ R8; MOVQ AX, R14; MOVQ DX, R11; \
|
||||
MOVQ 24+x, AX; MULQ R8; \
|
||||
ADDQ R12, R15; MOVQ R15, 16+z; \
|
||||
ADCQ R13, R9; \
|
||||
ADCQ R14, R10; \
|
||||
ADCQ AX, R11; \
|
||||
ADCQ $0, DX; \
|
||||
ADCQ 24+z, R9; MOVQ R9, R15; \
|
||||
ADCQ 32+z, R10; MOVQ R10, 32+z; \
|
||||
ADCQ 40+z, R11; MOVQ R11, 40+z; \
|
||||
ADCQ $0, DX; MOVQ DX, 48+z; \
|
||||
MOVQ 24+y, R8; \
|
||||
MOVQ 0+x, AX; MULQ R8; MOVQ AX, R12; MOVQ DX, R9; \
|
||||
MOVQ 8+x, AX; MULQ R8; MOVQ AX, R13; MOVQ DX, R10; \
|
||||
MOVQ 16+x, AX; MULQ R8; MOVQ AX, R14; MOVQ DX, R11; \
|
||||
MOVQ 24+x, AX; MULQ R8; \
|
||||
ADDQ R12, R15; MOVQ R15, 24+z; \
|
||||
ADCQ R13, R9; \
|
||||
ADCQ R14, R10; \
|
||||
ADCQ AX, R11; \
|
||||
ADCQ $0, DX; \
|
||||
ADCQ 32+z, R9; MOVQ R9, 32+z; \
|
||||
ADCQ 40+z, R10; MOVQ R10, 40+z; \
|
||||
ADCQ 48+z, R11; MOVQ R11, 48+z; \
|
||||
ADCQ $0, DX; MOVQ DX, 56+z;
|
||||
|
||||
// integerSqrLeg squares x and stores in z
|
||||
// Uses: AX, CX, DX, R8-R15, FLAGS
|
||||
// Instr: x86_64
|
||||
#define integerSqrLeg(z,x) \
|
||||
MOVQ 0+x, R8; \
|
||||
MOVQ 8+x, AX; MULQ R8; MOVQ AX, R9; MOVQ DX, R10; /* A[0]*A[1] */ \
|
||||
MOVQ 16+x, AX; MULQ R8; MOVQ AX, R14; MOVQ DX, R11; /* A[0]*A[2] */ \
|
||||
MOVQ 24+x, AX; MULQ R8; MOVQ AX, R15; MOVQ DX, R12; /* A[0]*A[3] */ \
|
||||
MOVQ 24+x, R8; \
|
||||
MOVQ 8+x, AX; MULQ R8; MOVQ AX, CX; MOVQ DX, R13; /* A[3]*A[1] */ \
|
||||
MOVQ 16+x, AX; MULQ R8; /* A[3]*A[2] */ \
|
||||
\
|
||||
ADDQ R14, R10;\
|
||||
ADCQ R15, R11; MOVL $0, R15;\
|
||||
ADCQ CX, R12;\
|
||||
ADCQ AX, R13;\
|
||||
ADCQ $0, DX; MOVQ DX, R14;\
|
||||
MOVQ 8+x, AX; MULQ 16+x;\
|
||||
\
|
||||
ADDQ AX, R11;\
|
||||
ADCQ DX, R12;\
|
||||
ADCQ $0, R13;\
|
||||
ADCQ $0, R14;\
|
||||
ADCQ $0, R15;\
|
||||
\
|
||||
SHLQ $1, R14, R15; MOVQ R15, 56+z;\
|
||||
SHLQ $1, R13, R14; MOVQ R14, 48+z;\
|
||||
SHLQ $1, R12, R13; MOVQ R13, 40+z;\
|
||||
SHLQ $1, R11, R12; MOVQ R12, 32+z;\
|
||||
SHLQ $1, R10, R11; MOVQ R11, 24+z;\
|
||||
SHLQ $1, R9, R10; MOVQ R10, 16+z;\
|
||||
SHLQ $1, R9; MOVQ R9, 8+z;\
|
||||
\
|
||||
MOVQ 0+x,AX; MULQ AX; MOVQ AX, 0+z; MOVQ DX, R9;\
|
||||
MOVQ 8+x,AX; MULQ AX; MOVQ AX, R10; MOVQ DX, R11;\
|
||||
MOVQ 16+x,AX; MULQ AX; MOVQ AX, R12; MOVQ DX, R13;\
|
||||
MOVQ 24+x,AX; MULQ AX; MOVQ AX, R14; MOVQ DX, R15;\
|
||||
\
|
||||
ADDQ 8+z, R9; MOVQ R9, 8+z;\
|
||||
ADCQ 16+z, R10; MOVQ R10, 16+z;\
|
||||
ADCQ 24+z, R11; MOVQ R11, 24+z;\
|
||||
ADCQ 32+z, R12; MOVQ R12, 32+z;\
|
||||
ADCQ 40+z, R13; MOVQ R13, 40+z;\
|
||||
ADCQ 48+z, R14; MOVQ R14, 48+z;\
|
||||
ADCQ 56+z, R15; MOVQ R15, 56+z;
|
||||
|
||||
// integerSqrAdx squares x and stores in z
|
||||
// Uses: AX, CX, DX, R8-R15, FLAGS
|
||||
// Instr: x86_64, bmi2, adx
|
||||
#define integerSqrAdx(z,x) \
|
||||
MOVQ 0+x, DX; /* A[0] */ \
|
||||
MULXQ 8+x, R8, R14; /* A[1]*A[0] */ XORL R15, R15; \
|
||||
MULXQ 16+x, R9, R10; /* A[2]*A[0] */ ADCXQ R14, R9; \
|
||||
MULXQ 24+x, AX, CX; /* A[3]*A[0] */ ADCXQ AX, R10; \
|
||||
MOVQ 24+x, DX; /* A[3] */ \
|
||||
MULXQ 8+x, R11, R12; /* A[1]*A[3] */ ADCXQ CX, R11; \
|
||||
MULXQ 16+x, AX, R13; /* A[2]*A[3] */ ADCXQ AX, R12; \
|
||||
MOVQ 8+x, DX; /* A[1] */ ADCXQ R15, R13; \
|
||||
MULXQ 16+x, AX, CX; /* A[2]*A[1] */ MOVL $0, R14; \
|
||||
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; ADCXQ R15, R14; \
|
||||
XORL R15, R15; \
|
||||
ADOXQ AX, R10; ADCXQ R8, R8; \
|
||||
ADOXQ CX, R11; ADCXQ R9, R9; \
|
||||
ADOXQ R15, R12; ADCXQ R10, R10; \
|
||||
ADOXQ R15, R13; ADCXQ R11, R11; \
|
||||
ADOXQ R15, R14; ADCXQ R12, R12; \
|
||||
;;;;;;;;;;;;;;; ADCXQ R13, R13; \
|
||||
;;;;;;;;;;;;;;; ADCXQ R14, R14; \
|
||||
MOVQ 0+x, DX; MULXQ DX, AX, CX; /* A[0]^2 */ \
|
||||
;;;;;;;;;;;;;;; MOVQ AX, 0+z; \
|
||||
ADDQ CX, R8; MOVQ R8, 8+z; \
|
||||
MOVQ 8+x, DX; MULXQ DX, AX, CX; /* A[1]^2 */ \
|
||||
ADCQ AX, R9; MOVQ R9, 16+z; \
|
||||
ADCQ CX, R10; MOVQ R10, 24+z; \
|
||||
MOVQ 16+x, DX; MULXQ DX, AX, CX; /* A[2]^2 */ \
|
||||
ADCQ AX, R11; MOVQ R11, 32+z; \
|
||||
ADCQ CX, R12; MOVQ R12, 40+z; \
|
||||
MOVQ 24+x, DX; MULXQ DX, AX, CX; /* A[3]^2 */ \
|
||||
ADCQ AX, R13; MOVQ R13, 48+z; \
|
||||
ADCQ CX, R14; MOVQ R14, 56+z;
|
||||
|
||||
// reduceFromDouble finds z congruent to x modulo p such that 0<z<2^256
|
||||
// Uses: AX, DX, R8-R13, FLAGS
|
||||
// Instr: x86_64
|
||||
#define reduceFromDoubleLeg(z,x) \
|
||||
/* 2*C = 38 = 2^256 */ \
|
||||
MOVL $38, AX; MULQ 32+x; MOVQ AX, R8; MOVQ DX, R9; /* C*C[4] */ \
|
||||
MOVL $38, AX; MULQ 40+x; MOVQ AX, R12; MOVQ DX, R10; /* C*C[5] */ \
|
||||
MOVL $38, AX; MULQ 48+x; MOVQ AX, R13; MOVQ DX, R11; /* C*C[6] */ \
|
||||
MOVL $38, AX; MULQ 56+x; /* C*C[7] */ \
|
||||
ADDQ R12, R9; \
|
||||
ADCQ R13, R10; \
|
||||
ADCQ AX, R11; \
|
||||
ADCQ $0, DX; \
|
||||
ADDQ 0+x, R8; \
|
||||
ADCQ 8+x, R9; \
|
||||
ADCQ 16+x, R10; \
|
||||
ADCQ 24+x, R11; \
|
||||
ADCQ $0, DX; \
|
||||
MOVL $38, AX; \
|
||||
IMULQ AX, DX; /* C*C[4], CF=0, OF=0 */ \
|
||||
ADDQ DX, R8; \
|
||||
ADCQ $0, R9; MOVQ R9, 8+z; \
|
||||
ADCQ $0, R10; MOVQ R10, 16+z; \
|
||||
ADCQ $0, R11; MOVQ R11, 24+z; \
|
||||
MOVL $0, DX; \
|
||||
CMOVQCS AX, DX; \
|
||||
ADDQ DX, R8; MOVQ R8, 0+z;
|
||||
|
||||
// reduceFromDoubleAdx finds z congruent to x modulo p such that 0<z<2^256
|
||||
// Uses: AX, DX, R8-R13, FLAGS
|
||||
// Instr: x86_64, bmi2, adx
|
||||
#define reduceFromDoubleAdx(z,x) \
|
||||
MOVL $38, DX; /* 2*C = 38 = 2^256 */ \
|
||||
MULXQ 32+x, R8, R10; /* C*C[4] */ XORL AX, AX; ADOXQ 0+x, R8; \
|
||||
MULXQ 40+x, R9, R11; /* C*C[5] */ ADCXQ R10, R9; ADOXQ 8+x, R9; \
|
||||
MULXQ 48+x, R10, R13; /* C*C[6] */ ADCXQ R11, R10; ADOXQ 16+x, R10; \
|
||||
MULXQ 56+x, R11, R12; /* C*C[7] */ ADCXQ R13, R11; ADOXQ 24+x, R11; \
|
||||
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; ADCXQ AX, R12; ADOXQ AX, R12; \
|
||||
IMULQ DX, R12; /* C*C[4], CF=0, OF=0 */ \
|
||||
ADCXQ R12, R8; \
|
||||
ADCXQ AX, R9; MOVQ R9, 8+z; \
|
||||
ADCXQ AX, R10; MOVQ R10, 16+z; \
|
||||
ADCXQ AX, R11; MOVQ R11, 24+z; \
|
||||
MOVL $0, R12; \
|
||||
CMOVQCS DX, R12; \
|
||||
ADDQ R12, R8; MOVQ R8, 0+z;
|
||||
|
||||
// addSub calculates two operations: x,y = x+y,x-y
|
||||
// Uses: AX, DX, R8-R15, FLAGS
|
||||
#define addSub(x,y) \
|
||||
MOVL $38, AX; \
|
||||
XORL DX, DX; \
|
||||
MOVQ 0+x, R8; MOVQ R8, R12; ADDQ 0+y, R8; \
|
||||
MOVQ 8+x, R9; MOVQ R9, R13; ADCQ 8+y, R9; \
|
||||
MOVQ 16+x, R10; MOVQ R10, R14; ADCQ 16+y, R10; \
|
||||
MOVQ 24+x, R11; MOVQ R11, R15; ADCQ 24+y, R11; \
|
||||
CMOVQCS AX, DX; \
|
||||
XORL AX, AX; \
|
||||
ADDQ DX, R8; \
|
||||
ADCQ $0, R9; \
|
||||
ADCQ $0, R10; \
|
||||
ADCQ $0, R11; \
|
||||
MOVL $38, DX; \
|
||||
CMOVQCS DX, AX; \
|
||||
ADDQ AX, R8; \
|
||||
MOVL $38, AX; \
|
||||
SUBQ 0+y, R12; \
|
||||
SBBQ 8+y, R13; \
|
||||
SBBQ 16+y, R14; \
|
||||
SBBQ 24+y, R15; \
|
||||
MOVL $0, DX; \
|
||||
CMOVQCS AX, DX; \
|
||||
SUBQ DX, R12; \
|
||||
SBBQ $0, R13; \
|
||||
SBBQ $0, R14; \
|
||||
SBBQ $0, R15; \
|
||||
MOVL $0, DX; \
|
||||
CMOVQCS AX, DX; \
|
||||
SUBQ DX, R12; \
|
||||
MOVQ R8, 0+x; \
|
||||
MOVQ R9, 8+x; \
|
||||
MOVQ R10, 16+x; \
|
||||
MOVQ R11, 24+x; \
|
||||
MOVQ R12, 0+y; \
|
||||
MOVQ R13, 8+y; \
|
||||
MOVQ R14, 16+y; \
|
||||
MOVQ R15, 24+y;
|
||||
111
vendor/github.com/cloudflare/circl/math/fp25519/fp_amd64.s
generated
vendored
Normal file
111
vendor/github.com/cloudflare/circl/math/fp25519/fp_amd64.s
generated
vendored
Normal file
@ -0,0 +1,111 @@
|
||||
// +build amd64
|
||||
|
||||
#include "textflag.h"
|
||||
#include "fp_amd64.h"
|
||||
|
||||
// func cmovAmd64(x, y *Elt, n uint)
|
||||
TEXT ·cmovAmd64(SB),NOSPLIT,$0-24
|
||||
MOVQ x+0(FP), DI
|
||||
MOVQ y+8(FP), SI
|
||||
MOVQ n+16(FP), BX
|
||||
cselect(0(DI),0(SI),BX)
|
||||
RET
|
||||
|
||||
// func cswapAmd64(x, y *Elt, n uint)
|
||||
TEXT ·cswapAmd64(SB),NOSPLIT,$0-24
|
||||
MOVQ x+0(FP), DI
|
||||
MOVQ y+8(FP), SI
|
||||
MOVQ n+16(FP), BX
|
||||
cswap(0(DI),0(SI),BX)
|
||||
RET
|
||||
|
||||
// func subAmd64(z, x, y *Elt)
|
||||
TEXT ·subAmd64(SB),NOSPLIT,$0-24
|
||||
MOVQ z+0(FP), DI
|
||||
MOVQ x+8(FP), SI
|
||||
MOVQ y+16(FP), BX
|
||||
subtraction(0(DI),0(SI),0(BX))
|
||||
RET
|
||||
|
||||
// func addsubAmd64(x, y *Elt)
|
||||
TEXT ·addsubAmd64(SB),NOSPLIT,$0-16
|
||||
MOVQ x+0(FP), DI
|
||||
MOVQ y+8(FP), SI
|
||||
addSub(0(DI),0(SI))
|
||||
RET
|
||||
|
||||
#define addLegacy \
|
||||
additionLeg(0(DI),0(SI),0(BX))
|
||||
#define addBmi2Adx \
|
||||
additionAdx(0(DI),0(SI),0(BX))
|
||||
|
||||
#define mulLegacy \
|
||||
integerMulLeg(0(SP),0(SI),0(BX)) \
|
||||
reduceFromDoubleLeg(0(DI),0(SP))
|
||||
#define mulBmi2Adx \
|
||||
integerMulAdx(0(SP),0(SI),0(BX)) \
|
||||
reduceFromDoubleAdx(0(DI),0(SP))
|
||||
|
||||
#define sqrLegacy \
|
||||
integerSqrLeg(0(SP),0(SI)) \
|
||||
reduceFromDoubleLeg(0(DI),0(SP))
|
||||
#define sqrBmi2Adx \
|
||||
integerSqrAdx(0(SP),0(SI)) \
|
||||
reduceFromDoubleAdx(0(DI),0(SP))
|
||||
|
||||
// func addAmd64(z, x, y *Elt)
|
||||
TEXT ·addAmd64(SB),NOSPLIT,$0-24
|
||||
MOVQ z+0(FP), DI
|
||||
MOVQ x+8(FP), SI
|
||||
MOVQ y+16(FP), BX
|
||||
CHECK_BMI2ADX(LADD, addLegacy, addBmi2Adx)
|
||||
|
||||
// func mulAmd64(z, x, y *Elt)
|
||||
TEXT ·mulAmd64(SB),NOSPLIT,$64-24
|
||||
MOVQ z+0(FP), DI
|
||||
MOVQ x+8(FP), SI
|
||||
MOVQ y+16(FP), BX
|
||||
CHECK_BMI2ADX(LMUL, mulLegacy, mulBmi2Adx)
|
||||
|
||||
// func sqrAmd64(z, x *Elt)
|
||||
TEXT ·sqrAmd64(SB),NOSPLIT,$64-16
|
||||
MOVQ z+0(FP), DI
|
||||
MOVQ x+8(FP), SI
|
||||
CHECK_BMI2ADX(LSQR, sqrLegacy, sqrBmi2Adx)
|
||||
|
||||
// func modpAmd64(z *Elt)
|
||||
TEXT ·modpAmd64(SB),NOSPLIT,$0-8
|
||||
MOVQ z+0(FP), DI
|
||||
|
||||
MOVQ (DI), R8
|
||||
MOVQ 8(DI), R9
|
||||
MOVQ 16(DI), R10
|
||||
MOVQ 24(DI), R11
|
||||
|
||||
MOVL $19, AX
|
||||
MOVL $38, CX
|
||||
|
||||
BTRQ $63, R11 // PUT BIT 255 IN CARRY FLAG AND CLEAR
|
||||
CMOVLCC AX, CX // C[255] ? 38 : 19
|
||||
|
||||
// ADD EITHER 19 OR 38 TO C
|
||||
ADDQ CX, R8
|
||||
ADCQ $0, R9
|
||||
ADCQ $0, R10
|
||||
ADCQ $0, R11
|
||||
|
||||
// TEST FOR BIT 255 AGAIN; ONLY TRIGGERED ON OVERFLOW MODULO 2^255-19
|
||||
MOVL $0, CX
|
||||
CMOVLPL AX, CX // C[255] ? 0 : 19
|
||||
BTRQ $63, R11 // CLEAR BIT 255
|
||||
|
||||
// SUBTRACT 19 IF NECESSARY
|
||||
SUBQ CX, R8
|
||||
MOVQ R8, (DI)
|
||||
SBBQ $0, R9
|
||||
MOVQ R9, 8(DI)
|
||||
SBBQ $0, R10
|
||||
MOVQ R10, 16(DI)
|
||||
SBBQ $0, R11
|
||||
MOVQ R11, 24(DI)
|
||||
RET
|
||||
317
vendor/github.com/cloudflare/circl/math/fp25519/fp_generic.go
generated
vendored
Normal file
317
vendor/github.com/cloudflare/circl/math/fp25519/fp_generic.go
generated
vendored
Normal file
@ -0,0 +1,317 @@
|
||||
package fp25519
|
||||
|
||||
import (
|
||||
"encoding/binary"
|
||||
"math/bits"
|
||||
)
|
||||
|
||||
func cmovGeneric(x, y *Elt, n uint) {
|
||||
m := -uint64(n & 0x1)
|
||||
x0 := binary.LittleEndian.Uint64(x[0*8 : 1*8])
|
||||
x1 := binary.LittleEndian.Uint64(x[1*8 : 2*8])
|
||||
x2 := binary.LittleEndian.Uint64(x[2*8 : 3*8])
|
||||
x3 := binary.LittleEndian.Uint64(x[3*8 : 4*8])
|
||||
|
||||
y0 := binary.LittleEndian.Uint64(y[0*8 : 1*8])
|
||||
y1 := binary.LittleEndian.Uint64(y[1*8 : 2*8])
|
||||
y2 := binary.LittleEndian.Uint64(y[2*8 : 3*8])
|
||||
y3 := binary.LittleEndian.Uint64(y[3*8 : 4*8])
|
||||
|
||||
x0 = (x0 &^ m) | (y0 & m)
|
||||
x1 = (x1 &^ m) | (y1 & m)
|
||||
x2 = (x2 &^ m) | (y2 & m)
|
||||
x3 = (x3 &^ m) | (y3 & m)
|
||||
|
||||
binary.LittleEndian.PutUint64(x[0*8:1*8], x0)
|
||||
binary.LittleEndian.PutUint64(x[1*8:2*8], x1)
|
||||
binary.LittleEndian.PutUint64(x[2*8:3*8], x2)
|
||||
binary.LittleEndian.PutUint64(x[3*8:4*8], x3)
|
||||
}
|
||||
|
||||
func cswapGeneric(x, y *Elt, n uint) {
|
||||
m := -uint64(n & 0x1)
|
||||
x0 := binary.LittleEndian.Uint64(x[0*8 : 1*8])
|
||||
x1 := binary.LittleEndian.Uint64(x[1*8 : 2*8])
|
||||
x2 := binary.LittleEndian.Uint64(x[2*8 : 3*8])
|
||||
x3 := binary.LittleEndian.Uint64(x[3*8 : 4*8])
|
||||
|
||||
y0 := binary.LittleEndian.Uint64(y[0*8 : 1*8])
|
||||
y1 := binary.LittleEndian.Uint64(y[1*8 : 2*8])
|
||||
y2 := binary.LittleEndian.Uint64(y[2*8 : 3*8])
|
||||
y3 := binary.LittleEndian.Uint64(y[3*8 : 4*8])
|
||||
|
||||
t0 := m & (x0 ^ y0)
|
||||
t1 := m & (x1 ^ y1)
|
||||
t2 := m & (x2 ^ y2)
|
||||
t3 := m & (x3 ^ y3)
|
||||
x0 ^= t0
|
||||
x1 ^= t1
|
||||
x2 ^= t2
|
||||
x3 ^= t3
|
||||
y0 ^= t0
|
||||
y1 ^= t1
|
||||
y2 ^= t2
|
||||
y3 ^= t3
|
||||
|
||||
binary.LittleEndian.PutUint64(x[0*8:1*8], x0)
|
||||
binary.LittleEndian.PutUint64(x[1*8:2*8], x1)
|
||||
binary.LittleEndian.PutUint64(x[2*8:3*8], x2)
|
||||
binary.LittleEndian.PutUint64(x[3*8:4*8], x3)
|
||||
|
||||
binary.LittleEndian.PutUint64(y[0*8:1*8], y0)
|
||||
binary.LittleEndian.PutUint64(y[1*8:2*8], y1)
|
||||
binary.LittleEndian.PutUint64(y[2*8:3*8], y2)
|
||||
binary.LittleEndian.PutUint64(y[3*8:4*8], y3)
|
||||
}
|
||||
|
||||
func addGeneric(z, x, y *Elt) {
|
||||
x0 := binary.LittleEndian.Uint64(x[0*8 : 1*8])
|
||||
x1 := binary.LittleEndian.Uint64(x[1*8 : 2*8])
|
||||
x2 := binary.LittleEndian.Uint64(x[2*8 : 3*8])
|
||||
x3 := binary.LittleEndian.Uint64(x[3*8 : 4*8])
|
||||
|
||||
y0 := binary.LittleEndian.Uint64(y[0*8 : 1*8])
|
||||
y1 := binary.LittleEndian.Uint64(y[1*8 : 2*8])
|
||||
y2 := binary.LittleEndian.Uint64(y[2*8 : 3*8])
|
||||
y3 := binary.LittleEndian.Uint64(y[3*8 : 4*8])
|
||||
|
||||
z0, c0 := bits.Add64(x0, y0, 0)
|
||||
z1, c1 := bits.Add64(x1, y1, c0)
|
||||
z2, c2 := bits.Add64(x2, y2, c1)
|
||||
z3, c3 := bits.Add64(x3, y3, c2)
|
||||
|
||||
z0, c0 = bits.Add64(z0, (-c3)&38, 0)
|
||||
z1, c1 = bits.Add64(z1, 0, c0)
|
||||
z2, c2 = bits.Add64(z2, 0, c1)
|
||||
z3, c3 = bits.Add64(z3, 0, c2)
|
||||
z0, _ = bits.Add64(z0, (-c3)&38, 0)
|
||||
|
||||
binary.LittleEndian.PutUint64(z[0*8:1*8], z0)
|
||||
binary.LittleEndian.PutUint64(z[1*8:2*8], z1)
|
||||
binary.LittleEndian.PutUint64(z[2*8:3*8], z2)
|
||||
binary.LittleEndian.PutUint64(z[3*8:4*8], z3)
|
||||
}
|
||||
|
||||
func subGeneric(z, x, y *Elt) {
|
||||
x0 := binary.LittleEndian.Uint64(x[0*8 : 1*8])
|
||||
x1 := binary.LittleEndian.Uint64(x[1*8 : 2*8])
|
||||
x2 := binary.LittleEndian.Uint64(x[2*8 : 3*8])
|
||||
x3 := binary.LittleEndian.Uint64(x[3*8 : 4*8])
|
||||
|
||||
y0 := binary.LittleEndian.Uint64(y[0*8 : 1*8])
|
||||
y1 := binary.LittleEndian.Uint64(y[1*8 : 2*8])
|
||||
y2 := binary.LittleEndian.Uint64(y[2*8 : 3*8])
|
||||
y3 := binary.LittleEndian.Uint64(y[3*8 : 4*8])
|
||||
|
||||
z0, c0 := bits.Sub64(x0, y0, 0)
|
||||
z1, c1 := bits.Sub64(x1, y1, c0)
|
||||
z2, c2 := bits.Sub64(x2, y2, c1)
|
||||
z3, c3 := bits.Sub64(x3, y3, c2)
|
||||
|
||||
z0, c0 = bits.Sub64(z0, (-c3)&38, 0)
|
||||
z1, c1 = bits.Sub64(z1, 0, c0)
|
||||
z2, c2 = bits.Sub64(z2, 0, c1)
|
||||
z3, c3 = bits.Sub64(z3, 0, c2)
|
||||
z0, _ = bits.Sub64(z0, (-c3)&38, 0)
|
||||
|
||||
binary.LittleEndian.PutUint64(z[0*8:1*8], z0)
|
||||
binary.LittleEndian.PutUint64(z[1*8:2*8], z1)
|
||||
binary.LittleEndian.PutUint64(z[2*8:3*8], z2)
|
||||
binary.LittleEndian.PutUint64(z[3*8:4*8], z3)
|
||||
}
|
||||
|
||||
func addsubGeneric(x, y *Elt) {
|
||||
z := &Elt{}
|
||||
addGeneric(z, x, y)
|
||||
subGeneric(y, x, y)
|
||||
*x = *z
|
||||
}
|
||||
|
||||
func mulGeneric(z, x, y *Elt) {
|
||||
x0 := binary.LittleEndian.Uint64(x[0*8 : 1*8])
|
||||
x1 := binary.LittleEndian.Uint64(x[1*8 : 2*8])
|
||||
x2 := binary.LittleEndian.Uint64(x[2*8 : 3*8])
|
||||
x3 := binary.LittleEndian.Uint64(x[3*8 : 4*8])
|
||||
|
||||
y0 := binary.LittleEndian.Uint64(y[0*8 : 1*8])
|
||||
y1 := binary.LittleEndian.Uint64(y[1*8 : 2*8])
|
||||
y2 := binary.LittleEndian.Uint64(y[2*8 : 3*8])
|
||||
y3 := binary.LittleEndian.Uint64(y[3*8 : 4*8])
|
||||
|
||||
yi := y0
|
||||
h0, l0 := bits.Mul64(x0, yi)
|
||||
h1, l1 := bits.Mul64(x1, yi)
|
||||
h2, l2 := bits.Mul64(x2, yi)
|
||||
h3, l3 := bits.Mul64(x3, yi)
|
||||
|
||||
z0 := l0
|
||||
a0, c0 := bits.Add64(h0, l1, 0)
|
||||
a1, c1 := bits.Add64(h1, l2, c0)
|
||||
a2, c2 := bits.Add64(h2, l3, c1)
|
||||
a3, _ := bits.Add64(h3, 0, c2)
|
||||
|
||||
yi = y1
|
||||
h0, l0 = bits.Mul64(x0, yi)
|
||||
h1, l1 = bits.Mul64(x1, yi)
|
||||
h2, l2 = bits.Mul64(x2, yi)
|
||||
h3, l3 = bits.Mul64(x3, yi)
|
||||
|
||||
z1, c0 := bits.Add64(a0, l0, 0)
|
||||
h0, c1 = bits.Add64(h0, l1, c0)
|
||||
h1, c2 = bits.Add64(h1, l2, c1)
|
||||
h2, c3 := bits.Add64(h2, l3, c2)
|
||||
h3, _ = bits.Add64(h3, 0, c3)
|
||||
|
||||
a0, c0 = bits.Add64(a1, h0, 0)
|
||||
a1, c1 = bits.Add64(a2, h1, c0)
|
||||
a2, c2 = bits.Add64(a3, h2, c1)
|
||||
a3, _ = bits.Add64(0, h3, c2)
|
||||
|
||||
yi = y2
|
||||
h0, l0 = bits.Mul64(x0, yi)
|
||||
h1, l1 = bits.Mul64(x1, yi)
|
||||
h2, l2 = bits.Mul64(x2, yi)
|
||||
h3, l3 = bits.Mul64(x3, yi)
|
||||
|
||||
z2, c0 := bits.Add64(a0, l0, 0)
|
||||
h0, c1 = bits.Add64(h0, l1, c0)
|
||||
h1, c2 = bits.Add64(h1, l2, c1)
|
||||
h2, c3 = bits.Add64(h2, l3, c2)
|
||||
h3, _ = bits.Add64(h3, 0, c3)
|
||||
|
||||
a0, c0 = bits.Add64(a1, h0, 0)
|
||||
a1, c1 = bits.Add64(a2, h1, c0)
|
||||
a2, c2 = bits.Add64(a3, h2, c1)
|
||||
a3, _ = bits.Add64(0, h3, c2)
|
||||
|
||||
yi = y3
|
||||
h0, l0 = bits.Mul64(x0, yi)
|
||||
h1, l1 = bits.Mul64(x1, yi)
|
||||
h2, l2 = bits.Mul64(x2, yi)
|
||||
h3, l3 = bits.Mul64(x3, yi)
|
||||
|
||||
z3, c0 := bits.Add64(a0, l0, 0)
|
||||
h0, c1 = bits.Add64(h0, l1, c0)
|
||||
h1, c2 = bits.Add64(h1, l2, c1)
|
||||
h2, c3 = bits.Add64(h2, l3, c2)
|
||||
h3, _ = bits.Add64(h3, 0, c3)
|
||||
|
||||
z4, c0 := bits.Add64(a1, h0, 0)
|
||||
z5, c1 := bits.Add64(a2, h1, c0)
|
||||
z6, c2 := bits.Add64(a3, h2, c1)
|
||||
z7, _ := bits.Add64(0, h3, c2)
|
||||
|
||||
red64(z, z0, z1, z2, z3, z4, z5, z6, z7)
|
||||
}
|
||||
|
||||
func sqrGeneric(z, x *Elt) {
|
||||
x0 := binary.LittleEndian.Uint64(x[0*8 : 1*8])
|
||||
x1 := binary.LittleEndian.Uint64(x[1*8 : 2*8])
|
||||
x2 := binary.LittleEndian.Uint64(x[2*8 : 3*8])
|
||||
x3 := binary.LittleEndian.Uint64(x[3*8 : 4*8])
|
||||
|
||||
h0, a0 := bits.Mul64(x0, x1)
|
||||
h1, l1 := bits.Mul64(x0, x2)
|
||||
h2, l2 := bits.Mul64(x0, x3)
|
||||
h3, l3 := bits.Mul64(x3, x1)
|
||||
h4, l4 := bits.Mul64(x3, x2)
|
||||
h, l := bits.Mul64(x1, x2)
|
||||
|
||||
a1, c0 := bits.Add64(l1, h0, 0)
|
||||
a2, c1 := bits.Add64(l2, h1, c0)
|
||||
a3, c2 := bits.Add64(l3, h2, c1)
|
||||
a4, c3 := bits.Add64(l4, h3, c2)
|
||||
a5, _ := bits.Add64(h4, 0, c3)
|
||||
|
||||
a2, c0 = bits.Add64(a2, l, 0)
|
||||
a3, c1 = bits.Add64(a3, h, c0)
|
||||
a4, c2 = bits.Add64(a4, 0, c1)
|
||||
a5, c3 = bits.Add64(a5, 0, c2)
|
||||
a6, _ := bits.Add64(0, 0, c3)
|
||||
|
||||
a0, c0 = bits.Add64(a0, a0, 0)
|
||||
a1, c1 = bits.Add64(a1, a1, c0)
|
||||
a2, c2 = bits.Add64(a2, a2, c1)
|
||||
a3, c3 = bits.Add64(a3, a3, c2)
|
||||
a4, c4 := bits.Add64(a4, a4, c3)
|
||||
a5, c5 := bits.Add64(a5, a5, c4)
|
||||
a6, _ = bits.Add64(a6, a6, c5)
|
||||
|
||||
b1, b0 := bits.Mul64(x0, x0)
|
||||
b3, b2 := bits.Mul64(x1, x1)
|
||||
b5, b4 := bits.Mul64(x2, x2)
|
||||
b7, b6 := bits.Mul64(x3, x3)
|
||||
|
||||
b1, c0 = bits.Add64(b1, a0, 0)
|
||||
b2, c1 = bits.Add64(b2, a1, c0)
|
||||
b3, c2 = bits.Add64(b3, a2, c1)
|
||||
b4, c3 = bits.Add64(b4, a3, c2)
|
||||
b5, c4 = bits.Add64(b5, a4, c3)
|
||||
b6, c5 = bits.Add64(b6, a5, c4)
|
||||
b7, _ = bits.Add64(b7, a6, c5)
|
||||
|
||||
red64(z, b0, b1, b2, b3, b4, b5, b6, b7)
|
||||
}
|
||||
|
||||
func modpGeneric(x *Elt) {
|
||||
x0 := binary.LittleEndian.Uint64(x[0*8 : 1*8])
|
||||
x1 := binary.LittleEndian.Uint64(x[1*8 : 2*8])
|
||||
x2 := binary.LittleEndian.Uint64(x[2*8 : 3*8])
|
||||
x3 := binary.LittleEndian.Uint64(x[3*8 : 4*8])
|
||||
|
||||
// CX = C[255] ? 38 : 19
|
||||
cx := uint64(19) << (x3 >> 63)
|
||||
// PUT BIT 255 IN CARRY FLAG AND CLEAR
|
||||
x3 &^= 1 << 63
|
||||
|
||||
x0, c0 := bits.Add64(x0, cx, 0)
|
||||
x1, c1 := bits.Add64(x1, 0, c0)
|
||||
x2, c2 := bits.Add64(x2, 0, c1)
|
||||
x3, _ = bits.Add64(x3, 0, c2)
|
||||
|
||||
// TEST FOR BIT 255 AGAIN; ONLY TRIGGERED ON OVERFLOW MODULO 2^255-19
|
||||
// cx = C[255] ? 0 : 19
|
||||
cx = uint64(19) &^ (-(x3 >> 63))
|
||||
// CLEAR BIT 255
|
||||
x3 &^= 1 << 63
|
||||
|
||||
x0, c0 = bits.Sub64(x0, cx, 0)
|
||||
x1, c1 = bits.Sub64(x1, 0, c0)
|
||||
x2, c2 = bits.Sub64(x2, 0, c1)
|
||||
x3, _ = bits.Sub64(x3, 0, c2)
|
||||
|
||||
binary.LittleEndian.PutUint64(x[0*8:1*8], x0)
|
||||
binary.LittleEndian.PutUint64(x[1*8:2*8], x1)
|
||||
binary.LittleEndian.PutUint64(x[2*8:3*8], x2)
|
||||
binary.LittleEndian.PutUint64(x[3*8:4*8], x3)
|
||||
}
|
||||
|
||||
func red64(z *Elt, x0, x1, x2, x3, x4, x5, x6, x7 uint64) {
|
||||
h0, l0 := bits.Mul64(x4, 38)
|
||||
h1, l1 := bits.Mul64(x5, 38)
|
||||
h2, l2 := bits.Mul64(x6, 38)
|
||||
h3, l3 := bits.Mul64(x7, 38)
|
||||
|
||||
l1, c0 := bits.Add64(h0, l1, 0)
|
||||
l2, c1 := bits.Add64(h1, l2, c0)
|
||||
l3, c2 := bits.Add64(h2, l3, c1)
|
||||
l4, _ := bits.Add64(h3, 0, c2)
|
||||
|
||||
l0, c0 = bits.Add64(l0, x0, 0)
|
||||
l1, c1 = bits.Add64(l1, x1, c0)
|
||||
l2, c2 = bits.Add64(l2, x2, c1)
|
||||
l3, c3 := bits.Add64(l3, x3, c2)
|
||||
l4, _ = bits.Add64(l4, 0, c3)
|
||||
|
||||
_, l4 = bits.Mul64(l4, 38)
|
||||
l0, c0 = bits.Add64(l0, l4, 0)
|
||||
z1, c1 := bits.Add64(l1, 0, c0)
|
||||
z2, c2 := bits.Add64(l2, 0, c1)
|
||||
z3, c3 := bits.Add64(l3, 0, c2)
|
||||
z0, _ := bits.Add64(l0, (-c3)&38, 0)
|
||||
|
||||
binary.LittleEndian.PutUint64(z[0*8:1*8], z0)
|
||||
binary.LittleEndian.PutUint64(z[1*8:2*8], z1)
|
||||
binary.LittleEndian.PutUint64(z[2*8:3*8], z2)
|
||||
binary.LittleEndian.PutUint64(z[3*8:4*8], z3)
|
||||
}
|
||||
13
vendor/github.com/cloudflare/circl/math/fp25519/fp_noasm.go
generated
vendored
Normal file
13
vendor/github.com/cloudflare/circl/math/fp25519/fp_noasm.go
generated
vendored
Normal file
@ -0,0 +1,13 @@
|
||||
//go:build !amd64 || purego
|
||||
// +build !amd64 purego
|
||||
|
||||
package fp25519
|
||||
|
||||
func cmov(x, y *Elt, n uint) { cmovGeneric(x, y, n) }
|
||||
func cswap(x, y *Elt, n uint) { cswapGeneric(x, y, n) }
|
||||
func add(z, x, y *Elt) { addGeneric(z, x, y) }
|
||||
func sub(z, x, y *Elt) { subGeneric(z, x, y) }
|
||||
func addsub(x, y *Elt) { addsubGeneric(x, y) }
|
||||
func mul(z, x, y *Elt) { mulGeneric(z, x, y) }
|
||||
func sqr(z, x *Elt) { sqrGeneric(z, x) }
|
||||
func modp(z *Elt) { modpGeneric(z) }
|
||||
164
vendor/github.com/cloudflare/circl/math/fp448/fp.go
generated
vendored
Normal file
164
vendor/github.com/cloudflare/circl/math/fp448/fp.go
generated
vendored
Normal file
@ -0,0 +1,164 @@
|
||||
// Package fp448 provides prime field arithmetic over GF(2^448-2^224-1).
|
||||
package fp448
|
||||
|
||||
import (
|
||||
"errors"
|
||||
|
||||
"github.com/cloudflare/circl/internal/conv"
|
||||
)
|
||||
|
||||
// Size in bytes of an element.
|
||||
const Size = 56
|
||||
|
||||
// Elt is a prime field element.
|
||||
type Elt [Size]byte
|
||||
|
||||
func (e Elt) String() string { return conv.BytesLe2Hex(e[:]) }
|
||||
|
||||
// p is the prime modulus 2^448-2^224-1.
|
||||
var p = Elt{
|
||||
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, 0xfe, 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,
|
||||
}
|
||||
|
||||
// P returns the prime modulus 2^448-2^224-1.
|
||||
func P() Elt { return p }
|
||||
|
||||
// ToBytes stores in b the little-endian byte representation of x.
|
||||
func ToBytes(b []byte, x *Elt) error {
|
||||
if len(b) != Size {
|
||||
return errors.New("wrong size")
|
||||
}
|
||||
Modp(x)
|
||||
copy(b, x[:])
|
||||
return nil
|
||||
}
|
||||
|
||||
// IsZero returns true if x is equal to 0.
|
||||
func IsZero(x *Elt) bool { Modp(x); return *x == Elt{} }
|
||||
|
||||
// IsOne returns true if x is equal to 1.
|
||||
func IsOne(x *Elt) bool { Modp(x); return *x == Elt{1} }
|
||||
|
||||
// SetOne assigns x=1.
|
||||
func SetOne(x *Elt) { *x = Elt{1} }
|
||||
|
||||
// One returns the 1 element.
|
||||
func One() (x Elt) { x = Elt{1}; return }
|
||||
|
||||
// Neg calculates z = -x.
|
||||
func Neg(z, x *Elt) { Sub(z, &p, x) }
|
||||
|
||||
// Modp ensures that z is between [0,p-1].
|
||||
func Modp(z *Elt) { Sub(z, z, &p) }
|
||||
|
||||
// InvSqrt calculates z = sqrt(x/y) iff x/y is a quadratic-residue. If so,
|
||||
// isQR = true; otherwise, isQR = false, since x/y is a quadratic non-residue,
|
||||
// and z = sqrt(-x/y).
|
||||
func InvSqrt(z, x, y *Elt) (isQR bool) {
|
||||
// First note that x^(2(k+1)) = x^(p-1)/2 * x = legendre(x) * x
|
||||
// so that's x if x is a quadratic residue and -x otherwise.
|
||||
// Next, y^(6k+3) = y^(4k+2) * y^(2k+1) = y^(p-1) * y^((p-1)/2) = legendre(y).
|
||||
// So the z we compute satisfies z^2 y = x^(2(k+1)) y^(6k+3) = legendre(x)*legendre(y).
|
||||
// Thus if x and y are quadratic residues, then z is indeed sqrt(x/y).
|
||||
t0, t1 := &Elt{}, &Elt{}
|
||||
Mul(t0, x, y) // x*y
|
||||
Sqr(t1, y) // y^2
|
||||
Mul(t1, t0, t1) // x*y^3
|
||||
powPminus3div4(z, t1) // (x*y^3)^k
|
||||
Mul(z, z, t0) // z = x*y*(x*y^3)^k = x^(k+1) * y^(3k+1)
|
||||
|
||||
// Check if x/y is a quadratic residue
|
||||
Sqr(t0, z) // z^2
|
||||
Mul(t0, t0, y) // y*z^2
|
||||
Sub(t0, t0, x) // y*z^2-x
|
||||
return IsZero(t0)
|
||||
}
|
||||
|
||||
// Inv calculates z = 1/x mod p.
|
||||
func Inv(z, x *Elt) {
|
||||
// Calculates z = x^(4k+1) = x^(p-3+1) = x^(p-2) = x^-1, where k = (p-3)/4.
|
||||
t := &Elt{}
|
||||
powPminus3div4(t, x) // t = x^k
|
||||
Sqr(t, t) // t = x^2k
|
||||
Sqr(t, t) // t = x^4k
|
||||
Mul(z, t, x) // z = x^(4k+1)
|
||||
}
|
||||
|
||||
// powPminus3div4 calculates z = x^k mod p, where k = (p-3)/4.
|
||||
func powPminus3div4(z, x *Elt) {
|
||||
x0, x1 := &Elt{}, &Elt{}
|
||||
Sqr(z, x)
|
||||
Mul(z, z, x)
|
||||
Sqr(x0, z)
|
||||
Mul(x0, x0, x)
|
||||
Sqr(z, x0)
|
||||
Sqr(z, z)
|
||||
Sqr(z, z)
|
||||
Mul(z, z, x0)
|
||||
Sqr(x1, z)
|
||||
for i := 0; i < 5; i++ {
|
||||
Sqr(x1, x1)
|
||||
}
|
||||
Mul(x1, x1, z)
|
||||
Sqr(z, x1)
|
||||
for i := 0; i < 11; i++ {
|
||||
Sqr(z, z)
|
||||
}
|
||||
Mul(z, z, x1)
|
||||
Sqr(z, z)
|
||||
Sqr(z, z)
|
||||
Sqr(z, z)
|
||||
Mul(z, z, x0)
|
||||
Sqr(x1, z)
|
||||
for i := 0; i < 26; i++ {
|
||||
Sqr(x1, x1)
|
||||
}
|
||||
Mul(x1, x1, z)
|
||||
Sqr(z, x1)
|
||||
for i := 0; i < 53; i++ {
|
||||
Sqr(z, z)
|
||||
}
|
||||
Mul(z, z, x1)
|
||||
Sqr(z, z)
|
||||
Sqr(z, z)
|
||||
Sqr(z, z)
|
||||
Mul(z, z, x0)
|
||||
Sqr(x1, z)
|
||||
for i := 0; i < 110; i++ {
|
||||
Sqr(x1, x1)
|
||||
}
|
||||
Mul(x1, x1, z)
|
||||
Sqr(z, x1)
|
||||
Mul(z, z, x)
|
||||
for i := 0; i < 223; i++ {
|
||||
Sqr(z, z)
|
||||
}
|
||||
Mul(z, z, x1)
|
||||
}
|
||||
|
||||
// Cmov assigns y to x if n is 1.
|
||||
func Cmov(x, y *Elt, n uint) { cmov(x, y, n) }
|
||||
|
||||
// Cswap interchanges x and y if n is 1.
|
||||
func Cswap(x, y *Elt, n uint) { cswap(x, y, n) }
|
||||
|
||||
// Add calculates z = x+y mod p.
|
||||
func Add(z, x, y *Elt) { add(z, x, y) }
|
||||
|
||||
// Sub calculates z = x-y mod p.
|
||||
func Sub(z, x, y *Elt) { sub(z, x, y) }
|
||||
|
||||
// AddSub calculates (x,y) = (x+y mod p, x-y mod p).
|
||||
func AddSub(x, y *Elt) { addsub(x, y) }
|
||||
|
||||
// Mul calculates z = x*y mod p.
|
||||
func Mul(z, x, y *Elt) { mul(z, x, y) }
|
||||
|
||||
// Sqr calculates z = x^2 mod p.
|
||||
func Sqr(z, x *Elt) { sqr(z, x) }
|
||||
43
vendor/github.com/cloudflare/circl/math/fp448/fp_amd64.go
generated
vendored
Normal file
43
vendor/github.com/cloudflare/circl/math/fp448/fp_amd64.go
generated
vendored
Normal file
@ -0,0 +1,43 @@
|
||||
//go:build amd64 && !purego
|
||||
// +build amd64,!purego
|
||||
|
||||
package fp448
|
||||
|
||||
import (
|
||||
"golang.org/x/sys/cpu"
|
||||
)
|
||||
|
||||
var hasBmi2Adx = cpu.X86.HasBMI2 && cpu.X86.HasADX
|
||||
|
||||
var _ = hasBmi2Adx
|
||||
|
||||
func cmov(x, y *Elt, n uint) { cmovAmd64(x, y, n) }
|
||||
func cswap(x, y *Elt, n uint) { cswapAmd64(x, y, n) }
|
||||
func add(z, x, y *Elt) { addAmd64(z, x, y) }
|
||||
func sub(z, x, y *Elt) { subAmd64(z, x, y) }
|
||||
func addsub(x, y *Elt) { addsubAmd64(x, y) }
|
||||
func mul(z, x, y *Elt) { mulAmd64(z, x, y) }
|
||||
func sqr(z, x *Elt) { sqrAmd64(z, x) }
|
||||
|
||||
/* Functions defined in fp_amd64.s */
|
||||
|
||||
//go:noescape
|
||||
func cmovAmd64(x, y *Elt, n uint)
|
||||
|
||||
//go:noescape
|
||||
func cswapAmd64(x, y *Elt, n uint)
|
||||
|
||||
//go:noescape
|
||||
func addAmd64(z, x, y *Elt)
|
||||
|
||||
//go:noescape
|
||||
func subAmd64(z, x, y *Elt)
|
||||
|
||||
//go:noescape
|
||||
func addsubAmd64(x, y *Elt)
|
||||
|
||||
//go:noescape
|
||||
func mulAmd64(z, x, y *Elt)
|
||||
|
||||
//go:noescape
|
||||
func sqrAmd64(z, x *Elt)
|
||||
591
vendor/github.com/cloudflare/circl/math/fp448/fp_amd64.h
generated
vendored
Normal file
591
vendor/github.com/cloudflare/circl/math/fp448/fp_amd64.h
generated
vendored
Normal file
@ -0,0 +1,591 @@
|
||||
// This code was imported from https://github.com/armfazh/rfc7748_precomputed
|
||||
|
||||
// CHECK_BMI2ADX triggers bmi2adx if supported,
|
||||
// otherwise it fallbacks to legacy code.
|
||||
#define CHECK_BMI2ADX(label, legacy, bmi2adx) \
|
||||
CMPB ·hasBmi2Adx(SB), $0 \
|
||||
JE label \
|
||||
bmi2adx \
|
||||
RET \
|
||||
label: \
|
||||
legacy \
|
||||
RET
|
||||
|
||||
// cselect is a conditional move
|
||||
// if b=1: it copies y into x;
|
||||
// if b=0: x remains with the same value;
|
||||
// if b<> 0,1: undefined.
|
||||
// Uses: AX, DX, FLAGS
|
||||
// Instr: x86_64, cmov
|
||||
#define cselect(x,y,b) \
|
||||
TESTQ b, b \
|
||||
MOVQ 0+x, AX; MOVQ 0+y, DX; CMOVQNE DX, AX; MOVQ AX, 0+x; \
|
||||
MOVQ 8+x, AX; MOVQ 8+y, DX; CMOVQNE DX, AX; MOVQ AX, 8+x; \
|
||||
MOVQ 16+x, AX; MOVQ 16+y, DX; CMOVQNE DX, AX; MOVQ AX, 16+x; \
|
||||
MOVQ 24+x, AX; MOVQ 24+y, DX; CMOVQNE DX, AX; MOVQ AX, 24+x; \
|
||||
MOVQ 32+x, AX; MOVQ 32+y, DX; CMOVQNE DX, AX; MOVQ AX, 32+x; \
|
||||
MOVQ 40+x, AX; MOVQ 40+y, DX; CMOVQNE DX, AX; MOVQ AX, 40+x; \
|
||||
MOVQ 48+x, AX; MOVQ 48+y, DX; CMOVQNE DX, AX; MOVQ AX, 48+x;
|
||||
|
||||
// cswap is a conditional swap
|
||||
// if b=1: x,y <- y,x;
|
||||
// if b=0: x,y remain with the same values;
|
||||
// if b<> 0,1: undefined.
|
||||
// Uses: AX, DX, R8, FLAGS
|
||||
// Instr: x86_64, cmov
|
||||
#define cswap(x,y,b) \
|
||||
TESTQ b, b \
|
||||
MOVQ 0+x, AX; MOVQ AX, R8; MOVQ 0+y, DX; CMOVQNE DX, AX; CMOVQNE R8, DX; MOVQ AX, 0+x; MOVQ DX, 0+y; \
|
||||
MOVQ 8+x, AX; MOVQ AX, R8; MOVQ 8+y, DX; CMOVQNE DX, AX; CMOVQNE R8, DX; MOVQ AX, 8+x; MOVQ DX, 8+y; \
|
||||
MOVQ 16+x, AX; MOVQ AX, R8; MOVQ 16+y, DX; CMOVQNE DX, AX; CMOVQNE R8, DX; MOVQ AX, 16+x; MOVQ DX, 16+y; \
|
||||
MOVQ 24+x, AX; MOVQ AX, R8; MOVQ 24+y, DX; CMOVQNE DX, AX; CMOVQNE R8, DX; MOVQ AX, 24+x; MOVQ DX, 24+y; \
|
||||
MOVQ 32+x, AX; MOVQ AX, R8; MOVQ 32+y, DX; CMOVQNE DX, AX; CMOVQNE R8, DX; MOVQ AX, 32+x; MOVQ DX, 32+y; \
|
||||
MOVQ 40+x, AX; MOVQ AX, R8; MOVQ 40+y, DX; CMOVQNE DX, AX; CMOVQNE R8, DX; MOVQ AX, 40+x; MOVQ DX, 40+y; \
|
||||
MOVQ 48+x, AX; MOVQ AX, R8; MOVQ 48+y, DX; CMOVQNE DX, AX; CMOVQNE R8, DX; MOVQ AX, 48+x; MOVQ DX, 48+y;
|
||||
|
||||
// additionLeg adds x and y and stores in z
|
||||
// Uses: AX, DX, R8-R14, FLAGS
|
||||
// Instr: x86_64
|
||||
#define additionLeg(z,x,y) \
|
||||
MOVQ 0+x, R8; ADDQ 0+y, R8; \
|
||||
MOVQ 8+x, R9; ADCQ 8+y, R9; \
|
||||
MOVQ 16+x, R10; ADCQ 16+y, R10; \
|
||||
MOVQ 24+x, R11; ADCQ 24+y, R11; \
|
||||
MOVQ 32+x, R12; ADCQ 32+y, R12; \
|
||||
MOVQ 40+x, R13; ADCQ 40+y, R13; \
|
||||
MOVQ 48+x, R14; ADCQ 48+y, R14; \
|
||||
MOVQ $0, AX; ADCQ $0, AX; \
|
||||
MOVQ AX, DX; \
|
||||
SHLQ $32, DX; \
|
||||
ADDQ AX, R8; MOVQ $0, AX; \
|
||||
ADCQ $0, R9; \
|
||||
ADCQ $0, R10; \
|
||||
ADCQ DX, R11; \
|
||||
ADCQ $0, R12; \
|
||||
ADCQ $0, R13; \
|
||||
ADCQ $0, R14; \
|
||||
ADCQ $0, AX; \
|
||||
MOVQ AX, DX; \
|
||||
SHLQ $32, DX; \
|
||||
ADDQ AX, R8; MOVQ R8, 0+z; \
|
||||
ADCQ $0, R9; MOVQ R9, 8+z; \
|
||||
ADCQ $0, R10; MOVQ R10, 16+z; \
|
||||
ADCQ DX, R11; MOVQ R11, 24+z; \
|
||||
ADCQ $0, R12; MOVQ R12, 32+z; \
|
||||
ADCQ $0, R13; MOVQ R13, 40+z; \
|
||||
ADCQ $0, R14; MOVQ R14, 48+z;
|
||||
|
||||
|
||||
// additionAdx adds x and y and stores in z
|
||||
// Uses: AX, DX, R8-R15, FLAGS
|
||||
// Instr: x86_64, adx
|
||||
#define additionAdx(z,x,y) \
|
||||
MOVL $32, R15; \
|
||||
XORL DX, DX; \
|
||||
MOVQ 0+x, R8; ADCXQ 0+y, R8; \
|
||||
MOVQ 8+x, R9; ADCXQ 8+y, R9; \
|
||||
MOVQ 16+x, R10; ADCXQ 16+y, R10; \
|
||||
MOVQ 24+x, R11; ADCXQ 24+y, R11; \
|
||||
MOVQ 32+x, R12; ADCXQ 32+y, R12; \
|
||||
MOVQ 40+x, R13; ADCXQ 40+y, R13; \
|
||||
MOVQ 48+x, R14; ADCXQ 48+y, R14; \
|
||||
;;;;;;;;;;;;;;; ADCXQ DX, DX; \
|
||||
XORL AX, AX; \
|
||||
ADCXQ DX, R8; SHLXQ R15, DX, DX; \
|
||||
ADCXQ AX, R9; \
|
||||
ADCXQ AX, R10; \
|
||||
ADCXQ DX, R11; \
|
||||
ADCXQ AX, R12; \
|
||||
ADCXQ AX, R13; \
|
||||
ADCXQ AX, R14; \
|
||||
ADCXQ AX, AX; \
|
||||
XORL DX, DX; \
|
||||
ADCXQ AX, R8; MOVQ R8, 0+z; SHLXQ R15, AX, AX; \
|
||||
ADCXQ DX, R9; MOVQ R9, 8+z; \
|
||||
ADCXQ DX, R10; MOVQ R10, 16+z; \
|
||||
ADCXQ AX, R11; MOVQ R11, 24+z; \
|
||||
ADCXQ DX, R12; MOVQ R12, 32+z; \
|
||||
ADCXQ DX, R13; MOVQ R13, 40+z; \
|
||||
ADCXQ DX, R14; MOVQ R14, 48+z;
|
||||
|
||||
// subtraction subtracts y from x and stores in z
|
||||
// Uses: AX, DX, R8-R14, FLAGS
|
||||
// Instr: x86_64
|
||||
#define subtraction(z,x,y) \
|
||||
MOVQ 0+x, R8; SUBQ 0+y, R8; \
|
||||
MOVQ 8+x, R9; SBBQ 8+y, R9; \
|
||||
MOVQ 16+x, R10; SBBQ 16+y, R10; \
|
||||
MOVQ 24+x, R11; SBBQ 24+y, R11; \
|
||||
MOVQ 32+x, R12; SBBQ 32+y, R12; \
|
||||
MOVQ 40+x, R13; SBBQ 40+y, R13; \
|
||||
MOVQ 48+x, R14; SBBQ 48+y, R14; \
|
||||
MOVQ $0, AX; SETCS AX; \
|
||||
MOVQ AX, DX; \
|
||||
SHLQ $32, DX; \
|
||||
SUBQ AX, R8; MOVQ $0, AX; \
|
||||
SBBQ $0, R9; \
|
||||
SBBQ $0, R10; \
|
||||
SBBQ DX, R11; \
|
||||
SBBQ $0, R12; \
|
||||
SBBQ $0, R13; \
|
||||
SBBQ $0, R14; \
|
||||
SETCS AX; \
|
||||
MOVQ AX, DX; \
|
||||
SHLQ $32, DX; \
|
||||
SUBQ AX, R8; MOVQ R8, 0+z; \
|
||||
SBBQ $0, R9; MOVQ R9, 8+z; \
|
||||
SBBQ $0, R10; MOVQ R10, 16+z; \
|
||||
SBBQ DX, R11; MOVQ R11, 24+z; \
|
||||
SBBQ $0, R12; MOVQ R12, 32+z; \
|
||||
SBBQ $0, R13; MOVQ R13, 40+z; \
|
||||
SBBQ $0, R14; MOVQ R14, 48+z;
|
||||
|
||||
// maddBmi2Adx multiplies x and y and accumulates in z
|
||||
// Uses: AX, DX, R15, FLAGS
|
||||
// Instr: x86_64, bmi2, adx
|
||||
#define maddBmi2Adx(z,x,y,i,r0,r1,r2,r3,r4,r5,r6) \
|
||||
MOVQ i+y, DX; XORL AX, AX; \
|
||||
MULXQ 0+x, AX, R8; ADOXQ AX, r0; ADCXQ R8, r1; MOVQ r0,i+z; \
|
||||
MULXQ 8+x, AX, r0; ADOXQ AX, r1; ADCXQ r0, r2; MOVQ $0, R8; \
|
||||
MULXQ 16+x, AX, r0; ADOXQ AX, r2; ADCXQ r0, r3; \
|
||||
MULXQ 24+x, AX, r0; ADOXQ AX, r3; ADCXQ r0, r4; \
|
||||
MULXQ 32+x, AX, r0; ADOXQ AX, r4; ADCXQ r0, r5; \
|
||||
MULXQ 40+x, AX, r0; ADOXQ AX, r5; ADCXQ r0, r6; \
|
||||
MULXQ 48+x, AX, r0; ADOXQ AX, r6; ADCXQ R8, r0; \
|
||||
;;;;;;;;;;;;;;;;;;; ADOXQ R8, r0;
|
||||
|
||||
// integerMulAdx multiplies x and y and stores in z
|
||||
// Uses: AX, DX, R8-R15, FLAGS
|
||||
// Instr: x86_64, bmi2, adx
|
||||
#define integerMulAdx(z,x,y) \
|
||||
MOVL $0,R15; \
|
||||
MOVQ 0+y, DX; XORL AX, AX; MOVQ $0, R8; \
|
||||
MULXQ 0+x, AX, R9; MOVQ AX, 0+z; \
|
||||
MULXQ 8+x, AX, R10; ADCXQ AX, R9; \
|
||||
MULXQ 16+x, AX, R11; ADCXQ AX, R10; \
|
||||
MULXQ 24+x, AX, R12; ADCXQ AX, R11; \
|
||||
MULXQ 32+x, AX, R13; ADCXQ AX, R12; \
|
||||
MULXQ 40+x, AX, R14; ADCXQ AX, R13; \
|
||||
MULXQ 48+x, AX, R15; ADCXQ AX, R14; \
|
||||
;;;;;;;;;;;;;;;;;;;; ADCXQ R8, R15; \
|
||||
maddBmi2Adx(z,x,y, 8, R9,R10,R11,R12,R13,R14,R15) \
|
||||
maddBmi2Adx(z,x,y,16,R10,R11,R12,R13,R14,R15, R9) \
|
||||
maddBmi2Adx(z,x,y,24,R11,R12,R13,R14,R15, R9,R10) \
|
||||
maddBmi2Adx(z,x,y,32,R12,R13,R14,R15, R9,R10,R11) \
|
||||
maddBmi2Adx(z,x,y,40,R13,R14,R15, R9,R10,R11,R12) \
|
||||
maddBmi2Adx(z,x,y,48,R14,R15, R9,R10,R11,R12,R13) \
|
||||
MOVQ R15, 56+z; \
|
||||
MOVQ R9, 64+z; \
|
||||
MOVQ R10, 72+z; \
|
||||
MOVQ R11, 80+z; \
|
||||
MOVQ R12, 88+z; \
|
||||
MOVQ R13, 96+z; \
|
||||
MOVQ R14, 104+z;
|
||||
|
||||
// maddLegacy multiplies x and y and accumulates in z
|
||||
// Uses: AX, DX, R15, FLAGS
|
||||
// Instr: x86_64
|
||||
#define maddLegacy(z,x,y,i) \
|
||||
MOVQ i+y, R15; \
|
||||
MOVQ 0+x, AX; MULQ R15; MOVQ AX, R8; ;;;;;;;;;;;; MOVQ DX, R9; \
|
||||
MOVQ 8+x, AX; MULQ R15; ADDQ AX, R9; ADCQ $0, DX; MOVQ DX, R10; \
|
||||
MOVQ 16+x, AX; MULQ R15; ADDQ AX, R10; ADCQ $0, DX; MOVQ DX, R11; \
|
||||
MOVQ 24+x, AX; MULQ R15; ADDQ AX, R11; ADCQ $0, DX; MOVQ DX, R12; \
|
||||
MOVQ 32+x, AX; MULQ R15; ADDQ AX, R12; ADCQ $0, DX; MOVQ DX, R13; \
|
||||
MOVQ 40+x, AX; MULQ R15; ADDQ AX, R13; ADCQ $0, DX; MOVQ DX, R14; \
|
||||
MOVQ 48+x, AX; MULQ R15; ADDQ AX, R14; ADCQ $0, DX; \
|
||||
ADDQ 0+i+z, R8; MOVQ R8, 0+i+z; \
|
||||
ADCQ 8+i+z, R9; MOVQ R9, 8+i+z; \
|
||||
ADCQ 16+i+z, R10; MOVQ R10, 16+i+z; \
|
||||
ADCQ 24+i+z, R11; MOVQ R11, 24+i+z; \
|
||||
ADCQ 32+i+z, R12; MOVQ R12, 32+i+z; \
|
||||
ADCQ 40+i+z, R13; MOVQ R13, 40+i+z; \
|
||||
ADCQ 48+i+z, R14; MOVQ R14, 48+i+z; \
|
||||
ADCQ $0, DX; MOVQ DX, 56+i+z;
|
||||
|
||||
// integerMulLeg multiplies x and y and stores in z
|
||||
// Uses: AX, DX, R8-R15, FLAGS
|
||||
// Instr: x86_64
|
||||
#define integerMulLeg(z,x,y) \
|
||||
MOVQ 0+y, R15; \
|
||||
MOVQ 0+x, AX; MULQ R15; MOVQ AX, 0+z; ;;;;;;;;;;;; MOVQ DX, R8; \
|
||||
MOVQ 8+x, AX; MULQ R15; ADDQ AX, R8; ADCQ $0, DX; MOVQ DX, R9; MOVQ R8, 8+z; \
|
||||
MOVQ 16+x, AX; MULQ R15; ADDQ AX, R9; ADCQ $0, DX; MOVQ DX, R10; MOVQ R9, 16+z; \
|
||||
MOVQ 24+x, AX; MULQ R15; ADDQ AX, R10; ADCQ $0, DX; MOVQ DX, R11; MOVQ R10, 24+z; \
|
||||
MOVQ 32+x, AX; MULQ R15; ADDQ AX, R11; ADCQ $0, DX; MOVQ DX, R12; MOVQ R11, 32+z; \
|
||||
MOVQ 40+x, AX; MULQ R15; ADDQ AX, R12; ADCQ $0, DX; MOVQ DX, R13; MOVQ R12, 40+z; \
|
||||
MOVQ 48+x, AX; MULQ R15; ADDQ AX, R13; ADCQ $0, DX; MOVQ DX,56+z; MOVQ R13, 48+z; \
|
||||
maddLegacy(z,x,y, 8) \
|
||||
maddLegacy(z,x,y,16) \
|
||||
maddLegacy(z,x,y,24) \
|
||||
maddLegacy(z,x,y,32) \
|
||||
maddLegacy(z,x,y,40) \
|
||||
maddLegacy(z,x,y,48)
|
||||
|
||||
// integerSqrLeg squares x and stores in z
|
||||
// Uses: AX, CX, DX, R8-R15, FLAGS
|
||||
// Instr: x86_64
|
||||
#define integerSqrLeg(z,x) \
|
||||
XORL R15, R15; \
|
||||
MOVQ 0+x, CX; \
|
||||
MOVQ CX, AX; MULQ CX; MOVQ AX, 0+z; MOVQ DX, R8; \
|
||||
ADDQ CX, CX; ADCQ $0, R15; \
|
||||
MOVQ 8+x, AX; MULQ CX; ADDQ AX, R8; ADCQ $0, DX; MOVQ DX, R9; MOVQ R8, 8+z; \
|
||||
MOVQ 16+x, AX; MULQ CX; ADDQ AX, R9; ADCQ $0, DX; MOVQ DX, R10; \
|
||||
MOVQ 24+x, AX; MULQ CX; ADDQ AX, R10; ADCQ $0, DX; MOVQ DX, R11; \
|
||||
MOVQ 32+x, AX; MULQ CX; ADDQ AX, R11; ADCQ $0, DX; MOVQ DX, R12; \
|
||||
MOVQ 40+x, AX; MULQ CX; ADDQ AX, R12; ADCQ $0, DX; MOVQ DX, R13; \
|
||||
MOVQ 48+x, AX; MULQ CX; ADDQ AX, R13; ADCQ $0, DX; MOVQ DX, R14; \
|
||||
\
|
||||
MOVQ 8+x, CX; \
|
||||
MOVQ CX, AX; ADDQ R15, CX; MOVQ $0, R15; ADCQ $0, R15; \
|
||||
;;;;;;;;;;;;;; MULQ CX; ADDQ AX, R9; ADCQ $0, DX; MOVQ R9,16+z; \
|
||||
MOVQ R15, AX; NEGQ AX; ANDQ 8+x, AX; ADDQ AX, DX; ADCQ $0, R11; MOVQ DX, R8; \
|
||||
ADDQ 8+x, CX; ADCQ $0, R15; \
|
||||
MOVQ 16+x, AX; MULQ CX; ADDQ AX, R10; ADCQ $0, DX; ADDQ R8, R10; ADCQ $0, DX; MOVQ DX, R8; MOVQ R10, 24+z; \
|
||||
MOVQ 24+x, AX; MULQ CX; ADDQ AX, R11; ADCQ $0, DX; ADDQ R8, R11; ADCQ $0, DX; MOVQ DX, R8; \
|
||||
MOVQ 32+x, AX; MULQ CX; ADDQ AX, R12; ADCQ $0, DX; ADDQ R8, R12; ADCQ $0, DX; MOVQ DX, R8; \
|
||||
MOVQ 40+x, AX; MULQ CX; ADDQ AX, R13; ADCQ $0, DX; ADDQ R8, R13; ADCQ $0, DX; MOVQ DX, R8; \
|
||||
MOVQ 48+x, AX; MULQ CX; ADDQ AX, R14; ADCQ $0, DX; ADDQ R8, R14; ADCQ $0, DX; MOVQ DX, R9; \
|
||||
\
|
||||
MOVQ 16+x, CX; \
|
||||
MOVQ CX, AX; ADDQ R15, CX; MOVQ $0, R15; ADCQ $0, R15; \
|
||||
;;;;;;;;;;;;;; MULQ CX; ADDQ AX, R11; ADCQ $0, DX; MOVQ R11, 32+z; \
|
||||
MOVQ R15, AX; NEGQ AX; ANDQ 16+x,AX; ADDQ AX, DX; ADCQ $0, R13; MOVQ DX, R8; \
|
||||
ADDQ 16+x, CX; ADCQ $0, R15; \
|
||||
MOVQ 24+x, AX; MULQ CX; ADDQ AX, R12; ADCQ $0, DX; ADDQ R8, R12; ADCQ $0, DX; MOVQ DX, R8; MOVQ R12, 40+z; \
|
||||
MOVQ 32+x, AX; MULQ CX; ADDQ AX, R13; ADCQ $0, DX; ADDQ R8, R13; ADCQ $0, DX; MOVQ DX, R8; \
|
||||
MOVQ 40+x, AX; MULQ CX; ADDQ AX, R14; ADCQ $0, DX; ADDQ R8, R14; ADCQ $0, DX; MOVQ DX, R8; \
|
||||
MOVQ 48+x, AX; MULQ CX; ADDQ AX, R9; ADCQ $0, DX; ADDQ R8, R9; ADCQ $0, DX; MOVQ DX,R10; \
|
||||
\
|
||||
MOVQ 24+x, CX; \
|
||||
MOVQ CX, AX; ADDQ R15, CX; MOVQ $0, R15; ADCQ $0, R15; \
|
||||
;;;;;;;;;;;;;; MULQ CX; ADDQ AX, R13; ADCQ $0, DX; MOVQ R13, 48+z; \
|
||||
MOVQ R15, AX; NEGQ AX; ANDQ 24+x,AX; ADDQ AX, DX; ADCQ $0, R9; MOVQ DX, R8; \
|
||||
ADDQ 24+x, CX; ADCQ $0, R15; \
|
||||
MOVQ 32+x, AX; MULQ CX; ADDQ AX, R14; ADCQ $0, DX; ADDQ R8, R14; ADCQ $0, DX; MOVQ DX, R8; MOVQ R14, 56+z; \
|
||||
MOVQ 40+x, AX; MULQ CX; ADDQ AX, R9; ADCQ $0, DX; ADDQ R8, R9; ADCQ $0, DX; MOVQ DX, R8; \
|
||||
MOVQ 48+x, AX; MULQ CX; ADDQ AX, R10; ADCQ $0, DX; ADDQ R8, R10; ADCQ $0, DX; MOVQ DX,R11; \
|
||||
\
|
||||
MOVQ 32+x, CX; \
|
||||
MOVQ CX, AX; ADDQ R15, CX; MOVQ $0, R15; ADCQ $0, R15; \
|
||||
;;;;;;;;;;;;;; MULQ CX; ADDQ AX, R9; ADCQ $0, DX; MOVQ R9, 64+z; \
|
||||
MOVQ R15, AX; NEGQ AX; ANDQ 32+x,AX; ADDQ AX, DX; ADCQ $0, R11; MOVQ DX, R8; \
|
||||
ADDQ 32+x, CX; ADCQ $0, R15; \
|
||||
MOVQ 40+x, AX; MULQ CX; ADDQ AX, R10; ADCQ $0, DX; ADDQ R8, R10; ADCQ $0, DX; MOVQ DX, R8; MOVQ R10, 72+z; \
|
||||
MOVQ 48+x, AX; MULQ CX; ADDQ AX, R11; ADCQ $0, DX; ADDQ R8, R11; ADCQ $0, DX; MOVQ DX,R12; \
|
||||
\
|
||||
XORL R13, R13; \
|
||||
XORL R14, R14; \
|
||||
MOVQ 40+x, CX; \
|
||||
MOVQ CX, AX; ADDQ R15, CX; MOVQ $0, R15; ADCQ $0, R15; \
|
||||
;;;;;;;;;;;;;; MULQ CX; ADDQ AX, R11; ADCQ $0, DX; MOVQ R11, 80+z; \
|
||||
MOVQ R15, AX; NEGQ AX; ANDQ 40+x,AX; ADDQ AX, DX; ADCQ $0, R13; MOVQ DX, R8; \
|
||||
ADDQ 40+x, CX; ADCQ $0, R15; \
|
||||
MOVQ 48+x, AX; MULQ CX; ADDQ AX, R12; ADCQ $0, DX; ADDQ R8, R12; ADCQ $0, DX; MOVQ DX, R8; MOVQ R12, 88+z; \
|
||||
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; ADDQ R8, R13; ADCQ $0,R14; \
|
||||
\
|
||||
XORL R9, R9; \
|
||||
MOVQ 48+x, CX; \
|
||||
MOVQ CX, AX; ADDQ R15, CX; MOVQ $0, R15; ADCQ $0, R15; \
|
||||
;;;;;;;;;;;;;; MULQ CX; ADDQ AX, R13; ADCQ $0, DX; MOVQ R13, 96+z; \
|
||||
MOVQ R15, AX; NEGQ AX; ANDQ 48+x,AX; ADDQ AX, DX; ADCQ $0, R9; MOVQ DX, R8; \
|
||||
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; ADDQ R8,R14; ADCQ $0, R9; MOVQ R14, 104+z;
|
||||
|
||||
|
||||
// integerSqrAdx squares x and stores in z
|
||||
// Uses: AX, CX, DX, R8-R15, FLAGS
|
||||
// Instr: x86_64, bmi2, adx
|
||||
#define integerSqrAdx(z,x) \
|
||||
XORL R15, R15; \
|
||||
MOVQ 0+x, DX; \
|
||||
;;;;;;;;;;;;;; MULXQ DX, AX, R8; MOVQ AX, 0+z; \
|
||||
ADDQ DX, DX; ADCQ $0, R15; CLC; \
|
||||
MULXQ 8+x, AX, R9; ADCXQ AX, R8; MOVQ R8, 8+z; \
|
||||
MULXQ 16+x, AX, R10; ADCXQ AX, R9; MOVQ $0, R8;\
|
||||
MULXQ 24+x, AX, R11; ADCXQ AX, R10; \
|
||||
MULXQ 32+x, AX, R12; ADCXQ AX, R11; \
|
||||
MULXQ 40+x, AX, R13; ADCXQ AX, R12; \
|
||||
MULXQ 48+x, AX, R14; ADCXQ AX, R13; \
|
||||
;;;;;;;;;;;;;;;;;;;; ADCXQ R8, R14; \
|
||||
\
|
||||
MOVQ 8+x, DX; \
|
||||
MOVQ DX, AX; ADDQ R15, DX; MOVQ $0, R15; ADCQ $0, R15; \
|
||||
MULXQ AX, AX, CX; \
|
||||
MOVQ R15, R8; NEGQ R8; ANDQ 8+x, R8; \
|
||||
ADDQ AX, R9; MOVQ R9, 16+z; \
|
||||
ADCQ CX, R8; \
|
||||
ADCQ $0, R11; \
|
||||
ADDQ 8+x, DX; \
|
||||
ADCQ $0, R15; \
|
||||
XORL R9, R9; ;;;;;;;;;;;;;;;;;;;;; ADOXQ R8, R10; \
|
||||
MULXQ 16+x, AX, CX; ADCXQ AX, R10; ADOXQ CX, R11; MOVQ R10, 24+z; \
|
||||
MULXQ 24+x, AX, CX; ADCXQ AX, R11; ADOXQ CX, R12; MOVQ $0, R10; \
|
||||
MULXQ 32+x, AX, CX; ADCXQ AX, R12; ADOXQ CX, R13; \
|
||||
MULXQ 40+x, AX, CX; ADCXQ AX, R13; ADOXQ CX, R14; \
|
||||
MULXQ 48+x, AX, CX; ADCXQ AX, R14; ADOXQ CX, R9; \
|
||||
;;;;;;;;;;;;;;;;;;; ADCXQ R10, R9; \
|
||||
\
|
||||
MOVQ 16+x, DX; \
|
||||
MOVQ DX, AX; ADDQ R15, DX; MOVQ $0, R15; ADCQ $0, R15; \
|
||||
MULXQ AX, AX, CX; \
|
||||
MOVQ R15, R8; NEGQ R8; ANDQ 16+x, R8; \
|
||||
ADDQ AX, R11; MOVQ R11, 32+z; \
|
||||
ADCQ CX, R8; \
|
||||
ADCQ $0, R13; \
|
||||
ADDQ 16+x, DX; \
|
||||
ADCQ $0, R15; \
|
||||
XORL R11, R11; ;;;;;;;;;;;;;;;;;;; ADOXQ R8, R12; \
|
||||
MULXQ 24+x, AX, CX; ADCXQ AX, R12; ADOXQ CX, R13; MOVQ R12, 40+z; \
|
||||
MULXQ 32+x, AX, CX; ADCXQ AX, R13; ADOXQ CX, R14; MOVQ $0, R12; \
|
||||
MULXQ 40+x, AX, CX; ADCXQ AX, R14; ADOXQ CX, R9; \
|
||||
MULXQ 48+x, AX, CX; ADCXQ AX, R9; ADOXQ CX, R10; \
|
||||
;;;;;;;;;;;;;;;;;;; ADCXQ R11,R10; \
|
||||
\
|
||||
MOVQ 24+x, DX; \
|
||||
MOVQ DX, AX; ADDQ R15, DX; MOVQ $0, R15; ADCQ $0, R15; \
|
||||
MULXQ AX, AX, CX; \
|
||||
MOVQ R15, R8; NEGQ R8; ANDQ 24+x, R8; \
|
||||
ADDQ AX, R13; MOVQ R13, 48+z; \
|
||||
ADCQ CX, R8; \
|
||||
ADCQ $0, R9; \
|
||||
ADDQ 24+x, DX; \
|
||||
ADCQ $0, R15; \
|
||||
XORL R13, R13; ;;;;;;;;;;;;;;;;;;; ADOXQ R8, R14; \
|
||||
MULXQ 32+x, AX, CX; ADCXQ AX, R14; ADOXQ CX, R9; MOVQ R14, 56+z; \
|
||||
MULXQ 40+x, AX, CX; ADCXQ AX, R9; ADOXQ CX, R10; MOVQ $0, R14; \
|
||||
MULXQ 48+x, AX, CX; ADCXQ AX, R10; ADOXQ CX, R11; \
|
||||
;;;;;;;;;;;;;;;;;;; ADCXQ R12,R11; \
|
||||
\
|
||||
MOVQ 32+x, DX; \
|
||||
MOVQ DX, AX; ADDQ R15, DX; MOVQ $0, R15; ADCQ $0, R15; \
|
||||
MULXQ AX, AX, CX; \
|
||||
MOVQ R15, R8; NEGQ R8; ANDQ 32+x, R8; \
|
||||
ADDQ AX, R9; MOVQ R9, 64+z; \
|
||||
ADCQ CX, R8; \
|
||||
ADCQ $0, R11; \
|
||||
ADDQ 32+x, DX; \
|
||||
ADCQ $0, R15; \
|
||||
XORL R9, R9; ;;;;;;;;;;;;;;;;;;;;; ADOXQ R8, R10; \
|
||||
MULXQ 40+x, AX, CX; ADCXQ AX, R10; ADOXQ CX, R11; MOVQ R10, 72+z; \
|
||||
MULXQ 48+x, AX, CX; ADCXQ AX, R11; ADOXQ CX, R12; \
|
||||
;;;;;;;;;;;;;;;;;;; ADCXQ R13,R12; \
|
||||
\
|
||||
MOVQ 40+x, DX; \
|
||||
MOVQ DX, AX; ADDQ R15, DX; MOVQ $0, R15; ADCQ $0, R15; \
|
||||
MULXQ AX, AX, CX; \
|
||||
MOVQ R15, R8; NEGQ R8; ANDQ 40+x, R8; \
|
||||
ADDQ AX, R11; MOVQ R11, 80+z; \
|
||||
ADCQ CX, R8; \
|
||||
ADCQ $0, R13; \
|
||||
ADDQ 40+x, DX; \
|
||||
ADCQ $0, R15; \
|
||||
XORL R11, R11; ;;;;;;;;;;;;;;;;;;; ADOXQ R8, R12; \
|
||||
MULXQ 48+x, AX, CX; ADCXQ AX, R12; ADOXQ CX, R13; MOVQ R12, 88+z; \
|
||||
;;;;;;;;;;;;;;;;;;; ADCXQ R14,R13; \
|
||||
\
|
||||
MOVQ 48+x, DX; \
|
||||
MOVQ DX, AX; ADDQ R15, DX; MOVQ $0, R15; ADCQ $0, R15; \
|
||||
MULXQ AX, AX, CX; \
|
||||
MOVQ R15, R8; NEGQ R8; ANDQ 48+x, R8; \
|
||||
XORL R10, R10; ;;;;;;;;;;;;;; ADOXQ CX, R14; \
|
||||
;;;;;;;;;;;;;; ADCXQ AX, R13; ;;;;;;;;;;;;;; MOVQ R13, 96+z; \
|
||||
;;;;;;;;;;;;;; ADCXQ R8, R14; MOVQ R14, 104+z;
|
||||
|
||||
// reduceFromDoubleLeg finds a z=x modulo p such that z<2^448 and stores in z
|
||||
// Uses: AX, R8-R15, FLAGS
|
||||
// Instr: x86_64
|
||||
#define reduceFromDoubleLeg(z,x) \
|
||||
/* ( ,2C13,2C12,2C11,2C10|C10,C9,C8, C7) + (C6,...,C0) */ \
|
||||
/* (r14, r13, r12, r11, r10,r9,r8,r15) */ \
|
||||
MOVQ 80+x,AX; MOVQ AX,R10; \
|
||||
MOVQ $0xFFFFFFFF00000000, R8; \
|
||||
ANDQ R8,R10; \
|
||||
\
|
||||
MOVQ $0,R14; \
|
||||
MOVQ 104+x,R13; SHLQ $1,R13,R14; \
|
||||
MOVQ 96+x,R12; SHLQ $1,R12,R13; \
|
||||
MOVQ 88+x,R11; SHLQ $1,R11,R12; \
|
||||
MOVQ 72+x, R9; SHLQ $1,R10,R11; \
|
||||
MOVQ 64+x, R8; SHLQ $1,R10; \
|
||||
MOVQ $0xFFFFFFFF,R15; ANDQ R15,AX; ORQ AX,R10; \
|
||||
MOVQ 56+x,R15; \
|
||||
\
|
||||
ADDQ 0+x,R15; MOVQ R15, 0+z; MOVQ 56+x,R15; \
|
||||
ADCQ 8+x, R8; MOVQ R8, 8+z; MOVQ 64+x, R8; \
|
||||
ADCQ 16+x, R9; MOVQ R9,16+z; MOVQ 72+x, R9; \
|
||||
ADCQ 24+x,R10; MOVQ R10,24+z; MOVQ 80+x,R10; \
|
||||
ADCQ 32+x,R11; MOVQ R11,32+z; MOVQ 88+x,R11; \
|
||||
ADCQ 40+x,R12; MOVQ R12,40+z; MOVQ 96+x,R12; \
|
||||
ADCQ 48+x,R13; MOVQ R13,48+z; MOVQ 104+x,R13; \
|
||||
ADCQ $0,R14; \
|
||||
/* (c10c9,c9c8,c8c7,c7c13,c13c12,c12c11,c11c10) + (c6,...,c0) */ \
|
||||
/* ( r9, r8, r15, r13, r12, r11, r10) */ \
|
||||
MOVQ R10, AX; \
|
||||
SHRQ $32,R11,R10; \
|
||||
SHRQ $32,R12,R11; \
|
||||
SHRQ $32,R13,R12; \
|
||||
SHRQ $32,R15,R13; \
|
||||
SHRQ $32, R8,R15; \
|
||||
SHRQ $32, R9, R8; \
|
||||
SHRQ $32, AX, R9; \
|
||||
\
|
||||
ADDQ 0+z,R10; \
|
||||
ADCQ 8+z,R11; \
|
||||
ADCQ 16+z,R12; \
|
||||
ADCQ 24+z,R13; \
|
||||
ADCQ 32+z,R15; \
|
||||
ADCQ 40+z, R8; \
|
||||
ADCQ 48+z, R9; \
|
||||
ADCQ $0,R14; \
|
||||
/* ( c7) + (c6,...,c0) */ \
|
||||
/* (r14) */ \
|
||||
MOVQ R14, AX; SHLQ $32, AX; \
|
||||
ADDQ R14,R10; MOVQ $0,R14; \
|
||||
ADCQ $0,R11; \
|
||||
ADCQ $0,R12; \
|
||||
ADCQ AX,R13; \
|
||||
ADCQ $0,R15; \
|
||||
ADCQ $0, R8; \
|
||||
ADCQ $0, R9; \
|
||||
ADCQ $0,R14; \
|
||||
/* ( c7) + (c6,...,c0) */ \
|
||||
/* (r14) */ \
|
||||
MOVQ R14, AX; SHLQ $32,AX; \
|
||||
ADDQ R14,R10; MOVQ R10, 0+z; \
|
||||
ADCQ $0,R11; MOVQ R11, 8+z; \
|
||||
ADCQ $0,R12; MOVQ R12,16+z; \
|
||||
ADCQ AX,R13; MOVQ R13,24+z; \
|
||||
ADCQ $0,R15; MOVQ R15,32+z; \
|
||||
ADCQ $0, R8; MOVQ R8,40+z; \
|
||||
ADCQ $0, R9; MOVQ R9,48+z;
|
||||
|
||||
// reduceFromDoubleAdx finds a z=x modulo p such that z<2^448 and stores in z
|
||||
// Uses: AX, R8-R15, FLAGS
|
||||
// Instr: x86_64, adx
|
||||
#define reduceFromDoubleAdx(z,x) \
|
||||
/* ( ,2C13,2C12,2C11,2C10|C10,C9,C8, C7) + (C6,...,C0) */ \
|
||||
/* (r14, r13, r12, r11, r10,r9,r8,r15) */ \
|
||||
MOVQ 80+x,AX; MOVQ AX,R10; \
|
||||
MOVQ $0xFFFFFFFF00000000, R8; \
|
||||
ANDQ R8,R10; \
|
||||
\
|
||||
MOVQ $0,R14; \
|
||||
MOVQ 104+x,R13; SHLQ $1,R13,R14; \
|
||||
MOVQ 96+x,R12; SHLQ $1,R12,R13; \
|
||||
MOVQ 88+x,R11; SHLQ $1,R11,R12; \
|
||||
MOVQ 72+x, R9; SHLQ $1,R10,R11; \
|
||||
MOVQ 64+x, R8; SHLQ $1,R10; \
|
||||
MOVQ $0xFFFFFFFF,R15; ANDQ R15,AX; ORQ AX,R10; \
|
||||
MOVQ 56+x,R15; \
|
||||
\
|
||||
XORL AX,AX; \
|
||||
ADCXQ 0+x,R15; MOVQ R15, 0+z; MOVQ 56+x,R15; \
|
||||
ADCXQ 8+x, R8; MOVQ R8, 8+z; MOVQ 64+x, R8; \
|
||||
ADCXQ 16+x, R9; MOVQ R9,16+z; MOVQ 72+x, R9; \
|
||||
ADCXQ 24+x,R10; MOVQ R10,24+z; MOVQ 80+x,R10; \
|
||||
ADCXQ 32+x,R11; MOVQ R11,32+z; MOVQ 88+x,R11; \
|
||||
ADCXQ 40+x,R12; MOVQ R12,40+z; MOVQ 96+x,R12; \
|
||||
ADCXQ 48+x,R13; MOVQ R13,48+z; MOVQ 104+x,R13; \
|
||||
ADCXQ AX,R14; \
|
||||
/* (c10c9,c9c8,c8c7,c7c13,c13c12,c12c11,c11c10) + (c6,...,c0) */ \
|
||||
/* ( r9, r8, r15, r13, r12, r11, r10) */ \
|
||||
MOVQ R10, AX; \
|
||||
SHRQ $32,R11,R10; \
|
||||
SHRQ $32,R12,R11; \
|
||||
SHRQ $32,R13,R12; \
|
||||
SHRQ $32,R15,R13; \
|
||||
SHRQ $32, R8,R15; \
|
||||
SHRQ $32, R9, R8; \
|
||||
SHRQ $32, AX, R9; \
|
||||
\
|
||||
XORL AX,AX; \
|
||||
ADCXQ 0+z,R10; \
|
||||
ADCXQ 8+z,R11; \
|
||||
ADCXQ 16+z,R12; \
|
||||
ADCXQ 24+z,R13; \
|
||||
ADCXQ 32+z,R15; \
|
||||
ADCXQ 40+z, R8; \
|
||||
ADCXQ 48+z, R9; \
|
||||
ADCXQ AX,R14; \
|
||||
/* ( c7) + (c6,...,c0) */ \
|
||||
/* (r14) */ \
|
||||
MOVQ R14, AX; SHLQ $32, AX; \
|
||||
CLC; \
|
||||
ADCXQ R14,R10; MOVQ $0,R14; \
|
||||
ADCXQ R14,R11; \
|
||||
ADCXQ R14,R12; \
|
||||
ADCXQ AX,R13; \
|
||||
ADCXQ R14,R15; \
|
||||
ADCXQ R14, R8; \
|
||||
ADCXQ R14, R9; \
|
||||
ADCXQ R14,R14; \
|
||||
/* ( c7) + (c6,...,c0) */ \
|
||||
/* (r14) */ \
|
||||
MOVQ R14, AX; SHLQ $32, AX; \
|
||||
CLC; \
|
||||
ADCXQ R14,R10; MOVQ R10, 0+z; MOVQ $0,R14; \
|
||||
ADCXQ R14,R11; MOVQ R11, 8+z; \
|
||||
ADCXQ R14,R12; MOVQ R12,16+z; \
|
||||
ADCXQ AX,R13; MOVQ R13,24+z; \
|
||||
ADCXQ R14,R15; MOVQ R15,32+z; \
|
||||
ADCXQ R14, R8; MOVQ R8,40+z; \
|
||||
ADCXQ R14, R9; MOVQ R9,48+z;
|
||||
|
||||
// addSub calculates two operations: x,y = x+y,x-y
|
||||
// Uses: AX, DX, R8-R15, FLAGS
|
||||
#define addSub(x,y) \
|
||||
MOVQ 0+x, R8; ADDQ 0+y, R8; \
|
||||
MOVQ 8+x, R9; ADCQ 8+y, R9; \
|
||||
MOVQ 16+x, R10; ADCQ 16+y, R10; \
|
||||
MOVQ 24+x, R11; ADCQ 24+y, R11; \
|
||||
MOVQ 32+x, R12; ADCQ 32+y, R12; \
|
||||
MOVQ 40+x, R13; ADCQ 40+y, R13; \
|
||||
MOVQ 48+x, R14; ADCQ 48+y, R14; \
|
||||
MOVQ $0, AX; ADCQ $0, AX; \
|
||||
MOVQ AX, DX; \
|
||||
SHLQ $32, DX; \
|
||||
ADDQ AX, R8; MOVQ $0, AX; \
|
||||
ADCQ $0, R9; \
|
||||
ADCQ $0, R10; \
|
||||
ADCQ DX, R11; \
|
||||
ADCQ $0, R12; \
|
||||
ADCQ $0, R13; \
|
||||
ADCQ $0, R14; \
|
||||
ADCQ $0, AX; \
|
||||
MOVQ AX, DX; \
|
||||
SHLQ $32, DX; \
|
||||
ADDQ AX, R8; MOVQ 0+x,AX; MOVQ R8, 0+x; MOVQ AX, R8; \
|
||||
ADCQ $0, R9; MOVQ 8+x,AX; MOVQ R9, 8+x; MOVQ AX, R9; \
|
||||
ADCQ $0, R10; MOVQ 16+x,AX; MOVQ R10, 16+x; MOVQ AX, R10; \
|
||||
ADCQ DX, R11; MOVQ 24+x,AX; MOVQ R11, 24+x; MOVQ AX, R11; \
|
||||
ADCQ $0, R12; MOVQ 32+x,AX; MOVQ R12, 32+x; MOVQ AX, R12; \
|
||||
ADCQ $0, R13; MOVQ 40+x,AX; MOVQ R13, 40+x; MOVQ AX, R13; \
|
||||
ADCQ $0, R14; MOVQ 48+x,AX; MOVQ R14, 48+x; MOVQ AX, R14; \
|
||||
SUBQ 0+y, R8; \
|
||||
SBBQ 8+y, R9; \
|
||||
SBBQ 16+y, R10; \
|
||||
SBBQ 24+y, R11; \
|
||||
SBBQ 32+y, R12; \
|
||||
SBBQ 40+y, R13; \
|
||||
SBBQ 48+y, R14; \
|
||||
MOVQ $0, AX; SETCS AX; \
|
||||
MOVQ AX, DX; \
|
||||
SHLQ $32, DX; \
|
||||
SUBQ AX, R8; MOVQ $0, AX; \
|
||||
SBBQ $0, R9; \
|
||||
SBBQ $0, R10; \
|
||||
SBBQ DX, R11; \
|
||||
SBBQ $0, R12; \
|
||||
SBBQ $0, R13; \
|
||||
SBBQ $0, R14; \
|
||||
SETCS AX; \
|
||||
MOVQ AX, DX; \
|
||||
SHLQ $32, DX; \
|
||||
SUBQ AX, R8; MOVQ R8, 0+y; \
|
||||
SBBQ $0, R9; MOVQ R9, 8+y; \
|
||||
SBBQ $0, R10; MOVQ R10, 16+y; \
|
||||
SBBQ DX, R11; MOVQ R11, 24+y; \
|
||||
SBBQ $0, R12; MOVQ R12, 32+y; \
|
||||
SBBQ $0, R13; MOVQ R13, 40+y; \
|
||||
SBBQ $0, R14; MOVQ R14, 48+y;
|
||||
74
vendor/github.com/cloudflare/circl/math/fp448/fp_amd64.s
generated
vendored
Normal file
74
vendor/github.com/cloudflare/circl/math/fp448/fp_amd64.s
generated
vendored
Normal file
@ -0,0 +1,74 @@
|
||||
// +build amd64
|
||||
|
||||
#include "textflag.h"
|
||||
#include "fp_amd64.h"
|
||||
|
||||
// func cmovAmd64(x, y *Elt, n uint)
|
||||
TEXT ·cmovAmd64(SB),NOSPLIT,$0-24
|
||||
MOVQ x+0(FP), DI
|
||||
MOVQ y+8(FP), SI
|
||||
MOVQ n+16(FP), BX
|
||||
cselect(0(DI),0(SI),BX)
|
||||
RET
|
||||
|
||||
// func cswapAmd64(x, y *Elt, n uint)
|
||||
TEXT ·cswapAmd64(SB),NOSPLIT,$0-24
|
||||
MOVQ x+0(FP), DI
|
||||
MOVQ y+8(FP), SI
|
||||
MOVQ n+16(FP), BX
|
||||
cswap(0(DI),0(SI),BX)
|
||||
RET
|
||||
|
||||
// func subAmd64(z, x, y *Elt)
|
||||
TEXT ·subAmd64(SB),NOSPLIT,$0-24
|
||||
MOVQ z+0(FP), DI
|
||||
MOVQ x+8(FP), SI
|
||||
MOVQ y+16(FP), BX
|
||||
subtraction(0(DI),0(SI),0(BX))
|
||||
RET
|
||||
|
||||
// func addsubAmd64(x, y *Elt)
|
||||
TEXT ·addsubAmd64(SB),NOSPLIT,$0-16
|
||||
MOVQ x+0(FP), DI
|
||||
MOVQ y+8(FP), SI
|
||||
addSub(0(DI),0(SI))
|
||||
RET
|
||||
|
||||
#define addLegacy \
|
||||
additionLeg(0(DI),0(SI),0(BX))
|
||||
#define addBmi2Adx \
|
||||
additionAdx(0(DI),0(SI),0(BX))
|
||||
|
||||
#define mulLegacy \
|
||||
integerMulLeg(0(SP),0(SI),0(BX)) \
|
||||
reduceFromDoubleLeg(0(DI),0(SP))
|
||||
#define mulBmi2Adx \
|
||||
integerMulAdx(0(SP),0(SI),0(BX)) \
|
||||
reduceFromDoubleAdx(0(DI),0(SP))
|
||||
|
||||
#define sqrLegacy \
|
||||
integerSqrLeg(0(SP),0(SI)) \
|
||||
reduceFromDoubleLeg(0(DI),0(SP))
|
||||
#define sqrBmi2Adx \
|
||||
integerSqrAdx(0(SP),0(SI)) \
|
||||
reduceFromDoubleAdx(0(DI),0(SP))
|
||||
|
||||
// func addAmd64(z, x, y *Elt)
|
||||
TEXT ·addAmd64(SB),NOSPLIT,$0-24
|
||||
MOVQ z+0(FP), DI
|
||||
MOVQ x+8(FP), SI
|
||||
MOVQ y+16(FP), BX
|
||||
CHECK_BMI2ADX(LADD, addLegacy, addBmi2Adx)
|
||||
|
||||
// func mulAmd64(z, x, y *Elt)
|
||||
TEXT ·mulAmd64(SB),NOSPLIT,$112-24
|
||||
MOVQ z+0(FP), DI
|
||||
MOVQ x+8(FP), SI
|
||||
MOVQ y+16(FP), BX
|
||||
CHECK_BMI2ADX(LMUL, mulLegacy, mulBmi2Adx)
|
||||
|
||||
// func sqrAmd64(z, x *Elt)
|
||||
TEXT ·sqrAmd64(SB),NOSPLIT,$112-16
|
||||
MOVQ z+0(FP), DI
|
||||
MOVQ x+8(FP), SI
|
||||
CHECK_BMI2ADX(LSQR, sqrLegacy, sqrBmi2Adx)
|
||||
339
vendor/github.com/cloudflare/circl/math/fp448/fp_generic.go
generated
vendored
Normal file
339
vendor/github.com/cloudflare/circl/math/fp448/fp_generic.go
generated
vendored
Normal file
@ -0,0 +1,339 @@
|
||||
package fp448
|
||||
|
||||
import (
|
||||
"encoding/binary"
|
||||
"math/bits"
|
||||
)
|
||||
|
||||
func cmovGeneric(x, y *Elt, n uint) {
|
||||
m := -uint64(n & 0x1)
|
||||
x0 := binary.LittleEndian.Uint64(x[0*8 : 1*8])
|
||||
x1 := binary.LittleEndian.Uint64(x[1*8 : 2*8])
|
||||
x2 := binary.LittleEndian.Uint64(x[2*8 : 3*8])
|
||||
x3 := binary.LittleEndian.Uint64(x[3*8 : 4*8])
|
||||
x4 := binary.LittleEndian.Uint64(x[4*8 : 5*8])
|
||||
x5 := binary.LittleEndian.Uint64(x[5*8 : 6*8])
|
||||
x6 := binary.LittleEndian.Uint64(x[6*8 : 7*8])
|
||||
|
||||
y0 := binary.LittleEndian.Uint64(y[0*8 : 1*8])
|
||||
y1 := binary.LittleEndian.Uint64(y[1*8 : 2*8])
|
||||
y2 := binary.LittleEndian.Uint64(y[2*8 : 3*8])
|
||||
y3 := binary.LittleEndian.Uint64(y[3*8 : 4*8])
|
||||
y4 := binary.LittleEndian.Uint64(y[4*8 : 5*8])
|
||||
y5 := binary.LittleEndian.Uint64(y[5*8 : 6*8])
|
||||
y6 := binary.LittleEndian.Uint64(y[6*8 : 7*8])
|
||||
|
||||
x0 = (x0 &^ m) | (y0 & m)
|
||||
x1 = (x1 &^ m) | (y1 & m)
|
||||
x2 = (x2 &^ m) | (y2 & m)
|
||||
x3 = (x3 &^ m) | (y3 & m)
|
||||
x4 = (x4 &^ m) | (y4 & m)
|
||||
x5 = (x5 &^ m) | (y5 & m)
|
||||
x6 = (x6 &^ m) | (y6 & m)
|
||||
|
||||
binary.LittleEndian.PutUint64(x[0*8:1*8], x0)
|
||||
binary.LittleEndian.PutUint64(x[1*8:2*8], x1)
|
||||
binary.LittleEndian.PutUint64(x[2*8:3*8], x2)
|
||||
binary.LittleEndian.PutUint64(x[3*8:4*8], x3)
|
||||
binary.LittleEndian.PutUint64(x[4*8:5*8], x4)
|
||||
binary.LittleEndian.PutUint64(x[5*8:6*8], x5)
|
||||
binary.LittleEndian.PutUint64(x[6*8:7*8], x6)
|
||||
}
|
||||
|
||||
func cswapGeneric(x, y *Elt, n uint) {
|
||||
m := -uint64(n & 0x1)
|
||||
x0 := binary.LittleEndian.Uint64(x[0*8 : 1*8])
|
||||
x1 := binary.LittleEndian.Uint64(x[1*8 : 2*8])
|
||||
x2 := binary.LittleEndian.Uint64(x[2*8 : 3*8])
|
||||
x3 := binary.LittleEndian.Uint64(x[3*8 : 4*8])
|
||||
x4 := binary.LittleEndian.Uint64(x[4*8 : 5*8])
|
||||
x5 := binary.LittleEndian.Uint64(x[5*8 : 6*8])
|
||||
x6 := binary.LittleEndian.Uint64(x[6*8 : 7*8])
|
||||
|
||||
y0 := binary.LittleEndian.Uint64(y[0*8 : 1*8])
|
||||
y1 := binary.LittleEndian.Uint64(y[1*8 : 2*8])
|
||||
y2 := binary.LittleEndian.Uint64(y[2*8 : 3*8])
|
||||
y3 := binary.LittleEndian.Uint64(y[3*8 : 4*8])
|
||||
y4 := binary.LittleEndian.Uint64(y[4*8 : 5*8])
|
||||
y5 := binary.LittleEndian.Uint64(y[5*8 : 6*8])
|
||||
y6 := binary.LittleEndian.Uint64(y[6*8 : 7*8])
|
||||
|
||||
t0 := m & (x0 ^ y0)
|
||||
t1 := m & (x1 ^ y1)
|
||||
t2 := m & (x2 ^ y2)
|
||||
t3 := m & (x3 ^ y3)
|
||||
t4 := m & (x4 ^ y4)
|
||||
t5 := m & (x5 ^ y5)
|
||||
t6 := m & (x6 ^ y6)
|
||||
x0 ^= t0
|
||||
x1 ^= t1
|
||||
x2 ^= t2
|
||||
x3 ^= t3
|
||||
x4 ^= t4
|
||||
x5 ^= t5
|
||||
x6 ^= t6
|
||||
y0 ^= t0
|
||||
y1 ^= t1
|
||||
y2 ^= t2
|
||||
y3 ^= t3
|
||||
y4 ^= t4
|
||||
y5 ^= t5
|
||||
y6 ^= t6
|
||||
|
||||
binary.LittleEndian.PutUint64(x[0*8:1*8], x0)
|
||||
binary.LittleEndian.PutUint64(x[1*8:2*8], x1)
|
||||
binary.LittleEndian.PutUint64(x[2*8:3*8], x2)
|
||||
binary.LittleEndian.PutUint64(x[3*8:4*8], x3)
|
||||
binary.LittleEndian.PutUint64(x[4*8:5*8], x4)
|
||||
binary.LittleEndian.PutUint64(x[5*8:6*8], x5)
|
||||
binary.LittleEndian.PutUint64(x[6*8:7*8], x6)
|
||||
|
||||
binary.LittleEndian.PutUint64(y[0*8:1*8], y0)
|
||||
binary.LittleEndian.PutUint64(y[1*8:2*8], y1)
|
||||
binary.LittleEndian.PutUint64(y[2*8:3*8], y2)
|
||||
binary.LittleEndian.PutUint64(y[3*8:4*8], y3)
|
||||
binary.LittleEndian.PutUint64(y[4*8:5*8], y4)
|
||||
binary.LittleEndian.PutUint64(y[5*8:6*8], y5)
|
||||
binary.LittleEndian.PutUint64(y[6*8:7*8], y6)
|
||||
}
|
||||
|
||||
func addGeneric(z, x, y *Elt) {
|
||||
x0 := binary.LittleEndian.Uint64(x[0*8 : 1*8])
|
||||
x1 := binary.LittleEndian.Uint64(x[1*8 : 2*8])
|
||||
x2 := binary.LittleEndian.Uint64(x[2*8 : 3*8])
|
||||
x3 := binary.LittleEndian.Uint64(x[3*8 : 4*8])
|
||||
x4 := binary.LittleEndian.Uint64(x[4*8 : 5*8])
|
||||
x5 := binary.LittleEndian.Uint64(x[5*8 : 6*8])
|
||||
x6 := binary.LittleEndian.Uint64(x[6*8 : 7*8])
|
||||
|
||||
y0 := binary.LittleEndian.Uint64(y[0*8 : 1*8])
|
||||
y1 := binary.LittleEndian.Uint64(y[1*8 : 2*8])
|
||||
y2 := binary.LittleEndian.Uint64(y[2*8 : 3*8])
|
||||
y3 := binary.LittleEndian.Uint64(y[3*8 : 4*8])
|
||||
y4 := binary.LittleEndian.Uint64(y[4*8 : 5*8])
|
||||
y5 := binary.LittleEndian.Uint64(y[5*8 : 6*8])
|
||||
y6 := binary.LittleEndian.Uint64(y[6*8 : 7*8])
|
||||
|
||||
z0, c0 := bits.Add64(x0, y0, 0)
|
||||
z1, c1 := bits.Add64(x1, y1, c0)
|
||||
z2, c2 := bits.Add64(x2, y2, c1)
|
||||
z3, c3 := bits.Add64(x3, y3, c2)
|
||||
z4, c4 := bits.Add64(x4, y4, c3)
|
||||
z5, c5 := bits.Add64(x5, y5, c4)
|
||||
z6, z7 := bits.Add64(x6, y6, c5)
|
||||
|
||||
z0, c0 = bits.Add64(z0, z7, 0)
|
||||
z1, c1 = bits.Add64(z1, 0, c0)
|
||||
z2, c2 = bits.Add64(z2, 0, c1)
|
||||
z3, c3 = bits.Add64(z3, z7<<32, c2)
|
||||
z4, c4 = bits.Add64(z4, 0, c3)
|
||||
z5, c5 = bits.Add64(z5, 0, c4)
|
||||
z6, z7 = bits.Add64(z6, 0, c5)
|
||||
|
||||
z0, c0 = bits.Add64(z0, z7, 0)
|
||||
z1, c1 = bits.Add64(z1, 0, c0)
|
||||
z2, c2 = bits.Add64(z2, 0, c1)
|
||||
z3, c3 = bits.Add64(z3, z7<<32, c2)
|
||||
z4, c4 = bits.Add64(z4, 0, c3)
|
||||
z5, c5 = bits.Add64(z5, 0, c4)
|
||||
z6, _ = bits.Add64(z6, 0, c5)
|
||||
|
||||
binary.LittleEndian.PutUint64(z[0*8:1*8], z0)
|
||||
binary.LittleEndian.PutUint64(z[1*8:2*8], z1)
|
||||
binary.LittleEndian.PutUint64(z[2*8:3*8], z2)
|
||||
binary.LittleEndian.PutUint64(z[3*8:4*8], z3)
|
||||
binary.LittleEndian.PutUint64(z[4*8:5*8], z4)
|
||||
binary.LittleEndian.PutUint64(z[5*8:6*8], z5)
|
||||
binary.LittleEndian.PutUint64(z[6*8:7*8], z6)
|
||||
}
|
||||
|
||||
func subGeneric(z, x, y *Elt) {
|
||||
x0 := binary.LittleEndian.Uint64(x[0*8 : 1*8])
|
||||
x1 := binary.LittleEndian.Uint64(x[1*8 : 2*8])
|
||||
x2 := binary.LittleEndian.Uint64(x[2*8 : 3*8])
|
||||
x3 := binary.LittleEndian.Uint64(x[3*8 : 4*8])
|
||||
x4 := binary.LittleEndian.Uint64(x[4*8 : 5*8])
|
||||
x5 := binary.LittleEndian.Uint64(x[5*8 : 6*8])
|
||||
x6 := binary.LittleEndian.Uint64(x[6*8 : 7*8])
|
||||
|
||||
y0 := binary.LittleEndian.Uint64(y[0*8 : 1*8])
|
||||
y1 := binary.LittleEndian.Uint64(y[1*8 : 2*8])
|
||||
y2 := binary.LittleEndian.Uint64(y[2*8 : 3*8])
|
||||
y3 := binary.LittleEndian.Uint64(y[3*8 : 4*8])
|
||||
y4 := binary.LittleEndian.Uint64(y[4*8 : 5*8])
|
||||
y5 := binary.LittleEndian.Uint64(y[5*8 : 6*8])
|
||||
y6 := binary.LittleEndian.Uint64(y[6*8 : 7*8])
|
||||
|
||||
z0, c0 := bits.Sub64(x0, y0, 0)
|
||||
z1, c1 := bits.Sub64(x1, y1, c0)
|
||||
z2, c2 := bits.Sub64(x2, y2, c1)
|
||||
z3, c3 := bits.Sub64(x3, y3, c2)
|
||||
z4, c4 := bits.Sub64(x4, y4, c3)
|
||||
z5, c5 := bits.Sub64(x5, y5, c4)
|
||||
z6, z7 := bits.Sub64(x6, y6, c5)
|
||||
|
||||
z0, c0 = bits.Sub64(z0, z7, 0)
|
||||
z1, c1 = bits.Sub64(z1, 0, c0)
|
||||
z2, c2 = bits.Sub64(z2, 0, c1)
|
||||
z3, c3 = bits.Sub64(z3, z7<<32, c2)
|
||||
z4, c4 = bits.Sub64(z4, 0, c3)
|
||||
z5, c5 = bits.Sub64(z5, 0, c4)
|
||||
z6, z7 = bits.Sub64(z6, 0, c5)
|
||||
|
||||
z0, c0 = bits.Sub64(z0, z7, 0)
|
||||
z1, c1 = bits.Sub64(z1, 0, c0)
|
||||
z2, c2 = bits.Sub64(z2, 0, c1)
|
||||
z3, c3 = bits.Sub64(z3, z7<<32, c2)
|
||||
z4, c4 = bits.Sub64(z4, 0, c3)
|
||||
z5, c5 = bits.Sub64(z5, 0, c4)
|
||||
z6, _ = bits.Sub64(z6, 0, c5)
|
||||
|
||||
binary.LittleEndian.PutUint64(z[0*8:1*8], z0)
|
||||
binary.LittleEndian.PutUint64(z[1*8:2*8], z1)
|
||||
binary.LittleEndian.PutUint64(z[2*8:3*8], z2)
|
||||
binary.LittleEndian.PutUint64(z[3*8:4*8], z3)
|
||||
binary.LittleEndian.PutUint64(z[4*8:5*8], z4)
|
||||
binary.LittleEndian.PutUint64(z[5*8:6*8], z5)
|
||||
binary.LittleEndian.PutUint64(z[6*8:7*8], z6)
|
||||
}
|
||||
|
||||
func addsubGeneric(x, y *Elt) {
|
||||
z := &Elt{}
|
||||
addGeneric(z, x, y)
|
||||
subGeneric(y, x, y)
|
||||
*x = *z
|
||||
}
|
||||
|
||||
func mulGeneric(z, x, y *Elt) {
|
||||
x0 := binary.LittleEndian.Uint64(x[0*8 : 1*8])
|
||||
x1 := binary.LittleEndian.Uint64(x[1*8 : 2*8])
|
||||
x2 := binary.LittleEndian.Uint64(x[2*8 : 3*8])
|
||||
x3 := binary.LittleEndian.Uint64(x[3*8 : 4*8])
|
||||
x4 := binary.LittleEndian.Uint64(x[4*8 : 5*8])
|
||||
x5 := binary.LittleEndian.Uint64(x[5*8 : 6*8])
|
||||
x6 := binary.LittleEndian.Uint64(x[6*8 : 7*8])
|
||||
|
||||
y0 := binary.LittleEndian.Uint64(y[0*8 : 1*8])
|
||||
y1 := binary.LittleEndian.Uint64(y[1*8 : 2*8])
|
||||
y2 := binary.LittleEndian.Uint64(y[2*8 : 3*8])
|
||||
y3 := binary.LittleEndian.Uint64(y[3*8 : 4*8])
|
||||
y4 := binary.LittleEndian.Uint64(y[4*8 : 5*8])
|
||||
y5 := binary.LittleEndian.Uint64(y[5*8 : 6*8])
|
||||
y6 := binary.LittleEndian.Uint64(y[6*8 : 7*8])
|
||||
|
||||
yy := [7]uint64{y0, y1, y2, y3, y4, y5, y6}
|
||||
zz := [7]uint64{}
|
||||
|
||||
yi := yy[0]
|
||||
h0, l0 := bits.Mul64(x0, yi)
|
||||
h1, l1 := bits.Mul64(x1, yi)
|
||||
h2, l2 := bits.Mul64(x2, yi)
|
||||
h3, l3 := bits.Mul64(x3, yi)
|
||||
h4, l4 := bits.Mul64(x4, yi)
|
||||
h5, l5 := bits.Mul64(x5, yi)
|
||||
h6, l6 := bits.Mul64(x6, yi)
|
||||
|
||||
zz[0] = l0
|
||||
a0, c0 := bits.Add64(h0, l1, 0)
|
||||
a1, c1 := bits.Add64(h1, l2, c0)
|
||||
a2, c2 := bits.Add64(h2, l3, c1)
|
||||
a3, c3 := bits.Add64(h3, l4, c2)
|
||||
a4, c4 := bits.Add64(h4, l5, c3)
|
||||
a5, c5 := bits.Add64(h5, l6, c4)
|
||||
a6, _ := bits.Add64(h6, 0, c5)
|
||||
|
||||
for i := 1; i < 7; i++ {
|
||||
yi = yy[i]
|
||||
h0, l0 = bits.Mul64(x0, yi)
|
||||
h1, l1 = bits.Mul64(x1, yi)
|
||||
h2, l2 = bits.Mul64(x2, yi)
|
||||
h3, l3 = bits.Mul64(x3, yi)
|
||||
h4, l4 = bits.Mul64(x4, yi)
|
||||
h5, l5 = bits.Mul64(x5, yi)
|
||||
h6, l6 = bits.Mul64(x6, yi)
|
||||
|
||||
zz[i], c0 = bits.Add64(a0, l0, 0)
|
||||
a0, c1 = bits.Add64(a1, l1, c0)
|
||||
a1, c2 = bits.Add64(a2, l2, c1)
|
||||
a2, c3 = bits.Add64(a3, l3, c2)
|
||||
a3, c4 = bits.Add64(a4, l4, c3)
|
||||
a4, c5 = bits.Add64(a5, l5, c4)
|
||||
a5, a6 = bits.Add64(a6, l6, c5)
|
||||
|
||||
a0, c0 = bits.Add64(a0, h0, 0)
|
||||
a1, c1 = bits.Add64(a1, h1, c0)
|
||||
a2, c2 = bits.Add64(a2, h2, c1)
|
||||
a3, c3 = bits.Add64(a3, h3, c2)
|
||||
a4, c4 = bits.Add64(a4, h4, c3)
|
||||
a5, c5 = bits.Add64(a5, h5, c4)
|
||||
a6, _ = bits.Add64(a6, h6, c5)
|
||||
}
|
||||
red64(z, &zz, &[7]uint64{a0, a1, a2, a3, a4, a5, a6})
|
||||
}
|
||||
|
||||
func sqrGeneric(z, x *Elt) { mulGeneric(z, x, x) }
|
||||
|
||||
func red64(z *Elt, l, h *[7]uint64) {
|
||||
/* (2C13, 2C12, 2C11, 2C10|C10, C9, C8, C7) + (C6,...,C0) */
|
||||
h0 := h[0]
|
||||
h1 := h[1]
|
||||
h2 := h[2]
|
||||
h3 := ((h[3] & (0xFFFFFFFF << 32)) << 1) | (h[3] & 0xFFFFFFFF)
|
||||
h4 := (h[3] >> 63) | (h[4] << 1)
|
||||
h5 := (h[4] >> 63) | (h[5] << 1)
|
||||
h6 := (h[5] >> 63) | (h[6] << 1)
|
||||
h7 := (h[6] >> 63)
|
||||
|
||||
l0, c0 := bits.Add64(h0, l[0], 0)
|
||||
l1, c1 := bits.Add64(h1, l[1], c0)
|
||||
l2, c2 := bits.Add64(h2, l[2], c1)
|
||||
l3, c3 := bits.Add64(h3, l[3], c2)
|
||||
l4, c4 := bits.Add64(h4, l[4], c3)
|
||||
l5, c5 := bits.Add64(h5, l[5], c4)
|
||||
l6, c6 := bits.Add64(h6, l[6], c5)
|
||||
l7, _ := bits.Add64(h7, 0, c6)
|
||||
|
||||
/* (C10C9, C9C8,C8C7,C7C13,C13C12,C12C11,C11C10) + (C6,...,C0) */
|
||||
h0 = (h[3] >> 32) | (h[4] << 32)
|
||||
h1 = (h[4] >> 32) | (h[5] << 32)
|
||||
h2 = (h[5] >> 32) | (h[6] << 32)
|
||||
h3 = (h[6] >> 32) | (h[0] << 32)
|
||||
h4 = (h[0] >> 32) | (h[1] << 32)
|
||||
h5 = (h[1] >> 32) | (h[2] << 32)
|
||||
h6 = (h[2] >> 32) | (h[3] << 32)
|
||||
|
||||
l0, c0 = bits.Add64(l0, h0, 0)
|
||||
l1, c1 = bits.Add64(l1, h1, c0)
|
||||
l2, c2 = bits.Add64(l2, h2, c1)
|
||||
l3, c3 = bits.Add64(l3, h3, c2)
|
||||
l4, c4 = bits.Add64(l4, h4, c3)
|
||||
l5, c5 = bits.Add64(l5, h5, c4)
|
||||
l6, c6 = bits.Add64(l6, h6, c5)
|
||||
l7, _ = bits.Add64(l7, 0, c6)
|
||||
|
||||
/* (C7) + (C6,...,C0) */
|
||||
l0, c0 = bits.Add64(l0, l7, 0)
|
||||
l1, c1 = bits.Add64(l1, 0, c0)
|
||||
l2, c2 = bits.Add64(l2, 0, c1)
|
||||
l3, c3 = bits.Add64(l3, l7<<32, c2)
|
||||
l4, c4 = bits.Add64(l4, 0, c3)
|
||||
l5, c5 = bits.Add64(l5, 0, c4)
|
||||
l6, l7 = bits.Add64(l6, 0, c5)
|
||||
|
||||
/* (C7) + (C6,...,C0) */
|
||||
l0, c0 = bits.Add64(l0, l7, 0)
|
||||
l1, c1 = bits.Add64(l1, 0, c0)
|
||||
l2, c2 = bits.Add64(l2, 0, c1)
|
||||
l3, c3 = bits.Add64(l3, l7<<32, c2)
|
||||
l4, c4 = bits.Add64(l4, 0, c3)
|
||||
l5, c5 = bits.Add64(l5, 0, c4)
|
||||
l6, _ = bits.Add64(l6, 0, c5)
|
||||
|
||||
binary.LittleEndian.PutUint64(z[0*8:1*8], l0)
|
||||
binary.LittleEndian.PutUint64(z[1*8:2*8], l1)
|
||||
binary.LittleEndian.PutUint64(z[2*8:3*8], l2)
|
||||
binary.LittleEndian.PutUint64(z[3*8:4*8], l3)
|
||||
binary.LittleEndian.PutUint64(z[4*8:5*8], l4)
|
||||
binary.LittleEndian.PutUint64(z[5*8:6*8], l5)
|
||||
binary.LittleEndian.PutUint64(z[6*8:7*8], l6)
|
||||
}
|
||||
12
vendor/github.com/cloudflare/circl/math/fp448/fp_noasm.go
generated
vendored
Normal file
12
vendor/github.com/cloudflare/circl/math/fp448/fp_noasm.go
generated
vendored
Normal file
@ -0,0 +1,12 @@
|
||||
//go:build !amd64 || purego
|
||||
// +build !amd64 purego
|
||||
|
||||
package fp448
|
||||
|
||||
func cmov(x, y *Elt, n uint) { cmovGeneric(x, y, n) }
|
||||
func cswap(x, y *Elt, n uint) { cswapGeneric(x, y, n) }
|
||||
func add(z, x, y *Elt) { addGeneric(z, x, y) }
|
||||
func sub(z, x, y *Elt) { subGeneric(z, x, y) }
|
||||
func addsub(x, y *Elt) { addsubGeneric(x, y) }
|
||||
func mul(z, x, y *Elt) { mulGeneric(z, x, y) }
|
||||
func sqr(z, x *Elt) { sqrGeneric(z, x) }
|
||||
75
vendor/github.com/cloudflare/circl/math/fp448/fuzzer.go
generated
vendored
Normal file
75
vendor/github.com/cloudflare/circl/math/fp448/fuzzer.go
generated
vendored
Normal file
@ -0,0 +1,75 @@
|
||||
//go:build gofuzz
|
||||
// +build gofuzz
|
||||
|
||||
// How to run the fuzzer:
|
||||
//
|
||||
// $ go get -u github.com/dvyukov/go-fuzz/go-fuzz
|
||||
// $ go get -u github.com/dvyukov/go-fuzz/go-fuzz-build
|
||||
// $ go-fuzz-build -libfuzzer -func FuzzReduction -o lib.a
|
||||
// $ clang -fsanitize=fuzzer lib.a -o fu.exe
|
||||
// $ ./fu.exe
|
||||
package fp448
|
||||
|
||||
import (
|
||||
"encoding/binary"
|
||||
"fmt"
|
||||
"math/big"
|
||||
|
||||
"github.com/cloudflare/circl/internal/conv"
|
||||
)
|
||||
|
||||
// FuzzReduction is a fuzzer target for red64 function, which reduces t
|
||||
// (112 bits) to a number t' (56 bits) congruent modulo p448.
|
||||
func FuzzReduction(data []byte) int {
|
||||
if len(data) != 2*Size {
|
||||
return -1
|
||||
}
|
||||
var got, want Elt
|
||||
var lo, hi [7]uint64
|
||||
a := data[:Size]
|
||||
b := data[Size:]
|
||||
lo[0] = binary.LittleEndian.Uint64(a[0*8 : 1*8])
|
||||
lo[1] = binary.LittleEndian.Uint64(a[1*8 : 2*8])
|
||||
lo[2] = binary.LittleEndian.Uint64(a[2*8 : 3*8])
|
||||
lo[3] = binary.LittleEndian.Uint64(a[3*8 : 4*8])
|
||||
lo[4] = binary.LittleEndian.Uint64(a[4*8 : 5*8])
|
||||
lo[5] = binary.LittleEndian.Uint64(a[5*8 : 6*8])
|
||||
lo[6] = binary.LittleEndian.Uint64(a[6*8 : 7*8])
|
||||
|
||||
hi[0] = binary.LittleEndian.Uint64(b[0*8 : 1*8])
|
||||
hi[1] = binary.LittleEndian.Uint64(b[1*8 : 2*8])
|
||||
hi[2] = binary.LittleEndian.Uint64(b[2*8 : 3*8])
|
||||
hi[3] = binary.LittleEndian.Uint64(b[3*8 : 4*8])
|
||||
hi[4] = binary.LittleEndian.Uint64(b[4*8 : 5*8])
|
||||
hi[5] = binary.LittleEndian.Uint64(b[5*8 : 6*8])
|
||||
hi[6] = binary.LittleEndian.Uint64(b[6*8 : 7*8])
|
||||
|
||||
red64(&got, &lo, &hi)
|
||||
|
||||
t := conv.BytesLe2BigInt(data[:2*Size])
|
||||
|
||||
two448 := big.NewInt(1)
|
||||
two448.Lsh(two448, 448) // 2^448
|
||||
mask448 := big.NewInt(1)
|
||||
mask448.Sub(two448, mask448) // 2^448-1
|
||||
two224plus1 := big.NewInt(1)
|
||||
two224plus1.Lsh(two224plus1, 224)
|
||||
two224plus1.Add(two224plus1, big.NewInt(1)) // 2^224+1
|
||||
|
||||
var loBig, hiBig big.Int
|
||||
for t.Cmp(two448) >= 0 {
|
||||
loBig.And(t, mask448)
|
||||
hiBig.Rsh(t, 448)
|
||||
t.Mul(&hiBig, two224plus1)
|
||||
t.Add(t, &loBig)
|
||||
}
|
||||
conv.BigInt2BytesLe(want[:], t)
|
||||
|
||||
if got != want {
|
||||
fmt.Printf("in: %v\n", conv.BytesLe2BigInt(data[:2*Size]))
|
||||
fmt.Printf("got: %v\n", got)
|
||||
fmt.Printf("want: %v\n", want)
|
||||
panic("error found")
|
||||
}
|
||||
return 1
|
||||
}
|
||||
122
vendor/github.com/cloudflare/circl/math/mlsbset/mlsbset.go
generated
vendored
Normal file
122
vendor/github.com/cloudflare/circl/math/mlsbset/mlsbset.go
generated
vendored
Normal file
@ -0,0 +1,122 @@
|
||||
// Package mlsbset provides a constant-time exponentiation method with precomputation.
|
||||
//
|
||||
// References: "Efficient and secure algorithms for GLV-based scalar
|
||||
// multiplication and their implementation on GLV–GLS curves" by (Faz-Hernandez et al.)
|
||||
// - https://doi.org/10.1007/s13389-014-0085-7
|
||||
// - https://eprint.iacr.org/2013/158
|
||||
package mlsbset
|
||||
|
||||
import (
|
||||
"errors"
|
||||
"fmt"
|
||||
"math/big"
|
||||
|
||||
"github.com/cloudflare/circl/internal/conv"
|
||||
)
|
||||
|
||||
// EltG is a group element.
|
||||
type EltG interface{}
|
||||
|
||||
// EltP is a precomputed group element.
|
||||
type EltP interface{}
|
||||
|
||||
// Group defines the operations required by MLSBSet exponentiation method.
|
||||
type Group interface {
|
||||
Identity() EltG // Returns the identity of the group.
|
||||
Sqr(x EltG) // Calculates x = x^2.
|
||||
Mul(x EltG, y EltP) // Calculates x = x*y.
|
||||
NewEltP() EltP // Returns an arbitrary precomputed element.
|
||||
ExtendedEltP() EltP // Returns the precomputed element x^(2^(w*d)).
|
||||
Lookup(a EltP, v uint, s, u int32) // Sets a = s*T[v][u].
|
||||
}
|
||||
|
||||
// Params contains the parameters of the encoding.
|
||||
type Params struct {
|
||||
T uint // T is the maximum size (in bits) of exponents.
|
||||
V uint // V is the number of tables.
|
||||
W uint // W is the window size.
|
||||
E uint // E is the number of digits per table.
|
||||
D uint // D is the number of digits in total.
|
||||
L uint // L is the length of the code.
|
||||
}
|
||||
|
||||
// Encoder allows to convert integers into valid powers.
|
||||
type Encoder struct{ p Params }
|
||||
|
||||
// New produces an encoder of the MLSBSet algorithm.
|
||||
func New(t, v, w uint) (Encoder, error) {
|
||||
if !(t > 1 && v >= 1 && w >= 2) {
|
||||
return Encoder{}, errors.New("t>1, v>=1, w>=2")
|
||||
}
|
||||
e := (t + w*v - 1) / (w * v)
|
||||
d := e * v
|
||||
l := d * w
|
||||
return Encoder{Params{t, v, w, e, d, l}}, nil
|
||||
}
|
||||
|
||||
// Encode converts an odd integer k into a valid power for exponentiation.
|
||||
func (m Encoder) Encode(k []byte) (*Power, error) {
|
||||
if len(k) == 0 {
|
||||
return nil, errors.New("empty slice")
|
||||
}
|
||||
if !(len(k) <= int(m.p.L+7)>>3) {
|
||||
return nil, errors.New("k too big")
|
||||
}
|
||||
if k[0]%2 == 0 {
|
||||
return nil, errors.New("k must be odd")
|
||||
}
|
||||
ap := int((m.p.L+7)/8) - len(k)
|
||||
k = append(k, make([]byte, ap)...)
|
||||
s := m.signs(k)
|
||||
b := make([]int32, m.p.L-m.p.D)
|
||||
c := conv.BytesLe2BigInt(k)
|
||||
c.Rsh(c, m.p.D)
|
||||
var bi big.Int
|
||||
for i := m.p.D; i < m.p.L; i++ {
|
||||
c0 := int32(c.Bit(0))
|
||||
b[i-m.p.D] = s[i%m.p.D] * c0
|
||||
bi.SetInt64(int64(b[i-m.p.D] >> 1))
|
||||
c.Rsh(c, 1)
|
||||
c.Sub(c, &bi)
|
||||
}
|
||||
carry := int(c.Int64())
|
||||
return &Power{m, s, b, carry}, nil
|
||||
}
|
||||
|
||||
// signs calculates the set of signs.
|
||||
func (m Encoder) signs(k []byte) []int32 {
|
||||
s := make([]int32, m.p.D)
|
||||
s[m.p.D-1] = 1
|
||||
for i := uint(1); i < m.p.D; i++ {
|
||||
ki := int32((k[i>>3] >> (i & 0x7)) & 0x1)
|
||||
s[i-1] = 2*ki - 1
|
||||
}
|
||||
return s
|
||||
}
|
||||
|
||||
// GetParams returns the complementary parameters of the encoding.
|
||||
func (m Encoder) GetParams() Params { return m.p }
|
||||
|
||||
// tableSize returns the size of each table.
|
||||
func (m Encoder) tableSize() uint { return 1 << (m.p.W - 1) }
|
||||
|
||||
// Elts returns the total number of elements that must be precomputed.
|
||||
func (m Encoder) Elts() uint { return m.p.V * m.tableSize() }
|
||||
|
||||
// IsExtended returns true if the element x^(2^(wd)) must be calculated.
|
||||
func (m Encoder) IsExtended() bool { q := m.p.T / (m.p.V * m.p.W); return m.p.T == q*m.p.V*m.p.W }
|
||||
|
||||
// Ops returns the number of squares and multiplications executed during an exponentiation.
|
||||
func (m Encoder) Ops() (S uint, M uint) {
|
||||
S = m.p.E
|
||||
M = m.p.E * m.p.V
|
||||
if m.IsExtended() {
|
||||
M++
|
||||
}
|
||||
return
|
||||
}
|
||||
|
||||
func (m Encoder) String() string {
|
||||
return fmt.Sprintf("T: %v W: %v V: %v e: %v d: %v l: %v wv|t: %v",
|
||||
m.p.T, m.p.W, m.p.V, m.p.E, m.p.D, m.p.L, m.IsExtended())
|
||||
}
|
||||
64
vendor/github.com/cloudflare/circl/math/mlsbset/power.go
generated
vendored
Normal file
64
vendor/github.com/cloudflare/circl/math/mlsbset/power.go
generated
vendored
Normal file
@ -0,0 +1,64 @@
|
||||
package mlsbset
|
||||
|
||||
import "fmt"
|
||||
|
||||
// Power is a valid exponent produced by the MLSBSet encoding algorithm.
|
||||
type Power struct {
|
||||
set Encoder // parameters of code.
|
||||
s []int32 // set of signs.
|
||||
b []int32 // set of digits.
|
||||
c int // carry is {0,1}.
|
||||
}
|
||||
|
||||
// Exp is calculates x^k, where x is a predetermined element of a group G.
|
||||
func (p *Power) Exp(G Group) EltG {
|
||||
a, b := G.Identity(), G.NewEltP()
|
||||
for e := int(p.set.p.E - 1); e >= 0; e-- {
|
||||
G.Sqr(a)
|
||||
for v := uint(0); v < p.set.p.V; v++ {
|
||||
sgnElt, idElt := p.Digit(v, uint(e))
|
||||
G.Lookup(b, v, sgnElt, idElt)
|
||||
G.Mul(a, b)
|
||||
}
|
||||
}
|
||||
if p.set.IsExtended() && p.c == 1 {
|
||||
G.Mul(a, G.ExtendedEltP())
|
||||
}
|
||||
return a
|
||||
}
|
||||
|
||||
// Digit returns the (v,e)-th digit and its sign.
|
||||
func (p *Power) Digit(v, e uint) (sgn, dig int32) {
|
||||
sgn = p.bit(0, v, e)
|
||||
dig = 0
|
||||
for i := p.set.p.W - 1; i > 0; i-- {
|
||||
dig = 2*dig + p.bit(i, v, e)
|
||||
}
|
||||
mask := dig >> 31
|
||||
dig = (dig + mask) ^ mask
|
||||
return sgn, dig
|
||||
}
|
||||
|
||||
// bit returns the (w,v,e)-th bit of the code.
|
||||
func (p *Power) bit(w, v, e uint) int32 {
|
||||
if !(w < p.set.p.W &&
|
||||
v < p.set.p.V &&
|
||||
e < p.set.p.E) {
|
||||
panic(fmt.Errorf("indexes outside (%v,%v,%v)", w, v, e))
|
||||
}
|
||||
if w == 0 {
|
||||
return p.s[p.set.p.E*v+e]
|
||||
}
|
||||
return p.b[p.set.p.D*(w-1)+p.set.p.E*v+e]
|
||||
}
|
||||
|
||||
func (p *Power) String() string {
|
||||
dig := ""
|
||||
for j := uint(0); j < p.set.p.V; j++ {
|
||||
for i := uint(0); i < p.set.p.E; i++ {
|
||||
s, d := p.Digit(j, i)
|
||||
dig += fmt.Sprintf("(%2v,%2v) = %+2v %+2v\n", j, i, s, d)
|
||||
}
|
||||
}
|
||||
return fmt.Sprintf("len: %v\ncarry: %v\ndigits:\n%v", len(p.b)+len(p.s), p.c, dig)
|
||||
}
|
||||
84
vendor/github.com/cloudflare/circl/math/wnaf.go
generated
vendored
Normal file
84
vendor/github.com/cloudflare/circl/math/wnaf.go
generated
vendored
Normal file
@ -0,0 +1,84 @@
|
||||
// Package math provides some utility functions for big integers.
|
||||
package math
|
||||
|
||||
import "math/big"
|
||||
|
||||
// SignedDigit obtains the signed-digit recoding of n and returns a list L of
|
||||
// digits such that n = sum( L[i]*2^(i*(w-1)) ), and each L[i] is an odd number
|
||||
// in the set {±1, ±3, ..., ±2^(w-1)-1}. The third parameter ensures that the
|
||||
// output has ceil(l/(w-1)) digits.
|
||||
//
|
||||
// Restrictions:
|
||||
// - n is odd and n > 0.
|
||||
// - 1 < w < 32.
|
||||
// - l >= bit length of n.
|
||||
//
|
||||
// References:
|
||||
// - Alg.6 in "Exponent Recoding and Regular Exponentiation Algorithms"
|
||||
// by Joye-Tunstall. http://doi.org/10.1007/978-3-642-02384-2_21
|
||||
// - Alg.6 in "Selecting Elliptic Curves for Cryptography: An Efficiency and
|
||||
// Security Analysis" by Bos et al. http://doi.org/10.1007/s13389-015-0097-y
|
||||
func SignedDigit(n *big.Int, w, l uint) []int32 {
|
||||
if n.Sign() <= 0 || n.Bit(0) == 0 {
|
||||
panic("n must be non-zero, odd, and positive")
|
||||
}
|
||||
if w <= 1 || w >= 32 {
|
||||
panic("Verify that 1 < w < 32")
|
||||
}
|
||||
if uint(n.BitLen()) > l {
|
||||
panic("n is too big to fit in l digits")
|
||||
}
|
||||
lenN := (l + (w - 1) - 1) / (w - 1) // ceil(l/(w-1))
|
||||
L := make([]int32, lenN+1)
|
||||
var k, v big.Int
|
||||
k.Set(n)
|
||||
|
||||
var i uint
|
||||
for i = 0; i < lenN; i++ {
|
||||
words := k.Bits()
|
||||
value := int32(words[0] & ((1 << w) - 1))
|
||||
value -= int32(1) << (w - 1)
|
||||
L[i] = value
|
||||
v.SetInt64(int64(value))
|
||||
k.Sub(&k, &v)
|
||||
k.Rsh(&k, w-1)
|
||||
}
|
||||
L[i] = int32(k.Int64())
|
||||
return L
|
||||
}
|
||||
|
||||
// OmegaNAF obtains the window-w Non-Adjacent Form of a positive number n and
|
||||
// 1 < w < 32. The returned slice L holds n = sum( L[i]*2^i ).
|
||||
//
|
||||
// Reference:
|
||||
// - Alg.9 "Efficient arithmetic on Koblitz curves" by Solinas.
|
||||
// http://doi.org/10.1023/A:1008306223194
|
||||
func OmegaNAF(n *big.Int, w uint) (L []int32) {
|
||||
if n.Sign() < 0 {
|
||||
panic("n must be positive")
|
||||
}
|
||||
if w <= 1 || w >= 32 {
|
||||
panic("Verify that 1 < w < 32")
|
||||
}
|
||||
|
||||
L = make([]int32, n.BitLen()+1)
|
||||
var k, v big.Int
|
||||
k.Set(n)
|
||||
|
||||
i := 0
|
||||
for ; k.Sign() > 0; i++ {
|
||||
value := int32(0)
|
||||
if k.Bit(0) == 1 {
|
||||
words := k.Bits()
|
||||
value = int32(words[0] & ((1 << w) - 1))
|
||||
if value >= (int32(1) << (w - 1)) {
|
||||
value -= int32(1) << w
|
||||
}
|
||||
v.SetInt64(int64(value))
|
||||
k.Sub(&k, &v)
|
||||
}
|
||||
L[i] = value
|
||||
k.Rsh(&k, 1)
|
||||
}
|
||||
return L[:i]
|
||||
}
|
||||
453
vendor/github.com/cloudflare/circl/sign/ed25519/ed25519.go
generated
vendored
Normal file
453
vendor/github.com/cloudflare/circl/sign/ed25519/ed25519.go
generated
vendored
Normal file
@ -0,0 +1,453 @@
|
||||
// Package ed25519 implements Ed25519 signature scheme as described in RFC-8032.
|
||||
//
|
||||
// This package provides optimized implementations of the three signature
|
||||
// variants and maintaining closer compatiblilty with crypto/ed25519.
|
||||
//
|
||||
// | Scheme Name | Sign Function | Verification | Context |
|
||||
// |-------------|-------------------|---------------|-------------------|
|
||||
// | Ed25519 | Sign | Verify | None |
|
||||
// | Ed25519Ph | SignPh | VerifyPh | Yes, can be empty |
|
||||
// | Ed25519Ctx | SignWithCtx | VerifyWithCtx | Yes, non-empty |
|
||||
// | All above | (PrivateKey).Sign | VerifyAny | As above |
|
||||
//
|
||||
// Specific functions for sign and verify are defined. A generic signing
|
||||
// function for all schemes is available through the crypto.Signer interface,
|
||||
// which is implemented by the PrivateKey type. A correspond all-in-one
|
||||
// verification method is provided by the VerifyAny function.
|
||||
//
|
||||
// Signing with Ed25519Ph or Ed25519Ctx requires a context string for domain
|
||||
// separation. This parameter is passed using a SignerOptions struct defined
|
||||
// in this package. While Ed25519Ph accepts an empty context, Ed25519Ctx
|
||||
// enforces non-empty context strings.
|
||||
//
|
||||
// # Compatibility with crypto.ed25519
|
||||
//
|
||||
// These functions are compatible with the “Ed25519” function defined in
|
||||
// RFC-8032. However, unlike RFC 8032's formulation, this package's private
|
||||
// key representation includes a public key suffix to make multiple signing
|
||||
// operations with the same key more efficient. This package refers to the
|
||||
// RFC-8032 private key as the “seed”.
|
||||
//
|
||||
// References
|
||||
//
|
||||
// - RFC-8032: https://rfc-editor.org/rfc/rfc8032.txt
|
||||
// - Ed25519: https://ed25519.cr.yp.to/
|
||||
// - EdDSA: High-speed high-security signatures. https://doi.org/10.1007/s13389-012-0027-1
|
||||
package ed25519
|
||||
|
||||
import (
|
||||
"bytes"
|
||||
"crypto"
|
||||
cryptoRand "crypto/rand"
|
||||
"crypto/sha512"
|
||||
"crypto/subtle"
|
||||
"errors"
|
||||
"fmt"
|
||||
"io"
|
||||
"strconv"
|
||||
|
||||
"github.com/cloudflare/circl/sign"
|
||||
)
|
||||
|
||||
const (
|
||||
// ContextMaxSize is the maximum length (in bytes) allowed for context.
|
||||
ContextMaxSize = 255
|
||||
// PublicKeySize is the size, in bytes, of public keys as used in this package.
|
||||
PublicKeySize = 32
|
||||
// PrivateKeySize is the size, in bytes, of private keys as used in this package.
|
||||
PrivateKeySize = 64
|
||||
// SignatureSize is the size, in bytes, of signatures generated and verified by this package.
|
||||
SignatureSize = 64
|
||||
// SeedSize is the size, in bytes, of private key seeds. These are the private key representations used by RFC 8032.
|
||||
SeedSize = 32
|
||||
)
|
||||
|
||||
const (
|
||||
paramB = 256 / 8 // Size of keys in bytes.
|
||||
)
|
||||
|
||||
// SignerOptions implements crypto.SignerOpts and augments with parameters
|
||||
// that are specific to the Ed25519 signature schemes.
|
||||
type SignerOptions struct {
|
||||
// Hash must be crypto.Hash(0) for Ed25519/Ed25519ctx, or crypto.SHA512
|
||||
// for Ed25519ph.
|
||||
crypto.Hash
|
||||
|
||||
// Context is an optional domain separation string for Ed25519ph and a
|
||||
// must for Ed25519ctx. Its length must be less or equal than 255 bytes.
|
||||
Context string
|
||||
|
||||
// Scheme is an identifier for choosing a signature scheme. The zero value
|
||||
// is ED25519.
|
||||
Scheme SchemeID
|
||||
}
|
||||
|
||||
// SchemeID is an identifier for each signature scheme.
|
||||
type SchemeID uint
|
||||
|
||||
const (
|
||||
ED25519 SchemeID = iota
|
||||
ED25519Ph
|
||||
ED25519Ctx
|
||||
)
|
||||
|
||||
// PrivateKey is the type of Ed25519 private keys. It implements crypto.Signer.
|
||||
type PrivateKey []byte
|
||||
|
||||
// Equal reports whether priv and x have the same value.
|
||||
func (priv PrivateKey) Equal(x crypto.PrivateKey) bool {
|
||||
xx, ok := x.(PrivateKey)
|
||||
return ok && subtle.ConstantTimeCompare(priv, xx) == 1
|
||||
}
|
||||
|
||||
// Public returns the PublicKey corresponding to priv.
|
||||
func (priv PrivateKey) Public() crypto.PublicKey {
|
||||
publicKey := make(PublicKey, PublicKeySize)
|
||||
copy(publicKey, priv[SeedSize:])
|
||||
return publicKey
|
||||
}
|
||||
|
||||
// Seed returns the private key seed corresponding to priv. It is provided for
|
||||
// interoperability with RFC 8032. RFC 8032's private keys correspond to seeds
|
||||
// in this package.
|
||||
func (priv PrivateKey) Seed() []byte {
|
||||
seed := make([]byte, SeedSize)
|
||||
copy(seed, priv[:SeedSize])
|
||||
return seed
|
||||
}
|
||||
|
||||
func (priv PrivateKey) Scheme() sign.Scheme { return sch }
|
||||
|
||||
func (pub PublicKey) Scheme() sign.Scheme { return sch }
|
||||
|
||||
func (priv PrivateKey) MarshalBinary() (data []byte, err error) {
|
||||
privateKey := make(PrivateKey, PrivateKeySize)
|
||||
copy(privateKey, priv)
|
||||
return privateKey, nil
|
||||
}
|
||||
|
||||
func (pub PublicKey) MarshalBinary() (data []byte, err error) {
|
||||
publicKey := make(PublicKey, PublicKeySize)
|
||||
copy(publicKey, pub)
|
||||
return publicKey, nil
|
||||
}
|
||||
|
||||
// Equal reports whether pub and x have the same value.
|
||||
func (pub PublicKey) Equal(x crypto.PublicKey) bool {
|
||||
xx, ok := x.(PublicKey)
|
||||
return ok && bytes.Equal(pub, xx)
|
||||
}
|
||||
|
||||
// Sign creates a signature of a message with priv key.
|
||||
// This function is compatible with crypto.ed25519 and also supports the
|
||||
// three signature variants defined in RFC-8032, namely Ed25519 (or pure
|
||||
// EdDSA), Ed25519Ph, and Ed25519Ctx.
|
||||
// The opts.HashFunc() must return zero to specify either Ed25519 or Ed25519Ctx
|
||||
// variant. This can be achieved by passing crypto.Hash(0) as the value for
|
||||
// opts.
|
||||
// The opts.HashFunc() must return SHA512 to specify the Ed25519Ph variant.
|
||||
// This can be achieved by passing crypto.SHA512 as the value for opts.
|
||||
// Use a SignerOptions struct (defined in this package) to pass a context
|
||||
// string for signing.
|
||||
func (priv PrivateKey) Sign(
|
||||
rand io.Reader,
|
||||
message []byte,
|
||||
opts crypto.SignerOpts,
|
||||
) (signature []byte, err error) {
|
||||
var ctx string
|
||||
var scheme SchemeID
|
||||
if o, ok := opts.(SignerOptions); ok {
|
||||
ctx = o.Context
|
||||
scheme = o.Scheme
|
||||
}
|
||||
|
||||
switch true {
|
||||
case scheme == ED25519 && opts.HashFunc() == crypto.Hash(0):
|
||||
return Sign(priv, message), nil
|
||||
case scheme == ED25519Ph && opts.HashFunc() == crypto.SHA512:
|
||||
return SignPh(priv, message, ctx), nil
|
||||
case scheme == ED25519Ctx && opts.HashFunc() == crypto.Hash(0) && len(ctx) > 0:
|
||||
return SignWithCtx(priv, message, ctx), nil
|
||||
default:
|
||||
return nil, errors.New("ed25519: bad hash algorithm")
|
||||
}
|
||||
}
|
||||
|
||||
// GenerateKey generates a public/private key pair using entropy from rand.
|
||||
// If rand is nil, crypto/rand.Reader will be used.
|
||||
func GenerateKey(rand io.Reader) (PublicKey, PrivateKey, error) {
|
||||
if rand == nil {
|
||||
rand = cryptoRand.Reader
|
||||
}
|
||||
|
||||
seed := make([]byte, SeedSize)
|
||||
if _, err := io.ReadFull(rand, seed); err != nil {
|
||||
return nil, nil, err
|
||||
}
|
||||
|
||||
privateKey := NewKeyFromSeed(seed)
|
||||
publicKey := make(PublicKey, PublicKeySize)
|
||||
copy(publicKey, privateKey[SeedSize:])
|
||||
|
||||
return publicKey, privateKey, nil
|
||||
}
|
||||
|
||||
// NewKeyFromSeed calculates a private key from a seed. It will panic if
|
||||
// len(seed) is not SeedSize. This function is provided for interoperability
|
||||
// with RFC 8032. RFC 8032's private keys correspond to seeds in this
|
||||
// package.
|
||||
func NewKeyFromSeed(seed []byte) PrivateKey {
|
||||
privateKey := make(PrivateKey, PrivateKeySize)
|
||||
newKeyFromSeed(privateKey, seed)
|
||||
return privateKey
|
||||
}
|
||||
|
||||
func newKeyFromSeed(privateKey, seed []byte) {
|
||||
if l := len(seed); l != SeedSize {
|
||||
panic("ed25519: bad seed length: " + strconv.Itoa(l))
|
||||
}
|
||||
var P pointR1
|
||||
k := sha512.Sum512(seed)
|
||||
clamp(k[:])
|
||||
reduceModOrder(k[:paramB], false)
|
||||
P.fixedMult(k[:paramB])
|
||||
copy(privateKey[:SeedSize], seed)
|
||||
_ = P.ToBytes(privateKey[SeedSize:])
|
||||
}
|
||||
|
||||
func signAll(signature []byte, privateKey PrivateKey, message, ctx []byte, preHash bool) {
|
||||
if l := len(privateKey); l != PrivateKeySize {
|
||||
panic("ed25519: bad private key length: " + strconv.Itoa(l))
|
||||
}
|
||||
|
||||
H := sha512.New()
|
||||
var PHM []byte
|
||||
|
||||
if preHash {
|
||||
_, _ = H.Write(message)
|
||||
PHM = H.Sum(nil)
|
||||
H.Reset()
|
||||
} else {
|
||||
PHM = message
|
||||
}
|
||||
|
||||
// 1. Hash the 32-byte private key using SHA-512.
|
||||
_, _ = H.Write(privateKey[:SeedSize])
|
||||
h := H.Sum(nil)
|
||||
clamp(h[:])
|
||||
prefix, s := h[paramB:], h[:paramB]
|
||||
|
||||
// 2. Compute SHA-512(dom2(F, C) || prefix || PH(M))
|
||||
H.Reset()
|
||||
|
||||
writeDom(H, ctx, preHash)
|
||||
|
||||
_, _ = H.Write(prefix)
|
||||
_, _ = H.Write(PHM)
|
||||
r := H.Sum(nil)
|
||||
reduceModOrder(r[:], true)
|
||||
|
||||
// 3. Compute the point [r]B.
|
||||
var P pointR1
|
||||
P.fixedMult(r[:paramB])
|
||||
R := (&[paramB]byte{})[:]
|
||||
if err := P.ToBytes(R); err != nil {
|
||||
panic(err)
|
||||
}
|
||||
|
||||
// 4. Compute SHA512(dom2(F, C) || R || A || PH(M)).
|
||||
H.Reset()
|
||||
|
||||
writeDom(H, ctx, preHash)
|
||||
|
||||
_, _ = H.Write(R)
|
||||
_, _ = H.Write(privateKey[SeedSize:])
|
||||
_, _ = H.Write(PHM)
|
||||
hRAM := H.Sum(nil)
|
||||
|
||||
reduceModOrder(hRAM[:], true)
|
||||
|
||||
// 5. Compute S = (r + k * s) mod order.
|
||||
S := (&[paramB]byte{})[:]
|
||||
calculateS(S, r[:paramB], hRAM[:paramB], s)
|
||||
|
||||
// 6. The signature is the concatenation of R and S.
|
||||
copy(signature[:paramB], R[:])
|
||||
copy(signature[paramB:], S[:])
|
||||
}
|
||||
|
||||
// Sign signs the message with privateKey and returns a signature.
|
||||
// This function supports the signature variant defined in RFC-8032: Ed25519,
|
||||
// also known as the pure version of EdDSA.
|
||||
// It will panic if len(privateKey) is not PrivateKeySize.
|
||||
func Sign(privateKey PrivateKey, message []byte) []byte {
|
||||
signature := make([]byte, SignatureSize)
|
||||
signAll(signature, privateKey, message, []byte(""), false)
|
||||
return signature
|
||||
}
|
||||
|
||||
// SignPh creates a signature of a message with private key and context.
|
||||
// This function supports the signature variant defined in RFC-8032: Ed25519ph,
|
||||
// meaning it internally hashes the message using SHA-512, and optionally
|
||||
// accepts a context string.
|
||||
// It will panic if len(privateKey) is not PrivateKeySize.
|
||||
// Context could be passed to this function, which length should be no more than
|
||||
// ContextMaxSize=255. It can be empty.
|
||||
func SignPh(privateKey PrivateKey, message []byte, ctx string) []byte {
|
||||
if len(ctx) > ContextMaxSize {
|
||||
panic(fmt.Errorf("ed25519: bad context length: %v", len(ctx)))
|
||||
}
|
||||
|
||||
signature := make([]byte, SignatureSize)
|
||||
signAll(signature, privateKey, message, []byte(ctx), true)
|
||||
return signature
|
||||
}
|
||||
|
||||
// SignWithCtx creates a signature of a message with private key and context.
|
||||
// This function supports the signature variant defined in RFC-8032: Ed25519ctx,
|
||||
// meaning it accepts a non-empty context string.
|
||||
// It will panic if len(privateKey) is not PrivateKeySize.
|
||||
// Context must be passed to this function, which length should be no more than
|
||||
// ContextMaxSize=255 and cannot be empty.
|
||||
func SignWithCtx(privateKey PrivateKey, message []byte, ctx string) []byte {
|
||||
if len(ctx) == 0 || len(ctx) > ContextMaxSize {
|
||||
panic(fmt.Errorf("ed25519: bad context length: %v > %v", len(ctx), ContextMaxSize))
|
||||
}
|
||||
|
||||
signature := make([]byte, SignatureSize)
|
||||
signAll(signature, privateKey, message, []byte(ctx), false)
|
||||
return signature
|
||||
}
|
||||
|
||||
func verify(public PublicKey, message, signature, ctx []byte, preHash bool) bool {
|
||||
if len(public) != PublicKeySize ||
|
||||
len(signature) != SignatureSize ||
|
||||
!isLessThanOrder(signature[paramB:]) {
|
||||
return false
|
||||
}
|
||||
|
||||
var P pointR1
|
||||
if ok := P.FromBytes(public); !ok {
|
||||
return false
|
||||
}
|
||||
|
||||
H := sha512.New()
|
||||
var PHM []byte
|
||||
|
||||
if preHash {
|
||||
_, _ = H.Write(message)
|
||||
PHM = H.Sum(nil)
|
||||
H.Reset()
|
||||
} else {
|
||||
PHM = message
|
||||
}
|
||||
|
||||
R := signature[:paramB]
|
||||
|
||||
writeDom(H, ctx, preHash)
|
||||
|
||||
_, _ = H.Write(R)
|
||||
_, _ = H.Write(public)
|
||||
_, _ = H.Write(PHM)
|
||||
hRAM := H.Sum(nil)
|
||||
reduceModOrder(hRAM[:], true)
|
||||
|
||||
var Q pointR1
|
||||
encR := (&[paramB]byte{})[:]
|
||||
P.neg()
|
||||
Q.doubleMult(&P, signature[paramB:], hRAM[:paramB])
|
||||
_ = Q.ToBytes(encR)
|
||||
return bytes.Equal(R, encR)
|
||||
}
|
||||
|
||||
// VerifyAny returns true if the signature is valid. Failure cases are invalid
|
||||
// signature, or when the public key cannot be decoded.
|
||||
// This function supports all the three signature variants defined in RFC-8032,
|
||||
// namely Ed25519 (or pure EdDSA), Ed25519Ph, and Ed25519Ctx.
|
||||
// The opts.HashFunc() must return zero to specify either Ed25519 or Ed25519Ctx
|
||||
// variant. This can be achieved by passing crypto.Hash(0) as the value for opts.
|
||||
// The opts.HashFunc() must return SHA512 to specify the Ed25519Ph variant.
|
||||
// This can be achieved by passing crypto.SHA512 as the value for opts.
|
||||
// Use a SignerOptions struct to pass a context string for signing.
|
||||
func VerifyAny(public PublicKey, message, signature []byte, opts crypto.SignerOpts) bool {
|
||||
var ctx string
|
||||
var scheme SchemeID
|
||||
if o, ok := opts.(SignerOptions); ok {
|
||||
ctx = o.Context
|
||||
scheme = o.Scheme
|
||||
}
|
||||
|
||||
switch true {
|
||||
case scheme == ED25519 && opts.HashFunc() == crypto.Hash(0):
|
||||
return Verify(public, message, signature)
|
||||
case scheme == ED25519Ph && opts.HashFunc() == crypto.SHA512:
|
||||
return VerifyPh(public, message, signature, ctx)
|
||||
case scheme == ED25519Ctx && opts.HashFunc() == crypto.Hash(0) && len(ctx) > 0:
|
||||
return VerifyWithCtx(public, message, signature, ctx)
|
||||
default:
|
||||
return false
|
||||
}
|
||||
}
|
||||
|
||||
// Verify returns true if the signature is valid. Failure cases are invalid
|
||||
// signature, or when the public key cannot be decoded.
|
||||
// This function supports the signature variant defined in RFC-8032: Ed25519,
|
||||
// also known as the pure version of EdDSA.
|
||||
func Verify(public PublicKey, message, signature []byte) bool {
|
||||
return verify(public, message, signature, []byte(""), false)
|
||||
}
|
||||
|
||||
// VerifyPh returns true if the signature is valid. Failure cases are invalid
|
||||
// signature, or when the public key cannot be decoded.
|
||||
// This function supports the signature variant defined in RFC-8032: Ed25519ph,
|
||||
// meaning it internally hashes the message using SHA-512.
|
||||
// Context could be passed to this function, which length should be no more than
|
||||
// 255. It can be empty.
|
||||
func VerifyPh(public PublicKey, message, signature []byte, ctx string) bool {
|
||||
return verify(public, message, signature, []byte(ctx), true)
|
||||
}
|
||||
|
||||
// VerifyWithCtx returns true if the signature is valid. Failure cases are invalid
|
||||
// signature, or when the public key cannot be decoded, or when context is
|
||||
// not provided.
|
||||
// This function supports the signature variant defined in RFC-8032: Ed25519ctx,
|
||||
// meaning it does not handle prehashed messages. Non-empty context string must be
|
||||
// provided, and must not be more than 255 of length.
|
||||
func VerifyWithCtx(public PublicKey, message, signature []byte, ctx string) bool {
|
||||
if len(ctx) == 0 || len(ctx) > ContextMaxSize {
|
||||
return false
|
||||
}
|
||||
|
||||
return verify(public, message, signature, []byte(ctx), false)
|
||||
}
|
||||
|
||||
func clamp(k []byte) {
|
||||
k[0] &= 248
|
||||
k[paramB-1] = (k[paramB-1] & 127) | 64
|
||||
}
|
||||
|
||||
// isLessThanOrder returns true if 0 <= x < order.
|
||||
func isLessThanOrder(x []byte) bool {
|
||||
i := len(order) - 1
|
||||
for i > 0 && x[i] == order[i] {
|
||||
i--
|
||||
}
|
||||
return x[i] < order[i]
|
||||
}
|
||||
|
||||
func writeDom(h io.Writer, ctx []byte, preHash bool) {
|
||||
dom2 := "SigEd25519 no Ed25519 collisions"
|
||||
|
||||
if len(ctx) > 0 {
|
||||
_, _ = h.Write([]byte(dom2))
|
||||
if preHash {
|
||||
_, _ = h.Write([]byte{byte(0x01), byte(len(ctx))})
|
||||
} else {
|
||||
_, _ = h.Write([]byte{byte(0x00), byte(len(ctx))})
|
||||
}
|
||||
_, _ = h.Write(ctx)
|
||||
} else if preHash {
|
||||
_, _ = h.Write([]byte(dom2))
|
||||
_, _ = h.Write([]byte{0x01, 0x00})
|
||||
}
|
||||
}
|
||||
175
vendor/github.com/cloudflare/circl/sign/ed25519/modular.go
generated
vendored
Normal file
175
vendor/github.com/cloudflare/circl/sign/ed25519/modular.go
generated
vendored
Normal file
@ -0,0 +1,175 @@
|
||||
package ed25519
|
||||
|
||||
import (
|
||||
"encoding/binary"
|
||||
"math/bits"
|
||||
)
|
||||
|
||||
var order = [paramB]byte{
|
||||
0xed, 0xd3, 0xf5, 0x5c, 0x1a, 0x63, 0x12, 0x58,
|
||||
0xd6, 0x9c, 0xf7, 0xa2, 0xde, 0xf9, 0xde, 0x14,
|
||||
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
|
||||
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x10,
|
||||
}
|
||||
|
||||
// isLessThan returns true if 0 <= x < y, and assumes that slices have the same length.
|
||||
func isLessThan(x, y []byte) bool {
|
||||
i := len(x) - 1
|
||||
for i > 0 && x[i] == y[i] {
|
||||
i--
|
||||
}
|
||||
return x[i] < y[i]
|
||||
}
|
||||
|
||||
// reduceModOrder calculates k = k mod order of the curve.
|
||||
func reduceModOrder(k []byte, is512Bit bool) {
|
||||
var X [((2 * paramB) * 8) / 64]uint64
|
||||
numWords := len(k) >> 3
|
||||
for i := 0; i < numWords; i++ {
|
||||
X[i] = binary.LittleEndian.Uint64(k[i*8 : (i+1)*8])
|
||||
}
|
||||
red512(&X, is512Bit)
|
||||
for i := 0; i < numWords; i++ {
|
||||
binary.LittleEndian.PutUint64(k[i*8:(i+1)*8], X[i])
|
||||
}
|
||||
}
|
||||
|
||||
// red512 calculates x = x mod Order of the curve.
|
||||
func red512(x *[8]uint64, full bool) {
|
||||
// Implementation of Algs.(14.47)+(14.52) of Handbook of Applied
|
||||
// Cryptography, by A. Menezes, P. van Oorschot, and S. Vanstone.
|
||||
const (
|
||||
ell0 = uint64(0x5812631a5cf5d3ed)
|
||||
ell1 = uint64(0x14def9dea2f79cd6)
|
||||
ell160 = uint64(0x812631a5cf5d3ed0)
|
||||
ell161 = uint64(0x4def9dea2f79cd65)
|
||||
ell162 = uint64(0x0000000000000001)
|
||||
)
|
||||
|
||||
var c0, c1, c2, c3 uint64
|
||||
r0, r1, r2, r3, r4 := x[0], x[1], x[2], x[3], uint64(0)
|
||||
|
||||
if full {
|
||||
q0, q1, q2, q3 := x[4], x[5], x[6], x[7]
|
||||
|
||||
for i := 0; i < 3; i++ {
|
||||
h0, s0 := bits.Mul64(q0, ell160)
|
||||
h1, s1 := bits.Mul64(q1, ell160)
|
||||
h2, s2 := bits.Mul64(q2, ell160)
|
||||
h3, s3 := bits.Mul64(q3, ell160)
|
||||
|
||||
s1, c0 = bits.Add64(h0, s1, 0)
|
||||
s2, c1 = bits.Add64(h1, s2, c0)
|
||||
s3, c2 = bits.Add64(h2, s3, c1)
|
||||
s4, _ := bits.Add64(h3, 0, c2)
|
||||
|
||||
h0, l0 := bits.Mul64(q0, ell161)
|
||||
h1, l1 := bits.Mul64(q1, ell161)
|
||||
h2, l2 := bits.Mul64(q2, ell161)
|
||||
h3, l3 := bits.Mul64(q3, ell161)
|
||||
|
||||
l1, c0 = bits.Add64(h0, l1, 0)
|
||||
l2, c1 = bits.Add64(h1, l2, c0)
|
||||
l3, c2 = bits.Add64(h2, l3, c1)
|
||||
l4, _ := bits.Add64(h3, 0, c2)
|
||||
|
||||
s1, c0 = bits.Add64(s1, l0, 0)
|
||||
s2, c1 = bits.Add64(s2, l1, c0)
|
||||
s3, c2 = bits.Add64(s3, l2, c1)
|
||||
s4, c3 = bits.Add64(s4, l3, c2)
|
||||
s5, s6 := bits.Add64(l4, 0, c3)
|
||||
|
||||
s2, c0 = bits.Add64(s2, q0, 0)
|
||||
s3, c1 = bits.Add64(s3, q1, c0)
|
||||
s4, c2 = bits.Add64(s4, q2, c1)
|
||||
s5, c3 = bits.Add64(s5, q3, c2)
|
||||
s6, s7 := bits.Add64(s6, 0, c3)
|
||||
|
||||
q := q0 | q1 | q2 | q3
|
||||
m := -((q | -q) >> 63) // if q=0 then m=0...0 else m=1..1
|
||||
s0 &= m
|
||||
s1 &= m
|
||||
s2 &= m
|
||||
s3 &= m
|
||||
q0, q1, q2, q3 = s4, s5, s6, s7
|
||||
|
||||
if (i+1)%2 == 0 {
|
||||
r0, c0 = bits.Add64(r0, s0, 0)
|
||||
r1, c1 = bits.Add64(r1, s1, c0)
|
||||
r2, c2 = bits.Add64(r2, s2, c1)
|
||||
r3, c3 = bits.Add64(r3, s3, c2)
|
||||
r4, _ = bits.Add64(r4, 0, c3)
|
||||
} else {
|
||||
r0, c0 = bits.Sub64(r0, s0, 0)
|
||||
r1, c1 = bits.Sub64(r1, s1, c0)
|
||||
r2, c2 = bits.Sub64(r2, s2, c1)
|
||||
r3, c3 = bits.Sub64(r3, s3, c2)
|
||||
r4, _ = bits.Sub64(r4, 0, c3)
|
||||
}
|
||||
}
|
||||
|
||||
m := -(r4 >> 63)
|
||||
r0, c0 = bits.Add64(r0, m&ell160, 0)
|
||||
r1, c1 = bits.Add64(r1, m&ell161, c0)
|
||||
r2, c2 = bits.Add64(r2, m&ell162, c1)
|
||||
r3, c3 = bits.Add64(r3, 0, c2)
|
||||
r4, _ = bits.Add64(r4, m&1, c3)
|
||||
x[4], x[5], x[6], x[7] = 0, 0, 0, 0
|
||||
}
|
||||
|
||||
q0 := (r4 << 4) | (r3 >> 60)
|
||||
r3 &= (uint64(1) << 60) - 1
|
||||
|
||||
h0, s0 := bits.Mul64(ell0, q0)
|
||||
h1, s1 := bits.Mul64(ell1, q0)
|
||||
s1, c0 = bits.Add64(h0, s1, 0)
|
||||
s2, _ := bits.Add64(h1, 0, c0)
|
||||
|
||||
r0, c0 = bits.Sub64(r0, s0, 0)
|
||||
r1, c1 = bits.Sub64(r1, s1, c0)
|
||||
r2, c2 = bits.Sub64(r2, s2, c1)
|
||||
r3, _ = bits.Sub64(r3, 0, c2)
|
||||
|
||||
x[0], x[1], x[2], x[3] = r0, r1, r2, r3
|
||||
}
|
||||
|
||||
// calculateS performs s = r+k*a mod Order of the curve.
|
||||
func calculateS(s, r, k, a []byte) {
|
||||
K := [4]uint64{
|
||||
binary.LittleEndian.Uint64(k[0*8 : 1*8]),
|
||||
binary.LittleEndian.Uint64(k[1*8 : 2*8]),
|
||||
binary.LittleEndian.Uint64(k[2*8 : 3*8]),
|
||||
binary.LittleEndian.Uint64(k[3*8 : 4*8]),
|
||||
}
|
||||
S := [8]uint64{
|
||||
binary.LittleEndian.Uint64(r[0*8 : 1*8]),
|
||||
binary.LittleEndian.Uint64(r[1*8 : 2*8]),
|
||||
binary.LittleEndian.Uint64(r[2*8 : 3*8]),
|
||||
binary.LittleEndian.Uint64(r[3*8 : 4*8]),
|
||||
}
|
||||
var c3 uint64
|
||||
for i := range K {
|
||||
ai := binary.LittleEndian.Uint64(a[i*8 : (i+1)*8])
|
||||
|
||||
h0, l0 := bits.Mul64(K[0], ai)
|
||||
h1, l1 := bits.Mul64(K[1], ai)
|
||||
h2, l2 := bits.Mul64(K[2], ai)
|
||||
h3, l3 := bits.Mul64(K[3], ai)
|
||||
|
||||
l1, c0 := bits.Add64(h0, l1, 0)
|
||||
l2, c1 := bits.Add64(h1, l2, c0)
|
||||
l3, c2 := bits.Add64(h2, l3, c1)
|
||||
l4, _ := bits.Add64(h3, 0, c2)
|
||||
|
||||
S[i+0], c0 = bits.Add64(S[i+0], l0, 0)
|
||||
S[i+1], c1 = bits.Add64(S[i+1], l1, c0)
|
||||
S[i+2], c2 = bits.Add64(S[i+2], l2, c1)
|
||||
S[i+3], c3 = bits.Add64(S[i+3], l3, c2)
|
||||
S[i+4], _ = bits.Add64(S[i+4], l4, c3)
|
||||
}
|
||||
red512(&S, true)
|
||||
binary.LittleEndian.PutUint64(s[0*8:1*8], S[0])
|
||||
binary.LittleEndian.PutUint64(s[1*8:2*8], S[1])
|
||||
binary.LittleEndian.PutUint64(s[2*8:3*8], S[2])
|
||||
binary.LittleEndian.PutUint64(s[3*8:4*8], S[3])
|
||||
}
|
||||
180
vendor/github.com/cloudflare/circl/sign/ed25519/mult.go
generated
vendored
Normal file
180
vendor/github.com/cloudflare/circl/sign/ed25519/mult.go
generated
vendored
Normal file
@ -0,0 +1,180 @@
|
||||
package ed25519
|
||||
|
||||
import (
|
||||
"crypto/subtle"
|
||||
"encoding/binary"
|
||||
"math/bits"
|
||||
|
||||
"github.com/cloudflare/circl/internal/conv"
|
||||
"github.com/cloudflare/circl/math"
|
||||
fp "github.com/cloudflare/circl/math/fp25519"
|
||||
)
|
||||
|
||||
var paramD = fp.Elt{
|
||||
0xa3, 0x78, 0x59, 0x13, 0xca, 0x4d, 0xeb, 0x75,
|
||||
0xab, 0xd8, 0x41, 0x41, 0x4d, 0x0a, 0x70, 0x00,
|
||||
0x98, 0xe8, 0x79, 0x77, 0x79, 0x40, 0xc7, 0x8c,
|
||||
0x73, 0xfe, 0x6f, 0x2b, 0xee, 0x6c, 0x03, 0x52,
|
||||
}
|
||||
|
||||
// mLSBRecoding parameters.
|
||||
const (
|
||||
fxT = 257
|
||||
fxV = 2
|
||||
fxW = 3
|
||||
fx2w1 = 1 << (uint(fxW) - 1)
|
||||
numWords64 = (paramB * 8 / 64)
|
||||
)
|
||||
|
||||
// mLSBRecoding is the odd-only modified LSB-set.
|
||||
//
|
||||
// Reference:
|
||||
//
|
||||
// "Efficient and secure algorithms for GLV-based scalar multiplication and
|
||||
// their implementation on GLV–GLS curves" by (Faz-Hernandez et al.)
|
||||
// http://doi.org/10.1007/s13389-014-0085-7.
|
||||
func mLSBRecoding(L []int8, k []byte) {
|
||||
const ee = (fxT + fxW*fxV - 1) / (fxW * fxV)
|
||||
const dd = ee * fxV
|
||||
const ll = dd * fxW
|
||||
if len(L) == (ll + 1) {
|
||||
var m [numWords64 + 1]uint64
|
||||
for i := 0; i < numWords64; i++ {
|
||||
m[i] = binary.LittleEndian.Uint64(k[8*i : 8*i+8])
|
||||
}
|
||||
condAddOrderN(&m)
|
||||
L[dd-1] = 1
|
||||
for i := 0; i < dd-1; i++ {
|
||||
kip1 := (m[(i+1)/64] >> (uint(i+1) % 64)) & 0x1
|
||||
L[i] = int8(kip1<<1) - 1
|
||||
}
|
||||
{ // right-shift by d
|
||||
right := uint(dd % 64)
|
||||
left := uint(64) - right
|
||||
lim := ((numWords64+1)*64 - dd) / 64
|
||||
j := dd / 64
|
||||
for i := 0; i < lim; i++ {
|
||||
m[i] = (m[i+j] >> right) | (m[i+j+1] << left)
|
||||
}
|
||||
m[lim] = m[lim+j] >> right
|
||||
}
|
||||
for i := dd; i < ll; i++ {
|
||||
L[i] = L[i%dd] * int8(m[0]&0x1)
|
||||
div2subY(m[:], int64(L[i]>>1), numWords64)
|
||||
}
|
||||
L[ll] = int8(m[0])
|
||||
}
|
||||
}
|
||||
|
||||
// absolute returns always a positive value.
|
||||
func absolute(x int32) int32 {
|
||||
mask := x >> 31
|
||||
return (x + mask) ^ mask
|
||||
}
|
||||
|
||||
// condAddOrderN updates x = x+order if x is even, otherwise x remains unchanged.
|
||||
func condAddOrderN(x *[numWords64 + 1]uint64) {
|
||||
isOdd := (x[0] & 0x1) - 1
|
||||
c := uint64(0)
|
||||
for i := 0; i < numWords64; i++ {
|
||||
orderWord := binary.LittleEndian.Uint64(order[8*i : 8*i+8])
|
||||
o := isOdd & orderWord
|
||||
x0, c0 := bits.Add64(x[i], o, c)
|
||||
x[i] = x0
|
||||
c = c0
|
||||
}
|
||||
x[numWords64], _ = bits.Add64(x[numWords64], 0, c)
|
||||
}
|
||||
|
||||
// div2subY update x = (x/2) - y.
|
||||
func div2subY(x []uint64, y int64, l int) {
|
||||
s := uint64(y >> 63)
|
||||
for i := 0; i < l-1; i++ {
|
||||
x[i] = (x[i] >> 1) | (x[i+1] << 63)
|
||||
}
|
||||
x[l-1] = (x[l-1] >> 1)
|
||||
|
||||
b := uint64(0)
|
||||
x0, b0 := bits.Sub64(x[0], uint64(y), b)
|
||||
x[0] = x0
|
||||
b = b0
|
||||
for i := 1; i < l-1; i++ {
|
||||
x0, b0 := bits.Sub64(x[i], s, b)
|
||||
x[i] = x0
|
||||
b = b0
|
||||
}
|
||||
x[l-1], _ = bits.Sub64(x[l-1], s, b)
|
||||
}
|
||||
|
||||
func (P *pointR1) fixedMult(scalar []byte) {
|
||||
if len(scalar) != paramB {
|
||||
panic("wrong scalar size")
|
||||
}
|
||||
const ee = (fxT + fxW*fxV - 1) / (fxW * fxV)
|
||||
const dd = ee * fxV
|
||||
const ll = dd * fxW
|
||||
|
||||
L := make([]int8, ll+1)
|
||||
mLSBRecoding(L[:], scalar)
|
||||
S := &pointR3{}
|
||||
P.SetIdentity()
|
||||
for ii := ee - 1; ii >= 0; ii-- {
|
||||
P.double()
|
||||
for j := 0; j < fxV; j++ {
|
||||
dig := L[fxW*dd-j*ee+ii-ee]
|
||||
for i := (fxW-1)*dd - j*ee + ii - ee; i >= (2*dd - j*ee + ii - ee); i = i - dd {
|
||||
dig = 2*dig + L[i]
|
||||
}
|
||||
idx := absolute(int32(dig))
|
||||
sig := L[dd-j*ee+ii-ee]
|
||||
Tabj := &tabSign[fxV-j-1]
|
||||
for k := 0; k < fx2w1; k++ {
|
||||
S.cmov(&Tabj[k], subtle.ConstantTimeEq(int32(k), idx))
|
||||
}
|
||||
S.cneg(subtle.ConstantTimeEq(int32(sig), -1))
|
||||
P.mixAdd(S)
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
const (
|
||||
omegaFix = 7
|
||||
omegaVar = 5
|
||||
)
|
||||
|
||||
// doubleMult returns P=mG+nQ.
|
||||
func (P *pointR1) doubleMult(Q *pointR1, m, n []byte) {
|
||||
nafFix := math.OmegaNAF(conv.BytesLe2BigInt(m), omegaFix)
|
||||
nafVar := math.OmegaNAF(conv.BytesLe2BigInt(n), omegaVar)
|
||||
|
||||
if len(nafFix) > len(nafVar) {
|
||||
nafVar = append(nafVar, make([]int32, len(nafFix)-len(nafVar))...)
|
||||
} else if len(nafFix) < len(nafVar) {
|
||||
nafFix = append(nafFix, make([]int32, len(nafVar)-len(nafFix))...)
|
||||
}
|
||||
|
||||
var TabQ [1 << (omegaVar - 2)]pointR2
|
||||
Q.oddMultiples(TabQ[:])
|
||||
P.SetIdentity()
|
||||
for i := len(nafFix) - 1; i >= 0; i-- {
|
||||
P.double()
|
||||
// Generator point
|
||||
if nafFix[i] != 0 {
|
||||
idxM := absolute(nafFix[i]) >> 1
|
||||
R := tabVerif[idxM]
|
||||
if nafFix[i] < 0 {
|
||||
R.neg()
|
||||
}
|
||||
P.mixAdd(&R)
|
||||
}
|
||||
// Variable input point
|
||||
if nafVar[i] != 0 {
|
||||
idxN := absolute(nafVar[i]) >> 1
|
||||
S := TabQ[idxN]
|
||||
if nafVar[i] < 0 {
|
||||
S.neg()
|
||||
}
|
||||
P.add(&S)
|
||||
}
|
||||
}
|
||||
}
|
||||
195
vendor/github.com/cloudflare/circl/sign/ed25519/point.go
generated
vendored
Normal file
195
vendor/github.com/cloudflare/circl/sign/ed25519/point.go
generated
vendored
Normal file
@ -0,0 +1,195 @@
|
||||
package ed25519
|
||||
|
||||
import fp "github.com/cloudflare/circl/math/fp25519"
|
||||
|
||||
type (
|
||||
pointR1 struct{ x, y, z, ta, tb fp.Elt }
|
||||
pointR2 struct {
|
||||
pointR3
|
||||
z2 fp.Elt
|
||||
}
|
||||
)
|
||||
type pointR3 struct{ addYX, subYX, dt2 fp.Elt }
|
||||
|
||||
func (P *pointR1) neg() {
|
||||
fp.Neg(&P.x, &P.x)
|
||||
fp.Neg(&P.ta, &P.ta)
|
||||
}
|
||||
|
||||
func (P *pointR1) SetIdentity() {
|
||||
P.x = fp.Elt{}
|
||||
fp.SetOne(&P.y)
|
||||
fp.SetOne(&P.z)
|
||||
P.ta = fp.Elt{}
|
||||
P.tb = fp.Elt{}
|
||||
}
|
||||
|
||||
func (P *pointR1) toAffine() {
|
||||
fp.Inv(&P.z, &P.z)
|
||||
fp.Mul(&P.x, &P.x, &P.z)
|
||||
fp.Mul(&P.y, &P.y, &P.z)
|
||||
fp.Modp(&P.x)
|
||||
fp.Modp(&P.y)
|
||||
fp.SetOne(&P.z)
|
||||
P.ta = P.x
|
||||
P.tb = P.y
|
||||
}
|
||||
|
||||
func (P *pointR1) ToBytes(k []byte) error {
|
||||
P.toAffine()
|
||||
var x [fp.Size]byte
|
||||
err := fp.ToBytes(k[:fp.Size], &P.y)
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
err = fp.ToBytes(x[:], &P.x)
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
b := x[0] & 1
|
||||
k[paramB-1] = k[paramB-1] | (b << 7)
|
||||
return nil
|
||||
}
|
||||
|
||||
func (P *pointR1) FromBytes(k []byte) bool {
|
||||
if len(k) != paramB {
|
||||
panic("wrong size")
|
||||
}
|
||||
signX := k[paramB-1] >> 7
|
||||
copy(P.y[:], k[:fp.Size])
|
||||
P.y[fp.Size-1] &= 0x7F
|
||||
p := fp.P()
|
||||
if !isLessThan(P.y[:], p[:]) {
|
||||
return false
|
||||
}
|
||||
|
||||
one, u, v := &fp.Elt{}, &fp.Elt{}, &fp.Elt{}
|
||||
fp.SetOne(one)
|
||||
fp.Sqr(u, &P.y) // u = y^2
|
||||
fp.Mul(v, u, ¶mD) // v = dy^2
|
||||
fp.Sub(u, u, one) // u = y^2-1
|
||||
fp.Add(v, v, one) // v = dy^2+1
|
||||
isQR := fp.InvSqrt(&P.x, u, v) // x = sqrt(u/v)
|
||||
if !isQR {
|
||||
return false
|
||||
}
|
||||
fp.Modp(&P.x) // x = x mod p
|
||||
if fp.IsZero(&P.x) && signX == 1 {
|
||||
return false
|
||||
}
|
||||
if signX != (P.x[0] & 1) {
|
||||
fp.Neg(&P.x, &P.x)
|
||||
}
|
||||
P.ta = P.x
|
||||
P.tb = P.y
|
||||
fp.SetOne(&P.z)
|
||||
return true
|
||||
}
|
||||
|
||||
// double calculates 2P for curves with A=-1.
|
||||
func (P *pointR1) double() {
|
||||
Px, Py, Pz, Pta, Ptb := &P.x, &P.y, &P.z, &P.ta, &P.tb
|
||||
a, b, c, e, f, g, h := Px, Py, Pz, Pta, Px, Py, Ptb
|
||||
fp.Add(e, Px, Py) // x+y
|
||||
fp.Sqr(a, Px) // A = x^2
|
||||
fp.Sqr(b, Py) // B = y^2
|
||||
fp.Sqr(c, Pz) // z^2
|
||||
fp.Add(c, c, c) // C = 2*z^2
|
||||
fp.Add(h, a, b) // H = A+B
|
||||
fp.Sqr(e, e) // (x+y)^2
|
||||
fp.Sub(e, e, h) // E = (x+y)^2-A-B
|
||||
fp.Sub(g, b, a) // G = B-A
|
||||
fp.Sub(f, c, g) // F = C-G
|
||||
fp.Mul(Pz, f, g) // Z = F * G
|
||||
fp.Mul(Px, e, f) // X = E * F
|
||||
fp.Mul(Py, g, h) // Y = G * H, T = E * H
|
||||
}
|
||||
|
||||
func (P *pointR1) mixAdd(Q *pointR3) {
|
||||
fp.Add(&P.z, &P.z, &P.z) // D = 2*z1
|
||||
P.coreAddition(Q)
|
||||
}
|
||||
|
||||
func (P *pointR1) add(Q *pointR2) {
|
||||
fp.Mul(&P.z, &P.z, &Q.z2) // D = 2*z1*z2
|
||||
P.coreAddition(&Q.pointR3)
|
||||
}
|
||||
|
||||
// coreAddition calculates P=P+Q for curves with A=-1.
|
||||
func (P *pointR1) coreAddition(Q *pointR3) {
|
||||
Px, Py, Pz, Pta, Ptb := &P.x, &P.y, &P.z, &P.ta, &P.tb
|
||||
addYX2, subYX2, dt2 := &Q.addYX, &Q.subYX, &Q.dt2
|
||||
a, b, c, d, e, f, g, h := Px, Py, &fp.Elt{}, Pz, Pta, Px, Py, Ptb
|
||||
fp.Mul(c, Pta, Ptb) // t1 = ta*tb
|
||||
fp.Sub(h, Py, Px) // y1-x1
|
||||
fp.Add(b, Py, Px) // y1+x1
|
||||
fp.Mul(a, h, subYX2) // A = (y1-x1)*(y2-x2)
|
||||
fp.Mul(b, b, addYX2) // B = (y1+x1)*(y2+x2)
|
||||
fp.Mul(c, c, dt2) // C = 2*D*t1*t2
|
||||
fp.Sub(e, b, a) // E = B-A
|
||||
fp.Add(h, b, a) // H = B+A
|
||||
fp.Sub(f, d, c) // F = D-C
|
||||
fp.Add(g, d, c) // G = D+C
|
||||
fp.Mul(Pz, f, g) // Z = F * G
|
||||
fp.Mul(Px, e, f) // X = E * F
|
||||
fp.Mul(Py, g, h) // Y = G * H, T = E * H
|
||||
}
|
||||
|
||||
func (P *pointR1) oddMultiples(T []pointR2) {
|
||||
var R pointR2
|
||||
n := len(T)
|
||||
T[0].fromR1(P)
|
||||
_2P := *P
|
||||
_2P.double()
|
||||
R.fromR1(&_2P)
|
||||
for i := 1; i < n; i++ {
|
||||
P.add(&R)
|
||||
T[i].fromR1(P)
|
||||
}
|
||||
}
|
||||
|
||||
func (P *pointR1) isEqual(Q *pointR1) bool {
|
||||
l, r := &fp.Elt{}, &fp.Elt{}
|
||||
fp.Mul(l, &P.x, &Q.z)
|
||||
fp.Mul(r, &Q.x, &P.z)
|
||||
fp.Sub(l, l, r)
|
||||
b := fp.IsZero(l)
|
||||
fp.Mul(l, &P.y, &Q.z)
|
||||
fp.Mul(r, &Q.y, &P.z)
|
||||
fp.Sub(l, l, r)
|
||||
b = b && fp.IsZero(l)
|
||||
fp.Mul(l, &P.ta, &P.tb)
|
||||
fp.Mul(l, l, &Q.z)
|
||||
fp.Mul(r, &Q.ta, &Q.tb)
|
||||
fp.Mul(r, r, &P.z)
|
||||
fp.Sub(l, l, r)
|
||||
b = b && fp.IsZero(l)
|
||||
return b
|
||||
}
|
||||
|
||||
func (P *pointR3) neg() {
|
||||
P.addYX, P.subYX = P.subYX, P.addYX
|
||||
fp.Neg(&P.dt2, &P.dt2)
|
||||
}
|
||||
|
||||
func (P *pointR2) fromR1(Q *pointR1) {
|
||||
fp.Add(&P.addYX, &Q.y, &Q.x)
|
||||
fp.Sub(&P.subYX, &Q.y, &Q.x)
|
||||
fp.Mul(&P.dt2, &Q.ta, &Q.tb)
|
||||
fp.Mul(&P.dt2, &P.dt2, ¶mD)
|
||||
fp.Add(&P.dt2, &P.dt2, &P.dt2)
|
||||
fp.Add(&P.z2, &Q.z, &Q.z)
|
||||
}
|
||||
|
||||
func (P *pointR3) cneg(b int) {
|
||||
t := &fp.Elt{}
|
||||
fp.Cswap(&P.addYX, &P.subYX, uint(b))
|
||||
fp.Neg(t, &P.dt2)
|
||||
fp.Cmov(&P.dt2, t, uint(b))
|
||||
}
|
||||
|
||||
func (P *pointR3) cmov(Q *pointR3, b int) {
|
||||
fp.Cmov(&P.addYX, &Q.addYX, uint(b))
|
||||
fp.Cmov(&P.subYX, &Q.subYX, uint(b))
|
||||
fp.Cmov(&P.dt2, &Q.dt2, uint(b))
|
||||
}
|
||||
9
vendor/github.com/cloudflare/circl/sign/ed25519/pubkey.go
generated
vendored
Normal file
9
vendor/github.com/cloudflare/circl/sign/ed25519/pubkey.go
generated
vendored
Normal file
@ -0,0 +1,9 @@
|
||||
//go:build go1.13
|
||||
// +build go1.13
|
||||
|
||||
package ed25519
|
||||
|
||||
import cryptoEd25519 "crypto/ed25519"
|
||||
|
||||
// PublicKey is the type of Ed25519 public keys.
|
||||
type PublicKey cryptoEd25519.PublicKey
|
||||
7
vendor/github.com/cloudflare/circl/sign/ed25519/pubkey112.go
generated
vendored
Normal file
7
vendor/github.com/cloudflare/circl/sign/ed25519/pubkey112.go
generated
vendored
Normal file
@ -0,0 +1,7 @@
|
||||
//go:build !go1.13
|
||||
// +build !go1.13
|
||||
|
||||
package ed25519
|
||||
|
||||
// PublicKey is the type of Ed25519 public keys.
|
||||
type PublicKey []byte
|
||||
87
vendor/github.com/cloudflare/circl/sign/ed25519/signapi.go
generated
vendored
Normal file
87
vendor/github.com/cloudflare/circl/sign/ed25519/signapi.go
generated
vendored
Normal file
@ -0,0 +1,87 @@
|
||||
package ed25519
|
||||
|
||||
import (
|
||||
"crypto/rand"
|
||||
"encoding/asn1"
|
||||
|
||||
"github.com/cloudflare/circl/sign"
|
||||
)
|
||||
|
||||
var sch sign.Scheme = &scheme{}
|
||||
|
||||
// Scheme returns a signature interface.
|
||||
func Scheme() sign.Scheme { return sch }
|
||||
|
||||
type scheme struct{}
|
||||
|
||||
func (*scheme) Name() string { return "Ed25519" }
|
||||
func (*scheme) PublicKeySize() int { return PublicKeySize }
|
||||
func (*scheme) PrivateKeySize() int { return PrivateKeySize }
|
||||
func (*scheme) SignatureSize() int { return SignatureSize }
|
||||
func (*scheme) SeedSize() int { return SeedSize }
|
||||
func (*scheme) TLSIdentifier() uint { return 0x0807 }
|
||||
func (*scheme) SupportsContext() bool { return false }
|
||||
func (*scheme) Oid() asn1.ObjectIdentifier {
|
||||
return asn1.ObjectIdentifier{1, 3, 101, 112}
|
||||
}
|
||||
|
||||
func (*scheme) GenerateKey() (sign.PublicKey, sign.PrivateKey, error) {
|
||||
return GenerateKey(rand.Reader)
|
||||
}
|
||||
|
||||
func (*scheme) Sign(
|
||||
sk sign.PrivateKey,
|
||||
message []byte,
|
||||
opts *sign.SignatureOpts,
|
||||
) []byte {
|
||||
priv, ok := sk.(PrivateKey)
|
||||
if !ok {
|
||||
panic(sign.ErrTypeMismatch)
|
||||
}
|
||||
if opts != nil && opts.Context != "" {
|
||||
panic(sign.ErrContextNotSupported)
|
||||
}
|
||||
return Sign(priv, message)
|
||||
}
|
||||
|
||||
func (*scheme) Verify(
|
||||
pk sign.PublicKey,
|
||||
message, signature []byte,
|
||||
opts *sign.SignatureOpts,
|
||||
) bool {
|
||||
pub, ok := pk.(PublicKey)
|
||||
if !ok {
|
||||
panic(sign.ErrTypeMismatch)
|
||||
}
|
||||
if opts != nil {
|
||||
if opts.Context != "" {
|
||||
panic(sign.ErrContextNotSupported)
|
||||
}
|
||||
}
|
||||
return Verify(pub, message, signature)
|
||||
}
|
||||
|
||||
func (*scheme) DeriveKey(seed []byte) (sign.PublicKey, sign.PrivateKey) {
|
||||
privateKey := NewKeyFromSeed(seed)
|
||||
publicKey := make(PublicKey, PublicKeySize)
|
||||
copy(publicKey, privateKey[SeedSize:])
|
||||
return publicKey, privateKey
|
||||
}
|
||||
|
||||
func (*scheme) UnmarshalBinaryPublicKey(buf []byte) (sign.PublicKey, error) {
|
||||
if len(buf) < PublicKeySize {
|
||||
return nil, sign.ErrPubKeySize
|
||||
}
|
||||
pub := make(PublicKey, PublicKeySize)
|
||||
copy(pub, buf[:PublicKeySize])
|
||||
return pub, nil
|
||||
}
|
||||
|
||||
func (*scheme) UnmarshalBinaryPrivateKey(buf []byte) (sign.PrivateKey, error) {
|
||||
if len(buf) < PrivateKeySize {
|
||||
return nil, sign.ErrPrivKeySize
|
||||
}
|
||||
priv := make(PrivateKey, PrivateKeySize)
|
||||
copy(priv, buf[:PrivateKeySize])
|
||||
return priv, nil
|
||||
}
|
||||
213
vendor/github.com/cloudflare/circl/sign/ed25519/tables.go
generated
vendored
Normal file
213
vendor/github.com/cloudflare/circl/sign/ed25519/tables.go
generated
vendored
Normal file
@ -0,0 +1,213 @@
|
||||
package ed25519
|
||||
|
||||
import fp "github.com/cloudflare/circl/math/fp25519"
|
||||
|
||||
var tabSign = [fxV][fx2w1]pointR3{
|
||||
{
|
||||
pointR3{
|
||||
addYX: fp.Elt{0x85, 0x3b, 0x8c, 0xf5, 0xc6, 0x93, 0xbc, 0x2f, 0x19, 0x0e, 0x8c, 0xfb, 0xc6, 0x2d, 0x93, 0xcf, 0xc2, 0x42, 0x3d, 0x64, 0x98, 0x48, 0x0b, 0x27, 0x65, 0xba, 0xd4, 0x33, 0x3a, 0x9d, 0xcf, 0x07},
|
||||
subYX: fp.Elt{0x3e, 0x91, 0x40, 0xd7, 0x05, 0x39, 0x10, 0x9d, 0xb3, 0xbe, 0x40, 0xd1, 0x05, 0x9f, 0x39, 0xfd, 0x09, 0x8a, 0x8f, 0x68, 0x34, 0x84, 0xc1, 0xa5, 0x67, 0x12, 0xf8, 0x98, 0x92, 0x2f, 0xfd, 0x44},
|
||||
dt2: fp.Elt{0x68, 0xaa, 0x7a, 0x87, 0x05, 0x12, 0xc9, 0xab, 0x9e, 0xc4, 0xaa, 0xcc, 0x23, 0xe8, 0xd9, 0x26, 0x8c, 0x59, 0x43, 0xdd, 0xcb, 0x7d, 0x1b, 0x5a, 0xa8, 0x65, 0x0c, 0x9f, 0x68, 0x7b, 0x11, 0x6f},
|
||||
},
|
||||
{
|
||||
addYX: fp.Elt{0x7c, 0xb0, 0x9e, 0xe6, 0xc5, 0xbf, 0xfa, 0x13, 0x8e, 0x0d, 0x22, 0xde, 0xc8, 0xd1, 0xce, 0x52, 0x02, 0xd5, 0x62, 0x31, 0x71, 0x0e, 0x8e, 0x9d, 0xb0, 0xd6, 0x00, 0xa5, 0x5a, 0x0e, 0xce, 0x72},
|
||||
subYX: fp.Elt{0x1a, 0x8e, 0x5c, 0xdc, 0xa4, 0xb3, 0x6c, 0x51, 0x18, 0xa0, 0x09, 0x80, 0x9a, 0x46, 0x33, 0xd5, 0xe0, 0x3c, 0x4d, 0x3b, 0xfc, 0x49, 0xa2, 0x43, 0x29, 0xe1, 0x29, 0xa9, 0x93, 0xea, 0x7c, 0x35},
|
||||
dt2: fp.Elt{0x08, 0x46, 0x6f, 0x68, 0x7f, 0x0b, 0x7c, 0x9e, 0xad, 0xba, 0x07, 0x61, 0x74, 0x83, 0x2f, 0xfc, 0x26, 0xd6, 0x09, 0xb9, 0x00, 0x34, 0x36, 0x4f, 0x01, 0xf3, 0x48, 0xdb, 0x43, 0xba, 0x04, 0x44},
|
||||
},
|
||||
{
|
||||
addYX: fp.Elt{0x4c, 0xda, 0x0d, 0x13, 0x66, 0xfd, 0x82, 0x84, 0x9f, 0x75, 0x5b, 0xa2, 0x17, 0xfe, 0x34, 0xbf, 0x1f, 0xcb, 0xba, 0x90, 0x55, 0x80, 0x83, 0xfd, 0x63, 0xb9, 0x18, 0xf8, 0x5b, 0x5d, 0x94, 0x1e},
|
||||
subYX: fp.Elt{0xb9, 0xdb, 0x6c, 0x04, 0x88, 0x22, 0xd8, 0x79, 0x83, 0x2f, 0x8d, 0x65, 0x6b, 0xd2, 0xab, 0x1b, 0xdd, 0x65, 0xe5, 0x93, 0x63, 0xf8, 0xa2, 0xd8, 0x3c, 0xf1, 0x4b, 0xc5, 0x99, 0xd1, 0xf2, 0x12},
|
||||
dt2: fp.Elt{0x05, 0x4c, 0xb8, 0x3b, 0xfe, 0xf5, 0x9f, 0x2e, 0xd1, 0xb2, 0xb8, 0xff, 0xfe, 0x6d, 0xd9, 0x37, 0xe0, 0xae, 0xb4, 0x5a, 0x51, 0x80, 0x7e, 0x9b, 0x1d, 0xd1, 0x8d, 0x8c, 0x56, 0xb1, 0x84, 0x35},
|
||||
},
|
||||
{
|
||||
addYX: fp.Elt{0x39, 0x71, 0x43, 0x34, 0xe3, 0x42, 0x45, 0xa1, 0xf2, 0x68, 0x71, 0xa7, 0xe8, 0x23, 0xfd, 0x9f, 0x86, 0x48, 0xff, 0xe5, 0x96, 0x74, 0xcf, 0x05, 0x49, 0xe2, 0xb3, 0x6c, 0x17, 0x77, 0x2f, 0x6d},
|
||||
subYX: fp.Elt{0x73, 0x3f, 0xc1, 0xc7, 0x6a, 0x66, 0xa1, 0x20, 0xdd, 0x11, 0xfb, 0x7a, 0x6e, 0xa8, 0x51, 0xb8, 0x3f, 0x9d, 0xa2, 0x97, 0x84, 0xb5, 0xc7, 0x90, 0x7c, 0xab, 0x48, 0xd6, 0x84, 0xa3, 0xd5, 0x1a},
|
||||
dt2: fp.Elt{0x63, 0x27, 0x3c, 0x49, 0x4b, 0xfc, 0x22, 0xf2, 0x0b, 0x50, 0xc2, 0x0f, 0xb4, 0x1f, 0x31, 0x0c, 0x2f, 0x53, 0xab, 0xaa, 0x75, 0x6f, 0xe0, 0x69, 0x39, 0x56, 0xe0, 0x3b, 0xb7, 0xa8, 0xbf, 0x45},
|
||||
},
|
||||
},
|
||||
{
|
||||
{
|
||||
addYX: fp.Elt{0x00, 0x45, 0xd9, 0x0d, 0x58, 0x03, 0xfc, 0x29, 0x93, 0xec, 0xbb, 0x6f, 0xa4, 0x7a, 0xd2, 0xec, 0xf8, 0xa7, 0xe2, 0xc2, 0x5f, 0x15, 0x0a, 0x13, 0xd5, 0xa1, 0x06, 0xb7, 0x1a, 0x15, 0x6b, 0x41},
|
||||
subYX: fp.Elt{0x85, 0x8c, 0xb2, 0x17, 0xd6, 0x3b, 0x0a, 0xd3, 0xea, 0x3b, 0x77, 0x39, 0xb7, 0x77, 0xd3, 0xc5, 0xbf, 0x5c, 0x6a, 0x1e, 0x8c, 0xe7, 0xc6, 0xc6, 0xc4, 0xb7, 0x2a, 0x8b, 0xf7, 0xb8, 0x61, 0x0d},
|
||||
dt2: fp.Elt{0xb0, 0x36, 0xc1, 0xe9, 0xef, 0xd7, 0xa8, 0x56, 0x20, 0x4b, 0xe4, 0x58, 0xcd, 0xe5, 0x07, 0xbd, 0xab, 0xe0, 0x57, 0x1b, 0xda, 0x2f, 0xe6, 0xaf, 0xd2, 0xe8, 0x77, 0x42, 0xf7, 0x2a, 0x1a, 0x19},
|
||||
},
|
||||
{
|
||||
addYX: fp.Elt{0x6a, 0x6d, 0x6d, 0xd1, 0xfa, 0xf5, 0x03, 0x30, 0xbd, 0x6d, 0xc2, 0xc8, 0xf5, 0x38, 0x80, 0x4f, 0xb2, 0xbe, 0xa1, 0x76, 0x50, 0x1a, 0x73, 0xf2, 0x78, 0x2b, 0x8e, 0x3a, 0x1e, 0x34, 0x47, 0x7b},
|
||||
subYX: fp.Elt{0xc3, 0x2c, 0x36, 0xdc, 0xc5, 0x45, 0xbc, 0xef, 0x1b, 0x64, 0xd6, 0x65, 0x28, 0xe9, 0xda, 0x84, 0x13, 0xbe, 0x27, 0x8e, 0x3f, 0x98, 0x2a, 0x37, 0xee, 0x78, 0x97, 0xd6, 0xc0, 0x6f, 0xb4, 0x53},
|
||||
dt2: fp.Elt{0x58, 0x5d, 0xa7, 0xa3, 0x68, 0xbb, 0x20, 0x30, 0x2e, 0x03, 0xe9, 0xb1, 0xd4, 0x90, 0x72, 0xe3, 0x71, 0xb2, 0x36, 0x3e, 0x73, 0xa0, 0x2e, 0x3d, 0xd1, 0x85, 0x33, 0x62, 0x4e, 0xa7, 0x7b, 0x31},
|
||||
},
|
||||
{
|
||||
addYX: fp.Elt{0xbf, 0xc4, 0x38, 0x53, 0xfb, 0x68, 0xa9, 0x77, 0xce, 0x55, 0xf9, 0x05, 0xcb, 0xeb, 0xfb, 0x8c, 0x46, 0xc2, 0x32, 0x7c, 0xf0, 0xdb, 0xd7, 0x2c, 0x62, 0x8e, 0xdd, 0x54, 0x75, 0xcf, 0x3f, 0x33},
|
||||
subYX: fp.Elt{0x49, 0x50, 0x1f, 0x4e, 0x6e, 0x55, 0x55, 0xde, 0x8c, 0x4e, 0x77, 0x96, 0x38, 0x3b, 0xfe, 0xb6, 0x43, 0x3c, 0x86, 0x69, 0xc2, 0x72, 0x66, 0x1f, 0x6b, 0xf9, 0x87, 0xbc, 0x4f, 0x37, 0x3e, 0x3c},
|
||||
dt2: fp.Elt{0xd2, 0x2f, 0x06, 0x6b, 0x08, 0x07, 0x69, 0x77, 0xc0, 0x94, 0xcc, 0xae, 0x43, 0x00, 0x59, 0x6e, 0xa3, 0x63, 0xa8, 0xdd, 0xfa, 0x24, 0x18, 0xd0, 0x35, 0xc7, 0x78, 0xf7, 0x0d, 0xd4, 0x5a, 0x1e},
|
||||
},
|
||||
{
|
||||
addYX: fp.Elt{0x45, 0xc1, 0x17, 0x51, 0xf8, 0xed, 0x7e, 0xc7, 0xa9, 0x1a, 0x11, 0x6e, 0x2d, 0xef, 0x0b, 0xd5, 0x3f, 0x98, 0xb0, 0xa3, 0x9d, 0x65, 0xf1, 0xcd, 0x53, 0x4a, 0x8a, 0x18, 0x70, 0x0a, 0x7f, 0x23},
|
||||
subYX: fp.Elt{0xdd, 0xef, 0xbe, 0x3a, 0x31, 0xe0, 0xbc, 0xbe, 0x6d, 0x5d, 0x79, 0x87, 0xd6, 0xbe, 0x68, 0xe3, 0x59, 0x76, 0x8c, 0x86, 0x0e, 0x7a, 0x92, 0x13, 0x14, 0x8f, 0x67, 0xb3, 0xcb, 0x1a, 0x76, 0x76},
|
||||
dt2: fp.Elt{0x56, 0x7a, 0x1c, 0x9d, 0xca, 0x96, 0xf9, 0xf9, 0x03, 0x21, 0xd4, 0xe8, 0xb3, 0xd5, 0xe9, 0x52, 0xc8, 0x54, 0x1e, 0x1b, 0x13, 0xb6, 0xfd, 0x47, 0x7d, 0x02, 0x32, 0x33, 0x27, 0xe2, 0x1f, 0x19},
|
||||
},
|
||||
},
|
||||
}
|
||||
|
||||
var tabVerif = [1 << (omegaFix - 2)]pointR3{
|
||||
{ /* 1P */
|
||||
addYX: fp.Elt{0x85, 0x3b, 0x8c, 0xf5, 0xc6, 0x93, 0xbc, 0x2f, 0x19, 0x0e, 0x8c, 0xfb, 0xc6, 0x2d, 0x93, 0xcf, 0xc2, 0x42, 0x3d, 0x64, 0x98, 0x48, 0x0b, 0x27, 0x65, 0xba, 0xd4, 0x33, 0x3a, 0x9d, 0xcf, 0x07},
|
||||
subYX: fp.Elt{0x3e, 0x91, 0x40, 0xd7, 0x05, 0x39, 0x10, 0x9d, 0xb3, 0xbe, 0x40, 0xd1, 0x05, 0x9f, 0x39, 0xfd, 0x09, 0x8a, 0x8f, 0x68, 0x34, 0x84, 0xc1, 0xa5, 0x67, 0x12, 0xf8, 0x98, 0x92, 0x2f, 0xfd, 0x44},
|
||||
dt2: fp.Elt{0x68, 0xaa, 0x7a, 0x87, 0x05, 0x12, 0xc9, 0xab, 0x9e, 0xc4, 0xaa, 0xcc, 0x23, 0xe8, 0xd9, 0x26, 0x8c, 0x59, 0x43, 0xdd, 0xcb, 0x7d, 0x1b, 0x5a, 0xa8, 0x65, 0x0c, 0x9f, 0x68, 0x7b, 0x11, 0x6f},
|
||||
},
|
||||
{ /* 3P */
|
||||
addYX: fp.Elt{0x30, 0x97, 0xee, 0x4c, 0xa8, 0xb0, 0x25, 0xaf, 0x8a, 0x4b, 0x86, 0xe8, 0x30, 0x84, 0x5a, 0x02, 0x32, 0x67, 0x01, 0x9f, 0x02, 0x50, 0x1b, 0xc1, 0xf4, 0xf8, 0x80, 0x9a, 0x1b, 0x4e, 0x16, 0x7a},
|
||||
subYX: fp.Elt{0x65, 0xd2, 0xfc, 0xa4, 0xe8, 0x1f, 0x61, 0x56, 0x7d, 0xba, 0xc1, 0xe5, 0xfd, 0x53, 0xd3, 0x3b, 0xbd, 0xd6, 0x4b, 0x21, 0x1a, 0xf3, 0x31, 0x81, 0x62, 0xda, 0x5b, 0x55, 0x87, 0x15, 0xb9, 0x2a},
|
||||
dt2: fp.Elt{0x89, 0xd8, 0xd0, 0x0d, 0x3f, 0x93, 0xae, 0x14, 0x62, 0xda, 0x35, 0x1c, 0x22, 0x23, 0x94, 0x58, 0x4c, 0xdb, 0xf2, 0x8c, 0x45, 0xe5, 0x70, 0xd1, 0xc6, 0xb4, 0xb9, 0x12, 0xaf, 0x26, 0x28, 0x5a},
|
||||
},
|
||||
{ /* 5P */
|
||||
addYX: fp.Elt{0x33, 0xbb, 0xa5, 0x08, 0x44, 0xbc, 0x12, 0xa2, 0x02, 0xed, 0x5e, 0xc7, 0xc3, 0x48, 0x50, 0x8d, 0x44, 0xec, 0xbf, 0x5a, 0x0c, 0xeb, 0x1b, 0xdd, 0xeb, 0x06, 0xe2, 0x46, 0xf1, 0xcc, 0x45, 0x29},
|
||||
subYX: fp.Elt{0xba, 0xd6, 0x47, 0xa4, 0xc3, 0x82, 0x91, 0x7f, 0xb7, 0x29, 0x27, 0x4b, 0xd1, 0x14, 0x00, 0xd5, 0x87, 0xa0, 0x64, 0xb8, 0x1c, 0xf1, 0x3c, 0xe3, 0xf3, 0x55, 0x1b, 0xeb, 0x73, 0x7e, 0x4a, 0x15},
|
||||
dt2: fp.Elt{0x85, 0x82, 0x2a, 0x81, 0xf1, 0xdb, 0xbb, 0xbc, 0xfc, 0xd1, 0xbd, 0xd0, 0x07, 0x08, 0x0e, 0x27, 0x2d, 0xa7, 0xbd, 0x1b, 0x0b, 0x67, 0x1b, 0xb4, 0x9a, 0xb6, 0x3b, 0x6b, 0x69, 0xbe, 0xaa, 0x43},
|
||||
},
|
||||
{ /* 7P */
|
||||
addYX: fp.Elt{0xbf, 0xa3, 0x4e, 0x94, 0xd0, 0x5c, 0x1a, 0x6b, 0xd2, 0xc0, 0x9d, 0xb3, 0x3a, 0x35, 0x70, 0x74, 0x49, 0x2e, 0x54, 0x28, 0x82, 0x52, 0xb2, 0x71, 0x7e, 0x92, 0x3c, 0x28, 0x69, 0xea, 0x1b, 0x46},
|
||||
subYX: fp.Elt{0xb1, 0x21, 0x32, 0xaa, 0x9a, 0x2c, 0x6f, 0xba, 0xa7, 0x23, 0xba, 0x3b, 0x53, 0x21, 0xa0, 0x6c, 0x3a, 0x2c, 0x19, 0x92, 0x4f, 0x76, 0xea, 0x9d, 0xe0, 0x17, 0x53, 0x2e, 0x5d, 0xdd, 0x6e, 0x1d},
|
||||
dt2: fp.Elt{0xa2, 0xb3, 0xb8, 0x01, 0xc8, 0x6d, 0x83, 0xf1, 0x9a, 0xa4, 0x3e, 0x05, 0x47, 0x5f, 0x03, 0xb3, 0xf3, 0xad, 0x77, 0x58, 0xba, 0x41, 0x9c, 0x52, 0xa7, 0x90, 0x0f, 0x6a, 0x1c, 0xbb, 0x9f, 0x7a},
|
||||
},
|
||||
{ /* 9P */
|
||||
addYX: fp.Elt{0x2f, 0x63, 0xa8, 0xa6, 0x8a, 0x67, 0x2e, 0x9b, 0xc5, 0x46, 0xbc, 0x51, 0x6f, 0x9e, 0x50, 0xa6, 0xb5, 0xf5, 0x86, 0xc6, 0xc9, 0x33, 0xb2, 0xce, 0x59, 0x7f, 0xdd, 0x8a, 0x33, 0xed, 0xb9, 0x34},
|
||||
subYX: fp.Elt{0x64, 0x80, 0x9d, 0x03, 0x7e, 0x21, 0x6e, 0xf3, 0x9b, 0x41, 0x20, 0xf5, 0xb6, 0x81, 0xa0, 0x98, 0x44, 0xb0, 0x5e, 0xe7, 0x08, 0xc6, 0xcb, 0x96, 0x8f, 0x9c, 0xdc, 0xfa, 0x51, 0x5a, 0xc0, 0x49},
|
||||
dt2: fp.Elt{0x1b, 0xaf, 0x45, 0x90, 0xbf, 0xe8, 0xb4, 0x06, 0x2f, 0xd2, 0x19, 0xa7, 0xe8, 0x83, 0xff, 0xe2, 0x16, 0xcf, 0xd4, 0x93, 0x29, 0xfc, 0xf6, 0xaa, 0x06, 0x8b, 0x00, 0x1b, 0x02, 0x72, 0xc1, 0x73},
|
||||
},
|
||||
{ /* 11P */
|
||||
addYX: fp.Elt{0xde, 0x2a, 0x80, 0x8a, 0x84, 0x00, 0xbf, 0x2f, 0x27, 0x2e, 0x30, 0x02, 0xcf, 0xfe, 0xd9, 0xe5, 0x06, 0x34, 0x70, 0x17, 0x71, 0x84, 0x3e, 0x11, 0xaf, 0x8f, 0x6d, 0x54, 0xe2, 0xaa, 0x75, 0x42},
|
||||
subYX: fp.Elt{0x48, 0x43, 0x86, 0x49, 0x02, 0x5b, 0x5f, 0x31, 0x81, 0x83, 0x08, 0x77, 0x69, 0xb3, 0xd6, 0x3e, 0x95, 0xeb, 0x8d, 0x6a, 0x55, 0x75, 0xa0, 0xa3, 0x7f, 0xc7, 0xd5, 0x29, 0x80, 0x59, 0xab, 0x18},
|
||||
dt2: fp.Elt{0xe9, 0x89, 0x60, 0xfd, 0xc5, 0x2c, 0x2b, 0xd8, 0xa4, 0xe4, 0x82, 0x32, 0xa1, 0xb4, 0x1e, 0x03, 0x22, 0x86, 0x1a, 0xb5, 0x99, 0x11, 0x31, 0x44, 0x48, 0xf9, 0x3d, 0xb5, 0x22, 0x55, 0xc6, 0x3d},
|
||||
},
|
||||
{ /* 13P */
|
||||
addYX: fp.Elt{0x6d, 0x7f, 0x00, 0xa2, 0x22, 0xc2, 0x70, 0xbf, 0xdb, 0xde, 0xbc, 0xb5, 0x9a, 0xb3, 0x84, 0xbf, 0x07, 0xba, 0x07, 0xfb, 0x12, 0x0e, 0x7a, 0x53, 0x41, 0xf2, 0x46, 0xc3, 0xee, 0xd7, 0x4f, 0x23},
|
||||
subYX: fp.Elt{0x93, 0xbf, 0x7f, 0x32, 0x3b, 0x01, 0x6f, 0x50, 0x6b, 0x6f, 0x77, 0x9b, 0xc9, 0xeb, 0xfc, 0xae, 0x68, 0x59, 0xad, 0xaa, 0x32, 0xb2, 0x12, 0x9d, 0xa7, 0x24, 0x60, 0x17, 0x2d, 0x88, 0x67, 0x02},
|
||||
dt2: fp.Elt{0x78, 0xa3, 0x2e, 0x73, 0x19, 0xa1, 0x60, 0x53, 0x71, 0xd4, 0x8d, 0xdf, 0xb1, 0xe6, 0x37, 0x24, 0x33, 0xe5, 0xa7, 0x91, 0xf8, 0x37, 0xef, 0xa2, 0x63, 0x78, 0x09, 0xaa, 0xfd, 0xa6, 0x7b, 0x49},
|
||||
},
|
||||
{ /* 15P */
|
||||
addYX: fp.Elt{0xa0, 0xea, 0xcf, 0x13, 0x03, 0xcc, 0xce, 0x24, 0x6d, 0x24, 0x9c, 0x18, 0x8d, 0xc2, 0x48, 0x86, 0xd0, 0xd4, 0xf2, 0xc1, 0xfa, 0xbd, 0xbd, 0x2d, 0x2b, 0xe7, 0x2d, 0xf1, 0x17, 0x29, 0xe2, 0x61},
|
||||
subYX: fp.Elt{0x0b, 0xcf, 0x8c, 0x46, 0x86, 0xcd, 0x0b, 0x04, 0xd6, 0x10, 0x99, 0x2a, 0xa4, 0x9b, 0x82, 0xd3, 0x92, 0x51, 0xb2, 0x07, 0x08, 0x30, 0x08, 0x75, 0xbf, 0x5e, 0xd0, 0x18, 0x42, 0xcd, 0xb5, 0x43},
|
||||
dt2: fp.Elt{0x16, 0xb5, 0xd0, 0x9b, 0x2f, 0x76, 0x9a, 0x5d, 0xee, 0xde, 0x3f, 0x37, 0x4e, 0xaf, 0x38, 0xeb, 0x70, 0x42, 0xd6, 0x93, 0x7d, 0x5a, 0x2e, 0x03, 0x42, 0xd8, 0xe4, 0x0a, 0x21, 0x61, 0x1d, 0x51},
|
||||
},
|
||||
{ /* 17P */
|
||||
addYX: fp.Elt{0x81, 0x9d, 0x0e, 0x95, 0xef, 0x76, 0xc6, 0x92, 0x4f, 0x04, 0xd7, 0xc0, 0xcd, 0x20, 0x46, 0xa5, 0x48, 0x12, 0x8f, 0x6f, 0x64, 0x36, 0x9b, 0xaa, 0xe3, 0x55, 0xb8, 0xdd, 0x24, 0x59, 0x32, 0x6d},
|
||||
subYX: fp.Elt{0x87, 0xde, 0x20, 0x44, 0x48, 0x86, 0x13, 0x08, 0xb4, 0xed, 0x92, 0xb5, 0x16, 0xf0, 0x1c, 0x8a, 0x25, 0x2d, 0x94, 0x29, 0x27, 0x4e, 0xfa, 0x39, 0x10, 0x28, 0x48, 0xe2, 0x6f, 0xfe, 0xa7, 0x71},
|
||||
dt2: fp.Elt{0x54, 0xc8, 0xc8, 0xa5, 0xb8, 0x82, 0x71, 0x6c, 0x03, 0x2a, 0x5f, 0xfe, 0x79, 0x14, 0xfd, 0x33, 0x0c, 0x8d, 0x77, 0x83, 0x18, 0x59, 0xcf, 0x72, 0xa9, 0xea, 0x9e, 0x55, 0xb6, 0xc4, 0x46, 0x47},
|
||||
},
|
||||
{ /* 19P */
|
||||
addYX: fp.Elt{0x2b, 0x9a, 0xc6, 0x6d, 0x3c, 0x7b, 0x77, 0xd3, 0x17, 0xf6, 0x89, 0x6f, 0x27, 0xb2, 0xfa, 0xde, 0xb5, 0x16, 0x3a, 0xb5, 0xf7, 0x1c, 0x65, 0x45, 0xb7, 0x9f, 0xfe, 0x34, 0xde, 0x51, 0x9a, 0x5c},
|
||||
subYX: fp.Elt{0x47, 0x11, 0x74, 0x64, 0xc8, 0x46, 0x85, 0x34, 0x49, 0xc8, 0xfc, 0x0e, 0xdd, 0xae, 0x35, 0x7d, 0x32, 0xa3, 0x72, 0x06, 0x76, 0x9a, 0x93, 0xff, 0xd6, 0xe6, 0xb5, 0x7d, 0x49, 0x63, 0x96, 0x21},
|
||||
dt2: fp.Elt{0x67, 0x0e, 0xf1, 0x79, 0xcf, 0xf1, 0x10, 0xf5, 0x5b, 0x51, 0x58, 0xe6, 0xa1, 0xda, 0xdd, 0xff, 0x77, 0x22, 0x14, 0x10, 0x17, 0xa7, 0xc3, 0x09, 0xbb, 0x23, 0x82, 0x60, 0x3c, 0x50, 0x04, 0x48},
|
||||
},
|
||||
{ /* 21P */
|
||||
addYX: fp.Elt{0xc7, 0x7f, 0xa3, 0x2c, 0xd0, 0x9e, 0x24, 0xc4, 0xab, 0xac, 0x15, 0xa6, 0xe3, 0xa0, 0x59, 0xa0, 0x23, 0x0e, 0x6e, 0xc9, 0xd7, 0x6e, 0xa9, 0x88, 0x6d, 0x69, 0x50, 0x16, 0xa5, 0x98, 0x33, 0x55},
|
||||
subYX: fp.Elt{0x75, 0xd1, 0x36, 0x3a, 0xd2, 0x21, 0x68, 0x3b, 0x32, 0x9e, 0x9b, 0xe9, 0xa7, 0x0a, 0xb4, 0xbb, 0x47, 0x8a, 0x83, 0x20, 0xe4, 0x5c, 0x9e, 0x5d, 0x5e, 0x4c, 0xde, 0x58, 0x88, 0x09, 0x1e, 0x77},
|
||||
dt2: fp.Elt{0xdf, 0x1e, 0x45, 0x78, 0xd2, 0xf5, 0x12, 0x9a, 0xcb, 0x9c, 0x89, 0x85, 0x79, 0x5d, 0xda, 0x3a, 0x08, 0x95, 0xa5, 0x9f, 0x2d, 0x4a, 0x7f, 0x47, 0x11, 0xa6, 0xf5, 0x8f, 0xd6, 0xd1, 0x5e, 0x5a},
|
||||
},
|
||||
{ /* 23P */
|
||||
addYX: fp.Elt{0x83, 0x0e, 0x15, 0xfe, 0x2a, 0x12, 0x95, 0x11, 0xd8, 0x35, 0x4b, 0x7e, 0x25, 0x9a, 0x20, 0xcf, 0x20, 0x1e, 0x71, 0x1e, 0x29, 0xf8, 0x87, 0x73, 0xf0, 0x92, 0xbf, 0xd8, 0x97, 0xb8, 0xac, 0x44},
|
||||
subYX: fp.Elt{0x59, 0x73, 0x52, 0x58, 0xc5, 0xe0, 0xe5, 0xba, 0x7e, 0x9d, 0xdb, 0xca, 0x19, 0x5c, 0x2e, 0x39, 0xe9, 0xab, 0x1c, 0xda, 0x1e, 0x3c, 0x65, 0x28, 0x44, 0xdc, 0xef, 0x5f, 0x13, 0x60, 0x9b, 0x01},
|
||||
dt2: fp.Elt{0x83, 0x4b, 0x13, 0x5e, 0x14, 0x68, 0x60, 0x1e, 0x16, 0x4c, 0x30, 0x24, 0x4f, 0xe6, 0xf5, 0xc4, 0xd7, 0x3e, 0x1a, 0xfc, 0xa8, 0x88, 0x6e, 0x50, 0x92, 0x2f, 0xad, 0xe6, 0xfd, 0x49, 0x0c, 0x15},
|
||||
},
|
||||
{ /* 25P */
|
||||
addYX: fp.Elt{0x38, 0x11, 0x47, 0x09, 0x95, 0xf2, 0x7b, 0x8e, 0x51, 0xa6, 0x75, 0x4f, 0x39, 0xef, 0x6f, 0x5d, 0xad, 0x08, 0xa7, 0x25, 0xc4, 0x79, 0xaf, 0x10, 0x22, 0x99, 0xb9, 0x5b, 0x07, 0x5a, 0x2b, 0x6b},
|
||||
subYX: fp.Elt{0x68, 0xa8, 0xdc, 0x9c, 0x3c, 0x86, 0x49, 0xb8, 0xd0, 0x4a, 0x71, 0xb8, 0xdb, 0x44, 0x3f, 0xc8, 0x8d, 0x16, 0x36, 0x0c, 0x56, 0xe3, 0x3e, 0xfe, 0xc1, 0xfb, 0x05, 0x1e, 0x79, 0xd7, 0xa6, 0x78},
|
||||
dt2: fp.Elt{0x76, 0xb9, 0xa0, 0x47, 0x4b, 0x70, 0xbf, 0x58, 0xd5, 0x48, 0x17, 0x74, 0x55, 0xb3, 0x01, 0xa6, 0x90, 0xf5, 0x42, 0xd5, 0xb1, 0x1f, 0x2b, 0xaa, 0x00, 0x5d, 0xd5, 0x4a, 0xfc, 0x7f, 0x5c, 0x72},
|
||||
},
|
||||
{ /* 27P */
|
||||
addYX: fp.Elt{0xb2, 0x99, 0xcf, 0xd1, 0x15, 0x67, 0x42, 0xe4, 0x34, 0x0d, 0xa2, 0x02, 0x11, 0xd5, 0x52, 0x73, 0x9f, 0x10, 0x12, 0x8b, 0x7b, 0x15, 0xd1, 0x23, 0xa3, 0xf3, 0xb1, 0x7c, 0x27, 0xc9, 0x4c, 0x79},
|
||||
subYX: fp.Elt{0xc0, 0x98, 0xd0, 0x1c, 0xf7, 0x2b, 0x80, 0x91, 0x66, 0x63, 0x5e, 0xed, 0xa4, 0x6c, 0x41, 0xfe, 0x4c, 0x99, 0x02, 0x49, 0x71, 0x5d, 0x58, 0xdf, 0xe7, 0xfa, 0x55, 0xf8, 0x25, 0x46, 0xd5, 0x4c},
|
||||
dt2: fp.Elt{0x53, 0x50, 0xac, 0xc2, 0x26, 0xc4, 0xf6, 0x4a, 0x58, 0x72, 0xf6, 0x32, 0xad, 0xed, 0x9a, 0xbc, 0x21, 0x10, 0x31, 0x0a, 0xf1, 0x32, 0xd0, 0x2a, 0x85, 0x8e, 0xcc, 0x6f, 0x7b, 0x35, 0x08, 0x70},
|
||||
},
|
||||
{ /* 29P */
|
||||
addYX: fp.Elt{0x01, 0x3f, 0x77, 0x38, 0x27, 0x67, 0x88, 0x0b, 0xfb, 0xcc, 0xfb, 0x95, 0xfa, 0xc8, 0xcc, 0xb8, 0xb6, 0x29, 0xad, 0xb9, 0xa3, 0xd5, 0x2d, 0x8d, 0x6a, 0x0f, 0xad, 0x51, 0x98, 0x7e, 0xef, 0x06},
|
||||
subYX: fp.Elt{0x34, 0x4a, 0x58, 0x82, 0xbb, 0x9f, 0x1b, 0xd0, 0x2b, 0x79, 0xb4, 0xd2, 0x63, 0x64, 0xab, 0x47, 0x02, 0x62, 0x53, 0x48, 0x9c, 0x63, 0x31, 0xb6, 0x28, 0xd4, 0xd6, 0x69, 0x36, 0x2a, 0xa9, 0x13},
|
||||
dt2: fp.Elt{0xe5, 0x7d, 0x57, 0xc0, 0x1c, 0x77, 0x93, 0xca, 0x5c, 0xdc, 0x35, 0x50, 0x1e, 0xe4, 0x40, 0x75, 0x71, 0xe0, 0x02, 0xd8, 0x01, 0x0f, 0x68, 0x24, 0x6a, 0xf8, 0x2a, 0x8a, 0xdf, 0x6d, 0x29, 0x3c},
|
||||
},
|
||||
{ /* 31P */
|
||||
addYX: fp.Elt{0x13, 0xa7, 0x14, 0xd9, 0xf9, 0x15, 0xad, 0xae, 0x12, 0xf9, 0x8f, 0x8c, 0xf9, 0x7b, 0x2f, 0xa9, 0x30, 0xd7, 0x53, 0x9f, 0x17, 0x23, 0xf8, 0xaf, 0xba, 0x77, 0x0c, 0x49, 0x93, 0xd3, 0x99, 0x7a},
|
||||
subYX: fp.Elt{0x41, 0x25, 0x1f, 0xbb, 0x2e, 0x4d, 0xeb, 0xfc, 0x1f, 0xb9, 0xad, 0x40, 0xc7, 0x10, 0x95, 0xb8, 0x05, 0xad, 0xa1, 0xd0, 0x7d, 0xa3, 0x71, 0xfc, 0x7b, 0x71, 0x47, 0x07, 0x70, 0x2c, 0x89, 0x0a},
|
||||
dt2: fp.Elt{0xe8, 0xa3, 0xbd, 0x36, 0x24, 0xed, 0x52, 0x8f, 0x94, 0x07, 0xe8, 0x57, 0x41, 0xc8, 0xa8, 0x77, 0xe0, 0x9c, 0x2f, 0x26, 0x63, 0x65, 0xa9, 0xa5, 0xd2, 0xf7, 0x02, 0x83, 0xd2, 0x62, 0x67, 0x28},
|
||||
},
|
||||
{ /* 33P */
|
||||
addYX: fp.Elt{0x25, 0x5b, 0xe3, 0x3c, 0x09, 0x36, 0x78, 0x4e, 0x97, 0xaa, 0x6b, 0xb2, 0x1d, 0x18, 0xe1, 0x82, 0x3f, 0xb8, 0xc7, 0xcb, 0xd3, 0x92, 0xc1, 0x0c, 0x3a, 0x9d, 0x9d, 0x6a, 0x04, 0xda, 0xf1, 0x32},
|
||||
subYX: fp.Elt{0xbd, 0xf5, 0x2e, 0xce, 0x2b, 0x8e, 0x55, 0x7c, 0x63, 0xbc, 0x47, 0x67, 0xb4, 0x6c, 0x98, 0xe4, 0xb8, 0x89, 0xbb, 0x3b, 0x9f, 0x17, 0x4a, 0x15, 0x7a, 0x76, 0xf1, 0xd6, 0xa3, 0xf2, 0x86, 0x76},
|
||||
dt2: fp.Elt{0x6a, 0x7c, 0x59, 0x6d, 0xa6, 0x12, 0x8d, 0xaa, 0x2b, 0x85, 0xd3, 0x04, 0x03, 0x93, 0x11, 0x8f, 0x22, 0xb0, 0x09, 0xc2, 0x73, 0xdc, 0x91, 0x3f, 0xa6, 0x28, 0xad, 0xa9, 0xf8, 0x05, 0x13, 0x56},
|
||||
},
|
||||
{ /* 35P */
|
||||
addYX: fp.Elt{0xd1, 0xae, 0x92, 0xec, 0x8d, 0x97, 0x0c, 0x10, 0xe5, 0x73, 0x6d, 0x4d, 0x43, 0xd5, 0x43, 0xca, 0x48, 0xba, 0x47, 0xd8, 0x22, 0x1b, 0x13, 0x83, 0x2c, 0x4d, 0x5d, 0xe3, 0x53, 0xec, 0xaa},
|
||||
subYX: fp.Elt{0xd5, 0xc0, 0xb0, 0xe7, 0x28, 0xcc, 0x22, 0x67, 0x53, 0x5c, 0x07, 0xdb, 0xbb, 0xe9, 0x9d, 0x70, 0x61, 0x0a, 0x01, 0xd7, 0xa7, 0x8d, 0xf6, 0xca, 0x6c, 0xcc, 0x57, 0x2c, 0xef, 0x1a, 0x0a, 0x03},
|
||||
dt2: fp.Elt{0xaa, 0xd2, 0x3a, 0x00, 0x73, 0xf7, 0xb1, 0x7b, 0x08, 0x66, 0x21, 0x2b, 0x80, 0x29, 0x3f, 0x0b, 0x3e, 0xd2, 0x0e, 0x52, 0x86, 0xdc, 0x21, 0x78, 0x80, 0x54, 0x06, 0x24, 0x1c, 0x9c, 0xbe, 0x20},
|
||||
},
|
||||
{ /* 37P */
|
||||
addYX: fp.Elt{0xa6, 0x73, 0x96, 0x24, 0xd8, 0x87, 0x53, 0xe1, 0x93, 0xe4, 0x46, 0xf5, 0x2d, 0xbc, 0x43, 0x59, 0xb5, 0x63, 0x6f, 0xc3, 0x81, 0x9a, 0x7f, 0x1c, 0xde, 0xc1, 0x0a, 0x1f, 0x36, 0xb3, 0x0a, 0x75},
|
||||
subYX: fp.Elt{0x60, 0x5e, 0x02, 0xe2, 0x4a, 0xe4, 0xe0, 0x20, 0x38, 0xb9, 0xdc, 0xcb, 0x2f, 0x3b, 0x3b, 0xb0, 0x1c, 0x0d, 0x5a, 0xf9, 0x9c, 0x63, 0x5d, 0x10, 0x11, 0xe3, 0x67, 0x50, 0x54, 0x4c, 0x76, 0x69},
|
||||
dt2: fp.Elt{0x37, 0x10, 0xf8, 0xa2, 0x83, 0x32, 0x8a, 0x1e, 0xf1, 0xcb, 0x7f, 0xbd, 0x23, 0xda, 0x2e, 0x6f, 0x63, 0x25, 0x2e, 0xac, 0x5b, 0xd1, 0x2f, 0xb7, 0x40, 0x50, 0x07, 0xb7, 0x3f, 0x6b, 0xf9, 0x54},
|
||||
},
|
||||
{ /* 39P */
|
||||
addYX: fp.Elt{0x79, 0x92, 0x66, 0x29, 0x04, 0xf2, 0xad, 0x0f, 0x4a, 0x72, 0x7d, 0x7d, 0x04, 0xa2, 0xdd, 0x3a, 0xf1, 0x60, 0x57, 0x8c, 0x82, 0x94, 0x3d, 0x6f, 0x9e, 0x53, 0xb7, 0x2b, 0xc5, 0xe9, 0x7f, 0x3d},
|
||||
subYX: fp.Elt{0xcd, 0x1e, 0xb1, 0x16, 0xc6, 0xaf, 0x7d, 0x17, 0x79, 0x64, 0x57, 0xfa, 0x9c, 0x4b, 0x76, 0x89, 0x85, 0xe7, 0xec, 0xe6, 0x10, 0xa1, 0xa8, 0xb7, 0xf0, 0xdb, 0x85, 0xbe, 0x9f, 0x83, 0xe6, 0x78},
|
||||
dt2: fp.Elt{0x6b, 0x85, 0xb8, 0x37, 0xf7, 0x2d, 0x33, 0x70, 0x8a, 0x17, 0x1a, 0x04, 0x43, 0x5d, 0xd0, 0x75, 0x22, 0x9e, 0xe5, 0xa0, 0x4a, 0xf7, 0x0f, 0x32, 0x42, 0x82, 0x08, 0x50, 0xf3, 0x68, 0xf2, 0x70},
|
||||
},
|
||||
{ /* 41P */
|
||||
addYX: fp.Elt{0x47, 0x5f, 0x80, 0xb1, 0x83, 0x45, 0x86, 0x66, 0x19, 0x7c, 0xdd, 0x60, 0xd1, 0xc5, 0x35, 0xf5, 0x06, 0xb0, 0x4c, 0x1e, 0xb7, 0x4e, 0x87, 0xe9, 0xd9, 0x89, 0xd8, 0xfa, 0x5c, 0x34, 0x0d, 0x7c},
|
||||
subYX: fp.Elt{0x55, 0xf3, 0xdc, 0x70, 0x20, 0x11, 0x24, 0x23, 0x17, 0xe1, 0xfc, 0xe7, 0x7e, 0xc9, 0x0c, 0x38, 0x98, 0xb6, 0x52, 0x35, 0xed, 0xde, 0x1d, 0xb3, 0xb9, 0xc4, 0xb8, 0x39, 0xc0, 0x56, 0x4e, 0x40},
|
||||
dt2: fp.Elt{0x8a, 0x33, 0x78, 0x8c, 0x4b, 0x1f, 0x1f, 0x59, 0xe1, 0xb5, 0xe0, 0x67, 0xb1, 0x6a, 0x36, 0xa0, 0x44, 0x3d, 0x5f, 0xb4, 0x52, 0x41, 0xbc, 0x5c, 0x77, 0xc7, 0xae, 0x2a, 0x76, 0x54, 0xd7, 0x20},
|
||||
},
|
||||
{ /* 43P */
|
||||
addYX: fp.Elt{0x58, 0xb7, 0x3b, 0xc7, 0x6f, 0xc3, 0x8f, 0x5e, 0x9a, 0xbb, 0x3c, 0x36, 0xa5, 0x43, 0xe5, 0xac, 0x22, 0xc9, 0x3b, 0x90, 0x7d, 0x4a, 0x93, 0xa9, 0x62, 0xec, 0xce, 0xf3, 0x46, 0x1e, 0x8f, 0x2b},
|
||||
subYX: fp.Elt{0x43, 0xf5, 0xb9, 0x35, 0xb1, 0xfe, 0x74, 0x9d, 0x6c, 0x95, 0x8c, 0xde, 0xf1, 0x7d, 0xb3, 0x84, 0xa9, 0x8b, 0x13, 0x57, 0x07, 0x2b, 0x32, 0xe9, 0xe1, 0x4c, 0x0b, 0x79, 0xa8, 0xad, 0xb8, 0x38},
|
||||
dt2: fp.Elt{0x5d, 0xf9, 0x51, 0xdf, 0x9c, 0x4a, 0xc0, 0xb5, 0xac, 0xde, 0x1f, 0xcb, 0xae, 0x52, 0x39, 0x2b, 0xda, 0x66, 0x8b, 0x32, 0x8b, 0x6d, 0x10, 0x1d, 0x53, 0x19, 0xba, 0xce, 0x32, 0xeb, 0x9a, 0x04},
|
||||
},
|
||||
{ /* 45P */
|
||||
addYX: fp.Elt{0x31, 0x79, 0xfc, 0x75, 0x0b, 0x7d, 0x50, 0xaa, 0xd3, 0x25, 0x67, 0x7a, 0x4b, 0x92, 0xef, 0x0f, 0x30, 0x39, 0x6b, 0x39, 0x2b, 0x54, 0x82, 0x1d, 0xfc, 0x74, 0xf6, 0x30, 0x75, 0xe1, 0x5e, 0x79},
|
||||
subYX: fp.Elt{0x7e, 0xfe, 0xdc, 0x63, 0x3c, 0x7d, 0x76, 0xd7, 0x40, 0x6e, 0x85, 0x97, 0x48, 0x59, 0x9c, 0x20, 0x13, 0x7c, 0x4f, 0xe1, 0x61, 0x68, 0x67, 0xb6, 0xfc, 0x25, 0xd6, 0xc8, 0xe0, 0x65, 0xc6, 0x51},
|
||||
dt2: fp.Elt{0x81, 0xbd, 0xec, 0x52, 0x0a, 0x5b, 0x4a, 0x25, 0xe7, 0xaf, 0x34, 0xe0, 0x6e, 0x1f, 0x41, 0x5d, 0x31, 0x4a, 0xee, 0xca, 0x0d, 0x4d, 0xa2, 0xe6, 0x77, 0x44, 0xc5, 0x9d, 0xf4, 0x9b, 0xd1, 0x6c},
|
||||
},
|
||||
{ /* 47P */
|
||||
addYX: fp.Elt{0x86, 0xc3, 0xaf, 0x65, 0x21, 0x61, 0xfe, 0x1f, 0x10, 0x1b, 0xd5, 0xb8, 0x88, 0x2a, 0x2a, 0x08, 0xaa, 0x0b, 0x99, 0x20, 0x7e, 0x62, 0xf6, 0x76, 0xe7, 0x43, 0x9e, 0x42, 0xa7, 0xb3, 0x01, 0x5e},
|
||||
subYX: fp.Elt{0xa3, 0x9c, 0x17, 0x52, 0x90, 0x61, 0x87, 0x7e, 0x85, 0x9f, 0x2c, 0x0b, 0x06, 0x0a, 0x1d, 0x57, 0x1e, 0x71, 0x99, 0x84, 0xa8, 0xba, 0xa2, 0x80, 0x38, 0xe6, 0xb2, 0x40, 0xdb, 0xf3, 0x20, 0x75},
|
||||
dt2: fp.Elt{0xa1, 0x57, 0x93, 0xd3, 0xe3, 0x0b, 0xb5, 0x3d, 0xa5, 0x94, 0x9e, 0x59, 0xdd, 0x6c, 0x7b, 0x96, 0x6e, 0x1e, 0x31, 0xdf, 0x64, 0x9a, 0x30, 0x1a, 0x86, 0xc9, 0xf3, 0xce, 0x9c, 0x2c, 0x09, 0x71},
|
||||
},
|
||||
{ /* 49P */
|
||||
addYX: fp.Elt{0xcf, 0x1d, 0x05, 0x74, 0xac, 0xd8, 0x6b, 0x85, 0x1e, 0xaa, 0xb7, 0x55, 0x08, 0xa4, 0xf6, 0x03, 0xeb, 0x3c, 0x74, 0xc9, 0xcb, 0xe7, 0x4a, 0x3a, 0xde, 0xab, 0x37, 0x71, 0xbb, 0xa5, 0x73, 0x41},
|
||||
subYX: fp.Elt{0x8c, 0x91, 0x64, 0x03, 0x3f, 0x52, 0xd8, 0x53, 0x1c, 0x6b, 0xab, 0x3f, 0xf4, 0x04, 0xb4, 0xa2, 0xa4, 0xe5, 0x81, 0x66, 0x9e, 0x4a, 0x0b, 0x08, 0xa7, 0x7b, 0x25, 0xd0, 0x03, 0x5b, 0xa1, 0x0e},
|
||||
dt2: fp.Elt{0x8a, 0x21, 0xf9, 0xf0, 0x31, 0x6e, 0xc5, 0x17, 0x08, 0x47, 0xfc, 0x1a, 0x2b, 0x6e, 0x69, 0x5a, 0x76, 0xf1, 0xb2, 0xf4, 0x68, 0x16, 0x93, 0xf7, 0x67, 0x3a, 0x4e, 0x4a, 0x61, 0x65, 0xc5, 0x5f},
|
||||
},
|
||||
{ /* 51P */
|
||||
addYX: fp.Elt{0x8e, 0x98, 0x90, 0x77, 0xe6, 0xe1, 0x92, 0x48, 0x22, 0xd7, 0x5c, 0x1c, 0x0f, 0x95, 0xd5, 0x01, 0xed, 0x3e, 0x92, 0xe5, 0x9a, 0x81, 0xb0, 0xe3, 0x1b, 0x65, 0x46, 0x9d, 0x40, 0xc7, 0x14, 0x32},
|
||||
subYX: fp.Elt{0xe5, 0x7a, 0x6d, 0xc4, 0x0d, 0x57, 0x6e, 0x13, 0x8f, 0xdc, 0xf8, 0x54, 0xcc, 0xaa, 0xd0, 0x0f, 0x86, 0xad, 0x0d, 0x31, 0x03, 0x9f, 0x54, 0x59, 0xa1, 0x4a, 0x45, 0x4c, 0x41, 0x1c, 0x71, 0x62},
|
||||
dt2: fp.Elt{0x70, 0x17, 0x65, 0x06, 0x74, 0x82, 0x29, 0x13, 0x36, 0x94, 0x27, 0x8a, 0x66, 0xa0, 0xa4, 0x3b, 0x3c, 0x22, 0x5d, 0x18, 0xec, 0xb8, 0xb6, 0xd9, 0x3c, 0x83, 0xcb, 0x3e, 0x07, 0x94, 0xea, 0x5b},
|
||||
},
|
||||
{ /* 53P */
|
||||
addYX: fp.Elt{0xf8, 0xd2, 0x43, 0xf3, 0x63, 0xce, 0x70, 0xb4, 0xf1, 0xe8, 0x43, 0x05, 0x8f, 0xba, 0x67, 0x00, 0x6f, 0x7b, 0x11, 0xa2, 0xa1, 0x51, 0xda, 0x35, 0x2f, 0xbd, 0xf1, 0x44, 0x59, 0x78, 0xd0, 0x4a},
|
||||
subYX: fp.Elt{0xe4, 0x9b, 0xc8, 0x12, 0x09, 0xbf, 0x1d, 0x64, 0x9c, 0x57, 0x6e, 0x7d, 0x31, 0x8b, 0xf3, 0xac, 0x65, 0xb0, 0x97, 0xf6, 0x02, 0x9e, 0xfe, 0xab, 0xec, 0x1e, 0xf6, 0x48, 0xc1, 0xd5, 0xac, 0x3a},
|
||||
dt2: fp.Elt{0x01, 0x83, 0x31, 0xc3, 0x34, 0x3b, 0x8e, 0x85, 0x26, 0x68, 0x31, 0x07, 0x47, 0xc0, 0x99, 0xdc, 0x8c, 0xa8, 0x9d, 0xd3, 0x2e, 0x5b, 0x08, 0x34, 0x3d, 0x85, 0x02, 0xd9, 0xb1, 0x0c, 0xff, 0x3a},
|
||||
},
|
||||
{ /* 55P */
|
||||
addYX: fp.Elt{0x05, 0x35, 0xc5, 0xf4, 0x0b, 0x43, 0x26, 0x92, 0x83, 0x22, 0x1f, 0x26, 0x13, 0x9c, 0xe4, 0x68, 0xc6, 0x27, 0xd3, 0x8f, 0x78, 0x33, 0xef, 0x09, 0x7f, 0x9e, 0xd9, 0x2b, 0x73, 0x9f, 0xcf, 0x2c},
|
||||
subYX: fp.Elt{0x5e, 0x40, 0x20, 0x3a, 0xeb, 0xc7, 0xc5, 0x87, 0xc9, 0x56, 0xad, 0xed, 0xef, 0x11, 0xe3, 0x8e, 0xf9, 0xd5, 0x29, 0xad, 0x48, 0x2e, 0x25, 0x29, 0x1d, 0x25, 0xcd, 0xf4, 0x86, 0x7e, 0x0e, 0x11},
|
||||
dt2: fp.Elt{0xe4, 0xf5, 0x03, 0xd6, 0x9e, 0xd8, 0xc0, 0x57, 0x0c, 0x20, 0xb0, 0xf0, 0x28, 0x86, 0x88, 0x12, 0xb7, 0x3b, 0x2e, 0xa0, 0x09, 0x27, 0x17, 0x53, 0x37, 0x3a, 0x69, 0xb9, 0xe0, 0x57, 0xc5, 0x05},
|
||||
},
|
||||
{ /* 57P */
|
||||
addYX: fp.Elt{0xb0, 0x0e, 0xc2, 0x89, 0xb0, 0xbb, 0x76, 0xf7, 0x5c, 0xd8, 0x0f, 0xfa, 0xf6, 0x5b, 0xf8, 0x61, 0xfb, 0x21, 0x44, 0x63, 0x4e, 0x3f, 0xb9, 0xb6, 0x05, 0x12, 0x86, 0x41, 0x08, 0xef, 0x9f, 0x28},
|
||||
subYX: fp.Elt{0x6f, 0x7e, 0xc9, 0x1f, 0x31, 0xce, 0xf9, 0xd8, 0xae, 0xfd, 0xf9, 0x11, 0x30, 0x26, 0x3f, 0x7a, 0xdd, 0x25, 0xed, 0x8b, 0xa0, 0x7e, 0x5b, 0xe1, 0x5a, 0x87, 0xe9, 0x8f, 0x17, 0x4c, 0x15, 0x6e},
|
||||
dt2: fp.Elt{0xbf, 0x9a, 0xd6, 0xfe, 0x36, 0x63, 0x61, 0xcf, 0x4f, 0xc9, 0x35, 0x83, 0xe7, 0xe4, 0x16, 0x9b, 0xe7, 0x7f, 0x3a, 0x75, 0x65, 0x97, 0x78, 0x13, 0x19, 0xa3, 0x5c, 0xa9, 0x42, 0xf6, 0xfb, 0x6a},
|
||||
},
|
||||
{ /* 59P */
|
||||
addYX: fp.Elt{0xcc, 0xa8, 0x13, 0xf9, 0x70, 0x50, 0xe5, 0x5d, 0x61, 0xf5, 0x0c, 0x2b, 0x7b, 0x16, 0x1d, 0x7d, 0x89, 0xd4, 0xea, 0x90, 0xb6, 0x56, 0x29, 0xda, 0xd9, 0x1e, 0x80, 0xdb, 0xce, 0x93, 0xc0, 0x12},
|
||||
subYX: fp.Elt{0xc1, 0xd2, 0xf5, 0x62, 0x0c, 0xde, 0xa8, 0x7d, 0x9a, 0x7b, 0x0e, 0xb0, 0xa4, 0x3d, 0xfc, 0x98, 0xe0, 0x70, 0xad, 0x0d, 0xda, 0x6a, 0xeb, 0x7d, 0xc4, 0x38, 0x50, 0xb9, 0x51, 0xb8, 0xb4, 0x0d},
|
||||
dt2: fp.Elt{0x0f, 0x19, 0xb8, 0x08, 0x93, 0x7f, 0x14, 0xfc, 0x10, 0xe3, 0x1a, 0xa1, 0xa0, 0x9d, 0x96, 0x06, 0xfd, 0xd7, 0xc7, 0xda, 0x72, 0x55, 0xe7, 0xce, 0xe6, 0x5c, 0x63, 0xc6, 0x99, 0x87, 0xaa, 0x33},
|
||||
},
|
||||
{ /* 61P */
|
||||
addYX: fp.Elt{0xb1, 0x6c, 0x15, 0xfc, 0x88, 0xf5, 0x48, 0x83, 0x27, 0x6d, 0x0a, 0x1a, 0x9b, 0xba, 0xa2, 0x6d, 0xb6, 0x5a, 0xca, 0x87, 0x5c, 0x2d, 0x26, 0xe2, 0xa6, 0x89, 0xd5, 0xc8, 0xc1, 0xd0, 0x2c, 0x21},
|
||||
subYX: fp.Elt{0xf2, 0x5c, 0x08, 0xbd, 0x1e, 0xf5, 0x0f, 0xaf, 0x1f, 0x3f, 0xd3, 0x67, 0x89, 0x1a, 0xf5, 0x78, 0x3c, 0x03, 0x60, 0x50, 0xe1, 0xbf, 0xc2, 0x6e, 0x86, 0x1a, 0xe2, 0xe8, 0x29, 0x6f, 0x3c, 0x23},
|
||||
dt2: fp.Elt{0x81, 0xc7, 0x18, 0x7f, 0x10, 0xd5, 0xf4, 0xd2, 0x28, 0x9d, 0x7e, 0x52, 0xf2, 0xcd, 0x2e, 0x12, 0x41, 0x33, 0x3d, 0x3d, 0x2a, 0x86, 0x0a, 0xa7, 0xe3, 0x4c, 0x91, 0x11, 0x89, 0x77, 0xb7, 0x1d},
|
||||
},
|
||||
{ /* 63P */
|
||||
addYX: fp.Elt{0xb6, 0x1a, 0x70, 0xdd, 0x69, 0x47, 0x39, 0xb3, 0xa5, 0x8d, 0xcf, 0x19, 0xd4, 0xde, 0xb8, 0xe2, 0x52, 0xc8, 0x2a, 0xfd, 0x61, 0x41, 0xdf, 0x15, 0xbe, 0x24, 0x7d, 0x01, 0x8a, 0xca, 0xe2, 0x7a},
|
||||
subYX: fp.Elt{0x6f, 0xc2, 0x6b, 0x7c, 0x39, 0x52, 0xf3, 0xdd, 0x13, 0x01, 0xd5, 0x53, 0xcc, 0xe2, 0x97, 0x7a, 0x30, 0xa3, 0x79, 0xbf, 0x3a, 0xf4, 0x74, 0x7c, 0xfc, 0xad, 0xe2, 0x26, 0xad, 0x97, 0xad, 0x31},
|
||||
dt2: fp.Elt{0x62, 0xb9, 0x20, 0x09, 0xed, 0x17, 0xe8, 0xb7, 0x9d, 0xda, 0x19, 0x3f, 0xcc, 0x18, 0x85, 0x1e, 0x64, 0x0a, 0x56, 0x25, 0x4f, 0xc1, 0x91, 0xe4, 0x83, 0x2c, 0x62, 0xa6, 0x53, 0xfc, 0xd1, 0x1e},
|
||||
},
|
||||
}
|
||||
411
vendor/github.com/cloudflare/circl/sign/ed448/ed448.go
generated
vendored
Normal file
411
vendor/github.com/cloudflare/circl/sign/ed448/ed448.go
generated
vendored
Normal file
@ -0,0 +1,411 @@
|
||||
// Package ed448 implements Ed448 signature scheme as described in RFC-8032.
|
||||
//
|
||||
// This package implements two signature variants.
|
||||
//
|
||||
// | Scheme Name | Sign Function | Verification | Context |
|
||||
// |-------------|-------------------|---------------|-------------------|
|
||||
// | Ed448 | Sign | Verify | Yes, can be empty |
|
||||
// | Ed448Ph | SignPh | VerifyPh | Yes, can be empty |
|
||||
// | All above | (PrivateKey).Sign | VerifyAny | As above |
|
||||
//
|
||||
// Specific functions for sign and verify are defined. A generic signing
|
||||
// function for all schemes is available through the crypto.Signer interface,
|
||||
// which is implemented by the PrivateKey type. A correspond all-in-one
|
||||
// verification method is provided by the VerifyAny function.
|
||||
//
|
||||
// Both schemes require a context string for domain separation. This parameter
|
||||
// is passed using a SignerOptions struct defined in this package.
|
||||
//
|
||||
// References:
|
||||
//
|
||||
// - RFC8032: https://rfc-editor.org/rfc/rfc8032.txt
|
||||
// - EdDSA for more curves: https://eprint.iacr.org/2015/677
|
||||
// - High-speed high-security signatures: https://doi.org/10.1007/s13389-012-0027-1
|
||||
package ed448
|
||||
|
||||
import (
|
||||
"bytes"
|
||||
"crypto"
|
||||
cryptoRand "crypto/rand"
|
||||
"crypto/subtle"
|
||||
"errors"
|
||||
"fmt"
|
||||
"io"
|
||||
"strconv"
|
||||
|
||||
"github.com/cloudflare/circl/ecc/goldilocks"
|
||||
"github.com/cloudflare/circl/internal/sha3"
|
||||
"github.com/cloudflare/circl/sign"
|
||||
)
|
||||
|
||||
const (
|
||||
// ContextMaxSize is the maximum length (in bytes) allowed for context.
|
||||
ContextMaxSize = 255
|
||||
// PublicKeySize is the length in bytes of Ed448 public keys.
|
||||
PublicKeySize = 57
|
||||
// PrivateKeySize is the length in bytes of Ed448 private keys.
|
||||
PrivateKeySize = 114
|
||||
// SignatureSize is the length in bytes of signatures.
|
||||
SignatureSize = 114
|
||||
// SeedSize is the size, in bytes, of private key seeds. These are the private key representations used by RFC 8032.
|
||||
SeedSize = 57
|
||||
)
|
||||
|
||||
const (
|
||||
paramB = 456 / 8 // Size of keys in bytes.
|
||||
hashSize = 2 * paramB // Size of the hash function's output.
|
||||
)
|
||||
|
||||
// SignerOptions implements crypto.SignerOpts and augments with parameters
|
||||
// that are specific to the Ed448 signature schemes.
|
||||
type SignerOptions struct {
|
||||
// Hash must be crypto.Hash(0) for both Ed448 and Ed448Ph.
|
||||
crypto.Hash
|
||||
|
||||
// Context is an optional domain separation string for signing.
|
||||
// Its length must be less or equal than 255 bytes.
|
||||
Context string
|
||||
|
||||
// Scheme is an identifier for choosing a signature scheme.
|
||||
Scheme SchemeID
|
||||
}
|
||||
|
||||
// SchemeID is an identifier for each signature scheme.
|
||||
type SchemeID uint
|
||||
|
||||
const (
|
||||
ED448 SchemeID = iota
|
||||
ED448Ph
|
||||
)
|
||||
|
||||
// PublicKey is the type of Ed448 public keys.
|
||||
type PublicKey []byte
|
||||
|
||||
// Equal reports whether pub and x have the same value.
|
||||
func (pub PublicKey) Equal(x crypto.PublicKey) bool {
|
||||
xx, ok := x.(PublicKey)
|
||||
return ok && bytes.Equal(pub, xx)
|
||||
}
|
||||
|
||||
// PrivateKey is the type of Ed448 private keys. It implements crypto.Signer.
|
||||
type PrivateKey []byte
|
||||
|
||||
// Equal reports whether priv and x have the same value.
|
||||
func (priv PrivateKey) Equal(x crypto.PrivateKey) bool {
|
||||
xx, ok := x.(PrivateKey)
|
||||
return ok && subtle.ConstantTimeCompare(priv, xx) == 1
|
||||
}
|
||||
|
||||
// Public returns the PublicKey corresponding to priv.
|
||||
func (priv PrivateKey) Public() crypto.PublicKey {
|
||||
publicKey := make([]byte, PublicKeySize)
|
||||
copy(publicKey, priv[SeedSize:])
|
||||
return PublicKey(publicKey)
|
||||
}
|
||||
|
||||
// Seed returns the private key seed corresponding to priv. It is provided for
|
||||
// interoperability with RFC 8032. RFC 8032's private keys correspond to seeds
|
||||
// in this package.
|
||||
func (priv PrivateKey) Seed() []byte {
|
||||
seed := make([]byte, SeedSize)
|
||||
copy(seed, priv[:SeedSize])
|
||||
return seed
|
||||
}
|
||||
|
||||
func (priv PrivateKey) Scheme() sign.Scheme { return sch }
|
||||
|
||||
func (pub PublicKey) Scheme() sign.Scheme { return sch }
|
||||
|
||||
func (priv PrivateKey) MarshalBinary() (data []byte, err error) {
|
||||
privateKey := make(PrivateKey, PrivateKeySize)
|
||||
copy(privateKey, priv)
|
||||
return privateKey, nil
|
||||
}
|
||||
|
||||
func (pub PublicKey) MarshalBinary() (data []byte, err error) {
|
||||
publicKey := make(PublicKey, PublicKeySize)
|
||||
copy(publicKey, pub)
|
||||
return publicKey, nil
|
||||
}
|
||||
|
||||
// Sign creates a signature of a message given a key pair.
|
||||
// This function supports all the two signature variants defined in RFC-8032,
|
||||
// namely Ed448 (or pure EdDSA) and Ed448Ph.
|
||||
// The opts.HashFunc() must return zero to the specify Ed448 variant. This can
|
||||
// be achieved by passing crypto.Hash(0) as the value for opts.
|
||||
// Use an Options struct to pass a bool indicating that the ed448Ph variant
|
||||
// should be used.
|
||||
// The struct can also be optionally used to pass a context string for signing.
|
||||
func (priv PrivateKey) Sign(
|
||||
rand io.Reader,
|
||||
message []byte,
|
||||
opts crypto.SignerOpts,
|
||||
) (signature []byte, err error) {
|
||||
var ctx string
|
||||
var scheme SchemeID
|
||||
|
||||
if o, ok := opts.(SignerOptions); ok {
|
||||
ctx = o.Context
|
||||
scheme = o.Scheme
|
||||
}
|
||||
|
||||
switch true {
|
||||
case scheme == ED448 && opts.HashFunc() == crypto.Hash(0):
|
||||
return Sign(priv, message, ctx), nil
|
||||
case scheme == ED448Ph && opts.HashFunc() == crypto.Hash(0):
|
||||
return SignPh(priv, message, ctx), nil
|
||||
default:
|
||||
return nil, errors.New("ed448: bad hash algorithm")
|
||||
}
|
||||
}
|
||||
|
||||
// GenerateKey generates a public/private key pair using entropy from rand.
|
||||
// If rand is nil, crypto/rand.Reader will be used.
|
||||
func GenerateKey(rand io.Reader) (PublicKey, PrivateKey, error) {
|
||||
if rand == nil {
|
||||
rand = cryptoRand.Reader
|
||||
}
|
||||
|
||||
seed := make(PrivateKey, SeedSize)
|
||||
if _, err := io.ReadFull(rand, seed); err != nil {
|
||||
return nil, nil, err
|
||||
}
|
||||
|
||||
privateKey := NewKeyFromSeed(seed)
|
||||
publicKey := make([]byte, PublicKeySize)
|
||||
copy(publicKey, privateKey[SeedSize:])
|
||||
|
||||
return publicKey, privateKey, nil
|
||||
}
|
||||
|
||||
// NewKeyFromSeed calculates a private key from a seed. It will panic if
|
||||
// len(seed) is not SeedSize. This function is provided for interoperability
|
||||
// with RFC 8032. RFC 8032's private keys correspond to seeds in this
|
||||
// package.
|
||||
func NewKeyFromSeed(seed []byte) PrivateKey {
|
||||
privateKey := make([]byte, PrivateKeySize)
|
||||
newKeyFromSeed(privateKey, seed)
|
||||
return privateKey
|
||||
}
|
||||
|
||||
func newKeyFromSeed(privateKey, seed []byte) {
|
||||
if l := len(seed); l != SeedSize {
|
||||
panic("ed448: bad seed length: " + strconv.Itoa(l))
|
||||
}
|
||||
|
||||
var h [hashSize]byte
|
||||
H := sha3.NewShake256()
|
||||
_, _ = H.Write(seed)
|
||||
_, _ = H.Read(h[:])
|
||||
s := &goldilocks.Scalar{}
|
||||
deriveSecretScalar(s, h[:paramB])
|
||||
|
||||
copy(privateKey[:SeedSize], seed)
|
||||
_ = goldilocks.Curve{}.ScalarBaseMult(s).ToBytes(privateKey[SeedSize:])
|
||||
}
|
||||
|
||||
func signAll(signature []byte, privateKey PrivateKey, message, ctx []byte, preHash bool) {
|
||||
if len(ctx) > ContextMaxSize {
|
||||
panic(fmt.Errorf("ed448: bad context length: " + strconv.Itoa(len(ctx))))
|
||||
}
|
||||
|
||||
H := sha3.NewShake256()
|
||||
var PHM []byte
|
||||
|
||||
if preHash {
|
||||
var h [64]byte
|
||||
_, _ = H.Write(message)
|
||||
_, _ = H.Read(h[:])
|
||||
PHM = h[:]
|
||||
H.Reset()
|
||||
} else {
|
||||
PHM = message
|
||||
}
|
||||
|
||||
// 1. Hash the 57-byte private key using SHAKE256(x, 114).
|
||||
var h [hashSize]byte
|
||||
_, _ = H.Write(privateKey[:SeedSize])
|
||||
_, _ = H.Read(h[:])
|
||||
s := &goldilocks.Scalar{}
|
||||
deriveSecretScalar(s, h[:paramB])
|
||||
prefix := h[paramB:]
|
||||
|
||||
// 2. Compute SHAKE256(dom4(F, C) || prefix || PH(M), 114).
|
||||
var rPM [hashSize]byte
|
||||
H.Reset()
|
||||
|
||||
writeDom(&H, ctx, preHash)
|
||||
|
||||
_, _ = H.Write(prefix)
|
||||
_, _ = H.Write(PHM)
|
||||
_, _ = H.Read(rPM[:])
|
||||
|
||||
// 3. Compute the point [r]B.
|
||||
r := &goldilocks.Scalar{}
|
||||
r.FromBytes(rPM[:])
|
||||
R := (&[paramB]byte{})[:]
|
||||
if err := (goldilocks.Curve{}.ScalarBaseMult(r).ToBytes(R)); err != nil {
|
||||
panic(err)
|
||||
}
|
||||
// 4. Compute SHAKE256(dom4(F, C) || R || A || PH(M), 114)
|
||||
var hRAM [hashSize]byte
|
||||
H.Reset()
|
||||
|
||||
writeDom(&H, ctx, preHash)
|
||||
|
||||
_, _ = H.Write(R)
|
||||
_, _ = H.Write(privateKey[SeedSize:])
|
||||
_, _ = H.Write(PHM)
|
||||
_, _ = H.Read(hRAM[:])
|
||||
|
||||
// 5. Compute S = (r + k * s) mod order.
|
||||
k := &goldilocks.Scalar{}
|
||||
k.FromBytes(hRAM[:])
|
||||
S := &goldilocks.Scalar{}
|
||||
S.Mul(k, s)
|
||||
S.Add(S, r)
|
||||
|
||||
// 6. The signature is the concatenation of R and S.
|
||||
copy(signature[:paramB], R[:])
|
||||
copy(signature[paramB:], S[:])
|
||||
}
|
||||
|
||||
// Sign signs the message with privateKey and returns a signature.
|
||||
// This function supports the signature variant defined in RFC-8032: Ed448,
|
||||
// also known as the pure version of EdDSA.
|
||||
// It will panic if len(privateKey) is not PrivateKeySize.
|
||||
func Sign(priv PrivateKey, message []byte, ctx string) []byte {
|
||||
signature := make([]byte, SignatureSize)
|
||||
signAll(signature, priv, message, []byte(ctx), false)
|
||||
return signature
|
||||
}
|
||||
|
||||
// SignPh creates a signature of a message given a keypair.
|
||||
// This function supports the signature variant defined in RFC-8032: Ed448ph,
|
||||
// meaning it internally hashes the message using SHAKE-256.
|
||||
// Context could be passed to this function, which length should be no more than
|
||||
// 255. It can be empty.
|
||||
func SignPh(priv PrivateKey, message []byte, ctx string) []byte {
|
||||
signature := make([]byte, SignatureSize)
|
||||
signAll(signature, priv, message, []byte(ctx), true)
|
||||
return signature
|
||||
}
|
||||
|
||||
func verify(public PublicKey, message, signature, ctx []byte, preHash bool) bool {
|
||||
if len(public) != PublicKeySize ||
|
||||
len(signature) != SignatureSize ||
|
||||
len(ctx) > ContextMaxSize ||
|
||||
!isLessThanOrder(signature[paramB:]) {
|
||||
return false
|
||||
}
|
||||
|
||||
P, err := goldilocks.FromBytes(public)
|
||||
if err != nil {
|
||||
return false
|
||||
}
|
||||
|
||||
H := sha3.NewShake256()
|
||||
var PHM []byte
|
||||
|
||||
if preHash {
|
||||
var h [64]byte
|
||||
_, _ = H.Write(message)
|
||||
_, _ = H.Read(h[:])
|
||||
PHM = h[:]
|
||||
H.Reset()
|
||||
} else {
|
||||
PHM = message
|
||||
}
|
||||
|
||||
var hRAM [hashSize]byte
|
||||
R := signature[:paramB]
|
||||
|
||||
writeDom(&H, ctx, preHash)
|
||||
|
||||
_, _ = H.Write(R)
|
||||
_, _ = H.Write(public)
|
||||
_, _ = H.Write(PHM)
|
||||
_, _ = H.Read(hRAM[:])
|
||||
|
||||
k := &goldilocks.Scalar{}
|
||||
k.FromBytes(hRAM[:])
|
||||
S := &goldilocks.Scalar{}
|
||||
S.FromBytes(signature[paramB:])
|
||||
|
||||
encR := (&[paramB]byte{})[:]
|
||||
P.Neg()
|
||||
_ = goldilocks.Curve{}.CombinedMult(S, k, P).ToBytes(encR)
|
||||
return bytes.Equal(R, encR)
|
||||
}
|
||||
|
||||
// VerifyAny returns true if the signature is valid. Failure cases are invalid
|
||||
// signature, or when the public key cannot be decoded.
|
||||
// This function supports all the two signature variants defined in RFC-8032,
|
||||
// namely Ed448 (or pure EdDSA) and Ed448Ph.
|
||||
// The opts.HashFunc() must return zero, this can be achieved by passing
|
||||
// crypto.Hash(0) as the value for opts.
|
||||
// Use a SignerOptions struct to pass a context string for signing.
|
||||
func VerifyAny(public PublicKey, message, signature []byte, opts crypto.SignerOpts) bool {
|
||||
var ctx string
|
||||
var scheme SchemeID
|
||||
if o, ok := opts.(SignerOptions); ok {
|
||||
ctx = o.Context
|
||||
scheme = o.Scheme
|
||||
}
|
||||
|
||||
switch true {
|
||||
case scheme == ED448 && opts.HashFunc() == crypto.Hash(0):
|
||||
return Verify(public, message, signature, ctx)
|
||||
case scheme == ED448Ph && opts.HashFunc() == crypto.Hash(0):
|
||||
return VerifyPh(public, message, signature, ctx)
|
||||
default:
|
||||
return false
|
||||
}
|
||||
}
|
||||
|
||||
// Verify returns true if the signature is valid. Failure cases are invalid
|
||||
// signature, or when the public key cannot be decoded.
|
||||
// This function supports the signature variant defined in RFC-8032: Ed448,
|
||||
// also known as the pure version of EdDSA.
|
||||
func Verify(public PublicKey, message, signature []byte, ctx string) bool {
|
||||
return verify(public, message, signature, []byte(ctx), false)
|
||||
}
|
||||
|
||||
// VerifyPh returns true if the signature is valid. Failure cases are invalid
|
||||
// signature, or when the public key cannot be decoded.
|
||||
// This function supports the signature variant defined in RFC-8032: Ed448ph,
|
||||
// meaning it internally hashes the message using SHAKE-256.
|
||||
// Context could be passed to this function, which length should be no more than
|
||||
// 255. It can be empty.
|
||||
func VerifyPh(public PublicKey, message, signature []byte, ctx string) bool {
|
||||
return verify(public, message, signature, []byte(ctx), true)
|
||||
}
|
||||
|
||||
func deriveSecretScalar(s *goldilocks.Scalar, h []byte) {
|
||||
h[0] &= 0xFC // The two least significant bits of the first octet are cleared,
|
||||
h[paramB-1] = 0x00 // all eight bits the last octet are cleared, and
|
||||
h[paramB-2] |= 0x80 // the highest bit of the second to last octet is set.
|
||||
s.FromBytes(h[:paramB])
|
||||
}
|
||||
|
||||
// isLessThanOrder returns true if 0 <= x < order and if the last byte of x is zero.
|
||||
func isLessThanOrder(x []byte) bool {
|
||||
order := goldilocks.Curve{}.Order()
|
||||
i := len(order) - 1
|
||||
for i > 0 && x[i] == order[i] {
|
||||
i--
|
||||
}
|
||||
return x[paramB-1] == 0 && x[i] < order[i]
|
||||
}
|
||||
|
||||
func writeDom(h io.Writer, ctx []byte, preHash bool) {
|
||||
dom4 := "SigEd448"
|
||||
_, _ = h.Write([]byte(dom4))
|
||||
|
||||
if preHash {
|
||||
_, _ = h.Write([]byte{byte(0x01), byte(len(ctx))})
|
||||
} else {
|
||||
_, _ = h.Write([]byte{byte(0x00), byte(len(ctx))})
|
||||
}
|
||||
_, _ = h.Write(ctx)
|
||||
}
|
||||
87
vendor/github.com/cloudflare/circl/sign/ed448/signapi.go
generated
vendored
Normal file
87
vendor/github.com/cloudflare/circl/sign/ed448/signapi.go
generated
vendored
Normal file
@ -0,0 +1,87 @@
|
||||
package ed448
|
||||
|
||||
import (
|
||||
"crypto/rand"
|
||||
"encoding/asn1"
|
||||
|
||||
"github.com/cloudflare/circl/sign"
|
||||
)
|
||||
|
||||
var sch sign.Scheme = &scheme{}
|
||||
|
||||
// Scheme returns a signature interface.
|
||||
func Scheme() sign.Scheme { return sch }
|
||||
|
||||
type scheme struct{}
|
||||
|
||||
func (*scheme) Name() string { return "Ed448" }
|
||||
func (*scheme) PublicKeySize() int { return PublicKeySize }
|
||||
func (*scheme) PrivateKeySize() int { return PrivateKeySize }
|
||||
func (*scheme) SignatureSize() int { return SignatureSize }
|
||||
func (*scheme) SeedSize() int { return SeedSize }
|
||||
func (*scheme) TLSIdentifier() uint { return 0x0808 }
|
||||
func (*scheme) SupportsContext() bool { return true }
|
||||
func (*scheme) Oid() asn1.ObjectIdentifier {
|
||||
return asn1.ObjectIdentifier{1, 3, 101, 113}
|
||||
}
|
||||
|
||||
func (*scheme) GenerateKey() (sign.PublicKey, sign.PrivateKey, error) {
|
||||
return GenerateKey(rand.Reader)
|
||||
}
|
||||
|
||||
func (*scheme) Sign(
|
||||
sk sign.PrivateKey,
|
||||
message []byte,
|
||||
opts *sign.SignatureOpts,
|
||||
) []byte {
|
||||
priv, ok := sk.(PrivateKey)
|
||||
if !ok {
|
||||
panic(sign.ErrTypeMismatch)
|
||||
}
|
||||
ctx := ""
|
||||
if opts != nil {
|
||||
ctx = opts.Context
|
||||
}
|
||||
return Sign(priv, message, ctx)
|
||||
}
|
||||
|
||||
func (*scheme) Verify(
|
||||
pk sign.PublicKey,
|
||||
message, signature []byte,
|
||||
opts *sign.SignatureOpts,
|
||||
) bool {
|
||||
pub, ok := pk.(PublicKey)
|
||||
if !ok {
|
||||
panic(sign.ErrTypeMismatch)
|
||||
}
|
||||
ctx := ""
|
||||
if opts != nil {
|
||||
ctx = opts.Context
|
||||
}
|
||||
return Verify(pub, message, signature, ctx)
|
||||
}
|
||||
|
||||
func (*scheme) DeriveKey(seed []byte) (sign.PublicKey, sign.PrivateKey) {
|
||||
privateKey := NewKeyFromSeed(seed)
|
||||
publicKey := make(PublicKey, PublicKeySize)
|
||||
copy(publicKey, privateKey[SeedSize:])
|
||||
return publicKey, privateKey
|
||||
}
|
||||
|
||||
func (*scheme) UnmarshalBinaryPublicKey(buf []byte) (sign.PublicKey, error) {
|
||||
if len(buf) < PublicKeySize {
|
||||
return nil, sign.ErrPubKeySize
|
||||
}
|
||||
pub := make(PublicKey, PublicKeySize)
|
||||
copy(pub, buf[:PublicKeySize])
|
||||
return pub, nil
|
||||
}
|
||||
|
||||
func (*scheme) UnmarshalBinaryPrivateKey(buf []byte) (sign.PrivateKey, error) {
|
||||
if len(buf) < PrivateKeySize {
|
||||
return nil, sign.ErrPrivKeySize
|
||||
}
|
||||
priv := make(PrivateKey, PrivateKeySize)
|
||||
copy(priv, buf[:PrivateKeySize])
|
||||
return priv, nil
|
||||
}
|
||||
110
vendor/github.com/cloudflare/circl/sign/sign.go
generated
vendored
Normal file
110
vendor/github.com/cloudflare/circl/sign/sign.go
generated
vendored
Normal file
@ -0,0 +1,110 @@
|
||||
// Package sign provides unified interfaces for signature schemes.
|
||||
//
|
||||
// A register of schemes is available in the package
|
||||
//
|
||||
// github.com/cloudflare/circl/sign/schemes
|
||||
package sign
|
||||
|
||||
import (
|
||||
"crypto"
|
||||
"encoding"
|
||||
"errors"
|
||||
)
|
||||
|
||||
type SignatureOpts struct {
|
||||
// If non-empty, includes the given context in the signature if supported
|
||||
// and will cause an error during signing otherwise.
|
||||
Context string
|
||||
}
|
||||
|
||||
// A public key is used to verify a signature set by the corresponding private
|
||||
// key.
|
||||
type PublicKey interface {
|
||||
// Returns the signature scheme for this public key.
|
||||
Scheme() Scheme
|
||||
Equal(crypto.PublicKey) bool
|
||||
encoding.BinaryMarshaler
|
||||
crypto.PublicKey
|
||||
}
|
||||
|
||||
// A private key allows one to create signatures.
|
||||
type PrivateKey interface {
|
||||
// Returns the signature scheme for this private key.
|
||||
Scheme() Scheme
|
||||
Equal(crypto.PrivateKey) bool
|
||||
// For compatibility with Go standard library
|
||||
crypto.Signer
|
||||
crypto.PrivateKey
|
||||
encoding.BinaryMarshaler
|
||||
}
|
||||
|
||||
// A Scheme represents a specific instance of a signature scheme.
|
||||
type Scheme interface {
|
||||
// Name of the scheme.
|
||||
Name() string
|
||||
|
||||
// GenerateKey creates a new key-pair.
|
||||
GenerateKey() (PublicKey, PrivateKey, error)
|
||||
|
||||
// Creates a signature using the PrivateKey on the given message and
|
||||
// returns the signature. opts are additional options which can be nil.
|
||||
//
|
||||
// Panics if key is nil or wrong type or opts context is not supported.
|
||||
Sign(sk PrivateKey, message []byte, opts *SignatureOpts) []byte
|
||||
|
||||
// Checks whether the given signature is a valid signature set by
|
||||
// the private key corresponding to the given public key on the
|
||||
// given message. opts are additional options which can be nil.
|
||||
//
|
||||
// Panics if key is nil or wrong type or opts context is not supported.
|
||||
Verify(pk PublicKey, message []byte, signature []byte, opts *SignatureOpts) bool
|
||||
|
||||
// Deterministically derives a keypair from a seed. If you're unsure,
|
||||
// you're better off using GenerateKey().
|
||||
//
|
||||
// Panics if seed is not of length SeedSize().
|
||||
DeriveKey(seed []byte) (PublicKey, PrivateKey)
|
||||
|
||||
// Unmarshals a PublicKey from the provided buffer.
|
||||
UnmarshalBinaryPublicKey([]byte) (PublicKey, error)
|
||||
|
||||
// Unmarshals a PublicKey from the provided buffer.
|
||||
UnmarshalBinaryPrivateKey([]byte) (PrivateKey, error)
|
||||
|
||||
// Size of binary marshalled public keys.
|
||||
PublicKeySize() int
|
||||
|
||||
// Size of binary marshalled public keys.
|
||||
PrivateKeySize() int
|
||||
|
||||
// Size of signatures.
|
||||
SignatureSize() int
|
||||
|
||||
// Size of seeds.
|
||||
SeedSize() int
|
||||
|
||||
// Returns whether contexts are supported.
|
||||
SupportsContext() bool
|
||||
}
|
||||
|
||||
var (
|
||||
// ErrTypeMismatch is the error used if types of, for instance, private
|
||||
// and public keys don't match.
|
||||
ErrTypeMismatch = errors.New("types mismatch")
|
||||
|
||||
// ErrSeedSize is the error used if the provided seed is of the wrong
|
||||
// size.
|
||||
ErrSeedSize = errors.New("wrong seed size")
|
||||
|
||||
// ErrPubKeySize is the error used if the provided public key is of
|
||||
// the wrong size.
|
||||
ErrPubKeySize = errors.New("wrong size for public key")
|
||||
|
||||
// ErrPrivKeySize is the error used if the provided private key is of
|
||||
// the wrong size.
|
||||
ErrPrivKeySize = errors.New("wrong size for private key")
|
||||
|
||||
// ErrContextNotSupported is the error used if a context is not
|
||||
// supported.
|
||||
ErrContextNotSupported = errors.New("context not supported")
|
||||
)
|
||||
Reference in New Issue
Block a user