diff options
Diffstat (limited to 'vendor/golang.org/x')
57 files changed, 15332 insertions, 3098 deletions
diff --git a/vendor/golang.org/x/crypto/acme/types.go b/vendor/golang.org/x/crypto/acme/types.go index e751bf52..eaae4529 100644 --- a/vendor/golang.org/x/crypto/acme/types.go +++ b/vendor/golang.org/x/crypto/acme/types.go @@ -57,6 +57,32 @@ var ( ErrNoAccount = errors.New("acme: account does not exist") ) +// A Subproblem describes an ACME subproblem as reported in an Error. +type Subproblem struct { + // Type is a URI reference that identifies the problem type, + // typically in a "urn:acme:error:xxx" form. + Type string + // Detail is a human-readable explanation specific to this occurrence of the problem. + Detail string + // Instance indicates a URL that the client should direct a human user to visit + // in order for instructions on how to agree to the updated Terms of Service. + // In such an event CA sets StatusCode to 403, Type to + // "urn:ietf:params:acme:error:userActionRequired", and adds a Link header with relation + // "terms-of-service" containing the latest TOS URL. + Instance string + // Identifier may contain the ACME identifier that the error is for. + Identifier *AuthzID +} + +func (sp Subproblem) String() string { + str := fmt.Sprintf("%s: ", sp.Type) + if sp.Identifier != nil { + str += fmt.Sprintf("[%s: %s] ", sp.Identifier.Type, sp.Identifier.Value) + } + str += sp.Detail + return str +} + // Error is an ACME error, defined in Problem Details for HTTP APIs doc // http://tools.ietf.org/html/draft-ietf-appsawg-http-problem. type Error struct { @@ -76,10 +102,21 @@ type Error struct { // Header is the original server error response headers. // It may be nil. Header http.Header + // Subproblems may contain more detailed information about the individual problems + // that caused the error. This field is only sent by RFC 8555 compatible ACME + // servers. Defined in RFC 8555 Section 6.7.1. + Subproblems []Subproblem } func (e *Error) Error() string { - return fmt.Sprintf("%d %s: %s", e.StatusCode, e.ProblemType, e.Detail) + str := fmt.Sprintf("%d %s: %s", e.StatusCode, e.ProblemType, e.Detail) + if len(e.Subproblems) > 0 { + str += fmt.Sprintf("; subproblems:") + for _, sp := range e.Subproblems { + str += fmt.Sprintf("\n\t%s", sp) + } + } + return str } // AuthorizationError indicates that an authorization for an identifier @@ -533,20 +570,23 @@ func (c *wireChallenge) challenge() *Challenge { // wireError is a subset of fields of the Problem Details object // as described in https://tools.ietf.org/html/rfc7807#section-3.1. type wireError struct { - Status int - Type string - Detail string - Instance string + Status int + Type string + Detail string + Instance string + Subproblems []Subproblem } func (e *wireError) error(h http.Header) *Error { - return &Error{ + err := &Error{ StatusCode: e.Status, ProblemType: e.Type, Detail: e.Detail, Instance: e.Instance, Header: h, + Subproblems: e.Subproblems, } + return err } // CertOption is an optional argument type for the TLS ChallengeCert methods for diff --git a/vendor/golang.org/x/crypto/argon2/argon2.go b/vendor/golang.org/x/crypto/argon2/argon2.go new file mode 100644 index 00000000..b423feae --- /dev/null +++ b/vendor/golang.org/x/crypto/argon2/argon2.go @@ -0,0 +1,285 @@ +// 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. + +// Package argon2 implements the key derivation function Argon2. +// Argon2 was selected as the winner of the Password Hashing Competition and can +// be used to derive cryptographic keys from passwords. +// +// For a detailed specification of Argon2 see [1]. +// +// If you aren't sure which function you need, use Argon2id (IDKey) and +// the parameter recommendations for your scenario. +// +// +// Argon2i +// +// Argon2i (implemented by Key) is the side-channel resistant version of Argon2. +// It uses data-independent memory access, which is preferred for password +// hashing and password-based key derivation. Argon2i requires more passes over +// memory than Argon2id to protect from trade-off attacks. The recommended +// parameters (taken from [2]) for non-interactive operations are time=3 and to +// use the maximum available memory. +// +// +// Argon2id +// +// Argon2id (implemented by IDKey) is a hybrid version of Argon2 combining +// Argon2i and Argon2d. It uses data-independent memory access for the first +// half of the first iteration over the memory and data-dependent memory access +// for the rest. Argon2id is side-channel resistant and provides better brute- +// force cost savings due to time-memory tradeoffs than Argon2i. The recommended +// parameters for non-interactive operations (taken from [2]) are time=1 and to +// use the maximum available memory. +// +// [1] https://github.com/P-H-C/phc-winner-argon2/blob/master/argon2-specs.pdf +// [2] https://tools.ietf.org/html/draft-irtf-cfrg-argon2-03#section-9.3 +package argon2 + +import ( + "encoding/binary" + "sync" + + "golang.org/x/crypto/blake2b" +) + +// The Argon2 version implemented by this package. +const Version = 0x13 + +const ( + argon2d = iota + argon2i + argon2id +) + +// Key derives a key from the password, salt, and cost parameters using Argon2i +// returning a byte slice of length keyLen that can be used as cryptographic +// key. The CPU cost and parallelism degree must be greater than zero. +// +// For example, you can get a derived key for e.g. AES-256 (which needs a +// 32-byte key) by doing: +// +// key := argon2.Key([]byte("some password"), salt, 3, 32*1024, 4, 32) +// +// The draft RFC recommends[2] time=3, and memory=32*1024 is a sensible number. +// If using that amount of memory (32 MB) is not possible in some contexts then +// the time parameter can be increased to compensate. +// +// The time parameter specifies the number of passes over the memory and the +// memory parameter specifies the size of the memory in KiB. For example +// memory=32*1024 sets the memory cost to ~32 MB. The number of threads can be +// adjusted to the number of available CPUs. The cost parameters should be +// increased as memory latency and CPU parallelism increases. Remember to get a +// good random salt. +func Key(password, salt []byte, time, memory uint32, threads uint8, keyLen uint32) []byte { + return deriveKey(argon2i, password, salt, nil, nil, time, memory, threads, keyLen) +} + +// IDKey derives a key from the password, salt, and cost parameters using +// Argon2id returning a byte slice of length keyLen that can be used as +// cryptographic key. The CPU cost and parallelism degree must be greater than +// zero. +// +// For example, you can get a derived key for e.g. AES-256 (which needs a +// 32-byte key) by doing: +// +// key := argon2.IDKey([]byte("some password"), salt, 1, 64*1024, 4, 32) +// +// The draft RFC recommends[2] time=1, and memory=64*1024 is a sensible number. +// If using that amount of memory (64 MB) is not possible in some contexts then +// the time parameter can be increased to compensate. +// +// The time parameter specifies the number of passes over the memory and the +// memory parameter specifies the size of the memory in KiB. For example +// memory=64*1024 sets the memory cost to ~64 MB. The number of threads can be +// adjusted to the numbers of available CPUs. The cost parameters should be +// increased as memory latency and CPU parallelism increases. Remember to get a +// good random salt. +func IDKey(password, salt []byte, time, memory uint32, threads uint8, keyLen uint32) []byte { + return deriveKey(argon2id, password, salt, nil, nil, time, memory, threads, keyLen) +} + +func deriveKey(mode int, password, salt, secret, data []byte, time, memory uint32, threads uint8, keyLen uint32) []byte { + if time < 1 { + panic("argon2: number of rounds too small") + } + if threads < 1 { + panic("argon2: parallelism degree too low") + } + h0 := initHash(password, salt, secret, data, time, memory, uint32(threads), keyLen, mode) + + memory = memory / (syncPoints * uint32(threads)) * (syncPoints * uint32(threads)) + if memory < 2*syncPoints*uint32(threads) { + memory = 2 * syncPoints * uint32(threads) + } + B := initBlocks(&h0, memory, uint32(threads)) + processBlocks(B, time, memory, uint32(threads), mode) + return extractKey(B, memory, uint32(threads), keyLen) +} + +const ( + blockLength = 128 + syncPoints = 4 +) + +type block [blockLength]uint64 + +func initHash(password, salt, key, data []byte, time, memory, threads, keyLen uint32, mode int) [blake2b.Size + 8]byte { + var ( + h0 [blake2b.Size + 8]byte + params [24]byte + tmp [4]byte + ) + + b2, _ := blake2b.New512(nil) + binary.LittleEndian.PutUint32(params[0:4], threads) + binary.LittleEndian.PutUint32(params[4:8], keyLen) + binary.LittleEndian.PutUint32(params[8:12], memory) + binary.LittleEndian.PutUint32(params[12:16], time) + binary.LittleEndian.PutUint32(params[16:20], uint32(Version)) + binary.LittleEndian.PutUint32(params[20:24], uint32(mode)) + b2.Write(params[:]) + binary.LittleEndian.PutUint32(tmp[:], uint32(len(password))) + b2.Write(tmp[:]) + b2.Write(password) + binary.LittleEndian.PutUint32(tmp[:], uint32(len(salt))) + b2.Write(tmp[:]) + b2.Write(salt) + binary.LittleEndian.PutUint32(tmp[:], uint32(len(key))) + b2.Write(tmp[:]) + b2.Write(key) + binary.LittleEndian.PutUint32(tmp[:], uint32(len(data))) + b2.Write(tmp[:]) + b2.Write(data) + b2.Sum(h0[:0]) + return h0 +} + +func initBlocks(h0 *[blake2b.Size + 8]byte, memory, threads uint32) []block { + var block0 [1024]byte + B := make([]block, memory) + for lane := uint32(0); lane < threads; lane++ { + j := lane * (memory / threads) + binary.LittleEndian.PutUint32(h0[blake2b.Size+4:], lane) + + binary.LittleEndian.PutUint32(h0[blake2b.Size:], 0) + blake2bHash(block0[:], h0[:]) + for i := range B[j+0] { + B[j+0][i] = binary.LittleEndian.Uint64(block0[i*8:]) + } + + binary.LittleEndian.PutUint32(h0[blake2b.Size:], 1) + blake2bHash(block0[:], h0[:]) + for i := range B[j+1] { + B[j+1][i] = binary.LittleEndian.Uint64(block0[i*8:]) + } + } + return B +} + +func processBlocks(B []block, time, memory, threads uint32, mode int) { + lanes := memory / threads + segments := lanes / syncPoints + + processSegment := func(n, slice, lane uint32, wg *sync.WaitGroup) { + var addresses, in, zero block + if mode == argon2i || (mode == argon2id && n == 0 && slice < syncPoints/2) { + in[0] = uint64(n) + in[1] = uint64(lane) + in[2] = uint64(slice) + in[3] = uint64(memory) + in[4] = uint64(time) + in[5] = uint64(mode) + } + + index := uint32(0) + if n == 0 && slice == 0 { + index = 2 // we have already generated the first two blocks + if mode == argon2i || mode == argon2id { + in[6]++ + processBlock(&addresses, &in, &zero) + processBlock(&addresses, &addresses, &zero) + } + } + + offset := lane*lanes + slice*segments + index + var random uint64 + for index < segments { + prev := offset - 1 + if index == 0 && slice == 0 { + prev += lanes // last block in lane + } + if mode == argon2i || (mode == argon2id && n == 0 && slice < syncPoints/2) { + if index%blockLength == 0 { + in[6]++ + processBlock(&addresses, &in, &zero) + processBlock(&addresses, &addresses, &zero) + } + random = addresses[index%blockLength] + } else { + random = B[prev][0] + } + newOffset := indexAlpha(random, lanes, segments, threads, n, slice, lane, index) + processBlockXOR(&B[offset], &B[prev], &B[newOffset]) + index, offset = index+1, offset+1 + } + wg.Done() + } + + for n := uint32(0); n < time; n++ { + for slice := uint32(0); slice < syncPoints; slice++ { + var wg sync.WaitGroup + for lane := uint32(0); lane < threads; lane++ { + wg.Add(1) + go processSegment(n, slice, lane, &wg) + } + wg.Wait() + } + } + +} + +func extractKey(B []block, memory, threads, keyLen uint32) []byte { + lanes := memory / threads + for lane := uint32(0); lane < threads-1; lane++ { + for i, v := range B[(lane*lanes)+lanes-1] { + B[memory-1][i] ^= v + } + } + + var block [1024]byte + for i, v := range B[memory-1] { + binary.LittleEndian.PutUint64(block[i*8:], v) + } + key := make([]byte, keyLen) + blake2bHash(key, block[:]) + return key +} + +func indexAlpha(rand uint64, lanes, segments, threads, n, slice, lane, index uint32) uint32 { + refLane := uint32(rand>>32) % threads + if n == 0 && slice == 0 { + refLane = lane + } + m, s := 3*segments, ((slice+1)%syncPoints)*segments + if lane == refLane { + m += index + } + if n == 0 { + m, s = slice*segments, 0 + if slice == 0 || lane == refLane { + m += index + } + } + if index == 0 || lane == refLane { + m-- + } + return phi(rand, uint64(m), uint64(s), refLane, lanes) +} + +func phi(rand, m, s uint64, lane, lanes uint32) uint32 { + p := rand & 0xFFFFFFFF + p = (p * p) >> 32 + p = (p * m) >> 32 + return lane*lanes + uint32((s+m-(p+1))%uint64(lanes)) +} diff --git a/vendor/golang.org/x/crypto/argon2/blake2b.go b/vendor/golang.org/x/crypto/argon2/blake2b.go new file mode 100644 index 00000000..10f46948 --- /dev/null +++ b/vendor/golang.org/x/crypto/argon2/blake2b.go @@ -0,0 +1,53 @@ +// 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. + +package argon2 + +import ( + "encoding/binary" + "hash" + + "golang.org/x/crypto/blake2b" +) + +// blake2bHash computes an arbitrary long hash value of in +// and writes the hash to out. +func blake2bHash(out []byte, in []byte) { + var b2 hash.Hash + if n := len(out); n < blake2b.Size { + b2, _ = blake2b.New(n, nil) + } else { + b2, _ = blake2b.New512(nil) + } + + var buffer [blake2b.Size]byte + binary.LittleEndian.PutUint32(buffer[:4], uint32(len(out))) + b2.Write(buffer[:4]) + b2.Write(in) + + if len(out) <= blake2b.Size { + b2.Sum(out[:0]) + return + } + + outLen := len(out) + b2.Sum(buffer[:0]) + b2.Reset() + copy(out, buffer[:32]) + out = out[32:] + for len(out) > blake2b.Size { + b2.Write(buffer[:]) + b2.Sum(buffer[:0]) + copy(out, buffer[:32]) + out = out[32:] + b2.Reset() + } + + if outLen%blake2b.Size > 0 { // outLen > 64 + r := ((outLen + 31) / 32) - 2 // ⌈τ /32⌉-2 + b2, _ = blake2b.New(outLen-32*r, nil) + } + b2.Write(buffer[:]) + b2.Sum(out[:0]) +} diff --git a/vendor/golang.org/x/crypto/argon2/blamka_amd64.go b/vendor/golang.org/x/crypto/argon2/blamka_amd64.go new file mode 100644 index 00000000..a014ac92 --- /dev/null +++ b/vendor/golang.org/x/crypto/argon2/blamka_amd64.go @@ -0,0 +1,61 @@ +// 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. + +//go:build amd64 && gc && !purego +// +build amd64,gc,!purego + +package argon2 + +import "golang.org/x/sys/cpu" + +func init() { + useSSE4 = cpu.X86.HasSSE41 +} + +//go:noescape +func mixBlocksSSE2(out, a, b, c *block) + +//go:noescape +func xorBlocksSSE2(out, a, b, c *block) + +//go:noescape +func blamkaSSE4(b *block) + +func processBlockSSE(out, in1, in2 *block, xor bool) { + var t block + mixBlocksSSE2(&t, in1, in2, &t) + if useSSE4 { + blamkaSSE4(&t) + } else { + for i := 0; i < blockLength; i += 16 { + blamkaGeneric( + &t[i+0], &t[i+1], &t[i+2], &t[i+3], + &t[i+4], &t[i+5], &t[i+6], &t[i+7], + &t[i+8], &t[i+9], &t[i+10], &t[i+11], + &t[i+12], &t[i+13], &t[i+14], &t[i+15], + ) + } + for i := 0; i < blockLength/8; i += 2 { + blamkaGeneric( + &t[i], &t[i+1], &t[16+i], &t[16+i+1], + &t[32+i], &t[32+i+1], &t[48+i], &t[48+i+1], + &t[64+i], &t[64+i+1], &t[80+i], &t[80+i+1], + &t[96+i], &t[96+i+1], &t[112+i], &t[112+i+1], + ) + } + } + if xor { + xorBlocksSSE2(out, in1, in2, &t) + } else { + mixBlocksSSE2(out, in1, in2, &t) + } +} + +func processBlock(out, in1, in2 *block) { + processBlockSSE(out, in1, in2, false) +} + +func processBlockXOR(out, in1, in2 *block) { + processBlockSSE(out, in1, in2, true) +} diff --git a/vendor/golang.org/x/crypto/argon2/blamka_amd64.s b/vendor/golang.org/x/crypto/argon2/blamka_amd64.s new file mode 100644 index 00000000..b2cc0515 --- /dev/null +++ b/vendor/golang.org/x/crypto/argon2/blamka_amd64.s @@ -0,0 +1,244 @@ +// 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. + +//go:build amd64 && gc && !purego +// +build amd64,gc,!purego + +#include "textflag.h" + +DATA ·c40<>+0x00(SB)/8, $0x0201000706050403 +DATA ·c40<>+0x08(SB)/8, $0x0a09080f0e0d0c0b +GLOBL ·c40<>(SB), (NOPTR+RODATA), $16 + +DATA ·c48<>+0x00(SB)/8, $0x0100070605040302 +DATA ·c48<>+0x08(SB)/8, $0x09080f0e0d0c0b0a +GLOBL ·c48<>(SB), (NOPTR+RODATA), $16 + +#define SHUFFLE(v2, v3, v4, v5, v6, v7, t1, t2) \ + MOVO v4, t1; \ + MOVO v5, v4; \ + MOVO t1, v5; \ + MOVO v6, t1; \ + PUNPCKLQDQ v6, t2; \ + PUNPCKHQDQ v7, v6; \ + PUNPCKHQDQ t2, v6; \ + PUNPCKLQDQ v7, t2; \ + MOVO t1, v7; \ + MOVO v2, t1; \ + PUNPCKHQDQ t2, v7; \ + PUNPCKLQDQ v3, t2; \ + PUNPCKHQDQ t2, v2; \ + PUNPCKLQDQ t1, t2; \ + PUNPCKHQDQ t2, v3 + +#define SHUFFLE_INV(v2, v3, v4, v5, v6, v7, t1, t2) \ + MOVO v4, t1; \ + MOVO v5, v4; \ + MOVO t1, v5; \ + MOVO v2, t1; \ + PUNPCKLQDQ v2, t2; \ + PUNPCKHQDQ v3, v2; \ + PUNPCKHQDQ t2, v2; \ + PUNPCKLQDQ v3, t2; \ + MOVO t1, v3; \ + MOVO v6, t1; \ + PUNPCKHQDQ t2, v3; \ + PUNPCKLQDQ v7, t2; \ + PUNPCKHQDQ t2, v6; \ + PUNPCKLQDQ t1, t2; \ + PUNPCKHQDQ t2, v7 + +#define HALF_ROUND(v0, v1, v2, v3, v4, v5, v6, v7, t0, c40, c48) \ + MOVO v0, t0; \ + PMULULQ v2, t0; \ + PADDQ v2, v0; \ + PADDQ t0, v0; \ + PADDQ t0, v0; \ + PXOR v0, v6; \ + PSHUFD $0xB1, v6, v6; \ + MOVO v4, t0; \ + PMULULQ v6, t0; \ + PADDQ v6, v4; \ + PADDQ t0, v4; \ + PADDQ t0, v4; \ + PXOR v4, v2; \ + PSHUFB c40, v2; \ + MOVO v0, t0; \ + PMULULQ v2, t0; \ + PADDQ v2, v0; \ + PADDQ t0, v0; \ + PADDQ t0, v0; \ + PXOR v0, v6; \ + PSHUFB c48, v6; \ + MOVO v4, t0; \ + PMULULQ v6, t0; \ + PADDQ v6, v4; \ + PADDQ t0, v4; \ + PADDQ t0, v4; \ + PXOR v4, v2; \ + MOVO v2, t0; \ + PADDQ v2, t0; \ + PSRLQ $63, v2; \ + PXOR t0, v2; \ + MOVO v1, t0; \ + PMULULQ v3, t0; \ + PADDQ v3, v1; \ + PADDQ t0, v1; \ + PADDQ t0, v1; \ + PXOR v1, v7; \ + PSHUFD $0xB1, v7, v7; \ + MOVO v5, t0; \ + PMULULQ v7, t0; \ + PADDQ v7, v5; \ + PADDQ t0, v5; \ + PADDQ t0, v5; \ + PXOR v5, v3; \ + PSHUFB c40, v3; \ + MOVO v1, t0; \ + PMULULQ v3, t0; \ + PADDQ v3, v1; \ + PADDQ t0, v1; \ + PADDQ t0, v1; \ + PXOR v1, v7; \ + PSHUFB c48, v7; \ + MOVO v5, t0; \ + PMULULQ v7, t0; \ + PADDQ v7, v5; \ + PADDQ t0, v5; \ + PADDQ t0, v5; \ + PXOR v5, v3; \ + MOVO v3, t0; \ + PADDQ v3, t0; \ + PSRLQ $63, v3; \ + PXOR t0, v3 + +#define LOAD_MSG_0(block, off) \ + MOVOU 8*(off+0)(block), X0; \ + MOVOU 8*(off+2)(block), X1; \ + MOVOU 8*(off+4)(block), X2; \ + MOVOU 8*(off+6)(block), X3; \ + MOVOU 8*(off+8)(block), X4; \ + MOVOU 8*(off+10)(block), X5; \ + MOVOU 8*(off+12)(block), X6; \ + MOVOU 8*(off+14)(block), X7 + +#define STORE_MSG_0(block, off) \ + MOVOU X0, 8*(off+0)(block); \ + MOVOU X1, 8*(off+2)(block); \ + MOVOU X2, 8*(off+4)(block); \ + MOVOU X3, 8*(off+6)(block); \ + MOVOU X4, 8*(off+8)(block); \ + MOVOU X5, 8*(off+10)(block); \ + MOVOU X6, 8*(off+12)(block); \ + MOVOU X7, 8*(off+14)(block) + +#define LOAD_MSG_1(block, off) \ + MOVOU 8*off+0*8(block), X0; \ + MOVOU 8*off+16*8(block), X1; \ + MOVOU 8*off+32*8(block), X2; \ + MOVOU 8*off+48*8(block), X3; \ + MOVOU 8*off+64*8(block), X4; \ + MOVOU 8*off+80*8(block), X5; \ + MOVOU 8*off+96*8(block), X6; \ + MOVOU 8*off+112*8(block), X7 + +#define STORE_MSG_1(block, off) \ + MOVOU X0, 8*off+0*8(block); \ + MOVOU X1, 8*off+16*8(block); \ + MOVOU X2, 8*off+32*8(block); \ + MOVOU X3, 8*off+48*8(block); \ + MOVOU X4, 8*off+64*8(block); \ + MOVOU X5, 8*off+80*8(block); \ + MOVOU X6, 8*off+96*8(block); \ + MOVOU X7, 8*off+112*8(block) + +#define BLAMKA_ROUND_0(block, off, t0, t1, c40, c48) \ + LOAD_MSG_0(block, off); \ + HALF_ROUND(X0, X1, X2, X3, X4, X5, X6, X7, t0, c40, c48); \ + SHUFFLE(X2, X3, X4, X5, X6, X7, t0, t1); \ + HALF_ROUND(X0, X1, X2, X3, X4, X5, X6, X7, t0, c40, c48); \ + SHUFFLE_INV(X2, X3, X4, X5, X6, X7, t0, t1); \ + STORE_MSG_0(block, off) + +#define BLAMKA_ROUND_1(block, off, t0, t1, c40, c48) \ + LOAD_MSG_1(block, off); \ + HALF_ROUND(X0, X1, X2, X3, X4, X5, X6, X7, t0, c40, c48); \ + SHUFFLE(X2, X3, X4, X5, X6, X7, t0, t1); \ + HALF_ROUND(X0, X1, X2, X3, X4, X5, X6, X7, t0, c40, c48); \ + SHUFFLE_INV(X2, X3, X4, X5, X6, X7, t0, t1); \ + STORE_MSG_1(block, off) + +// func blamkaSSE4(b *block) +TEXT ·blamkaSSE4(SB), 4, $0-8 + MOVQ b+0(FP), AX + + MOVOU ·c40<>(SB), X10 + MOVOU ·c48<>(SB), X11 + + BLAMKA_ROUND_0(AX, 0, X8, X9, X10, X11) + BLAMKA_ROUND_0(AX, 16, X8, X9, X10, X11) + BLAMKA_ROUND_0(AX, 32, X8, X9, X10, X11) + BLAMKA_ROUND_0(AX, 48, X8, X9, X10, X11) + BLAMKA_ROUND_0(AX, 64, X8, X9, X10, X11) + BLAMKA_ROUND_0(AX, 80, X8, X9, X10, X11) + BLAMKA_ROUND_0(AX, 96, X8, X9, X10, X11) + BLAMKA_ROUND_0(AX, 112, X8, X9, X10, X11) + + BLAMKA_ROUND_1(AX, 0, X8, X9, X10, X11) + BLAMKA_ROUND_1(AX, 2, X8, X9, X10, X11) + BLAMKA_ROUND_1(AX, 4, X8, X9, X10, X11) + BLAMKA_ROUND_1(AX, 6, X8, X9, X10, X11) + BLAMKA_ROUND_1(AX, 8, X8, X9, X10, X11) + BLAMKA_ROUND_1(AX, 10, X8, X9, X10, X11) + BLAMKA_ROUND_1(AX, 12, X8, X9, X10, X11) + BLAMKA_ROUND_1(AX, 14, X8, X9, X10, X11) + RET + +// func mixBlocksSSE2(out, a, b, c *block) +TEXT ·mixBlocksSSE2(SB), 4, $0-32 + MOVQ out+0(FP), DX + MOVQ a+8(FP), AX + MOVQ b+16(FP), BX + MOVQ a+24(FP), CX + MOVQ $128, BP + +loop: + MOVOU 0(AX), X0 + MOVOU 0(BX), X1 + MOVOU 0(CX), X2 + PXOR X1, X0 + PXOR X2, X0 + MOVOU X0, 0(DX) + ADDQ $16, AX + ADDQ $16, BX + ADDQ $16, CX + ADDQ $16, DX + SUBQ $2, BP + JA loop + RET + +// func xorBlocksSSE2(out, a, b, c *block) +TEXT ·xorBlocksSSE2(SB), 4, $0-32 + MOVQ out+0(FP), DX + MOVQ a+8(FP), AX + MOVQ b+16(FP), BX + MOVQ a+24(FP), CX + MOVQ $128, BP + +loop: + MOVOU 0(AX), X0 + MOVOU 0(BX), X1 + MOVOU 0(CX), X2 + MOVOU 0(DX), X3 + PXOR X1, X0 + PXOR X2, X0 + PXOR X3, X0 + MOVOU X0, 0(DX) + ADDQ $16, AX + ADDQ $16, BX + ADDQ $16, CX + ADDQ $16, DX + SUBQ $2, BP + JA loop + RET diff --git a/vendor/golang.org/x/crypto/argon2/blamka_generic.go b/vendor/golang.org/x/crypto/argon2/blamka_generic.go new file mode 100644 index 00000000..a481b224 --- /dev/null +++ b/vendor/golang.org/x/crypto/argon2/blamka_generic.go @@ -0,0 +1,163 @@ +// 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. + +package argon2 + +var useSSE4 bool + +func processBlockGeneric(out, in1, in2 *block, xor bool) { + var t block + for i := range t { + t[i] = in1[i] ^ in2[i] + } + for i := 0; i < blockLength; i += 16 { + blamkaGeneric( + &t[i+0], &t[i+1], &t[i+2], &t[i+3], + &t[i+4], &t[i+5], &t[i+6], &t[i+7], + &t[i+8], &t[i+9], &t[i+10], &t[i+11], + &t[i+12], &t[i+13], &t[i+14], &t[i+15], + ) + } + for i := 0; i < blockLength/8; i += 2 { + blamkaGeneric( + &t[i], &t[i+1], &t[16+i], &t[16+i+1], + &t[32+i], &t[32+i+1], &t[48+i], &t[48+i+1], + &t[64+i], &t[64+i+1], &t[80+i], &t[80+i+1], + &t[96+i], &t[96+i+1], &t[112+i], &t[112+i+1], + ) + } + if xor { + for i := range t { + out[i] ^= in1[i] ^ in2[i] ^ t[i] + } + } else { + for i := range t { + out[i] = in1[i] ^ in2[i] ^ t[i] + } + } +} + +func blamkaGeneric(t00, t01, t02, t03, t04, t05, t06, t07, t08, t09, t10, t11, t12, t13, t14, t15 *uint64) { + v00, v01, v02, v03 := *t00, *t01, *t02, *t03 + v04, v05, v06, v07 := *t04, *t05, *t06, *t07 + v08, v09, v10, v11 := *t08, *t09, *t10, *t11 + v12, v13, v14, v15 := *t12, *t13, *t14, *t15 + + v00 += v04 + 2*uint64(uint32(v00))*uint64(uint32(v04)) + v12 ^= v00 + v12 = v12>>32 | v12<<32 + v08 += v12 + 2*uint64(uint32(v08))*uint64(uint32(v12)) + v04 ^= v08 + v04 = v04>>24 | v04<<40 + + v00 += v04 + 2*uint64(uint32(v00))*uint64(uint32(v04)) + v12 ^= v00 + v12 = v12>>16 | v12<<48 + v08 += v12 + 2*uint64(uint32(v08))*uint64(uint32(v12)) + v04 ^= v08 + v04 = v04>>63 | v04<<1 + + v01 += v05 + 2*uint64(uint32(v01))*uint64(uint32(v05)) + v13 ^= v01 + v13 = v13>>32 | v13<<32 + v09 += v13 + 2*uint64(uint32(v09))*uint64(uint32(v13)) + v05 ^= v09 + v05 = v05>>24 | v05<<40 + + v01 += v05 + 2*uint64(uint32(v01))*uint64(uint32(v05)) + v13 ^= v01 + v13 = v13>>16 | v13<<48 + v09 += v13 + 2*uint64(uint32(v09))*uint64(uint32(v13)) + v05 ^= v09 + v05 = v05>>63 | v05<<1 + + v02 += v06 + 2*uint64(uint32(v02))*uint64(uint32(v06)) + v14 ^= v02 + v14 = v14>>32 | v14<<32 + v10 += v14 + 2*uint64(uint32(v10))*uint64(uint32(v14)) + v06 ^= v10 + v06 = v06>>24 | v06<<40 + + v02 += v06 + 2*uint64(uint32(v02))*uint64(uint32(v06)) + v14 ^= v02 + v14 = v14>>16 | v14<<48 + v10 += v14 + 2*uint64(uint32(v10))*uint64(uint32(v14)) + v06 ^= v10 + v06 = v06>>63 | v06<<1 + + v03 += v07 + 2*uint64(uint32(v03))*uint64(uint32(v07)) + v15 ^= v03 + v15 = v15>>32 | v15<<32 + v11 += v15 + 2*uint64(uint32(v11))*uint64(uint32(v15)) + v07 ^= v11 + v07 = v07>>24 | v07<<40 + + v03 += v07 + 2*uint64(uint32(v03))*uint64(uint32(v07)) + v15 ^= v03 + v15 = v15>>16 | v15<<48 + v11 += v15 + 2*uint64(uint32(v11))*uint64(uint32(v15)) + v07 ^= v11 + v07 = v07>>63 | v07<<1 + + v00 += v05 + 2*uint64(uint32(v00))*uint64(uint32(v05)) + v15 ^= v00 + v15 = v15>>32 | v15<<32 + v10 += v15 + 2*uint64(uint32(v10))*uint64(uint32(v15)) + v05 ^= v10 + v05 = v05>>24 | v05<<40 + + v00 += v05 + 2*uint64(uint32(v00))*uint64(uint32(v05)) + v15 ^= v00 + v15 = v15>>16 | v15<<48 + v10 += v15 + 2*uint64(uint32(v10))*uint64(uint32(v15)) + v05 ^= v10 + v05 = v05>>63 | v05<<1 + + v01 += v06 + 2*uint64(uint32(v01))*uint64(uint32(v06)) + v12 ^= v01 + v12 = v12>>32 | v12<<32 + v11 += v12 + 2*uint64(uint32(v11))*uint64(uint32(v12)) + v06 ^= v11 + v06 = v06>>24 | v06<<40 + + v01 += v06 + 2*uint64(uint32(v01))*uint64(uint32(v06)) + v12 ^= v01 + v12 = v12>>16 | v12<<48 + v11 += v12 + 2*uint64(uint32(v11))*uint64(uint32(v12)) + v06 ^= v11 + v06 = v06>>63 | v06<<1 + + v02 += v07 + 2*uint64(uint32(v02))*uint64(uint32(v07)) + v13 ^= v02 + v13 = v13>>32 | v13<<32 + v08 += v13 + 2*uint64(uint32(v08))*uint64(uint32(v13)) + v07 ^= v08 + v07 = v07>>24 | v07<<40 + + v02 += v07 + 2*uint64(uint32(v02))*uint64(uint32(v07)) + v13 ^= v02 + v13 = v13>>16 | v13<<48 + v08 += v13 + 2*uint64(uint32(v08))*uint64(uint32(v13)) + v07 ^= v08 + v07 = v07>>63 | v07<<1 + + v03 += v04 + 2*uint64(uint32(v03))*uint64(uint32(v04)) + v14 ^= v03 + v14 = v14>>32 | v14<<32 + v09 += v14 + 2*uint64(uint32(v09))*uint64(uint32(v14)) + v04 ^= v09 + v04 = v04>>24 | v04<<40 + + v03 += v04 + 2*uint64(uint32(v03))*uint64(uint32(v04)) + v14 ^= v03 + v14 = v14>>16 | v14<<48 + v09 += v14 + 2*uint64(uint32(v09))*uint64(uint32(v14)) + v04 ^= v09 + v04 = v04>>63 | v04<<1 + + *t00, *t01, *t02, *t03 = v00, v01, v02, v03 + *t04, *t05, *t06, *t07 = v04, v05, v06, v07 + *t08, *t09, *t10, *t11 = v08, v09, v10, v11 + *t12, *t13, *t14, *t15 = v12, v13, v14, v15 +} diff --git a/vendor/golang.org/x/crypto/argon2/blamka_ref.go b/vendor/golang.org/x/crypto/argon2/blamka_ref.go new file mode 100644 index 00000000..167c59d2 --- /dev/null +++ b/vendor/golang.org/x/crypto/argon2/blamka_ref.go @@ -0,0 +1,16 @@ +// 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. + +//go:build !amd64 || purego || !gc +// +build !amd64 purego !gc + +package argon2 + +func processBlock(out, in1, in2 *block) { + processBlockGeneric(out, in1, in2, false) +} + +func processBlockXOR(out, in1, in2 *block) { + processBlockGeneric(out, in1, in2, true) +} diff --git a/vendor/golang.org/x/crypto/blake2b/blake2b.go b/vendor/golang.org/x/crypto/blake2b/blake2b.go new file mode 100644 index 00000000..d2e98d42 --- /dev/null +++ b/vendor/golang.org/x/crypto/blake2b/blake2b.go @@ -0,0 +1,291 @@ +// Copyright 2016 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 blake2b implements the BLAKE2b hash algorithm defined by RFC 7693 +// and the extendable output function (XOF) BLAKE2Xb. +// +// BLAKE2b is optimized for 64-bit platforms—including NEON-enabled ARMs—and +// produces digests of any size between 1 and 64 bytes. +// For a detailed specification of BLAKE2b see https://blake2.net/blake2.pdf +// and for BLAKE2Xb see https://blake2.net/blake2x.pdf +// +// If you aren't sure which function you need, use BLAKE2b (Sum512 or New512). +// If you need a secret-key MAC (message authentication code), use the New512 +// function with a non-nil key. +// +// BLAKE2X is a construction to compute hash values larger than 64 bytes. It +// can produce hash values between 0 and 4 GiB. +package blake2b + +import ( + "encoding/binary" + "errors" + "hash" +) + +const ( + // The blocksize of BLAKE2b in bytes. + BlockSize = 128 + // The hash size of BLAKE2b-512 in bytes. + Size = 64 + // The hash size of BLAKE2b-384 in bytes. + Size384 = 48 + // The hash size of BLAKE2b-256 in bytes. + Size256 = 32 +) + +var ( + useAVX2 bool + useAVX bool + useSSE4 bool +) + +var ( + errKeySize = errors.New("blake2b: invalid key size") + errHashSize = errors.New("blake2b: invalid hash size") +) + +var iv = [8]uint64{ + 0x6a09e667f3bcc908, 0xbb67ae8584caa73b, 0x3c6ef372fe94f82b, 0xa54ff53a5f1d36f1, + 0x510e527fade682d1, 0x9b05688c2b3e6c1f, 0x1f83d9abfb41bd6b, 0x5be0cd19137e2179, +} + +// Sum512 returns the BLAKE2b-512 checksum of the data. +func Sum512(data []byte) [Size]byte { + var sum [Size]byte + checkSum(&sum, Size, data) + return sum +} + +// Sum384 returns the BLAKE2b-384 checksum of the data. +func Sum384(data []byte) [Size384]byte { + var sum [Size]byte + var sum384 [Size384]byte + checkSum(&sum, Size384, data) + copy(sum384[:], sum[:Size384]) + return sum384 +} + +// Sum256 returns the BLAKE2b-256 checksum of the data. +func Sum256(data []byte) [Size256]byte { + var sum [Size]byte + var sum256 [Size256]byte + checkSum(&sum, Size256, data) + copy(sum256[:], sum[:Size256]) + return sum256 +} + +// New512 returns a new hash.Hash computing the BLAKE2b-512 checksum. A non-nil +// key turns the hash into a MAC. The key must be between zero and 64 bytes long. +func New512(key []byte) (hash.Hash, error) { return newDigest(Size, key) } + +// New384 returns a new hash.Hash computing the BLAKE2b-384 checksum. A non-nil +// key turns the hash into a MAC. The key must be between zero and 64 bytes long. +func New384(key []byte) (hash.Hash, error) { return newDigest(Size384, key) } + +// New256 returns a new hash.Hash computing the BLAKE2b-256 checksum. A non-nil +// key turns the hash into a MAC. The key must be between zero and 64 bytes long. +func New256(key []byte) (hash.Hash, error) { return newDigest(Size256, key) } + +// New returns a new hash.Hash computing the BLAKE2b checksum with a custom length. +// A non-nil key turns the hash into a MAC. The key must be between zero and 64 bytes long. +// The hash size can be a value between 1 and 64 but it is highly recommended to use +// values equal or greater than: +// - 32 if BLAKE2b is used as a hash function (The key is zero bytes long). +// - 16 if BLAKE2b is used as a MAC function (The key is at least 16 bytes long). +// When the key is nil, the returned hash.Hash implements BinaryMarshaler +// and BinaryUnmarshaler for state (de)serialization as documented by hash.Hash. +func New(size int, key []byte) (hash.Hash, error) { return newDigest(size, key) } + +func newDigest(hashSize int, key []byte) (*digest, error) { + if hashSize < 1 || hashSize > Size { + return nil, errHashSize + } + if len(key) > Size { + return nil, errKeySize + } + d := &digest{ + size: hashSize, + keyLen: len(key), + } + copy(d.key[:], key) + d.Reset() + return d, nil +} + +func checkSum(sum *[Size]byte, hashSize int, data []byte) { + h := iv + h[0] ^= uint64(hashSize) | (1 << 16) | (1 << 24) + var c [2]uint64 + + if length := len(data); length > BlockSize { + n := length &^ (BlockSize - 1) + if length == n { + n -= BlockSize + } + hashBlocks(&h, &c, 0, data[:n]) + data = data[n:] + } + + var block [BlockSize]byte + offset := copy(block[:], data) + remaining := uint64(BlockSize - offset) + if c[0] < remaining { + c[1]-- + } + c[0] -= remaining + + hashBlocks(&h, &c, 0xFFFFFFFFFFFFFFFF, block[:]) + + for i, v := range h[:(hashSize+7)/8] { + binary.LittleEndian.PutUint64(sum[8*i:], v) + } +} + +type digest struct { + h [8]uint64 + c [2]uint64 + size int + block [BlockSize]byte + offset int + + key [BlockSize]byte + keyLen int +} + +const ( + magic = "b2b" + marshaledSize = len(magic) + 8*8 + 2*8 + 1 + BlockSize + 1 +) + +func (d *digest) MarshalBinary() ([]byte, error) { + if d.keyLen != 0 { + return nil, errors.New("crypto/blake2b: cannot marshal MACs") + } + b := make([]byte, 0, marshaledSize) + b = append(b, magic...) + for i := 0; i < 8; i++ { + b = appendUint64(b, d.h[i]) + } + b = appendUint64(b, d.c[0]) + b = appendUint64(b, d.c[1]) + // Maximum value for size is 64 + b = append(b, byte(d.size)) + b = append(b, d.block[:]...) + b = append(b, byte(d.offset)) + return b, nil +} + +func (d *digest) UnmarshalBinary(b []byte) error { + if len(b) < len(magic) || string(b[:len(magic)]) != magic { + return errors.New("crypto/blake2b: invalid hash state identifier") + } + if len(b) != marshaledSize { + return errors.New("crypto/blake2b: invalid hash state size") + } + b = b[len(magic):] + for i := 0; i < 8; i++ { + b, d.h[i] = consumeUint64(b) + } + b, d.c[0] = consumeUint64(b) + b, d.c[1] = consumeUint64(b) + d.size = int(b[0]) + b = b[1:] + copy(d.block[:], b[:BlockSize]) + b = b[BlockSize:] + d.offset = int(b[0]) + return nil +} + +func (d *digest) BlockSize() int { return BlockSize } + +func (d *digest) Size() int { return d.size } + +func (d *digest) Reset() { + d.h = iv + d.h[0] ^= uint64(d.size) | (uint64(d.keyLen) << 8) | (1 << 16) | (1 << 24) + d.offset, d.c[0], d.c[1] = 0, 0, 0 + if d.keyLen > 0 { + d.block = d.key + d.offset = BlockSize + } +} + +func (d *digest) Write(p []byte) (n int, err error) { + n = len(p) + + if d.offset > 0 { + remaining := BlockSize - d.offset + if n <= remaining { + d.offset += copy(d.block[d.offset:], p) + return + } + copy(d.block[d.offset:], p[:remaining]) + hashBlocks(&d.h, &d.c, 0, d.block[:]) + d.offset = 0 + p = p[remaining:] + } + + if length := len(p); length > BlockSize { + nn := length &^ (BlockSize - 1) + if length == nn { + nn -= BlockSize + } + hashBlocks(&d.h, &d.c, 0, p[:nn]) + p = p[nn:] + } + + if len(p) > 0 { + d.offset += copy(d.block[:], p) + } + + return +} + +func (d *digest) Sum(sum []byte) []byte { + var hash [Size]byte + d.finalize(&hash) + return append(sum, hash[:d.size]...) +} + +func (d *digest) finalize(hash *[Size]byte) { + var block [BlockSize]byte + copy(block[:], d.block[:d.offset]) + remaining := uint64(BlockSize - d.offset) + + c := d.c + if c[0] < remaining { + c[1]-- + } + c[0] -= remaining + + h := d.h + hashBlocks(&h, &c, 0xFFFFFFFFFFFFFFFF, block[:]) + + for i, v := range h { + binary.LittleEndian.PutUint64(hash[8*i:], v) + } +} + +func appendUint64(b []byte, x uint64) []byte { + var a [8]byte + binary.BigEndian.PutUint64(a[:], x) + return append(b, a[:]...) +} + +func appendUint32(b []byte, x uint32) []byte { + var a [4]byte + binary.BigEndian.PutUint32(a[:], x) + return append(b, a[:]...) +} + +func consumeUint64(b []byte) ([]byte, uint64) { + x := binary.BigEndian.Uint64(b) + return b[8:], x +} + +func consumeUint32(b []byte) ([]byte, uint32) { + x := binary.BigEndian.Uint32(b) + return b[4:], x +} diff --git a/vendor/golang.org/x/crypto/blake2b/blake2bAVX2_amd64.go b/vendor/golang.org/x/crypto/blake2b/blake2bAVX2_amd64.go new file mode 100644 index 00000000..56bfaaa1 --- /dev/null +++ b/vendor/golang.org/x/crypto/blake2b/blake2bAVX2_amd64.go @@ -0,0 +1,38 @@ +// Copyright 2016 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 go1.7 && amd64 && gc && !purego +// +build go1.7,amd64,gc,!purego + +package blake2b + +import "golang.org/x/sys/cpu" + +func init() { + useAVX2 = cpu.X86.HasAVX2 + useAVX = cpu.X86.HasAVX + useSSE4 = cpu.X86.HasSSE41 +} + +//go:noescape +func hashBlocksAVX2(h *[8]uint64, c *[2]uint64, flag uint64, blocks []byte) + +//go:noescape +func hashBlocksAVX(h *[8]uint64, c *[2]uint64, flag uint64, blocks []byte) + +//go:noescape +func hashBlocksSSE4(h *[8]uint64, c *[2]uint64, flag uint64, blocks []byte) + +func hashBlocks(h *[8]uint64, c *[2]uint64, flag uint64, blocks []byte) { + switch { + case useAVX2: + hashBlocksAVX2(h, c, flag, blocks) + case useAVX: + hashBlocksAVX(h, c, flag, blocks) + case useSSE4: + hashBlocksSSE4(h, c, flag, blocks) + default: + hashBlocksGeneric(h, c, flag, blocks) + } +} diff --git a/vendor/golang.org/x/crypto/blake2b/blake2bAVX2_amd64.s b/vendor/golang.org/x/crypto/blake2b/blake2bAVX2_amd64.s new file mode 100644 index 00000000..4b9daa18 --- /dev/null +++ b/vendor/golang.org/x/crypto/blake2b/blake2bAVX2_amd64.s @@ -0,0 +1,745 @@ +// Copyright 2016 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 go1.7 && amd64 && gc && !purego +// +build go1.7,amd64,gc,!purego + +#include "textflag.h" + +DATA ·AVX2_iv0<>+0x00(SB)/8, $0x6a09e667f3bcc908 +DATA ·AVX2_iv0<>+0x08(SB)/8, $0xbb67ae8584caa73b +DATA ·AVX2_iv0<>+0x10(SB)/8, $0x3c6ef372fe94f82b +DATA ·AVX2_iv0<>+0x18(SB)/8, $0xa54ff53a5f1d36f1 +GLOBL ·AVX2_iv0<>(SB), (NOPTR+RODATA), $32 + +DATA ·AVX2_iv1<>+0x00(SB)/8, $0x510e527fade682d1 +DATA ·AVX2_iv1<>+0x08(SB)/8, $0x9b05688c2b3e6c1f +DATA ·AVX2_iv1<>+0x10(SB)/8, $0x1f83d9abfb41bd6b +DATA ·AVX2_iv1<>+0x18(SB)/8, $0x5be0cd19137e2179 +GLOBL ·AVX2_iv1<>(SB), (NOPTR+RODATA), $32 + +DATA ·AVX2_c40<>+0x00(SB)/8, $0x0201000706050403 +DATA ·AVX2_c40<>+0x08(SB)/8, $0x0a09080f0e0d0c0b +DATA ·AVX2_c40<>+0x10(SB)/8, $0x0201000706050403 +DATA ·AVX2_c40<>+0x18(SB)/8, $0x0a09080f0e0d0c0b +GLOBL ·AVX2_c40<>(SB), (NOPTR+RODATA), $32 + +DATA ·AVX2_c48<>+0x00(SB)/8, $0x0100070605040302 +DATA ·AVX2_c48<>+0x08(SB)/8, $0x09080f0e0d0c0b0a +DATA ·AVX2_c48<>+0x10(SB)/8, $0x0100070605040302 +DATA ·AVX2_c48<>+0x18(SB)/8, $0x09080f0e0d0c0b0a +GLOBL ·AVX2_c48<>(SB), (NOPTR+RODATA), $32 + +DATA ·AVX_iv0<>+0x00(SB)/8, $0x6a09e667f3bcc908 +DATA ·AVX_iv0<>+0x08(SB)/8, $0xbb67ae8584caa73b +GLOBL ·AVX_iv0<>(SB), (NOPTR+RODATA), $16 + +DATA ·AVX_iv1<>+0x00(SB)/8, $0x3c6ef372fe94f82b +DATA ·AVX_iv1<>+0x08(SB)/8, $0xa54ff53a5f1d36f1 +GLOBL ·AVX_iv1<>(SB), (NOPTR+RODATA), $16 + +DATA ·AVX_iv2<>+0x00(SB)/8, $0x510e527fade682d1 +DATA ·AVX_iv2<>+0x08(SB)/8, $0x9b05688c2b3e6c1f +GLOBL ·AVX_iv2<>(SB), (NOPTR+RODATA), $16 + +DATA ·AVX_iv3<>+0x00(SB)/8, $0x1f83d9abfb41bd6b +DATA ·AVX_iv3<>+0x08(SB)/8, $0x5be0cd19137e2179 +GLOBL ·AVX_iv3<>(SB), (NOPTR+RODATA), $16 + +DATA ·AVX_c40<>+0x00(SB)/8, $0x0201000706050403 +DATA ·AVX_c40<>+0x08(SB)/8, $0x0a09080f0e0d0c0b +GLOBL ·AVX_c40<>(SB), (NOPTR+RODATA), $16 + +DATA ·AVX_c48<>+0x00(SB)/8, $0x0100070605040302 +DATA ·AVX_c48<>+0x08(SB)/8, $0x09080f0e0d0c0b0a +GLOBL ·AVX_c48<>(SB), (NOPTR+RODATA), $16 + +#define VPERMQ_0x39_Y1_Y1 BYTE $0xc4; BYTE $0xe3; BYTE $0xfd; BYTE $0x00; BYTE $0xc9; BYTE $0x39 +#define VPERMQ_0x93_Y1_Y1 BYTE $0xc4; BYTE $0xe3; BYTE $0xfd; BYTE $0x00; BYTE $0xc9; BYTE $0x93 +#define VPERMQ_0x4E_Y2_Y2 BYTE $0xc4; BYTE $0xe3; BYTE $0xfd; BYTE $0x00; BYTE $0xd2; BYTE $0x4e +#define VPERMQ_0x93_Y3_Y3 BYTE $0xc4; BYTE $0xe3; BYTE $0xfd; BYTE $0x00; BYTE $0xdb; BYTE $0x93 +#define VPERMQ_0x39_Y3_Y3 BYTE $0xc4; BYTE $0xe3; BYTE $0xfd; BYTE $0x00; BYTE $0xdb; BYTE $0x39 + +#define ROUND_AVX2(m0, m1, m2, m3, t, c40, c48) \ + VPADDQ m0, Y0, Y0; \ + VPADDQ Y1, Y0, Y0; \ + VPXOR Y0, Y3, Y3; \ + VPSHUFD $-79, Y3, Y3; \ + VPADDQ Y3, Y2, Y2; \ + VPXOR Y2, Y1, Y1; \ + VPSHUFB c40, Y1, Y1; \ + VPADDQ m1, Y0, Y0; \ + VPADDQ Y1, Y0, Y0; \ + VPXOR Y0, Y3, Y3; \ + VPSHUFB c48, Y3, Y3; \ + VPADDQ Y3, Y2, Y2; \ + VPXOR Y2, Y1, Y1; \ + VPADDQ Y1, Y1, t; \ + VPSRLQ $63, Y1, Y1; \ + VPXOR t, Y1, Y1; \ + VPERMQ_0x39_Y1_Y1; \ + VPERMQ_0x4E_Y2_Y2; \ + VPERMQ_0x93_Y3_Y3; \ + VPADDQ m2, Y0, Y0; \ + VPADDQ Y1, Y0, Y0; \ + VPXOR Y0, Y3, Y3; \ + VPSHUFD $-79, Y3, Y3; \ + VPADDQ Y3, Y2, Y2; \ + VPXOR Y2, Y1, Y1; \ + VPSHUFB c40, Y1, Y1; \ + VPADDQ m3, Y0, Y0; \ + VPADDQ Y1, Y0, Y0; \ + VPXOR Y0, Y3, Y3; \ + VPSHUFB c48, Y3, Y3; \ + VPADDQ Y3, Y2, Y2; \ + VPXOR Y2, Y1, Y1; \ + VPADDQ Y1, Y1, t; \ + VPSRLQ $63, Y1, Y1; \ + VPXOR t, Y1, Y1; \ + VPERMQ_0x39_Y3_Y3; \ + VPERMQ_0x4E_Y2_Y2; \ + VPERMQ_0x93_Y1_Y1 + +#define VMOVQ_SI_X11_0 BYTE $0xC5; BYTE $0x7A; BYTE $0x7E; BYTE $0x1E +#define VMOVQ_SI_X12_0 BYTE $0xC5; BYTE $0x7A; BYTE $0x7E; BYTE $0x26 +#define VMOVQ_SI_X13_0 BYTE $0xC5; BYTE $0x7A; BYTE $0x7E; BYTE $0x2E +#define VMOVQ_SI_X14_0 BYTE $0xC5; BYTE $0x7A; BYTE $0x7E; BYTE $0x36 +#define VMOVQ_SI_X15_0 BYTE $0xC5; BYTE $0x7A; BYTE $0x7E; BYTE $0x3E + +#define VMOVQ_SI_X11(n) BYTE $0xC5; BYTE $0x7A; BYTE $0x7E; BYTE $0x5E; BYTE $n +#define VMOVQ_SI_X12(n) BYTE $0xC5; BYTE $0x7A; BYTE $0x7E; BYTE $0x66; BYTE $n +#define VMOVQ_SI_X13(n) BYTE $0xC5; BYTE $0x7A; BYTE $0x7E; BYTE $0x6E; BYTE $n +#define VMOVQ_SI_X14(n) BYTE $0xC5; BYTE $0x7A; BYTE $0x7E; BYTE $0x76; BYTE $n +#define VMOVQ_SI_X15(n) BYTE $0xC5; BYTE $0x7A; BYTE $0x7E; BYTE $0x7E; BYTE $n + +#define VPINSRQ_1_SI_X11_0 BYTE $0xC4; BYTE $0x63; BYTE $0xA1; BYTE $0x22; BYTE $0x1E; BYTE $0x01 +#define VPINSRQ_1_SI_X12_0 BYTE $0xC4; BYTE $0x63; BYTE $0x99; BYTE $0x22; BYTE $0x26; BYTE $0x01 +#define VPINSRQ_1_SI_X13_0 BYTE $0xC4; BYTE $0x63; BYTE $0x91; BYTE $0x22; BYTE $0x2E; BYTE $0x01 +#define VPINSRQ_1_SI_X14_0 BYTE $0xC4; BYTE $0x63; BYTE $0x89; BYTE $0x22; BYTE $0x36; BYTE $0x01 +#define VPINSRQ_1_SI_X15_0 BYTE $0xC4; BYTE $0x63; BYTE $0x81; BYTE $0x22; BYTE $0x3E; BYTE $0x01 + +#define VPINSRQ_1_SI_X11(n) BYTE $0xC4; BYTE $0x63; BYTE $0xA1; BYTE $0x22; BYTE $0x5E; BYTE $n; BYTE $0x01 +#define VPINSRQ_1_SI_X12(n) BYTE $0xC4; BYTE $0x63; BYTE $0x99; BYTE $0x22; BYTE $0x66; BYTE $n; BYTE $0x01 +#define VPINSRQ_1_SI_X13(n) BYTE $0xC4; BYTE $0x63; BYTE $0x91; BYTE $0x22; BYTE $0x6E; BYTE $n; BYTE $0x01 +#define VPINSRQ_1_SI_X14(n) BYTE $0xC4; BYTE $0x63; BYTE $0x89; BYTE $0x22; BYTE $0x76; BYTE $n; BYTE $0x01 +#define VPINSRQ_1_SI_X15(n) BYTE $0xC4; BYTE $0x63; BYTE $0x81; BYTE $0x22; BYTE $0x7E; BYTE $n; BYTE $0x01 + +#define VMOVQ_R8_X15 BYTE $0xC4; BYTE $0x41; BYTE $0xF9; BYTE $0x6E; BYTE $0xF8 +#define VPINSRQ_1_R9_X15 BYTE $0xC4; BYTE $0x43; BYTE $0x81; BYTE $0x22; BYTE $0xF9; BYTE $0x01 + +// load msg: Y12 = (i0, i1, i2, i3) +// i0, i1, i2, i3 must not be 0 +#define LOAD_MSG_AVX2_Y12(i0, i1, i2, i3) \ + VMOVQ_SI_X12(i0*8); \ + VMOVQ_SI_X11(i2*8); \ + VPINSRQ_1_SI_X12(i1*8); \ + VPINSRQ_1_SI_X11(i3*8); \ + VINSERTI128 $1, X11, Y12, Y12 + +// load msg: Y13 = (i0, i1, i2, i3) +// i0, i1, i2, i3 must not be 0 +#define LOAD_MSG_AVX2_Y13(i0, i1, i2, i3) \ + VMOVQ_SI_X13(i0*8); \ + VMOVQ_SI_X11(i2*8); \ + VPINSRQ_1_SI_X13(i1*8); \ + VPINSRQ_1_SI_X11(i3*8); \ + VINSERTI128 $1, X11, Y13, Y13 + +// load msg: Y14 = (i0, i1, i2, i3) +// i0, i1, i2, i3 must not be 0 +#define LOAD_MSG_AVX2_Y14(i0, i1, i2, i3) \ + VMOVQ_SI_X14(i0*8); \ + VMOVQ_SI_X11(i2*8); \ + VPINSRQ_1_SI_X14(i1*8); \ + VPINSRQ_1_SI_X11(i3*8); \ + VINSERTI128 $1, X11, Y14, Y14 + +// load msg: Y15 = (i0, i1, i2, i3) +// i0, i1, i2, i3 must not be 0 +#define LOAD_MSG_AVX2_Y15(i0, i1, i2, i3) \ + VMOVQ_SI_X15(i0*8); \ + VMOVQ_SI_X11(i2*8); \ + VPINSRQ_1_SI_X15(i1*8); \ + VPINSRQ_1_SI_X11(i3*8); \ + VINSERTI128 $1, X11, Y15, Y15 + +#define LOAD_MSG_AVX2_0_2_4_6_1_3_5_7_8_10_12_14_9_11_13_15() \ + VMOVQ_SI_X12_0; \ + VMOVQ_SI_X11(4*8); \ + VPINSRQ_1_SI_X12(2*8); \ + VPINSRQ_1_SI_X11(6*8); \ + VINSERTI128 $1, X11, Y12, Y12; \ + LOAD_MSG_AVX2_Y13(1, 3, 5, 7); \ + LOAD_MSG_AVX2_Y14(8, 10, 12, 14); \ + LOAD_MSG_AVX2_Y15(9, 11, 13, 15) + +#define LOAD_MSG_AVX2_14_4_9_13_10_8_15_6_1_0_11_5_12_2_7_3() \ + LOAD_MSG_AVX2_Y12(14, 4, 9, 13); \ + LOAD_MSG_AVX2_Y13(10, 8, 15, 6); \ + VMOVQ_SI_X11(11*8); \ + VPSHUFD $0x4E, 0*8(SI), X14; \ + VPINSRQ_1_SI_X11(5*8); \ + VINSERTI128 $1, X11, Y14, Y14; \ + LOAD_MSG_AVX2_Y15(12, 2, 7, 3) + +#define LOAD_MSG_AVX2_11_12_5_15_8_0_2_13_10_3_7_9_14_6_1_4() \ + VMOVQ_SI_X11(5*8); \ + VMOVDQU 11*8(SI), X12; \ + VPINSRQ_1_SI_X11(15*8); \ + VINSERTI128 $1, X11, Y12, Y12; \ + VMOVQ_SI_X13(8*8); \ + VMOVQ_SI_X11(2*8); \ + VPINSRQ_1_SI_X13_0; \ + VPINSRQ_1_SI_X11(13*8); \ + VINSERTI128 $1, X11, Y13, Y13; \ + LOAD_MSG_AVX2_Y14(10, 3, 7, 9); \ + LOAD_MSG_AVX2_Y15(14, 6, 1, 4) + +#define LOAD_MSG_AVX2_7_3_13_11_9_1_12_14_2_5_4_15_6_10_0_8() \ + LOAD_MSG_AVX2_Y12(7, 3, 13, 11); \ + LOAD_MSG_AVX2_Y13(9, 1, 12, 14); \ + LOAD_MSG_AVX2_Y14(2, 5, 4, 15); \ + VMOVQ_SI_X15(6*8); \ + VMOVQ_SI_X11_0; \ + VPINSRQ_1_SI_X15(10*8); \ + VPINSRQ_1_SI_X11(8*8); \ + VINSERTI128 $1, X11, Y15, Y15 + +#define LOAD_MSG_AVX2_9_5_2_10_0_7_4_15_14_11_6_3_1_12_8_13() \ + LOAD_MSG_AVX2_Y12(9, 5, 2, 10); \ + VMOVQ_SI_X13_0; \ + VMOVQ_SI_X11(4*8); \ + VPINSRQ_1_SI_X13(7*8); \ + VPINSRQ_1_SI_X11(15*8); \ + VINSERTI128 $1, X11, Y13, Y13; \ + LOAD_MSG_AVX2_Y14(14, 11, 6, 3); \ + LOAD_MSG_AVX2_Y15(1, 12, 8, 13) + +#define LOAD_MSG_AVX2_2_6_0_8_12_10_11_3_4_7_15_1_13_5_14_9() \ + VMOVQ_SI_X12(2*8); \ + VMOVQ_SI_X11_0; \ + VPINSRQ_1_SI_X12(6*8); \ + VPINSRQ_1_SI_X11(8*8); \ + VINSERTI128 $1, X11, Y12, Y12; \ + LOAD_MSG_AVX2_Y13(12, 10, 11, 3); \ + LOAD_MSG_AVX2_Y14(4, 7, 15, 1); \ + LOAD_MSG_AVX2_Y15(13, 5, 14, 9) + +#define LOAD_MSG_AVX2_12_1_14_4_5_15_13_10_0_6_9_8_7_3_2_11() \ + LOAD_MSG_AVX2_Y12(12, 1, 14, 4); \ + LOAD_MSG_AVX2_Y13(5, 15, 13, 10); \ + VMOVQ_SI_X14_0; \ + VPSHUFD $0x4E, 8*8(SI), X11; \ + VPINSRQ_1_SI_X14(6*8); \ + VINSERTI128 $1, X11, Y14, Y14; \ + LOAD_MSG_AVX2_Y15(7, 3, 2, 11) + +#define LOAD_MSG_AVX2_13_7_12_3_11_14_1_9_5_15_8_2_0_4_6_10() \ + LOAD_MSG_AVX2_Y12(13, 7, 12, 3); \ + LOAD_MSG_AVX2_Y13(11, 14, 1, 9); \ + LOAD_MSG_AVX2_Y14(5, 15, 8, 2); \ + VMOVQ_SI_X15_0; \ + VMOVQ_SI_X11(6*8); \ + VPINSRQ_1_SI_X15(4*8); \ + VPINSRQ_1_SI_X11(10*8); \ + VINSERTI128 $1, X11, Y15, Y15 + +#define LOAD_MSG_AVX2_6_14_11_0_15_9_3_8_12_13_1_10_2_7_4_5() \ + VMOVQ_SI_X12(6*8); \ + VMOVQ_SI_X11(11*8); \ + VPINSRQ_1_SI_X12(14*8); \ + VPINSRQ_1_SI_X11_0; \ + VINSERTI128 $1, X11, Y12, Y12; \ + LOAD_MSG_AVX2_Y13(15, 9, 3, 8); \ + VMOVQ_SI_X11(1*8); \ + VMOVDQU 12*8(SI), X14; \ + VPINSRQ_1_SI_X11(10*8); \ + VINSERTI128 $1, X11, Y14, Y14; \ + VMOVQ_SI_X15(2*8); \ + VMOVDQU 4*8(SI), X11; \ + VPINSRQ_1_SI_X15(7*8); \ + VINSERTI128 $1, X11, Y15, Y15 + +#define LOAD_MSG_AVX2_10_8_7_1_2_4_6_5_15_9_3_13_11_14_12_0() \ + LOAD_MSG_AVX2_Y12(10, 8, 7, 1); \ + VMOVQ_SI_X13(2*8); \ + VPSHUFD $0x4E, 5*8(SI), X11; \ + VPINSRQ_1_SI_X13(4*8); \ + VINSERTI128 $1, X11, Y13, Y13; \ + LOAD_MSG_AVX2_Y14(15, 9, 3, 13); \ + VMOVQ_SI_X15(11*8); \ + VMOVQ_SI_X11(12*8); \ + VPINSRQ_1_SI_X15(14*8); \ + VPINSRQ_1_SI_X11_0; \ + VINSERTI128 $1, X11, Y15, Y15 + +// func hashBlocksAVX2(h *[8]uint64, c *[2]uint64, flag uint64, blocks []byte) +TEXT ·hashBlocksAVX2(SB), 4, $320-48 // frame size = 288 + 32 byte alignment + MOVQ h+0(FP), AX + MOVQ c+8(FP), BX + MOVQ flag+16(FP), CX + MOVQ blocks_base+24(FP), SI + MOVQ blocks_len+32(FP), DI + + MOVQ SP, DX + ADDQ $31, DX + ANDQ $~31, DX + + MOVQ CX, 16(DX) + XORQ CX, CX + MOVQ CX, 24(DX) + + VMOVDQU ·AVX2_c40<>(SB), Y4 + VMOVDQU ·AVX2_c48<>(SB), Y5 + + VMOVDQU 0(AX), Y8 + VMOVDQU 32(AX), Y9 + VMOVDQU ·AVX2_iv0<>(SB), Y6 + VMOVDQU ·AVX2_iv1<>(SB), Y7 + + MOVQ 0(BX), R8 + MOVQ 8(BX), R9 + MOVQ R9, 8(DX) + +loop: + ADDQ $128, R8 + MOVQ R8, 0(DX) + CMPQ R8, $128 + JGE noinc + INCQ R9 + MOVQ R9, 8(DX) + +noinc: + VMOVDQA Y8, Y0 + VMOVDQA Y9, Y1 + VMOVDQA Y6, Y2 + VPXOR 0(DX), Y7, Y3 + + LOAD_MSG_AVX2_0_2_4_6_1_3_5_7_8_10_12_14_9_11_13_15() + VMOVDQA Y12, 32(DX) + VMOVDQA Y13, 64(DX) + VMOVDQA Y14, 96(DX) + VMOVDQA Y15, 128(DX) + ROUND_AVX2(Y12, Y13, Y14, Y15, Y10, Y4, Y5) + LOAD_MSG_AVX2_14_4_9_13_10_8_15_6_1_0_11_5_12_2_7_3() + VMOVDQA Y12, 160(DX) + VMOVDQA Y13, 192(DX) + VMOVDQA Y14, 224(DX) + VMOVDQA Y15, 256(DX) + + ROUND_AVX2(Y12, Y13, Y14, Y15, Y10, Y4, Y5) + LOAD_MSG_AVX2_11_12_5_15_8_0_2_13_10_3_7_9_14_6_1_4() + ROUND_AVX2(Y12, Y13, Y14, Y15, Y10, Y4, Y5) + LOAD_MSG_AVX2_7_3_13_11_9_1_12_14_2_5_4_15_6_10_0_8() + ROUND_AVX2(Y12, Y13, Y14, Y15, Y10, Y4, Y5) + LOAD_MSG_AVX2_9_5_2_10_0_7_4_15_14_11_6_3_1_12_8_13() + ROUND_AVX2(Y12, Y13, Y14, Y15, Y10, Y4, Y5) + LOAD_MSG_AVX2_2_6_0_8_12_10_11_3_4_7_15_1_13_5_14_9() + ROUND_AVX2(Y12, Y13, Y14, Y15, Y10, Y4, Y5) + LOAD_MSG_AVX2_12_1_14_4_5_15_13_10_0_6_9_8_7_3_2_11() + ROUND_AVX2(Y12, Y13, Y14, Y15, Y10, Y4, Y5) + LOAD_MSG_AVX2_13_7_12_3_11_14_1_9_5_15_8_2_0_4_6_10() + ROUND_AVX2(Y12, Y13, Y14, Y15, Y10, Y4, Y5) + LOAD_MSG_AVX2_6_14_11_0_15_9_3_8_12_13_1_10_2_7_4_5() + ROUND_AVX2(Y12, Y13, Y14, Y15, Y10, Y4, Y5) + LOAD_MSG_AVX2_10_8_7_1_2_4_6_5_15_9_3_13_11_14_12_0() + ROUND_AVX2(Y12, Y13, Y14, Y15, Y10, Y4, Y5) + + ROUND_AVX2(32(DX), 64(DX), 96(DX), 128(DX), Y10, Y4, Y5) + ROUND_AVX2(160(DX), 192(DX), 224(DX), 256(DX), Y10, Y4, Y5) + + VPXOR Y0, Y8, Y8 + VPXOR Y1, Y9, Y9 + VPXOR Y2, Y8, Y8 + VPXOR Y3, Y9, Y9 + + LEAQ 128(SI), SI + SUBQ $128, DI + JNE loop + + MOVQ R8, 0(BX) + MOVQ R9, 8(BX) + + VMOVDQU Y8, 0(AX) + VMOVDQU Y9, 32(AX) + VZEROUPPER + + RET + +#define VPUNPCKLQDQ_X2_X2_X15 BYTE $0xC5; BYTE $0x69; BYTE $0x6C; BYTE $0xFA +#define VPUNPCKLQDQ_X3_X3_X15 BYTE $0xC5; BYTE $0x61; BYTE $0x6C; BYTE $0xFB +#define VPUNPCKLQDQ_X7_X7_X15 BYTE $0xC5; BYTE $0x41; BYTE $0x6C; BYTE $0xFF +#define VPUNPCKLQDQ_X13_X13_X15 BYTE $0xC4; BYTE $0x41; BYTE $0x11; BYTE $0x6C; BYTE $0xFD +#define VPUNPCKLQDQ_X14_X14_X15 BYTE $0xC4; BYTE $0x41; BYTE $0x09; BYTE $0x6C; BYTE $0xFE + +#define VPUNPCKHQDQ_X15_X2_X2 BYTE $0xC4; BYTE $0xC1; BYTE $0x69; BYTE $0x6D; BYTE $0xD7 +#define VPUNPCKHQDQ_X15_X3_X3 BYTE $0xC4; BYTE $0xC1; BYTE $0x61; BYTE $0x6D; BYTE $0xDF +#define VPUNPCKHQDQ_X15_X6_X6 BYTE $0xC4; BYTE $0xC1; BYTE $0x49; BYTE $0x6D; BYTE $0xF7 +#define VPUNPCKHQDQ_X15_X7_X7 BYTE $0xC4; BYTE $0xC1; BYTE $0x41; BYTE $0x6D; BYTE $0xFF +#define VPUNPCKHQDQ_X15_X3_X2 BYTE $0xC4; BYTE $0xC1; BYTE $0x61; BYTE $0x6D; BYTE $0xD7 +#define VPUNPCKHQDQ_X15_X7_X6 BYTE $0xC4; BYTE $0xC1; BYTE $0x41; BYTE $0x6D; BYTE $0xF7 +#define VPUNPCKHQDQ_X15_X13_X3 BYTE $0xC4; BYTE $0xC1; BYTE $0x11; BYTE $0x6D; BYTE $0xDF +#define VPUNPCKHQDQ_X15_X13_X7 BYTE $0xC4; BYTE $0xC1; BYTE $0x11; BYTE $0x6D; BYTE $0xFF + +#define SHUFFLE_AVX() \ + VMOVDQA X6, X13; \ + VMOVDQA X2, X14; \ + VMOVDQA X4, X6; \ + VPUNPCKLQDQ_X13_X13_X15; \ + VMOVDQA X5, X4; \ + VMOVDQA X6, X5; \ + VPUNPCKHQDQ_X15_X7_X6; \ + VPUNPCKLQDQ_X7_X7_X15; \ + VPUNPCKHQDQ_X15_X13_X7; \ + VPUNPCKLQDQ_X3_X3_X15; \ + VPUNPCKHQDQ_X15_X2_X2; \ + VPUNPCKLQDQ_X14_X14_X15; \ + VPUNPCKHQDQ_X15_X3_X3; \ + +#define SHUFFLE_AVX_INV() \ + VMOVDQA X2, X13; \ + VMOVDQA X4, X14; \ + VPUNPCKLQDQ_X2_X2_X15; \ + VMOVDQA X5, X4; \ + VPUNPCKHQDQ_X15_X3_X2; \ + VMOVDQA X14, X5; \ + VPUNPCKLQDQ_X3_X3_X15; \ + VMOVDQA X6, X14; \ + VPUNPCKHQDQ_X15_X13_X3; \ + VPUNPCKLQDQ_X7_X7_X15; \ + VPUNPCKHQDQ_X15_X6_X6; \ + VPUNPCKLQDQ_X14_X14_X15; \ + VPUNPCKHQDQ_X15_X7_X7; \ + +#define HALF_ROUND_AVX(v0, v1, v2, v3, v4, v5, v6, v7, m0, m1, m2, m3, t0, c40, c48) \ + VPADDQ m0, v0, v0; \ + VPADDQ v2, v0, v0; \ + VPADDQ m1, v1, v1; \ + VPADDQ v3, v1, v1; \ + VPXOR v0, v6, v6; \ + VPXOR v1, v7, v7; \ + VPSHUFD $-79, v6, v6; \ + VPSHUFD $-79, v7, v7; \ + VPADDQ v6, v4, v4; \ + VPADDQ v7, v5, v5; \ + VPXOR v4, v2, v2; \ + VPXOR v5, v3, v3; \ + VPSHUFB c40, v2, v2; \ + VPSHUFB c40, v3, v3; \ + VPADDQ m2, v0, v0; \ + VPADDQ v2, v0, v0; \ + VPADDQ m3, v1, v1; \ + VPADDQ v3, v1, v1; \ + VPXOR v0, v6, v6; \ + VPXOR v1, v7, v7; \ + VPSHUFB c48, v6, v6; \ + VPSHUFB c48, v7, v7; \ + VPADDQ v6, v4, v4; \ + VPADDQ v7, v5, v5; \ + VPXOR v4, v2, v2; \ + VPXOR v5, v3, v3; \ + VPADDQ v2, v2, t0; \ + VPSRLQ $63, v2, v2; \ + VPXOR t0, v2, v2; \ + VPADDQ v3, v3, t0; \ + VPSRLQ $63, v3, v3; \ + VPXOR t0, v3, v3 + +// load msg: X12 = (i0, i1), X13 = (i2, i3), X14 = (i4, i5), X15 = (i6, i7) +// i0, i1, i2, i3, i4, i5, i6, i7 must not be 0 +#define LOAD_MSG_AVX(i0, i1, i2, i3, i4, i5, i6, i7) \ + VMOVQ_SI_X12(i0*8); \ + VMOVQ_SI_X13(i2*8); \ + VMOVQ_SI_X14(i4*8); \ + VMOVQ_SI_X15(i6*8); \ + VPINSRQ_1_SI_X12(i1*8); \ + VPINSRQ_1_SI_X13(i3*8); \ + VPINSRQ_1_SI_X14(i5*8); \ + VPINSRQ_1_SI_X15(i7*8) + +// load msg: X12 = (0, 2), X13 = (4, 6), X14 = (1, 3), X15 = (5, 7) +#define LOAD_MSG_AVX_0_2_4_6_1_3_5_7() \ + VMOVQ_SI_X12_0; \ + VMOVQ_SI_X13(4*8); \ + VMOVQ_SI_X14(1*8); \ + VMOVQ_SI_X15(5*8); \ + VPINSRQ_1_SI_X12(2*8); \ + VPINSRQ_1_SI_X13(6*8); \ + VPINSRQ_1_SI_X14(3*8); \ + VPINSRQ_1_SI_X15(7*8) + +// load msg: X12 = (1, 0), X13 = (11, 5), X14 = (12, 2), X15 = (7, 3) +#define LOAD_MSG_AVX_1_0_11_5_12_2_7_3() \ + VPSHUFD $0x4E, 0*8(SI), X12; \ + VMOVQ_SI_X13(11*8); \ + VMOVQ_SI_X14(12*8); \ + VMOVQ_SI_X15(7*8); \ + VPINSRQ_1_SI_X13(5*8); \ + VPINSRQ_1_SI_X14(2*8); \ + VPINSRQ_1_SI_X15(3*8) + +// load msg: X12 = (11, 12), X13 = (5, 15), X14 = (8, 0), X15 = (2, 13) +#define LOAD_MSG_AVX_11_12_5_15_8_0_2_13() \ + VMOVDQU 11*8(SI), X12; \ + VMOVQ_SI_X13(5*8); \ + VMOVQ_SI_X14(8*8); \ + VMOVQ_SI_X15(2*8); \ + VPINSRQ_1_SI_X13(15*8); \ + VPINSRQ_1_SI_X14_0; \ + VPINSRQ_1_SI_X15(13*8) + +// load msg: X12 = (2, 5), X13 = (4, 15), X14 = (6, 10), X15 = (0, 8) +#define LOAD_MSG_AVX_2_5_4_15_6_10_0_8() \ + VMOVQ_SI_X12(2*8); \ + VMOVQ_SI_X13(4*8); \ + VMOVQ_SI_X14(6*8); \ + VMOVQ_SI_X15_0; \ + VPINSRQ_1_SI_X12(5*8); \ + VPINSRQ_1_SI_X13(15*8); \ + VPINSRQ_1_SI_X14(10*8); \ + VPINSRQ_1_SI_X15(8*8) + +// load msg: X12 = (9, 5), X13 = (2, 10), X14 = (0, 7), X15 = (4, 15) +#define LOAD_MSG_AVX_9_5_2_10_0_7_4_15() \ + VMOVQ_SI_X12(9*8); \ + VMOVQ_SI_X13(2*8); \ + VMOVQ_SI_X14_0; \ + VMOVQ_SI_X15(4*8); \ + VPINSRQ_1_SI_X12(5*8); \ + VPINSRQ_1_SI_X13(10*8); \ + VPINSRQ_1_SI_X14(7*8); \ + VPINSRQ_1_SI_X15(15*8) + +// load msg: X12 = (2, 6), X13 = (0, 8), X14 = (12, 10), X15 = (11, 3) +#define LOAD_MSG_AVX_2_6_0_8_12_10_11_3() \ + VMOVQ_SI_X12(2*8); \ + VMOVQ_SI_X13_0; \ + VMOVQ_SI_X14(12*8); \ + VMOVQ_SI_X15(11*8); \ + VPINSRQ_1_SI_X12(6*8); \ + VPINSRQ_1_SI_X13(8*8); \ + VPINSRQ_1_SI_X14(10*8); \ + VPINSRQ_1_SI_X15(3*8) + +// load msg: X12 = (0, 6), X13 = (9, 8), X14 = (7, 3), X15 = (2, 11) +#define LOAD_MSG_AVX_0_6_9_8_7_3_2_11() \ + MOVQ 0*8(SI), X12; \ + VPSHUFD $0x4E, 8*8(SI), X13; \ + MOVQ 7*8(SI), X14; \ + MOVQ 2*8(SI), X15; \ + VPINSRQ_1_SI_X12(6*8); \ + VPINSRQ_1_SI_X14(3*8); \ + VPINSRQ_1_SI_X15(11*8) + +// load msg: X12 = (6, 14), X13 = (11, 0), X14 = (15, 9), X15 = (3, 8) +#define LOAD_MSG_AVX_6_14_11_0_15_9_3_8() \ + MOVQ 6*8(SI), X12; \ + MOVQ 11*8(SI), X13; \ + MOVQ 15*8(SI), X14; \ + MOVQ 3*8(SI), X15; \ + VPINSRQ_1_SI_X12(14*8); \ + VPINSRQ_1_SI_X13_0; \ + VPINSRQ_1_SI_X14(9*8); \ + VPINSRQ_1_SI_X15(8*8) + +// load msg: X12 = (5, 15), X13 = (8, 2), X14 = (0, 4), X15 = (6, 10) +#define LOAD_MSG_AVX_5_15_8_2_0_4_6_10() \ + MOVQ 5*8(SI), X12; \ + MOVQ 8*8(SI), X13; \ + MOVQ 0*8(SI), X14; \ + MOVQ 6*8(SI), X15; \ + VPINSRQ_1_SI_X12(15*8); \ + VPINSRQ_1_SI_X13(2*8); \ + VPINSRQ_1_SI_X14(4*8); \ + VPINSRQ_1_SI_X15(10*8) + +// load msg: X12 = (12, 13), X13 = (1, 10), X14 = (2, 7), X15 = (4, 5) +#define LOAD_MSG_AVX_12_13_1_10_2_7_4_5() \ + VMOVDQU 12*8(SI), X12; \ + MOVQ 1*8(SI), X13; \ + MOVQ 2*8(SI), X14; \ + VPINSRQ_1_SI_X13(10*8); \ + VPINSRQ_1_SI_X14(7*8); \ + VMOVDQU 4*8(SI), X15 + +// load msg: X12 = (15, 9), X13 = (3, 13), X14 = (11, 14), X15 = (12, 0) +#define LOAD_MSG_AVX_15_9_3_13_11_14_12_0() \ + MOVQ 15*8(SI), X12; \ + MOVQ 3*8(SI), X13; \ + MOVQ 11*8(SI), X14; \ + MOVQ 12*8(SI), X15; \ + VPINSRQ_1_SI_X12(9*8); \ + VPINSRQ_1_SI_X13(13*8); \ + VPINSRQ_1_SI_X14(14*8); \ + VPINSRQ_1_SI_X15_0 + +// func hashBlocksAVX(h *[8]uint64, c *[2]uint64, flag uint64, blocks []byte) +TEXT ·hashBlocksAVX(SB), 4, $288-48 // frame size = 272 + 16 byte alignment + MOVQ h+0(FP), AX + MOVQ c+8(FP), BX + MOVQ flag+16(FP), CX + MOVQ blocks_base+24(FP), SI + MOVQ blocks_len+32(FP), DI + + MOVQ SP, R10 + ADDQ $15, R10 + ANDQ $~15, R10 + + VMOVDQU ·AVX_c40<>(SB), X0 + VMOVDQU ·AVX_c48<>(SB), X1 + VMOVDQA X0, X8 + VMOVDQA X1, X9 + + VMOVDQU ·AVX_iv3<>(SB), X0 + VMOVDQA X0, 0(R10) + XORQ CX, 0(R10) // 0(R10) = ·AVX_iv3 ^ (CX || 0) + + VMOVDQU 0(AX), X10 + VMOVDQU 16(AX), X11 + VMOVDQU 32(AX), X2 + VMOVDQU 48(AX), X3 + + MOVQ 0(BX), R8 + MOVQ 8(BX), R9 + +loop: + ADDQ $128, R8 + CMPQ R8, $128 + JGE noinc + INCQ R9 + +noinc: + VMOVQ_R8_X15 + VPINSRQ_1_R9_X15 + + VMOVDQA X10, X0 + VMOVDQA X11, X1 + VMOVDQU ·AVX_iv0<>(SB), X4 + VMOVDQU ·AVX_iv1<>(SB), X5 + VMOVDQU ·AVX_iv2<>(SB), X6 + + VPXOR X15, X6, X6 + VMOVDQA 0(R10), X7 + + LOAD_MSG_AVX_0_2_4_6_1_3_5_7() + VMOVDQA X12, 16(R10) + VMOVDQA X13, 32(R10) + VMOVDQA X14, 48(R10) + VMOVDQA X15, 64(R10) + HALF_ROUND_AVX(X0, X1, X2, X3, X4, X5, X6, X7, X12, X13, X14, X15, X15, X8, X9) + SHUFFLE_AVX() + LOAD_MSG_AVX(8, 10, 12, 14, 9, 11, 13, 15) + VMOVDQA X12, 80(R10) + VMOVDQA X13, 96(R10) + VMOVDQA X14, 112(R10) + VMOVDQA X15, 128(R10) + HALF_ROUND_AVX(X0, X1, X2, X3, X4, X5, X6, X7, X12, X13, X14, X15, X15, X8, X9) + SHUFFLE_AVX_INV() + + LOAD_MSG_AVX(14, 4, 9, 13, 10, 8, 15, 6) + VMOVDQA X12, 144(R10) + VMOVDQA X13, 160(R10) + VMOVDQA X14, 176(R10) + VMOVDQA X15, 192(R10) + HALF_ROUND_AVX(X0, X1, X2, X3, X4, X5, X6, X7, X12, X13, X14, X15, X15, X8, X9) + SHUFFLE_AVX() + LOAD_MSG_AVX_1_0_11_5_12_2_7_3() + VMOVDQA X12, 208(R10) + VMOVDQA X13, 224(R10) + VMOVDQA X14, 240(R10) + VMOVDQA X15, 256(R10) + HALF_ROUND_AVX(X0, X1, X2, X3, X4, X5, X6, X7, X12, X13, X14, X15, X15, X8, X9) + SHUFFLE_AVX_INV() + + LOAD_MSG_AVX_11_12_5_15_8_0_2_13() + HALF_ROUND_AVX(X0, X1, X2, X3, X4, X5, X6, X7, X12, X13, X14, X15, X15, X8, X9) + SHUFFLE_AVX() + LOAD_MSG_AVX(10, 3, 7, 9, 14, 6, 1, 4) + HALF_ROUND_AVX(X0, X1, X2, X3, X4, X5, X6, X7, X12, X13, X14, X15, X15, X8, X9) + SHUFFLE_AVX_INV() + + LOAD_MSG_AVX(7, 3, 13, 11, 9, 1, 12, 14) + HALF_ROUND_AVX(X0, X1, X2, X3, X4, X5, X6, X7, X12, X13, X14, X15, X15, X8, X9) + SHUFFLE_AVX() + LOAD_MSG_AVX_2_5_4_15_6_10_0_8() + HALF_ROUND_AVX(X0, X1, X2, X3, X4, X5, X6, X7, X12, X13, X14, X15, X15, X8, X9) + SHUFFLE_AVX_INV() + + LOAD_MSG_AVX_9_5_2_10_0_7_4_15() + HALF_ROUND_AVX(X0, X1, X2, X3, X4, X5, X6, X7, X12, X13, X14, X15, X15, X8, X9) + SHUFFLE_AVX() + LOAD_MSG_AVX(14, 11, 6, 3, 1, 12, 8, 13) + HALF_ROUND_AVX(X0, X1, X2, X3, X4, X5, X6, X7, X12, X13, X14, X15, X15, X8, X9) + SHUFFLE_AVX_INV() + + LOAD_MSG_AVX_2_6_0_8_12_10_11_3() + HALF_ROUND_AVX(X0, X1, X2, X3, X4, X5, X6, X7, X12, X13, X14, X15, X15, X8, X9) + SHUFFLE_AVX() + LOAD_MSG_AVX(4, 7, 15, 1, 13, 5, 14, 9) + HALF_ROUND_AVX(X0, X1, X2, X3, X4, X5, X6, X7, X12, X13, X14, X15, X15, X8, X9) + SHUFFLE_AVX_INV() + + LOAD_MSG_AVX(12, 1, 14, 4, 5, 15, 13, 10) + HALF_ROUND_AVX(X0, X1, X2, X3, X4, X5, X6, X7, X12, X13, X14, X15, X15, X8, X9) + SHUFFLE_AVX() + LOAD_MSG_AVX_0_6_9_8_7_3_2_11() + HALF_ROUND_AVX(X0, X1, X2, X3, X4, X5, X6, X7, X12, X13, X14, X15, X15, X8, X9) + SHUFFLE_AVX_INV() + + LOAD_MSG_AVX(13, 7, 12, 3, 11, 14, 1, 9) + HALF_ROUND_AVX(X0, X1, X2, X3, X4, X5, X6, X7, X12, X13, X14, X15, X15, X8, X9) + SHUFFLE_AVX() + LOAD_MSG_AVX_5_15_8_2_0_4_6_10() + HALF_ROUND_AVX(X0, X1, X2, X3, X4, X5, X6, X7, X12, X13, X14, X15, X15, X8, X9) + SHUFFLE_AVX_INV() + + LOAD_MSG_AVX_6_14_11_0_15_9_3_8() + HALF_ROUND_AVX(X0, X1, X2, X3, X4, X5, X6, X7, X12, X13, X14, X15, X15, X8, X9) + SHUFFLE_AVX() + LOAD_MSG_AVX_12_13_1_10_2_7_4_5() + HALF_ROUND_AVX(X0, X1, X2, X3, X4, X5, X6, X7, X12, X13, X14, X15, X15, X8, X9) + SHUFFLE_AVX_INV() + + LOAD_MSG_AVX(10, 8, 7, 1, 2, 4, 6, 5) + HALF_ROUND_AVX(X0, X1, X2, X3, X4, X5, X6, X7, X12, X13, X14, X15, X15, X8, X9) + SHUFFLE_AVX() + LOAD_MSG_AVX_15_9_3_13_11_14_12_0() + HALF_ROUND_AVX(X0, X1, X2, X3, X4, X5, X6, X7, X12, X13, X14, X15, X15, X8, X9) + SHUFFLE_AVX_INV() + + HALF_ROUND_AVX(X0, X1, X2, X3, X4, X5, X6, X7, 16(R10), 32(R10), 48(R10), 64(R10), X15, X8, X9) + SHUFFLE_AVX() + HALF_ROUND_AVX(X0, X1, X2, X3, X4, X5, X6, X7, 80(R10), 96(R10), 112(R10), 128(R10), X15, X8, X9) + SHUFFLE_AVX_INV() + + HALF_ROUND_AVX(X0, X1, X2, X3, X4, X5, X6, X7, 144(R10), 160(R10), 176(R10), 192(R10), X15, X8, X9) + SHUFFLE_AVX() + HALF_ROUND_AVX(X0, X1, X2, X3, X4, X5, X6, X7, 208(R10), 224(R10), 240(R10), 256(R10), X15, X8, X9) + SHUFFLE_AVX_INV() + + VMOVDQU 32(AX), X14 + VMOVDQU 48(AX), X15 + VPXOR X0, X10, X10 + VPXOR X1, X11, X11 + VPXOR X2, X14, X14 + VPXOR X3, X15, X15 + VPXOR X4, X10, X10 + VPXOR X5, X11, X11 + VPXOR X6, X14, X2 + VPXOR X7, X15, X3 + VMOVDQU X2, 32(AX) + VMOVDQU X3, 48(AX) + + LEAQ 128(SI), SI + SUBQ $128, DI + JNE loop + + VMOVDQU X10, 0(AX) + VMOVDQU X11, 16(AX) + + MOVQ R8, 0(BX) + MOVQ R9, 8(BX) + VZEROUPPER + + RET diff --git a/vendor/golang.org/x/crypto/blake2b/blake2b_amd64.go b/vendor/golang.org/x/crypto/blake2b/blake2b_amd64.go new file mode 100644 index 00000000..5fa1b328 --- /dev/null +++ b/vendor/golang.org/x/crypto/blake2b/blake2b_amd64.go @@ -0,0 +1,25 @@ +// Copyright 2016 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 !go1.7 && amd64 && gc && !purego +// +build !go1.7,amd64,gc,!purego + +package blake2b + +import "golang.org/x/sys/cpu" + +func init() { + useSSE4 = cpu.X86.HasSSE41 +} + +//go:noescape +func hashBlocksSSE4(h *[8]uint64, c *[2]uint64, flag uint64, blocks []byte) + +func hashBlocks(h *[8]uint64, c *[2]uint64, flag uint64, blocks []byte) { + if useSSE4 { + hashBlocksSSE4(h, c, flag, blocks) + } else { + hashBlocksGeneric(h, c, flag, blocks) + } +} diff --git a/vendor/golang.org/x/crypto/blake2b/blake2b_amd64.s b/vendor/golang.org/x/crypto/blake2b/blake2b_amd64.s new file mode 100644 index 00000000..ae75eb9a --- /dev/null +++ b/vendor/golang.org/x/crypto/blake2b/blake2b_amd64.s @@ -0,0 +1,279 @@ +// Copyright 2016 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 && gc && !purego +// +build amd64,gc,!purego + +#include "textflag.h" + +DATA ·iv0<>+0x00(SB)/8, $0x6a09e667f3bcc908 +DATA ·iv0<>+0x08(SB)/8, $0xbb67ae8584caa73b +GLOBL ·iv0<>(SB), (NOPTR+RODATA), $16 + +DATA ·iv1<>+0x00(SB)/8, $0x3c6ef372fe94f82b +DATA ·iv1<>+0x08(SB)/8, $0xa54ff53a5f1d36f1 +GLOBL ·iv1<>(SB), (NOPTR+RODATA), $16 + +DATA ·iv2<>+0x00(SB)/8, $0x510e527fade682d1 +DATA ·iv2<>+0x08(SB)/8, $0x9b05688c2b3e6c1f +GLOBL ·iv2<>(SB), (NOPTR+RODATA), $16 + +DATA ·iv3<>+0x00(SB)/8, $0x1f83d9abfb41bd6b +DATA ·iv3<>+0x08(SB)/8, $0x5be0cd19137e2179 +GLOBL ·iv3<>(SB), (NOPTR+RODATA), $16 + +DATA ·c40<>+0x00(SB)/8, $0x0201000706050403 +DATA ·c40<>+0x08(SB)/8, $0x0a09080f0e0d0c0b +GLOBL ·c40<>(SB), (NOPTR+RODATA), $16 + +DATA ·c48<>+0x00(SB)/8, $0x0100070605040302 +DATA ·c48<>+0x08(SB)/8, $0x09080f0e0d0c0b0a +GLOBL ·c48<>(SB), (NOPTR+RODATA), $16 + +#define SHUFFLE(v2, v3, v4, v5, v6, v7, t1, t2) \ + MOVO v4, t1; \ + MOVO v5, v4; \ + MOVO t1, v5; \ + MOVO v6, t1; \ + PUNPCKLQDQ v6, t2; \ + PUNPCKHQDQ v7, v6; \ + PUNPCKHQDQ t2, v6; \ + PUNPCKLQDQ v7, t2; \ + MOVO t1, v7; \ + MOVO v2, t1; \ + PUNPCKHQDQ t2, v7; \ + PUNPCKLQDQ v3, t2; \ + PUNPCKHQDQ t2, v2; \ + PUNPCKLQDQ t1, t2; \ + PUNPCKHQDQ t2, v3 + +#define SHUFFLE_INV(v2, v3, v4, v5, v6, v7, t1, t2) \ + MOVO v4, t1; \ + MOVO v5, v4; \ + MOVO t1, v5; \ + MOVO v2, t1; \ + PUNPCKLQDQ v2, t2; \ + PUNPCKHQDQ v3, v2; \ + PUNPCKHQDQ t2, v2; \ + PUNPCKLQDQ v3, t2; \ + MOVO t1, v3; \ + MOVO v6, t1; \ + PUNPCKHQDQ t2, v3; \ + PUNPCKLQDQ v7, t2; \ + PUNPCKHQDQ t2, v6; \ + PUNPCKLQDQ t1, t2; \ + PUNPCKHQDQ t2, v7 + +#define HALF_ROUND(v0, v1, v2, v3, v4, v5, v6, v7, m0, m1, m2, m3, t0, c40, c48) \ + PADDQ m0, v0; \ + PADDQ m1, v1; \ + PADDQ v2, v0; \ + PADDQ v3, v1; \ + PXOR v0, v6; \ + PXOR v1, v7; \ + PSHUFD $0xB1, v6, v6; \ + PSHUFD $0xB1, v7, v7; \ + PADDQ v6, v4; \ + PADDQ v7, v5; \ + PXOR v4, v2; \ + PXOR v5, v3; \ + PSHUFB c40, v2; \ + PSHUFB c40, v3; \ + PADDQ m2, v0; \ + PADDQ m3, v1; \ + PADDQ v2, v0; \ + PADDQ v3, v1; \ + PXOR v0, v6; \ + PXOR v1, v7; \ + PSHUFB c48, v6; \ + PSHUFB c48, v7; \ + PADDQ v6, v4; \ + PADDQ v7, v5; \ + PXOR v4, v2; \ + PXOR v5, v3; \ + MOVOU v2, t0; \ + PADDQ v2, t0; \ + PSRLQ $63, v2; \ + PXOR t0, v2; \ + MOVOU v3, t0; \ + PADDQ v3, t0; \ + PSRLQ $63, v3; \ + PXOR t0, v3 + +#define LOAD_MSG(m0, m1, m2, m3, src, i0, i1, i2, i3, i4, i5, i6, i7) \ + MOVQ i0*8(src), m0; \ + PINSRQ $1, i1*8(src), m0; \ + MOVQ i2*8(src), m1; \ + PINSRQ $1, i3*8(src), m1; \ + MOVQ i4*8(src), m2; \ + PINSRQ $1, i5*8(src), m2; \ + MOVQ i6*8(src), m3; \ + PINSRQ $1, i7*8(src), m3 + +// func hashBlocksSSE4(h *[8]uint64, c *[2]uint64, flag uint64, blocks []byte) +TEXT ·hashBlocksSSE4(SB), 4, $288-48 // frame size = 272 + 16 byte alignment + MOVQ h+0(FP), AX + MOVQ c+8(FP), BX + MOVQ flag+16(FP), CX + MOVQ blocks_base+24(FP), SI + MOVQ blocks_len+32(FP), DI + + MOVQ SP, R10 + ADDQ $15, R10 + ANDQ $~15, R10 + + MOVOU ·iv3<>(SB), X0 + MOVO X0, 0(R10) + XORQ CX, 0(R10) // 0(R10) = ·iv3 ^ (CX || 0) + + MOVOU ·c40<>(SB), X13 + MOVOU ·c48<>(SB), X14 + + MOVOU 0(AX), X12 + MOVOU 16(AX), X15 + + MOVQ 0(BX), R8 + MOVQ 8(BX), R9 + +loop: + ADDQ $128, R8 + CMPQ R8, $128 + JGE noinc + INCQ R9 + +noinc: + MOVQ R8, X8 + PINSRQ $1, R9, X8 + + MOVO X12, X0 + MOVO X15, X1 + MOVOU 32(AX), X2 + MOVOU 48(AX), X3 + MOVOU ·iv0<>(SB), X4 + MOVOU ·iv1<>(SB), X5 + MOVOU ·iv2<>(SB), X6 + + PXOR X8, X6 + MOVO 0(R10), X7 + + LOAD_MSG(X8, X9, X10, X11, SI, 0, 2, 4, 6, 1, 3, 5, 7) + MOVO X8, 16(R10) + MOVO X9, 32(R10) + MOVO X10, 48(R10) + MOVO X11, 64(R10) + HALF_ROUND(X0, X1, X2, X3, X4, X5, X6, X7, X8, X9, X10, X11, X11, X13, X14) + SHUFFLE(X2, X3, X4, X5, X6, X7, X8, X9) + LOAD_MSG(X8, X9, X10, X11, SI, 8, 10, 12, 14, 9, 11, 13, 15) + MOVO X8, 80(R10) + MOVO X9, 96(R10) + MOVO X10, 112(R10) + MOVO X11, 128(R10) + HALF_ROUND(X0, X1, X2, X3, X4, X5, X6, X7, X8, X9, X10, X11, X11, X13, X14) + SHUFFLE_INV(X2, X3, X4, X5, X6, X7, X8, X9) + + LOAD_MSG(X8, X9, X10, X11, SI, 14, 4, 9, 13, 10, 8, 15, 6) + MOVO X8, 144(R10) + MOVO X9, 160(R10) + MOVO X10, 176(R10) + MOVO X11, 192(R10) + HALF_ROUND(X0, X1, X2, X3, X4, X5, X6, X7, X8, X9, X10, X11, X11, X13, X14) + SHUFFLE(X2, X3, X4, X5, X6, X7, X8, X9) + LOAD_MSG(X8, X9, X10, X11, SI, 1, 0, 11, 5, 12, 2, 7, 3) + MOVO X8, 208(R10) + MOVO X9, 224(R10) + MOVO X10, 240(R10) + MOVO X11, 256(R10) + HALF_ROUND(X0, X1, X2, X3, X4, X5, X6, X7, X8, X9, X10, X11, X11, X13, X14) + SHUFFLE_INV(X2, X3, X4, X5, X6, X7, X8, X9) + + LOAD_MSG(X8, X9, X10, X11, SI, 11, 12, 5, 15, 8, 0, 2, 13) + HALF_ROUND(X0, X1, X2, X3, X4, X5, X6, X7, X8, X9, X10, X11, X11, X13, X14) + SHUFFLE(X2, X3, X4, X5, X6, X7, X8, X9) + LOAD_MSG(X8, X9, X10, X11, SI, 10, 3, 7, 9, 14, 6, 1, 4) + HALF_ROUND(X0, X1, X2, X3, X4, X5, X6, X7, X8, X9, X10, X11, X11, X13, X14) + SHUFFLE_INV(X2, X3, X4, X5, X6, X7, X8, X9) + + LOAD_MSG(X8, X9, X10, X11, SI, 7, 3, 13, 11, 9, 1, 12, 14) + HALF_ROUND(X0, X1, X2, X3, X4, X5, X6, X7, X8, X9, X10, X11, X11, X13, X14) + SHUFFLE(X2, X3, X4, X5, X6, X7, X8, X9) + LOAD_MSG(X8, X9, X10, X11, SI, 2, 5, 4, 15, 6, 10, 0, 8) + HALF_ROUND(X0, X1, X2, X3, X4, X5, X6, X7, X8, X9, X10, X11, X11, X13, X14) + SHUFFLE_INV(X2, X3, X4, X5, X6, X7, X8, X9) + + LOAD_MSG(X8, X9, X10, X11, SI, 9, 5, 2, 10, 0, 7, 4, 15) + HALF_ROUND(X0, X1, X2, X3, X4, X5, X6, X7, X8, X9, X10, X11, X11, X13, X14) + SHUFFLE(X2, X3, X4, X5, X6, X7, X8, X9) + LOAD_MSG(X8, X9, X10, X11, SI, 14, 11, 6, 3, 1, 12, 8, 13) + HALF_ROUND(X0, X1, X2, X3, X4, X5, X6, X7, X8, X9, X10, X11, X11, X13, X14) + SHUFFLE_INV(X2, X3, X4, X5, X6, X7, X8, X9) + + LOAD_MSG(X8, X9, X10, X11, SI, 2, 6, 0, 8, 12, 10, 11, 3) + HALF_ROUND(X0, X1, X2, X3, X4, X5, X6, X7, X8, X9, X10, X11, X11, X13, X14) + SHUFFLE(X2, X3, X4, X5, X6, X7, X8, X9) + LOAD_MSG(X8, X9, X10, X11, SI, 4, 7, 15, 1, 13, 5, 14, 9) + HALF_ROUND(X0, X1, X2, X3, X4, X5, X6, X7, X8, X9, X10, X11, X11, X13, X14) + SHUFFLE_INV(X2, X3, X4, X5, X6, X7, X8, X9) + + LOAD_MSG(X8, X9, X10, X11, SI, 12, 1, 14, 4, 5, 15, 13, 10) + HALF_ROUND(X0, X1, X2, X3, X4, X5, X6, X7, X8, X9, X10, X11, X11, X13, X14) + SHUFFLE(X2, X3, X4, X5, X6, X7, X8, X9) + LOAD_MSG(X8, X9, X10, X11, SI, 0, 6, 9, 8, 7, 3, 2, 11) + HALF_ROUND(X0, X1, X2, X3, X4, X5, X6, X7, X8, X9, X10, X11, X11, X13, X14) + SHUFFLE_INV(X2, X3, X4, X5, X6, X7, X8, X9) + + LOAD_MSG(X8, X9, X10, X11, SI, 13, 7, 12, 3, 11, 14, 1, 9) + HALF_ROUND(X0, X1, X2, X3, X4, X5, X6, X7, X8, X9, X10, X11, X11, X13, X14) + SHUFFLE(X2, X3, X4, X5, X6, X7, X8, X9) + LOAD_MSG(X8, X9, X10, X11, SI, 5, 15, 8, 2, 0, 4, 6, 10) + HALF_ROUND(X0, X1, X2, X3, X4, X5, X6, X7, X8, X9, X10, X11, X11, X13, X14) + SHUFFLE_INV(X2, X3, X4, X5, X6, X7, X8, X9) + + LOAD_MSG(X8, X9, X10, X11, SI, 6, 14, 11, 0, 15, 9, 3, 8) + HALF_ROUND(X0, X1, X2, X3, X4, X5, X6, X7, X8, X9, X10, X11, X11, X13, X14) + SHUFFLE(X2, X3, X4, X5, X6, X7, X8, X9) + LOAD_MSG(X8, X9, X10, X11, SI, 12, 13, 1, 10, 2, 7, 4, 5) + HALF_ROUND(X0, X1, X2, X3, X4, X5, X6, X7, X8, X9, X10, X11, X11, X13, X14) + SHUFFLE_INV(X2, X3, X4, X5, X6, X7, X8, X9) + + LOAD_MSG(X8, X9, X10, X11, SI, 10, 8, 7, 1, 2, 4, 6, 5) + HALF_ROUND(X0, X1, X2, X3, X4, X5, X6, X7, X8, X9, X10, X11, X11, X13, X14) + SHUFFLE(X2, X3, X4, X5, X6, X7, X8, X9) + LOAD_MSG(X8, X9, X10, X11, SI, 15, 9, 3, 13, 11, 14, 12, 0) + HALF_ROUND(X0, X1, X2, X3, X4, X5, X6, X7, X8, X9, X10, X11, X11, X13, X14) + SHUFFLE_INV(X2, X3, X4, X5, X6, X7, X8, X9) + + HALF_ROUND(X0, X1, X2, X3, X4, X5, X6, X7, 16(R10), 32(R10), 48(R10), 64(R10), X11, X13, X14) + SHUFFLE(X2, X3, X4, X5, X6, X7, X8, X9) + HALF_ROUND(X0, X1, X2, X3, X4, X5, X6, X7, 80(R10), 96(R10), 112(R10), 128(R10), X11, X13, X14) + SHUFFLE_INV(X2, X3, X4, X5, X6, X7, X8, X9) + + HALF_ROUND(X0, X1, X2, X3, X4, X5, X6, X7, 144(R10), 160(R10), 176(R10), 192(R10), X11, X13, X14) + SHUFFLE(X2, X3, X4, X5, X6, X7, X8, X9) + HALF_ROUND(X0, X1, X2, X3, X4, X5, X6, X7, 208(R10), 224(R10), 240(R10), 256(R10), X11, X13, X14) + SHUFFLE_INV(X2, X3, X4, X5, X6, X7, X8, X9) + + MOVOU 32(AX), X10 + MOVOU 48(AX), X11 + PXOR X0, X12 + PXOR X1, X15 + PXOR X2, X10 + PXOR X3, X11 + PXOR X4, X12 + PXOR X5, X15 + PXOR X6, X10 + PXOR X7, X11 + MOVOU X10, 32(AX) + MOVOU X11, 48(AX) + + LEAQ 128(SI), SI + SUBQ $128, DI + JNE loop + + MOVOU X12, 0(AX) + MOVOU X15, 16(AX) + + MOVQ R8, 0(BX) + MOVQ R9, 8(BX) + + RET diff --git a/vendor/golang.org/x/crypto/blake2b/blake2b_generic.go b/vendor/golang.org/x/crypto/blake2b/blake2b_generic.go new file mode 100644 index 00000000..3168a8aa --- /dev/null +++ b/vendor/golang.org/x/crypto/blake2b/blake2b_generic.go @@ -0,0 +1,182 @@ +// Copyright 2016 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 blake2b + +import ( + "encoding/binary" + "math/bits" +) + +// the precomputed values for BLAKE2b +// there are 12 16-byte arrays - one for each round +// the entries are calculated from the sigma constants. +var precomputed = [12][16]byte{ + {0, 2, 4, 6, 1, 3, 5, 7, 8, 10, 12, 14, 9, 11, 13, 15}, + {14, 4, 9, 13, 10, 8, 15, 6, 1, 0, 11, 5, 12, 2, 7, 3}, + {11, 12, 5, 15, 8, 0, 2, 13, 10, 3, 7, 9, 14, 6, 1, 4}, + {7, 3, 13, 11, 9, 1, 12, 14, 2, 5, 4, 15, 6, 10, 0, 8}, + {9, 5, 2, 10, 0, 7, 4, 15, 14, 11, 6, 3, 1, 12, 8, 13}, + {2, 6, 0, 8, 12, 10, 11, 3, 4, 7, 15, 1, 13, 5, 14, 9}, + {12, 1, 14, 4, 5, 15, 13, 10, 0, 6, 9, 8, 7, 3, 2, 11}, + {13, 7, 12, 3, 11, 14, 1, 9, 5, 15, 8, 2, 0, 4, 6, 10}, + {6, 14, 11, 0, 15, 9, 3, 8, 12, 13, 1, 10, 2, 7, 4, 5}, + {10, 8, 7, 1, 2, 4, 6, 5, 15, 9, 3, 13, 11, 14, 12, 0}, + {0, 2, 4, 6, 1, 3, 5, 7, 8, 10, 12, 14, 9, 11, 13, 15}, // equal to the first + {14, 4, 9, 13, 10, 8, 15, 6, 1, 0, 11, 5, 12, 2, 7, 3}, // equal to the second +} + +func hashBlocksGeneric(h *[8]uint64, c *[2]uint64, flag uint64, blocks []byte) { + var m [16]uint64 + c0, c1 := c[0], c[1] + + for i := 0; i < len(blocks); { + c0 += BlockSize + if c0 < BlockSize { + c1++ + } + + v0, v1, v2, v3, v4, v5, v6, v7 := h[0], h[1], h[2], h[3], h[4], h[5], h[6], h[7] + v8, v9, v10, v11, v12, v13, v14, v15 := iv[0], iv[1], iv[2], iv[3], iv[4], iv[5], iv[6], iv[7] + v12 ^= c0 + v13 ^= c1 + v14 ^= flag + + for j := range m { + m[j] = binary.LittleEndian.Uint64(blocks[i:]) + i += 8 + } + + for j := range precomputed { + s := &(precomputed[j]) + + v0 += m[s[0]] + v0 += v4 + v12 ^= v0 + v12 = bits.RotateLeft64(v12, -32) + v8 += v12 + v4 ^= v8 + v4 = bits.RotateLeft64(v4, -24) + v1 += m[s[1]] + v1 += v5 + v13 ^= v1 + v13 = bits.RotateLeft64(v13, -32) + v9 += v13 + v5 ^= v9 + v5 = bits.RotateLeft64(v5, -24) + v2 += m[s[2]] + v2 += v6 + v14 ^= v2 + v14 = bits.RotateLeft64(v14, -32) + v10 += v14 + v6 ^= v10 + v6 = bits.RotateLeft64(v6, -24) + v3 += m[s[3]] + v3 += v7 + v15 ^= v3 + v15 = bits.RotateLeft64(v15, -32) + v11 += v15 + v7 ^= v11 + v7 = bits.RotateLeft64(v7, -24) + + v0 += m[s[4]] + v0 += v4 + v12 ^= v0 + v12 = bits.RotateLeft64(v12, -16) + v8 += v12 + v4 ^= v8 + v4 = bits.RotateLeft64(v4, -63) + v1 += m[s[5]] + v1 += v5 + v13 ^= v1 + v13 = bits.RotateLeft64(v13, -16) + v9 += v13 + v5 ^= v9 + v5 = bits.RotateLeft64(v5, -63) + v2 += m[s[6]] + v2 += v6 + v14 ^= v2 + v14 = bits.RotateLeft64(v14, -16) + v10 += v14 + v6 ^= v10 + v6 = bits.RotateLeft64(v6, -63) + v3 += m[s[7]] + v3 += v7 + v15 ^= v3 + v15 = bits.RotateLeft64(v15, -16) + v11 += v15 + v7 ^= v11 + v7 = bits.RotateLeft64(v7, -63) + + v0 += m[s[8]] + v0 += v5 + v15 ^= v0 + v15 = bits.RotateLeft64(v15, -32) + v10 += v15 + v5 ^= v10 + v5 = bits.RotateLeft64(v5, -24) + v1 += m[s[9]] + v1 += v6 + v12 ^= v1 + v12 = bits.RotateLeft64(v12, -32) + v11 += v12 + v6 ^= v11 + v6 = bits.RotateLeft64(v6, -24) + v2 += m[s[10]] + v2 += v7 + v13 ^= v2 + v13 = bits.RotateLeft64(v13, -32) + v8 += v13 + v7 ^= v8 + v7 = bits.RotateLeft64(v7, -24) + v3 += m[s[11]] + v3 += v4 + v14 ^= v3 + v14 = bits.RotateLeft64(v14, -32) + v9 += v14 + v4 ^= v9 + v4 = bits.RotateLeft64(v4, -24) + + v0 += m[s[12]] + v0 += v5 + v15 ^= v0 + v15 = bits.RotateLeft64(v15, -16) + v10 += v15 + v5 ^= v10 + v5 = bits.RotateLeft64(v5, -63) + v1 += m[s[13]] + v1 += v6 + v12 ^= v1 + v12 = bits.RotateLeft64(v12, -16) + v11 += v12 + v6 ^= v11 + v6 = bits.RotateLeft64(v6, -63) + v2 += m[s[14]] + v2 += v7 + v13 ^= v2 + v13 = bits.RotateLeft64(v13, -16) + v8 += v13 + v7 ^= v8 + v7 = bits.RotateLeft64(v7, -63) + v3 += m[s[15]] + v3 += v4 + v14 ^= v3 + v14 = bits.RotateLeft64(v14, -16) + v9 += v14 + v4 ^= v9 + v4 = bits.RotateLeft64(v4, -63) + + } + + h[0] ^= v0 ^ v8 + h[1] ^= v1 ^ v9 + h[2] ^= v2 ^ v10 + h[3] ^= v3 ^ v11 + h[4] ^= v4 ^ v12 + h[5] ^= v5 ^ v13 + h[6] ^= v6 ^ v14 + h[7] ^= v7 ^ v15 + } + c[0], c[1] = c0, c1 +} diff --git a/vendor/golang.org/x/crypto/blake2b/blake2b_ref.go b/vendor/golang.org/x/crypto/blake2b/blake2b_ref.go new file mode 100644 index 00000000..b0137cdf --- /dev/null +++ b/vendor/golang.org/x/crypto/blake2b/blake2b_ref.go @@ -0,0 +1,12 @@ +// Copyright 2016 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 || purego || !gc +// +build !amd64 purego !gc + +package blake2b + +func hashBlocks(h *[8]uint64, c *[2]uint64, flag uint64, blocks []byte) { + hashBlocksGeneric(h, c, flag, blocks) +} diff --git a/vendor/golang.org/x/crypto/blake2b/blake2x.go b/vendor/golang.org/x/crypto/blake2b/blake2x.go new file mode 100644 index 00000000..52c414db --- /dev/null +++ b/vendor/golang.org/x/crypto/blake2b/blake2x.go @@ -0,0 +1,177 @@ +// 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. + +package blake2b + +import ( + "encoding/binary" + "errors" + "io" +) + +// XOF defines the interface to hash functions that +// support arbitrary-length output. +type XOF interface { + // Write absorbs more data into the hash's state. It panics if called + // after Read. + io.Writer + + // Read reads more output from the hash. It returns io.EOF if the limit + // has been reached. + io.Reader + + // Clone returns a copy of the XOF in its current state. + Clone() XOF + + // Reset resets the XOF to its initial state. + Reset() +} + +// OutputLengthUnknown can be used as the size argument to NewXOF to indicate +// the length of the output is not known in advance. +const OutputLengthUnknown = 0 + +// magicUnknownOutputLength is a magic value for the output size that indicates +// an unknown number of output bytes. +const magicUnknownOutputLength = (1 << 32) - 1 + +// maxOutputLength is the absolute maximum number of bytes to produce when the +// number of output bytes is unknown. +const maxOutputLength = (1 << 32) * 64 + +// NewXOF creates a new variable-output-length hash. The hash either produce a +// known number of bytes (1 <= size < 2**32-1), or an unknown number of bytes +// (size == OutputLengthUnknown). In the latter case, an absolute limit of +// 256GiB applies. +// +// A non-nil key turns the hash into a MAC. The key must between +// zero and 32 bytes long. +func NewXOF(size uint32, key []byte) (XOF, error) { + if len(key) > Size { + return nil, errKeySize + } + if size == magicUnknownOutputLength { + // 2^32-1 indicates an unknown number of bytes and thus isn't a + // valid length. + return nil, errors.New("blake2b: XOF length too large") + } + if size == OutputLengthUnknown { + size = magicUnknownOutputLength + } + x := &xof{ + d: digest{ + size: Size, + keyLen: len(key), + }, + length: size, + } + copy(x.d.key[:], key) + x.Reset() + return x, nil +} + +type xof struct { + d digest + length uint32 + remaining uint64 + cfg, root, block [Size]byte + offset int + nodeOffset uint32 + readMode bool +} + +func (x *xof) Write(p []byte) (n int, err error) { + if x.readMode { + panic("blake2b: write to XOF after read") + } + return x.d.Write(p) +} + +func (x *xof) Clone() XOF { + clone := *x + return &clone +} + +func (x *xof) Reset() { + x.cfg[0] = byte(Size) + binary.LittleEndian.PutUint32(x.cfg[4:], uint32(Size)) // leaf length + binary.LittleEndian.PutUint32(x.cfg[12:], x.length) // XOF length + x.cfg[17] = byte(Size) // inner hash size + + x.d.Reset() + x.d.h[1] ^= uint64(x.length) << 32 + + x.remaining = uint64(x.length) + if x.remaining == magicUnknownOutputLength { + x.remaining = maxOutputLength + } + x.offset, x.nodeOffset = 0, 0 + x.readMode = false +} + +func (x *xof) Read(p []byte) (n int, err error) { + if !x.readMode { + x.d.finalize(&x.root) + x.readMode = true + } + + if x.remaining == 0 { + return 0, io.EOF + } + + n = len(p) + if uint64(n) > x.remaining { + n = int(x.remaining) + p = p[:n] + } + + if x.offset > 0 { + blockRemaining := Size - x.offset + if n < blockRemaining { + x.offset += copy(p, x.block[x.offset:]) + x.remaining -= uint64(n) + return + } + copy(p, x.block[x.offset:]) + p = p[blockRemaining:] + x.offset = 0 + x.remaining -= uint64(blockRemaining) + } + + for len(p) >= Size { + binary.LittleEndian.PutUint32(x.cfg[8:], x.nodeOffset) + x.nodeOffset++ + + x.d.initConfig(&x.cfg) + x.d.Write(x.root[:]) + x.d.finalize(&x.block) + + copy(p, x.block[:]) + p = p[Size:] + x.remaining -= uint64(Size) + } + + if todo := len(p); todo > 0 { + if x.remaining < uint64(Size) { + x.cfg[0] = byte(x.remaining) + } + binary.LittleEndian.PutUint32(x.cfg[8:], x.nodeOffset) + x.nodeOffset++ + + x.d.initConfig(&x.cfg) + x.d.Write(x.root[:]) + x.d.finalize(&x.block) + + x.offset = copy(p, x.block[:todo]) + x.remaining -= uint64(todo) + } + return +} + +func (d *digest) initConfig(cfg *[Size]byte) { + d.offset, d.c[0], d.c[1] = 0, 0, 0 + for i := range d.h { + d.h[i] = iv[i] ^ binary.LittleEndian.Uint64(cfg[i*8:]) + } +} diff --git a/vendor/golang.org/x/crypto/blake2b/register.go b/vendor/golang.org/x/crypto/blake2b/register.go new file mode 100644 index 00000000..9d863396 --- /dev/null +++ b/vendor/golang.org/x/crypto/blake2b/register.go @@ -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. + +//go:build go1.9 +// +build go1.9 + +package blake2b + +import ( + "crypto" + "hash" +) + +func init() { + newHash256 := func() hash.Hash { + h, _ := New256(nil) + return h + } + newHash384 := func() hash.Hash { + h, _ := New384(nil) + return h + } + + newHash512 := func() hash.Hash { + h, _ := New512(nil) + return h + } + + crypto.RegisterHash(crypto.BLAKE2b_256, newHash256) + crypto.RegisterHash(crypto.BLAKE2b_384, newHash384) + crypto.RegisterHash(crypto.BLAKE2b_512, newHash512) +} diff --git a/vendor/golang.org/x/crypto/chacha20/chacha_arm64.s b/vendor/golang.org/x/crypto/chacha20/chacha_arm64.s index 8fb49a13..63cae9e6 100644 --- a/vendor/golang.org/x/crypto/chacha20/chacha_arm64.s +++ b/vendor/golang.org/x/crypto/chacha20/chacha_arm64.s @@ -2,6 +2,7 @@ // Use of this source code is governed by a BSD-style // license that can be found in the LICENSE file. +//go:build go1.11 && gc && !purego // +build go1.11,gc,!purego #include "textflag.h" diff --git a/vendor/golang.org/x/crypto/chacha20/chacha_ppc64le.s b/vendor/golang.org/x/crypto/chacha20/chacha_ppc64le.s index 3dad4b2f..5c0fed26 100644 --- a/vendor/golang.org/x/crypto/chacha20/chacha_ppc64le.s +++ b/vendor/golang.org/x/crypto/chacha20/chacha_ppc64le.s @@ -19,6 +19,7 @@ // The differences in this and the original implementation are // due to the calling conventions and initialization of constants. +//go:build gc && !purego // +build gc,!purego #include "textflag.h" diff --git a/vendor/golang.org/x/crypto/chacha20/chacha_s390x.s b/vendor/golang.org/x/crypto/chacha20/chacha_s390x.s index 81816118..f3ef5a01 100644 --- a/vendor/golang.org/x/crypto/chacha20/chacha_s390x.s +++ b/vendor/golang.org/x/crypto/chacha20/chacha_s390x.s @@ -2,6 +2,7 @@ // Use of this source code is governed by a BSD-style // license that can be found in the LICENSE file. +//go:build gc && !purego // +build gc,!purego #include "go_asm.h" diff --git a/vendor/golang.org/x/crypto/curve25519/curve25519.go b/vendor/golang.org/x/crypto/curve25519/curve25519.go index 4b9a655d..cda3fdd3 100644 --- a/vendor/golang.org/x/crypto/curve25519/curve25519.go +++ b/vendor/golang.org/x/crypto/curve25519/curve25519.go @@ -10,6 +10,8 @@ package curve25519 // import "golang.org/x/crypto/curve25519" import ( "crypto/subtle" "fmt" + + "golang.org/x/crypto/curve25519/internal/field" ) // ScalarMult sets dst to the product scalar * point. @@ -18,7 +20,55 @@ import ( // zeroes, irrespective of the scalar. Instead, use the X25519 function, which // will return an error. func ScalarMult(dst, scalar, point *[32]byte) { - scalarMult(dst, scalar, point) + var e [32]byte + + copy(e[:], scalar[:]) + e[0] &= 248 + e[31] &= 127 + e[31] |= 64 + + var x1, x2, z2, x3, z3, tmp0, tmp1 field.Element + x1.SetBytes(point[:]) + x2.One() + x3.Set(&x1) + z3.One() + + swap := 0 + for pos := 254; pos >= 0; pos-- { + b := e[pos/8] >> uint(pos&7) + b &= 1 + swap ^= int(b) + x2.Swap(&x3, swap) + z2.Swap(&z3, swap) + swap = int(b) + + tmp0.Subtract(&x3, &z3) + tmp1.Subtract(&x2, &z2) + x2.Add(&x2, &z2) + z2.Add(&x3, &z3) + z3.Multiply(&tmp0, &x2) + z2.Multiply(&z2, &tmp1) + tmp0.Square(&tmp1) + tmp1.Square(&x2) + x3.Add(&z3, &z2) + z2.Subtract(&z3, &z2) + x2.Multiply(&tmp1, &tmp0) + tmp1.Subtract(&tmp1, &tmp0) + z2.Square(&z2) + + z3.Mult32(&tmp1, 121666) + x3.Square(&x3) + tmp0.Add(&tmp0, &z3) + z3.Multiply(&x1, &z2) + z2.Multiply(&tmp1, &tmp0) + } + + x2.Swap(&x3, swap) + z2.Swap(&z3, swap) + + z2.Invert(&z2) + x2.Multiply(&x2, &z2) + copy(dst[:], x2.Bytes()) } // ScalarBaseMult sets dst to the product scalar * base where base is the diff --git a/vendor/golang.org/x/crypto/curve25519/curve25519_amd64.go b/vendor/golang.org/x/crypto/curve25519/curve25519_amd64.go deleted file mode 100644 index 84858480..00000000 --- a/vendor/golang.org/x/crypto/curve25519/curve25519_amd64.go +++ /dev/null @@ -1,241 +0,0 @@ -// Copyright 2012 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 && gc && !purego -// +build amd64,gc,!purego - -package curve25519 - -// These functions are implemented in the .s files. The names of the functions -// in the rest of the file are also taken from the SUPERCOP sources to help -// people following along. - -//go:noescape - -func cswap(inout *[5]uint64, v uint64) - -//go:noescape - -func ladderstep(inout *[5][5]uint64) - -//go:noescape - -func freeze(inout *[5]uint64) - -//go:noescape - -func mul(dest, a, b *[5]uint64) - -//go:noescape - -func square(out, in *[5]uint64) - -// mladder uses a Montgomery ladder to calculate (xr/zr) *= s. -func mladder(xr, zr *[5]uint64, s *[32]byte) { - var work [5][5]uint64 - - work[0] = *xr - setint(&work[1], 1) - setint(&work[2], 0) - work[3] = *xr - setint(&work[4], 1) - - j := uint(6) - var prevbit byte - - for i := 31; i >= 0; i-- { - for j < 8 { - bit := ((*s)[i] >> j) & 1 - swap := bit ^ prevbit - prevbit = bit - cswap(&work[1], uint64(swap)) - ladderstep(&work) - j-- - } - j = 7 - } - - *xr = work[1] - *zr = work[2] -} - -func scalarMult(out, in, base *[32]byte) { - var e [32]byte - copy(e[:], (*in)[:]) - e[0] &= 248 - e[31] &= 127 - e[31] |= 64 - - var t, z [5]uint64 - unpack(&t, base) - mladder(&t, &z, &e) - invert(&z, &z) - mul(&t, &t, &z) - pack(out, &t) -} - -func setint(r *[5]uint64, v uint64) { - r[0] = v - r[1] = 0 - r[2] = 0 - r[3] = 0 - r[4] = 0 -} - -// unpack sets r = x where r consists of 5, 51-bit limbs in little-endian -// order. -func unpack(r *[5]uint64, x *[32]byte) { - r[0] = uint64(x[0]) | - uint64(x[1])<<8 | - uint64(x[2])<<16 | - uint64(x[3])<<24 | - uint64(x[4])<<32 | - uint64(x[5])<<40 | - uint64(x[6]&7)<<48 - - r[1] = uint64(x[6])>>3 | - uint64(x[7])<<5 | - uint64(x[8])<<13 | - uint64(x[9])<<21 | - uint64(x[10])<<29 | - uint64(x[11])<<37 | - uint64(x[12]&63)<<45 - - r[2] = uint64(x[12])>>6 | - uint64(x[13])<<2 | - uint64(x[14])<<10 | - uint64(x[15])<<18 | - uint64(x[16])<<26 | - uint64(x[17])<<34 | - uint64(x[18])<<42 | - uint64(x[19]&1)<<50 - - r[3] = uint64(x[19])>>1 | - uint64(x[20])<<7 | - uint64(x[21])<<15 | - uint64(x[22])<<23 | - uint64(x[23])<<31 | - uint64(x[24])<<39 | - uint64(x[25]&15)<<47 - - r[4] = uint64(x[25])>>4 | - uint64(x[26])<<4 | - uint64(x[27])<<12 | - uint64(x[28])<<20 | - uint64(x[29])<<28 | - uint64(x[30])<<36 | - uint64(x[31]&127)<<44 -} - -// pack sets out = x where out is the usual, little-endian form of the 5, -// 51-bit limbs in x. -func pack(out *[32]byte, x *[5]uint64) { - t := *x - freeze(&t) - - out[0] = byte(t[0]) - out[1] = byte(t[0] >> 8) - out[2] = byte(t[0] >> 16) - out[3] = byte(t[0] >> 24) - out[4] = byte(t[0] >> 32) - out[5] = byte(t[0] >> 40) - out[6] = byte(t[0] >> 48) - - out[6] ^= byte(t[1]<<3) & 0xf8 - out[7] = byte(t[1] >> 5) - out[8] = byte(t[1] >> 13) - out[9] = byte(t[1] >> 21) - out[10] = byte(t[1] >> 29) - out[11] = byte(t[1] >> 37) - out[12] = byte(t[1] >> 45) - - out[12] ^= byte(t[2]<<6) & 0xc0 - out[13] = byte(t[2] >> 2) - out[14] = byte(t[2] >> 10) - out[15] = byte(t[2] >> 18) - out[16] = byte(t[2] >> 26) - out[17] = byte(t[2] >> 34) - out[18] = byte(t[2] >> 42) - out[19] = byte(t[2] >> 50) - - out[19] ^= byte(t[3]<<1) & 0xfe - out[20] = byte(t[3] >> 7) - out[21] = byte(t[3] >> 15) - out[22] = byte(t[3] >> 23) - out[23] = byte(t[3] >> 31) - out[24] = byte(t[3] >> 39) - out[25] = byte(t[3] >> 47) - - out[25] ^= byte(t[4]<<4) & 0xf0 - out[26] = byte(t[4] >> 4) - out[27] = byte(t[4] >> 12) - out[28] = byte(t[4] >> 20) - out[29] = byte(t[4] >> 28) - out[30] = byte(t[4] >> 36) - out[31] = byte(t[4] >> 44) -} - -// invert calculates r = x^-1 mod p using Fermat's little theorem. -func invert(r *[5]uint64, x *[5]uint64) { - var z2, z9, z11, z2_5_0, z2_10_0, z2_20_0, z2_50_0, z2_100_0, t [5]uint64 - - square(&z2, x) /* 2 */ - square(&t, &z2) /* 4 */ - square(&t, &t) /* 8 */ - mul(&z9, &t, x) /* 9 */ - mul(&z11, &z9, &z2) /* 11 */ - square(&t, &z11) /* 22 */ - mul(&z2_5_0, &t, &z9) /* 2^5 - 2^0 = 31 */ - - square(&t, &z2_5_0) /* 2^6 - 2^1 */ - for i := 1; i < 5; i++ { /* 2^20 - 2^10 */ - square(&t, &t) - } - mul(&z2_10_0, &t, &z2_5_0) /* 2^10 - 2^0 */ - - square(&t, &z2_10_0) /* 2^11 - 2^1 */ - for i := 1; i < 10; i++ { /* 2^20 - 2^10 */ - square(&t, &t) - } - mul(&z2_20_0, &t, &z2_10_0) /* 2^20 - 2^0 */ - - square(&t, &z2_20_0) /* 2^21 - 2^1 */ - for i := 1; i < 20; i++ { /* 2^40 - 2^20 */ - square(&t, &t) - } - mul(&t, &t, &z2_20_0) /* 2^40 - 2^0 */ - - square(&t, &t) /* 2^41 - 2^1 */ - for i := 1; i < 10; i++ { /* 2^50 - 2^10 */ - square(&t, &t) - } - mul(&z2_50_0, &t, &z2_10_0) /* 2^50 - 2^0 */ - - square(&t, &z2_50_0) /* 2^51 - 2^1 */ - for i := 1; i < 50; i++ { /* 2^100 - 2^50 */ - square(&t, &t) - } - mul(&z2_100_0, &t, &z2_50_0) /* 2^100 - 2^0 */ - - square(&t, &z2_100_0) /* 2^101 - 2^1 */ - for i := 1; i < 100; i++ { /* 2^200 - 2^100 */ - square(&t, &t) - } - mul(&t, &t, &z2_100_0) /* 2^200 - 2^0 */ - - square(&t, &t) /* 2^201 - 2^1 */ - for i := 1; i < 50; i++ { /* 2^250 - 2^50 */ - square(&t, &t) - } - mul(&t, &t, &z2_50_0) /* 2^250 - 2^0 */ - - square(&t, &t) /* 2^251 - 2^1 */ - square(&t, &t) /* 2^252 - 2^2 */ - square(&t, &t) /* 2^253 - 2^3 */ - - square(&t, &t) /* 2^254 - 2^4 */ - - square(&t, &t) /* 2^255 - 2^5 */ - mul(r, &t, &z11) /* 2^255 - 21 */ -} diff --git a/vendor/golang.org/x/crypto/curve25519/curve25519_amd64.s b/vendor/golang.org/x/crypto/curve25519/curve25519_amd64.s deleted file mode 100644 index 6c533809..00000000 --- a/vendor/golang.org/x/crypto/curve25519/curve25519_amd64.s +++ /dev/null @@ -1,1793 +0,0 @@ -// Copyright 2012 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. - -// This code was translated into a form compatible with 6a from the public -// domain sources in SUPERCOP: https://bench.cr.yp.to/supercop.html - -// +build amd64,gc,!purego - -#define REDMASK51 0x0007FFFFFFFFFFFF - -// These constants cannot be encoded in non-MOVQ immediates. -// We access them directly from memory instead. - -DATA ·_121666_213(SB)/8, $996687872 -GLOBL ·_121666_213(SB), 8, $8 - -DATA ·_2P0(SB)/8, $0xFFFFFFFFFFFDA -GLOBL ·_2P0(SB), 8, $8 - -DATA ·_2P1234(SB)/8, $0xFFFFFFFFFFFFE -GLOBL ·_2P1234(SB), 8, $8 - -// func freeze(inout *[5]uint64) -TEXT ·freeze(SB),7,$0-8 - MOVQ inout+0(FP), DI - - MOVQ 0(DI),SI - MOVQ 8(DI),DX - MOVQ 16(DI),CX - MOVQ 24(DI),R8 - MOVQ 32(DI),R9 - MOVQ $REDMASK51,AX - MOVQ AX,R10 - SUBQ $18,R10 - MOVQ $3,R11 -REDUCELOOP: - MOVQ SI,R12 - SHRQ $51,R12 - ANDQ AX,SI - ADDQ R12,DX - MOVQ DX,R12 - SHRQ $51,R12 - ANDQ AX,DX - ADDQ R12,CX - MOVQ CX,R12 - SHRQ $51,R12 - ANDQ AX,CX - ADDQ R12,R8 - MOVQ R8,R12 - SHRQ $51,R12 - ANDQ AX,R8 - ADDQ R12,R9 - MOVQ R9,R12 - SHRQ $51,R12 - ANDQ AX,R9 - IMUL3Q $19,R12,R12 - ADDQ R12,SI - SUBQ $1,R11 - JA REDUCELOOP - MOVQ $1,R12 - CMPQ R10,SI - CMOVQLT R11,R12 - CMPQ AX,DX - CMOVQNE R11,R12 - CMPQ AX,CX - CMOVQNE R11,R12 - CMPQ AX,R8 - CMOVQNE R11,R12 - CMPQ AX,R9 - CMOVQNE R11,R12 - NEGQ R12 - ANDQ R12,AX - ANDQ R12,R10 - SUBQ R10,SI - SUBQ AX,DX - SUBQ AX,CX - SUBQ AX,R8 - SUBQ AX,R9 - MOVQ SI,0(DI) - MOVQ DX,8(DI) - MOVQ CX,16(DI) - MOVQ R8,24(DI) - MOVQ R9,32(DI) - RET - -// func ladderstep(inout *[5][5]uint64) -TEXT ·ladderstep(SB),0,$296-8 - MOVQ inout+0(FP),DI - - MOVQ 40(DI),SI - MOVQ 48(DI),DX - MOVQ 56(DI),CX - MOVQ 64(DI),R8 - MOVQ 72(DI),R9 - MOVQ SI,AX - MOVQ DX,R10 - MOVQ CX,R11 - MOVQ R8,R12 - MOVQ R9,R13 - ADDQ ·_2P0(SB),AX - ADDQ ·_2P1234(SB),R10 - ADDQ ·_2P1234(SB),R11 - ADDQ ·_2P1234(SB),R12 - ADDQ ·_2P1234(SB),R13 - ADDQ 80(DI),SI - ADDQ 88(DI),DX - ADDQ 96(DI),CX - ADDQ 104(DI),R8 - ADDQ 112(DI),R9 - SUBQ 80(DI),AX - SUBQ 88(DI),R10 - SUBQ 96(DI),R11 - SUBQ 104(DI),R12 - SUBQ 112(DI),R13 - MOVQ SI,0(SP) - MOVQ DX,8(SP) - MOVQ CX,16(SP) - MOVQ R8,24(SP) - MOVQ R9,32(SP) - MOVQ AX,40(SP) - MOVQ R10,48(SP) - MOVQ R11,56(SP) - MOVQ R12,64(SP) - MOVQ R13,72(SP) - MOVQ 40(SP),AX - MULQ 40(SP) - MOVQ AX,SI - MOVQ DX,CX - MOVQ 40(SP),AX - SHLQ $1,AX - MULQ 48(SP) - MOVQ AX,R8 - MOVQ DX,R9 - MOVQ 40(SP),AX - SHLQ $1,AX - MULQ 56(SP) - MOVQ AX,R10 - MOVQ DX,R11 - MOVQ 40(SP),AX - SHLQ $1,AX - MULQ 64(SP) - MOVQ AX,R12 - MOVQ DX,R13 - MOVQ 40(SP),AX - SHLQ $1,AX - MULQ 72(SP) - MOVQ AX,R14 - MOVQ DX,R15 - MOVQ 48(SP),AX - MULQ 48(SP) - ADDQ AX,R10 - ADCQ DX,R11 - MOVQ 48(SP),AX - SHLQ $1,AX - MULQ 56(SP) - ADDQ AX,R12 - ADCQ DX,R13 - MOVQ 48(SP),AX - SHLQ $1,AX - MULQ 64(SP) - ADDQ AX,R14 - ADCQ DX,R15 - MOVQ 48(SP),DX - IMUL3Q $38,DX,AX - MULQ 72(SP) - ADDQ AX,SI - ADCQ DX,CX - MOVQ 56(SP),AX - MULQ 56(SP) - ADDQ AX,R14 - ADCQ DX,R15 - MOVQ 56(SP),DX - IMUL3Q $38,DX,AX - MULQ 64(SP) - ADDQ AX,SI - ADCQ DX,CX - MOVQ 56(SP),DX - IMUL3Q $38,DX,AX - MULQ 72(SP) - ADDQ AX,R8 - ADCQ DX,R9 - MOVQ 64(SP),DX - IMUL3Q $19,DX,AX - MULQ 64(SP) - ADDQ AX,R8 - ADCQ DX,R9 - MOVQ 64(SP),DX - IMUL3Q $38,DX,AX - MULQ 72(SP) - ADDQ AX,R10 - ADCQ DX,R11 - MOVQ 72(SP),DX - IMUL3Q $19,DX,AX - MULQ 72(SP) - ADDQ AX,R12 - ADCQ DX,R13 - MOVQ $REDMASK51,DX - SHLQ $13,SI,CX - ANDQ DX,SI - SHLQ $13,R8,R9 - ANDQ DX,R8 - ADDQ CX,R8 - SHLQ $13,R10,R11 - ANDQ DX,R10 - ADDQ R9,R10 - SHLQ $13,R12,R13 - ANDQ DX,R12 - ADDQ R11,R12 - SHLQ $13,R14,R15 - ANDQ DX,R14 - ADDQ R13,R14 - IMUL3Q $19,R15,CX - ADDQ CX,SI - MOVQ SI,CX - SHRQ $51,CX - ADDQ R8,CX - ANDQ DX,SI - MOVQ CX,R8 - SHRQ $51,CX - ADDQ R10,CX - ANDQ DX,R8 - MOVQ CX,R9 - SHRQ $51,CX - ADDQ R12,CX - ANDQ DX,R9 - MOVQ CX,AX - SHRQ $51,CX - ADDQ R14,CX - ANDQ DX,AX - MOVQ CX,R10 - SHRQ $51,CX - IMUL3Q $19,CX,CX - ADDQ CX,SI - ANDQ DX,R10 - MOVQ SI,80(SP) - MOVQ R8,88(SP) - MOVQ R9,96(SP) - MOVQ AX,104(SP) - MOVQ R10,112(SP) - MOVQ 0(SP),AX - MULQ 0(SP) - MOVQ AX,SI - MOVQ DX,CX - MOVQ 0(SP),AX - SHLQ $1,AX - MULQ 8(SP) - MOVQ AX,R8 - MOVQ DX,R9 - MOVQ 0(SP),AX - SHLQ $1,AX - MULQ 16(SP) - MOVQ AX,R10 - MOVQ DX,R11 - MOVQ 0(SP),AX - SHLQ $1,AX - MULQ 24(SP) - MOVQ AX,R12 - MOVQ DX,R13 - MOVQ 0(SP),AX - SHLQ $1,AX - MULQ 32(SP) - MOVQ AX,R14 - MOVQ DX,R15 - MOVQ 8(SP),AX - MULQ 8(SP) - ADDQ AX,R10 - ADCQ DX,R11 - MOVQ 8(SP),AX - SHLQ $1,AX - MULQ 16(SP) - ADDQ AX,R12 - ADCQ DX,R13 - MOVQ 8(SP),AX - SHLQ $1,AX - MULQ 24(SP) - ADDQ AX,R14 - ADCQ DX,R15 - MOVQ 8(SP),DX - IMUL3Q $38,DX,AX - MULQ 32(SP) - ADDQ AX,SI - ADCQ DX,CX - MOVQ 16(SP),AX - MULQ 16(SP) - ADDQ AX,R14 - ADCQ DX,R15 - MOVQ 16(SP),DX - IMUL3Q $38,DX,AX - MULQ 24(SP) - ADDQ AX,SI - ADCQ DX,CX - MOVQ 16(SP),DX - IMUL3Q $38,DX,AX - MULQ 32(SP) - ADDQ AX,R8 - ADCQ DX,R9 - MOVQ 24(SP),DX - IMUL3Q $19,DX,AX - MULQ 24(SP) - ADDQ AX,R8 - ADCQ DX,R9 - MOVQ 24(SP),DX - IMUL3Q $38,DX,AX - MULQ 32(SP) - ADDQ AX,R10 - ADCQ DX,R11 - MOVQ 32(SP),DX - IMUL3Q $19,DX,AX - MULQ 32(SP) - ADDQ AX,R12 - ADCQ DX,R13 - MOVQ $REDMASK51,DX - SHLQ $13,SI,CX - ANDQ DX,SI - SHLQ $13,R8,R9 - ANDQ DX,R8 - ADDQ CX,R8 - SHLQ $13,R10,R11 - ANDQ DX,R10 - ADDQ R9,R10 - SHLQ $13,R12,R13 - ANDQ DX,R12 - ADDQ R11,R12 - SHLQ $13,R14,R15 - ANDQ DX,R14 - ADDQ R13,R14 - IMUL3Q $19,R15,CX - ADDQ CX,SI - MOVQ SI,CX - SHRQ $51,CX - ADDQ R8,CX - ANDQ DX,SI - MOVQ CX,R8 - SHRQ $51,CX - ADDQ R10,CX - ANDQ DX,R8 - MOVQ CX,R9 - SHRQ $51,CX - ADDQ R12,CX - ANDQ DX,R9 - MOVQ CX,AX - SHRQ $51,CX - ADDQ R14,CX - ANDQ DX,AX - MOVQ CX,R10 - SHRQ $51,CX - IMUL3Q $19,CX,CX - ADDQ CX,SI - ANDQ DX,R10 - MOVQ SI,120(SP) - MOVQ R8,128(SP) - MOVQ R9,136(SP) - MOVQ AX,144(SP) - MOVQ R10,152(SP) - MOVQ SI,SI - MOVQ R8,DX - MOVQ R9,CX - MOVQ AX,R8 - MOVQ R10,R9 - ADDQ ·_2P0(SB),SI - ADDQ ·_2P1234(SB),DX - ADDQ ·_2P1234(SB),CX - ADDQ ·_2P1234(SB),R8 - ADDQ ·_2P1234(SB),R9 - SUBQ 80(SP),SI - SUBQ 88(SP),DX - SUBQ 96(SP),CX - SUBQ 104(SP),R8 - SUBQ 112(SP),R9 - MOVQ SI,160(SP) - MOVQ DX,168(SP) - MOVQ CX,176(SP) - MOVQ R8,184(SP) - MOVQ R9,192(SP) - MOVQ 120(DI),SI - MOVQ 128(DI),DX - MOVQ 136(DI),CX - MOVQ 144(DI),R8 - MOVQ 152(DI),R9 - MOVQ SI,AX - MOVQ DX,R10 - MOVQ CX,R11 - MOVQ R8,R12 - MOVQ R9,R13 - ADDQ ·_2P0(SB),AX - ADDQ ·_2P1234(SB),R10 - ADDQ ·_2P1234(SB),R11 - ADDQ ·_2P1234(SB),R12 - ADDQ ·_2P1234(SB),R13 - ADDQ 160(DI),SI - ADDQ 168(DI),DX - ADDQ 176(DI),CX - ADDQ 184(DI),R8 - ADDQ 192(DI),R9 - SUBQ 160(DI),AX - SUBQ 168(DI),R10 - SUBQ 176(DI),R11 - SUBQ 184(DI),R12 - SUBQ 192(DI),R13 - MOVQ SI,200(SP) - MOVQ DX,208(SP) - MOVQ CX,216(SP) - MOVQ R8,224(SP) - MOVQ R9,232(SP) - MOVQ AX,240(SP) - MOVQ R10,248(SP) - MOVQ R11,256(SP) - MOVQ R12,264(SP) - MOVQ R13,272(SP) - MOVQ 224(SP),SI - IMUL3Q $19,SI,AX - MOVQ AX,280(SP) - MULQ 56(SP) - MOVQ AX,SI - MOVQ DX,CX - MOVQ 232(SP),DX - IMUL3Q $19,DX,AX - MOVQ AX,288(SP) - MULQ 48(SP) - ADDQ AX,SI - ADCQ DX,CX - MOVQ 200(SP),AX - MULQ 40(SP) - ADDQ AX,SI - ADCQ DX,CX - MOVQ 200(SP),AX - MULQ 48(SP) - MOVQ AX,R8 - MOVQ DX,R9 - MOVQ 200(SP),AX - MULQ 56(SP) - MOVQ AX,R10 - MOVQ DX,R11 - MOVQ 200(SP),AX - MULQ 64(SP) - MOVQ AX,R12 - MOVQ DX,R13 - MOVQ 200(SP),AX - MULQ 72(SP) - MOVQ AX,R14 - MOVQ DX,R15 - MOVQ 208(SP),AX - MULQ 40(SP) - ADDQ AX,R8 - ADCQ DX,R9 - MOVQ 208(SP),AX - MULQ 48(SP) - ADDQ AX,R10 - ADCQ DX,R11 - MOVQ 208(SP),AX - MULQ 56(SP) - ADDQ AX,R12 - ADCQ DX,R13 - MOVQ 208(SP),AX - MULQ 64(SP) - ADDQ AX,R14 - ADCQ DX,R15 - MOVQ 208(SP),DX - IMUL3Q $19,DX,AX - MULQ 72(SP) - ADDQ AX,SI - ADCQ DX,CX - MOVQ 216(SP),AX - MULQ 40(SP) - ADDQ AX,R10 - ADCQ DX,R11 - MOVQ 216(SP),AX - MULQ 48(SP) - ADDQ AX,R12 - ADCQ DX,R13 - MOVQ 216(SP),AX - MULQ 56(SP) - ADDQ AX,R14 - ADCQ DX,R15 - MOVQ 216(SP),DX - IMUL3Q $19,DX,AX - MULQ 64(SP) - ADDQ AX,SI - ADCQ DX,CX - MOVQ 216(SP),DX - IMUL3Q $19,DX,AX - MULQ 72(SP) - ADDQ AX,R8 - ADCQ DX,R9 - MOVQ 224(SP),AX - MULQ 40(SP) - ADDQ AX,R12 - ADCQ DX,R13 - MOVQ 224(SP),AX - MULQ 48(SP) - ADDQ AX,R14 - ADCQ DX,R15 - MOVQ 280(SP),AX - MULQ 64(SP) - ADDQ AX,R8 - ADCQ DX,R9 - MOVQ 280(SP),AX - MULQ 72(SP) - ADDQ AX,R10 - ADCQ DX,R11 - MOVQ 232(SP),AX - MULQ 40(SP) - ADDQ AX,R14 - ADCQ DX,R15 - MOVQ 288(SP),AX - MULQ 56(SP) - ADDQ AX,R8 - ADCQ DX,R9 - MOVQ 288(SP),AX - MULQ 64(SP) - ADDQ AX,R10 - ADCQ DX,R11 - MOVQ 288(SP),AX - MULQ 72(SP) - ADDQ AX,R12 - ADCQ DX,R13 - MOVQ $REDMASK51,DX - SHLQ $13,SI,CX - ANDQ DX,SI - SHLQ $13,R8,R9 - ANDQ DX,R8 - ADDQ CX,R8 - SHLQ $13,R10,R11 - ANDQ DX,R10 - ADDQ R9,R10 - SHLQ $13,R12,R13 - ANDQ DX,R12 - ADDQ R11,R12 - SHLQ $13,R14,R15 - ANDQ DX,R14 - ADDQ R13,R14 - IMUL3Q $19,R15,CX - ADDQ CX,SI - MOVQ SI,CX - SHRQ $51,CX - ADDQ R8,CX - MOVQ CX,R8 - SHRQ $51,CX - ANDQ DX,SI - ADDQ R10,CX - MOVQ CX,R9 - SHRQ $51,CX - ANDQ DX,R8 - ADDQ R12,CX - MOVQ CX,AX - SHRQ $51,CX - ANDQ DX,R9 - ADDQ R14,CX - MOVQ CX,R10 - SHRQ $51,CX - ANDQ DX,AX - IMUL3Q $19,CX,CX - ADDQ CX,SI - ANDQ DX,R10 - MOVQ SI,40(SP) - MOVQ R8,48(SP) - MOVQ R9,56(SP) - MOVQ AX,64(SP) - MOVQ R10,72(SP) - MOVQ 264(SP),SI - IMUL3Q $19,SI,AX - MOVQ AX,200(SP) - MULQ 16(SP) - MOVQ AX,SI - MOVQ DX,CX - MOVQ 272(SP),DX - IMUL3Q $19,DX,AX - MOVQ AX,208(SP) - MULQ 8(SP) - ADDQ AX,SI - ADCQ DX,CX - MOVQ 240(SP),AX - MULQ 0(SP) - ADDQ AX,SI - ADCQ DX,CX - MOVQ 240(SP),AX - MULQ 8(SP) - MOVQ AX,R8 - MOVQ DX,R9 - MOVQ 240(SP),AX - MULQ 16(SP) - MOVQ AX,R10 - MOVQ DX,R11 - MOVQ 240(SP),AX - MULQ 24(SP) - MOVQ AX,R12 - MOVQ DX,R13 - MOVQ 240(SP),AX - MULQ 32(SP) - MOVQ AX,R14 - MOVQ DX,R15 - MOVQ 248(SP),AX - MULQ 0(SP) - ADDQ AX,R8 - ADCQ DX,R9 - MOVQ 248(SP),AX - MULQ 8(SP) - ADDQ AX,R10 - ADCQ DX,R11 - MOVQ 248(SP),AX - MULQ 16(SP) - ADDQ AX,R12 - ADCQ DX,R13 - MOVQ 248(SP),AX - MULQ 24(SP) - ADDQ AX,R14 - ADCQ DX,R15 - MOVQ 248(SP),DX - IMUL3Q $19,DX,AX - MULQ 32(SP) - ADDQ AX,SI - ADCQ DX,CX - MOVQ 256(SP),AX - MULQ 0(SP) - ADDQ AX,R10 - ADCQ DX,R11 - MOVQ 256(SP),AX - MULQ 8(SP) - ADDQ AX,R12 - ADCQ DX,R13 - MOVQ 256(SP),AX - MULQ 16(SP) - ADDQ AX,R14 - ADCQ DX,R15 - MOVQ 256(SP),DX - IMUL3Q $19,DX,AX - MULQ 24(SP) - ADDQ AX,SI - ADCQ DX,CX - MOVQ 256(SP),DX - IMUL3Q $19,DX,AX - MULQ 32(SP) - ADDQ AX,R8 - ADCQ DX,R9 - MOVQ 264(SP),AX - MULQ 0(SP) - ADDQ AX,R12 - ADCQ DX,R13 - MOVQ 264(SP),AX - MULQ 8(SP) - ADDQ AX,R14 - ADCQ DX,R15 - MOVQ 200(SP),AX - MULQ 24(SP) - ADDQ AX,R8 - ADCQ DX,R9 - MOVQ 200(SP),AX - MULQ 32(SP) - ADDQ AX,R10 - ADCQ DX,R11 - MOVQ 272(SP),AX - MULQ 0(SP) - ADDQ AX,R14 - ADCQ DX,R15 - MOVQ 208(SP),AX - MULQ 16(SP) - ADDQ AX,R8 - ADCQ DX,R9 - MOVQ 208(SP),AX - MULQ 24(SP) - ADDQ AX,R10 - ADCQ DX,R11 - MOVQ 208(SP),AX - MULQ 32(SP) - ADDQ AX,R12 - ADCQ DX,R13 - MOVQ $REDMASK51,DX - SHLQ $13,SI,CX - ANDQ DX,SI - SHLQ $13,R8,R9 - ANDQ DX,R8 - ADDQ CX,R8 - SHLQ $13,R10,R11 - ANDQ DX,R10 - ADDQ R9,R10 - SHLQ $13,R12,R13 - ANDQ DX,R12 - ADDQ R11,R12 - SHLQ $13,R14,R15 - ANDQ DX,R14 - ADDQ R13,R14 - IMUL3Q $19,R15,CX - ADDQ CX,SI - MOVQ SI,CX - SHRQ $51,CX - ADDQ R8,CX - MOVQ CX,R8 - SHRQ $51,CX - ANDQ DX,SI - ADDQ R10,CX - MOVQ CX,R9 - SHRQ $51,CX - ANDQ DX,R8 - ADDQ R12,CX - MOVQ CX,AX - SHRQ $51,CX - ANDQ DX,R9 - ADDQ R14,CX - MOVQ CX,R10 - SHRQ $51,CX - ANDQ DX,AX - IMUL3Q $19,CX,CX - ADDQ CX,SI - ANDQ DX,R10 - MOVQ SI,DX - MOVQ R8,CX - MOVQ R9,R11 - MOVQ AX,R12 - MOVQ R10,R13 - ADDQ ·_2P0(SB),DX - ADDQ ·_2P1234(SB),CX - ADDQ ·_2P1234(SB),R11 - ADDQ ·_2P1234(SB),R12 - ADDQ ·_2P1234(SB),R13 - ADDQ 40(SP),SI - ADDQ 48(SP),R8 - ADDQ 56(SP),R9 - ADDQ 64(SP),AX - ADDQ 72(SP),R10 - SUBQ 40(SP),DX - SUBQ 48(SP),CX - SUBQ 56(SP),R11 - SUBQ 64(SP),R12 - SUBQ 72(SP),R13 - MOVQ SI,120(DI) - MOVQ R8,128(DI) - MOVQ R9,136(DI) - MOVQ AX,144(DI) - MOVQ R10,152(DI) - MOVQ DX,160(DI) - MOVQ CX,168(DI) - MOVQ R11,176(DI) - MOVQ R12,184(DI) - MOVQ R13,192(DI) - MOVQ 120(DI),AX - MULQ 120(DI) - MOVQ AX,SI - MOVQ DX,CX - MOVQ 120(DI),AX - SHLQ $1,AX - MULQ 128(DI) - MOVQ AX,R8 - MOVQ DX,R9 - MOVQ 120(DI),AX - SHLQ $1,AX - MULQ 136(DI) - MOVQ AX,R10 - MOVQ DX,R11 - MOVQ 120(DI),AX - SHLQ $1,AX - MULQ 144(DI) - MOVQ AX,R12 - MOVQ DX,R13 - MOVQ 120(DI),AX - SHLQ $1,AX - MULQ 152(DI) - MOVQ AX,R14 - MOVQ DX,R15 - MOVQ 128(DI),AX - MULQ 128(DI) - ADDQ AX,R10 - ADCQ DX,R11 - MOVQ 128(DI),AX - SHLQ $1,AX - MULQ 136(DI) - ADDQ AX,R12 - ADCQ DX,R13 - MOVQ 128(DI),AX - SHLQ $1,AX - MULQ 144(DI) - ADDQ AX,R14 - ADCQ DX,R15 - MOVQ 128(DI),DX - IMUL3Q $38,DX,AX - MULQ 152(DI) - ADDQ AX,SI - ADCQ DX,CX - MOVQ 136(DI),AX - MULQ 136(DI) - ADDQ AX,R14 - ADCQ DX,R15 - MOVQ 136(DI),DX - IMUL3Q $38,DX,AX - MULQ 144(DI) - ADDQ AX,SI - ADCQ DX,CX - MOVQ 136(DI),DX - IMUL3Q $38,DX,AX - MULQ 152(DI) - ADDQ AX,R8 - ADCQ DX,R9 - MOVQ 144(DI),DX - IMUL3Q $19,DX,AX - MULQ 144(DI) - ADDQ AX,R8 - ADCQ DX,R9 - MOVQ 144(DI),DX - IMUL3Q $38,DX,AX - MULQ 152(DI) - ADDQ AX,R10 - ADCQ DX,R11 - MOVQ 152(DI),DX - IMUL3Q $19,DX,AX - MULQ 152(DI) - ADDQ AX,R12 - ADCQ DX,R13 - MOVQ $REDMASK51,DX - SHLQ $13,SI,CX - ANDQ DX,SI - SHLQ $13,R8,R9 - ANDQ DX,R8 - ADDQ CX,R8 - SHLQ $13,R10,R11 - ANDQ DX,R10 - ADDQ R9,R10 - SHLQ $13,R12,R13 - ANDQ DX,R12 - ADDQ R11,R12 - SHLQ $13,R14,R15 - ANDQ DX,R14 - ADDQ R13,R14 - IMUL3Q $19,R15,CX - ADDQ CX,SI - MOVQ SI,CX - SHRQ $51,CX - ADDQ R8,CX - ANDQ DX,SI - MOVQ CX,R8 - SHRQ $51,CX - ADDQ R10,CX - ANDQ DX,R8 - MOVQ CX,R9 - SHRQ $51,CX - ADDQ R12,CX - ANDQ DX,R9 - MOVQ CX,AX - SHRQ $51,CX - ADDQ R14,CX - ANDQ DX,AX - MOVQ CX,R10 - SHRQ $51,CX - IMUL3Q $19,CX,CX - ADDQ CX,SI - ANDQ DX,R10 - MOVQ SI,120(DI) - MOVQ R8,128(DI) - MOVQ R9,136(DI) - MOVQ AX,144(DI) - MOVQ R10,152(DI) - MOVQ 160(DI),AX - MULQ 160(DI) - MOVQ AX,SI - MOVQ DX,CX - MOVQ 160(DI),AX - SHLQ $1,AX - MULQ 168(DI) - MOVQ AX,R8 - MOVQ DX,R9 - MOVQ 160(DI),AX - SHLQ $1,AX - MULQ 176(DI) - MOVQ AX,R10 - MOVQ DX,R11 - MOVQ 160(DI),AX - SHLQ $1,AX - MULQ 184(DI) - MOVQ AX,R12 - MOVQ DX,R13 - MOVQ 160(DI),AX - SHLQ $1,AX - MULQ 192(DI) - MOVQ AX,R14 - MOVQ DX,R15 - MOVQ 168(DI),AX - MULQ 168(DI) - ADDQ AX,R10 - ADCQ DX,R11 - MOVQ 168(DI),AX - SHLQ $1,AX - MULQ 176(DI) - ADDQ AX,R12 - ADCQ DX,R13 - MOVQ 168(DI),AX - SHLQ $1,AX - MULQ 184(DI) - ADDQ AX,R14 - ADCQ DX,R15 - MOVQ 168(DI),DX - IMUL3Q $38,DX,AX - MULQ 192(DI) - ADDQ AX,SI - ADCQ DX,CX - MOVQ 176(DI),AX - MULQ 176(DI) - ADDQ AX,R14 - ADCQ DX,R15 - MOVQ 176(DI),DX - IMUL3Q $38,DX,AX - MULQ 184(DI) - ADDQ AX,SI - ADCQ DX,CX - MOVQ 176(DI),DX - IMUL3Q $38,DX,AX - MULQ 192(DI) - ADDQ AX,R8 - ADCQ DX,R9 - MOVQ 184(DI),DX - IMUL3Q $19,DX,AX - MULQ 184(DI) - ADDQ AX,R8 - ADCQ DX,R9 - MOVQ 184(DI),DX - IMUL3Q $38,DX,AX - MULQ 192(DI) - ADDQ AX,R10 - ADCQ DX,R11 - MOVQ 192(DI),DX - IMUL3Q $19,DX,AX - MULQ 192(DI) - ADDQ AX,R12 - ADCQ DX,R13 - MOVQ $REDMASK51,DX - SHLQ $13,SI,CX - ANDQ DX,SI - SHLQ $13,R8,R9 - ANDQ DX,R8 - ADDQ CX,R8 - SHLQ $13,R10,R11 - ANDQ DX,R10 - ADDQ R9,R10 - SHLQ $13,R12,R13 - ANDQ DX,R12 - ADDQ R11,R12 - SHLQ $13,R14,R15 - ANDQ DX,R14 - ADDQ R13,R14 - IMUL3Q $19,R15,CX - ADDQ CX,SI - MOVQ SI,CX - SHRQ $51,CX - ADDQ R8,CX - ANDQ DX,SI - MOVQ CX,R8 - SHRQ $51,CX - ADDQ R10,CX - ANDQ DX,R8 - MOVQ CX,R9 - SHRQ $51,CX - ADDQ R12,CX - ANDQ DX,R9 - MOVQ CX,AX - SHRQ $51,CX - ADDQ R14,CX - ANDQ DX,AX - MOVQ CX,R10 - SHRQ $51,CX - IMUL3Q $19,CX,CX - ADDQ CX,SI - ANDQ DX,R10 - MOVQ SI,160(DI) - MOVQ R8,168(DI) - MOVQ R9,176(DI) - MOVQ AX,184(DI) - MOVQ R10,192(DI) - MOVQ 184(DI),SI - IMUL3Q $19,SI,AX - MOVQ AX,0(SP) - MULQ 16(DI) - MOVQ AX,SI - MOVQ DX,CX - MOVQ 192(DI),DX - IMUL3Q $19,DX,AX - MOVQ AX,8(SP) - MULQ 8(DI) - ADDQ AX,SI - ADCQ DX,CX - MOVQ 160(DI),AX - MULQ 0(DI) - ADDQ AX,SI - ADCQ DX,CX - MOVQ 160(DI),AX - MULQ 8(DI) - MOVQ AX,R8 - MOVQ DX,R9 - MOVQ 160(DI),AX - MULQ 16(DI) - MOVQ AX,R10 - MOVQ DX,R11 - MOVQ 160(DI),AX - MULQ 24(DI) - MOVQ AX,R12 - MOVQ DX,R13 - MOVQ 160(DI),AX - MULQ 32(DI) - MOVQ AX,R14 - MOVQ DX,R15 - MOVQ 168(DI),AX - MULQ 0(DI) - ADDQ AX,R8 - ADCQ DX,R9 - MOVQ 168(DI),AX - MULQ 8(DI) - ADDQ AX,R10 - ADCQ DX,R11 - MOVQ 168(DI),AX - MULQ 16(DI) - ADDQ AX,R12 - ADCQ DX,R13 - MOVQ 168(DI),AX - MULQ 24(DI) - ADDQ AX,R14 - ADCQ DX,R15 - MOVQ 168(DI),DX - IMUL3Q $19,DX,AX - MULQ 32(DI) - ADDQ AX,SI - ADCQ DX,CX - MOVQ 176(DI),AX - MULQ 0(DI) - ADDQ AX,R10 - ADCQ DX,R11 - MOVQ 176(DI),AX - MULQ 8(DI) - ADDQ AX,R12 - ADCQ DX,R13 - MOVQ 176(DI),AX - MULQ 16(DI) - ADDQ AX,R14 - ADCQ DX,R15 - MOVQ 176(DI),DX - IMUL3Q $19,DX,AX - MULQ 24(DI) - ADDQ AX,SI - ADCQ DX,CX - MOVQ 176(DI),DX - IMUL3Q $19,DX,AX - MULQ 32(DI) - ADDQ AX,R8 - ADCQ DX,R9 - MOVQ 184(DI),AX - MULQ 0(DI) - ADDQ AX,R12 - ADCQ DX,R13 - MOVQ 184(DI),AX - MULQ 8(DI) - ADDQ AX,R14 - ADCQ DX,R15 - MOVQ 0(SP),AX - MULQ 24(DI) - ADDQ AX,R8 - ADCQ DX,R9 - MOVQ 0(SP),AX - MULQ 32(DI) - ADDQ AX,R10 - ADCQ DX,R11 - MOVQ 192(DI),AX - MULQ 0(DI) - ADDQ AX,R14 - ADCQ DX,R15 - MOVQ 8(SP),AX - MULQ 16(DI) - ADDQ AX,R8 - ADCQ DX,R9 - MOVQ 8(SP),AX - MULQ 24(DI) - ADDQ AX,R10 - ADCQ DX,R11 - MOVQ 8(SP),AX - MULQ 32(DI) - ADDQ AX,R12 - ADCQ DX,R13 - MOVQ $REDMASK51,DX - SHLQ $13,SI,CX - ANDQ DX,SI - SHLQ $13,R8,R9 - ANDQ DX,R8 - ADDQ CX,R8 - SHLQ $13,R10,R11 - ANDQ DX,R10 - ADDQ R9,R10 - SHLQ $13,R12,R13 - ANDQ DX,R12 - ADDQ R11,R12 - SHLQ $13,R14,R15 - ANDQ DX,R14 - ADDQ R13,R14 - IMUL3Q $19,R15,CX - ADDQ CX,SI - MOVQ SI,CX - SHRQ $51,CX - ADDQ R8,CX - MOVQ CX,R8 - SHRQ $51,CX - ANDQ DX,SI - ADDQ R10,CX - MOVQ CX,R9 - SHRQ $51,CX - ANDQ DX,R8 - ADDQ R12,CX - MOVQ CX,AX - SHRQ $51,CX - ANDQ DX,R9 - ADDQ R14,CX - MOVQ CX,R10 - SHRQ $51,CX - ANDQ DX,AX - IMUL3Q $19,CX,CX - ADDQ CX,SI - ANDQ DX,R10 - MOVQ SI,160(DI) - MOVQ R8,168(DI) - MOVQ R9,176(DI) - MOVQ AX,184(DI) - MOVQ R10,192(DI) - MOVQ 144(SP),SI - IMUL3Q $19,SI,AX - MOVQ AX,0(SP) - MULQ 96(SP) - MOVQ AX,SI - MOVQ DX,CX - MOVQ 152(SP),DX - IMUL3Q $19,DX,AX - MOVQ AX,8(SP) - MULQ 88(SP) - ADDQ AX,SI - ADCQ DX,CX - MOVQ 120(SP),AX - MULQ 80(SP) - ADDQ AX,SI - ADCQ DX,CX - MOVQ 120(SP),AX - MULQ 88(SP) - MOVQ AX,R8 - MOVQ DX,R9 - MOVQ 120(SP),AX - MULQ 96(SP) - MOVQ AX,R10 - MOVQ DX,R11 - MOVQ 120(SP),AX - MULQ 104(SP) - MOVQ AX,R12 - MOVQ DX,R13 - MOVQ 120(SP),AX - MULQ 112(SP) - MOVQ AX,R14 - MOVQ DX,R15 - MOVQ 128(SP),AX - MULQ 80(SP) - ADDQ AX,R8 - ADCQ DX,R9 - MOVQ 128(SP),AX - MULQ 88(SP) - ADDQ AX,R10 - ADCQ DX,R11 - MOVQ 128(SP),AX - MULQ 96(SP) - ADDQ AX,R12 - ADCQ DX,R13 - MOVQ 128(SP),AX - MULQ 104(SP) - ADDQ AX,R14 - ADCQ DX,R15 - MOVQ 128(SP),DX - IMUL3Q $19,DX,AX - MULQ 112(SP) - ADDQ AX,SI - ADCQ DX,CX - MOVQ 136(SP),AX - MULQ 80(SP) - ADDQ AX,R10 - ADCQ DX,R11 - MOVQ 136(SP),AX - MULQ 88(SP) - ADDQ AX,R12 - ADCQ DX,R13 - MOVQ 136(SP),AX - MULQ 96(SP) - ADDQ AX,R14 - ADCQ DX,R15 - MOVQ 136(SP),DX - IMUL3Q $19,DX,AX - MULQ 104(SP) - ADDQ AX,SI - ADCQ DX,CX - MOVQ 136(SP),DX - IMUL3Q $19,DX,AX - MULQ 112(SP) - ADDQ AX,R8 - ADCQ DX,R9 - MOVQ 144(SP),AX - MULQ 80(SP) - ADDQ AX,R12 - ADCQ DX,R13 - MOVQ 144(SP),AX - MULQ 88(SP) - ADDQ AX,R14 - ADCQ DX,R15 - MOVQ 0(SP),AX - MULQ 104(SP) - ADDQ AX,R8 - ADCQ DX,R9 - MOVQ 0(SP),AX - MULQ 112(SP) - ADDQ AX,R10 - ADCQ DX,R11 - MOVQ 152(SP),AX - MULQ 80(SP) - ADDQ AX,R14 - ADCQ DX,R15 - MOVQ 8(SP),AX - MULQ 96(SP) - ADDQ AX,R8 - ADCQ DX,R9 - MOVQ 8(SP),AX - MULQ 104(SP) - ADDQ AX,R10 - ADCQ DX,R11 - MOVQ 8(SP),AX - MULQ 112(SP) - ADDQ AX,R12 - ADCQ DX,R13 - MOVQ $REDMASK51,DX - SHLQ $13,SI,CX - ANDQ DX,SI - SHLQ $13,R8,R9 - ANDQ DX,R8 - ADDQ CX,R8 - SHLQ $13,R10,R11 - ANDQ DX,R10 - ADDQ R9,R10 - SHLQ $13,R12,R13 - ANDQ DX,R12 - ADDQ R11,R12 - SHLQ $13,R14,R15 - ANDQ DX,R14 - ADDQ R13,R14 - IMUL3Q $19,R15,CX - ADDQ CX,SI - MOVQ SI,CX - SHRQ $51,CX - ADDQ R8,CX - MOVQ CX,R8 - SHRQ $51,CX - ANDQ DX,SI - ADDQ R10,CX - MOVQ CX,R9 - SHRQ $51,CX - ANDQ DX,R8 - ADDQ R12,CX - MOVQ CX,AX - SHRQ $51,CX - ANDQ DX,R9 - ADDQ R14,CX - MOVQ CX,R10 - SHRQ $51,CX - ANDQ DX,AX - IMUL3Q $19,CX,CX - ADDQ CX,SI - ANDQ DX,R10 - MOVQ SI,40(DI) - MOVQ R8,48(DI) - MOVQ R9,56(DI) - MOVQ AX,64(DI) - MOVQ R10,72(DI) - MOVQ 160(SP),AX - MULQ ·_121666_213(SB) - SHRQ $13,AX - MOVQ AX,SI - MOVQ DX,CX - MOVQ 168(SP),AX - MULQ ·_121666_213(SB) - SHRQ $13,AX - ADDQ AX,CX - MOVQ DX,R8 - MOVQ 176(SP),AX - MULQ ·_121666_213(SB) - SHRQ $13,AX - ADDQ AX,R8 - MOVQ DX,R9 - MOVQ 184(SP),AX - MULQ ·_121666_213(SB) - SHRQ $13,AX - ADDQ AX,R9 - MOVQ DX,R10 - MOVQ 192(SP),AX - MULQ ·_121666_213(SB) - SHRQ $13,AX - ADDQ AX,R10 - IMUL3Q $19,DX,DX - ADDQ DX,SI - ADDQ 80(SP),SI - ADDQ 88(SP),CX - ADDQ 96(SP),R8 - ADDQ 104(SP),R9 - ADDQ 112(SP),R10 - MOVQ SI,80(DI) - MOVQ CX,88(DI) - MOVQ R8,96(DI) - MOVQ R9,104(DI) - MOVQ R10,112(DI) - MOVQ 104(DI),SI - IMUL3Q $19,SI,AX - MOVQ AX,0(SP) - MULQ 176(SP) - MOVQ AX,SI - MOVQ DX,CX - MOVQ 112(DI),DX - IMUL3Q $19,DX,AX - MOVQ AX,8(SP) - MULQ 168(SP) - ADDQ AX,SI - ADCQ DX,CX - MOVQ 80(DI),AX - MULQ 160(SP) - ADDQ AX,SI - ADCQ DX,CX - MOVQ 80(DI),AX - MULQ 168(SP) - MOVQ AX,R8 - MOVQ DX,R9 - MOVQ 80(DI),AX - MULQ 176(SP) - MOVQ AX,R10 - MOVQ DX,R11 - MOVQ 80(DI),AX - MULQ 184(SP) - MOVQ AX,R12 - MOVQ DX,R13 - MOVQ 80(DI),AX - MULQ 192(SP) - MOVQ AX,R14 - MOVQ DX,R15 - MOVQ 88(DI),AX - MULQ 160(SP) - ADDQ AX,R8 - ADCQ DX,R9 - MOVQ 88(DI),AX - MULQ 168(SP) - ADDQ AX,R10 - ADCQ DX,R11 - MOVQ 88(DI),AX - MULQ 176(SP) - ADDQ AX,R12 - ADCQ DX,R13 - MOVQ 88(DI),AX - MULQ 184(SP) - ADDQ AX,R14 - ADCQ DX,R15 - MOVQ 88(DI),DX - IMUL3Q $19,DX,AX - MULQ 192(SP) - ADDQ AX,SI - ADCQ DX,CX - MOVQ 96(DI),AX - MULQ 160(SP) - ADDQ AX,R10 - ADCQ DX,R11 - MOVQ 96(DI),AX - MULQ 168(SP) - ADDQ AX,R12 - ADCQ DX,R13 - MOVQ 96(DI),AX - MULQ 176(SP) - ADDQ AX,R14 - ADCQ DX,R15 - MOVQ 96(DI),DX - IMUL3Q $19,DX,AX - MULQ 184(SP) - ADDQ AX,SI - ADCQ DX,CX - MOVQ 96(DI),DX - IMUL3Q $19,DX,AX - MULQ 192(SP) - ADDQ AX,R8 - ADCQ DX,R9 - MOVQ 104(DI),AX - MULQ 160(SP) - ADDQ AX,R12 - ADCQ DX,R13 - MOVQ 104(DI),AX - MULQ 168(SP) - ADDQ AX,R14 - ADCQ DX,R15 - MOVQ 0(SP),AX - MULQ 184(SP) - ADDQ AX,R8 - ADCQ DX,R9 - MOVQ 0(SP),AX - MULQ 192(SP) - ADDQ AX,R10 - ADCQ DX,R11 - MOVQ 112(DI),AX - MULQ 160(SP) - ADDQ AX,R14 - ADCQ DX,R15 - MOVQ 8(SP),AX - MULQ 176(SP) - ADDQ AX,R8 - ADCQ DX,R9 - MOVQ 8(SP),AX - MULQ 184(SP) - ADDQ AX,R10 - ADCQ DX,R11 - MOVQ 8(SP),AX - MULQ 192(SP) - ADDQ AX,R12 - ADCQ DX,R13 - MOVQ $REDMASK51,DX - SHLQ $13,SI,CX - ANDQ DX,SI - SHLQ $13,R8,R9 - ANDQ DX,R8 - ADDQ CX,R8 - SHLQ $13,R10,R11 - ANDQ DX,R10 - ADDQ R9,R10 - SHLQ $13,R12,R13 - ANDQ DX,R12 - ADDQ R11,R12 - SHLQ $13,R14,R15 - ANDQ DX,R14 - ADDQ R13,R14 - IMUL3Q $19,R15,CX - ADDQ CX,SI - MOVQ SI,CX - SHRQ $51,CX - ADDQ R8,CX - MOVQ CX,R8 - SHRQ $51,CX - ANDQ DX,SI - ADDQ R10,CX - MOVQ CX,R9 - SHRQ $51,CX - ANDQ DX,R8 - ADDQ R12,CX - MOVQ CX,AX - SHRQ $51,CX - ANDQ DX,R9 - ADDQ R14,CX - MOVQ CX,R10 - SHRQ $51,CX - ANDQ DX,AX - IMUL3Q $19,CX,CX - ADDQ CX,SI - ANDQ DX,R10 - MOVQ SI,80(DI) - MOVQ R8,88(DI) - MOVQ R9,96(DI) - MOVQ AX,104(DI) - MOVQ R10,112(DI) - RET - -// func cswap(inout *[4][5]uint64, v uint64) -TEXT ·cswap(SB),7,$0 - MOVQ inout+0(FP),DI - MOVQ v+8(FP),SI - - SUBQ $1, SI - NOTQ SI - MOVQ SI, X15 - PSHUFD $0x44, X15, X15 - - MOVOU 0(DI), X0 - MOVOU 16(DI), X2 - MOVOU 32(DI), X4 - MOVOU 48(DI), X6 - MOVOU 64(DI), X8 - MOVOU 80(DI), X1 - MOVOU 96(DI), X3 - MOVOU 112(DI), X5 - MOVOU 128(DI), X7 - MOVOU 144(DI), X9 - - MOVO X1, X10 - MOVO X3, X11 - MOVO X5, X12 - MOVO X7, X13 - MOVO X9, X14 - - PXOR X0, X10 - PXOR X2, X11 - PXOR X4, X12 - PXOR X6, X13 - PXOR X8, X14 - PAND X15, X10 - PAND X15, X11 - PAND X15, X12 - PAND X15, X13 - PAND X15, X14 - PXOR X10, X0 - PXOR X10, X1 - PXOR X11, X2 - PXOR X11, X3 - PXOR X12, X4 - PXOR X12, X5 - PXOR X13, X6 - PXOR X13, X7 - PXOR X14, X8 - PXOR X14, X9 - - MOVOU X0, 0(DI) - MOVOU X2, 16(DI) - MOVOU X4, 32(DI) - MOVOU X6, 48(DI) - MOVOU X8, 64(DI) - MOVOU X1, 80(DI) - MOVOU X3, 96(DI) - MOVOU X5, 112(DI) - MOVOU X7, 128(DI) - MOVOU X9, 144(DI) - RET - -// func mul(dest, a, b *[5]uint64) -TEXT ·mul(SB),0,$16-24 - MOVQ dest+0(FP), DI - MOVQ a+8(FP), SI - MOVQ b+16(FP), DX - - MOVQ DX,CX - MOVQ 24(SI),DX - IMUL3Q $19,DX,AX - MOVQ AX,0(SP) - MULQ 16(CX) - MOVQ AX,R8 - MOVQ DX,R9 - MOVQ 32(SI),DX - IMUL3Q $19,DX,AX - MOVQ AX,8(SP) - MULQ 8(CX) - ADDQ AX,R8 - ADCQ DX,R9 - MOVQ 0(SI),AX - MULQ 0(CX) - ADDQ AX,R8 - ADCQ DX,R9 - MOVQ 0(SI),AX - MULQ 8(CX) - MOVQ AX,R10 - MOVQ DX,R11 - MOVQ 0(SI),AX - MULQ 16(CX) - MOVQ AX,R12 - MOVQ DX,R13 - MOVQ 0(SI),AX - MULQ 24(CX) - MOVQ AX,R14 - MOVQ DX,R15 - MOVQ 0(SI),AX - MULQ 32(CX) - MOVQ AX,BX - MOVQ DX,BP - MOVQ 8(SI),AX - MULQ 0(CX) - ADDQ AX,R10 - ADCQ DX,R11 - MOVQ 8(SI),AX - MULQ 8(CX) - ADDQ AX,R12 - ADCQ DX,R13 - MOVQ 8(SI),AX - MULQ 16(CX) - ADDQ AX,R14 - ADCQ DX,R15 - MOVQ 8(SI),AX - MULQ 24(CX) - ADDQ AX,BX - ADCQ DX,BP - MOVQ 8(SI),DX - IMUL3Q $19,DX,AX - MULQ 32(CX) - ADDQ AX,R8 - ADCQ DX,R9 - MOVQ 16(SI),AX - MULQ 0(CX) - ADDQ AX,R12 - ADCQ DX,R13 - MOVQ 16(SI),AX - MULQ 8(CX) - ADDQ AX,R14 - ADCQ DX,R15 - MOVQ 16(SI),AX - MULQ 16(CX) - ADDQ AX,BX - ADCQ DX,BP - MOVQ 16(SI),DX - IMUL3Q $19,DX,AX - MULQ 24(CX) - ADDQ AX,R8 - ADCQ DX,R9 - MOVQ 16(SI),DX - IMUL3Q $19,DX,AX - MULQ 32(CX) - ADDQ AX,R10 - ADCQ DX,R11 - MOVQ 24(SI),AX - MULQ 0(CX) - ADDQ AX,R14 - ADCQ DX,R15 - MOVQ 24(SI),AX - MULQ 8(CX) - ADDQ AX,BX - ADCQ DX,BP - MOVQ 0(SP),AX - MULQ 24(CX) - ADDQ AX,R10 - ADCQ DX,R11 - MOVQ 0(SP),AX - MULQ 32(CX) - ADDQ AX,R12 - ADCQ DX,R13 - MOVQ 32(SI),AX - MULQ 0(CX) - ADDQ AX,BX - ADCQ DX,BP - MOVQ 8(SP),AX - MULQ 16(CX) - ADDQ AX,R10 - ADCQ DX,R11 - MOVQ 8(SP),AX - MULQ 24(CX) - ADDQ AX,R12 - ADCQ DX,R13 - MOVQ 8(SP),AX - MULQ 32(CX) - ADDQ AX,R14 - ADCQ DX,R15 - MOVQ $REDMASK51,SI - SHLQ $13,R8,R9 - ANDQ SI,R8 - SHLQ $13,R10,R11 - ANDQ SI,R10 - ADDQ R9,R10 - SHLQ $13,R12,R13 - ANDQ SI,R12 - ADDQ R11,R12 - SHLQ $13,R14,R15 - ANDQ SI,R14 - ADDQ R13,R14 - SHLQ $13,BX,BP - ANDQ SI,BX - ADDQ R15,BX - IMUL3Q $19,BP,DX - ADDQ DX,R8 - MOVQ R8,DX - SHRQ $51,DX - ADDQ R10,DX - MOVQ DX,CX - SHRQ $51,DX - ANDQ SI,R8 - ADDQ R12,DX - MOVQ DX,R9 - SHRQ $51,DX - ANDQ SI,CX - ADDQ R14,DX - MOVQ DX,AX - SHRQ $51,DX - ANDQ SI,R9 - ADDQ BX,DX - MOVQ DX,R10 - SHRQ $51,DX - ANDQ SI,AX - IMUL3Q $19,DX,DX - ADDQ DX,R8 - ANDQ SI,R10 - MOVQ R8,0(DI) - MOVQ CX,8(DI) - MOVQ R9,16(DI) - MOVQ AX,24(DI) - MOVQ R10,32(DI) - RET - -// func square(out, in *[5]uint64) -TEXT ·square(SB),7,$0-16 - MOVQ out+0(FP), DI - MOVQ in+8(FP), SI - - MOVQ 0(SI),AX - MULQ 0(SI) - MOVQ AX,CX - MOVQ DX,R8 - MOVQ 0(SI),AX - SHLQ $1,AX - MULQ 8(SI) - MOVQ AX,R9 - MOVQ DX,R10 - MOVQ 0(SI),AX - SHLQ $1,AX - MULQ 16(SI) - MOVQ AX,R11 - MOVQ DX,R12 - MOVQ 0(SI),AX - SHLQ $1,AX - MULQ 24(SI) - MOVQ AX,R13 - MOVQ DX,R14 - MOVQ 0(SI),AX - SHLQ $1,AX - MULQ 32(SI) - MOVQ AX,R15 - MOVQ DX,BX - MOVQ 8(SI),AX - MULQ 8(SI) - ADDQ AX,R11 - ADCQ DX,R12 - MOVQ 8(SI),AX - SHLQ $1,AX - MULQ 16(SI) - ADDQ AX,R13 - ADCQ DX,R14 - MOVQ 8(SI),AX - SHLQ $1,AX - MULQ 24(SI) - ADDQ AX,R15 - ADCQ DX,BX - MOVQ 8(SI),DX - IMUL3Q $38,DX,AX - MULQ 32(SI) - ADDQ AX,CX - ADCQ DX,R8 - MOVQ 16(SI),AX - MULQ 16(SI) - ADDQ AX,R15 - ADCQ DX,BX - MOVQ 16(SI),DX - IMUL3Q $38,DX,AX - MULQ 24(SI) - ADDQ AX,CX - ADCQ DX,R8 - MOVQ 16(SI),DX - IMUL3Q $38,DX,AX - MULQ 32(SI) - ADDQ AX,R9 - ADCQ DX,R10 - MOVQ 24(SI),DX - IMUL3Q $19,DX,AX - MULQ 24(SI) - ADDQ AX,R9 - ADCQ DX,R10 - MOVQ 24(SI),DX - IMUL3Q $38,DX,AX - MULQ 32(SI) - ADDQ AX,R11 - ADCQ DX,R12 - MOVQ 32(SI),DX - IMUL3Q $19,DX,AX - MULQ 32(SI) - ADDQ AX,R13 - ADCQ DX,R14 - MOVQ $REDMASK51,SI - SHLQ $13,CX,R8 - ANDQ SI,CX - SHLQ $13,R9,R10 - ANDQ SI,R9 - ADDQ R8,R9 - SHLQ $13,R11,R12 - ANDQ SI,R11 - ADDQ R10,R11 - SHLQ $13,R13,R14 - ANDQ SI,R13 - ADDQ R12,R13 - SHLQ $13,R15,BX - ANDQ SI,R15 - ADDQ R14,R15 - IMUL3Q $19,BX,DX - ADDQ DX,CX - MOVQ CX,DX - SHRQ $51,DX - ADDQ R9,DX - ANDQ SI,CX - MOVQ DX,R8 - SHRQ $51,DX - ADDQ R11,DX - ANDQ SI,R8 - MOVQ DX,R9 - SHRQ $51,DX - ADDQ R13,DX - ANDQ SI,R9 - MOVQ DX,AX - SHRQ $51,DX - ADDQ R15,DX - ANDQ SI,AX - MOVQ DX,R10 - SHRQ $51,DX - IMUL3Q $19,DX,DX - ADDQ DX,CX - ANDQ SI,R10 - MOVQ CX,0(DI) - MOVQ R8,8(DI) - MOVQ R9,16(DI) - MOVQ AX,24(DI) - MOVQ R10,32(DI) - RET diff --git a/vendor/golang.org/x/crypto/curve25519/curve25519_generic.go b/vendor/golang.org/x/crypto/curve25519/curve25519_generic.go deleted file mode 100644 index c43b13fc..00000000 --- a/vendor/golang.org/x/crypto/curve25519/curve25519_generic.go +++ /dev/null @@ -1,828 +0,0 @@ -// Copyright 2013 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 curve25519 - -import "encoding/binary" - -// This code is a port of the public domain, "ref10" implementation of -// curve25519 from SUPERCOP 20130419 by D. J. Bernstein. - -// fieldElement represents an element of the field GF(2^255 - 19). An element -// t, entries t[0]...t[9], represents the integer t[0]+2^26 t[1]+2^51 t[2]+2^77 -// t[3]+2^102 t[4]+...+2^230 t[9]. Bounds on each t[i] vary depending on -// context. -type fieldElement [10]int32 - -func feZero(fe *fieldElement) { - for i := range fe { - fe[i] = 0 - } -} - -func feOne(fe *fieldElement) { - feZero(fe) - fe[0] = 1 -} - -func feAdd(dst, a, b *fieldElement) { - for i := range dst { - dst[i] = a[i] + b[i] - } -} - -func feSub(dst, a, b *fieldElement) { - for i := range dst { - dst[i] = a[i] - b[i] - } -} - -func feCopy(dst, src *fieldElement) { - for i := range dst { - dst[i] = src[i] - } -} - -// feCSwap replaces (f,g) with (g,f) if b == 1; replaces (f,g) with (f,g) if b == 0. -// -// Preconditions: b in {0,1}. -func feCSwap(f, g *fieldElement, b int32) { - b = -b - for i := range f { - t := b & (f[i] ^ g[i]) - f[i] ^= t - g[i] ^= t - } -} - -// load3 reads a 24-bit, little-endian value from in. -func load3(in []byte) int64 { - var r int64 - r = int64(in[0]) - r |= int64(in[1]) << 8 - r |= int64(in[2]) << 16 - return r -} - -// load4 reads a 32-bit, little-endian value from in. -func load4(in []byte) int64 { - return int64(binary.LittleEndian.Uint32(in)) -} - -func feFromBytes(dst *fieldElement, src *[32]byte) { - h0 := load4(src[:]) - h1 := load3(src[4:]) << 6 - h2 := load3(src[7:]) << 5 - h3 := load3(src[10:]) << 3 - h4 := load3(src[13:]) << 2 - h5 := load4(src[16:]) - h6 := load3(src[20:]) << 7 - h7 := load3(src[23:]) << 5 - h8 := load3(src[26:]) << 4 - h9 := (load3(src[29:]) & 0x7fffff) << 2 - - var carry [10]int64 - carry[9] = (h9 + 1<<24) >> 25 - h0 += carry[9] * 19 - h9 -= carry[9] << 25 - carry[1] = (h1 + 1<<24) >> 25 - h2 += carry[1] - h1 -= carry[1] << 25 - carry[3] = (h3 + 1<<24) >> 25 - h4 += carry[3] - h3 -= carry[3] << 25 - carry[5] = (h5 + 1<<24) >> 25 - h6 += carry[5] - h5 -= carry[5] << 25 - carry[7] = (h7 + 1<<24) >> 25 - h8 += carry[7] - h7 -= carry[7] << 25 - - carry[0] = (h0 + 1<<25) >> 26 - h1 += carry[0] - h0 -= carry[0] << 26 - carry[2] = (h2 + 1<<25) >> 26 - h3 += carry[2] - h2 -= carry[2] << 26 - carry[4] = (h4 + 1<<25) >> 26 - h5 += carry[4] - h4 -= carry[4] << 26 - carry[6] = (h6 + 1<<25) >> 26 - h7 += carry[6] - h6 -= carry[6] << 26 - carry[8] = (h8 + 1<<25) >> 26 - h9 += carry[8] - h8 -= carry[8] << 26 - - dst[0] = int32(h0) - dst[1] = int32(h1) - dst[2] = int32(h2) - dst[3] = int32(h3) - dst[4] = int32(h4) - dst[5] = int32(h5) - dst[6] = int32(h6) - dst[7] = int32(h7) - dst[8] = int32(h8) - dst[9] = int32(h9) -} - -// feToBytes marshals h to s. -// Preconditions: -// |h| bounded by 1.1*2^25,1.1*2^24,1.1*2^25,1.1*2^24,etc. -// -// Write p=2^255-19; q=floor(h/p). -// Basic claim: q = floor(2^(-255)(h + 19 2^(-25)h9 + 2^(-1))). -// -// Proof: -// Have |h|<=p so |q|<=1 so |19^2 2^(-255) q|<1/4. -// Also have |h-2^230 h9|<2^230 so |19 2^(-255)(h-2^230 h9)|<1/4. -// -// Write y=2^(-1)-19^2 2^(-255)q-19 2^(-255)(h-2^230 h9). -// Then 0<y<1. -// -// Write r=h-pq. -// Have 0<=r<=p-1=2^255-20. -// Thus 0<=r+19(2^-255)r<r+19(2^-255)2^255<=2^255-1. -// -// Write x=r+19(2^-255)r+y. -// Then 0<x<2^255 so floor(2^(-255)x) = 0 so floor(q+2^(-255)x) = q. -// -// Have q+2^(-255)x = 2^(-255)(h + 19 2^(-25) h9 + 2^(-1)) -// so floor(2^(-255)(h + 19 2^(-25) h9 + 2^(-1))) = q. -func feToBytes(s *[32]byte, h *fieldElement) { - var carry [10]int32 - - q := (19*h[9] + (1 << 24)) >> 25 - q = (h[0] + q) >> 26 - q = (h[1] + q) >> 25 - q = (h[2] + q) >> 26 - q = (h[3] + q) >> 25 - q = (h[4] + q) >> 26 - q = (h[5] + q) >> 25 - q = (h[6] + q) >> 26 - q = (h[7] + q) >> 25 - q = (h[8] + q) >> 26 - q = (h[9] + q) >> 25 - - // Goal: Output h-(2^255-19)q, which is between 0 and 2^255-20. - h[0] += 19 * q - // Goal: Output h-2^255 q, which is between 0 and 2^255-20. - - carry[0] = h[0] >> 26 - h[1] += carry[0] - h[0] -= carry[0] << 26 - carry[1] = h[1] >> 25 - h[2] += carry[1] - h[1] -= carry[1] << 25 - carry[2] = h[2] >> 26 - h[3] += carry[2] - h[2] -= carry[2] << 26 - carry[3] = h[3] >> 25 - h[4] += carry[3] - h[3] -= carry[3] << 25 - carry[4] = h[4] >> 26 - h[5] += carry[4] - h[4] -= carry[4] << 26 - carry[5] = h[5] >> 25 - h[6] += carry[5] - h[5] -= carry[5] << 25 - carry[6] = h[6] >> 26 - h[7] += carry[6] - h[6] -= carry[6] << 26 - carry[7] = h[7] >> 25 - h[8] += carry[7] - h[7] -= carry[7] << 25 - carry[8] = h[8] >> 26 - h[9] += carry[8] - h[8] -= carry[8] << 26 - carry[9] = h[9] >> 25 - h[9] -= carry[9] << 25 - // h10 = carry9 - - // Goal: Output h[0]+...+2^255 h10-2^255 q, which is between 0 and 2^255-20. - // Have h[0]+...+2^230 h[9] between 0 and 2^255-1; - // evidently 2^255 h10-2^255 q = 0. - // Goal: Output h[0]+...+2^230 h[9]. - - s[0] = byte(h[0] >> 0) - s[1] = byte(h[0] >> 8) - s[2] = byte(h[0] >> 16) - s[3] = byte((h[0] >> 24) | (h[1] << 2)) - s[4] = byte(h[1] >> 6) - s[5] = byte(h[1] >> 14) - s[6] = byte((h[1] >> 22) | (h[2] << 3)) - s[7] = byte(h[2] >> 5) - s[8] = byte(h[2] >> 13) - s[9] = byte((h[2] >> 21) | (h[3] << 5)) - s[10] = byte(h[3] >> 3) - s[11] = byte(h[3] >> 11) - s[12] = byte((h[3] >> 19) | (h[4] << 6)) - s[13] = byte(h[4] >> 2) - s[14] = byte(h[4] >> 10) - s[15] = byte(h[4] >> 18) - s[16] = byte(h[5] >> 0) - s[17] = byte(h[5] >> 8) - s[18] = byte(h[5] >> 16) - s[19] = byte((h[5] >> 24) | (h[6] << 1)) - s[20] = byte(h[6] >> 7) - s[21] = byte(h[6] >> 15) - s[22] = byte((h[6] >> 23) | (h[7] << 3)) - s[23] = byte(h[7] >> 5) - s[24] = byte(h[7] >> 13) - s[25] = byte((h[7] >> 21) | (h[8] << 4)) - s[26] = byte(h[8] >> 4) - s[27] = byte(h[8] >> 12) - s[28] = byte((h[8] >> 20) | (h[9] << 6)) - s[29] = byte(h[9] >> 2) - s[30] = byte(h[9] >> 10) - s[31] = byte(h[9] >> 18) -} - -// feMul calculates h = f * g -// Can overlap h with f or g. -// -// Preconditions: -// |f| bounded by 1.1*2^26,1.1*2^25,1.1*2^26,1.1*2^25,etc. -// |g| bounded by 1.1*2^26,1.1*2^25,1.1*2^26,1.1*2^25,etc. -// -// Postconditions: -// |h| bounded by 1.1*2^25,1.1*2^24,1.1*2^25,1.1*2^24,etc. -// -// Notes on implementation strategy: -// -// Using schoolbook multiplication. -// Karatsuba would save a little in some cost models. -// -// Most multiplications by 2 and 19 are 32-bit precomputations; -// cheaper than 64-bit postcomputations. -// -// There is one remaining multiplication by 19 in the carry chain; -// one *19 precomputation can be merged into this, -// but the resulting data flow is considerably less clean. -// -// There are 12 carries below. -// 10 of them are 2-way parallelizable and vectorizable. -// Can get away with 11 carries, but then data flow is much deeper. -// -// With tighter constraints on inputs can squeeze carries into int32. -func feMul(h, f, g *fieldElement) { - f0 := f[0] - f1 := f[1] - f2 := f[2] - f3 := f[3] - f4 := f[4] - f5 := f[5] - f6 := f[6] - f7 := f[7] - f8 := f[8] - f9 := f[9] - g0 := g[0] - g1 := g[1] - g2 := g[2] - g3 := g[3] - g4 := g[4] - g5 := g[5] - g6 := g[6] - g7 := g[7] - g8 := g[8] - g9 := g[9] - g1_19 := 19 * g1 // 1.4*2^29 - g2_19 := 19 * g2 // 1.4*2^30; still ok - g3_19 := 19 * g3 - g4_19 := 19 * g4 - g5_19 := 19 * g5 - g6_19 := 19 * g6 - g7_19 := 19 * g7 - g8_19 := 19 * g8 - g9_19 := 19 * g9 - f1_2 := 2 * f1 - f3_2 := 2 * f3 - f5_2 := 2 * f5 - f7_2 := 2 * f7 - f9_2 := 2 * f9 - f0g0 := int64(f0) * int64(g0) - f0g1 := int64(f0) * int64(g1) - f0g2 := int64(f0) * int64(g2) - f0g3 := int64(f0) * int64(g3) - f0g4 := int64(f0) * int64(g4) - f0g5 := int64(f0) * int64(g5) - f0g6 := int64(f0) * int64(g6) - f0g7 := int64(f0) * int64(g7) - f0g8 := int64(f0) * int64(g8) - f0g9 := int64(f0) * int64(g9) - f1g0 := int64(f1) * int64(g0) - f1g1_2 := int64(f1_2) * int64(g1) - f1g2 := int64(f1) * int64(g2) - f1g3_2 := int64(f1_2) * int64(g3) - f1g4 := int64(f1) * int64(g4) - f1g5_2 := int64(f1_2) * int64(g5) - f1g6 := int64(f1) * int64(g6) - f1g7_2 := int64(f1_2) * int64(g7) - f1g8 := int64(f1) * int64(g8) - f1g9_38 := int64(f1_2) * int64(g9_19) - f2g0 := int64(f2) * int64(g0) - f2g1 := int64(f2) * int64(g1) - f2g2 := int64(f2) * int64(g2) - f2g3 := int64(f2) * int64(g3) - f2g4 := int64(f2) * int64(g4) - f2g5 := int64(f2) * int64(g5) - f2g6 := int64(f2) * int64(g6) - f2g7 := int64(f2) * int64(g7) - f2g8_19 := int64(f2) * int64(g8_19) - f2g9_19 := int64(f2) * int64(g9_19) - f3g0 := int64(f3) * int64(g0) - f3g1_2 := int64(f3_2) * int64(g1) - f3g2 := int64(f3) * int64(g2) - f3g3_2 := int64(f3_2) * int64(g3) - f3g4 := int64(f3) * int64(g4) - f3g5_2 := int64(f3_2) * int64(g5) - f3g6 := int64(f3) * int64(g6) - f3g7_38 := int64(f3_2) * int64(g7_19) - f3g8_19 := int64(f3) * int64(g8_19) - f3g9_38 := int64(f3_2) * int64(g9_19) - f4g0 := int64(f4) * int64(g0) - f4g1 := int64(f4) * int64(g1) - f4g2 := int64(f4) * int64(g2) - f4g3 := int64(f4) * int64(g3) - f4g4 := int64(f4) * int64(g4) - f4g5 := int64(f4) * int64(g5) - f4g6_19 := int64(f4) * int64(g6_19) - f4g7_19 := int64(f4) * int64(g7_19) - f4g8_19 := int64(f4) * int64(g8_19) - f4g9_19 := int64(f4) * int64(g9_19) - f5g0 := int64(f5) * int64(g0) - f5g1_2 := int64(f5_2) * int64(g1) - f5g2 := int64(f5) * int64(g2) - f5g3_2 := int64(f5_2) * int64(g3) - f5g4 := int64(f5) * int64(g4) - f5g5_38 := int64(f5_2) * int64(g5_19) - f5g6_19 := int64(f5) * int64(g6_19) - f5g7_38 := int64(f5_2) * int64(g7_19) - f5g8_19 := int64(f5) * int64(g8_19) - f5g9_38 := int64(f5_2) * int64(g9_19) - f6g0 := int64(f6) * int64(g0) - f6g1 := int64(f6) * int64(g1) - f6g2 := int64(f6) * int64(g2) - f6g3 := int64(f6) * int64(g3) - f6g4_19 := int64(f6) * int64(g4_19) - f6g5_19 := int64(f6) * int64(g5_19) - f6g6_19 := int64(f6) * int64(g6_19) - f6g7_19 := int64(f6) * int64(g7_19) - f6g8_19 := int64(f6) * int64(g8_19) - f6g9_19 := int64(f6) * int64(g9_19) - f7g0 := int64(f7) * int64(g0) - f7g1_2 := int64(f7_2) * int64(g1) - f7g2 := int64(f7) * int64(g2) - f7g3_38 := int64(f7_2) * int64(g3_19) - f7g4_19 := int64(f7) * int64(g4_19) - f7g5_38 := int64(f7_2) * int64(g5_19) - f7g6_19 := int64(f7) * int64(g6_19) - f7g7_38 := int64(f7_2) * int64(g7_19) - f7g8_19 := int64(f7) * int64(g8_19) - f7g9_38 := int64(f7_2) * int64(g9_19) - f8g0 := int64(f8) * int64(g0) - f8g1 := int64(f8) * int64(g1) - f8g2_19 := int64(f8) * int64(g2_19) - f8g3_19 := int64(f8) * int64(g3_19) - f8g4_19 := int64(f8) * int64(g4_19) - f8g5_19 := int64(f8) * int64(g5_19) - f8g6_19 := int64(f8) * int64(g6_19) - f8g7_19 := int64(f8) * int64(g7_19) - f8g8_19 := int64(f8) * int64(g8_19) - f8g9_19 := int64(f8) * int64(g9_19) - f9g0 := int64(f9) * int64(g0) - f9g1_38 := int64(f9_2) * int64(g1_19) - f9g2_19 := int64(f9) * int64(g2_19) - f9g3_38 := int64(f9_2) * int64(g3_19) - f9g4_19 := int64(f9) * int64(g4_19) - f9g5_38 := int64(f9_2) * int64(g5_19) - f9g6_19 := int64(f9) * int64(g6_19) - f9g7_38 := int64(f9_2) * int64(g7_19) - f9g8_19 := int64(f9) * int64(g8_19) - f9g9_38 := int64(f9_2) * int64(g9_19) - h0 := f0g0 + f1g9_38 + f2g8_19 + f3g7_38 + f4g6_19 + f5g5_38 + f6g4_19 + f7g3_38 + f8g2_19 + f9g1_38 - h1 := f0g1 + f1g0 + f2g9_19 + f3g8_19 + f4g7_19 + f5g6_19 + f6g5_19 + f7g4_19 + f8g3_19 + f9g2_19 - h2 := f0g2 + f1g1_2 + f2g0 + f3g9_38 + f4g8_19 + f5g7_38 + f6g6_19 + f7g5_38 + f8g4_19 + f9g3_38 - h3 := f0g3 + f1g2 + f2g1 + f3g0 + f4g9_19 + f5g8_19 + f6g7_19 + f7g6_19 + f8g5_19 + f9g4_19 - h4 := f0g4 + f1g3_2 + f2g2 + f3g1_2 + f4g0 + f5g9_38 + f6g8_19 + f7g7_38 + f8g6_19 + f9g5_38 - h5 := f0g5 + f1g4 + f2g3 + f3g2 + f4g1 + f5g0 + f6g9_19 + f7g8_19 + f8g7_19 + f9g6_19 - h6 := f0g6 + f1g5_2 + f2g4 + f3g3_2 + f4g2 + f5g1_2 + f6g0 + f7g9_38 + f8g8_19 + f9g7_38 - h7 := f0g7 + f1g6 + f2g5 + f3g4 + f4g3 + f5g2 + f6g1 + f7g0 + f8g9_19 + f9g8_19 - h8 := f0g8 + f1g7_2 + f2g6 + f3g5_2 + f4g4 + f5g3_2 + f6g2 + f7g1_2 + f8g0 + f9g9_38 - h9 := f0g9 + f1g8 + f2g7 + f3g6 + f4g5 + f5g4 + f6g3 + f7g2 + f8g1 + f9g0 - var carry [10]int64 - - // |h0| <= (1.1*1.1*2^52*(1+19+19+19+19)+1.1*1.1*2^50*(38+38+38+38+38)) - // i.e. |h0| <= 1.2*2^59; narrower ranges for h2, h4, h6, h8 - // |h1| <= (1.1*1.1*2^51*(1+1+19+19+19+19+19+19+19+19)) - // i.e. |h1| <= 1.5*2^58; narrower ranges for h3, h5, h7, h9 - - carry[0] = (h0 + (1 << 25)) >> 26 - h1 += carry[0] - h0 -= carry[0] << 26 - carry[4] = (h4 + (1 << 25)) >> 26 - h5 += carry[4] - h4 -= carry[4] << 26 - // |h0| <= 2^25 - // |h4| <= 2^25 - // |h1| <= 1.51*2^58 - // |h5| <= 1.51*2^58 - - carry[1] = (h1 + (1 << 24)) >> 25 - h2 += carry[1] - h1 -= carry[1] << 25 - carry[5] = (h5 + (1 << 24)) >> 25 - h6 += carry[5] - h5 -= carry[5] << 25 - // |h1| <= 2^24; from now on fits into int32 - // |h5| <= 2^24; from now on fits into int32 - // |h2| <= 1.21*2^59 - // |h6| <= 1.21*2^59 - - carry[2] = (h2 + (1 << 25)) >> 26 - h3 += carry[2] - h2 -= carry[2] << 26 - carry[6] = (h6 + (1 << 25)) >> 26 - h7 += carry[6] - h6 -= carry[6] << 26 - // |h2| <= 2^25; from now on fits into int32 unchanged - // |h6| <= 2^25; from now on fits into int32 unchanged - // |h3| <= 1.51*2^58 - // |h7| <= 1.51*2^58 - - carry[3] = (h3 + (1 << 24)) >> 25 - h4 += carry[3] - h3 -= carry[3] << 25 - carry[7] = (h7 + (1 << 24)) >> 25 - h8 += carry[7] - h7 -= carry[7] << 25 - // |h3| <= 2^24; from now on fits into int32 unchanged - // |h7| <= 2^24; from now on fits into int32 unchanged - // |h4| <= 1.52*2^33 - // |h8| <= 1.52*2^33 - - carry[4] = (h4 + (1 << 25)) >> 26 - h5 += carry[4] - h4 -= carry[4] << 26 - carry[8] = (h8 + (1 << 25)) >> 26 - h9 += carry[8] - h8 -= carry[8] << 26 - // |h4| <= 2^25; from now on fits into int32 unchanged - // |h8| <= 2^25; from now on fits into int32 unchanged - // |h5| <= 1.01*2^24 - // |h9| <= 1.51*2^58 - - carry[9] = (h9 + (1 << 24)) >> 25 - h0 += carry[9] * 19 - h9 -= carry[9] << 25 - // |h9| <= 2^24; from now on fits into int32 unchanged - // |h0| <= 1.8*2^37 - - carry[0] = (h0 + (1 << 25)) >> 26 - h1 += carry[0] - h0 -= carry[0] << 26 - // |h0| <= 2^25; from now on fits into int32 unchanged - // |h1| <= 1.01*2^24 - - h[0] = int32(h0) - h[1] = int32(h1) - h[2] = int32(h2) - h[3] = int32(h3) - h[4] = int32(h4) - h[5] = int32(h5) - h[6] = int32(h6) - h[7] = int32(h7) - h[8] = int32(h8) - h[9] = int32(h9) -} - -// feSquare calculates h = f*f. Can overlap h with f. -// -// Preconditions: -// |f| bounded by 1.1*2^26,1.1*2^25,1.1*2^26,1.1*2^25,etc. -// -// Postconditions: -// |h| bounded by 1.1*2^25,1.1*2^24,1.1*2^25,1.1*2^24,etc. -func feSquare(h, f *fieldElement) { - f0 := f[0] - f1 := f[1] - f2 := f[2] - f3 := f[3] - f4 := f[4] - f5 := f[5] - f6 := f[6] - f7 := f[7] - f8 := f[8] - f9 := f[9] - f0_2 := 2 * f0 - f1_2 := 2 * f1 - f2_2 := 2 * f2 - f3_2 := 2 * f3 - f4_2 := 2 * f4 - f5_2 := 2 * f5 - f6_2 := 2 * f6 - f7_2 := 2 * f7 - f5_38 := 38 * f5 // 1.31*2^30 - f6_19 := 19 * f6 // 1.31*2^30 - f7_38 := 38 * f7 // 1.31*2^30 - f8_19 := 19 * f8 // 1.31*2^30 - f9_38 := 38 * f9 // 1.31*2^30 - f0f0 := int64(f0) * int64(f0) - f0f1_2 := int64(f0_2) * int64(f1) - f0f2_2 := int64(f0_2) * int64(f2) - f0f3_2 := int64(f0_2) * int64(f3) - f0f4_2 := int64(f0_2) * int64(f4) - f0f5_2 := int64(f0_2) * int64(f5) - f0f6_2 := int64(f0_2) * int64(f6) - f0f7_2 := int64(f0_2) * int64(f7) - f0f8_2 := int64(f0_2) * int64(f8) - f0f9_2 := int64(f0_2) * int64(f9) - f1f1_2 := int64(f1_2) * int64(f1) - f1f2_2 := int64(f1_2) * int64(f2) - f1f3_4 := int64(f1_2) * int64(f3_2) - f1f4_2 := int64(f1_2) * int64(f4) - f1f5_4 := int64(f1_2) * int64(f5_2) - f1f6_2 := int64(f1_2) * int64(f6) - f1f7_4 := int64(f1_2) * int64(f7_2) - f1f8_2 := int64(f1_2) * int64(f8) - f1f9_76 := int64(f1_2) * int64(f9_38) - f2f2 := int64(f2) * int64(f2) - f2f3_2 := int64(f2_2) * int64(f3) - f2f4_2 := int64(f2_2) * int64(f4) - f2f5_2 := int64(f2_2) * int64(f5) - f2f6_2 := int64(f2_2) * int64(f6) - f2f7_2 := int64(f2_2) * int64(f7) - f2f8_38 := int64(f2_2) * int64(f8_19) - f2f9_38 := int64(f2) * int64(f9_38) - f3f3_2 := int64(f3_2) * int64(f3) - f3f4_2 := int64(f3_2) * int64(f4) - f3f5_4 := int64(f3_2) * int64(f5_2) - f3f6_2 := int64(f3_2) * int64(f6) - f3f7_76 := int64(f3_2) * int64(f7_38) - f3f8_38 := int64(f3_2) * int64(f8_19) - f3f9_76 := int64(f3_2) * int64(f9_38) - f4f4 := int64(f4) * int64(f4) - f4f5_2 := int64(f4_2) * int64(f5) - f4f6_38 := int64(f4_2) * int64(f6_19) - f4f7_38 := int64(f4) * int64(f7_38) - f4f8_38 := int64(f4_2) * int64(f8_19) - f4f9_38 := int64(f4) * int64(f9_38) - f5f5_38 := int64(f5) * int64(f5_38) - f5f6_38 := int64(f5_2) * int64(f6_19) - f5f7_76 := int64(f5_2) * int64(f7_38) - f5f8_38 := int64(f5_2) * int64(f8_19) - f5f9_76 := int64(f5_2) * int64(f9_38) - f6f6_19 := int64(f6) * int64(f6_19) - f6f7_38 := int64(f6) * int64(f7_38) - f6f8_38 := int64(f6_2) * int64(f8_19) - f6f9_38 := int64(f6) * int64(f9_38) - f7f7_38 := int64(f7) * int64(f7_38) - f7f8_38 := int64(f7_2) * int64(f8_19) - f7f9_76 := int64(f7_2) * int64(f9_38) - f8f8_19 := int64(f8) * int64(f8_19) - f8f9_38 := int64(f8) * int64(f9_38) - f9f9_38 := int64(f9) * int64(f9_38) - h0 := f0f0 + f1f9_76 + f2f8_38 + f3f7_76 + f4f6_38 + f5f5_38 - h1 := f0f1_2 + f2f9_38 + f3f8_38 + f4f7_38 + f5f6_38 - h2 := f0f2_2 + f1f1_2 + f3f9_76 + f4f8_38 + f5f7_76 + f6f6_19 - h3 := f0f3_2 + f1f2_2 + f4f9_38 + f5f8_38 + f6f7_38 - h4 := f0f4_2 + f1f3_4 + f2f2 + f5f9_76 + f6f8_38 + f7f7_38 - h5 := f0f5_2 + f1f4_2 + f2f3_2 + f6f9_38 + f7f8_38 - h6 := f0f6_2 + f1f5_4 + f2f4_2 + f3f3_2 + f7f9_76 + f8f8_19 - h7 := f0f7_2 + f1f6_2 + f2f5_2 + f3f4_2 + f8f9_38 - h8 := f0f8_2 + f1f7_4 + f2f6_2 + f3f5_4 + f4f4 + f9f9_38 - h9 := f0f9_2 + f1f8_2 + f2f7_2 + f3f6_2 + f4f5_2 - var carry [10]int64 - - carry[0] = (h0 + (1 << 25)) >> 26 - h1 += carry[0] - h0 -= carry[0] << 26 - carry[4] = (h4 + (1 << 25)) >> 26 - h5 += carry[4] - h4 -= carry[4] << 26 - - carry[1] = (h1 + (1 << 24)) >> 25 - h2 += carry[1] - h1 -= carry[1] << 25 - carry[5] = (h5 + (1 << 24)) >> 25 - h6 += carry[5] - h5 -= carry[5] << 25 - - carry[2] = (h2 + (1 << 25)) >> 26 - h3 += carry[2] - h2 -= carry[2] << 26 - carry[6] = (h6 + (1 << 25)) >> 26 - h7 += carry[6] - h6 -= carry[6] << 26 - - carry[3] = (h3 + (1 << 24)) >> 25 - h4 += carry[3] - h3 -= carry[3] << 25 - carry[7] = (h7 + (1 << 24)) >> 25 - h8 += carry[7] - h7 -= carry[7] << 25 - - carry[4] = (h4 + (1 << 25)) >> 26 - h5 += carry[4] - h4 -= carry[4] << 26 - carry[8] = (h8 + (1 << 25)) >> 26 - h9 += carry[8] - h8 -= carry[8] << 26 - - carry[9] = (h9 + (1 << 24)) >> 25 - h0 += carry[9] * 19 - h9 -= carry[9] << 25 - - carry[0] = (h0 + (1 << 25)) >> 26 - h1 += carry[0] - h0 -= carry[0] << 26 - - h[0] = int32(h0) - h[1] = int32(h1) - h[2] = int32(h2) - h[3] = int32(h3) - h[4] = int32(h4) - h[5] = int32(h5) - h[6] = int32(h6) - h[7] = int32(h7) - h[8] = int32(h8) - h[9] = int32(h9) -} - -// feMul121666 calculates h = f * 121666. Can overlap h with f. -// -// Preconditions: -// |f| bounded by 1.1*2^26,1.1*2^25,1.1*2^26,1.1*2^25,etc. -// -// Postconditions: -// |h| bounded by 1.1*2^25,1.1*2^24,1.1*2^25,1.1*2^24,etc. -func feMul121666(h, f *fieldElement) { - h0 := int64(f[0]) * 121666 - h1 := int64(f[1]) * 121666 - h2 := int64(f[2]) * 121666 - h3 := int64(f[3]) * 121666 - h4 := int64(f[4]) * 121666 - h5 := int64(f[5]) * 121666 - h6 := int64(f[6]) * 121666 - h7 := int64(f[7]) * 121666 - h8 := int64(f[8]) * 121666 - h9 := int64(f[9]) * 121666 - var carry [10]int64 - - carry[9] = (h9 + (1 << 24)) >> 25 - h0 += carry[9] * 19 - h9 -= carry[9] << 25 - carry[1] = (h1 + (1 << 24)) >> 25 - h2 += carry[1] - h1 -= carry[1] << 25 - carry[3] = (h3 + (1 << 24)) >> 25 - h4 += carry[3] - h3 -= carry[3] << 25 - carry[5] = (h5 + (1 << 24)) >> 25 - h6 += carry[5] - h5 -= carry[5] << 25 - carry[7] = (h7 + (1 << 24)) >> 25 - h8 += carry[7] - h7 -= carry[7] << 25 - - carry[0] = (h0 + (1 << 25)) >> 26 - h1 += carry[0] - h0 -= carry[0] << 26 - carry[2] = (h2 + (1 << 25)) >> 26 - h3 += carry[2] - h2 -= carry[2] << 26 - carry[4] = (h4 + (1 << 25)) >> 26 - h5 += carry[4] - h4 -= carry[4] << 26 - carry[6] = (h6 + (1 << 25)) >> 26 - h7 += carry[6] - h6 -= carry[6] << 26 - carry[8] = (h8 + (1 << 25)) >> 26 - h9 += carry[8] - h8 -= carry[8] << 26 - - h[0] = int32(h0) - h[1] = int32(h1) - h[2] = int32(h2) - h[3] = int32(h3) - h[4] = int32(h4) - h[5] = int32(h5) - h[6] = int32(h6) - h[7] = int32(h7) - h[8] = int32(h8) - h[9] = int32(h9) -} - -// feInvert sets out = z^-1. -func feInvert(out, z *fieldElement) { - var t0, t1, t2, t3 fieldElement - var i int - - feSquare(&t0, z) - for i = 1; i < 1; i++ { - feSquare(&t0, &t0) - } - feSquare(&t1, &t0) - for i = 1; i < 2; i++ { - feSquare(&t1, &t1) - } - feMul(&t1, z, &t1) - feMul(&t0, &t0, &t1) - feSquare(&t2, &t0) - for i = 1; i < 1; i++ { - feSquare(&t2, &t2) - } - feMul(&t1, &t1, &t2) - feSquare(&t2, &t1) - for i = 1; i < 5; i++ { - feSquare(&t2, &t2) - } - feMul(&t1, &t2, &t1) - feSquare(&t2, &t1) - for i = 1; i < 10; i++ { - feSquare(&t2, &t2) - } - feMul(&t2, &t2, &t1) - feSquare(&t3, &t2) - for i = 1; i < 20; i++ { - feSquare(&t3, &t3) - } - feMul(&t2, &t3, &t2) - feSquare(&t2, &t2) - for i = 1; i < 10; i++ { - feSquare(&t2, &t2) - } - feMul(&t1, &t2, &t1) - feSquare(&t2, &t1) - for i = 1; i < 50; i++ { - feSquare(&t2, &t2) - } - feMul(&t2, &t2, &t1) - feSquare(&t3, &t2) - for i = 1; i < 100; i++ { - feSquare(&t3, &t3) - } - feMul(&t2, &t3, &t2) - feSquare(&t2, &t2) - for i = 1; i < 50; i++ { - feSquare(&t2, &t2) - } - feMul(&t1, &t2, &t1) - feSquare(&t1, &t1) - for i = 1; i < 5; i++ { - feSquare(&t1, &t1) - } - feMul(out, &t1, &t0) -} - -func scalarMultGeneric(out, in, base *[32]byte) { - var e [32]byte - - copy(e[:], in[:]) - e[0] &= 248 - e[31] &= 127 - e[31] |= 64 - - var x1, x2, z2, x3, z3, tmp0, tmp1 fieldElement - feFromBytes(&x1, base) - feOne(&x2) - feCopy(&x3, &x1) - feOne(&z3) - - swap := int32(0) - for pos := 254; pos >= 0; pos-- { - b := e[pos/8] >> uint(pos&7) - b &= 1 - swap ^= int32(b) - feCSwap(&x2, &x3, swap) - feCSwap(&z2, &z3, swap) - swap = int32(b) - - feSub(&tmp0, &x3, &z3) - feSub(&tmp1, &x2, &z2) - feAdd(&x2, &x2, &z2) - feAdd(&z2, &x3, &z3) - feMul(&z3, &tmp0, &x2) - feMul(&z2, &z2, &tmp1) - feSquare(&tmp0, &tmp1) - feSquare(&tmp1, &x2) - feAdd(&x3, &z3, &z2) - feSub(&z2, &z3, &z2) - feMul(&x2, &tmp1, &tmp0) - feSub(&tmp1, &tmp1, &tmp0) - feSquare(&z2, &z2) - feMul121666(&z3, &tmp1) - feSquare(&x3, &x3) - feAdd(&tmp0, &tmp0, &z3) - feMul(&z3, &x1, &z2) - feMul(&z2, &tmp1, &tmp0) - } - - feCSwap(&x2, &x3, swap) - feCSwap(&z2, &z3, swap) - - feInvert(&z2, &z2) - feMul(&x2, &x2, &z2) - feToBytes(out, &x2) -} diff --git a/vendor/golang.org/x/crypto/curve25519/curve25519_noasm.go b/vendor/golang.org/x/crypto/curve25519/curve25519_noasm.go deleted file mode 100644 index 259728af..00000000 --- a/vendor/golang.org/x/crypto/curve25519/curve25519_noasm.go +++ /dev/null @@ -1,12 +0,0 @@ -// Copyright 2019 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 || !gc || purego -// +build !amd64 !gc purego - -package curve25519 - -func scalarMult(out, in, base *[32]byte) { - scalarMultGeneric(out, in, base) -} diff --git a/vendor/golang.org/x/crypto/curve25519/internal/field/README b/vendor/golang.org/x/crypto/curve25519/internal/field/README new file mode 100644 index 00000000..e25bca7d --- /dev/null +++ b/vendor/golang.org/x/crypto/curve25519/internal/field/README @@ -0,0 +1,7 @@ +This package is kept in sync with crypto/ed25519/internal/edwards25519/field in +the standard library. + +If there are any changes in the standard library that need to be synced to this +package, run sync.sh. It will not overwrite any local changes made since the +previous sync, so it's ok to land changes in this package first, and then sync +to the standard library later. diff --git a/vendor/golang.org/x/crypto/curve25519/internal/field/fe.go b/vendor/golang.org/x/crypto/curve25519/internal/field/fe.go new file mode 100644 index 00000000..ca841ad9 --- /dev/null +++ b/vendor/golang.org/x/crypto/curve25519/internal/field/fe.go @@ -0,0 +1,416 @@ +// Copyright (c) 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. + +// Package field implements fast arithmetic modulo 2^255-19. +package field + +import ( + "crypto/subtle" + "encoding/binary" + "math/bits" +) + +// Element represents an element of the field GF(2^255-19). Note that this +// is not a cryptographically secure group, and should only be used to interact +// with edwards25519.Point coordinates. +// +// This type works similarly to math/big.Int, and all arguments and receivers +// are allowed to alias. +// +// The zero value is a valid zero element. +type Element struct { + // An element t represents the integer + // t.l0 + t.l1*2^51 + t.l2*2^102 + t.l3*2^153 + t.l4*2^204 + // + // Between operations, all limbs are expected to be lower than 2^52. + l0 uint64 + l1 uint64 + l2 uint64 + l3 uint64 + l4 uint64 +} + +const maskLow51Bits uint64 = (1 << 51) - 1 + +var feZero = &Element{0, 0, 0, 0, 0} + +// Zero sets v = 0, and returns v. +func (v *Element) Zero() *Element { + *v = *feZero + return v +} + +var feOne = &Element{1, 0, 0, 0, 0} + +// One sets v = 1, and returns v. +func (v *Element) One() *Element { + *v = *feOne + return v +} + +// reduce reduces v modulo 2^255 - 19 and returns it. +func (v *Element) reduce() *Element { + v.carryPropagate() + + // After the light reduction we now have a field element representation + // v < 2^255 + 2^13 * 19, but need v < 2^255 - 19. + + // If v >= 2^255 - 19, then v + 19 >= 2^255, which would overflow 2^255 - 1, + // generating a carry. That is, c will be 0 if v < 2^255 - 19, and 1 otherwise. + c := (v.l0 + 19) >> 51 + c = (v.l1 + c) >> 51 + c = (v.l2 + c) >> 51 + c = (v.l3 + c) >> 51 + c = (v.l4 + c) >> 51 + + // If v < 2^255 - 19 and c = 0, this will be a no-op. Otherwise, it's + // effectively applying the reduction identity to the carry. + v.l0 += 19 * c + + v.l1 += v.l0 >> 51 + v.l0 = v.l0 & maskLow51Bits + v.l2 += v.l1 >> 51 + v.l1 = v.l1 & maskLow51Bits + v.l3 += v.l2 >> 51 + v.l2 = v.l2 & maskLow51Bits + v.l4 += v.l3 >> 51 + v.l3 = v.l3 & maskLow51Bits + // no additional carry + v.l4 = v.l4 & maskLow51Bits + + return v +} + +// Add sets v = a + b, and returns v. +func (v *Element) Add(a, b *Element) *Element { + v.l0 = a.l0 + b.l0 + v.l1 = a.l1 + b.l1 + v.l2 = a.l2 + b.l2 + v.l3 = a.l3 + b.l3 + v.l4 = a.l4 + b.l4 + // Using the generic implementation here is actually faster than the + // assembly. Probably because the body of this function is so simple that + // the compiler can figure out better optimizations by inlining the carry + // propagation. TODO + return v.carryPropagateGeneric() +} + +// Subtract sets v = a - b, and returns v. +func (v *Element) Subtract(a, b *Element) *Element { + // We first add 2 * p, to guarantee the subtraction won't underflow, and + // then subtract b (which can be up to 2^255 + 2^13 * 19). + v.l0 = (a.l0 + 0xFFFFFFFFFFFDA) - b.l0 + v.l1 = (a.l1 + 0xFFFFFFFFFFFFE) - b.l1 + v.l2 = (a.l2 + 0xFFFFFFFFFFFFE) - b.l2 + v.l3 = (a.l3 + 0xFFFFFFFFFFFFE) - b.l3 + v.l4 = (a.l4 + 0xFFFFFFFFFFFFE) - b.l4 + return v.carryPropagate() +} + +// Negate sets v = -a, and returns v. +func (v *Element) Negate(a *Element) *Element { + return v.Subtract(feZero, a) +} + +// Invert sets v = 1/z mod p, and returns v. +// +// If z == 0, Invert returns v = 0. +func (v *Element) Invert(z *Element) *Element { + // Inversion is implemented as exponentiation with exponent p − 2. It uses the + // same sequence of 255 squarings and 11 multiplications as [Curve25519]. + var z2, z9, z11, z2_5_0, z2_10_0, z2_20_0, z2_50_0, z2_100_0, t Element + + z2.Square(z) // 2 + t.Square(&z2) // 4 + t.Square(&t) // 8 + z9.Multiply(&t, z) // 9 + z11.Multiply(&z9, &z2) // 11 + t.Square(&z11) // 22 + z2_5_0.Multiply(&t, &z9) // 31 = 2^5 - 2^0 + + t.Square(&z2_5_0) // 2^6 - 2^1 + for i := 0; i < 4; i++ { + t.Square(&t) // 2^10 - 2^5 + } + z2_10_0.Multiply(&t, &z2_5_0) // 2^10 - 2^0 + + t.Square(&z2_10_0) // 2^11 - 2^1 + for i := 0; i < 9; i++ { + t.Square(&t) // 2^20 - 2^10 + } + z2_20_0.Multiply(&t, &z2_10_0) // 2^20 - 2^0 + + t.Square(&z2_20_0) // 2^21 - 2^1 + for i := 0; i < 19; i++ { + t.Square(&t) // 2^40 - 2^20 + } + t.Multiply(&t, &z2_20_0) // 2^40 - 2^0 + + t.Square(&t) // 2^41 - 2^1 + for i := 0; i < 9; i++ { + t.Square(&t) // 2^50 - 2^10 + } + z2_50_0.Multiply(&t, &z2_10_0) // 2^50 - 2^0 + + t.Square(&z2_50_0) // 2^51 - 2^1 + for i := 0; i < 49; i++ { + t.Square(&t) // 2^100 - 2^50 + } + z2_100_0.Multiply(&t, &z2_50_0) // 2^100 - 2^0 + + t.Square(&z2_100_0) // 2^101 - 2^1 + for i := 0; i < 99; i++ { + t.Square(&t) // 2^200 - 2^100 + } + t.Multiply(&t, &z2_100_0) // 2^200 - 2^0 + + t.Square(&t) // 2^201 - 2^1 + for i := 0; i < 49; i++ { + t.Square(&t) // 2^250 - 2^50 + } + t.Multiply(&t, &z2_50_0) // 2^250 - 2^0 + + t.Square(&t) // 2^251 - 2^1 + t.Square(&t) // 2^252 - 2^2 + t.Square(&t) // 2^253 - 2^3 + t.Square(&t) // 2^254 - 2^4 + t.Square(&t) // 2^255 - 2^5 + + return v.Multiply(&t, &z11) // 2^255 - 21 +} + +// Set sets v = a, and returns v. +func (v *Element) Set(a *Element) *Element { + *v = *a + return v +} + +// SetBytes sets v to x, which must be a 32-byte little-endian encoding. +// +// Consistent with RFC 7748, the most significant bit (the high bit of the +// last byte) is ignored, and non-canonical values (2^255-19 through 2^255-1) +// are accepted. Note that this is laxer than specified by RFC 8032. +func (v *Element) SetBytes(x []byte) *Element { + if len(x) != 32 { + panic("edwards25519: invalid field element input size") + } + + // Bits 0:51 (bytes 0:8, bits 0:64, shift 0, mask 51). + v.l0 = binary.LittleEndian.Uint64(x[0:8]) + v.l0 &= maskLow51Bits + // Bits 51:102 (bytes 6:14, bits 48:112, shift 3, mask 51). + v.l1 = binary.LittleEndian.Uint64(x[6:14]) >> 3 + v.l1 &= maskLow51Bits + // Bits 102:153 (bytes 12:20, bits 96:160, shift 6, mask 51). + v.l2 = binary.LittleEndian.Uint64(x[12:20]) >> 6 + v.l2 &= maskLow51Bits + // Bits 153:204 (bytes 19:27, bits 152:216, shift 1, mask 51). + v.l3 = binary.LittleEndian.Uint64(x[19:27]) >> 1 + v.l3 &= maskLow51Bits + // Bits 204:251 (bytes 24:32, bits 192:256, shift 12, mask 51). + // Note: not bytes 25:33, shift 4, to avoid overread. + v.l4 = binary.LittleEndian.Uint64(x[24:32]) >> 12 + v.l4 &= maskLow51Bits + + return v +} + +// Bytes returns the canonical 32-byte little-endian encoding of v. +func (v *Element) Bytes() []byte { + // This function is outlined to make the allocations inline in the caller + // rather than happen on the heap. + var out [32]byte + return v.bytes(&out) +} + +func (v *Element) bytes(out *[32]byte) []byte { + t := *v + t.reduce() + + var buf [8]byte + for i, l := range [5]uint64{t.l0, t.l1, t.l2, t.l3, t.l4} { + bitsOffset := i * 51 + binary.LittleEndian.PutUint64(buf[:], l<<uint(bitsOffset%8)) + for i, bb := range buf { + off := bitsOffset/8 + i + if off >= len(out) { + break + } + out[off] |= bb + } + } + + return out[:] +} + +// Equal returns 1 if v and u are equal, and 0 otherwise. +func (v *Element) Equal(u *Element) int { + sa, sv := u.Bytes(), v.Bytes() + return subtle.ConstantTimeCompare(sa, sv) +} + +// mask64Bits returns 0xffffffff if cond is 1, and 0 otherwise. +func mask64Bits(cond int) uint64 { return ^(uint64(cond) - 1) } + +// Select sets v to a if cond == 1, and to b if cond == 0. +func (v *Element) Select(a, b *Element, cond int) *Element { + m := mask64Bits(cond) + v.l0 = (m & a.l0) | (^m & b.l0) + v.l1 = (m & a.l1) | (^m & b.l1) + v.l2 = (m & a.l2) | (^m & b.l2) + v.l3 = (m & a.l3) | (^m & b.l3) + v.l4 = (m & a.l4) | (^m & b.l4) + return v +} + +// Swap swaps v and u if cond == 1 or leaves them unchanged if cond == 0, and returns v. +func (v *Element) Swap(u *Element, cond int) { + m := mask64Bits(cond) + t := m & (v.l0 ^ u.l0) + v.l0 ^= t + u.l0 ^= t + t = m & (v.l1 ^ u.l1) + v.l1 ^= t + u.l1 ^= t + t = m & (v.l2 ^ u.l2) + v.l2 ^= t + u.l2 ^= t + t = m & (v.l3 ^ u.l3) + v.l3 ^= t + u.l3 ^= t + t = m & (v.l4 ^ u.l4) + v.l4 ^= t + u.l4 ^= t +} + +// IsNegative returns 1 if v is negative, and 0 otherwise. +func (v *Element) IsNegative() int { + return int(v.Bytes()[0] & 1) +} + +// Absolute sets v to |u|, and returns v. +func (v *Element) Absolute(u *Element) *Element { + return v.Select(new(Element).Negate(u), u, u.IsNegative()) +} + +// Multiply sets v = x * y, and returns v. +func (v *Element) Multiply(x, y *Element) *Element { + feMul(v, x, y) + return v +} + +// Square sets v = x * x, and returns v. +func (v *Element) Square(x *Element) *Element { + feSquare(v, x) + return v +} + +// Mult32 sets v = x * y, and returns v. +func (v *Element) Mult32(x *Element, y uint32) *Element { + x0lo, x0hi := mul51(x.l0, y) + x1lo, x1hi := mul51(x.l1, y) + x2lo, x2hi := mul51(x.l2, y) + x3lo, x3hi := mul51(x.l3, y) + x4lo, x4hi := mul51(x.l4, y) + v.l0 = x0lo + 19*x4hi // carried over per the reduction identity + v.l1 = x1lo + x0hi + v.l2 = x2lo + x1hi + v.l3 = x3lo + x2hi + v.l4 = x4lo + x3hi + // The hi portions are going to be only 32 bits, plus any previous excess, + // so we can skip the carry propagation. + return v +} + +// mul51 returns lo + hi * 2⁵¹ = a * b. +func mul51(a uint64, b uint32) (lo uint64, hi uint64) { + mh, ml := bits.Mul64(a, uint64(b)) + lo = ml & maskLow51Bits + hi = (mh << 13) | (ml >> 51) + return +} + +// Pow22523 set v = x^((p-5)/8), and returns v. (p-5)/8 is 2^252-3. +func (v *Element) Pow22523(x *Element) *Element { + var t0, t1, t2 Element + + t0.Square(x) // x^2 + t1.Square(&t0) // x^4 + t1.Square(&t1) // x^8 + t1.Multiply(x, &t1) // x^9 + t0.Multiply(&t0, &t1) // x^11 + t0.Square(&t0) // x^22 + t0.Multiply(&t1, &t0) // x^31 + t1.Square(&t0) // x^62 + for i := 1; i < 5; i++ { // x^992 + t1.Square(&t1) + } + t0.Multiply(&t1, &t0) // x^1023 -> 1023 = 2^10 - 1 + t1.Square(&t0) // 2^11 - 2 + for i := 1; i < 10; i++ { // 2^20 - 2^10 + t1.Square(&t1) + } + t1.Multiply(&t1, &t0) // 2^20 - 1 + t2.Square(&t1) // 2^21 - 2 + for i := 1; i < 20; i++ { // 2^40 - 2^20 + t2.Square(&t2) + } + t1.Multiply(&t2, &t1) // 2^40 - 1 + t1.Square(&t1) // 2^41 - 2 + for i := 1; i < 10; i++ { // 2^50 - 2^10 + t1.Square(&t1) + } + t0.Multiply(&t1, &t0) // 2^50 - 1 + t1.Square(&t0) // 2^51 - 2 + for i := 1; i < 50; i++ { // 2^100 - 2^50 + t1.Square(&t1) + } + t1.Multiply(&t1, &t0) // 2^100 - 1 + t2.Square(&t1) // 2^101 - 2 + for i := 1; i < 100; i++ { // 2^200 - 2^100 + t2.Square(&t2) + } + t1.Multiply(&t2, &t1) // 2^200 - 1 + t1.Square(&t1) // 2^201 - 2 + for i := 1; i < 50; i++ { // 2^250 - 2^50 + t1.Square(&t1) + } + t0.Multiply(&t1, &t0) // 2^250 - 1 + t0.Square(&t0) // 2^251 - 2 + t0.Square(&t0) // 2^252 - 4 + return v.Multiply(&t0, x) // 2^252 - 3 -> x^(2^252-3) +} + +// sqrtM1 is 2^((p-1)/4), which squared is equal to -1 by Euler's Criterion. +var sqrtM1 = &Element{1718705420411056, 234908883556509, + 2233514472574048, 2117202627021982, 765476049583133} + +// SqrtRatio sets r to the non-negative square root of the ratio of u and v. +// +// If u/v is square, SqrtRatio returns r and 1. If u/v is not square, SqrtRatio +// sets r according to Section 4.3 of draft-irtf-cfrg-ristretto255-decaf448-00, +// and returns r and 0. +func (r *Element) SqrtRatio(u, v *Element) (rr *Element, wasSquare int) { + var a, b Element + + // r = (u * v3) * (u * v7)^((p-5)/8) + v2 := a.Square(v) + uv3 := b.Multiply(u, b.Multiply(v2, v)) + uv7 := a.Multiply(uv3, a.Square(v2)) + r.Multiply(uv3, r.Pow22523(uv7)) + + check := a.Multiply(v, a.Square(r)) // check = v * r^2 + + uNeg := b.Negate(u) + correctSignSqrt := check.Equal(u) + flippedSignSqrt := check.Equal(uNeg) + flippedSignSqrtI := check.Equal(uNeg.Multiply(uNeg, sqrtM1)) + + rPrime := b.Multiply(r, sqrtM1) // r_prime = SQRT_M1 * r + // r = CT_SELECT(r_prime IF flipped_sign_sqrt | flipped_sign_sqrt_i ELSE r) + r.Select(rPrime, r, flippedSignSqrt|flippedSignSqrtI) + + r.Absolute(r) // Choose the nonnegative square root. + return r, correctSignSqrt | flippedSignSqrt +} diff --git a/vendor/golang.org/x/crypto/curve25519/internal/field/fe_amd64.go b/vendor/golang.org/x/crypto/curve25519/internal/field/fe_amd64.go new file mode 100644 index 00000000..44dc8e8c --- /dev/null +++ b/vendor/golang.org/x/crypto/curve25519/internal/field/fe_amd64.go @@ -0,0 +1,13 @@ +// Code generated by command: go run fe_amd64_asm.go -out ../fe_amd64.s -stubs ../fe_amd64.go -pkg field. DO NOT EDIT. + +// +build amd64,gc,!purego + +package field + +// feMul sets out = a * b. It works like feMulGeneric. +//go:noescape +func feMul(out *Element, a *Element, b *Element) + +// feSquare sets out = a * a. It works like feSquareGeneric. +//go:noescape +func feSquare(out *Element, a *Element) diff --git a/vendor/golang.org/x/crypto/curve25519/internal/field/fe_amd64.s b/vendor/golang.org/x/crypto/curve25519/internal/field/fe_amd64.s new file mode 100644 index 00000000..293f013c --- /dev/null +++ b/vendor/golang.org/x/crypto/curve25519/internal/field/fe_amd64.s @@ -0,0 +1,379 @@ +// Code generated by command: go run fe_amd64_asm.go -out ../fe_amd64.s -stubs ../fe_amd64.go -pkg field. DO NOT EDIT. + +//go:build amd64 && gc && !purego +// +build amd64,gc,!purego + +#include "textflag.h" + +// func feMul(out *Element, a *Element, b *Element) +TEXT ·feMul(SB), NOSPLIT, $0-24 + MOVQ a+8(FP), CX + MOVQ b+16(FP), BX + + // r0 = a0×b0 + MOVQ (CX), AX + MULQ (BX) + MOVQ AX, DI + MOVQ DX, SI + + // r0 += 19×a1×b4 + MOVQ 8(CX), AX + IMUL3Q $0x13, AX, AX + MULQ 32(BX) + ADDQ AX, DI + ADCQ DX, SI + + // r0 += 19×a2×b3 + MOVQ 16(CX), AX + IMUL3Q $0x13, AX, AX + MULQ 24(BX) + ADDQ AX, DI + ADCQ DX, SI + + // r0 += 19×a3×b2 + MOVQ 24(CX), AX + IMUL3Q $0x13, AX, AX + MULQ 16(BX) + ADDQ AX, DI + ADCQ DX, SI + + // r0 += 19×a4×b1 + MOVQ 32(CX), AX + IMUL3Q $0x13, AX, AX + MULQ 8(BX) + ADDQ AX, DI + ADCQ DX, SI + + // r1 = a0×b1 + MOVQ (CX), AX + MULQ 8(BX) + MOVQ AX, R9 + MOVQ DX, R8 + + // r1 += a1×b0 + MOVQ 8(CX), AX + MULQ (BX) + ADDQ AX, R9 + ADCQ DX, R8 + + // r1 += 19×a2×b4 + MOVQ 16(CX), AX + IMUL3Q $0x13, AX, AX + MULQ 32(BX) + ADDQ AX, R9 + ADCQ DX, R8 + + // r1 += 19×a3×b3 + MOVQ 24(CX), AX + IMUL3Q $0x13, AX, AX + MULQ 24(BX) + ADDQ AX, R9 + ADCQ DX, R8 + + // r1 += 19×a4×b2 + MOVQ 32(CX), AX + IMUL3Q $0x13, AX, AX + MULQ 16(BX) + ADDQ AX, R9 + ADCQ DX, R8 + + // r2 = a0×b2 + MOVQ (CX), AX + MULQ 16(BX) + MOVQ AX, R11 + MOVQ DX, R10 + + // r2 += a1×b1 + MOVQ 8(CX), AX + MULQ 8(BX) + ADDQ AX, R11 + ADCQ DX, R10 + + // r2 += a2×b0 + MOVQ 16(CX), AX + MULQ (BX) + ADDQ AX, R11 + ADCQ DX, R10 + + // r2 += 19×a3×b4 + MOVQ 24(CX), AX + IMUL3Q $0x13, AX, AX + MULQ 32(BX) + ADDQ AX, R11 + ADCQ DX, R10 + + // r2 += 19×a4×b3 + MOVQ 32(CX), AX + IMUL3Q $0x13, AX, AX + MULQ 24(BX) + ADDQ AX, R11 + ADCQ DX, R10 + + // r3 = a0×b3 + MOVQ (CX), AX + MULQ 24(BX) + MOVQ AX, R13 + MOVQ DX, R12 + + // r3 += a1×b2 + MOVQ 8(CX), AX + MULQ 16(BX) + ADDQ AX, R13 + ADCQ DX, R12 + + // r3 += a2×b1 + MOVQ 16(CX), AX + MULQ 8(BX) + ADDQ AX, R13 + ADCQ DX, R12 + + // r3 += a3×b0 + MOVQ 24(CX), AX + MULQ (BX) + ADDQ AX, R13 + ADCQ DX, R12 + + // r3 += 19×a4×b4 + MOVQ 32(CX), AX + IMUL3Q $0x13, AX, AX + MULQ 32(BX) + ADDQ AX, R13 + ADCQ DX, R12 + + // r4 = a0×b4 + MOVQ (CX), AX + MULQ 32(BX) + MOVQ AX, R15 + MOVQ DX, R14 + + // r4 += a1×b3 + MOVQ 8(CX), AX + MULQ 24(BX) + ADDQ AX, R15 + ADCQ DX, R14 + + // r4 += a2×b2 + MOVQ 16(CX), AX + MULQ 16(BX) + ADDQ AX, R15 + ADCQ DX, R14 + + // r4 += a3×b1 + MOVQ 24(CX), AX + MULQ 8(BX) + ADDQ AX, R15 + ADCQ DX, R14 + + // r4 += a4×b0 + MOVQ 32(CX), AX + MULQ (BX) + ADDQ AX, R15 + ADCQ DX, R14 + + // First reduction chain + MOVQ $0x0007ffffffffffff, AX + SHLQ $0x0d, DI, SI + SHLQ $0x0d, R9, R8 + SHLQ $0x0d, R11, R10 + SHLQ $0x0d, R13, R12 + SHLQ $0x0d, R15, R14 + ANDQ AX, DI + IMUL3Q $0x13, R14, R14 + ADDQ R14, DI + ANDQ AX, R9 + ADDQ SI, R9 + ANDQ AX, R11 + ADDQ R8, R11 + ANDQ AX, R13 + ADDQ R10, R13 + ANDQ AX, R15 + ADDQ R12, R15 + + // Second reduction chain (carryPropagate) + MOVQ DI, SI + SHRQ $0x33, SI + MOVQ R9, R8 + SHRQ $0x33, R8 + MOVQ R11, R10 + SHRQ $0x33, R10 + MOVQ R13, R12 + SHRQ $0x33, R12 + MOVQ R15, R14 + SHRQ $0x33, R14 + ANDQ AX, DI + IMUL3Q $0x13, R14, R14 + ADDQ R14, DI + ANDQ AX, R9 + ADDQ SI, R9 + ANDQ AX, R11 + ADDQ R8, R11 + ANDQ AX, R13 + ADDQ R10, R13 + ANDQ AX, R15 + ADDQ R12, R15 + + // Store output + MOVQ out+0(FP), AX + MOVQ DI, (AX) + MOVQ R9, 8(AX) + MOVQ R11, 16(AX) + MOVQ R13, 24(AX) + MOVQ R15, 32(AX) + RET + +// func feSquare(out *Element, a *Element) +TEXT ·feSquare(SB), NOSPLIT, $0-16 + MOVQ a+8(FP), CX + + // r0 = l0×l0 + MOVQ (CX), AX + MULQ (CX) + MOVQ AX, SI + MOVQ DX, BX + + // r0 += 38×l1×l4 + MOVQ 8(CX), AX + IMUL3Q $0x26, AX, AX + MULQ 32(CX) + ADDQ AX, SI + ADCQ DX, BX + + // r0 += 38×l2×l3 + MOVQ 16(CX), AX + IMUL3Q $0x26, AX, AX + MULQ 24(CX) + ADDQ AX, SI + ADCQ DX, BX + + // r1 = 2×l0×l1 + MOVQ (CX), AX + SHLQ $0x01, AX + MULQ 8(CX) + MOVQ AX, R8 + MOVQ DX, DI + + // r1 += 38×l2×l4 + MOVQ 16(CX), AX + IMUL3Q $0x26, AX, AX + MULQ 32(CX) + ADDQ AX, R8 + ADCQ DX, DI + + // r1 += 19×l3×l3 + MOVQ 24(CX), AX + IMUL3Q $0x13, AX, AX + MULQ 24(CX) + ADDQ AX, R8 + ADCQ DX, DI + + // r2 = 2×l0×l2 + MOVQ (CX), AX + SHLQ $0x01, AX + MULQ 16(CX) + MOVQ AX, R10 + MOVQ DX, R9 + + // r2 += l1×l1 + MOVQ 8(CX), AX + MULQ 8(CX) + ADDQ AX, R10 + ADCQ DX, R9 + + // r2 += 38×l3×l4 + MOVQ 24(CX), AX + IMUL3Q $0x26, AX, AX + MULQ 32(CX) + ADDQ AX, R10 + ADCQ DX, R9 + + // r3 = 2×l0×l3 + MOVQ (CX), AX + SHLQ $0x01, AX + MULQ 24(CX) + MOVQ AX, R12 + MOVQ DX, R11 + + // r3 += 2×l1×l2 + MOVQ 8(CX), AX + IMUL3Q $0x02, AX, AX + MULQ 16(CX) + ADDQ AX, R12 + ADCQ DX, R11 + + // r3 += 19×l4×l4 + MOVQ 32(CX), AX + IMUL3Q $0x13, AX, AX + MULQ 32(CX) + ADDQ AX, R12 + ADCQ DX, R11 + + // r4 = 2×l0×l4 + MOVQ (CX), AX + SHLQ $0x01, AX + MULQ 32(CX) + MOVQ AX, R14 + MOVQ DX, R13 + + // r4 += 2×l1×l3 + MOVQ 8(CX), AX + IMUL3Q $0x02, AX, AX + MULQ 24(CX) + ADDQ AX, R14 + ADCQ DX, R13 + + // r4 += l2×l2 + MOVQ 16(CX), AX + MULQ 16(CX) + ADDQ AX, R14 + ADCQ DX, R13 + + // First reduction chain + MOVQ $0x0007ffffffffffff, AX + SHLQ $0x0d, SI, BX + SHLQ $0x0d, R8, DI + SHLQ $0x0d, R10, R9 + SHLQ $0x0d, R12, R11 + SHLQ $0x0d, R14, R13 + ANDQ AX, SI + IMUL3Q $0x13, R13, R13 + ADDQ R13, SI + ANDQ AX, R8 + ADDQ BX, R8 + ANDQ AX, R10 + ADDQ DI, R10 + ANDQ AX, R12 + ADDQ R9, R12 + ANDQ AX, R14 + ADDQ R11, R14 + + // Second reduction chain (carryPropagate) + MOVQ SI, BX + SHRQ $0x33, BX + MOVQ R8, DI + SHRQ $0x33, DI + MOVQ R10, R9 + SHRQ $0x33, R9 + MOVQ R12, R11 + SHRQ $0x33, R11 + MOVQ R14, R13 + SHRQ $0x33, R13 + ANDQ AX, SI + IMUL3Q $0x13, R13, R13 + ADDQ R13, SI + ANDQ AX, R8 + ADDQ BX, R8 + ANDQ AX, R10 + ADDQ DI, R10 + ANDQ AX, R12 + ADDQ R9, R12 + ANDQ AX, R14 + ADDQ R11, R14 + + // Store output + MOVQ out+0(FP), AX + MOVQ SI, (AX) + MOVQ R8, 8(AX) + MOVQ R10, 16(AX) + MOVQ R12, 24(AX) + MOVQ R14, 32(AX) + RET diff --git a/vendor/golang.org/x/crypto/curve25519/internal/field/fe_amd64_noasm.go b/vendor/golang.org/x/crypto/curve25519/internal/field/fe_amd64_noasm.go new file mode 100644 index 00000000..ddb6c9b8 --- /dev/null +++ b/vendor/golang.org/x/crypto/curve25519/internal/field/fe_amd64_noasm.go @@ -0,0 +1,12 @@ +// Copyright (c) 2019 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 || !gc || purego +// +build !amd64 !gc purego + +package field + +func feMul(v, x, y *Element) { feMulGeneric(v, x, y) } + +func feSquare(v, x *Element) { feSquareGeneric(v, x) } diff --git a/vendor/golang.org/x/crypto/curve25519/internal/field/fe_arm64.go b/vendor/golang.org/x/crypto/curve25519/internal/field/fe_arm64.go new file mode 100644 index 00000000..af459ef5 --- /dev/null +++ b/vendor/golang.org/x/crypto/curve25519/internal/field/fe_arm64.go @@ -0,0 +1,16 @@ +// Copyright (c) 2020 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 arm64 && gc && !purego +// +build arm64,gc,!purego + +package field + +//go:noescape +func carryPropagate(v *Element) + +func (v *Element) carryPropagate() *Element { + carryPropagate(v) + return v +} diff --git a/vendor/golang.org/x/crypto/curve25519/internal/field/fe_arm64.s b/vendor/golang.org/x/crypto/curve25519/internal/field/fe_arm64.s new file mode 100644 index 00000000..5c91e458 --- /dev/null +++ b/vendor/golang.org/x/crypto/curve25519/internal/field/fe_arm64.s @@ -0,0 +1,43 @@ +// Copyright (c) 2020 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 arm64 && gc && !purego +// +build arm64,gc,!purego + +#include "textflag.h" + +// carryPropagate works exactly like carryPropagateGeneric and uses the +// same AND, ADD, and LSR+MADD instructions emitted by the compiler, but +// avoids loading R0-R4 twice and uses LDP and STP. +// +// See https://golang.org/issues/43145 for the main compiler issue. +// +// func carryPropagate(v *Element) +TEXT ·carryPropagate(SB),NOFRAME|NOSPLIT,$0-8 + MOVD v+0(FP), R20 + + LDP 0(R20), (R0, R1) + LDP 16(R20), (R2, R3) + MOVD 32(R20), R4 + + AND $0x7ffffffffffff, R0, R10 + AND $0x7ffffffffffff, R1, R11 + AND $0x7ffffffffffff, R2, R12 + AND $0x7ffffffffffff, R3, R13 + AND $0x7ffffffffffff, R4, R14 + + ADD R0>>51, R11, R11 + ADD R1>>51, R12, R12 + ADD R2>>51, R13, R13 + ADD R3>>51, R14, R14 + // R4>>51 * 19 + R10 -> R10 + LSR $51, R4, R21 + MOVD $19, R22 + MADD R22, R10, R21, R10 + + STP (R10, R11), 0(R20) + STP (R12, R13), 16(R20) + MOVD R14, 32(R20) + + RET diff --git a/vendor/golang.org/x/crypto/curve25519/internal/field/fe_arm64_noasm.go b/vendor/golang.org/x/crypto/curve25519/internal/field/fe_arm64_noasm.go new file mode 100644 index 00000000..234a5b2e --- /dev/null +++ b/vendor/golang.org/x/crypto/curve25519/internal/field/fe_arm64_noasm.go @@ -0,0 +1,12 @@ +// Copyright (c) 2021 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 !arm64 || !gc || purego +// +build !arm64 !gc purego + +package field + +func (v *Element) carryPropagate() *Element { + return v.carryPropagateGeneric() +} diff --git a/vendor/golang.org/x/crypto/curve25519/internal/field/fe_generic.go b/vendor/golang.org/x/crypto/curve25519/internal/field/fe_generic.go new file mode 100644 index 00000000..7b5b78cb --- /dev/null +++ b/vendor/golang.org/x/crypto/curve25519/internal/field/fe_generic.go @@ -0,0 +1,264 @@ +// Copyright (c) 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. + +package field + +import "math/bits" + +// uint128 holds a 128-bit number as two 64-bit limbs, for use with the +// bits.Mul64 and bits.Add64 intrinsics. +type uint128 struct { + lo, hi uint64 +} + +// mul64 returns a * b. +func mul64(a, b uint64) uint128 { + hi, lo := bits.Mul64(a, b) + return uint128{lo, hi} +} + +// addMul64 returns v + a * b. +func addMul64(v uint128, a, b uint64) uint128 { + hi, lo := bits.Mul64(a, b) + lo, c := bits.Add64(lo, v.lo, 0) + hi, _ = bits.Add64(hi, v.hi, c) + return uint128{lo, hi} +} + +// shiftRightBy51 returns a >> 51. a is assumed to be at most 115 bits. +func shiftRightBy51(a uint128) uint64 { + return (a.hi << (64 - 51)) | (a.lo >> 51) +} + +func feMulGeneric(v, a, b *Element) { + a0 := a.l0 + a1 := a.l1 + a2 := a.l2 + a3 := a.l3 + a4 := a.l4 + + b0 := b.l0 + b1 := b.l1 + b2 := b.l2 + b3 := b.l3 + b4 := b.l4 + + // Limb multiplication works like pen-and-paper columnar multiplication, but + // with 51-bit limbs instead of digits. + // + // a4 a3 a2 a1 a0 x + // b4 b3 b2 b1 b0 = + // ------------------------ + // a4b0 a3b0 a2b0 a1b0 a0b0 + + // a4b1 a3b1 a2b1 a1b1 a0b1 + + // a4b2 a3b2 a2b2 a1b2 a0b2 + + // a4b3 a3b3 a2b3 a1b3 a0b3 + + // a4b4 a3b4 a2b4 a1b4 a0b4 = + // ---------------------------------------------- + // r8 r7 r6 r5 r4 r3 r2 r1 r0 + // + // We can then use the reduction identity (a * 2²⁵⁵ + b = a * 19 + b) to + // reduce the limbs that would overflow 255 bits. r5 * 2²⁵⁵ becomes 19 * r5, + // r6 * 2³⁰⁶ becomes 19 * r6 * 2⁵¹, etc. + // + // Reduction can be carried out simultaneously to multiplication. For + // example, we do not compute r5: whenever the result of a multiplication + // belongs to r5, like a1b4, we multiply it by 19 and add the result to r0. + // + // a4b0 a3b0 a2b0 a1b0 a0b0 + + // a3b1 a2b1 a1b1 a0b1 19×a4b1 + + // a2b2 a1b2 a0b2 19×a4b2 19×a3b2 + + // a1b3 a0b3 19×a4b3 19×a3b3 19×a2b3 + + // a0b4 19×a4b4 19×a3b4 19×a2b4 19×a1b4 = + // -------------------------------------- + // r4 r3 r2 r1 r0 + // + // Finally we add up the columns into wide, overlapping limbs. + + a1_19 := a1 * 19 + a2_19 := a2 * 19 + a3_19 := a3 * 19 + a4_19 := a4 * 19 + + // r0 = a0×b0 + 19×(a1×b4 + a2×b3 + a3×b2 + a4×b1) + r0 := mul64(a0, b0) + r0 = addMul64(r0, a1_19, b4) + r0 = addMul64(r0, a2_19, b3) + r0 = addMul64(r0, a3_19, b2) + r0 = addMul64(r0, a4_19, b1) + + // r1 = a0×b1 + a1×b0 + 19×(a2×b4 + a3×b3 + a4×b2) + r1 := mul64(a0, b1) + r1 = addMul64(r1, a1, b0) + r1 = addMul64(r1, a2_19, b4) + r1 = addMul64(r1, a3_19, b3) + r1 = addMul64(r1, a4_19, b2) + + // r2 = a0×b2 + a1×b1 + a2×b0 + 19×(a3×b4 + a4×b3) + r2 := mul64(a0, b2) + r2 = addMul64(r2, a1, b1) + r2 = addMul64(r2, a2, b0) + r2 = addMul64(r2, a3_19, b4) + r2 = addMul64(r2, a4_19, b3) + + // r3 = a0×b3 + a1×b2 + a2×b1 + a3×b0 + 19×a4×b4 + r3 := mul64(a0, b3) + r3 = addMul64(r3, a1, b2) + r3 = addMul64(r3, a2, b1) + r3 = addMul64(r3, a3, b0) + r3 = addMul64(r3, a4_19, b4) + + // r4 = a0×b4 + a1×b3 + a2×b2 + a3×b1 + a4×b0 + r4 := mul64(a0, b4) + r4 = addMul64(r4, a1, b3) + r4 = addMul64(r4, a2, b2) + r4 = addMul64(r4, a3, b1) + r4 = addMul64(r4, a4, b0) + + // After the multiplication, we need to reduce (carry) the five coefficients + // to obtain a result with limbs that are at most slightly larger than 2⁵¹, + // to respect the Element invariant. + // + // Overall, the reduction works the same as carryPropagate, except with + // wider inputs: we take the carry for each coefficient by shifting it right + // by 51, and add it to the limb above it. The top carry is multiplied by 19 + // according to the reduction identity and added to the lowest limb. + // + // The largest coefficient (r0) will be at most 111 bits, which guarantees + // that all carries are at most 111 - 51 = 60 bits, which fits in a uint64. + // + // r0 = a0×b0 + 19×(a1×b4 + a2×b3 + a3×b2 + a4×b1) + // r0 < 2⁵²×2⁵² + 19×(2⁵²×2⁵² + 2⁵²×2⁵² + 2⁵²×2⁵² + 2⁵²×2⁵²) + // r0 < (1 + 19 × 4) × 2⁵² × 2⁵² + // r0 < 2⁷ × 2⁵² × 2⁵² + // r0 < 2¹¹¹ + // + // Moreover, the top coefficient (r4) is at most 107 bits, so c4 is at most + // 56 bits, and c4 * 19 is at most 61 bits, which again fits in a uint64 and + // allows us to easily apply the reduction identity. + // + // r4 = a0×b4 + a1×b3 + a2×b2 + a3×b1 + a4×b0 + // r4 < 5 × 2⁵² × 2⁵² + // r4 < 2¹⁰⁷ + // + + c0 := shiftRightBy51(r0) + c1 := shiftRightBy51(r1) + c2 := shiftRightBy51(r2) + c3 := shiftRightBy51(r3) + c4 := shiftRightBy51(r4) + + rr0 := r0.lo&maskLow51Bits + c4*19 + rr1 := r1.lo&maskLow51Bits + c0 + rr2 := r2.lo&maskLow51Bits + c1 + rr3 := r3.lo&maskLow51Bits + c2 + rr4 := r4.lo&maskLow51Bits + c3 + + // Now all coefficients fit into 64-bit registers but are still too large to + // be passed around as a Element. We therefore do one last carry chain, + // where the carries will be small enough to fit in the wiggle room above 2⁵¹. + *v = Element{rr0, rr1, rr2, rr3, rr4} + v.carryPropagate() +} + +func feSquareGeneric(v, a *Element) { + l0 := a.l0 + l1 := a.l1 + l2 := a.l2 + l3 := a.l3 + l4 := a.l4 + + // Squaring works precisely like multiplication above, but thanks to its + // symmetry we get to group a few terms together. + // + // l4 l3 l2 l1 l0 x + // l4 l3 l2 l1 l0 = + // ------------------------ + // l4l0 l3l0 l2l0 l1l0 l0l0 + + // l4l1 l3l1 l2l1 l1l1 l0l1 + + // l4l2 l3l2 l2l2 l1l2 l0l2 + + // l4l3 l3l3 l2l3 l1l3 l0l3 + + // l4l4 l3l4 l2l4 l1l4 l0l4 = + // ---------------------------------------------- + // r8 r7 r6 r5 r4 r3 r2 r1 r0 + // + // l4l0 l3l0 l2l0 l1l0 l0l0 + + // l3l1 l2l1 l1l1 l0l1 19×l4l1 + + // l2l2 l1l2 l0l2 19×l4l2 19×l3l2 + + // l1l3 l0l3 19×l4l3 19×l3l3 19×l2l3 + + // l0l4 19×l4l4 19×l3l4 19×l2l4 19×l1l4 = + // -------------------------------------- + // r4 r3 r2 r1 r0 + // + // With precomputed 2×, 19×, and 2×19× terms, we can compute each limb with + // only three Mul64 and four Add64, instead of five and eight. + + l0_2 := l0 * 2 + l1_2 := l1 * 2 + + l1_38 := l1 * 38 + l2_38 := l2 * 38 + l3_38 := l3 * 38 + + l3_19 := l3 * 19 + l4_19 := l4 * 19 + + // r0 = l0×l0 + 19×(l1×l4 + l2×l3 + l3×l2 + l4×l1) = l0×l0 + 19×2×(l1×l4 + l2×l3) + r0 := mul64(l0, l0) + r0 = addMul64(r0, l1_38, l4) + r0 = addMul64(r0, l2_38, l3) + + // r1 = l0×l1 + l1×l0 + 19×(l2×l4 + l3×l3 + l4×l2) = 2×l0×l1 + 19×2×l2×l4 + 19×l3×l3 + r1 := mul64(l0_2, l1) + r1 = addMul64(r1, l2_38, l4) + r1 = addMul64(r1, l3_19, l3) + + // r2 = l0×l2 + l1×l1 + l2×l0 + 19×(l3×l4 + l4×l3) = 2×l0×l2 + l1×l1 + 19×2×l3×l4 + r2 := mul64(l0_2, l2) + r2 = addMul64(r2, l1, l1) + r2 = addMul64(r2, l3_38, l4) + + // r3 = l0×l3 + l1×l2 + l2×l1 + l3×l0 + 19×l4×l4 = 2×l0×l3 + 2×l1×l2 + 19×l4×l4 + r3 := mul64(l0_2, l3) + r3 = addMul64(r3, l1_2, l2) + r3 = addMul64(r3, l4_19, l4) + + // r4 = l0×l4 + l1×l3 + l2×l2 + l3×l1 + l4×l0 = 2×l0×l4 + 2×l1×l3 + l2×l2 + r4 := mul64(l0_2, l4) + r4 = addMul64(r4, l1_2, l3) + r4 = addMul64(r4, l2, l2) + + c0 := shiftRightBy51(r0) + c1 := shiftRightBy51(r1) + c2 := shiftRightBy51(r2) + c3 := shiftRightBy51(r3) + c4 := shiftRightBy51(r4) + + rr0 := r0.lo&maskLow51Bits + c4*19 + rr1 := r1.lo&maskLow51Bits + c0 + rr2 := r2.lo&maskLow51Bits + c1 + rr3 := r3.lo&maskLow51Bits + c2 + rr4 := r4.lo&maskLow51Bits + c3 + + *v = Element{rr0, rr1, rr2, rr3, rr4} + v.carryPropagate() +} + +// carryPropagate brings the limbs below 52 bits by applying the reduction +// identity (a * 2²⁵⁵ + b = a * 19 + b) to the l4 carry. TODO inline +func (v *Element) carryPropagateGeneric() *Element { + c0 := v.l0 >> 51 + c1 := v.l1 >> 51 + c2 := v.l2 >> 51 + c3 := v.l3 >> 51 + c4 := v.l4 >> 51 + + v.l0 = v.l0&maskLow51Bits + c4*19 + v.l1 = v.l1&maskLow51Bits + c0 + v.l2 = v.l2&maskLow51Bits + c1 + v.l3 = v.l3&maskLow51Bits + c2 + v.l4 = v.l4&maskLow51Bits + c3 + + return v +} diff --git a/vendor/golang.org/x/crypto/curve25519/internal/field/sync.checkpoint b/vendor/golang.org/x/crypto/curve25519/internal/field/sync.checkpoint new file mode 100644 index 00000000..e3685f95 --- /dev/null +++ b/vendor/golang.org/x/crypto/curve25519/internal/field/sync.checkpoint @@ -0,0 +1 @@ +b0c49ae9f59d233526f8934262c5bbbe14d4358d diff --git a/vendor/golang.org/x/crypto/curve25519/internal/field/sync.sh b/vendor/golang.org/x/crypto/curve25519/internal/field/sync.sh new file mode 100644 index 00000000..1ba22a8b --- /dev/null +++ b/vendor/golang.org/x/crypto/curve25519/internal/field/sync.sh @@ -0,0 +1,19 @@ +#! /bin/bash +set -euo pipefail + +cd "$(git rev-parse --show-toplevel)" + +STD_PATH=src/crypto/ed25519/internal/edwards25519/field +LOCAL_PATH=curve25519/internal/field +LAST_SYNC_REF=$(cat $LOCAL_PATH/sync.checkpoint) + +git fetch https://go.googlesource.com/go master + +if git diff --quiet $LAST_SYNC_REF:$STD_PATH FETCH_HEAD:$STD_PATH; then + echo "No changes." +else + NEW_REF=$(git rev-parse FETCH_HEAD | tee $LOCAL_PATH/sync.checkpoint) + echo "Applying changes from $LAST_SYNC_REF to $NEW_REF..." + git diff $LAST_SYNC_REF:$STD_PATH FETCH_HEAD:$STD_PATH | \ + git apply -3 --directory=$LOCAL_PATH +fi diff --git a/vendor/golang.org/x/crypto/pbkdf2/pbkdf2.go b/vendor/golang.org/x/crypto/pbkdf2/pbkdf2.go new file mode 100644 index 00000000..593f6530 --- /dev/null +++ b/vendor/golang.org/x/crypto/pbkdf2/pbkdf2.go @@ -0,0 +1,77 @@ +// Copyright 2012 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 pbkdf2 implements the key derivation function PBKDF2 as defined in RFC +2898 / PKCS #5 v2.0. + +A key derivation function is useful when encrypting data based on a password +or any other not-fully-random data. It uses a pseudorandom function to derive +a secure encryption key based on the password. + +While v2.0 of the standard defines only one pseudorandom function to use, +HMAC-SHA1, the drafted v2.1 specification allows use of all five FIPS Approved +Hash Functions SHA-1, SHA-224, SHA-256, SHA-384 and SHA-512 for HMAC. To +choose, you can pass the `New` functions from the different SHA packages to +pbkdf2.Key. +*/ +package pbkdf2 // import "golang.org/x/crypto/pbkdf2" + +import ( + "crypto/hmac" + "hash" +) + +// Key derives a key from the password, salt and iteration count, returning a +// []byte of length keylen that can be used as cryptographic key. The key is +// derived based on the method described as PBKDF2 with the HMAC variant using +// the supplied hash function. +// +// For example, to use a HMAC-SHA-1 based PBKDF2 key derivation function, you +// can get a derived key for e.g. AES-256 (which needs a 32-byte key) by +// doing: +// +// dk := pbkdf2.Key([]byte("some password"), salt, 4096, 32, sha1.New) +// +// Remember to get a good random salt. At least 8 bytes is recommended by the +// RFC. +// +// Using a higher iteration count will increase the cost of an exhaustive +// search but will also make derivation proportionally slower. +func Key(password, salt []byte, iter, keyLen int, h func() hash.Hash) []byte { + prf := hmac.New(h, password) + hashLen := prf.Size() + numBlocks := (keyLen + hashLen - 1) / hashLen + + var buf [4]byte + dk := make([]byte, 0, numBlocks*hashLen) + U := make([]byte, hashLen) + for block := 1; block <= numBlocks; block++ { + // N.B.: || means concatenation, ^ means XOR + // for each block T_i = U_1 ^ U_2 ^ ... ^ U_iter + // U_1 = PRF(password, salt || uint(i)) + prf.Reset() + prf.Write(salt) + buf[0] = byte(block >> 24) + buf[1] = byte(block >> 16) + buf[2] = byte(block >> 8) + buf[3] = byte(block) + prf.Write(buf[:4]) + dk = prf.Sum(dk) + T := dk[len(dk)-hashLen:] + copy(U, T) + + // U_n = PRF(password, U_(n-1)) + for n := 2; n <= iter; n++ { + prf.Reset() + prf.Write(U) + U = U[:0] + U = prf.Sum(U) + for x := range U { + T[x] ^= U[x] + } + } + } + return dk[:keyLen] +} diff --git a/vendor/golang.org/x/crypto/poly1305/sum_amd64.s b/vendor/golang.org/x/crypto/poly1305/sum_amd64.s index 2cb03731..1d74f0f8 100644 --- a/vendor/golang.org/x/crypto/poly1305/sum_amd64.s +++ b/vendor/golang.org/x/crypto/poly1305/sum_amd64.s @@ -2,6 +2,7 @@ // Use of this source code is governed by a BSD-style // license that can be found in the LICENSE file. +//go:build gc && !purego // +build gc,!purego #include "textflag.h" diff --git a/vendor/golang.org/x/crypto/poly1305/sum_ppc64le.s b/vendor/golang.org/x/crypto/poly1305/sum_ppc64le.s index 5cd7494b..58422aad 100644 --- a/vendor/golang.org/x/crypto/poly1305/sum_ppc64le.s +++ b/vendor/golang.org/x/crypto/poly1305/sum_ppc64le.s @@ -2,6 +2,7 @@ // Use of this source code is governed by a BSD-style // license that can be found in the LICENSE file. +//go:build gc && !purego // +build gc,!purego #include "textflag.h" @@ -82,7 +83,7 @@ multiply: BGE loop bytes_between_0_and_15: - CMP $0, R5 + CMP R5, $0 BEQ done MOVD $0, R16 // h0 MOVD $0, R17 // h1 @@ -122,7 +123,7 @@ just1: // Exactly 8 MOVD (R4), R16 - CMP $0, R17 + CMP R17, $0 // Check if we've already set R17; if not // set 1 to indicate end of msg. @@ -151,7 +152,7 @@ less4: ADD $2, R4 less2: - CMP $0, R5 + CMP R5, $0 BEQ insert1 MOVBZ (R4), R21 SLD R22, R21, R21 @@ -166,12 +167,12 @@ insert1: carry: // Add new values to h0, h1, h2 - ADDC R16, R8 - ADDE R17, R9 - ADDE $0, R10 - MOVD $16, R5 - ADD R5, R4 - BR multiply + ADDC R16, R8 + ADDE R17, R9 + ADDZE R10, R10 + MOVD $16, R5 + ADD R5, R4 + BR multiply done: // Save h0, h1, h2 in state diff --git a/vendor/golang.org/x/crypto/poly1305/sum_s390x.s b/vendor/golang.org/x/crypto/poly1305/sum_s390x.s index bdd882c6..69c64f84 100644 --- a/vendor/golang.org/x/crypto/poly1305/sum_s390x.s +++ b/vendor/golang.org/x/crypto/poly1305/sum_s390x.s @@ -2,6 +2,7 @@ // Use of this source code is governed by a BSD-style // license that can be found in the LICENSE file. +//go:build gc && !purego // +build gc,!purego #include "textflag.h" diff --git a/vendor/golang.org/x/crypto/salsa20/salsa/salsa20_amd64.s b/vendor/golang.org/x/crypto/salsa20/salsa/salsa20_amd64.s index f97efc67..c0892772 100644 --- a/vendor/golang.org/x/crypto/salsa20/salsa/salsa20_amd64.s +++ b/vendor/golang.org/x/crypto/salsa20/salsa/salsa20_amd64.s @@ -2,6 +2,7 @@ // Use of this source code is governed by a BSD-style // license that can be found in the LICENSE file. +//go:build amd64 && !purego && gc // +build amd64,!purego,gc // This code was translated into a form compatible with 6a from the public diff --git a/vendor/golang.org/x/crypto/scrypt/scrypt.go b/vendor/golang.org/x/crypto/scrypt/scrypt.go new file mode 100644 index 00000000..bbe4494c --- /dev/null +++ b/vendor/golang.org/x/crypto/scrypt/scrypt.go @@ -0,0 +1,212 @@ +// Copyright 2012 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 scrypt implements the scrypt key derivation function as defined in +// Colin Percival's paper "Stronger Key Derivation via Sequential Memory-Hard +// Functions" (https://www.tarsnap.com/scrypt/scrypt.pdf). +package scrypt // import "golang.org/x/crypto/scrypt" + +import ( + "crypto/sha256" + "encoding/binary" + "errors" + "math/bits" + + "golang.org/x/crypto/pbkdf2" +) + +const maxInt = int(^uint(0) >> 1) + +// blockCopy copies n numbers from src into dst. +func blockCopy(dst, src []uint32, n int) { + copy(dst, src[:n]) +} + +// blockXOR XORs numbers from dst with n numbers from src. +func blockXOR(dst, src []uint32, n int) { + for i, v := range src[:n] { + dst[i] ^= v + } +} + +// salsaXOR applies Salsa20/8 to the XOR of 16 numbers from tmp and in, +// and puts the result into both tmp and out. +func salsaXOR(tmp *[16]uint32, in, out []uint32) { + w0 := tmp[0] ^ in[0] + w1 := tmp[1] ^ in[1] + w2 := tmp[2] ^ in[2] + w3 := tmp[3] ^ in[3] + w4 := tmp[4] ^ in[4] + w5 := tmp[5] ^ in[5] + w6 := tmp[6] ^ in[6] + w7 := tmp[7] ^ in[7] + w8 := tmp[8] ^ in[8] + w9 := tmp[9] ^ in[9] + w10 := tmp[10] ^ in[10] + w11 := tmp[11] ^ in[11] + w12 := tmp[12] ^ in[12] + w13 := tmp[13] ^ in[13] + w14 := tmp[14] ^ in[14] + w15 := tmp[15] ^ in[15] + + x0, x1, x2, x3, x4, x5, x6, x7, x8 := w0, w1, w2, w3, w4, w5, w6, w7, w8 + x9, x10, x11, x12, x13, x14, x15 := w9, w10, w11, w12, w13, w14, w15 + + for i := 0; i < 8; i += 2 { + x4 ^= bits.RotateLeft32(x0+x12, 7) + x8 ^= bits.RotateLeft32(x4+x0, 9) + x12 ^= bits.RotateLeft32(x8+x4, 13) + x0 ^= bits.RotateLeft32(x12+x8, 18) + + x9 ^= bits.RotateLeft32(x5+x1, 7) + x13 ^= bits.RotateLeft32(x9+x5, 9) + x1 ^= bits.RotateLeft32(x13+x9, 13) + x5 ^= bits.RotateLeft32(x1+x13, 18) + + x14 ^= bits.RotateLeft32(x10+x6, 7) + x2 ^= bits.RotateLeft32(x14+x10, 9) + x6 ^= bits.RotateLeft32(x2+x14, 13) + x10 ^= bits.RotateLeft32(x6+x2, 18) + + x3 ^= bits.RotateLeft32(x15+x11, 7) + x7 ^= bits.RotateLeft32(x3+x15, 9) + x11 ^= bits.RotateLeft32(x7+x3, 13) + x15 ^= bits.RotateLeft32(x11+x7, 18) + + x1 ^= bits.RotateLeft32(x0+x3, 7) + x2 ^= bits.RotateLeft32(x1+x0, 9) + x3 ^= bits.RotateLeft32(x2+x1, 13) + x0 ^= bits.RotateLeft32(x3+x2, 18) + + x6 ^= bits.RotateLeft32(x5+x4, 7) + x7 ^= bits.RotateLeft32(x6+x5, 9) + x4 ^= bits.RotateLeft32(x7+x6, 13) + x5 ^= bits.RotateLeft32(x4+x7, 18) + + x11 ^= bits.RotateLeft32(x10+x9, 7) + x8 ^= bits.RotateLeft32(x11+x10, 9) + x9 ^= bits.RotateLeft32(x8+x11, 13) + x10 ^= bits.RotateLeft32(x9+x8, 18) + + x12 ^= bits.RotateLeft32(x15+x14, 7) + x13 ^= bits.RotateLeft32(x12+x15, 9) + x14 ^= bits.RotateLeft32(x13+x12, 13) + x15 ^= bits.RotateLeft32(x14+x13, 18) + } + x0 += w0 + x1 += w1 + x2 += w2 + x3 += w3 + x4 += w4 + x5 += w5 + x6 += w6 + x7 += w7 + x8 += w8 + x9 += w9 + x10 += w10 + x11 += w11 + x12 += w12 + x13 += w13 + x14 += w14 + x15 += w15 + + out[0], tmp[0] = x0, x0 + out[1], tmp[1] = x1, x1 + out[2], tmp[2] = x2, x2 + out[3], tmp[3] = x3, x3 + out[4], tmp[4] = x4, x4 + out[5], tmp[5] = x5, x5 + out[6], tmp[6] = x6, x6 + out[7], tmp[7] = x7, x7 + out[8], tmp[8] = x8, x8 + out[9], tmp[9] = x9, x9 + out[10], tmp[10] = x10, x10 + out[11], tmp[11] = x11, x11 + out[12], tmp[12] = x12, x12 + out[13], tmp[13] = x13, x13 + out[14], tmp[14] = x14, x14 + out[15], tmp[15] = x15, x15 +} + +func blockMix(tmp *[16]uint32, in, out []uint32, r int) { + blockCopy(tmp[:], in[(2*r-1)*16:], 16) + for i := 0; i < 2*r; i += 2 { + salsaXOR(tmp, in[i*16:], out[i*8:]) + salsaXOR(tmp, in[i*16+16:], out[i*8+r*16:]) + } +} + +func integer(b []uint32, r int) uint64 { + j := (2*r - 1) * 16 + return uint64(b[j]) | uint64(b[j+1])<<32 +} + +func smix(b []byte, r, N int, v, xy []uint32) { + var tmp [16]uint32 + R := 32 * r + x := xy + y := xy[R:] + + j := 0 + for i := 0; i < R; i++ { + x[i] = binary.LittleEndian.Uint32(b[j:]) + j += 4 + } + for i := 0; i < N; i += 2 { + blockCopy(v[i*R:], x, R) + blockMix(&tmp, x, y, r) + + blockCopy(v[(i+1)*R:], y, R) + blockMix(&tmp, y, x, r) + } + for i := 0; i < N; i += 2 { + j := int(integer(x, r) & uint64(N-1)) + blockXOR(x, v[j*R:], R) + blockMix(&tmp, x, y, r) + + j = int(integer(y, r) & uint64(N-1)) + blockXOR(y, v[j*R:], R) + blockMix(&tmp, y, x, r) + } + j = 0 + for _, v := range x[:R] { + binary.LittleEndian.PutUint32(b[j:], v) + j += 4 + } +} + +// Key derives a key from the password, salt, and cost parameters, returning +// a byte slice of length keyLen that can be used as cryptographic key. +// +// N is a CPU/memory cost parameter, which must be a power of two greater than 1. +// r and p must satisfy r * p < 2³⁰. If the parameters do not satisfy the +// limits, the function returns a nil byte slice and an error. +// +// For example, you can get a derived key for e.g. AES-256 (which needs a +// 32-byte key) by doing: +// +// dk, err := scrypt.Key([]byte("some password"), salt, 32768, 8, 1, 32) +// +// The recommended parameters for interactive logins as of 2017 are N=32768, r=8 +// and p=1. The parameters N, r, and p should be increased as memory latency and +// CPU parallelism increases; consider setting N to the highest power of 2 you +// can derive within 100 milliseconds. Remember to get a good random salt. +func Key(password, salt []byte, N, r, p, keyLen int) ([]byte, error) { + if N <= 1 || N&(N-1) != 0 { + return nil, errors.New("scrypt: N must be > 1 and a power of 2") + } + if uint64(r)*uint64(p) >= 1<<30 || r > maxInt/128/p || r > maxInt/256 || N > maxInt/128/r { + return nil, errors.New("scrypt: parameters are too large") + } + + xy := make([]uint32, 64*r) + v := make([]uint32, 32*N*r) + b := pbkdf2.Key(password, salt, 1, p*128*r, sha256.New) + + for i := 0; i < p; i++ { + smix(b[i*128*r:], r, N, v, xy) + } + + return pbkdf2.Key(password, b, 1, keyLen, sha256.New), nil +} diff --git a/vendor/golang.org/x/crypto/ssh/client.go b/vendor/golang.org/x/crypto/ssh/client.go index 7b00bff1..99f68bd3 100644 --- a/vendor/golang.org/x/crypto/ssh/client.go +++ b/vendor/golang.org/x/crypto/ssh/client.go @@ -77,7 +77,7 @@ func NewClientConn(c net.Conn, addr string, config *ClientConfig) (Conn, <-chan } conn := &connection{ - sshConn: sshConn{conn: c}, + sshConn: sshConn{conn: c, user: fullConf.User}, } if err := conn.clientHandshake(addr, &fullConf); err != nil { diff --git a/vendor/golang.org/x/net/html/parse.go b/vendor/golang.org/x/net/html/parse.go index f91466f7..038941d7 100644 --- a/vendor/golang.org/x/net/html/parse.go +++ b/vendor/golang.org/x/net/html/parse.go @@ -663,6 +663,24 @@ func inHeadIM(p *parser) bool { // Ignore the token. return true case a.Template: + // TODO: remove this divergence from the HTML5 spec. + // + // We don't handle all of the corner cases when mixing foreign + // content (i.e. <math> or <svg>) with <template>. Without this + // early return, we can get into an infinite loop, possibly because + // of the "TODO... further divergence" a little below. + // + // As a workaround, if we are mixing foreign content and templates, + // just ignore the rest of the HTML. Foreign content is rare and a + // relatively old HTML feature. Templates are also rare and a + // relatively new HTML feature. Their combination is very rare. + for _, e := range p.oe { + if e.Namespace != "" { + p.im = ignoreTheRemainingTokens + return true + } + } + p.addElement() p.afe = append(p.afe, &scopeMarker) p.framesetOK = false @@ -683,7 +701,7 @@ func inHeadIM(p *parser) bool { if !p.oe.contains(a.Template) { return true } - // TODO: remove this divergence from the HTML5 spec. + // TODO: remove this further divergence from the HTML5 spec. // // See https://bugs.chromium.org/p/chromium/issues/detail?id=829668 p.generateImpliedEndTags() @@ -2127,6 +2145,10 @@ func afterAfterFramesetIM(p *parser) bool { return true } +func ignoreTheRemainingTokens(p *parser) bool { + return true +} + const whitespaceOrNUL = whitespace + "\x00" // Section 12.2.6.5 diff --git a/vendor/golang.org/x/net/http/httpguts/httplex.go b/vendor/golang.org/x/net/http/httpguts/httplex.go index e7de24ee..c79aa73f 100644 --- a/vendor/golang.org/x/net/http/httpguts/httplex.go +++ b/vendor/golang.org/x/net/http/httpguts/httplex.go @@ -137,11 +137,13 @@ func trimOWS(x string) string { // contains token amongst its comma-separated tokens, ASCII // case-insensitively. func headerValueContainsToken(v string, token string) bool { - v = trimOWS(v) - if comma := strings.IndexByte(v, ','); comma != -1 { - return tokenEqual(trimOWS(v[:comma]), token) || headerValueContainsToken(v[comma+1:], token) + for comma := strings.IndexByte(v, ','); comma != -1; comma = strings.IndexByte(v, ',') { + if tokenEqual(trimOWS(v[:comma]), token) { + return true + } + v = v[comma+1:] } - return tokenEqual(v, token) + return tokenEqual(trimOWS(v), token) } // lowerASCII returns the ASCII lowercase version of b. diff --git a/vendor/golang.org/x/net/http2/Dockerfile b/vendor/golang.org/x/net/http2/Dockerfile index 53fc5257..85122459 100644 --- a/vendor/golang.org/x/net/http2/Dockerfile +++ b/vendor/golang.org/x/net/http2/Dockerfile @@ -38,7 +38,7 @@ RUN make RUN make install WORKDIR /root -RUN wget http://curl.haxx.se/download/curl-7.45.0.tar.gz +RUN wget https://curl.se/download/curl-7.45.0.tar.gz RUN tar -zxvf curl-7.45.0.tar.gz WORKDIR /root/curl-7.45.0 RUN ./configure --with-ssl --with-nghttp2=/usr/local diff --git a/vendor/golang.org/x/net/http2/ascii.go b/vendor/golang.org/x/net/http2/ascii.go new file mode 100644 index 00000000..17caa205 --- /dev/null +++ b/vendor/golang.org/x/net/http2/ascii.go @@ -0,0 +1,53 @@ +// Copyright 2021 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 http2 + +import "strings" + +// The HTTP protocols are defined in terms of ASCII, not Unicode. This file +// contains helper functions which may use Unicode-aware functions which would +// otherwise be unsafe and could introduce vulnerabilities if used improperly. + +// asciiEqualFold is strings.EqualFold, ASCII only. It reports whether s and t +// are equal, ASCII-case-insensitively. +func asciiEqualFold(s, t string) bool { + if len(s) != len(t) { + return false + } + for i := 0; i < len(s); i++ { + if lower(s[i]) != lower(t[i]) { + return false + } + } + return true +} + +// lower returns the ASCII lowercase version of b. +func lower(b byte) byte { + if 'A' <= b && b <= 'Z' { + return b + ('a' - 'A') + } + return b +} + +// isASCIIPrint returns whether s is ASCII and printable according to +// https://tools.ietf.org/html/rfc20#section-4.2. +func isASCIIPrint(s string) bool { + for i := 0; i < len(s); i++ { + if s[i] < ' ' || s[i] > '~' { + return false + } + } + return true +} + +// asciiToLower returns the lowercase version of s if s is ASCII and printable, +// and whether or not it was. +func asciiToLower(s string) (lower string, ok bool) { + if !isASCIIPrint(s) { + return "", false + } + return strings.ToLower(s), true +} diff --git a/vendor/golang.org/x/net/http2/client_conn_pool.go b/vendor/golang.org/x/net/http2/client_conn_pool.go index 3a67636f..652bc11a 100644 --- a/vendor/golang.org/x/net/http2/client_conn_pool.go +++ b/vendor/golang.org/x/net/http2/client_conn_pool.go @@ -7,7 +7,9 @@ package http2 import ( + "context" "crypto/tls" + "errors" "net/http" "sync" ) @@ -78,61 +80,69 @@ func (p *clientConnPool) getClientConn(req *http.Request, addr string, dialOnMis // It gets its own connection. traceGetConn(req, addr) const singleUse = true - cc, err := p.t.dialClientConn(addr, singleUse) + cc, err := p.t.dialClientConn(req.Context(), addr, singleUse) if err != nil { return nil, err } return cc, nil } - p.mu.Lock() - for _, cc := range p.conns[addr] { - if st := cc.idleState(); st.canTakeNewRequest { - if p.shouldTraceGetConn(st) { - traceGetConn(req, addr) + for { + p.mu.Lock() + for _, cc := range p.conns[addr] { + if st := cc.idleState(); st.canTakeNewRequest { + if p.shouldTraceGetConn(st) { + traceGetConn(req, addr) + } + p.mu.Unlock() + return cc, nil } + } + if !dialOnMiss { p.mu.Unlock() - return cc, nil + return nil, ErrNoCachedConn } - } - if !dialOnMiss { + traceGetConn(req, addr) + call := p.getStartDialLocked(req.Context(), addr) p.mu.Unlock() - return nil, ErrNoCachedConn + <-call.done + if shouldRetryDial(call, req) { + continue + } + return call.res, call.err } - traceGetConn(req, addr) - call := p.getStartDialLocked(addr) - p.mu.Unlock() - <-call.done - return call.res, call.err } // dialCall is an in-flight Transport dial call to a host. type dialCall struct { - _ incomparable - p *clientConnPool + _ incomparable + p *clientConnPool + // the context associated with the request + // that created this dialCall + ctx context.Context done chan struct{} // closed when done res *ClientConn // valid after done is closed err error // valid after done is closed } // requires p.mu is held. -func (p *clientConnPool) getStartDialLocked(addr string) *dialCall { +func (p *clientConnPool) getStartDialLocked(ctx context.Context, addr string) *dialCall { if call, ok := p.dialing[addr]; ok { // A dial is already in-flight. Don't start another. return call } - call := &dialCall{p: p, done: make(chan struct{})} + call := &dialCall{p: p, done: make(chan struct{}), ctx: ctx} if p.dialing == nil { p.dialing = make(map[string]*dialCall) } p.dialing[addr] = call - go call.dial(addr) + go call.dial(call.ctx, addr) return call } // run in its own goroutine. -func (c *dialCall) dial(addr string) { +func (c *dialCall) dial(ctx context.Context, addr string) { const singleUse = false // shared conn - c.res, c.err = c.p.t.dialClientConn(addr, singleUse) + c.res, c.err = c.p.t.dialClientConn(ctx, addr, singleUse) close(c.done) c.p.mu.Lock() @@ -276,3 +286,28 @@ type noDialClientConnPool struct{ *clientConnPool } func (p noDialClientConnPool) GetClientConn(req *http.Request, addr string) (*ClientConn, error) { return p.getClientConn(req, addr, noDialOnMiss) } + +// shouldRetryDial reports whether the current request should +// retry dialing after the call finished unsuccessfully, for example +// if the dial was canceled because of a context cancellation or +// deadline expiry. +func shouldRetryDial(call *dialCall, req *http.Request) bool { + if call.err == nil { + // No error, no need to retry + return false + } + if call.ctx == req.Context() { + // If the call has the same context as the request, the dial + // should not be retried, since any cancellation will have come + // from this request. + return false + } + if !errors.Is(call.err, context.Canceled) && !errors.Is(call.err, context.DeadlineExceeded) { + // If the call error is not because of a context cancellation or a deadline expiry, + // the dial should not be retried. + return false + } + // Only retry if the error is a context cancellation error or deadline expiry + // and the context associated with the call was canceled or expired. + return call.ctx.Err() != nil +} diff --git a/vendor/golang.org/x/net/http2/go115.go b/vendor/golang.org/x/net/http2/go115.go new file mode 100644 index 00000000..908af1ab --- /dev/null +++ b/vendor/golang.org/x/net/http2/go115.go @@ -0,0 +1,27 @@ +// Copyright 2021 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 go1.15 +// +build go1.15 + +package http2 + +import ( + "context" + "crypto/tls" +) + +// dialTLSWithContext uses tls.Dialer, added in Go 1.15, to open a TLS +// connection. +func (t *Transport) dialTLSWithContext(ctx context.Context, network, addr string, cfg *tls.Config) (*tls.Conn, error) { + dialer := &tls.Dialer{ + Config: cfg, + } + cn, err := dialer.DialContext(ctx, network, addr) + if err != nil { + return nil, err + } + tlsCn := cn.(*tls.Conn) // DialContext comment promises this will always succeed + return tlsCn, nil +} diff --git a/vendor/golang.org/x/net/http2/headermap.go b/vendor/golang.org/x/net/http2/headermap.go index c3ff3fa1..9e12941d 100644 --- a/vendor/golang.org/x/net/http2/headermap.go +++ b/vendor/golang.org/x/net/http2/headermap.go @@ -6,7 +6,6 @@ package http2 import ( "net/http" - "strings" "sync" ) @@ -79,10 +78,10 @@ func buildCommonHeaderMaps() { } } -func lowerHeader(v string) string { +func lowerHeader(v string) (lower string, ascii bool) { buildCommonHeaderMapsOnce() if s, ok := commonLowerHeader[v]; ok { - return s + return s, true } - return strings.ToLower(v) + return asciiToLower(v) } diff --git a/vendor/golang.org/x/net/http2/not_go115.go b/vendor/golang.org/x/net/http2/not_go115.go new file mode 100644 index 00000000..e6c04cf7 --- /dev/null +++ b/vendor/golang.org/x/net/http2/not_go115.go @@ -0,0 +1,31 @@ +// Copyright 2021 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 !go1.15 +// +build !go1.15 + +package http2 + +import ( + "context" + "crypto/tls" +) + +// dialTLSWithContext opens a TLS connection. +func (t *Transport) dialTLSWithContext(ctx context.Context, network, addr string, cfg *tls.Config) (*tls.Conn, error) { + cn, err := tls.Dial(network, addr, cfg) + if err != nil { + return nil, err + } + if err := cn.Handshake(); err != nil { + return nil, err + } + if cfg.InsecureSkipVerify { + return cn, nil + } + if err := cn.VerifyHostname(cfg.ServerName); err != nil { + return nil, err + } + return cn, nil +} diff --git a/vendor/golang.org/x/net/http2/server.go b/vendor/golang.org/x/net/http2/server.go index e125bbd2..0ccbe9b4 100644 --- a/vendor/golang.org/x/net/http2/server.go +++ b/vendor/golang.org/x/net/http2/server.go @@ -231,13 +231,12 @@ func ConfigureServer(s *http.Server, conf *Server) error { if s.TLSConfig == nil { s.TLSConfig = new(tls.Config) - } else if s.TLSConfig.CipherSuites != nil { - // If they already provided a CipherSuite list, return - // an error if it has a bad order or is missing - // ECDHE_RSA_WITH_AES_128_GCM_SHA256 or ECDHE_ECDSA_WITH_AES_128_GCM_SHA256. + } else if s.TLSConfig.CipherSuites != nil && s.TLSConfig.MinVersion < tls.VersionTLS13 { + // If they already provided a TLS 1.0–1.2 CipherSuite list, return an + // error if it is missing ECDHE_RSA_WITH_AES_128_GCM_SHA256 or + // ECDHE_ECDSA_WITH_AES_128_GCM_SHA256. haveRequired := false - sawBad := false - for i, cs := range s.TLSConfig.CipherSuites { + for _, cs := range s.TLSConfig.CipherSuites { switch cs { case tls.TLS_ECDHE_RSA_WITH_AES_128_GCM_SHA256, // Alternative MTI cipher to not discourage ECDSA-only servers. @@ -245,14 +244,9 @@ func ConfigureServer(s *http.Server, conf *Server) error { tls.TLS_ECDHE_ECDSA_WITH_AES_128_GCM_SHA256: haveRequired = true } - if isBadCipher(cs) { - sawBad = true - } else if sawBad { - return fmt.Errorf("http2: TLSConfig.CipherSuites index %d contains an HTTP/2-approved cipher suite (%#04x), but it comes after unapproved cipher suites. With this configuration, clients that don't support previous, approved cipher suites may be given an unapproved one and reject the connection.", i, cs) - } } if !haveRequired { - return fmt.Errorf("http2: TLSConfig.CipherSuites is missing an HTTP/2-required AES_128_GCM_SHA256 cipher (need at least one of TLS_ECDHE_RSA_WITH_AES_128_GCM_SHA256 or TLS_ECDHE_ECDSA_WITH_AES_128_GCM_SHA256).") + return fmt.Errorf("http2: TLSConfig.CipherSuites is missing an HTTP/2-required AES_128_GCM_SHA256 cipher (need at least one of TLS_ECDHE_RSA_WITH_AES_128_GCM_SHA256 or TLS_ECDHE_ECDSA_WITH_AES_128_GCM_SHA256)") } } @@ -265,16 +259,12 @@ func ConfigureServer(s *http.Server, conf *Server) error { s.TLSConfig.PreferServerCipherSuites = true - haveNPN := false - for _, p := range s.TLSConfig.NextProtos { - if p == NextProtoTLS { - haveNPN = true - break - } - } - if !haveNPN { + if !strSliceContains(s.TLSConfig.NextProtos, NextProtoTLS) { s.TLSConfig.NextProtos = append(s.TLSConfig.NextProtos, NextProtoTLS) } + if !strSliceContains(s.TLSConfig.NextProtos, "http/1.1") { + s.TLSConfig.NextProtos = append(s.TLSConfig.NextProtos, "http/1.1") + } if s.TLSNextProto == nil { s.TLSNextProto = map[string]func(*http.Server, *tls.Conn, http.Handler){} @@ -2789,8 +2779,12 @@ func (w *responseWriter) Push(target string, opts *http.PushOptions) error { // but PUSH_PROMISE requests cannot have a body. // http://tools.ietf.org/html/rfc7540#section-8.2 // Also disallow Host, since the promised URL must be absolute. - switch strings.ToLower(k) { - case "content-length", "content-encoding", "trailer", "te", "expect", "host": + if asciiEqualFold(k, "content-length") || + asciiEqualFold(k, "content-encoding") || + asciiEqualFold(k, "trailer") || + asciiEqualFold(k, "te") || + asciiEqualFold(k, "expect") || + asciiEqualFold(k, "host") { return fmt.Errorf("promised request headers cannot include %q", k) } } diff --git a/vendor/golang.org/x/net/http2/transport.go b/vendor/golang.org/x/net/http2/transport.go index 7688d72c..b97adff7 100644 --- a/vendor/golang.org/x/net/http2/transport.go +++ b/vendor/golang.org/x/net/http2/transport.go @@ -264,9 +264,8 @@ type ClientConn struct { peerMaxHeaderListSize uint64 initialWindowSize uint32 - hbuf bytes.Buffer // HPACK encoder writes into this - henc *hpack.Encoder - freeBuf [][]byte + hbuf bytes.Buffer // HPACK encoder writes into this + henc *hpack.Encoder wmu sync.Mutex // held while writing; acquire AFTER mu if holding both werr error // first write error that has occurred @@ -564,12 +563,12 @@ func canRetryError(err error) bool { return false } -func (t *Transport) dialClientConn(addr string, singleUse bool) (*ClientConn, error) { +func (t *Transport) dialClientConn(ctx context.Context, addr string, singleUse bool) (*ClientConn, error) { host, _, err := net.SplitHostPort(addr) if err != nil { return nil, err } - tconn, err := t.dialTLS()("tcp", addr, t.newTLSConfig(host)) + tconn, err := t.dialTLS(ctx)("tcp", addr, t.newTLSConfig(host)) if err != nil { return nil, err } @@ -590,34 +589,24 @@ func (t *Transport) newTLSConfig(host string) *tls.Config { return cfg } -func (t *Transport) dialTLS() func(string, string, *tls.Config) (net.Conn, error) { +func (t *Transport) dialTLS(ctx context.Context) func(string, string, *tls.Config) (net.Conn, error) { if t.DialTLS != nil { return t.DialTLS } - return t.dialTLSDefault -} - -func (t *Transport) dialTLSDefault(network, addr string, cfg *tls.Config) (net.Conn, error) { - cn, err := tls.Dial(network, addr, cfg) - if err != nil { - return nil, err - } - if err := cn.Handshake(); err != nil { - return nil, err - } - if !cfg.InsecureSkipVerify { - if err := cn.VerifyHostname(cfg.ServerName); err != nil { + return func(network, addr string, cfg *tls.Config) (net.Conn, error) { + tlsCn, err := t.dialTLSWithContext(ctx, network, addr, cfg) + if err != nil { return nil, err } + state := tlsCn.ConnectionState() + if p := state.NegotiatedProtocol; p != NextProtoTLS { + return nil, fmt.Errorf("http2: unexpected ALPN protocol %q; want %q", p, NextProtoTLS) + } + if !state.NegotiatedProtocolIsMutual { + return nil, errors.New("http2: could not negotiate protocol mutually") + } + return tlsCn, nil } - state := cn.ConnectionState() - if p := state.NegotiatedProtocol; p != NextProtoTLS { - return nil, fmt.Errorf("http2: unexpected ALPN protocol %q; want %q", p, NextProtoTLS) - } - if !state.NegotiatedProtocolIsMutual { - return nil, errors.New("http2: could not negotiate protocol mutually") - } - return cn, nil } // disableKeepAlives reports whether connections should be closed as @@ -923,46 +912,6 @@ func (cc *ClientConn) closeForLostPing() error { return cc.closeForError(err) } -const maxAllocFrameSize = 512 << 10 - -// frameBuffer returns a scratch buffer suitable for writing DATA frames. -// They're capped at the min of the peer's max frame size or 512KB -// (kinda arbitrarily), but definitely capped so we don't allocate 4GB -// bufers. -func (cc *ClientConn) frameScratchBuffer() []byte { - cc.mu.Lock() - size := cc.maxFrameSize - if size > maxAllocFrameSize { - size = maxAllocFrameSize - } - for i, buf := range cc.freeBuf { - if len(buf) >= int(size) { - cc.freeBuf[i] = nil - cc.mu.Unlock() - return buf[:size] - } - } - cc.mu.Unlock() - return make([]byte, size) -} - -func (cc *ClientConn) putFrameScratchBuffer(buf []byte) { - cc.mu.Lock() - defer cc.mu.Unlock() - const maxBufs = 4 // arbitrary; 4 concurrent requests per conn? investigate. - if len(cc.freeBuf) < maxBufs { - cc.freeBuf = append(cc.freeBuf, buf) - return - } - for i, old := range cc.freeBuf { - if old == nil { - cc.freeBuf[i] = buf - return - } - } - // forget about it. -} - // errRequestCanceled is a copy of net/http's errRequestCanceled because it's not // exported. At least they'll be DeepEqual for h1-vs-h2 comparisons tests. var errRequestCanceled = errors.New("net/http: request canceled") @@ -1005,7 +954,7 @@ func checkConnHeaders(req *http.Request) error { if vv := req.Header["Transfer-Encoding"]; len(vv) > 0 && (len(vv) > 1 || vv[0] != "" && vv[0] != "chunked") { return fmt.Errorf("http2: invalid Transfer-Encoding request header: %q", vv) } - if vv := req.Header["Connection"]; len(vv) > 0 && (len(vv) > 1 || vv[0] != "" && !strings.EqualFold(vv[0], "close") && !strings.EqualFold(vv[0], "keep-alive")) { + if vv := req.Header["Connection"]; len(vv) > 0 && (len(vv) > 1 || vv[0] != "" && !asciiEqualFold(vv[0], "close") && !asciiEqualFold(vv[0], "keep-alive")) { return fmt.Errorf("http2: invalid Connection request header: %q", vv) } return nil @@ -1305,11 +1254,35 @@ var ( errReqBodyTooLong = errors.New("http2: request body larger than specified content length") ) +// frameScratchBufferLen returns the length of a buffer to use for +// outgoing request bodies to read/write to/from. +// +// It returns max(1, min(peer's advertised max frame size, +// Request.ContentLength+1, 512KB)). +func (cs *clientStream) frameScratchBufferLen(maxFrameSize int) int { + const max = 512 << 10 + n := int64(maxFrameSize) + if n > max { + n = max + } + if cl := actualContentLength(cs.req); cl != -1 && cl+1 < n { + // Add an extra byte past the declared content-length to + // give the caller's Request.Body io.Reader a chance to + // give us more bytes than they declared, so we can catch it + // early. + n = cl + 1 + } + if n < 1 { + return 1 + } + return int(n) // doesn't truncate; max is 512K +} + +var bufPool sync.Pool // of *[]byte + func (cs *clientStream) writeRequestBody(body io.Reader, bodyCloser io.Closer) (err error) { cc := cs.cc sentEnd := false // whether we sent the final DATA frame w/ END_STREAM - buf := cc.frameScratchBuffer() - defer cc.putFrameScratchBuffer(buf) defer func() { traceWroteRequest(cs.trace, err) @@ -1328,9 +1301,24 @@ func (cs *clientStream) writeRequestBody(body io.Reader, bodyCloser io.Closer) ( remainLen := actualContentLength(req) hasContentLen := remainLen != -1 + cc.mu.Lock() + maxFrameSize := int(cc.maxFrameSize) + cc.mu.Unlock() + + // Scratch buffer for reading into & writing from. + scratchLen := cs.frameScratchBufferLen(maxFrameSize) + var buf []byte + if bp, ok := bufPool.Get().(*[]byte); ok && len(*bp) >= scratchLen { + defer bufPool.Put(bp) + buf = *bp + } else { + buf = make([]byte, scratchLen) + defer bufPool.Put(&buf) + } + var sawEOF bool for !sawEOF { - n, err := body.Read(buf[:len(buf)-1]) + n, err := body.Read(buf[:len(buf)]) if hasContentLen { remainLen -= int64(n) if remainLen == 0 && err == nil { @@ -1341,8 +1329,9 @@ func (cs *clientStream) writeRequestBody(body io.Reader, bodyCloser io.Closer) ( // to send the END_STREAM bit early, double-check that we're actually // at EOF. Subsequent reads should return (0, EOF) at this point. // If either value is different, we return an error in one of two ways below. + var scratch [1]byte var n1 int - n1, err = body.Read(buf[n:]) + n1, err = body.Read(scratch[:]) remainLen -= int64(n1) } if remainLen < 0 { @@ -1412,10 +1401,6 @@ func (cs *clientStream) writeRequestBody(body io.Reader, bodyCloser io.Closer) ( } } - cc.mu.Lock() - maxFrameSize := int(cc.maxFrameSize) - cc.mu.Unlock() - cc.wmu.Lock() defer cc.wmu.Unlock() @@ -1531,19 +1516,21 @@ func (cc *ClientConn) encodeHeaders(req *http.Request, addGzipHeader bool, trail var didUA bool for k, vv := range req.Header { - if strings.EqualFold(k, "host") || strings.EqualFold(k, "content-length") { + if asciiEqualFold(k, "host") || asciiEqualFold(k, "content-length") { // Host is :authority, already sent. // Content-Length is automatic, set below. continue - } else if strings.EqualFold(k, "connection") || strings.EqualFold(k, "proxy-connection") || - strings.EqualFold(k, "transfer-encoding") || strings.EqualFold(k, "upgrade") || - strings.EqualFold(k, "keep-alive") { + } else if asciiEqualFold(k, "connection") || + asciiEqualFold(k, "proxy-connection") || + asciiEqualFold(k, "transfer-encoding") || + asciiEqualFold(k, "upgrade") || + asciiEqualFold(k, "keep-alive") { // Per 8.1.2.2 Connection-Specific Header // Fields, don't send connection-specific // fields. We have already checked if any // are error-worthy so just ignore the rest. continue - } else if strings.EqualFold(k, "user-agent") { + } else if asciiEqualFold(k, "user-agent") { // Match Go's http1 behavior: at most one // User-Agent. If set to nil or empty string, // then omit it. Otherwise if not mentioned, @@ -1556,7 +1543,7 @@ func (cc *ClientConn) encodeHeaders(req *http.Request, addGzipHeader bool, trail if vv[0] == "" { continue } - } else if strings.EqualFold(k, "cookie") { + } else if asciiEqualFold(k, "cookie") { // Per 8.1.2.5 To allow for better compression efficiency, the // Cookie header field MAY be split into separate header fields, // each with one or more cookie-pairs. @@ -1615,7 +1602,12 @@ func (cc *ClientConn) encodeHeaders(req *http.Request, addGzipHeader bool, trail // Header list size is ok. Write the headers. enumerateHeaders(func(name, value string) { - name = strings.ToLower(name) + name, ascii := asciiToLower(name) + if !ascii { + // Skip writing invalid headers. Per RFC 7540, Section 8.1.2, header + // field names have to be ASCII characters (just as in HTTP/1.x). + return + } cc.writeHeader(name, value) if traceHeaders { traceWroteHeaderField(trace, name, value) @@ -1663,9 +1655,14 @@ func (cc *ClientConn) encodeTrailers(req *http.Request) ([]byte, error) { } for k, vv := range req.Trailer { + lowKey, ascii := asciiToLower(k) + if !ascii { + // Skip writing invalid headers. Per RFC 7540, Section 8.1.2, header + // field names have to be ASCII characters (just as in HTTP/1.x). + continue + } // Transfer-Encoding, etc.. have already been filtered at the // start of RoundTrip - lowKey := strings.ToLower(k) for _, v := range vv { cc.writeHeader(lowKey, v) } diff --git a/vendor/golang.org/x/net/http2/write.go b/vendor/golang.org/x/net/http2/write.go index 3849bc26..33f61398 100644 --- a/vendor/golang.org/x/net/http2/write.go +++ b/vendor/golang.org/x/net/http2/write.go @@ -341,7 +341,12 @@ func encodeHeaders(enc *hpack.Encoder, h http.Header, keys []string) { } for _, k := range keys { vv := h[k] - k = lowerHeader(k) + k, ascii := lowerHeader(k) + if !ascii { + // Skip writing invalid headers. Per RFC 7540, Section 8.1.2, header + // field names have to be ASCII characters (just as in HTTP/1.x). + continue + } if !validWireHeaderFieldName(k) { // Skip it as backup paranoia. Per // golang.org/issue/14048, these should diff --git a/vendor/golang.org/x/net/idna/idna10.0.0.go b/vendor/golang.org/x/net/idna/idna10.0.0.go index 7e69ee1b..5208ba6c 100644 --- a/vendor/golang.org/x/net/idna/idna10.0.0.go +++ b/vendor/golang.org/x/net/idna/idna10.0.0.go @@ -67,15 +67,14 @@ func Transitional(transitional bool) Option { // VerifyDNSLength sets whether a Profile should fail if any of the IDN parts // are longer than allowed by the RFC. +// +// This option corresponds to the VerifyDnsLength flag in UTS #46. func VerifyDNSLength(verify bool) Option { return func(o *options) { o.verifyDNSLength = verify } } // RemoveLeadingDots removes leading label separators. Leading runes that map to // dots, such as U+3002 IDEOGRAPHIC FULL STOP, are removed as well. -// -// This is the behavior suggested by the UTS #46 and is adopted by some -// browsers. func RemoveLeadingDots(remove bool) Option { return func(o *options) { o.removeLeadingDots = remove } } @@ -83,6 +82,8 @@ func RemoveLeadingDots(remove bool) Option { // ValidateLabels sets whether to check the mandatory label validation criteria // as defined in Section 5.4 of RFC 5891. This includes testing for correct use // of hyphens ('-'), normalization, validity of runes, and the context rules. +// In particular, ValidateLabels also sets the CheckHyphens and CheckJoiners flags +// in UTS #46. func ValidateLabels(enable bool) Option { return func(o *options) { // Don't override existing mappings, but set one that at least checks @@ -91,25 +92,48 @@ func ValidateLabels(enable bool) Option { o.mapping = normalize } o.trie = trie - o.validateLabels = enable - o.fromPuny = validateFromPunycode + o.checkJoiners = enable + o.checkHyphens = enable + if enable { + o.fromPuny = validateFromPunycode + } else { + o.fromPuny = nil + } + } +} + +// CheckHyphens sets whether to check for correct use of hyphens ('-') in +// labels. Most web browsers do not have this option set, since labels such as +// "r3---sn-apo3qvuoxuxbt-j5pe" are in common use. +// +// This option corresponds to the CheckHyphens flag in UTS #46. +func CheckHyphens(enable bool) Option { + return func(o *options) { o.checkHyphens = enable } +} + +// CheckJoiners sets whether to check the ContextJ rules as defined in Appendix +// A of RFC 5892, concerning the use of joiner runes. +// +// This option corresponds to the CheckJoiners flag in UTS #46. +func CheckJoiners(enable bool) Option { + return func(o *options) { + o.trie = trie + o.checkJoiners = enable } } // StrictDomainName limits the set of permissible ASCII characters to those // allowed in domain names as defined in RFC 1034 (A-Z, a-z, 0-9 and the -// hyphen). This is set by default for MapForLookup and ValidateForRegistration. +// hyphen). This is set by default for MapForLookup and ValidateForRegistration, +// but is only useful if ValidateLabels is set. // // This option is useful, for instance, for browsers that allow characters // outside this range, for example a '_' (U+005F LOW LINE). See -// http://www.rfc-editor.org/std/std3.txt for more details This option -// corresponds to the UseSTD3ASCIIRules option in UTS #46. +// http://www.rfc-editor.org/std/std3.txt for more details. +// +// This option corresponds to the UseSTD3ASCIIRules flag in UTS #46. func StrictDomainName(use bool) Option { - return func(o *options) { - o.trie = trie - o.useSTD3Rules = use - o.fromPuny = validateFromPunycode - } + return func(o *options) { o.useSTD3Rules = use } } // NOTE: the following options pull in tables. The tables should not be linked @@ -117,6 +141,8 @@ func StrictDomainName(use bool) Option { // BidiRule enables the Bidi rule as defined in RFC 5893. Any application // that relies on proper validation of labels should include this rule. +// +// This option corresponds to the CheckBidi flag in UTS #46. func BidiRule() Option { return func(o *options) { o.bidirule = bidirule.ValidString } } @@ -152,7 +178,8 @@ func MapForLookup() Option { type options struct { transitional bool useSTD3Rules bool - validateLabels bool + checkHyphens bool + checkJoiners bool verifyDNSLength bool removeLeadingDots bool @@ -225,8 +252,11 @@ func (p *Profile) String() string { if p.useSTD3Rules { s += ":UseSTD3Rules" } - if p.validateLabels { - s += ":ValidateLabels" + if p.checkHyphens { + s += ":CheckHyphens" + } + if p.checkJoiners { + s += ":CheckJoiners" } if p.verifyDNSLength { s += ":VerifyDNSLength" @@ -254,26 +284,29 @@ var ( punycode = &Profile{} lookup = &Profile{options{ - transitional: true, - useSTD3Rules: true, - validateLabels: true, - trie: trie, - fromPuny: validateFromPunycode, - mapping: validateAndMap, - bidirule: bidirule.ValidString, + transitional: true, + useSTD3Rules: true, + checkHyphens: true, + checkJoiners: true, + trie: trie, + fromPuny: validateFromPunycode, + mapping: validateAndMap, + bidirule: bidirule.ValidString, }} display = &Profile{options{ - useSTD3Rules: true, - validateLabels: true, - trie: trie, - fromPuny: validateFromPunycode, - mapping: validateAndMap, - bidirule: bidirule.ValidString, + useSTD3Rules: true, + checkHyphens: true, + checkJoiners: true, + trie: trie, + fromPuny: validateFromPunycode, + mapping: validateAndMap, + bidirule: bidirule.ValidString, }} registration = &Profile{options{ useSTD3Rules: true, - validateLabels: true, verifyDNSLength: true, + checkHyphens: true, + checkJoiners: true, trie: trie, fromPuny: validateFromPunycode, mapping: validateRegistration, @@ -340,7 +373,7 @@ func (p *Profile) process(s string, toASCII bool) (string, error) { } isBidi = isBidi || bidirule.DirectionString(u) != bidi.LeftToRight labels.set(u) - if err == nil && p.validateLabels { + if err == nil && p.fromPuny != nil { err = p.fromPuny(p, u) } if err == nil { @@ -681,16 +714,18 @@ func (p *Profile) validateLabel(s string) (err error) { } return nil } - if !p.validateLabels { - return nil - } - trie := p.trie // p.validateLabels is only set if trie is set. - if len(s) > 4 && s[2] == '-' && s[3] == '-' { - return &labelError{s, "V2"} + if p.checkHyphens { + if len(s) > 4 && s[2] == '-' && s[3] == '-' { + return &labelError{s, "V2"} + } + if s[0] == '-' || s[len(s)-1] == '-' { + return &labelError{s, "V3"} + } } - if s[0] == '-' || s[len(s)-1] == '-' { - return &labelError{s, "V3"} + if !p.checkJoiners { + return nil } + trie := p.trie // p.checkJoiners is only set if trie is set. // TODO: merge the use of this in the trie. v, sz := trie.lookupString(s) x := info(v) diff --git a/vendor/golang.org/x/net/idna/idna9.0.0.go b/vendor/golang.org/x/net/idna/idna9.0.0.go index 7c745637..55f718f1 100644 --- a/vendor/golang.org/x/net/idna/idna9.0.0.go +++ b/vendor/golang.org/x/net/idna/idna9.0.0.go @@ -66,15 +66,14 @@ func Transitional(transitional bool) Option { // VerifyDNSLength sets whether a Profile should fail if any of the IDN parts // are longer than allowed by the RFC. +// +// This option corresponds to the VerifyDnsLength flag in UTS #46. func VerifyDNSLength(verify bool) Option { return func(o *options) { o.verifyDNSLength = verify } } // RemoveLeadingDots removes leading label separators. Leading runes that map to // dots, such as U+3002 IDEOGRAPHIC FULL STOP, are removed as well. -// -// This is the behavior suggested by the UTS #46 and is adopted by some -// browsers. func RemoveLeadingDots(remove bool) Option { return func(o *options) { o.removeLeadingDots = remove } } @@ -82,6 +81,8 @@ func RemoveLeadingDots(remove bool) Option { // ValidateLabels sets whether to check the mandatory label validation criteria // as defined in Section 5.4 of RFC 5891. This includes testing for correct use // of hyphens ('-'), normalization, validity of runes, and the context rules. +// In particular, ValidateLabels also sets the CheckHyphens and CheckJoiners flags +// in UTS #46. func ValidateLabels(enable bool) Option { return func(o *options) { // Don't override existing mappings, but set one that at least checks @@ -90,25 +91,48 @@ func ValidateLabels(enable bool) Option { o.mapping = normalize } o.trie = trie - o.validateLabels = enable - o.fromPuny = validateFromPunycode + o.checkJoiners = enable + o.checkHyphens = enable + if enable { + o.fromPuny = validateFromPunycode + } else { + o.fromPuny = nil + } + } +} + +// CheckHyphens sets whether to check for correct use of hyphens ('-') in +// labels. Most web browsers do not have this option set, since labels such as +// "r3---sn-apo3qvuoxuxbt-j5pe" are in common use. +// +// This option corresponds to the CheckHyphens flag in UTS #46. +func CheckHyphens(enable bool) Option { + return func(o *options) { o.checkHyphens = enable } +} + +// CheckJoiners sets whether to check the ContextJ rules as defined in Appendix +// A of RFC 5892, concerning the use of joiner runes. +// +// This option corresponds to the CheckJoiners flag in UTS #46. +func CheckJoiners(enable bool) Option { + return func(o *options) { + o.trie = trie + o.checkJoiners = enable } } // StrictDomainName limits the set of permissable ASCII characters to those // allowed in domain names as defined in RFC 1034 (A-Z, a-z, 0-9 and the -// hyphen). This is set by default for MapForLookup and ValidateForRegistration. +// hyphen). This is set by default for MapForLookup and ValidateForRegistration, +// but is only useful if ValidateLabels is set. // // This option is useful, for instance, for browsers that allow characters // outside this range, for example a '_' (U+005F LOW LINE). See -// http://www.rfc-editor.org/std/std3.txt for more details This option -// corresponds to the UseSTD3ASCIIRules option in UTS #46. +// http://www.rfc-editor.org/std/std3.txt for more details. +// +// This option corresponds to the UseSTD3ASCIIRules flag in UTS #46. func StrictDomainName(use bool) Option { - return func(o *options) { - o.trie = trie - o.useSTD3Rules = use - o.fromPuny = validateFromPunycode - } + return func(o *options) { o.useSTD3Rules = use } } // NOTE: the following options pull in tables. The tables should not be linked @@ -116,6 +140,8 @@ func StrictDomainName(use bool) Option { // BidiRule enables the Bidi rule as defined in RFC 5893. Any application // that relies on proper validation of labels should include this rule. +// +// This option corresponds to the CheckBidi flag in UTS #46. func BidiRule() Option { return func(o *options) { o.bidirule = bidirule.ValidString } } @@ -152,7 +178,8 @@ func MapForLookup() Option { type options struct { transitional bool useSTD3Rules bool - validateLabels bool + checkHyphens bool + checkJoiners bool verifyDNSLength bool removeLeadingDots bool @@ -225,8 +252,11 @@ func (p *Profile) String() string { if p.useSTD3Rules { s += ":UseSTD3Rules" } - if p.validateLabels { - s += ":ValidateLabels" + if p.checkHyphens { + s += ":CheckHyphens" + } + if p.checkJoiners { + s += ":CheckJoiners" } if p.verifyDNSLength { s += ":VerifyDNSLength" @@ -255,9 +285,10 @@ var ( punycode = &Profile{} lookup = &Profile{options{ transitional: true, - useSTD3Rules: true, - validateLabels: true, removeLeadingDots: true, + useSTD3Rules: true, + checkHyphens: true, + checkJoiners: true, trie: trie, fromPuny: validateFromPunycode, mapping: validateAndMap, @@ -265,8 +296,9 @@ var ( }} display = &Profile{options{ useSTD3Rules: true, - validateLabels: true, removeLeadingDots: true, + checkHyphens: true, + checkJoiners: true, trie: trie, fromPuny: validateFromPunycode, mapping: validateAndMap, @@ -274,8 +306,9 @@ var ( }} registration = &Profile{options{ useSTD3Rules: true, - validateLabels: true, verifyDNSLength: true, + checkHyphens: true, + checkJoiners: true, trie: trie, fromPuny: validateFromPunycode, mapping: validateRegistration, @@ -339,7 +372,7 @@ func (p *Profile) process(s string, toASCII bool) (string, error) { continue } labels.set(u) - if err == nil && p.validateLabels { + if err == nil && p.fromPuny != nil { err = p.fromPuny(p, u) } if err == nil { @@ -629,16 +662,18 @@ func (p *Profile) validateLabel(s string) error { if p.bidirule != nil && !p.bidirule(s) { return &labelError{s, "B"} } - if !p.validateLabels { - return nil - } - trie := p.trie // p.validateLabels is only set if trie is set. - if len(s) > 4 && s[2] == '-' && s[3] == '-' { - return &labelError{s, "V2"} + if p.checkHyphens { + if len(s) > 4 && s[2] == '-' && s[3] == '-' { + return &labelError{s, "V2"} + } + if s[0] == '-' || s[len(s)-1] == '-' { + return &labelError{s, "V3"} + } } - if s[0] == '-' || s[len(s)-1] == '-' { - return &labelError{s, "V3"} + if !p.checkJoiners { + return nil } + trie := p.trie // p.checkJoiners is only set if trie is set. // TODO: merge the use of this in the trie. v, sz := trie.lookupString(s) x := info(v) diff --git a/vendor/golang.org/x/net/publicsuffix/list.go b/vendor/golang.org/x/net/publicsuffix/list.go new file mode 100644 index 00000000..200617ea --- /dev/null +++ b/vendor/golang.org/x/net/publicsuffix/list.go @@ -0,0 +1,181 @@ +// Copyright 2012 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:generate go run gen.go + +// Package publicsuffix provides a public suffix list based on data from +// https://publicsuffix.org/ +// +// A public suffix is one under which Internet users can directly register +// names. It is related to, but different from, a TLD (top level domain). +// +// "com" is a TLD (top level domain). Top level means it has no dots. +// +// "com" is also a public suffix. Amazon and Google have registered different +// siblings under that domain: "amazon.com" and "google.com". +// +// "au" is another TLD, again because it has no dots. But it's not "amazon.au". +// Instead, it's "amazon.com.au". +// +// "com.au" isn't an actual TLD, because it's not at the top level (it has +// dots). But it is an eTLD (effective TLD), because that's the branching point +// for domain name registrars. +// +// Another name for "an eTLD" is "a public suffix". Often, what's more of +// interest is the eTLD+1, or one more label than the public suffix. For +// example, browsers partition read/write access to HTTP cookies according to +// the eTLD+1. Web pages served from "amazon.com.au" can't read cookies from +// "google.com.au", but web pages served from "maps.google.com" can share +// cookies from "www.google.com", so you don't have to sign into Google Maps +// separately from signing into Google Web Search. Note that all four of those +// domains have 3 labels and 2 dots. The first two domains are each an eTLD+1, +// the last two are not (but share the same eTLD+1: "google.com"). +// +// All of these domains have the same eTLD+1: +// - "www.books.amazon.co.uk" +// - "books.amazon.co.uk" +// - "amazon.co.uk" +// Specifically, the eTLD+1 is "amazon.co.uk", because the eTLD is "co.uk". +// +// There is no closed form algorithm to calculate the eTLD of a domain. +// Instead, the calculation is data driven. This package provides a +// pre-compiled snapshot of Mozilla's PSL (Public Suffix List) data at +// https://publicsuffix.org/ +package publicsuffix // import "golang.org/x/net/publicsuffix" + +// TODO: specify case sensitivity and leading/trailing dot behavior for +// func PublicSuffix and func EffectiveTLDPlusOne. + +import ( + "fmt" + "net/http/cookiejar" + "strings" +) + +// List implements the cookiejar.PublicSuffixList interface by calling the +// PublicSuffix function. +var List cookiejar.PublicSuffixList = list{} + +type list struct{} + +func (list) PublicSuffix(domain string) string { + ps, _ := PublicSuffix(domain) + return ps +} + +func (list) String() string { + return version +} + +// PublicSuffix returns the public suffix of the domain using a copy of the +// publicsuffix.org database compiled into the library. +// +// icann is whether the public suffix is managed by the Internet Corporation +// for Assigned Names and Numbers. If not, the public suffix is either a +// privately managed domain (and in practice, not a top level domain) or an +// unmanaged top level domain (and not explicitly mentioned in the +// publicsuffix.org list). For example, "foo.org" and "foo.co.uk" are ICANN +// domains, "foo.dyndns.org" and "foo.blogspot.co.uk" are private domains and +// "cromulent" is an unmanaged top level domain. +// +// Use cases for distinguishing ICANN domains like "foo.com" from private +// domains like "foo.appspot.com" can be found at +// https://wiki.mozilla.org/Public_Suffix_List/Use_Cases +func PublicSuffix(domain string) (publicSuffix string, icann bool) { + lo, hi := uint32(0), uint32(numTLD) + s, suffix, icannNode, wildcard := domain, len(domain), false, false +loop: + for { + dot := strings.LastIndex(s, ".") + if wildcard { + icann = icannNode + suffix = 1 + dot + } + if lo == hi { + break + } + f := find(s[1+dot:], lo, hi) + if f == notFound { + break + } + + u := nodes[f] >> (nodesBitsTextOffset + nodesBitsTextLength) + icannNode = u&(1<<nodesBitsICANN-1) != 0 + u >>= nodesBitsICANN + u = children[u&(1<<nodesBitsChildren-1)] + lo = u & (1<<childrenBitsLo - 1) + u >>= childrenBitsLo + hi = u & (1<<childrenBitsHi - 1) + u >>= childrenBitsHi + switch u & (1<<childrenBitsNodeType - 1) { + case nodeTypeNormal: + suffix = 1 + dot + case nodeTypeException: + suffix = 1 + len(s) + break loop + } + u >>= childrenBitsNodeType + wildcard = u&(1<<childrenBitsWildcard-1) != 0 + if !wildcard { + icann = icannNode + } + + if dot == -1 { + break + } + s = s[:dot] + } + if suffix == len(domain) { + // If no rules match, the prevailing rule is "*". + return domain[1+strings.LastIndex(domain, "."):], icann + } + return domain[suffix:], icann +} + +const notFound uint32 = 1<<32 - 1 + +// find returns the index of the node in the range [lo, hi) whose label equals +// label, or notFound if there is no such node. The range is assumed to be in +// strictly increasing node label order. +func find(label string, lo, hi uint32) uint32 { + for lo < hi { + mid := lo + (hi-lo)/2 + s := nodeLabel(mid) + if s < label { + lo = mid + 1 + } else if s == label { + return mid + } else { + hi = mid + } + } + return notFound +} + +// nodeLabel returns the label for the i'th node. +func nodeLabel(i uint32) string { + x := nodes[i] + length := x & (1<<nodesBitsTextLength - 1) + x >>= nodesBitsTextLength + offset := x & (1<<nodesBitsTextOffset - 1) + return text[offset : offset+length] +} + +// EffectiveTLDPlusOne returns the effective top level domain plus one more +// label. For example, the eTLD+1 for "foo.bar.golang.org" is "golang.org". +func EffectiveTLDPlusOne(domain string) (string, error) { + if strings.HasPrefix(domain, ".") || strings.HasSuffix(domain, ".") || strings.Contains(domain, "..") { + return "", fmt.Errorf("publicsuffix: empty label in domain %q", domain) + } + + suffix, _ := PublicSuffix(domain) + if len(domain) <= len(suffix) { + return "", fmt.Errorf("publicsuffix: cannot derive eTLD+1 for domain %q", domain) + } + i := len(domain) - len(suffix) - 1 + if domain[i] != '.' { + return "", fmt.Errorf("publicsuffix: invalid public suffix %q for domain %q", suffix, domain) + } + return domain[1+strings.LastIndex(domain[:i], "."):], nil +} diff --git a/vendor/golang.org/x/net/publicsuffix/table.go b/vendor/golang.org/x/net/publicsuffix/table.go new file mode 100644 index 00000000..c2e368db --- /dev/null +++ b/vendor/golang.org/x/net/publicsuffix/table.go @@ -0,0 +1,10520 @@ +// generated by go run gen.go; DO NOT EDIT + +package publicsuffix + +const version = "publicsuffix.org's public_suffix_list.dat, git revision 1e2388af5cee935fdec6dc557db41559111e3fb9 (2021-04-26T23:42:06Z)" + +const ( + nodesBitsChildren = 10 + nodesBitsICANN = 1 + nodesBitsTextOffset = 15 + nodesBitsTextLength = 6 + + childrenBitsWildcard = 1 + childrenBitsNodeType = 2 + childrenBitsHi = 14 + childrenBitsLo = 14 +) + +const ( + nodeTypeNormal = 0 + nodeTypeException = 1 + nodeTypeParentOnly = 2 +) + +// numTLD is the number of top level domains. +const numTLD = 1506 + +// Text is the combined text of all labels. +const text = "9guacuiababia-goracleaningroks-theatree12hpalmasfjorden4tatarant" + + "ours3-ap-northeast-2ix4432-balsan-suedtirolkuszczytnord-aurdalp1" + + "kappchizip6116-b-datacentermezproxyzgorabogadobeaemcloud-fr1337b" + + "irdartcenterprisecloudaccesscambridgeiseiroumuenchenirasakincheo" + + "nishiazaindianapolis-a-bloggerbirkenesoddtangenovarahkkeravjuego" + + "shikikugawashtenawdev-myqnapcloudcontrolledekagaminogifts3-websi" + + "te-ap-southeast-2birthplacevje-og-hornnes3-website-eu-west-1bjar" + + "koyuu2-localhostrolekaniepcextraspace-to-rentalstomakomaibarabje" + + "rkreimbamblebesbyglandroverhallaakesvuemieleccebinagisoccertmgra" + + "zerbaijan-mayengerdalipaywhirlimanowarudaustevollillyokosukanrag" + + "rocerybnikeisenbahnaumburggfarmerseine164-balsfjordd-dnshome-web" + + "serverdal-o-g-i-naval-d-aosta-valleyboltateshinanomachimkentatey" + + "amajudygarlanddnslivefsnillfjorddnss3-ap-south-1bjugnieznord-oda" + + "lomzaporizhzhiablackfridayuzawabloombergbauernishigohtawaramotoi" + + "neppueblockbusterniiminamiawajikindianmarketinglitcheltenham-rad" + + "io-opencraftrainingliwicebloxcms3-website-sa-east-1bluedagestang" + + "emologicallyngenishiharabmoattachments3-website-us-east-1bms3-we" + + "bsite-us-west-1bmwedeploybnrwegroweibolognagareyamakeuparaglidin" + + "globoavistanbulsan-sudtirolondonetskaratebomloabathsbchernivtsic" + + "iliabondigitaloceanographicsxboxfordellogliastradinglogoweirbonn" + + "ishiizunazukindielddanuorrindigenamsosnowiechernovtsyncloudray-d" + + "nstracebookinghostedpictetjeldsundrayddnsfreebox-osascoli-piceno" + + "rdlandraydnsupdaterbookonlinewjerseyboomlajollamericanexpressexy" + + "boschaefflerdalondrinapleskns3-website-us-west-2bostik-serverran" + + "koshigayachts5ybostonakijinsekikogentappsselfiparisor-fronishika" + + "taketomisatomobelembetsukubankaratsuginamikatagamilanotairesakyo" + + "tanabellevuelosangelesjabbottjmaxxxenishikatsuragit-reposalangen" + + "ishikawazukamisatohoboleslawiechirurgiens-dentistes-en-francebot" + + "anicalgardeno-stagingloppenzaporizhzhedmarkareliancebotanicgarde" + + "nishimerabotanychiryukyuragifuchungbukharanzanishinomiyashironom" + + "niweatherchannelorenskoglugsjcbnpparibashkiriabouncemerckmsdnipr" + + "opetrovskjervoyageorgeorgiabounty-fullensakerrypropertiesalon-1b" + + "outiquebeconomiastalowa-wolawassamukawataricoharuovatmallorcafed" + + "eration-webpaashorokanaieboutiresindevicenzaganquannefrankfurtjo" + + "meloyalistoragebozen-sudtirolottebozen-suedtirolottokonamegataka" + + "yamassa-carrara-massacarraramassabusinessebykleclerchitachinakag" + + "awatchandclockariyameiwamarshallstatebankarlsoybplaceducatoraybr" + + "andywinevalleybrasiliabrindisibenikilatironrenderbristoloseyouri" + + "parliamentjxeroxfinitybritishcolumbialowiezakopanelastxjampalace" + + "broadcastlebtimnetzjavaldaostathelleluxembourgmbhartipschlesisch" + + "esaltdalouvrehabmerbroadwaybroke-itkmaxxn--0trq7p7nnishinoomoteg" + + "omurabrokerbronnoysundrivegarsheiheijindowapblogsiteleafamilycom" + + "pany-2brothermesaverdealerbrowsersafetymarketsaludrobaknoluoktac" + + "hikawafflecellclstagehirnrtksatxn--11b4c3drudupontariobranconaka" + + "niikawatanagurabrumunddalpusercontentlon-2brunelblagrarchaeology" + + "eongbuk0brusselsalvadordalibabalena-devicesalzburgminakamichihar" + + "abruxellesamegawabryanskleppgafanishinoshimatsusakahoginankokubu" + + "njindustriabrynewmexicodyn-o-saurlandesamnangerbuskerudurbanamex" + + "hibitionishiokoppegardurhamburgmodellingmxn--12c1fe0bradescotlan" + + "dynathomebuiltwithdarkarmoybuzentsujiiebuzzlgretakamoriokakegawa" + + "bwellbeingzonebzhitomirbzzwesteuropenairbusantiquest-a-la-maison" + + "dre-landroidyndns-at-homedepotenzaolbia-tempio-olbiatempioolbial" + + "ystokkeliwebhostingrimstadyndns-at-workisboringripecolumbusheyco" + + "mmunecommunity-prochowicecomoarekecomparemarkerryhotelsantamaria" + + "kecomsecaaskoyabearalvahkihokumakogenebakkeshibechambagriculture" + + "nnebugattiffanyaarborteaches-yogasawara-rugbydgoszczecinemacerat" + + "abuseating-organicbcieszyncondoshichinohealth-carereformemergenc" + + "yahikobeardubaiduckdnswedeniwaizumiotsukumiyamazonawsglobalaccel" + + "eratorahimeshimabaridagawalbrzycharternopilawalesundyndns-remote" + + "wdyndns-serverisignconferenceconstructionconsuladoesntexisteinge" + + "ekashibatakatorinzais-a-candidateconsultanthropologyconsultingro" + + "undhandlingroznynysaikisosakitagawacontactoyouracontagematsubara" + + "vpagexluzerncontemporaryarteducationalchikugodogadollsantoandrea" + + "mhostersanukis-a-caterercontractorskenconventureshinodearthruher" + + "ecifedexetercookingchannelsdvrdnsdojoburgrpasadenaritakoelncoolv" + + "ivanovoldacooperativano-frankivskolefrakkestadyndns-webhareidsbe" + + "rgentingruecopenhagencyclopedichonanbulsan-suedtirolubindalublin" + + "desnesamsclubartowestfalenishitosashimizunaminamibosogndalucania" + + "coproductionsaobernardocorporationcorsicahcesuoloansaogoncarrier" + + "corvettemp-dnsaotomelbournecosenzamamidorissadonnagatorogersvps-" + + "hostrowiechoseikarugamvikarpaczeladzcosidnsfor-better-thanawawsm" + + "pplanetariumemorialcostumedicinaharimalborkashiharacouchpotatofr" + + "iesapporocoukashiwaracouncilcouponsardegnarusawacozoracqcxn--12c" + + "fi8ixb8lcranbrookuwanalyticsardiniacrdyndns-wikinkobierzycecredi" + + "tcardyndns-workshoparenakanojohanamakinoharacreditunioncremonash" + + "gabadaddjaguarqhachinoheguris-a-celticsfancrewhoswholdingsmall-w" + + "ebredirectmeetoystre-slidrettozawacricketrzyncrimeast-kazakhstan" + + "angercrotonecrownipassagensarlcrsarpsborguidefenseljordyndns1cru" + + "isesarufutsunomiyawakasaikaitabashijonawatecuisinellancashirecip" + + "escaracalvinklein-berlindaskvollculturalcentertainmentozsdelmenh" + + "orstalbansasayamattelekommunikationcuneocupcakecuritibaghdadynns" + + "asebofageologycurvallee-aosteroycymrussiacyonabarumemsettlersask" + + "atchewancyouthachiojiyaizuwakamatsubushikusakadogawaferrarivnefe" + + "rrerotikagoshimalopolskanlandynv6fetsundynvpnpluscountryestateof" + + "delawareclaimsaudafgulenfhvalerfidoomdnsiskinkyotobetsumidatlant" + + "ichoshibuyahabackyardsamsungriwataraidyndns-freeboxoslocus-4fiel" + + "dyroyrvikinguitarsauheradynservebbsassaris-a-chefashionfigueresi" + + "stancefilateliafilegear-audnedalnfilegear-dealstahaugesunderseap" + + "ortsinfolionetworkangerfilegear-gbizfilegear-iefilegear-jpmorgan" + + "filegear-sg-1filminamiechizenfinalfinancefineartschokokekschokol" + + "adenfinlandfinnoyfirebaseappatriafirenetraniandriabarlettatrania" + + "ndriafirenzefirestonefirewebhopensocialfirmdalegnicapebretonamic" + + "rolightingunmaniwakuratefishingokasells-for-lesscholarshipschool" + + "sztynsettsurgeonshalloffameldalfitjarvodkafjordvagsoygardendofth" + + "einternetnedalceschulefitnessettlementranoyfjalerflekkefjordfles" + + "berguovdageaidnulminamifuranoflickragerokunohealthcareerschulser" + + "verflirfloginlinefloraflorencefloridatsunanjoetsuwanouchikujogas" + + "zkolancasterfloripaderbornfloristanohatajiris-a-cpadualstackasse" + + "rversailleschwarzgwangjuifminamiiserniafloromskogushikamifuranor" + + "e-og-uvdalflowerschweizfltranslateflynnhosting-clusterfndfnwkasu" + + "kabedzin-addrammenulvikasumigaurayasudafoodnetworkdalfor-ourfor-" + + "somedizinhistorischesciencecentersciencehistoryfor-theaterforexr" + + "othachirogatakanabeautysfjordforgotdnscientistordalforli-cesena-" + + "forlicesenaforlikescandyn53forsalegoldpoint2thisamitsukeforsanda" + + "suoloftransportefortalfortevaksdalfortmissoulanciafortworthadano" + + "rfolkebibleksvikasuyanaizuerichardlillesandefjordfosnescjohnsonf" + + "otaruis-a-cubicle-slavellinodeobjectscrapper-sitefoxafozfranamiz" + + "uhobby-sitexascrappingwiddleitungsenfrancaiseharafranziskanerima" + + "ringatlantakahamalselvendrellfredrikstadtvscrysecuritytacticserv" + + "ehttpaviancargodaddyn-vpndnservehumourfreeddnsgeekgalaxyfreedesk" + + "topocznordreisa-hockeynutazurestaticappspacehosted-by-previderfr" + + "eemasonryfreemyiphosteurovisionfreesitextileikangerfreetlserveir" + + "choyodobashichikashukujitawaraumalatvuopmicrosoftbankaruizawafre" + + "iburgxn--1ck2e1bar0emmafann-arboretumbriamallamaceiobbcg12038fre" + + "seniusculturecreationfribourgfriuli-v-giuliafriuli-ve-giuliafriu" + + "li-vegiuliafriuli-venezia-giuliafriuli-veneziagiuliafriuli-vgiul" + + "iafriuliv-giuliafriulive-giuliafriulivegiuliafriulivenezia-giuli" + + "afriuliveneziagiuliafriulivgiuliafrlfroganserveminecraftransurlf" + + "rognfrolandfrom-akrehamnfrom-alfrom-arfrom-azimuthatogayabukijob" + + "servableusercontentrapaniizafrom-capetownnews-stagingfrom-coffee" + + "dbackplaneappfizerfrom-ctravelchannelfrom-dchristiansburgroks-th" + + "isayamanobeokakudamatsuefrom-deatnuniversityfrom-flanderservemp3" + + "from-gaulardalfrom-hichisochildrensgardenfrom-iafrom-idfrom-ilfr" + + "om-in-brbar1from-kservep2pgfoggiafrom-kyowariasahikawafrom-lange" + + "vagrigentomologyeonggiehtavuoatnabudapest-a-la-masion-rancherkas" + + "ydneyfrom-malvikaszubyfrom-mdfrom-meerestaurantravelersinsurance" + + "from-mifunefrom-mnfrom-modalenfrom-mservepicservequakefrom-mtnfr" + + "om-nctulanservesarcasmatartanddesignfrom-ndfrom-nefrom-nh-serveb" + + "logspotrdfrom-njservicesevastopolefrom-nminamiizukaminokawanishi" + + "aizubangefrom-nvallee-d-aosteigenfrom-nyminamimakis-a-democratre" + + "ndhostingfrom-ohdattorelayfrom-oketogolffansevenassisicilyfrom-o" + + "rfrom-padoval-daostavalleyfrom-pratogurafrom-ris-a-designerfrom-" + + "schoenbrunnfrom-sdscloudfrom-tnfrom-txn--1ctwolominamatarnobrzeg" + + "yptianfrom-utsiracusagaeroclubmedecincinnativeamericanantiquest-" + + "mon-blogueurodirumadridnbloggerimo-i-rana4unjargafrom-vald-aosta" + + "rostwodzislawienfrom-vtrentin-sud-tirolfrom-wafrom-wiardwebspace" + + "from-wvalleeaosteinkjerusalempresashibetsukuis-a-doctorprojectre" + + "ntin-sudtirolfrom-wyfrosinonefrostaplesharis-a-financialadvisor-" + + "aurdalfroyaitakaharunusualpersonfstcgroupharmaciensharpharmacysh" + + "awaiijimarburgfujiiderafujikawaguchikonefujiminokamoenairlineen-" + + "rootaribeiraogashimadachicagoboatshellaspeziafujinomiyadattowebc" + + "ampinashikiminohostfoldnavyfujiokayamamurogawafujisatoshonairpor" + + "tland-4-salernoduminamiminowafujisawafujishiroishidakabiratoride" + + "bianfujitsurugashimandalfujiyoshidavvenjargap-northeast-3fukayab" + + "eatshimojis-a-geekatowicefukuchiyamadavvesiidappnodebalancertifi" + + "cationfukudomigawafukuis-a-greenfukumitsubishigakirovogradoyfuku" + + "okazakiryuohkurafukuroishikarikaturindalfukusakisarazure-mobilei" + + "rfjordfukuyamagatakahashimamakishiwadazaifudaigojomedio-campidan" + + "o-mediocampidanomediofunabashiriuchinadafunagatakahatakaishimogo" + + "senfunahashikamiamakusatsumasendaisennangonohejis-a-gurunzenfund" + + "aciofunkfeuerfuoiskujukuriyamangooglecodespotrentin-sued-tirolfu" + + "osskoczowiiheyakumodernfurnitureggio-calabriafurubirafurudonosti" + + "aafurukawairtelebitbridgestonekobayashikaoirmitakeharackmazeplay" + + "fusodegaurafussagamiharafutabayamaguchinomihachimanagementrentin" + + "-suedtirolfutboldlygoingnowhere-for-morenakatombetsumitakagiizef" + + "uttsurugimperiafuturecmshimokawafuturehostingfuturemailingfvghan" + + "gglidinghangoutsystemscloudsitehannanmokuizumodenaklodzkochikush" + + "inonsenergyhannorthwesternmutualhanyuzenhapmircloudletshimonitay" + + "anagitapphdfcbankatsuyamarugame-hostyhostinghappousrcfastly-terr" + + "ariumetacentrumeteorappassenger-associationharstadharvestcelebra" + + "tionhasamansionshimonosekikawahasaminami-alpshimosuwalkis-a-land" + + "scaperugiahashbanghasudahasura-apphiladelphiaareadmyblogsytehasv" + + "ikaufentigerhatoyamazakitahiroshimanxn--1lqs03nhatsukaichikaisei" + + "yoichippubetsubetsugarustkanmakiwakunigamiharutwentehattfjelldal" + + "hayashimamotobungotakadancehazuminobusells-for-uhelsinkitakamiiz" + + "umisanofidelitysvardontexistmein-iservebeerhembygdsforbundhemnes" + + "himotsukehemsedalhepforgeblockshimotsumaherokusslattuminamioguni" + + "5heroyhgtvalleedaostehidorahigashiagatsumagoianiahigashichichibu" + + "nkyonanaoshimakanegasakimobetsuldalhigashihiroshimanehigashiizum" + + "ozakitakatakaokalmykiahigashikagawahigashikagurasoedahigashikawa" + + "kitaaikitakyushuaiahigashikurumegurownproviderhigashimatsushimao" + + "ris-a-lawyerhigashimatsuyamakitaakitadaitoigawahigashimurayamamo" + + "torcycleshinichinanhigashinarusells-itrentino-aadigehigashinehig" + + "ashiomitamamurausukitamihamadahigashiosakasayamanakakogawahigash" + + "ishirakawamatakarazukaluganskygearapphilatelyhigashisumiyoshikaw" + + "aminamiaikitamotosumy-gatewayhigashitsunortonhigashiurawa-mazows" + + "zexnetrentino-alto-adigehigashiyamatokoriyamanashifteditorxn--1l" + + "qs71dhigashiyodogawahigashiyoshinogaris-a-liberalhiraizumisatohm" + + "apartmentshinjournalismailillehammerfeste-iphilipsynology-diskst" + + "ationhirakatashinagawahiranairtrafficplexus-1hirarahiratsukaeruh" + + "irayakagehistorichouseshinjukumamotoyamashikokuchuohitachiomiyag" + + "ildeskaliszhitachiotagoppdalhitraeumtgeradegreehjartdalhjelmelan" + + "dholeckodairaholidayhomegoodshinkamigototalhomeiphoenixn--1qqw23" + + "ahomelinkyard-cloudjiffylkesbiblackbaudcdn-edgestackhero-network" + + "inggroupowiathletajimageandsoundandvision-riopretochigiessensios" + + "itecnologiahomelinuxn--2m4a15ehomeofficehomesecuritymacaparecida" + + "homesecuritypchristmaseratinterhostsolutionsandnessjoenishiwakin" + + "ternationalfirearmsandoyhomesenseeringhomeunixn--2scrj9chromedic" + + "altanissettaishinomakinderoyhondahongotembaixadahonjyoitakasagot" + + "pantheonsitehornindalhorsellsyourhomeftphonefosshinshinotsurgery" + + "hortendofinternet-dnshinshirohospitalhoteleshintokushimahotelwit" + + "hflightshintomikasaharahotmailhoyangerhoylandetroitskypehumaniti" + + "eshinyoshitomiokamishihoronobeauxartsandcraftshiojirishirifujied" + + "ahurdalhurumajis-a-libertarianhyllestadhyogoris-a-linux-usershio" + + "yandexcloudhyugawarahyundaiwafuneis-uberleetrentino-stirolis-ver" + + "y-badajozis-a-painteractivestfoldis-very-evillageis-very-goodyea" + + "ris-very-niceis-very-sweetpepperis-with-thebandownloadisleofmana" + + "ustdaljenv-arubajddarchitecturealtoregontrailroadjeonnamerikawau" + + "ejetztrentino-sud-tiroljevnakershusdecorativeartshisognejewelryj" + + "ewishartgalleryjfkazteleportlligatrentino-sudtiroljgorajlljls-st" + + "o1jls-sto2jls-sto3jmphxn--30rr7yjnjaworznoshiroomgjoyentrentino-" + + "sued-tiroljoyokaichibalashovhadselburgjpnjprshisuifuettertdasnet" + + "zjurkosaigawakosakaerodromegallupaascolipiceno-ipifony-1koseis-a" + + "-photographerokuapphotographysiokosherbrookegawakoshimizumakiyos" + + "emitekoshunantankddiamondshizukuishimofusaitoshimatta-varjjatren" + + "tino-suedtirolkosugekotohiradomainsureggioemiliaromagnamsskogane" + + "is-a-playershiftcryptonomichigangwonkotourakouhokutamakiyosunnda" + + "lkounosupplieshopitsitekouyamashikekouzushimashikizunokunimilita" + + "rykozagawakozakis-a-republicancerresearchaeologicaliforniakozowi" + + "ldlifestylekpnkppspdnshoppingkrasnikahokutokamachintaifun-dnsali" + + "ashopwarendalenugkrasnodarkredstonekrelliankristiansandcatshouji" + + "s-a-rockstarachowicekristiansundkrodsheradkrokstadelvalle-aostat" + + "ic-accesshowakryminamisanrikubetsupportrentinoa-adigekumanottero" + + "ykumatorinow-dnshowtimelhusgardenkumejimasoykumenantokigawakunis" + + "akis-a-socialistdlibestadkunitachiarailwaykunitomigusukuleuvenet" + + "okashikis-a-soxfankunneppubtlshwilliamhillkunstsammlungkunstundd" + + "esignkuokgroupilotsienarviikamiokameokamakurazakitchenkuregruhos" + + "tingkurgankurobeepilepsykkylvenicekurogimimatakatsukis-a-student" + + "alkuroisoftwarezzokuromatsunais-a-teacherkassyno-dshirahamatonbe" + + "tsurnadalkurotakikawasakis-a-techietis-a-llamaritimoldell-oglias" + + "traderkushirogawakustanais-a-therapistoiakusupplynxn--3bst00mina" + + "mitanekutchanelkutnowruzhgorodeokuzumakis-an-accountantshirakoka" + + "miminershiranukamisunagawakvafjordkvalsundkvamlidlugolekadenagah" + + "amaroyerkvanangenkvinesdalkvinnheradkviteseidatingkvitsoykwpspec" + + "truminamiuonumassivegridkzmisconfusedmishimasudamissilewismiller" + + "misugitokorozawamitourismilezajskfh-muenstermitoyoakemiuramiyazu" + + "recontainerdpolicemiyotamanomjondalenmlbfanmontrealestatefarmequ" + + "ipmentrentinoaadigemonza-brianzapposigdalmonza-e-della-brianzapt" + + "okuyamatsumaebashikshacknetrentinoalto-adigemonzabrianzaramonzae" + + "brianzamonzaedellabrianzamoonscaleforcemordoviamoriyamatsumotofu" + + "kemoriyoshiminamiashigaramormonstermoroyamatsunomortgagemoscowin" + + "barclaycards3-external-1moseushistorymosjoenmoskenesilkhakassiam" + + "ossimple-urlmosvikharkivanylvenneslaskerrylogisticshizuokamitsue" + + "moteginowaniigatakamatsukawamoviemovimientokyotangovtrentinoalto" + + "adigemozilla-iotrentinos-tirolmtranbymuginozawaonsenmuikaminoyam" + + "axunispacemukoebenhavnmulhouseoullensvanguardmultibaasirdalmunak" + + "atanemuncienciamuosattemupimientakinouemurmanskharkovaomurotorcr" + + "aftrentinostirolmusashinoharamuseetrentinosud-tirolmuseumverenig" + + "ingmusicarbonia-iglesias-carboniaiglesiascarboniamutsuzawamy-vig" + + "orgemy-wanggouvichurchaseljedugit-pagespeedmobilizeroticagliarik" + + "uzentakataipeidsvolluccaravantaarparochernigovernmentoyosatoyoka" + + "wamyactivedirectorymyasustor-elvdalmycdmycloudnslupskhersonmydat" + + "tolocalhistorymyddnskingmydissentrentinosudtirolmydobisshikis-an" + + "-artistgstagemydroboehringerikemydslzmyeffectrentinosued-tirolmy" + + "fastblogermyfirewallonieruchomoscienceandindustrynmyforuminamiya" + + "mashirokawanabelaudibleasingmyfritzmyftpaccessmolarvikhmelnitski" + + "yamarumorimachidamyhome-servermyjinomykolaivarggatrentinosuedtir" + + "olmymailermymediapcircustomer-ocimdbananarepublic66myokohamamats" + + "udamypepinbarclays3-fips-us-gov-west-1mypetsmushcdn77-sslingmyph" + + "otoshibalatinoipirangalsaceomypicturesnoasakakinokiamypsxn--3ds4" + + "43gmysecuritycamerakermyshopblocksokndalmyshopifyresdalmythic-be" + + "astsolarssonmytis-a-bookkeeperspectakashimarcheapigeelvinckhmeln" + + "ytskyivaporcloudmytuleaprendemasakievennodesabaerobaticketsologn" + + "emyvncistrondheimmobilienissandiegomywireitrentinsud-tirolplatte" + + "rpioneerplazaplcube-serverplumbingoplurinacionalpodhalepodlasiel" + + "laktyubinskiptveterinairealmpmnpodzonepohlpoivronpokerpokrovsknx" + + "-serversicherungpoliticarrdpolitiendapolkowicepoltavalle-d-aosta" + + "ticsomnarvikomaganepomorzeszowindmillponpesaro-urbino-pesarourbi" + + "nopesaromasvuotnaroyponypordenonepornporsangerporsangugeporsgrun" + + "nanyokoshibahikariwanumatakkofuefukihabororosoopoznanpraxis-a-br" + + "uinsfanprdpresidioprgmrprimetelemarkomakiyosatokaizukamikoaniiha" + + "matamakawajimarnardalprincipeprivatizehealthinsuranceprofesional" + + "progressivestnesopotrentinsudtirolpromombetsurfaststacksavannahg" + + "apropertyprotectionprotonetrentinsued-tirolprudentialpruszkowind" + + "owskrakowinnersor-odalprvcyberlevagangaviikanonjis-an-engineerin" + + "gprzeworskogpulawypupippugliapvhagebostadpvtrentinsuedtirolpwcit" + + "adeliverydyndns-iparsanfranciscofreakunemurorangecloudplatform0p" + + "ythonanywherepaircraftingvollolipopittsburghofficialpzqldqotoyoh" + + "ashimotoolsor-varangerqponiatowadaqslgbtrentoyonakagyokutoyakolo" + + "brzegersundqualifioappiwatequickconnectrevisohughesorfoldquicksy" + + "tesorocabalestrandabergamo-siemenscaledogawarabikomaezakirunombr" + + "esciaquipelementsorreisahayakawakamiichikawamisatottoris-an-ente" + + "rtainerqvcitichitosetoeigersundyndns-blogdnsampaleomutashinaindu" + + "striesteamfamberkeleyswidnikkokonoeswiebodzin-butterswiftcoversw" + + "inoujscienceandhistoryswissmarterthanyousynology-dsowatuvalleaos" + + "taverntuxfamilytwmailvevelstadvibo-valentiavibovalentiavideovill" + + "asphinxn--3e0b707evinnicasacamdvrcampinagrandebuilderschmidtre-g" + + "auldalvinnytsiavipsinaappixolinovirginiavirtual-userveexchangevi" + + "rtualcloudvirtualservervirtualuserveftpizzavirtueeldomein-vigorl" + + "icevirtuelvisakegawaviterboknowsitallvivolkenkundenvixn--3hcrj9c" + + "ivilizationisshingucciprianidyndns-mailukowestus2vlaanderenvladi" + + "kavkazimierz-dolnyvladimirvlogintoyonezawavminiservervologdansko" + + "mmunevolvolkswagentspjelkavikomatsushimarylandvolyngdalvoorloper" + + "auniterois-foundationvossevangenvotevotingvotoyonowithyoutubersp" + + "acekitagatargitlaborwiwatsukiyonosegawawixsitewloclawekomorotsuk" + + "agawawmcloudwmflabsrhtritonwnextdirectromsojamisonwoodsideloitte" + + "mpurlworldworse-thandawowiospydebergwpdevcloudwpenginepoweredwph" + + "ostedmailwpmucdnpklabudhabikinokawabarthaebaruericssongdalenvikn" + + "akatsugawawpmudevcdnaccessokamogawawritesthisblogwroclawitdkomon" + + "otogawawtcircleverappspotagerwtfastvps-serveronakasatsunairguard" + + "iannakadomarinedre-eikerwuozuwzmiuwajimaxn--45brj9civilwarmiasak" + + "uchinotsuchiurakawatchesangoxn--45q11clanbibaidarmeniaxn--4gbrim" + + "iningxn--4it168dxn--4it797kongsbergxn--4pvxs4allxn--54b7fta0ccld" + + "mailuroyxn--55qw42gxn--55qx5dxn--5js045dxn--5rtp49clic20001wwwfa" + + "rmsteadyndns-office-on-the-weberxn--5rtq34kongsvingerxn--5su34j9" + + "36bgsgxn--5tzm5gxn--6btw5axn--6frz82gxn--6orx2rxn--6qq986b3xlxn-" + + "-7t0a264clicketcloudcontrolappartintuitoyotapartsanjotoyotomiyaz" + + "akinuyamashinatsukigatakasakitashiobaraxn--80aaa0cvacationsrlxn-" + + "-80adxhksrvaroyxn--80ao21axn--80aqecdr1axn--80asehdbarefootballo" + + "oningjesdalimitediscourses3-sa-east-1xn--80aswgxn--80augustowith" + + "googleapiszxn--8ltr62koninjambylxn--8pvr4uxn--8y0a063axn--90a1af" + + "lakstadaokagakicks-assnasaarlandxn--90a3academiamicable-modemone" + + "yxn--90aeroportalaheadjudaicadaquestorebaselectroandinosaurepbod" + + "ynamic-dnsoruminanoxn--90aishobarakawagoexn--90amcdirxn--90azhyt" + + "omyravendbargainstantcloudfrontdoorlandiscoveryggeehimejiiyamano" + + "uchikuhokuryugasakitanakagusukumodumcpreservationayorovnoceanogr" + + "aphiquemrhcloudishakotanfshostrodawaraustraliamuneues3-ap-southe" + + "ast-1xn--9dbhblg6dietrusteexn--9dbq2axn--9et52uxn--9krt00axn--an" + + "dy-iraxn--aroport-byaotsurreyxn--asky-iraxn--aurskog-hland-jnbar" + + "reauctioncilla-speziaustrheimatunduhrennesoyokoteastasiamusement" + + "dllpages3-ap-southeast-2xn--avery-yuasakuhokksundxn--b-5gaxn--b4" + + "w605ferdxn--balsan-sdtirol-nsbstorfjordxn--bck1b9a5dre4clickrisi" + + "nglesannaniyodogawaxn--bdddj-mrabdxn--bearalvhki-y4axn--berlevg-" + + "jxaxn--bhcavuotna-s4axn--bhccavuotna-k7axn--bidr-5nachikatsuurax" + + "n--bievt-0qa2xn--bjarky-fyasakaiminatoyookanazawaxn--bjddar-ptar" + + "umizusawaxn--blt-elabourxn--bmlo-graingerxn--bod-2naturalhistory" + + "museumcenterxn--bozen-sdtirol-2obanazawaxn--brnny-wuacademy-fire" + + "wall-gatewayxn--brnnysund-m8accident-investigation-aptibleadpage" + + "square7xn--brum-voagatrvestre-slidreportromsakatamayufuelverumin" + + "comcastresinstagingxn--btsfjord-9zaxn--bulsan-sdtirol-nsbarrel-o" + + "f-knowledgeappleborkaracoldwarszawauthordalandds3-ca-central-1xn" + + "--c1avgxn--c2br7gxn--c3s14minnesotaketakazakis-an-actorxn--cck2b" + + "3barrell-of-knowledgecomputerhistoryofscience-fictionfabricafjs3" + + "-us-east-2xn--cckwcxetdxn--cesena-forl-mcbremangerxn--cesenaforl" + + "-i8axn--cg4bkis-gonexn--ciqpnxn--clchc0ea0b2g2a9gcdxn--comunicae" + + "s-v6a2oxn--correios-e-telecomunicaes-ghc29axn--czr694barsycenter" + + "prisesakikonaikawachinaganoharamcoachampionshiphoptobamagazineat" + + "-urlimolisemineu-1xn--czrs0try-snowplowiczest-le-patronxn--czru2" + + "dxn--czrw28barsyonlineustargardiskussionsbereichattanooganordest" + + "e-idcasadelamonedapliernewspaperxn--d1acj3basicservercelliguriau" + + "tomotivelandeportenrittogitsulikes-piedmonticellocalzoneastcoast" + + "aldefenceastus2xn--d1alfaromeoxn--d1atrycloudflareplantationxn--" + + "d5qv7z876clinichofunatoriginstitutemasekd1xn--davvenjrga-y4axn--" + + "djrs72d6uyxn--djty4konskowolayangroupiemontexn--dnna-grajewolter" + + "skluwerxn--drbak-wuaxn--dyry-iraxn--e1a4cliniquenoharavennagasak" + + "indlecznagasukexn--eckvdtc9dxn--efvn9storjcloud-ver-jpchungnamda" + + "lseidfjordyndns-homednsandvikcoromantovalle-daostavangerxn--efvy" + + "88haibarakitahatakanezawaxn--ehqz56nxn--elqq16hair-surveillancex" + + "n--eveni-0qa01gaxn--f6qx53axn--fct429konsulatrobeeldengeluidvare" + + "serve-onlinexn--fhbeiarnxn--finny-yuaxn--fiq228c5hstpetersburgxn" + + "--fiq64basilicataniautoscanadaeguambulancentralus-2xn--fiqs8stre" + + "amscompute-1xn--fiqz9studioxn--fjord-lraxn--fjq720axn--fl-ziaxn-" + + "-flor-jraxn--flw351exn--forl-cesena-fcbsstudynamisches-dnsoundca" + + "stronomy-routerxn--forlcesena-c8axn--fpcrj9c3dxn--frde-grandrapi" + + "dstuff-4-salexn--frna-woaraisaijosoyrovigotsukisofukushimangyshl" + + "akasamatsudopaasnesoddenmarkhangelskjakdnepropetrovskiervaapstei" + + "ermarkonyvelohmusashimurayamarylhurstjordalshalsenxn--frya-hraxn" + + "--fzc2c9e2clintonoshoesannohelplfinancialutskarumaifarsundyndns-" + + "picsanokasaokamikitayamatsurinvestmentsantabarbaraxn--fzys8d69uv" + + "gmailxn--g2xx48clothingdustdataitogakushimotoganewyorkshirebungo" + + "onordkappartyxn--gckr3f0fauskedsmokorsetagayaseralingenoamishira" + + "satogliattis-a-conservativegasaveincloudynufcfanxn--gecrj9cn-nor" + + "thwest-1xn--ggaviika-8ya47hakatanorth-kazakhstanxn--gildeskl-g0a" + + "xn--givuotna-8yasugitpagefrontapplantsolundbeckmpspbar2xn--gjvik" + + "-wuaxn--gk3at1exn--gls-elacaixaxn--gmq050is-into-animeinforumzxn" + + "--gmqw5axn--gnstigbestellen-zvbrplsbxn--3oq18vl8pn36axn--gnstigl" + + "iefern-wobihirosakikamijimatsushigexn--h-2failxn--h1aeghakodatex" + + "n--h1ahnxn--h1alizxn--h2breg3evenestufftoread-booksnesouthcaroli" + + "natalxn--h2brj9c8cngrondarxn--h3cuzk1discountysnestuttgartrogsta" + + "dxn--hbmer-xqaxn--hcesuolo-7ya35basketballfinanzgorzeleccogjovik" + + "aragandaveroykenflfanpachigasakids3-eu-central-1xn--hery-iraxn--" + + "hgebostad-g3axn--hkkinen-5waxn--hmmrfeasta-s4accident-prevention" + + "-k3susakis-bytomaritimekeepingxn--hnefoss-q1axn--hobl-iraxn--hol" + + "tlen-hxaxn--hpmir-xqaxn--hxt814exn--hyanger-q1axn--hylandet-54ax" + + "n--i1b6b1a6a2exn--imr513nxn--indery-fyasuokannamihokkaidovre-eik" + + "erxn--io0a7is-into-carshiraokamitondabayashiogamagoriziaxn--j1ad" + + "platformshangrilaquilanxessomaxn--j1aefbsbxn--12co0c3b4evalled-a" + + "ostaobaomoriguchiharag-cloud-charitychyattorneyagawakayamagnethn" + + "ologyxn--j1ael8batochiokinoshimaintenanceu-2xn--j1amhakonexn--j6" + + "w193gxn--jlq480n2rgxn--jlq61u9w7batsfjordisrechtranakaiwamizawav" + + "ocatanzarowbq-aukraanghkembuchikumagayagawakepnogatagajoboji234l" + + "ima-cityeatselinogradult3l3p0rtatamotorsitestingdyniabruzzoologi" + + "calabamagasakishimabaraogakibichuobiraetnaamesjevuemielnoboribet" + + "sucks3-ap-northeast-1xn--jlster-byatominamidaitomanchesterxn--jr" + + "peland-54axn--jvr189mintereisenxn--k7yn95exn--karmy-yuaxn--kbrq7" + + "oxn--kcrx77d1x4axn--kfjord-iuaxn--klbu-woaxn--klt787dxn--kltp7dx" + + "n--kltx9axn--klty5xn--3pxu8komvuxn--32vp30hagakhanamigawaxn--kol" + + "uokta-7ya57hakubahcavuotnagaivuotnagaokakyotambabyenglandxn--kpr" + + "w13dxn--kpry57dxn--kput3is-into-cartoonshiratakahagithubusercont" + + "entrentino-altoadigexn--krager-gyatsukanoyaltakasugais-into-game" + + "ssinazawaxn--kranghke-b0axn--krdsherad-m8axn--krehamn-dxaxn--krj" + + "ohka-hwab49jdevcloudfunctionshishikuis-a-patsfanxn--ksnes-uuaxn-" + + "-kvfjord-nxaxn--kvitsy-fyatsushiroxn--kvnangen-k0axn--l-1fairwin" + + "dsusonoxn--l1accentureklamborghinikolaeventsuzakanagawaxn--lahea" + + "dju-7yawaraxn--langevg-jxaxn--lcvr32dxn--ldingen-q1axn--leagavii" + + "ka-52bauhausposts-and-telecommunicationsncfditchyouripalmsprings" + + "akerxn--lesund-huaxn--lgbbat1ad8jdfastlylbanzaicloudappspaceuser" + + "contentatsunobninskanzakiwielunnereviewsaitamatsukuribmdevelopme" + + "ntattoolforgerockartuzyolasitebinordre-landgcanonoichinomiyakebi" + + "zenakanotoddenavuotnarashinobserverevistarnbergjerstadotsuruokak" + + "amigaharaustinnavigationavoizumizakibigawamswatch-and-clockeretr" + + "osnubaltimore-og-romsdalpha-myqnapcloud66xn--lgrd-poacctrysiljan" + + "xn--lhppi-xqaxn--linds-pramericanartunespeedpartnersortlandxn--l" + + "ns-qlavagiskexn--loabt-0qaxn--lrdal-sraxn--lrenskog-54axn--lt-li" + + "acnpyatigorskodjeepsondriodejaneirodoyxn--lten-granexn--lury-ira" + + "xn--m3ch0j3axn--mely-iraxn--merker-kuaxn--mgb2ddesuzukananiikapp" + + "uboliviajessheimpertrixcdn77-secureggiocalabriaxn--mgb9awbfbx-os" + + "trowwlkpmgujoinvilleirvikashiwazakiyokawaraxn--mgba3a3ejtunkommu" + + "nalforbundxn--mgba3a4f16axn--mgba3a4fra1-deltaiwanairforcechirea" + + "dthedocscbgxn--mgba7c0bbn0axn--mgbaakc7dvfbxosaves-the-whalessan" + + "dria-trani-barletta-andriatranibarlettaandriaxn--mgbaam7a8hakuis" + + "-a-hard-workershimokitayamayfirstockholmestrandxn--mgbab2bdxn--m" + + "gbah1a3hjkrdxn--mgbai9a5eva00bellunord-frontierxn--mgbai9azgqp6j" + + "ejuniperxn--mgbayh7gpalermomahachijolsterxn--mgbbh1a71exn--mgbc0" + + "a9azcgxn--mgbca7dzdoxn--mgbcpq6gpa1axn--mgberp4a5d4a87gxn--mgber" + + "p4a5d4arxn--mgbgu82axn--mgbi4ecexposedxn--mgbpl2fhskydivingxn--m" + + "gbqly7c0a67fbcnsantacruzsewhalingrongausdaluxuryxn--mgbqly7cvafr" + + "-1xn--mgbt3dhdxn--mgbtf8flapymnturystykaneyamazoexn--mgbtx2benev" + + "entodayombolzano-altoadigeometre-experts-comptables3-us-gov-west" + + "-1xn--mgbx4cd0abbvieeexn--mix082fedorainfraclouderaxn--mix891fed" + + "orapeoplegallodingenxn--mjndalen-64axn--mk0axin-dsldxn--mk1bu44c" + + "ntoyotsukaidoxn--mkru45is-leetrentino-s-tirolxn--mlatvuopmi-s4ax" + + "n--mli-tlavangenxn--mlselv-iuaxn--moreke-juaxn--mori-qsakuragawa" + + "xn--mosjen-eyawatahamaxn--mot-tlazioxn--mre-og-romsdal-qqbuseran" + + "ishiaritakurashikis-lostre-toteneis-a-nursembokukitauraxn--msy-u" + + "la0hakusanagochijiwadefinimamateramobaraxn--mtta-vrjjat-k7afedor" + + "aprojectrani-andria-barletta-trani-andriaxn--muost-0qaxn--mxtq1m" + + "isakis-an-actresshiraois-a-musicianxn--ngbc5azdxn--ngbe9e0axn--n" + + "gbrxn--41axn--nit225kooris-a-personaltrainerxn--nmesjevuemie-tcb" + + "alsan-sudtirollagdenesnaaseinet-freaksuzukis-certifiedunetlifyis" + + "-a-nascarfanxn--nnx388axn--nodessakurais-not-certifiedxn--nqv7fs" + + "00emaxn--nry-yla5gxn--ntso0iqx3axn--ntsq17gxn--nttery-byaeserveg" + + "ame-serverxn--nvuotna-hwaxn--nyqy26axn--o1achernihivgubsvalbardu" + + "nloppacificivilaviationissayokkaichiropractichocolatelevisionthe" + + "wifiatmparmatsuzakinfinitintelligencexn--o3cw4haldenxn--o3cyx2ax" + + "n--od0algxn--od0aq3bentleyomitanocelotenkawavoues3-eu-west-1xn--" + + "ogbpf8flatangerxn--oppegrd-ixaxn--ostery-fyaxn--osyro-wuaxn--otu" + + "796dxn--p1acfeiraquarelleaseeklogesavonarutolgaxn--p1ais-savedxn" + + "--pgbs0dhlxn--porsgu-sta26fermochizukirkenesaxoxn--pssu33lxn--ps" + + "sy2uxn--q7ce6axn--q9jyb4collectionxn--qcka1pmckinseyxn--qqqt11mi" + + "sasaguris-an-anarchistoricalsocietyxn--qxa6axn--qxamsterdamnserv" + + "erbaniaxn--rady-iraxn--rdal-poaxn--rde-ulaxn--rdy-0nabaris-slick" + + "autokeinoticeablevangerxn--rennesy-v1axn--rhkkervju-01aferraraxn" + + "--rholt-mragowoltlab-democraciaxn--rhqv96gxn--rht27zxn--rht3dxn-" + + "-rht61exn--risa-5naturalsciencesnaturellesvcivilisationissedaluc" + + "ernexn--risr-iraxn--rland-uuaxn--rlingen-mxaxn--rmskog-byaxn--rn" + + "y31halsaintlouis-a-anarchistoireggio-emilia-romagnakayamannorthf" + + "lankatsushikabeebyteapplinzis-a-hunterxn--rovu88beppublishproxyo" + + "nagoyaxarnetflixilovecollegefantasyleaguernseyokozeatonsbergivin" + + "gjemnes3-eu-west-2xn--rros-granvindafjordxn--rskog-uuaxn--rst-0n" + + "aturbruksgymnxn--rsta-framercanvasveioxn--rvc1e0am3exn--ryken-vu" + + "axn--ryrvik-byaxn--s-1faithammarfeastafricapitalonewportrentino-" + + "a-adigexn--s9brj9colognexus-3xn--sandnessjen-ogbeskidyn-ip24xn--" + + "sandy-yuaxn--sdtirol-n2axn--seral-lraxn--ses554gxn--sgne-graphox" + + "n--42c2d9axn--skierv-utazasvelvikomforbarcelonagawakuyachimataij" + + "iitatebayashiibahccavuotnagaragusarts3-eu-west-3utilities-1xn--s" + + "kjervy-v1axn--skjk-soaxn--sknit-yqaxn--sknland-fxaxn--slat-5natu" + + "rhistorischesvizzeraxn--slt-elabcn-north-1xn--smla-hraxn--smna-g" + + "ratangentlentapisa-geekopervikazunoticiashitaramaxn--snase-nraxn" + + "--sndre-land-0cbestbuyshouses3-us-west-1xn--snes-poaxn--snsa-roa" + + "xn--sr-aurdal-l8axn--sr-fron-q1axn--sr-odal-q1axn--sr-varanger-g" + + "gbetainaboxfusejnyanagawalmartaxihuanhktcmembers3-us-west-2xn--s" + + "rfold-byaxn--srreisa-q1axn--srum-gratis-a-bulls-fanxn--stfold-9x" + + "axn--stjrdal-s1axn--stjrdalshalsen-sqbhzcasertairaholtalenhlfanh" + + "s3-website-ap-northeast-1xn--stre-toten-zcbieidskoguchikuzenviro" + + "nmentalconservationionjukudoyamaizuruhrxn--t60b56axn--tckwebthin" + + "gsvn-reposouthwest1-uslivinghistoryxn--tiq49xqyjelasticbeanstalk" + + "azoologyxn--tjme-hraxn--tn0agrinetbankoryokamikawanehonbetsuruta" + + "haraxn--tnsberg-q1axn--tor131oxn--trany-yuaxn--trentin-sd-tirol-" + + "rzbielawaltervistainaioirasebastopologyeongnamegawafaicloudinebr" + + "askaunicommbankarasjohkameyamatotakadazurewebsiteshikagamiishibu" + + "kawakkanaibetsubamericanfamilydsmynasushiobaracingjerdrumcpebets" + + "uikiraurskog-holandingivestbytemark12xn--trentin-sdtirol-7vbiell" + + "ahppiacenzachpomorskienikonanporocpanamatsuuraxn--trentino-sd-ti" + + "rol-c3bieszczadygeyachiyodaejeonbukcoalwaysdatabaseballangenkain" + + "anaejrietisalatinabenonicasinorddalivornowtv-infolldalombardiade" + + "mbroideryonagunicloudivtasvuodnakamagayahooguyoriikarasjokarasuy" + + "amarriottcp4xn--trentino-sdtirol-szbievat-band-campaniaxn--trent" + + "inosd-tirol-rzbifukagawashingtondclk3xn--trentinosdtirol-7vbigva" + + "lledaostargetmyipanasonicateringebuildingladedyn-berlincolninohe" + + "kinannestadivttasvuotnakamuratajimidsundiyoshiokanumazuryukin-th" + + "e-bandain-vpncatholicaxiaskimitsubatamibudejjuedischesapeakebaye" + + "rnuorochesterxn--trentinsd-tirol-6vbihorologyukuhashimoichinosek" + + "igaharaxn--trentinsdtirol-nsbikedaemonmoutheworkpccweddinglassas" + + "sinationalheritagets-itgoryurihonjournalistjohninomiyakonojorpel" + + "andrangedalombardynalias3-website-ap-southeast-1xn--trgstad-r1ax" + + "n--trna-woaxn--troms-zuaxn--tysvr-vraxn--uc0atvestre-totennishia" + + "wakuraxn--uc0ay4axn--uist22hamurakamigoris-a-knightpointtohnosho" + + "ooshikamaishimodatexn--uisz3gxn--unjrga-rtashkentuscanyxn--unup4" + + "yxn--uuwu58axn--vads-jraxn--valle-aoste-ebbtushuissier-justicexn" + + "--valle-d-aoste-ehbodoes-itvedestrandxn--valleaoste-e7axn--valle" + + "daoste-ebbvadsobetsuitaikikuchikuseihicampobassociatest-iserveco" + + "unterstrikeymachinewhampshirealtydalvdalaskanittedallasalleangav" + + "iikaasdaburxn--vard-jraxn--vegrshei-c0axn--vermgensberater-ctbit" + + "swidnicartoonartdecologiaxn--vermgensberatung-pwblogoiplatter-ap" + + "pinkhplaystation-cloudyclusterxn--vestvgy-ixa6oxn--vg-yiabkhazia" + + "xn--vgan-qoaxn--vgsy-qoa0jelenia-goraxn--vgu402colonialwilliamsb" + + "urgrossetouchihayaakasakawaharaxn--vhquvestvagoyxn--vler-qoaxn--" + + "vre-eiker-k8axn--vrggt-xqadxn--vry-yla5gxn--vuq861bilbaokinawash" + + "irosatobishimagentositechnologyusuharaxn--w4r85el8fhu5dnraxn--w4" + + "rs40lxn--wcvs22dxn--wgbh1coloradoplateaudiopsysantafedjeffersonx" + + "n--wgbl6axn--xhq521billustrationredumbrellair-traffic-controlley" + + "usuisservehalflifeinsuranceu-3xn--xkc2al3hye2axn--xkc2dl3a5ee0ha" + + "ndsonyxn--y9a3aquariumisawaxn--yer-znatuurwetenschappenginexn--y" + + "fro4i67oxn--ygarden-p1axn--ygbi2ammxn--45br5cylxn--ystre-slidre-" + + "ujbioddaxn--zbx025dxn--zf0ao64axn--zf0avxlxn--zfr164biparachutin" + + "gleezeu-4xnbayxz" + +// nodes is the list of nodes. Each node is represented as a uint32, which +// encodes the node's children, wildcard bit and node type (as an index into +// the children array), ICANN bit and text. +// +// If the table was generated with the -comments flag, there is a //-comment +// after each node's data. In it is the nodes-array indexes of the children, +// formatted as (n0x1234-n0x1256), with * denoting the wildcard bit. The +// nodeType is printed as + for normal, ! for exception, and o for parent-only +// nodes that have children but don't match a domain label in their own right. +// An I denotes an ICANN domain. +// +// The layout within the uint32, from MSB to LSB, is: +// [ 0 bits] unused +// [10 bits] children index +// [ 1 bits] ICANN bit +// [15 bits] text index +// [ 6 bits] text length +var nodes = [...]uint32{ + 0x329b43, + 0x2f0784, + 0x31f886, + 0x21a5c3, + 0x21a5c6, + 0x399386, + 0x3bf783, + 0x277104, + 0x2029c7, + 0x31f4c8, + 0x1a000c2, + 0x1f3cd07, + 0x37f349, + 0x2ddb4a, + 0x2ddb4b, + 0x23d883, + 0x23f745, + 0x2202ac2, + 0x28c4c4, + 0x2c9743, + 0x3734c5, + 0x2602c02, + 0x354743, + 0x2a85584, + 0x374945, + 0x2e0f242, + 0x229d8e, + 0x260543, + 0x3b9946, + 0x3205b42, + 0x378ac7, + 0x242446, + 0x36041c2, + 0x293b03, + 0x232946, + 0x38ec88, + 0x298246, + 0x359944, + 0x3a00ac2, + 0x34b549, + 0x22d607, + 0x2094c6, + 0x3679c9, + 0x224748, + 0x210204, + 0x2f9546, + 0x207b46, + 0x3e03742, + 0x239b06, + 0x216b8f, + 0x3cd40e, + 0x22ff04, + 0x311205, + 0x32dbc5, + 0x3aec89, + 0x2494c9, + 0x233147, + 0x221b46, + 0x21da43, + 0x420b602, + 0x233843, + 0x2b200a, + 0x4602043, + 0x3402c5, + 0x30c842, + 0x3ab409, + 0x4e00ec2, + 0x207e84, + 0x346706, + 0x2c54c5, + 0x376bc4, + 0x5646644, + 0x2030c3, + 0x23a844, + 0x5a00b82, + 0x3e3104, + 0x5f35d04, + 0x3e1b0a, + 0x6200882, + 0x2b82c7, + 0x36f9c8, + 0x7a01e02, + 0x335087, + 0x2f5404, + 0x2f5407, + 0x3ea985, + 0x381247, + 0x340886, + 0x349f84, + 0x3544c5, + 0x26d147, + 0x9205202, + 0x239c83, + 0x961a7c2, + 0x3b6143, + 0x9a04142, + 0x26e645, + 0x9e00202, + 0x379b84, + 0x239305, + 0x22fe47, + 0x2f78ce, + 0x2c4ac4, + 0x219684, + 0x207e43, + 0x3bc989, + 0x2e700b, + 0x2f8288, + 0x32acc8, + 0x330248, + 0x3d0bc8, + 0xa36780a, + 0x381147, + 0x3d7f06, + 0xa61a602, + 0x271d03, + 0x3dfa43, + 0x3e1204, + 0x271d43, + 0x396303, + 0x17385c2, + 0xaa02b82, + 0x28ffc5, + 0x266446, + 0x2a59c4, + 0x3a94c7, + 0x24f486, + 0x2d64c4, + 0x3c13c7, + 0x2194c3, + 0xb6e29c2, + 0xbb27082, + 0xbe27bc2, + 0x227bc6, + 0xc200282, + 0x269185, + 0x339b03, + 0x3d9704, + 0x2fe784, + 0x2fe785, + 0x3ef083, + 0xc658843, + 0xca06f02, + 0x20d3c5, + 0x20d3cb, + 0x20e18b, + 0x2045c4, + 0x20d7c9, + 0x20fcc4, + 0xce10602, + 0x210e43, + 0x2113c3, + 0xd20a182, + 0x21e78a, + 0xd602a02, + 0x28c745, + 0x2f348a, + 0x2510c4, + 0x212a43, + 0x213104, + 0x2151c3, + 0x2151c4, + 0x2151c7, + 0x217005, + 0x217c06, + 0x2183c6, + 0x21a643, + 0x21ffc8, + 0x213743, + 0xda037c2, + 0x230d08, + 0x2984cb, + 0x2284c8, + 0x229146, + 0x22a187, + 0x22d208, + 0xf205f42, + 0xf6272c2, + 0x27c848, + 0x2370c7, + 0x314b85, + 0xfb14b88, + 0xfe23848, + 0x2551c3, + 0x2319c4, + 0x399402, + 0x10232002, + 0x106083c2, + 0x10e32382, + 0x232383, + 0x11203702, + 0x30e183, + 0x220ec4, + 0x207243, + 0x2101c4, + 0x24f18b, + 0x203703, + 0x2fa346, + 0x28cfc4, + 0x2d06ce, + 0x384b05, + 0x277848, + 0x3b9a47, + 0x3b9a4a, + 0x223203, + 0x2f0587, + 0x2e71c5, + 0x238b84, + 0x25fc86, + 0x25fc87, + 0x36d4c4, + 0x117145c4, + 0x3c5a04, + 0x24ed84, + 0x3d1606, + 0x224dc3, + 0x3d5608, + 0x3d7348, + 0x29e303, + 0x21e743, + 0x343a04, + 0x356943, + 0x11e035c2, + 0x122b79c2, + 0x202546, + 0x2f9643, + 0x3b2fc4, + 0x12648fc2, + 0x29ed03, + 0x381a43, + 0x21ce82, + 0x12a02102, + 0x2dd246, + 0x21e247, + 0x36f747, + 0x2ef505, + 0x348b84, + 0x2fbb05, + 0x2d1bc7, + 0x2ba349, + 0x2bbdc6, + 0x2ef406, + 0x13a12fc2, + 0x318508, + 0x321246, + 0x30a6c5, + 0x309f47, + 0x310244, + 0x310245, + 0x373104, + 0x373108, + 0x13e0d482, + 0x14200482, + 0x254206, + 0x200488, + 0x328205, + 0x34c246, + 0x34ea08, + 0x35d3c8, + 0x14602cc5, + 0x17243244, + 0x285687, + 0x1760f742, + 0x17ab90c2, + 0x18e05842, + 0x346805, + 0x19a96945, + 0x277e86, + 0x3b6547, + 0x3ba447, + 0x19e29f43, + 0x33f007, + 0x3cc1c8, + 0x27635149, + 0x229f47, + 0x235887, + 0x342548, + 0x236086, + 0x238686, + 0x23b74c, + 0x23cd0a, + 0x23d8c7, + 0x23f60b, + 0x240307, + 0x24030e, + 0x27a40ec4, + 0x241284, + 0x244887, + 0x253c47, + 0x248706, + 0x248707, + 0x32b4c7, + 0x261c03, + 0x27e0f1c2, + 0x249ec6, + 0x249eca, + 0x24ab0b, + 0x24c887, + 0x24d305, + 0x24d783, + 0x24df46, + 0x24df47, + 0x38f183, + 0x28200102, + 0x24eaca, + 0x28729c42, + 0x28ba8ac2, + 0x28e48e02, + 0x29238fc2, + 0x251805, + 0x252204, + 0x29e01bc2, + 0x3e3185, + 0x24b103, + 0x2a4585, + 0x202444, + 0x216384, + 0x2dfb06, + 0x2608c6, + 0x20d5c3, + 0x3d4804, + 0x340b43, + 0x2ae00d02, + 0x22a504, + 0x22a506, + 0x257a85, + 0x2b5a46, + 0x30a048, + 0x2138c4, + 0x31de08, + 0x38ea45, + 0x281d88, + 0x2d9f06, + 0x21ba87, + 0x27f784, + 0x2c27f786, + 0x2c605483, + 0x3ac1c3, + 0x2cc488, + 0x333444, + 0x2ca131c7, + 0x24c106, + 0x2f1289, + 0x366948, + 0x330988, + 0x332384, + 0x3d69c3, + 0x24b1c2, + 0x2d25d9c2, + 0x2d61c982, + 0x31f383, + 0x2da02b02, + 0x38f104, + 0x288c46, + 0x23eb43, + 0x2cd707, + 0x385d43, + 0x2c4b88, + 0x229545, + 0x26c9c3, + 0x239285, + 0x2393c4, + 0x3a6f86, + 0x22bb06, + 0x22fd86, + 0x25db84, + 0x2406c3, + 0x2de46882, + 0x2e23fd85, + 0x200843, + 0x2ea03402, + 0x220203, + 0x205a45, + 0x2ee24d03, + 0x2f63e6c9, + 0x2fa00942, + 0x30204f42, + 0x29bc85, + 0x21ecc6, + 0x29d146, + 0x308d88, + 0x308d8b, + 0x345ecb, + 0x38a445, + 0x2e2f49, + 0x1602642, + 0x31fb88, + 0x20dac4, + 0x30a03642, + 0x33dfc3, + 0x31253e06, + 0x3160ea82, + 0x3d11c8, + 0x31a06cc2, + 0x26f54a, + 0x322771c3, + 0x32b7f986, + 0x315d88, + 0x398846, + 0x3957c7, + 0x216d87, + 0x2076ca, + 0x251144, + 0x364a84, + 0x37ee49, + 0x32fb9585, + 0x229dc6, + 0x22e783, + 0x282a04, + 0x3320a6c4, + 0x20a6c7, + 0x33656c07, + 0x29ed44, + 0x2400c5, + 0x277f48, + 0x252d07, + 0x252f87, + 0x33a18b02, + 0x3a8084, + 0x2a51c8, + 0x2547c4, + 0x259344, + 0x259745, + 0x259887, + 0x34689bc9, + 0x25a444, + 0x25b309, + 0x25b9c8, + 0x25c604, + 0x25c607, + 0x25d7c3, + 0x25e587, + 0x34a00c02, + 0x16c7402, + 0x25f746, + 0x2bf047, + 0x2600c4, + 0x261687, + 0x263287, + 0x263883, + 0x34e62642, + 0x213802, + 0x2649c3, + 0x2649c4, + 0x2649cb, + 0x32adc8, + 0x213804, + 0x265e85, + 0x2676c7, + 0x2f4d05, + 0x31b2ca, + 0x26ac43, + 0x35202e42, + 0x215a44, + 0x271f49, + 0x275843, + 0x275907, + 0x330689, + 0x3929c8, + 0x20f283, + 0x28f107, + 0x27e1c3, + 0x295f04, + 0x2975c9, + 0x29a286, + 0x3a3f03, + 0x202a82, + 0x26dc83, + 0x2c7207, + 0x39a245, + 0x2ca6c6, + 0x29e6c4, + 0x37bf05, + 0x28fa83, + 0x21c186, + 0x218143, + 0x20d9c2, + 0x258804, + 0x356a5c02, + 0x35b10a03, + 0x35e038c2, + 0x2574c3, + 0x218844, + 0x242047, + 0x21f406, + 0x20a682, + 0x36204682, + 0x330bc4, + 0x36a15342, + 0x36e05d02, + 0x205d04, + 0x205d05, + 0x3ce545, + 0x3b6ec6, + 0x37208442, + 0x3d5a05, + 0x3d9e45, + 0x296883, + 0x239d46, + 0x212005, + 0x227b42, + 0x35d005, + 0x227b44, + 0x230783, + 0x2309c3, + 0x3760ccc2, + 0x26d347, + 0x267884, + 0x267889, + 0x282904, + 0x2967c3, + 0x2c3e48, + 0x37a967c4, + 0x2967c6, + 0x2b5543, + 0x266803, + 0x2e9c43, + 0x37f003c2, + 0x392ec2, + 0x38200642, + 0x33b848, + 0x213508, + 0x3c4846, + 0x2916c5, + 0x234b85, + 0x209fc7, + 0x3868a905, + 0x21e682, + 0x38aa71c2, + 0x38e00042, + 0x321ec8, + 0x318445, + 0x302d04, + 0x24da05, + 0x2562c7, + 0x295d04, + 0x262442, + 0x3922cf82, + 0x351b84, + 0x230607, + 0x29c207, + 0x381204, + 0x3e0443, + 0x29e244, + 0x29e248, + 0x396389c6, + 0x25fb0a, + 0x35b6c4, + 0x2a4c08, + 0x23ff44, + 0x22a286, + 0x2a7184, + 0x346b06, + 0x267b49, + 0x223d07, + 0x3a6c43, + 0x39a04d02, + 0x3c3943, + 0x210802, + 0x39e0a442, + 0x26e406, + 0x24bc88, + 0x2b6347, + 0x233549, + 0x2b6509, + 0x2b9a05, + 0x2bb609, + 0x2bc705, + 0x2bd545, + 0x2be748, + 0x3a207304, + 0x3a634307, + 0x235c43, + 0x2be947, + 0x235c46, + 0x2bf5c7, + 0x2b4445, + 0x2354c3, + 0x3aa3cac2, + 0x212c84, + 0x3ae05302, + 0x3b21d7c2, + 0x30db46, + 0x36f945, + 0x2c2507, + 0x383d03, + 0x238404, + 0x20f583, + 0x236e03, + 0x3b603842, + 0x3be075c2, + 0x399484, + 0x262603, + 0x308a45, + 0x3c209c42, + 0x3ca08102, + 0x39f646, + 0x2f7804, + 0x2fd3c4, + 0x2fd3ca, + 0x3d2005c2, + 0x203e83, + 0x310f0a, + 0x3a8488, + 0x3d658104, + 0x2005c3, + 0x249bc3, + 0x34c689, + 0x27ddc9, + 0x2cd806, + 0x3da5e043, + 0x2baf8d, + 0x328846, + 0x35c70b, + 0x3de0f002, + 0x2f9388, + 0x42a200c2, + 0x42e019c2, + 0x2c0c85, + 0x43203382, + 0x2b2507, + 0x2121c3, + 0x2121c8, + 0x43605fc2, + 0x39ec44, + 0x3e0643, + 0x24b206, + 0x2274c4, + 0x21e703, + 0x44a06702, + 0x38a3c4, + 0x2c6045, + 0x2c6e07, + 0x28d743, + 0x2c7dc3, + 0x161a742, + 0x2c8483, + 0x2c8803, + 0x44e00c42, + 0x276f44, + 0x2408c6, + 0x328cc3, + 0x2c8c83, + 0x45258e02, + 0x258e08, + 0x2c9a44, + 0x204ec6, + 0x393047, + 0x2a2046, + 0x2cc404, + 0x53604842, + 0x235b0b, + 0x2e894e, + 0x21fa8f, + 0x2e1803, + 0x53e6dc42, + 0x161d942, + 0x54203e42, + 0x2a94c3, + 0x28d243, + 0x2bc506, + 0x34efc6, + 0x2d8bc7, + 0x3835c4, + 0x5461ee02, + 0x54a17682, + 0x240d85, + 0x31a707, + 0x2cb806, + 0x54e78102, + 0x38d184, + 0x2d12c3, + 0x55208042, + 0x5577c743, + 0x2d2684, + 0x2d8149, + 0x55adfe42, + 0x55e19f42, + 0x254b45, + 0x562e0602, + 0x56a065c2, + 0x362607, + 0x37f5cb, + 0x216b45, + 0x2610c9, + 0x268b06, + 0x56e08484, + 0x208489, + 0x36e507, + 0x3e2d07, + 0x225903, + 0x2f9206, + 0x352a87, + 0x21b643, + 0x2ab186, + 0x5762cbc2, + 0x57a2b342, + 0x215703, + 0x3ab5c5, + 0x223b47, + 0x241886, + 0x39a1c5, + 0x267804, + 0x2b3985, + 0x30c904, + 0x57e04442, + 0x2deb84, + 0x2d1084, + 0x3ec38d, + 0x2d1089, + 0x25c088, + 0x267384, + 0x209c05, + 0x32b287, + 0x3470c4, + 0x3d5d07, + 0x242f45, + 0x582b7144, + 0x2b2b85, + 0x20c444, + 0x3c8586, + 0x3b6345, + 0x58601a82, + 0x22b303, + 0x3018c3, + 0x244bc4, + 0x244bc5, + 0x386dc6, + 0x255d45, + 0x2680c4, + 0x58b0b703, + 0x58e12686, + 0x222705, + 0x222bc5, + 0x3b6444, + 0x2fde43, + 0x35b74c, + 0x592c5b02, + 0x59601742, + 0x59a0b982, + 0x2280c3, + 0x2280c4, + 0x59e0fd02, + 0x3619c8, + 0x227904, + 0x396a86, + 0x5a22d442, + 0x5a609cc2, + 0x5aa00b42, + 0x28ae85, + 0x286446, + 0x35bc04, + 0x232e86, + 0x211c46, + 0x2097c3, + 0x5ae99c0a, + 0x296705, + 0x2b1fc3, + 0x20e986, + 0x5b20e989, + 0x22a9c7, + 0x3d3048, + 0x224609, + 0x2ba4c8, + 0x2503c6, + 0x208143, + 0x5b602c82, + 0x3adb08, + 0x5ba54902, + 0x5be026c2, + 0x2335c3, + 0x2f7305, + 0x24c284, + 0x245489, + 0x238dc4, + 0x2472c8, + 0x5c610843, + 0x5ca643c4, + 0x21ed08, + 0x5ce08f02, + 0x23f002, + 0x32db45, + 0x270a09, + 0x219c03, + 0x319ac4, + 0x376504, + 0x267c43, + 0x29190a, + 0x5d20bdc2, + 0x5d612ac2, + 0x2e2943, + 0x39c503, + 0x1635002, + 0x271503, + 0x5da1dfc2, + 0x5de0dec2, + 0x5e292e44, + 0x292e46, + 0x27e5c4, + 0x28bc83, + 0x3d8d43, + 0x5e706943, + 0x24ae86, + 0x32df05, + 0x2e6707, + 0x2e6646, + 0x2e6c08, + 0x2e6e06, + 0x20dec4, + 0x2abf8b, + 0x2e9703, + 0x2e9705, + 0x226e42, + 0x362902, + 0x5ea51882, + 0x5ee0f782, + 0x21ee43, + 0x5f27eec2, + 0x27eec3, + 0x2ea783, + 0x5fa03b02, + 0x5feedcc6, + 0x29d686, + 0x60246542, + 0x60611402, + 0x60a30a02, + 0x60e05582, + 0x6120d082, + 0x61604342, + 0x21a083, + 0x3b6006, + 0x61a22d84, + 0x33bc86, + 0x28d5c4, + 0x20a383, + 0x62603bc2, + 0x2048c2, + 0x2350c3, + 0x62a127c3, + 0x3c97c7, + 0x3b6247, + 0x67e582c7, + 0x348507, + 0x2166c3, + 0x68277a44, + 0x31d704, + 0x31d70a, + 0x3ba585, + 0x6863b542, + 0x261643, + 0x68a00602, + 0x25c743, + 0x3c3903, + 0x69200582, + 0x3cc144, + 0x20a1c4, + 0x3cf585, + 0x32c5c5, + 0x2fd606, + 0x3a7586, + 0x69616602, + 0x69a01242, + 0x2f9bc5, + 0x29d392, + 0x2af9c6, + 0x209843, + 0x2dd486, + 0x3d19c5, + 0x161e7c2, + 0x71e09f02, + 0x209f03, + 0x211683, + 0x3a5bc3, + 0x72214542, + 0x21d343, + 0x7261c682, + 0x249c83, + 0x3856c8, + 0x25d543, + 0x2b9886, + 0x3e8dc7, + 0x34d686, + 0x34d68b, + 0x28d507, + 0x30b684, + 0x72e07c42, + 0x2ca605, + 0x73212783, + 0x22d043, + 0x3c7445, + 0x2165c3, + 0x73a165c6, + 0x3ddfc3, + 0x20f0c4, + 0x2003c6, + 0x30aac6, + 0x73e1f483, + 0x2382c7, + 0x34c587, + 0x2ad945, + 0x31cec6, + 0x21a683, + 0x76ac9683, + 0x76e00a82, + 0x7723e044, + 0x3d5409, + 0x218b85, + 0x30a444, + 0x388b08, + 0x328b05, + 0x7775e205, + 0x24d489, + 0x209583, + 0x3d9c04, + 0x77a0f102, + 0x21f043, + 0x77e78302, + 0x278306, + 0x162e6c2, + 0x782135c2, + 0x28ad88, + 0x29e203, + 0x2b2ac7, + 0x2bd9c5, + 0x2cb045, + 0x2cb48b, + 0x2f8f86, + 0x2cb686, + 0x27ea44, + 0x215506, + 0x786f9788, + 0x293ec3, + 0x26b483, + 0x26b484, + 0x3e5004, + 0x2fe047, + 0x316985, + 0x78b1f402, + 0x78e06582, + 0x79606585, + 0x298f04, + 0x3e514b, + 0x2fe688, + 0x253b44, + 0x79a58e42, + 0x79e53ac2, + 0x3d72c3, + 0x2ff984, + 0x2ffc45, + 0x3006c7, + 0x7a302844, + 0x381304, + 0x7a602782, + 0x3885c9, + 0x303d45, + 0x216e05, + 0x3045c5, + 0x7aa02783, + 0x244084, + 0x24408b, + 0x305d44, + 0x30600b, + 0x306885, + 0x21fbca, + 0x307048, + 0x30724a, + 0x307ac3, + 0x307aca, + 0x7b2189c2, + 0x7b685042, + 0x7baa31c3, + 0x7bed2102, + 0x309ec3, + 0x7c30afc2, + 0x7c73a282, + 0x30c584, + 0x220106, + 0x232bc5, + 0x3101c3, + 0x3cdb06, + 0x20ef45, + 0x255884, + 0x7ca00902, + 0x2a1b84, + 0x2e2bca, + 0x2c5747, + 0x3e26c6, + 0x24eec7, + 0x249f03, + 0x2d26c8, + 0x3eb80b, + 0x2282c5, + 0x376645, + 0x376646, + 0x2fd9c4, + 0x21cb08, + 0x207a43, + 0x207a44, + 0x207a47, + 0x30b2c6, + 0x33e886, + 0x2d050a, + 0x25b384, + 0x27d94a, + 0x7cf83846, + 0x383847, + 0x265f07, + 0x2696c4, + 0x2696c9, + 0x220a45, + 0x36e343, + 0x22bcc3, + 0x7d225f83, + 0x298ac4, + 0x7d600682, + 0x2f08c6, + 0x7dad3105, + 0x2dd6c5, + 0x245d86, + 0x2c8b44, + 0x7de01082, + 0x245e84, + 0x7e209942, + 0x237a05, + 0x3c78c4, + 0x7f62cac3, + 0x7fa116c2, + 0x2116c3, + 0x21d486, + 0x7fe01782, + 0x32d608, + 0x22a844, + 0x22a846, + 0x39cd86, + 0x80267784, + 0x21fe05, + 0x243148, + 0x255547, + 0x350587, + 0x35058f, + 0x2a50c6, + 0x248083, + 0x24d684, + 0x215c83, + 0x22a3c4, + 0x3acac4, + 0x80608382, + 0x2b76c3, + 0x337703, + 0x80a036c2, + 0x2036c3, + 0x38f1c3, + 0x21708a, + 0x314d47, + 0x25cbcc, + 0x25ce86, + 0x25e406, + 0x262287, + 0x80e65507, + 0x269d89, + 0x81230e44, + 0x81a1ee82, + 0x81e033c2, + 0x2d08c6, + 0x2380c4, + 0x38c746, + 0x26cb88, + 0x3ab684, + 0x32ea46, + 0x29d105, + 0x82280408, + 0x24e043, + 0x282ac5, + 0x396603, + 0x216f03, + 0x216f04, + 0x215a03, + 0x82639d02, + 0x82a04082, + 0x36e209, + 0x28ac85, + 0x28af84, + 0x28c845, + 0x204084, + 0x2e43c7, + 0x35b485, + 0x8324a3c4, + 0x2d1548, + 0x2d2e86, + 0x2d4204, + 0x2d53c8, + 0x83605f82, + 0x2e7cc4, + 0x315484, + 0x337f87, + 0x83a05f84, + 0x21a542, + 0x83e12882, + 0x254a43, + 0x254a44, + 0x2ae6c3, + 0x2bfcc5, + 0x8420c402, + 0x2f8dc5, + 0x246f82, + 0x312685, + 0x2e15c5, + 0x8460c582, + 0x3819c4, + 0x84a04942, + 0x208d46, + 0x25b846, + 0x270b48, + 0x2da1c8, + 0x30dac4, + 0x2fb0c5, + 0x2ba8c9, + 0x31fcc4, + 0x3ed084, + 0x224b03, + 0x207803, + 0x84e07805, + 0x268285, + 0x2800c4, + 0x29ec82, + 0x329e83, + 0x85203682, + 0x85601402, + 0x32d0c5, + 0x289807, + 0x286f44, + 0x224809, + 0x2e2d09, + 0x28a843, + 0x28a848, + 0x3917c9, + 0x222207, + 0x85b2e885, + 0x354f06, + 0x355546, + 0x356a05, + 0x2d1185, + 0x85e01882, + 0x375005, + 0x2cf188, + 0x2dcac6, + 0x862d4807, + 0x306ac4, + 0x2bde47, + 0x3a3946, + 0x866088c2, + 0x386ac6, + 0x311d0a, + 0x312585, + 0x86a136c2, + 0x86e14cc2, + 0x27cfc6, + 0x8729c3c7, + 0x87601b42, + 0x237fc3, + 0x2f0206, + 0x2d9fc4, + 0x36f086, + 0x3d51c6, + 0x37378a, + 0x200e05, + 0x384046, + 0x3c3743, + 0x3c3744, + 0x87a03142, + 0x321203, + 0x87e28102, + 0x320e43, + 0x88311184, + 0x2db744, + 0x887e954a, + 0x229c83, + 0x34c847, + 0x3dcdc6, + 0x268644, + 0x243502, + 0x2b5902, + 0x88a007c2, + 0x231403, + 0x265cc7, + 0x2007c7, + 0x297f84, + 0x2fcd07, + 0x3007c6, + 0x237207, + 0x227cc4, + 0x221705, + 0x201985, + 0x88e15642, + 0x21a706, + 0x226243, + 0x228882, + 0x228886, + 0x89227202, + 0x89608ec2, + 0x220d05, + 0x89a01c82, + 0x89e00fc2, + 0x398085, + 0x2e9a45, + 0x30c185, + 0x8a66e003, + 0x224e45, + 0x2f9047, + 0x2b6985, + 0x200fc5, + 0x277944, + 0x328986, + 0x24c344, + 0x8aa008c2, + 0x8b6dc005, + 0x213b47, + 0x20f2c8, + 0x278606, + 0x27860d, + 0x27db89, + 0x27db92, + 0x333505, + 0x33e543, + 0x8ba10702, + 0x31be44, + 0x3288c3, + 0x3888c5, + 0x3dfac5, + 0x8be6ca02, + 0x26ca03, + 0x8c231342, + 0x8ca27442, + 0x8ce00082, + 0x219645, + 0x3a6d43, + 0x8d205182, + 0x8d609e42, + 0x3cc106, + 0x27988a, + 0x24e2c3, + 0x244b43, + 0x2f1c43, + 0x8f201b02, + 0x9da55202, + 0x9e20d682, + 0x204c02, + 0x329c89, + 0x2df244, + 0x2eb948, + 0x9e708602, + 0x9ee08602, + 0x35f645, + 0x23fa48, + 0x23b2c8, + 0x30010c, + 0x2450c3, + 0x9f273ec2, + 0x9f612182, + 0x38c146, + 0x313dc5, + 0x2eef43, + 0x256186, + 0x313f06, + 0x24f243, + 0x3153c3, + 0x315806, + 0x317284, + 0x26f646, + 0x240fc4, + 0x317944, + 0x318c4a, + 0x9fa52ec2, + 0x25d945, + 0x31a20a, + 0x31a145, + 0x31b804, + 0x31b906, + 0x31ba84, + 0x21f306, + 0x9fe08902, + 0x21a246, + 0x23ab05, + 0x3c35c7, + 0x3cb1c6, + 0x262484, + 0x2ef1c7, + 0x224045, + 0x323447, + 0x21e087, + 0x21e08e, + 0x28cf06, + 0x3266c5, + 0x205ec7, + 0x3d9cc7, + 0x211845, + 0x213e04, + 0x325f42, + 0x24bb47, + 0x287304, + 0x249b04, + 0x2d77cb, + 0xa0225103, + 0x307f07, + 0x225104, + 0x308207, + 0x22f403, + 0x34de8d, + 0x31dc88, + 0xa06348c4, + 0x24a2c5, + 0x31e145, + 0x31e583, + 0xa0a2a742, + 0x3211c3, + 0x321743, + 0x213704, + 0x2262c5, + 0x2263c7, + 0x3c37c6, + 0x39ab03, + 0x22b7cb, + 0x27114b, + 0x2b6d8b, + 0x2bbb4b, + 0x2c858a, + 0x2dcc8b, + 0x2f9e0b, + 0x31418c, + 0x317d4b, + 0x363911, + 0x37848a, + 0x3bbfcb, + 0x3ee8cc, + 0x322a0b, + 0x32370a, + 0x323d8a, + 0x324c0e, + 0x32520b, + 0x3254ca, + 0x326d51, + 0x32718a, + 0x32768b, + 0x327bce, + 0x329f4c, + 0x32a3cb, + 0x32a68e, + 0x32aa0c, + 0x32b94a, + 0x32ca8c, + 0xa0f2d80a, + 0x32e048, + 0x32f4c9, + 0x3336ca, + 0x33394a, + 0x333bcb, + 0x336e8e, + 0x3379d1, + 0x340f89, + 0x3411ca, + 0x341dcb, + 0x34328d, + 0x34410a, + 0x344756, + 0x345acb, + 0x34748a, + 0x347dca, + 0x34980b, + 0x34b3c9, + 0x34e809, + 0x34f3cd, + 0x350e0b, + 0x3526cb, + 0x353309, + 0x35394e, + 0x353f8a, + 0x354cca, + 0x35530a, + 0x355a0b, + 0x35624b, + 0x35784d, + 0x35af8d, + 0x35cc90, + 0x35d14b, + 0x35e34c, + 0x35fc0b, + 0x36210b, + 0x36548e, + 0x36614b, + 0x36614d, + 0x36b54b, + 0x36bfcf, + 0x36c38b, + 0x36d08a, + 0x36e789, + 0x370b09, + 0xa1370e8b, + 0x37114e, + 0x3714ce, + 0x37628b, + 0x37704f, + 0x379e4b, + 0x37a10b, + 0x37a3ca, + 0x37f1c9, + 0x38248f, + 0x38b98c, + 0x38cbcc, + 0x38dace, + 0x38e28f, + 0x38e64e, + 0x38f2d0, + 0x38f6cf, + 0x390b4e, + 0x391bcc, + 0x391ed1, + 0x392312, + 0x392bd1, + 0x39320e, + 0x393a4b, + 0x393a4e, + 0x393dcf, + 0x39418e, + 0x394510, + 0x394913, + 0x394dd1, + 0x39520c, + 0x39550e, + 0x39598c, + 0x395ed3, + 0x396c10, + 0x39708c, + 0x39738c, + 0x397c4b, + 0x39908e, + 0x39958b, + 0x399ccb, + 0x39ad0c, + 0x3a0d8a, + 0x3a18cc, + 0x3a1bcc, + 0x3a1ec9, + 0x3a430b, + 0x3a45c8, + 0x3a4d89, + 0x3a4d8f, + 0x3a664b, + 0xa17a894a, + 0x3a9f0c, + 0x3aae4b, + 0xa1bab109, + 0x3abbc8, + 0x3abf8b, + 0x3ace8a, + 0x3ad10a, + 0x3ad38b, + 0x3ad88c, + 0x3ae8c9, + 0x3aeb08, + 0x3b17cb, + 0x3b598b, + 0x3b898e, + 0x3ba1cb, + 0x3bb94b, + 0x3c79cb, + 0x3c7c89, + 0x3c88cd, + 0x3dedca, + 0x3e39d7, + 0x3e4658, + 0x3e77c9, + 0x3e8a0b, + 0x3e9994, + 0x3e9e8b, + 0x3ea40a, + 0x3eafca, + 0x3eb24b, + 0x3ec790, + 0x3ecb91, + 0x3ed18a, + 0x3edecd, + 0x3ee5cd, + 0x3efa8b, + 0x21a803, + 0xa1e02843, + 0x2181c6, + 0x3d2985, + 0x2eaf47, + 0x2c2006, + 0xa2209302, + 0x2700c9, + 0x237744, + 0x2f7d08, + 0x225ec3, + 0x31bd87, + 0xa2601c42, + 0x2c2543, + 0xa2a04182, + 0x2e3786, + 0x2e4d84, + 0x2efc44, + 0x2021c3, + 0xa32e0642, + 0xa3632284, + 0x269607, + 0xa3a32642, + 0x229f43, + 0x224d03, + 0x2e9c43, + 0x219c03, + 0x2127c3, + 0x21f483, + 0x10bb08, + 0x20bc03, + 0x2000c2, + 0x7ffc8, + 0x205842, + 0x2e9c43, + 0x219c03, + 0x2127c3, + 0xbc03, + 0x21f483, + 0x217083, + 0x33d716, + 0x369b53, + 0x2fcb89, + 0x285588, + 0x2ca489, + 0x31a386, + 0x351bd0, + 0x3eba93, + 0x30b388, + 0x28bd87, + 0x28de87, + 0x2b36ca, + 0x354849, + 0x335dc9, + 0x29f80b, + 0x340886, + 0x32aeca, + 0x229146, + 0x2361c3, + 0x26d285, + 0x3d5608, + 0x290e4d, + 0x3468cc, + 0x23a7c7, + 0x3a728d, + 0x243244, + 0x23b4ca, + 0x23c84a, + 0x23cd0a, + 0x205847, + 0x248547, + 0x24ba84, + 0x27f786, + 0x384a84, + 0x224d08, + 0x238e09, + 0x308d86, + 0x308d88, + 0x24fa4d, + 0x2e2f49, + 0x315d88, + 0x216d87, + 0x220f4a, + 0x2bf046, + 0x33ed44, + 0x211e87, + 0x2f0aca, + 0x23cf4e, + 0x28a905, + 0x29bf4b, + 0x231149, + 0x27ddc9, + 0x2b2347, + 0x3da84a, + 0x2f5547, + 0x2e8a89, + 0x346d88, + 0x37078b, + 0x2f7305, + 0x25bf4a, + 0x2307c9, + 0x38638a, + 0x3efd8b, + 0x211d8b, + 0x29f595, + 0x2d8345, + 0x216e05, + 0x24408a, + 0x2722ca, + 0x32ee87, + 0x216e43, + 0x2d0848, + 0x2ece4a, + 0x22a846, + 0x266949, + 0x280408, + 0x2d4204, + 0x395c89, + 0x2da1c8, + 0x2d9e47, + 0x2dc006, + 0x213b47, + 0x3a2947, + 0x24ac85, + 0x2b7f0c, + 0x24a2c5, + 0x229f43, + 0x224d03, + 0x2e9c43, + 0x2127c3, + 0xbc03, + 0x21f483, + 0x205842, + 0x229f43, + 0x2127c3, + 0x20bc03, + 0x21f483, + 0x229f43, + 0x2127c3, + 0xbc03, + 0x25d543, + 0x21f483, + 0x1df183, + 0x7ffc8, + 0x229f43, + 0x224d03, + 0x2e9c43, + 0x219c03, + 0x2127c3, + 0xbc03, + 0x21f483, + 0x7ffc8, + 0x205842, + 0x229f43, + 0x234f87, + 0x98704, + 0x2127c3, + 0x37344, + 0x21f483, + 0xef45, + 0x205842, + 0x201902, + 0x30b602, + 0x205fc2, + 0x202a42, + 0x229ac2, + 0x164ca, + 0x14244b, + 0x5b547, + 0x1b8586, + 0xa1606, + 0x60209, + 0xebb49, + 0x1a3dc7, + 0x15b4e8a, + 0x1314e, + 0x10ad89, + 0x482cac3, + 0x98307, + 0x149c86, + 0x5ec3, + 0x11d6c5, + 0xc1, + 0x5229f43, + 0x224d03, + 0x28c6c3, + 0x2e9c43, + 0x25e043, + 0x219c03, + 0x2ee0c6, + 0x2127c3, + 0x21f483, + 0x236f03, + 0x7ffc8, + 0x20a944, + 0x264187, + 0x202203, + 0x261a44, + 0x225f43, + 0x2455c3, + 0x2e9c43, + 0xf1a47, + 0x9c4, + 0x14c3, + 0x172f85, + 0x66000c2, + 0x58843, + 0x6a05842, + 0x6e96109, + 0x709b3c9, + 0x9b80d, + 0x9bb4d, + 0x30b602, + 0x58104, + 0x172fc9, + 0x2003c2, + 0x7658008, + 0x105744, + 0x320a03, + 0x7ffc8, + 0x87304, + 0x14076c2, + 0x14005c2, + 0x14076c2, + 0x1517b46, + 0x23d9c3, + 0x2c9ec3, + 0x7e29f43, + 0x23b4c4, + 0x8624d03, + 0x8ee9c43, + 0x203842, + 0x258104, + 0x2127c3, + 0x239503, + 0x200f82, + 0x21f483, + 0x222402, + 0x30bd83, + 0x201782, + 0x2b32c3, + 0x221943, + 0x205242, + 0x7ffc8, + 0x829db89, + 0x22003, + 0x23d9c3, + 0x3d7348, + 0x8a39503, + 0x200f82, + 0x30bd83, + 0x201782, + 0x2b32c3, + 0x221943, + 0x205242, + 0x25ce87, + 0x30bd83, + 0x201782, + 0x2b32c3, + 0x221943, + 0x205242, + 0x229f43, + 0x2b82, + 0x24dc3, + 0x3642, + 0x6cc2, + 0x4682, + 0x2c82, + 0x1b02, + 0x2842, + 0x258843, + 0x229f43, + 0x224d03, + 0x2e9c43, + 0x258104, + 0x25e043, + 0x219c03, + 0x222d84, + 0x2127c3, + 0x21f483, + 0x202082, + 0x202783, + 0x7ffc8, + 0x229f43, + 0x224d03, + 0x2e9c43, + 0x219c03, + 0x2127c3, + 0x21f483, + 0x9a03, + 0x1c682, + 0x258843, + 0x205842, + 0x229f43, + 0x224d03, + 0x2e9c43, + 0x258104, + 0x2127c3, + 0x21f483, + 0x32e885, + 0x26ca02, + 0x2000c2, + 0x7ffc8, + 0xaeba692, + 0xb2d6d88, + 0x1475dc8, + 0x3424a, + 0x2cc5, + 0x2707, + 0x2e9c43, + 0x228ac1, + 0x2009c1, + 0x200a01, + 0x201101, + 0x200dc1, + 0x218341, + 0x202281, + 0x202f81, + 0x249081, + 0x200001, + 0x2000c1, + 0x200201, + 0x145d45, + 0x7ffc8, + 0x200101, + 0x200d01, + 0x200501, + 0x200c01, + 0x200041, + 0x200801, + 0x200181, + 0x200c41, + 0x200701, + 0x2004c1, + 0x200b41, + 0x200581, + 0x2003c1, + 0x200a81, + 0x205601, + 0x200401, + 0x200741, + 0x2007c1, + 0x200081, + 0x204c01, + 0x205241, + 0x201541, + 0x201c41, + 0x201b81, + 0x229f43, + 0x224d03, + 0x2e9c43, + 0x2127c3, + 0x21f483, + 0x205842, + 0x229f43, + 0x224d03, + 0x2003c2, + 0x21f483, + 0xf1a47, + 0x84447, + 0x332c6, + 0x46aca, + 0x9a808, + 0x64f08, + 0x65bc7, + 0xc3184, + 0x71506, + 0xf58c5, + 0xcab05, + 0xb0e03, + 0x18a46, + 0x5b646, + 0x29f804, + 0x334f47, + 0x7ffc8, + 0x2ef2c4, + 0x229f43, + 0x224d03, + 0x2e9c43, + 0x2127c3, + 0x21f483, + 0x5842, + 0x229f43, + 0x224d03, + 0x2e9c43, + 0x2127c3, + 0x21f483, + 0x32da08, + 0x209f84, + 0x23a844, + 0x2045c4, + 0x38c047, + 0x2ec207, + 0x229f43, + 0x24128b, + 0x3b154a, + 0x34a2c7, + 0x3e4448, + 0x220208, + 0x224d03, + 0x2886c7, + 0x28c6c3, + 0x214688, + 0x22f089, + 0x258104, + 0x25e043, + 0x247608, + 0x219c03, + 0x2e984a, + 0x2ee0c6, + 0x33bc87, + 0x2127c3, + 0x30eec6, + 0x3c0848, + 0x21f483, + 0x25a6c6, + 0x2fe8cd, + 0x300408, + 0x305d4b, + 0x20e0c6, + 0x385887, + 0x22ab45, + 0x2b904a, + 0x22b685, + 0x26818a, + 0x26ca02, + 0x205ec3, + 0x249b04, + 0x200006, + 0x3bf783, + 0x2a1c03, + 0x289e03, + 0x209f83, + 0x20c083, + 0x203742, + 0x38bd85, + 0x2b9dc9, + 0x202043, + 0x24b303, + 0x2030c3, + 0x219243, + 0x200201, + 0x31fa87, + 0x219385, + 0x3c5943, + 0x269183, + 0x3ef083, + 0x2045c4, + 0x383d43, + 0x2120c8, + 0x36e9c3, + 0x31484d, + 0x28cfc8, + 0x3d7506, + 0x2f77c3, + 0x366443, + 0x39afc3, + 0xde29f43, + 0x23dc08, + 0x241284, + 0x248c03, + 0x24c883, + 0x200106, + 0x250bc8, + 0x24dac3, + 0x22f903, + 0x2bfb03, + 0x205483, + 0x2b9083, + 0x220203, + 0x224d03, + 0x233a43, + 0x254583, + 0x209343, + 0x296a03, + 0x328343, + 0x20ea83, + 0x20a6c3, + 0x3ab305, + 0x2601c4, + 0x261307, + 0x262642, + 0x263d83, + 0x268406, + 0x269fc3, + 0x26ad43, + 0x28a803, + 0x271dc3, + 0x21f403, + 0x20a643, + 0x2a7a87, + 0xeae9c43, + 0x2421c3, + 0x208103, + 0x204203, + 0x258103, + 0x21a583, + 0x226dc5, + 0x382803, + 0x38d2c9, + 0x200c43, + 0x3dfdc3, + 0xee57443, + 0x227883, + 0x204603, + 0x217388, + 0x2b9d06, + 0x271b86, + 0x2c4f06, + 0x26bf87, + 0x22ea83, + 0x2335c3, + 0x219c03, + 0x29a906, + 0x226e42, + 0x2ed403, + 0x366005, + 0x2127c3, + 0x31b087, + 0x160bc03, + 0x219d03, + 0x2058c3, + 0x23eb03, + 0x22d043, + 0x21f483, + 0x215c46, + 0x200a86, + 0x387c83, + 0x22e683, + 0x202783, + 0x227d43, + 0x315443, + 0x309743, + 0x30c883, + 0x20ef45, + 0x23ffc3, + 0x23ffc6, + 0x21ad03, + 0x28c148, + 0x22bcc3, + 0x22bcc9, + 0x2b8a88, + 0x22d3c8, + 0x310ac5, + 0x235d8a, + 0x23ed4a, + 0x24430b, + 0x244cc8, + 0x31c843, + 0x21e6c3, + 0x30c8c3, + 0x2f3883, + 0x30e088, + 0x32a203, + 0x3c3744, + 0x203142, + 0x23c7c3, + 0x253f03, + 0x2007c3, + 0x3a8143, + 0x280183, + 0x236f03, + 0x26ca02, + 0x2f5443, + 0x2450c3, + 0x317cc3, + 0x319684, + 0x249b04, + 0x231a83, + 0x7ffc8, + 0xe315f8c, + 0xe6e5745, + 0xc1e05, + 0x2000c2, + 0x200ac2, + 0x203742, + 0x201182, + 0x200202, + 0x202542, + 0x25a282, + 0x203642, + 0x200382, + 0x200b42, + 0x208f02, + 0x20f782, + 0x27eec2, + 0x200a82, + 0x229ac2, + 0x20f102, + 0x215502, + 0x202782, + 0x2bbd02, + 0x206902, + 0x200682, + 0x214602, + 0x201082, + 0x2036c2, + 0x2033c2, + 0x207802, + 0x200fc2, + 0xc2, + 0xac2, + 0x3742, + 0x1182, + 0x202, + 0x2542, + 0x5a282, + 0x3642, + 0x382, + 0xb42, + 0x8f02, + 0xf782, + 0x7eec2, + 0xa82, + 0x29ac2, + 0xf102, + 0x15502, + 0x2782, + 0xbbd02, + 0x6902, + 0x682, + 0x14602, + 0x1082, + 0x36c2, + 0x33c2, + 0x7802, + 0xfc2, + 0x229f43, + 0x224d03, + 0x2e9c43, + 0x2127c3, + 0x21f483, + 0x5ec2, + 0x229f43, + 0x224d03, + 0x2e9c43, + 0x2127c3, + 0x21f483, + 0x9c589, + 0x5842, + 0x205842, + 0x21f483, + 0x10a29f43, + 0x2e9c43, + 0x219c03, + 0xf19c7, + 0x81983, + 0x247f42, + 0x7ffc8, + 0x229f43, + 0x224d03, + 0x2e9c43, + 0x1e683, + 0x2127c3, + 0xbc03, + 0x81983, + 0x21f483, + 0x4182, + 0x2001c2, + 0x1405405, + 0x145d45, + 0x212d02, + 0x7ffc8, + 0x5842, + 0x240482, + 0x203782, + 0x20a382, + 0x23b542, + 0x216602, + 0xcab05, + 0x20ad82, + 0x200f82, + 0x214542, + 0x203fc2, + 0x20f102, + 0x248dc2, + 0x212882, + 0x223ac2, + 0x11a7c7c4, + 0x142, + 0xf1a47, + 0x13683, + 0x1b670d, + 0xf5949, + 0x1a5fcb, + 0xf8f08, + 0x6b349, + 0x1133c6, + 0x2e9c43, + 0x7ffc8, + 0x9c4, + 0x14c3, + 0x172f85, + 0x7ffc8, + 0xf2447, + 0x12c5a847, + 0x13263284, + 0x66806, + 0x172fc9, + 0xb714e, + 0x13e007, + 0x15b2a43, + 0x13602c02, + 0x1edc89, + 0x1f04, + 0x2000c2, + 0x29f804, + 0x205842, + 0x229f43, + 0x201902, + 0x224d03, + 0x26403, + 0x200382, + 0x2ef2c4, + 0x25e043, + 0x254902, + 0x2127c3, + 0x16602, + 0x2003c2, + 0x21f483, + 0x216e06, + 0x33418f, + 0x725ec3, + 0x2fc58a, + 0x7ffc8, + 0x205842, + 0x28c6c3, + 0x2e9c43, + 0x219c03, + 0xbc03, + 0x14bb6147, + 0x1582a46, + 0x1d1ec6, + 0x14fc8bc8, + 0x1e6644, + 0x152c518a, + 0x15c34147, + 0xd6d88, + 0xb7148, + 0x15e930b, + 0x147ccca, + 0x1606ac83, + 0xfb6c9, + 0x165045c8, + 0x16a54187, + 0x14b8e4a, + 0x1500f47, + 0xb378b, + 0x16e81f4c, + 0xaa845, + 0xfc185, + 0x11adc9, + 0x1bddc4, + 0x1153c3, + 0x156c52c5, + 0x124283, + 0x15a32783, + 0x124283, + 0x13682, + 0x1c82, + 0x9e42, + 0x9e42, + 0x3702, + 0x9e42, + 0x1b02, + 0x2102, + 0xd02, + 0x145d45, + 0xf1a47, + 0x1e6644, + 0x102504, + 0x205842, + 0x229f43, + 0x2e9c43, + 0x2127c3, + 0x2000c2, + 0x204cc2, + 0x206f02, + 0x17e29f43, + 0x248d82, + 0x224d03, + 0x200c02, + 0x2a5c02, + 0x2e9c43, + 0x21e682, + 0x271102, + 0x232242, + 0x2086c2, + 0x2a1342, + 0x200802, + 0x202142, + 0x204d02, + 0x227e02, + 0x20a442, + 0x13038c, + 0x2c7dc2, + 0x2803c2, + 0x226282, + 0x240e42, + 0x219c03, + 0x20dec2, + 0x2127c3, + 0x20e942, + 0x2a28c2, + 0x21f483, + 0x24b382, + 0x2036c2, + 0x21ee82, + 0x204082, + 0x20c582, + 0x2136c2, + 0x215642, + 0x231342, + 0x226d82, + 0x3254ca, + 0x36d08a, + 0x3a8fca, + 0x3f0382, + 0x2102c2, + 0x227482, + 0x18239b09, + 0x187bf80a, + 0x1542547, + 0x18a05f02, + 0x142cb83, + 0x10c2, + 0x1bf80a, + 0x15fe8e, + 0x259b44, + 0x100585, + 0x19229f43, + 0x498c3, + 0x224d03, + 0x25b9c4, + 0x2e9c43, + 0x258104, + 0x25e043, + 0x13de09, + 0x136086, + 0x219c03, + 0xf9704, + 0xd83, + 0x2127c3, + 0x8e345, + 0x20bc03, + 0x21f483, + 0x1528a44, + 0x23ffc3, + 0x1954bc04, + 0x205ec3, + 0x7ffc8, + 0x3842, + 0x154d603, + 0x125e06, + 0x1471484, + 0x1fc5, + 0x1bdbca, + 0x86a42, + 0x1a002acd, + 0x1b9946, + 0x187591, + 0x1a639b09, + 0x15500a, + 0x2048, + 0x1b5508, + 0x6e90e, + 0x182d13, + 0x21121487, + 0xec2, + 0x39c94, + 0x46f07, + 0x2d74e, + 0x145d4b, + 0x1482cb, + 0x1c304a, + 0x110947, + 0x7ffc8, + 0xa1d08, + 0xf647, + 0x2141f6cb, + 0x21646, + 0x24bc7, + 0x37c2, + 0x3124d, + 0x142e85, + 0x18ee07, + 0x10a6ca, + 0x12820c, + 0x1283cf, + 0x570f, + 0xb90c2, + 0x5842, + 0x96948, + 0x218f754c, + 0x1aee0a, + 0xf1f4a, + 0x8240a, + 0x8cdc8, + 0x15948, + 0x6da88, + 0xf2408, + 0xc348, + 0xd02, + 0x548f, + 0x152038d, + 0x181acb, + 0xd1e88, + 0x40787, + 0x5494a, + 0x3bc0b, + 0xa54c9, + 0x54847, + 0x159286, + 0x15848, + 0x3ef0c, + 0x1cd787, + 0x2f5ca, + 0x1db408, + 0x332ce, + 0x3464e, + 0x11078b, + 0x5594b, + 0x15024b, + 0x10a249, + 0x11870b, + 0x12618d, + 0x15be4b, + 0x3accd, + 0x3b04d, + 0x41b4a, + 0x4994b, + 0x4a10b, + 0x50ec5, + 0x21dc8c10, + 0x32c4f, + 0x7c98f, + 0x147a8d, + 0x85f10, + 0x6cc2, + 0x222fc8c8, + 0x1cd608, + 0x9ed50, + 0x1217ce, + 0x2276e985, + 0x5a44b, + 0x13cf10, + 0xa650b, + 0x1b858c, + 0x15a4a, + 0x55b09, + 0x6f248, + 0x762c7, + 0x76607, + 0x767c7, + 0x77707, + 0x78487, + 0x78947, + 0x79607, + 0x79b07, + 0x7a007, + 0x7a387, + 0x7aa47, + 0x7ac07, + 0x7adc7, + 0x7af87, + 0x7b307, + 0x7b847, + 0x7d147, + 0x7d587, + 0x7e007, + 0x7e2c7, + 0x7e487, + 0x7e787, + 0x7ed87, + 0x7ef87, + 0x7f907, + 0x7fac7, + 0x7fc87, + 0x80247, + 0x80887, + 0x81247, + 0x82247, + 0x82687, + 0x82e87, + 0x83047, + 0x83687, + 0x83a07, + 0x83ec7, + 0x842c7, + 0x84607, + 0x847c7, + 0x85187, + 0x86c47, + 0x87407, + 0x879c7, + 0x87b87, + 0x88007, + 0x89347, + 0xd9c2, + 0x6db8a, + 0x18848, + 0x1c014c, + 0x1d5287, + 0x9ae85, + 0x17ac91, + 0x1f0006, + 0x12c00a, + 0x967ca, + 0x66806, + 0xbcf4b, + 0x642, + 0x389d1, + 0xcb289, + 0xa6a09, + 0xa7546, + 0x4d02, + 0x6b04a, + 0xb92c9, + 0xb9a0f, + 0xba00e, + 0xbb988, + 0x22a6eb12, + 0x15388, + 0x22e6f447, + 0xbee0f, + 0x1d7c2, + 0x719c9, + 0x8654a, + 0x23217d09, + 0x18c389, + 0x18c38c, + 0x2994b, + 0x1b438e, + 0x448c, + 0xfb3cf, + 0x1c494e, + 0x3f30c, + 0x56a09, + 0x15f291, + 0x61ac8, + 0x6a152, + 0x81c4d, + 0x83b8d, + 0x88b0b, + 0x89a95, + 0x90249, + 0x9158a, + 0x95bc9, + 0x190f90, + 0x1b56cb, + 0xa0dcf, + 0xab04b, + 0xb194c, + 0xc1390, + 0xdb90a, + 0x1a158d, + 0x1a3f8e, + 0x19e84a, + 0xc324c, + 0x1a2614, + 0xcaf11, + 0xce00b, + 0xd03cf, + 0xd2fcd, + 0xd608e, + 0xd9d0c, + 0xda74c, + 0xdb60b, + 0xdc60e, + 0xdd9d0, + 0x141b0b, + 0x1a110d, + 0x1ae1cf, + 0xf2ecc, + 0x108c0e, + 0x10fd91, + 0x1a3a8c, + 0x144347, + 0x162a4d, + 0x16d2cc, + 0x17a610, + 0x17bd0d, + 0x19b5c7, + 0x1a4990, + 0x1afe08, + 0xc284b, + 0xc480f, + 0x1c03c8, + 0x6e30d, + 0x112610, + 0x17d2c9, + 0x237c8bc8, + 0x23ac8c86, + 0xc9983, + 0x61ec9, + 0x25889, + 0xd0e85, + 0x8042, + 0x14a749, + 0x6738a, + 0x23e6a606, + 0x146a60d, + 0x242ff684, + 0x1e4c46, + 0x25dca, + 0x2c60d, + 0x246e034b, + 0x98e08, + 0x2489f389, + 0x2f443, + 0x119aca, + 0xebb49, + 0xf1091, + 0xf14c9, + 0xf1ec7, + 0xf2c08, + 0xf3347, + 0x6f348, + 0x558b, + 0x130049, + 0xfa0d0, + 0xfa58c, + 0xfaa09, + 0x24efadcd, + 0xfc408, + 0xfd045, + 0x146f08, + 0x1a370a, + 0x1325c7, + 0x1242, + 0x25276f95, + 0x13dc0a, + 0x142cc9, + 0x25a48, + 0x1a7ec9, + 0x1d2a45, + 0x11af0a, + 0x173947, + 0x9c30f, + 0xaa8cb, + 0x16154c, + 0xef892, + 0x3e046, + 0x1409588, + 0x7b645, + 0x115608, + 0x1e4d8b, + 0x1e5151, + 0x17587, + 0x6798a, + 0x25704485, + 0x1b5ccc, + 0x2590afce, + 0x13a283, + 0x19de06, + 0x48dc2, + 0x10d2cb, + 0x10de4a, + 0x150f14c, + 0x98d08, + 0x3ae88, + 0x25e25ac6, + 0x152f8e, + 0x132207, + 0x9942, + 0x1782, + 0x18fb50, + 0x6ca87, + 0x6cb8f, + 0x18a46, + 0x5c88e, + 0xa494b, + 0x566c8, + 0xa5889, + 0x1e1e52, + 0x115c4d, + 0x1167c8, + 0x1a5e89, + 0x1ec14d, + 0x6cf09, + 0x6d6cb, + 0x6fe48, + 0x79e08, + 0x7b488, + 0x7e909, + 0x7eb0a, + 0x7f28c, + 0xcf34a, + 0xe808a, + 0x115487, + 0xae6ca, + 0xf8ac8, + 0x780d, + 0xb7bd1, + 0x262d6386, + 0x16588b, + 0x3754c, + 0x45188, + 0x1d9a49, + 0x15d48d, + 0x77950, + 0x1476cc, + 0x14b94d, + 0x9e42, + 0x8a4cd, + 0x1b02, + 0x55202, + 0x1153ca, + 0x267cbc4a, + 0x2b10a, + 0x26a87cc8, + 0x12bf0a, + 0x11bc8b, + 0x11c9c7, + 0x1b134c, + 0x348cc, + 0x11e90a, + 0x26d1eb8f, + 0x11ef4c, + 0x11f247, + 0x1208ce, + 0x271f0245, + 0x184588, + 0x4182, + 0x1405483, + 0x1ab751ce, + 0x1b20118e, + 0x1ba0c98a, + 0x1c332dce, + 0x1ca060ce, + 0x1d340c8c, + 0x1542547, + 0x15550c9, + 0x142cb83, + 0x1db6890c, + 0x1e206cc9, + 0x1ebb7249, + 0x1f3bd9c9, + 0x10c2, + 0x175111, + 0x10d1, + 0xc8cd, + 0x132d11, + 0x1361d1, + 0x140bcf, + 0x16884f, + 0x1a9c0c, + 0x1b718c, + 0x1bd90c, + 0xe72cd, + 0xf8455, + 0x12b64c, + 0x142f8c, + 0x198c90, + 0x1c170c, + 0x1c3bcc, + 0x1c6019, + 0x1db5d9, + 0x5e19, + 0x6a14, + 0xf7d4, + 0x10954, + 0x10ed4, + 0x17714, + 0x1fa0fa89, + 0x20010c09, + 0x20b43049, + 0x1ae61cc9, + 0x10c2, + 0x1b661cc9, + 0x10c2, + 0x5e0a, + 0x10c2, + 0x1be61cc9, + 0x10c2, + 0x5e0a, + 0x10c2, + 0x1c661cc9, + 0x10c2, + 0x1ce61cc9, + 0x10c2, + 0x1d661cc9, + 0x10c2, + 0x5e0a, + 0x10c2, + 0x1de61cc9, + 0x10c2, + 0x5e0a, + 0x10c2, + 0x1e661cc9, + 0x10c2, + 0x1ee61cc9, + 0x10c2, + 0x5e0a, + 0x10c2, + 0x1f661cc9, + 0x10c2, + 0x5e0a, + 0x10c2, + 0x1fe61cc9, + 0x10c2, + 0x20661cc9, + 0x10c2, + 0x20e61cc9, + 0x10c2, + 0x5e0a, + 0x10c2, + 0x1400401, + 0x187585, + 0x1c3044, + 0x145b883, + 0x15cf803, + 0x158f143, + 0x1751ce, + 0x118e, + 0x8face, + 0xc98a, + 0x132dce, + 0x60ce, + 0x140c8c, + 0x16890c, + 0x6cc9, + 0x1b7249, + 0x1bd9c9, + 0xfa89, + 0x10c09, + 0x143049, + 0xf864d, + 0x11189, + 0x179c9, + 0x147384, + 0x170a04, + 0x1ec684, + 0x1f0144, + 0xb3a44, + 0x154bc4, + 0x1ba644, + 0x55e04, + 0x18944, + 0x212c4, + 0x16f4c9, + 0x16f4cc, + 0x14fa46, + 0x14fa4e, + 0x81d84, + 0x1596343, + 0x1c3a47, + 0x1490c0c, + 0x2043, + 0x212c4, + 0x6cc2, + 0x4f087, + 0xf7548, + 0xa2108, + 0xdcbc4, + 0x1a9806, + 0x1351c7, + 0xe3504, + 0x114046, + 0x1f182, + 0x1541, + 0x22104, + 0x6e786, + 0x1a883, + 0x6cc2, + 0x2043, + 0xdc843, + 0xef683, + 0x12683, + 0x10a1c3, + 0xef885, + 0x803c2, + 0x7102, + 0x7108, + 0xf4c87, + 0x1300c7, + 0xd02, + 0x2000c2, + 0x205842, + 0x201902, + 0x218b02, + 0x200382, + 0x2003c2, + 0x201782, + 0x229f43, + 0x224d03, + 0x2e9c43, + 0x258103, + 0x2127c3, + 0x21f483, + 0x7ffc8, + 0x229f43, + 0x224d03, + 0x2127c3, + 0x21f483, + 0x12c03, + 0x2e9c43, + 0x58104, + 0x2000c2, + 0x258843, + 0x29629f43, + 0x3ab707, + 0x2e9c43, + 0x2280c3, + 0x222d84, + 0x2127c3, + 0x21f483, + 0x22600a, + 0x216e05, + 0x202783, + 0x208ec2, + 0x7ffc8, + 0x29ae574a, + 0xc41, + 0x7ffc8, + 0x5842, + 0x137d42, + 0x2a29f10b, + 0x2a635204, + 0xff5c5, + 0x1402cc5, + 0xf7546, + 0x2aa02cc5, + 0x635c3, + 0x9ec43, + 0x9c4, + 0x14c3, + 0x172f85, + 0x145d45, + 0x7ffc8, + 0x24bc7, + 0x29f43, + 0x3514d, + 0x2b246907, + 0xac86, + 0x2b40c7c5, + 0x148792, + 0xad47, + 0x1624a, + 0x14e88, + 0x16147, + 0x1d5b4a, + 0x1bad08, + 0x6d487, + 0x156acf, + 0x4dd87, + 0x539c6, + 0x13cf10, + 0xc9c8f, + 0x1ac09, + 0x1e4cc4, + 0x2b80ae0e, + 0x4f3c9, + 0x7b0c6, + 0x111ac9, + 0x19ab46, + 0x1d71c6, + 0xbe24c, + 0x3be0a, + 0xa5647, + 0x1e224a, + 0xb209, + 0xfe38c, + 0x2724a, + 0x6b68a, + 0x172fc9, + 0x1e4c46, + 0xa570a, + 0x116d4a, + 0xaf4ca, + 0x157189, + 0xeee88, + 0xef106, + 0xf644d, + 0x5fe0b, + 0xd1445, + 0x2bf889cc, + 0x13e007, + 0x1c8049, + 0xdab07, + 0xb2c54, + 0x112a0b, + 0xd1cca, + 0x1e1cca, + 0xb578d, + 0x151be89, + 0x115a0c, + 0x1165cb, + 0x163217, + 0x163d55, + 0x2f5c3, + 0x2f5c3, + 0x332c6, + 0x2f5c3, + 0xf7548, + 0x156983, + 0x51384, + 0x1c244, + 0x1c24c, + 0x63883, + 0x14af587, + 0xa5845, + 0x142b343, + 0x142b348, + 0x60209, + 0xef885, + 0x1e4d8b, + 0xce2cb, + 0x14f3143, + 0x14f3148, + 0x149c86, + 0x1441d07, + 0x191207, + 0x2cd82bc9, + 0x12686, + 0x58843, + 0x7ffc8, + 0x5842, + 0x5b9c4, + 0x97783, + 0x12e885, + 0x229f43, + 0x224d03, + 0x2e9c43, + 0x2127c3, + 0x21f483, + 0x2030c3, + 0x229f43, + 0x224d03, + 0x28c6c3, + 0x2e9c43, + 0x219c03, + 0x2127c3, + 0x21f483, + 0x39ac43, + 0x205ec3, + 0x2030c3, + 0x29f804, + 0x229f43, + 0x224d03, + 0x2e9c43, + 0x2127c3, + 0x21f483, + 0x2043c3, + 0x208d43, + 0x208ec2, + 0x2e582cc5, + 0x14325c3, + 0x229f43, + 0x224d03, + 0x226403, + 0x28c6c3, + 0x2e9c43, + 0x258104, + 0x3ce883, + 0x2335c3, + 0x219c03, + 0x2127c3, + 0x81983, + 0x21f483, + 0x202783, + 0x2f2265c3, + 0xef789, + 0x5842, + 0x2f0243, + 0x2fe29f43, + 0x224d03, + 0x255f03, + 0x2e9c43, + 0x22d643, + 0x2335c3, + 0x21f483, + 0x203303, + 0x3d2bc4, + 0x7ffc8, + 0x30629f43, + 0x224d03, + 0x2bba43, + 0x2e9c43, + 0x219c03, + 0x222d84, + 0x2127c3, + 0x21f483, + 0x265503, + 0x7ffc8, + 0x30e29f43, + 0x224d03, + 0x28c6c3, + 0x20bc03, + 0x21f483, + 0x7ffc8, + 0x1542547, + 0x258843, + 0x229f43, + 0x224d03, + 0x2e9c43, + 0x258104, + 0x222d84, + 0x2127c3, + 0x21f483, + 0x145d45, + 0xf1a47, + 0xb2e8b, + 0x31e3eb46, + 0xf18c4, + 0xd1445, + 0x1475dc8, + 0x3204d, + 0x1c8bc8, + 0x3275e205, + 0x2c684, + 0x5842, + 0xb8c3, + 0x14f945, + 0x47f42, + 0x340a45, + 0x7ffc8, + 0x33f0ac4d, + 0x3420244a, + 0xc142, + 0x5083, + 0x16934f, + 0x18b02, + 0x81d84, + 0x212c4, + 0x5842, + 0x2000c2, + 0x258843, + 0x229f43, + 0x2e9c43, + 0x258104, + 0x219c03, + 0x222d84, + 0x2127c3, + 0x21f483, + 0x202783, + 0x229f43, + 0x224d03, + 0x2127c3, + 0x21f483, + 0xef45, + 0x32e1c8, + 0x29f804, + 0x371f86, + 0x3a9ac6, + 0x7ffc8, + 0x3184c3, + 0x236c09, + 0x21b795, + 0x1b79f, + 0x229f43, + 0x8bf47, + 0x398852, + 0x18ce86, + 0x18fa45, + 0x15a4a, + 0x55b09, + 0x39860f, + 0x2ef2c4, + 0x231b05, + 0x3dfb90, + 0x285787, + 0x20bc03, + 0x219d08, + 0x21146, + 0x28aa0a, + 0x257fc4, + 0x3041c3, + 0x208ec2, + 0x2ff38b, + 0x224d03, + 0x2e9c43, + 0xbc03, + 0x18a044, + 0x229f43, + 0x224d03, + 0x2e9c43, + 0x219c03, + 0x2127c3, + 0xbc03, + 0x21f483, + 0x309a43, + 0x205842, + 0x38fc3, + 0x1e3084, + 0x2127c3, + 0x21f483, + 0x36426b85, + 0x1d9806, + 0x229f43, + 0x224d03, + 0x2e9c43, + 0x219c03, + 0x21f483, + 0x229f43, + 0x224d03, + 0x2e9c43, + 0x2280c3, + 0x2307c3, + 0x21f483, + 0x58843, + 0x205842, + 0x229f43, + 0x224d03, + 0x2127c3, + 0xbc03, + 0x21f483, + 0x1a802, + 0x2000c2, + 0x229f43, + 0x224d03, + 0x2e9c43, + 0x2127c3, + 0x21f483, + 0x2cc5, + 0x63649, + 0x2043, + 0x29f804, + 0x229f43, + 0x224d03, + 0x292e44, + 0x2127c3, + 0x21f483, + 0x7ffc8, + 0x229f43, + 0x224d03, + 0x2e9c43, + 0x2127c3, + 0x81983, + 0x21f483, + 0x12b409, + 0x45c4, + 0x229f43, + 0xd02, + 0x224d03, + 0x28c6c3, + 0x204203, + 0x219c03, + 0x2127c3, + 0xbc03, + 0x21f483, + 0xfc2, + 0x229f43, + 0x224d03, + 0x2e9c43, + 0x3547c4, + 0x258104, + 0x2127c3, + 0x21f483, + 0x205ec3, + 0x2b82, + 0x205842, + 0x229f43, + 0x224d03, + 0x2e9c43, + 0x2127c3, + 0x81983, + 0x21f483, + 0x15aec3, + 0x7ffc8, + 0x229f43, + 0x224d03, + 0x2e9c43, + 0x352e83, + 0x3e83, + 0x280c3, + 0x2127c3, + 0x81983, + 0x21f483, + 0x36146, + 0x3254ca, + 0x344509, + 0x3627cb, + 0x362f8a, + 0x36d08a, + 0x38068b, + 0x39a90a, + 0x3a0d8a, + 0x3a8fca, + 0x3a924b, + 0x3c9509, + 0x3dc94a, + 0x3dd18b, + 0x3ea14b, + 0x3ef7ca, + 0x35c2, + 0x229f43, + 0x224d03, + 0x28c6c3, + 0x219c03, + 0x2127c3, + 0xbc03, + 0x21f483, + 0x344b, + 0x1217c7, + 0x6f7c8, + 0x1ec284, + 0x1e6644, + 0x9dac8, + 0xf3f86, + 0x56c6, + 0x11df87, + 0x120287, + 0xf0c9, + 0x7ffc8, + 0x229f43, + 0x15a44, + 0x2762c4, + 0x202182, + 0x222d84, + 0x3734c5, + 0x2030c3, + 0x29f804, + 0x229f43, + 0x241284, + 0x224d03, + 0x25b9c4, + 0x2ef2c4, + 0x258104, + 0x2335c3, + 0x2127c3, + 0x21f483, + 0x28a685, + 0x2043c3, + 0x202783, + 0x21cb03, + 0x24a3c4, + 0x325d84, + 0x22cc85, + 0x7ffc8, + 0x20b904, + 0x3d1606, + 0x373104, + 0x205842, + 0x2efc87, + 0x253087, + 0x259344, + 0x2f4d05, + 0x37bf05, + 0x235c45, + 0x258104, + 0x26c048, + 0x260ec6, + 0x35a148, + 0x358fc5, + 0x2f7305, + 0x277a44, + 0x21f483, + 0x305744, + 0x37f506, + 0x216f03, + 0x24a3c4, + 0x268285, + 0x34a6c4, + 0x2affc4, + 0x208ec2, + 0x24fd46, + 0x3bc546, + 0x313dc5, + 0x2000c2, + 0x258843, + 0xf4106, + 0x3ba05842, + 0x22f904, + 0x197604, + 0x68585, + 0x200382, + 0x219c03, + 0x205582, + 0x2127c3, + 0x2003c2, + 0x301946, + 0x217083, + 0x1e4bc5, + 0x205ec3, + 0x7ffc8, + 0x7ffc8, + 0x2e9c43, + 0x81983, + 0x2000c2, + 0x3c605842, + 0x2e9c43, + 0x27ad43, + 0x3ce883, + 0x235204, + 0x2127c3, + 0x21f483, + 0x7ffc8, + 0x3df87, + 0x2000c2, + 0x3ce05842, + 0x229f43, + 0x2127c3, + 0xbc03, + 0x21f483, + 0x682, + 0x210702, + 0x26ca02, + 0x2280c3, + 0x2fe343, + 0x2000c2, + 0x145d45, + 0x7ffc8, + 0xf1a47, + 0x205842, + 0x224d03, + 0x25b9c4, + 0x204b03, + 0x2e9c43, + 0x204203, + 0x219c03, + 0x2127c3, + 0x21c043, + 0x21f483, + 0x216e43, + 0x5ec3, + 0x13fe13, + 0x142054, + 0x145d45, + 0xf1a47, + 0x16249, + 0x114786, + 0x12efcb, + 0x332c6, + 0x64d47, + 0x162e06, + 0x649, + 0x78e0a, + 0x9a6cd, + 0x1b640c, + 0x1176ca, + 0x191648, + 0xcab05, + 0x16288, + 0x18a46, + 0x1d1ac6, + 0x5b646, + 0x206cc2, + 0x71e44, + 0xfbbc6, + 0x14e1f4e, + 0x23c6, + 0x7804c, + 0x3e382a4b, + 0x145d45, + 0x149a8b, + 0x3e7b5347, + 0x3ebb534a, + 0x3efd4ec4, + 0x1c3207, + 0x2a691, + 0x12130a, + 0x229f43, + 0x3f290b08, + 0x1d5ac5, + 0x19f508, + 0x2ba44, + 0x67585, + 0xb0d07, + 0x3f5d14c6, + 0xe184b, + 0x3fb84209, + 0x15345, + 0x17ac86, + 0x11c306, + 0xa160a, + 0x9e80c, + 0x1c5983, + 0x1e6644, + 0x3ffeba44, + 0x60209, + 0x10b707, + 0x10e60a, + 0x14e5649, + 0x605, + 0x118683, + 0x4023fcc7, + 0x8e345, + 0x1569f86, + 0x14b89c6, + 0xbd00c, + 0x1074c8, + 0x40448dc3, + 0x10be44, + 0x18ef4b, + 0x2178b, + 0x40b3f1cc, + 0x1418303, + 0xd2cc8, + 0xce2cb, + 0xb0bc9, + 0xd7743, + 0x11bf88, + 0x1425d06, + 0x98307, + 0x40f5d489, + 0x422eb088, + 0xa3b47, + 0xfc18a, + 0x42763748, + 0x11628d, + 0x1c7e49, + 0x11448, + 0x2043, + 0x1455349, + 0x212c4, + 0x14c945, + 0x2d143, + 0x332c6, + 0xf7548, + 0x1403842, + 0x18944, + 0x2b405, + 0x149c3c3, + 0x2d907, + 0x41205483, + 0x41771a06, + 0x41a44084, + 0x41f73a47, + 0xf7544, + 0xf7544, + 0xf7544, + 0xf7544, + 0x2cc9, + 0x41, + 0x229f43, + 0x224d03, + 0x2e9c43, + 0x219c03, + 0x2127c3, + 0x21f483, + 0x2000c2, + 0x205842, + 0x2e9c43, + 0x203842, + 0x2127c3, + 0x21f483, + 0x217083, + 0x38e28f, + 0x38e64e, + 0x7ffc8, + 0x229f43, + 0x50a07, + 0x224d03, + 0x2e9c43, + 0x25e043, + 0x2127c3, + 0x21f483, + 0x2304, + 0x1604, + 0xa9c4, + 0x225543, + 0x373d07, + 0x205b42, + 0x27c049, + 0x200ac2, + 0x38fe4b, + 0x2b038a, + 0x2e9f09, + 0x200542, + 0x22be06, + 0x3a0355, + 0x38ff95, + 0x25ab13, + 0x390513, + 0x20b602, + 0x20b605, + 0x20b60c, + 0x2833cb, + 0x251605, + 0x201182, + 0x30c842, + 0x36e406, + 0x200ec2, + 0x2da306, + 0x215ccd, + 0x2ca88c, + 0x3c8c84, + 0x200882, + 0x204e42, + 0x26a508, + 0x200202, + 0x2016c6, + 0x3a2fcf, + 0x2016d0, + 0x23a404, + 0x3a0515, + 0x25ac93, + 0x21e943, + 0x3541ca, + 0x392747, + 0x397ec9, + 0x30e4c7, + 0x327082, + 0x200282, + 0x3ceec6, + 0x2045c2, + 0x7ffc8, + 0x20a182, + 0x202a02, + 0x211907, + 0x398247, + 0x398251, + 0x2223c5, + 0x2223ce, + 0x22284f, + 0x2037c2, + 0x30ef87, + 0x225588, + 0x205f42, + 0x2272c2, + 0x212306, + 0x21230f, + 0x242910, + 0x232382, + 0x203702, + 0x2efdc8, + 0x207243, + 0x297948, + 0x2bbfcd, + 0x203703, + 0x3d3bc8, + 0x293e0f, + 0x2941ce, + 0x3e198a, + 0x2ee1d1, + 0x2ee650, + 0x22320d, + 0x22354c, + 0x3c5a07, + 0x354347, + 0x372049, + 0x21e742, + 0x202542, + 0x266e4c, + 0x26714b, + 0x202102, + 0x2db7c6, + 0x212fc2, + 0x200482, + 0x2b90c2, + 0x205842, + 0x235644, + 0x2456c7, + 0x20f1c2, + 0x24adc7, + 0x24d147, + 0x213682, + 0x215582, + 0x2508c5, + 0x201bc2, + 0x2dbd4e, + 0x2138cd, + 0x224d03, + 0x3b494e, + 0x2cda8d, + 0x332183, + 0x200d42, + 0x2958c4, + 0x29e2c2, + 0x220f42, + 0x3ac685, + 0x3b0dc7, + 0x254482, + 0x218b02, + 0x25b147, + 0x260588, + 0x262642, + 0x27b6c6, + 0x266ccc, + 0x26700b, + 0x202e42, + 0x27274f, + 0x272b10, + 0x272f0f, + 0x2732d5, + 0x273814, + 0x273d0e, + 0x27408e, + 0x27440f, + 0x2747ce, + 0x274b54, + 0x275053, + 0x27550d, + 0x289509, + 0x29be83, + 0x2038c2, + 0x35ed05, + 0x204b06, + 0x200382, + 0x36dc47, + 0x2e9c43, + 0x200642, + 0x3e7088, + 0x2ee411, + 0x2ee850, + 0x208102, + 0x29b207, + 0x203382, + 0x262807, + 0x208042, + 0x335309, + 0x36e3c7, + 0x28c948, + 0x3d1306, + 0x2fe243, + 0x39d7c5, + 0x22b342, + 0x2004c2, + 0x208a85, + 0x367d45, + 0x204442, + 0x25c083, + 0x349e07, + 0x3d1887, + 0x202d02, + 0x39a304, + 0x20d003, + 0x3d1d49, + 0x3db288, + 0x20b982, + 0x20fd02, + 0x243e47, + 0x2f04c5, + 0x237e48, + 0x350847, + 0x20e983, + 0x2fba46, + 0x22308d, + 0x22340c, + 0x39f706, + 0x203782, + 0x202c82, + 0x2026c2, + 0x293c8f, + 0x29408e, + 0x37bf87, + 0x205c02, + 0x219c05, + 0x219c06, + 0x21dfc2, + 0x20dec2, + 0x29cb06, + 0x210043, + 0x347146, + 0x2e34c5, + 0x2e34cd, + 0x2e3a55, + 0x2e4b0c, + 0x2e4e8d, + 0x2e51d2, + 0x20f782, + 0x27eec2, + 0x204342, + 0x217506, + 0x204346, + 0x43a8bec4, + 0x201242, + 0x204b86, + 0x214542, + 0x3d8045, + 0x202a42, + 0x2139c9, + 0x23388c, + 0x233bcb, + 0x2003c2, + 0x261708, + 0x20df02, + 0x200a82, + 0x283186, + 0x261c45, + 0x393507, + 0x3a81c5, + 0x26d105, + 0x2020c2, + 0x216342, + 0x20f102, + 0x2a10c7, + 0x301a0d, + 0x301d8c, + 0x24efc7, + 0x22e6c2, + 0x215502, + 0x3cf0c8, + 0x34a8c8, + 0x34d908, + 0x3c0384, + 0x2dc887, + 0x2ff703, + 0x253ac2, + 0x2043c2, + 0x302609, + 0x2336c7, + 0x202782, + 0x2837c5, + 0x285042, + 0x20e0c2, + 0x3095c3, + 0x3095c6, + 0x309742, + 0x30bd02, + 0x200402, + 0x3bd706, + 0x34ed07, + 0x21e202, + 0x200902, + 0x29778f, + 0x3b478d, + 0x38c84e, + 0x2cd90c, + 0x20a602, + 0x203342, + 0x3d1145, + 0x323f46, + 0x202682, + 0x206902, + 0x200682, + 0x2cdc04, + 0x2bbe44, + 0x358906, + 0x201782, + 0x28e207, + 0x248883, + 0x248888, + 0x2496c8, + 0x256887, + 0x3ab886, + 0x205f82, + 0x212f43, + 0x212f47, + 0x282d06, + 0x2d8485, + 0x285348, + 0x204942, + 0x38a4c7, + 0x207802, + 0x29ec82, + 0x203682, + 0x201889, + 0x2088c2, + 0x14cc8, + 0x200e02, + 0x2aa083, + 0x200e87, + 0x202602, + 0x233a0c, + 0x233d0b, + 0x39f786, + 0x20e385, + 0x43e27303, + 0x201c82, + 0x200fc2, + 0x2d5146, + 0x243783, + 0x354547, + 0x26d0c2, + 0x2008c2, + 0x3a01d5, + 0x390155, + 0x25a9d3, + 0x390693, + 0x277487, + 0x287591, + 0x288f50, + 0x296b12, + 0x299e51, + 0x2ac948, + 0x3b9dd0, + 0x2ac94f, + 0x2b0153, + 0x37b092, + 0x39b750, + 0x2c2acf, + 0x2c6152, + 0x2c7851, + 0x2c8dd3, + 0x2ccf12, + 0x2d498f, + 0x2e314e, + 0x2e4692, + 0x2e9d11, + 0x2ea3cf, + 0x2ed08e, + 0x2ed891, + 0x2f2810, + 0x2f3b12, + 0x2f6c51, + 0x2fda90, + 0x3064cf, + 0x307691, + 0x309ad0, + 0x30c9c6, + 0x30d987, + 0x311047, + 0x205dc2, + 0x292805, + 0x3dec07, + 0x26ca02, + 0x202d82, + 0x3cbe45, + 0x20a503, + 0x2718c6, + 0x301bcd, + 0x301f0c, + 0x204c02, + 0x20b48b, + 0x28328a, + 0x286d8a, + 0x227549, + 0x2d3d0b, + 0x300ccd, + 0x35098c, + 0x312e0a, + 0x36ee0c, + 0x3d4f8b, + 0x25144c, + 0x2813ce, + 0x28818b, + 0x2a724c, + 0x2ecd03, + 0x352f06, + 0x363742, + 0x308602, + 0x25f183, + 0x208602, + 0x23fa43, + 0x2d6ec6, + 0x273487, + 0x2d9706, + 0x3aefc8, + 0x349c88, + 0x321a86, + 0x212182, + 0x31378d, + 0x313acc, + 0x221947, + 0x317507, + 0x228282, + 0x21f182, + 0x212ec2, + 0x28f8c2, + 0x337216, + 0x33c315, + 0x33f8d6, + 0x3435d3, + 0x343c92, + 0x356513, + 0x3573d2, + 0x3bb24f, + 0x3caad8, + 0x3ce957, + 0x3cfb99, + 0x3d3318, + 0x3d3dd8, + 0x3d4957, + 0x3d8357, + 0x3d91d6, + 0x3df613, + 0x3dff95, + 0x3e0952, + 0x3e0dd3, + 0x1e702, + 0x4420f0c4, + 0x447c8bc8, + 0x2cc5, + 0x205842, + 0x2127c3, + 0x47f42, + 0x21f483, + 0x229f43, + 0x224d03, + 0x2e9c43, + 0x219c03, + 0x222d84, + 0x2127c3, + 0x21f483, + 0x217083, + 0x2000c2, + 0x202ac2, + 0x456a2d45, + 0x45a3d685, + 0x45f6f186, + 0x7ffc8, + 0x462c9445, + 0x205842, + 0x201902, + 0x46730c85, + 0x46a91485, + 0x46e91f07, + 0x47358c49, + 0x4761d684, + 0x200382, + 0x200642, + 0x47a5c245, + 0x47ea2689, + 0x4836cc48, + 0x486c19c5, + 0x48b51107, + 0x48e1b008, + 0x4930d585, + 0x49623f46, + 0x49a531c9, + 0x49f7fbc8, + 0x4a2db448, + 0x4a6aa18a, + 0x4aa39104, + 0x4ae9cdc5, + 0x4b2b4708, + 0x4b654b45, + 0x21c142, + 0x4ba089c3, + 0x4beb4ec6, + 0x4c328ec8, + 0x4c746546, + 0x4cb4ee48, + 0x4cfb6006, + 0x4d3854c4, + 0x4d6048c2, + 0x4dee9287, + 0x4e2bcd44, + 0x4e68d7c7, + 0x4ebe8dc7, + 0x2003c2, + 0x4eead945, + 0x4f2854c4, + 0x4f7839c7, + 0x4fa48087, + 0x4fe95706, + 0x50218085, + 0x506a8b87, + 0x50ae8c88, + 0x50eb8c07, + 0x512bebc9, + 0x516e9a45, + 0x51b0fc07, + 0x51ea2386, + 0x2c68b, + 0x5236fc88, + 0x2289cd, + 0x284949, + 0x2a290b, + 0x2b0e8b, + 0x2b94cb, + 0x37880b, + 0x32414b, + 0x32440b, + 0x3248c9, + 0x32574b, + 0x325a0b, + 0x32680b, + 0x32740a, + 0x32794a, + 0x327f4c, + 0x32c2cb, + 0x32c80a, + 0x34144a, + 0x34bf0e, + 0x34cf0e, + 0x34d28a, + 0x34f70a, + 0x35164b, + 0x35190b, + 0x35240b, + 0x3767cb, + 0x376dca, + 0x377a8b, + 0x377d4a, + 0x377fca, + 0x37824a, + 0x39b34b, + 0x3a228b, + 0x3a548e, + 0x3a580b, + 0x3acbcb, + 0x3add0b, + 0x3b1a8a, + 0x3b1d09, + 0x3b1f4a, + 0x3b3e8a, + 0x3ca4cb, + 0x3dd44b, + 0x3de4ca, + 0x3df04b, + 0x3e694b, + 0x3ef20b, + 0x52693288, + 0x52a99789, + 0x52eb0a49, + 0x532f7d08, + 0x358685, + 0x20c003, + 0x260a44, + 0x34f285, + 0x21d3c6, + 0x223cc5, + 0x299004, + 0x36db48, + 0x31e445, + 0x2a46c4, + 0x3d5f87, + 0x2afb4a, + 0x384c8a, + 0x37c087, + 0x329087, + 0x2f2d47, + 0x25c3c7, + 0x207505, + 0x224346, + 0x37bb87, + 0x3ce084, + 0x2ced86, + 0x3048c6, + 0x3cf605, + 0x3324c4, + 0x2ad586, + 0x2aed87, + 0x2301c6, + 0x318287, + 0x240903, + 0x3c6c46, + 0x220b05, + 0x292007, + 0x27ba0a, + 0x310484, + 0x21a988, + 0x2be509, + 0x3c0a07, + 0x3c9f86, + 0x26c248, + 0x3e9149, + 0x310504, + 0x282884, + 0x304b45, + 0x222c88, + 0x2e1b87, + 0x30bec9, + 0x2f0e88, + 0x319806, + 0x328986, + 0x2aadc8, + 0x375846, + 0x23d685, + 0x2957c6, + 0x28db88, + 0x293b86, + 0x26608b, + 0x29eb06, + 0x2ac4cd, + 0x3da785, + 0x2bcc06, + 0x21b0c5, + 0x304d09, + 0x2d86c7, + 0x219a88, + 0x3c0746, + 0x2ab709, + 0x2ca346, + 0x27b985, + 0x219186, + 0x2dd006, + 0x2e6089, + 0x2d1846, + 0x2c8a07, + 0x364e85, + 0x202a43, + 0x266205, + 0x39ea47, + 0x335ac6, + 0x3da689, + 0x36f186, + 0x295a06, + 0x24b3c9, + 0x2951c9, + 0x2b3587, + 0x3642c8, + 0x29df09, + 0x292488, + 0x3ed546, + 0x2eec45, + 0x3220ca, + 0x295a86, + 0x3cb586, + 0x2e91c5, + 0x25f988, + 0x35b587, + 0x2387ca, + 0x25c686, + 0x303605, + 0x30c706, + 0x2a3407, + 0x3c9e47, + 0x30eb45, + 0x27bb45, + 0x242786, + 0x246246, + 0x255046, + 0x2b4bc4, + 0x294549, + 0x29afc6, + 0x378bca, + 0x22de48, + 0x30f908, + 0x384c8a, + 0x23c3c5, + 0x2aecc5, + 0x3d2808, + 0x3206c8, + 0x248307, + 0x23c286, + 0x339dc8, + 0x3d7687, + 0x292b88, + 0x2d0286, + 0x296488, + 0x2a8046, + 0x359147, + 0x245906, + 0x2ad586, + 0x243aca, + 0x39f886, + 0x2eec49, + 0x3bd606, + 0x211a4a, + 0x3854c9, + 0x240c06, + 0x2d2544, + 0x35edcd, + 0x2912c7, + 0x3c7506, + 0x2db305, + 0x2ca3c5, + 0x39cd86, + 0x2cc849, + 0x2dddc7, + 0x28ea46, + 0x2c9b06, + 0x299089, + 0x23d5c4, + 0x240d04, + 0x20bec8, + 0x35dac6, + 0x3dde08, + 0x219108, + 0x264787, + 0x3bcd49, + 0x3d0487, + 0x2c930a, + 0x3030cf, + 0x39b0ca, + 0x3d0f45, + 0x28ddc5, + 0x218f45, + 0x23a347, + 0x28f6c3, + 0x3644c8, + 0x236606, + 0x236709, + 0x2fc746, + 0x2e6a47, + 0x2ab4c9, + 0x219988, + 0x304ec7, + 0x322683, + 0x358705, + 0x2a2f45, + 0x2b4a0b, + 0x254c04, + 0x37a8c4, + 0x28b806, + 0x322847, + 0x39d30a, + 0x259587, + 0x2297c7, + 0x291485, + 0x3d9745, + 0x29e409, + 0x2ad586, + 0x25940d, + 0x346cc5, + 0x2b4c83, + 0x21df03, + 0x2fcac5, + 0x33a6c5, + 0x26c248, + 0x28f207, + 0x24e486, + 0x2b06c6, + 0x2316c5, + 0x23e987, + 0x331047, + 0x260d87, + 0x29ce4a, + 0x3c6d08, + 0x2b4bc4, + 0x293907, + 0x290647, + 0x360686, + 0x2a76c7, + 0x2f50c8, + 0x278fc8, + 0x280b46, + 0x3292c8, + 0x22ec44, + 0x37bb86, + 0x2693c6, + 0x38d946, + 0x20a246, + 0x2add04, + 0x25c486, + 0x2d9886, + 0x2aa686, + 0x20e506, + 0x3dac86, + 0x239a46, + 0x24e388, + 0x2cbd48, + 0x2ebec8, + 0x223ec8, + 0x3d2786, + 0x204005, + 0x372b86, + 0x2c1a45, + 0x32d207, + 0x280d85, + 0x215243, + 0x310c85, + 0x396884, + 0x3dadc5, + 0x20df03, + 0x2ca187, + 0x3ae008, + 0x318346, + 0x2c004d, + 0x28dd86, + 0x2a9c05, + 0x201883, + 0x2d6749, + 0x23d746, + 0x2a9146, + 0x21b404, + 0x39b047, + 0x3cdf86, + 0x303845, + 0x239803, + 0x3ec004, + 0x290806, + 0x224444, + 0x3c3448, + 0x3d8b09, + 0x281009, + 0x2b1d0a, + 0x25258d, + 0x3e7507, + 0x3d7086, + 0x216384, + 0x358c49, + 0x297d48, + 0x299606, + 0x246dc6, + 0x2a76c7, + 0x37aa06, + 0x21de46, + 0x3bd006, + 0x3e8e4a, + 0x21b008, + 0x2bae85, + 0x3866c9, + 0x3ccd0a, + 0x397988, + 0x2ae188, + 0x2a90c8, + 0x3296cc, + 0x3a2505, + 0x2b0948, + 0x2cfd86, + 0x2a3a06, + 0x2e0947, + 0x259485, + 0x295945, + 0x280ec9, + 0x20db47, + 0x2366c5, + 0x228e87, + 0x21df03, + 0x2e2545, + 0x22e248, + 0x294e47, + 0x2ae049, + 0x2d4205, + 0x36e684, + 0x31cf48, + 0x2bc287, + 0x305088, + 0x22c1c8, + 0x39e745, + 0x276dc6, + 0x2b07c6, + 0x35c509, + 0x2694c7, + 0x2c2306, + 0x3684c7, + 0x205383, + 0x21d684, + 0x22ed45, + 0x23eac4, + 0x38d244, + 0x293507, + 0x27a4c7, + 0x28ec04, + 0x2ade90, + 0x3868c7, + 0x3d9745, + 0x385f4c, + 0x207504, + 0x2bf3c8, + 0x359049, + 0x2c5ec6, + 0x31c0c8, + 0x205c04, + 0x28bb08, + 0x298b06, + 0x243948, + 0x2af346, + 0x31ffcb, + 0x3745c5, + 0x22ebc8, + 0x2186c4, + 0x3d8f4a, + 0x2ae049, + 0x3d6746, + 0x222f08, + 0x26a045, + 0x2d5cc4, + 0x2bf2c6, + 0x260c48, + 0x293288, + 0x3344c6, + 0x331c84, + 0x322046, + 0x3d0507, + 0x28d6c7, + 0x2a76cf, + 0x346087, + 0x39e187, + 0x36ca85, + 0x209e85, + 0x2b3249, + 0x31f7c6, + 0x292145, + 0x2954c7, + 0x2e4288, + 0x2244c5, + 0x245906, + 0x22dc88, + 0x34654a, + 0x24a588, + 0x29c887, + 0x303506, + 0x386686, + 0x2003c3, + 0x219d43, + 0x3ccec9, + 0x29dd89, + 0x2beac6, + 0x2d4205, + 0x329548, + 0x222f08, + 0x2ad1c8, + 0x3bd08b, + 0x2c0287, + 0x31c609, + 0x2a7948, + 0x34eb84, + 0x3d6a48, + 0x2a07c9, + 0x2c2605, + 0x2b83c7, + 0x21d705, + 0x293188, + 0x2a2bcb, + 0x2a88d0, + 0x2bc845, + 0x21860c, + 0x24e645, + 0x288a83, + 0x2d4d46, + 0x2d8d84, + 0x299486, + 0x2aed87, + 0x223ec4, + 0x2ce548, + 0x36438d, + 0x341805, + 0x22ebc4, + 0x2ba544, + 0x39dec9, + 0x2ac208, + 0x32f6c7, + 0x298b88, + 0x294608, + 0x28ed45, + 0x3cd207, + 0x28ecc7, + 0x2369c7, + 0x27bb49, + 0x288849, + 0x221346, + 0x223746, + 0x295586, + 0x323a45, + 0x3c6a84, + 0x3d4386, + 0x3d88c6, + 0x28ed88, + 0x2a30cb, + 0x310347, + 0x216384, + 0x3cdec6, + 0x219447, + 0x239645, + 0x286745, + 0x269984, + 0x2887c6, + 0x3d4408, + 0x358c49, + 0x25f5c6, + 0x297b48, + 0x303906, + 0x364dc8, + 0x2dadcc, + 0x28ec06, + 0x2a98cd, + 0x2a9d4b, + 0x2c8ac5, + 0x331187, + 0x2d1946, + 0x3c9d08, + 0x2213c9, + 0x2c0588, + 0x3d9745, + 0x2a82c7, + 0x292588, + 0x371d89, + 0x38eb86, + 0x262d4a, + 0x3c9a88, + 0x2c03cb, + 0x2de38c, + 0x28bc08, + 0x28fec6, + 0x3725c8, + 0x3461c7, + 0x2a8589, + 0x2a258d, + 0x2ad486, + 0x3049c8, + 0x2cbc09, + 0x2d7488, + 0x296588, + 0x2da48c, + 0x2dc187, + 0x2dd187, + 0x27b985, + 0x2cf707, + 0x2e4148, + 0x2bf346, + 0x25f44c, + 0x306948, + 0x2e7608, + 0x220846, + 0x30aa07, + 0x221544, + 0x223ec8, + 0x321b8c, + 0x29aa0c, + 0x3d0fc5, + 0x3cf687, + 0x331c06, + 0x30a986, + 0x38be48, + 0x225804, + 0x2301cb, + 0x374dcb, + 0x303506, + 0x364207, + 0x374845, + 0x2827c5, + 0x230306, + 0x26a005, + 0x254bc5, + 0x2e5ec7, + 0x20df09, + 0x203a84, + 0x248c45, + 0x309505, + 0x217f48, + 0x35de45, + 0x2d4649, + 0x2c0cc7, + 0x2c0ccb, + 0x302106, + 0x24e0c9, + 0x332408, + 0x289985, + 0x236ac8, + 0x288888, + 0x3b5207, + 0x298907, + 0x293589, + 0x243887, + 0x29b5c9, + 0x2bdbcc, + 0x2beac8, + 0x2de1c9, + 0x3a1407, + 0x2946c9, + 0x3e1347, + 0x2de488, + 0x3e1545, + 0x37bb06, + 0x2db348, + 0x2ec7c8, + 0x3ccbc9, + 0x254c07, + 0x2b1f05, + 0x207c09, + 0x36a346, + 0x2a2384, + 0x30ce06, + 0x328d48, + 0x23da47, + 0x2a32c8, + 0x329389, + 0x323307, + 0x2ad306, + 0x331244, + 0x310d09, + 0x3cd088, + 0x220707, + 0x297346, + 0x2a3006, + 0x3cb504, + 0x2fb8c6, + 0x207cc3, + 0x374149, + 0x374586, + 0x2bce85, + 0x2b06c6, + 0x20e685, + 0x292a08, + 0x204f87, + 0x247806, + 0x330cc6, + 0x30f908, + 0x2b33c7, + 0x2ad4c5, + 0x2adc88, + 0x3dd848, + 0x3c9a88, + 0x24e505, + 0x37bb86, + 0x280dc9, + 0x35c384, + 0x20e50b, + 0x21db4b, + 0x2bad89, + 0x21df03, + 0x267ec5, + 0x338106, + 0x250248, + 0x3a7644, + 0x318346, + 0x29cf89, + 0x2c6c05, + 0x2e5e06, + 0x2bc286, + 0x222f04, + 0x2ae30a, + 0x2bcdc8, + 0x2ec7c6, + 0x379ac5, + 0x383187, + 0x33a907, + 0x276dc4, + 0x21dd87, + 0x2c9304, + 0x2f0f06, + 0x205bc3, + 0x27bb45, + 0x2c4ac5, + 0x3e1708, + 0x293ac5, + 0x28e949, + 0x223d07, + 0x223d0b, + 0x2b4ccc, + 0x2b52ca, + 0x351107, + 0x208c03, + 0x28d0c8, + 0x240cc5, + 0x224545, + 0x3587c4, + 0x2de386, + 0x359046, + 0x2fb907, + 0x26458b, + 0x2add04, + 0x36cbc4, + 0x2e1404, + 0x2e5bc6, + 0x223ec4, + 0x222d88, + 0x3585c5, + 0x252bc5, + 0x2ad107, + 0x331289, + 0x33a6c5, + 0x39cd8a, + 0x3de289, + 0x2a678a, + 0x3e8f89, + 0x312c84, + 0x2c9bc5, + 0x37ab08, + 0x383a8b, + 0x304b45, + 0x219286, + 0x24d204, + 0x28ee86, + 0x323189, + 0x219547, + 0x36f348, + 0x252906, + 0x3d0487, + 0x293288, + 0x380146, + 0x3d6e04, + 0x26ae87, + 0x390e85, + 0x39f0c7, + 0x205b04, + 0x2d18c6, + 0x33aa48, + 0x2a9f08, + 0x31a707, + 0x385088, + 0x2a8105, + 0x21dc84, + 0x384b88, + 0x320fc4, + 0x218ec5, + 0x38bc44, + 0x3d7787, + 0x29b087, + 0x294808, + 0x305206, + 0x293a45, + 0x28e748, + 0x24a788, + 0x2b1c49, + 0x21de46, + 0x238848, + 0x3d8dca, + 0x2396c8, + 0x30d585, + 0x372d86, + 0x3de148, + 0x2a838a, + 0x35bb07, + 0x298185, + 0x2a4d88, + 0x270504, + 0x25fa06, + 0x2dd808, + 0x3dac86, + 0x33b048, + 0x231cc7, + 0x3d5e86, + 0x2d2544, + 0x34c407, + 0x2cc184, + 0x323147, + 0x2eff4d, + 0x248385, + 0x2cc64b, + 0x29ac86, + 0x261808, + 0x2ce504, + 0x255246, + 0x290806, + 0x372907, + 0x2a958d, + 0x308a87, + 0x2cd508, + 0x3b4dc5, + 0x29e5c8, + 0x2e1b06, + 0x2a8188, + 0x23f1c6, + 0x385cc7, + 0x2e93c9, + 0x35b387, + 0x2998c8, + 0x26e5c5, + 0x231748, + 0x30a8c5, + 0x245845, + 0x370505, + 0x2191c3, + 0x20a2c4, + 0x239785, + 0x2531c9, + 0x37b946, + 0x2f51c8, + 0x249b85, + 0x2cf5c7, + 0x2d89ca, + 0x2e5d49, + 0x2dcf0a, + 0x2ebf48, + 0x228ccc, + 0x29554d, + 0x303b03, + 0x33af48, + 0x3ebfc5, + 0x346306, + 0x219806, + 0x35ea85, + 0x3685c9, + 0x208b85, + 0x28e748, + 0x268e86, + 0x370d06, + 0x2b3cc9, + 0x26ba87, + 0x2a2e86, + 0x2d8948, + 0x38d848, + 0x2f7f07, + 0x2e62ce, + 0x2e1d45, + 0x371c85, + 0x3dab88, + 0x3327c7, + 0x20df82, + 0x2da144, + 0x29938a, + 0x2207c8, + 0x2889c6, + 0x2ab608, + 0x2b07c6, + 0x209d08, + 0x2c2308, + 0x245804, + 0x2cf985, + 0x773104, + 0x773104, + 0x773104, + 0x203e03, + 0x2038c6, + 0x28ec06, + 0x2af74c, + 0x205c43, + 0x205b06, + 0x21b284, + 0x23d6c8, + 0x29cdc5, + 0x299486, + 0x2b4808, + 0x2ecdc6, + 0x247786, + 0x3d6548, + 0x22edc7, + 0x243649, + 0x33824a, + 0x27a644, + 0x280d85, + 0x30be85, + 0x358a46, + 0x3e7546, + 0x3316c6, + 0x36a0c6, + 0x243784, + 0x24378b, + 0x23da44, + 0x24e245, + 0x2c1285, + 0x264846, + 0x3e9788, + 0x295407, + 0x374504, + 0x26f0c3, + 0x270005, + 0x30ccc7, + 0x29530b, + 0x3e1607, + 0x2b4708, + 0x2cfac7, + 0x27e146, + 0x284c08, + 0x2a6d4b, + 0x34f1c6, + 0x2103c9, + 0x2a6ec5, + 0x322683, + 0x2e5e06, + 0x231bc8, + 0x214283, + 0x2d1a03, + 0x293286, + 0x2b07c6, + 0x37e60a, + 0x28ff05, + 0x29064b, + 0x2b060b, + 0x24da83, + 0x20a8c3, + 0x2c9284, + 0x2d8807, + 0x231c44, + 0x23d6c4, + 0x2cfc04, + 0x2399c8, + 0x379a08, + 0x219f49, + 0x2e9ac8, + 0x3c7787, + 0x20e506, + 0x2f4e0f, + 0x2e1e86, + 0x2eb284, + 0x37984a, + 0x30cbc7, + 0x2cc286, + 0x2a23c9, + 0x219ec5, + 0x246305, + 0x21a006, + 0x231883, + 0x270549, + 0x21b186, + 0x329149, + 0x39d306, + 0x27bb45, + 0x3d13c5, + 0x203383, + 0x3cc588, + 0x32f887, + 0x236604, + 0x23d548, + 0x2a3784, + 0x320ec6, + 0x2d4d46, + 0x249406, + 0x22ea89, + 0x2244c5, + 0x2ad586, + 0x262689, + 0x2e1006, + 0x239a46, + 0x3afcc6, + 0x22e9c5, + 0x38bc46, + 0x385cc4, + 0x3e1545, + 0x2db344, + 0x2cec86, + 0x346c84, + 0x219543, + 0x297e05, + 0x23fb48, + 0x255787, + 0x3a76c9, + 0x298088, + 0x2aab91, + 0x2bc30a, + 0x303447, + 0x279306, + 0x21b284, + 0x2db448, + 0x2f6088, + 0x2aad4a, + 0x2d440d, + 0x219186, + 0x3d6646, + 0x34c4c6, + 0x30e9c7, + 0x2cd5c5, + 0x3bcb07, + 0x23d605, + 0x2c0e04, + 0x347246, + 0x23c0c7, + 0x27024d, + 0x3de087, + 0x36da48, + 0x28ea49, + 0x372c86, + 0x38eb05, + 0x245404, + 0x328e46, + 0x3bcc46, + 0x220946, + 0x2abe88, + 0x233803, + 0x218183, + 0x384745, + 0x25c786, + 0x2c22c5, + 0x252b08, + 0x2aef4a, + 0x276ec4, + 0x23d6c8, + 0x2a90c8, + 0x39ec07, + 0x298789, + 0x2d6a88, + 0x2bec47, + 0x2d9a06, + 0x3dac8a, + 0x328ec8, + 0x31ce09, + 0x2ac2c8, + 0x21d009, + 0x2791c7, + 0x2cca05, + 0x3bd286, + 0x2bf1c8, + 0x28a308, + 0x2662c8, + 0x341948, + 0x24e245, + 0x20bcc4, + 0x23dd08, + 0x24cf84, + 0x3e8d84, + 0x27bb45, + 0x2a4707, + 0x331049, + 0x372707, + 0x238885, + 0x28ba06, + 0x3792c6, + 0x210504, + 0x2b3fc6, + 0x290a84, + 0x28b0c6, + 0x330e06, + 0x2140c6, + 0x3d9745, + 0x2529c7, + 0x208c03, + 0x270d09, + 0x30f708, + 0x23d544, + 0x358b4d, + 0x2aa008, + 0x3012c8, + 0x31cd86, + 0x2e94c9, + 0x2e5d49, + 0x322e85, + 0x2af04a, + 0x281a0a, + 0x28e44c, + 0x28e5c6, + 0x28ccc6, + 0x2e2486, + 0x3ac749, + 0x346546, + 0x2b3406, + 0x208c46, + 0x223ec8, + 0x24a586, + 0x2eaa4b, + 0x2a4885, + 0x252bc5, + 0x28d7c5, + 0x20bc46, + 0x219143, + 0x249386, + 0x3de007, + 0x2db305, + 0x28c085, + 0x2ca3c5, + 0x2f9a46, + 0x322f44, + 0x336946, + 0x2a0b09, + 0x20bacc, + 0x2c0b48, + 0x260bc4, + 0x37fac6, + 0x29ad86, + 0x231bc8, + 0x222f08, + 0x20b9c9, + 0x383187, + 0x35d809, + 0x283886, + 0x219104, + 0x20fd44, + 0x293884, + 0x293288, + 0x330e8a, + 0x33a646, + 0x36c947, + 0x39f347, + 0x24e1c5, + 0x2b6904, + 0x2a0786, + 0x2cd606, + 0x205083, + 0x30f547, + 0x22c0c8, + 0x322fca, + 0x3cf988, + 0x34ee48, + 0x346cc5, + 0x229005, + 0x310445, + 0x24e586, + 0x250fc6, + 0x3e1845, + 0x374389, + 0x2b670c, + 0x34a587, + 0x2aadc8, + 0x295dc5, + 0x773104, + 0x2bb4c4, + 0x294f84, + 0x24b586, + 0x2b150e, + 0x246387, + 0x301285, + 0x35c30c, + 0x2a3647, + 0x23c047, + 0x247a89, + 0x21aa49, + 0x298185, + 0x30f708, + 0x280dc9, + 0x3c9945, + 0x2db248, + 0x2e8e86, + 0x384e06, + 0x3854c4, + 0x31c7c8, + 0x252483, + 0x2034c4, + 0x270085, + 0x3a4807, + 0x3235c5, + 0x3d8c89, + 0x39138d, + 0x2b2246, + 0x3d5504, + 0x23c208, + 0x20dd4a, + 0x3a9947, + 0x34a405, + 0x203503, + 0x2b07ce, + 0x3cc68c, + 0x397a87, + 0x2b16c7, + 0x4dba3607, + 0x2b4c6, + 0x2c684, + 0x205b43, + 0x346585, + 0x294f85, + 0x2ab9c8, + 0x2a8f09, + 0x260ac6, + 0x231c44, + 0x303386, + 0x38d60b, + 0x2e00cc, + 0x267c47, + 0x2ead05, + 0x3dd748, + 0x2f7cc5, + 0x379847, + 0x2e9287, + 0x252485, + 0x219143, + 0x245ac4, + 0x328c05, + 0x203985, + 0x203986, + 0x2a0588, + 0x23c0c7, + 0x219b06, + 0x3cb406, + 0x370446, + 0x2d1a49, + 0x3cd307, + 0x260946, + 0x2e0246, + 0x239006, + 0x2bcd05, + 0x20d646, + 0x3b5c05, + 0x35dec8, + 0x2a434b, + 0x2a0106, + 0x39f384, + 0x23a1c9, + 0x223d04, + 0x2e8e08, + 0x311707, + 0x296484, + 0x2d5ec8, + 0x2dca44, + 0x2bcd44, + 0x23d485, + 0x341846, + 0x239907, + 0x22eb83, + 0x2ad3c5, + 0x33ecc4, + 0x371cc6, + 0x322f08, + 0x384f85, + 0x2a4009, + 0x207e05, + 0x205b08, + 0x35c1c7, + 0x374688, + 0x2d5b07, + 0x39e249, + 0x25c306, + 0x3a0fc6, + 0x208c44, + 0x20e445, + 0x3dce8c, + 0x28d7c7, + 0x28dc87, + 0x3e7188, + 0x2b2246, + 0x3ddf44, + 0x31da44, + 0x293409, + 0x2e2586, + 0x29e487, + 0x372a44, + 0x2b40c6, + 0x3d22c5, + 0x2e9107, + 0x2ea9c6, + 0x262c09, + 0x31f9c7, + 0x2a76c7, + 0x2b3b46, + 0x297285, + 0x291a88, + 0x21b008, + 0x375b46, + 0x384fc5, + 0x2dedc6, + 0x203e43, + 0x2ab849, + 0x33144e, + 0x2d5848, + 0x2a3888, + 0x37594b, + 0x2a4246, + 0x39f244, + 0x247784, + 0x33154a, + 0x218507, + 0x260a05, + 0x2103c9, + 0x2d9945, + 0x3e8dc7, + 0x245b84, + 0x2900c7, + 0x219008, + 0x3c0ac6, + 0x2d6fc9, + 0x2d6b8a, + 0x218486, + 0x2a9b46, + 0x2c1205, + 0x3a5dc5, + 0x3a9647, + 0x251a88, + 0x3d2208, + 0x245806, + 0x3d1445, + 0x3e72ce, + 0x2b4bc4, + 0x2ab945, + 0x28b389, + 0x31f5c8, + 0x29c7c6, + 0x2ad78c, + 0x2aeb50, + 0x2b114f, + 0x2b3148, + 0x351107, + 0x3d9745, + 0x239785, + 0x239789, + 0x2a4f89, + 0x322146, + 0x304bc7, + 0x38bd45, + 0x248309, + 0x360706, + 0x34638d, + 0x293749, + 0x23d6c4, + 0x2d5048, + 0x23ddc9, + 0x33a806, + 0x28d2c5, + 0x3a0fc6, + 0x36f209, + 0x36fb08, + 0x204005, + 0x2a0504, + 0x2ad94b, + 0x33a6c5, + 0x2502c6, + 0x295886, + 0x25d146, + 0x24e80b, + 0x2a4109, + 0x3e1485, + 0x32d107, + 0x2bc286, + 0x261986, + 0x294d08, + 0x2d9b09, + 0x36d80c, + 0x30cac8, + 0x31bb06, + 0x3344c3, + 0x235f06, + 0x240c45, + 0x291188, + 0x3d0e46, + 0x304f88, + 0x259605, + 0x26bf45, + 0x2ddf88, + 0x383487, + 0x219747, + 0x2fb907, + 0x31c0c8, + 0x351248, + 0x2f5f86, + 0x2ceac7, + 0x21d547, + 0x39dfca, + 0x205cc3, + 0x20bc46, + 0x260d05, + 0x2854c4, + 0x28ea49, + 0x39e1c4, + 0x200e84, + 0x2af3c4, + 0x2b16cb, + 0x32f7c7, + 0x2f9a05, + 0x2a7e08, + 0x28ba06, + 0x28ba08, + 0x28fe46, + 0x29d2c5, + 0x29d805, + 0x2a1486, + 0x276c48, + 0x2a2308, + 0x28ec06, + 0x2a7c4f, + 0x2ab310, + 0x3da785, + 0x208c03, + 0x286385, + 0x31c548, + 0x2a4e89, + 0x3c9a88, + 0x21b288, + 0x263f08, + 0x32f887, + 0x28b6c9, + 0x305188, + 0x3c8fc4, + 0x2af248, + 0x218009, + 0x2cf047, + 0x39eb84, + 0x3727c8, + 0x25278a, + 0x32f346, + 0x219186, + 0x21dd09, + 0x2aed87, + 0x2e68c8, + 0x245c08, + 0x3cbac8, + 0x2775c5, + 0x348d85, + 0x252bc5, + 0x294f45, + 0x2cba47, + 0x21dcc5, + 0x2db305, + 0x21da06, + 0x3c99c7, + 0x3839c7, + 0x252a86, + 0x2ec485, + 0x2502c6, + 0x205005, + 0x36d588, + 0x320644, + 0x2e1086, + 0x398084, + 0x2d5cc8, + 0x2e118a, + 0x28f20c, + 0x2afd05, + 0x30ea86, + 0x36d9c6, + 0x3b6b46, + 0x31bb84, + 0x3d2b45, + 0x28f707, + 0x2aee09, + 0x2e6187, + 0x773104, + 0x773104, + 0x32f645, + 0x30e584, + 0x2acf4a, + 0x28b886, + 0x2ddf04, + 0x3cf605, + 0x2cae05, + 0x2cd504, + 0x2954c7, + 0x207d87, + 0x2e5bc8, + 0x2deec8, + 0x204009, + 0x320fc8, + 0x299a0b, + 0x2398c4, + 0x34a4c5, + 0x2921c5, + 0x2fb889, + 0x2d9b09, + 0x23a0c8, + 0x2f0d08, + 0x264844, + 0x29adc5, + 0x20c003, + 0x358a05, + 0x2ad606, + 0x2a8d4c, + 0x21b086, + 0x28d1c6, + 0x29ca45, + 0x2f9ac8, + 0x2e0a86, + 0x279486, + 0x219186, + 0x22e80c, + 0x282384, + 0x37058a, + 0x29c988, + 0x2a8b87, + 0x33ebc6, + 0x260b87, + 0x302f85, + 0x297346, + 0x361386, + 0x37b807, + 0x255844, + 0x3d7885, + 0x28b384, + 0x2c0e87, + 0x28b5c8, + 0x28cb4a, + 0x292407, + 0x2bc907, + 0x351087, + 0x2f7e09, + 0x2a8d4a, + 0x232443, + 0x255745, + 0x214103, + 0x2cfc49, + 0x231e08, + 0x36ca87, + 0x3c9b89, + 0x21b106, + 0x2050c8, + 0x2ca105, + 0x24a88a, + 0x3a8289, + 0x280a09, + 0x2e0947, + 0x2f6189, + 0x213fc8, + 0x3d6c46, + 0x30ec48, + 0x28c3c7, + 0x243887, + 0x3de287, + 0x2e8c88, + 0x37f046, + 0x252545, + 0x28f707, + 0x2a9648, + 0x3703c4, + 0x378a84, + 0x2a2d87, + 0x2c2687, + 0x280c4a, + 0x3d6bc6, + 0x3d2e4a, + 0x2da087, + 0x2b4987, + 0x3d7944, + 0x29b684, + 0x2e9006, + 0x3cd884, + 0x3cd88c, + 0x311645, + 0x218e49, + 0x205c84, + 0x2cd5c5, + 0x20dcc8, + 0x2a23c5, + 0x39cd86, + 0x2a50c4, + 0x2a5fca, + 0x2c1f06, + 0x3513ca, + 0x2b8c07, + 0x2a3405, + 0x231885, + 0x24e20a, + 0x28a245, + 0x239746, + 0x24cf84, + 0x2c9406, + 0x3a9705, + 0x3d0f06, + 0x31a70c, + 0x36464a, + 0x281b04, + 0x20e506, + 0x2aed87, + 0x2ea944, + 0x223ec8, + 0x3ab986, + 0x39f1c9, + 0x37d709, + 0x2bebc9, + 0x20e6c6, + 0x28c4c6, + 0x30ed87, + 0x3742c8, + 0x28c2c9, + 0x32f7c7, + 0x2a7f86, + 0x3d0507, + 0x34c385, + 0x2b4bc4, + 0x30e947, + 0x21d705, + 0x2992c5, + 0x393747, + 0x252348, + 0x3dd6c6, + 0x2aa4cd, + 0x2abbcf, + 0x2b060d, + 0x21dc04, + 0x23fc46, + 0x2ed548, + 0x208c05, + 0x24e6c8, + 0x3b50ca, + 0x23d6c4, + 0x2cbec6, + 0x2b6187, + 0x2cde87, + 0x22ee89, + 0x30ec05, + 0x2cd504, + 0x2cf8ca, + 0x2d6649, + 0x2f6287, + 0x2aa786, + 0x33a806, + 0x29ad06, + 0x26af46, + 0x35a38f, + 0x2ed409, + 0x24a586, + 0x26be86, + 0x237789, + 0x2cebc7, + 0x20ae43, + 0x22e986, + 0x219d43, + 0x35e948, + 0x255107, + 0x2b3349, + 0x2b4588, + 0x219888, + 0x254d46, + 0x22af49, + 0x35d745, + 0x235e44, + 0x2ccac7, + 0x3ac7c5, + 0x21dc04, + 0x3e75c8, + 0x2187c4, + 0x2ce907, + 0x3adf86, + 0x242845, + 0x2ac2c8, + 0x33a6cb, + 0x30fc07, + 0x24e486, + 0x2e1f04, + 0x3b5f86, + 0x27bb45, + 0x21d705, + 0x291809, + 0x2950c9, + 0x2438c4, + 0x243905, + 0x20e545, + 0x24a706, + 0x30f808, + 0x2d9286, + 0x22bf0b, + 0x2c5d4a, + 0x2d5c05, + 0x29d886, + 0x236305, + 0x3c5b45, + 0x2a9247, + 0x20bec8, + 0x276cc4, + 0x25be46, + 0x2a2386, + 0x214187, + 0x322644, + 0x290806, + 0x23a445, + 0x23a449, + 0x28c6c4, + 0x30bfc9, + 0x28ec06, + 0x2dc248, + 0x20e545, + 0x39f445, + 0x3d0f06, + 0x36d709, + 0x21aa49, + 0x28d246, + 0x31f6c8, + 0x35c408, + 0x2362c4, + 0x2d0084, + 0x2d0088, + 0x3c7608, + 0x35d909, + 0x2ad586, + 0x219186, + 0x339c8d, + 0x318346, + 0x2dac89, + 0x3bcf05, + 0x21a006, + 0x36fc88, + 0x336885, + 0x21d584, + 0x27bb45, + 0x294a08, + 0x2acd09, + 0x28b444, + 0x2d18c6, + 0x2eadca, + 0x397988, + 0x280dc9, + 0x28d90a, + 0x3c9b06, + 0x2abd88, + 0x379605, + 0x3b4c48, + 0x303005, + 0x21afc9, + 0x33c7c9, + 0x23bc42, + 0x2a6ec5, + 0x292286, + 0x28eb47, + 0x2854c5, + 0x33eac6, + 0x317308, + 0x2b2246, + 0x37a9c9, + 0x28dd86, + 0x294b88, + 0x2be0c5, + 0x24c706, + 0x385dc8, + 0x293288, + 0x2790c8, + 0x319888, + 0x20d644, + 0x223803, + 0x37ac04, + 0x292606, + 0x34c3c4, + 0x2a37c7, + 0x279389, + 0x2e1405, + 0x245c06, + 0x22e986, + 0x2a03cb, + 0x2cc1c6, + 0x237fc6, + 0x2e3fc8, + 0x328986, + 0x2a3203, + 0x207083, + 0x2b4bc4, + 0x238745, + 0x303747, + 0x28b5c8, + 0x28b5cf, + 0x28f60b, + 0x30f608, + 0x2d1946, + 0x30f90e, + 0x24e643, + 0x3036c4, + 0x2cc145, + 0x2cd386, + 0x2a088b, + 0x2a47c6, + 0x22dd09, + 0x242845, + 0x248a08, + 0x203cc8, + 0x21a90c, + 0x2b1706, + 0x358a46, + 0x2d4205, + 0x299688, + 0x28f205, + 0x34eb88, + 0x2adb0a, + 0x2b0a49, + 0x773104, + 0x2000c2, + 0x53a05842, + 0x200382, + 0x258104, + 0x2026c2, + 0x292e44, + 0x2048c2, + 0xbc03, + 0x2003c2, + 0x2036c2, + 0x7ffc8, + 0x45c4, + 0x229f43, + 0x224d03, + 0x2e9c43, + 0xf002, + 0x58e02, + 0x219c03, + 0x2127c3, + 0x21f483, + 0x6ca02, + 0x9e42, + 0x1b02, + 0x258843, + 0x229f43, + 0x224d03, + 0x2e9c43, + 0x258104, + 0x2127c3, + 0x21f483, + 0x220743, + 0x29f804, + 0x229f43, + 0x241284, + 0x224d03, + 0x2ef2c4, + 0x2e9c43, + 0x285787, + 0x219c03, + 0x20bc03, + 0x219d08, + 0x21f483, + 0x28aa0b, + 0x3041c3, + 0x216e06, + 0x208ec2, + 0x2ff38b, + 0x224d03, + 0x2e9c43, + 0x2127c3, + 0x21f483, + 0x229f43, + 0x224d03, + 0x2e9c43, + 0x21f483, + 0x21ad03, + 0x207743, + 0x2000c2, + 0x7ffc8, + 0x232a05, + 0x21d788, + 0x34fd88, + 0x205842, + 0x354705, + 0x3d0647, + 0x203642, + 0x2ce747, + 0x200382, + 0x262447, + 0x22cf89, + 0x27c388, + 0x3cb949, + 0x212c82, + 0x203e87, + 0x392fc4, + 0x3d0707, + 0x2c5c47, + 0x26dc42, + 0x219c03, + 0x20f782, + 0x2048c2, + 0x2003c2, + 0x20f102, + 0x200902, + 0x2036c2, + 0x2eb705, + 0x212345, + 0x5842, + 0x24d03, + 0x229f43, + 0x224d03, + 0x219443, + 0x2e9c43, + 0x204203, + 0x2127c3, + 0x21f483, + 0x229f43, + 0x224d03, + 0x2e9c43, + 0x2127c3, + 0x21f483, + 0x229f43, + 0x224d03, + 0x2e9c43, + 0x14fa46, + 0x566c744b, + 0x219c03, + 0x2127c3, + 0x81983, + 0x21f483, + 0xca7c5, + 0x11643, + 0x101, + 0x229f43, + 0x224d03, + 0x2e9c43, + 0x258104, + 0x25e043, + 0x2127c3, + 0x81983, + 0x21f483, + 0x21fc83, + 0x5706e786, + 0x5483, + 0x1739c5, + 0x229f43, + 0x224d03, + 0x2e9c43, + 0x2127c3, + 0x21f483, + 0x205842, + 0x229f43, + 0x224d03, + 0x2e9c43, + 0x2127c3, + 0x81983, + 0x21f483, + 0x7042, + 0x7ffc8, + 0x361c3, + 0xbc03, + 0x81983, + 0x51a44, + 0x1487dc4, + 0xf80c5, + 0x2000c2, + 0x32d4c4, + 0x229f43, + 0x224d03, + 0x2e9c43, + 0x240a03, + 0x235c45, + 0x25e043, + 0x2280c3, + 0x2127c3, + 0x25c743, + 0x21f483, + 0x217083, + 0x208d43, + 0x205ec3, + 0xc8bc3, + 0x5c2, + 0x47f42, + 0x229f43, + 0x224d03, + 0x2e9c43, + 0x2127c3, + 0x21f483, + 0x2000c2, + 0x258843, + 0x205842, + 0xd02, + 0x224d03, + 0x2e9c43, + 0x258104, + 0x2127c3, + 0x21f483, + 0x2036c2, + 0x7ffc8, + 0x2e9c43, + 0x81983, + 0x7ffc8, + 0x81983, + 0x2c9ec3, + 0x229f43, + 0x23b4c4, + 0x224d03, + 0x2e9c43, + 0x203842, + 0x219c03, + 0x2127c3, + 0xbc03, + 0x21f483, + 0x229f43, + 0x224d03, + 0x2e9c43, + 0x203842, + 0x2335c3, + 0x2127c3, + 0x21f483, + 0x2fe343, + 0x217083, + 0x2000c2, + 0x205842, + 0x2e9c43, + 0x2127c3, + 0x21f483, + 0x216e05, + 0x157246, + 0x762c4, + 0x31384, + 0x29f804, + 0x208ec2, + 0x882, + 0x7ffc8, + 0xd02, + 0x58e02, + 0xfc2, + 0x2000c2, + 0x145d45, + 0x25388, + 0xf7c03, + 0x205842, + 0x48244, + 0x5c149406, + 0xc344, + 0xb2e8b, + 0x46a06, + 0x84447, + 0xb7ac9, + 0x224d03, + 0x573c8, + 0x573cb, + 0x5784b, + 0x585cb, + 0x5890b, + 0x58bcb, + 0x5900b, + 0xeb86, + 0x2e9c43, + 0x146bc5, + 0x172ec4, + 0x267c83, + 0x1196c7, + 0x15a2c6, + 0x12fc05, + 0x1cde04, + 0xf37c4, + 0x7f0c4, + 0x2127c3, + 0x8d346, + 0xf9304, + 0x81983, + 0x21f483, + 0x305744, + 0x1300c7, + 0x156e49, + 0xb2c48, + 0x1e3f05, + 0x1d3204, + 0x1d0844, + 0x172283, + 0x5b646, + 0x11448, + 0x198185, + 0x71c9, + 0x13803, + 0x10b2c6, + 0x145d45, + 0x205842, + 0x229f43, + 0x224d03, + 0x2e9c43, + 0x219c03, + 0x20bc03, + 0x21f483, + 0x3041c3, + 0x208ec2, + 0x7ffc8, + 0x229f43, + 0x224d03, + 0x2e9c43, + 0x258103, + 0x222d84, + 0x2127c3, + 0xbc03, + 0x21f483, + 0x229f43, + 0x224d03, + 0x2ef2c4, + 0x2e9c43, + 0x2127c3, + 0x21f483, + 0x216e06, + 0x224d03, + 0x2e9c43, + 0x1d343, + 0x81983, + 0x21f483, + 0x229f43, + 0x224d03, + 0x2e9c43, + 0x2127c3, + 0x21f483, + 0x145d45, + 0x84447, + 0x84c3, + 0x13803, + 0x7ffc8, + 0x2e9c43, + 0x229f43, + 0x224d03, + 0x2e9c43, + 0x979c3, + 0x2127c3, + 0x21f483, + 0x5f629f43, + 0x224d03, + 0x2127c3, + 0x21f483, + 0x7ffc8, + 0x2000c2, + 0x205842, + 0x229f43, + 0x2e9c43, + 0x2127c3, + 0x2003c2, + 0x21f483, + 0x33cd07, + 0x236d4b, + 0x219dc3, + 0x321e08, + 0x374047, + 0x3e2986, + 0x3112c5, + 0x354849, + 0x216b88, + 0x285b89, + 0x285b90, + 0x38864b, + 0x3aec89, + 0x2084c3, + 0x221c49, + 0x23ca06, + 0x23ca0c, + 0x232ac8, + 0x3ed388, + 0x271709, + 0x2d094e, + 0x22cd4b, + 0x2c54cc, + 0x2030c3, + 0x27f60c, + 0x2030c9, + 0x3e4347, + 0x23e60c, + 0x2c714a, + 0x259b44, + 0x2c084d, + 0x27f4c8, + 0x3d9ecd, + 0x282c06, + 0x29f80b, + 0x356fc9, + 0x26c107, + 0x386206, + 0x332949, + 0x349f8a, + 0x3a73c8, + 0x303dc4, + 0x2c3087, + 0x250d47, + 0x20a3c4, + 0x22d744, + 0x387109, + 0x3bc989, + 0x3d0bc8, + 0x32e9c5, + 0x212bc5, + 0x20da06, + 0x2c0709, + 0x352bcd, + 0x21a108, + 0x20d907, + 0x311348, + 0x24f486, + 0x2443c4, + 0x269185, + 0x3e8c86, + 0x3eb4c4, + 0x202fc7, + 0x20644a, + 0x213f04, + 0x2183c6, + 0x21bf49, + 0x21bf4f, + 0x21cd0d, + 0x21d246, + 0x224f90, + 0x225386, + 0x225c47, + 0x226587, + 0x22658f, + 0x227009, + 0x22ca86, + 0x22d207, + 0x22d208, + 0x22e049, + 0x3d5848, + 0x30b9c7, + 0x20e2c3, + 0x234e06, + 0x32e6c8, + 0x2d0c0a, + 0x203709, + 0x216cc3, + 0x354606, + 0x25bc8a, + 0x244e47, + 0x3e418a, + 0x34910e, + 0x227146, + 0x33f0c7, + 0x24b806, + 0x202546, + 0x348b8b, + 0x20ec8a, + 0x3d7c8d, + 0x28c587, + 0x27a688, + 0x27a689, + 0x27a68f, + 0x3a784c, + 0x3a7b09, + 0x278ace, + 0x28588a, + 0x237d46, + 0x2f7486, + 0x3b2acc, + 0x317fcc, + 0x322c88, + 0x35b287, + 0x224245, + 0x3d08c4, + 0x34aece, + 0x22f544, + 0x3405c7, + 0x3ad60a, + 0x3e6bd4, + 0x3ea64f, + 0x226748, + 0x234cc8, + 0x38168d, + 0x38168e, + 0x235149, + 0x342548, + 0x34254f, + 0x23e30c, + 0x23e30f, + 0x23f987, + 0x2422ca, + 0x2445cb, + 0x245008, + 0x2474c7, + 0x253c4d, + 0x366a06, + 0x2c0a06, + 0x249209, + 0x272348, + 0x24f808, + 0x24f80e, + 0x236e47, + 0x308645, + 0x251805, + 0x209484, + 0x3e2c46, + 0x3d0ac8, + 0x264283, + 0x2c68ce, + 0x254008, + 0x24fe4b, + 0x359547, + 0x233645, + 0x27f786, + 0x2bfb07, + 0x32ecc8, + 0x330989, + 0x23ec45, + 0x297e48, + 0x230546, + 0x3b984a, + 0x34adc9, + 0x23e6c9, + 0x23e6cb, + 0x284f88, + 0x20a289, + 0x2c9806, + 0x26c4ca, + 0x3d1fca, + 0x2424cc, + 0x379c87, + 0x27c18a, + 0x3c6e8b, + 0x3c6e99, + 0x2d9408, + 0x216e85, + 0x253e06, + 0x36ff09, + 0x240186, + 0x22ff8a, + 0x229dc6, + 0x20a6c4, + 0x2e2e4d, + 0x20a6c7, + 0x325f89, + 0x255f05, + 0x256dc8, + 0x257189, + 0x259344, + 0x259a47, + 0x259a48, + 0x25a107, + 0x279c48, + 0x260787, + 0x2e5885, + 0x26888c, + 0x268c89, + 0x31b2ca, + 0x26b909, + 0x221d49, + 0x26bc4c, + 0x26ef8b, + 0x270f48, + 0x272548, + 0x275904, + 0x295f08, + 0x2975c9, + 0x2c7207, + 0x21c186, + 0x2af587, + 0x2fbc89, + 0x20ffcb, + 0x2511c7, + 0x21f507, + 0x2b8d47, + 0x3d9e44, + 0x3d9e45, + 0x2eefc5, + 0x357dcb, + 0x208f44, + 0x3b6988, + 0x25d44a, + 0x230607, + 0x3ecf87, + 0x29fc92, + 0x28afc6, + 0x2389c6, + 0x33564e, + 0x28c886, + 0x2a4c08, + 0x2a5acf, + 0x3da288, + 0x3b4608, + 0x3ae48a, + 0x3ae491, + 0x2b424e, + 0x26524a, + 0x26524c, + 0x265a07, + 0x342750, + 0x3d8948, + 0x2b4445, + 0x2bfe0a, + 0x3eb50c, + 0x2b84cd, + 0x204206, + 0x204207, + 0x20420c, + 0x20e80c, + 0x3a864c, + 0x2c340b, + 0x3ab384, + 0x21de84, + 0x2c4d89, + 0x31dac7, + 0x3ead89, + 0x288509, + 0x2c6e07, + 0x2c6fc6, + 0x2c6fc9, + 0x2c73c3, + 0x2b234a, + 0x32e587, + 0x20c0cb, + 0x3d7b0a, + 0x262584, + 0x2128c6, + 0x292689, + 0x368784, + 0x2eb30a, + 0x240d85, + 0x2d7a85, + 0x2d7a8d, + 0x2d7dce, + 0x31c3c5, + 0x33b486, + 0x216a07, + 0x24ecca, + 0x22f846, + 0x27f1c4, + 0x2fb147, + 0x2e0d4b, + 0x3d5d07, + 0x3b55c4, + 0x3c8586, + 0x3c858d, + 0x2f208c, + 0x212686, + 0x21a30a, + 0x2281c6, + 0x222088, + 0x3b2f47, + 0x22790a, + 0x23e186, + 0x286443, + 0x286446, + 0x220d48, + 0x375c0a, + 0x2a0207, + 0x2a0208, + 0x2a2844, + 0x28b1c7, + 0x36a3c8, + 0x2dbb08, + 0x31a988, + 0x35a6ca, + 0x2f7305, + 0x2bbec7, + 0x265093, + 0x27d886, + 0x2472c8, + 0x22a349, + 0x2ce608, + 0x254dcb, + 0x2cfe88, + 0x2e0e84, + 0x2de086, + 0x323fc6, + 0x341689, + 0x2e0c07, + 0x268988, + 0x297446, + 0x393644, + 0x32df05, + 0x3d98c8, + 0x34a9ca, + 0x2e2ac8, + 0x2e6e06, + 0x2abf8a, + 0x203b08, + 0x2e1908, + 0x2eb588, + 0x2ec146, + 0x2ed746, + 0x33c00c, + 0x2edcd0, + 0x2ee0c5, + 0x2bb0c8, + 0x2bb0d0, + 0x3da090, + 0x285a0e, + 0x33bc8e, + 0x33bc94, + 0x3b244f, + 0x3b2806, + 0x3bef11, + 0x3ed913, + 0x20a488, + 0x20b405, + 0x3cbf08, + 0x332c05, + 0x3e244c, + 0x2166c9, + 0x22f389, + 0x3b9c47, + 0x3495c9, + 0x35dbc7, + 0x207586, + 0x268f87, + 0x201245, + 0x211683, + 0x21d343, + 0x23d384, + 0x21338d, + 0x331e0f, + 0x393685, + 0x2165c6, + 0x22bbc7, + 0x232847, + 0x2c5886, + 0x2c588b, + 0x2b5485, + 0x213786, + 0x3a7107, + 0x261449, + 0x226e86, + 0x310b85, + 0x381d4b, + 0x3cf886, + 0x218b85, + 0x240a88, + 0x28ad88, + 0x2a184c, + 0x2a1850, + 0x2ae909, + 0x2b6c07, + 0x2cb48b, + 0x2d8346, + 0x30b88a, + 0x24704b, + 0x34bc8a, + 0x361806, + 0x2fe205, + 0x32e2c6, + 0x28df48, + 0x2c760a, + 0x38131c, + 0x33194c, + 0x304288, + 0x216e05, + 0x288dc7, + 0x2d0586, + 0x38bfc5, + 0x220106, + 0x2c5a48, + 0x2d68c7, + 0x2d0848, + 0x256f0a, + 0x38a5cc, + 0x3d8109, + 0x384347, + 0x2cdc04, + 0x2518c6, + 0x3b418a, + 0x288605, + 0x22d3cc, + 0x22da88, + 0x2fd6c8, + 0x30a50c, + 0x35c98c, + 0x3963c9, + 0x3eab87, + 0x251f0c, + 0x22b704, + 0x306dca, + 0x227d8c, + 0x28400b, + 0x259e4b, + 0x25ce86, + 0x263407, + 0x265507, + 0x34298f, + 0x312151, + 0x2f47d2, + 0x26550d, + 0x26550e, + 0x26584e, + 0x3b2608, + 0x3b2612, + 0x230e48, + 0x257f07, + 0x25e70a, + 0x251d48, + 0x28c845, + 0x2cb88a, + 0x225707, + 0x2e7cc4, + 0x254a43, + 0x2417c5, + 0x3ae707, + 0x2fce87, + 0x2b86ce, + 0x365d4d, + 0x3c8249, + 0x207805, + 0x31e6c3, + 0x33e006, + 0x26c905, + 0x250088, + 0x385989, + 0x224805, + 0x253e4f, + 0x2b2f87, + 0x311145, + 0x359f0a, + 0x3daa46, + 0x3917c9, + 0x353c8c, + 0x366c49, + 0x3ec046, + 0x25d24c, + 0x3345c6, + 0x3bf308, + 0x239546, + 0x27cfc6, + 0x2cc344, + 0x3c39c3, + 0x3e954a, + 0x250491, + 0x3a7cca, + 0x26b245, + 0x26f947, + 0x265cc7, + 0x2d54c4, + 0x36a4cb, + 0x3cb7c8, + 0x2d5146, + 0x3e7205, + 0x277944, + 0x268189, + 0x2008c4, + 0x3ebe47, + 0x333505, + 0x333507, + 0x335885, + 0x25f3c3, + 0x257dc8, + 0x27988a, + 0x22eb83, + 0x232a4a, + 0x3bd7c6, + 0x253bcf, + 0x272109, + 0x2c6850, + 0x2d5648, + 0x2e7709, + 0x2aa307, + 0x3c850f, + 0x3c9f44, + 0x2ef344, + 0x20b786, + 0x2f0686, + 0x26204a, + 0x256186, + 0x2c3a87, + 0x315808, + 0x315a07, + 0x3170c7, + 0x318c4a, + 0x3179cb, + 0x23ab05, + 0x2f4408, + 0x2098c3, + 0x3d458c, + 0x386b0f, + 0x22404d, + 0x29d4c7, + 0x243449, + 0x396687, + 0x2d0f88, + 0x3e6dcc, + 0x301748, + 0x24a2c8, + 0x33314e, + 0x344cd4, + 0x3451e4, + 0x364b8a, + 0x388ecb, + 0x35dc84, + 0x35dc89, + 0x2cbf48, + 0x252245, + 0x373e4a, + 0x3c9047, + 0x285584, + 0x258843, + 0x229f43, + 0x241284, + 0x224d03, + 0x2e9c43, + 0x258104, + 0x25e043, + 0x219c03, + 0x2edcc6, + 0x222d84, + 0x2127c3, + 0x21f483, + 0x202783, + 0x2000c2, + 0x258843, + 0x205842, + 0x229f43, + 0x241284, + 0x224d03, + 0x2e9c43, + 0x25e043, + 0x2edcc6, + 0x2127c3, + 0x21f483, + 0x7ffc8, + 0x229f43, + 0x224d03, + 0x28c6c3, + 0x2127c3, + 0x81983, + 0x21f483, + 0x258843, + 0x7ffc8, + 0x229f43, + 0x224d03, + 0x2e9c43, + 0x219c03, + 0x222d84, + 0x2127c3, + 0x21f483, + 0x2000c2, + 0x289e03, + 0x205842, + 0x224d03, + 0x2e9c43, + 0x219c03, + 0x2127c3, + 0x21f483, + 0x203702, + 0x2035c2, + 0x205842, + 0x229f43, + 0x208542, + 0x2005c2, + 0x258104, + 0x292e44, + 0x230a02, + 0x222d84, + 0x2003c2, + 0x21f483, + 0x202783, + 0x25ce86, + 0x26ca02, + 0x201b02, + 0x22a742, + 0x61e12d83, + 0x62265243, + 0x66746, + 0x66746, + 0x29f804, + 0x20bc03, + 0x2acd, + 0x1d094a, + 0x1d39cc, + 0x92ccc, + 0x62c6e64f, + 0x1cc94d, + 0x713c4, + 0x7b204, + 0x161cc4, + 0x145d45, + 0x98409, + 0xb778c, + 0x110947, + 0x16906, + 0x1eb88, + 0x24bc7, + 0x286c8, + 0x1c14ca, + 0x1145c7, + 0xb79c9, + 0x632f8c05, + 0xf8c09, + 0x634404cb, + 0x125c88, + 0x137dcb, + 0x344b, + 0x182bc8, + 0x13054a, + 0x17d3ce, + 0x638b738a, + 0x1e544d, + 0x3514d, + 0x14ce40b, + 0xf1f4a, + 0xc344, + 0x8ef86, + 0x19f508, + 0xd1e88, + 0x40787, + 0x16245, + 0x1e0507, + 0xa54c9, + 0x1cd787, + 0x1db408, + 0x31009, + 0x15f9c4, + 0x53705, + 0x3810e, + 0x1401c7, + 0x63e26c46, + 0xbe10d, + 0x1cd608, + 0xf4008, + 0x6429ed46, + 0x64d82888, + 0x106b8a, + 0xb2908, + 0x13cf10, + 0x6388c, + 0x76987, + 0x77d47, + 0x7bd87, + 0x81847, + 0xd9c2, + 0x1da407, + 0xee4c, + 0x1e1905, + 0xbd847, + 0xb6ac6, + 0xb92c9, + 0xbb988, + 0x1d7c2, + 0x5c2, + 0x19ab46, + 0x1d6ecb, + 0x1d71c6, + 0x71c84, + 0xcabc7, + 0x56a09, + 0x90249, + 0x1c03c8, + 0x58e02, + 0x12d349, + 0x15288, + 0xfff4a, + 0xd28c8, + 0x652e034b, + 0x162d09, + 0x51c86, + 0xe5649, + 0xf1ec7, + 0xf2609, + 0xf3948, + 0xf5707, + 0xf7289, + 0xf9d05, + 0xfa0d0, + 0x1c5e46, + 0xcab05, + 0xd5247, + 0x12634d, + 0x65ac9683, + 0x4d385, + 0x2e6c6, + 0xff7c7, + 0x105758, + 0x98d08, + 0x4c08a, + 0x152f8e, + 0x9942, + 0x65f5f74b, + 0x662e574a, + 0x59c0a, + 0x6a90d, + 0x33c2, + 0xdfa46, + 0x18a46, + 0xac788, + 0xbb70a, + 0x566c8, + 0x7fe89, + 0x1167c8, + 0x75a8e, + 0x29c08, + 0x13e007, + 0x6669ec84, + 0xd3f0d, + 0x10df85, + 0x1735c8, + 0x3fe48, + 0x66888d0a, + 0x66eb3dc8, + 0x1133c6, + 0x9e42, + 0xa6f44, + 0x6d586, + 0x67045f08, + 0x5b646, + 0x678c200b, + 0x4182, + 0x154a09, + 0x135c08, + 0x14b207, + 0x3268a, + 0x118a87, + 0x401, + 0x81, + 0x18e907, + 0x1c8388, + 0xc7e88, + 0xc8088, + 0xc8288, + 0x6fcc7, + 0xb1fc3, + 0x64644084, + 0x64aa6b83, + 0xc1, + 0x39d46, + 0xc1, + 0x201, + 0x39d46, + 0xb1fc3, + 0x656212c4, + 0x196f84, + 0x1fe85, + 0x2c945, + 0xcad04, + 0x2a084, + 0x59244, + 0x1434307, + 0x1421207, + 0x1c8bc8, + 0x148e4c, + 0xc41, + 0x8d43, + 0x2c684, + 0xef885, + 0x1c8bc8, + 0x677c8bc8, + 0x54e83, + 0x80383, + 0x16c43, + 0x22207, + 0x5ec7, + 0x145e305, + 0x5d8c4, + 0x76ac7, + 0x5842, + 0x2c904, + 0x1b01ca, + 0x259b44, + 0x229f43, + 0x25b9c4, + 0x258104, + 0x2127c3, + 0x22a205, + 0x21fc83, + 0x23ffc3, + 0x32e885, + 0x205ec3, + 0x15d43, + 0x68e29f43, + 0x224d03, + 0x5b9c4, + 0x4b03, + 0x2e9c43, + 0x200181, + 0x280c3, + 0x219c03, + 0x292e44, + 0x222d84, + 0x2127c3, + 0x5c743, + 0x21f483, + 0x217083, + 0x7ffc8, + 0x2000c2, + 0x258843, + 0x205842, + 0x229f43, + 0x224d03, + 0x28c6c3, + 0x2005c2, + 0x258104, + 0x25e043, + 0x219c03, + 0x2127c3, + 0x20bc03, + 0x21f483, + 0x205ec3, + 0x186a44, + 0x7ffc8, + 0xfd147, + 0x5842, + 0x12de85, + 0x639cf, + 0x1e50c6, + 0x1475dc8, + 0x116ace, + 0x69e087c2, + 0x2373c8, + 0x3d1086, + 0x25da46, + 0x3a33c7, + 0x6a204cc2, + 0x6a6c66c8, + 0x22ad4a, + 0x276408, + 0x200ac2, + 0x32e3c9, + 0x23ab47, + 0x21c106, + 0x257b09, + 0x2bc004, + 0x3e2886, + 0x2deb04, + 0x20de84, + 0x267f09, + 0x314a86, + 0x2bb4c5, + 0x27a245, + 0x235987, + 0x2d2187, + 0x305344, + 0x35eb06, + 0x2e88c5, + 0x3d7605, + 0x236245, + 0x24f647, + 0x359385, + 0x257609, + 0x372385, + 0x32ee04, + 0x22f787, + 0x3ce14e, + 0x209a09, + 0x335509, + 0x3681c6, + 0x24b088, + 0x3793cb, + 0x3bd38c, + 0x323ac6, + 0x2c5387, + 0x2f9185, + 0x30e20a, + 0x3d0cc9, + 0x20aa89, + 0x208186, + 0x3a6ec5, + 0x251b85, + 0x371809, + 0x2363cb, + 0x239186, + 0x353486, + 0x20d904, + 0x241f86, + 0x3086c8, + 0x3d38c6, + 0x242d46, + 0x204788, + 0x206f07, + 0x207f49, + 0x20cc05, + 0x7ffc8, + 0x3e0484, + 0x317644, + 0x212a45, + 0x343a49, + 0x2292c7, + 0x2292cb, + 0x22c3ca, + 0x22f2c5, + 0x6aa0a582, + 0x3d79c7, + 0x6ae2fbc8, + 0x2083c7, + 0x223a85, + 0x2449ca, + 0x5842, + 0x28f84b, + 0x29090a, + 0x279746, + 0x2114c3, + 0x21438d, + 0x3d250c, + 0x3d628d, + 0x245b45, + 0x36cdc5, + 0x2642c7, + 0x3db089, + 0x22ac46, + 0x256005, + 0x30d0c8, + 0x241e83, + 0x350088, + 0x241e88, + 0x3c6b07, + 0x2f0308, + 0x310589, + 0x33edc7, + 0x2368c7, + 0x209348, + 0x25e1c4, + 0x25e1c7, + 0x282b08, + 0x365746, + 0x20668f, + 0x35bcc7, + 0x35e606, + 0x3eacc5, + 0x22a8c3, + 0x253847, + 0x395c03, + 0x25a2c6, + 0x25d7c6, + 0x25eac6, + 0x2a3e05, + 0x279c43, + 0x32cfc8, + 0x3aa189, + 0x25ec4b, + 0x25ef08, + 0x260445, + 0x2629c5, + 0x6b262642, + 0x269049, + 0x3d1bc7, + 0x213805, + 0x267e07, + 0x269c46, + 0x26ae05, + 0x26c74b, + 0x270f44, + 0x275fc5, + 0x276107, + 0x289746, + 0x28a185, + 0x296347, + 0x296f87, + 0x2cc984, + 0x2b758a, + 0x2fabc8, + 0x379689, + 0x2f9505, + 0x2464c6, + 0x30888a, + 0x27a146, + 0x396907, + 0x27c50d, + 0x2b4fc9, + 0x389205, + 0x3b7007, + 0x3cdc48, + 0x385b88, + 0x32b107, + 0x367e86, + 0x21c507, + 0x267883, + 0x314a04, + 0x38abc5, + 0x3b76c7, + 0x3bffc9, + 0x234488, + 0x396805, + 0x2421c4, + 0x2544c5, + 0x25f0cd, + 0x2086c2, + 0x228346, + 0x2c9706, + 0x3097ca, + 0x3a8b86, + 0x3b40c5, + 0x2defc5, + 0x2defc7, + 0x3b968c, + 0x2b278a, + 0x29da06, + 0x2ed645, + 0x241dc6, + 0x29fac7, + 0x2a1f06, + 0x2a3d0c, + 0x257c49, + 0x6b61c907, + 0x2a5e85, + 0x2a5e86, + 0x2a6248, + 0x256505, + 0x2b5705, + 0x2b5bc8, + 0x2b5dca, + 0x6ba27e02, + 0x6be10802, + 0x21b485, + 0x30bac3, + 0x336a48, + 0x24bc83, + 0x2b6044, + 0x39190b, + 0x3c5c88, + 0x2bda08, + 0x6c340949, + 0x2bd309, + 0x2be006, + 0x2bf788, + 0x2bf989, + 0x2c1046, + 0x2c11c5, + 0x254646, + 0x2c1789, + 0x2d6487, + 0x24c5c6, + 0x2bc547, + 0x34a147, + 0x3a6c84, + 0x6c609189, + 0x38c208, + 0x2c65c8, + 0x393887, + 0x2e2746, + 0x3dae89, + 0x25da07, + 0x3cc38a, + 0x3d2c88, + 0x224a07, + 0x231546, + 0x3affca, + 0x3ac908, + 0x31f445, + 0x22e5c5, + 0x319f87, + 0x324689, + 0x326a8b, + 0x3c0588, + 0x372409, + 0x25f847, + 0x2d2acc, + 0x2d350c, + 0x2d380a, + 0x2d3a8c, + 0x2de688, + 0x2de888, + 0x2dea84, + 0x2df209, + 0x2df449, + 0x2df68a, + 0x2df909, + 0x2dfc87, + 0x20878c, + 0x3cefc6, + 0x27bec8, + 0x27a206, + 0x2f5c06, + 0x389107, + 0x39c208, + 0x3e2e4b, + 0x208287, + 0x26fa89, + 0x292f49, + 0x38d487, + 0x207484, + 0x269247, + 0x31fe46, + 0x217246, + 0x21a4c5, + 0x3b03c8, + 0x3494c4, + 0x3494c6, + 0x2b264b, + 0x269889, + 0x24f546, + 0x242f49, + 0x212b06, + 0x39a308, + 0x20d003, + 0x3a7045, + 0x21e3c9, + 0x3a98c5, + 0x3619c4, + 0x383706, + 0x3250c5, + 0x263c06, + 0x31ac07, + 0x210286, + 0x2707cb, + 0x26c3c7, + 0x27d286, + 0x28f486, + 0x235a46, + 0x305309, + 0x200b4a, + 0x2d59c5, + 0x2ccc0d, + 0x2b5ec6, + 0x25d646, + 0x2d5546, + 0x222005, + 0x2fa3c7, + 0x3d6847, + 0x314e0e, + 0x219c03, + 0x2e2709, + 0x286809, + 0x2356c7, + 0x27e5c7, + 0x3317c5, + 0x2dbc85, + 0x6cb8724f, + 0x2e7947, + 0x2e7b08, + 0x2e7fc4, + 0x2e8306, + 0x6ce51882, + 0x2ec3c6, + 0x2edcc6, + 0x374a0e, + 0x34feca, + 0x214806, + 0x2cdd4a, + 0x3d6089, + 0x3023c5, + 0x2d8548, + 0x301186, + 0x2c4f88, + 0x385348, + 0x32234b, + 0x3a34c5, + 0x359408, + 0x2048cc, + 0x223947, + 0x25e646, + 0x3b2d88, + 0x3e2b08, + 0x6d216602, + 0x201ccb, + 0x392889, + 0x20ce09, + 0x3d1707, + 0x35e048, + 0x6d615f88, + 0x38480b, + 0x26e189, + 0x262f4d, + 0x385188, + 0x2d4e48, + 0x6da00f82, + 0x3ef104, + 0x6de47f42, + 0x365c06, + 0x6e201a42, + 0x3021ca, + 0x2b5586, + 0x230388, + 0x2583c8, + 0x264bc6, + 0x330846, + 0x309186, + 0x250005, + 0x245704, + 0x6e655cc4, + 0x358806, + 0x251647, + 0x6ea8d407, + 0x39e54b, + 0x2085c9, + 0x36ce0a, + 0x2df104, + 0x25dcc8, + 0x24c38d, + 0x302949, + 0x302b88, + 0x302e09, + 0x305744, + 0x230d44, + 0x291dc5, + 0x204c8b, + 0x3c5c06, + 0x358645, + 0x241949, + 0x35ebc8, + 0x26ae44, + 0x30e389, + 0x270705, + 0x2d21c8, + 0x236f87, + 0x335908, + 0x292886, + 0x3d5707, + 0x2f3589, + 0x381ec9, + 0x218c05, + 0x245a05, + 0x6ee09702, + 0x32ebc4, + 0x38a845, + 0x3a32c6, + 0x33ea05, + 0x262a87, + 0x303a05, + 0x287004, + 0x368286, + 0x256087, + 0x220bc6, + 0x330b45, + 0x21ae08, + 0x3d1285, + 0x228047, + 0x22f989, + 0x2699ca, + 0x2baac7, + 0x2baacc, + 0x2bb486, + 0x24d809, + 0x254345, + 0x256448, + 0x218a43, + 0x2c97c5, + 0x2ef5c5, + 0x24dc07, + 0x6f200bc2, + 0x2fef07, + 0x2e38c6, + 0x387e86, + 0x2ebd46, + 0x3e2a46, + 0x253548, + 0x3cc045, + 0x35e6c7, + 0x35e6cd, + 0x254a43, + 0x3cf485, + 0x359cc7, + 0x2ff248, + 0x359885, + 0x21f1c8, + 0x38a2c6, + 0x2a6bc7, + 0x2f5b45, + 0x3a3546, + 0x32d545, + 0x20c58a, + 0x2f9946, + 0x243cc7, + 0x2c6cc5, + 0x2fa847, + 0x2fb0c4, + 0x361946, + 0x3010c5, + 0x232f4b, + 0x31fcc9, + 0x289f0a, + 0x218c88, + 0x308388, + 0x30c28c, + 0x30dc87, + 0x30f408, + 0x388cc8, + 0x32f245, + 0x31a4ca, + 0x31e6c9, + 0x6f601402, + 0x20fec6, + 0x224804, + 0x2276c9, + 0x350bc9, + 0x312fc7, + 0x281687, + 0x288389, + 0x35a8c8, + 0x35a8cf, + 0x234046, + 0x2f160b, + 0x266b05, + 0x266b07, + 0x337789, + 0x30e306, + 0x30e307, + 0x2f4b45, + 0x23bb04, + 0x2a8746, + 0x215784, + 0x2cee87, + 0x2db048, + 0x6fba6dc8, + 0x3b8845, + 0x3bc687, + 0x2d9589, + 0x21a004, + 0x24cf48, + 0x6ff04708, + 0x2d54c4, + 0x30b548, + 0x3862c4, + 0x215649, + 0x221f45, + 0x70208ec2, + 0x234085, + 0x3aba85, + 0x3b6d08, + 0x23f7c7, + 0x706008c2, + 0x371bc5, + 0x2ea7c6, + 0x25e946, + 0x32eb88, + 0x366e48, + 0x33e9c6, + 0x31d946, + 0x2fd209, + 0x387dc6, + 0x3e068b, + 0x3e27c5, + 0x25d086, + 0x266548, + 0x366b06, + 0x2a5346, + 0x21f8ca, + 0x2eb7ca, + 0x264485, + 0x286a87, + 0x2852c6, + 0x70a04c02, + 0x359e07, + 0x3e1285, + 0x308804, + 0x308805, + 0x25dbc6, + 0x2686c7, + 0x20b785, + 0x2eb944, + 0x2e85c8, + 0x2a5405, + 0x2f6ac7, + 0x32a285, + 0x20c4c5, + 0x229604, + 0x229609, + 0x2e8708, + 0x20b0c6, + 0x217e86, + 0x3ce5c6, + 0x70ec3648, + 0x306247, + 0x33e5cd, + 0x3dcb8c, + 0x3e79c9, + 0x313549, + 0x7137e082, + 0x3e6403, + 0x246583, + 0x31ff05, + 0x3b77ca, + 0x33e406, + 0x241145, + 0x31b544, + 0x31b54b, + 0x333e8c, + 0x33474c, + 0x334a55, + 0x33660d, + 0x3384cf, + 0x338892, + 0x338d0f, + 0x3390d2, + 0x339553, + 0x339a0d, + 0x339fcd, + 0x33a34e, + 0x33ac4e, + 0x33b24c, + 0x33b60c, + 0x33ba4b, + 0x33ca0e, + 0x33d312, + 0x33e1cc, + 0x33f4d0, + 0x34ca92, + 0x34db0c, + 0x34e1cd, + 0x34e50c, + 0x351fd1, + 0x35360d, + 0x3556cd, + 0x355cca, + 0x355f4c, + 0x357b8c, + 0x35834c, + 0x35ac8c, + 0x360213, + 0x360c10, + 0x361010, + 0x361dcd, + 0x3623cc, + 0x3648c9, + 0x36704d, + 0x367393, + 0x368f11, + 0x369713, + 0x36a78f, + 0x36ab4c, + 0x36ae4f, + 0x36b20d, + 0x36b80f, + 0x36bbd0, + 0x36c64e, + 0x37554e, + 0x375e90, + 0x376a8d, + 0x37740e, + 0x37778c, + 0x378e53, + 0x37b50e, + 0x37c250, + 0x37c651, + 0x37ca8f, + 0x37ce53, + 0x37dc0d, + 0x37df4f, + 0x37e30e, + 0x37e890, + 0x37ec89, + 0x37fdd0, + 0x3802cf, + 0x38094f, + 0x380d12, + 0x38210e, + 0x387a4d, + 0x38800d, + 0x38834d, + 0x38934d, + 0x38968d, + 0x3899d0, + 0x389dcb, + 0x38a98c, + 0x38ad0c, + 0x38b30c, + 0x38b60e, + 0x39a510, + 0x39bb52, + 0x39bfcb, + 0x39c40e, + 0x39c78e, + 0x39d00e, + 0x39d58b, + 0x7179d916, + 0x39edcd, + 0x39fa14, + 0x3a0a4d, + 0x3a2b15, + 0x3a514d, + 0x3a5acf, + 0x3a628f, + 0x3aa3cf, + 0x3aa78e, + 0x3aab0d, + 0x3ac291, + 0x3af1cc, + 0x3af4cc, + 0x3af7cb, + 0x3afa8c, + 0x3b05cf, + 0x3b0992, + 0x3b0f8d, + 0x3b21cc, + 0x3b310c, + 0x3b340d, + 0x3b374f, + 0x3b3b0e, + 0x3b748c, + 0x3b7a4d, + 0x3b7d8b, + 0x3b834c, + 0x3b8d0d, + 0x3b904e, + 0x3b93c9, + 0x3ba753, + 0x3baf0d, + 0x3bb60d, + 0x3bbc0c, + 0x3bc28e, + 0x3bdecf, + 0x3be28c, + 0x3be58d, + 0x3be8cf, + 0x3bec8c, + 0x3bf50c, + 0x3bfa8c, + 0x3bfd8c, + 0x3c0c4d, + 0x3c0f92, + 0x3c1a0c, + 0x3c1d0c, + 0x3c2011, + 0x3c244f, + 0x3c280f, + 0x3c2bd3, + 0x3c3ece, + 0x3c424f, + 0x3c460c, + 0x71bc4cce, + 0x3c504f, + 0x3c5416, + 0x3c6652, + 0x3c920c, + 0x3ca10f, + 0x3ca78d, + 0x3dbc0f, + 0x3dbfcc, + 0x3dc2cd, + 0x3dc60d, + 0x3de74e, + 0x3df30c, + 0x3e32cc, + 0x3e35d0, + 0x3e5791, + 0x3e5bcb, + 0x3e600c, + 0x3e630e, + 0x3e7f11, + 0x3e834e, + 0x3e86cd, + 0x3ed6cb, + 0x3ee20f, + 0x3eebd4, + 0x21e682, + 0x21e682, + 0x2048c3, + 0x21e682, + 0x2048c3, + 0x21e682, + 0x204fc2, + 0x254685, + 0x3e7c0c, + 0x21e682, + 0x21e682, + 0x204fc2, + 0x21e682, + 0x2a7045, + 0x2699c5, + 0x21e682, + 0x21e682, + 0x202a02, + 0x2a7045, + 0x336c49, + 0x368c0c, + 0x21e682, + 0x21e682, + 0x21e682, + 0x21e682, + 0x254685, + 0x21e682, + 0x21e682, + 0x21e682, + 0x21e682, + 0x202a02, + 0x336c49, + 0x21e682, + 0x21e682, + 0x21e682, + 0x2699c5, + 0x21e682, + 0x2699c5, + 0x368c0c, + 0x3e7c0c, + 0x258843, + 0x229f43, + 0x224d03, + 0x2e9c43, + 0x258104, + 0x2127c3, + 0x21f483, + 0x31cf, + 0xa788, + 0x75bc4, + 0xbc03, + 0xe44c8, + 0x1df183, + 0x2000c2, + 0x72a05842, + 0x24c883, + 0x23bf84, + 0x204b03, + 0x2e9c44, + 0x2389c6, + 0x20f503, + 0x3835c4, + 0x2aaf45, + 0x219c03, + 0x2127c3, + 0x81983, + 0x21f483, + 0x22600a, + 0x25ce86, + 0x39cb0c, + 0x7ffc8, + 0x205842, + 0x229f43, + 0x224d03, + 0x2e9c43, + 0x2335c3, + 0x2edcc6, + 0x2127c3, + 0x21f483, + 0x202783, + 0x13803, + 0xb7048, + 0x735eb785, + 0x80407, + 0x57dc5, + 0x1c387, + 0x145d45, + 0x3589, + 0x2c02, + 0x1cb20a, + 0x74332b45, + 0x145d45, + 0x110947, + 0x29b08, + 0x1060e, + 0x9a352, + 0x12dc8b, + 0x1146c6, + 0x746f8c05, + 0x74b8c5cc, + 0x8e07, + 0xf1a47, + 0x1b654a, + 0x47cd0, + 0xc7c5, + 0xb2e8b, + 0xd1e88, + 0x40787, + 0x3bc0b, + 0xa54c9, + 0x54847, + 0x1cd787, + 0x393c7, + 0x406c6, + 0x1db408, + 0x750332c6, + 0x56607, + 0xef6c6, + 0xbe10d, + 0x5de50, + 0x75406cc2, + 0x1cd608, + 0x199810, + 0x199f4c, + 0x75b9fecd, + 0x6d988, + 0x6de0b, + 0x7d747, + 0x9e6c9, + 0x66806, + 0xa6448, + 0x4d02, + 0x6b04a, + 0x150407, + 0xbd847, + 0xb92c9, + 0xbb988, + 0x146bc5, + 0x19ab46, + 0x1d71c6, + 0x103e4e, + 0x3c4ce, + 0x4b6cf, + 0x56a09, + 0x90249, + 0x1dda0b, + 0xc1b4f, + 0x17d90c, + 0xd71cb, + 0x11b208, + 0x19e447, + 0x1abd88, + 0xc2e8b, + 0xc384c, + 0xc3c4c, + 0xc404c, + 0xc434d, + 0x1c03c8, + 0x803c2, + 0x12d349, + 0x191648, + 0xe068b, + 0xe2946, + 0xea14b, + 0x13ce4b, + 0xf428a, + 0xf58c5, + 0xfa0d0, + 0xfd8c6, + 0x1683c6, + 0xcab05, + 0xd5247, + 0xec648, + 0xff7c7, + 0xffa87, + 0x121587, + 0xd7606, + 0x165a4a, + 0xa1b8a, + 0x18a46, + 0xbd60d, + 0x566c8, + 0x1167c8, + 0x1a5e89, + 0x4be49, + 0xd1445, + 0x15804c, + 0xc454b, + 0x184109, + 0x18de04, + 0x113189, + 0x1133c6, + 0x15fa86, + 0x1b02, + 0x5b646, + 0x4bfcb, + 0x11d147, + 0x11d307, + 0x4182, + 0xe3f05, + 0x29c84, + 0x101, + 0x5fdc3, + 0x74f4c586, + 0xa6b83, + 0x382, + 0xae04, + 0xac2, + 0x9f804, + 0x882, + 0x1e02, + 0x2b82, + 0x127082, + 0x3702, + 0xb79c2, + 0x2102, + 0xb90c2, + 0x38fc2, + 0x1bc2, + 0xd02, + 0x5d9c2, + 0x24d03, + 0x942, + 0x3642, + 0x18b02, + 0x2e42, + 0x642, + 0x3cac2, + 0x1d7c2, + 0x75c2, + 0x9c42, + 0x5c2, + 0x5e043, + 0x3382, + 0x5fc2, + 0x58e02, + 0x8042, + 0xb982, + 0xfd02, + 0x2d442, + 0x2c82, + 0x26c2, + 0xbdc2, + 0x7eec2, + 0x5582, + 0x127c3, + 0x602, + 0x16602, + 0x1242, + 0x1c682, + 0x18b85, + 0x6582, + 0x85042, + 0x172303, + 0x682, + 0x9942, + 0x33c2, + 0x5f82, + 0x12882, + 0x8c2, + 0x9e42, + 0x1b02, + 0x2cc5, + 0x75e04fc2, + 0x762f3143, + 0x2043, + 0x76604fc2, + 0x2043, + 0xe2207, + 0x2029c3, + 0x2000c2, + 0x229f43, + 0x224d03, + 0x28c6c3, + 0x2005c3, + 0x2335c3, + 0x2127c3, + 0x20bc03, + 0x21f483, + 0x39ac43, + 0x16fe06, + 0xd1484, + 0x17585, + 0x108585, + 0xb8c3, + 0x7ffc8, + 0x229f43, + 0x224d03, + 0x28c6c3, + 0x219c03, + 0x2127c3, + 0x20bc03, + 0x81983, + 0x21f483, + 0x229f43, + 0x224d03, + 0x21f483, + 0x229f43, + 0x224d03, + 0x2e9c43, + 0x200181, + 0x219c03, + 0x2127c3, + 0x25c743, + 0x21f483, + 0x2ec4, + 0x258843, + 0x229f43, + 0x224d03, + 0x229dc3, + 0x28c6c3, + 0x25c783, + 0x244d83, + 0x2b5543, + 0x204f83, + 0x2e9c43, + 0x258104, + 0x2127c3, + 0x21f483, + 0x205ec3, + 0x209f84, + 0x239343, + 0x30c3, + 0x220cc3, + 0x32bd48, + 0x349f84, + 0x20020a, + 0x264086, + 0xd9384, + 0x3babc7, + 0x22688a, + 0x233f09, + 0x3cb087, + 0x3d018a, + 0x258843, + 0x21b50b, + 0x237ac9, + 0x36a2c5, + 0x2384c7, + 0x5842, + 0x229f43, + 0x246747, + 0x347a05, + 0x2dec09, + 0x224d03, + 0x22cb86, + 0x2dd343, + 0xe3943, + 0x119e46, + 0x173bc6, + 0xf487, + 0x213cc6, + 0x22dc45, + 0x20ccc7, + 0x316f07, + 0x792e9c43, + 0x34dd47, + 0x24be03, + 0x23aa45, + 0x258104, + 0x2c8888, + 0x3e664c, + 0x2c7c85, + 0x2b5146, + 0x246607, + 0x384407, + 0x27d3c7, + 0x290448, + 0x3190cf, + 0x372ac5, + 0x24c987, + 0x29cc87, + 0x249c4a, + 0x30cf09, + 0x32c545, + 0x34d4ca, + 0x1080c6, + 0xd1747, + 0x2dd3c5, + 0x397644, + 0x340386, + 0x14f0c6, + 0x25bb47, + 0x2e1687, + 0x209748, + 0x20d005, + 0x347906, + 0x43288, + 0x242cc5, + 0x42e86, + 0x318985, + 0x29bcc4, + 0x247907, + 0x25338a, + 0x2afe88, + 0x3d6cc6, + 0x335c3, + 0x2f7305, + 0x220346, + 0x2089c6, + 0x374cc6, + 0x219c03, + 0x3b1207, + 0x29cc05, + 0x2127c3, + 0x2f454d, + 0x20bc03, + 0x209848, + 0x23d404, + 0x220645, + 0x2b6086, + 0x201a46, + 0x25cf87, + 0x26e047, + 0x280745, + 0x21f483, + 0x3326c7, + 0x207349, + 0x246049, + 0x38cf8a, + 0x2020c2, + 0x23aa04, + 0x32c1c4, + 0x2fec07, + 0x2fedc8, + 0x300949, + 0x3cf349, + 0x3014c7, + 0x10c5c9, + 0x2b81c6, + 0x103bc6, + 0x305744, + 0x2353ca, + 0x307d48, + 0x309049, + 0x309306, + 0x2cd685, + 0x2afd48, + 0x2e2bca, + 0x21cb03, + 0x20a106, + 0x3015c7, + 0x35c0c5, + 0x84408, + 0x3c3345, + 0x216f03, + 0x24a3c4, + 0x4a3c9, + 0x22e585, + 0x297087, + 0x2e8845, + 0x2f1bc6, + 0x1063c5, + 0x2148c3, + 0x2148c9, + 0x22040c, + 0x2d320c, + 0x3485c8, + 0x2a0c47, + 0x3e4008, + 0x111547, + 0x3118ca, + 0x311f8b, + 0x237c08, + 0x201b48, + 0x260fc6, + 0x31c245, + 0x284d8a, + 0x3da585, + 0x208ec2, + 0x2e1487, + 0x278606, + 0x37f485, + 0x3977c9, + 0x36f885, + 0x1d2348, + 0x2a3585, + 0x23a609, + 0x322dc6, + 0x3406c8, + 0x246ec3, + 0x211706, + 0x383646, + 0x31cb85, + 0x31cb89, + 0x287109, + 0x284b07, + 0x120c44, + 0x320c47, + 0x3cf249, + 0x221a85, + 0x26a88, + 0x372185, + 0x2028c5, + 0x367bc9, + 0x201182, + 0x2556c4, + 0x20f582, + 0x203382, + 0x361b85, + 0x352948, + 0x2d1385, + 0x2dfe43, + 0x2dfe45, + 0x2ec5c3, + 0x211402, + 0x298a44, + 0x203a83, + 0x200a82, + 0x2f81c4, + 0x30d543, + 0x2043c2, + 0x26e983, + 0x2189c4, + 0x309483, + 0x2623c4, + 0x201782, + 0x21ee83, + 0x21e503, + 0x204942, + 0x29ec82, + 0x286f49, + 0x205182, + 0x29b184, + 0x203ac2, + 0x264644, + 0x2b8184, + 0x2d4844, + 0x201b02, + 0x249442, + 0x396583, + 0x311d43, + 0x297204, + 0x2e6f44, + 0x31e604, + 0x320dc4, + 0x31c503, + 0x383983, + 0x308044, + 0x322604, + 0x322746, + 0x202742, + 0x5842, + 0x4d383, + 0x205842, + 0x224d03, + 0x2e9c43, + 0x2127c3, + 0x21f483, + 0x14305, + 0x2000c2, + 0x258843, + 0x229f43, + 0x224d03, + 0x206dc3, + 0x2e9c43, + 0x258104, + 0x287204, + 0x222d84, + 0x2127c3, + 0x21f483, + 0x202783, + 0x305d44, + 0x329b43, + 0x223503, + 0x387d04, + 0x371f86, + 0x207e43, + 0x145d45, + 0xf1a47, + 0x261c03, + 0x7ae14fc8, + 0x209343, + 0x2ca043, + 0x21b643, + 0x2335c3, + 0x371ac5, + 0x38483, + 0x229f43, + 0x224d03, + 0x2e9c43, + 0x2127c3, + 0x21f483, + 0x211543, + 0x2033c3, + 0x7ffc8, + 0x229f43, + 0x224d03, + 0x2e9c43, + 0x25e043, + 0x2127c3, + 0x294384, + 0x81983, + 0x21f483, + 0x2d0584, + 0x145d45, + 0x2f5345, + 0xf1a47, + 0x205842, + 0x201902, + 0x200382, + 0x2048c2, + 0xbc03, + 0x2003c2, + 0x1544, + 0x229f43, + 0x241284, + 0x224d03, + 0x2e9c43, + 0x219c03, + 0x2127c3, + 0x21f483, + 0x7ffc8, + 0x229f43, + 0x224d03, + 0x2e9c43, + 0x219c03, + 0x222d84, + 0x2127c3, + 0xbc03, + 0x21f483, + 0x217083, + 0x29f804, + 0x7ffc8, + 0x229f43, + 0x20bc03, + 0xb8c3, + 0x123944, + 0x259b44, + 0x7ffc8, + 0x5842, + 0x229f43, + 0x25b9c4, + 0x258104, + 0x20bc03, + 0x200f82, + 0x81983, + 0x21f483, + 0x23ffc3, + 0x4a3c4, + 0x32e885, + 0x208ec2, + 0x325ec3, + 0x172fc9, + 0xf2386, + 0x87e08, + 0x2000c2, + 0x7ffc8, + 0x205842, + 0x224d03, + 0x2e9c43, + 0x2005c2, + 0xbc03, + 0x21f483, + 0x2802, + 0x82, + 0xc2, + 0x1d0347, + 0x1e949, + 0x2fc3, + 0x7ffc8, + 0x18f203, + 0x7e724f47, + 0x29f43, + 0xfdc8, + 0x24d03, + 0x86247, + 0xe9c43, + 0x3d286, + 0x5e043, + 0xa9388, + 0xdc448, + 0x1d4883, + 0x122246, + 0x7e92fc05, + 0x1318c5, + 0x19c03, + 0x9dac8, + 0xe59c8, + 0x62b03, + 0x7ecf6786, + 0xfb305, + 0x869c4, + 0x3e8c7, + 0x127c3, + 0x4b83, + 0x1f483, + 0x2082, + 0x18a0ca, + 0x37945, + 0x3d43, + 0x7f2d8e0c, + 0x161c43, + 0x120984, + 0x118ecb, + 0x119488, + 0x1965c4, + 0xa1342, + 0x45f03, + 0x1434307, + 0x15ce3c7, + 0x14dff08, + 0x1445f03, + 0x1c8bc8, + 0x1496944, + 0x183dcb, + 0x12c82, + 0x1300c7, + 0x14bc04, + 0x2000c2, + 0x205842, + 0x241284, + 0x2e9c43, + 0x219c03, + 0x2127c3, + 0x21f483, + 0x229f43, + 0x224d03, + 0x2e9c43, + 0x2335c3, + 0x2127c3, + 0x21f483, + 0x2a31c3, + 0x217083, + 0x13803, + 0x229f43, + 0x224d03, + 0x2e9c43, + 0x2127c3, + 0x21f483, + 0x229f43, + 0x224d03, + 0x2e9c43, + 0x2127c3, + 0x21f483, + 0xb8c3, + 0x24d03, + 0x814e9c43, + 0x80407, + 0x229f43, + 0x224d03, + 0x2e9c43, + 0x258104, + 0x2335c3, + 0x2127c3, + 0x21f483, + 0x26ca02, + 0x2000c1, + 0x2000c2, + 0x200201, + 0x3385c2, + 0x7ffc8, + 0x224f85, + 0x200101, + 0x29f43, + 0x3b4c4, + 0x200d01, + 0x200501, + 0x200c01, + 0x254602, + 0x395c04, + 0x254603, + 0x200041, + 0x200801, + 0x200181, + 0x1eaa46, + 0x200701, + 0x3bc807, + 0x38decf, + 0x3786c6, + 0x2004c1, + 0x323986, + 0x200b41, + 0x200581, + 0x3b7fce, + 0x2003c1, + 0x21f483, + 0x200a81, + 0x328745, + 0x202082, + 0x216e05, + 0x200401, + 0x200741, + 0x2007c1, + 0x208ec2, + 0x200081, + 0x205241, + 0x201541, + 0x201c41, + 0x201b81, + 0x60209, + 0x7ffc8, + 0x229f43, + 0x224d03, + 0x10e7c8, + 0x2e9c43, + 0x2127c3, + 0x21f483, + 0x21fc83, + 0x1efd03, + 0x229f43, + 0x2e9c43, + 0xa1288, + 0x219c03, + 0x2127c3, + 0x9843, + 0x21f483, + 0x82f0ad88, + 0x1ef9c3, + 0x11448, + 0x12d02, + 0x2583, + 0x6cc2, + 0x1b02, + 0x145d45, + 0x7ffc8, + 0x9e0c6, + 0x161487, + 0xbc03, + 0x145d45, + 0x179c04, + 0x199ac8, + 0x51a44, + 0x1217c7, + 0x63e44, + 0x5818c, + 0x1e6644, + 0x27885, + 0x60209, + 0x176507, + 0x1df86, + 0x5b74a, + 0x156e00a, + 0x11d484, + 0x1506c43, + 0x7ffc8, + 0x81983, + 0x229f43, + 0x224d03, + 0x2e9c43, + 0x2127c3, + 0x21f483, + 0x2030c3, + 0x7ffc8, + 0x229f43, + 0x224d03, + 0x2ef2c4, + 0x21f483, + 0x28a685, + 0x279884, + 0x229f43, + 0x224d03, + 0x2e9c43, + 0x2026c2, + 0x2127c3, + 0x21f483, + 0x17083, + 0xf3f86, + 0xc2904, + 0x124a86, + 0x258843, + 0x229f43, + 0x224d03, + 0x2e9c43, + 0x2026c2, + 0x2127c3, + 0x21f483, + 0x217083, + 0x205842, + 0x229f43, + 0x23ba49, + 0x224d03, + 0x2bc9c9, + 0x219c03, + 0x2127c3, + 0x8d344, + 0xbc03, + 0x21f483, + 0x305548, + 0x245347, + 0x32e885, + 0xd2048, + 0x12e889, + 0x1e5e08, + 0x1d0347, + 0xff04a, + 0x15964b, + 0x123bc7, + 0x4af48, + 0x8fca, + 0xc9508, + 0x1e949, + 0x2e447, + 0x1d8c7, + 0xbd08, + 0xfdc8, + 0x4cc4f, + 0xb0045, + 0x1f507, + 0x3d286, + 0x41007, + 0x12c686, + 0xa9388, + 0xae506, + 0x1404c7, + 0x167fc9, + 0x1ca87, + 0xe7d89, + 0xd2449, + 0xd9106, + 0xdc448, + 0xd2305, + 0x158e0a, + 0xe59c8, + 0x62b03, + 0xec9c8, + 0x3e8c7, + 0x1865c5, + 0x160810, + 0x4b83, + 0x81983, + 0x183307, + 0x1c605, + 0xffd88, + 0x7a605, + 0x161c43, + 0x1dea48, + 0x2606, + 0x15f089, + 0xbfb87, + 0x17328b, + 0x7f144, + 0x112d84, + 0x118ecb, + 0x119488, + 0x119d47, + 0x145d45, + 0x229f43, + 0x224d03, + 0x28c6c3, + 0x21f483, + 0x249f03, + 0x2e9c43, + 0x81983, + 0x229f43, + 0x224d03, + 0x2e9c43, + 0x219c03, + 0x2127c3, + 0x21f483, + 0x1ddb4b, + 0x2000c2, + 0x205842, + 0x21f483, + 0x2102, + 0x26c2, + 0x5ec2, + 0x7ffc8, + 0x12b409, + 0x1c8bc8, + 0x5842, + 0x2000c2, + 0x205842, + 0x200382, + 0x2005c2, + 0x205c02, + 0x2127c3, + 0x165c6, + 0x2003c2, + 0x4a3c4, + 0x2000c2, + 0x258843, + 0x205842, + 0x229f43, + 0x224d03, + 0x200382, + 0x2e9c43, + 0x25e043, + 0x219c03, + 0x222d84, + 0x2127c3, + 0x21c043, + 0xbc03, + 0x21f483, + 0x320984, + 0x205ec3, + 0x2e9c43, + 0x205842, + 0x229f43, + 0x224d03, + 0x2e9c43, + 0x219c03, + 0x2127c3, + 0x20bc03, + 0x21f483, + 0x3c96c7, + 0x229f43, + 0x24dac7, + 0x3a3d06, + 0x21b983, + 0x226403, + 0x2e9c43, + 0x204203, + 0x258104, + 0x3b4204, + 0x33ef46, + 0x231083, + 0x2127c3, + 0x10aacb, + 0x21f483, + 0x28a685, + 0x22b5c4, + 0x3b6a43, + 0x3d8003, + 0x2e1487, + 0x236f05, + 0x2283, + 0x229f43, + 0x224d03, + 0x2e9c43, + 0x219c03, + 0x2127c3, + 0x1c3404, + 0x21f483, + 0x1f343, + 0x8a30d6cc, + 0x5db43, + 0x53a87, + 0x4c106, + 0xd5247, + 0x135f85, + 0x204e42, + 0x256803, + 0x219383, + 0x258843, + 0x8ae29f43, + 0x208542, + 0x224d03, + 0x204b03, + 0x2e9c43, + 0x258104, + 0x3ce883, + 0x372ac3, + 0x219c03, + 0x222d84, + 0x8b203bc2, + 0x2127c3, + 0x21f483, + 0x2043c3, + 0x229c83, + 0x212843, + 0x26ca02, + 0x205ec3, + 0x7ffc8, + 0x2e9c43, + 0xb8c3, + 0x285584, + 0x258843, + 0x205842, + 0x229f43, + 0x241284, + 0x224d03, + 0x2e9c43, + 0x258104, + 0x25e043, + 0x276f44, + 0x292e44, + 0x2edcc6, + 0x222d84, + 0x2127c3, + 0x21f483, + 0x202783, + 0x278606, + 0x46bcb, + 0x332c6, + 0x12650a, + 0x11e28a, + 0x7ffc8, + 0x243244, + 0x8c629f43, + 0x384f44, + 0x224d03, + 0x29e6c4, + 0x2e9c43, + 0x352e83, + 0x219c03, + 0x2127c3, + 0x81983, + 0x21f483, + 0x2f7c3, + 0x34804b, + 0x3dc94a, + 0x3ef4cc, + 0xf7088, + 0x2000c2, + 0x205842, + 0x200382, + 0x235c45, + 0x258104, + 0x2026c2, + 0x219c03, + 0x292e44, + 0x2048c2, + 0x2003c2, + 0x2036c2, + 0x26ca02, + 0x58843, + 0x35c2, + 0x2da949, + 0x27ce48, + 0x2f0949, + 0x3a6ac9, + 0x212d4a, + 0x214aca, + 0x20d482, + 0x2b90c2, + 0x5842, + 0x229f43, + 0x20f1c2, + 0x24cb46, + 0x329c42, + 0x48e02, + 0x20ad42, + 0x3599ce, + 0x21eece, + 0x212747, + 0x2154c2, + 0x224d03, + 0x2e9c43, + 0x205d42, + 0x2005c2, + 0x58103, + 0x24148f, + 0x21d942, + 0x2e8447, + 0x2ecb87, + 0x2f1d07, + 0x2f5d4c, + 0x2fbe8c, + 0x2fc844, + 0x291c0a, + 0x21ee02, + 0x208042, + 0x2d4344, + 0x200702, + 0x24f6c2, + 0x2fc0c4, + 0x21c142, + 0x20b982, + 0x280c3, + 0x2ae587, + 0x35ba05, + 0x22d442, + 0x240f84, + 0x20bdc2, + 0x2f6908, + 0x2127c3, + 0x37f808, + 0x204982, + 0x2fca05, + 0x3a4706, + 0x21f483, + 0x206582, + 0x300b87, + 0x2082, + 0x252e45, + 0x331d05, + 0x20b082, + 0x208382, + 0x3cb68a, + 0x2805ca, + 0x246f82, + 0x2af444, + 0x202602, + 0x23a8c8, + 0x20d682, + 0x2dd588, + 0x4c01, + 0x314487, + 0x315189, + 0x252ec2, + 0x31ab85, + 0x37ba45, + 0x21c6cb, + 0x20d0cc, + 0x2323c8, + 0x32ff08, + 0x202742, + 0x25d042, + 0x2000c2, + 0x7ffc8, + 0x205842, + 0x229f43, + 0x200382, + 0x2048c2, + 0xbc03, + 0x2003c2, + 0x21f483, + 0x2036c2, + 0x2000c2, + 0x145d45, + 0x8da05842, + 0x10d804, + 0x44005, + 0x8eae9c43, + 0x2280c3, + 0x2026c2, + 0x2127c3, + 0x3c5f83, + 0x8ee1f483, + 0x2fe343, + 0x2e2306, + 0x1976c5, + 0x1617083, + 0x145d45, + 0x1482cb, + 0x7ffc8, + 0x8dfce6c8, + 0x6b547, + 0x8e2ce18a, + 0x7fdc7, + 0xcab05, + 0x8e786f09, + 0x3204d, + 0x3d082, + 0x119a82, + 0xc41, + 0xf7544, + 0xb978a, + 0x80407, + 0x1e5c4, + 0x1e603, + 0x1e604, + 0x8f603e02, + 0x8fa00ac2, + 0x8fe00ec2, + 0x90200b82, + 0x90604142, + 0x90a03702, + 0xf1a47, + 0x90e05842, + 0x91215582, + 0x91605802, + 0x91a00d02, + 0x21eec3, + 0x2ba44, + 0x91f0e7c8, + 0x220f43, + 0x92217202, + 0x6d988, + 0x92602a82, + 0x82907, + 0x1bbe47, + 0x92a00042, + 0x92e02142, + 0x93200182, + 0x93603842, + 0x93a09c42, + 0x93e005c2, + 0x16a205, + 0x2191c3, + 0x368784, + 0x94200702, + 0x94619f42, + 0x94a065c2, + 0x8e04b, + 0x94e00b42, + 0x95654902, + 0x95a026c2, + 0x95e05c02, + 0x9dac8, + 0x9621dfc2, + 0x9660dec2, + 0x96a0f782, + 0x96e7eec2, + 0x97203bc2, + 0x97604242, + 0x97a048c2, + 0x97e0ee02, + 0x9822f002, + 0x9860e942, + 0xf9304, + 0x381983, + 0x98a3fa02, + 0x98e1d342, + 0x9920dcc2, + 0x996006c2, + 0x99a003c2, + 0x99e00a82, + 0xfde88, + 0x1ddcc7, + 0x9a202782, + 0x9a603342, + 0x9aa036c2, + 0x9ae1ee82, + 0x15804c, + 0x9b201c82, + 0x9b626d42, + 0x9ba06202, + 0x9be04c02, + 0x9c212182, + 0x9c612ec2, + 0x9ca05242, + 0x9ce0f542, + 0x9d288142, + 0x9d689482, + 0x2035c2, + 0x3ce883, + 0x22d643, + 0x2035c2, + 0x3ce883, + 0x22d643, + 0x2035c2, + 0x3ce883, + 0x22d643, + 0x2035c2, + 0x3ce883, + 0x22d643, + 0x2035c2, + 0x3ce883, + 0x22d643, + 0x2035c2, + 0x3ce883, + 0x22d643, + 0x2035c2, + 0x3ce883, + 0x22d643, + 0x2035c2, + 0x3ce883, + 0x22d643, + 0x2035c2, + 0x3ce883, + 0x22d643, + 0x2035c2, + 0x3ce883, + 0x2d643, + 0xc8503, + 0x2035c2, + 0x3ce883, + 0x22d643, + 0x2035c2, + 0x3ce883, + 0x22d643, + 0x2035c2, + 0x3ce883, + 0x22d643, + 0x2035c2, + 0x22d643, + 0x2035c2, + 0x3ce883, + 0x22d643, + 0x2035c2, + 0x3ce883, + 0x22d643, + 0x2035c2, + 0x3ce883, + 0x22d643, + 0x2035c2, + 0x3ce883, + 0x22d643, + 0x2035c2, + 0x3ce883, + 0x22d643, + 0x2035c2, + 0x3ce883, + 0x22d643, + 0x2035c2, + 0x3ce883, + 0x22d643, + 0x2035c2, + 0x953ce883, + 0x22d643, + 0x371b44, + 0x2f0846, + 0x309a43, + 0x2035c2, + 0x3ce883, + 0x22d643, + 0x2035c2, + 0x3ce883, + 0x22d643, + 0x271609, + 0x2035c2, + 0x367e03, + 0x2d2743, + 0x3b6c85, + 0x204b03, + 0x3ce883, + 0x22d643, + 0x2ed403, + 0x23c7c3, + 0x205249, + 0x2035c2, + 0x3ce883, + 0x22d643, + 0x2035c2, + 0x3ce883, + 0x22d643, + 0x2035c2, + 0x3ce883, + 0x22d643, + 0x2035c2, + 0x3ce883, + 0x22d643, + 0x2035c2, + 0x3ce883, + 0x22d643, + 0x2035c2, + 0x22d643, + 0x2035c2, + 0x3ce883, + 0x22d643, + 0x2035c2, + 0x3ce883, + 0x22d643, + 0x2035c2, + 0x3ce883, + 0x22d643, + 0x2035c2, + 0x3ce883, + 0x22d643, + 0x2035c2, + 0x3ce883, + 0x22d643, + 0x2035c2, + 0x3ce883, + 0x22d643, + 0x2035c2, + 0x3ce883, + 0x22d643, + 0x2035c2, + 0x3ce883, + 0x22d643, + 0x2035c2, + 0x3ce883, + 0x22d643, + 0x2035c2, + 0x3ce883, + 0x22d643, + 0x2035c2, + 0x3ce883, + 0x22d643, + 0x2035c2, + 0x22d643, + 0x2035c2, + 0x3ce883, + 0x22d643, + 0x2035c2, + 0x22d643, + 0x2035c2, + 0x3ce883, + 0x22d643, + 0x2035c2, + 0x3ce883, + 0x22d643, + 0x2035c2, + 0x3ce883, + 0x22d643, + 0x2035c2, + 0x3ce883, + 0x22d643, + 0x2035c2, + 0x3ce883, + 0x22d643, + 0x2035c2, + 0x3ce883, + 0x22d643, + 0x2035c2, + 0x3ce883, + 0x22d643, + 0x2035c2, + 0x3ce883, + 0x22d643, + 0x2035c2, + 0x2035c2, + 0x3ce883, + 0x22d643, + 0x9de29f43, + 0x224d03, + 0x3a6d03, + 0x219c03, + 0x2127c3, + 0xbc03, + 0x21f483, + 0x7ffc8, + 0x205842, + 0x229f43, + 0x2127c3, + 0x21f483, + 0x71482, + 0x229f43, + 0x224d03, + 0x2e9c43, + 0x9e90b602, + 0x219c03, + 0x2127c3, + 0xbc03, + 0x21f483, + 0xd01, + 0x259b44, + 0x205842, + 0x229f43, + 0x200983, + 0x224d03, + 0x25b9c4, + 0x28c6c3, + 0x2e9c43, + 0x258104, + 0x25e043, + 0x219c03, + 0x2127c3, + 0x21f483, + 0x23ffc3, + 0x32e885, + 0x23c7c3, + 0x205ec3, + 0x882, + 0xbc03, + 0x205842, + 0x229f43, + 0x3ce883, + 0x2127c3, + 0x21f483, + 0x2000c2, + 0x258843, + 0x7ffc8, + 0x229f43, + 0x224d03, + 0x2e9c43, + 0x2389c6, + 0x258104, + 0x25e043, + 0x222d84, + 0x2127c3, + 0x21f483, + 0x202783, + 0x45c4, + 0xb90c2, + 0x229f43, + 0x5483, + 0x224d03, + 0x26c2, + 0x2127c3, + 0x21f483, + 0x76c04, + 0x762c4, + 0xfc2, + 0x1489e07, + 0x187887, + 0x229f43, + 0x332c6, + 0x224d03, + 0x2e9c43, + 0xf8986, + 0x2127c3, + 0x21f483, + 0x32bbc8, + 0x32fd49, + 0x340f89, + 0x34b788, + 0x3a6908, + 0x3a6909, + 0x3254ca, + 0x362f8a, + 0x3a0d8a, + 0x3a8fca, + 0x3dc94a, + 0x3ea14b, + 0x230a4d, + 0x248e4f, + 0x36ea90, + 0x36668d, + 0x38b00c, + 0x3a8d0b, + 0x1a20c7, + 0x1299ce, + 0x12cd8a, + 0x12fa49, + 0x140f89, + 0x164fc9, + 0x16520a, + 0x16de09, + 0x16e789, + 0x17014b, + 0x29b08, + 0x10b448, + 0x14abc9, + 0x1498307, + 0xe3f05, + 0x229f43, + 0x224d03, + 0x2e9c43, + 0x219c03, + 0x2127c3, + 0x21f483, + 0x1f483, + 0x2000c2, + 0x236d45, + 0x228083, + 0xa2e05842, + 0x224d03, + 0x2e9c43, + 0x3664c7, + 0x21b643, + 0x219c03, + 0x2127c3, + 0x25c743, + 0x21c043, + 0x204003, + 0x20bc03, + 0x21f483, + 0x25ce86, + 0x208ec2, + 0x205ec3, + 0x7ffc8, + 0x2000c2, + 0x258843, + 0x205842, + 0x229f43, + 0x224d03, + 0x2e9c43, + 0x258104, + 0x219c03, + 0x2127c3, + 0x21f483, + 0x217083, + 0x187887, + 0x12c82, + 0x9744, + 0x151d546, + 0x2000c2, + 0x205842, + 0x2e9c43, + 0x219c03, + 0x21f483, +} + +// children is the list of nodes' children, the parent's wildcard bit and the +// parent's node type. If a node has no children then their children index +// will be in the range [0, 6), depending on the wildcard bit and node type. +// +// The layout within the uint32, from MSB to LSB, is: +// [ 1 bits] unused +// [ 1 bits] wildcard bit +// [ 2 bits] node type +// [14 bits] high nodes index (exclusive) of children +// [14 bits] low nodes index (inclusive) of children +var children = [...]uint32{ + 0x0, + 0x10000000, + 0x20000000, + 0x40000000, + 0x50000000, + 0x60000000, + 0x17a05e2, + 0x17a45e8, + 0x17a85e9, + 0x17cc5ea, + 0x19245f3, + 0x193c649, + 0x195064f, + 0x1968654, + 0x198865a, + 0x19ac662, + 0x19c466b, + 0x1a04671, + 0x1a08681, + 0x1a30682, + 0x1a3468c, + 0x1a4c68d, + 0x1a50693, + 0x1a54694, + 0x1a94695, + 0x1a986a5, + 0x1a9c6a6, + 0x21aa06a7, + 0x61aa86a8, + 0x21ab06aa, + 0x1af86ac, + 0x1b006be, + 0x21b046c0, + 0x1b286c1, + 0x1b2c6ca, + 0x1b406cb, + 0x1b446d0, + 0x1b646d1, + 0x1b946d9, + 0x1bb06e5, + 0x1bb86ec, + 0x1be06ee, + 0x1bf86f8, + 0x21bfc6fe, + 0x21c006ff, + 0x1c04700, + 0x1c9c701, + 0x1cb0727, + 0x1cc472c, + 0x1cfc731, + 0x1d0c73f, + 0x1d20743, + 0x1d38748, + 0x1ddc74e, + 0x2010777, + 0x2018804, + 0x2201c806, + 0x22020807, + 0x208c808, + 0x20f8823, + 0x211083e, + 0x2124844, + 0x2128849, + 0x212c84a, + 0x213484b, + 0x214c84d, + 0x2150853, + 0x2174854, + 0x21c485d, + 0x21c8871, + 0x221cc872, + 0x21ec873, + 0x21f087b, + 0x21f487c, + 0x222087d, + 0x62224888, + 0x2222c889, + 0x2223088b, + 0x227488c, + 0x6227889d, + 0x229489e, + 0x22ec8a5, + 0x222f08bb, + 0x222f48bc, + 0x222fc8bd, + 0x223008bf, + 0x223048c0, + 0x23088c1, + 0x23108c2, + 0x23148c4, + 0x223208c5, + 0x223288c8, + 0x23388ca, + 0x23488ce, + 0x23fc8d2, + 0x24008ff, + 0x22410900, + 0x22414904, + 0x2241c905, + 0x2474907, + 0x247891d, + 0x247c91e, + 0x248091f, + 0x2a4c920, + 0x2a50a93, + 0x22af8a94, + 0x22afcabe, + 0x22b00abf, + 0x22b0cac0, + 0x22b10ac3, + 0x22b1cac4, + 0x22b20ac7, + 0x22b24ac8, + 0x22b28ac9, + 0x22b2caca, + 0x22b30acb, + 0x22b3cacc, + 0x22b40acf, + 0x22b4cad0, + 0x22b50ad3, + 0x22b54ad4, + 0x22b58ad5, + 0x22b64ad6, + 0x22b68ad9, + 0x22b74ada, + 0x22b78add, + 0x22b7cade, + 0x22b80adf, + 0x2b84ae0, + 0x22b88ae1, + 0x22b94ae2, + 0x22b98ae5, + 0x2b9cae6, + 0x2ba4ae7, + 0x62bb0ae9, + 0x2bf4aec, + 0x22c14afd, + 0x22c18b05, + 0x22c1cb06, + 0x22c24b07, + 0x22c2cb09, + 0x22c30b0b, + 0x22c34b0c, + 0x22c3cb0d, + 0x22c40b0f, + 0x22c44b10, + 0x2c48b11, + 0x22c74b12, + 0x22c78b1d, + 0x22c7cb1e, + 0x2c80b1f, + 0x22c84b20, + 0x22c88b21, + 0x22c94b22, + 0x22c98b25, + 0x2c9cb26, + 0x2ca4b27, + 0x2cacb29, + 0x2cb0b2b, + 0x2cccb2c, + 0x2ce4b33, + 0x2ce8b39, + 0x2cf8b3a, + 0x2d04b3e, + 0x2d38b41, + 0x2d40b4e, + 0x22d44b50, + 0x2d5cb51, + 0x22d64b57, + 0x22d68b59, + 0x22d70b5a, + 0x2e74b5c, + 0x22e78b9d, + 0x2e80b9e, + 0x2e84ba0, + 0x22e88ba1, + 0x2e8cba2, + 0x2ed0ba3, + 0x2ed4bb4, + 0x2ed8bb5, + 0x2ef0bb6, + 0x2f04bbc, + 0x2f2cbc1, + 0x2f54bcb, + 0x2f58bd5, + 0x62f5cbd6, + 0x2f90bd7, + 0x2f94be4, + 0x22f98be5, + 0x2f9cbe6, + 0x2fc4be7, + 0x2fc8bf1, + 0x2fecbf2, + 0x2ff0bfb, + 0x3004bfc, + 0x3008c01, + 0x300cc02, + 0x302cc03, + 0x304cc0b, + 0x23050c13, + 0x3054c14, + 0x23058c15, + 0x305cc16, + 0x3060c17, + 0x3064c18, + 0x3068c19, + 0x3084c1a, + 0x23088c21, + 0x23090c22, + 0x3094c24, + 0x30bcc25, + 0x30d0c2f, + 0x3144c34, + 0x3150c51, + 0x3154c54, + 0x3174c55, + 0x318cc5d, + 0x3190c63, + 0x31a4c64, + 0x31bcc69, + 0x31dcc6f, + 0x31f4c77, + 0x31fcc7d, + 0x3218c7f, + 0x3234c86, + 0x3238c8d, + 0x3264c8e, + 0x3284c99, + 0x32a4ca1, + 0x32a8ca9, + 0x3310caa, + 0x3330cc4, + 0x3358ccc, + 0x335ccd6, + 0x3374cd7, + 0x33b8cdd, + 0x3438cee, + 0x3478d0e, + 0x347cd1e, + 0x3488d1f, + 0x34a8d22, + 0x34b0d2a, + 0x34d4d2c, + 0x34dcd35, + 0x351cd37, + 0x3570d47, + 0x3574d5c, + 0x3678d5d, + 0x23680d9e, + 0x23684da0, + 0x23688da1, + 0x2368cda2, + 0x23690da3, + 0x3694da4, + 0x23698da5, + 0x2369cda6, + 0x236a0da7, + 0x36a4da8, + 0x236a8da9, + 0x236b8daa, + 0x236bcdae, + 0x236c0daf, + 0x236c4db0, + 0x236c8db1, + 0x236ccdb2, + 0x236d0db3, + 0x36e8db4, + 0x370cdba, + 0x372cdc3, + 0x3da0dcb, + 0x23da4f68, + 0x23da8f69, + 0x23dacf6a, + 0x23db0f6b, + 0x3dc0f6c, + 0x3de0f70, + 0x3fa0f78, + 0x4070fe8, + 0x40e101c, + 0x4139038, + 0x422104e, + 0x4279088, + 0x42b509e, + 0x43b10ad, + 0x447d0ec, + 0x451511f, + 0x45a5145, + 0x4609169, + 0x4841182, + 0x48f9210, + 0x49c523e, + 0x4a11271, + 0x4a99284, + 0x4ad52a6, + 0x4b252b5, + 0x4b9d2c9, + 0x64ba12e7, + 0x64ba52e8, + 0x64ba92e9, + 0x4c252ea, + 0x4c81309, + 0x4cfd320, + 0x4d7533f, + 0x4df535d, + 0x4e6137d, + 0x4f8d398, + 0x4fe53e3, + 0x64fe93f9, + 0x50813fa, + 0x5089420, + 0x2508d422, + 0x5115423, + 0x5161445, + 0x51c9458, + 0x5271472, + 0x533949c, + 0x53a14ce, + 0x54b54e8, + 0x654b952d, + 0x654bd52e, + 0x551952f, + 0x5575546, + 0x560555d, + 0x5681581, + 0x56c55a0, + 0x57a95b1, + 0x57dd5ea, + 0x583d5f7, + 0x58b160f, + 0x593962c, + 0x597964e, + 0x59e965e, + 0x659ed67a, + 0x5a1567b, + 0x5a19685, + 0x5a49686, + 0x5a65692, + 0x5aa9699, + 0x5ab96aa, + 0x5ad16ae, + 0x5b496b4, + 0x5b516d2, + 0x5b6d6d4, + 0x5b816db, + 0x5ba56e0, + 0x25ba96e9, + 0x5bd56ea, + 0x5bd96f5, + 0x5be16f6, + 0x5bf56f8, + 0x5c156fd, + 0x5c25705, + 0x5c31709, + 0x5c6d70c, + 0x5c7171b, + 0x5c7971c, + 0x5c8d71e, + 0x5cb5723, + 0x5cc172d, + 0x5cc9730, + 0x5cf1732, + 0x5d1573c, + 0x5d2d745, + 0x5d3174b, + 0x5d3974c, + 0x5d4174e, + 0x5d55750, + 0x5e11755, + 0x5e15784, + 0x5e1d785, + 0x5e21787, + 0x5e45788, + 0x5e69791, + 0x5e8579a, + 0x5e997a1, + 0x5ead7a6, + 0x5eb57ab, + 0x5ebd7ad, + 0x5ec57af, + 0x5edd7b1, + 0x5eed7b7, + 0x5ef17bb, + 0x5f0d7bc, + 0x67957c3, + 0x67cd9e5, + 0x67f99f3, + 0x68159fe, + 0x6839a05, + 0x6859a0e, + 0x689da16, + 0x68a5a27, + 0x268a9a29, + 0x268ada2a, + 0x68b5a2b, + 0x6ae5a2d, + 0x6af9ab9, + 0x26afdabe, + 0x6b01abf, + 0x6b09ac0, + 0x26b15ac2, + 0x26b25ac5, + 0x26b2dac9, + 0x26b39acb, + 0x6b3dace, + 0x26b41acf, + 0x26b59ad0, + 0x26b61ad6, + 0x26b69ad8, + 0x26b6dada, + 0x26b75adb, + 0x6b79add, + 0x26b7dade, + 0x6b81adf, + 0x26b8dae0, + 0x6b95ae3, + 0x6ba9ae5, + 0x6badaea, + 0x6bd5aeb, + 0x6c11af5, + 0x6c15b04, + 0x6c4db05, + 0x6c71b13, + 0x77c9b1c, + 0x77cddf2, + 0x77d1df3, + 0x277d5df4, + 0x77d9df5, + 0x277dddf6, + 0x77e1df7, + 0x277eddf8, + 0x77f1dfb, + 0x77f5dfc, + 0x277f9dfd, + 0x77fddfe, + 0x27805dff, + 0x7809e01, + 0x780de02, + 0x2781de03, + 0x7821e07, + 0x7825e08, + 0x7829e09, + 0x782de0a, + 0x27831e0b, + 0x7835e0c, + 0x7839e0d, + 0x783de0e, + 0x7841e0f, + 0x27849e10, + 0x784de12, + 0x7851e13, + 0x7855e14, + 0x27859e15, + 0x785de16, + 0x27865e17, + 0x27869e19, + 0x7885e1a, + 0x789de21, + 0x78e1e27, + 0x78e5e38, + 0x7909e39, + 0x791de42, + 0x7921e47, + 0x7925e48, + 0x7ae9e49, + 0x27aedeba, + 0x27af5ebb, + 0x27af9ebd, + 0x27afdebe, + 0x7b05ebf, + 0x7be1ec1, + 0x27bedef8, + 0x27bf1efb, + 0x27bf5efc, + 0x27bf9efd, + 0x7bfdefe, + 0x7c29eff, + 0x7c39f0a, + 0x7c3df0e, + 0x7c61f0f, + 0x7c6df18, + 0x7c8df1b, + 0x7c91f23, + 0x7cc9f24, + 0x7f85f32, + 0x8041fe1, + 0x8046010, + 0x804a011, + 0x805e012, + 0x8062017, + 0x8096018, + 0x80ce025, + 0x280d2033, + 0x80ee034, + 0x811603b, + 0x811a045, + 0x813e046, + 0x815a04f, + 0x8182056, + 0x8192060, + 0x8196064, + 0x819a065, + 0x81d6066, + 0x81e2075, + 0x820a078, + 0x82ae082, + 0x282b20ab, + 0x82b60ac, + 0x82c60ad, + 0x282ca0b1, + 0x82de0b2, + 0x82fa0b7, + 0x831a0be, + 0x831e0c6, + 0x83320c7, + 0x83460cc, + 0x834a0d1, + 0x83520d2, + 0x83560d4, + 0x83760d5, + 0x84220dd, + 0x8426108, + 0x8446109, + 0x8472111, + 0x2848211c, + 0x8486120, + 0x8496121, + 0x84d6125, + 0x84de135, + 0x84f2137, + 0x851213c, + 0x852e144, + 0x853a14b, + 0x855a14e, + 0x858e156, + 0x8596163, + 0x866a165, + 0x866e19a, + 0x868219b, + 0x868a1a0, + 0x86a21a2, + 0x86a61a8, + 0x86b21a9, + 0x86be1ac, + 0x86c21af, + 0x86ca1b0, + 0x86ce1b2, + 0x86f21b3, + 0x87321bc, + 0x87361cc, + 0x87561cd, + 0x87aa1d5, + 0x87da1ea, + 0x287de1f6, + 0x87e61f7, + 0x883e1f9, + 0x884220f, + 0x8846210, + 0x884a211, + 0x888e212, + 0x889e223, + 0x88de227, + 0x88e2237, + 0x8912238, + 0x8a5e244, + 0x8a86297, + 0x8ac22a1, + 0x8aea2b0, + 0x28af22ba, + 0x28af62bc, + 0x28afa2bd, + 0x8b022be, + 0x8b0e2c0, + 0x8c322c3, + 0x8c3e30c, + 0x8c4a30f, + 0x8c56312, + 0x8c62315, + 0x8c6e318, + 0x8c7a31b, + 0x8c8631e, + 0x8c92321, + 0x8c9e324, + 0x8caa327, + 0x28cae32a, + 0x8cba32b, + 0x8cc632e, + 0x8cd2331, + 0x8cda334, + 0x8ce6336, + 0x8cf2339, + 0x8cfe33c, + 0x8d0a33f, + 0x8d16342, + 0x8d22345, + 0x8d2e348, + 0x8d3a34b, + 0x8d4634e, + 0x8d52351, + 0x8d5e354, + 0x8d8a357, + 0x8d96362, + 0x8da2365, + 0x8dae368, + 0x8dba36b, + 0x8dc636e, + 0x8dce371, + 0x8dda373, + 0x8de6376, + 0x8df2379, + 0x8dfe37c, + 0x8e0a37f, + 0x8e16382, + 0x8e22385, + 0x8e2e388, + 0x8e3a38b, + 0x8e4638e, + 0x8e52391, + 0x8e5a394, + 0x8e66396, + 0x8e6e399, + 0x8e7a39b, + 0x8e8639e, + 0x8e923a1, + 0x8e9e3a4, + 0x8eaa3a7, + 0x8eb63aa, + 0x8ec23ad, + 0x8ece3b0, + 0x8ed23b3, + 0x8ede3b4, + 0x8efa3b7, + 0x8efe3be, + 0x8f0e3bf, + 0x8f323c3, + 0x8f363cc, + 0x8f7a3cd, + 0x8f823de, + 0x8f963e0, + 0x8fca3e5, + 0x8fea3f2, + 0x8fee3fa, + 0x8ff63fb, + 0x901a3fd, + 0x9032406, + 0x904a40c, + 0x9062412, + 0x908a418, + 0x909e422, + 0x90b6427, + 0x90ba42d, + 0x2910242e, + 0x9106440, + 0x9132441, + 0x914244c, + 0x9156450, +} + +// max children 654 (capacity 1023) +// max text offset 31758 (capacity 32767) +// max text length 36 (capacity 63) +// max hi 9301 (capacity 16383) +// max lo 9296 (capacity 16383) |