add package

diff --git a/vendor/github.com/gogo/protobuf/proto/Makefile b/vendor/github.com/gogo/protobuf/proto/Makefile
new file mode 100644 (file)
index 0000000..00d65f3
--- /dev/null
+++ b/vendor/github.com/gogo/protobuf/proto/Makefile
@@ -0,0 +1,43 @@
+# Go support for Protocol Buffers - Google's data interchange format
+#
+# Copyright 2010 The Go Authors.  All rights reserved.
+# https://github.com/golang/protobuf
+#
+# Redistribution and use in source and binary forms, with or without
+# modification, are permitted provided that the following conditions are
+# met:
+#
+#     * Redistributions of source code must retain the above copyright
+# notice, this list of conditions and the following disclaimer.
+#     * Redistributions in binary form must reproduce the above
+# copyright notice, this list of conditions and the following disclaimer
+# in the documentation and/or other materials provided with the
+# distribution.
+#     * Neither the name of Google Inc. nor the names of its
+# contributors may be used to endorse or promote products derived from
+# this software without specific prior written permission.
+#
+# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+# "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+# LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+# A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+# OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+# SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+# LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+# DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+# THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+# (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+# OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+install:
+       go install
+
+test: install generate-test-pbs
+       go test
+
+
+generate-test-pbs:
+       make install
+       make -C test_proto
+       make -C proto3_proto
+       make

diff --git a/vendor/github.com/gogo/protobuf/proto/all_test.go b/vendor/github.com/gogo/protobuf/proto/all_test.go
new file mode 100644 (file)
index 0000000..f391af7
--- /dev/null
+++ b/vendor/github.com/gogo/protobuf/proto/all_test.go
@@ -0,0 +1,2511 @@
+// Go support for Protocol Buffers - Google's data interchange format
+//
+// Copyright 2010 The Go Authors.  All rights reserved.
+// https://github.com/golang/protobuf
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//     * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//     * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//     * Neither the name of Google Inc. nor the names of its
+// contributors may be used to endorse or promote products derived from
+// this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+package proto_test
+
+import (
+       "bytes"
+       "encoding/json"
+       "errors"
+       "fmt"
+       "math"
+       "math/rand"
+       "reflect"
+       "runtime/debug"
+       "strings"
+       "sync"
+       "testing"
+       "time"
+
+       . "github.com/gogo/protobuf/proto"
+       pb3 "github.com/gogo/protobuf/proto/proto3_proto"
+       . "github.com/gogo/protobuf/proto/test_proto"
+)
+
+var globalO *Buffer
+
+func old() *Buffer {
+       if globalO == nil {
+               globalO = NewBuffer(nil)
+       }
+       globalO.Reset()
+       return globalO
+}
+
+func equalbytes(b1, b2 []byte, t *testing.T) {
+       if len(b1) != len(b2) {
+               t.Errorf("wrong lengths: 2*%d != %d", len(b1), len(b2))
+               return
+       }
+       for i := 0; i < len(b1); i++ {
+               if b1[i] != b2[i] {
+                       t.Errorf("bad byte[%d]:%x %x: %s %s", i, b1[i], b2[i], b1, b2)
+               }
+       }
+}
+
+func initGoTestField() *GoTestField {
+       f := new(GoTestField)
+       f.Label = String("label")
+       f.Type = String("type")
+       return f
+}
+
+// These are all structurally equivalent but the tag numbers differ.
+// (It's remarkable that required, optional, and repeated all have
+// 8 letters.)
+func initGoTest_RequiredGroup() *GoTest_RequiredGroup {
+       return &GoTest_RequiredGroup{
+               RequiredField: String("required"),
+       }
+}
+
+func initGoTest_OptionalGroup() *GoTest_OptionalGroup {
+       return &GoTest_OptionalGroup{
+               RequiredField: String("optional"),
+       }
+}
+
+func initGoTest_RepeatedGroup() *GoTest_RepeatedGroup {
+       return &GoTest_RepeatedGroup{
+               RequiredField: String("repeated"),
+       }
+}
+
+func initGoTest(setdefaults bool) *GoTest {
+       pb := new(GoTest)
+       if setdefaults {
+               pb.F_BoolDefaulted = Bool(Default_GoTest_F_BoolDefaulted)
+               pb.F_Int32Defaulted = Int32(Default_GoTest_F_Int32Defaulted)
+               pb.F_Int64Defaulted = Int64(Default_GoTest_F_Int64Defaulted)
+               pb.F_Fixed32Defaulted = Uint32(Default_GoTest_F_Fixed32Defaulted)
+               pb.F_Fixed64Defaulted = Uint64(Default_GoTest_F_Fixed64Defaulted)
+               pb.F_Uint32Defaulted = Uint32(Default_GoTest_F_Uint32Defaulted)
+               pb.F_Uint64Defaulted = Uint64(Default_GoTest_F_Uint64Defaulted)
+               pb.F_FloatDefaulted = Float32(Default_GoTest_F_FloatDefaulted)
+               pb.F_DoubleDefaulted = Float64(Default_GoTest_F_DoubleDefaulted)
+               pb.F_StringDefaulted = String(Default_GoTest_F_StringDefaulted)
+               pb.F_BytesDefaulted = Default_GoTest_F_BytesDefaulted
+               pb.F_Sint32Defaulted = Int32(Default_GoTest_F_Sint32Defaulted)
+               pb.F_Sint64Defaulted = Int64(Default_GoTest_F_Sint64Defaulted)
+               pb.F_Sfixed32Defaulted = Int32(Default_GoTest_F_Sfixed32Defaulted)
+               pb.F_Sfixed64Defaulted = Int64(Default_GoTest_F_Sfixed64Defaulted)
+       }
+
+       pb.Kind = GoTest_TIME.Enum()
+       pb.RequiredField = initGoTestField()
+       pb.F_BoolRequired = Bool(true)
+       pb.F_Int32Required = Int32(3)
+       pb.F_Int64Required = Int64(6)
+       pb.F_Fixed32Required = Uint32(32)
+       pb.F_Fixed64Required = Uint64(64)
+       pb.F_Uint32Required = Uint32(3232)
+       pb.F_Uint64Required = Uint64(6464)
+       pb.F_FloatRequired = Float32(3232)
+       pb.F_DoubleRequired = Float64(6464)
+       pb.F_StringRequired = String("string")
+       pb.F_BytesRequired = []byte("bytes")
+       pb.F_Sint32Required = Int32(-32)
+       pb.F_Sint64Required = Int64(-64)
+       pb.F_Sfixed32Required = Int32(-32)
+       pb.F_Sfixed64Required = Int64(-64)
+       pb.Requiredgroup = initGoTest_RequiredGroup()
+
+       return pb
+}
+
+func hex(c uint8) uint8 {
+       if '0' <= c && c <= '9' {
+               return c - '0'
+       }
+       if 'a' <= c && c <= 'f' {
+               return 10 + c - 'a'
+       }
+       if 'A' <= c && c <= 'F' {
+               return 10 + c - 'A'
+       }
+       return 0
+}
+
+func equal(b []byte, s string, t *testing.T) bool {
+       if 2*len(b) != len(s) {
+               //              fail(fmt.Sprintf("wrong lengths: 2*%d != %d", len(b), len(s)), b, s, t)
+               fmt.Printf("wrong lengths: 2*%d != %d\n", len(b), len(s))
+               return false
+       }
+       for i, j := 0, 0; i < len(b); i, j = i+1, j+2 {
+               x := hex(s[j])*16 + hex(s[j+1])
+               if b[i] != x {
+                       //                      fail(fmt.Sprintf("bad byte[%d]:%x %x", i, b[i], x), b, s, t)
+                       fmt.Printf("bad byte[%d]:%x %x", i, b[i], x)
+                       return false
+               }
+       }
+       return true
+}
+
+func overify(t *testing.T, pb *GoTest, expected string) {
+       o := old()
+       err := o.Marshal(pb)
+       if err != nil {
+               fmt.Printf("overify marshal-1 err = %v", err)
+               o.DebugPrint("", o.Bytes())
+               t.Fatalf("expected = %s", expected)
+       }
+       if !equal(o.Bytes(), expected, t) {
+               o.DebugPrint("overify neq 1", o.Bytes())
+               t.Fatalf("expected = %s", expected)
+       }
+
+       // Now test Unmarshal by recreating the original buffer.
+       pbd := new(GoTest)
+       err = o.Unmarshal(pbd)
+       if err != nil {
+               t.Fatalf("overify unmarshal err = %v", err)
+               o.DebugPrint("", o.Bytes())
+               t.Fatalf("string = %s", expected)
+       }
+       o.Reset()
+       err = o.Marshal(pbd)
+       if err != nil {
+               t.Errorf("overify marshal-2 err = %v", err)
+               o.DebugPrint("", o.Bytes())
+               t.Fatalf("string = %s", expected)
+       }
+       if !equal(o.Bytes(), expected, t) {
+               o.DebugPrint("overify neq 2", o.Bytes())
+               t.Fatalf("string = %s", expected)
+       }
+}
+
+// Simple tests for numeric encode/decode primitives (varint, etc.)
+func TestNumericPrimitives(t *testing.T) {
+       for i := uint64(0); i < 1e6; i += 111 {
+               o := old()
+               if o.EncodeVarint(i) != nil {
+                       t.Error("EncodeVarint")
+                       break
+               }
+               x, e := o.DecodeVarint()
+               if e != nil {
+                       t.Fatal("DecodeVarint")
+               }
+               if x != i {
+                       t.Fatal("varint decode fail:", i, x)
+               }
+
+               o = old()
+               if o.EncodeFixed32(i) != nil {
+                       t.Fatal("encFixed32")
+               }
+               x, e = o.DecodeFixed32()
+               if e != nil {
+                       t.Fatal("decFixed32")
+               }
+               if x != i {
+                       t.Fatal("fixed32 decode fail:", i, x)
+               }
+
+               o = old()
+               if o.EncodeFixed64(i*1234567) != nil {
+                       t.Error("encFixed64")
+                       break
+               }
+               x, e = o.DecodeFixed64()
+               if e != nil {
+                       t.Error("decFixed64")
+                       break
+               }
+               if x != i*1234567 {
+                       t.Error("fixed64 decode fail:", i*1234567, x)
+                       break
+               }
+
+               o = old()
+               i32 := int32(i - 12345)
+               if o.EncodeZigzag32(uint64(i32)) != nil {
+                       t.Fatal("EncodeZigzag32")
+               }
+               x, e = o.DecodeZigzag32()
+               if e != nil {
+                       t.Fatal("DecodeZigzag32")
+               }
+               if x != uint64(uint32(i32)) {
+                       t.Fatal("zigzag32 decode fail:", i32, x)
+               }
+
+               o = old()
+               i64 := int64(i - 12345)
+               if o.EncodeZigzag64(uint64(i64)) != nil {
+                       t.Fatal("EncodeZigzag64")
+               }
+               x, e = o.DecodeZigzag64()
+               if e != nil {
+                       t.Fatal("DecodeZigzag64")
+               }
+               if x != uint64(i64) {
+                       t.Fatal("zigzag64 decode fail:", i64, x)
+               }
+       }
+}
+
+// fakeMarshaler is a simple struct implementing Marshaler and Message interfaces.
+type fakeMarshaler struct {
+       b   []byte
+       err error
+}
+
+func (f *fakeMarshaler) Marshal() ([]byte, error) { return f.b, f.err }
+func (f *fakeMarshaler) String() string           { return fmt.Sprintf("Bytes: %v Error: %v", f.b, f.err) }
+func (f *fakeMarshaler) ProtoMessage()            {}
+func (f *fakeMarshaler) Reset()                   {}
+
+type msgWithFakeMarshaler struct {
+       M *fakeMarshaler `protobuf:"bytes,1,opt,name=fake"`
+}
+
+func (m *msgWithFakeMarshaler) String() string { return CompactTextString(m) }
+func (m *msgWithFakeMarshaler) ProtoMessage()  {}
+func (m *msgWithFakeMarshaler) Reset()         {}
+
+// Simple tests for proto messages that implement the Marshaler interface.
+func TestMarshalerEncoding(t *testing.T) {
+       tests := []struct {
+               name    string
+               m       Message
+               want    []byte
+               errType reflect.Type
+       }{
+               {
+                       name: "Marshaler that fails",
+                       m: &fakeMarshaler{
+                               err: errors.New("some marshal err"),
+                               b:   []byte{5, 6, 7},
+                       },
+                       // Since the Marshal method returned bytes, they should be written to the
+                       // buffer.  (For efficiency, we assume that Marshal implementations are
+                       // always correct w.r.t. RequiredNotSetError and output.)
+                       want:    []byte{5, 6, 7},
+                       errType: reflect.TypeOf(errors.New("some marshal err")),
+               },
+               {
+                       name: "Marshaler that fails with RequiredNotSetError",
+                       m: &msgWithFakeMarshaler{
+                               M: &fakeMarshaler{
+                                       err: &RequiredNotSetError{},
+                                       b:   []byte{5, 6, 7},
+                               },
+                       },
+                       // Since there's an error that can be continued after,
+                       // the buffer should be written.
+                       want: []byte{
+                               10, 3, // for &msgWithFakeMarshaler
+                               5, 6, 7, // for &fakeMarshaler
+                       },
+                       errType: reflect.TypeOf(&RequiredNotSetError{}),
+               },
+               {
+                       name: "Marshaler that succeeds",
+                       m: &fakeMarshaler{
+                               b: []byte{0, 1, 2, 3, 4, 127, 255},
+                       },
+                       want: []byte{0, 1, 2, 3, 4, 127, 255},
+               },
+       }
+       for _, test := range tests {
+               b := NewBuffer(nil)
+               err := b.Marshal(test.m)
+               if reflect.TypeOf(err) != test.errType {
+                       t.Errorf("%s: got err %T(%v) wanted %T", test.name, err, err, test.errType)
+               }
+               if !reflect.DeepEqual(test.want, b.Bytes()) {
+                       t.Errorf("%s: got bytes %v wanted %v", test.name, b.Bytes(), test.want)
+               }
+               if size := Size(test.m); size != len(b.Bytes()) {
+                       t.Errorf("%s: Size(_) = %v, but marshaled to %v bytes", test.name, size, len(b.Bytes()))
+               }
+
+               m, mErr := Marshal(test.m)
+               if !bytes.Equal(b.Bytes(), m) {
+                       t.Errorf("%s: Marshal returned %v, but (*Buffer).Marshal wrote %v", test.name, m, b.Bytes())
+               }
+               if !reflect.DeepEqual(err, mErr) {
+                       t.Errorf("%s: Marshal err = %q, but (*Buffer).Marshal returned %q",
+                               test.name, fmt.Sprint(mErr), fmt.Sprint(err))
+               }
+       }
+}
+
+// Ensure that Buffer.Marshal uses O(N) memory for N messages
+func TestBufferMarshalAllocs(t *testing.T) {
+       value := &OtherMessage{Key: Int64(1)}
+       msg := &MyMessage{Count: Int32(1), Others: []*OtherMessage{value}}
+
+       reallocSize := func(t *testing.T, items int, prealloc int) (int64, int64) {
+               var b Buffer
+               b.SetBuf(make([]byte, 0, prealloc))
+
+               var allocSpace int64
+               prevCap := cap(b.Bytes())
+               for i := 0; i < items; i++ {
+                       err := b.Marshal(msg)
+                       if err != nil {
+                               t.Errorf("Marshal err = %q", err)
+                               break
+                       }
+                       if c := cap(b.Bytes()); prevCap != c {
+                               allocSpace += int64(c)
+                               prevCap = c
+                       }
+               }
+               needSpace := int64(len(b.Bytes()))
+               return allocSpace, needSpace
+       }
+
+       for _, prealloc := range []int{0, 100, 10000} {
+               for _, items := range []int{1, 2, 5, 10, 20, 50, 100, 200, 500, 1000} {
+                       runtimeSpace, need := reallocSize(t, items, prealloc)
+                       totalSpace := int64(prealloc) + runtimeSpace
+
+                       runtimeRatio := float64(runtimeSpace) / float64(need)
+                       totalRatio := float64(totalSpace) / float64(need)
+
+                       if totalRatio < 1 || runtimeRatio > 4 {
+                               t.Errorf("needed %dB, allocated %dB total (ratio %.1f), allocated %dB at runtime (ratio %.1f)",
+                                       need, totalSpace, totalRatio, runtimeSpace, runtimeRatio)
+                       }
+               }
+       }
+}
+
+// Simple tests for bytes
+func TestBytesPrimitives(t *testing.T) {
+       o := old()
+       bytes := []byte{'n', 'o', 'w', ' ', 'i', 's', ' ', 't', 'h', 'e', ' ', 't', 'i', 'm', 'e'}
+       if o.EncodeRawBytes(bytes) != nil {
+               t.Error("EncodeRawBytes")
+       }
+       decb, e := o.DecodeRawBytes(false)
+       if e != nil {
+               t.Error("DecodeRawBytes")
+       }
+       equalbytes(bytes, decb, t)
+}
+
+// Simple tests for strings
+func TestStringPrimitives(t *testing.T) {
+       o := old()
+       s := "now is the time"
+       if o.EncodeStringBytes(s) != nil {
+               t.Error("enc_string")
+       }
+       decs, e := o.DecodeStringBytes()
+       if e != nil {
+               t.Error("dec_string")
+       }
+       if s != decs {
+               t.Error("string encode/decode fail:", s, decs)
+       }
+}
+
+// Do we catch the "required bit not set" case?
+func TestRequiredBit(t *testing.T) {
+       o := old()
+       pb := new(GoTest)
+       err := o.Marshal(pb)
+       if err == nil {
+               t.Error("did not catch missing required fields")
+       } else if !strings.Contains(err.Error(), "Kind") {
+               t.Error("wrong error type:", err)
+       }
+}
+
+// Check that all fields are nil.
+// Clearly silly, and a residue from a more interesting test with an earlier,
+// different initialization property, but it once caught a compiler bug so
+// it lives.
+func checkInitialized(pb *GoTest, t *testing.T) {
+       if pb.F_BoolDefaulted != nil {
+               t.Error("New or Reset did not set boolean:", *pb.F_BoolDefaulted)
+       }
+       if pb.F_Int32Defaulted != nil {
+               t.Error("New or Reset did not set int32:", *pb.F_Int32Defaulted)
+       }
+       if pb.F_Int64Defaulted != nil {
+               t.Error("New or Reset did not set int64:", *pb.F_Int64Defaulted)
+       }
+       if pb.F_Fixed32Defaulted != nil {
+               t.Error("New or Reset did not set fixed32:", *pb.F_Fixed32Defaulted)
+       }
+       if pb.F_Fixed64Defaulted != nil {
+               t.Error("New or Reset did not set fixed64:", *pb.F_Fixed64Defaulted)
+       }
+       if pb.F_Uint32Defaulted != nil {
+               t.Error("New or Reset did not set uint32:", *pb.F_Uint32Defaulted)
+       }
+       if pb.F_Uint64Defaulted != nil {
+               t.Error("New or Reset did not set uint64:", *pb.F_Uint64Defaulted)
+       }
+       if pb.F_FloatDefaulted != nil {
+               t.Error("New or Reset did not set float:", *pb.F_FloatDefaulted)
+       }
+       if pb.F_DoubleDefaulted != nil {
+               t.Error("New or Reset did not set double:", *pb.F_DoubleDefaulted)
+       }
+       if pb.F_StringDefaulted != nil {
+               t.Error("New or Reset did not set string:", *pb.F_StringDefaulted)
+       }
+       if pb.F_BytesDefaulted != nil {
+               t.Error("New or Reset did not set bytes:", string(pb.F_BytesDefaulted))
+       }
+       if pb.F_Sint32Defaulted != nil {
+               t.Error("New or Reset did not set int32:", *pb.F_Sint32Defaulted)
+       }
+       if pb.F_Sint64Defaulted != nil {
+               t.Error("New or Reset did not set int64:", *pb.F_Sint64Defaulted)
+       }
+}
+
+// Does Reset() reset?
+func TestReset(t *testing.T) {
+       pb := initGoTest(true)
+       // muck with some values
+       pb.F_BoolDefaulted = Bool(false)
+       pb.F_Int32Defaulted = Int32(237)
+       pb.F_Int64Defaulted = Int64(12346)
+       pb.F_Fixed32Defaulted = Uint32(32000)
+       pb.F_Fixed64Defaulted = Uint64(666)
+       pb.F_Uint32Defaulted = Uint32(323232)
+       pb.F_Uint64Defaulted = nil
+       pb.F_FloatDefaulted = nil
+       pb.F_DoubleDefaulted = Float64(0)
+       pb.F_StringDefaulted = String("gotcha")
+       pb.F_BytesDefaulted = []byte("asdfasdf")
+       pb.F_Sint32Defaulted = Int32(123)
+       pb.F_Sint64Defaulted = Int64(789)
+       pb.Reset()
+       checkInitialized(pb, t)
+}
+
+// All required fields set, no defaults provided.
+func TestEncodeDecode1(t *testing.T) {
+       pb := initGoTest(false)
+       overify(t, pb,
+               "0807"+ // field 1, encoding 0, value 7
+                       "220d"+"0a056c6162656c120474797065"+ // field 4, encoding 2 (GoTestField)
+                       "5001"+ // field 10, encoding 0, value 1
+                       "5803"+ // field 11, encoding 0, value 3
+                       "6006"+ // field 12, encoding 0, value 6
+                       "6d20000000"+ // field 13, encoding 5, value 0x20
+                       "714000000000000000"+ // field 14, encoding 1, value 0x40
+                       "78a019"+ // field 15, encoding 0, value 0xca0 = 3232
+                       "8001c032"+ // field 16, encoding 0, value 0x1940 = 6464
+                       "8d0100004a45"+ // field 17, encoding 5, value 3232.0
+                       "9101000000000040b940"+ // field 18, encoding 1, value 6464.0
+                       "9a0106"+"737472696e67"+ // field 19, encoding 2, string "string"
+                       "b304"+ // field 70, encoding 3, start group
+                       "ba0408"+"7265717569726564"+ // field 71, encoding 2, string "required"
+                       "b404"+ // field 70, encoding 4, end group
+                       "aa0605"+"6279746573"+ // field 101, encoding 2, string "bytes"
+                       "b0063f"+ // field 102, encoding 0, 0x3f zigzag32
+                       "b8067f"+ // field 103, encoding 0, 0x7f zigzag64
+                       "c506e0ffffff"+ // field 104, encoding 5, -32 fixed32
+                       "c906c0ffffffffffffff") // field 105, encoding 1, -64 fixed64
+}
+
+// All required fields set, defaults provided.
+func TestEncodeDecode2(t *testing.T) {
+       pb := initGoTest(true)
+       overify(t, pb,
+               "0807"+ // field 1, encoding 0, value 7
+                       "220d"+"0a056c6162656c120474797065"+ // field 4, encoding 2 (GoTestField)
+                       "5001"+ // field 10, encoding 0, value 1
+                       "5803"+ // field 11, encoding 0, value 3
+                       "6006"+ // field 12, encoding 0, value 6
+                       "6d20000000"+ // field 13, encoding 5, value 32
+                       "714000000000000000"+ // field 14, encoding 1, value 64
+                       "78a019"+ // field 15, encoding 0, value 3232
+                       "8001c032"+ // field 16, encoding 0, value 6464
+                       "8d0100004a45"+ // field 17, encoding 5, value 3232.0
+                       "9101000000000040b940"+ // field 18, encoding 1, value 6464.0
+                       "9a0106"+"737472696e67"+ // field 19, encoding 2 string "string"
+                       "c00201"+ // field 40, encoding 0, value 1
+                       "c80220"+ // field 41, encoding 0, value 32
+                       "d00240"+ // field 42, encoding 0, value 64
+                       "dd0240010000"+ // field 43, encoding 5, value 320
+                       "e1028002000000000000"+ // field 44, encoding 1, value 640
+                       "e8028019"+ // field 45, encoding 0, value 3200
+                       "f0028032"+ // field 46, encoding 0, value 6400
+                       "fd02e0659948"+ // field 47, encoding 5, value 314159.0
+                       "81030000000050971041"+ // field 48, encoding 1, value 271828.0
+                       "8a0310"+"68656c6c6f2c2022776f726c6421220a"+ // field 49, encoding 2 string "hello, \"world!\"\n"
+                       "b304"+ // start group field 70 level 1
+                       "ba0408"+"7265717569726564"+ // field 71, encoding 2, string "required"
+                       "b404"+ // end group field 70 level 1
+                       "aa0605"+"6279746573"+ // field 101, encoding 2 string "bytes"
+                       "b0063f"+ // field 102, encoding 0, 0x3f zigzag32
+                       "b8067f"+ // field 103, encoding 0, 0x7f zigzag64
+                       "c506e0ffffff"+ // field 104, encoding 5, -32 fixed32
+                       "c906c0ffffffffffffff"+ // field 105, encoding 1, -64 fixed64
+                       "8a1907"+"4269676e6f7365"+ // field 401, encoding 2, string "Bignose"
+                       "90193f"+ // field 402, encoding 0, value 63
+                       "98197f"+ // field 403, encoding 0, value 127
+                       "a519e0ffffff"+ // field 404, encoding 5, -32 fixed32
+                       "a919c0ffffffffffffff") // field 405, encoding 1, -64 fixed64
+
+}
+
+// All default fields set to their default value by hand
+func TestEncodeDecode3(t *testing.T) {
+       pb := initGoTest(false)
+       pb.F_BoolDefaulted = Bool(true)
+       pb.F_Int32Defaulted = Int32(32)
+       pb.F_Int64Defaulted = Int64(64)
+       pb.F_Fixed32Defaulted = Uint32(320)
+       pb.F_Fixed64Defaulted = Uint64(640)
+       pb.F_Uint32Defaulted = Uint32(3200)
+       pb.F_Uint64Defaulted = Uint64(6400)
+       pb.F_FloatDefaulted = Float32(314159)
+       pb.F_DoubleDefaulted = Float64(271828)
+       pb.F_StringDefaulted = String("hello, \"world!\"\n")
+       pb.F_BytesDefaulted = []byte("Bignose")
+       pb.F_Sint32Defaulted = Int32(-32)
+       pb.F_Sint64Defaulted = Int64(-64)
+       pb.F_Sfixed32Defaulted = Int32(-32)
+       pb.F_Sfixed64Defaulted = Int64(-64)
+
+       overify(t, pb,
+               "0807"+ // field 1, encoding 0, value 7
+                       "220d"+"0a056c6162656c120474797065"+ // field 4, encoding 2 (GoTestField)
+                       "5001"+ // field 10, encoding 0, value 1
+                       "5803"+ // field 11, encoding 0, value 3
+                       "6006"+ // field 12, encoding 0, value 6
+                       "6d20000000"+ // field 13, encoding 5, value 32
+                       "714000000000000000"+ // field 14, encoding 1, value 64
+                       "78a019"+ // field 15, encoding 0, value 3232
+                       "8001c032"+ // field 16, encoding 0, value 6464
+                       "8d0100004a45"+ // field 17, encoding 5, value 3232.0
+                       "9101000000000040b940"+ // field 18, encoding 1, value 6464.0
+                       "9a0106"+"737472696e67"+ // field 19, encoding 2 string "string"
+                       "c00201"+ // field 40, encoding 0, value 1
+                       "c80220"+ // field 41, encoding 0, value 32
+                       "d00240"+ // field 42, encoding 0, value 64
+                       "dd0240010000"+ // field 43, encoding 5, value 320
+                       "e1028002000000000000"+ // field 44, encoding 1, value 640
+                       "e8028019"+ // field 45, encoding 0, value 3200
+                       "f0028032"+ // field 46, encoding 0, value 6400
+                       "fd02e0659948"+ // field 47, encoding 5, value 314159.0
+                       "81030000000050971041"+ // field 48, encoding 1, value 271828.0
+                       "8a0310"+"68656c6c6f2c2022776f726c6421220a"+ // field 49, encoding 2 string "hello, \"world!\"\n"
+                       "b304"+ // start group field 70 level 1
+                       "ba0408"+"7265717569726564"+ // field 71, encoding 2, string "required"
+                       "b404"+ // end group field 70 level 1
+                       "aa0605"+"6279746573"+ // field 101, encoding 2 string "bytes"
+                       "b0063f"+ // field 102, encoding 0, 0x3f zigzag32
+                       "b8067f"+ // field 103, encoding 0, 0x7f zigzag64
+                       "c506e0ffffff"+ // field 104, encoding 5, -32 fixed32
+                       "c906c0ffffffffffffff"+ // field 105, encoding 1, -64 fixed64
+                       "8a1907"+"4269676e6f7365"+ // field 401, encoding 2, string "Bignose"
+                       "90193f"+ // field 402, encoding 0, value 63
+                       "98197f"+ // field 403, encoding 0, value 127
+                       "a519e0ffffff"+ // field 404, encoding 5, -32 fixed32
+                       "a919c0ffffffffffffff") // field 405, encoding 1, -64 fixed64
+
+}
+
+// All required fields set, defaults provided, all non-defaulted optional fields have values.
+func TestEncodeDecode4(t *testing.T) {
+       pb := initGoTest(true)
+       pb.Table = String("hello")
+       pb.Param = Int32(7)
+       pb.OptionalField = initGoTestField()
+       pb.F_BoolOptional = Bool(true)
+       pb.F_Int32Optional = Int32(32)
+       pb.F_Int64Optional = Int64(64)
+       pb.F_Fixed32Optional = Uint32(3232)
+       pb.F_Fixed64Optional = Uint64(6464)
+       pb.F_Uint32Optional = Uint32(323232)
+       pb.F_Uint64Optional = Uint64(646464)
+       pb.F_FloatOptional = Float32(32.)
+       pb.F_DoubleOptional = Float64(64.)
+       pb.F_StringOptional = String("hello")
+       pb.F_BytesOptional = []byte("Bignose")
+       pb.F_Sint32Optional = Int32(-32)
+       pb.F_Sint64Optional = Int64(-64)
+       pb.F_Sfixed32Optional = Int32(-32)
+       pb.F_Sfixed64Optional = Int64(-64)
+       pb.Optionalgroup = initGoTest_OptionalGroup()
+
+       overify(t, pb,
+               "0807"+ // field 1, encoding 0, value 7
+                       "1205"+"68656c6c6f"+ // field 2, encoding 2, string "hello"
+                       "1807"+ // field 3, encoding 0, value 7
+                       "220d"+"0a056c6162656c120474797065"+ // field 4, encoding 2 (GoTestField)
+                       "320d"+"0a056c6162656c120474797065"+ // field 6, encoding 2 (GoTestField)
+                       "5001"+ // field 10, encoding 0, value 1
+                       "5803"+ // field 11, encoding 0, value 3
+                       "6006"+ // field 12, encoding 0, value 6
+                       "6d20000000"+ // field 13, encoding 5, value 32
+                       "714000000000000000"+ // field 14, encoding 1, value 64
+                       "78a019"+ // field 15, encoding 0, value 3232
+                       "8001c032"+ // field 16, encoding 0, value 6464
+                       "8d0100004a45"+ // field 17, encoding 5, value 3232.0
+                       "9101000000000040b940"+ // field 18, encoding 1, value 6464.0
+                       "9a0106"+"737472696e67"+ // field 19, encoding 2 string "string"
+                       "f00101"+ // field 30, encoding 0, value 1
+                       "f80120"+ // field 31, encoding 0, value 32
+                       "800240"+ // field 32, encoding 0, value 64
+                       "8d02a00c0000"+ // field 33, encoding 5, value 3232
+                       "91024019000000000000"+ // field 34, encoding 1, value 6464
+                       "9802a0dd13"+ // field 35, encoding 0, value 323232
+                       "a002c0ba27"+ // field 36, encoding 0, value 646464
+                       "ad0200000042"+ // field 37, encoding 5, value 32.0
+                       "b1020000000000005040"+ // field 38, encoding 1, value 64.0
+                       "ba0205"+"68656c6c6f"+ // field 39, encoding 2, string "hello"
+                       "c00201"+ // field 40, encoding 0, value 1
+                       "c80220"+ // field 41, encoding 0, value 32
+                       "d00240"+ // field 42, encoding 0, value 64
+                       "dd0240010000"+ // field 43, encoding 5, value 320
+                       "e1028002000000000000"+ // field 44, encoding 1, value 640
+                       "e8028019"+ // field 45, encoding 0, value 3200
+                       "f0028032"+ // field 46, encoding 0, value 6400
+                       "fd02e0659948"+ // field 47, encoding 5, value 314159.0
+                       "81030000000050971041"+ // field 48, encoding 1, value 271828.0
+                       "8a0310"+"68656c6c6f2c2022776f726c6421220a"+ // field 49, encoding 2 string "hello, \"world!\"\n"
+                       "b304"+ // start group field 70 level 1
+                       "ba0408"+"7265717569726564"+ // field 71, encoding 2, string "required"
+                       "b404"+ // end group field 70 level 1
+                       "d305"+ // start group field 90 level 1
+                       "da0508"+"6f7074696f6e616c"+ // field 91, encoding 2, string "optional"
+                       "d405"+ // end group field 90 level 1
+                       "aa0605"+"6279746573"+ // field 101, encoding 2 string "bytes"
+                       "b0063f"+ // field 102, encoding 0, 0x3f zigzag32
+                       "b8067f"+ // field 103, encoding 0, 0x7f zigzag64
+                       "c506e0ffffff"+ // field 104, encoding 5, -32 fixed32
+                       "c906c0ffffffffffffff"+ // field 105, encoding 1, -64 fixed64
+                       "ea1207"+"4269676e6f7365"+ // field 301, encoding 2, string "Bignose"
+                       "f0123f"+ // field 302, encoding 0, value 63
+                       "f8127f"+ // field 303, encoding 0, value 127
+                       "8513e0ffffff"+ // field 304, encoding 5, -32 fixed32
+                       "8913c0ffffffffffffff"+ // field 305, encoding 1, -64 fixed64
+                       "8a1907"+"4269676e6f7365"+ // field 401, encoding 2, string "Bignose"
+                       "90193f"+ // field 402, encoding 0, value 63
+                       "98197f"+ // field 403, encoding 0, value 127
+                       "a519e0ffffff"+ // field 404, encoding 5, -32 fixed32
+                       "a919c0ffffffffffffff") // field 405, encoding 1, -64 fixed64
+
+}
+
+// All required fields set, defaults provided, all repeated fields given two values.
+func TestEncodeDecode5(t *testing.T) {
+       pb := initGoTest(true)
+       pb.RepeatedField = []*GoTestField{initGoTestField(), initGoTestField()}
+       pb.F_BoolRepeated = []bool{false, true}
+       pb.F_Int32Repeated = []int32{32, 33}
+       pb.F_Int64Repeated = []int64{64, 65}
+       pb.F_Fixed32Repeated = []uint32{3232, 3333}
+       pb.F_Fixed64Repeated = []uint64{6464, 6565}
+       pb.F_Uint32Repeated = []uint32{323232, 333333}
+       pb.F_Uint64Repeated = []uint64{646464, 656565}
+       pb.F_FloatRepeated = []float32{32., 33.}
+       pb.F_DoubleRepeated = []float64{64., 65.}
+       pb.F_StringRepeated = []string{"hello", "sailor"}
+       pb.F_BytesRepeated = [][]byte{[]byte("big"), []byte("nose")}
+       pb.F_Sint32Repeated = []int32{32, -32}
+       pb.F_Sint64Repeated = []int64{64, -64}
+       pb.F_Sfixed32Repeated = []int32{32, -32}
+       pb.F_Sfixed64Repeated = []int64{64, -64}
+       pb.Repeatedgroup = []*GoTest_RepeatedGroup{initGoTest_RepeatedGroup(), initGoTest_RepeatedGroup()}
+
+       overify(t, pb,
+               "0807"+ // field 1, encoding 0, value 7
+                       "220d"+"0a056c6162656c120474797065"+ // field 4, encoding 2 (GoTestField)
+                       "2a0d"+"0a056c6162656c120474797065"+ // field 5, encoding 2 (GoTestField)
+                       "2a0d"+"0a056c6162656c120474797065"+ // field 5, encoding 2 (GoTestField)
+                       "5001"+ // field 10, encoding 0, value 1
+                       "5803"+ // field 11, encoding 0, value 3
+                       "6006"+ // field 12, encoding 0, value 6
+                       "6d20000000"+ // field 13, encoding 5, value 32
+                       "714000000000000000"+ // field 14, encoding 1, value 64
+                       "78a019"+ // field 15, encoding 0, value 3232
+                       "8001c032"+ // field 16, encoding 0, value 6464
+                       "8d0100004a45"+ // field 17, encoding 5, value 3232.0
+                       "9101000000000040b940"+ // field 18, encoding 1, value 6464.0
+                       "9a0106"+"737472696e67"+ // field 19, encoding 2 string "string"
+                       "a00100"+ // field 20, encoding 0, value 0
+                       "a00101"+ // field 20, encoding 0, value 1
+                       "a80120"+ // field 21, encoding 0, value 32
+                       "a80121"+ // field 21, encoding 0, value 33
+                       "b00140"+ // field 22, encoding 0, value 64
+                       "b00141"+ // field 22, encoding 0, value 65
+                       "bd01a00c0000"+ // field 23, encoding 5, value 3232
+                       "bd01050d0000"+ // field 23, encoding 5, value 3333
+                       "c1014019000000000000"+ // field 24, encoding 1, value 6464
+                       "c101a519000000000000"+ // field 24, encoding 1, value 6565
+                       "c801a0dd13"+ // field 25, encoding 0, value 323232
+                       "c80195ac14"+ // field 25, encoding 0, value 333333
+                       "d001c0ba27"+ // field 26, encoding 0, value 646464
+                       "d001b58928"+ // field 26, encoding 0, value 656565
+                       "dd0100000042"+ // field 27, encoding 5, value 32.0
+                       "dd0100000442"+ // field 27, encoding 5, value 33.0
+                       "e1010000000000005040"+ // field 28, encoding 1, value 64.0
+                       "e1010000000000405040"+ // field 28, encoding 1, value 65.0
+                       "ea0105"+"68656c6c6f"+ // field 29, encoding 2, string "hello"
+                       "ea0106"+"7361696c6f72"+ // field 29, encoding 2, string "sailor"
+                       "c00201"+ // field 40, encoding 0, value 1
+                       "c80220"+ // field 41, encoding 0, value 32
+                       "d00240"+ // field 42, encoding 0, value 64
+                       "dd0240010000"+ // field 43, encoding 5, value 320
+                       "e1028002000000000000"+ // field 44, encoding 1, value 640
+                       "e8028019"+ // field 45, encoding 0, value 3200
+                       "f0028032"+ // field 46, encoding 0, value 6400
+                       "fd02e0659948"+ // field 47, encoding 5, value 314159.0
+                       "81030000000050971041"+ // field 48, encoding 1, value 271828.0
+                       "8a0310"+"68656c6c6f2c2022776f726c6421220a"+ // field 49, encoding 2 string "hello, \"world!\"\n"
+                       "b304"+ // start group field 70 level 1
+                       "ba0408"+"7265717569726564"+ // field 71, encoding 2, string "required"
+                       "b404"+ // end group field 70 level 1
+                       "8305"+ // start group field 80 level 1
+                       "8a0508"+"7265706561746564"+ // field 81, encoding 2, string "repeated"
+                       "8405"+ // end group field 80 level 1
+                       "8305"+ // start group field 80 level 1
+                       "8a0508"+"7265706561746564"+ // field 81, encoding 2, string "repeated"
+                       "8405"+ // end group field 80 level 1
+                       "aa0605"+"6279746573"+ // field 101, encoding 2 string "bytes"
+                       "b0063f"+ // field 102, encoding 0, 0x3f zigzag32
+                       "b8067f"+ // field 103, encoding 0, 0x7f zigzag64
+                       "c506e0ffffff"+ // field 104, encoding 5, -32 fixed32
+                       "c906c0ffffffffffffff"+ // field 105, encoding 1, -64 fixed64
+                       "ca0c03"+"626967"+ // field 201, encoding 2, string "big"
+                       "ca0c04"+"6e6f7365"+ // field 201, encoding 2, string "nose"
+                       "d00c40"+ // field 202, encoding 0, value 32
+                       "d00c3f"+ // field 202, encoding 0, value -32
+                       "d80c8001"+ // field 203, encoding 0, value 64
+                       "d80c7f"+ // field 203, encoding 0, value -64
+                       "e50c20000000"+ // field 204, encoding 5, 32 fixed32
+                       "e50ce0ffffff"+ // field 204, encoding 5, -32 fixed32
+                       "e90c4000000000000000"+ // field 205, encoding 1, 64 fixed64
+                       "e90cc0ffffffffffffff"+ // field 205, encoding 1, -64 fixed64
+                       "8a1907"+"4269676e6f7365"+ // field 401, encoding 2, string "Bignose"
+                       "90193f"+ // field 402, encoding 0, value 63
+                       "98197f"+ // field 403, encoding 0, value 127
+                       "a519e0ffffff"+ // field 404, encoding 5, -32 fixed32
+                       "a919c0ffffffffffffff") // field 405, encoding 1, -64 fixed64
+
+}
+
+// All required fields set, all packed repeated fields given two values.
+func TestEncodeDecode6(t *testing.T) {
+       pb := initGoTest(false)
+       pb.F_BoolRepeatedPacked = []bool{false, true}
+       pb.F_Int32RepeatedPacked = []int32{32, 33}
+       pb.F_Int64RepeatedPacked = []int64{64, 65}
+       pb.F_Fixed32RepeatedPacked = []uint32{3232, 3333}
+       pb.F_Fixed64RepeatedPacked = []uint64{6464, 6565}
+       pb.F_Uint32RepeatedPacked = []uint32{323232, 333333}
+       pb.F_Uint64RepeatedPacked = []uint64{646464, 656565}
+       pb.F_FloatRepeatedPacked = []float32{32., 33.}
+       pb.F_DoubleRepeatedPacked = []float64{64., 65.}
+       pb.F_Sint32RepeatedPacked = []int32{32, -32}
+       pb.F_Sint64RepeatedPacked = []int64{64, -64}
+       pb.F_Sfixed32RepeatedPacked = []int32{32, -32}
+       pb.F_Sfixed64RepeatedPacked = []int64{64, -64}
+
+       overify(t, pb,
+               "0807"+ // field 1, encoding 0, value 7
+                       "220d"+"0a056c6162656c120474797065"+ // field 4, encoding 2 (GoTestField)
+                       "5001"+ // field 10, encoding 0, value 1
+                       "5803"+ // field 11, encoding 0, value 3
+                       "6006"+ // field 12, encoding 0, value 6
+                       "6d20000000"+ // field 13, encoding 5, value 32
+                       "714000000000000000"+ // field 14, encoding 1, value 64
+                       "78a019"+ // field 15, encoding 0, value 3232
+                       "8001c032"+ // field 16, encoding 0, value 6464
+                       "8d0100004a45"+ // field 17, encoding 5, value 3232.0
+                       "9101000000000040b940"+ // field 18, encoding 1, value 6464.0
+                       "9a0106"+"737472696e67"+ // field 19, encoding 2 string "string"
+                       "9203020001"+ // field 50, encoding 2, 2 bytes, value 0, value 1
+                       "9a03022021"+ // field 51, encoding 2, 2 bytes, value 32, value 33
+                       "a203024041"+ // field 52, encoding 2, 2 bytes, value 64, value 65
+                       "aa0308"+ // field 53, encoding 2, 8 bytes
+                       "a00c0000050d0000"+ // value 3232, value 3333
+                       "b20310"+ // field 54, encoding 2, 16 bytes
+                       "4019000000000000a519000000000000"+ // value 6464, value 6565
+                       "ba0306"+ // field 55, encoding 2, 6 bytes
+                       "a0dd1395ac14"+ // value 323232, value 333333
+                       "c20306"+ // field 56, encoding 2, 6 bytes
+                       "c0ba27b58928"+ // value 646464, value 656565
+                       "ca0308"+ // field 57, encoding 2, 8 bytes
+                       "0000004200000442"+ // value 32.0, value 33.0
+                       "d20310"+ // field 58, encoding 2, 16 bytes
+                       "00000000000050400000000000405040"+ // value 64.0, value 65.0
+                       "b304"+ // start group field 70 level 1
+                       "ba0408"+"7265717569726564"+ // field 71, encoding 2, string "required"
+                       "b404"+ // end group field 70 level 1
+                       "aa0605"+"6279746573"+ // field 101, encoding 2 string "bytes"
+                       "b0063f"+ // field 102, encoding 0, 0x3f zigzag32
+                       "b8067f"+ // field 103, encoding 0, 0x7f zigzag64
+                       "c506e0ffffff"+ // field 104, encoding 5, -32 fixed32
+                       "c906c0ffffffffffffff"+ // field 105, encoding 1, -64 fixed64
+                       "b21f02"+ // field 502, encoding 2, 2 bytes
+                       "403f"+ // value 32, value -32
+                       "ba1f03"+ // field 503, encoding 2, 3 bytes
+                       "80017f"+ // value 64, value -64
+                       "c21f08"+ // field 504, encoding 2, 8 bytes
+                       "20000000e0ffffff"+ // value 32, value -32
+                       "ca1f10"+ // field 505, encoding 2, 16 bytes
+                       "4000000000000000c0ffffffffffffff") // value 64, value -64
+
+}
+
+// Test that we can encode empty bytes fields.
+func TestEncodeDecodeBytes1(t *testing.T) {
+       pb := initGoTest(false)
+
+       // Create our bytes
+       pb.F_BytesRequired = []byte{}
+       pb.F_BytesRepeated = [][]byte{{}}
+       pb.F_BytesOptional = []byte{}
+
+       d, err := Marshal(pb)
+       if err != nil {
+               t.Error(err)
+       }
+
+       pbd := new(GoTest)
+       if err := Unmarshal(d, pbd); err != nil {
+               t.Error(err)
+       }
+
+       if pbd.F_BytesRequired == nil || len(pbd.F_BytesRequired) != 0 {
+               t.Error("required empty bytes field is incorrect")
+       }
+       if pbd.F_BytesRepeated == nil || len(pbd.F_BytesRepeated) == 1 && pbd.F_BytesRepeated[0] == nil {
+               t.Error("repeated empty bytes field is incorrect")
+       }
+       if pbd.F_BytesOptional == nil || len(pbd.F_BytesOptional) != 0 {
+               t.Error("optional empty bytes field is incorrect")
+       }
+}
+
+// Test that we encode nil-valued fields of a repeated bytes field correctly.
+// Since entries in a repeated field cannot be nil, nil must mean empty value.
+func TestEncodeDecodeBytes2(t *testing.T) {
+       pb := initGoTest(false)
+
+       // Create our bytes
+       pb.F_BytesRepeated = [][]byte{nil}
+
+       d, err := Marshal(pb)
+       if err != nil {
+               t.Error(err)
+       }
+
+       pbd := new(GoTest)
+       if err := Unmarshal(d, pbd); err != nil {
+               t.Error(err)
+       }
+
+       if len(pbd.F_BytesRepeated) != 1 || pbd.F_BytesRepeated[0] == nil {
+               t.Error("Unexpected value for repeated bytes field")
+       }
+}
+
+// All required fields set, defaults provided, all repeated fields given two values.
+func TestSkippingUnrecognizedFields(t *testing.T) {
+       o := old()
+       pb := initGoTestField()
+
+       // Marshal it normally.
+       o.Marshal(pb)
+
+       // Now new a GoSkipTest record.
+       skip := &GoSkipTest{
+               SkipInt32:   Int32(32),
+               SkipFixed32: Uint32(3232),
+               SkipFixed64: Uint64(6464),
+               SkipString:  String("skipper"),
+               Skipgroup: &GoSkipTest_SkipGroup{
+                       GroupInt32:  Int32(75),
+                       GroupString: String("wxyz"),
+               },
+       }
+
+       // Marshal it into same buffer.
+       o.Marshal(skip)
+
+       pbd := new(GoTestField)
+       o.Unmarshal(pbd)
+
+       // The __unrecognized field should be a marshaling of GoSkipTest
+       skipd := new(GoSkipTest)
+
+       o.SetBuf(pbd.XXX_unrecognized)
+       o.Unmarshal(skipd)
+
+       if *skipd.SkipInt32 != *skip.SkipInt32 {
+               t.Error("skip int32", skipd.SkipInt32)
+       }
+       if *skipd.SkipFixed32 != *skip.SkipFixed32 {
+               t.Error("skip fixed32", skipd.SkipFixed32)
+       }
+       if *skipd.SkipFixed64 != *skip.SkipFixed64 {
+               t.Error("skip fixed64", skipd.SkipFixed64)
+       }
+       if *skipd.SkipString != *skip.SkipString {
+               t.Error("skip string", *skipd.SkipString)
+       }
+       if *skipd.Skipgroup.GroupInt32 != *skip.Skipgroup.GroupInt32 {
+               t.Error("skip group int32", skipd.Skipgroup.GroupInt32)
+       }
+       if *skipd.Skipgroup.GroupString != *skip.Skipgroup.GroupString {
+               t.Error("skip group string", *skipd.Skipgroup.GroupString)
+       }
+}
+
+// Check that unrecognized fields of a submessage are preserved.
+func TestSubmessageUnrecognizedFields(t *testing.T) {
+       nm := &NewMessage{
+               Nested: &NewMessage_Nested{
+                       Name:      String("Nigel"),
+                       FoodGroup: String("carbs"),
+               },
+       }
+       b, err := Marshal(nm)
+       if err != nil {
+               t.Fatalf("Marshal of NewMessage: %v", err)
+       }
+
+       // Unmarshal into an OldMessage.
+       om := new(OldMessage)
+       if err = Unmarshal(b, om); err != nil {
+               t.Fatalf("Unmarshal to OldMessage: %v", err)
+       }
+       exp := &OldMessage{
+               Nested: &OldMessage_Nested{
+                       Name: String("Nigel"),
+                       // normal protocol buffer users should not do this
+                       XXX_unrecognized: []byte("\x12\x05carbs"),
+               },
+       }
+       if !Equal(om, exp) {
+               t.Errorf("om = %v, want %v", om, exp)
+       }
+
+       // Clone the OldMessage.
+       om = Clone(om).(*OldMessage)
+       if !Equal(om, exp) {
+               t.Errorf("Clone(om) = %v, want %v", om, exp)
+       }
+
+       // Marshal the OldMessage, then unmarshal it into an empty NewMessage.
+       if b, err = Marshal(om); err != nil {
+               t.Fatalf("Marshal of OldMessage: %v", err)
+       }
+       t.Logf("Marshal(%v) -> %q", om, b)
+       nm2 := new(NewMessage)
+       if err := Unmarshal(b, nm2); err != nil {
+               t.Fatalf("Unmarshal to NewMessage: %v", err)
+       }
+       if !Equal(nm, nm2) {
+               t.Errorf("NewMessage round-trip: %v => %v", nm, nm2)
+       }
+}
+
+// Check that an int32 field can be upgraded to an int64 field.
+func TestNegativeInt32(t *testing.T) {
+       om := &OldMessage{
+               Num: Int32(-1),
+       }
+       b, err := Marshal(om)
+       if err != nil {
+               t.Fatalf("Marshal of OldMessage: %v", err)
+       }
+
+       // Check the size. It should be 11 bytes;
+       // 1 for the field/wire type, and 10 for the negative number.
+       if len(b) != 11 {
+               t.Errorf("%v marshaled as %q, wanted 11 bytes", om, b)
+       }
+
+       // Unmarshal into a NewMessage.
+       nm := new(NewMessage)
+       if err := Unmarshal(b, nm); err != nil {
+               t.Fatalf("Unmarshal to NewMessage: %v", err)
+       }
+       want := &NewMessage{
+               Num: Int64(-1),
+       }
+       if !Equal(nm, want) {
+               t.Errorf("nm = %v, want %v", nm, want)
+       }
+}
+
+// Check that we can grow an array (repeated field) to have many elements.
+// This test doesn't depend only on our encoding; for variety, it makes sure
+// we create, encode, and decode the correct contents explicitly.  It's therefore
+// a bit messier.
+// This test also uses (and hence tests) the Marshal/Unmarshal functions
+// instead of the methods.
+func TestBigRepeated(t *testing.T) {
+       pb := initGoTest(true)
+
+       // Create the arrays
+       const N = 50 // Internally the library starts much smaller.
+       pb.Repeatedgroup = make([]*GoTest_RepeatedGroup, N)
+       pb.F_Sint64Repeated = make([]int64, N)
+       pb.F_Sint32Repeated = make([]int32, N)
+       pb.F_BytesRepeated = make([][]byte, N)
+       pb.F_StringRepeated = make([]string, N)
+       pb.F_DoubleRepeated = make([]float64, N)
+       pb.F_FloatRepeated = make([]float32, N)
+       pb.F_Uint64Repeated = make([]uint64, N)
+       pb.F_Uint32Repeated = make([]uint32, N)
+       pb.F_Fixed64Repeated = make([]uint64, N)
+       pb.F_Fixed32Repeated = make([]uint32, N)
+       pb.F_Int64Repeated = make([]int64, N)
+       pb.F_Int32Repeated = make([]int32, N)
+       pb.F_BoolRepeated = make([]bool, N)
+       pb.RepeatedField = make([]*GoTestField, N)
+
+       // Fill in the arrays with checkable values.
+       igtf := initGoTestField()
+       igtrg := initGoTest_RepeatedGroup()
+       for i := 0; i < N; i++ {
+               pb.Repeatedgroup[i] = igtrg
+               pb.F_Sint64Repeated[i] = int64(i)
+               pb.F_Sint32Repeated[i] = int32(i)
+               s := fmt.Sprint(i)
+               pb.F_BytesRepeated[i] = []byte(s)
+               pb.F_StringRepeated[i] = s
+               pb.F_DoubleRepeated[i] = float64(i)
+               pb.F_FloatRepeated[i] = float32(i)
+               pb.F_Uint64Repeated[i] = uint64(i)
+               pb.F_Uint32Repeated[i] = uint32(i)
+               pb.F_Fixed64Repeated[i] = uint64(i)
+               pb.F_Fixed32Repeated[i] = uint32(i)
+               pb.F_Int64Repeated[i] = int64(i)
+               pb.F_Int32Repeated[i] = int32(i)
+               pb.F_BoolRepeated[i] = i%2 == 0
+               pb.RepeatedField[i] = igtf
+       }
+
+       // Marshal.
+       buf, _ := Marshal(pb)
+
+       // Now test Unmarshal by recreating the original buffer.
+       pbd := new(GoTest)
+       Unmarshal(buf, pbd)
+
+       // Check the checkable values
+       for i := uint64(0); i < N; i++ {
+               if pbd.Repeatedgroup[i] == nil { // TODO: more checking?
+                       t.Error("pbd.Repeatedgroup bad")
+               }
+               if x := uint64(pbd.F_Sint64Repeated[i]); x != i {
+                       t.Error("pbd.F_Sint64Repeated bad", x, i)
+               }
+               if x := uint64(pbd.F_Sint32Repeated[i]); x != i {
+                       t.Error("pbd.F_Sint32Repeated bad", x, i)
+               }
+               s := fmt.Sprint(i)
+               equalbytes(pbd.F_BytesRepeated[i], []byte(s), t)
+               if pbd.F_StringRepeated[i] != s {
+                       t.Error("pbd.F_Sint32Repeated bad", pbd.F_StringRepeated[i], i)
+               }
+               if x := uint64(pbd.F_DoubleRepeated[i]); x != i {
+                       t.Error("pbd.F_DoubleRepeated bad", x, i)
+               }
+               if x := uint64(pbd.F_FloatRepeated[i]); x != i {
+                       t.Error("pbd.F_FloatRepeated bad", x, i)
+               }
+               if x := pbd.F_Uint64Repeated[i]; x != i {
+                       t.Error("pbd.F_Uint64Repeated bad", x, i)
+               }
+               if x := uint64(pbd.F_Uint32Repeated[i]); x != i {
+                       t.Error("pbd.F_Uint32Repeated bad", x, i)
+               }
+               if x := pbd.F_Fixed64Repeated[i]; x != i {
+                       t.Error("pbd.F_Fixed64Repeated bad", x, i)
+               }
+               if x := uint64(pbd.F_Fixed32Repeated[i]); x != i {
+                       t.Error("pbd.F_Fixed32Repeated bad", x, i)
+               }
+               if x := uint64(pbd.F_Int64Repeated[i]); x != i {
+                       t.Error("pbd.F_Int64Repeated bad", x, i)
+               }
+               if x := uint64(pbd.F_Int32Repeated[i]); x != i {
+                       t.Error("pbd.F_Int32Repeated bad", x, i)
+               }
+               if x := pbd.F_BoolRepeated[i]; x != (i%2 == 0) {
+                       t.Error("pbd.F_BoolRepeated bad", x, i)
+               }
+               if pbd.RepeatedField[i] == nil { // TODO: more checking?
+                       t.Error("pbd.RepeatedField bad")
+               }
+       }
+}
+
+func TestBadWireTypeUnknown(t *testing.T) {
+       var b []byte
+       fmt.Sscanf("0a01780d00000000080b101612036161611521000000202c220362626225370000002203636363214200000000000000584d5a036464645900000000000056405d63000000", "%x", &b)
+
+       m := new(MyMessage)
+       if err := Unmarshal(b, m); err != nil {
+               t.Errorf("unexpected Unmarshal error: %v", err)
+       }
+
+       var unknown []byte
+       fmt.Sscanf("0a01780d0000000010161521000000202c2537000000214200000000000000584d5a036464645d63000000", "%x", &unknown)
+       if !bytes.Equal(m.XXX_unrecognized, unknown) {
+               t.Errorf("unknown bytes mismatch:\ngot  %x\nwant %x", m.XXX_unrecognized, unknown)
+       }
+       DiscardUnknown(m)
+
+       want := &MyMessage{Count: Int32(11), Name: String("aaa"), Pet: []string{"bbb", "ccc"}, Bigfloat: Float64(88)}
+       if !Equal(m, want) {
+               t.Errorf("message mismatch:\ngot  %v\nwant %v", m, want)
+       }
+}
+
+func encodeDecode(t *testing.T, in, out Message, msg string) {
+       buf, err := Marshal(in)
+       if err != nil {
+               t.Fatalf("failed marshaling %v: %v", msg, err)
+       }
+       if err := Unmarshal(buf, out); err != nil {
+               t.Fatalf("failed unmarshaling %v: %v", msg, err)
+       }
+}
+
+func TestPackedNonPackedDecoderSwitching(t *testing.T) {
+       np, p := new(NonPackedTest), new(PackedTest)
+
+       // non-packed -> packed
+       np.A = []int32{0, 1, 1, 2, 3, 5}
+       encodeDecode(t, np, p, "non-packed -> packed")
+       if !reflect.DeepEqual(np.A, p.B) {
+               t.Errorf("failed non-packed -> packed; np.A=%+v, p.B=%+v", np.A, p.B)
+       }
+
+       // packed -> non-packed
+       np.Reset()
+       p.B = []int32{3, 1, 4, 1, 5, 9}
+       encodeDecode(t, p, np, "packed -> non-packed")
+       if !reflect.DeepEqual(p.B, np.A) {
+               t.Errorf("failed packed -> non-packed; p.B=%+v, np.A=%+v", p.B, np.A)
+       }
+}
+
+func TestProto1RepeatedGroup(t *testing.T) {
+       pb := &MessageList{
+               Message: []*MessageList_Message{
+                       {
+                               Name:  String("blah"),
+                               Count: Int32(7),
+                       },
+                       // NOTE: pb.Message[1] is a nil
+                       nil,
+               },
+       }
+
+       o := old()
+       err := o.Marshal(pb)
+       if err == nil || !strings.Contains(err.Error(), "repeated field Message has nil") {
+               t.Fatalf("unexpected or no error when marshaling: %v", err)
+       }
+}
+
+// Test that enums work.  Checks for a bug introduced by making enums
+// named types instead of int32: newInt32FromUint64 would crash with
+// a type mismatch in reflect.PointTo.
+func TestEnum(t *testing.T) {
+       pb := new(GoEnum)
+       pb.Foo = FOO_FOO1.Enum()
+       o := old()
+       if err := o.Marshal(pb); err != nil {
+               t.Fatal("error encoding enum:", err)
+       }
+       pb1 := new(GoEnum)
+       if err := o.Unmarshal(pb1); err != nil {
+               t.Fatal("error decoding enum:", err)
+       }
+       if *pb1.Foo != FOO_FOO1 {
+               t.Error("expected 7 but got ", *pb1.Foo)
+       }
+}
+
+// Enum types have String methods. Check that enum fields can be printed.
+// We don't care what the value actually is, just as long as it doesn't crash.
+func TestPrintingNilEnumFields(t *testing.T) {
+       pb := new(GoEnum)
+       _ = fmt.Sprintf("%+v", pb)
+}
+
+// Verify that absent required fields cause Marshal/Unmarshal to return errors.
+func TestRequiredFieldEnforcement(t *testing.T) {
+       pb := new(GoTestField)
+       _, err := Marshal(pb)
+       if err == nil {
+               t.Error("marshal: expected error, got nil")
+       } else if _, ok := err.(*RequiredNotSetError); !ok || !strings.Contains(err.Error(), "Label") {
+               t.Errorf("marshal: bad error type: %v", err)
+       }
+
+       // A slightly sneaky, yet valid, proto. It encodes the same required field twice,
+       // so simply counting the required fields is insufficient.
+       // field 1, encoding 2, value "hi"
+       buf := []byte("\x0A\x02hi\x0A\x02hi")
+       err = Unmarshal(buf, pb)
+       if err == nil {
+               t.Error("unmarshal: expected error, got nil")
+       } else if _, ok := err.(*RequiredNotSetError); !ok || !strings.Contains(err.Error(), "Type") && !strings.Contains(err.Error(), "{Unknown}") {
+               // TODO: remove unknown cases once we commit to the new unmarshaler.
+               t.Errorf("unmarshal: bad error type: %v", err)
+       }
+}
+
+// Verify that absent required fields in groups cause Marshal/Unmarshal to return errors.
+func TestRequiredFieldEnforcementGroups(t *testing.T) {
+       pb := &GoTestRequiredGroupField{Group: &GoTestRequiredGroupField_Group{}}
+       if _, err := Marshal(pb); err == nil {
+               t.Error("marshal: expected error, got nil")
+       } else if _, ok := err.(*RequiredNotSetError); !ok || !strings.Contains(err.Error(), "Group.Field") {
+               t.Errorf("marshal: bad error type: %v", err)
+       }
+
+       buf := []byte{11, 12}
+       if err := Unmarshal(buf, pb); err == nil {
+               t.Error("unmarshal: expected error, got nil")
+       } else if _, ok := err.(*RequiredNotSetError); !ok || !strings.Contains(err.Error(), "Group.Field") && !strings.Contains(err.Error(), "Group.{Unknown}") {
+               t.Errorf("unmarshal: bad error type: %v", err)
+       }
+}
+
+func TestTypedNilMarshal(t *testing.T) {
+       // A typed nil should return ErrNil and not crash.
+       {
+               var m *GoEnum
+               if _, err := Marshal(m); err != ErrNil {
+                       t.Errorf("Marshal(%#v): got %v, want ErrNil", m, err)
+               }
+       }
+
+       {
+               m := &Communique{Union: &Communique_Msg{Msg: nil}}
+               if _, err := Marshal(m); err == nil || err == ErrNil {
+                       t.Errorf("Marshal(%#v): got %v, want errOneofHasNil", m, err)
+               }
+       }
+}
+
+// A type that implements the Marshaler interface, but is not nillable.
+type nonNillableInt uint64
+
+func (nni nonNillableInt) Marshal() ([]byte, error) {
+       return EncodeVarint(uint64(nni)), nil
+}
+
+type NNIMessage struct {
+       nni nonNillableInt
+}
+
+func (*NNIMessage) Reset()         {}
+func (*NNIMessage) String() string { return "" }
+func (*NNIMessage) ProtoMessage()  {}
+
+type NMMessage struct{}
+
+func (*NMMessage) Reset()         {}
+func (*NMMessage) String() string { return "" }
+func (*NMMessage) ProtoMessage()  {}
+
+// Verify a type that uses the Marshaler interface, but has a nil pointer.
+func TestNilMarshaler(t *testing.T) {
+       // Try a struct with a Marshaler field that is nil.
+       // It should be directly marshable.
+       nmm := new(NMMessage)
+       if _, err := Marshal(nmm); err != nil {
+               t.Error("unexpected error marshaling nmm: ", err)
+       }
+
+       // Try a struct with a Marshaler field that is not nillable.
+       nnim := new(NNIMessage)
+       nnim.nni = 7
+       var _ Marshaler = nnim.nni // verify it is truly a Marshaler
+       if _, err := Marshal(nnim); err != nil {
+               t.Error("unexpected error marshaling nnim: ", err)
+       }
+}
+
+func TestAllSetDefaults(t *testing.T) {
+       // Exercise SetDefaults with all scalar field types.
+       m := &Defaults{
+               // NaN != NaN, so override that here.
+               F_Nan: Float32(1.7),
+       }
+       expected := &Defaults{
+               F_Bool:    Bool(true),
+               F_Int32:   Int32(32),
+               F_Int64:   Int64(64),
+               F_Fixed32: Uint32(320),
+               F_Fixed64: Uint64(640),
+               F_Uint32:  Uint32(3200),
+               F_Uint64:  Uint64(6400),
+               F_Float:   Float32(314159),
+               F_Double:  Float64(271828),
+               F_String:  String(`hello, "world!"` + "\n"),
+               F_Bytes:   []byte("Bignose"),
+               F_Sint32:  Int32(-32),
+               F_Sint64:  Int64(-64),
+               F_Enum:    Defaults_GREEN.Enum(),
+               F_Pinf:    Float32(float32(math.Inf(1))),
+               F_Ninf:    Float32(float32(math.Inf(-1))),
+               F_Nan:     Float32(1.7),
+               StrZero:   String(""),
+       }
+       SetDefaults(m)
+       if !Equal(m, expected) {
+               t.Errorf("SetDefaults failed\n got %v\nwant %v", m, expected)
+       }
+}
+
+func TestSetDefaultsWithSetField(t *testing.T) {
+       // Check that a set value is not overridden.
+       m := &Defaults{
+               F_Int32: Int32(12),
+       }
+       SetDefaults(m)
+       if v := m.GetF_Int32(); v != 12 {
+               t.Errorf("m.FInt32 = %v, want 12", v)
+       }
+}
+
+func TestSetDefaultsWithSubMessage(t *testing.T) {
+       m := &OtherMessage{
+               Key: Int64(123),
+               Inner: &InnerMessage{
+                       Host: String("gopher"),
+               },
+       }
+       expected := &OtherMessage{
+               Key: Int64(123),
+               Inner: &InnerMessage{
+                       Host: String("gopher"),
+                       Port: Int32(4000),
+               },
+       }
+       SetDefaults(m)
+       if !Equal(m, expected) {
+               t.Errorf("\n got %v\nwant %v", m, expected)
+       }
+}
+
+func TestSetDefaultsWithRepeatedSubMessage(t *testing.T) {
+       m := &MyMessage{
+               RepInner: []*InnerMessage{{}},
+       }
+       expected := &MyMessage{
+               RepInner: []*InnerMessage{{
+                       Port: Int32(4000),
+               }},
+       }
+       SetDefaults(m)
+       if !Equal(m, expected) {
+               t.Errorf("\n got %v\nwant %v", m, expected)
+       }
+}
+
+func TestSetDefaultWithRepeatedNonMessage(t *testing.T) {
+       m := &MyMessage{
+               Pet: []string{"turtle", "wombat"},
+       }
+       expected := Clone(m)
+       SetDefaults(m)
+       if !Equal(m, expected) {
+               t.Errorf("\n got %v\nwant %v", m, expected)
+       }
+}
+
+func TestMaximumTagNumber(t *testing.T) {
+       m := &MaxTag{
+               LastField: String("natural goat essence"),
+       }
+       buf, err := Marshal(m)
+       if err != nil {
+               t.Fatalf("proto.Marshal failed: %v", err)
+       }
+       m2 := new(MaxTag)
+       if err := Unmarshal(buf, m2); err != nil {
+               t.Fatalf("proto.Unmarshal failed: %v", err)
+       }
+       if got, want := m2.GetLastField(), *m.LastField; got != want {
+               t.Errorf("got %q, want %q", got, want)
+       }
+}
+
+func TestJSON(t *testing.T) {
+       m := &MyMessage{
+               Count: Int32(4),
+               Pet:   []string{"bunny", "kitty"},
+               Inner: &InnerMessage{
+                       Host: String("cauchy"),
+               },
+               Bikeshed: MyMessage_GREEN.Enum(),
+       }
+       const expected = `{"count":4,"pet":["bunny","kitty"],"inner":{"host":"cauchy"},"bikeshed":1}`
+
+       b, err := json.Marshal(m)
+       if err != nil {
+               t.Fatalf("json.Marshal failed: %v", err)
+       }
+       s := string(b)
+       if s != expected {
+               t.Errorf("got  %s\nwant %s", s, expected)
+       }
+
+       received := new(MyMessage)
+       if err := json.Unmarshal(b, received); err != nil {
+               t.Fatalf("json.Unmarshal failed: %v", err)
+       }
+       if !Equal(received, m) {
+               t.Fatalf("got %s, want %s", received, m)
+       }
+
+       // Test unmarshalling of JSON with symbolic enum name.
+       const old = `{"count":4,"pet":["bunny","kitty"],"inner":{"host":"cauchy"},"bikeshed":"GREEN"}`
+       received.Reset()
+       if err := json.Unmarshal([]byte(old), received); err != nil {
+               t.Fatalf("json.Unmarshal failed: %v", err)
+       }
+       if !Equal(received, m) {
+               t.Fatalf("got %s, want %s", received, m)
+       }
+}
+
+func TestBadWireType(t *testing.T) {
+       b := []byte{7<<3 | 6} // field 7, wire type 6
+       pb := new(OtherMessage)
+       if err := Unmarshal(b, pb); err == nil {
+               t.Errorf("Unmarshal did not fail")
+       } else if !strings.Contains(err.Error(), "unknown wire type") {
+               t.Errorf("wrong error: %v", err)
+       }
+}
+
+func TestBytesWithInvalidLength(t *testing.T) {
+       // If a byte sequence has an invalid (negative) length, Unmarshal should not panic.
+       b := []byte{2<<3 | WireBytes, 0xff, 0xff, 0xff, 0xff, 0xff, 0}
+       Unmarshal(b, new(MyMessage))
+}
+
+func TestLengthOverflow(t *testing.T) {
+       // Overflowing a length should not panic.
+       b := []byte{2<<3 | WireBytes, 1, 1, 3<<3 | WireBytes, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x7f, 0x01}
+       Unmarshal(b, new(MyMessage))
+}
+
+func TestVarintOverflow(t *testing.T) {
+       // Overflowing a 64-bit length should not be allowed.
+       b := []byte{1<<3 | WireVarint, 0x01, 3<<3 | WireBytes, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x01}
+       if err := Unmarshal(b, new(MyMessage)); err == nil {
+               t.Fatalf("Overflowed uint64 length without error")
+       }
+}
+
+func TestBytesWithInvalidLengthInGroup(t *testing.T) {
+       // Overflowing a 64-bit length should not be allowed.
+       b := []byte{0xbb, 0x30, 0xb2, 0x30, 0xb0, 0xb2, 0x83, 0xf1, 0xb0, 0xb2, 0xef, 0xbf, 0xbd, 0x01}
+       if err := Unmarshal(b, new(MyMessage)); err == nil {
+               t.Fatalf("Overflowed uint64 length without error")
+       }
+}
+
+func TestUnmarshalFuzz(t *testing.T) {
+       const N = 1000
+       seed := time.Now().UnixNano()
+       t.Logf("RNG seed is %d", seed)
+       rng := rand.New(rand.NewSource(seed))
+       buf := make([]byte, 20)
+       for i := 0; i < N; i++ {
+               for j := range buf {
+                       buf[j] = byte(rng.Intn(256))
+               }
+               fuzzUnmarshal(t, buf)
+       }
+}
+
+func TestMergeMessages(t *testing.T) {
+       pb := &MessageList{Message: []*MessageList_Message{{Name: String("x"), Count: Int32(1)}}}
+       data, err := Marshal(pb)
+       if err != nil {
+               t.Fatalf("Marshal: %v", err)
+       }
+
+       pb1 := new(MessageList)
+       if err := Unmarshal(data, pb1); err != nil {
+               t.Fatalf("first Unmarshal: %v", err)
+       }
+       if err := Unmarshal(data, pb1); err != nil {
+               t.Fatalf("second Unmarshal: %v", err)
+       }
+       if len(pb1.Message) != 1 {
+               t.Errorf("two Unmarshals produced %d Messages, want 1", len(pb1.Message))
+       }
+
+       pb2 := new(MessageList)
+       if err := UnmarshalMerge(data, pb2); err != nil {
+               t.Fatalf("first UnmarshalMerge: %v", err)
+       }
+       if err := UnmarshalMerge(data, pb2); err != nil {
+               t.Fatalf("second UnmarshalMerge: %v", err)
+       }
+       if len(pb2.Message) != 2 {
+               t.Errorf("two UnmarshalMerges produced %d Messages, want 2", len(pb2.Message))
+       }
+}
+
+func TestExtensionMarshalOrder(t *testing.T) {
+       m := &MyMessage{Count: Int(123)}
+       if err := SetExtension(m, E_Ext_More, &Ext{Data: String("alpha")}); err != nil {
+               t.Fatalf("SetExtension: %v", err)
+       }
+       if err := SetExtension(m, E_Ext_Text, String("aleph")); err != nil {
+               t.Fatalf("SetExtension: %v", err)
+       }
+       if err := SetExtension(m, E_Ext_Number, Int32(1)); err != nil {
+               t.Fatalf("SetExtension: %v", err)
+       }
+
+       // Serialize m several times, and check we get the same bytes each time.
+       var orig []byte
+       for i := 0; i < 100; i++ {
+               b, err := Marshal(m)
+               if err != nil {
+                       t.Fatalf("Marshal: %v", err)
+               }
+               if i == 0 {
+                       orig = b
+                       continue
+               }
+               if !bytes.Equal(b, orig) {
+                       t.Errorf("Bytes differ on attempt #%d", i)
+               }
+       }
+}
+
+func TestExtensionMapFieldMarshalDeterministic(t *testing.T) {
+       m := &MyMessage{Count: Int(123)}
+       if err := SetExtension(m, E_Ext_More, &Ext{MapField: map[int32]int32{1: 1, 2: 2, 3: 3, 4: 4}}); err != nil {
+               t.Fatalf("SetExtension: %v", err)
+       }
+       marshal := func(m Message) []byte {
+               var b Buffer
+               b.SetDeterministic(true)
+               if err := b.Marshal(m); err != nil {
+                       t.Fatalf("Marshal failed: %v", err)
+               }
+               return b.Bytes()
+       }
+
+       want := marshal(m)
+       for i := 0; i < 100; i++ {
+               if got := marshal(m); !bytes.Equal(got, want) {
+                       t.Errorf("Marshal produced inconsistent output with determinism enabled (pass %d).\n got %v\nwant %v", i, got, want)
+               }
+       }
+}
+
+// Many extensions, because small maps might not iterate differently on each iteration.
+var exts = []*ExtensionDesc{
+       E_X201,
+       E_X202,
+       E_X203,
+       E_X204,
+       E_X205,
+       E_X206,
+       E_X207,
+       E_X208,
+       E_X209,
+       E_X210,
+       E_X211,
+       E_X212,
+       E_X213,
+       E_X214,
+       E_X215,
+       E_X216,
+       E_X217,
+       E_X218,
+       E_X219,
+       E_X220,
+       E_X221,
+       E_X222,
+       E_X223,
+       E_X224,
+       E_X225,
+       E_X226,
+       E_X227,
+       E_X228,
+       E_X229,
+       E_X230,
+       E_X231,
+       E_X232,
+       E_X233,
+       E_X234,
+       E_X235,
+       E_X236,
+       E_X237,
+       E_X238,
+       E_X239,
+       E_X240,
+       E_X241,
+       E_X242,
+       E_X243,
+       E_X244,
+       E_X245,
+       E_X246,
+       E_X247,
+       E_X248,
+       E_X249,
+       E_X250,
+}
+
+func TestMessageSetMarshalOrder(t *testing.T) {
+       m := &MyMessageSet{}
+       for _, x := range exts {
+               if err := SetExtension(m, x, &Empty{}); err != nil {
+                       t.Fatalf("SetExtension: %v", err)
+               }
+       }
+
+       buf, err := Marshal(m)
+       if err != nil {
+               t.Fatalf("Marshal: %v", err)
+       }
+
+       // Serialize m several times, and check we get the same bytes each time.
+       for i := 0; i < 10; i++ {
+               b1, err := Marshal(m)
+               if err != nil {
+                       t.Fatalf("Marshal: %v", err)
+               }
+               if !bytes.Equal(b1, buf) {
+                       t.Errorf("Bytes differ on re-Marshal #%d", i)
+               }
+
+               m2 := &MyMessageSet{}
+               if err = Unmarshal(buf, m2); err != nil {
+                       t.Errorf("Unmarshal: %v", err)
+               }
+               b2, err := Marshal(m2)
+               if err != nil {
+                       t.Errorf("re-Marshal: %v", err)
+               }
+               if !bytes.Equal(b2, buf) {
+                       t.Errorf("Bytes differ on round-trip #%d", i)
+               }
+       }
+}
+
+func TestUnmarshalMergesMessages(t *testing.T) {
+       // If a nested message occurs twice in the input,
+       // the fields should be merged when decoding.
+       a := &OtherMessage{
+               Key: Int64(123),
+               Inner: &InnerMessage{
+                       Host: String("polhode"),
+                       Port: Int32(1234),
+               },
+       }
+       aData, err := Marshal(a)
+       if err != nil {
+               t.Fatalf("Marshal(a): %v", err)
+       }
+       b := &OtherMessage{
+               Weight: Float32(1.2),
+               Inner: &InnerMessage{
+                       Host:      String("herpolhode"),
+                       Connected: Bool(true),
+               },
+       }
+       bData, err := Marshal(b)
+       if err != nil {
+               t.Fatalf("Marshal(b): %v", err)
+       }
+       want := &OtherMessage{
+               Key:    Int64(123),
+               Weight: Float32(1.2),
+               Inner: &InnerMessage{
+                       Host:      String("herpolhode"),
+                       Port:      Int32(1234),
+                       Connected: Bool(true),
+               },
+       }
+       got := new(OtherMessage)
+       if err := Unmarshal(append(aData, bData...), got); err != nil {
+               t.Fatalf("Unmarshal: %v", err)
+       }
+       if !Equal(got, want) {
+               t.Errorf("\n got %v\nwant %v", got, want)
+       }
+}
+
+func TestUnmarshalMergesGroups(t *testing.T) {
+       // If a nested group occurs twice in the input,
+       // the fields should be merged when decoding.
+       a := &GroupNew{
+               G: &GroupNew_G{
+                       X: Int32(7),
+                       Y: Int32(8),
+               },
+       }
+       aData, err := Marshal(a)
+       if err != nil {
+               t.Fatalf("Marshal(a): %v", err)
+       }
+       b := &GroupNew{
+               G: &GroupNew_G{
+                       X: Int32(9),
+               },
+       }
+       bData, err := Marshal(b)
+       if err != nil {
+               t.Fatalf("Marshal(b): %v", err)
+       }
+       want := &GroupNew{
+               G: &GroupNew_G{
+                       X: Int32(9),
+                       Y: Int32(8),
+               },
+       }
+       got := new(GroupNew)
+       if err := Unmarshal(append(aData, bData...), got); err != nil {
+               t.Fatalf("Unmarshal: %v", err)
+       }
+       if !Equal(got, want) {
+               t.Errorf("\n got %v\nwant %v", got, want)
+       }
+}
+
+func TestEncodingSizes(t *testing.T) {
+       tests := []struct {
+               m Message
+               n int
+       }{
+               {&Defaults{F_Int32: Int32(math.MaxInt32)}, 6},
+               {&Defaults{F_Int32: Int32(math.MinInt32)}, 11},
+               {&Defaults{F_Uint32: Uint32(uint32(math.MaxInt32) + 1)}, 6},
+               {&Defaults{F_Uint32: Uint32(math.MaxUint32)}, 6},
+       }
+       for _, test := range tests {
+               b, err := Marshal(test.m)
+               if err != nil {
+                       t.Errorf("Marshal(%v): %v", test.m, err)
+                       continue
+               }
+               if len(b) != test.n {
+                       t.Errorf("Marshal(%v) yielded %d bytes, want %d bytes", test.m, len(b), test.n)
+               }
+       }
+}
+
+func TestRequiredNotSetError(t *testing.T) {
+       pb := initGoTest(false)
+       pb.RequiredField.Label = nil
+       pb.F_Int32Required = nil
+       pb.F_Int64Required = nil
+
+       expected := "0807" + // field 1, encoding 0, value 7
+               "2206" + "120474797065" + // field 4, encoding 2 (GoTestField)
+               "5001" + // field 10, encoding 0, value 1
+               "6d20000000" + // field 13, encoding 5, value 0x20
+               "714000000000000000" + // field 14, encoding 1, value 0x40
+               "78a019" + // field 15, encoding 0, value 0xca0 = 3232
+               "8001c032" + // field 16, encoding 0, value 0x1940 = 6464
+               "8d0100004a45" + // field 17, encoding 5, value 3232.0
+               "9101000000000040b940" + // field 18, encoding 1, value 6464.0
+               "9a0106" + "737472696e67" + // field 19, encoding 2, string "string"
+               "b304" + // field 70, encoding 3, start group
+               "ba0408" + "7265717569726564" + // field 71, encoding 2, string "required"
+               "b404" + // field 70, encoding 4, end group
+               "aa0605" + "6279746573" + // field 101, encoding 2, string "bytes"
+               "b0063f" + // field 102, encoding 0, 0x3f zigzag32
+               "b8067f" + // field 103, encoding 0, 0x7f zigzag64
+               "c506e0ffffff" + // field 104, encoding 5, -32 fixed32
+               "c906c0ffffffffffffff" // field 105, encoding 1, -64 fixed64
+
+       o := old()
+       mbytes, err := Marshal(pb)
+       if _, ok := err.(*RequiredNotSetError); !ok {
+               fmt.Printf("marshal-1 err = %v, want *RequiredNotSetError", err)
+               o.DebugPrint("", mbytes)
+               t.Fatalf("expected = %s", expected)
+       }
+       if !strings.Contains(err.Error(), "RequiredField.Label") {
+               t.Errorf("marshal-1 wrong err msg: %v", err)
+       }
+       if !equal(mbytes, expected, t) {
+               o.DebugPrint("neq 1", mbytes)
+               t.Fatalf("expected = %s", expected)
+       }
+
+       // Now test Unmarshal by recreating the original buffer.
+       pbd := new(GoTest)
+       err = Unmarshal(mbytes, pbd)
+       if _, ok := err.(*RequiredNotSetError); !ok {
+               t.Fatalf("unmarshal err = %v, want *RequiredNotSetError", err)
+               o.DebugPrint("", mbytes)
+               t.Fatalf("string = %s", expected)
+       }
+       if !strings.Contains(err.Error(), "RequiredField.Label") && !strings.Contains(err.Error(), "RequiredField.{Unknown}") {
+               t.Errorf("unmarshal wrong err msg: %v", err)
+       }
+       mbytes, err = Marshal(pbd)
+       if _, ok := err.(*RequiredNotSetError); !ok {
+               t.Errorf("marshal-2 err = %v, want *RequiredNotSetError", err)
+               o.DebugPrint("", mbytes)
+               t.Fatalf("string = %s", expected)
+       }
+       if !strings.Contains(err.Error(), "RequiredField.Label") {
+               t.Errorf("marshal-2 wrong err msg: %v", err)
+       }
+       if !equal(mbytes, expected, t) {
+               o.DebugPrint("neq 2", mbytes)
+               t.Fatalf("string = %s", expected)
+       }
+}
+
+func TestRequiredNotSetErrorWithBadWireTypes(t *testing.T) {
+       // Required field expects a varint, and properly found a varint.
+       if err := Unmarshal([]byte{0x08, 0x00}, new(GoEnum)); err != nil {
+               t.Errorf("Unmarshal = %v, want nil", err)
+       }
+       // Required field expects a varint, but found a fixed32 instead.
+       if err := Unmarshal([]byte{0x0d, 0x00, 0x00, 0x00, 0x00}, new(GoEnum)); err == nil {
+               t.Errorf("Unmarshal = nil, want RequiredNotSetError")
+       }
+       // Required field expects a varint, and found both a varint and fixed32 (ignored).
+       m := new(GoEnum)
+       if err := Unmarshal([]byte{0x08, 0x00, 0x0d, 0x00, 0x00, 0x00, 0x00}, m); err != nil {
+               t.Errorf("Unmarshal = %v, want nil", err)
+       }
+       if !bytes.Equal(m.XXX_unrecognized, []byte{0x0d, 0x00, 0x00, 0x00, 0x00}) {
+               t.Errorf("expected fixed32 to appear as unknown bytes: %x", m.XXX_unrecognized)
+       }
+}
+
+func fuzzUnmarshal(t *testing.T, data []byte) {
+       defer func() {
+               if e := recover(); e != nil {
+                       t.Errorf("These bytes caused a panic: %+v", data)
+                       t.Logf("Stack:\n%s", debug.Stack())
+                       t.FailNow()
+               }
+       }()
+
+       pb := new(MyMessage)
+       Unmarshal(data, pb)
+}
+
+func TestMapFieldMarshal(t *testing.T) {
+       m := &MessageWithMap{
+               NameMapping: map[int32]string{
+                       1: "Rob",
+                       4: "Ian",
+                       8: "Dave",
+               },
+       }
+       b, err := Marshal(m)
+       if err != nil {
+               t.Fatalf("Marshal: %v", err)
+       }
+
+       // b should be the concatenation of these three byte sequences in some order.
+       parts := []string{
+               "\n\a\b\x01\x12\x03Rob",
+               "\n\a\b\x04\x12\x03Ian",
+               "\n\b\b\x08\x12\x04Dave",
+       }
+       ok := false
+       for i := range parts {
+               for j := range parts {
+                       if j == i {
+                               continue
+                       }
+                       for k := range parts {
+                               if k == i || k == j {
+                                       continue
+                               }
+                               try := parts[i] + parts[j] + parts[k]
+                               if bytes.Equal(b, []byte(try)) {
+                                       ok = true
+                                       break
+                               }
+                       }
+               }
+       }
+       if !ok {
+               t.Fatalf("Incorrect Marshal output.\n got %q\nwant %q (or a permutation of that)", b, parts[0]+parts[1]+parts[2])
+       }
+       t.Logf("FYI b: %q", b)
+
+       (new(Buffer)).DebugPrint("Dump of b", b)
+}
+
+func TestMapFieldDeterministicMarshal(t *testing.T) {
+       m := &MessageWithMap{
+               NameMapping: map[int32]string{
+                       1: "Rob",
+                       4: "Ian",
+                       8: "Dave",
+               },
+       }
+
+       marshal := func(m Message) []byte {
+               var b Buffer
+               b.SetDeterministic(true)
+               if err := b.Marshal(m); err != nil {
+                       t.Fatalf("Marshal failed: %v", err)
+               }
+               return b.Bytes()
+       }
+
+       want := marshal(m)
+       for i := 0; i < 10; i++ {
+               if got := marshal(m); !bytes.Equal(got, want) {
+                       t.Errorf("Marshal produced inconsistent output with determinism enabled (pass %d).\n got %v\nwant %v", i, got, want)
+               }
+       }
+}
+
+func TestMapFieldRoundTrips(t *testing.T) {
+       m := &MessageWithMap{
+               NameMapping: map[int32]string{
+                       1: "Rob",
+                       4: "Ian",
+                       8: "Dave",
+               },
+               MsgMapping: map[int64]*FloatingPoint{
+                       0x7001: {F: Float64(2.0)},
+               },
+               ByteMapping: map[bool][]byte{
+                       false: []byte("that's not right!"),
+                       true:  []byte("aye, 'tis true!"),
+               },
+       }
+       b, err := Marshal(m)
+       if err != nil {
+               t.Fatalf("Marshal: %v", err)
+       }
+       t.Logf("FYI b: %q", b)
+       m2 := new(MessageWithMap)
+       if err := Unmarshal(b, m2); err != nil {
+               t.Fatalf("Unmarshal: %v", err)
+       }
+       if !Equal(m, m2) {
+               t.Errorf("Map did not survive a round trip.\ninitial: %v\n  final: %v", m, m2)
+       }
+}
+
+func TestMapFieldWithNil(t *testing.T) {
+       m1 := &MessageWithMap{
+               MsgMapping: map[int64]*FloatingPoint{
+                       1: nil,
+               },
+       }
+       b, err := Marshal(m1)
+       if err != nil {
+               t.Fatalf("Marshal: %v", err)
+       }
+       m2 := new(MessageWithMap)
+       if err := Unmarshal(b, m2); err != nil {
+               t.Fatalf("Unmarshal: %v, got these bytes: %v", err, b)
+       }
+       if v, ok := m2.MsgMapping[1]; !ok {
+               t.Error("msg_mapping[1] not present")
+       } else if v != nil {
+               t.Errorf("msg_mapping[1] not nil: %v", v)
+       }
+}
+
+func TestMapFieldWithNilBytes(t *testing.T) {
+       m1 := &MessageWithMap{
+               ByteMapping: map[bool][]byte{
+                       false: {},
+                       true:  nil,
+               },
+       }
+       n := Size(m1)
+       b, err := Marshal(m1)
+       if err != nil {
+               t.Fatalf("Marshal: %v", err)
+       }
+       if n != len(b) {
+               t.Errorf("Size(m1) = %d; want len(Marshal(m1)) = %d", n, len(b))
+       }
+       m2 := new(MessageWithMap)
+       if err := Unmarshal(b, m2); err != nil {
+               t.Fatalf("Unmarshal: %v, got these bytes: %v", err, b)
+       }
+       if v, ok := m2.ByteMapping[false]; !ok {
+               t.Error("byte_mapping[false] not present")
+       } else if len(v) != 0 {
+               t.Errorf("byte_mapping[false] not empty: %#v", v)
+       }
+       if v, ok := m2.ByteMapping[true]; !ok {
+               t.Error("byte_mapping[true] not present")
+       } else if len(v) != 0 {
+               t.Errorf("byte_mapping[true] not empty: %#v", v)
+       }
+}
+
+func TestDecodeMapFieldMissingKey(t *testing.T) {
+       b := []byte{
+               0x0A, 0x03, // message, tag 1 (name_mapping), of length 3 bytes
+               // no key
+               0x12, 0x01, 0x6D, // string value of length 1 byte, value "m"
+       }
+       got := &MessageWithMap{}
+       err := Unmarshal(b, got)
+       if err != nil {
+               t.Fatalf("failed to marshal map with missing key: %v", err)
+       }
+       want := &MessageWithMap{NameMapping: map[int32]string{0: "m"}}
+       if !Equal(got, want) {
+               t.Errorf("Unmarshaled map with no key was not as expected. got: %v, want %v", got, want)
+       }
+}
+
+func TestDecodeMapFieldMissingValue(t *testing.T) {
+       b := []byte{
+               0x0A, 0x02, // message, tag 1 (name_mapping), of length 2 bytes
+               0x08, 0x01, // varint key, value 1
+               // no value
+       }
+       got := &MessageWithMap{}
+       err := Unmarshal(b, got)
+       if err != nil {
+               t.Fatalf("failed to marshal map with missing value: %v", err)
+       }
+       want := &MessageWithMap{NameMapping: map[int32]string{1: ""}}
+       if !Equal(got, want) {
+               t.Errorf("Unmarshaled map with no value was not as expected. got: %v, want %v", got, want)
+       }
+}
+
+func TestOneof(t *testing.T) {
+       m := &Communique{}
+       b, err := Marshal(m)
+       if err != nil {
+               t.Fatalf("Marshal of empty message with oneof: %v", err)
+       }
+       if len(b) != 0 {
+               t.Errorf("Marshal of empty message yielded too many bytes: %v", b)
+       }
+
+       m = &Communique{
+               Union: &Communique_Name{Name: "Barry"},
+       }
+
+       // Round-trip.
+       b, err = Marshal(m)
+       if err != nil {
+               t.Fatalf("Marshal of message with oneof: %v", err)
+       }
+       if len(b) != 7 { // name tag/wire (1) + name len (1) + name (5)
+               t.Errorf("Incorrect marshal of message with oneof: %v", b)
+       }
+       m.Reset()
+       if err = Unmarshal(b, m); err != nil {
+               t.Fatalf("Unmarshal of message with oneof: %v", err)
+       }
+       if x, ok := m.Union.(*Communique_Name); !ok || x.Name != "Barry" {
+               t.Errorf("After round trip, Union = %+v", m.Union)
+       }
+       if name := m.GetName(); name != "Barry" {
+               t.Errorf("After round trip, GetName = %q, want %q", name, "Barry")
+       }
+
+       // Let's try with a message in the oneof.
+       m.Union = &Communique_Msg{Msg: &Strings{StringField: String("deep deep string")}}
+       b, err = Marshal(m)
+       if err != nil {
+               t.Fatalf("Marshal of message with oneof set to message: %v", err)
+       }
+       if len(b) != 20 { // msg tag/wire (1) + msg len (1) + msg (1 + 1 + 16)
+               t.Errorf("Incorrect marshal of message with oneof set to message: %v", b)
+       }
+       m.Reset()
+       if err := Unmarshal(b, m); err != nil {
+               t.Fatalf("Unmarshal of message with oneof set to message: %v", err)
+       }
+       ss, ok := m.Union.(*Communique_Msg)
+       if !ok || ss.Msg.GetStringField() != "deep deep string" {
+               t.Errorf("After round trip with oneof set to message, Union = %+v", m.Union)
+       }
+}
+
+func TestOneofNilBytes(t *testing.T) {
+       // A oneof with nil byte slice should marshal to tag + 0 (size), with no error.
+       m := &Communique{Union: &Communique_Data{Data: nil}}
+       b, err := Marshal(m)
+       if err != nil {
+               t.Fatalf("Marshal failed: %v", err)
+       }
+       want := []byte{
+               7<<3 | 2, // tag 7, wire type 2
+               0,        // size
+       }
+       if !bytes.Equal(b, want) {
+               t.Errorf("Wrong result of Marshal: got %x, want %x", b, want)
+       }
+}
+
+func TestInefficientPackedBool(t *testing.T) {
+       // https://github.com/golang/protobuf/issues/76
+       inp := []byte{
+               0x12, 0x02, // 0x12 = 2<<3|2; 2 bytes
+               // Usually a bool should take a single byte,
+               // but it is permitted to be any varint.
+               0xb9, 0x30,
+       }
+       if err := Unmarshal(inp, new(MoreRepeated)); err != nil {
+               t.Error(err)
+       }
+}
+
+// Make sure pure-reflect-based implementation handles
+// []int32-[]enum conversion correctly.
+func TestRepeatedEnum2(t *testing.T) {
+       pb := &RepeatedEnum{
+               Color: []RepeatedEnum_Color{RepeatedEnum_RED},
+       }
+       b, err := Marshal(pb)
+       if err != nil {
+               t.Fatalf("Marshal failed: %v", err)
+       }
+       x := new(RepeatedEnum)
+       err = Unmarshal(b, x)
+       if err != nil {
+               t.Fatalf("Unmarshal failed: %v", err)
+       }
+       if !Equal(pb, x) {
+               t.Errorf("Incorrect result: want: %v got: %v", pb, x)
+       }
+}
+
+// TestConcurrentMarshal makes sure that it is safe to marshal
+// same message in multiple goroutines concurrently.
+func TestConcurrentMarshal(t *testing.T) {
+       pb := initGoTest(true)
+       const N = 100
+       b := make([][]byte, N)
+
+       var wg sync.WaitGroup
+       for i := 0; i < N; i++ {
+               wg.Add(1)
+               go func(i int) {
+                       defer wg.Done()
+                       var err error
+                       b[i], err = Marshal(pb)
+                       if err != nil {
+                               t.Errorf("marshal error: %v", err)
+                       }
+               }(i)
+       }
+
+       wg.Wait()
+       for i := 1; i < N; i++ {
+               if !bytes.Equal(b[0], b[i]) {
+                       t.Errorf("concurrent marshal result not same: b[0] = %v, b[%d] = %v", b[0], i, b[i])
+               }
+       }
+}
+
+func TestInvalidUTF8(t *testing.T) {
+       const invalidUTF8 = "\xde\xad\xbe\xef\x80\x00\xff"
+       tests := []struct {
+               label  string
+               proto2 Message
+               proto3 Message
+               want   []byte
+       }{{
+               label:  "Scalar",
+               proto2: &TestUTF8{Scalar: String(invalidUTF8)},
+               proto3: &pb3.TestUTF8{Scalar: invalidUTF8},
+               want:   []byte{0x0a, 0x07, 0xde, 0xad, 0xbe, 0xef, 0x80, 0x00, 0xff},
+       }, {
+               label:  "Vector",
+               proto2: &TestUTF8{Vector: []string{invalidUTF8}},
+               proto3: &pb3.TestUTF8{Vector: []string{invalidUTF8}},
+               want:   []byte{0x12, 0x07, 0xde, 0xad, 0xbe, 0xef, 0x80, 0x00, 0xff},
+       }, {
+               label:  "Oneof",
+               proto2: &TestUTF8{Oneof: &TestUTF8_Field{Field: invalidUTF8}},
+               proto3: &pb3.TestUTF8{Oneof: &pb3.TestUTF8_Field{Field: invalidUTF8}},
+               want:   []byte{0x1a, 0x07, 0xde, 0xad, 0xbe, 0xef, 0x80, 0x00, 0xff},
+       }, {
+               label:  "MapKey",
+               proto2: &TestUTF8{MapKey: map[string]int64{invalidUTF8: 0}},
+               proto3: &pb3.TestUTF8{MapKey: map[string]int64{invalidUTF8: 0}},
+               want:   []byte{0x22, 0x0b, 0x0a, 0x07, 0xde, 0xad, 0xbe, 0xef, 0x80, 0x00, 0xff, 0x10, 0x00},
+       }, {
+               label:  "MapValue",
+               proto2: &TestUTF8{MapValue: map[int64]string{0: invalidUTF8}},
+               proto3: &pb3.TestUTF8{MapValue: map[int64]string{0: invalidUTF8}},
+               want:   []byte{0x2a, 0x0b, 0x08, 0x00, 0x12, 0x07, 0xde, 0xad, 0xbe, 0xef, 0x80, 0x00, 0xff},
+       }}
+
+       for _, tt := range tests {
+               // Proto2 should not validate UTF-8.
+               b, err := Marshal(tt.proto2)
+               if err != nil {
+                       t.Errorf("Marshal(proto2.%s) = %v, want nil", tt.label, err)
+               }
+               if !bytes.Equal(b, tt.want) {
+                       t.Errorf("Marshal(proto2.%s) = %x, want %x", tt.label, b, tt.want)
+               }
+
+               m := Clone(tt.proto2)
+               m.Reset()
+               if err = Unmarshal(tt.want, m); err != nil {
+                       t.Errorf("Unmarshal(proto2.%s) = %v, want nil", tt.label, err)
+               }
+               if !Equal(m, tt.proto2) {
+                       t.Errorf("proto2.%s: output mismatch:\ngot  %v\nwant %v", tt.label, m, tt.proto2)
+               }
+
+               // Proto3 should validate UTF-8.
+               b, err = Marshal(tt.proto3)
+               if err == nil {
+                       t.Errorf("Marshal(proto3.%s) = %v, want non-nil", tt.label, err)
+               }
+               if !bytes.Equal(b, tt.want) {
+                       t.Errorf("Marshal(proto3.%s) = %x, want %x", tt.label, b, tt.want)
+               }
+
+               m = Clone(tt.proto3)
+               m.Reset()
+               err = Unmarshal(tt.want, m)
+               if err == nil {
+                       t.Errorf("Unmarshal(proto3.%s) = %v, want non-nil", tt.label, err)
+               }
+               if !Equal(m, tt.proto3) {
+                       t.Errorf("proto3.%s: output mismatch:\ngot  %v\nwant %v", tt.label, m, tt.proto2)
+               }
+       }
+}
+
+type CustomRawMessage []byte
+
+func (m *CustomRawMessage) Marshal() ([]byte, error) {
+       return []byte(*m), nil
+}
+func (m *CustomRawMessage) Reset()         { *m = nil }
+func (m *CustomRawMessage) String() string { return fmt.Sprintf("%x", *m) }
+func (m *CustomRawMessage) ProtoMessage()  {}
+
+func TestDeterministicErrorOnCustomMarshaler(t *testing.T) {
+       in := CustomRawMessage{1, 2, 3}
+       var b1 Buffer
+       b1.SetDeterministic(true)
+       err := b1.Marshal(&in)
+       if err == nil || !strings.Contains(err.Error(), "deterministic") {
+               t.Fatalf("Marshal error:\ngot  %v\nwant deterministic not supported error", err)
+       }
+}
+
+func TestRequired(t *testing.T) {
+       // The F_BoolRequired field appears after all of the required fields.
+       // It should still be handled even after multiple required field violations.
+       m := &GoTest{F_BoolRequired: Bool(true)}
+       got, err := Marshal(m)
+       if _, ok := err.(*RequiredNotSetError); !ok {
+               t.Errorf("Marshal() = %v, want RequiredNotSetError error", err)
+       }
+       if want := []byte{0x50, 0x01}; !bytes.Equal(got, want) {
+               t.Errorf("Marshal() = %x, want %x", got, want)
+       }
+
+       m = new(GoTest)
+       err = Unmarshal(got, m)
+       if _, ok := err.(*RequiredNotSetError); !ok {
+               t.Errorf("Marshal() = %v, want RequiredNotSetError error", err)
+       }
+       if !m.GetF_BoolRequired() {
+               t.Error("m.F_BoolRequired = false, want true")
+       }
+}
+
+// Benchmarks
+
+func testMsg() *GoTest {
+       pb := initGoTest(true)
+       const N = 1000 // Internally the library starts much smaller.
+       pb.F_Int32Repeated = make([]int32, N)
+       pb.F_DoubleRepeated = make([]float64, N)
+       for i := 0; i < N; i++ {
+               pb.F_Int32Repeated[i] = int32(i)
+               pb.F_DoubleRepeated[i] = float64(i)
+       }
+       return pb
+}
+
+func bytesMsg() *GoTest {
+       pb := initGoTest(true)
+       buf := make([]byte, 4000)
+       for i := range buf {
+               buf[i] = byte(i)
+       }
+       pb.F_BytesDefaulted = buf
+       return pb
+}
+
+func benchmarkMarshal(b *testing.B, pb Message, marshal func(Message) ([]byte, error)) {
+       d, _ := marshal(pb)
+       b.SetBytes(int64(len(d)))
+       b.ResetTimer()
+       for i := 0; i < b.N; i++ {
+               marshal(pb)
+       }
+}
+
+func benchmarkBufferMarshal(b *testing.B, pb Message) {
+       p := NewBuffer(nil)
+       benchmarkMarshal(b, pb, func(pb0 Message) ([]byte, error) {
+               p.Reset()
+               err := p.Marshal(pb0)
+               return p.Bytes(), err
+       })
+}
+
+func benchmarkSize(b *testing.B, pb Message) {
+       benchmarkMarshal(b, pb, func(pb0 Message) ([]byte, error) {
+               Size(pb)
+               return nil, nil
+       })
+}
+
+func newOf(pb Message) Message {
+       in := reflect.ValueOf(pb)
+       if in.IsNil() {
+               return pb
+       }
+       return reflect.New(in.Type().Elem()).Interface().(Message)
+}
+
+func benchmarkUnmarshal(b *testing.B, pb Message, unmarshal func([]byte, Message) error) {
+       d, _ := Marshal(pb)
+       b.SetBytes(int64(len(d)))
+       pbd := newOf(pb)
+
+       b.ResetTimer()
+       for i := 0; i < b.N; i++ {
+               unmarshal(d, pbd)
+       }
+}
+
+func benchmarkBufferUnmarshal(b *testing.B, pb Message) {
+       p := NewBuffer(nil)
+       benchmarkUnmarshal(b, pb, func(d []byte, pb0 Message) error {
+               p.SetBuf(d)
+               return p.Unmarshal(pb0)
+       })
+}
+
+// Benchmark{Marshal,BufferMarshal,Size,Unmarshal,BufferUnmarshal}{,Bytes}
+
+func BenchmarkMarshal(b *testing.B) {
+       benchmarkMarshal(b, testMsg(), Marshal)
+}
+
+func BenchmarkBufferMarshal(b *testing.B) {
+       benchmarkBufferMarshal(b, testMsg())
+}
+
+func BenchmarkSize(b *testing.B) {
+       benchmarkSize(b, testMsg())
+}
+
+func BenchmarkUnmarshal(b *testing.B) {
+       benchmarkUnmarshal(b, testMsg(), Unmarshal)
+}
+
+func BenchmarkBufferUnmarshal(b *testing.B) {
+       benchmarkBufferUnmarshal(b, testMsg())
+}
+
+func BenchmarkMarshalBytes(b *testing.B) {
+       benchmarkMarshal(b, bytesMsg(), Marshal)
+}
+
+func BenchmarkBufferMarshalBytes(b *testing.B) {
+       benchmarkBufferMarshal(b, bytesMsg())
+}
+
+func BenchmarkSizeBytes(b *testing.B) {
+       benchmarkSize(b, bytesMsg())
+}
+
+func BenchmarkUnmarshalBytes(b *testing.B) {
+       benchmarkUnmarshal(b, bytesMsg(), Unmarshal)
+}
+
+func BenchmarkBufferUnmarshalBytes(b *testing.B) {
+       benchmarkBufferUnmarshal(b, bytesMsg())
+}
+
+func BenchmarkUnmarshalUnrecognizedFields(b *testing.B) {
+       b.StopTimer()
+       pb := initGoTestField()
+       skip := &GoSkipTest{
+               SkipInt32:   Int32(32),
+               SkipFixed32: Uint32(3232),
+               SkipFixed64: Uint64(6464),
+               SkipString:  String("skipper"),
+               Skipgroup: &GoSkipTest_SkipGroup{
+                       GroupInt32:  Int32(75),
+                       GroupString: String("wxyz"),
+               },
+       }
+
+       pbd := new(GoTestField)
+       p := NewBuffer(nil)
+       p.Marshal(pb)
+       p.Marshal(skip)
+       p2 := NewBuffer(nil)
+
+       b.StartTimer()
+       for i := 0; i < b.N; i++ {
+               p2.SetBuf(p.Bytes())
+               p2.Unmarshal(pbd)
+       }
+}

diff --git a/vendor/github.com/gogo/protobuf/proto/any_test.go b/vendor/github.com/gogo/protobuf/proto/any_test.go
new file mode 100644 (file)
index 0000000..c0e10f2
--- /dev/null
+++ b/vendor/github.com/gogo/protobuf/proto/any_test.go
@@ -0,0 +1,300 @@
+// Go support for Protocol Buffers - Google's data interchange format
+//
+// Copyright 2016 The Go Authors.  All rights reserved.
+// https://github.com/golang/protobuf
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//     * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//     * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//     * Neither the name of Google Inc. nor the names of its
+// contributors may be used to endorse or promote products derived from
+// this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+package proto_test
+
+import (
+       "strings"
+       "testing"
+
+       "github.com/gogo/protobuf/proto"
+
+       pb "github.com/gogo/protobuf/proto/proto3_proto"
+       testpb "github.com/gogo/protobuf/proto/test_proto"
+       "github.com/gogo/protobuf/types"
+)
+
+var (
+       expandedMarshaler        = proto.TextMarshaler{ExpandAny: true}
+       expandedCompactMarshaler = proto.TextMarshaler{Compact: true, ExpandAny: true}
+)
+
+// anyEqual reports whether two messages which may be google.protobuf.Any or may
+// contain google.protobuf.Any fields are equal. We can't use proto.Equal for
+// comparison, because semantically equivalent messages may be marshaled to
+// binary in different tag order. Instead, trust that TextMarshaler with
+// ExpandAny option works and compare the text marshaling results.
+func anyEqual(got, want proto.Message) bool {
+       // if messages are proto.Equal, no need to marshal.
+       if proto.Equal(got, want) {
+               return true
+       }
+       g := expandedMarshaler.Text(got)
+       w := expandedMarshaler.Text(want)
+       return g == w
+}
+
+type golden struct {
+       m    proto.Message
+       t, c string
+}
+
+var goldenMessages = makeGolden()
+
+func makeGolden() []golden {
+       nested := &pb.Nested{Bunny: "Monty"}
+       nb, err := proto.Marshal(nested)
+       if err != nil {
+               panic(err)
+       }
+       m1 := &pb.Message{
+               Name:        "David",
+               ResultCount: 47,
+               Anything:    &types.Any{TypeUrl: "type.googleapis.com/" + proto.MessageName(nested), Value: nb},
+       }
+       m2 := &pb.Message{
+               Name:        "David",
+               ResultCount: 47,
+               Anything:    &types.Any{TypeUrl: "http://[::1]/type.googleapis.com/" + proto.MessageName(nested), Value: nb},
+       }
+       m3 := &pb.Message{
+               Name:        "David",
+               ResultCount: 47,
+               Anything:    &types.Any{TypeUrl: `type.googleapis.com/"/` + proto.MessageName(nested), Value: nb},
+       }
+       m4 := &pb.Message{
+               Name:        "David",
+               ResultCount: 47,
+               Anything:    &types.Any{TypeUrl: "type.googleapis.com/a/path/" + proto.MessageName(nested), Value: nb},
+       }
+       m5 := &types.Any{TypeUrl: "type.googleapis.com/" + proto.MessageName(nested), Value: nb}
+
+       any1 := &testpb.MyMessage{Count: proto.Int32(47), Name: proto.String("David")}
+       proto.SetExtension(any1, testpb.E_Ext_More, &testpb.Ext{Data: proto.String("foo")})
+       proto.SetExtension(any1, testpb.E_Ext_Text, proto.String("bar"))
+       any1b, err := proto.Marshal(any1)
+       if err != nil {
+               panic(err)
+       }
+       any2 := &testpb.MyMessage{Count: proto.Int32(42), Bikeshed: testpb.MyMessage_GREEN.Enum(), RepBytes: [][]byte{[]byte("roboto")}}
+       proto.SetExtension(any2, testpb.E_Ext_More, &testpb.Ext{Data: proto.String("baz")})
+       any2b, err := proto.Marshal(any2)
+       if err != nil {
+               panic(err)
+       }
+       m6 := &pb.Message{
+               Name:        "David",
+               ResultCount: 47,
+               Anything:    &types.Any{TypeUrl: "type.googleapis.com/" + proto.MessageName(any1), Value: any1b},
+               ManyThings: []*types.Any{
+                       {TypeUrl: "type.googleapis.com/" + proto.MessageName(any2), Value: any2b},
+                       {TypeUrl: "type.googleapis.com/" + proto.MessageName(any1), Value: any1b},
+               },
+       }
+
+       const (
+               m1Golden = `
+name: "David"
+result_count: 47
+anything: <
+  [type.googleapis.com/proto3_proto.Nested]: <
+    bunny: "Monty"
+  >
+>
+`
+               m2Golden = `
+name: "David"
+result_count: 47
+anything: <
+  ["http://[::1]/type.googleapis.com/proto3_proto.Nested"]: <
+    bunny: "Monty"
+  >
+>
+`
+               m3Golden = `
+name: "David"
+result_count: 47
+anything: <
+  ["type.googleapis.com/\"/proto3_proto.Nested"]: <
+    bunny: "Monty"
+  >
+>
+`
+               m4Golden = `
+name: "David"
+result_count: 47
+anything: <
+  [type.googleapis.com/a/path/proto3_proto.Nested]: <
+    bunny: "Monty"
+  >
+>
+`
+               m5Golden = `
+[type.googleapis.com/proto3_proto.Nested]: <
+  bunny: "Monty"
+>
+`
+               m6Golden = `
+name: "David"
+result_count: 47
+anything: <
+  [type.googleapis.com/test_proto.MyMessage]: <
+    count: 47
+    name: "David"
+    [test_proto.Ext.more]: <
+      data: "foo"
+    >
+    [test_proto.Ext.text]: "bar"
+  >
+>
+many_things: <
+  [type.googleapis.com/test_proto.MyMessage]: <
+    count: 42
+    bikeshed: GREEN
+    rep_bytes: "roboto"
+    [test_proto.Ext.more]: <
+      data: "baz"
+    >
+  >
+>
+many_things: <
+  [type.googleapis.com/test_proto.MyMessage]: <
+    count: 47
+    name: "David"
+    [test_proto.Ext.more]: <
+      data: "foo"
+    >
+    [test_proto.Ext.text]: "bar"
+  >
+>
+`
+       )
+       return []golden{
+               {m1, strings.TrimSpace(m1Golden) + "\n", strings.TrimSpace(compact(m1Golden)) + " "},
+               {m2, strings.TrimSpace(m2Golden) + "\n", strings.TrimSpace(compact(m2Golden)) + " "},
+               {m3, strings.TrimSpace(m3Golden) + "\n", strings.TrimSpace(compact(m3Golden)) + " "},
+               {m4, strings.TrimSpace(m4Golden) + "\n", strings.TrimSpace(compact(m4Golden)) + " "},
+               {m5, strings.TrimSpace(m5Golden) + "\n", strings.TrimSpace(compact(m5Golden)) + " "},
+               {m6, strings.TrimSpace(m6Golden) + "\n", strings.TrimSpace(compact(m6Golden)) + " "},
+       }
+}
+
+func TestMarshalGolden(t *testing.T) {
+       for _, tt := range goldenMessages {
+               if got, want := expandedMarshaler.Text(tt.m), tt.t; got != want {
+                       t.Errorf("message %v: got:\n%s\nwant:\n%s", tt.m, got, want)
+               }
+               if got, want := expandedCompactMarshaler.Text(tt.m), tt.c; got != want {
+                       t.Errorf("message %v: got:\n`%s`\nwant:\n`%s`", tt.m, got, want)
+               }
+       }
+}
+
+func TestUnmarshalGolden(t *testing.T) {
+       for _, tt := range goldenMessages {
+               want := tt.m
+               got := proto.Clone(tt.m)
+               got.Reset()
+               if err := proto.UnmarshalText(tt.t, got); err != nil {
+                       t.Errorf("failed to unmarshal\n%s\nerror: %v", tt.t, err)
+               }
+               if !anyEqual(got, want) {
+                       t.Errorf("message:\n%s\ngot:\n%s\nwant:\n%s", tt.t, got, want)
+               }
+               got.Reset()
+               if err := proto.UnmarshalText(tt.c, got); err != nil {
+                       t.Errorf("failed to unmarshal\n%s\nerror: %v", tt.c, err)
+               }
+               if !anyEqual(got, want) {
+                       t.Errorf("message:\n%s\ngot:\n%s\nwant:\n%s", tt.c, got, want)
+               }
+       }
+}
+
+func TestMarshalUnknownAny(t *testing.T) {
+       m := &pb.Message{
+               Anything: &types.Any{
+                       TypeUrl: "foo",
+                       Value:   []byte("bar"),
+               },
+       }
+       want := `anything: <
+  type_url: "foo"
+  value: "bar"
+>
+`
+       got := expandedMarshaler.Text(m)
+       if got != want {
+               t.Errorf("got\n`%s`\nwant\n`%s`", got, want)
+       }
+}
+
+func TestAmbiguousAny(t *testing.T) {
+       pb := &types.Any{}
+       err := proto.UnmarshalText(`
+       type_url: "ttt/proto3_proto.Nested"
+       value: "\n\x05Monty"
+       `, pb)
+       t.Logf("result: %v (error: %v)", expandedMarshaler.Text(pb), err)
+       if err != nil {
+               t.Errorf("failed to parse ambiguous Any message: %v", err)
+       }
+}
+
+func TestUnmarshalOverwriteAny(t *testing.T) {
+       pb := &types.Any{}
+       err := proto.UnmarshalText(`
+  [type.googleapis.com/a/path/proto3_proto.Nested]: <
+    bunny: "Monty"
+  >
+  [type.googleapis.com/a/path/proto3_proto.Nested]: <
+    bunny: "Rabbit of Caerbannog"
+  >
+       `, pb)
+       want := `line 7: Any message unpacked multiple times, or "type_url" already set`
+       if err.Error() != want {
+               t.Errorf("incorrect error.\nHave: %v\nWant: %v", err.Error(), want)
+       }
+}
+
+func TestUnmarshalAnyMixAndMatch(t *testing.T) {
+       pb := &types.Any{}
+       err := proto.UnmarshalText(`
+       value: "\n\x05Monty"
+  [type.googleapis.com/a/path/proto3_proto.Nested]: <
+    bunny: "Rabbit of Caerbannog"
+  >
+       `, pb)
+       want := `line 5: Any message unpacked multiple times, or "value" already set`
+       if err.Error() != want {
+               t.Errorf("incorrect error.\nHave: %v\nWant: %v", err.Error(), want)
+       }
+}

diff --git a/vendor/github.com/gogo/protobuf/proto/clone.go b/vendor/github.com/gogo/protobuf/proto/clone.go
new file mode 100644 (file)
index 0000000..a26b046
--- /dev/null
+++ b/vendor/github.com/gogo/protobuf/proto/clone.go
@@ -0,0 +1,258 @@
+// Go support for Protocol Buffers - Google's data interchange format
+//
+// Copyright 2011 The Go Authors.  All rights reserved.
+// https://github.com/golang/protobuf
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//     * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//     * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//     * Neither the name of Google Inc. nor the names of its
+// contributors may be used to endorse or promote products derived from
+// this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+// Protocol buffer deep copy and merge.
+// TODO: RawMessage.
+
+package proto
+
+import (
+       "fmt"
+       "log"
+       "reflect"
+       "strings"
+)
+
+// Clone returns a deep copy of a protocol buffer.
+func Clone(src Message) Message {
+       in := reflect.ValueOf(src)
+       if in.IsNil() {
+               return src
+       }
+       out := reflect.New(in.Type().Elem())
+       dst := out.Interface().(Message)
+       Merge(dst, src)
+       return dst
+}
+
+// Merger is the interface representing objects that can merge messages of the same type.
+type Merger interface {
+       // Merge merges src into this message.
+       // Required and optional fields that are set in src will be set to that value in dst.
+       // Elements of repeated fields will be appended.
+       //
+       // Merge may panic if called with a different argument type than the receiver.
+       Merge(src Message)
+}
+
+// generatedMerger is the custom merge method that generated protos will have.
+// We must add this method since a generate Merge method will conflict with
+// many existing protos that have a Merge data field already defined.
+type generatedMerger interface {
+       XXX_Merge(src Message)
+}
+
+// Merge merges src into dst.
+// Required and optional fields that are set in src will be set to that value in dst.
+// Elements of repeated fields will be appended.
+// Merge panics if src and dst are not the same type, or if dst is nil.
+func Merge(dst, src Message) {
+       if m, ok := dst.(Merger); ok {
+               m.Merge(src)
+               return
+       }
+
+       in := reflect.ValueOf(src)
+       out := reflect.ValueOf(dst)
+       if out.IsNil() {
+               panic("proto: nil destination")
+       }
+       if in.Type() != out.Type() {
+               panic(fmt.Sprintf("proto.Merge(%T, %T) type mismatch", dst, src))
+       }
+       if in.IsNil() {
+               return // Merge from nil src is a noop
+       }
+       if m, ok := dst.(generatedMerger); ok {
+               m.XXX_Merge(src)
+               return
+       }
+       mergeStruct(out.Elem(), in.Elem())
+}
+
+func mergeStruct(out, in reflect.Value) {
+       sprop := GetProperties(in.Type())
+       for i := 0; i < in.NumField(); i++ {
+               f := in.Type().Field(i)
+               if strings.HasPrefix(f.Name, "XXX_") {
+                       continue
+               }
+               mergeAny(out.Field(i), in.Field(i), false, sprop.Prop[i])
+       }
+
+       if emIn, ok := in.Addr().Interface().(extensionsBytes); ok {
+               emOut := out.Addr().Interface().(extensionsBytes)
+               bIn := emIn.GetExtensions()
+               bOut := emOut.GetExtensions()
+               *bOut = append(*bOut, *bIn...)
+       } else if emIn, err := extendable(in.Addr().Interface()); err == nil {
+               emOut, _ := extendable(out.Addr().Interface())
+               mIn, muIn := emIn.extensionsRead()
+               if mIn != nil {
+                       mOut := emOut.extensionsWrite()
+                       muIn.Lock()
+                       mergeExtension(mOut, mIn)
+                       muIn.Unlock()
+               }
+       }
+
+       uf := in.FieldByName("XXX_unrecognized")
+       if !uf.IsValid() {
+               return
+       }
+       uin := uf.Bytes()
+       if len(uin) > 0 {
+               out.FieldByName("XXX_unrecognized").SetBytes(append([]byte(nil), uin...))
+       }
+}
+
+// mergeAny performs a merge between two values of the same type.
+// viaPtr indicates whether the values were indirected through a pointer (implying proto2).
+// prop is set if this is a struct field (it may be nil).
+func mergeAny(out, in reflect.Value, viaPtr bool, prop *Properties) {
+       if in.Type() == protoMessageType {
+               if !in.IsNil() {
+                       if out.IsNil() {
+                               out.Set(reflect.ValueOf(Clone(in.Interface().(Message))))
+                       } else {
+                               Merge(out.Interface().(Message), in.Interface().(Message))
+                       }
+               }
+               return
+       }
+       switch in.Kind() {
+       case reflect.Bool, reflect.Float32, reflect.Float64, reflect.Int32, reflect.Int64,
+               reflect.String, reflect.Uint32, reflect.Uint64:
+               if !viaPtr && isProto3Zero(in) {
+                       return
+               }
+               out.Set(in)
+       case reflect.Interface:
+               // Probably a oneof field; copy non-nil values.
+               if in.IsNil() {
+                       return
+               }
+               // Allocate destination if it is not set, or set to a different type.
+               // Otherwise we will merge as normal.
+               if out.IsNil() || out.Elem().Type() != in.Elem().Type() {
+                       out.Set(reflect.New(in.Elem().Elem().Type())) // interface -> *T -> T -> new(T)
+               }
+               mergeAny(out.Elem(), in.Elem(), false, nil)
+       case reflect.Map:
+               if in.Len() == 0 {
+                       return
+               }
+               if out.IsNil() {
+                       out.Set(reflect.MakeMap(in.Type()))
+               }
+               // For maps with value types of *T or []byte we need to deep copy each value.
+               elemKind := in.Type().Elem().Kind()
+               for _, key := range in.MapKeys() {
+                       var val reflect.Value
+                       switch elemKind {
+                       case reflect.Ptr:
+                               val = reflect.New(in.Type().Elem().Elem())
+                               mergeAny(val, in.MapIndex(key), false, nil)
+                       case reflect.Slice:
+                               val = in.MapIndex(key)
+                               val = reflect.ValueOf(append([]byte{}, val.Bytes()...))
+                       default:
+                               val = in.MapIndex(key)
+                       }
+                       out.SetMapIndex(key, val)
+               }
+       case reflect.Ptr:
+               if in.IsNil() {
+                       return
+               }
+               if out.IsNil() {
+                       out.Set(reflect.New(in.Elem().Type()))
+               }
+               mergeAny(out.Elem(), in.Elem(), true, nil)
+       case reflect.Slice:
+               if in.IsNil() {
+                       return
+               }
+               if in.Type().Elem().Kind() == reflect.Uint8 {
+                       // []byte is a scalar bytes field, not a repeated field.
+
+                       // Edge case: if this is in a proto3 message, a zero length
+                       // bytes field is considered the zero value, and should not
+                       // be merged.
+                       if prop != nil && prop.proto3 && in.Len() == 0 {
+                               return
+                       }
+
+                       // Make a deep copy.
+                       // Append to []byte{} instead of []byte(nil) so that we never end up
+                       // with a nil result.
+                       out.SetBytes(append([]byte{}, in.Bytes()...))
+                       return
+               }
+               n := in.Len()
+               if out.IsNil() {
+                       out.Set(reflect.MakeSlice(in.Type(), 0, n))
+               }
+               switch in.Type().Elem().Kind() {
+               case reflect.Bool, reflect.Float32, reflect.Float64, reflect.Int32, reflect.Int64,
+                       reflect.String, reflect.Uint32, reflect.Uint64:
+                       out.Set(reflect.AppendSlice(out, in))
+               default:
+                       for i := 0; i < n; i++ {
+                               x := reflect.Indirect(reflect.New(in.Type().Elem()))
+                               mergeAny(x, in.Index(i), false, nil)
+                               out.Set(reflect.Append(out, x))
+                       }
+               }
+       case reflect.Struct:
+               mergeStruct(out, in)
+       default:
+               // unknown type, so not a protocol buffer
+               log.Printf("proto: don't know how to copy %v", in)
+       }
+}
+
+func mergeExtension(out, in map[int32]Extension) {
+       for extNum, eIn := range in {
+               eOut := Extension{desc: eIn.desc}
+               if eIn.value != nil {
+                       v := reflect.New(reflect.TypeOf(eIn.value)).Elem()
+                       mergeAny(v, reflect.ValueOf(eIn.value), false, nil)
+                       eOut.value = v.Interface()
+               }
+               if eIn.enc != nil {
+                       eOut.enc = make([]byte, len(eIn.enc))
+                       copy(eOut.enc, eIn.enc)
+               }
+
+               out[extNum] = eOut
+       }
+}

diff --git a/vendor/github.com/gogo/protobuf/proto/clone_test.go b/vendor/github.com/gogo/protobuf/proto/clone_test.go
new file mode 100644 (file)
index 0000000..ac4b919
--- /dev/null
+++ b/vendor/github.com/gogo/protobuf/proto/clone_test.go
@@ -0,0 +1,397 @@
+// Go support for Protocol Buffers - Google's data interchange format
+//
+// Copyright 2011 The Go Authors.  All rights reserved.
+// https://github.com/golang/protobuf
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//     * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//     * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//     * Neither the name of Google Inc. nor the names of its
+// contributors may be used to endorse or promote products derived from
+// this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+package proto_test
+
+import (
+       "testing"
+
+       "github.com/gogo/protobuf/proto"
+
+       proto3pb "github.com/gogo/protobuf/proto/proto3_proto"
+       pb "github.com/gogo/protobuf/proto/test_proto"
+)
+
+var cloneTestMessage = &pb.MyMessage{
+       Count: proto.Int32(42),
+       Name:  proto.String("Dave"),
+       Pet:   []string{"bunny", "kitty", "horsey"},
+       Inner: &pb.InnerMessage{
+               Host:      proto.String("niles"),
+               Port:      proto.Int32(9099),
+               Connected: proto.Bool(true),
+       },
+       Others: []*pb.OtherMessage{
+               {
+                       Value: []byte("some bytes"),
+               },
+       },
+       Somegroup: &pb.MyMessage_SomeGroup{
+               GroupField: proto.Int32(6),
+       },
+       RepBytes: [][]byte{[]byte("sham"), []byte("wow")},
+}
+
+func init() {
+       ext := &pb.Ext{
+               Data: proto.String("extension"),
+       }
+       if err := proto.SetExtension(cloneTestMessage, pb.E_Ext_More, ext); err != nil {
+               panic("SetExtension: " + err.Error())
+       }
+}
+
+func TestClone(t *testing.T) {
+       m := proto.Clone(cloneTestMessage).(*pb.MyMessage)
+       if !proto.Equal(m, cloneTestMessage) {
+               t.Fatalf("Clone(%v) = %v", cloneTestMessage, m)
+       }
+
+       // Verify it was a deep copy.
+       *m.Inner.Port++
+       if proto.Equal(m, cloneTestMessage) {
+               t.Error("Mutating clone changed the original")
+       }
+       // Byte fields and repeated fields should be copied.
+       if &m.Pet[0] == &cloneTestMessage.Pet[0] {
+               t.Error("Pet: repeated field not copied")
+       }
+       if &m.Others[0] == &cloneTestMessage.Others[0] {
+               t.Error("Others: repeated field not copied")
+       }
+       if &m.Others[0].Value[0] == &cloneTestMessage.Others[0].Value[0] {
+               t.Error("Others[0].Value: bytes field not copied")
+       }
+       if &m.RepBytes[0] == &cloneTestMessage.RepBytes[0] {
+               t.Error("RepBytes: repeated field not copied")
+       }
+       if &m.RepBytes[0][0] == &cloneTestMessage.RepBytes[0][0] {
+               t.Error("RepBytes[0]: bytes field not copied")
+       }
+}
+
+func TestCloneNil(t *testing.T) {
+       var m *pb.MyMessage
+       if c := proto.Clone(m); !proto.Equal(m, c) {
+               t.Errorf("Clone(%v) = %v", m, c)
+       }
+}
+
+var mergeTests = []struct {
+       src, dst, want proto.Message
+}{
+       {
+               src: &pb.MyMessage{
+                       Count: proto.Int32(42),
+               },
+               dst: &pb.MyMessage{
+                       Name: proto.String("Dave"),
+               },
+               want: &pb.MyMessage{
+                       Count: proto.Int32(42),
+                       Name:  proto.String("Dave"),
+               },
+       },
+       {
+               src: &pb.MyMessage{
+                       Inner: &pb.InnerMessage{
+                               Host:      proto.String("hey"),
+                               Connected: proto.Bool(true),
+                       },
+                       Pet: []string{"horsey"},
+                       Others: []*pb.OtherMessage{
+                               {
+                                       Value: []byte("some bytes"),
+                               },
+                       },
+               },
+               dst: &pb.MyMessage{
+                       Inner: &pb.InnerMessage{
+                               Host: proto.String("niles"),
+                               Port: proto.Int32(9099),
+                       },
+                       Pet: []string{"bunny", "kitty"},
+                       Others: []*pb.OtherMessage{
+                               {
+                                       Key: proto.Int64(31415926535),
+                               },
+                               {
+                                       // Explicitly test a src=nil field
+                                       Inner: nil,
+                               },
+                       },
+               },
+               want: &pb.MyMessage{
+                       Inner: &pb.InnerMessage{
+                               Host:      proto.String("hey"),
+                               Connected: proto.Bool(true),
+                               Port:      proto.Int32(9099),
+                       },
+                       Pet: []string{"bunny", "kitty", "horsey"},
+                       Others: []*pb.OtherMessage{
+                               {
+                                       Key: proto.Int64(31415926535),
+                               },
+                               {},
+                               {
+                                       Value: []byte("some bytes"),
+                               },
+                       },
+               },
+       },
+       {
+               src: &pb.MyMessage{
+                       RepBytes: [][]byte{[]byte("wow")},
+               },
+               dst: &pb.MyMessage{
+                       Somegroup: &pb.MyMessage_SomeGroup{
+                               GroupField: proto.Int32(6),
+                       },
+                       RepBytes: [][]byte{[]byte("sham")},
+               },
+               want: &pb.MyMessage{
+                       Somegroup: &pb.MyMessage_SomeGroup{
+                               GroupField: proto.Int32(6),
+                       },
+                       RepBytes: [][]byte{[]byte("sham"), []byte("wow")},
+               },
+       },
+       // Check that a scalar bytes field replaces rather than appends.
+       {
+               src:  &pb.OtherMessage{Value: []byte("foo")},
+               dst:  &pb.OtherMessage{Value: []byte("bar")},
+               want: &pb.OtherMessage{Value: []byte("foo")},
+       },
+       {
+               src: &pb.MessageWithMap{
+                       NameMapping: map[int32]string{6: "Nigel"},
+                       MsgMapping: map[int64]*pb.FloatingPoint{
+                               0x4001: {F: proto.Float64(2.0)},
+                               0x4002: {
+                                       F: proto.Float64(2.0),
+                               },
+                       },
+                       ByteMapping: map[bool][]byte{true: []byte("wowsa")},
+               },
+               dst: &pb.MessageWithMap{
+                       NameMapping: map[int32]string{
+                               6: "Bruce", // should be overwritten
+                               7: "Andrew",
+                       },
+                       MsgMapping: map[int64]*pb.FloatingPoint{
+                               0x4002: {
+                                       F:     proto.Float64(3.0),
+                                       Exact: proto.Bool(true),
+                               }, // the entire message should be overwritten
+                       },
+               },
+               want: &pb.MessageWithMap{
+                       NameMapping: map[int32]string{
+                               6: "Nigel",
+                               7: "Andrew",
+                       },
+                       MsgMapping: map[int64]*pb.FloatingPoint{
+                               0x4001: {F: proto.Float64(2.0)},
+                               0x4002: {
+                                       F: proto.Float64(2.0),
+                               },
+                       },
+                       ByteMapping: map[bool][]byte{true: []byte("wowsa")},
+               },
+       },
+       // proto3 shouldn't merge zero values,
+       // in the same way that proto2 shouldn't merge nils.
+       {
+               src: &proto3pb.Message{
+                       Name: "Aaron",
+                       Data: []byte(""), // zero value, but not nil
+               },
+               dst: &proto3pb.Message{
+                       HeightInCm: 176,
+                       Data:       []byte("texas!"),
+               },
+               want: &proto3pb.Message{
+                       Name:       "Aaron",
+                       HeightInCm: 176,
+                       Data:       []byte("texas!"),
+               },
+       },
+       // Oneof fields should merge by assignment.
+       {
+               src: &pb.Communique{
+                       Union: &pb.Communique_Number{Number: 41},
+               },
+               dst: &pb.Communique{
+                       Union: &pb.Communique_Name{Name: "Bobby Tables"},
+               },
+               want: &pb.Communique{
+                       Union: &pb.Communique_Number{Number: 41},
+               },
+       },
+       { // Oneof nil is the same as not set.
+               src:  &pb.Communique{},
+               dst:  &pb.Communique{Union: &pb.Communique_Name{Name: "Bobby Tables"}},
+               want: &pb.Communique{Union: &pb.Communique_Name{Name: "Bobby Tables"}},
+       },
+       {
+               src:  &pb.Communique{Union: &pb.Communique_Number{Number: 1337}},
+               dst:  &pb.Communique{},
+               want: &pb.Communique{Union: &pb.Communique_Number{Number: 1337}},
+       },
+       {
+               src:  &pb.Communique{Union: &pb.Communique_Col{Col: pb.MyMessage_RED}},
+               dst:  &pb.Communique{},
+               want: &pb.Communique{Union: &pb.Communique_Col{Col: pb.MyMessage_RED}},
+       },
+       {
+               src:  &pb.Communique{Union: &pb.Communique_Data{Data: []byte("hello")}},
+               dst:  &pb.Communique{},
+               want: &pb.Communique{Union: &pb.Communique_Data{Data: []byte("hello")}},
+       },
+       {
+               src:  &pb.Communique{Union: &pb.Communique_Msg{Msg: &pb.Strings{BytesField: []byte{1, 2, 3}}}},
+               dst:  &pb.Communique{},
+               want: &pb.Communique{Union: &pb.Communique_Msg{Msg: &pb.Strings{BytesField: []byte{1, 2, 3}}}},
+       },
+       {
+               src:  &pb.Communique{Union: &pb.Communique_Msg{}},
+               dst:  &pb.Communique{},
+               want: &pb.Communique{Union: &pb.Communique_Msg{}},
+       },
+       {
+               src:  &pb.Communique{Union: &pb.Communique_Msg{Msg: &pb.Strings{StringField: proto.String("123")}}},
+               dst:  &pb.Communique{Union: &pb.Communique_Msg{Msg: &pb.Strings{BytesField: []byte{1, 2, 3}}}},
+               want: &pb.Communique{Union: &pb.Communique_Msg{Msg: &pb.Strings{StringField: proto.String("123"), BytesField: []byte{1, 2, 3}}}},
+       },
+       {
+               src: &proto3pb.Message{
+                       Terrain: map[string]*proto3pb.Nested{
+                               "kay_a": {Cute: true},      // replace
+                               "kay_b": {Bunny: "rabbit"}, // insert
+                       },
+               },
+               dst: &proto3pb.Message{
+                       Terrain: map[string]*proto3pb.Nested{
+                               "kay_a": {Bunny: "lost"},  // replaced
+                               "kay_c": {Bunny: "bunny"}, // keep
+                       },
+               },
+               want: &proto3pb.Message{
+                       Terrain: map[string]*proto3pb.Nested{
+                               "kay_a": {Cute: true},
+                               "kay_b": {Bunny: "rabbit"},
+                               "kay_c": {Bunny: "bunny"},
+                       },
+               },
+       },
+       {
+               src: &pb.GoTest{
+                       F_BoolRepeated:   []bool{},
+                       F_Int32Repeated:  []int32{},
+                       F_Int64Repeated:  []int64{},
+                       F_Uint32Repeated: []uint32{},
+                       F_Uint64Repeated: []uint64{},
+                       F_FloatRepeated:  []float32{},
+                       F_DoubleRepeated: []float64{},
+                       F_StringRepeated: []string{},
+                       F_BytesRepeated:  [][]byte{},
+               },
+               dst: &pb.GoTest{},
+               want: &pb.GoTest{
+                       F_BoolRepeated:   []bool{},
+                       F_Int32Repeated:  []int32{},
+                       F_Int64Repeated:  []int64{},
+                       F_Uint32Repeated: []uint32{},
+                       F_Uint64Repeated: []uint64{},
+                       F_FloatRepeated:  []float32{},
+                       F_DoubleRepeated: []float64{},
+                       F_StringRepeated: []string{},
+                       F_BytesRepeated:  [][]byte{},
+               },
+       },
+       {
+               src: &pb.GoTest{},
+               dst: &pb.GoTest{
+                       F_BoolRepeated:   []bool{},
+                       F_Int32Repeated:  []int32{},
+                       F_Int64Repeated:  []int64{},
+                       F_Uint32Repeated: []uint32{},
+                       F_Uint64Repeated: []uint64{},
+                       F_FloatRepeated:  []float32{},
+                       F_DoubleRepeated: []float64{},
+                       F_StringRepeated: []string{},
+                       F_BytesRepeated:  [][]byte{},
+               },
+               want: &pb.GoTest{
+                       F_BoolRepeated:   []bool{},
+                       F_Int32Repeated:  []int32{},
+                       F_Int64Repeated:  []int64{},
+                       F_Uint32Repeated: []uint32{},
+                       F_Uint64Repeated: []uint64{},
+                       F_FloatRepeated:  []float32{},
+                       F_DoubleRepeated: []float64{},
+                       F_StringRepeated: []string{},
+                       F_BytesRepeated:  [][]byte{},
+               },
+       },
+       {
+               src: &pb.GoTest{
+                       F_BytesRepeated: [][]byte{nil, {}, {0}},
+               },
+               dst: &pb.GoTest{},
+               want: &pb.GoTest{
+                       F_BytesRepeated: [][]byte{nil, {}, {0}},
+               },
+       },
+       {
+               src: &pb.MyMessage{
+                       Others: []*pb.OtherMessage{},
+               },
+               dst: &pb.MyMessage{},
+               want: &pb.MyMessage{
+                       Others: []*pb.OtherMessage{},
+               },
+       },
+}
+
+func TestMerge(t *testing.T) {
+       for _, m := range mergeTests {
+               got := proto.Clone(m.dst)
+               if !proto.Equal(got, m.dst) {
+                       t.Errorf("Clone()\ngot  %v\nwant %v", got, m.dst)
+                       continue
+               }
+               proto.Merge(got, m.src)
+               if !proto.Equal(got, m.want) {
+                       t.Errorf("Merge(%v, %v)\ngot  %v\nwant %v", m.dst, m.src, got, m.want)
+               }
+       }
+}

diff --git a/vendor/github.com/gogo/protobuf/proto/custom_gogo.go b/vendor/github.com/gogo/protobuf/proto/custom_gogo.go
new file mode 100644 (file)
index 0000000..2455248
--- /dev/null
+++ b/vendor/github.com/gogo/protobuf/proto/custom_gogo.go
@@ -0,0 +1,39 @@
+// Protocol Buffers for Go with Gadgets
+//
+// Copyright (c) 2018, The GoGo Authors. All rights reserved.
+// http://github.com/gogo/protobuf
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//     * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//     * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+package proto
+
+import "reflect"
+
+type custom interface {
+       Marshal() ([]byte, error)
+       Unmarshal(data []byte) error
+       Size() int
+}
+
+var customType = reflect.TypeOf((*custom)(nil)).Elem()

diff --git a/vendor/github.com/gogo/protobuf/proto/decode.go b/vendor/github.com/gogo/protobuf/proto/decode.go
new file mode 100644 (file)
index 0000000..63b0f08
--- /dev/null
+++ b/vendor/github.com/gogo/protobuf/proto/decode.go
@@ -0,0 +1,427 @@
+// Go support for Protocol Buffers - Google's data interchange format
+//
+// Copyright 2010 The Go Authors.  All rights reserved.
+// https://github.com/golang/protobuf
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//     * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//     * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//     * Neither the name of Google Inc. nor the names of its
+// contributors may be used to endorse or promote products derived from
+// this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+package proto
+
+/*
+ * Routines for decoding protocol buffer data to construct in-memory representations.
+ */
+
+import (
+       "errors"
+       "fmt"
+       "io"
+)
+
+// errOverflow is returned when an integer is too large to be represented.
+var errOverflow = errors.New("proto: integer overflow")
+
+// ErrInternalBadWireType is returned by generated code when an incorrect
+// wire type is encountered. It does not get returned to user code.
+var ErrInternalBadWireType = errors.New("proto: internal error: bad wiretype for oneof")
+
+// DecodeVarint reads a varint-encoded integer from the slice.
+// It returns the integer and the number of bytes consumed, or
+// zero if there is not enough.
+// This is the format for the
+// int32, int64, uint32, uint64, bool, and enum
+// protocol buffer types.
+func DecodeVarint(buf []byte) (x uint64, n int) {
+       for shift := uint(0); shift < 64; shift += 7 {
+               if n >= len(buf) {
+                       return 0, 0
+               }
+               b := uint64(buf[n])
+               n++
+               x |= (b & 0x7F) << shift
+               if (b & 0x80) == 0 {
+                       return x, n
+               }
+       }
+
+       // The number is too large to represent in a 64-bit value.
+       return 0, 0
+}
+
+func (p *Buffer) decodeVarintSlow() (x uint64, err error) {
+       i := p.index
+       l := len(p.buf)
+
+       for shift := uint(0); shift < 64; shift += 7 {
+               if i >= l {
+                       err = io.ErrUnexpectedEOF
+                       return
+               }
+               b := p.buf[i]
+               i++
+               x |= (uint64(b) & 0x7F) << shift
+               if b < 0x80 {
+                       p.index = i
+                       return
+               }
+       }
+
+       // The number is too large to represent in a 64-bit value.
+       err = errOverflow
+       return
+}
+
+// DecodeVarint reads a varint-encoded integer from the Buffer.
+// This is the format for the
+// int32, int64, uint32, uint64, bool, and enum
+// protocol buffer types.
+func (p *Buffer) DecodeVarint() (x uint64, err error) {
+       i := p.index
+       buf := p.buf
+
+       if i >= len(buf) {
+               return 0, io.ErrUnexpectedEOF
+       } else if buf[i] < 0x80 {
+               p.index++
+               return uint64(buf[i]), nil
+       } else if len(buf)-i < 10 {
+               return p.decodeVarintSlow()
+       }
+
+       var b uint64
+       // we already checked the first byte
+       x = uint64(buf[i]) - 0x80
+       i++
+
+       b = uint64(buf[i])
+       i++
+       x += b << 7
+       if b&0x80 == 0 {
+               goto done
+       }
+       x -= 0x80 << 7
+
+       b = uint64(buf[i])
+       i++
+       x += b << 14
+       if b&0x80 == 0 {
+               goto done
+       }
+       x -= 0x80 << 14
+
+       b = uint64(buf[i])
+       i++
+       x += b << 21
+       if b&0x80 == 0 {
+               goto done
+       }
+       x -= 0x80 << 21
+
+       b = uint64(buf[i])
+       i++
+       x += b << 28
+       if b&0x80 == 0 {
+               goto done
+       }
+       x -= 0x80 << 28
+
+       b = uint64(buf[i])
+       i++
+       x += b << 35
+       if b&0x80 == 0 {
+               goto done
+       }
+       x -= 0x80 << 35
+
+       b = uint64(buf[i])
+       i++
+       x += b << 42
+       if b&0x80 == 0 {
+               goto done
+       }
+       x -= 0x80 << 42
+
+       b = uint64(buf[i])
+       i++
+       x += b << 49
+       if b&0x80 == 0 {
+               goto done
+       }
+       x -= 0x80 << 49
+
+       b = uint64(buf[i])
+       i++
+       x += b << 56
+       if b&0x80 == 0 {
+               goto done
+       }
+       x -= 0x80 << 56
+
+       b = uint64(buf[i])
+       i++
+       x += b << 63
+       if b&0x80 == 0 {
+               goto done
+       }
+
+       return 0, errOverflow
+
+done:
+       p.index = i
+       return x, nil
+}
+
+// DecodeFixed64 reads a 64-bit integer from the Buffer.
+// This is the format for the
+// fixed64, sfixed64, and double protocol buffer types.
+func (p *Buffer) DecodeFixed64() (x uint64, err error) {
+       // x, err already 0
+       i := p.index + 8
+       if i < 0 || i > len(p.buf) {
+               err = io.ErrUnexpectedEOF
+               return
+       }
+       p.index = i
+
+       x = uint64(p.buf[i-8])
+       x |= uint64(p.buf[i-7]) << 8
+       x |= uint64(p.buf[i-6]) << 16
+       x |= uint64(p.buf[i-5]) << 24
+       x |= uint64(p.buf[i-4]) << 32
+       x |= uint64(p.buf[i-3]) << 40
+       x |= uint64(p.buf[i-2]) << 48
+       x |= uint64(p.buf[i-1]) << 56
+       return
+}
+
+// DecodeFixed32 reads a 32-bit integer from the Buffer.
+// This is the format for the
+// fixed32, sfixed32, and float protocol buffer types.
+func (p *Buffer) DecodeFixed32() (x uint64, err error) {
+       // x, err already 0
+       i := p.index + 4
+       if i < 0 || i > len(p.buf) {
+               err = io.ErrUnexpectedEOF
+               return
+       }
+       p.index = i
+
+       x = uint64(p.buf[i-4])
+       x |= uint64(p.buf[i-3]) << 8
+       x |= uint64(p.buf[i-2]) << 16
+       x |= uint64(p.buf[i-1]) << 24
+       return
+}
+
+// DecodeZigzag64 reads a zigzag-encoded 64-bit integer
+// from the Buffer.
+// This is the format used for the sint64 protocol buffer type.
+func (p *Buffer) DecodeZigzag64() (x uint64, err error) {
+       x, err = p.DecodeVarint()
+       if err != nil {
+               return
+       }
+       x = (x >> 1) ^ uint64((int64(x&1)<<63)>>63)
+       return
+}
+
+// DecodeZigzag32 reads a zigzag-encoded 32-bit integer
+// from  the Buffer.
+// This is the format used for the sint32 protocol buffer type.
+func (p *Buffer) DecodeZigzag32() (x uint64, err error) {
+       x, err = p.DecodeVarint()
+       if err != nil {
+               return
+       }
+       x = uint64((uint32(x) >> 1) ^ uint32((int32(x&1)<<31)>>31))
+       return
+}
+
+// DecodeRawBytes reads a count-delimited byte buffer from the Buffer.
+// This is the format used for the bytes protocol buffer
+// type and for embedded messages.
+func (p *Buffer) DecodeRawBytes(alloc bool) (buf []byte, err error) {
+       n, err := p.DecodeVarint()
+       if err != nil {
+               return nil, err
+       }
+
+       nb := int(n)
+       if nb < 0 {
+               return nil, fmt.Errorf("proto: bad byte length %d", nb)
+       }
+       end := p.index + nb
+       if end < p.index || end > len(p.buf) {
+               return nil, io.ErrUnexpectedEOF
+       }
+
+       if !alloc {
+               // todo: check if can get more uses of alloc=false
+               buf = p.buf[p.index:end]
+               p.index += nb
+               return
+       }
+
+       buf = make([]byte, nb)
+       copy(buf, p.buf[p.index:])
+       p.index += nb
+       return
+}
+
+// DecodeStringBytes reads an encoded string from the Buffer.
+// This is the format used for the proto2 string type.
+func (p *Buffer) DecodeStringBytes() (s string, err error) {
+       buf, err := p.DecodeRawBytes(false)
+       if err != nil {
+               return
+       }
+       return string(buf), nil
+}
+
+// Unmarshaler is the interface representing objects that can
+// unmarshal themselves.  The argument points to data that may be
+// overwritten, so implementations should not keep references to the
+// buffer.
+// Unmarshal implementations should not clear the receiver.
+// Any unmarshaled data should be merged into the receiver.
+// Callers of Unmarshal that do not want to retain existing data
+// should Reset the receiver before calling Unmarshal.
+type Unmarshaler interface {
+       Unmarshal([]byte) error
+}
+
+// newUnmarshaler is the interface representing objects that can
+// unmarshal themselves. The semantics are identical to Unmarshaler.
+//
+// This exists to support protoc-gen-go generated messages.
+// The proto package will stop type-asserting to this interface in the future.
+//
+// DO NOT DEPEND ON THIS.
+type newUnmarshaler interface {
+       XXX_Unmarshal([]byte) error
+}
+
+// Unmarshal parses the protocol buffer representation in buf and places the
+// decoded result in pb.  If the struct underlying pb does not match
+// the data in buf, the results can be unpredictable.
+//
+// Unmarshal resets pb before starting to unmarshal, so any
+// existing data in pb is always removed. Use UnmarshalMerge
+// to preserve and append to existing data.
+func Unmarshal(buf []byte, pb Message) error {
+       pb.Reset()
+       if u, ok := pb.(newUnmarshaler); ok {
+               return u.XXX_Unmarshal(buf)
+       }
+       if u, ok := pb.(Unmarshaler); ok {
+               return u.Unmarshal(buf)
+       }
+       return NewBuffer(buf).Unmarshal(pb)
+}
+
+// UnmarshalMerge parses the protocol buffer representation in buf and
+// writes the decoded result to pb.  If the struct underlying pb does not match
+// the data in buf, the results can be unpredictable.
+//
+// UnmarshalMerge merges into existing data in pb.
+// Most code should use Unmarshal instead.
+func UnmarshalMerge(buf []byte, pb Message) error {
+       if u, ok := pb.(newUnmarshaler); ok {
+               return u.XXX_Unmarshal(buf)
+       }
+       if u, ok := pb.(Unmarshaler); ok {
+               // NOTE: The history of proto have unfortunately been inconsistent
+               // whether Unmarshaler should or should not implicitly clear itself.
+               // Some implementations do, most do not.
+               // Thus, calling this here may or may not do what people want.
+               //
+               // See https://github.com/golang/protobuf/issues/424
+               return u.Unmarshal(buf)
+       }
+       return NewBuffer(buf).Unmarshal(pb)
+}
+
+// DecodeMessage reads a count-delimited message from the Buffer.
+func (p *Buffer) DecodeMessage(pb Message) error {
+       enc, err := p.DecodeRawBytes(false)
+       if err != nil {
+               return err
+       }
+       return NewBuffer(enc).Unmarshal(pb)
+}
+
+// DecodeGroup reads a tag-delimited group from the Buffer.
+// StartGroup tag is already consumed. This function consumes
+// EndGroup tag.
+func (p *Buffer) DecodeGroup(pb Message) error {
+       b := p.buf[p.index:]
+       x, y := findEndGroup(b)
+       if x < 0 {
+               return io.ErrUnexpectedEOF
+       }
+       err := Unmarshal(b[:x], pb)
+       p.index += y
+       return err
+}
+
+// Unmarshal parses the protocol buffer representation in the
+// Buffer and places the decoded result in pb.  If the struct
+// underlying pb does not match the data in the buffer, the results can be
+// unpredictable.
+//
+// Unlike proto.Unmarshal, this does not reset pb before starting to unmarshal.
+func (p *Buffer) Unmarshal(pb Message) error {
+       // If the object can unmarshal itself, let it.
+       if u, ok := pb.(newUnmarshaler); ok {
+               err := u.XXX_Unmarshal(p.buf[p.index:])
+               p.index = len(p.buf)
+               return err
+       }
+       if u, ok := pb.(Unmarshaler); ok {
+               // NOTE: The history of proto have unfortunately been inconsistent
+               // whether Unmarshaler should or should not implicitly clear itself.
+               // Some implementations do, most do not.
+               // Thus, calling this here may or may not do what people want.
+               //
+               // See https://github.com/golang/protobuf/issues/424
+               err := u.Unmarshal(p.buf[p.index:])
+               p.index = len(p.buf)
+               return err
+       }
+
+       // Slow workaround for messages that aren't Unmarshalers.
+       // This includes some hand-coded .pb.go files and
+       // bootstrap protos.
+       // TODO: fix all of those and then add Unmarshal to
+       // the Message interface. Then:
+       // The cast above and code below can be deleted.
+       // The old unmarshaler can be deleted.
+       // Clients can call Unmarshal directly (can already do that, actually).
+       var info InternalMessageInfo
+       err := info.Unmarshal(pb, p.buf[p.index:])
+       p.index = len(p.buf)
+       return err
+}

diff --git a/vendor/github.com/gogo/protobuf/proto/decode_test.go b/vendor/github.com/gogo/protobuf/proto/decode_test.go
new file mode 100644 (file)
index 0000000..03c5d0d
--- /dev/null
+++ b/vendor/github.com/gogo/protobuf/proto/decode_test.go
@@ -0,0 +1,259 @@
+// Go support for Protocol Buffers - Google's data interchange format
+//
+// Copyright 2010 The Go Authors.  All rights reserved.
+// https://github.com/golang/protobuf
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//     * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//     * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//     * Neither the name of Google Inc. nor the names of its
+// contributors may be used to endorse or promote products derived from
+// this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+// +build go1.7
+
+package proto_test
+
+import (
+       "testing"
+
+       "github.com/gogo/protobuf/proto"
+       tpb "github.com/gogo/protobuf/proto/proto3_proto"
+)
+
+var msgBlackhole = new(tpb.Message)
+
+// Disabled this Benchmark because it is using features (b.Run) from go1.7 and gogoprotobuf still have compatibility with go1.5
+// BenchmarkVarint32ArraySmall shows the performance on an array of small int32 fields (1 and
+// 2 bytes long).
+// func BenchmarkVarint32ArraySmall(b *testing.B) {
+//     for i := uint(1); i <= 10; i++ {
+//             dist := genInt32Dist([7]int{0, 3, 1}, 1<<i)
+//             raw, err := proto.Marshal(&tpb.Message{
+//                     ShortKey: dist,
+//             })
+//             if err != nil {
+//                     b.Error("wrong encode", err)
+//             }
+//             b.Run(fmt.Sprintf("Len%v", len(dist)), func(b *testing.B) {
+//                     scratchBuf := proto.NewBuffer(nil)
+//                     b.ResetTimer()
+//                     for k := 0; k < b.N; k++ {
+//                             scratchBuf.SetBuf(raw)
+//                             msgBlackhole.Reset()
+//                             if err := scratchBuf.Unmarshal(msgBlackhole); err != nil {
+//                                     b.Error("wrong decode", err)
+//                             }
+//                     }
+//             })
+//     }
+// }
+
+// Disabled this Benchmark because it is using features (b.Run) from go1.7 and gogoprotobuf still have compatibility with go1.5
+// BenchmarkVarint32ArrayLarge shows the performance on an array of large int32 fields (3 and
+// 4 bytes long, with a small number of 1, 2, 5 and 10 byte long versions).
+// func BenchmarkVarint32ArrayLarge(b *testing.B) {
+//     for i := uint(1); i <= 10; i++ {
+//             dist := genInt32Dist([7]int{0, 1, 2, 4, 8, 1, 1}, 1<<i)
+//             raw, err := proto.Marshal(&tpb.Message{
+//                     ShortKey: dist,
+//             })
+//             if err != nil {
+//                     b.Error("wrong encode", err)
+//             }
+//             b.Run(fmt.Sprintf("Len%v", len(dist)), func(b *testing.B) {
+//                     scratchBuf := proto.NewBuffer(nil)
+//                     b.ResetTimer()
+//                     for k := 0; k < b.N; k++ {
+//                             scratchBuf.SetBuf(raw)
+//                             msgBlackhole.Reset()
+//                             if err := scratchBuf.Unmarshal(msgBlackhole); err != nil {
+//                                     b.Error("wrong decode", err)
+//                             }
+//                     }
+//             })
+//     }
+// }
+
+// Disabled this Benchmark because it is using features (b.Run) from go1.7 and gogoprotobuf still have compatibility with go1.5
+// BenchmarkVarint64ArraySmall shows the performance on an array of small int64 fields (1 and
+// 2 bytes long).
+// func BenchmarkVarint64ArraySmall(b *testing.B) {
+//     for i := uint(1); i <= 10; i++ {
+//             dist := genUint64Dist([11]int{0, 3, 1}, 1<<i)
+//             raw, err := proto.Marshal(&tpb.Message{
+//                     Key: dist,
+//             })
+//             if err != nil {
+//                     b.Error("wrong encode", err)
+//             }
+//             b.Run(fmt.Sprintf("Len%v", len(dist)), func(b *testing.B) {
+//                     scratchBuf := proto.NewBuffer(nil)
+//                     b.ResetTimer()
+//                     for k := 0; k < b.N; k++ {
+//                             scratchBuf.SetBuf(raw)
+//                             msgBlackhole.Reset()
+//                             if err := scratchBuf.Unmarshal(msgBlackhole); err != nil {
+//                                     b.Error("wrong decode", err)
+//                             }
+//                     }
+//             })
+//     }
+// }
+
+// Disabled this Benchmark because it is using features (b.Run) from go1.7 and gogoprotobuf still have compatibility with go1.5
+// BenchmarkVarint64ArrayLarge shows the performance on an array of large int64 fields (6, 7,
+// and 8 bytes long with a small number of the other sizes).
+// func BenchmarkVarint64ArrayLarge(b *testing.B) {
+//     for i := uint(1); i <= 10; i++ {
+//             dist := genUint64Dist([11]int{0, 1, 1, 2, 4, 8, 16, 32, 16, 1, 1}, 1<<i)
+//             raw, err := proto.Marshal(&tpb.Message{
+//                     Key: dist,
+//             })
+//             if err != nil {
+//                     b.Error("wrong encode", err)
+//             }
+//             b.Run(fmt.Sprintf("Len%v", len(dist)), func(b *testing.B) {
+//                     scratchBuf := proto.NewBuffer(nil)
+//                     b.ResetTimer()
+//                     for k := 0; k < b.N; k++ {
+//                             scratchBuf.SetBuf(raw)
+//                             msgBlackhole.Reset()
+//                             if err := scratchBuf.Unmarshal(msgBlackhole); err != nil {
+//                                     b.Error("wrong decode", err)
+//                             }
+//                     }
+//             })
+//     }
+// }
+
+// Disabled this Benchmark because it is using features (b.Run) from go1.7 and gogoprotobuf still have compatibility with go1.5
+// BenchmarkVarint64ArrayMixed shows the performance of lots of small messages, each
+// containing a small number of large (3, 4, and 5 byte) repeated int64s.
+// func BenchmarkVarint64ArrayMixed(b *testing.B) {
+//     for i := uint(1); i <= 1<<5; i <<= 1 {
+//             dist := genUint64Dist([11]int{0, 0, 0, 4, 6, 4, 0, 0, 0, 0, 0}, int(i))
+//             // number of sub fields
+//             for k := uint(1); k <= 1<<10; k <<= 2 {
+//                     msg := &tpb.Message{}
+//                     for m := uint(0); m < k; m++ {
+//                             msg.Children = append(msg.Children, &tpb.Message{
+//                                     Key: dist,
+//                             })
+//                     }
+//                     raw, err := proto.Marshal(msg)
+//                     if err != nil {
+//                             b.Error("wrong encode", err)
+//                     }
+//                     b.Run(fmt.Sprintf("Fields%vLen%v", k, i), func(b *testing.B) {
+//                             scratchBuf := proto.NewBuffer(nil)
+//                             b.ResetTimer()
+//                             for k := 0; k < b.N; k++ {
+//                                     scratchBuf.SetBuf(raw)
+//                                     msgBlackhole.Reset()
+//                                     if err := scratchBuf.Unmarshal(msgBlackhole); err != nil {
+//                                             b.Error("wrong decode", err)
+//                                     }
+//                             }
+//                     })
+//             }
+//     }
+// }
+
+// genInt32Dist generates a slice of ints that will match the size distribution of dist.
+// A size of 6 corresponds to a max length varint32, which is 10 bytes.  The distribution
+// is 1-indexed. (i.e. the value at index 1 is how many 1 byte ints to create).
+func genInt32Dist(dist [7]int, count int) (dest []int32) {
+       for i := 0; i < count; i++ {
+               for k := 0; k < len(dist); k++ {
+                       var num int32
+                       switch k {
+                       case 1:
+                               num = 1<<7 - 1
+                       case 2:
+                               num = 1<<14 - 1
+                       case 3:
+                               num = 1<<21 - 1
+                       case 4:
+                               num = 1<<28 - 1
+                       case 5:
+                               num = 1<<29 - 1
+                       case 6:
+                               num = -1
+                       }
+                       for m := 0; m < dist[k]; m++ {
+                               dest = append(dest, num)
+                       }
+               }
+       }
+       return
+}
+
+// genUint64Dist generates a slice of ints that will match the size distribution of dist.
+// The distribution is 1-indexed. (i.e. the value at index 1 is how many 1 byte ints to create).
+func genUint64Dist(dist [11]int, count int) (dest []uint64) {
+       for i := 0; i < count; i++ {
+               for k := 0; k < len(dist); k++ {
+                       var num uint64
+                       switch k {
+                       case 1:
+                               num = 1<<7 - 1
+                       case 2:
+                               num = 1<<14 - 1
+                       case 3:
+                               num = 1<<21 - 1
+                       case 4:
+                               num = 1<<28 - 1
+                       case 5:
+                               num = 1<<35 - 1
+                       case 6:
+                               num = 1<<42 - 1
+                       case 7:
+                               num = 1<<49 - 1
+                       case 8:
+                               num = 1<<56 - 1
+                       case 9:
+                               num = 1<<63 - 1
+                       case 10:
+                               num = 1<<64 - 1
+                       }
+                       for m := 0; m < dist[k]; m++ {
+                               dest = append(dest, num)
+                       }
+               }
+       }
+       return
+}
+
+// BenchmarkDecodeEmpty measures the overhead of doing the minimal possible decode.
+func BenchmarkDecodeEmpty(b *testing.B) {
+       raw, err := proto.Marshal(&tpb.Message{})
+       if err != nil {
+               b.Error("wrong encode", err)
+       }
+       b.ResetTimer()
+       for i := 0; i < b.N; i++ {
+               if err := proto.Unmarshal(raw, msgBlackhole); err != nil {
+                       b.Error("wrong decode", err)
+               }
+       }
+}

diff --git a/vendor/github.com/gogo/protobuf/proto/deprecated.go b/vendor/github.com/gogo/protobuf/proto/deprecated.go
new file mode 100644 (file)
index 0000000..35b882c
--- /dev/null
+++ b/vendor/github.com/gogo/protobuf/proto/deprecated.go
@@ -0,0 +1,63 @@
+// Go support for Protocol Buffers - Google's data interchange format
+//
+// Copyright 2018 The Go Authors.  All rights reserved.
+// https://github.com/golang/protobuf
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//     * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//     * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//     * Neither the name of Google Inc. nor the names of its
+// contributors may be used to endorse or promote products derived from
+// this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+package proto
+
+import "errors"
+
+// Deprecated: do not use.
+type Stats struct{ Emalloc, Dmalloc, Encode, Decode, Chit, Cmiss, Size uint64 }
+
+// Deprecated: do not use.
+func GetStats() Stats { return Stats{} }
+
+// Deprecated: do not use.
+func MarshalMessageSet(interface{}) ([]byte, error) {
+       return nil, errors.New("proto: not implemented")
+}
+
+// Deprecated: do not use.
+func UnmarshalMessageSet([]byte, interface{}) error {
+       return errors.New("proto: not implemented")
+}
+
+// Deprecated: do not use.
+func MarshalMessageSetJSON(interface{}) ([]byte, error) {
+       return nil, errors.New("proto: not implemented")
+}
+
+// Deprecated: do not use.
+func UnmarshalMessageSetJSON([]byte, interface{}) error {
+       return errors.New("proto: not implemented")
+}
+
+// Deprecated: do not use.
+func RegisterMessageSetType(Message, int32, string) {}

diff --git a/vendor/github.com/gogo/protobuf/proto/discard.go b/vendor/github.com/gogo/protobuf/proto/discard.go
new file mode 100644 (file)
index 0000000..fe1bd7d
--- /dev/null
+++ b/vendor/github.com/gogo/protobuf/proto/discard.go
@@ -0,0 +1,350 @@
+// Go support for Protocol Buffers - Google's data interchange format
+//
+// Copyright 2017 The Go Authors.  All rights reserved.
+// https://github.com/golang/protobuf
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//     * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//     * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//     * Neither the name of Google Inc. nor the names of its
+// contributors may be used to endorse or promote products derived from
+// this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+package proto
+
+import (
+       "fmt"
+       "reflect"
+       "strings"
+       "sync"
+       "sync/atomic"
+)
+
+type generatedDiscarder interface {
+       XXX_DiscardUnknown()
+}
+
+// DiscardUnknown recursively discards all unknown fields from this message
+// and all embedded messages.
+//
+// When unmarshaling a message with unrecognized fields, the tags and values
+// of such fields are preserved in the Message. This allows a later call to
+// marshal to be able to produce a message that continues to have those
+// unrecognized fields. To avoid this, DiscardUnknown is used to
+// explicitly clear the unknown fields after unmarshaling.
+//
+// For proto2 messages, the unknown fields of message extensions are only
+// discarded from messages that have been accessed via GetExtension.
+func DiscardUnknown(m Message) {
+       if m, ok := m.(generatedDiscarder); ok {
+               m.XXX_DiscardUnknown()
+               return
+       }
+       // TODO: Dynamically populate a InternalMessageInfo for legacy messages,
+       // but the master branch has no implementation for InternalMessageInfo,
+       // so it would be more work to replicate that approach.
+       discardLegacy(m)
+}
+
+// DiscardUnknown recursively discards all unknown fields.
+func (a *InternalMessageInfo) DiscardUnknown(m Message) {
+       di := atomicLoadDiscardInfo(&a.discard)
+       if di == nil {
+               di = getDiscardInfo(reflect.TypeOf(m).Elem())
+               atomicStoreDiscardInfo(&a.discard, di)
+       }
+       di.discard(toPointer(&m))
+}
+
+type discardInfo struct {
+       typ reflect.Type
+
+       initialized int32 // 0: only typ is valid, 1: everything is valid
+       lock        sync.Mutex
+
+       fields       []discardFieldInfo
+       unrecognized field
+}
+
+type discardFieldInfo struct {
+       field   field // Offset of field, guaranteed to be valid
+       discard func(src pointer)
+}
+
+var (
+       discardInfoMap  = map[reflect.Type]*discardInfo{}
+       discardInfoLock sync.Mutex
+)
+
+func getDiscardInfo(t reflect.Type) *discardInfo {
+       discardInfoLock.Lock()
+       defer discardInfoLock.Unlock()
+       di := discardInfoMap[t]
+       if di == nil {
+               di = &discardInfo{typ: t}
+               discardInfoMap[t] = di
+       }
+       return di
+}
+
+func (di *discardInfo) discard(src pointer) {
+       if src.isNil() {
+               return // Nothing to do.
+       }
+
+       if atomic.LoadInt32(&di.initialized) == 0 {
+               di.computeDiscardInfo()
+       }
+
+       for _, fi := range di.fields {
+               sfp := src.offset(fi.field)
+               fi.discard(sfp)
+       }
+
+       // For proto2 messages, only discard unknown fields in message extensions
+       // that have been accessed via GetExtension.
+       if em, err := extendable(src.asPointerTo(di.typ).Interface()); err == nil {
+               // Ignore lock since DiscardUnknown is not concurrency safe.
+               emm, _ := em.extensionsRead()
+               for _, mx := range emm {
+                       if m, ok := mx.value.(Message); ok {
+                               DiscardUnknown(m)
+                       }
+               }
+       }
+
+       if di.unrecognized.IsValid() {
+               *src.offset(di.unrecognized).toBytes() = nil
+       }
+}
+
+func (di *discardInfo) computeDiscardInfo() {
+       di.lock.Lock()
+       defer di.lock.Unlock()
+       if di.initialized != 0 {
+               return
+       }
+       t := di.typ
+       n := t.NumField()
+
+       for i := 0; i < n; i++ {
+               f := t.Field(i)
+               if strings.HasPrefix(f.Name, "XXX_") {
+                       continue
+               }
+
+               dfi := discardFieldInfo{field: toField(&f)}
+               tf := f.Type
+
+               // Unwrap tf to get its most basic type.
+               var isPointer, isSlice bool
+               if tf.Kind() == reflect.Slice && tf.Elem().Kind() != reflect.Uint8 {
+                       isSlice = true
+                       tf = tf.Elem()
+               }
+               if tf.Kind() == reflect.Ptr {
+                       isPointer = true
+                       tf = tf.Elem()
+               }
+               if isPointer && isSlice && tf.Kind() != reflect.Struct {
+                       panic(fmt.Sprintf("%v.%s cannot be a slice of pointers to primitive types", t, f.Name))
+               }
+
+               switch tf.Kind() {
+               case reflect.Struct:
+                       switch {
+                       case !isPointer:
+                               panic(fmt.Sprintf("%v.%s cannot be a direct struct value", t, f.Name))
+                       case isSlice: // E.g., []*pb.T
+                               discardInfo := getDiscardInfo(tf)
+                               dfi.discard = func(src pointer) {
+                                       sps := src.getPointerSlice()
+                                       for _, sp := range sps {
+                                               if !sp.isNil() {
+                                                       discardInfo.discard(sp)
+                                               }
+                                       }
+                               }
+                       default: // E.g., *pb.T
+                               discardInfo := getDiscardInfo(tf)
+                               dfi.discard = func(src pointer) {
+                                       sp := src.getPointer()
+                                       if !sp.isNil() {
+                                               discardInfo.discard(sp)
+                                       }
+                               }
+                       }
+               case reflect.Map:
+                       switch {
+                       case isPointer || isSlice:
+                               panic(fmt.Sprintf("%v.%s cannot be a pointer to a map or a slice of map values", t, f.Name))
+                       default: // E.g., map[K]V
+                               if tf.Elem().Kind() == reflect.Ptr { // Proto struct (e.g., *T)
+                                       dfi.discard = func(src pointer) {
+                                               sm := src.asPointerTo(tf).Elem()
+                                               if sm.Len() == 0 {
+                                                       return
+                                               }
+                                               for _, key := range sm.MapKeys() {
+                                                       val := sm.MapIndex(key)
+                                                       DiscardUnknown(val.Interface().(Message))
+                                               }
+                                       }
+                               } else {
+                                       dfi.discard = func(pointer) {} // Noop
+                               }
+                       }
+               case reflect.Interface:
+                       // Must be oneof field.
+                       switch {
+                       case isPointer || isSlice:
+                               panic(fmt.Sprintf("%v.%s cannot be a pointer to a interface or a slice of interface values", t, f.Name))
+                       default: // E.g., interface{}
+                               // TODO: Make this faster?
+                               dfi.discard = func(src pointer) {
+                                       su := src.asPointerTo(tf).Elem()
+                                       if !su.IsNil() {
+                                               sv := su.Elem().Elem().Field(0)
+                                               if sv.Kind() == reflect.Ptr && sv.IsNil() {
+                                                       return
+                                               }
+                                               switch sv.Type().Kind() {
+                                               case reflect.Ptr: // Proto struct (e.g., *T)
+                                                       DiscardUnknown(sv.Interface().(Message))
+                                               }
+                                       }
+                               }
+                       }
+               default:
+                       continue
+               }
+               di.fields = append(di.fields, dfi)
+       }
+
+       di.unrecognized = invalidField
+       if f, ok := t.FieldByName("XXX_unrecognized"); ok {
+               if f.Type != reflect.TypeOf([]byte{}) {
+                       panic("expected XXX_unrecognized to be of type []byte")
+               }
+               di.unrecognized = toField(&f)
+       }
+
+       atomic.StoreInt32(&di.initialized, 1)
+}
+
+func discardLegacy(m Message) {
+       v := reflect.ValueOf(m)
+       if v.Kind() != reflect.Ptr || v.IsNil() {
+               return
+       }
+       v = v.Elem()
+       if v.Kind() != reflect.Struct {
+               return
+       }
+       t := v.Type()
+
+       for i := 0; i < v.NumField(); i++ {
+               f := t.Field(i)
+               if strings.HasPrefix(f.Name, "XXX_") {
+                       continue
+               }
+               vf := v.Field(i)
+               tf := f.Type
+
+               // Unwrap tf to get its most basic type.
+               var isPointer, isSlice bool
+               if tf.Kind() == reflect.Slice && tf.Elem().Kind() != reflect.Uint8 {
+                       isSlice = true
+                       tf = tf.Elem()
+               }
+               if tf.Kind() == reflect.Ptr {
+                       isPointer = true
+                       tf = tf.Elem()
+               }
+               if isPointer && isSlice && tf.Kind() != reflect.Struct {
+                       panic(fmt.Sprintf("%T.%s cannot be a slice of pointers to primitive types", m, f.Name))
+               }
+
+               switch tf.Kind() {
+               case reflect.Struct:
+                       switch {
+                       case !isPointer:
+                               panic(fmt.Sprintf("%T.%s cannot be a direct struct value", m, f.Name))
+                       case isSlice: // E.g., []*pb.T
+                               for j := 0; j < vf.Len(); j++ {
+                                       discardLegacy(vf.Index(j).Interface().(Message))
+                               }
+                       default: // E.g., *pb.T
+                               discardLegacy(vf.Interface().(Message))
+                       }
+               case reflect.Map:
+                       switch {
+                       case isPointer || isSlice:
+                               panic(fmt.Sprintf("%T.%s cannot be a pointer to a map or a slice of map values", m, f.Name))
+                       default: // E.g., map[K]V
+                               tv := vf.Type().Elem()
+                               if tv.Kind() == reflect.Ptr && tv.Implements(protoMessageType) { // Proto struct (e.g., *T)
+                                       for _, key := range vf.MapKeys() {
+                                               val := vf.MapIndex(key)
+                                               discardLegacy(val.Interface().(Message))
+                                       }
+                               }
+                       }
+               case reflect.Interface:
+                       // Must be oneof field.
+                       switch {
+                       case isPointer || isSlice:
+                               panic(fmt.Sprintf("%T.%s cannot be a pointer to a interface or a slice of interface values", m, f.Name))
+                       default: // E.g., test_proto.isCommunique_Union interface
+                               if !vf.IsNil() && f.Tag.Get("protobuf_oneof") != "" {
+                                       vf = vf.Elem() // E.g., *test_proto.Communique_Msg
+                                       if !vf.IsNil() {
+                                               vf = vf.Elem()   // E.g., test_proto.Communique_Msg
+                                               vf = vf.Field(0) // E.g., Proto struct (e.g., *T) or primitive value
+                                               if vf.Kind() == reflect.Ptr {
+                                                       discardLegacy(vf.Interface().(Message))
+                                               }
+                                       }
+                               }
+                       }
+               }
+       }
+
+       if vf := v.FieldByName("XXX_unrecognized"); vf.IsValid() {
+               if vf.Type() != reflect.TypeOf([]byte{}) {
+                       panic("expected XXX_unrecognized to be of type []byte")
+               }
+               vf.Set(reflect.ValueOf([]byte(nil)))
+       }
+
+       // For proto2 messages, only discard unknown fields in message extensions
+       // that have been accessed via GetExtension.
+       if em, err := extendable(m); err == nil {
+               // Ignore lock since discardLegacy is not concurrency safe.
+               emm, _ := em.extensionsRead()
+               for _, mx := range emm {
+                       if m, ok := mx.value.(Message); ok {
+                               discardLegacy(m)
+                       }
+               }
+       }
+}

diff --git a/vendor/github.com/gogo/protobuf/proto/discard_test.go b/vendor/github.com/gogo/protobuf/proto/discard_test.go
new file mode 100644 (file)
index 0000000..2971712
--- /dev/null
+++ b/vendor/github.com/gogo/protobuf/proto/discard_test.go
@@ -0,0 +1,169 @@
+// Go support for Protocol Buffers - Google's data interchange format
+//
+// Copyright 2017 The Go Authors.  All rights reserved.
+// https://github.com/golang/protobuf
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//     * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//     * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//     * Neither the name of Google Inc. nor the names of its
+// contributors may be used to endorse or promote products derived from
+// this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+package proto_test
+
+import (
+       "testing"
+
+       "github.com/gogo/protobuf/proto"
+       proto3pb "github.com/gogo/protobuf/proto/proto3_proto"
+       pb "github.com/gogo/protobuf/proto/test_proto"
+)
+
+func TestDiscardUnknown(t *testing.T) {
+       tests := []struct {
+               desc     string
+               in, want proto.Message
+       }{{
+               desc: "Nil",
+               in:   nil, want: nil, // Should not panic
+       }, {
+               desc: "NilPtr",
+               in:   (*proto3pb.Message)(nil), want: (*proto3pb.Message)(nil), // Should not panic
+       }, {
+               desc: "Nested",
+               in: &proto3pb.Message{
+                       Name:             "Aaron",
+                       Nested:           &proto3pb.Nested{Cute: true, XXX_unrecognized: []byte("blah")},
+                       XXX_unrecognized: []byte("blah"),
+               },
+               want: &proto3pb.Message{
+                       Name:   "Aaron",
+                       Nested: &proto3pb.Nested{Cute: true},
+               },
+       }, {
+               desc: "Slice",
+               in: &proto3pb.Message{
+                       Name: "Aaron",
+                       Children: []*proto3pb.Message{
+                               {Name: "Sarah", XXX_unrecognized: []byte("blah")},
+                               {Name: "Abraham", XXX_unrecognized: []byte("blah")},
+                       },
+                       XXX_unrecognized: []byte("blah"),
+               },
+               want: &proto3pb.Message{
+                       Name: "Aaron",
+                       Children: []*proto3pb.Message{
+                               {Name: "Sarah"},
+                               {Name: "Abraham"},
+                       },
+               },
+       }, {
+               desc: "OneOf",
+               in: &pb.Communique{
+                       Union: &pb.Communique_Msg{Msg: &pb.Strings{
+                               StringField:      proto.String("123"),
+                               XXX_unrecognized: []byte("blah"),
+                       }},
+                       XXX_unrecognized: []byte("blah"),
+               },
+               want: &pb.Communique{
+                       Union: &pb.Communique_Msg{Msg: &pb.Strings{StringField: proto.String("123")}},
+               },
+       }, {
+               desc: "Map",
+               in: &pb.MessageWithMap{MsgMapping: map[int64]*pb.FloatingPoint{
+                       0x4002: {
+                               Exact:            proto.Bool(true),
+                               XXX_unrecognized: []byte("blah"),
+                       },
+               }},
+               want: &pb.MessageWithMap{MsgMapping: map[int64]*pb.FloatingPoint{
+                       0x4002: {Exact: proto.Bool(true)},
+               }},
+       }, {
+               desc: "Extension",
+               in: func() proto.Message {
+                       m := &pb.MyMessage{
+                               Count: proto.Int32(42),
+                               Somegroup: &pb.MyMessage_SomeGroup{
+                                       GroupField:       proto.Int32(6),
+                                       XXX_unrecognized: []byte("blah"),
+                               },
+                               XXX_unrecognized: []byte("blah"),
+                       }
+                       proto.SetExtension(m, pb.E_Ext_More, &pb.Ext{
+                               Data:             proto.String("extension"),
+                               XXX_unrecognized: []byte("blah"),
+                       })
+                       return m
+               }(),
+               want: func() proto.Message {
+                       m := &pb.MyMessage{
+                               Count:     proto.Int32(42),
+                               Somegroup: &pb.MyMessage_SomeGroup{GroupField: proto.Int32(6)},
+                       }
+                       proto.SetExtension(m, pb.E_Ext_More, &pb.Ext{Data: proto.String("extension")})
+                       return m
+               }(),
+       }}
+
+       // Test the legacy code path.
+       for _, tt := range tests {
+               // Clone the input so that we don't alter the original.
+               in := tt.in
+               if in != nil {
+                       in = proto.Clone(tt.in)
+               }
+
+               var m LegacyMessage
+               m.Message, _ = in.(*proto3pb.Message)
+               m.Communique, _ = in.(*pb.Communique)
+               m.MessageWithMap, _ = in.(*pb.MessageWithMap)
+               m.MyMessage, _ = in.(*pb.MyMessage)
+               proto.DiscardUnknown(&m)
+               if !proto.Equal(in, tt.want) {
+                       t.Errorf("test %s/Legacy, expected unknown fields to be discarded\ngot  %v\nwant %v", tt.desc, in, tt.want)
+               }
+       }
+
+       for _, tt := range tests {
+               proto.DiscardUnknown(tt.in)
+               if !proto.Equal(tt.in, tt.want) {
+                       t.Errorf("test %s, expected unknown fields to be discarded\ngot  %v\nwant %v", tt.desc, tt.in, tt.want)
+               }
+       }
+}
+
+// LegacyMessage is a proto.Message that has several nested messages.
+// This does not have the XXX_DiscardUnknown method and so forces DiscardUnknown
+// to use the legacy fallback logic.
+type LegacyMessage struct {
+       Message        *proto3pb.Message
+       Communique     *pb.Communique
+       MessageWithMap *pb.MessageWithMap
+       MyMessage      *pb.MyMessage
+}
+
+func (m *LegacyMessage) Reset()         { *m = LegacyMessage{} }
+func (m *LegacyMessage) String() string { return proto.CompactTextString(m) }
+func (*LegacyMessage) ProtoMessage()    {}

diff --git a/vendor/github.com/gogo/protobuf/proto/duration.go b/vendor/github.com/gogo/protobuf/proto/duration.go
new file mode 100644 (file)
index 0000000..93464c9
--- /dev/null
+++ b/vendor/github.com/gogo/protobuf/proto/duration.go
@@ -0,0 +1,100 @@
+// Go support for Protocol Buffers - Google's data interchange format
+//
+// Copyright 2016 The Go Authors.  All rights reserved.
+// https://github.com/golang/protobuf
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//     * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//     * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//     * Neither the name of Google Inc. nor the names of its
+// contributors may be used to endorse or promote products derived from
+// this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+package proto
+
+// This file implements conversions between google.protobuf.Duration
+// and time.Duration.
+
+import (
+       "errors"
+       "fmt"
+       "time"
+)
+
+const (
+       // Range of a Duration in seconds, as specified in
+       // google/protobuf/duration.proto. This is about 10,000 years in seconds.
+       maxSeconds = int64(10000 * 365.25 * 24 * 60 * 60)
+       minSeconds = -maxSeconds
+)
+
+// validateDuration determines whether the Duration is valid according to the
+// definition in google/protobuf/duration.proto. A valid Duration
+// may still be too large to fit into a time.Duration (the range of Duration
+// is about 10,000 years, and the range of time.Duration is about 290).
+func validateDuration(d *duration) error {
+       if d == nil {
+               return errors.New("duration: nil Duration")
+       }
+       if d.Seconds < minSeconds || d.Seconds > maxSeconds {
+               return fmt.Errorf("duration: %#v: seconds out of range", d)
+       }
+       if d.Nanos <= -1e9 || d.Nanos >= 1e9 {
+               return fmt.Errorf("duration: %#v: nanos out of range", d)
+       }
+       // Seconds and Nanos must have the same sign, unless d.Nanos is zero.
+       if (d.Seconds < 0 && d.Nanos > 0) || (d.Seconds > 0 && d.Nanos < 0) {
+               return fmt.Errorf("duration: %#v: seconds and nanos have different signs", d)
+       }
+       return nil
+}
+
+// DurationFromProto converts a Duration to a time.Duration. DurationFromProto
+// returns an error if the Duration is invalid or is too large to be
+// represented in a time.Duration.
+func durationFromProto(p *duration) (time.Duration, error) {
+       if err := validateDuration(p); err != nil {
+               return 0, err
+       }
+       d := time.Duration(p.Seconds) * time.Second
+       if int64(d/time.Second) != p.Seconds {
+               return 0, fmt.Errorf("duration: %#v is out of range for time.Duration", p)
+       }
+       if p.Nanos != 0 {
+               d += time.Duration(p.Nanos)
+               if (d < 0) != (p.Nanos < 0) {
+                       return 0, fmt.Errorf("duration: %#v is out of range for time.Duration", p)
+               }
+       }
+       return d, nil
+}
+
+// DurationProto converts a time.Duration to a Duration.
+func durationProto(d time.Duration) *duration {
+       nanos := d.Nanoseconds()
+       secs := nanos / 1e9
+       nanos -= secs * 1e9
+       return &duration{
+               Seconds: secs,
+               Nanos:   int32(nanos),
+       }
+}

diff --git a/vendor/github.com/gogo/protobuf/proto/duration_gogo.go b/vendor/github.com/gogo/protobuf/proto/duration_gogo.go
new file mode 100644 (file)
index 0000000..e748e17
--- /dev/null
+++ b/vendor/github.com/gogo/protobuf/proto/duration_gogo.go
@@ -0,0 +1,49 @@
+// Protocol Buffers for Go with Gadgets
+//
+// Copyright (c) 2016, The GoGo Authors. All rights reserved.
+// http://github.com/gogo/protobuf
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//     * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//     * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+package proto
+
+import (
+       "reflect"
+       "time"
+)
+
+var durationType = reflect.TypeOf((*time.Duration)(nil)).Elem()
+
+type duration struct {
+       Seconds int64 `protobuf:"varint,1,opt,name=seconds,proto3" json:"seconds,omitempty"`
+       Nanos   int32 `protobuf:"varint,2,opt,name=nanos,proto3" json:"nanos,omitempty"`
+}
+
+func (m *duration) Reset()       { *m = duration{} }
+func (*duration) ProtoMessage()  {}
+func (*duration) String() string { return "duration<string>" }
+
+func init() {
+       RegisterType((*duration)(nil), "gogo.protobuf.proto.duration")
+}

diff --git a/vendor/github.com/gogo/protobuf/proto/encode.go b/vendor/github.com/gogo/protobuf/proto/encode.go
new file mode 100644 (file)
index 0000000..3abfed2
--- /dev/null
+++ b/vendor/github.com/gogo/protobuf/proto/encode.go
@@ -0,0 +1,203 @@
+// Go support for Protocol Buffers - Google's data interchange format
+//
+// Copyright 2010 The Go Authors.  All rights reserved.
+// https://github.com/golang/protobuf
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//     * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//     * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//     * Neither the name of Google Inc. nor the names of its
+// contributors may be used to endorse or promote products derived from
+// this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+package proto
+
+/*
+ * Routines for encoding data into the wire format for protocol buffers.
+ */
+
+import (
+       "errors"
+       "reflect"
+)
+
+var (
+       // errRepeatedHasNil is the error returned if Marshal is called with
+       // a struct with a repeated field containing a nil element.
+       errRepeatedHasNil = errors.New("proto: repeated field has nil element")
+
+       // errOneofHasNil is the error returned if Marshal is called with
+       // a struct with a oneof field containing a nil element.
+       errOneofHasNil = errors.New("proto: oneof field has nil value")
+
+       // ErrNil is the error returned if Marshal is called with nil.
+       ErrNil = errors.New("proto: Marshal called with nil")
+
+       // ErrTooLarge is the error returned if Marshal is called with a
+       // message that encodes to >2GB.
+       ErrTooLarge = errors.New("proto: message encodes to over 2 GB")
+)
+
+// The fundamental encoders that put bytes on the wire.
+// Those that take integer types all accept uint64 and are
+// therefore of type valueEncoder.
+
+const maxVarintBytes = 10 // maximum length of a varint
+
+// EncodeVarint returns the varint encoding of x.
+// This is the format for the
+// int32, int64, uint32, uint64, bool, and enum
+// protocol buffer types.
+// Not used by the package itself, but helpful to clients
+// wishing to use the same encoding.
+func EncodeVarint(x uint64) []byte {
+       var buf [maxVarintBytes]byte
+       var n int
+       for n = 0; x > 127; n++ {
+               buf[n] = 0x80 | uint8(x&0x7F)
+               x >>= 7
+       }
+       buf[n] = uint8(x)
+       n++
+       return buf[0:n]
+}
+
+// EncodeVarint writes a varint-encoded integer to the Buffer.
+// This is the format for the
+// int32, int64, uint32, uint64, bool, and enum
+// protocol buffer types.
+func (p *Buffer) EncodeVarint(x uint64) error {
+       for x >= 1<<7 {
+               p.buf = append(p.buf, uint8(x&0x7f|0x80))
+               x >>= 7
+       }
+       p.buf = append(p.buf, uint8(x))
+       return nil
+}
+
+// SizeVarint returns the varint encoding size of an integer.
+func SizeVarint(x uint64) int {
+       switch {
+       case x < 1<<7:
+               return 1
+       case x < 1<<14:
+               return 2
+       case x < 1<<21:
+               return 3
+       case x < 1<<28:
+               return 4
+       case x < 1<<35:
+               return 5
+       case x < 1<<42:
+               return 6
+       case x < 1<<49:
+               return 7
+       case x < 1<<56:
+               return 8
+       case x < 1<<63:
+               return 9
+       }
+       return 10
+}
+
+// EncodeFixed64 writes a 64-bit integer to the Buffer.
+// This is the format for the
+// fixed64, sfixed64, and double protocol buffer types.
+func (p *Buffer) EncodeFixed64(x uint64) error {
+       p.buf = append(p.buf,
+               uint8(x),
+               uint8(x>>8),
+               uint8(x>>16),
+               uint8(x>>24),
+               uint8(x>>32),
+               uint8(x>>40),
+               uint8(x>>48),
+               uint8(x>>56))
+       return nil
+}
+
+// EncodeFixed32 writes a 32-bit integer to the Buffer.
+// This is the format for the
+// fixed32, sfixed32, and float protocol buffer types.
+func (p *Buffer) EncodeFixed32(x uint64) error {
+       p.buf = append(p.buf,
+               uint8(x),
+               uint8(x>>8),
+               uint8(x>>16),
+               uint8(x>>24))
+       return nil
+}
+
+// EncodeZigzag64 writes a zigzag-encoded 64-bit integer
+// to the Buffer.
+// This is the format used for the sint64 protocol buffer type.
+func (p *Buffer) EncodeZigzag64(x uint64) error {
+       // use signed number to get arithmetic right shift.
+       return p.EncodeVarint(uint64((x << 1) ^ uint64((int64(x) >> 63))))
+}
+
+// EncodeZigzag32 writes a zigzag-encoded 32-bit integer
+// to the Buffer.
+// This is the format used for the sint32 protocol buffer type.
+func (p *Buffer) EncodeZigzag32(x uint64) error {
+       // use signed number to get arithmetic right shift.
+       return p.EncodeVarint(uint64((uint32(x) << 1) ^ uint32((int32(x) >> 31))))
+}
+
+// EncodeRawBytes writes a count-delimited byte buffer to the Buffer.
+// This is the format used for the bytes protocol buffer
+// type and for embedded messages.
+func (p *Buffer) EncodeRawBytes(b []byte) error {
+       p.EncodeVarint(uint64(len(b)))
+       p.buf = append(p.buf, b...)
+       return nil
+}
+
+// EncodeStringBytes writes an encoded string to the Buffer.
+// This is the format used for the proto2 string type.
+func (p *Buffer) EncodeStringBytes(s string) error {
+       p.EncodeVarint(uint64(len(s)))
+       p.buf = append(p.buf, s...)
+       return nil
+}
+
+// Marshaler is the interface representing objects that can marshal themselves.
+type Marshaler interface {
+       Marshal() ([]byte, error)
+}
+
+// EncodeMessage writes the protocol buffer to the Buffer,
+// prefixed by a varint-encoded length.
+func (p *Buffer) EncodeMessage(pb Message) error {
+       siz := Size(pb)
+       p.EncodeVarint(uint64(siz))
+       return p.Marshal(pb)
+}
+
+// All protocol buffer fields are nillable, but be careful.
+func isNil(v reflect.Value) bool {
+       switch v.Kind() {
+       case reflect.Interface, reflect.Map, reflect.Ptr, reflect.Slice:
+               return v.IsNil()
+       }
+       return false
+}

diff --git a/vendor/github.com/gogo/protobuf/proto/encode_gogo.go b/vendor/github.com/gogo/protobuf/proto/encode_gogo.go
new file mode 100644 (file)
index 0000000..0f5fb17
--- /dev/null
+++ b/vendor/github.com/gogo/protobuf/proto/encode_gogo.go
@@ -0,0 +1,33 @@
+// Protocol Buffers for Go with Gadgets
+//
+// Copyright (c) 2013, The GoGo Authors. All rights reserved.
+// http://github.com/gogo/protobuf
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//     * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//     * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+package proto
+
+func NewRequiredNotSetError(field string) *RequiredNotSetError {
+       return &RequiredNotSetError{field}
+}

diff --git a/vendor/github.com/gogo/protobuf/proto/encode_test.go b/vendor/github.com/gogo/protobuf/proto/encode_test.go
new file mode 100644 (file)
index 0000000..2176b89
--- /dev/null
+++ b/vendor/github.com/gogo/protobuf/proto/encode_test.go
@@ -0,0 +1,84 @@
+// Go support for Protocol Buffers - Google's data interchange format
+//
+// Copyright 2010 The Go Authors.  All rights reserved.
+// https://github.com/golang/protobuf
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//     * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//     * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//     * Neither the name of Google Inc. nor the names of its
+// contributors may be used to endorse or promote products derived from
+// this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+// +build go1.7
+
+package proto_test
+
+import (
+       "testing"
+
+       "github.com/gogo/protobuf/proto"
+       tpb "github.com/gogo/protobuf/proto/proto3_proto"
+)
+
+var (
+       blackhole []byte
+)
+
+// Disabled this Benchmark because it is using features (b.Run) from go1.7 and gogoprotobuf still have compatibility with go1.5
+// BenchmarkAny creates increasingly large arbitrary Any messages.  The type is always the
+// same.
+// func BenchmarkAny(b *testing.B) {
+//     data := make([]byte, 1<<20)
+//     quantum := 1 << 10
+//     for i := uint(0); i <= 10; i++ {
+//             b.Run(strconv.Itoa(quantum<<i), func(b *testing.B) {
+//                     for k := 0; k < b.N; k++ {
+//                             inner := &tpb.Message{
+//                                     Data: data[:quantum<<i],
+//                             }
+//                             outer, err := types.MarshalAny(inner)
+//                             if err != nil {
+//                                     b.Error("wrong encode", err)
+//                             }
+//                             raw, err := proto.Marshal(&tpb.Message{
+//                                     Anything: outer,
+//                             })
+//                             if err != nil {
+//                                     b.Error("wrong encode", err)
+//                             }
+//                             blackhole = raw
+//                     }
+//             })
+//     }
+// }
+
+// BenchmarkEmpy measures the overhead of doing the minimal possible encode.
+func BenchmarkEmpy(b *testing.B) {
+       for i := 0; i < b.N; i++ {
+               raw, err := proto.Marshal(&tpb.Message{})
+               if err != nil {
+                       b.Error("wrong encode", err)
+               }
+               blackhole = raw
+       }
+}

diff --git a/vendor/github.com/gogo/protobuf/proto/equal.go b/vendor/github.com/gogo/protobuf/proto/equal.go
new file mode 100644 (file)
index 0000000..d4db5a1
--- /dev/null
+++ b/vendor/github.com/gogo/protobuf/proto/equal.go
@@ -0,0 +1,300 @@
+// Go support for Protocol Buffers - Google's data interchange format
+//
+// Copyright 2011 The Go Authors.  All rights reserved.
+// https://github.com/golang/protobuf
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//     * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//     * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//     * Neither the name of Google Inc. nor the names of its
+// contributors may be used to endorse or promote products derived from
+// this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+// Protocol buffer comparison.
+
+package proto
+
+import (
+       "bytes"
+       "log"
+       "reflect"
+       "strings"
+)
+
+/*
+Equal returns true iff protocol buffers a and b are equal.
+The arguments must both be pointers to protocol buffer structs.
+
+Equality is defined in this way:
+  - Two messages are equal iff they are the same type,
+    corresponding fields are equal, unknown field sets
+    are equal, and extensions sets are equal.
+  - Two set scalar fields are equal iff their values are equal.
+    If the fields are of a floating-point type, remember that
+    NaN != x for all x, including NaN. If the message is defined
+    in a proto3 .proto file, fields are not "set"; specifically,
+    zero length proto3 "bytes" fields are equal (nil == {}).
+  - Two repeated fields are equal iff their lengths are the same,
+    and their corresponding elements are equal. Note a "bytes" field,
+    although represented by []byte, is not a repeated field and the
+    rule for the scalar fields described above applies.
+  - Two unset fields are equal.
+  - Two unknown field sets are equal if their current
+    encoded state is equal.
+  - Two extension sets are equal iff they have corresponding
+    elements that are pairwise equal.
+  - Two map fields are equal iff their lengths are the same,
+    and they contain the same set of elements. Zero-length map
+    fields are equal.
+  - Every other combination of things are not equal.
+
+The return value is undefined if a and b are not protocol buffers.
+*/
+func Equal(a, b Message) bool {
+       if a == nil || b == nil {
+               return a == b
+       }
+       v1, v2 := reflect.ValueOf(a), reflect.ValueOf(b)
+       if v1.Type() != v2.Type() {
+               return false
+       }
+       if v1.Kind() == reflect.Ptr {
+               if v1.IsNil() {
+                       return v2.IsNil()
+               }
+               if v2.IsNil() {
+                       return false
+               }
+               v1, v2 = v1.Elem(), v2.Elem()
+       }
+       if v1.Kind() != reflect.Struct {
+               return false
+       }
+       return equalStruct(v1, v2)
+}
+
+// v1 and v2 are known to have the same type.
+func equalStruct(v1, v2 reflect.Value) bool {
+       sprop := GetProperties(v1.Type())
+       for i := 0; i < v1.NumField(); i++ {
+               f := v1.Type().Field(i)
+               if strings.HasPrefix(f.Name, "XXX_") {
+                       continue
+               }
+               f1, f2 := v1.Field(i), v2.Field(i)
+               if f.Type.Kind() == reflect.Ptr {
+                       if n1, n2 := f1.IsNil(), f2.IsNil(); n1 && n2 {
+                               // both unset
+                               continue
+                       } else if n1 != n2 {
+                               // set/unset mismatch
+                               return false
+                       }
+                       f1, f2 = f1.Elem(), f2.Elem()
+               }
+               if !equalAny(f1, f2, sprop.Prop[i]) {
+                       return false
+               }
+       }
+
+       if em1 := v1.FieldByName("XXX_InternalExtensions"); em1.IsValid() {
+               em2 := v2.FieldByName("XXX_InternalExtensions")
+               if !equalExtensions(v1.Type(), em1.Interface().(XXX_InternalExtensions), em2.Interface().(XXX_InternalExtensions)) {
+                       return false
+               }
+       }
+
+       if em1 := v1.FieldByName("XXX_extensions"); em1.IsValid() {
+               em2 := v2.FieldByName("XXX_extensions")
+               if !equalExtMap(v1.Type(), em1.Interface().(map[int32]Extension), em2.Interface().(map[int32]Extension)) {
+                       return false
+               }
+       }
+
+       uf := v1.FieldByName("XXX_unrecognized")
+       if !uf.IsValid() {
+               return true
+       }
+
+       u1 := uf.Bytes()
+       u2 := v2.FieldByName("XXX_unrecognized").Bytes()
+       return bytes.Equal(u1, u2)
+}
+
+// v1 and v2 are known to have the same type.
+// prop may be nil.
+func equalAny(v1, v2 reflect.Value, prop *Properties) bool {
+       if v1.Type() == protoMessageType {
+               m1, _ := v1.Interface().(Message)
+               m2, _ := v2.Interface().(Message)
+               return Equal(m1, m2)
+       }
+       switch v1.Kind() {
+       case reflect.Bool:
+               return v1.Bool() == v2.Bool()
+       case reflect.Float32, reflect.Float64:
+               return v1.Float() == v2.Float()
+       case reflect.Int32, reflect.Int64:
+               return v1.Int() == v2.Int()
+       case reflect.Interface:
+               // Probably a oneof field; compare the inner values.
+               n1, n2 := v1.IsNil(), v2.IsNil()
+               if n1 || n2 {
+                       return n1 == n2
+               }
+               e1, e2 := v1.Elem(), v2.Elem()
+               if e1.Type() != e2.Type() {
+                       return false
+               }
+               return equalAny(e1, e2, nil)
+       case reflect.Map:
+               if v1.Len() != v2.Len() {
+                       return false
+               }
+               for _, key := range v1.MapKeys() {
+                       val2 := v2.MapIndex(key)
+                       if !val2.IsValid() {
+                               // This key was not found in the second map.
+                               return false
+                       }
+                       if !equalAny(v1.MapIndex(key), val2, nil) {
+                               return false
+                       }
+               }
+               return true
+       case reflect.Ptr:
+               // Maps may have nil values in them, so check for nil.
+               if v1.IsNil() && v2.IsNil() {
+                       return true
+               }
+               if v1.IsNil() != v2.IsNil() {
+                       return false
+               }
+               return equalAny(v1.Elem(), v2.Elem(), prop)
+       case reflect.Slice:
+               if v1.Type().Elem().Kind() == reflect.Uint8 {
+                       // short circuit: []byte
+
+                       // Edge case: if this is in a proto3 message, a zero length
+                       // bytes field is considered the zero value.
+                       if prop != nil && prop.proto3 && v1.Len() == 0 && v2.Len() == 0 {
+                               return true
+                       }
+                       if v1.IsNil() != v2.IsNil() {
+                               return false
+                       }
+                       return bytes.Equal(v1.Interface().([]byte), v2.Interface().([]byte))
+               }
+
+               if v1.Len() != v2.Len() {
+                       return false
+               }
+               for i := 0; i < v1.Len(); i++ {
+                       if !equalAny(v1.Index(i), v2.Index(i), prop) {
+                               return false
+                       }
+               }
+               return true
+       case reflect.String:
+               return v1.Interface().(string) == v2.Interface().(string)
+       case reflect.Struct:
+               return equalStruct(v1, v2)
+       case reflect.Uint32, reflect.Uint64:
+               return v1.Uint() == v2.Uint()
+       }
+
+       // unknown type, so not a protocol buffer
+       log.Printf("proto: don't know how to compare %v", v1)
+       return false
+}
+
+// base is the struct type that the extensions are based on.
+// x1 and x2 are InternalExtensions.
+func equalExtensions(base reflect.Type, x1, x2 XXX_InternalExtensions) bool {
+       em1, _ := x1.extensionsRead()
+       em2, _ := x2.extensionsRead()
+       return equalExtMap(base, em1, em2)
+}
+
+func equalExtMap(base reflect.Type, em1, em2 map[int32]Extension) bool {
+       if len(em1) != len(em2) {
+               return false
+       }
+
+       for extNum, e1 := range em1 {
+               e2, ok := em2[extNum]
+               if !ok {
+                       return false
+               }
+
+               m1, m2 := e1.value, e2.value
+
+               if m1 == nil && m2 == nil {
+                       // Both have only encoded form.
+                       if bytes.Equal(e1.enc, e2.enc) {
+                               continue
+                       }
+                       // The bytes are different, but the extensions might still be
+                       // equal. We need to decode them to compare.
+               }
+
+               if m1 != nil && m2 != nil {
+                       // Both are unencoded.
+                       if !equalAny(reflect.ValueOf(m1), reflect.ValueOf(m2), nil) {
+                               return false
+                       }
+                       continue
+               }
+
+               // At least one is encoded. To do a semantically correct comparison
+               // we need to unmarshal them first.
+               var desc *ExtensionDesc
+               if m := extensionMaps[base]; m != nil {
+                       desc = m[extNum]
+               }
+               if desc == nil {
+                       // If both have only encoded form and the bytes are the same,
+                       // it is handled above. We get here when the bytes are different.
+                       // We don't know how to decode it, so just compare them as byte
+                       // slices.
+                       log.Printf("proto: don't know how to compare extension %d of %v", extNum, base)
+                       return false
+               }
+               var err error
+               if m1 == nil {
+                       m1, err = decodeExtension(e1.enc, desc)
+               }
+               if m2 == nil && err == nil {
+                       m2, err = decodeExtension(e2.enc, desc)
+               }
+               if err != nil {
+                       // The encoded form is invalid.
+                       log.Printf("proto: badly encoded extension %d of %v: %v", extNum, base, err)
+                       return false
+               }
+               if !equalAny(reflect.ValueOf(m1), reflect.ValueOf(m2), nil) {
+                       return false
+               }
+       }
+
+       return true
+}

diff --git a/vendor/github.com/gogo/protobuf/proto/equal_test.go b/vendor/github.com/gogo/protobuf/proto/equal_test.go
new file mode 100644 (file)
index 0000000..0d55f39
--- /dev/null
+++ b/vendor/github.com/gogo/protobuf/proto/equal_test.go
@@ -0,0 +1,244 @@
+// Go support for Protocol Buffers - Google's data interchange format
+//
+// Copyright 2011 The Go Authors.  All rights reserved.
+// https://github.com/golang/protobuf
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//     * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//     * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//     * Neither the name of Google Inc. nor the names of its
+// contributors may be used to endorse or promote products derived from
+// this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+package proto_test
+
+import (
+       "testing"
+
+       . "github.com/gogo/protobuf/proto"
+       proto3pb "github.com/gogo/protobuf/proto/proto3_proto"
+       pb "github.com/gogo/protobuf/proto/test_proto"
+)
+
+// Four identical base messages.
+// The init function adds extensions to some of them.
+var messageWithoutExtension = &pb.MyMessage{Count: Int32(7)}
+var messageWithExtension1a = &pb.MyMessage{Count: Int32(7)}
+var messageWithExtension1b = &pb.MyMessage{Count: Int32(7)}
+var messageWithExtension2 = &pb.MyMessage{Count: Int32(7)}
+var messageWithExtension3a = &pb.MyMessage{Count: Int32(7)}
+var messageWithExtension3b = &pb.MyMessage{Count: Int32(7)}
+var messageWithExtension3c = &pb.MyMessage{Count: Int32(7)}
+
+// Two messages with non-message extensions.
+var messageWithInt32Extension1 = &pb.MyMessage{Count: Int32(8)}
+var messageWithInt32Extension2 = &pb.MyMessage{Count: Int32(8)}
+
+func init() {
+       ext1 := &pb.Ext{Data: String("Kirk")}
+       ext2 := &pb.Ext{Data: String("Picard")}
+
+       // messageWithExtension1a has ext1, but never marshals it.
+       if err := SetExtension(messageWithExtension1a, pb.E_Ext_More, ext1); err != nil {
+               panic("SetExtension on 1a failed: " + err.Error())
+       }
+
+       // messageWithExtension1b is the unmarshaled form of messageWithExtension1a.
+       if err := SetExtension(messageWithExtension1b, pb.E_Ext_More, ext1); err != nil {
+               panic("SetExtension on 1b failed: " + err.Error())
+       }
+       buf, err := Marshal(messageWithExtension1b)
+       if err != nil {
+               panic("Marshal of 1b failed: " + err.Error())
+       }
+       messageWithExtension1b.Reset()
+       if err := Unmarshal(buf, messageWithExtension1b); err != nil {
+               panic("Unmarshal of 1b failed: " + err.Error())
+       }
+
+       // messageWithExtension2 has ext2.
+       if err := SetExtension(messageWithExtension2, pb.E_Ext_More, ext2); err != nil {
+               panic("SetExtension on 2 failed: " + err.Error())
+       }
+
+       if err := SetExtension(messageWithInt32Extension1, pb.E_Ext_Number, Int32(23)); err != nil {
+               panic("SetExtension on Int32-1 failed: " + err.Error())
+       }
+       if err := SetExtension(messageWithInt32Extension1, pb.E_Ext_Number, Int32(24)); err != nil {
+               panic("SetExtension on Int32-2 failed: " + err.Error())
+       }
+
+       // messageWithExtension3{a,b,c} has unregistered extension.
+       if RegisteredExtensions(messageWithExtension3a)[200] != nil {
+               panic("expect extension 200 unregistered")
+       }
+       bytes := []byte{
+               0xc0, 0x0c, 0x01, // id=200, wiretype=0 (varint), data=1
+       }
+       bytes2 := []byte{
+               0xc0, 0x0c, 0x02, // id=200, wiretype=0 (varint), data=2
+       }
+       SetRawExtension(messageWithExtension3a, 200, bytes)
+       SetRawExtension(messageWithExtension3b, 200, bytes)
+       SetRawExtension(messageWithExtension3c, 200, bytes2)
+}
+
+var EqualTests = []struct {
+       desc string
+       a, b Message
+       exp  bool
+}{
+       {"different types", &pb.GoEnum{}, &pb.GoTestField{}, false},
+       {"equal empty", &pb.GoEnum{}, &pb.GoEnum{}, true},
+       {"nil vs nil", nil, nil, true},
+       {"typed nil vs typed nil", (*pb.GoEnum)(nil), (*pb.GoEnum)(nil), true},
+       {"typed nil vs empty", (*pb.GoEnum)(nil), &pb.GoEnum{}, false},
+       {"different typed nil", (*pb.GoEnum)(nil), (*pb.GoTestField)(nil), false},
+
+       {"one set field, one unset field", &pb.GoTestField{Label: String("foo")}, &pb.GoTestField{}, false},
+       {"one set field zero, one unset field", &pb.GoTest{Param: Int32(0)}, &pb.GoTest{}, false},
+       {"different set fields", &pb.GoTestField{Label: String("foo")}, &pb.GoTestField{Label: String("bar")}, false},
+       {"equal set", &pb.GoTestField{Label: String("foo")}, &pb.GoTestField{Label: String("foo")}, true},
+
+       {"repeated, one set", &pb.GoTest{F_Int32Repeated: []int32{2, 3}}, &pb.GoTest{}, false},
+       {"repeated, different length", &pb.GoTest{F_Int32Repeated: []int32{2, 3}}, &pb.GoTest{F_Int32Repeated: []int32{2}}, false},
+       {"repeated, different value", &pb.GoTest{F_Int32Repeated: []int32{2}}, &pb.GoTest{F_Int32Repeated: []int32{3}}, false},
+       {"repeated, equal", &pb.GoTest{F_Int32Repeated: []int32{2, 4}}, &pb.GoTest{F_Int32Repeated: []int32{2, 4}}, true},
+       {"repeated, nil equal nil", &pb.GoTest{F_Int32Repeated: nil}, &pb.GoTest{F_Int32Repeated: nil}, true},
+       {"repeated, nil equal empty", &pb.GoTest{F_Int32Repeated: nil}, &pb.GoTest{F_Int32Repeated: []int32{}}, true},
+       {"repeated, empty equal nil", &pb.GoTest{F_Int32Repeated: []int32{}}, &pb.GoTest{F_Int32Repeated: nil}, true},
+
+       {
+               "nested, different",
+               &pb.GoTest{RequiredField: &pb.GoTestField{Label: String("foo")}},
+               &pb.GoTest{RequiredField: &pb.GoTestField{Label: String("bar")}},
+               false,
+       },
+       {
+               "nested, equal",
+               &pb.GoTest{RequiredField: &pb.GoTestField{Label: String("wow")}},
+               &pb.GoTest{RequiredField: &pb.GoTestField{Label: String("wow")}},
+               true,
+       },
+
+       {"bytes", &pb.OtherMessage{Value: []byte("foo")}, &pb.OtherMessage{Value: []byte("foo")}, true},
+       {"bytes, empty", &pb.OtherMessage{Value: []byte{}}, &pb.OtherMessage{Value: []byte{}}, true},
+       {"bytes, empty vs nil", &pb.OtherMessage{Value: []byte{}}, &pb.OtherMessage{Value: nil}, false},
+       {
+               "repeated bytes",
+               &pb.MyMessage{RepBytes: [][]byte{[]byte("sham"), []byte("wow")}},
+               &pb.MyMessage{RepBytes: [][]byte{[]byte("sham"), []byte("wow")}},
+               true,
+       },
+       // In proto3, []byte{} and []byte(nil) are equal.
+       {"proto3 bytes, empty vs nil", &proto3pb.Message{Data: []byte{}}, &proto3pb.Message{Data: nil}, true},
+
+       {"extension vs. no extension", messageWithoutExtension, messageWithExtension1a, false},
+       {"extension vs. same extension", messageWithExtension1a, messageWithExtension1b, true},
+       {"extension vs. different extension", messageWithExtension1a, messageWithExtension2, false},
+
+       {"int32 extension vs. itself", messageWithInt32Extension1, messageWithInt32Extension1, true},
+       {"int32 extension vs. a different int32", messageWithInt32Extension1, messageWithInt32Extension2, false},
+
+       {"unregistered extension same", messageWithExtension3a, messageWithExtension3b, true},
+       {"unregistered extension different", messageWithExtension3a, messageWithExtension3c, false},
+
+       {
+               "message with group",
+               &pb.MyMessage{
+                       Count: Int32(1),
+                       Somegroup: &pb.MyMessage_SomeGroup{
+                               GroupField: Int32(5),
+                       },
+               },
+               &pb.MyMessage{
+                       Count: Int32(1),
+                       Somegroup: &pb.MyMessage_SomeGroup{
+                               GroupField: Int32(5),
+                       },
+               },
+               true,
+       },
+
+       {
+               "map same",
+               &pb.MessageWithMap{NameMapping: map[int32]string{1: "Ken"}},
+               &pb.MessageWithMap{NameMapping: map[int32]string{1: "Ken"}},
+               true,
+       },
+       {
+               "map different entry",
+               &pb.MessageWithMap{NameMapping: map[int32]string{1: "Ken"}},
+               &pb.MessageWithMap{NameMapping: map[int32]string{2: "Rob"}},
+               false,
+       },
+       {
+               "map different key only",
+               &pb.MessageWithMap{NameMapping: map[int32]string{1: "Ken"}},
+               &pb.MessageWithMap{NameMapping: map[int32]string{2: "Ken"}},
+               false,
+       },
+       {
+               "map different value only",
+               &pb.MessageWithMap{NameMapping: map[int32]string{1: "Ken"}},
+               &pb.MessageWithMap{NameMapping: map[int32]string{1: "Rob"}},
+               false,
+       },
+       {
+               "zero-length maps same",
+               &pb.MessageWithMap{NameMapping: map[int32]string{}},
+               &pb.MessageWithMap{NameMapping: nil},
+               true,
+       },
+       {
+               "orders in map don't matter",
+               &pb.MessageWithMap{NameMapping: map[int32]string{1: "Ken", 2: "Rob"}},
+               &pb.MessageWithMap{NameMapping: map[int32]string{2: "Rob", 1: "Ken"}},
+               true,
+       },
+       {
+               "oneof same",
+               &pb.Communique{Union: &pb.Communique_Number{Number: 41}},
+               &pb.Communique{Union: &pb.Communique_Number{Number: 41}},
+               true,
+       },
+       {
+               "oneof one nil",
+               &pb.Communique{Union: &pb.Communique_Number{Number: 41}},
+               &pb.Communique{},
+               false,
+       },
+       {
+               "oneof different",
+               &pb.Communique{Union: &pb.Communique_Number{Number: 41}},
+               &pb.Communique{Union: &pb.Communique_Name{Name: "Bobby Tables"}},
+               false,
+       },
+}
+
+func TestEqual(t *testing.T) {
+       for _, tc := range EqualTests {
+               if res := Equal(tc.a, tc.b); res != tc.exp {
+                       t.Errorf("%v: Equal(%v, %v) = %v, want %v", tc.desc, tc.a, tc.b, res, tc.exp)
+               }
+       }
+}

diff --git a/vendor/github.com/gogo/protobuf/proto/extensions.go b/vendor/github.com/gogo/protobuf/proto/extensions.go
new file mode 100644 (file)
index 0000000..686bd2a
--- /dev/null
+++ b/vendor/github.com/gogo/protobuf/proto/extensions.go
@@ -0,0 +1,604 @@
+// Go support for Protocol Buffers - Google's data interchange format
+//
+// Copyright 2010 The Go Authors.  All rights reserved.
+// https://github.com/golang/protobuf
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//     * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//     * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//     * Neither the name of Google Inc. nor the names of its
+// contributors may be used to endorse or promote products derived from
+// this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+package proto
+
+/*
+ * Types and routines for supporting protocol buffer extensions.
+ */
+
+import (
+       "errors"
+       "fmt"
+       "io"
+       "reflect"
+       "strconv"
+       "sync"
+)
+
+// ErrMissingExtension is the error returned by GetExtension if the named extension is not in the message.
+var ErrMissingExtension = errors.New("proto: missing extension")
+
+// ExtensionRange represents a range of message extensions for a protocol buffer.
+// Used in code generated by the protocol compiler.
+type ExtensionRange struct {
+       Start, End int32 // both inclusive
+}
+
+// extendableProto is an interface implemented by any protocol buffer generated by the current
+// proto compiler that may be extended.
+type extendableProto interface {
+       Message
+       ExtensionRangeArray() []ExtensionRange
+       extensionsWrite() map[int32]Extension
+       extensionsRead() (map[int32]Extension, sync.Locker)
+}
+
+// extendableProtoV1 is an interface implemented by a protocol buffer generated by the previous
+// version of the proto compiler that may be extended.
+type extendableProtoV1 interface {
+       Message
+       ExtensionRangeArray() []ExtensionRange
+       ExtensionMap() map[int32]Extension
+}
+
+// extensionAdapter is a wrapper around extendableProtoV1 that implements extendableProto.
+type extensionAdapter struct {
+       extendableProtoV1
+}
+
+func (e extensionAdapter) extensionsWrite() map[int32]Extension {
+       return e.ExtensionMap()
+}
+
+func (e extensionAdapter) extensionsRead() (map[int32]Extension, sync.Locker) {
+       return e.ExtensionMap(), notLocker{}
+}
+
+// notLocker is a sync.Locker whose Lock and Unlock methods are nops.
+type notLocker struct{}
+
+func (n notLocker) Lock()   {}
+func (n notLocker) Unlock() {}
+
+// extendable returns the extendableProto interface for the given generated proto message.
+// If the proto message has the old extension format, it returns a wrapper that implements
+// the extendableProto interface.
+func extendable(p interface{}) (extendableProto, error) {
+       switch p := p.(type) {
+       case extendableProto:
+               if isNilPtr(p) {
+                       return nil, fmt.Errorf("proto: nil %T is not extendable", p)
+               }
+               return p, nil
+       case extendableProtoV1:
+               if isNilPtr(p) {
+                       return nil, fmt.Errorf("proto: nil %T is not extendable", p)
+               }
+               return extensionAdapter{p}, nil
+       case extensionsBytes:
+               return slowExtensionAdapter{p}, nil
+       }
+       // Don't allocate a specific error containing %T:
+       // this is the hot path for Clone and MarshalText.
+       return nil, errNotExtendable
+}
+
+var errNotExtendable = errors.New("proto: not an extendable proto.Message")
+
+func isNilPtr(x interface{}) bool {
+       v := reflect.ValueOf(x)
+       return v.Kind() == reflect.Ptr && v.IsNil()
+}
+
+// XXX_InternalExtensions is an internal representation of proto extensions.
+//
+// Each generated message struct type embeds an anonymous XXX_InternalExtensions field,
+// thus gaining the unexported 'extensions' method, which can be called only from the proto package.
+//
+// The methods of XXX_InternalExtensions are not concurrency safe in general,
+// but calls to logically read-only methods such as has and get may be executed concurrently.
+type XXX_InternalExtensions struct {
+       // The struct must be indirect so that if a user inadvertently copies a
+       // generated message and its embedded XXX_InternalExtensions, they
+       // avoid the mayhem of a copied mutex.
+       //
+       // The mutex serializes all logically read-only operations to p.extensionMap.
+       // It is up to the client to ensure that write operations to p.extensionMap are
+       // mutually exclusive with other accesses.
+       p *struct {
+               mu           sync.Mutex
+               extensionMap map[int32]Extension
+       }
+}
+
+// extensionsWrite returns the extension map, creating it on first use.
+func (e *XXX_InternalExtensions) extensionsWrite() map[int32]Extension {
+       if e.p == nil {
+               e.p = new(struct {
+                       mu           sync.Mutex
+                       extensionMap map[int32]Extension
+               })
+               e.p.extensionMap = make(map[int32]Extension)
+       }
+       return e.p.extensionMap
+}
+
+// extensionsRead returns the extensions map for read-only use.  It may be nil.
+// The caller must hold the returned mutex's lock when accessing Elements within the map.
+func (e *XXX_InternalExtensions) extensionsRead() (map[int32]Extension, sync.Locker) {
+       if e.p == nil {
+               return nil, nil
+       }
+       return e.p.extensionMap, &e.p.mu
+}
+
+// ExtensionDesc represents an extension specification.
+// Used in generated code from the protocol compiler.
+type ExtensionDesc struct {
+       ExtendedType  Message     // nil pointer to the type that is being extended
+       ExtensionType interface{} // nil pointer to the extension type
+       Field         int32       // field number
+       Name          string      // fully-qualified name of extension, for text formatting
+       Tag           string      // protobuf tag style
+       Filename      string      // name of the file in which the extension is defined
+}
+
+func (ed *ExtensionDesc) repeated() bool {
+       t := reflect.TypeOf(ed.ExtensionType)
+       return t.Kind() == reflect.Slice && t.Elem().Kind() != reflect.Uint8
+}
+
+// Extension represents an extension in a message.
+type Extension struct {
+       // When an extension is stored in a message using SetExtension
+       // only desc and value are set. When the message is marshaled
+       // enc will be set to the encoded form of the message.
+       //
+       // When a message is unmarshaled and contains extensions, each
+       // extension will have only enc set. When such an extension is
+       // accessed using GetExtension (or GetExtensions) desc and value
+       // will be set.
+       desc  *ExtensionDesc
+       value interface{}
+       enc   []byte
+}
+
+// SetRawExtension is for testing only.
+func SetRawExtension(base Message, id int32, b []byte) {
+       if ebase, ok := base.(extensionsBytes); ok {
+               clearExtension(base, id)
+               ext := ebase.GetExtensions()
+               *ext = append(*ext, b...)
+               return
+       }
+       epb, err := extendable(base)
+       if err != nil {
+               return
+       }
+       extmap := epb.extensionsWrite()
+       extmap[id] = Extension{enc: b}
+}
+
+// isExtensionField returns true iff the given field number is in an extension range.
+func isExtensionField(pb extendableProto, field int32) bool {
+       for _, er := range pb.ExtensionRangeArray() {
+               if er.Start <= field && field <= er.End {
+                       return true
+               }
+       }
+       return false
+}
+
+// checkExtensionTypes checks that the given extension is valid for pb.
+func checkExtensionTypes(pb extendableProto, extension *ExtensionDesc) error {
+       var pbi interface{} = pb
+       // Check the extended type.
+       if ea, ok := pbi.(extensionAdapter); ok {
+               pbi = ea.extendableProtoV1
+       }
+       if ea, ok := pbi.(slowExtensionAdapter); ok {
+               pbi = ea.extensionsBytes
+       }
+       if a, b := reflect.TypeOf(pbi), reflect.TypeOf(extension.ExtendedType); a != b {
+               return fmt.Errorf("proto: bad extended type; %v does not extend %v", b, a)
+       }
+       // Check the range.
+       if !isExtensionField(pb, extension.Field) {
+               return errors.New("proto: bad extension number; not in declared ranges")
+       }
+       return nil
+}
+
+// extPropKey is sufficient to uniquely identify an extension.
+type extPropKey struct {
+       base  reflect.Type
+       field int32
+}
+
+var extProp = struct {
+       sync.RWMutex
+       m map[extPropKey]*Properties
+}{
+       m: make(map[extPropKey]*Properties),
+}
+
+func extensionProperties(ed *ExtensionDesc) *Properties {
+       key := extPropKey{base: reflect.TypeOf(ed.ExtendedType), field: ed.Field}
+
+       extProp.RLock()
+       if prop, ok := extProp.m[key]; ok {
+               extProp.RUnlock()
+               return prop
+       }
+       extProp.RUnlock()
+
+       extProp.Lock()
+       defer extProp.Unlock()
+       // Check again.
+       if prop, ok := extProp.m[key]; ok {
+               return prop
+       }
+
+       prop := new(Properties)
+       prop.Init(reflect.TypeOf(ed.ExtensionType), "unknown_name", ed.Tag, nil)
+       extProp.m[key] = prop
+       return prop
+}
+
+// HasExtension returns whether the given extension is present in pb.
+func HasExtension(pb Message, extension *ExtensionDesc) bool {
+       if epb, doki := pb.(extensionsBytes); doki {
+               ext := epb.GetExtensions()
+               buf := *ext
+               o := 0
+               for o < len(buf) {
+                       tag, n := DecodeVarint(buf[o:])
+                       fieldNum := int32(tag >> 3)
+                       if int32(fieldNum) == extension.Field {
+                               return true
+                       }
+                       wireType := int(tag & 0x7)
+                       o += n
+                       l, err := size(buf[o:], wireType)
+                       if err != nil {
+                               return false
+                       }
+                       o += l
+               }
+               return false
+       }
+       // TODO: Check types, field numbers, etc.?
+       epb, err := extendable(pb)
+       if err != nil {
+               return false
+       }
+       extmap, mu := epb.extensionsRead()
+       if extmap == nil {
+               return false
+       }
+       mu.Lock()
+       _, ok := extmap[extension.Field]
+       mu.Unlock()
+       return ok
+}
+
+// ClearExtension removes the given extension from pb.
+func ClearExtension(pb Message, extension *ExtensionDesc) {
+       clearExtension(pb, extension.Field)
+}
+
+func clearExtension(pb Message, fieldNum int32) {
+       if epb, ok := pb.(extensionsBytes); ok {
+               offset := 0
+               for offset != -1 {
+                       offset = deleteExtension(epb, fieldNum, offset)
+               }
+               return
+       }
+       epb, err := extendable(pb)
+       if err != nil {
+               return
+       }
+       // TODO: Check types, field numbers, etc.?
+       extmap := epb.extensionsWrite()
+       delete(extmap, fieldNum)
+}
+
+// GetExtension retrieves a proto2 extended field from pb.
+//
+// If the descriptor is type complete (i.e., ExtensionDesc.ExtensionType is non-nil),
+// then GetExtension parses the encoded field and returns a Go value of the specified type.
+// If the field is not present, then the default value is returned (if one is specified),
+// otherwise ErrMissingExtension is reported.
+//
+// If the descriptor is not type complete (i.e., ExtensionDesc.ExtensionType is nil),
+// then GetExtension returns the raw encoded bytes of the field extension.
+func GetExtension(pb Message, extension *ExtensionDesc) (interface{}, error) {
+       if epb, doki := pb.(extensionsBytes); doki {
+               ext := epb.GetExtensions()
+               return decodeExtensionFromBytes(extension, *ext)
+       }
+
+       epb, err := extendable(pb)
+       if err != nil {
+               return nil, err
+       }
+
+       if extension.ExtendedType != nil {
+               // can only check type if this is a complete descriptor
+               if cerr := checkExtensionTypes(epb, extension); cerr != nil {
+                       return nil, cerr
+               }
+       }
+
+       emap, mu := epb.extensionsRead()
+       if emap == nil {
+               return defaultExtensionValue(extension)
+       }
+       mu.Lock()
+       defer mu.Unlock()
+       e, ok := emap[extension.Field]
+       if !ok {
+               // defaultExtensionValue returns the default value or
+               // ErrMissingExtension if there is no default.
+               return defaultExtensionValue(extension)
+       }
+
+       if e.value != nil {
+               // Already decoded. Check the descriptor, though.
+               if e.desc != extension {
+                       // This shouldn't happen. If it does, it means that
+                       // GetExtension was called twice with two different
+                       // descriptors with the same field number.
+                       return nil, errors.New("proto: descriptor conflict")
+               }
+               return e.value, nil
+       }
+
+       if extension.ExtensionType == nil {
+               // incomplete descriptor
+               return e.enc, nil
+       }
+
+       v, err := decodeExtension(e.enc, extension)
+       if err != nil {
+               return nil, err
+       }
+
+       // Remember the decoded version and drop the encoded version.
+       // That way it is safe to mutate what we return.
+       e.value = v
+       e.desc = extension
+       e.enc = nil
+       emap[extension.Field] = e
+       return e.value, nil
+}
+
+// defaultExtensionValue returns the default value for extension.
+// If no default for an extension is defined ErrMissingExtension is returned.
+func defaultExtensionValue(extension *ExtensionDesc) (interface{}, error) {
+       if extension.ExtensionType == nil {
+               // incomplete descriptor, so no default
+               return nil, ErrMissingExtension
+       }
+
+       t := reflect.TypeOf(extension.ExtensionType)
+       props := extensionProperties(extension)
+
+       sf, _, err := fieldDefault(t, props)
+       if err != nil {
+               return nil, err
+       }
+
+       if sf == nil || sf.value == nil {
+               // There is no default value.
+               return nil, ErrMissingExtension
+       }
+
+       if t.Kind() != reflect.Ptr {
+               // We do not need to return a Ptr, we can directly return sf.value.
+               return sf.value, nil
+       }
+
+       // We need to return an interface{} that is a pointer to sf.value.
+       value := reflect.New(t).Elem()
+       value.Set(reflect.New(value.Type().Elem()))
+       if sf.kind == reflect.Int32 {
+               // We may have an int32 or an enum, but the underlying data is int32.
+               // Since we can't set an int32 into a non int32 reflect.value directly
+               // set it as a int32.
+               value.Elem().SetInt(int64(sf.value.(int32)))
+       } else {
+               value.Elem().Set(reflect.ValueOf(sf.value))
+       }
+       return value.Interface(), nil
+}
+
+// decodeExtension decodes an extension encoded in b.
+func decodeExtension(b []byte, extension *ExtensionDesc) (interface{}, error) {
+       t := reflect.TypeOf(extension.ExtensionType)
+       unmarshal := typeUnmarshaler(t, extension.Tag)
+
+       // t is a pointer to a struct, pointer to basic type or a slice.
+       // Allocate space to store the pointer/slice.
+       value := reflect.New(t).Elem()
+
+       var err error
+       for {
+               x, n := decodeVarint(b)
+               if n == 0 {
+                       return nil, io.ErrUnexpectedEOF
+               }
+               b = b[n:]
+               wire := int(x) & 7
+
+               b, err = unmarshal(b, valToPointer(value.Addr()), wire)
+               if err != nil {
+                       return nil, err
+               }
+
+               if len(b) == 0 {
+                       break
+               }
+       }
+       return value.Interface(), nil
+}
+
+// GetExtensions returns a slice of the extensions present in pb that are also listed in es.
+// The returned slice has the same length as es; missing extensions will appear as nil elements.
+func GetExtensions(pb Message, es []*ExtensionDesc) (extensions []interface{}, err error) {
+       epb, err := extendable(pb)
+       if err != nil {
+               return nil, err
+       }
+       extensions = make([]interface{}, len(es))
+       for i, e := range es {
+               extensions[i], err = GetExtension(epb, e)
+               if err == ErrMissingExtension {
+                       err = nil
+               }
+               if err != nil {
+                       return
+               }
+       }
+       return
+}
+
+// ExtensionDescs returns a new slice containing pb's extension descriptors, in undefined order.
+// For non-registered extensions, ExtensionDescs returns an incomplete descriptor containing
+// just the Field field, which defines the extension's field number.
+func ExtensionDescs(pb Message) ([]*ExtensionDesc, error) {
+       epb, err := extendable(pb)
+       if err != nil {
+               return nil, err
+       }
+       registeredExtensions := RegisteredExtensions(pb)
+
+       emap, mu := epb.extensionsRead()
+       if emap == nil {
+               return nil, nil
+       }
+       mu.Lock()
+       defer mu.Unlock()
+       extensions := make([]*ExtensionDesc, 0, len(emap))
+       for extid, e := range emap {
+               desc := e.desc
+               if desc == nil {
+                       desc = registeredExtensions[extid]
+                       if desc == nil {
+                               desc = &ExtensionDesc{Field: extid}
+                       }
+               }
+
+               extensions = append(extensions, desc)
+       }
+       return extensions, nil
+}
+
+// SetExtension sets the specified extension of pb to the specified value.
+func SetExtension(pb Message, extension *ExtensionDesc, value interface{}) error {
+       if epb, ok := pb.(extensionsBytes); ok {
+               newb, err := encodeExtension(extension, value)
+               if err != nil {
+                       return err
+               }
+               bb := epb.GetExtensions()
+               *bb = append(*bb, newb...)
+               return nil
+       }
+       epb, err := extendable(pb)
+       if err != nil {
+               return err
+       }
+       if err := checkExtensionTypes(epb, extension); err != nil {
+               return err
+       }
+       typ := reflect.TypeOf(extension.ExtensionType)
+       if typ != reflect.TypeOf(value) {
+               return fmt.Errorf("proto: bad extension value type. got: %T, want: %T", value, extension.ExtensionType)
+       }
+       // nil extension values need to be caught early, because the
+       // encoder can't distinguish an ErrNil due to a nil extension
+       // from an ErrNil due to a missing field. Extensions are
+       // always optional, so the encoder would just swallow the error
+       // and drop all the extensions from the encoded message.
+       if reflect.ValueOf(value).IsNil() {
+               return fmt.Errorf("proto: SetExtension called with nil value of type %T", value)
+       }
+
+       extmap := epb.extensionsWrite()
+       extmap[extension.Field] = Extension{desc: extension, value: value}
+       return nil
+}
+
+// ClearAllExtensions clears all extensions from pb.
+func ClearAllExtensions(pb Message) {
+       if epb, doki := pb.(extensionsBytes); doki {
+               ext := epb.GetExtensions()
+               *ext = []byte{}
+               return
+       }
+       epb, err := extendable(pb)
+       if err != nil {
+               return
+       }
+       m := epb.extensionsWrite()
+       for k := range m {
+               delete(m, k)
+       }
+}
+
+// A global registry of extensions.
+// The generated code will register the generated descriptors by calling RegisterExtension.
+
+var extensionMaps = make(map[reflect.Type]map[int32]*ExtensionDesc)
+
+// RegisterExtension is called from the generated code.
+func RegisterExtension(desc *ExtensionDesc) {
+       st := reflect.TypeOf(desc.ExtendedType).Elem()
+       m := extensionMaps[st]
+       if m == nil {
+               m = make(map[int32]*ExtensionDesc)
+               extensionMaps[st] = m
+       }
+       if _, ok := m[desc.Field]; ok {
+               panic("proto: duplicate extension registered: " + st.String() + " " + strconv.Itoa(int(desc.Field)))
+       }
+       m[desc.Field] = desc
+}
+
+// RegisteredExtensions returns a map of the registered extensions of a
+// protocol buffer struct, indexed by the extension number.
+// The argument pb should be a nil pointer to the struct type.
+func RegisteredExtensions(pb Message) map[int32]*ExtensionDesc {
+       return extensionMaps[reflect.TypeOf(pb).Elem()]
+}

diff --git a/vendor/github.com/gogo/protobuf/proto/extensions_gogo.go b/vendor/github.com/gogo/protobuf/proto/extensions_gogo.go
new file mode 100644 (file)
index 0000000..53ebd8c
--- /dev/null
+++ b/vendor/github.com/gogo/protobuf/proto/extensions_gogo.go
@@ -0,0 +1,368 @@
+// Protocol Buffers for Go with Gadgets
+//
+// Copyright (c) 2013, The GoGo Authors. All rights reserved.
+// http://github.com/gogo/protobuf
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//     * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//     * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+package proto
+
+import (
+       "bytes"
+       "errors"
+       "fmt"
+       "io"
+       "reflect"
+       "sort"
+       "strings"
+       "sync"
+)
+
+type extensionsBytes interface {
+       Message
+       ExtensionRangeArray() []ExtensionRange
+       GetExtensions() *[]byte
+}
+
+type slowExtensionAdapter struct {
+       extensionsBytes
+}
+
+func (s slowExtensionAdapter) extensionsWrite() map[int32]Extension {
+       panic("Please report a bug to github.com/gogo/protobuf if you see this message: Writing extensions is not supported for extensions stored in a byte slice field.")
+}
+
+func (s slowExtensionAdapter) extensionsRead() (map[int32]Extension, sync.Locker) {
+       b := s.GetExtensions()
+       m, err := BytesToExtensionsMap(*b)
+       if err != nil {
+               panic(err)
+       }
+       return m, notLocker{}
+}
+
+func GetBoolExtension(pb Message, extension *ExtensionDesc, ifnotset bool) bool {
+       if reflect.ValueOf(pb).IsNil() {
+               return ifnotset
+       }
+       value, err := GetExtension(pb, extension)
+       if err != nil {
+               return ifnotset
+       }
+       if value == nil {
+               return ifnotset
+       }
+       if value.(*bool) == nil {
+               return ifnotset
+       }
+       return *(value.(*bool))
+}
+
+func (this *Extension) Equal(that *Extension) bool {
+       if err := this.Encode(); err != nil {
+               return false
+       }
+       if err := that.Encode(); err != nil {
+               return false
+       }
+       return bytes.Equal(this.enc, that.enc)
+}
+
+func (this *Extension) Compare(that *Extension) int {
+       if err := this.Encode(); err != nil {
+               return 1
+       }
+       if err := that.Encode(); err != nil {
+               return -1
+       }
+       return bytes.Compare(this.enc, that.enc)
+}
+
+func SizeOfInternalExtension(m extendableProto) (n int) {
+       info := getMarshalInfo(reflect.TypeOf(m))
+       return info.sizeV1Extensions(m.extensionsWrite())
+}
+
+type sortableMapElem struct {
+       field int32
+       ext   Extension
+}
+
+func newSortableExtensionsFromMap(m map[int32]Extension) sortableExtensions {
+       s := make(sortableExtensions, 0, len(m))
+       for k, v := range m {
+               s = append(s, &sortableMapElem{field: k, ext: v})
+       }
+       return s
+}
+
+type sortableExtensions []*sortableMapElem
+
+func (this sortableExtensions) Len() int { return len(this) }
+
+func (this sortableExtensions) Swap(i, j int) { this[i], this[j] = this[j], this[i] }
+
+func (this sortableExtensions) Less(i, j int) bool { return this[i].field < this[j].field }
+
+func (this sortableExtensions) String() string {
+       sort.Sort(this)
+       ss := make([]string, len(this))
+       for i := range this {
+               ss[i] = fmt.Sprintf("%d: %v", this[i].field, this[i].ext)
+       }
+       return "map[" + strings.Join(ss, ",") + "]"
+}
+
+func StringFromInternalExtension(m extendableProto) string {
+       return StringFromExtensionsMap(m.extensionsWrite())
+}
+
+func StringFromExtensionsMap(m map[int32]Extension) string {
+       return newSortableExtensionsFromMap(m).String()
+}
+
+func StringFromExtensionsBytes(ext []byte) string {
+       m, err := BytesToExtensionsMap(ext)
+       if err != nil {
+               panic(err)
+       }
+       return StringFromExtensionsMap(m)
+}
+
+func EncodeInternalExtension(m extendableProto, data []byte) (n int, err error) {
+       return EncodeExtensionMap(m.extensionsWrite(), data)
+}
+
+func EncodeExtensionMap(m map[int32]Extension, data []byte) (n int, err error) {
+       o := 0
+       for _, e := range m {
+               if err := e.Encode(); err != nil {
+                       return 0, err
+               }
+               n := copy(data[o:], e.enc)
+               if n != len(e.enc) {
+                       return 0, io.ErrShortBuffer
+               }
+               o += n
+       }
+       return o, nil
+}
+
+func GetRawExtension(m map[int32]Extension, id int32) ([]byte, error) {
+       e := m[id]
+       if err := e.Encode(); err != nil {
+               return nil, err
+       }
+       return e.enc, nil
+}
+
+func size(buf []byte, wire int) (int, error) {
+       switch wire {
+       case WireVarint:
+               _, n := DecodeVarint(buf)
+               return n, nil
+       case WireFixed64:
+               return 8, nil
+       case WireBytes:
+               v, n := DecodeVarint(buf)
+               return int(v) + n, nil
+       case WireFixed32:
+               return 4, nil
+       case WireStartGroup:
+               offset := 0
+               for {
+                       u, n := DecodeVarint(buf[offset:])
+                       fwire := int(u & 0x7)
+                       offset += n
+                       if fwire == WireEndGroup {
+                               return offset, nil
+                       }
+                       s, err := size(buf[offset:], wire)
+                       if err != nil {
+                               return 0, err
+                       }
+                       offset += s
+               }
+       }
+       return 0, fmt.Errorf("proto: can't get size for unknown wire type %d", wire)
+}
+
+func BytesToExtensionsMap(buf []byte) (map[int32]Extension, error) {
+       m := make(map[int32]Extension)
+       i := 0
+       for i < len(buf) {
+               tag, n := DecodeVarint(buf[i:])
+               if n <= 0 {
+                       return nil, fmt.Errorf("unable to decode varint")
+               }
+               fieldNum := int32(tag >> 3)
+               wireType := int(tag & 0x7)
+               l, err := size(buf[i+n:], wireType)
+               if err != nil {
+                       return nil, err
+               }
+               end := i + int(l) + n
+               m[int32(fieldNum)] = Extension{enc: buf[i:end]}
+               i = end
+       }
+       return m, nil
+}
+
+func NewExtension(e []byte) Extension {
+       ee := Extension{enc: make([]byte, len(e))}
+       copy(ee.enc, e)
+       return ee
+}
+
+func AppendExtension(e Message, tag int32, buf []byte) {
+       if ee, eok := e.(extensionsBytes); eok {
+               ext := ee.GetExtensions()
+               *ext = append(*ext, buf...)
+               return
+       }
+       if ee, eok := e.(extendableProto); eok {
+               m := ee.extensionsWrite()
+               ext := m[int32(tag)] // may be missing
+               ext.enc = append(ext.enc, buf...)
+               m[int32(tag)] = ext
+       }
+}
+
+func encodeExtension(extension *ExtensionDesc, value interface{}) ([]byte, error) {
+       u := getMarshalInfo(reflect.TypeOf(extension.ExtendedType))
+       ei := u.getExtElemInfo(extension)
+       v := value
+       p := toAddrPointer(&v, ei.isptr)
+       siz := ei.sizer(p, SizeVarint(ei.wiretag))
+       buf := make([]byte, 0, siz)
+       return ei.marshaler(buf, p, ei.wiretag, false)
+}
+
+func decodeExtensionFromBytes(extension *ExtensionDesc, buf []byte) (interface{}, error) {
+       o := 0
+       for o < len(buf) {
+               tag, n := DecodeVarint((buf)[o:])
+               fieldNum := int32(tag >> 3)
+               wireType := int(tag & 0x7)
+               if o+n > len(buf) {
+                       return nil, fmt.Errorf("unable to decode extension")
+               }
+               l, err := size((buf)[o+n:], wireType)
+               if err != nil {
+                       return nil, err
+               }
+               if int32(fieldNum) == extension.Field {
+                       if o+n+l > len(buf) {
+                               return nil, fmt.Errorf("unable to decode extension")
+                       }
+                       v, err := decodeExtension((buf)[o:o+n+l], extension)
+                       if err != nil {
+                               return nil, err
+                       }
+                       return v, nil
+               }
+               o += n + l
+       }
+       return defaultExtensionValue(extension)
+}
+
+func (this *Extension) Encode() error {
+       if this.enc == nil {
+               var err error
+               this.enc, err = encodeExtension(this.desc, this.value)
+               if err != nil {
+                       return err
+               }
+       }
+       return nil
+}
+
+func (this Extension) GoString() string {
+       if err := this.Encode(); err != nil {
+               return fmt.Sprintf("error encoding extension: %v", err)
+       }
+       return fmt.Sprintf("proto.NewExtension(%#v)", this.enc)
+}
+
+func SetUnsafeExtension(pb Message, fieldNum int32, value interface{}) error {
+       typ := reflect.TypeOf(pb).Elem()
+       ext, ok := extensionMaps[typ]
+       if !ok {
+               return fmt.Errorf("proto: bad extended type; %s is not extendable", typ.String())
+       }
+       desc, ok := ext[fieldNum]
+       if !ok {
+               return errors.New("proto: bad extension number; not in declared ranges")
+       }
+       return SetExtension(pb, desc, value)
+}
+
+func GetUnsafeExtension(pb Message, fieldNum int32) (interface{}, error) {
+       typ := reflect.TypeOf(pb).Elem()
+       ext, ok := extensionMaps[typ]
+       if !ok {
+               return nil, fmt.Errorf("proto: bad extended type; %s is not extendable", typ.String())
+       }
+       desc, ok := ext[fieldNum]
+       if !ok {
+               return nil, fmt.Errorf("unregistered field number %d", fieldNum)
+       }
+       return GetExtension(pb, desc)
+}
+
+func NewUnsafeXXX_InternalExtensions(m map[int32]Extension) XXX_InternalExtensions {
+       x := &XXX_InternalExtensions{
+               p: new(struct {
+                       mu           sync.Mutex
+                       extensionMap map[int32]Extension
+               }),
+       }
+       x.p.extensionMap = m
+       return *x
+}
+
+func GetUnsafeExtensionsMap(extendable Message) map[int32]Extension {
+       pb := extendable.(extendableProto)
+       return pb.extensionsWrite()
+}
+
+func deleteExtension(pb extensionsBytes, theFieldNum int32, offset int) int {
+       ext := pb.GetExtensions()
+       for offset < len(*ext) {
+               tag, n1 := DecodeVarint((*ext)[offset:])
+               fieldNum := int32(tag >> 3)
+               wireType := int(tag & 0x7)
+               n2, err := size((*ext)[offset+n1:], wireType)
+               if err != nil {
+                       panic(err)
+               }
+               newOffset := offset + n1 + n2
+               if fieldNum == theFieldNum {
+                       *ext = append((*ext)[:offset], (*ext)[newOffset:]...)
+                       return offset
+               }
+               offset = newOffset
+       }
+       return -1
+}

diff --git a/vendor/github.com/gogo/protobuf/proto/extensions_test.go b/vendor/github.com/gogo/protobuf/proto/extensions_test.go
new file mode 100644 (file)
index 0000000..c126cbb
--- /dev/null
+++ b/vendor/github.com/gogo/protobuf/proto/extensions_test.go
@@ -0,0 +1,691 @@
+// Go support for Protocol Buffers - Google's data interchange format
+//
+// Copyright 2014 The Go Authors.  All rights reserved.
+// https://github.com/golang/protobuf
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//     * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//     * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//     * Neither the name of Google Inc. nor the names of its
+// contributors may be used to endorse or promote products derived from
+// this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+package proto_test
+
+import (
+       "bytes"
+       "fmt"
+       "io"
+       "reflect"
+       "sort"
+       "strings"
+       "testing"
+
+       "github.com/gogo/protobuf/proto"
+       pb "github.com/gogo/protobuf/proto/test_proto"
+)
+
+func TestGetExtensionsWithMissingExtensions(t *testing.T) {
+       msg := &pb.MyMessage{}
+       ext1 := &pb.Ext{}
+       if err := proto.SetExtension(msg, pb.E_Ext_More, ext1); err != nil {
+               t.Fatalf("Could not set ext1: %s", err)
+       }
+       exts, err := proto.GetExtensions(msg, []*proto.ExtensionDesc{
+               pb.E_Ext_More,
+               pb.E_Ext_Text,
+       })
+       if err != nil {
+               t.Fatalf("GetExtensions() failed: %s", err)
+       }
+       if exts[0] != ext1 {
+               t.Errorf("ext1 not in returned extensions: %T %v", exts[0], exts[0])
+       }
+       if exts[1] != nil {
+               t.Errorf("ext2 in returned extensions: %T %v", exts[1], exts[1])
+       }
+}
+
+func TestGetExtensionWithEmptyBuffer(t *testing.T) {
+       // Make sure that GetExtension returns an error if its
+       // undecoded buffer is empty.
+       msg := &pb.MyMessage{}
+       proto.SetRawExtension(msg, pb.E_Ext_More.Field, []byte{})
+       _, err := proto.GetExtension(msg, pb.E_Ext_More)
+       if want := io.ErrUnexpectedEOF; err != want {
+               t.Errorf("unexpected error in GetExtension from empty buffer: got %v, want %v", err, want)
+       }
+}
+
+func TestGetExtensionForIncompleteDesc(t *testing.T) {
+       msg := &pb.MyMessage{Count: proto.Int32(0)}
+       extdesc1 := &proto.ExtensionDesc{
+               ExtendedType:  (*pb.MyMessage)(nil),
+               ExtensionType: (*bool)(nil),
+               Field:         123456789,
+               Name:          "a.b",
+               Tag:           "varint,123456789,opt",
+       }
+       ext1 := proto.Bool(true)
+       if err := proto.SetExtension(msg, extdesc1, ext1); err != nil {
+               t.Fatalf("Could not set ext1: %s", err)
+       }
+       extdesc2 := &proto.ExtensionDesc{
+               ExtendedType:  (*pb.MyMessage)(nil),
+               ExtensionType: ([]byte)(nil),
+               Field:         123456790,
+               Name:          "a.c",
+               Tag:           "bytes,123456790,opt",
+       }
+       ext2 := []byte{0, 1, 2, 3, 4, 5, 6, 7}
+       if err := proto.SetExtension(msg, extdesc2, ext2); err != nil {
+               t.Fatalf("Could not set ext2: %s", err)
+       }
+       extdesc3 := &proto.ExtensionDesc{
+               ExtendedType:  (*pb.MyMessage)(nil),
+               ExtensionType: (*pb.Ext)(nil),
+               Field:         123456791,
+               Name:          "a.d",
+               Tag:           "bytes,123456791,opt",
+       }
+       ext3 := &pb.Ext{Data: proto.String("foo")}
+       if err := proto.SetExtension(msg, extdesc3, ext3); err != nil {
+               t.Fatalf("Could not set ext3: %s", err)
+       }
+
+       b, err := proto.Marshal(msg)
+       if err != nil {
+               t.Fatalf("Could not marshal msg: %v", err)
+       }
+       if err := proto.Unmarshal(b, msg); err != nil {
+               t.Fatalf("Could not unmarshal into msg: %v", err)
+       }
+
+       var expected proto.Buffer
+       if err := expected.EncodeVarint(uint64((extdesc1.Field << 3) | proto.WireVarint)); err != nil {
+               t.Fatalf("failed to compute expected prefix for ext1: %s", err)
+       }
+       if err := expected.EncodeVarint(1 /* bool true */); err != nil {
+               t.Fatalf("failed to compute expected value for ext1: %s", err)
+       }
+
+       if b, err := proto.GetExtension(msg, &proto.ExtensionDesc{Field: extdesc1.Field}); err != nil {
+               t.Fatalf("Failed to get raw value for ext1: %s", err)
+       } else if !reflect.DeepEqual(b, expected.Bytes()) {
+               t.Fatalf("Raw value for ext1: got %v, want %v", b, expected.Bytes())
+       }
+
+       expected = proto.Buffer{} // reset
+       if err := expected.EncodeVarint(uint64((extdesc2.Field << 3) | proto.WireBytes)); err != nil {
+               t.Fatalf("failed to compute expected prefix for ext2: %s", err)
+       }
+       if err := expected.EncodeRawBytes(ext2); err != nil {
+               t.Fatalf("failed to compute expected value for ext2: %s", err)
+       }
+
+       if b, err := proto.GetExtension(msg, &proto.ExtensionDesc{Field: extdesc2.Field}); err != nil {
+               t.Fatalf("Failed to get raw value for ext2: %s", err)
+       } else if !reflect.DeepEqual(b, expected.Bytes()) {
+               t.Fatalf("Raw value for ext2: got %v, want %v", b, expected.Bytes())
+       }
+
+       expected = proto.Buffer{} // reset
+       if err := expected.EncodeVarint(uint64((extdesc3.Field << 3) | proto.WireBytes)); err != nil {
+               t.Fatalf("failed to compute expected prefix for ext3: %s", err)
+       }
+       if b, err := proto.Marshal(ext3); err != nil {
+               t.Fatalf("failed to compute expected value for ext3: %s", err)
+       } else if err := expected.EncodeRawBytes(b); err != nil {
+               t.Fatalf("failed to compute expected value for ext3: %s", err)
+       }
+
+       if b, err := proto.GetExtension(msg, &proto.ExtensionDesc{Field: extdesc3.Field}); err != nil {
+               t.Fatalf("Failed to get raw value for ext3: %s", err)
+       } else if !reflect.DeepEqual(b, expected.Bytes()) {
+               t.Fatalf("Raw value for ext3: got %v, want %v", b, expected.Bytes())
+       }
+}
+
+func TestExtensionDescsWithUnregisteredExtensions(t *testing.T) {
+       msg := &pb.MyMessage{Count: proto.Int32(0)}
+       extdesc1 := pb.E_Ext_More
+       if descs, err := proto.ExtensionDescs(msg); len(descs) != 0 || err != nil {
+               t.Errorf("proto.ExtensionDescs: got %d descs, error %v; want 0, nil", len(descs), err)
+       }
+
+       ext1 := &pb.Ext{}
+       if err := proto.SetExtension(msg, extdesc1, ext1); err != nil {
+               t.Fatalf("Could not set ext1: %s", err)
+       }
+       extdesc2 := &proto.ExtensionDesc{
+               ExtendedType:  (*pb.MyMessage)(nil),
+               ExtensionType: (*bool)(nil),
+               Field:         123456789,
+               Name:          "a.b",
+               Tag:           "varint,123456789,opt",
+       }
+       ext2 := proto.Bool(false)
+       if err := proto.SetExtension(msg, extdesc2, ext2); err != nil {
+               t.Fatalf("Could not set ext2: %s", err)
+       }
+
+       b, err := proto.Marshal(msg)
+       if err != nil {
+               t.Fatalf("Could not marshal msg: %v", err)
+       }
+       if err = proto.Unmarshal(b, msg); err != nil {
+               t.Fatalf("Could not unmarshal into msg: %v", err)
+       }
+
+       descs, err := proto.ExtensionDescs(msg)
+       if err != nil {
+               t.Fatalf("proto.ExtensionDescs: got error %v", err)
+       }
+       sortExtDescs(descs)
+       wantDescs := []*proto.ExtensionDesc{extdesc1, {Field: extdesc2.Field}}
+       if !reflect.DeepEqual(descs, wantDescs) {
+               t.Errorf("proto.ExtensionDescs(msg) sorted extension ids: got %+v, want %+v", descs, wantDescs)
+       }
+}
+
+type ExtensionDescSlice []*proto.ExtensionDesc
+
+func (s ExtensionDescSlice) Len() int           { return len(s) }
+func (s ExtensionDescSlice) Less(i, j int) bool { return s[i].Field < s[j].Field }
+func (s ExtensionDescSlice) Swap(i, j int)      { s[i], s[j] = s[j], s[i] }
+
+func sortExtDescs(s []*proto.ExtensionDesc) {
+       sort.Sort(ExtensionDescSlice(s))
+}
+
+func TestGetExtensionStability(t *testing.T) {
+       check := func(m *pb.MyMessage) bool {
+               ext1, err := proto.GetExtension(m, pb.E_Ext_More)
+               if err != nil {
+                       t.Fatalf("GetExtension() failed: %s", err)
+               }
+               ext2, err := proto.GetExtension(m, pb.E_Ext_More)
+               if err != nil {
+                       t.Fatalf("GetExtension() failed: %s", err)
+               }
+               return ext1 == ext2
+       }
+       msg := &pb.MyMessage{Count: proto.Int32(4)}
+       ext0 := &pb.Ext{}
+       if err := proto.SetExtension(msg, pb.E_Ext_More, ext0); err != nil {
+               t.Fatalf("Could not set ext1: %s", ext0)
+       }
+       if !check(msg) {
+               t.Errorf("GetExtension() not stable before marshaling")
+       }
+       bb, err := proto.Marshal(msg)
+       if err != nil {
+               t.Fatalf("Marshal() failed: %s", err)
+       }
+       msg1 := &pb.MyMessage{}
+       err = proto.Unmarshal(bb, msg1)
+       if err != nil {
+               t.Fatalf("Unmarshal() failed: %s", err)
+       }
+       if !check(msg1) {
+               t.Errorf("GetExtension() not stable after unmarshaling")
+       }
+}
+
+func TestGetExtensionDefaults(t *testing.T) {
+       var setFloat64 float64 = 1
+       var setFloat32 float32 = 2
+       var setInt32 int32 = 3
+       var setInt64 int64 = 4
+       var setUint32 uint32 = 5
+       var setUint64 uint64 = 6
+       var setBool = true
+       var setBool2 = false
+       var setString = "Goodnight string"
+       var setBytes = []byte("Goodnight bytes")
+       var setEnum = pb.DefaultsMessage_TWO
+
+       type testcase struct {
+               ext  *proto.ExtensionDesc // Extension we are testing.
+               want interface{}          // Expected value of extension, or nil (meaning that GetExtension will fail).
+               def  interface{}          // Expected value of extension after ClearExtension().
+       }
+       tests := []testcase{
+               {pb.E_NoDefaultDouble, setFloat64, nil},
+               {pb.E_NoDefaultFloat, setFloat32, nil},
+               {pb.E_NoDefaultInt32, setInt32, nil},
+               {pb.E_NoDefaultInt64, setInt64, nil},
+               {pb.E_NoDefaultUint32, setUint32, nil},
+               {pb.E_NoDefaultUint64, setUint64, nil},
+               {pb.E_NoDefaultSint32, setInt32, nil},
+               {pb.E_NoDefaultSint64, setInt64, nil},
+               {pb.E_NoDefaultFixed32, setUint32, nil},
+               {pb.E_NoDefaultFixed64, setUint64, nil},
+               {pb.E_NoDefaultSfixed32, setInt32, nil},
+               {pb.E_NoDefaultSfixed64, setInt64, nil},
+               {pb.E_NoDefaultBool, setBool, nil},
+               {pb.E_NoDefaultBool, setBool2, nil},
+               {pb.E_NoDefaultString, setString, nil},
+               {pb.E_NoDefaultBytes, setBytes, nil},
+               {pb.E_NoDefaultEnum, setEnum, nil},
+               {pb.E_DefaultDouble, setFloat64, float64(3.1415)},
+               {pb.E_DefaultFloat, setFloat32, float32(3.14)},
+               {pb.E_DefaultInt32, setInt32, int32(42)},
+               {pb.E_DefaultInt64, setInt64, int64(43)},
+               {pb.E_DefaultUint32, setUint32, uint32(44)},
+               {pb.E_DefaultUint64, setUint64, uint64(45)},
+               {pb.E_DefaultSint32, setInt32, int32(46)},
+               {pb.E_DefaultSint64, setInt64, int64(47)},
+               {pb.E_DefaultFixed32, setUint32, uint32(48)},
+               {pb.E_DefaultFixed64, setUint64, uint64(49)},
+               {pb.E_DefaultSfixed32, setInt32, int32(50)},
+               {pb.E_DefaultSfixed64, setInt64, int64(51)},
+               {pb.E_DefaultBool, setBool, true},
+               {pb.E_DefaultBool, setBool2, true},
+               {pb.E_DefaultString, setString, "Hello, string,def=foo"},
+               {pb.E_DefaultBytes, setBytes, []byte("Hello, bytes")},
+               {pb.E_DefaultEnum, setEnum, pb.DefaultsMessage_ONE},
+       }
+
+       checkVal := func(test testcase, msg *pb.DefaultsMessage, valWant interface{}) error {
+               val, err := proto.GetExtension(msg, test.ext)
+               if err != nil {
+                       if valWant != nil {
+                               return fmt.Errorf("GetExtension(): %s", err)
+                       }
+                       if want := proto.ErrMissingExtension; err != want {
+                               return fmt.Errorf("Unexpected error: got %v, want %v", err, want)
+                       }
+                       return nil
+               }
+
+               // All proto2 extension values are either a pointer to a value or a slice of values.
+               ty := reflect.TypeOf(val)
+               tyWant := reflect.TypeOf(test.ext.ExtensionType)
+               if got, want := ty, tyWant; got != want {
+                       return fmt.Errorf("unexpected reflect.TypeOf(): got %v want %v", got, want)
+               }
+               tye := ty.Elem()
+               tyeWant := tyWant.Elem()
+               if got, want := tye, tyeWant; got != want {
+                       return fmt.Errorf("unexpected reflect.TypeOf().Elem(): got %v want %v", got, want)
+               }
+
+               // Check the name of the type of the value.
+               // If it is an enum it will be type int32 with the name of the enum.
+               if got, want := tye.Name(), tye.Name(); got != want {
+                       return fmt.Errorf("unexpected reflect.TypeOf().Elem().Name(): got %v want %v", got, want)
+               }
+
+               // Check that value is what we expect.
+               // If we have a pointer in val, get the value it points to.
+               valExp := val
+               if ty.Kind() == reflect.Ptr {
+                       valExp = reflect.ValueOf(val).Elem().Interface()
+               }
+               if got, want := valExp, valWant; !reflect.DeepEqual(got, want) {
+                       return fmt.Errorf("unexpected reflect.DeepEqual(): got %v want %v", got, want)
+               }
+
+               return nil
+       }
+
+       setTo := func(test testcase) interface{} {
+               setTo := reflect.ValueOf(test.want)
+               if typ := reflect.TypeOf(test.ext.ExtensionType); typ.Kind() == reflect.Ptr {
+                       setTo = reflect.New(typ).Elem()
+                       setTo.Set(reflect.New(setTo.Type().Elem()))
+                       setTo.Elem().Set(reflect.ValueOf(test.want))
+               }
+               return setTo.Interface()
+       }
+
+       for _, test := range tests {
+               msg := &pb.DefaultsMessage{}
+               name := test.ext.Name
+
+               // Check the initial value.
+               if err := checkVal(test, msg, test.def); err != nil {
+                       t.Errorf("%s: %v", name, err)
+               }
+
+               // Set the per-type value and check value.
+               name = fmt.Sprintf("%s (set to %T %v)", name, test.want, test.want)
+               if err := proto.SetExtension(msg, test.ext, setTo(test)); err != nil {
+                       t.Errorf("%s: SetExtension(): %v", name, err)
+                       continue
+               }
+               if err := checkVal(test, msg, test.want); err != nil {
+                       t.Errorf("%s: %v", name, err)
+                       continue
+               }
+
+               // Set and check the value.
+               name += " (cleared)"
+               proto.ClearExtension(msg, test.ext)
+               if err := checkVal(test, msg, test.def); err != nil {
+                       t.Errorf("%s: %v", name, err)
+               }
+       }
+}
+
+func TestNilMessage(t *testing.T) {
+       name := "nil interface"
+       if got, err := proto.GetExtension(nil, pb.E_Ext_More); err == nil {
+               t.Errorf("%s: got %T %v, expected to fail", name, got, got)
+       } else if !strings.Contains(err.Error(), "extendable") {
+               t.Errorf("%s: got error %v, expected not-extendable error", name, err)
+       }
+
+       // Regression tests: all functions of the Extension API
+       // used to panic when passed (*M)(nil), where M is a concrete message
+       // type.  Now they handle this gracefully as a no-op or reported error.
+       var nilMsg *pb.MyMessage
+       desc := pb.E_Ext_More
+
+       isNotExtendable := func(err error) bool {
+               return strings.Contains(fmt.Sprint(err), "not extendable")
+       }
+
+       if proto.HasExtension(nilMsg, desc) {
+               t.Error("HasExtension(nil) = true")
+       }
+
+       if _, err := proto.GetExtensions(nilMsg, []*proto.ExtensionDesc{desc}); !isNotExtendable(err) {
+               t.Errorf("GetExtensions(nil) = %q (wrong error)", err)
+       }
+
+       if _, err := proto.ExtensionDescs(nilMsg); !isNotExtendable(err) {
+               t.Errorf("ExtensionDescs(nil) = %q (wrong error)", err)
+       }
+
+       if err := proto.SetExtension(nilMsg, desc, nil); !isNotExtendable(err) {
+               t.Errorf("SetExtension(nil) = %q (wrong error)", err)
+       }
+
+       proto.ClearExtension(nilMsg, desc) // no-op
+       proto.ClearAllExtensions(nilMsg)   // no-op
+}
+
+func TestExtensionsRoundTrip(t *testing.T) {
+       msg := &pb.MyMessage{}
+       ext1 := &pb.Ext{
+               Data: proto.String("hi"),
+       }
+       ext2 := &pb.Ext{
+               Data: proto.String("there"),
+       }
+       exists := proto.HasExtension(msg, pb.E_Ext_More)
+       if exists {
+               t.Error("Extension More present unexpectedly")
+       }
+       if err := proto.SetExtension(msg, pb.E_Ext_More, ext1); err != nil {
+               t.Error(err)
+       }
+       if err := proto.SetExtension(msg, pb.E_Ext_More, ext2); err != nil {
+               t.Error(err)
+       }
+       e, err := proto.GetExtension(msg, pb.E_Ext_More)
+       if err != nil {
+               t.Error(err)
+       }
+       x, ok := e.(*pb.Ext)
+       if !ok {
+               t.Errorf("e has type %T, expected test_proto.Ext", e)
+       } else if *x.Data != "there" {
+               t.Errorf("SetExtension failed to overwrite, got %+v, not 'there'", x)
+       }
+       proto.ClearExtension(msg, pb.E_Ext_More)
+       if _, err = proto.GetExtension(msg, pb.E_Ext_More); err != proto.ErrMissingExtension {
+               t.Errorf("got %v, expected ErrMissingExtension", e)
+       }
+       if _, err := proto.GetExtension(msg, pb.E_X215); err == nil {
+               t.Error("expected bad extension error, got nil")
+       }
+       if err := proto.SetExtension(msg, pb.E_X215, 12); err == nil {
+               t.Error("expected extension err")
+       }
+       if err := proto.SetExtension(msg, pb.E_Ext_More, 12); err == nil {
+               t.Error("expected some sort of type mismatch error, got nil")
+       }
+}
+
+func TestNilExtension(t *testing.T) {
+       msg := &pb.MyMessage{
+               Count: proto.Int32(1),
+       }
+       if err := proto.SetExtension(msg, pb.E_Ext_Text, proto.String("hello")); err != nil {
+               t.Fatal(err)
+       }
+       if err := proto.SetExtension(msg, pb.E_Ext_More, (*pb.Ext)(nil)); err == nil {
+               t.Error("expected SetExtension to fail due to a nil extension")
+       } else if want := fmt.Sprintf("proto: SetExtension called with nil value of type %T", new(pb.Ext)); err.Error() != want {
+               t.Errorf("expected error %v, got %v", want, err)
+       }
+       // Note: if the behavior of Marshal is ever changed to ignore nil extensions, update
+       // this test to verify that E_Ext_Text is properly propagated through marshal->unmarshal.
+}
+
+func TestMarshalUnmarshalRepeatedExtension(t *testing.T) {
+       // Add a repeated extension to the result.
+       tests := []struct {
+               name string
+               ext  []*pb.ComplexExtension
+       }{
+               {
+                       "two fields",
+                       []*pb.ComplexExtension{
+                               {First: proto.Int32(7)},
+                               {Second: proto.Int32(11)},
+                       },
+               },
+               {
+                       "repeated field",
+                       []*pb.ComplexExtension{
+                               {Third: []int32{1000}},
+                               {Third: []int32{2000}},
+                       },
+               },
+               {
+                       "two fields and repeated field",
+                       []*pb.ComplexExtension{
+                               {Third: []int32{1000}},
+                               {First: proto.Int32(9)},
+                               {Second: proto.Int32(21)},
+                               {Third: []int32{2000}},
+                       },
+               },
+       }
+       for _, test := range tests {
+               // Marshal message with a repeated extension.
+               msg1 := new(pb.OtherMessage)
+               err := proto.SetExtension(msg1, pb.E_RComplex, test.ext)
+               if err != nil {
+                       t.Fatalf("[%s] Error setting extension: %v", test.name, err)
+               }
+               b, err := proto.Marshal(msg1)
+               if err != nil {
+                       t.Fatalf("[%s] Error marshaling message: %v", test.name, err)
+               }
+
+               // Unmarshal and read the merged proto.
+               msg2 := new(pb.OtherMessage)
+               err = proto.Unmarshal(b, msg2)
+               if err != nil {
+                       t.Fatalf("[%s] Error unmarshaling message: %v", test.name, err)
+               }
+               e, err := proto.GetExtension(msg2, pb.E_RComplex)
+               if err != nil {
+                       t.Fatalf("[%s] Error getting extension: %v", test.name, err)
+               }
+               ext := e.([]*pb.ComplexExtension)
+               if ext == nil {
+                       t.Fatalf("[%s] Invalid extension", test.name)
+               }
+               if len(ext) != len(test.ext) {
+                       t.Errorf("[%s] Wrong length of ComplexExtension: got: %v want: %v\n", test.name, len(ext), len(test.ext))
+               }
+               for i := range test.ext {
+                       if !proto.Equal(ext[i], test.ext[i]) {
+                               t.Errorf("[%s] Wrong value for ComplexExtension[%d]: got: %v want: %v\n", test.name, i, ext[i], test.ext[i])
+                       }
+               }
+       }
+}
+
+func TestUnmarshalRepeatingNonRepeatedExtension(t *testing.T) {
+       // We may see multiple instances of the same extension in the wire
+       // format. For example, the proto compiler may encode custom options in
+       // this way. Here, we verify that we merge the extensions together.
+       tests := []struct {
+               name string
+               ext  []*pb.ComplexExtension
+       }{
+               {
+                       "two fields",
+                       []*pb.ComplexExtension{
+                               {First: proto.Int32(7)},
+                               {Second: proto.Int32(11)},
+                       },
+               },
+               {
+                       "repeated field",
+                       []*pb.ComplexExtension{
+                               {Third: []int32{1000}},
+                               {Third: []int32{2000}},
+                       },
+               },
+               {
+                       "two fields and repeated field",
+                       []*pb.ComplexExtension{
+                               {Third: []int32{1000}},
+                               {First: proto.Int32(9)},
+                               {Second: proto.Int32(21)},
+                               {Third: []int32{2000}},
+                       },
+               },
+       }
+       for _, test := range tests {
+               var buf bytes.Buffer
+               var want pb.ComplexExtension
+
+               // Generate a serialized representation of a repeated extension
+               // by catenating bytes together.
+               for i, e := range test.ext {
+                       // Merge to create the wanted proto.
+                       proto.Merge(&want, e)
+
+                       // serialize the message
+                       msg := new(pb.OtherMessage)
+                       err := proto.SetExtension(msg, pb.E_Complex, e)
+                       if err != nil {
+                               t.Fatalf("[%s] Error setting extension %d: %v", test.name, i, err)
+                       }
+                       b, err := proto.Marshal(msg)
+                       if err != nil {
+                               t.Fatalf("[%s] Error marshaling message %d: %v", test.name, i, err)
+                       }
+                       buf.Write(b)
+               }
+
+               // Unmarshal and read the merged proto.
+               msg2 := new(pb.OtherMessage)
+               err := proto.Unmarshal(buf.Bytes(), msg2)
+               if err != nil {
+                       t.Fatalf("[%s] Error unmarshaling message: %v", test.name, err)
+               }
+               e, err := proto.GetExtension(msg2, pb.E_Complex)
+               if err != nil {
+                       t.Fatalf("[%s] Error getting extension: %v", test.name, err)
+               }
+               ext := e.(*pb.ComplexExtension)
+               if ext == nil {
+                       t.Fatalf("[%s] Invalid extension", test.name)
+               }
+               if !proto.Equal(ext, &want) {
+                       t.Errorf("[%s] Wrong value for ComplexExtension: got: %v want: %v\n", test.name, ext, &want)
+
+               }
+       }
+}
+
+func TestClearAllExtensions(t *testing.T) {
+       // unregistered extension
+       desc := &proto.ExtensionDesc{
+               ExtendedType:  (*pb.MyMessage)(nil),
+               ExtensionType: (*bool)(nil),
+               Field:         101010100,
+               Name:          "emptyextension",
+               Tag:           "varint,0,opt",
+       }
+       m := &pb.MyMessage{}
+       if proto.HasExtension(m, desc) {
+               t.Errorf("proto.HasExtension(%s): got true, want false", proto.MarshalTextString(m))
+       }
+       if err := proto.SetExtension(m, desc, proto.Bool(true)); err != nil {
+               t.Errorf("proto.SetExtension(m, desc, true): got error %q, want nil", err)
+       }
+       if !proto.HasExtension(m, desc) {
+               t.Errorf("proto.HasExtension(%s): got false, want true", proto.MarshalTextString(m))
+       }
+       proto.ClearAllExtensions(m)
+       if proto.HasExtension(m, desc) {
+               t.Errorf("proto.HasExtension(%s): got true, want false", proto.MarshalTextString(m))
+       }
+}
+
+func TestMarshalRace(t *testing.T) {
+       ext := &pb.Ext{}
+       m := &pb.MyMessage{Count: proto.Int32(4)}
+       if err := proto.SetExtension(m, pb.E_Ext_More, ext); err != nil {
+               t.Fatalf("proto.SetExtension(m, desc, true): got error %q, want nil", err)
+       }
+
+       b, err := proto.Marshal(m)
+       if err != nil {
+               t.Fatalf("Could not marshal message: %v", err)
+       }
+       if err := proto.Unmarshal(b, m); err != nil {
+               t.Fatalf("Could not unmarshal message: %v", err)
+       }
+       // after Unmarshal, the extension is in undecoded form.
+       // GetExtension will decode it lazily. Make sure this does
+       // not race against Marshal.
+
+       errChan := make(chan error, 6)
+       for n := 3; n > 0; n-- {
+               go func() {
+                       _, err := proto.Marshal(m)
+                       errChan <- err
+               }()
+               go func() {
+                       _, err := proto.GetExtension(m, pb.E_Ext_More)
+                       errChan <- err
+               }()
+       }
+       for i := 0; i < 6; i++ {
+               err := <-errChan
+               if err != nil {
+                       t.Fatal(err)
+               }
+       }
+}

diff --git a/vendor/github.com/gogo/protobuf/proto/lib.go b/vendor/github.com/gogo/protobuf/proto/lib.go
new file mode 100644 (file)
index 0000000..d17f802
--- /dev/null
+++ b/vendor/github.com/gogo/protobuf/proto/lib.go
@@ -0,0 +1,967 @@
+// Go support for Protocol Buffers - Google's data interchange format
+//
+// Copyright 2010 The Go Authors.  All rights reserved.
+// https://github.com/golang/protobuf
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//     * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//     * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//     * Neither the name of Google Inc. nor the names of its
+// contributors may be used to endorse or promote products derived from
+// this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+/*
+Package proto converts data structures to and from the wire format of
+protocol buffers.  It works in concert with the Go source code generated
+for .proto files by the protocol compiler.
+
+A summary of the properties of the protocol buffer interface
+for a protocol buffer variable v:
+
+  - Names are turned from camel_case to CamelCase for export.
+  - There are no methods on v to set fields; just treat
+       them as structure fields.
+  - There are getters that return a field's value if set,
+       and return the field's default value if unset.
+       The getters work even if the receiver is a nil message.
+  - The zero value for a struct is its correct initialization state.
+       All desired fields must be set before marshaling.
+  - A Reset() method will restore a protobuf struct to its zero state.
+  - Non-repeated fields are pointers to the values; nil means unset.
+       That is, optional or required field int32 f becomes F *int32.
+  - Repeated fields are slices.
+  - Helper functions are available to aid the setting of fields.
+       msg.Foo = proto.String("hello") // set field
+  - Constants are defined to hold the default values of all fields that
+       have them.  They have the form Default_StructName_FieldName.
+       Because the getter methods handle defaulted values,
+       direct use of these constants should be rare.
+  - Enums are given type names and maps from names to values.
+       Enum values are prefixed by the enclosing message's name, or by the
+       enum's type name if it is a top-level enum. Enum types have a String
+       method, and a Enum method to assist in message construction.
+  - Nested messages, groups and enums have type names prefixed with the name of
+       the surrounding message type.
+  - Extensions are given descriptor names that start with E_,
+       followed by an underscore-delimited list of the nested messages
+       that contain it (if any) followed by the CamelCased name of the
+       extension field itself.  HasExtension, ClearExtension, GetExtension
+       and SetExtension are functions for manipulating extensions.
+  - Oneof field sets are given a single field in their message,
+       with distinguished wrapper types for each possible field value.
+  - Marshal and Unmarshal are functions to encode and decode the wire format.
+
+When the .proto file specifies `syntax="proto3"`, there are some differences:
+
+  - Non-repeated fields of non-message type are values instead of pointers.
+  - Enum types do not get an Enum method.
+
+The simplest way to describe this is to see an example.
+Given file test.proto, containing
+
+       package example;
+
+       enum FOO { X = 17; }
+
+       message Test {
+         required string label = 1;
+         optional int32 type = 2 [default=77];
+         repeated int64 reps = 3;
+         optional group OptionalGroup = 4 {
+           required string RequiredField = 5;
+         }
+         oneof union {
+           int32 number = 6;
+           string name = 7;
+         }
+       }
+
+The resulting file, test.pb.go, is:
+
+       package example
+
+       import proto "github.com/gogo/protobuf/proto"
+       import math "math"
+
+       type FOO int32
+       const (
+               FOO_X FOO = 17
+       )
+       var FOO_name = map[int32]string{
+               17: "X",
+       }
+       var FOO_value = map[string]int32{
+               "X": 17,
+       }
+
+       func (x FOO) Enum() *FOO {
+               p := new(FOO)
+               *p = x
+               return p
+       }
+       func (x FOO) String() string {
+               return proto.EnumName(FOO_name, int32(x))
+       }
+       func (x *FOO) UnmarshalJSON(data []byte) error {
+               value, err := proto.UnmarshalJSONEnum(FOO_value, data)
+               if err != nil {
+                       return err
+               }
+               *x = FOO(value)
+               return nil
+       }
+
+       type Test struct {
+               Label         *string             `protobuf:"bytes,1,req,name=label" json:"label,omitempty"`
+               Type          *int32              `protobuf:"varint,2,opt,name=type,def=77" json:"type,omitempty"`
+               Reps          []int64             `protobuf:"varint,3,rep,name=reps" json:"reps,omitempty"`
+               Optionalgroup *Test_OptionalGroup `protobuf:"group,4,opt,name=OptionalGroup" json:"optionalgroup,omitempty"`
+               // Types that are valid to be assigned to Union:
+               //      *Test_Number
+               //      *Test_Name
+               Union            isTest_Union `protobuf_oneof:"union"`
+               XXX_unrecognized []byte       `json:"-"`
+       }
+       func (m *Test) Reset()         { *m = Test{} }
+       func (m *Test) String() string { return proto.CompactTextString(m) }
+       func (*Test) ProtoMessage() {}
+
+       type isTest_Union interface {
+               isTest_Union()
+       }
+
+       type Test_Number struct {
+               Number int32 `protobuf:"varint,6,opt,name=number"`
+       }
+       type Test_Name struct {
+               Name string `protobuf:"bytes,7,opt,name=name"`
+       }
+
+       func (*Test_Number) isTest_Union() {}
+       func (*Test_Name) isTest_Union()   {}
+
+       func (m *Test) GetUnion() isTest_Union {
+               if m != nil {
+                       return m.Union
+               }
+               return nil
+       }
+       const Default_Test_Type int32 = 77
+
+       func (m *Test) GetLabel() string {
+               if m != nil && m.Label != nil {
+                       return *m.Label
+               }
+               return ""
+       }
+
+       func (m *Test) GetType() int32 {
+               if m != nil && m.Type != nil {
+                       return *m.Type
+               }
+               return Default_Test_Type
+       }
+
+       func (m *Test) GetOptionalgroup() *Test_OptionalGroup {
+               if m != nil {
+                       return m.Optionalgroup
+               }
+               return nil
+       }
+
+       type Test_OptionalGroup struct {
+               RequiredField *string `protobuf:"bytes,5,req" json:"RequiredField,omitempty"`
+       }
+       func (m *Test_OptionalGroup) Reset()         { *m = Test_OptionalGroup{} }
+       func (m *Test_OptionalGroup) String() string { return proto.CompactTextString(m) }
+
+       func (m *Test_OptionalGroup) GetRequiredField() string {
+               if m != nil && m.RequiredField != nil {
+                       return *m.RequiredField
+               }
+               return ""
+       }
+
+       func (m *Test) GetNumber() int32 {
+               if x, ok := m.GetUnion().(*Test_Number); ok {
+                       return x.Number
+               }
+               return 0
+       }
+
+       func (m *Test) GetName() string {
+               if x, ok := m.GetUnion().(*Test_Name); ok {
+                       return x.Name
+               }
+               return ""
+       }
+
+       func init() {
+               proto.RegisterEnum("example.FOO", FOO_name, FOO_value)
+       }
+
+To create and play with a Test object:
+
+       package main
+
+       import (
+               "log"
+
+               "github.com/gogo/protobuf/proto"
+               pb "./example.pb"
+       )
+
+       func main() {
+               test := &pb.Test{
+                       Label: proto.String("hello"),
+                       Type:  proto.Int32(17),
+                       Reps:  []int64{1, 2, 3},
+                       Optionalgroup: &pb.Test_OptionalGroup{
+                               RequiredField: proto.String("good bye"),
+                       },
+                       Union: &pb.Test_Name{"fred"},
+               }
+               data, err := proto.Marshal(test)
+               if err != nil {
+                       log.Fatal("marshaling error: ", err)
+               }
+               newTest := &pb.Test{}
+               err = proto.Unmarshal(data, newTest)
+               if err != nil {
+                       log.Fatal("unmarshaling error: ", err)
+               }
+               // Now test and newTest contain the same data.
+               if test.GetLabel() != newTest.GetLabel() {
+                       log.Fatalf("data mismatch %q != %q", test.GetLabel(), newTest.GetLabel())
+               }
+               // Use a type switch to determine which oneof was set.
+               switch u := test.Union.(type) {
+               case *pb.Test_Number: // u.Number contains the number.
+               case *pb.Test_Name: // u.Name contains the string.
+               }
+               // etc.
+       }
+*/
+package proto
+
+import (
+       "encoding/json"
+       "fmt"
+       "log"
+       "reflect"
+       "sort"
+       "strconv"
+       "sync"
+)
+
+// RequiredNotSetError is an error type returned by either Marshal or Unmarshal.
+// Marshal reports this when a required field is not initialized.
+// Unmarshal reports this when a required field is missing from the wire data.
+type RequiredNotSetError struct{ field string }
+
+func (e *RequiredNotSetError) Error() string {
+       if e.field == "" {
+               return fmt.Sprintf("proto: required field not set")
+       }
+       return fmt.Sprintf("proto: required field %q not set", e.field)
+}
+func (e *RequiredNotSetError) RequiredNotSet() bool {
+       return true
+}
+
+type invalidUTF8Error struct{ field string }
+
+func (e *invalidUTF8Error) Error() string {
+       if e.field == "" {
+               return "proto: invalid UTF-8 detected"
+       }
+       return fmt.Sprintf("proto: field %q contains invalid UTF-8", e.field)
+}
+func (e *invalidUTF8Error) InvalidUTF8() bool {
+       return true
+}
+
+// errInvalidUTF8 is a sentinel error to identify fields with invalid UTF-8.
+// This error should not be exposed to the external API as such errors should
+// be recreated with the field information.
+var errInvalidUTF8 = &invalidUTF8Error{}
+
+// isNonFatal reports whether the error is either a RequiredNotSet error
+// or a InvalidUTF8 error.
+func isNonFatal(err error) bool {
+       if re, ok := err.(interface{ RequiredNotSet() bool }); ok && re.RequiredNotSet() {
+               return true
+       }
+       if re, ok := err.(interface{ InvalidUTF8() bool }); ok && re.InvalidUTF8() {
+               return true
+       }
+       return false
+}
+
+type nonFatal struct{ E error }
+
+// Merge merges err into nf and reports whether it was successful.
+// Otherwise it returns false for any fatal non-nil errors.
+func (nf *nonFatal) Merge(err error) (ok bool) {
+       if err == nil {
+               return true // not an error
+       }
+       if !isNonFatal(err) {
+               return false // fatal error
+       }
+       if nf.E == nil {
+               nf.E = err // store first instance of non-fatal error
+       }
+       return true
+}
+
+// Message is implemented by generated protocol buffer messages.
+type Message interface {
+       Reset()
+       String() string
+       ProtoMessage()
+}
+
+// A Buffer is a buffer manager for marshaling and unmarshaling
+// protocol buffers.  It may be reused between invocations to
+// reduce memory usage.  It is not necessary to use a Buffer;
+// the global functions Marshal and Unmarshal create a
+// temporary Buffer and are fine for most applications.
+type Buffer struct {
+       buf   []byte // encode/decode byte stream
+       index int    // read point
+
+       deterministic bool
+}
+
+// NewBuffer allocates a new Buffer and initializes its internal data to
+// the contents of the argument slice.
+func NewBuffer(e []byte) *Buffer {
+       return &Buffer{buf: e}
+}
+
+// Reset resets the Buffer, ready for marshaling a new protocol buffer.
+func (p *Buffer) Reset() {
+       p.buf = p.buf[0:0] // for reading/writing
+       p.index = 0        // for reading
+}
+
+// SetBuf replaces the internal buffer with the slice,
+// ready for unmarshaling the contents of the slice.
+func (p *Buffer) SetBuf(s []byte) {
+       p.buf = s
+       p.index = 0
+}
+
+// Bytes returns the contents of the Buffer.
+func (p *Buffer) Bytes() []byte { return p.buf }
+
+// SetDeterministic sets whether to use deterministic serialization.
+//
+// Deterministic serialization guarantees that for a given binary, equal
+// messages will always be serialized to the same bytes. This implies:
+//
+//   - Repeated serialization of a message will return the same bytes.
+//   - Different processes of the same binary (which may be executing on
+//     different machines) will serialize equal messages to the same bytes.
+//
+// Note that the deterministic serialization is NOT canonical across
+// languages. It is not guaranteed to remain stable over time. It is unstable
+// across different builds with schema changes due to unknown fields.
+// Users who need canonical serialization (e.g., persistent storage in a
+// canonical form, fingerprinting, etc.) should define their own
+// canonicalization specification and implement their own serializer rather
+// than relying on this API.
+//
+// If deterministic serialization is requested, map entries will be sorted
+// by keys in lexographical order. This is an implementation detail and
+// subject to change.
+func (p *Buffer) SetDeterministic(deterministic bool) {
+       p.deterministic = deterministic
+}
+
+/*
+ * Helper routines for simplifying the creation of optional fields of basic type.
+ */
+
+// Bool is a helper routine that allocates a new bool value
+// to store v and returns a pointer to it.
+func Bool(v bool) *bool {
+       return &v
+}
+
+// Int32 is a helper routine that allocates a new int32 value
+// to store v and returns a pointer to it.
+func Int32(v int32) *int32 {
+       return &v
+}
+
+// Int is a helper routine that allocates a new int32 value
+// to store v and returns a pointer to it, but unlike Int32
+// its argument value is an int.
+func Int(v int) *int32 {
+       p := new(int32)
+       *p = int32(v)
+       return p
+}
+
+// Int64 is a helper routine that allocates a new int64 value
+// to store v and returns a pointer to it.
+func Int64(v int64) *int64 {
+       return &v
+}
+
+// Float32 is a helper routine that allocates a new float32 value
+// to store v and returns a pointer to it.
+func Float32(v float32) *float32 {
+       return &v
+}
+
+// Float64 is a helper routine that allocates a new float64 value
+// to store v and returns a pointer to it.
+func Float64(v float64) *float64 {
+       return &v
+}
+
+// Uint32 is a helper routine that allocates a new uint32 value
+// to store v and returns a pointer to it.
+func Uint32(v uint32) *uint32 {
+       return &v
+}
+
+// Uint64 is a helper routine that allocates a new uint64 value
+// to store v and returns a pointer to it.
+func Uint64(v uint64) *uint64 {
+       return &v
+}
+
+// String is a helper routine that allocates a new string value
+// to store v and returns a pointer to it.
+func String(v string) *string {
+       return &v
+}
+
+// EnumName is a helper function to simplify printing protocol buffer enums
+// by name.  Given an enum map and a value, it returns a useful string.
+func EnumName(m map[int32]string, v int32) string {
+       s, ok := m[v]
+       if ok {
+               return s
+       }
+       return strconv.Itoa(int(v))
+}
+
+// UnmarshalJSONEnum is a helper function to simplify recovering enum int values
+// from their JSON-encoded representation. Given a map from the enum's symbolic
+// names to its int values, and a byte buffer containing the JSON-encoded
+// value, it returns an int32 that can be cast to the enum type by the caller.
+//
+// The function can deal with both JSON representations, numeric and symbolic.
+func UnmarshalJSONEnum(m map[string]int32, data []byte, enumName string) (int32, error) {
+       if data[0] == '"' {
+               // New style: enums are strings.
+               var repr string
+               if err := json.Unmarshal(data, &repr); err != nil {
+                       return -1, err
+               }
+               val, ok := m[repr]
+               if !ok {
+                       return 0, fmt.Errorf("unrecognized enum %s value %q", enumName, repr)
+               }
+               return val, nil
+       }
+       // Old style: enums are ints.
+       var val int32
+       if err := json.Unmarshal(data, &val); err != nil {
+               return 0, fmt.Errorf("cannot unmarshal %#q into enum %s", data, enumName)
+       }
+       return val, nil
+}
+
+// DebugPrint dumps the encoded data in b in a debugging format with a header
+// including the string s. Used in testing but made available for general debugging.
+func (p *Buffer) DebugPrint(s string, b []byte) {
+       var u uint64
+
+       obuf := p.buf
+       sindex := p.index
+       p.buf = b
+       p.index = 0
+       depth := 0
+
+       fmt.Printf("\n--- %s ---\n", s)
+
+out:
+       for {
+               for i := 0; i < depth; i++ {
+                       fmt.Print("  ")
+               }
+
+               index := p.index
+               if index == len(p.buf) {
+                       break
+               }
+
+               op, err := p.DecodeVarint()
+               if err != nil {
+                       fmt.Printf("%3d: fetching op err %v\n", index, err)
+                       break out
+               }
+               tag := op >> 3
+               wire := op & 7
+
+               switch wire {
+               default:
+                       fmt.Printf("%3d: t=%3d unknown wire=%d\n",
+                               index, tag, wire)
+                       break out
+
+               case WireBytes:
+                       var r []byte
+
+                       r, err = p.DecodeRawBytes(false)
+                       if err != nil {
+                               break out
+                       }
+                       fmt.Printf("%3d: t=%3d bytes [%d]", index, tag, len(r))
+                       if len(r) <= 6 {
+                               for i := 0; i < len(r); i++ {
+                                       fmt.Printf(" %.2x", r[i])
+                               }
+                       } else {
+                               for i := 0; i < 3; i++ {
+                                       fmt.Printf(" %.2x", r[i])
+                               }
+                               fmt.Printf(" ..")
+                               for i := len(r) - 3; i < len(r); i++ {
+                                       fmt.Printf(" %.2x", r[i])
+                               }
+                       }
+                       fmt.Printf("\n")
+
+               case WireFixed32:
+                       u, err = p.DecodeFixed32()
+                       if err != nil {
+                               fmt.Printf("%3d: t=%3d fix32 err %v\n", index, tag, err)
+                               break out
+                       }
+                       fmt.Printf("%3d: t=%3d fix32 %d\n", index, tag, u)
+
+               case WireFixed64:
+                       u, err = p.DecodeFixed64()
+                       if err != nil {
+                               fmt.Printf("%3d: t=%3d fix64 err %v\n", index, tag, err)
+                               break out
+                       }
+                       fmt.Printf("%3d: t=%3d fix64 %d\n", index, tag, u)
+
+               case WireVarint:
+                       u, err = p.DecodeVarint()
+                       if err != nil {
+                               fmt.Printf("%3d: t=%3d varint err %v\n", index, tag, err)
+                               break out
+                       }
+                       fmt.Printf("%3d: t=%3d varint %d\n", index, tag, u)
+
+               case WireStartGroup:
+                       fmt.Printf("%3d: t=%3d start\n", index, tag)
+                       depth++
+
+               case WireEndGroup:
+                       depth--
+                       fmt.Printf("%3d: t=%3d end\n", index, tag)
+               }
+       }
+
+       if depth != 0 {
+               fmt.Printf("%3d: start-end not balanced %d\n", p.index, depth)
+       }
+       fmt.Printf("\n")
+
+       p.buf = obuf
+       p.index = sindex
+}
+
+// SetDefaults sets unset protocol buffer fields to their default values.
+// It only modifies fields that are both unset and have defined defaults.
+// It recursively sets default values in any non-nil sub-messages.
+func SetDefaults(pb Message) {
+       setDefaults(reflect.ValueOf(pb), true, false)
+}
+
+// v is a struct.
+func setDefaults(v reflect.Value, recur, zeros bool) {
+       if v.Kind() == reflect.Ptr {
+               v = v.Elem()
+       }
+
+       defaultMu.RLock()
+       dm, ok := defaults[v.Type()]
+       defaultMu.RUnlock()
+       if !ok {
+               dm = buildDefaultMessage(v.Type())
+               defaultMu.Lock()
+               defaults[v.Type()] = dm
+               defaultMu.Unlock()
+       }
+
+       for _, sf := range dm.scalars {
+               f := v.Field(sf.index)
+               if !f.IsNil() {
+                       // field already set
+                       continue
+               }
+               dv := sf.value
+               if dv == nil && !zeros {
+                       // no explicit default, and don't want to set zeros
+                       continue
+               }
+               fptr := f.Addr().Interface() // **T
+               // TODO: Consider batching the allocations we do here.
+               switch sf.kind {
+               case reflect.Bool:
+                       b := new(bool)
+                       if dv != nil {
+                               *b = dv.(bool)
+                       }
+                       *(fptr.(**bool)) = b
+               case reflect.Float32:
+                       f := new(float32)
+                       if dv != nil {
+                               *f = dv.(float32)
+                       }
+                       *(fptr.(**float32)) = f
+               case reflect.Float64:
+                       f := new(float64)
+                       if dv != nil {
+                               *f = dv.(float64)
+                       }
+                       *(fptr.(**float64)) = f
+               case reflect.Int32:
+                       // might be an enum
+                       if ft := f.Type(); ft != int32PtrType {
+                               // enum
+                               f.Set(reflect.New(ft.Elem()))
+                               if dv != nil {
+                                       f.Elem().SetInt(int64(dv.(int32)))
+                               }
+                       } else {
+                               // int32 field
+                               i := new(int32)
+                               if dv != nil {
+                                       *i = dv.(int32)
+                               }
+                               *(fptr.(**int32)) = i
+                       }
+               case reflect.Int64:
+                       i := new(int64)
+                       if dv != nil {
+                               *i = dv.(int64)
+                       }
+                       *(fptr.(**int64)) = i
+               case reflect.String:
+                       s := new(string)
+                       if dv != nil {
+                               *s = dv.(string)
+                       }
+                       *(fptr.(**string)) = s
+               case reflect.Uint8:
+                       // exceptional case: []byte
+                       var b []byte
+                       if dv != nil {
+                               db := dv.([]byte)
+                               b = make([]byte, len(db))
+                               copy(b, db)
+                       } else {
+                               b = []byte{}
+                       }
+                       *(fptr.(*[]byte)) = b
+               case reflect.Uint32:
+                       u := new(uint32)
+                       if dv != nil {
+                               *u = dv.(uint32)
+                       }
+                       *(fptr.(**uint32)) = u
+               case reflect.Uint64:
+                       u := new(uint64)
+                       if dv != nil {
+                               *u = dv.(uint64)
+                       }
+                       *(fptr.(**uint64)) = u
+               default:
+                       log.Printf("proto: can't set default for field %v (sf.kind=%v)", f, sf.kind)
+               }
+       }
+
+       for _, ni := range dm.nested {
+               f := v.Field(ni)
+               // f is *T or T or []*T or []T
+               switch f.Kind() {
+               case reflect.Struct:
+                       setDefaults(f, recur, zeros)
+
+               case reflect.Ptr:
+                       if f.IsNil() {
+                               continue
+                       }
+                       setDefaults(f, recur, zeros)
+
+               case reflect.Slice:
+                       for i := 0; i < f.Len(); i++ {
+                               e := f.Index(i)
+                               if e.Kind() == reflect.Ptr && e.IsNil() {
+                                       continue
+                               }
+                               setDefaults(e, recur, zeros)
+                       }
+
+               case reflect.Map:
+                       for _, k := range f.MapKeys() {
+                               e := f.MapIndex(k)
+                               if e.IsNil() {
+                                       continue
+                               }
+                               setDefaults(e, recur, zeros)
+                       }
+               }
+       }
+}
+
+var (
+       // defaults maps a protocol buffer struct type to a slice of the fields,
+       // with its scalar fields set to their proto-declared non-zero default values.
+       defaultMu sync.RWMutex
+       defaults  = make(map[reflect.Type]defaultMessage)
+
+       int32PtrType = reflect.TypeOf((*int32)(nil))
+)
+
+// defaultMessage represents information about the default values of a message.
+type defaultMessage struct {
+       scalars []scalarField
+       nested  []int // struct field index of nested messages
+}
+
+type scalarField struct {
+       index int          // struct field index
+       kind  reflect.Kind // element type (the T in *T or []T)
+       value interface{}  // the proto-declared default value, or nil
+}
+
+// t is a struct type.
+func buildDefaultMessage(t reflect.Type) (dm defaultMessage) {
+       sprop := GetProperties(t)
+       for _, prop := range sprop.Prop {
+               fi, ok := sprop.decoderTags.get(prop.Tag)
+               if !ok {
+                       // XXX_unrecognized
+                       continue
+               }
+               ft := t.Field(fi).Type
+
+               sf, nested, err := fieldDefault(ft, prop)
+               switch {
+               case err != nil:
+                       log.Print(err)
+               case nested:
+                       dm.nested = append(dm.nested, fi)
+               case sf != nil:
+                       sf.index = fi
+                       dm.scalars = append(dm.scalars, *sf)
+               }
+       }
+
+       return dm
+}
+
+// fieldDefault returns the scalarField for field type ft.
+// sf will be nil if the field can not have a default.
+// nestedMessage will be true if this is a nested message.
+// Note that sf.index is not set on return.
+func fieldDefault(ft reflect.Type, prop *Properties) (sf *scalarField, nestedMessage bool, err error) {
+       var canHaveDefault bool
+       switch ft.Kind() {
+       case reflect.Struct:
+               nestedMessage = true // non-nullable
+
+       case reflect.Ptr:
+               if ft.Elem().Kind() == reflect.Struct {
+                       nestedMessage = true
+               } else {
+                       canHaveDefault = true // proto2 scalar field
+               }
+
+       case reflect.Slice:
+               switch ft.Elem().Kind() {
+               case reflect.Ptr, reflect.Struct:
+                       nestedMessage = true // repeated message
+               case reflect.Uint8:
+                       canHaveDefault = true // bytes field
+               }
+
+       case reflect.Map:
+               if ft.Elem().Kind() == reflect.Ptr {
+                       nestedMessage = true // map with message values
+               }
+       }
+
+       if !canHaveDefault {
+               if nestedMessage {
+                       return nil, true, nil
+               }
+               return nil, false, nil
+       }
+
+       // We now know that ft is a pointer or slice.
+       sf = &scalarField{kind: ft.Elem().Kind()}
+
+       // scalar fields without defaults
+       if !prop.HasDefault {
+               return sf, false, nil
+       }
+
+       // a scalar field: either *T or []byte
+       switch ft.Elem().Kind() {
+       case reflect.Bool:
+               x, err := strconv.ParseBool(prop.Default)
+               if err != nil {
+                       return nil, false, fmt.Errorf("proto: bad default bool %q: %v", prop.Default, err)
+               }
+               sf.value = x
+       case reflect.Float32:
+               x, err := strconv.ParseFloat(prop.Default, 32)
+               if err != nil {
+                       return nil, false, fmt.Errorf("proto: bad default float32 %q: %v", prop.Default, err)
+               }
+               sf.value = float32(x)
+       case reflect.Float64:
+               x, err := strconv.ParseFloat(prop.Default, 64)
+               if err != nil {
+                       return nil, false, fmt.Errorf("proto: bad default float64 %q: %v", prop.Default, err)
+               }
+               sf.value = x
+       case reflect.Int32:
+               x, err := strconv.ParseInt(prop.Default, 10, 32)
+               if err != nil {
+                       return nil, false, fmt.Errorf("proto: bad default int32 %q: %v", prop.Default, err)
+               }
+               sf.value = int32(x)
+       case reflect.Int64:
+               x, err := strconv.ParseInt(prop.Default, 10, 64)
+               if err != nil {
+                       return nil, false, fmt.Errorf("proto: bad default int64 %q: %v", prop.Default, err)
+               }
+               sf.value = x
+       case reflect.String:
+               sf.value = prop.Default
+       case reflect.Uint8:
+               // []byte (not *uint8)
+               sf.value = []byte(prop.Default)
+       case reflect.Uint32:
+               x, err := strconv.ParseUint(prop.Default, 10, 32)
+               if err != nil {
+                       return nil, false, fmt.Errorf("proto: bad default uint32 %q: %v", prop.Default, err)
+               }
+               sf.value = uint32(x)
+       case reflect.Uint64:
+               x, err := strconv.ParseUint(prop.Default, 10, 64)
+               if err != nil {
+                       return nil, false, fmt.Errorf("proto: bad default uint64 %q: %v", prop.Default, err)
+               }
+               sf.value = x
+       default:
+               return nil, false, fmt.Errorf("proto: unhandled def kind %v", ft.Elem().Kind())
+       }
+
+       return sf, false, nil
+}
+
+// mapKeys returns a sort.Interface to be used for sorting the map keys.
+// Map fields may have key types of non-float scalars, strings and enums.
+func mapKeys(vs []reflect.Value) sort.Interface {
+       s := mapKeySorter{vs: vs}
+
+       // Type specialization per https://developers.google.com/protocol-buffers/docs/proto#maps.
+       if len(vs) == 0 {
+               return s
+       }
+       switch vs[0].Kind() {
+       case reflect.Int32, reflect.Int64:
+               s.less = func(a, b reflect.Value) bool { return a.Int() < b.Int() }
+       case reflect.Uint32, reflect.Uint64:
+               s.less = func(a, b reflect.Value) bool { return a.Uint() < b.Uint() }
+       case reflect.Bool:
+               s.less = func(a, b reflect.Value) bool { return !a.Bool() && b.Bool() } // false < true
+       case reflect.String:
+               s.less = func(a, b reflect.Value) bool { return a.String() < b.String() }
+       default:
+               panic(fmt.Sprintf("unsupported map key type: %v", vs[0].Kind()))
+       }
+
+       return s
+}
+
+type mapKeySorter struct {
+       vs   []reflect.Value
+       less func(a, b reflect.Value) bool
+}
+
+func (s mapKeySorter) Len() int      { return len(s.vs) }
+func (s mapKeySorter) Swap(i, j int) { s.vs[i], s.vs[j] = s.vs[j], s.vs[i] }
+func (s mapKeySorter) Less(i, j int) bool {
+       return s.less(s.vs[i], s.vs[j])
+}
+
+// isProto3Zero reports whether v is a zero proto3 value.
+func isProto3Zero(v reflect.Value) bool {
+       switch v.Kind() {
+       case reflect.Bool:
+               return !v.Bool()
+       case reflect.Int32, reflect.Int64:
+               return v.Int() == 0
+       case reflect.Uint32, reflect.Uint64:
+               return v.Uint() == 0
+       case reflect.Float32, reflect.Float64:
+               return v.Float() == 0
+       case reflect.String:
+               return v.String() == ""
+       }
+       return false
+}
+
+// ProtoPackageIsVersion2 is referenced from generated protocol buffer files
+// to assert that that code is compatible with this version of the proto package.
+const GoGoProtoPackageIsVersion2 = true
+
+// ProtoPackageIsVersion1 is referenced from generated protocol buffer files
+// to assert that that code is compatible with this version of the proto package.
+const GoGoProtoPackageIsVersion1 = true
+
+// InternalMessageInfo is a type used internally by generated .pb.go files.
+// This type is not intended to be used by non-generated code.
+// This type is not subject to any compatibility guarantee.
+type InternalMessageInfo struct {
+       marshal   *marshalInfo
+       unmarshal *unmarshalInfo
+       merge     *mergeInfo
+       discard   *discardInfo
+}

diff --git a/vendor/github.com/gogo/protobuf/proto/lib_gogo.go b/vendor/github.com/gogo/protobuf/proto/lib_gogo.go
new file mode 100644 (file)
index 0000000..b3aa391
--- /dev/null
+++ b/vendor/github.com/gogo/protobuf/proto/lib_gogo.go
@@ -0,0 +1,50 @@
+// Protocol Buffers for Go with Gadgets
+//
+// Copyright (c) 2013, The GoGo Authors. All rights reserved.
+// http://github.com/gogo/protobuf
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//     * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//     * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+package proto
+
+import (
+       "encoding/json"
+       "strconv"
+)
+
+type Sizer interface {
+       Size() int
+}
+
+type ProtoSizer interface {
+       ProtoSize() int
+}
+
+func MarshalJSONEnum(m map[int32]string, value int32) ([]byte, error) {
+       s, ok := m[value]
+       if !ok {
+               s = strconv.Itoa(int(value))
+       }
+       return json.Marshal(s)
+}

diff --git a/vendor/github.com/gogo/protobuf/proto/map_test.go b/vendor/github.com/gogo/protobuf/proto/map_test.go
new file mode 100644 (file)
index 0000000..467791b
--- /dev/null
+++ b/vendor/github.com/gogo/protobuf/proto/map_test.go
@@ -0,0 +1,70 @@
+package proto_test
+
+import (
+       "fmt"
+       "reflect"
+       "testing"
+
+       "github.com/gogo/protobuf/proto"
+       ppb "github.com/gogo/protobuf/proto/proto3_proto"
+)
+
+func TestMap(t *testing.T) {
+       var b []byte
+       fmt.Sscanf("a2010c0a044b657931120456616c31a201130a044b657932120556616c3261120456616c32a201240a044b6579330d05000000120556616c33621a0556616c3361120456616c331505000000a20100a201260a044b657934130a07536f6d6555524c1209536f6d655469746c651a08536e69707065743114", "%x", &b)
+
+       var m ppb.Message
+       if err := proto.Unmarshal(b, &m); err != nil {
+               t.Fatalf("proto.Unmarshal error: %v", err)
+       }
+
+       got := m.StringMap
+       want := map[string]string{
+               "":     "",
+               "Key1": "Val1",
+               "Key2": "Val2",
+               "Key3": "Val3",
+               "Key4": "",
+       }
+
+       if !reflect.DeepEqual(got, want) {
+               t.Errorf("maps differ:\ngot  %#v\nwant %#v", got, want)
+       }
+}
+
+func marshalled() []byte {
+       m := &ppb.IntMaps{}
+       for i := 0; i < 1000; i++ {
+               m.Maps = append(m.Maps, &ppb.IntMap{
+                       Rtt: map[int32]int32{1: 2},
+               })
+       }
+       b, err := proto.Marshal(m)
+       if err != nil {
+               panic(fmt.Sprintf("Can't marshal %+v: %v", m, err))
+       }
+       return b
+}
+
+func BenchmarkConcurrentMapUnmarshal(b *testing.B) {
+       in := marshalled()
+       b.RunParallel(func(pb *testing.PB) {
+               for pb.Next() {
+                       var out ppb.IntMaps
+                       if err := proto.Unmarshal(in, &out); err != nil {
+                               b.Errorf("Can't unmarshal ppb.IntMaps: %v", err)
+                       }
+               }
+       })
+}
+
+func BenchmarkSequentialMapUnmarshal(b *testing.B) {
+       in := marshalled()
+       b.ResetTimer()
+       for i := 0; i < b.N; i++ {
+               var out ppb.IntMaps
+               if err := proto.Unmarshal(in, &out); err != nil {
+                       b.Errorf("Can't unmarshal ppb.IntMaps: %v", err)
+               }
+       }
+}

diff --git a/vendor/github.com/gogo/protobuf/proto/message_set.go b/vendor/github.com/gogo/protobuf/proto/message_set.go
new file mode 100644 (file)
index 0000000..f48a756
--- /dev/null
+++ b/vendor/github.com/gogo/protobuf/proto/message_set.go
@@ -0,0 +1,181 @@
+// Go support for Protocol Buffers - Google's data interchange format
+//
+// Copyright 2010 The Go Authors.  All rights reserved.
+// https://github.com/golang/protobuf
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//     * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//     * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//     * Neither the name of Google Inc. nor the names of its
+// contributors may be used to endorse or promote products derived from
+// this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+package proto
+
+/*
+ * Support for message sets.
+ */
+
+import (
+       "errors"
+)
+
+// errNoMessageTypeID occurs when a protocol buffer does not have a message type ID.
+// A message type ID is required for storing a protocol buffer in a message set.
+var errNoMessageTypeID = errors.New("proto does not have a message type ID")
+
+// The first two types (_MessageSet_Item and messageSet)
+// model what the protocol compiler produces for the following protocol message:
+//   message MessageSet {
+//     repeated group Item = 1 {
+//       required int32 type_id = 2;
+//       required string message = 3;
+//     };
+//   }
+// That is the MessageSet wire format. We can't use a proto to generate these
+// because that would introduce a circular dependency between it and this package.
+
+type _MessageSet_Item struct {
+       TypeId  *int32 `protobuf:"varint,2,req,name=type_id"`
+       Message []byte `protobuf:"bytes,3,req,name=message"`
+}
+
+type messageSet struct {
+       Item             []*_MessageSet_Item `protobuf:"group,1,rep"`
+       XXX_unrecognized []byte
+       // TODO: caching?
+}
+
+// Make sure messageSet is a Message.
+var _ Message = (*messageSet)(nil)
+
+// messageTypeIder is an interface satisfied by a protocol buffer type
+// that may be stored in a MessageSet.
+type messageTypeIder interface {
+       MessageTypeId() int32
+}
+
+func (ms *messageSet) find(pb Message) *_MessageSet_Item {
+       mti, ok := pb.(messageTypeIder)
+       if !ok {
+               return nil
+       }
+       id := mti.MessageTypeId()
+       for _, item := range ms.Item {
+               if *item.TypeId == id {
+                       return item
+               }
+       }
+       return nil
+}
+
+func (ms *messageSet) Has(pb Message) bool {
+       return ms.find(pb) != nil
+}
+
+func (ms *messageSet) Unmarshal(pb Message) error {
+       if item := ms.find(pb); item != nil {
+               return Unmarshal(item.Message, pb)
+       }
+       if _, ok := pb.(messageTypeIder); !ok {
+               return errNoMessageTypeID
+       }
+       return nil // TODO: return error instead?
+}
+
+func (ms *messageSet) Marshal(pb Message) error {
+       msg, err := Marshal(pb)
+       if err != nil {
+               return err
+       }
+       if item := ms.find(pb); item != nil {
+               // reuse existing item
+               item.Message = msg
+               return nil
+       }
+
+       mti, ok := pb.(messageTypeIder)
+       if !ok {
+               return errNoMessageTypeID
+       }
+
+       mtid := mti.MessageTypeId()
+       ms.Item = append(ms.Item, &_MessageSet_Item{
+               TypeId:  &mtid,
+               Message: msg,
+       })
+       return nil
+}
+
+func (ms *messageSet) Reset()         { *ms = messageSet{} }
+func (ms *messageSet) String() string { return CompactTextString(ms) }
+func (*messageSet) ProtoMessage()     {}
+
+// Support for the message_set_wire_format message option.
+
+func skipVarint(buf []byte) []byte {
+       i := 0
+       for ; buf[i]&0x80 != 0; i++ {
+       }
+       return buf[i+1:]
+}
+
+// unmarshalMessageSet decodes the extension map encoded in buf in the message set wire format.
+// It is called by Unmarshal methods on protocol buffer messages with the message_set_wire_format option.
+func unmarshalMessageSet(buf []byte, exts interface{}) error {
+       var m map[int32]Extension
+       switch exts := exts.(type) {
+       case *XXX_InternalExtensions:
+               m = exts.extensionsWrite()
+       case map[int32]Extension:
+               m = exts
+       default:
+               return errors.New("proto: not an extension map")
+       }
+
+       ms := new(messageSet)
+       if err := Unmarshal(buf, ms); err != nil {
+               return err
+       }
+       for _, item := range ms.Item {
+               id := *item.TypeId
+               msg := item.Message
+
+               // Restore wire type and field number varint, plus length varint.
+               // Be careful to preserve duplicate items.
+               b := EncodeVarint(uint64(id)<<3 | WireBytes)
+               if ext, ok := m[id]; ok {
+                       // Existing data; rip off the tag and length varint
+                       // so we join the new data correctly.
+                       // We can assume that ext.enc is set because we are unmarshaling.
+                       o := ext.enc[len(b):]   // skip wire type and field number
+                       _, n := DecodeVarint(o) // calculate length of length varint
+                       o = o[n:]               // skip length varint
+                       msg = append(o, msg...) // join old data and new data
+               }
+               b = append(b, EncodeVarint(uint64(len(msg)))...)
+               b = append(b, msg...)
+
+               m[id] = Extension{enc: b}
+       }
+       return nil
+}

diff --git a/vendor/github.com/gogo/protobuf/proto/message_set_test.go b/vendor/github.com/gogo/protobuf/proto/message_set_test.go
new file mode 100644 (file)
index 0000000..29c40d3
--- /dev/null
+++ b/vendor/github.com/gogo/protobuf/proto/message_set_test.go
@@ -0,0 +1,88 @@
+// Go support for Protocol Buffers - Google's data interchange format
+//
+// Copyright 2014 The Go Authors.  All rights reserved.
+// https://github.com/golang/protobuf
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//     * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//     * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//     * Neither the name of Google Inc. nor the names of its
+// contributors may be used to endorse or promote products derived from
+// this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+package proto_test
+
+import (
+       "bytes"
+       "fmt"
+       "testing"
+
+       "github.com/gogo/protobuf/proto"
+       . "github.com/gogo/protobuf/proto/test_proto"
+)
+
+func TestUnmarshalMessageSetWithDuplicate(t *testing.T) {
+       /*
+               Message{
+                       Tag{1, StartGroup},
+                       Message{
+                               Tag{2, Varint}, Uvarint(12345),
+                               Tag{3, Bytes}, Bytes("hoo"),
+                       },
+                       Tag{1, EndGroup},
+                       Tag{1, StartGroup},
+                       Message{
+                               Tag{2, Varint}, Uvarint(12345),
+                               Tag{3, Bytes}, Bytes("hah"),
+                       },
+                       Tag{1, EndGroup},
+               }
+       */
+       var in []byte
+       fmt.Sscanf("0b10b9601a03686f6f0c0b10b9601a036861680c", "%x", &in)
+
+       /*
+               Message{
+                       Tag{1, StartGroup},
+                       Message{
+                               Tag{2, Varint}, Uvarint(12345),
+                               Tag{3, Bytes}, Bytes("hoohah"),
+                       },
+                       Tag{1, EndGroup},
+               }
+       */
+       var want []byte
+       fmt.Sscanf("0b10b9601a06686f6f6861680c", "%x", &want)
+
+       var m MyMessageSet
+       if err := proto.Unmarshal(in, &m); err != nil {
+               t.Fatalf("unexpected Unmarshal error: %v", err)
+       }
+       got, err := proto.Marshal(&m)
+       if err != nil {
+               t.Fatalf("unexpected Marshal error: %v", err)
+       }
+
+       if !bytes.Equal(got, want) {
+               t.Errorf("output mismatch:\ngot  %x\nwant %x", got, want)
+       }
+}

diff --git a/vendor/github.com/gogo/protobuf/proto/pointer_reflect.go b/vendor/github.com/gogo/protobuf/proto/pointer_reflect.go
new file mode 100644 (file)
index 0000000..b6cad90
--- /dev/null
+++ b/vendor/github.com/gogo/protobuf/proto/pointer_reflect.go
@@ -0,0 +1,357 @@
+// Go support for Protocol Buffers - Google's data interchange format
+//
+// Copyright 2012 The Go Authors.  All rights reserved.
+// https://github.com/golang/protobuf
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//     * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//     * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//     * Neither the name of Google Inc. nor the names of its
+// contributors may be used to endorse or promote products derived from
+// this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+// +build purego appengine js
+
+// This file contains an implementation of proto field accesses using package reflect.
+// It is slower than the code in pointer_unsafe.go but it avoids package unsafe and can
+// be used on App Engine.
+
+package proto
+
+import (
+       "reflect"
+       "sync"
+)
+
+const unsafeAllowed = false
+
+// A field identifies a field in a struct, accessible from a pointer.
+// In this implementation, a field is identified by the sequence of field indices
+// passed to reflect's FieldByIndex.
+type field []int
+
+// toField returns a field equivalent to the given reflect field.
+func toField(f *reflect.StructField) field {
+       return f.Index
+}
+
+// invalidField is an invalid field identifier.
+var invalidField = field(nil)
+
+// zeroField is a noop when calling pointer.offset.
+var zeroField = field([]int{})
+
+// IsValid reports whether the field identifier is valid.
+func (f field) IsValid() bool { return f != nil }
+
+// The pointer type is for the table-driven decoder.
+// The implementation here uses a reflect.Value of pointer type to
+// create a generic pointer. In pointer_unsafe.go we use unsafe
+// instead of reflect to implement the same (but faster) interface.
+type pointer struct {
+       v reflect.Value
+}
+
+// toPointer converts an interface of pointer type to a pointer
+// that points to the same target.
+func toPointer(i *Message) pointer {
+       return pointer{v: reflect.ValueOf(*i)}
+}
+
+// toAddrPointer converts an interface to a pointer that points to
+// the interface data.
+func toAddrPointer(i *interface{}, isptr bool) pointer {
+       v := reflect.ValueOf(*i)
+       u := reflect.New(v.Type())
+       u.Elem().Set(v)
+       return pointer{v: u}
+}
+
+// valToPointer converts v to a pointer.  v must be of pointer type.
+func valToPointer(v reflect.Value) pointer {
+       return pointer{v: v}
+}
+
+// offset converts from a pointer to a structure to a pointer to
+// one of its fields.
+func (p pointer) offset(f field) pointer {
+       return pointer{v: p.v.Elem().FieldByIndex(f).Addr()}
+}
+
+func (p pointer) isNil() bool {
+       return p.v.IsNil()
+}
+
+// grow updates the slice s in place to make it one element longer.
+// s must be addressable.
+// Returns the (addressable) new element.
+func grow(s reflect.Value) reflect.Value {
+       n, m := s.Len(), s.Cap()
+       if n < m {
+               s.SetLen(n + 1)
+       } else {
+               s.Set(reflect.Append(s, reflect.Zero(s.Type().Elem())))
+       }
+       return s.Index(n)
+}
+
+func (p pointer) toInt64() *int64 {
+       return p.v.Interface().(*int64)
+}
+func (p pointer) toInt64Ptr() **int64 {
+       return p.v.Interface().(**int64)
+}
+func (p pointer) toInt64Slice() *[]int64 {
+       return p.v.Interface().(*[]int64)
+}
+
+var int32ptr = reflect.TypeOf((*int32)(nil))
+
+func (p pointer) toInt32() *int32 {
+       return p.v.Convert(int32ptr).Interface().(*int32)
+}
+
+// The toInt32Ptr/Slice methods don't work because of enums.
+// Instead, we must use set/get methods for the int32ptr/slice case.
+/*
+       func (p pointer) toInt32Ptr() **int32 {
+               return p.v.Interface().(**int32)
+}
+       func (p pointer) toInt32Slice() *[]int32 {
+               return p.v.Interface().(*[]int32)
+}
+*/
+func (p pointer) getInt32Ptr() *int32 {
+       if p.v.Type().Elem().Elem() == reflect.TypeOf(int32(0)) {
+               // raw int32 type
+               return p.v.Elem().Interface().(*int32)
+       }
+       // an enum
+       return p.v.Elem().Convert(int32PtrType).Interface().(*int32)
+}
+func (p pointer) setInt32Ptr(v int32) {
+       // Allocate value in a *int32. Possibly convert that to a *enum.
+       // Then assign it to a **int32 or **enum.
+       // Note: we can convert *int32 to *enum, but we can't convert
+       // **int32 to **enum!
+       p.v.Elem().Set(reflect.ValueOf(&v).Convert(p.v.Type().Elem()))
+}
+
+// getInt32Slice copies []int32 from p as a new slice.
+// This behavior differs from the implementation in pointer_unsafe.go.
+func (p pointer) getInt32Slice() []int32 {
+       if p.v.Type().Elem().Elem() == reflect.TypeOf(int32(0)) {
+               // raw int32 type
+               return p.v.Elem().Interface().([]int32)
+       }
+       // an enum
+       // Allocate a []int32, then assign []enum's values into it.
+       // Note: we can't convert []enum to []int32.
+       slice := p.v.Elem()
+       s := make([]int32, slice.Len())
+       for i := 0; i < slice.Len(); i++ {
+               s[i] = int32(slice.Index(i).Int())
+       }
+       return s
+}
+
+// setInt32Slice copies []int32 into p as a new slice.
+// This behavior differs from the implementation in pointer_unsafe.go.
+func (p pointer) setInt32Slice(v []int32) {
+       if p.v.Type().Elem().Elem() == reflect.TypeOf(int32(0)) {
+               // raw int32 type
+               p.v.Elem().Set(reflect.ValueOf(v))
+               return
+       }
+       // an enum
+       // Allocate a []enum, then assign []int32's values into it.
+       // Note: we can't convert []enum to []int32.
+       slice := reflect.MakeSlice(p.v.Type().Elem(), len(v), cap(v))
+       for i, x := range v {
+               slice.Index(i).SetInt(int64(x))
+       }
+       p.v.Elem().Set(slice)
+}
+func (p pointer) appendInt32Slice(v int32) {
+       grow(p.v.Elem()).SetInt(int64(v))
+}
+
+func (p pointer) toUint64() *uint64 {
+       return p.v.Interface().(*uint64)
+}
+func (p pointer) toUint64Ptr() **uint64 {
+       return p.v.Interface().(**uint64)
+}
+func (p pointer) toUint64Slice() *[]uint64 {
+       return p.v.Interface().(*[]uint64)
+}
+func (p pointer) toUint32() *uint32 {
+       return p.v.Interface().(*uint32)
+}
+func (p pointer) toUint32Ptr() **uint32 {
+       return p.v.Interface().(**uint32)
+}
+func (p pointer) toUint32Slice() *[]uint32 {
+       return p.v.Interface().(*[]uint32)
+}
+func (p pointer) toBool() *bool {
+       return p.v.Interface().(*bool)
+}
+func (p pointer) toBoolPtr() **bool {
+       return p.v.Interface().(**bool)
+}
+func (p pointer) toBoolSlice() *[]bool {
+       return p.v.Interface().(*[]bool)
+}
+func (p pointer) toFloat64() *float64 {
+       return p.v.Interface().(*float64)
+}
+func (p pointer) toFloat64Ptr() **float64 {
+       return p.v.Interface().(**float64)
+}
+func (p pointer) toFloat64Slice() *[]float64 {
+       return p.v.Interface().(*[]float64)
+}
+func (p pointer) toFloat32() *float32 {
+       return p.v.Interface().(*float32)
+}
+func (p pointer) toFloat32Ptr() **float32 {
+       return p.v.Interface().(**float32)
+}
+func (p pointer) toFloat32Slice() *[]float32 {
+       return p.v.Interface().(*[]float32)
+}
+func (p pointer) toString() *string {
+       return p.v.Interface().(*string)
+}
+func (p pointer) toStringPtr() **string {
+       return p.v.Interface().(**string)
+}
+func (p pointer) toStringSlice() *[]string {
+       return p.v.Interface().(*[]string)
+}
+func (p pointer) toBytes() *[]byte {
+       return p.v.Interface().(*[]byte)
+}
+func (p pointer) toBytesSlice() *[][]byte {
+       return p.v.Interface().(*[][]byte)
+}
+func (p pointer) toExtensions() *XXX_InternalExtensions {
+       return p.v.Interface().(*XXX_InternalExtensions)
+}
+func (p pointer) toOldExtensions() *map[int32]Extension {
+       return p.v.Interface().(*map[int32]Extension)
+}
+func (p pointer) getPointer() pointer {
+       return pointer{v: p.v.Elem()}
+}
+func (p pointer) setPointer(q pointer) {
+       p.v.Elem().Set(q.v)
+}
+func (p pointer) appendPointer(q pointer) {
+       grow(p.v.Elem()).Set(q.v)
+}
+
+// getPointerSlice copies []*T from p as a new []pointer.
+// This behavior differs from the implementation in pointer_unsafe.go.
+func (p pointer) getPointerSlice() []pointer {
+       if p.v.IsNil() {
+               return nil
+       }
+       n := p.v.Elem().Len()
+       s := make([]pointer, n)
+       for i := 0; i < n; i++ {
+               s[i] = pointer{v: p.v.Elem().Index(i)}
+       }
+       return s
+}
+
+// setPointerSlice copies []pointer into p as a new []*T.
+// This behavior differs from the implementation in pointer_unsafe.go.
+func (p pointer) setPointerSlice(v []pointer) {
+       if v == nil {
+               p.v.Elem().Set(reflect.New(p.v.Elem().Type()).Elem())
+               return
+       }
+       s := reflect.MakeSlice(p.v.Elem().Type(), 0, len(v))
+       for _, p := range v {
+               s = reflect.Append(s, p.v)
+       }
+       p.v.Elem().Set(s)
+}
+
+// getInterfacePointer returns a pointer that points to the
+// interface data of the interface pointed by p.
+func (p pointer) getInterfacePointer() pointer {
+       if p.v.Elem().IsNil() {
+               return pointer{v: p.v.Elem()}
+       }
+       return pointer{v: p.v.Elem().Elem().Elem().Field(0).Addr()} // *interface -> interface -> *struct -> struct
+}
+
+func (p pointer) asPointerTo(t reflect.Type) reflect.Value {
+       // TODO: check that p.v.Type().Elem() == t?
+       return p.v
+}
+
+func atomicLoadUnmarshalInfo(p **unmarshalInfo) *unmarshalInfo {
+       atomicLock.Lock()
+       defer atomicLock.Unlock()
+       return *p
+}
+func atomicStoreUnmarshalInfo(p **unmarshalInfo, v *unmarshalInfo) {
+       atomicLock.Lock()
+       defer atomicLock.Unlock()
+       *p = v
+}
+func atomicLoadMarshalInfo(p **marshalInfo) *marshalInfo {
+       atomicLock.Lock()
+       defer atomicLock.Unlock()
+       return *p
+}
+func atomicStoreMarshalInfo(p **marshalInfo, v *marshalInfo) {
+       atomicLock.Lock()
+       defer atomicLock.Unlock()
+       *p = v
+}
+func atomicLoadMergeInfo(p **mergeInfo) *mergeInfo {
+       atomicLock.Lock()
+       defer atomicLock.Unlock()
+       return *p
+}
+func atomicStoreMergeInfo(p **mergeInfo, v *mergeInfo) {
+       atomicLock.Lock()
+       defer atomicLock.Unlock()
+       *p = v
+}
+func atomicLoadDiscardInfo(p **discardInfo) *discardInfo {
+       atomicLock.Lock()
+       defer atomicLock.Unlock()
+       return *p
+}
+func atomicStoreDiscardInfo(p **discardInfo, v *discardInfo) {
+       atomicLock.Lock()
+       defer atomicLock.Unlock()
+       *p = v
+}
+
+var atomicLock sync.Mutex

diff --git a/vendor/github.com/gogo/protobuf/proto/pointer_reflect_gogo.go b/vendor/github.com/gogo/protobuf/proto/pointer_reflect_gogo.go
new file mode 100644 (file)
index 0000000..7ffd3c2
--- /dev/null
+++ b/vendor/github.com/gogo/protobuf/proto/pointer_reflect_gogo.go
@@ -0,0 +1,59 @@
+// Protocol Buffers for Go with Gadgets
+//
+// Copyright (c) 2018, The GoGo Authors. All rights reserved.
+// http://github.com/gogo/protobuf
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//     * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//     * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+// +build purego appengine js
+
+// This file contains an implementation of proto field accesses using package reflect.
+// It is slower than the code in pointer_unsafe.go but it avoids package unsafe and can
+// be used on App Engine.
+
+package proto
+
+import (
+       "reflect"
+)
+
+// TODO: untested, so probably incorrect.
+
+func (p pointer) getRef() pointer {
+       return pointer{v: p.v.Addr()}
+}
+
+func (p pointer) appendRef(v pointer, typ reflect.Type) {
+       slice := p.getSlice(typ)
+       elem := v.asPointerTo(typ).Elem()
+       newSlice := reflect.Append(slice, elem)
+       slice.Set(newSlice)
+}
+
+func (p pointer) getSlice(typ reflect.Type) reflect.Value {
+       sliceTyp := reflect.SliceOf(typ)
+       slice := p.asPointerTo(sliceTyp)
+       slice = slice.Elem()
+       return slice
+}

diff --git a/vendor/github.com/gogo/protobuf/proto/pointer_unsafe.go b/vendor/github.com/gogo/protobuf/proto/pointer_unsafe.go
new file mode 100644 (file)
index 0000000..d55a335
--- /dev/null
+++ b/vendor/github.com/gogo/protobuf/proto/pointer_unsafe.go
@@ -0,0 +1,308 @@
+// Go support for Protocol Buffers - Google's data interchange format
+//
+// Copyright 2012 The Go Authors.  All rights reserved.
+// https://github.com/golang/protobuf
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//     * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//     * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//     * Neither the name of Google Inc. nor the names of its
+// contributors may be used to endorse or promote products derived from
+// this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+// +build !purego,!appengine,!js
+
+// This file contains the implementation of the proto field accesses using package unsafe.
+
+package proto
+
+import (
+       "reflect"
+       "sync/atomic"
+       "unsafe"
+)
+
+const unsafeAllowed = true
+
+// A field identifies a field in a struct, accessible from a pointer.
+// In this implementation, a field is identified by its byte offset from the start of the struct.
+type field uintptr
+
+// toField returns a field equivalent to the given reflect field.
+func toField(f *reflect.StructField) field {
+       return field(f.Offset)
+}
+
+// invalidField is an invalid field identifier.
+const invalidField = ^field(0)
+
+// zeroField is a noop when calling pointer.offset.
+const zeroField = field(0)
+
+// IsValid reports whether the field identifier is valid.
+func (f field) IsValid() bool {
+       return f != invalidField
+}
+
+// The pointer type below is for the new table-driven encoder/decoder.
+// The implementation here uses unsafe.Pointer to create a generic pointer.
+// In pointer_reflect.go we use reflect instead of unsafe to implement
+// the same (but slower) interface.
+type pointer struct {
+       p unsafe.Pointer
+}
+
+// size of pointer
+var ptrSize = unsafe.Sizeof(uintptr(0))
+
+// toPointer converts an interface of pointer type to a pointer
+// that points to the same target.
+func toPointer(i *Message) pointer {
+       // Super-tricky - read pointer out of data word of interface value.
+       // Saves ~25ns over the equivalent:
+       // return valToPointer(reflect.ValueOf(*i))
+       return pointer{p: (*[2]unsafe.Pointer)(unsafe.Pointer(i))[1]}
+}
+
+// toAddrPointer converts an interface to a pointer that points to
+// the interface data.
+func toAddrPointer(i *interface{}, isptr bool) pointer {
+       // Super-tricky - read or get the address of data word of interface value.
+       if isptr {
+               // The interface is of pointer type, thus it is a direct interface.
+               // The data word is the pointer data itself. We take its address.
+               return pointer{p: unsafe.Pointer(uintptr(unsafe.Pointer(i)) + ptrSize)}
+       }
+       // The interface is not of pointer type. The data word is the pointer
+       // to the data.
+       return pointer{p: (*[2]unsafe.Pointer)(unsafe.Pointer(i))[1]}
+}
+
+// valToPointer converts v to a pointer. v must be of pointer type.
+func valToPointer(v reflect.Value) pointer {
+       return pointer{p: unsafe.Pointer(v.Pointer())}
+}
+
+// offset converts from a pointer to a structure to a pointer to
+// one of its fields.
+func (p pointer) offset(f field) pointer {
+       // For safety, we should panic if !f.IsValid, however calling panic causes
+       // this to no longer be inlineable, which is a serious performance cost.
+       /*
+               if !f.IsValid() {
+                       panic("invalid field")
+               }
+       */
+       return pointer{p: unsafe.Pointer(uintptr(p.p) + uintptr(f))}
+}
+
+func (p pointer) isNil() bool {
+       return p.p == nil
+}
+
+func (p pointer) toInt64() *int64 {
+       return (*int64)(p.p)
+}
+func (p pointer) toInt64Ptr() **int64 {
+       return (**int64)(p.p)
+}
+func (p pointer) toInt64Slice() *[]int64 {
+       return (*[]int64)(p.p)
+}
+func (p pointer) toInt32() *int32 {
+       return (*int32)(p.p)
+}
+
+// See pointer_reflect.go for why toInt32Ptr/Slice doesn't exist.
+/*
+       func (p pointer) toInt32Ptr() **int32 {
+               return (**int32)(p.p)
+       }
+       func (p pointer) toInt32Slice() *[]int32 {
+               return (*[]int32)(p.p)
+       }
+*/
+func (p pointer) getInt32Ptr() *int32 {
+       return *(**int32)(p.p)
+}
+func (p pointer) setInt32Ptr(v int32) {
+       *(**int32)(p.p) = &v
+}
+
+// getInt32Slice loads a []int32 from p.
+// The value returned is aliased with the original slice.
+// This behavior differs from the implementation in pointer_reflect.go.
+func (p pointer) getInt32Slice() []int32 {
+       return *(*[]int32)(p.p)
+}
+
+// setInt32Slice stores a []int32 to p.
+// The value set is aliased with the input slice.
+// This behavior differs from the implementation in pointer_reflect.go.
+func (p pointer) setInt32Slice(v []int32) {
+       *(*[]int32)(p.p) = v
+}
+
+// TODO: Can we get rid of appendInt32Slice and use setInt32Slice instead?
+func (p pointer) appendInt32Slice(v int32) {
+       s := (*[]int32)(p.p)
+       *s = append(*s, v)
+}
+
+func (p pointer) toUint64() *uint64 {
+       return (*uint64)(p.p)
+}
+func (p pointer) toUint64Ptr() **uint64 {
+       return (**uint64)(p.p)
+}
+func (p pointer) toUint64Slice() *[]uint64 {
+       return (*[]uint64)(p.p)
+}
+func (p pointer) toUint32() *uint32 {
+       return (*uint32)(p.p)
+}
+func (p pointer) toUint32Ptr() **uint32 {
+       return (**uint32)(p.p)
+}
+func (p pointer) toUint32Slice() *[]uint32 {
+       return (*[]uint32)(p.p)
+}
+func (p pointer) toBool() *bool {
+       return (*bool)(p.p)
+}
+func (p pointer) toBoolPtr() **bool {
+       return (**bool)(p.p)
+}
+func (p pointer) toBoolSlice() *[]bool {
+       return (*[]bool)(p.p)
+}
+func (p pointer) toFloat64() *float64 {
+       return (*float64)(p.p)
+}
+func (p pointer) toFloat64Ptr() **float64 {
+       return (**float64)(p.p)
+}
+func (p pointer) toFloat64Slice() *[]float64 {
+       return (*[]float64)(p.p)
+}
+func (p pointer) toFloat32() *float32 {
+       return (*float32)(p.p)
+}
+func (p pointer) toFloat32Ptr() **float32 {
+       return (**float32)(p.p)
+}
+func (p pointer) toFloat32Slice() *[]float32 {
+       return (*[]float32)(p.p)
+}
+func (p pointer) toString() *string {
+       return (*string)(p.p)
+}
+func (p pointer) toStringPtr() **string {
+       return (**string)(p.p)
+}
+func (p pointer) toStringSlice() *[]string {
+       return (*[]string)(p.p)
+}
+func (p pointer) toBytes() *[]byte {
+       return (*[]byte)(p.p)
+}
+func (p pointer) toBytesSlice() *[][]byte {
+       return (*[][]byte)(p.p)
+}
+func (p pointer) toExtensions() *XXX_InternalExtensions {
+       return (*XXX_InternalExtensions)(p.p)
+}
+func (p pointer) toOldExtensions() *map[int32]Extension {
+       return (*map[int32]Extension)(p.p)
+}
+
+// getPointerSlice loads []*T from p as a []pointer.
+// The value returned is aliased with the original slice.
+// This behavior differs from the implementation in pointer_reflect.go.
+func (p pointer) getPointerSlice() []pointer {
+       // Super-tricky - p should point to a []*T where T is a
+       // message type. We load it as []pointer.
+       return *(*[]pointer)(p.p)
+}
+
+// setPointerSlice stores []pointer into p as a []*T.
+// The value set is aliased with the input slice.
+// This behavior differs from the implementation in pointer_reflect.go.
+func (p pointer) setPointerSlice(v []pointer) {
+       // Super-tricky - p should point to a []*T where T is a
+       // message type. We store it as []pointer.
+       *(*[]pointer)(p.p) = v
+}
+
+// getPointer loads the pointer at p and returns it.
+func (p pointer) getPointer() pointer {
+       return pointer{p: *(*unsafe.Pointer)(p.p)}
+}
+
+// setPointer stores the pointer q at p.
+func (p pointer) setPointer(q pointer) {
+       *(*unsafe.Pointer)(p.p) = q.p
+}
+
+// append q to the slice pointed to by p.
+func (p pointer) appendPointer(q pointer) {
+       s := (*[]unsafe.Pointer)(p.p)
+       *s = append(*s, q.p)
+}
+
+// getInterfacePointer returns a pointer that points to the
+// interface data of the interface pointed by p.
+func (p pointer) getInterfacePointer() pointer {
+       // Super-tricky - read pointer out of data word of interface value.
+       return pointer{p: (*(*[2]unsafe.Pointer)(p.p))[1]}
+}
+
+// asPointerTo returns a reflect.Value that is a pointer to an
+// object of type t stored at p.
+func (p pointer) asPointerTo(t reflect.Type) reflect.Value {
+       return reflect.NewAt(t, p.p)
+}
+
+func atomicLoadUnmarshalInfo(p **unmarshalInfo) *unmarshalInfo {
+       return (*unmarshalInfo)(atomic.LoadPointer((*unsafe.Pointer)(unsafe.Pointer(p))))
+}
+func atomicStoreUnmarshalInfo(p **unmarshalInfo, v *unmarshalInfo) {
+       atomic.StorePointer((*unsafe.Pointer)(unsafe.Pointer(p)), unsafe.Pointer(v))
+}
+func atomicLoadMarshalInfo(p **marshalInfo) *marshalInfo {
+       return (*marshalInfo)(atomic.LoadPointer((*unsafe.Pointer)(unsafe.Pointer(p))))
+}
+func atomicStoreMarshalInfo(p **marshalInfo, v *marshalInfo) {
+       atomic.StorePointer((*unsafe.Pointer)(unsafe.Pointer(p)), unsafe.Pointer(v))
+}
+func atomicLoadMergeInfo(p **mergeInfo) *mergeInfo {
+       return (*mergeInfo)(atomic.LoadPointer((*unsafe.Pointer)(unsafe.Pointer(p))))
+}
+func atomicStoreMergeInfo(p **mergeInfo, v *mergeInfo) {
+       atomic.StorePointer((*unsafe.Pointer)(unsafe.Pointer(p)), unsafe.Pointer(v))
+}
+func atomicLoadDiscardInfo(p **discardInfo) *discardInfo {
+       return (*discardInfo)(atomic.LoadPointer((*unsafe.Pointer)(unsafe.Pointer(p))))
+}
+func atomicStoreDiscardInfo(p **discardInfo, v *discardInfo) {
+       atomic.StorePointer((*unsafe.Pointer)(unsafe.Pointer(p)), unsafe.Pointer(v))
+}

diff --git a/vendor/github.com/gogo/protobuf/proto/pointer_unsafe_gogo.go b/vendor/github.com/gogo/protobuf/proto/pointer_unsafe_gogo.go
new file mode 100644 (file)
index 0000000..aca8eed
--- /dev/null
+++ b/vendor/github.com/gogo/protobuf/proto/pointer_unsafe_gogo.go
@@ -0,0 +1,56 @@
+// Protocol Buffers for Go with Gadgets
+//
+// Copyright (c) 2018, The GoGo Authors. All rights reserved.
+// http://github.com/gogo/protobuf
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//     * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//     * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+// +build !purego,!appengine,!js
+
+// This file contains the implementation of the proto field accesses using package unsafe.
+
+package proto
+
+import (
+       "reflect"
+       "unsafe"
+)
+
+func (p pointer) getRef() pointer {
+       return pointer{p: (unsafe.Pointer)(&p.p)}
+}
+
+func (p pointer) appendRef(v pointer, typ reflect.Type) {
+       slice := p.getSlice(typ)
+       elem := v.asPointerTo(typ).Elem()
+       newSlice := reflect.Append(slice, elem)
+       slice.Set(newSlice)
+}
+
+func (p pointer) getSlice(typ reflect.Type) reflect.Value {
+       sliceTyp := reflect.SliceOf(typ)
+       slice := p.asPointerTo(sliceTyp)
+       slice = slice.Elem()
+       return slice
+}

diff --git a/vendor/github.com/gogo/protobuf/proto/properties.go b/vendor/github.com/gogo/protobuf/proto/properties.go
new file mode 100644 (file)
index 0000000..c9e5fa0
--- /dev/null
+++ b/vendor/github.com/gogo/protobuf/proto/properties.go
@@ -0,0 +1,599 @@
+// Protocol Buffers for Go with Gadgets
+//
+// Copyright (c) 2013, The GoGo Authors. All rights reserved.
+// http://github.com/gogo/protobuf
+//
+// Go support for Protocol Buffers - Google's data interchange format
+//
+// Copyright 2010 The Go Authors.  All rights reserved.
+// https://github.com/golang/protobuf
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//     * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//     * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//     * Neither the name of Google Inc. nor the names of its
+// contributors may be used to endorse or promote products derived from
+// this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+package proto
+
+/*
+ * Routines for encoding data into the wire format for protocol buffers.
+ */
+
+import (
+       "fmt"
+       "log"
+       "os"
+       "reflect"
+       "sort"
+       "strconv"
+       "strings"
+       "sync"
+)
+
+const debug bool = false
+
+// Constants that identify the encoding of a value on the wire.
+const (
+       WireVarint     = 0
+       WireFixed64    = 1
+       WireBytes      = 2
+       WireStartGroup = 3
+       WireEndGroup   = 4
+       WireFixed32    = 5
+)
+
+// tagMap is an optimization over map[int]int for typical protocol buffer
+// use-cases. Encoded protocol buffers are often in tag order with small tag
+// numbers.
+type tagMap struct {
+       fastTags []int
+       slowTags map[int]int
+}
+
+// tagMapFastLimit is the upper bound on the tag number that will be stored in
+// the tagMap slice rather than its map.
+const tagMapFastLimit = 1024
+
+func (p *tagMap) get(t int) (int, bool) {
+       if t > 0 && t < tagMapFastLimit {
+               if t >= len(p.fastTags) {
+                       return 0, false
+               }
+               fi := p.fastTags[t]
+               return fi, fi >= 0
+       }
+       fi, ok := p.slowTags[t]
+       return fi, ok
+}
+
+func (p *tagMap) put(t int, fi int) {
+       if t > 0 && t < tagMapFastLimit {
+               for len(p.fastTags) < t+1 {
+                       p.fastTags = append(p.fastTags, -1)
+               }
+               p.fastTags[t] = fi
+               return
+       }
+       if p.slowTags == nil {
+               p.slowTags = make(map[int]int)
+       }
+       p.slowTags[t] = fi
+}
+
+// StructProperties represents properties for all the fields of a struct.
+// decoderTags and decoderOrigNames should only be used by the decoder.
+type StructProperties struct {
+       Prop             []*Properties  // properties for each field
+       reqCount         int            // required count
+       decoderTags      tagMap         // map from proto tag to struct field number
+       decoderOrigNames map[string]int // map from original name to struct field number
+       order            []int          // list of struct field numbers in tag order
+
+       // OneofTypes contains information about the oneof fields in this message.
+       // It is keyed by the original name of a field.
+       OneofTypes map[string]*OneofProperties
+}
+
+// OneofProperties represents information about a specific field in a oneof.
+type OneofProperties struct {
+       Type  reflect.Type // pointer to generated struct type for this oneof field
+       Field int          // struct field number of the containing oneof in the message
+       Prop  *Properties
+}
+
+// Implement the sorting interface so we can sort the fields in tag order, as recommended by the spec.
+// See encode.go, (*Buffer).enc_struct.
+
+func (sp *StructProperties) Len() int { return len(sp.order) }
+func (sp *StructProperties) Less(i, j int) bool {
+       return sp.Prop[sp.order[i]].Tag < sp.Prop[sp.order[j]].Tag
+}
+func (sp *StructProperties) Swap(i, j int) { sp.order[i], sp.order[j] = sp.order[j], sp.order[i] }
+
+// Properties represents the protocol-specific behavior of a single struct field.
+type Properties struct {
+       Name     string // name of the field, for error messages
+       OrigName string // original name before protocol compiler (always set)
+       JSONName string // name to use for JSON; determined by protoc
+       Wire     string
+       WireType int
+       Tag      int
+       Required bool
+       Optional bool
+       Repeated bool
+       Packed   bool   // relevant for repeated primitives only
+       Enum     string // set for enum types only
+       proto3   bool   // whether this is known to be a proto3 field
+       oneof    bool   // whether this is a oneof field
+
+       Default     string // default value
+       HasDefault  bool   // whether an explicit default was provided
+       CustomType  string
+       CastType    string
+       StdTime     bool
+       StdDuration bool
+       WktPointer  bool
+
+       stype reflect.Type      // set for struct types only
+       ctype reflect.Type      // set for custom types only
+       sprop *StructProperties // set for struct types only
+
+       mtype      reflect.Type // set for map types only
+       MapKeyProp *Properties  // set for map types only
+       MapValProp *Properties  // set for map types only
+}
+
+// String formats the properties in the protobuf struct field tag style.
+func (p *Properties) String() string {
+       s := p.Wire
+       s += ","
+       s += strconv.Itoa(p.Tag)
+       if p.Required {
+               s += ",req"
+       }
+       if p.Optional {
+               s += ",opt"
+       }
+       if p.Repeated {
+               s += ",rep"
+       }
+       if p.Packed {
+               s += ",packed"
+       }
+       s += ",name=" + p.OrigName
+       if p.JSONName != p.OrigName {
+               s += ",json=" + p.JSONName
+       }
+       if p.proto3 {
+               s += ",proto3"
+       }
+       if p.oneof {
+               s += ",oneof"
+       }
+       if len(p.Enum) > 0 {
+               s += ",enum=" + p.Enum
+       }
+       if p.HasDefault {
+               s += ",def=" + p.Default
+       }
+       return s
+}
+
+// Parse populates p by parsing a string in the protobuf struct field tag style.
+func (p *Properties) Parse(s string) {
+       // "bytes,49,opt,name=foo,def=hello!"
+       fields := strings.Split(s, ",") // breaks def=, but handled below.
+       if len(fields) < 2 {
+               fmt.Fprintf(os.Stderr, "proto: tag has too few fields: %q\n", s)
+               return
+       }
+
+       p.Wire = fields[0]
+       switch p.Wire {
+       case "varint":
+               p.WireType = WireVarint
+       case "fixed32":
+               p.WireType = WireFixed32
+       case "fixed64":
+               p.WireType = WireFixed64
+       case "zigzag32":
+               p.WireType = WireVarint
+       case "zigzag64":
+               p.WireType = WireVarint
+       case "bytes", "group":
+               p.WireType = WireBytes
+               // no numeric converter for non-numeric types
+       default:
+               fmt.Fprintf(os.Stderr, "proto: tag has unknown wire type: %q\n", s)
+               return
+       }
+
+       var err error
+       p.Tag, err = strconv.Atoi(fields[1])
+       if err != nil {
+               return
+       }
+
+outer:
+       for i := 2; i < len(fields); i++ {
+               f := fields[i]
+               switch {
+               case f == "req":
+                       p.Required = true
+               case f == "opt":
+                       p.Optional = true
+               case f == "rep":
+                       p.Repeated = true
+               case f == "packed":
+                       p.Packed = true
+               case strings.HasPrefix(f, "name="):
+                       p.OrigName = f[5:]
+               case strings.HasPrefix(f, "json="):
+                       p.JSONName = f[5:]
+               case strings.HasPrefix(f, "enum="):
+                       p.Enum = f[5:]
+               case f == "proto3":
+                       p.proto3 = true
+               case f == "oneof":
+                       p.oneof = true
+               case strings.HasPrefix(f, "def="):
+                       p.HasDefault = true
+                       p.Default = f[4:] // rest of string
+                       if i+1 < len(fields) {
+                               // Commas aren't escaped, and def is always last.
+                               p.Default += "," + strings.Join(fields[i+1:], ",")
+                               break outer
+                       }
+               case strings.HasPrefix(f, "embedded="):
+                       p.OrigName = strings.Split(f, "=")[1]
+               case strings.HasPrefix(f, "customtype="):
+                       p.CustomType = strings.Split(f, "=")[1]
+               case strings.HasPrefix(f, "casttype="):
+                       p.CastType = strings.Split(f, "=")[1]
+               case f == "stdtime":
+                       p.StdTime = true
+               case f == "stdduration":
+                       p.StdDuration = true
+               case f == "wktptr":
+                       p.WktPointer = true
+               }
+       }
+}
+
+var protoMessageType = reflect.TypeOf((*Message)(nil)).Elem()
+
+// setFieldProps initializes the field properties for submessages and maps.
+func (p *Properties) setFieldProps(typ reflect.Type, f *reflect.StructField, lockGetProp bool) {
+       isMap := typ.Kind() == reflect.Map
+       if len(p.CustomType) > 0 && !isMap {
+               p.ctype = typ
+               p.setTag(lockGetProp)
+               return
+       }
+       if p.StdTime && !isMap {
+               p.setTag(lockGetProp)
+               return
+       }
+       if p.StdDuration && !isMap {
+               p.setTag(lockGetProp)
+               return
+       }
+       if p.WktPointer && !isMap {
+               p.setTag(lockGetProp)
+               return
+       }
+       switch t1 := typ; t1.Kind() {
+       case reflect.Struct:
+               p.stype = typ
+       case reflect.Ptr:
+               if t1.Elem().Kind() == reflect.Struct {
+                       p.stype = t1.Elem()
+               }
+       case reflect.Slice:
+               switch t2 := t1.Elem(); t2.Kind() {
+               case reflect.Ptr:
+                       switch t3 := t2.Elem(); t3.Kind() {
+                       case reflect.Struct:
+                               p.stype = t3
+                       }
+               case reflect.Struct:
+                       p.stype = t2
+               }
+
+       case reflect.Map:
+
+               p.mtype = t1
+               p.MapKeyProp = &Properties{}
+               p.MapKeyProp.init(reflect.PtrTo(p.mtype.Key()), "Key", f.Tag.Get("protobuf_key"), nil, lockGetProp)
+               p.MapValProp = &Properties{}
+               vtype := p.mtype.Elem()
+               if vtype.Kind() != reflect.Ptr && vtype.Kind() != reflect.Slice {
+                       // The value type is not a message (*T) or bytes ([]byte),
+                       // so we need encoders for the pointer to this type.
+                       vtype = reflect.PtrTo(vtype)
+               }
+
+               p.MapValProp.CustomType = p.CustomType
+               p.MapValProp.StdDuration = p.StdDuration
+               p.MapValProp.StdTime = p.StdTime
+               p.MapValProp.WktPointer = p.WktPointer
+               p.MapValProp.init(vtype, "Value", f.Tag.Get("protobuf_val"), nil, lockGetProp)
+       }
+       p.setTag(lockGetProp)
+}
+
+func (p *Properties) setTag(lockGetProp bool) {
+       if p.stype != nil {
+               if lockGetProp {
+                       p.sprop = GetProperties(p.stype)
+               } else {
+                       p.sprop = getPropertiesLocked(p.stype)
+               }
+       }
+}
+
+var (
+       marshalerType = reflect.TypeOf((*Marshaler)(nil)).Elem()
+)
+
+// Init populates the properties from a protocol buffer struct tag.
+func (p *Properties) Init(typ reflect.Type, name, tag string, f *reflect.StructField) {
+       p.init(typ, name, tag, f, true)
+}
+
+func (p *Properties) init(typ reflect.Type, name, tag string, f *reflect.StructField, lockGetProp bool) {
+       // "bytes,49,opt,def=hello!"
+       p.Name = name
+       p.OrigName = name
+       if tag == "" {
+               return
+       }
+       p.Parse(tag)
+       p.setFieldProps(typ, f, lockGetProp)
+}
+
+var (
+       propertiesMu  sync.RWMutex
+       propertiesMap = make(map[reflect.Type]*StructProperties)
+)
+
+// GetProperties returns the list of properties for the type represented by t.
+// t must represent a generated struct type of a protocol message.
+func GetProperties(t reflect.Type) *StructProperties {
+       if t.Kind() != reflect.Struct {
+               panic("proto: type must have kind struct")
+       }
+
+       // Most calls to GetProperties in a long-running program will be
+       // retrieving details for types we have seen before.
+       propertiesMu.RLock()
+       sprop, ok := propertiesMap[t]
+       propertiesMu.RUnlock()
+       if ok {
+               return sprop
+       }
+
+       propertiesMu.Lock()
+       sprop = getPropertiesLocked(t)
+       propertiesMu.Unlock()
+       return sprop
+}
+
+// getPropertiesLocked requires that propertiesMu is held.
+func getPropertiesLocked(t reflect.Type) *StructProperties {
+       if prop, ok := propertiesMap[t]; ok {
+               return prop
+       }
+
+       prop := new(StructProperties)
+       // in case of recursive protos, fill this in now.
+       propertiesMap[t] = prop
+
+       // build properties
+       prop.Prop = make([]*Properties, t.NumField())
+       prop.order = make([]int, t.NumField())
+
+       isOneofMessage := false
+       for i := 0; i < t.NumField(); i++ {
+               f := t.Field(i)
+               p := new(Properties)
+               name := f.Name
+               p.init(f.Type, name, f.Tag.Get("protobuf"), &f, false)
+
+               oneof := f.Tag.Get("protobuf_oneof") // special case
+               if oneof != "" {
+                       isOneofMessage = true
+                       // Oneof fields don't use the traditional protobuf tag.
+                       p.OrigName = oneof
+               }
+               prop.Prop[i] = p
+               prop.order[i] = i
+               if debug {
+                       print(i, " ", f.Name, " ", t.String(), " ")
+                       if p.Tag > 0 {
+                               print(p.String())
+                       }
+                       print("\n")
+               }
+       }
+
+       // Re-order prop.order.
+       sort.Sort(prop)
+
+       type oneofMessage interface {
+               XXX_OneofFuncs() (func(Message, *Buffer) error, func(Message, int, int, *Buffer) (bool, error), func(Message) int, []interface{})
+       }
+       if om, ok := reflect.Zero(reflect.PtrTo(t)).Interface().(oneofMessage); isOneofMessage && ok {
+               var oots []interface{}
+               _, _, _, oots = om.XXX_OneofFuncs()
+
+               // Interpret oneof metadata.
+               prop.OneofTypes = make(map[string]*OneofProperties)
+               for _, oot := range oots {
+                       oop := &OneofProperties{
+                               Type: reflect.ValueOf(oot).Type(), // *T
+                               Prop: new(Properties),
+                       }
+                       sft := oop.Type.Elem().Field(0)
+                       oop.Prop.Name = sft.Name
+                       oop.Prop.Parse(sft.Tag.Get("protobuf"))
+                       // There will be exactly one interface field that
+                       // this new value is assignable to.
+                       for i := 0; i < t.NumField(); i++ {
+                               f := t.Field(i)
+                               if f.Type.Kind() != reflect.Interface {
+                                       continue
+                               }
+                               if !oop.Type.AssignableTo(f.Type) {
+                                       continue
+                               }
+                               oop.Field = i
+                               break
+                       }
+                       prop.OneofTypes[oop.Prop.OrigName] = oop
+               }
+       }
+
+       // build required counts
+       // build tags
+       reqCount := 0
+       prop.decoderOrigNames = make(map[string]int)
+       for i, p := range prop.Prop {
+               if strings.HasPrefix(p.Name, "XXX_") {
+                       // Internal fields should not appear in tags/origNames maps.
+                       // They are handled specially when encoding and decoding.
+                       continue
+               }
+               if p.Required {
+                       reqCount++
+               }
+               prop.decoderTags.put(p.Tag, i)
+               prop.decoderOrigNames[p.OrigName] = i
+       }
+       prop.reqCount = reqCount
+
+       return prop
+}
+
+// A global registry of enum types.
+// The generated code will register the generated maps by calling RegisterEnum.
+
+var enumValueMaps = make(map[string]map[string]int32)
+var enumStringMaps = make(map[string]map[int32]string)
+
+// RegisterEnum is called from the generated code to install the enum descriptor
+// maps into the global table to aid parsing text format protocol buffers.
+func RegisterEnum(typeName string, unusedNameMap map[int32]string, valueMap map[string]int32) {
+       if _, ok := enumValueMaps[typeName]; ok {
+               panic("proto: duplicate enum registered: " + typeName)
+       }
+       enumValueMaps[typeName] = valueMap
+       if _, ok := enumStringMaps[typeName]; ok {
+               panic("proto: duplicate enum registered: " + typeName)
+       }
+       enumStringMaps[typeName] = unusedNameMap
+}
+
+// EnumValueMap returns the mapping from names to integers of the
+// enum type enumType, or a nil if not found.
+func EnumValueMap(enumType string) map[string]int32 {
+       return enumValueMaps[enumType]
+}
+
+// A registry of all linked message types.
+// The string is a fully-qualified proto name ("pkg.Message").
+var (
+       protoTypedNils = make(map[string]Message)      // a map from proto names to typed nil pointers
+       protoMapTypes  = make(map[string]reflect.Type) // a map from proto names to map types
+       revProtoTypes  = make(map[reflect.Type]string)
+)
+
+// RegisterType is called from generated code and maps from the fully qualified
+// proto name to the type (pointer to struct) of the protocol buffer.
+func RegisterType(x Message, name string) {
+       if _, ok := protoTypedNils[name]; ok {
+               // TODO: Some day, make this a panic.
+               log.Printf("proto: duplicate proto type registered: %s", name)
+               return
+       }
+       t := reflect.TypeOf(x)
+       if v := reflect.ValueOf(x); v.Kind() == reflect.Ptr && v.Pointer() == 0 {
+               // Generated code always calls RegisterType with nil x.
+               // This check is just for extra safety.
+               protoTypedNils[name] = x
+       } else {
+               protoTypedNils[name] = reflect.Zero(t).Interface().(Message)
+       }
+       revProtoTypes[t] = name
+}
+
+// RegisterMapType is called from generated code and maps from the fully qualified
+// proto name to the native map type of the proto map definition.
+func RegisterMapType(x interface{}, name string) {
+       if reflect.TypeOf(x).Kind() != reflect.Map {
+               panic(fmt.Sprintf("RegisterMapType(%T, %q); want map", x, name))
+       }
+       if _, ok := protoMapTypes[name]; ok {
+               log.Printf("proto: duplicate proto type registered: %s", name)
+               return
+       }
+       t := reflect.TypeOf(x)
+       protoMapTypes[name] = t
+       revProtoTypes[t] = name
+}
+
+// MessageName returns the fully-qualified proto name for the given message type.
+func MessageName(x Message) string {
+       type xname interface {
+               XXX_MessageName() string
+       }
+       if m, ok := x.(xname); ok {
+               return m.XXX_MessageName()
+       }
+       return revProtoTypes[reflect.TypeOf(x)]
+}
+
+// MessageType returns the message type (pointer to struct) for a named message.
+// The type is not guaranteed to implement proto.Message if the name refers to a
+// map entry.
+func MessageType(name string) reflect.Type {
+       if t, ok := protoTypedNils[name]; ok {
+               return reflect.TypeOf(t)
+       }
+       return protoMapTypes[name]
+}
+
+// A registry of all linked proto files.
+var (
+       protoFiles = make(map[string][]byte) // file name => fileDescriptor
+)
+
+// RegisterFile is called from generated code and maps from the
+// full file name of a .proto file to its compressed FileDescriptorProto.
+func RegisterFile(filename string, fileDescriptor []byte) {
+       protoFiles[filename] = fileDescriptor
+}
+
+// FileDescriptor returns the compressed FileDescriptorProto for a .proto file.
+func FileDescriptor(filename string) []byte { return protoFiles[filename] }

diff --git a/vendor/github.com/gogo/protobuf/proto/properties_gogo.go b/vendor/github.com/gogo/protobuf/proto/properties_gogo.go
new file mode 100644 (file)
index 0000000..40ea3dd
--- /dev/null
+++ b/vendor/github.com/gogo/protobuf/proto/properties_gogo.go
@@ -0,0 +1,36 @@
+// Protocol Buffers for Go with Gadgets
+//
+// Copyright (c) 2018, The GoGo Authors. All rights reserved.
+// http://github.com/gogo/protobuf
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//     * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//     * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+package proto
+
+import (
+       "reflect"
+)
+
+var sizerType = reflect.TypeOf((*Sizer)(nil)).Elem()
+var protosizerType = reflect.TypeOf((*ProtoSizer)(nil)).Elem()

diff --git a/vendor/github.com/gogo/protobuf/proto/proto3_proto/Makefile b/vendor/github.com/gogo/protobuf/proto/proto3_proto/Makefile
new file mode 100644 (file)
index 0000000..158782f
--- /dev/null
+++ b/vendor/github.com/gogo/protobuf/proto/proto3_proto/Makefile
@@ -0,0 +1,7 @@
+regenerate:
+       go install github.com/gogo/protobuf/protoc-min-version
+       protoc-min-version --version="3.0.0" --gogo_out=\
+       Mtest_proto/test.proto=github.com/gogo/protobuf/proto/test_proto,\
+       Mgoogle/protobuf/any.proto=github.com/gogo/protobuf/types:. \
+       --proto_path=../../protobuf:../:. proto3.proto
+       

diff --git a/vendor/github.com/gogo/protobuf/proto/proto3_proto/proto3.pb.go b/vendor/github.com/gogo/protobuf/proto/proto3_proto/proto3.pb.go
new file mode 100644 (file)
index 0000000..973c726
--- /dev/null
+++ b/vendor/github.com/gogo/protobuf/proto/proto3_proto/proto3.pb.go
@@ -0,0 +1,615 @@
+// Code generated by protoc-gen-gogo. DO NOT EDIT.
+// source: proto3.proto
+
+package proto3_proto
+
+import (
+       fmt "fmt"
+       proto "github.com/gogo/protobuf/proto"
+       test_proto "github.com/gogo/protobuf/proto/test_proto"
+       types "github.com/gogo/protobuf/types"
+       math "math"
+)
+
+// Reference imports to suppress errors if they are not otherwise used.
+var _ = proto.Marshal
+var _ = fmt.Errorf
+var _ = math.Inf
+
+// This is a compile-time assertion to ensure that this generated file
+// is compatible with the proto package it is being compiled against.
+// A compilation error at this line likely means your copy of the
+// proto package needs to be updated.
+const _ = proto.GoGoProtoPackageIsVersion2 // please upgrade the proto package
+
+type Message_Humour int32
+
+const (
+       Message_UNKNOWN     Message_Humour = 0
+       Message_PUNS        Message_Humour = 1
+       Message_SLAPSTICK   Message_Humour = 2
+       Message_BILL_BAILEY Message_Humour = 3
+)
+
+var Message_Humour_name = map[int32]string{
+       0: "UNKNOWN",
+       1: "PUNS",
+       2: "SLAPSTICK",
+       3: "BILL_BAILEY",
+}
+
+var Message_Humour_value = map[string]int32{
+       "UNKNOWN":     0,
+       "PUNS":        1,
+       "SLAPSTICK":   2,
+       "BILL_BAILEY": 3,
+}
+
+func (x Message_Humour) String() string {
+       return proto.EnumName(Message_Humour_name, int32(x))
+}
+
+func (Message_Humour) EnumDescriptor() ([]byte, []int) {
+       return fileDescriptor_4fee6d65e34a64b6, []int{0, 0}
+}
+
+type Message struct {
+       Name                 string                             `protobuf:"bytes,1,opt,name=name,proto3" json:"name,omitempty"`
+       Hilarity             Message_Humour                     `protobuf:"varint,2,opt,name=hilarity,proto3,enum=proto3_proto.Message_Humour" json:"hilarity,omitempty"`
+       HeightInCm           uint32                             `protobuf:"varint,3,opt,name=height_in_cm,json=heightInCm,proto3" json:"height_in_cm,omitempty"`
+       Data                 []byte                             `protobuf:"bytes,4,opt,name=data,proto3" json:"data,omitempty"`
+       ResultCount          int64                              `protobuf:"varint,7,opt,name=result_count,json=resultCount,proto3" json:"result_count,omitempty"`
+       TrueScotsman         bool                               `protobuf:"varint,8,opt,name=true_scotsman,json=trueScotsman,proto3" json:"true_scotsman,omitempty"`
+       Score                float32                            `protobuf:"fixed32,9,opt,name=score,proto3" json:"score,omitempty"`
+       Key                  []uint64                           `protobuf:"varint,5,rep,packed,name=key,proto3" json:"key,omitempty"`
+       ShortKey             []int32                            `protobuf:"varint,19,rep,packed,name=short_key,json=shortKey,proto3" json:"short_key,omitempty"`
+       Nested               *Nested                            `protobuf:"bytes,6,opt,name=nested,proto3" json:"nested,omitempty"`
+       RFunny               []Message_Humour                   `protobuf:"varint,16,rep,packed,name=r_funny,json=rFunny,proto3,enum=proto3_proto.Message_Humour" json:"r_funny,omitempty"`
+       Terrain              map[string]*Nested                 `protobuf:"bytes,10,rep,name=terrain,proto3" json:"terrain,omitempty" protobuf_key:"bytes,1,opt,name=key,proto3" protobuf_val:"bytes,2,opt,name=value,proto3"`
+       Proto2Field          *test_proto.SubDefaults            `protobuf:"bytes,11,opt,name=proto2_field,json=proto2Field,proto3" json:"proto2_field,omitempty"`
+       Proto2Value          map[string]*test_proto.SubDefaults `protobuf:"bytes,13,rep,name=proto2_value,json=proto2Value,proto3" json:"proto2_value,omitempty" protobuf_key:"bytes,1,opt,name=key,proto3" protobuf_val:"bytes,2,opt,name=value,proto3"`
+       Anything             *types.Any                         `protobuf:"bytes,14,opt,name=anything,proto3" json:"anything,omitempty"`
+       ManyThings           []*types.Any                       `protobuf:"bytes,15,rep,name=many_things,json=manyThings,proto3" json:"many_things,omitempty"`
+       Submessage           *Message                           `protobuf:"bytes,17,opt,name=submessage,proto3" json:"submessage,omitempty"`
+       Children             []*Message                         `protobuf:"bytes,18,rep,name=children,proto3" json:"children,omitempty"`
+       StringMap            map[string]string                  `protobuf:"bytes,20,rep,name=string_map,json=stringMap,proto3" json:"string_map,omitempty" protobuf_key:"bytes,1,opt,name=key,proto3" protobuf_val:"bytes,2,opt,name=value,proto3"`
+       XXX_NoUnkeyedLiteral struct{}                           `json:"-"`
+       XXX_unrecognized     []byte                             `json:"-"`
+       XXX_sizecache        int32                              `json:"-"`
+}
+
+func (m *Message) Reset()         { *m = Message{} }
+func (m *Message) String() string { return proto.CompactTextString(m) }
+func (*Message) ProtoMessage()    {}
+func (*Message) Descriptor() ([]byte, []int) {
+       return fileDescriptor_4fee6d65e34a64b6, []int{0}
+}
+func (m *Message) XXX_Unmarshal(b []byte) error {
+       return xxx_messageInfo_Message.Unmarshal(m, b)
+}
+func (m *Message) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+       return xxx_messageInfo_Message.Marshal(b, m, deterministic)
+}
+func (m *Message) XXX_Merge(src proto.Message) {
+       xxx_messageInfo_Message.Merge(m, src)
+}
+func (m *Message) XXX_Size() int {
+       return xxx_messageInfo_Message.Size(m)
+}
+func (m *Message) XXX_DiscardUnknown() {
+       xxx_messageInfo_Message.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_Message proto.InternalMessageInfo
+
+func (m *Message) GetName() string {
+       if m != nil {
+               return m.Name
+       }
+       return ""
+}
+
+func (m *Message) GetHilarity() Message_Humour {
+       if m != nil {
+               return m.Hilarity
+       }
+       return Message_UNKNOWN
+}
+
+func (m *Message) GetHeightInCm() uint32 {
+       if m != nil {
+               return m.HeightInCm
+       }
+       return 0
+}
+
+func (m *Message) GetData() []byte {
+       if m != nil {
+               return m.Data
+       }
+       return nil
+}
+
+func (m *Message) GetResultCount() int64 {
+       if m != nil {
+               return m.ResultCount
+       }
+       return 0
+}
+
+func (m *Message) GetTrueScotsman() bool {
+       if m != nil {
+               return m.TrueScotsman
+       }
+       return false
+}
+
+func (m *Message) GetScore() float32 {
+       if m != nil {
+               return m.Score
+       }
+       return 0
+}
+
+func (m *Message) GetKey() []uint64 {
+       if m != nil {
+               return m.Key
+       }
+       return nil
+}
+
+func (m *Message) GetShortKey() []int32 {
+       if m != nil {
+               return m.ShortKey
+       }
+       return nil
+}
+
+func (m *Message) GetNested() *Nested {
+       if m != nil {
+               return m.Nested
+       }
+       return nil
+}
+
+func (m *Message) GetRFunny() []Message_Humour {
+       if m != nil {
+               return m.RFunny
+       }
+       return nil
+}
+
+func (m *Message) GetTerrain() map[string]*Nested {
+       if m != nil {
+               return m.Terrain
+       }
+       return nil
+}
+
+func (m *Message) GetProto2Field() *test_proto.SubDefaults {
+       if m != nil {
+               return m.Proto2Field
+       }
+       return nil
+}
+
+func (m *Message) GetProto2Value() map[string]*test_proto.SubDefaults {
+       if m != nil {
+               return m.Proto2Value
+       }
+       return nil
+}
+
+func (m *Message) GetAnything() *types.Any {
+       if m != nil {
+               return m.Anything
+       }
+       return nil
+}
+
+func (m *Message) GetManyThings() []*types.Any {
+       if m != nil {
+               return m.ManyThings
+       }
+       return nil
+}
+
+func (m *Message) GetSubmessage() *Message {
+       if m != nil {
+               return m.Submessage
+       }
+       return nil
+}
+
+func (m *Message) GetChildren() []*Message {
+       if m != nil {
+               return m.Children
+       }
+       return nil
+}
+
+func (m *Message) GetStringMap() map[string]string {
+       if m != nil {
+               return m.StringMap
+       }
+       return nil
+}
+
+type Nested struct {
+       Bunny                string   `protobuf:"bytes,1,opt,name=bunny,proto3" json:"bunny,omitempty"`
+       Cute                 bool     `protobuf:"varint,2,opt,name=cute,proto3" json:"cute,omitempty"`
+       XXX_NoUnkeyedLiteral struct{} `json:"-"`
+       XXX_unrecognized     []byte   `json:"-"`
+       XXX_sizecache        int32    `json:"-"`
+}
+
+func (m *Nested) Reset()         { *m = Nested{} }
+func (m *Nested) String() string { return proto.CompactTextString(m) }
+func (*Nested) ProtoMessage()    {}
+func (*Nested) Descriptor() ([]byte, []int) {
+       return fileDescriptor_4fee6d65e34a64b6, []int{1}
+}
+func (m *Nested) XXX_Unmarshal(b []byte) error {
+       return xxx_messageInfo_Nested.Unmarshal(m, b)
+}
+func (m *Nested) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+       return xxx_messageInfo_Nested.Marshal(b, m, deterministic)
+}
+func (m *Nested) XXX_Merge(src proto.Message) {
+       xxx_messageInfo_Nested.Merge(m, src)
+}
+func (m *Nested) XXX_Size() int {
+       return xxx_messageInfo_Nested.Size(m)
+}
+func (m *Nested) XXX_DiscardUnknown() {
+       xxx_messageInfo_Nested.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_Nested proto.InternalMessageInfo
+
+func (m *Nested) GetBunny() string {
+       if m != nil {
+               return m.Bunny
+       }
+       return ""
+}
+
+func (m *Nested) GetCute() bool {
+       if m != nil {
+               return m.Cute
+       }
+       return false
+}
+
+type MessageWithMap struct {
+       ByteMapping          map[bool][]byte `protobuf:"bytes,1,rep,name=byte_mapping,json=byteMapping,proto3" json:"byte_mapping,omitempty" protobuf_key:"varint,1,opt,name=key,proto3" protobuf_val:"bytes,2,opt,name=value,proto3"`
+       XXX_NoUnkeyedLiteral struct{}        `json:"-"`
+       XXX_unrecognized     []byte          `json:"-"`
+       XXX_sizecache        int32           `json:"-"`
+}
+
+func (m *MessageWithMap) Reset()         { *m = MessageWithMap{} }
+func (m *MessageWithMap) String() string { return proto.CompactTextString(m) }
+func (*MessageWithMap) ProtoMessage()    {}
+func (*MessageWithMap) Descriptor() ([]byte, []int) {
+       return fileDescriptor_4fee6d65e34a64b6, []int{2}
+}
+func (m *MessageWithMap) XXX_Unmarshal(b []byte) error {
+       return xxx_messageInfo_MessageWithMap.Unmarshal(m, b)
+}
+func (m *MessageWithMap) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+       return xxx_messageInfo_MessageWithMap.Marshal(b, m, deterministic)
+}
+func (m *MessageWithMap) XXX_Merge(src proto.Message) {
+       xxx_messageInfo_MessageWithMap.Merge(m, src)
+}
+func (m *MessageWithMap) XXX_Size() int {
+       return xxx_messageInfo_MessageWithMap.Size(m)
+}
+func (m *MessageWithMap) XXX_DiscardUnknown() {
+       xxx_messageInfo_MessageWithMap.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_MessageWithMap proto.InternalMessageInfo
+
+func (m *MessageWithMap) GetByteMapping() map[bool][]byte {
+       if m != nil {
+               return m.ByteMapping
+       }
+       return nil
+}
+
+type IntMap struct {
+       Rtt                  map[int32]int32 `protobuf:"bytes,1,rep,name=rtt,proto3" json:"rtt,omitempty" protobuf_key:"varint,1,opt,name=key,proto3" protobuf_val:"varint,2,opt,name=value,proto3"`
+       XXX_NoUnkeyedLiteral struct{}        `json:"-"`
+       XXX_unrecognized     []byte          `json:"-"`
+       XXX_sizecache        int32           `json:"-"`
+}
+
+func (m *IntMap) Reset()         { *m = IntMap{} }
+func (m *IntMap) String() string { return proto.CompactTextString(m) }
+func (*IntMap) ProtoMessage()    {}
+func (*IntMap) Descriptor() ([]byte, []int) {
+       return fileDescriptor_4fee6d65e34a64b6, []int{3}
+}
+func (m *IntMap) XXX_Unmarshal(b []byte) error {
+       return xxx_messageInfo_IntMap.Unmarshal(m, b)
+}
+func (m *IntMap) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+       return xxx_messageInfo_IntMap.Marshal(b, m, deterministic)
+}
+func (m *IntMap) XXX_Merge(src proto.Message) {
+       xxx_messageInfo_IntMap.Merge(m, src)
+}
+func (m *IntMap) XXX_Size() int {
+       return xxx_messageInfo_IntMap.Size(m)
+}
+func (m *IntMap) XXX_DiscardUnknown() {
+       xxx_messageInfo_IntMap.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_IntMap proto.InternalMessageInfo
+
+func (m *IntMap) GetRtt() map[int32]int32 {
+       if m != nil {
+               return m.Rtt
+       }
+       return nil
+}
+
+type IntMaps struct {
+       Maps                 []*IntMap `protobuf:"bytes,1,rep,name=maps,proto3" json:"maps,omitempty"`
+       XXX_NoUnkeyedLiteral struct{}  `json:"-"`
+       XXX_unrecognized     []byte    `json:"-"`
+       XXX_sizecache        int32     `json:"-"`
+}
+
+func (m *IntMaps) Reset()         { *m = IntMaps{} }
+func (m *IntMaps) String() string { return proto.CompactTextString(m) }
+func (*IntMaps) ProtoMessage()    {}
+func (*IntMaps) Descriptor() ([]byte, []int) {
+       return fileDescriptor_4fee6d65e34a64b6, []int{4}
+}
+func (m *IntMaps) XXX_Unmarshal(b []byte) error {
+       return xxx_messageInfo_IntMaps.Unmarshal(m, b)
+}
+func (m *IntMaps) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+       return xxx_messageInfo_IntMaps.Marshal(b, m, deterministic)
+}
+func (m *IntMaps) XXX_Merge(src proto.Message) {
+       xxx_messageInfo_IntMaps.Merge(m, src)
+}
+func (m *IntMaps) XXX_Size() int {
+       return xxx_messageInfo_IntMaps.Size(m)
+}
+func (m *IntMaps) XXX_DiscardUnknown() {
+       xxx_messageInfo_IntMaps.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_IntMaps proto.InternalMessageInfo
+
+func (m *IntMaps) GetMaps() []*IntMap {
+       if m != nil {
+               return m.Maps
+       }
+       return nil
+}
+
+type TestUTF8 struct {
+       Scalar string   `protobuf:"bytes,1,opt,name=scalar,proto3" json:"scalar,omitempty"`
+       Vector []string `protobuf:"bytes,2,rep,name=vector,proto3" json:"vector,omitempty"`
+       // Types that are valid to be assigned to Oneof:
+       //      *TestUTF8_Field
+       Oneof                isTestUTF8_Oneof `protobuf_oneof:"oneof"`
+       MapKey               map[string]int64 `protobuf:"bytes,4,rep,name=map_key,json=mapKey,proto3" json:"map_key,omitempty" protobuf_key:"bytes,1,opt,name=key,proto3" protobuf_val:"varint,2,opt,name=value,proto3"`
+       MapValue             map[int64]string `protobuf:"bytes,5,rep,name=map_value,json=mapValue,proto3" json:"map_value,omitempty" protobuf_key:"varint,1,opt,name=key,proto3" protobuf_val:"bytes,2,opt,name=value,proto3"`
+       XXX_NoUnkeyedLiteral struct{}         `json:"-"`
+       XXX_unrecognized     []byte           `json:"-"`
+       XXX_sizecache        int32            `json:"-"`
+}
+
+func (m *TestUTF8) Reset()         { *m = TestUTF8{} }
+func (m *TestUTF8) String() string { return proto.CompactTextString(m) }
+func (*TestUTF8) ProtoMessage()    {}
+func (*TestUTF8) Descriptor() ([]byte, []int) {
+       return fileDescriptor_4fee6d65e34a64b6, []int{5}
+}
+func (m *TestUTF8) XXX_Unmarshal(b []byte) error {
+       return xxx_messageInfo_TestUTF8.Unmarshal(m, b)
+}
+func (m *TestUTF8) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+       return xxx_messageInfo_TestUTF8.Marshal(b, m, deterministic)
+}
+func (m *TestUTF8) XXX_Merge(src proto.Message) {
+       xxx_messageInfo_TestUTF8.Merge(m, src)
+}
+func (m *TestUTF8) XXX_Size() int {
+       return xxx_messageInfo_TestUTF8.Size(m)
+}
+func (m *TestUTF8) XXX_DiscardUnknown() {
+       xxx_messageInfo_TestUTF8.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_TestUTF8 proto.InternalMessageInfo
+
+type isTestUTF8_Oneof interface {
+       isTestUTF8_Oneof()
+}
+
+type TestUTF8_Field struct {
+       Field string `protobuf:"bytes,3,opt,name=field,proto3,oneof"`
+}
+
+func (*TestUTF8_Field) isTestUTF8_Oneof() {}
+
+func (m *TestUTF8) GetOneof() isTestUTF8_Oneof {
+       if m != nil {
+               return m.Oneof
+       }
+       return nil
+}
+
+func (m *TestUTF8) GetScalar() string {
+       if m != nil {
+               return m.Scalar
+       }
+       return ""
+}
+
+func (m *TestUTF8) GetVector() []string {
+       if m != nil {
+               return m.Vector
+       }
+       return nil
+}
+
+func (m *TestUTF8) GetField() string {
+       if x, ok := m.GetOneof().(*TestUTF8_Field); ok {
+               return x.Field
+       }
+       return ""
+}
+
+func (m *TestUTF8) GetMapKey() map[string]int64 {
+       if m != nil {
+               return m.MapKey
+       }
+       return nil
+}
+
+func (m *TestUTF8) GetMapValue() map[int64]string {
+       if m != nil {
+               return m.MapValue
+       }
+       return nil
+}
+
+// XXX_OneofFuncs is for the internal use of the proto package.
+func (*TestUTF8) XXX_OneofFuncs() (func(msg proto.Message, b *proto.Buffer) error, func(msg proto.Message, tag, wire int, b *proto.Buffer) (bool, error), func(msg proto.Message) (n int), []interface{}) {
+       return _TestUTF8_OneofMarshaler, _TestUTF8_OneofUnmarshaler, _TestUTF8_OneofSizer, []interface{}{
+               (*TestUTF8_Field)(nil),
+       }
+}
+
+func _TestUTF8_OneofMarshaler(msg proto.Message, b *proto.Buffer) error {
+       m := msg.(*TestUTF8)
+       // oneof
+       switch x := m.Oneof.(type) {
+       case *TestUTF8_Field:
+               _ = b.EncodeVarint(3<<3 | proto.WireBytes)
+               _ = b.EncodeStringBytes(x.Field)
+       case nil:
+       default:
+               return fmt.Errorf("TestUTF8.Oneof has unexpected type %T", x)
+       }
+       return nil
+}
+
+func _TestUTF8_OneofUnmarshaler(msg proto.Message, tag, wire int, b *proto.Buffer) (bool, error) {
+       m := msg.(*TestUTF8)
+       switch tag {
+       case 3: // oneof.field
+               if wire != proto.WireBytes {
+                       return true, proto.ErrInternalBadWireType
+               }
+               x, err := b.DecodeStringBytes()
+               m.Oneof = &TestUTF8_Field{x}
+               return true, err
+       default:
+               return false, nil
+       }
+}
+
+func _TestUTF8_OneofSizer(msg proto.Message) (n int) {
+       m := msg.(*TestUTF8)
+       // oneof
+       switch x := m.Oneof.(type) {
+       case *TestUTF8_Field:
+               n += 1 // tag and wire
+               n += proto.SizeVarint(uint64(len(x.Field)))
+               n += len(x.Field)
+       case nil:
+       default:
+               panic(fmt.Sprintf("proto: unexpected type %T in oneof", x))
+       }
+       return n
+}
+
+func init() {
+       proto.RegisterEnum("proto3_proto.Message_Humour", Message_Humour_name, Message_Humour_value)
+       proto.RegisterType((*Message)(nil), "proto3_proto.Message")
+       proto.RegisterMapType((map[string]*test_proto.SubDefaults)(nil), "proto3_proto.Message.Proto2ValueEntry")
+       proto.RegisterMapType((map[string]string)(nil), "proto3_proto.Message.StringMapEntry")
+       proto.RegisterMapType((map[string]*Nested)(nil), "proto3_proto.Message.TerrainEntry")
+       proto.RegisterType((*Nested)(nil), "proto3_proto.Nested")
+       proto.RegisterType((*MessageWithMap)(nil), "proto3_proto.MessageWithMap")
+       proto.RegisterMapType((map[bool][]byte)(nil), "proto3_proto.MessageWithMap.ByteMappingEntry")
+       proto.RegisterType((*IntMap)(nil), "proto3_proto.IntMap")
+       proto.RegisterMapType((map[int32]int32)(nil), "proto3_proto.IntMap.RttEntry")
+       proto.RegisterType((*IntMaps)(nil), "proto3_proto.IntMaps")
+       proto.RegisterType((*TestUTF8)(nil), "proto3_proto.TestUTF8")
+       proto.RegisterMapType((map[string]int64)(nil), "proto3_proto.TestUTF8.MapKeyEntry")
+       proto.RegisterMapType((map[int64]string)(nil), "proto3_proto.TestUTF8.MapValueEntry")
+}
+
+func init() { proto.RegisterFile("proto3.proto", fileDescriptor_4fee6d65e34a64b6) }
+
+var fileDescriptor_4fee6d65e34a64b6 = []byte{
+       // 891 bytes of a gzipped FileDescriptorProto
+       0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x84, 0x54, 0xff, 0x8e, 0xdb, 0x44,
+       0x10, 0xae, 0xe3, 0xfc, 0x70, 0x26, 0xc9, 0x35, 0x2c, 0x69, 0x59, 0x02, 0x48, 0x26, 0x20, 0x64,
+       0x21, 0xea, 0x83, 0x54, 0x87, 0x8e, 0xb6, 0x02, 0xdd, 0x1d, 0x3d, 0x35, 0xba, 0x4b, 0x88, 0x36,
+       0x39, 0x4e, 0xfc, 0x65, 0x6d, 0x72, 0x9b, 0xc4, 0x22, 0x5e, 0x07, 0xef, 0xba, 0x92, 0x5f, 0x80,
+       0x07, 0xe1, 0x95, 0x78, 0x21, 0xb4, 0xbb, 0xce, 0xd5, 0xa9, 0x5c, 0xee, 0x2f, 0xef, 0x7c, 0xfe,
+       0x66, 0xbe, 0xd9, 0x99, 0xd9, 0x81, 0xf6, 0x2e, 0x89, 0x65, 0xfc, 0xdc, 0xd7, 0x1f, 0x94, 0x5b,
+       0x81, 0xfe, 0xf4, 0x3f, 0x5d, 0xc7, 0xf1, 0x7a, 0xcb, 0x8e, 0xb5, 0xb5, 0x48, 0x57, 0xc7, 0x94,
+       0x67, 0x86, 0xd8, 0x7f, 0x22, 0x99, 0x90, 0x86, 0x76, 0xac, 0x8e, 0x06, 0x1e, 0xfc, 0xdd, 0x84,
+       0xc6, 0x98, 0x09, 0x41, 0xd7, 0x0c, 0x21, 0xa8, 0x72, 0x1a, 0x31, 0x6c, 0xb9, 0x96, 0xd7, 0x24,
+       0xfa, 0x8c, 0x4e, 0xc1, 0xd9, 0x84, 0x5b, 0x9a, 0x84, 0x32, 0xc3, 0x15, 0xd7, 0xf2, 0x8e, 0x86,
+       0x9f, 0xfb, 0x45, 0x49, 0x3f, 0x77, 0xf6, 0xdf, 0xa4, 0x51, 0x9c, 0x26, 0xe4, 0x9e, 0x8d, 0x5c,
+       0x68, 0x6f, 0x58, 0xb8, 0xde, 0xc8, 0x20, 0xe4, 0xc1, 0x32, 0xc2, 0xb6, 0x6b, 0x79, 0x1d, 0x02,
+       0x06, 0x1b, 0xf1, 0x8b, 0x48, 0xe9, 0xdd, 0x51, 0x49, 0x71, 0xd5, 0xb5, 0xbc, 0x36, 0xd1, 0x67,
+       0xf4, 0x25, 0xb4, 0x13, 0x26, 0xd2, 0xad, 0x0c, 0x96, 0x71, 0xca, 0x25, 0x6e, 0xb8, 0x96, 0x67,
+       0x93, 0x96, 0xc1, 0x2e, 0x14, 0x84, 0xbe, 0x82, 0x8e, 0x4c, 0x52, 0x16, 0x88, 0x65, 0x2c, 0x45,
+       0x44, 0x39, 0x76, 0x5c, 0xcb, 0x73, 0x48, 0x5b, 0x81, 0xb3, 0x1c, 0x43, 0x3d, 0xa8, 0x89, 0x65,
+       0x9c, 0x30, 0xdc, 0x74, 0x2d, 0xaf, 0x42, 0x8c, 0x81, 0xba, 0x60, 0xff, 0xc9, 0x32, 0x5c, 0x73,
+       0x6d, 0xaf, 0x4a, 0xd4, 0x11, 0x7d, 0x06, 0x4d, 0xb1, 0x89, 0x13, 0x19, 0x28, 0xfc, 0x63, 0xd7,
+       0xf6, 0x6a, 0xc4, 0xd1, 0xc0, 0x15, 0xcb, 0xd0, 0x77, 0x50, 0xe7, 0x4c, 0x48, 0x76, 0x87, 0xeb,
+       0xae, 0xe5, 0xb5, 0x86, 0xbd, 0xc3, 0xab, 0x4f, 0xf4, 0x3f, 0x92, 0x73, 0xd0, 0x09, 0x34, 0x92,
+       0x60, 0x95, 0x72, 0x9e, 0xe1, 0xae, 0x6b, 0x3f, 0x58, 0xa9, 0x7a, 0x72, 0xa9, 0xb8, 0xe8, 0x15,
+       0x34, 0x24, 0x4b, 0x12, 0x1a, 0x72, 0x0c, 0xae, 0xed, 0xb5, 0x86, 0x83, 0x72, 0xb7, 0xb9, 0x21,
+       0xbd, 0xe6, 0x32, 0xc9, 0xc8, 0xde, 0x05, 0xbd, 0xc8, 0xe7, 0x61, 0x18, 0xac, 0x42, 0xb6, 0xbd,
+       0xc3, 0x2d, 0x9d, 0xe8, 0x27, 0xfe, 0xbb, 0x6e, 0xfb, 0xb3, 0x74, 0xf1, 0x2b, 0x5b, 0xd1, 0x74,
+       0x2b, 0x05, 0x69, 0x19, 0xf2, 0xa5, 0xe2, 0xa2, 0xd1, 0xbd, 0xef, 0x5b, 0xba, 0x4d, 0x19, 0xee,
+       0x68, 0xf9, 0x6f, 0xca, 0xe5, 0xa7, 0x9a, 0xf9, 0xbb, 0x22, 0x9a, 0x14, 0xf2, 0x50, 0x1a, 0x41,
+       0xdf, 0x83, 0x43, 0x79, 0x26, 0x37, 0x21, 0x5f, 0xe3, 0xa3, 0xbc, 0x56, 0x66, 0x16, 0xfd, 0xfd,
+       0x2c, 0xfa, 0x67, 0x3c, 0x23, 0xf7, 0x2c, 0x74, 0x02, 0xad, 0x88, 0xf2, 0x2c, 0xd0, 0x96, 0xc0,
+       0x8f, 0xb5, 0x76, 0xb9, 0x13, 0x28, 0xe2, 0x5c, 0xf3, 0xd0, 0x09, 0x80, 0x48, 0x17, 0x91, 0x49,
+       0x0a, 0x7f, 0xa4, 0xa5, 0x9e, 0x94, 0x66, 0x4c, 0x0a, 0x44, 0xf4, 0x03, 0x38, 0xcb, 0x4d, 0xb8,
+       0xbd, 0x4b, 0x18, 0xc7, 0x48, 0x4b, 0x7d, 0xc0, 0xe9, 0x9e, 0x86, 0x2e, 0x00, 0x84, 0x4c, 0x42,
+       0xbe, 0x0e, 0x22, 0xba, 0xc3, 0x3d, 0xed, 0xf4, 0x75, 0x79, 0x6d, 0x66, 0x9a, 0x37, 0xa6, 0x3b,
+       0x53, 0x99, 0xa6, 0xd8, 0xdb, 0xfd, 0x29, 0xb4, 0x8b, 0x7d, 0xdb, 0x0f, 0xa0, 0x79, 0x61, 0x7a,
+       0x00, 0xbf, 0x85, 0x9a, 0xa9, 0x7e, 0xe5, 0x7f, 0x46, 0xcc, 0x50, 0x5e, 0x54, 0x4e, 0xad, 0xfe,
+       0x2d, 0x74, 0xdf, 0x6f, 0x45, 0x49, 0xd4, 0x67, 0x87, 0x51, 0x3f, 0x38, 0x0f, 0x85, 0xc0, 0xaf,
+       0xe0, 0xe8, 0xf0, 0x1e, 0x25, 0x61, 0x7b, 0xc5, 0xb0, 0xcd, 0x82, 0xf7, 0xe0, 0x17, 0xa8, 0x9b,
+       0xb9, 0x46, 0x2d, 0x68, 0xdc, 0x4c, 0xae, 0x26, 0xbf, 0xdd, 0x4e, 0xba, 0x8f, 0x90, 0x03, 0xd5,
+       0xe9, 0xcd, 0x64, 0xd6, 0xb5, 0x50, 0x07, 0x9a, 0xb3, 0xeb, 0xb3, 0xe9, 0x6c, 0x3e, 0xba, 0xb8,
+       0xea, 0x56, 0xd0, 0x63, 0x68, 0x9d, 0x8f, 0xae, 0xaf, 0x83, 0xf3, 0xb3, 0xd1, 0xf5, 0xeb, 0x3f,
+       0xba, 0xf6, 0x60, 0x08, 0x75, 0x73, 0x59, 0x25, 0xb2, 0xd0, 0xaf, 0xc8, 0x08, 0x1b, 0x43, 0x2d,
+       0x8b, 0x65, 0x2a, 0x8d, 0xb2, 0x43, 0xf4, 0x79, 0xf0, 0x8f, 0x05, 0x47, 0x79, 0x0f, 0x6e, 0x43,
+       0xb9, 0x19, 0xd3, 0x1d, 0x9a, 0x42, 0x7b, 0x91, 0x49, 0xa6, 0x7a, 0xb6, 0x53, 0xc3, 0x68, 0xe9,
+       0xbe, 0x3d, 0x2b, 0xed, 0x5b, 0xee, 0xe3, 0x9f, 0x67, 0x92, 0x8d, 0x0d, 0x3f, 0x1f, 0xed, 0xc5,
+       0x3b, 0xa4, 0xff, 0x33, 0x74, 0xdf, 0x27, 0x14, 0x2b, 0xe3, 0x94, 0x54, 0xa6, 0x5d, 0xac, 0xcc,
+       0x5f, 0x50, 0x1f, 0x71, 0xa9, 0x72, 0x3b, 0x06, 0x3b, 0x91, 0x32, 0x4f, 0xe9, 0x8b, 0xc3, 0x94,
+       0x0c, 0xc5, 0x27, 0x52, 0x9a, 0x14, 0x14, 0xb3, 0xff, 0x23, 0x38, 0x7b, 0xa0, 0x28, 0x59, 0x2b,
+       0x91, 0xac, 0x15, 0x25, 0x9f, 0x43, 0xc3, 0xc4, 0x13, 0xc8, 0x83, 0x6a, 0x44, 0x77, 0x22, 0x17,
+       0xed, 0x95, 0x89, 0x12, 0xcd, 0x18, 0xfc, 0x5b, 0x01, 0x67, 0xce, 0x84, 0xbc, 0x99, 0x5f, 0x9e,
+       0xa2, 0xa7, 0x50, 0x17, 0x4b, 0xba, 0xa5, 0x49, 0xde, 0x84, 0xdc, 0x52, 0xf8, 0x5b, 0xb6, 0x94,
+       0x71, 0x82, 0x2b, 0xae, 0xad, 0x70, 0x63, 0xa1, 0xa7, 0x50, 0x33, 0xfb, 0x47, 0x6d, 0xf9, 0xe6,
+       0x9b, 0x47, 0xc4, 0x98, 0xe8, 0x25, 0x34, 0x22, 0xba, 0xd3, 0xcb, 0xb5, 0x5a, 0xb6, 0xdc, 0xf6,
+       0x82, 0xfe, 0x98, 0xee, 0xae, 0x58, 0x66, 0xee, 0x5e, 0x8f, 0xb4, 0x81, 0xce, 0xa0, 0xa9, 0x9c,
+       0xcd, 0x25, 0x6b, 0x65, 0x0f, 0xb0, 0xe8, 0x5e, 0x58, 0x4d, 0x4e, 0x94, 0x9b, 0xfd, 0x9f, 0xa0,
+       0x55, 0x88, 0xfc, 0xd0, 0x44, 0xdb, 0xc5, 0xf7, 0xf0, 0x12, 0x3a, 0x07, 0x51, 0x8b, 0xce, 0xf6,
+       0x03, 0xcf, 0xe1, 0xbc, 0x01, 0xb5, 0x98, 0xb3, 0x78, 0xb5, 0xa8, 0x9b, 0x7c, 0xff, 0x0b, 0x00,
+       0x00, 0xff, 0xff, 0x0e, 0x22, 0xea, 0x15, 0xb6, 0x07, 0x00, 0x00,
+}

diff --git a/vendor/github.com/gogo/protobuf/proto/proto3_proto/proto3.proto b/vendor/github.com/gogo/protobuf/proto/proto3_proto/proto3.proto
new file mode 100644 (file)
index 0000000..6adea22
--- /dev/null
+++ b/vendor/github.com/gogo/protobuf/proto/proto3_proto/proto3.proto
@@ -0,0 +1,97 @@
+// Go support for Protocol Buffers - Google's data interchange format
+//
+// Copyright 2014 The Go Authors.  All rights reserved.
+// https://github.com/golang/protobuf
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//     * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//     * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//     * Neither the name of Google Inc. nor the names of its
+// contributors may be used to endorse or promote products derived from
+// this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+syntax = "proto3";
+
+import "google/protobuf/any.proto";
+import "test_proto/test.proto";
+
+package proto3_proto;
+
+message Message {
+  enum Humour {
+    UNKNOWN = 0;
+    PUNS = 1;
+    SLAPSTICK = 2;
+    BILL_BAILEY = 3;
+  }
+
+  string name = 1;
+  Humour hilarity = 2;
+  uint32 height_in_cm = 3;
+  bytes data = 4;
+  int64 result_count = 7;
+  bool true_scotsman = 8;
+  float score = 9;
+
+  repeated uint64 key = 5;
+  repeated int32 short_key = 19;
+  Nested nested = 6;
+  repeated Humour r_funny = 16;
+
+  map<string, Nested> terrain = 10;
+  test_proto.SubDefaults proto2_field = 11;
+  map<string, test_proto.SubDefaults> proto2_value = 13;
+
+  google.protobuf.Any anything = 14;
+  repeated google.protobuf.Any many_things = 15;
+
+  Message submessage = 17;
+  repeated Message children = 18;
+
+  map<string, string> string_map = 20;
+}
+
+message Nested {
+  string bunny = 1;
+  bool cute = 2;
+}
+
+message MessageWithMap {
+  map<bool, bytes> byte_mapping = 1;
+}
+
+
+message IntMap {
+  map<int32, int32> rtt = 1;
+}
+
+message IntMaps {
+  repeated IntMap maps = 1;
+}
+
+message TestUTF8 {
+  string scalar = 1;
+  repeated string vector = 2;
+  oneof oneof { string field = 3; }
+  map<string, int64> map_key = 4;
+  map<int64, string> map_value = 5;
+}

diff --git a/vendor/github.com/gogo/protobuf/proto/proto3_test.go b/vendor/github.com/gogo/protobuf/proto/proto3_test.go
new file mode 100644 (file)
index 0000000..3909aeb
--- /dev/null
+++ b/vendor/github.com/gogo/protobuf/proto/proto3_test.go
@@ -0,0 +1,151 @@
+// Go support for Protocol Buffers - Google's data interchange format
+//
+// Copyright 2014 The Go Authors.  All rights reserved.
+// https://github.com/golang/protobuf
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//     * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//     * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//     * Neither the name of Google Inc. nor the names of its
+// contributors may be used to endorse or promote products derived from
+// this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+package proto_test
+
+import (
+       "bytes"
+       "testing"
+
+       "github.com/gogo/protobuf/proto"
+       pb "github.com/gogo/protobuf/proto/proto3_proto"
+       tpb "github.com/gogo/protobuf/proto/test_proto"
+)
+
+func TestProto3ZeroValues(t *testing.T) {
+       tests := []struct {
+               desc string
+               m    proto.Message
+       }{
+               {"zero message", &pb.Message{}},
+               {"empty bytes field", &pb.Message{Data: []byte{}}},
+       }
+       for _, test := range tests {
+               b, err := proto.Marshal(test.m)
+               if err != nil {
+                       t.Errorf("%s: proto.Marshal: %v", test.desc, err)
+                       continue
+               }
+               if len(b) > 0 {
+                       t.Errorf("%s: Encoding is non-empty: %q", test.desc, b)
+               }
+       }
+}
+
+func TestRoundTripProto3(t *testing.T) {
+       m := &pb.Message{
+               Name:         "David",          // (2 | 1<<3): 0x0a 0x05 "David"
+               Hilarity:     pb.Message_PUNS,  // (0 | 2<<3): 0x10 0x01
+               HeightInCm:   178,              // (0 | 3<<3): 0x18 0xb2 0x01
+               Data:         []byte("roboto"), // (2 | 4<<3): 0x20 0x06 "roboto"
+               ResultCount:  47,               // (0 | 7<<3): 0x38 0x2f
+               TrueScotsman: true,             // (0 | 8<<3): 0x40 0x01
+               Score:        8.1,              // (5 | 9<<3): 0x4d <8.1>
+
+               Key: []uint64{1, 0xdeadbeef},
+               Nested: &pb.Nested{
+                       Bunny: "Monty",
+               },
+       }
+       t.Logf(" m: %v", m)
+
+       b, err := proto.Marshal(m)
+       if err != nil {
+               t.Fatalf("proto.Marshal: %v", err)
+       }
+       t.Logf(" b: %q", b)
+
+       m2 := new(pb.Message)
+       if err := proto.Unmarshal(b, m2); err != nil {
+               t.Fatalf("proto.Unmarshal: %v", err)
+       }
+       t.Logf("m2: %v", m2)
+
+       if !proto.Equal(m, m2) {
+               t.Errorf("proto.Equal returned false:\n m: %v\nm2: %v", m, m2)
+       }
+}
+
+func TestGettersForBasicTypesExist(t *testing.T) {
+       var m pb.Message
+       if got := m.GetNested().GetBunny(); got != "" {
+               t.Errorf("m.GetNested().GetBunny() = %q, want empty string", got)
+       }
+       if got := m.GetNested().GetCute(); got {
+               t.Errorf("m.GetNested().GetCute() = %t, want false", got)
+       }
+}
+
+func TestProto3SetDefaults(t *testing.T) {
+       in := &pb.Message{
+               Terrain: map[string]*pb.Nested{
+                       "meadow": new(pb.Nested),
+               },
+               Proto2Field: new(tpb.SubDefaults),
+               Proto2Value: map[string]*tpb.SubDefaults{
+                       "badlands": new(tpb.SubDefaults),
+               },
+       }
+
+       got := proto.Clone(in).(*pb.Message)
+       proto.SetDefaults(got)
+
+       // There are no defaults in proto3.  Everything should be the zero value, but
+       // we need to remember to set defaults for nested proto2 messages.
+       want := &pb.Message{
+               Terrain: map[string]*pb.Nested{
+                       "meadow": new(pb.Nested),
+               },
+               Proto2Field: &tpb.SubDefaults{N: proto.Int64(7)},
+               Proto2Value: map[string]*tpb.SubDefaults{
+                       "badlands": {N: proto.Int64(7)},
+               },
+       }
+
+       if !proto.Equal(got, want) {
+               t.Errorf("with in = %v\nproto.SetDefaults(in) =>\ngot %v\nwant %v", in, got, want)
+       }
+}
+
+func TestUnknownFieldPreservation(t *testing.T) {
+       b1 := "\x0a\x05David"      // Known tag 1
+       b2 := "\xc2\x0c\x06Google" // Unknown tag 200
+       b := []byte(b1 + b2)
+
+       m := new(pb.Message)
+       if err := proto.Unmarshal(b, m); err != nil {
+               t.Fatalf("proto.Unmarshal: %v", err)
+       }
+
+       if !bytes.Equal(m.XXX_unrecognized, []byte(b2)) {
+               t.Fatalf("mismatching unknown fields:\ngot  %q\nwant %q", m.XXX_unrecognized, b2)
+       }
+}

diff --git a/vendor/github.com/gogo/protobuf/proto/size2_test.go b/vendor/github.com/gogo/protobuf/proto/size2_test.go
new file mode 100644 (file)
index 0000000..0b8eb85
--- /dev/null
+++ b/vendor/github.com/gogo/protobuf/proto/size2_test.go
@@ -0,0 +1,64 @@
+// Go support for Protocol Buffers - Google's data interchange format
+//
+// Copyright 2012 The Go Authors.  All rights reserved.
+// https://github.com/golang/protobuf
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//     * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//     * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//     * Neither the name of Google Inc. nor the names of its
+// contributors may be used to endorse or promote products derived from
+// this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+package proto
+
+import (
+       "math"
+       "testing"
+)
+
+// This is a separate file and package from size_test.go because that one uses
+// generated messages and thus may not be in package proto without having a circular
+// dependency, whereas this file tests unexported details of size.go.
+
+func TestVarintSize(t *testing.T) {
+       // Check the edge cases carefully.
+       testCases := []struct {
+               n    uint64
+               size int
+       }{
+               {0, 1},
+               {1, 1},
+               {127, 1},
+               {128, 2},
+               {16383, 2},
+               {16384, 3},
+               {math.MaxInt64, 9},
+               {math.MaxInt64 + 1, 10},
+       }
+       for _, tc := range testCases {
+               size := SizeVarint(tc.n)
+               if size != tc.size {
+                       t.Errorf("sizeVarint(%d) = %d, want %d", tc.n, size, tc.size)
+               }
+       }
+}

diff --git a/vendor/github.com/gogo/protobuf/proto/size_test.go b/vendor/github.com/gogo/protobuf/proto/size_test.go
new file mode 100644 (file)
index 0000000..121e26b
--- /dev/null
+++ b/vendor/github.com/gogo/protobuf/proto/size_test.go
@@ -0,0 +1,190 @@
+// Go support for Protocol Buffers - Google's data interchange format
+//
+// Copyright 2012 The Go Authors.  All rights reserved.
+// https://github.com/golang/protobuf
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//     * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//     * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//     * Neither the name of Google Inc. nor the names of its
+// contributors may be used to endorse or promote products derived from
+// this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+package proto_test
+
+import (
+       "log"
+       "strings"
+       "testing"
+
+       . "github.com/gogo/protobuf/proto"
+       proto3pb "github.com/gogo/protobuf/proto/proto3_proto"
+       pb "github.com/gogo/protobuf/proto/test_proto"
+)
+
+var messageWithExtension1 = &pb.MyMessage{Count: Int32(7)}
+
+// messageWithExtension2 is in equal_test.go.
+var messageWithExtension3 = &pb.MyMessage{Count: Int32(8)}
+
+func init() {
+       if err := SetExtension(messageWithExtension1, pb.E_Ext_More, &pb.Ext{Data: String("Abbott")}); err != nil {
+               log.Panicf("SetExtension: %v", err)
+       }
+       if err := SetExtension(messageWithExtension3, pb.E_Ext_More, &pb.Ext{Data: String("Costello")}); err != nil {
+               log.Panicf("SetExtension: %v", err)
+       }
+
+       // Force messageWithExtension3 to have the extension encoded.
+       Marshal(messageWithExtension3)
+
+}
+
+// non-pointer custom message
+type nonptrMessage struct{}
+
+func (m nonptrMessage) ProtoMessage()  {}
+func (m nonptrMessage) Reset()         {}
+func (m nonptrMessage) String() string { return "" }
+
+func (m nonptrMessage) Marshal() ([]byte, error) {
+       return []byte{42}, nil
+}
+
+// custom message embedding a proto.Message
+type messageWithEmbedding struct {
+       *pb.OtherMessage
+}
+
+func (m *messageWithEmbedding) ProtoMessage()  {}
+func (m *messageWithEmbedding) Reset()         {}
+func (m *messageWithEmbedding) String() string { return "" }
+
+func (m *messageWithEmbedding) Marshal() ([]byte, error) {
+       return []byte{42}, nil
+}
+
+var SizeTests = []struct {
+       desc string
+       pb   Message
+}{
+       {"empty", &pb.OtherMessage{}},
+       // Basic types.
+       {"bool", &pb.Defaults{F_Bool: Bool(true)}},
+       {"int32", &pb.Defaults{F_Int32: Int32(12)}},
+       {"negative int32", &pb.Defaults{F_Int32: Int32(-1)}},
+       {"small int64", &pb.Defaults{F_Int64: Int64(1)}},
+       {"big int64", &pb.Defaults{F_Int64: Int64(1 << 20)}},
+       {"negative int64", &pb.Defaults{F_Int64: Int64(-1)}},
+       {"fixed32", &pb.Defaults{F_Fixed32: Uint32(71)}},
+       {"fixed64", &pb.Defaults{F_Fixed64: Uint64(72)}},
+       {"uint32", &pb.Defaults{F_Uint32: Uint32(123)}},
+       {"uint64", &pb.Defaults{F_Uint64: Uint64(124)}},
+       {"float", &pb.Defaults{F_Float: Float32(12.6)}},
+       {"double", &pb.Defaults{F_Double: Float64(13.9)}},
+       {"string", &pb.Defaults{F_String: String("niles")}},
+       {"bytes", &pb.Defaults{F_Bytes: []byte("wowsa")}},
+       {"bytes, empty", &pb.Defaults{F_Bytes: []byte{}}},
+       {"sint32", &pb.Defaults{F_Sint32: Int32(65)}},
+       {"sint64", &pb.Defaults{F_Sint64: Int64(67)}},
+       {"enum", &pb.Defaults{F_Enum: pb.Defaults_BLUE.Enum()}},
+       // Repeated.
+       {"empty repeated bool", &pb.MoreRepeated{Bools: []bool{}}},
+       {"repeated bool", &pb.MoreRepeated{Bools: []bool{false, true, true, false}}},
+       {"packed repeated bool", &pb.MoreRepeated{BoolsPacked: []bool{false, true, true, false, true, true, true}}},
+       {"repeated int32", &pb.MoreRepeated{Ints: []int32{1, 12203, 1729, -1}}},
+       {"repeated int32 packed", &pb.MoreRepeated{IntsPacked: []int32{1, 12203, 1729}}},
+       {"repeated int64 packed", &pb.MoreRepeated{Int64SPacked: []int64{
+               // Need enough large numbers to verify that the header is counting the number of bytes
+               // for the field, not the number of elements.
+               1 << 62, 1 << 62, 1 << 62, 1 << 62, 1 << 62, 1 << 62, 1 << 62, 1 << 62, 1 << 62, 1 << 62,
+               1 << 62, 1 << 62, 1 << 62, 1 << 62, 1 << 62, 1 << 62, 1 << 62, 1 << 62, 1 << 62, 1 << 62,
+       }}},
+       {"repeated string", &pb.MoreRepeated{Strings: []string{"r", "ken", "gri"}}},
+       {"repeated fixed", &pb.MoreRepeated{Fixeds: []uint32{1, 2, 3, 4}}},
+       // Nested.
+       {"nested", &pb.OldMessage{Nested: &pb.OldMessage_Nested{Name: String("whatever")}}},
+       {"group", &pb.GroupOld{G: &pb.GroupOld_G{X: Int32(12345)}}},
+       // Other things.
+       {"unrecognized", &pb.MoreRepeated{XXX_unrecognized: []byte{13<<3 | 0, 4}}},
+       {"extension (unencoded)", messageWithExtension1},
+       {"extension (encoded)", messageWithExtension3},
+       // proto3 message
+       {"proto3 empty", &proto3pb.Message{}},
+       {"proto3 bool", &proto3pb.Message{TrueScotsman: true}},
+       {"proto3 int64", &proto3pb.Message{ResultCount: 1}},
+       {"proto3 uint32", &proto3pb.Message{HeightInCm: 123}},
+       {"proto3 float", &proto3pb.Message{Score: 12.6}},
+       {"proto3 string", &proto3pb.Message{Name: "Snezana"}},
+       {"proto3 bytes", &proto3pb.Message{Data: []byte("wowsa")}},
+       {"proto3 bytes, empty", &proto3pb.Message{Data: []byte{}}},
+       {"proto3 enum", &proto3pb.Message{Hilarity: proto3pb.Message_PUNS}},
+       {"proto3 map field with empty bytes", &proto3pb.MessageWithMap{ByteMapping: map[bool][]byte{false: {}}}},
+
+       {"map field", &pb.MessageWithMap{NameMapping: map[int32]string{1: "Rob", 7: "Andrew"}}},
+       {"map field with message", &pb.MessageWithMap{MsgMapping: map[int64]*pb.FloatingPoint{0x7001: {F: Float64(2.0)}}}},
+       {"map field with bytes", &pb.MessageWithMap{ByteMapping: map[bool][]byte{true: []byte("this time for sure")}}},
+       {"map field with empty bytes", &pb.MessageWithMap{ByteMapping: map[bool][]byte{true: {}}}},
+
+       {"map field with big entry", &pb.MessageWithMap{NameMapping: map[int32]string{8: strings.Repeat("x", 125)}}},
+       {"map field with big key and val", &pb.MessageWithMap{StrToStr: map[string]string{strings.Repeat("x", 70): strings.Repeat("y", 70)}}},
+       {"map field with big numeric key", &pb.MessageWithMap{NameMapping: map[int32]string{0xf00d: "om nom nom"}}},
+
+       {"oneof not set", &pb.Oneof{}},
+       {"oneof bool", &pb.Oneof{Union: &pb.Oneof_F_Bool{F_Bool: true}}},
+       {"oneof zero int32", &pb.Oneof{Union: &pb.Oneof_F_Int32{F_Int32: 0}}},
+       {"oneof big int32", &pb.Oneof{Union: &pb.Oneof_F_Int32{F_Int32: 1 << 20}}},
+       {"oneof int64", &pb.Oneof{Union: &pb.Oneof_F_Int64{F_Int64: 42}}},
+       {"oneof fixed32", &pb.Oneof{Union: &pb.Oneof_F_Fixed32{F_Fixed32: 43}}},
+       {"oneof fixed64", &pb.Oneof{Union: &pb.Oneof_F_Fixed64{F_Fixed64: 44}}},
+       {"oneof uint32", &pb.Oneof{Union: &pb.Oneof_F_Uint32{F_Uint32: 45}}},
+       {"oneof uint64", &pb.Oneof{Union: &pb.Oneof_F_Uint64{F_Uint64: 46}}},
+       {"oneof float", &pb.Oneof{Union: &pb.Oneof_F_Float{F_Float: 47.1}}},
+       {"oneof double", &pb.Oneof{Union: &pb.Oneof_F_Double{F_Double: 48.9}}},
+       {"oneof string", &pb.Oneof{Union: &pb.Oneof_F_String{F_String: "Rhythmic Fman"}}},
+       {"oneof bytes", &pb.Oneof{Union: &pb.Oneof_F_Bytes{F_Bytes: []byte("let go")}}},
+       {"oneof sint32", &pb.Oneof{Union: &pb.Oneof_F_Sint32{F_Sint32: 50}}},
+       {"oneof sint64", &pb.Oneof{Union: &pb.Oneof_F_Sint64{F_Sint64: 51}}},
+       {"oneof enum", &pb.Oneof{Union: &pb.Oneof_F_Enum{F_Enum: pb.MyMessage_BLUE}}},
+       {"message for oneof", &pb.GoTestField{Label: String("k"), Type: String("v")}},
+       {"oneof message", &pb.Oneof{Union: &pb.Oneof_F_Message{F_Message: &pb.GoTestField{Label: String("k"), Type: String("v")}}}},
+       {"oneof group", &pb.Oneof{Union: &pb.Oneof_FGroup{FGroup: &pb.Oneof_F_Group{X: Int32(52)}}}},
+       {"oneof largest tag", &pb.Oneof{Union: &pb.Oneof_F_Largest_Tag{F_Largest_Tag: 1}}},
+       {"multiple oneofs", &pb.Oneof{Union: &pb.Oneof_F_Int32{F_Int32: 1}, Tormato: &pb.Oneof_Value{Value: 2}}},
+       {"non-pointer message", nonptrMessage{}},
+       {"custom message with embedding", &messageWithEmbedding{&pb.OtherMessage{}}},
+}
+
+func TestSize(t *testing.T) {
+       for _, tc := range SizeTests {
+               size := Size(tc.pb)
+               b, err := Marshal(tc.pb)
+               if err != nil {
+                       t.Errorf("%v: Marshal failed: %v", tc.desc, err)
+                       continue
+               }
+               if size != len(b) {
+                       t.Errorf("%v: Size(%v) = %d, want %d", tc.desc, tc.pb, size, len(b))
+                       t.Logf("%v: bytes: %#v", tc.desc, b)
+               }
+       }
+}

diff --git a/vendor/github.com/gogo/protobuf/proto/skip_gogo.go b/vendor/github.com/gogo/protobuf/proto/skip_gogo.go
new file mode 100644 (file)
index 0000000..5a5fd93
--- /dev/null
+++ b/vendor/github.com/gogo/protobuf/proto/skip_gogo.go
@@ -0,0 +1,119 @@
+// Protocol Buffers for Go with Gadgets
+//
+// Copyright (c) 2013, The GoGo Authors. All rights reserved.
+// http://github.com/gogo/protobuf
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//     * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//     * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+package proto
+
+import (
+       "fmt"
+       "io"
+)
+
+func Skip(data []byte) (n int, err error) {
+       l := len(data)
+       index := 0
+       for index < l {
+               var wire uint64
+               for shift := uint(0); ; shift += 7 {
+                       if index >= l {
+                               return 0, io.ErrUnexpectedEOF
+                       }
+                       b := data[index]
+                       index++
+                       wire |= (uint64(b) & 0x7F) << shift
+                       if b < 0x80 {
+                               break
+                       }
+               }
+               wireType := int(wire & 0x7)
+               switch wireType {
+               case 0:
+                       for {
+                               if index >= l {
+                                       return 0, io.ErrUnexpectedEOF
+                               }
+                               index++
+                               if data[index-1] < 0x80 {
+                                       break
+                               }
+                       }
+                       return index, nil
+               case 1:
+                       index += 8
+                       return index, nil
+               case 2:
+                       var length int
+                       for shift := uint(0); ; shift += 7 {
+                               if index >= l {
+                                       return 0, io.ErrUnexpectedEOF
+                               }
+                               b := data[index]
+                               index++
+                               length |= (int(b) & 0x7F) << shift
+                               if b < 0x80 {
+                                       break
+                               }
+                       }
+                       index += length
+                       return index, nil
+               case 3:
+                       for {
+                               var innerWire uint64
+                               var start int = index
+                               for shift := uint(0); ; shift += 7 {
+                                       if index >= l {
+                                               return 0, io.ErrUnexpectedEOF
+                                       }
+                                       b := data[index]
+                                       index++
+                                       innerWire |= (uint64(b) & 0x7F) << shift
+                                       if b < 0x80 {
+                                               break
+                                       }
+                               }
+                               innerWireType := int(innerWire & 0x7)
+                               if innerWireType == 4 {
+                                       break
+                               }
+                               next, err := Skip(data[start:])
+                               if err != nil {
+                                       return 0, err
+                               }
+                               index = start + next
+                       }
+                       return index, nil
+               case 4:
+                       return index, nil
+               case 5:
+                       index += 4
+                       return index, nil
+               default:
+                       return 0, fmt.Errorf("proto: illegal wireType %d", wireType)
+               }
+       }
+       panic("unreachable")
+}

diff --git a/vendor/github.com/gogo/protobuf/proto/table_marshal.go b/vendor/github.com/gogo/protobuf/proto/table_marshal.go
new file mode 100644 (file)
index 0000000..9b1538d
--- /dev/null
+++ b/vendor/github.com/gogo/protobuf/proto/table_marshal.go
@@ -0,0 +1,3006 @@
+// Go support for Protocol Buffers - Google's data interchange format
+//
+// Copyright 2016 The Go Authors.  All rights reserved.
+// https://github.com/golang/protobuf
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//     * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//     * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//     * Neither the name of Google Inc. nor the names of its
+// contributors may be used to endorse or promote products derived from
+// this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+package proto
+
+import (
+       "errors"
+       "fmt"
+       "math"
+       "reflect"
+       "sort"
+       "strconv"
+       "strings"
+       "sync"
+       "sync/atomic"
+       "unicode/utf8"
+)
+
+// a sizer takes a pointer to a field and the size of its tag, computes the size of
+// the encoded data.
+type sizer func(pointer, int) int
+
+// a marshaler takes a byte slice, a pointer to a field, and its tag (in wire format),
+// marshals the field to the end of the slice, returns the slice and error (if any).
+type marshaler func(b []byte, ptr pointer, wiretag uint64, deterministic bool) ([]byte, error)
+
+// marshalInfo is the information used for marshaling a message.
+type marshalInfo struct {
+       typ          reflect.Type
+       fields       []*marshalFieldInfo
+       unrecognized field                      // offset of XXX_unrecognized
+       extensions   field                      // offset of XXX_InternalExtensions
+       v1extensions field                      // offset of XXX_extensions
+       sizecache    field                      // offset of XXX_sizecache
+       initialized  int32                      // 0 -- only typ is set, 1 -- fully initialized
+       messageset   bool                       // uses message set wire format
+       hasmarshaler bool                       // has custom marshaler
+       sync.RWMutex                            // protect extElems map, also for initialization
+       extElems     map[int32]*marshalElemInfo // info of extension elements
+
+       hassizer      bool // has custom sizer
+       hasprotosizer bool // has custom protosizer
+
+       bytesExtensions field // offset of XXX_extensions where the field type is []byte
+}
+
+// marshalFieldInfo is the information used for marshaling a field of a message.
+type marshalFieldInfo struct {
+       field      field
+       wiretag    uint64 // tag in wire format
+       tagsize    int    // size of tag in wire format
+       sizer      sizer
+       marshaler  marshaler
+       isPointer  bool
+       required   bool                              // field is required
+       name       string                            // name of the field, for error reporting
+       oneofElems map[reflect.Type]*marshalElemInfo // info of oneof elements
+}
+
+// marshalElemInfo is the information used for marshaling an extension or oneof element.
+type marshalElemInfo struct {
+       wiretag   uint64 // tag in wire format
+       tagsize   int    // size of tag in wire format
+       sizer     sizer
+       marshaler marshaler
+       isptr     bool // elem is pointer typed, thus interface of this type is a direct interface (extension only)
+}
+
+var (
+       marshalInfoMap  = map[reflect.Type]*marshalInfo{}
+       marshalInfoLock sync.Mutex
+
+       uint8SliceType = reflect.TypeOf(([]uint8)(nil)).Kind()
+)
+
+// getMarshalInfo returns the information to marshal a given type of message.
+// The info it returns may not necessarily initialized.
+// t is the type of the message (NOT the pointer to it).
+func getMarshalInfo(t reflect.Type) *marshalInfo {
+       marshalInfoLock.Lock()
+       u, ok := marshalInfoMap[t]
+       if !ok {
+               u = &marshalInfo{typ: t}
+               marshalInfoMap[t] = u
+       }
+       marshalInfoLock.Unlock()
+       return u
+}
+
+// Size is the entry point from generated code,
+// and should be ONLY called by generated code.
+// It computes the size of encoded data of msg.
+// a is a pointer to a place to store cached marshal info.
+func (a *InternalMessageInfo) Size(msg Message) int {
+       u := getMessageMarshalInfo(msg, a)
+       ptr := toPointer(&msg)
+       if ptr.isNil() {
+               // We get here if msg is a typed nil ((*SomeMessage)(nil)),
+               // so it satisfies the interface, and msg == nil wouldn't
+               // catch it. We don't want crash in this case.
+               return 0
+       }
+       return u.size(ptr)
+}
+
+// Marshal is the entry point from generated code,
+// and should be ONLY called by generated code.
+// It marshals msg to the end of b.
+// a is a pointer to a place to store cached marshal info.
+func (a *InternalMessageInfo) Marshal(b []byte, msg Message, deterministic bool) ([]byte, error) {
+       u := getMessageMarshalInfo(msg, a)
+       ptr := toPointer(&msg)
+       if ptr.isNil() {
+               // We get here if msg is a typed nil ((*SomeMessage)(nil)),
+               // so it satisfies the interface, and msg == nil wouldn't
+               // catch it. We don't want crash in this case.
+               return b, ErrNil
+       }
+       return u.marshal(b, ptr, deterministic)
+}
+
+func getMessageMarshalInfo(msg interface{}, a *InternalMessageInfo) *marshalInfo {
+       // u := a.marshal, but atomically.
+       // We use an atomic here to ensure memory consistency.
+       u := atomicLoadMarshalInfo(&a.marshal)
+       if u == nil {
+               // Get marshal information from type of message.
+               t := reflect.ValueOf(msg).Type()
+               if t.Kind() != reflect.Ptr {
+                       panic(fmt.Sprintf("cannot handle non-pointer message type %v", t))
+               }
+               u = getMarshalInfo(t.Elem())
+               // Store it in the cache for later users.
+               // a.marshal = u, but atomically.
+               atomicStoreMarshalInfo(&a.marshal, u)
+       }
+       return u
+}
+
+// size is the main function to compute the size of the encoded data of a message.
+// ptr is the pointer to the message.
+func (u *marshalInfo) size(ptr pointer) int {
+       if atomic.LoadInt32(&u.initialized) == 0 {
+               u.computeMarshalInfo()
+       }
+
+       // If the message can marshal itself, let it do it, for compatibility.
+       // NOTE: This is not efficient.
+       if u.hasmarshaler {
+               // Uses the message's Size method if available
+               if u.hassizer {
+                       s := ptr.asPointerTo(u.typ).Interface().(Sizer)
+                       return s.Size()
+               }
+               // Uses the message's ProtoSize method if available
+               if u.hasprotosizer {
+                       s := ptr.asPointerTo(u.typ).Interface().(ProtoSizer)
+                       return s.ProtoSize()
+               }
+
+               m := ptr.asPointerTo(u.typ).Interface().(Marshaler)
+               b, _ := m.Marshal()
+               return len(b)
+       }
+
+       n := 0
+       for _, f := range u.fields {
+               if f.isPointer && ptr.offset(f.field).getPointer().isNil() {
+                       // nil pointer always marshals to nothing
+                       continue
+               }
+               n += f.sizer(ptr.offset(f.field), f.tagsize)
+       }
+       if u.extensions.IsValid() {
+               e := ptr.offset(u.extensions).toExtensions()
+               if u.messageset {
+                       n += u.sizeMessageSet(e)
+               } else {
+                       n += u.sizeExtensions(e)
+               }
+       }
+       if u.v1extensions.IsValid() {
+               m := *ptr.offset(u.v1extensions).toOldExtensions()
+               n += u.sizeV1Extensions(m)
+       }
+       if u.bytesExtensions.IsValid() {
+               s := *ptr.offset(u.bytesExtensions).toBytes()
+               n += len(s)
+       }
+       if u.unrecognized.IsValid() {
+               s := *ptr.offset(u.unrecognized).toBytes()
+               n += len(s)
+       }
+
+       // cache the result for use in marshal
+       if u.sizecache.IsValid() {
+               atomic.StoreInt32(ptr.offset(u.sizecache).toInt32(), int32(n))
+       }
+       return n
+}
+
+// cachedsize gets the size from cache. If there is no cache (i.e. message is not generated),
+// fall back to compute the size.
+func (u *marshalInfo) cachedsize(ptr pointer) int {
+       if u.sizecache.IsValid() {
+               return int(atomic.LoadInt32(ptr.offset(u.sizecache).toInt32()))
+       }
+       return u.size(ptr)
+}
+
+// marshal is the main function to marshal a message. It takes a byte slice and appends
+// the encoded data to the end of the slice, returns the slice and error (if any).
+// ptr is the pointer to the message.
+// If deterministic is true, map is marshaled in deterministic order.
+func (u *marshalInfo) marshal(b []byte, ptr pointer, deterministic bool) ([]byte, error) {
+       if atomic.LoadInt32(&u.initialized) == 0 {
+               u.computeMarshalInfo()
+       }
+
+       // If the message can marshal itself, let it do it, for compatibility.
+       // NOTE: This is not efficient.
+       if u.hasmarshaler {
+               m := ptr.asPointerTo(u.typ).Interface().(Marshaler)
+               b1, err := m.Marshal()
+               b = append(b, b1...)
+               return b, err
+       }
+
+       var err, errLater error
+       // The old marshaler encodes extensions at beginning.
+       if u.extensions.IsValid() {
+               e := ptr.offset(u.extensions).toExtensions()
+               if u.messageset {
+                       b, err = u.appendMessageSet(b, e, deterministic)
+               } else {
+                       b, err = u.appendExtensions(b, e, deterministic)
+               }
+               if err != nil {
+                       return b, err
+               }
+       }
+       if u.v1extensions.IsValid() {
+               m := *ptr.offset(u.v1extensions).toOldExtensions()
+               b, err = u.appendV1Extensions(b, m, deterministic)
+               if err != nil {
+                       return b, err
+               }
+       }
+       if u.bytesExtensions.IsValid() {
+               s := *ptr.offset(u.bytesExtensions).toBytes()
+               b = append(b, s...)
+       }
+       for _, f := range u.fields {
+               if f.required {
+                       if f.isPointer && ptr.offset(f.field).getPointer().isNil() {
+                               // Required field is not set.
+                               // We record the error but keep going, to give a complete marshaling.
+                               if errLater == nil {
+                                       errLater = &RequiredNotSetError{f.name}
+                               }
+                               continue
+                       }
+               }
+               if f.isPointer && ptr.offset(f.field).getPointer().isNil() {
+                       // nil pointer always marshals to nothing
+                       continue
+               }
+               b, err = f.marshaler(b, ptr.offset(f.field), f.wiretag, deterministic)
+               if err != nil {
+                       if err1, ok := err.(*RequiredNotSetError); ok {
+                               // Required field in submessage is not set.
+                               // We record the error but keep going, to give a complete marshaling.
+                               if errLater == nil {
+                                       errLater = &RequiredNotSetError{f.name + "." + err1.field}
+                               }
+                               continue
+                       }
+                       if err == errRepeatedHasNil {
+                               err = errors.New("proto: repeated field " + f.name + " has nil element")
+                       }
+                       if err == errInvalidUTF8 {
+                               if errLater == nil {
+                                       fullName := revProtoTypes[reflect.PtrTo(u.typ)] + "." + f.name
+                                       errLater = &invalidUTF8Error{fullName}
+                               }
+                               continue
+                       }
+                       return b, err
+               }
+       }
+       if u.unrecognized.IsValid() {
+               s := *ptr.offset(u.unrecognized).toBytes()
+               b = append(b, s...)
+       }
+       return b, errLater
+}
+
+// computeMarshalInfo initializes the marshal info.
+func (u *marshalInfo) computeMarshalInfo() {
+       u.Lock()
+       defer u.Unlock()
+       if u.initialized != 0 { // non-atomic read is ok as it is protected by the lock
+               return
+       }
+
+       t := u.typ
+       u.unrecognized = invalidField
+       u.extensions = invalidField
+       u.v1extensions = invalidField
+       u.bytesExtensions = invalidField
+       u.sizecache = invalidField
+       isOneofMessage := false
+
+       if reflect.PtrTo(t).Implements(sizerType) {
+               u.hassizer = true
+       }
+       if reflect.PtrTo(t).Implements(protosizerType) {
+               u.hasprotosizer = true
+       }
+       // If the message can marshal itself, let it do it, for compatibility.
+       // NOTE: This is not efficient.
+       if reflect.PtrTo(t).Implements(marshalerType) {
+               u.hasmarshaler = true
+               atomic.StoreInt32(&u.initialized, 1)
+               return
+       }
+
+       n := t.NumField()
+
+       // deal with XXX fields first
+       for i := 0; i < t.NumField(); i++ {
+               f := t.Field(i)
+               if f.Tag.Get("protobuf_oneof") != "" {
+                       isOneofMessage = true
+               }
+               if !strings.HasPrefix(f.Name, "XXX_") {
+                       continue
+               }
+               switch f.Name {
+               case "XXX_sizecache":
+                       u.sizecache = toField(&f)
+               case "XXX_unrecognized":
+                       u.unrecognized = toField(&f)
+               case "XXX_InternalExtensions":
+                       u.extensions = toField(&f)
+                       u.messageset = f.Tag.Get("protobuf_messageset") == "1"
+               case "XXX_extensions":
+                       if f.Type.Kind() == reflect.Map {
+                               u.v1extensions = toField(&f)
+                       } else {
+                               u.bytesExtensions = toField(&f)
+                       }
+               case "XXX_NoUnkeyedLiteral":
+                       // nothing to do
+               default:
+                       panic("unknown XXX field: " + f.Name)
+               }
+               n--
+       }
+
+       // get oneof implementers
+       var oneofImplementers []interface{}
+       // gogo: isOneofMessage is needed for embedded oneof messages, without a marshaler and unmarshaler
+       if m, ok := reflect.Zero(reflect.PtrTo(t)).Interface().(oneofMessage); ok && isOneofMessage {
+               _, _, _, oneofImplementers = m.XXX_OneofFuncs()
+       }
+
+       // normal fields
+       fields := make([]marshalFieldInfo, n) // batch allocation
+       u.fields = make([]*marshalFieldInfo, 0, n)
+       for i, j := 0, 0; i < t.NumField(); i++ {
+               f := t.Field(i)
+
+               if strings.HasPrefix(f.Name, "XXX_") {
+                       continue
+               }
+               field := &fields[j]
+               j++
+               field.name = f.Name
+               u.fields = append(u.fields, field)
+               if f.Tag.Get("protobuf_oneof") != "" {
+                       field.computeOneofFieldInfo(&f, oneofImplementers)
+                       continue
+               }
+               if f.Tag.Get("protobuf") == "" {
+                       // field has no tag (not in generated message), ignore it
+                       u.fields = u.fields[:len(u.fields)-1]
+                       j--
+                       continue
+               }
+               field.computeMarshalFieldInfo(&f)
+       }
+
+       // fields are marshaled in tag order on the wire.
+       sort.Sort(byTag(u.fields))
+
+       atomic.StoreInt32(&u.initialized, 1)
+}
+
+// helper for sorting fields by tag
+type byTag []*marshalFieldInfo
+
+func (a byTag) Len() int           { return len(a) }
+func (a byTag) Swap(i, j int)      { a[i], a[j] = a[j], a[i] }
+func (a byTag) Less(i, j int) bool { return a[i].wiretag < a[j].wiretag }
+
+// getExtElemInfo returns the information to marshal an extension element.
+// The info it returns is initialized.
+func (u *marshalInfo) getExtElemInfo(desc *ExtensionDesc) *marshalElemInfo {
+       // get from cache first
+       u.RLock()
+       e, ok := u.extElems[desc.Field]
+       u.RUnlock()
+       if ok {
+               return e
+       }
+
+       t := reflect.TypeOf(desc.ExtensionType) // pointer or slice to basic type or struct
+       tags := strings.Split(desc.Tag, ",")
+       tag, err := strconv.Atoi(tags[1])
+       if err != nil {
+               panic("tag is not an integer")
+       }
+       wt := wiretype(tags[0])
+       sizr, marshalr := typeMarshaler(t, tags, false, false)
+       e = &marshalElemInfo{
+               wiretag:   uint64(tag)<<3 | wt,
+               tagsize:   SizeVarint(uint64(tag) << 3),
+               sizer:     sizr,
+               marshaler: marshalr,
+               isptr:     t.Kind() == reflect.Ptr,
+       }
+
+       // update cache
+       u.Lock()
+       if u.extElems == nil {
+               u.extElems = make(map[int32]*marshalElemInfo)
+       }
+       u.extElems[desc.Field] = e
+       u.Unlock()
+       return e
+}
+
+// computeMarshalFieldInfo fills up the information to marshal a field.
+func (fi *marshalFieldInfo) computeMarshalFieldInfo(f *reflect.StructField) {
+       // parse protobuf tag of the field.
+       // tag has format of "bytes,49,opt,name=foo,def=hello!"
+       tags := strings.Split(f.Tag.Get("protobuf"), ",")
+       if tags[0] == "" {
+               return
+       }
+       tag, err := strconv.Atoi(tags[1])
+       if err != nil {
+               panic("tag is not an integer")
+       }
+       wt := wiretype(tags[0])
+       if tags[2] == "req" {
+               fi.required = true
+       }
+       fi.setTag(f, tag, wt)
+       fi.setMarshaler(f, tags)
+}
+
+func (fi *marshalFieldInfo) computeOneofFieldInfo(f *reflect.StructField, oneofImplementers []interface{}) {
+       fi.field = toField(f)
+       fi.wiretag = math.MaxInt32 // Use a large tag number, make oneofs sorted at the end. This tag will not appear on the wire.
+       fi.isPointer = true
+       fi.sizer, fi.marshaler = makeOneOfMarshaler(fi, f)
+       fi.oneofElems = make(map[reflect.Type]*marshalElemInfo)
+
+       ityp := f.Type // interface type
+       for _, o := range oneofImplementers {
+               t := reflect.TypeOf(o)
+               if !t.Implements(ityp) {
+                       continue
+               }
+               sf := t.Elem().Field(0) // oneof implementer is a struct with a single field
+               tags := strings.Split(sf.Tag.Get("protobuf"), ",")
+               tag, err := strconv.Atoi(tags[1])
+               if err != nil {
+                       panic("tag is not an integer")
+               }
+               wt := wiretype(tags[0])
+               sizr, marshalr := typeMarshaler(sf.Type, tags, false, true) // oneof should not omit any zero value
+               fi.oneofElems[t.Elem()] = &marshalElemInfo{
+                       wiretag:   uint64(tag)<<3 | wt,
+                       tagsize:   SizeVarint(uint64(tag) << 3),
+                       sizer:     sizr,
+                       marshaler: marshalr,
+               }
+       }
+}
+
+type oneofMessage interface {
+       XXX_OneofFuncs() (func(Message, *Buffer) error, func(Message, int, int, *Buffer) (bool, error), func(Message) int, []interface{})
+}
+
+// wiretype returns the wire encoding of the type.
+func wiretype(encoding string) uint64 {
+       switch encoding {
+       case "fixed32":
+               return WireFixed32
+       case "fixed64":
+               return WireFixed64
+       case "varint", "zigzag32", "zigzag64":
+               return WireVarint
+       case "bytes":
+               return WireBytes
+       case "group":
+               return WireStartGroup
+       }
+       panic("unknown wire type " + encoding)
+}
+
+// setTag fills up the tag (in wire format) and its size in the info of a field.
+func (fi *marshalFieldInfo) setTag(f *reflect.StructField, tag int, wt uint64) {
+       fi.field = toField(f)
+       fi.wiretag = uint64(tag)<<3 | wt
+       fi.tagsize = SizeVarint(uint64(tag) << 3)
+}
+
+// setMarshaler fills up the sizer and marshaler in the info of a field.
+func (fi *marshalFieldInfo) setMarshaler(f *reflect.StructField, tags []string) {
+       switch f.Type.Kind() {
+       case reflect.Map:
+               // map field
+               fi.isPointer = true
+               fi.sizer, fi.marshaler = makeMapMarshaler(f)
+               return
+       case reflect.Ptr, reflect.Slice:
+               fi.isPointer = true
+       }
+       fi.sizer, fi.marshaler = typeMarshaler(f.Type, tags, true, false)
+}
+
+// typeMarshaler returns the sizer and marshaler of a given field.
+// t is the type of the field.
+// tags is the generated "protobuf" tag of the field.
+// If nozero is true, zero value is not marshaled to the wire.
+// If oneof is true, it is a oneof field.
+func typeMarshaler(t reflect.Type, tags []string, nozero, oneof bool) (sizer, marshaler) {
+       encoding := tags[0]
+
+       pointer := false
+       slice := false
+       if t.Kind() == reflect.Slice && t.Elem().Kind() != reflect.Uint8 {
+               slice = true
+               t = t.Elem()
+       }
+       if t.Kind() == reflect.Ptr {
+               pointer = true
+               t = t.Elem()
+       }
+
+       packed := false
+       proto3 := false
+       ctype := false
+       isTime := false
+       isDuration := false
+       isWktPointer := false
+       validateUTF8 := true
+       for i := 2; i < len(tags); i++ {
+               if tags[i] == "packed" {
+                       packed = true
+               }
+               if tags[i] == "proto3" {
+                       proto3 = true
+               }
+               if strings.HasPrefix(tags[i], "customtype=") {
+                       ctype = true
+               }
+               if tags[i] == "stdtime" {
+                       isTime = true
+               }
+               if tags[i] == "stdduration" {
+                       isDuration = true
+               }
+               if tags[i] == "wktptr" {
+                       isWktPointer = true
+               }
+       }
+       validateUTF8 = validateUTF8 && proto3
+       if !proto3 && !pointer && !slice {
+               nozero = false
+       }
+
+       if ctype {
+               if reflect.PtrTo(t).Implements(customType) {
+                       if slice {
+                               return makeMessageRefSliceMarshaler(getMarshalInfo(t))
+                       }
+                       if pointer {
+                               return makeCustomPtrMarshaler(getMarshalInfo(t))
+                       }
+                       return makeCustomMarshaler(getMarshalInfo(t))
+               } else {
+                       panic(fmt.Sprintf("custom type: type: %v, does not implement the proto.custom interface", t))
+               }
+       }
+
+       if isTime {
+               if pointer {
+                       if slice {
+                               return makeTimePtrSliceMarshaler(getMarshalInfo(t))
+                       }
+                       return makeTimePtrMarshaler(getMarshalInfo(t))
+               }
+               if slice {
+                       return makeTimeSliceMarshaler(getMarshalInfo(t))
+               }
+               return makeTimeMarshaler(getMarshalInfo(t))
+       }
+
+       if isDuration {
+               if pointer {
+                       if slice {
+                               return makeDurationPtrSliceMarshaler(getMarshalInfo(t))
+                       }
+                       return makeDurationPtrMarshaler(getMarshalInfo(t))
+               }
+               if slice {
+                       return makeDurationSliceMarshaler(getMarshalInfo(t))
+               }
+               return makeDurationMarshaler(getMarshalInfo(t))
+       }
+
+       if isWktPointer {
+               switch t.Kind() {
+               case reflect.Float64:
+                       if pointer {
+                               if slice {
+                                       return makeStdDoubleValuePtrSliceMarshaler(getMarshalInfo(t))
+                               }
+                               return makeStdDoubleValuePtrMarshaler(getMarshalInfo(t))
+                       }
+                       if slice {
+                               return makeStdDoubleValueSliceMarshaler(getMarshalInfo(t))
+                       }
+                       return makeStdDoubleValueMarshaler(getMarshalInfo(t))
+               case reflect.Float32:
+                       if pointer {
+                               if slice {
+                                       return makeStdFloatValuePtrSliceMarshaler(getMarshalInfo(t))
+                               }
+                               return makeStdFloatValuePtrMarshaler(getMarshalInfo(t))
+                       }
+                       if slice {
+                               return makeStdFloatValueSliceMarshaler(getMarshalInfo(t))
+                       }
+                       return makeStdFloatValueMarshaler(getMarshalInfo(t))
+               case reflect.Int64:
+                       if pointer {
+                               if slice {
+                                       return makeStdInt64ValuePtrSliceMarshaler(getMarshalInfo(t))
+                               }
+                               return makeStdInt64ValuePtrMarshaler(getMarshalInfo(t))
+                       }
+                       if slice {
+                               return makeStdInt64ValueSliceMarshaler(getMarshalInfo(t))
+                       }
+                       return makeStdInt64ValueMarshaler(getMarshalInfo(t))
+               case reflect.Uint64:
+                       if pointer {
+                               if slice {
+                                       return makeStdUInt64ValuePtrSliceMarshaler(getMarshalInfo(t))
+                               }
+                               return makeStdUInt64ValuePtrMarshaler(getMarshalInfo(t))
+                       }
+                       if slice {
+                               return makeStdUInt64ValueSliceMarshaler(getMarshalInfo(t))
+                       }
+                       return makeStdUInt64ValueMarshaler(getMarshalInfo(t))
+               case reflect.Int32:
+                       if pointer {
+                               if slice {
+                                       return makeStdInt32ValuePtrSliceMarshaler(getMarshalInfo(t))
+                               }
+                               return makeStdInt32ValuePtrMarshaler(getMarshalInfo(t))
+                       }
+                       if slice {
+                               return makeStdInt32ValueSliceMarshaler(getMarshalInfo(t))
+                       }
+                       return makeStdInt32ValueMarshaler(getMarshalInfo(t))
+               case reflect.Uint32:
+                       if pointer {
+                               if slice {
+                                       return makeStdUInt32ValuePtrSliceMarshaler(getMarshalInfo(t))
+                               }
+                               return makeStdUInt32ValuePtrMarshaler(getMarshalInfo(t))
+                       }
+                       if slice {
+                               return makeStdUInt32ValueSliceMarshaler(getMarshalInfo(t))
+                       }
+                       return makeStdUInt32ValueMarshaler(getMarshalInfo(t))
+               case reflect.Bool:
+                       if pointer {
+                               if slice {
+                                       return makeStdBoolValuePtrSliceMarshaler(getMarshalInfo(t))
+                               }
+                               return makeStdBoolValuePtrMarshaler(getMarshalInfo(t))
+                       }
+                       if slice {
+                               return makeStdBoolValueSliceMarshaler(getMarshalInfo(t))
+                       }
+                       return makeStdBoolValueMarshaler(getMarshalInfo(t))
+               case reflect.String:
+                       if pointer {
+                               if slice {
+                                       return makeStdStringValuePtrSliceMarshaler(getMarshalInfo(t))
+                               }
+                               return makeStdStringValuePtrMarshaler(getMarshalInfo(t))
+                       }
+                       if slice {
+                               return makeStdStringValueSliceMarshaler(getMarshalInfo(t))
+                       }
+                       return makeStdStringValueMarshaler(getMarshalInfo(t))
+               case uint8SliceType:
+                       if pointer {
+                               if slice {
+                                       return makeStdBytesValuePtrSliceMarshaler(getMarshalInfo(t))
+                               }
+                               return makeStdBytesValuePtrMarshaler(getMarshalInfo(t))
+                       }
+                       if slice {
+                               return makeStdBytesValueSliceMarshaler(getMarshalInfo(t))
+                       }
+                       return makeStdBytesValueMarshaler(getMarshalInfo(t))
+               default:
+                       panic(fmt.Sprintf("unknown wktpointer type %#v", t))
+               }
+       }
+
+       switch t.Kind() {
+       case reflect.Bool:
+               if pointer {
+                       return sizeBoolPtr, appendBoolPtr
+               }
+               if slice {
+                       if packed {
+                               return sizeBoolPackedSlice, appendBoolPackedSlice
+                       }
+                       return sizeBoolSlice, appendBoolSlice
+               }
+               if nozero {
+                       return sizeBoolValueNoZero, appendBoolValueNoZero
+               }
+               return sizeBoolValue, appendBoolValue
+       case reflect.Uint32:
+               switch encoding {
+               case "fixed32":
+                       if pointer {
+                               return sizeFixed32Ptr, appendFixed32Ptr
+                       }
+                       if slice {
+                               if packed {
+                                       return sizeFixed32PackedSlice, appendFixed32PackedSlice
+                               }
+                               return sizeFixed32Slice, appendFixed32Slice
+                       }
+                       if nozero {
+                               return sizeFixed32ValueNoZero, appendFixed32ValueNoZero
+                       }
+                       return sizeFixed32Value, appendFixed32Value
+               case "varint":
+                       if pointer {
+                               return sizeVarint32Ptr, appendVarint32Ptr
+                       }
+                       if slice {
+                               if packed {
+                                       return sizeVarint32PackedSlice, appendVarint32PackedSlice
+                               }
+                               return sizeVarint32Slice, appendVarint32Slice
+                       }
+                       if nozero {
+                               return sizeVarint32ValueNoZero, appendVarint32ValueNoZero
+                       }
+                       return sizeVarint32Value, appendVarint32Value
+               }
+       case reflect.Int32:
+               switch encoding {
+               case "fixed32":
+                       if pointer {
+                               return sizeFixedS32Ptr, appendFixedS32Ptr
+                       }
+                       if slice {
+                               if packed {
+                                       return sizeFixedS32PackedSlice, appendFixedS32PackedSlice
+                               }
+                               return sizeFixedS32Slice, appendFixedS32Slice
+                       }
+                       if nozero {
+                               return sizeFixedS32ValueNoZero, appendFixedS32ValueNoZero
+                       }
+                       return sizeFixedS32Value, appendFixedS32Value
+               case "varint":
+                       if pointer {
+                               return sizeVarintS32Ptr, appendVarintS32Ptr
+                       }
+                       if slice {
+                               if packed {
+                                       return sizeVarintS32PackedSlice, appendVarintS32PackedSlice
+                               }
+                               return sizeVarintS32Slice, appendVarintS32Slice
+                       }
+                       if nozero {
+                               return sizeVarintS32ValueNoZero, appendVarintS32ValueNoZero
+                       }
+                       return sizeVarintS32Value, appendVarintS32Value
+               case "zigzag32":
+                       if pointer {
+                               return sizeZigzag32Ptr, appendZigzag32Ptr
+                       }
+                       if slice {
+                               if packed {
+                                       return sizeZigzag32PackedSlice, appendZigzag32PackedSlice
+                               }
+                               return sizeZigzag32Slice, appendZigzag32Slice
+                       }
+                       if nozero {
+                               return sizeZigzag32ValueNoZero, appendZigzag32ValueNoZero
+                       }
+                       return sizeZigzag32Value, appendZigzag32Value
+               }
+       case reflect.Uint64:
+               switch encoding {
+               case "fixed64":
+                       if pointer {
+                               return sizeFixed64Ptr, appendFixed64Ptr
+                       }
+                       if slice {
+                               if packed {
+                                       return sizeFixed64PackedSlice, appendFixed64PackedSlice
+                               }
+                               return sizeFixed64Slice, appendFixed64Slice
+                       }
+                       if nozero {
+                               return sizeFixed64ValueNoZero, appendFixed64ValueNoZero
+                       }
+                       return sizeFixed64Value, appendFixed64Value
+               case "varint":
+                       if pointer {
+                               return sizeVarint64Ptr, appendVarint64Ptr
+                       }
+                       if slice {
+                               if packed {
+                                       return sizeVarint64PackedSlice, appendVarint64PackedSlice
+                               }
+                               return sizeVarint64Slice, appendVarint64Slice
+                       }
+                       if nozero {
+                               return sizeVarint64ValueNoZero, appendVarint64ValueNoZero
+                       }
+                       return sizeVarint64Value, appendVarint64Value
+               }
+       case reflect.Int64:
+               switch encoding {
+               case "fixed64":
+                       if pointer {
+                               return sizeFixedS64Ptr, appendFixedS64Ptr
+                       }
+                       if slice {
+                               if packed {
+                                       return sizeFixedS64PackedSlice, appendFixedS64PackedSlice
+                               }
+                               return sizeFixedS64Slice, appendFixedS64Slice
+                       }
+                       if nozero {
+                               return sizeFixedS64ValueNoZero, appendFixedS64ValueNoZero
+                       }
+                       return sizeFixedS64Value, appendFixedS64Value
+               case "varint":
+                       if pointer {
+                               return sizeVarintS64Ptr, appendVarintS64Ptr
+                       }
+                       if slice {
+                               if packed {
+                                       return sizeVarintS64PackedSlice, appendVarintS64PackedSlice
+                               }
+                               return sizeVarintS64Slice, appendVarintS64Slice
+                       }
+                       if nozero {
+                               return sizeVarintS64ValueNoZero, appendVarintS64ValueNoZero
+                       }
+                       return sizeVarintS64Value, appendVarintS64Value
+               case "zigzag64":
+                       if pointer {
+                               return sizeZigzag64Ptr, appendZigzag64Ptr
+                       }
+                       if slice {
+                               if packed {
+                                       return sizeZigzag64PackedSlice, appendZigzag64PackedSlice
+                               }
+                               return sizeZigzag64Slice, appendZigzag64Slice
+                       }
+                       if nozero {
+                               return sizeZigzag64ValueNoZero, appendZigzag64ValueNoZero
+                       }
+                       return sizeZigzag64Value, appendZigzag64Value
+               }
+       case reflect.Float32:
+               if pointer {
+                       return sizeFloat32Ptr, appendFloat32Ptr
+               }
+               if slice {
+                       if packed {
+                               return sizeFloat32PackedSlice, appendFloat32PackedSlice
+                       }
+                       return sizeFloat32Slice, appendFloat32Slice
+               }
+               if nozero {
+                       return sizeFloat32ValueNoZero, appendFloat32ValueNoZero
+               }
+               return sizeFloat32Value, appendFloat32Value
+       case reflect.Float64:
+               if pointer {
+                       return sizeFloat64Ptr, appendFloat64Ptr
+               }
+               if slice {
+                       if packed {
+                               return sizeFloat64PackedSlice, appendFloat64PackedSlice
+                       }
+                       return sizeFloat64Slice, appendFloat64Slice
+               }
+               if nozero {
+                       return sizeFloat64ValueNoZero, appendFloat64ValueNoZero
+               }
+               return sizeFloat64Value, appendFloat64Value
+       case reflect.String:
+               if validateUTF8 {
+                       if pointer {
+                               return sizeStringPtr, appendUTF8StringPtr
+                       }
+                       if slice {
+                               return sizeStringSlice, appendUTF8StringSlice
+                       }
+                       if nozero {
+                               return sizeStringValueNoZero, appendUTF8StringValueNoZero
+                       }
+                       return sizeStringValue, appendUTF8StringValue
+               }
+               if pointer {
+                       return sizeStringPtr, appendStringPtr
+               }
+               if slice {
+                       return sizeStringSlice, appendStringSlice
+               }
+               if nozero {
+                       return sizeStringValueNoZero, appendStringValueNoZero
+               }
+               return sizeStringValue, appendStringValue
+       case reflect.Slice:
+               if slice {
+                       return sizeBytesSlice, appendBytesSlice
+               }
+               if oneof {
+                       // Oneof bytes field may also have "proto3" tag.
+                       // We want to marshal it as a oneof field. Do this
+                       // check before the proto3 check.
+                       return sizeBytesOneof, appendBytesOneof
+               }
+               if proto3 {
+                       return sizeBytes3, appendBytes3
+               }
+               return sizeBytes, appendBytes
+       case reflect.Struct:
+               switch encoding {
+               case "group":
+                       if slice {
+                               return makeGroupSliceMarshaler(getMarshalInfo(t))
+                       }
+                       return makeGroupMarshaler(getMarshalInfo(t))
+               case "bytes":
+                       if pointer {
+                               if slice {
+                                       return makeMessageSliceMarshaler(getMarshalInfo(t))
+                               }
+                               return makeMessageMarshaler(getMarshalInfo(t))
+                       } else {
+                               if slice {
+                                       return makeMessageRefSliceMarshaler(getMarshalInfo(t))
+                               }
+                               return makeMessageRefMarshaler(getMarshalInfo(t))
+                       }
+               }
+       }
+       panic(fmt.Sprintf("unknown or mismatched type: type: %v, wire type: %v", t, encoding))
+}
+
+// Below are functions to size/marshal a specific type of a field.
+// They are stored in the field's info, and called by function pointers.
+// They have type sizer or marshaler.
+
+func sizeFixed32Value(_ pointer, tagsize int) int {
+       return 4 + tagsize
+}
+func sizeFixed32ValueNoZero(ptr pointer, tagsize int) int {
+       v := *ptr.toUint32()
+       if v == 0 {
+               return 0
+       }
+       return 4 + tagsize
+}
+func sizeFixed32Ptr(ptr pointer, tagsize int) int {
+       p := *ptr.toUint32Ptr()
+       if p == nil {
+               return 0
+       }
+       return 4 + tagsize
+}
+func sizeFixed32Slice(ptr pointer, tagsize int) int {
+       s := *ptr.toUint32Slice()
+       return (4 + tagsize) * len(s)
+}
+func sizeFixed32PackedSlice(ptr pointer, tagsize int) int {
+       s := *ptr.toUint32Slice()
+       if len(s) == 0 {
+               return 0
+       }
+       return 4*len(s) + SizeVarint(uint64(4*len(s))) + tagsize
+}
+func sizeFixedS32Value(_ pointer, tagsize int) int {
+       return 4 + tagsize
+}
+func sizeFixedS32ValueNoZero(ptr pointer, tagsize int) int {
+       v := *ptr.toInt32()
+       if v == 0 {
+               return 0
+       }
+       return 4 + tagsize
+}
+func sizeFixedS32Ptr(ptr pointer, tagsize int) int {
+       p := ptr.getInt32Ptr()
+       if p == nil {
+               return 0
+       }
+       return 4 + tagsize
+}
+func sizeFixedS32Slice(ptr pointer, tagsize int) int {
+       s := ptr.getInt32Slice()
+       return (4 + tagsize) * len(s)
+}
+func sizeFixedS32PackedSlice(ptr pointer, tagsize int) int {
+       s := ptr.getInt32Slice()
+       if len(s) == 0 {
+               return 0
+       }
+       return 4*len(s) + SizeVarint(uint64(4*len(s))) + tagsize
+}
+func sizeFloat32Value(_ pointer, tagsize int) int {
+       return 4 + tagsize
+}
+func sizeFloat32ValueNoZero(ptr pointer, tagsize int) int {
+       v := math.Float32bits(*ptr.toFloat32())
+       if v == 0 {
+               return 0
+       }
+       return 4 + tagsize
+}
+func sizeFloat32Ptr(ptr pointer, tagsize int) int {
+       p := *ptr.toFloat32Ptr()
+       if p == nil {
+               return 0
+       }
+       return 4 + tagsize
+}
+func sizeFloat32Slice(ptr pointer, tagsize int) int {
+       s := *ptr.toFloat32Slice()
+       return (4 + tagsize) * len(s)
+}
+func sizeFloat32PackedSlice(ptr pointer, tagsize int) int {
+       s := *ptr.toFloat32Slice()
+       if len(s) == 0 {
+               return 0
+       }
+       return 4*len(s) + SizeVarint(uint64(4*len(s))) + tagsize
+}
+func sizeFixed64Value(_ pointer, tagsize int) int {
+       return 8 + tagsize
+}
+func sizeFixed64ValueNoZero(ptr pointer, tagsize int) int {
+       v := *ptr.toUint64()
+       if v == 0 {
+               return 0
+       }
+       return 8 + tagsize
+}
+func sizeFixed64Ptr(ptr pointer, tagsize int) int {
+       p := *ptr.toUint64Ptr()
+       if p == nil {
+               return 0
+       }
+       return 8 + tagsize
+}
+func sizeFixed64Slice(ptr pointer, tagsize int) int {
+       s := *ptr.toUint64Slice()
+       return (8 + tagsize) * len(s)
+}
+func sizeFixed64PackedSlice(ptr pointer, tagsize int) int {
+       s := *ptr.toUint64Slice()
+       if len(s) == 0 {
+               return 0
+       }
+       return 8*len(s) + SizeVarint(uint64(8*len(s))) + tagsize
+}
+func sizeFixedS64Value(_ pointer, tagsize int) int {
+       return 8 + tagsize
+}
+func sizeFixedS64ValueNoZero(ptr pointer, tagsize int) int {
+       v := *ptr.toInt64()
+       if v == 0 {
+               return 0
+       }
+       return 8 + tagsize
+}
+func sizeFixedS64Ptr(ptr pointer, tagsize int) int {
+       p := *ptr.toInt64Ptr()
+       if p == nil {
+               return 0
+       }
+       return 8 + tagsize
+}
+func sizeFixedS64Slice(ptr pointer, tagsize int) int {
+       s := *ptr.toInt64Slice()
+       return (8 + tagsize) * len(s)
+}
+func sizeFixedS64PackedSlice(ptr pointer, tagsize int) int {
+       s := *ptr.toInt64Slice()
+       if len(s) == 0 {
+               return 0
+       }
+       return 8*len(s) + SizeVarint(uint64(8*len(s))) + tagsize
+}
+func sizeFloat64Value(_ pointer, tagsize int) int {
+       return 8 + tagsize
+}
+func sizeFloat64ValueNoZero(ptr pointer, tagsize int) int {
+       v := math.Float64bits(*ptr.toFloat64())
+       if v == 0 {
+               return 0
+       }
+       return 8 + tagsize
+}
+func sizeFloat64Ptr(ptr pointer, tagsize int) int {
+       p := *ptr.toFloat64Ptr()
+       if p == nil {
+               return 0
+       }
+       return 8 + tagsize
+}
+func sizeFloat64Slice(ptr pointer, tagsize int) int {
+       s := *ptr.toFloat64Slice()
+       return (8 + tagsize) * len(s)
+}
+func sizeFloat64PackedSlice(ptr pointer, tagsize int) int {
+       s := *ptr.toFloat64Slice()
+       if len(s) == 0 {
+               return 0
+       }
+       return 8*len(s) + SizeVarint(uint64(8*len(s))) + tagsize
+}
+func sizeVarint32Value(ptr pointer, tagsize int) int {
+       v := *ptr.toUint32()
+       return SizeVarint(uint64(v)) + tagsize
+}
+func sizeVarint32ValueNoZero(ptr pointer, tagsize int) int {
+       v := *ptr.toUint32()
+       if v == 0 {
+               return 0
+       }
+       return SizeVarint(uint64(v)) + tagsize
+}
+func sizeVarint32Ptr(ptr pointer, tagsize int) int {
+       p := *ptr.toUint32Ptr()
+       if p == nil {
+               return 0
+       }
+       return SizeVarint(uint64(*p)) + tagsize
+}
+func sizeVarint32Slice(ptr pointer, tagsize int) int {
+       s := *ptr.toUint32Slice()
+       n := 0
+       for _, v := range s {
+               n += SizeVarint(uint64(v)) + tagsize
+       }
+       return n
+}
+func sizeVarint32PackedSlice(ptr pointer, tagsize int) int {
+       s := *ptr.toUint32Slice()
+       if len(s) == 0 {
+               return 0
+       }
+       n := 0
+       for _, v := range s {
+               n += SizeVarint(uint64(v))
+       }
+       return n + SizeVarint(uint64(n)) + tagsize
+}
+func sizeVarintS32Value(ptr pointer, tagsize int) int {
+       v := *ptr.toInt32()
+       return SizeVarint(uint64(v)) + tagsize
+}
+func sizeVarintS32ValueNoZero(ptr pointer, tagsize int) int {
+       v := *ptr.toInt32()
+       if v == 0 {
+               return 0
+       }
+       return SizeVarint(uint64(v)) + tagsize
+}
+func sizeVarintS32Ptr(ptr pointer, tagsize int) int {
+       p := ptr.getInt32Ptr()
+       if p == nil {
+               return 0
+       }
+       return SizeVarint(uint64(*p)) + tagsize
+}
+func sizeVarintS32Slice(ptr pointer, tagsize int) int {
+       s := ptr.getInt32Slice()
+       n := 0
+       for _, v := range s {
+               n += SizeVarint(uint64(v)) + tagsize
+       }
+       return n
+}
+func sizeVarintS32PackedSlice(ptr pointer, tagsize int) int {
+       s := ptr.getInt32Slice()
+       if len(s) == 0 {
+               return 0
+       }
+       n := 0
+       for _, v := range s {
+               n += SizeVarint(uint64(v))
+       }
+       return n + SizeVarint(uint64(n)) + tagsize
+}
+func sizeVarint64Value(ptr pointer, tagsize int) int {
+       v := *ptr.toUint64()
+       return SizeVarint(v) + tagsize
+}
+func sizeVarint64ValueNoZero(ptr pointer, tagsize int) int {
+       v := *ptr.toUint64()
+       if v == 0 {
+               return 0
+       }
+       return SizeVarint(v) + tagsize
+}
+func sizeVarint64Ptr(ptr pointer, tagsize int) int {
+       p := *ptr.toUint64Ptr()
+       if p == nil {
+               return 0
+       }
+       return SizeVarint(*p) + tagsize
+}
+func sizeVarint64Slice(ptr pointer, tagsize int) int {
+       s := *ptr.toUint64Slice()
+       n := 0
+       for _, v := range s {
+               n += SizeVarint(v) + tagsize
+       }
+       return n
+}
+func sizeVarint64PackedSlice(ptr pointer, tagsize int) int {
+       s := *ptr.toUint64Slice()
+       if len(s) == 0 {
+               return 0
+       }
+       n := 0
+       for _, v := range s {
+               n += SizeVarint(v)
+       }
+       return n + SizeVarint(uint64(n)) + tagsize
+}
+func sizeVarintS64Value(ptr pointer, tagsize int) int {
+       v := *ptr.toInt64()
+       return SizeVarint(uint64(v)) + tagsize
+}
+func sizeVarintS64ValueNoZero(ptr pointer, tagsize int) int {
+       v := *ptr.toInt64()
+       if v == 0 {
+               return 0
+       }
+       return SizeVarint(uint64(v)) + tagsize
+}
+func sizeVarintS64Ptr(ptr pointer, tagsize int) int {
+       p := *ptr.toInt64Ptr()
+       if p == nil {
+               return 0
+       }
+       return SizeVarint(uint64(*p)) + tagsize
+}
+func sizeVarintS64Slice(ptr pointer, tagsize int) int {
+       s := *ptr.toInt64Slice()
+       n := 0
+       for _, v := range s {
+               n += SizeVarint(uint64(v)) + tagsize
+       }
+       return n
+}
+func sizeVarintS64PackedSlice(ptr pointer, tagsize int) int {
+       s := *ptr.toInt64Slice()
+       if len(s) == 0 {
+               return 0
+       }
+       n := 0
+       for _, v := range s {
+               n += SizeVarint(uint64(v))
+       }
+       return n + SizeVarint(uint64(n)) + tagsize
+}
+func sizeZigzag32Value(ptr pointer, tagsize int) int {
+       v := *ptr.toInt32()
+       return SizeVarint(uint64((uint32(v)<<1)^uint32((int32(v)>>31)))) + tagsize
+}
+func sizeZigzag32ValueNoZero(ptr pointer, tagsize int) int {
+       v := *ptr.toInt32()
+       if v == 0 {
+               return 0
+       }
+       return SizeVarint(uint64((uint32(v)<<1)^uint32((int32(v)>>31)))) + tagsize
+}
+func sizeZigzag32Ptr(ptr pointer, tagsize int) int {
+       p := ptr.getInt32Ptr()
+       if p == nil {
+               return 0
+       }
+       v := *p
+       return SizeVarint(uint64((uint32(v)<<1)^uint32((int32(v)>>31)))) + tagsize
+}
+func sizeZigzag32Slice(ptr pointer, tagsize int) int {
+       s := ptr.getInt32Slice()
+       n := 0
+       for _, v := range s {
+               n += SizeVarint(uint64((uint32(v)<<1)^uint32((int32(v)>>31)))) + tagsize
+       }
+       return n
+}
+func sizeZigzag32PackedSlice(ptr pointer, tagsize int) int {
+       s := ptr.getInt32Slice()
+       if len(s) == 0 {
+               return 0
+       }
+       n := 0
+       for _, v := range s {
+               n += SizeVarint(uint64((uint32(v) << 1) ^ uint32((int32(v) >> 31))))
+       }
+       return n + SizeVarint(uint64(n)) + tagsize
+}
+func sizeZigzag64Value(ptr pointer, tagsize int) int {
+       v := *ptr.toInt64()
+       return SizeVarint(uint64(v<<1)^uint64((int64(v)>>63))) + tagsize
+}
+func sizeZigzag64ValueNoZero(ptr pointer, tagsize int) int {
+       v := *ptr.toInt64()
+       if v == 0 {
+               return 0
+       }
+       return SizeVarint(uint64(v<<1)^uint64((int64(v)>>63))) + tagsize
+}
+func sizeZigzag64Ptr(ptr pointer, tagsize int) int {
+       p := *ptr.toInt64Ptr()
+       if p == nil {
+               return 0
+       }
+       v := *p
+       return SizeVarint(uint64(v<<1)^uint64((int64(v)>>63))) + tagsize
+}
+func sizeZigzag64Slice(ptr pointer, tagsize int) int {
+       s := *ptr.toInt64Slice()
+       n := 0
+       for _, v := range s {
+               n += SizeVarint(uint64(v<<1)^uint64((int64(v)>>63))) + tagsize
+       }
+       return n
+}
+func sizeZigzag64PackedSlice(ptr pointer, tagsize int) int {
+       s := *ptr.toInt64Slice()
+       if len(s) == 0 {
+               return 0
+       }
+       n := 0
+       for _, v := range s {
+               n += SizeVarint(uint64(v<<1) ^ uint64((int64(v) >> 63)))
+       }
+       return n + SizeVarint(uint64(n)) + tagsize
+}
+func sizeBoolValue(_ pointer, tagsize int) int {
+       return 1 + tagsize
+}
+func sizeBoolValueNoZero(ptr pointer, tagsize int) int {
+       v := *ptr.toBool()
+       if !v {
+               return 0
+       }
+       return 1 + tagsize
+}
+func sizeBoolPtr(ptr pointer, tagsize int) int {
+       p := *ptr.toBoolPtr()
+       if p == nil {
+               return 0
+       }
+       return 1 + tagsize
+}
+func sizeBoolSlice(ptr pointer, tagsize int) int {
+       s := *ptr.toBoolSlice()
+       return (1 + tagsize) * len(s)
+}
+func sizeBoolPackedSlice(ptr pointer, tagsize int) int {
+       s := *ptr.toBoolSlice()
+       if len(s) == 0 {
+               return 0
+       }
+       return len(s) + SizeVarint(uint64(len(s))) + tagsize
+}
+func sizeStringValue(ptr pointer, tagsize int) int {
+       v := *ptr.toString()
+       return len(v) + SizeVarint(uint64(len(v))) + tagsize
+}
+func sizeStringValueNoZero(ptr pointer, tagsize int) int {
+       v := *ptr.toString()
+       if v == "" {
+               return 0
+       }
+       return len(v) + SizeVarint(uint64(len(v))) + tagsize
+}
+func sizeStringPtr(ptr pointer, tagsize int) int {
+       p := *ptr.toStringPtr()
+       if p == nil {
+               return 0
+       }
+       v := *p
+       return len(v) + SizeVarint(uint64(len(v))) + tagsize
+}
+func sizeStringSlice(ptr pointer, tagsize int) int {
+       s := *ptr.toStringSlice()
+       n := 0
+       for _, v := range s {
+               n += len(v) + SizeVarint(uint64(len(v))) + tagsize
+       }
+       return n
+}
+func sizeBytes(ptr pointer, tagsize int) int {
+       v := *ptr.toBytes()
+       if v == nil {
+               return 0
+       }
+       return len(v) + SizeVarint(uint64(len(v))) + tagsize
+}
+func sizeBytes3(ptr pointer, tagsize int) int {
+       v := *ptr.toBytes()
+       if len(v) == 0 {
+               return 0
+       }
+       return len(v) + SizeVarint(uint64(len(v))) + tagsize
+}
+func sizeBytesOneof(ptr pointer, tagsize int) int {
+       v := *ptr.toBytes()
+       return len(v) + SizeVarint(uint64(len(v))) + tagsize
+}
+func sizeBytesSlice(ptr pointer, tagsize int) int {
+       s := *ptr.toBytesSlice()
+       n := 0
+       for _, v := range s {
+               n += len(v) + SizeVarint(uint64(len(v))) + tagsize
+       }
+       return n
+}
+
+// appendFixed32 appends an encoded fixed32 to b.
+func appendFixed32(b []byte, v uint32) []byte {
+       b = append(b,
+               byte(v),
+               byte(v>>8),
+               byte(v>>16),
+               byte(v>>24))
+       return b
+}
+
+// appendFixed64 appends an encoded fixed64 to b.
+func appendFixed64(b []byte, v uint64) []byte {
+       b = append(b,
+               byte(v),
+               byte(v>>8),
+               byte(v>>16),
+               byte(v>>24),
+               byte(v>>32),
+               byte(v>>40),
+               byte(v>>48),
+               byte(v>>56))
+       return b
+}
+
+// appendVarint appends an encoded varint to b.
+func appendVarint(b []byte, v uint64) []byte {
+       // TODO: make 1-byte (maybe 2-byte) case inline-able, once we
+       // have non-leaf inliner.
+       switch {
+       case v < 1<<7:
+               b = append(b, byte(v))
+       case v < 1<<14:
+               b = append(b,
+                       byte(v&0x7f|0x80),
+                       byte(v>>7))
+       case v < 1<<21:
+               b = append(b,
+                       byte(v&0x7f|0x80),
+                       byte((v>>7)&0x7f|0x80),
+                       byte(v>>14))
+       case v < 1<<28:
+               b = append(b,
+                       byte(v&0x7f|0x80),
+                       byte((v>>7)&0x7f|0x80),
+                       byte((v>>14)&0x7f|0x80),
+                       byte(v>>21))
+       case v < 1<<35:
+               b = append(b,
+                       byte(v&0x7f|0x80),
+                       byte((v>>7)&0x7f|0x80),
+                       byte((v>>14)&0x7f|0x80),
+                       byte((v>>21)&0x7f|0x80),
+                       byte(v>>28))
+       case v < 1<<42:
+               b = append(b,
+                       byte(v&0x7f|0x80),
+                       byte((v>>7)&0x7f|0x80),
+                       byte((v>>14)&0x7f|0x80),
+                       byte((v>>21)&0x7f|0x80),
+                       byte((v>>28)&0x7f|0x80),
+                       byte(v>>35))
+       case v < 1<<49:
+               b = append(b,
+                       byte(v&0x7f|0x80),
+                       byte((v>>7)&0x7f|0x80),
+                       byte((v>>14)&0x7f|0x80),
+                       byte((v>>21)&0x7f|0x80),
+                       byte((v>>28)&0x7f|0x80),
+                       byte((v>>35)&0x7f|0x80),
+                       byte(v>>42))
+       case v < 1<<56:
+               b = append(b,
+                       byte(v&0x7f|0x80),
+                       byte((v>>7)&0x7f|0x80),
+                       byte((v>>14)&0x7f|0x80),
+                       byte((v>>21)&0x7f|0x80),
+                       byte((v>>28)&0x7f|0x80),
+                       byte((v>>35)&0x7f|0x80),
+                       byte((v>>42)&0x7f|0x80),
+                       byte(v>>49))
+       case v < 1<<63:
+               b = append(b,
+                       byte(v&0x7f|0x80),
+                       byte((v>>7)&0x7f|0x80),
+                       byte((v>>14)&0x7f|0x80),
+                       byte((v>>21)&0x7f|0x80),
+                       byte((v>>28)&0x7f|0x80),
+                       byte((v>>35)&0x7f|0x80),
+                       byte((v>>42)&0x7f|0x80),
+                       byte((v>>49)&0x7f|0x80),
+                       byte(v>>56))
+       default:
+               b = append(b,
+                       byte(v&0x7f|0x80),
+                       byte((v>>7)&0x7f|0x80),
+                       byte((v>>14)&0x7f|0x80),
+                       byte((v>>21)&0x7f|0x80),
+                       byte((v>>28)&0x7f|0x80),
+                       byte((v>>35)&0x7f|0x80),
+                       byte((v>>42)&0x7f|0x80),
+                       byte((v>>49)&0x7f|0x80),
+                       byte((v>>56)&0x7f|0x80),
+                       1)
+       }
+       return b
+}
+
+func appendFixed32Value(b []byte, ptr pointer, wiretag uint64, _ bool) ([]byte, error) {
+       v := *ptr.toUint32()
+       b = appendVarint(b, wiretag)
+       b = appendFixed32(b, v)
+       return b, nil
+}
+func appendFixed32ValueNoZero(b []byte, ptr pointer, wiretag uint64, _ bool) ([]byte, error) {
+       v := *ptr.toUint32()
+       if v == 0 {
+               return b, nil
+       }
+       b = appendVarint(b, wiretag)
+       b = appendFixed32(b, v)
+       return b, nil
+}
+func appendFixed32Ptr(b []byte, ptr pointer, wiretag uint64, _ bool) ([]byte, error) {
+       p := *ptr.toUint32Ptr()
+       if p == nil {
+               return b, nil
+       }
+       b = appendVarint(b, wiretag)
+       b = appendFixed32(b, *p)
+       return b, nil
+}
+func appendFixed32Slice(b []byte, ptr pointer, wiretag uint64, _ bool) ([]byte, error) {
+       s := *ptr.toUint32Slice()
+       for _, v := range s {
+               b = appendVarint(b, wiretag)
+               b = appendFixed32(b, v)
+       }
+       return b, nil
+}
+func appendFixed32PackedSlice(b []byte, ptr pointer, wiretag uint64, _ bool) ([]byte, error) {
+       s := *ptr.toUint32Slice()
+       if len(s) == 0 {
+               return b, nil
+       }
+       b = appendVarint(b, wiretag&^7|WireBytes)
+       b = appendVarint(b, uint64(4*len(s)))
+       for _, v := range s {
+               b = appendFixed32(b, v)
+       }
+       return b, nil
+}
+func appendFixedS32Value(b []byte, ptr pointer, wiretag uint64, _ bool) ([]byte, error) {
+       v := *ptr.toInt32()
+       b = appendVarint(b, wiretag)
+       b = appendFixed32(b, uint32(v))
+       return b, nil
+}
+func appendFixedS32ValueNoZero(b []byte, ptr pointer, wiretag uint64, _ bool) ([]byte, error) {
+       v := *ptr.toInt32()
+       if v == 0 {
+               return b, nil
+       }
+       b = appendVarint(b, wiretag)
+       b = appendFixed32(b, uint32(v))
+       return b, nil
+}
+func appendFixedS32Ptr(b []byte, ptr pointer, wiretag uint64, _ bool) ([]byte, error) {
+       p := ptr.getInt32Ptr()
+       if p == nil {
+               return b, nil
+       }
+       b = appendVarint(b, wiretag)
+       b = appendFixed32(b, uint32(*p))
+       return b, nil
+}
+func appendFixedS32Slice(b []byte, ptr pointer, wiretag uint64, _ bool) ([]byte, error) {
+       s := ptr.getInt32Slice()
+       for _, v := range s {
+               b = appendVarint(b, wiretag)
+               b = appendFixed32(b, uint32(v))
+       }
+       return b, nil
+}
+func appendFixedS32PackedSlice(b []byte, ptr pointer, wiretag uint64, _ bool) ([]byte, error) {
+       s := ptr.getInt32Slice()
+       if len(s) == 0 {
+               return b, nil
+       }
+       b = appendVarint(b, wiretag&^7|WireBytes)
+       b = appendVarint(b, uint64(4*len(s)))
+       for _, v := range s {
+               b = appendFixed32(b, uint32(v))
+       }
+       return b, nil
+}
+func appendFloat32Value(b []byte, ptr pointer, wiretag uint64, _ bool) ([]byte, error) {
+       v := math.Float32bits(*ptr.toFloat32())
+       b = appendVarint(b, wiretag)
+       b = appendFixed32(b, v)
+       return b, nil
+}
+func appendFloat32ValueNoZero(b []byte, ptr pointer, wiretag uint64, _ bool) ([]byte, error) {
+       v := math.Float32bits(*ptr.toFloat32())
+       if v == 0 {
+               return b, nil
+       }
+       b = appendVarint(b, wiretag)
+       b = appendFixed32(b, v)
+       return b, nil
+}
+func appendFloat32Ptr(b []byte, ptr pointer, wiretag uint64, _ bool) ([]byte, error) {
+       p := *ptr.toFloat32Ptr()
+       if p == nil {
+               return b, nil
+       }
+       b = appendVarint(b, wiretag)
+       b = appendFixed32(b, math.Float32bits(*p))
+       return b, nil
+}
+func appendFloat32Slice(b []byte, ptr pointer, wiretag uint64, _ bool) ([]byte, error) {
+       s := *ptr.toFloat32Slice()
+       for _, v := range s {
+               b = appendVarint(b, wiretag)
+               b = appendFixed32(b, math.Float32bits(v))
+       }
+       return b, nil
+}
+func appendFloat32PackedSlice(b []byte, ptr pointer, wiretag uint64, _ bool) ([]byte, error) {
+       s := *ptr.toFloat32Slice()
+       if len(s) == 0 {
+               return b, nil
+       }
+       b = appendVarint(b, wiretag&^7|WireBytes)
+       b = appendVarint(b, uint64(4*len(s)))
+       for _, v := range s {
+               b = appendFixed32(b, math.Float32bits(v))
+       }
+       return b, nil
+}
+func appendFixed64Value(b []byte, ptr pointer, wiretag uint64, _ bool) ([]byte, error) {
+       v := *ptr.toUint64()
+       b = appendVarint(b, wiretag)
+       b = appendFixed64(b, v)
+       return b, nil
+}
+func appendFixed64ValueNoZero(b []byte, ptr pointer, wiretag uint64, _ bool) ([]byte, error) {
+       v := *ptr.toUint64()
+       if v == 0 {
+               return b, nil
+       }
+       b = appendVarint(b, wiretag)
+       b = appendFixed64(b, v)
+       return b, nil
+}
+func appendFixed64Ptr(b []byte, ptr pointer, wiretag uint64, _ bool) ([]byte, error) {
+       p := *ptr.toUint64Ptr()
+       if p == nil {
+               return b, nil
+       }
+       b = appendVarint(b, wiretag)
+       b = appendFixed64(b, *p)
+       return b, nil
+}
+func appendFixed64Slice(b []byte, ptr pointer, wiretag uint64, _ bool) ([]byte, error) {
+       s := *ptr.toUint64Slice()
+       for _, v := range s {
+               b = appendVarint(b, wiretag)
+               b = appendFixed64(b, v)
+       }
+       return b, nil
+}
+func appendFixed64PackedSlice(b []byte, ptr pointer, wiretag uint64, _ bool) ([]byte, error) {
+       s := *ptr.toUint64Slice()
+       if len(s) == 0 {
+               return b, nil
+       }
+       b = appendVarint(b, wiretag&^7|WireBytes)
+       b = appendVarint(b, uint64(8*len(s)))
+       for _, v := range s {
+               b = appendFixed64(b, v)
+       }
+       return b, nil
+}
+func appendFixedS64Value(b []byte, ptr pointer, wiretag uint64, _ bool) ([]byte, error) {
+       v := *ptr.toInt64()
+       b = appendVarint(b, wiretag)
+       b = appendFixed64(b, uint64(v))
+       return b, nil
+}
+func appendFixedS64ValueNoZero(b []byte, ptr pointer, wiretag uint64, _ bool) ([]byte, error) {
+       v := *ptr.toInt64()
+       if v == 0 {
+               return b, nil
+       }
+       b = appendVarint(b, wiretag)
+       b = appendFixed64(b, uint64(v))
+       return b, nil
+}
+func appendFixedS64Ptr(b []byte, ptr pointer, wiretag uint64, _ bool) ([]byte, error) {
+       p := *ptr.toInt64Ptr()
+       if p == nil {
+               return b, nil
+       }
+       b = appendVarint(b, wiretag)
+       b = appendFixed64(b, uint64(*p))
+       return b, nil
+}
+func appendFixedS64Slice(b []byte, ptr pointer, wiretag uint64, _ bool) ([]byte, error) {
+       s := *ptr.toInt64Slice()
+       for _, v := range s {
+               b = appendVarint(b, wiretag)
+               b = appendFixed64(b, uint64(v))
+       }
+       return b, nil
+}
+func appendFixedS64PackedSlice(b []byte, ptr pointer, wiretag uint64, _ bool) ([]byte, error) {
+       s := *ptr.toInt64Slice()
+       if len(s) == 0 {
+               return b, nil
+       }
+       b = appendVarint(b, wiretag&^7|WireBytes)
+       b = appendVarint(b, uint64(8*len(s)))
+       for _, v := range s {
+               b = appendFixed64(b, uint64(v))
+       }
+       return b, nil
+}
+func appendFloat64Value(b []byte, ptr pointer, wiretag uint64, _ bool) ([]byte, error) {
+       v := math.Float64bits(*ptr.toFloat64())
+       b = appendVarint(b, wiretag)
+       b = appendFixed64(b, v)
+       return b, nil
+}
+func appendFloat64ValueNoZero(b []byte, ptr pointer, wiretag uint64, _ bool) ([]byte, error) {
+       v := math.Float64bits(*ptr.toFloat64())
+       if v == 0 {
+               return b, nil
+       }
+       b = appendVarint(b, wiretag)
+       b = appendFixed64(b, v)
+       return b, nil
+}
+func appendFloat64Ptr(b []byte, ptr pointer, wiretag uint64, _ bool) ([]byte, error) {
+       p := *ptr.toFloat64Ptr()
+       if p == nil {
+               return b, nil
+       }
+       b = appendVarint(b, wiretag)
+       b = appendFixed64(b, math.Float64bits(*p))
+       return b, nil
+}
+func appendFloat64Slice(b []byte, ptr pointer, wiretag uint64, _ bool) ([]byte, error) {
+       s := *ptr.toFloat64Slice()
+       for _, v := range s {
+               b = appendVarint(b, wiretag)
+               b = appendFixed64(b, math.Float64bits(v))
+       }
+       return b, nil
+}
+func appendFloat64PackedSlice(b []byte, ptr pointer, wiretag uint64, _ bool) ([]byte, error) {
+       s := *ptr.toFloat64Slice()
+       if len(s) == 0 {
+               return b, nil
+       }
+       b = appendVarint(b, wiretag&^7|WireBytes)
+       b = appendVarint(b, uint64(8*len(s)))
+       for _, v := range s {
+               b = appendFixed64(b, math.Float64bits(v))
+       }
+       return b, nil
+}
+func appendVarint32Value(b []byte, ptr pointer, wiretag uint64, _ bool) ([]byte, error) {
+       v := *ptr.toUint32()
+       b = appendVarint(b, wiretag)
+       b = appendVarint(b, uint64(v))
+       return b, nil
+}
+func appendVarint32ValueNoZero(b []byte, ptr pointer, wiretag uint64, _ bool) ([]byte, error) {
+       v := *ptr.toUint32()
+       if v == 0 {
+               return b, nil
+       }
+       b = appendVarint(b, wiretag)
+       b = appendVarint(b, uint64(v))
+       return b, nil
+}
+func appendVarint32Ptr(b []byte, ptr pointer, wiretag uint64, _ bool) ([]byte, error) {
+       p := *ptr.toUint32Ptr()
+       if p == nil {
+               return b, nil
+       }
+       b = appendVarint(b, wiretag)
+       b = appendVarint(b, uint64(*p))
+       return b, nil
+}
+func appendVarint32Slice(b []byte, ptr pointer, wiretag uint64, _ bool) ([]byte, error) {
+       s := *ptr.toUint32Slice()
+       for _, v := range s {
+               b = appendVarint(b, wiretag)
+               b = appendVarint(b, uint64(v))
+       }
+       return b, nil
+}
+func appendVarint32PackedSlice(b []byte, ptr pointer, wiretag uint64, _ bool) ([]byte, error) {
+       s := *ptr.toUint32Slice()
+       if len(s) == 0 {
+               return b, nil
+       }
+       b = appendVarint(b, wiretag&^7|WireBytes)
+       // compute size
+       n := 0
+       for _, v := range s {
+               n += SizeVarint(uint64(v))
+       }
+       b = appendVarint(b, uint64(n))
+       for _, v := range s {
+               b = appendVarint(b, uint64(v))
+       }
+       return b, nil
+}
+func appendVarintS32Value(b []byte, ptr pointer, wiretag uint64, _ bool) ([]byte, error) {
+       v := *ptr.toInt32()
+       b = appendVarint(b, wiretag)
+       b = appendVarint(b, uint64(v))
+       return b, nil
+}
+func appendVarintS32ValueNoZero(b []byte, ptr pointer, wiretag uint64, _ bool) ([]byte, error) {
+       v := *ptr.toInt32()
+       if v == 0 {
+               return b, nil
+       }
+       b = appendVarint(b, wiretag)
+       b = appendVarint(b, uint64(v))
+       return b, nil
+}
+func appendVarintS32Ptr(b []byte, ptr pointer, wiretag uint64, _ bool) ([]byte, error) {
+       p := ptr.getInt32Ptr()
+       if p == nil {
+               return b, nil
+       }
+       b = appendVarint(b, wiretag)
+       b = appendVarint(b, uint64(*p))
+       return b, nil
+}
+func appendVarintS32Slice(b []byte, ptr pointer, wiretag uint64, _ bool) ([]byte, error) {
+       s := ptr.getInt32Slice()
+       for _, v := range s {
+               b = appendVarint(b, wiretag)
+               b = appendVarint(b, uint64(v))
+       }
+       return b, nil
+}
+func appendVarintS32PackedSlice(b []byte, ptr pointer, wiretag uint64, _ bool) ([]byte, error) {
+       s := ptr.getInt32Slice()
+       if len(s) == 0 {
+               return b, nil
+       }
+       b = appendVarint(b, wiretag&^7|WireBytes)
+       // compute size
+       n := 0
+       for _, v := range s {
+               n += SizeVarint(uint64(v))
+       }
+       b = appendVarint(b, uint64(n))
+       for _, v := range s {
+               b = appendVarint(b, uint64(v))
+       }
+       return b, nil
+}
+func appendVarint64Value(b []byte, ptr pointer, wiretag uint64, _ bool) ([]byte, error) {
+       v := *ptr.toUint64()
+       b = appendVarint(b, wiretag)
+       b = appendVarint(b, v)
+       return b, nil
+}
+func appendVarint64ValueNoZero(b []byte, ptr pointer, wiretag uint64, _ bool) ([]byte, error) {
+       v := *ptr.toUint64()
+       if v == 0 {
+               return b, nil
+       }
+       b = appendVarint(b, wiretag)
+       b = appendVarint(b, v)
+       return b, nil
+}
+func appendVarint64Ptr(b []byte, ptr pointer, wiretag uint64, _ bool) ([]byte, error) {
+       p := *ptr.toUint64Ptr()
+       if p == nil {
+               return b, nil
+       }
+       b = appendVarint(b, wiretag)
+       b = appendVarint(b, *p)
+       return b, nil
+}
+func appendVarint64Slice(b []byte, ptr pointer, wiretag uint64, _ bool) ([]byte, error) {
+       s := *ptr.toUint64Slice()
+       for _, v := range s {
+               b = appendVarint(b, wiretag)
+               b = appendVarint(b, v)
+       }
+       return b, nil
+}
+func appendVarint64PackedSlice(b []byte, ptr pointer, wiretag uint64, _ bool) ([]byte, error) {
+       s := *ptr.toUint64Slice()
+       if len(s) == 0 {
+               return b, nil
+       }
+       b = appendVarint(b, wiretag&^7|WireBytes)
+       // compute size
+       n := 0
+       for _, v := range s {
+               n += SizeVarint(v)
+       }
+       b = appendVarint(b, uint64(n))
+       for _, v := range s {
+               b = appendVarint(b, v)
+       }
+       return b, nil
+}
+func appendVarintS64Value(b []byte, ptr pointer, wiretag uint64, _ bool) ([]byte, error) {
+       v := *ptr.toInt64()
+       b = appendVarint(b, wiretag)
+       b = appendVarint(b, uint64(v))
+       return b, nil
+}
+func appendVarintS64ValueNoZero(b []byte, ptr pointer, wiretag uint64, _ bool) ([]byte, error) {
+       v := *ptr.toInt64()
+       if v == 0 {
+               return b, nil
+       }
+       b = appendVarint(b, wiretag)
+       b = appendVarint(b, uint64(v))
+       return b, nil
+}
+func appendVarintS64Ptr(b []byte, ptr pointer, wiretag uint64, _ bool) ([]byte, error) {
+       p := *ptr.toInt64Ptr()
+       if p == nil {
+               return b, nil
+       }
+       b = appendVarint(b, wiretag)
+       b = appendVarint(b, uint64(*p))
+       return b, nil
+}
+func appendVarintS64Slice(b []byte, ptr pointer, wiretag uint64, _ bool) ([]byte, error) {
+       s := *ptr.toInt64Slice()
+       for _, v := range s {
+               b = appendVarint(b, wiretag)
+               b = appendVarint(b, uint64(v))
+       }
+       return b, nil
+}
+func appendVarintS64PackedSlice(b []byte, ptr pointer, wiretag uint64, _ bool) ([]byte, error) {
+       s := *ptr.toInt64Slice()
+       if len(s) == 0 {
+               return b, nil
+       }
+       b = appendVarint(b, wiretag&^7|WireBytes)
+       // compute size
+       n := 0
+       for _, v := range s {
+               n += SizeVarint(uint64(v))
+       }
+       b = appendVarint(b, uint64(n))
+       for _, v := range s {
+               b = appendVarint(b, uint64(v))
+       }
+       return b, nil
+}
+func appendZigzag32Value(b []byte, ptr pointer, wiretag uint64, _ bool) ([]byte, error) {
+       v := *ptr.toInt32()
+       b = appendVarint(b, wiretag)
+       b = appendVarint(b, uint64((uint32(v)<<1)^uint32((int32(v)>>31))))
+       return b, nil
+}
+func appendZigzag32ValueNoZero(b []byte, ptr pointer, wiretag uint64, _ bool) ([]byte, error) {
+       v := *ptr.toInt32()
+       if v == 0 {
+               return b, nil
+       }
+       b = appendVarint(b, wiretag)
+       b = appendVarint(b, uint64((uint32(v)<<1)^uint32((int32(v)>>31))))
+       return b, nil
+}
+func appendZigzag32Ptr(b []byte, ptr pointer, wiretag uint64, _ bool) ([]byte, error) {
+       p := ptr.getInt32Ptr()
+       if p == nil {
+               return b, nil
+       }
+       b = appendVarint(b, wiretag)
+       v := *p
+       b = appendVarint(b, uint64((uint32(v)<<1)^uint32((int32(v)>>31))))
+       return b, nil
+}
+func appendZigzag32Slice(b []byte, ptr pointer, wiretag uint64, _ bool) ([]byte, error) {
+       s := ptr.getInt32Slice()
+       for _, v := range s {
+               b = appendVarint(b, wiretag)
+               b = appendVarint(b, uint64((uint32(v)<<1)^uint32((int32(v)>>31))))
+       }
+       return b, nil
+}
+func appendZigzag32PackedSlice(b []byte, ptr pointer, wiretag uint64, _ bool) ([]byte, error) {
+       s := ptr.getInt32Slice()
+       if len(s) == 0 {
+               return b, nil
+       }
+       b = appendVarint(b, wiretag&^7|WireBytes)
+       // compute size
+       n := 0
+       for _, v := range s {
+               n += SizeVarint(uint64((uint32(v) << 1) ^ uint32((int32(v) >> 31))))
+       }
+       b = appendVarint(b, uint64(n))
+       for _, v := range s {
+               b = appendVarint(b, uint64((uint32(v)<<1)^uint32((int32(v)>>31))))
+       }
+       return b, nil
+}
+func appendZigzag64Value(b []byte, ptr pointer, wiretag uint64, _ bool) ([]byte, error) {
+       v := *ptr.toInt64()
+       b = appendVarint(b, wiretag)
+       b = appendVarint(b, uint64(v<<1)^uint64((int64(v)>>63)))
+       return b, nil
+}
+func appendZigzag64ValueNoZero(b []byte, ptr pointer, wiretag uint64, _ bool) ([]byte, error) {
+       v := *ptr.toInt64()
+       if v == 0 {
+               return b, nil
+       }
+       b = appendVarint(b, wiretag)
+       b = appendVarint(b, uint64(v<<1)^uint64((int64(v)>>63)))
+       return b, nil
+}
+func appendZigzag64Ptr(b []byte, ptr pointer, wiretag uint64, _ bool) ([]byte, error) {
+       p := *ptr.toInt64Ptr()
+       if p == nil {
+               return b, nil
+       }
+       b = appendVarint(b, wiretag)
+       v := *p
+       b = appendVarint(b, uint64(v<<1)^uint64((int64(v)>>63)))
+       return b, nil
+}
+func appendZigzag64Slice(b []byte, ptr pointer, wiretag uint64, _ bool) ([]byte, error) {
+       s := *ptr.toInt64Slice()
+       for _, v := range s {
+               b = appendVarint(b, wiretag)
+               b = appendVarint(b, uint64(v<<1)^uint64((int64(v)>>63)))
+       }
+       return b, nil
+}
+func appendZigzag64PackedSlice(b []byte, ptr pointer, wiretag uint64, _ bool) ([]byte, error) {
+       s := *ptr.toInt64Slice()
+       if len(s) == 0 {
+               return b, nil
+       }
+       b = appendVarint(b, wiretag&^7|WireBytes)
+       // compute size
+       n := 0
+       for _, v := range s {
+               n += SizeVarint(uint64(v<<1) ^ uint64((int64(v) >> 63)))
+       }
+       b = appendVarint(b, uint64(n))
+       for _, v := range s {
+               b = appendVarint(b, uint64(v<<1)^uint64((int64(v)>>63)))
+       }
+       return b, nil
+}
+func appendBoolValue(b []byte, ptr pointer, wiretag uint64, _ bool) ([]byte, error) {
+       v := *ptr.toBool()
+       b = appendVarint(b, wiretag)
+       if v {
+               b = append(b, 1)
+       } else {
+               b = append(b, 0)
+       }
+       return b, nil
+}
+func appendBoolValueNoZero(b []byte, ptr pointer, wiretag uint64, _ bool) ([]byte, error) {
+       v := *ptr.toBool()
+       if !v {
+               return b, nil
+       }
+       b = appendVarint(b, wiretag)
+       b = append(b, 1)
+       return b, nil
+}
+
+func appendBoolPtr(b []byte, ptr pointer, wiretag uint64, _ bool) ([]byte, error) {
+       p := *ptr.toBoolPtr()
+       if p == nil {
+               return b, nil
+       }
+       b = appendVarint(b, wiretag)
+       if *p {
+               b = append(b, 1)
+       } else {
+               b = append(b, 0)
+       }
+       return b, nil
+}
+func appendBoolSlice(b []byte, ptr pointer, wiretag uint64, _ bool) ([]byte, error) {
+       s := *ptr.toBoolSlice()
+       for _, v := range s {
+               b = appendVarint(b, wiretag)
+               if v {
+                       b = append(b, 1)
+               } else {
+                       b = append(b, 0)
+               }
+       }
+       return b, nil
+}
+func appendBoolPackedSlice(b []byte, ptr pointer, wiretag uint64, _ bool) ([]byte, error) {
+       s := *ptr.toBoolSlice()
+       if len(s) == 0 {
+               return b, nil
+       }
+       b = appendVarint(b, wiretag&^7|WireBytes)
+       b = appendVarint(b, uint64(len(s)))
+       for _, v := range s {
+               if v {
+                       b = append(b, 1)
+               } else {
+                       b = append(b, 0)
+               }
+       }
+       return b, nil
+}
+func appendStringValue(b []byte, ptr pointer, wiretag uint64, _ bool) ([]byte, error) {
+       v := *ptr.toString()
+       b = appendVarint(b, wiretag)
+       b = appendVarint(b, uint64(len(v)))
+       b = append(b, v...)
+       return b, nil
+}
+func appendStringValueNoZero(b []byte, ptr pointer, wiretag uint64, _ bool) ([]byte, error) {
+       v := *ptr.toString()
+       if v == "" {
+               return b, nil
+       }
+       b = appendVarint(b, wiretag)
+       b = appendVarint(b, uint64(len(v)))
+       b = append(b, v...)
+       return b, nil
+}
+func appendStringPtr(b []byte, ptr pointer, wiretag uint64, _ bool) ([]byte, error) {
+       p := *ptr.toStringPtr()
+       if p == nil {
+               return b, nil
+       }
+       v := *p
+       b = appendVarint(b, wiretag)
+       b = appendVarint(b, uint64(len(v)))
+       b = append(b, v...)
+       return b, nil
+}
+func appendStringSlice(b []byte, ptr pointer, wiretag uint64, _ bool) ([]byte, error) {
+       s := *ptr.toStringSlice()
+       for _, v := range s {
+               b = appendVarint(b, wiretag)
+               b = appendVarint(b, uint64(len(v)))
+               b = append(b, v...)
+       }
+       return b, nil
+}
+func appendUTF8StringValue(b []byte, ptr pointer, wiretag uint64, _ bool) ([]byte, error) {
+       var invalidUTF8 bool
+       v := *ptr.toString()
+       if !utf8.ValidString(v) {
+               invalidUTF8 = true
+       }
+       b = appendVarint(b, wiretag)
+       b = appendVarint(b, uint64(len(v)))
+       b = append(b, v...)
+       if invalidUTF8 {
+               return b, errInvalidUTF8
+       }
+       return b, nil
+}
+func appendUTF8StringValueNoZero(b []byte, ptr pointer, wiretag uint64, _ bool) ([]byte, error) {
+       var invalidUTF8 bool
+       v := *ptr.toString()
+       if v == "" {
+               return b, nil
+       }
+       if !utf8.ValidString(v) {
+               invalidUTF8 = true
+       }
+       b = appendVarint(b, wiretag)
+       b = appendVarint(b, uint64(len(v)))
+       b = append(b, v...)
+       if invalidUTF8 {
+               return b, errInvalidUTF8
+       }
+       return b, nil
+}
+func appendUTF8StringPtr(b []byte, ptr pointer, wiretag uint64, _ bool) ([]byte, error) {
+       var invalidUTF8 bool
+       p := *ptr.toStringPtr()
+       if p == nil {
+               return b, nil
+       }
+       v := *p
+       if !utf8.ValidString(v) {
+               invalidUTF8 = true
+       }
+       b = appendVarint(b, wiretag)
+       b = appendVarint(b, uint64(len(v)))
+       b = append(b, v...)
+       if invalidUTF8 {
+               return b, errInvalidUTF8
+       }
+       return b, nil
+}
+func appendUTF8StringSlice(b []byte, ptr pointer, wiretag uint64, _ bool) ([]byte, error) {
+       var invalidUTF8 bool
+       s := *ptr.toStringSlice()
+       for _, v := range s {
+               if !utf8.ValidString(v) {
+                       invalidUTF8 = true
+               }
+               b = appendVarint(b, wiretag)
+               b = appendVarint(b, uint64(len(v)))
+               b = append(b, v...)
+       }
+       if invalidUTF8 {
+               return b, errInvalidUTF8
+       }
+       return b, nil
+}
+func appendBytes(b []byte, ptr pointer, wiretag uint64, _ bool) ([]byte, error) {
+       v := *ptr.toBytes()
+       if v == nil {
+               return b, nil
+       }
+       b = appendVarint(b, wiretag)
+       b = appendVarint(b, uint64(len(v)))
+       b = append(b, v...)
+       return b, nil
+}
+func appendBytes3(b []byte, ptr pointer, wiretag uint64, _ bool) ([]byte, error) {
+       v := *ptr.toBytes()
+       if len(v) == 0 {
+               return b, nil
+       }
+       b = appendVarint(b, wiretag)
+       b = appendVarint(b, uint64(len(v)))
+       b = append(b, v...)
+       return b, nil
+}
+func appendBytesOneof(b []byte, ptr pointer, wiretag uint64, _ bool) ([]byte, error) {
+       v := *ptr.toBytes()
+       b = appendVarint(b, wiretag)
+       b = appendVarint(b, uint64(len(v)))
+       b = append(b, v...)
+       return b, nil
+}
+func appendBytesSlice(b []byte, ptr pointer, wiretag uint64, _ bool) ([]byte, error) {
+       s := *ptr.toBytesSlice()
+       for _, v := range s {
+               b = appendVarint(b, wiretag)
+               b = appendVarint(b, uint64(len(v)))
+               b = append(b, v...)
+       }
+       return b, nil
+}
+
+// makeGroupMarshaler returns the sizer and marshaler for a group.
+// u is the marshal info of the underlying message.
+func makeGroupMarshaler(u *marshalInfo) (sizer, marshaler) {
+       return func(ptr pointer, tagsize int) int {
+                       p := ptr.getPointer()
+                       if p.isNil() {
+                               return 0
+                       }
+                       return u.size(p) + 2*tagsize
+               },
+               func(b []byte, ptr pointer, wiretag uint64, deterministic bool) ([]byte, error) {
+                       p := ptr.getPointer()
+                       if p.isNil() {
+                               return b, nil
+                       }
+                       var err error
+                       b = appendVarint(b, wiretag) // start group
+                       b, err = u.marshal(b, p, deterministic)
+                       b = appendVarint(b, wiretag+(WireEndGroup-WireStartGroup)) // end group
+                       return b, err
+               }
+}
+
+// makeGroupSliceMarshaler returns the sizer and marshaler for a group slice.
+// u is the marshal info of the underlying message.
+func makeGroupSliceMarshaler(u *marshalInfo) (sizer, marshaler) {
+       return func(ptr pointer, tagsize int) int {
+                       s := ptr.getPointerSlice()
+                       n := 0
+                       for _, v := range s {
+                               if v.isNil() {
+                                       continue
+                               }
+                               n += u.size(v) + 2*tagsize
+                       }
+                       return n
+               },
+               func(b []byte, ptr pointer, wiretag uint64, deterministic bool) ([]byte, error) {
+                       s := ptr.getPointerSlice()
+                       var err error
+                       var nerr nonFatal
+                       for _, v := range s {
+                               if v.isNil() {
+                                       return b, errRepeatedHasNil
+                               }
+                               b = appendVarint(b, wiretag) // start group
+                               b, err = u.marshal(b, v, deterministic)
+                               b = appendVarint(b, wiretag+(WireEndGroup-WireStartGroup)) // end group
+                               if !nerr.Merge(err) {
+                                       if err == ErrNil {
+                                               err = errRepeatedHasNil
+                                       }
+                                       return b, err
+                               }
+                       }
+                       return b, nerr.E
+               }
+}
+
+// makeMessageMarshaler returns the sizer and marshaler for a message field.
+// u is the marshal info of the message.
+func makeMessageMarshaler(u *marshalInfo) (sizer, marshaler) {
+       return func(ptr pointer, tagsize int) int {
+                       p := ptr.getPointer()
+                       if p.isNil() {
+                               return 0
+                       }
+                       siz := u.size(p)
+                       return siz + SizeVarint(uint64(siz)) + tagsize
+               },
+               func(b []byte, ptr pointer, wiretag uint64, deterministic bool) ([]byte, error) {
+                       p := ptr.getPointer()
+                       if p.isNil() {
+                               return b, nil
+                       }
+                       b = appendVarint(b, wiretag)
+                       siz := u.cachedsize(p)
+                       b = appendVarint(b, uint64(siz))
+                       return u.marshal(b, p, deterministic)
+               }
+}
+
+// makeMessageSliceMarshaler returns the sizer and marshaler for a message slice.
+// u is the marshal info of the message.
+func makeMessageSliceMarshaler(u *marshalInfo) (sizer, marshaler) {
+       return func(ptr pointer, tagsize int) int {
+                       s := ptr.getPointerSlice()
+                       n := 0
+                       for _, v := range s {
+                               if v.isNil() {
+                                       continue
+                               }
+                               siz := u.size(v)
+                               n += siz + SizeVarint(uint64(siz)) + tagsize
+                       }
+                       return n
+               },
+               func(b []byte, ptr pointer, wiretag uint64, deterministic bool) ([]byte, error) {
+                       s := ptr.getPointerSlice()
+                       var err error
+                       var nerr nonFatal
+                       for _, v := range s {
+                               if v.isNil() {
+                                       return b, errRepeatedHasNil
+                               }
+                               b = appendVarint(b, wiretag)
+                               siz := u.cachedsize(v)
+                               b = appendVarint(b, uint64(siz))
+                               b, err = u.marshal(b, v, deterministic)
+
+                               if !nerr.Merge(err) {
+                                       if err == ErrNil {
+                                               err = errRepeatedHasNil
+                                       }
+                                       return b, err
+                               }
+                       }
+                       return b, nerr.E
+               }
+}
+
+// makeMapMarshaler returns the sizer and marshaler for a map field.
+// f is the pointer to the reflect data structure of the field.
+func makeMapMarshaler(f *reflect.StructField) (sizer, marshaler) {
+       // figure out key and value type
+       t := f.Type
+       keyType := t.Key()
+       valType := t.Elem()
+       tags := strings.Split(f.Tag.Get("protobuf"), ",")
+       keyTags := strings.Split(f.Tag.Get("protobuf_key"), ",")
+       valTags := strings.Split(f.Tag.Get("protobuf_val"), ",")
+       stdOptions := false
+       for _, t := range tags {
+               if strings.HasPrefix(t, "customtype=") {
+                       valTags = append(valTags, t)
+               }
+               if t == "stdtime" {
+                       valTags = append(valTags, t)
+                       stdOptions = true
+               }
+               if t == "stdduration" {
+                       valTags = append(valTags, t)
+                       stdOptions = true
+               }
+               if t == "wktptr" {
+                       valTags = append(valTags, t)
+               }
+       }
+       keySizer, keyMarshaler := typeMarshaler(keyType, keyTags, false, false) // don't omit zero value in map
+       valSizer, valMarshaler := typeMarshaler(valType, valTags, false, false) // don't omit zero value in map
+       keyWireTag := 1<<3 | wiretype(keyTags[0])
+       valWireTag := 2<<3 | wiretype(valTags[0])
+
+       // We create an interface to get the addresses of the map key and value.
+       // If value is pointer-typed, the interface is a direct interface, the
+       // idata itself is the value. Otherwise, the idata is the pointer to the
+       // value.
+       // Key cannot be pointer-typed.
+       valIsPtr := valType.Kind() == reflect.Ptr
+
+       // If value is a message with nested maps, calling
+       // valSizer in marshal may be quadratic. We should use
+       // cached version in marshal (but not in size).
+       // If value is not message type, we don't have size cache,
+       // but it cannot be nested either. Just use valSizer.
+       valCachedSizer := valSizer
+       if valIsPtr && !stdOptions && valType.Elem().Kind() == reflect.Struct {
+               u := getMarshalInfo(valType.Elem())
+               valCachedSizer = func(ptr pointer, tagsize int) int {
+                       // Same as message sizer, but use cache.
+                       p := ptr.getPointer()
+                       if p.isNil() {
+                               return 0
+                       }
+                       siz := u.cachedsize(p)
+                       return siz + SizeVarint(uint64(siz)) + tagsize
+               }
+       }
+       return func(ptr pointer, tagsize int) int {
+                       m := ptr.asPointerTo(t).Elem() // the map
+                       n := 0
+                       for _, k := range m.MapKeys() {
+                               ki := k.Interface()
+                               vi := m.MapIndex(k).Interface()
+                               kaddr := toAddrPointer(&ki, false)             // pointer to key
+                               vaddr := toAddrPointer(&vi, valIsPtr)          // pointer to value
+                               siz := keySizer(kaddr, 1) + valSizer(vaddr, 1) // tag of key = 1 (size=1), tag of val = 2 (size=1)
+                               n += siz + SizeVarint(uint64(siz)) + tagsize
+                       }
+                       return n
+               },
+               func(b []byte, ptr pointer, tag uint64, deterministic bool) ([]byte, error) {
+                       m := ptr.asPointerTo(t).Elem() // the map
+                       var err error
+                       keys := m.MapKeys()
+                       if len(keys) > 1 && deterministic {
+                               sort.Sort(mapKeys(keys))
+                       }
+
+                       var nerr nonFatal
+                       for _, k := range keys {
+                               ki := k.Interface()
+                               vi := m.MapIndex(k).Interface()
+                               kaddr := toAddrPointer(&ki, false)    // pointer to key
+                               vaddr := toAddrPointer(&vi, valIsPtr) // pointer to value
+                               b = appendVarint(b, tag)
+                               siz := keySizer(kaddr, 1) + valCachedSizer(vaddr, 1) // tag of key = 1 (size=1), tag of val = 2 (size=1)
+                               b = appendVarint(b, uint64(siz))
+                               b, err = keyMarshaler(b, kaddr, keyWireTag, deterministic)
+                               if !nerr.Merge(err) {
+                                       return b, err
+                               }
+                               b, err = valMarshaler(b, vaddr, valWireTag, deterministic)
+                               if err != ErrNil && !nerr.Merge(err) { // allow nil value in map
+                                       return b, err
+                               }
+                       }
+                       return b, nerr.E
+               }
+}
+
+// makeOneOfMarshaler returns the sizer and marshaler for a oneof field.
+// fi is the marshal info of the field.
+// f is the pointer to the reflect data structure of the field.
+func makeOneOfMarshaler(fi *marshalFieldInfo, f *reflect.StructField) (sizer, marshaler) {
+       // Oneof field is an interface. We need to get the actual data type on the fly.
+       t := f.Type
+       return func(ptr pointer, _ int) int {
+                       p := ptr.getInterfacePointer()
+                       if p.isNil() {
+                               return 0
+                       }
+                       v := ptr.asPointerTo(t).Elem().Elem().Elem() // *interface -> interface -> *struct -> struct
+                       telem := v.Type()
+                       e := fi.oneofElems[telem]
+                       return e.sizer(p, e.tagsize)
+               },
+               func(b []byte, ptr pointer, _ uint64, deterministic bool) ([]byte, error) {
+                       p := ptr.getInterfacePointer()
+                       if p.isNil() {
+                               return b, nil
+                       }
+                       v := ptr.asPointerTo(t).Elem().Elem().Elem() // *interface -> interface -> *struct -> struct
+                       telem := v.Type()
+                       if telem.Field(0).Type.Kind() == reflect.Ptr && p.getPointer().isNil() {
+                               return b, errOneofHasNil
+                       }
+                       e := fi.oneofElems[telem]
+                       return e.marshaler(b, p, e.wiretag, deterministic)
+               }
+}
+
+// sizeExtensions computes the size of encoded data for a XXX_InternalExtensions field.
+func (u *marshalInfo) sizeExtensions(ext *XXX_InternalExtensions) int {
+       m, mu := ext.extensionsRead()
+       if m == nil {
+               return 0
+       }
+       mu.Lock()
+
+       n := 0
+       for _, e := range m {
+               if e.value == nil || e.desc == nil {
+                       // Extension is only in its encoded form.
+                       n += len(e.enc)
+                       continue
+               }
+
+               // We don't skip extensions that have an encoded form set,
+               // because the extension value may have been mutated after
+               // the last time this function was called.
+               ei := u.getExtElemInfo(e.desc)
+               v := e.value
+               p := toAddrPointer(&v, ei.isptr)
+               n += ei.sizer(p, ei.tagsize)
+       }
+       mu.Unlock()
+       return n
+}
+
+// appendExtensions marshals a XXX_InternalExtensions field to the end of byte slice b.
+func (u *marshalInfo) appendExtensions(b []byte, ext *XXX_InternalExtensions, deterministic bool) ([]byte, error) {
+       m, mu := ext.extensionsRead()
+       if m == nil {
+               return b, nil
+       }
+       mu.Lock()
+       defer mu.Unlock()
+
+       var err error
+       var nerr nonFatal
+
+       // Fast-path for common cases: zero or one extensions.
+       // Don't bother sorting the keys.
+       if len(m) <= 1 {
+               for _, e := range m {
+                       if e.value == nil || e.desc == nil {
+                               // Extension is only in its encoded form.
+                               b = append(b, e.enc...)
+                               continue
+                       }
+
+                       // We don't skip extensions that have an encoded form set,
+                       // because the extension value may have been mutated after
+                       // the last time this function was called.
+
+                       ei := u.getExtElemInfo(e.desc)
+                       v := e.value
+                       p := toAddrPointer(&v, ei.isptr)
+                       b, err = ei.marshaler(b, p, ei.wiretag, deterministic)
+                       if !nerr.Merge(err) {
+                               return b, err
+                       }
+               }
+               return b, nerr.E
+       }
+
+       // Sort the keys to provide a deterministic encoding.
+       // Not sure this is required, but the old code does it.
+       keys := make([]int, 0, len(m))
+       for k := range m {
+               keys = append(keys, int(k))
+       }
+       sort.Ints(keys)
+
+       for _, k := range keys {
+               e := m[int32(k)]
+               if e.value == nil || e.desc == nil {
+                       // Extension is only in its encoded form.
+                       b = append(b, e.enc...)
+                       continue
+               }
+
+               // We don't skip extensions that have an encoded form set,
+               // because the extension value may have been mutated after
+               // the last time this function was called.
+
+               ei := u.getExtElemInfo(e.desc)
+               v := e.value
+               p := toAddrPointer(&v, ei.isptr)
+               b, err = ei.marshaler(b, p, ei.wiretag, deterministic)
+               if !nerr.Merge(err) {
+                       return b, err
+               }
+       }
+       return b, nerr.E
+}
+
+// message set format is:
+//   message MessageSet {
+//     repeated group Item = 1 {
+//       required int32 type_id = 2;
+//       required string message = 3;
+//     };
+//   }
+
+// sizeMessageSet computes the size of encoded data for a XXX_InternalExtensions field
+// in message set format (above).
+func (u *marshalInfo) sizeMessageSet(ext *XXX_InternalExtensions) int {
+       m, mu := ext.extensionsRead()
+       if m == nil {
+               return 0
+       }
+       mu.Lock()
+
+       n := 0
+       for id, e := range m {
+               n += 2                          // start group, end group. tag = 1 (size=1)
+               n += SizeVarint(uint64(id)) + 1 // type_id, tag = 2 (size=1)
+
+               if e.value == nil || e.desc == nil {
+                       // Extension is only in its encoded form.
+                       msgWithLen := skipVarint(e.enc) // skip old tag, but leave the length varint
+                       siz := len(msgWithLen)
+                       n += siz + 1 // message, tag = 3 (size=1)
+                       continue
+               }
+
+               // We don't skip extensions that have an encoded form set,
+               // because the extension value may have been mutated after
+               // the last time this function was called.
+
+               ei := u.getExtElemInfo(e.desc)
+               v := e.value
+               p := toAddrPointer(&v, ei.isptr)
+               n += ei.sizer(p, 1) // message, tag = 3 (size=1)
+       }
+       mu.Unlock()
+       return n
+}
+
+// appendMessageSet marshals a XXX_InternalExtensions field in message set format (above)
+// to the end of byte slice b.
+func (u *marshalInfo) appendMessageSet(b []byte, ext *XXX_InternalExtensions, deterministic bool) ([]byte, error) {
+       m, mu := ext.extensionsRead()
+       if m == nil {
+               return b, nil
+       }
+       mu.Lock()
+       defer mu.Unlock()
+
+       var err error
+       var nerr nonFatal
+
+       // Fast-path for common cases: zero or one extensions.
+       // Don't bother sorting the keys.
+       if len(m) <= 1 {
+               for id, e := range m {
+                       b = append(b, 1<<3|WireStartGroup)
+                       b = append(b, 2<<3|WireVarint)
+                       b = appendVarint(b, uint64(id))
+
+                       if e.value == nil || e.desc == nil {
+                               // Extension is only in its encoded form.
+                               msgWithLen := skipVarint(e.enc) // skip old tag, but leave the length varint
+                               b = append(b, 3<<3|WireBytes)
+                               b = append(b, msgWithLen...)
+                               b = append(b, 1<<3|WireEndGroup)
+                               continue
+                       }
+
+                       // We don't skip extensions that have an encoded form set,
+                       // because the extension value may have been mutated after
+                       // the last time this function was called.
+
+                       ei := u.getExtElemInfo(e.desc)
+                       v := e.value
+                       p := toAddrPointer(&v, ei.isptr)
+                       b, err = ei.marshaler(b, p, 3<<3|WireBytes, deterministic)
+                       if !nerr.Merge(err) {
+                               return b, err
+                       }
+                       b = append(b, 1<<3|WireEndGroup)
+               }
+               return b, nerr.E
+       }
+
+       // Sort the keys to provide a deterministic encoding.
+       keys := make([]int, 0, len(m))
+       for k := range m {
+               keys = append(keys, int(k))
+       }
+       sort.Ints(keys)
+
+       for _, id := range keys {
+               e := m[int32(id)]
+               b = append(b, 1<<3|WireStartGroup)
+               b = append(b, 2<<3|WireVarint)
+               b = appendVarint(b, uint64(id))
+
+               if e.value == nil || e.desc == nil {
+                       // Extension is only in its encoded form.
+                       msgWithLen := skipVarint(e.enc) // skip old tag, but leave the length varint
+                       b = append(b, 3<<3|WireBytes)
+                       b = append(b, msgWithLen...)
+                       b = append(b, 1<<3|WireEndGroup)
+                       continue
+               }
+
+               // We don't skip extensions that have an encoded form set,
+               // because the extension value may have been mutated after
+               // the last time this function was called.
+
+               ei := u.getExtElemInfo(e.desc)
+               v := e.value
+               p := toAddrPointer(&v, ei.isptr)
+               b, err = ei.marshaler(b, p, 3<<3|WireBytes, deterministic)
+               b = append(b, 1<<3|WireEndGroup)
+               if !nerr.Merge(err) {
+                       return b, err
+               }
+       }
+       return b, nerr.E
+}
+
+// sizeV1Extensions computes the size of encoded data for a V1-API extension field.
+func (u *marshalInfo) sizeV1Extensions(m map[int32]Extension) int {
+       if m == nil {
+               return 0
+       }
+
+       n := 0
+       for _, e := range m {
+               if e.value == nil || e.desc == nil {
+                       // Extension is only in its encoded form.
+                       n += len(e.enc)
+                       continue
+               }
+
+               // We don't skip extensions that have an encoded form set,
+               // because the extension value may have been mutated after
+               // the last time this function was called.
+
+               ei := u.getExtElemInfo(e.desc)
+               v := e.value
+               p := toAddrPointer(&v, ei.isptr)
+               n += ei.sizer(p, ei.tagsize)
+       }
+       return n
+}
+
+// appendV1Extensions marshals a V1-API extension field to the end of byte slice b.
+func (u *marshalInfo) appendV1Extensions(b []byte, m map[int32]Extension, deterministic bool) ([]byte, error) {
+       if m == nil {
+               return b, nil
+       }
+
+       // Sort the keys to provide a deterministic encoding.
+       keys := make([]int, 0, len(m))
+       for k := range m {
+               keys = append(keys, int(k))
+       }
+       sort.Ints(keys)
+
+       var err error
+       var nerr nonFatal
+       for _, k := range keys {
+               e := m[int32(k)]
+               if e.value == nil || e.desc == nil {
+                       // Extension is only in its encoded form.
+                       b = append(b, e.enc...)
+                       continue
+               }
+
+               // We don't skip extensions that have an encoded form set,
+               // because the extension value may have been mutated after
+               // the last time this function was called.
+
+               ei := u.getExtElemInfo(e.desc)
+               v := e.value
+               p := toAddrPointer(&v, ei.isptr)
+               b, err = ei.marshaler(b, p, ei.wiretag, deterministic)
+               if !nerr.Merge(err) {
+                       return b, err
+               }
+       }
+       return b, nerr.E
+}
+
+// newMarshaler is the interface representing objects that can marshal themselves.
+//
+// This exists to support protoc-gen-go generated messages.
+// The proto package will stop type-asserting to this interface in the future.
+//
+// DO NOT DEPEND ON THIS.
+type newMarshaler interface {
+       XXX_Size() int
+       XXX_Marshal(b []byte, deterministic bool) ([]byte, error)
+}
+
+// Size returns the encoded size of a protocol buffer message.
+// This is the main entry point.
+func Size(pb Message) int {
+       if m, ok := pb.(newMarshaler); ok {
+               return m.XXX_Size()
+       }
+       if m, ok := pb.(Marshaler); ok {
+               // If the message can marshal itself, let it do it, for compatibility.
+               // NOTE: This is not efficient.
+               b, _ := m.Marshal()
+               return len(b)
+       }
+       // in case somehow we didn't generate the wrapper
+       if pb == nil {
+               return 0
+       }
+       var info InternalMessageInfo
+       return info.Size(pb)
+}
+
+// Marshal takes a protocol buffer message
+// and encodes it into the wire format, returning the data.
+// This is the main entry point.
+func Marshal(pb Message) ([]byte, error) {
+       if m, ok := pb.(newMarshaler); ok {
+               siz := m.XXX_Size()
+               b := make([]byte, 0, siz)
+               return m.XXX_Marshal(b, false)
+       }
+       if m, ok := pb.(Marshaler); ok {
+               // If the message can marshal itself, let it do it, for compatibility.
+               // NOTE: This is not efficient.
+               return m.Marshal()
+       }
+       // in case somehow we didn't generate the wrapper
+       if pb == nil {
+               return nil, ErrNil
+       }
+       var info InternalMessageInfo
+       siz := info.Size(pb)
+       b := make([]byte, 0, siz)
+       return info.Marshal(b, pb, false)
+}
+
+// Marshal takes a protocol buffer message
+// and encodes it into the wire format, writing the result to the
+// Buffer.
+// This is an alternative entry point. It is not necessary to use
+// a Buffer for most applications.
+func (p *Buffer) Marshal(pb Message) error {
+       var err error
+       if p.deterministic {
+               if _, ok := pb.(Marshaler); ok {
+                       return fmt.Errorf("proto: deterministic not supported by the Marshal method of %T", pb)
+               }
+       }
+       if m, ok := pb.(newMarshaler); ok {
+               siz := m.XXX_Size()
+               p.grow(siz) // make sure buf has enough capacity
+               p.buf, err = m.XXX_Marshal(p.buf, p.deterministic)
+               return err
+       }
+       if m, ok := pb.(Marshaler); ok {
+               // If the message can marshal itself, let it do it, for compatibility.
+               // NOTE: This is not efficient.
+               var b []byte
+               b, err = m.Marshal()
+               p.buf = append(p.buf, b...)
+               return err
+       }
+       // in case somehow we didn't generate the wrapper
+       if pb == nil {
+               return ErrNil
+       }
+       var info InternalMessageInfo
+       siz := info.Size(pb)
+       p.grow(siz) // make sure buf has enough capacity
+       p.buf, err = info.Marshal(p.buf, pb, p.deterministic)
+       return err
+}
+
+// grow grows the buffer's capacity, if necessary, to guarantee space for
+// another n bytes. After grow(n), at least n bytes can be written to the
+// buffer without another allocation.
+func (p *Buffer) grow(n int) {
+       need := len(p.buf) + n
+       if need <= cap(p.buf) {
+               return
+       }
+       newCap := len(p.buf) * 2
+       if newCap < need {
+               newCap = need
+       }
+       p.buf = append(make([]byte, 0, newCap), p.buf...)
+}

diff --git a/vendor/github.com/gogo/protobuf/proto/table_marshal_gogo.go b/vendor/github.com/gogo/protobuf/proto/table_marshal_gogo.go
new file mode 100644 (file)
index 0000000..997f57c
--- /dev/null
+++ b/vendor/github.com/gogo/protobuf/proto/table_marshal_gogo.go
@@ -0,0 +1,388 @@
+// Protocol Buffers for Go with Gadgets
+//
+// Copyright (c) 2018, The GoGo Authors. All rights reserved.
+// http://github.com/gogo/protobuf
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//     * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//     * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+package proto
+
+import (
+       "reflect"
+       "time"
+)
+
+// makeMessageRefMarshaler differs a bit from makeMessageMarshaler
+// It marshal a message T instead of a *T
+func makeMessageRefMarshaler(u *marshalInfo) (sizer, marshaler) {
+       return func(ptr pointer, tagsize int) int {
+                       siz := u.size(ptr)
+                       return siz + SizeVarint(uint64(siz)) + tagsize
+               },
+               func(b []byte, ptr pointer, wiretag uint64, deterministic bool) ([]byte, error) {
+                       b = appendVarint(b, wiretag)
+                       siz := u.cachedsize(ptr)
+                       b = appendVarint(b, uint64(siz))
+                       return u.marshal(b, ptr, deterministic)
+               }
+}
+
+// makeMessageRefSliceMarshaler differs quite a lot from makeMessageSliceMarshaler
+// It marshals a slice of messages []T instead of []*T
+func makeMessageRefSliceMarshaler(u *marshalInfo) (sizer, marshaler) {
+       return func(ptr pointer, tagsize int) int {
+                       s := ptr.getSlice(u.typ)
+                       n := 0
+                       for i := 0; i < s.Len(); i++ {
+                               elem := s.Index(i)
+                               e := elem.Interface()
+                               v := toAddrPointer(&e, false)
+                               siz := u.size(v)
+                               n += siz + SizeVarint(uint64(siz)) + tagsize
+                       }
+                       return n
+               },
+               func(b []byte, ptr pointer, wiretag uint64, deterministic bool) ([]byte, error) {
+                       s := ptr.getSlice(u.typ)
+                       var err, errreq error
+                       for i := 0; i < s.Len(); i++ {
+                               elem := s.Index(i)
+                               e := elem.Interface()
+                               v := toAddrPointer(&e, false)
+                               b = appendVarint(b, wiretag)
+                               siz := u.size(v)
+                               b = appendVarint(b, uint64(siz))
+                               b, err = u.marshal(b, v, deterministic)
+
+                               if err != nil {
+                                       if _, ok := err.(*RequiredNotSetError); ok {
+                                               // Required field in submessage is not set.
+                                               // We record the error but keep going, to give a complete marshaling.
+                                               if errreq == nil {
+                                                       errreq = err
+                                               }
+                                               continue
+                                       }
+                                       if err == ErrNil {
+                                               err = errRepeatedHasNil
+                                       }
+                                       return b, err
+                               }
+                       }
+
+                       return b, errreq
+               }
+}
+
+func makeCustomPtrMarshaler(u *marshalInfo) (sizer, marshaler) {
+       return func(ptr pointer, tagsize int) int {
+                       if ptr.isNil() {
+                               return 0
+                       }
+                       m := ptr.asPointerTo(reflect.PtrTo(u.typ)).Elem().Interface().(custom)
+                       siz := m.Size()
+                       return tagsize + SizeVarint(uint64(siz)) + siz
+               }, func(b []byte, ptr pointer, wiretag uint64, deterministic bool) ([]byte, error) {
+                       if ptr.isNil() {
+                               return b, nil
+                       }
+                       m := ptr.asPointerTo(reflect.PtrTo(u.typ)).Elem().Interface().(custom)
+                       siz := m.Size()
+                       buf, err := m.Marshal()
+                       if err != nil {
+                               return nil, err
+                       }
+                       b = appendVarint(b, wiretag)
+                       b = appendVarint(b, uint64(siz))
+                       b = append(b, buf...)
+                       return b, nil
+               }
+}
+
+func makeCustomMarshaler(u *marshalInfo) (sizer, marshaler) {
+       return func(ptr pointer, tagsize int) int {
+                       m := ptr.asPointerTo(u.typ).Interface().(custom)
+                       siz := m.Size()
+                       return tagsize + SizeVarint(uint64(siz)) + siz
+               }, func(b []byte, ptr pointer, wiretag uint64, deterministic bool) ([]byte, error) {
+                       m := ptr.asPointerTo(u.typ).Interface().(custom)
+                       siz := m.Size()
+                       buf, err := m.Marshal()
+                       if err != nil {
+                               return nil, err
+                       }
+                       b = appendVarint(b, wiretag)
+                       b = appendVarint(b, uint64(siz))
+                       b = append(b, buf...)
+                       return b, nil
+               }
+}
+
+func makeTimeMarshaler(u *marshalInfo) (sizer, marshaler) {
+       return func(ptr pointer, tagsize int) int {
+                       t := ptr.asPointerTo(u.typ).Interface().(*time.Time)
+                       ts, err := timestampProto(*t)
+                       if err != nil {
+                               return 0
+                       }
+                       siz := Size(ts)
+                       return tagsize + SizeVarint(uint64(siz)) + siz
+               }, func(b []byte, ptr pointer, wiretag uint64, deterministic bool) ([]byte, error) {
+                       t := ptr.asPointerTo(u.typ).Interface().(*time.Time)
+                       ts, err := timestampProto(*t)
+                       if err != nil {
+                               return nil, err
+                       }
+                       buf, err := Marshal(ts)
+                       if err != nil {
+                               return nil, err
+                       }
+                       b = appendVarint(b, wiretag)
+                       b = appendVarint(b, uint64(len(buf)))
+                       b = append(b, buf...)
+                       return b, nil
+               }
+}
+
+func makeTimePtrMarshaler(u *marshalInfo) (sizer, marshaler) {
+       return func(ptr pointer, tagsize int) int {
+                       if ptr.isNil() {
+                               return 0
+                       }
+                       t := ptr.asPointerTo(reflect.PtrTo(u.typ)).Elem().Interface().(*time.Time)
+                       ts, err := timestampProto(*t)
+                       if err != nil {
+                               return 0
+                       }
+                       siz := Size(ts)
+                       return tagsize + SizeVarint(uint64(siz)) + siz
+               }, func(b []byte, ptr pointer, wiretag uint64, deterministic bool) ([]byte, error) {
+                       if ptr.isNil() {
+                               return b, nil
+                       }
+                       t := ptr.asPointerTo(reflect.PtrTo(u.typ)).Elem().Interface().(*time.Time)
+                       ts, err := timestampProto(*t)
+                       if err != nil {
+                               return nil, err
+                       }
+                       buf, err := Marshal(ts)
+                       if err != nil {
+                               return nil, err
+                       }
+                       b = appendVarint(b, wiretag)
+                       b = appendVarint(b, uint64(len(buf)))
+                       b = append(b, buf...)
+                       return b, nil
+               }
+}
+
+func makeTimeSliceMarshaler(u *marshalInfo) (sizer, marshaler) {
+       return func(ptr pointer, tagsize int) int {
+                       s := ptr.getSlice(u.typ)
+                       n := 0
+                       for i := 0; i < s.Len(); i++ {
+                               elem := s.Index(i)
+                               t := elem.Interface().(time.Time)
+                               ts, err := timestampProto(t)
+                               if err != nil {
+                                       return 0
+                               }
+                               siz := Size(ts)
+                               n += siz + SizeVarint(uint64(siz)) + tagsize
+                       }
+                       return n
+               },
+               func(b []byte, ptr pointer, wiretag uint64, deterministic bool) ([]byte, error) {
+                       s := ptr.getSlice(u.typ)
+                       for i := 0; i < s.Len(); i++ {
+                               elem := s.Index(i)
+                               t := elem.Interface().(time.Time)
+                               ts, err := timestampProto(t)
+                               if err != nil {
+                                       return nil, err
+                               }
+                               siz := Size(ts)
+                               buf, err := Marshal(ts)
+                               if err != nil {
+                                       return nil, err
+                               }
+                               b = appendVarint(b, wiretag)
+                               b = appendVarint(b, uint64(siz))
+                               b = append(b, buf...)
+                       }
+
+                       return b, nil
+               }
+}
+
+func makeTimePtrSliceMarshaler(u *marshalInfo) (sizer, marshaler) {
+       return func(ptr pointer, tagsize int) int {
+                       s := ptr.getSlice(reflect.PtrTo(u.typ))
+                       n := 0
+                       for i := 0; i < s.Len(); i++ {
+                               elem := s.Index(i)
+                               t := elem.Interface().(*time.Time)
+                               ts, err := timestampProto(*t)
+                               if err != nil {
+                                       return 0
+                               }
+                               siz := Size(ts)
+                               n += siz + SizeVarint(uint64(siz)) + tagsize
+                       }
+                       return n
+               },
+               func(b []byte, ptr pointer, wiretag uint64, deterministic bool) ([]byte, error) {
+                       s := ptr.getSlice(reflect.PtrTo(u.typ))
+                       for i := 0; i < s.Len(); i++ {
+                               elem := s.Index(i)
+                               t := elem.Interface().(*time.Time)
+                               ts, err := timestampProto(*t)
+                               if err != nil {
+                                       return nil, err
+                               }
+                               siz := Size(ts)
+                               buf, err := Marshal(ts)
+                               if err != nil {
+                                       return nil, err
+                               }
+                               b = appendVarint(b, wiretag)
+                               b = appendVarint(b, uint64(siz))
+                               b = append(b, buf...)
+                       }
+
+                       return b, nil
+               }
+}
+
+func makeDurationMarshaler(u *marshalInfo) (sizer, marshaler) {
+       return func(ptr pointer, tagsize int) int {
+                       d := ptr.asPointerTo(u.typ).Interface().(*time.Duration)
+                       dur := durationProto(*d)
+                       siz := Size(dur)
+                       return tagsize + SizeVarint(uint64(siz)) + siz
+               }, func(b []byte, ptr pointer, wiretag uint64, deterministic bool) ([]byte, error) {
+                       d := ptr.asPointerTo(u.typ).Interface().(*time.Duration)
+                       dur := durationProto(*d)
+                       buf, err := Marshal(dur)
+                       if err != nil {
+                               return nil, err
+                       }
+                       b = appendVarint(b, wiretag)
+                       b = appendVarint(b, uint64(len(buf)))
+                       b = append(b, buf...)
+                       return b, nil
+               }
+}
+
+func makeDurationPtrMarshaler(u *marshalInfo) (sizer, marshaler) {
+       return func(ptr pointer, tagsize int) int {
+                       if ptr.isNil() {
+                               return 0
+                       }
+                       d := ptr.asPointerTo(reflect.PtrTo(u.typ)).Elem().Interface().(*time.Duration)
+                       dur := durationProto(*d)
+                       siz := Size(dur)
+                       return tagsize + SizeVarint(uint64(siz)) + siz
+               }, func(b []byte, ptr pointer, wiretag uint64, deterministic bool) ([]byte, error) {
+                       if ptr.isNil() {
+                               return b, nil
+                       }
+                       d := ptr.asPointerTo(reflect.PtrTo(u.typ)).Elem().Interface().(*time.Duration)
+                       dur := durationProto(*d)
+                       buf, err := Marshal(dur)
+                       if err != nil {
+                               return nil, err
+                       }
+                       b = appendVarint(b, wiretag)
+                       b = appendVarint(b, uint64(len(buf)))
+                       b = append(b, buf...)
+                       return b, nil
+               }
+}
+
+func makeDurationSliceMarshaler(u *marshalInfo) (sizer, marshaler) {
+       return func(ptr pointer, tagsize int) int {
+                       s := ptr.getSlice(u.typ)
+                       n := 0
+                       for i := 0; i < s.Len(); i++ {
+                               elem := s.Index(i)
+                               d := elem.Interface().(time.Duration)
+                               dur := durationProto(d)
+                               siz := Size(dur)
+                               n += siz + SizeVarint(uint64(siz)) + tagsize
+                       }
+                       return n
+               },
+               func(b []byte, ptr pointer, wiretag uint64, deterministic bool) ([]byte, error) {
+                       s := ptr.getSlice(u.typ)
+                       for i := 0; i < s.Len(); i++ {
+                               elem := s.Index(i)
+                               d := elem.Interface().(time.Duration)
+                               dur := durationProto(d)
+                               siz := Size(dur)
+                               buf, err := Marshal(dur)
+                               if err != nil {
+                                       return nil, err
+                               }
+                               b = appendVarint(b, wiretag)
+                               b = appendVarint(b, uint64(siz))
+                               b = append(b, buf...)
+                       }
+
+                       return b, nil
+               }
+}
+
+func makeDurationPtrSliceMarshaler(u *marshalInfo) (sizer, marshaler) {
+       return func(ptr pointer, tagsize int) int {
+                       s := ptr.getSlice(reflect.PtrTo(u.typ))
+                       n := 0
+                       for i := 0; i < s.Len(); i++ {
+                               elem := s.Index(i)
+                               d := elem.Interface().(*time.Duration)
+                               dur := durationProto(*d)
+                               siz := Size(dur)
+                               n += siz + SizeVarint(uint64(siz)) + tagsize
+                       }
+                       return n
+               },
+               func(b []byte, ptr pointer, wiretag uint64, deterministic bool) ([]byte, error) {
+                       s := ptr.getSlice(reflect.PtrTo(u.typ))
+                       for i := 0; i < s.Len(); i++ {
+                               elem := s.Index(i)
+                               d := elem.Interface().(*time.Duration)
+                               dur := durationProto(*d)
+                               siz := Size(dur)
+                               buf, err := Marshal(dur)
+                               if err != nil {
+                                       return nil, err
+                               }
+                               b = appendVarint(b, wiretag)
+                               b = appendVarint(b, uint64(siz))
+                               b = append(b, buf...)
+                       }
+
+                       return b, nil
+               }
+}

diff --git a/vendor/github.com/gogo/protobuf/proto/table_merge.go b/vendor/github.com/gogo/protobuf/proto/table_merge.go
new file mode 100644 (file)
index 0000000..f520106
--- /dev/null
+++ b/vendor/github.com/gogo/protobuf/proto/table_merge.go
@@ -0,0 +1,657 @@
+// Go support for Protocol Buffers - Google's data interchange format
+//
+// Copyright 2016 The Go Authors.  All rights reserved.
+// https://github.com/golang/protobuf
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//     * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//     * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//     * Neither the name of Google Inc. nor the names of its
+// contributors may be used to endorse or promote products derived from
+// this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+package proto
+
+import (
+       "fmt"
+       "reflect"
+       "strings"
+       "sync"
+       "sync/atomic"
+)
+
+// Merge merges the src message into dst.
+// This assumes that dst and src of the same type and are non-nil.
+func (a *InternalMessageInfo) Merge(dst, src Message) {
+       mi := atomicLoadMergeInfo(&a.merge)
+       if mi == nil {
+               mi = getMergeInfo(reflect.TypeOf(dst).Elem())
+               atomicStoreMergeInfo(&a.merge, mi)
+       }
+       mi.merge(toPointer(&dst), toPointer(&src))
+}
+
+type mergeInfo struct {
+       typ reflect.Type
+
+       initialized int32 // 0: only typ is valid, 1: everything is valid
+       lock        sync.Mutex
+
+       fields       []mergeFieldInfo
+       unrecognized field // Offset of XXX_unrecognized
+}
+
+type mergeFieldInfo struct {
+       field field // Offset of field, guaranteed to be valid
+
+       // isPointer reports whether the value in the field is a pointer.
+       // This is true for the following situations:
+       //      * Pointer to struct
+       //      * Pointer to basic type (proto2 only)
+       //      * Slice (first value in slice header is a pointer)
+       //      * String (first value in string header is a pointer)
+       isPointer bool
+
+       // basicWidth reports the width of the field assuming that it is directly
+       // embedded in the struct (as is the case for basic types in proto3).
+       // The possible values are:
+       //      0: invalid
+       //      1: bool
+       //      4: int32, uint32, float32
+       //      8: int64, uint64, float64
+       basicWidth int
+
+       // Where dst and src are pointers to the types being merged.
+       merge func(dst, src pointer)
+}
+
+var (
+       mergeInfoMap  = map[reflect.Type]*mergeInfo{}
+       mergeInfoLock sync.Mutex
+)
+
+func getMergeInfo(t reflect.Type) *mergeInfo {
+       mergeInfoLock.Lock()
+       defer mergeInfoLock.Unlock()
+       mi := mergeInfoMap[t]
+       if mi == nil {
+               mi = &mergeInfo{typ: t}
+               mergeInfoMap[t] = mi
+       }
+       return mi
+}
+
+// merge merges src into dst assuming they are both of type *mi.typ.
+func (mi *mergeInfo) merge(dst, src pointer) {
+       if dst.isNil() {
+               panic("proto: nil destination")
+       }
+       if src.isNil() {
+               return // Nothing to do.
+       }
+
+       if atomic.LoadInt32(&mi.initialized) == 0 {
+               mi.computeMergeInfo()
+       }
+
+       for _, fi := range mi.fields {
+               sfp := src.offset(fi.field)
+
+               // As an optimization, we can avoid the merge function call cost
+               // if we know for sure that the source will have no effect
+               // by checking if it is the zero value.
+               if unsafeAllowed {
+                       if fi.isPointer && sfp.getPointer().isNil() { // Could be slice or string
+                               continue
+                       }
+                       if fi.basicWidth > 0 {
+                               switch {
+                               case fi.basicWidth == 1 && !*sfp.toBool():
+                                       continue
+                               case fi.basicWidth == 4 && *sfp.toUint32() == 0:
+                                       continue
+                               case fi.basicWidth == 8 && *sfp.toUint64() == 0:
+                                       continue
+                               }
+                       }
+               }
+
+               dfp := dst.offset(fi.field)
+               fi.merge(dfp, sfp)
+       }
+
+       // TODO: Make this faster?
+       out := dst.asPointerTo(mi.typ).Elem()
+       in := src.asPointerTo(mi.typ).Elem()
+       if emIn, err := extendable(in.Addr().Interface()); err == nil {
+               emOut, _ := extendable(out.Addr().Interface())
+               mIn, muIn := emIn.extensionsRead()
+               if mIn != nil {
+                       mOut := emOut.extensionsWrite()
+                       muIn.Lock()
+                       mergeExtension(mOut, mIn)
+                       muIn.Unlock()
+               }
+       }
+
+       if mi.unrecognized.IsValid() {
+               if b := *src.offset(mi.unrecognized).toBytes(); len(b) > 0 {
+                       *dst.offset(mi.unrecognized).toBytes() = append([]byte(nil), b...)
+               }
+       }
+}
+
+func (mi *mergeInfo) computeMergeInfo() {
+       mi.lock.Lock()
+       defer mi.lock.Unlock()
+       if mi.initialized != 0 {
+               return
+       }
+       t := mi.typ
+       n := t.NumField()
+
+       props := GetProperties(t)
+       for i := 0; i < n; i++ {
+               f := t.Field(i)
+               if strings.HasPrefix(f.Name, "XXX_") {
+                       continue
+               }
+
+               mfi := mergeFieldInfo{field: toField(&f)}
+               tf := f.Type
+
+               // As an optimization, we can avoid the merge function call cost
+               // if we know for sure that the source will have no effect
+               // by checking if it is the zero value.
+               if unsafeAllowed {
+                       switch tf.Kind() {
+                       case reflect.Ptr, reflect.Slice, reflect.String:
+                               // As a special case, we assume slices and strings are pointers
+                               // since we know that the first field in the SliceSlice or
+                               // StringHeader is a data pointer.
+                               mfi.isPointer = true
+                       case reflect.Bool:
+                               mfi.basicWidth = 1
+                       case reflect.Int32, reflect.Uint32, reflect.Float32:
+                               mfi.basicWidth = 4
+                       case reflect.Int64, reflect.Uint64, reflect.Float64:
+                               mfi.basicWidth = 8
+                       }
+               }
+
+               // Unwrap tf to get at its most basic type.
+               var isPointer, isSlice bool
+               if tf.Kind() == reflect.Slice && tf.Elem().Kind() != reflect.Uint8 {
+                       isSlice = true
+                       tf = tf.Elem()
+               }
+               if tf.Kind() == reflect.Ptr {
+                       isPointer = true
+                       tf = tf.Elem()
+               }
+               if isPointer && isSlice && tf.Kind() != reflect.Struct {
+                       panic("both pointer and slice for basic type in " + tf.Name())
+               }
+
+               switch tf.Kind() {
+               case reflect.Int32:
+                       switch {
+                       case isSlice: // E.g., []int32
+                               mfi.merge = func(dst, src pointer) {
+                                       // NOTE: toInt32Slice is not defined (see pointer_reflect.go).
+                                       /*
+                                               sfsp := src.toInt32Slice()
+                                               if *sfsp != nil {
+                                                       dfsp := dst.toInt32Slice()
+                                                       *dfsp = append(*dfsp, *sfsp...)
+                                                       if *dfsp == nil {
+                                                               *dfsp = []int64{}
+                                                       }
+                                               }
+                                       */
+                                       sfs := src.getInt32Slice()
+                                       if sfs != nil {
+                                               dfs := dst.getInt32Slice()
+                                               dfs = append(dfs, sfs...)
+                                               if dfs == nil {
+                                                       dfs = []int32{}
+                                               }
+                                               dst.setInt32Slice(dfs)
+                                       }
+                               }
+                       case isPointer: // E.g., *int32
+                               mfi.merge = func(dst, src pointer) {
+                                       // NOTE: toInt32Ptr is not defined (see pointer_reflect.go).
+                                       /*
+                                               sfpp := src.toInt32Ptr()
+                                               if *sfpp != nil {
+                                                       dfpp := dst.toInt32Ptr()
+                                                       if *dfpp == nil {
+                                                               *dfpp = Int32(**sfpp)
+                                                       } else {
+                                                               **dfpp = **sfpp
+                                                       }
+                                               }
+                                       */
+                                       sfp := src.getInt32Ptr()
+                                       if sfp != nil {
+                                               dfp := dst.getInt32Ptr()
+                                               if dfp == nil {
+                                                       dst.setInt32Ptr(*sfp)
+                                               } else {
+                                                       *dfp = *sfp
+                                               }
+                                       }
+                               }
+                       default: // E.g., int32
+                               mfi.merge = func(dst, src pointer) {
+                                       if v := *src.toInt32(); v != 0 {
+                                               *dst.toInt32() = v
+                                       }
+                               }
+                       }
+               case reflect.Int64:
+                       switch {
+                       case isSlice: // E.g., []int64
+                               mfi.merge = func(dst, src pointer) {
+                                       sfsp := src.toInt64Slice()
+                                       if *sfsp != nil {
+                                               dfsp := dst.toInt64Slice()
+                                               *dfsp = append(*dfsp, *sfsp...)
+                                               if *dfsp == nil {
+                                                       *dfsp = []int64{}
+                                               }
+                                       }
+                               }
+                       case isPointer: // E.g., *int64
+                               mfi.merge = func(dst, src pointer) {
+                                       sfpp := src.toInt64Ptr()
+                                       if *sfpp != nil {
+                                               dfpp := dst.toInt64Ptr()
+                                               if *dfpp == nil {
+                                                       *dfpp = Int64(**sfpp)
+                                               } else {
+                                                       **dfpp = **sfpp
+                                               }
+                                       }
+                               }
+                       default: // E.g., int64
+                               mfi.merge = func(dst, src pointer) {
+                                       if v := *src.toInt64(); v != 0 {
+                                               *dst.toInt64() = v
+                                       }
+                               }
+                       }
+               case reflect.Uint32:
+                       switch {
+                       case isSlice: // E.g., []uint32
+                               mfi.merge = func(dst, src pointer) {
+                                       sfsp := src.toUint32Slice()
+                                       if *sfsp != nil {
+                                               dfsp := dst.toUint32Slice()
+                                               *dfsp = append(*dfsp, *sfsp...)
+                                               if *dfsp == nil {
+                                                       *dfsp = []uint32{}
+                                               }
+                                       }
+                               }
+                       case isPointer: // E.g., *uint32
+                               mfi.merge = func(dst, src pointer) {
+                                       sfpp := src.toUint32Ptr()
+                                       if *sfpp != nil {
+                                               dfpp := dst.toUint32Ptr()
+                                               if *dfpp == nil {
+                                                       *dfpp = Uint32(**sfpp)
+                                               } else {
+                                                       **dfpp = **sfpp
+                                               }
+                                       }
+                               }
+                       default: // E.g., uint32
+                               mfi.merge = func(dst, src pointer) {
+                                       if v := *src.toUint32(); v != 0 {
+                                               *dst.toUint32() = v
+                                       }
+                               }
+                       }
+               case reflect.Uint64:
+                       switch {
+                       case isSlice: // E.g., []uint64
+                               mfi.merge = func(dst, src pointer) {
+                                       sfsp := src.toUint64Slice()
+                                       if *sfsp != nil {
+                                               dfsp := dst.toUint64Slice()
+                                               *dfsp = append(*dfsp, *sfsp...)
+                                               if *dfsp == nil {
+                                                       *dfsp = []uint64{}
+                                               }
+                                       }
+                               }
+                       case isPointer: // E.g., *uint64
+                               mfi.merge = func(dst, src pointer) {
+                                       sfpp := src.toUint64Ptr()
+                                       if *sfpp != nil {
+                                               dfpp := dst.toUint64Ptr()
+                                               if *dfpp == nil {
+                                                       *dfpp = Uint64(**sfpp)
+                                               } else {
+                                                       **dfpp = **sfpp
+                                               }
+                                       }
+                               }
+                       default: // E.g., uint64
+                               mfi.merge = func(dst, src pointer) {
+                                       if v := *src.toUint64(); v != 0 {
+                                               *dst.toUint64() = v
+                                       }
+                               }
+                       }
+               case reflect.Float32:
+                       switch {
+                       case isSlice: // E.g., []float32
+                               mfi.merge = func(dst, src pointer) {
+                                       sfsp := src.toFloat32Slice()
+                                       if *sfsp != nil {
+                                               dfsp := dst.toFloat32Slice()
+                                               *dfsp = append(*dfsp, *sfsp...)
+                                               if *dfsp == nil {
+                                                       *dfsp = []float32{}
+                                               }
+                                       }
+                               }
+                       case isPointer: // E.g., *float32
+                               mfi.merge = func(dst, src pointer) {
+                                       sfpp := src.toFloat32Ptr()
+                                       if *sfpp != nil {
+                                               dfpp := dst.toFloat32Ptr()
+                                               if *dfpp == nil {
+                                                       *dfpp = Float32(**sfpp)
+                                               } else {
+                                                       **dfpp = **sfpp
+                                               }
+                                       }
+                               }
+                       default: // E.g., float32
+                               mfi.merge = func(dst, src pointer) {
+                                       if v := *src.toFloat32(); v != 0 {
+                                               *dst.toFloat32() = v
+                                       }
+                               }
+                       }
+               case reflect.Float64:
+                       switch {
+                       case isSlice: // E.g., []float64
+                               mfi.merge = func(dst, src pointer) {
+                                       sfsp := src.toFloat64Slice()
+                                       if *sfsp != nil {
+                                               dfsp := dst.toFloat64Slice()
+                                               *dfsp = append(*dfsp, *sfsp...)
+                                               if *dfsp == nil {
+                                                       *dfsp = []float64{}
+                                               }
+                                       }
+                               }
+                       case isPointer: // E.g., *float64
+                               mfi.merge = func(dst, src pointer) {
+                                       sfpp := src.toFloat64Ptr()
+                                       if *sfpp != nil {
+                                               dfpp := dst.toFloat64Ptr()
+                                               if *dfpp == nil {
+                                                       *dfpp = Float64(**sfpp)
+                                               } else {
+                                                       **dfpp = **sfpp
+                                               }
+                                       }
+                               }
+                       default: // E.g., float64
+                               mfi.merge = func(dst, src pointer) {
+                                       if v := *src.toFloat64(); v != 0 {
+                                               *dst.toFloat64() = v
+                                       }
+                               }
+                       }
+               case reflect.Bool:
+                       switch {
+                       case isSlice: // E.g., []bool
+                               mfi.merge = func(dst, src pointer) {
+                                       sfsp := src.toBoolSlice()
+                                       if *sfsp != nil {
+                                               dfsp := dst.toBoolSlice()
+                                               *dfsp = append(*dfsp, *sfsp...)
+                                               if *dfsp == nil {
+                                                       *dfsp = []bool{}
+                                               }
+                                       }
+                               }
+                       case isPointer: // E.g., *bool
+                               mfi.merge = func(dst, src pointer) {
+                                       sfpp := src.toBoolPtr()
+                                       if *sfpp != nil {
+                                               dfpp := dst.toBoolPtr()
+                                               if *dfpp == nil {
+                                                       *dfpp = Bool(**sfpp)
+                                               } else {
+                                                       **dfpp = **sfpp
+                                               }
+                                       }
+                               }
+                       default: // E.g., bool
+                               mfi.merge = func(dst, src pointer) {
+                                       if v := *src.toBool(); v {
+                                               *dst.toBool() = v
+                                       }
+                               }
+                       }
+               case reflect.String:
+                       switch {
+                       case isSlice: // E.g., []string
+                               mfi.merge = func(dst, src pointer) {
+                                       sfsp := src.toStringSlice()
+                                       if *sfsp != nil {
+                                               dfsp := dst.toStringSlice()
+                                               *dfsp = append(*dfsp, *sfsp...)
+                                               if *dfsp == nil {
+                                                       *dfsp = []string{}
+                                               }
+                                       }
+                               }
+                       case isPointer: // E.g., *string
+                               mfi.merge = func(dst, src pointer) {
+                                       sfpp := src.toStringPtr()
+                                       if *sfpp != nil {
+                                               dfpp := dst.toStringPtr()
+                                               if *dfpp == nil {
+                                                       *dfpp = String(**sfpp)
+                                               } else {
+                                                       **dfpp = **sfpp
+                                               }
+                                       }
+                               }
+                       default: // E.g., string
+                               mfi.merge = func(dst, src pointer) {
+                                       if v := *src.toString(); v != "" {
+                                               *dst.toString() = v
+                                       }
+                               }
+                       }
+               case reflect.Slice:
+                       isProto3 := props.Prop[i].proto3
+                       switch {
+                       case isPointer:
+                               panic("bad pointer in byte slice case in " + tf.Name())
+                       case tf.Elem().Kind() != reflect.Uint8:
+                               panic("bad element kind in byte slice case in " + tf.Name())
+                       case isSlice: // E.g., [][]byte
+                               mfi.merge = func(dst, src pointer) {
+                                       sbsp := src.toBytesSlice()
+                                       if *sbsp != nil {
+                                               dbsp := dst.toBytesSlice()
+                                               for _, sb := range *sbsp {
+                                                       if sb == nil {
+                                                               *dbsp = append(*dbsp, nil)
+                                                       } else {
+                                                               *dbsp = append(*dbsp, append([]byte{}, sb...))
+                                                       }
+                                               }
+                                               if *dbsp == nil {
+                                                       *dbsp = [][]byte{}
+                                               }
+                                       }
+                               }
+                       default: // E.g., []byte
+                               mfi.merge = func(dst, src pointer) {
+                                       sbp := src.toBytes()
+                                       if *sbp != nil {
+                                               dbp := dst.toBytes()
+                                               if !isProto3 || len(*sbp) > 0 {
+                                                       *dbp = append([]byte{}, *sbp...)
+                                               }
+                                       }
+                               }
+                       }
+               case reflect.Struct:
+                       switch {
+                       case !isPointer:
+                               mergeInfo := getMergeInfo(tf)
+                               mfi.merge = func(dst, src pointer) {
+                                       mergeInfo.merge(dst, src)
+                               }
+                       case isSlice: // E.g., []*pb.T
+                               mergeInfo := getMergeInfo(tf)
+                               mfi.merge = func(dst, src pointer) {
+                                       sps := src.getPointerSlice()
+                                       if sps != nil {
+                                               dps := dst.getPointerSlice()
+                                               for _, sp := range sps {
+                                                       var dp pointer
+                                                       if !sp.isNil() {
+                                                               dp = valToPointer(reflect.New(tf))
+                                                               mergeInfo.merge(dp, sp)
+                                                       }
+                                                       dps = append(dps, dp)
+                                               }
+                                               if dps == nil {
+                                                       dps = []pointer{}
+                                               }
+                                               dst.setPointerSlice(dps)
+                                       }
+                               }
+                       default: // E.g., *pb.T
+                               mergeInfo := getMergeInfo(tf)
+                               mfi.merge = func(dst, src pointer) {
+                                       sp := src.getPointer()
+                                       if !sp.isNil() {
+                                               dp := dst.getPointer()
+                                               if dp.isNil() {
+                                                       dp = valToPointer(reflect.New(tf))
+                                                       dst.setPointer(dp)
+                                               }
+                                               mergeInfo.merge(dp, sp)
+                                       }
+                               }
+                       }
+               case reflect.Map:
+                       switch {
+                       case isPointer || isSlice:
+                               panic("bad pointer or slice in map case in " + tf.Name())
+                       default: // E.g., map[K]V
+                               mfi.merge = func(dst, src pointer) {
+                                       sm := src.asPointerTo(tf).Elem()
+                                       if sm.Len() == 0 {
+                                               return
+                                       }
+                                       dm := dst.asPointerTo(tf).Elem()
+                                       if dm.IsNil() {
+                                               dm.Set(reflect.MakeMap(tf))
+                                       }
+
+                                       switch tf.Elem().Kind() {
+                                       case reflect.Ptr: // Proto struct (e.g., *T)
+                                               for _, key := range sm.MapKeys() {
+                                                       val := sm.MapIndex(key)
+                                                       val = reflect.ValueOf(Clone(val.Interface().(Message)))
+                                                       dm.SetMapIndex(key, val)
+                                               }
+                                       case reflect.Slice: // E.g. Bytes type (e.g., []byte)
+                                               for _, key := range sm.MapKeys() {
+                                                       val := sm.MapIndex(key)
+                                                       val = reflect.ValueOf(append([]byte{}, val.Bytes()...))
+                                                       dm.SetMapIndex(key, val)
+                                               }
+                                       default: // Basic type (e.g., string)
+                                               for _, key := range sm.MapKeys() {
+                                                       val := sm.MapIndex(key)
+                                                       dm.SetMapIndex(key, val)
+                                               }
+                                       }
+                               }
+                       }
+               case reflect.Interface:
+                       // Must be oneof field.
+                       switch {
+                       case isPointer || isSlice:
+                               panic("bad pointer or slice in interface case in " + tf.Name())
+                       default: // E.g., interface{}
+                               // TODO: Make this faster?
+                               mfi.merge = func(dst, src pointer) {
+                                       su := src.asPointerTo(tf).Elem()
+                                       if !su.IsNil() {
+                                               du := dst.asPointerTo(tf).Elem()
+                                               typ := su.Elem().Type()
+                                               if du.IsNil() || du.Elem().Type() != typ {
+                                                       du.Set(reflect.New(typ.Elem())) // Initialize interface if empty
+                                               }
+                                               sv := su.Elem().Elem().Field(0)
+                                               if sv.Kind() == reflect.Ptr && sv.IsNil() {
+                                                       return
+                                               }
+                                               dv := du.Elem().Elem().Field(0)
+                                               if dv.Kind() == reflect.Ptr && dv.IsNil() {
+                                                       dv.Set(reflect.New(sv.Type().Elem())) // Initialize proto message if empty
+                                               }
+                                               switch sv.Type().Kind() {
+                                               case reflect.Ptr: // Proto struct (e.g., *T)
+                                                       Merge(dv.Interface().(Message), sv.Interface().(Message))
+                                               case reflect.Slice: // E.g. Bytes type (e.g., []byte)
+                                                       dv.Set(reflect.ValueOf(append([]byte{}, sv.Bytes()...)))
+                                               default: // Basic type (e.g., string)
+                                                       dv.Set(sv)
+                                               }
+                                       }
+                               }
+                       }
+               default:
+                       panic(fmt.Sprintf("merger not found for type:%s", tf))
+               }
+               mi.fields = append(mi.fields, mfi)
+       }
+
+       mi.unrecognized = invalidField
+       if f, ok := t.FieldByName("XXX_unrecognized"); ok {
+               if f.Type != reflect.TypeOf([]byte{}) {
+                       panic("expected XXX_unrecognized to be of type []byte")
+               }
+               mi.unrecognized = toField(&f)
+       }
+
+       atomic.StoreInt32(&mi.initialized, 1)
+}

diff --git a/vendor/github.com/gogo/protobuf/proto/table_unmarshal.go b/vendor/github.com/gogo/protobuf/proto/table_unmarshal.go
new file mode 100644 (file)
index 0000000..bb2622f
--- /dev/null
+++ b/vendor/github.com/gogo/protobuf/proto/table_unmarshal.go
@@ -0,0 +1,2245 @@
+// Go support for Protocol Buffers - Google's data interchange format
+//
+// Copyright 2016 The Go Authors.  All rights reserved.
+// https://github.com/golang/protobuf
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//     * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//     * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//     * Neither the name of Google Inc. nor the names of its
+// contributors may be used to endorse or promote products derived from
+// this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+package proto
+
+import (
+       "errors"
+       "fmt"
+       "io"
+       "math"
+       "reflect"
+       "strconv"
+       "strings"
+       "sync"
+       "sync/atomic"
+       "unicode/utf8"
+)
+
+// Unmarshal is the entry point from the generated .pb.go files.
+// This function is not intended to be used by non-generated code.
+// This function is not subject to any compatibility guarantee.
+// msg contains a pointer to a protocol buffer struct.
+// b is the data to be unmarshaled into the protocol buffer.
+// a is a pointer to a place to store cached unmarshal information.
+func (a *InternalMessageInfo) Unmarshal(msg Message, b []byte) error {
+       // Load the unmarshal information for this message type.
+       // The atomic load ensures memory consistency.
+       u := atomicLoadUnmarshalInfo(&a.unmarshal)
+       if u == nil {
+               // Slow path: find unmarshal info for msg, update a with it.
+               u = getUnmarshalInfo(reflect.TypeOf(msg).Elem())
+               atomicStoreUnmarshalInfo(&a.unmarshal, u)
+       }
+       // Then do the unmarshaling.
+       err := u.unmarshal(toPointer(&msg), b)
+       return err
+}
+
+type unmarshalInfo struct {
+       typ reflect.Type // type of the protobuf struct
+
+       // 0 = only typ field is initialized
+       // 1 = completely initialized
+       initialized     int32
+       lock            sync.Mutex                    // prevents double initialization
+       dense           []unmarshalFieldInfo          // fields indexed by tag #
+       sparse          map[uint64]unmarshalFieldInfo // fields indexed by tag #
+       reqFields       []string                      // names of required fields
+       reqMask         uint64                        // 1<<len(reqFields)-1
+       unrecognized    field                         // offset of []byte to put unrecognized data (or invalidField if we should throw it away)
+       extensions      field                         // offset of extensions field (of type proto.XXX_InternalExtensions), or invalidField if it does not exist
+       oldExtensions   field                         // offset of old-form extensions field (of type map[int]Extension)
+       extensionRanges []ExtensionRange              // if non-nil, implies extensions field is valid
+       isMessageSet    bool                          // if true, implies extensions field is valid
+
+       bytesExtensions field // offset of XXX_extensions with type []byte
+}
+
+// An unmarshaler takes a stream of bytes and a pointer to a field of a message.
+// It decodes the field, stores it at f, and returns the unused bytes.
+// w is the wire encoding.
+// b is the data after the tag and wire encoding have been read.
+type unmarshaler func(b []byte, f pointer, w int) ([]byte, error)
+
+type unmarshalFieldInfo struct {
+       // location of the field in the proto message structure.
+       field field
+
+       // function to unmarshal the data for the field.
+       unmarshal unmarshaler
+
+       // if a required field, contains a single set bit at this field's index in the required field list.
+       reqMask uint64
+
+       name string // name of the field, for error reporting
+}
+
+var (
+       unmarshalInfoMap  = map[reflect.Type]*unmarshalInfo{}
+       unmarshalInfoLock sync.Mutex
+)
+
+// getUnmarshalInfo returns the data structure which can be
+// subsequently used to unmarshal a message of the given type.
+// t is the type of the message (note: not pointer to message).
+func getUnmarshalInfo(t reflect.Type) *unmarshalInfo {
+       // It would be correct to return a new unmarshalInfo
+       // unconditionally. We would end up allocating one
+       // per occurrence of that type as a message or submessage.
+       // We use a cache here just to reduce memory usage.
+       unmarshalInfoLock.Lock()
+       defer unmarshalInfoLock.Unlock()
+       u := unmarshalInfoMap[t]
+       if u == nil {
+               u = &unmarshalInfo{typ: t}
+               // Note: we just set the type here. The rest of the fields
+               // will be initialized on first use.
+               unmarshalInfoMap[t] = u
+       }
+       return u
+}
+
+// unmarshal does the main work of unmarshaling a message.
+// u provides type information used to unmarshal the message.
+// m is a pointer to a protocol buffer message.
+// b is a byte stream to unmarshal into m.
+// This is top routine used when recursively unmarshaling submessages.
+func (u *unmarshalInfo) unmarshal(m pointer, b []byte) error {
+       if atomic.LoadInt32(&u.initialized) == 0 {
+               u.computeUnmarshalInfo()
+       }
+       if u.isMessageSet {
+               return unmarshalMessageSet(b, m.offset(u.extensions).toExtensions())
+       }
+       var reqMask uint64 // bitmask of required fields we've seen.
+       var errLater error
+       for len(b) > 0 {
+               // Read tag and wire type.
+               // Special case 1 and 2 byte varints.
+               var x uint64
+               if b[0] < 128 {
+                       x = uint64(b[0])
+                       b = b[1:]
+               } else if len(b) >= 2 && b[1] < 128 {
+                       x = uint64(b[0]&0x7f) + uint64(b[1])<<7
+                       b = b[2:]
+               } else {
+                       var n int
+                       x, n = decodeVarint(b)
+                       if n == 0 {
+                               return io.ErrUnexpectedEOF
+                       }
+                       b = b[n:]
+               }
+               tag := x >> 3
+               wire := int(x) & 7
+
+               // Dispatch on the tag to one of the unmarshal* functions below.
+               var f unmarshalFieldInfo
+               if tag < uint64(len(u.dense)) {
+                       f = u.dense[tag]
+               } else {
+                       f = u.sparse[tag]
+               }
+               if fn := f.unmarshal; fn != nil {
+                       var err error
+                       b, err = fn(b, m.offset(f.field), wire)
+                       if err == nil {
+                               reqMask |= f.reqMask
+                               continue
+                       }
+                       if r, ok := err.(*RequiredNotSetError); ok {
+                               // Remember this error, but keep parsing. We need to produce
+                               // a full parse even if a required field is missing.
+                               if errLater == nil {
+                                       errLater = r
+                               }
+                               reqMask |= f.reqMask
+                               continue
+                       }
+                       if err != errInternalBadWireType {
+                               if err == errInvalidUTF8 {
+                                       if errLater == nil {
+                                               fullName := revProtoTypes[reflect.PtrTo(u.typ)] + "." + f.name
+                                               errLater = &invalidUTF8Error{fullName}
+                                       }
+                                       continue
+                               }
+                               return err
+                       }
+                       // Fragments with bad wire type are treated as unknown fields.
+               }
+
+               // Unknown tag.
+               if !u.unrecognized.IsValid() {
+                       // Don't keep unrecognized data; just skip it.
+                       var err error
+                       b, err = skipField(b, wire)
+                       if err != nil {
+                               return err
+                       }
+                       continue
+               }
+               // Keep unrecognized data around.
+               // maybe in extensions, maybe in the unrecognized field.
+               z := m.offset(u.unrecognized).toBytes()
+               var emap map[int32]Extension
+               var e Extension
+               for _, r := range u.extensionRanges {
+                       if uint64(r.Start) <= tag && tag <= uint64(r.End) {
+                               if u.extensions.IsValid() {
+                                       mp := m.offset(u.extensions).toExtensions()
+                                       emap = mp.extensionsWrite()
+                                       e = emap[int32(tag)]
+                                       z = &e.enc
+                                       break
+                               }
+                               if u.oldExtensions.IsValid() {
+                                       p := m.offset(u.oldExtensions).toOldExtensions()
+                                       emap = *p
+                                       if emap == nil {
+                                               emap = map[int32]Extension{}
+                                               *p = emap
+                                       }
+                                       e = emap[int32(tag)]
+                                       z = &e.enc
+                                       break
+                               }
+                               if u.bytesExtensions.IsValid() {
+                                       z = m.offset(u.bytesExtensions).toBytes()
+                                       break
+                               }
+                               panic("no extensions field available")
+                       }
+               }
+               // Use wire type to skip data.
+               var err error
+               b0 := b
+               b, err = skipField(b, wire)
+               if err != nil {
+                       return err
+               }
+               *z = encodeVarint(*z, tag<<3|uint64(wire))
+               *z = append(*z, b0[:len(b0)-len(b)]...)
+
+               if emap != nil {
+                       emap[int32(tag)] = e
+               }
+       }
+       if reqMask != u.reqMask && errLater == nil {
+               // A required field of this message is missing.
+               for _, n := range u.reqFields {
+                       if reqMask&1 == 0 {
+                               errLater = &RequiredNotSetError{n}
+                       }
+                       reqMask >>= 1
+               }
+       }
+       return errLater
+}
+
+// computeUnmarshalInfo fills in u with information for use
+// in unmarshaling protocol buffers of type u.typ.
+func (u *unmarshalInfo) computeUnmarshalInfo() {
+       u.lock.Lock()
+       defer u.lock.Unlock()
+       if u.initialized != 0 {
+               return
+       }
+       t := u.typ
+       n := t.NumField()
+
+       // Set up the "not found" value for the unrecognized byte buffer.
+       // This is the default for proto3.
+       u.unrecognized = invalidField
+       u.extensions = invalidField
+       u.oldExtensions = invalidField
+       u.bytesExtensions = invalidField
+
+       // List of the generated type and offset for each oneof field.
+       type oneofField struct {
+               ityp  reflect.Type // interface type of oneof field
+               field field        // offset in containing message
+       }
+       var oneofFields []oneofField
+
+       for i := 0; i < n; i++ {
+               f := t.Field(i)
+               if f.Name == "XXX_unrecognized" {
+                       // The byte slice used to hold unrecognized input is special.
+                       if f.Type != reflect.TypeOf(([]byte)(nil)) {
+                               panic("bad type for XXX_unrecognized field: " + f.Type.Name())
+                       }
+                       u.unrecognized = toField(&f)
+                       continue
+               }
+               if f.Name == "XXX_InternalExtensions" {
+                       // Ditto here.
+                       if f.Type != reflect.TypeOf(XXX_InternalExtensions{}) {
+                               panic("bad type for XXX_InternalExtensions field: " + f.Type.Name())
+                       }
+                       u.extensions = toField(&f)
+                       if f.Tag.Get("protobuf_messageset") == "1" {
+                               u.isMessageSet = true
+                       }
+                       continue
+               }
+               if f.Name == "XXX_extensions" {
+                       // An older form of the extensions field.
+                       if f.Type == reflect.TypeOf((map[int32]Extension)(nil)) {
+                               u.oldExtensions = toField(&f)
+                               continue
+                       } else if f.Type == reflect.TypeOf(([]byte)(nil)) {
+                               u.bytesExtensions = toField(&f)
+                               continue
+                       }
+                       panic("bad type for XXX_extensions field: " + f.Type.Name())
+               }
+               if f.Name == "XXX_NoUnkeyedLiteral" || f.Name == "XXX_sizecache" {
+                       continue
+               }
+
+               oneof := f.Tag.Get("protobuf_oneof")
+               if oneof != "" {
+                       oneofFields = append(oneofFields, oneofField{f.Type, toField(&f)})
+                       // The rest of oneof processing happens below.
+                       continue
+               }
+
+               tags := f.Tag.Get("protobuf")
+               tagArray := strings.Split(tags, ",")
+               if len(tagArray) < 2 {
+                       panic("protobuf tag not enough fields in " + t.Name() + "." + f.Name + ": " + tags)
+               }
+               tag, err := strconv.Atoi(tagArray[1])
+               if err != nil {
+                       panic("protobuf tag field not an integer: " + tagArray[1])
+               }
+
+               name := ""
+               for _, tag := range tagArray[3:] {
+                       if strings.HasPrefix(tag, "name=") {
+                               name = tag[5:]
+                       }
+               }
+
+               // Extract unmarshaling function from the field (its type and tags).
+               unmarshal := fieldUnmarshaler(&f)
+
+               // Required field?
+               var reqMask uint64
+               if tagArray[2] == "req" {
+                       bit := len(u.reqFields)
+                       u.reqFields = append(u.reqFields, name)
+                       reqMask = uint64(1) << uint(bit)
+                       // TODO: if we have more than 64 required fields, we end up
+                       // not verifying that all required fields are present.
+                       // Fix this, perhaps using a count of required fields?
+               }
+
+               // Store the info in the correct slot in the message.
+               u.setTag(tag, toField(&f), unmarshal, reqMask, name)
+       }
+
+       // Find any types associated with oneof fields.
+       // TODO: XXX_OneofFuncs returns more info than we need.  Get rid of some of it?
+       fn := reflect.Zero(reflect.PtrTo(t)).MethodByName("XXX_OneofFuncs")
+       // gogo: len(oneofFields) > 0 is needed for embedded oneof messages, without a marshaler and unmarshaler
+       if fn.IsValid() && len(oneofFields) > 0 {
+               res := fn.Call(nil)[3] // last return value from XXX_OneofFuncs: []interface{}
+               for i := res.Len() - 1; i >= 0; i-- {
+                       v := res.Index(i)                             // interface{}
+                       tptr := reflect.ValueOf(v.Interface()).Type() // *Msg_X
+                       typ := tptr.Elem()                            // Msg_X
+
+                       f := typ.Field(0) // oneof implementers have one field
+                       baseUnmarshal := fieldUnmarshaler(&f)
+                       tags := strings.Split(f.Tag.Get("protobuf"), ",")
+                       fieldNum, err := strconv.Atoi(tags[1])
+                       if err != nil {
+                               panic("protobuf tag field not an integer: " + tags[1])
+                       }
+                       var name string
+                       for _, tag := range tags {
+                               if strings.HasPrefix(tag, "name=") {
+                                       name = strings.TrimPrefix(tag, "name=")
+                                       break
+                               }
+                       }
+
+                       // Find the oneof field that this struct implements.
+                       // Might take O(n^2) to process all of the oneofs, but who cares.
+                       for _, of := range oneofFields {
+                               if tptr.Implements(of.ityp) {
+                                       // We have found the corresponding interface for this struct.
+                                       // That lets us know where this struct should be stored
+                                       // when we encounter it during unmarshaling.
+                                       unmarshal := makeUnmarshalOneof(typ, of.ityp, baseUnmarshal)
+                                       u.setTag(fieldNum, of.field, unmarshal, 0, name)
+                               }
+                       }
+               }
+       }
+
+       // Get extension ranges, if any.
+       fn = reflect.Zero(reflect.PtrTo(t)).MethodByName("ExtensionRangeArray")
+       if fn.IsValid() {
+               if !u.extensions.IsValid() && !u.oldExtensions.IsValid() && !u.bytesExtensions.IsValid() {
+                       panic("a message with extensions, but no extensions field in " + t.Name())
+               }
+               u.extensionRanges = fn.Call(nil)[0].Interface().([]ExtensionRange)
+       }
+
+       // Explicitly disallow tag 0. This will ensure we flag an error
+       // when decoding a buffer of all zeros. Without this code, we
+       // would decode and skip an all-zero buffer of even length.
+       // [0 0] is [tag=0/wiretype=varint varint-encoded-0].
+       u.setTag(0, zeroField, func(b []byte, f pointer, w int) ([]byte, error) {
+               return nil, fmt.Errorf("proto: %s: illegal tag 0 (wire type %d)", t, w)
+       }, 0, "")
+
+       // Set mask for required field check.
+       u.reqMask = uint64(1)<<uint(len(u.reqFields)) - 1
+
+       atomic.StoreInt32(&u.initialized, 1)
+}
+
+// setTag stores the unmarshal information for the given tag.
+// tag = tag # for field
+// field/unmarshal = unmarshal info for that field.
+// reqMask = if required, bitmask for field position in required field list. 0 otherwise.
+// name = short name of the field.
+func (u *unmarshalInfo) setTag(tag int, field field, unmarshal unmarshaler, reqMask uint64, name string) {
+       i := unmarshalFieldInfo{field: field, unmarshal: unmarshal, reqMask: reqMask, name: name}
+       n := u.typ.NumField()
+       if tag >= 0 && (tag < 16 || tag < 2*n) { // TODO: what are the right numbers here?
+               for len(u.dense) <= tag {
+                       u.dense = append(u.dense, unmarshalFieldInfo{})
+               }
+               u.dense[tag] = i
+               return
+       }
+       if u.sparse == nil {
+               u.sparse = map[uint64]unmarshalFieldInfo{}
+       }
+       u.sparse[uint64(tag)] = i
+}
+
+// fieldUnmarshaler returns an unmarshaler for the given field.
+func fieldUnmarshaler(f *reflect.StructField) unmarshaler {
+       if f.Type.Kind() == reflect.Map {
+               return makeUnmarshalMap(f)
+       }
+       return typeUnmarshaler(f.Type, f.Tag.Get("protobuf"))
+}
+
+// typeUnmarshaler returns an unmarshaler for the given field type / field tag pair.
+func typeUnmarshaler(t reflect.Type, tags string) unmarshaler {
+       tagArray := strings.Split(tags, ",")
+       encoding := tagArray[0]
+       name := "unknown"
+       ctype := false
+       isTime := false
+       isDuration := false
+       isWktPointer := false
+       proto3 := false
+       validateUTF8 := true
+       for _, tag := range tagArray[3:] {
+               if strings.HasPrefix(tag, "name=") {
+                       name = tag[5:]
+               }
+               if tag == "proto3" {
+                       proto3 = true
+               }
+               if strings.HasPrefix(tag, "customtype=") {
+                       ctype = true
+               }
+               if tag == "stdtime" {
+                       isTime = true
+               }
+               if tag == "stdduration" {
+                       isDuration = true
+               }
+               if tag == "wktptr" {
+                       isWktPointer = true
+               }
+       }
+       validateUTF8 = validateUTF8 && proto3
+
+       // Figure out packaging (pointer, slice, or both)
+       slice := false
+       pointer := false
+       if t.Kind() == reflect.Slice && t.Elem().Kind() != reflect.Uint8 {
+               slice = true
+               t = t.Elem()
+       }
+       if t.Kind() == reflect.Ptr {
+               pointer = true
+               t = t.Elem()
+       }
+
+       if ctype {
+               if reflect.PtrTo(t).Implements(customType) {
+                       if slice {
+                               return makeUnmarshalCustomSlice(getUnmarshalInfo(t), name)
+                       }
+                       if pointer {
+                               return makeUnmarshalCustomPtr(getUnmarshalInfo(t), name)
+                       }
+                       return makeUnmarshalCustom(getUnmarshalInfo(t), name)
+               } else {
+                       panic(fmt.Sprintf("custom type: type: %v, does not implement the proto.custom interface", t))
+               }
+       }
+
+       if isTime {
+               if pointer {
+                       if slice {
+                               return makeUnmarshalTimePtrSlice(getUnmarshalInfo(t), name)
+                       }
+                       return makeUnmarshalTimePtr(getUnmarshalInfo(t), name)
+               }
+               if slice {
+                       return makeUnmarshalTimeSlice(getUnmarshalInfo(t), name)
+               }
+               return makeUnmarshalTime(getUnmarshalInfo(t), name)
+       }
+
+       if isDuration {
+               if pointer {
+                       if slice {
+                               return makeUnmarshalDurationPtrSlice(getUnmarshalInfo(t), name)
+                       }
+                       return makeUnmarshalDurationPtr(getUnmarshalInfo(t), name)
+               }
+               if slice {
+                       return makeUnmarshalDurationSlice(getUnmarshalInfo(t), name)
+               }
+               return makeUnmarshalDuration(getUnmarshalInfo(t), name)
+       }
+
+       if isWktPointer {
+               switch t.Kind() {
+               case reflect.Float64:
+                       if pointer {
+                               if slice {
+                                       return makeStdDoubleValuePtrSliceUnmarshaler(getUnmarshalInfo(t), name)
+                               }
+                               return makeStdDoubleValuePtrUnmarshaler(getUnmarshalInfo(t), name)
+                       }
+                       if slice {
+                               return makeStdDoubleValueSliceUnmarshaler(getUnmarshalInfo(t), name)
+                       }
+                       return makeStdDoubleValueUnmarshaler(getUnmarshalInfo(t), name)
+               case reflect.Float32:
+                       if pointer {
+                               if slice {
+                                       return makeStdFloatValuePtrSliceUnmarshaler(getUnmarshalInfo(t), name)
+                               }
+                               return makeStdFloatValuePtrUnmarshaler(getUnmarshalInfo(t), name)
+                       }
+                       if slice {
+                               return makeStdFloatValueSliceUnmarshaler(getUnmarshalInfo(t), name)
+                       }
+                       return makeStdFloatValueUnmarshaler(getUnmarshalInfo(t), name)
+               case reflect.Int64:
+                       if pointer {
+                               if slice {
+                                       return makeStdInt64ValuePtrSliceUnmarshaler(getUnmarshalInfo(t), name)
+                               }
+                               return makeStdInt64ValuePtrUnmarshaler(getUnmarshalInfo(t), name)
+                       }
+                       if slice {
+                               return makeStdInt64ValueSliceUnmarshaler(getUnmarshalInfo(t), name)
+                       }
+                       return makeStdInt64ValueUnmarshaler(getUnmarshalInfo(t), name)
+               case reflect.Uint64:
+                       if pointer {
+                               if slice {
+                                       return makeStdUInt64ValuePtrSliceUnmarshaler(getUnmarshalInfo(t), name)
+                               }
+                               return makeStdUInt64ValuePtrUnmarshaler(getUnmarshalInfo(t), name)
+                       }
+                       if slice {
+                               return makeStdUInt64ValueSliceUnmarshaler(getUnmarshalInfo(t), name)
+                       }
+                       return makeStdUInt64ValueUnmarshaler(getUnmarshalInfo(t), name)
+               case reflect.Int32:
+                       if pointer {
+                               if slice {
+                                       return makeStdInt32ValuePtrSliceUnmarshaler(getUnmarshalInfo(t), name)
+                               }
+                               return makeStdInt32ValuePtrUnmarshaler(getUnmarshalInfo(t), name)
+                       }
+                       if slice {
+                               return makeStdInt32ValueSliceUnmarshaler(getUnmarshalInfo(t), name)
+                       }
+                       return makeStdInt32ValueUnmarshaler(getUnmarshalInfo(t), name)
+               case reflect.Uint32:
+                       if pointer {
+                               if slice {
+                                       return makeStdUInt32ValuePtrSliceUnmarshaler(getUnmarshalInfo(t), name)
+                               }
+                               return makeStdUInt32ValuePtrUnmarshaler(getUnmarshalInfo(t), name)
+                       }
+                       if slice {
+                               return makeStdUInt32ValueSliceUnmarshaler(getUnmarshalInfo(t), name)
+                       }
+                       return makeStdUInt32ValueUnmarshaler(getUnmarshalInfo(t), name)
+               case reflect.Bool:
+                       if pointer {
+                               if slice {
+                                       return makeStdBoolValuePtrSliceUnmarshaler(getUnmarshalInfo(t), name)
+                               }
+                               return makeStdBoolValuePtrUnmarshaler(getUnmarshalInfo(t), name)
+                       }
+                       if slice {
+                               return makeStdBoolValueSliceUnmarshaler(getUnmarshalInfo(t), name)
+                       }
+                       return makeStdBoolValueUnmarshaler(getUnmarshalInfo(t), name)
+               case reflect.String:
+                       if pointer {
+                               if slice {
+                                       return makeStdStringValuePtrSliceUnmarshaler(getUnmarshalInfo(t), name)
+                               }
+                               return makeStdStringValuePtrUnmarshaler(getUnmarshalInfo(t), name)
+                       }
+                       if slice {
+                               return makeStdStringValueSliceUnmarshaler(getUnmarshalInfo(t), name)
+                       }
+                       return makeStdStringValueUnmarshaler(getUnmarshalInfo(t), name)
+               case uint8SliceType:
+                       if pointer {
+                               if slice {
+                                       return makeStdBytesValuePtrSliceUnmarshaler(getUnmarshalInfo(t), name)
+                               }
+                               return makeStdBytesValuePtrUnmarshaler(getUnmarshalInfo(t), name)
+                       }
+                       if slice {
+                               return makeStdBytesValueSliceUnmarshaler(getUnmarshalInfo(t), name)
+                       }
+                       return makeStdBytesValueUnmarshaler(getUnmarshalInfo(t), name)
+               default:
+                       panic(fmt.Sprintf("unknown wktpointer type %#v", t))
+               }
+       }
+
+       // We'll never have both pointer and slice for basic types.
+       if pointer && slice && t.Kind() != reflect.Struct {
+               panic("both pointer and slice for basic type in " + t.Name())
+       }
+
+       switch t.Kind() {
+       case reflect.Bool:
+               if pointer {
+                       return unmarshalBoolPtr
+               }
+               if slice {
+                       return unmarshalBoolSlice
+               }
+               return unmarshalBoolValue
+       case reflect.Int32:
+               switch encoding {
+               case "fixed32":
+                       if pointer {
+                               return unmarshalFixedS32Ptr
+                       }
+                       if slice {
+                               return unmarshalFixedS32Slice
+                       }
+                       return unmarshalFixedS32Value
+               case "varint":
+                       // this could be int32 or enum
+                       if pointer {
+                               return unmarshalInt32Ptr
+                       }
+                       if slice {
+                               return unmarshalInt32Slice
+                       }
+                       return unmarshalInt32Value
+               case "zigzag32":
+                       if pointer {
+                               return unmarshalSint32Ptr
+                       }
+                       if slice {
+                               return unmarshalSint32Slice
+                       }
+                       return unmarshalSint32Value
+               }
+       case reflect.Int64:
+               switch encoding {
+               case "fixed64":
+                       if pointer {
+                               return unmarshalFixedS64Ptr
+                       }
+                       if slice {
+                               return unmarshalFixedS64Slice
+                       }
+                       return unmarshalFixedS64Value
+               case "varint":
+                       if pointer {
+                               return unmarshalInt64Ptr
+                       }
+                       if slice {
+                               return unmarshalInt64Slice
+                       }
+                       return unmarshalInt64Value
+               case "zigzag64":
+                       if pointer {
+                               return unmarshalSint64Ptr
+                       }
+                       if slice {
+                               return unmarshalSint64Slice
+                       }
+                       return unmarshalSint64Value
+               }
+       case reflect.Uint32:
+               switch encoding {
+               case "fixed32":
+                       if pointer {
+                               return unmarshalFixed32Ptr
+                       }
+                       if slice {
+                               return unmarshalFixed32Slice
+                       }
+                       return unmarshalFixed32Value
+               case "varint":
+                       if pointer {
+                               return unmarshalUint32Ptr
+                       }
+                       if slice {
+                               return unmarshalUint32Slice
+                       }
+                       return unmarshalUint32Value
+               }
+       case reflect.Uint64:
+               switch encoding {
+               case "fixed64":
+                       if pointer {
+                               return unmarshalFixed64Ptr
+                       }
+                       if slice {
+                               return unmarshalFixed64Slice
+                       }
+                       return unmarshalFixed64Value
+               case "varint":
+                       if pointer {
+                               return unmarshalUint64Ptr
+                       }
+                       if slice {
+                               return unmarshalUint64Slice
+                       }
+                       return unmarshalUint64Value
+               }
+       case reflect.Float32:
+               if pointer {
+                       return unmarshalFloat32Ptr
+               }
+               if slice {
+                       return unmarshalFloat32Slice
+               }
+               return unmarshalFloat32Value
+       case reflect.Float64:
+               if pointer {
+                       return unmarshalFloat64Ptr
+               }
+               if slice {
+                       return unmarshalFloat64Slice
+               }
+               return unmarshalFloat64Value
+       case reflect.Map:
+               panic("map type in typeUnmarshaler in " + t.Name())
+       case reflect.Slice:
+               if pointer {
+                       panic("bad pointer in slice case in " + t.Name())
+               }
+               if slice {
+                       return unmarshalBytesSlice
+               }
+               return unmarshalBytesValue
+       case reflect.String:
+               if validateUTF8 {
+                       if pointer {
+                               return unmarshalUTF8StringPtr
+                       }
+                       if slice {
+                               return unmarshalUTF8StringSlice
+                       }
+                       return unmarshalUTF8StringValue
+               }
+               if pointer {
+                       return unmarshalStringPtr
+               }
+               if slice {
+                       return unmarshalStringSlice
+               }
+               return unmarshalStringValue
+       case reflect.Struct:
+               // message or group field
+               if !pointer {
+                       switch encoding {
+                       case "bytes":
+                               if slice {
+                                       return makeUnmarshalMessageSlice(getUnmarshalInfo(t), name)
+                               }
+                               return makeUnmarshalMessage(getUnmarshalInfo(t), name)
+                       }
+               }
+               switch encoding {
+               case "bytes":
+                       if slice {
+                               return makeUnmarshalMessageSlicePtr(getUnmarshalInfo(t), name)
+                       }
+                       return makeUnmarshalMessagePtr(getUnmarshalInfo(t), name)
+               case "group":
+                       if slice {
+                               return makeUnmarshalGroupSlicePtr(getUnmarshalInfo(t), name)
+                       }
+                       return makeUnmarshalGroupPtr(getUnmarshalInfo(t), name)
+               }
+       }
+       panic(fmt.Sprintf("unmarshaler not found type:%s encoding:%s", t, encoding))
+}
+
+// Below are all the unmarshalers for individual fields of various types.
+
+func unmarshalInt64Value(b []byte, f pointer, w int) ([]byte, error) {
+       if w != WireVarint {
+               return b, errInternalBadWireType
+       }
+       x, n := decodeVarint(b)
+       if n == 0 {
+               return nil, io.ErrUnexpectedEOF
+       }
+       b = b[n:]
+       v := int64(x)
+       *f.toInt64() = v
+       return b, nil
+}
+
+func unmarshalInt64Ptr(b []byte, f pointer, w int) ([]byte, error) {
+       if w != WireVarint {
+               return b, errInternalBadWireType
+       }
+       x, n := decodeVarint(b)
+       if n == 0 {
+               return nil, io.ErrUnexpectedEOF
+       }
+       b = b[n:]
+       v := int64(x)
+       *f.toInt64Ptr() = &v
+       return b, nil
+}
+
+func unmarshalInt64Slice(b []byte, f pointer, w int) ([]byte, error) {
+       if w == WireBytes { // packed
+               x, n := decodeVarint(b)
+               if n == 0 {
+                       return nil, io.ErrUnexpectedEOF
+               }
+               b = b[n:]
+               if x > uint64(len(b)) {
+                       return nil, io.ErrUnexpectedEOF
+               }
+               res := b[x:]
+               b = b[:x]
+               for len(b) > 0 {
+                       x, n = decodeVarint(b)
+                       if n == 0 {
+                               return nil, io.ErrUnexpectedEOF
+                       }
+                       b = b[n:]
+                       v := int64(x)
+                       s := f.toInt64Slice()
+                       *s = append(*s, v)
+               }
+               return res, nil
+       }
+       if w != WireVarint {
+               return b, errInternalBadWireType
+       }
+       x, n := decodeVarint(b)
+       if n == 0 {
+               return nil, io.ErrUnexpectedEOF
+       }
+       b = b[n:]
+       v := int64(x)
+       s := f.toInt64Slice()
+       *s = append(*s, v)
+       return b, nil
+}
+
+func unmarshalSint64Value(b []byte, f pointer, w int) ([]byte, error) {
+       if w != WireVarint {
+               return b, errInternalBadWireType
+       }
+       x, n := decodeVarint(b)
+       if n == 0 {
+               return nil, io.ErrUnexpectedEOF
+       }
+       b = b[n:]
+       v := int64(x>>1) ^ int64(x)<<63>>63
+       *f.toInt64() = v
+       return b, nil
+}
+
+func unmarshalSint64Ptr(b []byte, f pointer, w int) ([]byte, error) {
+       if w != WireVarint {
+               return b, errInternalBadWireType
+       }
+       x, n := decodeVarint(b)
+       if n == 0 {
+               return nil, io.ErrUnexpectedEOF
+       }
+       b = b[n:]
+       v := int64(x>>1) ^ int64(x)<<63>>63
+       *f.toInt64Ptr() = &v
+       return b, nil
+}
+
+func unmarshalSint64Slice(b []byte, f pointer, w int) ([]byte, error) {
+       if w == WireBytes { // packed
+               x, n := decodeVarint(b)
+               if n == 0 {
+                       return nil, io.ErrUnexpectedEOF
+               }
+               b = b[n:]
+               if x > uint64(len(b)) {
+                       return nil, io.ErrUnexpectedEOF
+               }
+               res := b[x:]
+               b = b[:x]
+               for len(b) > 0 {
+                       x, n = decodeVarint(b)
+                       if n == 0 {
+                               return nil, io.ErrUnexpectedEOF
+                       }
+                       b = b[n:]
+                       v := int64(x>>1) ^ int64(x)<<63>>63
+                       s := f.toInt64Slice()
+                       *s = append(*s, v)
+               }
+               return res, nil
+       }
+       if w != WireVarint {
+               return b, errInternalBadWireType
+       }
+       x, n := decodeVarint(b)
+       if n == 0 {
+               return nil, io.ErrUnexpectedEOF
+       }
+       b = b[n:]
+       v := int64(x>>1) ^ int64(x)<<63>>63
+       s := f.toInt64Slice()
+       *s = append(*s, v)
+       return b, nil
+}
+
+func unmarshalUint64Value(b []byte, f pointer, w int) ([]byte, error) {
+       if w != WireVarint {
+               return b, errInternalBadWireType
+       }
+       x, n := decodeVarint(b)
+       if n == 0 {
+               return nil, io.ErrUnexpectedEOF
+       }
+       b = b[n:]
+       v := uint64(x)
+       *f.toUint64() = v
+       return b, nil
+}
+
+func unmarshalUint64Ptr(b []byte, f pointer, w int) ([]byte, error) {
+       if w != WireVarint {
+               return b, errInternalBadWireType
+       }
+       x, n := decodeVarint(b)
+       if n == 0 {
+               return nil, io.ErrUnexpectedEOF
+       }
+       b = b[n:]
+       v := uint64(x)
+       *f.toUint64Ptr() = &v
+       return b, nil
+}
+
+func unmarshalUint64Slice(b []byte, f pointer, w int) ([]byte, error) {
+       if w == WireBytes { // packed
+               x, n := decodeVarint(b)
+               if n == 0 {
+                       return nil, io.ErrUnexpectedEOF
+               }
+               b = b[n:]
+               if x > uint64(len(b)) {
+                       return nil, io.ErrUnexpectedEOF
+               }
+               res := b[x:]
+               b = b[:x]
+               for len(b) > 0 {
+                       x, n = decodeVarint(b)
+                       if n == 0 {
+                               return nil, io.ErrUnexpectedEOF
+                       }
+                       b = b[n:]
+                       v := uint64(x)
+                       s := f.toUint64Slice()
+                       *s = append(*s, v)
+               }
+               return res, nil
+       }
+       if w != WireVarint {
+               return b, errInternalBadWireType
+       }
+       x, n := decodeVarint(b)
+       if n == 0 {
+               return nil, io.ErrUnexpectedEOF
+       }
+       b = b[n:]
+       v := uint64(x)
+       s := f.toUint64Slice()
+       *s = append(*s, v)
+       return b, nil
+}
+
+func unmarshalInt32Value(b []byte, f pointer, w int) ([]byte, error) {
+       if w != WireVarint {
+               return b, errInternalBadWireType
+       }
+       x, n := decodeVarint(b)
+       if n == 0 {
+               return nil, io.ErrUnexpectedEOF
+       }
+       b = b[n:]
+       v := int32(x)
+       *f.toInt32() = v
+       return b, nil
+}
+
+func unmarshalInt32Ptr(b []byte, f pointer, w int) ([]byte, error) {
+       if w != WireVarint {
+               return b, errInternalBadWireType
+       }
+       x, n := decodeVarint(b)
+       if n == 0 {
+               return nil, io.ErrUnexpectedEOF
+       }
+       b = b[n:]
+       v := int32(x)
+       f.setInt32Ptr(v)
+       return b, nil
+}
+
+func unmarshalInt32Slice(b []byte, f pointer, w int) ([]byte, error) {
+       if w == WireBytes { // packed
+               x, n := decodeVarint(b)
+               if n == 0 {
+                       return nil, io.ErrUnexpectedEOF
+               }
+               b = b[n:]
+               if x > uint64(len(b)) {
+                       return nil, io.ErrUnexpectedEOF
+               }
+               res := b[x:]
+               b = b[:x]
+               for len(b) > 0 {
+                       x, n = decodeVarint(b)
+                       if n == 0 {
+                               return nil, io.ErrUnexpectedEOF
+                       }
+                       b = b[n:]
+                       v := int32(x)
+                       f.appendInt32Slice(v)
+               }
+               return res, nil
+       }
+       if w != WireVarint {
+               return b, errInternalBadWireType
+       }
+       x, n := decodeVarint(b)
+       if n == 0 {
+               return nil, io.ErrUnexpectedEOF
+       }
+       b = b[n:]
+       v := int32(x)
+       f.appendInt32Slice(v)
+       return b, nil
+}
+
+func unmarshalSint32Value(b []byte, f pointer, w int) ([]byte, error) {
+       if w != WireVarint {
+               return b, errInternalBadWireType
+       }
+       x, n := decodeVarint(b)
+       if n == 0 {
+               return nil, io.ErrUnexpectedEOF
+       }
+       b = b[n:]
+       v := int32(x>>1) ^ int32(x)<<31>>31
+       *f.toInt32() = v
+       return b, nil
+}
+
+func unmarshalSint32Ptr(b []byte, f pointer, w int) ([]byte, error) {
+       if w != WireVarint {
+               return b, errInternalBadWireType
+       }
+       x, n := decodeVarint(b)
+       if n == 0 {
+               return nil, io.ErrUnexpectedEOF
+       }
+       b = b[n:]
+       v := int32(x>>1) ^ int32(x)<<31>>31
+       f.setInt32Ptr(v)
+       return b, nil
+}
+
+func unmarshalSint32Slice(b []byte, f pointer, w int) ([]byte, error) {
+       if w == WireBytes { // packed
+               x, n := decodeVarint(b)
+               if n == 0 {
+                       return nil, io.ErrUnexpectedEOF
+               }
+               b = b[n:]
+               if x > uint64(len(b)) {
+                       return nil, io.ErrUnexpectedEOF
+               }
+               res := b[x:]
+               b = b[:x]
+               for len(b) > 0 {
+                       x, n = decodeVarint(b)
+                       if n == 0 {
+                               return nil, io.ErrUnexpectedEOF
+                       }
+                       b = b[n:]
+                       v := int32(x>>1) ^ int32(x)<<31>>31
+                       f.appendInt32Slice(v)
+               }
+               return res, nil
+       }
+       if w != WireVarint {
+               return b, errInternalBadWireType
+       }
+       x, n := decodeVarint(b)
+       if n == 0 {
+               return nil, io.ErrUnexpectedEOF
+       }
+       b = b[n:]
+       v := int32(x>>1) ^ int32(x)<<31>>31
+       f.appendInt32Slice(v)
+       return b, nil
+}
+
+func unmarshalUint32Value(b []byte, f pointer, w int) ([]byte, error) {
+       if w != WireVarint {
+               return b, errInternalBadWireType
+       }
+       x, n := decodeVarint(b)
+       if n == 0 {
+               return nil, io.ErrUnexpectedEOF
+       }
+       b = b[n:]
+       v := uint32(x)
+       *f.toUint32() = v
+       return b, nil
+}
+
+func unmarshalUint32Ptr(b []byte, f pointer, w int) ([]byte, error) {
+       if w != WireVarint {
+               return b, errInternalBadWireType
+       }
+       x, n := decodeVarint(b)
+       if n == 0 {
+               return nil, io.ErrUnexpectedEOF
+       }
+       b = b[n:]
+       v := uint32(x)
+       *f.toUint32Ptr() = &v
+       return b, nil
+}
+
+func unmarshalUint32Slice(b []byte, f pointer, w int) ([]byte, error) {
+       if w == WireBytes { // packed
+               x, n := decodeVarint(b)
+               if n == 0 {
+                       return nil, io.ErrUnexpectedEOF
+               }
+               b = b[n:]
+               if x > uint64(len(b)) {
+                       return nil, io.ErrUnexpectedEOF
+               }
+               res := b[x:]
+               b = b[:x]
+               for len(b) > 0 {
+                       x, n = decodeVarint(b)
+                       if n == 0 {
+                               return nil, io.ErrUnexpectedEOF
+                       }
+                       b = b[n:]
+                       v := uint32(x)
+                       s := f.toUint32Slice()
+                       *s = append(*s, v)
+               }
+               return res, nil
+       }
+       if w != WireVarint {
+               return b, errInternalBadWireType
+       }
+       x, n := decodeVarint(b)
+       if n == 0 {
+               return nil, io.ErrUnexpectedEOF
+       }
+       b = b[n:]
+       v := uint32(x)
+       s := f.toUint32Slice()
+       *s = append(*s, v)
+       return b, nil
+}
+
+func unmarshalFixed64Value(b []byte, f pointer, w int) ([]byte, error) {
+       if w != WireFixed64 {
+               return b, errInternalBadWireType
+       }
+       if len(b) < 8 {
+               return nil, io.ErrUnexpectedEOF
+       }
+       v := uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56
+       *f.toUint64() = v
+       return b[8:], nil
+}
+
+func unmarshalFixed64Ptr(b []byte, f pointer, w int) ([]byte, error) {
+       if w != WireFixed64 {
+               return b, errInternalBadWireType
+       }
+       if len(b) < 8 {
+               return nil, io.ErrUnexpectedEOF
+       }
+       v := uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56
+       *f.toUint64Ptr() = &v
+       return b[8:], nil
+}
+
+func unmarshalFixed64Slice(b []byte, f pointer, w int) ([]byte, error) {
+       if w == WireBytes { // packed
+               x, n := decodeVarint(b)
+               if n == 0 {
+                       return nil, io.ErrUnexpectedEOF
+               }
+               b = b[n:]
+               if x > uint64(len(b)) {
+                       return nil, io.ErrUnexpectedEOF
+               }
+               res := b[x:]
+               b = b[:x]
+               for len(b) > 0 {
+                       if len(b) < 8 {
+                               return nil, io.ErrUnexpectedEOF
+                       }
+                       v := uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56
+                       s := f.toUint64Slice()
+                       *s = append(*s, v)
+                       b = b[8:]
+               }
+               return res, nil
+       }
+       if w != WireFixed64 {
+               return b, errInternalBadWireType
+       }
+       if len(b) < 8 {
+               return nil, io.ErrUnexpectedEOF
+       }
+       v := uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56
+       s := f.toUint64Slice()
+       *s = append(*s, v)
+       return b[8:], nil
+}
+
+func unmarshalFixedS64Value(b []byte, f pointer, w int) ([]byte, error) {
+       if w != WireFixed64 {
+               return b, errInternalBadWireType
+       }
+       if len(b) < 8 {
+               return nil, io.ErrUnexpectedEOF
+       }
+       v := int64(b[0]) | int64(b[1])<<8 | int64(b[2])<<16 | int64(b[3])<<24 | int64(b[4])<<32 | int64(b[5])<<40 | int64(b[6])<<48 | int64(b[7])<<56
+       *f.toInt64() = v
+       return b[8:], nil
+}
+
+func unmarshalFixedS64Ptr(b []byte, f pointer, w int) ([]byte, error) {
+       if w != WireFixed64 {
+               return b, errInternalBadWireType
+       }
+       if len(b) < 8 {
+               return nil, io.ErrUnexpectedEOF
+       }
+       v := int64(b[0]) | int64(b[1])<<8 | int64(b[2])<<16 | int64(b[3])<<24 | int64(b[4])<<32 | int64(b[5])<<40 | int64(b[6])<<48 | int64(b[7])<<56
+       *f.toInt64Ptr() = &v
+       return b[8:], nil
+}
+
+func unmarshalFixedS64Slice(b []byte, f pointer, w int) ([]byte, error) {
+       if w == WireBytes { // packed
+               x, n := decodeVarint(b)
+               if n == 0 {
+                       return nil, io.ErrUnexpectedEOF
+               }
+               b = b[n:]
+               if x > uint64(len(b)) {
+                       return nil, io.ErrUnexpectedEOF
+               }
+               res := b[x:]
+               b = b[:x]
+               for len(b) > 0 {
+                       if len(b) < 8 {
+                               return nil, io.ErrUnexpectedEOF
+                       }
+                       v := int64(b[0]) | int64(b[1])<<8 | int64(b[2])<<16 | int64(b[3])<<24 | int64(b[4])<<32 | int64(b[5])<<40 | int64(b[6])<<48 | int64(b[7])<<56
+                       s := f.toInt64Slice()
+                       *s = append(*s, v)
+                       b = b[8:]
+               }
+               return res, nil
+       }
+       if w != WireFixed64 {
+               return b, errInternalBadWireType
+       }
+       if len(b) < 8 {
+               return nil, io.ErrUnexpectedEOF
+       }
+       v := int64(b[0]) | int64(b[1])<<8 | int64(b[2])<<16 | int64(b[3])<<24 | int64(b[4])<<32 | int64(b[5])<<40 | int64(b[6])<<48 | int64(b[7])<<56
+       s := f.toInt64Slice()
+       *s = append(*s, v)
+       return b[8:], nil
+}
+
+func unmarshalFixed32Value(b []byte, f pointer, w int) ([]byte, error) {
+       if w != WireFixed32 {
+               return b, errInternalBadWireType
+       }
+       if len(b) < 4 {
+               return nil, io.ErrUnexpectedEOF
+       }
+       v := uint32(b[0]) | uint32(b[1])<<8 | uint32(b[2])<<16 | uint32(b[3])<<24
+       *f.toUint32() = v
+       return b[4:], nil
+}
+
+func unmarshalFixed32Ptr(b []byte, f pointer, w int) ([]byte, error) {
+       if w != WireFixed32 {
+               return b, errInternalBadWireType
+       }
+       if len(b) < 4 {
+               return nil, io.ErrUnexpectedEOF
+       }
+       v := uint32(b[0]) | uint32(b[1])<<8 | uint32(b[2])<<16 | uint32(b[3])<<24
+       *f.toUint32Ptr() = &v
+       return b[4:], nil
+}
+
+func unmarshalFixed32Slice(b []byte, f pointer, w int) ([]byte, error) {
+       if w == WireBytes { // packed
+               x, n := decodeVarint(b)
+               if n == 0 {
+                       return nil, io.ErrUnexpectedEOF
+               }
+               b = b[n:]
+               if x > uint64(len(b)) {
+                       return nil, io.ErrUnexpectedEOF
+               }
+               res := b[x:]
+               b = b[:x]
+               for len(b) > 0 {
+                       if len(b) < 4 {
+                               return nil, io.ErrUnexpectedEOF
+                       }
+                       v := uint32(b[0]) | uint32(b[1])<<8 | uint32(b[2])<<16 | uint32(b[3])<<24
+                       s := f.toUint32Slice()
+                       *s = append(*s, v)
+                       b = b[4:]
+               }
+               return res, nil
+       }
+       if w != WireFixed32 {
+               return b, errInternalBadWireType
+       }
+       if len(b) < 4 {
+               return nil, io.ErrUnexpectedEOF
+       }
+       v := uint32(b[0]) | uint32(b[1])<<8 | uint32(b[2])<<16 | uint32(b[3])<<24
+       s := f.toUint32Slice()
+       *s = append(*s, v)
+       return b[4:], nil
+}
+
+func unmarshalFixedS32Value(b []byte, f pointer, w int) ([]byte, error) {
+       if w != WireFixed32 {
+               return b, errInternalBadWireType
+       }
+       if len(b) < 4 {
+               return nil, io.ErrUnexpectedEOF
+       }
+       v := int32(b[0]) | int32(b[1])<<8 | int32(b[2])<<16 | int32(b[3])<<24
+       *f.toInt32() = v
+       return b[4:], nil
+}
+
+func unmarshalFixedS32Ptr(b []byte, f pointer, w int) ([]byte, error) {
+       if w != WireFixed32 {
+               return b, errInternalBadWireType
+       }
+       if len(b) < 4 {
+               return nil, io.ErrUnexpectedEOF
+       }
+       v := int32(b[0]) | int32(b[1])<<8 | int32(b[2])<<16 | int32(b[3])<<24
+       f.setInt32Ptr(v)
+       return b[4:], nil
+}
+
+func unmarshalFixedS32Slice(b []byte, f pointer, w int) ([]byte, error) {
+       if w == WireBytes { // packed
+               x, n := decodeVarint(b)
+               if n == 0 {
+                       return nil, io.ErrUnexpectedEOF
+               }
+               b = b[n:]
+               if x > uint64(len(b)) {
+                       return nil, io.ErrUnexpectedEOF
+               }
+               res := b[x:]
+               b = b[:x]
+               for len(b) > 0 {
+                       if len(b) < 4 {
+                               return nil, io.ErrUnexpectedEOF
+                       }
+                       v := int32(b[0]) | int32(b[1])<<8 | int32(b[2])<<16 | int32(b[3])<<24
+                       f.appendInt32Slice(v)
+                       b = b[4:]
+               }
+               return res, nil
+       }
+       if w != WireFixed32 {
+               return b, errInternalBadWireType
+       }
+       if len(b) < 4 {
+               return nil, io.ErrUnexpectedEOF
+       }
+       v := int32(b[0]) | int32(b[1])<<8 | int32(b[2])<<16 | int32(b[3])<<24
+       f.appendInt32Slice(v)
+       return b[4:], nil
+}
+
+func unmarshalBoolValue(b []byte, f pointer, w int) ([]byte, error) {
+       if w != WireVarint {
+               return b, errInternalBadWireType
+       }
+       // Note: any length varint is allowed, even though any sane
+       // encoder will use one byte.
+       // See https://github.com/golang/protobuf/issues/76
+       x, n := decodeVarint(b)
+       if n == 0 {
+               return nil, io.ErrUnexpectedEOF
+       }
+       // TODO: check if x>1? Tests seem to indicate no.
+       v := x != 0
+       *f.toBool() = v
+       return b[n:], nil
+}
+
+func unmarshalBoolPtr(b []byte, f pointer, w int) ([]byte, error) {
+       if w != WireVarint {
+               return b, errInternalBadWireType
+       }
+       x, n := decodeVarint(b)
+       if n == 0 {
+               return nil, io.ErrUnexpectedEOF
+       }
+       v := x != 0
+       *f.toBoolPtr() = &v
+       return b[n:], nil
+}
+
+func unmarshalBoolSlice(b []byte, f pointer, w int) ([]byte, error) {
+       if w == WireBytes { // packed
+               x, n := decodeVarint(b)
+               if n == 0 {
+                       return nil, io.ErrUnexpectedEOF
+               }
+               b = b[n:]
+               if x > uint64(len(b)) {
+                       return nil, io.ErrUnexpectedEOF
+               }
+               res := b[x:]
+               b = b[:x]
+               for len(b) > 0 {
+                       x, n = decodeVarint(b)
+                       if n == 0 {
+                               return nil, io.ErrUnexpectedEOF
+                       }
+                       v := x != 0
+                       s := f.toBoolSlice()
+                       *s = append(*s, v)
+                       b = b[n:]
+               }
+               return res, nil
+       }
+       if w != WireVarint {
+               return b, errInternalBadWireType
+       }
+       x, n := decodeVarint(b)
+       if n == 0 {
+               return nil, io.ErrUnexpectedEOF
+       }
+       v := x != 0
+       s := f.toBoolSlice()
+       *s = append(*s, v)
+       return b[n:], nil
+}
+
+func unmarshalFloat64Value(b []byte, f pointer, w int) ([]byte, error) {
+       if w != WireFixed64 {
+               return b, errInternalBadWireType
+       }
+       if len(b) < 8 {
+               return nil, io.ErrUnexpectedEOF
+       }
+       v := math.Float64frombits(uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56)
+       *f.toFloat64() = v
+       return b[8:], nil
+}
+
+func unmarshalFloat64Ptr(b []byte, f pointer, w int) ([]byte, error) {
+       if w != WireFixed64 {
+               return b, errInternalBadWireType
+       }
+       if len(b) < 8 {
+               return nil, io.ErrUnexpectedEOF
+       }
+       v := math.Float64frombits(uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56)
+       *f.toFloat64Ptr() = &v
+       return b[8:], nil
+}
+
+func unmarshalFloat64Slice(b []byte, f pointer, w int) ([]byte, error) {
+       if w == WireBytes { // packed
+               x, n := decodeVarint(b)
+               if n == 0 {
+                       return nil, io.ErrUnexpectedEOF
+               }
+               b = b[n:]
+               if x > uint64(len(b)) {
+                       return nil, io.ErrUnexpectedEOF
+               }
+               res := b[x:]
+               b = b[:x]
+               for len(b) > 0 {
+                       if len(b) < 8 {
+                               return nil, io.ErrUnexpectedEOF
+                       }
+                       v := math.Float64frombits(uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56)
+                       s := f.toFloat64Slice()
+                       *s = append(*s, v)
+                       b = b[8:]
+               }
+               return res, nil
+       }
+       if w != WireFixed64 {
+               return b, errInternalBadWireType
+       }
+       if len(b) < 8 {
+               return nil, io.ErrUnexpectedEOF
+       }
+       v := math.Float64frombits(uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56)
+       s := f.toFloat64Slice()
+       *s = append(*s, v)
+       return b[8:], nil
+}
+
+func unmarshalFloat32Value(b []byte, f pointer, w int) ([]byte, error) {
+       if w != WireFixed32 {
+               return b, errInternalBadWireType
+       }
+       if len(b) < 4 {
+               return nil, io.ErrUnexpectedEOF
+       }
+       v := math.Float32frombits(uint32(b[0]) | uint32(b[1])<<8 | uint32(b[2])<<16 | uint32(b[3])<<24)
+       *f.toFloat32() = v
+       return b[4:], nil
+}
+
+func unmarshalFloat32Ptr(b []byte, f pointer, w int) ([]byte, error) {
+       if w != WireFixed32 {
+               return b, errInternalBadWireType
+       }
+       if len(b) < 4 {
+               return nil, io.ErrUnexpectedEOF
+       }
+       v := math.Float32frombits(uint32(b[0]) | uint32(b[1])<<8 | uint32(b[2])<<16 | uint32(b[3])<<24)
+       *f.toFloat32Ptr() = &v
+       return b[4:], nil
+}
+
+func unmarshalFloat32Slice(b []byte, f pointer, w int) ([]byte, error) {
+       if w == WireBytes { // packed
+               x, n := decodeVarint(b)
+               if n == 0 {
+                       return nil, io.ErrUnexpectedEOF
+               }
+               b = b[n:]
+               if x > uint64(len(b)) {
+                       return nil, io.ErrUnexpectedEOF
+               }
+               res := b[x:]
+               b = b[:x]
+               for len(b) > 0 {
+                       if len(b) < 4 {
+                               return nil, io.ErrUnexpectedEOF
+                       }
+                       v := math.Float32frombits(uint32(b[0]) | uint32(b[1])<<8 | uint32(b[2])<<16 | uint32(b[3])<<24)
+                       s := f.toFloat32Slice()
+                       *s = append(*s, v)
+                       b = b[4:]
+               }
+               return res, nil
+       }
+       if w != WireFixed32 {
+               return b, errInternalBadWireType
+       }
+       if len(b) < 4 {
+               return nil, io.ErrUnexpectedEOF
+       }
+       v := math.Float32frombits(uint32(b[0]) | uint32(b[1])<<8 | uint32(b[2])<<16 | uint32(b[3])<<24)
+       s := f.toFloat32Slice()
+       *s = append(*s, v)
+       return b[4:], nil
+}
+
+func unmarshalStringValue(b []byte, f pointer, w int) ([]byte, error) {
+       if w != WireBytes {
+               return b, errInternalBadWireType
+       }
+       x, n := decodeVarint(b)
+       if n == 0 {
+               return nil, io.ErrUnexpectedEOF
+       }
+       b = b[n:]
+       if x > uint64(len(b)) {
+               return nil, io.ErrUnexpectedEOF
+       }
+       v := string(b[:x])
+       *f.toString() = v
+       return b[x:], nil
+}
+
+func unmarshalStringPtr(b []byte, f pointer, w int) ([]byte, error) {
+       if w != WireBytes {
+               return b, errInternalBadWireType
+       }
+       x, n := decodeVarint(b)
+       if n == 0 {
+               return nil, io.ErrUnexpectedEOF
+       }
+       b = b[n:]
+       if x > uint64(len(b)) {
+               return nil, io.ErrUnexpectedEOF
+       }
+       v := string(b[:x])
+       *f.toStringPtr() = &v
+       return b[x:], nil
+}
+
+func unmarshalStringSlice(b []byte, f pointer, w int) ([]byte, error) {
+       if w != WireBytes {
+               return b, errInternalBadWireType
+       }
+       x, n := decodeVarint(b)
+       if n == 0 {
+               return nil, io.ErrUnexpectedEOF
+       }
+       b = b[n:]
+       if x > uint64(len(b)) {
+               return nil, io.ErrUnexpectedEOF
+       }
+       v := string(b[:x])
+       s := f.toStringSlice()
+       *s = append(*s, v)
+       return b[x:], nil
+}
+
+func unmarshalUTF8StringValue(b []byte, f pointer, w int) ([]byte, error) {
+       if w != WireBytes {
+               return b, errInternalBadWireType
+       }
+       x, n := decodeVarint(b)
+       if n == 0 {
+               return nil, io.ErrUnexpectedEOF
+       }
+       b = b[n:]
+       if x > uint64(len(b)) {
+               return nil, io.ErrUnexpectedEOF
+       }
+       v := string(b[:x])
+       *f.toString() = v
+       if !utf8.ValidString(v) {
+               return b[x:], errInvalidUTF8
+       }
+       return b[x:], nil
+}
+
+func unmarshalUTF8StringPtr(b []byte, f pointer, w int) ([]byte, error) {
+       if w != WireBytes {
+               return b, errInternalBadWireType
+       }
+       x, n := decodeVarint(b)
+       if n == 0 {
+               return nil, io.ErrUnexpectedEOF
+       }
+       b = b[n:]
+       if x > uint64(len(b)) {
+               return nil, io.ErrUnexpectedEOF
+       }
+       v := string(b[:x])
+       *f.toStringPtr() = &v
+       if !utf8.ValidString(v) {
+               return b[x:], errInvalidUTF8
+       }
+       return b[x:], nil
+}
+
+func unmarshalUTF8StringSlice(b []byte, f pointer, w int) ([]byte, error) {
+       if w != WireBytes {
+               return b, errInternalBadWireType
+       }
+       x, n := decodeVarint(b)
+       if n == 0 {
+               return nil, io.ErrUnexpectedEOF
+       }
+       b = b[n:]
+       if x > uint64(len(b)) {
+               return nil, io.ErrUnexpectedEOF
+       }
+       v := string(b[:x])
+       s := f.toStringSlice()
+       *s = append(*s, v)
+       if !utf8.ValidString(v) {
+               return b[x:], errInvalidUTF8
+       }
+       return b[x:], nil
+}
+
+var emptyBuf [0]byte
+
+func unmarshalBytesValue(b []byte, f pointer, w int) ([]byte, error) {
+       if w != WireBytes {
+               return b, errInternalBadWireType
+       }
+       x, n := decodeVarint(b)
+       if n == 0 {
+               return nil, io.ErrUnexpectedEOF
+       }
+       b = b[n:]
+       if x > uint64(len(b)) {
+               return nil, io.ErrUnexpectedEOF
+       }
+       // The use of append here is a trick which avoids the zeroing
+       // that would be required if we used a make/copy pair.
+       // We append to emptyBuf instead of nil because we want
+       // a non-nil result even when the length is 0.
+       v := append(emptyBuf[:], b[:x]...)
+       *f.toBytes() = v
+       return b[x:], nil
+}
+
+func unmarshalBytesSlice(b []byte, f pointer, w int) ([]byte, error) {
+       if w != WireBytes {
+               return b, errInternalBadWireType
+       }
+       x, n := decodeVarint(b)
+       if n == 0 {
+               return nil, io.ErrUnexpectedEOF
+       }
+       b = b[n:]
+       if x > uint64(len(b)) {
+               return nil, io.ErrUnexpectedEOF
+       }
+       v := append(emptyBuf[:], b[:x]...)
+       s := f.toBytesSlice()
+       *s = append(*s, v)
+       return b[x:], nil
+}
+
+func makeUnmarshalMessagePtr(sub *unmarshalInfo, name string) unmarshaler {
+       return func(b []byte, f pointer, w int) ([]byte, error) {
+               if w != WireBytes {
+                       return b, errInternalBadWireType
+               }
+               x, n := decodeVarint(b)
+               if n == 0 {
+                       return nil, io.ErrUnexpectedEOF
+               }
+               b = b[n:]
+               if x > uint64(len(b)) {
+                       return nil, io.ErrUnexpectedEOF
+               }
+               // First read the message field to see if something is there.
+               // The semantics of multiple submessages are weird.  Instead of
+               // the last one winning (as it is for all other fields), multiple
+               // submessages are merged.
+               v := f.getPointer()
+               if v.isNil() {
+                       v = valToPointer(reflect.New(sub.typ))
+                       f.setPointer(v)
+               }
+               err := sub.unmarshal(v, b[:x])
+               if err != nil {
+                       if r, ok := err.(*RequiredNotSetError); ok {
+                               r.field = name + "." + r.field
+                       } else {
+                               return nil, err
+                       }
+               }
+               return b[x:], err
+       }
+}
+
+func makeUnmarshalMessageSlicePtr(sub *unmarshalInfo, name string) unmarshaler {
+       return func(b []byte, f pointer, w int) ([]byte, error) {
+               if w != WireBytes {
+                       return b, errInternalBadWireType
+               }
+               x, n := decodeVarint(b)
+               if n == 0 {
+                       return nil, io.ErrUnexpectedEOF
+               }
+               b = b[n:]
+               if x > uint64(len(b)) {
+                       return nil, io.ErrUnexpectedEOF
+               }
+               v := valToPointer(reflect.New(sub.typ))
+               err := sub.unmarshal(v, b[:x])
+               if err != nil {
+                       if r, ok := err.(*RequiredNotSetError); ok {
+                               r.field = name + "." + r.field
+                       } else {
+                               return nil, err
+                       }
+               }
+               f.appendPointer(v)
+               return b[x:], err
+       }
+}
+
+func makeUnmarshalGroupPtr(sub *unmarshalInfo, name string) unmarshaler {
+       return func(b []byte, f pointer, w int) ([]byte, error) {
+               if w != WireStartGroup {
+                       return b, errInternalBadWireType
+               }
+               x, y := findEndGroup(b)
+               if x < 0 {
+                       return nil, io.ErrUnexpectedEOF
+               }
+               v := f.getPointer()
+               if v.isNil() {
+                       v = valToPointer(reflect.New(sub.typ))
+                       f.setPointer(v)
+               }
+               err := sub.unmarshal(v, b[:x])
+               if err != nil {
+                       if r, ok := err.(*RequiredNotSetError); ok {
+                               r.field = name + "." + r.field
+                       } else {
+                               return nil, err
+                       }
+               }
+               return b[y:], err
+       }
+}
+
+func makeUnmarshalGroupSlicePtr(sub *unmarshalInfo, name string) unmarshaler {
+       return func(b []byte, f pointer, w int) ([]byte, error) {
+               if w != WireStartGroup {
+                       return b, errInternalBadWireType
+               }
+               x, y := findEndGroup(b)
+               if x < 0 {
+                       return nil, io.ErrUnexpectedEOF
+               }
+               v := valToPointer(reflect.New(sub.typ))
+               err := sub.unmarshal(v, b[:x])
+               if err != nil {
+                       if r, ok := err.(*RequiredNotSetError); ok {
+                               r.field = name + "." + r.field
+                       } else {
+                               return nil, err
+                       }
+               }
+               f.appendPointer(v)
+               return b[y:], err
+       }
+}
+
+func makeUnmarshalMap(f *reflect.StructField) unmarshaler {
+       t := f.Type
+       kt := t.Key()
+       vt := t.Elem()
+       tagArray := strings.Split(f.Tag.Get("protobuf"), ",")
+       valTags := strings.Split(f.Tag.Get("protobuf_val"), ",")
+       for _, t := range tagArray {
+               if strings.HasPrefix(t, "customtype=") {
+                       valTags = append(valTags, t)
+               }
+               if t == "stdtime" {
+                       valTags = append(valTags, t)
+               }
+               if t == "stdduration" {
+                       valTags = append(valTags, t)
+               }
+               if t == "wktptr" {
+                       valTags = append(valTags, t)
+               }
+       }
+       unmarshalKey := typeUnmarshaler(kt, f.Tag.Get("protobuf_key"))
+       unmarshalVal := typeUnmarshaler(vt, strings.Join(valTags, ","))
+       return func(b []byte, f pointer, w int) ([]byte, error) {
+               // The map entry is a submessage. Figure out how big it is.
+               if w != WireBytes {
+                       return nil, fmt.Errorf("proto: bad wiretype for map field: got %d want %d", w, WireBytes)
+               }
+               x, n := decodeVarint(b)
+               if n == 0 {
+                       return nil, io.ErrUnexpectedEOF
+               }
+               b = b[n:]
+               if x > uint64(len(b)) {
+                       return nil, io.ErrUnexpectedEOF
+               }
+               r := b[x:] // unused data to return
+               b = b[:x]  // data for map entry
+
+               // Note: we could use #keys * #values ~= 200 functions
+               // to do map decoding without reflection. Probably not worth it.
+               // Maps will be somewhat slow. Oh well.
+
+               // Read key and value from data.
+               var nerr nonFatal
+               k := reflect.New(kt)
+               v := reflect.New(vt)
+               for len(b) > 0 {
+                       x, n := decodeVarint(b)
+                       if n == 0 {
+                               return nil, io.ErrUnexpectedEOF
+                       }
+                       wire := int(x) & 7
+                       b = b[n:]
+
+                       var err error
+                       switch x >> 3 {
+                       case 1:
+                               b, err = unmarshalKey(b, valToPointer(k), wire)
+                       case 2:
+                               b, err = unmarshalVal(b, valToPointer(v), wire)
+                       default:
+                               err = errInternalBadWireType // skip unknown tag
+                       }
+
+                       if nerr.Merge(err) {
+                               continue
+                       }
+                       if err != errInternalBadWireType {
+                               return nil, err
+                       }
+
+                       // Skip past unknown fields.
+                       b, err = skipField(b, wire)
+                       if err != nil {
+                               return nil, err
+                       }
+               }
+
+               // Get map, allocate if needed.
+               m := f.asPointerTo(t).Elem() // an addressable map[K]T
+               if m.IsNil() {
+                       m.Set(reflect.MakeMap(t))
+               }
+
+               // Insert into map.
+               m.SetMapIndex(k.Elem(), v.Elem())
+
+               return r, nerr.E
+       }
+}
+
+// makeUnmarshalOneof makes an unmarshaler for oneof fields.
+// for:
+// message Msg {
+//   oneof F {
+//     int64 X = 1;
+//     float64 Y = 2;
+//   }
+// }
+// typ is the type of the concrete entry for a oneof case (e.g. Msg_X).
+// ityp is the interface type of the oneof field (e.g. isMsg_F).
+// unmarshal is the unmarshaler for the base type of the oneof case (e.g. int64).
+// Note that this function will be called once for each case in the oneof.
+func makeUnmarshalOneof(typ, ityp reflect.Type, unmarshal unmarshaler) unmarshaler {
+       sf := typ.Field(0)
+       field0 := toField(&sf)
+       return func(b []byte, f pointer, w int) ([]byte, error) {
+               // Allocate holder for value.
+               v := reflect.New(typ)
+
+               // Unmarshal data into holder.
+               // We unmarshal into the first field of the holder object.
+               var err error
+               var nerr nonFatal
+               b, err = unmarshal(b, valToPointer(v).offset(field0), w)
+               if !nerr.Merge(err) {
+                       return nil, err
+               }
+
+               // Write pointer to holder into target field.
+               f.asPointerTo(ityp).Elem().Set(v)
+
+               return b, nerr.E
+       }
+}
+
+// Error used by decode internally.
+var errInternalBadWireType = errors.New("proto: internal error: bad wiretype")
+
+// skipField skips past a field of type wire and returns the remaining bytes.
+func skipField(b []byte, wire int) ([]byte, error) {
+       switch wire {
+       case WireVarint:
+               _, k := decodeVarint(b)
+               if k == 0 {
+                       return b, io.ErrUnexpectedEOF
+               }
+               b = b[k:]
+       case WireFixed32:
+               if len(b) < 4 {
+                       return b, io.ErrUnexpectedEOF
+               }
+               b = b[4:]
+       case WireFixed64:
+               if len(b) < 8 {
+                       return b, io.ErrUnexpectedEOF
+               }
+               b = b[8:]
+       case WireBytes:
+               m, k := decodeVarint(b)
+               if k == 0 || uint64(len(b)-k) < m {
+                       return b, io.ErrUnexpectedEOF
+               }
+               b = b[uint64(k)+m:]
+       case WireStartGroup:
+               _, i := findEndGroup(b)
+               if i == -1 {
+                       return b, io.ErrUnexpectedEOF
+               }
+               b = b[i:]
+       default:
+               return b, fmt.Errorf("proto: can't skip unknown wire type %d", wire)
+       }
+       return b, nil
+}
+
+// findEndGroup finds the index of the next EndGroup tag.
+// Groups may be nested, so the "next" EndGroup tag is the first
+// unpaired EndGroup.
+// findEndGroup returns the indexes of the start and end of the EndGroup tag.
+// Returns (-1,-1) if it can't find one.
+func findEndGroup(b []byte) (int, int) {
+       depth := 1
+       i := 0
+       for {
+               x, n := decodeVarint(b[i:])
+               if n == 0 {
+                       return -1, -1
+               }
+               j := i
+               i += n
+               switch x & 7 {
+               case WireVarint:
+                       _, k := decodeVarint(b[i:])
+                       if k == 0 {
+                               return -1, -1
+                       }
+                       i += k
+               case WireFixed32:
+                       if len(b)-4 < i {
+                               return -1, -1
+                       }
+                       i += 4
+               case WireFixed64:
+                       if len(b)-8 < i {
+                               return -1, -1
+                       }
+                       i += 8
+               case WireBytes:
+                       m, k := decodeVarint(b[i:])
+                       if k == 0 {
+                               return -1, -1
+                       }
+                       i += k
+                       if uint64(len(b)-i) < m {
+                               return -1, -1
+                       }
+                       i += int(m)
+               case WireStartGroup:
+                       depth++
+               case WireEndGroup:
+                       depth--
+                       if depth == 0 {
+                               return j, i
+                       }
+               default:
+                       return -1, -1
+               }
+       }
+}
+
+// encodeVarint appends a varint-encoded integer to b and returns the result.
+func encodeVarint(b []byte, x uint64) []byte {
+       for x >= 1<<7 {
+               b = append(b, byte(x&0x7f|0x80))
+               x >>= 7
+       }
+       return append(b, byte(x))
+}
+
+// decodeVarint reads a varint-encoded integer from b.
+// Returns the decoded integer and the number of bytes read.
+// If there is an error, it returns 0,0.
+func decodeVarint(b []byte) (uint64, int) {
+       var x, y uint64
+       if len(b) == 0 {
+               goto bad
+       }
+       x = uint64(b[0])
+       if x < 0x80 {
+               return x, 1
+       }
+       x -= 0x80
+
+       if len(b) <= 1 {
+               goto bad
+       }
+       y = uint64(b[1])
+       x += y << 7
+       if y < 0x80 {
+               return x, 2
+       }
+       x -= 0x80 << 7
+
+       if len(b) <= 2 {
+               goto bad
+       }
+       y = uint64(b[2])
+       x += y << 14
+       if y < 0x80 {
+               return x, 3
+       }
+       x -= 0x80 << 14
+
+       if len(b) <= 3 {
+               goto bad
+       }
+       y = uint64(b[3])
+       x += y << 21
+       if y < 0x80 {
+               return x, 4
+       }
+       x -= 0x80 << 21
+
+       if len(b) <= 4 {
+               goto bad
+       }
+       y = uint64(b[4])
+       x += y << 28
+       if y < 0x80 {
+               return x, 5
+       }
+       x -= 0x80 << 28
+
+       if len(b) <= 5 {
+               goto bad
+       }
+       y = uint64(b[5])
+       x += y << 35
+       if y < 0x80 {
+               return x, 6
+       }
+       x -= 0x80 << 35
+
+       if len(b) <= 6 {
+               goto bad
+       }
+       y = uint64(b[6])
+       x += y << 42
+       if y < 0x80 {
+               return x, 7
+       }
+       x -= 0x80 << 42
+
+       if len(b) <= 7 {
+               goto bad
+       }
+       y = uint64(b[7])
+       x += y << 49
+       if y < 0x80 {
+               return x, 8
+       }
+       x -= 0x80 << 49
+
+       if len(b) <= 8 {
+               goto bad
+       }
+       y = uint64(b[8])
+       x += y << 56
+       if y < 0x80 {
+               return x, 9
+       }
+       x -= 0x80 << 56
+
+       if len(b) <= 9 {
+               goto bad
+       }
+       y = uint64(b[9])
+       x += y << 63
+       if y < 2 {
+               return x, 10
+       }
+
+bad:
+       return 0, 0
+}

diff --git a/vendor/github.com/gogo/protobuf/proto/table_unmarshal_gogo.go b/vendor/github.com/gogo/protobuf/proto/table_unmarshal_gogo.go
new file mode 100644 (file)
index 0000000..00d6c7a
--- /dev/null
+++ b/vendor/github.com/gogo/protobuf/proto/table_unmarshal_gogo.go
@@ -0,0 +1,385 @@
+// Protocol Buffers for Go with Gadgets
+//
+// Copyright (c) 2018, The GoGo Authors. All rights reserved.
+// http://github.com/gogo/protobuf
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//     * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//     * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+package proto
+
+import (
+       "io"
+       "reflect"
+)
+
+func makeUnmarshalMessage(sub *unmarshalInfo, name string) unmarshaler {
+       return func(b []byte, f pointer, w int) ([]byte, error) {
+               if w != WireBytes {
+                       return nil, errInternalBadWireType
+               }
+               x, n := decodeVarint(b)
+               if n == 0 {
+                       return nil, io.ErrUnexpectedEOF
+               }
+               b = b[n:]
+               if x > uint64(len(b)) {
+                       return nil, io.ErrUnexpectedEOF
+               }
+               // First read the message field to see if something is there.
+               // The semantics of multiple submessages are weird.  Instead of
+               // the last one winning (as it is for all other fields), multiple
+               // submessages are merged.
+               v := f // gogo: changed from v := f.getPointer()
+               if v.isNil() {
+                       v = valToPointer(reflect.New(sub.typ))
+                       f.setPointer(v)
+               }
+               err := sub.unmarshal(v, b[:x])
+               if err != nil {
+                       if r, ok := err.(*RequiredNotSetError); ok {
+                               r.field = name + "." + r.field
+                       } else {
+                               return nil, err
+                       }
+               }
+               return b[x:], err
+       }
+}
+
+func makeUnmarshalMessageSlice(sub *unmarshalInfo, name string) unmarshaler {
+       return func(b []byte, f pointer, w int) ([]byte, error) {
+               if w != WireBytes {
+                       return nil, errInternalBadWireType
+               }
+               x, n := decodeVarint(b)
+               if n == 0 {
+                       return nil, io.ErrUnexpectedEOF
+               }
+               b = b[n:]
+               if x > uint64(len(b)) {
+                       return nil, io.ErrUnexpectedEOF
+               }
+               v := valToPointer(reflect.New(sub.typ))
+               err := sub.unmarshal(v, b[:x])
+               if err != nil {
+                       if r, ok := err.(*RequiredNotSetError); ok {
+                               r.field = name + "." + r.field
+                       } else {
+                               return nil, err
+                       }
+               }
+               f.appendRef(v, sub.typ) // gogo: changed from f.appendPointer(v)
+               return b[x:], err
+       }
+}
+
+func makeUnmarshalCustomPtr(sub *unmarshalInfo, name string) unmarshaler {
+       return func(b []byte, f pointer, w int) ([]byte, error) {
+               if w != WireBytes {
+                       return nil, errInternalBadWireType
+               }
+               x, n := decodeVarint(b)
+               if n == 0 {
+                       return nil, io.ErrUnexpectedEOF
+               }
+               b = b[n:]
+               if x > uint64(len(b)) {
+                       return nil, io.ErrUnexpectedEOF
+               }
+
+               s := f.asPointerTo(reflect.PtrTo(sub.typ)).Elem()
+               s.Set(reflect.New(sub.typ))
+               m := s.Interface().(custom)
+               if err := m.Unmarshal(b[:x]); err != nil {
+                       return nil, err
+               }
+               return b[x:], nil
+       }
+}
+
+func makeUnmarshalCustomSlice(sub *unmarshalInfo, name string) unmarshaler {
+       return func(b []byte, f pointer, w int) ([]byte, error) {
+               if w != WireBytes {
+                       return nil, errInternalBadWireType
+               }
+               x, n := decodeVarint(b)
+               if n == 0 {
+                       return nil, io.ErrUnexpectedEOF
+               }
+               b = b[n:]
+               if x > uint64(len(b)) {
+                       return nil, io.ErrUnexpectedEOF
+               }
+               m := reflect.New(sub.typ)
+               c := m.Interface().(custom)
+               if err := c.Unmarshal(b[:x]); err != nil {
+                       return nil, err
+               }
+               v := valToPointer(m)
+               f.appendRef(v, sub.typ)
+               return b[x:], nil
+       }
+}
+
+func makeUnmarshalCustom(sub *unmarshalInfo, name string) unmarshaler {
+       return func(b []byte, f pointer, w int) ([]byte, error) {
+               if w != WireBytes {
+                       return nil, errInternalBadWireType
+               }
+               x, n := decodeVarint(b)
+               if n == 0 {
+                       return nil, io.ErrUnexpectedEOF
+               }
+               b = b[n:]
+               if x > uint64(len(b)) {
+                       return nil, io.ErrUnexpectedEOF
+               }
+
+               m := f.asPointerTo(sub.typ).Interface().(custom)
+               if err := m.Unmarshal(b[:x]); err != nil {
+                       return nil, err
+               }
+               return b[x:], nil
+       }
+}
+
+func makeUnmarshalTime(sub *unmarshalInfo, name string) unmarshaler {
+       return func(b []byte, f pointer, w int) ([]byte, error) {
+               if w != WireBytes {
+                       return nil, errInternalBadWireType
+               }
+               x, n := decodeVarint(b)
+               if n == 0 {
+                       return nil, io.ErrUnexpectedEOF
+               }
+               b = b[n:]
+               if x > uint64(len(b)) {
+                       return nil, io.ErrUnexpectedEOF
+               }
+               m := &timestamp{}
+               if err := Unmarshal(b[:x], m); err != nil {
+                       return nil, err
+               }
+               t, err := timestampFromProto(m)
+               if err != nil {
+                       return nil, err
+               }
+               s := f.asPointerTo(sub.typ).Elem()
+               s.Set(reflect.ValueOf(t))
+               return b[x:], nil
+       }
+}
+
+func makeUnmarshalTimePtr(sub *unmarshalInfo, name string) unmarshaler {
+       return func(b []byte, f pointer, w int) ([]byte, error) {
+               if w != WireBytes {
+                       return nil, errInternalBadWireType
+               }
+               x, n := decodeVarint(b)
+               if n == 0 {
+                       return nil, io.ErrUnexpectedEOF
+               }
+               b = b[n:]
+               if x > uint64(len(b)) {
+                       return nil, io.ErrUnexpectedEOF
+               }
+               m := &timestamp{}
+               if err := Unmarshal(b[:x], m); err != nil {
+                       return nil, err
+               }
+               t, err := timestampFromProto(m)
+               if err != nil {
+                       return nil, err
+               }
+               s := f.asPointerTo(reflect.PtrTo(sub.typ)).Elem()
+               s.Set(reflect.ValueOf(&t))
+               return b[x:], nil
+       }
+}
+
+func makeUnmarshalTimePtrSlice(sub *unmarshalInfo, name string) unmarshaler {
+       return func(b []byte, f pointer, w int) ([]byte, error) {
+               if w != WireBytes {
+                       return nil, errInternalBadWireType
+               }
+               x, n := decodeVarint(b)
+               if n == 0 {
+                       return nil, io.ErrUnexpectedEOF
+               }
+               b = b[n:]
+               if x > uint64(len(b)) {
+                       return nil, io.ErrUnexpectedEOF
+               }
+               m := &timestamp{}
+               if err := Unmarshal(b[:x], m); err != nil {
+                       return nil, err
+               }
+               t, err := timestampFromProto(m)
+               if err != nil {
+                       return nil, err
+               }
+               slice := f.getSlice(reflect.PtrTo(sub.typ))
+               newSlice := reflect.Append(slice, reflect.ValueOf(&t))
+               slice.Set(newSlice)
+               return b[x:], nil
+       }
+}
+
+func makeUnmarshalTimeSlice(sub *unmarshalInfo, name string) unmarshaler {
+       return func(b []byte, f pointer, w int) ([]byte, error) {
+               if w != WireBytes {
+                       return nil, errInternalBadWireType
+               }
+               x, n := decodeVarint(b)
+               if n == 0 {
+                       return nil, io.ErrUnexpectedEOF
+               }
+               b = b[n:]
+               if x > uint64(len(b)) {
+                       return nil, io.ErrUnexpectedEOF
+               }
+               m := &timestamp{}
+               if err := Unmarshal(b[:x], m); err != nil {
+                       return nil, err
+               }
+               t, err := timestampFromProto(m)
+               if err != nil {
+                       return nil, err
+               }
+               slice := f.getSlice(sub.typ)
+               newSlice := reflect.Append(slice, reflect.ValueOf(t))
+               slice.Set(newSlice)
+               return b[x:], nil
+       }
+}
+
+func makeUnmarshalDurationPtr(sub *unmarshalInfo, name string) unmarshaler {
+       return func(b []byte, f pointer, w int) ([]byte, error) {
+               if w != WireBytes {
+                       return nil, errInternalBadWireType
+               }
+               x, n := decodeVarint(b)
+               if n == 0 {
+                       return nil, io.ErrUnexpectedEOF
+               }
+               b = b[n:]
+               if x > uint64(len(b)) {
+                       return nil, io.ErrUnexpectedEOF
+               }
+               m := &duration{}
+               if err := Unmarshal(b[:x], m); err != nil {
+                       return nil, err
+               }
+               d, err := durationFromProto(m)
+               if err != nil {
+                       return nil, err
+               }
+               s := f.asPointerTo(reflect.PtrTo(sub.typ)).Elem()
+               s.Set(reflect.ValueOf(&d))
+               return b[x:], nil
+       }
+}
+
+func makeUnmarshalDuration(sub *unmarshalInfo, name string) unmarshaler {
+       return func(b []byte, f pointer, w int) ([]byte, error) {
+               if w != WireBytes {
+                       return nil, errInternalBadWireType
+               }
+               x, n := decodeVarint(b)
+               if n == 0 {
+                       return nil, io.ErrUnexpectedEOF
+               }
+               b = b[n:]
+               if x > uint64(len(b)) {
+                       return nil, io.ErrUnexpectedEOF
+               }
+               m := &duration{}
+               if err := Unmarshal(b[:x], m); err != nil {
+                       return nil, err
+               }
+               d, err := durationFromProto(m)
+               if err != nil {
+                       return nil, err
+               }
+               s := f.asPointerTo(sub.typ).Elem()
+               s.Set(reflect.ValueOf(d))
+               return b[x:], nil
+       }
+}
+
+func makeUnmarshalDurationPtrSlice(sub *unmarshalInfo, name string) unmarshaler {
+       return func(b []byte, f pointer, w int) ([]byte, error) {
+               if w != WireBytes {
+                       return nil, errInternalBadWireType
+               }
+               x, n := decodeVarint(b)
+               if n == 0 {
+                       return nil, io.ErrUnexpectedEOF
+               }
+               b = b[n:]
+               if x > uint64(len(b)) {
+                       return nil, io.ErrUnexpectedEOF
+               }
+               m := &duration{}
+               if err := Unmarshal(b[:x], m); err != nil {
+                       return nil, err
+               }
+               d, err := durationFromProto(m)
+               if err != nil {
+                       return nil, err
+               }
+               slice := f.getSlice(reflect.PtrTo(sub.typ))
+               newSlice := reflect.Append(slice, reflect.ValueOf(&d))
+               slice.Set(newSlice)
+               return b[x:], nil
+       }
+}
+
+func makeUnmarshalDurationSlice(sub *unmarshalInfo, name string) unmarshaler {
+       return func(b []byte, f pointer, w int) ([]byte, error) {
+               if w != WireBytes {
+                       return nil, errInternalBadWireType
+               }
+               x, n := decodeVarint(b)
+               if n == 0 {
+                       return nil, io.ErrUnexpectedEOF
+               }
+               b = b[n:]
+               if x > uint64(len(b)) {
+                       return nil, io.ErrUnexpectedEOF
+               }
+               m := &duration{}
+               if err := Unmarshal(b[:x], m); err != nil {
+                       return nil, err
+               }
+               d, err := durationFromProto(m)
+               if err != nil {
+                       return nil, err
+               }
+               slice := f.getSlice(sub.typ)
+               newSlice := reflect.Append(slice, reflect.ValueOf(d))
+               slice.Set(newSlice)
+               return b[x:], nil
+       }
+}

diff --git a/vendor/github.com/gogo/protobuf/proto/test_proto/Makefile b/vendor/github.com/gogo/protobuf/proto/test_proto/Makefile
new file mode 100644 (file)
index 0000000..e71c21a
--- /dev/null
+++ b/vendor/github.com/gogo/protobuf/proto/test_proto/Makefile
@@ -0,0 +1,37 @@
+# Go support for Protocol Buffers - Google's data interchange format
+#
+# Copyright 2010 The Go Authors.  All rights reserved.
+# https://github.com/golang/protobuf
+#
+# Redistribution and use in source and binary forms, with or without
+# modification, are permitted provided that the following conditions are
+# met:
+#
+#     * Redistributions of source code must retain the above copyright
+# notice, this list of conditions and the following disclaimer.
+#     * Redistributions in binary form must reproduce the above
+# copyright notice, this list of conditions and the following disclaimer
+# in the documentation and/or other materials provided with the
+# distribution.
+#     * Neither the name of Google Inc. nor the names of its
+# contributors may be used to endorse or promote products derived from
+# this software without specific prior written permission.
+#
+# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+# "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+# LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+# A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+# OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+# SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+# LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+# DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+# THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+# (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+# OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+all:   regenerate
+
+regenerate:
+       go install github.com/gogo/protobuf/protoc-min-version
+       protoc-min-version --version="3.0.0" --gogo_out=paths=source_relative:. test.proto
+       

diff --git a/vendor/github.com/gogo/protobuf/proto/test_proto/test.pb.go b/vendor/github.com/gogo/protobuf/proto/test_proto/test.pb.go
new file mode 100644 (file)
index 0000000..b3fa226
--- /dev/null
+++ b/vendor/github.com/gogo/protobuf/proto/test_proto/test.pb.go
@@ -0,0 +1,5291 @@
+// Code generated by protoc-gen-gogo. DO NOT EDIT.
+// source: test.proto
+
+package test_proto
+
+import (
+       fmt "fmt"
+       proto "github.com/gogo/protobuf/proto"
+       math "math"
+)
+
+// Reference imports to suppress errors if they are not otherwise used.
+var _ = proto.Marshal
+var _ = fmt.Errorf
+var _ = math.Inf
+
+// This is a compile-time assertion to ensure that this generated file
+// is compatible with the proto package it is being compiled against.
+// A compilation error at this line likely means your copy of the
+// proto package needs to be updated.
+const _ = proto.GoGoProtoPackageIsVersion2 // please upgrade the proto package
+
+type FOO int32
+
+const (
+       FOO_FOO1 FOO = 1
+)
+
+var FOO_name = map[int32]string{
+       1: "FOO1",
+}
+
+var FOO_value = map[string]int32{
+       "FOO1": 1,
+}
+
+func (x FOO) Enum() *FOO {
+       p := new(FOO)
+       *p = x
+       return p
+}
+
+func (x FOO) String() string {
+       return proto.EnumName(FOO_name, int32(x))
+}
+
+func (x *FOO) UnmarshalJSON(data []byte) error {
+       value, err := proto.UnmarshalJSONEnum(FOO_value, data, "FOO")
+       if err != nil {
+               return err
+       }
+       *x = FOO(value)
+       return nil
+}
+
+func (FOO) EnumDescriptor() ([]byte, []int) {
+       return fileDescriptor_c161fcfdc0c3ff1e, []int{0}
+}
+
+// An enum, for completeness.
+type GoTest_KIND int32
+
+const (
+       GoTest_VOID GoTest_KIND = 0
+       // Basic types
+       GoTest_BOOL        GoTest_KIND = 1
+       GoTest_BYTES       GoTest_KIND = 2
+       GoTest_FINGERPRINT GoTest_KIND = 3
+       GoTest_FLOAT       GoTest_KIND = 4
+       GoTest_INT         GoTest_KIND = 5
+       GoTest_STRING      GoTest_KIND = 6
+       GoTest_TIME        GoTest_KIND = 7
+       // Groupings
+       GoTest_TUPLE GoTest_KIND = 8
+       GoTest_ARRAY GoTest_KIND = 9
+       GoTest_MAP   GoTest_KIND = 10
+       // Table types
+       GoTest_TABLE GoTest_KIND = 11
+       // Functions
+       GoTest_FUNCTION GoTest_KIND = 12
+)
+
+var GoTest_KIND_name = map[int32]string{
+       0:  "VOID",
+       1:  "BOOL",
+       2:  "BYTES",
+       3:  "FINGERPRINT",
+       4:  "FLOAT",
+       5:  "INT",
+       6:  "STRING",
+       7:  "TIME",
+       8:  "TUPLE",
+       9:  "ARRAY",
+       10: "MAP",
+       11: "TABLE",
+       12: "FUNCTION",
+}
+
+var GoTest_KIND_value = map[string]int32{
+       "VOID":        0,
+       "BOOL":        1,
+       "BYTES":       2,
+       "FINGERPRINT": 3,
+       "FLOAT":       4,
+       "INT":         5,
+       "STRING":      6,
+       "TIME":        7,
+       "TUPLE":       8,
+       "ARRAY":       9,
+       "MAP":         10,
+       "TABLE":       11,
+       "FUNCTION":    12,
+}
+
+func (x GoTest_KIND) Enum() *GoTest_KIND {
+       p := new(GoTest_KIND)
+       *p = x
+       return p
+}
+
+func (x GoTest_KIND) String() string {
+       return proto.EnumName(GoTest_KIND_name, int32(x))
+}
+
+func (x *GoTest_KIND) UnmarshalJSON(data []byte) error {
+       value, err := proto.UnmarshalJSONEnum(GoTest_KIND_value, data, "GoTest_KIND")
+       if err != nil {
+               return err
+       }
+       *x = GoTest_KIND(value)
+       return nil
+}
+
+func (GoTest_KIND) EnumDescriptor() ([]byte, []int) {
+       return fileDescriptor_c161fcfdc0c3ff1e, []int{2, 0}
+}
+
+type MyMessage_Color int32
+
+const (
+       MyMessage_RED   MyMessage_Color = 0
+       MyMessage_GREEN MyMessage_Color = 1
+       MyMessage_BLUE  MyMessage_Color = 2
+)
+
+var MyMessage_Color_name = map[int32]string{
+       0: "RED",
+       1: "GREEN",
+       2: "BLUE",
+}
+
+var MyMessage_Color_value = map[string]int32{
+       "RED":   0,
+       "GREEN": 1,
+       "BLUE":  2,
+}
+
+func (x MyMessage_Color) Enum() *MyMessage_Color {
+       p := new(MyMessage_Color)
+       *p = x
+       return p
+}
+
+func (x MyMessage_Color) String() string {
+       return proto.EnumName(MyMessage_Color_name, int32(x))
+}
+
+func (x *MyMessage_Color) UnmarshalJSON(data []byte) error {
+       value, err := proto.UnmarshalJSONEnum(MyMessage_Color_value, data, "MyMessage_Color")
+       if err != nil {
+               return err
+       }
+       *x = MyMessage_Color(value)
+       return nil
+}
+
+func (MyMessage_Color) EnumDescriptor() ([]byte, []int) {
+       return fileDescriptor_c161fcfdc0c3ff1e, []int{13, 0}
+}
+
+type DefaultsMessage_DefaultsEnum int32
+
+const (
+       DefaultsMessage_ZERO DefaultsMessage_DefaultsEnum = 0
+       DefaultsMessage_ONE  DefaultsMessage_DefaultsEnum = 1
+       DefaultsMessage_TWO  DefaultsMessage_DefaultsEnum = 2
+)
+
+var DefaultsMessage_DefaultsEnum_name = map[int32]string{
+       0: "ZERO",
+       1: "ONE",
+       2: "TWO",
+}
+
+var DefaultsMessage_DefaultsEnum_value = map[string]int32{
+       "ZERO": 0,
+       "ONE":  1,
+       "TWO":  2,
+}
+
+func (x DefaultsMessage_DefaultsEnum) Enum() *DefaultsMessage_DefaultsEnum {
+       p := new(DefaultsMessage_DefaultsEnum)
+       *p = x
+       return p
+}
+
+func (x DefaultsMessage_DefaultsEnum) String() string {
+       return proto.EnumName(DefaultsMessage_DefaultsEnum_name, int32(x))
+}
+
+func (x *DefaultsMessage_DefaultsEnum) UnmarshalJSON(data []byte) error {
+       value, err := proto.UnmarshalJSONEnum(DefaultsMessage_DefaultsEnum_value, data, "DefaultsMessage_DefaultsEnum")
+       if err != nil {
+               return err
+       }
+       *x = DefaultsMessage_DefaultsEnum(value)
+       return nil
+}
+
+func (DefaultsMessage_DefaultsEnum) EnumDescriptor() ([]byte, []int) {
+       return fileDescriptor_c161fcfdc0c3ff1e, []int{16, 0}
+}
+
+type Defaults_Color int32
+
+const (
+       Defaults_RED   Defaults_Color = 0
+       Defaults_GREEN Defaults_Color = 1
+       Defaults_BLUE  Defaults_Color = 2
+)
+
+var Defaults_Color_name = map[int32]string{
+       0: "RED",
+       1: "GREEN",
+       2: "BLUE",
+}
+
+var Defaults_Color_value = map[string]int32{
+       "RED":   0,
+       "GREEN": 1,
+       "BLUE":  2,
+}
+
+func (x Defaults_Color) Enum() *Defaults_Color {
+       p := new(Defaults_Color)
+       *p = x
+       return p
+}
+
+func (x Defaults_Color) String() string {
+       return proto.EnumName(Defaults_Color_name, int32(x))
+}
+
+func (x *Defaults_Color) UnmarshalJSON(data []byte) error {
+       value, err := proto.UnmarshalJSONEnum(Defaults_Color_value, data, "Defaults_Color")
+       if err != nil {
+               return err
+       }
+       *x = Defaults_Color(value)
+       return nil
+}
+
+func (Defaults_Color) EnumDescriptor() ([]byte, []int) {
+       return fileDescriptor_c161fcfdc0c3ff1e, []int{21, 0}
+}
+
+type RepeatedEnum_Color int32
+
+const (
+       RepeatedEnum_RED RepeatedEnum_Color = 1
+)
+
+var RepeatedEnum_Color_name = map[int32]string{
+       1: "RED",
+}
+
+var RepeatedEnum_Color_value = map[string]int32{
+       "RED": 1,
+}
+
+func (x RepeatedEnum_Color) Enum() *RepeatedEnum_Color {
+       p := new(RepeatedEnum_Color)
+       *p = x
+       return p
+}
+
+func (x RepeatedEnum_Color) String() string {
+       return proto.EnumName(RepeatedEnum_Color_name, int32(x))
+}
+
+func (x *RepeatedEnum_Color) UnmarshalJSON(data []byte) error {
+       value, err := proto.UnmarshalJSONEnum(RepeatedEnum_Color_value, data, "RepeatedEnum_Color")
+       if err != nil {
+               return err
+       }
+       *x = RepeatedEnum_Color(value)
+       return nil
+}
+
+func (RepeatedEnum_Color) EnumDescriptor() ([]byte, []int) {
+       return fileDescriptor_c161fcfdc0c3ff1e, []int{23, 0}
+}
+
+type GoEnum struct {
+       Foo                  *FOO     `protobuf:"varint,1,req,name=foo,enum=test_proto.FOO" json:"foo,omitempty"`
+       XXX_NoUnkeyedLiteral struct{} `json:"-"`
+       XXX_unrecognized     []byte   `json:"-"`
+       XXX_sizecache        int32    `json:"-"`
+}
+
+func (m *GoEnum) Reset()         { *m = GoEnum{} }
+func (m *GoEnum) String() string { return proto.CompactTextString(m) }
+func (*GoEnum) ProtoMessage()    {}
+func (*GoEnum) Descriptor() ([]byte, []int) {
+       return fileDescriptor_c161fcfdc0c3ff1e, []int{0}
+}
+func (m *GoEnum) XXX_Unmarshal(b []byte) error {
+       return xxx_messageInfo_GoEnum.Unmarshal(m, b)
+}
+func (m *GoEnum) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+       return xxx_messageInfo_GoEnum.Marshal(b, m, deterministic)
+}
+func (m *GoEnum) XXX_Merge(src proto.Message) {
+       xxx_messageInfo_GoEnum.Merge(m, src)
+}
+func (m *GoEnum) XXX_Size() int {
+       return xxx_messageInfo_GoEnum.Size(m)
+}
+func (m *GoEnum) XXX_DiscardUnknown() {
+       xxx_messageInfo_GoEnum.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_GoEnum proto.InternalMessageInfo
+
+func (m *GoEnum) GetFoo() FOO {
+       if m != nil && m.Foo != nil {
+               return *m.Foo
+       }
+       return FOO_FOO1
+}
+
+type GoTestField struct {
+       Label                *string  `protobuf:"bytes,1,req,name=Label" json:"Label,omitempty"`
+       Type                 *string  `protobuf:"bytes,2,req,name=Type" json:"Type,omitempty"`
+       XXX_NoUnkeyedLiteral struct{} `json:"-"`
+       XXX_unrecognized     []byte   `json:"-"`
+       XXX_sizecache        int32    `json:"-"`
+}
+
+func (m *GoTestField) Reset()         { *m = GoTestField{} }
+func (m *GoTestField) String() string { return proto.CompactTextString(m) }
+func (*GoTestField) ProtoMessage()    {}
+func (*GoTestField) Descriptor() ([]byte, []int) {
+       return fileDescriptor_c161fcfdc0c3ff1e, []int{1}
+}
+func (m *GoTestField) XXX_Unmarshal(b []byte) error {
+       return xxx_messageInfo_GoTestField.Unmarshal(m, b)
+}
+func (m *GoTestField) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+       return xxx_messageInfo_GoTestField.Marshal(b, m, deterministic)
+}
+func (m *GoTestField) XXX_Merge(src proto.Message) {
+       xxx_messageInfo_GoTestField.Merge(m, src)
+}
+func (m *GoTestField) XXX_Size() int {
+       return xxx_messageInfo_GoTestField.Size(m)
+}
+func (m *GoTestField) XXX_DiscardUnknown() {
+       xxx_messageInfo_GoTestField.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_GoTestField proto.InternalMessageInfo
+
+func (m *GoTestField) GetLabel() string {
+       if m != nil && m.Label != nil {
+               return *m.Label
+       }
+       return ""
+}
+
+func (m *GoTestField) GetType() string {
+       if m != nil && m.Type != nil {
+               return *m.Type
+       }
+       return ""
+}
+
+type GoTest struct {
+       // Some typical parameters
+       Kind  *GoTest_KIND `protobuf:"varint,1,req,name=Kind,enum=test_proto.GoTest_KIND" json:"Kind,omitempty"`
+       Table *string      `protobuf:"bytes,2,opt,name=Table" json:"Table,omitempty"`
+       Param *int32       `protobuf:"varint,3,opt,name=Param" json:"Param,omitempty"`
+       // Required, repeated and optional foreign fields.
+       RequiredField *GoTestField   `protobuf:"bytes,4,req,name=RequiredField" json:"RequiredField,omitempty"`
+       RepeatedField []*GoTestField `protobuf:"bytes,5,rep,name=RepeatedField" json:"RepeatedField,omitempty"`
+       OptionalField *GoTestField   `protobuf:"bytes,6,opt,name=OptionalField" json:"OptionalField,omitempty"`
+       // Required fields of all basic types
+       F_BoolRequired     *bool    `protobuf:"varint,10,req,name=F_Bool_required,json=FBoolRequired" json:"F_Bool_required,omitempty"`
+       F_Int32Required    *int32   `protobuf:"varint,11,req,name=F_Int32_required,json=FInt32Required" json:"F_Int32_required,omitempty"`
+       F_Int64Required    *int64   `protobuf:"varint,12,req,name=F_Int64_required,json=FInt64Required" json:"F_Int64_required,omitempty"`
+       F_Fixed32Required  *uint32  `protobuf:"fixed32,13,req,name=F_Fixed32_required,json=FFixed32Required" json:"F_Fixed32_required,omitempty"`
+       F_Fixed64Required  *uint64  `protobuf:"fixed64,14,req,name=F_Fixed64_required,json=FFixed64Required" json:"F_Fixed64_required,omitempty"`
+       F_Uint32Required   *uint32  `protobuf:"varint,15,req,name=F_Uint32_required,json=FUint32Required" json:"F_Uint32_required,omitempty"`
+       F_Uint64Required   *uint64  `protobuf:"varint,16,req,name=F_Uint64_required,json=FUint64Required" json:"F_Uint64_required,omitempty"`
+       F_FloatRequired    *float32 `protobuf:"fixed32,17,req,name=F_Float_required,json=FFloatRequired" json:"F_Float_required,omitempty"`
+       F_DoubleRequired   *float64 `protobuf:"fixed64,18,req,name=F_Double_required,json=FDoubleRequired" json:"F_Double_required,omitempty"`
+       F_StringRequired   *string  `protobuf:"bytes,19,req,name=F_String_required,json=FStringRequired" json:"F_String_required,omitempty"`
+       F_BytesRequired    []byte   `protobuf:"bytes,101,req,name=F_Bytes_required,json=FBytesRequired" json:"F_Bytes_required,omitempty"`
+       F_Sint32Required   *int32   `protobuf:"zigzag32,102,req,name=F_Sint32_required,json=FSint32Required" json:"F_Sint32_required,omitempty"`
+       F_Sint64Required   *int64   `protobuf:"zigzag64,103,req,name=F_Sint64_required,json=FSint64Required" json:"F_Sint64_required,omitempty"`
+       F_Sfixed32Required *int32   `protobuf:"fixed32,104,req,name=F_Sfixed32_required,json=FSfixed32Required" json:"F_Sfixed32_required,omitempty"`
+       F_Sfixed64Required *int64   `protobuf:"fixed64,105,req,name=F_Sfixed64_required,json=FSfixed64Required" json:"F_Sfixed64_required,omitempty"`
+       // Repeated fields of all basic types
+       F_BoolRepeated     []bool    `protobuf:"varint,20,rep,name=F_Bool_repeated,json=FBoolRepeated" json:"F_Bool_repeated,omitempty"`
+       F_Int32Repeated    []int32   `protobuf:"varint,21,rep,name=F_Int32_repeated,json=FInt32Repeated" json:"F_Int32_repeated,omitempty"`
+       F_Int64Repeated    []int64   `protobuf:"varint,22,rep,name=F_Int64_repeated,json=FInt64Repeated" json:"F_Int64_repeated,omitempty"`
+       F_Fixed32Repeated  []uint32  `protobuf:"fixed32,23,rep,name=F_Fixed32_repeated,json=FFixed32Repeated" json:"F_Fixed32_repeated,omitempty"`
+       F_Fixed64Repeated  []uint64  `protobuf:"fixed64,24,rep,name=F_Fixed64_repeated,json=FFixed64Repeated" json:"F_Fixed64_repeated,omitempty"`
+       F_Uint32Repeated   []uint32  `protobuf:"varint,25,rep,name=F_Uint32_repeated,json=FUint32Repeated" json:"F_Uint32_repeated,omitempty"`
+       F_Uint64Repeated   []uint64  `protobuf:"varint,26,rep,name=F_Uint64_repeated,json=FUint64Repeated" json:"F_Uint64_repeated,omitempty"`
+       F_FloatRepeated    []float32 `protobuf:"fixed32,27,rep,name=F_Float_repeated,json=FFloatRepeated" json:"F_Float_repeated,omitempty"`
+       F_DoubleRepeated   []float64 `protobuf:"fixed64,28,rep,name=F_Double_repeated,json=FDoubleRepeated" json:"F_Double_repeated,omitempty"`
+       F_StringRepeated   []string  `protobuf:"bytes,29,rep,name=F_String_repeated,json=FStringRepeated" json:"F_String_repeated,omitempty"`
+       F_BytesRepeated    [][]byte  `protobuf:"bytes,201,rep,name=F_Bytes_repeated,json=FBytesRepeated" json:"F_Bytes_repeated,omitempty"`
+       F_Sint32Repeated   []int32   `protobuf:"zigzag32,202,rep,name=F_Sint32_repeated,json=FSint32Repeated" json:"F_Sint32_repeated,omitempty"`
+       F_Sint64Repeated   []int64   `protobuf:"zigzag64,203,rep,name=F_Sint64_repeated,json=FSint64Repeated" json:"F_Sint64_repeated,omitempty"`
+       F_Sfixed32Repeated []int32   `protobuf:"fixed32,204,rep,name=F_Sfixed32_repeated,json=FSfixed32Repeated" json:"F_Sfixed32_repeated,omitempty"`
+       F_Sfixed64Repeated []int64   `protobuf:"fixed64,205,rep,name=F_Sfixed64_repeated,json=FSfixed64Repeated" json:"F_Sfixed64_repeated,omitempty"`
+       // Optional fields of all basic types
+       F_BoolOptional     *bool    `protobuf:"varint,30,opt,name=F_Bool_optional,json=FBoolOptional" json:"F_Bool_optional,omitempty"`
+       F_Int32Optional    *int32   `protobuf:"varint,31,opt,name=F_Int32_optional,json=FInt32Optional" json:"F_Int32_optional,omitempty"`
+       F_Int64Optional    *int64   `protobuf:"varint,32,opt,name=F_Int64_optional,json=FInt64Optional" json:"F_Int64_optional,omitempty"`
+       F_Fixed32Optional  *uint32  `protobuf:"fixed32,33,opt,name=F_Fixed32_optional,json=FFixed32Optional" json:"F_Fixed32_optional,omitempty"`
+       F_Fixed64Optional  *uint64  `protobuf:"fixed64,34,opt,name=F_Fixed64_optional,json=FFixed64Optional" json:"F_Fixed64_optional,omitempty"`
+       F_Uint32Optional   *uint32  `protobuf:"varint,35,opt,name=F_Uint32_optional,json=FUint32Optional" json:"F_Uint32_optional,omitempty"`
+       F_Uint64Optional   *uint64  `protobuf:"varint,36,opt,name=F_Uint64_optional,json=FUint64Optional" json:"F_Uint64_optional,omitempty"`
+       F_FloatOptional    *float32 `protobuf:"fixed32,37,opt,name=F_Float_optional,json=FFloatOptional" json:"F_Float_optional,omitempty"`
+       F_DoubleOptional   *float64 `protobuf:"fixed64,38,opt,name=F_Double_optional,json=FDoubleOptional" json:"F_Double_optional,omitempty"`
+       F_StringOptional   *string  `protobuf:"bytes,39,opt,name=F_String_optional,json=FStringOptional" json:"F_String_optional,omitempty"`
+       F_BytesOptional    []byte   `protobuf:"bytes,301,opt,name=F_Bytes_optional,json=FBytesOptional" json:"F_Bytes_optional,omitempty"`
+       F_Sint32Optional   *int32   `protobuf:"zigzag32,302,opt,name=F_Sint32_optional,json=FSint32Optional" json:"F_Sint32_optional,omitempty"`
+       F_Sint64Optional   *int64   `protobuf:"zigzag64,303,opt,name=F_Sint64_optional,json=FSint64Optional" json:"F_Sint64_optional,omitempty"`
+       F_Sfixed32Optional *int32   `protobuf:"fixed32,304,opt,name=F_Sfixed32_optional,json=FSfixed32Optional" json:"F_Sfixed32_optional,omitempty"`
+       F_Sfixed64Optional *int64   `protobuf:"fixed64,305,opt,name=F_Sfixed64_optional,json=FSfixed64Optional" json:"F_Sfixed64_optional,omitempty"`
+       // Default-valued fields of all basic types
+       F_BoolDefaulted     *bool    `protobuf:"varint,40,opt,name=F_Bool_defaulted,json=FBoolDefaulted,def=1" json:"F_Bool_defaulted,omitempty"`
+       F_Int32Defaulted    *int32   `protobuf:"varint,41,opt,name=F_Int32_defaulted,json=FInt32Defaulted,def=32" json:"F_Int32_defaulted,omitempty"`
+       F_Int64Defaulted    *int64   `protobuf:"varint,42,opt,name=F_Int64_defaulted,json=FInt64Defaulted,def=64" json:"F_Int64_defaulted,omitempty"`
+       F_Fixed32Defaulted  *uint32  `protobuf:"fixed32,43,opt,name=F_Fixed32_defaulted,json=FFixed32Defaulted,def=320" json:"F_Fixed32_defaulted,omitempty"`
+       F_Fixed64Defaulted  *uint64  `protobuf:"fixed64,44,opt,name=F_Fixed64_defaulted,json=FFixed64Defaulted,def=640" json:"F_Fixed64_defaulted,omitempty"`
+       F_Uint32Defaulted   *uint32  `protobuf:"varint,45,opt,name=F_Uint32_defaulted,json=FUint32Defaulted,def=3200" json:"F_Uint32_defaulted,omitempty"`
+       F_Uint64Defaulted   *uint64  `protobuf:"varint,46,opt,name=F_Uint64_defaulted,json=FUint64Defaulted,def=6400" json:"F_Uint64_defaulted,omitempty"`
+       F_FloatDefaulted    *float32 `protobuf:"fixed32,47,opt,name=F_Float_defaulted,json=FFloatDefaulted,def=314159" json:"F_Float_defaulted,omitempty"`
+       F_DoubleDefaulted   *float64 `protobuf:"fixed64,48,opt,name=F_Double_defaulted,json=FDoubleDefaulted,def=271828" json:"F_Double_defaulted,omitempty"`
+       F_StringDefaulted   *string  `protobuf:"bytes,49,opt,name=F_String_defaulted,json=FStringDefaulted,def=hello, \"world!\"\n" json:"F_String_defaulted,omitempty"`
+       F_BytesDefaulted    []byte   `protobuf:"bytes,401,opt,name=F_Bytes_defaulted,json=FBytesDefaulted,def=Bignose" json:"F_Bytes_defaulted,omitempty"`
+       F_Sint32Defaulted   *int32   `protobuf:"zigzag32,402,opt,name=F_Sint32_defaulted,json=FSint32Defaulted,def=-32" json:"F_Sint32_defaulted,omitempty"`
+       F_Sint64Defaulted   *int64   `protobuf:"zigzag64,403,opt,name=F_Sint64_defaulted,json=FSint64Defaulted,def=-64" json:"F_Sint64_defaulted,omitempty"`
+       F_Sfixed32Defaulted *int32   `protobuf:"fixed32,404,opt,name=F_Sfixed32_defaulted,json=FSfixed32Defaulted,def=-32" json:"F_Sfixed32_defaulted,omitempty"`
+       F_Sfixed64Defaulted *int64   `protobuf:"fixed64,405,opt,name=F_Sfixed64_defaulted,json=FSfixed64Defaulted,def=-64" json:"F_Sfixed64_defaulted,omitempty"`
+       // Packed repeated fields (no string or bytes).
+       F_BoolRepeatedPacked     []bool                  `protobuf:"varint,50,rep,packed,name=F_Bool_repeated_packed,json=FBoolRepeatedPacked" json:"F_Bool_repeated_packed,omitempty"`
+       F_Int32RepeatedPacked    []int32                 `protobuf:"varint,51,rep,packed,name=F_Int32_repeated_packed,json=FInt32RepeatedPacked" json:"F_Int32_repeated_packed,omitempty"`
+       F_Int64RepeatedPacked    []int64                 `protobuf:"varint,52,rep,packed,name=F_Int64_repeated_packed,json=FInt64RepeatedPacked" json:"F_Int64_repeated_packed,omitempty"`
+       F_Fixed32RepeatedPacked  []uint32                `protobuf:"fixed32,53,rep,packed,name=F_Fixed32_repeated_packed,json=FFixed32RepeatedPacked" json:"F_Fixed32_repeated_packed,omitempty"`
+       F_Fixed64RepeatedPacked  []uint64                `protobuf:"fixed64,54,rep,packed,name=F_Fixed64_repeated_packed,json=FFixed64RepeatedPacked" json:"F_Fixed64_repeated_packed,omitempty"`
+       F_Uint32RepeatedPacked   []uint32                `protobuf:"varint,55,rep,packed,name=F_Uint32_repeated_packed,json=FUint32RepeatedPacked" json:"F_Uint32_repeated_packed,omitempty"`
+       F_Uint64RepeatedPacked   []uint64                `protobuf:"varint,56,rep,packed,name=F_Uint64_repeated_packed,json=FUint64RepeatedPacked" json:"F_Uint64_repeated_packed,omitempty"`
+       F_FloatRepeatedPacked    []float32               `protobuf:"fixed32,57,rep,packed,name=F_Float_repeated_packed,json=FFloatRepeatedPacked" json:"F_Float_repeated_packed,omitempty"`
+       F_DoubleRepeatedPacked   []float64               `protobuf:"fixed64,58,rep,packed,name=F_Double_repeated_packed,json=FDoubleRepeatedPacked" json:"F_Double_repeated_packed,omitempty"`
+       F_Sint32RepeatedPacked   []int32                 `protobuf:"zigzag32,502,rep,packed,name=F_Sint32_repeated_packed,json=FSint32RepeatedPacked" json:"F_Sint32_repeated_packed,omitempty"`
+       F_Sint64RepeatedPacked   []int64                 `protobuf:"zigzag64,503,rep,packed,name=F_Sint64_repeated_packed,json=FSint64RepeatedPacked" json:"F_Sint64_repeated_packed,omitempty"`
+       F_Sfixed32RepeatedPacked []int32                 `protobuf:"fixed32,504,rep,packed,name=F_Sfixed32_repeated_packed,json=FSfixed32RepeatedPacked" json:"F_Sfixed32_repeated_packed,omitempty"`
+       F_Sfixed64RepeatedPacked []int64                 `protobuf:"fixed64,505,rep,packed,name=F_Sfixed64_repeated_packed,json=FSfixed64RepeatedPacked" json:"F_Sfixed64_repeated_packed,omitempty"`
+       Requiredgroup            *GoTest_RequiredGroup   `protobuf:"group,70,req,name=RequiredGroup,json=requiredgroup" json:"requiredgroup,omitempty"`
+       Repeatedgroup            []*GoTest_RepeatedGroup `protobuf:"group,80,rep,name=RepeatedGroup,json=repeatedgroup" json:"repeatedgroup,omitempty"`
+       Optionalgroup            *GoTest_OptionalGroup   `protobuf:"group,90,opt,name=OptionalGroup,json=optionalgroup" json:"optionalgroup,omitempty"`
+       XXX_NoUnkeyedLiteral     struct{}                `json:"-"`
+       XXX_unrecognized         []byte                  `json:"-"`
+       XXX_sizecache            int32                   `json:"-"`
+}
+
+func (m *GoTest) Reset()         { *m = GoTest{} }
+func (m *GoTest) String() string { return proto.CompactTextString(m) }
+func (*GoTest) ProtoMessage()    {}
+func (*GoTest) Descriptor() ([]byte, []int) {
+       return fileDescriptor_c161fcfdc0c3ff1e, []int{2}
+}
+func (m *GoTest) XXX_Unmarshal(b []byte) error {
+       return xxx_messageInfo_GoTest.Unmarshal(m, b)
+}
+func (m *GoTest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+       return xxx_messageInfo_GoTest.Marshal(b, m, deterministic)
+}
+func (m *GoTest) XXX_Merge(src proto.Message) {
+       xxx_messageInfo_GoTest.Merge(m, src)
+}
+func (m *GoTest) XXX_Size() int {
+       return xxx_messageInfo_GoTest.Size(m)
+}
+func (m *GoTest) XXX_DiscardUnknown() {
+       xxx_messageInfo_GoTest.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_GoTest proto.InternalMessageInfo
+
+const Default_GoTest_F_BoolDefaulted bool = true
+const Default_GoTest_F_Int32Defaulted int32 = 32
+const Default_GoTest_F_Int64Defaulted int64 = 64
+const Default_GoTest_F_Fixed32Defaulted uint32 = 320
+const Default_GoTest_F_Fixed64Defaulted uint64 = 640
+const Default_GoTest_F_Uint32Defaulted uint32 = 3200
+const Default_GoTest_F_Uint64Defaulted uint64 = 6400
+const Default_GoTest_F_FloatDefaulted float32 = 314159
+const Default_GoTest_F_DoubleDefaulted float64 = 271828
+const Default_GoTest_F_StringDefaulted string = "hello, \"world!\"\n"
+
+var Default_GoTest_F_BytesDefaulted []byte = []byte("Bignose")
+
+const Default_GoTest_F_Sint32Defaulted int32 = -32
+const Default_GoTest_F_Sint64Defaulted int64 = -64
+const Default_GoTest_F_Sfixed32Defaulted int32 = -32
+const Default_GoTest_F_Sfixed64Defaulted int64 = -64
+
+func (m *GoTest) GetKind() GoTest_KIND {
+       if m != nil && m.Kind != nil {
+               return *m.Kind
+       }
+       return GoTest_VOID
+}
+
+func (m *GoTest) GetTable() string {
+       if m != nil && m.Table != nil {
+               return *m.Table
+       }
+       return ""
+}
+
+func (m *GoTest) GetParam() int32 {
+       if m != nil && m.Param != nil {
+               return *m.Param
+       }
+       return 0
+}
+
+func (m *GoTest) GetRequiredField() *GoTestField {
+       if m != nil {
+               return m.RequiredField
+       }
+       return nil
+}
+
+func (m *GoTest) GetRepeatedField() []*GoTestField {
+       if m != nil {
+               return m.RepeatedField
+       }
+       return nil
+}
+
+func (m *GoTest) GetOptionalField() *GoTestField {
+       if m != nil {
+               return m.OptionalField
+       }
+       return nil
+}
+
+func (m *GoTest) GetF_BoolRequired() bool {
+       if m != nil && m.F_BoolRequired != nil {
+               return *m.F_BoolRequired
+       }
+       return false
+}
+
+func (m *GoTest) GetF_Int32Required() int32 {
+       if m != nil && m.F_Int32Required != nil {
+               return *m.F_Int32Required
+       }
+       return 0
+}
+
+func (m *GoTest) GetF_Int64Required() int64 {
+       if m != nil && m.F_Int64Required != nil {
+               return *m.F_Int64Required
+       }
+       return 0
+}
+
+func (m *GoTest) GetF_Fixed32Required() uint32 {
+       if m != nil && m.F_Fixed32Required != nil {
+               return *m.F_Fixed32Required
+       }
+       return 0
+}
+
+func (m *GoTest) GetF_Fixed64Required() uint64 {
+       if m != nil && m.F_Fixed64Required != nil {
+               return *m.F_Fixed64Required
+       }
+       return 0
+}
+
+func (m *GoTest) GetF_Uint32Required() uint32 {
+       if m != nil && m.F_Uint32Required != nil {
+               return *m.F_Uint32Required
+       }
+       return 0
+}
+
+func (m *GoTest) GetF_Uint64Required() uint64 {
+       if m != nil && m.F_Uint64Required != nil {
+               return *m.F_Uint64Required
+       }
+       return 0
+}
+
+func (m *GoTest) GetF_FloatRequired() float32 {
+       if m != nil && m.F_FloatRequired != nil {
+               return *m.F_FloatRequired
+       }
+       return 0
+}
+
+func (m *GoTest) GetF_DoubleRequired() float64 {
+       if m != nil && m.F_DoubleRequired != nil {
+               return *m.F_DoubleRequired
+       }
+       return 0
+}
+
+func (m *GoTest) GetF_StringRequired() string {
+       if m != nil && m.F_StringRequired != nil {
+               return *m.F_StringRequired
+       }
+       return ""
+}
+
+func (m *GoTest) GetF_BytesRequired() []byte {
+       if m != nil {
+               return m.F_BytesRequired
+       }
+       return nil
+}
+
+func (m *GoTest) GetF_Sint32Required() int32 {
+       if m != nil && m.F_Sint32Required != nil {
+               return *m.F_Sint32Required
+       }
+       return 0
+}
+
+func (m *GoTest) GetF_Sint64Required() int64 {
+       if m != nil && m.F_Sint64Required != nil {
+               return *m.F_Sint64Required
+       }
+       return 0
+}
+
+func (m *GoTest) GetF_Sfixed32Required() int32 {
+       if m != nil && m.F_Sfixed32Required != nil {
+               return *m.F_Sfixed32Required
+       }
+       return 0
+}
+
+func (m *GoTest) GetF_Sfixed64Required() int64 {
+       if m != nil && m.F_Sfixed64Required != nil {
+               return *m.F_Sfixed64Required
+       }
+       return 0
+}
+
+func (m *GoTest) GetF_BoolRepeated() []bool {
+       if m != nil {
+               return m.F_BoolRepeated
+       }
+       return nil
+}
+
+func (m *GoTest) GetF_Int32Repeated() []int32 {
+       if m != nil {
+               return m.F_Int32Repeated
+       }
+       return nil
+}
+
+func (m *GoTest) GetF_Int64Repeated() []int64 {
+       if m != nil {
+               return m.F_Int64Repeated
+       }
+       return nil
+}
+
+func (m *GoTest) GetF_Fixed32Repeated() []uint32 {
+       if m != nil {
+               return m.F_Fixed32Repeated
+       }
+       return nil
+}
+
+func (m *GoTest) GetF_Fixed64Repeated() []uint64 {
+       if m != nil {
+               return m.F_Fixed64Repeated
+       }
+       return nil
+}
+
+func (m *GoTest) GetF_Uint32Repeated() []uint32 {
+       if m != nil {
+               return m.F_Uint32Repeated
+       }
+       return nil
+}
+
+func (m *GoTest) GetF_Uint64Repeated() []uint64 {
+       if m != nil {
+               return m.F_Uint64Repeated
+       }
+       return nil
+}
+
+func (m *GoTest) GetF_FloatRepeated() []float32 {
+       if m != nil {
+               return m.F_FloatRepeated
+       }
+       return nil
+}
+
+func (m *GoTest) GetF_DoubleRepeated() []float64 {
+       if m != nil {
+               return m.F_DoubleRepeated
+       }
+       return nil
+}
+
+func (m *GoTest) GetF_StringRepeated() []string {
+       if m != nil {
+               return m.F_StringRepeated
+       }
+       return nil
+}
+
+func (m *GoTest) GetF_BytesRepeated() [][]byte {
+       if m != nil {
+               return m.F_BytesRepeated
+       }
+       return nil
+}
+
+func (m *GoTest) GetF_Sint32Repeated() []int32 {
+       if m != nil {
+               return m.F_Sint32Repeated
+       }
+       return nil
+}
+
+func (m *GoTest) GetF_Sint64Repeated() []int64 {
+       if m != nil {
+               return m.F_Sint64Repeated
+       }
+       return nil
+}
+
+func (m *GoTest) GetF_Sfixed32Repeated() []int32 {
+       if m != nil {
+               return m.F_Sfixed32Repeated
+       }
+       return nil
+}
+
+func (m *GoTest) GetF_Sfixed64Repeated() []int64 {
+       if m != nil {
+               return m.F_Sfixed64Repeated
+       }
+       return nil
+}
+
+func (m *GoTest) GetF_BoolOptional() bool {
+       if m != nil && m.F_BoolOptional != nil {
+               return *m.F_BoolOptional
+       }
+       return false
+}
+
+func (m *GoTest) GetF_Int32Optional() int32 {
+       if m != nil && m.F_Int32Optional != nil {
+               return *m.F_Int32Optional
+       }
+       return 0
+}
+
+func (m *GoTest) GetF_Int64Optional() int64 {
+       if m != nil && m.F_Int64Optional != nil {
+               return *m.F_Int64Optional
+       }
+       return 0
+}
+
+func (m *GoTest) GetF_Fixed32Optional() uint32 {
+       if m != nil && m.F_Fixed32Optional != nil {
+               return *m.F_Fixed32Optional
+       }
+       return 0
+}
+
+func (m *GoTest) GetF_Fixed64Optional() uint64 {
+       if m != nil && m.F_Fixed64Optional != nil {
+               return *m.F_Fixed64Optional
+       }
+       return 0
+}
+
+func (m *GoTest) GetF_Uint32Optional() uint32 {
+       if m != nil && m.F_Uint32Optional != nil {
+               return *m.F_Uint32Optional
+       }
+       return 0
+}
+
+func (m *GoTest) GetF_Uint64Optional() uint64 {
+       if m != nil && m.F_Uint64Optional != nil {
+               return *m.F_Uint64Optional
+       }
+       return 0
+}
+
+func (m *GoTest) GetF_FloatOptional() float32 {
+       if m != nil && m.F_FloatOptional != nil {
+               return *m.F_FloatOptional
+       }
+       return 0
+}
+
+func (m *GoTest) GetF_DoubleOptional() float64 {
+       if m != nil && m.F_DoubleOptional != nil {
+               return *m.F_DoubleOptional
+       }
+       return 0
+}
+
+func (m *GoTest) GetF_StringOptional() string {
+       if m != nil && m.F_StringOptional != nil {
+               return *m.F_StringOptional
+       }
+       return ""
+}
+
+func (m *GoTest) GetF_BytesOptional() []byte {
+       if m != nil {
+               return m.F_BytesOptional
+       }
+       return nil
+}
+
+func (m *GoTest) GetF_Sint32Optional() int32 {
+       if m != nil && m.F_Sint32Optional != nil {
+               return *m.F_Sint32Optional
+       }
+       return 0
+}
+
+func (m *GoTest) GetF_Sint64Optional() int64 {
+       if m != nil && m.F_Sint64Optional != nil {
+               return *m.F_Sint64Optional
+       }
+       return 0
+}
+
+func (m *GoTest) GetF_Sfixed32Optional() int32 {
+       if m != nil && m.F_Sfixed32Optional != nil {
+               return *m.F_Sfixed32Optional
+       }
+       return 0
+}
+
+func (m *GoTest) GetF_Sfixed64Optional() int64 {
+       if m != nil && m.F_Sfixed64Optional != nil {
+               return *m.F_Sfixed64Optional
+       }
+       return 0
+}
+
+func (m *GoTest) GetF_BoolDefaulted() bool {
+       if m != nil && m.F_BoolDefaulted != nil {
+               return *m.F_BoolDefaulted
+       }
+       return Default_GoTest_F_BoolDefaulted
+}
+
+func (m *GoTest) GetF_Int32Defaulted() int32 {
+       if m != nil && m.F_Int32Defaulted != nil {
+               return *m.F_Int32Defaulted
+       }
+       return Default_GoTest_F_Int32Defaulted
+}
+
+func (m *GoTest) GetF_Int64Defaulted() int64 {
+       if m != nil && m.F_Int64Defaulted != nil {
+               return *m.F_Int64Defaulted
+       }
+       return Default_GoTest_F_Int64Defaulted
+}
+
+func (m *GoTest) GetF_Fixed32Defaulted() uint32 {
+       if m != nil && m.F_Fixed32Defaulted != nil {
+               return *m.F_Fixed32Defaulted
+       }
+       return Default_GoTest_F_Fixed32Defaulted
+}
+
+func (m *GoTest) GetF_Fixed64Defaulted() uint64 {
+       if m != nil && m.F_Fixed64Defaulted != nil {
+               return *m.F_Fixed64Defaulted
+       }
+       return Default_GoTest_F_Fixed64Defaulted
+}
+
+func (m *GoTest) GetF_Uint32Defaulted() uint32 {
+       if m != nil && m.F_Uint32Defaulted != nil {
+               return *m.F_Uint32Defaulted
+       }
+       return Default_GoTest_F_Uint32Defaulted
+}
+
+func (m *GoTest) GetF_Uint64Defaulted() uint64 {
+       if m != nil && m.F_Uint64Defaulted != nil {
+               return *m.F_Uint64Defaulted
+       }
+       return Default_GoTest_F_Uint64Defaulted
+}
+
+func (m *GoTest) GetF_FloatDefaulted() float32 {
+       if m != nil && m.F_FloatDefaulted != nil {
+               return *m.F_FloatDefaulted
+       }
+       return Default_GoTest_F_FloatDefaulted
+}
+
+func (m *GoTest) GetF_DoubleDefaulted() float64 {
+       if m != nil && m.F_DoubleDefaulted != nil {
+               return *m.F_DoubleDefaulted
+       }
+       return Default_GoTest_F_DoubleDefaulted
+}
+
+func (m *GoTest) GetF_StringDefaulted() string {
+       if m != nil && m.F_StringDefaulted != nil {
+               return *m.F_StringDefaulted
+       }
+       return Default_GoTest_F_StringDefaulted
+}
+
+func (m *GoTest) GetF_BytesDefaulted() []byte {
+       if m != nil && m.F_BytesDefaulted != nil {
+               return m.F_BytesDefaulted
+       }
+       return append([]byte(nil), Default_GoTest_F_BytesDefaulted...)
+}
+
+func (m *GoTest) GetF_Sint32Defaulted() int32 {
+       if m != nil && m.F_Sint32Defaulted != nil {
+               return *m.F_Sint32Defaulted
+       }
+       return Default_GoTest_F_Sint32Defaulted
+}
+
+func (m *GoTest) GetF_Sint64Defaulted() int64 {
+       if m != nil && m.F_Sint64Defaulted != nil {
+               return *m.F_Sint64Defaulted
+       }
+       return Default_GoTest_F_Sint64Defaulted
+}
+
+func (m *GoTest) GetF_Sfixed32Defaulted() int32 {
+       if m != nil && m.F_Sfixed32Defaulted != nil {
+               return *m.F_Sfixed32Defaulted
+       }
+       return Default_GoTest_F_Sfixed32Defaulted
+}
+
+func (m *GoTest) GetF_Sfixed64Defaulted() int64 {
+       if m != nil && m.F_Sfixed64Defaulted != nil {
+               return *m.F_Sfixed64Defaulted
+       }
+       return Default_GoTest_F_Sfixed64Defaulted
+}
+
+func (m *GoTest) GetF_BoolRepeatedPacked() []bool {
+       if m != nil {
+               return m.F_BoolRepeatedPacked
+       }
+       return nil
+}
+
+func (m *GoTest) GetF_Int32RepeatedPacked() []int32 {
+       if m != nil {
+               return m.F_Int32RepeatedPacked
+       }
+       return nil
+}
+
+func (m *GoTest) GetF_Int64RepeatedPacked() []int64 {
+       if m != nil {
+               return m.F_Int64RepeatedPacked
+       }
+       return nil
+}
+
+func (m *GoTest) GetF_Fixed32RepeatedPacked() []uint32 {
+       if m != nil {
+               return m.F_Fixed32RepeatedPacked
+       }
+       return nil
+}
+
+func (m *GoTest) GetF_Fixed64RepeatedPacked() []uint64 {
+       if m != nil {
+               return m.F_Fixed64RepeatedPacked
+       }
+       return nil
+}
+
+func (m *GoTest) GetF_Uint32RepeatedPacked() []uint32 {
+       if m != nil {
+               return m.F_Uint32RepeatedPacked
+       }
+       return nil
+}
+
+func (m *GoTest) GetF_Uint64RepeatedPacked() []uint64 {
+       if m != nil {
+               return m.F_Uint64RepeatedPacked
+       }
+       return nil
+}
+
+func (m *GoTest) GetF_FloatRepeatedPacked() []float32 {
+       if m != nil {
+               return m.F_FloatRepeatedPacked
+       }
+       return nil
+}
+
+func (m *GoTest) GetF_DoubleRepeatedPacked() []float64 {
+       if m != nil {
+               return m.F_DoubleRepeatedPacked
+       }
+       return nil
+}
+
+func (m *GoTest) GetF_Sint32RepeatedPacked() []int32 {
+       if m != nil {
+               return m.F_Sint32RepeatedPacked
+       }
+       return nil
+}
+
+func (m *GoTest) GetF_Sint64RepeatedPacked() []int64 {
+       if m != nil {
+               return m.F_Sint64RepeatedPacked
+       }
+       return nil
+}
+
+func (m *GoTest) GetF_Sfixed32RepeatedPacked() []int32 {
+       if m != nil {
+               return m.F_Sfixed32RepeatedPacked
+       }
+       return nil
+}
+
+func (m *GoTest) GetF_Sfixed64RepeatedPacked() []int64 {
+       if m != nil {
+               return m.F_Sfixed64RepeatedPacked
+       }
+       return nil
+}
+
+func (m *GoTest) GetRequiredgroup() *GoTest_RequiredGroup {
+       if m != nil {
+               return m.Requiredgroup
+       }
+       return nil
+}
+
+func (m *GoTest) GetRepeatedgroup() []*GoTest_RepeatedGroup {
+       if m != nil {
+               return m.Repeatedgroup
+       }
+       return nil
+}
+
+func (m *GoTest) GetOptionalgroup() *GoTest_OptionalGroup {
+       if m != nil {
+               return m.Optionalgroup
+       }
+       return nil
+}
+
+// Required, repeated, and optional groups.
+type GoTest_RequiredGroup struct {
+       RequiredField        *string  `protobuf:"bytes,71,req,name=RequiredField" json:"RequiredField,omitempty"`
+       XXX_NoUnkeyedLiteral struct{} `json:"-"`
+       XXX_unrecognized     []byte   `json:"-"`
+       XXX_sizecache        int32    `json:"-"`
+}
+
+func (m *GoTest_RequiredGroup) Reset()         { *m = GoTest_RequiredGroup{} }
+func (m *GoTest_RequiredGroup) String() string { return proto.CompactTextString(m) }
+func (*GoTest_RequiredGroup) ProtoMessage()    {}
+func (*GoTest_RequiredGroup) Descriptor() ([]byte, []int) {
+       return fileDescriptor_c161fcfdc0c3ff1e, []int{2, 0}
+}
+func (m *GoTest_RequiredGroup) XXX_Unmarshal(b []byte) error {
+       return xxx_messageInfo_GoTest_RequiredGroup.Unmarshal(m, b)
+}
+func (m *GoTest_RequiredGroup) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+       return xxx_messageInfo_GoTest_RequiredGroup.Marshal(b, m, deterministic)
+}
+func (m *GoTest_RequiredGroup) XXX_Merge(src proto.Message) {
+       xxx_messageInfo_GoTest_RequiredGroup.Merge(m, src)
+}
+func (m *GoTest_RequiredGroup) XXX_Size() int {
+       return xxx_messageInfo_GoTest_RequiredGroup.Size(m)
+}
+func (m *GoTest_RequiredGroup) XXX_DiscardUnknown() {
+       xxx_messageInfo_GoTest_RequiredGroup.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_GoTest_RequiredGroup proto.InternalMessageInfo
+
+func (m *GoTest_RequiredGroup) GetRequiredField() string {
+       if m != nil && m.RequiredField != nil {
+               return *m.RequiredField
+       }
+       return ""
+}
+
+type GoTest_RepeatedGroup struct {
+       RequiredField        *string  `protobuf:"bytes,81,req,name=RequiredField" json:"RequiredField,omitempty"`
+       XXX_NoUnkeyedLiteral struct{} `json:"-"`
+       XXX_unrecognized     []byte   `json:"-"`
+       XXX_sizecache        int32    `json:"-"`
+}
+
+func (m *GoTest_RepeatedGroup) Reset()         { *m = GoTest_RepeatedGroup{} }
+func (m *GoTest_RepeatedGroup) String() string { return proto.CompactTextString(m) }
+func (*GoTest_RepeatedGroup) ProtoMessage()    {}
+func (*GoTest_RepeatedGroup) Descriptor() ([]byte, []int) {
+       return fileDescriptor_c161fcfdc0c3ff1e, []int{2, 1}
+}
+func (m *GoTest_RepeatedGroup) XXX_Unmarshal(b []byte) error {
+       return xxx_messageInfo_GoTest_RepeatedGroup.Unmarshal(m, b)
+}
+func (m *GoTest_RepeatedGroup) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+       return xxx_messageInfo_GoTest_RepeatedGroup.Marshal(b, m, deterministic)
+}
+func (m *GoTest_RepeatedGroup) XXX_Merge(src proto.Message) {
+       xxx_messageInfo_GoTest_RepeatedGroup.Merge(m, src)
+}
+func (m *GoTest_RepeatedGroup) XXX_Size() int {
+       return xxx_messageInfo_GoTest_RepeatedGroup.Size(m)
+}
+func (m *GoTest_RepeatedGroup) XXX_DiscardUnknown() {
+       xxx_messageInfo_GoTest_RepeatedGroup.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_GoTest_RepeatedGroup proto.InternalMessageInfo
+
+func (m *GoTest_RepeatedGroup) GetRequiredField() string {
+       if m != nil && m.RequiredField != nil {
+               return *m.RequiredField
+       }
+       return ""
+}
+
+type GoTest_OptionalGroup struct {
+       RequiredField        *string  `protobuf:"bytes,91,req,name=RequiredField" json:"RequiredField,omitempty"`
+       XXX_NoUnkeyedLiteral struct{} `json:"-"`
+       XXX_unrecognized     []byte   `json:"-"`
+       XXX_sizecache        int32    `json:"-"`
+}
+
+func (m *GoTest_OptionalGroup) Reset()         { *m = GoTest_OptionalGroup{} }
+func (m *GoTest_OptionalGroup) String() string { return proto.CompactTextString(m) }
+func (*GoTest_OptionalGroup) ProtoMessage()    {}
+func (*GoTest_OptionalGroup) Descriptor() ([]byte, []int) {
+       return fileDescriptor_c161fcfdc0c3ff1e, []int{2, 2}
+}
+func (m *GoTest_OptionalGroup) XXX_Unmarshal(b []byte) error {
+       return xxx_messageInfo_GoTest_OptionalGroup.Unmarshal(m, b)
+}
+func (m *GoTest_OptionalGroup) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+       return xxx_messageInfo_GoTest_OptionalGroup.Marshal(b, m, deterministic)
+}
+func (m *GoTest_OptionalGroup) XXX_Merge(src proto.Message) {
+       xxx_messageInfo_GoTest_OptionalGroup.Merge(m, src)
+}
+func (m *GoTest_OptionalGroup) XXX_Size() int {
+       return xxx_messageInfo_GoTest_OptionalGroup.Size(m)
+}
+func (m *GoTest_OptionalGroup) XXX_DiscardUnknown() {
+       xxx_messageInfo_GoTest_OptionalGroup.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_GoTest_OptionalGroup proto.InternalMessageInfo
+
+func (m *GoTest_OptionalGroup) GetRequiredField() string {
+       if m != nil && m.RequiredField != nil {
+               return *m.RequiredField
+       }
+       return ""
+}
+
+// For testing a group containing a required field.
+type GoTestRequiredGroupField struct {
+       Group                *GoTestRequiredGroupField_Group `protobuf:"group,1,req,name=Group,json=group" json:"group,omitempty"`
+       XXX_NoUnkeyedLiteral struct{}                        `json:"-"`
+       XXX_unrecognized     []byte                          `json:"-"`
+       XXX_sizecache        int32                           `json:"-"`
+}
+
+func (m *GoTestRequiredGroupField) Reset()         { *m = GoTestRequiredGroupField{} }
+func (m *GoTestRequiredGroupField) String() string { return proto.CompactTextString(m) }
+func (*GoTestRequiredGroupField) ProtoMessage()    {}
+func (*GoTestRequiredGroupField) Descriptor() ([]byte, []int) {
+       return fileDescriptor_c161fcfdc0c3ff1e, []int{3}
+}
+func (m *GoTestRequiredGroupField) XXX_Unmarshal(b []byte) error {
+       return xxx_messageInfo_GoTestRequiredGroupField.Unmarshal(m, b)
+}
+func (m *GoTestRequiredGroupField) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+       return xxx_messageInfo_GoTestRequiredGroupField.Marshal(b, m, deterministic)
+}
+func (m *GoTestRequiredGroupField) XXX_Merge(src proto.Message) {
+       xxx_messageInfo_GoTestRequiredGroupField.Merge(m, src)
+}
+func (m *GoTestRequiredGroupField) XXX_Size() int {
+       return xxx_messageInfo_GoTestRequiredGroupField.Size(m)
+}
+func (m *GoTestRequiredGroupField) XXX_DiscardUnknown() {
+       xxx_messageInfo_GoTestRequiredGroupField.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_GoTestRequiredGroupField proto.InternalMessageInfo
+
+func (m *GoTestRequiredGroupField) GetGroup() *GoTestRequiredGroupField_Group {
+       if m != nil {
+               return m.Group
+       }
+       return nil
+}
+
+type GoTestRequiredGroupField_Group struct {
+       Field                *int32   `protobuf:"varint,2,req,name=Field" json:"Field,omitempty"`
+       XXX_NoUnkeyedLiteral struct{} `json:"-"`
+       XXX_unrecognized     []byte   `json:"-"`
+       XXX_sizecache        int32    `json:"-"`
+}
+
+func (m *GoTestRequiredGroupField_Group) Reset()         { *m = GoTestRequiredGroupField_Group{} }
+func (m *GoTestRequiredGroupField_Group) String() string { return proto.CompactTextString(m) }
+func (*GoTestRequiredGroupField_Group) ProtoMessage()    {}
+func (*GoTestRequiredGroupField_Group) Descriptor() ([]byte, []int) {
+       return fileDescriptor_c161fcfdc0c3ff1e, []int{3, 0}
+}
+func (m *GoTestRequiredGroupField_Group) XXX_Unmarshal(b []byte) error {
+       return xxx_messageInfo_GoTestRequiredGroupField_Group.Unmarshal(m, b)
+}
+func (m *GoTestRequiredGroupField_Group) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+       return xxx_messageInfo_GoTestRequiredGroupField_Group.Marshal(b, m, deterministic)
+}
+func (m *GoTestRequiredGroupField_Group) XXX_Merge(src proto.Message) {
+       xxx_messageInfo_GoTestRequiredGroupField_Group.Merge(m, src)
+}
+func (m *GoTestRequiredGroupField_Group) XXX_Size() int {
+       return xxx_messageInfo_GoTestRequiredGroupField_Group.Size(m)
+}
+func (m *GoTestRequiredGroupField_Group) XXX_DiscardUnknown() {
+       xxx_messageInfo_GoTestRequiredGroupField_Group.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_GoTestRequiredGroupField_Group proto.InternalMessageInfo
+
+func (m *GoTestRequiredGroupField_Group) GetField() int32 {
+       if m != nil && m.Field != nil {
+               return *m.Field
+       }
+       return 0
+}
+
+// For testing skipping of unrecognized fields.
+// Numbers are all big, larger than tag numbers in GoTestField,
+// the message used in the corresponding test.
+type GoSkipTest struct {
+       SkipInt32            *int32                `protobuf:"varint,11,req,name=skip_int32,json=skipInt32" json:"skip_int32,omitempty"`
+       SkipFixed32          *uint32               `protobuf:"fixed32,12,req,name=skip_fixed32,json=skipFixed32" json:"skip_fixed32,omitempty"`
+       SkipFixed64          *uint64               `protobuf:"fixed64,13,req,name=skip_fixed64,json=skipFixed64" json:"skip_fixed64,omitempty"`
+       SkipString           *string               `protobuf:"bytes,14,req,name=skip_string,json=skipString" json:"skip_string,omitempty"`
+       Skipgroup            *GoSkipTest_SkipGroup `protobuf:"group,15,req,name=SkipGroup,json=skipgroup" json:"skipgroup,omitempty"`
+       XXX_NoUnkeyedLiteral struct{}              `json:"-"`
+       XXX_unrecognized     []byte                `json:"-"`
+       XXX_sizecache        int32                 `json:"-"`
+}
+
+func (m *GoSkipTest) Reset()         { *m = GoSkipTest{} }
+func (m *GoSkipTest) String() string { return proto.CompactTextString(m) }
+func (*GoSkipTest) ProtoMessage()    {}
+func (*GoSkipTest) Descriptor() ([]byte, []int) {
+       return fileDescriptor_c161fcfdc0c3ff1e, []int{4}
+}
+func (m *GoSkipTest) XXX_Unmarshal(b []byte) error {
+       return xxx_messageInfo_GoSkipTest.Unmarshal(m, b)
+}
+func (m *GoSkipTest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+       return xxx_messageInfo_GoSkipTest.Marshal(b, m, deterministic)
+}
+func (m *GoSkipTest) XXX_Merge(src proto.Message) {
+       xxx_messageInfo_GoSkipTest.Merge(m, src)
+}
+func (m *GoSkipTest) XXX_Size() int {
+       return xxx_messageInfo_GoSkipTest.Size(m)
+}
+func (m *GoSkipTest) XXX_DiscardUnknown() {
+       xxx_messageInfo_GoSkipTest.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_GoSkipTest proto.InternalMessageInfo
+
+func (m *GoSkipTest) GetSkipInt32() int32 {
+       if m != nil && m.SkipInt32 != nil {
+               return *m.SkipInt32
+       }
+       return 0
+}
+
+func (m *GoSkipTest) GetSkipFixed32() uint32 {
+       if m != nil && m.SkipFixed32 != nil {
+               return *m.SkipFixed32
+       }
+       return 0
+}
+
+func (m *GoSkipTest) GetSkipFixed64() uint64 {
+       if m != nil && m.SkipFixed64 != nil {
+               return *m.SkipFixed64
+       }
+       return 0
+}
+
+func (m *GoSkipTest) GetSkipString() string {
+       if m != nil && m.SkipString != nil {
+               return *m.SkipString
+       }
+       return ""
+}
+
+func (m *GoSkipTest) GetSkipgroup() *GoSkipTest_SkipGroup {
+       if m != nil {
+               return m.Skipgroup
+       }
+       return nil
+}
+
+type GoSkipTest_SkipGroup struct {
+       GroupInt32           *int32   `protobuf:"varint,16,req,name=group_int32,json=groupInt32" json:"group_int32,omitempty"`
+       GroupString          *string  `protobuf:"bytes,17,req,name=group_string,json=groupString" json:"group_string,omitempty"`
+       XXX_NoUnkeyedLiteral struct{} `json:"-"`
+       XXX_unrecognized     []byte   `json:"-"`
+       XXX_sizecache        int32    `json:"-"`
+}
+
+func (m *GoSkipTest_SkipGroup) Reset()         { *m = GoSkipTest_SkipGroup{} }
+func (m *GoSkipTest_SkipGroup) String() string { return proto.CompactTextString(m) }
+func (*GoSkipTest_SkipGroup) ProtoMessage()    {}
+func (*GoSkipTest_SkipGroup) Descriptor() ([]byte, []int) {
+       return fileDescriptor_c161fcfdc0c3ff1e, []int{4, 0}
+}
+func (m *GoSkipTest_SkipGroup) XXX_Unmarshal(b []byte) error {
+       return xxx_messageInfo_GoSkipTest_SkipGroup.Unmarshal(m, b)
+}
+func (m *GoSkipTest_SkipGroup) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+       return xxx_messageInfo_GoSkipTest_SkipGroup.Marshal(b, m, deterministic)
+}
+func (m *GoSkipTest_SkipGroup) XXX_Merge(src proto.Message) {
+       xxx_messageInfo_GoSkipTest_SkipGroup.Merge(m, src)
+}
+func (m *GoSkipTest_SkipGroup) XXX_Size() int {
+       return xxx_messageInfo_GoSkipTest_SkipGroup.Size(m)
+}
+func (m *GoSkipTest_SkipGroup) XXX_DiscardUnknown() {
+       xxx_messageInfo_GoSkipTest_SkipGroup.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_GoSkipTest_SkipGroup proto.InternalMessageInfo
+
+func (m *GoSkipTest_SkipGroup) GetGroupInt32() int32 {
+       if m != nil && m.GroupInt32 != nil {
+               return *m.GroupInt32
+       }
+       return 0
+}
+
+func (m *GoSkipTest_SkipGroup) GetGroupString() string {
+       if m != nil && m.GroupString != nil {
+               return *m.GroupString
+       }
+       return ""
+}
+
+// For testing packed/non-packed decoder switching.
+// A serialized instance of one should be deserializable as the other.
+type NonPackedTest struct {
+       A                    []int32  `protobuf:"varint,1,rep,name=a" json:"a,omitempty"`
+       XXX_NoUnkeyedLiteral struct{} `json:"-"`
+       XXX_unrecognized     []byte   `json:"-"`
+       XXX_sizecache        int32    `json:"-"`
+}
+
+func (m *NonPackedTest) Reset()         { *m = NonPackedTest{} }
+func (m *NonPackedTest) String() string { return proto.CompactTextString(m) }
+func (*NonPackedTest) ProtoMessage()    {}
+func (*NonPackedTest) Descriptor() ([]byte, []int) {
+       return fileDescriptor_c161fcfdc0c3ff1e, []int{5}
+}
+func (m *NonPackedTest) XXX_Unmarshal(b []byte) error {
+       return xxx_messageInfo_NonPackedTest.Unmarshal(m, b)
+}
+func (m *NonPackedTest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+       return xxx_messageInfo_NonPackedTest.Marshal(b, m, deterministic)
+}
+func (m *NonPackedTest) XXX_Merge(src proto.Message) {
+       xxx_messageInfo_NonPackedTest.Merge(m, src)
+}
+func (m *NonPackedTest) XXX_Size() int {
+       return xxx_messageInfo_NonPackedTest.Size(m)
+}
+func (m *NonPackedTest) XXX_DiscardUnknown() {
+       xxx_messageInfo_NonPackedTest.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_NonPackedTest proto.InternalMessageInfo
+
+func (m *NonPackedTest) GetA() []int32 {
+       if m != nil {
+               return m.A
+       }
+       return nil
+}
+
+type PackedTest struct {
+       B                    []int32  `protobuf:"varint,1,rep,packed,name=b" json:"b,omitempty"`
+       XXX_NoUnkeyedLiteral struct{} `json:"-"`
+       XXX_unrecognized     []byte   `json:"-"`
+       XXX_sizecache        int32    `json:"-"`
+}
+
+func (m *PackedTest) Reset()         { *m = PackedTest{} }
+func (m *PackedTest) String() string { return proto.CompactTextString(m) }
+func (*PackedTest) ProtoMessage()    {}
+func (*PackedTest) Descriptor() ([]byte, []int) {
+       return fileDescriptor_c161fcfdc0c3ff1e, []int{6}
+}
+func (m *PackedTest) XXX_Unmarshal(b []byte) error {
+       return xxx_messageInfo_PackedTest.Unmarshal(m, b)
+}
+func (m *PackedTest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+       return xxx_messageInfo_PackedTest.Marshal(b, m, deterministic)
+}
+func (m *PackedTest) XXX_Merge(src proto.Message) {
+       xxx_messageInfo_PackedTest.Merge(m, src)
+}
+func (m *PackedTest) XXX_Size() int {
+       return xxx_messageInfo_PackedTest.Size(m)
+}
+func (m *PackedTest) XXX_DiscardUnknown() {
+       xxx_messageInfo_PackedTest.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_PackedTest proto.InternalMessageInfo
+
+func (m *PackedTest) GetB() []int32 {
+       if m != nil {
+               return m.B
+       }
+       return nil
+}
+
+type MaxTag struct {
+       // Maximum possible tag number.
+       LastField            *string  `protobuf:"bytes,536870911,opt,name=last_field,json=lastField" json:"last_field,omitempty"`
+       XXX_NoUnkeyedLiteral struct{} `json:"-"`
+       XXX_unrecognized     []byte   `json:"-"`
+       XXX_sizecache        int32    `json:"-"`
+}
+
+func (m *MaxTag) Reset()         { *m = MaxTag{} }
+func (m *MaxTag) String() string { return proto.CompactTextString(m) }
+func (*MaxTag) ProtoMessage()    {}
+func (*MaxTag) Descriptor() ([]byte, []int) {
+       return fileDescriptor_c161fcfdc0c3ff1e, []int{7}
+}
+func (m *MaxTag) XXX_Unmarshal(b []byte) error {
+       return xxx_messageInfo_MaxTag.Unmarshal(m, b)
+}
+func (m *MaxTag) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+       return xxx_messageInfo_MaxTag.Marshal(b, m, deterministic)
+}
+func (m *MaxTag) XXX_Merge(src proto.Message) {
+       xxx_messageInfo_MaxTag.Merge(m, src)
+}
+func (m *MaxTag) XXX_Size() int {
+       return xxx_messageInfo_MaxTag.Size(m)
+}
+func (m *MaxTag) XXX_DiscardUnknown() {
+       xxx_messageInfo_MaxTag.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_MaxTag proto.InternalMessageInfo
+
+func (m *MaxTag) GetLastField() string {
+       if m != nil && m.LastField != nil {
+               return *m.LastField
+       }
+       return ""
+}
+
+type OldMessage struct {
+       Nested               *OldMessage_Nested `protobuf:"bytes,1,opt,name=nested" json:"nested,omitempty"`
+       Num                  *int32             `protobuf:"varint,2,opt,name=num" json:"num,omitempty"`
+       XXX_NoUnkeyedLiteral struct{}           `json:"-"`
+       XXX_unrecognized     []byte             `json:"-"`
+       XXX_sizecache        int32              `json:"-"`
+}
+
+func (m *OldMessage) Reset()         { *m = OldMessage{} }
+func (m *OldMessage) String() string { return proto.CompactTextString(m) }
+func (*OldMessage) ProtoMessage()    {}
+func (*OldMessage) Descriptor() ([]byte, []int) {
+       return fileDescriptor_c161fcfdc0c3ff1e, []int{8}
+}
+func (m *OldMessage) XXX_Unmarshal(b []byte) error {
+       return xxx_messageInfo_OldMessage.Unmarshal(m, b)
+}
+func (m *OldMessage) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+       return xxx_messageInfo_OldMessage.Marshal(b, m, deterministic)
+}
+func (m *OldMessage) XXX_Merge(src proto.Message) {
+       xxx_messageInfo_OldMessage.Merge(m, src)
+}
+func (m *OldMessage) XXX_Size() int {
+       return xxx_messageInfo_OldMessage.Size(m)
+}
+func (m *OldMessage) XXX_DiscardUnknown() {
+       xxx_messageInfo_OldMessage.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_OldMessage proto.InternalMessageInfo
+
+func (m *OldMessage) GetNested() *OldMessage_Nested {
+       if m != nil {
+               return m.Nested
+       }
+       return nil
+}
+
+func (m *OldMessage) GetNum() int32 {
+       if m != nil && m.Num != nil {
+               return *m.Num
+       }
+       return 0
+}
+
+type OldMessage_Nested struct {
+       Name                 *string  `protobuf:"bytes,1,opt,name=name" json:"name,omitempty"`
+       XXX_NoUnkeyedLiteral struct{} `json:"-"`
+       XXX_unrecognized     []byte   `json:"-"`
+       XXX_sizecache        int32    `json:"-"`
+}
+
+func (m *OldMessage_Nested) Reset()         { *m = OldMessage_Nested{} }
+func (m *OldMessage_Nested) String() string { return proto.CompactTextString(m) }
+func (*OldMessage_Nested) ProtoMessage()    {}
+func (*OldMessage_Nested) Descriptor() ([]byte, []int) {
+       return fileDescriptor_c161fcfdc0c3ff1e, []int{8, 0}
+}
+func (m *OldMessage_Nested) XXX_Unmarshal(b []byte) error {
+       return xxx_messageInfo_OldMessage_Nested.Unmarshal(m, b)
+}
+func (m *OldMessage_Nested) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+       return xxx_messageInfo_OldMessage_Nested.Marshal(b, m, deterministic)
+}
+func (m *OldMessage_Nested) XXX_Merge(src proto.Message) {
+       xxx_messageInfo_OldMessage_Nested.Merge(m, src)
+}
+func (m *OldMessage_Nested) XXX_Size() int {
+       return xxx_messageInfo_OldMessage_Nested.Size(m)
+}
+func (m *OldMessage_Nested) XXX_DiscardUnknown() {
+       xxx_messageInfo_OldMessage_Nested.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_OldMessage_Nested proto.InternalMessageInfo
+
+func (m *OldMessage_Nested) GetName() string {
+       if m != nil && m.Name != nil {
+               return *m.Name
+       }
+       return ""
+}
+
+// NewMessage is wire compatible with OldMessage;
+// imagine it as a future version.
+type NewMessage struct {
+       Nested *NewMessage_Nested `protobuf:"bytes,1,opt,name=nested" json:"nested,omitempty"`
+       // This is an int32 in OldMessage.
+       Num                  *int64   `protobuf:"varint,2,opt,name=num" json:"num,omitempty"`
+       XXX_NoUnkeyedLiteral struct{} `json:"-"`
+       XXX_unrecognized     []byte   `json:"-"`
+       XXX_sizecache        int32    `json:"-"`
+}
+
+func (m *NewMessage) Reset()         { *m = NewMessage{} }
+func (m *NewMessage) String() string { return proto.CompactTextString(m) }
+func (*NewMessage) ProtoMessage()    {}
+func (*NewMessage) Descriptor() ([]byte, []int) {
+       return fileDescriptor_c161fcfdc0c3ff1e, []int{9}
+}
+func (m *NewMessage) XXX_Unmarshal(b []byte) error {
+       return xxx_messageInfo_NewMessage.Unmarshal(m, b)
+}
+func (m *NewMessage) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+       return xxx_messageInfo_NewMessage.Marshal(b, m, deterministic)
+}
+func (m *NewMessage) XXX_Merge(src proto.Message) {
+       xxx_messageInfo_NewMessage.Merge(m, src)
+}
+func (m *NewMessage) XXX_Size() int {
+       return xxx_messageInfo_NewMessage.Size(m)
+}
+func (m *NewMessage) XXX_DiscardUnknown() {
+       xxx_messageInfo_NewMessage.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_NewMessage proto.InternalMessageInfo
+
+func (m *NewMessage) GetNested() *NewMessage_Nested {
+       if m != nil {
+               return m.Nested
+       }
+       return nil
+}
+
+func (m *NewMessage) GetNum() int64 {
+       if m != nil && m.Num != nil {
+               return *m.Num
+       }
+       return 0
+}
+
+type NewMessage_Nested struct {
+       Name                 *string  `protobuf:"bytes,1,opt,name=name" json:"name,omitempty"`
+       FoodGroup            *string  `protobuf:"bytes,2,opt,name=food_group,json=foodGroup" json:"food_group,omitempty"`
+       XXX_NoUnkeyedLiteral struct{} `json:"-"`
+       XXX_unrecognized     []byte   `json:"-"`
+       XXX_sizecache        int32    `json:"-"`
+}
+
+func (m *NewMessage_Nested) Reset()         { *m = NewMessage_Nested{} }
+func (m *NewMessage_Nested) String() string { return proto.CompactTextString(m) }
+func (*NewMessage_Nested) ProtoMessage()    {}
+func (*NewMessage_Nested) Descriptor() ([]byte, []int) {
+       return fileDescriptor_c161fcfdc0c3ff1e, []int{9, 0}
+}
+func (m *NewMessage_Nested) XXX_Unmarshal(b []byte) error {
+       return xxx_messageInfo_NewMessage_Nested.Unmarshal(m, b)
+}
+func (m *NewMessage_Nested) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+       return xxx_messageInfo_NewMessage_Nested.Marshal(b, m, deterministic)
+}
+func (m *NewMessage_Nested) XXX_Merge(src proto.Message) {
+       xxx_messageInfo_NewMessage_Nested.Merge(m, src)
+}
+func (m *NewMessage_Nested) XXX_Size() int {
+       return xxx_messageInfo_NewMessage_Nested.Size(m)
+}
+func (m *NewMessage_Nested) XXX_DiscardUnknown() {
+       xxx_messageInfo_NewMessage_Nested.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_NewMessage_Nested proto.InternalMessageInfo
+
+func (m *NewMessage_Nested) GetName() string {
+       if m != nil && m.Name != nil {
+               return *m.Name
+       }
+       return ""
+}
+
+func (m *NewMessage_Nested) GetFoodGroup() string {
+       if m != nil && m.FoodGroup != nil {
+               return *m.FoodGroup
+       }
+       return ""
+}
+
+type InnerMessage struct {
+       Host                 *string  `protobuf:"bytes,1,req,name=host" json:"host,omitempty"`
+       Port                 *int32   `protobuf:"varint,2,opt,name=port,def=4000" json:"port,omitempty"`
+       Connected            *bool    `protobuf:"varint,3,opt,name=connected" json:"connected,omitempty"`
+       XXX_NoUnkeyedLiteral struct{} `json:"-"`
+       XXX_unrecognized     []byte   `json:"-"`
+       XXX_sizecache        int32    `json:"-"`
+}
+
+func (m *InnerMessage) Reset()         { *m = InnerMessage{} }
+func (m *InnerMessage) String() string { return proto.CompactTextString(m) }
+func (*InnerMessage) ProtoMessage()    {}
+func (*InnerMessage) Descriptor() ([]byte, []int) {
+       return fileDescriptor_c161fcfdc0c3ff1e, []int{10}
+}
+func (m *InnerMessage) XXX_Unmarshal(b []byte) error {
+       return xxx_messageInfo_InnerMessage.Unmarshal(m, b)
+}
+func (m *InnerMessage) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+       return xxx_messageInfo_InnerMessage.Marshal(b, m, deterministic)
+}
+func (m *InnerMessage) XXX_Merge(src proto.Message) {
+       xxx_messageInfo_InnerMessage.Merge(m, src)
+}
+func (m *InnerMessage) XXX_Size() int {
+       return xxx_messageInfo_InnerMessage.Size(m)
+}
+func (m *InnerMessage) XXX_DiscardUnknown() {
+       xxx_messageInfo_InnerMessage.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_InnerMessage proto.InternalMessageInfo
+
+const Default_InnerMessage_Port int32 = 4000
+
+func (m *InnerMessage) GetHost() string {
+       if m != nil && m.Host != nil {
+               return *m.Host
+       }
+       return ""
+}
+
+func (m *InnerMessage) GetPort() int32 {
+       if m != nil && m.Port != nil {
+               return *m.Port
+       }
+       return Default_InnerMessage_Port
+}
+
+func (m *InnerMessage) GetConnected() bool {
+       if m != nil && m.Connected != nil {
+               return *m.Connected
+       }
+       return false
+}
+
+type OtherMessage struct {
+       Key                          *int64        `protobuf:"varint,1,opt,name=key" json:"key,omitempty"`
+       Value                        []byte        `protobuf:"bytes,2,opt,name=value" json:"value,omitempty"`
+       Weight                       *float32      `protobuf:"fixed32,3,opt,name=weight" json:"weight,omitempty"`
+       Inner                        *InnerMessage `protobuf:"bytes,4,opt,name=inner" json:"inner,omitempty"`
+       XXX_NoUnkeyedLiteral         struct{}      `json:"-"`
+       proto.XXX_InternalExtensions `json:"-"`
+       XXX_unrecognized             []byte `json:"-"`
+       XXX_sizecache                int32  `json:"-"`
+}
+
+func (m *OtherMessage) Reset()         { *m = OtherMessage{} }
+func (m *OtherMessage) String() string { return proto.CompactTextString(m) }
+func (*OtherMessage) ProtoMessage()    {}
+func (*OtherMessage) Descriptor() ([]byte, []int) {
+       return fileDescriptor_c161fcfdc0c3ff1e, []int{11}
+}
+
+var extRange_OtherMessage = []proto.ExtensionRange{
+       {Start: 100, End: 536870911},
+}
+
+func (*OtherMessage) ExtensionRangeArray() []proto.ExtensionRange {
+       return extRange_OtherMessage
+}
+
+func (m *OtherMessage) XXX_Unmarshal(b []byte) error {
+       return xxx_messageInfo_OtherMessage.Unmarshal(m, b)
+}
+func (m *OtherMessage) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+       return xxx_messageInfo_OtherMessage.Marshal(b, m, deterministic)
+}
+func (m *OtherMessage) XXX_Merge(src proto.Message) {
+       xxx_messageInfo_OtherMessage.Merge(m, src)
+}
+func (m *OtherMessage) XXX_Size() int {
+       return xxx_messageInfo_OtherMessage.Size(m)
+}
+func (m *OtherMessage) XXX_DiscardUnknown() {
+       xxx_messageInfo_OtherMessage.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_OtherMessage proto.InternalMessageInfo
+
+func (m *OtherMessage) GetKey() int64 {
+       if m != nil && m.Key != nil {
+               return *m.Key
+       }
+       return 0
+}
+
+func (m *OtherMessage) GetValue() []byte {
+       if m != nil {
+               return m.Value
+       }
+       return nil
+}
+
+func (m *OtherMessage) GetWeight() float32 {
+       if m != nil && m.Weight != nil {
+               return *m.Weight
+       }
+       return 0
+}
+
+func (m *OtherMessage) GetInner() *InnerMessage {
+       if m != nil {
+               return m.Inner
+       }
+       return nil
+}
+
+type RequiredInnerMessage struct {
+       LeoFinallyWonAnOscar *InnerMessage `protobuf:"bytes,1,req,name=leo_finally_won_an_oscar,json=leoFinallyWonAnOscar" json:"leo_finally_won_an_oscar,omitempty"`
+       XXX_NoUnkeyedLiteral struct{}      `json:"-"`
+       XXX_unrecognized     []byte        `json:"-"`
+       XXX_sizecache        int32         `json:"-"`
+}
+
+func (m *RequiredInnerMessage) Reset()         { *m = RequiredInnerMessage{} }
+func (m *RequiredInnerMessage) String() string { return proto.CompactTextString(m) }
+func (*RequiredInnerMessage) ProtoMessage()    {}
+func (*RequiredInnerMessage) Descriptor() ([]byte, []int) {
+       return fileDescriptor_c161fcfdc0c3ff1e, []int{12}
+}
+func (m *RequiredInnerMessage) XXX_Unmarshal(b []byte) error {
+       return xxx_messageInfo_RequiredInnerMessage.Unmarshal(m, b)
+}
+func (m *RequiredInnerMessage) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+       return xxx_messageInfo_RequiredInnerMessage.Marshal(b, m, deterministic)
+}
+func (m *RequiredInnerMessage) XXX_Merge(src proto.Message) {
+       xxx_messageInfo_RequiredInnerMessage.Merge(m, src)
+}
+func (m *RequiredInnerMessage) XXX_Size() int {
+       return xxx_messageInfo_RequiredInnerMessage.Size(m)
+}
+func (m *RequiredInnerMessage) XXX_DiscardUnknown() {
+       xxx_messageInfo_RequiredInnerMessage.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_RequiredInnerMessage proto.InternalMessageInfo
+
+func (m *RequiredInnerMessage) GetLeoFinallyWonAnOscar() *InnerMessage {
+       if m != nil {
+               return m.LeoFinallyWonAnOscar
+       }
+       return nil
+}
+
+type MyMessage struct {
+       Count          *int32                `protobuf:"varint,1,req,name=count" json:"count,omitempty"`
+       Name           *string               `protobuf:"bytes,2,opt,name=name" json:"name,omitempty"`
+       Quote          *string               `protobuf:"bytes,3,opt,name=quote" json:"quote,omitempty"`
+       Pet            []string              `protobuf:"bytes,4,rep,name=pet" json:"pet,omitempty"`
+       Inner          *InnerMessage         `protobuf:"bytes,5,opt,name=inner" json:"inner,omitempty"`
+       Others         []*OtherMessage       `protobuf:"bytes,6,rep,name=others" json:"others,omitempty"`
+       WeMustGoDeeper *RequiredInnerMessage `protobuf:"bytes,13,opt,name=we_must_go_deeper,json=weMustGoDeeper" json:"we_must_go_deeper,omitempty"`
+       RepInner       []*InnerMessage       `protobuf:"bytes,12,rep,name=rep_inner,json=repInner" json:"rep_inner,omitempty"`
+       Bikeshed       *MyMessage_Color      `protobuf:"varint,7,opt,name=bikeshed,enum=test_proto.MyMessage_Color" json:"bikeshed,omitempty"`
+       Somegroup      *MyMessage_SomeGroup  `protobuf:"group,8,opt,name=SomeGroup,json=somegroup" json:"somegroup,omitempty"`
+       // This field becomes [][]byte in the generated code.
+       RepBytes                     [][]byte `protobuf:"bytes,10,rep,name=rep_bytes,json=repBytes" json:"rep_bytes,omitempty"`
+       Bigfloat                     *float64 `protobuf:"fixed64,11,opt,name=bigfloat" json:"bigfloat,omitempty"`
+       XXX_NoUnkeyedLiteral         struct{} `json:"-"`
+       proto.XXX_InternalExtensions `json:"-"`
+       XXX_unrecognized             []byte `json:"-"`
+       XXX_sizecache                int32  `json:"-"`
+}
+
+func (m *MyMessage) Reset()         { *m = MyMessage{} }
+func (m *MyMessage) String() string { return proto.CompactTextString(m) }
+func (*MyMessage) ProtoMessage()    {}
+func (*MyMessage) Descriptor() ([]byte, []int) {
+       return fileDescriptor_c161fcfdc0c3ff1e, []int{13}
+}
+
+var extRange_MyMessage = []proto.ExtensionRange{
+       {Start: 100, End: 536870911},
+}
+
+func (*MyMessage) ExtensionRangeArray() []proto.ExtensionRange {
+       return extRange_MyMessage
+}
+
+func (m *MyMessage) XXX_Unmarshal(b []byte) error {
+       return xxx_messageInfo_MyMessage.Unmarshal(m, b)
+}
+func (m *MyMessage) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+       return xxx_messageInfo_MyMessage.Marshal(b, m, deterministic)
+}
+func (m *MyMessage) XXX_Merge(src proto.Message) {
+       xxx_messageInfo_MyMessage.Merge(m, src)
+}
+func (m *MyMessage) XXX_Size() int {
+       return xxx_messageInfo_MyMessage.Size(m)
+}
+func (m *MyMessage) XXX_DiscardUnknown() {
+       xxx_messageInfo_MyMessage.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_MyMessage proto.InternalMessageInfo
+
+func (m *MyMessage) GetCount() int32 {
+       if m != nil && m.Count != nil {
+               return *m.Count
+       }
+       return 0
+}
+
+func (m *MyMessage) GetName() string {
+       if m != nil && m.Name != nil {
+               return *m.Name
+       }
+       return ""
+}
+
+func (m *MyMessage) GetQuote() string {
+       if m != nil && m.Quote != nil {
+               return *m.Quote
+       }
+       return ""
+}
+
+func (m *MyMessage) GetPet() []string {
+       if m != nil {
+               return m.Pet
+       }
+       return nil
+}
+
+func (m *MyMessage) GetInner() *InnerMessage {
+       if m != nil {
+               return m.Inner
+       }
+       return nil
+}
+
+func (m *MyMessage) GetOthers() []*OtherMessage {
+       if m != nil {
+               return m.Others
+       }
+       return nil
+}
+
+func (m *MyMessage) GetWeMustGoDeeper() *RequiredInnerMessage {
+       if m != nil {
+               return m.WeMustGoDeeper
+       }
+       return nil
+}
+
+func (m *MyMessage) GetRepInner() []*InnerMessage {
+       if m != nil {
+               return m.RepInner
+       }
+       return nil
+}
+
+func (m *MyMessage) GetBikeshed() MyMessage_Color {
+       if m != nil && m.Bikeshed != nil {
+               return *m.Bikeshed
+       }
+       return MyMessage_RED
+}
+
+func (m *MyMessage) GetSomegroup() *MyMessage_SomeGroup {
+       if m != nil {
+               return m.Somegroup
+       }
+       return nil
+}
+
+func (m *MyMessage) GetRepBytes() [][]byte {
+       if m != nil {
+               return m.RepBytes
+       }
+       return nil
+}
+
+func (m *MyMessage) GetBigfloat() float64 {
+       if m != nil && m.Bigfloat != nil {
+               return *m.Bigfloat
+       }
+       return 0
+}
+
+type MyMessage_SomeGroup struct {
+       GroupField           *int32   `protobuf:"varint,9,opt,name=group_field,json=groupField" json:"group_field,omitempty"`
+       XXX_NoUnkeyedLiteral struct{} `json:"-"`
+       XXX_unrecognized     []byte   `json:"-"`
+       XXX_sizecache        int32    `json:"-"`
+}
+
+func (m *MyMessage_SomeGroup) Reset()         { *m = MyMessage_SomeGroup{} }
+func (m *MyMessage_SomeGroup) String() string { return proto.CompactTextString(m) }
+func (*MyMessage_SomeGroup) ProtoMessage()    {}
+func (*MyMessage_SomeGroup) Descriptor() ([]byte, []int) {
+       return fileDescriptor_c161fcfdc0c3ff1e, []int{13, 0}
+}
+func (m *MyMessage_SomeGroup) XXX_Unmarshal(b []byte) error {
+       return xxx_messageInfo_MyMessage_SomeGroup.Unmarshal(m, b)
+}
+func (m *MyMessage_SomeGroup) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+       return xxx_messageInfo_MyMessage_SomeGroup.Marshal(b, m, deterministic)
+}
+func (m *MyMessage_SomeGroup) XXX_Merge(src proto.Message) {
+       xxx_messageInfo_MyMessage_SomeGroup.Merge(m, src)
+}
+func (m *MyMessage_SomeGroup) XXX_Size() int {
+       return xxx_messageInfo_MyMessage_SomeGroup.Size(m)
+}
+func (m *MyMessage_SomeGroup) XXX_DiscardUnknown() {
+       xxx_messageInfo_MyMessage_SomeGroup.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_MyMessage_SomeGroup proto.InternalMessageInfo
+
+func (m *MyMessage_SomeGroup) GetGroupField() int32 {
+       if m != nil && m.GroupField != nil {
+               return *m.GroupField
+       }
+       return 0
+}
+
+type Ext struct {
+       Data                 *string         `protobuf:"bytes,1,opt,name=data" json:"data,omitempty"`
+       MapField             map[int32]int32 `protobuf:"bytes,2,rep,name=map_field,json=mapField" json:"map_field,omitempty" protobuf_key:"varint,1,opt,name=key" protobuf_val:"varint,2,opt,name=value"`
+       XXX_NoUnkeyedLiteral struct{}        `json:"-"`
+       XXX_unrecognized     []byte          `json:"-"`
+       XXX_sizecache        int32           `json:"-"`
+}
+
+func (m *Ext) Reset()         { *m = Ext{} }
+func (m *Ext) String() string { return proto.CompactTextString(m) }
+func (*Ext) ProtoMessage()    {}
+func (*Ext) Descriptor() ([]byte, []int) {
+       return fileDescriptor_c161fcfdc0c3ff1e, []int{14}
+}
+func (m *Ext) XXX_Unmarshal(b []byte) error {
+       return xxx_messageInfo_Ext.Unmarshal(m, b)
+}
+func (m *Ext) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+       return xxx_messageInfo_Ext.Marshal(b, m, deterministic)
+}
+func (m *Ext) XXX_Merge(src proto.Message) {
+       xxx_messageInfo_Ext.Merge(m, src)
+}
+func (m *Ext) XXX_Size() int {
+       return xxx_messageInfo_Ext.Size(m)
+}
+func (m *Ext) XXX_DiscardUnknown() {
+       xxx_messageInfo_Ext.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_Ext proto.InternalMessageInfo
+
+func (m *Ext) GetData() string {
+       if m != nil && m.Data != nil {
+               return *m.Data
+       }
+       return ""
+}
+
+func (m *Ext) GetMapField() map[int32]int32 {
+       if m != nil {
+               return m.MapField
+       }
+       return nil
+}
+
+var E_Ext_More = &proto.ExtensionDesc{
+       ExtendedType:  (*MyMessage)(nil),
+       ExtensionType: (*Ext)(nil),
+       Field:         103,
+       Name:          "test_proto.Ext.more",
+       Tag:           "bytes,103,opt,name=more",
+       Filename:      "test.proto",
+}
+
+var E_Ext_Text = &proto.ExtensionDesc{
+       ExtendedType:  (*MyMessage)(nil),
+       ExtensionType: (*string)(nil),
+       Field:         104,
+       Name:          "test_proto.Ext.text",
+       Tag:           "bytes,104,opt,name=text",
+       Filename:      "test.proto",
+}
+
+var E_Ext_Number = &proto.ExtensionDesc{
+       ExtendedType:  (*MyMessage)(nil),
+       ExtensionType: (*int32)(nil),
+       Field:         105,
+       Name:          "test_proto.Ext.number",
+       Tag:           "varint,105,opt,name=number",
+       Filename:      "test.proto",
+}
+
+type ComplexExtension struct {
+       First                *int32   `protobuf:"varint,1,opt,name=first" json:"first,omitempty"`
+       Second               *int32   `protobuf:"varint,2,opt,name=second" json:"second,omitempty"`
+       Third                []int32  `protobuf:"varint,3,rep,name=third" json:"third,omitempty"`
+       XXX_NoUnkeyedLiteral struct{} `json:"-"`
+       XXX_unrecognized     []byte   `json:"-"`
+       XXX_sizecache        int32    `json:"-"`
+}
+
+func (m *ComplexExtension) Reset()         { *m = ComplexExtension{} }
+func (m *ComplexExtension) String() string { return proto.CompactTextString(m) }
+func (*ComplexExtension) ProtoMessage()    {}
+func (*ComplexExtension) Descriptor() ([]byte, []int) {
+       return fileDescriptor_c161fcfdc0c3ff1e, []int{15}
+}
+func (m *ComplexExtension) XXX_Unmarshal(b []byte) error {
+       return xxx_messageInfo_ComplexExtension.Unmarshal(m, b)
+}
+func (m *ComplexExtension) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+       return xxx_messageInfo_ComplexExtension.Marshal(b, m, deterministic)
+}
+func (m *ComplexExtension) XXX_Merge(src proto.Message) {
+       xxx_messageInfo_ComplexExtension.Merge(m, src)
+}
+func (m *ComplexExtension) XXX_Size() int {
+       return xxx_messageInfo_ComplexExtension.Size(m)
+}
+func (m *ComplexExtension) XXX_DiscardUnknown() {
+       xxx_messageInfo_ComplexExtension.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_ComplexExtension proto.InternalMessageInfo
+
+func (m *ComplexExtension) GetFirst() int32 {
+       if m != nil && m.First != nil {
+               return *m.First
+       }
+       return 0
+}
+
+func (m *ComplexExtension) GetSecond() int32 {
+       if m != nil && m.Second != nil {
+               return *m.Second
+       }
+       return 0
+}
+
+func (m *ComplexExtension) GetThird() []int32 {
+       if m != nil {
+               return m.Third
+       }
+       return nil
+}
+
+type DefaultsMessage struct {
+       XXX_NoUnkeyedLiteral         struct{} `json:"-"`
+       proto.XXX_InternalExtensions `json:"-"`
+       XXX_unrecognized             []byte `json:"-"`
+       XXX_sizecache                int32  `json:"-"`
+}
+
+func (m *DefaultsMessage) Reset()         { *m = DefaultsMessage{} }
+func (m *DefaultsMessage) String() string { return proto.CompactTextString(m) }
+func (*DefaultsMessage) ProtoMessage()    {}
+func (*DefaultsMessage) Descriptor() ([]byte, []int) {
+       return fileDescriptor_c161fcfdc0c3ff1e, []int{16}
+}
+
+var extRange_DefaultsMessage = []proto.ExtensionRange{
+       {Start: 100, End: 536870911},
+}
+
+func (*DefaultsMessage) ExtensionRangeArray() []proto.ExtensionRange {
+       return extRange_DefaultsMessage
+}
+
+func (m *DefaultsMessage) XXX_Unmarshal(b []byte) error {
+       return xxx_messageInfo_DefaultsMessage.Unmarshal(m, b)
+}
+func (m *DefaultsMessage) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+       return xxx_messageInfo_DefaultsMessage.Marshal(b, m, deterministic)
+}
+func (m *DefaultsMessage) XXX_Merge(src proto.Message) {
+       xxx_messageInfo_DefaultsMessage.Merge(m, src)
+}
+func (m *DefaultsMessage) XXX_Size() int {
+       return xxx_messageInfo_DefaultsMessage.Size(m)
+}
+func (m *DefaultsMessage) XXX_DiscardUnknown() {
+       xxx_messageInfo_DefaultsMessage.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_DefaultsMessage proto.InternalMessageInfo
+
+type MyMessageSet struct {
+       XXX_NoUnkeyedLiteral         struct{} `json:"-"`
+       proto.XXX_InternalExtensions `protobuf_messageset:"1" json:"-"`
+       XXX_unrecognized             []byte `json:"-"`
+       XXX_sizecache                int32  `json:"-"`
+}
+
+func (m *MyMessageSet) Reset()         { *m = MyMessageSet{} }
+func (m *MyMessageSet) String() string { return proto.CompactTextString(m) }
+func (*MyMessageSet) ProtoMessage()    {}
+func (*MyMessageSet) Descriptor() ([]byte, []int) {
+       return fileDescriptor_c161fcfdc0c3ff1e, []int{17}
+}
+
+var extRange_MyMessageSet = []proto.ExtensionRange{
+       {Start: 100, End: 2147483646},
+}
+
+func (*MyMessageSet) ExtensionRangeArray() []proto.ExtensionRange {
+       return extRange_MyMessageSet
+}
+
+func (m *MyMessageSet) XXX_Unmarshal(b []byte) error {
+       return xxx_messageInfo_MyMessageSet.Unmarshal(m, b)
+}
+func (m *MyMessageSet) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+       return xxx_messageInfo_MyMessageSet.Marshal(b, m, deterministic)
+}
+func (m *MyMessageSet) XXX_Merge(src proto.Message) {
+       xxx_messageInfo_MyMessageSet.Merge(m, src)
+}
+func (m *MyMessageSet) XXX_Size() int {
+       return xxx_messageInfo_MyMessageSet.Size(m)
+}
+func (m *MyMessageSet) XXX_DiscardUnknown() {
+       xxx_messageInfo_MyMessageSet.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_MyMessageSet proto.InternalMessageInfo
+
+type Empty struct {
+       XXX_NoUnkeyedLiteral struct{} `json:"-"`
+       XXX_unrecognized     []byte   `json:"-"`
+       XXX_sizecache        int32    `json:"-"`
+}
+
+func (m *Empty) Reset()         { *m = Empty{} }
+func (m *Empty) String() string { return proto.CompactTextString(m) }
+func (*Empty) ProtoMessage()    {}
+func (*Empty) Descriptor() ([]byte, []int) {
+       return fileDescriptor_c161fcfdc0c3ff1e, []int{18}
+}
+func (m *Empty) XXX_Unmarshal(b []byte) error {
+       return xxx_messageInfo_Empty.Unmarshal(m, b)
+}
+func (m *Empty) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+       return xxx_messageInfo_Empty.Marshal(b, m, deterministic)
+}
+func (m *Empty) XXX_Merge(src proto.Message) {
+       xxx_messageInfo_Empty.Merge(m, src)
+}
+func (m *Empty) XXX_Size() int {
+       return xxx_messageInfo_Empty.Size(m)
+}
+func (m *Empty) XXX_DiscardUnknown() {
+       xxx_messageInfo_Empty.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_Empty proto.InternalMessageInfo
+
+type MessageList struct {
+       Message              []*MessageList_Message `protobuf:"group,1,rep,name=Message,json=message" json:"message,omitempty"`
+       XXX_NoUnkeyedLiteral struct{}               `json:"-"`
+       XXX_unrecognized     []byte                 `json:"-"`
+       XXX_sizecache        int32                  `json:"-"`
+}
+
+func (m *MessageList) Reset()         { *m = MessageList{} }
+func (m *MessageList) String() string { return proto.CompactTextString(m) }
+func (*MessageList) ProtoMessage()    {}
+func (*MessageList) Descriptor() ([]byte, []int) {
+       return fileDescriptor_c161fcfdc0c3ff1e, []int{19}
+}
+func (m *MessageList) XXX_Unmarshal(b []byte) error {
+       return xxx_messageInfo_MessageList.Unmarshal(m, b)
+}
+func (m *MessageList) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+       return xxx_messageInfo_MessageList.Marshal(b, m, deterministic)
+}
+func (m *MessageList) XXX_Merge(src proto.Message) {
+       xxx_messageInfo_MessageList.Merge(m, src)
+}
+func (m *MessageList) XXX_Size() int {
+       return xxx_messageInfo_MessageList.Size(m)
+}
+func (m *MessageList) XXX_DiscardUnknown() {
+       xxx_messageInfo_MessageList.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_MessageList proto.InternalMessageInfo
+
+func (m *MessageList) GetMessage() []*MessageList_Message {
+       if m != nil {
+               return m.Message
+       }
+       return nil
+}
+
+type MessageList_Message struct {
+       Name                 *string  `protobuf:"bytes,2,req,name=name" json:"name,omitempty"`
+       Count                *int32   `protobuf:"varint,3,req,name=count" json:"count,omitempty"`
+       XXX_NoUnkeyedLiteral struct{} `json:"-"`
+       XXX_unrecognized     []byte   `json:"-"`
+       XXX_sizecache        int32    `json:"-"`
+}
+
+func (m *MessageList_Message) Reset()         { *m = MessageList_Message{} }
+func (m *MessageList_Message) String() string { return proto.CompactTextString(m) }
+func (*MessageList_Message) ProtoMessage()    {}
+func (*MessageList_Message) Descriptor() ([]byte, []int) {
+       return fileDescriptor_c161fcfdc0c3ff1e, []int{19, 0}
+}
+func (m *MessageList_Message) XXX_Unmarshal(b []byte) error {
+       return xxx_messageInfo_MessageList_Message.Unmarshal(m, b)
+}
+func (m *MessageList_Message) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+       return xxx_messageInfo_MessageList_Message.Marshal(b, m, deterministic)
+}
+func (m *MessageList_Message) XXX_Merge(src proto.Message) {
+       xxx_messageInfo_MessageList_Message.Merge(m, src)
+}
+func (m *MessageList_Message) XXX_Size() int {
+       return xxx_messageInfo_MessageList_Message.Size(m)
+}
+func (m *MessageList_Message) XXX_DiscardUnknown() {
+       xxx_messageInfo_MessageList_Message.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_MessageList_Message proto.InternalMessageInfo
+
+func (m *MessageList_Message) GetName() string {
+       if m != nil && m.Name != nil {
+               return *m.Name
+       }
+       return ""
+}
+
+func (m *MessageList_Message) GetCount() int32 {
+       if m != nil && m.Count != nil {
+               return *m.Count
+       }
+       return 0
+}
+
+type Strings struct {
+       StringField          *string  `protobuf:"bytes,1,opt,name=string_field,json=stringField" json:"string_field,omitempty"`
+       BytesField           []byte   `protobuf:"bytes,2,opt,name=bytes_field,json=bytesField" json:"bytes_field,omitempty"`
+       XXX_NoUnkeyedLiteral struct{} `json:"-"`
+       XXX_unrecognized     []byte   `json:"-"`
+       XXX_sizecache        int32    `json:"-"`
+}
+
+func (m *Strings) Reset()         { *m = Strings{} }
+func (m *Strings) String() string { return proto.CompactTextString(m) }
+func (*Strings) ProtoMessage()    {}
+func (*Strings) Descriptor() ([]byte, []int) {
+       return fileDescriptor_c161fcfdc0c3ff1e, []int{20}
+}
+func (m *Strings) XXX_Unmarshal(b []byte) error {
+       return xxx_messageInfo_Strings.Unmarshal(m, b)
+}
+func (m *Strings) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+       return xxx_messageInfo_Strings.Marshal(b, m, deterministic)
+}
+func (m *Strings) XXX_Merge(src proto.Message) {
+       xxx_messageInfo_Strings.Merge(m, src)
+}
+func (m *Strings) XXX_Size() int {
+       return xxx_messageInfo_Strings.Size(m)
+}
+func (m *Strings) XXX_DiscardUnknown() {
+       xxx_messageInfo_Strings.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_Strings proto.InternalMessageInfo
+
+func (m *Strings) GetStringField() string {
+       if m != nil && m.StringField != nil {
+               return *m.StringField
+       }
+       return ""
+}
+
+func (m *Strings) GetBytesField() []byte {
+       if m != nil {
+               return m.BytesField
+       }
+       return nil
+}
+
+type Defaults struct {
+       // Default-valued fields of all basic types.
+       // Same as GoTest, but copied here to make testing easier.
+       F_Bool    *bool           `protobuf:"varint,1,opt,name=F_Bool,json=FBool,def=1" json:"F_Bool,omitempty"`
+       F_Int32   *int32          `protobuf:"varint,2,opt,name=F_Int32,json=FInt32,def=32" json:"F_Int32,omitempty"`
+       F_Int64   *int64          `protobuf:"varint,3,opt,name=F_Int64,json=FInt64,def=64" json:"F_Int64,omitempty"`
+       F_Fixed32 *uint32         `protobuf:"fixed32,4,opt,name=F_Fixed32,json=FFixed32,def=320" json:"F_Fixed32,omitempty"`
+       F_Fixed64 *uint64         `protobuf:"fixed64,5,opt,name=F_Fixed64,json=FFixed64,def=640" json:"F_Fixed64,omitempty"`
+       F_Uint32  *uint32         `protobuf:"varint,6,opt,name=F_Uint32,json=FUint32,def=3200" json:"F_Uint32,omitempty"`
+       F_Uint64  *uint64         `protobuf:"varint,7,opt,name=F_Uint64,json=FUint64,def=6400" json:"F_Uint64,omitempty"`
+       F_Float   *float32        `protobuf:"fixed32,8,opt,name=F_Float,json=FFloat,def=314159" json:"F_Float,omitempty"`
+       F_Double  *float64        `protobuf:"fixed64,9,opt,name=F_Double,json=FDouble,def=271828" json:"F_Double,omitempty"`
+       F_String  *string         `protobuf:"bytes,10,opt,name=F_String,json=FString,def=hello, \"world!\"\n" json:"F_String,omitempty"`
+       F_Bytes   []byte          `protobuf:"bytes,11,opt,name=F_Bytes,json=FBytes,def=Bignose" json:"F_Bytes,omitempty"`
+       F_Sint32  *int32          `protobuf:"zigzag32,12,opt,name=F_Sint32,json=FSint32,def=-32" json:"F_Sint32,omitempty"`
+       F_Sint64  *int64          `protobuf:"zigzag64,13,opt,name=F_Sint64,json=FSint64,def=-64" json:"F_Sint64,omitempty"`
+       F_Enum    *Defaults_Color `protobuf:"varint,14,opt,name=F_Enum,json=FEnum,enum=test_proto.Defaults_Color,def=1" json:"F_Enum,omitempty"`
+       // More fields with crazy defaults.
+       F_Pinf *float32 `protobuf:"fixed32,15,opt,name=F_Pinf,json=FPinf,def=inf" json:"F_Pinf,omitempty"`
+       F_Ninf *float32 `protobuf:"fixed32,16,opt,name=F_Ninf,json=FNinf,def=-inf" json:"F_Ninf,omitempty"`
+       F_Nan  *float32 `protobuf:"fixed32,17,opt,name=F_Nan,json=FNan,def=nan" json:"F_Nan,omitempty"`
+       // Sub-message.
+       Sub *SubDefaults `protobuf:"bytes,18,opt,name=sub" json:"sub,omitempty"`
+       // Redundant but explicit defaults.
+       StrZero              *string  `protobuf:"bytes,19,opt,name=str_zero,json=strZero,def=" json:"str_zero,omitempty"`
+       XXX_NoUnkeyedLiteral struct{} `json:"-"`
+       XXX_unrecognized     []byte   `json:"-"`
+       XXX_sizecache        int32    `json:"-"`
+}
+
+func (m *Defaults) Reset()         { *m = Defaults{} }
+func (m *Defaults) String() string { return proto.CompactTextString(m) }
+func (*Defaults) ProtoMessage()    {}
+func (*Defaults) Descriptor() ([]byte, []int) {
+       return fileDescriptor_c161fcfdc0c3ff1e, []int{21}
+}
+func (m *Defaults) XXX_Unmarshal(b []byte) error {
+       return xxx_messageInfo_Defaults.Unmarshal(m, b)
+}
+func (m *Defaults) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+       return xxx_messageInfo_Defaults.Marshal(b, m, deterministic)
+}
+func (m *Defaults) XXX_Merge(src proto.Message) {
+       xxx_messageInfo_Defaults.Merge(m, src)
+}
+func (m *Defaults) XXX_Size() int {
+       return xxx_messageInfo_Defaults.Size(m)
+}
+func (m *Defaults) XXX_DiscardUnknown() {
+       xxx_messageInfo_Defaults.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_Defaults proto.InternalMessageInfo
+
+const Default_Defaults_F_Bool bool = true
+const Default_Defaults_F_Int32 int32 = 32
+const Default_Defaults_F_Int64 int64 = 64
+const Default_Defaults_F_Fixed32 uint32 = 320
+const Default_Defaults_F_Fixed64 uint64 = 640
+const Default_Defaults_F_Uint32 uint32 = 3200
+const Default_Defaults_F_Uint64 uint64 = 6400
+const Default_Defaults_F_Float float32 = 314159
+const Default_Defaults_F_Double float64 = 271828
+const Default_Defaults_F_String string = "hello, \"world!\"\n"
+
+var Default_Defaults_F_Bytes []byte = []byte("Bignose")
+
+const Default_Defaults_F_Sint32 int32 = -32
+const Default_Defaults_F_Sint64 int64 = -64
+const Default_Defaults_F_Enum Defaults_Color = Defaults_GREEN
+
+var Default_Defaults_F_Pinf float32 = float32(math.Inf(1))
+var Default_Defaults_F_Ninf float32 = float32(math.Inf(-1))
+var Default_Defaults_F_Nan float32 = float32(math.NaN())
+
+func (m *Defaults) GetF_Bool() bool {
+       if m != nil && m.F_Bool != nil {
+               return *m.F_Bool
+       }
+       return Default_Defaults_F_Bool
+}
+
+func (m *Defaults) GetF_Int32() int32 {
+       if m != nil && m.F_Int32 != nil {
+               return *m.F_Int32
+       }
+       return Default_Defaults_F_Int32
+}
+
+func (m *Defaults) GetF_Int64() int64 {
+       if m != nil && m.F_Int64 != nil {
+               return *m.F_Int64
+       }
+       return Default_Defaults_F_Int64
+}
+
+func (m *Defaults) GetF_Fixed32() uint32 {
+       if m != nil && m.F_Fixed32 != nil {
+               return *m.F_Fixed32
+       }
+       return Default_Defaults_F_Fixed32
+}
+
+func (m *Defaults) GetF_Fixed64() uint64 {
+       if m != nil && m.F_Fixed64 != nil {
+               return *m.F_Fixed64
+       }
+       return Default_Defaults_F_Fixed64
+}
+
+func (m *Defaults) GetF_Uint32() uint32 {
+       if m != nil && m.F_Uint32 != nil {
+               return *m.F_Uint32
+       }
+       return Default_Defaults_F_Uint32
+}
+
+func (m *Defaults) GetF_Uint64() uint64 {
+       if m != nil && m.F_Uint64 != nil {
+               return *m.F_Uint64
+       }
+       return Default_Defaults_F_Uint64
+}
+
+func (m *Defaults) GetF_Float() float32 {
+       if m != nil && m.F_Float != nil {
+               return *m.F_Float
+       }
+       return Default_Defaults_F_Float
+}
+
+func (m *Defaults) GetF_Double() float64 {
+       if m != nil && m.F_Double != nil {
+               return *m.F_Double
+       }
+       return Default_Defaults_F_Double
+}
+
+func (m *Defaults) GetF_String() string {
+       if m != nil && m.F_String != nil {
+               return *m.F_String
+       }
+       return Default_Defaults_F_String
+}
+
+func (m *Defaults) GetF_Bytes() []byte {
+       if m != nil && m.F_Bytes != nil {
+               return m.F_Bytes
+       }
+       return append([]byte(nil), Default_Defaults_F_Bytes...)
+}
+
+func (m *Defaults) GetF_Sint32() int32 {
+       if m != nil && m.F_Sint32 != nil {
+               return *m.F_Sint32
+       }
+       return Default_Defaults_F_Sint32
+}
+
+func (m *Defaults) GetF_Sint64() int64 {
+       if m != nil && m.F_Sint64 != nil {
+               return *m.F_Sint64
+       }
+       return Default_Defaults_F_Sint64
+}
+
+func (m *Defaults) GetF_Enum() Defaults_Color {
+       if m != nil && m.F_Enum != nil {
+               return *m.F_Enum
+       }
+       return Default_Defaults_F_Enum
+}
+
+func (m *Defaults) GetF_Pinf() float32 {
+       if m != nil && m.F_Pinf != nil {
+               return *m.F_Pinf
+       }
+       return Default_Defaults_F_Pinf
+}
+
+func (m *Defaults) GetF_Ninf() float32 {
+       if m != nil && m.F_Ninf != nil {
+               return *m.F_Ninf
+       }
+       return Default_Defaults_F_Ninf
+}
+
+func (m *Defaults) GetF_Nan() float32 {
+       if m != nil && m.F_Nan != nil {
+               return *m.F_Nan
+       }
+       return Default_Defaults_F_Nan
+}
+
+func (m *Defaults) GetSub() *SubDefaults {
+       if m != nil {
+               return m.Sub
+       }
+       return nil
+}
+
+func (m *Defaults) GetStrZero() string {
+       if m != nil && m.StrZero != nil {
+               return *m.StrZero
+       }
+       return ""
+}
+
+type SubDefaults struct {
+       N                    *int64   `protobuf:"varint,1,opt,name=n,def=7" json:"n,omitempty"`
+       XXX_NoUnkeyedLiteral struct{} `json:"-"`
+       XXX_unrecognized     []byte   `json:"-"`
+       XXX_sizecache        int32    `json:"-"`
+}
+
+func (m *SubDefaults) Reset()         { *m = SubDefaults{} }
+func (m *SubDefaults) String() string { return proto.CompactTextString(m) }
+func (*SubDefaults) ProtoMessage()    {}
+func (*SubDefaults) Descriptor() ([]byte, []int) {
+       return fileDescriptor_c161fcfdc0c3ff1e, []int{22}
+}
+func (m *SubDefaults) XXX_Unmarshal(b []byte) error {
+       return xxx_messageInfo_SubDefaults.Unmarshal(m, b)
+}
+func (m *SubDefaults) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+       return xxx_messageInfo_SubDefaults.Marshal(b, m, deterministic)
+}
+func (m *SubDefaults) XXX_Merge(src proto.Message) {
+       xxx_messageInfo_SubDefaults.Merge(m, src)
+}
+func (m *SubDefaults) XXX_Size() int {
+       return xxx_messageInfo_SubDefaults.Size(m)
+}
+func (m *SubDefaults) XXX_DiscardUnknown() {
+       xxx_messageInfo_SubDefaults.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_SubDefaults proto.InternalMessageInfo
+
+const Default_SubDefaults_N int64 = 7
+
+func (m *SubDefaults) GetN() int64 {
+       if m != nil && m.N != nil {
+               return *m.N
+       }
+       return Default_SubDefaults_N
+}
+
+type RepeatedEnum struct {
+       Color                []RepeatedEnum_Color `protobuf:"varint,1,rep,name=color,enum=test_proto.RepeatedEnum_Color" json:"color,omitempty"`
+       XXX_NoUnkeyedLiteral struct{}             `json:"-"`
+       XXX_unrecognized     []byte               `json:"-"`
+       XXX_sizecache        int32                `json:"-"`
+}
+
+func (m *RepeatedEnum) Reset()         { *m = RepeatedEnum{} }
+func (m *RepeatedEnum) String() string { return proto.CompactTextString(m) }
+func (*RepeatedEnum) ProtoMessage()    {}
+func (*RepeatedEnum) Descriptor() ([]byte, []int) {
+       return fileDescriptor_c161fcfdc0c3ff1e, []int{23}
+}
+func (m *RepeatedEnum) XXX_Unmarshal(b []byte) error {
+       return xxx_messageInfo_RepeatedEnum.Unmarshal(m, b)
+}
+func (m *RepeatedEnum) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+       return xxx_messageInfo_RepeatedEnum.Marshal(b, m, deterministic)
+}
+func (m *RepeatedEnum) XXX_Merge(src proto.Message) {
+       xxx_messageInfo_RepeatedEnum.Merge(m, src)
+}
+func (m *RepeatedEnum) XXX_Size() int {
+       return xxx_messageInfo_RepeatedEnum.Size(m)
+}
+func (m *RepeatedEnum) XXX_DiscardUnknown() {
+       xxx_messageInfo_RepeatedEnum.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_RepeatedEnum proto.InternalMessageInfo
+
+func (m *RepeatedEnum) GetColor() []RepeatedEnum_Color {
+       if m != nil {
+               return m.Color
+       }
+       return nil
+}
+
+type MoreRepeated struct {
+       Bools                []bool   `protobuf:"varint,1,rep,name=bools" json:"bools,omitempty"`
+       BoolsPacked          []bool   `protobuf:"varint,2,rep,packed,name=bools_packed,json=boolsPacked" json:"bools_packed,omitempty"`
+       Ints                 []int32  `protobuf:"varint,3,rep,name=ints" json:"ints,omitempty"`
+       IntsPacked           []int32  `protobuf:"varint,4,rep,packed,name=ints_packed,json=intsPacked" json:"ints_packed,omitempty"`
+       Int64SPacked         []int64  `protobuf:"varint,7,rep,packed,name=int64s_packed,json=int64sPacked" json:"int64s_packed,omitempty"`
+       Strings              []string `protobuf:"bytes,5,rep,name=strings" json:"strings,omitempty"`
+       Fixeds               []uint32 `protobuf:"fixed32,6,rep,name=fixeds" json:"fixeds,omitempty"`
+       XXX_NoUnkeyedLiteral struct{} `json:"-"`
+       XXX_unrecognized     []byte   `json:"-"`
+       XXX_sizecache        int32    `json:"-"`
+}
+
+func (m *MoreRepeated) Reset()         { *m = MoreRepeated{} }
+func (m *MoreRepeated) String() string { return proto.CompactTextString(m) }
+func (*MoreRepeated) ProtoMessage()    {}
+func (*MoreRepeated) Descriptor() ([]byte, []int) {
+       return fileDescriptor_c161fcfdc0c3ff1e, []int{24}
+}
+func (m *MoreRepeated) XXX_Unmarshal(b []byte) error {
+       return xxx_messageInfo_MoreRepeated.Unmarshal(m, b)
+}
+func (m *MoreRepeated) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+       return xxx_messageInfo_MoreRepeated.Marshal(b, m, deterministic)
+}
+func (m *MoreRepeated) XXX_Merge(src proto.Message) {
+       xxx_messageInfo_MoreRepeated.Merge(m, src)
+}
+func (m *MoreRepeated) XXX_Size() int {
+       return xxx_messageInfo_MoreRepeated.Size(m)
+}
+func (m *MoreRepeated) XXX_DiscardUnknown() {
+       xxx_messageInfo_MoreRepeated.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_MoreRepeated proto.InternalMessageInfo
+
+func (m *MoreRepeated) GetBools() []bool {
+       if m != nil {
+               return m.Bools
+       }
+       return nil
+}
+
+func (m *MoreRepeated) GetBoolsPacked() []bool {
+       if m != nil {
+               return m.BoolsPacked
+       }
+       return nil
+}
+
+func (m *MoreRepeated) GetInts() []int32 {
+       if m != nil {
+               return m.Ints
+       }
+       return nil
+}
+
+func (m *MoreRepeated) GetIntsPacked() []int32 {
+       if m != nil {
+               return m.IntsPacked
+       }
+       return nil
+}
+
+func (m *MoreRepeated) GetInt64SPacked() []int64 {
+       if m != nil {
+               return m.Int64SPacked
+       }
+       return nil
+}
+
+func (m *MoreRepeated) GetStrings() []string {
+       if m != nil {
+               return m.Strings
+       }
+       return nil
+}
+
+func (m *MoreRepeated) GetFixeds() []uint32 {
+       if m != nil {
+               return m.Fixeds
+       }
+       return nil
+}
+
+type GroupOld struct {
+       G                    *GroupOld_G `protobuf:"group,101,opt,name=G,json=g" json:"g,omitempty"`
+       XXX_NoUnkeyedLiteral struct{}    `json:"-"`
+       XXX_unrecognized     []byte      `json:"-"`
+       XXX_sizecache        int32       `json:"-"`
+}
+
+func (m *GroupOld) Reset()         { *m = GroupOld{} }
+func (m *GroupOld) String() string { return proto.CompactTextString(m) }
+func (*GroupOld) ProtoMessage()    {}
+func (*GroupOld) Descriptor() ([]byte, []int) {
+       return fileDescriptor_c161fcfdc0c3ff1e, []int{25}
+}
+func (m *GroupOld) XXX_Unmarshal(b []byte) error {
+       return xxx_messageInfo_GroupOld.Unmarshal(m, b)
+}
+func (m *GroupOld) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+       return xxx_messageInfo_GroupOld.Marshal(b, m, deterministic)
+}
+func (m *GroupOld) XXX_Merge(src proto.Message) {
+       xxx_messageInfo_GroupOld.Merge(m, src)
+}
+func (m *GroupOld) XXX_Size() int {
+       return xxx_messageInfo_GroupOld.Size(m)
+}
+func (m *GroupOld) XXX_DiscardUnknown() {
+       xxx_messageInfo_GroupOld.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_GroupOld proto.InternalMessageInfo
+
+func (m *GroupOld) GetG() *GroupOld_G {
+       if m != nil {
+               return m.G
+       }
+       return nil
+}
+
+type GroupOld_G struct {
+       X                    *int32   `protobuf:"varint,2,opt,name=x" json:"x,omitempty"`
+       XXX_NoUnkeyedLiteral struct{} `json:"-"`
+       XXX_unrecognized     []byte   `json:"-"`
+       XXX_sizecache        int32    `json:"-"`
+}
+
+func (m *GroupOld_G) Reset()         { *m = GroupOld_G{} }
+func (m *GroupOld_G) String() string { return proto.CompactTextString(m) }
+func (*GroupOld_G) ProtoMessage()    {}
+func (*GroupOld_G) Descriptor() ([]byte, []int) {
+       return fileDescriptor_c161fcfdc0c3ff1e, []int{25, 0}
+}
+func (m *GroupOld_G) XXX_Unmarshal(b []byte) error {
+       return xxx_messageInfo_GroupOld_G.Unmarshal(m, b)
+}
+func (m *GroupOld_G) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+       return xxx_messageInfo_GroupOld_G.Marshal(b, m, deterministic)
+}
+func (m *GroupOld_G) XXX_Merge(src proto.Message) {
+       xxx_messageInfo_GroupOld_G.Merge(m, src)
+}
+func (m *GroupOld_G) XXX_Size() int {
+       return xxx_messageInfo_GroupOld_G.Size(m)
+}
+func (m *GroupOld_G) XXX_DiscardUnknown() {
+       xxx_messageInfo_GroupOld_G.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_GroupOld_G proto.InternalMessageInfo
+
+func (m *GroupOld_G) GetX() int32 {
+       if m != nil && m.X != nil {
+               return *m.X
+       }
+       return 0
+}
+
+type GroupNew struct {
+       G                    *GroupNew_G `protobuf:"group,101,opt,name=G,json=g" json:"g,omitempty"`
+       XXX_NoUnkeyedLiteral struct{}    `json:"-"`
+       XXX_unrecognized     []byte      `json:"-"`
+       XXX_sizecache        int32       `json:"-"`
+}
+
+func (m *GroupNew) Reset()         { *m = GroupNew{} }
+func (m *GroupNew) String() string { return proto.CompactTextString(m) }
+func (*GroupNew) ProtoMessage()    {}
+func (*GroupNew) Descriptor() ([]byte, []int) {
+       return fileDescriptor_c161fcfdc0c3ff1e, []int{26}
+}
+func (m *GroupNew) XXX_Unmarshal(b []byte) error {
+       return xxx_messageInfo_GroupNew.Unmarshal(m, b)
+}
+func (m *GroupNew) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+       return xxx_messageInfo_GroupNew.Marshal(b, m, deterministic)
+}
+func (m *GroupNew) XXX_Merge(src proto.Message) {
+       xxx_messageInfo_GroupNew.Merge(m, src)
+}
+func (m *GroupNew) XXX_Size() int {
+       return xxx_messageInfo_GroupNew.Size(m)
+}
+func (m *GroupNew) XXX_DiscardUnknown() {
+       xxx_messageInfo_GroupNew.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_GroupNew proto.InternalMessageInfo
+
+func (m *GroupNew) GetG() *GroupNew_G {
+       if m != nil {
+               return m.G
+       }
+       return nil
+}
+
+type GroupNew_G struct {
+       X                    *int32   `protobuf:"varint,2,opt,name=x" json:"x,omitempty"`
+       Y                    *int32   `protobuf:"varint,3,opt,name=y" json:"y,omitempty"`
+       XXX_NoUnkeyedLiteral struct{} `json:"-"`
+       XXX_unrecognized     []byte   `json:"-"`
+       XXX_sizecache        int32    `json:"-"`
+}
+
+func (m *GroupNew_G) Reset()         { *m = GroupNew_G{} }
+func (m *GroupNew_G) String() string { return proto.CompactTextString(m) }
+func (*GroupNew_G) ProtoMessage()    {}
+func (*GroupNew_G) Descriptor() ([]byte, []int) {
+       return fileDescriptor_c161fcfdc0c3ff1e, []int{26, 0}
+}
+func (m *GroupNew_G) XXX_Unmarshal(b []byte) error {
+       return xxx_messageInfo_GroupNew_G.Unmarshal(m, b)
+}
+func (m *GroupNew_G) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+       return xxx_messageInfo_GroupNew_G.Marshal(b, m, deterministic)
+}
+func (m *GroupNew_G) XXX_Merge(src proto.Message) {
+       xxx_messageInfo_GroupNew_G.Merge(m, src)
+}
+func (m *GroupNew_G) XXX_Size() int {
+       return xxx_messageInfo_GroupNew_G.Size(m)
+}
+func (m *GroupNew_G) XXX_DiscardUnknown() {
+       xxx_messageInfo_GroupNew_G.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_GroupNew_G proto.InternalMessageInfo
+
+func (m *GroupNew_G) GetX() int32 {
+       if m != nil && m.X != nil {
+               return *m.X
+       }
+       return 0
+}
+
+func (m *GroupNew_G) GetY() int32 {
+       if m != nil && m.Y != nil {
+               return *m.Y
+       }
+       return 0
+}
+
+type FloatingPoint struct {
+       F                    *float64 `protobuf:"fixed64,1,req,name=f" json:"f,omitempty"`
+       Exact                *bool    `protobuf:"varint,2,opt,name=exact" json:"exact,omitempty"`
+       XXX_NoUnkeyedLiteral struct{} `json:"-"`
+       XXX_unrecognized     []byte   `json:"-"`
+       XXX_sizecache        int32    `json:"-"`
+}
+
+func (m *FloatingPoint) Reset()         { *m = FloatingPoint{} }
+func (m *FloatingPoint) String() string { return proto.CompactTextString(m) }
+func (*FloatingPoint) ProtoMessage()    {}
+func (*FloatingPoint) Descriptor() ([]byte, []int) {
+       return fileDescriptor_c161fcfdc0c3ff1e, []int{27}
+}
+func (m *FloatingPoint) XXX_Unmarshal(b []byte) error {
+       return xxx_messageInfo_FloatingPoint.Unmarshal(m, b)
+}
+func (m *FloatingPoint) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+       return xxx_messageInfo_FloatingPoint.Marshal(b, m, deterministic)
+}
+func (m *FloatingPoint) XXX_Merge(src proto.Message) {
+       xxx_messageInfo_FloatingPoint.Merge(m, src)
+}
+func (m *FloatingPoint) XXX_Size() int {
+       return xxx_messageInfo_FloatingPoint.Size(m)
+}
+func (m *FloatingPoint) XXX_DiscardUnknown() {
+       xxx_messageInfo_FloatingPoint.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_FloatingPoint proto.InternalMessageInfo
+
+func (m *FloatingPoint) GetF() float64 {
+       if m != nil && m.F != nil {
+               return *m.F
+       }
+       return 0
+}
+
+func (m *FloatingPoint) GetExact() bool {
+       if m != nil && m.Exact != nil {
+               return *m.Exact
+       }
+       return false
+}
+
+type MessageWithMap struct {
+       NameMapping          map[int32]string         `protobuf:"bytes,1,rep,name=name_mapping,json=nameMapping" json:"name_mapping,omitempty" protobuf_key:"varint,1,opt,name=key" protobuf_val:"bytes,2,opt,name=value"`
+       MsgMapping           map[int64]*FloatingPoint `protobuf:"bytes,2,rep,name=msg_mapping,json=msgMapping" json:"msg_mapping,omitempty" protobuf_key:"zigzag64,1,opt,name=key" protobuf_val:"bytes,2,opt,name=value"`
+       ByteMapping          map[bool][]byte          `protobuf:"bytes,3,rep,name=byte_mapping,json=byteMapping" json:"byte_mapping,omitempty" protobuf_key:"varint,1,opt,name=key" protobuf_val:"bytes,2,opt,name=value"`
+       StrToStr             map[string]string        `protobuf:"bytes,4,rep,name=str_to_str,json=strToStr" json:"str_to_str,omitempty" protobuf_key:"bytes,1,opt,name=key" protobuf_val:"bytes,2,opt,name=value"`
+       XXX_NoUnkeyedLiteral struct{}                 `json:"-"`
+       XXX_unrecognized     []byte                   `json:"-"`
+       XXX_sizecache        int32                    `json:"-"`
+}
+
+func (m *MessageWithMap) Reset()         { *m = MessageWithMap{} }
+func (m *MessageWithMap) String() string { return proto.CompactTextString(m) }
+func (*MessageWithMap) ProtoMessage()    {}
+func (*MessageWithMap) Descriptor() ([]byte, []int) {
+       return fileDescriptor_c161fcfdc0c3ff1e, []int{28}
+}
+func (m *MessageWithMap) XXX_Unmarshal(b []byte) error {
+       return xxx_messageInfo_MessageWithMap.Unmarshal(m, b)
+}
+func (m *MessageWithMap) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+       return xxx_messageInfo_MessageWithMap.Marshal(b, m, deterministic)
+}
+func (m *MessageWithMap) XXX_Merge(src proto.Message) {
+       xxx_messageInfo_MessageWithMap.Merge(m, src)
+}
+func (m *MessageWithMap) XXX_Size() int {
+       return xxx_messageInfo_MessageWithMap.Size(m)
+}
+func (m *MessageWithMap) XXX_DiscardUnknown() {
+       xxx_messageInfo_MessageWithMap.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_MessageWithMap proto.InternalMessageInfo
+
+func (m *MessageWithMap) GetNameMapping() map[int32]string {
+       if m != nil {
+               return m.NameMapping
+       }
+       return nil
+}
+
+func (m *MessageWithMap) GetMsgMapping() map[int64]*FloatingPoint {
+       if m != nil {
+               return m.MsgMapping
+       }
+       return nil
+}
+
+func (m *MessageWithMap) GetByteMapping() map[bool][]byte {
+       if m != nil {
+               return m.ByteMapping
+       }
+       return nil
+}
+
+func (m *MessageWithMap) GetStrToStr() map[string]string {
+       if m != nil {
+               return m.StrToStr
+       }
+       return nil
+}
+
+type Oneof struct {
+       // Types that are valid to be assigned to Union:
+       //      *Oneof_F_Bool
+       //      *Oneof_F_Int32
+       //      *Oneof_F_Int64
+       //      *Oneof_F_Fixed32
+       //      *Oneof_F_Fixed64
+       //      *Oneof_F_Uint32
+       //      *Oneof_F_Uint64
+       //      *Oneof_F_Float
+       //      *Oneof_F_Double
+       //      *Oneof_F_String
+       //      *Oneof_F_Bytes
+       //      *Oneof_F_Sint32
+       //      *Oneof_F_Sint64
+       //      *Oneof_F_Enum
+       //      *Oneof_F_Message
+       //      *Oneof_FGroup
+       //      *Oneof_F_Largest_Tag
+       Union isOneof_Union `protobuf_oneof:"union"`
+       // Types that are valid to be assigned to Tormato:
+       //      *Oneof_Value
+       Tormato              isOneof_Tormato `protobuf_oneof:"tormato"`
+       XXX_NoUnkeyedLiteral struct{}        `json:"-"`
+       XXX_unrecognized     []byte          `json:"-"`
+       XXX_sizecache        int32           `json:"-"`
+}
+
+func (m *Oneof) Reset()         { *m = Oneof{} }
+func (m *Oneof) String() string { return proto.CompactTextString(m) }
+func (*Oneof) ProtoMessage()    {}
+func (*Oneof) Descriptor() ([]byte, []int) {
+       return fileDescriptor_c161fcfdc0c3ff1e, []int{29}
+}
+func (m *Oneof) XXX_Unmarshal(b []byte) error {
+       return xxx_messageInfo_Oneof.Unmarshal(m, b)
+}
+func (m *Oneof) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+       return xxx_messageInfo_Oneof.Marshal(b, m, deterministic)
+}
+func (m *Oneof) XXX_Merge(src proto.Message) {
+       xxx_messageInfo_Oneof.Merge(m, src)
+}
+func (m *Oneof) XXX_Size() int {
+       return xxx_messageInfo_Oneof.Size(m)
+}
+func (m *Oneof) XXX_DiscardUnknown() {
+       xxx_messageInfo_Oneof.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_Oneof proto.InternalMessageInfo
+
+type isOneof_Union interface {
+       isOneof_Union()
+}
+type isOneof_Tormato interface {
+       isOneof_Tormato()
+}
+
+type Oneof_F_Bool struct {
+       F_Bool bool `protobuf:"varint,1,opt,name=F_Bool,json=FBool,oneof"`
+}
+type Oneof_F_Int32 struct {
+       F_Int32 int32 `protobuf:"varint,2,opt,name=F_Int32,json=FInt32,oneof"`
+}
+type Oneof_F_Int64 struct {
+       F_Int64 int64 `protobuf:"varint,3,opt,name=F_Int64,json=FInt64,oneof"`
+}
+type Oneof_F_Fixed32 struct {
+       F_Fixed32 uint32 `protobuf:"fixed32,4,opt,name=F_Fixed32,json=FFixed32,oneof"`
+}
+type Oneof_F_Fixed64 struct {
+       F_Fixed64 uint64 `protobuf:"fixed64,5,opt,name=F_Fixed64,json=FFixed64,oneof"`
+}
+type Oneof_F_Uint32 struct {
+       F_Uint32 uint32 `protobuf:"varint,6,opt,name=F_Uint32,json=FUint32,oneof"`
+}
+type Oneof_F_Uint64 struct {
+       F_Uint64 uint64 `protobuf:"varint,7,opt,name=F_Uint64,json=FUint64,oneof"`
+}
+type Oneof_F_Float struct {
+       F_Float float32 `protobuf:"fixed32,8,opt,name=F_Float,json=FFloat,oneof"`
+}
+type Oneof_F_Double struct {
+       F_Double float64 `protobuf:"fixed64,9,opt,name=F_Double,json=FDouble,oneof"`
+}
+type Oneof_F_String struct {
+       F_String string `protobuf:"bytes,10,opt,name=F_String,json=FString,oneof"`
+}
+type Oneof_F_Bytes struct {
+       F_Bytes []byte `protobuf:"bytes,11,opt,name=F_Bytes,json=FBytes,oneof"`
+}
+type Oneof_F_Sint32 struct {
+       F_Sint32 int32 `protobuf:"zigzag32,12,opt,name=F_Sint32,json=FSint32,oneof"`
+}
+type Oneof_F_Sint64 struct {
+       F_Sint64 int64 `protobuf:"zigzag64,13,opt,name=F_Sint64,json=FSint64,oneof"`
+}
+type Oneof_F_Enum struct {
+       F_Enum MyMessage_Color `protobuf:"varint,14,opt,name=F_Enum,json=FEnum,enum=test_proto.MyMessage_Color,oneof"`
+}
+type Oneof_F_Message struct {
+       F_Message *GoTestField `protobuf:"bytes,15,opt,name=F_Message,json=FMessage,oneof"`
+}
+type Oneof_FGroup struct {
+       FGroup *Oneof_F_Group `protobuf:"group,16,opt,name=F_Group,json=fGroup,oneof"`
+}
+type Oneof_F_Largest_Tag struct {
+       F_Largest_Tag int32 `protobuf:"varint,536870911,opt,name=F_Largest_Tag,json=FLargestTag,oneof"`
+}
+type Oneof_Value struct {
+       Value int32 `protobuf:"varint,100,opt,name=value,oneof"`
+}
+
+func (*Oneof_F_Bool) isOneof_Union()        {}
+func (*Oneof_F_Int32) isOneof_Union()       {}
+func (*Oneof_F_Int64) isOneof_Union()       {}
+func (*Oneof_F_Fixed32) isOneof_Union()     {}
+func (*Oneof_F_Fixed64) isOneof_Union()     {}
+func (*Oneof_F_Uint32) isOneof_Union()      {}
+func (*Oneof_F_Uint64) isOneof_Union()      {}
+func (*Oneof_F_Float) isOneof_Union()       {}
+func (*Oneof_F_Double) isOneof_Union()      {}
+func (*Oneof_F_String) isOneof_Union()      {}
+func (*Oneof_F_Bytes) isOneof_Union()       {}
+func (*Oneof_F_Sint32) isOneof_Union()      {}
+func (*Oneof_F_Sint64) isOneof_Union()      {}
+func (*Oneof_F_Enum) isOneof_Union()        {}
+func (*Oneof_F_Message) isOneof_Union()     {}
+func (*Oneof_FGroup) isOneof_Union()        {}
+func (*Oneof_F_Largest_Tag) isOneof_Union() {}
+func (*Oneof_Value) isOneof_Tormato()       {}
+
+func (m *Oneof) GetUnion() isOneof_Union {
+       if m != nil {
+               return m.Union
+       }
+       return nil
+}
+func (m *Oneof) GetTormato() isOneof_Tormato {
+       if m != nil {
+               return m.Tormato
+       }
+       return nil
+}
+
+func (m *Oneof) GetF_Bool() bool {
+       if x, ok := m.GetUnion().(*Oneof_F_Bool); ok {
+               return x.F_Bool
+       }
+       return false
+}
+
+func (m *Oneof) GetF_Int32() int32 {
+       if x, ok := m.GetUnion().(*Oneof_F_Int32); ok {
+               return x.F_Int32
+       }
+       return 0
+}
+
+func (m *Oneof) GetF_Int64() int64 {
+       if x, ok := m.GetUnion().(*Oneof_F_Int64); ok {
+               return x.F_Int64
+       }
+       return 0
+}
+
+func (m *Oneof) GetF_Fixed32() uint32 {
+       if x, ok := m.GetUnion().(*Oneof_F_Fixed32); ok {
+               return x.F_Fixed32
+       }
+       return 0
+}
+
+func (m *Oneof) GetF_Fixed64() uint64 {
+       if x, ok := m.GetUnion().(*Oneof_F_Fixed64); ok {
+               return x.F_Fixed64
+       }
+       return 0
+}
+
+func (m *Oneof) GetF_Uint32() uint32 {
+       if x, ok := m.GetUnion().(*Oneof_F_Uint32); ok {
+               return x.F_Uint32
+       }
+       return 0
+}
+
+func (m *Oneof) GetF_Uint64() uint64 {
+       if x, ok := m.GetUnion().(*Oneof_F_Uint64); ok {
+               return x.F_Uint64
+       }
+       return 0
+}
+
+func (m *Oneof) GetF_Float() float32 {
+       if x, ok := m.GetUnion().(*Oneof_F_Float); ok {
+               return x.F_Float
+       }
+       return 0
+}
+
+func (m *Oneof) GetF_Double() float64 {
+       if x, ok := m.GetUnion().(*Oneof_F_Double); ok {
+               return x.F_Double
+       }
+       return 0
+}
+
+func (m *Oneof) GetF_String() string {
+       if x, ok := m.GetUnion().(*Oneof_F_String); ok {
+               return x.F_String
+       }
+       return ""
+}
+
+func (m *Oneof) GetF_Bytes() []byte {
+       if x, ok := m.GetUnion().(*Oneof_F_Bytes); ok {
+               return x.F_Bytes
+       }
+       return nil
+}
+
+func (m *Oneof) GetF_Sint32() int32 {
+       if x, ok := m.GetUnion().(*Oneof_F_Sint32); ok {
+               return x.F_Sint32
+       }
+       return 0
+}
+
+func (m *Oneof) GetF_Sint64() int64 {
+       if x, ok := m.GetUnion().(*Oneof_F_Sint64); ok {
+               return x.F_Sint64
+       }
+       return 0
+}
+
+func (m *Oneof) GetF_Enum() MyMessage_Color {
+       if x, ok := m.GetUnion().(*Oneof_F_Enum); ok {
+               return x.F_Enum
+       }
+       return MyMessage_RED
+}
+
+func (m *Oneof) GetF_Message() *GoTestField {
+       if x, ok := m.GetUnion().(*Oneof_F_Message); ok {
+               return x.F_Message
+       }
+       return nil
+}
+
+func (m *Oneof) GetFGroup() *Oneof_F_Group {
+       if x, ok := m.GetUnion().(*Oneof_FGroup); ok {
+               return x.FGroup
+       }
+       return nil
+}
+
+func (m *Oneof) GetF_Largest_Tag() int32 {
+       if x, ok := m.GetUnion().(*Oneof_F_Largest_Tag); ok {
+               return x.F_Largest_Tag
+       }
+       return 0
+}
+
+func (m *Oneof) GetValue() int32 {
+       if x, ok := m.GetTormato().(*Oneof_Value); ok {
+               return x.Value
+       }
+       return 0
+}
+
+// XXX_OneofFuncs is for the internal use of the proto package.
+func (*Oneof) XXX_OneofFuncs() (func(msg proto.Message, b *proto.Buffer) error, func(msg proto.Message, tag, wire int, b *proto.Buffer) (bool, error), func(msg proto.Message) (n int), []interface{}) {
+       return _Oneof_OneofMarshaler, _Oneof_OneofUnmarshaler, _Oneof_OneofSizer, []interface{}{
+               (*Oneof_F_Bool)(nil),
+               (*Oneof_F_Int32)(nil),
+               (*Oneof_F_Int64)(nil),
+               (*Oneof_F_Fixed32)(nil),
+               (*Oneof_F_Fixed64)(nil),
+               (*Oneof_F_Uint32)(nil),
+               (*Oneof_F_Uint64)(nil),
+               (*Oneof_F_Float)(nil),
+               (*Oneof_F_Double)(nil),
+               (*Oneof_F_String)(nil),
+               (*Oneof_F_Bytes)(nil),
+               (*Oneof_F_Sint32)(nil),
+               (*Oneof_F_Sint64)(nil),
+               (*Oneof_F_Enum)(nil),
+               (*Oneof_F_Message)(nil),
+               (*Oneof_FGroup)(nil),
+               (*Oneof_F_Largest_Tag)(nil),
+               (*Oneof_Value)(nil),
+       }
+}
+
+func _Oneof_OneofMarshaler(msg proto.Message, b *proto.Buffer) error {
+       m := msg.(*Oneof)
+       // union
+       switch x := m.Union.(type) {
+       case *Oneof_F_Bool:
+               t := uint64(0)
+               if x.F_Bool {
+                       t = 1
+               }
+               _ = b.EncodeVarint(1<<3 | proto.WireVarint)
+               _ = b.EncodeVarint(t)
+       case *Oneof_F_Int32:
+               _ = b.EncodeVarint(2<<3 | proto.WireVarint)
+               _ = b.EncodeVarint(uint64(x.F_Int32))
+       case *Oneof_F_Int64:
+               _ = b.EncodeVarint(3<<3 | proto.WireVarint)
+               _ = b.EncodeVarint(uint64(x.F_Int64))
+       case *Oneof_F_Fixed32:
+               _ = b.EncodeVarint(4<<3 | proto.WireFixed32)
+               _ = b.EncodeFixed32(uint64(x.F_Fixed32))
+       case *Oneof_F_Fixed64:
+               _ = b.EncodeVarint(5<<3 | proto.WireFixed64)
+               _ = b.EncodeFixed64(uint64(x.F_Fixed64))
+       case *Oneof_F_Uint32:
+               _ = b.EncodeVarint(6<<3 | proto.WireVarint)
+               _ = b.EncodeVarint(uint64(x.F_Uint32))
+       case *Oneof_F_Uint64:
+               _ = b.EncodeVarint(7<<3 | proto.WireVarint)
+               _ = b.EncodeVarint(uint64(x.F_Uint64))
+       case *Oneof_F_Float:
+               _ = b.EncodeVarint(8<<3 | proto.WireFixed32)
+               _ = b.EncodeFixed32(uint64(math.Float32bits(x.F_Float)))
+       case *Oneof_F_Double:
+               _ = b.EncodeVarint(9<<3 | proto.WireFixed64)
+               _ = b.EncodeFixed64(math.Float64bits(x.F_Double))
+       case *Oneof_F_String:
+               _ = b.EncodeVarint(10<<3 | proto.WireBytes)
+               _ = b.EncodeStringBytes(x.F_String)
+       case *Oneof_F_Bytes:
+               _ = b.EncodeVarint(11<<3 | proto.WireBytes)
+               _ = b.EncodeRawBytes(x.F_Bytes)
+       case *Oneof_F_Sint32:
+               _ = b.EncodeVarint(12<<3 | proto.WireVarint)
+               _ = b.EncodeZigzag32(uint64(x.F_Sint32))
+       case *Oneof_F_Sint64:
+               _ = b.EncodeVarint(13<<3 | proto.WireVarint)
+               _ = b.EncodeZigzag64(uint64(x.F_Sint64))
+       case *Oneof_F_Enum:
+               _ = b.EncodeVarint(14<<3 | proto.WireVarint)
+               _ = b.EncodeVarint(uint64(x.F_Enum))
+       case *Oneof_F_Message:
+               _ = b.EncodeVarint(15<<3 | proto.WireBytes)
+               if err := b.EncodeMessage(x.F_Message); err != nil {
+                       return err
+               }
+       case *Oneof_FGroup:
+               _ = b.EncodeVarint(16<<3 | proto.WireStartGroup)
+               if err := b.Marshal(x.FGroup); err != nil {
+                       return err
+               }
+               _ = b.EncodeVarint(16<<3 | proto.WireEndGroup)
+       case *Oneof_F_Largest_Tag:
+               _ = b.EncodeVarint(536870911<<3 | proto.WireVarint)
+               _ = b.EncodeVarint(uint64(x.F_Largest_Tag))
+       case nil:
+       default:
+               return fmt.Errorf("Oneof.Union has unexpected type %T", x)
+       }
+       // tormato
+       switch x := m.Tormato.(type) {
+       case *Oneof_Value:
+               _ = b.EncodeVarint(100<<3 | proto.WireVarint)
+               _ = b.EncodeVarint(uint64(x.Value))
+       case nil:
+       default:
+               return fmt.Errorf("Oneof.Tormato has unexpected type %T", x)
+       }
+       return nil
+}
+
+func _Oneof_OneofUnmarshaler(msg proto.Message, tag, wire int, b *proto.Buffer) (bool, error) {
+       m := msg.(*Oneof)
+       switch tag {
+       case 1: // union.F_Bool
+               if wire != proto.WireVarint {
+                       return true, proto.ErrInternalBadWireType
+               }
+               x, err := b.DecodeVarint()
+               m.Union = &Oneof_F_Bool{x != 0}
+               return true, err
+       case 2: // union.F_Int32
+               if wire != proto.WireVarint {
+                       return true, proto.ErrInternalBadWireType
+               }
+               x, err := b.DecodeVarint()
+               m.Union = &Oneof_F_Int32{int32(x)}
+               return true, err
+       case 3: // union.F_Int64
+               if wire != proto.WireVarint {
+                       return true, proto.ErrInternalBadWireType
+               }
+               x, err := b.DecodeVarint()
+               m.Union = &Oneof_F_Int64{int64(x)}
+               return true, err
+       case 4: // union.F_Fixed32
+               if wire != proto.WireFixed32 {
+                       return true, proto.ErrInternalBadWireType
+               }
+               x, err := b.DecodeFixed32()
+               m.Union = &Oneof_F_Fixed32{uint32(x)}
+               return true, err
+       case 5: // union.F_Fixed64
+               if wire != proto.WireFixed64 {
+                       return true, proto.ErrInternalBadWireType
+               }
+               x, err := b.DecodeFixed64()
+               m.Union = &Oneof_F_Fixed64{x}
+               return true, err
+       case 6: // union.F_Uint32
+               if wire != proto.WireVarint {
+                       return true, proto.ErrInternalBadWireType
+               }
+               x, err := b.DecodeVarint()
+               m.Union = &Oneof_F_Uint32{uint32(x)}
+               return true, err
+       case 7: // union.F_Uint64
+               if wire != proto.WireVarint {
+                       return true, proto.ErrInternalBadWireType
+               }
+               x, err := b.DecodeVarint()
+               m.Union = &Oneof_F_Uint64{x}
+               return true, err
+       case 8: // union.F_Float
+               if wire != proto.WireFixed32 {
+                       return true, proto.ErrInternalBadWireType
+               }
+               x, err := b.DecodeFixed32()
+               m.Union = &Oneof_F_Float{math.Float32frombits(uint32(x))}
+               return true, err
+       case 9: // union.F_Double
+               if wire != proto.WireFixed64 {
+                       return true, proto.ErrInternalBadWireType
+               }
+               x, err := b.DecodeFixed64()
+               m.Union = &Oneof_F_Double{math.Float64frombits(x)}
+               return true, err
+       case 10: // union.F_String
+               if wire != proto.WireBytes {
+                       return true, proto.ErrInternalBadWireType
+               }
+               x, err := b.DecodeStringBytes()
+               m.Union = &Oneof_F_String{x}
+               return true, err
+       case 11: // union.F_Bytes
+               if wire != proto.WireBytes {
+                       return true, proto.ErrInternalBadWireType
+               }
+               x, err := b.DecodeRawBytes(true)
+               m.Union = &Oneof_F_Bytes{x}
+               return true, err
+       case 12: // union.F_Sint32
+               if wire != proto.WireVarint {
+                       return true, proto.ErrInternalBadWireType
+               }
+               x, err := b.DecodeZigzag32()
+               m.Union = &Oneof_F_Sint32{int32(x)}
+               return true, err
+       case 13: // union.F_Sint64
+               if wire != proto.WireVarint {
+                       return true, proto.ErrInternalBadWireType
+               }
+               x, err := b.DecodeZigzag64()
+               m.Union = &Oneof_F_Sint64{int64(x)}
+               return true, err
+       case 14: // union.F_Enum
+               if wire != proto.WireVarint {
+                       return true, proto.ErrInternalBadWireType
+               }
+               x, err := b.DecodeVarint()
+               m.Union = &Oneof_F_Enum{MyMessage_Color(x)}
+               return true, err
+       case 15: // union.F_Message
+               if wire != proto.WireBytes {
+                       return true, proto.ErrInternalBadWireType
+               }
+               msg := new(GoTestField)
+               err := b.DecodeMessage(msg)
+               m.Union = &Oneof_F_Message{msg}
+               return true, err
+       case 16: // union.f_group
+               if wire != proto.WireStartGroup {
+                       return true, proto.ErrInternalBadWireType
+               }
+               msg := new(Oneof_F_Group)
+               err := b.DecodeGroup(msg)
+               m.Union = &Oneof_FGroup{msg}
+               return true, err
+       case 536870911: // union.F_Largest_Tag
+               if wire != proto.WireVarint {
+                       return true, proto.ErrInternalBadWireType
+               }
+               x, err := b.DecodeVarint()
+               m.Union = &Oneof_F_Largest_Tag{int32(x)}
+               return true, err
+       case 100: // tormato.value
+               if wire != proto.WireVarint {
+                       return true, proto.ErrInternalBadWireType
+               }
+               x, err := b.DecodeVarint()
+               m.Tormato = &Oneof_Value{int32(x)}
+               return true, err
+       default:
+               return false, nil
+       }
+}
+
+func _Oneof_OneofSizer(msg proto.Message) (n int) {
+       m := msg.(*Oneof)
+       // union
+       switch x := m.Union.(type) {
+       case *Oneof_F_Bool:
+               n += 1 // tag and wire
+               n += 1
+       case *Oneof_F_Int32:
+               n += 1 // tag and wire
+               n += proto.SizeVarint(uint64(x.F_Int32))
+       case *Oneof_F_Int64:
+               n += 1 // tag and wire
+               n += proto.SizeVarint(uint64(x.F_Int64))
+       case *Oneof_F_Fixed32:
+               n += 1 // tag and wire
+               n += 4
+       case *Oneof_F_Fixed64:
+               n += 1 // tag and wire
+               n += 8
+       case *Oneof_F_Uint32:
+               n += 1 // tag and wire
+               n += proto.SizeVarint(uint64(x.F_Uint32))
+       case *Oneof_F_Uint64:
+               n += 1 // tag and wire
+               n += proto.SizeVarint(uint64(x.F_Uint64))
+       case *Oneof_F_Float:
+               n += 1 // tag and wire
+               n += 4
+       case *Oneof_F_Double:
+               n += 1 // tag and wire
+               n += 8
+       case *Oneof_F_String:
+               n += 1 // tag and wire
+               n += proto.SizeVarint(uint64(len(x.F_String)))
+               n += len(x.F_String)
+       case *Oneof_F_Bytes:
+               n += 1 // tag and wire
+               n += proto.SizeVarint(uint64(len(x.F_Bytes)))
+               n += len(x.F_Bytes)
+       case *Oneof_F_Sint32:
+               n += 1 // tag and wire
+               n += proto.SizeVarint(uint64((uint32(x.F_Sint32) << 1) ^ uint32((int32(x.F_Sint32) >> 31))))
+       case *Oneof_F_Sint64:
+               n += 1 // tag and wire
+               n += proto.SizeVarint(uint64(uint64(x.F_Sint64<<1) ^ uint64((int64(x.F_Sint64) >> 63))))
+       case *Oneof_F_Enum:
+               n += 1 // tag and wire
+               n += proto.SizeVarint(uint64(x.F_Enum))
+       case *Oneof_F_Message:
+               s := proto.Size(x.F_Message)
+               n += 1 // tag and wire
+               n += proto.SizeVarint(uint64(s))
+               n += s
+       case *Oneof_FGroup:
+               n += 2 // tag and wire
+               n += proto.Size(x.FGroup)
+               n += 2 // tag and wire
+       case *Oneof_F_Largest_Tag:
+               n += 5 // tag and wire
+               n += proto.SizeVarint(uint64(x.F_Largest_Tag))
+       case nil:
+       default:
+               panic(fmt.Sprintf("proto: unexpected type %T in oneof", x))
+       }
+       // tormato
+       switch x := m.Tormato.(type) {
+       case *Oneof_Value:
+               n += 2 // tag and wire
+               n += proto.SizeVarint(uint64(x.Value))
+       case nil:
+       default:
+               panic(fmt.Sprintf("proto: unexpected type %T in oneof", x))
+       }
+       return n
+}
+
+type Oneof_F_Group struct {
+       X                    *int32   `protobuf:"varint,17,opt,name=x" json:"x,omitempty"`
+       XXX_NoUnkeyedLiteral struct{} `json:"-"`
+       XXX_unrecognized     []byte   `json:"-"`
+       XXX_sizecache        int32    `json:"-"`
+}
+
+func (m *Oneof_F_Group) Reset()         { *m = Oneof_F_Group{} }
+func (m *Oneof_F_Group) String() string { return proto.CompactTextString(m) }
+func (*Oneof_F_Group) ProtoMessage()    {}
+func (*Oneof_F_Group) Descriptor() ([]byte, []int) {
+       return fileDescriptor_c161fcfdc0c3ff1e, []int{29, 0}
+}
+func (m *Oneof_F_Group) XXX_Unmarshal(b []byte) error {
+       return xxx_messageInfo_Oneof_F_Group.Unmarshal(m, b)
+}
+func (m *Oneof_F_Group) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+       return xxx_messageInfo_Oneof_F_Group.Marshal(b, m, deterministic)
+}
+func (m *Oneof_F_Group) XXX_Merge(src proto.Message) {
+       xxx_messageInfo_Oneof_F_Group.Merge(m, src)
+}
+func (m *Oneof_F_Group) XXX_Size() int {
+       return xxx_messageInfo_Oneof_F_Group.Size(m)
+}
+func (m *Oneof_F_Group) XXX_DiscardUnknown() {
+       xxx_messageInfo_Oneof_F_Group.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_Oneof_F_Group proto.InternalMessageInfo
+
+func (m *Oneof_F_Group) GetX() int32 {
+       if m != nil && m.X != nil {
+               return *m.X
+       }
+       return 0
+}
+
+type Communique struct {
+       MakeMeCry *bool `protobuf:"varint,1,opt,name=make_me_cry,json=makeMeCry" json:"make_me_cry,omitempty"`
+       // This is a oneof, called "union".
+       //
+       // Types that are valid to be assigned to Union:
+       //      *Communique_Number
+       //      *Communique_Name
+       //      *Communique_Data
+       //      *Communique_TempC
+       //      *Communique_Col
+       //      *Communique_Msg
+       Union                isCommunique_Union `protobuf_oneof:"union"`
+       XXX_NoUnkeyedLiteral struct{}           `json:"-"`
+       XXX_unrecognized     []byte             `json:"-"`
+       XXX_sizecache        int32              `json:"-"`
+}
+
+func (m *Communique) Reset()         { *m = Communique{} }
+func (m *Communique) String() string { return proto.CompactTextString(m) }
+func (*Communique) ProtoMessage()    {}
+func (*Communique) Descriptor() ([]byte, []int) {
+       return fileDescriptor_c161fcfdc0c3ff1e, []int{30}
+}
+func (m *Communique) XXX_Unmarshal(b []byte) error {
+       return xxx_messageInfo_Communique.Unmarshal(m, b)
+}
+func (m *Communique) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+       return xxx_messageInfo_Communique.Marshal(b, m, deterministic)
+}
+func (m *Communique) XXX_Merge(src proto.Message) {
+       xxx_messageInfo_Communique.Merge(m, src)
+}
+func (m *Communique) XXX_Size() int {
+       return xxx_messageInfo_Communique.Size(m)
+}
+func (m *Communique) XXX_DiscardUnknown() {
+       xxx_messageInfo_Communique.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_Communique proto.InternalMessageInfo
+
+type isCommunique_Union interface {
+       isCommunique_Union()
+}
+
+type Communique_Number struct {
+       Number int32 `protobuf:"varint,5,opt,name=number,oneof"`
+}
+type Communique_Name struct {
+       Name string `protobuf:"bytes,6,opt,name=name,oneof"`
+}
+type Communique_Data struct {
+       Data []byte `protobuf:"bytes,7,opt,name=data,oneof"`
+}
+type Communique_TempC struct {
+       TempC float64 `protobuf:"fixed64,8,opt,name=temp_c,json=tempC,oneof"`
+}
+type Communique_Col struct {
+       Col MyMessage_Color `protobuf:"varint,9,opt,name=col,enum=test_proto.MyMessage_Color,oneof"`
+}
+type Communique_Msg struct {
+       Msg *Strings `protobuf:"bytes,10,opt,name=msg,oneof"`
+}
+
+func (*Communique_Number) isCommunique_Union() {}
+func (*Communique_Name) isCommunique_Union()   {}
+func (*Communique_Data) isCommunique_Union()   {}
+func (*Communique_TempC) isCommunique_Union()  {}
+func (*Communique_Col) isCommunique_Union()    {}
+func (*Communique_Msg) isCommunique_Union()    {}
+
+func (m *Communique) GetUnion() isCommunique_Union {
+       if m != nil {
+               return m.Union
+       }
+       return nil
+}
+
+func (m *Communique) GetMakeMeCry() bool {
+       if m != nil && m.MakeMeCry != nil {
+               return *m.MakeMeCry
+       }
+       return false
+}
+
+func (m *Communique) GetNumber() int32 {
+       if x, ok := m.GetUnion().(*Communique_Number); ok {
+               return x.Number
+       }
+       return 0
+}
+
+func (m *Communique) GetName() string {
+       if x, ok := m.GetUnion().(*Communique_Name); ok {
+               return x.Name
+       }
+       return ""
+}
+
+func (m *Communique) GetData() []byte {
+       if x, ok := m.GetUnion().(*Communique_Data); ok {
+               return x.Data
+       }
+       return nil
+}
+
+func (m *Communique) GetTempC() float64 {
+       if x, ok := m.GetUnion().(*Communique_TempC); ok {
+               return x.TempC
+       }
+       return 0
+}
+
+func (m *Communique) GetCol() MyMessage_Color {
+       if x, ok := m.GetUnion().(*Communique_Col); ok {
+               return x.Col
+       }
+       return MyMessage_RED
+}
+
+func (m *Communique) GetMsg() *Strings {
+       if x, ok := m.GetUnion().(*Communique_Msg); ok {
+               return x.Msg
+       }
+       return nil
+}
+
+// XXX_OneofFuncs is for the internal use of the proto package.
+func (*Communique) XXX_OneofFuncs() (func(msg proto.Message, b *proto.Buffer) error, func(msg proto.Message, tag, wire int, b *proto.Buffer) (bool, error), func(msg proto.Message) (n int), []interface{}) {
+       return _Communique_OneofMarshaler, _Communique_OneofUnmarshaler, _Communique_OneofSizer, []interface{}{
+               (*Communique_Number)(nil),
+               (*Communique_Name)(nil),
+               (*Communique_Data)(nil),
+               (*Communique_TempC)(nil),
+               (*Communique_Col)(nil),
+               (*Communique_Msg)(nil),
+       }
+}
+
+func _Communique_OneofMarshaler(msg proto.Message, b *proto.Buffer) error {
+       m := msg.(*Communique)
+       // union
+       switch x := m.Union.(type) {
+       case *Communique_Number:
+               _ = b.EncodeVarint(5<<3 | proto.WireVarint)
+               _ = b.EncodeVarint(uint64(x.Number))
+       case *Communique_Name:
+               _ = b.EncodeVarint(6<<3 | proto.WireBytes)
+               _ = b.EncodeStringBytes(x.Name)
+       case *Communique_Data:
+               _ = b.EncodeVarint(7<<3 | proto.WireBytes)
+               _ = b.EncodeRawBytes(x.Data)
+       case *Communique_TempC:
+               _ = b.EncodeVarint(8<<3 | proto.WireFixed64)
+               _ = b.EncodeFixed64(math.Float64bits(x.TempC))
+       case *Communique_Col:
+               _ = b.EncodeVarint(9<<3 | proto.WireVarint)
+               _ = b.EncodeVarint(uint64(x.Col))
+       case *Communique_Msg:
+               _ = b.EncodeVarint(10<<3 | proto.WireBytes)
+               if err := b.EncodeMessage(x.Msg); err != nil {
+                       return err
+               }
+       case nil:
+       default:
+               return fmt.Errorf("Communique.Union has unexpected type %T", x)
+       }
+       return nil
+}
+
+func _Communique_OneofUnmarshaler(msg proto.Message, tag, wire int, b *proto.Buffer) (bool, error) {
+       m := msg.(*Communique)
+       switch tag {
+       case 5: // union.number
+               if wire != proto.WireVarint {
+                       return true, proto.ErrInternalBadWireType
+               }
+               x, err := b.DecodeVarint()
+               m.Union = &Communique_Number{int32(x)}
+               return true, err
+       case 6: // union.name
+               if wire != proto.WireBytes {
+                       return true, proto.ErrInternalBadWireType
+               }
+               x, err := b.DecodeStringBytes()
+               m.Union = &Communique_Name{x}
+               return true, err
+       case 7: // union.data
+               if wire != proto.WireBytes {
+                       return true, proto.ErrInternalBadWireType
+               }
+               x, err := b.DecodeRawBytes(true)
+               m.Union = &Communique_Data{x}
+               return true, err
+       case 8: // union.temp_c
+               if wire != proto.WireFixed64 {
+                       return true, proto.ErrInternalBadWireType
+               }
+               x, err := b.DecodeFixed64()
+               m.Union = &Communique_TempC{math.Float64frombits(x)}
+               return true, err
+       case 9: // union.col
+               if wire != proto.WireVarint {
+                       return true, proto.ErrInternalBadWireType
+               }
+               x, err := b.DecodeVarint()
+               m.Union = &Communique_Col{MyMessage_Color(x)}
+               return true, err
+       case 10: // union.msg
+               if wire != proto.WireBytes {
+                       return true, proto.ErrInternalBadWireType
+               }
+               msg := new(Strings)
+               err := b.DecodeMessage(msg)
+               m.Union = &Communique_Msg{msg}
+               return true, err
+       default:
+               return false, nil
+       }
+}
+
+func _Communique_OneofSizer(msg proto.Message) (n int) {
+       m := msg.(*Communique)
+       // union
+       switch x := m.Union.(type) {
+       case *Communique_Number:
+               n += 1 // tag and wire
+               n += proto.SizeVarint(uint64(x.Number))
+       case *Communique_Name:
+               n += 1 // tag and wire
+               n += proto.SizeVarint(uint64(len(x.Name)))
+               n += len(x.Name)
+       case *Communique_Data:
+               n += 1 // tag and wire
+               n += proto.SizeVarint(uint64(len(x.Data)))
+               n += len(x.Data)
+       case *Communique_TempC:
+               n += 1 // tag and wire
+               n += 8
+       case *Communique_Col:
+               n += 1 // tag and wire
+               n += proto.SizeVarint(uint64(x.Col))
+       case *Communique_Msg:
+               s := proto.Size(x.Msg)
+               n += 1 // tag and wire
+               n += proto.SizeVarint(uint64(s))
+               n += s
+       case nil:
+       default:
+               panic(fmt.Sprintf("proto: unexpected type %T in oneof", x))
+       }
+       return n
+}
+
+type TestUTF8 struct {
+       Scalar *string  `protobuf:"bytes,1,opt,name=scalar" json:"scalar,omitempty"`
+       Vector []string `protobuf:"bytes,2,rep,name=vector" json:"vector,omitempty"`
+       // Types that are valid to be assigned to Oneof:
+       //      *TestUTF8_Field
+       Oneof                isTestUTF8_Oneof `protobuf_oneof:"oneof"`
+       MapKey               map[string]int64 `protobuf:"bytes,4,rep,name=map_key,json=mapKey" json:"map_key,omitempty" protobuf_key:"bytes,1,opt,name=key" protobuf_val:"varint,2,opt,name=value"`
+       MapValue             map[int64]string `protobuf:"bytes,5,rep,name=map_value,json=mapValue" json:"map_value,omitempty" protobuf_key:"varint,1,opt,name=key" protobuf_val:"bytes,2,opt,name=value"`
+       XXX_NoUnkeyedLiteral struct{}         `json:"-"`
+       XXX_unrecognized     []byte           `json:"-"`
+       XXX_sizecache        int32            `json:"-"`
+}
+
+func (m *TestUTF8) Reset()         { *m = TestUTF8{} }
+func (m *TestUTF8) String() string { return proto.CompactTextString(m) }
+func (*TestUTF8) ProtoMessage()    {}
+func (*TestUTF8) Descriptor() ([]byte, []int) {
+       return fileDescriptor_c161fcfdc0c3ff1e, []int{31}
+}
+func (m *TestUTF8) XXX_Unmarshal(b []byte) error {
+       return xxx_messageInfo_TestUTF8.Unmarshal(m, b)
+}
+func (m *TestUTF8) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+       return xxx_messageInfo_TestUTF8.Marshal(b, m, deterministic)
+}
+func (m *TestUTF8) XXX_Merge(src proto.Message) {
+       xxx_messageInfo_TestUTF8.Merge(m, src)
+}
+func (m *TestUTF8) XXX_Size() int {
+       return xxx_messageInfo_TestUTF8.Size(m)
+}
+func (m *TestUTF8) XXX_DiscardUnknown() {
+       xxx_messageInfo_TestUTF8.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_TestUTF8 proto.InternalMessageInfo
+
+type isTestUTF8_Oneof interface {
+       isTestUTF8_Oneof()
+}
+
+type TestUTF8_Field struct {
+       Field string `protobuf:"bytes,3,opt,name=field,oneof"`
+}
+
+func (*TestUTF8_Field) isTestUTF8_Oneof() {}
+
+func (m *TestUTF8) GetOneof() isTestUTF8_Oneof {
+       if m != nil {
+               return m.Oneof
+       }
+       return nil
+}
+
+func (m *TestUTF8) GetScalar() string {
+       if m != nil && m.Scalar != nil {
+               return *m.Scalar
+       }
+       return ""
+}
+
+func (m *TestUTF8) GetVector() []string {
+       if m != nil {
+               return m.Vector
+       }
+       return nil
+}
+
+func (m *TestUTF8) GetField() string {
+       if x, ok := m.GetOneof().(*TestUTF8_Field); ok {
+               return x.Field
+       }
+       return ""
+}
+
+func (m *TestUTF8) GetMapKey() map[string]int64 {
+       if m != nil {
+               return m.MapKey
+       }
+       return nil
+}
+
+func (m *TestUTF8) GetMapValue() map[int64]string {
+       if m != nil {
+               return m.MapValue
+       }
+       return nil
+}
+
+// XXX_OneofFuncs is for the internal use of the proto package.
+func (*TestUTF8) XXX_OneofFuncs() (func(msg proto.Message, b *proto.Buffer) error, func(msg proto.Message, tag, wire int, b *proto.Buffer) (bool, error), func(msg proto.Message) (n int), []interface{}) {
+       return _TestUTF8_OneofMarshaler, _TestUTF8_OneofUnmarshaler, _TestUTF8_OneofSizer, []interface{}{
+               (*TestUTF8_Field)(nil),
+       }
+}
+
+func _TestUTF8_OneofMarshaler(msg proto.Message, b *proto.Buffer) error {
+       m := msg.(*TestUTF8)
+       // oneof
+       switch x := m.Oneof.(type) {
+       case *TestUTF8_Field:
+               _ = b.EncodeVarint(3<<3 | proto.WireBytes)
+               _ = b.EncodeStringBytes(x.Field)
+       case nil:
+       default:
+               return fmt.Errorf("TestUTF8.Oneof has unexpected type %T", x)
+       }
+       return nil
+}
+
+func _TestUTF8_OneofUnmarshaler(msg proto.Message, tag, wire int, b *proto.Buffer) (bool, error) {
+       m := msg.(*TestUTF8)
+       switch tag {
+       case 3: // oneof.field
+               if wire != proto.WireBytes {
+                       return true, proto.ErrInternalBadWireType
+               }
+               x, err := b.DecodeStringBytes()
+               m.Oneof = &TestUTF8_Field{x}
+               return true, err
+       default:
+               return false, nil
+       }
+}
+
+func _TestUTF8_OneofSizer(msg proto.Message) (n int) {
+       m := msg.(*TestUTF8)
+       // oneof
+       switch x := m.Oneof.(type) {
+       case *TestUTF8_Field:
+               n += 1 // tag and wire
+               n += proto.SizeVarint(uint64(len(x.Field)))
+               n += len(x.Field)
+       case nil:
+       default:
+               panic(fmt.Sprintf("proto: unexpected type %T in oneof", x))
+       }
+       return n
+}
+
+var E_Greeting = &proto.ExtensionDesc{
+       ExtendedType:  (*MyMessage)(nil),
+       ExtensionType: ([]string)(nil),
+       Field:         106,
+       Name:          "test_proto.greeting",
+       Tag:           "bytes,106,rep,name=greeting",
+       Filename:      "test.proto",
+}
+
+var E_Complex = &proto.ExtensionDesc{
+       ExtendedType:  (*OtherMessage)(nil),
+       ExtensionType: (*ComplexExtension)(nil),
+       Field:         200,
+       Name:          "test_proto.complex",
+       Tag:           "bytes,200,opt,name=complex",
+       Filename:      "test.proto",
+}
+
+var E_RComplex = &proto.ExtensionDesc{
+       ExtendedType:  (*OtherMessage)(nil),
+       ExtensionType: ([]*ComplexExtension)(nil),
+       Field:         201,
+       Name:          "test_proto.r_complex",
+       Tag:           "bytes,201,rep,name=r_complex",
+       Filename:      "test.proto",
+}
+
+var E_NoDefaultDouble = &proto.ExtensionDesc{
+       ExtendedType:  (*DefaultsMessage)(nil),
+       ExtensionType: (*float64)(nil),
+       Field:         101,
+       Name:          "test_proto.no_default_double",
+       Tag:           "fixed64,101,opt,name=no_default_double",
+       Filename:      "test.proto",
+}
+
+var E_NoDefaultFloat = &proto.ExtensionDesc{
+       ExtendedType:  (*DefaultsMessage)(nil),
+       ExtensionType: (*float32)(nil),
+       Field:         102,
+       Name:          "test_proto.no_default_float",
+       Tag:           "fixed32,102,opt,name=no_default_float",
+       Filename:      "test.proto",
+}
+
+var E_NoDefaultInt32 = &proto.ExtensionDesc{
+       ExtendedType:  (*DefaultsMessage)(nil),
+       ExtensionType: (*int32)(nil),
+       Field:         103,
+       Name:          "test_proto.no_default_int32",
+       Tag:           "varint,103,opt,name=no_default_int32",
+       Filename:      "test.proto",
+}
+
+var E_NoDefaultInt64 = &proto.ExtensionDesc{
+       ExtendedType:  (*DefaultsMessage)(nil),
+       ExtensionType: (*int64)(nil),
+       Field:         104,
+       Name:          "test_proto.no_default_int64",
+       Tag:           "varint,104,opt,name=no_default_int64",
+       Filename:      "test.proto",
+}
+
+var E_NoDefaultUint32 = &proto.ExtensionDesc{
+       ExtendedType:  (*DefaultsMessage)(nil),
+       ExtensionType: (*uint32)(nil),
+       Field:         105,
+       Name:          "test_proto.no_default_uint32",
+       Tag:           "varint,105,opt,name=no_default_uint32",
+       Filename:      "test.proto",
+}
+
+var E_NoDefaultUint64 = &proto.ExtensionDesc{
+       ExtendedType:  (*DefaultsMessage)(nil),
+       ExtensionType: (*uint64)(nil),
+       Field:         106,
+       Name:          "test_proto.no_default_uint64",
+       Tag:           "varint,106,opt,name=no_default_uint64",
+       Filename:      "test.proto",
+}
+
+var E_NoDefaultSint32 = &proto.ExtensionDesc{
+       ExtendedType:  (*DefaultsMessage)(nil),
+       ExtensionType: (*int32)(nil),
+       Field:         107,
+       Name:          "test_proto.no_default_sint32",
+       Tag:           "zigzag32,107,opt,name=no_default_sint32",
+       Filename:      "test.proto",
+}
+
+var E_NoDefaultSint64 = &proto.ExtensionDesc{
+       ExtendedType:  (*DefaultsMessage)(nil),
+       ExtensionType: (*int64)(nil),
+       Field:         108,
+       Name:          "test_proto.no_default_sint64",
+       Tag:           "zigzag64,108,opt,name=no_default_sint64",
+       Filename:      "test.proto",
+}
+
+var E_NoDefaultFixed32 = &proto.ExtensionDesc{
+       ExtendedType:  (*DefaultsMessage)(nil),
+       ExtensionType: (*uint32)(nil),
+       Field:         109,
+       Name:          "test_proto.no_default_fixed32",
+       Tag:           "fixed32,109,opt,name=no_default_fixed32",
+       Filename:      "test.proto",
+}
+
+var E_NoDefaultFixed64 = &proto.ExtensionDesc{
+       ExtendedType:  (*DefaultsMessage)(nil),
+       ExtensionType: (*uint64)(nil),
+       Field:         110,
+       Name:          "test_proto.no_default_fixed64",
+       Tag:           "fixed64,110,opt,name=no_default_fixed64",
+       Filename:      "test.proto",
+}
+
+var E_NoDefaultSfixed32 = &proto.ExtensionDesc{
+       ExtendedType:  (*DefaultsMessage)(nil),
+       ExtensionType: (*int32)(nil),
+       Field:         111,
+       Name:          "test_proto.no_default_sfixed32",
+       Tag:           "fixed32,111,opt,name=no_default_sfixed32",
+       Filename:      "test.proto",
+}
+
+var E_NoDefaultSfixed64 = &proto.ExtensionDesc{
+       ExtendedType:  (*DefaultsMessage)(nil),
+       ExtensionType: (*int64)(nil),
+       Field:         112,
+       Name:          "test_proto.no_default_sfixed64",
+       Tag:           "fixed64,112,opt,name=no_default_sfixed64",
+       Filename:      "test.proto",
+}
+
+var E_NoDefaultBool = &proto.ExtensionDesc{
+       ExtendedType:  (*DefaultsMessage)(nil),
+       ExtensionType: (*bool)(nil),
+       Field:         113,
+       Name:          "test_proto.no_default_bool",
+       Tag:           "varint,113,opt,name=no_default_bool",
+       Filename:      "test.proto",
+}
+
+var E_NoDefaultString = &proto.ExtensionDesc{
+       ExtendedType:  (*DefaultsMessage)(nil),
+       ExtensionType: (*string)(nil),
+       Field:         114,
+       Name:          "test_proto.no_default_string",
+       Tag:           "bytes,114,opt,name=no_default_string",
+       Filename:      "test.proto",
+}
+
+var E_NoDefaultBytes = &proto.ExtensionDesc{
+       ExtendedType:  (*DefaultsMessage)(nil),
+       ExtensionType: ([]byte)(nil),
+       Field:         115,
+       Name:          "test_proto.no_default_bytes",
+       Tag:           "bytes,115,opt,name=no_default_bytes",
+       Filename:      "test.proto",
+}
+
+var E_NoDefaultEnum = &proto.ExtensionDesc{
+       ExtendedType:  (*DefaultsMessage)(nil),
+       ExtensionType: (*DefaultsMessage_DefaultsEnum)(nil),
+       Field:         116,
+       Name:          "test_proto.no_default_enum",
+       Tag:           "varint,116,opt,name=no_default_enum,enum=test_proto.DefaultsMessage_DefaultsEnum",
+       Filename:      "test.proto",
+}
+
+var E_DefaultDouble = &proto.ExtensionDesc{
+       ExtendedType:  (*DefaultsMessage)(nil),
+       ExtensionType: (*float64)(nil),
+       Field:         201,
+       Name:          "test_proto.default_double",
+       Tag:           "fixed64,201,opt,name=default_double,def=3.1415",
+       Filename:      "test.proto",
+}
+
+var E_DefaultFloat = &proto.ExtensionDesc{
+       ExtendedType:  (*DefaultsMessage)(nil),
+       ExtensionType: (*float32)(nil),
+       Field:         202,
+       Name:          "test_proto.default_float",
+       Tag:           "fixed32,202,opt,name=default_float,def=3.14",
+       Filename:      "test.proto",
+}
+
+var E_DefaultInt32 = &proto.ExtensionDesc{
+       ExtendedType:  (*DefaultsMessage)(nil),
+       ExtensionType: (*int32)(nil),
+       Field:         203,
+       Name:          "test_proto.default_int32",
+       Tag:           "varint,203,opt,name=default_int32,def=42",
+       Filename:      "test.proto",
+}
+
+var E_DefaultInt64 = &proto.ExtensionDesc{
+       ExtendedType:  (*DefaultsMessage)(nil),
+       ExtensionType: (*int64)(nil),
+       Field:         204,
+       Name:          "test_proto.default_int64",
+       Tag:           "varint,204,opt,name=default_int64,def=43",
+       Filename:      "test.proto",
+}
+
+var E_DefaultUint32 = &proto.ExtensionDesc{
+       ExtendedType:  (*DefaultsMessage)(nil),
+       ExtensionType: (*uint32)(nil),
+       Field:         205,
+       Name:          "test_proto.default_uint32",
+       Tag:           "varint,205,opt,name=default_uint32,def=44",
+       Filename:      "test.proto",
+}
+
+var E_DefaultUint64 = &proto.ExtensionDesc{
+       ExtendedType:  (*DefaultsMessage)(nil),
+       ExtensionType: (*uint64)(nil),
+       Field:         206,
+       Name:          "test_proto.default_uint64",
+       Tag:           "varint,206,opt,name=default_uint64,def=45",
+       Filename:      "test.proto",
+}
+
+var E_DefaultSint32 = &proto.ExtensionDesc{
+       ExtendedType:  (*DefaultsMessage)(nil),
+       ExtensionType: (*int32)(nil),
+       Field:         207,
+       Name:          "test_proto.default_sint32",
+       Tag:           "zigzag32,207,opt,name=default_sint32,def=46",
+       Filename:      "test.proto",
+}
+
+var E_DefaultSint64 = &proto.ExtensionDesc{
+       ExtendedType:  (*DefaultsMessage)(nil),
+       ExtensionType: (*int64)(nil),
+       Field:         208,
+       Name:          "test_proto.default_sint64",
+       Tag:           "zigzag64,208,opt,name=default_sint64,def=47",
+       Filename:      "test.proto",
+}
+
+var E_DefaultFixed32 = &proto.ExtensionDesc{
+       ExtendedType:  (*DefaultsMessage)(nil),
+       ExtensionType: (*uint32)(nil),
+       Field:         209,
+       Name:          "test_proto.default_fixed32",
+       Tag:           "fixed32,209,opt,name=default_fixed32,def=48",
+       Filename:      "test.proto",
+}
+
+var E_DefaultFixed64 = &proto.ExtensionDesc{
+       ExtendedType:  (*DefaultsMessage)(nil),
+       ExtensionType: (*uint64)(nil),
+       Field:         210,
+       Name:          "test_proto.default_fixed64",
+       Tag:           "fixed64,210,opt,name=default_fixed64,def=49",
+       Filename:      "test.proto",
+}
+
+var E_DefaultSfixed32 = &proto.ExtensionDesc{
+       ExtendedType:  (*DefaultsMessage)(nil),
+       ExtensionType: (*int32)(nil),
+       Field:         211,
+       Name:          "test_proto.default_sfixed32",
+       Tag:           "fixed32,211,opt,name=default_sfixed32,def=50",
+       Filename:      "test.proto",
+}
+
+var E_DefaultSfixed64 = &proto.ExtensionDesc{
+       ExtendedType:  (*DefaultsMessage)(nil),
+       ExtensionType: (*int64)(nil),
+       Field:         212,
+       Name:          "test_proto.default_sfixed64",
+       Tag:           "fixed64,212,opt,name=default_sfixed64,def=51",
+       Filename:      "test.proto",
+}
+
+var E_DefaultBool = &proto.ExtensionDesc{
+       ExtendedType:  (*DefaultsMessage)(nil),
+       ExtensionType: (*bool)(nil),
+       Field:         213,
+       Name:          "test_proto.default_bool",
+       Tag:           "varint,213,opt,name=default_bool,def=1",
+       Filename:      "test.proto",
+}
+
+var E_DefaultString = &proto.ExtensionDesc{
+       ExtendedType:  (*DefaultsMessage)(nil),
+       ExtensionType: (*string)(nil),
+       Field:         214,
+       Name:          "test_proto.default_string",
+       Tag:           "bytes,214,opt,name=default_string,def=Hello, string,def=foo",
+       Filename:      "test.proto",
+}
+
+var E_DefaultBytes = &proto.ExtensionDesc{
+       ExtendedType:  (*DefaultsMessage)(nil),
+       ExtensionType: ([]byte)(nil),
+       Field:         215,
+       Name:          "test_proto.default_bytes",
+       Tag:           "bytes,215,opt,name=default_bytes,def=Hello, bytes",
+       Filename:      "test.proto",
+}
+
+var E_DefaultEnum = &proto.ExtensionDesc{
+       ExtendedType:  (*DefaultsMessage)(nil),
+       ExtensionType: (*DefaultsMessage_DefaultsEnum)(nil),
+       Field:         216,
+       Name:          "test_proto.default_enum",
+       Tag:           "varint,216,opt,name=default_enum,enum=test_proto.DefaultsMessage_DefaultsEnum,def=1",
+       Filename:      "test.proto",
+}
+
+var E_X201 = &proto.ExtensionDesc{
+       ExtendedType:  (*MyMessageSet)(nil),
+       ExtensionType: (*Empty)(nil),
+       Field:         201,
+       Name:          "test_proto.x201",
+       Tag:           "bytes,201,opt,name=x201",
+       Filename:      "test.proto",
+}
+
+var E_X202 = &proto.ExtensionDesc{
+       ExtendedType:  (*MyMessageSet)(nil),
+       ExtensionType: (*Empty)(nil),
+       Field:         202,
+       Name:          "test_proto.x202",
+       Tag:           "bytes,202,opt,name=x202",
+       Filename:      "test.proto",
+}
+
+var E_X203 = &proto.ExtensionDesc{
+       ExtendedType:  (*MyMessageSet)(nil),
+       ExtensionType: (*Empty)(nil),
+       Field:         203,
+       Name:          "test_proto.x203",
+       Tag:           "bytes,203,opt,name=x203",
+       Filename:      "test.proto",
+}
+
+var E_X204 = &proto.ExtensionDesc{
+       ExtendedType:  (*MyMessageSet)(nil),
+       ExtensionType: (*Empty)(nil),
+       Field:         204,
+       Name:          "test_proto.x204",
+       Tag:           "bytes,204,opt,name=x204",
+       Filename:      "test.proto",
+}
+
+var E_X205 = &proto.ExtensionDesc{
+       ExtendedType:  (*MyMessageSet)(nil),
+       ExtensionType: (*Empty)(nil),
+       Field:         205,
+       Name:          "test_proto.x205",
+       Tag:           "bytes,205,opt,name=x205",
+       Filename:      "test.proto",
+}
+
+var E_X206 = &proto.ExtensionDesc{
+       ExtendedType:  (*MyMessageSet)(nil),
+       ExtensionType: (*Empty)(nil),
+       Field:         206,
+       Name:          "test_proto.x206",
+       Tag:           "bytes,206,opt,name=x206",
+       Filename:      "test.proto",
+}
+
+var E_X207 = &proto.ExtensionDesc{
+       ExtendedType:  (*MyMessageSet)(nil),
+       ExtensionType: (*Empty)(nil),
+       Field:         207,
+       Name:          "test_proto.x207",
+       Tag:           "bytes,207,opt,name=x207",
+       Filename:      "test.proto",
+}
+
+var E_X208 = &proto.ExtensionDesc{
+       ExtendedType:  (*MyMessageSet)(nil),
+       ExtensionType: (*Empty)(nil),
+       Field:         208,
+       Name:          "test_proto.x208",
+       Tag:           "bytes,208,opt,name=x208",
+       Filename:      "test.proto",
+}
+
+var E_X209 = &proto.ExtensionDesc{
+       ExtendedType:  (*MyMessageSet)(nil),
+       ExtensionType: (*Empty)(nil),
+       Field:         209,
+       Name:          "test_proto.x209",
+       Tag:           "bytes,209,opt,name=x209",
+       Filename:      "test.proto",
+}
+
+var E_X210 = &proto.ExtensionDesc{
+       ExtendedType:  (*MyMessageSet)(nil),
+       ExtensionType: (*Empty)(nil),
+       Field:         210,
+       Name:          "test_proto.x210",
+       Tag:           "bytes,210,opt,name=x210",
+       Filename:      "test.proto",
+}
+
+var E_X211 = &proto.ExtensionDesc{
+       ExtendedType:  (*MyMessageSet)(nil),
+       ExtensionType: (*Empty)(nil),
+       Field:         211,
+       Name:          "test_proto.x211",
+       Tag:           "bytes,211,opt,name=x211",
+       Filename:      "test.proto",
+}
+
+var E_X212 = &proto.ExtensionDesc{
+       ExtendedType:  (*MyMessageSet)(nil),
+       ExtensionType: (*Empty)(nil),
+       Field:         212,
+       Name:          "test_proto.x212",
+       Tag:           "bytes,212,opt,name=x212",
+       Filename:      "test.proto",
+}
+
+var E_X213 = &proto.ExtensionDesc{
+       ExtendedType:  (*MyMessageSet)(nil),
+       ExtensionType: (*Empty)(nil),
+       Field:         213,
+       Name:          "test_proto.x213",
+       Tag:           "bytes,213,opt,name=x213",
+       Filename:      "test.proto",
+}
+
+var E_X214 = &proto.ExtensionDesc{
+       ExtendedType:  (*MyMessageSet)(nil),
+       ExtensionType: (*Empty)(nil),
+       Field:         214,
+       Name:          "test_proto.x214",
+       Tag:           "bytes,214,opt,name=x214",
+       Filename:      "test.proto",
+}
+
+var E_X215 = &proto.ExtensionDesc{
+       ExtendedType:  (*MyMessageSet)(nil),
+       ExtensionType: (*Empty)(nil),
+       Field:         215,
+       Name:          "test_proto.x215",
+       Tag:           "bytes,215,opt,name=x215",
+       Filename:      "test.proto",
+}
+
+var E_X216 = &proto.ExtensionDesc{
+       ExtendedType:  (*MyMessageSet)(nil),
+       ExtensionType: (*Empty)(nil),
+       Field:         216,
+       Name:          "test_proto.x216",
+       Tag:           "bytes,216,opt,name=x216",
+       Filename:      "test.proto",
+}
+
+var E_X217 = &proto.ExtensionDesc{
+       ExtendedType:  (*MyMessageSet)(nil),
+       ExtensionType: (*Empty)(nil),
+       Field:         217,
+       Name:          "test_proto.x217",
+       Tag:           "bytes,217,opt,name=x217",
+       Filename:      "test.proto",
+}
+
+var E_X218 = &proto.ExtensionDesc{
+       ExtendedType:  (*MyMessageSet)(nil),
+       ExtensionType: (*Empty)(nil),
+       Field:         218,
+       Name:          "test_proto.x218",
+       Tag:           "bytes,218,opt,name=x218",
+       Filename:      "test.proto",
+}
+
+var E_X219 = &proto.ExtensionDesc{
+       ExtendedType:  (*MyMessageSet)(nil),
+       ExtensionType: (*Empty)(nil),
+       Field:         219,
+       Name:          "test_proto.x219",
+       Tag:           "bytes,219,opt,name=x219",
+       Filename:      "test.proto",
+}
+
+var E_X220 = &proto.ExtensionDesc{
+       ExtendedType:  (*MyMessageSet)(nil),
+       ExtensionType: (*Empty)(nil),
+       Field:         220,
+       Name:          "test_proto.x220",
+       Tag:           "bytes,220,opt,name=x220",
+       Filename:      "test.proto",
+}
+
+var E_X221 = &proto.ExtensionDesc{
+       ExtendedType:  (*MyMessageSet)(nil),
+       ExtensionType: (*Empty)(nil),
+       Field:         221,
+       Name:          "test_proto.x221",
+       Tag:           "bytes,221,opt,name=x221",
+       Filename:      "test.proto",
+}
+
+var E_X222 = &proto.ExtensionDesc{
+       ExtendedType:  (*MyMessageSet)(nil),
+       ExtensionType: (*Empty)(nil),
+       Field:         222,
+       Name:          "test_proto.x222",
+       Tag:           "bytes,222,opt,name=x222",
+       Filename:      "test.proto",
+}
+
+var E_X223 = &proto.ExtensionDesc{
+       ExtendedType:  (*MyMessageSet)(nil),
+       ExtensionType: (*Empty)(nil),
+       Field:         223,
+       Name:          "test_proto.x223",
+       Tag:           "bytes,223,opt,name=x223",
+       Filename:      "test.proto",
+}
+
+var E_X224 = &proto.ExtensionDesc{
+       ExtendedType:  (*MyMessageSet)(nil),
+       ExtensionType: (*Empty)(nil),
+       Field:         224,
+       Name:          "test_proto.x224",
+       Tag:           "bytes,224,opt,name=x224",
+       Filename:      "test.proto",
+}
+
+var E_X225 = &proto.ExtensionDesc{
+       ExtendedType:  (*MyMessageSet)(nil),
+       ExtensionType: (*Empty)(nil),
+       Field:         225,
+       Name:          "test_proto.x225",
+       Tag:           "bytes,225,opt,name=x225",
+       Filename:      "test.proto",
+}
+
+var E_X226 = &proto.ExtensionDesc{
+       ExtendedType:  (*MyMessageSet)(nil),
+       ExtensionType: (*Empty)(nil),
+       Field:         226,
+       Name:          "test_proto.x226",
+       Tag:           "bytes,226,opt,name=x226",
+       Filename:      "test.proto",
+}
+
+var E_X227 = &proto.ExtensionDesc{
+       ExtendedType:  (*MyMessageSet)(nil),
+       ExtensionType: (*Empty)(nil),
+       Field:         227,
+       Name:          "test_proto.x227",
+       Tag:           "bytes,227,opt,name=x227",
+       Filename:      "test.proto",
+}
+
+var E_X228 = &proto.ExtensionDesc{
+       ExtendedType:  (*MyMessageSet)(nil),
+       ExtensionType: (*Empty)(nil),
+       Field:         228,
+       Name:          "test_proto.x228",
+       Tag:           "bytes,228,opt,name=x228",
+       Filename:      "test.proto",
+}
+
+var E_X229 = &proto.ExtensionDesc{
+       ExtendedType:  (*MyMessageSet)(nil),
+       ExtensionType: (*Empty)(nil),
+       Field:         229,
+       Name:          "test_proto.x229",
+       Tag:           "bytes,229,opt,name=x229",
+       Filename:      "test.proto",
+}
+
+var E_X230 = &proto.ExtensionDesc{
+       ExtendedType:  (*MyMessageSet)(nil),
+       ExtensionType: (*Empty)(nil),
+       Field:         230,
+       Name:          "test_proto.x230",
+       Tag:           "bytes,230,opt,name=x230",
+       Filename:      "test.proto",
+}
+
+var E_X231 = &proto.ExtensionDesc{
+       ExtendedType:  (*MyMessageSet)(nil),
+       ExtensionType: (*Empty)(nil),
+       Field:         231,
+       Name:          "test_proto.x231",
+       Tag:           "bytes,231,opt,name=x231",
+       Filename:      "test.proto",
+}
+
+var E_X232 = &proto.ExtensionDesc{
+       ExtendedType:  (*MyMessageSet)(nil),
+       ExtensionType: (*Empty)(nil),
+       Field:         232,
+       Name:          "test_proto.x232",
+       Tag:           "bytes,232,opt,name=x232",
+       Filename:      "test.proto",
+}
+
+var E_X233 = &proto.ExtensionDesc{
+       ExtendedType:  (*MyMessageSet)(nil),
+       ExtensionType: (*Empty)(nil),
+       Field:         233,
+       Name:          "test_proto.x233",
+       Tag:           "bytes,233,opt,name=x233",
+       Filename:      "test.proto",
+}
+
+var E_X234 = &proto.ExtensionDesc{
+       ExtendedType:  (*MyMessageSet)(nil),
+       ExtensionType: (*Empty)(nil),
+       Field:         234,
+       Name:          "test_proto.x234",
+       Tag:           "bytes,234,opt,name=x234",
+       Filename:      "test.proto",
+}
+
+var E_X235 = &proto.ExtensionDesc{
+       ExtendedType:  (*MyMessageSet)(nil),
+       ExtensionType: (*Empty)(nil),
+       Field:         235,
+       Name:          "test_proto.x235",
+       Tag:           "bytes,235,opt,name=x235",
+       Filename:      "test.proto",
+}
+
+var E_X236 = &proto.ExtensionDesc{
+       ExtendedType:  (*MyMessageSet)(nil),
+       ExtensionType: (*Empty)(nil),
+       Field:         236,
+       Name:          "test_proto.x236",
+       Tag:           "bytes,236,opt,name=x236",
+       Filename:      "test.proto",
+}
+
+var E_X237 = &proto.ExtensionDesc{
+       ExtendedType:  (*MyMessageSet)(nil),
+       ExtensionType: (*Empty)(nil),
+       Field:         237,
+       Name:          "test_proto.x237",
+       Tag:           "bytes,237,opt,name=x237",
+       Filename:      "test.proto",
+}
+
+var E_X238 = &proto.ExtensionDesc{
+       ExtendedType:  (*MyMessageSet)(nil),
+       ExtensionType: (*Empty)(nil),
+       Field:         238,
+       Name:          "test_proto.x238",
+       Tag:           "bytes,238,opt,name=x238",
+       Filename:      "test.proto",
+}
+
+var E_X239 = &proto.ExtensionDesc{
+       ExtendedType:  (*MyMessageSet)(nil),
+       ExtensionType: (*Empty)(nil),
+       Field:         239,
+       Name:          "test_proto.x239",
+       Tag:           "bytes,239,opt,name=x239",
+       Filename:      "test.proto",
+}
+
+var E_X240 = &proto.ExtensionDesc{
+       ExtendedType:  (*MyMessageSet)(nil),
+       ExtensionType: (*Empty)(nil),
+       Field:         240,
+       Name:          "test_proto.x240",
+       Tag:           "bytes,240,opt,name=x240",
+       Filename:      "test.proto",
+}
+
+var E_X241 = &proto.ExtensionDesc{
+       ExtendedType:  (*MyMessageSet)(nil),
+       ExtensionType: (*Empty)(nil),
+       Field:         241,
+       Name:          "test_proto.x241",
+       Tag:           "bytes,241,opt,name=x241",
+       Filename:      "test.proto",
+}
+
+var E_X242 = &proto.ExtensionDesc{
+       ExtendedType:  (*MyMessageSet)(nil),
+       ExtensionType: (*Empty)(nil),
+       Field:         242,
+       Name:          "test_proto.x242",
+       Tag:           "bytes,242,opt,name=x242",
+       Filename:      "test.proto",
+}
+
+var E_X243 = &proto.ExtensionDesc{
+       ExtendedType:  (*MyMessageSet)(nil),
+       ExtensionType: (*Empty)(nil),
+       Field:         243,
+       Name:          "test_proto.x243",
+       Tag:           "bytes,243,opt,name=x243",
+       Filename:      "test.proto",
+}
+
+var E_X244 = &proto.ExtensionDesc{
+       ExtendedType:  (*MyMessageSet)(nil),
+       ExtensionType: (*Empty)(nil),
+       Field:         244,
+       Name:          "test_proto.x244",
+       Tag:           "bytes,244,opt,name=x244",
+       Filename:      "test.proto",
+}
+
+var E_X245 = &proto.ExtensionDesc{
+       ExtendedType:  (*MyMessageSet)(nil),
+       ExtensionType: (*Empty)(nil),
+       Field:         245,
+       Name:          "test_proto.x245",
+       Tag:           "bytes,245,opt,name=x245",
+       Filename:      "test.proto",
+}
+
+var E_X246 = &proto.ExtensionDesc{
+       ExtendedType:  (*MyMessageSet)(nil),
+       ExtensionType: (*Empty)(nil),
+       Field:         246,
+       Name:          "test_proto.x246",
+       Tag:           "bytes,246,opt,name=x246",
+       Filename:      "test.proto",
+}
+
+var E_X247 = &proto.ExtensionDesc{
+       ExtendedType:  (*MyMessageSet)(nil),
+       ExtensionType: (*Empty)(nil),
+       Field:         247,
+       Name:          "test_proto.x247",
+       Tag:           "bytes,247,opt,name=x247",
+       Filename:      "test.proto",
+}
+
+var E_X248 = &proto.ExtensionDesc{
+       ExtendedType:  (*MyMessageSet)(nil),
+       ExtensionType: (*Empty)(nil),
+       Field:         248,
+       Name:          "test_proto.x248",
+       Tag:           "bytes,248,opt,name=x248",
+       Filename:      "test.proto",
+}
+
+var E_X249 = &proto.ExtensionDesc{
+       ExtendedType:  (*MyMessageSet)(nil),
+       ExtensionType: (*Empty)(nil),
+       Field:         249,
+       Name:          "test_proto.x249",
+       Tag:           "bytes,249,opt,name=x249",
+       Filename:      "test.proto",
+}
+
+var E_X250 = &proto.ExtensionDesc{
+       ExtendedType:  (*MyMessageSet)(nil),
+       ExtensionType: (*Empty)(nil),
+       Field:         250,
+       Name:          "test_proto.x250",
+       Tag:           "bytes,250,opt,name=x250",
+       Filename:      "test.proto",
+}
+
+func init() {
+       proto.RegisterEnum("test_proto.FOO", FOO_name, FOO_value)
+       proto.RegisterEnum("test_proto.GoTest_KIND", GoTest_KIND_name, GoTest_KIND_value)
+       proto.RegisterEnum("test_proto.MyMessage_Color", MyMessage_Color_name, MyMessage_Color_value)
+       proto.RegisterEnum("test_proto.DefaultsMessage_DefaultsEnum", DefaultsMessage_DefaultsEnum_name, DefaultsMessage_DefaultsEnum_value)
+       proto.RegisterEnum("test_proto.Defaults_Color", Defaults_Color_name, Defaults_Color_value)
+       proto.RegisterEnum("test_proto.RepeatedEnum_Color", RepeatedEnum_Color_name, RepeatedEnum_Color_value)
+       proto.RegisterType((*GoEnum)(nil), "test_proto.GoEnum")
+       proto.RegisterType((*GoTestField)(nil), "test_proto.GoTestField")
+       proto.RegisterType((*GoTest)(nil), "test_proto.GoTest")
+       proto.RegisterType((*GoTest_RequiredGroup)(nil), "test_proto.GoTest.RequiredGroup")
+       proto.RegisterType((*GoTest_RepeatedGroup)(nil), "test_proto.GoTest.RepeatedGroup")
+       proto.RegisterType((*GoTest_OptionalGroup)(nil), "test_proto.GoTest.OptionalGroup")
+       proto.RegisterType((*GoTestRequiredGroupField)(nil), "test_proto.GoTestRequiredGroupField")
+       proto.RegisterType((*GoTestRequiredGroupField_Group)(nil), "test_proto.GoTestRequiredGroupField.Group")
+       proto.RegisterType((*GoSkipTest)(nil), "test_proto.GoSkipTest")
+       proto.RegisterType((*GoSkipTest_SkipGroup)(nil), "test_proto.GoSkipTest.SkipGroup")
+       proto.RegisterType((*NonPackedTest)(nil), "test_proto.NonPackedTest")
+       proto.RegisterType((*PackedTest)(nil), "test_proto.PackedTest")
+       proto.RegisterType((*MaxTag)(nil), "test_proto.MaxTag")
+       proto.RegisterType((*OldMessage)(nil), "test_proto.OldMessage")
+       proto.RegisterType((*OldMessage_Nested)(nil), "test_proto.OldMessage.Nested")
+       proto.RegisterType((*NewMessage)(nil), "test_proto.NewMessage")
+       proto.RegisterType((*NewMessage_Nested)(nil), "test_proto.NewMessage.Nested")
+       proto.RegisterType((*InnerMessage)(nil), "test_proto.InnerMessage")
+       proto.RegisterType((*OtherMessage)(nil), "test_proto.OtherMessage")
+       proto.RegisterType((*RequiredInnerMessage)(nil), "test_proto.RequiredInnerMessage")
+       proto.RegisterType((*MyMessage)(nil), "test_proto.MyMessage")
+       proto.RegisterType((*MyMessage_SomeGroup)(nil), "test_proto.MyMessage.SomeGroup")
+       proto.RegisterExtension(E_Ext_More)
+       proto.RegisterExtension(E_Ext_Text)
+       proto.RegisterExtension(E_Ext_Number)
+       proto.RegisterType((*Ext)(nil), "test_proto.Ext")
+       proto.RegisterMapType((map[int32]int32)(nil), "test_proto.Ext.MapFieldEntry")
+       proto.RegisterType((*ComplexExtension)(nil), "test_proto.ComplexExtension")
+       proto.RegisterType((*DefaultsMessage)(nil), "test_proto.DefaultsMessage")
+       proto.RegisterType((*MyMessageSet)(nil), "test_proto.MyMessageSet")
+       proto.RegisterType((*Empty)(nil), "test_proto.Empty")
+       proto.RegisterType((*MessageList)(nil), "test_proto.MessageList")
+       proto.RegisterType((*MessageList_Message)(nil), "test_proto.MessageList.Message")
+       proto.RegisterType((*Strings)(nil), "test_proto.Strings")
+       proto.RegisterType((*Defaults)(nil), "test_proto.Defaults")
+       proto.RegisterType((*SubDefaults)(nil), "test_proto.SubDefaults")
+       proto.RegisterType((*RepeatedEnum)(nil), "test_proto.RepeatedEnum")
+       proto.RegisterType((*MoreRepeated)(nil), "test_proto.MoreRepeated")
+       proto.RegisterType((*GroupOld)(nil), "test_proto.GroupOld")
+       proto.RegisterType((*GroupOld_G)(nil), "test_proto.GroupOld.G")
+       proto.RegisterType((*GroupNew)(nil), "test_proto.GroupNew")
+       proto.RegisterType((*GroupNew_G)(nil), "test_proto.GroupNew.G")
+       proto.RegisterType((*FloatingPoint)(nil), "test_proto.FloatingPoint")
+       proto.RegisterType((*MessageWithMap)(nil), "test_proto.MessageWithMap")
+       proto.RegisterMapType((map[bool][]byte)(nil), "test_proto.MessageWithMap.ByteMappingEntry")
+       proto.RegisterMapType((map[int64]*FloatingPoint)(nil), "test_proto.MessageWithMap.MsgMappingEntry")
+       proto.RegisterMapType((map[int32]string)(nil), "test_proto.MessageWithMap.NameMappingEntry")
+       proto.RegisterMapType((map[string]string)(nil), "test_proto.MessageWithMap.StrToStrEntry")
+       proto.RegisterType((*Oneof)(nil), "test_proto.Oneof")
+       proto.RegisterType((*Oneof_F_Group)(nil), "test_proto.Oneof.F_Group")
+       proto.RegisterType((*Communique)(nil), "test_proto.Communique")
+       proto.RegisterType((*TestUTF8)(nil), "test_proto.TestUTF8")
+       proto.RegisterMapType((map[string]int64)(nil), "test_proto.TestUTF8.MapKeyEntry")
+       proto.RegisterMapType((map[int64]string)(nil), "test_proto.TestUTF8.MapValueEntry")
+       proto.RegisterExtension(E_Greeting)
+       proto.RegisterExtension(E_Complex)
+       proto.RegisterExtension(E_RComplex)
+       proto.RegisterExtension(E_NoDefaultDouble)
+       proto.RegisterExtension(E_NoDefaultFloat)
+       proto.RegisterExtension(E_NoDefaultInt32)
+       proto.RegisterExtension(E_NoDefaultInt64)
+       proto.RegisterExtension(E_NoDefaultUint32)
+       proto.RegisterExtension(E_NoDefaultUint64)
+       proto.RegisterExtension(E_NoDefaultSint32)
+       proto.RegisterExtension(E_NoDefaultSint64)
+       proto.RegisterExtension(E_NoDefaultFixed32)
+       proto.RegisterExtension(E_NoDefaultFixed64)
+       proto.RegisterExtension(E_NoDefaultSfixed32)
+       proto.RegisterExtension(E_NoDefaultSfixed64)
+       proto.RegisterExtension(E_NoDefaultBool)
+       proto.RegisterExtension(E_NoDefaultString)
+       proto.RegisterExtension(E_NoDefaultBytes)
+       proto.RegisterExtension(E_NoDefaultEnum)
+       proto.RegisterExtension(E_DefaultDouble)
+       proto.RegisterExtension(E_DefaultFloat)
+       proto.RegisterExtension(E_DefaultInt32)
+       proto.RegisterExtension(E_DefaultInt64)
+       proto.RegisterExtension(E_DefaultUint32)
+       proto.RegisterExtension(E_DefaultUint64)
+       proto.RegisterExtension(E_DefaultSint32)
+       proto.RegisterExtension(E_DefaultSint64)
+       proto.RegisterExtension(E_DefaultFixed32)
+       proto.RegisterExtension(E_DefaultFixed64)
+       proto.RegisterExtension(E_DefaultSfixed32)
+       proto.RegisterExtension(E_DefaultSfixed64)
+       proto.RegisterExtension(E_DefaultBool)
+       proto.RegisterExtension(E_DefaultString)
+       proto.RegisterExtension(E_DefaultBytes)
+       proto.RegisterExtension(E_DefaultEnum)
+       proto.RegisterExtension(E_X201)
+       proto.RegisterExtension(E_X202)
+       proto.RegisterExtension(E_X203)
+       proto.RegisterExtension(E_X204)
+       proto.RegisterExtension(E_X205)
+       proto.RegisterExtension(E_X206)
+       proto.RegisterExtension(E_X207)
+       proto.RegisterExtension(E_X208)
+       proto.RegisterExtension(E_X209)
+       proto.RegisterExtension(E_X210)
+       proto.RegisterExtension(E_X211)
+       proto.RegisterExtension(E_X212)
+       proto.RegisterExtension(E_X213)
+       proto.RegisterExtension(E_X214)
+       proto.RegisterExtension(E_X215)
+       proto.RegisterExtension(E_X216)
+       proto.RegisterExtension(E_X217)
+       proto.RegisterExtension(E_X218)
+       proto.RegisterExtension(E_X219)
+       proto.RegisterExtension(E_X220)
+       proto.RegisterExtension(E_X221)
+       proto.RegisterExtension(E_X222)
+       proto.RegisterExtension(E_X223)
+       proto.RegisterExtension(E_X224)
+       proto.RegisterExtension(E_X225)
+       proto.RegisterExtension(E_X226)
+       proto.RegisterExtension(E_X227)
+       proto.RegisterExtension(E_X228)
+       proto.RegisterExtension(E_X229)
+       proto.RegisterExtension(E_X230)
+       proto.RegisterExtension(E_X231)
+       proto.RegisterExtension(E_X232)
+       proto.RegisterExtension(E_X233)
+       proto.RegisterExtension(E_X234)
+       proto.RegisterExtension(E_X235)
+       proto.RegisterExtension(E_X236)
+       proto.RegisterExtension(E_X237)
+       proto.RegisterExtension(E_X238)
+       proto.RegisterExtension(E_X239)
+       proto.RegisterExtension(E_X240)
+       proto.RegisterExtension(E_X241)
+       proto.RegisterExtension(E_X242)
+       proto.RegisterExtension(E_X243)
+       proto.RegisterExtension(E_X244)
+       proto.RegisterExtension(E_X245)
+       proto.RegisterExtension(E_X246)
+       proto.RegisterExtension(E_X247)
+       proto.RegisterExtension(E_X248)
+       proto.RegisterExtension(E_X249)
+       proto.RegisterExtension(E_X250)
+}
+
+func init() { proto.RegisterFile("test.proto", fileDescriptor_c161fcfdc0c3ff1e) }
+
+var fileDescriptor_c161fcfdc0c3ff1e = []byte{
+       // 4787 bytes of a gzipped FileDescriptorProto
+       0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x94, 0x5a, 0xd9, 0x73, 0x1b, 0x47,
+       0x7a, 0xd7, 0x0c, 0xee, 0x0f, 0x20, 0x31, 0x6c, 0xd1, 0x12, 0x44, 0x59, 0xd2, 0x08, 0x7b, 0x18,
+       0x96, 0x6c, 0x8a, 0x04, 0x86, 0x90, 0x04, 0xc7, 0x8e, 0x75, 0x10, 0x34, 0x4b, 0x22, 0x21, 0x0f,
+       0x69, 0x3b, 0xab, 0x3c, 0xa0, 0x40, 0x62, 0x00, 0x62, 0x05, 0xcc, 0xc0, 0xc0, 0x60, 0x45, 0x26,
+       0x95, 0x2a, 0x3f, 0xa6, 0x2a, 0x4f, 0xd9, 0x24, 0x55, 0x79, 0xcf, 0x4b, 0x5e, 0x72, 0x3d, 0x24,
+       0x7f, 0x43, 0x7c, 0xad, 0x77, 0xd7, 0x7b, 0x25, 0xd9, 0x64, 0x73, 0xdf, 0xd9, 0xdc, 0x7b, 0xe4,
+       0xc5, 0xa9, 0xfe, 0xba, 0x67, 0xa6, 0x67, 0x00, 0x35, 0xc9, 0x27, 0x4c, 0x77, 0xff, 0xbe, 0x5f,
+       0x5f, 0xbf, 0xf9, 0xbe, 0xaf, 0x1b, 0x03, 0xe0, 0x5a, 0x63, 0x77, 0x79, 0x38, 0x72, 0x5c, 0x87,
+       0xe0, 0x73, 0x13, 0x9f, 0x8b, 0xd7, 0x21, 0xb9, 0xe1, 0xac, 0xdb, 0x93, 0x01, 0xb9, 0x0a, 0xb1,
+       0x8e, 0xe3, 0x14, 0x14, 0x5d, 0x2d, 0xcd, 0x97, 0xf3, 0xcb, 0x01, 0x66, 0xb9, 0xde, 0x68, 0x98,
+       0xb4, 0xad, 0x78, 0x13, 0xb2, 0x1b, 0xce, 0xae, 0x35, 0x76, 0xeb, 0x3d, 0xab, 0xdf, 0x26, 0x8b,
+       0x90, 0x78, 0xd8, 0xda, 0xb3, 0xfa, 0x68, 0x93, 0x31, 0x59, 0x81, 0x10, 0x88, 0xef, 0x1e, 0x0d,
+       0xad, 0x82, 0x8a, 0x95, 0xf8, 0x5c, 0xfc, 0xc3, 0x22, 0xed, 0x86, 0x5a, 0x92, 0xeb, 0x10, 0x7f,
+       0xd0, 0xb3, 0xdb, 0xbc, 0x9f, 0xf3, 0x62, 0x3f, 0x0c, 0xb1, 0xfc, 0x60, 0x73, 0xfb, 0xbe, 0x89,
+       0x20, 0xda, 0xc3, 0x6e, 0x6b, 0xaf, 0x4f, 0xc9, 0x14, 0xda, 0x03, 0x16, 0x68, 0xed, 0xa3, 0xd6,
+       0xa8, 0x35, 0x28, 0xc4, 0x74, 0xa5, 0x94, 0x30, 0x59, 0x81, 0xbc, 0x0a, 0x73, 0xa6, 0xf5, 0xee,
+       0xa4, 0x37, 0xb2, 0xda, 0x38, 0xbc, 0x42, 0x5c, 0x57, 0x4b, 0xd9, 0x59, 0x3d, 0x60, 0xb3, 0x19,
+       0x46, 0x33, 0xf3, 0xa1, 0xd5, 0x72, 0x3d, 0xf3, 0x84, 0x1e, 0x3b, 0xc6, 0x5c, 0x40, 0x53, 0xf3,
+       0xc6, 0xd0, 0xed, 0x39, 0x76, 0xab, 0xcf, 0xcc, 0x93, 0xba, 0x22, 0x35, 0x0f, 0xa1, 0xc9, 0x17,
+       0x21, 0x5f, 0x6f, 0xde, 0x75, 0x9c, 0x7e, 0x73, 0xc4, 0x47, 0x55, 0x00, 0x5d, 0x2d, 0xa5, 0xcd,
+       0xb9, 0x3a, 0xad, 0xf5, 0x86, 0x4a, 0x4a, 0xa0, 0xd5, 0x9b, 0x9b, 0xb6, 0x5b, 0x29, 0x07, 0xc0,
+       0xac, 0xae, 0x96, 0x12, 0xe6, 0x7c, 0x1d, 0xab, 0xa7, 0x90, 0x55, 0x23, 0x40, 0xe6, 0x74, 0xb5,
+       0x14, 0x63, 0xc8, 0xaa, 0xe1, 0x23, 0x5f, 0x02, 0x52, 0x6f, 0xd6, 0x7b, 0x87, 0x56, 0x5b, 0x64,
+       0x9d, 0xd3, 0xd5, 0x52, 0xca, 0xd4, 0xea, 0xbc, 0x61, 0x06, 0x5a, 0x64, 0x9e, 0xd7, 0xd5, 0x52,
+       0xd2, 0x43, 0x0b, 0xdc, 0xd7, 0x60, 0xa1, 0xde, 0x7c, 0xab, 0x17, 0x1e, 0x70, 0x5e, 0x57, 0x4b,
+       0x73, 0x66, 0xbe, 0xce, 0xea, 0xa7, 0xb1, 0x22, 0xb1, 0xa6, 0xab, 0xa5, 0x38, 0xc7, 0x0a, 0xbc,
+       0x38, 0xbb, 0x7a, 0xdf, 0x69, 0xb9, 0x01, 0x74, 0x41, 0x57, 0x4b, 0xaa, 0x39, 0x5f, 0xc7, 0xea,
+       0x30, 0xeb, 0x7d, 0x67, 0xb2, 0xd7, 0xb7, 0x02, 0x28, 0xd1, 0xd5, 0x92, 0x62, 0xe6, 0xeb, 0xac,
+       0x3e, 0x8c, 0xdd, 0x71, 0x47, 0x3d, 0xbb, 0x1b, 0x60, 0xcf, 0xa2, 0x8e, 0xf3, 0x75, 0x56, 0x1f,
+       0x1e, 0xc1, 0xdd, 0x23, 0xd7, 0x1a, 0x07, 0x50, 0x4b, 0x57, 0x4b, 0x39, 0x73, 0xbe, 0x8e, 0xd5,
+       0x11, 0xd6, 0xc8, 0x1a, 0x74, 0x74, 0xb5, 0xb4, 0x40, 0x59, 0x67, 0xac, 0xc1, 0x4e, 0x64, 0x0d,
+       0xba, 0xba, 0x5a, 0x22, 0x1c, 0x2b, 0xac, 0xc1, 0x32, 0x9c, 0xad, 0x37, 0x77, 0x3a, 0xd1, 0x8d,
+       0x3b, 0xd0, 0xd5, 0x52, 0xde, 0x5c, 0xa8, 0x7b, 0x2d, 0xb3, 0xf0, 0x22, 0x7b, 0x4f, 0x57, 0x4b,
+       0x9a, 0x8f, 0x17, 0xf8, 0x45, 0x4d, 0x32, 0xa9, 0x17, 0x16, 0xf5, 0x98, 0xa0, 0x49, 0x56, 0x19,
+       0xd6, 0x24, 0x07, 0x3e, 0xa7, 0xc7, 0x44, 0x4d, 0x46, 0x90, 0xd8, 0x3d, 0x47, 0x9e, 0xd3, 0x63,
+       0xa2, 0x26, 0x39, 0x32, 0xa2, 0x49, 0x8e, 0x3d, 0xaf, 0xc7, 0xc2, 0x9a, 0x9c, 0x42, 0x8b, 0xcc,
+       0x05, 0x3d, 0x16, 0xd6, 0x24, 0x47, 0x87, 0x35, 0xc9, 0xc1, 0x17, 0xf4, 0x58, 0x48, 0x93, 0x51,
+       0xac, 0x48, 0xbc, 0xa4, 0xc7, 0x42, 0x9a, 0x14, 0x67, 0xe7, 0x69, 0x92, 0x43, 0x2f, 0xea, 0x31,
+       0x51, 0x93, 0x22, 0xab, 0xaf, 0x49, 0x0e, 0x7d, 0x5e, 0x8f, 0x85, 0x34, 0x29, 0x62, 0x7d, 0x4d,
+       0x72, 0xec, 0x25, 0x3d, 0x16, 0xd2, 0x24, 0xc7, 0xbe, 0x28, 0x6a, 0x92, 0x43, 0xdf, 0x57, 0xf4,
+       0x98, 0x28, 0x4a, 0x0e, 0xbd, 0x1e, 0x12, 0x25, 0xc7, 0x7e, 0x40, 0xb1, 0xa2, 0x2a, 0xa3, 0x60,
+       0x71, 0x15, 0x3e, 0xa4, 0x60, 0x51, 0x96, 0x1c, 0x7c, 0x23, 0x22, 0x4b, 0x0e, 0xff, 0x88, 0xc2,
+       0xc3, 0xba, 0x9c, 0x36, 0x10, 0xf9, 0x3f, 0xa6, 0x06, 0x61, 0x61, 0x72, 0x83, 0x40, 0x98, 0x0e,
+       0x77, 0xa2, 0x85, 0xcb, 0xba, 0xe2, 0x0b, 0xd3, 0xf3, 0xac, 0xa2, 0x30, 0x7d, 0xe0, 0x15, 0x0c,
+       0x19, 0x5c, 0x98, 0x53, 0xc8, 0xaa, 0x11, 0x20, 0x75, 0x5d, 0x09, 0x84, 0xe9, 0x23, 0x43, 0xc2,
+       0xf4, 0xb1, 0x57, 0x75, 0x45, 0x14, 0xe6, 0x0c, 0xb4, 0xc8, 0x5c, 0xd4, 0x15, 0x51, 0x98, 0x3e,
+       0x5a, 0x14, 0xa6, 0x0f, 0xfe, 0x9c, 0xae, 0x08, 0xc2, 0x9c, 0xc6, 0x8a, 0xc4, 0x9f, 0xd7, 0x15,
+       0x41, 0x98, 0xe1, 0xd9, 0x31, 0x61, 0xfa, 0xd0, 0x2f, 0xe8, 0x4a, 0x20, 0xcc, 0x30, 0x2b, 0x17,
+       0xa6, 0x0f, 0xfd, 0xa2, 0xae, 0x08, 0xc2, 0x0c, 0x63, 0xb9, 0x30, 0x7d, 0xec, 0x0b, 0x18, 0xa7,
+       0x3d, 0x61, 0xfa, 0x58, 0x41, 0x98, 0x3e, 0xf4, 0x77, 0x68, 0x4c, 0xf7, 0x85, 0xe9, 0x43, 0x45,
+       0x61, 0xfa, 0xd8, 0xdf, 0xa5, 0xd8, 0x40, 0x98, 0xd3, 0x60, 0x71, 0x15, 0x7e, 0x8f, 0x82, 0x03,
+       0x61, 0xfa, 0xe0, 0xb0, 0x30, 0x7d, 0xf8, 0xef, 0x53, 0xb8, 0x28, 0xcc, 0x59, 0x06, 0x22, 0xff,
+       0x1f, 0x50, 0x03, 0x51, 0x98, 0xbe, 0xc1, 0x32, 0x4e, 0x93, 0x0a, 0xb3, 0x6d, 0x75, 0x5a, 0x93,
+       0x3e, 0x95, 0x71, 0x89, 0x2a, 0xb3, 0x16, 0x77, 0x47, 0x13, 0x8b, 0xce, 0xd5, 0x71, 0xfa, 0xf7,
+       0xbd, 0x36, 0xb2, 0x4c, 0x87, 0xcf, 0x04, 0x1a, 0x18, 0xbc, 0x48, 0x15, 0x5a, 0x53, 0x2b, 0x65,
+       0x33, 0xcf, 0x54, 0x3a, 0x8d, 0xaf, 0x1a, 0x02, 0xfe, 0x1a, 0xd5, 0x69, 0x4d, 0xad, 0x1a, 0x0c,
+       0x5f, 0x35, 0x02, 0x7c, 0x85, 0x4e, 0xc0, 0x13, 0x6b, 0x60, 0x71, 0x9d, 0xaa, 0xb5, 0x16, 0xab,
+       0x94, 0x57, 0xcc, 0x05, 0x4f, 0xb2, 0xb3, 0x8c, 0x42, 0xdd, 0xbc, 0x44, 0x45, 0x5b, 0x8b, 0x55,
+       0x0d, 0xdf, 0x48, 0xec, 0xa9, 0x4c, 0x85, 0xce, 0xa5, 0x1b, 0xd8, 0xbc, 0x4c, 0xb5, 0x5b, 0x8b,
+       0x57, 0xca, 0x2b, 0x2b, 0xa6, 0xc6, 0x15, 0x3c, 0xc3, 0x26, 0xd4, 0xcf, 0x32, 0xd5, 0x70, 0x2d,
+       0x5e, 0x35, 0x7c, 0x9b, 0x70, 0x3f, 0x0b, 0x9e, 0x94, 0x03, 0x93, 0x1b, 0x54, 0xcb, 0xb5, 0x64,
+       0x65, 0xd5, 0x58, 0x5d, 0xbb, 0x6d, 0xe6, 0x99, 0xa6, 0x03, 0x1b, 0x83, 0xf6, 0xc3, 0x45, 0x1d,
+       0x18, 0xad, 0x50, 0x55, 0xd7, 0x92, 0xe5, 0x9b, 0xab, 0xb7, 0xca, 0xb7, 0x4c, 0x8d, 0xab, 0x3b,
+       0xb0, 0x7a, 0x8d, 0x5a, 0x71, 0x79, 0x07, 0x56, 0xab, 0x54, 0xdf, 0x35, 0xed, 0xc0, 0xea, 0xf7,
+       0x9d, 0x97, 0xf4, 0xe2, 0x53, 0x67, 0xd4, 0x6f, 0x5f, 0x2d, 0x82, 0xa9, 0x71, 0xc5, 0x8b, 0xbd,
+       0x2e, 0x78, 0x92, 0x0f, 0xcc, 0x7f, 0x95, 0x66, 0xac, 0xb9, 0x5a, 0xea, 0x6e, 0xaf, 0x6b, 0x3b,
+       0x63, 0xcb, 0xcc, 0x33, 0xf1, 0x47, 0xd6, 0x64, 0x27, 0xba, 0x8e, 0x5f, 0xa5, 0x66, 0x0b, 0xb5,
+       0xd8, 0xcb, 0x95, 0x32, 0xed, 0x69, 0xd6, 0x3a, 0xee, 0x44, 0xd7, 0xf1, 0xd7, 0xa8, 0x0d, 0xa9,
+       0xc5, 0x5e, 0xae, 0x1a, 0xdc, 0x46, 0x5c, 0xc7, 0x2a, 0x2c, 0x0a, 0xef, 0x42, 0x60, 0xf5, 0xeb,
+       0xd4, 0x2a, 0xcf, 0x7a, 0x22, 0xfe, 0x1b, 0x31, 0xd3, 0x2e, 0xd4, 0xdb, 0x6f, 0x50, 0x3b, 0x8d,
+       0xf5, 0x46, 0xfc, 0x17, 0x23, 0xb0, 0xbb, 0x09, 0xe7, 0x22, 0xb9, 0x44, 0x73, 0xd8, 0xda, 0x7f,
+       0x62, 0xb5, 0x0b, 0x65, 0x9a, 0x52, 0xdc, 0x55, 0x35, 0xc5, 0x3c, 0x1b, 0x4a, 0x2b, 0x1e, 0x61,
+       0x33, 0xb9, 0x0d, 0xe7, 0xa3, 0xc9, 0x85, 0x67, 0x59, 0xa1, 0x39, 0x06, 0x5a, 0x2e, 0x86, 0xf3,
+       0x8c, 0x88, 0xa9, 0x10, 0x54, 0x3c, 0x53, 0x83, 0x26, 0x1d, 0x81, 0x69, 0x10, 0x5b, 0xb8, 0xe9,
+       0xab, 0x70, 0x61, 0x3a, 0xfd, 0xf0, 0x8c, 0xd7, 0x68, 0x16, 0x82, 0xc6, 0xe7, 0xa2, 0x99, 0xc8,
+       0x94, 0xf9, 0x8c, 0xbe, 0xab, 0x34, 0x2d, 0x11, 0xcd, 0xa7, 0x7a, 0x7f, 0x05, 0x0a, 0x53, 0x09,
+       0x8a, 0x67, 0x7d, 0x93, 0xe6, 0x29, 0x68, 0xfd, 0x5c, 0x24, 0x57, 0x89, 0x1a, 0xcf, 0xe8, 0xfa,
+       0x16, 0x4d, 0x5c, 0x04, 0xe3, 0xa9, 0x9e, 0x71, 0xc9, 0xc2, 0x29, 0x8c, 0x67, 0x7b, 0x9b, 0x66,
+       0x32, 0x7c, 0xc9, 0x42, 0xd9, 0x8c, 0xd8, 0x6f, 0x24, 0xa7, 0xf1, 0x6c, 0x6b, 0x34, 0xb5, 0xe1,
+       0xfd, 0x86, 0xd3, 0x1b, 0x6e, 0xfc, 0x33, 0xd4, 0x78, 0x67, 0xf6, 0x8c, 0x7f, 0x14, 0xa3, 0x49,
+       0x09, 0xb7, 0xde, 0x99, 0x35, 0x65, 0xdf, 0x7a, 0xc6, 0x94, 0x7f, 0x4c, 0xad, 0x89, 0x60, 0x3d,
+       0x35, 0xe7, 0xd7, 0x61, 0x69, 0x46, 0xbe, 0xe2, 0xd9, 0xff, 0x84, 0xda, 0xe7, 0xd1, 0xfe, 0xfc,
+       0x54, 0xea, 0x32, 0xcd, 0x30, 0x63, 0x04, 0x3f, 0xa5, 0x0c, 0x5a, 0x88, 0x61, 0x6a, 0x0c, 0x75,
+       0x98, 0xf3, 0xf2, 0xf1, 0xee, 0xc8, 0x99, 0x0c, 0x0b, 0x75, 0x5d, 0x2d, 0x41, 0x59, 0x9f, 0x71,
+       0x3a, 0xf6, 0xd2, 0xf3, 0x0d, 0x8a, 0x33, 0xc3, 0x66, 0x8c, 0x87, 0x31, 0x33, 0x9e, 0x47, 0x7a,
+       0xec, 0x99, 0x3c, 0x0c, 0xe7, 0xf3, 0x08, 0x66, 0x94, 0xc7, 0x0b, 0x77, 0x8c, 0xe7, 0xb1, 0xae,
+       0x3c, 0x83, 0xc7, 0x0b, 0x7e, 0x9c, 0x27, 0x64, 0xb6, 0xb4, 0x16, 0x9c, 0xc9, 0xb1, 0x9d, 0x7c,
+       0x3e, 0x7a, 0x48, 0xdf, 0xc0, 0xd3, 0x55, 0xb8, 0x92, 0x99, 0x09, 0xc3, 0x9b, 0x36, 0x7b, 0xf3,
+       0x19, 0x66, 0xa1, 0xd1, 0x4c, 0x9b, 0xfd, 0xfc, 0x0c, 0xb3, 0xe2, 0x6f, 0x2a, 0x10, 0x7f, 0xb0,
+       0xb9, 0x7d, 0x9f, 0xa4, 0x21, 0xfe, 0x76, 0x63, 0xf3, 0xbe, 0x76, 0x86, 0x3e, 0xdd, 0x6d, 0x34,
+       0x1e, 0x6a, 0x0a, 0xc9, 0x40, 0xe2, 0xee, 0x97, 0x76, 0xd7, 0x77, 0x34, 0x95, 0xe4, 0x21, 0x5b,
+       0xdf, 0xdc, 0xde, 0x58, 0x37, 0x1f, 0x99, 0x9b, 0xdb, 0xbb, 0x5a, 0x8c, 0xb6, 0xd5, 0x1f, 0x36,
+       0xee, 0xec, 0x6a, 0x71, 0x92, 0x82, 0x18, 0xad, 0x4b, 0x10, 0x80, 0xe4, 0xce, 0xae, 0xb9, 0xb9,
+       0xbd, 0xa1, 0x25, 0x29, 0xcb, 0xee, 0xe6, 0xd6, 0xba, 0x96, 0xa2, 0xc8, 0xdd, 0xb7, 0x1e, 0x3d,
+       0x5c, 0xd7, 0xd2, 0xf4, 0xf1, 0x8e, 0x69, 0xde, 0xf9, 0x92, 0x96, 0xa1, 0x46, 0x5b, 0x77, 0x1e,
+       0x69, 0x80, 0xcd, 0x77, 0xee, 0x3e, 0x5c, 0xd7, 0xb2, 0x24, 0x07, 0xe9, 0xfa, 0x5b, 0xdb, 0xf7,
+       0x76, 0x37, 0x1b, 0xdb, 0x5a, 0xae, 0xf8, 0x8b, 0x50, 0x60, 0xcb, 0x1c, 0x5a, 0x45, 0x76, 0x65,
+       0xf0, 0x3a, 0x24, 0xd8, 0xde, 0x28, 0xa8, 0x95, 0x6b, 0xd3, 0x7b, 0x33, 0x6d, 0xb4, 0xcc, 0x76,
+       0x89, 0x19, 0x2e, 0x5d, 0x82, 0x04, 0x5b, 0xa7, 0x45, 0x48, 0xb0, 0xf5, 0x51, 0xf1, 0x2a, 0x81,
+       0x15, 0x8a, 0xbf, 0xa5, 0x02, 0x6c, 0x38, 0x3b, 0x4f, 0x7a, 0x43, 0xbc, 0xb8, 0xb9, 0x04, 0x30,
+       0x7e, 0xd2, 0x1b, 0x36, 0xf1, 0x0d, 0xe4, 0x97, 0x0e, 0x19, 0x5a, 0x83, 0xbe, 0x97, 0x5c, 0x85,
+       0x1c, 0x36, 0xf3, 0x57, 0x04, 0xef, 0x1a, 0x52, 0x66, 0x96, 0xd6, 0x71, 0x27, 0x19, 0x86, 0x54,
+       0x0d, 0xbc, 0x62, 0x48, 0x0a, 0x90, 0xaa, 0x41, 0xae, 0x00, 0x16, 0x9b, 0x63, 0x8c, 0xa6, 0x78,
+       0xad, 0x90, 0x31, 0xb1, 0x5f, 0x16, 0x5f, 0xc9, 0x6b, 0x80, 0x7d, 0xb2, 0x99, 0xe7, 0x67, 0xbd,
+       0x25, 0xde, 0x80, 0x97, 0xe9, 0x03, 0x9b, 0x6f, 0x60, 0xb2, 0xd4, 0x80, 0x8c, 0x5f, 0x4f, 0x7b,
+       0xc3, 0x5a, 0x3e, 0x27, 0x0d, 0xe7, 0x04, 0x58, 0xe5, 0x4f, 0x8a, 0x01, 0xf8, 0x78, 0x16, 0x70,
+       0x3c, 0xcc, 0x88, 0x0d, 0xa8, 0x78, 0x09, 0xe6, 0xb6, 0x1d, 0x9b, 0xbd, 0xc7, 0xb8, 0x4e, 0x39,
+       0x50, 0x5a, 0x05, 0x05, 0xcf, 0xbf, 0x4a, 0xab, 0x78, 0x19, 0x40, 0x68, 0xd3, 0x40, 0xd9, 0x63,
+       0x6d, 0xe8, 0x0f, 0x94, 0xbd, 0xe2, 0x75, 0x48, 0x6e, 0xb5, 0x0e, 0x77, 0x5b, 0x5d, 0x72, 0x15,
+       0xa0, 0xdf, 0x1a, 0xbb, 0xcd, 0x0e, 0xee, 0xc4, 0x67, 0x9f, 0x7d, 0xf6, 0x99, 0x82, 0xc9, 0x74,
+       0x86, 0xd6, 0xb2, 0x1d, 0x19, 0x03, 0x34, 0xfa, 0xed, 0x2d, 0x6b, 0x3c, 0x6e, 0x75, 0x2d, 0xb2,
+       0x06, 0x49, 0xdb, 0x1a, 0xd3, 0xe8, 0xab, 0xe0, 0x5d, 0xd3, 0x25, 0x71, 0x1d, 0x02, 0xdc, 0xf2,
+       0x36, 0x82, 0x4c, 0x0e, 0x26, 0x1a, 0xc4, 0xec, 0xc9, 0x00, 0x6f, 0xd4, 0x12, 0x26, 0x7d, 0x5c,
+       0x7a, 0x1e, 0x92, 0x0c, 0x43, 0x08, 0xc4, 0xed, 0xd6, 0xc0, 0x2a, 0xb0, 0x9e, 0xf1, 0xb9, 0xf8,
+       0x55, 0x05, 0x60, 0xdb, 0x7a, 0x7a, 0xa2, 0x5e, 0x03, 0x9c, 0xa4, 0xd7, 0x18, 0xeb, 0xf5, 0x15,
+       0x59, 0xaf, 0x54, 0x6d, 0x1d, 0xc7, 0x69, 0x37, 0xd9, 0x46, 0xb3, 0xeb, 0xbf, 0x0c, 0xad, 0xc1,
+       0x9d, 0x2b, 0x3e, 0x86, 0xdc, 0xa6, 0x6d, 0x5b, 0x23, 0x6f, 0x54, 0x04, 0xe2, 0x07, 0xce, 0xd8,
+       0xe5, 0x37, 0x91, 0xf8, 0x4c, 0x0a, 0x10, 0x1f, 0x3a, 0x23, 0x97, 0xcd, 0xb4, 0x16, 0x37, 0x56,
+       0x56, 0x56, 0x4c, 0xac, 0x21, 0xcf, 0x43, 0x66, 0xdf, 0xb1, 0x6d, 0x6b, 0x9f, 0x4e, 0x23, 0x86,
+       0x47, 0xc7, 0xa0, 0xa2, 0xf8, 0xcb, 0x0a, 0xe4, 0x1a, 0xee, 0x41, 0x40, 0xae, 0x41, 0xec, 0x89,
+       0x75, 0x84, 0xc3, 0x8b, 0x99, 0xf4, 0x91, 0xbe, 0x30, 0x5f, 0x69, 0xf5, 0x27, 0xec, 0x5e, 0x32,
+       0x67, 0xb2, 0x02, 0x39, 0x07, 0xc9, 0xa7, 0x56, 0xaf, 0x7b, 0xe0, 0x22, 0xa7, 0x6a, 0xf2, 0x12,
+       0x59, 0x86, 0x44, 0x8f, 0x0e, 0xb6, 0x10, 0xc7, 0x15, 0x2b, 0x88, 0x2b, 0x26, 0xce, 0xc2, 0x64,
+       0xb0, 0x6b, 0xe9, 0x74, 0x5b, 0x7b, 0xef, 0xbd, 0xf7, 0xde, 0x53, 0x8b, 0x07, 0xb0, 0xe8, 0xbd,
+       0xc4, 0xa1, 0xe9, 0x3e, 0x82, 0x42, 0xdf, 0x72, 0x9a, 0x9d, 0x9e, 0xdd, 0xea, 0xf7, 0x8f, 0x9a,
+       0x4f, 0x1d, 0xbb, 0xd9, 0xb2, 0x9b, 0xce, 0x78, 0xbf, 0x35, 0xc2, 0x25, 0x90, 0x75, 0xb2, 0xd8,
+       0xb7, 0x9c, 0x3a, 0x33, 0x7c, 0xc7, 0xb1, 0xef, 0xd8, 0x0d, 0x6a, 0x55, 0xfc, 0x34, 0x0e, 0x99,
+       0xad, 0x23, 0x8f, 0x7f, 0x11, 0x12, 0xfb, 0xce, 0xc4, 0x66, 0xeb, 0x99, 0x30, 0x59, 0xc1, 0xdf,
+       0x27, 0x55, 0xd8, 0xa7, 0x45, 0x48, 0xbc, 0x3b, 0x71, 0x5c, 0x0b, 0xa7, 0x9c, 0x31, 0x59, 0x81,
+       0xae, 0xd8, 0xd0, 0x72, 0x0b, 0x71, 0xbc, 0xa6, 0xa0, 0x8f, 0xc1, 0x1a, 0x24, 0x4e, 0xb4, 0x06,
+       0x64, 0x05, 0x92, 0x0e, 0xdd, 0x83, 0x71, 0x21, 0x89, 0xf7, 0xb0, 0x21, 0x03, 0x71, 0x77, 0x4c,
+       0x8e, 0x23, 0x0f, 0x60, 0xe1, 0xa9, 0xd5, 0x1c, 0x4c, 0xc6, 0x6e, 0xb3, 0xeb, 0x34, 0xdb, 0x96,
+       0x35, 0xb4, 0x46, 0x85, 0x39, 0xec, 0x2d, 0xe4, 0x21, 0x66, 0x2d, 0xa8, 0x39, 0xff, 0xd4, 0xda,
+       0x9a, 0x8c, 0xdd, 0x0d, 0xe7, 0x3e, 0xda, 0x91, 0x35, 0xc8, 0x8c, 0x2c, 0xea, 0x17, 0xe8, 0x90,
+       0x73, 0xd3, 0x23, 0x08, 0x19, 0xa7, 0x47, 0xd6, 0x10, 0x2b, 0xc8, 0x4d, 0x48, 0xef, 0xf5, 0x9e,
+       0x58, 0xe3, 0x03, 0xab, 0x5d, 0x48, 0xe9, 0x4a, 0x69, 0xbe, 0x7c, 0x51, 0xb4, 0xf2, 0x17, 0x78,
+       0xf9, 0x9e, 0xd3, 0x77, 0x46, 0xa6, 0x0f, 0x26, 0xaf, 0x42, 0x66, 0xec, 0x0c, 0x2c, 0xa6, 0xf6,
+       0x34, 0x06, 0xdb, 0x2b, 0xb3, 0x2d, 0x77, 0x9c, 0x81, 0xe5, 0x79, 0x35, 0xcf, 0x82, 0x5c, 0x64,
+       0xc3, 0xdd, 0xa3, 0x87, 0x89, 0x02, 0xe0, 0x85, 0x0f, 0x1d, 0x14, 0x1e, 0x2e, 0xc8, 0x12, 0x1d,
+       0x54, 0xb7, 0x43, 0x73, 0xb6, 0x42, 0x16, 0xcf, 0xf2, 0x7e, 0x79, 0xe9, 0x25, 0xc8, 0xf8, 0x84,
+       0x81, 0x3b, 0x64, 0x2e, 0x28, 0x83, 0x1e, 0x82, 0xb9, 0x43, 0xe6, 0x7f, 0xbe, 0x00, 0x09, 0x1c,
+       0x38, 0x8d, 0x5c, 0xe6, 0x3a, 0x0d, 0x94, 0x19, 0x48, 0x6c, 0x98, 0xeb, 0xeb, 0xdb, 0x9a, 0x82,
+       0x31, 0xf3, 0xe1, 0x5b, 0xeb, 0x9a, 0x2a, 0xe8, 0xf7, 0xb7, 0x55, 0x88, 0xad, 0x1f, 0xa2, 0x72,
+       0xda, 0x2d, 0xb7, 0xe5, 0xbd, 0xe1, 0xf4, 0x99, 0xd4, 0x20, 0x33, 0x68, 0x79, 0x7d, 0xa9, 0xb8,
+       0xc4, 0x21, 0x5f, 0xb2, 0x7e, 0xe8, 0x2e, 0x6f, 0xb5, 0x58, 0xcf, 0xeb, 0xb6, 0x3b, 0x3a, 0x32,
+       0xd3, 0x03, 0x5e, 0x5c, 0x7a, 0x05, 0xe6, 0x42, 0x4d, 0xe2, 0x2b, 0x9a, 0x98, 0xf1, 0x8a, 0x26,
+       0xf8, 0x2b, 0x5a, 0x53, 0x6f, 0x29, 0xe5, 0x1a, 0xc4, 0x07, 0xce, 0xc8, 0x22, 0xcf, 0xcd, 0x5c,
+       0xe0, 0x42, 0x17, 0x25, 0x93, 0x8f, 0x0c, 0xc5, 0x44, 0x9b, 0xf2, 0x8b, 0x10, 0x77, 0xad, 0x43,
+       0xf7, 0x59, 0xb6, 0x07, 0x6c, 0x7e, 0x14, 0x52, 0x7e, 0x19, 0x92, 0xf6, 0x64, 0xb0, 0x67, 0x8d,
+       0x9e, 0x05, 0xee, 0xe1, 0xc0, 0x38, 0xa8, 0xf8, 0x36, 0x68, 0xf7, 0x9c, 0xc1, 0xb0, 0x6f, 0x1d,
+       0xae, 0x1f, 0xba, 0x96, 0x3d, 0xee, 0x39, 0x36, 0x9d, 0x43, 0xa7, 0x37, 0x42, 0xb7, 0x86, 0x73,
+       0xc0, 0x02, 0x75, 0x33, 0x63, 0x6b, 0xdf, 0xb1, 0xdb, 0x7c, 0x6a, 0xbc, 0x44, 0xd1, 0xee, 0x41,
+       0x6f, 0x44, 0x3d, 0x1a, 0x0d, 0x3e, 0xac, 0x50, 0xdc, 0x80, 0x3c, 0x3f, 0x86, 0x8d, 0x79, 0xc7,
+       0xc5, 0x6b, 0x90, 0xf3, 0xaa, 0xf0, 0x9f, 0x9f, 0x34, 0xc4, 0x1f, 0xaf, 0x9b, 0x0d, 0xed, 0x0c,
+       0xdd, 0xd7, 0xc6, 0xf6, 0xba, 0xa6, 0xd0, 0x87, 0xdd, 0x77, 0x1a, 0xa1, 0xbd, 0x7c, 0x1e, 0x72,
+       0xfe, 0xd8, 0x77, 0x2c, 0x17, 0x5b, 0x68, 0x94, 0x4a, 0xd5, 0xd4, 0xb4, 0x52, 0x4c, 0x41, 0x62,
+       0x7d, 0x30, 0x74, 0x8f, 0x8a, 0xbf, 0x04, 0x59, 0x0e, 0x7a, 0xd8, 0x1b, 0xbb, 0xe4, 0x36, 0xa4,
+       0x06, 0x7c, 0xbe, 0x0a, 0xe6, 0xa2, 0x61, 0x59, 0x07, 0x48, 0xef, 0xd9, 0xf4, 0xf0, 0x4b, 0x15,
+       0x48, 0x09, 0xee, 0x9d, 0x7b, 0x1e, 0x55, 0xf4, 0x3c, 0xcc, 0x47, 0xc5, 0x04, 0x1f, 0x55, 0xdc,
+       0x82, 0x14, 0x0b, 0xcc, 0x63, 0x4c, 0x37, 0xd8, 0xf9, 0x9d, 0x69, 0x8c, 0x89, 0x2f, 0xcb, 0xea,
+       0x58, 0x0e, 0x75, 0x05, 0xb2, 0xf8, 0xce, 0xf8, 0x2a, 0xa4, 0xde, 0x1c, 0xb0, 0x8a, 0x29, 0xfe,
+       0x8f, 0x12, 0x90, 0xf6, 0xd6, 0x8a, 0x5c, 0x84, 0x24, 0x3b, 0xc4, 0x22, 0x95, 0x77, 0xa9, 0x93,
+       0xc0, 0x63, 0x2b, 0xb9, 0x08, 0x29, 0x7e, 0x50, 0xe5, 0x01, 0x47, 0xad, 0x94, 0xcd, 0x24, 0x3b,
+       0x98, 0xfa, 0x8d, 0x55, 0x03, 0xfd, 0x24, 0xbb, 0xae, 0x49, 0xb2, 0xa3, 0x27, 0xd1, 0x21, 0xe3,
+       0x1f, 0x36, 0x31, 0x44, 0xf0, 0xbb, 0x99, 0xb4, 0x77, 0xba, 0x14, 0x10, 0x55, 0x03, 0x1d, 0x28,
+       0xbf, 0x88, 0x49, 0xd7, 0x83, 0xbc, 0x29, 0xed, 0x1d, 0x19, 0xf1, 0x9f, 0x27, 0xef, 0xd6, 0x25,
+       0xc5, 0x0f, 0x89, 0x01, 0xa0, 0x6a, 0xa0, 0x67, 0xf2, 0xae, 0x58, 0x52, 0xfc, 0x20, 0x48, 0xae,
+       0xd0, 0x21, 0xe2, 0xc1, 0x0e, 0xfd, 0x4f, 0x70, 0x9f, 0x92, 0x64, 0xc7, 0x3d, 0x72, 0x95, 0x32,
+       0xb0, 0xd3, 0x1b, 0xba, 0x86, 0xe0, 0xf2, 0x24, 0xc5, 0x0f, 0x75, 0xe4, 0x3a, 0x85, 0xb0, 0xe5,
+       0x2f, 0xc0, 0x33, 0x6e, 0x4a, 0x52, 0xfc, 0xa6, 0x84, 0xe8, 0xb4, 0x43, 0xf4, 0x50, 0xe8, 0x95,
+       0x84, 0x5b, 0x91, 0x24, 0xbb, 0x15, 0x21, 0x97, 0x91, 0x8e, 0x4d, 0x2a, 0x17, 0xdc, 0x80, 0xa4,
+       0xf8, 0x29, 0x30, 0x68, 0xc7, 0x5c, 0xd2, 0xbf, 0xed, 0x48, 0xf1, 0x73, 0x1e, 0xb9, 0x45, 0xf7,
+       0x8b, 0x2a, 0xbc, 0x30, 0x8f, 0xbe, 0x78, 0x49, 0x94, 0x9e, 0xb7, 0xab, 0xcc, 0x15, 0xd7, 0x98,
+       0x1b, 0x33, 0x13, 0x75, 0x7c, 0x23, 0x96, 0xa8, 0xe5, 0xa3, 0x9e, 0xdd, 0x29, 0xe4, 0x71, 0x2d,
+       0x62, 0x3d, 0xbb, 0x63, 0x26, 0xea, 0xb4, 0x86, 0xa9, 0x60, 0x9b, 0xb6, 0x69, 0xd8, 0x16, 0x7f,
+       0x99, 0x35, 0xd2, 0x2a, 0x52, 0x80, 0x44, 0xbd, 0xb9, 0xdd, 0xb2, 0x0b, 0x0b, 0xcc, 0xce, 0x6e,
+       0xd9, 0x66, 0xbc, 0xbe, 0xdd, 0xb2, 0xc9, 0x8b, 0x10, 0x1b, 0x4f, 0xf6, 0x0a, 0x64, 0xfa, 0x6f,
+       0xc1, 0x9d, 0xc9, 0x9e, 0x37, 0x18, 0x93, 0x62, 0xc8, 0x45, 0x48, 0x8f, 0xdd, 0x51, 0xf3, 0x17,
+       0xac, 0x91, 0x53, 0x38, 0x8b, 0xcb, 0x78, 0xc6, 0x4c, 0x8d, 0xdd, 0xd1, 0x63, 0x6b, 0xe4, 0x9c,
+       0xd0, 0x07, 0x17, 0x2f, 0x43, 0x56, 0xe0, 0x25, 0x79, 0x50, 0x6c, 0x96, 0xc0, 0xd4, 0x94, 0x9b,
+       0xa6, 0x62, 0x17, 0xdf, 0x86, 0x9c, 0x77, 0xc4, 0xc2, 0x19, 0x1b, 0xf4, 0x6d, 0xea, 0x3b, 0x23,
+       0x7c, 0x4b, 0xe7, 0xcb, 0x97, 0xc3, 0x11, 0x33, 0x00, 0xf2, 0xc8, 0xc5, 0xc0, 0x45, 0x2d, 0x32,
+       0x18, 0xa5, 0xf8, 0x03, 0x05, 0x72, 0x5b, 0xce, 0x28, 0xf8, 0xff, 0x62, 0x11, 0x12, 0x7b, 0x8e,
+       0xd3, 0x1f, 0x23, 0x71, 0xda, 0x64, 0x05, 0xf2, 0x05, 0xc8, 0xe1, 0x83, 0x77, 0x48, 0x56, 0xfd,
+       0x5b, 0xa0, 0x2c, 0xd6, 0xf3, 0x73, 0x31, 0x81, 0x78, 0xcf, 0x76, 0xc7, 0xdc, 0xa3, 0xe1, 0x33,
+       0xf9, 0x1c, 0x64, 0xe9, 0xaf, 0x67, 0x19, 0xf7, 0xb3, 0x69, 0xa0, 0xd5, 0xdc, 0xf0, 0x05, 0x98,
+       0x43, 0x0d, 0xf8, 0xb0, 0x94, 0x7f, 0xe3, 0x93, 0x63, 0x0d, 0x1c, 0x58, 0x80, 0x14, 0x73, 0x08,
+       0x63, 0xfc, 0xc3, 0x37, 0x63, 0x7a, 0x45, 0xea, 0x66, 0xf1, 0xa0, 0xc2, 0x32, 0x90, 0x94, 0xc9,
+       0x4b, 0xc5, 0x7b, 0x90, 0xc6, 0x70, 0xd9, 0xe8, 0xb7, 0xc9, 0xe7, 0x41, 0xe9, 0x16, 0x2c, 0x0c,
+       0xd7, 0xe7, 0x42, 0xa7, 0x10, 0x0e, 0x58, 0xde, 0x30, 0x95, 0xee, 0xd2, 0x02, 0x28, 0x1b, 0xf4,
+       0x58, 0x70, 0xc8, 0x1d, 0xb6, 0x72, 0x58, 0x7c, 0x93, 0x93, 0x6c, 0x5b, 0x4f, 0xe5, 0x24, 0xdb,
+       0xd6, 0x53, 0x46, 0x72, 0x65, 0x8a, 0x84, 0x96, 0x8e, 0xf8, 0x7f, 0xe0, 0xca, 0x51, 0xb1, 0x02,
+       0x73, 0xf8, 0xa2, 0xf6, 0xec, 0xee, 0x23, 0xa7, 0x67, 0xe3, 0x41, 0xa4, 0x83, 0x09, 0x9c, 0x62,
+       0x2a, 0x1d, 0xba, 0x0f, 0xd6, 0x61, 0x6b, 0x9f, 0xa5, 0xc3, 0x69, 0x93, 0x15, 0x8a, 0xdf, 0x8f,
+       0xc3, 0x3c, 0x77, 0xb2, 0xef, 0xf4, 0xdc, 0x83, 0xad, 0xd6, 0x90, 0x6c, 0x43, 0x8e, 0xfa, 0xd7,
+       0xe6, 0xa0, 0x35, 0x1c, 0xd2, 0x17, 0x59, 0xc1, 0xd0, 0x7c, 0x7d, 0x86, 0xdb, 0xe6, 0x16, 0xcb,
+       0xdb, 0xad, 0x81, 0xb5, 0xc5, 0xd0, 0x2c, 0x50, 0x67, 0xed, 0xa0, 0x86, 0x3c, 0x80, 0xec, 0x60,
+       0xdc, 0xf5, 0xe9, 0x58, 0xa4, 0xbf, 0x26, 0xa1, 0xdb, 0x1a, 0x77, 0x43, 0x6c, 0x30, 0xf0, 0x2b,
+       0xe8, 0xe0, 0xa8, 0x77, 0xf6, 0xd9, 0x62, 0xc7, 0x0e, 0x8e, 0xba, 0x92, 0xf0, 0xe0, 0xf6, 0x82,
+       0x1a, 0x52, 0x07, 0xa0, 0xaf, 0x9a, 0xeb, 0xd0, 0x13, 0x1e, 0x6a, 0x29, 0x5b, 0x2e, 0x49, 0xd8,
+       0x76, 0xdc, 0xd1, 0xae, 0xb3, 0xe3, 0x8e, 0x78, 0x42, 0x32, 0xe6, 0xc5, 0xa5, 0xd7, 0x40, 0x8b,
+       0xae, 0xc2, 0x71, 0x39, 0x49, 0x46, 0xc8, 0x49, 0x96, 0x7e, 0x0e, 0xf2, 0x91, 0x69, 0x8b, 0xe6,
+       0x84, 0x99, 0xdf, 0x10, 0xcd, 0xb3, 0xe5, 0x0b, 0xa1, 0x6f, 0x34, 0xc4, 0xad, 0x17, 0x99, 0x5f,
+       0x03, 0x2d, 0xba, 0x04, 0x22, 0x75, 0x5a, 0x72, 0xa0, 0x41, 0xfb, 0x57, 0x60, 0x2e, 0x34, 0x69,
+       0xd1, 0x38, 0x73, 0xcc, 0xb4, 0x8a, 0xbf, 0x92, 0x80, 0x44, 0xc3, 0xb6, 0x9c, 0x0e, 0x39, 0x1f,
+       0x8e, 0x9d, 0x6f, 0x9c, 0xf1, 0xe2, 0xe6, 0x85, 0x48, 0xdc, 0x7c, 0xe3, 0x8c, 0x1f, 0x35, 0x2f,
+       0x44, 0xa2, 0xa6, 0xd7, 0x54, 0x35, 0xc8, 0xa5, 0xa9, 0x98, 0xf9, 0xc6, 0x19, 0x21, 0x60, 0x5e,
+       0x9a, 0x0a, 0x98, 0x41, 0x73, 0xd5, 0xa0, 0x0e, 0x36, 0x1c, 0x2d, 0xdf, 0x38, 0x13, 0x44, 0xca,
+       0x8b, 0xd1, 0x48, 0xe9, 0x37, 0x56, 0x0d, 0x36, 0x24, 0x21, 0x4a, 0xe2, 0x90, 0x58, 0x7c, 0xbc,
+       0x18, 0x8d, 0x8f, 0x68, 0xc7, 0x23, 0xe3, 0xc5, 0x68, 0x64, 0xc4, 0x46, 0x1e, 0x09, 0x2f, 0x44,
+       0x22, 0x21, 0x92, 0xb2, 0x10, 0x78, 0x31, 0x1a, 0x02, 0x99, 0x9d, 0x30, 0x52, 0x31, 0xfe, 0xf9,
+       0x8d, 0x55, 0x83, 0x18, 0x91, 0xe0, 0x27, 0x3b, 0x88, 0xe0, 0x6e, 0x60, 0x18, 0xa8, 0xd2, 0x85,
+       0xf3, 0x12, 0xd4, 0xbc, 0xf4, 0x13, 0x16, 0x5c, 0x51, 0x2f, 0x41, 0x33, 0x20, 0xd5, 0xe1, 0x67,
+       0x75, 0x0d, 0x3d, 0x59, 0x48, 0x9c, 0x28, 0x81, 0xe5, 0x7a, 0x13, 0x3d, 0x1a, 0x9d, 0x5d, 0x87,
+       0x1d, 0x38, 0x4a, 0x30, 0x57, 0x6f, 0x3e, 0x6c, 0x8d, 0xba, 0x14, 0xba, 0xdb, 0xea, 0xfa, 0xb7,
+       0x1e, 0x54, 0x05, 0xd9, 0x3a, 0x6f, 0xd9, 0x6d, 0x75, 0xc9, 0x39, 0x4f, 0x62, 0x6d, 0x6c, 0x55,
+       0xb8, 0xc8, 0x96, 0xce, 0xd3, 0xa5, 0x63, 0x64, 0xe8, 0x1b, 0x17, 0xb8, 0x6f, 0xbc, 0x9b, 0x82,
+       0xc4, 0xc4, 0xee, 0x39, 0xf6, 0xdd, 0x0c, 0xa4, 0x5c, 0x67, 0x34, 0x68, 0xb9, 0x4e, 0xf1, 0x87,
+       0x0a, 0xc0, 0x3d, 0x67, 0x30, 0x98, 0xd8, 0xbd, 0x77, 0x27, 0x16, 0xb9, 0x0c, 0xd9, 0x41, 0xeb,
+       0x89, 0xd5, 0x1c, 0x58, 0xcd, 0xfd, 0x91, 0xf7, 0x36, 0x64, 0x68, 0xd5, 0x96, 0x75, 0x6f, 0x74,
+       0x44, 0x0a, 0x5e, 0x02, 0x8f, 0x0a, 0x42, 0x61, 0xf2, 0x84, 0x7e, 0x91, 0xa7, 0xa3, 0x49, 0xbe,
+       0x93, 0x5e, 0x42, 0xca, 0x0e, 0x39, 0x29, 0xbe, 0x87, 0xec, 0x98, 0x73, 0x1e, 0x92, 0xae, 0x35,
+       0x18, 0x36, 0xf7, 0x51, 0x30, 0x54, 0x14, 0x09, 0x5a, 0xbe, 0x47, 0x6e, 0x40, 0x6c, 0xdf, 0xe9,
+       0xa3, 0x54, 0x8e, 0xdd, 0x1d, 0x8a, 0x24, 0x2f, 0x40, 0x6c, 0x30, 0x66, 0xf2, 0xc9, 0x96, 0xcf,
+       0x86, 0x32, 0x08, 0x16, 0xb2, 0x28, 0x70, 0x30, 0xee, 0xfa, 0x73, 0x2f, 0x7e, 0xa2, 0x42, 0x9a,
+       0xee, 0xd7, 0x5b, 0xbb, 0xf5, 0x5b, 0x78, 0x6c, 0xd8, 0x6f, 0xf5, 0xf1, 0x86, 0x80, 0xbe, 0xa6,
+       0xbc, 0x44, 0xeb, 0xbf, 0x62, 0xed, 0xbb, 0xce, 0x08, 0x5d, 0x73, 0xc6, 0xe4, 0x25, 0xba, 0xe4,
+       0x2c, 0x2b, 0x8e, 0xf1, 0x59, 0xb2, 0x22, 0x66, 0xf4, 0xad, 0x61, 0x93, 0xfa, 0x00, 0xe6, 0x2f,
+       0x43, 0xa7, 0x6b, 0xaf, 0x3b, 0x7a, 0x74, 0x7b, 0x60, 0x1d, 0x31, 0x3f, 0x99, 0x1c, 0x60, 0x81,
+       0xfc, 0x2c, 0x3b, 0xf2, 0xb1, 0x9d, 0x64, 0xdf, 0x57, 0x15, 0x9f, 0x65, 0xfc, 0x36, 0x05, 0x05,
+       0xe7, 0x3e, 0x2c, 0x2e, 0xdd, 0x86, 0xac, 0xc0, 0x7b, 0x9c, 0x2b, 0x8a, 0x45, 0xfc, 0x58, 0x88,
+       0xf5, 0xb8, 0x5b, 0x1d, 0xd1, 0x8f, 0xd1, 0x15, 0x75, 0xa8, 0x86, 0xaf, 0xe5, 0x21, 0x56, 0x6f,
+       0x34, 0x68, 0x9e, 0x55, 0x6f, 0x34, 0x56, 0x35, 0xa5, 0xb6, 0x0a, 0xe9, 0xee, 0xc8, 0xb2, 0xa8,
+       0xeb, 0x7d, 0xd6, 0x39, 0xef, 0xcb, 0xb8, 0xac, 0x3e, 0xac, 0xf6, 0x26, 0xa4, 0xf6, 0xd9, 0x49,
+       0x8f, 0x3c, 0xf3, 0x56, 0xa3, 0xf0, 0xc7, 0xec, 0x76, 0xed, 0x79, 0x11, 0x10, 0x3d, 0x1f, 0x9a,
+       0x1e, 0x4f, 0x6d, 0x17, 0x32, 0xa3, 0xe6, 0xf1, 0xa4, 0xef, 0xb3, 0x58, 0x2e, 0x27, 0x4d, 0x8f,
+       0x78, 0x55, 0x6d, 0x03, 0x16, 0x6c, 0xc7, 0xfb, 0x93, 0xaf, 0xd9, 0xe6, 0x9e, 0x6c, 0x56, 0x12,
+       0xed, 0x75, 0x60, 0xb1, 0x4f, 0x05, 0x6c, 0x87, 0x37, 0x30, 0xef, 0x57, 0x5b, 0x07, 0x4d, 0x20,
+       0xea, 0x30, 0x77, 0x29, 0xe3, 0xe9, 0xb0, 0xaf, 0x13, 0x7c, 0x1e, 0xf4, 0xb0, 0x11, 0x1a, 0xee,
+       0x03, 0x65, 0x34, 0x5d, 0xf6, 0xb1, 0x87, 0x4f, 0x83, 0x61, 0x65, 0x9a, 0x86, 0x46, 0x04, 0x19,
+       0xcd, 0x01, 0xfb, 0x12, 0x44, 0xa4, 0xa9, 0x1a, 0x91, 0xd5, 0x99, 0x9c, 0x60, 0x38, 0x3d, 0xf6,
+       0x29, 0x87, 0xcf, 0xc3, 0x02, 0xce, 0x0c, 0xa2, 0xe3, 0x06, 0xf4, 0x65, 0xf6, 0x9d, 0x47, 0x88,
+       0x68, 0x6a, 0x44, 0xe3, 0x13, 0x8c, 0xe8, 0x09, 0xfb, 0xac, 0xc2, 0x27, 0xda, 0x99, 0x35, 0xa2,
+       0xf1, 0x09, 0x46, 0xd4, 0x67, 0x9f, 0x5c, 0x84, 0x88, 0xaa, 0x46, 0x6d, 0x13, 0x88, 0xb8, 0xf1,
+       0x3c, 0x3a, 0x4b, 0x99, 0x06, 0xec, 0x53, 0x9a, 0x60, 0xeb, 0x99, 0xd1, 0x2c, 0xaa, 0xe3, 0x06,
+       0x65, 0xb3, 0xef, 0x6c, 0xc2, 0x54, 0x55, 0xa3, 0xf6, 0x00, 0xce, 0x8a, 0xd3, 0x3b, 0xd1, 0xb0,
+       0x1c, 0xf6, 0x91, 0x48, 0x30, 0x41, 0x6e, 0x35, 0x93, 0xec, 0xb8, 0x81, 0x0d, 0xd9, 0x07, 0x24,
+       0x11, 0xb2, 0xaa, 0x51, 0xbb, 0x07, 0x79, 0x81, 0x6c, 0x0f, 0xef, 0x15, 0x64, 0x44, 0xef, 0xb2,
+       0xcf, 0x9e, 0x7c, 0x22, 0x9a, 0x51, 0x45, 0x77, 0x8f, 0xe5, 0x18, 0x52, 0x9a, 0x11, 0xfb, 0x6a,
+       0x27, 0x18, 0x0f, 0xda, 0x44, 0x5e, 0x94, 0x3d, 0x96, 0x90, 0xc8, 0x78, 0xc6, 0xec, 0x8b, 0x9e,
+       0x60, 0x38, 0xd4, 0xa4, 0x36, 0x08, 0x4d, 0xca, 0xa2, 0x69, 0x86, 0x94, 0xc5, 0xc5, 0x88, 0x58,
+       0x92, 0x40, 0x96, 0xc5, 0xeb, 0x2b, 0x61, 0xfa, 0xb4, 0x58, 0x7b, 0x00, 0xf3, 0xa7, 0x71, 0x59,
+       0xef, 0x2b, 0xec, 0x2e, 0xa3, 0xb2, 0xbc, 0x6a, 0xac, 0xae, 0x99, 0x73, 0xed, 0x90, 0xe7, 0xda,
+       0x80, 0xb9, 0x53, 0xb8, 0xad, 0x0f, 0x14, 0x76, 0x23, 0x40, 0xb9, 0xcc, 0x5c, 0x3b, 0xec, 0xbb,
+       0xe6, 0x4e, 0xe1, 0xb8, 0x3e, 0x54, 0xd8, 0x15, 0x92, 0x51, 0xf6, 0x69, 0x3c, 0xdf, 0x35, 0x77,
+       0x0a, 0xc7, 0xf5, 0x11, 0x3b, 0xf1, 0xab, 0x46, 0x45, 0xa4, 0x41, 0x4f, 0x31, 0x7f, 0x1a, 0xc7,
+       0xf5, 0xb1, 0x82, 0x57, 0x4a, 0xaa, 0x61, 0xf8, 0xeb, 0xe3, 0xfb, 0xae, 0xf9, 0xd3, 0x38, 0xae,
+       0xaf, 0x29, 0x78, 0xf5, 0xa4, 0x1a, 0x6b, 0x21, 0xa2, 0xf0, 0x88, 0x4e, 0xe2, 0xb8, 0x3e, 0x51,
+       0xf0, 0x3e, 0x48, 0x35, 0xaa, 0x3e, 0xd1, 0xce, 0xd4, 0x88, 0x4e, 0xe2, 0xb8, 0xbe, 0x8e, 0xe7,
+       0xab, 0x9a, 0x6a, 0xdc, 0x0c, 0x11, 0xa1, 0xef, 0xca, 0x9f, 0xca, 0x71, 0x7d, 0x43, 0xc1, 0xab,
+       0x3b, 0xd5, 0xb8, 0x65, 0x7a, 0x23, 0x08, 0x7c, 0x57, 0xfe, 0x54, 0x8e, 0xeb, 0x9b, 0x0a, 0xde,
+       0xf1, 0xa9, 0xc6, 0xed, 0x30, 0x15, 0xfa, 0x2e, 0xed, 0x74, 0x8e, 0xeb, 0x53, 0x05, 0xbf, 0xe8,
+       0x51, 0xd7, 0x56, 0x4c, 0x6f, 0x10, 0x82, 0xef, 0xd2, 0x4e, 0xe7, 0xb8, 0xbe, 0xa5, 0xe0, 0x67,
+       0x3e, 0xea, 0xda, 0x6a, 0x84, 0xac, 0x6a, 0xd4, 0xd6, 0x21, 0x77, 0x72, 0xc7, 0xf5, 0x6d, 0xf1,
+       0x06, 0x35, 0xdb, 0x16, 0xbc, 0xd7, 0x63, 0x61, 0xff, 0x4e, 0xe0, 0xba, 0xbe, 0x83, 0xc9, 0x5f,
+       0xed, 0xb9, 0x37, 0xd8, 0x3d, 0x23, 0x33, 0x79, 0xa9, 0x6d, 0x75, 0x5e, 0xed, 0x38, 0x4e, 0xb0,
+       0xa5, 0xcc, 0xa1, 0x35, 0x82, 0xb7, 0xe7, 0x04, 0xde, 0xec, 0xbb, 0x0a, 0x5e, 0x4b, 0xe6, 0x38,
+       0x35, 0x5a, 0xf8, 0xef, 0x11, 0x73, 0x6d, 0x76, 0x30, 0xe7, 0xe3, 0xfd, 0xda, 0xf7, 0x94, 0xd3,
+       0x39, 0xb6, 0x5a, 0xac, 0xb1, 0xbd, 0xee, 0x2f, 0x0e, 0xd6, 0xbc, 0x0e, 0xf1, 0xc3, 0xf2, 0xca,
+       0x6a, 0x38, 0xc5, 0x13, 0x6f, 0xe5, 0x99, 0x3b, 0xcb, 0x96, 0x17, 0x42, 0x7f, 0x5f, 0x0c, 0x86,
+       0xee, 0x91, 0x89, 0x96, 0x9c, 0xa1, 0x2c, 0x61, 0xf8, 0x40, 0xca, 0x50, 0xe6, 0x0c, 0x15, 0x09,
+       0xc3, 0x87, 0x52, 0x86, 0x0a, 0x67, 0x30, 0x24, 0x0c, 0x1f, 0x49, 0x19, 0x0c, 0xce, 0xb0, 0x26,
+       0x61, 0xf8, 0x58, 0xca, 0xb0, 0xc6, 0x19, 0xaa, 0x12, 0x86, 0xaf, 0x49, 0x19, 0xaa, 0x9c, 0xe1,
+       0xa6, 0x84, 0xe1, 0x13, 0x29, 0xc3, 0x4d, 0xce, 0x70, 0x4b, 0xc2, 0xf0, 0x75, 0x29, 0xc3, 0x2d,
+       0xce, 0x70, 0x5b, 0xc2, 0xf0, 0x0d, 0x29, 0xc3, 0x6d, 0xc6, 0xb0, 0xba, 0x22, 0x61, 0xf8, 0xa6,
+       0x8c, 0x61, 0x75, 0x85, 0x33, 0xc8, 0x34, 0xf9, 0xa9, 0x94, 0x81, 0x6b, 0x72, 0x55, 0xa6, 0xc9,
+       0x6f, 0x49, 0x19, 0xb8, 0x26, 0x57, 0x65, 0x9a, 0xfc, 0xb6, 0x94, 0x81, 0x6b, 0x72, 0x55, 0xa6,
+       0xc9, 0xef, 0x48, 0x19, 0xb8, 0x26, 0x57, 0x65, 0x9a, 0xfc, 0xae, 0x94, 0x81, 0x6b, 0x72, 0x55,
+       0xa6, 0xc9, 0xef, 0x49, 0x19, 0xb8, 0x26, 0x57, 0x65, 0x9a, 0xfc, 0x13, 0x29, 0x03, 0xd7, 0xe4,
+       0xaa, 0x4c, 0x93, 0x7f, 0x2a, 0x65, 0xe0, 0x9a, 0x5c, 0x95, 0x69, 0xf2, 0xcf, 0xa4, 0x0c, 0x5c,
+       0x93, 0x65, 0x99, 0x26, 0xbf, 0x2f, 0x63, 0x28, 0x73, 0x4d, 0x96, 0x65, 0x9a, 0xfc, 0x73, 0x29,
+       0x03, 0xd7, 0x64, 0x59, 0xa6, 0xc9, 0xbf, 0x90, 0x32, 0x70, 0x4d, 0x96, 0x65, 0x9a, 0xfc, 0x81,
+       0x94, 0x81, 0x6b, 0xb2, 0x2c, 0xd3, 0xe4, 0x5f, 0x4a, 0x19, 0xb8, 0x26, 0xcb, 0x32, 0x4d, 0xfe,
+       0x95, 0x94, 0x81, 0x6b, 0xb2, 0x2c, 0xd3, 0xe4, 0x5f, 0x4b, 0x19, 0xb8, 0x26, 0xcb, 0x32, 0x4d,
+       0xfe, 0x8d, 0x94, 0x81, 0x6b, 0xb2, 0x2c, 0xd3, 0xe4, 0xdf, 0x4a, 0x19, 0xb8, 0x26, 0xcb, 0x32,
+       0x4d, 0xfe, 0x9d, 0x94, 0x81, 0x6b, 0xb2, 0x22, 0xd3, 0xe4, 0xdf, 0xcb, 0x18, 0x2a, 0x5c, 0x93,
+       0x15, 0x99, 0x26, 0xff, 0x41, 0xca, 0xc0, 0x35, 0x59, 0x91, 0x69, 0xf2, 0x1f, 0xa5, 0x0c, 0x5c,
+       0x93, 0x15, 0x99, 0x26, 0xff, 0x49, 0xca, 0xc0, 0x35, 0x59, 0x91, 0x69, 0xf2, 0x9f, 0xa5, 0x0c,
+       0x5c, 0x93, 0x15, 0x99, 0x26, 0xff, 0x45, 0xca, 0xc0, 0x35, 0x59, 0x91, 0x69, 0xf2, 0x5f, 0xa5,
+       0x0c, 0x5c, 0x93, 0x15, 0x99, 0x26, 0xff, 0x4d, 0xca, 0xc0, 0x35, 0x59, 0x91, 0x69, 0xf2, 0x87,
+       0x52, 0x06, 0xae, 0xc9, 0x8a, 0x4c, 0x93, 0xff, 0x2e, 0x65, 0xe0, 0x9a, 0x34, 0x64, 0x9a, 0xfc,
+       0x0f, 0x19, 0x83, 0xc1, 0x35, 0x69, 0xc8, 0x34, 0xf9, 0x9f, 0x52, 0x06, 0xae, 0x49, 0x43, 0xa6,
+       0xc9, 0xff, 0x92, 0x32, 0x70, 0x4d, 0x1a, 0x32, 0x4d, 0xfe, 0xb7, 0x94, 0x81, 0x6b, 0xd2, 0x90,
+       0x69, 0xf2, 0x7f, 0xa4, 0x0c, 0x5c, 0x93, 0x86, 0x4c, 0x93, 0xff, 0x2b, 0x65, 0xe0, 0x9a, 0x34,
+       0x64, 0x9a, 0xfc, 0x91, 0x94, 0x81, 0x6b, 0xd2, 0x90, 0x69, 0xf2, 0xc7, 0x52, 0x06, 0xae, 0x49,
+       0x43, 0xa6, 0xc9, 0x9f, 0x48, 0x19, 0xb8, 0x26, 0x0d, 0x99, 0x26, 0x7f, 0x2a, 0x65, 0xe0, 0x9a,
+       0x5c, 0x93, 0x69, 0xf2, 0xff, 0x64, 0x0c, 0x6b, 0x2b, 0x77, 0xaf, 0x3f, 0x7e, 0xb1, 0xdb, 0x73,
+       0x0f, 0x26, 0x7b, 0xcb, 0xfb, 0xce, 0xe0, 0x46, 0xd7, 0xe9, 0x3a, 0x37, 0x10, 0xb4, 0x37, 0xe9,
+       0xb0, 0x87, 0x1b, 0x81, 0xe1, 0xff, 0x07, 0x00, 0x00, 0xff, 0xff, 0xe0, 0xd1, 0x6e, 0x72, 0xd7,
+       0x3e, 0x00, 0x00,
+}

diff --git a/vendor/github.com/gogo/protobuf/proto/test_proto/test.proto b/vendor/github.com/gogo/protobuf/proto/test_proto/test.proto
new file mode 100644 (file)
index 0000000..e8548c9
--- /dev/null
+++ b/vendor/github.com/gogo/protobuf/proto/test_proto/test.proto
@@ -0,0 +1,570 @@
+// Go support for Protocol Buffers - Google's data interchange format
+//
+// Copyright 2010 The Go Authors.  All rights reserved.
+// https://github.com/golang/protobuf
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//     * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//     * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//     * Neither the name of Google Inc. nor the names of its
+// contributors may be used to endorse or promote products derived from
+// this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+// A feature-rich test file for the protocol compiler and libraries.
+
+syntax = "proto2";
+
+package test_proto;
+
+option go_package = "github.com/gogo/protobuf/proto/test_proto";
+
+enum FOO { FOO1 = 1; };
+
+message GoEnum {
+  required FOO foo = 1;
+}
+
+message GoTestField {
+  required string Label = 1;
+  required string Type = 2;
+}
+
+message GoTest {
+  // An enum, for completeness.
+  enum KIND {
+    VOID = 0;
+
+    // Basic types
+    BOOL = 1;
+    BYTES = 2;
+    FINGERPRINT = 3;
+    FLOAT = 4;
+    INT = 5;
+    STRING = 6;
+    TIME = 7;
+
+    // Groupings
+    TUPLE = 8;
+    ARRAY = 9;
+    MAP = 10;
+
+    // Table types
+    TABLE = 11;
+
+    // Functions
+    FUNCTION = 12;  // last tag
+  };
+
+  // Some typical parameters
+  required KIND Kind = 1;
+  optional string Table = 2;
+  optional int32 Param = 3;
+
+  // Required, repeated and optional foreign fields.
+  required GoTestField RequiredField = 4;
+  repeated GoTestField RepeatedField = 5;
+  optional GoTestField OptionalField = 6;
+
+  // Required fields of all basic types
+  required bool F_Bool_required = 10;
+  required int32 F_Int32_required = 11;
+  required int64 F_Int64_required = 12;
+  required fixed32 F_Fixed32_required = 13;
+  required fixed64 F_Fixed64_required = 14;
+  required uint32 F_Uint32_required = 15;
+  required uint64 F_Uint64_required = 16;
+  required float F_Float_required = 17;
+  required double F_Double_required = 18;
+  required string F_String_required = 19;
+  required bytes F_Bytes_required = 101;
+  required sint32 F_Sint32_required = 102;
+  required sint64 F_Sint64_required = 103;
+  required sfixed32 F_Sfixed32_required = 104;
+  required sfixed64 F_Sfixed64_required = 105;
+
+  // Repeated fields of all basic types
+  repeated bool F_Bool_repeated = 20;
+  repeated int32 F_Int32_repeated = 21;
+  repeated int64 F_Int64_repeated = 22;
+  repeated fixed32 F_Fixed32_repeated = 23;
+  repeated fixed64 F_Fixed64_repeated = 24;
+  repeated uint32 F_Uint32_repeated = 25;
+  repeated uint64 F_Uint64_repeated = 26;
+  repeated float F_Float_repeated = 27;
+  repeated double F_Double_repeated = 28;
+  repeated string F_String_repeated = 29;
+  repeated bytes F_Bytes_repeated = 201;
+  repeated sint32 F_Sint32_repeated = 202;
+  repeated sint64 F_Sint64_repeated = 203;
+  repeated sfixed32 F_Sfixed32_repeated = 204;
+  repeated sfixed64 F_Sfixed64_repeated = 205;
+
+  // Optional fields of all basic types
+  optional bool F_Bool_optional = 30;
+  optional int32 F_Int32_optional = 31;
+  optional int64 F_Int64_optional = 32;
+  optional fixed32 F_Fixed32_optional = 33;
+  optional fixed64 F_Fixed64_optional = 34;
+  optional uint32 F_Uint32_optional = 35;
+  optional uint64 F_Uint64_optional = 36;
+  optional float F_Float_optional = 37;
+  optional double F_Double_optional = 38;
+  optional string F_String_optional = 39;
+  optional bytes F_Bytes_optional = 301;
+  optional sint32 F_Sint32_optional = 302;
+  optional sint64 F_Sint64_optional = 303;
+  optional sfixed32 F_Sfixed32_optional = 304;
+  optional sfixed64 F_Sfixed64_optional = 305;
+
+  // Default-valued fields of all basic types
+  optional bool F_Bool_defaulted = 40 [default=true];
+  optional int32 F_Int32_defaulted = 41 [default=32];
+  optional int64 F_Int64_defaulted = 42 [default=64];
+  optional fixed32 F_Fixed32_defaulted = 43 [default=320];
+  optional fixed64 F_Fixed64_defaulted = 44 [default=640];
+  optional uint32 F_Uint32_defaulted = 45 [default=3200];
+  optional uint64 F_Uint64_defaulted = 46 [default=6400];
+  optional float F_Float_defaulted = 47 [default=314159.];
+  optional double F_Double_defaulted = 48 [default=271828.];
+  optional string F_String_defaulted = 49 [default="hello, \"world!\"\n"];
+  optional bytes F_Bytes_defaulted = 401 [default="Bignose"];
+  optional sint32 F_Sint32_defaulted = 402 [default = -32];
+  optional sint64 F_Sint64_defaulted = 403 [default = -64];
+  optional sfixed32 F_Sfixed32_defaulted = 404 [default = -32];
+  optional sfixed64 F_Sfixed64_defaulted = 405 [default = -64];
+
+  // Packed repeated fields (no string or bytes).
+  repeated bool F_Bool_repeated_packed = 50 [packed=true];
+  repeated int32 F_Int32_repeated_packed = 51 [packed=true];
+  repeated int64 F_Int64_repeated_packed = 52 [packed=true];
+  repeated fixed32 F_Fixed32_repeated_packed = 53 [packed=true];
+  repeated fixed64 F_Fixed64_repeated_packed = 54 [packed=true];
+  repeated uint32 F_Uint32_repeated_packed = 55 [packed=true];
+  repeated uint64 F_Uint64_repeated_packed = 56 [packed=true];
+  repeated float F_Float_repeated_packed = 57 [packed=true];
+  repeated double F_Double_repeated_packed = 58 [packed=true];
+  repeated sint32 F_Sint32_repeated_packed = 502 [packed=true];
+  repeated sint64 F_Sint64_repeated_packed = 503 [packed=true];
+  repeated sfixed32 F_Sfixed32_repeated_packed = 504 [packed=true];
+  repeated sfixed64 F_Sfixed64_repeated_packed = 505 [packed=true];
+
+  // Required, repeated, and optional groups.
+  required group RequiredGroup = 70 {
+    required string RequiredField = 71;
+  };
+
+  repeated group RepeatedGroup = 80 {
+    required string RequiredField = 81;
+  };
+
+  optional group OptionalGroup = 90 {
+    required string RequiredField = 91;
+  };
+}
+
+// For testing a group containing a required field.
+message GoTestRequiredGroupField {
+  required group Group = 1 {
+    required int32 Field = 2;
+  };
+}
+
+// For testing skipping of unrecognized fields.
+// Numbers are all big, larger than tag numbers in GoTestField,
+// the message used in the corresponding test.
+message GoSkipTest {
+  required int32 skip_int32 = 11;
+  required fixed32 skip_fixed32 = 12;
+  required fixed64 skip_fixed64 = 13;
+  required string skip_string = 14;
+  required group SkipGroup = 15 {
+    required int32 group_int32 = 16;
+    required string group_string = 17;
+  }
+}
+
+// For testing packed/non-packed decoder switching.
+// A serialized instance of one should be deserializable as the other.
+message NonPackedTest {
+  repeated int32 a = 1;
+}
+
+message PackedTest {
+  repeated int32 b = 1 [packed=true];
+}
+
+message MaxTag {
+  // Maximum possible tag number.
+  optional string last_field = 536870911;
+}
+
+message OldMessage {
+  message Nested {
+    optional string name = 1;
+  }
+  optional Nested nested = 1;
+
+  optional int32 num = 2;
+}
+
+// NewMessage is wire compatible with OldMessage;
+// imagine it as a future version.
+message NewMessage {
+  message Nested {
+    optional string name = 1;
+    optional string food_group = 2;
+  }
+  optional Nested nested = 1;
+
+  // This is an int32 in OldMessage.
+  optional int64 num = 2;
+}
+
+// Smaller tests for ASCII formatting.
+
+message InnerMessage {
+  required string host = 1;
+  optional int32 port = 2 [default=4000];
+  optional bool connected = 3;
+}
+
+message OtherMessage {
+  optional int64 key = 1;
+  optional bytes value = 2;
+  optional float weight = 3;
+  optional InnerMessage inner = 4;
+
+  extensions 100 to max;
+}
+
+message RequiredInnerMessage {
+  required InnerMessage leo_finally_won_an_oscar = 1;
+}
+
+message MyMessage {
+  required int32 count = 1;
+  optional string name = 2;
+  optional string quote = 3;
+  repeated string pet = 4;
+  optional InnerMessage inner = 5;
+  repeated OtherMessage others = 6;
+  optional RequiredInnerMessage we_must_go_deeper = 13;
+  repeated InnerMessage rep_inner = 12;
+
+  enum Color {
+    RED = 0;
+    GREEN = 1;
+    BLUE = 2;
+  };
+  optional Color bikeshed = 7;
+
+  optional group SomeGroup = 8 {
+    optional int32 group_field = 9;
+  }
+
+  // This field becomes [][]byte in the generated code.
+  repeated bytes rep_bytes = 10;
+
+  optional double bigfloat = 11;
+
+  extensions 100 to max;
+}
+
+message Ext {
+  extend MyMessage {
+    optional Ext more = 103;
+    optional string text = 104;
+    optional int32 number = 105;
+  }
+
+  optional string data = 1;
+  map<int32, int32> map_field = 2;
+}
+
+extend MyMessage {
+  repeated string greeting = 106;
+  // leave field 200 unregistered for testing
+}
+
+message ComplexExtension {
+  optional int32 first = 1;
+  optional int32 second = 2;
+  repeated int32 third = 3;
+}
+
+extend OtherMessage {
+  optional ComplexExtension complex = 200;
+  repeated ComplexExtension r_complex = 201;
+}
+
+message DefaultsMessage {
+  enum DefaultsEnum {
+    ZERO = 0;
+    ONE = 1;
+    TWO = 2;
+  };
+  extensions 100 to max;
+}
+
+extend DefaultsMessage {
+  optional double no_default_double = 101;
+  optional float no_default_float = 102;
+  optional int32 no_default_int32 = 103;
+  optional int64 no_default_int64 = 104;
+  optional uint32 no_default_uint32 = 105;
+  optional uint64 no_default_uint64 = 106;
+  optional sint32 no_default_sint32 = 107;
+  optional sint64 no_default_sint64 = 108;
+  optional fixed32 no_default_fixed32 = 109;
+  optional fixed64 no_default_fixed64 = 110;
+  optional sfixed32 no_default_sfixed32 = 111;
+  optional sfixed64 no_default_sfixed64 = 112;
+  optional bool no_default_bool = 113;
+  optional string no_default_string = 114;
+  optional bytes no_default_bytes = 115;
+  optional DefaultsMessage.DefaultsEnum no_default_enum = 116;
+
+  optional double default_double = 201 [default = 3.1415];
+  optional float default_float = 202 [default = 3.14];
+  optional int32 default_int32 = 203 [default = 42];
+  optional int64 default_int64 = 204 [default = 43];
+  optional uint32 default_uint32 = 205 [default = 44];
+  optional uint64 default_uint64 = 206 [default = 45];
+  optional sint32 default_sint32 = 207 [default = 46];
+  optional sint64 default_sint64 = 208 [default = 47];
+  optional fixed32 default_fixed32 = 209 [default = 48];
+  optional fixed64 default_fixed64 = 210 [default = 49];
+  optional sfixed32 default_sfixed32 = 211 [default = 50];
+  optional sfixed64 default_sfixed64 = 212 [default = 51];
+  optional bool default_bool = 213 [default = true];
+  optional string default_string = 214 [default = "Hello, string,def=foo"];
+  optional bytes default_bytes = 215 [default = "Hello, bytes"];
+  optional DefaultsMessage.DefaultsEnum default_enum = 216 [default = ONE];
+}
+
+message MyMessageSet {
+  option message_set_wire_format = true;
+  extensions 100 to max;
+}
+
+message Empty {
+}
+
+extend MyMessageSet {
+    optional Empty x201 = 201;
+    optional Empty x202 = 202;
+    optional Empty x203 = 203;
+    optional Empty x204 = 204;
+    optional Empty x205 = 205;
+    optional Empty x206 = 206;
+    optional Empty x207 = 207;
+    optional Empty x208 = 208;
+    optional Empty x209 = 209;
+    optional Empty x210 = 210;
+    optional Empty x211 = 211;
+    optional Empty x212 = 212;
+    optional Empty x213 = 213;
+    optional Empty x214 = 214;
+    optional Empty x215 = 215;
+    optional Empty x216 = 216;
+    optional Empty x217 = 217;
+    optional Empty x218 = 218;
+    optional Empty x219 = 219;
+    optional Empty x220 = 220;
+    optional Empty x221 = 221;
+    optional Empty x222 = 222;
+    optional Empty x223 = 223;
+    optional Empty x224 = 224;
+    optional Empty x225 = 225;
+    optional Empty x226 = 226;
+    optional Empty x227 = 227;
+    optional Empty x228 = 228;
+    optional Empty x229 = 229;
+    optional Empty x230 = 230;
+    optional Empty x231 = 231;
+    optional Empty x232 = 232;
+    optional Empty x233 = 233;
+    optional Empty x234 = 234;
+    optional Empty x235 = 235;
+    optional Empty x236 = 236;
+    optional Empty x237 = 237;
+    optional Empty x238 = 238;
+    optional Empty x239 = 239;
+    optional Empty x240 = 240;
+    optional Empty x241 = 241;
+    optional Empty x242 = 242;
+    optional Empty x243 = 243;
+    optional Empty x244 = 244;
+    optional Empty x245 = 245;
+    optional Empty x246 = 246;
+    optional Empty x247 = 247;
+    optional Empty x248 = 248;
+    optional Empty x249 = 249;
+    optional Empty x250 = 250;
+}
+
+message MessageList {
+  repeated group Message = 1 {
+    required string name = 2;
+    required int32 count = 3;
+  }
+}
+
+message Strings {
+  optional string string_field = 1;
+  optional bytes bytes_field = 2;
+}
+
+message Defaults {
+  enum Color {
+    RED = 0;
+    GREEN = 1;
+    BLUE = 2;
+  }
+
+  // Default-valued fields of all basic types.
+  // Same as GoTest, but copied here to make testing easier.
+  optional bool F_Bool = 1 [default=true];
+  optional int32 F_Int32 = 2 [default=32];
+  optional int64 F_Int64 = 3 [default=64];
+  optional fixed32 F_Fixed32 = 4 [default=320];
+  optional fixed64 F_Fixed64 = 5 [default=640];
+  optional uint32 F_Uint32 = 6 [default=3200];
+  optional uint64 F_Uint64 = 7 [default=6400];
+  optional float F_Float = 8 [default=314159.];
+  optional double F_Double = 9 [default=271828.];
+  optional string F_String = 10 [default="hello, \"world!\"\n"];
+  optional bytes F_Bytes = 11 [default="Bignose"];
+  optional sint32 F_Sint32 = 12 [default=-32];
+  optional sint64 F_Sint64 = 13 [default=-64];
+  optional Color F_Enum = 14 [default=GREEN];
+
+  // More fields with crazy defaults.
+  optional float F_Pinf = 15 [default=inf];
+  optional float F_Ninf = 16 [default=-inf];
+  optional float F_Nan = 17 [default=nan];
+
+  // Sub-message.
+  optional SubDefaults sub = 18;
+
+  // Redundant but explicit defaults.
+  optional string str_zero = 19 [default=""];
+}
+
+message SubDefaults {
+  optional int64 n = 1 [default=7];
+}
+
+message RepeatedEnum {
+  enum Color {
+    RED = 1;
+  }
+  repeated Color color = 1;
+}
+
+message MoreRepeated {
+  repeated bool bools = 1;
+  repeated bool bools_packed = 2 [packed=true];
+  repeated int32 ints = 3;
+  repeated int32 ints_packed = 4 [packed=true];
+  repeated int64 int64s_packed = 7 [packed=true];
+  repeated string strings = 5;
+  repeated fixed32 fixeds = 6;
+}
+
+// GroupOld and GroupNew have the same wire format.
+// GroupNew has a new field inside a group.
+
+message GroupOld {
+  optional group G = 101 {
+    optional int32 x = 2;
+  }
+}
+
+message GroupNew {
+  optional group G = 101 {
+    optional int32 x = 2;
+    optional int32 y = 3;
+  }
+}
+
+message FloatingPoint {
+  required double f = 1;
+  optional bool exact = 2;
+}
+
+message MessageWithMap {
+  map<int32, string> name_mapping = 1;
+  map<sint64, FloatingPoint> msg_mapping = 2;
+  map<bool, bytes> byte_mapping = 3;
+  map<string, string> str_to_str = 4;
+}
+
+message Oneof {
+  oneof union {
+    bool F_Bool = 1;
+    int32 F_Int32 = 2;
+    int64 F_Int64 = 3;
+    fixed32 F_Fixed32 = 4;
+    fixed64 F_Fixed64 = 5;
+    uint32 F_Uint32 = 6;
+    uint64 F_Uint64 = 7;
+    float F_Float = 8;
+    double F_Double = 9;
+    string F_String = 10;
+    bytes F_Bytes = 11;
+    sint32 F_Sint32 = 12;
+    sint64 F_Sint64 = 13;
+    MyMessage.Color F_Enum = 14;
+    GoTestField F_Message = 15;
+    group F_Group = 16 {
+      optional int32 x = 17;
+    }
+    int32 F_Largest_Tag = 536870911;
+  }
+
+  oneof tormato {
+    int32 value = 100;
+  }
+}
+
+message Communique {
+  optional bool make_me_cry = 1;
+
+  // This is a oneof, called "union".
+  oneof union {
+    int32 number = 5;
+    string name = 6;
+    bytes data = 7;
+    double temp_c = 8;
+    MyMessage.Color col = 9;
+    Strings msg = 10;
+  }
+}
+
+message TestUTF8 {
+  optional string scalar = 1;
+  repeated string vector = 2;
+  oneof oneof { string field = 3; }
+  map<string, int64> map_key = 4;
+  map<int64, string> map_value = 5;
+}

diff --git a/vendor/github.com/gogo/protobuf/proto/text.go b/vendor/github.com/gogo/protobuf/proto/text.go
new file mode 100644 (file)
index 0000000..0407ba8
--- /dev/null
+++ b/vendor/github.com/gogo/protobuf/proto/text.go
@@ -0,0 +1,928 @@
+// Protocol Buffers for Go with Gadgets
+//
+// Copyright (c) 2013, The GoGo Authors. All rights reserved.
+// http://github.com/gogo/protobuf
+//
+// Go support for Protocol Buffers - Google's data interchange format
+//
+// Copyright 2010 The Go Authors.  All rights reserved.
+// https://github.com/golang/protobuf
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//     * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//     * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//     * Neither the name of Google Inc. nor the names of its
+// contributors may be used to endorse or promote products derived from
+// this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+package proto
+
+// Functions for writing the text protocol buffer format.
+
+import (
+       "bufio"
+       "bytes"
+       "encoding"
+       "errors"
+       "fmt"
+       "io"
+       "log"
+       "math"
+       "reflect"
+       "sort"
+       "strings"
+       "sync"
+       "time"
+)
+
+var (
+       newline         = []byte("\n")
+       spaces          = []byte("                                        ")
+       endBraceNewline = []byte("}\n")
+       backslashN      = []byte{'\\', 'n'}
+       backslashR      = []byte{'\\', 'r'}
+       backslashT      = []byte{'\\', 't'}
+       backslashDQ     = []byte{'\\', '"'}
+       backslashBS     = []byte{'\\', '\\'}
+       posInf          = []byte("inf")
+       negInf          = []byte("-inf")
+       nan             = []byte("nan")
+)
+
+type writer interface {
+       io.Writer
+       WriteByte(byte) error
+}
+
+// textWriter is an io.Writer that tracks its indentation level.
+type textWriter struct {
+       ind      int
+       complete bool // if the current position is a complete line
+       compact  bool // whether to write out as a one-liner
+       w        writer
+}
+
+func (w *textWriter) WriteString(s string) (n int, err error) {
+       if !strings.Contains(s, "\n") {
+               if !w.compact && w.complete {
+                       w.writeIndent()
+               }
+               w.complete = false
+               return io.WriteString(w.w, s)
+       }
+       // WriteString is typically called without newlines, so this
+       // codepath and its copy are rare.  We copy to avoid
+       // duplicating all of Write's logic here.
+       return w.Write([]byte(s))
+}
+
+func (w *textWriter) Write(p []byte) (n int, err error) {
+       newlines := bytes.Count(p, newline)
+       if newlines == 0 {
+               if !w.compact && w.complete {
+                       w.writeIndent()
+               }
+               n, err = w.w.Write(p)
+               w.complete = false
+               return n, err
+       }
+
+       frags := bytes.SplitN(p, newline, newlines+1)
+       if w.compact {
+               for i, frag := range frags {
+                       if i > 0 {
+                               if err := w.w.WriteByte(' '); err != nil {
+                                       return n, err
+                               }
+                               n++
+                       }
+                       nn, err := w.w.Write(frag)
+                       n += nn
+                       if err != nil {
+                               return n, err
+                       }
+               }
+               return n, nil
+       }
+
+       for i, frag := range frags {
+               if w.complete {
+                       w.writeIndent()
+               }
+               nn, err := w.w.Write(frag)
+               n += nn
+               if err != nil {
+                       return n, err
+               }
+               if i+1 < len(frags) {
+                       if err := w.w.WriteByte('\n'); err != nil {
+                               return n, err
+                       }
+                       n++
+               }
+       }
+       w.complete = len(frags[len(frags)-1]) == 0
+       return n, nil
+}
+
+func (w *textWriter) WriteByte(c byte) error {
+       if w.compact && c == '\n' {
+               c = ' '
+       }
+       if !w.compact && w.complete {
+               w.writeIndent()
+       }
+       err := w.w.WriteByte(c)
+       w.complete = c == '\n'
+       return err
+}
+
+func (w *textWriter) indent() { w.ind++ }
+
+func (w *textWriter) unindent() {
+       if w.ind == 0 {
+               log.Print("proto: textWriter unindented too far")
+               return
+       }
+       w.ind--
+}
+
+func writeName(w *textWriter, props *Properties) error {
+       if _, err := w.WriteString(props.OrigName); err != nil {
+               return err
+       }
+       if props.Wire != "group" {
+               return w.WriteByte(':')
+       }
+       return nil
+}
+
+func requiresQuotes(u string) bool {
+       // When type URL contains any characters except [0-9A-Za-z./\-]*, it must be quoted.
+       for _, ch := range u {
+               switch {
+               case ch == '.' || ch == '/' || ch == '_':
+                       continue
+               case '0' <= ch && ch <= '9':
+                       continue
+               case 'A' <= ch && ch <= 'Z':
+                       continue
+               case 'a' <= ch && ch <= 'z':
+                       continue
+               default:
+                       return true
+               }
+       }
+       return false
+}
+
+// isAny reports whether sv is a google.protobuf.Any message
+func isAny(sv reflect.Value) bool {
+       type wkt interface {
+               XXX_WellKnownType() string
+       }
+       t, ok := sv.Addr().Interface().(wkt)
+       return ok && t.XXX_WellKnownType() == "Any"
+}
+
+// writeProto3Any writes an expanded google.protobuf.Any message.
+//
+// It returns (false, nil) if sv value can't be unmarshaled (e.g. because
+// required messages are not linked in).
+//
+// It returns (true, error) when sv was written in expanded format or an error
+// was encountered.
+func (tm *TextMarshaler) writeProto3Any(w *textWriter, sv reflect.Value) (bool, error) {
+       turl := sv.FieldByName("TypeUrl")
+       val := sv.FieldByName("Value")
+       if !turl.IsValid() || !val.IsValid() {
+               return true, errors.New("proto: invalid google.protobuf.Any message")
+       }
+
+       b, ok := val.Interface().([]byte)
+       if !ok {
+               return true, errors.New("proto: invalid google.protobuf.Any message")
+       }
+
+       parts := strings.Split(turl.String(), "/")
+       mt := MessageType(parts[len(parts)-1])
+       if mt == nil {
+               return false, nil
+       }
+       m := reflect.New(mt.Elem())
+       if err := Unmarshal(b, m.Interface().(Message)); err != nil {
+               return false, nil
+       }
+       w.Write([]byte("["))
+       u := turl.String()
+       if requiresQuotes(u) {
+               writeString(w, u)
+       } else {
+               w.Write([]byte(u))
+       }
+       if w.compact {
+               w.Write([]byte("]:<"))
+       } else {
+               w.Write([]byte("]: <\n"))
+               w.ind++
+       }
+       if err := tm.writeStruct(w, m.Elem()); err != nil {
+               return true, err
+       }
+       if w.compact {
+               w.Write([]byte("> "))
+       } else {
+               w.ind--
+               w.Write([]byte(">\n"))
+       }
+       return true, nil
+}
+
+func (tm *TextMarshaler) writeStruct(w *textWriter, sv reflect.Value) error {
+       if tm.ExpandAny && isAny(sv) {
+               if canExpand, err := tm.writeProto3Any(w, sv); canExpand {
+                       return err
+               }
+       }
+       st := sv.Type()
+       sprops := GetProperties(st)
+       for i := 0; i < sv.NumField(); i++ {
+               fv := sv.Field(i)
+               props := sprops.Prop[i]
+               name := st.Field(i).Name
+
+               if name == "XXX_NoUnkeyedLiteral" {
+                       continue
+               }
+
+               if strings.HasPrefix(name, "XXX_") {
+                       // There are two XXX_ fields:
+                       //   XXX_unrecognized []byte
+                       //   XXX_extensions   map[int32]proto.Extension
+                       // The first is handled here;
+                       // the second is handled at the bottom of this function.
+                       if name == "XXX_unrecognized" && !fv.IsNil() {
+                               if err := writeUnknownStruct(w, fv.Interface().([]byte)); err != nil {
+                                       return err
+                               }
+                       }
+                       continue
+               }
+               if fv.Kind() == reflect.Ptr && fv.IsNil() {
+                       // Field not filled in. This could be an optional field or
+                       // a required field that wasn't filled in. Either way, there
+                       // isn't anything we can show for it.
+                       continue
+               }
+               if fv.Kind() == reflect.Slice && fv.IsNil() {
+                       // Repeated field that is empty, or a bytes field that is unused.
+                       continue
+               }
+
+               if props.Repeated && fv.Kind() == reflect.Slice {
+                       // Repeated field.
+                       for j := 0; j < fv.Len(); j++ {
+                               if err := writeName(w, props); err != nil {
+                                       return err
+                               }
+                               if !w.compact {
+                                       if err := w.WriteByte(' '); err != nil {
+                                               return err
+                                       }
+                               }
+                               v := fv.Index(j)
+                               if v.Kind() == reflect.Ptr && v.IsNil() {
+                                       // A nil message in a repeated field is not valid,
+                                       // but we can handle that more gracefully than panicking.
+                                       if _, err := w.Write([]byte("<nil>\n")); err != nil {
+                                               return err
+                                       }
+                                       continue
+                               }
+                               if len(props.Enum) > 0 {
+                                       if err := tm.writeEnum(w, v, props); err != nil {
+                                               return err
+                                       }
+                               } else if err := tm.writeAny(w, v, props); err != nil {
+                                       return err
+                               }
+                               if err := w.WriteByte('\n'); err != nil {
+                                       return err
+                               }
+                       }
+                       continue
+               }
+               if fv.Kind() == reflect.Map {
+                       // Map fields are rendered as a repeated struct with key/value fields.
+                       keys := fv.MapKeys()
+                       sort.Sort(mapKeys(keys))
+                       for _, key := range keys {
+                               val := fv.MapIndex(key)
+                               if err := writeName(w, props); err != nil {
+                                       return err
+                               }
+                               if !w.compact {
+                                       if err := w.WriteByte(' '); err != nil {
+                                               return err
+                                       }
+                               }
+                               // open struct
+                               if err := w.WriteByte('<'); err != nil {
+                                       return err
+                               }
+                               if !w.compact {
+                                       if err := w.WriteByte('\n'); err != nil {
+                                               return err
+                                       }
+                               }
+                               w.indent()
+                               // key
+                               if _, err := w.WriteString("key:"); err != nil {
+                                       return err
+                               }
+                               if !w.compact {
+                                       if err := w.WriteByte(' '); err != nil {
+                                               return err
+                                       }
+                               }
+                               if err := tm.writeAny(w, key, props.MapKeyProp); err != nil {
+                                       return err
+                               }
+                               if err := w.WriteByte('\n'); err != nil {
+                                       return err
+                               }
+                               // nil values aren't legal, but we can avoid panicking because of them.
+                               if val.Kind() != reflect.Ptr || !val.IsNil() {
+                                       // value
+                                       if _, err := w.WriteString("value:"); err != nil {
+                                               return err
+                                       }
+                                       if !w.compact {
+                                               if err := w.WriteByte(' '); err != nil {
+                                                       return err
+                                               }
+                                       }
+                                       if err := tm.writeAny(w, val, props.MapValProp); err != nil {
+                                               return err
+                                       }
+                                       if err := w.WriteByte('\n'); err != nil {
+                                               return err
+                                       }
+                               }
+                               // close struct
+                               w.unindent()
+                               if err := w.WriteByte('>'); err != nil {
+                                       return err
+                               }
+                               if err := w.WriteByte('\n'); err != nil {
+                                       return err
+                               }
+                       }
+                       continue
+               }
+               if props.proto3 && fv.Kind() == reflect.Slice && fv.Len() == 0 {
+                       // empty bytes field
+                       continue
+               }
+               if props.proto3 && fv.Kind() != reflect.Ptr && fv.Kind() != reflect.Slice {
+                       // proto3 non-repeated scalar field; skip if zero value
+                       if isProto3Zero(fv) {
+                               continue
+                       }
+               }
+
+               if fv.Kind() == reflect.Interface {
+                       // Check if it is a oneof.
+                       if st.Field(i).Tag.Get("protobuf_oneof") != "" {
+                               // fv is nil, or holds a pointer to generated struct.
+                               // That generated struct has exactly one field,
+                               // which has a protobuf struct tag.
+                               if fv.IsNil() {
+                                       continue
+                               }
+                               inner := fv.Elem().Elem() // interface -> *T -> T
+                               tag := inner.Type().Field(0).Tag.Get("protobuf")
+                               props = new(Properties) // Overwrite the outer props var, but not its pointee.
+                               props.Parse(tag)
+                               // Write the value in the oneof, not the oneof itself.
+                               fv = inner.Field(0)
+
+                               // Special case to cope with malformed messages gracefully:
+                               // If the value in the oneof is a nil pointer, don't panic
+                               // in writeAny.
+                               if fv.Kind() == reflect.Ptr && fv.IsNil() {
+                                       // Use errors.New so writeAny won't render quotes.
+                                       msg := errors.New("/* nil */")
+                                       fv = reflect.ValueOf(&msg).Elem()
+                               }
+                       }
+               }
+
+               if err := writeName(w, props); err != nil {
+                       return err
+               }
+               if !w.compact {
+                       if err := w.WriteByte(' '); err != nil {
+                               return err
+                       }
+               }
+
+               if len(props.Enum) > 0 {
+                       if err := tm.writeEnum(w, fv, props); err != nil {
+                               return err
+                       }
+               } else if err := tm.writeAny(w, fv, props); err != nil {
+                       return err
+               }
+
+               if err := w.WriteByte('\n'); err != nil {
+                       return err
+               }
+       }
+
+       // Extensions (the XXX_extensions field).
+       pv := sv
+       if pv.CanAddr() {
+               pv = sv.Addr()
+       } else {
+               pv = reflect.New(sv.Type())
+               pv.Elem().Set(sv)
+       }
+       if _, err := extendable(pv.Interface()); err == nil {
+               if err := tm.writeExtensions(w, pv); err != nil {
+                       return err
+               }
+       }
+
+       return nil
+}
+
+// writeAny writes an arbitrary field.
+func (tm *TextMarshaler) writeAny(w *textWriter, v reflect.Value, props *Properties) error {
+       v = reflect.Indirect(v)
+
+       if props != nil {
+               if len(props.CustomType) > 0 {
+                       custom, ok := v.Interface().(Marshaler)
+                       if ok {
+                               data, err := custom.Marshal()
+                               if err != nil {
+                                       return err
+                               }
+                               if err := writeString(w, string(data)); err != nil {
+                                       return err
+                               }
+                               return nil
+                       }
+               } else if len(props.CastType) > 0 {
+                       if _, ok := v.Interface().(interface {
+                               String() string
+                       }); ok {
+                               switch v.Kind() {
+                               case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64,
+                                       reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64:
+                                       _, err := fmt.Fprintf(w, "%d", v.Interface())
+                                       return err
+                               }
+                       }
+               } else if props.StdTime {
+                       t, ok := v.Interface().(time.Time)
+                       if !ok {
+                               return fmt.Errorf("stdtime is not time.Time, but %T", v.Interface())
+                       }
+                       tproto, err := timestampProto(t)
+                       if err != nil {
+                               return err
+                       }
+                       propsCopy := *props // Make a copy so that this is goroutine-safe
+                       propsCopy.StdTime = false
+                       err = tm.writeAny(w, reflect.ValueOf(tproto), &propsCopy)
+                       return err
+               } else if props.StdDuration {
+                       d, ok := v.Interface().(time.Duration)
+                       if !ok {
+                               return fmt.Errorf("stdtime is not time.Duration, but %T", v.Interface())
+                       }
+                       dproto := durationProto(d)
+                       propsCopy := *props // Make a copy so that this is goroutine-safe
+                       propsCopy.StdDuration = false
+                       err := tm.writeAny(w, reflect.ValueOf(dproto), &propsCopy)
+                       return err
+               }
+       }
+
+       // Floats have special cases.
+       if v.Kind() == reflect.Float32 || v.Kind() == reflect.Float64 {
+               x := v.Float()
+               var b []byte
+               switch {
+               case math.IsInf(x, 1):
+                       b = posInf
+               case math.IsInf(x, -1):
+                       b = negInf
+               case math.IsNaN(x):
+                       b = nan
+               }
+               if b != nil {
+                       _, err := w.Write(b)
+                       return err
+               }
+               // Other values are handled below.
+       }
+
+       // We don't attempt to serialise every possible value type; only those
+       // that can occur in protocol buffers.
+       switch v.Kind() {
+       case reflect.Slice:
+               // Should only be a []byte; repeated fields are handled in writeStruct.
+               if err := writeString(w, string(v.Bytes())); err != nil {
+                       return err
+               }
+       case reflect.String:
+               if err := writeString(w, v.String()); err != nil {
+                       return err
+               }
+       case reflect.Struct:
+               // Required/optional group/message.
+               var bra, ket byte = '<', '>'
+               if props != nil && props.Wire == "group" {
+                       bra, ket = '{', '}'
+               }
+               if err := w.WriteByte(bra); err != nil {
+                       return err
+               }
+               if !w.compact {
+                       if err := w.WriteByte('\n'); err != nil {
+                               return err
+                       }
+               }
+               w.indent()
+               if v.CanAddr() {
+                       // Calling v.Interface on a struct causes the reflect package to
+                       // copy the entire struct. This is racy with the new Marshaler
+                       // since we atomically update the XXX_sizecache.
+                       //
+                       // Thus, we retrieve a pointer to the struct if possible to avoid
+                       // a race since v.Interface on the pointer doesn't copy the struct.
+                       //
+                       // If v is not addressable, then we are not worried about a race
+                       // since it implies that the binary Marshaler cannot possibly be
+                       // mutating this value.
+                       v = v.Addr()
+               }
+               if etm, ok := v.Interface().(encoding.TextMarshaler); ok {
+                       text, err := etm.MarshalText()
+                       if err != nil {
+                               return err
+                       }
+                       if _, err = w.Write(text); err != nil {
+                               return err
+                       }
+               } else {
+                       if v.Kind() == reflect.Ptr {
+                               v = v.Elem()
+                       }
+                       if err := tm.writeStruct(w, v); err != nil {
+                               return err
+                       }
+               }
+               w.unindent()
+               if err := w.WriteByte(ket); err != nil {
+                       return err
+               }
+       default:
+               _, err := fmt.Fprint(w, v.Interface())
+               return err
+       }
+       return nil
+}
+
+// equivalent to C's isprint.
+func isprint(c byte) bool {
+       return c >= 0x20 && c < 0x7f
+}
+
+// writeString writes a string in the protocol buffer text format.
+// It is similar to strconv.Quote except we don't use Go escape sequences,
+// we treat the string as a byte sequence, and we use octal escapes.
+// These differences are to maintain interoperability with the other
+// languages' implementations of the text format.
+func writeString(w *textWriter, s string) error {
+       // use WriteByte here to get any needed indent
+       if err := w.WriteByte('"'); err != nil {
+               return err
+       }
+       // Loop over the bytes, not the runes.
+       for i := 0; i < len(s); i++ {
+               var err error
+               // Divergence from C++: we don't escape apostrophes.
+               // There's no need to escape them, and the C++ parser
+               // copes with a naked apostrophe.
+               switch c := s[i]; c {
+               case '\n':
+                       _, err = w.w.Write(backslashN)
+               case '\r':
+                       _, err = w.w.Write(backslashR)
+               case '\t':
+                       _, err = w.w.Write(backslashT)
+               case '"':
+                       _, err = w.w.Write(backslashDQ)
+               case '\\':
+                       _, err = w.w.Write(backslashBS)
+               default:
+                       if isprint(c) {
+                               err = w.w.WriteByte(c)
+                       } else {
+                               _, err = fmt.Fprintf(w.w, "\\%03o", c)
+                       }
+               }
+               if err != nil {
+                       return err
+               }
+       }
+       return w.WriteByte('"')
+}
+
+func writeUnknownStruct(w *textWriter, data []byte) (err error) {
+       if !w.compact {
+               if _, err := fmt.Fprintf(w, "/* %d unknown bytes */\n", len(data)); err != nil {
+                       return err
+               }
+       }
+       b := NewBuffer(data)
+       for b.index < len(b.buf) {
+               x, err := b.DecodeVarint()
+               if err != nil {
+                       _, ferr := fmt.Fprintf(w, "/* %v */\n", err)
+                       return ferr
+               }
+               wire, tag := x&7, x>>3
+               if wire == WireEndGroup {
+                       w.unindent()
+                       if _, werr := w.Write(endBraceNewline); werr != nil {
+                               return werr
+                       }
+                       continue
+               }
+               if _, ferr := fmt.Fprint(w, tag); ferr != nil {
+                       return ferr
+               }
+               if wire != WireStartGroup {
+                       if err = w.WriteByte(':'); err != nil {
+                               return err
+                       }
+               }
+               if !w.compact || wire == WireStartGroup {
+                       if err = w.WriteByte(' '); err != nil {
+                               return err
+                       }
+               }
+               switch wire {
+               case WireBytes:
+                       buf, e := b.DecodeRawBytes(false)
+                       if e == nil {
+                               _, err = fmt.Fprintf(w, "%q", buf)
+                       } else {
+                               _, err = fmt.Fprintf(w, "/* %v */", e)
+                       }
+               case WireFixed32:
+                       x, err = b.DecodeFixed32()
+                       err = writeUnknownInt(w, x, err)
+               case WireFixed64:
+                       x, err = b.DecodeFixed64()
+                       err = writeUnknownInt(w, x, err)
+               case WireStartGroup:
+                       err = w.WriteByte('{')
+                       w.indent()
+               case WireVarint:
+                       x, err = b.DecodeVarint()
+                       err = writeUnknownInt(w, x, err)
+               default:
+                       _, err = fmt.Fprintf(w, "/* unknown wire type %d */", wire)
+               }
+               if err != nil {
+                       return err
+               }
+               if err := w.WriteByte('\n'); err != nil {
+                       return err
+               }
+       }
+       return nil
+}
+
+func writeUnknownInt(w *textWriter, x uint64, err error) error {
+       if err == nil {
+               _, err = fmt.Fprint(w, x)
+       } else {
+               _, err = fmt.Fprintf(w, "/* %v */", err)
+       }
+       return err
+}
+
+type int32Slice []int32
+
+func (s int32Slice) Len() int           { return len(s) }
+func (s int32Slice) Less(i, j int) bool { return s[i] < s[j] }
+func (s int32Slice) Swap(i, j int)      { s[i], s[j] = s[j], s[i] }
+
+// writeExtensions writes all the extensions in pv.
+// pv is assumed to be a pointer to a protocol message struct that is extendable.
+func (tm *TextMarshaler) writeExtensions(w *textWriter, pv reflect.Value) error {
+       emap := extensionMaps[pv.Type().Elem()]
+       e := pv.Interface().(Message)
+
+       var m map[int32]Extension
+       var mu sync.Locker
+       if em, ok := e.(extensionsBytes); ok {
+               eb := em.GetExtensions()
+               var err error
+               m, err = BytesToExtensionsMap(*eb)
+               if err != nil {
+                       return err
+               }
+               mu = notLocker{}
+       } else if _, ok := e.(extendableProto); ok {
+               ep, _ := extendable(e)
+               m, mu = ep.extensionsRead()
+               if m == nil {
+                       return nil
+               }
+       }
+
+       // Order the extensions by ID.
+       // This isn't strictly necessary, but it will give us
+       // canonical output, which will also make testing easier.
+
+       mu.Lock()
+       ids := make([]int32, 0, len(m))
+       for id := range m {
+               ids = append(ids, id)
+       }
+       sort.Sort(int32Slice(ids))
+       mu.Unlock()
+
+       for _, extNum := range ids {
+               ext := m[extNum]
+               var desc *ExtensionDesc
+               if emap != nil {
+                       desc = emap[extNum]
+               }
+               if desc == nil {
+                       // Unknown extension.
+                       if err := writeUnknownStruct(w, ext.enc); err != nil {
+                               return err
+                       }
+                       continue
+               }
+
+               pb, err := GetExtension(e, desc)
+               if err != nil {
+                       return fmt.Errorf("failed getting extension: %v", err)
+               }
+
+               // Repeated extensions will appear as a slice.
+               if !desc.repeated() {
+                       if err := tm.writeExtension(w, desc.Name, pb); err != nil {
+                               return err
+                       }
+               } else {
+                       v := reflect.ValueOf(pb)
+                       for i := 0; i < v.Len(); i++ {
+                               if err := tm.writeExtension(w, desc.Name, v.Index(i).Interface()); err != nil {
+                                       return err
+                               }
+                       }
+               }
+       }
+       return nil
+}
+
+func (tm *TextMarshaler) writeExtension(w *textWriter, name string, pb interface{}) error {
+       if _, err := fmt.Fprintf(w, "[%s]:", name); err != nil {
+               return err
+       }
+       if !w.compact {
+               if err := w.WriteByte(' '); err != nil {
+                       return err
+               }
+       }
+       if err := tm.writeAny(w, reflect.ValueOf(pb), nil); err != nil {
+               return err
+       }
+       if err := w.WriteByte('\n'); err != nil {
+               return err
+       }
+       return nil
+}
+
+func (w *textWriter) writeIndent() {
+       if !w.complete {
+               return
+       }
+       remain := w.ind * 2
+       for remain > 0 {
+               n := remain
+               if n > len(spaces) {
+                       n = len(spaces)
+               }
+               w.w.Write(spaces[:n])
+               remain -= n
+       }
+       w.complete = false
+}
+
+// TextMarshaler is a configurable text format marshaler.
+type TextMarshaler struct {
+       Compact   bool // use compact text format (one line).
+       ExpandAny bool // expand google.protobuf.Any messages of known types
+}
+
+// Marshal writes a given protocol buffer in text format.
+// The only errors returned are from w.
+func (tm *TextMarshaler) Marshal(w io.Writer, pb Message) error {
+       val := reflect.ValueOf(pb)
+       if pb == nil || val.IsNil() {
+               w.Write([]byte("<nil>"))
+               return nil
+       }
+       var bw *bufio.Writer
+       ww, ok := w.(writer)
+       if !ok {
+               bw = bufio.NewWriter(w)
+               ww = bw
+       }
+       aw := &textWriter{
+               w:        ww,
+               complete: true,
+               compact:  tm.Compact,
+       }
+
+       if etm, ok := pb.(encoding.TextMarshaler); ok {
+               text, err := etm.MarshalText()
+               if err != nil {
+                       return err
+               }
+               if _, err = aw.Write(text); err != nil {
+                       return err
+               }
+               if bw != nil {
+                       return bw.Flush()
+               }
+               return nil
+       }
+       // Dereference the received pointer so we don't have outer < and >.
+       v := reflect.Indirect(val)
+       if err := tm.writeStruct(aw, v); err != nil {
+               return err
+       }
+       if bw != nil {
+               return bw.Flush()
+       }
+       return nil
+}
+
+// Text is the same as Marshal, but returns the string directly.
+func (tm *TextMarshaler) Text(pb Message) string {
+       var buf bytes.Buffer
+       tm.Marshal(&buf, pb)
+       return buf.String()
+}
+
+var (
+       defaultTextMarshaler = TextMarshaler{}
+       compactTextMarshaler = TextMarshaler{Compact: true}
+)
+
+// TODO: consider removing some of the Marshal functions below.
+
+// MarshalText writes a given protocol buffer in text format.
+// The only errors returned are from w.
+func MarshalText(w io.Writer, pb Message) error { return defaultTextMarshaler.Marshal(w, pb) }
+
+// MarshalTextString is the same as MarshalText, but returns the string directly.
+func MarshalTextString(pb Message) string { return defaultTextMarshaler.Text(pb) }
+
+// CompactText writes a given protocol buffer in compact text format (one line).
+func CompactText(w io.Writer, pb Message) error { return compactTextMarshaler.Marshal(w, pb) }
+
+// CompactTextString is the same as CompactText, but returns the string directly.
+func CompactTextString(pb Message) string { return compactTextMarshaler.Text(pb) }

diff --git a/vendor/github.com/gogo/protobuf/proto/text_gogo.go b/vendor/github.com/gogo/protobuf/proto/text_gogo.go
new file mode 100644 (file)
index 0000000..1d6c6aa
--- /dev/null
+++ b/vendor/github.com/gogo/protobuf/proto/text_gogo.go
@@ -0,0 +1,57 @@
+// Protocol Buffers for Go with Gadgets
+//
+// Copyright (c) 2013, The GoGo Authors. All rights reserved.
+// http://github.com/gogo/protobuf
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//     * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//     * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+package proto
+
+import (
+       "fmt"
+       "reflect"
+)
+
+func (tm *TextMarshaler) writeEnum(w *textWriter, v reflect.Value, props *Properties) error {
+       m, ok := enumStringMaps[props.Enum]
+       if !ok {
+               if err := tm.writeAny(w, v, props); err != nil {
+                       return err
+               }
+       }
+       key := int32(0)
+       if v.Kind() == reflect.Ptr {
+               key = int32(v.Elem().Int())
+       } else {
+               key = int32(v.Int())
+       }
+       s, ok := m[key]
+       if !ok {
+               if err := tm.writeAny(w, v, props); err != nil {
+                       return err
+               }
+       }
+       _, err := fmt.Fprint(w, s)
+       return err
+}

diff --git a/vendor/github.com/gogo/protobuf/proto/text_parser.go b/vendor/github.com/gogo/protobuf/proto/text_parser.go
new file mode 100644 (file)
index 0000000..1ce0be2
--- /dev/null
+++ b/vendor/github.com/gogo/protobuf/proto/text_parser.go
@@ -0,0 +1,1018 @@
+// Protocol Buffers for Go with Gadgets
+//
+// Copyright (c) 2013, The GoGo Authors. All rights reserved.
+// http://github.com/gogo/protobuf
+//
+// Go support for Protocol Buffers - Google's data interchange format
+//
+// Copyright 2010 The Go Authors.  All rights reserved.
+// https://github.com/golang/protobuf
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//     * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//     * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//     * Neither the name of Google Inc. nor the names of its
+// contributors may be used to endorse or promote products derived from
+// this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+package proto
+
+// Functions for parsing the Text protocol buffer format.
+// TODO: message sets.
+
+import (
+       "encoding"
+       "errors"
+       "fmt"
+       "reflect"
+       "strconv"
+       "strings"
+       "time"
+       "unicode/utf8"
+)
+
+// Error string emitted when deserializing Any and fields are already set
+const anyRepeatedlyUnpacked = "Any message unpacked multiple times, or %q already set"
+
+type ParseError struct {
+       Message string
+       Line    int // 1-based line number
+       Offset  int // 0-based byte offset from start of input
+}
+
+func (p *ParseError) Error() string {
+       if p.Line == 1 {
+               // show offset only for first line
+               return fmt.Sprintf("line 1.%d: %v", p.Offset, p.Message)
+       }
+       return fmt.Sprintf("line %d: %v", p.Line, p.Message)
+}
+
+type token struct {
+       value    string
+       err      *ParseError
+       line     int    // line number
+       offset   int    // byte number from start of input, not start of line
+       unquoted string // the unquoted version of value, if it was a quoted string
+}
+
+func (t *token) String() string {
+       if t.err == nil {
+               return fmt.Sprintf("%q (line=%d, offset=%d)", t.value, t.line, t.offset)
+       }
+       return fmt.Sprintf("parse error: %v", t.err)
+}
+
+type textParser struct {
+       s            string // remaining input
+       done         bool   // whether the parsing is finished (success or error)
+       backed       bool   // whether back() was called
+       offset, line int
+       cur          token
+}
+
+func newTextParser(s string) *textParser {
+       p := new(textParser)
+       p.s = s
+       p.line = 1
+       p.cur.line = 1
+       return p
+}
+
+func (p *textParser) errorf(format string, a ...interface{}) *ParseError {
+       pe := &ParseError{fmt.Sprintf(format, a...), p.cur.line, p.cur.offset}
+       p.cur.err = pe
+       p.done = true
+       return pe
+}
+
+// Numbers and identifiers are matched by [-+._A-Za-z0-9]
+func isIdentOrNumberChar(c byte) bool {
+       switch {
+       case 'A' <= c && c <= 'Z', 'a' <= c && c <= 'z':
+               return true
+       case '0' <= c && c <= '9':
+               return true
+       }
+       switch c {
+       case '-', '+', '.', '_':
+               return true
+       }
+       return false
+}
+
+func isWhitespace(c byte) bool {
+       switch c {
+       case ' ', '\t', '\n', '\r':
+               return true
+       }
+       return false
+}
+
+func isQuote(c byte) bool {
+       switch c {
+       case '"', '\'':
+               return true
+       }
+       return false
+}
+
+func (p *textParser) skipWhitespace() {
+       i := 0
+       for i < len(p.s) && (isWhitespace(p.s[i]) || p.s[i] == '#') {
+               if p.s[i] == '#' {
+                       // comment; skip to end of line or input
+                       for i < len(p.s) && p.s[i] != '\n' {
+                               i++
+                       }
+                       if i == len(p.s) {
+                               break
+                       }
+               }
+               if p.s[i] == '\n' {
+                       p.line++
+               }
+               i++
+       }
+       p.offset += i
+       p.s = p.s[i:len(p.s)]
+       if len(p.s) == 0 {
+               p.done = true
+       }
+}
+
+func (p *textParser) advance() {
+       // Skip whitespace
+       p.skipWhitespace()
+       if p.done {
+               return
+       }
+
+       // Start of non-whitespace
+       p.cur.err = nil
+       p.cur.offset, p.cur.line = p.offset, p.line
+       p.cur.unquoted = ""
+       switch p.s[0] {
+       case '<', '>', '{', '}', ':', '[', ']', ';', ',', '/':
+               // Single symbol
+               p.cur.value, p.s = p.s[0:1], p.s[1:len(p.s)]
+       case '"', '\'':
+               // Quoted string
+               i := 1
+               for i < len(p.s) && p.s[i] != p.s[0] && p.s[i] != '\n' {
+                       if p.s[i] == '\\' && i+1 < len(p.s) {
+                               // skip escaped char
+                               i++
+                       }
+                       i++
+               }
+               if i >= len(p.s) || p.s[i] != p.s[0] {
+                       p.errorf("unmatched quote")
+                       return
+               }
+               unq, err := unquoteC(p.s[1:i], rune(p.s[0]))
+               if err != nil {
+                       p.errorf("invalid quoted string %s: %v", p.s[0:i+1], err)
+                       return
+               }
+               p.cur.value, p.s = p.s[0:i+1], p.s[i+1:len(p.s)]
+               p.cur.unquoted = unq
+       default:
+               i := 0
+               for i < len(p.s) && isIdentOrNumberChar(p.s[i]) {
+                       i++
+               }
+               if i == 0 {
+                       p.errorf("unexpected byte %#x", p.s[0])
+                       return
+               }
+               p.cur.value, p.s = p.s[0:i], p.s[i:len(p.s)]
+       }
+       p.offset += len(p.cur.value)
+}
+
+var (
+       errBadUTF8 = errors.New("proto: bad UTF-8")
+)
+
+func unquoteC(s string, quote rune) (string, error) {
+       // This is based on C++'s tokenizer.cc.
+       // Despite its name, this is *not* parsing C syntax.
+       // For instance, "\0" is an invalid quoted string.
+
+       // Avoid allocation in trivial cases.
+       simple := true
+       for _, r := range s {
+               if r == '\\' || r == quote {
+                       simple = false
+                       break
+               }
+       }
+       if simple {
+               return s, nil
+       }
+
+       buf := make([]byte, 0, 3*len(s)/2)
+       for len(s) > 0 {
+               r, n := utf8.DecodeRuneInString(s)
+               if r == utf8.RuneError && n == 1 {
+                       return "", errBadUTF8
+               }
+               s = s[n:]
+               if r != '\\' {
+                       if r < utf8.RuneSelf {
+                               buf = append(buf, byte(r))
+                       } else {
+                               buf = append(buf, string(r)...)
+                       }
+                       continue
+               }
+
+               ch, tail, err := unescape(s)
+               if err != nil {
+                       return "", err
+               }
+               buf = append(buf, ch...)
+               s = tail
+       }
+       return string(buf), nil
+}
+
+func unescape(s string) (ch string, tail string, err error) {
+       r, n := utf8.DecodeRuneInString(s)
+       if r == utf8.RuneError && n == 1 {
+               return "", "", errBadUTF8
+       }
+       s = s[n:]
+       switch r {
+       case 'a':
+               return "\a", s, nil
+       case 'b':
+               return "\b", s, nil
+       case 'f':
+               return "\f", s, nil
+       case 'n':
+               return "\n", s, nil
+       case 'r':
+               return "\r", s, nil
+       case 't':
+               return "\t", s, nil
+       case 'v':
+               return "\v", s, nil
+       case '?':
+               return "?", s, nil // trigraph workaround
+       case '\'', '"', '\\':
+               return string(r), s, nil
+       case '0', '1', '2', '3', '4', '5', '6', '7':
+               if len(s) < 2 {
+                       return "", "", fmt.Errorf(`\%c requires 2 following digits`, r)
+               }
+               ss := string(r) + s[:2]
+               s = s[2:]
+               i, err := strconv.ParseUint(ss, 8, 8)
+               if err != nil {
+                       return "", "", fmt.Errorf(`\%s contains non-octal digits`, ss)
+               }
+               return string([]byte{byte(i)}), s, nil
+       case 'x', 'X', 'u', 'U':
+               var n int
+               switch r {
+               case 'x', 'X':
+                       n = 2
+               case 'u':
+                       n = 4
+               case 'U':
+                       n = 8
+               }
+               if len(s) < n {
+                       return "", "", fmt.Errorf(`\%c requires %d following digits`, r, n)
+               }
+               ss := s[:n]
+               s = s[n:]
+               i, err := strconv.ParseUint(ss, 16, 64)
+               if err != nil {
+                       return "", "", fmt.Errorf(`\%c%s contains non-hexadecimal digits`, r, ss)
+               }
+               if r == 'x' || r == 'X' {
+                       return string([]byte{byte(i)}), s, nil
+               }
+               if i > utf8.MaxRune {
+                       return "", "", fmt.Errorf(`\%c%s is not a valid Unicode code point`, r, ss)
+               }
+               return string(i), s, nil
+       }
+       return "", "", fmt.Errorf(`unknown escape \%c`, r)
+}
+
+// Back off the parser by one token. Can only be done between calls to next().
+// It makes the next advance() a no-op.
+func (p *textParser) back() { p.backed = true }
+
+// Advances the parser and returns the new current token.
+func (p *textParser) next() *token {
+       if p.backed || p.done {
+               p.backed = false
+               return &p.cur
+       }
+       p.advance()
+       if p.done {
+               p.cur.value = ""
+       } else if len(p.cur.value) > 0 && isQuote(p.cur.value[0]) {
+               // Look for multiple quoted strings separated by whitespace,
+               // and concatenate them.
+               cat := p.cur
+               for {
+                       p.skipWhitespace()
+                       if p.done || !isQuote(p.s[0]) {
+                               break
+                       }
+                       p.advance()
+                       if p.cur.err != nil {
+                               return &p.cur
+                       }
+                       cat.value += " " + p.cur.value
+                       cat.unquoted += p.cur.unquoted
+               }
+               p.done = false // parser may have seen EOF, but we want to return cat
+               p.cur = cat
+       }
+       return &p.cur
+}
+
+func (p *textParser) consumeToken(s string) error {
+       tok := p.next()
+       if tok.err != nil {
+               return tok.err
+       }
+       if tok.value != s {
+               p.back()
+               return p.errorf("expected %q, found %q", s, tok.value)
+       }
+       return nil
+}
+
+// Return a RequiredNotSetError indicating which required field was not set.
+func (p *textParser) missingRequiredFieldError(sv reflect.Value) *RequiredNotSetError {
+       st := sv.Type()
+       sprops := GetProperties(st)
+       for i := 0; i < st.NumField(); i++ {
+               if !isNil(sv.Field(i)) {
+                       continue
+               }
+
+               props := sprops.Prop[i]
+               if props.Required {
+                       return &RequiredNotSetError{fmt.Sprintf("%v.%v", st, props.OrigName)}
+               }
+       }
+       return &RequiredNotSetError{fmt.Sprintf("%v.<unknown field name>", st)} // should not happen
+}
+
+// Returns the index in the struct for the named field, as well as the parsed tag properties.
+func structFieldByName(sprops *StructProperties, name string) (int, *Properties, bool) {
+       i, ok := sprops.decoderOrigNames[name]
+       if ok {
+               return i, sprops.Prop[i], true
+       }
+       return -1, nil, false
+}
+
+// Consume a ':' from the input stream (if the next token is a colon),
+// returning an error if a colon is needed but not present.
+func (p *textParser) checkForColon(props *Properties, typ reflect.Type) *ParseError {
+       tok := p.next()
+       if tok.err != nil {
+               return tok.err
+       }
+       if tok.value != ":" {
+               // Colon is optional when the field is a group or message.
+               needColon := true
+               switch props.Wire {
+               case "group":
+                       needColon = false
+               case "bytes":
+                       // A "bytes" field is either a message, a string, or a repeated field;
+                       // those three become *T, *string and []T respectively, so we can check for
+                       // this field being a pointer to a non-string.
+                       if typ.Kind() == reflect.Ptr {
+                               // *T or *string
+                               if typ.Elem().Kind() == reflect.String {
+                                       break
+                               }
+                       } else if typ.Kind() == reflect.Slice {
+                               // []T or []*T
+                               if typ.Elem().Kind() != reflect.Ptr {
+                                       break
+                               }
+                       } else if typ.Kind() == reflect.String {
+                               // The proto3 exception is for a string field,
+                               // which requires a colon.
+                               break
+                       }
+                       needColon = false
+               }
+               if needColon {
+                       return p.errorf("expected ':', found %q", tok.value)
+               }
+               p.back()
+       }
+       return nil
+}
+
+func (p *textParser) readStruct(sv reflect.Value, terminator string) error {
+       st := sv.Type()
+       sprops := GetProperties(st)
+       reqCount := sprops.reqCount
+       var reqFieldErr error
+       fieldSet := make(map[string]bool)
+       // A struct is a sequence of "name: value", terminated by one of
+       // '>' or '}', or the end of the input.  A name may also be
+       // "[extension]" or "[type/url]".
+       //
+       // The whole struct can also be an expanded Any message, like:
+       // [type/url] < ... struct contents ... >
+       for {
+               tok := p.next()
+               if tok.err != nil {
+                       return tok.err
+               }
+               if tok.value == terminator {
+                       break
+               }
+               if tok.value == "[" {
+                       // Looks like an extension or an Any.
+                       //
+                       // TODO: Check whether we need to handle
+                       // namespace rooted names (e.g. ".something.Foo").
+                       extName, err := p.consumeExtName()
+                       if err != nil {
+                               return err
+                       }
+
+                       if s := strings.LastIndex(extName, "/"); s >= 0 {
+                               // If it contains a slash, it's an Any type URL.
+                               messageName := extName[s+1:]
+                               mt := MessageType(messageName)
+                               if mt == nil {
+                                       return p.errorf("unrecognized message %q in google.protobuf.Any", messageName)
+                               }
+                               tok = p.next()
+                               if tok.err != nil {
+                                       return tok.err
+                               }
+                               // consume an optional colon
+                               if tok.value == ":" {
+                                       tok = p.next()
+                                       if tok.err != nil {
+                                               return tok.err
+                                       }
+                               }
+                               var terminator string
+                               switch tok.value {
+                               case "<":
+                                       terminator = ">"
+                               case "{":
+                                       terminator = "}"
+                               default:
+                                       return p.errorf("expected '{' or '<', found %q", tok.value)
+                               }
+                               v := reflect.New(mt.Elem())
+                               if pe := p.readStruct(v.Elem(), terminator); pe != nil {
+                                       return pe
+                               }
+                               b, err := Marshal(v.Interface().(Message))
+                               if err != nil {
+                                       return p.errorf("failed to marshal message of type %q: %v", messageName, err)
+                               }
+                               if fieldSet["type_url"] {
+                                       return p.errorf(anyRepeatedlyUnpacked, "type_url")
+                               }
+                               if fieldSet["value"] {
+                                       return p.errorf(anyRepeatedlyUnpacked, "value")
+                               }
+                               sv.FieldByName("TypeUrl").SetString(extName)
+                               sv.FieldByName("Value").SetBytes(b)
+                               fieldSet["type_url"] = true
+                               fieldSet["value"] = true
+                               continue
+                       }
+
+                       var desc *ExtensionDesc
+                       // This could be faster, but it's functional.
+                       // TODO: Do something smarter than a linear scan.
+                       for _, d := range RegisteredExtensions(reflect.New(st).Interface().(Message)) {
+                               if d.Name == extName {
+                                       desc = d
+                                       break
+                               }
+                       }
+                       if desc == nil {
+                               return p.errorf("unrecognized extension %q", extName)
+                       }
+
+                       props := &Properties{}
+                       props.Parse(desc.Tag)
+
+                       typ := reflect.TypeOf(desc.ExtensionType)
+                       if err := p.checkForColon(props, typ); err != nil {
+                               return err
+                       }
+
+                       rep := desc.repeated()
+
+                       // Read the extension structure, and set it in
+                       // the value we're constructing.
+                       var ext reflect.Value
+                       if !rep {
+                               ext = reflect.New(typ).Elem()
+                       } else {
+                               ext = reflect.New(typ.Elem()).Elem()
+                       }
+                       if err := p.readAny(ext, props); err != nil {
+                               if _, ok := err.(*RequiredNotSetError); !ok {
+                                       return err
+                               }
+                               reqFieldErr = err
+                       }
+                       ep := sv.Addr().Interface().(Message)
+                       if !rep {
+                               SetExtension(ep, desc, ext.Interface())
+                       } else {
+                               old, err := GetExtension(ep, desc)
+                               var sl reflect.Value
+                               if err == nil {
+                                       sl = reflect.ValueOf(old) // existing slice
+                               } else {
+                                       sl = reflect.MakeSlice(typ, 0, 1)
+                               }
+                               sl = reflect.Append(sl, ext)
+                               SetExtension(ep, desc, sl.Interface())
+                       }
+                       if err := p.consumeOptionalSeparator(); err != nil {
+                               return err
+                       }
+                       continue
+               }
+
+               // This is a normal, non-extension field.
+               name := tok.value
+               var dst reflect.Value
+               fi, props, ok := structFieldByName(sprops, name)
+               if ok {
+                       dst = sv.Field(fi)
+               } else if oop, ok := sprops.OneofTypes[name]; ok {
+                       // It is a oneof.
+                       props = oop.Prop
+                       nv := reflect.New(oop.Type.Elem())
+                       dst = nv.Elem().Field(0)
+                       field := sv.Field(oop.Field)
+                       if !field.IsNil() {
+                               return p.errorf("field '%s' would overwrite already parsed oneof '%s'", name, sv.Type().Field(oop.Field).Name)
+                       }
+                       field.Set(nv)
+               }
+               if !dst.IsValid() {
+                       return p.errorf("unknown field name %q in %v", name, st)
+               }
+
+               if dst.Kind() == reflect.Map {
+                       // Consume any colon.
+                       if err := p.checkForColon(props, dst.Type()); err != nil {
+                               return err
+                       }
+
+                       // Construct the map if it doesn't already exist.
+                       if dst.IsNil() {
+                               dst.Set(reflect.MakeMap(dst.Type()))
+                       }
+                       key := reflect.New(dst.Type().Key()).Elem()
+                       val := reflect.New(dst.Type().Elem()).Elem()
+
+                       // The map entry should be this sequence of tokens:
+                       //      < key : KEY value : VALUE >
+                       // However, implementations may omit key or value, and technically
+                       // we should support them in any order.  See b/28924776 for a time
+                       // this went wrong.
+
+                       tok := p.next()
+                       var terminator string
+                       switch tok.value {
+                       case "<":
+                               terminator = ">"
+                       case "{":
+                               terminator = "}"
+                       default:
+                               return p.errorf("expected '{' or '<', found %q", tok.value)
+                       }
+                       for {
+                               tok := p.next()
+                               if tok.err != nil {
+                                       return tok.err
+                               }
+                               if tok.value == terminator {
+                                       break
+                               }
+                               switch tok.value {
+                               case "key":
+                                       if err := p.consumeToken(":"); err != nil {
+                                               return err
+                                       }
+                                       if err := p.readAny(key, props.MapKeyProp); err != nil {
+                                               return err
+                                       }
+                                       if err := p.consumeOptionalSeparator(); err != nil {
+                                               return err
+                                       }
+                               case "value":
+                                       if err := p.checkForColon(props.MapValProp, dst.Type().Elem()); err != nil {
+                                               return err
+                                       }
+                                       if err := p.readAny(val, props.MapValProp); err != nil {
+                                               return err
+                                       }
+                                       if err := p.consumeOptionalSeparator(); err != nil {
+                                               return err
+                                       }
+                               default:
+                                       p.back()
+                                       return p.errorf(`expected "key", "value", or %q, found %q`, terminator, tok.value)
+                               }
+                       }
+
+                       dst.SetMapIndex(key, val)
+                       continue
+               }
+
+               // Check that it's not already set if it's not a repeated field.
+               if !props.Repeated && fieldSet[name] {
+                       return p.errorf("non-repeated field %q was repeated", name)
+               }
+
+               if err := p.checkForColon(props, dst.Type()); err != nil {
+                       return err
+               }
+
+               // Parse into the field.
+               fieldSet[name] = true
+               if err := p.readAny(dst, props); err != nil {
+                       if _, ok := err.(*RequiredNotSetError); !ok {
+                               return err
+                       }
+                       reqFieldErr = err
+               }
+               if props.Required {
+                       reqCount--
+               }
+
+               if err := p.consumeOptionalSeparator(); err != nil {
+                       return err
+               }
+
+       }
+
+       if reqCount > 0 {
+               return p.missingRequiredFieldError(sv)
+       }
+       return reqFieldErr
+}
+
+// consumeExtName consumes extension name or expanded Any type URL and the
+// following ']'. It returns the name or URL consumed.
+func (p *textParser) consumeExtName() (string, error) {
+       tok := p.next()
+       if tok.err != nil {
+               return "", tok.err
+       }
+
+       // If extension name or type url is quoted, it's a single token.
+       if len(tok.value) > 2 && isQuote(tok.value[0]) && tok.value[len(tok.value)-1] == tok.value[0] {
+               name, err := unquoteC(tok.value[1:len(tok.value)-1], rune(tok.value[0]))
+               if err != nil {
+                       return "", err
+               }
+               return name, p.consumeToken("]")
+       }
+
+       // Consume everything up to "]"
+       var parts []string
+       for tok.value != "]" {
+               parts = append(parts, tok.value)
+               tok = p.next()
+               if tok.err != nil {
+                       return "", p.errorf("unrecognized type_url or extension name: %s", tok.err)
+               }
+               if p.done && tok.value != "]" {
+                       return "", p.errorf("unclosed type_url or extension name")
+               }
+       }
+       return strings.Join(parts, ""), nil
+}
+
+// consumeOptionalSeparator consumes an optional semicolon or comma.
+// It is used in readStruct to provide backward compatibility.
+func (p *textParser) consumeOptionalSeparator() error {
+       tok := p.next()
+       if tok.err != nil {
+               return tok.err
+       }
+       if tok.value != ";" && tok.value != "," {
+               p.back()
+       }
+       return nil
+}
+
+func (p *textParser) readAny(v reflect.Value, props *Properties) error {
+       tok := p.next()
+       if tok.err != nil {
+               return tok.err
+       }
+       if tok.value == "" {
+               return p.errorf("unexpected EOF")
+       }
+       if len(props.CustomType) > 0 {
+               if props.Repeated {
+                       t := reflect.TypeOf(v.Interface())
+                       if t.Kind() == reflect.Slice {
+                               tc := reflect.TypeOf(new(Marshaler))
+                               ok := t.Elem().Implements(tc.Elem())
+                               if ok {
+                                       fv := v
+                                       flen := fv.Len()
+                                       if flen == fv.Cap() {
+                                               nav := reflect.MakeSlice(v.Type(), flen, 2*flen+1)
+                                               reflect.Copy(nav, fv)
+                                               fv.Set(nav)
+                                       }
+                                       fv.SetLen(flen + 1)
+
+                                       // Read one.
+                                       p.back()
+                                       return p.readAny(fv.Index(flen), props)
+                               }
+                       }
+               }
+               if reflect.TypeOf(v.Interface()).Kind() == reflect.Ptr {
+                       custom := reflect.New(props.ctype.Elem()).Interface().(Unmarshaler)
+                       err := custom.Unmarshal([]byte(tok.unquoted))
+                       if err != nil {
+                               return p.errorf("%v %v: %v", err, v.Type(), tok.value)
+                       }
+                       v.Set(reflect.ValueOf(custom))
+               } else {
+                       custom := reflect.New(reflect.TypeOf(v.Interface())).Interface().(Unmarshaler)
+                       err := custom.Unmarshal([]byte(tok.unquoted))
+                       if err != nil {
+                               return p.errorf("%v %v: %v", err, v.Type(), tok.value)
+                       }
+                       v.Set(reflect.Indirect(reflect.ValueOf(custom)))
+               }
+               return nil
+       }
+       if props.StdTime {
+               fv := v
+               p.back()
+               props.StdTime = false
+               tproto := &timestamp{}
+               err := p.readAny(reflect.ValueOf(tproto).Elem(), props)
+               props.StdTime = true
+               if err != nil {
+                       return err
+               }
+               tim, err := timestampFromProto(tproto)
+               if err != nil {
+                       return err
+               }
+               if props.Repeated {
+                       t := reflect.TypeOf(v.Interface())
+                       if t.Kind() == reflect.Slice {
+                               if t.Elem().Kind() == reflect.Ptr {
+                                       ts := fv.Interface().([]*time.Time)
+                                       ts = append(ts, &tim)
+                                       fv.Set(reflect.ValueOf(ts))
+                                       return nil
+                               } else {
+                                       ts := fv.Interface().([]time.Time)
+                                       ts = append(ts, tim)
+                                       fv.Set(reflect.ValueOf(ts))
+                                       return nil
+                               }
+                       }
+               }
+               if reflect.TypeOf(v.Interface()).Kind() == reflect.Ptr {
+                       v.Set(reflect.ValueOf(&tim))
+               } else {
+                       v.Set(reflect.Indirect(reflect.ValueOf(&tim)))
+               }
+               return nil
+       }
+       if props.StdDuration {
+               fv := v
+               p.back()
+               props.StdDuration = false
+               dproto := &duration{}
+               err := p.readAny(reflect.ValueOf(dproto).Elem(), props)
+               props.StdDuration = true
+               if err != nil {
+                       return err
+               }
+               dur, err := durationFromProto(dproto)
+               if err != nil {
+                       return err
+               }
+               if props.Repeated {
+                       t := reflect.TypeOf(v.Interface())
+                       if t.Kind() == reflect.Slice {
+                               if t.Elem().Kind() == reflect.Ptr {
+                                       ds := fv.Interface().([]*time.Duration)
+                                       ds = append(ds, &dur)
+                                       fv.Set(reflect.ValueOf(ds))
+                                       return nil
+                               } else {
+                                       ds := fv.Interface().([]time.Duration)
+                                       ds = append(ds, dur)
+                                       fv.Set(reflect.ValueOf(ds))
+                                       return nil
+                               }
+                       }
+               }
+               if reflect.TypeOf(v.Interface()).Kind() == reflect.Ptr {
+                       v.Set(reflect.ValueOf(&dur))
+               } else {
+                       v.Set(reflect.Indirect(reflect.ValueOf(&dur)))
+               }
+               return nil
+       }
+       switch fv := v; fv.Kind() {
+       case reflect.Slice:
+               at := v.Type()
+               if at.Elem().Kind() == reflect.Uint8 {
+                       // Special case for []byte
+                       if tok.value[0] != '"' && tok.value[0] != '\'' {
+                               // Deliberately written out here, as the error after
+                               // this switch statement would write "invalid []byte: ...",
+                               // which is not as user-friendly.
+                               return p.errorf("invalid string: %v", tok.value)
+                       }
+                       bytes := []byte(tok.unquoted)
+                       fv.Set(reflect.ValueOf(bytes))
+                       return nil
+               }
+               // Repeated field.
+               if tok.value == "[" {
+                       // Repeated field with list notation, like [1,2,3].
+                       for {
+                               fv.Set(reflect.Append(fv, reflect.New(at.Elem()).Elem()))
+                               err := p.readAny(fv.Index(fv.Len()-1), props)
+                               if err != nil {
+                                       return err
+                               }
+                               ntok := p.next()
+                               if ntok.err != nil {
+                                       return ntok.err
+                               }
+                               if ntok.value == "]" {
+                                       break
+                               }
+                               if ntok.value != "," {
+                                       return p.errorf("Expected ']' or ',' found %q", ntok.value)
+                               }
+                       }
+                       return nil
+               }
+               // One value of the repeated field.
+               p.back()
+               fv.Set(reflect.Append(fv, reflect.New(at.Elem()).Elem()))
+               return p.readAny(fv.Index(fv.Len()-1), props)
+       case reflect.Bool:
+               // true/1/t/True or false/f/0/False.
+               switch tok.value {
+               case "true", "1", "t", "True":
+                       fv.SetBool(true)
+                       return nil
+               case "false", "0", "f", "False":
+                       fv.SetBool(false)
+                       return nil
+               }
+       case reflect.Float32, reflect.Float64:
+               v := tok.value
+               // Ignore 'f' for compatibility with output generated by C++, but don't
+               // remove 'f' when the value is "-inf" or "inf".
+               if strings.HasSuffix(v, "f") && tok.value != "-inf" && tok.value != "inf" {
+                       v = v[:len(v)-1]
+               }
+               if f, err := strconv.ParseFloat(v, fv.Type().Bits()); err == nil {
+                       fv.SetFloat(f)
+                       return nil
+               }
+       case reflect.Int8:
+               if x, err := strconv.ParseInt(tok.value, 0, 8); err == nil {
+                       fv.SetInt(x)
+                       return nil
+               }
+       case reflect.Int16:
+               if x, err := strconv.ParseInt(tok.value, 0, 16); err == nil {
+                       fv.SetInt(x)
+                       return nil
+               }
+       case reflect.Int32:
+               if x, err := strconv.ParseInt(tok.value, 0, 32); err == nil {
+                       fv.SetInt(x)
+                       return nil
+               }
+
+               if len(props.Enum) == 0 {
+                       break
+               }
+               m, ok := enumValueMaps[props.Enum]
+               if !ok {
+                       break
+               }
+               x, ok := m[tok.value]
+               if !ok {
+                       break
+               }
+               fv.SetInt(int64(x))
+               return nil
+       case reflect.Int64:
+               if x, err := strconv.ParseInt(tok.value, 0, 64); err == nil {
+                       fv.SetInt(x)
+                       return nil
+               }
+
+       case reflect.Ptr:
+               // A basic field (indirected through pointer), or a repeated message/group
+               p.back()
+               fv.Set(reflect.New(fv.Type().Elem()))
+               return p.readAny(fv.Elem(), props)
+       case reflect.String:
+               if tok.value[0] == '"' || tok.value[0] == '\'' {
+                       fv.SetString(tok.unquoted)
+                       return nil
+               }
+       case reflect.Struct:
+               var terminator string
+               switch tok.value {
+               case "{":
+                       terminator = "}"
+               case "<":
+                       terminator = ">"
+               default:
+                       return p.errorf("expected '{' or '<', found %q", tok.value)
+               }
+               // TODO: Handle nested messages which implement encoding.TextUnmarshaler.
+               return p.readStruct(fv, terminator)
+       case reflect.Uint8:
+               if x, err := strconv.ParseUint(tok.value, 0, 8); err == nil {
+                       fv.SetUint(x)
+                       return nil
+               }
+       case reflect.Uint16:
+               if x, err := strconv.ParseUint(tok.value, 0, 16); err == nil {
+                       fv.SetUint(x)
+                       return nil
+               }
+       case reflect.Uint32:
+               if x, err := strconv.ParseUint(tok.value, 0, 32); err == nil {
+                       fv.SetUint(uint64(x))
+                       return nil
+               }
+       case reflect.Uint64:
+               if x, err := strconv.ParseUint(tok.value, 0, 64); err == nil {
+                       fv.SetUint(x)
+                       return nil
+               }
+       }
+       return p.errorf("invalid %v: %v", v.Type(), tok.value)
+}
+
+// UnmarshalText reads a protocol buffer in Text format. UnmarshalText resets pb
+// before starting to unmarshal, so any existing data in pb is always removed.
+// If a required field is not set and no other error occurs,
+// UnmarshalText returns *RequiredNotSetError.
+func UnmarshalText(s string, pb Message) error {
+       if um, ok := pb.(encoding.TextUnmarshaler); ok {
+               return um.UnmarshalText([]byte(s))
+       }
+       pb.Reset()
+       v := reflect.ValueOf(pb)
+       return newTextParser(s).readStruct(v.Elem(), "")
+}

diff --git a/vendor/github.com/gogo/protobuf/proto/text_parser_test.go b/vendor/github.com/gogo/protobuf/proto/text_parser_test.go
new file mode 100644 (file)
index 0000000..ff235cf
--- /dev/null
+++ b/vendor/github.com/gogo/protobuf/proto/text_parser_test.go
@@ -0,0 +1,706 @@
+// Go support for Protocol Buffers - Google's data interchange format
+//
+// Copyright 2010 The Go Authors.  All rights reserved.
+// https://github.com/golang/protobuf
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//     * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//     * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//     * Neither the name of Google Inc. nor the names of its
+// contributors may be used to endorse or promote products derived from
+// this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+package proto_test
+
+import (
+       "fmt"
+       "math"
+       "testing"
+
+       . "github.com/gogo/protobuf/proto"
+       proto3pb "github.com/gogo/protobuf/proto/proto3_proto"
+       . "github.com/gogo/protobuf/proto/test_proto"
+)
+
+type UnmarshalTextTest struct {
+       in  string
+       err string // if "", no error expected
+       out *MyMessage
+}
+
+func buildExtStructTest(text string) UnmarshalTextTest {
+       msg := &MyMessage{
+               Count: Int32(42),
+       }
+       SetExtension(msg, E_Ext_More, &Ext{
+               Data: String("Hello, world!"),
+       })
+       return UnmarshalTextTest{in: text, out: msg}
+}
+
+func buildExtDataTest(text string) UnmarshalTextTest {
+       msg := &MyMessage{
+               Count: Int32(42),
+       }
+       SetExtension(msg, E_Ext_Text, String("Hello, world!"))
+       SetExtension(msg, E_Ext_Number, Int32(1729))
+       return UnmarshalTextTest{in: text, out: msg}
+}
+
+func buildExtRepStringTest(text string) UnmarshalTextTest {
+       msg := &MyMessage{
+               Count: Int32(42),
+       }
+       if err := SetExtension(msg, E_Greeting, []string{"bula", "hola"}); err != nil {
+               panic(err)
+       }
+       return UnmarshalTextTest{in: text, out: msg}
+}
+
+var unMarshalTextTests = []UnmarshalTextTest{
+       // Basic
+       {
+               in: " count:42\n  name:\"Dave\" ",
+               out: &MyMessage{
+                       Count: Int32(42),
+                       Name:  String("Dave"),
+               },
+       },
+
+       // Empty quoted string
+       {
+               in: `count:42 name:""`,
+               out: &MyMessage{
+                       Count: Int32(42),
+                       Name:  String(""),
+               },
+       },
+
+       // Quoted string concatenation with double quotes
+       {
+               in: `count:42 name: "My name is "` + "\n" + `"elsewhere"`,
+               out: &MyMessage{
+                       Count: Int32(42),
+                       Name:  String("My name is elsewhere"),
+               },
+       },
+
+       // Quoted string concatenation with single quotes
+       {
+               in: "count:42 name: 'My name is '\n'elsewhere'",
+               out: &MyMessage{
+                       Count: Int32(42),
+                       Name:  String("My name is elsewhere"),
+               },
+       },
+
+       // Quoted string concatenations with mixed quotes
+       {
+               in: "count:42 name: 'My name is '\n\"elsewhere\"",
+               out: &MyMessage{
+                       Count: Int32(42),
+                       Name:  String("My name is elsewhere"),
+               },
+       },
+       {
+               in: "count:42 name: \"My name is \"\n'elsewhere'",
+               out: &MyMessage{
+                       Count: Int32(42),
+                       Name:  String("My name is elsewhere"),
+               },
+       },
+
+       // Quoted string with escaped apostrophe
+       {
+               in: `count:42 name: "HOLIDAY - New Year\'s Day"`,
+               out: &MyMessage{
+                       Count: Int32(42),
+                       Name:  String("HOLIDAY - New Year's Day"),
+               },
+       },
+
+       // Quoted string with single quote
+       {
+               in: `count:42 name: 'Roger "The Ramster" Ramjet'`,
+               out: &MyMessage{
+                       Count: Int32(42),
+                       Name:  String(`Roger "The Ramster" Ramjet`),
+               },
+       },
+
+       // Quoted string with all the accepted special characters from the C++ test
+       {
+               in: `count:42 name: ` + "\"\\\"A string with \\' characters \\n and \\r newlines and \\t tabs and \\001 slashes \\\\ and  multiple   spaces\"",
+               out: &MyMessage{
+                       Count: Int32(42),
+                       Name:  String("\"A string with ' characters \n and \r newlines and \t tabs and \001 slashes \\ and  multiple   spaces"),
+               },
+       },
+
+       // Quoted string with quoted backslash
+       {
+               in: `count:42 name: "\\'xyz"`,
+               out: &MyMessage{
+                       Count: Int32(42),
+                       Name:  String(`\'xyz`),
+               },
+       },
+
+       // Quoted string with UTF-8 bytes.
+       {
+               in: "count:42 name: '\303\277\302\201\x00\xAB\xCD\xEF'",
+               out: &MyMessage{
+                       Count: Int32(42),
+                       Name:  String("\303\277\302\201\x00\xAB\xCD\xEF"),
+               },
+       },
+
+       // Quoted string with unicode escapes.
+       {
+               in: `count: 42 name: "\u0047\U00000047\uffff\U0010ffff"`,
+               out: &MyMessage{
+                       Count: Int32(42),
+                       Name:  String("GG\uffff\U0010ffff"),
+               },
+       },
+
+       // Bad quoted string
+       {
+               in:  `inner: < host: "\0" >` + "\n",
+               err: `line 1.15: invalid quoted string "\0": \0 requires 2 following digits`,
+       },
+
+       // Bad \u escape
+       {
+               in:  `count: 42 name: "\u000"`,
+               err: `line 1.16: invalid quoted string "\u000": \u requires 4 following digits`,
+       },
+
+       // Bad \U escape
+       {
+               in:  `count: 42 name: "\U0000000"`,
+               err: `line 1.16: invalid quoted string "\U0000000": \U requires 8 following digits`,
+       },
+
+       // Bad \U escape
+       {
+               in:  `count: 42 name: "\xxx"`,
+               err: `line 1.16: invalid quoted string "\xxx": \xxx contains non-hexadecimal digits`,
+       },
+
+       // Number too large for int64
+       {
+               in:  "count: 1 others { key: 123456789012345678901 }",
+               err: "line 1.23: invalid int64: 123456789012345678901",
+       },
+
+       // Number too large for int32
+       {
+               in:  "count: 1234567890123",
+               err: "line 1.7: invalid int32: 1234567890123",
+       },
+
+       // Number in hexadecimal
+       {
+               in: "count: 0x2beef",
+               out: &MyMessage{
+                       Count: Int32(0x2beef),
+               },
+       },
+
+       // Number in octal
+       {
+               in: "count: 024601",
+               out: &MyMessage{
+                       Count: Int32(024601),
+               },
+       },
+
+       // Floating point number with "f" suffix
+       {
+               in: "count: 4 others:< weight: 17.0f >",
+               out: &MyMessage{
+                       Count: Int32(4),
+                       Others: []*OtherMessage{
+                               {
+                                       Weight: Float32(17),
+                               },
+                       },
+               },
+       },
+
+       // Floating point positive infinity
+       {
+               in: "count: 4 bigfloat: inf",
+               out: &MyMessage{
+                       Count:    Int32(4),
+                       Bigfloat: Float64(math.Inf(1)),
+               },
+       },
+
+       // Floating point negative infinity
+       {
+               in: "count: 4 bigfloat: -inf",
+               out: &MyMessage{
+                       Count:    Int32(4),
+                       Bigfloat: Float64(math.Inf(-1)),
+               },
+       },
+
+       // Number too large for float32
+       {
+               in:  "others:< weight: 12345678901234567890123456789012345678901234567890 >",
+               err: "line 1.17: invalid float32: 12345678901234567890123456789012345678901234567890",
+       },
+
+       // Number posing as a quoted string
+       {
+               in:  `inner: < host: 12 >` + "\n",
+               err: `line 1.15: invalid string: 12`,
+       },
+
+       // Quoted string posing as int32
+       {
+               in:  `count: "12"`,
+               err: `line 1.7: invalid int32: "12"`,
+       },
+
+       // Quoted string posing a float32
+       {
+               in:  `others:< weight: "17.4" >`,
+               err: `line 1.17: invalid float32: "17.4"`,
+       },
+
+       // unclosed bracket doesn't cause infinite loop
+       {
+               in:  `[`,
+               err: `line 1.0: unclosed type_url or extension name`,
+       },
+
+       // Enum
+       {
+               in: `count:42 bikeshed: BLUE`,
+               out: &MyMessage{
+                       Count:    Int32(42),
+                       Bikeshed: MyMessage_BLUE.Enum(),
+               },
+       },
+
+       // Repeated field
+       {
+               in: `count:42 pet: "horsey" pet:"bunny"`,
+               out: &MyMessage{
+                       Count: Int32(42),
+                       Pet:   []string{"horsey", "bunny"},
+               },
+       },
+
+       // Repeated field with list notation
+       {
+               in: `count:42 pet: ["horsey", "bunny"]`,
+               out: &MyMessage{
+                       Count: Int32(42),
+                       Pet:   []string{"horsey", "bunny"},
+               },
+       },
+
+       // Repeated message with/without colon and <>/{}
+       {
+               in: `count:42 others:{} others{} others:<> others:{}`,
+               out: &MyMessage{
+                       Count: Int32(42),
+                       Others: []*OtherMessage{
+                               {},
+                               {},
+                               {},
+                               {},
+                       },
+               },
+       },
+
+       // Missing colon for inner message
+       {
+               in: `count:42 inner < host: "cauchy.syd" >`,
+               out: &MyMessage{
+                       Count: Int32(42),
+                       Inner: &InnerMessage{
+                               Host: String("cauchy.syd"),
+                       },
+               },
+       },
+
+       // Missing colon for string field
+       {
+               in:  `name "Dave"`,
+               err: `line 1.5: expected ':', found "\"Dave\""`,
+       },
+
+       // Missing colon for int32 field
+       {
+               in:  `count 42`,
+               err: `line 1.6: expected ':', found "42"`,
+       },
+
+       // Missing required field
+       {
+               in:  `name: "Pawel"`,
+               err: fmt.Sprintf(`proto: required field "%T.count" not set`, MyMessage{}),
+               out: &MyMessage{
+                       Name: String("Pawel"),
+               },
+       },
+
+       // Missing required field in a required submessage
+       {
+               in:  `count: 42 we_must_go_deeper < leo_finally_won_an_oscar <> >`,
+               err: fmt.Sprintf(`proto: required field "%T.host" not set`, InnerMessage{}),
+               out: &MyMessage{
+                       Count:          Int32(42),
+                       WeMustGoDeeper: &RequiredInnerMessage{LeoFinallyWonAnOscar: &InnerMessage{}},
+               },
+       },
+
+       // Repeated non-repeated field
+       {
+               in:  `name: "Rob" name: "Russ"`,
+               err: `line 1.12: non-repeated field "name" was repeated`,
+       },
+
+       // Group
+       {
+               in: `count: 17 SomeGroup { group_field: 12 }`,
+               out: &MyMessage{
+                       Count: Int32(17),
+                       Somegroup: &MyMessage_SomeGroup{
+                               GroupField: Int32(12),
+                       },
+               },
+       },
+
+       // Semicolon between fields
+       {
+               in: `count:3;name:"Calvin"`,
+               out: &MyMessage{
+                       Count: Int32(3),
+                       Name:  String("Calvin"),
+               },
+       },
+       // Comma between fields
+       {
+               in: `count:4,name:"Ezekiel"`,
+               out: &MyMessage{
+                       Count: Int32(4),
+                       Name:  String("Ezekiel"),
+               },
+       },
+
+       // Boolean false
+       {
+               in: `count:42 inner { host: "example.com" connected: false }`,
+               out: &MyMessage{
+                       Count: Int32(42),
+                       Inner: &InnerMessage{
+                               Host:      String("example.com"),
+                               Connected: Bool(false),
+                       },
+               },
+       },
+       // Boolean true
+       {
+               in: `count:42 inner { host: "example.com" connected: true }`,
+               out: &MyMessage{
+                       Count: Int32(42),
+                       Inner: &InnerMessage{
+                               Host:      String("example.com"),
+                               Connected: Bool(true),
+                       },
+               },
+       },
+       // Boolean 0
+       {
+               in: `count:42 inner { host: "example.com" connected: 0 }`,
+               out: &MyMessage{
+                       Count: Int32(42),
+                       Inner: &InnerMessage{
+                               Host:      String("example.com"),
+                               Connected: Bool(false),
+                       },
+               },
+       },
+       // Boolean 1
+       {
+               in: `count:42 inner { host: "example.com" connected: 1 }`,
+               out: &MyMessage{
+                       Count: Int32(42),
+                       Inner: &InnerMessage{
+                               Host:      String("example.com"),
+                               Connected: Bool(true),
+                       },
+               },
+       },
+       // Boolean f
+       {
+               in: `count:42 inner { host: "example.com" connected: f }`,
+               out: &MyMessage{
+                       Count: Int32(42),
+                       Inner: &InnerMessage{
+                               Host:      String("example.com"),
+                               Connected: Bool(false),
+                       },
+               },
+       },
+       // Boolean t
+       {
+               in: `count:42 inner { host: "example.com" connected: t }`,
+               out: &MyMessage{
+                       Count: Int32(42),
+                       Inner: &InnerMessage{
+                               Host:      String("example.com"),
+                               Connected: Bool(true),
+                       },
+               },
+       },
+       // Boolean False
+       {
+               in: `count:42 inner { host: "example.com" connected: False }`,
+               out: &MyMessage{
+                       Count: Int32(42),
+                       Inner: &InnerMessage{
+                               Host:      String("example.com"),
+                               Connected: Bool(false),
+                       },
+               },
+       },
+       // Boolean True
+       {
+               in: `count:42 inner { host: "example.com" connected: True }`,
+               out: &MyMessage{
+                       Count: Int32(42),
+                       Inner: &InnerMessage{
+                               Host:      String("example.com"),
+                               Connected: Bool(true),
+                       },
+               },
+       },
+
+       // Extension
+       buildExtStructTest(`count: 42 [test_proto.Ext.more]:<data:"Hello, world!" >`),
+       buildExtStructTest(`count: 42 [test_proto.Ext.more] {data:"Hello, world!"}`),
+       buildExtDataTest(`count: 42 [test_proto.Ext.text]:"Hello, world!" [test_proto.Ext.number]:1729`),
+       buildExtRepStringTest(`count: 42 [test_proto.greeting]:"bula" [test_proto.greeting]:"hola"`),
+
+       // Big all-in-one
+       {
+               in: "count:42  # Meaning\n" +
+                       `name:"Dave" ` +
+                       `quote:"\"I didn't want to go.\"" ` +
+                       `pet:"bunny" ` +
+                       `pet:"kitty" ` +
+                       `pet:"horsey" ` +
+                       `inner:<` +
+                       `  host:"footrest.syd" ` +
+                       `  port:7001 ` +
+                       `  connected:true ` +
+                       `> ` +
+                       `others:<` +
+                       `  key:3735928559 ` +
+                       `  value:"\x01A\a\f" ` +
+                       `> ` +
+                       `others:<` +
+                       "  weight:58.9  # Atomic weight of Co\n" +
+                       `  inner:<` +
+                       `    host:"lesha.mtv" ` +
+                       `    port:8002 ` +
+                       `  >` +
+                       `>`,
+               out: &MyMessage{
+                       Count: Int32(42),
+                       Name:  String("Dave"),
+                       Quote: String(`"I didn't want to go."`),
+                       Pet:   []string{"bunny", "kitty", "horsey"},
+                       Inner: &InnerMessage{
+                               Host:      String("footrest.syd"),
+                               Port:      Int32(7001),
+                               Connected: Bool(true),
+                       },
+                       Others: []*OtherMessage{
+                               {
+                                       Key:   Int64(3735928559),
+                                       Value: []byte{0x1, 'A', '\a', '\f'},
+                               },
+                               {
+                                       Weight: Float32(58.9),
+                                       Inner: &InnerMessage{
+                                               Host: String("lesha.mtv"),
+                                               Port: Int32(8002),
+                                       },
+                               },
+                       },
+               },
+       },
+}
+
+func TestUnmarshalText(t *testing.T) {
+       for i, test := range unMarshalTextTests {
+               pb := new(MyMessage)
+               err := UnmarshalText(test.in, pb)
+               if test.err == "" {
+                       // We don't expect failure.
+                       if err != nil {
+                               t.Errorf("Test %d: Unexpected error: %v", i, err)
+                       } else if !Equal(pb, test.out) {
+                               t.Errorf("Test %d: Incorrect populated \nHave: %v\nWant: %v",
+                                       i, pb, test.out)
+                       }
+               } else {
+                       // We do expect failure.
+                       if err == nil {
+                               t.Errorf("Test %d: Didn't get expected error: %v", i, test.err)
+                       } else if err.Error() != test.err {
+                               t.Errorf("Test %d: Incorrect error.\nHave: %v\nWant: %v",
+                                       i, err.Error(), test.err)
+                       } else if _, ok := err.(*RequiredNotSetError); ok && test.out != nil && !Equal(pb, test.out) {
+                               t.Errorf("Test %d: Incorrect populated \nHave: %v\nWant: %v",
+                                       i, pb, test.out)
+                       }
+               }
+       }
+}
+
+func TestUnmarshalTextCustomMessage(t *testing.T) {
+       msg := &textMessage{}
+       if err := UnmarshalText("custom", msg); err != nil {
+               t.Errorf("Unexpected error from custom unmarshal: %v", err)
+       }
+       if UnmarshalText("not custom", msg) == nil {
+               t.Errorf("Didn't get expected error from custom unmarshal")
+       }
+}
+
+// Regression test; this caused a panic.
+func TestRepeatedEnum(t *testing.T) {
+       pb := new(RepeatedEnum)
+       if err := UnmarshalText("color: RED", pb); err != nil {
+               t.Fatal(err)
+       }
+       exp := &RepeatedEnum{
+               Color: []RepeatedEnum_Color{RepeatedEnum_RED},
+       }
+       if !Equal(pb, exp) {
+               t.Errorf("Incorrect populated \nHave: %v\nWant: %v", pb, exp)
+       }
+}
+
+func TestProto3TextParsing(t *testing.T) {
+       m := new(proto3pb.Message)
+       const in = `name: "Wallace" true_scotsman: true`
+       want := &proto3pb.Message{
+               Name:         "Wallace",
+               TrueScotsman: true,
+       }
+       if err := UnmarshalText(in, m); err != nil {
+               t.Fatal(err)
+       }
+       if !Equal(m, want) {
+               t.Errorf("\n got %v\nwant %v", m, want)
+       }
+}
+
+func TestMapParsing(t *testing.T) {
+       m := new(MessageWithMap)
+       const in = `name_mapping:<key:1234 value:"Feist"> name_mapping:<key:1 value:"Beatles">` +
+               `msg_mapping:<key:-4, value:<f: 2.0>,>` + // separating commas are okay
+               `msg_mapping<key:-2 value<f: 4.0>>` + // no colon after "value"
+               `msg_mapping:<value:<f: 5.0>>` + // omitted key
+               `msg_mapping:<key:1>` + // omitted value
+               `byte_mapping:<key:true value:"so be it">` +
+               `byte_mapping:<>` // omitted key and value
+       want := &MessageWithMap{
+               NameMapping: map[int32]string{
+                       1:    "Beatles",
+                       1234: "Feist",
+               },
+               MsgMapping: map[int64]*FloatingPoint{
+                       -4: {F: Float64(2.0)},
+                       -2: {F: Float64(4.0)},
+                       0:  {F: Float64(5.0)},
+                       1:  nil,
+               },
+               ByteMapping: map[bool][]byte{
+                       false: nil,
+                       true:  []byte("so be it"),
+               },
+       }
+       if err := UnmarshalText(in, m); err != nil {
+               t.Fatal(err)
+       }
+       if !Equal(m, want) {
+               t.Errorf("\n got %v\nwant %v", m, want)
+       }
+}
+
+func TestOneofParsing(t *testing.T) {
+       const in = `name:"Shrek"`
+       m := new(Communique)
+       want := &Communique{Union: &Communique_Name{Name: "Shrek"}}
+       if err := UnmarshalText(in, m); err != nil {
+               t.Fatal(err)
+       }
+       if !Equal(m, want) {
+               t.Errorf("\n got %v\nwant %v", m, want)
+       }
+
+       const inOverwrite = `name:"Shrek" number:42`
+       m = new(Communique)
+       testErr := "line 1.13: field 'number' would overwrite already parsed oneof 'Union'"
+       if err := UnmarshalText(inOverwrite, m); err == nil {
+               t.Errorf("TestOneofParsing: Didn't get expected error: %v", testErr)
+       } else if err.Error() != testErr {
+               t.Errorf("TestOneofParsing: Incorrect error.\nHave: %v\nWant: %v",
+                       err.Error(), testErr)
+       }
+
+}
+
+var benchInput string
+
+func init() {
+       benchInput = "count: 4\n"
+       for i := 0; i < 1000; i++ {
+               benchInput += "pet: \"fido\"\n"
+       }
+
+       // Check it is valid input.
+       pb := new(MyMessage)
+       err := UnmarshalText(benchInput, pb)
+       if err != nil {
+               panic("Bad benchmark input: " + err.Error())
+       }
+}
+
+func BenchmarkUnmarshalText(b *testing.B) {
+       pb := new(MyMessage)
+       for i := 0; i < b.N; i++ {
+               UnmarshalText(benchInput, pb)
+       }
+       b.SetBytes(int64(len(benchInput)))
+}

diff --git a/vendor/github.com/gogo/protobuf/proto/text_test.go b/vendor/github.com/gogo/protobuf/proto/text_test.go
new file mode 100644 (file)
index 0000000..d7c6a8d
--- /dev/null
+++ b/vendor/github.com/gogo/protobuf/proto/text_test.go
@@ -0,0 +1,518 @@
+// Go support for Protocol Buffers - Google's data interchange format
+//
+// Copyright 2010 The Go Authors.  All rights reserved.
+// https://github.com/golang/protobuf
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//     * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//     * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//     * Neither the name of Google Inc. nor the names of its
+// contributors may be used to endorse or promote products derived from
+// this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+package proto_test
+
+import (
+       "bytes"
+       "errors"
+       "io/ioutil"
+       "math"
+       "strings"
+       "sync"
+       "testing"
+
+       "github.com/gogo/protobuf/proto"
+
+       proto3pb "github.com/gogo/protobuf/proto/proto3_proto"
+       pb "github.com/gogo/protobuf/proto/test_proto"
+       "github.com/gogo/protobuf/types"
+)
+
+// textMessage implements the methods that allow it to marshal and unmarshal
+// itself as text.
+type textMessage struct {
+}
+
+func (*textMessage) MarshalText() ([]byte, error) {
+       return []byte("custom"), nil
+}
+
+func (*textMessage) UnmarshalText(bytes []byte) error {
+       if string(bytes) != "custom" {
+               return errors.New("expected 'custom'")
+       }
+       return nil
+}
+
+func (*textMessage) Reset()         {}
+func (*textMessage) String() string { return "" }
+func (*textMessage) ProtoMessage()  {}
+
+func newTestMessage() *pb.MyMessage {
+       msg := &pb.MyMessage{
+               Count: proto.Int32(42),
+               Name:  proto.String("Dave"),
+               Quote: proto.String(`"I didn't want to go."`),
+               Pet:   []string{"bunny", "kitty", "horsey"},
+               Inner: &pb.InnerMessage{
+                       Host:      proto.String("footrest.syd"),
+                       Port:      proto.Int32(7001),
+                       Connected: proto.Bool(true),
+               },
+               Others: []*pb.OtherMessage{
+                       {
+                               Key:   proto.Int64(0xdeadbeef),
+                               Value: []byte{1, 65, 7, 12},
+                       },
+                       {
+                               Weight: proto.Float32(6.022),
+                               Inner: &pb.InnerMessage{
+                                       Host: proto.String("lesha.mtv"),
+                                       Port: proto.Int32(8002),
+                               },
+                       },
+               },
+               Bikeshed: pb.MyMessage_BLUE.Enum(),
+               Somegroup: &pb.MyMessage_SomeGroup{
+                       GroupField: proto.Int32(8),
+               },
+               // One normally wouldn't do this.
+               // This is an undeclared tag 13, as a varint (wire type 0) with value 4.
+               XXX_unrecognized: []byte{13<<3 | 0, 4},
+       }
+       ext := &pb.Ext{
+               Data: proto.String("Big gobs for big rats"),
+       }
+       if err := proto.SetExtension(msg, pb.E_Ext_More, ext); err != nil {
+               panic(err)
+       }
+       greetings := []string{"adg", "easy", "cow"}
+       if err := proto.SetExtension(msg, pb.E_Greeting, greetings); err != nil {
+               panic(err)
+       }
+
+       // Add an unknown extension. We marshal a pb.Ext, and fake the ID.
+       b, err := proto.Marshal(&pb.Ext{Data: proto.String("3G skiing")})
+       if err != nil {
+               panic(err)
+       }
+       b = append(proto.EncodeVarint(201<<3|proto.WireBytes), b...)
+       proto.SetRawExtension(msg, 201, b)
+
+       // Extensions can be plain fields, too, so let's test that.
+       b = append(proto.EncodeVarint(202<<3|proto.WireVarint), 19)
+       proto.SetRawExtension(msg, 202, b)
+
+       return msg
+}
+
+const text = `count: 42
+name: "Dave"
+quote: "\"I didn't want to go.\""
+pet: "bunny"
+pet: "kitty"
+pet: "horsey"
+inner: <
+  host: "footrest.syd"
+  port: 7001
+  connected: true
+>
+others: <
+  key: 3735928559
+  value: "\001A\007\014"
+>
+others: <
+  weight: 6.022
+  inner: <
+    host: "lesha.mtv"
+    port: 8002
+  >
+>
+bikeshed: BLUE
+SomeGroup {
+  group_field: 8
+}
+/* 2 unknown bytes */
+13: 4
+[test_proto.Ext.more]: <
+  data: "Big gobs for big rats"
+>
+[test_proto.greeting]: "adg"
+[test_proto.greeting]: "easy"
+[test_proto.greeting]: "cow"
+/* 13 unknown bytes */
+201: "\t3G skiing"
+/* 3 unknown bytes */
+202: 19
+`
+
+func TestMarshalText(t *testing.T) {
+       buf := new(bytes.Buffer)
+       if err := proto.MarshalText(buf, newTestMessage()); err != nil {
+               t.Fatalf("proto.MarshalText: %v", err)
+       }
+       s := buf.String()
+       if s != text {
+               t.Errorf("Got:\n===\n%v===\nExpected:\n===\n%v===\n", s, text)
+       }
+}
+
+func TestMarshalTextCustomMessage(t *testing.T) {
+       buf := new(bytes.Buffer)
+       if err := proto.MarshalText(buf, &textMessage{}); err != nil {
+               t.Fatalf("proto.MarshalText: %v", err)
+       }
+       s := buf.String()
+       if s != "custom" {
+               t.Errorf("Got %q, expected %q", s, "custom")
+       }
+}
+func TestMarshalTextNil(t *testing.T) {
+       want := "<nil>"
+       tests := []proto.Message{nil, (*pb.MyMessage)(nil)}
+       for i, test := range tests {
+               buf := new(bytes.Buffer)
+               if err := proto.MarshalText(buf, test); err != nil {
+                       t.Fatal(err)
+               }
+               if got := buf.String(); got != want {
+                       t.Errorf("%d: got %q want %q", i, got, want)
+               }
+       }
+}
+
+func TestMarshalTextUnknownEnum(t *testing.T) {
+       // The Color enum only specifies values 0-2.
+       m := &pb.MyMessage{Bikeshed: pb.MyMessage_Color(3).Enum()}
+       got := m.String()
+       const want = `bikeshed:3 `
+       if got != want {
+               t.Errorf("\n got %q\nwant %q", got, want)
+       }
+}
+
+func TestTextOneof(t *testing.T) {
+       tests := []struct {
+               m    proto.Message
+               want string
+       }{
+               // zero message
+               {&pb.Communique{}, ``},
+               // scalar field
+               {&pb.Communique{Union: &pb.Communique_Number{Number: 4}}, `number:4`},
+               // message field
+               {&pb.Communique{Union: &pb.Communique_Msg{
+                       Msg: &pb.Strings{StringField: proto.String("why hello!")},
+               }}, `msg:<string_field:"why hello!" >`},
+               // bad oneof (should not panic)
+               {&pb.Communique{Union: &pb.Communique_Msg{Msg: nil}}, `msg:/* nil */`},
+       }
+       for _, test := range tests {
+               got := strings.TrimSpace(test.m.String())
+               if got != test.want {
+                       t.Errorf("\n got %s\nwant %s", got, test.want)
+               }
+       }
+}
+
+func BenchmarkMarshalTextBuffered(b *testing.B) {
+       buf := new(bytes.Buffer)
+       m := newTestMessage()
+       for i := 0; i < b.N; i++ {
+               buf.Reset()
+               proto.MarshalText(buf, m)
+       }
+}
+
+func BenchmarkMarshalTextUnbuffered(b *testing.B) {
+       w := ioutil.Discard
+       m := newTestMessage()
+       for i := 0; i < b.N; i++ {
+               proto.MarshalText(w, m)
+       }
+}
+
+func compact(src string) string {
+       // s/[ \n]+/ /g; s/ $//;
+       dst := make([]byte, len(src))
+       space, comment := false, false
+       j := 0
+       for i := 0; i < len(src); i++ {
+               if strings.HasPrefix(src[i:], "/*") {
+                       comment = true
+                       i++
+                       continue
+               }
+               if comment && strings.HasPrefix(src[i:], "*/") {
+                       comment = false
+                       i++
+                       continue
+               }
+               if comment {
+                       continue
+               }
+               c := src[i]
+               if c == ' ' || c == '\n' {
+                       space = true
+                       continue
+               }
+               if j > 0 && (dst[j-1] == ':' || dst[j-1] == '<' || dst[j-1] == '{') {
+                       space = false
+               }
+               if c == '{' {
+                       space = false
+               }
+               if space {
+                       dst[j] = ' '
+                       j++
+                       space = false
+               }
+               dst[j] = c
+               j++
+       }
+       if space {
+               dst[j] = ' '
+               j++
+       }
+       return string(dst[0:j])
+}
+
+var compactText = compact(text)
+
+func TestCompactText(t *testing.T) {
+       s := proto.CompactTextString(newTestMessage())
+       if s != compactText {
+               t.Errorf("Got:\n===\n%v===\nExpected:\n===\n%v\n===\n", s, compactText)
+       }
+}
+
+func TestStringEscaping(t *testing.T) {
+       testCases := []struct {
+               in  *pb.Strings
+               out string
+       }{
+               {
+                       // Test data from C++ test (TextFormatTest.StringEscape).
+                       // Single divergence: we don't escape apostrophes.
+                       &pb.Strings{StringField: proto.String("\"A string with ' characters \n and \r newlines and \t tabs and \001 slashes \\ and  multiple   spaces")},
+                       "string_field: \"\\\"A string with ' characters \\n and \\r newlines and \\t tabs and \\001 slashes \\\\ and  multiple   spaces\"\n",
+               },
+               {
+                       // Test data from the same C++ test.
+                       &pb.Strings{StringField: proto.String("\350\260\267\346\255\214")},
+                       "string_field: \"\\350\\260\\267\\346\\255\\214\"\n",
+               },
+               {
+                       // Some UTF-8.
+                       &pb.Strings{StringField: proto.String("\x00\x01\xff\x81")},
+                       `string_field: "\000\001\377\201"` + "\n",
+               },
+       }
+
+       for i, tc := range testCases {
+               var buf bytes.Buffer
+               if err := proto.MarshalText(&buf, tc.in); err != nil {
+                       t.Errorf("proto.MarsalText: %v", err)
+                       continue
+               }
+               s := buf.String()
+               if s != tc.out {
+                       t.Errorf("#%d: Got:\n%s\nExpected:\n%s\n", i, s, tc.out)
+                       continue
+               }
+
+               // Check round-trip.
+               pbStrings := new(pb.Strings)
+               if err := proto.UnmarshalText(s, pbStrings); err != nil {
+                       t.Errorf("#%d: UnmarshalText: %v", i, err)
+                       continue
+               }
+               if !proto.Equal(pbStrings, tc.in) {
+                       t.Errorf("#%d: Round-trip failed:\nstart: %v\n  end: %v", i, tc.in, pbStrings)
+               }
+       }
+}
+
+// A limitedWriter accepts some output before it fails.
+// This is a proxy for something like a nearly-full or imminently-failing disk,
+// or a network connection that is about to die.
+type limitedWriter struct {
+       b     bytes.Buffer
+       limit int
+}
+
+var outOfSpace = errors.New("proto: insufficient space")
+
+func (w *limitedWriter) Write(p []byte) (n int, err error) {
+       var avail = w.limit - w.b.Len()
+       if avail <= 0 {
+               return 0, outOfSpace
+       }
+       if len(p) <= avail {
+               return w.b.Write(p)
+       }
+       n, _ = w.b.Write(p[:avail])
+       return n, outOfSpace
+}
+
+func TestMarshalTextFailing(t *testing.T) {
+       // Try lots of different sizes to exercise more error code-paths.
+       for lim := 0; lim < len(text); lim++ {
+               buf := new(limitedWriter)
+               buf.limit = lim
+               err := proto.MarshalText(buf, newTestMessage())
+               // We expect a certain error, but also some partial results in the buffer.
+               if err != outOfSpace {
+                       t.Errorf("Got:\n===\n%v===\nExpected:\n===\n%v===\n", err, outOfSpace)
+               }
+               s := buf.b.String()
+               x := text[:buf.limit]
+               if s != x {
+                       t.Errorf("Got:\n===\n%v===\nExpected:\n===\n%v===\n", s, x)
+               }
+       }
+}
+
+func TestFloats(t *testing.T) {
+       tests := []struct {
+               f    float64
+               want string
+       }{
+               {0, "0"},
+               {4.7, "4.7"},
+               {math.Inf(1), "inf"},
+               {math.Inf(-1), "-inf"},
+               {math.NaN(), "nan"},
+       }
+       for _, test := range tests {
+               msg := &pb.FloatingPoint{F: &test.f}
+               got := strings.TrimSpace(msg.String())
+               want := `f:` + test.want
+               if got != want {
+                       t.Errorf("f=%f: got %q, want %q", test.f, got, want)
+               }
+       }
+}
+
+func TestRepeatedNilText(t *testing.T) {
+       m := &pb.MessageList{
+               Message: []*pb.MessageList_Message{
+                       nil,
+                       {
+                               Name: proto.String("Horse"),
+                       },
+                       nil,
+               },
+       }
+       want := `Message <nil>
+Message {
+  name: "Horse"
+}
+Message <nil>
+`
+       if s := proto.MarshalTextString(m); s != want {
+               t.Errorf(" got: %s\nwant: %s", s, want)
+       }
+}
+
+func TestProto3Text(t *testing.T) {
+       tests := []struct {
+               m    proto.Message
+               want string
+       }{
+               // zero message
+               {&proto3pb.Message{}, ``},
+               // zero message except for an empty byte slice
+               {&proto3pb.Message{Data: []byte{}}, ``},
+               // trivial case
+               {&proto3pb.Message{Name: "Rob", HeightInCm: 175}, `name:"Rob" height_in_cm:175`},
+               // empty map
+               {&pb.MessageWithMap{}, ``},
+               // non-empty map; map format is the same as a repeated struct,
+               // and they are sorted by key (numerically for numeric keys).
+               {
+                       &pb.MessageWithMap{NameMapping: map[int32]string{
+                               -1:      "Negatory",
+                               7:       "Lucky",
+                               1234:    "Feist",
+                               6345789: "Otis",
+                       }},
+                       `name_mapping:<key:-1 value:"Negatory" > ` +
+                               `name_mapping:<key:7 value:"Lucky" > ` +
+                               `name_mapping:<key:1234 value:"Feist" > ` +
+                               `name_mapping:<key:6345789 value:"Otis" >`,
+               },
+               // map with nil value; not well-defined, but we shouldn't crash
+               {
+                       &pb.MessageWithMap{MsgMapping: map[int64]*pb.FloatingPoint{7: nil}},
+                       `msg_mapping:<key:7 >`,
+               },
+       }
+       for _, test := range tests {
+               got := strings.TrimSpace(test.m.String())
+               if got != test.want {
+                       t.Errorf("\n got %s\nwant %s", got, test.want)
+               }
+       }
+}
+
+func TestRacyMarshal(t *testing.T) {
+       // This test should be run with the race detector.
+
+       any := &pb.MyMessage{Count: proto.Int32(47), Name: proto.String("David")}
+       proto.SetExtension(any, pb.E_Ext_Text, proto.String("bar"))
+       b, err := proto.Marshal(any)
+       if err != nil {
+               panic(err)
+       }
+       m := &proto3pb.Message{
+               Name:        "David",
+               ResultCount: 47,
+               Anything:    &types.Any{TypeUrl: "type.googleapis.com/" + proto.MessageName(any), Value: b},
+       }
+
+       wantText := proto.MarshalTextString(m)
+       wantBytes, err := proto.Marshal(m)
+       if err != nil {
+               t.Fatalf("proto.Marshal error: %v", err)
+       }
+
+       var wg sync.WaitGroup
+       defer wg.Wait()
+       wg.Add(20)
+       for i := 0; i < 10; i++ {
+               go func() {
+                       defer wg.Done()
+                       got := proto.MarshalTextString(m)
+                       if got != wantText {
+                               t.Errorf("proto.MarshalTextString = %q, want %q", got, wantText)
+                       }
+               }()
+               go func() {
+                       defer wg.Done()
+                       got, err := proto.Marshal(m)
+                       if !bytes.Equal(got, wantBytes) || err != nil {
+                               t.Errorf("proto.Marshal = (%x, %v), want (%x, nil)", got, err, wantBytes)
+                       }
+               }()
+       }
+}

diff --git a/vendor/github.com/gogo/protobuf/proto/timestamp.go b/vendor/github.com/gogo/protobuf/proto/timestamp.go
new file mode 100644 (file)
index 0000000..9324f65
--- /dev/null
+++ b/vendor/github.com/gogo/protobuf/proto/timestamp.go
@@ -0,0 +1,113 @@
+// Go support for Protocol Buffers - Google's data interchange format
+//
+// Copyright 2016 The Go Authors.  All rights reserved.
+// https://github.com/golang/protobuf
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//     * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//     * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//     * Neither the name of Google Inc. nor the names of its
+// contributors may be used to endorse or promote products derived from
+// this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+package proto
+
+// This file implements operations on google.protobuf.Timestamp.
+
+import (
+       "errors"
+       "fmt"
+       "time"
+)
+
+const (
+       // Seconds field of the earliest valid Timestamp.
+       // This is time.Date(1, 1, 1, 0, 0, 0, 0, time.UTC).Unix().
+       minValidSeconds = -62135596800
+       // Seconds field just after the latest valid Timestamp.
+       // This is time.Date(10000, 1, 1, 0, 0, 0, 0, time.UTC).Unix().
+       maxValidSeconds = 253402300800
+)
+
+// validateTimestamp determines whether a Timestamp is valid.
+// A valid timestamp represents a time in the range
+// [0001-01-01, 10000-01-01) and has a Nanos field
+// in the range [0, 1e9).
+//
+// If the Timestamp is valid, validateTimestamp returns nil.
+// Otherwise, it returns an error that describes
+// the problem.
+//
+// Every valid Timestamp can be represented by a time.Time, but the converse is not true.
+func validateTimestamp(ts *timestamp) error {
+       if ts == nil {
+               return errors.New("timestamp: nil Timestamp")
+       }
+       if ts.Seconds < minValidSeconds {
+               return fmt.Errorf("timestamp: %#v before 0001-01-01", ts)
+       }
+       if ts.Seconds >= maxValidSeconds {
+               return fmt.Errorf("timestamp: %#v after 10000-01-01", ts)
+       }
+       if ts.Nanos < 0 || ts.Nanos >= 1e9 {
+               return fmt.Errorf("timestamp: %#v: nanos not in range [0, 1e9)", ts)
+       }
+       return nil
+}
+
+// TimestampFromProto converts a google.protobuf.Timestamp proto to a time.Time.
+// It returns an error if the argument is invalid.
+//
+// Unlike most Go functions, if Timestamp returns an error, the first return value
+// is not the zero time.Time. Instead, it is the value obtained from the
+// time.Unix function when passed the contents of the Timestamp, in the UTC
+// locale. This may or may not be a meaningful time; many invalid Timestamps
+// do map to valid time.Times.
+//
+// A nil Timestamp returns an error. The first return value in that case is
+// undefined.
+func timestampFromProto(ts *timestamp) (time.Time, error) {
+       // Don't return the zero value on error, because corresponds to a valid
+       // timestamp. Instead return whatever time.Unix gives us.
+       var t time.Time
+       if ts == nil {
+               t = time.Unix(0, 0).UTC() // treat nil like the empty Timestamp
+       } else {
+               t = time.Unix(ts.Seconds, int64(ts.Nanos)).UTC()
+       }
+       return t, validateTimestamp(ts)
+}
+
+// TimestampProto converts the time.Time to a google.protobuf.Timestamp proto.
+// It returns an error if the resulting Timestamp is invalid.
+func timestampProto(t time.Time) (*timestamp, error) {
+       seconds := t.Unix()
+       nanos := int32(t.Sub(time.Unix(seconds, 0)))
+       ts := &timestamp{
+               Seconds: seconds,
+               Nanos:   nanos,
+       }
+       if err := validateTimestamp(ts); err != nil {
+               return nil, err
+       }
+       return ts, nil
+}

diff --git a/vendor/github.com/gogo/protobuf/proto/timestamp_gogo.go b/vendor/github.com/gogo/protobuf/proto/timestamp_gogo.go
new file mode 100644 (file)
index 0000000..38439fa
--- /dev/null
+++ b/vendor/github.com/gogo/protobuf/proto/timestamp_gogo.go
@@ -0,0 +1,49 @@
+// Protocol Buffers for Go with Gadgets
+//
+// Copyright (c) 2016, The GoGo Authors. All rights reserved.
+// http://github.com/gogo/protobuf
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//     * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//     * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+package proto
+
+import (
+       "reflect"
+       "time"
+)
+
+var timeType = reflect.TypeOf((*time.Time)(nil)).Elem()
+
+type timestamp struct {
+       Seconds int64 `protobuf:"varint,1,opt,name=seconds,proto3" json:"seconds,omitempty"`
+       Nanos   int32 `protobuf:"varint,2,opt,name=nanos,proto3" json:"nanos,omitempty"`
+}
+
+func (m *timestamp) Reset()       { *m = timestamp{} }
+func (*timestamp) ProtoMessage()  {}
+func (*timestamp) String() string { return "timestamp<string>" }
+
+func init() {
+       RegisterType((*timestamp)(nil), "gogo.protobuf.proto.timestamp")
+}

diff --git a/vendor/github.com/gogo/protobuf/proto/wrappers.go b/vendor/github.com/gogo/protobuf/proto/wrappers.go
new file mode 100644 (file)
index 0000000..b175d1b
--- /dev/null
+++ b/vendor/github.com/gogo/protobuf/proto/wrappers.go
@@ -0,0 +1,1888 @@
+// Protocol Buffers for Go with Gadgets
+//
+// Copyright (c) 2018, The GoGo Authors. All rights reserved.
+// http://github.com/gogo/protobuf
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//     * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//     * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+package proto
+
+import (
+       "io"
+       "reflect"
+)
+
+func makeStdDoubleValueMarshaler(u *marshalInfo) (sizer, marshaler) {
+       return func(ptr pointer, tagsize int) int {
+                       t := ptr.asPointerTo(u.typ).Interface().(*float64)
+                       v := &float64Value{*t}
+                       siz := Size(v)
+                       return tagsize + SizeVarint(uint64(siz)) + siz
+               }, func(b []byte, ptr pointer, wiretag uint64, deterministic bool) ([]byte, error) {
+                       t := ptr.asPointerTo(u.typ).Interface().(*float64)
+                       v := &float64Value{*t}
+                       buf, err := Marshal(v)
+                       if err != nil {
+                               return nil, err
+                       }
+                       b = appendVarint(b, wiretag)
+                       b = appendVarint(b, uint64(len(buf)))
+                       b = append(b, buf...)
+                       return b, nil
+               }
+}
+
+func makeStdDoubleValuePtrMarshaler(u *marshalInfo) (sizer, marshaler) {
+       return func(ptr pointer, tagsize int) int {
+                       if ptr.isNil() {
+                               return 0
+                       }
+                       t := ptr.asPointerTo(reflect.PtrTo(u.typ)).Elem().Interface().(*float64)
+                       v := &float64Value{*t}
+                       siz := Size(v)
+                       return tagsize + SizeVarint(uint64(siz)) + siz
+               }, func(b []byte, ptr pointer, wiretag uint64, deterministic bool) ([]byte, error) {
+                       if ptr.isNil() {
+                               return b, nil
+                       }
+                       t := ptr.asPointerTo(reflect.PtrTo(u.typ)).Elem().Interface().(*float64)
+                       v := &float64Value{*t}
+                       buf, err := Marshal(v)
+                       if err != nil {
+                               return nil, err
+                       }
+                       b = appendVarint(b, wiretag)
+                       b = appendVarint(b, uint64(len(buf)))
+                       b = append(b, buf...)
+                       return b, nil
+               }
+}
+
+func makeStdDoubleValueSliceMarshaler(u *marshalInfo) (sizer, marshaler) {
+       return func(ptr pointer, tagsize int) int {
+                       s := ptr.getSlice(u.typ)
+                       n := 0
+                       for i := 0; i < s.Len(); i++ {
+                               elem := s.Index(i)
+                               t := elem.Interface().(float64)
+                               v := &float64Value{t}
+                               siz := Size(v)
+                               n += siz + SizeVarint(uint64(siz)) + tagsize
+                       }
+                       return n
+               },
+               func(b []byte, ptr pointer, wiretag uint64, deterministic bool) ([]byte, error) {
+                       s := ptr.getSlice(u.typ)
+                       for i := 0; i < s.Len(); i++ {
+                               elem := s.Index(i)
+                               t := elem.Interface().(float64)
+                               v := &float64Value{t}
+                               siz := Size(v)
+                               buf, err := Marshal(v)
+                               if err != nil {
+                                       return nil, err
+                               }
+                               b = appendVarint(b, wiretag)
+                               b = appendVarint(b, uint64(siz))
+                               b = append(b, buf...)
+                       }
+
+                       return b, nil
+               }
+}
+
+func makeStdDoubleValuePtrSliceMarshaler(u *marshalInfo) (sizer, marshaler) {
+       return func(ptr pointer, tagsize int) int {
+                       s := ptr.getSlice(reflect.PtrTo(u.typ))
+                       n := 0
+                       for i := 0; i < s.Len(); i++ {
+                               elem := s.Index(i)
+                               t := elem.Interface().(*float64)
+                               v := &float64Value{*t}
+                               siz := Size(v)
+                               n += siz + SizeVarint(uint64(siz)) + tagsize
+                       }
+                       return n
+               },
+               func(b []byte, ptr pointer, wiretag uint64, deterministic bool) ([]byte, error) {
+                       s := ptr.getSlice(reflect.PtrTo(u.typ))
+                       for i := 0; i < s.Len(); i++ {
+                               elem := s.Index(i)
+                               t := elem.Interface().(*float64)
+                               v := &float64Value{*t}
+                               siz := Size(v)
+                               buf, err := Marshal(v)
+                               if err != nil {
+                                       return nil, err
+                               }
+                               b = appendVarint(b, wiretag)
+                               b = appendVarint(b, uint64(siz))
+                               b = append(b, buf...)
+                       }
+
+                       return b, nil
+               }
+}
+
+func makeStdDoubleValueUnmarshaler(sub *unmarshalInfo, name string) unmarshaler {
+       return func(b []byte, f pointer, w int) ([]byte, error) {
+               if w != WireBytes {
+                       return nil, errInternalBadWireType
+               }
+               x, n := decodeVarint(b)
+               if n == 0 {
+                       return nil, io.ErrUnexpectedEOF
+               }
+               b = b[n:]
+               if x > uint64(len(b)) {
+                       return nil, io.ErrUnexpectedEOF
+               }
+               m := &float64Value{}
+               if err := Unmarshal(b[:x], m); err != nil {
+                       return nil, err
+               }
+               s := f.asPointerTo(sub.typ).Elem()
+               s.Set(reflect.ValueOf(m.Value))
+               return b[x:], nil
+       }
+}
+
+func makeStdDoubleValuePtrUnmarshaler(sub *unmarshalInfo, name string) unmarshaler {
+       return func(b []byte, f pointer, w int) ([]byte, error) {
+               if w != WireBytes {
+                       return nil, errInternalBadWireType
+               }
+               x, n := decodeVarint(b)
+               if n == 0 {
+                       return nil, io.ErrUnexpectedEOF
+               }
+               b = b[n:]
+               if x > uint64(len(b)) {
+                       return nil, io.ErrUnexpectedEOF
+               }
+               m := &float64Value{}
+               if err := Unmarshal(b[:x], m); err != nil {
+                       return nil, err
+               }
+               s := f.asPointerTo(reflect.PtrTo(sub.typ)).Elem()
+               s.Set(reflect.ValueOf(&m.Value))
+               return b[x:], nil
+       }
+}
+
+func makeStdDoubleValuePtrSliceUnmarshaler(sub *unmarshalInfo, name string) unmarshaler {
+       return func(b []byte, f pointer, w int) ([]byte, error) {
+               if w != WireBytes {
+                       return nil, errInternalBadWireType
+               }
+               x, n := decodeVarint(b)
+               if n == 0 {
+                       return nil, io.ErrUnexpectedEOF
+               }
+               b = b[n:]
+               if x > uint64(len(b)) {
+                       return nil, io.ErrUnexpectedEOF
+               }
+               m := &float64Value{}
+               if err := Unmarshal(b[:x], m); err != nil {
+                       return nil, err
+               }
+               slice := f.getSlice(reflect.PtrTo(sub.typ))
+               newSlice := reflect.Append(slice, reflect.ValueOf(&m.Value))
+               slice.Set(newSlice)
+               return b[x:], nil
+       }
+}
+
+func makeStdDoubleValueSliceUnmarshaler(sub *unmarshalInfo, name string) unmarshaler {
+       return func(b []byte, f pointer, w int) ([]byte, error) {
+               if w != WireBytes {
+                       return nil, errInternalBadWireType
+               }
+               x, n := decodeVarint(b)
+               if n == 0 {
+                       return nil, io.ErrUnexpectedEOF
+               }
+               b = b[n:]
+               if x > uint64(len(b)) {
+                       return nil, io.ErrUnexpectedEOF
+               }
+               m := &float64Value{}
+               if err := Unmarshal(b[:x], m); err != nil {
+                       return nil, err
+               }
+               slice := f.getSlice(sub.typ)
+               newSlice := reflect.Append(slice, reflect.ValueOf(m.Value))
+               slice.Set(newSlice)
+               return b[x:], nil
+       }
+}
+
+func makeStdFloatValueMarshaler(u *marshalInfo) (sizer, marshaler) {
+       return func(ptr pointer, tagsize int) int {
+                       t := ptr.asPointerTo(u.typ).Interface().(*float32)
+                       v := &float32Value{*t}
+                       siz := Size(v)
+                       return tagsize + SizeVarint(uint64(siz)) + siz
+               }, func(b []byte, ptr pointer, wiretag uint64, deterministic bool) ([]byte, error) {
+                       t := ptr.asPointerTo(u.typ).Interface().(*float32)
+                       v := &float32Value{*t}
+                       buf, err := Marshal(v)
+                       if err != nil {
+                               return nil, err
+                       }
+                       b = appendVarint(b, wiretag)
+                       b = appendVarint(b, uint64(len(buf)))
+                       b = append(b, buf...)
+                       return b, nil
+               }
+}
+
+func makeStdFloatValuePtrMarshaler(u *marshalInfo) (sizer, marshaler) {
+       return func(ptr pointer, tagsize int) int {
+                       if ptr.isNil() {
+                               return 0
+                       }
+                       t := ptr.asPointerTo(reflect.PtrTo(u.typ)).Elem().Interface().(*float32)
+                       v := &float32Value{*t}
+                       siz := Size(v)
+                       return tagsize + SizeVarint(uint64(siz)) + siz
+               }, func(b []byte, ptr pointer, wiretag uint64, deterministic bool) ([]byte, error) {
+                       if ptr.isNil() {
+                               return b, nil
+                       }
+                       t := ptr.asPointerTo(reflect.PtrTo(u.typ)).Elem().Interface().(*float32)
+                       v := &float32Value{*t}
+                       buf, err := Marshal(v)
+                       if err != nil {
+                               return nil, err
+                       }
+                       b = appendVarint(b, wiretag)
+                       b = appendVarint(b, uint64(len(buf)))
+                       b = append(b, buf...)
+                       return b, nil
+               }
+}
+
+func makeStdFloatValueSliceMarshaler(u *marshalInfo) (sizer, marshaler) {
+       return func(ptr pointer, tagsize int) int {
+                       s := ptr.getSlice(u.typ)
+                       n := 0
+                       for i := 0; i < s.Len(); i++ {
+                               elem := s.Index(i)
+                               t := elem.Interface().(float32)
+                               v := &float32Value{t}
+                               siz := Size(v)
+                               n += siz + SizeVarint(uint64(siz)) + tagsize
+                       }
+                       return n
+               },
+               func(b []byte, ptr pointer, wiretag uint64, deterministic bool) ([]byte, error) {
+                       s := ptr.getSlice(u.typ)
+                       for i := 0; i < s.Len(); i++ {
+                               elem := s.Index(i)
+                               t := elem.Interface().(float32)
+                               v := &float32Value{t}
+                               siz := Size(v)
+                               buf, err := Marshal(v)
+                               if err != nil {
+                                       return nil, err
+                               }
+                               b = appendVarint(b, wiretag)
+                               b = appendVarint(b, uint64(siz))
+                               b = append(b, buf...)
+                       }
+
+                       return b, nil
+               }
+}
+
+func makeStdFloatValuePtrSliceMarshaler(u *marshalInfo) (sizer, marshaler) {
+       return func(ptr pointer, tagsize int) int {
+                       s := ptr.getSlice(reflect.PtrTo(u.typ))
+                       n := 0
+                       for i := 0; i < s.Len(); i++ {
+                               elem := s.Index(i)
+                               t := elem.Interface().(*float32)
+                               v := &float32Value{*t}
+                               siz := Size(v)
+                               n += siz + SizeVarint(uint64(siz)) + tagsize
+                       }
+                       return n
+               },
+               func(b []byte, ptr pointer, wiretag uint64, deterministic bool) ([]byte, error) {
+                       s := ptr.getSlice(reflect.PtrTo(u.typ))
+                       for i := 0; i < s.Len(); i++ {
+                               elem := s.Index(i)
+                               t := elem.Interface().(*float32)
+                               v := &float32Value{*t}
+                               siz := Size(v)
+                               buf, err := Marshal(v)
+                               if err != nil {
+                                       return nil, err
+                               }
+                               b = appendVarint(b, wiretag)
+                               b = appendVarint(b, uint64(siz))
+                               b = append(b, buf...)
+                       }
+
+                       return b, nil
+               }
+}
+
+func makeStdFloatValueUnmarshaler(sub *unmarshalInfo, name string) unmarshaler {
+       return func(b []byte, f pointer, w int) ([]byte, error) {
+               if w != WireBytes {
+                       return nil, errInternalBadWireType
+               }
+               x, n := decodeVarint(b)
+               if n == 0 {
+                       return nil, io.ErrUnexpectedEOF
+               }
+               b = b[n:]
+               if x > uint64(len(b)) {
+                       return nil, io.ErrUnexpectedEOF
+               }
+               m := &float32Value{}
+               if err := Unmarshal(b[:x], m); err != nil {
+                       return nil, err
+               }
+               s := f.asPointerTo(sub.typ).Elem()
+               s.Set(reflect.ValueOf(m.Value))
+               return b[x:], nil
+       }
+}
+
+func makeStdFloatValuePtrUnmarshaler(sub *unmarshalInfo, name string) unmarshaler {
+       return func(b []byte, f pointer, w int) ([]byte, error) {
+               if w != WireBytes {
+                       return nil, errInternalBadWireType
+               }
+               x, n := decodeVarint(b)
+               if n == 0 {
+                       return nil, io.ErrUnexpectedEOF
+               }
+               b = b[n:]
+               if x > uint64(len(b)) {
+                       return nil, io.ErrUnexpectedEOF
+               }
+               m := &float32Value{}
+               if err := Unmarshal(b[:x], m); err != nil {
+                       return nil, err
+               }
+               s := f.asPointerTo(reflect.PtrTo(sub.typ)).Elem()
+               s.Set(reflect.ValueOf(&m.Value))
+               return b[x:], nil
+       }
+}
+
+func makeStdFloatValuePtrSliceUnmarshaler(sub *unmarshalInfo, name string) unmarshaler {
+       return func(b []byte, f pointer, w int) ([]byte, error) {
+               if w != WireBytes {
+                       return nil, errInternalBadWireType
+               }
+               x, n := decodeVarint(b)
+               if n == 0 {
+                       return nil, io.ErrUnexpectedEOF
+               }
+               b = b[n:]
+               if x > uint64(len(b)) {
+                       return nil, io.ErrUnexpectedEOF
+               }
+               m := &float32Value{}
+               if err := Unmarshal(b[:x], m); err != nil {
+                       return nil, err
+               }
+               slice := f.getSlice(reflect.PtrTo(sub.typ))
+               newSlice := reflect.Append(slice, reflect.ValueOf(&m.Value))
+               slice.Set(newSlice)
+               return b[x:], nil
+       }
+}
+
+func makeStdFloatValueSliceUnmarshaler(sub *unmarshalInfo, name string) unmarshaler {
+       return func(b []byte, f pointer, w int) ([]byte, error) {
+               if w != WireBytes {
+                       return nil, errInternalBadWireType
+               }
+               x, n := decodeVarint(b)
+               if n == 0 {
+                       return nil, io.ErrUnexpectedEOF
+               }
+               b = b[n:]
+               if x > uint64(len(b)) {
+                       return nil, io.ErrUnexpectedEOF
+               }
+               m := &float32Value{}
+               if err := Unmarshal(b[:x], m); err != nil {
+                       return nil, err
+               }
+               slice := f.getSlice(sub.typ)
+               newSlice := reflect.Append(slice, reflect.ValueOf(m.Value))
+               slice.Set(newSlice)
+               return b[x:], nil
+       }
+}
+
+func makeStdInt64ValueMarshaler(u *marshalInfo) (sizer, marshaler) {
+       return func(ptr pointer, tagsize int) int {
+                       t := ptr.asPointerTo(u.typ).Interface().(*int64)
+                       v := &int64Value{*t}
+                       siz := Size(v)
+                       return tagsize + SizeVarint(uint64(siz)) + siz
+               }, func(b []byte, ptr pointer, wiretag uint64, deterministic bool) ([]byte, error) {
+                       t := ptr.asPointerTo(u.typ).Interface().(*int64)
+                       v := &int64Value{*t}
+                       buf, err := Marshal(v)
+                       if err != nil {
+                               return nil, err
+                       }
+                       b = appendVarint(b, wiretag)
+                       b = appendVarint(b, uint64(len(buf)))
+                       b = append(b, buf...)
+                       return b, nil
+               }
+}
+
+func makeStdInt64ValuePtrMarshaler(u *marshalInfo) (sizer, marshaler) {
+       return func(ptr pointer, tagsize int) int {
+                       if ptr.isNil() {
+                               return 0
+                       }
+                       t := ptr.asPointerTo(reflect.PtrTo(u.typ)).Elem().Interface().(*int64)
+                       v := &int64Value{*t}
+                       siz := Size(v)
+                       return tagsize + SizeVarint(uint64(siz)) + siz
+               }, func(b []byte, ptr pointer, wiretag uint64, deterministic bool) ([]byte, error) {
+                       if ptr.isNil() {
+                               return b, nil
+                       }
+                       t := ptr.asPointerTo(reflect.PtrTo(u.typ)).Elem().Interface().(*int64)
+                       v := &int64Value{*t}
+                       buf, err := Marshal(v)
+                       if err != nil {
+                               return nil, err
+                       }
+                       b = appendVarint(b, wiretag)
+                       b = appendVarint(b, uint64(len(buf)))
+                       b = append(b, buf...)
+                       return b, nil
+               }
+}
+
+func makeStdInt64ValueSliceMarshaler(u *marshalInfo) (sizer, marshaler) {
+       return func(ptr pointer, tagsize int) int {
+                       s := ptr.getSlice(u.typ)
+                       n := 0
+                       for i := 0; i < s.Len(); i++ {
+                               elem := s.Index(i)
+                               t := elem.Interface().(int64)
+                               v := &int64Value{t}
+                               siz := Size(v)
+                               n += siz + SizeVarint(uint64(siz)) + tagsize
+                       }
+                       return n
+               },
+               func(b []byte, ptr pointer, wiretag uint64, deterministic bool) ([]byte, error) {
+                       s := ptr.getSlice(u.typ)
+                       for i := 0; i < s.Len(); i++ {
+                               elem := s.Index(i)
+                               t := elem.Interface().(int64)
+                               v := &int64Value{t}
+                               siz := Size(v)
+                               buf, err := Marshal(v)
+                               if err != nil {
+                                       return nil, err
+                               }
+                               b = appendVarint(b, wiretag)
+                               b = appendVarint(b, uint64(siz))
+                               b = append(b, buf...)
+                       }
+
+                       return b, nil
+               }
+}
+
+func makeStdInt64ValuePtrSliceMarshaler(u *marshalInfo) (sizer, marshaler) {
+       return func(ptr pointer, tagsize int) int {
+                       s := ptr.getSlice(reflect.PtrTo(u.typ))
+                       n := 0
+                       for i := 0; i < s.Len(); i++ {
+                               elem := s.Index(i)
+                               t := elem.Interface().(*int64)
+                               v := &int64Value{*t}
+                               siz := Size(v)
+                               n += siz + SizeVarint(uint64(siz)) + tagsize
+                       }
+                       return n
+               },
+               func(b []byte, ptr pointer, wiretag uint64, deterministic bool) ([]byte, error) {
+                       s := ptr.getSlice(reflect.PtrTo(u.typ))
+                       for i := 0; i < s.Len(); i++ {
+                               elem := s.Index(i)
+                               t := elem.Interface().(*int64)
+                               v := &int64Value{*t}
+                               siz := Size(v)
+                               buf, err := Marshal(v)
+                               if err != nil {
+                                       return nil, err
+                               }
+                               b = appendVarint(b, wiretag)
+                               b = appendVarint(b, uint64(siz))
+                               b = append(b, buf...)
+                       }
+
+                       return b, nil
+               }
+}
+
+func makeStdInt64ValueUnmarshaler(sub *unmarshalInfo, name string) unmarshaler {
+       return func(b []byte, f pointer, w int) ([]byte, error) {
+               if w != WireBytes {
+                       return nil, errInternalBadWireType
+               }
+               x, n := decodeVarint(b)
+               if n == 0 {
+                       return nil, io.ErrUnexpectedEOF
+               }
+               b = b[n:]
+               if x > uint64(len(b)) {
+                       return nil, io.ErrUnexpectedEOF
+               }
+               m := &int64Value{}
+               if err := Unmarshal(b[:x], m); err != nil {
+                       return nil, err
+               }
+               s := f.asPointerTo(sub.typ).Elem()
+               s.Set(reflect.ValueOf(m.Value))
+               return b[x:], nil
+       }
+}
+
+func makeStdInt64ValuePtrUnmarshaler(sub *unmarshalInfo, name string) unmarshaler {
+       return func(b []byte, f pointer, w int) ([]byte, error) {
+               if w != WireBytes {
+                       return nil, errInternalBadWireType
+               }
+               x, n := decodeVarint(b)
+               if n == 0 {
+                       return nil, io.ErrUnexpectedEOF
+               }
+               b = b[n:]
+               if x > uint64(len(b)) {
+                       return nil, io.ErrUnexpectedEOF
+               }
+               m := &int64Value{}
+               if err := Unmarshal(b[:x], m); err != nil {
+                       return nil, err
+               }
+               s := f.asPointerTo(reflect.PtrTo(sub.typ)).Elem()
+               s.Set(reflect.ValueOf(&m.Value))
+               return b[x:], nil
+       }
+}
+
+func makeStdInt64ValuePtrSliceUnmarshaler(sub *unmarshalInfo, name string) unmarshaler {
+       return func(b []byte, f pointer, w int) ([]byte, error) {
+               if w != WireBytes {
+                       return nil, errInternalBadWireType
+               }
+               x, n := decodeVarint(b)
+               if n == 0 {
+                       return nil, io.ErrUnexpectedEOF
+               }
+               b = b[n:]
+               if x > uint64(len(b)) {
+                       return nil, io.ErrUnexpectedEOF
+               }
+               m := &int64Value{}
+               if err := Unmarshal(b[:x], m); err != nil {
+                       return nil, err
+               }
+               slice := f.getSlice(reflect.PtrTo(sub.typ))
+               newSlice := reflect.Append(slice, reflect.ValueOf(&m.Value))
+               slice.Set(newSlice)
+               return b[x:], nil
+       }
+}
+
+func makeStdInt64ValueSliceUnmarshaler(sub *unmarshalInfo, name string) unmarshaler {
+       return func(b []byte, f pointer, w int) ([]byte, error) {
+               if w != WireBytes {
+                       return nil, errInternalBadWireType
+               }
+               x, n := decodeVarint(b)
+               if n == 0 {
+                       return nil, io.ErrUnexpectedEOF
+               }
+               b = b[n:]
+               if x > uint64(len(b)) {
+                       return nil, io.ErrUnexpectedEOF
+               }
+               m := &int64Value{}
+               if err := Unmarshal(b[:x], m); err != nil {
+                       return nil, err
+               }
+               slice := f.getSlice(sub.typ)
+               newSlice := reflect.Append(slice, reflect.ValueOf(m.Value))
+               slice.Set(newSlice)
+               return b[x:], nil
+       }
+}
+
+func makeStdUInt64ValueMarshaler(u *marshalInfo) (sizer, marshaler) {
+       return func(ptr pointer, tagsize int) int {
+                       t := ptr.asPointerTo(u.typ).Interface().(*uint64)
+                       v := &uint64Value{*t}
+                       siz := Size(v)
+                       return tagsize + SizeVarint(uint64(siz)) + siz
+               }, func(b []byte, ptr pointer, wiretag uint64, deterministic bool) ([]byte, error) {
+                       t := ptr.asPointerTo(u.typ).Interface().(*uint64)
+                       v := &uint64Value{*t}
+                       buf, err := Marshal(v)
+                       if err != nil {
+                               return nil, err
+                       }
+                       b = appendVarint(b, wiretag)
+                       b = appendVarint(b, uint64(len(buf)))
+                       b = append(b, buf...)
+                       return b, nil
+               }
+}
+
+func makeStdUInt64ValuePtrMarshaler(u *marshalInfo) (sizer, marshaler) {
+       return func(ptr pointer, tagsize int) int {
+                       if ptr.isNil() {
+                               return 0
+                       }
+                       t := ptr.asPointerTo(reflect.PtrTo(u.typ)).Elem().Interface().(*uint64)
+                       v := &uint64Value{*t}
+                       siz := Size(v)
+                       return tagsize + SizeVarint(uint64(siz)) + siz
+               }, func(b []byte, ptr pointer, wiretag uint64, deterministic bool) ([]byte, error) {
+                       if ptr.isNil() {
+                               return b, nil
+                       }
+                       t := ptr.asPointerTo(reflect.PtrTo(u.typ)).Elem().Interface().(*uint64)
+                       v := &uint64Value{*t}
+                       buf, err := Marshal(v)
+                       if err != nil {
+                               return nil, err
+                       }
+                       b = appendVarint(b, wiretag)
+                       b = appendVarint(b, uint64(len(buf)))
+                       b = append(b, buf...)
+                       return b, nil
+               }
+}
+
+func makeStdUInt64ValueSliceMarshaler(u *marshalInfo) (sizer, marshaler) {
+       return func(ptr pointer, tagsize int) int {
+                       s := ptr.getSlice(u.typ)
+                       n := 0
+                       for i := 0; i < s.Len(); i++ {
+                               elem := s.Index(i)
+                               t := elem.Interface().(uint64)
+                               v := &uint64Value{t}
+                               siz := Size(v)
+                               n += siz + SizeVarint(uint64(siz)) + tagsize
+                       }
+                       return n
+               },
+               func(b []byte, ptr pointer, wiretag uint64, deterministic bool) ([]byte, error) {
+                       s := ptr.getSlice(u.typ)
+                       for i := 0; i < s.Len(); i++ {
+                               elem := s.Index(i)
+                               t := elem.Interface().(uint64)
+                               v := &uint64Value{t}
+                               siz := Size(v)
+                               buf, err := Marshal(v)
+                               if err != nil {
+                                       return nil, err
+                               }
+                               b = appendVarint(b, wiretag)
+                               b = appendVarint(b, uint64(siz))
+                               b = append(b, buf...)
+                       }
+
+                       return b, nil
+               }
+}
+
+func makeStdUInt64ValuePtrSliceMarshaler(u *marshalInfo) (sizer, marshaler) {
+       return func(ptr pointer, tagsize int) int {
+                       s := ptr.getSlice(reflect.PtrTo(u.typ))
+                       n := 0
+                       for i := 0; i < s.Len(); i++ {
+                               elem := s.Index(i)
+                               t := elem.Interface().(*uint64)
+                               v := &uint64Value{*t}
+                               siz := Size(v)
+                               n += siz + SizeVarint(uint64(siz)) + tagsize
+                       }
+                       return n
+               },
+               func(b []byte, ptr pointer, wiretag uint64, deterministic bool) ([]byte, error) {
+                       s := ptr.getSlice(reflect.PtrTo(u.typ))
+                       for i := 0; i < s.Len(); i++ {
+                               elem := s.Index(i)
+                               t := elem.Interface().(*uint64)
+                               v := &uint64Value{*t}
+                               siz := Size(v)
+                               buf, err := Marshal(v)
+                               if err != nil {
+                                       return nil, err
+                               }
+                               b = appendVarint(b, wiretag)
+                               b = appendVarint(b, uint64(siz))
+                               b = append(b, buf...)
+                       }
+
+                       return b, nil
+               }
+}
+
+func makeStdUInt64ValueUnmarshaler(sub *unmarshalInfo, name string) unmarshaler {
+       return func(b []byte, f pointer, w int) ([]byte, error) {
+               if w != WireBytes {
+                       return nil, errInternalBadWireType
+               }
+               x, n := decodeVarint(b)
+               if n == 0 {
+                       return nil, io.ErrUnexpectedEOF
+               }
+               b = b[n:]
+               if x > uint64(len(b)) {
+                       return nil, io.ErrUnexpectedEOF
+               }
+               m := &uint64Value{}
+               if err := Unmarshal(b[:x], m); err != nil {
+                       return nil, err
+               }
+               s := f.asPointerTo(sub.typ).Elem()
+               s.Set(reflect.ValueOf(m.Value))
+               return b[x:], nil
+       }
+}
+
+func makeStdUInt64ValuePtrUnmarshaler(sub *unmarshalInfo, name string) unmarshaler {
+       return func(b []byte, f pointer, w int) ([]byte, error) {
+               if w != WireBytes {
+                       return nil, errInternalBadWireType
+               }
+               x, n := decodeVarint(b)
+               if n == 0 {
+                       return nil, io.ErrUnexpectedEOF
+               }
+               b = b[n:]
+               if x > uint64(len(b)) {
+                       return nil, io.ErrUnexpectedEOF
+               }
+               m := &uint64Value{}
+               if err := Unmarshal(b[:x], m); err != nil {
+                       return nil, err
+               }
+               s := f.asPointerTo(reflect.PtrTo(sub.typ)).Elem()
+               s.Set(reflect.ValueOf(&m.Value))
+               return b[x:], nil
+       }
+}
+
+func makeStdUInt64ValuePtrSliceUnmarshaler(sub *unmarshalInfo, name string) unmarshaler {
+       return func(b []byte, f pointer, w int) ([]byte, error) {
+               if w != WireBytes {
+                       return nil, errInternalBadWireType
+               }
+               x, n := decodeVarint(b)
+               if n == 0 {
+                       return nil, io.ErrUnexpectedEOF
+               }
+               b = b[n:]
+               if x > uint64(len(b)) {
+                       return nil, io.ErrUnexpectedEOF
+               }
+               m := &uint64Value{}
+               if err := Unmarshal(b[:x], m); err != nil {
+                       return nil, err
+               }
+               slice := f.getSlice(reflect.PtrTo(sub.typ))
+               newSlice := reflect.Append(slice, reflect.ValueOf(&m.Value))
+               slice.Set(newSlice)
+               return b[x:], nil
+       }
+}
+
+func makeStdUInt64ValueSliceUnmarshaler(sub *unmarshalInfo, name string) unmarshaler {
+       return func(b []byte, f pointer, w int) ([]byte, error) {
+               if w != WireBytes {
+                       return nil, errInternalBadWireType
+               }
+               x, n := decodeVarint(b)
+               if n == 0 {
+                       return nil, io.ErrUnexpectedEOF
+               }
+               b = b[n:]
+               if x > uint64(len(b)) {
+                       return nil, io.ErrUnexpectedEOF
+               }
+               m := &uint64Value{}
+               if err := Unmarshal(b[:x], m); err != nil {
+                       return nil, err
+               }
+               slice := f.getSlice(sub.typ)
+               newSlice := reflect.Append(slice, reflect.ValueOf(m.Value))
+               slice.Set(newSlice)
+               return b[x:], nil
+       }
+}
+
+func makeStdInt32ValueMarshaler(u *marshalInfo) (sizer, marshaler) {
+       return func(ptr pointer, tagsize int) int {
+                       t := ptr.asPointerTo(u.typ).Interface().(*int32)
+                       v := &int32Value{*t}
+                       siz := Size(v)
+                       return tagsize + SizeVarint(uint64(siz)) + siz
+               }, func(b []byte, ptr pointer, wiretag uint64, deterministic bool) ([]byte, error) {
+                       t := ptr.asPointerTo(u.typ).Interface().(*int32)
+                       v := &int32Value{*t}
+                       buf, err := Marshal(v)
+                       if err != nil {
+                               return nil, err
+                       }
+                       b = appendVarint(b, wiretag)
+                       b = appendVarint(b, uint64(len(buf)))
+                       b = append(b, buf...)
+                       return b, nil
+               }
+}
+
+func makeStdInt32ValuePtrMarshaler(u *marshalInfo) (sizer, marshaler) {
+       return func(ptr pointer, tagsize int) int {
+                       if ptr.isNil() {
+                               return 0
+                       }
+                       t := ptr.asPointerTo(reflect.PtrTo(u.typ)).Elem().Interface().(*int32)
+                       v := &int32Value{*t}
+                       siz := Size(v)
+                       return tagsize + SizeVarint(uint64(siz)) + siz
+               }, func(b []byte, ptr pointer, wiretag uint64, deterministic bool) ([]byte, error) {
+                       if ptr.isNil() {
+                               return b, nil
+                       }
+                       t := ptr.asPointerTo(reflect.PtrTo(u.typ)).Elem().Interface().(*int32)
+                       v := &int32Value{*t}
+                       buf, err := Marshal(v)
+                       if err != nil {
+                               return nil, err
+                       }
+                       b = appendVarint(b, wiretag)
+                       b = appendVarint(b, uint64(len(buf)))
+                       b = append(b, buf...)
+                       return b, nil
+               }
+}
+
+func makeStdInt32ValueSliceMarshaler(u *marshalInfo) (sizer, marshaler) {
+       return func(ptr pointer, tagsize int) int {
+                       s := ptr.getSlice(u.typ)
+                       n := 0
+                       for i := 0; i < s.Len(); i++ {
+                               elem := s.Index(i)
+                               t := elem.Interface().(int32)
+                               v := &int32Value{t}
+                               siz := Size(v)
+                               n += siz + SizeVarint(uint64(siz)) + tagsize
+                       }
+                       return n
+               },
+               func(b []byte, ptr pointer, wiretag uint64, deterministic bool) ([]byte, error) {
+                       s := ptr.getSlice(u.typ)
+                       for i := 0; i < s.Len(); i++ {
+                               elem := s.Index(i)
+                               t := elem.Interface().(int32)
+                               v := &int32Value{t}
+                               siz := Size(v)
+                               buf, err := Marshal(v)
+                               if err != nil {
+                                       return nil, err
+                               }
+                               b = appendVarint(b, wiretag)
+                               b = appendVarint(b, uint64(siz))
+                               b = append(b, buf...)
+                       }
+
+                       return b, nil
+               }
+}
+
+func makeStdInt32ValuePtrSliceMarshaler(u *marshalInfo) (sizer, marshaler) {
+       return func(ptr pointer, tagsize int) int {
+                       s := ptr.getSlice(reflect.PtrTo(u.typ))
+                       n := 0
+                       for i := 0; i < s.Len(); i++ {
+                               elem := s.Index(i)
+                               t := elem.Interface().(*int32)
+                               v := &int32Value{*t}
+                               siz := Size(v)
+                               n += siz + SizeVarint(uint64(siz)) + tagsize
+                       }
+                       return n
+               },
+               func(b []byte, ptr pointer, wiretag uint64, deterministic bool) ([]byte, error) {
+                       s := ptr.getSlice(reflect.PtrTo(u.typ))
+                       for i := 0; i < s.Len(); i++ {
+                               elem := s.Index(i)
+                               t := elem.Interface().(*int32)
+                               v := &int32Value{*t}
+                               siz := Size(v)
+                               buf, err := Marshal(v)
+                               if err != nil {
+                                       return nil, err
+                               }
+                               b = appendVarint(b, wiretag)
+                               b = appendVarint(b, uint64(siz))
+                               b = append(b, buf...)
+                       }
+
+                       return b, nil
+               }
+}
+
+func makeStdInt32ValueUnmarshaler(sub *unmarshalInfo, name string) unmarshaler {
+       return func(b []byte, f pointer, w int) ([]byte, error) {
+               if w != WireBytes {
+                       return nil, errInternalBadWireType
+               }
+               x, n := decodeVarint(b)
+               if n == 0 {
+                       return nil, io.ErrUnexpectedEOF
+               }
+               b = b[n:]
+               if x > uint64(len(b)) {
+                       return nil, io.ErrUnexpectedEOF
+               }
+               m := &int32Value{}
+               if err := Unmarshal(b[:x], m); err != nil {
+                       return nil, err
+               }
+               s := f.asPointerTo(sub.typ).Elem()
+               s.Set(reflect.ValueOf(m.Value))
+               return b[x:], nil
+       }
+}
+
+func makeStdInt32ValuePtrUnmarshaler(sub *unmarshalInfo, name string) unmarshaler {
+       return func(b []byte, f pointer, w int) ([]byte, error) {
+               if w != WireBytes {
+                       return nil, errInternalBadWireType
+               }
+               x, n := decodeVarint(b)
+               if n == 0 {
+                       return nil, io.ErrUnexpectedEOF
+               }
+               b = b[n:]
+               if x > uint64(len(b)) {
+                       return nil, io.ErrUnexpectedEOF
+               }
+               m := &int32Value{}
+               if err := Unmarshal(b[:x], m); err != nil {
+                       return nil, err
+               }
+               s := f.asPointerTo(reflect.PtrTo(sub.typ)).Elem()
+               s.Set(reflect.ValueOf(&m.Value))
+               return b[x:], nil
+       }
+}
+
+func makeStdInt32ValuePtrSliceUnmarshaler(sub *unmarshalInfo, name string) unmarshaler {
+       return func(b []byte, f pointer, w int) ([]byte, error) {
+               if w != WireBytes {
+                       return nil, errInternalBadWireType
+               }
+               x, n := decodeVarint(b)
+               if n == 0 {
+                       return nil, io.ErrUnexpectedEOF
+               }
+               b = b[n:]
+               if x > uint64(len(b)) {
+                       return nil, io.ErrUnexpectedEOF
+               }
+               m := &int32Value{}
+               if err := Unmarshal(b[:x], m); err != nil {
+                       return nil, err
+               }
+               slice := f.getSlice(reflect.PtrTo(sub.typ))
+               newSlice := reflect.Append(slice, reflect.ValueOf(&m.Value))
+               slice.Set(newSlice)
+               return b[x:], nil
+       }
+}
+
+func makeStdInt32ValueSliceUnmarshaler(sub *unmarshalInfo, name string) unmarshaler {
+       return func(b []byte, f pointer, w int) ([]byte, error) {
+               if w != WireBytes {
+                       return nil, errInternalBadWireType
+               }
+               x, n := decodeVarint(b)
+               if n == 0 {
+                       return nil, io.ErrUnexpectedEOF
+               }
+               b = b[n:]
+               if x > uint64(len(b)) {
+                       return nil, io.ErrUnexpectedEOF
+               }
+               m := &int32Value{}
+               if err := Unmarshal(b[:x], m); err != nil {
+                       return nil, err
+               }
+               slice := f.getSlice(sub.typ)
+               newSlice := reflect.Append(slice, reflect.ValueOf(m.Value))
+               slice.Set(newSlice)
+               return b[x:], nil
+       }
+}
+
+func makeStdUInt32ValueMarshaler(u *marshalInfo) (sizer, marshaler) {
+       return func(ptr pointer, tagsize int) int {
+                       t := ptr.asPointerTo(u.typ).Interface().(*uint32)
+                       v := &uint32Value{*t}
+                       siz := Size(v)
+                       return tagsize + SizeVarint(uint64(siz)) + siz
+               }, func(b []byte, ptr pointer, wiretag uint64, deterministic bool) ([]byte, error) {
+                       t := ptr.asPointerTo(u.typ).Interface().(*uint32)
+                       v := &uint32Value{*t}
+                       buf, err := Marshal(v)
+                       if err != nil {
+                               return nil, err
+                       }
+                       b = appendVarint(b, wiretag)
+                       b = appendVarint(b, uint64(len(buf)))
+                       b = append(b, buf...)
+                       return b, nil
+               }
+}
+
+func makeStdUInt32ValuePtrMarshaler(u *marshalInfo) (sizer, marshaler) {
+       return func(ptr pointer, tagsize int) int {
+                       if ptr.isNil() {
+                               return 0
+                       }
+                       t := ptr.asPointerTo(reflect.PtrTo(u.typ)).Elem().Interface().(*uint32)
+                       v := &uint32Value{*t}
+                       siz := Size(v)
+                       return tagsize + SizeVarint(uint64(siz)) + siz
+               }, func(b []byte, ptr pointer, wiretag uint64, deterministic bool) ([]byte, error) {
+                       if ptr.isNil() {
+                               return b, nil
+                       }
+                       t := ptr.asPointerTo(reflect.PtrTo(u.typ)).Elem().Interface().(*uint32)
+                       v := &uint32Value{*t}
+                       buf, err := Marshal(v)
+                       if err != nil {
+                               return nil, err
+                       }
+                       b = appendVarint(b, wiretag)
+                       b = appendVarint(b, uint64(len(buf)))
+                       b = append(b, buf...)
+                       return b, nil
+               }
+}
+
+func makeStdUInt32ValueSliceMarshaler(u *marshalInfo) (sizer, marshaler) {
+       return func(ptr pointer, tagsize int) int {
+                       s := ptr.getSlice(u.typ)
+                       n := 0
+                       for i := 0; i < s.Len(); i++ {
+                               elem := s.Index(i)
+                               t := elem.Interface().(uint32)
+                               v := &uint32Value{t}
+                               siz := Size(v)
+                               n += siz + SizeVarint(uint64(siz)) + tagsize
+                       }
+                       return n
+               },
+               func(b []byte, ptr pointer, wiretag uint64, deterministic bool) ([]byte, error) {
+                       s := ptr.getSlice(u.typ)
+                       for i := 0; i < s.Len(); i++ {
+                               elem := s.Index(i)
+                               t := elem.Interface().(uint32)
+                               v := &uint32Value{t}
+                               siz := Size(v)
+                               buf, err := Marshal(v)
+                               if err != nil {
+                                       return nil, err
+                               }
+                               b = appendVarint(b, wiretag)
+                               b = appendVarint(b, uint64(siz))
+                               b = append(b, buf...)
+                       }
+
+                       return b, nil
+               }
+}
+
+func makeStdUInt32ValuePtrSliceMarshaler(u *marshalInfo) (sizer, marshaler) {
+       return func(ptr pointer, tagsize int) int {
+                       s := ptr.getSlice(reflect.PtrTo(u.typ))
+                       n := 0
+                       for i := 0; i < s.Len(); i++ {
+                               elem := s.Index(i)
+                               t := elem.Interface().(*uint32)
+                               v := &uint32Value{*t}
+                               siz := Size(v)
+                               n += siz + SizeVarint(uint64(siz)) + tagsize
+                       }
+                       return n
+               },
+               func(b []byte, ptr pointer, wiretag uint64, deterministic bool) ([]byte, error) {
+                       s := ptr.getSlice(reflect.PtrTo(u.typ))
+                       for i := 0; i < s.Len(); i++ {
+                               elem := s.Index(i)
+                               t := elem.Interface().(*uint32)
+                               v := &uint32Value{*t}
+                               siz := Size(v)
+                               buf, err := Marshal(v)
+                               if err != nil {
+                                       return nil, err
+                               }
+                               b = appendVarint(b, wiretag)
+                               b = appendVarint(b, uint64(siz))
+                               b = append(b, buf...)
+                       }
+
+                       return b, nil
+               }
+}
+
+func makeStdUInt32ValueUnmarshaler(sub *unmarshalInfo, name string) unmarshaler {
+       return func(b []byte, f pointer, w int) ([]byte, error) {
+               if w != WireBytes {
+                       return nil, errInternalBadWireType
+               }
+               x, n := decodeVarint(b)
+               if n == 0 {
+                       return nil, io.ErrUnexpectedEOF
+               }
+               b = b[n:]
+               if x > uint64(len(b)) {
+                       return nil, io.ErrUnexpectedEOF
+               }
+               m := &uint32Value{}
+               if err := Unmarshal(b[:x], m); err != nil {
+                       return nil, err
+               }
+               s := f.asPointerTo(sub.typ).Elem()
+               s.Set(reflect.ValueOf(m.Value))
+               return b[x:], nil
+       }
+}
+
+func makeStdUInt32ValuePtrUnmarshaler(sub *unmarshalInfo, name string) unmarshaler {
+       return func(b []byte, f pointer, w int) ([]byte, error) {
+               if w != WireBytes {
+                       return nil, errInternalBadWireType
+               }
+               x, n := decodeVarint(b)
+               if n == 0 {
+                       return nil, io.ErrUnexpectedEOF
+               }
+               b = b[n:]
+               if x > uint64(len(b)) {
+                       return nil, io.ErrUnexpectedEOF
+               }
+               m := &uint32Value{}
+               if err := Unmarshal(b[:x], m); err != nil {
+                       return nil, err
+               }
+               s := f.asPointerTo(reflect.PtrTo(sub.typ)).Elem()
+               s.Set(reflect.ValueOf(&m.Value))
+               return b[x:], nil
+       }
+}
+
+func makeStdUInt32ValuePtrSliceUnmarshaler(sub *unmarshalInfo, name string) unmarshaler {
+       return func(b []byte, f pointer, w int) ([]byte, error) {
+               if w != WireBytes {
+                       return nil, errInternalBadWireType
+               }
+               x, n := decodeVarint(b)
+               if n == 0 {
+                       return nil, io.ErrUnexpectedEOF
+               }
+               b = b[n:]
+               if x > uint64(len(b)) {
+                       return nil, io.ErrUnexpectedEOF
+               }
+               m := &uint32Value{}
+               if err := Unmarshal(b[:x], m); err != nil {
+                       return nil, err
+               }
+               slice := f.getSlice(reflect.PtrTo(sub.typ))
+               newSlice := reflect.Append(slice, reflect.ValueOf(&m.Value))
+               slice.Set(newSlice)
+               return b[x:], nil
+       }
+}
+
+func makeStdUInt32ValueSliceUnmarshaler(sub *unmarshalInfo, name string) unmarshaler {
+       return func(b []byte, f pointer, w int) ([]byte, error) {
+               if w != WireBytes {
+                       return nil, errInternalBadWireType
+               }
+               x, n := decodeVarint(b)
+               if n == 0 {
+                       return nil, io.ErrUnexpectedEOF
+               }
+               b = b[n:]
+               if x > uint64(len(b)) {
+                       return nil, io.ErrUnexpectedEOF
+               }
+               m := &uint32Value{}
+               if err := Unmarshal(b[:x], m); err != nil {
+                       return nil, err
+               }
+               slice := f.getSlice(sub.typ)
+               newSlice := reflect.Append(slice, reflect.ValueOf(m.Value))
+               slice.Set(newSlice)
+               return b[x:], nil
+       }
+}
+
+func makeStdBoolValueMarshaler(u *marshalInfo) (sizer, marshaler) {
+       return func(ptr pointer, tagsize int) int {
+                       t := ptr.asPointerTo(u.typ).Interface().(*bool)
+                       v := &boolValue{*t}
+                       siz := Size(v)
+                       return tagsize + SizeVarint(uint64(siz)) + siz
+               }, func(b []byte, ptr pointer, wiretag uint64, deterministic bool) ([]byte, error) {
+                       t := ptr.asPointerTo(u.typ).Interface().(*bool)
+                       v := &boolValue{*t}
+                       buf, err := Marshal(v)
+                       if err != nil {
+                               return nil, err
+                       }
+                       b = appendVarint(b, wiretag)
+                       b = appendVarint(b, uint64(len(buf)))
+                       b = append(b, buf...)
+                       return b, nil
+               }
+}
+
+func makeStdBoolValuePtrMarshaler(u *marshalInfo) (sizer, marshaler) {
+       return func(ptr pointer, tagsize int) int {
+                       if ptr.isNil() {
+                               return 0
+                       }
+                       t := ptr.asPointerTo(reflect.PtrTo(u.typ)).Elem().Interface().(*bool)
+                       v := &boolValue{*t}
+                       siz := Size(v)
+                       return tagsize + SizeVarint(uint64(siz)) + siz
+               }, func(b []byte, ptr pointer, wiretag uint64, deterministic bool) ([]byte, error) {
+                       if ptr.isNil() {
+                               return b, nil
+                       }
+                       t := ptr.asPointerTo(reflect.PtrTo(u.typ)).Elem().Interface().(*bool)
+                       v := &boolValue{*t}
+                       buf, err := Marshal(v)
+                       if err != nil {
+                               return nil, err
+                       }
+                       b = appendVarint(b, wiretag)
+                       b = appendVarint(b, uint64(len(buf)))
+                       b = append(b, buf...)
+                       return b, nil
+               }
+}
+
+func makeStdBoolValueSliceMarshaler(u *marshalInfo) (sizer, marshaler) {
+       return func(ptr pointer, tagsize int) int {
+                       s := ptr.getSlice(u.typ)
+                       n := 0
+                       for i := 0; i < s.Len(); i++ {
+                               elem := s.Index(i)
+                               t := elem.Interface().(bool)
+                               v := &boolValue{t}
+                               siz := Size(v)
+                               n += siz + SizeVarint(uint64(siz)) + tagsize
+                       }
+                       return n
+               },
+               func(b []byte, ptr pointer, wiretag uint64, deterministic bool) ([]byte, error) {
+                       s := ptr.getSlice(u.typ)
+                       for i := 0; i < s.Len(); i++ {
+                               elem := s.Index(i)
+                               t := elem.Interface().(bool)
+                               v := &boolValue{t}
+                               siz := Size(v)
+                               buf, err := Marshal(v)
+                               if err != nil {
+                                       return nil, err
+                               }
+                               b = appendVarint(b, wiretag)
+                               b = appendVarint(b, uint64(siz))
+                               b = append(b, buf...)
+                       }
+
+                       return b, nil
+               }
+}
+
+func makeStdBoolValuePtrSliceMarshaler(u *marshalInfo) (sizer, marshaler) {
+       return func(ptr pointer, tagsize int) int {
+                       s := ptr.getSlice(reflect.PtrTo(u.typ))
+                       n := 0
+                       for i := 0; i < s.Len(); i++ {
+                               elem := s.Index(i)
+                               t := elem.Interface().(*bool)
+                               v := &boolValue{*t}
+                               siz := Size(v)
+                               n += siz + SizeVarint(uint64(siz)) + tagsize
+                       }
+                       return n
+               },
+               func(b []byte, ptr pointer, wiretag uint64, deterministic bool) ([]byte, error) {
+                       s := ptr.getSlice(reflect.PtrTo(u.typ))
+                       for i := 0; i < s.Len(); i++ {
+                               elem := s.Index(i)
+                               t := elem.Interface().(*bool)
+                               v := &boolValue{*t}
+                               siz := Size(v)
+                               buf, err := Marshal(v)
+                               if err != nil {
+                                       return nil, err
+                               }
+                               b = appendVarint(b, wiretag)
+                               b = appendVarint(b, uint64(siz))
+                               b = append(b, buf...)
+                       }
+
+                       return b, nil
+               }
+}
+
+func makeStdBoolValueUnmarshaler(sub *unmarshalInfo, name string) unmarshaler {
+       return func(b []byte, f pointer, w int) ([]byte, error) {
+               if w != WireBytes {
+                       return nil, errInternalBadWireType
+               }
+               x, n := decodeVarint(b)
+               if n == 0 {
+                       return nil, io.ErrUnexpectedEOF
+               }
+               b = b[n:]
+               if x > uint64(len(b)) {
+                       return nil, io.ErrUnexpectedEOF
+               }
+               m := &boolValue{}
+               if err := Unmarshal(b[:x], m); err != nil {
+                       return nil, err
+               }
+               s := f.asPointerTo(sub.typ).Elem()
+               s.Set(reflect.ValueOf(m.Value))
+               return b[x:], nil
+       }
+}
+
+func makeStdBoolValuePtrUnmarshaler(sub *unmarshalInfo, name string) unmarshaler {
+       return func(b []byte, f pointer, w int) ([]byte, error) {
+               if w != WireBytes {
+                       return nil, errInternalBadWireType
+               }
+               x, n := decodeVarint(b)
+               if n == 0 {
+                       return nil, io.ErrUnexpectedEOF
+               }
+               b = b[n:]
+               if x > uint64(len(b)) {
+                       return nil, io.ErrUnexpectedEOF
+               }
+               m := &boolValue{}
+               if err := Unmarshal(b[:x], m); err != nil {
+                       return nil, err
+               }
+               s := f.asPointerTo(reflect.PtrTo(sub.typ)).Elem()
+               s.Set(reflect.ValueOf(&m.Value))
+               return b[x:], nil
+       }
+}
+
+func makeStdBoolValuePtrSliceUnmarshaler(sub *unmarshalInfo, name string) unmarshaler {
+       return func(b []byte, f pointer, w int) ([]byte, error) {
+               if w != WireBytes {
+                       return nil, errInternalBadWireType
+               }
+               x, n := decodeVarint(b)
+               if n == 0 {
+                       return nil, io.ErrUnexpectedEOF
+               }
+               b = b[n:]
+               if x > uint64(len(b)) {
+                       return nil, io.ErrUnexpectedEOF
+               }
+               m := &boolValue{}
+               if err := Unmarshal(b[:x], m); err != nil {
+                       return nil, err
+               }
+               slice := f.getSlice(reflect.PtrTo(sub.typ))
+               newSlice := reflect.Append(slice, reflect.ValueOf(&m.Value))
+               slice.Set(newSlice)
+               return b[x:], nil
+       }
+}
+
+func makeStdBoolValueSliceUnmarshaler(sub *unmarshalInfo, name string) unmarshaler {
+       return func(b []byte, f pointer, w int) ([]byte, error) {
+               if w != WireBytes {
+                       return nil, errInternalBadWireType
+               }
+               x, n := decodeVarint(b)
+               if n == 0 {
+                       return nil, io.ErrUnexpectedEOF
+               }
+               b = b[n:]
+               if x > uint64(len(b)) {
+                       return nil, io.ErrUnexpectedEOF
+               }
+               m := &boolValue{}
+               if err := Unmarshal(b[:x], m); err != nil {
+                       return nil, err
+               }
+               slice := f.getSlice(sub.typ)
+               newSlice := reflect.Append(slice, reflect.ValueOf(m.Value))
+               slice.Set(newSlice)
+               return b[x:], nil
+       }
+}
+
+func makeStdStringValueMarshaler(u *marshalInfo) (sizer, marshaler) {
+       return func(ptr pointer, tagsize int) int {
+                       t := ptr.asPointerTo(u.typ).Interface().(*string)
+                       v := &stringValue{*t}
+                       siz := Size(v)
+                       return tagsize + SizeVarint(uint64(siz)) + siz
+               }, func(b []byte, ptr pointer, wiretag uint64, deterministic bool) ([]byte, error) {
+                       t := ptr.asPointerTo(u.typ).Interface().(*string)
+                       v := &stringValue{*t}
+                       buf, err := Marshal(v)
+                       if err != nil {
+                               return nil, err
+                       }
+                       b = appendVarint(b, wiretag)
+                       b = appendVarint(b, uint64(len(buf)))
+                       b = append(b, buf...)
+                       return b, nil
+               }
+}
+
+func makeStdStringValuePtrMarshaler(u *marshalInfo) (sizer, marshaler) {
+       return func(ptr pointer, tagsize int) int {
+                       if ptr.isNil() {
+                               return 0
+                       }
+                       t := ptr.asPointerTo(reflect.PtrTo(u.typ)).Elem().Interface().(*string)
+                       v := &stringValue{*t}
+                       siz := Size(v)
+                       return tagsize + SizeVarint(uint64(siz)) + siz
+               }, func(b []byte, ptr pointer, wiretag uint64, deterministic bool) ([]byte, error) {
+                       if ptr.isNil() {
+                               return b, nil
+                       }
+                       t := ptr.asPointerTo(reflect.PtrTo(u.typ)).Elem().Interface().(*string)
+                       v := &stringValue{*t}
+                       buf, err := Marshal(v)
+                       if err != nil {
+                               return nil, err
+                       }
+                       b = appendVarint(b, wiretag)
+                       b = appendVarint(b, uint64(len(buf)))
+                       b = append(b, buf...)
+                       return b, nil
+               }
+}
+
+func makeStdStringValueSliceMarshaler(u *marshalInfo) (sizer, marshaler) {
+       return func(ptr pointer, tagsize int) int {
+                       s := ptr.getSlice(u.typ)
+                       n := 0
+                       for i := 0; i < s.Len(); i++ {
+                               elem := s.Index(i)
+                               t := elem.Interface().(string)
+                               v := &stringValue{t}
+                               siz := Size(v)
+                               n += siz + SizeVarint(uint64(siz)) + tagsize
+                       }
+                       return n
+               },
+               func(b []byte, ptr pointer, wiretag uint64, deterministic bool) ([]byte, error) {
+                       s := ptr.getSlice(u.typ)
+                       for i := 0; i < s.Len(); i++ {
+                               elem := s.Index(i)
+                               t := elem.Interface().(string)
+                               v := &stringValue{t}
+                               siz := Size(v)
+                               buf, err := Marshal(v)
+                               if err != nil {
+                                       return nil, err
+                               }
+                               b = appendVarint(b, wiretag)
+                               b = appendVarint(b, uint64(siz))
+                               b = append(b, buf...)
+                       }
+
+                       return b, nil
+               }
+}
+
+func makeStdStringValuePtrSliceMarshaler(u *marshalInfo) (sizer, marshaler) {
+       return func(ptr pointer, tagsize int) int {
+                       s := ptr.getSlice(reflect.PtrTo(u.typ))
+                       n := 0
+                       for i := 0; i < s.Len(); i++ {
+                               elem := s.Index(i)
+                               t := elem.Interface().(*string)
+                               v := &stringValue{*t}
+                               siz := Size(v)
+                               n += siz + SizeVarint(uint64(siz)) + tagsize
+                       }
+                       return n
+               },
+               func(b []byte, ptr pointer, wiretag uint64, deterministic bool) ([]byte, error) {
+                       s := ptr.getSlice(reflect.PtrTo(u.typ))
+                       for i := 0; i < s.Len(); i++ {
+                               elem := s.Index(i)
+                               t := elem.Interface().(*string)
+                               v := &stringValue{*t}
+                               siz := Size(v)
+                               buf, err := Marshal(v)
+                               if err != nil {
+                                       return nil, err
+                               }
+                               b = appendVarint(b, wiretag)
+                               b = appendVarint(b, uint64(siz))
+                               b = append(b, buf...)
+                       }
+
+                       return b, nil
+               }
+}
+
+func makeStdStringValueUnmarshaler(sub *unmarshalInfo, name string) unmarshaler {
+       return func(b []byte, f pointer, w int) ([]byte, error) {
+               if w != WireBytes {
+                       return nil, errInternalBadWireType
+               }
+               x, n := decodeVarint(b)
+               if n == 0 {
+                       return nil, io.ErrUnexpectedEOF
+               }
+               b = b[n:]
+               if x > uint64(len(b)) {
+                       return nil, io.ErrUnexpectedEOF
+               }
+               m := &stringValue{}
+               if err := Unmarshal(b[:x], m); err != nil {
+                       return nil, err
+               }
+               s := f.asPointerTo(sub.typ).Elem()
+               s.Set(reflect.ValueOf(m.Value))
+               return b[x:], nil
+       }
+}
+
+func makeStdStringValuePtrUnmarshaler(sub *unmarshalInfo, name string) unmarshaler {
+       return func(b []byte, f pointer, w int) ([]byte, error) {
+               if w != WireBytes {
+                       return nil, errInternalBadWireType
+               }
+               x, n := decodeVarint(b)
+               if n == 0 {
+                       return nil, io.ErrUnexpectedEOF
+               }
+               b = b[n:]
+               if x > uint64(len(b)) {
+                       return nil, io.ErrUnexpectedEOF
+               }
+               m := &stringValue{}
+               if err := Unmarshal(b[:x], m); err != nil {
+                       return nil, err
+               }
+               s := f.asPointerTo(reflect.PtrTo(sub.typ)).Elem()
+               s.Set(reflect.ValueOf(&m.Value))
+               return b[x:], nil
+       }
+}
+
+func makeStdStringValuePtrSliceUnmarshaler(sub *unmarshalInfo, name string) unmarshaler {
+       return func(b []byte, f pointer, w int) ([]byte, error) {
+               if w != WireBytes {
+                       return nil, errInternalBadWireType
+               }
+               x, n := decodeVarint(b)
+               if n == 0 {
+                       return nil, io.ErrUnexpectedEOF
+               }
+               b = b[n:]
+               if x > uint64(len(b)) {
+                       return nil, io.ErrUnexpectedEOF
+               }
+               m := &stringValue{}
+               if err := Unmarshal(b[:x], m); err != nil {
+                       return nil, err
+               }
+               slice := f.getSlice(reflect.PtrTo(sub.typ))
+               newSlice := reflect.Append(slice, reflect.ValueOf(&m.Value))
+               slice.Set(newSlice)
+               return b[x:], nil
+       }
+}
+
+func makeStdStringValueSliceUnmarshaler(sub *unmarshalInfo, name string) unmarshaler {
+       return func(b []byte, f pointer, w int) ([]byte, error) {
+               if w != WireBytes {
+                       return nil, errInternalBadWireType
+               }
+               x, n := decodeVarint(b)
+               if n == 0 {
+                       return nil, io.ErrUnexpectedEOF
+               }
+               b = b[n:]
+               if x > uint64(len(b)) {
+                       return nil, io.ErrUnexpectedEOF
+               }
+               m := &stringValue{}
+               if err := Unmarshal(b[:x], m); err != nil {
+                       return nil, err
+               }
+               slice := f.getSlice(sub.typ)
+               newSlice := reflect.Append(slice, reflect.ValueOf(m.Value))
+               slice.Set(newSlice)
+               return b[x:], nil
+       }
+}
+
+func makeStdBytesValueMarshaler(u *marshalInfo) (sizer, marshaler) {
+       return func(ptr pointer, tagsize int) int {
+                       t := ptr.asPointerTo(u.typ).Interface().(*[]byte)
+                       v := &bytesValue{*t}
+                       siz := Size(v)
+                       return tagsize + SizeVarint(uint64(siz)) + siz
+               }, func(b []byte, ptr pointer, wiretag uint64, deterministic bool) ([]byte, error) {
+                       t := ptr.asPointerTo(u.typ).Interface().(*[]byte)
+                       v := &bytesValue{*t}
+                       buf, err := Marshal(v)
+                       if err != nil {
+                               return nil, err
+                       }
+                       b = appendVarint(b, wiretag)
+                       b = appendVarint(b, uint64(len(buf)))
+                       b = append(b, buf...)
+                       return b, nil
+               }
+}
+
+func makeStdBytesValuePtrMarshaler(u *marshalInfo) (sizer, marshaler) {
+       return func(ptr pointer, tagsize int) int {
+                       if ptr.isNil() {
+                               return 0
+                       }
+                       t := ptr.asPointerTo(reflect.PtrTo(u.typ)).Elem().Interface().(*[]byte)
+                       v := &bytesValue{*t}
+                       siz := Size(v)
+                       return tagsize + SizeVarint(uint64(siz)) + siz
+               }, func(b []byte, ptr pointer, wiretag uint64, deterministic bool) ([]byte, error) {
+                       if ptr.isNil() {
+                               return b, nil
+                       }
+                       t := ptr.asPointerTo(reflect.PtrTo(u.typ)).Elem().Interface().(*[]byte)
+                       v := &bytesValue{*t}
+                       buf, err := Marshal(v)
+                       if err != nil {
+                               return nil, err
+                       }
+                       b = appendVarint(b, wiretag)
+                       b = appendVarint(b, uint64(len(buf)))
+                       b = append(b, buf...)
+                       return b, nil
+               }
+}
+
+func makeStdBytesValueSliceMarshaler(u *marshalInfo) (sizer, marshaler) {
+       return func(ptr pointer, tagsize int) int {
+                       s := ptr.getSlice(u.typ)
+                       n := 0
+                       for i := 0; i < s.Len(); i++ {
+                               elem := s.Index(i)
+                               t := elem.Interface().([]byte)
+                               v := &bytesValue{t}
+                               siz := Size(v)
+                               n += siz + SizeVarint(uint64(siz)) + tagsize
+                       }
+                       return n
+               },
+               func(b []byte, ptr pointer, wiretag uint64, deterministic bool) ([]byte, error) {
+                       s := ptr.getSlice(u.typ)
+                       for i := 0; i < s.Len(); i++ {
+                               elem := s.Index(i)
+                               t := elem.Interface().([]byte)
+                               v := &bytesValue{t}
+                               siz := Size(v)
+                               buf, err := Marshal(v)
+                               if err != nil {
+                                       return nil, err
+                               }
+                               b = appendVarint(b, wiretag)
+                               b = appendVarint(b, uint64(siz))
+                               b = append(b, buf...)
+                       }
+
+                       return b, nil
+               }
+}
+
+func makeStdBytesValuePtrSliceMarshaler(u *marshalInfo) (sizer, marshaler) {
+       return func(ptr pointer, tagsize int) int {
+                       s := ptr.getSlice(reflect.PtrTo(u.typ))
+                       n := 0
+                       for i := 0; i < s.Len(); i++ {
+                               elem := s.Index(i)
+                               t := elem.Interface().(*[]byte)
+                               v := &bytesValue{*t}
+                               siz := Size(v)
+                               n += siz + SizeVarint(uint64(siz)) + tagsize
+                       }
+                       return n
+               },
+               func(b []byte, ptr pointer, wiretag uint64, deterministic bool) ([]byte, error) {
+                       s := ptr.getSlice(reflect.PtrTo(u.typ))
+                       for i := 0; i < s.Len(); i++ {
+                               elem := s.Index(i)
+                               t := elem.Interface().(*[]byte)
+                               v := &bytesValue{*t}
+                               siz := Size(v)
+                               buf, err := Marshal(v)
+                               if err != nil {
+                                       return nil, err
+                               }
+                               b = appendVarint(b, wiretag)
+                               b = appendVarint(b, uint64(siz))
+                               b = append(b, buf...)
+                       }
+
+                       return b, nil
+               }
+}
+
+func makeStdBytesValueUnmarshaler(sub *unmarshalInfo, name string) unmarshaler {
+       return func(b []byte, f pointer, w int) ([]byte, error) {
+               if w != WireBytes {
+                       return nil, errInternalBadWireType
+               }
+               x, n := decodeVarint(b)
+               if n == 0 {
+                       return nil, io.ErrUnexpectedEOF
+               }
+               b = b[n:]
+               if x > uint64(len(b)) {
+                       return nil, io.ErrUnexpectedEOF
+               }
+               m := &bytesValue{}
+               if err := Unmarshal(b[:x], m); err != nil {
+                       return nil, err
+               }
+               s := f.asPointerTo(sub.typ).Elem()
+               s.Set(reflect.ValueOf(m.Value))
+               return b[x:], nil
+       }
+}
+
+func makeStdBytesValuePtrUnmarshaler(sub *unmarshalInfo, name string) unmarshaler {
+       return func(b []byte, f pointer, w int) ([]byte, error) {
+               if w != WireBytes {
+                       return nil, errInternalBadWireType
+               }
+               x, n := decodeVarint(b)
+               if n == 0 {
+                       return nil, io.ErrUnexpectedEOF
+               }
+               b = b[n:]
+               if x > uint64(len(b)) {
+                       return nil, io.ErrUnexpectedEOF
+               }
+               m := &bytesValue{}
+               if err := Unmarshal(b[:x], m); err != nil {
+                       return nil, err
+               }
+               s := f.asPointerTo(reflect.PtrTo(sub.typ)).Elem()
+               s.Set(reflect.ValueOf(&m.Value))
+               return b[x:], nil
+       }
+}
+
+func makeStdBytesValuePtrSliceUnmarshaler(sub *unmarshalInfo, name string) unmarshaler {
+       return func(b []byte, f pointer, w int) ([]byte, error) {
+               if w != WireBytes {
+                       return nil, errInternalBadWireType
+               }
+               x, n := decodeVarint(b)
+               if n == 0 {
+                       return nil, io.ErrUnexpectedEOF
+               }
+               b = b[n:]
+               if x > uint64(len(b)) {
+                       return nil, io.ErrUnexpectedEOF
+               }
+               m := &bytesValue{}
+               if err := Unmarshal(b[:x], m); err != nil {
+                       return nil, err
+               }
+               slice := f.getSlice(reflect.PtrTo(sub.typ))
+               newSlice := reflect.Append(slice, reflect.ValueOf(&m.Value))
+               slice.Set(newSlice)
+               return b[x:], nil
+       }
+}
+
+func makeStdBytesValueSliceUnmarshaler(sub *unmarshalInfo, name string) unmarshaler {
+       return func(b []byte, f pointer, w int) ([]byte, error) {
+               if w != WireBytes {
+                       return nil, errInternalBadWireType
+               }
+               x, n := decodeVarint(b)
+               if n == 0 {
+                       return nil, io.ErrUnexpectedEOF
+               }
+               b = b[n:]
+               if x > uint64(len(b)) {
+                       return nil, io.ErrUnexpectedEOF
+               }
+               m := &bytesValue{}
+               if err := Unmarshal(b[:x], m); err != nil {
+                       return nil, err
+               }
+               slice := f.getSlice(sub.typ)
+               newSlice := reflect.Append(slice, reflect.ValueOf(m.Value))
+               slice.Set(newSlice)
+               return b[x:], nil
+       }
+}

diff --git a/vendor/github.com/gogo/protobuf/proto/wrappers_gogo.go b/vendor/github.com/gogo/protobuf/proto/wrappers_gogo.go
new file mode 100644 (file)
index 0000000..c1cf7bf
--- /dev/null
+++ b/vendor/github.com/gogo/protobuf/proto/wrappers_gogo.go
@@ -0,0 +1,113 @@
+// Protocol Buffers for Go with Gadgets
+//
+// Copyright (c) 2018, The GoGo Authors. All rights reserved.
+// http://github.com/gogo/protobuf
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//     * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//     * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+package proto
+
+type float64Value struct {
+       Value float64 `protobuf:"fixed64,1,opt,name=value,proto3" json:"value,omitempty"`
+}
+
+func (m *float64Value) Reset()       { *m = float64Value{} }
+func (*float64Value) ProtoMessage()  {}
+func (*float64Value) String() string { return "float64<string>" }
+
+type float32Value struct {
+       Value float32 `protobuf:"fixed32,1,opt,name=value,proto3" json:"value,omitempty"`
+}
+
+func (m *float32Value) Reset()       { *m = float32Value{} }
+func (*float32Value) ProtoMessage()  {}
+func (*float32Value) String() string { return "float32<string>" }
+
+type int64Value struct {
+       Value int64 `protobuf:"varint,1,opt,name=value,proto3" json:"value,omitempty"`
+}
+
+func (m *int64Value) Reset()       { *m = int64Value{} }
+func (*int64Value) ProtoMessage()  {}
+func (*int64Value) String() string { return "int64<string>" }
+
+type uint64Value struct {
+       Value uint64 `protobuf:"varint,1,opt,name=value,proto3" json:"value,omitempty"`
+}
+
+func (m *uint64Value) Reset()       { *m = uint64Value{} }
+func (*uint64Value) ProtoMessage()  {}
+func (*uint64Value) String() string { return "uint64<string>" }
+
+type int32Value struct {
+       Value int32 `protobuf:"varint,1,opt,name=value,proto3" json:"value,omitempty"`
+}
+
+func (m *int32Value) Reset()       { *m = int32Value{} }
+func (*int32Value) ProtoMessage()  {}
+func (*int32Value) String() string { return "int32<string>" }
+
+type uint32Value struct {
+       Value uint32 `protobuf:"varint,1,opt,name=value,proto3" json:"value,omitempty"`
+}
+
+func (m *uint32Value) Reset()       { *m = uint32Value{} }
+func (*uint32Value) ProtoMessage()  {}
+func (*uint32Value) String() string { return "uint32<string>" }
+
+type boolValue struct {
+       Value bool `protobuf:"varint,1,opt,name=value,proto3" json:"value,omitempty"`
+}
+
+func (m *boolValue) Reset()       { *m = boolValue{} }
+func (*boolValue) ProtoMessage()  {}
+func (*boolValue) String() string { return "bool<string>" }
+
+type stringValue struct {
+       Value string `protobuf:"bytes,1,opt,name=value,proto3" json:"value,omitempty"`
+}
+
+func (m *stringValue) Reset()       { *m = stringValue{} }
+func (*stringValue) ProtoMessage()  {}
+func (*stringValue) String() string { return "string<string>" }
+
+type bytesValue struct {
+       Value []byte `protobuf:"bytes,1,opt,name=value,proto3" json:"value,omitempty"`
+}
+
+func (m *bytesValue) Reset()       { *m = bytesValue{} }
+func (*bytesValue) ProtoMessage()  {}
+func (*bytesValue) String() string { return "[]byte<string>" }
+
+func init() {
+       RegisterType((*float64Value)(nil), "gogo.protobuf.proto.DoubleValue")
+       RegisterType((*float32Value)(nil), "gogo.protobuf.proto.FloatValue")
+       RegisterType((*int64Value)(nil), "gogo.protobuf.proto.Int64Value")
+       RegisterType((*uint64Value)(nil), "gogo.protobuf.proto.UInt64Value")
+       RegisterType((*int32Value)(nil), "gogo.protobuf.proto.Int32Value")
+       RegisterType((*uint32Value)(nil), "gogo.protobuf.proto.UInt32Value")
+       RegisterType((*boolValue)(nil), "gogo.protobuf.proto.BoolValue")
+       RegisterType((*stringValue)(nil), "gogo.protobuf.proto.StringValue")
+       RegisterType((*bytesValue)(nil), "gogo.protobuf.proto.BytesValue")
+}

diff --git a/vendor/github.com/gxed/hashland/keccakpg/go.mod b/vendor/github.com/gxed/hashland/keccakpg/go.mod
new file mode 100644 (file)
index 0000000..da524d9
--- /dev/null
+++ b/vendor/github.com/gxed/hashland/keccakpg/go.mod
@@ -0,0 +1 @@
+module github.com/gxed/hashland/keccakpg

diff --git a/vendor/github.com/gxed/hashland/keccakpg/keccak.go b/vendor/github.com/gxed/hashland/keccakpg/keccak.go
new file mode 100644 (file)
index 0000000..e97a49a
--- /dev/null
+++ b/vendor/github.com/gxed/hashland/keccakpg/keccak.go
@@ -0,0 +1,224 @@
+// Package keccak implements the Keccak (SHA-3) hash algorithm.
+// http://keccak.noekeon.org.
+package keccakpg
+
+import (
+       _ "fmt"
+       "hash"
+)
+
+const stdRounds = 24
+
+var roundConstants = []uint64{
+       0x0000000000000001, 0x0000000000008082,
+       0x800000000000808A, 0x8000000080008000,
+       0x000000000000808B, 0x0000000080000001,
+       0x8000000080008081, 0x8000000000008009,
+       0x000000000000008A, 0x0000000000000088,
+       0x0000000080008009, 0x000000008000000A,
+       0x000000008000808B, 0x800000000000008B,
+       0x8000000000008089, 0x8000000000008003,
+       0x8000000000008002, 0x8000000000000080,
+       0x000000000000800A, 0x800000008000000A,
+       0x8000000080008081, 0x8000000000008080,
+       0x0000000080000001, 0x8000000080008008,
+}
+
+var rotationConstants = [24]uint{
+       1, 3, 6, 10, 15, 21, 28, 36,
+       45, 55, 2, 14, 27, 41, 56, 8,
+       25, 43, 62, 18, 39, 61, 20, 44,
+}
+
+var piLane = [24]uint{
+       10, 7, 11, 17, 18, 3, 5, 16,
+       8, 21, 24, 4, 15, 23, 19, 13,
+       12, 2, 20, 14, 22, 9, 6, 1,
+}
+
+type keccak struct {
+       S         [25]uint64
+       size      int
+       blockSize int
+       rounds    int
+       buf       []byte
+}
+
+func newKeccak(bitlen, rounds int) hash.Hash {
+       var h keccak
+       h.size = bitlen / 8
+       h.blockSize = (200 - 2*h.size)
+       h.rounds = rounds
+       if rounds != stdRounds {
+               //fmt.Printf("keccak: warning non standard number of rounds %d vs %d\n", rounds, stdRounds)
+       }
+       return &h
+}
+
+func NewCustom(bits, rounds int) hash.Hash {
+       return newKeccak(bits, rounds)
+}
+
+func New160() hash.Hash {
+       return newKeccak(160, stdRounds)
+}
+
+func New224() hash.Hash {
+       return newKeccak(224, stdRounds)
+}
+
+func New256() hash.Hash {
+       return newKeccak(256, stdRounds)
+}
+
+func New384() hash.Hash {
+       return newKeccak(384, stdRounds)
+}
+
+func New512() hash.Hash {
+       return newKeccak(512, stdRounds)
+}
+
+func (k *keccak) Write(b []byte) (int, error) {
+       n := len(b)
+
+       if len(k.buf) > 0 {
+               x := k.blockSize - len(k.buf)
+               if x > len(b) {
+                       x = len(b)
+               }
+               k.buf = append(k.buf, b[:x]...)
+               b = b[x:]
+
+               if len(k.buf) < k.blockSize {
+                       return n, nil
+               }
+
+               k.f(k.buf)
+               k.buf = nil
+       }
+
+       for len(b) >= k.blockSize {
+               k.f(b[:k.blockSize])
+               b = b[k.blockSize:]
+       }
+
+       k.buf = b
+
+       return n, nil
+}
+
+func (k0 *keccak) Sum(b []byte) []byte {
+
+       k := *k0
+
+       last := k.pad(k.buf)
+       k.f(last)
+
+       buf := make([]byte, len(k.S)*8)
+       for i := range k.S {
+               putUint64le(buf[i*8:], k.S[i])
+       }
+       return append(b, buf[:k.size]...)
+}
+
+func (k *keccak) Reset() {
+       for i := range k.S {
+               k.S[i] = 0
+       }
+       k.buf = nil
+}
+
+func (k *keccak) Size() int {
+       return k.size
+}
+
+func (k *keccak) BlockSize() int {
+       return k.blockSize
+}
+
+func rotl64(x uint64, n uint) uint64 {
+       return (x << n) | (x >> (64 - n))
+}
+
+func (k *keccak) f(block []byte) {
+
+       if len(block) != k.blockSize {
+               panic("f() called with invalid block size")
+       }
+
+       for i := 0; i < k.blockSize/8; i++ {
+               k.S[i] ^= uint64le(block[i*8:])
+       }
+
+       for r := 0; r < k.rounds; r++ {
+               var bc [5]uint64
+
+               // theta
+               for i := range bc {
+                       bc[i] = k.S[i] ^ k.S[5+i] ^ k.S[10+i] ^ k.S[15+i] ^ k.S[20+i]
+               }
+               for i := range bc {
+                       t := bc[(i+4)%5] ^ rotl64(bc[(i+1)%5], 1)
+                       for j := 0; j < len(k.S); j += 5 {
+                               k.S[i+j] ^= t
+                       }
+               }
+
+               // rho phi
+               temp := k.S[1]
+               for i := range piLane {
+                       j := piLane[i]
+                       temp2 := k.S[j]
+                       k.S[j] = rotl64(temp, rotationConstants[i])
+                       temp = temp2
+               }
+
+               // chi
+               for j := 0; j < len(k.S); j += 5 {
+                       for i := range bc {
+                               bc[i] = k.S[j+i]
+                       }
+                       for i := range bc {
+                               k.S[j+i] ^= (^bc[(i+1)%5]) & bc[(i+2)%5]
+                       }
+               }
+
+               // iota
+               k.S[0] ^= roundConstants[r]
+       }
+}
+
+func (k *keccak) pad(block []byte) []byte {
+
+       padded := make([]byte, k.blockSize)
+
+       copy(padded, k.buf)
+       padded[len(k.buf)] = 0x01
+       padded[len(padded)-1] |= 0x80
+
+       return padded
+}
+
+func uint64le(v []byte) uint64 {
+       return uint64(v[0]) |
+               uint64(v[1])<<8 |
+               uint64(v[2])<<16 |
+               uint64(v[3])<<24 |
+               uint64(v[4])<<32 |
+               uint64(v[5])<<40 |
+               uint64(v[6])<<48 |
+               uint64(v[7])<<56
+
+}
+
+func putUint64le(v []byte, x uint64) {
+       v[0] = byte(x)
+       v[1] = byte(x >> 8)
+       v[2] = byte(x >> 16)
+       v[3] = byte(x >> 24)
+       v[4] = byte(x >> 32)
+       v[5] = byte(x >> 40)
+       v[6] = byte(x >> 48)
+       v[7] = byte(x >> 56)
+}

diff --git a/vendor/github.com/gxed/hashland/keccakpg/keccak_test.go b/vendor/github.com/gxed/hashland/keccakpg/keccak_test.go
new file mode 100644 (file)
index 0000000..c3a3074
--- /dev/null
+++ b/vendor/github.com/gxed/hashland/keccakpg/keccak_test.go
@@ -0,0 +1,335 @@
+package keccakpg
+
+import (
+       "bytes"
+       "hash"
+       "math/rand"
+       "testing"
+)
+
+type test struct {
+       length int
+       input  []byte
+       output []byte
+}
+
+var tests = []test{
+       {
+               28,
+               []byte{},
+               []byte{
+                       0xf7, 0x18, 0x37, 0x50, 0x2b, 0xa8, 0xe1, 0x08,
+                       0x37, 0xbd, 0xd8, 0xd3, 0x65, 0xad, 0xb8, 0x55,
+                       0x91, 0x89, 0x56, 0x02, 0xfc, 0x55, 0x2b, 0x48,
+                       0xb7, 0x39, 0x0a, 0xbd,
+               },
+       }, {
+               28,
+               []byte("Keccak-224 Test Hash"),
+               []byte{
+                       0x30, 0x04, 0x5b, 0x34, 0x94, 0x6e, 0x1b, 0x2e,
+                       0x09, 0x16, 0x13, 0x36, 0x2f, 0xd2, 0x2a, 0xa0,
+                       0x8e, 0x2b, 0xea, 0xfe, 0xc5, 0xe8, 0xda, 0xee,
+                       0x42, 0xc2, 0xe6, 0x65},
+       }, {
+               32,
+               []byte{},
+               []byte{
+                       0xc5, 0xd2, 0x46, 0x01, 0x86, 0xf7, 0x23, 0x3c,
+                       0x92, 0x7e, 0x7d, 0xb2, 0xdc, 0xc7, 0x03, 0xc0,
+                       0xe5, 0x00, 0xb6, 0x53, 0xca, 0x82, 0x27, 0x3b,
+                       0x7b, 0xfa, 0xd8, 0x04, 0x5d, 0x85, 0xa4, 0x70,
+               },
+       }, {
+               32,
+               []byte("Keccak-256 Test Hash"),
+               []byte{
+                       0xa8, 0xd7, 0x1b, 0x07, 0xf4, 0xaf, 0x26, 0xa4,
+                       0xff, 0x21, 0x02, 0x7f, 0x62, 0xff, 0x60, 0x26,
+                       0x7f, 0xf9, 0x55, 0xc9, 0x63, 0xf0, 0x42, 0xc4,
+                       0x6d, 0xa5, 0x2e, 0xe3, 0xcf, 0xaf, 0x3d, 0x3c},
+       }, {
+               48,
+               []byte{},
+               []byte{
+                       0x2c, 0x23, 0x14, 0x6a, 0x63, 0xa2, 0x9a, 0xcf,
+                       0x99, 0xe7, 0x3b, 0x88, 0xf8, 0xc2, 0x4e, 0xaa,
+                       0x7d, 0xc6, 0x0a, 0xa7, 0x71, 0x78, 0x0c, 0xcc,
+                       0x00, 0x6a, 0xfb, 0xfa, 0x8f, 0xe2, 0x47, 0x9b,
+                       0x2d, 0xd2, 0xb2, 0x13, 0x62, 0x33, 0x74, 0x41,
+                       0xac, 0x12, 0xb5, 0x15, 0x91, 0x19, 0x57, 0xff,
+               },
+       }, {
+               48,
+               []byte("Keccak-384 Test Hash"),
+               []byte{
+                       0xe2, 0x13, 0xfd, 0x74, 0xaf, 0x0c, 0x5f, 0xf9,
+                       0x1b, 0x42, 0x3c, 0x8b, 0xce, 0xec, 0xd7, 0x01,
+                       0xf8, 0xdd, 0x64, 0xec, 0x18, 0xfd, 0x6f, 0x92,
+                       0x60, 0xfc, 0x9e, 0xc1, 0xed, 0xbd, 0x22, 0x30,
+                       0xa6, 0x90, 0x86, 0x65, 0xbc, 0xd9, 0xfb, 0xf4,
+                       0x1a, 0x99, 0xa1, 0x8a, 0x7d, 0x9e, 0x44, 0x6e},
+       }, {
+               64,
+               []byte{},
+               []byte{
+                       0x0e, 0xab, 0x42, 0xde, 0x4c, 0x3c, 0xeb, 0x92,
+                       0x35, 0xfc, 0x91, 0xac, 0xff, 0xe7, 0x46, 0xb2,
+                       0x9c, 0x29, 0xa8, 0xc3, 0x66, 0xb7, 0xc6, 0x0e,
+                       0x4e, 0x67, 0xc4, 0x66, 0xf3, 0x6a, 0x43, 0x04,
+                       0xc0, 0x0f, 0xa9, 0xca, 0xf9, 0xd8, 0x79, 0x76,
+                       0xba, 0x46, 0x9b, 0xcb, 0xe0, 0x67, 0x13, 0xb4,
+                       0x35, 0xf0, 0x91, 0xef, 0x27, 0x69, 0xfb, 0x16,
+                       0x0c, 0xda, 0xb3, 0x3d, 0x36, 0x70, 0x68, 0x0e,
+               },
+       }, {
+               64,
+               []byte("Keccak-512 Test Hash"),
+               []byte{
+                       0x96, 0xee, 0x47, 0x18, 0xdc, 0xba, 0x3c, 0x74,
+                       0x61, 0x9b, 0xa1, 0xfa, 0x7f, 0x57, 0xdf, 0xe7,
+                       0x76, 0x9d, 0x3f, 0x66, 0x98, 0xa8, 0xb3, 0x3f,
+                       0xa1, 0x01, 0x83, 0x89, 0x70, 0xa1, 0x31, 0xe6,
+                       0x21, 0xcc, 0xfd, 0x05, 0xfe, 0xff, 0xbc, 0x11,
+                       0x80, 0xf2, 0x63, 0xc2, 0x7f, 0x1a, 0xda, 0xb4,
+                       0x60, 0x95, 0xd6, 0xf1, 0x25, 0x33, 0x14, 0x72,
+                       0x4b, 0x5c, 0xbf, 0x78, 0x28, 0x65, 0x8e, 0x6a,
+               },
+       },
+}
+
+func TestKeccak(t *testing.T) {
+       for i := range tests {
+               var h hash.Hash
+
+               switch tests[i].length {
+               case 28:
+                       h = New224()
+               case 32:
+                       h = New256()
+               case 48:
+                       h = New384()
+               case 64:
+                       h = New512()
+               default:
+                       panic("invalid testcase")
+               }
+
+               h.Write(tests[i].input)
+
+               d := h.Sum(nil)
+               if !bytes.Equal(d, tests[i].output) {
+                       t.Errorf("testcase %d: expected %x got %x", i, tests[i].output, d)
+               }
+       }
+}
+
+type testcase struct {
+       msg       []byte
+       output224 []byte
+       output256 []byte
+       output384 []byte
+       output512 []byte
+}
+
+func TestKeccakShort224(t *testing.T) {
+       for i := range tstShort {
+               h := New224()
+               h.Write(tstShort[i].msg)
+               d := h.Sum(nil)
+               if !bytes.Equal(d, tstShort[i].output224) {
+                       t.Errorf("testcase Short224 %d: expected %x got %x", i, tstShort[i].output224, d)
+               }
+       }
+}
+
+func TestKeccakShort256(t *testing.T) {
+       for i := range tstShort {
+               h := New256()
+               h.Write(tstShort[i].msg)
+               d := h.Sum(nil)
+               if !bytes.Equal(d, tstShort[i].output256) {
+                       t.Errorf("testcase Short256 %d: expected %x got %x", i, tstShort[i].output256, d)
+               }
+       }
+}
+
+func TestKeccakShort384(t *testing.T) {
+       for i := range tstShort {
+               h := New384()
+               h.Write(tstShort[i].msg)
+               d := h.Sum(nil)
+               if !bytes.Equal(d, tstShort[i].output384) {
+                       t.Errorf("testcase Short384 %d: expected %x got %x", i, tstShort[i].output384, d)
+               }
+       }
+}
+
+func TestKeccakShort512(t *testing.T) {
+       for i := range tstShort {
+               h := New512()
+               h.Write(tstShort[i].msg)
+               d := h.Sum(nil)
+               if !bytes.Equal(d, tstShort[i].output512) {
+                       t.Errorf("testcase Short512 %d: expected %x got %x", i, tstShort[i].output512, d)
+               }
+       }
+}
+
+func TestKeccakLong224(t *testing.T) {
+       for i := range tstLong {
+               h := New224()
+               h.Write(tstLong[i].msg)
+               d := h.Sum(nil)
+               if !bytes.Equal(d, tstLong[i].output224) {
+                       t.Errorf("testcase Long224 %d: expected %x got %x", i, tstLong[i].output224, d)
+               }
+       }
+}
+
+func TestKeccakLong256(t *testing.T) {
+       for i := range tstLong {
+               h := New256()
+               h.Write(tstLong[i].msg)
+               d := h.Sum(nil)
+               if !bytes.Equal(d, tstLong[i].output256) {
+                       t.Errorf("testcase Long256 %d: expected %x got %x", i, tstLong[i].output256, d)
+               }
+       }
+}
+
+func TestKeccakLong384(t *testing.T) {
+       for i := range tstLong {
+               h := New384()
+               h.Write(tstLong[i].msg)
+               d := h.Sum(nil)
+               if !bytes.Equal(d, tstLong[i].output384) {
+                       t.Errorf("testcase Long384 %d: expected %x got %x", i, tstLong[i].output384, d)
+               }
+       }
+}
+
+func TestKeccakLong512(t *testing.T) {
+       for i := range tstLong {
+               h := New512()
+               h.Write(tstLong[i].msg)
+               d := h.Sum(nil)
+               if !bytes.Equal(d, tstLong[i].output512) {
+                       t.Errorf("testcase Long512 %d: expected %x got %x", i, tstLong[i].output512, d)
+               }
+       }
+}
+
+const BUF_SIZE = 1048576
+
+var buf = func() []byte {
+    result := make([]byte, BUF_SIZE)
+    rand.Seed(0xDEADBEEF)
+    for i := range result {
+        result[i] = byte(rand.Int())
+    }
+    return result
+}()
+
+func BenchmarkKeccak224Write1MiB(b *testing.B) {
+    for i := 0; i < b.N; i++ {
+        b.StopTimer()
+        h := New224()
+        b.StartTimer()
+        h.Write(buf)
+    }
+}
+
+func BenchmarkKeccak224Sum(b *testing.B) {
+    b.StopTimer()
+    h := New224()
+    h.Write(buf)
+    b.StartTimer()
+    for i := 0; i < b.N; i++ {
+        b.StopTimer()
+        h0 := h
+        b.StartTimer()
+        h0.Sum(nil)
+    }
+}
+
+func BenchmarkKeccak224Real(b *testing.B) {
+    b.StopTimer()
+    b.SetBytes(int64(b.N*8))
+    bs := make([]byte, 8, 8)
+    h := New224()
+    b.StartTimer()
+    for i := 0; i < b.N; i++ {
+       h.Reset()
+               bs[0], bs[1], bs[2], bs[3], bs[4], bs[5], bs[6], bs[7] = byte(i), byte(i>>8), byte(i>>16), byte(i>>24), byte(i>>32), byte(i>>40), byte(i>>48), byte(i>>56)
+               h.Write(bs)
+        h.Sum(nil)
+    }
+}
+
+func BenchmarkKeccak256Write1MiB(b *testing.B) {
+    for i := 0; i < b.N; i++ {
+        b.StopTimer()
+        h := New224()
+        b.StartTimer()
+        h.Write(buf)
+    }
+}
+
+func BenchmarkKeccak256Sum(b *testing.B) {
+    b.StopTimer()
+    h := New256()
+    h.Write(buf)
+    b.StartTimer()
+    for i := 0; i < b.N; i++ {
+        b.StopTimer()
+        h1 := h
+        b.StartTimer()
+        h1.Sum(nil)
+    }
+}
+
+func BenchmarkKeccak384Write1MiB(b *testing.B) {
+    for i := 0; i < b.N; i++ {
+        b.StopTimer()
+        h := New384()
+        b.StartTimer()
+        h.Write(buf)
+    }
+}
+
+func BenchmarkKeccak384Sum(b *testing.B) {
+    b.StopTimer()
+    h := New384()
+    h.Write(buf)
+    b.StartTimer()
+    for i := 0; i < b.N; i++ {
+        b.StopTimer()
+        h0 := h
+        b.StartTimer()
+        h0.Sum(nil)
+    }
+}
+
+func BenchmarkKeccak512Write1MiB(b *testing.B) {
+    for i := 0; i < b.N; i++ {
+        b.StopTimer()
+        h := New512()
+        b.StartTimer()
+        h.Write(buf)
+    }
+}
+
+func BenchmarkKeccak512Sum(b *testing.B) {
+    b.StopTimer()
+    h := New512()
+    h.Write(buf)
+    b.StartTimer()
+    for i := 0; i < b.N; i++ {
+        b.StopTimer()
+        h0 := h
+        b.StartTimer()
+        h0.Sum(nil)
+    }
+}
+

diff --git a/vendor/github.com/gxed/hashland/keccakpg/keccak_vectors_test.go b/vendor/github.com/gxed/hashland/keccakpg/keccak_vectors_test.go
new file mode 100644 (file)
index 0000000..84fb33c
--- /dev/null
+++ b/vendor/github.com/gxed/hashland/keccakpg/keccak_vectors_test.go
@@ -0,0 +1,1929 @@
+package keccakpg
+
+// extracted from ShortMsgKAT_{224,256,384,512}.txt
+var tstShort = []testcase{
+       testcase{
+               msg:       []byte{0xcc},
+               output224: []byte{0xa9, 0xca, 0xb5, 0x9e, 0xb4, 0xa, 0x10, 0xb2, 0x46, 0x29, 0xf, 0x2d, 0x60, 0x86, 0xe3, 0x2e, 0x36, 0x89, 0xfa, 0xf1, 0xd2, 0x6b, 0x47, 0xc, 0x89, 0x9f, 0x28, 0x2},
+               output256: []byte{0xee, 0xad, 0x6d, 0xbf, 0xc7, 0x34, 0xa, 0x56, 0xca, 0xed, 0xc0, 0x44, 0x69, 0x6a, 0x16, 0x88, 0x70, 0x54, 0x9a, 0x6a, 0x7f, 0x6f, 0x56, 0x96, 0x1e, 0x84, 0xa5, 0x4b, 0xd9, 0x97, 0xb, 0x8a},
+               output384: []byte{0x1b, 0x84, 0xe6, 0x2a, 0x46, 0xe5, 0xa2, 0x1, 0x86, 0x17, 0x54, 0xaf, 0x5d, 0xc9, 0x5c, 0x4a, 0x1a, 0x69, 0xca, 0xf4, 0xa7, 0x96, 0xae, 0x40, 0x56, 0x80, 0x16, 0x1e, 0x29, 0x57, 0x26, 0x41, 0xf5, 0xfa, 0x1e, 0x86, 0x41, 0xd7, 0x95, 0x83, 0x36, 0xee, 0x7b, 0x11, 0xc5, 0x8f, 0x73, 0xe9},
+               output512: []byte{0x86, 0x30, 0xc1, 0x3c, 0xbd, 0x6, 0x6e, 0xa7, 0x4b, 0xbe, 0x7f, 0xe4, 0x68, 0xfe, 0xc1, 0xde, 0xe1, 0xe, 0xdc, 0x12, 0x54, 0xfb, 0x4c, 0x1b, 0x7c, 0x5f, 0xd6, 0x9b, 0x64, 0x6e, 0x44, 0x16, 0xb, 0x8c, 0xe0, 0x1d, 0x5, 0xa0, 0x90, 0x8c, 0xa7, 0x90, 0xdf, 0xb0, 0x80, 0xf4, 0xb5, 0x13, 0xbc, 0x3b, 0x62, 0x25, 0xec, 0xe7, 0xa8, 0x10, 0x37, 0x14, 0x41, 0xa5, 0xac, 0x66, 0x6e, 0xb9}},
+       testcase{
+               msg:       []byte{0x41, 0xfb},
+               output224: []byte{0x61, 0x5b, 0xa3, 0x67, 0xaf, 0xdc, 0x35, 0xaa, 0xc3, 0x97, 0xbc, 0x7e, 0xb5, 0xd5, 0x8d, 0x10, 0x6a, 0x73, 0x4b, 0x24, 0x98, 0x6d, 0x5d, 0x97, 0x8f, 0xef, 0xd6, 0x2c},
+               output256: []byte{0xa8, 0xea, 0xce, 0xda, 0x4d, 0x47, 0xb3, 0x28, 0x1a, 0x79, 0x5a, 0xd9, 0xe1, 0xea, 0x21, 0x22, 0xb4, 0x7, 0xba, 0xf9, 0xaa, 0xbc, 0xb9, 0xe1, 0x8b, 0x57, 0x17, 0xb7, 0x87, 0x35, 0x37, 0xd2},
+               output384: []byte{0x49, 0x5c, 0xce, 0x27, 0x14, 0xcd, 0x72, 0xc8, 0xc5, 0x3c, 0x33, 0x63, 0xd2, 0x2c, 0x58, 0xb5, 0x59, 0x60, 0xfe, 0x26, 0xbe, 0xb, 0xf3, 0xbb, 0xc7, 0xa3, 0x31, 0x6d, 0xd5, 0x63, 0xad, 0x1d, 0xb8, 0x41, 0xe, 0x75, 0xee, 0xfe, 0xa6, 0x55, 0xe3, 0x9d, 0x46, 0x70, 0xec, 0xb, 0x17, 0x92},
+               output512: []byte{0x55, 0x1d, 0xa6, 0x23, 0x6f, 0x8b, 0x96, 0xfc, 0xe9, 0xf9, 0x7f, 0x11, 0x90, 0xe9, 0x1, 0x32, 0x4f, 0xb, 0x45, 0xe0, 0x6d, 0xbb, 0xb5, 0xcd, 0xb8, 0x35, 0x5d, 0x6e, 0xd1, 0xdc, 0x34, 0xb3, 0xf0, 0xea, 0xe7, 0xdc, 0xb6, 0x86, 0x22, 0xff, 0x23, 0x2f, 0xa3, 0xce, 0xce, 0xd, 0x46, 0x16, 0xcd, 0xeb, 0x39, 0x31, 0xf9, 0x38, 0x3, 0x66, 0x2a, 0x28, 0xdf, 0x1c, 0xd5, 0x35, 0xb7, 0x31}},
+       testcase{
+               msg:       []byte{0x1f, 0x87, 0x7c},
+               output224: []byte{0x6f, 0x9d, 0x28, 0x98, 0xef, 0xd0, 0x96, 0xba, 0xaa, 0xaa, 0xb2, 0xe9, 0x74, 0x82, 0xdd, 0xb6, 0x38, 0x9b, 0x8e, 0x6c, 0xaa, 0x96, 0x4b, 0x7a, 0xe, 0x34, 0x7e, 0x13},
+               output256: []byte{0x62, 0x7d, 0x7b, 0xc1, 0x49, 0x1b, 0x2a, 0xb1, 0x27, 0x28, 0x28, 0x27, 0xb8, 0xde, 0x2d, 0x27, 0x6b, 0x13, 0xd7, 0xd7, 0xf, 0xb4, 0xc5, 0x95, 0x7f, 0xdf, 0x20, 0x65, 0x5b, 0xc7, 0xac, 0x30},
+               output384: []byte{0xb0, 0x66, 0x5c, 0x34, 0x5f, 0x45, 0xe6, 0xde, 0x14, 0x5b, 0x1, 0x90, 0x33, 0x5e, 0xf5, 0xd5, 0xaa, 0x59, 0xe0, 0xb4, 0x9f, 0xc1, 0x42, 0x5d, 0x5e, 0xae, 0x73, 0x55, 0xea, 0x44, 0x22, 0x84, 0xcb, 0x8a, 0x21, 0x52, 0xd5, 0x65, 0xeb, 0xdf, 0x28, 0x10, 0xec, 0xca, 0xb1, 0x5a, 0xf0, 0x4f},
+               output512: []byte{0xeb, 0x7f, 0x2a, 0x98, 0xe0, 0xa, 0xf3, 0x7d, 0x96, 0x4f, 0x7d, 0x8c, 0x44, 0xc1, 0xfb, 0x6e, 0x11, 0x4d, 0x8e, 0xe2, 0x1a, 0x7b, 0x97, 0x6a, 0xe7, 0x36, 0x53, 0x9e, 0xfd, 0xc1, 0xe3, 0xfe, 0x43, 0xbe, 0xce, 0xf5, 0x1, 0x51, 0x71, 0xe6, 0xda, 0x30, 0x16, 0x8c, 0xae, 0x99, 0xa8, 0x2c, 0x53, 0xfa, 0x99, 0x4, 0x27, 0x74, 0xef, 0x98, 0x2c, 0x1, 0x62, 0x6a, 0x54, 0xf, 0x8, 0xc0}},
+       testcase{
+               msg:       []byte{0xc1, 0xec, 0xfd, 0xfc},
+               output224: []byte{0xe4, 0x5, 0x86, 0x9d, 0xa1, 0x46, 0x4a, 0x70, 0x57, 0x0, 0xa3, 0xcb, 0xce, 0x13, 0x1a, 0xab, 0xee, 0xba, 0x9c, 0x8d, 0x2f, 0xe6, 0x57, 0x6b, 0x21, 0xbc, 0xbe, 0x16},
+               output256: []byte{0xb1, 0x49, 0xe7, 0x66, 0xd7, 0x61, 0x2e, 0xaf, 0x7d, 0x55, 0xf7, 0x4e, 0x1a, 0x4f, 0xdd, 0x63, 0x70, 0x9a, 0x81, 0x15, 0xb1, 0x4f, 0x61, 0xfc, 0xd2, 0x2a, 0xa4, 0xab, 0xc8, 0xb8, 0xe1, 0x22},
+               output384: []byte{0xf1, 0x85, 0xb, 0x2a, 0xbb, 0x24, 0xf3, 0xfd, 0x68, 0x3c, 0x70, 0x15, 0x82, 0x78, 0x9d, 0x9e, 0x92, 0xb6, 0xa4, 0x5f, 0x9c, 0x34, 0x5f, 0x9d, 0xae, 0x7f, 0x79, 0x97, 0xc8, 0xc9, 0x10, 0xe8, 0x80, 0x3, 0xe5, 0x92, 0xe5, 0x92, 0x81, 0xcf, 0x92, 0xc9, 0x2d, 0x6b, 0x51, 0xa1, 0xaf, 0xd1},
+               output512: []byte{0x95, 0x2d, 0x4c, 0xa, 0x6f, 0xe, 0xf5, 0xce, 0x43, 0x8c, 0x52, 0xe3, 0xed, 0xd3, 0x45, 0xea, 0x0, 0xf9, 0x1c, 0xf5, 0xda, 0x80, 0x97, 0xc1, 0x16, 0x8a, 0x16, 0x6, 0x9e, 0x95, 0x8f, 0xc0, 0x5b, 0xad, 0x90, 0xa0, 0xc5, 0xfb, 0x4d, 0xd9, 0xec, 0x28, 0xe8, 0x4b, 0x22, 0x6b, 0x94, 0xa8, 0x47, 0xd6, 0xbb, 0x89, 0x23, 0x56, 0x92, 0xef, 0x4c, 0x97, 0x12, 0xf0, 0xc7, 0x3, 0xf, 0xae}},
+       testcase{
+               msg:       []byte{0x21, 0xf1, 0x34, 0xac, 0x57},
+               output224: []byte{0x55, 0x73, 0xda, 0x2b, 0x2, 0x21, 0x6a, 0x86, 0x3, 0x89, 0xa5, 0x81, 0xf6, 0xe9, 0xfb, 0x8d, 0x80, 0x5e, 0x9e, 0x2, 0xf6, 0xfa, 0x91, 0x17, 0x1, 0xee, 0xe2, 0x98},
+               output256: []byte{0x67, 0xf0, 0x55, 0x44, 0xdb, 0xe9, 0x7d, 0x5d, 0x64, 0x17, 0xc1, 0xb1, 0xea, 0x9b, 0xc0, 0xe3, 0xa9, 0x9a, 0x54, 0x13, 0x81, 0xd1, 0xcd, 0x9b, 0x8, 0xa9, 0x76, 0x56, 0x87, 0xeb, 0x5b, 0xb4},
+               output384: []byte{0x68, 0xd4, 0x37, 0x32, 0x7f, 0x15, 0x82, 0x87, 0xc3, 0x4, 0xbb, 0xaf, 0x36, 0xf7, 0x82, 0xf4, 0x97, 0xda, 0x2c, 0x48, 0xa, 0x1f, 0xbb, 0x26, 0x86, 0x82, 0x36, 0x22, 0x18, 0x64, 0x1f, 0x90, 0x70, 0xa0, 0x14, 0x91, 0x9a, 0xd7, 0x33, 0x1c, 0x49, 0xbe, 0xef, 0xcc, 0xb4, 0x37, 0xfe, 0x9a},
+               output512: []byte{0x2e, 0x76, 0xd9, 0x3a, 0xff, 0xd6, 0x2b, 0x92, 0xfc, 0x4f, 0x29, 0xcb, 0x83, 0xef, 0xbe, 0x4b, 0xa2, 0x1d, 0x88, 0x42, 0x6a, 0xa7, 0xf0, 0x75, 0xbf, 0xc2, 0x9, 0x60, 0xea, 0x25, 0x87, 0x87, 0x89, 0x81, 0x72, 0xe1, 0x70, 0x45, 0xaf, 0x43, 0xab, 0x1f, 0xe4, 0x45, 0x53, 0x2b, 0xe0, 0x18, 0x5f, 0xbe, 0xa8, 0x4d, 0x9b, 0xe7, 0x88, 0xb0, 0x5f, 0x14, 0xdb, 0xf4, 0x85, 0x6a, 0x52, 0x54}},
+       testcase{
+               msg:       []byte{0xc6, 0xf5, 0xb, 0xb7, 0x4e, 0x29},
+               output224: []byte{0x16, 0x3c, 0x90, 0x60, 0x16, 0x3a, 0xa6, 0x6b, 0x8b, 0x7c, 0xc, 0xfa, 0xa6, 0x5d, 0x93, 0x4b, 0xff, 0x21, 0x9b, 0xcb, 0xc2, 0x67, 0x18, 0x7c, 0xab, 0xa0, 0x4, 0x2f},
+               output256: []byte{0x92, 0x30, 0x62, 0xc4, 0xe6, 0xf0, 0x57, 0x59, 0x72, 0x20, 0xd1, 0x82, 0xdb, 0xb1, 0xe, 0x81, 0xcd, 0x25, 0xf6, 0xb, 0x54, 0x0, 0x5b, 0x2a, 0x75, 0xdd, 0x33, 0xd6, 0xda, 0xc5, 0x18, 0xd0},
+               output384: []byte{0x3, 0x56, 0x6e, 0xc0, 0x3, 0xff, 0x55, 0x18, 0x4f, 0xc, 0x85, 0xbe, 0xeb, 0xc6, 0xd1, 0xec, 0xf5, 0xe5, 0xd0, 0x82, 0xd8, 0xd4, 0x1, 0x37, 0x24, 0x6f, 0x8f, 0xd4, 0x2b, 0xce, 0x9, 0x7c, 0x9, 0x41, 0x88, 0x45, 0xef, 0x60, 0x28, 0x6f, 0xdd, 0x89, 0x4a, 0x0, 0xfd, 0x2d, 0x65, 0x89},
+               output512: []byte{0x40, 0xfa, 0x80, 0x74, 0xe1, 0xe5, 0x9, 0xb2, 0x6, 0x44, 0x8f, 0xbe, 0x75, 0x7d, 0x94, 0x94, 0xb9, 0xb5, 0x1e, 0x8d, 0x6e, 0x67, 0x4a, 0x67, 0xf5, 0x3c, 0x11, 0xef, 0x92, 0xe9, 0x6c, 0x3e, 0xa0, 0x8b, 0x95, 0xeb, 0xd4, 0x17, 0x2b, 0x2, 0x0, 0x10, 0xcd, 0x6c, 0xf2, 0x95, 0x39, 0xa3, 0x4d, 0x6b, 0xfa, 0x0, 0x2a, 0x20, 0x42, 0x78, 0x7a, 0xa8, 0xd8, 0x79, 0xa0, 0xf5, 0xb5, 0x4c}},
+       testcase{
+               msg:       []byte{0x11, 0x97, 0x13, 0xcc, 0x83, 0xee, 0xef},
+               output224: []byte{0xcf, 0xc0, 0x4c, 0x6f, 0x84, 0x63, 0xdd, 0xab, 0x24, 0xcd, 0xf8, 0xb8, 0x65, 0x2b, 0xd1, 0x1d, 0xf2, 0x3d, 0xd1, 0xb9, 0x5f, 0x11, 0x83, 0x28, 0xdd, 0x1, 0x58, 0xe},
+               output256: []byte{0xfe, 0xb8, 0x40, 0x5d, 0xcd, 0x31, 0x5d, 0x48, 0xc6, 0xcb, 0xf7, 0xa3, 0x50, 0x49, 0x96, 0xde, 0x8e, 0x25, 0xcc, 0x22, 0x56, 0x6e, 0xfe, 0xc6, 0x74, 0x33, 0x71, 0x2e, 0xda, 0x99, 0x89, 0x4f},
+               output384: []byte{0x79, 0xd, 0x70, 0xf, 0xa3, 0x4d, 0x6a, 0x83, 0x5b, 0xe3, 0x11, 0xb6, 0x39, 0x47, 0x47, 0x80, 0x14, 0x8a, 0x2f, 0x8, 0x7a, 0xc2, 0xfa, 0x86, 0xe8, 0xa1, 0xa4, 0x33, 0xec, 0x7a, 0x4, 0xfc, 0xbf, 0xc5, 0x28, 0x4a, 0x3e, 0x18, 0x8b, 0x7d, 0x91, 0xc6, 0xd0, 0x94, 0xea, 0xfb, 0xee, 0xcb},
+               output512: []byte{0xd1, 0x11, 0x67, 0x86, 0xa3, 0xc1, 0xea, 0x46, 0xa8, 0xf2, 0x2d, 0x82, 0xab, 0xb4, 0xc5, 0xd0, 0x6d, 0xc0, 0x69, 0x1b, 0x2e, 0x74, 0x7a, 0xc9, 0x72, 0x6d, 0xb, 0x29, 0xe, 0x69, 0x59, 0xf7, 0xb2, 0x34, 0x28, 0x51, 0x9a, 0x65, 0x6b, 0x23, 0x76, 0x95, 0xe5, 0x64, 0x3, 0x85, 0x5e, 0xc4, 0xc9, 0x8d, 0xb0, 0xcf, 0x87, 0xf3, 0x1b, 0x6c, 0xea, 0xbf, 0x2b, 0x9b, 0x85, 0x89, 0xb7, 0x13}},
+       testcase{
+               msg:       []byte{0x4a, 0x4f, 0x20, 0x24, 0x84, 0x51, 0x25, 0x26},
+               output224: []byte{0x7a, 0x5c, 0x2c, 0xb3, 0xf9, 0x99, 0xdd, 0x0, 0xef, 0xf7, 0x39, 0x99, 0x63, 0x31, 0x4c, 0xa6, 0x47, 0xdd, 0xe, 0x5a, 0xe1, 0xbd, 0xde, 0xc6, 0x11, 0xf8, 0x33, 0x8d},
+               output256: []byte{0xe6, 0x20, 0xd8, 0xf2, 0x98, 0x2b, 0x24, 0xfe, 0xda, 0xaa, 0x3b, 0xaa, 0x9b, 0x46, 0xc3, 0xf9, 0xce, 0x20, 0x4e, 0xe3, 0x56, 0x66, 0x65, 0x53, 0xec, 0xb3, 0x5e, 0x15, 0xc3, 0xff, 0x9b, 0xf9},
+               output384: []byte{0x63, 0x8e, 0x65, 0x75, 0x8a, 0x29, 0x7c, 0xb0, 0x9d, 0xed, 0x1a, 0xc5, 0xb9, 0xe8, 0xf7, 0x79, 0x80, 0x20, 0x0, 0xab, 0x79, 0x1f, 0x67, 0xf3, 0x3c, 0x60, 0xbe, 0x36, 0x44, 0x37, 0x93, 0xad, 0xcc, 0x8a, 0x4a, 0x58, 0xe9, 0x86, 0x88, 0x15, 0x7a, 0x41, 0x78, 0x4f, 0x2, 0xa4, 0xbc, 0xb2},
+               output512: []byte{0xf3, 0x26, 0xc7, 0xc1, 0x26, 0xdd, 0xc2, 0x77, 0x92, 0x27, 0x60, 0xfe, 0xef, 0x77, 0xc9, 0xba, 0xb6, 0xfb, 0x5d, 0x34, 0x30, 0xf6, 0x52, 0x59, 0x37, 0x3, 0xd7, 0xc5, 0xe3, 0x1, 0x35, 0xcd, 0xb, 0x5, 0x75, 0x25, 0x75, 0x9, 0xa6, 0x24, 0x18, 0x43, 0x30, 0xd6, 0xab, 0x1f, 0x50, 0x8a, 0x66, 0x63, 0x91, 0xb5, 0xd4, 0x69, 0x4, 0x26, 0xb4, 0xe0, 0x53, 0x1, 0x89, 0x1d, 0xf8, 0x97}},
+       testcase{
+               msg:       []byte{0x1f, 0x66, 0xab, 0x41, 0x85, 0xed, 0x9b, 0x63, 0x75},
+               output224: []byte{0xa5, 0xa7, 0x58, 0x6, 0x8, 0x3a, 0xa9, 0x30, 0x70, 0x74, 0xef, 0x8f, 0xbd, 0x7d, 0xf5, 0x92, 0x98, 0x5e, 0x5f, 0x71, 0x46, 0x11, 0xe8, 0x12, 0x21, 0x6c, 0x4, 0x49},
+               output256: []byte{0x9e, 0x3, 0xf7, 0xc9, 0xa3, 0xd0, 0x55, 0xec, 0xa1, 0xd7, 0x86, 0xed, 0x6f, 0xb6, 0x24, 0xd9, 0x3f, 0x1c, 0xf0, 0xac, 0x27, 0xf9, 0xc2, 0xb6, 0xc0, 0x5e, 0x50, 0x9f, 0xac, 0x9e, 0x7f, 0xca},
+               output384: []byte{0x30, 0x8e, 0xc6, 0xf2, 0xee, 0x3f, 0x6e, 0x1, 0xfb, 0x3a, 0xa0, 0x6e, 0xb7, 0xc8, 0xca, 0xdd, 0x19, 0x93, 0x54, 0x75, 0x1b, 0x69, 0xfd, 0x4b, 0xa4, 0xd4, 0x67, 0x18, 0x58, 0xf2, 0x8b, 0xb4, 0x5c, 0x94, 0xe7, 0x12, 0xad, 0x9d, 0x35, 0x6f, 0xcb, 0x44, 0x30, 0x67, 0xef, 0x5a, 0xca, 0x2d},
+               output512: []byte{0x1f, 0x5b, 0x8a, 0x6e, 0x8d, 0x94, 0xf5, 0xe2, 0x53, 0x5d, 0x46, 0x84, 0x2b, 0x9c, 0xed, 0x46, 0x7c, 0x39, 0xc2, 0xdb, 0x32, 0x39, 0x63, 0xd3, 0xf3, 0xd9, 0x37, 0xe9, 0xdd, 0xa7, 0x6f, 0xbc, 0x17, 0x7, 0x2d, 0xda, 0x2a, 0xb4, 0x77, 0x1c, 0xd7, 0xa6, 0x45, 0x14, 0x5a, 0x2a, 0xec, 0x1b, 0x57, 0x49, 0xbf, 0x9e, 0xfe, 0xc, 0xde, 0x0, 0x6c, 0xc3, 0xef, 0x89, 0x36, 0x43, 0x8e, 0xd}},
+       testcase{
+               msg:       []byte{0xee, 0xd7, 0x42, 0x22, 0x27, 0x61, 0x3b, 0x6f, 0x53, 0xc9},
+               output224: []byte{0xac, 0x78, 0xfc, 0x53, 0xa1, 0xdb, 0x90, 0xa6, 0x34, 0xf1, 0xaa, 0xaf, 0x90, 0x11, 0x9c, 0x88, 0x9c, 0x8c, 0x24, 0xb5, 0x9b, 0x98, 0xb7, 0x36, 0x60, 0x29, 0xcc, 0x73},
+               output256: []byte{0xca, 0xad, 0x8e, 0x1e, 0xd5, 0x46, 0x63, 0x7, 0x48, 0xa1, 0x2f, 0x53, 0x51, 0xb5, 0x18, 0xa9, 0xa4, 0x31, 0xcd, 0xa6, 0xba, 0x56, 0xcb, 0xfc, 0x3c, 0xcb, 0xdd, 0x8a, 0xae, 0x50, 0x92, 0xf7},
+               output384: []byte{0xa8, 0x8f, 0x2f, 0xd1, 0x12, 0xe5, 0xf1, 0x1e, 0x77, 0x5a, 0xa7, 0x85, 0x8a, 0x3a, 0x52, 0x2, 0xe8, 0xfc, 0xd2, 0x59, 0xf5, 0xd1, 0x12, 0xba, 0xa6, 0xf5, 0x68, 0x24, 0xd, 0x2e, 0xcc, 0x4, 0x7e, 0xad, 0x88, 0x50, 0x9e, 0x4b, 0x8a, 0x74, 0x7d, 0x37, 0x7, 0x51, 0xff, 0xb2, 0xfd, 0xc0},
+               output512: []byte{0x2a, 0xee, 0xe7, 0xa7, 0x20, 0xc0, 0x30, 0xa8, 0x20, 0xcd, 0x7b, 0xaa, 0x85, 0x70, 0xd7, 0x2c, 0xb9, 0xb, 0x7a, 0x23, 0x8c, 0x38, 0xc3, 0x58, 0x67, 0x63, 0x58, 0xa7, 0xae, 0x9a, 0x5c, 0xf2, 0x66, 0x35, 0xb2, 0x32, 0xd, 0x61, 0xc1, 0x28, 0x48, 0x99, 0xe6, 0x54, 0xf0, 0xbf, 0xdd, 0xa, 0x3a, 0x9c, 0x34, 0x3f, 0xfb, 0xd1, 0x18, 0x38, 0xb5, 0x74, 0x65, 0xe6, 0xc3, 0xad, 0x3a, 0x57}},
+       testcase{
+               msg:       []byte{0xea, 0xee, 0xd5, 0xcd, 0xff, 0xd8, 0x9d, 0xec, 0xe4, 0x55, 0xf1},
+               output224: []byte{0x67, 0x2c, 0xa6, 0x82, 0x66, 0x86, 0xbe, 0xdb, 0x25, 0x85, 0x32, 0x83, 0xd, 0x60, 0x6b, 0x25, 0x8c, 0x6d, 0xe6, 0x1, 0x54, 0xec, 0x9, 0x57, 0xcd, 0x8b, 0x85, 0x8b},
+               output256: []byte{0xd6, 0x17, 0x8, 0xbd, 0xb3, 0x21, 0x1a, 0x9a, 0xab, 0x28, 0xd4, 0xdf, 0x1, 0xdf, 0xa4, 0xb2, 0x9e, 0xd4, 0x2, 0x85, 0x84, 0x4d, 0x84, 0x10, 0x42, 0x25, 0x7e, 0x97, 0x48, 0x86, 0x17, 0xb0},
+               output384: []byte{0xa2, 0x2a, 0x31, 0x34, 0x9d, 0x78, 0x16, 0x54, 0x5b, 0xe3, 0x1b, 0x80, 0xe9, 0x92, 0xbd, 0xbb, 0x62, 0xa2, 0x94, 0x80, 0x91, 0x7c, 0xea, 0xbd, 0xa, 0xf5, 0xf2, 0xfa, 0xfb, 0xf2, 0x76, 0xd4, 0xc2, 0x9b, 0x63, 0xa0, 0x49, 0x10, 0xb8, 0x30, 0xb8, 0x75, 0x7c, 0x81, 0xe2, 0x23, 0xb7, 0xf9},
+               output512: []byte{0x7b, 0x1c, 0x1b, 0xef, 0x3b, 0x4d, 0xeb, 0x4b, 0x48, 0x12, 0xc8, 0x1a, 0x6e, 0x7b, 0x3f, 0x2c, 0x66, 0xfa, 0x95, 0x15, 0x7f, 0xa3, 0xb9, 0xd2, 0x95, 0x9d, 0xc5, 0x6b, 0x8a, 0xdd, 0x10, 0x1, 0x70, 0xd3, 0xc8, 0xd1, 0x74, 0x5f, 0xd2, 0x30, 0xa3, 0x1f, 0x89, 0xfa, 0x17, 0x88, 0x9c, 0x4c, 0x58, 0x94, 0x6b, 0x5d, 0x74, 0x6e, 0x47, 0xb7, 0x1e, 0xd0, 0x39, 0x4b, 0x66, 0xd1, 0xbd, 0xb2}},
+       testcase{
+               msg:       []byte{0x5b, 0xe4, 0x3c, 0x90, 0xf2, 0x29, 0x2, 0xe4, 0xfe, 0x8e, 0xd2, 0xd3},
+               output224: []byte{0xd9, 0x8c, 0xa0, 0x7e, 0x17, 0x2b, 0xb, 0xc5, 0x3d, 0x67, 0x9d, 0x2f, 0x8d, 0x0, 0x2c, 0x63, 0xfd, 0x24, 0xa6, 0x30, 0x7f, 0x2b, 0x7e, 0x1e, 0xee, 0xf2, 0x8b, 0xe0},
+               output256: []byte{0xf, 0x53, 0xbe, 0x55, 0x99, 0x7, 0x80, 0xb3, 0xfa, 0xd9, 0x87, 0xf, 0x4, 0xf7, 0xd8, 0x15, 0x3c, 0x3a, 0xe6, 0x5, 0xc0, 0x57, 0xc8, 0x5a, 0xbb, 0x5d, 0x71, 0x76, 0x50, 0x43, 0xaa, 0xa8},
+               output384: []byte{0x36, 0xca, 0x9c, 0xc3, 0x29, 0xf9, 0xa0, 0xf, 0xaa, 0x5f, 0x4f, 0x21, 0x17, 0xa, 0x1, 0x77, 0x42, 0x17, 0x4d, 0x3c, 0xf0, 0x3c, 0x8, 0x4a, 0xeb, 0x75, 0x9f, 0x6f, 0xa0, 0x39, 0x3, 0x49, 0xe1, 0xb5, 0x2, 0xe4, 0x35, 0xcf, 0xfb, 0xb, 0xce, 0x4e, 0xd4, 0x6c, 0x0, 0x12, 0xa6, 0x5c},
+               output512: []byte{0xee, 0x41, 0x40, 0x1a, 0xf5, 0x9, 0xd6, 0xfc, 0x9, 0x44, 0xcd, 0x4a, 0xb, 0xb2, 0x9d, 0x2d, 0xce, 0xd, 0xcc, 0x86, 0x26, 0x6, 0xe6, 0x69, 0xe3, 0x13, 0x81, 0xe5, 0xd6, 0xce, 0xcb, 0x46, 0x31, 0x43, 0x64, 0x5d, 0x69, 0x6d, 0x14, 0xe4, 0x1, 0x69, 0xcd, 0xc7, 0x1c, 0x75, 0x68, 0x6d, 0x6e, 0x87, 0x32, 0xb4, 0x32, 0x9, 0x26, 0x26, 0x42, 0x1c, 0xc6, 0xcc, 0x19, 0x6f, 0x80, 0xbf}},
+       testcase{
+               msg:       []byte{0xa7, 0x46, 0x27, 0x32, 0x28, 0x12, 0x2f, 0x38, 0x1c, 0x3b, 0x46, 0xe4, 0xf1},
+               output224: []byte{0xf1, 0x22, 0xbe, 0x39, 0xc9, 0x1a, 0x6c, 0x17, 0xcd, 0x59, 0x0, 0xf5, 0x31, 0xe6, 0x80, 0xd5, 0x4c, 0xed, 0xef, 0xd4, 0xf0, 0xe3, 0xd1, 0x13, 0xd2, 0x65, 0x43, 0xd4},
+               output256: []byte{0x32, 0x21, 0x5a, 0xe8, 0x82, 0x4, 0xa7, 0x82, 0xb6, 0x2d, 0x18, 0x10, 0xd9, 0x45, 0xde, 0x49, 0x94, 0x8d, 0xe4, 0x58, 0x60, 0xf, 0x5e, 0x1e, 0x38, 0x96, 0xce, 0xca, 0x2e, 0xd3, 0x29, 0x2b},
+               output384: []byte{0x3d, 0xa5, 0x49, 0x76, 0xb2, 0x91, 0xdf, 0x77, 0xf1, 0xb, 0xf9, 0x5e, 0x9b, 0x7e, 0xf9, 0xfb, 0x2f, 0x88, 0xde, 0x7, 0x5d, 0xdf, 0x66, 0x50, 0xba, 0x78, 0x85, 0x90, 0xf4, 0xe2, 0xe3, 0xc8, 0x30, 0xd3, 0xb7, 0xdf, 0xc0, 0x19, 0x36, 0x56, 0xb0, 0xa1, 0x85, 0xe3, 0xaa, 0xd9, 0xaa, 0x5a},
+               output512: []byte{0x9b, 0x53, 0xb4, 0x10, 0xb9, 0xf5, 0xdc, 0xe9, 0xa, 0x77, 0x24, 0x4d, 0xb4, 0x7, 0xa3, 0xd0, 0xf4, 0x89, 0x8d, 0x11, 0x2d, 0x0, 0x44, 0xa8, 0xf6, 0x6a, 0xf9, 0x33, 0xe2, 0x66, 0x66, 0xde, 0x63, 0xeb, 0xd2, 0xa4, 0x32, 0x2d, 0x8f, 0xe5, 0x25, 0xab, 0x35, 0x4c, 0xe9, 0x67, 0x6b, 0x6a, 0x14, 0xd0, 0xce, 0x6b, 0x3d, 0x24, 0xe6, 0xcd, 0x58, 0x32, 0xbe, 0xa0, 0xc5, 0x15, 0x3c, 0xef}},
+       testcase{
+               msg:       []byte{0x3c, 0x58, 0x71, 0xcd, 0x61, 0x9c, 0x69, 0xa6, 0x3b, 0x54, 0xe, 0xb5, 0xa6, 0x25},
+               output224: []byte{0x2a, 0x26, 0xd2, 0xad, 0x20, 0x15, 0xc6, 0x7c, 0xab, 0xb7, 0x89, 0x5e, 0xc5, 0xfa, 0x25, 0x47, 0x3d, 0x4d, 0x14, 0x33, 0xfa, 0xe9, 0x2b, 0x9b, 0x2c, 0xda, 0x31, 0xf0},
+               output256: []byte{0x95, 0x10, 0xda, 0x68, 0xe5, 0x8e, 0xbb, 0x8d, 0x2a, 0xb9, 0xde, 0x84, 0x85, 0xbb, 0x40, 0x8e, 0x35, 0x82, 0x99, 0xa9, 0xc0, 0x11, 0xae, 0x85, 0x44, 0xb0, 0xd0, 0xfa, 0xf9, 0xd4, 0xa4, 0xea},
+               output384: []byte{0xd2, 0x1a, 0x7c, 0xf2, 0x52, 0x35, 0x8a, 0x11, 0x59, 0xa5, 0x59, 0x34, 0x45, 0x6e, 0x67, 0xd9, 0xe1, 0xda, 0x53, 0x8d, 0x4e, 0x9f, 0x9f, 0x1a, 0xce, 0x2f, 0xd7, 0x5f, 0x30, 0x74, 0xb2, 0x7a, 0xe2, 0xb3, 0x56, 0x14, 0x4b, 0xda, 0x7b, 0xa0, 0xb1, 0xec, 0xa1, 0xaa, 0x20, 0x1b, 0x20, 0xde},
+               output512: []byte{0x2b, 0x53, 0xfe, 0x65, 0x83, 0xfc, 0x24, 0xee, 0x8a, 0x63, 0x80, 0x10, 0x67, 0xe4, 0xd3, 0xbd, 0x6e, 0x69, 0x34, 0xef, 0x16, 0xbc, 0x82, 0x2f, 0xc3, 0xa6, 0x9f, 0x4e, 0xe1, 0x3a, 0x40, 0x4d, 0x9a, 0x3c, 0xe2, 0xbb, 0x4a, 0x12, 0xc7, 0x73, 0x82, 0xbf, 0xde, 0x4d, 0x84, 0x3f, 0x87, 0xfd, 0x6, 0xed, 0x8a, 0xec, 0xc2, 0x34, 0xa3, 0xa2, 0x4c, 0xed, 0xfe, 0x60, 0xbf, 0xc0, 0x69, 0x33}},
+       testcase{
+               msg:       []byte{0xfa, 0x22, 0x87, 0x4b, 0xcc, 0x6, 0x88, 0x79, 0xe8, 0xef, 0x11, 0xa6, 0x9f, 0x7, 0x22},
+               output224: []byte{0xa6, 0x9e, 0x4e, 0xc1, 0x64, 0x8c, 0xbb, 0xd5, 0x95, 0x55, 0x8e, 0xe4, 0xea, 0x34, 0x5e, 0x41, 0x96, 0xc2, 0x88, 0x1e, 0x85, 0xe8, 0x53, 0x73, 0x9b, 0x1f, 0x46, 0x4},
+               output256: []byte{0xf2, 0xb, 0x3b, 0xcf, 0x74, 0x3a, 0xa6, 0xfa, 0x8, 0x40, 0x38, 0x52, 0x7, 0x91, 0xc3, 0x64, 0xcb, 0x6d, 0x3d, 0x1d, 0xd7, 0x58, 0x41, 0xf8, 0xd7, 0x2, 0x1c, 0xd9, 0x83, 0x22, 0xbd, 0x8f},
+               output384: []byte{0x8a, 0xc, 0x63, 0x31, 0x42, 0x93, 0x75, 0xf0, 0x52, 0x96, 0xa, 0xff, 0xf6, 0xd5, 0xfe, 0x33, 0x75, 0x9f, 0x97, 0x14, 0x5d, 0x60, 0xb2, 0x62, 0xbe, 0xde, 0x86, 0xd5, 0x25, 0x49, 0x94, 0x55, 0x8f, 0xc1, 0x80, 0xa, 0xdd, 0x9, 0xd6, 0x88, 0x7c, 0x27, 0x5f, 0x4d, 0xd3, 0x53, 0x1c, 0xb0},
+               output512: []byte{0x80, 0x94, 0x6c, 0xa6, 0x8e, 0x8c, 0x16, 0xa9, 0x66, 0x7c, 0xd8, 0x33, 0x9d, 0x1c, 0x5b, 0x0, 0xf1, 0xe0, 0xd4, 0x1, 0xd0, 0xec, 0xc7, 0x94, 0x58, 0x75, 0x47, 0x94, 0x83, 0x8f, 0x3a, 0xe2, 0x94, 0x9a, 0x8c, 0xc5, 0xfe, 0x55, 0x84, 0x3, 0x3b, 0xca, 0x9c, 0x5b, 0xe6, 0x2c, 0x7c, 0x8, 0xf4, 0x2, 0xef, 0x2, 0xf7, 0x27, 0xce, 0xfa, 0x43, 0xbb, 0xd3, 0x74, 0xc2, 0xa6, 0x7c, 0x52}},
+       testcase{
+               msg:       []byte{0x52, 0xa6, 0x8, 0xab, 0x21, 0xcc, 0xdd, 0x8a, 0x44, 0x57, 0xa5, 0x7e, 0xde, 0x78, 0x21, 0x76},
+               output224: []byte{0x56, 0x79, 0xcd, 0x50, 0x9c, 0x51, 0x20, 0xaf, 0x54, 0x79, 0x5c, 0xf4, 0x77, 0x14, 0x96, 0x41, 0xcf, 0x27, 0xb2, 0xeb, 0xb6, 0xa5, 0xf9, 0x3, 0x40, 0x70, 0x4e, 0x57},
+               output256: []byte{0xe, 0x32, 0xde, 0xfa, 0x20, 0x71, 0xf0, 0xb5, 0xac, 0xe, 0x6a, 0x10, 0x8b, 0x84, 0x2e, 0xd0, 0xf1, 0xd3, 0x24, 0x97, 0x12, 0xf5, 0x8e, 0xe0, 0xdd, 0xf9, 0x56, 0xfe, 0x33, 0x2a, 0x5f, 0x95},
+               output384: []byte{0x18, 0x42, 0x2a, 0xc1, 0xd3, 0xa1, 0xe5, 0x4b, 0xad, 0x87, 0x68, 0x83, 0xd2, 0xd6, 0xdd, 0x65, 0xf6, 0x5c, 0x1d, 0x5f, 0x33, 0xa7, 0x12, 0x5c, 0xc4, 0xc1, 0x86, 0x40, 0x5a, 0x12, 0xed, 0x64, 0xba, 0x96, 0x67, 0x2e, 0xed, 0xda, 0x8c, 0x5a, 0x63, 0x31, 0xd2, 0x86, 0x83, 0xf4, 0x88, 0xeb},
+               output512: []byte{0x4b, 0x39, 0xd3, 0xda, 0x5b, 0xcd, 0xf4, 0xd9, 0xb7, 0x69, 0x1, 0x59, 0x95, 0x64, 0x43, 0x11, 0xc1, 0x4c, 0x43, 0x5b, 0xf7, 0x2b, 0x10, 0x9, 0xd6, 0xdd, 0x71, 0xb0, 0x1a, 0x63, 0xb9, 0x7c, 0xfb, 0x59, 0x64, 0x18, 0xe8, 0xe4, 0x23, 0x42, 0xd1, 0x17, 0xe0, 0x74, 0x71, 0xa8, 0x91, 0x43, 0x14, 0xba, 0x7b, 0xe, 0x26, 0x4d, 0xad, 0xf0, 0xce, 0xa3, 0x81, 0x86, 0x8c, 0xbd, 0x43, 0xd1}},
+       testcase{
+               msg:       []byte{0x82, 0xe1, 0x92, 0xe4, 0x4, 0x3d, 0xdc, 0xd1, 0x2e, 0xcf, 0x52, 0x96, 0x9d, 0xf, 0x80, 0x7e, 0xed},
+               output224: []byte{0x45, 0x55, 0x84, 0xa1, 0xa3, 0xbb, 0xfb, 0xb9, 0x77, 0xae, 0x8, 0xdd, 0xee, 0x93, 0xda, 0x5a, 0xca, 0xe0, 0xf2, 0xf4, 0xc3, 0xcd, 0xaa, 0xf0, 0x89, 0x72, 0x8a, 0xae},
+               output256: []byte{0x92, 0x4, 0x55, 0x6, 0x77, 0xb9, 0xaa, 0x77, 0xe, 0x6e, 0x93, 0xe3, 0x19, 0xb9, 0x95, 0x85, 0x40, 0xd5, 0x4f, 0xf4, 0xdc, 0xcb, 0x6, 0x3c, 0x85, 0x61, 0x30, 0x2c, 0xd8, 0xaf, 0xf6, 0x76},
+               output384: []byte{0x4a, 0x59, 0xda, 0x5, 0xc6, 0xe0, 0x35, 0xd5, 0x9d, 0x93, 0xf5, 0x59, 0xd4, 0xa1, 0x30, 0xd3, 0xed, 0x91, 0xc2, 0x2e, 0xad, 0xa5, 0x3f, 0xd6, 0x79, 0xfb, 0xb, 0xf, 0x31, 0x39, 0x8a, 0x6f, 0xf8, 0x3a, 0x5a, 0x97, 0x39, 0xbf, 0xd4, 0xe9, 0x5f, 0x57, 0x31, 0x8f, 0xcc, 0xb8, 0x16, 0xf0},
+               output512: []byte{0xc3, 0x7c, 0x9d, 0xc2, 0xe2, 0xd, 0x8e, 0x2f, 0xa, 0xe5, 0x88, 0xd7, 0xd4, 0x5a, 0x80, 0x7c, 0xcf, 0xa0, 0x0, 0xfc, 0x94, 0x8a, 0xc4, 0x2a, 0x8e, 0xd6, 0x3b, 0xb1, 0x4f, 0x31, 0x8f, 0xc3, 0xd4, 0xb9, 0x63, 0xf7, 0x30, 0x59, 0x80, 0xe6, 0xa0, 0xfd, 0x23, 0x16, 0xb5, 0x5b, 0x63, 0x14, 0x23, 0x73, 0xb1, 0xa2, 0x90, 0x2, 0x26, 0x48, 0x55, 0xc7, 0x16, 0xc5, 0xc9, 0xf1, 0x7f, 0x4c}},
+       testcase{
+               msg:       []byte{0x75, 0x68, 0x3d, 0xcb, 0x55, 0x61, 0x40, 0xc5, 0x22, 0x54, 0x3b, 0xb6, 0xe9, 0x9, 0x8b, 0x21, 0xa2, 0x1e},
+               output224: []byte{0xbb, 0x77, 0x9e, 0x72, 0x67, 0xca, 0xf0, 0xe8, 0x91, 0x54, 0x7e, 0xe3, 0xe3, 0xba, 0xbf, 0x17, 0x83, 0x76, 0x71, 0xcf, 0x73, 0x1e, 0xd5, 0x63, 0x34, 0xf6, 0x1c, 0xc3},
+               output256: []byte{0xa6, 0xd5, 0x44, 0x4c, 0xb7, 0xaa, 0x61, 0xf5, 0x10, 0x6c, 0xde, 0xdb, 0x39, 0xd5, 0xe1, 0xdd, 0x7d, 0x60, 0x8f, 0x10, 0x27, 0x98, 0xd7, 0xe8, 0x18, 0xac, 0x87, 0x28, 0x91, 0x23, 0xa1, 0xdb},
+               output384: []byte{0x98, 0xe6, 0xbc, 0xca, 0x5f, 0x2b, 0xb3, 0xc, 0x55, 0x47, 0x0, 0x20, 0x2e, 0x6, 0x4, 0xf7, 0xc8, 0x6b, 0x49, 0x41, 0xf0, 0x34, 0x53, 0x25, 0x10, 0xc, 0x83, 0xb1, 0x23, 0x4c, 0x45, 0x85, 0x6d, 0xfa, 0x76, 0x1e, 0x70, 0xdc, 0xd9, 0x72, 0xec, 0xb1, 0x24, 0x7a, 0xea, 0xc2, 0x92, 0x59},
+               output512: []byte{0x90, 0x73, 0xc6, 0x25, 0x55, 0xe6, 0x9, 0x5f, 0x17, 0xdf, 0x71, 0xad, 0x2, 0xba, 0xbb, 0x91, 0x0, 0x28, 0x86, 0x33, 0x89, 0x84, 0x89, 0xb2, 0x1c, 0x90, 0x6a, 0x31, 0x90, 0x87, 0x5b, 0xae, 0xac, 0xcc, 0x83, 0xbe, 0x80, 0xab, 0xd1, 0x14, 0x66, 0xfe, 0xc3, 0x71, 0xba, 0x2c, 0x46, 0x23, 0xd0, 0x7f, 0x1, 0x31, 0xde, 0xfa, 0xec, 0x13, 0xa8, 0xc7, 0x32, 0xa9, 0xf8, 0x41, 0x71, 0x63}},
+       testcase{
+               msg:       []byte{0x6, 0xe4, 0xef, 0xe4, 0x50, 0x35, 0xe6, 0x1f, 0xaa, 0xf4, 0x28, 0x7b, 0x4d, 0x8d, 0x1f, 0x12, 0xca, 0x97, 0xe5},
+               output224: []byte{0xe7, 0xb1, 0x81, 0xda, 0xec, 0x13, 0x2d, 0x3b, 0x6c, 0x9d, 0xfb, 0xf6, 0x18, 0x41, 0x13, 0x5b, 0x87, 0xfb, 0x99, 0x5b, 0xe2, 0x9, 0x57, 0xb8, 0xcd, 0x9, 0x5e, 0x2b},
+               output256: []byte{0x57, 0x96, 0xb9, 0x93, 0xd0, 0xbd, 0x12, 0x57, 0xcf, 0x26, 0x78, 0x2b, 0x4e, 0x58, 0xfa, 0xfb, 0x22, 0xb0, 0x98, 0x6d, 0x88, 0x68, 0x4a, 0xb5, 0xa2, 0xe6, 0xce, 0xc6, 0x70, 0x62, 0x75, 0xf9},
+               output384: []byte{0xd3, 0xc3, 0xd7, 0x6b, 0x3d, 0x39, 0x26, 0xfd, 0x4c, 0xc4, 0xc0, 0x5a, 0x8, 0x7c, 0x2d, 0x76, 0x99, 0x29, 0x98, 0xa5, 0xcd, 0x8c, 0x13, 0xfa, 0x3d, 0x23, 0x3e, 0xe, 0xcb, 0x2a, 0xd8, 0xb8, 0x1b, 0xa4, 0xbe, 0x58, 0x1e, 0x2, 0xbe, 0x91, 0xc7, 0xf8, 0x2c, 0xca, 0xc9, 0x0, 0x13, 0xa0},
+               output512: []byte{0x23, 0xe9, 0x35, 0x28, 0x56, 0x71, 0x8e, 0x1e, 0x2d, 0x68, 0xa2, 0x1d, 0x56, 0xd9, 0x31, 0x17, 0xce, 0xd7, 0x62, 0x8e, 0x98, 0x4f, 0xf0, 0x4e, 0xd8, 0xc0, 0xcb, 0x9b, 0x10, 0x53, 0x9e, 0x4e, 0xde, 0x28, 0x4f, 0x94, 0xfa, 0x71, 0xbf, 0x4b, 0x83, 0xbb, 0xb4, 0x93, 0x43, 0x5f, 0xd6, 0xbe, 0x26, 0xed, 0xdb, 0x9, 0xde, 0xac, 0x39, 0x68, 0xe, 0x6b, 0x5, 0xac, 0xc8, 0x7b, 0x8c, 0x4e}},
+       testcase{
+               msg:       []byte{0xe2, 0x61, 0x93, 0x98, 0x9d, 0x6, 0x56, 0x8f, 0xe6, 0x88, 0xe7, 0x55, 0x40, 0xae, 0xa0, 0x67, 0x47, 0xd9, 0xf8, 0x51},
+               output224: []byte{0x44, 0x72, 0x96, 0x46, 0xa0, 0x5a, 0xd0, 0x50, 0x3a, 0x87, 0x6b, 0x44, 0x8f, 0x88, 0xf1, 0x77, 0xa0, 0xa2, 0x63, 0xab, 0x74, 0x6c, 0xa6, 0xe3, 0x6, 0x76, 0xad, 0xb2},
+               output256: []byte{0xcf, 0xbe, 0x73, 0xc6, 0x58, 0x5b, 0xe6, 0x20, 0x4d, 0xd4, 0x73, 0xab, 0xe3, 0x56, 0xb5, 0x39, 0x47, 0x71, 0x74, 0xc4, 0xb7, 0x70, 0xbf, 0xc9, 0x1e, 0x9f, 0xdb, 0xcb, 0xc5, 0x70, 0x86, 0xe6},
+               output384: []byte{0x7c, 0x53, 0xda, 0x6, 0x0, 0x58, 0x18, 0x3c, 0xa6, 0x20, 0x4e, 0x77, 0xf0, 0x70, 0x9a, 0xeb, 0xef, 0x73, 0x55, 0x7c, 0x8f, 0x5e, 0x45, 0xc1, 0x95, 0xb7, 0xe9, 0x41, 0x6e, 0x72, 0x61, 0x36, 0x5d, 0x3, 0xb8, 0xa2, 0xd6, 0xc0, 0x1a, 0x10, 0x26, 0x55, 0x34, 0x4e, 0x72, 0x54, 0x75, 0xc4},
+               output512: []byte{0x90, 0x9d, 0x75, 0x34, 0x26, 0xb1, 0xde, 0xe0, 0x9f, 0xc4, 0x74, 0xf1, 0x8c, 0xf8, 0x10, 0xd5, 0xd5, 0xaa, 0xdb, 0xf8, 0xa0, 0x9a, 0xf4, 0x95, 0xbf, 0x6c, 0x22, 0xac, 0xa0, 0xc6, 0x73, 0x2, 0x1b, 0xfc, 0x5d, 0x2a, 0xd9, 0x4f, 0x50, 0xb2, 0x4e, 0x15, 0x69, 0xe9, 0x56, 0x69, 0x4b, 0x21, 0xcf, 0x2c, 0xc8, 0xb4, 0xf3, 0xc7, 0xee, 0x4c, 0xf1, 0x95, 0xe4, 0x42, 0x4c, 0xc4, 0x15, 0xdd}},
+       testcase{
+               msg:       []byte{0xd8, 0xdc, 0x8f, 0xde, 0xfb, 0xdc, 0xe9, 0xd4, 0x4e, 0x4c, 0xba, 0xfe, 0x78, 0x44, 0x7b, 0xae, 0x3b, 0x54, 0x36, 0x10, 0x2a},
+               output224: []byte{0x5, 0xe1, 0x57, 0x93, 0xe4, 0x17, 0xdd, 0x4e, 0x2, 0xcd, 0x6c, 0x56, 0x36, 0xd4, 0x2c, 0x16, 0x38, 0xc1, 0x64, 0xd7, 0xb, 0x79, 0xf7, 0x17, 0xf2, 0x5d, 0x1a, 0x15},
+               output256: []byte{0x31, 0xc8, 0x0, 0x6b, 0xe, 0xc3, 0x5e, 0x69, 0x6, 0x74, 0x29, 0x7c, 0xb2, 0x74, 0x76, 0xdb, 0x60, 0x66, 0xb5, 0xfa, 0x98, 0x25, 0xc6, 0x7, 0x28, 0xe9, 0xe0, 0xbb, 0x33, 0x8f, 0xb7, 0xc3},
+               output384: []byte{0x24, 0x15, 0xc1, 0xd0, 0x53, 0xca, 0x20, 0x7c, 0x17, 0xd9, 0x9d, 0x2, 0xdb, 0xd1, 0x77, 0xcd, 0x1a, 0xa7, 0xf0, 0xb, 0xd, 0xc, 0xa2, 0xcf, 0x30, 0xb4, 0xd2, 0x9, 0x8e, 0xea, 0x1a, 0x4, 0xa6, 0x8e, 0x5b, 0x1c, 0x6d, 0xf2, 0xfb, 0x25, 0xec, 0xe1, 0x57, 0xc4, 0x23, 0xee, 0x8a, 0xb7},
+               output512: []byte{0x4, 0x6c, 0x60, 0x19, 0xfc, 0x4d, 0x62, 0x8a, 0xe0, 0xda, 0x70, 0x92, 0xf9, 0x91, 0xf, 0x26, 0x9b, 0x85, 0x3d, 0x3b, 0x57, 0x5, 0x20, 0x39, 0xad, 0x13, 0x75, 0xc6, 0x65, 0x40, 0x5f, 0x9f, 0xd7, 0x9d, 0x57, 0x57, 0x9f, 0x42, 0xc4, 0xff, 0xf2, 0x49, 0xbb, 0x85, 0xae, 0x65, 0x11, 0x3a, 0x9f, 0x42, 0x76, 0xce, 0xde, 0x73, 0xe9, 0xcc, 0xb0, 0xc2, 0x47, 0x53, 0x93, 0x5a, 0x0, 0x6e}},
+       testcase{
+               msg:       []byte{0x57, 0x8, 0x5f, 0xd7, 0xe1, 0x42, 0x16, 0xab, 0x10, 0x2d, 0x83, 0x17, 0xb0, 0xcb, 0x33, 0x8a, 0x78, 0x6d, 0x5f, 0xc3, 0x2d, 0x8f},
+               output224: []byte{0x2c, 0x40, 0x77, 0xa8, 0x85, 0x89, 0x66, 0xef, 0x79, 0xaa, 0xc3, 0xec, 0x6d, 0x82, 0x85, 0x5e, 0xad, 0x22, 0x86, 0x7b, 0xa4, 0x5d, 0x61, 0x7a, 0x68, 0xcb, 0x92, 0x6e},
+               output256: []byte{0x3b, 0x8f, 0xa3, 0x90, 0x4f, 0xe1, 0xb8, 0x37, 0x56, 0x5a, 0x50, 0xd0, 0xfb, 0xf0, 0x3e, 0x48, 0x7d, 0x6d, 0x72, 0xfc, 0x3c, 0xea, 0x41, 0xad, 0xcc, 0xe3, 0x3d, 0xf1, 0xb8, 0x35, 0xd2, 0x47},
+               output384: []byte{0x90, 0xda, 0x42, 0xb0, 0xc3, 0x14, 0x44, 0x5e, 0xaf, 0xd8, 0x65, 0x6b, 0x26, 0x64, 0x4a, 0xdd, 0xed, 0xdc, 0x71, 0x3e, 0xab, 0x36, 0x28, 0x9b, 0xff, 0xc6, 0xed, 0x4a, 0x85, 0xbe, 0x66, 0xa1, 0xf, 0x5a, 0xcd, 0x6b, 0x3c, 0x61, 0xe9, 0xc3, 0x6a, 0x17, 0xc2, 0x62, 0x60, 0x87, 0x2d, 0xc8},
+               output512: []byte{0x51, 0xc9, 0x9, 0xa6, 0x52, 0x89, 0x49, 0xba, 0xdd, 0xaf, 0x1b, 0xa0, 0xb1, 0x54, 0xea, 0x9c, 0x33, 0xfd, 0xe5, 0x7, 0x43, 0x59, 0x50, 0x5b, 0x76, 0xd4, 0xb7, 0xed, 0x54, 0x35, 0x2d, 0xd8, 0x93, 0xd4, 0xb, 0x14, 0x2a, 0x5f, 0x80, 0x2f, 0x37, 0x8c, 0xba, 0x7b, 0x8c, 0x37, 0x82, 0xec, 0xf2, 0xa0, 0x48, 0x54, 0x2b, 0xe6, 0xc5, 0x93, 0x68, 0x22, 0x21, 0x48, 0x46, 0xa8, 0xd5, 0xe4}},
+       testcase{
+               msg:       []byte{0xa0, 0x54, 0x4, 0xdf, 0x5d, 0xbb, 0x57, 0x69, 0x7e, 0x2c, 0x16, 0xfa, 0x29, 0xde, 0xfa, 0xc8, 0xab, 0x35, 0x60, 0xd6, 0x12, 0x6f, 0xa0},
+               output224: []byte{0x2e, 0x89, 0x7b, 0x47, 0x9f, 0xbc, 0xbf, 0x42, 0xd2, 0x13, 0x9f, 0x67, 0x68, 0xdf, 0x14, 0x7a, 0x3b, 0x85, 0xc3, 0x6a, 0x5b, 0x3f, 0x3c, 0x6, 0x6e, 0xb0, 0x56, 0x5e},
+               output256: []byte{0x37, 0xfe, 0xbc, 0x4d, 0xf9, 0xd5, 0xd, 0xae, 0xab, 0xd0, 0xca, 0xa6, 0x57, 0x88, 0x12, 0xa6, 0x87, 0xe5, 0x5f, 0x1a, 0xc0, 0xb1, 0x9, 0xd2, 0x51, 0x28, 0x10, 0xd0, 0x5, 0x48, 0xc8, 0x5b},
+               output384: []byte{0xee, 0x20, 0x9e, 0x98, 0xa7, 0x5a, 0x67, 0xb0, 0x90, 0x8, 0x20, 0x2c, 0xad, 0x38, 0x9, 0x17, 0xeb, 0x1f, 0x92, 0xc5, 0xdb, 0x4e, 0x8f, 0x2c, 0x64, 0x90, 0xa, 0xf8, 0xc6, 0x3, 0xd2, 0x65, 0xca, 0xb3, 0x17, 0xbf, 0x7b, 0x8e, 0x22, 0x51, 0xe4, 0x79, 0xf8, 0x81, 0x8d, 0x30, 0x22, 0xca},
+               output512: []byte{0xef, 0xc8, 0x91, 0x7e, 0x12, 0x47, 0x74, 0x2a, 0x2d, 0x4e, 0xc2, 0x9a, 0xfe, 0xdd, 0xf1, 0xe6, 0xec, 0xe3, 0x77, 0xb3, 0xd8, 0xac, 0x6e, 0x58, 0xc9, 0x85, 0x1c, 0xe9, 0xc9, 0x9b, 0xd5, 0x99, 0xad, 0xeb, 0xfe, 0xd6, 0x57, 0xba, 0xac, 0xd1, 0x79, 0x3f, 0xc9, 0x1b, 0x4, 0xdf, 0x29, 0x57, 0xbf, 0x6f, 0x18, 0x88, 0x86, 0x92, 0x86, 0x0, 0x2d, 0xc4, 0xad, 0x9a, 0xc7, 0xf7, 0x67, 0x93}},
+       testcase{
+               msg:       []byte{0xae, 0xcb, 0xb0, 0x27, 0x59, 0xf7, 0x43, 0x3d, 0x6f, 0xcb, 0x6, 0x96, 0x3c, 0x74, 0x6, 0x1c, 0xd8, 0x3b, 0x5b, 0x3f, 0xfa, 0x6f, 0x13, 0xc6},
+               output224: []byte{0xba, 0x76, 0xff, 0xef, 0xd0, 0x6, 0xb8, 0x1e, 0xf5, 0x99, 0x1e, 0x69, 0x7d, 0x4, 0x25, 0x62, 0x1b, 0x16, 0x81, 0x8e, 0xa2, 0x7c, 0x11, 0x5, 0x6e, 0x0, 0x90, 0x4e},
+               output256: []byte{0x23, 0x29, 0x81, 0xb, 0x5a, 0x47, 0x35, 0xbc, 0xd4, 0x9c, 0x10, 0xe6, 0x45, 0x6c, 0xb, 0x1d, 0xed, 0x5e, 0xac, 0x25, 0x8a, 0xf4, 0x7c, 0xbb, 0x79, 0x7c, 0xa1, 0x62, 0xab, 0x6d, 0x1b, 0xa8},
+               output384: []byte{0x11, 0x98, 0xef, 0xa5, 0x7e, 0x1a, 0x78, 0x84, 0xda, 0xc8, 0x27, 0xe6, 0x83, 0x25, 0x55, 0x75, 0x51, 0xe, 0x1f, 0x92, 0x2, 0x4a, 0x13, 0x51, 0x44, 0x65, 0x9b, 0xe8, 0x7b, 0xbf, 0xd, 0x6, 0x3e, 0xd2, 0x6c, 0x98, 0x76, 0x47, 0xb9, 0x23, 0xa0, 0x91, 0xcf, 0x11, 0x68, 0x3, 0x16, 0xfe},
+               output512: []byte{0xfc, 0xef, 0x88, 0xbc, 0xc7, 0xef, 0x70, 0xd8, 0xc3, 0x97, 0x34, 0x29, 0xac, 0x51, 0x39, 0x15, 0x5f, 0x9b, 0xa6, 0x43, 0xb4, 0x31, 0x1, 0x3f, 0x18, 0x17, 0xec, 0xd2, 0xff, 0x3a, 0xb2, 0x87, 0x88, 0xf, 0x9e, 0xa5, 0x4d, 0xf7, 0x50, 0x3c, 0xb3, 0xf7, 0x3d, 0x7c, 0xf2, 0xb8, 0x7d, 0x2e, 0x9b, 0xdb, 0xd2, 0x3, 0x37, 0x8f, 0xae, 0x74, 0xca, 0x4b, 0xd2, 0x66, 0x7a, 0x4a, 0xa7, 0x6}},
+       testcase{
+               msg:       []byte{0xaa, 0xfd, 0xc9, 0x24, 0x3d, 0x3d, 0x4a, 0x9, 0x65, 0x58, 0xa3, 0x60, 0xcc, 0x27, 0xc8, 0xd8, 0x62, 0xf0, 0xbe, 0x73, 0xdb, 0x5e, 0x88, 0xaa, 0x55},
+               output224: []byte{0x1c, 0x1e, 0x75, 0x8d, 0x87, 0x39, 0x9a, 0x36, 0xbf, 0x7c, 0x8a, 0x2e, 0x6a, 0x55, 0xce, 0x6a, 0x4f, 0xc, 0x49, 0x87, 0x37, 0x95, 0x69, 0x59, 0x95, 0x9f, 0xd2, 0xac},
+               output256: []byte{0x6f, 0xff, 0xa0, 0x70, 0xb8, 0x65, 0xbe, 0x3e, 0xe7, 0x66, 0xdc, 0x2d, 0xb4, 0x9b, 0x6a, 0xa5, 0x5c, 0x36, 0x9f, 0x7d, 0xe3, 0x70, 0x3a, 0xda, 0x26, 0x12, 0xd7, 0x54, 0x14, 0x5c, 0x1, 0xe6},
+               output384: []byte{0x4, 0x35, 0xe5, 0x4c, 0x1, 0x6c, 0x7, 0x91, 0x67, 0x7d, 0xdb, 0xc6, 0xba, 0xdd, 0x55, 0xd1, 0x46, 0x75, 0x42, 0x96, 0xb3, 0x11, 0x32, 0xb0, 0xb1, 0xc0, 0xb5, 0xce, 0x4a, 0xed, 0xb0, 0x3a, 0xea, 0xa9, 0xa2, 0xdc, 0x51, 0x57, 0xd7, 0xaf, 0x20, 0xb8, 0xe3, 0x6d, 0x75, 0xe1, 0xcc, 0x0},
+               output512: []byte{0x47, 0xb, 0xdd, 0x8d, 0x70, 0x98, 0x75, 0xc8, 0xe6, 0xf8, 0x85, 0x91, 0xb9, 0x7d, 0x64, 0x86, 0xc5, 0xf0, 0x3b, 0x54, 0xbf, 0xc9, 0x5, 0x75, 0x74, 0x83, 0xe0, 0x13, 0xf6, 0x3a, 0x6c, 0x56, 0x98, 0x4d, 0x45, 0x18, 0xd4, 0x5c, 0x2d, 0x22, 0x98, 0xea, 0xdb, 0x44, 0xaf, 0x3a, 0xc, 0x35, 0xa7, 0x6b, 0x57, 0x3d, 0x45, 0x2f, 0x57, 0x47, 0x84, 0x4d, 0x3a, 0xd8, 0xf8, 0x4a, 0x2e, 0x85}},
+       testcase{
+               msg:       []byte{0x7b, 0xc8, 0x48, 0x67, 0xf6, 0xf9, 0xe9, 0xfd, 0xc3, 0xe1, 0x4, 0x6c, 0xae, 0x3a, 0x52, 0xc7, 0x7e, 0xd4, 0x85, 0x86, 0xe, 0xe2, 0x60, 0xe3, 0xb, 0x15},
+               output224: []byte{0xdd, 0xea, 0x76, 0x40, 0x9c, 0x61, 0xf6, 0xd1, 0x87, 0x3f, 0x1, 0xa3, 0x42, 0x51, 0xc7, 0x4c, 0x37, 0xb3, 0x4f, 0x28, 0xf7, 0xf4, 0x82, 0xa8, 0x43, 0x95, 0xb5, 0xf3},
+               output256: []byte{0xb3, 0x7, 0x61, 0xc0, 0x53, 0xe9, 0x26, 0xf1, 0x50, 0xb9, 0xdc, 0xe7, 0xe0, 0x5, 0xb4, 0xd8, 0x78, 0x11, 0xcc, 0xfb, 0x9e, 0x3b, 0x6e, 0xdb, 0x2, 0x21, 0x2, 0x2f, 0x1, 0x71, 0x1c, 0xf0},
+               output384: []byte{0x88, 0xd8, 0x98, 0xed, 0x7e, 0x6e, 0x54, 0xa6, 0x83, 0x81, 0x2b, 0x37, 0x2f, 0x67, 0x8a, 0x5f, 0xd7, 0x3b, 0xcf, 0x31, 0x60, 0xa9, 0x69, 0xfe, 0x45, 0x84, 0x65, 0x1a, 0xdb, 0x32, 0x55, 0xf9, 0xad, 0xcc, 0x8b, 0x85, 0xdc, 0xca, 0x5c, 0x3b, 0xf8, 0xeb, 0xa3, 0xa1, 0xb6, 0x9d, 0x9b, 0x90},
+               output512: []byte{0x42, 0x9f, 0xd4, 0x38, 0xb3, 0x90, 0xad, 0x2, 0x24, 0x2, 0x89, 0x75, 0x46, 0x7e, 0xc2, 0x28, 0xf9, 0xad, 0xcd, 0xe7, 0x1e, 0x17, 0x38, 0x0, 0x5e, 0x37, 0x17, 0xc5, 0x8f, 0x72, 0x7a, 0xa2, 0xb7, 0xc6, 0x17, 0x80, 0xbf, 0xc, 0x5f, 0x8b, 0x76, 0x6c, 0xc6, 0xd3, 0x45, 0x51, 0xd8, 0x7d, 0x22, 0xa1, 0x30, 0xb8, 0xc2, 0x15, 0x61, 0x42, 0x4, 0xe6, 0x7, 0xaa, 0x82, 0xff, 0x84, 0x69}},
+       testcase{
+               msg:       []byte{0xfa, 0xc5, 0x23, 0x57, 0x5a, 0x99, 0xec, 0x48, 0x27, 0x9a, 0x7a, 0x45, 0x9e, 0x98, 0xff, 0x90, 0x19, 0x18, 0xa4, 0x75, 0x3, 0x43, 0x27, 0xef, 0xb5, 0x58, 0x43},
+               output224: []byte{0x77, 0x7c, 0x52, 0x3c, 0xf4, 0x2d, 0x0, 0x6, 0xed, 0x1f, 0x88, 0xf1, 0xbd, 0xc, 0x3a, 0x5e, 0xf2, 0x18, 0x14, 0x72, 0x37, 0x94, 0xb8, 0x46, 0x1a, 0x37, 0x5c, 0x3a},
+               output256: []byte{0x4, 0xf1, 0xb3, 0xc1, 0xe2, 0x5b, 0xa5, 0xd0, 0x12, 0xe2, 0x2a, 0xd1, 0x44, 0xe5, 0xa8, 0x71, 0x9d, 0x94, 0x32, 0x2d, 0x5, 0xad, 0x9e, 0xf6, 0x1e, 0x7d, 0xb4, 0x9b, 0x59, 0x95, 0x9b, 0x3a},
+               output384: []byte{0x7a, 0xc3, 0x43, 0xa9, 0x36, 0x9f, 0xa7, 0xbf, 0x45, 0xaf, 0xed, 0x43, 0x8, 0x4d, 0xc1, 0xe2, 0x75, 0xab, 0x1b, 0x70, 0x3, 0x4c, 0xfa, 0xac, 0xd4, 0xf3, 0xcb, 0x5e, 0x5e, 0x22, 0x1, 0xcf, 0xbd, 0x1c, 0xff, 0xf8, 0x3b, 0xaa, 0xd3, 0x89, 0x7a, 0x4c, 0xb8, 0xa0, 0xde, 0x5c, 0x35, 0xc4},
+               output512: []byte{0x79, 0xa, 0x1, 0xa, 0xeb, 0x6f, 0x13, 0xe0, 0x19, 0xa1, 0xdc, 0x35, 0x57, 0x4b, 0x12, 0x19, 0xe7, 0x4f, 0xf5, 0xdb, 0x6f, 0xbd, 0x87, 0x46, 0x73, 0x36, 0x64, 0xff, 0xdb, 0xcf, 0xe1, 0xcc, 0x6e, 0x8a, 0xb3, 0x91, 0x17, 0xe3, 0x24, 0x4c, 0x4f, 0xa3, 0xc0, 0xa9, 0x62, 0xc9, 0xf5, 0x0, 0x30, 0xae, 0xf8, 0x8e, 0x19, 0x3e, 0x7e, 0xd, 0x4c, 0x47, 0x47, 0x34, 0x5f, 0x30, 0xcb, 0x54}},
+       testcase{
+               msg:       []byte{0xf, 0x8b, 0x2d, 0x8f, 0xcf, 0xd9, 0xd6, 0x8c, 0xff, 0xc1, 0x7c, 0xcf, 0xb1, 0x17, 0x70, 0x9b, 0x53, 0xd2, 0x64, 0x62, 0xa3, 0xf3, 0x46, 0xfb, 0x7c, 0x79, 0xb8, 0x5e},
+               output224: []byte{0x8d, 0x74, 0x74, 0xed, 0x6d, 0xea, 0x46, 0x26, 0xad, 0x3c, 0x1d, 0x6, 0xd2, 0xad, 0x5b, 0x19, 0x8c, 0xaa, 0xd0, 0x7b, 0x12, 0x7, 0x7c, 0x68, 0xc, 0xf6, 0xd8, 0x9b},
+               output256: []byte{0xae, 0xef, 0x4b, 0x4d, 0xa4, 0x20, 0x83, 0x4f, 0xfc, 0xed, 0x26, 0xdb, 0x29, 0x12, 0x48, 0xfb, 0x2d, 0x1, 0xe7, 0x65, 0xe2, 0xb0, 0x56, 0x40, 0x57, 0xf8, 0xe6, 0xc2, 0x3, 0xa, 0xc3, 0x7f},
+               output384: []byte{0x58, 0x87, 0x7b, 0x8d, 0xd9, 0x8c, 0x51, 0x33, 0x9e, 0x43, 0x2, 0xab, 0xe9, 0x5c, 0xf5, 0x76, 0x62, 0xcf, 0x5, 0xaa, 0x1, 0x93, 0x81, 0x61, 0xcb, 0xfb, 0x5d, 0xdd, 0xa7, 0x24, 0x51, 0x7f, 0xc, 0x0, 0x2d, 0x54, 0xb5, 0x4e, 0xea, 0x7e, 0xbd, 0x64, 0xe2, 0x9, 0xda, 0xeb, 0x8f, 0x1},
+               output512: []byte{0xaa, 0xf7, 0xa3, 0x91, 0x60, 0x2, 0x70, 0xf7, 0xb5, 0xa2, 0xa3, 0xbb, 0xc7, 0x47, 0x4a, 0xc4, 0x15, 0x4e, 0xbe, 0xac, 0x3, 0xa7, 0x90, 0xa5, 0x7f, 0xda, 0xd9, 0x6c, 0xea, 0x2d, 0x4, 0x3c, 0x9f, 0xa5, 0xf6, 0x91, 0x67, 0x90, 0xb9, 0x2f, 0x80, 0x32, 0xd6, 0x68, 0xed, 0x9a, 0x7, 0x11, 0x2d, 0xc5, 0xb2, 0x37, 0x3e, 0xc8, 0x16, 0xaa, 0xbc, 0xa6, 0xf5, 0x77, 0xce, 0x60, 0x41, 0x5e}},
+       testcase{
+               msg:       []byte{0xa9, 0x63, 0xc3, 0xe8, 0x95, 0xff, 0x5a, 0xb, 0xe4, 0x82, 0x44, 0x0, 0x51, 0x8d, 0x81, 0x41, 0x2f, 0x87, 0x5f, 0xa5, 0x5, 0x21, 0xe2, 0x6e, 0x85, 0xea, 0xc9, 0xc, 0x4},
+               output224: []byte{0xf5, 0x25, 0xd4, 0x51, 0x5d, 0x3c, 0xa5, 0x4a, 0x2f, 0xab, 0x9c, 0x67, 0x9e, 0x93, 0x56, 0x1f, 0xe1, 0x51, 0xea, 0x9, 0x60, 0x75, 0x13, 0x52, 0xcd, 0x7f, 0x59, 0x1a},
+               output256: []byte{0x3, 0xd2, 0x6a, 0xee, 0xb4, 0xa7, 0xbd, 0xdd, 0xbf, 0xf7, 0xcf, 0xf6, 0x67, 0x19, 0x8c, 0x42, 0x59, 0x41, 0xa2, 0x77, 0x69, 0x22, 0xdf, 0x2b, 0xec, 0x54, 0x5f, 0x53, 0x4, 0xe2, 0xc6, 0x1c},
+               output384: []byte{0x1c, 0xd6, 0x38, 0x12, 0x87, 0x18, 0xbe, 0x35, 0x13, 0x85, 0xe7, 0xa1, 0x56, 0xc3, 0xf0, 0xee, 0x8b, 0x21, 0xd, 0x15, 0x65, 0x87, 0x6f, 0x8e, 0xd4, 0x6c, 0x22, 0x7b, 0x93, 0xd, 0x18, 0x8f, 0xe8, 0xca, 0x27, 0x76, 0xf, 0xe1, 0x89, 0xd3, 0xb1, 0x36, 0x83, 0x65, 0x61, 0xe9, 0xa0, 0xee},
+               output512: []byte{0x3e, 0x28, 0x80, 0xa9, 0x74, 0xe5, 0xf, 0x98, 0xbd, 0x6c, 0xc0, 0xf9, 0xd7, 0x69, 0xaf, 0x34, 0x8c, 0xe3, 0xb7, 0xe8, 0xfa, 0x38, 0xcf, 0xc, 0xa2, 0xda, 0x5f, 0xd7, 0x4, 0xc9, 0xc0, 0xe5, 0x7d, 0x55, 0x0, 0xbe, 0xa3, 0xcb, 0x74, 0x77, 0x92, 0x7f, 0x9c, 0x39, 0x4a, 0xa3, 0xf9, 0xbb, 0xc0, 0x18, 0x24, 0x35, 0x2, 0x91, 0xb9, 0xa0, 0xa0, 0xcb, 0xf0, 0x94, 0xbb, 0x37, 0xda, 0x55}},
+       testcase{
+               msg:       []byte{0x3, 0xa1, 0x86, 0x88, 0xb1, 0xc, 0xc0, 0xed, 0xf8, 0x3a, 0xdf, 0xa, 0x84, 0x80, 0x8a, 0x97, 0x18, 0x38, 0x3c, 0x40, 0x70, 0xc6, 0xc4, 0xf2, 0x95, 0x9, 0x86, 0x99, 0xac, 0x2c},
+               output224: []byte{0x9a, 0x84, 0x55, 0xf4, 0x1f, 0x69, 0x3b, 0x91, 0xb3, 0xde, 0x46, 0xbf, 0x66, 0xff, 0x9, 0xd4, 0x2d, 0xc3, 0x0, 0xb8, 0x56, 0xb1, 0xdc, 0x2d, 0xfd, 0x12, 0x55, 0x5c},
+               output256: []byte{0x43, 0x5c, 0xfc, 0xd, 0x1a, 0xfd, 0x8d, 0x55, 0x9, 0xa9, 0xcc, 0xbf, 0x49, 0x70, 0x65, 0x75, 0x3, 0x86, 0x85, 0xbf, 0x8, 0xdb, 0x54, 0x9d, 0x97, 0x14, 0x54, 0x82, 0x40, 0x46, 0x3e, 0xe9},
+               output384: []byte{0xb4, 0xdb, 0xdf, 0xd9, 0x92, 0x2a, 0xfd, 0x1c, 0xe4, 0x6f, 0xf1, 0xcb, 0x27, 0xc3, 0xe, 0x2a, 0xea, 0xa9, 0x67, 0x63, 0x1a, 0x4, 0x0, 0x1c, 0x7e, 0xf2, 0xb5, 0xea, 0xbd, 0x3c, 0x6, 0x78, 0xc0, 0xff, 0x21, 0x9b, 0xe7, 0xb9, 0xfa, 0x4, 0xcf, 0x83, 0xdd, 0x40, 0xbc, 0x1b, 0x33, 0xb6},
+               output512: []byte{0x48, 0xe5, 0x5e, 0x3, 0x40, 0xf2, 0x4, 0x66, 0x88, 0x1a, 0x73, 0x2a, 0xa8, 0x84, 0x59, 0xad, 0x4b, 0xcd, 0xef, 0x36, 0x4c, 0x3b, 0xd0, 0x45, 0xae, 0x9, 0x9f, 0x95, 0x3d, 0x89, 0xf1, 0x59, 0x57, 0xae, 0xf2, 0x4, 0x26, 0x5c, 0x39, 0x15, 0xba, 0x42, 0xfe, 0x42, 0x35, 0x19, 0x6b, 0xe3, 0xd0, 0xf5, 0x64, 0x67, 0x62, 0x27, 0xc3, 0xc0, 0xde, 0xac, 0xfb, 0xaf, 0x68, 0xf9, 0xe7, 0x17}},
+       testcase{
+               msg:       []byte{0x84, 0xfb, 0x51, 0xb5, 0x17, 0xdf, 0x6c, 0x5a, 0xcc, 0xb5, 0xd0, 0x22, 0xf8, 0xf2, 0x8d, 0xa0, 0x9b, 0x10, 0x23, 0x2d, 0x42, 0x32, 0xf, 0xfc, 0x32, 0xdb, 0xec, 0xc3, 0x83, 0x5b, 0x29},
+               output224: []byte{0x81, 0xaf, 0x3a, 0x7a, 0x5b, 0xd4, 0xc1, 0xf9, 0x48, 0xd6, 0xaf, 0x4b, 0x96, 0xf9, 0x3c, 0x3b, 0xc, 0xf9, 0xc0, 0xe7, 0xa6, 0xda, 0x6f, 0xcd, 0x71, 0xee, 0xc7, 0xf6},
+               output256: []byte{0xd4, 0x77, 0xfb, 0x2, 0xca, 0xaa, 0x95, 0xb3, 0x28, 0xe, 0xc8, 0xee, 0x88, 0x2c, 0x29, 0xd9, 0xe8, 0xa6, 0x54, 0xb2, 0x1e, 0xf1, 0x78, 0xe0, 0xf9, 0x75, 0x71, 0xbf, 0x9d, 0x4d, 0x3c, 0x1c},
+               output384: []byte{0x50, 0x3d, 0xca, 0xa4, 0xad, 0xda, 0x5a, 0x94, 0x20, 0xb2, 0xe4, 0x36, 0xdd, 0x62, 0xd9, 0xab, 0x2e, 0x2, 0x54, 0x29, 0x5c, 0x29, 0x82, 0xef, 0x67, 0xfc, 0xe4, 0xf, 0x11, 0x7a, 0x24, 0x0, 0xab, 0x49, 0x2f, 0x7b, 0xd5, 0xd1, 0x33, 0xc6, 0xec, 0x22, 0x32, 0x26, 0x8b, 0xc2, 0x7b, 0x42},
+               output512: []byte{0x9d, 0x80, 0x98, 0xd8, 0xd6, 0xed, 0xbb, 0xaa, 0x2b, 0xcf, 0xc6, 0xfb, 0x2f, 0x89, 0xc3, 0xea, 0xc6, 0x7f, 0xec, 0x25, 0xcd, 0xfe, 0x75, 0xaa, 0x7b, 0xd5, 0x70, 0xa6, 0x48, 0xe8, 0xc8, 0x94, 0x5f, 0xf2, 0xec, 0x28, 0xf, 0x6d, 0xcf, 0x73, 0x38, 0x61, 0x9, 0x15, 0x5c, 0x5b, 0xbc, 0x44, 0x4c, 0x70, 0x7b, 0xb4, 0x2e, 0xab, 0x87, 0x3f, 0x5f, 0x74, 0x76, 0x65, 0x7b, 0x1b, 0xc1, 0xa8}},
+       testcase{
+               msg:       []byte{0x9f, 0x2f, 0xcc, 0x7c, 0x90, 0xde, 0x9, 0xd, 0x6b, 0x87, 0xcd, 0x7e, 0x97, 0x18, 0xc1, 0xea, 0x6c, 0xb2, 0x11, 0x18, 0xfc, 0x2d, 0x5d, 0xe9, 0xf9, 0x7e, 0x5d, 0xb6, 0xac, 0x1e, 0x9c, 0x10},
+               output224: []byte{0xa2, 0x7a, 0x5, 0x1a, 0x36, 0xa1, 0x50, 0x19, 0x74, 0xad, 0x8e, 0x98, 0x73, 0xe9, 0xdf, 0x23, 0x1a, 0xa9, 0xad, 0x90, 0xec, 0x1d, 0x7a, 0x8b, 0xbf, 0x8f, 0x63, 0x9a},
+               output256: []byte{0x24, 0xdd, 0x2e, 0xe0, 0x24, 0x82, 0x14, 0x4f, 0x53, 0x9f, 0x81, 0xd, 0x2c, 0xaa, 0x8a, 0x7b, 0x75, 0xd0, 0xfa, 0x33, 0x65, 0x7e, 0x47, 0x93, 0x21, 0x22, 0xd2, 0x73, 0xc3, 0xf6, 0xf6, 0xd1},
+               output384: []byte{0x64, 0xd1, 0x1a, 0xdc, 0x77, 0xaf, 0x5c, 0x56, 0x8f, 0x37, 0xe4, 0x4e, 0xfa, 0xc5, 0xfd, 0x3, 0xc4, 0x60, 0x39, 0x1a, 0xa8, 0x33, 0xab, 0xec, 0x4e, 0x46, 0x42, 0x37, 0xa8, 0x93, 0x7e, 0xed, 0xd2, 0x3e, 0xc5, 0x13, 0xdd, 0x2a, 0x71, 0xd0, 0x32, 0x9b, 0xea, 0xa8, 0xbe, 0xf3, 0x95, 0xc9},
+               output512: []byte{0x1e, 0xaf, 0xed, 0xce, 0x72, 0x92, 0xba, 0x73, 0xb8, 0xa, 0xe6, 0x15, 0x17, 0x45, 0xf4, 0x3a, 0xc9, 0x5b, 0xfc, 0x9f, 0x31, 0x69, 0x4d, 0x42, 0x24, 0x73, 0xab, 0xca, 0x2e, 0x69, 0xd6, 0x95, 0xcb, 0x65, 0x44, 0xdb, 0x65, 0x50, 0x60, 0x78, 0xcb, 0x20, 0xdb, 0xe0, 0x76, 0x2f, 0x84, 0xaa, 0x6a, 0xfd, 0x14, 0xa6, 0xa, 0xb5, 0x97, 0x95, 0x5b, 0xe7, 0x3f, 0x3f, 0x5c, 0x50, 0xf7, 0xa8}},
+       testcase{
+               msg:       []byte{0xde, 0x8f, 0x1b, 0x3f, 0xaa, 0x4b, 0x70, 0x40, 0xed, 0x45, 0x63, 0xc3, 0xb8, 0xe5, 0x98, 0x25, 0x31, 0x78, 0xe8, 0x7e, 0x4d, 0xd, 0xf7, 0x5e, 0x4f, 0xf2, 0xf2, 0xde, 0xdd, 0x5a, 0xb, 0xe0, 0x46},
+               output224: []byte{0xf2, 0x17, 0x81, 0x2e, 0x36, 0x2e, 0xc6, 0x4d, 0x4d, 0xc5, 0xea, 0xcf, 0xab, 0xc1, 0x65, 0x18, 0x4b, 0xfa, 0x45, 0x6e, 0x5c, 0x32, 0xc2, 0xc7, 0x90, 0x2, 0x53, 0xd0},
+               output256: []byte{0xe7, 0x8c, 0x42, 0x1e, 0x62, 0x13, 0xaf, 0xf8, 0xde, 0x1f, 0x2, 0x57, 0x59, 0xa4, 0xf2, 0xc9, 0x43, 0xdb, 0x62, 0xbb, 0xde, 0x35, 0x9c, 0x87, 0x37, 0xe1, 0x9b, 0x37, 0x76, 0xed, 0x2d, 0xd2},
+               output384: []byte{0xcf, 0x38, 0x76, 0x49, 0x73, 0xf1, 0xec, 0x1c, 0x34, 0xb5, 0x43, 0x3a, 0xe7, 0x5a, 0x3a, 0xad, 0x1a, 0xae, 0xf6, 0xab, 0x19, 0x78, 0x50, 0xc5, 0x6c, 0x86, 0x17, 0xbc, 0xd6, 0xa8, 0x82, 0xf6, 0x66, 0x68, 0x83, 0xac, 0x17, 0xb2, 0xdc, 0xcd, 0xba, 0xa6, 0x47, 0x7, 0x5d, 0x9, 0x72, 0xb5},
+               output512: []byte{0x9a, 0x76, 0x88, 0xe3, 0x1a, 0xaf, 0x40, 0xc1, 0x55, 0x75, 0xfc, 0x58, 0xc6, 0xb3, 0x92, 0x67, 0xaa, 0xd3, 0x72, 0x2e, 0x69, 0x6e, 0x51, 0x8a, 0x99, 0x45, 0xcf, 0x7f, 0x7c, 0xf, 0xea, 0x84, 0xcb, 0x3c, 0xb2, 0xe9, 0xf0, 0x38, 0x4a, 0x6b, 0x5d, 0xc6, 0x71, 0xad, 0xe7, 0xfb, 0x4d, 0x2b, 0x27, 0x1, 0x11, 0x73, 0xf3, 0xee, 0xea, 0xf1, 0x7c, 0xb4, 0x51, 0xcf, 0x26, 0x54, 0x20, 0x31}},
+       testcase{
+               msg:       []byte{0x62, 0xf1, 0x54, 0xec, 0x39, 0x4d, 0xb, 0xc7, 0x57, 0xd0, 0x45, 0xc7, 0x98, 0xc8, 0xb8, 0x7a, 0x0, 0xe0, 0x65, 0x5d, 0x4, 0x81, 0xa7, 0xd2, 0xd9, 0xfb, 0x58, 0xd9, 0x3a, 0xed, 0xc6, 0x76, 0xb5, 0xa0},
+               output224: []byte{0x5c, 0xa9, 0x2b, 0x5f, 0x58, 0x30, 0xe1, 0xe5, 0xf8, 0xdf, 0x43, 0x91, 0x33, 0x9d, 0xf7, 0xdf, 0x1f, 0x23, 0xbb, 0x31, 0xaa, 0x5, 0x43, 0x7c, 0x10, 0x3f, 0x16, 0x52},
+               output256: []byte{0xcc, 0xe3, 0xe3, 0xd4, 0x98, 0x32, 0x8a, 0x4d, 0x9c, 0x5b, 0x4d, 0xbf, 0x9a, 0x12, 0x9, 0x62, 0x8a, 0xb8, 0x26, 0x21, 0xad, 0x1a, 0xd, 0xa, 0x18, 0x68, 0x3, 0x62, 0x88, 0x9e, 0x61, 0x64},
+               output384: []byte{0x88, 0x2b, 0xff, 0x90, 0x4b, 0xff, 0x10, 0x31, 0x13, 0x95, 0x3, 0xbf, 0x6e, 0x2, 0x74, 0xc7, 0xa3, 0x92, 0x8c, 0x2d, 0x73, 0xbf, 0x47, 0x4a, 0x65, 0xb9, 0x7c, 0x22, 0xf6, 0x5f, 0x32, 0xbe, 0x26, 0xad, 0x1c, 0x5f, 0x7e, 0x4f, 0xa3, 0x5d, 0x5b, 0x62, 0x53, 0xaa, 0x40, 0x76, 0x36, 0x1a},
+               output512: []byte{0xad, 0xa5, 0xca, 0x56, 0x30, 0x66, 0x0, 0x3, 0xc4, 0xd1, 0x61, 0x49, 0xf2, 0x35, 0xfa, 0xeb, 0x78, 0x13, 0x2f, 0x7f, 0x77, 0x3a, 0x63, 0x1f, 0x82, 0xc, 0xc5, 0xc6, 0x54, 0xb0, 0x8e, 0xab, 0x42, 0x6, 0xbb, 0x4e, 0xa1, 0x38, 0x9d, 0x1c, 0xf7, 0x4d, 0x3b, 0x60, 0xb8, 0x6e, 0x48, 0x4c, 0x90, 0xc8, 0x17, 0xcd, 0xb5, 0xdd, 0x5d, 0xbf, 0x32, 0x71, 0x63, 0xb4, 0x64, 0x6f, 0x72, 0x13}},
+       testcase{
+               msg:       []byte{0xb2, 0xdc, 0xfe, 0x9f, 0xf1, 0x9e, 0x2b, 0x23, 0xce, 0x7d, 0xa2, 0xa4, 0x20, 0x7d, 0x3e, 0x5e, 0xc7, 0xc6, 0x11, 0x2a, 0x8a, 0x22, 0xae, 0xc9, 0x67, 0x5a, 0x88, 0x63, 0x78, 0xe1, 0x4e, 0x5b, 0xfb, 0xad, 0x4e},
+               output224: []byte{0x9f, 0x1, 0xf0, 0x7d, 0x93, 0xf, 0x40, 0xa2, 0x64, 0x7, 0x76, 0x1, 0x4, 0xef, 0xd1, 0xd, 0x44, 0x36, 0x29, 0x5f, 0x6b, 0x8c, 0x41, 0xfe, 0x2a, 0x4e, 0x9, 0xea},
+               output256: []byte{0xf8, 0x71, 0xdb, 0x93, 0xc5, 0xc9, 0x2e, 0xcd, 0x65, 0xd4, 0xed, 0xb9, 0x6f, 0xcb, 0x12, 0xe4, 0x72, 0x9b, 0xc2, 0xa1, 0x89, 0x9f, 0x7f, 0xb0, 0x29, 0xf5, 0xb, 0xff, 0x43, 0x1c, 0xbb, 0x72},
+               output384: []byte{0x80, 0x44, 0x8b, 0x7a, 0x76, 0xe0, 0xf0, 0x66, 0x60, 0x48, 0xc0, 0x21, 0x65, 0xa4, 0xfa, 0x8d, 0xfd, 0x25, 0xa, 0x22, 0x7c, 0xcd, 0xd4, 0x47, 0x1c, 0x37, 0x3, 0xd0, 0x77, 0x62, 0x36, 0x2d, 0xc1, 0xdf, 0x55, 0xfe, 0xc2, 0x9e, 0x2a, 0x31, 0xfe, 0x70, 0x95, 0x83, 0x74, 0x27, 0x1d, 0xd7},
+               output512: []byte{0x71, 0xa0, 0x80, 0x1d, 0x32, 0x58, 0x79, 0x80, 0xb0, 0x99, 0x63, 0xa0, 0xf5, 0x47, 0xb8, 0xb6, 0xee, 0x3b, 0xad, 0xe2, 0x24, 0x67, 0x1b, 0xf4, 0x4f, 0x12, 0xe3, 0xda, 0x4f, 0x21, 0x77, 0x8b, 0xac, 0x37, 0xfc, 0xc7, 0x3e, 0xf4, 0x5f, 0xee, 0x1c, 0x96, 0x68, 0x8b, 0xaf, 0x90, 0x20, 0xf4, 0x87, 0xb1, 0xa1, 0x6e, 0x3a, 0xc9, 0x1b, 0x50, 0x48, 0x45, 0xd6, 0xfb, 0xa8, 0x79, 0x13, 0x4f}},
+       testcase{
+               msg:       []byte{0x47, 0xf5, 0x69, 0x7a, 0xc8, 0xc3, 0x14, 0x9, 0xc0, 0x86, 0x88, 0x27, 0x34, 0x7a, 0x61, 0x3a, 0x35, 0x62, 0x4, 0x1c, 0x63, 0x3c, 0xf1, 0xf1, 0xf8, 0x68, 0x65, 0xa5, 0x76, 0xe0, 0x28, 0x35, 0xed, 0x2c, 0x24, 0x92},
+               output224: []byte{0x22, 0xa3, 0xfe, 0xd1, 0xf4, 0xe2, 0x98, 0xc3, 0x7a, 0x1d, 0x7b, 0xa0, 0xc8, 0xe, 0x99, 0x4b, 0x11, 0xd9, 0x5f, 0x29, 0xf, 0x39, 0x45, 0xa3, 0xce, 0xb2, 0xe2, 0xe6},
+               output256: []byte{0x4e, 0xb1, 0x43, 0x47, 0x74, 0x31, 0xdf, 0x1, 0x93, 0x11, 0xae, 0xd9, 0x36, 0xca, 0xb9, 0x1a, 0x91, 0x2e, 0xc1, 0xe6, 0x86, 0x8b, 0x71, 0xe9, 0xed, 0xdb, 0x77, 0x74, 0x8, 0xd4, 0xaf, 0x34},
+               output384: []byte{0x62, 0x68, 0xcd, 0x6b, 0x41, 0xf4, 0xc5, 0x12, 0x3e, 0xc4, 0xd5, 0x4d, 0x1e, 0x69, 0x43, 0xab, 0xb3, 0x2d, 0xbe, 0x7b, 0xff, 0xb8, 0xeb, 0x95, 0xe4, 0xfc, 0xee, 0x5c, 0x12, 0xd4, 0x64, 0x7b, 0xe1, 0x43, 0xc2, 0x7f, 0x12, 0x81, 0xcd, 0xd2, 0x75, 0x90, 0x49, 0x20, 0x44, 0x15, 0x8, 0xda},
+               output512: []byte{0xeb, 0xa6, 0x78, 0xb7, 0xa0, 0xe5, 0x66, 0x9d, 0xc7, 0xfa, 0x5e, 0xca, 0x5d, 0x5f, 0x19, 0xfe, 0x62, 0x5e, 0x11, 0x3e, 0x50, 0x28, 0xda, 0x5e, 0xfb, 0x13, 0x89, 0x23, 0xcd, 0x44, 0x47, 0x57, 0xb0, 0x60, 0x78, 0xe0, 0xba, 0x6, 0x4b, 0x36, 0xc7, 0x2c, 0xa2, 0x18, 0x7a, 0xb9, 0xdd, 0x31, 0xdd, 0xa6, 0xf2, 0x46, 0x68, 0xf4, 0x6c, 0x32, 0xf8, 0xec, 0x21, 0xac, 0x59, 0xaa, 0xfa, 0x24}},
+       testcase{
+               msg:       []byte{0x51, 0x2a, 0x6d, 0x29, 0x2e, 0x67, 0xec, 0xb2, 0xfe, 0x48, 0x6b, 0xfe, 0x92, 0x66, 0x9, 0x53, 0xa7, 0x54, 0x84, 0xff, 0x4c, 0x4f, 0x2e, 0xca, 0x2b, 0xa, 0xf0, 0xed, 0xcd, 0xd4, 0x33, 0x9c, 0x6b, 0x2e, 0xe4, 0xe5, 0x42},
+               output224: []byte{0x35, 0xf1, 0xab, 0x12, 0x63, 0x21, 0x1f, 0x73, 0x8d, 0x3f, 0x97, 0xd0, 0xe4, 0x84, 0xc, 0x38, 0x7e, 0x9, 0x36, 0x9f, 0x23, 0xbf, 0x92, 0x39, 0x15, 0xd, 0x3, 0x6},
+               output256: []byte{0x9a, 0xc, 0x1d, 0x50, 0xa5, 0x9d, 0xbf, 0x65, 0x7f, 0x67, 0x13, 0xc7, 0x95, 0xed, 0x14, 0xe1, 0xf2, 0x3b, 0x4e, 0xaa, 0x13, 0x7c, 0x55, 0x40, 0xaa, 0xcd, 0xb0, 0xa7, 0xe3, 0x2c, 0x29, 0xfc},
+               output384: []byte{0xc7, 0x3d, 0x18, 0xde, 0x7, 0xa6, 0x5a, 0xcc, 0x7e, 0x2d, 0x8b, 0x2a, 0x51, 0x0, 0x2a, 0xe2, 0x8c, 0xbc, 0x4b, 0xa, 0x6e, 0xe7, 0xf8, 0x1a, 0x6b, 0x48, 0x3f, 0x81, 0xa6, 0xdf, 0x8f, 0xf6, 0xb3, 0x3f, 0x63, 0x2a, 0x6e, 0x63, 0x12, 0x88, 0x8c, 0xa7, 0x14, 0x82, 0x1c, 0xb, 0x13, 0xdf},
+               output512: []byte{0x12, 0xdf, 0x92, 0xd8, 0x89, 0xd7, 0xba, 0xd, 0xf0, 0x5b, 0xcd, 0x2, 0xd9, 0xde, 0x58, 0xc9, 0x7f, 0x48, 0x13, 0x12, 0x69, 0x67, 0xff, 0x78, 0xbd, 0xf7, 0x59, 0xc6, 0x6c, 0x4c, 0xbe, 0x9d, 0xf6, 0x8a, 0xb3, 0x1a, 0x2, 0x56, 0xc7, 0x76, 0x73, 0xb, 0xb2, 0x5d, 0xee, 0xcf, 0x91, 0xf0, 0x99, 0x78, 0x68, 0xac, 0x8b, 0xb8, 0x6d, 0xf7, 0xa0, 0xfc, 0x11, 0xc, 0xb0, 0xa4, 0xde, 0x5d}},
+       testcase{
+               msg:       []byte{0x97, 0x3c, 0xf2, 0xb4, 0xdc, 0xf0, 0xbf, 0xa8, 0x72, 0xb4, 0x11, 0x94, 0xcb, 0x5, 0xbb, 0x4e, 0x16, 0x76, 0xa, 0x18, 0x40, 0xd8, 0x34, 0x33, 0x1, 0x80, 0x25, 0x76, 0x19, 0x7e, 0xc1, 0x9e, 0x2a, 0x14, 0x93, 0xd8, 0xf4, 0xfb},
+               output224: []byte{0x34, 0xcc, 0x70, 0x8b, 0x87, 0x4d, 0x40, 0x47, 0x8e, 0x82, 0x32, 0x4b, 0xf3, 0xaa, 0x32, 0xfe, 0x9f, 0x85, 0xaf, 0xf8, 0xc6, 0xb, 0x4b, 0xad, 0xf9, 0x70, 0x3, 0xe3},
+               output256: []byte{0xba, 0x6, 0x2e, 0x5d, 0x37, 0x2, 0x16, 0xd1, 0x19, 0x85, 0xc4, 0xca, 0x7a, 0x26, 0x58, 0xdd, 0xc7, 0x32, 0x8b, 0x4b, 0xe4, 0xb4, 0xa, 0x52, 0xdd, 0x8f, 0xa3, 0xca, 0x66, 0x2f, 0x9, 0xd1},
+               output384: []byte{0x3a, 0xb, 0xea, 0x62, 0xf4, 0x2f, 0x9c, 0xee, 0xdb, 0x34, 0x8f, 0x6e, 0x16, 0x13, 0xf0, 0x3, 0x56, 0xed, 0x97, 0x66, 0xa5, 0xc1, 0x9f, 0xc, 0x2e, 0xeb, 0x5, 0xc7, 0x4d, 0xe6, 0x9d, 0x39, 0x43, 0xe1, 0x6c, 0xf7, 0x22, 0x81, 0xfd, 0xd9, 0x27, 0x15, 0xfa, 0x3d, 0x51, 0x51, 0x59, 0x31},
+               output512: []byte{0xb8, 0xc7, 0xce, 0x2b, 0xe4, 0xcb, 0x32, 0xc1, 0x40, 0xe7, 0x5b, 0x75, 0x47, 0x42, 0x48, 0xc1, 0xdd, 0x77, 0xd1, 0x9b, 0xc, 0xbc, 0xa3, 0x1a, 0x3e, 0xcc, 0x2a, 0x35, 0xc5, 0x32, 0xe4, 0xfa, 0x3e, 0xd4, 0xab, 0xbc, 0xda, 0x27, 0xaa, 0x68, 0xa9, 0xdd, 0xa0, 0x6b, 0x24, 0x54, 0x43, 0xe5, 0x90, 0x3a, 0x65, 0x65, 0x2a, 0x94, 0xed, 0x3a, 0xf1, 0x50, 0x65, 0xd3, 0xe7, 0x73, 0x6e, 0x47}},
+       testcase{
+               msg:       []byte{0x80, 0xbe, 0xeb, 0xcd, 0x2e, 0x3f, 0x8a, 0x94, 0x51, 0xd4, 0x49, 0x99, 0x61, 0xc9, 0x73, 0x1a, 0xe6, 0x67, 0xcd, 0xc2, 0x4e, 0xa0, 0x20, 0xce, 0x3b, 0x9a, 0xa4, 0xbb, 0xc0, 0xa7, 0xf7, 0x9e, 0x30, 0xa9, 0x34, 0x46, 0x7d, 0xa4, 0xb0},
+               output224: []byte{0x5f, 0x33, 0x9b, 0x2f, 0x87, 0xe7, 0xf6, 0x95, 0xb2, 0x36, 0x26, 0x7c, 0x81, 0x9b, 0xa1, 0x70, 0x5d, 0x97, 0x64, 0x4a, 0xd7, 0x2e, 0x8, 0x71, 0xc7, 0xe3, 0xa9, 0x13},
+               output256: []byte{0x3a, 0x8, 0x3a, 0xe1, 0x63, 0xdf, 0x42, 0xbd, 0x51, 0xb9, 0xc6, 0x64, 0xbe, 0xe9, 0xdc, 0x43, 0x62, 0xf1, 0x6e, 0x63, 0x38, 0x3d, 0xf1, 0x64, 0x73, 0xdf, 0x71, 0xbe, 0x6d, 0xd4, 0xc, 0x1c},
+               output384: []byte{0x10, 0x92, 0xf6, 0x39, 0x55, 0xf3, 0xdf, 0xef, 0x13, 0x22, 0xcf, 0x95, 0x16, 0xf2, 0x15, 0x40, 0x21, 0x55, 0x52, 0xbc, 0x57, 0x9, 0xcc, 0xda, 0x17, 0xad, 0x27, 0x6e, 0xca, 0xa0, 0x91, 0xa7, 0x84, 0x51, 0xfe, 0x99, 0x25, 0x79, 0x1b, 0x8a, 0x91, 0x91, 0xb5, 0xd4, 0x20, 0x10, 0x15, 0x6f},
+               output512: []byte{0xa0, 0xae, 0x9d, 0xfb, 0x56, 0x83, 0x1f, 0xe4, 0xa3, 0x22, 0x3c, 0x50, 0x1b, 0x69, 0x7b, 0xd8, 0x24, 0x3c, 0x47, 0x1e, 0x83, 0x43, 0xac, 0xfd, 0x37, 0xa6, 0xb5, 0x87, 0xfe, 0xac, 0x74, 0x57, 0x1c, 0x23, 0xde, 0xeb, 0xc9, 0xb9, 0x4a, 0x54, 0xa, 0x2, 0xf1, 0xb1, 0xe2, 0x25, 0x1e, 0x1, 0x22, 0x9c, 0x9d, 0x58, 0xc4, 0x27, 0x9f, 0x15, 0x5d, 0x55, 0x66, 0xfb, 0x18, 0xe8, 0x12, 0x95}},
+       testcase{
+               msg:       []byte{0x7a, 0xba, 0xa1, 0x2e, 0xc2, 0xa7, 0x34, 0x76, 0x74, 0xe4, 0x44, 0x14, 0xa, 0xe0, 0xfb, 0x65, 0x9d, 0x8, 0xe1, 0xc6, 0x6d, 0xec, 0xd8, 0xd6, 0xea, 0xe9, 0x25, 0xfa, 0x45, 0x1d, 0x65, 0xf3, 0xc0, 0x30, 0x8e, 0x29, 0x44, 0x6b, 0x8e, 0xd3},
+               output224: []byte{0x8e, 0x20, 0xd5, 0xc8, 0x3c, 0xda, 0x82, 0x26, 0xb5, 0x8c, 0xef, 0xd7, 0x4c, 0x29, 0x3c, 0xa7, 0x57, 0x9c, 0xbb, 0x39, 0x49, 0xca, 0x9e, 0xb2, 0xf6, 0x15, 0x65, 0xb8},
+               output256: []byte{0x48, 0x76, 0xe2, 0x73, 0xac, 0x0, 0x94, 0x25, 0x76, 0xd9, 0x60, 0x8d, 0x5b, 0x63, 0xec, 0xc9, 0xa3, 0xe7, 0x5d, 0x5e, 0xc, 0x42, 0xc6, 0xab, 0xdb, 0xcd, 0xe0, 0x37, 0x78, 0x5a, 0xf9, 0xa7},
+               output384: []byte{0x8c, 0xd0, 0x22, 0x97, 0x1d, 0x57, 0x69, 0x76, 0x1b, 0x8e, 0x96, 0xb4, 0x42, 0x44, 0x4f, 0xa1, 0x85, 0xf, 0x12, 0x1, 0xaa, 0xb0, 0xac, 0x9f, 0x6e, 0x84, 0x4, 0xe2, 0xb3, 0xea, 0x1d, 0x93, 0x62, 0x44, 0xee, 0xdc, 0x79, 0x57, 0xc8, 0xb, 0x7f, 0xae, 0x60, 0xb3, 0xf2, 0x16, 0xc6, 0xa0},
+               output512: []byte{0x63, 0x1e, 0x78, 0x47, 0x12, 0x4a, 0x70, 0xfe, 0x6e, 0xb2, 0x93, 0xa4, 0x4a, 0x25, 0xc5, 0x6, 0x0, 0xb5, 0xe7, 0xe9, 0x75, 0xca, 0x9f, 0xab, 0x5a, 0xe6, 0x4a, 0xb8, 0x6c, 0x7e, 0x42, 0xc9, 0x12, 0xdd, 0x6e, 0xc0, 0x93, 0xf0, 0x1a, 0x8d, 0xeb, 0xc6, 0xe1, 0xf5, 0xe4, 0x87, 0xaf, 0x97, 0xdc, 0x3f, 0xd6, 0xc5, 0x30, 0x2, 0x76, 0x50, 0x50, 0xbe, 0x96, 0x3f, 0xfc, 0xd4, 0xd9, 0x89}},
+       testcase{
+               msg:       []byte{0xc8, 0x8d, 0xee, 0x99, 0x27, 0x67, 0x9b, 0x8a, 0xf4, 0x22, 0xab, 0xcb, 0xac, 0xf2, 0x83, 0xb9, 0x4, 0xff, 0x31, 0xe1, 0xca, 0xc5, 0x8c, 0x78, 0x19, 0x80, 0x9f, 0x65, 0xd5, 0x80, 0x7d, 0x46, 0x72, 0x3b, 0x20, 0xf6, 0x7b, 0xa6, 0x10, 0xc2, 0xb7},
+               output224: []byte{0x60, 0x62, 0x55, 0x34, 0x88, 0x12, 0xcf, 0xb5, 0x8, 0x2f, 0x4d, 0x4b, 0xb6, 0xbb, 0xc2, 0xfe, 0xef, 0x4, 0x4e, 0x38, 0x1f, 0xeb, 0xe, 0x34, 0x60, 0x61, 0xaa, 0x4f},
+               output256: []byte{0x47, 0x97, 0xba, 0x1c, 0x7a, 0xb7, 0x19, 0x70, 0x50, 0xd6, 0xb2, 0xe5, 0x6, 0xf2, 0xdf, 0x45, 0x50, 0xe4, 0xb6, 0x73, 0xdf, 0x78, 0xf1, 0x8c, 0x46, 0x54, 0x24, 0xe4, 0x8d, 0xf5, 0xe9, 0x97},
+               output384: []byte{0xb6, 0x57, 0x5d, 0x53, 0xd3, 0x53, 0x36, 0x5, 0x21, 0xb2, 0xa, 0xa1, 0xf9, 0x93, 0xf6, 0xe2, 0xb5, 0xa2, 0x62, 0xd1, 0xf5, 0x8, 0x78, 0x9d, 0x5c, 0xe2, 0x46, 0x9e, 0x9f, 0x3f, 0x33, 0xcc, 0xe8, 0x84, 0x8d, 0xf6, 0x90, 0xcc, 0xb0, 0xd6, 0x76, 0xfb, 0x94, 0x9e, 0xb1, 0x71, 0xa7, 0xd7},
+               output512: []byte{0xb9, 0x89, 0x26, 0x3b, 0xb4, 0xe0, 0x42, 0x4f, 0x95, 0xfd, 0xc9, 0xa4, 0x9c, 0x83, 0xa3, 0x76, 0x9f, 0xbf, 0x31, 0xdc, 0xed, 0xda, 0x7e, 0x0, 0x5a, 0xb5, 0xf2, 0x2f, 0x43, 0xd2, 0x71, 0x8d, 0xeb, 0xd3, 0x90, 0x85, 0x97, 0x1f, 0x7e, 0xb7, 0x82, 0x2c, 0x9f, 0xa0, 0xf6, 0x7f, 0x77, 0x6c, 0xec, 0x4e, 0x35, 0xa9, 0xa8, 0xb8, 0xc8, 0x35, 0xef, 0x4e, 0x9e, 0xbd, 0xa1, 0x92, 0x2e, 0x4d}},
+       testcase{
+               msg:       []byte{0x1, 0xe4, 0x3f, 0xe3, 0x50, 0xfc, 0xec, 0x45, 0xe, 0xc9, 0xb1, 0x2, 0x5, 0x3e, 0x6b, 0x5d, 0x56, 0xe0, 0x98, 0x96, 0xe0, 0xdd, 0xd9, 0x7, 0x4f, 0xe1, 0x38, 0xe6, 0x3, 0x82, 0x10, 0x27, 0xc, 0x83, 0x4c, 0xe6, 0xea, 0xdc, 0x2b, 0xb8, 0x6b, 0xf6},
+               output224: []byte{0xc8, 0x85, 0x27, 0x4c, 0xc3, 0xbf, 0x11, 0x9, 0x95, 0xfe, 0xf1, 0x15, 0x4a, 0x86, 0x77, 0x2f, 0x28, 0xb4, 0x1e, 0x74, 0x5e, 0x86, 0xe9, 0x35, 0xb4, 0xe3, 0xa0, 0x3f},
+               output256: []byte{0x41, 0xc9, 0x1b, 0xe9, 0x8c, 0x58, 0x13, 0xa4, 0xc5, 0xd8, 0xae, 0x7c, 0x29, 0xb9, 0x91, 0x9c, 0x1c, 0xc9, 0x5b, 0x4a, 0x5, 0xf8, 0x24, 0x33, 0x94, 0x8c, 0xb9, 0x9d, 0x9a, 0x6d, 0x3, 0x9c},
+               output384: []byte{0x73, 0x58, 0xc6, 0xa0, 0xae, 0x58, 0xef, 0xa1, 0x4f, 0x65, 0xb8, 0xe1, 0x62, 0xf0, 0x7e, 0xf2, 0xd0, 0xad, 0x8d, 0xd2, 0x0, 0x6a, 0x98, 0x29, 0x33, 0x7, 0xb7, 0x6b, 0x3b, 0xa9, 0xe7, 0x1c, 0x30, 0x8a, 0x66, 0x94, 0xf0, 0xb5, 0x6d, 0xe8, 0xd5, 0x9e, 0x58, 0x53, 0x6c, 0x35, 0x13, 0xe8},
+               output512: []byte{0xff, 0x6a, 0xdc, 0xb9, 0xe1, 0x54, 0x67, 0x98, 0xd3, 0x96, 0xdb, 0x78, 0x45, 0x2d, 0xf1, 0xa3, 0x75, 0xb6, 0x5e, 0xe3, 0xd5, 0x4f, 0xcc, 0x91, 0x5a, 0x8c, 0xa3, 0xda, 0x69, 0x3e, 0x24, 0x93, 0x19, 0x99, 0xb0, 0xfc, 0x8a, 0x4e, 0xb9, 0x2f, 0x6f, 0xf8, 0x5e, 0x42, 0xbb, 0x4c, 0xfd, 0x9c, 0xe7, 0xd7, 0x86, 0x3e, 0xee, 0x70, 0x9c, 0x9e, 0xf3, 0x76, 0x42, 0xb6, 0x96, 0x17, 0x44, 0x74}},
+       testcase{
+               msg:       []byte{0x33, 0x70, 0x23, 0x37, 0xa, 0x48, 0xb6, 0x2e, 0xe4, 0x35, 0x46, 0xf1, 0x7c, 0x4e, 0xf2, 0xbf, 0x8d, 0x7e, 0xcd, 0x1d, 0x49, 0xf9, 0xb, 0xab, 0x60, 0x4b, 0x83, 0x9c, 0x2e, 0x6e, 0x5b, 0xd2, 0x15, 0x40, 0xd2, 0x9b, 0xa2, 0x7a, 0xb8, 0xe3, 0x9, 0xa4, 0xb7},
+               output224: []byte{0xef, 0xa7, 0xf7, 0xe7, 0xbf, 0xfa, 0x6a, 0x5e, 0x7f, 0x7d, 0x1c, 0x24, 0xe7, 0xa0, 0xa9, 0xdc, 0x9a, 0x6f, 0x72, 0xb3, 0xe9, 0x55, 0xa, 0xa, 0xaa, 0x6, 0xcc, 0xe6},
+               output256: []byte{0xee, 0x35, 0x42, 0x90, 0xe3, 0xf9, 0xce, 0x91, 0x23, 0xc4, 0x9b, 0xa6, 0x16, 0xe1, 0xa2, 0x68, 0x4a, 0x90, 0xf3, 0xdd, 0xd8, 0x4e, 0x73, 0xa1, 0xd2, 0xc2, 0x32, 0xf7, 0x40, 0x41, 0x2b, 0x18},
+               output384: []byte{0x18, 0x3, 0xc, 0x2b, 0x5e, 0xa2, 0x3b, 0x6c, 0x66, 0xbd, 0xaf, 0x18, 0xa, 0x41, 0x17, 0x33, 0x94, 0x54, 0x2, 0x15, 0xca, 0x48, 0xfb, 0x3e, 0x75, 0x84, 0x33, 0xff, 0x98, 0x84, 0xef, 0xb9, 0xe5, 0x6d, 0x29, 0x22, 0xba, 0x53, 0x20, 0xba, 0x84, 0xbe, 0x36, 0xe6, 0xef, 0xe6, 0xb8, 0x9d},
+               output512: []byte{0x10, 0x51, 0xb7, 0xff, 0x77, 0x27, 0x4b, 0x78, 0x4e, 0x7f, 0xb7, 0x82, 0x3e, 0x75, 0x6f, 0xc, 0x43, 0x55, 0x4, 0x7e, 0x48, 0x97, 0x75, 0xbb, 0xed, 0xaa, 0x7c, 0xe5, 0xa7, 0x5e, 0xfa, 0xc3, 0x31, 0x49, 0x2c, 0x1, 0x6c, 0xe0, 0x2e, 0xb2, 0xbe, 0x8b, 0xa2, 0xfe, 0x6b, 0x73, 0x5b, 0x9a, 0x14, 0x84, 0xe7, 0x3a, 0xc0, 0x6d, 0xe5, 0x73, 0xc5, 0xd0, 0xb4, 0xa5, 0x88, 0x22, 0xa3, 0x6a}},
+       testcase{
+               msg:       []byte{0x68, 0x92, 0x54, 0xf, 0x96, 0x4c, 0x8c, 0x74, 0xbd, 0x2d, 0xb0, 0x2c, 0xa, 0xd8, 0x84, 0x51, 0xc, 0xb3, 0x8a, 0xfd, 0x44, 0x38, 0xaf, 0x31, 0xfc, 0x91, 0x27, 0x56, 0xf3, 0xef, 0xec, 0x6b, 0x32, 0xb5, 0x8e, 0xbc, 0x38, 0xfc, 0x2a, 0x6b, 0x91, 0x35, 0x96, 0xa8},
+               output224: []byte{0xac, 0xa7, 0xdc, 0xcc, 0x6b, 0x80, 0x9d, 0x51, 0x1f, 0x4c, 0x24, 0x8c, 0xaa, 0x5d, 0x13, 0x74, 0xe7, 0x34, 0xc1, 0xed, 0x6b, 0x99, 0x57, 0x60, 0xcc, 0x3c, 0x56, 0xd2},
+               output256: []byte{0xfb, 0xec, 0xb, 0x6d, 0x71, 0x69, 0x6e, 0xed, 0xe9, 0x0, 0xb7, 0x7a, 0xa6, 0xd7, 0xd2, 0x5f, 0x4a, 0xb4, 0x5d, 0xf8, 0x96, 0x1c, 0xa9, 0xc8, 0xb3, 0xf4, 0xf9, 0xb5, 0x1a, 0xf9, 0x83, 0xab},
+               output384: []byte{0x6f, 0x9f, 0x90, 0x16, 0xac, 0x3b, 0x6a, 0x59, 0x78, 0xa5, 0xdc, 0x8c, 0x75, 0x6, 0xc8, 0xb4, 0xd2, 0x87, 0x42, 0x25, 0x3b, 0xc5, 0x42, 0xe7, 0x9d, 0x95, 0x82, 0x44, 0x17, 0xaa, 0x54, 0x29, 0x91, 0xee, 0xf7, 0xe2, 0xb9, 0xc5, 0x8c, 0xdb, 0xc, 0x93, 0x61, 0x6a, 0xe9, 0xc1, 0xf8, 0x8f},
+               output512: []byte{0x56, 0x39, 0xa2, 0x82, 0x42, 0x97, 0xca, 0x9, 0x9e, 0xcf, 0x2a, 0x81, 0xee, 0xf1, 0x75, 0x3f, 0x63, 0x14, 0xcb, 0x66, 0x3d, 0x86, 0xf, 0x5, 0xa3, 0x9e, 0x3e, 0x80, 0x1f, 0xf8, 0x20, 0x60, 0xbb, 0xa1, 0x6, 0x28, 0xe2, 0xc0, 0xd9, 0xe0, 0xa8, 0x4d, 0xd0, 0x5e, 0xd6, 0x37, 0xfc, 0xb, 0x65, 0xba, 0x3, 0xbb, 0x66, 0xe4, 0x6f, 0xb2, 0x56, 0xf2, 0xa5, 0xb2, 0x8d, 0x3f, 0x41, 0xd2}},
+       testcase{
+               msg:       []byte{0xf5, 0x96, 0x1d, 0xfd, 0x2b, 0x1f, 0xff, 0xfd, 0xa4, 0xff, 0xbf, 0x30, 0x56, 0xc, 0x16, 0x5b, 0xfe, 0xda, 0xb8, 0xce, 0xb, 0xe5, 0x25, 0x84, 0x5d, 0xeb, 0x8d, 0xc6, 0x10, 0x4, 0xb7, 0xdb, 0x38, 0x46, 0x72, 0x5, 0xf5, 0xdc, 0xfb, 0x34, 0xa2, 0xac, 0xfe, 0x96, 0xc0},
+               output224: []byte{0x6f, 0x1e, 0xf5, 0x5c, 0xcc, 0x6e, 0xf9, 0xb6, 0x8d, 0xe5, 0x4c, 0x14, 0x44, 0x84, 0x87, 0x90, 0x10, 0x22, 0x45, 0x2a, 0xb7, 0x61, 0xf8, 0x46, 0x44, 0xe9, 0xa1, 0x27},
+               output256: []byte{0x9d, 0x24, 0xae, 0xea, 0x8, 0xf9, 0xa4, 0xb5, 0xfb, 0x8b, 0x6d, 0xe8, 0x5a, 0x22, 0x96, 0xf5, 0xf4, 0x10, 0x8d, 0xdd, 0x1e, 0xea, 0x4f, 0x8e, 0xe5, 0x88, 0x19, 0xcf, 0x84, 0xed, 0xb7, 0x65},
+               output384: []byte{0x42, 0x44, 0x21, 0xbb, 0x93, 0x99, 0xbd, 0x44, 0xab, 0x76, 0x50, 0x2, 0x73, 0xd7, 0xf1, 0xe1, 0x42, 0x1a, 0x2b, 0xfd, 0xe1, 0xa1, 0xc1, 0x30, 0xc0, 0xb3, 0x47, 0x44, 0x9, 0xd8, 0xae, 0x92, 0xb3, 0xe3, 0x85, 0x39, 0xcf, 0xb0, 0x9e, 0xd1, 0xd2, 0x3c, 0x62, 0xbb, 0x32, 0xb9, 0x36, 0x4b},
+               output512: []byte{0x97, 0xf9, 0xd6, 0x42, 0x50, 0x7e, 0x6d, 0xd1, 0x79, 0xd5, 0x6f, 0x4b, 0x81, 0x5e, 0x92, 0xd0, 0xd4, 0x86, 0x82, 0x6f, 0x27, 0x3e, 0xc7, 0x11, 0xb8, 0xf9, 0xcb, 0x76, 0xaf, 0xc7, 0x9f, 0x90, 0x8, 0x16, 0xfd, 0xbc, 0x13, 0xdd, 0x3a, 0x59, 0xfb, 0xec, 0xba, 0x1f, 0x3b, 0x69, 0x53, 0xf8, 0x79, 0xf2, 0x7c, 0x89, 0x87, 0xb2, 0x4c, 0x6f, 0xf8, 0x55, 0x7a, 0x2c, 0x83, 0x40, 0x76, 0xb9}},
+       testcase{
+               msg:       []byte{0xca, 0x6, 0x1a, 0x2e, 0xb6, 0xce, 0xed, 0x88, 0x81, 0xce, 0x20, 0x57, 0x17, 0x2d, 0x86, 0x9d, 0x73, 0xa1, 0x95, 0x1e, 0x63, 0xd5, 0x72, 0x61, 0x38, 0x4b, 0x80, 0xce, 0xb5, 0x45, 0x1e, 0x77, 0xb0, 0x6c, 0xf0, 0xf5, 0xa0, 0xea, 0x15, 0xca, 0x90, 0x7e, 0xe1, 0xc2, 0x7e, 0xba},
+               output224: []byte{0xb2, 0x97, 0xf6, 0x1f, 0xf0, 0x60, 0x21, 0xbf, 0xe1, 0xb9, 0xd3, 0x50, 0xb3, 0xf5, 0x4d, 0x81, 0xb, 0xc1, 0x6a, 0xde, 0x17, 0x0, 0x1b, 0xae, 0x1b, 0x4c, 0xd4, 0xa2},
+               output256: []byte{0x73, 0x20, 0x34, 0xca, 0xe3, 0xff, 0x11, 0x16, 0xf0, 0x7f, 0xc1, 0x8b, 0x5a, 0x26, 0xef, 0x8f, 0xaf, 0x3f, 0xe7, 0x5d, 0x3d, 0xbc, 0xa0, 0x5e, 0x48, 0x79, 0x53, 0x65, 0xe0, 0xa1, 0x7c, 0x40},
+               output384: []byte{0xd0, 0x7a, 0x2c, 0xac, 0xee, 0xa8, 0x69, 0x27, 0x4b, 0xae, 0xec, 0xda, 0x43, 0xb6, 0x2, 0x9, 0x30, 0xef, 0x38, 0x3a, 0x89, 0x7c, 0x72, 0xa7, 0xac, 0x7f, 0xbd, 0x8f, 0xf5, 0xce, 0xa7, 0xf8, 0xbe, 0x65, 0x58, 0x44, 0xd9, 0xf9, 0xbd, 0x2b, 0x49, 0x88, 0x80, 0xfa, 0x15, 0x27, 0xd9, 0x4f},
+               output512: []byte{0xaf, 0xef, 0x2a, 0xf5, 0xa0, 0x1b, 0x89, 0xbe, 0x19, 0xa, 0xe, 0x6e, 0x79, 0x6a, 0xa5, 0x1f, 0x1f, 0x8c, 0x35, 0x67, 0x72, 0xc6, 0xfc, 0x77, 0x31, 0xf0, 0x8a, 0xab, 0x8b, 0xd8, 0x1a, 0xee, 0x12, 0x87, 0xc7, 0xd, 0x56, 0x4f, 0x4f, 0x16, 0x9e, 0x37, 0xb0, 0x7f, 0x28, 0x20, 0x2a, 0x85, 0xf4, 0x68, 0x28, 0x1b, 0x4c, 0xdc, 0x12, 0x73, 0xcf, 0x61, 0xeb, 0x30, 0xe3, 0xbd, 0xce, 0xe1}},
+       testcase{
+               msg:       []byte{0x17, 0x43, 0xa7, 0x72, 0x51, 0xd6, 0x92, 0x42, 0x75, 0xc, 0x4f, 0x11, 0x40, 0x53, 0x2c, 0xd3, 0xc3, 0x3f, 0x9b, 0x5c, 0xcd, 0xf7, 0x51, 0x4e, 0x85, 0x84, 0xd4, 0xa5, 0xf9, 0xfb, 0xd7, 0x30, 0xbc, 0xf8, 0x4d, 0xd, 0x47, 0x26, 0x36, 0x4b, 0x9b, 0xf9, 0x5a, 0xb2, 0x51, 0xd9, 0xbb},
+               output224: []byte{0xbe, 0x9a, 0x75, 0x43, 0x6c, 0x39, 0x88, 0xfb, 0x2f, 0xe2, 0x1d, 0xc, 0x10, 0xea, 0xd9, 0xb9, 0xc8, 0x7, 0xde, 0x2e, 0x13, 0xa9, 0xbd, 0x84, 0x37, 0xf1, 0x33, 0x32},
+               output256: []byte{0xde, 0xac, 0x52, 0x18, 0x5, 0xbc, 0x6a, 0x97, 0xc0, 0x87, 0xe, 0x9e, 0x22, 0x5d, 0x1c, 0x4b, 0x2f, 0xd8, 0xf3, 0xa9, 0xa7, 0xf6, 0xb3, 0x9e, 0x35, 0x7c, 0x26, 0x41, 0x48, 0x21, 0xe2, 0xdd},
+               output384: []byte{0x25, 0xd7, 0xab, 0x5e, 0x93, 0x8, 0x19, 0xcf, 0x5f, 0x59, 0xac, 0xd2, 0x54, 0x26, 0x91, 0xad, 0x66, 0x48, 0x1d, 0xa5, 0x47, 0xea, 0xa9, 0xc2, 0xad, 0xd7, 0xc8, 0xea, 0x69, 0xa4, 0x75, 0xf4, 0x16, 0xc4, 0x30, 0xea, 0x1d, 0xe8, 0x40, 0x97, 0x4e, 0x32, 0x36, 0xa6, 0x25, 0x20, 0x91, 0x1f},
+               output512: []byte{0xf4, 0x67, 0xcc, 0xa6, 0x7c, 0x38, 0x7f, 0xfc, 0x9f, 0x1b, 0x17, 0x3a, 0x8, 0x4c, 0x45, 0x10, 0x95, 0xd0, 0x1a, 0xd0, 0xbf, 0x39, 0x53, 0xac, 0x10, 0x3a, 0x76, 0xf0, 0xf1, 0xbc, 0x86, 0x16, 0x73, 0x5, 0xa9, 0x26, 0xa9, 0x41, 0xa5, 0x34, 0x17, 0xf1, 0x61, 0x1a, 0x50, 0x5a, 0xaa, 0x20, 0x5b, 0xcf, 0xcc, 0xbf, 0xd3, 0x43, 0x46, 0x5d, 0xad, 0x8a, 0x6c, 0x1e, 0x80, 0x60, 0x9a, 0x9d}},
+       testcase{
+               msg:       []byte{0xd8, 0xfa, 0xba, 0x1f, 0x51, 0x94, 0xc4, 0xdb, 0x5f, 0x17, 0x6f, 0xab, 0xff, 0xf8, 0x56, 0x92, 0x4e, 0xf6, 0x27, 0xa3, 0x7c, 0xd0, 0x8c, 0xf5, 0x56, 0x8, 0xbb, 0xa8, 0xf1, 0xe3, 0x24, 0xd7, 0xc7, 0xf1, 0x57, 0x29, 0x8e, 0xab, 0xc4, 0xdc, 0xe7, 0xd8, 0x9c, 0xe5, 0x16, 0x24, 0x99, 0xf9},
+               output224: []byte{0x43, 0x4, 0x58, 0x2c, 0x38, 0x92, 0x94, 0x2b, 0x19, 0x60, 0x82, 0x2c, 0x96, 0x57, 0x88, 0xb2, 0x2d, 0xe1, 0x9f, 0x1c, 0x6d, 0x5e, 0x20, 0x44, 0x76, 0xad, 0xfd, 0x26},
+               output256: []byte{0xad, 0x55, 0x53, 0x73, 0x47, 0xb2, 0xd, 0x9f, 0xca, 0x2, 0x68, 0x3e, 0x6d, 0xe1, 0x3, 0x2e, 0xc1, 0xe, 0xb8, 0x4d, 0xa4, 0xcb, 0xd5, 0x1, 0xe4, 0x97, 0x44, 0xa6, 0x66, 0x29, 0x2e, 0xdf},
+               output384: []byte{0x36, 0xa6, 0xbf, 0x2d, 0x4e, 0xb3, 0xcc, 0x6f, 0xb7, 0x97, 0x91, 0x4e, 0x73, 0x4b, 0x2c, 0xa8, 0x70, 0x2c, 0xa7, 0xcc, 0x6d, 0x53, 0x9b, 0x4d, 0xdb, 0x23, 0x3e, 0xfa, 0xfc, 0xf0, 0x68, 0x71, 0x2e, 0x84, 0x53, 0x64, 0xa4, 0xa9, 0x29, 0xd3, 0x1a, 0x44, 0xc, 0x7d, 0xaf, 0x8b, 0x13, 0x4c},
+               output512: []byte{0x4b, 0x38, 0x9a, 0x2a, 0xd, 0xf5, 0xe2, 0x95, 0xea, 0x94, 0x44, 0xf2, 0x73, 0x9b, 0x54, 0x92, 0xf2, 0x90, 0xc4, 0x46, 0x7b, 0xb, 0x4c, 0xdc, 0x1c, 0xc9, 0xed, 0x2c, 0xef, 0xa7, 0xa9, 0xe5, 0x27, 0xe0, 0x62, 0x7c, 0xda, 0xf0, 0xbd, 0xa5, 0x8f, 0x17, 0xd1, 0x3f, 0x94, 0xaf, 0x7d, 0x2d, 0xef, 0xf6, 0xfc, 0x5d, 0x53, 0xdd, 0x91, 0x57, 0x67, 0x44, 0x75, 0x52, 0x7f, 0xbb, 0x4f, 0x86}},
+       testcase{
+               msg:       []byte{0xbe, 0x96, 0x84, 0xbe, 0x70, 0x34, 0x8, 0x60, 0x37, 0x3c, 0x9c, 0x48, 0x2b, 0xa5, 0x17, 0xe8, 0x99, 0xfc, 0x81, 0xba, 0xaa, 0x12, 0xe5, 0xc6, 0xd7, 0x72, 0x79, 0x75, 0xd1, 0xd4, 0x1b, 0xa8, 0xbe, 0xf7, 0x88, 0xcd, 0xb5, 0xcf, 0x46, 0x6, 0xc9, 0xc1, 0xc7, 0xf6, 0x1a, 0xed, 0x59, 0xf9, 0x7d},
+               output224: []byte{0x4, 0x80, 0xef, 0x85, 0x19, 0xc3, 0x2f, 0x89, 0xc6, 0x5b, 0x8d, 0xd4, 0x50, 0x2, 0x5e, 0xc4, 0x9c, 0xbd, 0xad, 0xa6, 0xc4, 0xcf, 0xcf, 0xc6, 0xfb, 0x4f, 0x1c, 0x61},
+               output256: []byte{0xb1, 0xf9, 0x90, 0x20, 0x4b, 0xf6, 0x30, 0x56, 0x9a, 0x3e, 0xdc, 0x63, 0x48, 0x64, 0x27, 0x47, 0x86, 0xf4, 0xc, 0xe1, 0xc5, 0x71, 0x65, 0xee, 0x32, 0xd0, 0xe2, 0x9f, 0x5d, 0xc, 0x68, 0x51},
+               output384: []byte{0xb6, 0x9d, 0x40, 0xa9, 0x2, 0x7, 0xed, 0xb2, 0xc, 0x0, 0x68, 0xf4, 0x2, 0x0, 0x8c, 0xe, 0x64, 0x30, 0xb, 0x89, 0xa1, 0xb6, 0xaf, 0x79, 0x30, 0x70, 0x8b, 0x26, 0x3c, 0x79, 0xa, 0x8, 0x7f, 0x3a, 0xdb, 0xb4, 0xc8, 0x42, 0x95, 0xd2, 0x33, 0x92, 0xe0, 0x69, 0x2f, 0x35, 0xbd, 0xbc},
+               output512: []byte{0x65, 0x90, 0xff, 0xfb, 0x73, 0x11, 0xab, 0x7d, 0xab, 0x37, 0xf, 0xb5, 0x18, 0xcc, 0xc1, 0x9b, 0xaa, 0x9a, 0xf7, 0xc8, 0x41, 0x79, 0xad, 0xb0, 0x2, 0xf8, 0xfa, 0xcd, 0x3c, 0x44, 0xaf, 0x28, 0x30, 0xa8, 0x4d, 0xf1, 0xe2, 0xc2, 0x40, 0x23, 0x68, 0xcc, 0x36, 0x61, 0x4a, 0x6e, 0xa2, 0x29, 0x3, 0x6, 0x3e, 0x57, 0xd0, 0xe, 0xc5, 0x11, 0xa4, 0x6a, 0x9a, 0x3, 0xfe, 0x38, 0x19, 0xf7}},
+       testcase{
+               msg:       []byte{0x7e, 0x15, 0xd2, 0xb9, 0xea, 0x74, 0xca, 0x60, 0xf6, 0x6c, 0x8d, 0xfa, 0xb3, 0x77, 0xd9, 0x19, 0x8b, 0x7b, 0x16, 0xde, 0xb6, 0xa1, 0xba, 0xe, 0xa3, 0xc7, 0xee, 0x20, 0x42, 0xf8, 0x9d, 0x37, 0x86, 0xe7, 0x79, 0xcf, 0x5, 0x3c, 0x77, 0x78, 0x5a, 0xa9, 0xe6, 0x92, 0xf8, 0x21, 0xf1, 0x4a, 0x7f, 0x51},
+               output224: []byte{0xb, 0xde, 0x9c, 0xd5, 0xd, 0x70, 0xf0, 0xe, 0xed, 0x97, 0xcc, 0xe4, 0xc, 0x3d, 0xf2, 0x2b, 0xb4, 0x90, 0x4c, 0x8, 0xc4, 0x17, 0x7c, 0x3a, 0x95, 0x98, 0x5d, 0x97},
+               output256: []byte{0xfa, 0x46, 0xc, 0xd5, 0x1b, 0xc6, 0x11, 0x78, 0x6d, 0x36, 0x4f, 0xca, 0xbe, 0x39, 0x5, 0x2b, 0xcd, 0x5f, 0x0, 0x9e, 0xdf, 0xa8, 0x1f, 0x47, 0x1, 0xc5, 0xb2, 0x2b, 0x72, 0x9b, 0x0, 0x16},
+               output384: []byte{0xcd, 0xdb, 0x88, 0x3b, 0x9e, 0xad, 0xc5, 0x9d, 0x28, 0x94, 0x17, 0x8b, 0x3b, 0xa6, 0xf6, 0x1e, 0x5e, 0x11, 0xc2, 0xc4, 0x15, 0xc8, 0x9e, 0x55, 0x4e, 0x20, 0xa1, 0x7e, 0x49, 0x9, 0xf8, 0xd9, 0x60, 0xf0, 0x2a, 0xa8, 0xe, 0x1a, 0x51, 0x29, 0xae, 0xeb, 0xf2, 0xcf, 0x97, 0x57, 0x11, 0xa4},
+               output512: []byte{0x89, 0x57, 0x96, 0xb2, 0xa0, 0x82, 0x4c, 0x55, 0xf0, 0x30, 0xd8, 0x2e, 0x79, 0x49, 0x25, 0xc3, 0x8d, 0x84, 0x59, 0xf3, 0x8c, 0xf8, 0x48, 0x51, 0x9f, 0x12, 0xf, 0xf6, 0xa9, 0xd5, 0xa0, 0x3e, 0xbf, 0x0, 0x6c, 0x3e, 0xa5, 0x2, 0x1e, 0x8f, 0x3b, 0x34, 0x8, 0xff, 0x12, 0xf0, 0x1b, 0xcd, 0xdf, 0x7a, 0x8, 0x5b, 0xa0, 0xa9, 0xa5, 0x89, 0x44, 0xfe, 0xc1, 0xf5, 0x54, 0x83, 0x6d, 0xf8}},
+       testcase{
+               msg:       []byte{0x9a, 0x21, 0x9b, 0xe4, 0x37, 0x13, 0xbd, 0x57, 0x80, 0x15, 0xe9, 0xfd, 0xa6, 0x6c, 0xf, 0x2d, 0x83, 0xca, 0xc5, 0x63, 0xb7, 0x76, 0xab, 0x9f, 0x38, 0xf3, 0xe4, 0xf7, 0xef, 0x22, 0x9c, 0xb4, 0x43, 0x30, 0x4f, 0xba, 0x40, 0x1e, 0xfb, 0x2b, 0xdb, 0xd7, 0xec, 0xe9, 0x39, 0x10, 0x22, 0x98, 0x65, 0x1c, 0x86},
+               output224: []byte{0x3b, 0xf3, 0xad, 0xdb, 0x76, 0x1a, 0xb3, 0x2a, 0x38, 0xb7, 0xb4, 0x70, 0x47, 0xad, 0x45, 0xb6, 0x8e, 0xdf, 0xd8, 0x8e, 0xd4, 0x75, 0x22, 0x74, 0x47, 0xea, 0x1b, 0x1e},
+               output256: []byte{0xf7, 0xb0, 0xfe, 0x5a, 0x69, 0xff, 0x44, 0x6, 0xd, 0x4f, 0x6a, 0xd2, 0x48, 0x6e, 0x6c, 0xde, 0x9e, 0xd6, 0x79, 0xaf, 0x9a, 0xa1, 0xad, 0xa6, 0x13, 0xe4, 0xcc, 0x39, 0x24, 0x42, 0xbe, 0xb5},
+               output384: []byte{0xfb, 0xe0, 0x5, 0x6d, 0x65, 0xaf, 0x27, 0x9e, 0xff, 0x15, 0x73, 0xf1, 0x69, 0x80, 0x9a, 0x5, 0xb6, 0xa5, 0x21, 0x12, 0xb6, 0x62, 0xd0, 0x7c, 0xdd, 0x25, 0x70, 0xbe, 0x5e, 0x19, 0x8a, 0x28, 0xd1, 0xea, 0x49, 0xcb, 0xea, 0xf0, 0xc0, 0x5e, 0x76, 0xa9, 0xf0, 0x9b, 0xaf, 0x6d, 0x1f, 0x34},
+               output512: []byte{0xe4, 0xbb, 0xd5, 0x4b, 0xfb, 0x99, 0xd3, 0x45, 0x47, 0x1f, 0x8a, 0xb9, 0x42, 0x71, 0xb4, 0xb7, 0x48, 0xf5, 0xce, 0x70, 0xc2, 0x1c, 0x28, 0xae, 0x65, 0x59, 0xe0, 0x3e, 0xe7, 0x89, 0xa, 0x2c, 0x81, 0x40, 0x43, 0xe6, 0x24, 0xa6, 0xbd, 0x29, 0x44, 0x35, 0x7, 0x56, 0xb3, 0x7f, 0xa8, 0x20, 0x8f, 0xc7, 0x47, 0x3a, 0x67, 0xb3, 0x10, 0xce, 0xeb, 0xc1, 0x7d, 0x96, 0x5e, 0xd6, 0x88, 0xb2}},
+       testcase{
+               msg:       []byte{0xc8, 0xf2, 0xb6, 0x93, 0xbd, 0xd, 0x75, 0xef, 0x99, 0xca, 0xeb, 0xdc, 0x22, 0xad, 0xf4, 0x8, 0x8a, 0x95, 0xa3, 0x54, 0x2f, 0x63, 0x72, 0x3, 0xe2, 0x83, 0xbb, 0xc3, 0x26, 0x87, 0x80, 0xe7, 0x87, 0xd6, 0x8d, 0x28, 0xcc, 0x38, 0x97, 0x45, 0x2f, 0x6a, 0x22, 0xaa, 0x85, 0x73, 0xcc, 0xeb, 0xf2, 0x45, 0x97, 0x2a},
+               output224: []byte{0x61, 0x82, 0x61, 0x4c, 0x82, 0x57, 0xeb, 0x5, 0xe9, 0xac, 0x9, 0x50, 0xe1, 0x5e, 0x60, 0x44, 0x87, 0x2e, 0x5c, 0xa, 0xb2, 0xaf, 0x45, 0x40, 0x76, 0x4c, 0xa0, 0xc8},
+               output256: []byte{0x24, 0x20, 0x4d, 0x49, 0x1f, 0x20, 0x25, 0x34, 0x85, 0x9f, 0xc0, 0xa2, 0x8, 0x23, 0x71, 0x84, 0x47, 0x1a, 0x2d, 0x80, 0x1f, 0xb3, 0xb9, 0x34, 0xd0, 0x96, 0x8d, 0xd, 0x84, 0x3d, 0x3, 0x45},
+               output384: []byte{0x26, 0x47, 0x3d, 0xe6, 0x84, 0xcf, 0x58, 0xd5, 0x59, 0xc7, 0xc0, 0xcf, 0xd3, 0x60, 0xa9, 0xaf, 0xfd, 0xf3, 0x39, 0x0, 0xfd, 0x69, 0xa3, 0xa9, 0x46, 0x58, 0x14, 0x84, 0xb9, 0x3e, 0xf6, 0xfe, 0x6f, 0xfa, 0xc4, 0x61, 0xb4, 0x55, 0x1e, 0x13, 0x6b, 0xea, 0xc6, 0x4c, 0xc3, 0x3a, 0x4c, 0x15},
+               output512: []byte{0x80, 0xd8, 0x62, 0xad, 0x5, 0x42, 0x8a, 0x29, 0x92, 0x13, 0xe6, 0x5b, 0x50, 0x31, 0x4, 0x63, 0xfd, 0x22, 0xc5, 0x5, 0xe6, 0x93, 0xdd, 0x47, 0x19, 0xe0, 0xa1, 0x20, 0xee, 0xaa, 0x35, 0xc5, 0xfc, 0x16, 0x8, 0xa0, 0x8d, 0x22, 0xe2, 0xcc, 0xdd, 0xec, 0xa4, 0x98, 0x78, 0xbc, 0x26, 0xab, 0xe5, 0x5a, 0x3c, 0x9a, 0x54, 0x63, 0x47, 0x43, 0x9a, 0x94, 0x2e, 0xd0, 0xc1, 0xa6, 0xa2, 0x3e}},
+       testcase{
+               msg:       []byte{0xec, 0xf, 0x99, 0x71, 0x10, 0x16, 0xc6, 0xa2, 0xa0, 0x7a, 0xd8, 0xd, 0x16, 0x42, 0x75, 0x6, 0xce, 0x6f, 0x44, 0x10, 0x59, 0xfd, 0x26, 0x94, 0x42, 0xba, 0xaa, 0x28, 0xc6, 0xca, 0x3, 0x7b, 0x22, 0xee, 0xac, 0x49, 0xd5, 0xd8, 0x94, 0xc0, 0xbf, 0x66, 0x21, 0x9f, 0x2c, 0x8, 0xe9, 0xd0, 0xe8, 0xab, 0x21, 0xde, 0x52},
+               output224: []byte{0xb, 0x5d, 0xc7, 0x22, 0xee, 0xa2, 0xc3, 0x48, 0x32, 0x5f, 0xd9, 0xb3, 0xd7, 0xf0, 0x8f, 0x36, 0x5b, 0x71, 0xd5, 0xb5, 0x82, 0xc2, 0x7b, 0xeb, 0x79, 0xb5, 0x1d, 0x5d},
+               output256: []byte{0x81, 0x14, 0x7c, 0xba, 0x6, 0x47, 0xee, 0xe7, 0x8c, 0x47, 0x84, 0x87, 0x4c, 0x5, 0x57, 0x62, 0x1a, 0x13, 0x8c, 0xa7, 0x81, 0xfb, 0x6f, 0x5d, 0xcd, 0xd, 0x9c, 0x60, 0x9a, 0xf5, 0x6f, 0x35},
+               output384: []byte{0x46, 0x2a, 0xd9, 0x7b, 0xb0, 0x15, 0x6a, 0x5d, 0xa3, 0xdd, 0xe, 0x9e, 0x5b, 0xf0, 0x6d, 0x31, 0x2, 0x4f, 0xe4, 0x3b, 0xb8, 0xc, 0x1, 0x8f, 0x68, 0x58, 0xee, 0x43, 0x32, 0xf2, 0xeb, 0x5a, 0x78, 0xad, 0xa0, 0x6c, 0xb5, 0x5d, 0xdc, 0x17, 0x2a, 0xd8, 0x7f, 0x88, 0xe2, 0x6d, 0x24, 0x51},
+               output512: []byte{0x2, 0x1b, 0x3b, 0x39, 0x2d, 0xec, 0xcb, 0x90, 0x75, 0x55, 0x9f, 0x88, 0xc0, 0xc2, 0x29, 0x2, 0x6a, 0x20, 0x48, 0xce, 0xf8, 0xee, 0xb2, 0xd4, 0xf9, 0x48, 0x3, 0xdc, 0xf2, 0xda, 0xa, 0x73, 0xe0, 0x4, 0xd7, 0xf1, 0x4e, 0x9f, 0xd6, 0x62, 0x67, 0xb, 0x59, 0x22, 0x9a, 0xb3, 0x88, 0x3c, 0x34, 0xf, 0x4e, 0x3a, 0x8c, 0x42, 0x62, 0x4c, 0xcb, 0x90, 0xbe, 0xc1, 0x15, 0x6f, 0x95, 0xd4}},
+       testcase{
+               msg:       []byte{0xd, 0xc4, 0x51, 0x81, 0x33, 0x7c, 0xa3, 0x2a, 0x82, 0x22, 0xfe, 0x7a, 0x3b, 0xf4, 0x2f, 0xc9, 0xf8, 0x97, 0x44, 0x25, 0x9c, 0xff, 0x65, 0x35, 0x4, 0xd6, 0x5, 0x1f, 0xe8, 0x4b, 0x1a, 0x7f, 0xfd, 0x20, 0xcb, 0x47, 0xd4, 0x69, 0x6c, 0xe2, 0x12, 0xa6, 0x86, 0xbb, 0x9b, 0xe9, 0xa8, 0xab, 0x1c, 0x69, 0x7b, 0x6d, 0x6a, 0x33},
+               output224: []byte{0x29, 0xc2, 0xb8, 0x17, 0xc7, 0x5b, 0x64, 0x17, 0xbc, 0x89, 0xc2, 0x62, 0xaf, 0x9d, 0x58, 0xf0, 0xc1, 0x8f, 0xbd, 0x99, 0x1f, 0x59, 0xf4, 0x18, 0x1f, 0x23, 0x70, 0x38},
+               output256: []byte{0x5b, 0x6d, 0x7e, 0xda, 0x55, 0x95, 0x74, 0xfa, 0xe8, 0x82, 0xe6, 0x26, 0x6f, 0x4c, 0x2b, 0xe3, 0x62, 0x13, 0x3e, 0x44, 0xb5, 0xa9, 0x47, 0xec, 0xb6, 0xe7, 0x5d, 0xb9, 0xfc, 0x85, 0x67, 0xe0},
+               output384: []byte{0x9f, 0x89, 0xf, 0xa8, 0xa, 0x4c, 0x48, 0xb6, 0x71, 0x81, 0xe8, 0x9d, 0xbf, 0x15, 0x17, 0x5c, 0xe4, 0x8b, 0x21, 0xf9, 0xd0, 0x94, 0x5, 0x21, 0x8a, 0x8c, 0xe3, 0xc0, 0x75, 0x92, 0x82, 0x78, 0xe, 0x14, 0x2f, 0xc5, 0x98, 0x51, 0x15, 0x7d, 0x14, 0x50, 0x9f, 0xce, 0x79, 0xd1, 0xb1, 0x7f},
+               output512: []byte{0x97, 0xbf, 0x33, 0xa5, 0x25, 0x4c, 0x8a, 0xca, 0x27, 0x48, 0x64, 0x28, 0x44, 0xb, 0x10, 0x34, 0xaa, 0xaf, 0xac, 0x8b, 0x49, 0x8e, 0xcb, 0x83, 0xc, 0x25, 0x81, 0xdc, 0x68, 0x51, 0x80, 0x79, 0xb6, 0x5f, 0xb0, 0xc5, 0x95, 0x99, 0x76, 0x93, 0xdd, 0xb8, 0xd6, 0x8d, 0x95, 0x64, 0xea, 0x98, 0xdc, 0x43, 0xcd, 0x28, 0x7e, 0x2e, 0x1, 0x8d, 0xb7, 0xdf, 0xaa, 0xaa, 0x20, 0x5c, 0x54, 0x7a}},
+       testcase{
+               msg:       []byte{0xde, 0x28, 0x6b, 0xa4, 0x20, 0x6e, 0x8b, 0x0, 0x57, 0x14, 0xf8, 0xf, 0xb1, 0xcd, 0xfa, 0xeb, 0xde, 0x91, 0xd2, 0x9f, 0x84, 0x60, 0x3e, 0x4a, 0x3e, 0xbc, 0x4, 0x68, 0x6f, 0x99, 0xa4, 0x6c, 0x9e, 0x88, 0xb, 0x96, 0xc5, 0x74, 0x82, 0x55, 0x82, 0xe8, 0x81, 0x2a, 0x26, 0xe5, 0xa8, 0x57, 0xff, 0xc6, 0x57, 0x9f, 0x63, 0x74, 0x2f},
+               output224: []byte{0x62, 0xc5, 0x87, 0x66, 0x94, 0xd8, 0x80, 0x7, 0x70, 0x9b, 0x50, 0x90, 0xe, 0xe2, 0xe6, 0xca, 0x95, 0x5, 0xcc, 0x90, 0x6, 0x7e, 0xfb, 0xf4, 0xc1, 0xd9, 0x5b, 0xb},
+               output256: []byte{0x86, 0xf8, 0x7e, 0x75, 0xc8, 0x7f, 0x9b, 0xe3, 0x9e, 0x4a, 0xa6, 0xd0, 0xc5, 0xa3, 0x7a, 0x59, 0x64, 0xd6, 0xff, 0xdc, 0x46, 0x25, 0x25, 0xc0, 0x64, 0x2c, 0x9d, 0xb0, 0x10, 0xde, 0x38, 0xee},
+               output384: []byte{0x2d, 0x9a, 0x34, 0x47, 0xd7, 0x72, 0x3d, 0x83, 0x7b, 0x87, 0x84, 0xfe, 0xaf, 0x3, 0xb8, 0xf9, 0x69, 0x4c, 0xde, 0x5f, 0xfb, 0x84, 0xc6, 0xa6, 0x62, 0x88, 0x95, 0xa3, 0x45, 0xbb, 0x8f, 0x3f, 0x5b, 0xa7, 0x25, 0x41, 0x69, 0x6, 0xde, 0x6, 0x3b, 0x1c, 0xef, 0xb7, 0x22, 0xc7, 0xe5, 0x6a},
+               output512: []byte{0xc0, 0x5f, 0xd9, 0xc3, 0xfa, 0x73, 0xf8, 0x9, 0x56, 0xff, 0x1c, 0x3b, 0x89, 0x16, 0xe, 0xb5, 0x20, 0xca, 0x64, 0xe, 0x20, 0x1b, 0x3f, 0xe5, 0xe6, 0xe2, 0x96, 0x22, 0xe, 0x81, 0xb5, 0x9d, 0x53, 0x4, 0x76, 0x1, 0xd, 0x37, 0x84, 0xca, 0x8, 0x69, 0x2b, 0x8c, 0x71, 0x6a, 0x3b, 0xe9, 0x82, 0xb3, 0x74, 0x50, 0xa9, 0x6d, 0x30, 0xa4, 0x1, 0xd3, 0xba, 0x3c, 0x39, 0xd, 0x9d, 0xe3}},
+       testcase{
+               msg:       []byte{0xee, 0xbc, 0xc1, 0x80, 0x57, 0x25, 0x2c, 0xbf, 0x3f, 0x9c, 0x7, 0xf, 0x1a, 0x73, 0x21, 0x33, 0x56, 0xd5, 0xd4, 0xbc, 0x19, 0xac, 0x2a, 0x41, 0x1e, 0xc8, 0xcd, 0xee, 0xe7, 0xa5, 0x71, 0xe2, 0xe2, 0xe, 0xaf, 0x61, 0xfd, 0xc, 0x33, 0xa0, 0xff, 0xeb, 0x29, 0x7d, 0xdb, 0x77, 0xa9, 0x7f, 0xa, 0x41, 0x53, 0x47, 0xdb, 0x66, 0xbc, 0xaf},
+               output224: []byte{0xd3, 0x62, 0xbe, 0x78, 0x96, 0xb2, 0xac, 0x3c, 0xa4, 0xdc, 0x31, 0x61, 0xb7, 0xf6, 0xc5, 0xb3, 0xfb, 0xe6, 0x5f, 0x32, 0xd0, 0x40, 0x40, 0x2b, 0x8d, 0x30, 0x6b, 0x15},
+               output256: []byte{0x95, 0x9f, 0xe0, 0x7, 0xb5, 0x7c, 0x29, 0x47, 0xc3, 0x6d, 0x1d, 0x66, 0xcc, 0x8, 0x8, 0xd8, 0xd, 0xb7, 0xdf, 0x45, 0xd6, 0x8a, 0x34, 0x85, 0x2b, 0x70, 0xd2, 0xdd, 0xa1, 0x92, 0xc2, 0x5c},
+               output384: []byte{0xaf, 0x41, 0x50, 0x63, 0xa5, 0xe2, 0x5c, 0x6e, 0x55, 0xec, 0xa7, 0xf9, 0xbd, 0x1c, 0xb0, 0xc7, 0x1a, 0x7a, 0x5, 0x9b, 0x56, 0x97, 0x37, 0x3, 0x6b, 0x33, 0x9c, 0xa5, 0x59, 0xcc, 0x9c, 0x74, 0x66, 0xfa, 0x23, 0x9e, 0xa5, 0x7c, 0xfb, 0x5f, 0xcc, 0x50, 0x94, 0x48, 0x71, 0xc0, 0x8, 0xfb},
+               output512: []byte{0xb9, 0x80, 0xe6, 0x57, 0xc1, 0x37, 0x26, 0xdb, 0xad, 0xb6, 0x57, 0xe, 0xa3, 0xa9, 0xe6, 0x33, 0x86, 0x9c, 0xad, 0xb7, 0x98, 0xeb, 0x35, 0xc4, 0x82, 0x69, 0x7a, 0x4, 0xcb, 0x71, 0x2f, 0x1c, 0x1e, 0x8c, 0x5d, 0xb, 0xd6, 0x7e, 0x43, 0xe5, 0x2d, 0xa2, 0x94, 0xe8, 0x2d, 0x5e, 0x80, 0xa6, 0x95, 0xa7, 0x4a, 0x3d, 0x27, 0xc0, 0xc6, 0x72, 0xad, 0xcf, 0xe2, 0xc9, 0x28, 0x85, 0x9a, 0x6d}},
+       testcase{
+               msg:       []byte{0x41, 0x6b, 0x5c, 0xdc, 0x9f, 0xe9, 0x51, 0xbd, 0x36, 0x1b, 0xd7, 0xab, 0xfc, 0x12, 0xa, 0x50, 0x54, 0x75, 0x8e, 0xba, 0x88, 0xfd, 0xd6, 0x8f, 0xd8, 0x4e, 0x39, 0xd3, 0xb0, 0x9a, 0xc2, 0x54, 0x97, 0xd3, 0x6b, 0x43, 0xcb, 0xe7, 0xb8, 0x5a, 0x6a, 0x3c, 0xeb, 0xda, 0x8d, 0xb4, 0xe5, 0x54, 0x9c, 0x3e, 0xe5, 0x1b, 0xb6, 0xfc, 0xb6, 0xac, 0x1e},
+               output224: []byte{0xd4, 0x20, 0xc7, 0xbd, 0xf8, 0xd8, 0x6d, 0x7b, 0x1c, 0xbd, 0x1a, 0xf7, 0x86, 0x8e, 0xbc, 0x4f, 0xf1, 0x72, 0x45, 0x59, 0x5b, 0x94, 0x95, 0x9a, 0x7, 0x14, 0x33, 0x3c},
+               output256: []byte{0x1a, 0x93, 0x56, 0x7e, 0xeb, 0xc4, 0x1c, 0xc4, 0x4d, 0x93, 0x46, 0xcd, 0xe6, 0x46, 0x0, 0x5d, 0x3e, 0x82, 0xde, 0x8e, 0xee, 0xb1, 0x31, 0xe9, 0xc1, 0xf6, 0xd1, 0xe4, 0xaf, 0xd2, 0x60, 0xf7},
+               output384: []byte{0x68, 0x11, 0xec, 0x7, 0xe6, 0xe8, 0x5a, 0x28, 0x9c, 0x88, 0x17, 0x22, 0xae, 0x84, 0xe6, 0xae, 0xf0, 0x1f, 0xd2, 0x76, 0x12, 0x94, 0xc6, 0xed, 0x98, 0x56, 0xd2, 0xf7, 0xea, 0x1c, 0x71, 0xa8, 0x9b, 0x2f, 0xcf, 0x4a, 0x9e, 0x56, 0x53, 0x33, 0x60, 0xea, 0x22, 0x31, 0x75, 0x61, 0xec, 0x5},
+               output512: []byte{0x6a, 0xdf, 0xc5, 0x61, 0x83, 0x5f, 0xdd, 0xd7, 0xa, 0x9f, 0xeb, 0x57, 0xc5, 0x13, 0x16, 0x5d, 0x12, 0xae, 0xb3, 0x28, 0x3f, 0xd, 0xd7, 0x77, 0x4d, 0xd5, 0x88, 0x52, 0xda, 0x9e, 0x96, 0x9a, 0xbd, 0xaf, 0x20, 0xdd, 0x44, 0x85, 0x6f, 0xa6, 0xe, 0x11, 0xbd, 0xfa, 0x2d, 0xbb, 0x7e, 0x33, 0x47, 0x66, 0x9f, 0xff, 0x7a, 0x57, 0xa8, 0xd8, 0xd3, 0x74, 0x31, 0xc2, 0xb3, 0x9, 0x97, 0x2d}},
+       testcase{
+               msg:       []byte{0x5c, 0x5f, 0xaf, 0x66, 0xf3, 0x2e, 0xf, 0x83, 0x11, 0xc3, 0x2e, 0x8d, 0xa8, 0x28, 0x4a, 0x4e, 0xd6, 0x8, 0x91, 0xa5, 0xa7, 0xe5, 0xf, 0xb2, 0x95, 0x6b, 0x3c, 0xba, 0xa7, 0x9f, 0xc6, 0x6c, 0xa3, 0x76, 0x46, 0xe, 0x10, 0x4, 0x15, 0x40, 0x1f, 0xc2, 0xb8, 0x51, 0x8c, 0x64, 0x50, 0x2f, 0x18, 0x7e, 0xa1, 0x4b, 0xfc, 0x95, 0x3, 0x75, 0x97, 0x5},
+               output224: []byte{0x2e, 0x4, 0xda, 0xe6, 0xe3, 0xfd, 0xf2, 0xa4, 0x7f, 0xf4, 0xe, 0x6f, 0x3e, 0x61, 0xb3, 0x71, 0xf3, 0xe5, 0x1a, 0x58, 0x64, 0xa3, 0x1c, 0xc1, 0x1d, 0x12, 0x76, 0x20},
+               output256: []byte{0x54, 0x9d, 0xb0, 0x56, 0xb6, 0x5e, 0xdf, 0x7d, 0x5, 0xbd, 0x66, 0x66, 0x1b, 0x6d, 0xa, 0x39, 0xb2, 0x9b, 0x82, 0x5b, 0xc8, 0x9, 0x10, 0xf8, 0xbf, 0x70, 0x60, 0xa5, 0x3b, 0xff, 0x68, 0xe1},
+               output384: []byte{0x7c, 0x90, 0x26, 0x8e, 0x98, 0x1a, 0x3c, 0xf, 0xf1, 0x9e, 0x14, 0xce, 0x98, 0x30, 0xa1, 0xb9, 0xda, 0x5f, 0xc1, 0x83, 0x95, 0x8, 0x75, 0x96, 0x15, 0x82, 0x64, 0x44, 0x62, 0x5, 0x9d, 0xd2, 0xfa, 0xdc, 0xfa, 0x68, 0x75, 0xd, 0x7d, 0x2f, 0x44, 0xdf, 0xca, 0xb9, 0xff, 0xce, 0x58, 0x32},
+               output512: []byte{0xe, 0x74, 0x59, 0xbd, 0xc8, 0x57, 0xb9, 0x49, 0xcc, 0x59, 0xa9, 0xc6, 0x49, 0xb9, 0x62, 0x52, 0x68, 0xbf, 0x9a, 0x11, 0xea, 0x81, 0xee, 0xef, 0xa4, 0xec, 0xdd, 0x41, 0xe, 0x2f, 0x6f, 0xd2, 0xc7, 0x82, 0x89, 0xc0, 0x13, 0x65, 0xf9, 0x90, 0x34, 0xff, 0x8f, 0xa8, 0xc1, 0x15, 0xdd, 0xce, 0xbe, 0xfa, 0x26, 0xa8, 0xd6, 0x46, 0x8f, 0x50, 0x30, 0xe6, 0x41, 0x74, 0x59, 0x50, 0x6, 0x1e}},
+       testcase{
+               msg:       []byte{0x71, 0x67, 0xe1, 0xe0, 0x2b, 0xe1, 0xa7, 0xca, 0x69, 0xd7, 0x88, 0x66, 0x6f, 0x82, 0x3a, 0xe4, 0xee, 0xf3, 0x92, 0x71, 0xf3, 0xc2, 0x6a, 0x5c, 0xf7, 0xce, 0xe0, 0x5b, 0xca, 0x83, 0x16, 0x10, 0x66, 0xdc, 0x2e, 0x21, 0x7b, 0x33, 0xd, 0xf8, 0x21, 0x10, 0x37, 0x99, 0xdf, 0x6d, 0x74, 0x81, 0xe, 0xed, 0x36, 0x3a, 0xdc, 0x4a, 0xb9, 0x9f, 0x36, 0x4, 0x6a},
+               output224: []byte{0x22, 0x81, 0x7a, 0x21, 0xcf, 0xce, 0xc4, 0xfd, 0x23, 0x48, 0xb6, 0xbe, 0x8a, 0x70, 0x42, 0xa3, 0x77, 0x54, 0xd7, 0x6a, 0x3f, 0x33, 0xa8, 0xf8, 0x18, 0x31, 0x2c, 0xc7},
+               output256: []byte{0x79, 0x4a, 0xbf, 0xd7, 0xeb, 0x62, 0x2d, 0x56, 0x8, 0xc1, 0xc7, 0xb3, 0xf0, 0xa7, 0x82, 0x1a, 0x71, 0x90, 0xb, 0x71, 0x72, 0x84, 0x7f, 0xb0, 0x90, 0x7a, 0xa2, 0x89, 0x99, 0x72, 0x66, 0x3e},
+               output384: []byte{0x64, 0xe9, 0xad, 0x35, 0x7b, 0x58, 0xc6, 0xfa, 0xd, 0x26, 0xd0, 0xd1, 0xf4, 0x8c, 0x4a, 0xb0, 0x57, 0xb9, 0xf8, 0x9, 0x65, 0xac, 0x38, 0x49, 0x4e, 0x88, 0xf5, 0x42, 0xba, 0x41, 0xd6, 0xb7, 0x98, 0xfc, 0x2d, 0xd8, 0x82, 0x90, 0xf8, 0xdd, 0xe7, 0x94, 0x8c, 0x19, 0xb5, 0xa1, 0xf2, 0x60},
+               output512: []byte{0x2a, 0x8c, 0xe9, 0xdf, 0x40, 0x87, 0x9b, 0x24, 0xda, 0xdf, 0x61, 0xc9, 0x13, 0x1f, 0x69, 0x4e, 0x55, 0x31, 0xad, 0xe6, 0xb7, 0xab, 0x7, 0x1c, 0xa1, 0xa, 0xbd, 0xd3, 0xc2, 0xe4, 0xa2, 0x2c, 0x86, 0x8a, 0x52, 0x98, 0x6a, 0x32, 0x9f, 0x88, 0x1, 0x37, 0xee, 0x76, 0x10, 0x97, 0x70, 0x92, 0x7d, 0x26, 0x58, 0xe6, 0x3e, 0xb4, 0x86, 0xd8, 0x80, 0x29, 0xa, 0xc0, 0x78, 0x2c, 0xf5, 0xbf}},
+       testcase{
+               msg:       []byte{0x2f, 0xda, 0x31, 0x1d, 0xbb, 0xa2, 0x73, 0x21, 0xc5, 0x32, 0x95, 0x10, 0xfa, 0xe6, 0x94, 0x8f, 0x3, 0x21, 0xb, 0x76, 0xd4, 0x3e, 0x74, 0x48, 0xd1, 0x68, 0x9a, 0x6, 0x38, 0x77, 0xb6, 0xd1, 0x4c, 0x4f, 0x6d, 0xe, 0xaa, 0x96, 0xc1, 0x50, 0x5, 0x13, 0x71, 0xf7, 0xdd, 0x8a, 0x41, 0x19, 0xf7, 0xda, 0x5c, 0x48, 0x3c, 0xc3, 0xe6, 0x72, 0x3c, 0x1, 0xfb, 0x7d},
+               output224: []byte{0x68, 0xca, 0xf2, 0x20, 0x33, 0x17, 0xa8, 0xbe, 0xd3, 0xc, 0x17, 0x92, 0xe8, 0x88, 0x91, 0x1, 0x24, 0xf2, 0xf0, 0xee, 0x1d, 0x24, 0xd4, 0x72, 0x74, 0xbc, 0xc8, 0x56},
+               output256: []byte{0x9c, 0xe8, 0x99, 0x58, 0xcb, 0xdd, 0xd8, 0xdc, 0xb2, 0x2f, 0x66, 0xe8, 0xcb, 0xa5, 0xf6, 0x9, 0x1a, 0x51, 0x95, 0x31, 0x89, 0x46, 0x48, 0x3, 0xbd, 0xc7, 0x73, 0xab, 0xc7, 0xfa, 0xa9, 0x6},
+               output384: []byte{0x3d, 0x73, 0xb3, 0x3f, 0x0, 0x13, 0x87, 0xfd, 0x1e, 0x75, 0x20, 0x68, 0xaf, 0x39, 0x45, 0x4e, 0x47, 0x6b, 0x84, 0x7, 0x3, 0x8c, 0x77, 0x2d, 0x94, 0x40, 0x4, 0x58, 0xc9, 0x36, 0x64, 0xec, 0x52, 0x26, 0xad, 0x1b, 0xd3, 0xa1, 0x9a, 0x6d, 0x9a, 0x6f, 0xbd, 0x6e, 0x6a, 0x62, 0x69, 0x5c},
+               output512: []byte{0xa8, 0x3c, 0xe5, 0xa6, 0xa5, 0x83, 0x76, 0xd5, 0x7d, 0xb4, 0xc5, 0x8d, 0xa1, 0xb4, 0x6c, 0x13, 0x1f, 0xf1, 0xbf, 0x8f, 0xf2, 0xde, 0x5e, 0x86, 0x17, 0xfb, 0x37, 0xe5, 0x9, 0x83, 0x98, 0xed, 0xb5, 0x3f, 0x98, 0x88, 0xb8, 0x75, 0x2a, 0x8a, 0xff, 0x19, 0x17, 0x8f, 0x2f, 0x6b, 0xd7, 0xa3, 0x3f, 0xd3, 0x6c, 0x59, 0xe4, 0xa6, 0x31, 0x90, 0x62, 0x80, 0x90, 0x7f, 0xc1, 0xc5, 0xab, 0x7}},
+       testcase{
+               msg:       []byte{0x95, 0xd1, 0x47, 0x4a, 0x5a, 0xab, 0x5d, 0x24, 0x22, 0xac, 0xa6, 0xe4, 0x81, 0x18, 0x78, 0x33, 0xa6, 0x21, 0x2b, 0xd2, 0xd0, 0xf9, 0x14, 0x51, 0xa6, 0x7d, 0xd7, 0x86, 0xdf, 0xc9, 0x1d, 0xfe, 0xd5, 0x1b, 0x35, 0xf4, 0x7e, 0x1d, 0xeb, 0x8a, 0x8a, 0xb4, 0xb9, 0xcb, 0x67, 0xb7, 0x1, 0x79, 0xcc, 0x26, 0xf5, 0x53, 0xae, 0x7b, 0x56, 0x99, 0x69, 0xce, 0x15, 0x1b, 0x8d},
+               output224: []byte{0x7b, 0xba, 0xc0, 0xc0, 0xf1, 0x92, 0xd2, 0xc4, 0x79, 0x34, 0x83, 0x58, 0xd2, 0x24, 0x7e, 0x4c, 0x8, 0x96, 0x6a, 0x51, 0x2f, 0x73, 0xd4, 0x4, 0x45, 0xb5, 0x2e, 0xc7},
+               output256: []byte{0x6d, 0xa7, 0x33, 0x81, 0x7d, 0xc8, 0x26, 0xe8, 0xda, 0x77, 0x3b, 0xec, 0xa7, 0x33, 0x81, 0x31, 0xab, 0x73, 0x96, 0x41, 0x71, 0x4, 0xed, 0xa2, 0x59, 0x70, 0x98, 0xc, 0x4e, 0xb2, 0xa1, 0x5f},
+               output384: []byte{0xfc, 0x61, 0x9c, 0xa9, 0x81, 0xc, 0xaa, 0xe3, 0x63, 0x9b, 0x3f, 0xc6, 0x61, 0x38, 0x8c, 0x45, 0x41, 0x67, 0x27, 0x1e, 0x65, 0xed, 0xa, 0x2e, 0x5e, 0x8b, 0xc7, 0x18, 0xad, 0x21, 0xb9, 0xed, 0xe8, 0x95, 0xa6, 0x58, 0xc9, 0x46, 0xdc, 0x2f, 0xb1, 0x5b, 0x33, 0x35, 0x4d, 0xfe, 0x40, 0x2a},
+               output512: []byte{0x9e, 0xbf, 0xce, 0xa2, 0xdb, 0x16, 0x76, 0xee, 0xe6, 0xb1, 0x3, 0x11, 0x95, 0x43, 0xc6, 0x4, 0x9d, 0xeb, 0xd8, 0xfb, 0x8f, 0x1e, 0x1, 0xa5, 0xab, 0x5b, 0x34, 0x8e, 0x29, 0x19, 0xe1, 0x4c, 0x8c, 0xfe, 0x8e, 0x54, 0x2f, 0x2a, 0xb7, 0x47, 0xb0, 0xfd, 0x4a, 0x4c, 0x3e, 0xee, 0x40, 0x19, 0xbb, 0x4, 0x6e, 0x24, 0xbf, 0xe2, 0x9, 0x1f, 0xb9, 0xc6, 0x5d, 0xca, 0x52, 0x7b, 0x71, 0xad}},
+       testcase{
+               msg:       []byte{0xc7, 0x1b, 0xd7, 0x94, 0x1f, 0x41, 0xdf, 0x4, 0x4a, 0x29, 0x27, 0xa8, 0xff, 0x55, 0xb4, 0xb4, 0x67, 0xc3, 0x3d, 0x8, 0x9f, 0x9, 0x88, 0xaa, 0x25, 0x3d, 0x29, 0x4a, 0xdd, 0xbd, 0xb3, 0x25, 0x30, 0xc0, 0xd4, 0x20, 0x8b, 0x10, 0xd9, 0x95, 0x98, 0x23, 0xf0, 0xc0, 0xf0, 0x73, 0x46, 0x84, 0x0, 0x6d, 0xf7, 0x9f, 0x70, 0x99, 0x87, 0xf, 0x6b, 0xf5, 0x32, 0x11, 0xa8, 0x8d},
+               output224: []byte{0xd2, 0x26, 0xd9, 0xe1, 0xf3, 0x6e, 0xc4, 0x22, 0x26, 0x93, 0x69, 0x9b, 0x6d, 0x3, 0x83, 0xc1, 0x45, 0x2e, 0x39, 0x1c, 0x41, 0xef, 0xd7, 0x64, 0x52, 0x89, 0xf8, 0xe3},
+               output256: []byte{0x66, 0xc9, 0xcd, 0xc8, 0xe8, 0xc6, 0xc9, 0x41, 0x7d, 0x7f, 0xfb, 0xef, 0x3b, 0x54, 0xb7, 0x2, 0xee, 0xe5, 0xf0, 0x1a, 0x9b, 0xda, 0x8d, 0xd4, 0xe2, 0x8f, 0xe3, 0x33, 0x5d, 0xeb, 0xbb, 0x51},
+               output384: []byte{0x58, 0x43, 0x12, 0x3a, 0x28, 0xf0, 0xb5, 0xc, 0x8, 0x20, 0x23, 0xac, 0x43, 0xb7, 0x29, 0x9c, 0x4f, 0xe6, 0x73, 0x2, 0x53, 0x2d, 0xf4, 0x80, 0x5b, 0xe6, 0xde, 0xc3, 0xb8, 0x45, 0x15, 0xb1, 0xc6, 0xc9, 0x8f, 0x8a, 0x4e, 0x3d, 0x6c, 0xa8, 0x26, 0xda, 0x4a, 0x11, 0x30, 0xc, 0x3b, 0x9b},
+               output512: []byte{0x97, 0xb0, 0x8b, 0xe7, 0x65, 0x3e, 0x9d, 0xf1, 0xb5, 0xaf, 0xa4, 0x59, 0xea, 0x75, 0xa, 0x3a, 0xc9, 0xbf, 0x35, 0x77, 0xbc, 0xc7, 0xe5, 0x34, 0x4f, 0xc8, 0x61, 0x18, 0x48, 0x80, 0x92, 0x6d, 0xef, 0x35, 0x4e, 0x4c, 0x65, 0xb2, 0xe, 0xc6, 0x6c, 0x47, 0xb7, 0xaf, 0xfd, 0x3e, 0x74, 0x93, 0x95, 0x8b, 0xab, 0xa, 0x90, 0x72, 0x4d, 0x3d, 0x8d, 0xd9, 0xe1, 0xd5, 0x61, 0xfa, 0x60, 0xc2}},
+       testcase{
+               msg:       []byte{0xf5, 0x7c, 0x64, 0x0, 0x6d, 0x9e, 0xa7, 0x61, 0x89, 0x2e, 0x14, 0x5c, 0x99, 0xdf, 0x1b, 0x24, 0x64, 0x8, 0x83, 0xda, 0x79, 0xd9, 0xed, 0x52, 0x62, 0x85, 0x9d, 0xcd, 0xa8, 0xc3, 0xc3, 0x2e, 0x5, 0xb0, 0x3d, 0x98, 0x4f, 0x1a, 0xb4, 0xa2, 0x30, 0x24, 0x2a, 0xb6, 0xb7, 0x8d, 0x36, 0x8d, 0xc5, 0xaa, 0xa1, 0xe6, 0xd3, 0x49, 0x8d, 0x53, 0x37, 0x1e, 0x84, 0xb0, 0xc1, 0xd4, 0xba},
+               output224: []byte{0x29, 0x4a, 0x1e, 0x5a, 0x6, 0x29, 0xa2, 0x73, 0x6f, 0x18, 0x86, 0x91, 0xa3, 0x5f, 0xe1, 0xab, 0xb5, 0x54, 0x72, 0x78, 0x5d, 0xaf, 0xf6, 0xcd, 0x88, 0xc6, 0xd5, 0x37},
+               output256: []byte{0x24, 0xab, 0x37, 0xa9, 0x36, 0x74, 0xcc, 0xb1, 0xce, 0xec, 0x9e, 0x56, 0x81, 0xef, 0xc8, 0xbd, 0xf9, 0xfc, 0xc7, 0x72, 0x1c, 0xf1, 0xca, 0xc1, 0x75, 0xe0, 0xb2, 0xe, 0x46, 0x15, 0x75, 0xb8},
+               output384: []byte{0x81, 0xed, 0xf0, 0x6e, 0x9b, 0x64, 0xf3, 0x1, 0x6b, 0x15, 0x47, 0x53, 0x5a, 0xba, 0x4d, 0xb0, 0x87, 0x60, 0xfd, 0x23, 0xe9, 0x58, 0x1, 0x63, 0x19, 0x2f, 0x66, 0x3f, 0xf6, 0x21, 0x6, 0x0, 0x10, 0x6, 0xa1, 0x39, 0x3c, 0xf2, 0xd, 0xe4, 0x65, 0x6d, 0xbc, 0xb0, 0x29, 0xfb, 0x63, 0x14},
+               output512: []byte{0xef, 0x8a, 0xaf, 0x8, 0x15, 0x9b, 0xbc, 0xb8, 0x8e, 0xfa, 0xc4, 0x9a, 0x33, 0xa5, 0x24, 0x8b, 0x7e, 0xd0, 0x54, 0x49, 0x60, 0xd8, 0xdd, 0x54, 0xd7, 0x48, 0xa9, 0x1c, 0xd, 0x84, 0xc6, 0x9f, 0x30, 0x8b, 0xb5, 0x4c, 0xb5, 0xec, 0x97, 0xd3, 0xf8, 0x1c, 0xdf, 0x76, 0xe6, 0x8e, 0x3, 0x20, 0x81, 0x5b, 0x93, 0xf2, 0xa0, 0x9, 0x42, 0xf2, 0x16, 0x8c, 0xbc, 0x18, 0xe8, 0x37, 0x77, 0x8}},
+       testcase{
+               msg:       []byte{0xe9, 0x26, 0xae, 0x8b, 0xa, 0xf6, 0xe5, 0x31, 0x76, 0xdb, 0xff, 0xcc, 0x2a, 0x6b, 0x88, 0xc6, 0xbd, 0x76, 0x5f, 0x93, 0x9d, 0x3d, 0x17, 0x8a, 0x9b, 0xde, 0x9e, 0xf3, 0xaa, 0x13, 0x1c, 0x61, 0xe3, 0x1c, 0x1e, 0x42, 0xcd, 0xfa, 0xf4, 0xb4, 0xdc, 0xde, 0x57, 0x9a, 0x37, 0xe1, 0x50, 0xef, 0xbe, 0xf5, 0x55, 0x5b, 0x4c, 0x1c, 0xb4, 0x4, 0x39, 0xd8, 0x35, 0xa7, 0x24, 0xe2, 0xfa, 0xe7},
+               output224: []byte{0xc5, 0x33, 0xdc, 0xf8, 0x8c, 0xd1, 0xa5, 0xdf, 0xf2, 0x2b, 0x91, 0x4d, 0x38, 0x75, 0xbd, 0x57, 0xfc, 0x17, 0xb2, 0xe1, 0xf4, 0x74, 0xae, 0x36, 0xc, 0x38, 0x77, 0xd2},
+               output256: []byte{0x57, 0x42, 0x71, 0xcd, 0x13, 0x95, 0x9e, 0x8d, 0xde, 0xae, 0x5b, 0xfb, 0xdb, 0x2, 0xa3, 0xfd, 0xf5, 0x4f, 0x2b, 0xab, 0xfd, 0xc, 0xbe, 0xb8, 0x93, 0x8, 0x2a, 0x97, 0x49, 0x57, 0xd0, 0xc1},
+               output384: []byte{0x14, 0xaa, 0x67, 0x9b, 0xc, 0x11, 0xf9, 0xc3, 0x63, 0xf5, 0x49, 0x33, 0x2, 0x61, 0xb4, 0x5e, 0x1e, 0x90, 0xce, 0x31, 0xf4, 0xa1, 0xb0, 0xce, 0x5c, 0xb9, 0xeb, 0x81, 0xbd, 0x60, 0x79, 0xa3, 0x74, 0x2d, 0x86, 0x2, 0x35, 0x6c, 0x50, 0x98, 0x5d, 0xd, 0x3e, 0x54, 0xf, 0xdf, 0xdc, 0xfb},
+               output512: []byte{0xc0, 0xa4, 0xd8, 0xdc, 0xa9, 0x67, 0x77, 0x2d, 0xbf, 0x6e, 0x55, 0x8, 0xc9, 0x13, 0xe7, 0xbe, 0xba, 0x1b, 0x74, 0x9a, 0x2b, 0x1a, 0xc9, 0x63, 0xd0, 0x67, 0x6e, 0x6f, 0x1d, 0xcd, 0x4e, 0xba, 0xa3, 0xf9, 0x9, 0xef, 0x87, 0xdd, 0x84, 0x98, 0x82, 0xdc, 0x82, 0x53, 0x34, 0x7a, 0x5f, 0x65, 0x20, 0xb5, 0xb9, 0xf5, 0x10, 0x97, 0x3f, 0x44, 0x39, 0x76, 0x45, 0x5f, 0x92, 0x3c, 0xfc, 0xb9}},
+       testcase{
+               msg:       []byte{0x16, 0xe8, 0xb3, 0xd8, 0xf9, 0x88, 0xe9, 0xbb, 0x4, 0xde, 0x9c, 0x96, 0xf2, 0x62, 0x78, 0x11, 0xc9, 0x73, 0xce, 0x4a, 0x52, 0x96, 0xb4, 0x77, 0x2c, 0xa3, 0xee, 0xfe, 0xb8, 0xa, 0x65, 0x2b, 0xdf, 0x21, 0xf5, 0xd, 0xf7, 0x9f, 0x32, 0xdb, 0x23, 0xf9, 0xf7, 0x3d, 0x39, 0x3b, 0x2d, 0x57, 0xd9, 0xa0, 0x29, 0x7f, 0x7a, 0x2f, 0x2e, 0x79, 0xcf, 0xda, 0x39, 0xfa, 0x39, 0x3d, 0xf1, 0xac, 0x0},
+               output224: []byte{0xc9, 0xb7, 0xad, 0x7a, 0x32, 0xb7, 0xd, 0xfb, 0x5a, 0x8a, 0x2f, 0xf9, 0xd9, 0x8b, 0x30, 0xe, 0x48, 0x4b, 0x99, 0x6e, 0xd7, 0x52, 0xa7, 0x32, 0xd8, 0x4d, 0xb6, 0xf7},
+               output256: []byte{0x19, 0x47, 0xe9, 0x1, 0xfa, 0x59, 0xea, 0x78, 0x98, 0x45, 0x77, 0x5f, 0x2a, 0x4d, 0xb9, 0xb4, 0x84, 0x8f, 0x8a, 0x77, 0x60, 0x73, 0xd5, 0x3d, 0x84, 0xcb, 0xd5, 0xd9, 0x27, 0xa9, 0x6b, 0xff},
+               output384: []byte{0xe4, 0x30, 0xce, 0x80, 0xbc, 0xc6, 0x1d, 0x87, 0xfd, 0xe0, 0xa2, 0x78, 0xcf, 0xf5, 0x4d, 0x73, 0xc, 0x3, 0xa0, 0x33, 0x77, 0xf4, 0xac, 0x10, 0xb9, 0x3e, 0xd5, 0x9c, 0x58, 0x80, 0x11, 0x7a, 0xcb, 0x20, 0xf1, 0x70, 0x5a, 0xef, 0xd2, 0x9b, 0xe0, 0x33, 0xd2, 0xf2, 0x2, 0x59, 0x46, 0x55},
+               output512: []byte{0xcf, 0x3, 0xc9, 0x46, 0xeb, 0x70, 0x22, 0xf6, 0xf, 0xb5, 0x43, 0x94, 0x62, 0xac, 0x22, 0x68, 0x4e, 0x47, 0xea, 0xac, 0xbf, 0xfe, 0x19, 0xb7, 0x97, 0x76, 0xb, 0x4a, 0x24, 0xa5, 0x23, 0x8b, 0xe9, 0xd9, 0xe, 0x17, 0xd4, 0xe, 0xa6, 0xfe, 0x7b, 0x28, 0x85, 0xce, 0xf7, 0xdf, 0xb8, 0xbb, 0x48, 0x94, 0x1, 0xca, 0xa9, 0x4f, 0x2d, 0xd6, 0xe0, 0x45, 0x92, 0xe3, 0x3e, 0x76, 0xb9, 0xd1}},
+       testcase{
+               msg:       []byte{0xfc, 0x42, 0x4e, 0xeb, 0x27, 0xc1, 0x8a, 0x11, 0xc0, 0x1f, 0x39, 0xc5, 0x55, 0xd8, 0xb7, 0x8a, 0x80, 0x5b, 0x88, 0xdb, 0xa1, 0xdc, 0x2a, 0x42, 0xed, 0x5e, 0x2c, 0xe, 0xc7, 0x37, 0xff, 0x68, 0xb2, 0x45, 0x6d, 0x80, 0xeb, 0x85, 0xe1, 0x17, 0x14, 0xfa, 0x3f, 0x8e, 0xab, 0xfb, 0x90, 0x6d, 0x3c, 0x17, 0x96, 0x4c, 0xb4, 0xf5, 0xe7, 0x6b, 0x29, 0xc1, 0x76, 0x5d, 0xb0, 0x3d, 0x91, 0xbe, 0x37, 0xfc},
+               output224: []byte{0xcf, 0x64, 0x6d, 0x5e, 0x5c, 0x81, 0x81, 0x8c, 0x97, 0xa0, 0x1f, 0x39, 0x3f, 0x80, 0x33, 0xce, 0x3c, 0xb7, 0xcc, 0xd0, 0x7f, 0xda, 0xc9, 0x98, 0x87, 0x66, 0xbd, 0x1c},
+               output256: []byte{0xc, 0x1b, 0x8c, 0x1a, 0xf2, 0x37, 0xe9, 0xc5, 0x50, 0x1b, 0x50, 0x31, 0x6a, 0x80, 0x86, 0x5a, 0xac, 0x8, 0xa3, 0x4a, 0xcf, 0x4f, 0x8b, 0xed, 0xd4, 0xa2, 0xd6, 0xe7, 0xb7, 0xbc, 0xbb, 0x85},
+               output384: []byte{0xc9, 0xf7, 0x4a, 0xc4, 0x7f, 0x91, 0x46, 0xf0, 0x91, 0xde, 0x63, 0x9, 0x35, 0x7f, 0x3c, 0x2a, 0xf3, 0xa9, 0xc4, 0x47, 0x4c, 0xc0, 0x5, 0xae, 0xfa, 0xce, 0x3c, 0x7a, 0x55, 0x2b, 0x61, 0x27, 0xe3, 0x4e, 0xc8, 0x2c, 0x3a, 0xfc, 0xaa, 0xcd, 0xd8, 0x3e, 0x69, 0x5c, 0xb8, 0x62, 0x41, 0xe4},
+               output512: []byte{0x2c, 0x35, 0xf1, 0xa5, 0x7a, 0x17, 0xcb, 0x29, 0x40, 0x3a, 0x2b, 0x40, 0xfc, 0x30, 0x7b, 0xde, 0x10, 0xba, 0x8f, 0x7f, 0xec, 0x7b, 0x94, 0xe1, 0xe4, 0x2e, 0xb4, 0xee, 0xb9, 0x52, 0xaa, 0xd0, 0xe, 0xc4, 0x6a, 0x26, 0x64, 0x6c, 0xd5, 0x1d, 0xb0, 0xc6, 0xb2, 0x38, 0x18, 0x9d, 0x7d, 0x47, 0xe, 0x21, 0xc2, 0x9b, 0xf8, 0x71, 0x4, 0x23, 0xcb, 0x56, 0x2, 0xca, 0xb7, 0x5e, 0x29, 0xe7}},
+       testcase{
+               msg:       []byte{0xab, 0xe3, 0x47, 0x2b, 0x54, 0xe7, 0x27, 0x34, 0xbd, 0xba, 0x7d, 0x91, 0x58, 0x73, 0x64, 0x64, 0x25, 0x1c, 0x4f, 0x21, 0xb3, 0x3f, 0xbb, 0xc9, 0x2d, 0x7f, 0xac, 0x9a, 0x35, 0xc4, 0xe3, 0x32, 0x2f, 0xf0, 0x1d, 0x23, 0x80, 0xcb, 0xaa, 0x4e, 0xf8, 0xfb, 0x7, 0xd2, 0x1a, 0x21, 0x28, 0xb7, 0xb9, 0xf5, 0xb6, 0xd9, 0xf3, 0x4e, 0x13, 0xf3, 0x9c, 0x7f, 0xfc, 0x2e, 0x72, 0xe4, 0x78, 0x88, 0x59, 0x9b, 0xa5},
+               output224: []byte{0xd4, 0x11, 0xe8, 0xa7, 0xcf, 0x50, 0xaa, 0xf9, 0x10, 0x76, 0xa8, 0xcc, 0x5f, 0x1, 0xbf, 0x5b, 0x6b, 0xb2, 0xcc, 0xae, 0x80, 0x46, 0xbf, 0x47, 0x87, 0x18, 0x91, 0xfd},
+               output256: []byte{0xc4, 0x31, 0x56, 0x66, 0xc7, 0x1f, 0xea, 0x83, 0x4d, 0x8f, 0xf2, 0x7f, 0x2, 0x5f, 0x5c, 0xc3, 0x4f, 0x37, 0xc1, 0xaa, 0xe7, 0x86, 0x4, 0xa4, 0xb0, 0x8d, 0xac, 0x45, 0xde, 0xcd, 0x42, 0xbe},
+               output384: []byte{0xc4, 0x2e, 0xcc, 0x88, 0x63, 0x7, 0x7a, 0xbf, 0xf6, 0x89, 0x41, 0x3c, 0xe3, 0x7b, 0x61, 0xf0, 0x43, 0x6d, 0xdb, 0x62, 0xe5, 0x6d, 0xe4, 0xe3, 0x33, 0x3c, 0x26, 0xd9, 0x5a, 0xee, 0x9e, 0x9c, 0xbe, 0x1d, 0x8a, 0xaa, 0x67, 0x44, 0xc0, 0xde, 0x6b, 0xa9, 0xcf, 0xf0, 0xff, 0x1, 0xa6, 0xbf},
+               output512: []byte{0x50, 0x5e, 0x6e, 0x60, 0x7c, 0x90, 0xc5, 0x7b, 0xbe, 0x7c, 0xe5, 0x2b, 0xb4, 0x2d, 0xf3, 0xd9, 0xb, 0xc3, 0x2d, 0xe5, 0x54, 0x2, 0x57, 0x30, 0xc8, 0x4e, 0xd0, 0xf8, 0x9a, 0x1, 0x32, 0x88, 0x5d, 0x7a, 0x40, 0xfa, 0xdf, 0xf7, 0xa4, 0xb0, 0x1d, 0xe4, 0xd2, 0x97, 0x35, 0xae, 0xfe, 0xe, 0x4, 0x69, 0xf4, 0xf1, 0x72, 0xb6, 0x2a, 0xd, 0xab, 0xa8, 0x89, 0xe1, 0x52, 0x30, 0x8f, 0xc4}},
+       testcase{
+               msg:       []byte{0x36, 0xf9, 0xf0, 0xa6, 0x5f, 0x2c, 0xa4, 0x98, 0xd7, 0x39, 0xb9, 0x44, 0xd6, 0xef, 0xf3, 0xda, 0x5e, 0xbb, 0xa5, 0x7e, 0x7d, 0x9c, 0x41, 0x59, 0x8a, 0x2b, 0xe, 0x43, 0x80, 0xf3, 0xcf, 0x4b, 0x47, 0x9e, 0xc2, 0x34, 0x8d, 0x1, 0x5f, 0xfe, 0x62, 0x56, 0x27, 0x35, 0x11, 0x15, 0x4a, 0xfc, 0xf3, 0xb4, 0xb4, 0xbf, 0x9, 0xd6, 0xc4, 0x74, 0x4f, 0xdd, 0xf, 0x62, 0xd7, 0x50, 0x79, 0xd4, 0x40, 0x70, 0x6b, 0x5},
+               output224: []byte{0xe0, 0x94, 0xc0, 0x30, 0x3d, 0x18, 0x41, 0xc6, 0xe4, 0xc0, 0x86, 0x48, 0x57, 0xcf, 0x36, 0xcf, 0xc9, 0x80, 0xe3, 0xcb, 0x4d, 0x78, 0xf1, 0x8e, 0x30, 0x11, 0x17, 0xc4},
+               output256: []byte{0x5f, 0xf8, 0x73, 0x4d, 0xb3, 0xf9, 0x97, 0x7e, 0xee, 0x9c, 0xf5, 0xe2, 0xcf, 0x72, 0x5c, 0x57, 0xaf, 0x9, 0x92, 0x64, 0x90, 0xc5, 0x5a, 0xbd, 0x9d, 0x0, 0xa4, 0x2e, 0x91, 0xa8, 0xc3, 0x44},
+               output384: []byte{0xb1, 0x53, 0x92, 0x71, 0x8c, 0xbf, 0x4a, 0x7c, 0x7f, 0xad, 0x1c, 0x15, 0xe7, 0xf2, 0x6c, 0x44, 0x6e, 0x79, 0xd5, 0x42, 0x51, 0x40, 0x4e, 0x64, 0x6b, 0x4d, 0xca, 0x3d, 0x42, 0x14, 0x2e, 0xd5, 0x14, 0xd, 0xd, 0x30, 0xbd, 0x83, 0x6c, 0x7d, 0x51, 0x3c, 0xe6, 0xf5, 0xe1, 0x4, 0xd4, 0x2d},
+               output512: []byte{0x7b, 0xe2, 0xc9, 0x54, 0x13, 0xc5, 0x89, 0xec, 0x5a, 0xd6, 0x9f, 0x8d, 0x80, 0xbf, 0xe9, 0xf2, 0x65, 0x40, 0xd5, 0xc1, 0x83, 0x2c, 0x7a, 0x49, 0xa3, 0x1a, 0x8f, 0x56, 0x55, 0xd9, 0xce, 0x8b, 0x47, 0xd9, 0x7c, 0x69, 0xcc, 0xcd, 0x69, 0x3c, 0x21, 0x19, 0x4, 0x14, 0x2a, 0x54, 0x3, 0xda, 0x7a, 0xd0, 0x9f, 0xbd, 0xb8, 0x25, 0x69, 0x8f, 0xe2, 0x1, 0x98, 0x8f, 0xcc, 0xcd, 0x2b, 0xb2}},
+       testcase{
+               msg:       []byte{0xab, 0xc8, 0x77, 0x63, 0xca, 0xe1, 0xca, 0x98, 0xbd, 0x8c, 0x5b, 0x82, 0xca, 0xba, 0x54, 0xac, 0x83, 0x28, 0x6f, 0x87, 0xe9, 0x61, 0x1, 0x28, 0xae, 0x4d, 0xe6, 0x8a, 0xc9, 0x5d, 0xf5, 0xe3, 0x29, 0xc3, 0x60, 0x71, 0x7b, 0xd3, 0x49, 0xf2, 0x6b, 0x87, 0x25, 0x28, 0x49, 0x2c, 0xa7, 0xc9, 0x4c, 0x2c, 0x1e, 0x1e, 0xf5, 0x6b, 0x74, 0xdb, 0xb6, 0x5c, 0x2a, 0xc3, 0x51, 0x98, 0x1f, 0xdb, 0x31, 0xd0, 0x6c, 0x77, 0xa4},
+               output224: []byte{0x51, 0x94, 0x8e, 0x17, 0x72, 0xc2, 0xc2, 0xee, 0x49, 0x15, 0x8d, 0x2, 0xa9, 0x75, 0xb2, 0x74, 0x77, 0xbd, 0x4, 0x12, 0x62, 0x95, 0x4c, 0x3e, 0x60, 0xf5, 0xac, 0xc2},
+               output256: []byte{0x1e, 0x14, 0x1a, 0x17, 0x1c, 0xab, 0x8, 0x52, 0x52, 0xea, 0x4c, 0x2f, 0x8f, 0x1f, 0x10, 0x87, 0xdd, 0x85, 0xa7, 0x5a, 0xb3, 0xac, 0xd0, 0xb3, 0xc2, 0x8e, 0xaa, 0x57, 0x35, 0xd3, 0x49, 0xaf},
+               output384: []byte{0xe0, 0x32, 0x94, 0xc6, 0x8e, 0xdf, 0x4e, 0x88, 0x26, 0xb6, 0x99, 0xab, 0xdd, 0xbe, 0xf7, 0x54, 0x67, 0xc4, 0x9c, 0xab, 0x56, 0xe0, 0x85, 0xe4, 0xb8, 0x3a, 0x58, 0xb2, 0xd9, 0xbd, 0xfa, 0xc9, 0xd5, 0x8b, 0x45, 0xaa, 0xcc, 0xe, 0xc0, 0xce, 0x2d, 0x6d, 0x79, 0x68, 0x6a, 0x41, 0xac, 0x13},
+               output512: []byte{0x8a, 0xac, 0x92, 0x1, 0xd7, 0x6d, 0xf1, 0x34, 0x24, 0xa3, 0x25, 0x52, 0xf0, 0x43, 0x90, 0xe4, 0x99, 0xb6, 0x16, 0x87, 0x11, 0xb7, 0xc, 0x87, 0x57, 0x89, 0xdd, 0xaa, 0x9b, 0x11, 0x5f, 0x8b, 0x82, 0x59, 0xa6, 0xd, 0x17, 0x83, 0x5e, 0x25, 0x87, 0xf8, 0x90, 0x1c, 0x3c, 0xa7, 0x82, 0xda, 0x9a, 0xfb, 0x28, 0xba, 0x87, 0xb9, 0xfc, 0xbe, 0x5, 0xa4, 0x7a, 0x42, 0xf4, 0x8f, 0xcd, 0x48}},
+       testcase{
+               msg:       []byte{0x94, 0xf7, 0xca, 0x8e, 0x1a, 0x54, 0x23, 0x4c, 0x6d, 0x53, 0xcc, 0x73, 0x4b, 0xb3, 0xd3, 0x15, 0xc, 0x8b, 0xa8, 0xc5, 0xf8, 0x80, 0xea, 0xb8, 0xd2, 0x5f, 0xed, 0x13, 0x79, 0x3a, 0x97, 0x1, 0xeb, 0xe3, 0x20, 0x50, 0x92, 0x86, 0xfd, 0x8e, 0x42, 0x2e, 0x93, 0x1d, 0x99, 0xc9, 0x8d, 0xa4, 0xdf, 0x7e, 0x70, 0xae, 0x44, 0x7b, 0xab, 0x8c, 0xff, 0xd9, 0x23, 0x82, 0xd8, 0xa7, 0x77, 0x60, 0xa2, 0x59, 0xfc, 0x4f, 0xbd, 0x72},
+               output224: []byte{0x82, 0x14, 0xa2, 0xb0, 0xe8, 0xbb, 0x60, 0xcd, 0x3e, 0x4d, 0xfb, 0xd, 0x8, 0x55, 0xd0, 0xf6, 0xc4, 0xba, 0x6d, 0x27, 0x28, 0xd0, 0x68, 0x7b, 0xdf, 0x75, 0xf7, 0x9e},
+               output256: []byte{0xef, 0x76, 0x3f, 0x22, 0xf3, 0x59, 0xdd, 0x7f, 0x5b, 0x3f, 0xe6, 0xa7, 0x45, 0xc4, 0x23, 0xd6, 0xb6, 0x41, 0xec, 0x7, 0xba, 0x52, 0x35, 0x23, 0x2a, 0x7, 0x1, 0x51, 0xf, 0x74, 0x42, 0x6e},
+               output384: []byte{0xd5, 0x53, 0x9d, 0x7a, 0xef, 0xf9, 0xf7, 0x4d, 0xc7, 0x5b, 0x6e, 0x95, 0xea, 0xde, 0x6, 0x3b, 0xe4, 0x19, 0xb1, 0x5a, 0x41, 0x79, 0xcf, 0xd0, 0x6d, 0x4f, 0xd2, 0x74, 0x1e, 0x22, 0xb2, 0xa2, 0x43, 0x95, 0xaa, 0xa1, 0xc0, 0x24, 0x2c, 0x99, 0x5e, 0xb5, 0xea, 0x89, 0x13, 0x47, 0xb4, 0xdb},
+               output512: []byte{0xaa, 0x52, 0x58, 0x7d, 0x84, 0x58, 0x63, 0x17, 0x2, 0x8f, 0xb7, 0xd3, 0xc2, 0x8, 0x92, 0xe0, 0x28, 0x8b, 0xfe, 0x2f, 0xea, 0xbd, 0x76, 0xd7, 0xf8, 0x91, 0x55, 0xff, 0xe9, 0xcc, 0xbf, 0x1a, 0x9, 0xfa, 0xf, 0xfb, 0x5, 0x53, 0xe8, 0x3f, 0x79, 0xae, 0x58, 0xbd, 0x30, 0xa3, 0x5f, 0xa5, 0x48, 0x92, 0xb6, 0xab, 0xa0, 0x9, 0x3a, 0x1, 0x24, 0x27, 0xdd, 0xab, 0x71, 0xcd, 0xf8, 0x19}},
+       testcase{
+               msg:       []byte{0x13, 0xbd, 0x28, 0x11, 0xf6, 0xed, 0x2b, 0x6f, 0x4, 0xff, 0x38, 0x95, 0xac, 0xee, 0xd7, 0xbe, 0xf8, 0xdc, 0xd4, 0x5e, 0xb1, 0x21, 0x79, 0x1b, 0xc1, 0x94, 0xa0, 0xf8, 0x6, 0x20, 0x6b, 0xff, 0xc3, 0xb9, 0x28, 0x1c, 0x2b, 0x30, 0x8b, 0x1a, 0x72, 0x9c, 0xe0, 0x8, 0x11, 0x9d, 0xd3, 0x6, 0x6e, 0x93, 0x78, 0xac, 0xdc, 0xc5, 0xa, 0x98, 0xa8, 0x2e, 0x20, 0x73, 0x88, 0x0, 0xb6, 0xcd, 0xdb, 0xe5, 0xfe, 0x96, 0x94, 0xad, 0x6d},
+               output224: []byte{0x8a, 0x2a, 0xe6, 0xb9, 0xaa, 0x7b, 0x1e, 0x8, 0xf8, 0xc7, 0xdc, 0x3b, 0xf5, 0xae, 0x87, 0x66, 0x60, 0xd3, 0xf, 0x79, 0x39, 0x17, 0x14, 0xa1, 0x75, 0x38, 0x10, 0x91},
+               output256: []byte{0x6a, 0x76, 0x9f, 0x93, 0xf2, 0x55, 0xb0, 0x78, 0xfe, 0x73, 0xaf, 0xf6, 0x8f, 0x4, 0x22, 0xa2, 0x79, 0x93, 0x99, 0x20, 0xe4, 0x69, 0xb, 0x4a, 0xff, 0xe, 0x43, 0x3c, 0xfa, 0x3d, 0x3d, 0xf3},
+               output384: []byte{0xb1, 0x15, 0xa9, 0x96, 0x8b, 0x5, 0x4c, 0x93, 0x4c, 0x39, 0x6d, 0x81, 0x88, 0xba, 0xc, 0x33, 0xa2, 0x3c, 0x71, 0x89, 0xce, 0x88, 0xb1, 0xde, 0x4a, 0x6, 0xcd, 0x31, 0x97, 0x92, 0xd2, 0x86, 0x47, 0xea, 0xe1, 0xd8, 0x8f, 0xb0, 0xb8, 0x74, 0x43, 0xe4, 0x62, 0x92, 0xa5, 0xc6, 0x45, 0xe8},
+               output512: []byte{0x48, 0xfc, 0x28, 0x2f, 0x37, 0xa3, 0xe1, 0xfb, 0x5d, 0xf4, 0xd2, 0xda, 0x1f, 0x71, 0x97, 0xec, 0x89, 0x9a, 0xe5, 0x73, 0xca, 0x8, 0xdf, 0x55, 0xe, 0x61, 0xee, 0x84, 0x7e, 0xeb, 0x1d, 0x24, 0xc0, 0x74, 0xff, 0x46, 0xbc, 0xae, 0xe2, 0x24, 0xec, 0x7d, 0x8c, 0xea, 0x42, 0x56, 0x15, 0x4f, 0xc, 0x4d, 0x43, 0x4e, 0x68, 0x28, 0x34, 0xf6, 0xd8, 0x27, 0xbf, 0xbd, 0xf7, 0x51, 0x12, 0xf5}},
+       testcase{
+               msg:       []byte{0x1e, 0xed, 0x9c, 0xba, 0x17, 0x9a, 0x0, 0x9e, 0xc2, 0xec, 0x55, 0x8, 0x77, 0x3d, 0xd3, 0x5, 0x47, 0x7c, 0xa1, 0x17, 0xe6, 0xd5, 0x69, 0xe6, 0x6b, 0x5f, 0x64, 0xc6, 0xbc, 0x64, 0x80, 0x1c, 0xe2, 0x5a, 0x84, 0x24, 0xce, 0x4a, 0x26, 0xd5, 0x75, 0xb8, 0xa6, 0xfb, 0x10, 0xea, 0xd3, 0xfd, 0x19, 0x92, 0xed, 0xdd, 0xee, 0xc2, 0xeb, 0xe7, 0x15, 0xd, 0xc9, 0x8f, 0x63, 0xad, 0xc3, 0x23, 0x7e, 0xf5, 0x7b, 0x91, 0x39, 0x7a, 0xa8, 0xa7},
+               output224: []byte{0x70, 0x2b, 0x19, 0x6, 0xa6, 0x3d, 0xf, 0x92, 0x4a, 0xfe, 0xc3, 0xbb, 0x5e, 0x5c, 0x57, 0x42, 0xe8, 0x5f, 0x98, 0x34, 0xea, 0x6f, 0x53, 0x6, 0x64, 0x48, 0x11, 0xa1},
+               output256: []byte{0xc0, 0x6d, 0xd4, 0x26, 0x16, 0x38, 0xc4, 0x4a, 0xfc, 0xb1, 0x86, 0xf0, 0xaf, 0x5d, 0xe2, 0xe, 0xa5, 0x3a, 0xa6, 0x33, 0x16, 0xfb, 0xb7, 0x17, 0x28, 0xf8, 0x74, 0xff, 0x3d, 0xac, 0xeb, 0xd},
+               output384: []byte{0xc8, 0xfa, 0xef, 0x75, 0x7e, 0x6d, 0x7b, 0xa, 0xf4, 0x6d, 0xa1, 0xe5, 0x7c, 0x71, 0xab, 0xb4, 0xaa, 0xf7, 0xcc, 0x91, 0xc5, 0xcd, 0xc3, 0x3b, 0xa8, 0xa7, 0x38, 0x17, 0x2b, 0x95, 0xde, 0x8, 0x7e, 0xc4, 0xc9, 0x26, 0x92, 0xcb, 0x40, 0xee, 0x37, 0x87, 0xbc, 0xe3, 0x20, 0x6f, 0xb7, 0xea},
+               output512: []byte{0x6b, 0x4b, 0xf, 0x12, 0x68, 0x63, 0x55, 0x2a, 0x6f, 0x40, 0xf4, 0x5e, 0x29, 0x5d, 0xc7, 0x9b, 0x9b, 0xa2, 0xa8, 0x8e, 0xa7, 0xc3, 0xb2, 0xf6, 0x7, 0xac, 0x1a, 0x84, 0x31, 0xa9, 0x78, 0x44, 0xc2, 0xa7, 0xb6, 0x64, 0x44, 0x3f, 0xb2, 0x3c, 0x5, 0x73, 0x9d, 0xf5, 0x49, 0x4f, 0xe9, 0x82, 0x4d, 0xb8, 0xb, 0x7f, 0x3e, 0x67, 0x87, 0x21, 0x42, 0xf1, 0x7e, 0x2c, 0x55, 0x44, 0xe1, 0xef}},
+       testcase{
+               msg:       []byte{0xba, 0x5b, 0x67, 0xb5, 0xec, 0x3a, 0x3f, 0xfa, 0xe2, 0xc1, 0x9d, 0xd8, 0x17, 0x6a, 0x2e, 0xf7, 0x5c, 0xc, 0xd9, 0x3, 0x72, 0x5d, 0x45, 0xc9, 0xcb, 0x70, 0x9, 0xa9, 0x0, 0xc0, 0xb0, 0xca, 0x7a, 0x29, 0x67, 0xa9, 0x5a, 0xe6, 0x82, 0x69, 0xa6, 0xdb, 0xf8, 0x46, 0x6c, 0x7b, 0x68, 0x44, 0xa1, 0xd6, 0x8, 0xac, 0x66, 0x1f, 0x7e, 0xff, 0x0, 0x53, 0x8e, 0x32, 0x3d, 0xb5, 0xf2, 0xc6, 0x44, 0xb7, 0x8b, 0x2d, 0x48, 0xde, 0x1a, 0x8, 0xaa},
+               output224: []byte{0xbf, 0x21, 0x1, 0x51, 0x12, 0x20, 0xb7, 0xdf, 0xe5, 0x4b, 0x12, 0x7c, 0x24, 0x76, 0xea, 0xad, 0xfd, 0x4e, 0xab, 0x7f, 0xd0, 0xf6, 0xbd, 0xd1, 0x93, 0x7, 0x8a, 0xc8},
+               output256: []byte{0xb5, 0xd8, 0x4b, 0x18, 0x9, 0xe8, 0x3b, 0x5e, 0x75, 0xaa, 0x53, 0xbd, 0xee, 0x79, 0xe3, 0xa9, 0x7f, 0x3f, 0xe3, 0xa7, 0xd3, 0x16, 0x2e, 0xbd, 0x49, 0x8, 0x24, 0xf, 0xf6, 0x91, 0x31, 0xd8},
+               output384: []byte{0xf4, 0xf2, 0x1b, 0xb7, 0x45, 0x93, 0xaa, 0x10, 0x7d, 0xc1, 0x95, 0xff, 0x52, 0xa3, 0xf9, 0x8, 0x16, 0xcc, 0xea, 0xe8, 0xd3, 0xeb, 0x9d, 0x45, 0x77, 0xb2, 0x8b, 0x49, 0xc3, 0x39, 0x83, 0x7a, 0x52, 0x70, 0xa, 0x62, 0xeb, 0x42, 0x1e, 0x8c, 0xa1, 0xc8, 0x7f, 0x45, 0x63, 0x10, 0xf6, 0x2c},
+               output512: []byte{0x7e, 0xec, 0x7b, 0x73, 0x0, 0x56, 0xb1, 0xbd, 0x4f, 0x6f, 0xfc, 0x18, 0x6f, 0xb4, 0x55, 0x91, 0xe5, 0xc, 0xd9, 0x3c, 0xf6, 0xe4, 0xfc, 0x95, 0x88, 0x89, 0xf8, 0x2d, 0x3f, 0x32, 0xc5, 0xc7, 0x4d, 0x3, 0xa4, 0xbc, 0xf7, 0xd2, 0x75, 0x42, 0x98, 0xf1, 0x34, 0x69, 0x8a, 0xf4, 0x55, 0x9b, 0xe, 0x29, 0xba, 0xaa, 0x36, 0x5c, 0xc0, 0xd, 0xb0, 0xd5, 0x1d, 0x40, 0x71, 0x79, 0xc5, 0x6d}},
+       testcase{
+               msg:       []byte{0xe, 0xfa, 0x26, 0xac, 0x56, 0x73, 0x16, 0x7d, 0xca, 0xca, 0xb8, 0x60, 0x93, 0x2e, 0xd6, 0x12, 0xf6, 0x5f, 0xf4, 0x9b, 0x80, 0xfa, 0x9a, 0xe6, 0x54, 0x65, 0xe5, 0x54, 0x2c, 0xb6, 0x20, 0x75, 0xdf, 0x1c, 0x5a, 0xe5, 0x4f, 0xba, 0x4d, 0xb8, 0x7, 0xbe, 0x25, 0xb0, 0x70, 0x3, 0x3e, 0xfa, 0x22, 0x3b, 0xdd, 0x5b, 0x1d, 0x3c, 0x94, 0xc6, 0xe1, 0x90, 0x9c, 0x2, 0xb6, 0x20, 0xd4, 0xb1, 0xb3, 0xa6, 0xc9, 0xfe, 0xd2, 0x4d, 0x70, 0x74, 0x96, 0x4},
+               output224: []byte{0xb0, 0x7a, 0xdb, 0xed, 0x91, 0x27, 0x23, 0xa0, 0x7f, 0xa5, 0x35, 0x3f, 0x66, 0x5e, 0xc1, 0x4f, 0xf8, 0x2d, 0x85, 0xe9, 0xb, 0xe3, 0xe5, 0xa1, 0xf5, 0xc9, 0xf, 0xff},
+               output256: []byte{0xca, 0xd7, 0xab, 0xb5, 0xbb, 0xa5, 0x90, 0x5b, 0x51, 0x81, 0xdd, 0x2d, 0xbc, 0x4e, 0x68, 0xcf, 0xd0, 0x1b, 0xa8, 0x65, 0x9f, 0x21, 0xc8, 0x29, 0xd, 0x3f, 0x83, 0x5c, 0x1a, 0x68, 0xbb, 0xe5},
+               output384: []byte{0x83, 0x54, 0x45, 0x11, 0xa0, 0x7f, 0x60, 0x58, 0xd9, 0xfe, 0x5a, 0xad, 0x7e, 0xa8, 0x37, 0xa9, 0xe1, 0x80, 0xd8, 0xbb, 0xb8, 0x84, 0xc5, 0x65, 0xb, 0x79, 0x89, 0x42, 0x98, 0x3a, 0x60, 0x5a, 0x51, 0x4c, 0x21, 0xd8, 0xd6, 0x3d, 0xb0, 0xe2, 0x5a, 0xae, 0x51, 0xd2, 0x6f, 0x41, 0xb, 0xc5},
+               output512: []byte{0x79, 0xcb, 0x92, 0x5a, 0xca, 0x7, 0x2e, 0xbb, 0x3b, 0x49, 0xa9, 0xd0, 0xe5, 0x9b, 0xb0, 0x7d, 0xd1, 0xc2, 0x23, 0xc1, 0xf2, 0x6c, 0x91, 0x76, 0x8b, 0x92, 0x94, 0x72, 0xc5, 0x1b, 0x97, 0x7f, 0x85, 0xc6, 0xce, 0xeb, 0x54, 0xbc, 0xe8, 0x9c, 0xf9, 0xff, 0x61, 0x55, 0xd7, 0xfe, 0x80, 0x91, 0x54, 0xf, 0x13, 0x48, 0xce, 0x95, 0x92, 0xa6, 0x40, 0x3f, 0x92, 0x10, 0x54, 0x77, 0x87, 0xe}},
+       testcase{
+               msg:       []byte{0xbb, 0xfd, 0x93, 0x3d, 0x1f, 0xd7, 0xbf, 0x59, 0x4a, 0xc7, 0xf4, 0x35, 0x27, 0x7d, 0xc1, 0x7d, 0x8d, 0x5a, 0x5b, 0x8e, 0x4d, 0x13, 0xd9, 0x6d, 0x2f, 0x64, 0xe7, 0x71, 0xab, 0xbd, 0x51, 0xa5, 0xa8, 0xae, 0xa7, 0x41, 0xbe, 0xcc, 0xbd, 0xdb, 0x17, 0x7b, 0xce, 0xa0, 0x52, 0x43, 0xeb, 0xd0, 0x3, 0xcf, 0xde, 0xae, 0x87, 0x7c, 0xca, 0x4d, 0xa9, 0x46, 0x5, 0xb6, 0x76, 0x91, 0x91, 0x9d, 0x8b, 0x3, 0x3f, 0x77, 0xd3, 0x84, 0xca, 0x1, 0x59, 0x3c, 0x1b},
+               output224: []byte{0xd1, 0x71, 0x8f, 0xd, 0x38, 0x7a, 0xc4, 0x27, 0x11, 0x1a, 0x7e, 0x90, 0xe5, 0x75, 0xde, 0x5f, 0x4, 0x77, 0x8e, 0xa2, 0xba, 0x14, 0x7a, 0x84, 0x51, 0x91, 0x4f, 0xf0},
+               output256: []byte{0x83, 0xca, 0x9, 0xc1, 0xf4, 0x18, 0xb5, 0xda, 0xd0, 0xa7, 0xf6, 0x4a, 0x90, 0x4a, 0x2e, 0x7, 0xc3, 0x31, 0x4f, 0x7d, 0x2, 0xd9, 0x26, 0x22, 0xf8, 0xf4, 0x67, 0x4b, 0xc1, 0xf6, 0xaa, 0x3d},
+               output384: []byte{0x8e, 0xcd, 0x84, 0x59, 0xfb, 0x90, 0x4d, 0x2e, 0xdd, 0xb1, 0x42, 0x7, 0x65, 0x9c, 0x2b, 0xf9, 0x6e, 0xfb, 0xd3, 0xe4, 0xc8, 0x98, 0x87, 0x36, 0xec, 0x75, 0x8, 0x8f, 0x1c, 0xc8, 0x11, 0x5d, 0x3f, 0xff, 0xc8, 0xce, 0xdf, 0x1c, 0x1, 0x72, 0x14, 0x69, 0xd2, 0x79, 0x68, 0xa6, 0x85, 0x6b},
+               output512: []byte{0xb5, 0xd1, 0xed, 0x8f, 0x3, 0x90, 0x44, 0xbc, 0xfe, 0xf4, 0x1e, 0x99, 0xb2, 0xf5, 0x64, 0xf4, 0x59, 0x91, 0xb3, 0x29, 0xb5, 0x3, 0xfc, 0x91, 0xfa, 0x29, 0xd2, 0x40, 0x85, 0x12, 0xf8, 0x71, 0x1e, 0x9d, 0xb6, 0x6f, 0x8a, 0xe1, 0x72, 0x16, 0x46, 0x50, 0x54, 0x5a, 0xe9, 0xe3, 0xdb, 0x32, 0xaa, 0x36, 0x9e, 0xc4, 0x7e, 0x81, 0xa7, 0x71, 0x11, 0x27, 0x6e, 0x6c, 0xa3, 0x8e, 0x4d, 0x92}},
+       testcase{
+               msg:       []byte{0x90, 0x7, 0x89, 0x99, 0xfd, 0x3c, 0x35, 0xb8, 0xaf, 0xbf, 0x40, 0x66, 0xcb, 0xde, 0x33, 0x58, 0x91, 0x36, 0x5f, 0xf, 0xc7, 0x5c, 0x12, 0x86, 0xcd, 0xd8, 0x8f, 0xa5, 0x1f, 0xab, 0x94, 0xf9, 0xb8, 0xde, 0xf7, 0xc9, 0xac, 0x58, 0x2a, 0x5d, 0xbc, 0xd9, 0x58, 0x17, 0xaf, 0xb7, 0xd1, 0xb4, 0x8f, 0x63, 0x70, 0x4e, 0x19, 0xc2, 0xba, 0xa4, 0xdf, 0x34, 0x7f, 0x48, 0xd4, 0xa6, 0xd6, 0x3, 0x1, 0x3c, 0x23, 0xf1, 0xe9, 0x61, 0x1d, 0x59, 0x5e, 0xba, 0xc3, 0x7c},
+               output224: []byte{0xfa, 0xf7, 0xd7, 0x93, 0x2, 0x4e, 0x6d, 0x5, 0xe7, 0x7c, 0x52, 0x31, 0x71, 0x24, 0x78, 0x82, 0x2c, 0x91, 0x52, 0x92, 0xfc, 0xc1, 0x42, 0x7e, 0x6a, 0xcf, 0xd3, 0xcf},
+               output256: []byte{0x33, 0xd, 0xe3, 0xee, 0x16, 0xae, 0xf6, 0x71, 0x14, 0x61, 0xa9, 0x94, 0x86, 0x3e, 0xed, 0x47, 0xaf, 0x71, 0xb3, 0x62, 0xd4, 0xc2, 0xf2, 0x43, 0x53, 0x4e, 0xf4, 0x32, 0xf6, 0x3a, 0x9, 0x1a},
+               output384: []byte{0xbe, 0x60, 0x24, 0x6e, 0x27, 0x95, 0x9d, 0xc8, 0x6, 0x5c, 0x6d, 0x4d, 0xca, 0xc9, 0x3e, 0xb7, 0xf7, 0x14, 0x6b, 0x49, 0xc7, 0x59, 0xbf, 0x1d, 0xd5, 0xeb, 0xa4, 0x6a, 0x3e, 0xcf, 0x7, 0x47, 0x84, 0xa9, 0xdf, 0x18, 0xde, 0xab, 0x7a, 0x19, 0xaf, 0x7f, 0x62, 0x90, 0xcd, 0xac, 0xa8, 0x7b},
+               output512: []byte{0x78, 0x2c, 0x0, 0x8a, 0x9e, 0xe3, 0xdd, 0xa0, 0xa1, 0x82, 0x26, 0x71, 0x85, 0xc9, 0x95, 0xa2, 0xaf, 0x73, 0x7b, 0xa8, 0xcb, 0x2f, 0x61, 0x79, 0xf2, 0xcd, 0xf5, 0x25, 0x5, 0xf8, 0xd9, 0x33, 0xe7, 0x12, 0xfc, 0x4e, 0x56, 0xd1, 0xe, 0x17, 0x5e, 0xc8, 0xcd, 0xd6, 0x2d, 0xe6, 0x52, 0x9c, 0xe1, 0xf0, 0x78, 0xbf, 0xa0, 0xdc, 0x7a, 0x52, 0x84, 0xf8, 0xc5, 0x65, 0x18, 0x2f, 0x85, 0xd9}},
+       testcase{
+               msg:       []byte{0x64, 0x10, 0x5e, 0xca, 0x86, 0x35, 0x15, 0xc2, 0xe, 0x7c, 0xfb, 0xaa, 0xa, 0xb, 0x88, 0x9, 0x4, 0x61, 0x64, 0xf3, 0x74, 0xd6, 0x91, 0xcd, 0xbd, 0x65, 0x8, 0xaa, 0xab, 0xc1, 0x81, 0x9f, 0x9a, 0xc8, 0x4b, 0x52, 0xba, 0xfc, 0x1b, 0xf, 0xe7, 0xcd, 0xdb, 0xc5, 0x54, 0xb6, 0x8, 0xc0, 0x1c, 0x89, 0x4, 0xc6, 0x69, 0xd8, 0xdb, 0x31, 0x6a, 0x9, 0x53, 0xa4, 0xc6, 0x8e, 0xce, 0x32, 0x4e, 0xc5, 0xa4, 0x9f, 0xfd, 0xb5, 0x9a, 0x1b, 0xd6, 0xa2, 0x92, 0xaa, 0xe},
+               output224: []byte{0xa3, 0x75, 0xd7, 0x56, 0xa8, 0xf3, 0x9c, 0x72, 0xf6, 0x7c, 0xa4, 0x89, 0xc9, 0x5f, 0x99, 0x35, 0xf, 0xfd, 0x5, 0x15, 0xb1, 0x51, 0xa3, 0xbf, 0xf2, 0x88, 0xca, 0xaa},
+               output256: []byte{0xb5, 0x67, 0x51, 0x97, 0xe4, 0x9b, 0x35, 0x72, 0x18, 0xf7, 0x11, 0x8c, 0xd1, 0x5e, 0xe7, 0x73, 0xb3, 0x9b, 0xd5, 0x9b, 0x22, 0x4d, 0x9a, 0x45, 0xca, 0x71, 0xc6, 0xe3, 0x71, 0xd9, 0x38, 0xf1},
+               output384: []byte{0x92, 0x35, 0xba, 0x18, 0xc5, 0x5e, 0x2c, 0xbc, 0xa0, 0xfb, 0x1d, 0xa3, 0xbc, 0x8d, 0xd, 0xfd, 0x84, 0x8c, 0xa0, 0xe5, 0x1d, 0xdc, 0x10, 0x20, 0xd4, 0xbe, 0xcc, 0xf, 0x13, 0x8d, 0xa1, 0x8, 0x79, 0x29, 0xfe, 0xc9, 0x3a, 0xf1, 0x6f, 0x5f, 0xb2, 0x9c, 0x4a, 0x77, 0x7d, 0xd9, 0x15, 0x48},
+               output512: []byte{0x91, 0xa0, 0x24, 0x1e, 0xda, 0x8c, 0xa5, 0x97, 0xcb, 0xb0, 0xf7, 0x3, 0xab, 0x7d, 0xba, 0xaf, 0x85, 0x9c, 0xff, 0x77, 0xb2, 0x4, 0x1, 0xad, 0x46, 0x23, 0xc, 0xe3, 0xb2, 0xbe, 0xef, 0x66, 0x85, 0x77, 0x5d, 0xe3, 0x75, 0x76, 0x1, 0x4d, 0x8d, 0xa1, 0xba, 0x67, 0x2d, 0x47, 0xaa, 0xd9, 0x5f, 0xb5, 0x3c, 0x59, 0xb, 0x65, 0x6, 0x34, 0xce, 0xbb, 0x43, 0xa1, 0x75, 0x73, 0x85, 0x69}},
+       testcase{
+               msg:       []byte{0xd4, 0x65, 0x4b, 0xe2, 0x88, 0xb9, 0xf3, 0xb7, 0x11, 0xc2, 0xd0, 0x20, 0x15, 0x97, 0x8a, 0x8c, 0xc5, 0x74, 0x71, 0xd5, 0x68, 0xa, 0x9, 0x2a, 0xa5, 0x34, 0xf7, 0x37, 0x2c, 0x71, 0xce, 0xaa, 0xb7, 0x25, 0xa3, 0x83, 0xc4, 0xfc, 0xf4, 0xd8, 0xde, 0xaa, 0x57, 0xfc, 0xa3, 0xce, 0x5, 0x6f, 0x31, 0x29, 0x61, 0xec, 0xcf, 0x9b, 0x86, 0xf1, 0x49, 0x81, 0xba, 0x5b, 0xed, 0x6a, 0xb5, 0xb4, 0x49, 0x8e, 0x1f, 0x6c, 0x82, 0xc6, 0xca, 0xe6, 0xfc, 0x14, 0x84, 0x5b, 0x3c, 0x8a},
+               output224: []byte{0x1b, 0xd1, 0xb6, 0xf3, 0x14, 0x4a, 0x3d, 0xee, 0x93, 0xde, 0xa1, 0xdf, 0x3, 0xc0, 0xe9, 0x58, 0xf4, 0x85, 0xb8, 0xae, 0x16, 0x4d, 0xce, 0xe5, 0x5f, 0x97, 0x34, 0x13},
+               output256: []byte{0xcd, 0x90, 0x38, 0xc1, 0x6, 0x6a, 0x59, 0x99, 0xd, 0xf5, 0x75, 0x21, 0x7, 0xb0, 0x66, 0xee, 0xbb, 0xe6, 0x72, 0xcb, 0xca, 0xf, 0x60, 0xd6, 0x87, 0xd0, 0x3a, 0x9d, 0x82, 0x19, 0x34, 0xbe},
+               output384: []byte{0x8, 0x73, 0x9d, 0xd8, 0x66, 0xc6, 0x21, 0x6a, 0xdc, 0xa2, 0x6d, 0x61, 0x21, 0xe5, 0xd8, 0x1f, 0xdb, 0x1f, 0x7b, 0xcd, 0x48, 0x2, 0xc2, 0xb8, 0x11, 0xd7, 0x3c, 0x28, 0x22, 0x77, 0xd4, 0x1, 0x4b, 0x49, 0x36, 0xe5, 0x58, 0x9f, 0x62, 0x27, 0x9b, 0xb3, 0x30, 0x75, 0x70, 0x57, 0x95, 0xf8},
+               output512: []byte{0x0, 0xb0, 0x2d, 0xbc, 0xb7, 0xa3, 0xbc, 0x11, 0x77, 0x1, 0xf2, 0xf1, 0x59, 0xfc, 0x44, 0x92, 0x92, 0x3c, 0x43, 0x7d, 0x33, 0x69, 0x83, 0x3a, 0x9b, 0xd0, 0x9e, 0x78, 0xe2, 0x60, 0xd4, 0x8d, 0x37, 0x16, 0x8d, 0x36, 0xc4, 0x97, 0x77, 0xb2, 0xe6, 0x8e, 0x6f, 0xe9, 0x84, 0x61, 0x6, 0xa6, 0xab, 0x87, 0x68, 0xc3, 0x97, 0x1f, 0xab, 0x31, 0xfd, 0x92, 0x2a, 0xac, 0xb8, 0x7d, 0x1c, 0xac}},
+       testcase{
+               msg:       []byte{0x12, 0xd9, 0x39, 0x48, 0x88, 0x30, 0x5a, 0xc9, 0x6e, 0x65, 0xf2, 0xbf, 0xe, 0x1b, 0x18, 0xc2, 0x9c, 0x90, 0xfe, 0x9d, 0x71, 0x4d, 0xd5, 0x9f, 0x65, 0x1f, 0x52, 0xb8, 0x8b, 0x30, 0x8, 0xc5, 0x88, 0x43, 0x55, 0x48, 0x6, 0x6e, 0xa2, 0xfc, 0x4c, 0x10, 0x11, 0x18, 0xc9, 0x1f, 0x32, 0x55, 0x62, 0x24, 0xa5, 0x40, 0xde, 0x6e, 0xfd, 0xdb, 0xca, 0x29, 0x6e, 0xf1, 0xfb, 0x0, 0x34, 0x1f, 0x5b, 0x1, 0xfe, 0xcf, 0xc1, 0x46, 0xbd, 0xb2, 0x51, 0xb3, 0xbd, 0xad, 0x55, 0x6c, 0xd2},
+               output224: []byte{0xbe, 0x88, 0xb4, 0x95, 0xd0, 0xcd, 0x90, 0x28, 0x1a, 0xf2, 0x9, 0x4b, 0x8d, 0x7e, 0x72, 0xeb, 0x41, 0x72, 0x88, 0xca, 0x16, 0xf7, 0x51, 0xc0, 0x96, 0x94, 0xb6, 0x82},
+               output256: []byte{0xd3, 0x17, 0x2c, 0xa2, 0x63, 0xaf, 0xf2, 0xb9, 0xdb, 0x6f, 0xb1, 0x33, 0x37, 0xf2, 0x54, 0x3c, 0x5a, 0xf5, 0x11, 0x51, 0x80, 0x1a, 0x76, 0x19, 0x40, 0x12, 0xf7, 0x10, 0x30, 0x6c, 0x14, 0xf6},
+               output384: []byte{0xd2, 0xa2, 0xe8, 0x58, 0xa5, 0xdd, 0x85, 0xd6, 0x2e, 0x6f, 0x51, 0xaf, 0x7e, 0x42, 0x35, 0x2a, 0xc0, 0xd7, 0xa6, 0x8a, 0x83, 0x54, 0x31, 0xbc, 0xca, 0x47, 0x55, 0x7e, 0x3b, 0x5c, 0x33, 0x73, 0xf4, 0xd, 0x3b, 0xaf, 0x85, 0xae, 0x41, 0x60, 0x12, 0xc7, 0xc9, 0x82, 0xb2, 0x32, 0x57, 0x90},
+               output512: []byte{0x3d, 0xed, 0xf8, 0x19, 0xb3, 0x57, 0xdf, 0xab, 0x1c, 0x70, 0x92, 0xab, 0xd8, 0x72, 0xa1, 0x55, 0x4d, 0xd0, 0x96, 0x2e, 0x99, 0x44, 0xee, 0xf9, 0xf7, 0xf8, 0xbc, 0xe8, 0x30, 0xf2, 0xd7, 0x4f, 0x1d, 0x9b, 0xa2, 0xb7, 0x48, 0xbb, 0xc6, 0xee, 0xb, 0x76, 0x0, 0xbe, 0x8c, 0xb0, 0xff, 0xcb, 0x79, 0x92, 0x4d, 0x9f, 0x51, 0xcd, 0xb9, 0xb0, 0x6b, 0xd6, 0xfd, 0x37, 0xf3, 0x5, 0x2, 0x29}},
+       testcase{
+               msg:       []byte{0x87, 0x1a, 0xd, 0x7a, 0x5f, 0x36, 0xc3, 0xda, 0x1d, 0xfc, 0xe5, 0x7a, 0xcd, 0x8a, 0xb8, 0x48, 0x7c, 0x27, 0x4f, 0xad, 0x33, 0x6b, 0xc1, 0x37, 0xeb, 0xd6, 0xff, 0x46, 0x58, 0xb5, 0x47, 0xc1, 0xdc, 0xfa, 0xb6, 0x5f, 0x3, 0x7a, 0xa5, 0x8f, 0x35, 0xef, 0x16, 0xaf, 0xf4, 0xab, 0xe7, 0x7b, 0xa6, 0x1f, 0x65, 0x82, 0x6f, 0x7b, 0xe6, 0x81, 0xb5, 0xb6, 0xd5, 0xa1, 0xea, 0x80, 0x85, 0xe2, 0xae, 0x9c, 0xd5, 0xcf, 0x9, 0x91, 0x87, 0x8a, 0x31, 0x1b, 0x54, 0x9a, 0x6d, 0x6a, 0xf2, 0x30},
+               output224: []byte{0x7d, 0xac, 0x4, 0x62, 0x54, 0x80, 0x84, 0x64, 0x2, 0x46, 0x17, 0xd6, 0x3a, 0x3, 0x82, 0x67, 0xfe, 0x2c, 0xa6, 0x50, 0x52, 0xbd, 0xeb, 0x56, 0x9a, 0xa, 0x9c, 0x15},
+               output256: []byte{0x9e, 0x3d, 0x4b, 0xcf, 0x58, 0xe, 0xec, 0xe3, 0x9b, 0xcf, 0x13, 0xe5, 0x71, 0x6e, 0x5b, 0xb8, 0xf5, 0xe8, 0xc3, 0xfc, 0x37, 0x23, 0xf6, 0x62, 0x46, 0xf8, 0x36, 0xd8, 0xdb, 0x12, 0x38, 0xf1},
+               output384: []byte{0x29, 0x90, 0xd7, 0xea, 0x6, 0x8a, 0x3, 0x7, 0x4, 0x7b, 0x15, 0x1d, 0x5d, 0xd6, 0xb1, 0xb2, 0x35, 0x8a, 0x9e, 0xc8, 0xad, 0x9b, 0x6b, 0x82, 0x6c, 0xf1, 0xbe, 0xf3, 0x99, 0xd4, 0x88, 0xbd, 0x68, 0xd7, 0x7d, 0xf8, 0xbe, 0x99, 0xf7, 0xdf, 0x7a, 0xf1, 0x4a, 0xe0, 0xce, 0x63, 0x63, 0x79},
+               output512: []byte{0x5f, 0xbe, 0x19, 0x45, 0x57, 0xb0, 0x42, 0x6f, 0x96, 0xba, 0x60, 0x71, 0x21, 0x76, 0xdf, 0x7, 0x3e, 0xaf, 0xe0, 0x4f, 0x2a, 0x50, 0x51, 0x54, 0x55, 0x41, 0x2e, 0xa3, 0xd8, 0xc, 0x11, 0x67, 0x58, 0xad, 0x95, 0x25, 0x98, 0xf4, 0x80, 0x31, 0x61, 0x21, 0x81, 0xd8, 0x2a, 0x16, 0xef, 0xe4, 0x66, 0x8f, 0xfb, 0x3b, 0xcc, 0xe9, 0x56, 0x3a, 0x77, 0x2f, 0xe4, 0x16, 0xff, 0x6d, 0xb3, 0xb3}},
+       testcase{
+               msg:       []byte{0xe9, 0xb, 0x4f, 0xfe, 0xf4, 0xd4, 0x57, 0xbc, 0x77, 0x11, 0xff, 0x4a, 0xa7, 0x22, 0x31, 0xca, 0x25, 0xaf, 0x6b, 0x2e, 0x20, 0x6f, 0x8b, 0xf8, 0x59, 0xd8, 0x75, 0x8b, 0x89, 0xa7, 0xcd, 0x36, 0x10, 0x5d, 0xb2, 0x53, 0x8d, 0x6, 0xda, 0x83, 0xba, 0xd5, 0xf6, 0x63, 0xba, 0x11, 0xa5, 0xf6, 0xf6, 0x1f, 0x23, 0x6f, 0xd5, 0xf8, 0xd5, 0x3c, 0x5e, 0x89, 0xf1, 0x83, 0xa3, 0xce, 0xc6, 0x15, 0xb5, 0xc, 0x7c, 0x68, 0x1e, 0x77, 0x3d, 0x10, 0x9f, 0xf7, 0x49, 0x1b, 0x5c, 0xc2, 0x22, 0x96, 0xc5},
+               output224: []byte{0x89, 0xf6, 0xb3, 0x20, 0xef, 0xab, 0xe4, 0x2c, 0xe1, 0x3c, 0x9e, 0x20, 0xe4, 0x82, 0x9f, 0x31, 0xa7, 0x84, 0x8e, 0xee, 0x3f, 0xc8, 0x54, 0xe6, 0x3, 0xfb, 0xd4, 0x6f},
+               output256: []byte{0xed, 0xc2, 0xd3, 0xb4, 0x9c, 0x85, 0xb8, 0xdd, 0x75, 0xf7, 0xb5, 0x12, 0x8d, 0xa0, 0x4c, 0xd7, 0x6b, 0xf4, 0x87, 0x87, 0x79, 0xa0, 0x7, 0x7a, 0xf3, 0xf1, 0xd7, 0xfb, 0x44, 0xf1, 0x89, 0x31},
+               output384: []byte{0x4b, 0x30, 0x87, 0xf8, 0x0, 0xe4, 0x8, 0x4d, 0x7f, 0x68, 0x57, 0x37, 0xac, 0x63, 0x5d, 0xb4, 0x59, 0xcf, 0x70, 0xc4, 0xfa, 0x86, 0x3c, 0x71, 0x1c, 0x11, 0x43, 0xcc, 0x10, 0xf0, 0xc4, 0xab, 0xa, 0x23, 0x70, 0xc0, 0x99, 0xfb, 0x28, 0x2f, 0x9c, 0x1c, 0xe5, 0xf0, 0x15, 0xbf, 0x3f, 0x79},
+               output512: []byte{0x2e, 0x8a, 0xb1, 0x61, 0x98, 0x59, 0xc1, 0x14, 0x73, 0xdc, 0x7c, 0x47, 0x4c, 0xe8, 0xb0, 0xae, 0x44, 0xb1, 0xc3, 0x84, 0x17, 0x81, 0x6f, 0xd9, 0x5b, 0x9e, 0x6, 0x14, 0xf3, 0x1e, 0x51, 0xeb, 0xb1, 0xdd, 0x16, 0xd1, 0xcb, 0xb5, 0x84, 0xc4, 0xeb, 0xd2, 0x8a, 0xa9, 0x9f, 0x4a, 0x68, 0xe0, 0x9d, 0xfe, 0x3a, 0xd4, 0x62, 0x48, 0x7f, 0x26, 0x8, 0x12, 0x4b, 0x75, 0x28, 0x29, 0x30, 0x45}},
+       testcase{
+               msg:       []byte{0xe7, 0x28, 0xde, 0x62, 0xd7, 0x58, 0x56, 0x50, 0xc, 0x4c, 0x77, 0xa4, 0x28, 0x61, 0x2c, 0xd8, 0x4, 0xf3, 0xc, 0x3f, 0x10, 0xd3, 0x6f, 0xb2, 0x19, 0xc5, 0xca, 0xa, 0xa3, 0x7, 0x26, 0xab, 0x19, 0xe, 0x5f, 0x3f, 0x27, 0x9e, 0x7, 0x33, 0xd7, 0x7e, 0x72, 0x67, 0xc1, 0x7b, 0xe2, 0x7d, 0x21, 0x65, 0xa, 0x9a, 0x4d, 0x1e, 0x32, 0xf6, 0x49, 0x62, 0x76, 0x38, 0xdb, 0xad, 0xa9, 0x70, 0x2c, 0x7c, 0xa3, 0x3, 0x26, 0x9e, 0xd1, 0x40, 0x14, 0xb2, 0xf3, 0xcf, 0x8b, 0x89, 0x4e, 0xac, 0x85, 0x54},
+               output224: []byte{0xa8, 0x5, 0xdb, 0xd3, 0xb8, 0xdf, 0x5e, 0x3, 0xe0, 0x5e, 0xff, 0xfd, 0xe1, 0xb9, 0x4b, 0x35, 0xa2, 0x3c, 0x5d, 0x77, 0xc2, 0x79, 0x7d, 0x98, 0x4e, 0x56, 0x65, 0x6f},
+               output256: []byte{0x80, 0xdc, 0xe7, 0xf0, 0x4d, 0xd6, 0xac, 0x17, 0xce, 0x70, 0x9b, 0x56, 0xcf, 0x6e, 0xa6, 0xc0, 0xa5, 0x71, 0x90, 0x64, 0x9b, 0xb1, 0x87, 0xb5, 0xe6, 0xd9, 0x5f, 0xa1, 0x81, 0x0, 0xc7, 0xac},
+               output384: []byte{0x5d, 0x34, 0x7f, 0xdd, 0xb1, 0x18, 0xfd, 0x7d, 0xb2, 0x70, 0x89, 0x84, 0x7, 0x97, 0x9d, 0x2d, 0x15, 0x31, 0xd3, 0xff, 0x66, 0x42, 0xec, 0x4f, 0x22, 0x91, 0x7e, 0xbb, 0xed, 0xa6, 0xce, 0xe0, 0xfb, 0xd, 0xe1, 0x14, 0x32, 0xed, 0xdd, 0xfc, 0xbf, 0xe, 0x2a, 0xb9, 0xcf, 0xa6, 0x58, 0x4},
+               output512: []byte{0xdb, 0x2d, 0x18, 0x2b, 0xdb, 0xac, 0x6a, 0xc8, 0x66, 0x53, 0x7e, 0x24, 0x71, 0x23, 0x32, 0xca, 0xe7, 0x4d, 0xc3, 0xd3, 0x61, 0x68, 0x98, 0x2e, 0x44, 0x53, 0xdd, 0x6e, 0x0, 0x96, 0x58, 0x34, 0x52, 0x55, 0x1, 0x3b, 0xc0, 0xa5, 0x4f, 0xca, 0x17, 0xae, 0xed, 0xcc, 0x4b, 0xeb, 0x79, 0xbd, 0xee, 0x19, 0x2c, 0xfa, 0xb5, 0x16, 0xd2, 0x45, 0x91, 0xc8, 0x69, 0x9f, 0x7c, 0x75, 0x81, 0x79}},
+       testcase{
+               msg:       []byte{0x63, 0x48, 0xf2, 0x29, 0xe7, 0xb1, 0xdf, 0x3b, 0x77, 0xc, 0x77, 0x54, 0x4e, 0x51, 0x66, 0xe0, 0x81, 0x85, 0xf, 0xa1, 0xc6, 0xc8, 0x81, 0x69, 0xdb, 0x74, 0xc7, 0x6e, 0x42, 0xeb, 0x98, 0x3f, 0xac, 0xb2, 0x76, 0xad, 0x6a, 0xd, 0x1f, 0xa7, 0xb5, 0xd, 0x3e, 0x3b, 0x6f, 0xcd, 0x79, 0x9e, 0xc9, 0x74, 0x70, 0x92, 0xa, 0x7a, 0xbe, 0xd4, 0x7d, 0x28, 0x8f, 0xf8, 0x83, 0xe2, 0x4c, 0xa2, 0x1c, 0x7f, 0x80, 0x16, 0xb9, 0x3b, 0xb9, 0xb9, 0xe0, 0x78, 0xbd, 0xb9, 0x70, 0x3d, 0x2b, 0x78, 0x1b, 0x61, 0x6e},
+               output224: []byte{0xf0, 0x57, 0x42, 0xcc, 0x1d, 0xb4, 0x22, 0xa3, 0x11, 0x3a, 0xc4, 0x96, 0x2, 0xe8, 0xd0, 0xdd, 0x6c, 0xb4, 0x72, 0xe7, 0xed, 0x26, 0xbc, 0xe4, 0xb, 0xba, 0x9, 0xbd},
+               output256: []byte{0x49, 0xbb, 0xd5, 0x43, 0x5d, 0x27, 0x6, 0xf8, 0x5f, 0xe7, 0x7b, 0x84, 0xa5, 0xfa, 0x15, 0xdd, 0xd8, 0x25, 0x9e, 0x5d, 0x2c, 0x20, 0xfb, 0x94, 0x7f, 0x13, 0x93, 0x73, 0xe5, 0xc8, 0x61, 0x21},
+               output384: []byte{0x95, 0x46, 0x37, 0xb8, 0x7f, 0xdc, 0xc4, 0x84, 0xf2, 0xb6, 0x1f, 0x7f, 0x42, 0x55, 0x80, 0x68, 0x2, 0x9f, 0x96, 0x9, 0x9c, 0x1d, 0x6b, 0x92, 0x46, 0x58, 0x50, 0x92, 0xea, 0xe6, 0x89, 0x24, 0xe5, 0x44, 0x1b, 0x45, 0x2, 0x72, 0x48, 0xa2, 0x72, 0x88, 0x33, 0x16, 0x9b, 0xfa, 0x50, 0x4},
+               output512: []byte{0x90, 0xa2, 0xc0, 0x5f, 0x70, 0x1, 0xd9, 0x85, 0xb5, 0x87, 0xa0, 0x46, 0xb4, 0x88, 0xbf, 0x4e, 0xd2, 0x9d, 0x75, 0xcc, 0x3, 0xa7, 0x45, 0x73, 0x1b, 0x5b, 0xc, 0xe5, 0x1b, 0xb8, 0x63, 0x87, 0xc4, 0xce, 0x34, 0x1, 0x8a, 0x6d, 0x90, 0x6e, 0xb7, 0xbe, 0xb4, 0x1a, 0x9, 0xaf, 0xe9, 0xfe, 0xdd, 0x99, 0xaa, 0xcc, 0x41, 0xb4, 0x55, 0x6f, 0x75, 0x22, 0x9c, 0x86, 0x88, 0xc7, 0xfc, 0xa2}},
+       testcase{
+               msg:       []byte{0x4b, 0x12, 0x7f, 0xde, 0x5d, 0xe7, 0x33, 0xa1, 0x68, 0xc, 0x27, 0x90, 0x36, 0x36, 0x27, 0xe6, 0x3a, 0xc8, 0xa3, 0xf1, 0xb4, 0x70, 0x7d, 0x98, 0x2c, 0xae, 0xa2, 0x58, 0x65, 0x5d, 0x9b, 0xf1, 0x8f, 0x89, 0xaf, 0xe5, 0x41, 0x27, 0x48, 0x2b, 0xa0, 0x1e, 0x8, 0x84, 0x55, 0x94, 0xb6, 0x71, 0x30, 0x6a, 0x2, 0x5c, 0x9a, 0x5c, 0x5b, 0x6f, 0x93, 0xb0, 0xa3, 0x95, 0x22, 0xdc, 0x87, 0x74, 0x37, 0xbe, 0x5c, 0x24, 0x36, 0xcb, 0xf3, 0x0, 0xce, 0x7a, 0xb6, 0x74, 0x79, 0x34, 0xfc, 0xfc, 0x30, 0xae, 0xaa, 0xf6},
+               output224: []byte{0x45, 0x94, 0x5f, 0x86, 0x7b, 0x7e, 0x1e, 0x75, 0xee, 0x49, 0x6e, 0xf, 0xc4, 0xaa, 0xff, 0x71, 0xa0, 0xcc, 0x53, 0x98, 0x41, 0xd1, 0x53, 0x43, 0x9a, 0xed, 0x4d, 0xfc},
+               output256: []byte{0x6b, 0x6c, 0x11, 0xf9, 0x73, 0x1d, 0x60, 0x78, 0x9d, 0x71, 0x3d, 0xaf, 0x53, 0xd2, 0xeb, 0x10, 0xab, 0x9c, 0xcf, 0x15, 0x43, 0xe, 0xa5, 0xd1, 0x24, 0x9b, 0xe0, 0x6e, 0xdf, 0xe2, 0xbf, 0xf6},
+               output384: []byte{0x78, 0x72, 0x6e, 0x91, 0xac, 0x31, 0x1f, 0x4d, 0x10, 0x47, 0x6, 0x36, 0x2b, 0x3, 0x14, 0xc2, 0x43, 0xcd, 0x81, 0x64, 0x41, 0x25, 0x88, 0x1f, 0xbc, 0x3, 0x67, 0x2, 0x10, 0xc8, 0x9f, 0xb8, 0xe7, 0xbf, 0xf6, 0xc6, 0x1f, 0xf6, 0x8b, 0x23, 0x4c, 0x31, 0x71, 0xf1, 0x6b, 0x39, 0x8f, 0x36},
+               output512: []byte{0xea, 0x39, 0x91, 0xc4, 0xa8, 0xa5, 0xf0, 0x14, 0x64, 0x2, 0xde, 0x4a, 0xe2, 0x35, 0x5, 0x4c, 0x78, 0xa4, 0x8d, 0xca, 0x34, 0xa, 0x7d, 0x4a, 0xd8, 0x75, 0x39, 0x95, 0xf8, 0x23, 0x47, 0xec, 0xfc, 0x0, 0x54, 0xd6, 0x4e, 0xb4, 0xf2, 0xa, 0xbc, 0x4f, 0x41, 0x5c, 0x54, 0x70, 0x1c, 0xbc, 0x61, 0xa7, 0xb2, 0x39, 0xa7, 0xc2, 0x21, 0xb8, 0x33, 0xd9, 0xea, 0x9f, 0x94, 0xb1, 0x54, 0xe8}},
+       testcase{
+               msg:       []byte{0x8, 0x46, 0x1f, 0x0, 0x6c, 0xff, 0x4c, 0xc6, 0x4b, 0x75, 0x2c, 0x95, 0x72, 0x87, 0xe5, 0xa0, 0xfa, 0xab, 0xc0, 0x5c, 0x9b, 0xff, 0x89, 0xd2, 0x3f, 0xd9, 0x2, 0xd3, 0x24, 0xc7, 0x99, 0x3, 0xb4, 0x8f, 0xcb, 0x8f, 0x8f, 0x4b, 0x1, 0xf3, 0xe4, 0xdd, 0xb4, 0x83, 0x59, 0x3d, 0x25, 0xf0, 0x0, 0x38, 0x66, 0x98, 0xf5, 0xad, 0xe7, 0xfa, 0xad, 0xe9, 0x61, 0x5f, 0xdc, 0x50, 0xd3, 0x27, 0x85, 0xea, 0x51, 0xd4, 0x98, 0x94, 0xe4, 0x5b, 0xaa, 0x3d, 0xc7, 0x7, 0xe2, 0x24, 0x68, 0x8c, 0x64, 0x8, 0xb6, 0x8b, 0x11},
+               output224: []byte{0x5a, 0x8a, 0xc7, 0x53, 0x3e, 0x13, 0x54, 0x6, 0x8b, 0x56, 0x4c, 0xcd, 0x21, 0x4e, 0xb2, 0xa2, 0xe0, 0x97, 0xdd, 0x60, 0xe0, 0x8b, 0xd6, 0x9f, 0xc7, 0x82, 0xb0, 0xaf},
+               output256: []byte{0x7e, 0x73, 0x8e, 0x8e, 0xb3, 0xd4, 0x7d, 0x18, 0xe9, 0x7d, 0x87, 0xc7, 0xb3, 0xfc, 0x68, 0x1f, 0x86, 0x41, 0x78, 0x83, 0xce, 0xd9, 0x2b, 0xa9, 0x3c, 0x30, 0x77, 0x81, 0x2b, 0xbd, 0x17, 0xe7},
+               output384: []byte{0x80, 0x76, 0x3f, 0xb5, 0x46, 0x88, 0xf1, 0x22, 0x26, 0x94, 0x30, 0x98, 0xa, 0xa3, 0xab, 0xe0, 0x90, 0x91, 0x2, 0xb, 0x8c, 0xfa, 0x6b, 0xde, 0xe, 0xdc, 0x2c, 0x63, 0xae, 0xd8, 0xb8, 0xba, 0x9, 0x7c, 0xdb, 0x79, 0xb8, 0xfc, 0x7f, 0x51, 0x17, 0x50, 0x8f, 0xca, 0x48, 0x64, 0xa1, 0x4d},
+               output512: []byte{0x13, 0x13, 0x2, 0x3b, 0x75, 0x3e, 0xd1, 0x72, 0x7f, 0x13, 0xcc, 0x67, 0xa6, 0x4b, 0x98, 0x9a, 0x8b, 0xf6, 0x54, 0x83, 0x24, 0xdf, 0x98, 0x54, 0xd8, 0xd5, 0xa9, 0x63, 0xed, 0x3d, 0x86, 0x2, 0x57, 0xfe, 0x65, 0x22, 0xb9, 0xc6, 0xd6, 0xcb, 0x1b, 0xca, 0xdf, 0x32, 0x2c, 0x98, 0x56, 0x1, 0xba, 0x36, 0xf7, 0xe6, 0x71, 0x10, 0x19, 0x20, 0x94, 0xaa, 0x8f, 0x98, 0x69, 0xa4, 0x58, 0xa8}},
+       testcase{
+               msg:       []byte{0x68, 0xc8, 0xf8, 0x84, 0x9b, 0x12, 0xe, 0x6e, 0xc, 0x99, 0x69, 0xa5, 0x86, 0x6a, 0xf5, 0x91, 0xa8, 0x29, 0xb9, 0x2f, 0x33, 0xcd, 0x9a, 0x4a, 0x31, 0x96, 0x95, 0x7a, 0x14, 0x8c, 0x49, 0x13, 0x8e, 0x1e, 0x2f, 0x5c, 0x76, 0x19, 0xa6, 0xd5, 0xed, 0xeb, 0xe9, 0x95, 0xac, 0xd8, 0x1e, 0xc8, 0xbb, 0x9c, 0x7b, 0x9c, 0xfc, 0xa6, 0x78, 0xd0, 0x81, 0xea, 0x9e, 0x25, 0xa7, 0x5d, 0x39, 0xdb, 0x4, 0xe1, 0x8d, 0x47, 0x59, 0x20, 0xce, 0x82, 0x8b, 0x94, 0xe7, 0x22, 0x41, 0xf2, 0x4d, 0xb7, 0x25, 0x46, 0xb3, 0x52, 0xa0, 0xe4},
+               output224: []byte{0x5, 0x9f, 0x7e, 0xb9, 0x83, 0x36, 0x2f, 0xd4, 0x4e, 0x94, 0xe2, 0xbf, 0xd5, 0x9c, 0xce, 0xd4, 0x3c, 0xae, 0x95, 0x9c, 0x9a, 0x48, 0x3e, 0xbd, 0x5e, 0x6e, 0x20, 0x36},
+               output256: []byte{0xa2, 0x78, 0xba, 0x93, 0xba, 0xd, 0x7c, 0xd2, 0x67, 0x7b, 0xe0, 0x8c, 0x9d, 0xfc, 0x5f, 0x51, 0x6a, 0x37, 0xf7, 0x22, 0xbb, 0x6, 0x56, 0x5f, 0xa2, 0x25, 0x0, 0xf6, 0x6f, 0xe0, 0x31, 0xa9},
+               output384: []byte{0x80, 0x44, 0x75, 0x83, 0x26, 0x2d, 0xed, 0x3, 0x7d, 0xa8, 0x8f, 0x3b, 0x98, 0x69, 0x8b, 0xd8, 0xf7, 0xae, 0xd7, 0xd9, 0xbf, 0x4d, 0x99, 0xf8, 0x13, 0x2e, 0xc3, 0xe7, 0xd1, 0x6b, 0xb8, 0x44, 0xad, 0xad, 0x18, 0x87, 0x57, 0xce, 0xb3, 0x2b, 0x35, 0x9c, 0x56, 0xe5, 0x0, 0x7e, 0xa3, 0xe4},
+               output512: []byte{0x9b, 0xca, 0x2a, 0x1a, 0x55, 0x46, 0xa1, 0x12, 0x75, 0xbf, 0x42, 0xf0, 0xb4, 0x84, 0x92, 0x86, 0x83, 0x59, 0xc7, 0x8d, 0x94, 0x78, 0x5a, 0xe, 0xe1, 0x2d, 0xc1, 0xc3, 0xd7, 0xa, 0x8e, 0x97, 0xeb, 0x46, 0x21, 0x48, 0xfa, 0xed, 0x1f, 0xfa, 0x4d, 0xab, 0xe, 0x91, 0x51, 0x9b, 0xd3, 0x6c, 0xc, 0x5c, 0x5f, 0xe7, 0xcf, 0xcf, 0xf3, 0xe1, 0x80, 0x68, 0x3, 0x18, 0xe1, 0xfc, 0xf7, 0x5b}},
+       testcase{
+               msg:       []byte{0xb8, 0xd5, 0x64, 0x72, 0x95, 0x4e, 0x31, 0xfb, 0x54, 0xe2, 0x8f, 0xca, 0x74, 0x3f, 0x84, 0xd8, 0xdc, 0x34, 0x89, 0x1c, 0xb5, 0x64, 0xc6, 0x4b, 0x8, 0xf7, 0xb7, 0x16, 0x36, 0xde, 0xbd, 0x64, 0xca, 0x1e, 0xdb, 0xdb, 0xa7, 0xfc, 0x5c, 0x3e, 0x40, 0x4, 0x9c, 0xe9, 0x82, 0xbb, 0xa8, 0xc7, 0xe0, 0x70, 0x30, 0x34, 0xe3, 0x31, 0x38, 0x46, 0x95, 0xe9, 0xde, 0x76, 0xb5, 0x10, 0x4f, 0x2f, 0xbc, 0x45, 0x35, 0xec, 0xbe, 0xeb, 0xc3, 0x3b, 0xc2, 0x7f, 0x29, 0xf1, 0x8f, 0x6f, 0x27, 0xe8, 0x2, 0x3b, 0xf, 0xbb, 0x6f, 0x56, 0x3c},
+               output224: []byte{0x22, 0xd6, 0x2a, 0xd2, 0x72, 0xfe, 0xfc, 0x89, 0xf7, 0x32, 0x56, 0xea, 0xac, 0xe0, 0xc, 0x7b, 0x8e, 0x99, 0x8f, 0xb3, 0x22, 0xc8, 0xeb, 0x67, 0xdc, 0x1e, 0xac, 0x6a},
+               output256: []byte{0x9c, 0xa, 0x9f, 0xd, 0xa1, 0x13, 0xd3, 0x9f, 0x49, 0x1b, 0x7d, 0xa6, 0xc4, 0xda, 0x5d, 0x84, 0xfe, 0x1c, 0xc4, 0x63, 0x67, 0xe5, 0xac, 0xc4, 0x33, 0xca, 0x3e, 0x5, 0x0, 0x95, 0x17, 0x38},
+               output384: []byte{0xe5, 0xfb, 0x4a, 0xe5, 0xdd, 0xfb, 0x4c, 0xe8, 0x22, 0x1d, 0xf4, 0xbe, 0x70, 0x24, 0xb, 0x76, 0x85, 0x1e, 0x55, 0xfa, 0xe8, 0x6b, 0xaf, 0x35, 0xba, 0xd9, 0xe7, 0x17, 0x9e, 0x24, 0xc9, 0x5d, 0xa6, 0xf0, 0xf0, 0x69, 0x5a, 0x8a, 0x52, 0x91, 0xa2, 0x39, 0x4b, 0x92, 0xa6, 0xff, 0x7b, 0x7c},
+               output512: []byte{0x84, 0x92, 0xf5, 0xe6, 0x21, 0xe8, 0x2f, 0xdb, 0xff, 0x19, 0x76, 0xb1, 0xbe, 0xec, 0xff, 0x7d, 0x13, 0x78, 0x5, 0xb5, 0x73, 0x6a, 0xb4, 0x92, 0x16, 0x12, 0x2a, 0x95, 0x39, 0x6b, 0x86, 0x3a, 0x4, 0x81, 0x21, 0x2b, 0x6d, 0xab, 0xa8, 0xb0, 0x5e, 0x29, 0xe2, 0x87, 0xbb, 0xe, 0x2f, 0x58, 0x8f, 0x86, 0x40, 0x7c, 0x84, 0xdb, 0xfb, 0x89, 0x4e, 0x6a, 0xcf, 0xc6, 0xf6, 0xb2, 0xe5, 0x71}},
+       testcase{
+               msg:       []byte{0xd, 0x58, 0xac, 0x66, 0x5f, 0xa8, 0x43, 0x42, 0xe6, 0xc, 0xef, 0xee, 0x31, 0xb1, 0xa4, 0xea, 0xcd, 0xb0, 0x92, 0xf1, 0x22, 0xdf, 0xc6, 0x83, 0x9, 0x7, 0x7a, 0xed, 0x1f, 0x3e, 0x52, 0x8f, 0x57, 0x88, 0x59, 0xee, 0x9e, 0x4c, 0xef, 0xb4, 0xa7, 0x28, 0xe9, 0x46, 0x32, 0x49, 0x27, 0xb6, 0x75, 0xcd, 0x4f, 0x4a, 0xc8, 0x4f, 0x64, 0xdb, 0x3d, 0xac, 0xfe, 0x85, 0xc, 0x1d, 0xd1, 0x87, 0x44, 0xc7, 0x4c, 0xec, 0xcd, 0x9f, 0xe4, 0xdc, 0x21, 0x40, 0x85, 0x10, 0x8f, 0x40, 0x4e, 0xab, 0x6d, 0x8f, 0x45, 0x2b, 0x54, 0x42, 0xa4, 0x7d},
+               output224: []byte{0xa3, 0x96, 0xea, 0x90, 0x5e, 0xb6, 0x12, 0x55, 0x4b, 0xd0, 0xe, 0x4f, 0xc1, 0xbb, 0x4c, 0x52, 0x47, 0xd7, 0x3f, 0xde, 0x4b, 0xba, 0xf5, 0x38, 0xe, 0xd4, 0x2d, 0xd0},
+               output256: []byte{0x6b, 0xed, 0x49, 0x6d, 0x2, 0xfe, 0x4c, 0xc2, 0x7d, 0x96, 0xdc, 0xee, 0xd1, 0x4a, 0x67, 0xda, 0x7b, 0xdf, 0x75, 0xe1, 0x9b, 0x62, 0x48, 0x96, 0xdf, 0xf6, 0xb0, 0xb6, 0x8e, 0x4f, 0xcc, 0x12},
+               output384: []byte{0xce, 0x6b, 0x7, 0xc0, 0xc7, 0xda, 0x2f, 0xa1, 0xe6, 0xca, 0x5, 0xde, 0x6, 0x52, 0xfc, 0x9f, 0x1f, 0x45, 0x2f, 0xc2, 0x61, 0xe7, 0x3e, 0x52, 0x45, 0x7c, 0x72, 0xbf, 0xd, 0x51, 0xba, 0xc7, 0xd6, 0x61, 0x60, 0xcf, 0xf1, 0x6d, 0x6a, 0x3, 0x52, 0x79, 0x82, 0xe7, 0xd4, 0x39, 0x35, 0x7},
+               output512: []byte{0xee, 0xbe, 0x4e, 0xc0, 0xfe, 0x3e, 0x2, 0x66, 0x52, 0x7f, 0x4d, 0x9f, 0x57, 0xa0, 0x17, 0x63, 0x7e, 0xab, 0x92, 0x37, 0x7d, 0x82, 0xb1, 0x58, 0x56, 0xa5, 0x5a, 0x22, 0xb0, 0x8, 0xdf, 0x67, 0xf2, 0x7a, 0xa5, 0xac, 0x4, 0xe1, 0xde, 0xee, 0xb2, 0xc8, 0x19, 0xce, 0x41, 0xdb, 0x7, 0xdb, 0xf6, 0xdc, 0xaf, 0x17, 0xa1, 0x92, 0xa4, 0x37, 0x1a, 0x1e, 0x92, 0xba, 0xdf, 0x1e, 0x63, 0x89}},
+       testcase{
+               msg:       []byte{0x17, 0x55, 0xe2, 0xd2, 0xe5, 0xd1, 0xc1, 0xb0, 0x15, 0x64, 0x56, 0xb5, 0x39, 0x75, 0x3f, 0xf4, 0x16, 0x65, 0x1d, 0x44, 0x69, 0x8e, 0x87, 0x0, 0x2d, 0xcf, 0x61, 0xdc, 0xfa, 0x2b, 0x4e, 0x72, 0xf2, 0x64, 0xd9, 0xad, 0x59, 0x1d, 0xf1, 0xfd, 0xee, 0x7b, 0x41, 0xb2, 0xeb, 0x0, 0x28, 0x3c, 0x5a, 0xeb, 0xb3, 0x41, 0x13, 0x23, 0xb6, 0x72, 0xea, 0xa1, 0x45, 0xc5, 0x12, 0x51, 0x85, 0x10, 0x4f, 0x20, 0xf3, 0x35, 0x80, 0x4b, 0x2, 0x32, 0x5b, 0x6d, 0xea, 0x65, 0x60, 0x3f, 0x34, 0x9f, 0x4d, 0x5d, 0x8b, 0x78, 0x2d, 0xd3, 0x46, 0x9c, 0xcd},
+               output224: []byte{0xd8, 0xb5, 0xb2, 0x4b, 0x9e, 0x92, 0x32, 0x6f, 0xde, 0x5d, 0xb1, 0x5, 0x8e, 0xed, 0xbe, 0xed, 0xb0, 0xb6, 0x59, 0x82, 0x92, 0x57, 0x34, 0xb6, 0xe2, 0x84, 0x40, 0x36},
+               output256: []byte{0xec, 0xd2, 0xe3, 0xfa, 0xf4, 0xba, 0x4d, 0xd6, 0x7e, 0x5a, 0x86, 0x56, 0xce, 0xbe, 0xbd, 0xb2, 0x46, 0x11, 0x61, 0x16, 0x78, 0xe9, 0x2e, 0xb6, 0xf, 0x7c, 0xbd, 0x31, 0x11, 0xd0, 0xa3, 0x45},
+               output384: []byte{0xfa, 0x76, 0xe0, 0x5f, 0x8d, 0x28, 0x32, 0xda, 0xdf, 0xeb, 0xa0, 0x10, 0x7a, 0x31, 0x37, 0xb7, 0xb9, 0xd4, 0xd1, 0x9a, 0x77, 0xa1, 0xe7, 0x8f, 0x8b, 0xbf, 0xec, 0xda, 0x7e, 0xf4, 0x64, 0x14, 0xc3, 0x63, 0x45, 0x3e, 0x8c, 0x49, 0x2, 0xc3, 0x2, 0xa4, 0xe1, 0x8c, 0xea, 0x4b, 0xa1, 0x57},
+               output512: []byte{0x9e, 0x36, 0xe6, 0x29, 0x1b, 0xc2, 0x29, 0x6c, 0xb4, 0xba, 0x71, 0x10, 0x9c, 0xed, 0xcc, 0x2a, 0x3f, 0xb, 0x4f, 0x1a, 0xe5, 0xe5, 0x40, 0x6d, 0xc4, 0xb3, 0xe5, 0x94, 0x55, 0x1d, 0x5c, 0x70, 0xe6, 0xf8, 0x14, 0xd2, 0xc9, 0xb8, 0x41, 0x31, 0x3, 0xef, 0x7, 0x53, 0x58, 0x86, 0xb4, 0xac, 0x51, 0x8a, 0xaf, 0x7a, 0xed, 0x64, 0xab, 0xed, 0x7a, 0x5b, 0xa, 0x26, 0xf7, 0x17, 0x14, 0x25}},
+       testcase{
+               msg:       []byte{0xb1, 0x80, 0xde, 0x1a, 0x61, 0x11, 0x11, 0xee, 0x75, 0x84, 0xba, 0x2c, 0x4b, 0x2, 0x5, 0x98, 0xcd, 0x57, 0x4a, 0xc7, 0x7e, 0x40, 0x4e, 0x85, 0x3d, 0x15, 0xa1, 0x1, 0xc6, 0xf5, 0xa2, 0xe5, 0xc8, 0x1, 0xd7, 0xd8, 0x5d, 0xc9, 0x52, 0x86, 0xa1, 0x80, 0x4c, 0x87, 0xb, 0xb9, 0xf0, 0xf, 0xd4, 0xdc, 0xb0, 0x3a, 0xa8, 0x32, 0x82, 0x75, 0x15, 0x88, 0x19, 0xdc, 0xad, 0x72, 0x53, 0xf3, 0xe3, 0xd2, 0x37, 0xae, 0xaa, 0x79, 0x79, 0x26, 0x8a, 0x5d, 0xb1, 0xc6, 0xce, 0x8, 0xa9, 0xec, 0x7c, 0x25, 0x79, 0x78, 0x3c, 0x8a, 0xfc, 0x1f, 0x91, 0xa7},
+               output224: []byte{0xfd, 0xb9, 0x1, 0x5b, 0x20, 0xdb, 0x44, 0x6f, 0x79, 0x57, 0x5e, 0x6b, 0x8c, 0x73, 0xa9, 0x8e, 0xac, 0x73, 0x1c, 0xfe, 0x2e, 0x59, 0xbd, 0x46, 0xdb, 0xda, 0xe, 0x35},
+               output256: []byte{0x63, 0x4a, 0x95, 0xa7, 0xe8, 0xba, 0x58, 0xf7, 0x81, 0x8a, 0x13, 0x90, 0x3e, 0xc8, 0xf3, 0x41, 0x1b, 0x6e, 0xcb, 0x7e, 0x38, 0x9e, 0xc9, 0xaa, 0x97, 0xc0, 0xec, 0xf8, 0x7f, 0xad, 0xd5, 0x88},
+               output384: []byte{0x1b, 0x43, 0xb7, 0xb, 0x6b, 0xbb, 0xc7, 0x68, 0xc1, 0xf4, 0xb3, 0xce, 0x24, 0x16, 0x67, 0xad, 0xb5, 0x24, 0x6d, 0x29, 0x98, 0x17, 0x23, 0x84, 0x61, 0x68, 0xd2, 0x23, 0x4e, 0x19, 0xa5, 0x13, 0xb, 0x1f, 0x57, 0x6b, 0x49, 0x74, 0xc6, 0x13, 0x63, 0x9a, 0x44, 0x9e, 0x61, 0xb2, 0xca, 0x79},
+               output512: []byte{0xf1, 0x8, 0x94, 0x83, 0xa0, 0xb, 0x26, 0x1, 0xbe, 0x9c, 0x16, 0x46, 0x9a, 0x9, 0xe, 0xfc, 0x49, 0xfc, 0xb7, 0xe, 0x62, 0xac, 0xf, 0xfe, 0xa2, 0xd1, 0xe5, 0x8, 0x8, 0x3c, 0xd5, 0xd4, 0x1d, 0xcf, 0x2d, 0xaa, 0xe1, 0xe0, 0xea, 0xc2, 0x17, 0x85, 0x9e, 0x5f, 0xea, 0xdd, 0xcb, 0x78, 0x2a, 0xc4, 0x71, 0xc0, 0x1d, 0x72, 0x66, 0x13, 0x61, 0x85, 0xd3, 0x7b, 0x56, 0x8e, 0x96, 0x6}},
+       testcase{
+               msg:       []byte{0xcf, 0x35, 0x83, 0xcb, 0xdf, 0xd4, 0xcb, 0xc1, 0x70, 0x63, 0xb1, 0xe7, 0xd9, 0xb, 0x2, 0xf0, 0xe6, 0xe2, 0xee, 0x5, 0xf9, 0x9d, 0x77, 0xe2, 0x4e, 0x56, 0x3, 0x92, 0x53, 0x5e, 0x47, 0xe0, 0x50, 0x77, 0x15, 0x7f, 0x96, 0x81, 0x35, 0x44, 0xa1, 0x70, 0x46, 0x91, 0x4f, 0x9e, 0xfb, 0x64, 0x76, 0x2a, 0x23, 0xcf, 0x7a, 0x49, 0xfe, 0x52, 0xa0, 0xa4, 0xc0, 0x1c, 0x63, 0xc, 0xfe, 0x87, 0x27, 0xb8, 0x1f, 0xb9, 0x9a, 0x89, 0xff, 0x7c, 0xc1, 0x1d, 0xca, 0x51, 0x73, 0x5, 0x7e, 0x4, 0x17, 0xb8, 0xfe, 0x7a, 0x9e, 0xfb, 0xa6, 0xd9, 0x5c, 0x55, 0x5f},
+               output224: []byte{0xdf, 0x1b, 0x47, 0xe7, 0x3e, 0x8c, 0xbd, 0x2c, 0xa8, 0x52, 0xcf, 0x58, 0xad, 0x68, 0xb5, 0xf8, 0xba, 0xa1, 0x16, 0x9c, 0x7, 0x95, 0x96, 0x10, 0x41, 0xe8, 0xa9, 0x18},
+               output256: []byte{0xa0, 0xfe, 0x35, 0x2b, 0xa2, 0x38, 0x9b, 0x4, 0x30, 0xed, 0xbe, 0x12, 0x1, 0x3, 0x2e, 0xb0, 0x9c, 0x25, 0x55, 0x14, 0xc5, 0xc5, 0xb5, 0x29, 0xc4, 0xba, 0xaf, 0xce, 0xb1, 0xac, 0x98, 0x17},
+               output384: []byte{0x93, 0x82, 0x52, 0x39, 0x3a, 0x53, 0x2d, 0x9e, 0x1f, 0x91, 0xd5, 0xc2, 0x22, 0xe2, 0xdf, 0x2c, 0xc7, 0xae, 0x10, 0x27, 0x5, 0xbf, 0xb8, 0x3f, 0xe3, 0xd, 0xca, 0xeb, 0xce, 0xa8, 0x2b, 0xff, 0x9b, 0xda, 0x7c, 0xa6, 0x70, 0x95, 0x43, 0x98, 0x59, 0x14, 0x66, 0x32, 0x49, 0x4d, 0x3c, 0xe4},
+               output512: []byte{0xd0, 0x63, 0xea, 0x79, 0x4c, 0xfd, 0x2e, 0xd9, 0x24, 0x86, 0x65, 0xa6, 0x8, 0x4a, 0x7b, 0x99, 0x5, 0x1c, 0x10, 0x51, 0xe4, 0x1b, 0x7d, 0x9d, 0xcb, 0x15, 0x37, 0xa1, 0xc7, 0x9c, 0xba, 0x6d, 0xeb, 0x4d, 0x84, 0x4c, 0x6a, 0x61, 0x8e, 0x43, 0xc7, 0xca, 0x2, 0xd, 0x16, 0x97, 0x69, 0x99, 0x68, 0x4f, 0xeb, 0x8, 0x46, 0x16, 0xf7, 0x7, 0x20, 0x9f, 0x75, 0xc4, 0xbd, 0x58, 0x4d, 0x86}},
+       testcase{
+               msg:       []byte{0x7, 0x2f, 0xc0, 0x23, 0x40, 0xef, 0x99, 0x11, 0x5b, 0xad, 0x72, 0xf9, 0x2c, 0x1, 0xe4, 0xc0, 0x93, 0xb9, 0x59, 0x9f, 0x6c, 0xfc, 0x45, 0xcb, 0x38, 0xe, 0xe6, 0x86, 0xcb, 0x5e, 0xb0, 0x19, 0xe8, 0x6, 0xab, 0x9b, 0xd5, 0x5e, 0x63, 0x4a, 0xb1, 0xa, 0xa6, 0x2a, 0x95, 0x10, 0xcc, 0x6, 0x72, 0xcd, 0x3e, 0xdd, 0xb5, 0x89, 0xc7, 0xdf, 0x2b, 0x67, 0xfc, 0xd3, 0x32, 0x9f, 0x61, 0xb1, 0xa4, 0x44, 0x1e, 0xca, 0x87, 0xa3, 0x3c, 0x8f, 0x55, 0xda, 0x4f, 0xbb, 0xad, 0x5c, 0xf2, 0xb2, 0x52, 0x7b, 0x8e, 0x98, 0x3b, 0xb3, 0x1a, 0x2f, 0xad, 0xec, 0x75, 0x23},
+               output224: []byte{0x1e, 0x8a, 0x90, 0x91, 0x8d, 0x6e, 0xad, 0x31, 0xe4, 0x46, 0xd4, 0xee, 0x26, 0x73, 0x87, 0x1e, 0xcc, 0x5c, 0x7d, 0xa9, 0xb1, 0x8e, 0xd5, 0x11, 0xe1, 0x63, 0x2e, 0xd},
+               output256: []byte{0x9a, 0xb, 0xfe, 0x14, 0xf9, 0xf3, 0x12, 0x7a, 0xca, 0x86, 0x77, 0x3a, 0x62, 0x9, 0x45, 0x73, 0x1d, 0xf7, 0x81, 0xa6, 0xd7, 0xdc, 0x82, 0x93, 0xc, 0xcd, 0xe2, 0xf6, 0x9d, 0xac, 0x8f, 0x94},
+               output384: []byte{0x47, 0x63, 0x3a, 0xd0, 0xc8, 0xa, 0xf2, 0x6b, 0xf7, 0x4d, 0x95, 0x98, 0xdb, 0xd5, 0xbc, 0xf7, 0x7f, 0xc6, 0xbf, 0xf1, 0xbc, 0xa0, 0x15, 0xa6, 0x11, 0xd7, 0xb8, 0x24, 0xf, 0x59, 0x7d, 0x87, 0x67, 0xfb, 0x8b, 0xb, 0xf5, 0xc3, 0x33, 0x15, 0x65, 0x80, 0xaf, 0xee, 0x12, 0x1c, 0x29, 0x9c},
+               output512: []byte{0x42, 0x4a, 0x86, 0xd7, 0x46, 0xc8, 0x7c, 0x85, 0xda, 0xbd, 0x1d, 0xae, 0x29, 0x8a, 0x48, 0x8e, 0x4c, 0xa2, 0x18, 0x3d, 0xe6, 0x92, 0xd1, 0xd0, 0x1c, 0x4b, 0x79, 0x94, 0xee, 0x51, 0x24, 0xf9, 0x0, 0x4b, 0xea, 0x84, 0x93, 0x3c, 0x31, 0x1c, 0xc3, 0x8e, 0xa6, 0xf6, 0x4, 0xa7, 0x76, 0x9e, 0xe1, 0x78, 0xe1, 0xec, 0x16, 0xa, 0x98, 0x91, 0xc4, 0x2c, 0x46, 0x2a, 0x13, 0xa6, 0x22, 0x86}},
+       testcase{
+               msg:       []byte{0x76, 0xee, 0xcf, 0x95, 0x6a, 0x52, 0x64, 0x9f, 0x87, 0x75, 0x28, 0x14, 0x6d, 0xe3, 0x3d, 0xf2, 0x49, 0xcd, 0x80, 0xe, 0x21, 0x83, 0xf, 0x65, 0xe9, 0xf, 0xf, 0x25, 0xca, 0x9d, 0x65, 0x40, 0xfd, 0xe4, 0x6, 0x3, 0x23, 0xe, 0xca, 0x67, 0x60, 0xf1, 0x13, 0x9c, 0x7f, 0x26, 0x8d, 0xeb, 0xa2, 0x6, 0x6, 0x31, 0xee, 0xa9, 0x2b, 0x1f, 0xff, 0x5, 0xf9, 0x3f, 0xd5, 0x57, 0x2f, 0xbe, 0x29, 0x57, 0x9e, 0xcd, 0x48, 0xbc, 0x3a, 0x8d, 0x6c, 0x2e, 0xb4, 0xa6, 0xb2, 0x6e, 0x38, 0xd6, 0xc5, 0xfb, 0xf2, 0xc0, 0x80, 0x44, 0xae, 0xea, 0x47, 0xa, 0x8f, 0x2f, 0x26},
+               output224: []byte{0x10, 0x60, 0xaf, 0xd1, 0xe1, 0xb9, 0xf7, 0xf4, 0x12, 0x91, 0xa4, 0x86, 0x17, 0x74, 0xb3, 0xb0, 0xc9, 0x5a, 0x81, 0x27, 0x88, 0xa4, 0x1d, 0x7e, 0xbe, 0xf4, 0xa8, 0x93},
+               output256: []byte{0x19, 0xe5, 0x10, 0x1b, 0xde, 0x60, 0xb2, 0x0, 0xa8, 0xb1, 0x71, 0xe4, 0xc3, 0xea, 0x3d, 0xfd, 0x91, 0x3e, 0x10, 0x11, 0x1d, 0x96, 0xf9, 0x68, 0x2a, 0xcc, 0x74, 0x67, 0x28, 0x2b, 0x4e, 0x31},
+               output384: []byte{0x4, 0x45, 0x63, 0x22, 0xe1, 0xbf, 0x27, 0x78, 0x5e, 0xdf, 0x3f, 0x59, 0x6d, 0xb3, 0x3e, 0x69, 0x3a, 0xad, 0xf7, 0x6d, 0x9d, 0x25, 0x93, 0x52, 0xd9, 0x7a, 0xcd, 0x56, 0x1b, 0xc4, 0x52, 0x36, 0x50, 0x6f, 0xba, 0x35, 0x30, 0x77, 0x22, 0x42, 0xcb, 0x36, 0x9a, 0x83, 0xa3, 0x8c, 0xd7, 0x49},
+               output512: []byte{0xa9, 0x40, 0x3c, 0x26, 0xa9, 0x6d, 0xe2, 0xc3, 0xd3, 0x59, 0xee, 0x29, 0xf3, 0xfd, 0x1c, 0x58, 0x11, 0x54, 0x85, 0x2d, 0x19, 0xad, 0x12, 0x88, 0x4b, 0x79, 0xe7, 0x8, 0x2d, 0x2d, 0xa2, 0x2e, 0xc8, 0x35, 0x53, 0xba, 0xba, 0x2b, 0xdf, 0xf2, 0xa2, 0xfa, 0x15, 0x94, 0x7a, 0x8e, 0x6a, 0xcd, 0x5f, 0x5d, 0x11, 0x3e, 0xc0, 0x91, 0xbf, 0xd1, 0x96, 0x2a, 0xa, 0x10, 0x40, 0x1d, 0x2c, 0x98}},
+       testcase{
+               msg:       []byte{0x7a, 0xdc, 0xb, 0x66, 0x93, 0xe6, 0x1c, 0x26, 0x9f, 0x27, 0x8e, 0x69, 0x44, 0xa5, 0xa2, 0xd8, 0x30, 0x9, 0x81, 0xe4, 0x0, 0x22, 0xf8, 0x39, 0xac, 0x64, 0x43, 0x87, 0xbf, 0xac, 0x90, 0x86, 0x65, 0x0, 0x85, 0xc2, 0xcd, 0xc5, 0x85, 0xfe, 0xa4, 0x7b, 0x9d, 0x2e, 0x52, 0xd6, 0x5a, 0x2b, 0x29, 0xa7, 0xdc, 0x37, 0x4, 0x1, 0xef, 0x5d, 0x60, 0xdd, 0xd, 0x21, 0xf9, 0xe2, 0xb9, 0xf, 0xae, 0x91, 0x93, 0x19, 0xb1, 0x4b, 0x8c, 0x55, 0x65, 0xb0, 0x42, 0x3c, 0xef, 0xb8, 0x27, 0xd5, 0xf1, 0x20, 0x33, 0x2, 0xa9, 0xd0, 0x15, 0x23, 0x49, 0x8a, 0x4d, 0xb1, 0x3, 0x74},
+               output224: []byte{0xea, 0x91, 0xed, 0xc3, 0x93, 0x49, 0x1b, 0x4c, 0xbc, 0x3, 0x5b, 0x85, 0x38, 0xdf, 0x8, 0xe3, 0xc6, 0xb8, 0xca, 0xd1, 0x83, 0x38, 0x5, 0x3c, 0x81, 0xfe, 0x2e, 0x8},
+               output256: []byte{0x4c, 0xc2, 0xaf, 0xf1, 0x41, 0x98, 0x7f, 0x4c, 0x2e, 0x68, 0x3f, 0xa2, 0xde, 0x30, 0x4, 0x2b, 0xac, 0xdc, 0xd0, 0x60, 0x87, 0xd7, 0xa7, 0xb0, 0x14, 0x99, 0x6e, 0x9c, 0xfe, 0xaa, 0x58, 0xce},
+               output384: []byte{0xf8, 0xb1, 0xf2, 0xc3, 0x17, 0xb9, 0xd1, 0x89, 0x8c, 0x30, 0x5d, 0xec, 0x3c, 0x6c, 0xa, 0xc4, 0x5c, 0xfe, 0x7f, 0x99, 0x5e, 0x94, 0x49, 0x68, 0x20, 0x6c, 0x1c, 0x1b, 0x2c, 0x92, 0xbd, 0x1d, 0x4f, 0xa3, 0x92, 0xff, 0xaa, 0x60, 0x94, 0xc6, 0xaf, 0xf9, 0x5e, 0x47, 0xdc, 0x25, 0x9e, 0xe9},
+               output512: []byte{0x3d, 0x23, 0x63, 0x2e, 0xe4, 0xc2, 0xd4, 0xf4, 0x11, 0x8a, 0x2, 0xa6, 0x77, 0xb5, 0xa3, 0x24, 0x27, 0xc7, 0x2b, 0xa5, 0x48, 0x99, 0xba, 0x2e, 0x6c, 0xcd, 0x22, 0xec, 0x3d, 0xef, 0xe0, 0xfc, 0xb0, 0x52, 0xe3, 0xf8, 0x3d, 0x35, 0x78, 0x6c, 0xea, 0x20, 0x80, 0xee, 0xd1, 0x48, 0xa0, 0xa9, 0x46, 0x28, 0xe7, 0x35, 0x20, 0x2e, 0x6b, 0x28, 0x9, 0x99, 0x4c, 0x5f, 0x5b, 0xda, 0xfd, 0xd6}},
+       testcase{
+               msg:       []byte{0xe1, 0xff, 0xfa, 0x98, 0x26, 0xcc, 0xe8, 0xb8, 0x6b, 0xcc, 0xef, 0xb8, 0x79, 0x4e, 0x48, 0xc4, 0x6c, 0xdf, 0x37, 0x20, 0x13, 0xf7, 0x82, 0xec, 0xed, 0x1e, 0x37, 0x82, 0x69, 0xb7, 0xbe, 0x2b, 0x7b, 0xf5, 0x13, 0x74, 0x9, 0x22, 0x61, 0xae, 0x12, 0xe, 0x82, 0x2b, 0xe6, 0x85, 0xf2, 0xe7, 0xa8, 0x36, 0x64, 0xbc, 0xfb, 0xe3, 0x8f, 0xe8, 0x63, 0x3f, 0x24, 0xe6, 0x33, 0xff, 0xe1, 0x98, 0x8e, 0x1b, 0xc5, 0xac, 0xf5, 0x9a, 0x58, 0x70, 0x79, 0xa5, 0x7a, 0x91, 0xb, 0xda, 0x60, 0x6, 0xe, 0x85, 0xb5, 0xf5, 0xb6, 0xf7, 0x76, 0xf0, 0x52, 0x96, 0x39, 0xd9, 0xcc, 0xe4, 0xbd},
+               output224: []byte{0xdf, 0x1a, 0xf1, 0x49, 0xe5, 0xc9, 0x2c, 0xb2, 0x91, 0x74, 0xc1, 0xed, 0xb6, 0xed, 0x89, 0x1e, 0xbc, 0xe4, 0x36, 0x60, 0x10, 0xdc, 0x7c, 0xbf, 0xc9, 0xb1, 0xd7, 0x57},
+               output256: []byte{0x9a, 0x8c, 0xe8, 0x19, 0x89, 0x4e, 0xfc, 0xcc, 0x21, 0x53, 0xb2, 0x39, 0xc3, 0xad, 0xc3, 0xf0, 0x7d, 0x9, 0x68, 0xea, 0xc5, 0xec, 0x80, 0x80, 0xac, 0x1, 0x74, 0xf2, 0xd5, 0xe6, 0x95, 0x9c},
+               output384: []byte{0x4f, 0x43, 0x91, 0x97, 0xc6, 0x64, 0x39, 0xba, 0xf6, 0x56, 0x18, 0xf8, 0x26, 0xe2, 0x99, 0xa3, 0x29, 0x38, 0xb, 0x55, 0x8a, 0x52, 0xb0, 0x71, 0x11, 0x82, 0x58, 0xb, 0xdb, 0xad, 0xba, 0xbb, 0x13, 0xad, 0x66, 0xd6, 0xf, 0xad, 0xdb, 0x9d, 0xed, 0x22, 0x6f, 0xb, 0x40, 0x1a, 0xa8, 0xbe},
+               output512: []byte{0xd8, 0xfa, 0x88, 0x68, 0x84, 0xce, 0x57, 0x7a, 0x72, 0x82, 0xde, 0xce, 0xac, 0xf4, 0x78, 0x6e, 0x7c, 0x68, 0xfc, 0x69, 0xb1, 0x41, 0x13, 0x7f, 0xf5, 0xdc, 0x7c, 0xb3, 0xc5, 0xf8, 0xab, 0xc8, 0x45, 0x71, 0x6d, 0xd2, 0x73, 0x97, 0xe8, 0xbd, 0x5c, 0xe2, 0x45, 0x10, 0x7a, 0x98, 0x4a, 0x3f, 0x8b, 0x21, 0xf1, 0x9f, 0x99, 0xed, 0x40, 0x11, 0x86, 0x21, 0xdc, 0x85, 0x30, 0x3a, 0x30, 0xb4}},
+       testcase{
+               msg:       []byte{0x69, 0xf9, 0xab, 0xba, 0x65, 0x59, 0x2e, 0xe0, 0x1d, 0xb4, 0xdc, 0xe5, 0x2d, 0xba, 0xb9, 0xb, 0x8, 0xfc, 0x4, 0x19, 0x36, 0x2, 0x79, 0x2e, 0xe4, 0xda, 0xa2, 0x63, 0x3, 0x3d, 0x59, 0x8, 0x15, 0x87, 0xb0, 0x9b, 0xbe, 0x49, 0xd0, 0xb4, 0x9c, 0x98, 0x25, 0xd2, 0x28, 0x40, 0xb2, 0xff, 0x5d, 0x9c, 0x51, 0x55, 0xf9, 0x75, 0xf8, 0xf2, 0xc2, 0xe7, 0xa9, 0xc, 0x75, 0xd2, 0xe4, 0xa8, 0x4, 0xf, 0xe3, 0x9f, 0x63, 0xbb, 0xaf, 0xb4, 0x3, 0xd9, 0xe2, 0x8c, 0xc3, 0xb8, 0x6e, 0x4, 0xe3, 0x94, 0xa9, 0xc9, 0xe8, 0x6, 0x5b, 0xd3, 0xc8, 0x5f, 0xa9, 0xf0, 0xc7, 0x89, 0x16, 0x0},
+               output224: []byte{0x5f, 0x69, 0x84, 0x8, 0xbf, 0xf0, 0x24, 0x6b, 0x5, 0xba, 0xd9, 0x6c, 0xb3, 0x42, 0xb2, 0xfd, 0x2f, 0x11, 0xb6, 0x80, 0x4e, 0xf2, 0xfa, 0x7, 0xa8, 0x1b, 0x9, 0x20},
+               output256: []byte{0x8b, 0x35, 0x76, 0x85, 0x25, 0xf5, 0x9a, 0xc7, 0x7d, 0x35, 0x52, 0x2a, 0xc8, 0x85, 0x83, 0x1a, 0x99, 0x47, 0x29, 0x9e, 0x11, 0x4a, 0x89, 0x56, 0xfe, 0x5b, 0xca, 0x10, 0x3d, 0xb7, 0xbb, 0x2c},
+               output384: []byte{0x1c, 0x8b, 0x99, 0xbf, 0x6a, 0x3e, 0x80, 0xf0, 0xb8, 0xc6, 0x7f, 0xa9, 0xbb, 0xf0, 0x7d, 0x19, 0xc1, 0x5d, 0x48, 0x4c, 0xde, 0x38, 0xf8, 0xfa, 0xad, 0xb7, 0x48, 0xae, 0x2, 0x4a, 0x2, 0xe2, 0x9f, 0xd2, 0xd7, 0xbd, 0xce, 0x66, 0xd4, 0x6c, 0x1a, 0x52, 0x39, 0xd7, 0x45, 0x3f, 0xd3, 0xe3},
+               output512: []byte{0xc7, 0x68, 0xcd, 0x31, 0x36, 0x2, 0xfa, 0xbb, 0x21, 0x93, 0xf9, 0xed, 0xbf, 0x66, 0x7b, 0x4c, 0xda, 0xbd, 0x57, 0xd5, 0xff, 0x60, 0xbd, 0xc2, 0x2b, 0xa7, 0xba, 0xd5, 0x31, 0x9e, 0xa0, 0x4e, 0x7c, 0xbe, 0xc5, 0xd4, 0xb4, 0xc4, 0x56, 0xa, 0xd5, 0x26, 0x9, 0xfd, 0xd2, 0x27, 0x50, 0xb6, 0x18, 0x95, 0x17, 0x96, 0x37, 0x6e, 0xd4, 0x1b, 0x2a, 0x8e, 0xaf, 0xfd, 0xd9, 0x92, 0x77, 0x22}},
+       testcase{
+               msg:       []byte{0x38, 0xa1, 0xa, 0x35, 0x2c, 0xa5, 0xae, 0xdf, 0xa8, 0xe1, 0x9c, 0x64, 0x78, 0x7d, 0x8e, 0x9c, 0x3a, 0x75, 0xdb, 0xf3, 0xb8, 0x67, 0x4b, 0xfa, 0xb2, 0x9b, 0x5d, 0xbf, 0xc1, 0x5a, 0x63, 0xd1, 0xf, 0xae, 0x66, 0xcd, 0x1a, 0x6e, 0x6d, 0x24, 0x52, 0xd5, 0x57, 0x96, 0x7e, 0xaa, 0xd8, 0x9a, 0x4c, 0x98, 0x44, 0x97, 0x87, 0xb0, 0xb3, 0x16, 0x4c, 0xa5, 0xb7, 0x17, 0xa9, 0x3f, 0x24, 0xeb, 0xb, 0x50, 0x6c, 0xeb, 0x70, 0xcb, 0xbc, 0xb8, 0xd7, 0x2b, 0x2a, 0x72, 0x99, 0x3f, 0x90, 0x9a, 0xad, 0x92, 0xf0, 0x44, 0xe0, 0xb5, 0xa2, 0xc9, 0xac, 0x9c, 0xb1, 0x6a, 0xc, 0xa2, 0xf8, 0x1f, 0x49},
+               output224: []byte{0xeb, 0xe6, 0xd6, 0x1e, 0x8a, 0x94, 0x6e, 0xd, 0x45, 0xd3, 0x88, 0x9f, 0x9e, 0x36, 0xa, 0xcd, 0x3a, 0x1a, 0x7d, 0x6c, 0x4b, 0x13, 0x7, 0x44, 0x8e, 0x6e, 0x73, 0x57},
+               output256: []byte{0x95, 0x5f, 0x1f, 0x7e, 0x4e, 0x54, 0x66, 0xb, 0x26, 0xf3, 0x0, 0x86, 0xf2, 0xdd, 0xda, 0xed, 0xd3, 0x28, 0x13, 0x54, 0x7c, 0x1b, 0x95, 0xd3, 0x5, 0xd8, 0x82, 0x68, 0x2b, 0x4f, 0xf7, 0xa0},
+               output384: []byte{0x46, 0xf8, 0x7b, 0xc0, 0x78, 0x49, 0xe9, 0x51, 0x4, 0xe6, 0x7c, 0xc3, 0xdc, 0x71, 0xbd, 0xc1, 0x9, 0xc1, 0x10, 0x2b, 0xfb, 0x1a, 0xcd, 0xfe, 0x2f, 0x6a, 0x23, 0x17, 0x3b, 0x52, 0xbf, 0x83, 0x6c, 0xe0, 0xc, 0xd7, 0xa5, 0xa5, 0xff, 0xe7, 0xd3, 0xbb, 0x8f, 0xab, 0x33, 0xde, 0xce, 0xdf},
+               output512: []byte{0x85, 0x62, 0xce, 0x93, 0x99, 0x80, 0x66, 0x23, 0xb2, 0x69, 0x57, 0x12, 0x26, 0x6a, 0xf3, 0xd4, 0xc1, 0x4f, 0x77, 0xd2, 0x44, 0x91, 0x43, 0x37, 0x92, 0x46, 0x96, 0x2c, 0x22, 0x39, 0x8c, 0x81, 0x35, 0x44, 0xa7, 0xde, 0xe4, 0xc4, 0x84, 0x7f, 0x9, 0xd3, 0xcb, 0xe4, 0x37, 0x34, 0x9b, 0x7f, 0xc6, 0x73, 0x8a, 0xc9, 0x70, 0x75, 0xb5, 0xdd, 0x9e, 0x2a, 0xdd, 0x6e, 0xca, 0xa6, 0x10, 0xf4}},
+       testcase{
+               msg:       []byte{0x6d, 0x8c, 0x6e, 0x44, 0x9b, 0xc1, 0x36, 0x34, 0xf1, 0x15, 0x74, 0x9c, 0x24, 0x8c, 0x17, 0xcd, 0x14, 0x8b, 0x72, 0x15, 0x7a, 0x2c, 0x37, 0xbf, 0x89, 0x69, 0xea, 0x83, 0xb4, 0xd6, 0xba, 0x8c, 0xe, 0xe2, 0x71, 0x1c, 0x28, 0xee, 0x11, 0x49, 0x5f, 0x43, 0x4, 0x95, 0x96, 0x52, 0xc, 0xe4, 0x36, 0x0, 0x4b, 0x2, 0x6b, 0x6c, 0x1f, 0x72, 0x92, 0xb9, 0xc4, 0x36, 0xb0, 0x55, 0xcb, 0xb7, 0x2d, 0x53, 0xd, 0x86, 0xd, 0x12, 0x76, 0xa1, 0x50, 0x2a, 0x51, 0x40, 0xe3, 0xc3, 0xf5, 0x4a, 0x93, 0x66, 0x3e, 0x4d, 0x20, 0xed, 0xec, 0x32, 0xd2, 0x84, 0xe2, 0x55, 0x64, 0xf6, 0x24, 0x95, 0x5b, 0x52},
+               output224: []byte{0x1b, 0x7f, 0x6b, 0xcb, 0x22, 0x71, 0xac, 0x9c, 0x3b, 0x55, 0x8e, 0x95, 0xf8, 0x52, 0x85, 0xee, 0x75, 0x6b, 0x3, 0xb7, 0x67, 0xa0, 0x1a, 0xc5, 0x7d, 0x7c, 0x6e, 0x94},
+               output256: []byte{0x8f, 0xac, 0x5a, 0x34, 0xeb, 0xaf, 0xa3, 0x8b, 0x55, 0x33, 0x36, 0x24, 0xa9, 0x51, 0x4f, 0xe9, 0x7d, 0x99, 0x56, 0xe7, 0x43, 0x9, 0xc5, 0x25, 0x2c, 0xd2, 0x9, 0xd, 0x3b, 0xbe, 0x2f, 0x9e},
+               output384: []byte{0xfa, 0x12, 0xb9, 0xd0, 0x70, 0xf6, 0x97, 0xfd, 0x53, 0x91, 0xf3, 0xfc, 0x9c, 0x44, 0x5, 0x6c, 0xed, 0xa6, 0x3f, 0x3, 0x5d, 0x76, 0x66, 0x55, 0xaa, 0x7d, 0xa, 0x57, 0x5e, 0xd5, 0x5b, 0x15, 0xba, 0x6b, 0xaf, 0x56, 0x30, 0x9, 0x40, 0xb5, 0x65, 0xe3, 0x7a, 0x24, 0x8e, 0x2d, 0xca, 0xb8},
+               output512: []byte{0x99, 0xad, 0xe7, 0xb1, 0x3e, 0x8e, 0x79, 0xae, 0xa6, 0xed, 0x1, 0xa2, 0x5e, 0x10, 0xe4, 0x1, 0xcd, 0x1d, 0x5, 0x58, 0x84, 0x57, 0x5e, 0xab, 0x3e, 0x66, 0xb2, 0x29, 0x4f, 0x3, 0xf8, 0xd5, 0xdb, 0xf7, 0x2a, 0xb1, 0xae, 0x39, 0x10, 0x31, 0x89, 0x38, 0x3e, 0xbf, 0xd2, 0xe4, 0x32, 0x58, 0x51, 0xc, 0x12, 0x4a, 0x89, 0x4a, 0x79, 0x3b, 0x20, 0x6f, 0xac, 0x75, 0x2c, 0x3, 0x57, 0x89}},
+       testcase{
+               msg:       []byte{0x6e, 0xfc, 0xbc, 0xaf, 0x45, 0x1c, 0x12, 0x9d, 0xbe, 0x0, 0xb9, 0xce, 0xf0, 0xc3, 0x74, 0x9d, 0x3e, 0xe9, 0xd4, 0x1c, 0x7b, 0xd5, 0x0, 0xad, 0xe4, 0xc, 0xdc, 0x65, 0xde, 0xdb, 0xbb, 0xad, 0xb8, 0x85, 0xa5, 0xb1, 0x4b, 0x32, 0xa0, 0xc0, 0xd0, 0x87, 0x82, 0x52, 0x1, 0xe3, 0x3, 0x28, 0x8a, 0x73, 0x38, 0x42, 0xfa, 0x7e, 0x59, 0x9c, 0xc, 0x51, 0x4e, 0x7, 0x8f, 0x5, 0xc8, 0x21, 0xc7, 0xa4, 0x49, 0x8b, 0x1, 0xc4, 0x0, 0x32, 0xe9, 0xf1, 0x87, 0x2a, 0x1c, 0x92, 0x5f, 0xa1, 0x7c, 0xe2, 0x53, 0xe8, 0x93, 0x5e, 0x4c, 0x3c, 0x71, 0x28, 0x22, 0x42, 0xcb, 0x71, 0x6b, 0x20, 0x89, 0xcc, 0xc1},
+               output224: []byte{0x43, 0x6d, 0x1b, 0xcd, 0x6b, 0x3d, 0xe2, 0x67, 0x7a, 0x72, 0xb9, 0x3e, 0x2c, 0xed, 0xb6, 0xc, 0x84, 0xa4, 0xfe, 0x12, 0x5a, 0x80, 0x2e, 0x29, 0x97, 0xeb, 0x2e, 0x67},
+               output256: []byte{0x62, 0x3, 0x9e, 0xf, 0x53, 0x86, 0x94, 0x80, 0xf8, 0x8c, 0x87, 0xbb, 0x3d, 0x19, 0xa3, 0x1a, 0xad, 0x32, 0x87, 0x8f, 0x27, 0xf2, 0xc4, 0xe7, 0x8f, 0xf0, 0x2b, 0xbe, 0xa2, 0xb8, 0xb0, 0xb9},
+               output384: []byte{0x53, 0x4, 0xd6, 0xdb, 0x27, 0x30, 0xfb, 0x7, 0xb8, 0x53, 0x48, 0xb0, 0x22, 0x6b, 0x1a, 0x81, 0xa5, 0x46, 0xba, 0x1f, 0xe2, 0x1, 0xec, 0xce, 0x1e, 0x55, 0x2d, 0xba, 0x6a, 0xfb, 0x84, 0xcc, 0xe7, 0xa6, 0xf9, 0x54, 0xe3, 0x10, 0xa, 0xe1, 0x72, 0x4b, 0x82, 0xcf, 0x1c, 0xbc, 0x41, 0x28},
+               output512: []byte{0xd1, 0x28, 0x31, 0xba, 0x39, 0xdb, 0xcd, 0x41, 0xf5, 0x6b, 0xc7, 0xfc, 0x7, 0x1b, 0xda, 0xab, 0xfb, 0x6e, 0x75, 0x72, 0xd0, 0x8b, 0x2f, 0xda, 0x3b, 0xdd, 0xfc, 0x6f, 0xa5, 0x66, 0x2f, 0x4b, 0xdb, 0xfa, 0x43, 0x1c, 0xa2, 0xe3, 0x8b, 0x18, 0x17, 0x27, 0x9, 0x7, 0x2e, 0x50, 0x12, 0xd, 0xb6, 0xbe, 0x93, 0xe8, 0x6c, 0xb4, 0xac, 0xe3, 0xc1, 0x1d, 0xd0, 0xe1, 0xf3, 0xf5, 0xc7, 0x12}},
+       testcase{
+               msg:       []byte{0x43, 0x3c, 0x53, 0x3, 0x13, 0x16, 0x24, 0xc0, 0x2, 0x1d, 0x86, 0x8a, 0x30, 0x82, 0x54, 0x75, 0xe8, 0xd0, 0xbd, 0x30, 0x52, 0xa0, 0x22, 0x18, 0x3, 0x98, 0xf4, 0xca, 0x44, 0x23, 0xb9, 0x82, 0x14, 0xb6, 0xbe, 0xaa, 0xc2, 0x1c, 0x88, 0x7, 0xa2, 0xc3, 0x3f, 0x8c, 0x93, 0xbd, 0x42, 0xb0, 0x92, 0xcc, 0x1b, 0x6, 0xce, 0xdf, 0x32, 0x24, 0xd5, 0xed, 0x1e, 0xc2, 0x97, 0x84, 0x44, 0x4f, 0x22, 0xe0, 0x8a, 0x55, 0xaa, 0x58, 0x54, 0x2b, 0x52, 0x4b, 0x2, 0xcd, 0x3d, 0x5d, 0x5f, 0x69, 0x7, 0xaf, 0xe7, 0x1c, 0x5d, 0x74, 0x62, 0x22, 0x4a, 0x3f, 0x9d, 0x9e, 0x53, 0xe7, 0xe0, 0x84, 0x6d, 0xcb, 0xb4, 0xce},
+               output224: []byte{0x62, 0xb1, 0xf, 0x1b, 0x62, 0x36, 0xeb, 0xc2, 0xda, 0x72, 0x95, 0x77, 0x42, 0xa8, 0xd4, 0xe4, 0x8e, 0x21, 0x3b, 0x5f, 0x89, 0x34, 0x60, 0x4b, 0xfd, 0x4d, 0x2c, 0x3a},
+               output256: []byte{0xce, 0x87, 0xa5, 0x17, 0x3b, 0xff, 0xd9, 0x23, 0x99, 0x22, 0x16, 0x58, 0xf8, 0x1, 0xd4, 0x5c, 0x29, 0x4d, 0x90, 0x6, 0xee, 0x9f, 0x3f, 0x9d, 0x41, 0x9c, 0x8d, 0x42, 0x77, 0x48, 0xdc, 0x41},
+               output384: []byte{0x13, 0x51, 0x14, 0x50, 0x8d, 0xd6, 0x3e, 0x27, 0x9e, 0x70, 0x9c, 0x26, 0xf7, 0x81, 0x7c, 0x4, 0x82, 0x76, 0x6c, 0xde, 0x49, 0x13, 0x2e, 0x3e, 0xdf, 0x2e, 0xed, 0xd8, 0x99, 0x6f, 0x4e, 0x35, 0x96, 0xd1, 0x84, 0x10, 0xb, 0x38, 0x48, 0x68, 0x24, 0x9f, 0x1d, 0x8b, 0x8f, 0xda, 0xa2, 0xc9},
+               output512: []byte{0x52, 0x7d, 0x28, 0xe3, 0x41, 0xe6, 0xb1, 0x4f, 0x46, 0x84, 0xad, 0xb4, 0xb8, 0x24, 0xc4, 0x96, 0xc6, 0x48, 0x2e, 0x51, 0x14, 0x95, 0x65, 0xd3, 0xd1, 0x72, 0x26, 0x82, 0x88, 0x84, 0x30, 0x6b, 0x51, 0xd6, 0x14, 0x8a, 0x72, 0x62, 0x2c, 0x2b, 0x75, 0xf5, 0xd3, 0x51, 0xb, 0x79, 0x9d, 0x8b, 0xdc, 0x3, 0xea, 0xed, 0xe4, 0x53, 0x67, 0x6a, 0x6e, 0xc8, 0xfe, 0x3, 0xa1, 0xad, 0xe, 0xab}},
+       testcase{
+               msg:       []byte{0xa8, 0x73, 0xe0, 0xc6, 0x7c, 0xa6, 0x39, 0x2, 0x6b, 0x66, 0x83, 0x0, 0x8f, 0x7a, 0xa6, 0x32, 0x4d, 0x49, 0x79, 0x55, 0xe, 0x9b, 0xce, 0x6, 0x4c, 0xa1, 0xe1, 0xfb, 0x97, 0xa3, 0xb, 0x14, 0x7a, 0x24, 0xf3, 0xf6, 0x66, 0xc0, 0xa7, 0x2d, 0x71, 0x34, 0x8e, 0xde, 0x70, 0x1c, 0xf2, 0xd1, 0x7e, 0x22, 0x53, 0xc3, 0x4d, 0x1e, 0xc3, 0xb6, 0x47, 0xdb, 0xce, 0xf2, 0xf8, 0x79, 0xf4, 0xeb, 0x88, 0x1c, 0x48, 0x30, 0xb7, 0x91, 0x37, 0x8c, 0x90, 0x1e, 0xb7, 0x25, 0xea, 0x5c, 0x17, 0x23, 0x16, 0xc6, 0xd6, 0x6, 0xe0, 0xaf, 0x7d, 0xf4, 0xdf, 0x7f, 0x76, 0xe4, 0x90, 0xcd, 0x30, 0xb2, 0xba, 0xdf, 0x45, 0x68, 0x5f},
+               output224: []byte{0x11, 0x86, 0xbe, 0xa0, 0x88, 0xd, 0xa, 0x96, 0xf6, 0xa5, 0x6b, 0xbb, 0x43, 0x1f, 0x4d, 0x26, 0x48, 0x38, 0xbb, 0x1, 0x80, 0xdc, 0xf6, 0x6e, 0xf0, 0xb5, 0x99, 0xca},
+               output256: []byte{0x2e, 0xf8, 0x90, 0x7b, 0x60, 0x10, 0x86, 0x38, 0xe5, 0xe, 0xac, 0x53, 0x5c, 0xc4, 0x6c, 0xa0, 0x2e, 0x4, 0x58, 0x1d, 0xdb, 0x42, 0x35, 0xfb, 0xac, 0x5c, 0xb5, 0xc5, 0x35, 0x83, 0xe2, 0x4b},
+               output384: []byte{0xd5, 0x60, 0xd5, 0x4a, 0x28, 0x81, 0xed, 0x47, 0xcc, 0x8c, 0x5a, 0xf9, 0x81, 0x8f, 0xee, 0xaf, 0x8, 0xb6, 0x21, 0xb1, 0xae, 0xd4, 0x56, 0x9d, 0x8, 0x80, 0x7a, 0xb, 0x61, 0xf9, 0x2, 0xc1, 0x69, 0x1d, 0x8b, 0x8, 0xff, 0x75, 0x59, 0xf, 0xea, 0xae, 0xd6, 0xe7, 0x5f, 0x4c, 0x9e, 0x3f},
+               output512: []byte{0xca, 0xcd, 0xcf, 0x8b, 0xf8, 0x55, 0x4, 0xe, 0x97, 0x95, 0xc4, 0x22, 0x6, 0x9d, 0x8e, 0x37, 0xb6, 0x28, 0x60, 0x66, 0xa2, 0x19, 0x7a, 0x32, 0xb, 0xd9, 0x34, 0x6, 0x1f, 0x66, 0x99, 0x52, 0x27, 0xbe, 0x6b, 0x85, 0xfd, 0x92, 0x8b, 0x83, 0x4d, 0x3c, 0xa4, 0x5e, 0x1a, 0xc3, 0x84, 0x4d, 0x9d, 0xc6, 0x6d, 0x61, 0x58, 0x1e, 0x77, 0x99, 0xcc, 0xfd, 0xe0, 0x8, 0x63, 0x9a, 0xb3, 0xdd}},
+       testcase{
+               msg:       []byte{0x0, 0x69, 0x17, 0xb6, 0x4f, 0x9d, 0xcd, 0xf1, 0xd2, 0xd8, 0x7c, 0x8a, 0x61, 0x73, 0xb6, 0x4f, 0x65, 0x87, 0x16, 0x8e, 0x80, 0xfa, 0xa8, 0xf, 0x82, 0xd8, 0x4f, 0x60, 0x30, 0x1e, 0x56, 0x1e, 0x31, 0x2d, 0x9f, 0xbc, 0xe6, 0x2f, 0x39, 0xa6, 0xfb, 0x47, 0x6e, 0x1, 0xe9, 0x25, 0xf2, 0x6b, 0xcc, 0x91, 0xde, 0x62, 0x14, 0x49, 0xbe, 0x65, 0x4, 0xc5, 0x4, 0x83, 0xa, 0xae, 0x39, 0x40, 0x96, 0xc8, 0xfc, 0x76, 0x94, 0x65, 0x10, 0x51, 0x36, 0x5d, 0x4e, 0xe9, 0x7, 0x1, 0x1, 0xec, 0x9b, 0x68, 0x8, 0x6f, 0x2e, 0xa8, 0xf8, 0xab, 0x7b, 0x81, 0x1e, 0xa8, 0xad, 0x93, 0x4d, 0x5c, 0x9b, 0x62, 0xc6, 0xa, 0x47, 0x71},
+               output224: []byte{0x38, 0x3d, 0x2f, 0x41, 0xec, 0xfd, 0xa5, 0x99, 0x4e, 0x81, 0x54, 0x32, 0x99, 0x9d, 0x19, 0x2e, 0x1a, 0x28, 0x2f, 0xf5, 0x66, 0x31, 0x96, 0xa4, 0xa2, 0x68, 0xa6, 0x7d},
+               output256: []byte{0xbe, 0x8b, 0x5b, 0xd3, 0x65, 0x18, 0xe9, 0xc5, 0xf4, 0xc7, 0x68, 0xfc, 0x2, 0x46, 0x1b, 0xb3, 0xd3, 0x9a, 0x5d, 0x0, 0xed, 0xef, 0x82, 0xce, 0xc7, 0xdf, 0x35, 0x1d, 0xf8, 0x2, 0x38, 0xe0},
+               output384: []byte{0xfe, 0x5f, 0x30, 0xa3, 0x15, 0x58, 0x40, 0x92, 0xa2, 0x71, 0xfd, 0xbc, 0xf4, 0x34, 0x7a, 0x24, 0xd1, 0x4a, 0x1f, 0x98, 0xca, 0xdc, 0x88, 0xdf, 0x28, 0x8c, 0x36, 0xce, 0xa8, 0xf8, 0x9e, 0x90, 0x20, 0x1, 0x99, 0x33, 0xbc, 0xd4, 0xf5, 0xa7, 0x47, 0x9e, 0x3e, 0x4a, 0x57, 0x64, 0x4c, 0x49},
+               output512: []byte{0xf4, 0x54, 0xa9, 0x53, 0x50, 0x1e, 0x19, 0x1a, 0x12, 0xa8, 0xc, 0x7a, 0x53, 0x98, 0xf0, 0x81, 0xce, 0xf7, 0x38, 0xe2, 0x5d, 0x48, 0xb0, 0x76, 0xa5, 0x2f, 0x77, 0xfb, 0x9, 0xef, 0xb, 0xc2, 0x32, 0x51, 0x16, 0x2, 0xb, 0xb0, 0x6c, 0x2c, 0x58, 0x5d, 0xa9, 0xf1, 0x15, 0xbd, 0x9d, 0x8f, 0x13, 0xb5, 0xe, 0x8e, 0x1f, 0xb1, 0x66, 0x44, 0x50, 0xfa, 0xe6, 0x90, 0xb7, 0x78, 0x34, 0x0}},
+       testcase{
+               msg:       []byte{0xf1, 0x3c, 0x97, 0x2c, 0x52, 0xcb, 0x3c, 0xc4, 0xa4, 0xdf, 0x28, 0xc9, 0x7f, 0x2d, 0xf1, 0x1c, 0xe0, 0x89, 0xb8, 0x15, 0x46, 0x6b, 0xe8, 0x88, 0x63, 0x24, 0x3e, 0xb3, 0x18, 0xc2, 0xad, 0xb1, 0xa4, 0x17, 0xcb, 0x10, 0x41, 0x30, 0x85, 0x98, 0x54, 0x17, 0x20, 0x19, 0x7b, 0x9b, 0x1c, 0xb5, 0xba, 0x23, 0x18, 0xbd, 0x55, 0x74, 0xd1, 0xdf, 0x21, 0x74, 0xaf, 0x14, 0x88, 0x41, 0x49, 0xba, 0x9b, 0x2f, 0x44, 0x6d, 0x60, 0x9d, 0xf2, 0x40, 0xce, 0x33, 0x55, 0x99, 0x95, 0x7b, 0x8e, 0xc8, 0x8, 0x76, 0xd9, 0xa0, 0x85, 0xae, 0x8, 0x49, 0x7, 0xbc, 0x59, 0x61, 0xb2, 0xb, 0xf5, 0xf6, 0xca, 0x58, 0xd5, 0xda, 0xb3, 0x8a, 0xdb},
+               output224: []byte{0xe2, 0x59, 0x4a, 0x63, 0x3b, 0x2d, 0xc6, 0x71, 0xfd, 0xd, 0xdf, 0xd3, 0xbf, 0x72, 0x38, 0x33, 0x2c, 0x42, 0x55, 0x20, 0x82, 0x7c, 0x52, 0x4f, 0xb0, 0xe1, 0x97, 0x78},
+               output256: []byte{0x52, 0xcb, 0xc5, 0xdb, 0xe4, 0x9b, 0x0, 0x96, 0x63, 0xc4, 0x3f, 0x7, 0x9d, 0xd1, 0x80, 0xe3, 0x8a, 0x77, 0x53, 0x37, 0x78, 0x6, 0x2a, 0x72, 0xa2, 0x9e, 0x86, 0x4a, 0x58, 0x52, 0x29, 0x22},
+               output384: []byte{0xa4, 0xe5, 0xee, 0x13, 0xf, 0xc1, 0x5, 0x81, 0x8c, 0xd1, 0xa0, 0xde, 0x74, 0xf1, 0x8, 0x5b, 0x9b, 0x4d, 0x93, 0x88, 0x9c, 0x50, 0x9d, 0xc3, 0xa2, 0x8, 0xb5, 0x23, 0xd, 0x39, 0xd8, 0xf3, 0x4, 0xbb, 0x40, 0x3f, 0x72, 0xbf, 0xc, 0xf5, 0xe0, 0x2c, 0x4c, 0x4a, 0x8, 0x31, 0xf3, 0x28},
+               output512: []byte{0x5f, 0x96, 0x8c, 0xc6, 0xec, 0xf7, 0x1c, 0x58, 0x8a, 0x3c, 0x3b, 0xa6, 0x88, 0x58, 0xbb, 0xff, 0x96, 0x86, 0x1f, 0x66, 0xc0, 0x73, 0x3f, 0xd6, 0x1f, 0xa9, 0x1a, 0x47, 0x9a, 0x49, 0x61, 0x8d, 0xf2, 0x2d, 0x94, 0x90, 0x21, 0x9d, 0xf8, 0x0, 0x8d, 0xc7, 0x88, 0x40, 0xae, 0x2, 0x2c, 0x5d, 0x41, 0xaf, 0x2b, 0x89, 0xd, 0x2, 0x14, 0xe5, 0x62, 0xda, 0x8d, 0xf0, 0xcb, 0x3f, 0x85, 0x22}},
+       testcase{
+               msg:       []byte{0xe3, 0x57, 0x80, 0xeb, 0x97, 0x99, 0xad, 0x4c, 0x77, 0x53, 0x5d, 0x4d, 0xdb, 0x68, 0x3c, 0xf3, 0x3e, 0xf3, 0x67, 0x71, 0x53, 0x27, 0xcf, 0x4c, 0x4a, 0x58, 0xed, 0x9c, 0xbd, 0xcd, 0xd4, 0x86, 0xf6, 0x69, 0xf8, 0x1, 0x89, 0xd5, 0x49, 0xa9, 0x36, 0x4f, 0xa8, 0x2a, 0x51, 0xa5, 0x26, 0x54, 0xec, 0x72, 0x1b, 0xb3, 0xaa, 0xb9, 0x5d, 0xce, 0xb4, 0xa8, 0x6a, 0x6a, 0xfa, 0x93, 0x82, 0x6d, 0xb9, 0x23, 0x51, 0x7e, 0x92, 0x8f, 0x33, 0xe3, 0xfb, 0xa8, 0x50, 0xd4, 0x56, 0x60, 0xef, 0x83, 0xb9, 0x87, 0x6a, 0xcc, 0xaf, 0xa2, 0xa9, 0x98, 0x7a, 0x25, 0x4b, 0x13, 0x7c, 0x6e, 0x14, 0xa, 0x21, 0x69, 0x1e, 0x10, 0x69, 0x41, 0x38, 0x48},
+               output224: []byte{0x23, 0x47, 0x64, 0xaa, 0xe8, 0xc3, 0x9b, 0x15, 0x71, 0xd7, 0x74, 0x1b, 0xb1, 0x76, 0xff, 0x86, 0x24, 0x60, 0x70, 0xec, 0x9a, 0xc9, 0x7a, 0x1b, 0x2e, 0xb3, 0x54, 0x72},
+               output256: []byte{0x3a, 0x8d, 0xfc, 0xfd, 0x1b, 0x36, 0x20, 0x3, 0xdd, 0xfa, 0x17, 0x91, 0x7, 0x27, 0x53, 0x9e, 0x64, 0xb1, 0x80, 0x21, 0xab, 0xba, 0x1, 0x8b, 0x5f, 0x58, 0xd7, 0x1f, 0x7a, 0x44, 0x97, 0x33},
+               output384: []byte{0x9f, 0xb5, 0x70, 0x5, 0x2, 0xe0, 0x19, 0x26, 0x82, 0x4f, 0x46, 0xe9, 0xf6, 0x18, 0x94, 0xf9, 0x48, 0x7d, 0xbc, 0xf8, 0xae, 0x62, 0x17, 0x20, 0x3c, 0x85, 0x60, 0x6f, 0x97, 0x55, 0x66, 0x53, 0x93, 0x76, 0xd6, 0x23, 0x9d, 0xb0, 0x4a, 0xef, 0x9b, 0xf4, 0x8c, 0xa4, 0xf1, 0x91, 0xa9, 0xb},
+               output512: []byte{0xe7, 0x14, 0x94, 0x61, 0xf9, 0xcd, 0x0, 0xb7, 0x1c, 0x21, 0x6c, 0x50, 0x4, 0x1b, 0x3e, 0xda, 0x97, 0x7, 0xd7, 0x36, 0xd, 0x4c, 0x21, 0x74, 0xc, 0x44, 0xc2, 0x12, 0x25, 0x6a, 0x31, 0xda, 0x39, 0x8f, 0xe0, 0x97, 0x8, 0xe4, 0x50, 0xea, 0x4e, 0x28, 0x26, 0xb7, 0xec, 0x20, 0xbe, 0xf7, 0x6c, 0xd2, 0xfb, 0xd9, 0xd0, 0x96, 0xaf, 0x6f, 0x77, 0xf8, 0x4a, 0xbc, 0x2e, 0x4f, 0xb0, 0x93}},
+       testcase{
+               msg:       []byte{0x64, 0xec, 0x2, 0x1c, 0x95, 0x85, 0xe0, 0x1f, 0xfe, 0x6d, 0x31, 0xbb, 0x50, 0xd4, 0x4c, 0x79, 0xb6, 0x99, 0x3d, 0x72, 0x67, 0x81, 0x63, 0xdb, 0x47, 0x49, 0x47, 0xa0, 0x53, 0x67, 0x46, 0x19, 0xd1, 0x58, 0x1, 0x6a, 0xdb, 0x24, 0x3f, 0x5c, 0x8d, 0x50, 0xaa, 0x92, 0xf5, 0xa, 0xb3, 0x6e, 0x57, 0x9f, 0xf2, 0xda, 0xbb, 0x78, 0xa, 0x2b, 0x52, 0x93, 0x70, 0xda, 0xa2, 0x99, 0x20, 0x7c, 0xfb, 0xcd, 0xd3, 0xa9, 0xa2, 0x50, 0x6, 0xd1, 0x9c, 0x4f, 0x1f, 0xe3, 0x3e, 0x4b, 0x1e, 0xae, 0xc3, 0x15, 0xd8, 0xc6, 0xee, 0x1e, 0x73, 0x6, 0x23, 0xfd, 0x19, 0x41, 0x87, 0x5b, 0x92, 0x4e, 0xb5, 0x7d, 0x6d, 0xc, 0x2e, 0xdc, 0x4e, 0x78, 0xd6},
+               output224: []byte{0xa6, 0x34, 0xd7, 0xeb, 0xaa, 0x2b, 0xc0, 0x4, 0x3e, 0xb5, 0xe2, 0x37, 0x69, 0xe, 0x38, 0xff, 0x1e, 0x5, 0xee, 0x5a, 0x4, 0x28, 0x82, 0xa2, 0x33, 0xa2, 0xd9, 0x2a},
+               output256: []byte{0xfa, 0x22, 0x1d, 0xee, 0xe8, 0xe, 0x25, 0xe5, 0x3c, 0x6c, 0x44, 0x8a, 0xa2, 0x20, 0x28, 0xb7, 0x25, 0x1, 0xf0, 0x7d, 0x1f, 0xf2, 0xc3, 0xfc, 0x7f, 0x93, 0xaf, 0x98, 0x38, 0xb2, 0xd0, 0xa9},
+               output384: []byte{0xf2, 0xe0, 0xff, 0x6c, 0xf4, 0x80, 0x1c, 0xff, 0x2e, 0xca, 0x17, 0x3, 0xe4, 0xe9, 0x56, 0xc0, 0x7, 0xa1, 0xf2, 0x70, 0x94, 0x30, 0xf1, 0xf7, 0xa0, 0xa4, 0xfd, 0xd1, 0x6a, 0x6, 0x35, 0x22, 0xa4, 0xdf, 0xb6, 0xc4, 0x1f, 0xa5, 0x29, 0xc2, 0xe3, 0x25, 0xf8, 0xcd, 0xd4, 0xf8, 0xda, 0x96},
+               output512: []byte{0x77, 0x9, 0x74, 0x13, 0xca, 0xa5, 0xa2, 0xd3, 0x82, 0x59, 0xd4, 0x7e, 0xc0, 0x78, 0x87, 0x1f, 0xa0, 0x9e, 0xe5, 0x61, 0x4d, 0x4c, 0x14, 0xfe, 0xb7, 0xa9, 0x5c, 0x92, 0x1c, 0xa, 0xae, 0x93, 0xb8, 0x73, 0x7a, 0x6d, 0xc8, 0x9e, 0x57, 0x69, 0x3b, 0xe8, 0xa0, 0x71, 0x2, 0x6, 0x66, 0x4b, 0x80, 0xb6, 0x57, 0xa1, 0x7, 0x96, 0x5, 0xa0, 0xff, 0x96, 0x64, 0xbb, 0xcb, 0x7, 0x22, 0xd6}},
+       testcase{
+               msg:       []byte{0x59, 0x54, 0xba, 0xb5, 0x12, 0xcf, 0x32, 0x7d, 0x66, 0xb5, 0xd9, 0xf2, 0x96, 0x18, 0x0, 0x80, 0x40, 0x26, 0x24, 0xad, 0x76, 0x28, 0x50, 0x6b, 0x55, 0x5e, 0xea, 0x83, 0x82, 0x56, 0x23, 0x24, 0xcf, 0x45, 0x2f, 0xba, 0x4a, 0x21, 0x30, 0xde, 0x3e, 0x16, 0x5d, 0x11, 0x83, 0x1a, 0x27, 0xd, 0x9c, 0xb9, 0x7c, 0xe8, 0xc2, 0xd3, 0x2a, 0x96, 0xf5, 0xd, 0x71, 0x60, 0xb, 0xb4, 0xca, 0x26, 0x8c, 0xf9, 0x8e, 0x90, 0xd6, 0x49, 0x6b, 0xa, 0x66, 0x19, 0xa5, 0xa8, 0xc6, 0x3d, 0xb6, 0xd8, 0xa0, 0x63, 0x4d, 0xfc, 0x6c, 0x7e, 0xc8, 0xea, 0x9c, 0x0, 0x6b, 0x6c, 0x45, 0x6f, 0x1b, 0x20, 0xcd, 0x19, 0xe7, 0x81, 0xaf, 0x20, 0x45, 0x4a, 0xc8, 0x80},
+               output224: []byte{0xef, 0x3, 0xfb, 0xb1, 0xef, 0x32, 0x96, 0xee, 0xcf, 0xb9, 0x89, 0x9, 0xe4, 0x16, 0xd1, 0x13, 0xb5, 0x74, 0x1e, 0x44, 0x96, 0x2e, 0xc5, 0x79, 0x93, 0xc6, 0xda, 0x5d},
+               output256: []byte{0xed, 0x9c, 0x8b, 0x87, 0xfc, 0xe2, 0x7b, 0xe4, 0xe9, 0x56, 0x10, 0xdb, 0x1d, 0xdd, 0xc, 0x3, 0x58, 0x47, 0xf4, 0x69, 0x9d, 0xfc, 0x8c, 0x3, 0x9a, 0x79, 0x8a, 0x30, 0x34, 0x3a, 0x60, 0x59},
+               output384: []byte{0x62, 0x2, 0x9d, 0x96, 0x2d, 0x2e, 0x32, 0x36, 0x88, 0xdc, 0x58, 0x51, 0xc5, 0x49, 0xda, 0x39, 0xef, 0x49, 0xcb, 0x99, 0x4d, 0x2d, 0x6c, 0x51, 0xc5, 0x7b, 0x9b, 0xba, 0xb3, 0x75, 0xaa, 0x10, 0xbd, 0x6, 0x5, 0x20, 0x8d, 0x99, 0x46, 0xea, 0x47, 0x25, 0x73, 0x88, 0x2, 0x30, 0xdd, 0x2d},
+               output512: []byte{0x55, 0xd8, 0xe5, 0x20, 0x23, 0x60, 0xd7, 0xd5, 0x84, 0x14, 0x19, 0x36, 0x2f, 0x86, 0x4c, 0xc9, 0x0, 0xe1, 0x1c, 0x58, 0x2f, 0xd0, 0xca, 0xb2, 0xff, 0x5f, 0x16, 0x80, 0xf6, 0xce, 0x92, 0x7b, 0x53, 0x79, 0xe2, 0x7a, 0x33, 0x5e, 0xba, 0xfe, 0x12, 0x86, 0xb9, 0xd4, 0xa1, 0x72, 0xab, 0x76, 0x1a, 0x36, 0xea, 0xde, 0x60, 0xf1, 0x4, 0x68, 0xea, 0xc4, 0xce, 0xaf, 0xbf, 0x63, 0xc7, 0xcc}},
+       testcase{
+               msg:       []byte{0x3, 0xd9, 0xf9, 0x2b, 0x2c, 0x56, 0x57, 0x9, 0xa5, 0x68, 0x72, 0x4a, 0xa, 0xff, 0x90, 0xf8, 0xf3, 0x47, 0xf4, 0x3b, 0x2, 0x33, 0x8f, 0x94, 0xa0, 0x3e, 0xd3, 0x2e, 0x6f, 0x33, 0x66, 0x6f, 0xf5, 0x80, 0x2d, 0xa4, 0xc8, 0x1b, 0xdc, 0xe0, 0xd0, 0xe8, 0x6c, 0x4, 0xaf, 0xd4, 0xed, 0xc2, 0xfc, 0x8b, 0x41, 0x41, 0xc2, 0x97, 0x5b, 0x6f, 0x7, 0x63, 0x9b, 0x19, 0x94, 0xc9, 0x73, 0xd9, 0xa9, 0xaf, 0xce, 0x3d, 0x9d, 0x36, 0x58, 0x62, 0x0, 0x34, 0x98, 0x51, 0x3b, 0xfa, 0x16, 0x6d, 0x26, 0x29, 0xe3, 0x14, 0xd9, 0x74, 0x41, 0x66, 0x7b, 0x0, 0x74, 0x14, 0xe7, 0x39, 0xd7, 0xfe, 0xbf, 0xf, 0xe3, 0xc3, 0x2c, 0x17, 0xaa, 0x18, 0x8a, 0x86, 0x83},
+               output224: []byte{0x21, 0xd, 0x24, 0x5c, 0xc8, 0xb5, 0xa7, 0xb4, 0xc1, 0xb1, 0x18, 0xa9, 0x89, 0xe, 0xcd, 0xdc, 0x34, 0xa6, 0x6e, 0xa9, 0x28, 0x5, 0xb7, 0xa7, 0xc1, 0x9a, 0x94, 0x4a},
+               output256: []byte{0xa4, 0x85, 0xcc, 0x9c, 0xf4, 0xca, 0x4f, 0x65, 0x9f, 0x89, 0xa0, 0xb7, 0x91, 0xa4, 0x42, 0x39, 0x53, 0x42, 0x4a, 0xc5, 0x71, 0x46, 0xb8, 0x79, 0xd3, 0x85, 0xa9, 0xe4, 0x6, 0x2a, 0xfe, 0x52},
+               output384: []byte{0x25, 0xe5, 0x46, 0xf7, 0x6e, 0xa9, 0xf9, 0x8e, 0x3, 0xe3, 0xb2, 0xf4, 0xab, 0x60, 0x81, 0x85, 0x7, 0x36, 0x58, 0xe7, 0xed, 0xa0, 0x77, 0x7b, 0xd5, 0xb0, 0x47, 0xa5, 0x90, 0x85, 0xc3, 0xc5, 0x0, 0x91, 0x63, 0x47, 0xd4, 0xf7, 0x7e, 0x38, 0xe3, 0x51, 0x59, 0xaf, 0x13, 0x3e, 0xd6, 0x38},
+               output512: []byte{0xef, 0xfb, 0x3, 0xb4, 0x97, 0xad, 0xd6, 0x23, 0xa, 0xe, 0xd9, 0x91, 0x22, 0xea, 0x86, 0x81, 0x38, 0x64, 0x4a, 0xb8, 0x1e, 0x86, 0x14, 0x91, 0xe5, 0x26, 0xfa, 0xe3, 0x7c, 0x39, 0x87, 0x2c, 0xa7, 0x31, 0x80, 0x4a, 0x0, 0x4, 0x59, 0x98, 0x49, 0x47, 0x8a, 0x78, 0x7b, 0xc7, 0xfc, 0xe2, 0x19, 0x3, 0xed, 0x55, 0x1d, 0x7d, 0xb8, 0x81, 0xd2, 0xa2, 0xc3, 0x67, 0xb6, 0x16, 0x85, 0x47}},
+       testcase{
+               msg:       []byte{0xf3, 0x1e, 0x8b, 0x4f, 0x9e, 0x6, 0x21, 0xd5, 0x31, 0xd2, 0x2a, 0x38, 0xb, 0xe5, 0xd9, 0xab, 0xd5, 0x6f, 0xae, 0xc5, 0x3c, 0xbd, 0x39, 0xb1, 0xfa, 0xb2, 0x30, 0xea, 0x67, 0x18, 0x44, 0x40, 0xe5, 0xb1, 0xd1, 0x54, 0x57, 0xbd, 0x25, 0xf5, 0x62, 0x4, 0xfa, 0x91, 0x7f, 0xa4, 0x8e, 0x66, 0x90, 0x16, 0xcb, 0x48, 0xc1, 0xff, 0xc1, 0xe1, 0xe4, 0x52, 0x74, 0xb3, 0xb4, 0x73, 0x79, 0xe0, 0xa, 0x43, 0x84, 0x3c, 0xf8, 0x60, 0x1a, 0x55, 0x51, 0x41, 0x1e, 0xc1, 0x25, 0x3, 0xe5, 0xaa, 0xc4, 0x3d, 0x86, 0x76, 0xa1, 0xb2, 0x29, 0x7e, 0xc7, 0xa0, 0x80, 0xd, 0xbf, 0xee, 0x4, 0x29, 0x2e, 0x93, 0x7f, 0x21, 0xc0, 0x5, 0xf1, 0x74, 0x11, 0x47, 0x30, 0x41},
+               output224: []byte{0x51, 0x7b, 0xae, 0x1, 0x7, 0x15, 0xa0, 0x20, 0x43, 0x5c, 0xfd, 0xb5, 0x31, 0xb8, 0x56, 0xc5, 0x70, 0x4e, 0xe, 0xc6, 0x11, 0x36, 0xf, 0x60, 0xd5, 0xb7, 0x61, 0x61},
+               output256: []byte{0x93, 0xcd, 0x43, 0x69, 0xa7, 0x79, 0x62, 0x39, 0xa5, 0xcd, 0xf7, 0x8b, 0xce, 0x22, 0xeb, 0xb2, 0x13, 0x7a, 0x63, 0x1c, 0x3a, 0x61, 0x3d, 0x5e, 0x35, 0x81, 0x6d, 0x2a, 0x64, 0xa3, 0x49, 0x47},
+               output384: []byte{0xbe, 0xef, 0xce, 0xff, 0x9e, 0x2d, 0x8, 0x25, 0xd6, 0xe, 0xa2, 0xe, 0x52, 0x71, 0xbf, 0x49, 0xc4, 0xae, 0x3a, 0x5b, 0x54, 0xb5, 0x60, 0x50, 0x98, 0x8d, 0xd3, 0xdf, 0x5d, 0xb5, 0xeb, 0x4f, 0x10, 0x2, 0xef, 0xbf, 0xba, 0xed, 0x2f, 0xc7, 0x21, 0x79, 0xde, 0x44, 0x11, 0x69, 0x76, 0xb2},
+               output512: []byte{0xa2, 0x26, 0x9a, 0x6e, 0xf2, 0xea, 0x8f, 0x1c, 0xf8, 0xbc, 0x33, 0x94, 0xd2, 0x76, 0x57, 0xb0, 0xdb, 0x99, 0x6c, 0x55, 0xe7, 0xc4, 0x77, 0x84, 0xc0, 0xb4, 0x51, 0x20, 0x2f, 0xc5, 0x27, 0x96, 0x79, 0xd7, 0x9e, 0x6, 0xf8, 0xdb, 0xaa, 0x9a, 0x63, 0x66, 0x5f, 0xd0, 0xe9, 0x14, 0xd1, 0x3c, 0x6e, 0x5, 0x6e, 0xa0, 0x6, 0xda, 0xaf, 0x4c, 0xb6, 0x1d, 0x26, 0x29, 0x46, 0x8e, 0x3d, 0x25}},
+       testcase{
+               msg:       []byte{0x75, 0x8e, 0xa3, 0xfe, 0xa7, 0x38, 0x97, 0x3d, 0xb0, 0xb8, 0xbe, 0x7e, 0x59, 0x9b, 0xbe, 0xf4, 0x51, 0x93, 0x73, 0xd6, 0xe6, 0xdc, 0xd7, 0x19, 0x5e, 0xa8, 0x85, 0xfc, 0x99, 0x1d, 0x89, 0x67, 0x62, 0x99, 0x27, 0x59, 0xc2, 0xa0, 0x90, 0x2, 0x91, 0x2f, 0xb0, 0x8e, 0xc, 0xb5, 0xb7, 0x6f, 0x49, 0x16, 0x2a, 0xeb, 0x8c, 0xf8, 0x7b, 0x17, 0x2c, 0xf3, 0xad, 0x19, 0x2, 0x53, 0xdf, 0x61, 0x2f, 0x77, 0xb1, 0xf0, 0xc5, 0x32, 0xe3, 0xb5, 0xfc, 0x99, 0xc2, 0xd3, 0x1f, 0x8f, 0x65, 0x1, 0x16, 0x95, 0xa0, 0x87, 0xa3, 0x5e, 0xe4, 0xee, 0xe5, 0xe3, 0x34, 0xc3, 0x69, 0xd8, 0xee, 0x5d, 0x29, 0xf6, 0x95, 0x81, 0x5d, 0x86, 0x6d, 0xa9, 0x9d, 0xf3, 0xf7, 0x94, 0x3},
+               output224: []byte{0x79, 0xd4, 0x78, 0xb4, 0xbc, 0x5e, 0x6f, 0xc2, 0xd4, 0x6, 0xbb, 0x1c, 0x38, 0x34, 0xa5, 0xce, 0x39, 0x7a, 0x88, 0xe8, 0x1, 0x35, 0xf5, 0x5d, 0x8f, 0xe3, 0x2c, 0x5e},
+               output256: []byte{0x37, 0x51, 0xce, 0x8, 0x75, 0xd, 0x92, 0x7e, 0xb5, 0xc3, 0xae, 0x4c, 0xa6, 0x2a, 0x70, 0x3a, 0x48, 0x1d, 0x86, 0xa4, 0xfa, 0x1c, 0x1, 0x1e, 0x81, 0x2b, 0x4b, 0xc0, 0xa2, 0xfe, 0xf0, 0x8d},
+               output384: []byte{0x7d, 0x18, 0x25, 0x4d, 0x46, 0xa1, 0x4d, 0x3, 0x83, 0xec, 0x56, 0xac, 0x9c, 0xa2, 0xfd, 0xa7, 0x88, 0x5a, 0xe6, 0x73, 0x46, 0x8c, 0x9f, 0x3b, 0x45, 0xba, 0x79, 0x2c, 0x2c, 0x23, 0xc9, 0xff, 0x82, 0x49, 0x1e, 0x6a, 0xec, 0xa1, 0x5d, 0x7, 0x6a, 0xd3, 0xa3, 0x43, 0x2c, 0xfa, 0x65, 0xc},
+               output512: []byte{0x5a, 0x29, 0x70, 0xd5, 0xec, 0x34, 0x6a, 0x8e, 0x4e, 0x1d, 0x5d, 0x1e, 0x57, 0xdc, 0x22, 0xf6, 0x87, 0x5d, 0xdf, 0x1c, 0xe3, 0x62, 0x6b, 0x49, 0xa9, 0x11, 0x9, 0xe0, 0xde, 0x99, 0x10, 0x33, 0xe9, 0x32, 0xf8, 0x83, 0xb6, 0xa7, 0x95, 0x1, 0x6d, 0x50, 0x14, 0xe2, 0x68, 0x30, 0x4a, 0xbe, 0x2f, 0x75, 0x77, 0x50, 0x5a, 0xab, 0x0, 0x95, 0x69, 0x11, 0x78, 0x1f, 0x7, 0x5d, 0x11, 0x3a}},
+       testcase{
+               msg:       []byte{0x47, 0xc6, 0xe0, 0xc2, 0xb7, 0x49, 0x48, 0x46, 0x59, 0x21, 0x86, 0x88, 0x4, 0xf0, 0xf7, 0xbd, 0x50, 0xdd, 0x32, 0x35, 0x83, 0xdc, 0x78, 0x4f, 0x99, 0x8a, 0x93, 0xcd, 0x1c, 0xa4, 0xc6, 0xef, 0x84, 0xd4, 0x1d, 0xc8, 0x1c, 0x2c, 0x40, 0xf3, 0x4b, 0x5b, 0xee, 0x6a, 0x93, 0x86, 0x7b, 0x3b, 0xdb, 0xa0, 0x5, 0x2c, 0x5f, 0x59, 0xe6, 0xf3, 0x65, 0x79, 0x18, 0xc3, 0x82, 0xe7, 0x71, 0xd3, 0x31, 0x9, 0x12, 0x2c, 0xc8, 0xbb, 0xe, 0x1e, 0x53, 0xc4, 0xe3, 0xd1, 0x3b, 0x43, 0xce, 0x44, 0x97, 0xf, 0x5e, 0xc, 0x7, 0x9d, 0x2a, 0xd7, 0xd7, 0xa3, 0x54, 0x9c, 0xd7, 0x57, 0x60, 0xc2, 0x1b, 0xb1, 0x5b, 0x44, 0x75, 0x89, 0xe8, 0x6e, 0x8d, 0x76, 0xb1, 0xe9, 0xce, 0xd2},
+               output224: []byte{0xf7, 0xba, 0x7a, 0x56, 0xaf, 0xc1, 0xc5, 0x8e, 0x62, 0x84, 0x1c, 0x3b, 0x98, 0xf5, 0x67, 0x71, 0x99, 0xf2, 0x4b, 0x53, 0x4b, 0xd, 0x52, 0xd9, 0xa5, 0xc9, 0x54, 0x95},
+               output256: []byte{0xa8, 0x8c, 0x7e, 0xf7, 0xb8, 0x9b, 0x7b, 0x6f, 0x75, 0xd8, 0x39, 0x22, 0xb8, 0xfd, 0x0, 0xf0, 0x34, 0xd7, 0x19, 0xf9, 0x7c, 0x67, 0x88, 0x41, 0x21, 0x43, 0x44, 0x47, 0xae, 0x9d, 0xd3, 0xb9},
+               output384: []byte{0x1e, 0x3e, 0x0, 0x7c, 0xe3, 0x77, 0x92, 0xd8, 0xa4, 0x42, 0x3b, 0x79, 0x7e, 0x87, 0x6e, 0x89, 0x85, 0x95, 0x90, 0xde, 0xdd, 0x39, 0x71, 0x1a, 0xd0, 0xf1, 0xde, 0x2f, 0xd9, 0x25, 0xf4, 0x32, 0xb, 0x44, 0xbd, 0x57, 0xdd, 0xc7, 0x5, 0x4, 0x27, 0x94, 0x3e, 0x3c, 0x95, 0x7d, 0x4b, 0x6d},
+               output512: []byte{0x2b, 0x43, 0x56, 0xa6, 0x4d, 0xf3, 0x19, 0x36, 0xb2, 0x7f, 0x45, 0x30, 0xf0, 0x76, 0xee, 0x73, 0xe7, 0x1e, 0x4e, 0x48, 0xab, 0xde, 0x4, 0xff, 0x1f, 0x54, 0x8e, 0x7, 0x27, 0xf4, 0xa5, 0x81, 0xb, 0x71, 0x87, 0x41, 0x87, 0xfd, 0x96, 0xed, 0x51, 0xd, 0xd, 0x68, 0x86, 0xaf, 0x11, 0x96, 0xa, 0xb, 0x3b, 0xad, 0x1e, 0xe7, 0x5d, 0xda, 0x4c, 0xdc, 0x14, 0x8e, 0x16, 0x2e, 0xda, 0xe9}},
+       testcase{
+               msg:       []byte{0xf6, 0x90, 0xa1, 0x32, 0xab, 0x46, 0xb2, 0x8e, 0xdf, 0xa6, 0x47, 0x92, 0x83, 0xd6, 0x44, 0x4e, 0x37, 0x1c, 0x64, 0x59, 0x10, 0x8a, 0xfd, 0x9c, 0x35, 0xdb, 0xd2, 0x35, 0xe0, 0xb6, 0xb6, 0xff, 0x4c, 0x4e, 0xa5, 0x8e, 0x75, 0x54, 0xbd, 0x0, 0x24, 0x60, 0x43, 0x3b, 0x21, 0x64, 0xca, 0x51, 0xe8, 0x68, 0xf7, 0x94, 0x7d, 0x7d, 0x7a, 0xd, 0x79, 0x2e, 0x4a, 0xbf, 0xb, 0xe5, 0xf4, 0x50, 0x85, 0x3c, 0xc4, 0xd, 0x85, 0x48, 0x5b, 0x2b, 0x88, 0x57, 0xea, 0x31, 0xb5, 0xea, 0x6e, 0x4c, 0xcf, 0xa2, 0xf3, 0xa7, 0xef, 0x33, 0x80, 0x6, 0x6d, 0x7d, 0x89, 0x79, 0xfd, 0xac, 0x61, 0x8a, 0xad, 0x3d, 0x7e, 0x88, 0x6d, 0xea, 0x4f, 0x0, 0x5a, 0xe4, 0xad, 0x5, 0xe5, 0x6, 0x5f},
+               output224: []byte{0x78, 0xa9, 0xb, 0x76, 0x9e, 0x9a, 0x32, 0x6c, 0x93, 0xd5, 0xa6, 0xa6, 0x10, 0x5a, 0xee, 0x3, 0x1d, 0xce, 0xb2, 0xc8, 0xd2, 0x22, 0xb3, 0x6e, 0x2, 0xf2, 0x7d, 0xb6},
+               output256: []byte{0x2b, 0x4f, 0x8f, 0x9e, 0xf7, 0xd6, 0xed, 0x60, 0xbb, 0x48, 0x81, 0xe6, 0x35, 0xe0, 0xf8, 0x87, 0xa5, 0x1b, 0xc, 0x1a, 0x42, 0xba, 0xb0, 0x77, 0x97, 0x6b, 0x43, 0xd2, 0xc7, 0x15, 0xe1, 0x1a},
+               output384: []byte{0xd1, 0xd2, 0x63, 0xb5, 0x31, 0x1b, 0x5, 0xc7, 0xb9, 0xf7, 0x78, 0x3e, 0x3a, 0xfd, 0x9a, 0x2e, 0x75, 0x79, 0x1c, 0xe0, 0x50, 0x3e, 0xd8, 0x20, 0x47, 0x4b, 0x35, 0x34, 0xd, 0x2c, 0xc8, 0x4b, 0x2, 0x70, 0x92, 0x1b, 0xbd, 0x96, 0x57, 0x22, 0x1, 0x1a, 0xa3, 0xc, 0xe4, 0x35, 0x29, 0x26},
+               output512: []byte{0xed, 0xcb, 0x59, 0x98, 0x42, 0x67, 0xbb, 0x0, 0x40, 0x2a, 0x78, 0xf2, 0xca, 0x34, 0x5e, 0xf2, 0x49, 0x49, 0x56, 0x17, 0x2e, 0x10, 0x92, 0x7e, 0xe6, 0x3a, 0xff, 0x23, 0xd0, 0xc8, 0x34, 0xbc, 0xa5, 0xc, 0x47, 0xcd, 0xbf, 0xfd, 0x89, 0x95, 0x3, 0x63, 0x7, 0xe9, 0xed, 0x4b, 0x14, 0x3e, 0x85, 0x34, 0x50, 0x36, 0x7d, 0xe, 0x14, 0xaf, 0xc8, 0x49, 0x0, 0x73, 0x65, 0x3c, 0xd8, 0x50}},
+       testcase{
+               msg:       []byte{0x58, 0xd6, 0xa9, 0x9b, 0xc6, 0x45, 0x88, 0x24, 0xb2, 0x56, 0x91, 0x67, 0x70, 0xa8, 0x41, 0x70, 0x40, 0x72, 0x1c, 0xcc, 0xfd, 0x4b, 0x79, 0xea, 0xcd, 0x8b, 0x65, 0xa3, 0x76, 0x7c, 0xe5, 0xba, 0x7e, 0x74, 0x10, 0x4c, 0x98, 0x5a, 0xc5, 0x6b, 0x8c, 0xc9, 0xae, 0xbd, 0x16, 0xfe, 0xbd, 0x4c, 0xda, 0x5a, 0xdb, 0x13, 0xb, 0xf, 0xf2, 0x32, 0x9c, 0xc8, 0xd6, 0x11, 0xeb, 0x14, 0xda, 0xc2, 0x68, 0xa2, 0xf9, 0xe6, 0x33, 0xc9, 0x9d, 0xe3, 0x39, 0x97, 0xfe, 0xa4, 0x1c, 0x52, 0xa7, 0xc5, 0xe1, 0x31, 0x7d, 0x5b, 0x5d, 0xae, 0xd3, 0x5e, 0xba, 0x7d, 0x5a, 0x60, 0xe4, 0x5d, 0x1f, 0xa7, 0xea, 0xab, 0xc3, 0x5f, 0x5c, 0x2b, 0xa, 0xf, 0x23, 0x79, 0x23, 0x19, 0x53, 0x32, 0x2c, 0x4e},
+               output224: []byte{0x3d, 0x9d, 0x5c, 0x2f, 0xd2, 0xf6, 0xf, 0x4b, 0xb8, 0x9e, 0x11, 0xfd, 0x3b, 0xc2, 0xfb, 0xd6, 0x56, 0x2, 0xeb, 0x3f, 0x3f, 0x38, 0xd6, 0xfa, 0x3, 0xbd, 0xce, 0x2c},
+               output256: []byte{0x58, 0x6c, 0xff, 0xdc, 0x43, 0x43, 0x13, 0xcc, 0x4e, 0x13, 0x3e, 0x85, 0xac, 0x88, 0xb3, 0xe5, 0xde, 0xa7, 0x18, 0x18, 0xab, 0xca, 0xc2, 0x36, 0xf0, 0xaa, 0xe4, 0x18, 0xf7, 0x2b, 0x6c, 0xde},
+               output384: []byte{0xe4, 0x82, 0xb0, 0xc1, 0xb2, 0x5, 0x7f, 0x1b, 0x6b, 0x89, 0x7b, 0xdc, 0x23, 0xd, 0xca, 0x2b, 0x48, 0xff, 0xc0, 0xe4, 0x60, 0xa, 0xc4, 0xa, 0x44, 0xdc, 0xe0, 0x3e, 0x99, 0xa8, 0xd1, 0xdf, 0x94, 0x90, 0x8a, 0x9f, 0xeb, 0xa0, 0x40, 0x5d, 0xa7, 0x95, 0x69, 0xe7, 0x50, 0x59, 0xf9, 0xce},
+               output512: []byte{0xd0, 0xb4, 0x53, 0xfb, 0xe7, 0x9, 0xc6, 0x91, 0x25, 0xdc, 0x8f, 0xe9, 0xe8, 0xae, 0x92, 0x45, 0x21, 0x16, 0x12, 0x97, 0x3, 0x73, 0xb4, 0x54, 0xf8, 0x65, 0x6a, 0x75, 0x5e, 0x84, 0x35, 0xb3, 0x21, 0xdd, 0x3a, 0x98, 0xf, 0xa2, 0x87, 0x19, 0x64, 0x17, 0x47, 0xe2, 0x54, 0xdc, 0x42, 0xc9, 0xbf, 0x1, 0x2b, 0x4d, 0x6d, 0xbd, 0x7e, 0xd1, 0x30, 0x20, 0xa8, 0x3b, 0x44, 0xc5, 0x4, 0xaa}},
+       testcase{
+               msg:       []byte{0xbe, 0xfa, 0xb5, 0x74, 0x39, 0x6d, 0x7f, 0x8b, 0x67, 0x5, 0xe2, 0xd5, 0xb5, 0x8b, 0x2c, 0x1c, 0x82, 0xb, 0xb2, 0x4e, 0x3f, 0x4b, 0xae, 0x3e, 0x8f, 0xbc, 0xd3, 0x6d, 0xbf, 0x73, 0x4e, 0xe1, 0x4e, 0x5d, 0x6a, 0xb9, 0x72, 0xae, 0xdd, 0x35, 0x40, 0x23, 0x54, 0x66, 0xe8, 0x25, 0x85, 0xe, 0xe4, 0xc5, 0x12, 0xea, 0x97, 0x95, 0xab, 0xfd, 0x33, 0xf3, 0x30, 0xd9, 0xfd, 0x7f, 0x79, 0xe6, 0x2b, 0xbb, 0x63, 0xa6, 0xea, 0x85, 0xde, 0x15, 0xbe, 0xae, 0xea, 0x6f, 0x8d, 0x20, 0x4a, 0x28, 0x95, 0x60, 0x59, 0xe2, 0x63, 0x2d, 0x11, 0x86, 0x1d, 0xfb, 0xe, 0x65, 0xbc, 0x7, 0xac, 0x8a, 0x15, 0x93, 0x88, 0xd5, 0xc3, 0x27, 0x7e, 0x22, 0x72, 0x86, 0xf6, 0x5f, 0xf5, 0xe5, 0xb5, 0xae, 0xc1},
+               output224: []byte{0xe1, 0xfa, 0xbe, 0x16, 0x15, 0x25, 0x60, 0x38, 0x7f, 0xad, 0xad, 0x33, 0x24, 0xcb, 0xb9, 0x4d, 0x8a, 0xf9, 0x68, 0x78, 0x6c, 0x3c, 0x99, 0x4c, 0x8f, 0x92, 0x6d, 0x32},
+               output256: []byte{0x52, 0xd1, 0x4a, 0xb9, 0x6b, 0x24, 0xaa, 0x4a, 0x7a, 0x55, 0x72, 0x1a, 0xa8, 0x55, 0xb, 0x1f, 0xcc, 0xac, 0x36, 0x53, 0xc7, 0x82, 0x34, 0x78, 0x3f, 0x72, 0x95, 0xae, 0x5f, 0x39, 0xa1, 0x7a},
+               output384: []byte{0xe5, 0x4b, 0xc3, 0xb2, 0x49, 0xdf, 0xf6, 0x37, 0x0, 0x1b, 0x58, 0xd1, 0x3c, 0xbf, 0x64, 0xf4, 0x53, 0xe0, 0x1a, 0xd6, 0x8a, 0x55, 0x4c, 0xa9, 0x94, 0xf7, 0x1e, 0xc7, 0x10, 0x21, 0x6e, 0xf9, 0x76, 0x9f, 0x1c, 0x8b, 0x46, 0x3d, 0xc7, 0xb4, 0xa9, 0xa, 0xc, 0xea, 0xce, 0xd4, 0x1e, 0x3d},
+               output512: []byte{0xfe, 0x97, 0xc0, 0x11, 0xe5, 0x25, 0x11, 0xe, 0x3, 0x14, 0x9f, 0xac, 0x41, 0x79, 0x89, 0x1a, 0xfc, 0xb6, 0x30, 0x4e, 0x1c, 0xfd, 0x9d, 0x84, 0xcb, 0x73, 0x89, 0x75, 0x55, 0x54, 0xee, 0x72, 0x35, 0x71, 0xd7, 0x6b, 0x80, 0xb9, 0x33, 0x3a, 0x69, 0x58, 0x84, 0x19, 0x23, 0x40, 0xb3, 0xfe, 0x2, 0x2d, 0x4a, 0x23, 0x3b, 0x7a, 0xa8, 0xe8, 0xc7, 0x68, 0x67, 0x45, 0xcf, 0xe7, 0x5e, 0x67}},
+       testcase{
+               msg:       []byte{0x8e, 0x58, 0x14, 0x4f, 0xa9, 0x17, 0x9d, 0x68, 0x64, 0x78, 0x62, 0x2c, 0xe4, 0x50, 0xc7, 0x48, 0x26, 0xc, 0x95, 0xd1, 0xba, 0x43, 0xb8, 0xf9, 0xb5, 0x9a, 0xbe, 0xca, 0x8d, 0x93, 0x48, 0x8d, 0xa7, 0x34, 0x63, 0xef, 0x40, 0x19, 0x8b, 0x4d, 0x16, 0xfb, 0xb, 0x7, 0x7, 0x20, 0x13, 0x47, 0xe0, 0x50, 0x6f, 0xf1, 0x9d, 0x1, 0xbe, 0xa0, 0xf4, 0x2b, 0x8a, 0xf9, 0xe7, 0x1a, 0x1f, 0x1b, 0xd1, 0x68, 0x78, 0x10, 0x69, 0xd4, 0xd3, 0x38, 0xfd, 0xef, 0x0, 0xbf, 0x41, 0x9f, 0xbb, 0x0, 0x30, 0x31, 0xdf, 0x67, 0x1f, 0x4a, 0x37, 0x97, 0x95, 0x64, 0xf6, 0x92, 0x82, 0xde, 0x9c, 0x65, 0x40, 0x78, 0x47, 0xdd, 0xd, 0xa5, 0x5, 0xab, 0x16, 0x41, 0xc0, 0x2d, 0xea, 0x4f, 0xd, 0x83, 0x49, 0x86},
+               output224: []byte{0xce, 0xf8, 0x4f, 0x19, 0x66, 0x21, 0x5b, 0x15, 0x11, 0xf5, 0xe0, 0xdb, 0x56, 0x4d, 0x68, 0x27, 0x89, 0x81, 0x84, 0xfb, 0xcb, 0x88, 0xbe, 0x2, 0x13, 0xfc, 0x56, 0x3f},
+               output256: []byte{0xb6, 0x34, 0x5e, 0xdd, 0x96, 0x60, 0x30, 0xcf, 0x70, 0xdf, 0xb5, 0xb7, 0x55, 0x2b, 0xc1, 0x41, 0xc4, 0x2e, 0xfe, 0x7a, 0x7e, 0x84, 0xf9, 0x57, 0xb1, 0xba, 0xf4, 0x67, 0x1b, 0xae, 0x43, 0x54},
+               output384: []byte{0x1, 0xdc, 0x4c, 0xed, 0x46, 0x93, 0xb3, 0x68, 0x14, 0x44, 0x38, 0x57, 0x93, 0x1c, 0x5d, 0x3c, 0xee, 0x87, 0x62, 0xfd, 0xa0, 0x22, 0xf, 0x8e, 0x9e, 0x63, 0xab, 0x1e, 0xe9, 0xa7, 0x13, 0x5a, 0xde, 0x21, 0xc5, 0xab, 0x37, 0x91, 0x82, 0x13, 0x52, 0xff, 0xbc, 0x32, 0x2f, 0x3e, 0xd2, 0x8},
+               output512: []byte{0x1b, 0xc4, 0xac, 0x8d, 0x97, 0x9c, 0xa6, 0x2a, 0x7f, 0xc8, 0x1c, 0x71, 0xc, 0xed, 0xf6, 0x5a, 0xf5, 0x6c, 0x9b, 0x65, 0x2e, 0xec, 0x35, 0x6a, 0xa9, 0x2d, 0xa9, 0x24, 0xd3, 0x70, 0xfd, 0xeb, 0xdf, 0x7, 0x6f, 0x91, 0xba, 0x4f, 0xe1, 0xec, 0x5c, 0xd7, 0x8f, 0xc4, 0xc8, 0x88, 0x5e, 0xa4, 0x30, 0x4b, 0xa2, 0xe8, 0xe6, 0x49, 0x44, 0xab, 0x4b, 0xf4, 0xd1, 0xb3, 0xd7, 0xde, 0xe7, 0x45}},
+       testcase{
+               msg:       []byte{0xb5, 0x5c, 0x10, 0xea, 0xe0, 0xec, 0x68, 0x4c, 0x16, 0xd1, 0x34, 0x63, 0xf2, 0x92, 0x91, 0xbf, 0x26, 0xc8, 0x2e, 0x2f, 0xa0, 0x42, 0x2a, 0x99, 0xc7, 0x1d, 0xb4, 0xaf, 0x14, 0xdd, 0x9c, 0x7f, 0x33, 0xed, 0xa5, 0x2f, 0xd7, 0x3d, 0x1, 0x7c, 0xc0, 0xf2, 0xdb, 0xe7, 0x34, 0xd8, 0x31, 0xf0, 0xd8, 0x20, 0xd0, 0x6d, 0x5f, 0x89, 0xda, 0xcc, 0x48, 0x57, 0x39, 0x14, 0x4f, 0x8c, 0xfd, 0x47, 0x99, 0x22, 0x3b, 0x1a, 0xff, 0x90, 0x31, 0xa1, 0x5, 0xcb, 0x6a, 0x2, 0x9b, 0xa7, 0x1e, 0x6e, 0x58, 0x67, 0xd8, 0x5a, 0x55, 0x49, 0x91, 0xc3, 0x8d, 0xf3, 0xc9, 0xef, 0x8c, 0x1e, 0x1e, 0x9a, 0x76, 0x30, 0xbe, 0x61, 0xca, 0xab, 0xca, 0x69, 0x28, 0xc, 0x39, 0x9c, 0x1f, 0xb7, 0xa1, 0x2d, 0x12, 0xae, 0xfc},
+               output224: []byte{0x8e, 0x4b, 0x5a, 0x2b, 0x79, 0xfc, 0x1e, 0x7d, 0x5, 0x26, 0xaa, 0xcb, 0x5b, 0x9a, 0xc0, 0x1a, 0x56, 0x96, 0x35, 0x64, 0x4c, 0x92, 0x49, 0xdf, 0xfe, 0xe3, 0xb9, 0x27},
+               output256: []byte{0x3, 0x47, 0x90, 0x19, 0x65, 0xd3, 0x63, 0x50, 0x5, 0xe7, 0x5a, 0x10, 0x95, 0x69, 0x5c, 0xca, 0x5, 0xb, 0xc9, 0xed, 0x2d, 0x44, 0xc, 0x3, 0x72, 0xa3, 0x1b, 0x34, 0x85, 0x14, 0xa8, 0x89},
+               output384: []byte{0x58, 0x7c, 0x81, 0x4, 0x93, 0x6b, 0xdd, 0x74, 0x70, 0x6, 0x66, 0x66, 0x38, 0x43, 0x74, 0x60, 0x15, 0x90, 0x6c, 0xf4, 0xc6, 0x81, 0xc2, 0xa6, 0xff, 0xdd, 0x7, 0xb7, 0x32, 0xe9, 0xe7, 0x78, 0x7b, 0x16, 0x5e, 0x11, 0x7d, 0xa3, 0x40, 0xbc, 0xe4, 0xe2, 0x73, 0x2, 0xba, 0x28, 0x82, 0x99},
+               output512: []byte{0x76, 0xe9, 0x70, 0xe9, 0x44, 0x9d, 0x86, 0x80, 0x67, 0xcd, 0x23, 0xb1, 0xa2, 0x2, 0xcb, 0xdc, 0x99, 0x69, 0x3f, 0xf6, 0xfa, 0x74, 0xba, 0x64, 0x4e, 0xc4, 0x1c, 0xbf, 0x8f, 0xd1, 0x39, 0xcb, 0xf, 0x5d, 0x11, 0x6, 0xfc, 0xd6, 0xc8, 0x71, 0xc3, 0x15, 0xff, 0x41, 0xc3, 0xea, 0xf9, 0x9c, 0x63, 0x62, 0x88, 0xf0, 0xfc, 0xf6, 0xa4, 0xb, 0x48, 0xc, 0xb8, 0x81, 0xd8, 0x7e, 0x9, 0x8f}},
+       testcase{
+               msg:       []byte{0x2e, 0xee, 0xa6, 0x93, 0xf5, 0x85, 0xf4, 0xed, 0x6f, 0x6f, 0x88, 0x65, 0xbb, 0xae, 0x47, 0xa6, 0x90, 0x8a, 0xec, 0xd7, 0xc4, 0x29, 0xe4, 0xbe, 0xc4, 0xf0, 0xde, 0x1d, 0xc, 0xa0, 0x18, 0x3f, 0xa2, 0x1, 0xa0, 0xcb, 0x14, 0xa5, 0x29, 0xb7, 0xd7, 0xac, 0xe, 0x6f, 0xf6, 0x60, 0x7a, 0x32, 0x43, 0xee, 0x9f, 0xb1, 0x1b, 0xcf, 0x3e, 0x23, 0x4, 0xfe, 0x75, 0xff, 0xcd, 0xdd, 0x6c, 0x5c, 0x2e, 0x2a, 0x4c, 0xd4, 0x5f, 0x63, 0xc9, 0x62, 0xd0, 0x10, 0x64, 0x50, 0x58, 0xd3, 0x65, 0x71, 0x40, 0x4a, 0x6d, 0x2b, 0x4f, 0x44, 0x75, 0x54, 0x34, 0xd7, 0x69, 0x98, 0xe8, 0x34, 0x9, 0xc3, 0x20, 0x5a, 0xa1, 0x61, 0x5d, 0xb4, 0x40, 0x57, 0xdb, 0x99, 0x12, 0x31, 0xd2, 0xcb, 0x42, 0x62, 0x45, 0x74, 0xf5, 0x45},
+               output224: []byte{0xba, 0xff, 0x55, 0xcd, 0xad, 0x66, 0xaa, 0x77, 0xad, 0x67, 0x7e, 0x13, 0xa1, 0x38, 0xb2, 0xf1, 0x72, 0x86, 0xb5, 0x4, 0xea, 0x6b, 0x94, 0xef, 0xfd, 0x9d, 0x9a, 0x95},
+               output256: []byte{0xf0, 0xbf, 0x71, 0x5, 0x87, 0xf, 0x23, 0x82, 0xb7, 0x68, 0x63, 0xbb, 0x97, 0xae, 0xe7, 0x9f, 0x95, 0xae, 0xe, 0x81, 0x42, 0x67, 0x5b, 0xbc, 0xcd, 0xb3, 0x47, 0x5b, 0xc, 0x99, 0x35, 0x2f},
+               output384: []byte{0x51, 0x75, 0x33, 0x84, 0xc8, 0xf9, 0x58, 0x4b, 0xe3, 0xed, 0x45, 0x26, 0xb9, 0xb2, 0x9a, 0x97, 0xdc, 0x8a, 0x87, 0xd1, 0x95, 0xd0, 0x15, 0x5e, 0x74, 0x44, 0x95, 0xe, 0xea, 0x55, 0xab, 0xec, 0x5c, 0xd, 0x78, 0x14, 0xf1, 0xdf, 0xce, 0x5c, 0xa4, 0xbf, 0x1d, 0x50, 0xeb, 0xc7, 0x9, 0xad},
+               output512: []byte{0x87, 0x16, 0x66, 0xb2, 0x30, 0xc5, 0xad, 0x75, 0xb9, 0x6d, 0x63, 0xbe, 0x22, 0x87, 0x6, 0x21, 0xc6, 0x8f, 0xd0, 0x89, 0x96, 0x55, 0xba, 0x7d, 0xc0, 0xe0, 0xe5, 0x29, 0x99, 0x15, 0xaf, 0x25, 0x2c, 0x22, 0x6d, 0xd7, 0x21, 0x76, 0x1, 0xd3, 0xa6, 0x88, 0xd, 0x55, 0xee, 0x5a, 0x20, 0xb1, 0x8, 0x20, 0xe2, 0x1c, 0x74, 0xf7, 0x30, 0xee, 0xa9, 0xd4, 0x7f, 0xe2, 0x6d, 0xeb, 0xe0, 0x6}},
+       testcase{
+               msg:       []byte{0xda, 0xb1, 0x1d, 0xc0, 0xb0, 0x47, 0xdb, 0x4, 0x20, 0xa5, 0x85, 0xf5, 0x6c, 0x42, 0xd9, 0x31, 0x75, 0x56, 0x28, 0x52, 0x42, 0x84, 0x99, 0xf6, 0x6a, 0xd, 0xb8, 0x11, 0xfc, 0xdd, 0xda, 0xb2, 0xf7, 0xcd, 0xff, 0xed, 0x15, 0x43, 0xe5, 0xfb, 0x72, 0x11, 0xb, 0x64, 0x68, 0x6b, 0xc7, 0xb6, 0x88, 0x7a, 0x53, 0x8a, 0xd4, 0x4c, 0x5, 0xf, 0x1e, 0x42, 0x63, 0x1b, 0xc4, 0xec, 0x8a, 0x9f, 0x2a, 0x4, 0x71, 0x63, 0xd8, 0x22, 0xa3, 0x89, 0x89, 0xee, 0x4a, 0xab, 0x1, 0xb4, 0xc1, 0xf1, 0x61, 0xb0, 0x62, 0xd8, 0x73, 0xb1, 0xcf, 0xa3, 0x88, 0xfd, 0x30, 0x15, 0x14, 0xf6, 0x22, 0x24, 0x15, 0x7b, 0x9b, 0xef, 0x42, 0x3c, 0x77, 0x83, 0xb7, 0xaa, 0xc8, 0xd3, 0xd, 0x65, 0xcd, 0x1b, 0xba, 0x8d, 0x68, 0x9c, 0x2d},
+               output224: []byte{0xb4, 0xef, 0xbe, 0x11, 0x67, 0x75, 0x5f, 0x5a, 0x75, 0xb7, 0x2c, 0xf1, 0x5e, 0x6, 0x1, 0x66, 0x2d, 0x3, 0x6a, 0x16, 0xca, 0xc8, 0x60, 0x2a, 0x90, 0x9f, 0xb3, 0x28},
+               output256: []byte{0x63, 0x1c, 0x6f, 0x5a, 0xbe, 0x50, 0xb2, 0x7c, 0x9d, 0xea, 0x55, 0x7f, 0xc3, 0xfb, 0xd3, 0xfb, 0x25, 0x78, 0x1f, 0xcb, 0x1b, 0xbf, 0x9f, 0x2e, 0x1, 0xc, 0xca, 0x20, 0xec, 0x52, 0xdb, 0xc4},
+               output384: []byte{0xbd, 0x1e, 0x1e, 0x9a, 0xe8, 0xb, 0x7f, 0xa7, 0x9a, 0xdb, 0xd4, 0x7d, 0x7a, 0x28, 0xba, 0x44, 0xf4, 0x87, 0x41, 0x8, 0xcd, 0x9b, 0xe5, 0xd3, 0x27, 0xcc, 0x93, 0xc6, 0xed, 0x4d, 0xac, 0xf8, 0xa9, 0xe2, 0xa3, 0x49, 0x1d, 0x41, 0x68, 0xbf, 0xfa, 0xe6, 0x3f, 0xb2, 0xf1, 0x7, 0xd, 0xe7},
+               output512: []byte{0x7e, 0x3e, 0xf6, 0x25, 0x52, 0xb2, 0x8a, 0x2b, 0x18, 0xa7, 0x1c, 0xee, 0xf2, 0xdd, 0x86, 0x59, 0xc8, 0xbd, 0xf2, 0x91, 0x38, 0x5a, 0xd0, 0x2f, 0xed, 0x35, 0x37, 0x75, 0xe0, 0x15, 0x94, 0xf2, 0x7c, 0xc2, 0x8c, 0xc7, 0x86, 0x63, 0xe1, 0x7c, 0xb8, 0xb3, 0x9f, 0xd4, 0xea, 0x48, 0xd4, 0x94, 0xad, 0xb, 0xd7, 0xae, 0xe9, 0x27, 0x7e, 0xc9, 0xb2, 0x1e, 0x46, 0x52, 0x38, 0x12, 0x73, 0x6e}},
+       testcase{
+               msg:       []byte{0x42, 0xe9, 0x9a, 0x2f, 0x80, 0xae, 0xe0, 0xe0, 0x1, 0x27, 0x9a, 0x24, 0x34, 0xf7, 0x31, 0xe0, 0x1d, 0x34, 0xa4, 0x4b, 0x1a, 0x81, 0x1, 0x72, 0x69, 0x21, 0xc0, 0x59, 0xc, 0x30, 0xf3, 0x12, 0xe, 0xb8, 0x30, 0x59, 0xf3, 0x25, 0xe8, 0x94, 0xa5, 0xac, 0x95, 0x9d, 0xca, 0x71, 0xce, 0x22, 0x14, 0x79, 0x99, 0x16, 0x42, 0x4e, 0x85, 0x9d, 0x27, 0xd7, 0x89, 0x43, 0x7b, 0x9d, 0x27, 0x24, 0xb, 0xf8, 0xc3, 0x5a, 0xdb, 0xaf, 0xce, 0xcc, 0x32, 0x2b, 0x48, 0xaa, 0x20, 0x5b, 0x29, 0x39, 0x62, 0xd8, 0x58, 0x65, 0x2a, 0xba, 0xcb, 0xd5, 0x88, 0xbc, 0xf6, 0xcb, 0xc3, 0x88, 0xd0, 0x99, 0x3b, 0xd6, 0x22, 0xf9, 0x6e, 0xd5, 0x46, 0x14, 0xc2, 0x5b, 0x6a, 0x9a, 0xa5, 0x27, 0x58, 0x9e, 0xaa, 0xff, 0xcf, 0x17, 0xdd, 0xf7},
+               output224: []byte{0xfa, 0x4b, 0xb6, 0x8, 0xf8, 0xf6, 0x8, 0x41, 0xe1, 0x18, 0x9f, 0x87, 0x70, 0x5, 0x16, 0x95, 0xcd, 0xc9, 0x93, 0x5b, 0xda, 0x71, 0x87, 0xc3, 0x64, 0x19, 0x22, 0x8a},
+               output256: []byte{0x37, 0x57, 0xa5, 0x3d, 0x19, 0x5b, 0x43, 0xb4, 0x3, 0xa7, 0x96, 0xa7, 0x4a, 0xaf, 0xb2, 0x6, 0x40, 0x72, 0xa6, 0x9e, 0x37, 0x2e, 0xe5, 0xb3, 0x6c, 0xc2, 0xb7, 0xa7, 0x91, 0xf7, 0x5c, 0x9f},
+               output384: []byte{0x6b, 0x7c, 0x11, 0x44, 0xfa, 0x98, 0x42, 0x61, 0x37, 0x7d, 0xba, 0xac, 0xa7, 0x8a, 0x3, 0xae, 0x58, 0xb, 0x7f, 0x3a, 0x17, 0xd6, 0x9b, 0xa0, 0xd5, 0x6e, 0xe9, 0x8, 0xdd, 0x9e, 0xc9, 0xf8, 0x7e, 0xa3, 0xa, 0x76, 0x26, 0xed, 0x7c, 0xcf, 0x25, 0xb5, 0x3a, 0x69, 0x94, 0xe1, 0x21, 0xe8},
+               output512: []byte{0xb, 0x87, 0xf6, 0xeb, 0xaa, 0x29, 0x3f, 0xf7, 0x9c, 0x87, 0x38, 0x20, 0x84, 0x6c, 0xf, 0xcc, 0x94, 0x3e, 0x3a, 0x83, 0xbd, 0x81, 0x11, 0x93, 0x1f, 0xf0, 0x3f, 0xf3, 0xb0, 0xbf, 0x78, 0x5c, 0x96, 0x1c, 0xa8, 0x4c, 0xf3, 0xfd, 0x40, 0xe0, 0xd8, 0x31, 0xdb, 0xae, 0xa5, 0x95, 0x49, 0x8f, 0xc1, 0x2d, 0xa8, 0x8c, 0xc5, 0x7, 0xde, 0x72, 0xa, 0x35, 0xc0, 0x1d, 0x73, 0xfc, 0x95, 0x95}},
+       testcase{
+               msg:       []byte{0x3c, 0x9b, 0x46, 0x45, 0xc, 0xf, 0x2c, 0xae, 0x8e, 0x38, 0x23, 0xf8, 0xbd, 0xb4, 0x27, 0x7f, 0x31, 0xb7, 0x44, 0xce, 0x2e, 0xb1, 0x70, 0x54, 0xbd, 0xdc, 0x6d, 0xff, 0x36, 0xaf, 0x7f, 0x49, 0xfb, 0x8a, 0x23, 0x20, 0xcc, 0x3b, 0xdf, 0x8e, 0xa, 0x2e, 0xa2, 0x9a, 0xd3, 0xa5, 0x5d, 0xe1, 0x16, 0x5d, 0x21, 0x9a, 0xde, 0xdd, 0xb5, 0x17, 0x52, 0x53, 0xe2, 0xd1, 0x48, 0x9e, 0x9b, 0x6f, 0xdd, 0x2, 0xe2, 0xc3, 0xd3, 0xa4, 0xb5, 0x4d, 0x60, 0xe3, 0xa4, 0x73, 0x34, 0xc3, 0x79, 0x13, 0xc5, 0x69, 0x53, 0x78, 0xa6, 0x69, 0xe9, 0xb7, 0x2d, 0xec, 0x32, 0xaf, 0x54, 0x34, 0xf9, 0x3f, 0x46, 0x17, 0x6e, 0xbf, 0x4, 0x4c, 0x47, 0x84, 0x46, 0x7c, 0x70, 0x4, 0x70, 0xd0, 0xc0, 0xb4, 0xc, 0x8a, 0x8, 0x8c, 0x81, 0x58, 0x16},
+               output224: []byte{0xb3, 0xa8, 0x77, 0x23, 0x15, 0x19, 0xc2, 0x4e, 0x2e, 0xfa, 0x42, 0x4e, 0x60, 0x57, 0x12, 0x8e, 0xa1, 0x5, 0xb5, 0x4c, 0x65, 0xe5, 0x80, 0x74, 0xb5, 0xb1, 0x58, 0x3c},
+               output256: []byte{0xc, 0xc9, 0x3, 0xac, 0xbc, 0xed, 0x72, 0x4b, 0x22, 0x1d, 0x34, 0x87, 0x7d, 0x1d, 0x14, 0x27, 0x18, 0x2f, 0x94, 0x93, 0xa3, 0x3d, 0xf7, 0x75, 0x87, 0x20, 0xe8, 0xbf, 0xc7, 0xaf, 0x98, 0xee},
+               output384: []byte{0x76, 0x41, 0x4f, 0x3b, 0x9e, 0x4f, 0xf8, 0xd1, 0x50, 0x28, 0xc, 0x8e, 0x44, 0xbc, 0x54, 0x5, 0x68, 0x49, 0xb2, 0x53, 0x51, 0x35, 0x2d, 0x9d, 0x9e, 0x98, 0x6b, 0x3e, 0xcb, 0x6e, 0xc0, 0x50, 0x54, 0x27, 0x9, 0xaf, 0xe0, 0x19, 0x79, 0xd2, 0xeb, 0x97, 0xe5, 0x1d, 0x41, 0x21, 0x7e, 0x6e},
+               output512: []byte{0x68, 0x1b, 0xab, 0xbd, 0x2e, 0x35, 0x15, 0x1, 0xc2, 0x85, 0x81, 0x2e, 0x6, 0xf2, 0x9, 0x40, 0xfd, 0x86, 0x55, 0x16, 0xcf, 0x2, 0x8b, 0x47, 0x87, 0xd1, 0xff, 0xcc, 0xd0, 0xd5, 0x37, 0x70, 0x5e, 0x8e, 0x9b, 0x73, 0xc6, 0x8, 0xd5, 0xa8, 0xdc, 0x4f, 0x8, 0xee, 0xe0, 0x90, 0x2a, 0xc1, 0x29, 0x36, 0xdd, 0xb8, 0xc7, 0xb2, 0x92, 0x28, 0xc6, 0xaa, 0xf8, 0xd0, 0xb9, 0x9, 0xc3, 0xd}},
+       testcase{
+               msg:       []byte{0xd1, 0xe6, 0x54, 0xb7, 0x7c, 0xb1, 0x55, 0xf5, 0xc7, 0x79, 0x71, 0xa6, 0x4d, 0xf9, 0xe5, 0xd3, 0x4c, 0x26, 0xa3, 0xca, 0xd6, 0xc7, 0xf6, 0xb3, 0x0, 0xd3, 0x9d, 0xeb, 0x19, 0x10, 0x9, 0x46, 0x91, 0xad, 0xaa, 0x9, 0x5b, 0xe4, 0xba, 0x5d, 0x86, 0x69, 0xa, 0x97, 0x64, 0x28, 0x63, 0x5d, 0x55, 0x26, 0xf3, 0xe9, 0x46, 0xf7, 0xdc, 0x3b, 0xd4, 0xdb, 0xc7, 0x89, 0x99, 0xe6, 0x53, 0x44, 0x11, 0x87, 0xa8, 0x1f, 0x9a, 0xdc, 0xd5, 0xa3, 0xc5, 0xf2, 0x54, 0xbc, 0x82, 0x56, 0xb0, 0x15, 0x8f, 0x54, 0x67, 0x3d, 0xcc, 0x12, 0x32, 0xf6, 0xe9, 0x18, 0xeb, 0xfc, 0x6c, 0x51, 0xce, 0x67, 0xea, 0xeb, 0x4, 0x2d, 0x9f, 0x57, 0xee, 0xc4, 0xbf, 0xe9, 0x10, 0xe1, 0x69, 0xaf, 0x78, 0xb3, 0xde, 0x48, 0xd1, 0x37, 0xdf, 0x4f, 0x28, 0x40},
+               output224: []byte{0x9f, 0x38, 0x5c, 0xb, 0x64, 0x5d, 0xb8, 0xdb, 0x8b, 0x73, 0xc9, 0x8c, 0x40, 0xbe, 0x26, 0x4f, 0xfe, 0xe6, 0x15, 0x1c, 0x7b, 0x5a, 0x9, 0x64, 0xe6, 0x7d, 0xaa, 0x9f},
+               output256: []byte{0xf2, 0x37, 0x50, 0xc3, 0x29, 0x73, 0xf2, 0x4c, 0x24, 0x22, 0xf4, 0xe2, 0xb4, 0x35, 0x89, 0xd9, 0xe7, 0x6d, 0x6a, 0x57, 0x59, 0x38, 0xe0, 0x1a, 0x96, 0xae, 0x8e, 0x73, 0xd0, 0x26, 0x56, 0x9c},
+               output384: []byte{0x92, 0xac, 0x60, 0xe5, 0xdc, 0x49, 0x20, 0x10, 0xa4, 0x5f, 0x46, 0xae, 0xf0, 0x5f, 0x40, 0x3f, 0x75, 0x69, 0xe1, 0xb4, 0xe2, 0xd0, 0xc9, 0x9, 0xc8, 0x71, 0xa7, 0x83, 0xfc, 0x12, 0x45, 0x7d, 0xe2, 0x81, 0xaf, 0xf4, 0xc4, 0xce, 0xe0, 0x20, 0x7d, 0x20, 0xea, 0xf5, 0x46, 0x28, 0x50, 0x70},
+               output512: []byte{0xc4, 0x6d, 0x22, 0x62, 0xf1, 0x86, 0x42, 0x1d, 0x7, 0xfd, 0x74, 0xf, 0x92, 0x23, 0x6, 0xd9, 0x9b, 0x1e, 0x38, 0x26, 0xf6, 0xa3, 0x24, 0x86, 0xbe, 0x5a, 0x91, 0xdc, 0x29, 0x8f, 0x17, 0x7f, 0x50, 0x91, 0x5e, 0x17, 0xeb, 0x4e, 0xa2, 0xe4, 0x54, 0x94, 0xc5, 0x1, 0x73, 0x6c, 0xef, 0xb0, 0xe2, 0x2a, 0xcd, 0x98, 0x9d, 0xa4, 0x1a, 0xc7, 0xbb, 0x7b, 0xe5, 0x6b, 0x4, 0xbf, 0xb5, 0xe1}},
+       testcase{
+               msg:       []byte{0x62, 0x6f, 0x68, 0xc1, 0x8a, 0x69, 0xa6, 0x59, 0x1, 0x59, 0xa9, 0xc4, 0x6b, 0xe0, 0x3d, 0x59, 0x65, 0x69, 0x8f, 0x2d, 0xac, 0x3d, 0xe7, 0x79, 0xb8, 0x78, 0xb3, 0xd9, 0xc4, 0x21, 0xe0, 0xf2, 0x1b, 0x95, 0x5a, 0x16, 0xc7, 0x15, 0xc1, 0xec, 0x1e, 0x22, 0xce, 0x3e, 0xb6, 0x45, 0xb8, 0xb4, 0xf2, 0x63, 0xf6, 0x6, 0x60, 0xea, 0x30, 0x28, 0x98, 0x1e, 0xeb, 0xd6, 0xc8, 0xc3, 0xa3, 0x67, 0x28, 0x5b, 0x69, 0x1c, 0x8e, 0xe5, 0x69, 0x44, 0xa7, 0xcd, 0x12, 0x17, 0x99, 0x7e, 0x1d, 0x9c, 0x21, 0x62, 0xb, 0x53, 0x6b, 0xdb, 0xd5, 0xde, 0x89, 0x25, 0xff, 0x71, 0xde, 0xc6, 0xfb, 0xc0, 0x66, 0x24, 0xab, 0x6b, 0x21, 0xe3, 0x29, 0x81, 0x3d, 0xe9, 0xd, 0x1e, 0x57, 0x2d, 0xfb, 0x89, 0xa1, 0x81, 0x20, 0xc3, 0xf6, 0x6, 0x35, 0x5d, 0x25},
+               output224: []byte{0xbd, 0x6c, 0x86, 0x59, 0x93, 0x8, 0x2e, 0xc7, 0xb3, 0x80, 0x8c, 0x13, 0xfd, 0x14, 0xf, 0xe0, 0xc0, 0x66, 0x7b, 0x3e, 0xe5, 0x1b, 0x9f, 0x8f, 0x1f, 0x4d, 0xff, 0xd8},
+               output256: []byte{0x1e, 0xce, 0x87, 0xe4, 0x4a, 0x99, 0xf5, 0x9d, 0x26, 0x41, 0x14, 0x18, 0xfb, 0x87, 0x93, 0x68, 0x9f, 0xf8, 0xa9, 0xc6, 0xef, 0x75, 0x59, 0x90, 0x56, 0x8, 0x7d, 0x8c, 0x99, 0x5b, 0xce, 0x1e},
+               output384: []byte{0x8f, 0x99, 0x3, 0x2c, 0xb4, 0x9b, 0xb0, 0x22, 0xee, 0x5f, 0xb3, 0x24, 0x46, 0xe1, 0xd3, 0x9a, 0xa0, 0xfc, 0xd7, 0x49, 0x74, 0x1e, 0x47, 0x96, 0x97, 0x9d, 0x4b, 0xea, 0x5a, 0xb1, 0xb0, 0x4d, 0x24, 0x15, 0x92, 0xec, 0x60, 0x58, 0xe5, 0x4b, 0x8e, 0xc9, 0xea, 0xb2, 0x74, 0xee, 0x63, 0x2d},
+               output512: []byte{0xb, 0x3d, 0xbc, 0x77, 0x3, 0x32, 0x82, 0x3e, 0x68, 0x64, 0x70, 0xd8, 0x42, 0x10, 0x4d, 0x3b, 0x3c, 0x14, 0x52, 0xf6, 0x4f, 0x1b, 0xcc, 0x71, 0xc5, 0xf3, 0xfa, 0xd1, 0xc0, 0xd9, 0x3f, 0x21, 0xef, 0xbd, 0x48, 0xd7, 0x3c, 0x7d, 0x49, 0x9, 0x22, 0x7b, 0x6, 0xb0, 0x6d, 0x54, 0x5, 0x7a, 0x74, 0xe0, 0x3c, 0x36, 0xd9, 0xc1, 0x6, 0xeb, 0xa7, 0x94, 0x11, 0xf1, 0xe6, 0xe1, 0xcf, 0xfe}},
+       testcase{
+               msg:       []byte{0x65, 0x1a, 0x6f, 0xb3, 0xc4, 0xb8, 0xc, 0x7c, 0x68, 0xc6, 0x1, 0x16, 0x75, 0xe6, 0x9, 0x4e, 0xb5, 0x6a, 0xbf, 0x5f, 0xc3, 0x5, 0x73, 0x24, 0xeb, 0xc6, 0x47, 0x78, 0x25, 0x6, 0x1f, 0x9f, 0x27, 0xe7, 0xa9, 0x46, 0x33, 0xab, 0xd1, 0xfa, 0x59, 0x8a, 0x74, 0x6e, 0x4a, 0x57, 0x7c, 0xaf, 0x52, 0x4c, 0x52, 0xec, 0x17, 0x88, 0x47, 0x1f, 0x92, 0xb8, 0xc3, 0x7f, 0x23, 0x79, 0x5c, 0xa1, 0x9d, 0x55, 0x9d, 0x44, 0x6c, 0xab, 0x16, 0xcb, 0xcd, 0xce, 0x90, 0xb7, 0x9f, 0xa1, 0x2, 0x6c, 0xee, 0x77, 0xbf, 0x4a, 0xb1, 0xb5, 0x3, 0xc5, 0xb9, 0x4c, 0x22, 0x56, 0xad, 0x75, 0xb3, 0xea, 0xc6, 0xfd, 0x5d, 0xcb, 0x96, 0xac, 0xa4, 0xb0, 0x3a, 0x83, 0x4b, 0xfb, 0x4e, 0x9a, 0xf9, 0x88, 0xce, 0xcb, 0xf2, 0xae, 0x59, 0x7c, 0xb9, 0x9, 0x79, 0x40},
+               output224: []byte{0x8c, 0xa8, 0x44, 0xac, 0xfc, 0xaa, 0xbd, 0x3b, 0x96, 0x9f, 0x86, 0xc2, 0xf1, 0xec, 0xdf, 0x16, 0x20, 0x57, 0x4e, 0xc8, 0xc2, 0x44, 0x26, 0xbe, 0x2d, 0xcc, 0x1b, 0xb5},
+               output256: []byte{0x71, 0xb4, 0xf9, 0xa, 0xc9, 0x21, 0x5d, 0x74, 0x74, 0xb1, 0x19, 0x7d, 0x1b, 0x8b, 0x24, 0x44, 0x9f, 0xd5, 0x7e, 0x9b, 0x5, 0x48, 0x3d, 0x32, 0xed, 0xbe, 0xbc, 0xb2, 0x1a, 0x82, 0xf8, 0x66},
+               output384: []byte{0x8b, 0xb4, 0xf3, 0xcf, 0x3, 0x90, 0xa3, 0x1d, 0x68, 0x22, 0x13, 0xd2, 0x23, 0x54, 0xdf, 0xe7, 0xd5, 0x80, 0xc8, 0x11, 0x68, 0x22, 0x59, 0x87, 0x2f, 0x2a, 0x29, 0xa0, 0x8d, 0x37, 0x3f, 0xd9, 0x98, 0xf8, 0x42, 0x33, 0x4f, 0x64, 0xf8, 0x13, 0x49, 0x36, 0x4a, 0x93, 0xc, 0x82, 0xba, 0xd4},
+               output512: []byte{0xca, 0x46, 0x27, 0x6b, 0xd, 0xc2, 0xec, 0x44, 0x24, 0xbb, 0x71, 0x36, 0xea, 0xe1, 0xaf, 0x20, 0x7b, 0xd6, 0xe5, 0xcd, 0x83, 0x36, 0x91, 0xc7, 0xd3, 0x7b, 0x2c, 0xae, 0xaf, 0x4f, 0x48, 0x4b, 0x96, 0xa3, 0x47, 0x6f, 0xc2, 0x5f, 0xeb, 0x20, 0x6a, 0xd3, 0x7c, 0xf9, 0x75, 0x38, 0x3d, 0xd5, 0x22, 0xca, 0xc, 0xc6, 0x20, 0xa, 0x38, 0x67, 0xfe, 0xe7, 0xf1, 0x78, 0xd6, 0x95, 0x3f, 0xef}},
+       testcase{
+               msg:       []byte{0x8a, 0xaf, 0x7, 0x2f, 0xce, 0x8a, 0x2d, 0x96, 0xbc, 0x10, 0xb3, 0xc9, 0x1c, 0x80, 0x9e, 0xe9, 0x30, 0x72, 0xfb, 0x20, 0x5c, 0xa7, 0xf1, 0xa, 0xbd, 0x82, 0xec, 0xd8, 0x2c, 0xf0, 0x40, 0xb1, 0xbc, 0x49, 0xea, 0x13, 0xd1, 0x85, 0x78, 0x15, 0xc0, 0xe9, 0x97, 0x81, 0xde, 0x3a, 0xdb, 0xb5, 0x44, 0x3c, 0xe1, 0xc8, 0x97, 0xe5, 0x51, 0x88, 0xce, 0xaf, 0x22, 0x1a, 0xa9, 0x68, 0x16, 0x38, 0xde, 0x5, 0xae, 0x1b, 0x32, 0x29, 0x38, 0xf4, 0x6b, 0xce, 0x51, 0x54, 0x3b, 0x57, 0xec, 0xdb, 0x4c, 0x26, 0x62, 0x72, 0x25, 0x9d, 0x17, 0x98, 0xde, 0x13, 0xbe, 0x90, 0xe1, 0xe, 0xfe, 0xc2, 0xd0, 0x74, 0x84, 0xd9, 0xb2, 0x1a, 0x38, 0x70, 0xe2, 0xaa, 0x9e, 0x6, 0xc2, 0x1a, 0xa2, 0xd0, 0xc9, 0xcf, 0x42, 0x0, 0x80, 0xa8, 0xa, 0x91, 0xde, 0xe1, 0x6f},
+               output224: []byte{0xe8, 0xd5, 0x49, 0xff, 0x8d, 0x53, 0x74, 0x5a, 0x4c, 0x5c, 0x75, 0xbd, 0xad, 0x92, 0x31, 0x40, 0x25, 0xda, 0x87, 0x7a, 0x77, 0xce, 0x49, 0xea, 0x13, 0x48, 0x40, 0xfa},
+               output256: []byte{0x3b, 0x36, 0x78, 0xbb, 0x11, 0x6f, 0xad, 0xab, 0x48, 0x42, 0x91, 0xf0, 0xcf, 0x97, 0x26, 0x6, 0x52, 0x35, 0x1, 0xf5, 0xb4, 0x5d, 0x51, 0x6, 0x37, 0x97, 0x97, 0x29, 0x28, 0xe3, 0x33, 0xc0},
+               output384: []byte{0xb, 0xb7, 0xda, 0xc5, 0x44, 0x56, 0x9e, 0x6e, 0xb7, 0x4a, 0xca, 0xb0, 0x1a, 0x84, 0x6f, 0x74, 0xad, 0x2a, 0xf, 0x31, 0xd8, 0xfa, 0xce, 0xe4, 0xd0, 0x9f, 0xa4, 0x9c, 0x81, 0xb9, 0x3b, 0xd8, 0x3b, 0x4f, 0x12, 0x9b, 0x96, 0xda, 0x4c, 0xe, 0xaf, 0x16, 0x5f, 0xde, 0x52, 0xef, 0x29, 0x5b},
+               output512: []byte{0x81, 0x5b, 0x44, 0x66, 0x8b, 0xf3, 0x75, 0x1a, 0x33, 0x92, 0x94, 0xf, 0xca, 0x54, 0xc1, 0xe3, 0xe4, 0xef, 0x52, 0x27, 0xb0, 0x52, 0x33, 0x2a, 0xfe, 0x6e, 0xb7, 0xa1, 0xa, 0xc8, 0xad, 0x64, 0x38, 0xce, 0x8a, 0x2, 0x77, 0xaa, 0x14, 0xbc, 0xc4, 0x15, 0x90, 0xf6, 0xd6, 0xa1, 0xb, 0x6b, 0x1b, 0xab, 0xe6, 0xbb, 0x4f, 0x8d, 0x77, 0x7e, 0xa5, 0x76, 0xd6, 0x34, 0xb0, 0xbe, 0x41, 0xc0}},
+       testcase{
+               msg:       []byte{0x53, 0xf9, 0x18, 0xfd, 0x0, 0xb1, 0x70, 0x1b, 0xd5, 0x4, 0xf8, 0xcd, 0xea, 0x80, 0x3a, 0xcc, 0xa2, 0x1a, 0xc1, 0x8c, 0x56, 0x4a, 0xb9, 0xc, 0x2a, 0x17, 0xda, 0x59, 0x2c, 0x7d, 0x69, 0x68, 0x8f, 0x65, 0x80, 0x57, 0x53, 0x95, 0x55, 0x1e, 0x8c, 0xd3, 0x3e, 0xf, 0xef, 0x8, 0xca, 0x6e, 0xd4, 0x58, 0x8d, 0x4d, 0x14, 0xb, 0x3e, 0x44, 0xc0, 0x32, 0x35, 0x5d, 0xf1, 0xc5, 0x31, 0x56, 0x4d, 0x7f, 0x48, 0x35, 0x75, 0x33, 0x44, 0x34, 0x5a, 0x67, 0x81, 0xe1, 0x1c, 0xd5, 0xe0, 0x95, 0xb7, 0x3d, 0xf5, 0xf8, 0x2c, 0x8a, 0xe3, 0xad, 0x0, 0x87, 0x79, 0x36, 0x89, 0x66, 0x71, 0xe9, 0x47, 0xcc, 0x52, 0xe2, 0xb2, 0x9d, 0xcd, 0x46, 0x3d, 0x90, 0xa0, 0xc9, 0x92, 0x91, 0x28, 0xda, 0x22, 0x2b, 0x5a, 0x21, 0x14, 0x50, 0xbb, 0xc0, 0xe0, 0x24, 0x48, 0xe2},
+               output224: []byte{0xe6, 0xbd, 0x80, 0x78, 0x7f, 0x87, 0x4, 0xff, 0xf7, 0x31, 0x12, 0xe8, 0xb3, 0x68, 0xad, 0xfb, 0xa3, 0xa1, 0x10, 0x91, 0x62, 0xc7, 0x69, 0x49, 0x13, 0x49, 0xdc, 0xef},
+               output256: []byte{0x40, 0x68, 0x24, 0x64, 0x95, 0xf5, 0x8, 0x89, 0x78, 0x13, 0x33, 0x29, 0x62, 0xd3, 0xae, 0xb, 0x84, 0x68, 0x50, 0x45, 0xe8, 0x32, 0xa9, 0xa3, 0x9a, 0xd5, 0xe9, 0x4c, 0x15, 0x4d, 0x26, 0x79},
+               output384: []byte{0x10, 0xdd, 0x93, 0x48, 0xb2, 0xd9, 0x58, 0x89, 0xee, 0x61, 0x39, 0x7, 0x82, 0x4a, 0x10, 0xef, 0xc7, 0x8, 0xa1, 0x1, 0xa6, 0x76, 0x72, 0xfc, 0xa4, 0xc6, 0x53, 0x9f, 0x51, 0x56, 0xc7, 0xdf, 0x80, 0x5d, 0xbe, 0x66, 0x6f, 0xcf, 0x4c, 0xc5, 0x78, 0xf4, 0x21, 0xae, 0x3c, 0xf2, 0x71, 0x22},
+               output512: []byte{0xf4, 0x77, 0x99, 0xa8, 0x54, 0x7f, 0xc9, 0xc0, 0x7d, 0xf, 0x80, 0x80, 0x29, 0xe7, 0x33, 0x56, 0x7, 0xd7, 0x22, 0x24, 0xbe, 0x28, 0x6e, 0x11, 0x86, 0x57, 0xbd, 0x13, 0xa2, 0xc5, 0x1d, 0x3, 0x74, 0x42, 0x6d, 0x9e, 0xeb, 0x76, 0x93, 0xbd, 0xe5, 0xec, 0x61, 0x81, 0x57, 0x4c, 0x14, 0x4, 0xdf, 0x29, 0xbf, 0x96, 0x94, 0x18, 0x62, 0xba, 0x1a, 0xa, 0x9a, 0x59, 0x3, 0x31, 0x94, 0x98}},
+       testcase{
+               msg:       []byte{0xa6, 0x45, 0x99, 0xb8, 0xa6, 0x1b, 0x5c, 0xce, 0xc9, 0xe6, 0x7a, 0xed, 0x69, 0x44, 0x74, 0x59, 0xc8, 0xda, 0x3d, 0x1e, 0xc6, 0xc7, 0xc7, 0xc8, 0x2a, 0x74, 0x28, 0xb9, 0xb5, 0x84, 0xfa, 0x67, 0xe9, 0xf, 0x68, 0xe2, 0xc0, 0xf, 0xbb, 0xed, 0x46, 0x13, 0x66, 0x6e, 0x51, 0x68, 0xda, 0x4a, 0x16, 0xf3, 0x95, 0xf7, 0xa3, 0xc3, 0x83, 0x2b, 0x3b, 0x13, 0x4b, 0xfc, 0x9c, 0xba, 0xa9, 0x5d, 0x2a, 0xf, 0xe2, 0x52, 0xf4, 0x4a, 0xc6, 0x68, 0x1e, 0xb6, 0xd4, 0xa, 0xb9, 0x1c, 0x1d, 0x2, 0x82, 0xfe, 0xd6, 0x70, 0x1c, 0x57, 0x46, 0x3d, 0x3c, 0x5f, 0x2b, 0xb8, 0xc6, 0xa7, 0x30, 0x1f, 0xb4, 0x57, 0x6a, 0xa3, 0xb5, 0xf1, 0x55, 0x10, 0xdb, 0x89, 0x56, 0xff, 0x77, 0x47, 0x8c, 0x26, 0xa7, 0xc0, 0x9b, 0xea, 0x7b, 0x39, 0x8c, 0xfc, 0x83, 0x50, 0x3f, 0x53, 0x8e},
+               output224: []byte{0xbd, 0x7d, 0x9e, 0x6c, 0xf9, 0xd2, 0xc1, 0x3, 0xf, 0x89, 0x25, 0x33, 0xe0, 0x1b, 0x72, 0xb5, 0x28, 0x8e, 0x17, 0x4b, 0x8, 0x64, 0xd8, 0x1d, 0x71, 0xf8, 0xc6, 0xe6},
+               output256: []byte{0x82, 0x69, 0x62, 0x59, 0x53, 0x65, 0x20, 0xe5, 0xe4, 0xd4, 0x7e, 0x10, 0x6b, 0xd1, 0xdc, 0xb3, 0x97, 0x52, 0x9a, 0xaf, 0xb7, 0x58, 0x78, 0xf3, 0x32, 0xd2, 0xaf, 0x26, 0x84, 0x49, 0x3f, 0x1b},
+               output384: []byte{0x44, 0x4b, 0x8a, 0x6f, 0x1e, 0xe1, 0x18, 0xde, 0x3f, 0xb3, 0xec, 0x76, 0xb2, 0xfb, 0xad, 0x9e, 0xf3, 0x19, 0x16, 0xe1, 0xf9, 0x90, 0x77, 0xde, 0xfc, 0x51, 0xc2, 0xe5, 0x9c, 0x8e, 0x6a, 0x3e, 0x20, 0x7b, 0xa4, 0x8e, 0x5e, 0xdd, 0x66, 0xc7, 0x2b, 0x5b, 0xeb, 0xa6, 0x74, 0x1, 0xd7, 0x94},
+               output512: []byte{0x8a, 0xa, 0xe1, 0x2a, 0x9e, 0x79, 0x7f, 0xb7, 0xbd, 0x46, 0xcb, 0xb9, 0x10, 0x7, 0x6a, 0x32, 0x87, 0x3b, 0xff, 0xcb, 0x9a, 0xd9, 0x8b, 0x4f, 0xc3, 0x73, 0x16, 0xae, 0xd6, 0x81, 0xec, 0x49, 0xc6, 0x5a, 0xbb, 0xb9, 0x58, 0x64, 0x5, 0xff, 0x96, 0xcc, 0x80, 0xda, 0x4b, 0xb8, 0xfa, 0x73, 0xbe, 0x1b, 0xa9, 0xe7, 0x37, 0x59, 0x5b, 0x23, 0x7, 0xcf, 0x36, 0x9d, 0x61, 0xba, 0xf5, 0x9c}},
+       testcase{
+               msg:       []byte{0xe, 0x3a, 0xb0, 0xe0, 0x54, 0x73, 0x9b, 0x0, 0xcd, 0xb6, 0xa8, 0x7b, 0xd1, 0x2c, 0xae, 0x2, 0x4b, 0x54, 0xcb, 0x5e, 0x55, 0xe, 0x6c, 0x42, 0x53, 0x60, 0xc2, 0xe8, 0x7e, 0x59, 0x40, 0x1f, 0x5e, 0xc2, 0x4e, 0xf0, 0x31, 0x48, 0x55, 0xf0, 0xf5, 0x6c, 0x47, 0x69, 0x5d, 0x56, 0xa7, 0xfb, 0x14, 0x17, 0x69, 0x3a, 0xf2, 0xa1, 0xed, 0x52, 0x91, 0xf2, 0xfe, 0xe9, 0x5f, 0x75, 0xee, 0xd5, 0x4a, 0x1b, 0x1c, 0x2e, 0x81, 0x22, 0x6f, 0xbf, 0xf6, 0xf6, 0x3a, 0xde, 0x58, 0x49, 0x11, 0xc7, 0x19, 0x67, 0xa8, 0xeb, 0x70, 0x93, 0x3b, 0xc3, 0xf5, 0xd1, 0x5b, 0xc9, 0x1b, 0x5c, 0x26, 0x44, 0xd9, 0x51, 0x6d, 0x3c, 0x3a, 0x8c, 0x15, 0x4e, 0xe4, 0x8e, 0x11, 0x8b, 0xd1, 0x44, 0x2c, 0x4, 0x3c, 0x7a, 0xd, 0xba, 0x5a, 0xc5, 0xb1, 0xd5, 0x36, 0xa, 0xae, 0x5b, 0x90, 0x65},
+               output224: []byte{0xa5, 0x31, 0x2e, 0x8c, 0x7f, 0xa, 0x35, 0x94, 0xa8, 0xec, 0xd1, 0xab, 0xc5, 0xcb, 0xc1, 0x4b, 0x25, 0x85, 0xf0, 0xb1, 0xfe, 0x32, 0xa4, 0xe1, 0xfa, 0xa, 0x2e, 0x25},
+               output256: []byte{0xb4, 0x94, 0x85, 0x26, 0x3, 0x39, 0x3b, 0x2b, 0x71, 0x84, 0x5b, 0xac, 0xbd, 0xce, 0x89, 0xfa, 0x14, 0x27, 0xdf, 0xe4, 0xaf, 0x9c, 0xdf, 0x92, 0x5d, 0x4f, 0x93, 0xfa, 0x83, 0xb9, 0x96, 0x6b},
+               output384: []byte{0xf4, 0xd1, 0x7c, 0x62, 0x99, 0xba, 0xe7, 0xd0, 0xe6, 0xd1, 0x5a, 0x55, 0xb, 0x31, 0x1f, 0x30, 0xc1, 0xb0, 0x38, 0xae, 0xf5, 0x6f, 0xe3, 0x75, 0xf3, 0xb4, 0xba, 0xe1, 0x4f, 0x7e, 0xa4, 0x27, 0xc5, 0xaa, 0x98, 0x7e, 0xf9, 0x32, 0x85, 0x97, 0x5c, 0xe5, 0xf9, 0xe4, 0x6a, 0x3e, 0x4c, 0x20},
+               output512: []byte{0xa3, 0xc6, 0xd5, 0x88, 0x72, 0xba, 0xfd, 0xed, 0xfd, 0xd5, 0xc, 0x3, 0x9, 0x8, 0x92, 0x40, 0xd6, 0x97, 0x7d, 0x4d, 0x3d, 0x59, 0xfb, 0x3f, 0x2b, 0xe1, 0x33, 0xc5, 0x7d, 0x2d, 0xfc, 0xfc, 0xc7, 0xc0, 0x27, 0x29, 0x6f, 0x74, 0xfe, 0x58, 0xb2, 0xa9, 0xa6, 0xcb, 0x7e, 0x5d, 0x70, 0x8, 0x89, 0x34, 0xd0, 0x51, 0xcb, 0xa5, 0x70, 0x1, 0xfe, 0x27, 0x96, 0x5c, 0xfa, 0x7, 0x1a, 0x6f}},
+       testcase{
+               msg:       []byte{0xa6, 0x2f, 0xc5, 0x95, 0xb4, 0x9, 0x6e, 0x63, 0x36, 0xe5, 0x3f, 0xcd, 0xfc, 0x8d, 0x1c, 0xc1, 0x75, 0xd7, 0x1d, 0xac, 0x9d, 0x75, 0xa, 0x61, 0x33, 0xd2, 0x31, 0x99, 0xea, 0xac, 0x28, 0x82, 0x7, 0x94, 0x4c, 0xea, 0x6b, 0x16, 0xd2, 0x76, 0x31, 0x91, 0x5b, 0x46, 0x19, 0xf7, 0x43, 0xda, 0x2e, 0x30, 0xa0, 0xc0, 0xb, 0xbd, 0xb1, 0xbb, 0xb3, 0x5a, 0xb8, 0x52, 0xef, 0x3b, 0x9a, 0xec, 0x6b, 0xa, 0x8d, 0xcc, 0x6e, 0x9e, 0x1a, 0xba, 0xa3, 0xad, 0x62, 0xac, 0xa, 0x6c, 0x5d, 0xe7, 0x65, 0xde, 0x2c, 0x37, 0x11, 0xb7, 0x69, 0xe3, 0xfd, 0xe4, 0x4a, 0x74, 0x1, 0x6f, 0xff, 0x82, 0xac, 0x46, 0xfa, 0x8f, 0x17, 0x97, 0xd3, 0xb2, 0xa7, 0x26, 0xb6, 0x96, 0xe3, 0xde, 0xa5, 0x53, 0x4, 0x39, 0xac, 0xee, 0x3a, 0x45, 0xc2, 0xa5, 0x1b, 0xc3, 0x2d, 0xd0, 0x55, 0x65, 0xb},
+               output224: []byte{0x2e, 0xd, 0x73, 0x93, 0x86, 0xaa, 0xaf, 0x37, 0x98, 0xe, 0xe4, 0x21, 0xaa, 0x8c, 0x19, 0xb1, 0x9a, 0xf5, 0x2e, 0x70, 0xf5, 0x9d, 0xc0, 0xa6, 0x98, 0x84, 0x71, 0xf5},
+               output256: []byte{0xd8, 0xa6, 0x19, 0xc0, 0xdf, 0xbe, 0xd2, 0xa9, 0x49, 0x8a, 0x14, 0x7b, 0x53, 0xd7, 0xb3, 0x3d, 0xd6, 0x53, 0xd3, 0x90, 0xe5, 0xc0, 0xcd, 0x69, 0x1f, 0x2, 0xc8, 0x60, 0x88, 0x22, 0xd0, 0x6a},
+               output384: []byte{0x39, 0xf9, 0x11, 0xe9, 0xcb, 0x27, 0x63, 0xc8, 0x91, 0x1a, 0xc3, 0x15, 0x30, 0x40, 0xe4, 0x8f, 0x40, 0x3a, 0xbf, 0xe3, 0x73, 0xe1, 0x4b, 0x70, 0x9a, 0x47, 0x68, 0x68, 0xd3, 0xab, 0x58, 0x41, 0xd1, 0x8, 0x8f, 0x83, 0x93, 0xdd, 0x72, 0x83, 0x5, 0xba, 0x34, 0x11, 0x38, 0x36, 0x5d, 0x27},
+               output512: []byte{0x11, 0xe0, 0xe5, 0x21, 0xb5, 0x5f, 0x2, 0xbe, 0xfc, 0x72, 0x7, 0xc0, 0x64, 0x44, 0xfc, 0xc0, 0xc1, 0x6d, 0xcf, 0x6f, 0x34, 0x96, 0x29, 0x21, 0xb7, 0x9, 0xa3, 0x22, 0xf3, 0x5e, 0x21, 0x93, 0x47, 0x7b, 0xd, 0xfa, 0x21, 0xf2, 0x13, 0xf2, 0x9, 0x70, 0x5f, 0xf3, 0x95, 0x85, 0x31, 0xa7, 0x5d, 0x94, 0x34, 0x60, 0x75, 0xfe, 0xb2, 0x9a, 0x28, 0x8b, 0x62, 0xe2, 0x31, 0x5a, 0xe2, 0x70}},
+       testcase{
+               msg:       []byte{0x2b, 0x6d, 0xb7, 0xce, 0xd8, 0x66, 0x5e, 0xbe, 0x9d, 0xeb, 0x8, 0x2, 0x95, 0x21, 0x84, 0x26, 0xbd, 0xaa, 0x7c, 0x6d, 0xa9, 0xad, 0xd2, 0x8, 0x89, 0x32, 0xcd, 0xff, 0xba, 0xa1, 0xc1, 0x41, 0x29, 0xbc, 0xcd, 0xd7, 0xf, 0x36, 0x9e, 0xfb, 0x14, 0x92, 0x85, 0x85, 0x8d, 0x2b, 0x1d, 0x15, 0x5d, 0x14, 0xde, 0x2f, 0xdb, 0x68, 0xa, 0x8b, 0x2, 0x72, 0x84, 0x5, 0x51, 0x82, 0xa0, 0xca, 0xe2, 0x75, 0x23, 0x4c, 0xc9, 0xc9, 0x28, 0x63, 0xc1, 0xb4, 0xab, 0x66, 0xf3, 0x4, 0xcf, 0x6, 0x21, 0xcd, 0x54, 0x56, 0x5f, 0x5b, 0xff, 0x46, 0x1d, 0x3b, 0x46, 0x1b, 0xd4, 0xd, 0xf2, 0x81, 0x98, 0xe3, 0x73, 0x25, 0x1, 0xb4, 0x86, 0xe, 0xad, 0xd5, 0x3, 0xd2, 0x6d, 0x6e, 0x69, 0x33, 0x8f, 0x4e, 0x4, 0x56, 0xe9, 0xe9, 0xba, 0xf3, 0xd8, 0x27, 0xae, 0x68, 0x5f, 0xb1, 0xd8, 0x17},
+               output224: []byte{0xaf, 0x3e, 0xc, 0xc6, 0xe6, 0x45, 0x1, 0xf1, 0xf, 0xd3, 0x97, 0x22, 0xe8, 0x52, 0x35, 0x5f, 0xd6, 0xd8, 0xd, 0x32, 0x19, 0x6, 0x31, 0xe2, 0xf0, 0x6c, 0x22, 0xad},
+               output256: []byte{0xd8, 0x2e, 0x25, 0x7d, 0x0, 0xd, 0xc9, 0xfa, 0x27, 0x9a, 0x0, 0xe2, 0x96, 0x1e, 0x32, 0x86, 0xd2, 0xfe, 0x1c, 0x2, 0xef, 0x59, 0x83, 0x3a, 0xb8, 0xa6, 0xa7, 0x10, 0x1b, 0xc2, 0x50, 0x54},
+               output384: []byte{0x3a, 0xde, 0xb7, 0xee, 0xec, 0xf9, 0x6, 0x9f, 0x14, 0x3a, 0x10, 0x15, 0x1f, 0xd4, 0x50, 0x6a, 0xee, 0xf3, 0xa0, 0xef, 0x94, 0xca, 0x65, 0xd4, 0x44, 0x8a, 0xcf, 0x1e, 0x89, 0x2b, 0x8e, 0xbb, 0x8, 0x87, 0x63, 0x18, 0x4, 0xdd, 0x64, 0xe1, 0x53, 0xad, 0x41, 0xfa, 0xe0, 0x12, 0x7a, 0x85},
+               output512: []byte{0xae, 0xbb, 0xa5, 0x7c, 0x8e, 0xd5, 0xaf, 0x6e, 0xc9, 0x3f, 0x4a, 0xa4, 0x57, 0x72, 0xff, 0x51, 0x67, 0xb7, 0xea, 0x88, 0xdf, 0xa7, 0x13, 0x64, 0xf3, 0x7d, 0x8f, 0xc5, 0xfd, 0xb7, 0xdc, 0x3b, 0x2c, 0x83, 0x31, 0xa0, 0x80, 0x23, 0xf2, 0x1d, 0x11, 0xb, 0x7d, 0x82, 0x1e, 0x2d, 0xc7, 0xe8, 0x60, 0x82, 0x62, 0x35, 0xe7, 0xe6, 0x29, 0x19, 0x12, 0xac, 0x52, 0x13, 0x84, 0x74, 0x73, 0x54}},
+       testcase{
+               msg:       []byte{0x10, 0xdb, 0x50, 0x9b, 0x2c, 0xdc, 0xab, 0xa6, 0xc0, 0x62, 0xae, 0x33, 0xbe, 0x48, 0x11, 0x6a, 0x29, 0xeb, 0x18, 0xe3, 0x90, 0xe1, 0xbb, 0xad, 0xa5, 0xca, 0xa, 0x27, 0x18, 0xaf, 0xbc, 0xd2, 0x34, 0x31, 0x44, 0x1, 0x6, 0x59, 0x48, 0x93, 0x4, 0x3c, 0xc7, 0xf2, 0x62, 0x52, 0x81, 0xbf, 0x7d, 0xe2, 0x65, 0x58, 0x80, 0x96, 0x6a, 0x23, 0x70, 0x5f, 0xc, 0x51, 0x55, 0xc2, 0xf5, 0xcc, 0xa9, 0xf2, 0xc2, 0x14, 0x2e, 0x96, 0xd0, 0xa2, 0xe7, 0x63, 0xb7, 0x6, 0x86, 0xcd, 0x42, 0x1b, 0x5d, 0xb8, 0x12, 0xda, 0xce, 0xd0, 0xc6, 0xd6, 0x50, 0x35, 0xfd, 0xe5, 0x58, 0xe9, 0x4f, 0x26, 0xb3, 0xe6, 0xdd, 0xe5, 0xbd, 0x13, 0x98, 0xc, 0xc8, 0x2, 0x92, 0xb7, 0x23, 0x1, 0x3b, 0xd0, 0x33, 0x28, 0x45, 0x84, 0xbf, 0xf2, 0x76, 0x57, 0x87, 0x1b, 0xc, 0xf0, 0x7a, 0x84, 0x9f, 0x4a, 0xe2},
+               output224: []byte{0xf0, 0x9, 0xe0, 0x5d, 0x1a, 0xfe, 0x2d, 0x33, 0xd2, 0xc5, 0xf4, 0x0, 0x8b, 0x46, 0xf3, 0x14, 0x68, 0xa7, 0xbf, 0x52, 0x99, 0xd4, 0xf0, 0xab, 0xe, 0xfe, 0x4f, 0xd3},
+               output256: []byte{0x8d, 0x5b, 0x7d, 0xbf, 0x39, 0x47, 0x21, 0x9a, 0xcd, 0xb0, 0x4f, 0xb2, 0xe1, 0x1a, 0x84, 0xa3, 0x13, 0xc5, 0x4c, 0x22, 0xf2, 0xae, 0x85, 0x8d, 0xfc, 0x88, 0x87, 0xbf, 0x62, 0x65, 0xf5, 0xf3},
+               output384: []byte{0x14, 0x83, 0x8, 0x77, 0xdf, 0xaf, 0xe6, 0xf8, 0x86, 0xa2, 0x2d, 0xe7, 0xce, 0x9a, 0x5f, 0xc7, 0x47, 0x33, 0xa8, 0xfc, 0x27, 0xec, 0xc5, 0x23, 0xb6, 0xb4, 0x52, 0x4e, 0x63, 0x12, 0xcb, 0xb2, 0x2b, 0x51, 0xd7, 0xeb, 0x9d, 0xda, 0xb3, 0x7b, 0xa5, 0x4b, 0xb2, 0xc0, 0xbf, 0xc3, 0x2a, 0x6f},
+               output512: []byte{0x2d, 0xf1, 0xe0, 0x95, 0x40, 0xb5, 0x3a, 0x17, 0x22, 0x2d, 0xab, 0x66, 0x27, 0x5c, 0xeb, 0xec, 0xeb, 0x1f, 0x8a, 0x5d, 0xb2, 0x6b, 0xc, 0x41, 0xf9, 0x55, 0xfa, 0x5, 0x49, 0xf3, 0x36, 0x7e, 0x82, 0x29, 0x9e, 0xc, 0xd6, 0x73, 0x95, 0x8a, 0xf7, 0xdf, 0xa0, 0x4d, 0x74, 0x1a, 0xa6, 0x3b, 0xa2, 0xc1, 0xad, 0x35, 0x17, 0x64, 0xdc, 0x92, 0x28, 0xd2, 0x15, 0xf2, 0x2c, 0x24, 0xca, 0x58}},
+       testcase{
+               msg:       []byte{0x93, 0x34, 0xde, 0x60, 0xc9, 0x97, 0xbd, 0xa6, 0x8, 0x61, 0x1, 0xa6, 0x31, 0x4f, 0x64, 0xe4, 0x45, 0x8f, 0x5f, 0xf9, 0x45, 0xc, 0x50, 0x9d, 0xf0, 0x6, 0xe8, 0xc5, 0x47, 0x98, 0x3c, 0x65, 0x1c, 0xa9, 0x78, 0x79, 0x17, 0x5a, 0xab, 0xa0, 0xc5, 0x39, 0xe8, 0x2d, 0x5, 0xc1, 0xe0, 0x2c, 0x48, 0x9, 0x75, 0xcb, 0xb3, 0x1, 0x18, 0x12, 0x10, 0x61, 0xb1, 0xeb, 0xac, 0x4f, 0x8d, 0x9a, 0x37, 0x81, 0xe2, 0xdb, 0x6b, 0x18, 0x4, 0x2e, 0x1, 0xec, 0xf9, 0x1, 0x7a, 0x64, 0xa0, 0xe5, 0x74, 0x47, 0xec, 0x7f, 0xcb, 0xe6, 0xa7, 0xf8, 0x25, 0x85, 0xf7, 0x40, 0x3e, 0xe2, 0x22, 0x3d, 0x52, 0xd3, 0x7b, 0x4b, 0xf4, 0x26, 0x42, 0x86, 0x13, 0xd6, 0xb4, 0x25, 0x79, 0x80, 0x97, 0x2a, 0xa, 0xca, 0xb5, 0x8, 0xa7, 0x62, 0xc, 0x1c, 0xb2, 0x8e, 0xb4, 0xe9, 0xd3, 0xf, 0xc4, 0x13, 0x61, 0xec},
+               output224: []byte{0x76, 0x28, 0x1b, 0xd1, 0x61, 0x38, 0x43, 0xa3, 0xad, 0xbc, 0xbc, 0x78, 0xd1, 0x92, 0x3a, 0xfb, 0x5b, 0x8a, 0xa2, 0xdc, 0xbc, 0x48, 0x93, 0x4d, 0xee, 0xc8, 0x4a, 0xaa},
+               output256: []byte{0x60, 0x7c, 0x3f, 0x31, 0x34, 0x2c, 0x3e, 0xe5, 0xc9, 0x3e, 0x55, 0x2a, 0x8d, 0xd7, 0x9f, 0xa8, 0x6d, 0xcc, 0xae, 0x2c, 0x1b, 0x58, 0xaa, 0xba, 0xc2, 0x5b, 0x59, 0x18, 0xac, 0xfa, 0x4d, 0xa5},
+               output384: []byte{0xd1, 0x9, 0x53, 0x2b, 0xc4, 0x21, 0x73, 0x26, 0xb3, 0xd2, 0x5e, 0xd2, 0xd2, 0xf3, 0xf0, 0xd2, 0x48, 0x2c, 0xc5, 0xbd, 0xd0, 0x54, 0x21, 0x8f, 0xa8, 0xbe, 0xdb, 0x91, 0xcd, 0x81, 0x4f, 0x7f, 0xd6, 0x83, 0xaa, 0x2a, 0xfc, 0xb8, 0x34, 0x2c, 0xd3, 0x4c, 0xe5, 0x4d, 0x60, 0x7e, 0x3d, 0xa0},
+               output512: []byte{0x82, 0x99, 0xcf, 0xce, 0xa5, 0xf0, 0xc, 0x93, 0xa5, 0xeb, 0x8a, 0x84, 0xa1, 0x36, 0x28, 0xa6, 0x8b, 0x26, 0x79, 0x6d, 0x53, 0xfb, 0x6a, 0x98, 0x6c, 0x95, 0xb0, 0xb1, 0xc2, 0x48, 0x92, 0xf, 0xb9, 0x46, 0xd8, 0xaf, 0x98, 0x34, 0x3d, 0x14, 0xef, 0xc7, 0x4a, 0x46, 0x11, 0xc5, 0x3c, 0xcc, 0x27, 0xc5, 0xf1, 0x4c, 0x72, 0x37, 0xaf, 0x28, 0x36, 0x43, 0x46, 0xca, 0x5c, 0xd7, 0xd, 0x1a}},
+       testcase{
+               msg:       []byte{0xe8, 0x8a, 0xb0, 0x86, 0x89, 0x16, 0x93, 0xaa, 0x53, 0x5c, 0xeb, 0x20, 0xe6, 0x4c, 0x7a, 0xb9, 0x7c, 0x7d, 0xd3, 0x54, 0x8f, 0x37, 0x86, 0x33, 0x98, 0x97, 0xa5, 0xf0, 0xc3, 0x90, 0x31, 0x54, 0x9c, 0xa8, 0x70, 0x16, 0x6e, 0x47, 0x77, 0x43, 0xcc, 0xfb, 0xe0, 0x16, 0xb4, 0x42, 0x8d, 0x89, 0x73, 0x8e, 0x42, 0x6f, 0x5f, 0xfe, 0x81, 0x62, 0x61, 0x37, 0xf1, 0x7a, 0xec, 0xff, 0x61, 0xb7, 0x2d, 0xbe, 0xe2, 0xdc, 0x20, 0x96, 0x18, 0x80, 0xcf, 0xe2, 0x81, 0xdf, 0xab, 0x5e, 0xe3, 0x8b, 0x19, 0x21, 0x88, 0x14, 0x50, 0xe1, 0x60, 0x32, 0xde, 0x5e, 0x4d, 0x55, 0xad, 0x8d, 0x4f, 0xca, 0x60, 0x97, 0x21, 0xb0, 0x69, 0x2b, 0xac, 0x79, 0xbe, 0x5a, 0x6, 0xe1, 0x77, 0xfe, 0x8c, 0x80, 0xc0, 0xc8, 0x35, 0x19, 0xfb, 0x33, 0x47, 0xde, 0x9f, 0x43, 0xd5, 0x56, 0x1c, 0xb8, 0x10, 0x7b, 0x9b, 0x5e, 0xdc},
+               output224: []byte{0xda, 0x7c, 0x79, 0xe0, 0x4f, 0xca, 0x2b, 0x69, 0xaa, 0xa5, 0x81, 0x99, 0xca, 0x69, 0x10, 0x5b, 0x6b, 0x18, 0xfe, 0x67, 0xe2, 0x9f, 0x38, 0x5, 0x1, 0xaa, 0x7f, 0xa8},
+               output256: []byte{0x6, 0x56, 0xde, 0x9d, 0xcd, 0x7b, 0x71, 0x12, 0xa8, 0x6c, 0x7b, 0xa1, 0x99, 0x63, 0x7d, 0x2c, 0x1c, 0x9e, 0x9c, 0xfb, 0xb7, 0x13, 0xe4, 0xed, 0xe7, 0x9f, 0x88, 0x62, 0xee, 0x69, 0x99, 0x3f},
+               output384: []byte{0xde, 0x64, 0xa3, 0x7a, 0x74, 0x56, 0x63, 0x8d, 0x3a, 0xca, 0x1b, 0x89, 0x5f, 0x4a, 0x88, 0xc2, 0x68, 0x17, 0x17, 0x79, 0x86, 0xa9, 0xf2, 0xf5, 0xb7, 0x7b, 0x49, 0xcf, 0xf2, 0xc3, 0xe4, 0x6b, 0xe2, 0xc4, 0x9a, 0xbe, 0x89, 0xd7, 0x41, 0x37, 0x5d, 0xb8, 0x7f, 0x4c, 0x89, 0x8f, 0x67, 0x62},
+               output512: []byte{0xaf, 0x57, 0xbe, 0xa3, 0x57, 0xfc, 0xba, 0x5, 0x79, 0xc4, 0x20, 0x4c, 0xf, 0x8d, 0xff, 0x18, 0x1b, 0xc8, 0xa4, 0x73, 0x1, 0x4b, 0xae, 0x78, 0xdf, 0x76, 0x6, 0x9d, 0xe4, 0x78, 0xb2, 0xf2, 0xa3, 0x90, 0x32, 0x7a, 0x65, 0xbd, 0xd2, 0x4b, 0xe9, 0x26, 0x55, 0x1c, 0x78, 0xf7, 0xb, 0xd, 0x5f, 0x1c, 0x8f, 0x4b, 0x97, 0x9, 0x97, 0xd5, 0x57, 0xf0, 0x63, 0x36, 0xa3, 0x15, 0xa7, 0x49}},
+       testcase{
+               msg:       []byte{0xfd, 0x19, 0xe0, 0x1a, 0x83, 0xeb, 0x6e, 0xc8, 0x10, 0xb9, 0x45, 0x82, 0xcb, 0x8f, 0xbf, 0xa2, 0xfc, 0xb9, 0x92, 0xb5, 0x36, 0x84, 0xfb, 0x74, 0x8d, 0x22, 0x64, 0xf0, 0x20, 0xd3, 0xb9, 0x60, 0xcb, 0x1d, 0x6b, 0x8c, 0x34, 0x8c, 0x2b, 0x54, 0xa9, 0xfc, 0xea, 0x72, 0x33, 0xc, 0x2a, 0xaa, 0x9a, 0x24, 0xec, 0xdb, 0x0, 0xc4, 0x36, 0xab, 0xc7, 0x2, 0x36, 0x1a, 0x82, 0xbb, 0x88, 0x28, 0xb8, 0x53, 0x69, 0xb8, 0xc7, 0x2e, 0xce, 0x0, 0x82, 0xfe, 0x6, 0x55, 0x71, 0x63, 0x89, 0x9c, 0x2a, 0xe, 0xfa, 0x46, 0x6c, 0x33, 0xc0, 0x43, 0x43, 0xa8, 0x39, 0x41, 0x70, 0x57, 0x39, 0x9a, 0x63, 0xa3, 0x92, 0x9b, 0xe1, 0xee, 0x48, 0x5, 0xd6, 0xce, 0x3e, 0x5d, 0xd, 0x9, 0x67, 0xfe, 0x90, 0x4, 0x69, 0x6a, 0x56, 0x63, 0xf4, 0xca, 0xc9, 0x17, 0x90, 0x6, 0xa2, 0xce, 0xb7, 0x55, 0x42, 0xd7, 0x5d, 0x68},
+               output224: []byte{0x70, 0xec, 0xb2, 0x61, 0x75, 0x73, 0x71, 0xa2, 0x82, 0x90, 0x3c, 0x69, 0x67, 0x15, 0xdc, 0x3, 0xf1, 0x6, 0xa3, 0x39, 0xf0, 0x76, 0x20, 0x3b, 0xab, 0x43, 0x6e, 0x94},
+               output256: []byte{0x4d, 0xdd, 0x62, 0x24, 0x85, 0x82, 0x99, 0xf3, 0x37, 0x8e, 0x3f, 0x5a, 0xe, 0xcc, 0x52, 0xfa, 0x4c, 0x41, 0x9c, 0x8e, 0xbb, 0x20, 0xf6, 0x35, 0xc4, 0xc4, 0x3f, 0x36, 0x32, 0x4e, 0xcb, 0x4e},
+               output384: []byte{0x8d, 0x97, 0x43, 0x71, 0xc, 0x17, 0x1c, 0xd3, 0x99, 0xa0, 0xd7, 0x12, 0xe9, 0xd5, 0x33, 0x74, 0xed, 0x8e, 0xa, 0x97, 0x67, 0x2a, 0x40, 0x29, 0x4c, 0x74, 0xf0, 0xd5, 0x3, 0xf0, 0x29, 0x2d, 0x6f, 0x41, 0xd5, 0xce, 0xa0, 0x8f, 0xb3, 0xc6, 0x23, 0xc4, 0xeb, 0xa5, 0x68, 0x48, 0x77, 0xd},
+               output512: []byte{0xb2, 0x99, 0xe4, 0x21, 0x6, 0x1e, 0xf2, 0x6c, 0x32, 0xbb, 0x4f, 0x50, 0xee, 0x66, 0x9d, 0x5, 0xfe, 0xb2, 0xcc, 0xba, 0x32, 0x97, 0x28, 0x9c, 0x30, 0xe6, 0x43, 0x40, 0x57, 0xb3, 0xea, 0x7f, 0x61, 0x7b, 0xbb, 0xf7, 0xa5, 0x55, 0x53, 0x28, 0xfc, 0x29, 0x1f, 0x79, 0x49, 0x87, 0x57, 0x7f, 0x45, 0x83, 0x50, 0xdf, 0x99, 0xaf, 0x3a, 0x57, 0x78, 0x30, 0xb, 0xe0, 0xbd, 0x80, 0x16, 0x4f}},
+       testcase{
+               msg:       []byte{0x59, 0xae, 0x20, 0xb6, 0xf7, 0xe0, 0xb3, 0xc7, 0xa9, 0x89, 0xaf, 0xb2, 0x83, 0x24, 0xa4, 0xf, 0xca, 0x25, 0xd8, 0x65, 0x1c, 0xf1, 0xf4, 0x6a, 0xe3, 0x83, 0xef, 0x6d, 0x84, 0x41, 0x58, 0x7a, 0xa1, 0xc0, 0x4c, 0x3e, 0x3b, 0xf8, 0x8e, 0x81, 0x31, 0xce, 0x61, 0x45, 0xcf, 0xb8, 0x97, 0x3d, 0x96, 0x1e, 0x84, 0x32, 0xb2, 0x2, 0xfa, 0x5a, 0xf3, 0xe0, 0x9d, 0x62, 0x5f, 0xaa, 0xd8, 0x25, 0xbc, 0x19, 0xda, 0x9b, 0x5c, 0x6c, 0x20, 0xd0, 0x2a, 0xbd, 0xa2, 0xfc, 0xc5, 0x8b, 0x5b, 0xd3, 0xfe, 0x50, 0x7b, 0xf2, 0x1, 0x26, 0x3f, 0x30, 0x54, 0x38, 0x19, 0x51, 0xc, 0x12, 0xbc, 0x23, 0xe2, 0xdd, 0xb4, 0xf7, 0x11, 0xd0, 0x87, 0xa8, 0x6e, 0xdb, 0x1b, 0x35, 0x53, 0x13, 0x36, 0x3a, 0x2d, 0xe9, 0x96, 0xb8, 0x91, 0x2, 0x5e, 0x14, 0x70, 0x36, 0x8, 0x74, 0x1, 0xcc, 0xf3, 0xca, 0x78, 0x15, 0xbf, 0x3c, 0x49},
+               output224: []byte{0x74, 0xd, 0x3c, 0xb4, 0x55, 0x13, 0x31, 0x73, 0xec, 0x65, 0x2a, 0xa0, 0x47, 0x9, 0xef, 0xf, 0x54, 0x9f, 0x19, 0xa9, 0xd4, 0xcc, 0x6b, 0xec, 0x9e, 0x87, 0x6b, 0x5a},
+               output256: []byte{0xec, 0x9, 0x63, 0x14, 0xe2, 0xf7, 0x3b, 0x6a, 0x70, 0x27, 0xff, 0xfa, 0x2, 0x10, 0x4c, 0x2f, 0x6d, 0xd1, 0x87, 0xf2, 0xc, 0x74, 0x34, 0x45, 0xbe, 0xfd, 0x4b, 0x5c, 0x3, 0x4b, 0x32, 0x95},
+               output384: []byte{0xfa, 0xe9, 0x98, 0xd1, 0x7, 0x4e, 0x30, 0xf2, 0xea, 0xa, 0x8b, 0x9f, 0xe2, 0x59, 0xfd, 0x2e, 0x2a, 0x36, 0x80, 0x49, 0x95, 0xeb, 0xe7, 0xe3, 0xa5, 0xad, 0x34, 0x86, 0x5b, 0x1a, 0x33, 0x16, 0x67, 0x52, 0x97, 0xfe, 0x8e, 0x33, 0xee, 0xf8, 0xad, 0xcc, 0x2, 0xbe, 0x8c, 0x47, 0x65, 0xbe},
+               output512: []byte{0xcb, 0xdf, 0xb0, 0xd0, 0xe7, 0x20, 0xf8, 0x72, 0x59, 0xdd, 0xd, 0xb, 0x4e, 0x9c, 0x53, 0x19, 0xe7, 0xf8, 0x8a, 0xae, 0xf7, 0xf7, 0xab, 0x2f, 0xa1, 0xca, 0x63, 0x9a, 0xfa, 0x1, 0x60, 0x82, 0x2f, 0x96, 0xb3, 0xc3, 0x57, 0xa4, 0x89, 0x4c, 0xe5, 0x3c, 0xd7, 0x13, 0xfa, 0xb2, 0x3a, 0xd0, 0x52, 0xe8, 0x56, 0x5f, 0xa3, 0xb3, 0xa5, 0x23, 0xcb, 0x9c, 0xe3, 0x9a, 0x6b, 0xd5, 0x35, 0xcc}},
+       testcase{
+               msg:       []byte{0x77, 0xee, 0x80, 0x4b, 0x9f, 0x32, 0x95, 0xab, 0x23, 0x62, 0x79, 0x8b, 0x72, 0xb0, 0xa1, 0xb2, 0xd3, 0x29, 0x1d, 0xce, 0xb8, 0x13, 0x98, 0x96, 0x35, 0x58, 0x30, 0xf3, 0x4b, 0x3b, 0x32, 0x85, 0x61, 0x53, 0x1f, 0x80, 0x79, 0xb7, 0x9a, 0x6e, 0x99, 0x80, 0x70, 0x51, 0x50, 0x86, 0x64, 0x2, 0xfd, 0xc1, 0x76, 0xc0, 0x58, 0x97, 0xe3, 0x59, 0xa6, 0xcb, 0x1a, 0x7a, 0xb0, 0x67, 0x38, 0x3e, 0xb4, 0x97, 0x18, 0x2a, 0x7e, 0x5a, 0xef, 0x70, 0x38, 0xe4, 0xc9, 0x6d, 0x13, 0x3b, 0x27, 0x82, 0x91, 0x74, 0x17, 0xe3, 0x91, 0x53, 0x5b, 0x5e, 0x1b, 0x51, 0xf4, 0x7d, 0x8e, 0xd7, 0xe4, 0xd4, 0x2, 0x5f, 0xe9, 0x8d, 0xc8, 0x7b, 0x9c, 0x16, 0x22, 0x61, 0x4b, 0xff, 0x3d, 0x10, 0x29, 0xe6, 0x8e, 0x37, 0x2d, 0xe7, 0x19, 0x80, 0x38, 0x57, 0xca, 0x52, 0x6, 0x7c, 0xdd, 0xaa, 0xd9, 0x58, 0x95, 0x1c, 0xb2, 0x6, 0x8c, 0xc6},
+               output224: []byte{0x66, 0x38, 0x35, 0xa8, 0x1a, 0x2a, 0x38, 0xd5, 0xad, 0x3a, 0x37, 0xbd, 0x9b, 0xc9, 0x66, 0x18, 0xd2, 0x7c, 0xa3, 0x22, 0x86, 0xe9, 0x9, 0x18, 0x34, 0xa0, 0x87, 0x1a},
+               output256: []byte{0xfe, 0x71, 0xd0, 0x1c, 0x2e, 0xe5, 0xe, 0x5, 0x4d, 0x6b, 0x7, 0x14, 0x7e, 0xf6, 0x29, 0x54, 0xfd, 0xe7, 0xe6, 0x95, 0x9d, 0x6e, 0xeb, 0xa6, 0x8e, 0x3c, 0x94, 0x10, 0x7e, 0xb0, 0x8, 0x4d},
+               output384: []byte{0xa, 0xa9, 0xcc, 0xc3, 0xc9, 0xca, 0xe1, 0x60, 0x3d, 0x3d, 0xa5, 0xe9, 0x5f, 0x30, 0x4a, 0xdb, 0x8f, 0xa5, 0x75, 0x83, 0x39, 0x29, 0xb0, 0x9f, 0x7c, 0x10, 0x95, 0xd9, 0x68, 0xbe, 0xa0, 0x47, 0x1d, 0xfe, 0x8a, 0xaa, 0xd3, 0xad, 0x11, 0x26, 0x6d, 0xaa, 0xff, 0x95, 0xf6, 0x66, 0x7a, 0xbc},
+               output512: []byte{0x5, 0x9a, 0x18, 0x1c, 0x83, 0xa2, 0x2b, 0xff, 0xa, 0xa9, 0xba, 0xa2, 0x2d, 0x87, 0x2b, 0xdf, 0x23, 0xcb, 0xe3, 0x41, 0x3, 0x2c, 0xf0, 0xbf, 0x57, 0x99, 0x7a, 0x4a, 0x19, 0x24, 0xd2, 0x4f, 0xba, 0xe9, 0xdc, 0xa1, 0x4b, 0x6d, 0x29, 0x6, 0x92, 0xb6, 0xa6, 0xb6, 0x34, 0x4c, 0xbe, 0x53, 0x17, 0x34, 0xf5, 0x8a, 0xd0, 0x22, 0x4c, 0x6e, 0x39, 0xbd, 0x1e, 0x87, 0xf8, 0x70, 0xaa, 0xd6}},
+       testcase{
+               msg:       []byte{0xb7, 0x71, 0xd5, 0xce, 0xf5, 0xd1, 0xa4, 0x1a, 0x93, 0xd1, 0x56, 0x43, 0xd7, 0x18, 0x1d, 0x2a, 0x2e, 0xf0, 0xa8, 0xe8, 0x4d, 0x91, 0x81, 0x2f, 0x20, 0xed, 0x21, 0xf1, 0x47, 0xbe, 0xf7, 0x32, 0xbf, 0x3a, 0x60, 0xef, 0x40, 0x67, 0xc3, 0x73, 0x4b, 0x85, 0xbc, 0x8c, 0xd4, 0x71, 0x78, 0xf, 0x10, 0xdc, 0x9e, 0x82, 0x91, 0xb5, 0x83, 0x39, 0xa6, 0x77, 0xb9, 0x60, 0x21, 0x8f, 0x71, 0xe7, 0x93, 0xf2, 0x79, 0x7a, 0xea, 0x34, 0x94, 0x6, 0x51, 0x28, 0x29, 0x6, 0x5d, 0x37, 0xbb, 0x55, 0xea, 0x79, 0x6f, 0xa4, 0xf5, 0x6f, 0xd8, 0x89, 0x6b, 0x49, 0xb2, 0xcd, 0x19, 0xb4, 0x32, 0x15, 0xad, 0x96, 0x7c, 0x71, 0x2b, 0x24, 0xe5, 0x3, 0x2d, 0x6, 0x52, 0x32, 0xe0, 0x2c, 0x12, 0x74, 0x9, 0xd2, 0xed, 0x41, 0x46, 0xb9, 0xd7, 0x5d, 0x76, 0x3d, 0x52, 0xdb, 0x98, 0xd9, 0x49, 0xd3, 0xb0, 0xfe, 0xd6, 0xa8, 0x5, 0x2f, 0xbb},
+               output224: []byte{0x25, 0x94, 0x15, 0x3a, 0xc2, 0xde, 0x68, 0x1f, 0x4d, 0xee, 0x34, 0xf, 0xa3, 0x44, 0xec, 0x38, 0x87, 0x73, 0xa3, 0x77, 0xd5, 0xb8, 0x9e, 0x50, 0x32, 0x54, 0xfd, 0x2e},
+               output256: []byte{0xbd, 0x6f, 0x54, 0x92, 0x58, 0x2a, 0x7c, 0x1b, 0x11, 0x63, 0x4, 0xde, 0x28, 0x31, 0x4d, 0xf9, 0xff, 0xfe, 0x95, 0xb0, 0xda, 0x11, 0xaf, 0x52, 0xfe, 0x94, 0x40, 0xa7, 0x17, 0xa3, 0x48, 0x59},
+               output384: []byte{0x8f, 0xfd, 0xf6, 0xa4, 0x75, 0x2d, 0x17, 0xd4, 0x96, 0xf8, 0xad, 0xee, 0x71, 0x16, 0xbd, 0x2a, 0xf0, 0xa4, 0xb7, 0x26, 0xbb, 0x3f, 0x4c, 0x5f, 0x85, 0xbe, 0x2c, 0x9d, 0xfc, 0x34, 0x5, 0x5a, 0x50, 0x9e, 0x4f, 0xe0, 0x16, 0x93, 0xd, 0x99, 0x51, 0xa7, 0x21, 0x25, 0x53, 0xe2, 0xe9, 0x8},
+               output512: []byte{0x9e, 0xde, 0xeb, 0x10, 0xee, 0x1b, 0x7b, 0xb8, 0xf1, 0x6a, 0x28, 0xd, 0x8c, 0xc3, 0xed, 0xa5, 0xe9, 0x9, 0xc5, 0x54, 0x41, 0x9d, 0xdc, 0x52, 0x3b, 0x69, 0xec, 0xed, 0xf2, 0xad, 0xf3, 0xb3, 0xc9, 0xbc, 0x66, 0xfe, 0xf3, 0x65, 0x34, 0x24, 0x71, 0xc4, 0x58, 0x12, 0x6f, 0x8, 0x3a, 0x3b, 0x8e, 0x7c, 0xc, 0x9d, 0x9d, 0x77, 0xe9, 0xf9, 0x1, 0x96, 0xb7, 0x1f, 0x9a, 0xad, 0xf4, 0x92}},
+       testcase{
+               msg:       []byte{0xb3, 0x2d, 0x95, 0xb0, 0xb9, 0xaa, 0xd2, 0xa8, 0x81, 0x6d, 0xe6, 0xd0, 0x6d, 0x1f, 0x86, 0x0, 0x85, 0x5, 0xbd, 0x8c, 0x14, 0x12, 0x4f, 0x6e, 0x9a, 0x16, 0x3b, 0x5a, 0x2a, 0xde, 0x55, 0xf8, 0x35, 0xd0, 0xec, 0x38, 0x80, 0xef, 0x50, 0x70, 0xd, 0x3b, 0x25, 0xe4, 0x2c, 0xc0, 0xaf, 0x5, 0xc, 0xcd, 0x1b, 0xe5, 0xe5, 0x55, 0xb2, 0x30, 0x87, 0xe0, 0x4d, 0x7b, 0xf9, 0x81, 0x36, 0x22, 0x78, 0xc, 0x73, 0x13, 0xa1, 0x95, 0x4f, 0x87, 0x40, 0xb6, 0xee, 0x2d, 0x3f, 0x71, 0xf7, 0x68, 0xdd, 0x41, 0x7f, 0x52, 0x4, 0x82, 0xbd, 0x3a, 0x8, 0xd4, 0xf2, 0x22, 0xb4, 0xee, 0x9d, 0xbd, 0x1, 0x54, 0x47, 0xb3, 0x35, 0x7, 0xdd, 0x50, 0xf3, 0xab, 0x42, 0x47, 0xc5, 0xde, 0x9a, 0x8a, 0xbd, 0x62, 0xa8, 0xde, 0xce, 0xa0, 0x1e, 0x3b, 0x87, 0xc8, 0xb9, 0x27, 0xf5, 0xb0, 0x8b, 0xeb, 0x37, 0x67, 0x4c, 0x6f, 0x8e, 0x38, 0xc, 0x4},
+               output224: []byte{0x42, 0x27, 0x5c, 0x29, 0x69, 0x37, 0x74, 0x57, 0x58, 0xff, 0x2b, 0x7b, 0xee, 0x9a, 0x89, 0x71, 0x91, 0xae, 0x87, 0xe4, 0x2b, 0xd1, 0x1, 0x98, 0xd9, 0x46, 0x6c, 0x19},
+               output256: []byte{0xe7, 0x17, 0xa7, 0x76, 0x94, 0x48, 0xab, 0xbe, 0x5f, 0xef, 0x81, 0x87, 0x95, 0x4a, 0x88, 0xac, 0x56, 0xde, 0xd1, 0xd2, 0x2e, 0x63, 0x94, 0xa, 0xb8, 0xd, 0x2, 0x95, 0x85, 0xa2, 0x19, 0x21},
+               output384: []byte{0x27, 0x8e, 0x83, 0xcf, 0xf1, 0xff, 0x6c, 0xc4, 0xb3, 0xac, 0x41, 0xf3, 0x87, 0x9d, 0xa8, 0x7a, 0xe6, 0x3b, 0x53, 0x5b, 0x43, 0x81, 0x5e, 0x27, 0x36, 0x87, 0xa4, 0xcc, 0x51, 0x98, 0x55, 0xb4, 0x52, 0xcb, 0x6a, 0xf0, 0x19, 0x8b, 0xb9, 0xfd, 0xf, 0x3e, 0x43, 0x73, 0x9b, 0xc0, 0xcd, 0xd7},
+               output512: []byte{0xa6, 0x5, 0x4f, 0xfc, 0x3d, 0x81, 0x59, 0x1b, 0xe9, 0x64, 0xc4, 0xb0, 0x4, 0xa3, 0xa2, 0x11, 0x42, 0x36, 0x5b, 0x59, 0xee, 0x98, 0xb2, 0x87, 0x3d, 0x48, 0x82, 0x93, 0xf9, 0x3a, 0x8d, 0x71, 0x54, 0xbf, 0x72, 0x10, 0x0, 0x12, 0xc6, 0xd, 0x3c, 0x94, 0x18, 0xf6, 0xaf, 0x8e, 0xa6, 0x63, 0x72, 0xcb, 0x47, 0x3, 0xf5, 0xf6, 0x38, 0x1d, 0xe6, 0xd4, 0xb9, 0xb9, 0x8c, 0xff, 0x1e, 0x90}},
+       testcase{
+               msg:       []byte{0x4, 0x41, 0xe, 0x31, 0x8, 0x2a, 0x47, 0x58, 0x4b, 0x40, 0x6f, 0x5, 0x13, 0x98, 0xa6, 0xab, 0xe7, 0x4e, 0x4d, 0xa5, 0x9b, 0xb6, 0xf8, 0x5e, 0x6b, 0x49, 0xe8, 0xa1, 0xf7, 0xf2, 0xca, 0x0, 0xdf, 0xba, 0x54, 0x62, 0xc2, 0xcd, 0x2b, 0xfd, 0xe8, 0xb6, 0x4f, 0xb2, 0x1d, 0x70, 0xc0, 0x83, 0xf1, 0x13, 0x18, 0xb5, 0x6a, 0x52, 0xd0, 0x3b, 0x81, 0xca, 0xc5, 0xee, 0xc2, 0x9e, 0xb3, 0x1b, 0xd0, 0x7, 0x8b, 0x61, 0x56, 0x78, 0x6d, 0xa3, 0xd6, 0xd8, 0xc3, 0x30, 0x98, 0xc5, 0xc4, 0x7b, 0xb6, 0x7a, 0xc6, 0x4d, 0xb1, 0x41, 0x65, 0xaf, 0x65, 0xb4, 0x45, 0x44, 0xd8, 0x6, 0xdd, 0xe5, 0xf4, 0x87, 0xd5, 0x37, 0x3c, 0x7f, 0x97, 0x92, 0xc2, 0x99, 0xe9, 0x68, 0x6b, 0x7e, 0x58, 0x21, 0xe7, 0xc8, 0xe2, 0x45, 0x83, 0x15, 0xb9, 0x96, 0xb5, 0x67, 0x7d, 0x92, 0x6d, 0xac, 0x57, 0xb3, 0xf2, 0x2d, 0xa8, 0x73, 0xc6, 0x1, 0x1, 0x6a, 0xd},
+               output224: []byte{0x14, 0x3f, 0x90, 0x55, 0xeb, 0x1f, 0x73, 0x67, 0x29, 0xc7, 0x77, 0x21, 0xfb, 0x65, 0xed, 0x5e, 0xe1, 0x42, 0xf6, 0xe9, 0x69, 0x13, 0x2f, 0xb2, 0x29, 0x89, 0xc1, 0x1f},
+               output256: []byte{0xa9, 0x5d, 0x50, 0xb5, 0xb, 0x45, 0x45, 0xf0, 0x94, 0x74, 0x41, 0xdf, 0x74, 0xa1, 0xe9, 0xd7, 0x46, 0x22, 0xeb, 0x3b, 0xaa, 0x49, 0xc1, 0xbb, 0xfc, 0x3a, 0xc, 0xce, 0x66, 0x19, 0xc1, 0xaa},
+               output384: []byte{0xaa, 0x4b, 0x5a, 0x5f, 0xb9, 0x4f, 0xe1, 0x95, 0x78, 0xf3, 0x33, 0x23, 0xba, 0x1e, 0xef, 0xc5, 0xb6, 0xed, 0x70, 0xb3, 0x4b, 0xc7, 0x1, 0x93, 0xf3, 0x86, 0xc9, 0x9f, 0x73, 0x86, 0x36, 0x11, 0xaf, 0x20, 0x58, 0x1b, 0x4b, 0x1b, 0x3e, 0xd7, 0x76, 0xdf, 0x9e, 0x23, 0x5d, 0x3d, 0x4e, 0x45},
+               output512: []byte{0xb0, 0xe5, 0x4a, 0x12, 0xfd, 0xba, 0x7, 0x38, 0x89, 0x8f, 0x1b, 0xbf, 0xb, 0xa8, 0x1f, 0x81, 0xde, 0x77, 0x64, 0x8d, 0x8d, 0x14, 0xc2, 0xb, 0xdd, 0x5d, 0x90, 0xf3, 0x0, 0xd3, 0x82, 0xe0, 0x69, 0xf5, 0xdb, 0xa7, 0xee, 0xc6, 0xb2, 0x31, 0x68, 0xb0, 0x8, 0xb9, 0xf3, 0x9c, 0x2b, 0x93, 0xfd, 0x74, 0x2a, 0x59, 0x2, 0xa5, 0xe0, 0x27, 0x28, 0xf5, 0x77, 0x12, 0xd6, 0xa6, 0x1d, 0x4e}},
+       testcase{
+               msg:       []byte{0x8b, 0x81, 0xe9, 0xba, 0xdd, 0xe0, 0x26, 0xf1, 0x4d, 0x95, 0xc0, 0x19, 0x97, 0x70, 0x24, 0xc9, 0xe1, 0x3d, 0xb7, 0xa5, 0xcd, 0x21, 0xf9, 0xe9, 0xfc, 0x49, 0x1d, 0x71, 0x61, 0x64, 0xbb, 0xac, 0xdc, 0x70, 0x60, 0xd8, 0x82, 0x61, 0x5d, 0x41, 0x14, 0x38, 0xae, 0xa0, 0x56, 0xc3, 0x40, 0xcd, 0xf9, 0x77, 0x78, 0x8f, 0x6e, 0x17, 0xd1, 0x18, 0xde, 0x55, 0x2, 0x68, 0x55, 0xf9, 0x32, 0x70, 0x47, 0x2d, 0x1f, 0xd1, 0x8b, 0x9e, 0x7e, 0x81, 0x2b, 0xae, 0x10, 0x7e, 0xd, 0xfd, 0xe7, 0x6, 0x33, 0x1, 0xb7, 0x1f, 0x6c, 0xfe, 0x4e, 0x22, 0x5c, 0xab, 0x3b, 0x23, 0x29, 0x5, 0xa5, 0x6e, 0x99, 0x4f, 0x8, 0xee, 0x28, 0x91, 0xba, 0x92, 0x2d, 0x49, 0xc3, 0xda, 0xfe, 0xb7, 0x5f, 0x7c, 0x69, 0x75, 0xc, 0xb6, 0x7d, 0x82, 0x2c, 0x96, 0x17, 0x6c, 0x46, 0xbd, 0x8a, 0x29, 0xf1, 0x70, 0x13, 0x73, 0xfb, 0x9, 0xa1, 0xa6, 0xe3, 0xc7, 0x15, 0x8f},
+               output224: []byte{0x44, 0x9a, 0x3, 0x13, 0xcc, 0xab, 0x44, 0x27, 0x3, 0x2b, 0x6b, 0xe9, 0xd6, 0x6f, 0x82, 0x7f, 0xfb, 0x4c, 0x71, 0xb5, 0x38, 0xb2, 0x10, 0x4f, 0x9d, 0x14, 0xd1, 0x4a},
+               output256: []byte{0xed, 0x53, 0xd7, 0x25, 0x95, 0xac, 0xe3, 0xa6, 0xd5, 0x16, 0x6a, 0x4e, 0xde, 0x41, 0xcc, 0xe3, 0x62, 0xd6, 0x44, 0xbd, 0xed, 0x77, 0x2b, 0xe6, 0x16, 0xb8, 0x7b, 0xcf, 0x67, 0x8a, 0x63, 0x64},
+               output384: []byte{0x31, 0x74, 0xcf, 0x37, 0x54, 0xa6, 0xfe, 0x60, 0x36, 0x31, 0xec, 0xda, 0x48, 0x95, 0x17, 0x1a, 0x9d, 0xcf, 0x7a, 0xfb, 0x2, 0xeb, 0x72, 0xae, 0x27, 0xa, 0x9e, 0x3e, 0xbf, 0x2a, 0x65, 0xa7, 0x2c, 0x34, 0x36, 0xc2, 0x33, 0xfd, 0x4f, 0x17, 0xf7, 0xfb, 0xaf, 0xba, 0xc0, 0x68, 0xc, 0x63},
+               output512: []byte{0x3c, 0xe9, 0x60, 0x77, 0xeb, 0x17, 0xc6, 0xa9, 0xc9, 0x5a, 0x9a, 0x47, 0x77, 0x48, 0x87, 0x6c, 0x64, 0x51, 0x9, 0x8d, 0xbe, 0xa2, 0xb3, 0x26, 0x1e, 0x6d, 0x75, 0xb6, 0x4a, 0x98, 0x8e, 0x1c, 0x75, 0xd7, 0xea, 0xc7, 0x3b, 0xc2, 0x40, 0x2a, 0xfc, 0x72, 0x65, 0x43, 0xe2, 0xa5, 0xbd, 0xb7, 0x66, 0x89, 0xc0, 0x93, 0x1f, 0xf7, 0x62, 0x81, 0x8d, 0xd2, 0xd3, 0xfe, 0x57, 0xa5, 0xf, 0xa9}},
+       testcase{
+               msg:       []byte{0xfa, 0x6e, 0xed, 0x24, 0xda, 0x66, 0x66, 0xa2, 0x22, 0x8, 0x14, 0x6b, 0x19, 0xa5, 0x32, 0xc2, 0xec, 0x9b, 0xa9, 0x4f, 0x9, 0xf1, 0xde, 0xf1, 0xe7, 0xfc, 0x13, 0xc3, 0x99, 0xa4, 0x8e, 0x41, 0xac, 0xc2, 0xa5, 0x89, 0xd0, 0x99, 0x27, 0x62, 0x96, 0x34, 0x8f, 0x39, 0x62, 0x53, 0xb5, 0x7c, 0xb0, 0xe4, 0x2, 0x91, 0xbd, 0x28, 0x27, 0x73, 0x65, 0x6b, 0x6e, 0xd, 0x8b, 0xea, 0x1c, 0xda, 0x8, 0x4a, 0x37, 0x38, 0x81, 0x6a, 0x84, 0x4, 0x85, 0xfc, 0xf3, 0xfb, 0x30, 0x7f, 0x77, 0x7f, 0xa5, 0xfe, 0xac, 0x48, 0x69, 0x5c, 0x2a, 0xf4, 0x76, 0x97, 0x20, 0x25, 0x8c, 0x77, 0x94, 0x3f, 0xb4, 0x55, 0x6c, 0x36, 0x2d, 0x9c, 0xba, 0x8b, 0xf1, 0x3, 0xae, 0xb9, 0x3, 0x4b, 0xaa, 0x8e, 0xa8, 0xbf, 0xb9, 0xc4, 0xf8, 0xe6, 0x74, 0x2c, 0xe0, 0xd5, 0x2c, 0x49, 0xea, 0x8e, 0x97, 0x4f, 0x33, 0x96, 0x12, 0xe8, 0x30, 0xe9, 0xe7, 0xa9, 0xc2, 0x90, 0x65},
+               output224: []byte{0x21, 0xe2, 0x76, 0x6, 0x44, 0xa1, 0x9e, 0xd1, 0x8e, 0xd0, 0xcd, 0x74, 0xc4, 0xe4, 0xc0, 0x71, 0xd7, 0x70, 0x13, 0x2a, 0xd2, 0x15, 0xeb, 0x6f, 0x7d, 0x42, 0xb0, 0x1d},
+               output256: []byte{0x81, 0x4, 0x1, 0xb2, 0x47, 0xc2, 0x35, 0x29, 0xe2, 0x46, 0x55, 0xca, 0xb8, 0x6c, 0x42, 0xdf, 0x44, 0x8, 0x5d, 0xa7, 0x6c, 0xa0, 0x1c, 0x9a, 0x14, 0x61, 0x8e, 0x56, 0x3b, 0x7c, 0x41, 0xbe},
+               output384: []byte{0x35, 0x48, 0x13, 0xd9, 0x82, 0x3d, 0x2f, 0x2, 0xd7, 0x5d, 0x13, 0x89, 0x3a, 0x6a, 0xbd, 0xb4, 0x4e, 0x9e, 0x99, 0x66, 0x65, 0x33, 0x42, 0x9c, 0xc6, 0xf7, 0xeb, 0x3f, 0xba, 0x10, 0xbf, 0x9e, 0xcd, 0x4a, 0x18, 0xbb, 0x9d, 0x51, 0x88, 0xe6, 0xe8, 0xf9, 0x1d, 0xfd, 0xdb, 0xe8, 0x40, 0x9a},
+               output512: []byte{0xc9, 0xac, 0xd6, 0xd9, 0x8a, 0x34, 0x95, 0x12, 0xb9, 0x52, 0xd1, 0x51, 0xed, 0x50, 0x15, 0x62, 0xf0, 0x4e, 0xa4, 0xbb, 0x4b, 0x89, 0x65, 0x81, 0x25, 0x10, 0xb9, 0xb8, 0x42, 0x53, 0x1a, 0x2b, 0x41, 0xa0, 0x10, 0x8a, 0xc1, 0x29, 0xcf, 0x9c, 0x95, 0x17, 0xbe, 0x79, 0x9, 0x21, 0xdf, 0x64, 0xad, 0x1d, 0xfc, 0xb, 0x93, 0xdd, 0xba, 0x34, 0x15, 0xee, 0xba, 0xf0, 0xda, 0x72, 0xf6, 0xa0}},
+       testcase{
+               msg:       []byte{0x9b, 0xb4, 0xaf, 0x1b, 0x4f, 0x9, 0xc0, 0x71, 0xce, 0x3c, 0xaf, 0xa9, 0x2e, 0x4e, 0xb7, 0x3c, 0xe8, 0xa6, 0xf5, 0xd8, 0x2a, 0x85, 0x73, 0x34, 0x40, 0x36, 0x8d, 0xee, 0x4e, 0xb1, 0xcb, 0xc7, 0xb5, 0x5a, 0xc1, 0x50, 0x77, 0x3b, 0x6f, 0xe4, 0x7d, 0xbe, 0x3, 0x6c, 0x45, 0x58, 0x2e, 0xd6, 0x7e, 0x23, 0xf4, 0xc7, 0x45, 0x85, 0xda, 0xb5, 0x9, 0xdf, 0x1b, 0x83, 0x61, 0x5, 0x64, 0x54, 0x56, 0x42, 0xb2, 0xb1, 0xec, 0x46, 0x3e, 0x18, 0x4, 0x8f, 0xc2, 0x34, 0x77, 0xc6, 0xb2, 0xaa, 0x3, 0x55, 0x94, 0xec, 0xd3, 0x37, 0x91, 0xaf, 0x6a, 0xf4, 0xcb, 0xc2, 0xa1, 0x16, 0x6a, 0xba, 0x8d, 0x62, 0x8c, 0x57, 0xe7, 0x7, 0xf0, 0xb0, 0xe8, 0x70, 0x7c, 0xaf, 0x91, 0xcd, 0x44, 0xbd, 0xb9, 0x15, 0xe0, 0x29, 0x6e, 0x1, 0x90, 0xd5, 0x6d, 0x33, 0xd8, 0xdd, 0xe1, 0xb, 0x5b, 0x60, 0x37, 0x78, 0x38, 0x97, 0x3c, 0x1d, 0x94, 0x3c, 0x22, 0xed, 0x33, 0x5e},
+               output224: []byte{0xd5, 0x53, 0x4c, 0x72, 0xbe, 0x2e, 0x4b, 0x1f, 0xaa, 0xa8, 0x13, 0x11, 0x8b, 0xd, 0x29, 0xdb, 0xb8, 0x6f, 0x62, 0x40, 0x67, 0xea, 0x34, 0x51, 0x5a, 0xfa, 0x8, 0xbe},
+               output256: []byte{0x9f, 0x1, 0xe6, 0x3f, 0x23, 0x55, 0x39, 0x3e, 0xcb, 0x19, 0x8, 0xd0, 0xca, 0xf3, 0x97, 0x18, 0x83, 0x30, 0x4, 0xa4, 0xbf, 0x37, 0xeb, 0xf4, 0xcf, 0x8d, 0x73, 0x19, 0xb6, 0x51, 0x72, 0xdf},
+               output384: []byte{0xe2, 0xef, 0xdc, 0x50, 0x7, 0xe4, 0xc1, 0x3f, 0x81, 0x10, 0x43, 0xdb, 0x96, 0x7a, 0x42, 0x3d, 0xe0, 0x2a, 0xf4, 0x11, 0xb4, 0xa2, 0x51, 0xa2, 0x25, 0xca, 0xd0, 0x41, 0xe8, 0x3b, 0xd4, 0xdd, 0x89, 0xd8, 0xb2, 0x41, 0x98, 0xda, 0x0, 0x9, 0x6c, 0xfe, 0x2e, 0x1b, 0x3f, 0x5d, 0x19, 0x60},
+               output512: []byte{0x26, 0xb4, 0xe5, 0xc4, 0xfa, 0x85, 0xcb, 0x33, 0x35, 0x94, 0x50, 0xe7, 0xf7, 0x15, 0x8f, 0xb6, 0xa0, 0x73, 0x99, 0x84, 0x56, 0x5e, 0x9d, 0x9e, 0xbe, 0x6a, 0xd6, 0x5b, 0x11, 0x82, 0x96, 0xe9, 0xc1, 0x9, 0x8c, 0x11, 0x54, 0x1c, 0x87, 0x1e, 0xb1, 0xb8, 0x98, 0x53, 0xf1, 0xfa, 0x73, 0xad, 0x87, 0x2, 0xeb, 0xf4, 0xfc, 0x9b, 0xe4, 0xd0, 0xab, 0x5, 0x7e, 0x43, 0x91, 0xdf, 0x96, 0x4e}},
+       testcase{
+               msg:       []byte{0x21, 0x67, 0xf0, 0x21, 0x18, 0xcc, 0x62, 0x4, 0x3e, 0x90, 0x91, 0xa6, 0x47, 0xca, 0xdb, 0xed, 0x95, 0x61, 0x1a, 0x52, 0x1f, 0xe0, 0xd6, 0x4e, 0x85, 0x18, 0xf1, 0x6c, 0x80, 0x8a, 0xb2, 0x97, 0x72, 0x55, 0x98, 0xae, 0x29, 0x68, 0x80, 0xa7, 0x73, 0x60, 0x7a, 0x79, 0x8f, 0x7c, 0x3c, 0xfc, 0xe8, 0xd, 0x25, 0x1e, 0xbe, 0xc6, 0x88, 0x50, 0x15, 0xf9, 0xab, 0xf7, 0xea, 0xab, 0xae, 0x46, 0x79, 0x8f, 0x82, 0xcb, 0x59, 0x26, 0xde, 0x5c, 0x23, 0xf4, 0x4a, 0x3f, 0x9f, 0x95, 0x34, 0xb3, 0xc6, 0xf4, 0x5, 0xb5, 0x36, 0x4c, 0x2f, 0x8a, 0x8b, 0xdc, 0x5c, 0xa4, 0x9c, 0x74, 0x9b, 0xed, 0x8c, 0xe4, 0xba, 0x48, 0x89, 0x70, 0x62, 0xae, 0x84, 0x24, 0xca, 0x6d, 0xde, 0x5f, 0x55, 0xc0, 0xe4, 0x2a, 0x95, 0xd1, 0xe2, 0x92, 0xca, 0x54, 0xfb, 0x46, 0xa8, 0x4f, 0xbc, 0x9c, 0xd8, 0x7f, 0x2d, 0xc, 0x9e, 0x74, 0x48, 0xde, 0x30, 0x43, 0xae, 0x22, 0xfd, 0xd2, 0x29},
+               output224: []byte{0xc0, 0xcd, 0x41, 0x3b, 0x1c, 0xe0, 0x0, 0xa1, 0xbb, 0xe3, 0xa2, 0xcd, 0x10, 0x3c, 0x7f, 0x8f, 0x95, 0x92, 0x5a, 0xc6, 0xc8, 0xa5, 0xc9, 0x22, 0xaf, 0xb5, 0xf9, 0x6d},
+               output256: []byte{0x7e, 0xc1, 0x1d, 0xe7, 0xdb, 0x79, 0xa, 0x85, 0x2, 0x81, 0xf0, 0x43, 0x59, 0x27, 0x79, 0xb4, 0x9, 0x19, 0x5d, 0xb4, 0xec, 0xed, 0xee, 0xfb, 0xb9, 0x3b, 0xa6, 0x83, 0xd3, 0xbc, 0xa8, 0x51},
+               output384: []byte{0xe4, 0x4c, 0x8, 0x56, 0xf0, 0xc2, 0x45, 0xe0, 0x2, 0xf9, 0x14, 0xcf, 0x30, 0xe, 0x98, 0xc4, 0x96, 0xe7, 0x25, 0xa4, 0xdb, 0x56, 0x1f, 0x29, 0x95, 0xad, 0x9c, 0x8b, 0x97, 0xf3, 0x41, 0xe1, 0x56, 0x25, 0xb5, 0x6b, 0x3, 0xd4, 0xd5, 0x88, 0x9, 0x27, 0xb8, 0x57, 0x4f, 0x5e, 0x5d, 0x74},
+               output512: []byte{0x91, 0x3b, 0xba, 0x5c, 0xc, 0x13, 0xcc, 0x49, 0xd8, 0x31, 0x0, 0x14, 0xcf, 0x5a, 0xf1, 0xb6, 0x3b, 0xa3, 0xd5, 0xdb, 0x8a, 0x27, 0x69, 0x9f, 0xcf, 0xc5, 0x73, 0x68, 0x8f, 0xe, 0x82, 0x6f, 0xb5, 0xa7, 0xb5, 0xd1, 0xd, 0x3a, 0x1d, 0xe6, 0x93, 0xaa, 0x66, 0xe0, 0x8c, 0x9, 0x15, 0xe7, 0x27, 0x8f, 0x61, 0xb5, 0xfa, 0x30, 0xf1, 0x26, 0x3b, 0x13, 0x4f, 0x1, 0x6f, 0x74, 0x84, 0x1f}},
+       testcase{
+               msg:       []byte{0x94, 0xb7, 0xfa, 0xb, 0xc1, 0xc4, 0x4e, 0x94, 0x9b, 0x1d, 0x76, 0x17, 0xd3, 0x1b, 0x47, 0x20, 0xcb, 0xe7, 0xca, 0x57, 0xc6, 0xfa, 0x4f, 0x40, 0x94, 0xd4, 0x76, 0x15, 0x67, 0xe3, 0x89, 0xec, 0xc6, 0x4f, 0x69, 0x68, 0xe4, 0x6, 0x4d, 0xf7, 0xd, 0xf8, 0x36, 0xa4, 0x7d, 0xc, 0x71, 0x33, 0x36, 0xb5, 0x2, 0x8b, 0x35, 0x93, 0xd, 0x29, 0xeb, 0x7a, 0x7f, 0x9a, 0x5a, 0xf9, 0xad, 0x5c, 0xf4, 0x41, 0x74, 0x5b, 0xae, 0xc9, 0xbb, 0x1, 0x4c, 0xee, 0xff, 0x5a, 0x41, 0xba, 0x5c, 0x1c, 0xe0, 0x85, 0xfe, 0xb9, 0x80, 0xba, 0xb9, 0xcf, 0x79, 0xf2, 0x15, 0x8e, 0x3, 0xef, 0x7e, 0x63, 0xe2, 0x9c, 0x38, 0xd7, 0x81, 0x6a, 0x84, 0xd4, 0xf7, 0x1e, 0xf, 0x54, 0x8b, 0x7f, 0xc3, 0x16, 0x8, 0x5a, 0xe3, 0x8a, 0x6, 0xf, 0xf9, 0xb8, 0xde, 0xc3, 0x6f, 0x91, 0xad, 0x9e, 0xbc, 0xa, 0x5b, 0x6c, 0x33, 0x8c, 0xbb, 0x8f, 0x66, 0x59, 0xd3, 0x42, 0xa2, 0x43, 0x68, 0xcf},
+               output224: []byte{0x93, 0xc6, 0xbf, 0x58, 0x5e, 0x99, 0x4b, 0x16, 0x69, 0x18, 0x4a, 0xc7, 0x1d, 0xc8, 0xe7, 0x72, 0xb5, 0x34, 0x43, 0xe6, 0x68, 0xda, 0x7, 0x86, 0xd5, 0x28, 0x9, 0xb},
+               output256: []byte{0xa7, 0x4a, 0xf9, 0xc5, 0x23, 0xb4, 0xa0, 0x8d, 0x9d, 0xb9, 0x69, 0x2e, 0xa8, 0x92, 0x55, 0x97, 0x7a, 0x59, 0x19, 0xb9, 0x29, 0x2b, 0x7c, 0xd0, 0xd9, 0x2c, 0x90, 0xc9, 0x7c, 0x98, 0xe2, 0x24},
+               output384: []byte{0x5d, 0x29, 0xc, 0x5d, 0xff, 0x59, 0xa3, 0xa3, 0xdb, 0x8b, 0xc7, 0x32, 0xb, 0x8f, 0x64, 0xa4, 0xdb, 0xf6, 0x7c, 0xa4, 0xf5, 0xdf, 0x9a, 0x7, 0xf2, 0x35, 0xed, 0xb6, 0x46, 0x3, 0x45, 0xfc, 0x89, 0x71, 0x4, 0x4, 0x81, 0xc9, 0xa5, 0xd0, 0xf0, 0x9b, 0x62, 0x26, 0x2b, 0x9e, 0xd9, 0xf8},
+               output512: []byte{0xe5, 0xd5, 0x3e, 0x81, 0x86, 0x62, 0x83, 0x17, 0x90, 0x12, 0xd9, 0x23, 0x93, 0x40, 0xb0, 0xcb, 0xfb, 0x8d, 0x7a, 0xeb, 0xce, 0xc, 0x82, 0x4d, 0xc6, 0x65, 0x3a, 0x65, 0x2b, 0xb1, 0xb5, 0x4e, 0x8, 0x83, 0x99, 0x1b, 0xe2, 0xc3, 0xe3, 0x9a, 0xd1, 0x11, 0xa7, 0xb2, 0x4e, 0x95, 0xda, 0xf6, 0xf7, 0xd9, 0xa3, 0x79, 0xd8, 0x84, 0xd6, 0x4f, 0x9c, 0x2a, 0xfd, 0x64, 0x5e, 0x1d, 0xb5, 0xe2}},
+       testcase{
+               msg:       []byte{0xea, 0x40, 0xe8, 0x3c, 0xb1, 0x8b, 0x3a, 0x24, 0x2c, 0x1e, 0xcc, 0x6c, 0xcd, 0xb, 0x78, 0x53, 0xa4, 0x39, 0xda, 0xb2, 0xc5, 0x69, 0xcf, 0xc6, 0xdc, 0x38, 0xa1, 0x9f, 0x5c, 0x90, 0xac, 0xbf, 0x76, 0xae, 0xf9, 0xea, 0x37, 0x42, 0xff, 0x3b, 0x54, 0xef, 0x7d, 0x36, 0xeb, 0x7c, 0xe4, 0xff, 0x1c, 0x9a, 0xb3, 0xbc, 0x11, 0x9c, 0xff, 0x6b, 0xe9, 0x3c, 0x3, 0xe2, 0x8, 0x78, 0x33, 0x35, 0xc0, 0xab, 0x81, 0x37, 0xbe, 0x5b, 0x10, 0xcd, 0xc6, 0x6f, 0xf3, 0xf8, 0x9a, 0x1b, 0xdd, 0xc6, 0xa1, 0xee, 0xd7, 0x4f, 0x50, 0x4c, 0xbe, 0x72, 0x90, 0x69, 0xb, 0xb2, 0x95, 0xa8, 0x72, 0xb9, 0xe3, 0xfe, 0x2c, 0xee, 0x9e, 0x6c, 0x67, 0xc4, 0x1d, 0xb8, 0xef, 0xd7, 0xd8, 0x63, 0xcf, 0x10, 0xf8, 0x40, 0xfe, 0x61, 0x8e, 0x79, 0x36, 0xda, 0x3d, 0xca, 0x5c, 0xa6, 0xdf, 0x93, 0x3f, 0x24, 0xf6, 0x95, 0x4b, 0xa0, 0x80, 0x1a, 0x12, 0x94, 0xcd, 0x8d, 0x7e, 0x66, 0xdf, 0xaf, 0xec},
+               output224: []byte{0xbf, 0xe1, 0x5b, 0xb5, 0x1f, 0x68, 0xf, 0x2f, 0x48, 0x9f, 0xf, 0xde, 0xb3, 0x2f, 0x27, 0x10, 0x90, 0xa0, 0x9d, 0x15, 0x63, 0xf2, 0x9f, 0xea, 0xf9, 0x21, 0x4, 0xe0},
+               output256: []byte{0x34, 0x4d, 0x12, 0x9c, 0x22, 0x83, 0x59, 0x46, 0x3c, 0x40, 0x55, 0x5d, 0x94, 0x21, 0x3d, 0x1, 0x56, 0x27, 0xe5, 0x87, 0x1c, 0x4, 0xf1, 0x6, 0xa0, 0xfe, 0xef, 0x93, 0x61, 0xcd, 0xec, 0xb6},
+               output384: []byte{0xfe, 0x68, 0x2, 0x50, 0xca, 0xb1, 0xfb, 0xdb, 0x6a, 0xc8, 0x80, 0xd, 0xdc, 0x28, 0xe7, 0x1, 0x0, 0xdf, 0x8d, 0xaa, 0xe3, 0x8d, 0xa2, 0x70, 0x4, 0x87, 0x2a, 0xb0, 0x5d, 0x40, 0xb1, 0x5a, 0xe9, 0x3e, 0xb4, 0x42, 0x66, 0xe3, 0x1, 0x4f, 0x9, 0x60, 0x3, 0x8b, 0x28, 0x25, 0x2c, 0x7b},
+               output512: []byte{0x5d, 0xa8, 0x3b, 0x7e, 0x22, 0x19, 0x33, 0xcd, 0x67, 0xfa, 0x2a, 0xf8, 0xc9, 0x93, 0x4d, 0xb7, 0x4c, 0xe8, 0x22, 0x21, 0x2c, 0x99, 0xe0, 0xee, 0x1, 0xf5, 0x22, 0xb, 0x4f, 0xe1, 0xe9, 0xb0, 0x38, 0x8e, 0x42, 0xe3, 0x28, 0xa1, 0xd1, 0x74, 0xe6, 0x36, 0x8f, 0x57, 0x73, 0x85, 0x30, 0x42, 0x54, 0x3a, 0x9b, 0x49, 0x3a, 0x94, 0xb6, 0x25, 0x98, 0xb, 0x73, 0xdf, 0x3f, 0x3f, 0xcc, 0xbb}},
+       testcase{
+               msg:       []byte{0x15, 0x7d, 0x5b, 0x7e, 0x45, 0x7, 0xf6, 0x6d, 0x9a, 0x26, 0x74, 0x76, 0xd3, 0x38, 0x31, 0xe7, 0xbb, 0x76, 0x8d, 0x4d, 0x4, 0xcc, 0x34, 0x38, 0xda, 0x12, 0xf9, 0x1, 0x2, 0x63, 0xea, 0x5f, 0xca, 0xfb, 0xde, 0x25, 0x79, 0xdb, 0x2f, 0x6b, 0x58, 0xf9, 0x11, 0xd5, 0x93, 0xd5, 0xf7, 0x9f, 0xb0, 0x5f, 0xe3, 0x59, 0x6e, 0x3f, 0xa8, 0xf, 0xf2, 0xf7, 0x61, 0xd1, 0xb0, 0xe5, 0x70, 0x80, 0x5, 0x5c, 0x11, 0x8c, 0x53, 0xe5, 0x3c, 0xdb, 0x63, 0x5, 0x52, 0x61, 0xd7, 0xc9, 0xb2, 0xb3, 0x9b, 0xd9, 0xa, 0xcc, 0x32, 0x52, 0xc, 0xbb, 0xdb, 0xda, 0x2c, 0x4f, 0xd8, 0x85, 0x6d, 0xbc, 0xee, 0x17, 0x31, 0x32, 0xa2, 0x67, 0x91, 0x98, 0xda, 0xf8, 0x30, 0x7, 0xa9, 0xb5, 0xc5, 0x15, 0x11, 0xae, 0x49, 0x76, 0x6c, 0x79, 0x2a, 0x29, 0x52, 0x3, 0x88, 0x44, 0x4e, 0xbe, 0xfe, 0x28, 0x25, 0x6f, 0xb3, 0x3d, 0x42, 0x60, 0x43, 0x9c, 0xba, 0x73, 0xa9, 0x47, 0x9e, 0xe0, 0xc, 0x63},
+               output224: []byte{0x6d, 0x73, 0x5f, 0xb7, 0x57, 0x91, 0x35, 0xf6, 0x1b, 0x77, 0x1b, 0x2b, 0xb0, 0xd8, 0x15, 0x14, 0xcd, 0xe9, 0xc9, 0x77, 0xac, 0xcf, 0x6f, 0xea, 0xf6, 0xed, 0xeb, 0xf0},
+               output256: []byte{0x4c, 0xe7, 0xc2, 0xb9, 0x35, 0xf2, 0x1f, 0xc3, 0x4c, 0x5e, 0x56, 0xd9, 0x40, 0xa5, 0x55, 0xc5, 0x93, 0x87, 0x2a, 0xec, 0x2f, 0x89, 0x6d, 0xe4, 0xe6, 0x8f, 0x2a, 0x1, 0x70, 0x60, 0xf5, 0x35},
+               output384: []byte{0x51, 0x1b, 0x13, 0xe5, 0x3f, 0xd3, 0x53, 0xfa, 0x4d, 0x38, 0xef, 0xc, 0xf8, 0xf1, 0xaf, 0x30, 0xda, 0x55, 0x48, 0x28, 0xa5, 0xfd, 0x1c, 0x53, 0xec, 0x41, 0xf7, 0x3d, 0x9a, 0xca, 0x6c, 0x54, 0xac, 0x79, 0x72, 0xc9, 0x33, 0xaf, 0x4a, 0x2f, 0xc7, 0xab, 0x85, 0x2c, 0xa6, 0x3a, 0x1b, 0xa6},
+               output512: []byte{0x72, 0xde, 0x91, 0x84, 0xbe, 0xb5, 0xc6, 0xa3, 0x7e, 0xa2, 0xc3, 0x95, 0x73, 0x4d, 0xd, 0x54, 0x12, 0x99, 0x1a, 0x57, 0xcf, 0xfc, 0xc1, 0x3f, 0xf9, 0xb5, 0xfa, 0xf, 0x20, 0x46, 0xee, 0x87, 0xc6, 0x18, 0x11, 0xfe, 0x8e, 0xf2, 0x47, 0x2, 0x39, 0xd5, 0x6, 0x6c, 0x22, 0x1, 0x73, 0xde, 0x5e, 0xbe, 0x41, 0x88, 0x5e, 0xd8, 0xac, 0xae, 0x39, 0x7f, 0xb3, 0x95, 0xe6, 0xca, 0x9a, 0xee}},
+       testcase{
+               msg:       []byte{0x83, 0x6b, 0x34, 0xb5, 0x15, 0x47, 0x6f, 0x61, 0x3f, 0xe4, 0x47, 0xa4, 0xe0, 0xc3, 0xf3, 0xb8, 0xf2, 0x9, 0x10, 0xac, 0x89, 0xa3, 0x97, 0x70, 0x55, 0xc9, 0x60, 0xd2, 0xd5, 0xd2, 0xb7, 0x2b, 0xd8, 0xac, 0xc7, 0x15, 0xa9, 0x3, 0x53, 0x21, 0xb8, 0x67, 0x3, 0xa4, 0x11, 0xdd, 0xe0, 0x46, 0x6d, 0x58, 0xa5, 0x97, 0x69, 0x67, 0x2a, 0xa6, 0xa, 0xd5, 0x87, 0xb8, 0x48, 0x1d, 0xe4, 0xbb, 0xa5, 0x52, 0xa1, 0x64, 0x57, 0x79, 0x78, 0x95, 0x1, 0xec, 0x53, 0xd5, 0x40, 0xb9, 0x4, 0x82, 0x1f, 0x32, 0xb0, 0xbd, 0x18, 0x55, 0xb0, 0x4e, 0x48, 0x48, 0xf9, 0xf8, 0xcf, 0xe9, 0xeb, 0xd8, 0x91, 0x1b, 0xe9, 0x57, 0x81, 0xa7, 0x59, 0xd7, 0xad, 0x97, 0x24, 0xa7, 0x10, 0x2d, 0xbe, 0x57, 0x67, 0x76, 0xb7, 0xc6, 0x32, 0xbc, 0x39, 0xb9, 0xb5, 0xe1, 0x90, 0x57, 0xe2, 0x26, 0x55, 0x2a, 0x59, 0x94, 0xc1, 0xdb, 0xb3, 0xb5, 0xc7, 0x87, 0x1a, 0x11, 0xf5, 0x53, 0x70, 0x11, 0x4, 0x4c, 0x53},
+               output224: []byte{0x6d, 0x93, 0x15, 0x31, 0x45, 0x90, 0x4c, 0xeb, 0xe0, 0xe8, 0xa6, 0x6c, 0x27, 0x2b, 0xed, 0xf4, 0xf0, 0xd0, 0xa3, 0xc5, 0x3a, 0xb3, 0x2, 0x64, 0x13, 0x54, 0x31, 0xa7},
+               output256: []byte{0x24, 0xb6, 0x9d, 0x8a, 0xb3, 0x5b, 0xac, 0xcb, 0xd9, 0x2f, 0x94, 0xe1, 0xb7, 0xb, 0x7, 0xc4, 0xc0, 0xec, 0xf1, 0x4e, 0xae, 0xac, 0x4b, 0x6b, 0x85, 0x60, 0x96, 0x6d, 0x5b, 0xe0, 0x86, 0xf3},
+               output384: []byte{0x55, 0x4c, 0xf0, 0xa, 0x9a, 0xaf, 0xe0, 0xdf, 0xc8, 0xd4, 0x9e, 0xa0, 0x32, 0x88, 0xb5, 0x2a, 0xed, 0x43, 0xa5, 0x10, 0x4e, 0x22, 0xb8, 0x38, 0xe4, 0xf, 0xde, 0x73, 0x58, 0x49, 0x1b, 0x57, 0x74, 0xdf, 0x45, 0x5c, 0xf2, 0xec, 0x73, 0xc5, 0x3a, 0x7b, 0x30, 0x62, 0x7a, 0x14, 0x2a, 0x41},
+               output512: []byte{0xb6, 0x78, 0xfa, 0x76, 0x55, 0x58, 0x49, 0x70, 0xde, 0xdb, 0xbc, 0x73, 0xa1, 0x6d, 0x78, 0x40, 0x93, 0x5b, 0x10, 0x4d, 0x6, 0xdc, 0xb4, 0x68, 0xdd, 0xd9, 0x81, 0x4d, 0x6c, 0xf4, 0x43, 0xfa, 0x6f, 0x92, 0x45, 0x82, 0x4d, 0xbf, 0xf3, 0xab, 0x5f, 0xff, 0xef, 0x24, 0xb2, 0x9c, 0xb2, 0x97, 0x87, 0x96, 0xf3, 0x7e, 0x7b, 0x49, 0xb1, 0x68, 0x2d, 0x59, 0xf7, 0x9e, 0x3c, 0x16, 0x9e, 0x81}},
+       testcase{
+               msg:       []byte{0xcc, 0x77, 0x84, 0xa4, 0x91, 0x2a, 0x7a, 0xb5, 0xad, 0x36, 0x20, 0xaa, 0xb2, 0x9b, 0xa8, 0x70, 0x77, 0xcd, 0x3c, 0xb8, 0x36, 0x36, 0xad, 0xc9, 0xf3, 0xdc, 0x94, 0xf5, 0x1e, 0xdf, 0x52, 0x1b, 0x21, 0x61, 0xef, 0x10, 0x8f, 0x21, 0xa0, 0xa2, 0x98, 0x55, 0x79, 0x81, 0xc0, 0xe5, 0x3c, 0xe6, 0xce, 0xd4, 0x5b, 0xdf, 0x78, 0x2c, 0x1e, 0xf2, 0x0, 0xd2, 0x9b, 0xab, 0x81, 0xdd, 0x64, 0x60, 0x58, 0x69, 0x64, 0xed, 0xab, 0x7c, 0xeb, 0xdb, 0xbe, 0xc7, 0x5f, 0xd7, 0x92, 0x50, 0x60, 0xf7, 0xda, 0x2b, 0x85, 0x3b, 0x2b, 0x8, 0x95, 0x88, 0xfa, 0xf, 0x8c, 0x16, 0xec, 0x64, 0x98, 0xb1, 0x4c, 0x55, 0xdc, 0xee, 0x33, 0x5c, 0xb3, 0xa9, 0x1d, 0x69, 0x8e, 0x4d, 0x39, 0x3a, 0xb8, 0xe8, 0xea, 0xc0, 0x82, 0x5f, 0x8a, 0xde, 0xbe, 0xee, 0x19, 0x6d, 0xf4, 0x12, 0x5, 0xc0, 0x11, 0x67, 0x4e, 0x53, 0x42, 0x6c, 0xaa, 0x45, 0x3f, 0x8d, 0xe1, 0xcb, 0xb5, 0x79, 0x32, 0xb0, 0xb7, 0x41, 0xd4, 0xc6},
+               output224: []byte{0xaf, 0xe3, 0x5, 0x35, 0x67, 0x5a, 0x70, 0x21, 0xbf, 0x61, 0x89, 0x41, 0xd9, 0x4d, 0xdf, 0xfc, 0xce, 0xfc, 0xaa, 0x1e, 0xf0, 0x6c, 0xde, 0x30, 0x6d, 0x5d, 0x7a, 0x75},
+               output256: []byte{0x19, 0xf3, 0x42, 0x15, 0x37, 0x3e, 0x8e, 0x80, 0xf6, 0x86, 0x95, 0x3e, 0x3, 0xca, 0x47, 0x2b, 0x50, 0x21, 0x67, 0x19, 0xcb, 0x51, 0x5e, 0x6, 0x67, 0xd4, 0xe6, 0x86, 0xe4, 0x5f, 0xcf, 0x7c},
+               output384: []byte{0xc1, 0x3c, 0x17, 0x7e, 0x64, 0x53, 0xf7, 0x8e, 0x81, 0xbc, 0x4e, 0xfe, 0xa7, 0xa1, 0xe, 0x9c, 0xa0, 0x22, 0x73, 0xa6, 0xeb, 0x75, 0x74, 0x97, 0x36, 0x85, 0x39, 0xbf, 0x4a, 0xe1, 0xf1, 0xbb, 0xcb, 0xae, 0xf, 0xff, 0x5d, 0xad, 0x55, 0xed, 0xca, 0x61, 0xf4, 0x74, 0x97, 0x6c, 0xbf, 0x64},
+               output512: []byte{0x66, 0xc6, 0x4d, 0x5b, 0x5, 0x85, 0xdd, 0x8c, 0x40, 0xbe, 0xcd, 0x45, 0x6e, 0x4b, 0x1, 0x88, 0x6, 0x1a, 0xe8, 0x5, 0x9f, 0x3, 0xe7, 0x9f, 0xe0, 0x4c, 0x40, 0x92, 0x54, 0x42, 0xba, 0x93, 0xb0, 0x52, 0xf5, 0x20, 0x87, 0xb3, 0xb, 0xdb, 0xfd, 0x48, 0x16, 0xbb, 0xd1, 0x48, 0x69, 0x6d, 0x4f, 0xa6, 0xc6, 0x1f, 0x21, 0x62, 0x53, 0xd7, 0xac, 0x17, 0x8b, 0x39, 0xec, 0x44, 0xc7, 0x70}},
+       testcase{
+               msg:       []byte{0x76, 0x39, 0xb4, 0x61, 0xff, 0xf2, 0x70, 0xb2, 0x45, 0x5a, 0xc1, 0xd1, 0xaf, 0xce, 0x78, 0x29, 0x44, 0xae, 0xa5, 0xe9, 0x8, 0x7e, 0xb4, 0xa3, 0x9e, 0xb9, 0x6b, 0xb5, 0xc3, 0xba, 0xaf, 0xe, 0x86, 0x8c, 0x85, 0x26, 0xd3, 0x40, 0x4f, 0x94, 0x5, 0xe7, 0x9e, 0x77, 0xbf, 0xac, 0x5f, 0xfb, 0x89, 0xbf, 0x19, 0x57, 0xb5, 0x23, 0xe1, 0x7d, 0x34, 0x1d, 0x73, 0x23, 0xc3, 0x2, 0xea, 0x70, 0x83, 0x87, 0x2d, 0xd5, 0xe8, 0x70, 0x56, 0x94, 0xac, 0xdd, 0xa3, 0x6d, 0x5a, 0x1b, 0x89, 0x5a, 0xaa, 0x16, 0xec, 0xa6, 0x10, 0x4c, 0x82, 0x68, 0x85, 0x32, 0xc8, 0xbf, 0xe1, 0x79, 0xb, 0x5d, 0xc9, 0xf4, 0xec, 0x5f, 0xe9, 0x5b, 0xae, 0xd3, 0x7e, 0x1d, 0x28, 0x7b, 0xe7, 0x10, 0x43, 0x1f, 0x1e, 0x5e, 0x8e, 0xe1, 0x5, 0xbc, 0x42, 0xed, 0x37, 0xd7, 0x4b, 0x1e, 0x55, 0x98, 0x4b, 0xf1, 0xc0, 0x9f, 0xe6, 0xa1, 0xfa, 0x13, 0xef, 0x3b, 0x96, 0xfa, 0xea, 0xed, 0x6a, 0x2a, 0x19, 0x50, 0xa1, 0x21, 0x53},
+               output224: []byte{0x91, 0x65, 0x1, 0x61, 0x48, 0x91, 0xbd, 0x99, 0x40, 0xa, 0x8a, 0xea, 0xab, 0xf6, 0x93, 0x26, 0xfa, 0x98, 0xb8, 0x33, 0xae, 0xd8, 0x23, 0x86, 0xab, 0x19, 0xe5, 0x7},
+               output256: []byte{0x29, 0xb, 0xd4, 0x80, 0x8e, 0x56, 0x76, 0xeb, 0xc, 0x97, 0x80, 0x84, 0xe4, 0xcd, 0x68, 0xe7, 0x45, 0x3, 0x16, 0x59, 0xa2, 0x68, 0x7, 0xad, 0x61, 0x5b, 0x10, 0xcd, 0xa5, 0x89, 0xb9, 0x69},
+               output384: []byte{0xc3, 0xe5, 0xdd, 0xf4, 0x57, 0x2a, 0x38, 0x6c, 0x99, 0xf9, 0x98, 0xe6, 0x8f, 0xcc, 0xc7, 0xf8, 0x58, 0x67, 0xa7, 0x3e, 0x13, 0xc2, 0x5, 0x8c, 0x18, 0x39, 0x1a, 0x92, 0x24, 0x16, 0xfd, 0x35, 0x2c, 0xa6, 0xb6, 0x59, 0xba, 0xd0, 0x21, 0xe0, 0xd9, 0xa0, 0x57, 0x89, 0xf5, 0x9d, 0x3c, 0x67},
+               output512: []byte{0xa7, 0xbd, 0x50, 0x6d, 0xb9, 0xc0, 0x50, 0x9a, 0xd4, 0x74, 0x13, 0xaf, 0x4b, 0xe, 0x39, 0x48, 0xb4, 0x7c, 0x18, 0x27, 0x8f, 0x15, 0xf5, 0xb1, 0x9f, 0xbb, 0xb, 0x76, 0xe2, 0xc1, 0xc1, 0xf1, 0x9d, 0xb9, 0x43, 0x85, 0x28, 0xeb, 0x6d, 0x87, 0xb0, 0xb4, 0xa5, 0x9, 0x56, 0x7d, 0xb3, 0x9f, 0x32, 0x64, 0x1e, 0x29, 0x44, 0x36, 0x57, 0x80, 0x91, 0x42, 0x96, 0xcf, 0x3e, 0x48, 0xce, 0xcf}},
+       testcase{
+               msg:       []byte{0xeb, 0x65, 0x13, 0xfc, 0x61, 0xb3, 0xc, 0xfb, 0xa5, 0x8d, 0x4d, 0x7e, 0x80, 0xf9, 0x4d, 0x14, 0x58, 0x90, 0x90, 0xcf, 0x1d, 0x80, 0xb1, 0xdf, 0x2e, 0x68, 0x8, 0x8d, 0xc6, 0x10, 0x49, 0x59, 0xba, 0xd, 0x58, 0x3d, 0x58, 0x5e, 0x95, 0x78, 0xab, 0xa, 0xec, 0xc, 0xf3, 0x6c, 0x48, 0x43, 0x5e, 0xb5, 0x2e, 0xd9, 0xab, 0x4b, 0xbc, 0xe7, 0xa5, 0xab, 0xe6, 0x79, 0xc9, 0x7a, 0xe2, 0xdb, 0xe3, 0x5e, 0x8c, 0xc1, 0xd4, 0x5b, 0x6, 0xdd, 0xa3, 0xcf, 0x41, 0x86, 0x65, 0xc5, 0x7c, 0xbe, 0xe4, 0xbb, 0xb4, 0x7f, 0xa4, 0xca, 0xf7, 0x8f, 0x4e, 0xe6, 0x56, 0xfe, 0xc2, 0x37, 0xfe, 0x4e, 0xeb, 0xba, 0xfa, 0x20, 0x6e, 0x1e, 0xf2, 0xbd, 0xe, 0xe4, 0xae, 0x71, 0xbd, 0xe, 0x9b, 0x2f, 0x54, 0xf9, 0x1d, 0xaa, 0xdf, 0x1f, 0xeb, 0xfd, 0x70, 0x32, 0x38, 0x1d, 0x63, 0x6b, 0x73, 0x3d, 0xcb, 0x3b, 0xf7, 0x6f, 0xb1, 0x4e, 0x23, 0xaf, 0xf1, 0xf6, 0x8e, 0xd3, 0xdb, 0xcf, 0x75, 0xc9, 0xb9, 0x9c, 0x6f, 0x26},
+               output224: []byte{0x9c, 0x37, 0x59, 0x90, 0x5e, 0x47, 0xe4, 0x9c, 0xc7, 0x5, 0x7c, 0x92, 0x37, 0x54, 0x5d, 0x44, 0x4f, 0x75, 0x85, 0x35, 0xf9, 0x91, 0xf7, 0xe8, 0x72, 0x8f, 0x3a, 0x51},
+               output256: []byte{0x70, 0x99, 0x9a, 0xb9, 0x81, 0x83, 0x9, 0xaf, 0xa8, 0xf1, 0xad, 0xc4, 0xfe, 0xa4, 0x7a, 0x7, 0x1a, 0x8a, 0xbd, 0x94, 0x1, 0x2f, 0x7c, 0xe2, 0x8c, 0xc7, 0x94, 0xa0, 0xd9, 0x97, 0xc5, 0xcb},
+               output384: []byte{0x15, 0x74, 0x81, 0xd0, 0xa2, 0x4b, 0xa9, 0xfa, 0xfa, 0x18, 0x0, 0xc9, 0x71, 0x3e, 0x70, 0x29, 0x76, 0x16, 0x7f, 0xdd, 0xf5, 0x23, 0x67, 0xa7, 0x93, 0x2a, 0xa3, 0xcf, 0xf2, 0x2f, 0x4a, 0x2e, 0x19, 0xa0, 0x16, 0xc7, 0xba, 0xcb, 0xd9, 0x7c, 0xec, 0x3e, 0xa6, 0xb1, 0xe8, 0x7c, 0xb3, 0xd3},
+               output512: []byte{0x2e, 0x68, 0x1f, 0x9d, 0xdb, 0xd7, 0xc7, 0x7e, 0xab, 0xd, 0x22, 0x5e, 0x2a, 0xd1, 0xf7, 0x22, 0x56, 0xbe, 0x23, 0x9d, 0xf2, 0x59, 0x33, 0xbc, 0xd6, 0xce, 0xdd, 0x75, 0x72, 0x69, 0xb3, 0x5e, 0x2a, 0x53, 0x52, 0xb3, 0x29, 0x8a, 0x4c, 0xda, 0x5, 0x42, 0xff, 0x7d, 0x3a, 0xdd, 0x2b, 0xc, 0xf4, 0x2f, 0x10, 0xfb, 0xe0, 0x5a, 0x67, 0xc8, 0x76, 0x3d, 0x54, 0xa7, 0x8a, 0x43, 0xae, 0xa7}},
+       testcase{
+               msg:       []byte{0x15, 0x94, 0xd7, 0x4b, 0xf5, 0xdd, 0xe4, 0x44, 0x26, 0x5d, 0x4c, 0x4, 0xda, 0xd9, 0x72, 0x1f, 0xf3, 0xe3, 0x4c, 0xbf, 0x62, 0x2d, 0xaf, 0x34, 0x1f, 0xe1, 0x6b, 0x96, 0x43, 0x1f, 0x6c, 0x4d, 0xf1, 0xf7, 0x60, 0xd3, 0x4f, 0x29, 0x6e, 0xb9, 0x7d, 0x98, 0xd5, 0x60, 0xad, 0x52, 0x86, 0xfe, 0xc4, 0xdc, 0xe1, 0x72, 0x4f, 0x20, 0xb5, 0x4f, 0xd7, 0xdf, 0x51, 0xd4, 0xbf, 0x13, 0x7a, 0xdd, 0x65, 0x6c, 0x80, 0x54, 0x6f, 0xb1, 0xbf, 0x51, 0x6d, 0x62, 0xee, 0x82, 0xba, 0xa9, 0x92, 0x91, 0xe, 0xf4, 0xcc, 0x18, 0xb7, 0xf, 0x3f, 0x86, 0x98, 0x27, 0x6f, 0xcf, 0xb4, 0x4e, 0xe, 0xc5, 0x46, 0xc2, 0xc3, 0x9c, 0xfd, 0x8e, 0xe9, 0x10, 0x34, 0xff, 0x93, 0x3, 0x5, 0x8b, 0x42, 0x52, 0x46, 0x2f, 0x86, 0xc8, 0x23, 0xeb, 0x15, 0xbf, 0x48, 0x1e, 0x6b, 0x79, 0xcc, 0x3a, 0x2, 0x21, 0x85, 0x95, 0xb3, 0x65, 0x8e, 0x8b, 0x37, 0x38, 0x2b, 0xd5, 0x4, 0x8e, 0xae, 0xd5, 0xfd, 0x2, 0xc3, 0x79, 0x44, 0xe7, 0x3b},
+               output224: []byte{0x73, 0x3a, 0xcd, 0xf9, 0xce, 0xd4, 0x7f, 0x2e, 0x43, 0x93, 0x6e, 0xd6, 0xc2, 0xac, 0xf, 0x82, 0x4f, 0x4f, 0x5b, 0x5d, 0x29, 0x42, 0x52, 0x2d, 0x4d, 0xe5, 0xf6, 0xfc},
+               output256: []byte{0x83, 0x12, 0x0, 0x33, 0xb0, 0x14, 0xf, 0xe3, 0xe3, 0xe1, 0xcb, 0xfe, 0xbf, 0xf3, 0x23, 0xab, 0xc0, 0x85, 0x35, 0xc0, 0xaa, 0x1, 0x78, 0x3, 0xf5, 0xd2, 0xf4, 0xec, 0xb3, 0x5f, 0x5d, 0xfb},
+               output384: []byte{0xbc, 0xdd, 0x36, 0xee, 0x35, 0xc2, 0xc7, 0x71, 0x85, 0x2e, 0x27, 0xdb, 0x2c, 0xdd, 0xab, 0xc1, 0x55, 0xab, 0x43, 0xd2, 0x8e, 0x62, 0x89, 0xf0, 0xab, 0xa4, 0xf9, 0x3e, 0x79, 0x3c, 0x99, 0x9f, 0x30, 0x83, 0x6c, 0x74, 0x83, 0xfb, 0xea, 0x5a, 0x73, 0xf4, 0xee, 0xb5, 0xd8, 0xd3, 0x2f, 0xe3},
+               output512: []byte{0xfd, 0x9b, 0xe2, 0x47, 0x63, 0xf6, 0x82, 0x4, 0x32, 0x43, 0x52, 0x5e, 0x5e, 0x7, 0x80, 0x53, 0x4a, 0x82, 0xad, 0x5e, 0x83, 0xb6, 0x5e, 0xb4, 0xac, 0xaf, 0x53, 0x53, 0x31, 0x3a, 0x4c, 0xc7, 0xc5, 0xee, 0xa9, 0xda, 0x14, 0x1d, 0xe5, 0x70, 0x23, 0x2c, 0xb4, 0x12, 0x62, 0x87, 0xe5, 0xc7, 0x76, 0x57, 0xca, 0x8d, 0x6a, 0x16, 0xb5, 0xbe, 0x53, 0xf4, 0x70, 0x34, 0x3e, 0x72, 0x2f, 0xd6}},
+       testcase{
+               msg:       []byte{0x4c, 0xfa, 0x12, 0x78, 0x90, 0x30, 0x26, 0xf6, 0x6f, 0xed, 0xd4, 0x13, 0x74, 0x55, 0x8b, 0xe1, 0xb5, 0x85, 0xd0, 0x3c, 0x5c, 0x55, 0xda, 0xc9, 0x43, 0x61, 0xdf, 0x28, 0x6d, 0x4b, 0xd3, 0x9c, 0x7c, 0xb8, 0x3, 0x7e, 0xd3, 0xb2, 0x67, 0xb0, 0x7c, 0x34, 0x66, 0x26, 0x44, 0x9d, 0xc, 0xc5, 0xb0, 0xdd, 0x2c, 0xf2, 0x21, 0xf7, 0xe4, 0xc3, 0x44, 0x9a, 0x4b, 0xe9, 0x99, 0x85, 0xd2, 0xd5, 0xe6, 0x7b, 0xff, 0x29, 0x23, 0x35, 0x7d, 0xde, 0xab, 0x5a, 0xbc, 0xb4, 0x61, 0x9f, 0x3a, 0x3a, 0x57, 0xb2, 0xcf, 0x92, 0x8a, 0x2, 0x2e, 0xb2, 0x76, 0x76, 0xc6, 0xcf, 0x80, 0x56, 0x89, 0x0, 0x4f, 0xca, 0x4d, 0x41, 0xea, 0x6c, 0x2d, 0xa, 0x47, 0x89, 0xc7, 0x60, 0x5f, 0x7b, 0xb8, 0x38, 0xdd, 0x88, 0x3b, 0x3a, 0xd3, 0xe6, 0x2, 0x7e, 0x77, 0x5b, 0xcf, 0x26, 0x28, 0x81, 0x42, 0x80, 0x99, 0xc7, 0xff, 0xf9, 0x5b, 0x14, 0xc0, 0x95, 0xea, 0x13, 0xe, 0xb, 0x99, 0x38, 0xa5, 0xe2, 0x2f, 0xc5, 0x26, 0x50, 0xf5, 0x91},
+               output224: []byte{0x53, 0x4, 0x38, 0xb7, 0xa8, 0x6b, 0x16, 0x43, 0x4c, 0x82, 0x71, 0x3e, 0xf7, 0x39, 0x2d, 0x25, 0xc5, 0xcf, 0x81, 0x4c, 0x7c, 0x64, 0x8, 0x36, 0x8c, 0x4f, 0x2e, 0xaf},
+               output256: []byte{0x55, 0x84, 0xbf, 0x3e, 0x93, 0xbc, 0x25, 0x94, 0x5c, 0x50, 0x8b, 0x91, 0x88, 0xd0, 0x50, 0x2c, 0x6e, 0x75, 0x5b, 0xbe, 0xba, 0xbf, 0xc8, 0xcb, 0x90, 0x7f, 0xa7, 0xa2, 0x52, 0xef, 0x46, 0x4a},
+               output384: []byte{0xfa, 0x7f, 0x66, 0xd3, 0x7c, 0x1d, 0xc3, 0xe8, 0x1b, 0xf5, 0x5c, 0x44, 0x3a, 0xba, 0xd5, 0xcf, 0x79, 0xa3, 0xd9, 0x83, 0x4f, 0x77, 0xa2, 0x6, 0x29, 0x11, 0x38, 0xae, 0x31, 0x43, 0x8b, 0x98, 0x67, 0x37, 0xdc, 0x45, 0x99, 0xec, 0x5d, 0x10, 0xf7, 0xf0, 0x5, 0xd1, 0x83, 0x3b, 0x7d, 0x2e},
+               output512: []byte{0x14, 0xea, 0x33, 0xbb, 0x33, 0xfd, 0xf0, 0x42, 0x6e, 0xd, 0xfb, 0x12, 0xde, 0x1c, 0x61, 0x3b, 0xa9, 0x71, 0x41, 0x45, 0x4c, 0x89, 0x71, 0xbc, 0xce, 0x25, 0xc6, 0xd8, 0x7a, 0x6c, 0x24, 0x3, 0xcc, 0xfa, 0xd1, 0xe8, 0xa6, 0xc1, 0x57, 0x54, 0xc3, 0xcc, 0x5a, 0xc1, 0x71, 0x8b, 0x7f, 0x7f, 0x1e, 0xc0, 0x3, 0xc1, 0xb9, 0x8d, 0x70, 0x96, 0x8c, 0x5d, 0xbb, 0x95, 0x54, 0xb, 0x4a, 0x17}},
+       testcase{
+               msg:       []byte{0xd3, 0xe6, 0x5c, 0xb9, 0x2c, 0xfa, 0x79, 0x66, 0x2f, 0x6a, 0xf4, 0x93, 0xd6, 0x96, 0xa0, 0x7c, 0xcf, 0x32, 0xaa, 0xad, 0xcc, 0xef, 0xf0, 0x6e, 0x73, 0xe8, 0xd9, 0xf6, 0xf9, 0x9, 0x20, 0x9e, 0x66, 0x71, 0x5d, 0x6e, 0x97, 0x87, 0x88, 0xc4, 0x9e, 0xfb, 0x90, 0x87, 0xb1, 0x70, 0xec, 0xf3, 0xaa, 0x86, 0xd2, 0xd4, 0xd1, 0xa0, 0x65, 0xae, 0xe, 0xfc, 0x89, 0x24, 0xf3, 0x65, 0xd6, 0x76, 0xb3, 0xcb, 0x9e, 0x2b, 0xec, 0x91, 0x8f, 0xd9, 0x6d, 0xb, 0x43, 0xde, 0xe8, 0x37, 0x27, 0xc9, 0xa9, 0x3b, 0xf5, 0x6c, 0xa2, 0xb2, 0xe5, 0x9a, 0xdb, 0xa8, 0x56, 0x96, 0x54, 0x6a, 0x81, 0x50, 0x67, 0xfc, 0x7a, 0x78, 0x3, 0x96, 0x29, 0xd4, 0x94, 0x8d, 0x15, 0x7e, 0x7b, 0xd, 0x82, 0x6d, 0x1b, 0xf8, 0xe8, 0x12, 0x37, 0xba, 0xb7, 0x32, 0x13, 0x12, 0xfd, 0xaa, 0x4d, 0x52, 0x17, 0x44, 0xf9, 0x88, 0xdb, 0x6f, 0xdf, 0x4, 0x54, 0x9d, 0xf, 0xdc, 0xa3, 0x93, 0xd6, 0x39, 0xc7, 0x29, 0xaf, 0x71, 0x6e, 0x9c, 0x8b, 0xba, 0x48},
+               output224: []byte{0x84, 0x94, 0x4e, 0xb0, 0x18, 0xf8, 0xa1, 0x24, 0xe3, 0xc9, 0x69, 0xc0, 0x37, 0x46, 0x4e, 0xe3, 0x2b, 0xac, 0xf8, 0xe5, 0x89, 0x1, 0xd2, 0xe2, 0x22, 0x91, 0xdf, 0x9a},
+               output256: []byte{0xc2, 0x34, 0xb2, 0x52, 0xc2, 0x1e, 0xdb, 0x84, 0x26, 0x34, 0xcc, 0x12, 0x4d, 0xa5, 0xbe, 0xe8, 0xa4, 0x74, 0x9c, 0xff, 0xba, 0x13, 0x47, 0x23, 0xf7, 0x96, 0x3b, 0x3a, 0x97, 0x29, 0xc0, 0xb4},
+               output384: []byte{0x8f, 0xe, 0x47, 0xed, 0x68, 0x6, 0x61, 0xf1, 0xac, 0xe9, 0xee, 0xee, 0x85, 0x5d, 0x93, 0x5f, 0xdf, 0xc6, 0x6b, 0x97, 0xc2, 0xe9, 0xa6, 0xfc, 0x73, 0x41, 0xf1, 0x4d, 0x93, 0x27, 0xc8, 0xe7, 0x2b, 0xca, 0x3f, 0xa6, 0x7e, 0x59, 0x80, 0x4c, 0xea, 0x41, 0xf0, 0x9e, 0x1c, 0x4f, 0x87, 0x15},
+               output512: []byte{0x3b, 0x4b, 0x39, 0x55, 0x14, 0xe0, 0xca, 0xb0, 0x4f, 0xc9, 0xf9, 0xd6, 0xc3, 0x58, 0x0, 0x6c, 0xe0, 0x6c, 0x93, 0x83, 0x1e, 0x89, 0x48, 0xfb, 0x9b, 0xd2, 0xa8, 0x63, 0xf3, 0xfa, 0x6, 0x4e, 0x78, 0xeb, 0x57, 0xc7, 0x6d, 0xd2, 0xd0, 0x58, 0xd0, 0x9a, 0xb3, 0xd1, 0x5, 0xc2, 0x8c, 0x2d, 0xac, 0xae, 0xbd, 0x4a, 0x47, 0x3f, 0x1f, 0xa0, 0x23, 0x5, 0x3c, 0xc1, 0x53, 0x66, 0x8, 0x2f}},
+       testcase{
+               msg:       []byte{0x84, 0x2c, 0xc5, 0x83, 0x50, 0x45, 0x39, 0x62, 0x2d, 0x7f, 0x71, 0xe7, 0xe3, 0x18, 0x63, 0xa2, 0xb8, 0x85, 0xc5, 0x6a, 0xb, 0xa6, 0x2d, 0xb4, 0xc2, 0xa3, 0xf2, 0xfd, 0x12, 0xe7, 0x96, 0x60, 0xdc, 0x72, 0x5, 0xca, 0x29, 0xa0, 0xdc, 0xa, 0x87, 0xdb, 0x4d, 0xc6, 0x2e, 0xe4, 0x7a, 0x41, 0xdb, 0x36, 0xb9, 0xdd, 0xb3, 0x29, 0x3b, 0x9a, 0xc4, 0xba, 0xae, 0x7d, 0xf5, 0xc6, 0xe7, 0x20, 0x1e, 0x17, 0xf7, 0x17, 0xab, 0x56, 0xe1, 0x2c, 0xad, 0x47, 0x6b, 0xe4, 0x96, 0x8, 0xad, 0x2d, 0x50, 0x30, 0x9e, 0x7d, 0x48, 0xd2, 0xd8, 0xde, 0x4f, 0xa5, 0x8a, 0xc3, 0xcf, 0xea, 0xfe, 0xee, 0x48, 0xc0, 0xa9, 0xee, 0xc8, 0x84, 0x98, 0xe3, 0xef, 0xc5, 0x1f, 0x54, 0xd3, 0x0, 0xd8, 0x28, 0xdd, 0xdc, 0xcb, 0x9d, 0xb, 0x6, 0xdd, 0x2, 0x1a, 0x29, 0xcf, 0x5c, 0xb5, 0xb2, 0x50, 0x69, 0x15, 0xbe, 0xb8, 0xa1, 0x19, 0x98, 0xb8, 0xb8, 0x86, 0xe0, 0xf9, 0xb7, 0xa8, 0xe, 0x97, 0xd9, 0x1a, 0x7d, 0x1, 0x27, 0xf, 0x9a, 0x77, 0x17},
+               output224: []byte{0x13, 0x11, 0xda, 0x75, 0x7c, 0x40, 0x5f, 0x2a, 0xe, 0xab, 0x11, 0xb, 0xc, 0x51, 0x5f, 0x5, 0xfc, 0xd5, 0x9f, 0x54, 0x95, 0xa9, 0x70, 0x42, 0x52, 0xda, 0x5a, 0xb8},
+               output256: []byte{0x64, 0x5f, 0x25, 0x45, 0x67, 0x52, 0x9, 0x1f, 0xff, 0xca, 0xad, 0xe8, 0x6, 0xc3, 0x4c, 0x79, 0xdf, 0xfe, 0x72, 0x14, 0xc, 0x7c, 0x75, 0xd6, 0xa6, 0xec, 0xfe, 0xed, 0xf6, 0xdb, 0x40, 0x1c},
+               output384: []byte{0xf1, 0x5, 0x81, 0xe, 0x72, 0x4c, 0x2c, 0x55, 0x16, 0x2c, 0xf7, 0x17, 0x21, 0xe3, 0xf5, 0x98, 0x71, 0xf0, 0x60, 0x10, 0xbc, 0x7f, 0x5, 0x2a, 0xb2, 0x82, 0xbf, 0xb6, 0xd4, 0xa3, 0xbf, 0x18, 0x4b, 0x89, 0x2b, 0xaf, 0x8f, 0xad, 0xd0, 0x20, 0x70, 0xf6, 0x4b, 0x9e, 0x3, 0x6d, 0xc5, 0xf7},
+               output512: []byte{0x2d, 0x7d, 0x28, 0xc4, 0x31, 0x1e, 0x4, 0x24, 0xd7, 0x1e, 0x7f, 0x9d, 0x26, 0x7a, 0x2e, 0x4, 0x8a, 0xa1, 0x75, 0x45, 0x5f, 0xcb, 0x72, 0x4c, 0xf0, 0xb1, 0x3d, 0xeb, 0xf4, 0x48, 0xb5, 0x9b, 0xf, 0x28, 0x26, 0x5b, 0xf, 0x1, 0xf, 0x4e, 0x4f, 0x40, 0x65, 0x0, 0x49, 0x4, 0xa7, 0xc2, 0x68, 0x7a, 0x5a, 0x1b, 0x30, 0xab, 0x59, 0x3b, 0xc4, 0x4f, 0x69, 0x8d, 0xff, 0x5d, 0xde, 0x33}},
+       testcase{
+               msg:       []byte{0x6c, 0x4b, 0xa, 0x7, 0x19, 0x57, 0x3e, 0x57, 0x24, 0x86, 0x61, 0xe9, 0x8f, 0xeb, 0xe3, 0x26, 0x57, 0x1f, 0x9a, 0x1c, 0xa8, 0x13, 0xd3, 0x63, 0x85, 0x31, 0xae, 0x28, 0xb4, 0x86, 0xf, 0x23, 0xc3, 0xa3, 0xa8, 0xac, 0x1c, 0x25, 0x0, 0x34, 0xa6, 0x60, 0xe2, 0xd7, 0x1e, 0x16, 0xd3, 0xac, 0xc4, 0xbf, 0x9c, 0xe2, 0x15, 0xc6, 0xf1, 0x5b, 0x1c, 0xf, 0xc7, 0xe7, 0x7d, 0x3d, 0x27, 0x15, 0x7e, 0x66, 0xda, 0x9c, 0xee, 0xc9, 0x25, 0x8f, 0x8f, 0x2b, 0xf9, 0xe0, 0x2b, 0x4a, 0xc9, 0x37, 0x93, 0xdd, 0x6e, 0x29, 0xe3, 0x7, 0xed, 0xe3, 0x69, 0x5a, 0xd, 0xf6, 0x3c, 0xbd, 0xc0, 0xfc, 0x66, 0xfb, 0x77, 0x8, 0x13, 0xeb, 0x14, 0x9c, 0xa2, 0xa9, 0x16, 0x91, 0x1b, 0xee, 0x49, 0x2, 0xc4, 0x7c, 0x78, 0x2, 0xe6, 0x9e, 0x40, 0x5f, 0xe3, 0xc0, 0x4c, 0xeb, 0x55, 0x22, 0x79, 0x2a, 0x55, 0x3, 0xfa, 0x82, 0x9f, 0x70, 0x72, 0x72, 0x22, 0x66, 0x21, 0xf7, 0xc4, 0x88, 0xa7, 0x69, 0x8c, 0xd, 0x69, 0xaa, 0x56, 0x1b, 0xe9, 0xf3, 0x78},
+               output224: []byte{0xb5, 0xfd, 0xae, 0xad, 0x7e, 0x68, 0x33, 0x3c, 0xed, 0xb5, 0xd4, 0xad, 0x63, 0x6a, 0xe7, 0x5, 0x9e, 0xb3, 0x13, 0x5, 0xe2, 0xc8, 0x31, 0x78, 0x7f, 0xd5, 0x12, 0x65},
+               output256: []byte{0x2d, 0x7c, 0xac, 0x69, 0x7e, 0x74, 0x10, 0xc1, 0xf7, 0x73, 0x5d, 0xd6, 0x91, 0x62, 0x4a, 0x7d, 0x4, 0xfa, 0x51, 0x81, 0x58, 0x58, 0xe8, 0xba, 0x98, 0xb1, 0x9b, 0xd, 0xed, 0x6, 0x38, 0xb5},
+               output384: []byte{0xcb, 0xb0, 0xfc, 0xe4, 0xaf, 0x36, 0xd1, 0x4b, 0x63, 0xbc, 0x72, 0xd3, 0x7f, 0xb4, 0x2, 0x83, 0x27, 0x84, 0x3f, 0xb2, 0x2e, 0xc0, 0x33, 0xbf, 0xc0, 0x68, 0xe7, 0xb0, 0x81, 0x28, 0x7e, 0x31, 0xe3, 0x45, 0x1d, 0x8a, 0x1d, 0x97, 0x69, 0x2b, 0x37, 0x9f, 0xf9, 0xe6, 0xac, 0xd4, 0x2, 0x40},
+               output512: []byte{0xcb, 0x66, 0x5e, 0xc6, 0x9a, 0xbd, 0x75, 0x74, 0x3c, 0x87, 0x13, 0x3, 0x4e, 0x9e, 0x41, 0x73, 0x6f, 0x8c, 0x1c, 0xe2, 0xc7, 0x7a, 0x85, 0x18, 0xe5, 0x3, 0x88, 0xc4, 0x11, 0xe6, 0x28, 0x4d, 0x9a, 0xad, 0xcd, 0x4d, 0x3b, 0xd5, 0xa9, 0xeb, 0x74, 0x67, 0x23, 0x25, 0xe4, 0x1e, 0x8a, 0x67, 0xac, 0xf3, 0x80, 0xd1, 0xe8, 0xa6, 0x16, 0x84, 0xf0, 0xe5, 0x1, 0xf5, 0x66, 0x3a, 0x3, 0x1d}},
+       testcase{
+               msg:       []byte{0x51, 0xb7, 0xdb, 0xb7, 0xce, 0x2f, 0xfe, 0xb4, 0x27, 0xa9, 0x1c, 0xcf, 0xe5, 0x21, 0x8f, 0xd4, 0xf, 0x9e, 0xb, 0x7e, 0x24, 0x75, 0x6d, 0x4c, 0x47, 0xcd, 0x55, 0x60, 0x60, 0x8, 0xbd, 0xc2, 0x7d, 0x16, 0x40, 0x9, 0x33, 0x90, 0x6f, 0xd9, 0xf3, 0xe, 0xff, 0xdd, 0x48, 0x80, 0x2, 0x2d, 0x8, 0x11, 0x55, 0x34, 0x2a, 0xf3, 0xfb, 0x6c, 0xd5, 0x36, 0x72, 0xab, 0x7f, 0xb5, 0xb3, 0xa3, 0xbc, 0xbe, 0x47, 0xbe, 0x1f, 0xd3, 0xa2, 0x27, 0x8c, 0xae, 0x8a, 0x5f, 0xd6, 0x1c, 0x14, 0x33, 0xf7, 0xd3, 0x50, 0x67, 0x5d, 0xd2, 0x18, 0x3, 0x74, 0x6c, 0xad, 0xca, 0x57, 0x41, 0x30, 0xf0, 0x12, 0x0, 0x2, 0x4c, 0x63, 0x40, 0xab, 0xc, 0xc2, 0xcf, 0x74, 0xf2, 0x23, 0x46, 0x69, 0xf3, 0x4e, 0x90, 0x9, 0xef, 0x2e, 0xb9, 0x48, 0x23, 0xd6, 0x2b, 0x31, 0x40, 0x7f, 0x4b, 0xa4, 0x6f, 0x1a, 0x1e, 0xec, 0x41, 0x64, 0x1e, 0x84, 0xd7, 0x77, 0x27, 0xb5, 0x9e, 0x74, 0x6b, 0x8a, 0x67, 0x1b, 0xef, 0x93, 0x6f, 0x5, 0xbe, 0x82, 0x7, 0x59, 0xfa},
+               output224: []byte{0x29, 0x19, 0xfd, 0x6c, 0x37, 0x6a, 0xec, 0x9f, 0x50, 0x28, 0x93, 0xa9, 0x97, 0xb, 0x9a, 0xc6, 0x59, 0x18, 0x55, 0x22, 0x7c, 0xe, 0x13, 0x7b, 0xe0, 0x17, 0x5, 0xac},
+               output256: []byte{0xf6, 0x64, 0xf6, 0x26, 0xbc, 0x6b, 0x7a, 0x8c, 0xf0, 0x3b, 0xe4, 0x29, 0x15, 0x5e, 0xe1, 0xf5, 0xcd, 0x6e, 0xcf, 0x14, 0x81, 0x6d, 0xe4, 0x9a, 0x5e, 0x22, 0x99, 0x3, 0xf8, 0x9a, 0x4d, 0xc6},
+               output384: []byte{0x44, 0xe4, 0xf7, 0x7c, 0xd, 0x7b, 0xca, 0x6a, 0xd5, 0x7d, 0x33, 0x4f, 0x97, 0x4b, 0xda, 0x8d, 0xe2, 0xe0, 0x8e, 0x10, 0x4f, 0x14, 0xa8, 0x71, 0x32, 0x80, 0xce, 0x73, 0x89, 0x7a, 0x94, 0x5d, 0xc2, 0x3a, 0xd0, 0x58, 0x53, 0x3b, 0x85, 0x75, 0xd, 0x9d, 0xd9, 0xd2, 0xd7, 0xb5, 0xd1, 0xaf},
+               output512: []byte{0x45, 0x15, 0xa1, 0x4, 0xfc, 0x68, 0x9, 0x4d, 0x24, 0x4b, 0x23, 0x4d, 0x9d, 0xc0, 0x6a, 0x2, 0x43, 0xb7, 0x1d, 0x41, 0x9d, 0x29, 0xa9, 0x5c, 0x46, 0xe3, 0xcb, 0xa6, 0xf5, 0x1e, 0x12, 0x1a, 0xbe, 0x4, 0x9b, 0x34, 0x53, 0x5d, 0xb3, 0xcc, 0xbf, 0x2a, 0xd6, 0x8d, 0x83, 0xfc, 0x36, 0x33, 0x1f, 0x61, 0x5b, 0x3e, 0x33, 0xde, 0xb3, 0x9a, 0x33, 0x81, 0xdf, 0xbc, 0xb7, 0x98, 0xfe, 0x4d}},
+       testcase{
+               msg:       []byte{0x83, 0x59, 0x9d, 0x93, 0xf5, 0x56, 0x1e, 0x82, 0x1b, 0xd0, 0x1a, 0x47, 0x23, 0x86, 0xbc, 0x2f, 0xf4, 0xef, 0xbd, 0x4a, 0xed, 0x60, 0xd5, 0x82, 0x1e, 0x84, 0xaa, 0xe7, 0x4d, 0x80, 0x71, 0x2, 0x98, 0x10, 0xf5, 0xe2, 0x86, 0xf8, 0xf1, 0x76, 0x51, 0xcd, 0x27, 0xda, 0x7, 0xb1, 0xeb, 0x43, 0x82, 0xf7, 0x54, 0xcd, 0x1c, 0x95, 0x26, 0x87, 0x83, 0xad, 0x9, 0x22, 0xf, 0x55, 0x2, 0x84, 0x3, 0x70, 0xd4, 0x94, 0xbe, 0xb1, 0x71, 0x24, 0x22, 0xf, 0x6a, 0xfc, 0xe9, 0x1e, 0xc8, 0xa0, 0xf5, 0x52, 0x31, 0xf9, 0x65, 0x24, 0x33, 0xe5, 0xce, 0x34, 0x89, 0xb7, 0x27, 0x71, 0x6c, 0xf4, 0xae, 0xba, 0x7d, 0xcd, 0xa2, 0xc, 0xd2, 0x9a, 0xa9, 0xa8, 0x59, 0x20, 0x12, 0x53, 0xf9, 0x48, 0xdd, 0x94, 0x39, 0x5a, 0xba, 0x9e, 0x38, 0x52, 0xbd, 0x1d, 0x60, 0xdd, 0xa7, 0xae, 0x5d, 0xc0, 0x45, 0xb2, 0x83, 0xda, 0x0, 0x6e, 0x1c, 0xba, 0xd8, 0x3c, 0xc1, 0x32, 0x92, 0xa3, 0x15, 0xdb, 0x55, 0x53, 0x30, 0x5c, 0x62, 0x8d, 0xd0, 0x91, 0x14, 0x65, 0x97},
+               output224: []byte{0x89, 0x10, 0xe7, 0xab, 0xc3, 0xda, 0xa5, 0x6, 0x97, 0x4e, 0xc1, 0x3e, 0x35, 0xc4, 0x31, 0x33, 0xeb, 0xfa, 0x91, 0xde, 0xec, 0x99, 0xbf, 0xad, 0x49, 0x54, 0x44, 0x7e},
+               output256: []byte{0x6, 0x42, 0x5e, 0x83, 0xe4, 0xaf, 0x81, 0x7d, 0x73, 0x5e, 0x99, 0x62, 0xc0, 0xcd, 0xdc, 0xe2, 0xcd, 0x40, 0xa0, 0x87, 0xa6, 0xb0, 0xaf, 0x35, 0x99, 0x71, 0x9e, 0x41, 0x5a, 0xb9, 0xa7, 0x2a},
+               output384: []byte{0x69, 0x13, 0x18, 0x4f, 0xae, 0x1e, 0xf9, 0xfa, 0x2d, 0x57, 0xb1, 0xb7, 0xbd, 0x58, 0x6d, 0x51, 0xde, 0x9a, 0x5f, 0x38, 0x70, 0x37, 0x26, 0x6e, 0x7b, 0x4a, 0x83, 0xf4, 0x36, 0x64, 0x98, 0xff, 0x86, 0xc8, 0x99, 0x34, 0xc0, 0x53, 0x32, 0xa7, 0xe6, 0x41, 0x14, 0x9e, 0xf6, 0x27, 0xfa, 0x34},
+               output512: []byte{0xce, 0xe3, 0xe6, 0xa, 0x49, 0xf7, 0xca, 0xed, 0x93, 0x87, 0xf3, 0xea, 0x69, 0x95, 0x24, 0xc4, 0xcc, 0xaf, 0xd3, 0x7c, 0x1a, 0x7e, 0x60, 0xd2, 0xf0, 0xab, 0x3, 0x77, 0x20, 0x64, 0x9f, 0x10, 0x8c, 0xce, 0x87, 0x69, 0xf7, 0xb, 0xc, 0x5d, 0x4, 0x93, 0x59, 0xee, 0xb8, 0x21, 0x2, 0x2f, 0x17, 0xc4, 0xb5, 0xf6, 0x46, 0xb7, 0x50, 0xe3, 0x7, 0x5, 0x58, 0xec, 0x12, 0x70, 0x57, 0xf1}},
+       testcase{
+               msg:       []byte{0x2b, 0xe9, 0xbf, 0x52, 0x6c, 0x9d, 0x5a, 0x75, 0xd5, 0x65, 0xdd, 0x11, 0xef, 0x63, 0xb9, 0x79, 0xd0, 0x68, 0x65, 0x9c, 0x7f, 0x2, 0x6c, 0x8, 0xbe, 0xa4, 0xaf, 0x16, 0x1d, 0x85, 0xa4, 0x62, 0xd8, 0xe, 0x45, 0x4, 0xe, 0x91, 0xf4, 0x16, 0x5c, 0x7, 0x4c, 0x43, 0xac, 0x66, 0x13, 0x80, 0x31, 0x1a, 0x8c, 0xbe, 0xd5, 0x9c, 0xc8, 0xe4, 0xc4, 0x51, 0x8e, 0x80, 0xcd, 0x2c, 0x78, 0xab, 0x1c, 0xab, 0xf6, 0x6b, 0xff, 0x83, 0xea, 0xb3, 0xa8, 0x1, 0x48, 0x55, 0x3, 0x7, 0x31, 0x9, 0x50, 0xd0, 0x34, 0xa6, 0x28, 0x6c, 0x93, 0xa1, 0xec, 0xe8, 0x92, 0x9e, 0x63, 0x85, 0xc5, 0xe3, 0xbb, 0x6e, 0xa8, 0xa7, 0xc0, 0xfb, 0x6d, 0x63, 0x32, 0xe3, 0x20, 0xe7, 0x1c, 0xc4, 0xeb, 0x46, 0x2a, 0x2a, 0x62, 0xe2, 0xbf, 0xe0, 0x8f, 0xc, 0xca, 0xd9, 0x3e, 0x61, 0xbe, 0xdb, 0x5d, 0xd0, 0xb7, 0x86, 0xa7, 0x28, 0xab, 0x66, 0x6f, 0x7, 0xe0, 0x57, 0x6d, 0x18, 0x9c, 0x92, 0xbf, 0x9f, 0xb2, 0xd, 0xca, 0x49, 0xac, 0x2d, 0x39, 0x56, 0xd4, 0x73, 0x85, 0xe2},
+               output224: []byte{0xf8, 0xb4, 0xa4, 0xa6, 0xfb, 0xb8, 0xc8, 0x43, 0x27, 0x12, 0xb5, 0xb8, 0x15, 0xb3, 0x66, 0x85, 0xc8, 0x66, 0x56, 0xc3, 0xf6, 0x7d, 0x5, 0xbd, 0xbb, 0x44, 0xb4, 0x9a},
+               output256: []byte{0xe8, 0xc3, 0x29, 0x14, 0x9b, 0x7, 0x5c, 0x45, 0x9e, 0x11, 0xc8, 0xac, 0x1e, 0x7e, 0x6a, 0xcf, 0xa5, 0x1c, 0xa9, 0x81, 0xc8, 0x9e, 0xc0, 0x76, 0x8e, 0xd7, 0x9d, 0x19, 0xf4, 0xe4, 0x84, 0xfb},
+               output384: []byte{0xf0, 0x4f, 0xf5, 0xaa, 0xa6, 0x8f, 0x25, 0x58, 0x58, 0x6d, 0x27, 0x48, 0x58, 0x7d, 0xee, 0x3c, 0xf2, 0x8b, 0xac, 0xab, 0x5b, 0xe5, 0xf8, 0x87, 0xd2, 0x4a, 0x6, 0x83, 0x11, 0xba, 0x2d, 0x9e, 0x9b, 0xc0, 0x20, 0x6c, 0x27, 0x6, 0xb9, 0xc1, 0x9, 0xe7, 0x16, 0x2e, 0x3e, 0xcb, 0x63, 0x46},
+               output512: []byte{0xe6, 0xed, 0x6f, 0x6, 0x9, 0x6, 0xd1, 0xa7, 0x72, 0xf4, 0x7e, 0x83, 0x90, 0x75, 0x7, 0xf8, 0x8a, 0x15, 0x1d, 0xe4, 0x1, 0xed, 0x79, 0xac, 0xb5, 0x6b, 0xe5, 0x7c, 0x25, 0x96, 0x79, 0x2d, 0xc0, 0xbc, 0x5a, 0x9d, 0xc1, 0x4, 0x5e, 0x37, 0xc6, 0xa3, 0x1d, 0xa1, 0xc3, 0x62, 0x0, 0x21, 0x4e, 0x4f, 0x56, 0x98, 0xaa, 0x27, 0x54, 0xee, 0xb2, 0xca, 0xec, 0xfc, 0x3, 0xbe, 0xc3, 0x9d}},
+       testcase{
+               msg:       []byte{0xca, 0x76, 0xd3, 0xa1, 0x25, 0x95, 0xa8, 0x17, 0x68, 0x26, 0x17, 0x0, 0x68, 0x48, 0x67, 0x55, 0x47, 0xd3, 0xe8, 0xf5, 0xc, 0x22, 0x10, 0xf9, 0xaf, 0x90, 0x6c, 0xe, 0x7c, 0xe5, 0xb, 0x44, 0x60, 0x18, 0x6f, 0xe7, 0x4, 0x57, 0xa9, 0xe8, 0x79, 0xe7, 0x9f, 0xd4, 0xd1, 0xa6, 0x88, 0xc7, 0xa, 0x34, 0x73, 0x61, 0xc8, 0x47, 0xba, 0xd, 0xd6, 0xaa, 0x52, 0x93, 0x6e, 0xaf, 0x8e, 0x58, 0xa1, 0xbe, 0x2f, 0x5c, 0x1c, 0x70, 0x4e, 0x20, 0x14, 0x6d, 0x36, 0x6a, 0xeb, 0x38, 0x53, 0xbe, 0xd9, 0xde, 0x9b, 0xef, 0xe9, 0x56, 0x9a, 0xc8, 0xaa, 0xea, 0x37, 0xa9, 0xfb, 0x71, 0x39, 0xa1, 0xa1, 0xa7, 0xd5, 0xc7, 0x48, 0x60, 0x5a, 0x8d, 0xef, 0xb2, 0x97, 0x86, 0x9e, 0xbe, 0xdd, 0x71, 0xd6, 0x15, 0xa5, 0xda, 0x23, 0x49, 0x6d, 0x11, 0xe1, 0x1a, 0xbb, 0xb1, 0x26, 0xb2, 0x6, 0xfa, 0xa, 0x77, 0x97, 0xee, 0x7d, 0xe1, 0x17, 0x98, 0x60, 0x12, 0xd0, 0x36, 0x2d, 0xce, 0xf7, 0x75, 0xc2, 0xfe, 0x14, 0x5a, 0xda, 0x6b, 0xda, 0x1c, 0xcb, 0x32, 0x6b, 0xf6, 0x44},
+               output224: []byte{0x92, 0x6f, 0xe0, 0x4, 0x4b, 0x12, 0x42, 0x2d, 0x3e, 0x4b, 0xfa, 0x52, 0xc5, 0x92, 0x52, 0xac, 0xc9, 0x1d, 0xbf, 0x9, 0xc4, 0x88, 0xae, 0x9d, 0x31, 0xc7, 0xeb, 0x63},
+               output256: []byte{0xc8, 0x67, 0x68, 0xf6, 0xc3, 0x49, 0xeb, 0x32, 0x3b, 0xd8, 0x2d, 0xb1, 0x96, 0x76, 0xe1, 0xb, 0xd8, 0xae, 0x9f, 0x70, 0x57, 0x76, 0x35, 0x56, 0xbb, 0xb6, 0xd0, 0xb6, 0x71, 0xe6, 0xf, 0x2a},
+               output384: []byte{0xd4, 0xb8, 0xcf, 0xb2, 0xfe, 0x5b, 0x63, 0xbb, 0x5b, 0xb6, 0x78, 0xb9, 0x8b, 0x46, 0x5a, 0x2d, 0xfd, 0x23, 0xdf, 0xf4, 0x98, 0xe7, 0x78, 0xee, 0x5, 0x35, 0xa5, 0xc0, 0x77, 0x70, 0x5a, 0xa2, 0xca, 0x2f, 0x3, 0x98, 0x32, 0xba, 0xea, 0xf, 0x73, 0x56, 0x9, 0xb3, 0xe4, 0xe1, 0x8c, 0xf7},
+               output512: []byte{0x9e, 0xd4, 0xee, 0xe8, 0x7f, 0x56, 0xae, 0x27, 0x41, 0xe8, 0xe4, 0xd6, 0x56, 0x23, 0xe4, 0xd1, 0xfa, 0x3a, 0xa1, 0x11, 0xf6, 0x4a, 0x85, 0xf6, 0x6e, 0x99, 0x9, 0x3b, 0xae, 0xd9, 0x90, 0xfe, 0x1d, 0x78, 0x8d, 0x6a, 0x4b, 0xe1, 0xa7, 0x2a, 0x66, 0x15, 0x28, 0x1e, 0xb4, 0x5e, 0x1b, 0x6f, 0xb6, 0xa, 0xfe, 0xfd, 0xd9, 0x39, 0x87, 0xf7, 0x94, 0x8, 0x4b, 0xda, 0x96, 0x2f, 0xac, 0x7f}},
+       testcase{
+               msg:       []byte{0xf7, 0x6b, 0x85, 0xdc, 0x67, 0x42, 0x10, 0x25, 0xd6, 0x4e, 0x93, 0x9, 0x6d, 0x1d, 0x71, 0x2b, 0x7b, 0xaf, 0x7f, 0xb0, 0x1, 0x71, 0x6f, 0x2, 0xd3, 0x3b, 0x21, 0x60, 0xc2, 0xc8, 0x82, 0xc3, 0x10, 0xef, 0x13, 0xa5, 0x76, 0xb1, 0xc2, 0xd3, 0xe, 0xf8, 0xf7, 0x8e, 0xf8, 0xd2, 0xf4, 0x65, 0x0, 0x71, 0x9, 0xaa, 0xd9, 0x3f, 0x74, 0xcb, 0x9e, 0x7d, 0x7b, 0xef, 0x7c, 0x95, 0x90, 0xe8, 0xaf, 0x3b, 0x26, 0x7c, 0x89, 0xc1, 0x5d, 0xb2, 0x38, 0x13, 0x8c, 0x45, 0x83, 0x3c, 0x98, 0xcc, 0x4a, 0x47, 0x1a, 0x78, 0x2, 0x72, 0x3e, 0xf4, 0xc7, 0x44, 0xa8, 0x53, 0xcf, 0x80, 0xa0, 0xc2, 0x56, 0x8d, 0xd4, 0xed, 0x58, 0xa2, 0xc9, 0x64, 0x48, 0x6, 0xf4, 0x21, 0x4, 0xce, 0xe5, 0x36, 0x28, 0xe5, 0xbd, 0xf7, 0xb6, 0x3b, 0xb, 0x33, 0x8e, 0x93, 0x1e, 0x31, 0xb8, 0x7c, 0x24, 0xb1, 0x46, 0xc6, 0xd0, 0x40, 0x60, 0x55, 0x67, 0xce, 0xef, 0x59, 0x60, 0xdf, 0x9e, 0x2, 0x2c, 0xb4, 0x69, 0xd4, 0xc7, 0x87, 0xf4, 0xcb, 0xa3, 0xc5, 0x44, 0xa1, 0xac, 0x91, 0xf9, 0x5f},
+               output224: []byte{0xa4, 0xe4, 0xb4, 0xa5, 0x73, 0xf7, 0xb8, 0x86, 0x5d, 0x77, 0xd7, 0xe5, 0x7f, 0x7d, 0x84, 0xa, 0x55, 0x26, 0x1a, 0x96, 0xe5, 0xfe, 0xdd, 0x76, 0x3d, 0x8, 0x11, 0xf4},
+               output256: []byte{0xd9, 0x7f, 0x46, 0xf3, 0xb7, 0xed, 0xbf, 0xb1, 0x6e, 0x52, 0xbf, 0xec, 0x7d, 0xba, 0x8, 0x15, 0xb9, 0x4d, 0x46, 0xe4, 0x25, 0x1e, 0x48, 0xa8, 0x53, 0xea, 0xbd, 0xf8, 0x76, 0x12, 0x77, 0x14},
+               output384: []byte{0x25, 0xb7, 0x23, 0x7d, 0xa9, 0xd4, 0xd, 0xe0, 0x47, 0xd4, 0x1a, 0x30, 0xbd, 0x37, 0x15, 0x5c, 0xf, 0x10, 0x8d, 0x72, 0x96, 0xb0, 0x90, 0x79, 0x95, 0x7d, 0x4e, 0xe3, 0x12, 0x24, 0xa4, 0xba, 0x25, 0x6a, 0xf7, 0x56, 0xd1, 0x54, 0x87, 0x89, 0x10, 0xc1, 0x58, 0xe4, 0x91, 0x86, 0x72, 0x8b},
+               output512: []byte{0x23, 0x13, 0x9b, 0xdd, 0x84, 0xe9, 0xf4, 0x3a, 0x6c, 0xc6, 0x15, 0xf0, 0xf0, 0x36, 0x19, 0x93, 0x28, 0xd3, 0x98, 0x7, 0xbe, 0xc9, 0xe7, 0x86, 0xd4, 0x25, 0x1b, 0x83, 0xb3, 0x8, 0x0, 0xf9, 0xdb, 0xe8, 0xed, 0xc0, 0xb9, 0x10, 0xfc, 0xd9, 0xd9, 0xf2, 0x4, 0xc2, 0xdd, 0xd4, 0xd3, 0xb9, 0x2b, 0xc2, 0x6a, 0xc, 0xfa, 0xab, 0xe7, 0x64, 0xbf, 0xb9, 0xa, 0x14, 0x44, 0x73, 0x3c, 0xd0}},
+       testcase{
+               msg:       []byte{0x25, 0xb8, 0xc9, 0xc0, 0x32, 0xea, 0x6b, 0xcd, 0x73, 0x3f, 0xfc, 0x87, 0x18, 0xfb, 0xb2, 0xa5, 0x3, 0xa4, 0xea, 0x8f, 0x71, 0xde, 0xa1, 0x17, 0x61, 0x89, 0xf6, 0x94, 0x30, 0x4f, 0xf, 0xf6, 0x8e, 0x86, 0x2a, 0x81, 0x97, 0xb8, 0x39, 0x95, 0x75, 0x49, 0xef, 0x24, 0x3a, 0x52, 0x79, 0xfc, 0x26, 0x46, 0xbd, 0x4c, 0x0, 0x9b, 0x6d, 0x1e, 0xde, 0xbf, 0x24, 0x73, 0x81, 0x97, 0xab, 0xb4, 0xc9, 0x92, 0xf6, 0xb1, 0xdc, 0x9b, 0xa8, 0x91, 0xf5, 0x70, 0x87, 0x9a, 0xcc, 0xd5, 0xa6, 0xb1, 0x86, 0x91, 0xa9, 0x3c, 0x7d, 0xa, 0x8d, 0x38, 0xf9, 0x5b, 0x63, 0x9c, 0x1d, 0xae, 0xb4, 0x8c, 0x4c, 0x2f, 0x15, 0xcc, 0xf5, 0xb9, 0xd5, 0x8, 0xf8, 0x33, 0x3c, 0x32, 0xde, 0x78, 0x78, 0x1b, 0x41, 0x85, 0xf, 0x26, 0x1b, 0x85, 0x5c, 0x4b, 0xeb, 0xcc, 0x12, 0x5a, 0x38, 0xc, 0x54, 0xd5, 0x1, 0xc5, 0xd3, 0xbd, 0x7, 0xe6, 0xb5, 0x21, 0x2, 0x11, 0x60, 0x88, 0xe5, 0x3d, 0x76, 0x58, 0x3b, 0x1, 0x61, 0xe2, 0xa5, 0x8d, 0x7, 0x78, 0xf0, 0x91, 0x20, 0x6a, 0xab, 0xd5, 0xa1},
+               output224: []byte{0xeb, 0xfd, 0x79, 0x6b, 0x29, 0xf6, 0x5, 0x99, 0x31, 0x73, 0x2f, 0x98, 0x60, 0x21, 0x85, 0xb6, 0x37, 0x7c, 0x4e, 0x6e, 0x40, 0xbd, 0x26, 0xc8, 0x10, 0xd6, 0xda, 0x96},
+               output256: []byte{0x51, 0xd0, 0x8e, 0x0, 0xaa, 0xa2, 0x52, 0x81, 0x2d, 0x87, 0x33, 0x57, 0x10, 0x76, 0x16, 0x5, 0x5b, 0x1b, 0x8c, 0x5f, 0xb2, 0xac, 0x79, 0x17, 0xd0, 0xf9, 0x1, 0xdf, 0xb0, 0x1f, 0xac, 0x47},
+               output384: []byte{0xf4, 0x1b, 0x2d, 0x2, 0xd3, 0x21, 0xf4, 0xba, 0x10, 0x6f, 0x93, 0x1e, 0xe2, 0x7d, 0x3f, 0x74, 0xe8, 0xd3, 0x97, 0xba, 0xce, 0xcb, 0xa, 0x1f, 0xa9, 0xb, 0xf5, 0xc8, 0x37, 0xac, 0xeb, 0x2e, 0xd8, 0xf0, 0xfe, 0xff, 0x7, 0xb7, 0xeb, 0xea, 0x6a, 0x88, 0xd0, 0xcc, 0x54, 0xae, 0x8e, 0x6a},
+               output512: []byte{0xec, 0x69, 0x39, 0x70, 0x0, 0xae, 0xd6, 0x3c, 0xb7, 0xe8, 0x6b, 0x4f, 0xb0, 0xbf, 0xd3, 0xdc, 0xee, 0x8a, 0x6f, 0x6a, 0x1c, 0xfe, 0x1, 0xa3, 0x24, 0xda, 0x13, 0x48, 0x4b, 0x73, 0x59, 0x9f, 0xcd, 0x37, 0xad, 0x39, 0x26, 0x62, 0xd4, 0xc4, 0x1d, 0x90, 0xba, 0xca, 0x66, 0xbe, 0x4d, 0x6e, 0x34, 0x24, 0xef, 0xd3, 0x5d, 0x7f, 0xf4, 0xcb, 0x7, 0xcb, 0xdf, 0xbe, 0xbd, 0xdb, 0x7b, 0x50}},
+       testcase{
+               msg:       []byte{0x21, 0xcf, 0xdc, 0x2a, 0x7c, 0xcb, 0x7f, 0x33, 0x1b, 0x3d, 0x2e, 0xef, 0xff, 0x37, 0xe4, 0x8a, 0xd9, 0xfa, 0x9c, 0x78, 0x8c, 0x3f, 0x3c, 0x20, 0xe, 0x1, 0x73, 0xd9, 0x99, 0x63, 0xe1, 0xcb, 0xca, 0x93, 0x62, 0x3b, 0x26, 0x4e, 0x92, 0x3, 0x94, 0xae, 0x48, 0xbb, 0x4c, 0x3a, 0x5b, 0xb9, 0x6f, 0xfb, 0xc8, 0xf0, 0xe5, 0x3f, 0x30, 0xe2, 0x29, 0x56, 0xad, 0xab, 0xc2, 0x76, 0x5f, 0x57, 0xfb, 0x76, 0x1e, 0x14, 0x7e, 0xcb, 0xf8, 0x56, 0x75, 0x33, 0xdb, 0x6e, 0x50, 0xc8, 0xa1, 0xf8, 0x94, 0x31, 0xa, 0x94, 0xed, 0xf8, 0x6, 0xdd, 0x8c, 0xa6, 0xa0, 0xe1, 0x41, 0xc0, 0xfa, 0x7c, 0x9f, 0xae, 0x6c, 0x6a, 0xe6, 0x5f, 0x18, 0xc9, 0x3a, 0x85, 0x29, 0xe6, 0xe5, 0xb5, 0x53, 0xbf, 0x55, 0xf2, 0x5b, 0xe2, 0xe8, 0xa, 0x98, 0x82, 0xbd, 0x37, 0xf1, 0x45, 0xfe, 0xcb, 0xeb, 0x3d, 0x44, 0x7a, 0x3c, 0x4e, 0x46, 0xc2, 0x15, 0x24, 0xcc, 0x55, 0xcd, 0xd6, 0x2f, 0x52, 0x1a, 0xb9, 0x2a, 0x8b, 0xa7, 0x2b, 0x89, 0x79, 0x96, 0xc4, 0x9b, 0xb2, 0x73, 0x19, 0x8b, 0x7b, 0x1c, 0x9e},
+               output224: []byte{0x3f, 0xb7, 0x39, 0x2a, 0x66, 0x21, 0xb8, 0x52, 0x31, 0x2a, 0x37, 0x4c, 0x14, 0xa6, 0x79, 0xaf, 0xb0, 0xe3, 0xd2, 0xec, 0x6a, 0x2d, 0x14, 0x7b, 0xd5, 0xe8, 0x73, 0xf6},
+               output256: []byte{0xc6, 0xa1, 0x88, 0xa6, 0xbd, 0xac, 0xa4, 0xdd, 0x7b, 0x1b, 0xc3, 0xe4, 0x10, 0x19, 0xaf, 0xe9, 0x34, 0x73, 0x6, 0x3f, 0x93, 0x2c, 0x16, 0x6e, 0x32, 0x42, 0xb7, 0xf5, 0x2a, 0x3c, 0x6f, 0x8e},
+               output384: []byte{0x96, 0x73, 0xa1, 0xa3, 0x53, 0x5b, 0x89, 0x75, 0xca, 0xf, 0x51, 0x2c, 0xdb, 0xf, 0xdc, 0xdf, 0xb0, 0x17, 0x9c, 0xe2, 0x29, 0xe7, 0x56, 0xad, 0x70, 0xea, 0xf1, 0xe5, 0xc3, 0xe1, 0xa4, 0x13, 0x5e, 0x9f, 0xa7, 0x65, 0x3e, 0xdb, 0xdc, 0xa4, 0x97, 0x5a, 0xc1, 0x8b, 0x17, 0xa6, 0x62, 0xeb},
+               output512: []byte{0x2e, 0xa3, 0xea, 0x0, 0xe6, 0xe9, 0x30, 0x5c, 0xed, 0xf, 0xc1, 0x60, 0xe0, 0x4, 0x26, 0x52, 0x21, 0x30, 0x6a, 0x2b, 0xe9, 0x61, 0x34, 0x74, 0x12, 0x68, 0x25, 0xaa, 0x3c, 0x31, 0x70, 0xae, 0x7, 0xe5, 0xea, 0x42, 0xf6, 0xb7, 0x4f, 0xb, 0x2c, 0x1b, 0xd2, 0xa6, 0xcd, 0x4d, 0x26, 0xeb, 0x1e, 0x4, 0xc6, 0x7c, 0x9a, 0x4a, 0xfe, 0xfc, 0x1d, 0xd0, 0xcb, 0x57, 0xc2, 0xa9, 0xf4, 0xc7}},
+       testcase{
+               msg:       []byte{0x4e, 0x45, 0x2b, 0xa4, 0x21, 0x27, 0xdc, 0xc9, 0x56, 0xef, 0x4f, 0x8f, 0x35, 0xdd, 0x68, 0xcb, 0x22, 0x5f, 0xb7, 0x3b, 0x5b, 0xc7, 0xe1, 0xec, 0x5a, 0x89, 0x8b, 0xba, 0x29, 0x31, 0x56, 0x3e, 0x74, 0xfa, 0xff, 0x3b, 0x67, 0x31, 0x4f, 0x24, 0x1e, 0xc4, 0x9f, 0x4a, 0x70, 0x61, 0xe3, 0xbd, 0x2, 0x13, 0xae, 0x82, 0x6b, 0xab, 0x38, 0xf, 0x1f, 0x14, 0xfa, 0xab, 0x8b, 0xe, 0xfd, 0xdd, 0x5f, 0xd1, 0xbb, 0x49, 0x37, 0x38, 0x53, 0xa0, 0x8f, 0x30, 0x55, 0x3d, 0x5a, 0x55, 0xcc, 0xbb, 0xb8, 0x15, 0x3d, 0xe4, 0x70, 0x4f, 0x29, 0xca, 0x2b, 0xde, 0xef, 0x4, 0x19, 0x46, 0x8e, 0x5, 0xdd, 0x51, 0x55, 0x7c, 0xcc, 0x80, 0xc0, 0xa9, 0x61, 0x90, 0xbb, 0xcc, 0x4d, 0x77, 0xec, 0xff, 0x21, 0xc6, 0x6b, 0xdf, 0x48, 0x64, 0x59, 0xd4, 0x27, 0xf9, 0x86, 0x41, 0xf, 0x88, 0x3a, 0x80, 0xa5, 0xbc, 0xc3, 0x2c, 0x20, 0xf0, 0x47, 0x8b, 0xb9, 0xa9, 0x7a, 0x12, 0x6f, 0xc5, 0xf9, 0x54, 0x51, 0xe4, 0xf, 0x29, 0x2a, 0x46, 0x14, 0x93, 0xd, 0x5, 0x4c, 0x85, 0x1a, 0xcd, 0x1, 0x9c, 0xcf},
+               output224: []byte{0x8b, 0x37, 0x50, 0x65, 0x5a, 0xf5, 0xec, 0xa1, 0xc, 0xc4, 0xf2, 0x91, 0x4, 0x35, 0x90, 0xe2, 0xd1, 0x97, 0x59, 0x25, 0x30, 0x47, 0xa4, 0xc1, 0xdb, 0xc8, 0x65, 0x77},
+               output256: []byte{0x2b, 0x31, 0xfb, 0xc5, 0x65, 0x11, 0x1, 0x10, 0x1, 0x1a, 0xb2, 0xc8, 0xf6, 0xcc, 0x3d, 0xa8, 0xfb, 0x55, 0xd4, 0x1b, 0x1a, 0xe5, 0xe0, 0x43, 0x10, 0x28, 0x3f, 0x20, 0x7d, 0x39, 0x68, 0x2d},
+               output384: []byte{0x32, 0x42, 0x9c, 0xb1, 0xb5, 0xda, 0xd6, 0x63, 0xa0, 0x66, 0x3e, 0x49, 0x3, 0x3d, 0xb2, 0x29, 0x9, 0x45, 0x1, 0x9d, 0xf7, 0xe7, 0x92, 0xcd, 0xff, 0x37, 0x23, 0xee, 0xdb, 0x88, 0xcd, 0x6, 0x3, 0xb3, 0xfa, 0xe0, 0x22, 0x8a, 0x18, 0x4f, 0x8e, 0xff, 0xac, 0x45, 0x11, 0x2f, 0x45, 0x3e},
+               output512: []byte{0x6a, 0x7a, 0xdd, 0xb2, 0x8f, 0x4f, 0x2c, 0x23, 0xcf, 0xc, 0x26, 0x45, 0x79, 0xfb, 0xa5, 0xf8, 0x92, 0xe0, 0x10, 0x68, 0x9f, 0x83, 0x7b, 0x84, 0xd0, 0x6, 0xd9, 0x14, 0x2, 0xfb, 0xfe, 0x9b, 0xa4, 0x4b, 0x91, 0x26, 0xf8, 0xb5, 0xde, 0x1e, 0xc6, 0xbb, 0xe1, 0x94, 0xa3, 0xe3, 0x85, 0x42, 0x35, 0x5, 0x6a, 0x9, 0x90, 0x1d, 0x18, 0xe8, 0xd6, 0xf1, 0x72, 0x7d, 0xd4, 0x30, 0x21, 0x2a}},
+       testcase{
+               msg:       []byte{0xfa, 0x85, 0x67, 0x1d, 0xf7, 0xda, 0xdf, 0x99, 0xa6, 0xff, 0xee, 0x97, 0xa3, 0xab, 0x99, 0x91, 0x67, 0x1f, 0x56, 0x29, 0x19, 0x50, 0x49, 0x88, 0x4, 0x97, 0x48, 0x78, 0x67, 0xa6, 0xc4, 0x46, 0xb6, 0x0, 0x87, 0xfa, 0xc9, 0xa0, 0xf2, 0xfc, 0xc8, 0xe3, 0xb2, 0x4e, 0x97, 0xe4, 0x23, 0x45, 0xb9, 0x3b, 0x5f, 0x7d, 0x36, 0x91, 0x82, 0x9d, 0x3f, 0x8c, 0xcd, 0x4b, 0xb3, 0x64, 0x11, 0xb8, 0x5f, 0xc2, 0x32, 0x8e, 0xb0, 0xc5, 0x1c, 0xb3, 0x15, 0x1f, 0x70, 0x86, 0xa, 0xd3, 0x24, 0x6c, 0xe0, 0x62, 0x3a, 0x8d, 0xc8, 0xb3, 0xc4, 0x9f, 0x95, 0x8f, 0x86, 0x90, 0xf8, 0xe3, 0x86, 0xe, 0x71, 0xeb, 0x2b, 0x14, 0x79, 0xa5, 0xce, 0xa0, 0xb3, 0xf8, 0xbe, 0xfd, 0x87, 0xac, 0xaf, 0x53, 0x62, 0x43, 0x5e, 0xae, 0xcc, 0xb5, 0x2f, 0x38, 0x61, 0x7b, 0xc6, 0xc5, 0xc2, 0xc6, 0xe2, 0x69, 0xea, 0xd1, 0xfb, 0xd6, 0x9e, 0x94, 0x1d, 0x4a, 0xd2, 0x1, 0x2d, 0xa2, 0xc5, 0xb2, 0x1b, 0xcf, 0xbf, 0x98, 0xe4, 0xa7, 0x7a, 0xb2, 0xaf, 0x1f, 0x3f, 0xda, 0x32, 0x33, 0xf0, 0x46, 0xd3, 0x8f, 0x1d, 0xc8},
+               output224: []byte{0xd3, 0xa5, 0x0, 0x44, 0x77, 0xbb, 0xb2, 0x1c, 0xf7, 0xd0, 0xfc, 0xa8, 0x4e, 0x51, 0xa7, 0xa5, 0x7e, 0x93, 0xfa, 0xe7, 0x22, 0x25, 0x70, 0xc0, 0x1b, 0x0, 0xe8, 0x9a},
+               output256: []byte{0x13, 0x51, 0xf5, 0xdb, 0xa4, 0x60, 0x98, 0xb9, 0xa7, 0x73, 0x38, 0x1d, 0x85, 0xd5, 0x2f, 0xad, 0x49, 0x1b, 0x3a, 0x82, 0xaf, 0x91, 0x7, 0xf1, 0x73, 0xdb, 0x81, 0xfb, 0x35, 0xed, 0x91, 0xd2},
+               output384: []byte{0xe9, 0x1d, 0xee, 0xbc, 0xd7, 0x2b, 0xa1, 0x2e, 0x22, 0x15, 0x60, 0x2b, 0x48, 0x8d, 0xed, 0x20, 0x3a, 0x1e, 0x21, 0x1d, 0x63, 0x58, 0xca, 0xdc, 0x6f, 0x90, 0x6f, 0xbd, 0x89, 0xca, 0x92, 0x8f, 0x54, 0x12, 0x22, 0xcb, 0xd8, 0xfc, 0x9a, 0x20, 0xb5, 0x73, 0xef, 0x22, 0xfc, 0x17, 0x87, 0x78},
+               output512: []byte{0x2c, 0xe, 0xe8, 0xa1, 0x65, 0xbf, 0x88, 0xc4, 0x4c, 0x86, 0x1, 0xc6, 0x37, 0x2e, 0x52, 0x2d, 0xa9, 0xec, 0xf4, 0x25, 0x44, 0xdc, 0xdc, 0x9, 0x86, 0x98, 0xf5, 0xd, 0xf8, 0xe7, 0xe, 0xb7, 0x44, 0xc, 0xab, 0x29, 0x53, 0xbb, 0x49, 0xc, 0xd2, 0xa5, 0xe0, 0x88, 0x7b, 0xee, 0xae, 0x34, 0x82, 0x19, 0x2d, 0xa9, 0x5e, 0x50, 0x98, 0xd3, 0xb3, 0x18, 0xf1, 0x6f, 0xc0, 0x8d, 0x1e, 0x1e}},
+       testcase{
+               msg:       []byte{0xe9, 0x8, 0x47, 0xae, 0x67, 0x97, 0xfb, 0xc0, 0xb6, 0xb3, 0x6d, 0x6e, 0x58, 0x8c, 0xa, 0x74, 0x3d, 0x72, 0x57, 0x88, 0xca, 0x50, 0xb6, 0xd7, 0x92, 0x35, 0x2e, 0xa8, 0x29, 0x4f, 0x5b, 0xa6, 0x54, 0xa1, 0x53, 0x66, 0xb8, 0xe1, 0xb2, 0x88, 0xd8, 0x4f, 0x51, 0x78, 0x24, 0x8, 0x27, 0x97, 0x5a, 0x76, 0x3b, 0xc4, 0x5c, 0x7b, 0x4, 0x30, 0xe8, 0xa5, 0x59, 0xdf, 0x44, 0x88, 0x50, 0x5e, 0x0, 0x9c, 0x63, 0xda, 0x99, 0x4f, 0x14, 0x3, 0xf4, 0x7, 0x95, 0x82, 0x3, 0xce, 0xbb, 0x6e, 0x37, 0xd8, 0x9c, 0x94, 0xa5, 0xea, 0xcf, 0x60, 0x39, 0xa3, 0x27, 0xf6, 0xc4, 0xdb, 0xbc, 0x7a, 0x2a, 0x30, 0x7d, 0x97, 0x6a, 0xa3, 0x9e, 0x41, 0xaf, 0x65, 0x37, 0x24, 0x3f, 0xc2, 0x18, 0xdf, 0xa6, 0xab, 0x4d, 0xd8, 0x17, 0xb6, 0xa3, 0x97, 0xdf, 0x5c, 0xa6, 0x91, 0x7, 0xa9, 0x19, 0x87, 0x99, 0xed, 0x24, 0x86, 0x41, 0xb6, 0x3b, 0x42, 0xcb, 0x4c, 0x29, 0xbf, 0xdd, 0x79, 0x75, 0xac, 0x96, 0xed, 0xfc, 0x27, 0x4a, 0xc5, 0x62, 0xd0, 0x47, 0x4c, 0x60, 0x34, 0x7a, 0x7, 0x8c, 0xe4, 0xc2, 0x5e, 0x88},
+               output224: []byte{0x75, 0xb7, 0x7c, 0x36, 0xe3, 0x94, 0x71, 0x1d, 0xfd, 0x35, 0xc1, 0x1a, 0xec, 0x8c, 0x3, 0x3d, 0xcd, 0x7c, 0x18, 0x71, 0x2f, 0x3b, 0x6, 0xd1, 0xfe, 0xdc, 0x10, 0x77},
+               output256: []byte{0xdf, 0xfc, 0x70, 0xf, 0x3e, 0x4d, 0x84, 0xd9, 0x13, 0x1c, 0xbb, 0x1f, 0x98, 0xfb, 0x84, 0x3d, 0xba, 0xfc, 0xb2, 0xef, 0x94, 0xa5, 0x2e, 0x89, 0xd2, 0x4, 0xd4, 0x31, 0x45, 0x1a, 0x33, 0x31},
+               output384: []byte{0x45, 0x29, 0xa, 0x24, 0x29, 0x1e, 0x81, 0xcc, 0xb8, 0xd7, 0x84, 0xb, 0x6c, 0x48, 0x12, 0xac, 0x98, 0x98, 0x3d, 0x7b, 0xd3, 0xaf, 0xe4, 0x6b, 0x42, 0x72, 0x96, 0xad, 0x63, 0x68, 0x62, 0xb9, 0xe0, 0x3e, 0xcf, 0x60, 0x5b, 0x11, 0x4c, 0xb4, 0x7c, 0x2, 0x7, 0x26, 0x7b, 0xc0, 0x59, 0x58},
+               output512: []byte{0xdd, 0xd4, 0xff, 0x11, 0x72, 0x31, 0xec, 0xa0, 0x44, 0x5e, 0xad, 0xa7, 0xc7, 0xf1, 0xd8, 0x46, 0x86, 0x52, 0xd, 0xaa, 0x70, 0xe1, 0x60, 0xc8, 0x7d, 0xbb, 0xb3, 0xfb, 0x32, 0xbb, 0x9e, 0x2f, 0x4c, 0xc5, 0x3d, 0xb5, 0x41, 0x3d, 0x4e, 0x88, 0xde, 0x18, 0xa0, 0x11, 0x85, 0x70, 0x31, 0x8b, 0xd6, 0xd0, 0xe5, 0x26, 0x4d, 0x77, 0x93, 0x39, 0xac, 0x6f, 0x4f, 0x4a, 0x95, 0x54, 0x6a, 0x53}},
+       testcase{
+               msg:       []byte{0xf6, 0xd5, 0xc2, 0xb6, 0xc9, 0x39, 0x54, 0xfc, 0x62, 0x76, 0x2, 0xc0, 0xc, 0x4c, 0xa9, 0xa7, 0xd3, 0xed, 0x12, 0xb2, 0x71, 0x73, 0xf0, 0xb2, 0xc9, 0xb0, 0xe4, 0xa5, 0x93, 0x93, 0x98, 0xa6, 0x65, 0xe6, 0x7e, 0x69, 0xd0, 0xb1, 0x2f, 0xb7, 0xe4, 0xce, 0xb2, 0x53, 0xe8, 0x8, 0x3d, 0x1c, 0xeb, 0x72, 0x4a, 0xc0, 0x7f, 0x0, 0x9f, 0x9, 0x4e, 0x42, 0xf2, 0xd6, 0xf2, 0x12, 0x94, 0x89, 0xe8, 0x46, 0xea, 0xff, 0x7, 0x0, 0xa8, 0xd4, 0x45, 0x3e, 0xf4, 0x53, 0xa3, 0xed, 0xdc, 0x18, 0xf4, 0x8, 0xc7, 0x7a, 0x83, 0x27, 0x56, 0x17, 0xfa, 0xbc, 0x4e, 0xa3, 0xa2, 0x83, 0x3a, 0xa7, 0x34, 0x6, 0xc0, 0xe9, 0x66, 0x27, 0x60, 0x79, 0xd3, 0x8e, 0x8e, 0x38, 0x53, 0x9a, 0x70, 0xe1, 0x94, 0xcc, 0x55, 0x13, 0xaa, 0xa4, 0x57, 0xc6, 0x99, 0x38, 0x3f, 0xd1, 0x90, 0xb, 0x1e, 0x72, 0xbd, 0xfb, 0x83, 0x5d, 0x1f, 0xd3, 0x21, 0xb3, 0x7b, 0xa8, 0x5, 0x49, 0xb0, 0x78, 0xa4, 0x9e, 0xa0, 0x81, 0x52, 0x86, 0x9a, 0x91, 0x8c, 0xa5, 0x7f, 0x5b, 0x54, 0xed, 0x71, 0xe4, 0xfd, 0x3a, 0xc5, 0xc0, 0x67, 0x29},
+               output224: []byte{0xe5, 0x2d, 0xf7, 0xfd, 0xf9, 0x57, 0x26, 0x9c, 0xa0, 0xb0, 0xf4, 0x65, 0x53, 0xd5, 0x54, 0xfe, 0x2e, 0x63, 0x67, 0x1, 0x9b, 0x37, 0x9a, 0x1e, 0x4f, 0x4c, 0x7a, 0x9f},
+               output256: []byte{0x26, 0x72, 0x6b, 0x52, 0x24, 0x2e, 0xf8, 0xec, 0xf4, 0xc6, 0x6a, 0xed, 0x9c, 0x4b, 0x46, 0xbf, 0x6f, 0x5d, 0x87, 0x4, 0x4a, 0xb, 0x99, 0xd4, 0xe4, 0xaf, 0x47, 0xdc, 0x36, 0xb, 0x9b, 0xe},
+               output384: []byte{0xe6, 0xbb, 0x2f, 0xaf, 0x5a, 0xbb, 0x3e, 0xda, 0xff, 0xe9, 0xe4, 0x7f, 0x62, 0x58, 0x64, 0x9, 0xb4, 0x43, 0xe4, 0xc6, 0x98, 0x7, 0xd, 0x61, 0xfc, 0x8, 0x22, 0x61, 0x5, 0x32, 0x70, 0xec, 0xdc, 0x24, 0x84, 0xaa, 0x1, 0x45, 0xc8, 0x51, 0x3, 0x1e, 0x3c, 0x99, 0xde, 0xff, 0x23, 0x89},
+               output512: []byte{0xa9, 0x74, 0x4e, 0xfa, 0x42, 0x88, 0x7d, 0xf2, 0x92, 0xfc, 0x9, 0xdf, 0xeb, 0x88, 0x5f, 0x1e, 0x80, 0x18, 0x55, 0xde, 0xd0, 0x9d, 0xc2, 0xf9, 0x7c, 0xbf, 0xcb, 0xd0, 0x19, 0x75, 0x18, 0x78, 0x61, 0x9d, 0xa1, 0xbc, 0x95, 0x73, 0x20, 0x1c, 0x7c, 0xc0, 0x50, 0xe2, 0xaa, 0x1d, 0x45, 0x3e, 0x95, 0x13, 0x66, 0xd8, 0x1c, 0x18, 0x8d, 0x32, 0x9b, 0x3c, 0xb8, 0x61, 0xc1, 0xd7, 0x8f, 0x92}},
+       testcase{
+               msg:       []byte{0xcf, 0x85, 0x62, 0xb1, 0xbe, 0xd8, 0x98, 0x92, 0xd6, 0x7d, 0xda, 0xaf, 0x3d, 0xee, 0xb2, 0x82, 0x46, 0x45, 0x6e, 0x97, 0x23, 0x26, 0xdb, 0xcd, 0xb5, 0xcf, 0x3f, 0xb2, 0x89, 0xac, 0xa0, 0x1e, 0x68, 0xda, 0x5d, 0x59, 0x89, 0x6e, 0x3a, 0x61, 0x65, 0x35, 0x8b, 0x7, 0x1b, 0x30, 0x4d, 0x6a, 0xb3, 0xd0, 0x18, 0x94, 0x4b, 0xe5, 0x4, 0x9d, 0x5e, 0xe, 0x2b, 0xb8, 0x19, 0xac, 0xf6, 0x7a, 0x60, 0x6, 0x11, 0x10, 0x89, 0xe6, 0x76, 0x71, 0x32, 0xd7, 0x2d, 0xd8, 0x5b, 0xed, 0xdc, 0xbb, 0x2d, 0x64, 0x49, 0x6d, 0xb0, 0xcc, 0x92, 0x95, 0x5a, 0xb4, 0xc6, 0x23, 0x4f, 0x1e, 0xea, 0x24, 0xf2, 0xd5, 0x14, 0x83, 0xf2, 0xe2, 0x9, 0xe4, 0x58, 0x9b, 0xf9, 0x51, 0x9f, 0xac, 0x51, 0xb4, 0xd0, 0x61, 0xe8, 0x1, 0x12, 0x5e, 0x60, 0x5f, 0x80, 0x93, 0xbb, 0x69, 0x97, 0xbc, 0x16, 0x3d, 0x55, 0x15, 0x96, 0xfe, 0x4a, 0xb7, 0xcf, 0xae, 0x8f, 0xb9, 0xa9, 0xf, 0x69, 0x80, 0x48, 0xc, 0xe0, 0xc2, 0x29, 0xfd, 0x16, 0x75, 0x40, 0x9b, 0xd7, 0x88, 0x35, 0x4d, 0xaf, 0x31, 0x62, 0x40, 0xcf, 0xe0, 0xaf, 0x93, 0xeb},
+               output224: []byte{0x41, 0x85, 0x3c, 0xd5, 0x46, 0x92, 0xdb, 0xd4, 0x78, 0xbb, 0x1e, 0x2d, 0x6c, 0xed, 0xcd, 0xa1, 0xd1, 0x39, 0xc8, 0x38, 0xac, 0x95, 0x6a, 0x37, 0xc8, 0x7f, 0x9, 0x8f},
+               output256: []byte{0x25, 0xe5, 0x36, 0x31, 0x5f, 0x8, 0xa4, 0x9, 0x76, 0xad, 0xec, 0xb5, 0x47, 0x56, 0xeb, 0xc0, 0xb2, 0x24, 0xc3, 0x8f, 0xaf, 0x11, 0x50, 0x93, 0x71, 0xb5, 0xa6, 0x92, 0xa5, 0x26, 0x9a, 0xb5},
+               output384: []byte{0x79, 0xb7, 0x92, 0xb3, 0x4d, 0xa4, 0x42, 0x5b, 0xb0, 0xb4, 0x21, 0x7a, 0xbe, 0x23, 0xe5, 0xdb, 0xe4, 0xe8, 0x7d, 0x39, 0x40, 0xe2, 0xf7, 0xba, 0x52, 0xca, 0x14, 0x66, 0x18, 0x58, 0xa, 0x62, 0x54, 0x5c, 0x44, 0xb8, 0x1e, 0x6, 0x62, 0xa, 0xf6, 0xe2, 0x73, 0x49, 0x90, 0x73, 0xe3, 0xa8},
+               output512: []byte{0x89, 0xca, 0xe4, 0x62, 0x46, 0xef, 0xed, 0xad, 0x11, 0x47, 0xeb, 0x18, 0x68, 0xc2, 0x3a, 0x6b, 0xe5, 0x4f, 0x6b, 0xac, 0x75, 0xf0, 0xc9, 0x8a, 0x9a, 0xef, 0xc6, 0xbf, 0x3c, 0xcb, 0x89, 0xae, 0x1, 0x2f, 0x2e, 0x88, 0xa9, 0xc8, 0x38, 0xb5, 0x5e, 0x57, 0xb2, 0x32, 0xcb, 0x3c, 0x80, 0xbc, 0x3c, 0x2e, 0x9f, 0xb3, 0xfc, 0x97, 0x68, 0xc6, 0x22, 0x6e, 0x93, 0x28, 0x4e, 0x20, 0x8b, 0xf2}},
+       testcase{
+               msg:       []byte{0x2a, 0xce, 0x31, 0xab, 0xb0, 0xa2, 0xe3, 0x26, 0x79, 0x44, 0xd2, 0xf7, 0x5e, 0x15, 0x59, 0x98, 0x5d, 0xb7, 0x35, 0x4c, 0x6e, 0x60, 0x5f, 0x18, 0xdc, 0x84, 0x70, 0x42, 0x3f, 0xca, 0x30, 0xb7, 0x33, 0x1d, 0x9b, 0x33, 0xc4, 0xa4, 0x32, 0x67, 0x83, 0xd1, 0xca, 0xae, 0x1b, 0x4f, 0x7, 0x6, 0xe, 0xff, 0x97, 0x8e, 0x47, 0x46, 0xbf, 0xc, 0x7e, 0x30, 0xcd, 0x61, 0x4, 0xb, 0xd5, 0xec, 0x27, 0x46, 0xb2, 0x98, 0x63, 0xeb, 0x7f, 0x10, 0x3e, 0xbd, 0xa6, 0x14, 0xc4, 0x29, 0x1a, 0x80, 0x5b, 0x6a, 0x4c, 0x82, 0x14, 0x23, 0x5, 0x64, 0xa0, 0x55, 0x7b, 0xc7, 0x10, 0x2e, 0xb, 0xd3, 0xed, 0x23, 0x71, 0x92, 0x52, 0xf7, 0x43, 0x5d, 0x64, 0xd2, 0x10, 0xee, 0x2a, 0xaf, 0xc5, 0x85, 0xbe, 0x90, 0x3f, 0xa4, 0x1e, 0x19, 0x68, 0xc5, 0xf, 0xd5, 0xd5, 0x36, 0x79, 0x26, 0xdf, 0x7a, 0x5, 0xe3, 0xa4, 0x2c, 0xf0, 0x7e, 0x65, 0x6f, 0xf9, 0x2d, 0xe7, 0x3b, 0x3, 0x6c, 0xf8, 0xb1, 0x98, 0x98, 0xc0, 0xcb, 0x34, 0x55, 0x7c, 0xc, 0x12, 0xc2, 0xd8, 0xb8, 0x4e, 0x91, 0x18, 0x1a, 0xf4, 0x67, 0xbc, 0x75, 0xa9, 0xd1},
+               output224: []byte{0x1f, 0x27, 0x27, 0xd5, 0x13, 0x2c, 0x45, 0x3b, 0xd3, 0x21, 0xa9, 0xfc, 0x7a, 0xa4, 0x6f, 0xb8, 0xb3, 0x34, 0x1d, 0x90, 0x98, 0x8c, 0x41, 0xde, 0x84, 0x39, 0xd2, 0xf1},
+               output256: []byte{0xab, 0x50, 0x45, 0x92, 0xad, 0x71, 0x84, 0xbe, 0x83, 0xcc, 0x65, 0x9e, 0xfb, 0x5d, 0x3d, 0xe8, 0x8b, 0xa0, 0x4b, 0x6, 0xb, 0x45, 0xd1, 0x6a, 0x76, 0xf0, 0x34, 0x8, 0xd, 0xde, 0x56, 0xc6},
+               output384: []byte{0x9f, 0xa1, 0xd0, 0xac, 0x7c, 0x37, 0x83, 0x17, 0x31, 0xb7, 0x1c, 0x19, 0xac, 0x9e, 0x81, 0xea, 0x11, 0x50, 0x83, 0xac, 0xe6, 0xd9, 0x43, 0x49, 0xce, 0x89, 0xfd, 0xb7, 0x9b, 0x34, 0x62, 0xa7, 0x49, 0xd7, 0x6f, 0xdc, 0x93, 0x89, 0x2f, 0x2f, 0x16, 0xab, 0xf, 0x7e, 0x18, 0xcd, 0xb7, 0x9c},
+               output512: []byte{0xe8, 0xa, 0x63, 0xfa, 0xf2, 0x48, 0xae, 0x76, 0x2d, 0x13, 0x88, 0x7a, 0xfe, 0x8e, 0x19, 0x54, 0xf9, 0x73, 0x27, 0xed, 0xd9, 0x64, 0x1c, 0xe5, 0x63, 0xf4, 0x14, 0x8f, 0x97, 0x96, 0x66, 0x98, 0x27, 0xb3, 0xa1, 0x2b, 0x6, 0xeb, 0xd7, 0x10, 0xd4, 0x17, 0x1b, 0x86, 0xe2, 0x1b, 0xc1, 0x33, 0x60, 0xa5, 0x41, 0x84, 0x53, 0x54, 0xe0, 0xf4, 0x93, 0x4e, 0x6f, 0xbb, 0xd7, 0xac, 0xbf, 0x2d}},
+       testcase{
+               msg:       []byte{0xd, 0x8d, 0x9, 0xae, 0xd1, 0x9f, 0x10, 0x13, 0x96, 0x9c, 0xe5, 0xe7, 0xeb, 0x92, 0xf8, 0x3a, 0x20, 0x9a, 0xe7, 0x6b, 0xe3, 0x1c, 0x75, 0x48, 0x44, 0xea, 0x91, 0x16, 0xce, 0xb3, 0x9a, 0x22, 0xeb, 0xb6, 0x0, 0x30, 0x17, 0xbb, 0xcf, 0x26, 0x55, 0x5f, 0xa6, 0x62, 0x41, 0x85, 0x18, 0x7d, 0xb8, 0xf0, 0xcb, 0x35, 0x64, 0xb8, 0xb1, 0xc0, 0x6b, 0xf6, 0x85, 0xd4, 0x7f, 0x32, 0x86, 0xed, 0xa2, 0xb, 0x83, 0x35, 0x8f, 0x59, 0x9d, 0x20, 0x44, 0xbb, 0xf0, 0x58, 0x3f, 0xab, 0x8d, 0x78, 0xf8, 0x54, 0xfe, 0xa, 0x59, 0x61, 0x83, 0x23, 0xc, 0x5e, 0xf8, 0xe5, 0x44, 0x26, 0x75, 0xe, 0xaf, 0x2c, 0xc4, 0xe2, 0x9d, 0x3b, 0xdd, 0x3, 0x7e, 0x73, 0x4d, 0x86, 0x3c, 0x2b, 0xd9, 0x78, 0x9b, 0x4c, 0x24, 0x30, 0x96, 0x13, 0x8f, 0x76, 0x72, 0xc2, 0x32, 0x31, 0x4e, 0xff, 0xdf, 0xc6, 0x51, 0x34, 0x27, 0xe2, 0xda, 0x76, 0x91, 0x6b, 0x52, 0x48, 0x93, 0x3b, 0xe3, 0x12, 0xeb, 0x5d, 0xde, 0x4c, 0xf7, 0x8, 0x4, 0xfb, 0x25, 0x8a, 0xc5, 0xfb, 0x82, 0xd5, 0x8d, 0x8, 0x17, 0x7a, 0xc6, 0xf4, 0x75, 0x60, 0x17, 0xff, 0xf5},
+               output224: []byte{0x5e, 0x74, 0x5f, 0x89, 0x66, 0xd9, 0x1e, 0xee, 0x1, 0x3b, 0x6, 0x12, 0x81, 0xbc, 0x20, 0xc7, 0x9b, 0x3, 0x23, 0x0, 0xa, 0x15, 0xbb, 0xde, 0x7e, 0xd, 0x25, 0xae},
+               output256: []byte{0x5d, 0x8e, 0xe1, 0x33, 0xec, 0x44, 0x1a, 0x3d, 0xf5, 0xa, 0x52, 0x68, 0xa8, 0xf3, 0x93, 0xf1, 0x3f, 0x30, 0xf2, 0x3f, 0x22, 0x6a, 0xe3, 0xa1, 0x8e, 0xc3, 0x31, 0x84, 0x44, 0x2, 0xff, 0x54},
+               output384: []byte{0x18, 0x7c, 0xdf, 0xdb, 0x37, 0x57, 0xd8, 0x0, 0x10, 0xd1, 0xe5, 0x31, 0x57, 0xa5, 0xcc, 0xb0, 0xfc, 0xc3, 0x49, 0x98, 0xef, 0xc6, 0xbb, 0x3c, 0xe2, 0xe6, 0x7, 0x68, 0xf5, 0xee, 0xaa, 0x59, 0x6, 0x56, 0xb4, 0x9c, 0xe, 0x3, 0x6a, 0x3f, 0x34, 0xc9, 0xef, 0x25, 0xf3, 0xbe, 0x58, 0x7a},
+               output512: []byte{0x9, 0xc1, 0xc, 0x48, 0x18, 0xa6, 0x82, 0x1c, 0x17, 0xd, 0x67, 0x80, 0xd0, 0x6, 0xf7, 0xe8, 0x53, 0xe3, 0xf, 0xe2, 0xd9, 0xa4, 0xe9, 0x65, 0x45, 0x67, 0x37, 0x4, 0xec, 0xa, 0x1a, 0x3e, 0x35, 0x63, 0x75, 0x71, 0x59, 0x94, 0xe1, 0xac, 0x1d, 0x8c, 0xb0, 0xe5, 0x6d, 0xbd, 0xb2, 0xf7, 0x7d, 0xc5, 0x58, 0xed, 0x22, 0x8f, 0xb5, 0x6e, 0xe6, 0x22, 0x17, 0xe6, 0x34, 0x55, 0xfd, 0xb}},
+       testcase{
+               msg:       []byte{0xc3, 0x23, 0x6b, 0x73, 0xde, 0xb7, 0x66, 0x2b, 0xf3, 0xf3, 0xda, 0xa5, 0x8f, 0x13, 0x7b, 0x35, 0x8b, 0xa6, 0x10, 0x56, 0xe, 0xf7, 0x45, 0x57, 0x85, 0xa9, 0xbe, 0xfd, 0xb0, 0x35, 0xa0, 0x66, 0xe9, 0x7, 0x4, 0xf9, 0x29, 0xbd, 0x96, 0x89, 0xce, 0xf0, 0xce, 0x3b, 0xda, 0x5a, 0xcf, 0x44, 0x80, 0xbc, 0xeb, 0x8d, 0x9, 0xd1, 0xb, 0x9, 0x8a, 0xd8, 0x50, 0xd, 0x9b, 0x60, 0x71, 0xdf, 0xc3, 0xa1, 0x4a, 0xf6, 0xc7, 0x75, 0x11, 0xd8, 0x1e, 0x3a, 0xa8, 0x84, 0x49, 0x86, 0xc3, 0xbe, 0xa6, 0xf4, 0x69, 0xf9, 0xe0, 0x21, 0x94, 0xc9, 0x28, 0x68, 0xcd, 0x5f, 0x51, 0x64, 0x62, 0x56, 0x79, 0x8f, 0xf0, 0x42, 0x49, 0x54, 0xc1, 0x43, 0x4b, 0xdf, 0xed, 0x9f, 0xac, 0xb3, 0x90, 0xb0, 0x7d, 0x34, 0x2e, 0x99, 0x29, 0x36, 0xe0, 0xf8, 0x8b, 0xfd, 0xe, 0x88, 0x4a, 0xd, 0xdb, 0x67, 0x9d, 0x5, 0x47, 0xcc, 0xde, 0xc6, 0x38, 0x42, 0x85, 0xa4, 0x54, 0x29, 0xd1, 0x15, 0xac, 0x7d, 0x23, 0x5a, 0x71, 0x72, 0x42, 0x2, 0x1d, 0x1d, 0xc3, 0x56, 0x41, 0xf5, 0xf0, 0xa4, 0x8e, 0x84, 0x45, 0xdb, 0xa5, 0x8e, 0x6c, 0xb2, 0xc8, 0xea},
+               output224: []byte{0xcd, 0x2e, 0xeb, 0x7d, 0x48, 0xd0, 0x26, 0x9, 0x86, 0xba, 0xdf, 0x16, 0xf1, 0x5a, 0xa0, 0x9b, 0x52, 0x29, 0xb7, 0x83, 0xc, 0x73, 0xee, 0x95, 0xb8, 0xcb, 0xf8, 0x5a},
+               output256: []byte{0x71, 0x2b, 0x1c, 0xc0, 0x4c, 0x0, 0x9b, 0x52, 0x3, 0x5c, 0xc4, 0x4c, 0x95, 0x5, 0xbb, 0x5c, 0xb5, 0x77, 0xba, 0xa, 0xd1, 0x73, 0x4e, 0xc2, 0x36, 0x20, 0xf5, 0x7e, 0xef, 0x3d, 0x37, 0xfb},
+               output384: []byte{0x70, 0x43, 0xf5, 0x4f, 0x39, 0xb, 0x6a, 0xbd, 0xd, 0xff, 0x6, 0xf2, 0x66, 0xe0, 0xe7, 0xb3, 0xe4, 0x1f, 0x8d, 0x2e, 0x8d, 0xd4, 0x3f, 0x89, 0x9a, 0xc4, 0x56, 0x66, 0x24, 0x47, 0xa8, 0x23, 0xa5, 0x67, 0xb1, 0xb0, 0xfb, 0x8c, 0x2d, 0xf2, 0x4e, 0x5f, 0x66, 0x89, 0x6, 0xc, 0xdd, 0xb4},
+               output512: []byte{0xd1, 0xca, 0xb5, 0x97, 0x9e, 0xb7, 0xf5, 0x3c, 0x97, 0xdc, 0xa5, 0xd7, 0x25, 0xd8, 0xb3, 0x30, 0x8, 0x90, 0x6d, 0x77, 0x59, 0xfd, 0x3e, 0xbb, 0x84, 0x1, 0xee, 0x2f, 0xff, 0x1, 0xdb, 0x89, 0x54, 0x95, 0xa0, 0xa0, 0x62, 0xd4, 0x7f, 0x25, 0x1b, 0xc3, 0xfc, 0x13, 0x98, 0x86, 0x7, 0xc6, 0x79, 0x89, 0x69, 0xd2, 0x13, 0xc9, 0x41, 0xef, 0xc1, 0x52, 0xe7, 0xdb, 0x1d, 0xa6, 0x8e, 0x72}},
+       testcase{
+               msg:       []byte{0xb3, 0x9f, 0xeb, 0x82, 0x83, 0xea, 0xdc, 0x63, 0xe8, 0x18, 0x4b, 0x51, 0xdf, 0x5a, 0xe3, 0xfd, 0x41, 0xaa, 0xc8, 0xa9, 0x63, 0xbb, 0xb, 0xe1, 0xcd, 0x8, 0xaa, 0x58, 0x67, 0xd8, 0xd9, 0x10, 0xc6, 0x69, 0x22, 0x1e, 0x73, 0x24, 0x33, 0x60, 0x64, 0x6f, 0x65, 0x53, 0xd1, 0xca, 0x5, 0xa8, 0x4e, 0x8d, 0xc0, 0xde, 0x5, 0xb6, 0x41, 0x9e, 0xc3, 0x49, 0xca, 0x99, 0x44, 0x80, 0x19, 0x3d, 0x1, 0xc9, 0x25, 0x25, 0xf3, 0xfb, 0x3d, 0xce, 0xfb, 0x8, 0xaf, 0xc6, 0xd2, 0x69, 0x47, 0xbd, 0xbb, 0xfd, 0x85, 0x19, 0x3f, 0x53, 0xb5, 0x6, 0x9, 0xc6, 0x14, 0x9, 0x5, 0xc5, 0x3a, 0x66, 0x86, 0xb5, 0x8e, 0x53, 0xa3, 0x19, 0xa5, 0x7b, 0x96, 0x23, 0x31, 0xed, 0xe9, 0x81, 0x49, 0xaf, 0x3d, 0xe3, 0x11, 0x8a, 0x81, 0x9d, 0xa4, 0xd7, 0x67, 0x6, 0xa0, 0x42, 0x4b, 0x4e, 0x1d, 0x29, 0x10, 0xb0, 0xed, 0x26, 0xaf, 0x61, 0xd1, 0x50, 0xeb, 0xcb, 0x46, 0x59, 0x5d, 0x42, 0x66, 0xa0, 0xbd, 0x7f, 0x65, 0x1b, 0xa4, 0x7d, 0xc, 0x7f, 0x17, 0x9c, 0xa2, 0x85, 0x45, 0x0, 0x7d, 0x92, 0xe8, 0x41, 0x9d, 0x48, 0xfd, 0xfb, 0xd7, 0x44, 0xce},
+               output224: []byte{0x33, 0x22, 0xfa, 0x72, 0x7a, 0x0, 0x89, 0xf5, 0x0, 0xa6, 0xa9, 0x9d, 0x67, 0x41, 0x9a, 0x76, 0xc7, 0xaf, 0x77, 0xef, 0x28, 0x93, 0xe8, 0xd3, 0x85, 0xb4, 0x27, 0x20},
+               output256: []byte{0x94, 0x2e, 0x39, 0xe2, 0x30, 0xa2, 0x25, 0x1f, 0xfd, 0xb2, 0xf8, 0x52, 0x2, 0x87, 0x1c, 0x98, 0x59, 0x70, 0x8, 0x40, 0x1b, 0x32, 0x2f, 0xf9, 0x84, 0xc, 0xc9, 0xc, 0xc8, 0x5b, 0x33, 0x7d},
+               output384: []byte{0xd0, 0xce, 0x2, 0x59, 0xaa, 0xee, 0xa5, 0xba, 0xef, 0xf5, 0x29, 0x29, 0x42, 0x3c, 0x3d, 0xa0, 0x7a, 0x8c, 0x75, 0x19, 0x5f, 0x86, 0xd7, 0x33, 0xa7, 0x18, 0xd1, 0xc4, 0x6a, 0x1e, 0x40, 0xaa, 0xd4, 0x4, 0x75, 0xc, 0x41, 0xd7, 0xa1, 0x58, 0xe7, 0x9f, 0x27, 0x88, 0x30, 0xb4, 0xc0, 0x7a},
+               output512: []byte{0x96, 0xad, 0x16, 0x38, 0x69, 0xae, 0x2f, 0xfd, 0xb8, 0x9b, 0x96, 0xf4, 0xdc, 0x70, 0xe, 0xce, 0x27, 0xd1, 0xf4, 0xda, 0xaf, 0xbc, 0x5f, 0xb8, 0x1a, 0x8e, 0x95, 0x13, 0xc6, 0xea, 0x5e, 0x2b, 0x6a, 0x8b, 0xcc, 0xf4, 0xe4, 0x9a, 0x29, 0x4a, 0xf3, 0x26, 0xf8, 0x72, 0x74, 0x6, 0x61, 0x62, 0x9a, 0xb7, 0x80, 0x58, 0x11, 0x55, 0x81, 0xe, 0x49, 0x24, 0x24, 0xc2, 0x4f, 0x8d, 0x1d, 0xd3}},
+       testcase{
+               msg:       []byte{0xa9, 0x83, 0xd5, 0x4f, 0x50, 0x38, 0x3, 0xe8, 0xc7, 0x99, 0x9f, 0x4e, 0xdb, 0xbe, 0x82, 0xe9, 0x8, 0x4f, 0x42, 0x21, 0x43, 0xa9, 0x32, 0xdd, 0xdd, 0xc4, 0x7a, 0x17, 0xb0, 0xb7, 0x56, 0x4a, 0x7f, 0x37, 0xa9, 0x9d, 0x7, 0x86, 0xe9, 0x94, 0x76, 0x42, 0x8d, 0x29, 0xe2, 0x9d, 0x3c, 0x19, 0x7a, 0x72, 0xbf, 0xab, 0x13, 0x42, 0xc1, 0x2a, 0xf, 0xc4, 0x78, 0x7f, 0xd7, 0x1, 0x7d, 0x7a, 0x61, 0x74, 0x4, 0x9e, 0xa4, 0x3b, 0x57, 0x79, 0x16, 0x9e, 0xf7, 0x47, 0x2b, 0xdb, 0xbd, 0x94, 0x1d, 0xcb, 0x82, 0xfc, 0x73, 0xaa, 0xc4, 0x5a, 0x8a, 0x94, 0xc9, 0xf2, 0xbd, 0x34, 0x77, 0xf6, 0x1f, 0xd3, 0xb7, 0x96, 0xf0, 0x2a, 0x1b, 0x82, 0x64, 0xa2, 0x14, 0xc6, 0xfe, 0xa7, 0x4b, 0x70, 0x51, 0xb2, 0x26, 0xc7, 0x22, 0x9, 0x9e, 0xc7, 0x88, 0x3a, 0x46, 0x2b, 0x83, 0xb6, 0xaf, 0xdd, 0x40, 0x9, 0x24, 0x8b, 0x8a, 0x23, 0x7f, 0x60, 0x5f, 0xe5, 0xa0, 0x8f, 0xe7, 0xd8, 0xb4, 0x53, 0x21, 0x42, 0x1e, 0xbb, 0xa6, 0x7b, 0xd7, 0xa, 0xb, 0x0, 0xdd, 0xbf, 0x94, 0xba, 0xab, 0x7f, 0x35, 0x9d, 0x5d, 0x1e, 0xea, 0x10, 0x5f, 0x28, 0xdc, 0xfb},
+               output224: []byte{0x23, 0x4c, 0x1b, 0xc0, 0x3f, 0xd4, 0xc3, 0xd3, 0x8d, 0xd4, 0xc7, 0x36, 0xb5, 0x9a, 0x91, 0x7, 0x91, 0x12, 0x10, 0xd5, 0x4e, 0x98, 0xb3, 0xa3, 0x72, 0xf5, 0x72, 0x36},
+               output256: []byte{0xb5, 0x42, 0xb6, 0xcd, 0x8e, 0xf2, 0xda, 0xb4, 0xed, 0x83, 0xb7, 0x7a, 0xc6, 0xdc, 0x52, 0xda, 0xf5, 0x54, 0xec, 0xda, 0x4e, 0xf7, 0xab, 0xa, 0x50, 0xe5, 0x46, 0xbe, 0xbe, 0x2d, 0x8e, 0x5a},
+               output384: []byte{0xe4, 0x38, 0x5a, 0x3b, 0xe0, 0x11, 0xaf, 0x20, 0xfe, 0x45, 0x66, 0xc1, 0xce, 0xbf, 0x4a, 0xa6, 0x82, 0x70, 0xe4, 0x2b, 0xe5, 0xa, 0xaa, 0xae, 0x65, 0xf8, 0xf6, 0x5, 0xe9, 0x80, 0xb1, 0xd2, 0x73, 0x6f, 0xb0, 0xe7, 0x94, 0x33, 0xd, 0x76, 0x4c, 0xa9, 0x6b, 0xc6, 0x8b, 0x83, 0x60, 0xbc},
+               output512: []byte{0xfd, 0x2e, 0x7a, 0x6e, 0x11, 0xe5, 0xd0, 0x2, 0x78, 0x9, 0x9e, 0xaf, 0x40, 0x30, 0x54, 0xd6, 0x17, 0xac, 0xac, 0x5b, 0xd3, 0xd0, 0xa4, 0x90, 0x81, 0x91, 0x78, 0x2c, 0x89, 0xf9, 0x21, 0x7a, 0x3f, 0x1, 0x18, 0xbc, 0x2b, 0x28, 0x4f, 0xdb, 0xce, 0x80, 0x3f, 0x66, 0xb7, 0x8d, 0xd7, 0x95, 0xeb, 0x18, 0xdc, 0x16, 0xba, 0x85, 0xe1, 0x9c, 0xb6, 0x39, 0x3d, 0xc5, 0x6c, 0x6, 0xec, 0xca}},
+       testcase{
+               msg:       []byte{0xe4, 0xd1, 0xc1, 0x89, 0x7a, 0xa, 0x86, 0x6c, 0xe5, 0x64, 0x63, 0x5b, 0x74, 0x22, 0x2f, 0x96, 0x96, 0xbf, 0x2c, 0x7f, 0x64, 0xd, 0xd7, 0x8d, 0x7e, 0x2a, 0xca, 0x66, 0xe1, 0xb6, 0x1c, 0x64, 0x2b, 0xb0, 0x3e, 0xa7, 0x53, 0x6a, 0xae, 0x59, 0x78, 0x11, 0xe9, 0xbf, 0x4a, 0x7b, 0x45, 0x3e, 0xde, 0x31, 0xf9, 0x7b, 0x46, 0xa5, 0xf0, 0xef, 0x51, 0xa0, 0x71, 0xa2, 0xb3, 0x91, 0x8d, 0xf1, 0x6b, 0x15, 0x25, 0x19, 0xae, 0x37, 0x76, 0xf9, 0xf1, 0xed, 0xab, 0x4c, 0x2a, 0x37, 0x7c, 0x32, 0x92, 0xe9, 0x64, 0x8, 0x35, 0x9d, 0x36, 0x13, 0x84, 0x4d, 0x5e, 0xb3, 0x93, 0x0, 0x2, 0x83, 0xd5, 0xad, 0x34, 0x1, 0xa3, 0x18, 0xb1, 0x2f, 0xd1, 0x47, 0x4b, 0x86, 0x12, 0xf2, 0xbb, 0x50, 0xfb, 0x6a, 0x8b, 0x9e, 0x2, 0x3a, 0x54, 0xd7, 0xdd, 0xe2, 0x8c, 0x43, 0xd6, 0xd8, 0x85, 0x4c, 0x8d, 0x9d, 0x11, 0x55, 0x93, 0x5c, 0x19, 0x98, 0x11, 0xdb, 0xfc, 0x87, 0xe9, 0xe0, 0x7, 0x2e, 0x90, 0xeb, 0x88, 0x68, 0x1c, 0xc7, 0x52, 0x97, 0x14, 0xf8, 0xfb, 0x8a, 0x2c, 0x9d, 0x88, 0x56, 0x7a, 0xdf, 0xb9, 0x74, 0xee, 0x20, 0x5a, 0x9b, 0xf7, 0xb8, 0x48},
+               output224: []byte{0xbf, 0x22, 0x9f, 0x40, 0x17, 0xe1, 0x67, 0x4d, 0x4c, 0xb8, 0x7b, 0x70, 0xd3, 0xd7, 0x77, 0xc7, 0x11, 0x4f, 0x8, 0x5d, 0x77, 0x21, 0x64, 0x37, 0xb8, 0x60, 0xd6, 0x41},
+               output256: []byte{0xf7, 0xe9, 0xe8, 0x25, 0x72, 0x2e, 0x65, 0x54, 0xa8, 0x61, 0x9c, 0xca, 0x3e, 0x57, 0xf5, 0xb5, 0xe6, 0xb7, 0x34, 0x74, 0x31, 0xd5, 0x5c, 0xe1, 0x78, 0x37, 0x2c, 0x91, 0x7b, 0xfb, 0x3d, 0xc2},
+               output384: []byte{0xc9, 0x79, 0xf0, 0x6, 0x56, 0xa0, 0x9e, 0x68, 0x48, 0x5c, 0xcf, 0x7, 0xfb, 0xbb, 0x91, 0x8, 0xb0, 0xc, 0x5f, 0xc1, 0x1d, 0x41, 0xf5, 0x96, 0x6f, 0xf0, 0x86, 0xf2, 0x6c, 0x71, 0x2, 0x47, 0x8e, 0xc1, 0x77, 0xee, 0x6d, 0x78, 0xc6, 0x23, 0xc3, 0x75, 0xa9, 0xe6, 0xf7, 0x61, 0x80, 0x9a},
+               output512: []byte{0xae, 0x53, 0x77, 0x6d, 0x96, 0x9a, 0x9b, 0x28, 0x56, 0x41, 0x99, 0x8a, 0x9f, 0x2c, 0x70, 0xca, 0x71, 0x85, 0x6c, 0x95, 0x6a, 0x3c, 0x43, 0xa, 0x32, 0xa1, 0xe0, 0x3a, 0x8e, 0x8, 0xd5, 0x44, 0xf1, 0x65, 0x11, 0xa2, 0x7c, 0xfa, 0x59, 0xf6, 0xb8, 0x27, 0x5a, 0x23, 0x57, 0xf8, 0xef, 0xa6, 0x54, 0x4b, 0x1c, 0xd0, 0xc0, 0xa, 0x94, 0x60, 0xf4, 0x79, 0x54, 0xa1, 0x46, 0x42, 0x9e, 0x49}},
+       testcase{
+               msg:       []byte{0xb1, 0xc, 0x59, 0x72, 0x3e, 0x3d, 0xca, 0xdd, 0x6d, 0x75, 0xdf, 0x87, 0xd0, 0xa1, 0x58, 0xe, 0x73, 0x13, 0x3a, 0x9b, 0x7d, 0x0, 0xcb, 0x95, 0xec, 0x19, 0xf5, 0x54, 0x70, 0x27, 0x32, 0x3b, 0xe7, 0x51, 0x58, 0xb1, 0x1f, 0x80, 0xb6, 0xe1, 0x42, 0xc6, 0xa7, 0x85, 0x31, 0x88, 0x6d, 0x90, 0x47, 0xb0, 0x8e, 0x55, 0x1e, 0x75, 0xe6, 0x26, 0x1e, 0x79, 0x78, 0x53, 0x66, 0xd7, 0x2, 0x4b, 0xd7, 0xcd, 0x9c, 0xf3, 0x22, 0xd9, 0xbe, 0x7d, 0x57, 0xfb, 0x66, 0x10, 0x69, 0xf2, 0x48, 0x1c, 0x7b, 0xb7, 0x59, 0xcd, 0x71, 0xb4, 0xb3, 0x6c, 0xa2, 0xbc, 0x2d, 0xf6, 0xd3, 0xa3, 0x28, 0xfa, 0xeb, 0xdb, 0x99, 0x5a, 0x97, 0x94, 0xa8, 0xd7, 0x21, 0x55, 0xed, 0x55, 0x1a, 0x1f, 0x87, 0xc8, 0xb, 0xf6, 0x5, 0x9b, 0x43, 0xfc, 0x76, 0x49, 0x0, 0xb1, 0x8a, 0x1c, 0x24, 0x41, 0xf7, 0x48, 0x77, 0x43, 0xcf, 0x84, 0xe5, 0x65, 0xf6, 0x1f, 0x8d, 0xd2, 0xec, 0xe6, 0xb6, 0xcc, 0xc9, 0x44, 0x40, 0x49, 0x19, 0x7a, 0xaa, 0xf5, 0x3e, 0x92, 0x6f, 0xbe, 0xe3, 0xbf, 0xca, 0x8b, 0xe5, 0x88, 0xec, 0x77, 0xf2, 0x9d, 0x21, 0x1b, 0xe8, 0x9d, 0xe1, 0x8b, 0x15, 0xf6},
+               output224: []byte{0xf9, 0x5d, 0xe3, 0xf4, 0xe, 0x5f, 0xaf, 0x58, 0xd3, 0x32, 0xb, 0x5b, 0x24, 0xac, 0xec, 0x7d, 0xe6, 0xb4, 0xb7, 0xe5, 0x4c, 0x2f, 0x80, 0xf6, 0xd3, 0x14, 0xab, 0x5a},
+               output256: []byte{0x14, 0xbb, 0x22, 0xb9, 0x8e, 0xaf, 0x41, 0xa4, 0xc2, 0x24, 0xfd, 0x3c, 0x37, 0x18, 0x8a, 0x75, 0x5f, 0x9b, 0x4, 0xf4, 0x6f, 0x3e, 0x23, 0xa6, 0x52, 0xda, 0x3d, 0xb9, 0xe2, 0x5d, 0x2f, 0x2c},
+               output384: []byte{0x36, 0x13, 0x93, 0x36, 0x11, 0xd, 0x1d, 0x6c, 0x27, 0xe4, 0xcc, 0x1f, 0x26, 0xf4, 0x28, 0xeb, 0x8b, 0xdb, 0xcb, 0xa3, 0xaa, 0x9f, 0xfd, 0xce, 0xcf, 0x72, 0x0, 0x9f, 0xb4, 0x6b, 0xfa, 0xf9, 0xe3, 0x46, 0x4c, 0x48, 0xbe, 0xfa, 0x47, 0x45, 0xbe, 0x36, 0xc6, 0x97, 0xdd, 0x3b, 0xed, 0x8b},
+               output512: []byte{0xd4, 0x74, 0x8c, 0x8e, 0x17, 0xf4, 0x11, 0x7b, 0xf2, 0xbf, 0x71, 0x55, 0x7a, 0xbb, 0x55, 0x92, 0x47, 0x55, 0x21, 0x26, 0xc3, 0x61, 0x92, 0xc5, 0xdf, 0x5c, 0x6c, 0x3e, 0x30, 0x7d, 0x87, 0x9b, 0x70, 0x3c, 0x3f, 0xcd, 0x70, 0x99, 0xdd, 0xab, 0x24, 0x3e, 0x2f, 0x1d, 0x5a, 0xe5, 0x6, 0x69, 0x90, 0xa7, 0xb3, 0x8d, 0x3f, 0x2c, 0xd7, 0xfb, 0x11, 0x5a, 0xa6, 0xd1, 0x35, 0xe7, 0x26, 0x1d}},
+       testcase{
+               msg:       []byte{0xdb, 0x11, 0xf6, 0x9, 0xba, 0xba, 0x7b, 0xc, 0xa6, 0x34, 0x92, 0x6b, 0x1d, 0xd5, 0x39, 0xc8, 0xcb, 0xad, 0xa2, 0x49, 0x67, 0xd7, 0xad, 0xd4, 0xd9, 0x87, 0x6f, 0x77, 0xc2, 0xd8, 0xc, 0xf, 0x4d, 0xce, 0xfb, 0xd7, 0x12, 0x15, 0x48, 0x37, 0x35, 0x82, 0x70, 0x5c, 0xca, 0x24, 0x95, 0xbd, 0x2a, 0x43, 0x71, 0x6f, 0xe6, 0x4e, 0xd2, 0x6d, 0x5, 0x9c, 0xfb, 0x56, 0x6b, 0x33, 0x64, 0xbd, 0x49, 0xee, 0x7, 0x17, 0xbd, 0xd9, 0x81, 0xd, 0xd1, 0x4d, 0x8f, 0xad, 0x80, 0xdb, 0xbd, 0xc4, 0xca, 0xfb, 0x37, 0xcc, 0x60, 0xfb, 0xf, 0xe2, 0xa8, 0xf, 0xb4, 0x54, 0x1b, 0x8c, 0xa9, 0xd5, 0x9d, 0xce, 0x45, 0x77, 0x38, 0xa9, 0xd3, 0xd8, 0xf6, 0x41, 0xaf, 0x8c, 0x3f, 0xd6, 0xda, 0x16, 0x2d, 0xc1, 0x6f, 0xc0, 0x1a, 0xac, 0x52, 0x7a, 0x4a, 0x2, 0x55, 0xb4, 0xd2, 0x31, 0xc0, 0xbe, 0x50, 0xf4, 0x4f, 0xd, 0xb0, 0xb7, 0x13, 0xaf, 0x3, 0xd9, 0x68, 0xfe, 0x7f, 0xf, 0x61, 0xed, 0x8, 0x24, 0xc5, 0x5c, 0x4b, 0x52, 0x65, 0x54, 0x8f, 0xeb, 0xd6, 0xaa, 0xd5, 0xc5, 0xee, 0xdf, 0x63, 0xef, 0xe7, 0x93, 0x48, 0x9c, 0x39, 0xb8, 0xfd, 0x29, 0xd1, 0x4, 0xce},
+               output224: []byte{0x4, 0xb3, 0xbb, 0xbd, 0xdf, 0xeb, 0xa4, 0x41, 0x0, 0x5a, 0x48, 0xce, 0xbd, 0xbb, 0x1c, 0x6b, 0x6a, 0x67, 0x4c, 0x2d, 0x9b, 0x22, 0x4d, 0xa2, 0x98, 0x44, 0x37, 0x4d},
+               output256: []byte{0xeb, 0x56, 0x68, 0xf9, 0x94, 0x1c, 0x6, 0xe5, 0xe3, 0x8e, 0xa0, 0x1b, 0x7f, 0xa9, 0x80, 0x63, 0x8b, 0x95, 0x36, 0xca, 0x19, 0x39, 0x95, 0xc, 0x16, 0x29, 0xf8, 0x4a, 0x6e, 0xff, 0x38, 0x66},
+               output384: []byte{0xce, 0x32, 0x68, 0xb8, 0xec, 0x92, 0x3b, 0x33, 0x31, 0xea, 0x2c, 0xf8, 0x51, 0x32, 0xc0, 0x73, 0x3c, 0xf8, 0xbf, 0x87, 0xda, 0xa5, 0x44, 0xf8, 0xee, 0x38, 0x6d, 0x5d, 0xe9, 0xfb, 0xd4, 0xd8, 0xad, 0x94, 0xe0, 0xb, 0x70, 0x5c, 0xa5, 0xb6, 0x1a, 0x3c, 0x17, 0x90, 0xb6, 0x50, 0x8, 0xc},
+               output512: []byte{0xd8, 0xff, 0x4, 0x81, 0xa6, 0x38, 0x90, 0xf0, 0xe5, 0xa5, 0x36, 0xeb, 0xba, 0x2f, 0x25, 0x3f, 0xa2, 0xcf, 0xa1, 0x9c, 0xf, 0x35, 0x35, 0x87, 0xaf, 0x4b, 0xdc, 0x31, 0x90, 0xe4, 0xf8, 0xf5, 0x4d, 0x17, 0xd6, 0x65, 0xe8, 0xb2, 0x1, 0x11, 0x21, 0xd4, 0x44, 0xbf, 0xad, 0xff, 0xf3, 0xe1, 0x92, 0xd9, 0x7f, 0xa0, 0x3b, 0x84, 0x9d, 0x63, 0xf3, 0x6d, 0xb2, 0xf, 0x4c, 0xf8, 0x8a, 0x74}},
+       testcase{
+               msg:       []byte{0xbe, 0xbd, 0x4f, 0x1a, 0x84, 0xfc, 0x8b, 0x15, 0xe4, 0x45, 0x2a, 0x54, 0xbd, 0x2, 0xd6, 0x9e, 0x30, 0x4b, 0x7f, 0x32, 0x61, 0x6a, 0xad, 0xd9, 0x5, 0x37, 0x93, 0x71, 0x6, 0xae, 0x4e, 0x28, 0xde, 0x9d, 0x8a, 0xab, 0x2, 0xd1, 0x9b, 0xc3, 0xe2, 0xfd, 0xe1, 0xd6, 0x51, 0x55, 0x9e, 0x29, 0x64, 0x53, 0xe4, 0xdb, 0xa9, 0x43, 0x70, 0xa1, 0x4d, 0xbb, 0xb2, 0xd1, 0xd4, 0xe2, 0x2, 0x23, 0x2, 0xee, 0x90, 0xe2, 0x8, 0x32, 0x1e, 0xfc, 0xd8, 0x52, 0x8a, 0xd8, 0x9e, 0x46, 0xdc, 0x83, 0x9e, 0xa9, 0xdf, 0x61, 0x8e, 0xa8, 0x39, 0x4a, 0x6b, 0xff, 0x30, 0x8e, 0x77, 0x26, 0xba, 0xe0, 0xc1, 0x9b, 0xcd, 0x4b, 0xe5, 0x2d, 0xa6, 0x25, 0x8e, 0x2e, 0xf4, 0xe9, 0x6a, 0xa2, 0x12, 0x44, 0x42, 0x9f, 0x49, 0xef, 0x5c, 0xb4, 0x86, 0xd7, 0xff, 0x35, 0xca, 0xc1, 0xba, 0xcb, 0x7e, 0x95, 0x71, 0x19, 0x44, 0xbc, 0xcb, 0x2a, 0xb3, 0x47, 0x0, 0xd4, 0x2d, 0x1e, 0xb3, 0x8b, 0x5d, 0x53, 0x6b, 0x94, 0x73, 0x48, 0xa4, 0x58, 0xed, 0xe3, 0xdc, 0x6b, 0xd6, 0xec, 0x54, 0x7b, 0x1b, 0xc, 0xae, 0x5b, 0x25, 0x7b, 0xe3, 0x6a, 0x71, 0x24, 0xe1, 0x6, 0xc, 0x17, 0xf, 0xfa},
+               output224: []byte{0x6c, 0x18, 0x9, 0xcd, 0x88, 0xa0, 0xed, 0xb2, 0x11, 0x98, 0x63, 0x59, 0x49, 0x8e, 0xa, 0xc3, 0x7e, 0x25, 0xe8, 0xeb, 0x62, 0x94, 0x69, 0x38, 0xc3, 0x7d, 0x3c, 0x26},
+               output256: []byte{0x91, 0x30, 0x14, 0xbb, 0x6e, 0x24, 0x3f, 0xac, 0x3a, 0x22, 0xa1, 0x85, 0xf8, 0x22, 0x7a, 0x68, 0xc2, 0x31, 0x1d, 0xc0, 0xb7, 0x18, 0xe2, 0x76, 0xbb, 0xbd, 0xb7, 0x3a, 0xf9, 0x8b, 0xe3, 0x5f},
+               output384: []byte{0xdd, 0xc3, 0x98, 0x87, 0x9b, 0xd1, 0x6f, 0xb6, 0x81, 0xfa, 0xe1, 0x51, 0x2e, 0x3a, 0x1a, 0xe7, 0xed, 0x23, 0x62, 0xda, 0xd8, 0xbe, 0xe0, 0xd1, 0x2d, 0x22, 0x56, 0xb2, 0xd8, 0x56, 0x28, 0x20, 0x43, 0xdc, 0xc, 0xbb, 0xc0, 0xf6, 0x31, 0x97, 0xb7, 0x5e, 0x99, 0x82, 0xa1, 0xda, 0xa8, 0xae},
+               output512: []byte{0x52, 0xd7, 0x71, 0xb5, 0x1, 0x6c, 0x6b, 0x1b, 0x93, 0xd3, 0xbf, 0x6a, 0x13, 0xf7, 0x18, 0xa7, 0xb4, 0x74, 0x1d, 0x52, 0x87, 0x98, 0x60, 0x93, 0x8, 0xb5, 0x4c, 0xea, 0x60, 0x37, 0x86, 0x2d, 0x92, 0x37, 0x51, 0xfd, 0xdc, 0xe1, 0x5, 0x80, 0xa7, 0xd6, 0x43, 0x1b, 0xf2, 0x8, 0xdf, 0x17, 0xc1, 0xb8, 0x25, 0xf7, 0xc7, 0x40, 0x1c, 0xcb, 0xd6, 0xd8, 0x6, 0xb7, 0x44, 0x24, 0x1a, 0xcf}},
+       testcase{
+               msg:       []byte{0x5a, 0xca, 0x56, 0xa0, 0x3a, 0x13, 0x78, 0x4b, 0xdc, 0x32, 0x89, 0xd9, 0x36, 0x4f, 0x79, 0xe2, 0xa8, 0x5c, 0x12, 0x27, 0x6b, 0x49, 0xb9, 0x2d, 0xb0, 0xad, 0xaa, 0x4f, 0x20, 0x6d, 0x50, 0x28, 0xf2, 0x13, 0xf6, 0x78, 0xc3, 0x51, 0xe, 0x11, 0x1f, 0x9d, 0xc4, 0xc1, 0xc1, 0xf8, 0xb6, 0xac, 0xb1, 0x7a, 0x64, 0x13, 0xaa, 0x22, 0x76, 0x7, 0xc5, 0x15, 0xc6, 0x2a, 0x73, 0x38, 0x17, 0xba, 0x5e, 0x76, 0x2c, 0xc6, 0x74, 0x8e, 0x7e, 0xd, 0x68, 0x72, 0xc9, 0x84, 0xd7, 0x23, 0xc9, 0xbb, 0x3b, 0x11, 0x7e, 0xb8, 0x96, 0x31, 0x85, 0x30, 0xa, 0x80, 0xbf, 0xa6, 0x5c, 0xde, 0x49, 0x5d, 0x70, 0xa4, 0x6c, 0x44, 0x85, 0x86, 0x5, 0xfc, 0xcb, 0xed, 0x8, 0x6c, 0x2b, 0x45, 0xce, 0xf9, 0x63, 0xd3, 0x32, 0x94, 0xdb, 0xe9, 0x70, 0x6b, 0x13, 0xaf, 0x22, 0xf1, 0xb7, 0xc4, 0xcd, 0x5a, 0x0, 0x1c, 0xfe, 0xc2, 0x51, 0xfb, 0xa1, 0x8e, 0x72, 0x2c, 0x6e, 0x1c, 0x4b, 0x11, 0x66, 0x91, 0x8b, 0x4f, 0x6f, 0x48, 0xa9, 0x8b, 0x64, 0xb3, 0xc0, 0x7f, 0xc8, 0x6a, 0x6b, 0x17, 0xa6, 0xd0, 0x48, 0xa, 0xb7, 0x9d, 0x4e, 0x64, 0x15, 0xb5, 0x20, 0xf1, 0xc4, 0x84, 0xd6, 0x75, 0xb1},
+               output224: []byte{0xd2, 0x74, 0x4a, 0x1b, 0xbb, 0x34, 0x71, 0x8f, 0xcb, 0xb6, 0x14, 0xc2, 0x1e, 0x1f, 0xcc, 0xd0, 0xff, 0x88, 0x61, 0x5c, 0xb8, 0x2a, 0xa0, 0x38, 0x3, 0xab, 0x94, 0x60},
+               output256: []byte{0x2, 0x84, 0x41, 0x8c, 0x10, 0x19, 0xf, 0x41, 0x30, 0x42, 0xe3, 0xec, 0xeb, 0x39, 0x54, 0x97, 0x9b, 0x94, 0xaf, 0xbf, 0x2e, 0x54, 0x5f, 0xc7, 0xf8, 0xa3, 0xc7, 0xdb, 0x2c, 0x23, 0x59, 0x16},
+               output384: []byte{0x35, 0xb, 0x4b, 0x27, 0x68, 0x2, 0xe, 0xaa, 0x95, 0x45, 0x2b, 0x90, 0x41, 0x44, 0x39, 0xa3, 0x8b, 0xe0, 0x36, 0x86, 0x13, 0x1d, 0x45, 0x61, 0x2c, 0x1b, 0x85, 0xfe, 0x6, 0xfd, 0x91, 0x96, 0xf2, 0x7d, 0x22, 0x1f, 0x4f, 0xf8, 0x32, 0x51, 0xaa, 0x8e, 0x69, 0xae, 0xf7, 0x2f, 0x90, 0x4d},
+               output512: []byte{0x36, 0xd4, 0x72, 0xa8, 0xae, 0x13, 0xd1, 0xe7, 0xe, 0x1f, 0xd2, 0x75, 0x11, 0x7f, 0xfe, 0x34, 0x6, 0x3b, 0xef, 0xcc, 0xf6, 0x70, 0x6f, 0xab, 0x8, 0x16, 0xe1, 0xb8, 0x1f, 0x7f, 0xe7, 0xf2, 0xdd, 0xb2, 0xa1, 0x22, 0xf1, 0xf5, 0x2c, 0x99, 0x50, 0x64, 0x46, 0x59, 0x43, 0xf, 0x81, 0xbc, 0xed, 0xad, 0x5d, 0x83, 0x3d, 0xf4, 0x81, 0x4c, 0xf6, 0xa, 0xe6, 0xc5, 0x42, 0xcc, 0x44, 0x78}},
+       testcase{
+               msg:       []byte{0xa5, 0xaa, 0xd0, 0xe4, 0x64, 0x6a, 0x32, 0xc8, 0x5c, 0xfc, 0xac, 0x73, 0xf0, 0x2f, 0xc5, 0x30, 0xf, 0x19, 0x82, 0xfa, 0xbb, 0x2f, 0x21, 0x79, 0xe2, 0x83, 0x3, 0xe4, 0x47, 0x85, 0x40, 0x94, 0xcd, 0xfc, 0x85, 0x43, 0x10, 0xe5, 0xc0, 0xf6, 0x9, 0x93, 0xce, 0xff, 0x54, 0xd8, 0x4d, 0x6b, 0x46, 0x32, 0x3d, 0x93, 0xa, 0xdb, 0x7, 0xc1, 0x75, 0x99, 0xb3, 0x5b, 0x50, 0x5f, 0x9, 0xe7, 0x84, 0xbc, 0xa5, 0x98, 0x5e, 0x1, 0x72, 0x25, 0x77, 0x97, 0xfb, 0x53, 0x64, 0x9e, 0x2e, 0x97, 0x23, 0xef, 0xd1, 0x68, 0x65, 0xc3, 0x1b, 0x5c, 0x3d, 0x51, 0x13, 0xb5, 0x8b, 0xb0, 0xbf, 0xc8, 0x92, 0xf, 0xab, 0xdd, 0xa0, 0x86, 0xd7, 0x53, 0x7e, 0x66, 0xd7, 0x9, 0xd0, 0x50, 0xbd, 0x14, 0xd0, 0xc9, 0x60, 0x87, 0x3f, 0x15, 0x6f, 0xad, 0x5b, 0x3d, 0x38, 0x40, 0xcd, 0xfc, 0xdc, 0x9b, 0xe6, 0xaf, 0x51, 0x9d, 0xb2, 0x62, 0xa2, 0x7f, 0x40, 0x89, 0x6a, 0xb2, 0x5c, 0xc3, 0x9f, 0x96, 0x98, 0x4d, 0x65, 0x6, 0x11, 0xc0, 0xd5, 0xa3, 0x8, 0xd, 0x5b, 0x3a, 0x1b, 0xf1, 0x86, 0xab, 0xd4, 0x29, 0x56, 0x58, 0x8b, 0x3b, 0x58, 0xcd, 0x94, 0x89, 0x70, 0xd2, 0x98, 0x77, 0x60, 0x60},
+               output224: []byte{0xf6, 0x11, 0x5f, 0x63, 0x5d, 0x98, 0xb5, 0x72, 0xfd, 0x1b, 0xa8, 0x57, 0x63, 0xec, 0xcf, 0x8b, 0xf2, 0x73, 0xfb, 0xf7, 0xb9, 0x6f, 0xd, 0xb0, 0x12, 0xc, 0xa8, 0xad},
+               output256: []byte{0x8f, 0xeb, 0xff, 0x80, 0x17, 0x87, 0xf5, 0x80, 0x3e, 0x15, 0x1d, 0xca, 0x34, 0x34, 0xa5, 0xcd, 0x44, 0xad, 0xb4, 0x9f, 0x1c, 0x2f, 0xfd, 0x5d, 0xc, 0xd0, 0x77, 0xa9, 0x7, 0x5a, 0x49, 0x2d},
+               output384: []byte{0x4c, 0xd1, 0x36, 0x71, 0x12, 0xc4, 0xf, 0xb7, 0xe3, 0x91, 0x9d, 0xf2, 0x6, 0x97, 0xa4, 0xe1, 0xcd, 0xc5, 0x5f, 0xd0, 0xf0, 0x1b, 0xe3, 0x95, 0x3b, 0x19, 0x98, 0xb5, 0xfc, 0xb4, 0x73, 0xe7, 0x6e, 0x9e, 0x75, 0xd5, 0xd8, 0x2e, 0x29, 0x73, 0xb3, 0xdb, 0x89, 0x53, 0x85, 0x54, 0x93, 0x3b},
+               output512: []byte{0xe5, 0x4, 0xad, 0x7f, 0x33, 0xd6, 0x5b, 0x8d, 0x34, 0x87, 0xb2, 0x88, 0x5, 0xd4, 0x78, 0x77, 0x8c, 0x90, 0x1c, 0xa, 0xff, 0x5f, 0x88, 0x9a, 0xe9, 0x5e, 0x29, 0x19, 0xb4, 0xf4, 0x31, 0xa8, 0x1, 0x16, 0xa8, 0x99, 0x34, 0x69, 0xe8, 0x22, 0x89, 0x5f, 0x3c, 0x21, 0xa4, 0x1d, 0x67, 0xaf, 0xda, 0x93, 0xa5, 0xb2, 0x9b, 0x62, 0x50, 0xf7, 0x63, 0x35, 0xa7, 0x6f, 0xe8, 0x91, 0x92, 0x74}},
+       testcase{
+               msg:       []byte{0x6, 0xcb, 0xbe, 0x67, 0xe9, 0x4a, 0x97, 0x82, 0x3, 0xea, 0xd6, 0xc0, 0x57, 0xa1, 0xa5, 0xb0, 0x98, 0x47, 0x8b, 0x4b, 0x4c, 0xbe, 0xf5, 0xa9, 0x7e, 0x93, 0xc8, 0xe4, 0x2f, 0x55, 0x72, 0x71, 0x35, 0x75, 0xfc, 0x2a, 0x88, 0x45, 0x31, 0xd7, 0x62, 0x2f, 0x8f, 0x87, 0x93, 0x87, 0xa8, 0x59, 0xa8, 0xf, 0x10, 0xef, 0x2, 0x70, 0x8c, 0xd8, 0xf7, 0x41, 0x3a, 0xb3, 0x85, 0xaf, 0xc3, 0x57, 0x67, 0x8b, 0x95, 0x78, 0xc0, 0xeb, 0xf6, 0x41, 0xef, 0x7, 0x6a, 0x1a, 0x30, 0xf1, 0xf7, 0x53, 0x79, 0xe9, 0xdc, 0xb2, 0xa8, 0x85, 0xbd, 0xd2, 0x95, 0x90, 0x5e, 0xe8, 0xc, 0x1, 0x68, 0xa6, 0x2a, 0x95, 0x97, 0xd1, 0xc, 0xf1, 0x2d, 0xd2, 0xd8, 0xce, 0xe4, 0x66, 0x45, 0xc7, 0xe5, 0xa1, 0x41, 0xf6, 0xe0, 0xe2, 0x3a, 0xa4, 0x82, 0xab, 0xe5, 0x66, 0x1c, 0x16, 0xe6, 0x9e, 0xf1, 0xe2, 0x83, 0x71, 0xe2, 0xe2, 0x36, 0xc3, 0x59, 0xba, 0x4e, 0x92, 0xc2, 0x56, 0x26, 0xa7, 0xb7, 0xff, 0x13, 0xf6, 0xea, 0x4a, 0xe9, 0x6, 0xe1, 0xcf, 0xe1, 0x63, 0xe9, 0x17, 0x19, 0xb1, 0xf7, 0x50, 0xa9, 0x6c, 0xbd, 0xe5, 0xfb, 0xc9, 0x53, 0xd9, 0xe5, 0x76, 0xcd, 0x21, 0x6a, 0xfc, 0x90, 0x32, 0x3a},
+               output224: []byte{0x5e, 0xe7, 0x3a, 0x4f, 0x13, 0xa0, 0x8a, 0x2d, 0x9b, 0x1e, 0x52, 0xdf, 0x88, 0x97, 0x2f, 0xfb, 0x9f, 0x3, 0xb8, 0x43, 0xa3, 0x87, 0xee, 0x52, 0xb0, 0xe, 0xdc, 0xee},
+               output256: []byte{0xea, 0x75, 0x11, 0xb9, 0x93, 0xb7, 0x86, 0xdf, 0x59, 0xa3, 0xb3, 0xe0, 0xb3, 0xcd, 0x87, 0x6c, 0xf, 0x5, 0x6d, 0x6c, 0xa4, 0x3c, 0xc8, 0x9c, 0x51, 0xc1, 0xb2, 0x1c, 0xcd, 0xc7, 0x9b, 0x42},
+               output384: []byte{0x87, 0x8a, 0xd5, 0x2f, 0xa0, 0x9f, 0xd4, 0xb6, 0x46, 0x50, 0x83, 0xc9, 0xc9, 0xe6, 0xa2, 0xdd, 0xb8, 0x13, 0x2, 0xe2, 0xdb, 0xc, 0xaa, 0x93, 0x4d, 0x3, 0xa1, 0x96, 0x97, 0x2a, 0xdd, 0xd4, 0xbb, 0x8f, 0xf8, 0x69, 0xbf, 0x0, 0x69, 0xe9, 0x70, 0xd6, 0xba, 0xeb, 0x5b, 0xba, 0x9b, 0x79},
+               output512: []byte{0x1d, 0xca, 0x53, 0xbe, 0xa, 0x34, 0x11, 0x44, 0x47, 0xd1, 0xc1, 0x44, 0x3b, 0x92, 0xb6, 0x9d, 0xfd, 0xed, 0x70, 0x59, 0x56, 0xea, 0xe6, 0xb, 0xba, 0xb3, 0x91, 0x78, 0xcc, 0xb1, 0x1f, 0x52, 0x6a, 0x30, 0x2a, 0xae, 0x83, 0x72, 0x6, 0x52, 0xef, 0x4c, 0x5d, 0xd4, 0x50, 0xa3, 0x64, 0x7d, 0xf7, 0xb7, 0x7c, 0x46, 0x64, 0x71, 0x7d, 0x93, 0x5b, 0x4f, 0x5b, 0x20, 0xf2, 0x6, 0xfe, 0xfe}},
+       testcase{
+               msg:       []byte{0xf1, 0xc5, 0x28, 0xcf, 0x77, 0x39, 0x87, 0x47, 0x7, 0xd4, 0xd8, 0xad, 0x5b, 0x98, 0xf7, 0xc7, 0x71, 0x69, 0xde, 0xb, 0x57, 0x18, 0x8d, 0xf2, 0x33, 0xb2, 0xdc, 0x8a, 0x5b, 0x31, 0xed, 0xa5, 0xdb, 0x42, 0x91, 0xdd, 0x9f, 0x68, 0xe6, 0xba, 0xd3, 0x7b, 0x8d, 0x7f, 0x6c, 0x9c, 0x0, 0x44, 0xb3, 0xbf, 0x74, 0xbb, 0xc3, 0xd7, 0xd1, 0x79, 0x8e, 0x13, 0x87, 0x9, 0xb0, 0xd7, 0x5e, 0x7c, 0x59, 0x3d, 0x3c, 0xcc, 0xdc, 0x1b, 0x20, 0xc7, 0x17, 0x4b, 0x4e, 0x69, 0x2a, 0xdd, 0x82, 0xa, 0xce, 0x26, 0x2d, 0x45, 0xcc, 0xfa, 0xe2, 0x7, 0x7e, 0x87, 0x87, 0x96, 0x34, 0x71, 0x68, 0x6, 0xa, 0x16, 0x2e, 0xcc, 0xa8, 0xc3, 0x8c, 0x1a, 0x88, 0x35, 0xb, 0xd6, 0x3b, 0xb5, 0x39, 0x13, 0x4f, 0x70, 0xf, 0xd4, 0xad, 0xdd, 0x59, 0x59, 0xe2, 0x55, 0x33, 0x7d, 0xaa, 0x6, 0xbc, 0x86, 0x35, 0x8f, 0xab, 0xcb, 0xef, 0xdf, 0xb5, 0xbc, 0x88, 0x97, 0x83, 0xd8, 0x43, 0xc0, 0x8a, 0xad, 0xc6, 0xc4, 0xf6, 0xc3, 0x6f, 0x65, 0xf1, 0x56, 0xe8, 0x51, 0xc9, 0xa0, 0xf9, 0x17, 0xe4, 0xa3, 0x67, 0xb5, 0xad, 0x93, 0xd8, 0x74, 0x81, 0x2a, 0x1d, 0xe6, 0xa7, 0xb9, 0x3c, 0xd5, 0x3a, 0xd9, 0x72, 0x32},
+               output224: []byte{0x44, 0xbc, 0x64, 0x55, 0x9b, 0xdb, 0x91, 0xb, 0x70, 0x79, 0xe0, 0x26, 0x1f, 0xf8, 0xb4, 0x9d, 0xba, 0x14, 0x1b, 0x32, 0xec, 0xbc, 0xb7, 0xb, 0x3a, 0xbd, 0xfb, 0xf9},
+               output256: []byte{0xba, 0xae, 0xcb, 0x6e, 0x9d, 0xb5, 0x79, 0x71, 0xd5, 0xc7, 0xf, 0x58, 0x19, 0xff, 0x89, 0xc5, 0x9, 0x32, 0x54, 0xde, 0x19, 0xef, 0x60, 0x59, 0xc4, 0x3c, 0xc0, 0xaf, 0xda, 0x7c, 0x5d, 0x34},
+               output384: []byte{0x60, 0x7, 0x1a, 0x7e, 0x2e, 0xcf, 0xaf, 0x3b, 0x5b, 0x2e, 0x84, 0xa6, 0x77, 0xfb, 0x98, 0xe4, 0x4b, 0xd3, 0x72, 0x5a, 0xdd, 0xee, 0xc5, 0xc3, 0x7e, 0xc6, 0x20, 0x52, 0xd5, 0x7a, 0xf7, 0xb6, 0x87, 0xa0, 0x63, 0xfd, 0x39, 0xc8, 0xf6, 0xe8, 0x6f, 0x79, 0xd9, 0x7f, 0x24, 0x6c, 0x75, 0x7b},
+               output512: []byte{0xcb, 0x1b, 0x3, 0xb1, 0x80, 0xe0, 0x40, 0x21, 0xe0, 0x9, 0x90, 0x50, 0xeb, 0x6b, 0x7e, 0xb9, 0x9, 0x2c, 0x5b, 0xd5, 0xc4, 0x45, 0xe9, 0xd3, 0x1e, 0xe3, 0x9c, 0x72, 0x4f, 0x3, 0x8e, 0x9f, 0x61, 0x9a, 0x96, 0xd3, 0xa2, 0x81, 0x2c, 0xa7, 0xf2, 0x8, 0xfe, 0xb2, 0xd0, 0x74, 0xc3, 0xf8, 0x17, 0x26, 0x2f, 0x75, 0x4, 0x70, 0x56, 0x23, 0xe6, 0x35, 0xb9, 0xf2, 0x73, 0xe3, 0x7a, 0x59}},
+       testcase{
+               msg:       []byte{0x9d, 0x9f, 0x3a, 0x7e, 0xcd, 0x51, 0xb4, 0x1f, 0x65, 0x72, 0xfd, 0xd, 0x8, 0x81, 0xe3, 0x3, 0x90, 0xdf, 0xb7, 0x80, 0x99, 0x1d, 0xae, 0x7d, 0xb3, 0xb4, 0x76, 0x19, 0x13, 0x47, 0x18, 0xe6, 0xf9, 0x87, 0x81, 0xe, 0x54, 0x26, 0x19, 0xdf, 0xaa, 0x7b, 0x50, 0x5c, 0x76, 0xb7, 0x35, 0xc, 0x64, 0x32, 0xd8, 0xbf, 0x1c, 0xfe, 0xbd, 0xf1, 0x6, 0x9b, 0x90, 0xa3, 0x5f, 0xd, 0x4, 0xcb, 0xdf, 0x13, 0xb, 0xd, 0xfc, 0x78, 0x75, 0xf4, 0xa4, 0xe6, 0x2c, 0xdb, 0x8e, 0x52, 0x5a, 0xad, 0xd7, 0xce, 0x84, 0x25, 0x20, 0xa4, 0x82, 0xac, 0x18, 0xf0, 0x94, 0x42, 0xd7, 0x83, 0x5, 0xfe, 0x85, 0xa7, 0x4e, 0x39, 0xe7, 0x60, 0xa4, 0x83, 0x74, 0x82, 0xed, 0x2f, 0x43, 0x7d, 0xd1, 0x3b, 0x2e, 0xc1, 0x4, 0x2a, 0xfc, 0xf9, 0xde, 0xcd, 0xc3, 0xe8, 0x77, 0xe5, 0xf, 0xf4, 0x10, 0x6a, 0xd1, 0xa, 0x52, 0x52, 0x30, 0xd1, 0x19, 0x20, 0x32, 0x4a, 0x81, 0x9, 0x4d, 0xa3, 0x1d, 0xea, 0xb6, 0x47, 0x6a, 0xa4, 0x2f, 0x20, 0xc8, 0x48, 0x43, 0xcf, 0xc1, 0xc5, 0x85, 0x45, 0xee, 0x80, 0x35, 0x2b, 0xdd, 0x37, 0x40, 0xdd, 0x6a, 0x16, 0x79, 0x2a, 0xe2, 0xd8, 0x6f, 0x11, 0x64, 0x1b, 0xb7, 0x17, 0xc2},
+               output224: []byte{0xde, 0x82, 0xad, 0xde, 0x82, 0x3c, 0x31, 0x2f, 0x83, 0xb3, 0xd4, 0xc0, 0xbd, 0x35, 0xaa, 0x3, 0x95, 0xab, 0x74, 0x7a, 0xbb, 0xc2, 0x2a, 0x70, 0x97, 0x3e, 0x2a, 0x6c},
+               output256: []byte{0x56, 0xdb, 0x69, 0x43, 0xb, 0x8c, 0xa8, 0x52, 0x22, 0x1d, 0x55, 0xd7, 0xbb, 0xff, 0x47, 0x7d, 0xc8, 0x3f, 0x7c, 0xb4, 0x4a, 0xb4, 0x4d, 0xdd, 0x64, 0xc3, 0x1a, 0x52, 0xc4, 0x83, 0xdb, 0x4f},
+               output384: []byte{0xeb, 0x92, 0x90, 0x23, 0xd6, 0x6a, 0xc2, 0xf, 0x11, 0xbf, 0x68, 0xeb, 0xc4, 0x30, 0x69, 0xd2, 0x7f, 0x35, 0x7, 0x7a, 0x68, 0xd2, 0x1f, 0xab, 0x30, 0x85, 0x4f, 0xfe, 0x53, 0xcb, 0xd7, 0x84, 0xd7, 0xb2, 0x57, 0x76, 0xd9, 0xf2, 0x66, 0xf1, 0x6, 0x43, 0x37, 0x51, 0xe6, 0xc3, 0x8a, 0x68},
+               output512: []byte{0xf0, 0x48, 0x2f, 0x9, 0x8b, 0x93, 0x62, 0x4b, 0xcd, 0xe1, 0xaa, 0xb5, 0x80, 0x97, 0x19, 0x86, 0x49, 0xa8, 0xdc, 0x84, 0x42, 0x18, 0x26, 0xd1, 0xc1, 0x1, 0x1a, 0xd4, 0x1b, 0x94, 0x83, 0x84, 0xc8, 0xed, 0x5a, 0x97, 0xc6, 0x4c, 0x13, 0x4b, 0x38, 0xa0, 0x7, 0x58, 0x12, 0xa3, 0x5f, 0x9c, 0xe3, 0xcb, 0x20, 0x9, 0x72, 0xc2, 0xec, 0xdf, 0xc4, 0x8, 0x71, 0x41, 0x39, 0xb9, 0xbf, 0xf0}},
+       testcase{
+               msg:       []byte{0x51, 0x79, 0x88, 0x87, 0x24, 0x81, 0x9f, 0xba, 0xd3, 0xaf, 0xa9, 0x27, 0xd3, 0x57, 0x77, 0x96, 0x66, 0xe, 0x6a, 0x81, 0xc5, 0x2d, 0x98, 0xe9, 0x30, 0x32, 0x61, 0xd5, 0xa4, 0xa8, 0x32, 0x32, 0xf6, 0xf7, 0x58, 0x93, 0x4d, 0x50, 0xaa, 0x83, 0xff, 0x9e, 0x20, 0xa5, 0x92, 0x6d, 0xfe, 0xba, 0xac, 0x49, 0x52, 0x9d, 0x0, 0x6e, 0xb9, 0x23, 0xc5, 0xae, 0x50, 0x48, 0xed, 0x54, 0x4e, 0xc4, 0x71, 0xed, 0x71, 0x91, 0xed, 0xf4, 0x63, 0x63, 0x38, 0x38, 0x24, 0xf9, 0x15, 0x76, 0x9b, 0x3e, 0x68, 0x80, 0x94, 0xc6, 0x82, 0xb0, 0x21, 0x51, 0xe5, 0xee, 0x1, 0xe5, 0x10, 0xb4, 0x31, 0xc8, 0x86, 0x5a, 0xff, 0x8b, 0x6b, 0x6f, 0x2f, 0x59, 0xcb, 0x6d, 0x12, 0x9d, 0xa7, 0x9e, 0x97, 0xc6, 0xd2, 0xb8, 0xfa, 0x6c, 0x6d, 0xa3, 0xf6, 0x3, 0x19, 0x9d, 0x2d, 0x1b, 0xca, 0xb5, 0x47, 0x68, 0x2a, 0x81, 0xcd, 0x6c, 0xf6, 0x5f, 0x65, 0x51, 0x12, 0x13, 0x91, 0xd7, 0x8b, 0xcc, 0x23, 0xb5, 0xbd, 0xe, 0x92, 0x2e, 0xc6, 0xd8, 0xbf, 0x97, 0xc9, 0x52, 0xe8, 0x4d, 0xd2, 0x8a, 0xef, 0x90, 0x9a, 0xba, 0x31, 0xed, 0xb9, 0x3, 0xb2, 0x8f, 0xbf, 0xc3, 0x3b, 0x77, 0x3, 0xcd, 0x99, 0x62, 0x15, 0xa1, 0x12, 0x38},
+               output224: []byte{0xb1, 0xba, 0x91, 0xc, 0x9f, 0x5e, 0x12, 0x66, 0x7, 0xff, 0x25, 0x31, 0xaf, 0xfe, 0xcb, 0xa7, 0x91, 0x26, 0x1e, 0x35, 0x4e, 0x2c, 0x1a, 0x81, 0xfd, 0xa7, 0xa7, 0x56},
+               output256: []byte{0xf8, 0x53, 0x8f, 0x59, 0x7f, 0x44, 0x63, 0xca, 0xd7, 0xa9, 0x19, 0x5, 0x74, 0x4b, 0x87, 0x15, 0x6d, 0xb3, 0x3c, 0x65, 0xba, 0x87, 0xb9, 0x12, 0x42, 0x7f, 0xec, 0x36, 0x69, 0xf4, 0x25, 0xd4},
+               output384: []byte{0x6a, 0x51, 0x97, 0x5c, 0x9f, 0xfe, 0xe8, 0xb9, 0x41, 0x35, 0xa3, 0xbd, 0xa9, 0x54, 0xdf, 0xe1, 0x4e, 0x62, 0x67, 0xdb, 0xc9, 0x25, 0x3f, 0xb, 0xb0, 0x45, 0x15, 0xa6, 0xb7, 0x74, 0x5a, 0xec, 0x61, 0x1b, 0x7b, 0x66, 0xae, 0x57, 0xd3, 0xfd, 0x37, 0x70, 0xae, 0xd4, 0xf4, 0x12, 0xec, 0x84},
+               output512: []byte{0xa3, 0x18, 0x84, 0x26, 0xce, 0xa0, 0xc1, 0x8c, 0xb6, 0x38, 0xbc, 0xc4, 0x5c, 0x43, 0x37, 0xc4, 0xb, 0xe4, 0x1f, 0x6e, 0x3, 0xcd, 0x2d, 0x7c, 0x4f, 0xee, 0x26, 0x2, 0x5c, 0x5c, 0xa2, 0x81, 0xcf, 0xbb, 0x3a, 0xd1, 0x55, 0x4d, 0x45, 0xed, 0xc2, 0xeb, 0x3, 0xe2, 0xeb, 0xe3, 0xde, 0x2, 0xf5, 0x7d, 0x36, 0xd5, 0xb6, 0xa8, 0x8a, 0x3c, 0x61, 0xa6, 0xaa, 0xed, 0xe6, 0x21, 0x80, 0xd0}},
+       testcase{
+               msg:       []byte{0x57, 0x6e, 0xf3, 0x52, 0xd, 0x30, 0xb7, 0xa4, 0x89, 0x9b, 0x8c, 0xd, 0x5e, 0x35, 0x9e, 0x45, 0xc5, 0x18, 0x9a, 0xdd, 0x10, 0xe, 0x43, 0xbe, 0x42, 0x9a, 0x2, 0xfb, 0x3d, 0xe5, 0xff, 0x4f, 0x8f, 0xd0, 0xe7, 0x9d, 0x96, 0x63, 0xac, 0xca, 0x72, 0xcd, 0x29, 0xc9, 0x45, 0x82, 0xb1, 0x92, 0x92, 0xa5, 0x57, 0xc5, 0xb1, 0x31, 0x52, 0x97, 0xd1, 0x68, 0xfb, 0xb5, 0x4e, 0x9e, 0x2e, 0xcd, 0x13, 0x80, 0x9c, 0x2b, 0x5f, 0xce, 0x99, 0x8e, 0xdc, 0x65, 0x70, 0x54, 0x5e, 0x14, 0x99, 0xdb, 0xe7, 0xfb, 0x74, 0xd4, 0x7c, 0xd7, 0xf3, 0x58, 0x23, 0xb2, 0x12, 0xb0, 0x5b, 0xf3, 0xf5, 0xa7, 0x9c, 0xaa, 0x34, 0x22, 0x4f, 0xdd, 0x67, 0xd, 0x33, 0x5f, 0xcb, 0x10, 0x6f, 0x5d, 0x92, 0xc3, 0x94, 0x6f, 0x44, 0xd3, 0xaf, 0xcb, 0xae, 0x2e, 0x41, 0xac, 0x55, 0x4d, 0x8e, 0x67, 0x59, 0xf3, 0x32, 0xb7, 0x6b, 0xe8, 0x9a, 0x3, 0x24, 0xaa, 0x12, 0xc5, 0x48, 0x2d, 0x1e, 0xa3, 0xee, 0x89, 0xde, 0xd4, 0x93, 0x6f, 0x3e, 0x3c, 0x8, 0x4, 0x36, 0xf5, 0x39, 0xfa, 0x13, 0x7e, 0x74, 0xc6, 0xd3, 0x38, 0x9b, 0xdf, 0x5a, 0x45, 0x7, 0x4c, 0x47, 0xbc, 0x7b, 0x20, 0xb0, 0x94, 0x84, 0x7, 0xa6, 0x6d, 0x85, 0x5e, 0x2f},
+               output224: []byte{0x3e, 0xf8, 0xd4, 0xa6, 0xbb, 0x8e, 0x17, 0x23, 0x74, 0xe8, 0x6, 0xe8, 0xd6, 0x5d, 0x5f, 0x81, 0xb3, 0xfd, 0xb3, 0x62, 0x99, 0xde, 0x1c, 0xc, 0xcc, 0x26, 0xdc, 0x65},
+               output256: []byte{0x44, 0x7e, 0xda, 0x92, 0x3c, 0xfe, 0x11, 0x12, 0xa6, 0xf1, 0xa3, 0xe4, 0xc7, 0x35, 0xbf, 0x8e, 0xe9, 0xe4, 0xf2, 0xae, 0xe7, 0xde, 0x66, 0x6a, 0x47, 0x2f, 0xf8, 0xcf, 0xf, 0xc6, 0x53, 0x15},
+               output384: []byte{0xd2, 0xdc, 0x49, 0xc0, 0x45, 0x53, 0xf0, 0x9a, 0x8c, 0x3d, 0x7d, 0xb5, 0x1d, 0xe8, 0x90, 0xa7, 0x1d, 0xbc, 0x10, 0xfe, 0x4e, 0x91, 0xc, 0x68, 0xba, 0x5c, 0xa5, 0xdd, 0xb3, 0x13, 0xd0, 0xa6, 0x83, 0x75, 0x27, 0x5c, 0x29, 0x1b, 0x4d, 0xeb, 0x41, 0xf4, 0x5e, 0x35, 0xa5, 0x58, 0xbf, 0x77},
+               output512: []byte{0xb, 0x14, 0x69, 0x3e, 0x63, 0x20, 0x66, 0x8d, 0x64, 0xeb, 0xb3, 0xbf, 0x6e, 0xeb, 0x81, 0xaa, 0xfc, 0xdb, 0x73, 0x20, 0xec, 0xde, 0x80, 0xa2, 0x45, 0x78, 0x6d, 0x1b, 0xa, 0x80, 0x8a, 0x15, 0xc7, 0x17, 0xdc, 0x8e, 0x88, 0x13, 0xbf, 0x64, 0xbf, 0x4a, 0xa5, 0x7c, 0x29, 0xc3, 0x3e, 0x91, 0x3d, 0x6c, 0xe1, 0x87, 0x9e, 0x52, 0xe1, 0x91, 0x9f, 0xb8, 0x3e, 0x4a, 0x20, 0x8e, 0xda, 0xa4}},
+       testcase{
+               msg:       []byte{0xd, 0xf2, 0x15, 0x2f, 0xa4, 0xf4, 0x35, 0x7c, 0x87, 0x41, 0x52, 0x9d, 0xd7, 0x7e, 0x78, 0x39, 0x25, 0xd3, 0xd7, 0x6e, 0x95, 0xba, 0xfa, 0x2b, 0x54, 0x2a, 0x2c, 0x33, 0xf3, 0xd1, 0xd1, 0x17, 0xd1, 0x59, 0xcf, 0x47, 0x3f, 0x82, 0x31, 0x3, 0x56, 0xfe, 0xe4, 0xc9, 0xa, 0x9e, 0x50, 0x5e, 0x70, 0xf8, 0xf2, 0x48, 0x59, 0x65, 0x63, 0x68, 0xba, 0x9, 0x38, 0x1f, 0xa2, 0x45, 0xeb, 0x6c, 0x3d, 0x76, 0x3f, 0x30, 0x93, 0xf0, 0xc8, 0x9b, 0x97, 0x2e, 0x66, 0xb5, 0x3d, 0x59, 0x40, 0x6d, 0x9f, 0x1, 0xae, 0xa0, 0x7f, 0x8b, 0x3b, 0x61, 0x5c, 0xac, 0x4e, 0xe4, 0xd0, 0x5f, 0x54, 0x2e, 0x7d, 0xd, 0xab, 0x45, 0xd6, 0x7c, 0xcc, 0xcd, 0x3a, 0x60, 0x6c, 0xcb, 0xeb, 0x31, 0xea, 0x1f, 0xa7, 0x0, 0x5b, 0xa0, 0x71, 0x76, 0xe6, 0xd, 0xab, 0x7d, 0x78, 0xf6, 0x81, 0xe, 0xf0, 0x86, 0xf4, 0x2f, 0x8, 0xe5, 0x95, 0xf0, 0xec, 0x21, 0x73, 0x72, 0xb9, 0x89, 0x70, 0xcc, 0x63, 0x21, 0x57, 0x6d, 0x92, 0xce, 0x38, 0xf7, 0xc3, 0x97, 0xa4, 0x3, 0xba, 0xda, 0x15, 0x48, 0xd2, 0x5, 0xc3, 0x43, 0xac, 0x9, 0xde, 0xca, 0x86, 0x32, 0x53, 0x73, 0xc3, 0xb7, 0x6d, 0x9f, 0x32, 0x2, 0x8f, 0xea, 0x8e, 0xb3, 0x25, 0x15},
+               output224: []byte{0x1c, 0x89, 0xd6, 0x46, 0xb, 0x3f, 0x13, 0x58, 0x4b, 0xf8, 0x31, 0x9e, 0xe5, 0x38, 0xf2, 0x4c, 0x85, 0xc, 0xa7, 0x71, 0xa5, 0x1e, 0xcc, 0x54, 0x76, 0x52, 0xba, 0xe3},
+               output256: []byte{0x74, 0xd9, 0x4c, 0x13, 0xaf, 0xea, 0x4d, 0xdd, 0x7, 0xa6, 0x37, 0xb6, 0x8b, 0x6f, 0xe0, 0x95, 0x1, 0x7c, 0x9, 0x2b, 0x3c, 0xdc, 0xcd, 0xc4, 0x98, 0xe2, 0x60, 0x35, 0xd8, 0x6d, 0x92, 0x1e},
+               output384: []byte{0xaa, 0xb5, 0x74, 0x7d, 0x7d, 0xcc, 0x77, 0xba, 0xcd, 0xe8, 0x1a, 0x58, 0xc3, 0x77, 0x64, 0xf8, 0xf4, 0x1e, 0x8, 0xf2, 0x41, 0x3b, 0x40, 0xd4, 0xe6, 0xc7, 0x92, 0xce, 0xfe, 0x52, 0xe4, 0xe2, 0xa4, 0x6, 0x33, 0x87, 0x52, 0xd7, 0xad, 0x12, 0x69, 0xe7, 0xd5, 0x28, 0x4f, 0xcb, 0x74, 0x0},
+               output512: []byte{0xa9, 0xab, 0xc3, 0xf5, 0x54, 0xc1, 0xe7, 0x17, 0x93, 0x5d, 0x28, 0xc2, 0x8e, 0x7c, 0x26, 0xaa, 0x9d, 0xc5, 0xbd, 0x6d, 0x7b, 0x2, 0xed, 0x7d, 0xc6, 0xaf, 0xe2, 0x1a, 0xe, 0xa0, 0x27, 0xa8, 0x80, 0x1a, 0xe0, 0x76, 0xf2, 0x87, 0x2d, 0x8, 0x63, 0x5e, 0xe8, 0x14, 0x20, 0x71, 0x18, 0x62, 0xed, 0xc4, 0xe4, 0x48, 0xc8, 0x55, 0x13, 0x28, 0x94, 0x38, 0xb3, 0xc8, 0xbe, 0x45, 0x6b, 0x5b}},
+       testcase{
+               msg:       []byte{0x3e, 0x15, 0x35, 0xd, 0x87, 0xd6, 0xeb, 0xb5, 0xc8, 0xad, 0x99, 0xd4, 0x25, 0x15, 0xcf, 0xe1, 0x79, 0x80, 0x93, 0x3c, 0x7a, 0x8f, 0x6b, 0x8b, 0xbb, 0xf0, 0xa6, 0x37, 0x28, 0xce, 0xfa, 0xad, 0x20, 0x52, 0x62, 0x3c, 0xb, 0xd5, 0x93, 0x18, 0x39, 0x11, 0x2a, 0x48, 0x63, 0x3f, 0xb3, 0xc2, 0x0, 0x4e, 0x7, 0x49, 0xc8, 0x7a, 0x41, 0xb2, 0x6a, 0x8b, 0x48, 0x94, 0x55, 0x39, 0xd1, 0xff, 0x41, 0xa4, 0xb2, 0x69, 0x46, 0x2f, 0xd1, 0x99, 0xbf, 0xec, 0xd4, 0x53, 0x74, 0x75, 0x6f, 0x55, 0xa9, 0x11, 0x6e, 0x92, 0x9, 0x3a, 0xc9, 0x94, 0x51, 0xae, 0xfb, 0x2a, 0xf9, 0xfd, 0x32, 0xd6, 0xd7, 0xf5, 0xfb, 0xc7, 0xf7, 0xa5, 0x40, 0xd5, 0x9, 0x7c, 0x9, 0x6e, 0xbc, 0x3b, 0x3a, 0x72, 0x15, 0x41, 0xde, 0x7, 0x3a, 0x1c, 0xc0, 0x2f, 0x7f, 0xb0, 0xfb, 0x1b, 0x93, 0x27, 0xfb, 0xb, 0x12, 0x18, 0xca, 0x49, 0xc9, 0x48, 0x7a, 0xb5, 0x39, 0x66, 0x22, 0xa1, 0x3a, 0xe5, 0x46, 0xc9, 0x7a, 0xbd, 0xef, 0x6b, 0x56, 0x38, 0xd, 0xda, 0x70, 0x12, 0xa8, 0x38, 0x40, 0x91, 0xb6, 0x65, 0x6d, 0xa, 0xb2, 0x72, 0xd3, 0x63, 0xce, 0xa7, 0x81, 0x63, 0xff, 0x76, 0x5c, 0xdd, 0x13, 0xab, 0x17, 0x38, 0xb9, 0x40, 0xd1, 0x6c, 0xae},
+               output224: []byte{0x99, 0x98, 0x17, 0x66, 0xcf, 0xe3, 0xb1, 0x88, 0x8f, 0x2a, 0x0, 0x8e, 0xfa, 0x10, 0x88, 0x1, 0x6c, 0xb2, 0x99, 0x93, 0x56, 0x7f, 0x9b, 0xb7, 0x4b, 0x5c, 0x4d, 0x3c},
+               output256: []byte{0xcc, 0x11, 0x19, 0x6c, 0x9, 0x5b, 0xff, 0xa0, 0x90, 0xa0, 0x5b, 0xa0, 0xbc, 0x25, 0x5d, 0x38, 0xbd, 0xa7, 0x21, 0x8d, 0x93, 0x11, 0x14, 0x3f, 0x4f, 0x20, 0xb, 0x18, 0x52, 0xd1, 0xbb, 0xd},
+               output384: []byte{0x72, 0xb5, 0x26, 0xd7, 0x4c, 0xf9, 0x52, 0x1e, 0x0, 0xd9, 0xd6, 0xbc, 0xdf, 0xc1, 0xfb, 0x17, 0x60, 0xc6, 0xac, 0xdf, 0x2d, 0xd7, 0x51, 0x71, 0x30, 0x5d, 0xb4, 0x5d, 0x38, 0x9, 0x8f, 0xf2, 0x3c, 0x5b, 0x8e, 0xd3, 0xc2, 0x1d, 0xa7, 0x3f, 0xfb, 0x8d, 0xf7, 0x21, 0x7c, 0xe4, 0x6d, 0xbb},
+               output512: []byte{0x4, 0xdd, 0x83, 0xd2, 0xf, 0x58, 0xe8, 0x54, 0xd8, 0x57, 0xf2, 0x47, 0x20, 0xc5, 0xa, 0x4b, 0x5f, 0x83, 0xdb, 0xc8, 0xca, 0xbd, 0x46, 0xd, 0x37, 0x94, 0x17, 0xcd, 0x48, 0x13, 0x77, 0x2a, 0xa8, 0x55, 0x91, 0xb9, 0x4, 0x62, 0xf3, 0x4d, 0xb3, 0xfa, 0xa4, 0xdc, 0xae, 0x33, 0x5f, 0xb1, 0x25, 0x2b, 0xf4, 0x11, 0x62, 0xe2, 0x49, 0x75, 0xa0, 0xdb, 0xd3, 0x8, 0xc4, 0x1a, 0x4a, 0x6b}},
+       testcase{
+               msg:       []byte{0xc3, 0x8d, 0x6b, 0xb, 0x75, 0x7c, 0xb5, 0x52, 0xbe, 0x40, 0x94, 0xe, 0xce, 0x0, 0x9, 0xef, 0x3b, 0xb, 0x59, 0x30, 0x7c, 0x14, 0x51, 0x68, 0x6f, 0x1a, 0x22, 0x70, 0x29, 0x22, 0x80, 0xd, 0x58, 0xbc, 0xe7, 0xa6, 0x36, 0xc1, 0x72, 0x7e, 0xe5, 0x47, 0xc0, 0x1b, 0x21, 0x47, 0x79, 0xe8, 0x98, 0xfc, 0xe, 0x56, 0xf, 0x8a, 0xe7, 0xf6, 0x1b, 0xef, 0x4d, 0x75, 0xea, 0xa6, 0x96, 0xb9, 0x21, 0xfd, 0x6b, 0x73, 0x5d, 0x17, 0x15, 0x35, 0xe9, 0xed, 0xd2, 0x67, 0xc1, 0x92, 0xb9, 0x98, 0x80, 0xc8, 0x79, 0x97, 0x71, 0x10, 0x2, 0x0, 0x90, 0x95, 0xd8, 0xa7, 0xa4, 0x37, 0xe2, 0x58, 0x10, 0x4a, 0x41, 0xa5, 0x5, 0xe5, 0xef, 0x71, 0xe5, 0x61, 0x3d, 0xdd, 0x20, 0x8, 0x19, 0x5f, 0xc, 0x57, 0x4e, 0x6b, 0xa3, 0xfe, 0x40, 0x9, 0x9c, 0xfa, 0x11, 0x6e, 0x5f, 0x1a, 0x2f, 0xa8, 0xa6, 0xda, 0x4, 0xba, 0xdc, 0xb4, 0xe2, 0xd5, 0xd0, 0xde, 0x31, 0xfd, 0xc4, 0x80, 0x8, 0x91, 0xc4, 0x57, 0x81, 0xa0, 0xaa, 0xc7, 0xc9, 0x7, 0xb5, 0x6d, 0x63, 0x1f, 0xca, 0x5c, 0xe8, 0xb2, 0xcd, 0xe6, 0x20, 0xd1, 0x1d, 0x17, 0x77, 0xed, 0x9f, 0xa6, 0x3, 0x54, 0x1d, 0xe7, 0x94, 0xdd, 0xc5, 0x75, 0x8f, 0xcd, 0x5f, 0xad, 0x78, 0xc0},
+               output224: []byte{0x2, 0x15, 0xe9, 0x1e, 0xf9, 0x92, 0xdc, 0xc7, 0xe8, 0x2d, 0x16, 0xa2, 0xc9, 0xb2, 0x79, 0x21, 0xc1, 0x31, 0xc, 0x18, 0x2f, 0x59, 0xdf, 0x8b, 0xed, 0x51, 0x51, 0xe8},
+               output256: []byte{0x8c, 0x8, 0x5b, 0x54, 0xc2, 0x13, 0x70, 0x43, 0x74, 0xdd, 0xd9, 0x20, 0xa4, 0x51, 0x68, 0x60, 0x8b, 0xe6, 0x5d, 0xfd, 0x3, 0x6a, 0x56, 0x26, 0x59, 0xf4, 0x71, 0x43, 0x60, 0x41, 0x44, 0xc2},
+               output384: []byte{0x80, 0xc, 0xfa, 0x48, 0xb4, 0x64, 0x7f, 0x77, 0x83, 0xbc, 0xd4, 0x1b, 0x2c, 0xf, 0x7f, 0x7d, 0x4d, 0xf, 0xaa, 0x72, 0x48, 0x1a, 0x2a, 0x42, 0xc4, 0xe9, 0xc4, 0x3c, 0x9f, 0x62, 0xe2, 0x7a, 0xcb, 0x4d, 0xdb, 0x73, 0xe3, 0x18, 0x6, 0x1d, 0x39, 0x60, 0x59, 0xaa, 0xde, 0x41, 0x45, 0xe2},
+               output512: []byte{0xce, 0x76, 0xb2, 0x5c, 0x92, 0x8c, 0xb7, 0x5c, 0x9, 0xc0, 0x67, 0x4e, 0x8f, 0xcd, 0x22, 0x8, 0x96, 0x54, 0x18, 0x2c, 0xd3, 0xd8, 0x4b, 0x85, 0xcc, 0x44, 0xb1, 0x86, 0xa8, 0xb1, 0xa7, 0xcc, 0x1b, 0xb6, 0x6f, 0x38, 0x9d, 0xa6, 0xd7, 0x44, 0xa2, 0x4a, 0x7b, 0x2, 0xbf, 0x5c, 0x85, 0x54, 0x2d, 0x1b, 0xa8, 0xef, 0xd, 0xb4, 0xa8, 0x6d, 0x2f, 0xc3, 0x94, 0x47, 0x1b, 0x39, 0x65, 0x19}},
+       testcase{
+               msg:       []byte{0x8d, 0x2d, 0xe3, 0xf0, 0xb3, 0x7a, 0x63, 0x85, 0xc9, 0x7, 0x39, 0x80, 0x5b, 0x17, 0x0, 0x57, 0xf0, 0x91, 0xcd, 0xc, 0x7a, 0xb, 0xc9, 0x51, 0x54, 0xf, 0x26, 0xa5, 0xa7, 0x5b, 0x3e, 0x69, 0x46, 0x31, 0xbb, 0x64, 0xc7, 0x63, 0x5e, 0xed, 0x31, 0x6f, 0x51, 0x31, 0x8e, 0x9d, 0x8d, 0xe1, 0x3c, 0x70, 0xa2, 0xab, 0xa0, 0x4a, 0x14, 0x83, 0x68, 0x55, 0xf3, 0x5e, 0x48, 0x5, 0x28, 0xb7, 0x76, 0xd0, 0xa1, 0xe8, 0xa2, 0x3b, 0x54, 0x7c, 0x8b, 0x8d, 0x6a, 0xd, 0x9, 0xb2, 0x41, 0xd3, 0xbe, 0x93, 0x77, 0x16, 0xc, 0xca, 0x4e, 0x67, 0x93, 0xd0, 0xa, 0x51, 0x5d, 0xc2, 0x99, 0x2c, 0xb7, 0xfc, 0x74, 0x1d, 0xac, 0xa1, 0x71, 0x43, 0x1d, 0xa9, 0x9c, 0xce, 0x6f, 0x77, 0x89, 0xf1, 0x29, 0xe2, 0xac, 0x5c, 0xf6, 0x5b, 0x40, 0xd7, 0x3, 0x3, 0x5c, 0xd2, 0x18, 0x5b, 0xb9, 0x36, 0xc8, 0x20, 0x2, 0xda, 0xf8, 0xcb, 0xc2, 0x7a, 0x7a, 0x9e, 0x55, 0x4b, 0x6, 0x19, 0x66, 0x30, 0x44, 0x6a, 0x6f, 0xa, 0x14, 0xba, 0x15, 0x5e, 0xd2, 0x6d, 0x95, 0xbd, 0x62, 0x7b, 0x72, 0x5, 0xc0, 0x72, 0xd0, 0x2b, 0x60, 0xdb, 0xf, 0xd7, 0xe4, 0x9e, 0xa0, 0x58, 0xc2, 0xe0, 0xba, 0x20, 0x2d, 0xaf, 0xf0, 0xde, 0x91, 0xe8, 0x45, 0xcf, 0x79},
+               output224: []byte{0xe5, 0x2e, 0xa6, 0x71, 0x4a, 0x39, 0x78, 0x81, 0xd, 0xc1, 0x9e, 0x99, 0x9c, 0x32, 0x51, 0x6d, 0x4a, 0xcf, 0xc, 0xbc, 0xd6, 0x7e, 0x91, 0x7a, 0x4f, 0xeb, 0x56, 0xd0},
+               output256: []byte{0xd2, 0xe2, 0x33, 0x26, 0x4a, 0x37, 0x73, 0x49, 0x5f, 0xfd, 0x12, 0x15, 0x9e, 0xf7, 0xb6, 0x31, 0x66, 0xc, 0x1b, 0x3e, 0x53, 0xa3, 0xda, 0xf, 0x24, 0xae, 0x14, 0x46, 0x6f, 0x16, 0x77, 0x57},
+               output384: []byte{0xf7, 0x82, 0xff, 0xd, 0xe7, 0xd5, 0x44, 0x2d, 0x56, 0x2c, 0xc5, 0x0, 0x25, 0x6e, 0xe4, 0xb5, 0xa0, 0xe, 0x88, 0x5c, 0x8c, 0xd8, 0x60, 0x9, 0xc5, 0x3f, 0x33, 0x7a, 0xe0, 0x3, 0x85, 0x4d, 0xe4, 0xb8, 0x97, 0x94, 0x28, 0x1a, 0x64, 0x37, 0x5e, 0x3f, 0x69, 0x6a, 0x41, 0x5b, 0x95, 0xd2},
+               output512: []byte{0x2, 0xd1, 0x67, 0x19, 0x81, 0xc2, 0xe8, 0x5d, 0x4, 0x55, 0xee, 0x85, 0xf4, 0x1b, 0x8e, 0x9c, 0x32, 0xb1, 0xc8, 0x2, 0x21, 0xdd, 0x43, 0x2b, 0x8b, 0xcb, 0x5f, 0xce, 0xfe, 0x9, 0x96, 0xf3, 0x2f, 0xe9, 0xfc, 0x3e, 0xeb, 0x3f, 0x1f, 0x55, 0x7a, 0xe1, 0x63, 0x27, 0x50, 0xb9, 0x2d, 0x5, 0x23, 0x9a, 0xf8, 0x57, 0xc4, 0x2d, 0x59, 0xa3, 0xda, 0xeb, 0x96, 0x29, 0xe1, 0x15, 0x8b, 0xec}},
+       testcase{
+               msg:       []byte{0xc4, 0x64, 0xbb, 0xda, 0xd2, 0x75, 0xc5, 0xd, 0xcd, 0x98, 0x3b, 0x65, 0xad, 0x10, 0x19, 0xb9, 0xff, 0x85, 0xa1, 0xe7, 0x1c, 0x80, 0x7f, 0x32, 0x4, 0xbb, 0x2c, 0x92, 0x1d, 0xc3, 0x1f, 0xbc, 0xd8, 0xc5, 0xfc, 0x45, 0x86, 0x8a, 0xe9, 0xef, 0x85, 0xb6, 0xc9, 0xb8, 0x3b, 0xba, 0x2a, 0x5a, 0x82, 0x22, 0x1, 0xed, 0x68, 0x58, 0x6e, 0xc5, 0xec, 0x27, 0xfb, 0x28, 0x57, 0xa5, 0xd1, 0xa2, 0xd0, 0x9d, 0x9, 0x11, 0x5f, 0x22, 0xdc, 0xc3, 0x9f, 0xe6, 0x1f, 0x5e, 0x1b, 0xa0, 0xff, 0x6e, 0x8b, 0x4a, 0xcb, 0x4c, 0x6d, 0xa7, 0x48, 0xbe, 0x7f, 0x3f, 0x8, 0x39, 0x73, 0x93, 0x94, 0xff, 0x7f, 0xa8, 0xe3, 0x9f, 0x7f, 0x7e, 0x84, 0xa3, 0x3c, 0x38, 0x66, 0x87, 0x5c, 0x1, 0xbc, 0xb1, 0x26, 0x3c, 0x94, 0x5, 0xd9, 0x19, 0x8, 0xe9, 0xe0, 0xb5, 0xe, 0x74, 0x59, 0xfa, 0xbb, 0x63, 0xd8, 0xc6, 0xbb, 0xb7, 0x3d, 0x8e, 0x34, 0x83, 0xc0, 0x99, 0xb5, 0x5b, 0xc3, 0xf, 0xf0, 0x92, 0xff, 0x68, 0xb6, 0xad, 0xed, 0xfd, 0x47, 0x7d, 0x63, 0x57, 0xc, 0x9f, 0x55, 0x15, 0x84, 0x7f, 0x36, 0xe2, 0x4b, 0xa0, 0xb7, 0x5, 0x55, 0x71, 0x30, 0xce, 0xc5, 0x7e, 0xba, 0xd1, 0xd0, 0xb3, 0x1a, 0x37, 0x8e, 0x91, 0x89, 0x4e, 0xe2, 0x6e, 0x3a, 0x4},
+               output224: []byte{0x4c, 0x3d, 0x63, 0x21, 0x13, 0x3e, 0xf7, 0x48, 0x10, 0xe6, 0xd, 0x31, 0x90, 0xff, 0xf3, 0xcf, 0x20, 0xc8, 0x52, 0x1c, 0xae, 0xa6, 0xff, 0x78, 0x2d, 0x7e, 0x3b, 0xab},
+               output256: []byte{0xff, 0xac, 0x7c, 0xa5, 0xfa, 0x6, 0x74, 0x19, 0xd1, 0xbd, 0xb0, 0xc, 0xe, 0x49, 0xc6, 0xe1, 0xa7, 0x48, 0x88, 0x9, 0x23, 0xa2, 0x3e, 0xd5, 0xdd, 0x67, 0xdd, 0xe6, 0x3d, 0x77, 0x7e, 0xdb},
+               output384: []byte{0xde, 0x34, 0x50, 0x6a, 0xd6, 0x90, 0x85, 0xc6, 0x35, 0x7d, 0x62, 0xb0, 0xb1, 0x27, 0xce, 0x66, 0xe2, 0x5e, 0x8e, 0xc5, 0xfa, 0xca, 0x5b, 0xa8, 0x98, 0xc7, 0x5c, 0xa1, 0x9e, 0x9a, 0xf2, 0x4f, 0x2, 0x40, 0x67, 0x16, 0xc6, 0x1a, 0x71, 0xd6, 0x2b, 0xdc, 0x28, 0xd7, 0x18, 0xc1, 0x25, 0xdf},
+               output512: []byte{0x6b, 0x8b, 0xc6, 0x21, 0x1f, 0xe5, 0x0, 0x1e, 0x7, 0xb7, 0xd2, 0xe, 0xc, 0x49, 0xd3, 0x14, 0x21, 0x1e, 0x38, 0x93, 0xa3, 0x9d, 0xa2, 0x41, 0xb8, 0x83, 0x9b, 0xb3, 0xa4, 0x94, 0xf9, 0xa2, 0xfd, 0x85, 0x61, 0x0, 0x9d, 0x22, 0xcc, 0xa1, 0x33, 0xa, 0x69, 0x36, 0x2b, 0x38, 0x6e, 0x71, 0x5f, 0x1d, 0xbe, 0x62, 0x91, 0xdb, 0xee, 0xcf, 0xad, 0xf1, 0x96, 0xda, 0x47, 0xe5, 0x31, 0x98}},
+       testcase{
+               msg:       []byte{0x8b, 0x8d, 0x68, 0xbb, 0x8a, 0x75, 0x73, 0x2f, 0xe2, 0x72, 0x81, 0x5a, 0x68, 0xa1, 0xc9, 0xc5, 0xaa, 0x31, 0xb4, 0x1d, 0xed, 0xc8, 0x49, 0x3e, 0x76, 0x52, 0x5d, 0x1d, 0x1, 0x3d, 0x33, 0xce, 0xbd, 0x9e, 0x21, 0xa5, 0xbb, 0x95, 0xdb, 0x26, 0x16, 0x97, 0x6a, 0x8c, 0x7, 0xfc, 0xf4, 0x11, 0xf5, 0xf6, 0xbc, 0x6f, 0x7e, 0xb, 0x57, 0xac, 0xa7, 0x8c, 0xc2, 0x79, 0xa, 0x6f, 0x9b, 0x89, 0x88, 0x58, 0xac, 0x9c, 0x79, 0xb1, 0x65, 0xff, 0x24, 0xe6, 0x66, 0x77, 0x53, 0x1e, 0x39, 0xf5, 0x72, 0xbe, 0x5d, 0x81, 0xeb, 0x32, 0x64, 0x52, 0x41, 0x81, 0x11, 0x5f, 0x32, 0x78, 0x2, 0x57, 0xbf, 0xb9, 0xae, 0xec, 0x6a, 0xf1, 0x2a, 0xf2, 0x8e, 0x58, 0x7c, 0xac, 0x6, 0x8a, 0x1a, 0x29, 0x53, 0xb5, 0x9a, 0xd6, 0x80, 0xf4, 0xc2, 0x45, 0xb2, 0xe3, 0xec, 0x36, 0xf5, 0x99, 0x40, 0xd3, 0x7e, 0x1d, 0x3d, 0xb3, 0x8e, 0x13, 0xed, 0xb2, 0x9b, 0x5c, 0xf, 0x40, 0x4f, 0x6f, 0xf8, 0x7f, 0x80, 0xfc, 0x8b, 0xe7, 0xa2, 0x25, 0xff, 0x22, 0xfb, 0xb9, 0xc8, 0xb6, 0xb1, 0xd7, 0x33, 0xc, 0x57, 0x84, 0xd, 0x24, 0xbc, 0x75, 0xb0, 0x6b, 0x80, 0xd3, 0xd, 0xad, 0x68, 0x6, 0x54, 0x4d, 0x51, 0xa, 0xf6, 0xc4, 0x78, 0x5e, 0x82, 0x3a, 0xc3, 0xe0, 0xb8},
+               output224: []byte{0xb9, 0xf0, 0x6, 0xdb, 0xf8, 0x53, 0xc0, 0x23, 0xde, 0xbe, 0x2f, 0x40, 0x3, 0x5a, 0x7e, 0x83, 0xc4, 0x9c, 0xde, 0x65, 0x6e, 0xc8, 0x6a, 0x46, 0x21, 0x95, 0xf, 0x3e},
+               output256: []byte{0x5b, 0x2e, 0xca, 0x9, 0x20, 0xd3, 0x2b, 0x19, 0x64, 0xbb, 0xf5, 0x81, 0xa, 0x6e, 0x6e, 0x53, 0x67, 0x5e, 0xd1, 0xb8, 0x38, 0x97, 0xfd, 0x4, 0x60, 0xd, 0x72, 0xe0, 0x97, 0x84, 0x58, 0x59},
+               output384: []byte{0x6f, 0x4f, 0xee, 0xdb, 0xa0, 0xab, 0xb4, 0xdb, 0xf8, 0x24, 0x30, 0x22, 0x50, 0xe6, 0xb6, 0x68, 0xcb, 0xff, 0xdc, 0xa0, 0xb8, 0xc3, 0x38, 0x23, 0x6f, 0xe0, 0x2a, 0x87, 0x79, 0xd8, 0xac, 0xa3, 0x91, 0xd8, 0xd1, 0x16, 0xb2, 0xbc, 0x43, 0xd4, 0xe, 0x73, 0x60, 0x96, 0x47, 0xa, 0xb, 0xc0},
+               output512: []byte{0xd0, 0xe, 0x91, 0x9d, 0xaf, 0xff, 0x3d, 0x5e, 0x51, 0xad, 0x3a, 0x30, 0x46, 0xf5, 0xe5, 0x9d, 0x64, 0xb6, 0x9c, 0xbc, 0xda, 0x22, 0x3c, 0xb2, 0x8b, 0xc3, 0x70, 0x20, 0x1d, 0x2c, 0x72, 0x2b, 0xae, 0x74, 0xdf, 0xe0, 0x8, 0x6b, 0xe, 0xb4, 0x7b, 0xdc, 0xb6, 0x2f, 0xab, 0xee, 0x87, 0xc, 0x33, 0x40, 0xd4, 0x6e, 0x55, 0xd8, 0xcf, 0xed, 0xf2, 0xdd, 0x3c, 0xed, 0x8a, 0x8d, 0xb3, 0xf2}},
+       testcase{
+               msg:       []byte{0x6b, 0x1, 0x87, 0x10, 0x44, 0x6f, 0x36, 0x8e, 0x74, 0x21, 0xf1, 0xbc, 0xc, 0xcf, 0x56, 0x2d, 0x9c, 0x18, 0x43, 0x84, 0x6b, 0xc8, 0xd9, 0x8d, 0x1c, 0x9b, 0xf7, 0xd9, 0xd6, 0xfc, 0xb4, 0x8b, 0xfc, 0x3b, 0xf8, 0x3b, 0x36, 0xd4, 0x4c, 0x4f, 0xa9, 0x34, 0x30, 0xaf, 0x75, 0xcd, 0x19, 0xb, 0xde, 0x36, 0xa7, 0xf9, 0x2f, 0x86, 0x7f, 0x58, 0xa8, 0x3, 0x90, 0xd, 0xf8, 0x1, 0x81, 0x50, 0x38, 0x4d, 0x85, 0xd8, 0x21, 0x32, 0xf1, 0x23, 0x0, 0x6a, 0xc2, 0xae, 0xba, 0x58, 0xe0, 0x2a, 0x3, 0x7f, 0xe6, 0xaf, 0xbd, 0x65, 0xec, 0xa7, 0xc4, 0x49, 0x77, 0xdd, 0x3d, 0xc7, 0x4f, 0x48, 0xb6, 0xe7, 0xa1, 0xbf, 0xd5, 0xcc, 0x4d, 0xcf, 0x24, 0xe4, 0xd5, 0x2e, 0x92, 0xbd, 0x44, 0x55, 0x84, 0x8e, 0x49, 0x28, 0xb0, 0xea, 0xc8, 0xb7, 0x47, 0x6f, 0xe3, 0xcc, 0x3, 0xe8, 0x62, 0xaa, 0x4d, 0xff, 0x44, 0x70, 0xdb, 0xfe, 0xd6, 0xde, 0x48, 0xe4, 0x10, 0xf2, 0x50, 0x96, 0x48, 0x7e, 0xcf, 0xc3, 0x2a, 0x27, 0x27, 0x7f, 0x3f, 0x50, 0x23, 0xb2, 0x72, 0x5a, 0xde, 0x46, 0x1b, 0x13, 0x55, 0x88, 0x95, 0x54, 0xa8, 0x83, 0x6c, 0x9c, 0xf5, 0x3b, 0xd7, 0x67, 0xf5, 0x73, 0x7d, 0x55, 0x18, 0x4e, 0xea, 0x1a, 0xb3, 0xf5, 0x3e, 0xdd, 0x9, 0x76, 0xc4, 0x85},
+               output224: []byte{0xa, 0x5a, 0xa6, 0xbc, 0x56, 0x4b, 0x8c, 0xb2, 0xf5, 0xfd, 0x72, 0x55, 0x45, 0x5c, 0xe, 0x7a, 0x5d, 0xac, 0xe0, 0x5, 0xc, 0x3b, 0xbd, 0x25, 0x9f, 0xde, 0x2a, 0xb9},
+               output256: []byte{0x68, 0xf4, 0x1f, 0xdf, 0xc7, 0x21, 0x7e, 0x89, 0x68, 0x7e, 0xd1, 0x18, 0xbc, 0x31, 0xac, 0x6e, 0xd2, 0xd9, 0xd1, 0xe1, 0xa2, 0xf1, 0xb2, 0xa, 0x2d, 0x42, 0x97, 0x29, 0xfa, 0x3, 0x51, 0x7b},
+               output384: []byte{0xa0, 0x40, 0xce, 0x1c, 0xbb, 0x99, 0x67, 0x23, 0xcb, 0xcd, 0xbd, 0xff, 0x7a, 0x6a, 0x5f, 0x69, 0x28, 0x97, 0x37, 0x60, 0x95, 0x34, 0xc5, 0xaf, 0x36, 0xf6, 0xc4, 0x20, 0xa6, 0xad, 0xfd, 0x57, 0x7, 0x94, 0x7, 0x95, 0x9, 0xd0, 0x7e, 0x62, 0x56, 0x6c, 0x58, 0x6, 0x2d, 0x81, 0x86, 0xdb},
+               output512: []byte{0xcf, 0x63, 0xf2, 0x8f, 0x10, 0x7a, 0x50, 0x9a, 0x41, 0x6f, 0x9a, 0x92, 0xc4, 0xe4, 0xdb, 0x4d, 0xbf, 0x0, 0xfb, 0x52, 0xc2, 0xe1, 0x6d, 0x8b, 0xb9, 0x69, 0x4e, 0x9, 0xf9, 0x14, 0x2a, 0x90, 0x4c, 0x34, 0xe1, 0xe9, 0x60, 0xbd, 0x97, 0xb8, 0xcf, 0xb2, 0xc5, 0x3e, 0x76, 0x60, 0xc7, 0x9b, 0x84, 0x1d, 0x15, 0x65, 0xcd, 0xab, 0x83, 0x29, 0x32, 0x34, 0x2, 0x6a, 0x23, 0xa5, 0x6d, 0x12}},
+       testcase{
+               msg:       []byte{0xc9, 0x53, 0x4a, 0x24, 0x71, 0x4b, 0xd4, 0xbe, 0x37, 0xc8, 0x8a, 0x3d, 0xa1, 0x8, 0x2e, 0xda, 0x7c, 0xab, 0xd1, 0x54, 0xc3, 0x9, 0xd7, 0xbd, 0x67, 0xd, 0xcc, 0xd9, 0x5a, 0xa5, 0x35, 0x59, 0x44, 0x63, 0x5, 0x8a, 0x29, 0xf7, 0x90, 0x31, 0xd6, 0xec, 0xaa, 0x9f, 0x67, 0x5d, 0x12, 0x11, 0xe9, 0x35, 0x9b, 0xe8, 0x26, 0x69, 0xa7, 0x9c, 0x85, 0x5e, 0xa8, 0xd8, 0x9d, 0xd3, 0x8c, 0x2c, 0x76, 0x1d, 0xdd, 0xe, 0xc0, 0xce, 0x9e, 0x97, 0x59, 0x74, 0x32, 0xe9, 0xa1, 0xbe, 0xae, 0x6, 0x2c, 0xdd, 0x71, 0xed, 0xfd, 0xfd, 0x46, 0x41, 0x19, 0xbe, 0x9e, 0x69, 0xd1, 0x8a, 0x7a, 0x7f, 0xd7, 0xce, 0xe, 0x21, 0x6, 0xf0, 0xc8, 0xb0, 0xab, 0xf4, 0x71, 0x5e, 0x2c, 0xa4, 0x8e, 0xf9, 0xf4, 0x54, 0xdc, 0x20, 0x3c, 0x96, 0x65, 0x66, 0x53, 0xb7, 0x27, 0x8, 0x35, 0x13, 0xf8, 0xef, 0xb8, 0x6e, 0x49, 0xc5, 0x13, 0xbb, 0x75, 0x8b, 0x3b, 0x5, 0x2f, 0xe2, 0x1f, 0x1c, 0x5, 0xbb, 0x33, 0xc3, 0x71, 0x29, 0xd6, 0xcc, 0x81, 0xf1, 0xae, 0xf6, 0xad, 0xc4, 0x5b, 0xe, 0x88, 0x27, 0xa8, 0x30, 0xfe, 0x54, 0x5c, 0xf5, 0x7d, 0x9, 0x55, 0x80, 0x2c, 0x11, 0x7d, 0x23, 0xcc, 0xb5, 0x5e, 0xa2, 0x8f, 0x95, 0xc0, 0xd8, 0xc2, 0xf9, 0xc5, 0xa2, 0x42, 0xb3, 0x3f},
+               output224: []byte{0x8c, 0xa4, 0xe0, 0x85, 0xf0, 0x49, 0x56, 0xb5, 0xb1, 0x65, 0x20, 0xe3, 0xa7, 0x67, 0xf8, 0xba, 0x93, 0x73, 0x64, 0xfe, 0x5f, 0x44, 0x60, 0x28, 0x8a, 0xd4, 0xf2, 0x31},
+               output256: []byte{0xfa, 0x2f, 0x3d, 0xe3, 0x1e, 0x9c, 0xf2, 0x5a, 0xb9, 0xa9, 0x78, 0xc8, 0x2d, 0x60, 0x5a, 0x43, 0xee, 0x39, 0xb6, 0x8a, 0xc8, 0xe3, 0xf, 0x49, 0xf9, 0xd2, 0x9, 0xcb, 0x4e, 0x17, 0x2a, 0xb4},
+               output384: []byte{0xff, 0x13, 0xc2, 0x9c, 0x5e, 0xd, 0x74, 0x6c, 0xa2, 0x7a, 0xee, 0x38, 0xb6, 0xb4, 0x9a, 0x13, 0xc1, 0xb3, 0xd7, 0xe, 0x62, 0x87, 0x54, 0x43, 0xbc, 0xfc, 0x22, 0xa2, 0x2e, 0x75, 0x3, 0x1e, 0x60, 0xd6, 0x8a, 0x91, 0x7e, 0x3a, 0xe1, 0xd4, 0x2d, 0x37, 0x4d, 0x44, 0xcd, 0xc9, 0xf4, 0xc8},
+               output512: []byte{0xf2, 0x1b, 0x8d, 0x45, 0xb6, 0xa8, 0x57, 0xce, 0x66, 0x3c, 0x7, 0x4c, 0x18, 0xcc, 0x54, 0xd9, 0x14, 0xcd, 0xd5, 0xeb, 0xd, 0x96, 0x8e, 0x61, 0x53, 0xa5, 0xf7, 0x0, 0x69, 0x34, 0x5d, 0x20, 0x5d, 0xdf, 0x43, 0x70, 0xec, 0x47, 0x3f, 0xc8, 0xb, 0x5, 0xf9, 0x37, 0xd0, 0x14, 0xc0, 0xa4, 0x64, 0x58, 0x2c, 0xb4, 0xa7, 0x3b, 0x1b, 0x72, 0x4, 0x1c, 0x5c, 0x99, 0xf5, 0x76, 0xa4, 0x1e}},
+       testcase{
+               msg:       []byte{0x7, 0x90, 0x6c, 0x87, 0x29, 0x7b, 0x86, 0x7a, 0xbf, 0x45, 0x76, 0xe9, 0xf3, 0xcc, 0x7f, 0x82, 0xf2, 0x2b, 0x15, 0x4a, 0xfc, 0xbf, 0x29, 0x3b, 0x93, 0x19, 0xf1, 0xb0, 0x58, 0x4d, 0xa6, 0xa4, 0xc, 0x27, 0xb3, 0x2e, 0xb, 0x1b, 0x7f, 0x41, 0x2c, 0x4f, 0x1b, 0x82, 0x48, 0xe, 0x70, 0xa9, 0x23, 0x5b, 0x12, 0xec, 0x27, 0x9, 0xa, 0x5a, 0x33, 0x17, 0x5a, 0x2b, 0xb2, 0x8d, 0x8a, 0xdc, 0x47, 0x5c, 0xef, 0xe3, 0x3f, 0x78, 0x3, 0xf8, 0xce, 0x27, 0x96, 0x72, 0x17, 0x38, 0x1f, 0x2, 0xe6, 0x7a, 0x3b, 0x4f, 0x84, 0xa7, 0x1f, 0x1c, 0x52, 0x28, 0xe0, 0xc2, 0xad, 0x97, 0x13, 0x73, 0xf6, 0xf6, 0x72, 0x62, 0x4f, 0xce, 0xa8, 0xd1, 0xa9, 0xf8, 0x51, 0x70, 0xfa, 0xd3, 0xf, 0xa0, 0xbb, 0xd2, 0x50, 0x35, 0xc3, 0xb4, 0x1a, 0x61, 0x75, 0xd4, 0x67, 0x99, 0x8b, 0xd1, 0x21, 0x5f, 0x6f, 0x38, 0x66, 0xf5, 0x38, 0x47, 0xf9, 0xcf, 0x68, 0xef, 0x3e, 0x2f, 0xbb, 0x54, 0xbc, 0x99, 0x4d, 0xe2, 0x30, 0x2b, 0x82, 0x9c, 0x5e, 0xea, 0x68, 0xec, 0x44, 0x1f, 0xcb, 0xaf, 0xd7, 0xd1, 0x6a, 0xe4, 0xfe, 0x9f, 0xff, 0x98, 0xbf, 0x0, 0xe5, 0xbc, 0x2a, 0xd5, 0x4d, 0xd9, 0x1f, 0xf9, 0xfd, 0xa4, 0xdd, 0x77, 0xb6, 0xc7, 0x54, 0xa9, 0x19, 0x55, 0xd1, 0xfb, 0xaa, 0xd0},
+               output224: []byte{0xc0, 0xaa, 0x34, 0x39, 0x1c, 0xb3, 0x10, 0x4c, 0x41, 0x99, 0x5f, 0x3d, 0xe7, 0x82, 0xf0, 0x12, 0xd4, 0x21, 0x58, 0x5e, 0x53, 0x84, 0xe0, 0x47, 0xa9, 0x97, 0x6, 0x2f},
+               output256: []byte{0xba, 0x2a, 0xf5, 0x6, 0xc1, 0xd, 0xa8, 0xd7, 0x75, 0x1e, 0x67, 0xed, 0x76, 0x6c, 0xfc, 0xd4, 0x7d, 0x4, 0x8d, 0x6e, 0xf9, 0x27, 0x7d, 0xbd, 0x2a, 0xbf, 0xe2, 0xfd, 0x5d, 0x78, 0x7b, 0x79},
+               output384: []byte{0x3a, 0x44, 0x18, 0xa1, 0x68, 0x96, 0xad, 0xab, 0x7c, 0x6d, 0xc7, 0x83, 0xa0, 0xfc, 0x9f, 0x8d, 0x7e, 0x94, 0x99, 0x37, 0xbe, 0x1d, 0x68, 0xb5, 0xef, 0x2, 0x57, 0x4b, 0x2b, 0xc, 0x9b, 0xa9, 0x2, 0xfb, 0x9c, 0x15, 0xed, 0x64, 0xfc, 0x82, 0x5d, 0x59, 0x8a, 0xaf, 0xc1, 0xb2, 0x63, 0x47},
+               output512: []byte{0x92, 0x28, 0x7f, 0x42, 0xab, 0x1a, 0x21, 0x23, 0x66, 0x9c, 0x4d, 0x35, 0xf1, 0x82, 0x57, 0xd3, 0xa5, 0x36, 0x44, 0x5f, 0xe, 0x4d, 0x2c, 0x80, 0x1e, 0x99, 0xf8, 0x52, 0x9c, 0xd9, 0xe2, 0xa7, 0x92, 0x5, 0x98, 0x2c, 0x28, 0xc, 0x7a, 0x6c, 0xdd, 0xde, 0xf2, 0x4c, 0xe9, 0x60, 0xec, 0x6c, 0xa9, 0xa3, 0x5f, 0x59, 0xa, 0xee, 0xbc, 0x40, 0x44, 0x8c, 0x38, 0x9e, 0x91, 0x5f, 0xc4, 0xe0}},
+       testcase{
+               msg:       []byte{0x58, 0x8e, 0x94, 0xb9, 0x5, 0x4a, 0xbc, 0x21, 0x89, 0xdf, 0x69, 0xb8, 0xba, 0x34, 0x34, 0x1b, 0x77, 0xcd, 0xd5, 0x28, 0xe7, 0x86, 0xe, 0x5d, 0xef, 0xca, 0xa7, 0x9b, 0xc, 0x9a, 0x45, 0x2a, 0xd4, 0xb8, 0x2a, 0xa3, 0x6, 0xbe, 0x84, 0x53, 0x6e, 0xb7, 0xce, 0xdc, 0xbe, 0x5, 0x8d, 0x7b, 0x84, 0xa6, 0xae, 0xf8, 0x26, 0xb0, 0x28, 0xb8, 0xa0, 0x27, 0x1b, 0x69, 0xac, 0x36, 0x5, 0xa9, 0x63, 0x5e, 0xa9, 0xf5, 0xea, 0xa, 0xa7, 0x0, 0xf3, 0xeb, 0x78, 0x35, 0xbc, 0x54, 0x61, 0x1b, 0x92, 0x29, 0x64, 0x30, 0xc, 0x95, 0x3e, 0xfe, 0x74, 0x91, 0xe3, 0x67, 0x7c, 0x2c, 0xeb, 0xe0, 0x82, 0x2e, 0x95, 0x6c, 0xd1, 0x64, 0x33, 0xb0, 0x2c, 0x68, 0xc4, 0xa2, 0x32, 0x52, 0xc3, 0xf9, 0xe1, 0x51, 0xa4, 0x16, 0xb4, 0x96, 0x32, 0x57, 0xb7, 0x83, 0xe0, 0x38, 0xf6, 0xb4, 0xd5, 0xc9, 0xf1, 0x10, 0xf8, 0x71, 0x65, 0x2c, 0x7a, 0x64, 0x9a, 0x7b, 0xce, 0xdc, 0xbc, 0xcc, 0x6f, 0x2d, 0x7, 0x25, 0xbb, 0x90, 0x3c, 0xc1, 0x96, 0xba, 0x76, 0xc7, 0x6a, 0xa9, 0xf1, 0xa, 0x19, 0xb, 0x1d, 0x11, 0x68, 0x99, 0x3b, 0xaa, 0x9f, 0xfc, 0x96, 0xa1, 0x65, 0x52, 0x16, 0x77, 0x34, 0x58, 0xbe, 0xc7, 0x2b, 0xe, 0x39, 0xc9, 0xf2, 0xc1, 0x21, 0x37, 0x8f, 0xea, 0xb4, 0xe7, 0x6a},
+               output224: []byte{0x33, 0xc1, 0x0, 0x10, 0xa0, 0xb8, 0x10, 0x38, 0x6a, 0xe6, 0x2f, 0x3f, 0x92, 0x7d, 0xea, 0xfc, 0xd, 0x5a, 0xf0, 0xaf, 0x3d, 0xc7, 0xa8, 0x35, 0x5c, 0xb7, 0x79, 0xcd},
+               output256: []byte{0x3c, 0xd3, 0x3f, 0x88, 0x11, 0xaf, 0x12, 0x18, 0x3c, 0x53, 0xe9, 0x78, 0x52, 0x8f, 0x53, 0xae, 0x7d, 0x55, 0x94, 0x32, 0x72, 0x40, 0x29, 0xe5, 0x5f, 0xcf, 0xa9, 0xb9, 0x90, 0xb9, 0x17, 0x13},
+               output384: []byte{0x17, 0xf8, 0x44, 0x11, 0xe6, 0xf, 0x6b, 0xd8, 0x56, 0xd0, 0x9c, 0xa, 0xcf, 0x31, 0x4e, 0x75, 0x46, 0x46, 0x6a, 0xb0, 0xc1, 0x61, 0x62, 0x84, 0xd2, 0x24, 0xd, 0x22, 0xbc, 0xcc, 0x72, 0x40, 0xe5, 0xa2, 0xd6, 0x56, 0xd3, 0x52, 0x57, 0xab, 0x49, 0x78, 0x1b, 0xda, 0xbe, 0xf6, 0xfc, 0xf9},
+               output512: []byte{0x74, 0xa9, 0xd8, 0xf9, 0xf7, 0x29, 0x8, 0xc7, 0x50, 0x2d, 0x1c, 0x41, 0x21, 0x2c, 0xd8, 0x6c, 0xf4, 0x34, 0x47, 0x21, 0xa6, 0xf0, 0x2d, 0x39, 0x3, 0x46, 0xf2, 0xba, 0xec, 0x6e, 0x61, 0x37, 0x42, 0x1e, 0x65, 0x16, 0xc3, 0x23, 0x54, 0x43, 0xbc, 0x23, 0x37, 0xb3, 0xa7, 0x76, 0x30, 0x71, 0x2a, 0x12, 0xf1, 0x1b, 0x7b, 0xa2, 0x4b, 0x2d, 0x70, 0x85, 0x49, 0x9b, 0xa7, 0x4b, 0xcb, 0x90}},
+       testcase{
+               msg:       []byte{0x8, 0x95, 0x9a, 0x7e, 0x4b, 0xaa, 0xe8, 0x74, 0x92, 0x88, 0x13, 0x36, 0x40, 0x71, 0x19, 0x4e, 0x29, 0x39, 0x77, 0x2f, 0x20, 0xdb, 0x7c, 0x31, 0x57, 0x7, 0x89, 0x87, 0xc5, 0x57, 0xc2, 0xa6, 0xd5, 0xab, 0xe6, 0x8d, 0x52, 0xe, 0xef, 0x3d, 0xc4, 0x91, 0x69, 0x2e, 0x1e, 0x21, 0xbc, 0xd8, 0x80, 0xad, 0xeb, 0xf6, 0x3b, 0xb4, 0x21, 0x3b, 0x50, 0x89, 0x7f, 0xa0, 0x5, 0x25, 0x6e, 0xd4, 0x1b, 0x56, 0x90, 0xf7, 0x8f, 0x52, 0x85, 0x5c, 0x8d, 0x91, 0x68, 0xa4, 0xb6, 0x66, 0xfc, 0xe2, 0xda, 0x2b, 0x45, 0x6d, 0x7a, 0x7e, 0x7c, 0x17, 0xab, 0x5f, 0x2f, 0xb1, 0xee, 0x90, 0xb7, 0x9e, 0x69, 0x87, 0x12, 0xe9, 0x63, 0x71, 0x59, 0x83, 0xfd, 0x7, 0x64, 0x1a, 0xe4, 0xb4, 0xe9, 0xdc, 0x73, 0x20, 0x3f, 0xac, 0x1a, 0xe1, 0x1f, 0xa1, 0xf8, 0xc7, 0x94, 0x1f, 0xcc, 0x82, 0xea, 0xb2, 0x47, 0xad, 0xdb, 0x56, 0xe2, 0x63, 0x84, 0x47, 0xe9, 0xd6, 0x9, 0xe6, 0x10, 0xb6, 0xc, 0xe0, 0x86, 0x65, 0x6a, 0xae, 0xbf, 0x1d, 0xa3, 0xc8, 0xa2, 0x31, 0xd7, 0xd9, 0x4e, 0x2f, 0xd0, 0xaf, 0xe4, 0x6b, 0x39, 0x1f, 0xf1, 0x4a, 0x72, 0xea, 0xeb, 0x3f, 0x44, 0xad, 0x4d, 0xf8, 0x58, 0x66, 0xde, 0xf4, 0x3d, 0x47, 0x81, 0xa0, 0xb3, 0x57, 0x8b, 0xc9, 0x96, 0xc8, 0x79, 0x70, 0xb1, 0x32},
+               output224: []byte{0x84, 0x2a, 0x2e, 0x13, 0xd2, 0x72, 0x8c, 0xa5, 0x5b, 0x42, 0xd7, 0x84, 0xbb, 0x6b, 0xc4, 0xb8, 0x89, 0xe5, 0x67, 0x75, 0xad, 0x56, 0xbf, 0x75, 0x78, 0x9c, 0xc5, 0x7a},
+               output256: []byte{0x3e, 0xcc, 0x9d, 0x27, 0x99, 0x40, 0x22, 0x4, 0x5c, 0xbe, 0xab, 0x4f, 0xc0, 0x41, 0xf1, 0x24, 0x19, 0xce, 0xc8, 0x6, 0xc, 0x8f, 0x6f, 0x9f, 0x3, 0x72, 0x88, 0x4d, 0xf6, 0x7, 0x4b, 0x5c},
+               output384: []byte{0xe5, 0x77, 0xf7, 0x9b, 0xe, 0x5, 0x35, 0x5b, 0x8f, 0x63, 0xec, 0x1e, 0x63, 0x9b, 0xc5, 0xa5, 0x1a, 0x72, 0xbb, 0xb0, 0xab, 0xaf, 0xe7, 0x6d, 0x31, 0x33, 0xde, 0xc4, 0xda, 0x9b, 0xef, 0x9a, 0x36, 0x1f, 0x3e, 0x3c, 0xa, 0xdb, 0x4c, 0x7, 0xe2, 0x75, 0x7f, 0xe1, 0xd4, 0x79, 0xb, 0x9a},
+               output512: []byte{0x74, 0x32, 0x86, 0x11, 0x32, 0xe6, 0x89, 0x4b, 0xb6, 0xae, 0x51, 0x15, 0x39, 0x81, 0x98, 0x31, 0x7e, 0x12, 0xcc, 0x73, 0xc0, 0xc5, 0xdf, 0xc6, 0x1c, 0xb1, 0x89, 0xff, 0x5a, 0xa9, 0xfb, 0xd, 0x62, 0x22, 0x4c, 0xbb, 0x1b, 0xfa, 0x8b, 0x10, 0x57, 0x84, 0x40, 0x57, 0x18, 0xe6, 0xf8, 0xe1, 0x5e, 0x4, 0x1d, 0xad, 0x80, 0xd1, 0x1a, 0xe5, 0x7, 0xb3, 0x3c, 0x15, 0xc6, 0xca, 0xc8, 0x24}},
+       testcase{
+               msg:       []byte{0xcb, 0x2a, 0x23, 0x4f, 0x45, 0xe2, 0xec, 0xd5, 0x86, 0x38, 0x95, 0xa4, 0x51, 0xd3, 0x89, 0xa3, 0x69, 0xaa, 0xb9, 0x9c, 0xfe, 0xf0, 0xd5, 0xc9, 0xff, 0xca, 0x1e, 0x6e, 0x63, 0xf7, 0x63, 0xb5, 0xc1, 0x4f, 0xb9, 0xb4, 0x78, 0x31, 0x3c, 0x8e, 0x8c, 0xe, 0xfe, 0xb3, 0xac, 0x95, 0x0, 0xcf, 0x5f, 0xd9, 0x37, 0x91, 0xb7, 0x89, 0xe6, 0x7e, 0xac, 0x12, 0xfd, 0x3, 0x8e, 0x25, 0x47, 0xcc, 0x8e, 0xf, 0xc9, 0xdb, 0x59, 0x1f, 0x33, 0xa1, 0xe4, 0x90, 0x7c, 0x64, 0xa9, 0x22, 0xdd, 0xa2, 0x3e, 0xc9, 0x82, 0x73, 0x10, 0xb3, 0x6, 0x9, 0x85, 0x54, 0xa4, 0xa7, 0x8f, 0x5, 0x2, 0x62, 0xdb, 0x5b, 0x54, 0x5b, 0x15, 0x9e, 0x1f, 0xf1, 0xdc, 0xa6, 0xeb, 0x73, 0x4b, 0x87, 0x23, 0x43, 0xb8, 0x42, 0xc5, 0x7e, 0xaf, 0xcf, 0xda, 0x84, 0x5, 0xee, 0xdb, 0xb4, 0x8e, 0xf3, 0x2e, 0x99, 0x69, 0x6d, 0x13, 0x59, 0x79, 0x23, 0x5c, 0x3a, 0x5, 0x36, 0x4e, 0x37, 0x1c, 0x2d, 0x76, 0xf1, 0x90, 0x2f, 0x1d, 0x83, 0x14, 0x6d, 0xf9, 0x49, 0x5c, 0xa, 0x6c, 0x57, 0xd7, 0xbf, 0x9e, 0xe7, 0x7e, 0x80, 0xf9, 0x78, 0x7a, 0xee, 0x27, 0xbe, 0x1f, 0xe1, 0x26, 0xcd, 0xc9, 0xef, 0x89, 0x3a, 0x4a, 0x7d, 0xcb, 0xbc, 0x36, 0x7e, 0x40, 0xfe, 0x4e, 0x1e, 0xe9, 0xb, 0x42, 0xea, 0x25, 0xaf, 0x1},
+               output224: []byte{0xa5, 0x76, 0x28, 0x1c, 0xfa, 0xa8, 0x9d, 0xce, 0xfb, 0x1d, 0x37, 0x77, 0x24, 0x0, 0xba, 0x4c, 0xab, 0xce, 0xef, 0x33, 0xcb, 0xa2, 0xf8, 0x33, 0x33, 0x6a, 0x74, 0xf2},
+               output256: []byte{0x15, 0x1, 0x98, 0x8a, 0x55, 0x37, 0x2a, 0xc1, 0xb0, 0xb7, 0x88, 0x49, 0xf3, 0xb7, 0xe1, 0x7, 0xe0, 0xbf, 0x1f, 0x2c, 0xba, 0xf6, 0x70, 0xde, 0x7f, 0x15, 0xac, 0xbb, 0x1a, 0x0, 0xad, 0x3d},
+               output384: []byte{0xf7, 0x81, 0x6, 0xf1, 0xe, 0x6c, 0x1f, 0x1c, 0xa5, 0x19, 0xf, 0xe5, 0x41, 0x34, 0x51, 0x45, 0xee, 0x25, 0xbc, 0x51, 0xd3, 0xc1, 0xcb, 0xaa, 0xa0, 0x4c, 0xd, 0xb2, 0xa3, 0xba, 0x25, 0x84, 0xdd, 0xd3, 0xf, 0x3a, 0x88, 0x9b, 0x94, 0xbb, 0xcb, 0x95, 0x73, 0xcd, 0x94, 0x17, 0x57, 0x4c},
+               output512: []byte{0x6a, 0xf4, 0xff, 0x4c, 0x42, 0x30, 0x51, 0xe3, 0x30, 0x6a, 0xce, 0x81, 0x2e, 0x5c, 0xfa, 0x85, 0x53, 0x2b, 0x73, 0xde, 0xef, 0xd, 0xfe, 0x60, 0x1d, 0x26, 0x30, 0x63, 0x23, 0x89, 0xd0, 0xfa, 0xb2, 0xa1, 0x9, 0x21, 0x4d, 0x32, 0x50, 0x8d, 0x23, 0x91, 0x77, 0x56, 0x65, 0xb8, 0x7a, 0x94, 0xd1, 0xdf, 0x29, 0xdb, 0x12, 0x14, 0xcb, 0x48, 0xde, 0xc1, 0xd, 0xbd, 0x3d, 0x8c, 0xf5, 0x91}},
+       testcase{
+               msg:       []byte{0xd1, 0x6b, 0xea, 0xdf, 0x2, 0xab, 0x1d, 0x4d, 0xc6, 0xf8, 0x8b, 0x8c, 0x45, 0x54, 0xc5, 0x1e, 0x86, 0x6d, 0xf8, 0x30, 0xb8, 0x9c, 0x6, 0xe7, 0x86, 0xa5, 0xf8, 0x75, 0x7e, 0x89, 0x9, 0x31, 0xa, 0xf5, 0x1c, 0x84, 0xe, 0xfe, 0x8d, 0x20, 0xb3, 0x53, 0x31, 0xf4, 0x35, 0x5d, 0x80, 0xf7, 0x32, 0x95, 0x97, 0x46, 0x53, 0xdd, 0xd6, 0x20, 0xcd, 0xde, 0x47, 0x30, 0xfb, 0x6c, 0x8d, 0xd, 0x2d, 0xcb, 0x2b, 0x45, 0xd9, 0x2d, 0x4f, 0xbd, 0xb5, 0x67, 0xc0, 0xa3, 0xe8, 0x6b, 0xd1, 0xa8, 0xa7, 0x95, 0xaf, 0x26, 0xfb, 0xf2, 0x9f, 0xc6, 0xc6, 0x59, 0x41, 0xcd, 0xdb, 0x9, 0xf, 0xf7, 0xcd, 0x23, 0xa, 0xc5, 0x26, 0x8a, 0xb4, 0x60, 0x6f, 0xcc, 0xba, 0x9e, 0xde, 0xd0, 0xa2, 0xb5, 0xd0, 0x14, 0xee, 0xc, 0x34, 0xf0, 0xb2, 0x88, 0x1a, 0xc0, 0x36, 0xe2, 0x4e, 0x15, 0x1b, 0xe8, 0x9e, 0xeb, 0x6c, 0xd9, 0xa7, 0xa7, 0x90, 0xaf, 0xcc, 0xff, 0x23, 0x4d, 0x7c, 0xb1, 0x1b, 0x99, 0xeb, 0xf5, 0x8c, 0xd0, 0xc5, 0x89, 0xf2, 0xb, 0xda, 0xc4, 0xf9, 0xf0, 0xe2, 0x8f, 0x75, 0xe3, 0xe0, 0x4e, 0x5b, 0x3d, 0xeb, 0xce, 0x60, 0x7a, 0x49, 0x6d, 0x84, 0x8d, 0x67, 0xfa, 0x7b, 0x49, 0x13, 0x2c, 0x71, 0xb8, 0x78, 0xfd, 0x55, 0x57, 0xe0, 0x82, 0xa1, 0x8e, 0xca, 0x1f, 0xbd, 0xa9, 0x4d, 0x4b},
+               output224: []byte{0xb1, 0x57, 0x94, 0x76, 0x97, 0x2d, 0x42, 0xfa, 0x38, 0x8f, 0xee, 0xb8, 0x42, 0x48, 0x34, 0x67, 0x2c, 0x4d, 0x1a, 0x42, 0x25, 0xee, 0x2d, 0xb8, 0x9d, 0xea, 0x73, 0x59},
+               output256: []byte{0x5c, 0x4e, 0x86, 0xa, 0x1, 0x75, 0xc9, 0x2c, 0x1e, 0x6a, 0xf2, 0xcb, 0xb3, 0x8, 0x41, 0x62, 0x40, 0x3c, 0xed, 0x7, 0x3f, 0xaa, 0xc9, 0x1, 0xd0, 0xd3, 0x58, 0xb6, 0xbf, 0x5e, 0xef, 0xa9},
+               output384: []byte{0x6f, 0x42, 0xfa, 0xf8, 0x7d, 0xa6, 0x55, 0x16, 0xfc, 0xc, 0xca, 0x70, 0xa3, 0x85, 0xf2, 0x6e, 0xbd, 0xaa, 0x94, 0xdf, 0x64, 0xaa, 0x5e, 0x7a, 0x31, 0x19, 0xac, 0x18, 0xc6, 0x21, 0x4e, 0x3d, 0xb, 0x61, 0x15, 0x8f, 0xbd, 0x6c, 0x24, 0x87, 0xe0, 0xab, 0xfb, 0xc, 0x6c, 0x85, 0xef, 0x87},
+               output512: []byte{0x46, 0x48, 0xd2, 0x63, 0xb6, 0x8, 0xcf, 0x28, 0xca, 0x65, 0xb2, 0x8a, 0x36, 0x1e, 0xbb, 0x0, 0xe0, 0x78, 0x4c, 0x65, 0xab, 0x1d, 0x55, 0xc4, 0x6a, 0x78, 0x57, 0x37, 0xb6, 0xc8, 0xd8, 0x3d, 0xd5, 0x2e, 0x33, 0x67, 0xd8, 0x98, 0x92, 0x1e, 0xa3, 0x6d, 0xad, 0xa4, 0x2d, 0x89, 0x38, 0x0, 0xd0, 0xbf, 0xcf, 0x86, 0x55, 0x4c, 0xdf, 0x5e, 0x76, 0x30, 0xd6, 0xa, 0x2e, 0x8e, 0xe2, 0x9f}},
+       testcase{
+               msg:       []byte{0x8f, 0x65, 0xf6, 0xbc, 0x59, 0xa8, 0x57, 0x5, 0x1, 0x6e, 0x2b, 0xae, 0x7f, 0xe5, 0x79, 0x80, 0xde, 0x31, 0x27, 0xe5, 0xab, 0x27, 0x5f, 0x57, 0x3d, 0x33, 0x4f, 0x73, 0xf8, 0x60, 0x31, 0x6, 0xec, 0x35, 0x53, 0x1, 0x66, 0x8, 0xef, 0x2d, 0xd6, 0xe6, 0x9b, 0x24, 0xbe, 0xb, 0x71, 0x13, 0xbf, 0x6a, 0x76, 0xb, 0xa6, 0xe9, 0xce, 0x1c, 0x48, 0xf9, 0xe1, 0x86, 0x1, 0x2c, 0xf9, 0x6a, 0x1d, 0x48, 0x49, 0xd7, 0x5d, 0xf5, 0xbb, 0x83, 0x15, 0x38, 0x7f, 0xd7, 0x8e, 0x9e, 0x15, 0x3e, 0x76, 0xf8, 0xba, 0x7e, 0xc6, 0xc8, 0x84, 0x98, 0x10, 0xf5, 0x9f, 0xb4, 0xbb, 0x9b, 0x0, 0x43, 0x18, 0x21, 0xb, 0x37, 0xf1, 0x29, 0x95, 0x26, 0x86, 0x6f, 0x44, 0x5, 0x9e, 0x1, 0x7e, 0x22, 0xe9, 0x6c, 0xbe, 0x41, 0x86, 0x99, 0xd0, 0x14, 0xc6, 0xea, 0x1, 0xc9, 0xf0, 0x3, 0x8b, 0x10, 0x29, 0x98, 0x84, 0xdb, 0xec, 0x31, 0x99, 0xbb, 0x5, 0xad, 0xc9, 0x4e, 0x95, 0x5a, 0x15, 0x33, 0x21, 0x9c, 0x11, 0x15, 0xfe, 0xd0, 0xe5, 0xf2, 0x12, 0x28, 0xb0, 0x71, 0xf4, 0xd, 0xd5, 0x7c, 0x42, 0x40, 0xd9, 0x8d, 0x37, 0xb7, 0x3e, 0x41, 0x2f, 0xe0, 0xfa, 0x47, 0x3, 0x12, 0xd, 0x7c, 0xc, 0x67, 0x97, 0x2e, 0xd2, 0x33, 0xe5, 0xde, 0xb3, 0x0, 0xa2, 0x26, 0x5, 0x47, 0x2f, 0xa3, 0xa3, 0xba, 0x86},
+               output224: []byte{0xa3, 0x2e, 0xc6, 0x96, 0x48, 0xb4, 0xfd, 0x9b, 0xa2, 0x43, 0x1e, 0xd0, 0xfe, 0xf0, 0x36, 0x18, 0x8c, 0x19, 0x78, 0x8d, 0x7d, 0xdf, 0xd, 0x25, 0xb6, 0xb0, 0x3e, 0xcd},
+               output256: []byte{0x27, 0x2b, 0x4f, 0x68, 0x92, 0x63, 0x5, 0x7f, 0xbf, 0x76, 0x5, 0xaa, 0xa6, 0x7a, 0xf0, 0x12, 0xd7, 0x42, 0x26, 0x71, 0x64, 0xc4, 0xfa, 0xb6, 0x80, 0x35, 0xd9, 0x9c, 0x58, 0x29, 0xb4, 0xf0},
+               output384: []byte{0x82, 0xfc, 0x97, 0xee, 0x34, 0xa8, 0xfc, 0xc2, 0x76, 0xae, 0x1c, 0x81, 0x30, 0x55, 0x5c, 0xc2, 0xd3, 0x39, 0xaa, 0x6c, 0xb3, 0x40, 0x3, 0x48, 0x83, 0x78, 0x85, 0x55, 0x29, 0xf9, 0xee, 0x3a, 0xf8, 0x19, 0xec, 0x10, 0x4d, 0xd2, 0xde, 0x30, 0xa, 0xb7, 0xdb, 0xc0, 0x4b, 0x2b, 0x40, 0x17},
+               output512: []byte{0xdb, 0xd3, 0x73, 0x24, 0x40, 0x1, 0x5, 0x95, 0xab, 0x26, 0xf8, 0x4e, 0xfe, 0xb0, 0x77, 0x32, 0x22, 0x7a, 0x7b, 0x7b, 0x52, 0xd6, 0xff, 0x33, 0x9c, 0x7f, 0xf1, 0xb6, 0x44, 0x22, 0x49, 0x20, 0x2a, 0xe3, 0x3a, 0xa, 0xef, 0x51, 0x67, 0xf5, 0xb0, 0x47, 0x4d, 0x74, 0xa5, 0xb5, 0xc, 0xdb, 0x3, 0x3d, 0x6c, 0x5c, 0x72, 0x89, 0x4a, 0x36, 0x86, 0xfe, 0x6e, 0xcb, 0x36, 0xe3, 0x57, 0xf3}},
+       testcase{
+               msg:       []byte{0x84, 0x89, 0x1e, 0x52, 0xe0, 0xd4, 0x51, 0x81, 0x32, 0x10, 0xc3, 0xfd, 0x63, 0x5b, 0x39, 0xa0, 0x3a, 0x6b, 0x7a, 0x73, 0x17, 0xb2, 0x21, 0xa7, 0xab, 0xc2, 0x70, 0xdf, 0xa9, 0x46, 0xc4, 0x26, 0x69, 0xaa, 0xcb, 0xbb, 0xdf, 0x80, 0x1e, 0x15, 0x84, 0xf3, 0x30, 0xe2, 0x8c, 0x72, 0x98, 0x47, 0xea, 0x14, 0x15, 0x2b, 0xd6, 0x37, 0xb3, 0xd0, 0xf2, 0xb3, 0x8b, 0x4b, 0xd5, 0xbf, 0x9c, 0x79, 0x1c, 0x58, 0x80, 0x62, 0x81, 0x10, 0x3a, 0x3e, 0xab, 0xba, 0xed, 0xe5, 0xe7, 0x11, 0xe5, 0x39, 0xe6, 0xa8, 0xb2, 0xcf, 0x29, 0x7c, 0xf3, 0x51, 0xc0, 0x78, 0xb4, 0xfa, 0x8f, 0x7f, 0x35, 0xcf, 0x61, 0xbe, 0xbf, 0x88, 0x14, 0xbf, 0x24, 0x8a, 0x1, 0xd4, 0x1e, 0x86, 0xc5, 0x71, 0x5e, 0xa4, 0xc, 0x63, 0xf7, 0x37, 0x53, 0x79, 0xa7, 0xeb, 0x1d, 0x78, 0xf2, 0x76, 0x22, 0xfb, 0x46, 0x8a, 0xb7, 0x84, 0xaa, 0xab, 0xa4, 0xe5, 0x34, 0xa6, 0xdf, 0xd1, 0xdf, 0x6f, 0xa1, 0x55, 0x11, 0x34, 0x1e, 0x72, 0x5e, 0xd2, 0xe8, 0x7f, 0x98, 0x73, 0x7c, 0xcb, 0x7b, 0x6a, 0x6d, 0xfa, 0xe4, 0x16, 0x47, 0x74, 0x72, 0xb0, 0x46, 0xbf, 0x18, 0x11, 0x18, 0x7d, 0x15, 0x1b, 0xfa, 0x9f, 0x7b, 0x2b, 0xf9, 0xac, 0xdb, 0x23, 0xa3, 0xbe, 0x50, 0x7c, 0xdf, 0x14, 0xcf, 0xdf, 0x51, 0x7d, 0x2c, 0xb5, 0xfb, 0x9e, 0x4a, 0xb6},
+               output224: []byte{0x2b, 0x8c, 0xf4, 0xc8, 0xd9, 0xe6, 0x71, 0x7e, 0xbc, 0xe4, 0xf0, 0x58, 0x4a, 0xda, 0x59, 0xa8, 0xac, 0xdf, 0xab, 0x98, 0xad, 0x7e, 0x33, 0xf3, 0x55, 0xb7, 0x70, 0x95},
+               output256: []byte{0x9b, 0x28, 0xe4, 0x2b, 0x67, 0xef, 0x32, 0xec, 0x80, 0xda, 0x10, 0xa0, 0x7b, 0x0, 0x4e, 0x1d, 0x71, 0xc6, 0xdc, 0xe7, 0x1d, 0x80, 0x13, 0xff, 0xa0, 0x30, 0x5d, 0xd, 0xc, 0xe0, 0x46, 0x9d},
+               output384: []byte{0x75, 0xd1, 0x40, 0xbe, 0x47, 0xe1, 0x16, 0x21, 0x1f, 0x4f, 0x66, 0x8e, 0x5, 0xad, 0xd3, 0x6c, 0x83, 0xb3, 0xe4, 0x81, 0xdf, 0x9f, 0x28, 0x6, 0x4a, 0x41, 0x89, 0x83, 0x35, 0xd9, 0x7c, 0x80, 0x54, 0x71, 0x21, 0x4e, 0x29, 0xc0, 0xb8, 0x49, 0x87, 0x58, 0x45, 0xc9, 0xb8, 0xde, 0x25, 0xe3},
+               output512: []byte{0xc2, 0x4d, 0x40, 0x54, 0x11, 0x8, 0x89, 0x29, 0xc, 0xbc, 0x40, 0xb8, 0x2a, 0xd8, 0x59, 0x92, 0x29, 0xd8, 0xe8, 0x6e, 0x4c, 0xe7, 0x6b, 0xdd, 0xbb, 0xb6, 0xf5, 0x38, 0x62, 0x23, 0x51, 0x2c, 0x9d, 0x7e, 0x0, 0x97, 0x3c, 0x70, 0x64, 0x42, 0xb2, 0xc8, 0xe, 0xdd, 0x20, 0x90, 0x40, 0x67, 0xaf, 0x8e, 0x4e, 0x68, 0x1a, 0xec, 0xbf, 0xad, 0xc6, 0xaa, 0x15, 0xa2, 0xeb, 0xfe, 0x7d, 0xdd}},
+       testcase{
+               msg:       []byte{0xfd, 0xd7, 0xa9, 0x43, 0x3a, 0x3b, 0x4a, 0xfa, 0xbd, 0x7a, 0x3a, 0x5e, 0x34, 0x57, 0xe5, 0x6d, 0xeb, 0xf7, 0x8e, 0x84, 0xb7, 0xa0, 0xb0, 0xca, 0xe, 0x8c, 0x6d, 0x53, 0xbd, 0xc, 0x2d, 0xae, 0x31, 0xb2, 0x70, 0xc, 0x61, 0x28, 0x33, 0x4f, 0x43, 0x98, 0x1b, 0xe3, 0xb2, 0x13, 0xb1, 0xd7, 0xa1, 0x18, 0xd5, 0x9c, 0x7e, 0x6b, 0x64, 0x93, 0xa8, 0x6f, 0x86, 0x6a, 0x16, 0x35, 0xc1, 0x28, 0x59, 0xcf, 0xb9, 0xad, 0x17, 0x46, 0xa, 0x77, 0xb4, 0x52, 0x2a, 0x5c, 0x18, 0x83, 0xc3, 0xd6, 0xac, 0xc8, 0x6e, 0x61, 0x62, 0x66, 0x7e, 0xc4, 0x14, 0xe9, 0xa1, 0x4, 0xaa, 0x89, 0x20, 0x53, 0xa2, 0xb1, 0xd7, 0x21, 0x65, 0xa8, 0x55, 0xba, 0xcd, 0x8f, 0xaf, 0x80, 0x34, 0xa5, 0xdd, 0x9b, 0x71, 0x6f, 0x47, 0xa0, 0x81, 0x8c, 0x9, 0xbb, 0x6b, 0xaf, 0x22, 0xaa, 0x50, 0x3c, 0x6, 0xb4, 0xca, 0x26, 0x1f, 0x55, 0x77, 0x61, 0x98, 0x9d, 0x2a, 0xfb, 0xd8, 0x8b, 0x6a, 0x67, 0x8a, 0xd1, 0x28, 0xaf, 0x68, 0x67, 0x21, 0x7, 0xd0, 0xf1, 0xfc, 0x73, 0xc5, 0xca, 0x74, 0x4, 0x59, 0x29, 0x7b, 0x32, 0x92, 0xb2, 0x81, 0xe9, 0x3b, 0xce, 0xb7, 0x61, 0xbd, 0xe7, 0x22, 0x1c, 0x3a, 0x55, 0x70, 0x8e, 0x5e, 0xc8, 0x44, 0x72, 0xcd, 0xdc, 0xaa, 0x84, 0xec, 0xf2, 0x37, 0x23, 0xcc, 0x9, 0x91, 0x35, 0x5c, 0x62, 0x80},
+               output224: []byte{0xe5, 0x83, 0x84, 0x94, 0x74, 0xf3, 0xc7, 0x59, 0xb7, 0xa3, 0x9, 0x3c, 0x7a, 0xba, 0xdd, 0x61, 0x42, 0x50, 0x73, 0xae, 0xa2, 0x67, 0x8e, 0x27, 0x82, 0x15, 0x70, 0x8d},
+               output256: []byte{0xee, 0x53, 0xf8, 0x3d, 0x2e, 0x2c, 0xcc, 0x31, 0x5c, 0x63, 0x77, 0xea, 0xdd, 0xa5, 0xf4, 0x2f, 0x42, 0xf3, 0xaa, 0xdd, 0x66, 0x4e, 0x3e, 0x89, 0x5c, 0x37, 0xcb, 0xe9, 0xd0, 0xe9, 0xb9, 0xde},
+               output384: []byte{0x1a, 0x4, 0xcd, 0x93, 0x74, 0x7c, 0xa5, 0x83, 0xa5, 0x8a, 0xb4, 0xa8, 0xc7, 0xc8, 0xc7, 0xa3, 0x3f, 0x2, 0x5e, 0xde, 0x1b, 0x2d, 0xd0, 0x80, 0xe5, 0xaf, 0xc, 0x4d, 0xc6, 0x3c, 0x87, 0x15, 0xe4, 0x36, 0xdd, 0x57, 0xff, 0x7f, 0x40, 0x1d, 0xec, 0xef, 0x81, 0x3f, 0x33, 0xd, 0x65, 0x88},
+               output512: []byte{0x4a, 0x64, 0x4, 0xd2, 0x78, 0xa0, 0xba, 0x70, 0x48, 0x8c, 0x18, 0xd7, 0xd1, 0x86, 0x1c, 0xde, 0x26, 0xfd, 0x57, 0xd6, 0x6a, 0x9a, 0xff, 0xe7, 0x4f, 0x1e, 0x64, 0x6e, 0x61, 0x60, 0x3, 0xa5, 0x2f, 0xe4, 0x25, 0x20, 0x50, 0x4a, 0xc4, 0xac, 0xe5, 0xca, 0x66, 0x65, 0xcf, 0x91, 0x55, 0xf4, 0x4e, 0xca, 0xa0, 0x5d, 0x55, 0xf8, 0xf, 0xe9, 0x79, 0x4a, 0xde, 0x17, 0x87, 0x1c, 0x57, 0x28}},
+       testcase{
+               msg:       []byte{0x70, 0xa4, 0xb, 0xfb, 0xef, 0x92, 0x27, 0x7a, 0x1a, 0xad, 0x72, 0xf6, 0xb7, 0x9d, 0x1, 0x77, 0x19, 0x7c, 0x4e, 0xbd, 0x43, 0x26, 0x68, 0xcf, 0xec, 0x5, 0xd0, 0x99, 0xac, 0xcb, 0x65, 0x10, 0x62, 0xb5, 0xdf, 0xf1, 0x56, 0xc0, 0xb2, 0x73, 0x36, 0x68, 0x7a, 0x94, 0xb2, 0x66, 0x79, 0xcf, 0xdd, 0x9d, 0xaf, 0x7a, 0xd2, 0x4, 0x33, 0x8d, 0xd9, 0xc4, 0xd1, 0x41, 0x14, 0x3, 0x3a, 0x5c, 0x22, 0x5b, 0xd1, 0x1f, 0x21, 0x7b, 0x5f, 0x47, 0x32, 0xda, 0x16, 0x7e, 0xe3, 0xf9, 0x39, 0x26, 0x2d, 0x40, 0x43, 0xfc, 0x9c, 0xba, 0x92, 0x30, 0x3b, 0x7b, 0x5e, 0x96, 0xae, 0xa1, 0x2a, 0xdd, 0xa6, 0x48, 0x59, 0xdf, 0x4b, 0x86, 0xe9, 0xee, 0xb, 0x58, 0xe3, 0x90, 0x91, 0xe6, 0xb1, 0x88, 0xb4, 0x8, 0xac, 0x94, 0xe1, 0x29, 0x4a, 0x89, 0x11, 0x24, 0x5e, 0xe3, 0x61, 0xe6, 0xe, 0x60, 0x1e, 0xff, 0x58, 0xd1, 0xd3, 0x76, 0x39, 0xf3, 0x75, 0x3b, 0xec, 0x80, 0xeb, 0xb4, 0xef, 0xde, 0x25, 0x81, 0x74, 0x36, 0x7, 0x66, 0x23, 0xfc, 0x65, 0x41, 0x5f, 0xe5, 0x1d, 0x1b, 0x2, 0x80, 0x36, 0x6d, 0x12, 0xc5, 0x54, 0xd8, 0x67, 0x43, 0xf3, 0xc3, 0xb6, 0x57, 0x2e, 0x40, 0x3, 0x61, 0xa6, 0x7, 0x26, 0x13, 0x14, 0x41, 0xba, 0x49, 0x3a, 0x83, 0xfb, 0xe9, 0xaf, 0xda, 0x90, 0xf7, 0xaf, 0x1a, 0xe7, 0x17, 0x23, 0x8d},
+               output224: []byte{0x10, 0x79, 0x5d, 0x3a, 0xbc, 0xc0, 0x77, 0xf4, 0xa1, 0xf5, 0xb5, 0x65, 0x3c, 0x47, 0x8f, 0x9d, 0xb4, 0x21, 0x10, 0xea, 0x9f, 0x34, 0x92, 0x54, 0x70, 0xb3, 0xcd, 0x11},
+               output256: []byte{0x21, 0xcc, 0xfd, 0xa6, 0x5c, 0x4b, 0x91, 0x53, 0x3, 0x1, 0x2b, 0x85, 0x2a, 0xb2, 0x94, 0x81, 0x3, 0xf, 0x87, 0x34, 0x7c, 0x29, 0x91, 0x7e, 0x21, 0xf2, 0x10, 0xf2, 0xbd, 0x5e, 0xfc, 0x9c},
+               output384: []byte{0xfb, 0x6, 0x26, 0xf2, 0xb1, 0x89, 0x67, 0x9d, 0xd9, 0x98, 0xbc, 0x18, 0xf3, 0xd, 0xf8, 0x2d, 0x9, 0x7, 0xb6, 0x2a, 0xa7, 0x7c, 0x86, 0x69, 0xe2, 0x2b, 0x53, 0x86, 0xe, 0x39, 0x88, 0x50, 0x3d, 0x88, 0x48, 0x84, 0x16, 0x3a, 0x56, 0x17, 0x39, 0x25, 0x4c, 0xa1, 0x39, 0x29, 0xb6, 0x9b},
+               output512: []byte{0xff, 0xfd, 0x1b, 0x1e, 0x31, 0x37, 0x7d, 0xff, 0x0, 0xb4, 0x92, 0x29, 0x5b, 0xcc, 0xc7, 0x35, 0x73, 0x3b, 0x2, 0x1f, 0x47, 0xbb, 0x4a, 0xfb, 0xa6, 0x54, 0x9e, 0xa6, 0xc1, 0xba, 0x38, 0x32, 0xe8, 0x58, 0x70, 0x99, 0xad, 0xc, 0xc2, 0x16, 0xaf, 0x58, 0x99, 0xac, 0x68, 0x3e, 0xb7, 0xc2, 0x46, 0x87, 0x1e, 0x21, 0xc3, 0xf, 0xee, 0xf9, 0xbc, 0xee, 0xdf, 0xc7, 0x8d, 0xc, 0x96, 0x6c}},
+       testcase{
+               msg:       []byte{0x74, 0x35, 0x6e, 0x44, 0x9f, 0x4b, 0xf8, 0x64, 0x4f, 0x77, 0xb1, 0x4f, 0x4d, 0x67, 0xcb, 0x6b, 0xd9, 0xc1, 0xf5, 0xae, 0x35, 0x76, 0x21, 0xd5, 0xb8, 0x14, 0x7e, 0x56, 0x2b, 0x65, 0xc6, 0x65, 0x85, 0xca, 0xf2, 0xe4, 0x91, 0xb4, 0x85, 0x29, 0xa0, 0x1a, 0x34, 0xd2, 0x26, 0xd4, 0x36, 0x95, 0x91, 0x53, 0x81, 0x53, 0x80, 0xd5, 0x68, 0x9e, 0x30, 0xb3, 0x53, 0x57, 0xcd, 0xac, 0x6e, 0x8, 0xd3, 0xf2, 0xb0, 0xe8, 0x8e, 0x20, 0x6, 0x0, 0xd6, 0x2b, 0xd9, 0xf5, 0xea, 0xf4, 0x88, 0xdf, 0x86, 0xa4, 0x47, 0xe, 0xa2, 0x27, 0x0, 0x61, 0x82, 0xe4, 0x48, 0x9, 0x0, 0x98, 0x68, 0xc4, 0xc2, 0x80, 0xc4, 0x3d, 0x7d, 0x64, 0xa5, 0x26, 0x8f, 0xa7, 0x19, 0x7, 0x49, 0x60, 0x8, 0x7b, 0x3a, 0x6a, 0xbc, 0x83, 0x78, 0x82, 0xf8, 0x82, 0xc8, 0x37, 0x83, 0x45, 0x35, 0x92, 0x93, 0x89, 0xa1, 0x2b, 0x2c, 0x78, 0x18, 0x7e, 0x2e, 0xa0, 0x7e, 0xf8, 0xb8, 0xee, 0xf2, 0x7d, 0xc8, 0x50, 0x2, 0xc3, 0xae, 0x35, 0xf1, 0xa5, 0xb, 0xee, 0x6a, 0x1c, 0x48, 0xba, 0x7e, 0x17, 0x5f, 0x33, 0x16, 0x67, 0xb, 0x27, 0x98, 0x34, 0x72, 0xaa, 0x6a, 0x61, 0xee, 0xd0, 0xa6, 0x83, 0xa3, 0x9e, 0xe3, 0x23, 0x8, 0x6, 0x20, 0xea, 0x44, 0xa9, 0xf7, 0x44, 0x11, 0xae, 0x5c, 0xe9, 0x90, 0x30, 0x52, 0x8f, 0x9a, 0xb4, 0x9c, 0x79, 0xf2},
+               output224: []byte{0x31, 0xa8, 0x43, 0xb4, 0xa9, 0xf3, 0x32, 0xf3, 0xb6, 0xb0, 0x99, 0x84, 0x35, 0x40, 0xaa, 0x70, 0x65, 0x1b, 0x26, 0xb8, 0xe, 0xb, 0xd7, 0x5b, 0x77, 0xf3, 0xaa, 0x9b},
+               output256: []byte{0xf5, 0xbf, 0x70, 0x71, 0xd, 0xa4, 0x40, 0xed, 0xb4, 0x3a, 0xfd, 0x3e, 0xb7, 0x69, 0x81, 0x80, 0x31, 0x7f, 0xfe, 0xfa, 0x81, 0x40, 0x6b, 0xb4, 0xdf, 0x9c, 0x2b, 0xb8, 0xb0, 0xb1, 0xc0, 0x34},
+               output384: []byte{0xcc, 0x2e, 0xf9, 0x60, 0x2f, 0x80, 0xd0, 0x73, 0x42, 0x95, 0xc7, 0xc1, 0x58, 0xec, 0x36, 0x66, 0x8, 0xcf, 0x60, 0xa4, 0x23, 0xd0, 0x83, 0x66, 0x44, 0xb6, 0x8, 0x31, 0xa9, 0x4e, 0x7e, 0xaf, 0x99, 0x4c, 0x81, 0xf1, 0x91, 0x74, 0xfd, 0x6c, 0xa7, 0x5b, 0xb2, 0x46, 0xbb, 0xcc, 0xa2, 0x0},
+               output512: []byte{0x33, 0xc8, 0xf4, 0xe, 0x1b, 0xd1, 0xeb, 0x1a, 0x3a, 0x70, 0xd2, 0x7, 0x1d, 0x27, 0x46, 0xe, 0xf0, 0xf6, 0xb2, 0xd3, 0xec, 0xe3, 0x73, 0x74, 0x38, 0x42, 0xd6, 0xb9, 0x28, 0xf3, 0x77, 0x1e, 0x4b, 0x74, 0x46, 0xa9, 0xec, 0xfb, 0xbf, 0x55, 0x2c, 0x6, 0x4f, 0x6b, 0x26, 0x9, 0x54, 0x1, 0x9, 0x75, 0x81, 0xc3, 0x8b, 0x95, 0xe9, 0x55, 0x11, 0x19, 0xa1, 0xfd, 0xcb, 0x3d, 0x58, 0xe7}},
+       testcase{
+               msg:       []byte{0x8c, 0x37, 0x98, 0xe5, 0x1b, 0xc6, 0x84, 0x82, 0xd7, 0x33, 0x7d, 0x3a, 0xbb, 0x75, 0xdc, 0x9f, 0xfe, 0x86, 0x7, 0x14, 0xa9, 0xad, 0x73, 0x55, 0x1e, 0x12, 0x0, 0x59, 0x86, 0xd, 0xde, 0x24, 0xab, 0x87, 0x32, 0x72, 0x22, 0xb6, 0x4c, 0xf7, 0x74, 0x41, 0x5a, 0x70, 0xf7, 0x24, 0xcd, 0xf2, 0x70, 0xde, 0x3f, 0xe4, 0x7d, 0xda, 0x7, 0xb6, 0x1c, 0x9e, 0xf2, 0xa3, 0x55, 0x1f, 0x45, 0xa5, 0x58, 0x48, 0x60, 0x24, 0x8f, 0xab, 0xde, 0x67, 0x6e, 0x1c, 0xd7, 0x5f, 0x63, 0x55, 0xaa, 0x3e, 0xae, 0xab, 0xe3, 0xb5, 0x1d, 0xc8, 0x13, 0xd9, 0xfb, 0x2e, 0xaa, 0x4f, 0xf, 0x1d, 0x9f, 0x83, 0x4d, 0x7c, 0xad, 0x9c, 0x7c, 0x69, 0x5a, 0xe8, 0x4b, 0x32, 0x93, 0x85, 0xbc, 0xb, 0xef, 0x89, 0x5b, 0x9f, 0x1e, 0xdf, 0x44, 0xa0, 0x3d, 0x4b, 0x41, 0xc, 0xc2, 0x3a, 0x79, 0xa6, 0xb6, 0x2e, 0x4f, 0x34, 0x6a, 0x5e, 0x8d, 0xd8, 0x51, 0xc2, 0x85, 0x79, 0x95, 0xdd, 0xbf, 0x5b, 0x2d, 0x71, 0x7a, 0xeb, 0x84, 0x73, 0x10, 0xe1, 0xf6, 0xa4, 0x6a, 0xc3, 0xd2, 0x6a, 0x7f, 0x9b, 0x44, 0x98, 0x5a, 0xf6, 0x56, 0xd2, 0xb7, 0xc9, 0x40, 0x6e, 0x8a, 0x9e, 0x8f, 0x47, 0xdc, 0xb4, 0xef, 0x6b, 0x83, 0xca, 0xac, 0xf9, 0xae, 0xfb, 0x61, 0x18, 0xbf, 0xcf, 0xf7, 0xe4, 0x4b, 0xef, 0x69, 0x37, 0xeb, 0xdd, 0xc8, 0x91, 0x86, 0x83, 0x9b, 0x77},
+               output224: []byte{0x10, 0x29, 0xca, 0x11, 0x79, 0x57, 0xd8, 0xf, 0x3c, 0x85, 0x9e, 0x83, 0x94, 0xdd, 0x34, 0x96, 0x93, 0x31, 0xca, 0x3b, 0xce, 0xdc, 0x43, 0x6b, 0x1e, 0xab, 0x8, 0x49},
+               output256: []byte{0xe8, 0x3e, 0xa2, 0x1f, 0x5b, 0xc0, 0x97, 0x69, 0x53, 0xaf, 0x86, 0x6, 0x9a, 0x10, 0xeb, 0x60, 0x24, 0xa1, 0xac, 0x59, 0xd6, 0x9, 0x68, 0x8e, 0x4a, 0x97, 0x59, 0xbb, 0x8b, 0x6c, 0x94, 0x41},
+               output384: []byte{0xb5, 0xa7, 0x16, 0x1, 0x12, 0xe0, 0x82, 0x5a, 0x7c, 0x3, 0x64, 0x3b, 0xeb, 0x98, 0xb1, 0xfc, 0x25, 0x49, 0xb8, 0x1f, 0x1, 0xc3, 0xc4, 0x27, 0x1d, 0xff, 0x99, 0xbe, 0x57, 0xd4, 0x72, 0xa7, 0xfa, 0xd1, 0x33, 0x80, 0x8d, 0x7d, 0x2d, 0x41, 0x4d, 0x60, 0x11, 0xe9, 0xa2, 0xe8, 0xdf, 0xec},
+               output512: []byte{0x2a, 0x11, 0xcb, 0x69, 0x21, 0xea, 0x66, 0x2a, 0x39, 0xdd, 0xee, 0x79, 0x82, 0xe3, 0xcf, 0x5b, 0x31, 0x71, 0x95, 0x66, 0x1d, 0x55, 0x5, 0xad, 0x4, 0xd1, 0x1e, 0xe2, 0x3e, 0x17, 0x8e, 0xd6, 0x5f, 0x3e, 0x6, 0xa7, 0xf0, 0x96, 0xf4, 0xea, 0xf1, 0xff, 0x6a, 0x9, 0x23, 0x9c, 0xf5, 0xa0, 0xa3, 0x9d, 0xc9, 0xf4, 0xc9, 0x2a, 0xf6, 0x3f, 0xdf, 0x72, 0x11, 0xe1, 0xcf, 0x46, 0x76, 0x53}},
+       testcase{
+               msg:       []byte{0xfa, 0x56, 0xbf, 0x73, 0xc, 0x4f, 0x83, 0x95, 0x87, 0x51, 0x89, 0xc1, 0xc, 0x4f, 0xb2, 0x51, 0x60, 0x57, 0x57, 0xa8, 0xfe, 0xcc, 0x31, 0xf9, 0x73, 0x7e, 0x3c, 0x25, 0x3, 0xb0, 0x26, 0x8, 0xe6, 0x73, 0x1e, 0x85, 0xd7, 0xa3, 0x83, 0x93, 0xc6, 0x7d, 0xe5, 0x16, 0xb8, 0x53, 0x4, 0x82, 0x4b, 0xfb, 0x13, 0x5e, 0x33, 0xbf, 0x22, 0xb3, 0xa2, 0x3b, 0x91, 0x3b, 0xf6, 0xac, 0xd2, 0xb7, 0xab, 0x85, 0x19, 0x8b, 0x81, 0x87, 0xb2, 0xbc, 0xd4, 0x54, 0xd5, 0xe3, 0x31, 0x8c, 0xac, 0xb3, 0x2f, 0xd6, 0x26, 0x1c, 0x31, 0xae, 0x7f, 0x6c, 0x54, 0xef, 0x6a, 0x7a, 0x2a, 0x4c, 0x9f, 0x3e, 0xcb, 0x81, 0xce, 0x35, 0x55, 0xd4, 0xf0, 0xad, 0x46, 0x6d, 0xd4, 0xc1, 0x8, 0xa9, 0x3, 0x99, 0xd7, 0x0, 0x41, 0x99, 0x7c, 0x3b, 0x25, 0x34, 0x5a, 0x96, 0x53, 0xf3, 0xc9, 0xa6, 0x71, 0x1a, 0xb1, 0xb9, 0x1d, 0x6a, 0x9d, 0x22, 0x16, 0x44, 0x2d, 0xa2, 0xc9, 0x73, 0xcb, 0xd6, 0x85, 0xee, 0x76, 0x43, 0xbf, 0xd7, 0x73, 0x27, 0xa2, 0xf7, 0xae, 0x9c, 0xb2, 0x83, 0x62, 0xa, 0x8, 0x71, 0x6d, 0xfb, 0x46, 0x2e, 0x5c, 0x1d, 0x65, 0x43, 0x2c, 0xa9, 0xd5, 0x6a, 0x90, 0xe8, 0x11, 0x44, 0x3c, 0xd1, 0xec, 0xb8, 0xf0, 0xde, 0x17, 0x9c, 0x9c, 0xb4, 0x8b, 0xa4, 0xf6, 0xfe, 0xc3, 0x60, 0xc6, 0x6f, 0x25, 0x2f, 0x6e, 0x64, 0xed, 0xc9, 0x6b},
+               output224: []byte{0x60, 0x96, 0xe9, 0x91, 0x4c, 0x1a, 0xc9, 0x3a, 0x68, 0x9, 0xde, 0x7a, 0xd9, 0x11, 0x19, 0xc6, 0x37, 0xb0, 0xb, 0xbd, 0x64, 0xdc, 0xc3, 0xe1, 0xfa, 0xc1, 0xe1, 0xed},
+               output256: []byte{0xa2, 0xd9, 0x3c, 0x63, 0x67, 0xe1, 0x86, 0x28, 0x9, 0xd3, 0x67, 0xec, 0x37, 0xf9, 0xda, 0x44, 0xcb, 0x3a, 0x8b, 0x43, 0x19, 0xc6, 0xa0, 0x94, 0xc5, 0xe7, 0xd7, 0x26, 0x6f, 0xe3, 0xa5, 0x93},
+               output384: []byte{0xe7, 0xb3, 0x11, 0x8d, 0x7f, 0xca, 0x9d, 0x29, 0x4f, 0x59, 0x6d, 0x82, 0xf, 0x46, 0x8c, 0xd9, 0x2, 0x79, 0x20, 0x77, 0x7a, 0x41, 0xa7, 0x6, 0xed, 0xe8, 0x77, 0xcb, 0xeb, 0x95, 0x17, 0xf2, 0x23, 0xb2, 0x68, 0xc5, 0xe8, 0x5, 0xa3, 0x74, 0x5, 0x18, 0x22, 0x69, 0x2e, 0x9a, 0xb4, 0x4b},
+               output512: []byte{0x91, 0x96, 0xbb, 0xbd, 0x19, 0x45, 0x41, 0xff, 0xee, 0x7e, 0xdb, 0xab, 0x97, 0x7, 0x38, 0xbd, 0xd3, 0xaa, 0xdb, 0xd6, 0xb7, 0x3d, 0x1c, 0x85, 0xb5, 0x80, 0xaf, 0xac, 0x12, 0x32, 0xae, 0x80, 0x77, 0xf7, 0x43, 0xce, 0x8b, 0x5b, 0x6f, 0x2b, 0x41, 0x8b, 0x51, 0x34, 0xcc, 0xcd, 0x4f, 0x83, 0x64, 0x5e, 0x86, 0x31, 0x88, 0x5b, 0x14, 0xfb, 0xbc, 0xb9, 0x9, 0xa9, 0x83, 0x6c, 0x37, 0x4c}},
+       testcase{
+               msg:       []byte{0xb6, 0x13, 0x4f, 0x9c, 0x3e, 0x91, 0xdd, 0x80, 0x0, 0x74, 0xd, 0x0, 0x9d, 0xd8, 0x6, 0x24, 0x8, 0x11, 0xd5, 0x1a, 0xb1, 0x54, 0x6a, 0x97, 0x4b, 0xcb, 0x18, 0xd3, 0x44, 0x64, 0x2b, 0xaa, 0x5c, 0xd5, 0x90, 0x3a, 0xf8, 0x4d, 0x58, 0xec, 0x5b, 0xa1, 0x73, 0x1, 0xd5, 0xec, 0xf, 0x10, 0xcc, 0xd0, 0x50, 0x9c, 0xbb, 0x3f, 0xd3, 0xff, 0xf9, 0x17, 0x2d, 0x19, 0x3a, 0xf0, 0xf7, 0x82, 0x25, 0x2f, 0xd1, 0x33, 0x8c, 0x72, 0x44, 0xd4, 0xe, 0xe, 0x42, 0x36, 0x22, 0x75, 0xb2, 0x2d, 0x1, 0xc4, 0xc3, 0x38, 0x9f, 0x19, 0xdd, 0x69, 0xbd, 0xf9, 0x58, 0xeb, 0xe2, 0x8e, 0x31, 0xa4, 0xff, 0xe2, 0xb5, 0xf1, 0x8a, 0x87, 0x83, 0x1c, 0xfb, 0x70, 0x95, 0xf5, 0x8a, 0x87, 0xc9, 0xfa, 0x21, 0xdb, 0x72, 0xba, 0x26, 0x93, 0x79, 0xb2, 0xdc, 0x23, 0x84, 0xb3, 0xda, 0x95, 0x3c, 0x79, 0x25, 0x76, 0x1f, 0xed, 0x32, 0x46, 0x20, 0xac, 0xea, 0x43, 0x5e, 0x52, 0xb4, 0x24, 0xa7, 0x72, 0x3f, 0x6a, 0x23, 0x57, 0x37, 0x41, 0x57, 0xa3, 0x4c, 0xd8, 0x25, 0x23, 0x51, 0xc2, 0x5a, 0x1b, 0x23, 0x28, 0x26, 0xce, 0xfe, 0x1b, 0xd3, 0xe7, 0xf, 0xfc, 0x15, 0xa3, 0x1e, 0x7c, 0x5, 0x98, 0x21, 0x9d, 0x7f, 0x0, 0x43, 0x62, 0x94, 0xd1, 0x18, 0x91, 0xb8, 0x24, 0x97, 0xbc, 0x78, 0xaa, 0x53, 0x63, 0x89, 0x2a, 0x24, 0x95, 0xdf, 0x8c, 0x1e, 0xef},
+               output224: []byte{0xf5, 0x83, 0xf0, 0x7d, 0xf2, 0x32, 0x78, 0x87, 0xc6, 0xf1, 0xa, 0x9b, 0x1d, 0x50, 0x9a, 0x74, 0x4f, 0x3c, 0x29, 0x4a, 0x42, 0x27, 0x97, 0x6e, 0x3c, 0x37, 0x22, 0xe8},
+               output256: []byte{0x3c, 0x64, 0x7b, 0x19, 0x5f, 0x22, 0xdc, 0x16, 0xd6, 0xde, 0xcc, 0x88, 0x73, 0x1, 0x7d, 0xf3, 0x69, 0xee, 0x1c, 0x46, 0x96, 0x34, 0x9, 0x34, 0xdb, 0x15, 0x8d, 0xc4, 0x5, 0x9c, 0x76, 0xdf},
+               output384: []byte{0xc3, 0xfa, 0x6c, 0x9d, 0xf, 0xf2, 0x31, 0x19, 0x8a, 0xec, 0xa8, 0xe, 0xa4, 0x28, 0xac, 0x4b, 0x32, 0xc4, 0x81, 0xd3, 0x90, 0xce, 0x4a, 0x90, 0xd0, 0xf6, 0x5f, 0xf7, 0xd5, 0x8f, 0x69, 0x6c, 0x1f, 0xaa, 0xda, 0x16, 0x73, 0xd7, 0xe2, 0xd1, 0x61, 0x46, 0x2c, 0x95, 0xc2, 0xe2, 0xa3, 0x10},
+               output512: []byte{0x19, 0x59, 0xca, 0xe3, 0x60, 0xf, 0x12, 0x8f, 0x72, 0xe1, 0x82, 0x1c, 0x33, 0x7d, 0x84, 0x1b, 0x14, 0xcb, 0xbf, 0xef, 0x3a, 0x6d, 0x22, 0x28, 0x6f, 0x18, 0xbd, 0xfc, 0x3e, 0xf6, 0x35, 0x28, 0xc1, 0x1b, 0xff, 0xa8, 0x41, 0xa6, 0xd2, 0x20, 0x8a, 0xfe, 0xb5, 0x66, 0x4d, 0x52, 0x4d, 0xe8, 0x30, 0x90, 0xab, 0xd, 0xb0, 0x7c, 0xd4, 0x7e, 0xf5, 0x2f, 0x4d, 0x2e, 0xaa, 0x84, 0x54, 0xce}},
+       testcase{
+               msg:       []byte{0xc9, 0x41, 0xcd, 0xb9, 0xc2, 0x8a, 0xb0, 0xa7, 0x91, 0xf2, 0xe5, 0xc8, 0xe8, 0xbb, 0x52, 0x85, 0x6, 0x26, 0xaa, 0x89, 0x20, 0x5b, 0xec, 0x3a, 0x7e, 0x22, 0x68, 0x23, 0x13, 0xd1, 0x98, 0xb1, 0xfa, 0x33, 0xfc, 0x72, 0x95, 0x38, 0x13, 0x54, 0x85, 0x87, 0x58, 0xae, 0x6c, 0x8e, 0xc6, 0xfa, 0xc3, 0x24, 0x5c, 0x6e, 0x45, 0x4d, 0x16, 0xfa, 0x2f, 0x51, 0xc4, 0x16, 0x6f, 0xab, 0x51, 0xdf, 0x27, 0x28, 0x58, 0xf2, 0xd6, 0x3, 0x77, 0xc, 0x40, 0x98, 0x7f, 0x64, 0x44, 0x2d, 0x48, 0x7a, 0xf4, 0x9c, 0xd5, 0xc3, 0x99, 0x1c, 0xe8, 0x58, 0xea, 0x2a, 0x60, 0xda, 0xb6, 0xa6, 0x5a, 0x34, 0x41, 0x49, 0x65, 0x93, 0x39, 0x73, 0xac, 0x24, 0x57, 0x8, 0x9e, 0x35, 0x91, 0x60, 0xb7, 0xcd, 0xed, 0xc4, 0x2f, 0x29, 0xe1, 0xa, 0x91, 0x92, 0x17, 0x85, 0xf6, 0xb7, 0x22, 0x4e, 0xe0, 0xb3, 0x49, 0x39, 0x3c, 0xdc, 0xff, 0x61, 0x51, 0xb5, 0xb, 0x37, 0x7d, 0x60, 0x95, 0x59, 0x92, 0x3d, 0x9, 0x84, 0xcd, 0xa6, 0x0, 0x8, 0x29, 0xb9, 0x16, 0xab, 0x68, 0x96, 0x69, 0x3e, 0xf6, 0xa2, 0x19, 0x9b, 0x3c, 0x22, 0xf7, 0xdc, 0x55, 0x0, 0xa1, 0x5b, 0x82, 0x58, 0x42, 0xe, 0x31, 0x4c, 0x22, 0x2b, 0xc0, 0x0, 0xbc, 0x4e, 0x54, 0x13, 0xe6, 0xdd, 0x82, 0xc9, 0x93, 0xf8, 0x33, 0xf, 0x5c, 0x6d, 0x1b, 0xe4, 0xbc, 0x79, 0xf0, 0x8a, 0x1a, 0xa, 0x46},
+               output224: []byte{0xa9, 0xf4, 0x3b, 0x96, 0x21, 0xfc, 0x59, 0x2, 0xdf, 0x24, 0x58, 0xfd, 0x53, 0xd0, 0xcd, 0xe9, 0xa, 0xae, 0x70, 0x0, 0x85, 0x5c, 0x67, 0xd8, 0x53, 0xc7, 0x93, 0x7a},
+               output256: []byte{0x3b, 0xb3, 0x94, 0xd0, 0x56, 0xd9, 0x4f, 0xde, 0x68, 0x92, 0xc, 0xd3, 0x83, 0x37, 0x8e, 0xe3, 0xab, 0xcc, 0x44, 0xb7, 0x25, 0x9d, 0x3d, 0xb9, 0xcd, 0xa, 0x89, 0x7e, 0x2, 0x1f, 0x7e, 0x2e},
+               output384: []byte{0xc4, 0xbd, 0x11, 0x57, 0xc0, 0x93, 0xac, 0xb2, 0x7b, 0xd3, 0xbd, 0x7f, 0x44, 0x4f, 0x83, 0x6b, 0xfc, 0xba, 0xd, 0xaf, 0xe1, 0x16, 0x75, 0x10, 0x4c, 0x64, 0x37, 0xe5, 0x98, 0x14, 0x42, 0xbe, 0x99, 0x9c, 0x86, 0xd, 0xd6, 0xe1, 0xb7, 0x5f, 0xaf, 0x6a, 0x55, 0x3e, 0x90, 0x7b, 0x61, 0xee},
+               output512: []byte{0xa9, 0x13, 0xdd, 0xc5, 0xbb, 0x8, 0x9c, 0x12, 0x1f, 0xf0, 0x93, 0xbe, 0x52, 0x92, 0x25, 0x14, 0x8d, 0xf7, 0x87, 0xd4, 0x8f, 0x4f, 0x61, 0x69, 0x9e, 0xff, 0x9f, 0xc2, 0x91, 0x2, 0x82, 0xa8, 0x98, 0xa8, 0x1a, 0x38, 0xd6, 0x6b, 0xe9, 0xb0, 0x64, 0x28, 0xd6, 0x46, 0x6a, 0x61, 0x4c, 0xa8, 0x22, 0xa8, 0x72, 0xc1, 0xc2, 0xc4, 0xd5, 0x3, 0xd4, 0x34, 0xd3, 0xb1, 0xd6, 0x94, 0x21, 0x2}},
+       testcase{
+               msg:       []byte{0x44, 0x99, 0xef, 0xff, 0xac, 0x4b, 0xce, 0xa5, 0x27, 0x47, 0xef, 0xd1, 0xe4, 0xf2, 0xb, 0x73, 0xe4, 0x87, 0x58, 0xbe, 0x91, 0x5c, 0x88, 0xa1, 0xff, 0xe5, 0x29, 0x9b, 0xb, 0x0, 0x58, 0x37, 0xa4, 0x6b, 0x2f, 0x20, 0xa9, 0xcb, 0x3c, 0x6e, 0x64, 0xa9, 0xe3, 0xc5, 0x64, 0xa2, 0x7c, 0xf, 0x1c, 0x6a, 0xd1, 0x96, 0x3, 0x73, 0x3, 0x6e, 0xc5, 0xbf, 0xe1, 0xa8, 0xfc, 0x6a, 0x43, 0x5c, 0x21, 0x85, 0xed, 0xf, 0x11, 0x4c, 0x50, 0xe8, 0xb3, 0xe4, 0xc7, 0xed, 0x96, 0xb0, 0x6a, 0x3, 0x68, 0x19, 0xc9, 0x46, 0x3e, 0x86, 0x4a, 0x58, 0xd6, 0x28, 0x6f, 0x78, 0x5e, 0x32, 0xa8, 0x4, 0x44, 0x3a, 0x56, 0xaf, 0xb, 0x4d, 0xf6, 0xab, 0xc5, 0x7e, 0xd5, 0xc2, 0xb1, 0x85, 0xdd, 0xee, 0x84, 0x89, 0xea, 0x8, 0xd, 0xee, 0xee, 0x66, 0xaa, 0x33, 0xc2, 0xe6, 0xda, 0xb3, 0x62, 0x51, 0xc4, 0x2, 0x68, 0x2b, 0x68, 0x24, 0x82, 0x1f, 0x99, 0x8c, 0x32, 0x16, 0x31, 0x64, 0x29, 0x8e, 0x1f, 0xaf, 0xd3, 0x1b, 0xab, 0xbc, 0xff, 0xb5, 0x94, 0xc9, 0x18, 0x88, 0xc6, 0x21, 0x90, 0x79, 0xd9, 0x7, 0xfd, 0xb4, 0x38, 0xed, 0x89, 0x52, 0x9d, 0x6d, 0x96, 0x21, 0x2f, 0xd5, 0x5a, 0xbe, 0x20, 0x39, 0x9d, 0xbe, 0xfd, 0x34, 0x22, 0x48, 0x50, 0x74, 0x36, 0x93, 0x1c, 0xde, 0xad, 0x49, 0x6e, 0xb6, 0xe4, 0xa8, 0x3, 0x58, 0xac, 0xc7, 0x86, 0x47, 0xd0, 0x43},
+               output224: []byte{0xe9, 0x67, 0x5f, 0xaa, 0xc3, 0x7c, 0x93, 0xaa, 0x61, 0xff, 0x97, 0x30, 0x67, 0x9a, 0x3d, 0x12, 0x9, 0xad, 0xba, 0xd4, 0x65, 0x25, 0x82, 0xdf, 0xf5, 0xb1, 0xba, 0xaf},
+               output256: []byte{0x43, 0x64, 0xf, 0x40, 0x86, 0x13, 0xcb, 0xf7, 0x39, 0x3d, 0x90, 0xb, 0x92, 0x1f, 0x22, 0xb8, 0x26, 0x35, 0x7f, 0x3b, 0x4f, 0xdf, 0xf7, 0x16, 0x8e, 0xc4, 0x5c, 0xbf, 0xb3, 0xef, 0x5e, 0xff},
+               output384: []byte{0xd0, 0x99, 0xf3, 0xc8, 0x5, 0x2c, 0xaa, 0x2c, 0xf9, 0x75, 0x1b, 0x1e, 0xd2, 0xd4, 0x72, 0xc2, 0x1f, 0xed, 0x66, 0x78, 0x92, 0xbc, 0x1c, 0x41, 0x76, 0x0, 0xa4, 0xc9, 0x3e, 0xff, 0xe8, 0x8f, 0x1b, 0x17, 0xb3, 0x6d, 0x37, 0xe4, 0xd2, 0x6b, 0x9c, 0xd6, 0x5a, 0xcb, 0x13, 0xa6, 0xdb, 0x6f},
+               output512: []byte{0xf1, 0xb, 0x91, 0x56, 0x4a, 0xd9, 0x3d, 0x73, 0x47, 0x43, 0x28, 0x19, 0x49, 0xba, 0xce, 0xf0, 0x65, 0xa6, 0x43, 0x2a, 0x45, 0x52, 0x36, 0xf1, 0xbf, 0x79, 0x8d, 0xe9, 0xae, 0xc6, 0xcc, 0xac, 0x9b, 0x8d, 0x37, 0x3b, 0x7, 0xc5, 0xac, 0xfb, 0xd6, 0x76, 0xef, 0x21, 0xe4, 0xa3, 0xa9, 0xe0, 0xf7, 0xc3, 0x8e, 0x87, 0x56, 0xd1, 0x77, 0xd0, 0xa5, 0xc2, 0x83, 0xd5, 0x20, 0x84, 0x4b, 0x4d}},
+       testcase{
+               msg:       []byte{0xee, 0xcb, 0xb8, 0xfd, 0xfa, 0x4d, 0xa6, 0x21, 0x70, 0xfd, 0x6, 0x72, 0x7f, 0x69, 0x7d, 0x81, 0xf8, 0x3f, 0x60, 0x1f, 0xf6, 0x1e, 0x47, 0x81, 0x5, 0xd3, 0xcb, 0x75, 0x2, 0xf2, 0xc8, 0x9b, 0xf3, 0xe8, 0xf5, 0x6e, 0xdd, 0x46, 0x9d, 0x4, 0x98, 0x7, 0xa3, 0x88, 0x82, 0xa7, 0xee, 0xfb, 0xc8, 0x5f, 0xc9, 0xa9, 0x50, 0x95, 0x2e, 0x9f, 0xa8, 0x4b, 0x8a, 0xfe, 0xbd, 0x3c, 0xe7, 0x82, 0xd4, 0xda, 0x59, 0x80, 0x2, 0x82, 0x7b, 0x1e, 0xb9, 0x88, 0x82, 0xea, 0x1f, 0xa, 0x8f, 0x7a, 0xa9, 0xce, 0x1, 0x3a, 0x6e, 0x9b, 0xc4, 0x62, 0xfb, 0x66, 0xc8, 0xd4, 0xa1, 0x8d, 0xa2, 0x14, 0x1, 0xe1, 0xb9, 0x33, 0x56, 0xeb, 0x12, 0xf3, 0x72, 0x5b, 0x6d, 0xb1, 0x68, 0x4f, 0x23, 0x0, 0xa9, 0x8b, 0x9a, 0x11, 0x9e, 0x5d, 0x27, 0xff, 0x70, 0x4a, 0xff, 0xb6, 0x18, 0xe1, 0x27, 0x8, 0xe7, 0x7e, 0x6e, 0x5f, 0x34, 0x13, 0x9a, 0x5a, 0x41, 0x13, 0x1f, 0xd1, 0xd6, 0x33, 0x6c, 0x27, 0x2a, 0x8f, 0xc3, 0x70, 0x80, 0xf0, 0x41, 0xc7, 0x13, 0x41, 0xbe, 0xe6, 0xab, 0x55, 0xc, 0xb4, 0xa2, 0xa, 0x6d, 0xdb, 0x6a, 0x8e, 0x2, 0x99, 0xf2, 0xb1, 0x4b, 0xc7, 0x30, 0xc5, 0x4b, 0x8b, 0x1c, 0x1c, 0x48, 0x7b, 0x49, 0x4b, 0xdc, 0xcf, 0xd3, 0xa5, 0x35, 0x35, 0xab, 0x2f, 0x23, 0x15, 0x90, 0xbf, 0x2c, 0x40, 0x62, 0xfd, 0x2a, 0xd5, 0x8f, 0x90, 0x6a, 0x2d, 0xd},
+               output224: []byte{0xcd, 0xb5, 0x0, 0x74, 0x8, 0x12, 0xa0, 0xd7, 0xc, 0x68, 0xd0, 0x9, 0x7d, 0xcc, 0x7a, 0xca, 0x86, 0xec, 0x6, 0x6c, 0x89, 0xd3, 0x66, 0x42, 0x87, 0x9a, 0x74, 0xa5},
+               output256: []byte{0xcb, 0x37, 0x13, 0xa5, 0xd5, 0xab, 0xbc, 0x6a, 0xf7, 0x2f, 0x8b, 0x38, 0xa7, 0x1, 0xc7, 0x12, 0x69, 0xb3, 0xb5, 0x1c, 0x62, 0xec, 0x51, 0x16, 0xf9, 0x6a, 0xd0, 0xd4, 0x2a, 0x10, 0xfd, 0x90},
+               output384: []byte{0x7a, 0x9f, 0xe1, 0x3f, 0xe3, 0x31, 0x81, 0x21, 0xba, 0xbb, 0x34, 0xa, 0x3b, 0x4, 0x5d, 0xc8, 0x9d, 0x1b, 0xe2, 0xd0, 0xec, 0x5, 0x80, 0x2c, 0x92, 0x54, 0xfe, 0xc3, 0x9e, 0xfc, 0xde, 0x16, 0x3c, 0x51, 0x4d, 0xcd, 0xba, 0x3f, 0xf9, 0x3f, 0x9b, 0x9, 0x74, 0x86, 0xc2, 0x1, 0x23, 0x85},
+               output512: []byte{0xef, 0x26, 0xa1, 0xba, 0xf3, 0x3d, 0x4d, 0xe0, 0x47, 0xbd, 0xd2, 0xce, 0x34, 0x73, 0x6e, 0x4, 0x2e, 0xcd, 0x33, 0xaa, 0x56, 0x9f, 0xfc, 0xc, 0xb8, 0x1e, 0xcf, 0xa6, 0x6e, 0x9f, 0x87, 0xda, 0x8d, 0x2, 0x5e, 0xcb, 0xa2, 0x4b, 0xcb, 0x18, 0x7e, 0x42, 0x1, 0x4, 0x6f, 0xb9, 0x9a, 0x2, 0xdf, 0xa6, 0xf1, 0xbf, 0x88, 0xec, 0x2b, 0x88, 0xde, 0x21, 0x6c, 0xf7, 0x59, 0xfa, 0xc4, 0x1d}},
+       testcase{
+               msg:       []byte{0xe6, 0x4f, 0x3e, 0x4a, 0xce, 0x5c, 0x84, 0x18, 0xd6, 0x5f, 0xec, 0x2b, 0xc5, 0xd2, 0xa3, 0x3, 0xdd, 0x45, 0x80, 0x34, 0x73, 0x6e, 0x3b, 0xd, 0xf7, 0x19, 0x9, 0x8b, 0xe7, 0xa2, 0x6, 0xde, 0xaf, 0x52, 0xd6, 0xba, 0x82, 0x31, 0x6c, 0xaf, 0x33, 0xe, 0xf8, 0x52, 0x37, 0x51, 0x88, 0xcd, 0xe2, 0xb3, 0x9c, 0xc9, 0x4a, 0xa4, 0x49, 0x57, 0x8a, 0x7e, 0x2a, 0x8e, 0x3f, 0x5a, 0x9d, 0x68, 0xe8, 0x16, 0xb8, 0xd1, 0x68, 0x89, 0xfb, 0xc0, 0xeb, 0xf0, 0x93, 0x9d, 0x4, 0xf6, 0x30, 0x33, 0xae, 0x9a, 0xe2, 0xbd, 0xab, 0x73, 0xb8, 0x8c, 0x26, 0xd6, 0xbd, 0x25, 0xee, 0x46, 0xe, 0xe1, 0xef, 0x58, 0xfb, 0xa, 0xfa, 0x92, 0xcc, 0x53, 0x9f, 0x8c, 0x76, 0xd3, 0xd0, 0x97, 0xe7, 0xa6, 0xa6, 0x3e, 0xbb, 0x9b, 0x58, 0x87, 0xed, 0xf3, 0xcf, 0x7, 0x60, 0x28, 0xc5, 0xbb, 0xd5, 0xb9, 0xdb, 0x32, 0x11, 0x37, 0x1a, 0xd3, 0xfe, 0x12, 0x1d, 0x4e, 0x9b, 0xf4, 0x42, 0x29, 0xf4, 0xe1, 0xec, 0xf5, 0xa0, 0xf9, 0xf0, 0xeb, 0xa4, 0xd5, 0xce, 0xb7, 0x28, 0x78, 0xab, 0x22, 0xc3, 0xf0, 0xeb, 0x5a, 0x62, 0x53, 0x23, 0xac, 0x66, 0xf7, 0x6, 0x1f, 0x4a, 0x81, 0xfa, 0xc8, 0x34, 0x47, 0x1e, 0xc, 0x59, 0x55, 0x3f, 0x10, 0x84, 0x75, 0xfe, 0x29, 0xd, 0x43, 0xe6, 0xa0, 0x55, 0xae, 0x3e, 0xe4, 0x6f, 0xb6, 0x74, 0x22, 0xf8, 0x14, 0xa6, 0x8c, 0x4b, 0xe3, 0xe8, 0xc9},
+               output224: []byte{0x66, 0xf2, 0x5, 0xd7, 0x14, 0x79, 0x91, 0xa9, 0x40, 0xaf, 0xfb, 0x74, 0x1, 0xb6, 0x92, 0x27, 0x53, 0x38, 0x51, 0x9a, 0x97, 0x60, 0x8c, 0x58, 0x43, 0x62, 0xff, 0xee},
+               output256: []byte{0xb3, 0x4, 0xfc, 0x4c, 0xa2, 0x21, 0x31, 0x85, 0x7d, 0x24, 0x2e, 0xb1, 0x2f, 0xe8, 0x99, 0xed, 0x9e, 0x6b, 0x55, 0x71, 0x7c, 0x33, 0x60, 0xf1, 0x13, 0x51, 0x2a, 0x84, 0x17, 0x4e, 0x6a, 0x77},
+               output384: []byte{0x8a, 0xee, 0xde, 0x5d, 0x6e, 0x2f, 0x9f, 0x1c, 0x7a, 0x66, 0x44, 0xa8, 0xda, 0xf, 0x93, 0x57, 0x4d, 0xf8, 0xca, 0x33, 0xb2, 0xed, 0x9d, 0x36, 0x46, 0x15, 0xe1, 0xf9, 0xcf, 0x1a, 0x80, 0x13, 0x15, 0x41, 0x7, 0x33, 0x88, 0x1c, 0xe0, 0xda, 0xd2, 0xf6, 0xfb, 0x5a, 0x91, 0x6a, 0x97, 0xe1},
+               output512: []byte{0xf8, 0xe0, 0x79, 0xa6, 0xdc, 0x5a, 0x6a, 0x7e, 0x7f, 0x32, 0xff, 0x7e, 0x80, 0x15, 0xd1, 0xb2, 0x6d, 0x43, 0xb5, 0x4f, 0x16, 0x6f, 0x21, 0x11, 0xcf, 0xb2, 0xb1, 0xeb, 0x23, 0x8c, 0xab, 0xee, 0x58, 0x63, 0xe, 0xf8, 0x45, 0xe0, 0xdb, 0x0, 0xdd, 0xf1, 0xd8, 0x0, 0xad, 0x67, 0xce, 0x7b, 0x2b, 0x65, 0x8b, 0x42, 0x11, 0x8c, 0xc1, 0x5c, 0x8e, 0xf3, 0xbc, 0x9f, 0xb2, 0x52, 0xdb, 0x64}},
+       testcase{
+               msg:       []byte{0xd2, 0xcb, 0x2d, 0x73, 0x30, 0x33, 0xf9, 0xe9, 0x13, 0x95, 0x31, 0x28, 0x8, 0x38, 0x3c, 0xc4, 0xf0, 0xca, 0x97, 0x4e, 0x87, 0xec, 0x68, 0x40, 0xd, 0x52, 0xe9, 0x6b, 0x3f, 0xa6, 0x98, 0x4a, 0xc5, 0x8d, 0x9a, 0xd0, 0x93, 0x8d, 0xde, 0x5a, 0x97, 0x30, 0x8, 0xd8, 0x18, 0xc4, 0x96, 0x7, 0xd9, 0xde, 0x22, 0x84, 0xe7, 0x61, 0x8f, 0x1b, 0x8a, 0xed, 0x83, 0x72, 0xfb, 0xd5, 0x2e, 0xd5, 0x45, 0x57, 0xaf, 0x42, 0x20, 0xfa, 0xc0, 0x9d, 0xfa, 0x84, 0x43, 0x1, 0x16, 0x99, 0xb9, 0x7d, 0x74, 0x3f, 0x8f, 0x2b, 0x1a, 0xef, 0x35, 0x37, 0xeb, 0xb4, 0x5d, 0xcc, 0x9e, 0x13, 0xdf, 0xb4, 0x38, 0x42, 0x8e, 0xe1, 0x90, 0xa4, 0xef, 0xdb, 0x3c, 0xae, 0xb7, 0xf3, 0x93, 0x31, 0x17, 0xbf, 0x63, 0xab, 0xdc, 0x7e, 0x57, 0xbe, 0xb4, 0x17, 0x1c, 0x7e, 0x1a, 0xd2, 0x60, 0xab, 0x5, 0x87, 0x80, 0x6c, 0x4d, 0x13, 0x7b, 0x63, 0x16, 0xb5, 0xa, 0xbc, 0x9c, 0xce, 0xd, 0xff, 0x3a, 0xca, 0xda, 0x47, 0xbb, 0xb8, 0x6b, 0xe7, 0x77, 0xe6, 0x17, 0xbb, 0xe5, 0x78, 0xff, 0x45, 0x19, 0x84, 0x4d, 0xb3, 0x60, 0xe0, 0xa9, 0x6c, 0x67, 0x1, 0x29, 0xe, 0x76, 0xbb, 0x95, 0xd2, 0x6f, 0xf, 0x80, 0x4c, 0x8a, 0x4f, 0x27, 0x17, 0xea, 0xc4, 0xe7, 0xde, 0x9f, 0x2c, 0xff, 0x3b, 0xbc, 0x55, 0xa1, 0x7e, 0x77, 0x6c, 0xd, 0x2, 0x85, 0x60, 0x32, 0xa6, 0xcd, 0x10, 0xad, 0x28, 0x38},
+               output224: []byte{0x90, 0x9f, 0xb2, 0x92, 0x77, 0xab, 0x2c, 0x4c, 0xe4, 0x27, 0x9c, 0x48, 0x5d, 0x4f, 0xba, 0x7e, 0x18, 0xff, 0x1a, 0x88, 0xc6, 0x6d, 0xaf, 0x7a, 0xcf, 0x63, 0x3, 0x10},
+               output256: []byte{0xa3, 0xca, 0x83, 0xd, 0x47, 0x71, 0xc1, 0xba, 0xa7, 0xfa, 0xda, 0x76, 0xc5, 0xfc, 0xea, 0xdd, 0xf, 0x3c, 0xb9, 0x73, 0x6e, 0x19, 0xcf, 0xec, 0x52, 0xe9, 0xe7, 0x4f, 0x56, 0xbf, 0xdd, 0x55},
+               output384: []byte{0x29, 0xe6, 0x2d, 0x8c, 0x1b, 0x71, 0xf8, 0x26, 0x54, 0x4a, 0xc, 0xbf, 0xcd, 0xd9, 0x9c, 0xf8, 0xaa, 0x1c, 0x97, 0xe1, 0x53, 0x6, 0x31, 0x20, 0xd2, 0x95, 0xed, 0xf6, 0x9e, 0x2e, 0xcb, 0x5a, 0x27, 0x83, 0xc6, 0x67, 0x60, 0xd0, 0xf8, 0x7b, 0xf9, 0x44, 0x51, 0x68, 0x24, 0xcc, 0xfc, 0xb1},
+               output512: []byte{0xa5, 0xbf, 0xaa, 0x52, 0x49, 0x9a, 0x68, 0x8d, 0x9c, 0x8d, 0x3d, 0xdc, 0xb, 0xa0, 0x6d, 0xec, 0xdf, 0x38, 0x29, 0xbe, 0x5d, 0x44, 0x4a, 0xcf, 0xa4, 0x12, 0xf4, 0xc6, 0xe8, 0x63, 0xf4, 0x78, 0x6b, 0xe9, 0x93, 0x58, 0x5, 0x31, 0x7, 0x34, 0xe4, 0xf0, 0xaf, 0xfe, 0x5, 0x55, 0x89, 0x99, 0x80, 0x74, 0x8, 0xe9, 0x7e, 0x10, 0xf, 0xad, 0xd0, 0xc9, 0x3f, 0xf1, 0x60, 0xf8, 0xb1, 0x1b}},
+       testcase{
+               msg:       []byte{0xf2, 0x99, 0x89, 0x55, 0x61, 0x3d, 0xd4, 0x14, 0xcc, 0x11, 0x1d, 0xf5, 0xce, 0x30, 0xa9, 0x95, 0xbb, 0x79, 0x2e, 0x26, 0xb, 0xe, 0x37, 0xa5, 0xb1, 0xd9, 0x42, 0xfe, 0x90, 0x17, 0x1a, 0x4a, 0xc2, 0xf6, 0x6d, 0x49, 0x28, 0xd7, 0xad, 0x37, 0x7f, 0x4d, 0x5, 0x54, 0xcb, 0xf4, 0xc5, 0x23, 0xd2, 0x1f, 0x6e, 0x5f, 0x37, 0x9d, 0x6f, 0x4b, 0x2, 0x8c, 0xdc, 0xb9, 0xb1, 0x75, 0x8d, 0x3b, 0x39, 0x66, 0x32, 0x42, 0xff, 0x3c, 0xb6, 0xed, 0xe6, 0xa3, 0x6a, 0x6f, 0x5, 0xdb, 0x3b, 0xc4, 0x1e, 0xd, 0x86, 0x1b, 0x38, 0x4b, 0x6d, 0xec, 0x58, 0xbb, 0x9, 0x6d, 0xa, 0x42, 0x2f, 0xd5, 0x42, 0xdf, 0x17, 0x5e, 0x1b, 0xe1, 0x57, 0x1f, 0xb5, 0x2a, 0xe6, 0x6f, 0x2d, 0x86, 0xa2, 0xf6, 0x82, 0x4a, 0x8c, 0xfa, 0xac, 0xba, 0xc4, 0xa7, 0x49, 0x2a, 0xd0, 0x43, 0x3e, 0xeb, 0x15, 0x45, 0x4a, 0xf8, 0xf3, 0x12, 0xb3, 0xb2, 0xa5, 0x77, 0x75, 0xe, 0x3e, 0xfb, 0xd3, 0x70, 0xe8, 0xa8, 0xca, 0xc1, 0x58, 0x25, 0x81, 0x97, 0x1f, 0xba, 0x3b, 0xa4, 0xbd, 0xd, 0x76, 0xe7, 0x18, 0xda, 0xcf, 0x84, 0x33, 0xd3, 0x3a, 0x59, 0xd2, 0x87, 0xf8, 0xcc, 0x92, 0x23, 0x4e, 0x7a, 0x27, 0x10, 0x41, 0xb5, 0x26, 0xe3, 0x89, 0xef, 0xb0, 0xe4, 0xb, 0x6a, 0x18, 0xb3, 0xaa, 0xf6, 0x58, 0xe8, 0x2e, 0xd1, 0xc7, 0x86, 0x31, 0xfd, 0x23, 0xb4, 0xc3, 0xeb, 0x27, 0xc3, 0xfa, 0xec, 0x86, 0x85},
+               output224: []byte{0xed, 0x53, 0x5e, 0xc0, 0x75, 0xc9, 0x83, 0xa0, 0x8f, 0x7d, 0x7a, 0xd5, 0x71, 0x4e, 0xbc, 0x84, 0x6f, 0x25, 0xe8, 0x66, 0x14, 0x92, 0xb2, 0xb3, 0x19, 0x78, 0xed, 0xf2},
+               output256: []byte{0xca, 0x15, 0x8c, 0x46, 0x37, 0xe, 0x64, 0xa9, 0xf0, 0x32, 0xf5, 0xba, 0x8e, 0x9, 0x14, 0x60, 0xfd, 0x55, 0x5e, 0xf7, 0x0, 0xed, 0xf7, 0x8, 0x7e, 0x56, 0xbe, 0xbf, 0xfa, 0x26, 0x1d, 0xe7},
+               output384: []byte{0xeb, 0x2f, 0x1b, 0xf2, 0xd9, 0xee, 0x85, 0x7b, 0x18, 0x93, 0x18, 0xdf, 0xaf, 0x49, 0xdc, 0x3f, 0xad, 0x79, 0x50, 0x11, 0x89, 0xac, 0x9b, 0x57, 0x65, 0xdf, 0xb2, 0x34, 0xec, 0x4a, 0x62, 0xf0, 0xb0, 0xe3, 0x4e, 0x7a, 0xc3, 0xf4, 0x94, 0xd6, 0xf0, 0x5c, 0x7b, 0xb8, 0x6a, 0xe5, 0xcd, 0xa2},
+               output512: []byte{0xcc, 0xea, 0x9f, 0xcf, 0x1a, 0xd9, 0x32, 0x70, 0xac, 0x46, 0x90, 0xe9, 0x6b, 0x87, 0x51, 0x22, 0xc5, 0xb5, 0xec, 0x20, 0xd2, 0xcc, 0x27, 0x7, 0x9c, 0xbf, 0x89, 0x31, 0x26, 0xc4, 0x4e, 0x2, 0x8, 0xa8, 0xbf, 0xa1, 0x39, 0x5, 0x7d, 0x72, 0xbd, 0x26, 0x38, 0x5, 0x9e, 0xc8, 0xda, 0x8a, 0x72, 0x4, 0x99, 0xaf, 0x9d, 0x4c, 0x11, 0x7f, 0x86, 0x79, 0x9d, 0x75, 0x15, 0xdf, 0xc6, 0xe0}},
+       testcase{
+               msg:       []byte{0x44, 0x77, 0x97, 0xe2, 0x89, 0x9b, 0x72, 0xa3, 0x56, 0xba, 0x55, 0xbf, 0x4d, 0xf3, 0xac, 0xca, 0x6c, 0xdb, 0x10, 0x41, 0xeb, 0x47, 0x7b, 0xd1, 0x83, 0x4a, 0x9f, 0x9a, 0xcb, 0xc3, 0x40, 0xa2, 0x94, 0xd7, 0x29, 0xf2, 0xf9, 0x7d, 0xf3, 0xa6, 0x10, 0xbe, 0xf, 0xf1, 0x5e, 0xdb, 0x9c, 0x6d, 0x5d, 0xb4, 0x16, 0x44, 0xb9, 0x87, 0x43, 0x60, 0x14, 0xf, 0xc6, 0x4f, 0x52, 0xaa, 0x3, 0xf0, 0x28, 0x6c, 0x8a, 0x64, 0x6, 0x70, 0x6, 0x7a, 0x84, 0xe0, 0x17, 0x92, 0x6a, 0x70, 0x43, 0x8d, 0xb1, 0xbb, 0x36, 0x1d, 0xef, 0xee, 0x73, 0x17, 0x2, 0x14, 0x25, 0xf8, 0x82, 0x1d, 0xef, 0x26, 0xd1, 0xef, 0xd7, 0x7f, 0xc8, 0x53, 0xb8, 0x18, 0x54, 0x5d, 0x5, 0x5a, 0xdc, 0x92, 0x84, 0x79, 0x6e, 0x58, 0x3c, 0x76, 0xe6, 0xfe, 0x74, 0xc9, 0xac, 0x25, 0x87, 0xaa, 0x46, 0xaa, 0x8f, 0x88, 0x4, 0xf2, 0xfe, 0xb5, 0x83, 0x6c, 0xc4, 0xb3, 0xab, 0xab, 0xab, 0x84, 0x29, 0xa5, 0x78, 0x3e, 0x17, 0xd5, 0x99, 0x9f, 0x32, 0x24, 0x2e, 0xb5, 0x9e, 0xf3, 0xc, 0xd7, 0xad, 0xab, 0xc1, 0x6d, 0x72, 0xdb, 0xdb, 0x9, 0x76, 0x23, 0x4, 0x7c, 0x98, 0x98, 0x9f, 0x88, 0xd1, 0x4e, 0xaf, 0x2, 0xa7, 0x21, 0x2b, 0xe1, 0x6e, 0xc2, 0xd0, 0x79, 0x81, 0xaa, 0xa9, 0x99, 0x49, 0xdd, 0xf8, 0x9e, 0xcd, 0x90, 0x33, 0x3a, 0x77, 0xbc, 0x4e, 0x19, 0x88, 0xa8, 0x2a, 0xbf, 0x7c, 0x7c, 0xaf, 0x32, 0x91},
+               output224: []byte{0x87, 0xf1, 0x5c, 0xc2, 0xae, 0xc2, 0x41, 0x68, 0xd8, 0xbb, 0xaf, 0x18, 0x88, 0x25, 0xf3, 0xbb, 0x1, 0x78, 0xcf, 0xb5, 0xc5, 0x89, 0x9f, 0x2f, 0xd0, 0x42, 0xce, 0x89},
+               output256: []byte{0x59, 0x1, 0xcd, 0xa0, 0xcd, 0x15, 0x10, 0xdb, 0x54, 0x55, 0xd0, 0x72, 0xd2, 0x73, 0x7a, 0x67, 0x21, 0xad, 0x9e, 0xe3, 0x27, 0x29, 0x53, 0xa1, 0x9c, 0x7a, 0xb3, 0x78, 0xbf, 0x36, 0x46, 0xc5},
+               output384: []byte{0x2a, 0x9c, 0xf2, 0xfd, 0x1, 0x2b, 0x2, 0x56, 0x16, 0x47, 0x8c, 0xef, 0x69, 0x71, 0xb6, 0xf9, 0xe4, 0x94, 0xa6, 0x3a, 0xab, 0x5f, 0x53, 0x31, 0xd, 0xde, 0x70, 0xfc, 0x6e, 0xd2, 0x7f, 0x1e, 0x2d, 0x78, 0x4, 0xae, 0xb8, 0xd2, 0x6, 0xf6, 0x41, 0xa7, 0x3e, 0x5, 0x4d, 0xa6, 0x20, 0xe6},
+               output512: []byte{0x2e, 0xfc, 0x5d, 0xfe, 0x2, 0x8a, 0x35, 0x50, 0x3a, 0x25, 0xbd, 0xf8, 0xb2, 0x16, 0x4d, 0x86, 0xca, 0x74, 0x96, 0xb7, 0xc5, 0xde, 0xd0, 0x9c, 0x5d, 0x41, 0x4b, 0x69, 0x77, 0xad, 0xbb, 0x4a, 0x69, 0x88, 0xab, 0x99, 0x39, 0xd1, 0xec, 0x65, 0xf4, 0x6b, 0xcc, 0x99, 0xc1, 0xdc, 0xd5, 0xf1, 0x9e, 0x3, 0x5d, 0x8d, 0x3d, 0xc3, 0x87, 0x36, 0x12, 0x0, 0xe4, 0xda, 0x80, 0xc8, 0x6, 0x71}},
+       testcase{
+               msg:       []byte{0x9f, 0x2c, 0x18, 0xad, 0xe9, 0xb3, 0x80, 0xc7, 0x84, 0xe1, 0x70, 0xfb, 0x76, 0x3e, 0x9a, 0xa2, 0x5, 0xf6, 0x43, 0x3, 0x6, 0x7e, 0xb1, 0xbc, 0xea, 0x93, 0xdf, 0x5d, 0xac, 0x4b, 0xf5, 0xa2, 0xe0, 0xb, 0x78, 0x19, 0x5f, 0x80, 0x8d, 0xf2, 0x4f, 0xc7, 0x6e, 0x26, 0xcb, 0x7b, 0xe3, 0x1d, 0xc3, 0x5f, 0x8, 0x44, 0xcd, 0xed, 0x15, 0x67, 0xbb, 0xa2, 0x98, 0x58, 0xcf, 0xfc, 0x97, 0xfb, 0x29, 0x1, 0x3, 0x31, 0xb0, 0x1d, 0x6a, 0x3f, 0xb3, 0x15, 0x9c, 0xc1, 0xb9, 0x73, 0xd2, 0x55, 0xda, 0x98, 0x43, 0xe3, 0x4a, 0xa, 0x40, 0x61, 0xca, 0xbd, 0xb9, 0xed, 0x37, 0xf2, 0x41, 0xbf, 0xab, 0xb3, 0xc2, 0xd, 0x32, 0x74, 0x3f, 0x40, 0x26, 0xb5, 0x9a, 0x4c, 0xcc, 0x38, 0x5a, 0x23, 0x1, 0xf8, 0x3c, 0xb, 0xa, 0x19, 0xb, 0xf, 0x2d, 0x1, 0xac, 0xb8, 0xf0, 0xd4, 0x11, 0x11, 0xe1, 0xf, 0x2f, 0x4e, 0x14, 0x93, 0x79, 0x27, 0x55, 0x99, 0xa5, 0x2d, 0xc0, 0x89, 0xb3, 0x5f, 0xdd, 0x52, 0x34, 0xb0, 0xcf, 0xb7, 0xb6, 0xd8, 0xae, 0xbd, 0x56, 0x3c, 0xa1, 0xfa, 0x65, 0x3c, 0x5c, 0x2, 0x1d, 0xfd, 0x6f, 0x59, 0x20, 0xe6, 0xf1, 0x8b, 0xfa, 0xfd, 0xbe, 0xcb, 0xf0, 0xab, 0x0, 0x28, 0x13, 0x33, 0xed, 0x50, 0xb9, 0xa9, 0x99, 0x54, 0x9c, 0x1c, 0x8f, 0x8c, 0x63, 0xd7, 0x62, 0x6c, 0x48, 0x32, 0x2e, 0x97, 0x91, 0xd5, 0xff, 0x72, 0x29, 0x40, 0x49, 0xbd, 0xe9, 0x1e, 0x73, 0xf8},
+               output224: []byte{0x31, 0xbb, 0x87, 0x25, 0x45, 0x21, 0x7f, 0xdb, 0xf1, 0x10, 0x77, 0xe8, 0x6b, 0x1e, 0xe4, 0x51, 0x47, 0x5c, 0x31, 0xdc, 0x5e, 0xe, 0x63, 0x6e, 0xfb, 0xe5, 0x8, 0x25},
+               output256: []byte{0xf6, 0x45, 0x62, 0xd6, 0x27, 0x3e, 0xfb, 0x5e, 0xbd, 0x2, 0x7e, 0xa, 0x6f, 0x38, 0xc3, 0xfb, 0x20, 0x4a, 0x6d, 0xbe, 0x89, 0x4e, 0xe0, 0x12, 0x0, 0xea, 0x24, 0x9b, 0x74, 0x7c, 0xfe, 0x66},
+               output384: []byte{0x5f, 0x8e, 0x2d, 0xe7, 0x42, 0x3, 0x6b, 0x6a, 0xc4, 0xa7, 0xd8, 0x98, 0x7b, 0x47, 0xc4, 0xc7, 0xa1, 0xcc, 0xb7, 0x23, 0x9e, 0x1b, 0x3e, 0xef, 0xd1, 0x11, 0x6d, 0x63, 0x92, 0xc7, 0x91, 0x77, 0xd6, 0x8c, 0x66, 0x22, 0x1f, 0x31, 0xd0, 0xfa, 0xed, 0x91, 0x34, 0x42, 0x9b, 0x89, 0xbe, 0xea},
+               output512: []byte{0xe8, 0xd, 0x7a, 0x93, 0x4f, 0xda, 0xf1, 0x7d, 0xb8, 0xdb, 0xb1, 0xdc, 0x6c, 0x42, 0xe9, 0xe, 0x13, 0x92, 0x11, 0xc2, 0xf5, 0x99, 0x89, 0xc, 0x6, 0xb1, 0x5d, 0x62, 0x48, 0xfd, 0xbe, 0x68, 0x2d, 0x77, 0xd4, 0xe0, 0x5f, 0x26, 0xd7, 0x28, 0x52, 0xf7, 0x49, 0x2b, 0xce, 0x11, 0x8c, 0xe7, 0xc3, 0x69, 0x50, 0xbd, 0x2c, 0x50, 0xf9, 0x69, 0x9b, 0xb4, 0x7d, 0x89, 0xc3, 0x11, 0x53, 0x77}},
+       testcase{
+               msg:       []byte{0xae, 0x15, 0x9f, 0x3f, 0xa3, 0x36, 0x19, 0x0, 0x2a, 0xe6, 0xbc, 0xce, 0x8c, 0xbb, 0xdd, 0x7d, 0x28, 0xe5, 0xed, 0x9d, 0x61, 0x53, 0x45, 0x95, 0xc4, 0xc9, 0xf4, 0x3c, 0x40, 0x2a, 0x9b, 0xb3, 0x1f, 0x3b, 0x30, 0x1c, 0xbf, 0xd4, 0xa4, 0x3c, 0xe4, 0xc2, 0x4c, 0xd5, 0xc9, 0x84, 0x9c, 0xc6, 0x25, 0x9e, 0xca, 0x90, 0xe2, 0xa7, 0x9e, 0x1, 0xff, 0xba, 0xc0, 0x7b, 0xa0, 0xe1, 0x47, 0xfa, 0x42, 0x67, 0x6a, 0x1d, 0x66, 0x85, 0x70, 0xe0, 0x39, 0x63, 0x87, 0xb5, 0xbc, 0xd5, 0x99, 0xe8, 0xe6, 0x6a, 0xae, 0xd1, 0xb8, 0xa1, 0x91, 0xc5, 0xa4, 0x75, 0x47, 0xf6, 0x13, 0x73, 0x2, 0x1f, 0xa6, 0xde, 0xad, 0xcb, 0x55, 0x36, 0x3d, 0x23, 0x3c, 0x24, 0x44, 0xf, 0x2c, 0x73, 0xdb, 0xb5, 0x19, 0xf7, 0xc9, 0xfa, 0x5a, 0x89, 0x62, 0xef, 0xd5, 0xf6, 0x25, 0x2c, 0x4, 0x7, 0xf1, 0x90, 0xdf, 0xef, 0xad, 0x70, 0x7f, 0x3c, 0x70, 0x7, 0xd6, 0x9f, 0xf3, 0x6b, 0x84, 0x89, 0xa5, 0xb6, 0xb7, 0xc5, 0x57, 0xe7, 0x9d, 0xd4, 0xf5, 0xc, 0x6, 0x51, 0x1f, 0x59, 0x9f, 0x56, 0xc8, 0x96, 0xb3, 0x5c, 0x91, 0x7b, 0x63, 0xba, 0x35, 0xc6, 0xff, 0x80, 0x92, 0xba, 0xf7, 0xd1, 0x65, 0x8e, 0x77, 0xfc, 0x95, 0xd8, 0xa6, 0xa4, 0x3e, 0xeb, 0x4c, 0x1, 0xf3, 0x3f, 0x3, 0x87, 0x7f, 0x92, 0x77, 0x4b, 0xe8, 0x9c, 0x11, 0x14, 0xdd, 0x53, 0x1c, 0x1, 0x1e, 0x53, 0xa3, 0x4d, 0xc2, 0x48, 0xa2, 0xf0, 0xe6},
+               output224: []byte{0x26, 0xd6, 0x9f, 0xa, 0xe8, 0xe4, 0xdc, 0x61, 0xc6, 0x35, 0x4f, 0xf5, 0x70, 0xfd, 0xd9, 0x13, 0xca, 0xf2, 0x1c, 0x18, 0x69, 0x7f, 0x3, 0x71, 0xf2, 0xd3, 0x23, 0xaf},
+               output256: []byte{0xe7, 0xd7, 0xa1, 0x13, 0xb3, 0xa3, 0x31, 0x75, 0xd0, 0xab, 0xd2, 0xcf, 0x4f, 0x9a, 0xdd, 0x8e, 0x41, 0xdc, 0x86, 0xc9, 0x3c, 0x95, 0x52, 0xc5, 0xb3, 0x58, 0x82, 0x77, 0xfb, 0xca, 0xa2, 0x4a},
+               output384: []byte{0xb0, 0xb1, 0xf4, 0x5, 0x84, 0x17, 0x51, 0x6a, 0x5c, 0x5a, 0x96, 0x83, 0xa5, 0xd7, 0x2b, 0x48, 0x9e, 0x6a, 0xd4, 0x22, 0x73, 0xd5, 0x91, 0x79, 0x1d, 0x2c, 0xda, 0x73, 0x60, 0xa4, 0x0, 0x8e, 0x86, 0xc8, 0x89, 0x93, 0x69, 0x94, 0x6f, 0x7a, 0xbf, 0xe2, 0x9b, 0xf9, 0x2c, 0x9c, 0xa9, 0x65},
+               output512: []byte{0xc4, 0x14, 0xb2, 0x9f, 0xd0, 0x77, 0x20, 0xf4, 0x6c, 0x35, 0x1f, 0x5c, 0x80, 0xbe, 0x20, 0x94, 0xe9, 0x5d, 0x13, 0xad, 0x97, 0xbd, 0xd1, 0xf7, 0xc5, 0x20, 0x7b, 0x69, 0x56, 0x93, 0xcd, 0x5e, 0x1e, 0x1, 0x69, 0xb1, 0xaa, 0x2e, 0x27, 0x11, 0x15, 0xbd, 0x51, 0x71, 0xfe, 0xc5, 0x1d, 0x4, 0xb7, 0x1e, 0x3e, 0x7c, 0xe1, 0x61, 0x8f, 0xbf, 0xeb, 0x38, 0x2f, 0x56, 0xf6, 0x5f, 0x7e, 0xff}},
+       testcase{
+               msg:       []byte{0x3b, 0x8e, 0x97, 0xc5, 0xff, 0xc2, 0xd6, 0xa4, 0xf, 0xa7, 0xde, 0x7f, 0xce, 0xfc, 0x90, 0xf3, 0xb1, 0x2c, 0x94, 0xe, 0x7a, 0xb4, 0x15, 0x32, 0x1e, 0x29, 0xee, 0x69, 0x2d, 0xfa, 0xc7, 0x99, 0xb0, 0x9, 0xc9, 0x9d, 0xcd, 0xdb, 0x70, 0x8f, 0xce, 0x5a, 0x17, 0x8c, 0x5c, 0x35, 0xee, 0x2b, 0x86, 0x17, 0x14, 0x3e, 0xdc, 0x4c, 0x40, 0xb4, 0xd3, 0x13, 0x66, 0x1f, 0x49, 0xab, 0xdd, 0x93, 0xce, 0xa7, 0x9d, 0x11, 0x75, 0x18, 0x80, 0x54, 0x96, 0xfe, 0x6a, 0xcf, 0x29, 0x2c, 0x4c, 0x2a, 0x1f, 0x76, 0xb4, 0x3, 0xa9, 0x7d, 0x7c, 0x39, 0x9d, 0xaf, 0x85, 0xb4, 0x6a, 0xd8, 0x4e, 0x16, 0x24, 0x6c, 0x67, 0xd6, 0x83, 0x67, 0x57, 0xbd, 0xe3, 0x36, 0xc2, 0x90, 0xd5, 0xd4, 0x1, 0xe6, 0xc1, 0x38, 0x6a, 0xb3, 0x27, 0x97, 0xaf, 0x6b, 0xb2, 0x51, 0xe9, 0xb2, 0xd8, 0xfe, 0x75, 0x4c, 0x47, 0x48, 0x2b, 0x72, 0xe0, 0xb3, 0x94, 0xea, 0xb7, 0x69, 0x16, 0x12, 0x6f, 0xd6, 0x8e, 0xa7, 0xd6, 0x5e, 0xb9, 0x3d, 0x59, 0xf5, 0xb4, 0xc5, 0xac, 0x40, 0xf7, 0xc3, 0xb3, 0x7e, 0x7f, 0x36, 0x94, 0xf2, 0x94, 0x24, 0xc2, 0x4a, 0xf8, 0xc8, 0xf0, 0xef, 0x59, 0xcd, 0x9d, 0xbf, 0x1d, 0x28, 0xe0, 0xe1, 0xf, 0x79, 0x9a, 0x6f, 0x78, 0xca, 0xd1, 0xd4, 0x5b, 0x9d, 0xb3, 0xd7, 0xde, 0xe4, 0xa7, 0x5, 0x9a, 0xbe, 0x99, 0x18, 0x27, 0x14, 0x98, 0x3b, 0x9c, 0x9d, 0x44, 0xd7, 0xf5, 0x64, 0x35, 0x96, 0xd4, 0xf3},
+               output224: []byte{0x17, 0x53, 0x93, 0x53, 0x4d, 0x90, 0xb6, 0x14, 0xb1, 0x58, 0x10, 0x5c, 0x95, 0xe1, 0x8a, 0x10, 0x52, 0xa5, 0x6d, 0xe, 0x77, 0x5e, 0xa1, 0xcf, 0x51, 0xad, 0x58, 0x53},
+               output256: []byte{0x3b, 0x40, 0xc1, 0x49, 0x3a, 0xf4, 0x11, 0xae, 0x78, 0x49, 0x90, 0x4d, 0x47, 0x8d, 0xf2, 0x40, 0x72, 0x54, 0xbf, 0x62, 0xb8, 0x8e, 0x9b, 0xff, 0xd7, 0xb4, 0x2b, 0xd2, 0xa6, 0xc, 0xe0, 0xfa},
+               output384: []byte{0x91, 0x72, 0xaa, 0xd6, 0xc1, 0x5b, 0x4d, 0xcd, 0x79, 0xbb, 0xd8, 0x4f, 0xad, 0x6, 0x1, 0x11, 0x9d, 0x8b, 0x4e, 0x3a, 0xfe, 0xd1, 0x7b, 0x59, 0x4f, 0xf3, 0x84, 0x24, 0x15, 0x79, 0x85, 0xee, 0x27, 0xb6, 0x58, 0x26, 0xb9, 0x90, 0x54, 0x86, 0xe7, 0x67, 0xe8, 0x5a, 0xa0, 0x31, 0xe0, 0x7b},
+               output512: []byte{0xa4, 0x67, 0x9a, 0x4c, 0xbe, 0xe6, 0x29, 0x22, 0x3, 0xba, 0xfb, 0xa8, 0x91, 0x32, 0x45, 0xf3, 0xe, 0x4, 0x6a, 0xba, 0x6c, 0x9, 0x37, 0xb4, 0x7, 0xc0, 0xb, 0x73, 0xd1, 0x7d, 0x8d, 0x69, 0x66, 0x90, 0xee, 0x25, 0xba, 0x1b, 0x39, 0xde, 0xb3, 0xdb, 0x93, 0x52, 0x5a, 0x8f, 0xbc, 0xfd, 0x88, 0x17, 0x3b, 0xa9, 0xc7, 0xa6, 0x5b, 0x44, 0x6, 0xd0, 0x55, 0xb, 0xa9, 0xb6, 0xcc, 0x7}},
+       testcase{
+               msg:       []byte{0x34, 0x34, 0xec, 0x31, 0xb1, 0xf, 0xaf, 0xdb, 0xfe, 0xec, 0xd, 0xd6, 0xbd, 0x94, 0xe8, 0xf, 0x7b, 0xa9, 0xdc, 0xa1, 0x9e, 0xf0, 0x75, 0xf7, 0xeb, 0x1, 0x75, 0x12, 0xaf, 0x66, 0xd6, 0xa4, 0xbc, 0xf7, 0xd1, 0x6b, 0xa0, 0x81, 0x9a, 0x18, 0x92, 0xa6, 0x37, 0x2f, 0x9b, 0x35, 0xbc, 0xc7, 0xca, 0x81, 0x55, 0xee, 0x19, 0xe8, 0x42, 0x8b, 0xc2, 0x2d, 0x21, 0x48, 0x56, 0xed, 0x5f, 0xa9, 0x37, 0x4c, 0x3c, 0x9, 0xbd, 0xe1, 0x69, 0x60, 0x2c, 0xc2, 0x19, 0x67, 0x9f, 0x65, 0xa1, 0x56, 0x6f, 0xc7, 0x31, 0x6f, 0x4c, 0xc3, 0xb6, 0x31, 0xa1, 0x8f, 0xb4, 0x44, 0x9f, 0xa6, 0xaf, 0xa1, 0x6a, 0x3d, 0xb2, 0xbc, 0x42, 0x12, 0xef, 0xf5, 0x39, 0xc6, 0x7c, 0xf1, 0x84, 0x68, 0x8, 0x26, 0x53, 0x55, 0x89, 0xc7, 0x11, 0x1d, 0x73, 0xbf, 0xfc, 0xe4, 0x31, 0xb4, 0xc4, 0x4, 0x92, 0xe7, 0x63, 0xd9, 0x27, 0x95, 0x60, 0xaa, 0xa3, 0x8e, 0xb2, 0xdc, 0x14, 0xa2, 0x12, 0xd7, 0x23, 0xf9, 0x94, 0xa1, 0xfe, 0x65, 0x6f, 0xf4, 0xdd, 0x14, 0x55, 0x1c, 0xe4, 0xe7, 0xc6, 0x21, 0xb2, 0xaa, 0x56, 0x4, 0xa1, 0x0, 0x1, 0xb2, 0x87, 0x8a, 0x89, 0x7a, 0x28, 0xa0, 0x80, 0x95, 0xc3, 0x25, 0xe1, 0xa, 0x26, 0xd2, 0xfb, 0x1a, 0x75, 0xbf, 0xd6, 0x4c, 0x25, 0x3, 0x9, 0xbb, 0x55, 0xa4, 0x4f, 0x23, 0xbb, 0xac, 0xd, 0x55, 0x16, 0xa1, 0xc6, 0x87, 0xd3, 0xb4, 0x1e, 0xf2, 0xfb, 0xbf, 0x9c, 0xc5, 0x6d, 0x47, 0x39},
+               output224: []byte{0x3d, 0xec, 0xd7, 0x1d, 0xa2, 0x26, 0x39, 0x98, 0x5c, 0xf2, 0x42, 0xf2, 0xfa, 0xe7, 0x17, 0x24, 0x59, 0x4, 0x2c, 0x82, 0x64, 0x95, 0xc8, 0xd8, 0xd9, 0x5c, 0x37, 0x19},
+               output256: []byte{0xfe, 0xeb, 0x17, 0x2a, 0xea, 0xb2, 0xf0, 0xde, 0xb7, 0x48, 0xfb, 0x77, 0x80, 0x1c, 0xa2, 0x2d, 0x3c, 0xe9, 0x9b, 0x7a, 0x9f, 0x97, 0x89, 0xe4, 0x79, 0xb9, 0x3d, 0x1f, 0x4b, 0x1d, 0x22, 0x7f},
+               output384: []byte{0xba, 0xfb, 0xb3, 0x32, 0x1c, 0x47, 0x98, 0x54, 0x8f, 0x5d, 0xd9, 0x83, 0xea, 0xc1, 0xe1, 0x6e, 0x1f, 0x3e, 0xf2, 0xba, 0x5c, 0x9d, 0x69, 0xa3, 0x40, 0xf6, 0xca, 0xbc, 0x9c, 0x7f, 0xe9, 0xf1, 0xfd, 0x95, 0xa6, 0x92, 0xb7, 0x38, 0x73, 0x42, 0x30, 0x49, 0x45, 0x67, 0x4d, 0x9d, 0x2e, 0x4a},
+               output512: []byte{0x5f, 0x49, 0xd6, 0x59, 0x4d, 0xa9, 0x39, 0x98, 0x7d, 0x19, 0x6, 0x29, 0x4b, 0x33, 0xa0, 0x37, 0xf6, 0x3c, 0x79, 0xe0, 0x78, 0x53, 0x1d, 0xfa, 0x7e, 0x6c, 0xe6, 0x72, 0x79, 0xd4, 0xd5, 0xdb, 0xeb, 0x65, 0xf, 0xf8, 0x69, 0xf, 0x23, 0xb6, 0x3b, 0x7e, 0x9c, 0x48, 0xea, 0x87, 0x91, 0xb8, 0xf, 0xdb, 0x34, 0xef, 0x66, 0xdc, 0xf0, 0xce, 0xfe, 0x45, 0x84, 0x2e, 0xcf, 0xf4, 0xad, 0x1d}},
+       testcase{
+               msg:       []byte{0x7c, 0x79, 0x53, 0xd8, 0x1c, 0x8d, 0x20, 0x8f, 0xd1, 0xc9, 0x76, 0x81, 0xd4, 0x8f, 0x49, 0xdd, 0x0, 0x34, 0x56, 0xde, 0x60, 0x47, 0x5b, 0x84, 0x7, 0xe, 0xf4, 0x84, 0x7c, 0x33, 0x3b, 0x74, 0x57, 0x5b, 0x1f, 0xc8, 0xd2, 0xa1, 0x86, 0x96, 0x44, 0x85, 0xa3, 0xb8, 0x63, 0x4f, 0xea, 0xa3, 0x59, 0x5a, 0xaa, 0x1a, 0x2f, 0x45, 0x95, 0xa7, 0xd6, 0xb6, 0x15, 0x35, 0x63, 0xde, 0xe3, 0x1b, 0xba, 0xc4, 0x43, 0xc8, 0xa3, 0x3e, 0xed, 0x6d, 0x5d, 0x95, 0x6a, 0x98, 0xa, 0x68, 0x36, 0x6c, 0x25, 0x27, 0xb5, 0x50, 0xee, 0x95, 0x2, 0x50, 0xdf, 0xb6, 0x91, 0xea, 0xcb, 0xd5, 0xd5, 0x6a, 0xe1, 0x4b, 0x97, 0x6, 0x68, 0xbe, 0x17, 0x4c, 0x89, 0xdf, 0x2f, 0xea, 0x43, 0xae, 0x52, 0xf1, 0x31, 0x42, 0x63, 0x9c, 0x88, 0x4f, 0xd6, 0x2a, 0x36, 0x83, 0xc0, 0xc3, 0x79, 0x2f, 0xf, 0x24, 0xab, 0x13, 0x18, 0xbc, 0xb2, 0x7e, 0x21, 0xf4, 0x73, 0x7f, 0xab, 0x62, 0xc7, 0x7e, 0xa3, 0x8b, 0xc8, 0xfd, 0x1c, 0xf4, 0x1f, 0x7d, 0xab, 0x64, 0xc1, 0x3f, 0xeb, 0xe7, 0x15, 0x2b, 0xf5, 0xbb, 0x7a, 0xb5, 0xa7, 0x8f, 0x53, 0x46, 0xd4, 0x3c, 0xc7, 0x41, 0xcb, 0x6f, 0x72, 0xb7, 0xb8, 0x98, 0xf, 0x26, 0x8b, 0x68, 0xbf, 0x62, 0xab, 0xdf, 0xb1, 0x57, 0x7a, 0x52, 0x43, 0x8f, 0xe1, 0x4b, 0x59, 0x14, 0x98, 0xcc, 0x95, 0xf0, 0x71, 0x22, 0x84, 0x60, 0xc7, 0xc5, 0xd5, 0xce, 0xb4, 0xa7, 0xbd, 0xe5, 0x88, 0xe7, 0xf2, 0x1c},
+               output224: []byte{0x2d, 0xa, 0x56, 0x86, 0x4b, 0xbe, 0xc6, 0x44, 0x9f, 0xbf, 0x7b, 0x2e, 0xae, 0x53, 0xda, 0x46, 0x64, 0x71, 0x83, 0xb5, 0x6f, 0xa4, 0xed, 0xb1, 0x60, 0x2e, 0x51, 0x63},
+               output256: []byte{0xb2, 0x40, 0xbc, 0x52, 0xb8, 0xaf, 0x1b, 0x50, 0x2e, 0x26, 0xbf, 0x1d, 0x5e, 0x75, 0xfe, 0x26, 0x63, 0xbf, 0xba, 0x50, 0x3f, 0xaf, 0x10, 0xf4, 0x67, 0x54, 0xdc, 0x3d, 0x23, 0xcb, 0x61, 0xc1},
+               output384: []byte{0xa0, 0x55, 0xe0, 0xa9, 0xc4, 0x57, 0x5c, 0xd4, 0xd7, 0xad, 0x84, 0xa2, 0x40, 0x17, 0x6f, 0x21, 0xed, 0x68, 0xf4, 0x84, 0xa2, 0x69, 0xe0, 0xc9, 0xef, 0xfb, 0x6f, 0xa9, 0x37, 0x46, 0xe3, 0x1f, 0x64, 0xb0, 0xb9, 0xc, 0x51, 0x3d, 0x2b, 0x57, 0xec, 0x78, 0xe9, 0xe5, 0xba, 0x3b, 0xa9, 0x9c},
+               output512: []byte{0xb7, 0x7f, 0xb7, 0x96, 0x69, 0xea, 0x52, 0xc7, 0x38, 0xe5, 0x8a, 0x9e, 0xf3, 0xed, 0x15, 0x1, 0xbb, 0xe7, 0x97, 0x44, 0x78, 0xaf, 0xb5, 0xa8, 0xbe, 0xd4, 0x45, 0x49, 0xd6, 0x23, 0x2f, 0xf8, 0xd7, 0xaa, 0x9e, 0xee, 0xaf, 0x2, 0xf6, 0x75, 0x53, 0x27, 0x95, 0x10, 0x93, 0x24, 0x31, 0x10, 0xd7, 0xbc, 0xfc, 0xe, 0x51, 0x29, 0x9d, 0xb7, 0x93, 0x85, 0x6b, 0x57, 0xa7, 0x7e, 0x84, 0x20}},
+       testcase{
+               msg:       []byte{0x7a, 0x6a, 0x4f, 0x4f, 0xdc, 0x59, 0xa1, 0xd2, 0x23, 0x38, 0x1a, 0xe5, 0xaf, 0x49, 0x8d, 0x74, 0xb7, 0x25, 0x2e, 0xcf, 0x59, 0xe3, 0x89, 0xe4, 0x91, 0x30, 0xc7, 0xea, 0xee, 0x62, 0x6e, 0x7b, 0xd9, 0x89, 0x7e, 0xff, 0xd9, 0x20, 0x17, 0xf4, 0xcc, 0xde, 0x66, 0xb0, 0x44, 0x4, 0x62, 0xcd, 0xed, 0xfd, 0x35, 0x2d, 0x81, 0x53, 0xe6, 0xa4, 0xc8, 0xd7, 0xa0, 0x81, 0x2f, 0x70, 0x1c, 0xc7, 0x37, 0xb5, 0x17, 0x8c, 0x25, 0x56, 0xf0, 0x71, 0x11, 0x20, 0xe, 0xb6, 0x27, 0xdb, 0xc2, 0x99, 0xca, 0xa7, 0x92, 0xdf, 0xa5, 0x8f, 0x35, 0x93, 0x52, 0x99, 0xfa, 0x3a, 0x35, 0x19, 0xe9, 0xb0, 0x31, 0x66, 0xdf, 0xfa, 0x15, 0x91, 0x3, 0xff, 0xa3, 0x5e, 0x85, 0x77, 0xf7, 0xc0, 0xa8, 0x6c, 0x6b, 0x46, 0xfe, 0x13, 0xdb, 0x8e, 0x2c, 0xdd, 0x9d, 0xcf, 0xba, 0x85, 0xbd, 0xdd, 0xcc, 0xe0, 0xa7, 0xa8, 0xe1, 0x55, 0xf8, 0x1f, 0x71, 0x2d, 0x8e, 0x9f, 0xe6, 0x46, 0x15, 0x3d, 0x3d, 0x22, 0xc8, 0x11, 0xbd, 0x39, 0xf8, 0x30, 0x43, 0x3b, 0x22, 0x13, 0xdd, 0x46, 0x30, 0x19, 0x41, 0xb5, 0x92, 0x93, 0xfd, 0xa, 0x33, 0xe2, 0xb6, 0x3a, 0xdb, 0xd9, 0x52, 0x39, 0xbc, 0x1, 0x31, 0x5c, 0x46, 0xfd, 0xb6, 0x78, 0x87, 0x5b, 0x3c, 0x81, 0xe0, 0x53, 0xa4, 0xf, 0x58, 0x1c, 0xfb, 0xec, 0x24, 0xa1, 0x40, 0x4b, 0x16, 0x71, 0xa1, 0xb8, 0x8a, 0x6d, 0x6, 0x12, 0x2, 0x29, 0x51, 0x8f, 0xb1, 0x3a, 0x74, 0xca, 0xa, 0xc5, 0xae},
+               output224: []byte{0xa0, 0xff, 0x9e, 0x11, 0xfb, 0xb4, 0x51, 0x94, 0x3a, 0x17, 0xe3, 0xac, 0x51, 0xd, 0xe0, 0xb5, 0x82, 0xbb, 0x7, 0x2b, 0x16, 0xdc, 0x4e, 0x3, 0xf9, 0xe4, 0x1, 0x9f},
+               output256: []byte{0x3e, 0xba, 0xce, 0x41, 0xf5, 0x78, 0xfd, 0xe6, 0x60, 0x3e, 0x3, 0x2f, 0xc1, 0xc7, 0xcf, 0xee, 0xf1, 0xcb, 0x79, 0xfe, 0x93, 0x8a, 0x94, 0xd4, 0xc7, 0xb5, 0x8b, 0xb, 0xa4, 0xcb, 0x97, 0x20},
+               output384: []byte{0x78, 0x8d, 0x19, 0xad, 0x68, 0xd1, 0xb2, 0x6c, 0xb0, 0x7, 0x83, 0x89, 0xb4, 0x5f, 0xb1, 0x8b, 0x3d, 0xa3, 0x5a, 0x57, 0xa1, 0xec, 0x91, 0x42, 0x73, 0x15, 0x8e, 0xad, 0x43, 0x74, 0x9b, 0xf1, 0xab, 0x49, 0xb1, 0xa6, 0x8d, 0x48, 0x31, 0xce, 0x19, 0x3f, 0x58, 0x52, 0xd2, 0xf, 0xd9, 0x6c},
+               output512: []byte{0xca, 0xca, 0xf, 0xf4, 0x31, 0x7, 0xf7, 0x30, 0xa7, 0xfb, 0xe6, 0x86, 0x9f, 0xba, 0x5a, 0xf1, 0xe6, 0x26, 0xc9, 0x63, 0x3, 0xbe, 0x3b, 0xc9, 0x51, 0x55, 0x16, 0x41, 0x99, 0xc8, 0x89, 0x22, 0x19, 0x45, 0x11, 0xb2, 0x4c, 0x48, 0x91, 0x11, 0x86, 0xf6, 0x47, 0xca, 0x24, 0x64, 0x27, 0xf2, 0xce, 0x7b, 0xa7, 0x47, 0x27, 0x1c, 0xd8, 0xd7, 0xc5, 0xe1, 0xd1, 0x27, 0xc2, 0x1f, 0x1e, 0xaa}},
+       testcase{
+               msg:       []byte{0xd9, 0xfa, 0xa1, 0x4c, 0xeb, 0xe9, 0xb7, 0xde, 0x55, 0x1b, 0x6c, 0x7, 0x65, 0x40, 0x9a, 0x33, 0x93, 0x85, 0x62, 0x1, 0x3b, 0x5e, 0x8e, 0xe, 0x1e, 0xa, 0x64, 0x18, 0xdf, 0x73, 0x99, 0xd0, 0xa6, 0xa7, 0x71, 0xfb, 0x81, 0xc3, 0xca, 0x9b, 0xd3, 0xbb, 0x8e, 0x29, 0x51, 0xb0, 0xbc, 0x79, 0x25, 0x25, 0xa2, 0x94, 0xeb, 0xd1, 0x8, 0x36, 0x88, 0x80, 0x6f, 0xe5, 0xe7, 0xf1, 0xe1, 0x7f, 0xd4, 0xe3, 0xa4, 0x1d, 0x0, 0xc8, 0x9e, 0x8f, 0xcf, 0x4a, 0x36, 0x3c, 0xae, 0xdb, 0x1a, 0xcb, 0x55, 0x8e, 0x3d, 0x56, 0x2f, 0x13, 0x2, 0xb3, 0xd8, 0x3b, 0xb8, 0x86, 0xed, 0x27, 0xb7, 0x60, 0x33, 0x79, 0x81, 0x31, 0xda, 0xb0, 0x5b, 0x42, 0x17, 0x38, 0x1e, 0xaa, 0xa7, 0xba, 0x15, 0xec, 0x82, 0xb, 0xb5, 0xc1, 0x3b, 0x51, 0x6d, 0xd6, 0x40, 0xea, 0xec, 0x5a, 0x27, 0xd0, 0x5f, 0xdf, 0xca, 0xf, 0x35, 0xb3, 0xa5, 0x31, 0x21, 0x46, 0x80, 0x6b, 0x4c, 0x2, 0x75, 0xbc, 0xd0, 0xaa, 0xa3, 0xb2, 0x1, 0x7f, 0x34, 0x69, 0x75, 0xdb, 0x56, 0x6f, 0x9b, 0x4d, 0x13, 0x7f, 0x4e, 0xe1, 0x6, 0x44, 0xc2, 0xa2, 0xda, 0x66, 0xde, 0xec, 0xa5, 0x34, 0x2e, 0x23, 0x64, 0x95, 0xc3, 0xc6, 0x28, 0x5, 0x28, 0xbf, 0xd3, 0x2e, 0x90, 0xaf, 0x4c, 0xd9, 0xbb, 0x90, 0x8f, 0x34, 0x1, 0x2b, 0x52, 0xb4, 0xbc, 0x56, 0xd4, 0x8c, 0xc8, 0xa6, 0xb5, 0x9b, 0xab, 0x1, 0x49, 0x88, 0xea, 0xbd, 0x12, 0xe1, 0xa0, 0xa1, 0xc2, 0xe1, 0x70, 0xe7},
+               output224: []byte{0x4f, 0xef, 0xbe, 0x74, 0x64, 0x59, 0x49, 0xa1, 0x29, 0x1c, 0x6f, 0x6f, 0x5, 0xea, 0xf4, 0xb7, 0x80, 0xea, 0x1, 0xec, 0x5e, 0xa5, 0x10, 0x5e, 0xcd, 0xcb, 0x98, 0x4a},
+               output256: []byte{0x65, 0xeb, 0x4b, 0xd5, 0xec, 0xca, 0x71, 0x64, 0xce, 0x9b, 0x66, 0x72, 0x7f, 0x11, 0x2c, 0x1a, 0xc6, 0x12, 0xd, 0xdd, 0x20, 0xd, 0xcb, 0x5c, 0xe7, 0x5b, 0x74, 0x87, 0x84, 0x3f, 0xcd, 0xb8},
+               output384: []byte{0x9c, 0x8a, 0x4f, 0x5b, 0xe0, 0x1a, 0xd5, 0xae, 0x9, 0x46, 0xef, 0x7e, 0x9f, 0x5a, 0x82, 0x28, 0x7b, 0x63, 0x44, 0xb9, 0x66, 0xee, 0x28, 0xbd, 0xed, 0xfe, 0x4b, 0xd4, 0x3d, 0x84, 0xd, 0x23, 0x20, 0x54, 0xd5, 0xe2, 0x16, 0x71, 0x6e, 0xa4, 0xf8, 0xb, 0x45, 0x7c, 0xbc, 0x11, 0xd, 0x1a},
+               output512: []byte{0xe5, 0x10, 0x6b, 0x2a, 0xd, 0x49, 0xd6, 0xd1, 0xe1, 0x3e, 0x33, 0x23, 0x23, 0x21, 0x1, 0xce, 0xa5, 0xda, 0x71, 0xca, 0xa2, 0x4e, 0x70, 0xef, 0xca, 0xc5, 0x7e, 0xc, 0xcf, 0x15, 0x6c, 0xdf, 0x4c, 0x24, 0x92, 0xb0, 0x3c, 0xe0, 0xe1, 0x34, 0x37, 0x1, 0x8d, 0xab, 0x76, 0xb9, 0xc9, 0x89, 0x88, 0x3b, 0xea, 0x69, 0xe8, 0x49, 0xf3, 0x3b, 0xb9, 0x37, 0xa3, 0x97, 0xb8, 0x4a, 0xda, 0x6a}},
+       testcase{
+               msg:       []byte{0x2d, 0x84, 0x27, 0x43, 0x3d, 0xc, 0x61, 0xf2, 0xd9, 0x6c, 0xfe, 0x80, 0xcf, 0x1e, 0x93, 0x22, 0x65, 0xa1, 0x91, 0x36, 0x5c, 0x3b, 0x61, 0xaa, 0xa3, 0xd6, 0xdc, 0xc0, 0x39, 0xf6, 0xba, 0x2a, 0xd5, 0x2a, 0x6a, 0x8c, 0xc3, 0xf, 0xc1, 0xf, 0x70, 0x5e, 0x6b, 0x77, 0x5, 0x10, 0x59, 0x77, 0xfa, 0x49, 0x6c, 0x1c, 0x70, 0x8a, 0x27, 0x7a, 0x12, 0x43, 0x4, 0xf1, 0xfc, 0x40, 0x91, 0x1e, 0x74, 0x41, 0xd1, 0xb5, 0xe7, 0x7b, 0x95, 0x1a, 0xad, 0x7b, 0x1, 0xfd, 0x5d, 0xb1, 0xb3, 0x77, 0xd1, 0x65, 0xb0, 0x5b, 0xbf, 0x89, 0x80, 0x42, 0xe3, 0x96, 0x60, 0xca, 0xf8, 0xb2, 0x79, 0xfe, 0x52, 0x29, 0xd1, 0xa8, 0xdb, 0x86, 0xc0, 0x99, 0x9e, 0xd6, 0x5e, 0x53, 0xd0, 0x1c, 0xcb, 0xc4, 0xb4, 0x31, 0x73, 0xcc, 0xf9, 0x92, 0xb3, 0xa1, 0x45, 0x86, 0xf6, 0xba, 0x42, 0xf5, 0xfe, 0x30, 0xaf, 0xa8, 0xae, 0x40, 0xc5, 0xdf, 0x29, 0x96, 0x6f, 0x93, 0x46, 0xda, 0x5f, 0x8b, 0x35, 0xf1, 0x6a, 0x1d, 0xe3, 0xab, 0x6d, 0xe0, 0xf4, 0x77, 0xd8, 0xd8, 0x66, 0x9, 0x18, 0x6, 0xe, 0x88, 0xb9, 0xb9, 0xe9, 0xca, 0x6a, 0x42, 0x7, 0x3, 0x3b, 0x87, 0xa8, 0x12, 0xdb, 0xf5, 0x54, 0x4d, 0x39, 0xe4, 0x88, 0x20, 0x10, 0xf8, 0x2b, 0x6c, 0xe0, 0x5, 0xf8, 0xe8, 0xff, 0x6f, 0xe3, 0xc3, 0x80, 0x6b, 0xc2, 0xb7, 0x3c, 0x2b, 0x83, 0xaf, 0xb7, 0x4, 0x34, 0x56, 0x29, 0x30, 0x4f, 0x9f, 0x86, 0x35, 0x87, 0x12, 0xe9, 0xfa, 0xe3, 0xca, 0x3e},
+               output224: []byte{0x7c, 0xc9, 0xee, 0xbb, 0xe0, 0xdf, 0x46, 0xa3, 0x98, 0x23, 0x3f, 0xa3, 0x12, 0x86, 0xf8, 0xa5, 0x30, 0x29, 0x2b, 0x53, 0xe4, 0x8b, 0xa5, 0x4b, 0x6a, 0xe4, 0x4, 0x72},
+               output256: []byte{0xd7, 0x15, 0x5f, 0x6d, 0x3a, 0x90, 0x80, 0x1f, 0x5e, 0x54, 0x76, 0x89, 0x38, 0x9f, 0xf6, 0x2a, 0x60, 0x4c, 0x81, 0xb7, 0xc1, 0x58, 0x3d, 0x92, 0x4, 0xac, 0x6b, 0x1, 0x94, 0xf0, 0xe8, 0xdd},
+               output384: []byte{0xa2, 0x9b, 0xcb, 0x89, 0xfd, 0x2b, 0x89, 0x0, 0x67, 0x82, 0x8, 0x8b, 0xf9, 0xa4, 0xab, 0x93, 0x9e, 0xab, 0xaf, 0xf6, 0xf4, 0xee, 0xfc, 0x31, 0xb0, 0x1a, 0x66, 0xb7, 0x3c, 0xdf, 0xb, 0x97, 0x7d, 0x94, 0x5e, 0x5, 0x1d, 0x7e, 0x9f, 0x2, 0xf1, 0x9c, 0xf3, 0x2a, 0xd4, 0xbe, 0xba, 0x6c},
+               output512: []byte{0xfa, 0xee, 0x46, 0x2e, 0x4b, 0xce, 0xd1, 0x2a, 0xd5, 0x4d, 0x37, 0x57, 0xd6, 0x44, 0x39, 0x6e, 0xd9, 0x20, 0x30, 0x37, 0x74, 0x16, 0x61, 0xae, 0xa3, 0x2b, 0xcc, 0xad, 0xae, 0x56, 0x8c, 0x4b, 0xdc, 0x92, 0x5e, 0xda, 0x76, 0x61, 0xe, 0x96, 0x4f, 0xbe, 0x3f, 0xb2, 0x6b, 0x33, 0xbc, 0xb, 0xc1, 0x23, 0xdd, 0xf9, 0xb5, 0x28, 0x71, 0x53, 0x17, 0xce, 0x5c, 0x92, 0xe0, 0xa, 0xc9, 0x6f}},
+       testcase{
+               msg:       []byte{0x5e, 0x19, 0xd9, 0x78, 0x87, 0xfc, 0xaa, 0xc0, 0x38, 0x7e, 0x22, 0xc6, 0xf8, 0x3, 0xc3, 0x4a, 0x3d, 0xac, 0xd2, 0x60, 0x41, 0x72, 0x43, 0x3f, 0x7a, 0x8a, 0x7a, 0x52, 0x6c, 0xa4, 0xa2, 0xa1, 0x27, 0x1e, 0xcf, 0xc5, 0xd5, 0xd7, 0xbe, 0x5a, 0xc0, 0xd8, 0x5d, 0x92, 0x10, 0x95, 0x35, 0xd, 0xfc, 0x65, 0x99, 0x7d, 0x44, 0x3c, 0x21, 0xc8, 0x9, 0x4e, 0xa, 0x3f, 0xef, 0xd2, 0x96, 0x1b, 0xcb, 0x94, 0xae, 0xd0, 0x32, 0x91, 0xae, 0x31, 0xc, 0xcd, 0xa7, 0x5d, 0x8a, 0xce, 0x4b, 0xc7, 0xd8, 0x9e, 0x7d, 0x3e, 0x5d, 0x16, 0x50, 0xbd, 0xa5, 0xd6, 0x68, 0xb8, 0xb5, 0xb, 0xfc, 0x8e, 0x60, 0x8e, 0x18, 0x4f, 0x4d, 0x3a, 0x9a, 0x2b, 0xad, 0xc4, 0xff, 0x5f, 0x7, 0xe0, 0xc0, 0xbc, 0x8a, 0x9f, 0x2e, 0xb, 0x2a, 0x26, 0xfd, 0x6d, 0x8c, 0x55, 0x0, 0x8, 0xfa, 0xaa, 0xb7, 0x5f, 0xd7, 0x1a, 0xf2, 0xa4, 0x24, 0xbe, 0xc9, 0xa7, 0xcd, 0x9d, 0x83, 0xfa, 0xd4, 0xc8, 0xe9, 0x31, 0x91, 0x15, 0x65, 0x6a, 0x87, 0x17, 0xd3, 0xb5, 0x23, 0xa6, 0x8f, 0xf8, 0x0, 0x42, 0x58, 0xb9, 0x99, 0xe, 0xd3, 0x62, 0x30, 0x84, 0x61, 0x80, 0x4b, 0xa3, 0xe3, 0xa7, 0xe9, 0x2d, 0x8f, 0x2f, 0xfa, 0xe5, 0xc2, 0xfb, 0xa5, 0x5b, 0xa5, 0xa3, 0xc2, 0x7c, 0xa, 0x2f, 0x71, 0xbd, 0x71, 0x1d, 0x2f, 0xe1, 0x79, 0x9c, 0x2a, 0xdb, 0x31, 0xb2, 0x0, 0x3, 0x54, 0x81, 0xe9, 0xee, 0x5c, 0x4a, 0xdf, 0x2a, 0xb9, 0xc0, 0xfa, 0x50, 0xb2, 0x39, 0x75, 0xcf},
+               output224: []byte{0x3, 0xd7, 0x18, 0xda, 0x67, 0x7c, 0x40, 0x18, 0xe5, 0x22, 0x88, 0xbb, 0x30, 0xe4, 0xe6, 0xe7, 0x32, 0xa1, 0x61, 0x44, 0x93, 0x11, 0x76, 0xf0, 0xa8, 0xc7, 0x39, 0x70},
+               output256: []byte{0xaa, 0x7a, 0xda, 0xf1, 0x6f, 0x39, 0xe3, 0x98, 0xb4, 0xab, 0xa, 0xda, 0x3, 0x77, 0x10, 0x55, 0x6b, 0x72, 0xb, 0x2, 0x48, 0xd8, 0x48, 0x17, 0xb2, 0xcf, 0xdf, 0x76, 0x0, 0x93, 0x35, 0x95},
+               output384: []byte{0x61, 0xd3, 0xb1, 0x37, 0x28, 0x92, 0x56, 0x46, 0x47, 0x6d, 0x67, 0xc8, 0xd6, 0x26, 0xd2, 0xec, 0xe6, 0x9d, 0x9b, 0x42, 0x50, 0x3f, 0xa6, 0xa0, 0xdf, 0x2b, 0x24, 0xa5, 0xf2, 0xab, 0xf, 0xb7, 0xd7, 0x4c, 0x2f, 0x1f, 0x7f, 0x4, 0x30, 0x4c, 0x49, 0xac, 0x94, 0xbd, 0x4e, 0x93, 0xfd, 0xa4},
+               output512: []byte{0xfb, 0xe2, 0x5b, 0x43, 0xe5, 0x40, 0x10, 0x4a, 0x3a, 0xad, 0xe8, 0x97, 0x83, 0x8c, 0x63, 0x51, 0x19, 0x28, 0xaf, 0x5a, 0xdd, 0x4f, 0x95, 0x2f, 0x1e, 0x6d, 0x4c, 0x39, 0xe7, 0xc, 0x92, 0x3d, 0xf1, 0x91, 0xfa, 0xa3, 0x6f, 0x46, 0xb2, 0x1f, 0x82, 0x7d, 0x9b, 0x43, 0x79, 0x96, 0xff, 0x72, 0x6, 0xf7, 0x33, 0x37, 0xcf, 0x20, 0xc6, 0xb0, 0xdb, 0x74, 0x8a, 0x70, 0x74, 0x55, 0xb4, 0x20}},
+       testcase{
+               msg:       []byte{0xc8, 0xe9, 0x76, 0xab, 0x46, 0x38, 0x90, 0x93, 0x87, 0xce, 0x3b, 0x8d, 0x4e, 0x51, 0xc, 0x32, 0x30, 0xe5, 0x69, 0xe, 0x2, 0xc4, 0x50, 0x93, 0xb1, 0xd2, 0x97, 0x91, 0xa, 0xbc, 0x48, 0x1e, 0x56, 0xee, 0xa0, 0xf2, 0x96, 0xf9, 0x83, 0x79, 0xdf, 0xc9, 0x8, 0xa, 0xf6, 0x9e, 0x73, 0xb2, 0x39, 0x9d, 0x1c, 0x14, 0x3b, 0xee, 0x80, 0xae, 0x13, 0x28, 0x16, 0x2c, 0xe1, 0xba, 0x7f, 0x6a, 0x83, 0x74, 0x67, 0x9b, 0x20, 0xaa, 0xcd, 0x38, 0xe, 0xb4, 0xe6, 0x13, 0x82, 0xc9, 0x99, 0x98, 0x70, 0x4d, 0x62, 0x70, 0x1a, 0xfa, 0x91, 0x4f, 0x9a, 0x27, 0x5, 0xcd, 0xb0, 0x65, 0x88, 0x5f, 0x50, 0xd0, 0x86, 0xc3, 0xeb, 0x57, 0x53, 0x70, 0xc, 0x38, 0x71, 0x18, 0xbb, 0x14, 0x2f, 0x3e, 0x6d, 0xa1, 0xe9, 0x88, 0xdf, 0xb3, 0x1a, 0xc7, 0x5d, 0x73, 0x68, 0x93, 0x1e, 0x45, 0xd1, 0x39, 0x1a, 0x27, 0x4b, 0x22, 0xf8, 0x3c, 0xeb, 0x7, 0x2f, 0x9b, 0xca, 0xbc, 0xb, 0x21, 0x66, 0x85, 0xbf, 0xd7, 0x89, 0xf5, 0x2, 0x39, 0x71, 0x2, 0x4b, 0x18, 0x78, 0xa2, 0x5, 0x44, 0x25, 0x22, 0xf9, 0xea, 0x7d, 0x87, 0x97, 0xa4, 0x10, 0x2a, 0x3d, 0xf4, 0x17, 0x3, 0x76, 0x82, 0x51, 0xfd, 0x5e, 0x1, 0x7c, 0x85, 0xd1, 0x20, 0xa, 0x46, 0x41, 0x18, 0xaa, 0x35, 0x65, 0x4e, 0x7c, 0xa3, 0x9f, 0x3c, 0x37, 0x5b, 0x8e, 0xf8, 0xcb, 0xe7, 0x53, 0x4d, 0xbc, 0x64, 0xbc, 0x20, 0xbe, 0xfb, 0x41, 0x7c, 0xf6, 0xe, 0xc9, 0x2f, 0x63, 0xd9, 0xee, 0x73, 0x97},
+               output224: []byte{0xa9, 0xab, 0xb4, 0x30, 0xfc, 0x1b, 0x3d, 0x8c, 0x6c, 0xde, 0xb5, 0x31, 0x98, 0x78, 0xe7, 0xb1, 0x2b, 0x11, 0x8e, 0x2e, 0x3, 0xf4, 0x5, 0x62, 0xa3, 0x76, 0x41, 0x8c},
+               output256: []byte{0xb1, 0x95, 0x46, 0x3f, 0xe2, 0x2a, 0x16, 0x8, 0x2, 0xbe, 0xa, 0x4, 0x64, 0xee, 0x3a, 0xb4, 0xd2, 0xb1, 0x17, 0xde, 0x51, 0x7b, 0x33, 0x1c, 0x7b, 0xf0, 0x4c, 0x8b, 0xa9, 0xc, 0x61, 0x20},
+               output384: []byte{0x58, 0x9a, 0xb9, 0x98, 0x1d, 0x9a, 0xbd, 0x1d, 0x71, 0x2d, 0x59, 0xc6, 0x86, 0x3d, 0x85, 0xb, 0xb1, 0xd4, 0x12, 0xd2, 0x4a, 0x96, 0x7d, 0x76, 0xcc, 0xe7, 0x8f, 0xfc, 0x99, 0x8f, 0x8c, 0x1, 0x6d, 0xd4, 0xb1, 0x15, 0xa1, 0xbc, 0x4d, 0xc4, 0x92, 0x48, 0xab, 0x5f, 0x75, 0x8c, 0x21, 0x5a},
+               output512: []byte{0xa, 0x41, 0xa0, 0x4, 0x57, 0x3e, 0xa, 0x98, 0x3f, 0xe9, 0xc9, 0x3b, 0xd5, 0x74, 0x39, 0xa2, 0xc, 0x8f, 0x99, 0xb8, 0x0, 0xa6, 0xd, 0x4a, 0x7, 0x11, 0x7e, 0x8d, 0x9b, 0x25, 0xc0, 0xee, 0x38, 0xba, 0xb3, 0xcd, 0xb6, 0xfc, 0x92, 0x16, 0xb8, 0xe0, 0x7f, 0xc, 0xcd, 0xd0, 0x28, 0xc4, 0x18, 0xef, 0x97, 0xb6, 0xd7, 0xe1, 0x5d, 0xec, 0xde, 0x74, 0x25, 0x49, 0x76, 0x44, 0xe2, 0xe4}},
+       testcase{
+               msg:       []byte{0x71, 0x45, 0xfa, 0x12, 0x4b, 0x74, 0x29, 0xa1, 0xfc, 0x22, 0x31, 0x23, 0x7a, 0x94, 0x9b, 0xa7, 0x20, 0x1b, 0xcc, 0x18, 0x22, 0xd3, 0x27, 0x2d, 0xe0, 0x5, 0xb6, 0x82, 0x39, 0x81, 0x96, 0xc2, 0x5f, 0x7e, 0x5c, 0xc2, 0xf2, 0x89, 0xfb, 0xf4, 0x44, 0x15, 0xf6, 0x99, 0xcb, 0x7f, 0xe6, 0x75, 0x77, 0x91, 0xb1, 0x44, 0x34, 0x10, 0x23, 0x4a, 0xe0, 0x61, 0xed, 0xf6, 0x23, 0x35, 0x9e, 0x2b, 0x4e, 0x32, 0xc1, 0x9b, 0xf8, 0x84, 0x50, 0x43, 0x2d, 0xd0, 0x1c, 0xaa, 0x5e, 0xb1, 0x6a, 0x1d, 0xc3, 0x78, 0xf3, 0x91, 0xca, 0x5e, 0x3c, 0x4e, 0x5f, 0x35, 0x67, 0x28, 0xbd, 0xdd, 0x49, 0x75, 0xdb, 0x7c, 0x89, 0xd, 0xa8, 0xbb, 0xc8, 0x4c, 0xc7, 0x3f, 0xf2, 0x44, 0x39, 0x4d, 0xd, 0x48, 0x95, 0x49, 0x78, 0x76, 0x5e, 0x4a, 0x0, 0xb5, 0x93, 0xf7, 0xf, 0x2c, 0xa0, 0x82, 0x67, 0x3a, 0x26, 0x1e, 0xd8, 0x8d, 0xbc, 0xef, 0x11, 0x27, 0x72, 0x8d, 0x8c, 0xd8, 0x9b, 0xc2, 0xc5, 0x97, 0xe9, 0x10, 0x2c, 0xed, 0x60, 0x10, 0xf6, 0x5f, 0xa7, 0x5a, 0x14, 0xeb, 0xe4, 0x67, 0xfa, 0x57, 0xce, 0x3b, 0xd4, 0x94, 0x8b, 0x68, 0x67, 0xd7, 0x4a, 0x9d, 0xf5, 0xc0, 0xec, 0x6f, 0x53, 0xc, 0xbf, 0x2e, 0xe6, 0x1c, 0xe6, 0xf0, 0x6b, 0xc8, 0xf2, 0x86, 0x4d, 0xff, 0x55, 0x83, 0x77, 0x6b, 0x31, 0xdf, 0x8c, 0x7f, 0xfc, 0xb6, 0x14, 0x28, 0xa5, 0x6b, 0xf7, 0xbd, 0x37, 0x18, 0x8b, 0x4a, 0x51, 0x23, 0xbb, 0xf3, 0x38, 0x39, 0x3a, 0xf4, 0x6e, 0xda, 0x85, 0xe6},
+               output224: []byte{0x4a, 0x7a, 0x58, 0xb3, 0x37, 0x87, 0x21, 0x89, 0xa0, 0x6b, 0x53, 0xb6, 0xbc, 0xc5, 0xc, 0x29, 0xef, 0x9d, 0xb, 0xbc, 0x49, 0x18, 0x32, 0x90, 0x7a, 0xf1, 0x4e, 0xc8},
+               output256: []byte{0x9f, 0x92, 0x96, 0xc5, 0x3e, 0x75, 0x3a, 0x4d, 0xe4, 0xe5, 0xc5, 0xa5, 0x47, 0xf5, 0x17, 0x63, 0xa9, 0x69, 0x3, 0xb0, 0x83, 0xfb, 0xc7, 0xa7, 0x82, 0x8e, 0xff, 0xe4, 0x76, 0x3a, 0x7c, 0xe6},
+               output384: []byte{0xb3, 0xcc, 0x72, 0x24, 0xa1, 0xdd, 0x20, 0x8e, 0x73, 0x9c, 0x55, 0x28, 0x23, 0x9b, 0x8d, 0x33, 0x5a, 0x12, 0x9e, 0xe2, 0xe, 0x59, 0x10, 0x26, 0x21, 0x18, 0xe, 0x6b, 0x51, 0x71, 0x4e, 0xd, 0x60, 0x7, 0x8f, 0x4e, 0x73, 0x28, 0x72, 0x64, 0x34, 0xae, 0x41, 0xca, 0x27, 0x35, 0x15, 0xba},
+               output512: []byte{0xff, 0x8, 0x15, 0x7, 0xf9, 0x79, 0xf6, 0x9c, 0x67, 0x43, 0xe4, 0x2e, 0xe7, 0x58, 0x85, 0x87, 0x13, 0xb5, 0x70, 0xcb, 0x48, 0xff, 0x85, 0xef, 0xd, 0x72, 0x8c, 0x4e, 0x1b, 0xb5, 0x45, 0x6d, 0x3, 0x5e, 0x49, 0x8c, 0x5, 0xea, 0x4c, 0xeb, 0xd8, 0x20, 0xe1, 0x34, 0xbb, 0x25, 0x2a, 0xc7, 0x6b, 0xa4, 0x94, 0x9a, 0x4f, 0xad, 0x76, 0x87, 0x1a, 0x99, 0x72, 0xae, 0x2f, 0xcc, 0xce, 0xea}},
+       testcase{
+               msg:       []byte{0x7f, 0xdf, 0xad, 0xcc, 0x9d, 0x29, 0xba, 0xd2, 0x3a, 0xe0, 0x38, 0xc6, 0xc6, 0x5c, 0xda, 0x1a, 0xef, 0x75, 0x72, 0x21, 0xb8, 0x87, 0x2e, 0xd3, 0xd7, 0x5f, 0xf8, 0xdf, 0x7d, 0xa0, 0x62, 0x7d, 0x26, 0x6e, 0x22, 0x4e, 0x81, 0x2c, 0x39, 0xf7, 0x98, 0x3e, 0x45, 0x58, 0xbf, 0xd0, 0xa1, 0xf2, 0xbe, 0xf3, 0xfe, 0xb5, 0x6b, 0xa0, 0x91, 0x20, 0xef, 0x76, 0x29, 0x17, 0xb9, 0xc0, 0x93, 0x86, 0x79, 0x48, 0x54, 0x7a, 0xee, 0x98, 0x60, 0xd, 0x10, 0xd8, 0x7b, 0x20, 0x10, 0x68, 0x78, 0xa8, 0xd2, 0x2c, 0x64, 0x37, 0x8b, 0xf6, 0x34, 0xf7, 0xf7, 0x59, 0x0, 0xc0, 0x39, 0x86, 0xb0, 0x77, 0xb0, 0xbf, 0x8b, 0x74, 0xa, 0x82, 0x44, 0x7b, 0x61, 0xb9, 0x9f, 0xee, 0x53, 0x76, 0xc5, 0xeb, 0x66, 0x80, 0xec, 0x9e, 0x30, 0x88, 0xf0, 0xbd, 0xd0, 0xc5, 0x68, 0x83, 0x41, 0x3d, 0x60, 0xc1, 0x35, 0x7d, 0x3c, 0x81, 0x19, 0x50, 0xe5, 0x89, 0xe, 0x76, 0x0, 0x10, 0x3c, 0x91, 0x63, 0x41, 0xb8, 0xc, 0x74, 0x3c, 0x6a, 0x85, 0x2b, 0x7b, 0x4f, 0xb6, 0xc, 0x3b, 0xa2, 0x1f, 0x3b, 0xc1, 0x5b, 0x83, 0x82, 0x43, 0x7a, 0x68, 0x45, 0x47, 0x79, 0xcf, 0x3c, 0xd7, 0xf9, 0xf9, 0xc, 0xcc, 0x8e, 0xf2, 0x8d, 0xb, 0x70, 0x65, 0x35, 0xb1, 0xe4, 0x10, 0x8e, 0xb5, 0x62, 0x7b, 0xb4, 0x5d, 0x71, 0x9c, 0xb0, 0x46, 0x83, 0x9a, 0xee, 0x31, 0x1c, 0xa1, 0xab, 0xdc, 0x83, 0x19, 0xe0, 0x50, 0xd6, 0x79, 0x72, 0xcb, 0x35, 0xa6, 0xb1, 0x60, 0x1b, 0x25, 0xdb, 0xf4, 0x87},
+               output224: []byte{0x80, 0x8e, 0x1, 0xcd, 0x27, 0x39, 0x19, 0xba, 0x1b, 0xff, 0x1, 0x1e, 0xe, 0x70, 0x94, 0xec, 0x6d, 0x5c, 0x49, 0x62, 0x91, 0x2b, 0x8, 0xf1, 0x19, 0x65, 0xab, 0x58},
+               output256: []byte{0x51, 0xde, 0x40, 0x90, 0xae, 0xc3, 0x6f, 0x6c, 0x44, 0x64, 0x76, 0xc7, 0x9, 0x25, 0x32, 0x72, 0xca, 0xb5, 0x95, 0xd9, 0x88, 0x7c, 0xa5, 0xd5, 0x2a, 0x9b, 0x38, 0x8, 0x68, 0x54, 0xd5, 0x8f},
+               output384: []byte{0xd3, 0x3a, 0xd2, 0xa7, 0x1c, 0x71, 0x2a, 0x6f, 0x8a, 0xd9, 0xac, 0x92, 0x39, 0x66, 0xb4, 0xdb, 0x8c, 0x48, 0x18, 0xc7, 0x9c, 0xc6, 0xf, 0x82, 0x75, 0x36, 0x7d, 0x24, 0x52, 0xcf, 0xd2, 0xf5, 0x54, 0x2f, 0xd1, 0x88, 0x8d, 0x64, 0xc9, 0xe9, 0x12, 0xb9, 0x2a, 0x18, 0x68, 0x42, 0xb0, 0x0},
+               output512: []byte{0x3, 0x44, 0x4a, 0xe8, 0x31, 0x9e, 0xbd, 0x12, 0x1e, 0x77, 0x7, 0xb9, 0xcd, 0xfd, 0x1f, 0xdf, 0xd5, 0x2f, 0x3d, 0x6b, 0x3d, 0x4b, 0xcb, 0x27, 0x48, 0xaf, 0x42, 0x1a, 0x3c, 0x86, 0x66, 0xc2, 0x2d, 0x8c, 0xd, 0x8a, 0x9, 0x67, 0x67, 0xb1, 0xcd, 0x16, 0xa8, 0xd5, 0x47, 0x38, 0xc5, 0xf6, 0x7a, 0x6f, 0x9d, 0x48, 0xc9, 0x8, 0x27, 0xbe, 0x71, 0x69, 0x1a, 0x42, 0xbe, 0x87, 0x10, 0x8b}},
+       testcase{
+               msg:       []byte{0x98, 0x86, 0x38, 0x21, 0x9f, 0xd3, 0x9, 0x54, 0x21, 0xf8, 0x26, 0xf5, 0x6e, 0x4f, 0x9, 0xe3, 0x56, 0x29, 0x6b, 0x62, 0x8c, 0x3c, 0xe6, 0x93, 0xc, 0x9f, 0x2e, 0x75, 0x8f, 0xd1, 0xa8, 0xc, 0x82, 0x73, 0xf2, 0xf6, 0x1e, 0x4d, 0xaa, 0xe6, 0x5c, 0x4f, 0x11, 0xd, 0x3e, 0x7c, 0xa0, 0x96, 0x5a, 0xc7, 0xd2, 0x4e, 0x34, 0xc0, 0xdc, 0x4b, 0xa2, 0xd6, 0xff, 0xb, 0xf5, 0xbb, 0xe9, 0x3b, 0x35, 0x85, 0xf3, 0x54, 0xd7, 0x54, 0x3c, 0xb5, 0x42, 0xa1, 0xaa, 0x54, 0x67, 0x4d, 0x37, 0x50, 0x77, 0xf2, 0xd3, 0x60, 0xa8, 0xf4, 0xd4, 0x2f, 0x3d, 0xb1, 0x31, 0xc3, 0xb7, 0xab, 0x73, 0x6, 0x26, 0x7b, 0xa1, 0x7, 0x65, 0x98, 0x64, 0xa9, 0xc, 0x8c, 0x90, 0x94, 0x60, 0xa7, 0x36, 0x21, 0xd1, 0xf5, 0xd9, 0xd3, 0xfd, 0x95, 0xbe, 0xb1, 0x9b, 0x23, 0xdb, 0x1c, 0xb6, 0xc0, 0xd0, 0xfb, 0xa9, 0x1d, 0x36, 0x89, 0x15, 0x29, 0xb8, 0xbd, 0x82, 0x63, 0xca, 0xa1, 0xba, 0xb5, 0x6a, 0x4a, 0xff, 0xae, 0xd4, 0x49, 0x62, 0xdf, 0x9, 0x6d, 0x8d, 0x5b, 0x1e, 0xb8, 0x45, 0xef, 0x31, 0x18, 0x8b, 0x3e, 0x10, 0xf1, 0xaf, 0x81, 0x1a, 0x13, 0xf1, 0x56, 0xbe, 0xb7, 0xa2, 0x88, 0xaa, 0xe5, 0x93, 0xeb, 0xd1, 0x47, 0x1b, 0x62, 0x4a, 0xa1, 0xa7, 0xc6, 0xad, 0xf0, 0x1e, 0x22, 0x0, 0xb3, 0xd7, 0x2d, 0x88, 0xa3, 0xae, 0xd3, 0x10, 0xc, 0x88, 0x23, 0x1e, 0x41, 0xef, 0xc3, 0x76, 0x90, 0x6f, 0xb, 0x58, 0xd, 0xc8, 0x95, 0xf0, 0x80, 0xfd, 0xa5, 0x74, 0x1d, 0xb1, 0xcb},
+               output224: []byte{0xdc, 0xbc, 0xc3, 0xb, 0x69, 0x9, 0xfd, 0xf0, 0x6, 0x50, 0xf1, 0xa1, 0xc, 0xfb, 0xbd, 0x41, 0x94, 0x8, 0xf9, 0xd3, 0x7f, 0x37, 0x8c, 0x5c, 0xa6, 0x93, 0xb8, 0x3},
+               output256: []byte{0x87, 0xa1, 0x74, 0x0, 0xf9, 0x19, 0xf2, 0xf5, 0x32, 0x32, 0xb2, 0x20, 0x5e, 0x1e, 0x8b, 0x14, 0xbd, 0x56, 0x98, 0xa7, 0x6e, 0x74, 0xb9, 0xbd, 0xd5, 0x63, 0x8a, 0x5c, 0x7b, 0xa5, 0xde, 0x1e},
+               output384: []byte{0xc1, 0x2d, 0x45, 0xa, 0x2, 0xc, 0xde, 0x18, 0xc2, 0x43, 0x23, 0xfb, 0x4e, 0x3f, 0xb2, 0x32, 0x55, 0x71, 0x4b, 0x1d, 0x4c, 0xbf, 0x29, 0x71, 0x9f, 0x74, 0xda, 0x5e, 0x61, 0x51, 0xfa, 0xe9, 0x1, 0xdc, 0x21, 0xa6, 0x68, 0xa, 0xd1, 0x59, 0xff, 0xb2, 0xe7, 0xc0, 0xaa, 0xab, 0xdf, 0x5b},
+               output512: []byte{0x5e, 0xe0, 0xa4, 0x45, 0x97, 0x24, 0x3, 0x7b, 0x73, 0x18, 0x81, 0x5a, 0x80, 0x14, 0x7c, 0x17, 0x2d, 0x6c, 0x8f, 0x88, 0x74, 0xc9, 0xa0, 0x5, 0x77, 0x6, 0xfb, 0x3e, 0x30, 0xf, 0xe9, 0x36, 0x81, 0x5f, 0x7, 0x67, 0x2e, 0x64, 0x47, 0xb7, 0x71, 0xde, 0x69, 0x9d, 0xfa, 0xdf, 0x34, 0x5c, 0x3b, 0xb5, 0x97, 0x4c, 0xf0, 0x19, 0x31, 0x5f, 0xad, 0xd5, 0x53, 0x4d, 0xff, 0x6a, 0x7, 0x9c}},
+       testcase{
+               msg:       []byte{0x5a, 0xab, 0x62, 0x75, 0x6d, 0x30, 0x7a, 0x66, 0x9d, 0x14, 0x6a, 0xba, 0x98, 0x8d, 0x90, 0x74, 0xc5, 0xa1, 0x59, 0xb3, 0xde, 0x85, 0x15, 0x1a, 0x81, 0x9b, 0x11, 0x7c, 0xa1, 0xff, 0x65, 0x97, 0xf6, 0x15, 0x6e, 0x80, 0xfd, 0xd2, 0x8c, 0x9c, 0x31, 0x76, 0x83, 0x51, 0x64, 0xd3, 0x7d, 0xa7, 0xda, 0x11, 0xd9, 0x4e, 0x9, 0xad, 0xd7, 0x70, 0xb6, 0x8a, 0x6e, 0x8, 0x1c, 0xd2, 0x2c, 0xa0, 0xc0, 0x4, 0xbf, 0xe7, 0xcd, 0x28, 0x3b, 0xf4, 0x3a, 0x58, 0x8d, 0xa9, 0x1f, 0x50, 0x9b, 0x27, 0xa6, 0x58, 0x4c, 0x47, 0x4a, 0x4a, 0x2f, 0x3e, 0xe0, 0xf1, 0xf5, 0x64, 0x47, 0x37, 0x92, 0x40, 0xa5, 0xab, 0x1f, 0xb7, 0x7f, 0xdc, 0xa4, 0x9b, 0x30, 0x5f, 0x7, 0xba, 0x86, 0xb6, 0x27, 0x56, 0xfb, 0x9e, 0xfb, 0x4f, 0xc2, 0x25, 0xc8, 0x68, 0x45, 0xf0, 0x26, 0xea, 0x54, 0x20, 0x76, 0xb9, 0x1a, 0xb, 0xc2, 0xcd, 0xd1, 0x36, 0xe1, 0x22, 0xc6, 0x59, 0xbe, 0x25, 0x9d, 0x98, 0xe5, 0x84, 0x1d, 0xf4, 0xc2, 0xf6, 0x3, 0x30, 0xd4, 0xd8, 0xcd, 0xee, 0x7b, 0xf1, 0xa0, 0xa2, 0x44, 0x52, 0x4e, 0xec, 0xc6, 0x8f, 0xf2, 0xae, 0xf5, 0xbf, 0x0, 0x69, 0xc9, 0xe8, 0x7a, 0x11, 0xc6, 0xe5, 0x19, 0xde, 0x1a, 0x40, 0x62, 0xa1, 0xc, 0x83, 0x83, 0x73, 0x88, 0xf7, 0xef, 0x58, 0x59, 0x8a, 0x38, 0x46, 0xf4, 0x9d, 0x49, 0x96, 0x82, 0xb6, 0x83, 0xc4, 0xa0, 0x62, 0xb4, 0x21, 0x59, 0x4f, 0xaf, 0xbc, 0x13, 0x83, 0xc9, 0x43, 0xba, 0x83, 0xbd, 0xef, 0x51, 0x5e, 0xfc, 0xf1, 0xd},
+               output224: []byte{0xbe, 0x7, 0x7f, 0x12, 0x76, 0x2e, 0xf5, 0x18, 0x59, 0xb6, 0xc5, 0x20, 0xb1, 0x92, 0x31, 0xe3, 0x4, 0x42, 0xac, 0x26, 0x8c, 0xe4, 0xfd, 0x47, 0x36, 0x6f, 0xf9, 0xf1},
+               output256: []byte{0x97, 0x42, 0x53, 0x6c, 0x46, 0x1d, 0xc, 0x35, 0x3, 0xa6, 0xc9, 0x43, 0xfa, 0x81, 0x5, 0xdb, 0xcd, 0x1e, 0x54, 0x2f, 0x72, 0x8d, 0x71, 0xcc, 0xc0, 0x51, 0x7c, 0xff, 0xc2, 0x32, 0xea, 0x68},
+               output384: []byte{0xe5, 0xb7, 0xa9, 0xb4, 0x1f, 0xa0, 0xce, 0xc3, 0x25, 0x2f, 0xf9, 0x50, 0x99, 0x52, 0x3d, 0xc8, 0x45, 0xc6, 0x9b, 0x67, 0xd, 0x8d, 0xfe, 0xba, 0x3e, 0x4a, 0xf6, 0xde, 0xc6, 0x59, 0xc4, 0xb2, 0xd4, 0xb0, 0x4f, 0x5f, 0x70, 0x62, 0x20, 0x94, 0x85, 0xa3, 0x7c, 0x54, 0x2c, 0xcb, 0xe7, 0xe6},
+               output512: []byte{0x54, 0x8, 0x5a, 0x2f, 0x9c, 0x32, 0x7e, 0x5d, 0x8e, 0xe2, 0x25, 0xef, 0xf5, 0xbd, 0x2c, 0x28, 0x37, 0xe4, 0x4e, 0x80, 0x57, 0xcf, 0x16, 0x91, 0xe6, 0x20, 0x20, 0x50, 0x7, 0x9d, 0x26, 0x85, 0x10, 0x61, 0xc4, 0xda, 0x8d, 0x88, 0xfc, 0x19, 0x23, 0x7e, 0x5b, 0x65, 0x89, 0x50, 0xe6, 0x68, 0x66, 0xe9, 0x20, 0x19, 0xd9, 0xe4, 0x25, 0xe2, 0x41, 0x62, 0x40, 0xa5, 0x9d, 0x25, 0xa6, 0xcf}},
+       testcase{
+               msg:       []byte{0x47, 0xb8, 0x21, 0x6a, 0xa0, 0xfb, 0xb5, 0xd6, 0x79, 0x66, 0xf2, 0xe8, 0x2c, 0x17, 0xc0, 0x7a, 0xa2, 0xd6, 0x32, 0x7e, 0x96, 0xfc, 0xd8, 0x3e, 0x3d, 0xe7, 0x33, 0x36, 0x89, 0xf3, 0xee, 0x79, 0x99, 0x4a, 0x1b, 0xf4, 0x50, 0x82, 0xc4, 0xd7, 0x25, 0xed, 0x8d, 0x41, 0x20, 0x5c, 0xb5, 0xbc, 0xdf, 0x5c, 0x34, 0x1f, 0x77, 0xfa, 0xcb, 0x1d, 0xa4, 0x6a, 0x5b, 0x9b, 0x2c, 0xbc, 0x49, 0xea, 0xdf, 0x78, 0x6b, 0xcd, 0x88, 0x1f, 0x37, 0x1a, 0x95, 0xfa, 0x17, 0xdf, 0x73, 0xf6, 0x6, 0x51, 0x9a, 0xea, 0xf, 0xf7, 0x9d, 0x5a, 0x11, 0x42, 0x7b, 0x98, 0xee, 0x7f, 0x13, 0xa5, 0xc0, 0x6, 0x37, 0xe2, 0x85, 0x41, 0x34, 0x69, 0x10, 0x59, 0x83, 0x91, 0x21, 0xfe, 0xa9, 0xab, 0xe2, 0xcd, 0x1b, 0xcb, 0xbb, 0xf2, 0x7c, 0x74, 0xca, 0xf3, 0x67, 0x8e, 0x5, 0xbf, 0xb1, 0xc9, 0x49, 0x89, 0x7e, 0xa0, 0x1f, 0x56, 0xff, 0xa4, 0xda, 0xfb, 0xe8, 0x64, 0x46, 0x11, 0x68, 0x5c, 0x61, 0x7a, 0x32, 0x6, 0xc7, 0xa7, 0x3, 0x6e, 0x4a, 0xc8, 0x16, 0x79, 0x9f, 0x69, 0x3d, 0xaf, 0xe7, 0xf1, 0x9f, 0x30, 0x3c, 0xe4, 0xeb, 0xa0, 0x9d, 0x21, 0xe0, 0x36, 0x10, 0x20, 0x1b, 0xfc, 0x66, 0x5b, 0x72, 0x40, 0xa, 0x54, 0x7a, 0x1e, 0x0, 0xfa, 0x9b, 0x7a, 0xd8, 0xd8, 0x4f, 0x84, 0xb3, 0x4a, 0xef, 0x11, 0x85, 0x15, 0xe7, 0x4d, 0xef, 0x11, 0xb9, 0x18, 0x8b, 0xd1, 0xe1, 0xf9, 0x7d, 0x9a, 0x12, 0xc3, 0x1, 0x32, 0xec, 0x28, 0x6, 0x33, 0x9b, 0xda, 0xda, 0xcd, 0xa2, 0xfd, 0x8b, 0x78},
+               output224: []byte{0x25, 0xc4, 0x25, 0x26, 0x5a, 0xb0, 0x7d, 0xa, 0x8e, 0xc6, 0x59, 0xd4, 0xd5, 0xee, 0x61, 0x8b, 0xde, 0x87, 0x0, 0x3b, 0x72, 0x55, 0xff, 0x4b, 0x53, 0x15, 0xf1, 0xc7},
+               output256: []byte{0xae, 0x3b, 0xf0, 0x93, 0x64, 0x97, 0xa2, 0x95, 0x5d, 0xf8, 0x74, 0xb7, 0xf2, 0x68, 0x53, 0x14, 0xc7, 0x60, 0x60, 0x30, 0xb9, 0xc6, 0xe7, 0xbf, 0xb8, 0xa8, 0xdf, 0xf9, 0x82, 0x59, 0x57, 0xb5},
+               output384: []byte{0x5e, 0x2b, 0xa5, 0x38, 0x2c, 0x35, 0x7b, 0x5a, 0x19, 0x87, 0xbd, 0xab, 0x9a, 0x2a, 0xb, 0x5, 0x3e, 0xb7, 0x5e, 0xe7, 0x70, 0xe1, 0x99, 0x4e, 0x63, 0xf, 0x24, 0x1, 0x5a, 0xb1, 0x2, 0xe4, 0x82, 0xa9, 0x5a, 0x25, 0xb6, 0x8f, 0x5d, 0xe9, 0x9f, 0xe9, 0x74, 0x8f, 0xa4, 0x8f, 0xf6, 0x96},
+               output512: []byte{0x3e, 0xa4, 0x9b, 0x6a, 0xbd, 0x39, 0xcd, 0xf0, 0x4b, 0xcc, 0xd6, 0x48, 0xfb, 0x7e, 0x1f, 0x8a, 0xe3, 0xda, 0xe9, 0xd3, 0xe3, 0xa5, 0xea, 0xb9, 0xce, 0x29, 0xbe, 0x35, 0x6d, 0xef, 0xbb, 0xbe, 0xb1, 0xbb, 0x93, 0xae, 0x40, 0xd3, 0x1c, 0xc1, 0xf0, 0x11, 0xdc, 0xc6, 0xc6, 0xac, 0x85, 0xb1, 0x2, 0xf2, 0x65, 0x4e, 0x2d, 0xbb, 0xac, 0x47, 0x33, 0x3b, 0xcd, 0xb4, 0x75, 0x8a, 0x1a, 0x28}},
+       testcase{
+               msg:       []byte{0x8c, 0xff, 0x1f, 0x67, 0xfe, 0x53, 0xc0, 0x98, 0x89, 0x6d, 0x91, 0x36, 0x38, 0x9b, 0xd8, 0x88, 0x18, 0x16, 0xcc, 0xab, 0x34, 0x86, 0x2b, 0xb6, 0x7a, 0x65, 0x6e, 0x3d, 0x98, 0x89, 0x6f, 0x3c, 0xe6, 0xff, 0xd4, 0xda, 0x73, 0x97, 0x58, 0x9, 0xfc, 0xdf, 0x96, 0x66, 0x76, 0xd, 0x6e, 0x56, 0x1c, 0x55, 0x23, 0x8b, 0x20, 0x5d, 0x80, 0x49, 0xc1, 0xce, 0xde, 0xef, 0x37, 0x4d, 0x17, 0x35, 0xda, 0xa5, 0x33, 0x14, 0x7b, 0xfa, 0x96, 0xb, 0x2c, 0xce, 0x4a, 0x4f, 0x25, 0x41, 0x76, 0xbb, 0x4d, 0x1b, 0xd1, 0xe8, 0x96, 0x54, 0x43, 0x2b, 0x8d, 0xbe, 0x1a, 0x13, 0x5c, 0x42, 0x11, 0x5b, 0x39, 0x4b, 0x2, 0x48, 0x56, 0xa2, 0xa8, 0x3d, 0xc8, 0x5d, 0x67, 0x82, 0xbe, 0x4b, 0x44, 0x42, 0x39, 0x56, 0x7c, 0xce, 0xc4, 0xb1, 0x84, 0xd4, 0x54, 0x8e, 0xae, 0x3f, 0xf6, 0xa1, 0x92, 0xf3, 0x43, 0x29, 0x2b, 0xa2, 0xe3, 0x2a, 0xf, 0x26, 0x7f, 0x31, 0xcc, 0x26, 0x71, 0x9e, 0xb8, 0x52, 0x45, 0xd4, 0x15, 0xfb, 0x89, 0x7a, 0xc2, 0xda, 0x43, 0x3e, 0xe9, 0x1a, 0x99, 0x42, 0x4c, 0x9d, 0x7f, 0x17, 0x66, 0xa4, 0x41, 0x71, 0xd1, 0x65, 0x10, 0x1, 0xc3, 0x8f, 0xc7, 0x92, 0x94, 0xac, 0xcc, 0x68, 0xce, 0xb5, 0x66, 0x5d, 0x36, 0x21, 0x84, 0x54, 0xd3, 0xba, 0x16, 0x9a, 0xe0, 0x58, 0xa8, 0x31, 0x33, 0x8c, 0x17, 0x74, 0x36, 0x3, 0xf8, 0x1e, 0xe1, 0x73, 0xbf, 0xc0, 0x92, 0x74, 0x64, 0xf9, 0xbd, 0x72, 0x8d, 0xee, 0x94, 0xc6, 0xae, 0xab, 0x7a, 0xae, 0x6e, 0xe3, 0xa6, 0x27, 0xe8},
+               output224: []byte{0x4, 0x6c, 0xf6, 0x2c, 0x41, 0xce, 0x9b, 0xf, 0x54, 0xb6, 0x67, 0x55, 0x80, 0x63, 0x2, 0x3f, 0x59, 0x88, 0x7b, 0xad, 0xa9, 0xcc, 0x28, 0x84, 0x14, 0xad, 0xee, 0x7f},
+               output256: []byte{0x5f, 0xe0, 0x21, 0x6d, 0xcc, 0x1b, 0xdb, 0x48, 0xf3, 0x37, 0x5b, 0x91, 0x73, 0xb7, 0xb2, 0x32, 0x93, 0x9a, 0xa2, 0x17, 0x7c, 0x6d, 0x5, 0x6e, 0x90, 0x8c, 0x8f, 0x2b, 0x92, 0x93, 0xb0, 0x30},
+               output384: []byte{0x4, 0x67, 0xc2, 0xb9, 0xf0, 0x2a, 0xf8, 0xce, 0xaf, 0x4f, 0x8f, 0xe8, 0x8d, 0x1d, 0xe3, 0xee, 0x3, 0xd7, 0x8e, 0xc2, 0x6e, 0xde, 0xe0, 0xe3, 0x4b, 0x6e, 0x7e, 0xe4, 0x9a, 0xc3, 0x57, 0xc3, 0x5a, 0x9a, 0xe3, 0x52, 0xff, 0x49, 0x32, 0xd7, 0x5e, 0x6, 0x17, 0xb8, 0xb0, 0xc6, 0x1c, 0x80},
+               output512: []byte{0xb3, 0x85, 0x17, 0x90, 0xca, 0x47, 0x57, 0x5d, 0xbf, 0x98, 0x8f, 0x82, 0xc3, 0xb5, 0x1, 0xdc, 0x83, 0x90, 0xa8, 0xe8, 0x59, 0x86, 0x98, 0x16, 0x61, 0x67, 0x56, 0x7a, 0x3, 0x32, 0x91, 0x3c, 0xcc, 0x88, 0x68, 0x58, 0x4d, 0xb4, 0xac, 0xfb, 0x2c, 0x9d, 0xc0, 0xf0, 0xa6, 0x83, 0x32, 0x92, 0xf4, 0xdc, 0xed, 0xc4, 0x7c, 0xf0, 0x3, 0x21, 0x76, 0x89, 0xbc, 0x24, 0x22, 0xb5, 0x3b, 0x93}},
+       testcase{
+               msg:       []byte{0xea, 0xcd, 0x7, 0x97, 0x1c, 0xff, 0x9b, 0x99, 0x39, 0x90, 0x3f, 0x8c, 0x1d, 0x8c, 0xbb, 0x5d, 0x4d, 0xb1, 0xb5, 0x48, 0xa8, 0x5d, 0x4, 0xe0, 0x37, 0x51, 0x4a, 0x58, 0x36, 0x4, 0xe7, 0x87, 0xf3, 0x29, 0x92, 0xbf, 0x21, 0x11, 0xb9, 0x7a, 0xc5, 0xe8, 0xa9, 0x38, 0x23, 0x35, 0x52, 0x73, 0x13, 0x21, 0x52, 0x2a, 0xb5, 0xe8, 0x58, 0x35, 0x61, 0x26, 0xb, 0x7d, 0x13, 0xeb, 0xee, 0xf7, 0x85, 0xb2, 0x3a, 0x41, 0xfd, 0x85, 0x76, 0xa6, 0xda, 0x76, 0x4a, 0x8e, 0xd6, 0xd8, 0x22, 0xd4, 0x95, 0x7a, 0x54, 0x5d, 0x52, 0x44, 0x75, 0x6c, 0x18, 0xaa, 0x80, 0xe1, 0xaa, 0xd4, 0xd1, 0xf9, 0xc2, 0xd, 0x25, 0x9d, 0xee, 0x17, 0x11, 0xe2, 0xcc, 0x8f, 0xd0, 0x13, 0x16, 0x9f, 0xb7, 0xcc, 0x4c, 0xe3, 0x8b, 0x36, 0x2f, 0x8e, 0x9, 0x36, 0xae, 0x91, 0x98, 0xb7, 0xe8, 0x38, 0xdc, 0xea, 0x4f, 0x7a, 0x5b, 0x94, 0x29, 0xbb, 0x3f, 0x6b, 0xbc, 0xf2, 0xdc, 0x92, 0x56, 0x5e, 0x36, 0x76, 0xc1, 0xc5, 0xe6, 0xeb, 0x3d, 0xd2, 0xa0, 0xf8, 0x6a, 0xa2, 0x3e, 0xdd, 0x3d, 0x8, 0x91, 0xf1, 0x97, 0x44, 0x76, 0x92, 0x79, 0x4b, 0x3d, 0xfa, 0x26, 0x96, 0x11, 0xad, 0x97, 0xf7, 0x2b, 0x79, 0x56, 0x2, 0xb4, 0xfd, 0xb1, 0x98, 0xf3, 0xfd, 0x3e, 0xb4, 0x1b, 0x41, 0x50, 0x64, 0x25, 0x6e, 0x34, 0x5e, 0x8d, 0x8c, 0x51, 0xc5, 0x55, 0xdc, 0x8a, 0x21, 0x90, 0x4a, 0x9b, 0xf, 0x1a, 0xd0, 0xef, 0xfa, 0xb7, 0x78, 0x6a, 0xac, 0x2d, 0xa3, 0xb1, 0x96, 0x50, 0x7e, 0x9f, 0x33, 0xca, 0x35, 0x64, 0x27},
+               output224: []byte{0x37, 0xe3, 0x84, 0x40, 0x80, 0x98, 0x61, 0x79, 0xfd, 0xa9, 0x9e, 0x9b, 0x8c, 0x54, 0xe2, 0x94, 0x64, 0x30, 0x60, 0x79, 0x5b, 0x66, 0xe8, 0x10, 0xe3, 0xe2, 0x5d, 0x9e},
+               output256: []byte{0xc3, 0x39, 0x90, 0x4e, 0xc8, 0x65, 0xf2, 0x4f, 0xb3, 0xf8, 0x8f, 0x14, 0x2a, 0x87, 0x86, 0xd7, 0x70, 0x93, 0x4e, 0x0, 0x6e, 0xae, 0xdd, 0xbf, 0x45, 0xac, 0xbb, 0x6b, 0x38, 0x43, 0x10, 0x21},
+               output384: []byte{0x87, 0xf9, 0xec, 0xb9, 0x6, 0xc9, 0xd8, 0xaa, 0xfa, 0x8d, 0xc6, 0x2a, 0xf8, 0x58, 0xc9, 0x96, 0x9, 0xa8, 0xe9, 0x59, 0xb, 0xa5, 0xbc, 0x91, 0xa8, 0x92, 0x5, 0xde, 0x44, 0xf0, 0x6a, 0xe7, 0x97, 0x6a, 0x9b, 0xe9, 0x18, 0xaa, 0xfc, 0x91, 0x34, 0xde, 0x90, 0x29, 0x11, 0x71, 0x52, 0xa1},
+               output512: []byte{0xa7, 0x10, 0xcb, 0x26, 0xc6, 0x32, 0xf2, 0x89, 0x50, 0x4c, 0xd0, 0x3, 0x9b, 0xa6, 0xab, 0x9b, 0x4d, 0x35, 0x24, 0xc5, 0x2b, 0x28, 0x6d, 0x46, 0x6e, 0x2f, 0x89, 0x39, 0xf8, 0x68, 0x4e, 0x3f, 0x18, 0xdc, 0xa2, 0x98, 0xa2, 0xba, 0x67, 0xeb, 0x71, 0x9, 0x97, 0xb7, 0xbb, 0x10, 0xae, 0x27, 0x94, 0x38, 0xb9, 0xb4, 0x86, 0x8d, 0xa, 0xdb, 0x24, 0x8f, 0x28, 0x2b, 0xb4, 0x40, 0xa1, 0x30}},
+       testcase{
+               msg:       []byte{0x23, 0xac, 0x4e, 0x9a, 0x42, 0xc6, 0xef, 0x45, 0xc3, 0x33, 0x6c, 0xe6, 0xdf, 0xc2, 0xff, 0x7d, 0xe8, 0x88, 0x4c, 0xd2, 0x3d, 0xc9, 0x12, 0xfe, 0xf0, 0xf7, 0x75, 0x6c, 0x9, 0xd3, 0x35, 0xc1, 0x89, 0xf3, 0xad, 0x3a, 0x23, 0x69, 0x7a, 0xbd, 0xa8, 0x51, 0xa8, 0x18, 0x81, 0xa0, 0xc8, 0xcc, 0xaf, 0xc9, 0x80, 0xab, 0x2c, 0x70, 0x25, 0x64, 0xc2, 0xbe, 0x15, 0xfe, 0x4c, 0x4b, 0x9f, 0x10, 0xdf, 0xb2, 0x24, 0x8d, 0xd, 0xc, 0xb2, 0xe2, 0x88, 0x7f, 0xd4, 0x59, 0x8a, 0x1d, 0x4a, 0xcd, 0xa8, 0x97, 0x94, 0x4a, 0x2f, 0xfc, 0x58, 0xf, 0xf9, 0x27, 0x19, 0xc9, 0x5c, 0xf2, 0xaa, 0x42, 0xdc, 0x58, 0x46, 0x74, 0xcb, 0x5a, 0x9b, 0xc5, 0x76, 0x5b, 0x9d, 0x6d, 0xdf, 0x57, 0x89, 0x79, 0x1d, 0x15, 0xf8, 0xdd, 0x92, 0x5a, 0xa1, 0x2b, 0xff, 0xaf, 0xbc, 0xe6, 0x8, 0x27, 0xb4, 0x90, 0xbb, 0x7d, 0xf3, 0xdd, 0xa6, 0xf2, 0xa1, 0x43, 0xc8, 0xbf, 0x96, 0xab, 0xc9, 0x3, 0xd8, 0x3d, 0x59, 0xa7, 0x91, 0xe2, 0xd6, 0x28, 0x14, 0xa8, 0x9b, 0x80, 0x80, 0xa2, 0x80, 0x60, 0x56, 0x8c, 0xf2, 0x4a, 0x80, 0xae, 0x61, 0x17, 0x9f, 0xe8, 0x4e, 0xf, 0xfa, 0xd0, 0x3, 0x88, 0x17, 0x8c, 0xb6, 0xa6, 0x17, 0xd3, 0x7e, 0xfd, 0x54, 0xcc, 0x1, 0x97, 0xa, 0x4a, 0x41, 0xd1, 0xa8, 0xd3, 0xdd, 0xce, 0x46, 0xed, 0xbb, 0xa4, 0xab, 0x7c, 0x90, 0xad, 0x56, 0x53, 0x98, 0xd3, 0x76, 0xf4, 0x31, 0x18, 0x9c, 0xe8, 0xc1, 0xc3, 0x3e, 0x13, 0x2f, 0xea, 0xe6, 0xa8, 0xcd, 0x17, 0xa6, 0x1c, 0x63, 0x0, 0x12},
+               output224: []byte{0x3b, 0x50, 0x3d, 0x61, 0x5e, 0x54, 0x13, 0x2b, 0x42, 0xca, 0xc1, 0xa0, 0x45, 0xa, 0xd, 0x7e, 0x2e, 0xdc, 0x63, 0xed, 0x87, 0xbf, 0x10, 0x9c, 0x50, 0x9c, 0x79, 0x87},
+               output256: []byte{0x4c, 0xa8, 0xb7, 0xfe, 0xbd, 0xf0, 0xa8, 0x6, 0x2e, 0x9b, 0x76, 0x18, 0x5c, 0xf4, 0x16, 0x50, 0x71, 0xbb, 0x30, 0x92, 0x8c, 0x18, 0xf1, 0x43, 0x38, 0xc3, 0x5, 0x62, 0x67, 0x89, 0xc6, 0xd3},
+               output384: []byte{0x51, 0xc, 0xb4, 0x84, 0xb6, 0xd4, 0xb4, 0x7a, 0x59, 0xf, 0x62, 0x11, 0xc7, 0xf3, 0x35, 0x92, 0x24, 0x6a, 0x2e, 0x5, 0xa1, 0xc6, 0x92, 0x58, 0xb6, 0xcf, 0x9a, 0x24, 0xc1, 0xa3, 0xaf, 0xc2, 0x52, 0x78, 0x41, 0xae, 0x3f, 0xcd, 0x55, 0x2e, 0x51, 0x3, 0xdd, 0x24, 0x74, 0x3a, 0xc6, 0xb3},
+               output512: []byte{0x8f, 0x67, 0x7a, 0x80, 0x89, 0x5, 0x2b, 0x47, 0xbe, 0x60, 0xc0, 0xbb, 0x76, 0x66, 0xe4, 0x3, 0xa5, 0xda, 0xa5, 0xe2, 0x8a, 0x2b, 0x63, 0x2f, 0x2e, 0x49, 0x6c, 0x58, 0x7f, 0x1f, 0xdc, 0xa0, 0xee, 0x33, 0xd9, 0xe7, 0x8d, 0xaa, 0x4e, 0xf5, 0x75, 0xb1, 0x33, 0x89, 0x74, 0x8b, 0x8c, 0x24, 0x11, 0x0, 0x53, 0xb0, 0xb9, 0x6a, 0x8, 0x2c, 0x6, 0xc3, 0xf8, 0xe, 0xbe, 0x8d, 0xe9, 0x76}},
+       testcase{
+               msg:       []byte{0x1, 0x72, 0xdf, 0x73, 0x22, 0x82, 0xc9, 0xd4, 0x88, 0x66, 0x9c, 0x35, 0x8e, 0x34, 0x92, 0x26, 0xc, 0xbe, 0x91, 0xc9, 0x5c, 0xfb, 0xc1, 0xe3, 0xfe, 0xa6, 0xc4, 0xb0, 0xec, 0x12, 0x9b, 0x45, 0xf2, 0x42, 0xac, 0xe0, 0x9f, 0x15, 0x2f, 0xc6, 0x23, 0x4e, 0x1b, 0xee, 0x8a, 0xab, 0x8c, 0xd5, 0x6e, 0x8b, 0x48, 0x6e, 0x1d, 0xcb, 0xa9, 0xc0, 0x54, 0x7, 0xc2, 0xf9, 0x5d, 0xa8, 0xd8, 0xf1, 0xc0, 0xaf, 0x78, 0xee, 0x2e, 0xd8, 0x2a, 0x3a, 0x79, 0xec, 0xc, 0xb0, 0x70, 0x93, 0x96, 0xee, 0x62, 0xaa, 0xdb, 0x84, 0xf8, 0xa4, 0xee, 0x8a, 0x7c, 0xcc, 0xa3, 0xc1, 0xee, 0x84, 0xe3, 0x2, 0xa0, 0x9e, 0xa8, 0x2, 0x20, 0x4a, 0xfe, 0xcf, 0x4, 0x9, 0x7e, 0x67, 0xd0, 0xf8, 0xe8, 0xa9, 0xd2, 0x65, 0x11, 0x26, 0xc0, 0xa5, 0x98, 0xa3, 0x70, 0x81, 0xe4, 0x2d, 0x16, 0x8b, 0xa, 0xe8, 0xa7, 0x19, 0x51, 0xc5, 0x24, 0x25, 0x9e, 0x4e, 0x20, 0x54, 0xe5, 0x35, 0xb7, 0x79, 0x67, 0x9b, 0xda, 0xde, 0x56, 0x6f, 0xe5, 0x57, 0x0, 0x85, 0x86, 0x18, 0xe6, 0x26, 0xb4, 0xa0, 0xfa, 0xf8, 0x95, 0xbc, 0xce, 0x90, 0x11, 0x50, 0x4a, 0x49, 0xe0, 0x5f, 0xd5, 0x61, 0x27, 0xea, 0xe3, 0xd1, 0xf8, 0x91, 0x7a, 0xfb, 0x54, 0x8e, 0xca, 0xda, 0xbd, 0xa1, 0x2, 0x1, 0x11, 0xfe, 0xc9, 0x31, 0x4c, 0x41, 0x34, 0x98, 0xa3, 0x60, 0xb0, 0x86, 0x40, 0x54, 0x9a, 0x22, 0xcb, 0x23, 0xc7, 0x31, 0xac, 0xe7, 0x43, 0x25, 0x2a, 0x82, 0x27, 0xa0, 0xd2, 0x68, 0x9d, 0x4c, 0x60, 0x1, 0x60, 0x66, 0x78, 0xdf, 0xb9, 0x21},
+               output224: []byte{0xcb, 0x40, 0x83, 0x7d, 0xaf, 0x4a, 0x88, 0x25, 0x38, 0x46, 0x4d, 0xec, 0xa, 0x99, 0x9d, 0xa4, 0x82, 0xb4, 0xaa, 0xe0, 0x87, 0x8, 0xea, 0x6d, 0x5d, 0x7f, 0xf4, 0x61},
+               output256: []byte{0x23, 0xd2, 0x61, 0x44, 0x20, 0x85, 0x9b, 0x2f, 0x13, 0xac, 0x8, 0x44, 0x53, 0xdd, 0x35, 0xc3, 0x3f, 0xe4, 0x7c, 0x89, 0x4d, 0xd5, 0xc, 0x8, 0x7f, 0xd1, 0x65, 0x3f, 0xca, 0xee, 0xa0, 0xb},
+               output384: []byte{0x3, 0xf3, 0xbb, 0x45, 0xfd, 0x70, 0x96, 0x6a, 0xc5, 0xef, 0xd9, 0x59, 0x8c, 0x48, 0xe, 0xd6, 0x77, 0xc8, 0x6c, 0x7c, 0xf0, 0xb, 0x10, 0x26, 0x1a, 0xe6, 0x79, 0xc, 0x52, 0x79, 0xa5, 0xe4, 0x73, 0x86, 0xf3, 0xd3, 0x17, 0x26, 0xd9, 0xcb, 0x61, 0x9b, 0x92, 0xa7, 0x9c, 0xca, 0xe2, 0x5c},
+               output512: []byte{0xce, 0x63, 0x1e, 0x6f, 0x2c, 0x2d, 0xc5, 0x73, 0x8c, 0xf, 0xa9, 0x58, 0x57, 0x17, 0x73, 0xb5, 0x8a, 0xf1, 0x30, 0xb9, 0x48, 0x24, 0x33, 0x14, 0x19, 0xee, 0x57, 0xe2, 0x69, 0x1c, 0xe5, 0xf2, 0x9d, 0xb3, 0xd8, 0xfe, 0x45, 0x6c, 0xd1, 0xe7, 0xcd, 0xc0, 0x7f, 0x61, 0x5, 0xfa, 0x1b, 0x6f, 0xd7, 0x29, 0xc2, 0xb4, 0x19, 0x0, 0x8c, 0xcd, 0x88, 0x91, 0x69, 0xc3, 0x38, 0x5d, 0xb1, 0xb9}},
+       testcase{
+               msg:       []byte{0x38, 0x75, 0xb9, 0x24, 0xc, 0xf3, 0xe0, 0xa8, 0xb5, 0x9c, 0x65, 0x85, 0x40, 0xf2, 0x6a, 0x70, 0x1c, 0xf1, 0x88, 0x49, 0x6e, 0x2c, 0x21, 0x74, 0x78, 0x8b, 0x12, 0x6f, 0xd2, 0x94, 0x2, 0xd6, 0xa7, 0x54, 0x53, 0xba, 0x6, 0x35, 0x28, 0x4d, 0x8, 0x83, 0x5f, 0x40, 0x5, 0x1a, 0x2a, 0x96, 0x83, 0xdc, 0x92, 0xaf, 0xb9, 0x38, 0x37, 0x19, 0x19, 0x12, 0x31, 0x17, 0x3, 0x79, 0xba, 0x6f, 0x4a, 0xdc, 0x81, 0x6f, 0xec, 0xbb, 0xf, 0x9c, 0x44, 0x6b, 0x78, 0x5b, 0xf5, 0x20, 0x79, 0x68, 0x41, 0xe5, 0x88, 0x78, 0xb7, 0x3c, 0x58, 0xd3, 0xeb, 0xb0, 0x97, 0xce, 0x47, 0x61, 0xfd, 0xea, 0xbe, 0x15, 0xde, 0x2f, 0x31, 0x9d, 0xfb, 0xaf, 0x17, 0x42, 0xcd, 0xeb, 0x38, 0x95, 0x59, 0xc7, 0x88, 0x13, 0x1a, 0x67, 0x93, 0xe1, 0x93, 0x85, 0x66, 0x61, 0x37, 0x6c, 0x81, 0xce, 0x95, 0x68, 0xda, 0x19, 0xaa, 0x69, 0x25, 0xb4, 0x7f, 0xfd, 0x77, 0xa4, 0x3c, 0x7a, 0xe, 0x75, 0x8c, 0x37, 0xd6, 0x92, 0x54, 0x90, 0x9f, 0xf0, 0xfb, 0xd4, 0x15, 0xef, 0x8e, 0xb9, 0x37, 0xbc, 0xd4, 0x9f, 0x91, 0x46, 0x8b, 0x49, 0x97, 0x4c, 0x7, 0xdc, 0x81, 0x9a, 0xbd, 0x67, 0x39, 0x5d, 0xb0, 0xe0, 0x58, 0x74, 0xff, 0x83, 0xdd, 0xda, 0xb8, 0x95, 0x34, 0x4a, 0xbd, 0xe, 0x71, 0x11, 0xb2, 0xdf, 0x9e, 0x58, 0xd7, 0x6d, 0x85, 0xad, 0x98, 0x10, 0x6b, 0x36, 0x29, 0x58, 0x26, 0xbe, 0x4, 0xd4, 0x35, 0x61, 0x55, 0x95, 0x60, 0x5e, 0x4b, 0x4b, 0xb8, 0x24, 0xb3, 0x3c, 0x4a, 0xfe, 0xb5, 0xe7, 0xbb, 0xd, 0x19, 0xf9, 0x9},
+               output224: []byte{0xea, 0xe9, 0x11, 0xe6, 0x66, 0x61, 0xdc, 0xd3, 0x47, 0x2b, 0x45, 0x8a, 0x48, 0xb7, 0x47, 0x30, 0x46, 0x89, 0x23, 0xc7, 0xab, 0xca, 0xc7, 0xf3, 0x11, 0xf0, 0x24, 0x63},
+               output256: []byte{0x55, 0x90, 0xbb, 0x75, 0x24, 0x7d, 0x7c, 0xd0, 0xb3, 0x56, 0x20, 0xf0, 0x6, 0x2b, 0x90, 0xff, 0xb2, 0xa2, 0x4d, 0xe4, 0x12, 0x20, 0xed, 0x62, 0x9d, 0x9e, 0x9a, 0x7a, 0xbc, 0xad, 0xfb, 0x51},
+               output384: []byte{0x68, 0xa4, 0x7c, 0x7d, 0x12, 0x4e, 0x8a, 0xea, 0x5c, 0xfe, 0xef, 0x7a, 0x9d, 0x8c, 0xa7, 0xaa, 0x8d, 0xf6, 0xee, 0xe6, 0x65, 0x2d, 0xe3, 0xa3, 0x85, 0x23, 0x1f, 0x29, 0xbc, 0x4b, 0x98, 0x3a, 0xec, 0x8a, 0xf2, 0xa6, 0x13, 0x29, 0xb6, 0x4b, 0xb5, 0x9a, 0x45, 0xb7, 0x7a, 0x38, 0xe4, 0xdf},
+               output512: []byte{0xff, 0xf6, 0x77, 0xbb, 0x58, 0x90, 0x9c, 0x15, 0x8e, 0xa6, 0x77, 0xbe, 0x70, 0x42, 0x53, 0x50, 0x5b, 0x10, 0x6a, 0xf9, 0x34, 0xf6, 0x39, 0xab, 0xfe, 0xc6, 0x3b, 0xd0, 0xc6, 0x30, 0x97, 0xaa, 0x4b, 0xf0, 0x32, 0xfe, 0x92, 0x41, 0x49, 0xdd, 0x99, 0x1d, 0x33, 0x5e, 0x1c, 0x44, 0xc0, 0x22, 0xe, 0x4d, 0x13, 0xcb, 0xc4, 0x1b, 0x6a, 0x98, 0xfb, 0x5a, 0x5, 0xfa, 0xa3, 0xfe, 0x15, 0xb3}},
+       testcase{
+               msg:       []byte{0x74, 0x7c, 0xc1, 0xa5, 0x9f, 0xef, 0xba, 0x94, 0xa9, 0xc7, 0x5b, 0xa8, 0x66, 0xc3, 0xd, 0xc5, 0xc1, 0xcb, 0xc, 0xf, 0x8e, 0x93, 0x61, 0xd9, 0x84, 0x84, 0x95, 0x6d, 0xd5, 0xd1, 0xa4, 0xf, 0x61, 0x84, 0xaf, 0xbe, 0x3d, 0xac, 0x9f, 0x76, 0x2, 0x8d, 0x1c, 0xae, 0xcc, 0xfb, 0xf6, 0x91, 0x99, 0xc6, 0xce, 0x2b, 0x4c, 0x9, 0x2a, 0x3f, 0x4d, 0x2a, 0x56, 0xfe, 0x5a, 0x33, 0xa0, 0x7, 0x57, 0xf4, 0xd7, 0xde, 0xe5, 0xdf, 0xb0, 0x52, 0x43, 0x11, 0xa9, 0x7a, 0xe0, 0x66, 0x8a, 0x47, 0x97, 0x1b, 0x95, 0x76, 0x6e, 0x2f, 0x6d, 0xd4, 0x8c, 0x3f, 0x57, 0x84, 0x1f, 0x91, 0xf0, 0x4a, 0x0, 0xad, 0x5e, 0xa7, 0xf, 0x2d, 0x47, 0x9a, 0x26, 0x20, 0xdc, 0x5c, 0xd7, 0x8e, 0xaa, 0xb3, 0xa3, 0xb0, 0x11, 0x71, 0x9b, 0x7e, 0x78, 0xd1, 0x9d, 0xdf, 0x70, 0xd9, 0x42, 0x37, 0x98, 0xaf, 0x77, 0x51, 0x7e, 0xbc, 0x55, 0x39, 0x2f, 0xcd, 0x1, 0xfc, 0x60, 0xd, 0x8d, 0x46, 0x6b, 0x9e, 0x7a, 0x7a, 0x85, 0xbf, 0x33, 0xf9, 0xcc, 0x54, 0x19, 0xe9, 0xbd, 0x87, 0x4d, 0xdf, 0xd6, 0x9, 0x81, 0x15, 0xd, 0xda, 0xf8, 0xd7, 0xfe, 0xba, 0xa4, 0x37, 0x4f, 0x8, 0x72, 0xa5, 0x62, 0x8d, 0x31, 0x80, 0x0, 0x31, 0x1e, 0x2f, 0x56, 0x55, 0x36, 0x5a, 0xd4, 0xd4, 0x7, 0xc2, 0xe, 0x5c, 0x4, 0xdf, 0x17, 0xa2, 0x22, 0xe7, 0xde, 0xec, 0x79, 0xc5, 0xab, 0x11, 0x16, 0xd8, 0x57, 0x2f, 0x91, 0xcd, 0x6, 0xe1, 0xcc, 0xc7, 0xce, 0xd5, 0x37, 0x36, 0xfc, 0x86, 0x7f, 0xd4, 0x9e, 0xce, 0xbe, 0x6b, 0xf8, 0x8, 0x2e, 0x8a},
+               output224: []byte{0x30, 0x7d, 0x5a, 0x8b, 0xa5, 0x86, 0x5a, 0x4d, 0x28, 0x1a, 0xcb, 0x2f, 0x3c, 0x5e, 0xf1, 0x6e, 0x3b, 0x11, 0xbc, 0xd8, 0xc0, 0xf8, 0x2d, 0x22, 0xd4, 0x7c, 0x2c, 0xc8},
+               output256: []byte{0xe5, 0x93, 0x24, 0x41, 0xb0, 0x12, 0xe5, 0x3, 0xb0, 0xb0, 0xc6, 0x10, 0x47, 0x3, 0xba, 0x2, 0x61, 0x3e, 0x47, 0x2a, 0xd6, 0x56, 0x55, 0xc0, 0x85, 0xb0, 0xad, 0xb0, 0x76, 0x56, 0xb2, 0x8f},
+               output384: []byte{0xdd, 0x3b, 0xba, 0x1b, 0x4f, 0x84, 0x93, 0xe0, 0x63, 0x91, 0x51, 0xd9, 0x30, 0x38, 0x35, 0xf4, 0x92, 0x60, 0x6e, 0x2d, 0xb3, 0xaf, 0x34, 0xfe, 0x65, 0x15, 0x6a, 0x64, 0x27, 0x94, 0x19, 0x6d, 0x0, 0xa6, 0xc3, 0x4a, 0x3a, 0x5f, 0xea, 0x66, 0x20, 0x2c, 0x3b, 0x5a, 0x79, 0x98, 0xa, 0x8a},
+               output512: []byte{0x45, 0x1e, 0xe5, 0x87, 0x22, 0x6c, 0x99, 0x98, 0x9f, 0x5e, 0xc1, 0x0, 0x50, 0x98, 0x3b, 0x1f, 0xd6, 0x61, 0x22, 0x8a, 0x4a, 0xb4, 0x86, 0x18, 0xf1, 0xd1, 0x17, 0x3c, 0x94, 0xfa, 0xc3, 0x9e, 0xcf, 0xd3, 0xc2, 0x6c, 0x16, 0x65, 0x36, 0x33, 0xb2, 0x60, 0x97, 0xe3, 0x1a, 0xf, 0x22, 0x13, 0xb4, 0xf1, 0x15, 0x3a, 0x57, 0xcb, 0x48, 0xa7, 0xd, 0x2a, 0xf1, 0xad, 0xeb, 0x1b, 0xbc, 0x6}},
+       testcase{
+               msg:       []byte{0x57, 0xaf, 0x97, 0x1f, 0xcc, 0xae, 0xc9, 0x74, 0x35, 0xdc, 0x2e, 0xc9, 0xef, 0x4, 0x29, 0xbc, 0xed, 0xc6, 0xb6, 0x47, 0x72, 0x9e, 0xa1, 0x68, 0x85, 0x8a, 0x6e, 0x49, 0xac, 0x10, 0x71, 0xe7, 0x6, 0xf4, 0xa5, 0xa6, 0x45, 0xca, 0x14, 0xe8, 0xc7, 0x74, 0x6d, 0x65, 0x51, 0x16, 0x20, 0x68, 0x2c, 0x90, 0x6c, 0x8b, 0x86, 0xec, 0x90, 0x1f, 0x3d, 0xde, 0xd4, 0x16, 0x7b, 0x3f, 0x0, 0xb0, 0x6c, 0xbf, 0xac, 0x6a, 0xee, 0x37, 0x28, 0x5, 0x1b, 0x3e, 0x5f, 0xf1, 0xb, 0x4f, 0x9e, 0xd8, 0xbd, 0xb, 0x8d, 0xa9, 0x43, 0x3, 0xc8, 0x33, 0x75, 0x5b, 0x3c, 0xa3, 0xae, 0xdd, 0xf0, 0xb5, 0x4b, 0xc8, 0xd6, 0x63, 0x21, 0x38, 0xb5, 0xd2, 0x5b, 0xab, 0x3, 0xd1, 0x7b, 0x34, 0x58, 0xa9, 0xd7, 0x82, 0x10, 0x80, 0x6, 0xf5, 0xbb, 0x7d, 0xe7, 0x5b, 0x5c, 0xb, 0xa8, 0x54, 0xb4, 0x23, 0xd8, 0xbb, 0x80, 0x1e, 0x70, 0x1e, 0x99, 0xdc, 0x4f, 0xea, 0xad, 0x59, 0xbc, 0x1c, 0x71, 0x12, 0x45, 0x3b, 0x4, 0xd3, 0x3e, 0xa3, 0x63, 0x56, 0x39, 0xfb, 0x80, 0x2c, 0x73, 0xc2, 0xb7, 0x1d, 0x58, 0xa5, 0x6b, 0xbd, 0x67, 0x1b, 0x18, 0xfe, 0x34, 0xed, 0x2e, 0x3d, 0xca, 0x38, 0x82, 0x7d, 0x63, 0xfd, 0xb1, 0xd4, 0xfb, 0x32, 0x85, 0x40, 0x50, 0x4, 0xb2, 0xb3, 0xe2, 0x60, 0x81, 0xa8, 0xff, 0x8, 0xcd, 0x6d, 0x2b, 0x8, 0xf8, 0xe7, 0xb7, 0xe9, 0xa, 0x2a, 0xb1, 0xed, 0x7a, 0x41, 0xb1, 0xd0, 0x12, 0x85, 0x22, 0xc2, 0xf8, 0xbf, 0xf5, 0x6a, 0x7f, 0xe6, 0x79, 0x69, 0x42, 0x2c, 0xe8, 0x39, 0xa9, 0xd4, 0x60, 0x8f, 0x3},
+               output224: []byte{0x58, 0x66, 0x6b, 0x32, 0x5d, 0x81, 0xcb, 0xe6, 0xa4, 0xbb, 0xad, 0x91, 0x72, 0xe, 0x2b, 0xa9, 0x3c, 0x70, 0xea, 0x11, 0x4e, 0x7f, 0x77, 0x32, 0x3c, 0x5b, 0xe4, 0x86},
+               output256: []byte{0x21, 0xc0, 0xd8, 0x4e, 0xb7, 0xb6, 0x17, 0x74, 0xf9, 0x7d, 0xb5, 0xd9, 0xac, 0xf1, 0xdf, 0xfa, 0xfb, 0x66, 0x2c, 0x1, 0xed, 0x29, 0x1a, 0x44, 0x2b, 0xec, 0x6f, 0x14, 0xd1, 0x33, 0x46, 0x99},
+               output384: []byte{0x50, 0xd3, 0xb0, 0x2a, 0xc7, 0xb9, 0x7, 0xb3, 0x10, 0xc1, 0xc0, 0x10, 0x5e, 0xb4, 0x7f, 0x6d, 0xcf, 0x3a, 0xf0, 0xe4, 0x73, 0x78, 0x5d, 0xaa, 0x54, 0xd8, 0x3, 0x7a, 0x9a, 0x3e, 0x74, 0xa5, 0xd1, 0xa4, 0x1d, 0x81, 0x12, 0x2, 0xf1, 0xe3, 0xc8, 0xa1, 0x40, 0x17, 0x3d, 0x92, 0xf6, 0xf},
+               output512: []byte{0xf9, 0xd6, 0xad, 0x86, 0x86, 0x12, 0x5e, 0x71, 0xfe, 0x8, 0x56, 0xe8, 0x6, 0xd6, 0x8b, 0xa9, 0x7e, 0xf1, 0x23, 0x44, 0x39, 0x38, 0xd2, 0x82, 0x83, 0x38, 0x7f, 0x33, 0xe3, 0xac, 0x6e, 0x2a, 0x7d, 0xe0, 0x42, 0xa3, 0xee, 0x5f, 0x79, 0x94, 0xc1, 0xee, 0xcc, 0x5b, 0x6f, 0x22, 0xcb, 0xae, 0x13, 0x49, 0xca, 0xb2, 0xfb, 0x7a, 0xa, 0x1, 0x25, 0xec, 0x23, 0x20, 0x32, 0x8, 0x58, 0xd4}},
+       testcase{
+               msg:       []byte{0x4, 0xe1, 0x6d, 0xed, 0xc1, 0x22, 0x79, 0x2, 0xba, 0xaf, 0x33, 0x2d, 0x3d, 0x8, 0x92, 0x36, 0x1, 0xbd, 0xd6, 0x4f, 0x57, 0x3f, 0xaa, 0x1b, 0xb7, 0x20, 0x19, 0x18, 0xcf, 0xe1, 0x6b, 0x1e, 0x10, 0x15, 0x1d, 0xae, 0x87, 0x5d, 0xa0, 0xc0, 0xd6, 0x3c, 0x59, 0xc3, 0xdd, 0x5, 0xc, 0x4c, 0x6a, 0x87, 0x40, 0x11, 0xb0, 0x18, 0x42, 0x1a, 0xfc, 0x46, 0x23, 0xab, 0x3, 0x81, 0x83, 0x1b, 0x2d, 0xa2, 0xa8, 0xba, 0x42, 0xc9, 0x6e, 0x4f, 0x70, 0x86, 0x4a, 0xc4, 0x4e, 0x10, 0x6f, 0x94, 0x31, 0x10, 0x51, 0xe7, 0x4c, 0x77, 0xc1, 0x29, 0x1b, 0xf5, 0xdb, 0x95, 0x39, 0xe6, 0x95, 0x67, 0xbf, 0x6a, 0x11, 0xcf, 0x69, 0x32, 0xbb, 0xba, 0xd3, 0x3f, 0x89, 0x46, 0xbf, 0x58, 0x14, 0xc0, 0x66, 0xd8, 0x51, 0x63, 0x3d, 0x1a, 0x51, 0x35, 0x10, 0x3, 0x9b, 0x34, 0x99, 0x39, 0xbf, 0xd4, 0x2b, 0x85, 0x8c, 0x21, 0x82, 0x7c, 0x8f, 0xf0, 0x5f, 0x1d, 0x9, 0xb1, 0xb0, 0x76, 0x5d, 0xc7, 0x8a, 0x13, 0x5b, 0x5c, 0xa4, 0xdf, 0xba, 0x8, 0x1, 0xbc, 0xad, 0xdf, 0xa1, 0x75, 0x62, 0x3c, 0x8b, 0x64, 0x7e, 0xac, 0xfb, 0x44, 0x44, 0xb8, 0x5a, 0x44, 0xf7, 0x38, 0x90, 0x60, 0x7d, 0x6, 0xd5, 0x7, 0xa4, 0xf8, 0x39, 0x36, 0x58, 0x78, 0x86, 0x69, 0xf6, 0xef, 0x4d, 0xeb, 0x58, 0xd0, 0x8c, 0x50, 0xca, 0x7, 0x56, 0xd5, 0xe2, 0xf4, 0x9d, 0x1a, 0x7a, 0xd7, 0x3e, 0xf, 0xb, 0x3d, 0x3b, 0x5f, 0x9, 0xa, 0xcf, 0x62, 0x2b, 0x18, 0x78, 0xc5, 0x91, 0x33, 0xe4, 0xa8, 0x48, 0xe0, 0x51, 0x53, 0x59, 0x2e, 0xa8, 0x1c, 0x6f, 0xbf},
+               output224: []byte{0xbc, 0x29, 0x6f, 0xfd, 0x39, 0x38, 0x1c, 0xf1, 0xc9, 0x62, 0x28, 0xa9, 0xf3, 0x80, 0xf4, 0x1c, 0x87, 0x1b, 0x87, 0x88, 0xc6, 0x54, 0xed, 0x9b, 0x38, 0x4c, 0x17, 0xfe},
+               output256: []byte{0xd, 0x1e, 0x6b, 0xb8, 0x81, 0x88, 0xb4, 0x9a, 0xf0, 0xa9, 0xa0, 0x5e, 0xb1, 0xaf, 0x94, 0x25, 0x5e, 0x67, 0x99, 0x51, 0x5a, 0x2f, 0x8e, 0xb4, 0x6a, 0xa6, 0xaf, 0x9a, 0x9d, 0xd5, 0xb9, 0xe0},
+               output384: []byte{0xa6, 0xbb, 0xae, 0x1f, 0xf8, 0xe0, 0xd, 0xce, 0x34, 0xf6, 0x40, 0xce, 0xe2, 0xcd, 0xb5, 0xbc, 0xfe, 0x43, 0x82, 0x76, 0x1b, 0xe3, 0x6a, 0x94, 0xe, 0x50, 0xee, 0xc1, 0x2b, 0x5c, 0x2a, 0x2, 0xb2, 0xb6, 0xbe, 0x18, 0xa7, 0xc8, 0x7a, 0x36, 0xfd, 0x21, 0x94, 0xc4, 0xd2, 0x43, 0xec, 0x38},
+               output512: []byte{0xf2, 0x6f, 0x32, 0x68, 0xfd, 0x62, 0xf, 0xc4, 0x76, 0xa4, 0x9a, 0xac, 0x3e, 0xd1, 0x58, 0x8, 0x64, 0x93, 0x4a, 0x2f, 0x6b, 0xa8, 0x81, 0xed, 0x8c, 0x8f, 0xb7, 0x57, 0xaa, 0xaa, 0x64, 0xbc, 0xdf, 0x50, 0x1e, 0x19, 0x13, 0xde, 0x60, 0xb, 0xbe, 0xf6, 0xf1, 0x2c, 0x94, 0x9f, 0xea, 0x8f, 0xd6, 0x8c, 0x64, 0x50, 0x86, 0xd5, 0xe3, 0xc, 0x92, 0x53, 0x58, 0x8f, 0xfb, 0xd1, 0x9b, 0xe5}},
+       testcase{
+               msg:       []byte{0x7c, 0x81, 0x5c, 0x38, 0x4e, 0xee, 0xf, 0x28, 0x8e, 0xce, 0x27, 0xcc, 0xed, 0x52, 0xa0, 0x16, 0x3, 0x12, 0x7b, 0x7, 0x9c, 0x0, 0x73, 0x78, 0xbc, 0x5d, 0x1e, 0x6c, 0x5e, 0x9e, 0x6d, 0x1c, 0x73, 0x57, 0x23, 0xac, 0xbb, 0xd5, 0x80, 0x1a, 0xc4, 0x98, 0x54, 0xb2, 0xb5, 0x69, 0xd4, 0x47, 0x2d, 0x33, 0xf4, 0xb, 0xbb, 0x88, 0x82, 0x95, 0x62, 0x45, 0xc3, 0x66, 0xdc, 0x35, 0x82, 0xd7, 0x16, 0x96, 0xa9, 0x7a, 0x4e, 0x19, 0x55, 0x7e, 0x41, 0xe5, 0x4d, 0xee, 0x48, 0x2a, 0x14, 0x22, 0x90, 0x5, 0xf9, 0x3a, 0xfd, 0x2c, 0x4a, 0x7d, 0x86, 0x14, 0xd1, 0xa, 0x97, 0xa9, 0xdf, 0xa0, 0x7f, 0x7c, 0xd9, 0x46, 0xfa, 0x45, 0x26, 0x30, 0x63, 0xdd, 0xd2, 0x9d, 0xb8, 0xf9, 0xe3, 0x4d, 0xb6, 0xd, 0xaa, 0x32, 0x68, 0x4f, 0x0, 0x72, 0xea, 0x2a, 0x94, 0x26, 0xec, 0xeb, 0xfa, 0x52, 0x39, 0xfb, 0x67, 0xf2, 0x9c, 0x18, 0xcb, 0xaa, 0x2a, 0xf6, 0xed, 0x4b, 0xf4, 0x28, 0x39, 0x36, 0x82, 0x3a, 0xc1, 0x79, 0x1, 0x64, 0xfe, 0xc5, 0x45, 0x7a, 0x9c, 0xba, 0x7c, 0x76, 0x7c, 0xa5, 0x93, 0x92, 0xd9, 0x4c, 0xab, 0x74, 0x48, 0xf5, 0xe, 0xb3, 0x4e, 0x9a, 0x93, 0xa8, 0x0, 0x27, 0x47, 0x1c, 0xe5, 0x97, 0x36, 0xf0, 0x99, 0xc8, 0x86, 0xde, 0xa1, 0xab, 0x4c, 0xba, 0x4d, 0x89, 0xf5, 0xfc, 0x7a, 0xe2, 0xf2, 0x1c, 0xcd, 0x27, 0xf6, 0x11, 0xec, 0xa4, 0x62, 0x6b, 0x2d, 0x8, 0xdc, 0x22, 0x38, 0x2e, 0x92, 0xc1, 0xef, 0xb2, 0xf6, 0xaf, 0xdc, 0x8f, 0xdc, 0x3d, 0x21, 0x72, 0x60, 0x4f, 0x50, 0x35, 0xc4, 0x6b, 0x81, 0x97, 0xd3},
+               output224: []byte{0xc, 0xce, 0xae, 0x71, 0x3e, 0x5e, 0x39, 0xbc, 0xef, 0xe7, 0xa2, 0x27, 0x30, 0x4, 0x81, 0x6f, 0xe0, 0x5, 0xd5, 0xed, 0xfb, 0x2a, 0x96, 0x5c, 0xc9, 0xac, 0x99, 0x48},
+               output256: []byte{0x93, 0x5d, 0xed, 0x24, 0xf5, 0xce, 0xcc, 0x69, 0xe1, 0xf0, 0x12, 0xb6, 0xb, 0x78, 0x31, 0xab, 0xce, 0x7e, 0xf5, 0xe, 0xeb, 0xb, 0xea, 0x7f, 0x81, 0x6c, 0x3d, 0xbf, 0x2b, 0x4a, 0xbd, 0xc1},
+               output384: []byte{0x7e, 0xd8, 0x3e, 0xb6, 0x59, 0x53, 0x6b, 0x36, 0x6, 0x17, 0x73, 0x7, 0x3b, 0x14, 0x8e, 0xd2, 0x11, 0x75, 0x12, 0x37, 0x2e, 0x49, 0xe0, 0xa3, 0xae, 0xe4, 0x8b, 0x96, 0x35, 0x3e, 0xc9, 0x36, 0xb3, 0x26, 0x88, 0xb1, 0x50, 0xc5, 0x85, 0x94, 0x4d, 0x20, 0x8, 0xf2, 0x13, 0x66, 0xb5, 0x31},
+               output512: []byte{0x8, 0x8, 0x45, 0xd6, 0xfd, 0x22, 0xa0, 0xb, 0x30, 0xfa, 0x1, 0xa4, 0xb4, 0xf8, 0x1f, 0xdc, 0x7b, 0x46, 0xca, 0x4c, 0x6a, 0x67, 0x6a, 0xd5, 0x86, 0x3a, 0x9d, 0xbf, 0x66, 0x11, 0xba, 0x97, 0xf2, 0x4f, 0xb5, 0x9b, 0xb5, 0xba, 0xc4, 0xe3, 0x76, 0xb3, 0xb8, 0xb3, 0x35, 0x71, 0x66, 0x78, 0x28, 0x76, 0xb7, 0x1, 0x27, 0x3f, 0xf3, 0x51, 0xbc, 0x8c, 0x58, 0x5, 0x53, 0x27, 0x67, 0xd4}},
+       testcase{
+               msg:       []byte{0xe2, 0x9d, 0x50, 0x51, 0x58, 0xdb, 0xdd, 0x93, 0x7d, 0x9e, 0x3d, 0x21, 0x45, 0x65, 0x8e, 0xe6, 0xf5, 0x99, 0x2a, 0x2f, 0xc7, 0x90, 0xf4, 0xf6, 0x8, 0xd9, 0xcd, 0xb4, 0x4a, 0x9, 0x1d, 0x5b, 0x94, 0xb8, 0x8e, 0x81, 0xfa, 0xc4, 0xfd, 0xf5, 0xc4, 0x94, 0x42, 0xf1, 0x3b, 0x91, 0x1c, 0x55, 0x88, 0x64, 0x69, 0x62, 0x95, 0x51, 0x18, 0x9e, 0xaf, 0xf6, 0x24, 0x88, 0xf1, 0xa4, 0x79, 0xb7, 0xdb, 0x11, 0xa1, 0x56, 0xe, 0x19, 0x8d, 0xdc, 0xcc, 0xcf, 0x50, 0x15, 0x90, 0x93, 0x42, 0x5f, 0xf7, 0xf1, 0xcb, 0x8d, 0x1d, 0x12, 0x46, 0xd0, 0x97, 0x87, 0x64, 0x8, 0x7d, 0x6b, 0xac, 0x25, 0x70, 0x26, 0xb0, 0x90, 0xef, 0xae, 0x8c, 0xec, 0x5f, 0x22, 0xb6, 0xf2, 0x1c, 0x59, 0xac, 0xe1, 0xac, 0x73, 0x86, 0xf5, 0xb8, 0x83, 0x7c, 0xa6, 0xa1, 0x2b, 0x6f, 0xbf, 0x55, 0x34, 0xdd, 0x5, 0x60, 0xef, 0x5, 0xca, 0x78, 0x10, 0x4d, 0x3b, 0x94, 0x3d, 0xdb, 0x22, 0xf, 0xea, 0xec, 0x89, 0xaa, 0x5e, 0x69, 0x2a, 0x0, 0xf8, 0x22, 0xa2, 0xab, 0x9a, 0x2f, 0xe6, 0x3, 0x50, 0xd7, 0x5e, 0x7b, 0xe1, 0x6f, 0xf2, 0x52, 0x6d, 0xc6, 0x43, 0x87, 0x25, 0x2, 0xd0, 0x1f, 0x42, 0xf1, 0x88, 0xab, 0xed, 0xa, 0x6e, 0x9a, 0x6f, 0x5f, 0xd0, 0xd1, 0xce, 0x7d, 0x57, 0x55, 0xc9, 0xff, 0xa6, 0x6b, 0xa, 0xf0, 0xb2, 0xb, 0xd8, 0x6, 0xf0, 0x8e, 0x6, 0x15, 0x66, 0x90, 0xd8, 0x1a, 0xc8, 0x11, 0x77, 0x8c, 0xa3, 0xda, 0xc2, 0xc2, 0x49, 0xb9, 0x60, 0x2, 0x1, 0x7f, 0xce, 0x93, 0xe5, 0x7, 0xe3, 0xb9, 0x53, 0xac, 0xf9, 0x99, 0x64, 0xb8, 0x47},
+               output224: []byte{0x79, 0x97, 0xfd, 0xf3, 0x8, 0x37, 0xd8, 0xb2, 0x5e, 0x85, 0xfc, 0x1, 0x31, 0x6e, 0x31, 0xb6, 0x1e, 0xe8, 0x14, 0x49, 0xd, 0xa0, 0x2, 0xa0, 0x48, 0x16, 0xd7, 0xca},
+               output256: []byte{0x67, 0x55, 0xbf, 0x7e, 0x60, 0xe4, 0xe0, 0x79, 0x65, 0xba, 0xc2, 0x4e, 0x51, 0xb1, 0xde, 0x93, 0xe3, 0xdd, 0x42, 0xae, 0x78, 0xf, 0x25, 0x66, 0x47, 0xd4, 0xcc, 0x2e, 0xf8, 0xef, 0xf7, 0x71},
+               output384: []byte{0x25, 0x16, 0xe0, 0x1, 0x5e, 0xd1, 0x62, 0x7, 0x32, 0x38, 0x99, 0x6d, 0x5a, 0x3, 0x23, 0x90, 0x87, 0xe0, 0x1c, 0x20, 0x91, 0xf7, 0xb0, 0x36, 0x37, 0xe6, 0xc8, 0x9a, 0x75, 0x8f, 0x56, 0x5e, 0x45, 0xc9, 0x8, 0xde, 0x87, 0x3e, 0x37, 0x8c, 0xaa, 0x43, 0x3b, 0xaf, 0x33, 0x9d, 0x5, 0x52},
+               output512: []byte{0x26, 0x78, 0xa8, 0x71, 0x5f, 0xc7, 0xe5, 0x38, 0x52, 0x2d, 0xd7, 0x60, 0x8d, 0x76, 0x95, 0x8, 0xb6, 0x30, 0x17, 0xd9, 0xeb, 0x6c, 0xc4, 0x8f, 0x1c, 0xb0, 0x7d, 0x14, 0xe7, 0x41, 0x6, 0x69, 0x36, 0xc8, 0x31, 0x6b, 0xf3, 0x21, 0x1e, 0x9, 0xf6, 0x26, 0x11, 0xe1, 0x40, 0xdd, 0xd1, 0x4a, 0x7, 0xf9, 0x7f, 0x9f, 0x37, 0x2e, 0x99, 0xc0, 0x84, 0xff, 0xe2, 0x89, 0xeb, 0x30, 0x2b, 0xd8}},
+       testcase{
+               msg:       []byte{0xd8, 0x55, 0x88, 0x69, 0x6f, 0x57, 0x6e, 0x65, 0xec, 0xa0, 0x15, 0x5f, 0x39, 0x5f, 0xc, 0xfa, 0xcd, 0x83, 0xf3, 0x6a, 0x99, 0x11, 0x1e, 0xd5, 0x76, 0x8d, 0xf2, 0xd1, 0x16, 0xd2, 0x12, 0x1e, 0x32, 0x35, 0x7b, 0xa4, 0xf5, 0x4e, 0xde, 0x92, 0x7f, 0x18, 0x9f, 0x29, 0x7d, 0x3a, 0x97, 0xfa, 0xd4, 0xe9, 0xa0, 0xf5, 0xb4, 0x1d, 0x8d, 0x89, 0xdd, 0x7f, 0xe2, 0x1, 0x56, 0x79, 0x9c, 0x2b, 0x7b, 0x6b, 0xf9, 0xc9, 0x57, 0xba, 0xd, 0x67, 0x63, 0xf5, 0xc3, 0xbc, 0x51, 0x29, 0x74, 0x7b, 0xbb, 0x53, 0x65, 0x2b, 0x49, 0x29, 0xc, 0xff, 0x1c, 0x87, 0xe2, 0xcd, 0xf2, 0xc4, 0xb9, 0x5d, 0x8a, 0xae, 0xe0, 0x9b, 0xc8, 0xfb, 0xfa, 0x68, 0x83, 0xe6, 0x2d, 0x23, 0x78, 0x85, 0x81, 0x4, 0x91, 0xbf, 0xc1, 0x1, 0xf1, 0xd8, 0xc6, 0x36, 0xe3, 0xd0, 0xed, 0xe8, 0x38, 0xad, 0x5, 0xc2, 0x7, 0xa3, 0xdf, 0x4f, 0xad, 0x76, 0x45, 0x29, 0x79, 0xeb, 0x99, 0xf2, 0x9a, 0xfa, 0xec, 0xed, 0xd1, 0xc6, 0x3b, 0x8d, 0x36, 0xcf, 0x37, 0x84, 0x54, 0xa1, 0xbb, 0x67, 0xa7, 0x41, 0xc7, 0x7a, 0xc6, 0xb6, 0xb3, 0xf9, 0x5f, 0x4f, 0x2, 0xb6, 0x4d, 0xab, 0xc1, 0x54, 0x38, 0x61, 0x3e, 0xa4, 0x97, 0x50, 0xdf, 0x42, 0xee, 0x90, 0x10, 0x1f, 0x11, 0x5a, 0xa9, 0xab, 0xb9, 0xff, 0x64, 0x32, 0x4d, 0xde, 0x9d, 0xab, 0xbb, 0x1, 0x5, 0x4e, 0x1b, 0xd6, 0xb4, 0xbc, 0xdc, 0x79, 0x30, 0xa4, 0x4c, 0x23, 0x0, 0xd8, 0x7c, 0xa7, 0x8c, 0x6, 0x92, 0x4d, 0x3, 0x23, 0xad, 0x78, 0x87, 0xe4, 0x6c, 0x90, 0xe8, 0xc4, 0xd1, 0x0, 0xac, 0xd9, 0xee, 0xd2, 0x1e},
+               output224: []byte{0x98, 0x97, 0xb4, 0x79, 0x87, 0x1a, 0xc7, 0x3d, 0xab, 0xbe, 0x62, 0x21, 0xe2, 0x7b, 0xfa, 0x67, 0x27, 0x8f, 0x2b, 0xb0, 0x44, 0xe3, 0xd0, 0x72, 0x6f, 0xcb, 0x2b, 0x81},
+               output256: []byte{0x62, 0xc9, 0xf5, 0xe5, 0xb5, 0x6e, 0x29, 0x94, 0x32, 0x7a, 0x7f, 0x9a, 0x3, 0x88, 0x8d, 0xa7, 0xba, 0xd6, 0x7e, 0x38, 0x75, 0x93, 0x80, 0x3b, 0x18, 0x7, 0x48, 0x2b, 0x13, 0x7b, 0x45, 0x9},
+               output384: []byte{0x6b, 0xae, 0x42, 0xad, 0xd0, 0x6c, 0x6a, 0x20, 0xa0, 0x5d, 0x84, 0x5e, 0x7b, 0xf3, 0x91, 0xf1, 0xea, 0xb8, 0x3e, 0x83, 0xa7, 0x10, 0xa1, 0x85, 0x27, 0xfc, 0x3, 0x64, 0x61, 0x4, 0xe5, 0x2a, 0x8b, 0x41, 0x7c, 0xff, 0x37, 0x57, 0x53, 0x88, 0x20, 0x81, 0xf3, 0x1b, 0x6f, 0x22, 0x95, 0xeb},
+               output512: []byte{0xaa, 0x3, 0xeb, 0x9, 0x41, 0x74, 0x35, 0xda, 0x9e, 0x6e, 0x78, 0x3, 0xf3, 0xb6, 0xea, 0xb6, 0x6f, 0xaa, 0x3d, 0x59, 0xcc, 0x62, 0x29, 0x50, 0xd6, 0x1f, 0x9b, 0x96, 0x2b, 0x69, 0x14, 0x5a, 0xc2, 0x25, 0x5c, 0xd7, 0x52, 0xcb, 0x96, 0x7, 0x74, 0x20, 0x92, 0x69, 0x7b, 0x1a, 0x79, 0xd1, 0x24, 0x81, 0x7a, 0xe2, 0x64, 0x21, 0xe6, 0x1d, 0x11, 0x76, 0x76, 0x48, 0x32, 0xed, 0x35, 0x4c}},
+       testcase{
+               msg:       []byte{0x3a, 0x12, 0xf8, 0x50, 0x8b, 0x40, 0xc3, 0x2c, 0x74, 0x49, 0x2b, 0x66, 0x32, 0x33, 0x75, 0xdc, 0xfe, 0x49, 0x18, 0x4c, 0x78, 0xf7, 0x31, 0x79, 0xf3, 0x31, 0x4b, 0x79, 0xe6, 0x33, 0x76, 0xb8, 0xac, 0x68, 0x3f, 0x5a, 0x51, 0xf1, 0x53, 0x4b, 0xd7, 0x29, 0xb0, 0x2b, 0x4, 0xd0, 0x2, 0xf5, 0x5c, 0xbd, 0x8e, 0x8f, 0xc9, 0xb5, 0xec, 0x1e, 0xa6, 0xbb, 0xe6, 0xa0, 0xd0, 0xe7, 0x43, 0x15, 0x18, 0xe6, 0xba, 0x45, 0xd1, 0x24, 0x3, 0x5f, 0x9d, 0x3d, 0xce, 0xa, 0x8b, 0xb7, 0xbf, 0x14, 0x30, 0xa9, 0xf6, 0x57, 0xe0, 0xb4, 0xea, 0x9f, 0x20, 0xeb, 0x20, 0xc7, 0x86, 0xa5, 0x81, 0x81, 0xa1, 0xe2, 0xa, 0x96, 0xf1, 0x62, 0x8f, 0x87, 0x28, 0xa1, 0x3b, 0xdf, 0x7a, 0x4b, 0x4b, 0x32, 0xfc, 0x8a, 0xa7, 0x5, 0x4c, 0xc4, 0x88, 0x1a, 0xe7, 0xfa, 0x19, 0xaf, 0xa6, 0x5c, 0x6c, 0x3e, 0xe1, 0xb3, 0xad, 0xe3, 0x19, 0x2a, 0xf4, 0x20, 0x54, 0xa8, 0xa9, 0x11, 0xb8, 0xec, 0x18, 0x26, 0x86, 0x5d, 0x46, 0xd9, 0x3f, 0x1e, 0x7c, 0x5e, 0x2b, 0x78, 0x13, 0xc9, 0x2a, 0x50, 0x6e, 0x53, 0x88, 0x6f, 0x3d, 0x47, 0x1, 0xbb, 0x93, 0xd2, 0xa6, 0x81, 0xad, 0x10, 0x9c, 0x84, 0x59, 0x4, 0xbb, 0x86, 0x1a, 0xf8, 0xaf, 0x6, 0x46, 0xb6, 0xe3, 0x99, 0xb3, 0x8b, 0x61, 0x40, 0x51, 0xd3, 0x4f, 0x68, 0x42, 0x56, 0x3a, 0xf, 0x37, 0xec, 0x0, 0xcb, 0x3d, 0x86, 0x5f, 0xc5, 0xd7, 0x46, 0xc4, 0x98, 0x7d, 0xe2, 0xa6, 0x50, 0x71, 0x10, 0x8, 0x83, 0xa2, 0xa9, 0xc7, 0xa2, 0xbf, 0xe1, 0xe2, 0xdd, 0x60, 0x3d, 0x9e, 0xa2, 0x4d, 0xc7, 0xc5, 0xfd, 0x6, 0xbe},
+               output224: []byte{0xea, 0xd2, 0x62, 0xf, 0xbc, 0x4b, 0xdf, 0xb1, 0x4a, 0xec, 0x8c, 0x7b, 0x9a, 0xa8, 0x82, 0xba, 0x3e, 0xb2, 0xaa, 0xcc, 0x9a, 0x15, 0xd7, 0xd3, 0x6d, 0xba, 0x8, 0x6d},
+               output256: []byte{0x99, 0x27, 0xfa, 0x5e, 0xfd, 0x86, 0x30, 0x4e, 0x73, 0xd5, 0x4a, 0xa4, 0x92, 0x88, 0x18, 0xc0, 0x5b, 0x1, 0x50, 0x46, 0x72, 0xc5, 0x29, 0x47, 0x13, 0x94, 0xa8, 0x2e, 0x4, 0x9e, 0x5f, 0x95},
+               output384: []byte{0x14, 0x69, 0xd, 0xdb, 0x5a, 0x48, 0xfd, 0xf3, 0x82, 0xdb, 0xc7, 0x45, 0xad, 0x3, 0x30, 0xc1, 0x48, 0x61, 0x24, 0xf6, 0xad, 0x2e, 0x5a, 0xe4, 0xa8, 0x50, 0xe3, 0x8c, 0x26, 0x4f, 0x99, 0xae, 0xae, 0x6f, 0x15, 0x60, 0x62, 0xab, 0x19, 0x46, 0xdd, 0x7, 0xaf, 0xe1, 0x70, 0xa, 0x82, 0x94},
+               output512: []byte{0xd3, 0x1, 0x2f, 0x2f, 0xb5, 0x68, 0x45, 0xb2, 0x58, 0xd7, 0x59, 0x8c, 0xb, 0xbb, 0x2c, 0x97, 0xd5, 0x3b, 0x60, 0x2d, 0xea, 0xe9, 0x32, 0x6d, 0xc3, 0x67, 0x8b, 0x22, 0x28, 0x45, 0x4a, 0x1e, 0x29, 0xf2, 0x88, 0x48, 0xed, 0x14, 0xc, 0x70, 0xbe, 0x85, 0xcd, 0xea, 0x9f, 0x99, 0xa8, 0xdc, 0x34, 0x7d, 0xea, 0xbd, 0x46, 0xd3, 0x62, 0xed, 0x1a, 0xfb, 0x23, 0x11, 0x46, 0xa0, 0x25, 0x5d}},
+       testcase{
+               msg:       []byte{0x18, 0x61, 0xed, 0xce, 0x46, 0xfa, 0x5a, 0xd1, 0x7e, 0x1f, 0xf1, 0xde, 0xae, 0x8, 0x4d, 0xec, 0x58, 0xf, 0x97, 0xd0, 0xa6, 0x78, 0x85, 0xdf, 0xe8, 0x34, 0xb9, 0xdf, 0xac, 0x1a, 0xe0, 0x76, 0x74, 0x2c, 0xe9, 0xe2, 0x67, 0x51, 0x2c, 0xa5, 0x1f, 0x6d, 0xf5, 0xa4, 0x55, 0xaf, 0xc, 0x5f, 0xd6, 0xab, 0xf9, 0x4a, 0xce, 0xa1, 0x3, 0xa3, 0x37, 0xc, 0x35, 0x44, 0x85, 0xa7, 0x84, 0x6f, 0xb8, 0x4f, 0x3a, 0xc7, 0xc2, 0x90, 0x4b, 0x5b, 0x2f, 0xbf, 0x22, 0x70, 0x2, 0xce, 0x51, 0x21, 0x33, 0xbb, 0x7e, 0x1c, 0x4e, 0x50, 0x5, 0x7b, 0xfd, 0x1e, 0x44, 0xdb, 0x33, 0xc7, 0xcd, 0xb9, 0x69, 0xa9, 0x9e, 0x28, 0x4b, 0x18, 0x4f, 0x50, 0xa1, 0x4b, 0x6, 0x8a, 0x1f, 0xc5, 0x0, 0x9d, 0x9b, 0x29, 0x8d, 0xbe, 0x92, 0x23, 0x95, 0x72, 0xa7, 0x62, 0x7a, 0xac, 0x2, 0xab, 0xe8, 0xf3, 0xe3, 0xb4, 0x73, 0x41, 0x7f, 0x36, 0xd4, 0xd2, 0x50, 0x5d, 0x16, 0xb7, 0x57, 0x7f, 0x45, 0x26, 0xc9, 0xd9, 0x4a, 0x27, 0xa, 0x2d, 0xfe, 0x45, 0xd, 0x6, 0xda, 0x8f, 0x6f, 0xa9, 0x56, 0x87, 0x9a, 0xa, 0x55, 0xcf, 0xe9, 0x9e, 0x74, 0x2e, 0xa5, 0x55, 0xea, 0x47, 0x7b, 0xa3, 0xe9, 0xb4, 0x4c, 0xcd, 0x50, 0x8c, 0x37, 0x54, 0x23, 0x61, 0x1a, 0xf9, 0x2e, 0x55, 0x34, 0x5d, 0xc2, 0x15, 0x77, 0x9b, 0x2d, 0x51, 0x19, 0xeb, 0xa4, 0x9c, 0x71, 0xd4, 0x9b, 0x9f, 0xe3, 0xf1, 0x56, 0x9f, 0xa2, 0x4e, 0x5c, 0xa3, 0xe3, 0x32, 0xd0, 0x42, 0x42, 0x2a, 0x8b, 0x81, 0x58, 0xd3, 0xec, 0x66, 0xa8, 0x0, 0x12, 0x97, 0x6f, 0x31, 0xff, 0xdf, 0x30, 0x5f, 0xc, 0x9c, 0x5e},
+               output224: []byte{0x54, 0x5e, 0x59, 0x81, 0x2c, 0x7a, 0xea, 0x1b, 0xd1, 0xcd, 0x48, 0x88, 0xd, 0x66, 0x50, 0x11, 0x7d, 0xfd, 0x9e, 0x58, 0xa7, 0x91, 0xda, 0xc1, 0x7, 0x2b, 0x19, 0xda},
+               output256: []byte{0x84, 0xe0, 0x56, 0xbf, 0x7b, 0xdf, 0xc7, 0x3a, 0x3a, 0xaa, 0x95, 0xb0, 0xa, 0x74, 0xa1, 0x36, 0xd7, 0x76, 0x6, 0x9b, 0xee, 0xb3, 0x4, 0x42, 0x3b, 0xea, 0xd9, 0x1, 0x20, 0xdb, 0x63, 0x50},
+               output384: []byte{0x9d, 0xa6, 0x65, 0x2b, 0xa8, 0x90, 0x0, 0x7a, 0x1, 0x12, 0x6f, 0xf, 0x65, 0x97, 0xa, 0xbf, 0x34, 0x74, 0xc7, 0x65, 0x9c, 0x6c, 0x80, 0xb0, 0x4d, 0xa2, 0xca, 0x59, 0x2e, 0xdf, 0xf, 0x39, 0x96, 0x1, 0xbc, 0xd, 0xad, 0x10, 0xa0, 0xdd, 0x6e, 0x31, 0x6a, 0x28, 0x6e, 0x23, 0x38, 0xef},
+               output512: []byte{0xb5, 0xc, 0x89, 0x6f, 0x2c, 0xdf, 0x7f, 0x10, 0x5d, 0xe7, 0x51, 0xff, 0x6c, 0xf6, 0x64, 0xe5, 0x92, 0xfa, 0xb7, 0x52, 0xd6, 0x52, 0xb0, 0x68, 0x98, 0xb9, 0xb2, 0x88, 0x5, 0x2d, 0xf2, 0x2f, 0x72, 0x1a, 0xd8, 0x7e, 0x70, 0x2a, 0xf0, 0x43, 0xe6, 0xb1, 0xe8, 0x89, 0x29, 0x85, 0xc, 0xbd, 0x56, 0x98, 0xa9, 0x17, 0x2c, 0x39, 0x32, 0x40, 0xb, 0x25, 0x38, 0xe4, 0x1, 0xa6, 0xf0, 0x81}},
+       testcase{
+               msg:       []byte{0x8, 0xd0, 0xff, 0xde, 0x3a, 0x6e, 0x4e, 0xf6, 0x56, 0x8, 0xea, 0x67, 0x2e, 0x48, 0x30, 0xc1, 0x29, 0x43, 0xd7, 0x18, 0x7c, 0xcf, 0xf0, 0x8f, 0x49, 0x41, 0xcf, 0xc1, 0x3e, 0x54, 0x5f, 0x3b, 0x9c, 0x7a, 0xd5, 0xee, 0xbb, 0xe2, 0xb0, 0x16, 0x42, 0xb4, 0x86, 0xca, 0xf8, 0x55, 0xc2, 0xc7, 0x3f, 0x58, 0xc1, 0xe4, 0xe3, 0x39, 0x1d, 0xa8, 0xe2, 0xd6, 0x3d, 0x96, 0xe1, 0x5f, 0xd8, 0x49, 0x53, 0xae, 0x5c, 0x23, 0x19, 0x11, 0xb0, 0xa, 0xd6, 0x5, 0xc, 0xd7, 0xaa, 0xfd, 0xaa, 0xc9, 0xb0, 0xf6, 0x63, 0xae, 0x6a, 0xab, 0x45, 0x51, 0x9d, 0xf, 0x53, 0x91, 0xa5, 0x41, 0x70, 0x7d, 0x47, 0x90, 0x34, 0xe7, 0x3a, 0x6a, 0xd8, 0x5, 0xae, 0x35, 0x98, 0x9, 0x6a, 0xf0, 0x78, 0xf1, 0x39, 0x33, 0x1, 0x49, 0x3d, 0x66, 0x3d, 0xd7, 0x1f, 0x83, 0x86, 0x9c, 0xa2, 0x7b, 0xa5, 0x8, 0xb7, 0xe9, 0x1e, 0x81, 0xe1, 0x28, 0xc1, 0x71, 0x6d, 0xc3, 0xac, 0xfe, 0x30, 0x84, 0xb2, 0x20, 0x1e, 0x4, 0xcf, 0x80, 0x6, 0x61, 0x7e, 0xec, 0xf1, 0xb6, 0x40, 0x47, 0x4a, 0x5d, 0x45, 0xcf, 0xde, 0x9f, 0x4d, 0x3e, 0xf9, 0x2d, 0x6d, 0x5, 0x5b, 0x90, 0x98, 0x92, 0x19, 0x4d, 0x8a, 0x82, 0x18, 0xdb, 0x6d, 0x82, 0x3, 0xa8, 0x42, 0x61, 0xd2, 0x0, 0xd7, 0x14, 0x73, 0xd7, 0x48, 0x8f, 0x34, 0x27, 0x41, 0x6b, 0x68, 0x96, 0xc1, 0x37, 0xd4, 0x55, 0xf2, 0x31, 0x7, 0x1c, 0xac, 0xbc, 0x86, 0xe0, 0x41, 0x5a, 0xb8, 0x8a, 0xec, 0x84, 0x1d, 0x96, 0xb7, 0xb8, 0xaf, 0x41, 0xe0, 0x5b, 0xb4, 0x61, 0xa4, 0x6, 0x45, 0xbf, 0x17, 0x66, 0x1, 0xf1, 0xe7, 0x60, 0xde, 0x5f},
+               output224: []byte{0x7c, 0x2f, 0xa0, 0x9, 0x61, 0xbc, 0xf0, 0x20, 0xb9, 0x5a, 0xe, 0xd7, 0x19, 0x3e, 0xa3, 0x58, 0x33, 0x40, 0xbb, 0xd3, 0x78, 0x98, 0xef, 0x6a, 0x46, 0x4c, 0x19, 0x40},
+               output256: []byte{0x40, 0x1c, 0x3b, 0xe5, 0x9c, 0xc3, 0x73, 0x45, 0x3a, 0xef, 0x96, 0x3, 0xf7, 0x33, 0x5c, 0x1d, 0x5f, 0xe6, 0x69, 0x90, 0x9a, 0x14, 0x25, 0xd7, 0x67, 0x1d, 0xcb, 0x84, 0xa4, 0x98, 0x87, 0xca},
+               output384: []byte{0xb9, 0x4d, 0x57, 0x8d, 0xe7, 0x9a, 0x43, 0x7b, 0xea, 0xd9, 0x51, 0xe9, 0xae, 0xe9, 0x12, 0x54, 0xd, 0x1, 0x39, 0x96, 0x5c, 0xf0, 0x14, 0x2f, 0x1f, 0xd4, 0x3, 0x53, 0x49, 0x59, 0xb7, 0x5d, 0x11, 0xe0, 0xb2, 0x46, 0x32, 0x1, 0xb1, 0x3, 0x64, 0xb9, 0x5, 0xcf, 0x9b, 0xaa, 0x57, 0xb3},
+               output512: []byte{0xa3, 0x4a, 0x2f, 0x27, 0xc3, 0x2f, 0x99, 0x3a, 0x7e, 0x70, 0x7, 0x86, 0x77, 0x33, 0x54, 0x74, 0x81, 0x29, 0x3c, 0x39, 0x12, 0x55, 0xff, 0xd0, 0xe5, 0xcc, 0xbe, 0x91, 0xe1, 0xcc, 0x74, 0x9b, 0x13, 0x52, 0x5a, 0xf6, 0xad, 0xfa, 0xc, 0x2d, 0x1d, 0x64, 0xbf, 0x87, 0xdd, 0x65, 0xb9, 0x96, 0xad, 0xa9, 0x11, 0x1c, 0x5d, 0xf5, 0x5b, 0xff, 0x8a, 0x57, 0x42, 0xe5, 0x4b, 0x84, 0x44, 0xf6}},
+       testcase{
+               msg:       []byte{0xd7, 0x82, 0xab, 0xb7, 0x2a, 0x5b, 0xe3, 0x39, 0x27, 0x57, 0xbe, 0x2, 0xd3, 0xe4, 0x5b, 0xe6, 0xe2, 0x9, 0x9d, 0x6f, 0x0, 0xd, 0x4, 0x2c, 0x8a, 0x54, 0x3f, 0x50, 0xed, 0x6e, 0xbc, 0x5, 0x5a, 0x7f, 0x13, 0x3b, 0xd, 0xd8, 0xe9, 0xbc, 0x34, 0x85, 0x36, 0xed, 0xca, 0xae, 0x2e, 0x12, 0xec, 0x18, 0xe8, 0x83, 0x7d, 0xf7, 0xa1, 0xb3, 0xc8, 0x7e, 0xc4, 0x6d, 0x50, 0xc2, 0x41, 0xde, 0xe8, 0x20, 0xfd, 0x58, 0x61, 0x97, 0x55, 0x2d, 0xc2, 0xb, 0xee, 0xa5, 0xf, 0x44, 0x5a, 0x7, 0xa3, 0x8f, 0x17, 0x68, 0xa3, 0x9e, 0x2b, 0x2f, 0xf0, 0x5d, 0xdd, 0xed, 0xf7, 0x51, 0xf1, 0xde, 0xf6, 0x12, 0xd2, 0xe4, 0xd8, 0x10, 0xda, 0xa3, 0xa0, 0xcc, 0x90, 0x45, 0x16, 0xf9, 0xa4, 0x3a, 0xf6, 0x60, 0x31, 0x53, 0x85, 0x17, 0x8a, 0x52, 0x9e, 0x51, 0xf8, 0xaa, 0xe1, 0x41, 0x80, 0x8c, 0x8b, 0xc5, 0xd7, 0xb6, 0xc, 0xac, 0x26, 0xbb, 0x98, 0x4a, 0xc1, 0x89, 0xd, 0x4, 0x36, 0xef, 0x78, 0x4, 0x26, 0xc5, 0x47, 0xe9, 0x4a, 0x7b, 0x8, 0xf0, 0x1a, 0xcb, 0xfc, 0x4a, 0x38, 0x25, 0xea, 0xe0, 0x4f, 0x52, 0xa, 0x90, 0x16, 0xf2, 0xfb, 0x8b, 0xf5, 0x16, 0x5e, 0xd1, 0x27, 0x36, 0xfc, 0x71, 0xe3, 0x6a, 0x49, 0xa7, 0x36, 0x14, 0x73, 0x9e, 0xaa, 0x3e, 0xc8, 0x34, 0x6, 0x9b, 0x1b, 0x40, 0xf1, 0x35, 0xc, 0x2b, 0x3a, 0xb8, 0x85, 0xc0, 0x2c, 0x64, 0xb, 0x9f, 0x76, 0x86, 0xed, 0x5f, 0x99, 0x52, 0x7e, 0x41, 0xcf, 0xcd, 0x79, 0x6f, 0xe4, 0xc2, 0x56, 0xc9, 0x17, 0x31, 0x86, 0xc2, 0x26, 0x16, 0x9f, 0xf2, 0x57, 0x95, 0x4e, 0xbd, 0xa8, 0x1c, 0xe, 0x5f, 0x99},
+               output224: []byte{0x23, 0x2d, 0xb2, 0x2e, 0xb2, 0xc1, 0x91, 0x9, 0xaf, 0xef, 0xb7, 0x19, 0x18, 0xea, 0x2d, 0xaa, 0x7c, 0xd, 0x76, 0x65, 0x2e, 0x18, 0x84, 0xea, 0x7a, 0x8a, 0xe6, 0x46},
+               output256: []byte{0x2, 0x4, 0x85, 0xdc, 0xd2, 0x64, 0x29, 0x6a, 0xfd, 0xb7, 0xf6, 0x43, 0xca, 0x82, 0x8c, 0x93, 0x35, 0x6f, 0x17, 0x14, 0xcb, 0xcc, 0x2f, 0xbb, 0xdd, 0x30, 0xf9, 0x89, 0x6c, 0x3f, 0x27, 0x89},
+               output384: []byte{0xb8, 0x5f, 0x56, 0xf6, 0x9d, 0x3b, 0xe5, 0x7a, 0x1c, 0x2a, 0xa5, 0x53, 0xf9, 0xb, 0xc1, 0xb0, 0x89, 0xe8, 0xf1, 0xc5, 0x61, 0x88, 0x1b, 0xe6, 0x46, 0x30, 0xea, 0x6b, 0xa4, 0xdd, 0x3b, 0xd5, 0x30, 0x15, 0x12, 0x31, 0x3a, 0x18, 0xc2, 0x6d, 0xf3, 0xe9, 0x7e, 0x5, 0x6a, 0x59, 0xed, 0xcf},
+               output512: []byte{0xdd, 0x5f, 0x4b, 0x16, 0x71, 0x75, 0xd9, 0x56, 0x6d, 0xca, 0x6c, 0x5b, 0x1b, 0x54, 0xa3, 0x3d, 0x2, 0xef, 0xd0, 0x2e, 0x25, 0xe2, 0x3b, 0xb6, 0xfb, 0x2, 0xd8, 0x78, 0xa4, 0x41, 0x5e, 0x5e, 0x86, 0x82, 0xc2, 0x9, 0xbe, 0xac, 0x4, 0xe9, 0x88, 0x2a, 0x27, 0x2d, 0x1, 0xe8, 0xeb, 0x43, 0x5c, 0xaa, 0x5b, 0xcd, 0x74, 0xfc, 0x82, 0x5c, 0x6b, 0x90, 0x82, 0xd0, 0x41, 0xdf, 0xf3, 0x33}},
+       testcase{
+               msg:       []byte{0x5f, 0xce, 0x81, 0x9, 0xa3, 0x58, 0x57, 0xe, 0x40, 0x98, 0x3e, 0x11, 0x84, 0xe5, 0x41, 0x83, 0x3b, 0xb9, 0x9, 0x1e, 0x28, 0xf, 0x25, 0x8c, 0xfb, 0x14, 0x43, 0x87, 0xb0, 0x5d, 0x19, 0xe, 0x43, 0x1c, 0xb1, 0x9b, 0xaa, 0x67, 0x27, 0x3b, 0xa0, 0xc5, 0x8a, 0xbe, 0x91, 0x30, 0x8e, 0x18, 0x44, 0xdc, 0xd0, 0xb3, 0x67, 0x8b, 0xaa, 0x42, 0xf3, 0x35, 0xf2, 0xfa, 0x5, 0x26, 0x7a, 0x2, 0x40, 0xb3, 0xc7, 0x18, 0xa5, 0x94, 0x2b, 0x3b, 0x3e, 0x3b, 0xfa, 0x98, 0xa5, 0x5c, 0x25, 0xa1, 0x46, 0x6e, 0x8d, 0x7a, 0x60, 0x37, 0x22, 0xcb, 0x2b, 0xbf, 0x3, 0xaf, 0xa5, 0x4c, 0xd7, 0x69, 0xa9, 0x9f, 0x31, 0x7, 0x35, 0xee, 0x5a, 0x5, 0xda, 0xe2, 0xc2, 0x2d, 0x39, 0x7b, 0xd9, 0x56, 0x35, 0xf5, 0x8c, 0x48, 0xa6, 0x7f, 0x90, 0xe1, 0xb7, 0x3a, 0xaf, 0xcd, 0x3f, 0x82, 0x11, 0x7f, 0x1, 0x66, 0x65, 0x78, 0x38, 0x69, 0x10, 0x5, 0xb1, 0x8d, 0xa6, 0xf3, 0x41, 0xd6, 0xe9, 0xf, 0xc1, 0xcd, 0xb3, 0x52, 0xb3, 0xf, 0xae, 0x45, 0xd3, 0x48, 0x29, 0x4e, 0x50, 0x1b, 0x63, 0x25, 0x2d, 0xe1, 0x47, 0x40, 0xf2, 0xb8, 0x5a, 0xe5, 0x29, 0x9d, 0xde, 0xc3, 0x17, 0x2d, 0xe8, 0xb6, 0xd0, 0xba, 0x21, 0x9a, 0x20, 0xa2, 0x3b, 0xb5, 0xe1, 0xf, 0xf4, 0x34, 0xd3, 0x9d, 0xb3, 0xf5, 0x83, 0x30, 0x5e, 0x9f, 0x5c, 0x3, 0x9d, 0x98, 0x56, 0x9e, 0x37, 0x7b, 0x75, 0xa7, 0xa, 0xb8, 0x37, 0xd1, 0xdf, 0x26, 0x9b, 0x8a, 0x4b, 0x56, 0x6f, 0x40, 0xbb, 0x91, 0xb5, 0x77, 0x45, 0x5f, 0xd3, 0xc3, 0x56, 0xc9, 0x14, 0xfa, 0x6, 0xb9, 0xa7, 0xce, 0x24, 0xc7, 0x31, 0x7a, 0x17, 0x2d},
+               output224: []byte{0xdb, 0x85, 0xaf, 0x5c, 0xfc, 0xe7, 0x46, 0x24, 0xe, 0x6d, 0x44, 0xe7, 0x3c, 0xef, 0x66, 0xa7, 0x2c, 0xe5, 0x96, 0x82, 0x84, 0xd3, 0x5f, 0xfe, 0xf7, 0xfb, 0xff, 0x6c},
+               output256: []byte{0xf8, 0xc4, 0x3e, 0x28, 0x81, 0x6b, 0xb4, 0x19, 0x93, 0xbd, 0xb8, 0x66, 0x88, 0x8f, 0x3c, 0xc5, 0x9e, 0xfb, 0xa2, 0x8, 0x39, 0x1, 0x44, 0xd3, 0x87, 0x8d, 0xbf, 0x9f, 0xbf, 0xa1, 0xd5, 0x7e},
+               output384: []byte{0x7d, 0x95, 0x8, 0xfb, 0x79, 0x58, 0x11, 0xea, 0x14, 0x42, 0xdb, 0x3e, 0xcb, 0x77, 0x9c, 0xb0, 0x49, 0x47, 0x36, 0xe7, 0x12, 0x3b, 0x25, 0x2c, 0xf8, 0x8a, 0x9a, 0xb, 0x50, 0xd5, 0x7c, 0xf0, 0xb, 0x87, 0xa6, 0xc4, 0xfa, 0xc2, 0x7f, 0x82, 0x1c, 0xd5, 0x59, 0x79, 0xd5, 0x86, 0xaa, 0x39},
+               output512: []byte{0xa4, 0x3a, 0xe5, 0xda, 0xd9, 0x36, 0x69, 0x75, 0x64, 0xae, 0x1b, 0xd9, 0xb8, 0x62, 0x4c, 0x5c, 0x31, 0xcc, 0x36, 0x60, 0x73, 0x22, 0xaf, 0x40, 0xe2, 0x53, 0xf1, 0xc, 0x28, 0x54, 0x67, 0xaf, 0xd0, 0xd0, 0x82, 0x52, 0xd2, 0xba, 0xd7, 0x6e, 0xfa, 0x52, 0xe4, 0x77, 0x5c, 0x9c, 0x26, 0x76, 0x1a, 0xbe, 0x38, 0x21, 0x28, 0x55, 0xa8, 0x1, 0x12, 0xfe, 0x2, 0x62, 0x3f, 0xbf, 0xa, 0x13}},
+       testcase{
+               msg:       []byte{0x61, 0x72, 0xf1, 0x97, 0x1a, 0x6e, 0x1e, 0x4e, 0x61, 0x70, 0xaf, 0xba, 0xd9, 0x5d, 0x5f, 0xec, 0x99, 0xbf, 0x69, 0xb2, 0x4b, 0x67, 0x4b, 0xc1, 0x7d, 0xd7, 0x80, 0x11, 0x61, 0x5e, 0x50, 0x2d, 0xe6, 0xf5, 0x6b, 0x86, 0xb1, 0xa7, 0x1d, 0x3f, 0x43, 0x48, 0x8, 0x72, 0x18, 0xac, 0x7b, 0x7d, 0x9, 0x30, 0x29, 0x93, 0xbe, 0x27, 0x2e, 0x4a, 0x59, 0x19, 0x68, 0xae, 0xf1, 0x8a, 0x12, 0x62, 0xd6, 0x65, 0x61, 0xd, 0x10, 0x70, 0xee, 0x91, 0xcc, 0x8d, 0xa3, 0x6e, 0x1f, 0x84, 0x1a, 0x69, 0xa7, 0xa6, 0x82, 0xc5, 0x80, 0xe8, 0x36, 0x94, 0x1d, 0x21, 0xd9, 0x9, 0xa3, 0xaf, 0xc1, 0xf0, 0xb9, 0x63, 0xe1, 0xca, 0x5a, 0xb1, 0x93, 0xe1, 0x24, 0xa1, 0xa5, 0x3d, 0xf1, 0xc5, 0x87, 0x47, 0xe, 0x58, 0x81, 0xfb, 0x54, 0xda, 0xe1, 0xb0, 0xd8, 0x40, 0xf0, 0xc8, 0xf9, 0xd1, 0xb0, 0x4c, 0x64, 0x5b, 0xa1, 0x4, 0x1c, 0x7d, 0x8d, 0xbf, 0x22, 0x3, 0xa, 0x62, 0x3a, 0xa1, 0x56, 0x38, 0xb3, 0xd9, 0x9a, 0x2c, 0x40, 0xf, 0xf7, 0x6f, 0x32, 0x52, 0x7, 0x9a, 0xf8, 0x8d, 0x2b, 0x37, 0xf3, 0x5e, 0xe6, 0x6c, 0x1a, 0xd7, 0x80, 0x1a, 0x28, 0xd3, 0xd3, 0x88, 0xac, 0x45, 0xb, 0x97, 0xd5, 0xf0, 0xf7, 0x9e, 0x45, 0x41, 0x75, 0x53, 0x56, 0xb3, 0xb1, 0xa5, 0x69, 0x6b, 0x2, 0x3f, 0x39, 0xab, 0x7a, 0xb5, 0xf2, 0x8d, 0xf4, 0x20, 0x29, 0x36, 0xbc, 0x97, 0x39, 0x3b, 0x93, 0xbc, 0x91, 0x5c, 0xb1, 0x59, 0xea, 0x1b, 0xd7, 0xa0, 0xa4, 0x14, 0xcb, 0x4b, 0x7a, 0x1a, 0xc3, 0xaf, 0x68, 0xf5, 0xd, 0x79, 0xf0, 0xc9, 0xc7, 0x31, 0x4e, 0x75, 0xf, 0x7d, 0x2, 0xfa, 0xa5, 0x8b, 0xfa},
+               output224: []byte{0xa1, 0xeb, 0x42, 0xfb, 0x7, 0x92, 0x36, 0x1f, 0xd, 0x68, 0x9, 0xa2, 0xe8, 0xdc, 0x6, 0x2f, 0x9, 0xf2, 0x85, 0x5b, 0x39, 0xbc, 0x2c, 0x4b, 0x7f, 0x54, 0x31, 0x1e},
+               output256: []byte{0x4e, 0xa5, 0x24, 0xe7, 0x5, 0x2, 0x2, 0x84, 0xb1, 0x82, 0x84, 0xe3, 0x46, 0x83, 0x72, 0x55, 0x90, 0xe1, 0xee, 0x56, 0x5a, 0x6f, 0xf5, 0x98, 0xed, 0x4d, 0x42, 0xb1, 0xc9, 0x87, 0x47, 0x1e},
+               output384: []byte{0xaf, 0xd9, 0x4b, 0x6, 0x1f, 0x35, 0x4b, 0x4, 0xd0, 0x71, 0x83, 0x26, 0xd7, 0xe1, 0xa, 0x6b, 0x59, 0x8c, 0xe3, 0x1c, 0xc3, 0x9c, 0x52, 0xd2, 0x65, 0xd6, 0xcf, 0x4, 0xe4, 0xd9, 0xee, 0x75, 0xcc, 0x20, 0x1, 0x49, 0x36, 0x76, 0x0, 0x31, 0x2e, 0x75, 0x14, 0xa6, 0x2f, 0xf, 0x9, 0x64},
+               output512: []byte{0xa5, 0xac, 0x23, 0xd4, 0xa0, 0xd5, 0x33, 0xcb, 0x9d, 0x8a, 0x68, 0x87, 0x3f, 0x5c, 0xb7, 0x49, 0x22, 0x84, 0x58, 0xd4, 0x3c, 0xe6, 0xbd, 0x5, 0x36, 0xc8, 0x73, 0x37, 0x77, 0xb5, 0xe6, 0xe3, 0xf2, 0x8f, 0xd3, 0x6b, 0xff, 0xe6, 0x90, 0x2, 0xa0, 0x77, 0x7b, 0xa7, 0x4f, 0xef, 0x22, 0xde, 0x3f, 0xac, 0x4c, 0x81, 0x8b, 0x48, 0x42, 0x81, 0x6c, 0x60, 0x94, 0x49, 0x6f, 0x96, 0x85, 0x55}},
+       testcase{
+               msg:       []byte{0x56, 0x68, 0xec, 0xd9, 0x9d, 0xfb, 0xe2, 0x15, 0xc4, 0x11, 0x83, 0x98, 0xac, 0x9c, 0x9e, 0xaf, 0x1a, 0x14, 0x33, 0xfa, 0xb4, 0xcc, 0xdd, 0x39, 0x68, 0x6, 0x47, 0x52, 0xb6, 0x25, 0xea, 0x94, 0x47, 0x31, 0xf7, 0x5d, 0x48, 0xa2, 0x7d, 0x4, 0x7d, 0x67, 0x54, 0x7f, 0x14, 0xdd, 0xf, 0xfa, 0xa5, 0x5f, 0xa5, 0xe2, 0x9f, 0x7a, 0xf0, 0xd1, 0x61, 0xd8, 0x5e, 0xaf, 0xc4, 0xf2, 0x2, 0x9b, 0x71, 0x7c, 0x91, 0x8e, 0xab, 0x9d, 0x30, 0x45, 0x43, 0x29, 0xb, 0xdb, 0xa7, 0x15, 0x8b, 0x68, 0x2, 0xc, 0xb, 0xa4, 0xe0, 0x79, 0xbc, 0x95, 0xb5, 0xbc, 0xf, 0xc0, 0x44, 0xa9, 0x92, 0xb9, 0x4b, 0x4c, 0xcd, 0x3b, 0xd6, 0x6d, 0xe, 0xab, 0xb5, 0xdb, 0xba, 0xb9, 0x4, 0xd6, 0x2e, 0x0, 0x75, 0x2c, 0x4e, 0x3b, 0x0, 0x91, 0xd7, 0x73, 0xbc, 0xf4, 0xc1, 0x4b, 0x43, 0x77, 0xda, 0x3e, 0xff, 0xf8, 0x24, 0xb1, 0xcb, 0x2f, 0xa0, 0x1b, 0x32, 0xd1, 0xe4, 0x6c, 0x90, 0x9e, 0x62, 0x6e, 0xd2, 0xda, 0xe9, 0x20, 0xf4, 0xc7, 0xdb, 0xeb, 0x63, 0x5b, 0xc7, 0x54, 0xfa, 0xcb, 0xd8, 0xd4, 0x9b, 0xeb, 0xa3, 0xf2, 0x3c, 0x1c, 0x41, 0xcc, 0xbf, 0xcd, 0xe, 0xe0, 0xc1, 0x14, 0xe6, 0x97, 0x37, 0xf5, 0x59, 0x7c, 0xb, 0xf1, 0xd8, 0x59, 0xf0, 0xc7, 0x67, 0xe1, 0x80, 0x2, 0xae, 0x8e, 0x39, 0xc2, 0x62, 0x61, 0xff, 0xde, 0x29, 0x20, 0xd3, 0xd0, 0xba, 0xf0, 0xe9, 0x6, 0x13, 0x86, 0x96, 0xcf, 0xe5, 0xb7, 0xe3, 0x2b, 0x60, 0xf, 0x45, 0xdf, 0x3a, 0xaa, 0x39, 0x93, 0x2f, 0x3a, 0x7d, 0xf9, 0x5b, 0x60, 0xfa, 0x87, 0x12, 0xa2, 0x27, 0x1f, 0xca, 0xf3, 0x91, 0x1c, 0xe7, 0xb5, 0x11, 0xb1},
+               output224: []byte{0x1a, 0xf4, 0xa3, 0xab, 0x9a, 0x7, 0xcf, 0x6, 0x4c, 0x25, 0x4d, 0x12, 0x2c, 0xc7, 0xde, 0x15, 0xe0, 0xf0, 0xd3, 0xca, 0x3d, 0xfa, 0x50, 0xea, 0x1c, 0x43, 0xa7, 0x8d},
+               output256: []byte{0xe4, 0x96, 0x3e, 0x74, 0xae, 0x1, 0xff, 0x77, 0x74, 0xb9, 0x6b, 0x4f, 0x61, 0x4d, 0x1c, 0xb2, 0xa4, 0xcf, 0x8d, 0x20, 0x6e, 0xd9, 0x3c, 0x66, 0xfa, 0x42, 0xf7, 0x14, 0x32, 0xbe, 0x2c, 0x3f},
+               output384: []byte{0xec, 0x63, 0xce, 0x9d, 0xd9, 0x79, 0xfc, 0xd1, 0x32, 0x24, 0x4b, 0xe1, 0x1a, 0x45, 0xdd, 0xb1, 0xd0, 0xf, 0xc8, 0xf8, 0x1, 0x60, 0xb8, 0xcc, 0x45, 0x6f, 0x5c, 0x5e, 0xb8, 0x9e, 0xc, 0x3f, 0x67, 0x5b, 0x28, 0xb9, 0x2d, 0xd9, 0xe6, 0xce, 0xfa, 0xa5, 0xda, 0x57, 0xb4, 0x90, 0x86, 0x46},
+               output512: []byte{0x7, 0xf3, 0xbc, 0xac, 0xf5, 0xf7, 0x88, 0x16, 0xd5, 0x15, 0xce, 0xdf, 0x1c, 0xbb, 0xa4, 0xff, 0xc5, 0x8d, 0x83, 0xaa, 0x86, 0x87, 0xb0, 0xe7, 0x25, 0x2f, 0xaa, 0xb4, 0x3e, 0x7f, 0x59, 0xa7, 0xff, 0x74, 0x15, 0x72, 0x7a, 0xdd, 0xf9, 0xa2, 0x25, 0x60, 0xad, 0xb5, 0x75, 0x5a, 0x2c, 0x6d, 0xf8, 0xc7, 0xe6, 0xdc, 0xac, 0xeb, 0x53, 0x10, 0x6a, 0x71, 0x4d, 0x80, 0x7a, 0xaa, 0xdb, 0xf3}},
+       testcase{
+               msg:       []byte{0x3, 0xd6, 0x25, 0x48, 0x83, 0x54, 0xdf, 0x30, 0xe3, 0xf8, 0x75, 0xa6, 0x8e, 0xdf, 0xcf, 0x34, 0xe, 0x83, 0x66, 0xa8, 0xe1, 0xab, 0x67, 0xf9, 0xd5, 0xc5, 0x48, 0x6a, 0x96, 0x82, 0x9d, 0xfa, 0xc0, 0x57, 0x82, 0x89, 0x8, 0x2b, 0x2a, 0x62, 0x11, 0x7e, 0x1c, 0xf4, 0x18, 0xb4, 0x3b, 0x90, 0xe0, 0xad, 0xc8, 0x81, 0xfc, 0x6a, 0xe8, 0x10, 0x5c, 0x88, 0x8e, 0x9e, 0xcd, 0x21, 0xae, 0xa1, 0xc9, 0xae, 0x1a, 0x40, 0x38, 0xdf, 0xd1, 0x73, 0x78, 0xfe, 0xd7, 0x1d, 0x2, 0xae, 0x49, 0x20, 0x87, 0xd7, 0xcd, 0xcd, 0x98, 0xf7, 0x46, 0x85, 0x52, 0x27, 0x96, 0x7c, 0xb1, 0xab, 0x47, 0x14, 0x26, 0x1e, 0xe3, 0xbe, 0xad, 0x3f, 0x4d, 0xb1, 0x18, 0x32, 0x9d, 0x3e, 0xbe, 0xf4, 0xbc, 0x48, 0xa8, 0x75, 0xc1, 0x9b, 0xa7, 0x63, 0x96, 0x6d, 0xa0, 0xeb, 0xea, 0x80, 0xe, 0x1, 0xb2, 0xf5, 0xb, 0x0, 0xe9, 0xdd, 0x4c, 0xac, 0xa6, 0xdc, 0xb3, 0x14, 0xd0, 0x1, 0x84, 0xef, 0x71, 0xea, 0x23, 0x91, 0xd7, 0x60, 0xc9, 0x50, 0x71, 0xd, 0xb4, 0xa7, 0xf, 0x92, 0x12, 0xff, 0xc5, 0x48, 0x61, 0xf9, 0xdc, 0x75, 0x2c, 0xe1, 0x88, 0x67, 0xb8, 0xad, 0xc, 0x48, 0xdf, 0x84, 0x66, 0xef, 0x72, 0x31, 0xe7, 0xac, 0x56, 0x7f, 0xe, 0xb5, 0x50, 0x99, 0xe6, 0x22, 0xeb, 0xb8, 0x6c, 0xb2, 0x37, 0x52, 0x1, 0x90, 0xa6, 0x1c, 0x66, 0xad, 0x34, 0xf1, 0xf4, 0xe2, 0x89, 0xcb, 0x32, 0x82, 0xae, 0x3e, 0xaa, 0xc6, 0x15, 0x2e, 0xd2, 0x4d, 0x2c, 0x92, 0xba, 0xe5, 0xa7, 0x65, 0x82, 0x52, 0xa5, 0x3c, 0x49, 0xb7, 0xb0, 0x2d, 0xfe, 0x54, 0xfd, 0xb2, 0xe9, 0x0, 0x74, 0xb6, 0xcf, 0x31, 0xa, 0xc6, 0x61},
+               output224: []byte{0xc1, 0x4d, 0x43, 0x52, 0x5e, 0x18, 0x89, 0x2c, 0x79, 0x14, 0x2d, 0x88, 0x7d, 0x2a, 0xd3, 0x99, 0x28, 0x48, 0xb7, 0x2c, 0xcc, 0x8, 0x7f, 0x64, 0xf0, 0xf1, 0xd6, 0x21},
+               output256: []byte{0xf, 0xd, 0x72, 0xbf, 0x8c, 0x1, 0x98, 0x45, 0x9e, 0x45, 0xec, 0xe9, 0xcc, 0x18, 0xe9, 0x30, 0xcb, 0x86, 0x26, 0x3a, 0xcc, 0xf1, 0xfc, 0x7a, 0x0, 0xbc, 0x85, 0x7a, 0xc9, 0xf2, 0x1, 0xad},
+               output384: []byte{0x86, 0x30, 0x1f, 0xe9, 0x8f, 0x3f, 0xfa, 0xbb, 0xc, 0xb0, 0x8, 0x5a, 0xaa, 0x1e, 0xc6, 0x1b, 0xca, 0xd6, 0x17, 0x14, 0x59, 0xa8, 0x62, 0x3b, 0xb7, 0x80, 0xec, 0x32, 0xe4, 0x6f, 0x52, 0x64, 0x99, 0x46, 0xa4, 0x21, 0xeb, 0xfc, 0x7d, 0xe9, 0xf, 0xe, 0x74, 0xec, 0x78, 0x7a, 0x3e, 0x3},
+               output512: []byte{0x13, 0xa5, 0x92, 0xb7, 0x3e, 0xde, 0x48, 0x70, 0x36, 0xc8, 0x81, 0x6b, 0xd6, 0xfc, 0x6c, 0xdc, 0x4, 0xdc, 0x61, 0x33, 0x40, 0x9a, 0x6e, 0xe9, 0x90, 0x58, 0x41, 0x60, 0x51, 0x8f, 0x9e, 0xf5, 0x73, 0x26, 0x4c, 0xf0, 0x4d, 0x38, 0xa3, 0xba, 0x75, 0xd1, 0x50, 0xf4, 0xf0, 0x26, 0xf6, 0xdf, 0x89, 0x36, 0xe1, 0x3c, 0x8f, 0x4f, 0x3e, 0xcc, 0x9e, 0xcb, 0xc4, 0x3f, 0xdf, 0xc4, 0x88, 0xa4}},
+       testcase{
+               msg:       []byte{0x2e, 0xdc, 0x28, 0x2f, 0xfb, 0x90, 0xb9, 0x71, 0x18, 0xdd, 0x3, 0xaa, 0xa0, 0x3b, 0x14, 0x5f, 0x36, 0x39, 0x5, 0xe3, 0xcb, 0xd2, 0xd5, 0xe, 0xcd, 0x69, 0x2b, 0x37, 0xbf, 0x0, 0x1, 0x85, 0xc6, 0x51, 0xd3, 0xe9, 0x72, 0x6c, 0x69, 0xd, 0x37, 0x73, 0xec, 0x1e, 0x48, 0x51, 0xe, 0x42, 0xb1, 0x77, 0x42, 0xb0, 0xb0, 0x37, 0x7e, 0x7d, 0xe6, 0xb8, 0xf5, 0x5e, 0x0, 0xa8, 0xa4, 0xdb, 0x47, 0x40, 0xce, 0xe6, 0xdb, 0x8, 0x30, 0x52, 0x9d, 0xd1, 0x96, 0x17, 0x50, 0x1d, 0xc1, 0xe9, 0x35, 0x9a, 0xa3, 0xbc, 0xf1, 0x47, 0xe0, 0xa7, 0x6b, 0x3a, 0xb7, 0xc, 0x49, 0x84, 0xc1, 0x3e, 0x33, 0x9e, 0x68, 0x6, 0xbb, 0x35, 0xe6, 0x83, 0xaf, 0x85, 0x27, 0x9, 0x36, 0x70, 0x85, 0x9f, 0x3d, 0x8a, 0xf, 0xc7, 0xd4, 0x93, 0xbc, 0xba, 0x6b, 0xb1, 0x2b, 0x5f, 0x65, 0xe7, 0x1e, 0x70, 0x5c, 0xa5, 0xd6, 0xc9, 0x48, 0xd6, 0x6e, 0xd3, 0xd7, 0x30, 0xb2, 0x6d, 0xb3, 0x95, 0xb3, 0x44, 0x77, 0x37, 0xc2, 0x6f, 0xad, 0x8, 0x9a, 0xa0, 0xad, 0xe, 0x30, 0x6c, 0xb2, 0x8b, 0xf0, 0xac, 0xf1, 0x6, 0xf8, 0x9a, 0xf3, 0x74, 0x5f, 0xe, 0xc7, 0x2d, 0x53, 0x49, 0x68, 0xcc, 0xa5, 0x43, 0xcd, 0x2c, 0xa5, 0xc, 0x94, 0xb1, 0x45, 0x67, 0x43, 0x25, 0x4e, 0x35, 0x8c, 0x13, 0x17, 0xc0, 0x7a, 0x7, 0xbf, 0x2b, 0xe, 0xca, 0x43, 0x8a, 0x70, 0x93, 0x67, 0xfa, 0xfc, 0x89, 0xa5, 0x72, 0x39, 0x2, 0x8f, 0xc5, 0xfe, 0xcf, 0xd5, 0x3b, 0x8e, 0xf9, 0x58, 0xef, 0x10, 0xee, 0x6, 0x8, 0xb7, 0xf5, 0xcb, 0x99, 0x23, 0xad, 0x97, 0x5, 0x8e, 0xc0, 0x67, 0x70, 0xc, 0xc7, 0x46, 0xc1, 0x27, 0xa6, 0x1e, 0xe3},
+               output224: []byte{0x11, 0x6c, 0x4, 0x62, 0xd5, 0xd, 0x57, 0xf9, 0x48, 0x1, 0x5e, 0xc7, 0x4b, 0xe9, 0x1, 0x57, 0x7, 0x31, 0x37, 0x12, 0xb4, 0x58, 0x83, 0xc0, 0x2f, 0xe8, 0x4e, 0x1e},
+               output256: []byte{0xdd, 0x1d, 0x2a, 0x92, 0xb3, 0xf3, 0xf3, 0x90, 0x2f, 0x6, 0x43, 0x65, 0x83, 0x8e, 0x1f, 0x5f, 0x34, 0x68, 0x73, 0xc, 0x34, 0x3e, 0x29, 0x74, 0xe7, 0xa9, 0xec, 0xfc, 0xd8, 0x4a, 0xa6, 0xdb},
+               output384: []byte{0xdd, 0xf8, 0xd5, 0x47, 0xbb, 0xa4, 0xf4, 0x3d, 0x88, 0x64, 0xca, 0xef, 0x1b, 0x1b, 0xed, 0x77, 0xaa, 0x12, 0xe4, 0x1f, 0x68, 0x86, 0xa5, 0xd8, 0x75, 0x8c, 0x65, 0x4b, 0x7e, 0xc1, 0xfa, 0x5b, 0xe, 0x77, 0xba, 0x4e, 0x76, 0x80, 0xc7, 0x83, 0xd, 0xa1, 0x61, 0xe1, 0x4c, 0xb1, 0xe6, 0x5c},
+               output512: []byte{0xc2, 0xfb, 0x59, 0xa, 0xb7, 0x4e, 0x23, 0xb, 0x8f, 0xe1, 0x59, 0x89, 0x2f, 0x94, 0xde, 0x4, 0xef, 0x7a, 0xda, 0xa0, 0x2b, 0x91, 0x8d, 0x49, 0x94, 0xf9, 0x96, 0x53, 0x8d, 0x25, 0x7f, 0x5a, 0x80, 0xc9, 0xb3, 0xbe, 0x8f, 0x41, 0x1, 0x70, 0xb0, 0xc5, 0xca, 0xc3, 0xf5, 0x7, 0x40, 0x12, 0x20, 0x88, 0x1c, 0x5e, 0x8, 0xd8, 0xbf, 0xa, 0x13, 0x24, 0x71, 0x70, 0xd3, 0x90, 0x85, 0xbc}},
+       testcase{
+               msg:       []byte{0x90, 0xb2, 0x8a, 0x6a, 0xa1, 0xfe, 0x53, 0x39, 0x15, 0xbc, 0xb8, 0xe8, 0x1e, 0xd6, 0xca, 0xcd, 0xc1, 0x9, 0x62, 0xb7, 0xff, 0x82, 0x47, 0x4f, 0x84, 0x5e, 0xeb, 0x86, 0x97, 0x76, 0x0, 0xcf, 0x70, 0xb0, 0x7b, 0xa8, 0xe3, 0x79, 0x61, 0x41, 0xee, 0x34, 0xe, 0x3f, 0xce, 0x84, 0x2a, 0x38, 0xa5, 0xa, 0xfb, 0xe9, 0x3, 0x1, 0xa3, 0xbd, 0xcc, 0x59, 0x1f, 0x2e, 0x7d, 0x9d, 0xe5, 0x3e, 0x49, 0x55, 0x25, 0x56, 0xb, 0x90, 0x8c, 0x89, 0x24, 0x39, 0x99, 0xa, 0x2c, 0xa2, 0x67, 0x9c, 0x55, 0x39, 0xff, 0xdf, 0x63, 0x67, 0x77, 0xad, 0x9c, 0x1c, 0xde, 0xf8, 0x9, 0xcd, 0xa9, 0xe8, 0xdc, 0xdb, 0x45, 0x1a, 0xbb, 0x9e, 0x9c, 0x17, 0xef, 0xa4, 0x37, 0x9a, 0xbd, 0x24, 0xb1, 0x82, 0xbd, 0x98, 0x1c, 0xaf, 0xc7, 0x92, 0x64, 0xa, 0x18, 0x3b, 0x61, 0x69, 0x43, 0x1, 0xd0, 0x4c, 0x5b, 0x3e, 0xaa, 0xd6, 0x94, 0xa6, 0xbd, 0x4c, 0xc0, 0x6e, 0xf5, 0xda, 0x8f, 0xa2, 0x3b, 0x4f, 0xa2, 0xa6, 0x45, 0x59, 0xc5, 0xa6, 0x83, 0x97, 0x93, 0x0, 0x79, 0xd2, 0x50, 0xc5, 0x1b, 0xcf, 0x0, 0xe2, 0xb1, 0x6a, 0x6c, 0x49, 0x17, 0x14, 0x33, 0xb0, 0xaa, 0xdf, 0xd8, 0x2, 0x31, 0x27, 0x65, 0x60, 0xb8, 0x4, 0x58, 0xdd, 0x77, 0x8, 0x9b, 0x7a, 0x1b, 0xbc, 0xc9, 0xe7, 0xe4, 0xb9, 0xf8, 0x81, 0xea, 0xcd, 0x6c, 0x92, 0xc4, 0x31, 0x83, 0x48, 0xa1, 0x3f, 0x49, 0x14, 0xeb, 0x27, 0x11, 0x5a, 0x1c, 0xfc, 0x5d, 0x16, 0xd7, 0xfd, 0x94, 0x95, 0x4c, 0x35, 0x32, 0xef, 0xac, 0xa2, 0xca, 0xb0, 0x25, 0x10, 0x3b, 0x2d, 0x2, 0xc6, 0xfd, 0x71, 0xda, 0x3a, 0x77, 0xf4, 0x17, 0xd7, 0x93, 0x26, 0x85, 0x88, 0x8a},
+               output224: []byte{0x96, 0xf7, 0x11, 0x11, 0x76, 0x64, 0x1f, 0x63, 0x73, 0x70, 0x1b, 0xa5, 0x94, 0x9, 0x0, 0x79, 0x14, 0x6d, 0x42, 0x20, 0xf3, 0xb, 0x51, 0x20, 0xc1, 0x24, 0x98, 0xba},
+               output256: []byte{0x21, 0xbf, 0x20, 0x66, 0x4c, 0xec, 0x2c, 0xd2, 0xce, 0xb1, 0xdf, 0xfc, 0x1d, 0x78, 0x89, 0x3d, 0x5c, 0xa1, 0xa7, 0xda, 0x88, 0xeb, 0x6b, 0xfd, 0xc, 0x6e, 0xfc, 0xa6, 0x19, 0xc, 0x9e, 0x15},
+               output384: []byte{0x72, 0x95, 0x3f, 0xe4, 0xca, 0x34, 0xe7, 0x17, 0xe3, 0x4, 0xdc, 0x77, 0xaf, 0xd9, 0xde, 0xde, 0x32, 0xa8, 0x46, 0x71, 0x27, 0xb9, 0xf7, 0x8b, 0xb0, 0xbe, 0x61, 0x91, 0xa7, 0xec, 0xd0, 0x51, 0xb7, 0xda, 0xe0, 0x91, 0xb1, 0x75, 0x89, 0x7, 0xdd, 0xa3, 0xb1, 0xd2, 0x5c, 0xc, 0x58, 0x83},
+               output512: []byte{0x2, 0x95, 0x15, 0x96, 0xa1, 0x3a, 0x1a, 0x41, 0x18, 0x8a, 0x4a, 0x1d, 0x63, 0x46, 0xf7, 0xea, 0xfb, 0x60, 0xa2, 0x5, 0x1e, 0xa6, 0x7c, 0x63, 0x23, 0x7d, 0x1a, 0x9b, 0x79, 0xec, 0x47, 0x33, 0xf3, 0x3e, 0xce, 0xc2, 0x23, 0xde, 0xdd, 0x94, 0x6b, 0x78, 0x38, 0x7b, 0x6f, 0x2d, 0xf5, 0xe9, 0xab, 0x6a, 0xf7, 0xdf, 0xba, 0xba, 0xf8, 0xf, 0x4f, 0xcc, 0x94, 0xfa, 0x8, 0x72, 0x75, 0xe8}},
+       testcase{
+               msg:       []byte{0x29, 0x69, 0x44, 0x7d, 0x17, 0x54, 0x90, 0xf2, 0xaa, 0x9b, 0xb0, 0x55, 0x1, 0x4d, 0xbe, 0xf2, 0xe6, 0x85, 0x4c, 0x95, 0xf8, 0xd6, 0x9, 0x50, 0xbf, 0xe8, 0xc0, 0xbe, 0x8d, 0xe2, 0x54, 0xc2, 0x6b, 0x2d, 0x31, 0xb9, 0xe4, 0xde, 0x9c, 0x68, 0xc9, 0xad, 0xf4, 0x9e, 0x4e, 0xe9, 0xb1, 0xc2, 0x85, 0x9, 0x67, 0xf2, 0x9f, 0x5d, 0x8, 0x73, 0x84, 0x83, 0xb4, 0x17, 0xbb, 0x96, 0xb2, 0xa5, 0x6f, 0xc, 0x8a, 0xca, 0x63, 0x2b, 0x55, 0x20, 0x59, 0xc5, 0x9a, 0xac, 0x3f, 0x61, 0xf7, 0xb4, 0x5c, 0x96, 0x6b, 0x75, 0xf1, 0xd9, 0x93, 0x1f, 0xf4, 0xe5, 0x96, 0x40, 0x63, 0x78, 0xce, 0xe9, 0x1a, 0xaa, 0x72, 0x6a, 0x3a, 0x84, 0xc3, 0x3f, 0x37, 0xe9, 0xcd, 0xbe, 0x62, 0x6b, 0x57, 0x45, 0xa0, 0xb0, 0x60, 0x64, 0xa8, 0xa8, 0xd5, 0x6e, 0x53, 0xaa, 0xf1, 0x2, 0xd2, 0x3d, 0xd9, 0xdf, 0xa, 0x3f, 0xdf, 0x7a, 0x63, 0x85, 0x9, 0xa6, 0x76, 0x1a, 0x33, 0xfa, 0x42, 0xfa, 0x8d, 0xdb, 0xd8, 0xe1, 0x61, 0x59, 0xc9, 0x30, 0x8, 0xb5, 0x37, 0x65, 0x1, 0x9c, 0x3f, 0xe, 0x9f, 0x10, 0xb1, 0x44, 0xce, 0x2a, 0xc5, 0x7f, 0x5d, 0x72, 0x97, 0xf9, 0xc9, 0x94, 0x9e, 0x4f, 0xf6, 0x8b, 0x70, 0xd3, 0x39, 0xf8, 0x75, 0x1, 0xce, 0x85, 0x50, 0xb7, 0x72, 0xf3, 0x2c, 0x6d, 0xa8, 0xad, 0x2c, 0xe2, 0x10, 0xa, 0x89, 0x5d, 0x8b, 0x8, 0xfa, 0x1e, 0xea, 0xd7, 0xc3, 0x76, 0xb4, 0x7, 0x70, 0x97, 0x3, 0xc5, 0x10, 0xb5, 0xf, 0x87, 0xe7, 0x3e, 0x43, 0xf8, 0xe7, 0x34, 0x8f, 0x87, 0xc3, 0x83, 0x2a, 0x54, 0x7e, 0xf2, 0xbb, 0xe5, 0x79, 0x9a, 0xbe, 0xdc, 0xf5, 0xe1, 0xf3, 0x72, 0xea, 0x80, 0x92, 0x33, 0xf0, 0x6},
+               output224: []byte{0x9e, 0xdd, 0xab, 0x2c, 0x9c, 0x60, 0xb1, 0x22, 0x50, 0x3c, 0x1c, 0x30, 0xec, 0x6e, 0x74, 0x5, 0xe, 0xe1, 0x3c, 0x7e, 0x10, 0x3a, 0x5, 0xf9, 0xed, 0x41, 0xd9, 0x92},
+               output256: []byte{0x64, 0x72, 0xd7, 0xc5, 0x30, 0xb5, 0x48, 0xe4, 0xb4, 0x7d, 0x22, 0x78, 0xd7, 0x17, 0x2b, 0x42, 0x1a, 0xf, 0xb6, 0x39, 0x8a, 0x28, 0x23, 0xdd, 0x2f, 0x2b, 0x26, 0x20, 0x8a, 0xf8, 0x94, 0x2e},
+               output384: []byte{0xf3, 0x6a, 0x9e, 0xe4, 0x55, 0x6, 0x6e, 0x56, 0x2f, 0xb6, 0x75, 0xf3, 0x99, 0xd9, 0xdc, 0xc6, 0xbc, 0xcf, 0x68, 0xfd, 0x1b, 0xb, 0xa9, 0xf7, 0xdc, 0xc1, 0xed, 0xfa, 0xc1, 0xf1, 0xe2, 0x34, 0xcb, 0x67, 0xb5, 0xa0, 0xf7, 0x70, 0xe5, 0x54, 0x35, 0xf7, 0x5f, 0x9e, 0xc8, 0x4a, 0x91, 0x51},
+               output512: []byte{0x5a, 0xa4, 0xe3, 0x2f, 0xe, 0xa3, 0xe8, 0x53, 0x92, 0x9b, 0xf6, 0x4a, 0xcc, 0x95, 0x65, 0xa0, 0x13, 0x0, 0xbc, 0x0, 0x70, 0x63, 0xb9, 0x39, 0xf6, 0xdb, 0xbe, 0x9c, 0xae, 0x5, 0x45, 0xea, 0x95, 0xfb, 0xca, 0xc3, 0x25, 0x75, 0xaa, 0x7, 0x27, 0xee, 0x4d, 0x93, 0x70, 0x71, 0xe6, 0xb3, 0xbe, 0x74, 0xe2, 0x3f, 0xe7, 0x6f, 0xd6, 0x3e, 0xc0, 0x5c, 0x7f, 0x7d, 0x8a, 0x40, 0x7a, 0xf0}},
+       testcase{
+               msg:       []byte{0x72, 0x16, 0x45, 0x63, 0x3a, 0x44, 0xa2, 0xc7, 0x8b, 0x19, 0x2, 0x4e, 0xae, 0xcf, 0x58, 0x57, 0x5a, 0xb2, 0x3c, 0x27, 0x19, 0x8, 0x33, 0xc2, 0x68, 0x75, 0xdc, 0xf, 0xd, 0x50, 0xb4, 0x6a, 0xea, 0x9c, 0x34, 0x3d, 0x82, 0xea, 0x7d, 0x5b, 0x3e, 0x50, 0xec, 0x70, 0x5, 0x45, 0xc6, 0x15, 0xda, 0xea, 0xea, 0x64, 0x72, 0x6a, 0xf, 0x5, 0x60, 0x75, 0x76, 0xdc, 0xd3, 0x96, 0xd8, 0x12, 0xb0, 0x3f, 0xb6, 0x55, 0x1c, 0x64, 0x10, 0x87, 0x85, 0x6d, 0x5, 0xb, 0x10, 0xe6, 0xa4, 0xd5, 0x57, 0x7b, 0x82, 0xa9, 0x8a, 0xfb, 0x89, 0xce, 0xe8, 0x59, 0x4c, 0x9d, 0xc1, 0x9e, 0x79, 0xfe, 0xff, 0x3, 0x82, 0xfc, 0xfd, 0x12, 0x7f, 0x1b, 0x80, 0x3a, 0x4b, 0x99, 0x46, 0xf4, 0xac, 0x9a, 0x43, 0x78, 0xe1, 0xe6, 0xe0, 0x41, 0xb1, 0x38, 0x9a, 0x53, 0xe3, 0x45, 0xc, 0xd3, 0x2d, 0x9d, 0x29, 0x41, 0xb0, 0xcb, 0xab, 0xdb, 0x50, 0xda, 0x8e, 0xa2, 0x51, 0x31, 0x45, 0x16, 0x4c, 0x3a, 0xb6, 0xbc, 0xbd, 0x25, 0x1c, 0x44, 0x8d, 0x2d, 0x4b, 0x8, 0x7a, 0xc5, 0x7a, 0x59, 0xc2, 0x28, 0x5d, 0x56, 0x4f, 0x16, 0xda, 0x4e, 0xd5, 0xe6, 0x7, 0xed, 0x97, 0x95, 0x92, 0x14, 0x6f, 0xfb, 0xe, 0xf3, 0xf3, 0xdb, 0x30, 0x8f, 0xb3, 0x42, 0xdf, 0x5e, 0xb5, 0x92, 0x4a, 0x48, 0x25, 0x6f, 0xc7, 0x63, 0x14, 0x1a, 0x27, 0x88, 0x14, 0xc8, 0x2d, 0x6d, 0x63, 0x48, 0x57, 0x75, 0x45, 0x87, 0xa, 0xe3, 0xa8, 0x3c, 0x72, 0x30, 0xac, 0x2, 0xa1, 0x54, 0xf, 0xe1, 0x79, 0x8f, 0x7e, 0xf0, 0x9e, 0x33, 0x5a, 0x86, 0x5a, 0x2a, 0xe0, 0x94, 0x9b, 0x21, 0xe4, 0xf7, 0x48, 0xfb, 0x8a, 0x51, 0xf4, 0x47, 0x50, 0xe2, 0x13, 0xa8, 0xfb},
+               output224: []byte{0x54, 0xcc, 0x87, 0xb9, 0x65, 0x51, 0x80, 0xc0, 0xe1, 0xc6, 0x67, 0x23, 0x50, 0xae, 0x19, 0x52, 0xdd, 0xf5, 0x1e, 0xe5, 0xd7, 0xe2, 0x15, 0x56, 0x96, 0x52, 0xaa, 0x2e},
+               output256: []byte{0x2a, 0xc7, 0xff, 0x80, 0xee, 0x36, 0xd5, 0x0, 0x99, 0x5c, 0x97, 0x3b, 0x87, 0x46, 0xd8, 0x46, 0x67, 0x15, 0xe6, 0xd8, 0xb0, 0xf5, 0x54, 0xaa, 0xcb, 0x5d, 0x28, 0x76, 0xd7, 0xf5, 0xb8, 0x74},
+               output384: []byte{0x37, 0x36, 0x8f, 0x5a, 0x7, 0x4d, 0xa0, 0xe5, 0x7, 0x58, 0x45, 0xf7, 0x6b, 0x1a, 0xc5, 0x85, 0x8d, 0xf7, 0x93, 0xee, 0xf8, 0x8a, 0x85, 0x4c, 0x7d, 0xaf, 0xe3, 0xb9, 0x7, 0x20, 0x70, 0x7a, 0x14, 0x5a, 0x5d, 0xcb, 0xd, 0x92, 0x66, 0xc6, 0x14, 0x82, 0x4, 0xce, 0x69, 0x3c, 0x54, 0x32},
+               output512: []byte{0x49, 0x5b, 0x2a, 0xa2, 0x10, 0x31, 0x59, 0xd9, 0xa9, 0x37, 0xe9, 0xdd, 0x56, 0xb0, 0x59, 0xac, 0xa9, 0x8a, 0x5e, 0x3c, 0xb7, 0xb5, 0x9b, 0xb6, 0x90, 0xde, 0xdc, 0x0, 0xc6, 0x92, 0xe9, 0xd7, 0xa1, 0x86, 0x14, 0xa7, 0x3d, 0x12, 0xe0, 0x76, 0x34, 0xb2, 0x9, 0xcc, 0x63, 0xd, 0x18, 0x18, 0xb0, 0x9f, 0x10, 0x76, 0xa9, 0x41, 0xff, 0x80, 0x47, 0x44, 0x93, 0xe3, 0xd4, 0x2b, 0x98, 0x12}},
+       testcase{
+               msg:       []byte{0x6b, 0x86, 0xd, 0x39, 0x72, 0x5a, 0x14, 0xb4, 0x98, 0xbb, 0x71, 0x45, 0x74, 0xb4, 0xd3, 0x7c, 0xa7, 0x87, 0x40, 0x47, 0x68, 0xf6, 0x4c, 0x64, 0x8b, 0x17, 0x51, 0xb3, 0x53, 0xac, 0x92, 0xba, 0xc2, 0xc3, 0xa2, 0x8e, 0xa9, 0x9, 0xfd, 0xf0, 0x42, 0x33, 0x36, 0x40, 0x1a, 0x2, 0xe6, 0x3e, 0xc2, 0x43, 0x25, 0x30, 0xd, 0x82, 0x3b, 0x68, 0x64, 0xbb, 0x70, 0x1f, 0x9d, 0x7c, 0x7a, 0x1f, 0x8e, 0xc9, 0xd0, 0xae, 0x35, 0x84, 0xaa, 0x6d, 0xd6, 0x2e, 0xa1, 0x99, 0x7c, 0xd8, 0x31, 0xb4, 0xba, 0xbd, 0x9a, 0x4d, 0xa5, 0x9, 0x32, 0xd4, 0xef, 0xda, 0x74, 0x5c, 0x61, 0xe4, 0x13, 0x8, 0x90, 0xe1, 0x56, 0xae, 0xe6, 0x11, 0x37, 0x16, 0xda, 0xf9, 0x57, 0x64, 0x22, 0x2a, 0x91, 0x18, 0x7d, 0xb2, 0xef, 0xfe, 0xa4, 0x9d, 0x5d, 0x5, 0x96, 0x10, 0x2d, 0x61, 0x9b, 0xd2, 0x6a, 0x61, 0x6b, 0xbf, 0xda, 0x83, 0x35, 0x50, 0x5f, 0xbb, 0xd, 0x90, 0xb4, 0xc1, 0x80, 0xd1, 0xa2, 0x33, 0x5b, 0x91, 0x53, 0x8e, 0x16, 0x68, 0xf9, 0xf9, 0x64, 0x27, 0x90, 0xb4, 0xe5, 0x5f, 0x9c, 0xab, 0xf, 0xe2, 0xbd, 0xd2, 0x93, 0x5d, 0x0, 0x1e, 0xe6, 0x41, 0x9a, 0xba, 0xb5, 0x45, 0x78, 0x80, 0xd0, 0xdb, 0xff, 0x20, 0xed, 0x87, 0x58, 0xf4, 0xc2, 0xf, 0xe7, 0x59, 0xef, 0xb3, 0x31, 0x41, 0xcf, 0xe, 0x89, 0x25, 0x87, 0xfe, 0x81, 0x87, 0xe5, 0xfb, 0xc5, 0x77, 0x86, 0xb7, 0xe8, 0xb0, 0x89, 0x61, 0x2c, 0x93, 0x6d, 0xfc, 0x3, 0xd2, 0x7e, 0xfb, 0xbe, 0x7c, 0x86, 0x73, 0xf1, 0x60, 0x6b, 0xd5, 0x1d, 0x5f, 0xf3, 0x86, 0xf4, 0xa7, 0xab, 0x68, 0xed, 0xf5, 0x9f, 0x38, 0x5e, 0xb1, 0x29, 0x1f, 0x11, 0x7b, 0xfe, 0x71, 0x73, 0x99},
+               output224: []byte{0x46, 0x29, 0xc9, 0x7f, 0x9b, 0xa9, 0x86, 0x98, 0xe0, 0xdd, 0xec, 0xa5, 0xe0, 0xa3, 0xb6, 0xde, 0x21, 0xe, 0xa9, 0xe8, 0x4b, 0xf9, 0x42, 0xc2, 0xcc, 0xf4, 0xec, 0x68},
+               output256: []byte{0x9f, 0xf8, 0x1d, 0x57, 0x5f, 0x7b, 0xf0, 0xc4, 0xef, 0x34, 0xb, 0x42, 0x79, 0xd5, 0x6e, 0x16, 0xce, 0x68, 0x82, 0x1a, 0xfc, 0xdf, 0x2a, 0x69, 0x10, 0x5d, 0x4f, 0x9c, 0xad, 0xad, 0xd3, 0xcf},
+               output384: []byte{0xda, 0xac, 0x83, 0xb0, 0xc5, 0xc8, 0xf8, 0xfc, 0x3b, 0xcc, 0xd2, 0x59, 0xc2, 0x7d, 0x96, 0x46, 0x73, 0xb4, 0xdc, 0xa7, 0x90, 0xb4, 0xb6, 0x38, 0x99, 0xe1, 0xb6, 0xc1, 0x9c, 0xc2, 0x91, 0xfe, 0x6f, 0x88, 0x37, 0x62, 0x81, 0xe0, 0xfa, 0x32, 0xa, 0xdf, 0xad, 0xc8, 0x2a, 0x8f, 0xf4, 0xef},
+               output512: []byte{0x21, 0x7b, 0x5a, 0x98, 0x5b, 0xed, 0x80, 0x0, 0x82, 0x74, 0x47, 0xe, 0x25, 0x44, 0x43, 0x23, 0x8c, 0x5a, 0xea, 0xcb, 0xc7, 0xee, 0x22, 0x89, 0xf0, 0xe6, 0x3b, 0x7a, 0xfe, 0x6d, 0xf, 0x39, 0x5e, 0x23, 0x61, 0xfd, 0x6d, 0x9d, 0xc3, 0x3b, 0x4f, 0x54, 0xf0, 0x3f, 0xf5, 0x6f, 0x6b, 0x26, 0x49, 0x76, 0x16, 0x1d, 0x80, 0x9, 0x17, 0x88, 0xee, 0x9d, 0x26, 0x2f, 0x14, 0x7a, 0x35, 0xfc}},
+       testcase{
+               msg:       []byte{0x6a, 0x1, 0x83, 0xa, 0xf3, 0x88, 0x9a, 0x25, 0x18, 0x32, 0x44, 0xde, 0xcb, 0x50, 0x8b, 0xd0, 0x12, 0x53, 0xd5, 0xb5, 0x8, 0xab, 0x49, 0xd, 0x31, 0x24, 0xaf, 0xbf, 0x42, 0x62, 0x6b, 0x2e, 0x70, 0x89, 0x4e, 0x9b, 0x56, 0x2b, 0x28, 0x8d, 0xa, 0x24, 0x50, 0xcf, 0xac, 0xf1, 0x4a, 0xd, 0xda, 0xe5, 0xc0, 0x47, 0x16, 0xe5, 0xa0, 0x8, 0x2c, 0x33, 0x98, 0x1f, 0x60, 0x37, 0xd2, 0x3d, 0x5e, 0x4, 0x5e, 0xe1, 0xef, 0x22, 0x83, 0xfb, 0x8b, 0x63, 0x78, 0xa9, 0x14, 0xc5, 0xd9, 0x44, 0x16, 0x27, 0xa7, 0x22, 0xc2, 0x82, 0xff, 0x45, 0x2e, 0x25, 0xa7, 0xea, 0x60, 0x8d, 0x69, 0xce, 0xe4, 0x39, 0x3a, 0x7, 0x25, 0xd1, 0x79, 0x63, 0xd0, 0x34, 0x26, 0x84, 0xf2, 0x55, 0x49, 0x6d, 0x8a, 0x18, 0xc2, 0x96, 0x11, 0x45, 0x31, 0x51, 0x30, 0x54, 0x93, 0x11, 0xfc, 0x7, 0xf0, 0x31, 0x2f, 0xb7, 0x8e, 0x60, 0x77, 0x33, 0x4f, 0x87, 0xea, 0xa8, 0x73, 0xbe, 0xe8, 0xaa, 0x95, 0x69, 0x89, 0x96, 0xeb, 0x21, 0x37, 0x5e, 0xb2, 0xb4, 0xef, 0x53, 0xc1, 0x44, 0x1, 0x20, 0x7d, 0xeb, 0x45, 0x68, 0x39, 0x8e, 0x5d, 0xd9, 0xa7, 0xcf, 0x97, 0xe8, 0xc9, 0x66, 0x3e, 0x23, 0x33, 0x4b, 0x46, 0x91, 0x2f, 0x83, 0x44, 0xc1, 0x9e, 0xfc, 0xf8, 0xc2, 0xba, 0x6f, 0x4, 0x32, 0x5f, 0x1a, 0x27, 0xe0, 0x62, 0xb6, 0x2a, 0x58, 0xd0, 0x76, 0x6f, 0xc6, 0xdb, 0x4d, 0x2c, 0x6a, 0x19, 0x28, 0x60, 0x4b, 0x1, 0x75, 0xd8, 0x72, 0xd1, 0x6b, 0x79, 0x8, 0xeb, 0xc0, 0x41, 0x76, 0x11, 0x87, 0xcc, 0x78, 0x55, 0x26, 0xc2, 0xa3, 0x87, 0x3f, 0xea, 0xc3, 0xa6, 0x42, 0xbb, 0x39, 0xf5, 0x35, 0x15, 0x50, 0xaf, 0x97, 0x70, 0xc3, 0x28, 0xaf, 0x7b},
+               output224: []byte{0xf4, 0x50, 0x34, 0xaa, 0x94, 0xc1, 0xa2, 0x68, 0x6e, 0xb8, 0x49, 0xef, 0x42, 0x62, 0xf2, 0xf5, 0xba, 0x9a, 0xcd, 0xd0, 0xe8, 0xea, 0x32, 0x40, 0x1e, 0x6, 0xb, 0x43},
+               output256: []byte{0x9, 0xed, 0xc4, 0x65, 0xd4, 0xfd, 0x91, 0xc5, 0xe8, 0x6b, 0x29, 0x2f, 0x4, 0x1b, 0xcc, 0x17, 0x57, 0x1e, 0x1f, 0x2e, 0x17, 0xd5, 0x84, 0xdf, 0xf2, 0x1d, 0xd7, 0xdd, 0x8d, 0x8b, 0xff, 0x35},
+               output384: []byte{0x35, 0x72, 0x58, 0xfa, 0x65, 0x79, 0x86, 0x7c, 0xc0, 0x8, 0x9c, 0x8b, 0x3c, 0x93, 0xce, 0x10, 0x67, 0x7a, 0x5a, 0xd4, 0xdb, 0xee, 0xe2, 0xa2, 0x7c, 0xea, 0x90, 0x31, 0x7a, 0xce, 0xbe, 0x72, 0x54, 0x50, 0x54, 0x68, 0x87, 0x5b, 0xcb, 0x33, 0x4e, 0xb, 0x6f, 0x70, 0xcf, 0xe5, 0x90, 0x82},
+               output512: []byte{0x29, 0x3c, 0x55, 0x1e, 0x75, 0x3b, 0xba, 0x7f, 0x31, 0x4d, 0xcb, 0x93, 0xa0, 0xfa, 0xd9, 0x4f, 0x3f, 0x5d, 0xee, 0x6e, 0xd4, 0x5d, 0x76, 0x5a, 0x70, 0x8e, 0x6f, 0xd2, 0x77, 0x60, 0x1f, 0x3, 0xf6, 0xc9, 0x5, 0xd7, 0xe1, 0xea, 0xea, 0xec, 0x51, 0x3c, 0xbb, 0xbd, 0x67, 0x2b, 0x81, 0x7f, 0x6d, 0x60, 0xfb, 0xf0, 0x2c, 0x20, 0x16, 0x7d, 0x7f, 0x4b, 0x7b, 0x84, 0xaf, 0xee, 0xb3, 0xf6}},
+       testcase{
+               msg:       []byte{0xb3, 0xc5, 0xe7, 0x4b, 0x69, 0x93, 0x3c, 0x25, 0x33, 0x10, 0x6c, 0x56, 0x3b, 0x4c, 0xa2, 0x2, 0x38, 0xf2, 0xb6, 0xe6, 0x75, 0xe8, 0x68, 0x1e, 0x34, 0xa3, 0x89, 0x89, 0x47, 0x85, 0xbd, 0xad, 0xe5, 0x96, 0x52, 0xd4, 0xa7, 0x3d, 0x80, 0xa5, 0xc8, 0x5b, 0xd4, 0x54, 0xfd, 0x1e, 0x9f, 0xfd, 0xad, 0x1c, 0x38, 0x15, 0xf5, 0x3, 0x8e, 0x9e, 0xf4, 0x32, 0xaa, 0xc5, 0xc3, 0xc4, 0xfe, 0x84, 0xc, 0xc3, 0x70, 0xcf, 0x86, 0x58, 0xa, 0x60, 0x11, 0x77, 0x8b, 0xbe, 0xda, 0xf5, 0x11, 0xa5, 0x1b, 0x56, 0xd1, 0xa2, 0xeb, 0x68, 0x39, 0x4a, 0xa2, 0x99, 0xe2, 0x6d, 0xa9, 0xad, 0xa6, 0xa2, 0xf3, 0x9b, 0x9f, 0xaf, 0xf7, 0xfb, 0xa4, 0x57, 0x68, 0x9b, 0x9c, 0x1a, 0x57, 0x7b, 0x2a, 0x1e, 0x50, 0x5f, 0xdf, 0x75, 0xc7, 0xa0, 0xa6, 0x4b, 0x1d, 0xf8, 0x1b, 0x3a, 0x35, 0x60, 0x1, 0xbf, 0xd, 0xf4, 0xe0, 0x2a, 0x1f, 0xc5, 0x9f, 0x65, 0x1c, 0x9d, 0x58, 0x5e, 0xc6, 0x22, 0x4b, 0xb2, 0x79, 0xc6, 0xbe, 0xba, 0x29, 0x66, 0xe8, 0x88, 0x2d, 0x68, 0x37, 0x60, 0x81, 0xb9, 0x87, 0x46, 0x8e, 0x7a, 0xed, 0x1e, 0xf9, 0xe, 0xbd, 0x9, 0xa, 0xe8, 0x25, 0x79, 0x5c, 0xdc, 0xa1, 0xb4, 0xf0, 0x9a, 0x97, 0x9c, 0x8d, 0xfc, 0x21, 0xa4, 0x8d, 0x8a, 0x53, 0xcd, 0xbb, 0x26, 0xc4, 0xdb, 0x54, 0x7f, 0xc0, 0x6e, 0xfe, 0x2f, 0x98, 0x50, 0xed, 0xd2, 0x68, 0x5a, 0x46, 0x61, 0xcb, 0x49, 0x11, 0xf1, 0x65, 0xd4, 0xb6, 0x3e, 0xf2, 0x5b, 0x87, 0xd0, 0xa9, 0x6d, 0x3d, 0xff, 0x6a, 0xb0, 0x75, 0x89, 0x99, 0xaa, 0xd2, 0x14, 0xd0, 0x7b, 0xd4, 0xf1, 0x33, 0xa6, 0x73, 0x4f, 0xde, 0x44, 0x5f, 0xe4, 0x74, 0x71, 0x1b, 0x69, 0xa9, 0x8f, 0x7e, 0x2b},
+               output224: []byte{0x62, 0x15, 0x3f, 0x59, 0x2c, 0x49, 0xd3, 0xc0, 0x48, 0x5f, 0x80, 0x7, 0x33, 0x19, 0x4, 0x9a, 0x51, 0xc, 0x73, 0x3, 0x27, 0x94, 0xc, 0xd9, 0xd5, 0x2f, 0x36, 0x98},
+               output256: []byte{0xc6, 0xd8, 0x6c, 0xc4, 0xcc, 0xef, 0x3b, 0xb7, 0xb, 0xf7, 0xbf, 0xdd, 0xec, 0x6a, 0x9a, 0x4, 0xa0, 0xdd, 0xa, 0x68, 0xfe, 0x1b, 0xf5, 0x1c, 0x14, 0x64, 0x8c, 0xf5, 0x6, 0xa0, 0x3e, 0x98},
+               output384: []byte{0x6, 0xe9, 0xf8, 0x92, 0xa2, 0x71, 0x6d, 0xe1, 0x8d, 0xac, 0x1b, 0x89, 0x46, 0x60, 0x44, 0x73, 0xad, 0xe0, 0x60, 0xaf, 0xc8, 0xcb, 0x12, 0x87, 0xe3, 0x89, 0x99, 0x40, 0x76, 0xff, 0x92, 0xb4, 0xba, 0xe3, 0xd8, 0x48, 0x54, 0x47, 0xe, 0xd0, 0x61, 0xae, 0x31, 0xa9, 0x7b, 0x7d, 0xd, 0xcf},
+               output512: []byte{0x89, 0xfe, 0x63, 0x14, 0xa0, 0x24, 0x6e, 0xff, 0x3b, 0xfd, 0x7, 0xa9, 0x5f, 0xe2, 0x39, 0xbd, 0x50, 0x71, 0x46, 0x7f, 0x53, 0x79, 0x91, 0x75, 0xb2, 0x26, 0xda, 0xf6, 0xc3, 0xdb, 0x61, 0x8c, 0xad, 0x4c, 0xa1, 0xc1, 0xaf, 0x64, 0xbf, 0x57, 0x93, 0xf0, 0x32, 0x54, 0xf5, 0x60, 0xe6, 0x33, 0x5b, 0xea, 0xaa, 0x86, 0xbc, 0xb9, 0xe9, 0x61, 0xf2, 0x14, 0xb2, 0xae, 0x97, 0xb4, 0x7a, 0xf0}},
+       testcase{
+               msg:       []byte{0x83, 0xaf, 0x34, 0x27, 0x9c, 0xcb, 0x54, 0x30, 0xfe, 0xbe, 0xc0, 0x7a, 0x81, 0x95, 0xd, 0x30, 0xf4, 0xb6, 0x6f, 0x48, 0x48, 0x26, 0xaf, 0xee, 0x74, 0x56, 0xf0, 0x7, 0x1a, 0x51, 0xe1, 0xbb, 0xc5, 0x55, 0x70, 0xb5, 0xcc, 0x7e, 0xc6, 0xf9, 0x30, 0x9c, 0x17, 0xbf, 0x5b, 0xef, 0xdd, 0x7c, 0x6b, 0xa6, 0xe9, 0x68, 0xcf, 0x21, 0x8a, 0x2b, 0x34, 0xbd, 0x5c, 0xf9, 0x27, 0xab, 0x84, 0x6e, 0x38, 0xa4, 0xb, 0xbd, 0x81, 0x75, 0x9e, 0x9e, 0x33, 0x38, 0x10, 0x16, 0xa7, 0x55, 0xf6, 0x99, 0xdf, 0x35, 0xd6, 0x60, 0x0, 0x7b, 0x5e, 0xad, 0xf2, 0x92, 0xfe, 0xef, 0xb7, 0x35, 0x20, 0x7e, 0xbf, 0x70, 0xb5, 0xbd, 0x17, 0x83, 0x4f, 0x7b, 0xfa, 0xe, 0x16, 0xcb, 0x21, 0x9a, 0xd4, 0xaf, 0x52, 0x4a, 0xb1, 0xea, 0x37, 0x33, 0x4a, 0xa6, 0x64, 0x35, 0xe5, 0xd3, 0x97, 0xfc, 0xa, 0x6, 0x5c, 0x41, 0x1e, 0xbb, 0xce, 0x32, 0xc2, 0x40, 0xb9, 0x4, 0x76, 0xd3, 0x7, 0xce, 0x80, 0x2e, 0xc8, 0x2c, 0x1c, 0x49, 0xbc, 0x1b, 0xec, 0x48, 0xc0, 0x67, 0x5e, 0xc2, 0xa6, 0xc6, 0xf3, 0xed, 0x3e, 0x5b, 0x74, 0x1d, 0x13, 0x43, 0x70, 0x95, 0x70, 0x7c, 0x56, 0x5e, 0x10, 0xd8, 0xa2, 0xb, 0x8c, 0x20, 0x46, 0x8f, 0xf9, 0x51, 0x4f, 0xcf, 0x31, 0xb4, 0x24, 0x9c, 0xd8, 0x2d, 0xce, 0xe5, 0x8c, 0xa, 0x2a, 0xf5, 0x38, 0xb2, 0x91, 0xa8, 0x7e, 0x33, 0x90, 0xd7, 0x37, 0x19, 0x1a, 0x7, 0x48, 0x4a, 0x5d, 0x3f, 0x3f, 0xb8, 0xc8, 0xf1, 0x5c, 0xe0, 0x56, 0xe5, 0xe5, 0xf8, 0xfe, 0xbe, 0x5e, 0x1f, 0xb5, 0x9d, 0x67, 0x40, 0x98, 0xa, 0xa0, 0x6c, 0xa8, 0xa0, 0xc2, 0xf, 0x57, 0x12, 0xb4, 0xcd, 0xe5, 0xd0, 0x32, 0xe9, 0x2a, 0xb8, 0x9f, 0xa, 0xe1},
+               output224: []byte{0xec, 0xde, 0x4d, 0x6e, 0xb0, 0xcf, 0x28, 0x1, 0xb, 0x45, 0xd0, 0xd3, 0x10, 0xe7, 0xd0, 0x5f, 0x8, 0xb8, 0xa, 0xfc, 0x44, 0xb8, 0xa3, 0x59, 0xbe, 0x7e, 0x19, 0x23},
+               output256: []byte{0x1a, 0xfc, 0x9b, 0xa6, 0x3e, 0xea, 0x27, 0x60, 0x3b, 0x3a, 0x7a, 0x55, 0x62, 0xe1, 0x2b, 0x31, 0xe8, 0xfe, 0x9a, 0x96, 0x81, 0x2b, 0x53, 0x1e, 0x9d, 0x4, 0x83, 0x85, 0xfb, 0x76, 0xd4, 0x4f},
+               output384: []byte{0x64, 0x4, 0x77, 0x90, 0xb1, 0x65, 0x6e, 0x78, 0x95, 0x3b, 0x98, 0x1b, 0x1b, 0xbf, 0xae, 0xaf, 0x9d, 0x2b, 0x1b, 0x89, 0x53, 0xab, 0x3, 0x4, 0x79, 0x12, 0x38, 0x39, 0x3f, 0x33, 0x72, 0xc6, 0x37, 0x3a, 0x1e, 0x8, 0x7b, 0x57, 0xbe, 0x48, 0x80, 0x62, 0x29, 0xdb, 0x73, 0xe1, 0xb1, 0xa4},
+               output512: []byte{0x76, 0x90, 0xf7, 0x3, 0xe8, 0x94, 0xee, 0x22, 0xd4, 0xdf, 0xf5, 0x5a, 0x7f, 0x8d, 0x50, 0x21, 0xd5, 0xf1, 0x7b, 0x72, 0x9f, 0x95, 0xa5, 0x9c, 0x4d, 0x55, 0xcf, 0xb2, 0x25, 0xc6, 0x7b, 0xe1, 0x5, 0xf2, 0xe7, 0xcd, 0xf5, 0x6d, 0x14, 0xe, 0x56, 0x66, 0x48, 0xe9, 0xe9, 0xc3, 0x9b, 0xbe, 0xd9, 0x6f, 0x98, 0x5a, 0x6d, 0xae, 0x1f, 0x21, 0xd8, 0xba, 0x50, 0xf, 0x7f, 0xd4, 0xe, 0xdf}},
+       testcase{
+               msg:       []byte{0xa7, 0xed, 0x84, 0x74, 0x9c, 0xcc, 0x56, 0xbb, 0x1d, 0xfb, 0xa5, 0x71, 0x19, 0xd2, 0x79, 0xd4, 0x12, 0xb8, 0xa9, 0x86, 0x88, 0x6d, 0x81, 0xf, 0x6, 0x7a, 0xf3, 0x49, 0xe8, 0x74, 0x9e, 0x9e, 0xa7, 0x46, 0xa6, 0xb, 0x3, 0x74, 0x26, 0x36, 0xc4, 0x64, 0xfc, 0x1e, 0xe2, 0x33, 0xac, 0xc5, 0x2c, 0x19, 0x83, 0x91, 0x46, 0x92, 0xb6, 0x43, 0x9, 0xed, 0xfd, 0xf2, 0x9f, 0x1a, 0xb9, 0x12, 0xec, 0x3e, 0x8d, 0xa0, 0x74, 0xd3, 0xf1, 0xd2, 0x31, 0x51, 0x1f, 0x57, 0x56, 0xf0, 0xb6, 0xee, 0xad, 0x3e, 0x89, 0xa6, 0xa8, 0x8f, 0xe3, 0x30, 0xa1, 0xf, 0xac, 0xe2, 0x67, 0xbf, 0xfb, 0xfc, 0x3e, 0x30, 0x90, 0xc7, 0xfd, 0x9a, 0x85, 0x5, 0x61, 0xf3, 0x63, 0xad, 0x75, 0xea, 0x88, 0x1e, 0x72, 0x44, 0xf8, 0xf, 0xf5, 0x58, 0x2, 0xd5, 0xef, 0x7a, 0x1a, 0x4e, 0x7b, 0x89, 0xfc, 0xfa, 0x80, 0xf1, 0x6d, 0xf5, 0x4d, 0x1b, 0x5, 0x6e, 0xe6, 0x37, 0xe6, 0x96, 0x4b, 0x9e, 0xf, 0xfd, 0x15, 0xb6, 0x19, 0x6b, 0xdd, 0x7d, 0xb2, 0x70, 0xc5, 0x6b, 0x47, 0x25, 0x14, 0x85, 0x34, 0x8e, 0x49, 0x81, 0x3b, 0x4e, 0xb9, 0xed, 0x12, 0x2a, 0x1, 0xb3, 0xea, 0x45, 0xad, 0x5e, 0x1a, 0x92, 0x9d, 0xf6, 0x1d, 0x5c, 0xf, 0x3e, 0x77, 0xe1, 0xfd, 0xc3, 0x56, 0xb6, 0x38, 0x83, 0xa6, 0xe, 0x9c, 0xbb, 0x9f, 0xc3, 0xe0, 0xc, 0x2f, 0x32, 0xdb, 0xd4, 0x69, 0x65, 0x98, 0x83, 0xf6, 0x90, 0xc6, 0x77, 0x2e, 0x33, 0x5f, 0x61, 0x7b, 0xc3, 0x3f, 0x16, 0x1d, 0x6f, 0x69, 0x84, 0x25, 0x2e, 0xe1, 0x2e, 0x62, 0xb6, 0x0, 0xa, 0xc5, 0x23, 0x1e, 0xc, 0x9b, 0xc6, 0x5b, 0xe2, 0x23, 0xd8, 0xdf, 0xd9, 0x4c, 0x50, 0x4, 0xa1, 0x1, 0xaf, 0x9f, 0xd6, 0xc0, 0xfb},
+               output224: []byte{0x3b, 0xfc, 0x50, 0x18, 0xcf, 0x15, 0xcb, 0x88, 0x0, 0x79, 0x29, 0x92, 0x4b, 0x3e, 0x1, 0x46, 0x35, 0xef, 0x13, 0x5c, 0x91, 0xf9, 0x67, 0x1b, 0x29, 0xbe, 0x87, 0x31},
+               output256: []byte{0x9b, 0x5e, 0x15, 0x53, 0x13, 0x85, 0xf0, 0xd4, 0x95, 0xfd, 0xbe, 0x68, 0x6e, 0x3e, 0x2, 0xec, 0xa4, 0x2b, 0x9f, 0x1b, 0x1c, 0xe8, 0x83, 0x7a, 0xd3, 0xb3, 0xe4, 0x2e, 0x61, 0x98, 0x5, 0xa},
+               output384: []byte{0x9c, 0xa6, 0xf3, 0x90, 0x87, 0xe6, 0x45, 0x7e, 0x12, 0xc9, 0x69, 0xd4, 0x1c, 0x8b, 0xd6, 0x6b, 0xdd, 0x69, 0x90, 0xce, 0x23, 0xd3, 0x55, 0x66, 0x9e, 0x76, 0x6, 0xb9, 0x20, 0x3d, 0x21, 0x68, 0x11, 0x23, 0x79, 0x55, 0xdf, 0x67, 0x39, 0x49, 0x5d, 0x94, 0xf0, 0xc4, 0x8c, 0xe0, 0x28, 0x45},
+               output512: []byte{0x65, 0xe4, 0x15, 0xc7, 0x95, 0x8a, 0x47, 0xfc, 0xa9, 0xee, 0xd3, 0x84, 0x6f, 0xd1, 0x28, 0x3a, 0xfe, 0xb3, 0x8e, 0x51, 0x30, 0xf5, 0x7e, 0xcd, 0x99, 0xdc, 0xb2, 0x1b, 0xed, 0xda, 0x85, 0x6e, 0x3b, 0x5f, 0xb9, 0xf8, 0x39, 0xe5, 0x79, 0xc5, 0xea, 0x38, 0x6e, 0xac, 0xa8, 0xcd, 0xc0, 0xa9, 0x54, 0x9e, 0xaa, 0xf6, 0xec, 0x45, 0x2d, 0xd6, 0xcb, 0x52, 0x12, 0xb7, 0x9, 0xbf, 0x5c, 0x59}},
+       testcase{
+               msg:       []byte{0xa6, 0xfe, 0x30, 0xdc, 0xfc, 0xda, 0x1a, 0x32, 0x9e, 0x82, 0xab, 0x50, 0xe3, 0x2b, 0x5f, 0x50, 0xeb, 0x25, 0xc8, 0x73, 0xc5, 0xd2, 0x30, 0x58, 0x60, 0xa8, 0x35, 0xae, 0xce, 0xe6, 0x26, 0x4a, 0xa3, 0x6a, 0x47, 0x42, 0x99, 0x22, 0xc4, 0xb8, 0xb3, 0xaf, 0xd0, 0xd, 0xa1, 0x60, 0x35, 0x83, 0xe, 0xdb, 0x89, 0x78, 0x31, 0xc4, 0xe7, 0xb0, 0xf, 0x2c, 0x23, 0xfc, 0xb, 0x15, 0xfd, 0xc3, 0xd, 0x85, 0xfb, 0x70, 0xc3, 0xc, 0x43, 0x1c, 0x63, 0x8e, 0x1a, 0x25, 0xb5, 0x1c, 0xaf, 0x1d, 0x7e, 0x8b, 0x5, 0xb, 0x7f, 0x89, 0xbf, 0xb3, 0xf, 0x59, 0xf0, 0xf2, 0xf, 0xec, 0xff, 0x3d, 0x63, 0x9a, 0xbc, 0x42, 0x55, 0xb3, 0x86, 0x8f, 0xc4, 0x5d, 0xd8, 0x1e, 0x47, 0xeb, 0x12, 0xab, 0x40, 0xf2, 0xaa, 0xc7, 0x35, 0xdf, 0x5d, 0x1d, 0xc1, 0xad, 0x99, 0x7c, 0xef, 0xc4, 0xd8, 0x36, 0xb8, 0x54, 0xce, 0xe9, 0xac, 0x2, 0x90, 0x0, 0x36, 0xf3, 0x86, 0x7f, 0xe0, 0xd8, 0x4a, 0xff, 0xf3, 0x7b, 0xde, 0x33, 0x8, 0xc2, 0x20, 0x6c, 0x62, 0xc4, 0x74, 0x33, 0x75, 0x9, 0x41, 0x8, 0x87, 0x7c, 0x73, 0xb8, 0x7b, 0x25, 0x46, 0xfe, 0x5, 0xea, 0x13, 0x7b, 0xed, 0xfc, 0x6, 0xa2, 0x79, 0x62, 0x74, 0x9, 0x9a, 0xd, 0x55, 0x4d, 0xa8, 0xf7, 0xd7, 0x22, 0x3a, 0x48, 0xcb, 0xf3, 0x1b, 0x7d, 0xec, 0xaa, 0x1e, 0xbc, 0x8b, 0x14, 0x57, 0x63, 0xe3, 0x67, 0x31, 0x68, 0xc1, 0xb1, 0xb7, 0x15, 0xc1, 0xcd, 0x99, 0xec, 0xd3, 0xdd, 0xb2, 0x38, 0xb0, 0x60, 0x49, 0x88, 0x5e, 0xca, 0xd9, 0x34, 0x7c, 0x24, 0x36, 0xdf, 0xf3, 0x2c, 0x77, 0x1f, 0x34, 0xa3, 0x85, 0x87, 0xa4, 0x4a, 0x82, 0xc5, 0xd3, 0xd1, 0x37, 0xa0, 0x3c, 0xaa, 0x27, 0xe6, 0x6c, 0x8f, 0xf6},
+               output224: []byte{0x22, 0x71, 0x55, 0x59, 0xad, 0x15, 0x71, 0x77, 0x22, 0xb1, 0xfa, 0x5, 0x83, 0x99, 0x60, 0x90, 0xc7, 0x9c, 0x3d, 0xf1, 0x6c, 0xc1, 0xe6, 0xe0, 0xf6, 0xd3, 0xe8, 0x98},
+               output256: []byte{0x21, 0x6f, 0xc3, 0x25, 0xf9, 0x42, 0xee, 0xd0, 0x84, 0x1, 0x52, 0x7a, 0x8f, 0x41, 0xc0, 0x88, 0x52, 0x7c, 0x64, 0x79, 0x34, 0x26, 0x22, 0xc9, 0x7, 0xea, 0x8, 0xff, 0x32, 0x90, 0xf8, 0xc6},
+               output384: []byte{0xfe, 0x99, 0xf1, 0x9c, 0x79, 0xa8, 0x90, 0x80, 0xe2, 0xff, 0x90, 0x98, 0x1d, 0xde, 0x91, 0x99, 0x45, 0x42, 0xd4, 0xbc, 0xc1, 0x27, 0x6a, 0x82, 0xd1, 0xa2, 0xe5, 0x38, 0x50, 0x34, 0x1b, 0x9a, 0xd5, 0x42, 0x2c, 0xea, 0xb8, 0x1e, 0x69, 0xda, 0xe5, 0xe9, 0x1d, 0xc5, 0xff, 0x60, 0xe1, 0xa3},
+               output512: []byte{0xd6, 0x54, 0x2a, 0x2f, 0x6, 0x54, 0xb9, 0xb8, 0x74, 0xa6, 0x27, 0xd3, 0xd5, 0x37, 0x64, 0xa6, 0x5b, 0x1d, 0xf2, 0xc0, 0xce, 0xc3, 0xbc, 0xd0, 0xb4, 0xb0, 0x88, 0xfa, 0xa1, 0x9, 0x5e, 0x54, 0xf1, 0x79, 0x97, 0x57, 0xc4, 0x37, 0x1f, 0x8d, 0x54, 0x4e, 0x29, 0x8d, 0x60, 0xe, 0x21, 0xe1, 0x1b, 0x2f, 0x90, 0xd2, 0x95, 0x71, 0x26, 0x21, 0x23, 0x1a, 0x9, 0xc5, 0x8b, 0x5, 0xa7, 0x4}},
+       testcase{
+               msg:       []byte{0x83, 0x16, 0x7f, 0xf5, 0x37, 0x4, 0xc3, 0xaa, 0x19, 0xe9, 0xfb, 0x33, 0x3, 0x53, 0x97, 0x59, 0xc4, 0x6d, 0xd4, 0x9, 0x1a, 0x52, 0xdd, 0xae, 0x9a, 0xd8, 0x64, 0x8, 0xb6, 0x93, 0x35, 0x98, 0x9e, 0x61, 0x41, 0x4b, 0xc2, 0xa, 0xb4, 0xd0, 0x12, 0x20, 0xe3, 0x52, 0x41, 0xef, 0xf5, 0xc9, 0x52, 0x2b, 0x7, 0x9f, 0xba, 0x59, 0x76, 0x74, 0xc8, 0xd7, 0x16, 0xfe, 0x44, 0x1e, 0x56, 0x61, 0x10, 0xb6, 0x21, 0x15, 0x31, 0xce, 0xcc, 0xf8, 0xfd, 0x6, 0xbc, 0x8e, 0x51, 0x1d, 0x0, 0x78, 0x5e, 0x57, 0x78, 0x8e, 0xd9, 0xa1, 0xc5, 0xc7, 0x35, 0x24, 0xf0, 0x18, 0x30, 0xd2, 0xe1, 0x14, 0x8c, 0x92, 0xd0, 0xed, 0xc9, 0x71, 0x13, 0xe3, 0xb7, 0xb5, 0xcd, 0x30, 0x49, 0x62, 0x7a, 0xbd, 0xb8, 0xb3, 0x9d, 0xd4, 0xd6, 0x89, 0xe, 0xe, 0xe9, 0x19, 0x93, 0xf9, 0x2b, 0x3, 0x35, 0x4a, 0x88, 0xf5, 0x22, 0x51, 0xc5, 0x46, 0xe6, 0x44, 0x34, 0xd9, 0xc3, 0xd7, 0x45, 0x44, 0xf2, 0x3f, 0xb9, 0x3e, 0x5a, 0x2d, 0x2f, 0x1f, 0xb1, 0x55, 0x45, 0xb4, 0xe1, 0x36, 0x7c, 0x97, 0x33, 0x5b, 0x2, 0x91, 0x94, 0x4c, 0x8b, 0x73, 0xa, 0xd3, 0xd4, 0x78, 0x92, 0x73, 0xfa, 0x44, 0xfb, 0x98, 0xd7, 0x8a, 0x36, 0xc3, 0xc3, 0x76, 0x4a, 0xbe, 0xea, 0xc7, 0xc5, 0x69, 0xc1, 0xe4, 0x3a, 0x35, 0x2e, 0x5b, 0x77, 0xc, 0x35, 0x4, 0xf8, 0x70, 0x90, 0xde, 0xe0, 0x75, 0xa1, 0xc4, 0xc8, 0x5c, 0xc, 0x39, 0xcf, 0x42, 0x1b, 0xdc, 0xc6, 0x15, 0xf9, 0xef, 0xf6, 0xcb, 0x4f, 0xe6, 0x46, 0x80, 0x4, 0xae, 0xce, 0x5f, 0x30, 0xe1, 0xec, 0xc6, 0xdb, 0x22, 0xad, 0x99, 0x39, 0xbb, 0x2b, 0xc, 0xcc, 0x96, 0x52, 0x1d, 0xfb, 0xf4, 0xae, 0x0, 0x8b, 0x5b, 0x46, 0xbc, 0x0, 0x6e},
+               output224: []byte{0x2f, 0x36, 0xff, 0x8a, 0xb7, 0x26, 0x4f, 0x7a, 0x57, 0x66, 0xde, 0x2, 0x50, 0x18, 0xe1, 0x9b, 0x5a, 0x64, 0xd9, 0x9, 0x94, 0xb7, 0x43, 0xb8, 0xfb, 0xfb, 0xdc, 0xca},
+               output256: []byte{0x43, 0x18, 0x4b, 0x9f, 0x2d, 0xb5, 0xb6, 0xda, 0x51, 0x60, 0xbc, 0x25, 0x5d, 0xbe, 0x19, 0xa0, 0xc9, 0x45, 0x33, 0xb8, 0x84, 0x80, 0x98, 0x15, 0xb7, 0xb3, 0x26, 0xd8, 0x68, 0x58, 0x9e, 0xdc},
+               output384: []byte{0x92, 0xe1, 0xd9, 0x94, 0xfe, 0xa2, 0xfd, 0x50, 0xa, 0x4b, 0x7f, 0x51, 0x39, 0x11, 0x90, 0x58, 0xa5, 0xb7, 0xe, 0xf6, 0x17, 0x4e, 0x55, 0x3f, 0x12, 0xfe, 0x7b, 0xcf, 0xca, 0x24, 0xb0, 0xa, 0x28, 0x39, 0x1e, 0x37, 0x61, 0xbd, 0xcb, 0xa3, 0xfd, 0x6b, 0x3, 0x3c, 0x12, 0x86, 0xe2, 0x8e},
+               output512: []byte{0xec, 0x98, 0x3e, 0x78, 0x76, 0x28, 0xb9, 0x4c, 0x87, 0xff, 0xf8, 0xd5, 0x7d, 0x2d, 0x5, 0x86, 0x67, 0xd1, 0x2f, 0x5a, 0xf4, 0x58, 0xbc, 0xe7, 0x9b, 0xb7, 0x84, 0x4f, 0xb4, 0x1d, 0x9c, 0x55, 0x92, 0xf, 0x59, 0x3c, 0x8d, 0x87, 0x30, 0xeb, 0x8d, 0x54, 0xff, 0x1d, 0x51, 0xcd, 0x8a, 0xd2, 0xf1, 0xc2, 0xa0, 0xf7, 0xd6, 0xb2, 0x99, 0xa2, 0x12, 0x66, 0x74, 0x4e, 0x47, 0xd1, 0x42, 0xb2}},
+       testcase{
+               msg:       []byte{0x3a, 0x3a, 0x81, 0x9c, 0x48, 0xef, 0xde, 0x2a, 0xd9, 0x14, 0xfb, 0xf0, 0xe, 0x18, 0xab, 0x6b, 0xc4, 0xf1, 0x45, 0x13, 0xab, 0x27, 0xd0, 0xc1, 0x78, 0xa1, 0x88, 0xb6, 0x14, 0x31, 0xe7, 0xf5, 0x62, 0x3c, 0xb6, 0x6b, 0x23, 0x34, 0x67, 0x75, 0xd3, 0x86, 0xb5, 0xe, 0x98, 0x2c, 0x49, 0x3a, 0xdb, 0xbf, 0xc5, 0x4b, 0x9a, 0x3c, 0xd3, 0x83, 0x38, 0x23, 0x36, 0xa1, 0xa0, 0xb2, 0x15, 0xa, 0x15, 0x35, 0x8f, 0x33, 0x6d, 0x3, 0xae, 0x18, 0xf6, 0x66, 0xc7, 0x57, 0x3d, 0x55, 0xc4, 0xfd, 0x18, 0x1c, 0x29, 0xe6, 0xcc, 0xfd, 0xe6, 0x3e, 0xa3, 0x5f, 0xa, 0xdf, 0x58, 0x85, 0xcf, 0xc0, 0xa3, 0xd8, 0x4a, 0x2b, 0x2e, 0x4d, 0xd2, 0x44, 0x96, 0xdb, 0x78, 0x9e, 0x66, 0x31, 0x70, 0xce, 0xf7, 0x47, 0x98, 0xaa, 0x1b, 0xbc, 0xd4, 0x57, 0x4e, 0xa0, 0xbb, 0xa4, 0x4, 0x89, 0xd7, 0x64, 0xb2, 0xf8, 0x3a, 0xad, 0xc6, 0x6b, 0x14, 0x8b, 0x4a, 0xc, 0xd9, 0x52, 0x46, 0xc1, 0x27, 0xd5, 0x87, 0x1c, 0x4f, 0x11, 0x41, 0x86, 0x90, 0xa5, 0xdd, 0xf0, 0x12, 0x46, 0xa0, 0xc8, 0xa, 0x43, 0xc7, 0x0, 0x88, 0xb6, 0x18, 0x36, 0x39, 0xdc, 0xfd, 0xa4, 0x12, 0x5b, 0xd1, 0x13, 0xa8, 0xf4, 0x9e, 0xe2, 0x3e, 0xd3, 0x6, 0xfa, 0xac, 0x57, 0x6c, 0x3f, 0xb0, 0xc1, 0xe2, 0x56, 0x67, 0x1d, 0x81, 0x7f, 0xc2, 0x53, 0x4a, 0x52, 0xf5, 0xb4, 0x39, 0xf7, 0x2e, 0x42, 0x4d, 0xe3, 0x76, 0xf4, 0xc5, 0x65, 0xcc, 0xa8, 0x23, 0x7, 0xdd, 0x9e, 0xf7, 0x6d, 0xa5, 0xb7, 0xc4, 0xeb, 0x7e, 0x8, 0x51, 0x72, 0xe3, 0x28, 0x80, 0x7c, 0x2, 0xd0, 0x11, 0xff, 0xbf, 0x33, 0x78, 0x53, 0x78, 0xd7, 0x9d, 0xc2, 0x66, 0xf6, 0xa5, 0xbe, 0x6b, 0xb0, 0xe4, 0xa9, 0x2e, 0xce, 0xeb, 0xae, 0xb1},
+               output224: []byte{0x5a, 0xf5, 0x69, 0x87, 0xea, 0x9c, 0xf1, 0x1f, 0xcd, 0xe, 0xac, 0x5e, 0xbc, 0x14, 0xb0, 0x37, 0x36, 0x5e, 0x9b, 0x11, 0x23, 0xe3, 0x1c, 0xb2, 0xdf, 0xc7, 0x92, 0x9a},
+               output256: []byte{0x34, 0x8f, 0xb7, 0x74, 0xad, 0xc9, 0x70, 0xa1, 0x6b, 0x11, 0x5, 0x66, 0x94, 0x42, 0x62, 0x5e, 0x6a, 0xda, 0xa8, 0x25, 0x7a, 0x89, 0xef, 0xfd, 0xb5, 0xa8, 0x2, 0xf1, 0x61, 0xb8, 0x62, 0xea},
+               output384: []byte{0x6b, 0xff, 0x1c, 0x84, 0x5, 0xa3, 0xfe, 0x59, 0x4e, 0x36, 0xe, 0x3b, 0xcc, 0xea, 0x1e, 0xbc, 0xd5, 0x9, 0x31, 0xd, 0xc7, 0x9b, 0x9e, 0x45, 0xc2, 0x63, 0x78, 0x3d, 0x7a, 0x5d, 0xd6, 0x62, 0xc6, 0x78, 0x9b, 0x18, 0xbd, 0x56, 0x7d, 0xbd, 0xda, 0x15, 0x54, 0xf5, 0xbe, 0xe6, 0xa8, 0x60},
+               output512: []byte{0x81, 0x95, 0xe, 0x70, 0x96, 0xd3, 0x1d, 0x4f, 0x22, 0xe3, 0xdb, 0x71, 0xca, 0xc7, 0x25, 0xbf, 0x59, 0xe8, 0x1a, 0xf5, 0x4c, 0x7c, 0xa9, 0xe6, 0xae, 0xee, 0x71, 0xc0, 0x10, 0xfc, 0x54, 0x67, 0x46, 0x63, 0x12, 0xa0, 0x1a, 0xa5, 0xc1, 0x37, 0xcf, 0xb1, 0x40, 0x64, 0x69, 0x41, 0x55, 0x67, 0x96, 0xf6, 0x12, 0xc9, 0x35, 0x12, 0x68, 0x73, 0x7c, 0x7e, 0x9a, 0x2b, 0x96, 0x31, 0xd1, 0xfa}},
+}
+
+// extracted from LongMsgKAT_{224,256,384,512}.txt
+var tstLong = []testcase{
+       testcase{
+               msg:       []byte{0x72, 0x46, 0x27, 0x91, 0x6c, 0x50, 0x33, 0x86, 0x43, 0xe6, 0x99, 0x6f, 0x7, 0x87, 0x7e, 0xaf, 0xd9, 0x6b, 0xdf, 0x1, 0xda, 0x7e, 0x99, 0x1d, 0x41, 0x55, 0xb9, 0xbe, 0x12, 0x95, 0xea, 0x7d, 0x21, 0xc9, 0x39, 0x1f, 0x4c, 0x4a, 0x41, 0xc7, 0x5f, 0x77, 0xe5, 0xd2, 0x73, 0x89, 0x25, 0x33, 0x93, 0x72, 0x5f, 0x14, 0x27, 0xf5, 0x79, 0x14, 0xb2, 0x73, 0xab, 0x86, 0x2b, 0x9e, 0x31, 0xda, 0xbc, 0xe5, 0x6, 0xe5, 0x58, 0x72, 0x5, 0x20, 0xd3, 0x33, 0x52, 0xd1, 0x19, 0xf6, 0x99, 0xe7, 0x84, 0xf9, 0xe5, 0x48, 0xff, 0x91, 0xbc, 0x35, 0xca, 0x14, 0x70, 0x42, 0x12, 0x87, 0x9, 0x82, 0xd, 0x69, 0xa8, 0x28, 0x7e, 0xa3, 0x25, 0x78, 0x57, 0x61, 0x5e, 0xb0, 0x32, 0x12, 0x70, 0xe9, 0x4b, 0x84, 0xf4, 0x46, 0x94, 0x27, 0x65, 0xce, 0x88, 0x2b, 0x19, 0x1f, 0xae, 0xe7, 0xe1, 0xc8, 0x7e, 0xf, 0xb, 0xd4, 0xe0, 0xcd, 0x8a, 0x92, 0x77, 0x3, 0x52, 0x4b, 0x55, 0x9b, 0x76, 0x9c, 0xa4, 0xec, 0xe1, 0xf6, 0xdb, 0xf3, 0x13, 0xfd, 0xcf, 0x67, 0xc5, 0x72, 0xec, 0x41, 0x85, 0xc1, 0xa8, 0x8e, 0x86, 0xec, 0x11, 0xb6, 0x45, 0x4b, 0x37, 0x19, 0x80, 0x2, 0xf, 0x19, 0x63, 0x3b, 0x6b, 0x95, 0xbd, 0x28, 0xe, 0x4f, 0xbc, 0xb0, 0x16, 0x1e, 0x1a, 0x82, 0x47, 0x3, 0x20, 0xce, 0xc6, 0xec, 0xfa, 0x25, 0xac, 0x73, 0xd0, 0x9f, 0x15, 0x36, 0xf2, 0x86, 0xd3, 0xf9, 0xda, 0xca, 0xfb, 0x2c, 0xd1, 0xd0, 0xce, 0x72, 0xd6, 0x4d, 0x19, 0x7f, 0x5c, 0x75, 0x20, 0xb3, 0xcc, 0xb2, 0xfd, 0x74, 0xeb, 0x72, 0x66, 0x4b, 0xa9, 0x38, 0x53, 0xef, 0x41, 0xea, 0xbf, 0x52, 0xf0, 0x15, 0xdd, 0x59, 0x15, 0x0, 0xd0, 0x18, 0xdd, 0x16, 0x28, 0x15, 0xcc, 0x99, 0x35, 0x95, 0xb1, 0x95},
+               output224: []byte{0xe9, 0xf, 0x81, 0xae, 0x86, 0xd7, 0x2d, 0xcc, 0x21, 0x90, 0xaf, 0x54, 0x5a, 0x34, 0x51, 0x50, 0xa6, 0x29, 0xee, 0x7d, 0xc7, 0x23, 0x7c, 0x19, 0x58, 0xcf, 0xcd, 0xbc},
+               output256: []byte{0xea, 0xe, 0x41, 0x6c, 0xf, 0x7b, 0x4f, 0x11, 0xe3, 0xf0, 0x4, 0x79, 0xfd, 0xdf, 0x95, 0x4f, 0x25, 0x39, 0xe5, 0xe5, 0x57, 0x75, 0x3b, 0xd5, 0x46, 0xf6, 0x9e, 0xe3, 0x75, 0xa5, 0xde, 0x29},
+               output384: []byte{0x86, 0xb7, 0xcc, 0x35, 0x44, 0xe5, 0xf9, 0x1f, 0x12, 0xa9, 0x10, 0xa5, 0x6a, 0xdd, 0xd6, 0xb5, 0xe7, 0xdc, 0x7d, 0xf5, 0x1f, 0xae, 0xcc, 0x2f, 0xc5, 0x15, 0xee, 0x66, 0x9b, 0x59, 0x12, 0xdd, 0x11, 0x6a, 0xa1, 0x30, 0x52, 0x56, 0x9e, 0xab, 0x59, 0x7c, 0xec, 0xa9, 0x22, 0xb1, 0xed, 0x32},
+               output512: []byte{0x4e, 0x98, 0x77, 0x68, 0x46, 0x9f, 0x54, 0x62, 0x96, 0xad, 0x1a, 0x43, 0xd5, 0x4c, 0xa, 0xa, 0x6c, 0x87, 0xe7, 0xe4, 0xe2, 0x6b, 0x68, 0x66, 0x12, 0xb1, 0xe5, 0xb1, 0x55, 0x4b, 0x68, 0x9b, 0xff, 0xd5, 0x6d, 0x6a, 0x4b, 0x45, 0x4c, 0xe4, 0xa5, 0x71, 0x76, 0x25, 0xbb, 0xad, 0x32, 0x1f, 0x8d, 0x5, 0xf1, 0x9c, 0x22, 0x52, 0x59, 0x64, 0x6f, 0x21, 0x41, 0x6a, 0xa2, 0xd7, 0xc2, 0xed}},
+       testcase{
+               msg:       []byte{0x31, 0x39, 0x84, 0xb, 0x8a, 0xd4, 0xbc, 0xd3, 0x90, 0x92, 0x91, 0x6f, 0xd9, 0xd0, 0x17, 0x98, 0xff, 0x5a, 0xa1, 0xe4, 0x8f, 0x34, 0x70, 0x2c, 0x72, 0xdf, 0xe7, 0x4b, 0x12, 0xe9, 0x8a, 0x11, 0x4e, 0x31, 0x8c, 0xdd, 0x2d, 0x47, 0xa9, 0xc3, 0x20, 0xff, 0xf9, 0x8, 0xa8, 0xdb, 0xc2, 0xa5, 0xb1, 0xd8, 0x72, 0x67, 0xc8, 0xe9, 0x83, 0x82, 0x98, 0x61, 0xa5, 0x67, 0x55, 0x8b, 0x37, 0xb2, 0x92, 0xd4, 0x57, 0x5e, 0x20, 0xd, 0xe9, 0xf1, 0xde, 0x45, 0x75, 0x5f, 0xaf, 0xf9, 0xef, 0xae, 0x34, 0x96, 0x4e, 0x43, 0x36, 0xc2, 0x59, 0xf1, 0xe6, 0x65, 0x99, 0xa7, 0xc9, 0x4, 0xec, 0x2, 0x53, 0x9f, 0x1a, 0x8e, 0xab, 0x87, 0x6, 0xe0, 0xb4, 0xf4, 0x8f, 0x72, 0xfe, 0xc2, 0x79, 0x49, 0x9, 0xee, 0x4a, 0x7b, 0x9, 0x2d, 0x60, 0x61, 0xc7, 0x44, 0x81, 0xc9, 0xe2, 0x1b, 0x93, 0x32, 0xdc, 0x7c, 0x6e, 0x48, 0x2d, 0x7f, 0x9c, 0xc3, 0x21, 0xb, 0x38, 0xa6, 0xf8, 0x8f, 0x79, 0x18, 0xc2, 0xd8, 0xc5, 0x5e, 0x64, 0xa4, 0x28, 0xce, 0x2b, 0x68, 0xfd, 0x7, 0xab, 0x57, 0x2a, 0x8b, 0xa, 0x23, 0x88, 0x66, 0x4f, 0x99, 0x48, 0x9f, 0x4, 0xeb, 0x54, 0xdf, 0x13, 0x76, 0x27, 0x18, 0x10, 0xe0, 0xe7, 0xbc, 0xe3, 0x96, 0xf5, 0x28, 0x7, 0x71, 0xe, 0xd, 0xea, 0x94, 0xeb, 0x49, 0xf4, 0xb3, 0x67, 0x27, 0x12, 0x60, 0xc3, 0x45, 0x6b, 0x98, 0x18, 0xfc, 0x7a, 0x72, 0x23, 0x4e, 0x6b, 0xf2, 0x20, 0x5f, 0xf6, 0xa3, 0x65, 0x46, 0x20, 0x50, 0x15, 0xeb, 0xd7, 0xd8, 0xc2, 0x52, 0x7a, 0xa4, 0x30, 0xf5, 0x8e, 0xe, 0x8a, 0xc9, 0x7a, 0x7b, 0x6b, 0x79, 0x3c, 0xd4, 0x3, 0xd5, 0x17, 0xd6, 0x62, 0x95, 0xf3, 0x7a, 0x34, 0xd0, 0xb7, 0xd2, 0xfa, 0x7b, 0xc3, 0x45, 0xac, 0x4, 0xca, 0x1e, 0x26, 0x64, 0x80, 0xde, 0xec, 0x39, 0xf5, 0xc8, 0x86, 0x41, 0xc9, 0xdc, 0xb, 0xd1, 0x35, 0x81, 0x58, 0xfd, 0xec, 0xdd, 0x96, 0x68, 0x5b, 0xbb, 0xb5, 0xc1, 0xfe, 0x5e, 0xa8, 0x9d, 0x2c, 0xb4, 0xa9, 0xd5, 0xd1, 0x2b, 0xb8, 0xc8, 0x93, 0x28, 0x1f, 0xf3, 0x8e, 0x87, 0xd6, 0xb4, 0x84, 0x1f, 0x6, 0x50, 0x9, 0x2d, 0x44, 0x7e, 0x1, 0x3f, 0x20, 0xea, 0x93, 0x4e, 0x18},
+               output224: []byte{0xc1, 0xc8, 0xb, 0x60, 0xec, 0xbe, 0x67, 0xb7, 0xa4, 0x99, 0x40, 0xdf, 0x5e, 0x3e, 0xe7, 0xf3, 0x1c, 0x13, 0x4, 0x84, 0x4d, 0x9a, 0x33, 0x3a, 0x17, 0x29, 0x83, 0xff},
+               output256: []byte{0x59, 0xe9, 0x4, 0xb2, 0xaa, 0xc, 0xcb, 0xf2, 0xa9, 0xd1, 0x27, 0x44, 0x6f, 0x11, 0x3b, 0x7c, 0xc3, 0xd0, 0x7b, 0x97, 0xe, 0x7, 0xa3, 0x22, 0x32, 0x5e, 0xce, 0xe6, 0x6a, 0xe0, 0xc9, 0xca},
+               output384: []byte{0xe0, 0x10, 0xd, 0x6a, 0x2, 0x56, 0x8b, 0x24, 0x4d, 0xf7, 0xea, 0x67, 0xf2, 0x80, 0xae, 0x5d, 0x95, 0x6b, 0xe6, 0x38, 0x36, 0xb0, 0x2b, 0xbf, 0xe8, 0x87, 0x5d, 0x6d, 0xbe, 0xd1, 0x64, 0x65, 0x58, 0x2e, 0x5b, 0x4d, 0xa7, 0xa6, 0x76, 0x2, 0x50, 0x8c, 0x67, 0x9f, 0xa, 0x50, 0xea, 0x2d},
+               output512: []byte{0x3d, 0x37, 0xd, 0xc8, 0x50, 0xbc, 0x7e, 0x15, 0x9c, 0xee, 0x3f, 0x24, 0xd9, 0xe9, 0x15, 0xb5, 0xb1, 0x30, 0x6f, 0xf4, 0x3, 0xc3, 0x2c, 0x7a, 0x3a, 0x38, 0x44, 0xf3, 0xfc, 0x8d, 0x90, 0xe3, 0x5f, 0x56, 0xd8, 0x3b, 0xdd, 0x9c, 0x63, 0x7b, 0xc4, 0x5e, 0x44, 0xe, 0x1f, 0x27, 0xcc, 0xd5, 0x6b, 0x6b, 0x38, 0x72, 0xec, 0x19, 0x10, 0x1b, 0xbe, 0x31, 0x84, 0x51, 0x8, 0xdc, 0xe9, 0x29}},
+       testcase{
+               msg:       []byte{0x2, 0x3d, 0x91, 0xac, 0x53, 0x26, 0x1, 0xc7, 0xca, 0x39, 0x42, 0xd6, 0x28, 0x27, 0x56, 0x6d, 0x92, 0x68, 0xbb, 0x42, 0x76, 0xfc, 0xaa, 0x1a, 0xe9, 0x27, 0x69, 0x3a, 0x69, 0x61, 0x65, 0x26, 0x76, 0xdb, 0xa0, 0x92, 0x19, 0xa0, 0x1b, 0x3d, 0x5a, 0xdf, 0xa1, 0x25, 0x47, 0xa9, 0x46, 0xe7, 0x8f, 0x3c, 0x5c, 0x62, 0xdd, 0x88, 0xb, 0x2, 0xd2, 0xee, 0xeb, 0x4b, 0x96, 0x63, 0x65, 0x29, 0xc6, 0xb0, 0x11, 0x20, 0xb2, 0x3e, 0xfc, 0x49, 0xcc, 0xfb, 0x36, 0xb8, 0x49, 0x7c, 0xd1, 0x97, 0x67, 0xb5, 0x37, 0x10, 0xa6, 0x36, 0x68, 0x3b, 0xc5, 0xe0, 0xe5, 0xc9, 0x53, 0x4c, 0xfc, 0x0, 0x46, 0x91, 0xe8, 0x7d, 0x1b, 0xee, 0x39, 0xb8, 0x6b, 0x95, 0x35, 0x72, 0x92, 0x7b, 0xd6, 0x68, 0x62, 0xe, 0xab, 0x87, 0x83, 0x6d, 0x9f, 0x3f, 0x8f, 0x28, 0xac, 0xe4, 0x11, 0x50, 0x77, 0x6c, 0xb, 0xc6, 0x65, 0x71, 0x78, 0xeb, 0xf2, 0x97, 0xfe, 0x1f, 0x72, 0x14, 0xed, 0xd9, 0xf2, 0x15, 0xff, 0xb4, 0x91, 0xb6, 0x81, 0xb0, 0x6a, 0xc2, 0x3, 0x2d, 0x35, 0xe6, 0xfd, 0xf8, 0x32, 0xa8, 0xb0, 0x60, 0x56, 0xda, 0x70, 0xd7, 0x7f, 0x1e, 0x9b, 0x4d, 0x26, 0xae, 0x71, 0x2d, 0x85, 0x23, 0xc8, 0x6f, 0x79, 0x25, 0x7, 0x18, 0x40, 0x5f, 0x91, 0xb0, 0xa8, 0x7c, 0x72, 0x5f, 0x2d, 0x3f, 0x52, 0x8, 0x89, 0x65, 0xf8, 0x87, 0xd8, 0xcf, 0x87, 0x20, 0x6d, 0xfd, 0xe4, 0x22, 0x38, 0x6e, 0x58, 0xed, 0xda, 0x34, 0xdd, 0xe2, 0x78, 0x3b, 0x30, 0x49, 0xb8, 0x69, 0x17, 0xb4, 0x62, 0x80, 0x27, 0xa0, 0x5d, 0x4d, 0x1f, 0x42, 0x9d, 0x2b, 0x49, 0xc4, 0xb1, 0xc8, 0x98, 0xdd, 0xdc, 0xb8, 0x2f, 0x34, 0x3e, 0x14, 0x55, 0x96, 0xde, 0x11, 0xa5, 0x41, 0x82, 0xf3, 0x9f, 0x47, 0x18, 0xec, 0xae, 0x8f, 0x50, 0x6b, 0xd9, 0x73, 0x9f, 0x5c, 0xd5, 0xd5, 0x68, 0x6d, 0x7f, 0xef, 0xc8, 0x34, 0x51, 0x4c, 0xd1, 0xb2, 0xc9, 0x1c, 0x33, 0xb3, 0x81, 0xb4, 0x5e, 0x2e, 0x53, 0x35, 0xd7, 0xa8, 0x72, 0xa, 0x8f, 0x17, 0xaf, 0xc8, 0xc2, 0xcb, 0x2b, 0xd8, 0x8b, 0x14, 0xaa, 0x2d, 0xca, 0x9, 0x9b, 0x0, 0xaa, 0x57, 0x5d, 0xa, 0xc, 0xcf, 0x9, 0x9c, 0xde, 0xc4, 0x87, 0xf, 0xb7, 0x10, 0xd2, 0x68, 0xe, 0x60, 0xc4, 0x8b, 0xfc, 0x29, 0x1f, 0xf0, 0xce, 0xf2, 0xee, 0xbf, 0x9b, 0x36, 0x90, 0x2e, 0x9f, 0xba, 0x8c, 0x88, 0x9b, 0xf6, 0xb4, 0xb9, 0xf5, 0xce, 0x53, 0xa1, 0x9b, 0xd, 0x93, 0x99, 0xcd, 0x19, 0xd6, 0x1b, 0xd0, 0x8c, 0xc, 0x2e, 0xc2, 0x5e, 0x9, 0x99, 0x59, 0x84, 0x8e, 0x6a, 0x55, 0xc, 0xa7, 0x13, 0x7b, 0x63, 0xf4, 0x31, 0x38, 0xd7, 0xb6, 0x51},
+               output224: []byte{0x23, 0x6, 0x20, 0xd7, 0x10, 0xcf, 0x3a, 0xb8, 0x35, 0x5, 0x9e, 0x1a, 0xa1, 0x70, 0x73, 0x5d, 0xb1, 0x7c, 0xae, 0x74, 0xb3, 0x45, 0x76, 0x5f, 0xf0, 0x2e, 0x8d, 0x89},
+               output256: []byte{0x6c, 0x2a, 0x84, 0x13, 0x18, 0x6, 0x6b, 0x90, 0xa9, 0x60, 0x4d, 0xc, 0x8e, 0xcc, 0xb2, 0x98, 0x6b, 0x84, 0xa0, 0xc8, 0x67, 0x5c, 0xd2, 0x43, 0xe9, 0x69, 0x57, 0xd2, 0x6e, 0x9c, 0x1c, 0xfd},
+               output384: []byte{0xae, 0x55, 0x9c, 0x73, 0x2e, 0x55, 0xc5, 0x21, 0xb7, 0x73, 0x1e, 0x9c, 0x80, 0x65, 0x93, 0x1b, 0x93, 0xab, 0x5e, 0xf1, 0x67, 0x28, 0xe3, 0xf3, 0xc7, 0x38, 0xe7, 0xd5, 0x7, 0xb1, 0x84, 0x89, 0x38, 0x8c, 0xc3, 0xca, 0x7b, 0xa0, 0x1a, 0xf6, 0x72, 0xc2, 0x2c, 0xb7, 0x67, 0xc2, 0x95, 0xd2},
+               output512: []byte{0x21, 0x8a, 0x55, 0x79, 0x65, 0x29, 0x14, 0x9f, 0x29, 0xcc, 0x4a, 0x19, 0xc8, 0xe, 0x5, 0xc2, 0x6f, 0x4, 0x8a, 0xbc, 0x98, 0x94, 0xad, 0x79, 0xf1, 0x1b, 0xac, 0x7c, 0x28, 0xde, 0x53, 0xbd, 0xc9, 0xbd, 0xb8, 0xbe, 0x49, 0x84, 0xf9, 0x24, 0x64, 0x8, 0x67, 0xfc, 0xfc, 0xe4, 0x23, 0x10, 0xad, 0xfa, 0x94, 0x9e, 0x2b, 0x25, 0x68, 0xff, 0xa0, 0x79, 0x5f, 0xbb, 0x32, 0x3, 0xde, 0x65}},
+       testcase{
+               msg:       []byte{0x20, 0xff, 0x45, 0x43, 0x69, 0xa5, 0xd0, 0x5b, 0x81, 0xa7, 0x8f, 0x3d, 0xb0, 0x58, 0x19, 0xfe, 0xa9, 0xb0, 0x8c, 0x23, 0x84, 0xf7, 0x5c, 0xb0, 0xab, 0x6a, 0xa1, 0x15, 0xdd, 0x69, 0xd, 0xa3, 0x13, 0x18, 0x74, 0xa1, 0xca, 0x8f, 0x70, 0x8a, 0xd1, 0x51, 0x9e, 0xa9, 0x52, 0xc1, 0xe2, 0x49, 0xcb, 0x54, 0xd, 0x19, 0x63, 0x92, 0xc7, 0x9e, 0x87, 0x75, 0x54, 0x24, 0xfe, 0xe7, 0xc8, 0x90, 0x80, 0x8c, 0x56, 0x27, 0x22, 0x35, 0x9e, 0xea, 0x52, 0xe8, 0xa1, 0x2f, 0xbb, 0xb9, 0x69, 0xdd, 0x79, 0x61, 0xd2, 0xba, 0x52, 0x3, 0x74, 0x93, 0x75, 0x5a, 0x5f, 0xa0, 0x4f, 0xd, 0x50, 0xa1, 0xaa, 0x26, 0xc9, 0xb4, 0x41, 0x48, 0xc0, 0xd3, 0xb9, 0x4d, 0x1c, 0x4a, 0x59, 0xa3, 0x1a, 0xca, 0x15, 0xae, 0x8b, 0xd4, 0x4a, 0xcb, 0x78, 0x33, 0xd8, 0xe9, 0x1c, 0x4b, 0x86, 0xfa, 0x31, 0x35, 0xa4, 0x23, 0x38, 0x7b, 0x81, 0x51, 0xb4, 0x13, 0x3e, 0xd2, 0x3f, 0x6d, 0x71, 0x87, 0xb5, 0xe, 0xc2, 0x20, 0x4a, 0xd9, 0x1, 0xad, 0x74, 0xd3, 0x96, 0xe4, 0x42, 0x74, 0xe0, 0xec, 0xaf, 0xaa, 0xe1, 0x7b, 0x3b, 0x90, 0x85, 0xe2, 0x22, 0x60, 0xb3, 0x5c, 0xa5, 0x3b, 0x15, 0xcc, 0x52, 0xab, 0xba, 0x75, 0x8a, 0xf6, 0x79, 0x8f, 0xbd, 0x4, 0xec, 0xee, 0xce, 0xd6, 0x48, 0xf3, 0xaf, 0x4f, 0xdb, 0x3d, 0xed, 0x75, 0x57, 0xa9, 0xa5, 0xcf, 0xb7, 0x38, 0x26, 0x12, 0xa8, 0xa8, 0xf3, 0xf4, 0x59, 0x47, 0xd1, 0xa2, 0x9c, 0xe2, 0x90, 0x72, 0x92, 0x8e, 0xc1, 0x93, 0xca, 0x25, 0xd5, 0x10, 0x71, 0xbd, 0x5e, 0x19, 0x84, 0xec, 0xf4, 0x2, 0xf3, 0x6, 0xea, 0x76, 0x2f, 0xf, 0x25, 0x28, 0x2f, 0x52, 0x96, 0xd9, 0x97, 0x65, 0x8b, 0xe3, 0xf9, 0x83, 0x69, 0x6f, 0xfa, 0x6d, 0x9, 0x5c, 0x63, 0x69, 0xb4, 0xda, 0xf7, 0x9e, 0x9a, 0x5d, 0x31, 0x36, 0x22, 0x91, 0x28, 0xf8, 0xeb, 0x63, 0xc1, 0x2b, 0x9e, 0x9f, 0xa7, 0x8a, 0xff, 0x7a, 0x3e, 0x9e, 0x19, 0xa6, 0x20, 0x22, 0x49, 0x3c, 0xd1, 0x36, 0xde, 0xfb, 0xb5, 0xbb, 0x7b, 0xa1, 0xb9, 0x38, 0xf3, 0x67, 0xfd, 0x2f, 0x63, 0xeb, 0x5c, 0xa7, 0x6c, 0xb, 0xf, 0xf2, 0x1b, 0x9e, 0x36, 0xc3, 0xf0, 0x72, 0x30, 0xcf, 0x3c, 0x30, 0x74, 0xe5, 0xda, 0x58, 0x70, 0x40, 0xa7, 0x69, 0x75, 0xd7, 0xe3, 0x9f, 0x44, 0x94, 0xac, 0xe5, 0x48, 0x6f, 0xcb, 0xf3, 0x80, 0xab, 0x75, 0x58, 0xc4, 0xfe, 0x89, 0x65, 0x63, 0x35, 0xb8, 0x2e, 0x4d, 0xb8, 0x65, 0x95, 0x9, 0xea, 0xb4, 0x6a, 0x19, 0x61, 0x31, 0x26, 0xe5, 0x94, 0x4, 0x27, 0x32, 0xdd, 0x4c, 0x41, 0x1f, 0x41, 0xaa, 0x8c, 0xde, 0xac, 0x71, 0xc0, 0xfb, 0x40, 0xa9, 0x4e, 0x6d, 0xa5, 0x58, 0xc0, 0x5e, 0x77, 0xb6, 0x18, 0x28, 0x6, 0xf2, 0x6d, 0x9a, 0xfd, 0xf3, 0xda, 0x0, 0xc6, 0x94, 0x19, 0x22, 0x2c, 0x81, 0x86, 0xa6, 0xef, 0xad, 0x60, 0xb, 0x41, 0xe, 0x6c, 0xe2, 0xf2, 0xa7, 0x97, 0xe4, 0x9d, 0xc1, 0xf1, 0x35, 0x31, 0x98, 0x1, 0xfa, 0x6f, 0x39, 0x6b, 0x6, 0xf9, 0x75, 0xe2, 0xa1, 0x90, 0xa0, 0x23, 0xe4, 0x74, 0xb6, 0x18, 0xe7},
+               output224: []byte{0x34, 0xa5, 0x8d, 0xdf, 0xc5, 0xc2, 0x22, 0x22, 0x81, 0xfa, 0x73, 0xeb, 0x34, 0xbf, 0xb5, 0xe1, 0x52, 0x27, 0x2c, 0xc3, 0xac, 0x7f, 0xe9, 0x7a, 0xc5, 0x8c, 0x8, 0xb0},
+               output256: []byte{0xe, 0xc8, 0xd9, 0xd2, 0xd, 0xdf, 0xa, 0x7b, 0x2, 0x51, 0xe9, 0x41, 0xa7, 0x26, 0x1b, 0x55, 0x75, 0x7, 0xff, 0x62, 0x87, 0xb5, 0x4, 0x36, 0x2a, 0x8f, 0x17, 0x34, 0xc5, 0xa9, 0x10, 0x12},
+               output384: []byte{0x59, 0x75, 0xfa, 0x4b, 0xce, 0xfc, 0x79, 0xfa, 0xdc, 0x79, 0xcc, 0xf1, 0x25, 0x4b, 0xba, 0x9e, 0xac, 0x25, 0x2e, 0x24, 0xc7, 0xde, 0xc7, 0xeb, 0x89, 0x72, 0xd2, 0x65, 0xef, 0xad, 0x3f, 0x6c, 0xf6, 0x48, 0xc4, 0x9d, 0xff, 0xf5, 0x45, 0x3a, 0xd2, 0x7d, 0x62, 0xff, 0x86, 0x7a, 0x2f, 0x3},
+               output512: []byte{0x11, 0x6a, 0xe9, 0x4c, 0x86, 0xf6, 0x8f, 0x96, 0xb8, 0xae, 0xf2, 0x98, 0xa9, 0xf5, 0x85, 0x2c, 0xc9, 0x91, 0x3a, 0x2a, 0xd3, 0xc3, 0xc3, 0x44, 0xf2, 0x8d, 0xcc, 0x9b, 0x29, 0x29, 0x2a, 0x71, 0x6f, 0xaf, 0x51, 0xdd, 0x4, 0xa9, 0x43, 0x3d, 0x8a, 0x12, 0x57, 0x2e, 0x1d, 0xbc, 0x58, 0x1a, 0x7c, 0xdc, 0x4e, 0x50, 0xbc, 0x1c, 0xa9, 0x5, 0x1d, 0xdb, 0xc1, 0x21, 0xf2, 0xe8, 0x64, 0xe2}},
+       testcase{
+               msg:       []byte{0x4f, 0xbd, 0xc5, 0x96, 0x50, 0x8d, 0x24, 0xa2, 0xa0, 0x1, 0xe, 0x14, 0x9, 0x80, 0xb8, 0x9, 0xfb, 0x9c, 0x6d, 0x55, 0xec, 0x75, 0x12, 0x58, 0x91, 0xdd, 0x98, 0x5d, 0x37, 0x66, 0x5b, 0xd8, 0xf, 0x9b, 0xeb, 0x6a, 0x50, 0x20, 0x75, 0x88, 0xab, 0xf3, 0xce, 0xee, 0x8c, 0x77, 0xcd, 0x8a, 0x5a, 0xd4, 0x8a, 0x9e, 0xa, 0xa0, 0x74, 0xed, 0x38, 0x87, 0x38, 0x36, 0x24, 0x96, 0xd2, 0xfb, 0x2c, 0x87, 0x54, 0x3b, 0xb3, 0x34, 0x9e, 0xa6, 0x49, 0x97, 0xce, 0x3e, 0x7b, 0x42, 0x4e, 0xa9, 0x2d, 0x12, 0x2f, 0x57, 0xdb, 0xb0, 0x85, 0x5a, 0x80, 0x30, 0x58, 0x43, 0x7f, 0xe0, 0x8a, 0xfb, 0xc, 0x8b, 0x5e, 0x71, 0x79, 0xb9, 0x4, 0x4b, 0xbf, 0x4d, 0x81, 0xa7, 0x16, 0x3b, 0x31, 0x39, 0xe3, 0x8, 0x88, 0xb5, 0x36, 0xb0, 0xf9, 0x57, 0xef, 0xf9, 0x9a, 0x71, 0x62, 0xf4, 0xca, 0x5a, 0xa7, 0x56, 0xa4, 0xa9, 0x82, 0xdf, 0xad, 0xbf, 0x31, 0xef, 0x25, 0x50, 0x83, 0xc4, 0xb5, 0xc6, 0xc1, 0xb9, 0x9a, 0x10, 0x7d, 0x7d, 0x3a, 0xff, 0xfd, 0xb8, 0x91, 0x47, 0xc2, 0xcc, 0x4c, 0x9a, 0x26, 0x43, 0xf4, 0x78, 0xe5, 0xe2, 0xd3, 0x93, 0xae, 0xa3, 0x7b, 0x4c, 0x7c, 0xb4, 0xb5, 0xe9, 0x7d, 0xad, 0xcf, 0x16, 0xb6, 0xb5, 0xa, 0xae, 0xf, 0x3b, 0x54, 0x9e, 0xce, 0x47, 0x74, 0x6d, 0xb6, 0xce, 0x6f, 0x67, 0xdd, 0x44, 0x6, 0xcd, 0x4e, 0x75, 0x59, 0x5d, 0x51, 0x3, 0xd1, 0x3f, 0x9d, 0xfa, 0x79, 0x37, 0x29, 0x24, 0xd3, 0x28, 0xf8, 0xdd, 0x1f, 0xcb, 0xeb, 0x5a, 0x8e, 0x2e, 0x8b, 0xf4, 0xc7, 0x6d, 0xe0, 0x8e, 0x3f, 0xc4, 0x6a, 0xa0, 0x21, 0xf9, 0x89, 0xc4, 0x93, 0x29, 0xc7, 0xac, 0xac, 0x5a, 0x68, 0x85, 0x56, 0xd7, 0xbc, 0xbc, 0xb2, 0xa5, 0xd4, 0xbe, 0x69, 0xd3, 0x28, 0x4e, 0x9c, 0x40, 0xec, 0x48, 0x38, 0xee, 0x85, 0x92, 0x12, 0xc, 0xe2, 0xa, 0xb, 0x63, 0x5e, 0xca, 0xda, 0xa8, 0x4f, 0xd5, 0x69, 0x5, 0x9, 0xf5, 0x4f, 0x77, 0xe3, 0x5a, 0x41, 0x7c, 0x58, 0x46, 0x48, 0xbc, 0x98, 0x39, 0xb9, 0x74, 0xe0, 0x7b, 0xfa, 0xb0, 0x3, 0x8e, 0x90, 0x29, 0x5d, 0xb, 0x13, 0x90, 0x25, 0x30, 0xa8, 0x30, 0xd1, 0xc2, 0xbd, 0xd5, 0x3f, 0x1f, 0x9c, 0x9f, 0xae, 0xd4, 0x3c, 0xa4, 0xee, 0xd0, 0xa8, 0xdd, 0x76, 0x1b, 0xc7, 0xed, 0xbd, 0xda, 0x28, 0xa2, 0x87, 0xc6, 0xc, 0xd4, 0x2a, 0xf5, 0xf9, 0xc7, 0x58, 0xe5, 0xc7, 0x25, 0x2, 0x31, 0xc0, 0x9a, 0x58, 0x25, 0x63, 0x68, 0x9a, 0xfc, 0x65, 0xe2, 0xb7, 0x9a, 0x7a, 0x2b, 0x68, 0x20, 0x6, 0x67, 0x75, 0x2e, 0x91, 0x1, 0x74, 0x6f, 0x3, 0x18, 0x4e, 0x23, 0x99, 0xe4, 0xed, 0x88, 0x35, 0xcb, 0x8e, 0x9a, 0xe9, 0xe, 0x29, 0x6a, 0xf2, 0x20, 0xae, 0x23, 0x42, 0x59, 0xfe, 0xb, 0xd0, 0xbc, 0xc6, 0xf, 0x7a, 0x4a, 0x5f, 0xf3, 0xf7, 0xc, 0x5e, 0xd4, 0xde, 0x9c, 0x8c, 0x51, 0x9a, 0x10, 0xe9, 0x62, 0xf6, 0x73, 0xc8, 0x2c, 0x5e, 0x93, 0x51, 0x78, 0x6a, 0x8a, 0x3b, 0xfd, 0x57, 0x0, 0x31, 0x85, 0x7b, 0xd4, 0xc8, 0x7f, 0x4f, 0xca, 0x31, 0xed, 0x4d, 0x50, 0xe1, 0x4f, 0x21, 0x7, 0xda, 0x2, 0xcb, 0x50, 0x58, 0x70, 0xb, 0x74, 0xea, 0x24, 0x1a, 0x8b, 0x41, 0xd7, 0x84, 0x61, 0x65, 0x8f, 0x1b, 0x2b, 0x90, 0xbf, 0xd8, 0x4a, 0x4c, 0x2c, 0x9d, 0x65, 0x43, 0x86, 0x1a, 0xb3, 0xc5, 0x64, 0x51, 0x75, 0x7d, 0xcf, 0xb9, 0xba, 0x60, 0x33, 0x34, 0x88, 0xdb, 0xdd, 0x2, 0xd6, 0x1, 0xb4, 0x1a, 0xae, 0x31, 0x7c, 0xa7, 0x47, 0x4e, 0xb6, 0xe6, 0xdd},
+               output224: []byte{0x7, 0x90, 0x64, 0x9a, 0x6f, 0x6e, 0xcc, 0x4d, 0xca, 0xca, 0xfa, 0xfb, 0x6a, 0xef, 0xbf, 0x6c, 0x6f, 0x7e, 0xc8, 0x83, 0xc7, 0x26, 0x71, 0xdb, 0x21, 0x1c, 0xd1, 0x63},
+               output256: []byte{0xe, 0xa3, 0x3e, 0x2e, 0x34, 0xf5, 0x72, 0x44, 0x6, 0x40, 0x24, 0x4c, 0x7f, 0x1f, 0x5f, 0x4, 0x69, 0x7c, 0xe9, 0x71, 0x39, 0xbd, 0xa7, 0x2a, 0x65, 0x58, 0xd8, 0x66, 0x3c, 0x2, 0xb3, 0x88},
+               output384: []byte{0xd8, 0xa1, 0x8f, 0xdf, 0xd, 0xbc, 0x4d, 0x9d, 0xc9, 0xa3, 0x99, 0xee, 0xd8, 0x33, 0xd2, 0x58, 0xbd, 0xf4, 0xe0, 0x6c, 0x50, 0xc1, 0x25, 0x50, 0xb5, 0x2, 0x97, 0xdd, 0xa0, 0x57, 0x84, 0xae, 0xe9, 0x1f, 0x33, 0x97, 0x66, 0x2, 0x1b, 0x2c, 0xa6, 0xbe, 0x15, 0x77, 0x82, 0x3d, 0x92, 0xb},
+               output512: []byte{0xde, 0xa5, 0x6b, 0xda, 0xbb, 0xc6, 0xd2, 0x41, 0x83, 0xcf, 0x7b, 0xde, 0x1e, 0x1f, 0x78, 0x63, 0x1b, 0x2b, 0x2, 0x30, 0xc7, 0x6f, 0xf2, 0xf4, 0x30, 0x75, 0xf2, 0xfd, 0xe7, 0x7c, 0xf0, 0x52, 0x76, 0x92, 0x76, 0xca, 0xd9, 0x8d, 0xa6, 0x23, 0x94, 0xec, 0x62, 0xd7, 0x77, 0x30, 0xf5, 0x76, 0x14, 0x89, 0x58, 0x5e, 0x9, 0x3e, 0xa7, 0x31, 0x5f, 0x35, 0x92, 0x71, 0x7c, 0x48, 0x5c, 0x84}},
+       testcase{
+               msg:       []byte{0xfe, 0x6, 0xa4, 0x70, 0x64, 0x68, 0xb3, 0x69, 0xf7, 0x62, 0x4f, 0x62, 0xd0, 0x4f, 0x9f, 0xac, 0x2, 0xf, 0x5, 0x15, 0x2f, 0x13, 0xe3, 0x50, 0x1, 0x6b, 0x2a, 0x29, 0xef, 0xff, 0x9a, 0x39, 0x39, 0x40, 0xc1, 0x38, 0x55, 0x33, 0x56, 0xb0, 0xe2, 0x84, 0x8c, 0x1, 0xb6, 0x22, 0xb9, 0x5f, 0xfa, 0x11, 0xab, 0x7, 0x58, 0x5f, 0x7d, 0xcb, 0xbf, 0x90, 0xe9, 0xf8, 0xec, 0x5f, 0xa2, 0xfb, 0x7b, 0x4c, 0xee, 0xd, 0xa, 0x4e, 0x8d, 0x33, 0x49, 0xa, 0xbd, 0x5, 0x8c, 0xf3, 0xbb, 0x85, 0xf0, 0xcd, 0x9b, 0x1b, 0xd3, 0xe9, 0x82, 0x30, 0x82, 0xd7, 0xb, 0x1a, 0x92, 0xac, 0xa6, 0xf2, 0xc8, 0x72, 0x16, 0xb4, 0xba, 0x9, 0xfe, 0xdd, 0xca, 0xa4, 0xcf, 0x25, 0x43, 0x36, 0x14, 0x6c, 0xc7, 0x56, 0x4, 0xfb, 0x1f, 0x28, 0x69, 0x18, 0xfa, 0x24, 0x34, 0xca, 0x36, 0xbe, 0x26, 0x21, 0x4, 0x94, 0x38, 0xa4, 0x0, 0xbd, 0xee, 0xa6, 0xc6, 0x57, 0xf0, 0x30, 0x15, 0x3, 0xcd, 0x7e, 0x6e, 0x38, 0x35, 0x8, 0x38, 0xf6, 0xe, 0xa7, 0xf0, 0x1, 0x75, 0x5d, 0xa4, 0x14, 0x2c, 0xe4, 0x57, 0x9b, 0x39, 0x2, 0x9d, 0xa8, 0x3f, 0x16, 0x46, 0xb7, 0xec, 0xb9, 0x94, 0x7e, 0xe8, 0x9a, 0xba, 0x37, 0x70, 0x99, 0xb8, 0x20, 0x26, 0x96, 0xb, 0x9e, 0xe6, 0x0, 0x77, 0x9b, 0xf0, 0xd, 0x6e, 0xb0, 0xcd, 0x9, 0x22, 0x6d, 0xb6, 0x91, 0x5a, 0x7a, 0xde, 0xd2, 0x7e, 0x67, 0x49, 0xe2, 0xcb, 0xc2, 0xc8, 0xb0, 0x30, 0xce, 0x18, 0x50, 0xeb, 0xfb, 0xe2, 0x4c, 0x6, 0x58, 0xf2, 0x9e, 0x9e, 0x70, 0x9c, 0xd1, 0xd, 0xb8, 0xa7, 0x7e, 0xfd, 0xef, 0xc9, 0xf, 0xdd, 0x7b, 0x9a, 0xd7, 0xa7, 0xe0, 0x33, 0x44, 0x12, 0xa5, 0x3d, 0x24, 0x8c, 0x4c, 0x12, 0xbf, 0x29, 0x87, 0xb7, 0xac, 0xcd, 0x2a, 0x8a, 0x60, 0x2f, 0x18, 0x45, 0x83, 0xaa, 0x56, 0xc, 0x1, 0x60, 0x93, 0xb5, 0x6b, 0x10, 0x1, 0x54, 0x47, 0x7b, 0x83, 0x46, 0x64, 0xe6, 0xb8, 0x5a, 0x19, 0xf8, 0xdc, 0x90, 0x9b, 0x4d, 0x79, 0x81, 0x6a, 0xf1, 0x22, 0x66, 0xc7, 0x31, 0xe2, 0x9a, 0x30, 0x4e, 0x9b, 0xed, 0x8e, 0xf1, 0xc8, 0x3, 0x3, 0x65, 0xb7, 0xde, 0xaf, 0x3d, 0x43, 0x69, 0x57, 0x30, 0x81, 0x17, 0xc7, 0xc5, 0x76, 0x7e, 0xc, 0xda, 0x6e, 0x34, 0x2d, 0xda, 0xf8, 0x24, 0x23, 0x3c, 0xbf, 0x4e, 0x69, 0x9d, 0xc6, 0x67, 0x35, 0x7c, 0xb3, 0x5c, 0x60, 0x2a, 0xc6, 0xbd, 0xde, 0xe7, 0x1b, 0x35, 0x2a, 0xf5, 0x5c, 0xb9, 0x39, 0x41, 0xa1, 0xa6, 0x30, 0x1a, 0x99, 0x4, 0x44, 0x7a, 0xf9, 0xee, 0x48, 0x61, 0x14, 0xd5, 0x7a, 0xe0, 0x39, 0x1, 0xf1, 0x0, 0x84, 0xad, 0xc0, 0x9, 0x6e, 0x46, 0x5e, 0x2e, 0xad, 0x24, 0x96, 0x27, 0x31, 0x12, 0xf2, 0xfa, 0xe6, 0x26, 0xe2, 0x30, 0xd4, 0x2e, 0xc2, 0x2e, 0xa1, 0xa, 0x82, 0x89, 0xb3, 0xe3, 0x5e, 0xee, 0x42, 0x15, 0x7, 0x69, 0xd6, 0xe6, 0x63, 0xa3, 0xca, 0x29, 0x17, 0x43, 0x16, 0xec, 0x93, 0xa2, 0x4f, 0x14, 0x8d, 0x98, 0x40, 0x53, 0xb8, 0xf9, 0x86, 0x64, 0xea, 0xca, 0x3e, 0xd, 0xea, 0xb, 0x42, 0xe8, 0xee, 0x30, 0xf8, 0x1a, 0x2c, 0xd6, 0xe4, 0x2c, 0x18, 0x9a, 0x25, 0xfe, 0xcb, 0x6e, 0x64, 0x3e, 0x69, 0x3e, 0x1f, 0x88, 0x71, 0xb8, 0x37, 0xc3, 0xf5, 0xff, 0x2a, 0xaf, 0xd1, 0x65, 0xa, 0x46, 0x5d, 0xc8, 0xe5, 0xc1, 0x99, 0x3b, 0xe6, 0x5c, 0xff, 0xd8, 0x7f, 0x2c, 0x68, 0xc, 0x86, 0xb0, 0xad, 0x31, 0x18, 0x83, 0x4a, 0x5f, 0x2e, 0x49, 0x0, 0x15, 0x13, 0x7b, 0xa9, 0x45, 0xc2, 0x77, 0x5d, 0xbd, 0x77, 0xfb, 0x3e, 0x5c, 0x67, 0x81, 0x9a, 0x9a, 0x7a, 0x94, 0xa6, 0x56, 0xfc, 0x47, 0x61, 0x65, 0x9c, 0x5b, 0x30, 0xed, 0x2a, 0xc5, 0x5a, 0x6d, 0x24, 0x9b, 0x70, 0xb, 0xc9, 0xc9, 0x3d, 0x59, 0x4, 0x90, 0xaa, 0xaa, 0xa7, 0x5a, 0x9f, 0xc3, 0x4a, 0x90, 0xd5, 0xa9, 0x10, 0x6f, 0x28, 0x60, 0xbd, 0xe1, 0x9f, 0xe5, 0x81, 0x54, 0x36, 0x6, 0x8a, 0x7f, 0x8e, 0xa4, 0x63, 0x6a},
+               output224: []byte{0xcc, 0xd8, 0xa5, 0xf3, 0xc0, 0xa2, 0xf6, 0xaa, 0xa2, 0x5b, 0xe8, 0x97, 0x91, 0x60, 0x8c, 0x42, 0x9a, 0xd8, 0xa6, 0xde, 0x76, 0x7a, 0x47, 0x94, 0xb3, 0x5, 0xfb, 0x62},
+               output256: []byte{0xd3, 0x10, 0x38, 0xec, 0x77, 0xcc, 0xad, 0x0, 0xaf, 0x3d, 0x9d, 0x5e, 0x9f, 0x5c, 0xe7, 0x17, 0xf5, 0x94, 0x5b, 0xde, 0x71, 0xc8, 0x7c, 0xea, 0x83, 0x7b, 0xe4, 0xb3, 0x60, 0xde, 0x59, 0x5a},
+               output384: []byte{0x99, 0xfd, 0xee, 0x84, 0xa6, 0xe0, 0x6e, 0x7e, 0x8b, 0x21, 0xaf, 0x15, 0x64, 0x48, 0xb3, 0x16, 0x8f, 0x77, 0x71, 0x35, 0x2, 0x95, 0x65, 0x69, 0x46, 0x8, 0xe1, 0x47, 0x53, 0x7c, 0xe2, 0x62, 0x39, 0xd6, 0x89, 0x8f, 0xb, 0x1, 0xe4, 0x7, 0xef, 0x9e, 0x1c, 0xe5, 0x2b, 0xed, 0x34, 0x5e},
+               output512: []byte{0x2e, 0x62, 0x36, 0x11, 0x7c, 0x4f, 0x99, 0x47, 0x8b, 0xff, 0x20, 0x4a, 0x44, 0x3c, 0x64, 0x77, 0x7c, 0xc0, 0xd6, 0x58, 0xa2, 0x46, 0x5, 0xe8, 0x10, 0xe5, 0xff, 0x12, 0xf2, 0x79, 0xbc, 0x32, 0x6c, 0x43, 0x91, 0x11, 0xa9, 0x11, 0x58, 0x31, 0x76, 0x28, 0xd, 0x63, 0xc4, 0xbf, 0x9c, 0x69, 0xf4, 0x7, 0x29, 0xcb, 0x97, 0x69, 0x96, 0xae, 0x77, 0x65, 0xe5, 0x91, 0x0, 0x4c, 0xd7, 0x99}},
+       testcase{
+               msg:       []byte{0xd0, 0xff, 0x6e, 0x4, 0x5f, 0x4b, 0x63, 0x6f, 0x75, 0xa3, 0x89, 0x79, 0x9f, 0x31, 0x40, 0x66, 0x64, 0x48, 0x54, 0x82, 0x1b, 0x6e, 0x7a, 0xe4, 0x4, 0x7a, 0xdf, 0xde, 0x2d, 0xc, 0xe, 0x2, 0xc2, 0x50, 0xf0, 0xbe, 0x58, 0x2b, 0xec, 0x94, 0x1, 0x11, 0x89, 0xb9, 0x64, 0xa8, 0xaf, 0x43, 0xf, 0x59, 0x21, 0xed, 0x9d, 0x9f, 0x44, 0x46, 0xe4, 0xc7, 0x88, 0x51, 0x5b, 0x89, 0xca, 0x69, 0xe5, 0xf7, 0xcd, 0xfc, 0xcc, 0x9e, 0x83, 0xe8, 0xf9, 0x46, 0x1, 0x45, 0xb4, 0x3d, 0xdc, 0x41, 0xc0, 0x7c, 0xc5, 0x12, 0xb7, 0xe6, 0xfd, 0xd0, 0xe1, 0xe7, 0xaa, 0xba, 0x29, 0xa6, 0xc0, 0x16, 0xcc, 0xb7, 0xbd, 0x54, 0xb1, 0x45, 0xf3, 0x95, 0x1e, 0xab, 0x9b, 0xc4, 0x90, 0x8f, 0x62, 0x3e, 0x5a, 0x9b, 0xc, 0x5b, 0x36, 0x5, 0x62, 0x92, 0x54, 0xb, 0x79, 0xfd, 0x15, 0xc5, 0x34, 0x57, 0xdc, 0x74, 0xa6, 0x5f, 0xd7, 0x73, 0xa3, 0x4d, 0x6b, 0x31, 0x3a, 0x5, 0x6f, 0x79, 0xbc, 0x29, 0xa3, 0xfa, 0xc1, 0x5f, 0x6a, 0x14, 0x46, 0xbf, 0xae, 0xea, 0xaf, 0xba, 0xc8, 0xec, 0xf8, 0x16, 0x8d, 0xde, 0x5f, 0x6a, 0xe6, 0xb6, 0xe5, 0x79, 0xbd, 0x3c, 0xe7, 0x4e, 0x7a, 0xbf, 0xad, 0xf3, 0x61, 0xd0, 0xfd, 0x32, 0xd5, 0x65, 0x86, 0xa8, 0xd2, 0xd4, 0xff, 0x4c, 0xfd, 0xf8, 0xa7, 0x50, 0xfa, 0xfd, 0xe4, 0xc2, 0xe9, 0xeb, 0x32, 0xb0, 0x68, 0x47, 0xfa, 0x30, 0xb1, 0x3c, 0xc2, 0x73, 0x53, 0x2d, 0x1a, 0x23, 0xc8, 0x25, 0x7f, 0x80, 0xc6, 0xb, 0x8f, 0xa9, 0x4f, 0xa9, 0x76, 0xf5, 0x34, 0x14, 0x5c, 0xd6, 0x1c, 0x41, 0xc0, 0xa5, 0x11, 0xb6, 0x2c, 0xad, 0xd5, 0x84, 0x8c, 0xef, 0xf6, 0x43, 0xf8, 0x3c, 0xe4, 0x3f, 0x8e, 0x69, 0x69, 0xc5, 0xa5, 0x59, 0xaf, 0xad, 0x60, 0xe3, 0x10, 0x59, 0x9a, 0x34, 0xb2, 0xe5, 0xe0, 0x29, 0xfb, 0xdd, 0xf2, 0x98, 0x8f, 0xce, 0x59, 0x26, 0x9c, 0x71, 0x28, 0xa1, 0xfc, 0x79, 0xa7, 0x4b, 0x15, 0x4d, 0x8a, 0xa2, 0x85, 0xd, 0xcf, 0xdb, 0xf5, 0x94, 0x68, 0x4e, 0x74, 0x9, 0x9e, 0x37, 0x88, 0x2b, 0x44, 0x3, 0x67, 0xc1, 0xdd, 0x30, 0x3, 0xf6, 0x1c, 0xaf, 0xb4, 0x6a, 0xc7, 0x5d, 0x30, 0xe6, 0x77, 0xaf, 0x54, 0x55, 0x9a, 0x5d, 0xab, 0x70, 0xc5, 0x6, 0xcf, 0x61, 0xa9, 0xc3, 0x5e, 0xe, 0x56, 0xe1, 0x43, 0x7, 0x46, 0x91, 0x6d, 0xde, 0xec, 0x8d, 0x89, 0xb0, 0xc1, 0xd, 0xaa, 0x2, 0xc5, 0xd7, 0xe9, 0xf4, 0x26, 0x21, 0xd2, 0xb3, 0x12, 0xea, 0xff, 0xc9, 0xff, 0x30, 0x62, 0x97, 0x95, 0x2a, 0x32, 0xd2, 0x6c, 0x21, 0x48, 0x57, 0xa, 0xec, 0x90, 0x50, 0x1c, 0xa7, 0x39, 0xce, 0x5e, 0x68, 0x9e, 0x70, 0x66, 0xd9, 0x58, 0xa, 0x4f, 0xc2, 0x5e, 0x20, 0x23, 0x89, 0x7c, 0x74, 0xc6, 0x85, 0x62, 0x73, 0x13, 0x3e, 0x12, 0x75, 0xa0, 0xd2, 0x75, 0xdc, 0x5b, 0x75, 0xdb, 0x72, 0x4c, 0xd1, 0x2c, 0x9c, 0x1, 0xbb, 0x95, 0xab, 0x5a, 0x22, 0x7b, 0x78, 0x50, 0x2, 0x6, 0x30, 0x50, 0x60, 0x96, 0x87, 0x8d, 0x28, 0x99, 0x23, 0x17, 0x71, 0x83, 0xea, 0x92, 0x82, 0xa4, 0xc7, 0x8e, 0xc2, 0x12, 0xd2, 0xe8, 0x98, 0xcb, 0x99, 0xd8, 0x1a, 0x33, 0x64, 0xdf, 0x20, 0x92, 0x7e, 0xe3, 0x4d, 0x44, 0x75, 0xa5, 0xcf, 0x5c, 0xdb, 0x24, 0x8, 0x8e, 0xd7, 0x5b, 0x60, 0x20, 0x19, 0x22, 0xe9, 0xc9, 0x72, 0xd8, 0x55, 0x6c, 0xa7, 0x5f, 0x82, 0x74, 0xd1, 0x5f, 0x3f, 0xb8, 0x8a, 0x6b, 0x42, 0xc7, 0x66, 0xde, 0xf6, 0xb2, 0x13, 0x29, 0xde, 0xe7, 0xc4, 0x57, 0x44, 0x6d, 0xde, 0x8c, 0x26, 0x40, 0x5f, 0xe5, 0xd0, 0x30, 0x9a, 0x4, 0x22, 0x9f, 0x44, 0x9e, 0x84, 0x90, 0xcf, 0x90, 0x0, 0xee, 0x8d, 0xf4, 0x0, 0xcb, 0x7c, 0x7e, 0xe8, 0x31, 0xbd, 0x70, 0x59, 0xd2, 0x40, 0x88, 0xfb, 0x42, 0xd6, 0x16, 0x81, 0xcd, 0xe4, 0x50, 0x50, 0xfc, 0xa7, 0x8f, 0xf6, 0x4d, 0x9c, 0x8d, 0x1f, 0x58, 0xb5, 0x5f, 0x80, 0x2f, 0xa5, 0xd2, 0xf2, 0xe7, 0x23, 0xf3, 0xe4, 0xee, 0xd4, 0x33, 0x8b, 0x6, 0xd, 0x31, 0xc8, 0xac, 0xc4, 0x6d, 0x26, 0x87, 0xb, 0xd4, 0x5d, 0xd, 0xe0, 0x79, 0x8d, 0x48, 0xe3, 0x2a, 0xad, 0x1a, 0x6d, 0x43, 0x22, 0xe6, 0x9f, 0x5e, 0x72, 0x30, 0x9b, 0x9d, 0x7f, 0xa1, 0xf2, 0x4b, 0xb1, 0xd6, 0x3f, 0xf0, 0x9e, 0xd4, 0x73, 0x91, 0xc2, 0x32, 0x49, 0x7b, 0xf2, 0x22, 0xc5, 0x42, 0xa7, 0x9, 0x75, 0xc8, 0x29, 0x2d, 0x27, 0x51, 0x97, 0xa4, 0xca},
+               output224: []byte{0x68, 0xc9, 0x38, 0xd6, 0x49, 0x6b, 0xb5, 0x7, 0xd7, 0xed, 0xe9, 0xac, 0x12, 0xfe, 0x8e, 0x1, 0xb, 0x3b, 0x2c, 0xfd, 0x44, 0xa5, 0xd4, 0x76, 0x10, 0x31, 0xb9, 0xe2},
+               output256: []byte{0xe4, 0xe3, 0xbb, 0x66, 0x2b, 0xe0, 0x94, 0x61, 0xf, 0x4, 0xd5, 0x59, 0x4e, 0xef, 0x5f, 0x78, 0xb1, 0xab, 0x8, 0xf, 0x2e, 0xbe, 0x5a, 0xcf, 0x41, 0xd6, 0x61, 0xfa, 0x13, 0xa6, 0x8d, 0xbd},
+               output384: []byte{0xe7, 0x2a, 0xfb, 0xd3, 0xac, 0xd3, 0x5b, 0x7f, 0x87, 0x8f, 0xce, 0xfa, 0xc7, 0x8d, 0xc5, 0x34, 0xe4, 0x25, 0x5, 0x22, 0x13, 0x76, 0x9d, 0xc3, 0xee, 0x17, 0x2a, 0xe5, 0x62, 0xf4, 0xa0, 0xfc, 0x94, 0x6d, 0x9c, 0x8e, 0x54, 0x6f, 0x15, 0x78, 0xa2, 0xac, 0xf3, 0xd0, 0x6d, 0x9f, 0x3c, 0xc9},
+               output512: []byte{0xc8, 0xee, 0x15, 0x8c, 0xc1, 0xad, 0x47, 0x8a, 0x5b, 0x16, 0x64, 0x5b, 0xcb, 0x3a, 0x54, 0xa3, 0x8c, 0x7a, 0x55, 0x4a, 0xb5, 0x84, 0xd, 0x13, 0xfa, 0x7, 0xc7, 0xc, 0x18, 0xa3, 0x5e, 0x30, 0x35, 0xfb, 0x64, 0x44, 0x5a, 0x9b, 0x65, 0xda, 0x6, 0xeb, 0x7c, 0xfa, 0x5b, 0xd3, 0xc9, 0x21, 0xb2, 0xd, 0x15, 0xc, 0xfb, 0x73, 0x21, 0x31, 0x54, 0x28, 0x38, 0x40, 0xb7, 0x28, 0xde, 0x1e}},
+       testcase{
+               msg:       []byte{0xc9, 0xa0, 0xb5, 0x1f, 0x31, 0x99, 0x33, 0x9c, 0x11, 0xa5, 0x75, 0x3c, 0x9d, 0x9c, 0x95, 0x10, 0x4b, 0x40, 0x1, 0x27, 0x8, 0x71, 0x77, 0xf1, 0x4d, 0x3e, 0x15, 0xbe, 0x88, 0x1e, 0xe8, 0x9b, 0xf4, 0x16, 0xf9, 0x7d, 0x4f, 0x7a, 0xa9, 0x63, 0x6c, 0x5e, 0xf2, 0x9e, 0xbb, 0xf8, 0x93, 0x8, 0x4, 0x0, 0x6e, 0xb2, 0x68, 0x39, 0x41, 0x5d, 0x39, 0x84, 0xb9, 0x20, 0x88, 0x24, 0x99, 0x75, 0x2c, 0x36, 0xa5, 0xbb, 0xd5, 0x83, 0x30, 0x8e, 0x71, 0x6d, 0xb1, 0x6f, 0x28, 0xdb, 0x98, 0xb3, 0xa3, 0xe7, 0x18, 0xa2, 0xeb, 0xcd, 0xfe, 0xfa, 0x75, 0xd7, 0xcc, 0xbb, 0x6a, 0x74, 0x6e, 0x32, 0xfe, 0xaa, 0x38, 0xd0, 0x34, 0x84, 0x34, 0x61, 0xdb, 0xcf, 0xca, 0x7f, 0x98, 0x3e, 0x19, 0xf5, 0xb2, 0x3e, 0xc2, 0xe3, 0xd7, 0x4d, 0x2b, 0x44, 0x2, 0xf3, 0xbd, 0xce, 0x7d, 0x7a, 0x9d, 0xf1, 0x38, 0x46, 0x68, 0xc7, 0x46, 0xcc, 0xe4, 0x66, 0xb0, 0x65, 0x4c, 0xdd, 0x5c, 0xa5, 0x6a, 0x77, 0xd6, 0x8a, 0x10, 0xa, 0xe0, 0x6d, 0x63, 0xcd, 0x9a, 0xf5, 0x12, 0xae, 0xba, 0xe7, 0x89, 0x93, 0x80, 0x8c, 0xe6, 0x72, 0x33, 0xe, 0x20, 0x65, 0xc0, 0xf7, 0x1e, 0x5, 0xc0, 0xfe, 0x82, 0x1c, 0xd5, 0xf8, 0x57, 0x32, 0x31, 0x5f, 0x4, 0x66, 0x6f, 0x3e, 0x4e, 0x6c, 0x4f, 0x3e, 0x9f, 0x41, 0x5e, 0x31, 0xfe, 0x9, 0x80, 0xd8, 0x74, 0x99, 0x41, 0x8, 0xe1, 0x24, 0x64, 0x60, 0x9c, 0x6d, 0x5c, 0x19, 0xce, 0xdf, 0xc8, 0x58, 0x46, 0xb0, 0xa8, 0x4e, 0xf3, 0xcc, 0xbd, 0x3b, 0x65, 0x5f, 0xb0, 0xde, 0x8c, 0xb8, 0x92, 0xbd, 0xf7, 0x74, 0xdf, 0x39, 0xc9, 0x55, 0xf0, 0x4f, 0x32, 0x28, 0x56, 0xd4, 0x70, 0x98, 0x1b, 0xee, 0xd0, 0xf7, 0x52, 0xd8, 0x2e, 0xad, 0x73, 0xb4, 0x13, 0x1c, 0x5d, 0xbf, 0x4, 0x24, 0xb4, 0xab, 0x65, 0x4f, 0x72, 0xe2, 0x6e, 0xf0, 0xcd, 0x29, 0x2b, 0x87, 0xbd, 0x5b, 0x66, 0xfb, 0xd5, 0xe7, 0xeb, 0xa9, 0x6c, 0x62, 0xcf, 0xfe, 0xfd, 0x4b, 0x1d, 0x87, 0xb, 0xfe, 0xf3, 0x12, 0xb8, 0x6e, 0x38, 0xed, 0x5c, 0xf, 0x50, 0x93, 0x5e, 0x2e, 0xcf, 0x9f, 0xcb, 0x8c, 0x95, 0xd3, 0x5d, 0x19, 0xa8, 0xfc, 0x8f, 0x20, 0x2b, 0xd9, 0xdb, 0xa7, 0x68, 0xca, 0x48, 0xfb, 0xbb, 0x7, 0x11, 0x79, 0x41, 0x3c, 0xd, 0xe4, 0xfd, 0xe8, 0x67, 0x62, 0xed, 0x4b, 0x13, 0xe1, 0xee, 0xf2, 0xa0, 0xa, 0xdd, 0x5d, 0x1c, 0x2a, 0x3a, 0xf7, 0x93, 0x77, 0x87, 0xde, 0xba, 0xf1, 0xf6, 0xf1, 0x2f, 0x3f, 0x2, 0x25, 0xff, 0xe5, 0x87, 0xa5, 0x54, 0xc, 0xb5, 0x50, 0xf7, 0xbc, 0x11, 0xdd, 0x6a, 0xf8, 0x64, 0xd6, 0xb6, 0xd1, 0x6d, 0xb1, 0x48, 0x8c, 0xb2, 0x26, 0xeb, 0xb2, 0x19, 0x9d, 0xa7, 0x5f, 0xdd, 0x59, 0xa7, 0x11, 0x58, 0x86, 0x72, 0x98, 0xf6, 0x39, 0x61, 0xb4, 0xa, 0x31, 0x20, 0x9f, 0x8f, 0x16, 0x62, 0x9b, 0x1c, 0xce, 0x7f, 0xfb, 0x61, 0x70, 0x72, 0x74, 0x8f, 0xde, 0x89, 0x20, 0xd1, 0x1c, 0xc0, 0xd0, 0x67, 0x83, 0x89, 0xd1, 0xf7, 0x19, 0xdf, 0x3e, 0xd1, 0x98, 0x46, 0xfe, 0x98, 0x93, 0xb0, 0x4d, 0xb6, 0xf, 0xa6, 0x3, 0x17, 0xd, 0x95, 0x73, 0xb1, 0xbf, 0xc7, 0xda, 0x66, 0x3e, 0x7, 0x25, 0x45, 0x52, 0xab, 0x62, 0x53, 0xdd, 0xe8, 0x14, 0x11, 0x71, 0x85, 0xf8, 0x43, 0x73, 0xfe, 0xcd, 0x7f, 0x98, 0xde, 0xd1, 0x70, 0xc8, 0x84, 0xd4, 0x1d, 0x1a, 0xc8, 0x18, 0x14, 0xc7, 0x3e, 0xa4, 0x8a, 0xd9, 0x4e, 0xca, 0x1b, 0x77, 0x33, 0xd8, 0x39, 0x3e, 0x32, 0xc, 0x8c, 0x46, 0x7e, 0xf6, 0x18, 0x9b, 0x4a, 0xc3, 0x24, 0xc6, 0x8c, 0x8a, 0x2e, 0xcf, 0x67, 0x9c, 0x89, 0x3b, 0x7d, 0xbc, 0x43, 0x10, 0xcd, 0x5, 0xda, 0xdd, 0x80, 0xbb, 0x63, 0x26, 0xb5, 0x1e, 0xcd, 0x99, 0xa4, 0x41, 0xbf, 0xf7, 0x7b, 0xe8, 0xd6, 0x44, 0xd7, 0x52, 0xf3, 0xc5, 0xc7, 0x94, 0xe7, 0xd4, 0x5b, 0xa7, 0x62, 0x83, 0xac, 0xf8, 0x91, 0x3b, 0xbf, 0x2a, 0x42, 0xf, 0x9e, 0x5d, 0x14, 0xd7, 0xa2, 0x3e, 0x95, 0xfd, 0xeb, 0xc6, 0x9b, 0x45, 0x5e, 0x46, 0x64, 0x23, 0x1, 0x2e, 0x9d, 0x1d, 0xe9, 0x35, 0x3e, 0x40, 0xd4, 0xbd, 0xc3, 0x10, 0x7c, 0x31, 0x44, 0xb9, 0x6c, 0x6d, 0xaf, 0xd4, 0x1c, 0xce, 0xfe, 0xb2, 0xb7, 0xff, 0x84, 0x8c, 0xb9, 0xfd, 0xbe, 0xa8, 0x64, 0x8b, 0xe3, 0x21, 0x60, 0xfa, 0xb7, 0xe7, 0xdf, 0xcc, 0xb8, 0x7, 0xfb, 0x1, 0x9e, 0xbf, 0x15, 0x92, 0x31, 0xed, 0xcf, 0x2d, 0x48, 0x7d, 0x76, 0xa3, 0xe8, 0x82, 0xf3, 0xf5, 0xc, 0xa4, 0x8d, 0xd0, 0x8a, 0x23, 0xb0, 0x6e, 0xe8, 0x87, 0xbd, 0x7d, 0xf9, 0xd7, 0xc6, 0xcc, 0x2b, 0xdb, 0xe3, 0x48, 0xe3, 0x12, 0x5c, 0x45, 0x32, 0x44, 0x8f, 0x40, 0xc, 0xd5, 0x7a, 0x86, 0x79, 0xab, 0xab, 0x13, 0xe5, 0x82, 0xb1, 0x3d, 0x49, 0x44, 0x26, 0x38, 0xe2, 0x69, 0x8f, 0xb7, 0xa5, 0x63, 0xc7, 0xfb, 0x26, 0x41, 0x57},
+               output224: []byte{0x2e, 0xaf, 0x74, 0x19, 0x85, 0x69, 0xe0, 0x5a, 0x6, 0x14, 0xb0, 0x67, 0xc9, 0x11, 0xd6, 0x25, 0xa9, 0x22, 0x2b, 0xcb, 0x6f, 0x75, 0x37, 0xc3, 0x4e, 0x75, 0x3, 0x93},
+               output256: []byte{0x6e, 0x1b, 0xb4, 0xd0, 0x34, 0xe9, 0xb9, 0x81, 0x6e, 0xd1, 0xa8, 0x46, 0xf9, 0x3, 0xf6, 0x2c, 0xb1, 0xbd, 0xb8, 0xa0, 0xd, 0x44, 0x6c, 0x9c, 0xc7, 0x77, 0xe4, 0x75, 0xa3, 0x27, 0xc5, 0x8d},
+               output384: []byte{0x25, 0x64, 0x32, 0xcf, 0xe8, 0xf9, 0xf0, 0xc3, 0xef, 0xbb, 0x6c, 0xd1, 0x35, 0xfd, 0x92, 0xa9, 0x2a, 0xc5, 0x77, 0x2f, 0x3c, 0xd9, 0x5, 0x38, 0x9c, 0x5e, 0x76, 0xa4, 0x3e, 0x4f, 0x68, 0x3, 0x8, 0xc1, 0x34, 0xac, 0xb8, 0xd1, 0x7b, 0xf7, 0xcc, 0xa2, 0xe6, 0x67, 0x57, 0xc6, 0x7c, 0x33},
+               output512: []byte{0x65, 0x6a, 0xbb, 0x69, 0x55, 0x4d, 0x7d, 0x34, 0x85, 0x5c, 0xc, 0x36, 0xd9, 0x9b, 0x73, 0xb9, 0x56, 0x9b, 0x1f, 0xf, 0x86, 0xb2, 0xcc, 0xa6, 0xc4, 0x6e, 0x80, 0x39, 0x37, 0x7d, 0x22, 0xc7, 0xf, 0x4d, 0x45, 0x7e, 0x3a, 0xd1, 0xdd, 0x33, 0x1, 0x2c, 0xb1, 0xbb, 0x26, 0x20, 0xbc, 0x1d, 0xbc, 0x4c, 0x68, 0xf0, 0xb2, 0xa3, 0x2, 0xb8, 0x1b, 0x64, 0xd2, 0x7, 0xb0, 0x4e, 0xf, 0x4f}},
+       testcase{
+               msg:       []byte{0xda, 0x5b, 0x21, 0x18, 0xcb, 0xd5, 0x9f, 0x40, 0x8c, 0xe5, 0x63, 0x62, 0x48, 0x9f, 0xda, 0x69, 0xef, 0x73, 0x17, 0x2f, 0x46, 0xde, 0xc1, 0x6c, 0xd, 0x4a, 0x66, 0xe3, 0xf3, 0xcc, 0xa3, 0x73, 0x92, 0x7c, 0xb6, 0x78, 0x4c, 0xe6, 0x2b, 0xbc, 0xb0, 0x8a, 0x49, 0xd, 0x0, 0x3a, 0x8f, 0x77, 0x39, 0x1e, 0x82, 0xcd, 0xd8, 0x78, 0x60, 0x90, 0x93, 0x83, 0xb0, 0x54, 0xdb, 0x95, 0x81, 0x67, 0x20, 0x11, 0x2e, 0x2f, 0x96, 0xde, 0x9e, 0xf, 0xfc, 0x8b, 0xab, 0xc1, 0x35, 0xe, 0xd4, 0x6b, 0x9a, 0xeb, 0x5d, 0x46, 0xb6, 0x69, 0x40, 0xef, 0xa3, 0x11, 0xf4, 0x85, 0x3f, 0x31, 0x18, 0x6, 0x3c, 0x55, 0x7, 0x33, 0xe7, 0x67, 0x9d, 0x87, 0x17, 0x29, 0x0, 0x1c, 0x12, 0x27, 0xe, 0x98, 0x43, 0x9e, 0x37, 0x5e, 0xc, 0xd2, 0x47, 0x69, 0xd3, 0x18, 0xe0, 0x3c, 0xbc, 0x97, 0xd6, 0x43, 0xf1, 0xdc, 0x5f, 0x1b, 0x5e, 0xf5, 0x9d, 0x12, 0x78, 0x9f, 0x22, 0x44, 0x9b, 0xd8, 0xfa, 0x43, 0xa1, 0x3c, 0xe7, 0x8a, 0x41, 0x86, 0x16, 0x65, 0x23, 0xf3, 0x80, 0x7b, 0xb, 0x62, 0x10, 0x79, 0xcc, 0x52, 0x8f, 0x4e, 0x17, 0xc2, 0x58, 0xd4, 0xf9, 0xbd, 0xd0, 0x95, 0xa3, 0xe3, 0x65, 0x61, 0x4b, 0x94, 0xf2, 0xcd, 0x77, 0x8c, 0xac, 0xab, 0xf2, 0x62, 0x44, 0x89, 0x15, 0x31, 0xee, 0xdc, 0x24, 0xe1, 0xbf, 0x45, 0x98, 0x31, 0x9e, 0xb8, 0xb7, 0x52, 0x77, 0x36, 0xbb, 0x1e, 0x73, 0x44, 0x29, 0x36, 0xf, 0x47, 0xf0, 0x4b, 0x2e, 0x95, 0xd5, 0xaa, 0xe9, 0x97, 0x76, 0x3a, 0x46, 0x7c, 0xc5, 0x30, 0x3d, 0x11, 0x41, 0xc2, 0xc0, 0x1f, 0x7a, 0xb9, 0xed, 0xab, 0x86, 0xd, 0x18, 0x6, 0x97, 0xc9, 0x6, 0xce, 0x15, 0x58, 0xae, 0xff, 0x5a, 0xdc, 0xe6, 0x3, 0xf8, 0xa4, 0xa1, 0xf, 0xc6, 0xc1, 0x69, 0x91, 0x89, 0xe7, 0x3b, 0x48, 0x9f, 0x64, 0xce, 0xfb, 0x89, 0xac, 0x55, 0x7c, 0x5b, 0xb8, 0x82, 0x6c, 0x3, 0x17, 0xea, 0xef, 0x23, 0x2, 0xe8, 0x55, 0xfb, 0xd9, 0x67, 0x77, 0x89, 0x81, 0x4, 0x36, 0x5d, 0x96, 0xae, 0x8a, 0x8e, 0xd8, 0x66, 0x9c, 0x56, 0x8c, 0x4d, 0xbe, 0xb0, 0xa7, 0xf, 0x6c, 0xf4, 0xc2, 0x2f, 0xd9, 0x33, 0x1, 0x44, 0x73, 0xf9, 0x18, 0x71, 0xc0, 0x8d, 0x5a, 0x7b, 0x44, 0xa9, 0x28, 0x29, 0x5f, 0xb2, 0xaa, 0x56, 0xd5, 0xe2, 0xc3, 0x9c, 0xa7, 0x9d, 0x28, 0x37, 0xfb, 0x39, 0xb3, 0x5c, 0x68, 0x10, 0xc3, 0x78, 0xd7, 0x49, 0xaa, 0xcb, 0x54, 0x33, 0x68, 0xa1, 0x9c, 0x13, 0x7b, 0x87, 0x22, 0x29, 0xe0, 0xa6, 0xf4, 0x69, 0x2, 0x2a, 0xa9, 0x3b, 0xcb, 0x2b, 0xe3, 0x8b, 0x76, 0x1c, 0x85, 0xac, 0x9, 0x41, 0x5c, 0xa7, 0xde, 0xeb, 0x38, 0xff, 0x2a, 0x21, 0x1, 0x50, 0x72, 0x6, 0xfe, 0x32, 0x2a, 0x89, 0x66, 0x6d, 0x32, 0x75, 0xa, 0xf0, 0xf4, 0xd7, 0xb2, 0xe5, 0x95, 0x71, 0xf0, 0x2a, 0x4, 0x8b, 0x8f, 0x94, 0xfe, 0x2d, 0x23, 0x10, 0x72, 0xe3, 0x1, 0xc8, 0x64, 0x1d, 0x1c, 0xdb, 0x4f, 0x84, 0x1a, 0xb1, 0x65, 0xaf, 0x29, 0x74, 0x95, 0xa3, 0x48, 0xbc, 0xcd, 0x93, 0x77, 0x12, 0xe6, 0x88, 0x52, 0xa4, 0xac, 0xa9, 0x48, 0xc1, 0x29, 0x4f, 0x8b, 0x73, 0x3d, 0x6, 0xd6, 0x7d, 0xe8, 0x9f, 0x20, 0x64, 0x98, 0xdd, 0x40, 0x1e, 0x14, 0x9f, 0xcc, 0x1e, 0xdc, 0xa9, 0x2d, 0xeb, 0x92, 0x95, 0x2e, 0xde, 0x4e, 0xbd, 0xc7, 0xcd, 0x79, 0x92, 0x10, 0x47, 0x69, 0xa0, 0x4d, 0xe8, 0x70, 0x50, 0x27, 0xa3, 0x13, 0x37, 0xb8, 0x8e, 0x8d, 0xe9, 0x3f, 0x66, 0x24, 0xe8, 0xf1, 0xb, 0x9f, 0x99, 0x24, 0xe8, 0xce, 0x5a, 0x9d, 0x84, 0x1c, 0x92, 0x60, 0x75, 0x3f, 0xa1, 0x49, 0x2c, 0xdd, 0xff, 0xe6, 0xb4, 0x40, 0xc, 0x57, 0x19, 0xd7, 0x6f, 0xb5, 0xb0, 0x1b, 0x23, 0x4f, 0x32, 0xff, 0xe6, 0x4f, 0x4, 0xd0, 0xa0, 0x6, 0x76, 0xfb, 0xfc, 0x58, 0xdb, 0xe1, 0x7b, 0x4d, 0x55, 0x2f, 0xdf, 0xc, 0x5b, 0x80, 0x2c, 0xc, 0xad, 0xf7, 0x23, 0xf7, 0x3f, 0x86, 0xe8, 0xff, 0xc4, 0x93, 0x99, 0x2d, 0x23, 0xe8, 0xc0, 0xb8, 0x4f, 0x72, 0x20, 0xa9, 0x83, 0xdd, 0xda, 0x21, 0x17, 0xb, 0x1f, 0x73, 0xc, 0x73, 0x6e, 0x75, 0x54, 0x9a, 0xf6, 0xec, 0xb8, 0xdc, 0x94, 0xfb, 0x25, 0xc2, 0x6b, 0xcd, 0xde, 0xe4, 0x20, 0xc8, 0x3e, 0x8a, 0x45, 0xae, 0x4c, 0x34, 0x58, 0x16, 0xb7, 0x16, 0x3c, 0xfe, 0x1, 0x6d, 0xcc, 0xfe, 0x47, 0xc6, 0x69, 0x79, 0xd6, 0x10, 0xa7, 0xf9, 0xb4, 0xa7, 0xb1, 0xba, 0x5e, 0x23, 0x3, 0x44, 0xc9, 0xf4, 0x6b, 0xa0, 0x76, 0xf2, 0xfc, 0xea, 0x68, 0xaa, 0xda, 0x8f, 0xa0, 0x9b, 0xf0, 0xb5, 0xcb, 0xb3, 0x85, 0xd, 0xde, 0xdd, 0x80, 0xa3, 0xe, 0x1f, 0x7a, 0x63, 0x9a, 0xc6, 0x9e, 0x55, 0x95, 0xc6, 0xa4, 0x8, 0x3a, 0xa9, 0x59, 0x83, 0x1e, 0xbb, 0xeb, 0x84, 0xc0, 0x18, 0x6, 0x87, 0x23, 0x19, 0x2f, 0x58, 0xba, 0xec, 0xdd, 0xd1, 0x8c, 0x85, 0x7e, 0x21, 0x2d, 0x4c, 0x7e, 0x72, 0x15, 0xb6, 0xc9, 0x54, 0x72, 0x81, 0x83, 0xfb, 0xaa, 0x7, 0x72, 0xb, 0x97, 0x18, 0x9a, 0xf6, 0xa7, 0x72, 0x9c, 0x30, 0xd2, 0x8d, 0xb3, 0x3a, 0x88, 0x9f, 0x22, 0x5d, 0x2, 0x7d, 0x16, 0x4f, 0x25, 0x45, 0x35, 0x77, 0xc, 0x50, 0x4c, 0x50, 0x6a, 0xee, 0x4e, 0xc4, 0x67, 0x67, 0x71, 0xf6, 0x9f, 0x93, 0x5b, 0xa0, 0x8a, 0x1c, 0x6c, 0x85},
+               output224: []byte{0x3a, 0x96, 0x95, 0xfc, 0x92, 0x10, 0x64, 0xad, 0x79, 0x92, 0x1d, 0x76, 0xe9, 0x1d, 0x7a, 0xc9, 0x1c, 0x77, 0x7a, 0x77, 0xbf, 0xb5, 0x38, 0xe, 0xa0, 0x68, 0x6c, 0x87},
+               output256: []byte{0x63, 0x19, 0xc9, 0x11, 0x7e, 0xc0, 0xfd, 0xfb, 0x18, 0x9c, 0x83, 0xb5, 0x51, 0x1, 0x51, 0x45, 0xfc, 0x61, 0xff, 0x66, 0xb0, 0xd1, 0xb1, 0x56, 0x8a, 0xc8, 0xd1, 0x7d, 0x61, 0xf2, 0xa0, 0x8f},
+               output384: []byte{0x61, 0xf4, 0x7f, 0x6b, 0xc7, 0x97, 0xd1, 0x66, 0x58, 0x9, 0xa3, 0x9c, 0xf9, 0x9b, 0x9, 0x39, 0x26, 0xb3, 0x3f, 0x92, 0x6e, 0xf6, 0xb0, 0xa1, 0xec, 0x8d, 0x82, 0x52, 0x35, 0x11, 0xff, 0x71, 0x9b, 0x3b, 0x62, 0x5c, 0xb1, 0xb5, 0x6a, 0x96, 0x62, 0x98, 0xfa, 0x77, 0xe5, 0xbf, 0x16, 0xf0},
+               output512: []byte{0xfc, 0x6, 0x93, 0x39, 0xa5, 0x2a, 0x68, 0x9a, 0xdd, 0x5b, 0xbb, 0xb6, 0x6d, 0x45, 0x82, 0xff, 0x1a, 0xf7, 0xc2, 0x20, 0x52, 0x48, 0x99, 0xa5, 0xee, 0x9a, 0x14, 0x42, 0x96, 0x6d, 0xfa, 0xdb, 0x6d, 0x98, 0xed, 0x2f, 0x74, 0x67, 0x89, 0x0, 0x8, 0x27, 0xf7, 0xbb, 0xa7, 0x74, 0x7, 0xe4, 0xb8, 0x7f, 0xa1, 0xb, 0x3b, 0x85, 0xb9, 0x24, 0x5c, 0xab, 0x9c, 0x73, 0x4a, 0x1f, 0x91, 0x59}},
+       testcase{
+               msg:       []byte{0xd1, 0x89, 0xb, 0x47, 0x4, 0xe1, 0x69, 0xc2, 0x8e, 0x44, 0xdd, 0xf6, 0x2a, 0x10, 0x91, 0x45, 0x4, 0x4, 0x91, 0x5, 0x39, 0xfc, 0x2d, 0xae, 0xb2, 0x6e, 0x8a, 0xcf, 0x45, 0x33, 0xb0, 0x24, 0xe5, 0x21, 0x5c, 0x2d, 0x2, 0x82, 0xd, 0xd8, 0xfb, 0x2c, 0xfc, 0x17, 0x43, 0x95, 0x5c, 0xba, 0xcf, 0xf0, 0xf8, 0xf3, 0x5d, 0xfb, 0xb5, 0xe3, 0xf9, 0x42, 0xf3, 0x62, 0x47, 0xf6, 0x82, 0x11, 0xd5, 0x18, 0xf3, 0xf6, 0x1, 0xaa, 0xe1, 0x2a, 0x1c, 0xdc, 0x0, 0xb, 0xab, 0x43, 0xd4, 0xc9, 0x73, 0xf2, 0x87, 0xe8, 0x7, 0x41, 0xdd, 0x1f, 0xcf, 0x6c, 0x34, 0xf2, 0xe6, 0xb4, 0xb6, 0xc3, 0x13, 0xd0, 0x1c, 0x4f, 0xf3, 0xcb, 0xf9, 0x16, 0x6f, 0x26, 0x94, 0x6f, 0x18, 0xef, 0x2d, 0x58, 0x27, 0x1b, 0xa9, 0x23, 0x3f, 0x9, 0xa6, 0xb7, 0x7b, 0xfd, 0x4f, 0x48, 0xb3, 0x6e, 0xb3, 0xd7, 0x3d, 0x11, 0x33, 0xc4, 0xf8, 0x42, 0xa7, 0xdc, 0x39, 0x7, 0xf6, 0x80, 0xb0, 0xb7, 0x73, 0x24, 0x2c, 0x11, 0xe3, 0xdd, 0x97, 0x3a, 0x44, 0x32, 0x7e, 0xa7, 0xce, 0xa9, 0xc0, 0xf8, 0xe0, 0x7d, 0x68, 0x2b, 0x66, 0x51, 0xe5, 0x6, 0xb5, 0x87, 0x55, 0x9f, 0xe0, 0x1e, 0xd7, 0x21, 0x0, 0xb, 0xaf, 0x57, 0xa, 0x16, 0xfb, 0xdd, 0x9e, 0xa2, 0x9f, 0xa3, 0xde, 0xf4, 0xbe, 0x91, 0x20, 0x58, 0x32, 0x1a, 0x8b, 0x72, 0xc, 0x5c, 0x10, 0x2e, 0x48, 0xa6, 0xe7, 0xed, 0x6f, 0x88, 0x38, 0xd4, 0x0, 0xdd, 0x57, 0xd0, 0x6e, 0xed, 0xbc, 0xd1, 0x53, 0x23, 0xf8, 0x6d, 0x85, 0x5c, 0x94, 0xb2, 0x1e, 0x41, 0xb1, 0x4e, 0xc9, 0xe1, 0xbb, 0xc8, 0x1, 0x92, 0x11, 0xfd, 0x88, 0x13, 0x8c, 0x91, 0xf9, 0xab, 0xbd, 0x9b, 0xb3, 0x91, 0x4d, 0x26, 0xc1, 0xdd, 0xc2, 0x16, 0x73, 0xd2, 0xd5, 0x12, 0x63, 0xb3, 0x9d, 0x66, 0xe7, 0x41, 0xd9, 0x24, 0xcf, 0x2b, 0x19, 0x2c, 0x5d, 0x2c, 0x1a, 0x14, 0x1, 0x26, 0xa3, 0xd6, 0x4a, 0x2c, 0x77, 0xbe, 0x6c, 0x2c, 0x6e, 0xbe, 0x85, 0x99, 0x97, 0x8a, 0xe9, 0xb, 0xd3, 0x6c, 0xbb, 0x9a, 0xf6, 0x4d, 0x7, 0x89, 0x10, 0xc4, 0x9, 0x4a, 0xb3, 0xbf, 0x39, 0x9c, 0x34, 0xf2, 0xab, 0x8e, 0xf8, 0x43, 0xe9, 0xfe, 0x1b, 0xf8, 0x8b, 0xf4, 0x43, 0xba, 0x21, 0xe4, 0x37, 0x7e, 0x5f, 0x49, 0xc0, 0x7f, 0xd9, 0x65, 0x3b, 0x52, 0x6e, 0x14, 0x56, 0x22, 0x37, 0xf0, 0x2d, 0x11, 0xb9, 0x4, 0xbc, 0xa6, 0xac, 0x31, 0xae, 0x72, 0x1a, 0x43, 0xe3, 0xc4, 0x91, 0xa, 0x24, 0xaf, 0x6f, 0x4d, 0x80, 0xc0, 0x31, 0xc1, 0x9, 0xfc, 0xf, 0xe4, 0x9f, 0x15, 0x27, 0x4b, 0xca, 0x92, 0xbd, 0xa0, 0x4c, 0x3b, 0x41, 0x96, 0xc1, 0x92, 0xf6, 0xce, 0x48, 0x9c, 0x63, 0xa8, 0x6, 0xac, 0xfc, 0x89, 0x5a, 0xb5, 0x2c, 0xad, 0x65, 0x7c, 0x17, 0x83, 0xb5, 0x28, 0xe1, 0x2d, 0xe, 0xd8, 0x56, 0xe1, 0xf8, 0xfc, 0x91, 0xf2, 0xaa, 0xfd, 0xfa, 0xa, 0x92, 0x49, 0x8d, 0x68, 0x53, 0x7, 0x72, 0xee, 0x73, 0xb3, 0x59, 0xfc, 0xf1, 0x41, 0x8d, 0x10, 0x96, 0xc4, 0x6b, 0x34, 0xdc, 0xf9, 0xe, 0x5b, 0x46, 0x8b, 0xbb, 0x29, 0x70, 0xbe, 0xcb, 0xd7, 0x0, 0x89, 0xcf, 0xb0, 0x39, 0xd6, 0x4c, 0xc5, 0xf, 0xff, 0x5e, 0xef, 0x26, 0x38, 0x4d, 0x34, 0xf2, 0x45, 0x15, 0xa6, 0x55, 0x8b, 0x6, 0xa1, 0xfd, 0xd8, 0x8f, 0x10, 0x50, 0xc5, 0xbd, 0x78, 0xcc, 0x6e, 0xd8, 0x3d, 0x4c, 0x2b, 0xe, 0x88, 0x2a, 0xeb, 0xcf, 0x84, 0xaf, 0xb0, 0x43, 0xd, 0xb, 0xf0, 0x9f, 0x2f, 0xb4, 0x2b, 0x8b, 0x45, 0x89, 0x15, 0x80, 0x93, 0xa7, 0x70, 0x9a, 0xae, 0x75, 0xa7, 0x90, 0x91, 0xe, 0x21, 0x1e, 0xe1, 0x33, 0x3f, 0xfb, 0x6f, 0xd8, 0x7, 0x78, 0xda, 0x3b, 0xf7, 0x38, 0x58, 0x97, 0x8e, 0x9d, 0xd6, 0x47, 0x97, 0x88, 0x41, 0xb1, 0x80, 0x1, 0xdb, 0xaa, 0xea, 0x43, 0xca, 0xc, 0xa, 0x3, 0xdb, 0xb9, 0xbc, 0xf3, 0xc, 0xe7, 0x6a, 0x6f, 0x4b, 0x2c, 0xf2, 0xa9, 0xb6, 0x53, 0x1b, 0x3e, 0x40, 0x51, 0xe7, 0xe0, 0x50, 0x90, 0xcd, 0x42, 0x1b, 0xc6, 0x6c, 0x47, 0x31, 0xe7, 0x12, 0x2a, 0xd1, 0x29, 0xfc, 0x42, 0xde, 0xdc, 0x83, 0xbb, 0x46, 0xe, 0x3f, 0x88, 0x99, 0x92, 0xfb, 0xd3, 0xca, 0x7, 0x26, 0x86, 0xe5, 0x6b, 0x72, 0xc7, 0x20, 0xfb, 0xc9, 0x8d, 0x72, 0x3e, 0xf7, 0xf2, 0x47, 0x28, 0x6f, 0x77, 0xcc, 0xdd, 0xc7, 0x28, 0x73, 0x8e, 0x94, 0x1b, 0x1a, 0x74, 0xd4, 0xf1, 0x66, 0x71, 0xc2, 0x1f, 0xdd, 0x56, 0x43, 0xa1, 0x15, 0xdd, 0xbc, 0xb8, 0x8e, 0xe7, 0xec, 0x67, 0xea, 0x66, 0xfd, 0x2b, 0xce, 0x71, 0x8d, 0xf6, 0xe0, 0x85, 0xd4, 0xb5, 0xfc, 0x71, 0xa7, 0x26, 0x96, 0x63, 0x6a, 0x8f, 0x7b, 0x3a, 0x68, 0xaf, 0xa5, 0x1a, 0x89, 0x67, 0x71, 0xfa, 0xaa, 0x7f, 0x1f, 0x82, 0x74, 0x30, 0xac, 0x5e, 0x80, 0x89, 0xdb, 0xc0, 0xd4, 0x17, 0x5e, 0x1b, 0x22, 0xa0, 0x57, 0xbc, 0x5f, 0x17, 0x24, 0xea, 0xdc, 0x1a, 0x41, 0xe7, 0x8f, 0xa3, 0xac, 0xaa, 0x8b, 0x97, 0xe5, 0xf2, 0xe1, 0x9e, 0xf9, 0xd5, 0x9a, 0xe1, 0x2b, 0x4, 0xe7, 0xf0, 0xe8, 0xa6, 0x21, 0xe0, 0x98, 0xa6, 0x69, 0x10, 0xe2, 0xa5, 0xed, 0x21, 0x2, 0xb8, 0x24, 0xcd, 0x3e, 0xa0, 0x44, 0xa8, 0x54, 0xf1, 0xcd, 0xb, 0x33, 0xe6, 0x1e, 0x7f, 0x73, 0x74, 0x14, 0xb2, 0x95, 0x35, 0x49, 0xf2, 0x5d, 0xd3, 0x4d, 0x19, 0xaa, 0x19, 0x81, 0xde, 0x7c, 0xd5, 0x64, 0x9f, 0xf6, 0xc6, 0x36, 0x4a, 0x4f, 0x25, 0x31, 0x2e, 0xf6, 0x23, 0x95, 0xa7, 0x47, 0xab, 0x88, 0xaa, 0xd7, 0x22, 0xc0, 0x5a, 0xec, 0x40, 0xde, 0xea, 0x8e, 0xee, 0x5e, 0x77, 0x9e, 0xf4, 0x58, 0xa6, 0x88, 0x40, 0xbc, 0x6b, 0xd5, 0xd2, 0x9a, 0xd4, 0xf, 0x98, 0xb3, 0xae, 0x1, 0xb, 0x62, 0x13, 0x37, 0x2a, 0xbb, 0x7b, 0xb8, 0xb8},
+               output224: []byte{0x97, 0x49, 0x5b, 0xfe, 0xda, 0xf1, 0xca, 0xb1, 0x8e, 0x85, 0x19, 0xb, 0x37, 0x47, 0x29, 0xf5, 0x54, 0x3f, 0xa3, 0xf1, 0xcd, 0x88, 0x43, 0x81, 0x56, 0xf0, 0x1a, 0xc},
+               output256: []byte{0xc7, 0x49, 0xb, 0x5, 0xb1, 0x72, 0xa1, 0xdb, 0xaa, 0xa6, 0x6f, 0xaa, 0x82, 0x31, 0x8, 0xd4, 0x4c, 0x82, 0xf1, 0xe8, 0x2a, 0x41, 0xfd, 0x57, 0xfd, 0x95, 0x0, 0xf, 0x30, 0xde, 0x74, 0x7e},
+               output384: []byte{0x96, 0xac, 0x67, 0xd6, 0xc9, 0xb, 0xe8, 0x1e, 0x7f, 0x5e, 0xf0, 0x52, 0xc4, 0xcd, 0xe5, 0x2c, 0x89, 0x1f, 0x48, 0xfe, 0x9e, 0x38, 0x77, 0x58, 0xda, 0x5d, 0xcd, 0xf1, 0x3a, 0x7, 0xf7, 0x5d, 0xe1, 0x7f, 0xc0, 0x3c, 0x61, 0x37, 0x99, 0x9a, 0xb1, 0xde, 0xc, 0xe9, 0xe, 0x15, 0xea, 0xd5},
+               output512: []byte{0x6e, 0x1, 0x6, 0x24, 0xe0, 0xc2, 0x58, 0x9f, 0x52, 0xa7, 0xfa, 0xbb, 0x75, 0xb0, 0x77, 0xc8, 0x6d, 0xf0, 0x4e, 0x4b, 0xe6, 0xfc, 0x73, 0x6d, 0xd0, 0x3, 0x46, 0x23, 0x13, 0x70, 0xa9, 0xa0, 0xf6, 0x71, 0x5e, 0x68, 0x3f, 0x97, 0x33, 0x22, 0x6c, 0x6a, 0xad, 0x19, 0x47, 0xeb, 0x46, 0x6c, 0x7d, 0xb7, 0x99, 0x79, 0xdd, 0x36, 0x7c, 0x33, 0x90, 0xd, 0x97, 0x27, 0xbd, 0xba, 0x24, 0xa9}},
+       testcase{
+               msg:       []byte{0xd9, 0x25, 0x70, 0x4, 0x99, 0x3c, 0x7a, 0xe5, 0xd, 0x20, 0xf5, 0x34, 0xb4, 0x2b, 0x4e, 0xc3, 0x9b, 0xf3, 0x58, 0x39, 0x3b, 0x9f, 0xb5, 0xc8, 0xe3, 0x7f, 0x87, 0xac, 0x73, 0x61, 0x35, 0x45, 0x54, 0xbe, 0x59, 0x6f, 0x40, 0xe6, 0x7b, 0x2e, 0xd4, 0x99, 0x88, 0x7e, 0x26, 0xdc, 0x43, 0x5c, 0x43, 0x31, 0xcd, 0xe3, 0xbf, 0x1a, 0x11, 0x8f, 0x60, 0xfd, 0x82, 0x14, 0x77, 0xff, 0xa3, 0xb9, 0x2f, 0x64, 0x69, 0x56, 0x8c, 0xd2, 0xcd, 0xa6, 0xfc, 0xa, 0x2b, 0x13, 0x90, 0x6a, 0xe4, 0x59, 0xcf, 0x5d, 0x54, 0x17, 0xde, 0x2c, 0xe1, 0x4, 0xd0, 0xb6, 0x49, 0x9d, 0x36, 0x83, 0xbe, 0xb4, 0x7, 0x15, 0x58, 0x2c, 0xe7, 0xd, 0xed, 0x5c, 0x5f, 0x84, 0x61, 0xed, 0xea, 0xa3, 0x8b, 0xfa, 0x31, 0x97, 0x96, 0x61, 0xa2, 0xdc, 0x96, 0xd9, 0x26, 0x30, 0x71, 0x28, 0xf7, 0x77, 0x0, 0xf2, 0xc7, 0xd3, 0x8b, 0x8a, 0x9d, 0x6c, 0x6f, 0x70, 0xa3, 0x97, 0x30, 0x5, 0x35, 0xf, 0x93, 0x8b, 0x9b, 0x4a, 0x64, 0xe2, 0x28, 0xcc, 0x3b, 0x3f, 0x9c, 0x4f, 0xd4, 0x46, 0xfc, 0x65, 0xa, 0xa6, 0x37, 0x71, 0x52, 0xd7, 0xf4, 0x69, 0x3, 0xd8, 0xec, 0x8e, 0x93, 0x40, 0x71, 0xe, 0x28, 0x47, 0x5c, 0xf2, 0x1e, 0x64, 0x17, 0x37, 0xe7, 0xd7, 0xda, 0x3c, 0xdf, 0x18, 0xd0, 0x1c, 0x8f, 0x37, 0x13, 0x1e, 0x72, 0x7c, 0x72, 0x74, 0xb2, 0xdb, 0x75, 0x9c, 0x55, 0x86, 0xfb, 0x84, 0xec, 0x36, 0xa5, 0xce, 0x2d, 0x82, 0xe, 0x55, 0x3d, 0xe6, 0x42, 0x6b, 0x8b, 0x96, 0x11, 0x12, 0x95, 0xc1, 0x9d, 0xba, 0x8d, 0x17, 0xa2, 0xb7, 0x4, 0x7f, 0xcd, 0xf6, 0x62, 0xa5, 0x9c, 0x2a, 0xf2, 0x7a, 0x9a, 0xbe, 0xe3, 0x7a, 0x7f, 0x8a, 0xfc, 0x6, 0x94, 0x43, 0x46, 0xe3, 0x43, 0xe7, 0x79, 0xeb, 0xd8, 0x95, 0x11, 0x9d, 0x74, 0x60, 0xe7, 0xda, 0x99, 0x89, 0x62, 0xfb, 0x11, 0x0, 0xe9, 0x50, 0xa8, 0xd7, 0xfe, 0x21, 0x43, 0x60, 0xad, 0x26, 0x3b, 0x8d, 0x7, 0xf, 0x2b, 0x7d, 0xc9, 0x1c, 0x9d, 0x77, 0xc6, 0x69, 0x2d, 0xa0, 0xf4, 0x72, 0xa0, 0xa4, 0x64, 0x6a, 0x1e, 0xdb, 0x6, 0x9c, 0xcd, 0x9c, 0xe4, 0xca, 0x6f, 0xc2, 0x47, 0x13, 0xd6, 0x50, 0x15, 0x3b, 0x9a, 0x25, 0x3d, 0xb5, 0x13, 0x6a, 0x37, 0x10, 0x19, 0x8e, 0x60, 0x93, 0x4d, 0xd2, 0x5, 0x33, 0x15, 0xd3, 0x13, 0xe2, 0x7d, 0xd2, 0xc6, 0xff, 0xd2, 0xec, 0xf0, 0x28, 0x62, 0x5f, 0xe, 0x93, 0x7a, 0xfd, 0x8c, 0x2f, 0xfb, 0x1f, 0x64, 0x6e, 0x51, 0xa7, 0x68, 0x20, 0x4d, 0x83, 0xa6, 0x49, 0x79, 0x8a, 0x51, 0xb8, 0xe8, 0x7f, 0xcd, 0xda, 0x7b, 0xdd, 0xf5, 0x8e, 0xd9, 0x43, 0xbb, 0x7e, 0x29, 0xc7, 0xd7, 0xc5, 0xdf, 0xf0, 0x24, 0x54, 0x5f, 0x6a, 0x68, 0x9a, 0xa0, 0xe7, 0x27, 0xfe, 0xcd, 0x80, 0xb5, 0x61, 0x1, 0x1a, 0x73, 0x1a, 0xcd, 0xd9, 0xb3, 0xf2, 0x83, 0x12, 0x30, 0x98, 0xba, 0x66, 0xb6, 0xb9, 0xfc, 0xe6, 0x12, 0x3b, 0x35, 0xb6, 0xf3, 0xa2, 0xe, 0xf1, 0x5, 0x5b, 0xe9, 0xe2, 0x57, 0xcd, 0xe9, 0x7e, 0x5a, 0xf4, 0x1e, 0xb7, 0x96, 0x43, 0x87, 0x27, 0xa6, 0x2a, 0xa6, 0x65, 0xcc, 0x9b, 0x77, 0x1c, 0x4a, 0x20, 0x52, 0xef, 0xac, 0x61, 0xbc, 0x91, 0xbc, 0xdf, 0x57, 0x3f, 0x72, 0x63, 0x10, 0x7d, 0x44, 0xdf, 0xeb, 0x12, 0x5e, 0x66, 0xd1, 0xf3, 0xdd, 0xed, 0x3b, 0xd6, 0x38, 0x45, 0xaf, 0x3b, 0xf4, 0x18, 0x5a, 0x9a, 0x24, 0xa7, 0xf4, 0xb7, 0x77, 0xc3, 0x24, 0x96, 0xa6, 0x10, 0x7b, 0x7a, 0xc9, 0x40, 0xaf, 0x24, 0xbe, 0x98, 0x3f, 0x6a, 0x75, 0x8e, 0x50, 0x64, 0xf8, 0x71, 0x7e, 0xab, 0xbb, 0x86, 0xe6, 0xaa, 0xda, 0x7d, 0xa7, 0x5f, 0x72, 0xab, 0xed, 0x59, 0xa4, 0x2d, 0xe8, 0x2b, 0x1a, 0xa2, 0x64, 0x2f, 0x5e, 0xf1, 0xb2, 0xe7, 0x30, 0x4f, 0x64, 0x2e, 0xb2, 0xaa, 0xfb, 0xf0, 0xc, 0x11, 0x83, 0xd9, 0xb5, 0xfb, 0x83, 0x89, 0x3e, 0xdd, 0x48, 0xe9, 0x3, 0x4d, 0xc7, 0xa7, 0xab, 0x66, 0xf3, 0xf3, 0x92, 0xf9, 0x66, 0x6c, 0x0, 0xec, 0xc9, 0x74, 0x3a, 0xc4, 0xf7, 0x77, 0xed, 0xcf, 0x47, 0xb6, 0x81, 0x8a, 0x34, 0xb7, 0x39, 0x2b, 0x4a, 0xb8, 0xe3, 0x88, 0x91, 0xfa, 0xb4, 0x1, 0x8d, 0xfb, 0x99, 0xaf, 0x6, 0x36, 0x91, 0x15, 0xd6, 0xc, 0x4f, 0xa0, 0x73, 0x24, 0xd, 0x9c, 0x26, 0x5, 0xe0, 0x20, 0xa4, 0x2d, 0xb2, 0xe1, 0xe0, 0xae, 0x4a, 0xde, 0x3a, 0x4, 0xb8, 0x25, 0x92, 0x7a, 0x5, 0xd4, 0xfe, 0x3f, 0x50, 0xc1, 0xc7, 0xad, 0xd7, 0xa4, 0x96, 0xda, 0x7e, 0x95, 0x82, 0x5c, 0x6, 0x43, 0x15, 0x19, 0x6c, 0x20, 0x7, 0x52, 0x4d, 0x1e, 0x1e, 0xf2, 0xc5, 0x13, 0x3, 0xdd, 0x12, 0x3, 0xab, 0x66, 0xd9, 0xfe, 0x89, 0xde, 0x55, 0x3c, 0xb4, 0xb9, 0x5a, 0x6c, 0x5d, 0x62, 0x9b, 0x89, 0xb7, 0x11, 0x64, 0x63, 0xee, 0x10, 0xab, 0x3c, 0xf2, 0xc2, 0x61, 0x5f, 0x95, 0x74, 0x1c, 0xa2, 0x26, 0xf9, 0xe9, 0xa2, 0xe, 0x99, 0x30, 0x38, 0x88, 0xf7, 0x25, 0xc7, 0x74, 0x76, 0x53, 0x3b, 0x4c, 0x39, 0x37, 0x63, 0x17, 0xf, 0x18, 0xf2, 0x92, 0xc8, 0x9a, 0x22, 0xdf, 0x68, 0xea, 0xbd, 0xb8, 0x1a, 0xef, 0x11, 0xcc, 0x2a, 0xc3, 0x29, 0xc1, 0x74, 0xbd, 0xae, 0x5d, 0x3c, 0xc0, 0xbd, 0xce, 0xa6, 0xeb, 0x22, 0x5e, 0x0, 0xc1, 0x50, 0x21, 0x43, 0x22, 0x64, 0xba, 0x7c, 0x5e, 0xb4, 0x9a, 0x49, 0x23, 0x1d, 0x1f, 0x7a, 0x13, 0xaf, 0xc2, 0x38, 0xbd, 0x4e, 0xfc, 0x4, 0xda, 0x3c, 0x15, 0xae, 0xb, 0xb7, 0xd6, 0x93, 0xa0, 0x15, 0xe, 0x6a, 0x5a, 0xd9, 0xb1, 0xe1, 0x1a, 0x49, 0xb, 0x3c, 0xe9, 0xc, 0x2, 0x74, 0x42, 0x50, 0x16, 0x84, 0xc5, 0x28, 0xfe, 0x26, 0x8, 0x81, 0x16, 0x2d, 0x9e, 0x5e, 0xf8, 0x4d, 0x6e, 0x4f, 0x73, 0xf2, 0x22, 0xe7, 0x79, 0xe5, 0x8b, 0x71, 0xd5, 0x17, 0x6d, 0x9a, 0x27, 0xf6, 0x5e, 0x49, 0xd8, 0x3e, 0xfb, 0xb2, 0xd7, 0x81, 0xe, 0x5b, 0x6, 0x61, 0x9d, 0x8c, 0xef, 0x7e, 0x7b, 0x51, 0xcd, 0xfb, 0x6e, 0x81, 0x38, 0xe4, 0xcf, 0x56, 0x74, 0x24, 0x2f, 0x94, 0x7e, 0xac, 0x13, 0xfa, 0xd0, 0x8d, 0x68, 0xa8, 0xa1, 0x1a, 0xac, 0x97, 0x54, 0xa5, 0x31, 0x6c, 0x93, 0x73, 0x8b, 0xa7, 0xf3, 0xc3, 0xbd, 0x2e, 0x82, 0x7a},
+               output224: []byte{0xb9, 0xcb, 0xbf, 0x5f, 0x95, 0x4c, 0xfe, 0x7a, 0x56, 0x17, 0xa1, 0x7d, 0xad, 0x9c, 0x43, 0x9f, 0xbf, 0x2a, 0x7, 0x1e, 0xfb, 0x4f, 0x3c, 0x23, 0x3c, 0xb, 0x3d, 0xf0},
+               output256: []byte{0x18, 0x36, 0x42, 0x46, 0x8b, 0xe2, 0x70, 0x7c, 0x33, 0x49, 0x13, 0x2c, 0xd3, 0xb0, 0x63, 0x3a, 0xa6, 0x3e, 0x57, 0x52, 0x48, 0x8c, 0x3a, 0xdc, 0xd, 0x50, 0x12, 0x65, 0xff, 0x5, 0x29, 0xb0},
+               output384: []byte{0x98, 0x72, 0xc7, 0xe0, 0x59, 0x40, 0x6, 0xc8, 0xb5, 0x9c, 0x37, 0x19, 0xaf, 0x32, 0x82, 0x1a, 0x60, 0xc, 0x26, 0x4d, 0x5e, 0xde, 0x1e, 0x16, 0x8f, 0x3f, 0x8c, 0x3f, 0x94, 0xfe, 0xd3, 0x7e, 0xcc, 0xb1, 0x30, 0xc0, 0x41, 0x29, 0x3, 0x93, 0xf3, 0x2d, 0xf6, 0x9f, 0x4, 0xf7, 0x8, 0xf9},
+               output512: []byte{0x1c, 0x91, 0x35, 0xe7, 0x9d, 0x19, 0xd0, 0x5f, 0x45, 0xe3, 0x25, 0x20, 0x1, 0x21, 0x99, 0xb4, 0xa4, 0x63, 0x33, 0xb5, 0x48, 0xa5, 0xa5, 0xf2, 0x61, 0x6a, 0xfc, 0x78, 0x92, 0x3e, 0x6, 0x4f, 0x1f, 0x21, 0xea, 0x2, 0x49, 0x67, 0x0, 0x54, 0x7e, 0xcc, 0x19, 0xd3, 0x34, 0x51, 0x2d, 0xfe, 0x93, 0x20, 0x19, 0x50, 0x5b, 0xa6, 0x44, 0x81, 0x45, 0x87, 0x9d, 0x42, 0xb2, 0xab, 0x72, 0x2f}},
+       testcase{
+               msg:       []byte{0x9, 0xcf, 0x13, 0x2a, 0xb9, 0x43, 0x65, 0x41, 0x84, 0xa3, 0xfc, 0x8d, 0x3, 0x68, 0xb4, 0x21, 0xfd, 0xac, 0x4e, 0xf1, 0x8, 0x1a, 0x29, 0xf3, 0x69, 0x1a, 0x52, 0x7f, 0xbd, 0xbd, 0x74, 0xc6, 0x37, 0x22, 0x33, 0xb3, 0x8d, 0xc4, 0x32, 0xba, 0x61, 0xf, 0x9c, 0x54, 0xfa, 0x68, 0x69, 0x9f, 0x9e, 0xc2, 0xa6, 0xbf, 0xb0, 0xb2, 0xcf, 0x7a, 0xa6, 0xd1, 0xa, 0xe2, 0x20, 0x7a, 0x75, 0x54, 0x16, 0x3a, 0xa1, 0x4f, 0xb6, 0xa9, 0xcf, 0xa0, 0x23, 0xce, 0x63, 0x54, 0x6b, 0x7b, 0x2, 0xaf, 0x3, 0x37, 0xa, 0x89, 0x9e, 0xa7, 0x3b, 0x27, 0xbd, 0xb5, 0xc3, 0x80, 0x61, 0x3c, 0xe, 0xa6, 0x70, 0xc6, 0x59, 0x80, 0x3d, 0x5f, 0x6f, 0x75, 0xc0, 0xce, 0x62, 0xb3, 0x11, 0xdc, 0x15, 0x7d, 0xe8, 0x43, 0xa9, 0x39, 0x5, 0xe7, 0xa2, 0x8a, 0x25, 0x57, 0x68, 0x4a, 0xe3, 0xdb, 0x4f, 0xd0, 0x9, 0x41, 0x2a, 0x10, 0x70, 0x98, 0xf8, 0x81, 0xdc, 0x6, 0x62, 0x2e, 0xd9, 0xe3, 0xdf, 0x2c, 0x8f, 0xe6, 0x9f, 0xe5, 0xb, 0xfa, 0xe1, 0x58, 0xb8, 0x7c, 0xa7, 0x61, 0xfe, 0x1e, 0x22, 0x18, 0x56, 0x61, 0xb, 0xca, 0x30, 0x1e, 0xe6, 0x89, 0x58, 0xc2, 0x5b, 0xf5, 0x8d, 0x3b, 0xe2, 0x3, 0xaf, 0x92, 0x8a, 0x91, 0x9a, 0xce, 0x53, 0xc3, 0xd9, 0x9f, 0x55, 0xab, 0x0, 0xdf, 0xc8, 0xa1, 0xa2, 0x8a, 0xb8, 0x3e, 0x78, 0x61, 0x7f, 0x19, 0x4e, 0xfc, 0x46, 0xda, 0xa7, 0x75, 0x73, 0xd0, 0x2f, 0xfc, 0xaa, 0x1f, 0x9d, 0x96, 0xfd, 0x8d, 0xa8, 0xde, 0xad, 0x3d, 0x4e, 0x75, 0xee, 0x5e, 0x65, 0xfc, 0x36, 0xb, 0x2a, 0x56, 0x7c, 0xd3, 0x4d, 0x52, 0xbc, 0x9a, 0xab, 0x8b, 0x71, 0x16, 0x3, 0x12, 0xe8, 0xe2, 0x1a, 0xa5, 0x6, 0x10, 0x5d, 0x66, 0x44, 0xe6, 0x86, 0x3e, 0x7d, 0x5e, 0x75, 0xed, 0x47, 0xc1, 0x76, 0x7, 0x43, 0xd1, 0x13, 0xa4, 0x52, 0x65, 0x53, 0xb3, 0x3, 0x34, 0x1f, 0xce, 0xe5, 0xfd, 0xd0, 0x5, 0xd3, 0x59, 0x29, 0xf2, 0xaf, 0xa7, 0x60, 0xbb, 0x83, 0x14, 0xd0, 0xc0, 0xea, 0xc9, 0x60, 0xfd, 0xa3, 0x26, 0x3a, 0x1e, 0x66, 0x88, 0x9, 0x82, 0x51, 0x61, 0x8c, 0x90, 0x33, 0x20, 0x5, 0xc7, 0x57, 0xaf, 0x95, 0x87, 0x14, 0x57, 0x1b, 0x77, 0xbf, 0x2a, 0x69, 0x3, 0xd, 0x99, 0xf7, 0x1d, 0x1a, 0x52, 0x59, 0x65, 0x8b, 0xe5, 0x65, 0xfb, 0xd0, 0x98, 0x7, 0x1, 0x22, 0xc4, 0x3e, 0xdf, 0xd4, 0x0, 0x99, 0x9c, 0x90, 0xa9, 0x8a, 0xce, 0x95, 0x31, 0x5f, 0xae, 0xe4, 0xf1, 0xc0, 0x44, 0x1c, 0x93, 0x15, 0xd5, 0x27, 0xc7, 0xff, 0x1a, 0x81, 0x71, 0x41, 0x5d, 0x2a, 0x7, 0x6e, 0x2c, 0x51, 0x3d, 0x40, 0xb0, 0x3c, 0xfe, 0x55, 0x13, 0xc0, 0xe7, 0x4e, 0xa3, 0xa0, 0x3a, 0xd4, 0x95, 0x8c, 0x0, 0xa3, 0xe1, 0x91, 0x6d, 0x34, 0x27, 0x3e, 0x30, 0x1d, 0x51, 0x7b, 0xa, 0x5e, 0x77, 0x3, 0x93, 0x88, 0xd, 0x9a, 0xfb, 0x4d, 0xe, 0xb4, 0x4d, 0x31, 0x40, 0xff, 0x7d, 0x82, 0x7c, 0x48, 0xf6, 0x7c, 0x6d, 0x92, 0xb8, 0x65, 0xd8, 0xfe, 0x7c, 0x7e, 0x45, 0xaa, 0x50, 0xdf, 0xd8, 0x52, 0x5f, 0x53, 0xd, 0xe1, 0x18, 0x8f, 0x3a, 0xf9, 0x8b, 0x3d, 0xc6, 0x25, 0xd3, 0x35, 0xe1, 0x91, 0xfb, 0xad, 0x5e, 0xe9, 0xdf, 0x9, 0xc9, 0x7b, 0x43, 0xf2, 0x3, 0xbf, 0xed, 0x79, 0x8f, 0x7d, 0x17, 0x1b, 0xf0, 0xc, 0x82, 0xea, 0xe, 0xd1, 0x7d, 0x58, 0x90, 0xc3, 0xd6, 0xb9, 0xef, 0x6f, 0xdc, 0x4, 0xc5, 0xff, 0xb6, 0x45, 0xe3, 0x5, 0x4, 0x6, 0xfe, 0x2f, 0xb6, 0xbd, 0xbe, 0x2f, 0xfe, 0x8, 0x3e, 0x75, 0x1d, 0xc1, 0x9f, 0x2f, 0x6, 0x44, 0x53, 0x97, 0x1, 0x9b, 0x61, 0xcf, 0x1f, 0x50, 0x58, 0x75, 0x52, 0xf, 0x9, 0xc6, 0xb7, 0x19, 0xe6, 0x42, 0xb8, 0x1b, 0x2f, 0xbf, 0xbd, 0xcc, 0x7, 0x2b, 0x79, 0x81, 0xa6, 0x66, 0xd5, 0x1e, 0x70, 0x65, 0xe2, 0x12, 0x44, 0x67, 0x9d, 0xfe, 0x5, 0x6b, 0xc9, 0xd4, 0x2b, 0x88, 0x51, 0xf9, 0xd2, 0x90, 0x5f, 0xd8, 0x38, 0x70, 0x7b, 0x27, 0x9a, 0x81, 0x6, 0xeb, 0x89, 0x4b, 0x60, 0xa7, 0x2e, 0x48, 0x51, 0xc3, 0x44, 0x11, 0x9c, 0xee, 0xb5, 0xbb, 0xe1, 0x10, 0xb1, 0xc5, 0xb2, 0x1c, 0x9a, 0x5f, 0x75, 0x45, 0x28, 0x30, 0x2, 0xd4, 0xb1, 0xc1, 0x15, 0x30, 0x8b, 0x1c, 0xb2, 0xf, 0x6d, 0x9c, 0xb8, 0x69, 0xed, 0x4, 0x59, 0xc5, 0x69, 0x66, 0x2a, 0xa5, 0x72, 0x9a, 0x7d, 0x71, 0x78, 0xde, 0x7d, 0x69, 0xe4, 0x88, 0x5c, 0xa7, 0x7c, 0x1, 0x1e, 0x78, 0x5e, 0xcf, 0xe, 0x2e, 0xcb, 0xb8, 0xf5, 0x24, 0x55, 0x79, 0xdb, 0xef, 0x7a, 0x5e, 0xb3, 0x3, 0x7, 0xe0, 0xb4, 0xb, 0x81, 0x7b, 0xd1, 0x11, 0x2d, 0x28, 0xee, 0xfd, 0x54, 0x83, 0x74, 0xbc, 0x86, 0x7e, 0xc, 0x34, 0xd2, 0x23, 0x69, 0x52, 0xb9, 0xf8, 0x59, 0x90, 0x3e, 0x87, 0xe9, 0x77, 0x19, 0xf, 0xf9, 0x4f, 0x5d, 0x81, 0x56, 0x99, 0x15, 0x4f, 0x96, 0xe5, 0x44, 0x9d, 0xdc, 0x1a, 0x14, 0xe4, 0x19, 0x6c, 0x83, 0xe4, 0xfb, 0x2, 0xf5, 0xf5, 0x8c, 0x30, 0xee, 0xed, 0x69, 0x1d, 0xe4, 0x7c, 0x81, 0xf4, 0x88, 0x3b, 0xd8, 0x4f, 0x6e, 0xd7, 0x11, 0xfe, 0xd0, 0xc1, 0x98, 0xbf, 0xa2, 0xb8, 0x29, 0x61, 0x82, 0xd7, 0x22, 0x5e, 0x89, 0x89, 0xac, 0xf5, 0x5d, 0x36, 0x12, 0xa9, 0x3e, 0x77, 0xd2, 0x4f, 0x7b, 0x6e, 0xef, 0x81, 0x3f, 0xd5, 0x14, 0xce, 0x21, 0x83, 0x57, 0x16, 0x2, 0x97, 0x63, 0x91, 0xf5, 0xac, 0x4e, 0x86, 0xda, 0x59, 0xa6, 0x42, 0x33, 0x23, 0xf, 0xb6, 0x7f, 0xf0, 0xbb, 0x9e, 0xc4, 0x6, 0x67, 0xf5, 0x4c, 0xcb, 0x23, 0x5d, 0x4, 0xb3, 0xfe, 0x1d, 0x9a, 0x47, 0xe1, 0x63, 0xcb, 0x19, 0xc3, 0x16, 0x4, 0x6f, 0xc1, 0x35, 0x3a, 0x66, 0x42, 0x21, 0x9e, 0x9c, 0xec, 0xf6, 0xe3, 0x15, 0x1c, 0xf, 0x4f, 0xae, 0x11, 0x77, 0xb6, 0x7f, 0x19, 0xb4, 0x96, 0x4d, 0xf9, 0x6b, 0xb6, 0xaf, 0x37, 0x1, 0x2b, 0x8e, 0xa9, 0xe5, 0xee, 0x24, 0xc5, 0x7a, 0x1, 0xc, 0x87, 0x2b, 0x15, 0xc8, 0xa6, 0x5d, 0x2, 0x66, 0x58, 0x9f, 0x6d, 0xa2, 0xe, 0x38, 0xd9, 0xbe, 0x2e, 0x2c, 0x21, 0x5c, 0x69, 0xf5, 0x58, 0x8, 0x4e, 0x48, 0xee, 0xb6, 0x1f, 0x4e, 0xaa, 0xe8, 0x3c, 0x57, 0xf3, 0xf1, 0xcd, 0x8, 0xd0, 0x57, 0x83, 0xfb, 0x9f, 0x5a, 0xb1, 0xcd, 0xa5, 0xe4, 0xb8, 0x62, 0x91, 0xff, 0xfb, 0x14, 0xfe, 0x9b, 0x49, 0x7e, 0xc7, 0x32, 0x92, 0xbb, 0xd2, 0x95, 0xc5, 0x65, 0x7d, 0x71, 0xcc, 0x74, 0xd3, 0x8a, 0x2f, 0x3d, 0xb7, 0x3b, 0xa9, 0x72, 0x98, 0x6b, 0x71, 0x69, 0xf7, 0x6b, 0xa3, 0x76, 0x37, 0x6f, 0x47, 0x47, 0xed, 0x65, 0xf2, 0xf1, 0xa5, 0xe6, 0x78, 0x89, 0xaf, 0x38, 0xa3, 0x80},
+               output224: []byte{0x65, 0x76, 0x51, 0xaa, 0x8d, 0x87, 0x15, 0xdb, 0x57, 0xff, 0x7f, 0x18, 0xea, 0x1f, 0x2a, 0x8c, 0xcd, 0xbc, 0x2d, 0x5b, 0xbe, 0xe8, 0xa5, 0x10, 0xeb, 0x3d, 0x3a, 0x27},
+               output256: []byte{0xca, 0x37, 0x2b, 0xec, 0xea, 0xbf, 0x81, 0x70, 0xb0, 0x11, 0x27, 0xad, 0xd4, 0xd3, 0xf7, 0x9, 0xe1, 0x26, 0x7a, 0xfb, 0x3e, 0xfb, 0x42, 0x71, 0xe2, 0xe6, 0x8f, 0xe9, 0x55, 0x8, 0x3, 0x67},
+               output384: []byte{0xee, 0x36, 0x27, 0x83, 0x2f, 0xbd, 0xf2, 0x54, 0xae, 0xd7, 0x1, 0x85, 0xd6, 0x8d, 0xbf, 0x87, 0x3c, 0x5f, 0x54, 0x82, 0xb6, 0xd1, 0x56, 0x38, 0x13, 0x88, 0xdf, 0xac, 0x4f, 0x33, 0x6b, 0x8e, 0x0, 0x5e, 0xed, 0xd2, 0xb8, 0x29, 0x8c, 0xa0, 0x9, 0x7, 0x88, 0xf0, 0xa6, 0xfa, 0x5f, 0x52},
+               output512: []byte{0x75, 0xff, 0x7d, 0x8f, 0xa4, 0xb9, 0x37, 0xb, 0x5b, 0x81, 0xdd, 0x88, 0xb6, 0x46, 0xa2, 0xb5, 0x46, 0x3a, 0x8f, 0xfa, 0x49, 0x82, 0xfb, 0x90, 0xc5, 0x5b, 0x68, 0x1c, 0x27, 0x16, 0x19, 0x20, 0x8a, 0x1b, 0x24, 0xde, 0xa3, 0x2f, 0x79, 0xf1, 0x9d, 0x9a, 0x96, 0xdc, 0x64, 0x20, 0x96, 0xa5, 0xae, 0xc2, 0xaa, 0xd8, 0x28, 0xb3, 0x8e, 0x42, 0xcf, 0x3d, 0x9e, 0xc7, 0xf1, 0x23, 0x93, 0xbf}},
+       testcase{
+               msg:       []byte{0x67, 0xb, 0x79, 0xc6, 0x3, 0xd, 0xa4, 0x36, 0x91, 0x46, 0xa7, 0xf1, 0x4e, 0x6b, 0xd3, 0x93, 0xdf, 0x72, 0x9b, 0x60, 0x36, 0x9d, 0x3d, 0x55, 0x46, 0x1e, 0x51, 0x87, 0xd4, 0xf8, 0xe8, 0x31, 0x14, 0xb2, 0x27, 0x52, 0x4e, 0xe9, 0x55, 0xf6, 0x4a, 0x2c, 0x60, 0x7d, 0xa8, 0x50, 0x23, 0x5a, 0x1b, 0x49, 0xfe, 0xc6, 0xeb, 0x51, 0xed, 0xc2, 0x19, 0x41, 0xdc, 0xc6, 0x7b, 0xd0, 0x74, 0x12, 0xcf, 0xe0, 0x58, 0xaf, 0x45, 0x5, 0xc3, 0x25, 0xd9, 0x49, 0x36, 0xee, 0x36, 0xde, 0x41, 0x33, 0x77, 0x3a, 0xcf, 0x66, 0x95, 0x15, 0xda, 0xf4, 0xed, 0x87, 0x50, 0x85, 0x89, 0xcf, 0x65, 0x17, 0x84, 0xa8, 0xc3, 0x82, 0xa, 0x88, 0xfb, 0xf7, 0xcb, 0x60, 0xe2, 0xa, 0x3, 0x5e, 0xcd, 0x6, 0x40, 0x5b, 0x50, 0xf6, 0xa1, 0x3a, 0x36, 0xe1, 0x74, 0x92, 0x5b, 0x4e, 0x33, 0x4e, 0x19, 0x7e, 0x1e, 0x5f, 0xe8, 0x68, 0x36, 0xac, 0xbc, 0x1a, 0xc6, 0x81, 0xcf, 0xd4, 0x2b, 0x2f, 0x11, 0xf7, 0x45, 0x87, 0x66, 0xd, 0xe8, 0x67, 0xeb, 0xba, 0x72, 0x22, 0xc3, 0xe8, 0x9b, 0x42, 0x95, 0x7a, 0xc4, 0x50, 0x8f, 0x9, 0xb2, 0xde, 0x9c, 0x3b, 0x57, 0xc8, 0x83, 0x13, 0x8f, 0xd, 0x44, 0x2a, 0x5, 0xd, 0x8a, 0xa3, 0x2, 0x3e, 0xa9, 0x20, 0x14, 0xf, 0x70, 0x23, 0x7a, 0xb2, 0x14, 0xbe, 0x9f, 0xa0, 0xc4, 0x52, 0xc5, 0x4b, 0x50, 0x20, 0x7, 0x7e, 0xcc, 0x1f, 0x5d, 0xdf, 0x5d, 0x95, 0x9a, 0x5a, 0xae, 0xaa, 0xcb, 0x38, 0x13, 0x55, 0xfd, 0x7b, 0x49, 0x3a, 0x1a, 0x51, 0xce, 0x83, 0xe6, 0xeb, 0x52, 0xcc, 0x61, 0x21, 0x4a, 0x2, 0xfa, 0xfb, 0x1, 0x59, 0x3d, 0x57, 0x30, 0xc7, 0x5, 0x8b, 0xf9, 0x10, 0x6b, 0x83, 0x14, 0xf1, 0x0, 0x52, 0x36, 0xe5, 0xbe, 0xce, 0xb3, 0x80, 0x5b, 0xac, 0x8f, 0xc4, 0x30, 0x8b, 0x20, 0x7, 0x82, 0x3b, 0xbd, 0xb3, 0xdc, 0x25, 0x4, 0x2d, 0x6a, 0xb7, 0x74, 0x59, 0x41, 0xb0, 0x55, 0xa7, 0x64, 0x8f, 0x99, 0xff, 0xda, 0xca, 0xca, 0x98, 0x1, 0x9, 0x4e, 0xa8, 0x6d, 0xbc, 0x9d, 0x2e, 0xf2, 0xb6, 0x1a, 0x97, 0xad, 0x5f, 0xb9, 0xff, 0x75, 0x41, 0x90, 0xa5, 0x29, 0xce, 0x65, 0xfe, 0x46, 0xaf, 0xda, 0x3c, 0xe, 0xae, 0xe, 0xc9, 0x8e, 0xd5, 0xb0, 0x89, 0x14, 0x8b, 0xe3, 0x58, 0xa8, 0xab, 0xa6, 0xb2, 0xf0, 0x14, 0xa5, 0xb7, 0x45, 0x47, 0xfd, 0xc0, 0x5, 0x1, 0xdd, 0xb1, 0x47, 0x2e, 0xf4, 0xad, 0x59, 0x2e, 0xfa, 0x80, 0x31, 0xb0, 0xa4, 0x37, 0x6d, 0xcc, 0xea, 0x87, 0x14, 0x57, 0x5b, 0xf0, 0x55, 0xb1, 0x2, 0x78, 0x24, 0xf4, 0x63, 0xe8, 0xaf, 0x11, 0xc, 0xcb, 0x52, 0x1b, 0x2f, 0x13, 0x63, 0xc0, 0xf1, 0x32, 0x56, 0xb7, 0x68, 0x64, 0x5a, 0x3, 0x77, 0x54, 0x1c, 0xf2, 0xf7, 0x3d, 0xa0, 0x3a, 0xf0, 0xc0, 0x26, 0xe5, 0x95, 0x70, 0xd6, 0x0, 0x7b, 0xaf, 0xc2, 0x97, 0xa4, 0x1d, 0xee, 0xeb, 0x32, 0xe7, 0x93, 0x64, 0xf9, 0xef, 0xff, 0x6f, 0x81, 0xb6, 0x9f, 0xdb, 0x99, 0xdb, 0xae, 0x4d, 0xdb, 0xa4, 0x60, 0x16, 0xf8, 0x6b, 0xe1, 0x15, 0x76, 0x93, 0xc6, 0x3c, 0xbc, 0xfe, 0x24, 0xc7, 0xb6, 0xdb, 0xc2, 0x26, 0x7, 0x98, 0xa6, 0xc3, 0x97, 0xbd, 0x91, 0xd4, 0xab, 0xe0, 0xd5, 0xc2, 0x3b, 0x43, 0x76, 0x9b, 0xb, 0xa2, 0x8b, 0x6b, 0x95, 0x4e, 0x66, 0x3, 0x5b, 0xdc, 0x52, 0xde, 0x3, 0xb3, 0x3c, 0xa0, 0x4, 0xb6, 0x70, 0xea, 0x6e, 0x34, 0x1b, 0x1, 0xad, 0xbc, 0x40, 0xde, 0x2f, 0x40, 0x6b, 0xfc, 0x46, 0x91, 0x22, 0xee, 0x30, 0x19, 0x21, 0x38, 0x86, 0x83, 0x26, 0xbb, 0x64, 0x28, 0x34, 0xf9, 0xe7, 0x8f, 0x51, 0x97, 0x6c, 0x3e, 0x6e, 0xa0, 0xef, 0xa5, 0x70, 0x92, 0x6f, 0x47, 0x61, 0x2c, 0xd0, 0x70, 0x2e, 0xa8, 0x22, 0x79, 0xd6, 0xe, 0x6, 0x28, 0x32, 0xd3, 0x17, 0x85, 0x93, 0x3e, 0x3b, 0xeb, 0x86, 0xd1, 0x87, 0x55, 0x4a, 0x16, 0x75, 0xa6, 0x1f, 0xb0, 0xb8, 0x65, 0x9, 0x2e, 0x51, 0x8a, 0xd3, 0x29, 0xf3, 0x8a, 0x70, 0xe7, 0xdb, 0xd6, 0x2, 0x5c, 0x99, 0x25, 0xfb, 0x3, 0x32, 0xb5, 0xed, 0x97, 0xe7, 0x71, 0x34, 0xb8, 0x68, 0x4f, 0x6f, 0x16, 0x7e, 0xa6, 0x39, 0xfe, 0x65, 0x45, 0xfa, 0xe5, 0x8b, 0x61, 0x19, 0x22, 0x85, 0x5b, 0x44, 0xe5, 0x20, 0x60, 0x1d, 0xd0, 0x75, 0x83, 0x19, 0xe9, 0x49, 0x1a, 0x12, 0x29, 0xdc, 0x49, 0xf9, 0xf6, 0xf9, 0xee, 0xad, 0xd9, 0xce, 0x88, 0xce, 0x91, 0xe3, 0xbd, 0x3d, 0x13, 0xf6, 0x4e, 0xd7, 0x74, 0x52, 0x80, 0xf4, 0x82, 0x8d, 0x3a, 0x0, 0xd6, 0x6f, 0x39, 0x66, 0xe0, 0xee, 0xdf, 0x93, 0xf, 0x56, 0x3d, 0x8e, 0x48, 0xed, 0x94, 0xbe, 0x42, 0xce, 0x5f, 0x48, 0xe9, 0x2e, 0x3f, 0x2d, 0x80, 0x1f, 0xfc, 0x46, 0x46, 0x92, 0xc1, 0xe, 0x73, 0x0, 0xab, 0xf, 0x85, 0xd1, 0xd4, 0x4f, 0x35, 0x3c, 0x74, 0x2e, 0x20, 0xde, 0x37, 0x6, 0xbb, 0xa4, 0xb2, 0x4a, 0xc0, 0x4, 0x8e, 0xa6, 0xe0, 0xb4, 0x4, 0x54, 0xb0, 0x6f, 0xa9, 0x5e, 0x5d, 0xc2, 0x95, 0x1c, 0xb4, 0xb0, 0xa7, 0xd1, 0xc1, 0x5a, 0x3c, 0x12, 0xa3, 0x88, 0x9c, 0x71, 0x91, 0x81, 0x41, 0x61, 0xc5, 0x18, 0x18, 0x80, 0x22, 0x3f, 0xe3, 0x7, 0x4, 0x4, 0xe6, 0x1d, 0x9d, 0x38, 0x2a, 0xae, 0x8f, 0x23, 0x61, 0x65, 0xff, 0xf3, 0x12, 0x1d, 0x1b, 0x4b, 0xbb, 0x5b, 0x4d, 0x9b, 0x1, 0x28, 0x2e, 0x26, 0x63, 0xde, 0x39, 0xc6, 0x42, 0x83, 0x9b, 0x34, 0xe8, 0x53, 0xba, 0xdd, 0x9e, 0x2e, 0x2c, 0x82, 0xfe, 0x90, 0xfe, 0x75, 0x5c, 0x86, 0x77, 0xde, 0x6a, 0x40, 0x5d, 0x1a, 0x23, 0x49, 0x2d, 0x84, 0xaa, 0x27, 0x2a, 0xd9, 0x4c, 0x18, 0x3, 0x0, 0xd7, 0x37, 0x75, 0x8e, 0x0, 0xda, 0x83, 0x5d, 0xa7, 0xba, 0x9e, 0xfa, 0x3e, 0xa0, 0xc1, 0x6d, 0xf2, 0xfd, 0x47, 0x2c, 0x1b, 0x57, 0xe0, 0xd5, 0xca, 0x40, 0xd4, 0x3a, 0x34, 0x59, 0xa0, 0x6a, 0x33, 0x60, 0x21, 0x7a, 0xdf, 0x41, 0x64, 0x5f, 0xec, 0x31, 0xf1, 0x4, 0xca, 0x61, 0x66, 0x41, 0x6e, 0x36, 0x59, 0x7c, 0x35, 0xdc, 0xf0, 0xfa, 0x43, 0x29, 0x8b, 0x7f, 0xca, 0x4f, 0x50, 0x45, 0xaf, 0xf9, 0x0, 0x29, 0x83, 0x39, 0xff, 0x5d, 0xbc, 0xc1, 0x40, 0x8d, 0x70, 0x3c, 0xee, 0x17, 0x8c, 0x6b, 0x19, 0x4e, 0x10, 0x15, 0xdf, 0x36, 0x2b, 0x3, 0x8a, 0xfd, 0x34, 0x96, 0x10, 0x81, 0x9f, 0xab, 0x28, 0x9a, 0xc1, 0x1c, 0xbb, 0x3f, 0x19, 0xff, 0xc9, 0xfa, 0x2, 0x3, 0xc2, 0x31, 0x71, 0x1f, 0xbc, 0xc4, 0x89, 0x22, 0x42, 0x20, 0x59, 0x40, 0x7e, 0xa2, 0x25, 0xf8, 0x50, 0x97, 0x61, 0xd3, 0xc5, 0x3d, 0x83, 0x43, 0x7b, 0x50, 0x78, 0x14, 0xe6, 0x12, 0x6, 0x55, 0x8c, 0x8a, 0x27, 0xe7, 0xd5, 0x54, 0x0, 0xc6, 0x4c, 0x22, 0xaa, 0xe3, 0x3c, 0x81, 0x73, 0x24, 0xab, 0xdd, 0x71, 0x14, 0xab, 0xfc, 0x1, 0xcf, 0xb1, 0xaf, 0xc1, 0x62, 0x96, 0xff, 0x6b, 0x3d, 0xbc, 0x82, 0x18, 0x51, 0x4b, 0x83, 0x10, 0x2b, 0xc8, 0x42, 0x72, 0xd4, 0x1c, 0x5, 0xea, 0xea, 0xdc, 0xf4, 0xa0, 0xfd, 0x99, 0x83, 0xfb, 0xb7, 0x96, 0x27, 0xba, 0x8f, 0x90, 0x5e, 0x4c, 0xd3, 0x45, 0xc8, 0x74},
+               output224: []byte{0x38, 0xa0, 0x93, 0xa9, 0x79, 0x52, 0x8f, 0xce, 0xad, 0x90, 0x63, 0xc2, 0x65, 0xb4, 0xfc, 0x44, 0xd, 0xda, 0xbb, 0x82, 0x77, 0x15, 0x73, 0xc7, 0xc2, 0xd0, 0x6b, 0x84},
+               output256: []byte{0x8f, 0xb5, 0x5e, 0xed, 0x6, 0x3f, 0x80, 0x47, 0x6c, 0xc7, 0xb2, 0xa2, 0x2e, 0xbd, 0xd3, 0x51, 0xd0, 0x28, 0x8d, 0xba, 0x71, 0x49, 0xff, 0xa, 0x99, 0xd5, 0xc6, 0xf8, 0x95, 0x46, 0xfb, 0x4},
+               output384: []byte{0x84, 0x3e, 0xbe, 0x1b, 0x88, 0x36, 0x7, 0xa3, 0x5e, 0x5b, 0x5a, 0x50, 0xd1, 0xc5, 0xa3, 0xb9, 0xba, 0x44, 0x3f, 0x59, 0x3d, 0x40, 0x4c, 0x4e, 0x95, 0xa1, 0x9c, 0x7, 0x42, 0x32, 0x4d, 0x43, 0xa9, 0x3b, 0xfa, 0xaf, 0x2a, 0xee, 0x7c, 0xb0, 0x4f, 0xac, 0xae, 0x49, 0xdd, 0x68, 0xa8, 0x8c},
+               output512: []byte{0xe2, 0x98, 0xe7, 0x24, 0x2, 0x46, 0xff, 0x59, 0xf9, 0xcc, 0xe, 0x19, 0x61, 0xfc, 0x68, 0x60, 0xb8, 0x73, 0x23, 0xac, 0x52, 0x67, 0x56, 0x2b, 0x53, 0x90, 0x53, 0xf7, 0xc6, 0xad, 0x1a, 0x3d, 0x23, 0x71, 0x54, 0x7c, 0xee, 0x17, 0x1c, 0x20, 0x10, 0xfd, 0xd5, 0x3, 0x8d, 0x22, 0x70, 0x20, 0xcd, 0xd8, 0xc7, 0xa1, 0xfa, 0xc0, 0x76, 0x19, 0x82, 0xba, 0x57, 0x5f, 0x36, 0x9a, 0xe8, 0xac}},
+       testcase{
+               msg:       []byte{0xc5, 0x95, 0x33, 0x68, 0x27, 0x25, 0x9b, 0x5, 0xd, 0xc7, 0x83, 0xf2, 0x2f, 0xf7, 0xb0, 0x33, 0xec, 0xc9, 0x8f, 0x9c, 0x7c, 0xe0, 0x26, 0x80, 0x9c, 0xf3, 0x88, 0xfb, 0xca, 0xa2, 0x9a, 0x9d, 0x35, 0x72, 0x54, 0x7c, 0xcc, 0xd, 0x5f, 0x8d, 0x26, 0x73, 0x6, 0x17, 0x93, 0x3f, 0x80, 0x9b, 0x95, 0x59, 0xab, 0x20, 0x33, 0x9f, 0xa9, 0xa, 0x52, 0x5c, 0x46, 0xa2, 0x99, 0xef, 0x14, 0xc9, 0x4, 0x5e, 0x62, 0x75, 0xe2, 0x2c, 0x34, 0x9, 0x3e, 0x9b, 0xcd, 0xb1, 0x23, 0x1, 0x98, 0x43, 0x36, 0x72, 0xed, 0xa8, 0xfd, 0xa5, 0xb1, 0x6e, 0xa9, 0x31, 0x32, 0x42, 0xed, 0x77, 0x7e, 0x86, 0xf4, 0xaf, 0xff, 0xb4, 0xbb, 0x8a, 0x9c, 0xc0, 0xa9, 0x2, 0xad, 0xe7, 0x74, 0xae, 0x68, 0x80, 0x95, 0xd2, 0x71, 0xce, 0x7d, 0xf9, 0x75, 0xf1, 0x40, 0x4f, 0xa5, 0xdc, 0x9a, 0xcb, 0x50, 0xd6, 0x6d, 0x2f, 0x93, 0xd7, 0x7e, 0x26, 0x25, 0x86, 0xca, 0xac, 0x61, 0xa, 0xb9, 0x90, 0x97, 0x48, 0x45, 0xf7, 0x58, 0x20, 0x31, 0x9f, 0xe8, 0xc5, 0x7, 0xc7, 0x59, 0xda, 0x47, 0x9a, 0xfc, 0x55, 0x57, 0xc3, 0x26, 0x18, 0xf6, 0x5e, 0xf7, 0xef, 0x36, 0xe6, 0x9f, 0x5c, 0x89, 0x34, 0x35, 0xa5, 0x92, 0xc3, 0xd3, 0xb3, 0xb8, 0xa8, 0x11, 0x8, 0x11, 0x36, 0x2b, 0x22, 0xf2, 0xd7, 0xa6, 0x60, 0xa7, 0x67, 0xd8, 0x8d, 0x6a, 0xc9, 0x65, 0x6f, 0xd, 0x83, 0xf1, 0xd0, 0x39, 0x5d, 0x47, 0x7a, 0xe9, 0xdf, 0x50, 0x16, 0xd9, 0x82, 0xbd, 0x6c, 0xb9, 0x72, 0xd7, 0x33, 0xf2, 0xe0, 0x10, 0xca, 0xda, 0xac, 0x4d, 0xd2, 0xf, 0x8b, 0x4b, 0x79, 0x8c, 0x12, 0xc5, 0xfc, 0xcc, 0xb7, 0xc7, 0xa1, 0x66, 0xe3, 0xbd, 0x45, 0x1c, 0xe0, 0xb8, 0x3f, 0x9f, 0xea, 0xfd, 0x67, 0xaf, 0x64, 0x7a, 0xde, 0xb7, 0xee, 0xf0, 0x23, 0xcf, 0x2c, 0xc, 0xba, 0x8c, 0x37, 0x9f, 0xbc, 0x4a, 0x5a, 0x3f, 0x58, 0x47, 0x3a, 0x37, 0x4e, 0x9, 0xff, 0x9, 0x60, 0x91, 0xde, 0xc2, 0xe5, 0xb3, 0x5a, 0x42, 0x83, 0xc7, 0xdd, 0x96, 0xc4, 0x6e, 0xfe, 0x4f, 0x27, 0x68, 0xac, 0xe5, 0xb4, 0x3a, 0x8, 0xdb, 0xde, 0xaf, 0x95, 0xbe, 0x5c, 0x2d, 0xb0, 0x54, 0xd, 0xdf, 0x80, 0xfc, 0x89, 0x5d, 0xce, 0x34, 0x3e, 0xa9, 0x3e, 0xd2, 0xed, 0x74, 0x8f, 0xc3, 0x24, 0x35, 0xe7, 0xb2, 0x8e, 0xd8, 0x47, 0x4e, 0xde, 0xa, 0xd4, 0x49, 0xb3, 0x27, 0x39, 0xf7, 0xd7, 0x4a, 0x37, 0xc9, 0x28, 0x7, 0xd, 0xc, 0x1c, 0x30, 0x5, 0x3a, 0xde, 0xca, 0xeb, 0xc8, 0x8f, 0x56, 0xc0, 0x13, 0xad, 0x54, 0x39, 0xad, 0x2c, 0xf6, 0xa3, 0x87, 0x63, 0x64, 0xa6, 0xb6, 0x8e, 0xd, 0x1f, 0xc2, 0x9, 0x6, 0x67, 0xe, 0xbe, 0x4e, 0x85, 0xce, 0xf0, 0x72, 0xff, 0x67, 0xda, 0x9, 0x7e, 0x3b, 0x6a, 0x88, 0xf7, 0x8d, 0xc1, 0xf, 0x95, 0x52, 0x7, 0x62, 0xee, 0x86, 0xe8, 0xb2, 0x63, 0x63, 0x24, 0x55, 0x55, 0xda, 0x7, 0x64, 0x93, 0x0, 0x89, 0x3f, 0xf3, 0x68, 0x54, 0xbc, 0xb8, 0x75, 0xaa, 0x19, 0x24, 0xb7, 0xa9, 0x91, 0x69, 0xe9, 0x65, 0x80, 0x3b, 0x74, 0xcb, 0xea, 0x5, 0xf7, 0xc4, 0x86, 0xfb, 0xea, 0x23, 0x55, 0xca, 0x3, 0x3a, 0x77, 0xc2, 0xf4, 0x16, 0x4a, 0x6, 0xed, 0xe3, 0xd, 0xc6, 0x24, 0x4f, 0xdb, 0x3e, 0x8d, 0xaf, 0x9e, 0x73, 0xf8, 0x35, 0x44, 0xb7, 0x9b, 0xab, 0x20, 0x85, 0x1a, 0x64, 0xd, 0xc8, 0x3c, 0x43, 0xc8, 0x98, 0xa, 0x27, 0x29, 0xec, 0x1, 0xf4, 0x9, 0xda, 0x9a, 0xf6, 0xe9, 0xb5, 0xb7, 0xa6, 0x28, 0x6a, 0xe8, 0xf2, 0x25, 0xaf, 0x90, 0xb2, 0xe5, 0x43, 0x88, 0x92, 0x11, 0x5e, 0x6d, 0xe7, 0x2d, 0xf2, 0x84, 0x83, 0x76, 0x49, 0x4, 0x3, 0xa5, 0x43, 0x76, 0x5e, 0xcf, 0xe2, 0xcb, 0xb4, 0x6e, 0xa7, 0xf0, 0x99, 0x9c, 0xb3, 0x99, 0x3c, 0xe0, 0x99, 0x75, 0x2e, 0x9, 0x99, 0xd8, 0x4c, 0x2b, 0xbf, 0x91, 0xa9, 0xfb, 0xd3, 0x9c, 0xb7, 0x21, 0xf4, 0xc6, 0x26, 0x6f, 0xee, 0x4d, 0xf8, 0x96, 0xeb, 0x29, 0x6c, 0xae, 0xb2, 0xb3, 0x48, 0x3b, 0x2, 0x5e, 0x4b, 0xe2, 0x7d, 0xeb, 0x57, 0xa3, 0xa7, 0x6, 0xbf, 0xf5, 0x98, 0x29, 0xba, 0xd9, 0xf1, 0x1e, 0xb7, 0x5a, 0x1d, 0x1, 0xe, 0xf1, 0xae, 0x92, 0x6d, 0x5f, 0x5c, 0xad, 0xad, 0x5c, 0xb3, 0xca, 0x71, 0x60, 0xa6, 0x68, 0x46, 0xab, 0x4f, 0x12, 0xf0, 0x36, 0x93, 0x3c, 0x90, 0xe1, 0x15, 0x70, 0x2e, 0x11, 0xb2, 0x65, 0x70, 0x31, 0xeb, 0x28, 0xbd, 0x1e, 0x27, 0x93, 0xd0, 0xd0, 0xbe, 0xf4, 0x23, 0x4c, 0x2b, 0x61, 0x66, 0xa0, 0x38, 0xcf, 0x67, 0xdd, 0x60, 0xcd, 0xcb, 0x86, 0xfb, 0x32, 0x37, 0x88, 0xaa, 0x67, 0x3f, 0x2c, 0xe5, 0xad, 0xc8, 0xfa, 0x8a, 0xae, 0x91, 0x1d, 0x73, 0x63, 0xff, 0x83, 0x3a, 0xbf, 0x61, 0x98, 0x47, 0xe7, 0x8f, 0x13, 0x7f, 0xd0, 0x95, 0x9b, 0x98, 0x3e, 0x76, 0x4a, 0x59, 0xfe, 0xd2, 0x9c, 0xee, 0x31, 0xf2, 0xf4, 0x77, 0x15, 0xfa, 0xea, 0x7f, 0x91, 0x48, 0x3a, 0x6e, 0x61, 0xdd, 0x7e, 0xce, 0xc5, 0x57, 0xcf, 0x24, 0xbb, 0x64, 0xcf, 0xcc, 0x7, 0x8, 0xdb, 0x55, 0xda, 0x24, 0x26, 0xd4, 0x33, 0x4, 0x38, 0xc4, 0x2a, 0x4f, 0xa7, 0xd9, 0xdc, 0x4a, 0x1c, 0x62, 0x58, 0x23, 0xdf, 0x1d, 0x70, 0x1b, 0xc3, 0xbc, 0x3a, 0xac, 0x58, 0x48, 0x43, 0xde, 0x33, 0x2, 0x6, 0xc4, 0x5d, 0xf0, 0x18, 0x4f, 0xfa, 0xe4, 0xe3, 0x47, 0xfc, 0xe6, 0x86, 0xc, 0x7e, 0xc, 0x8f, 0xd5, 0x4b, 0xed, 0x94, 0xce, 0x32, 0x1d, 0x62, 0x32, 0x5a, 0xe1, 0x2f, 0x93, 0x28, 0x71, 0xa4, 0x72, 0x46, 0x77, 0xbd, 0xde, 0x95, 0xe5, 0x42, 0xad, 0x66, 0xcd, 0xf4, 0x91, 0xf5, 0x70, 0x8f, 0xbe, 0xae, 0x6a, 0x68, 0x46, 0xd7, 0x6, 0x8f, 0x88, 0x27, 0x40, 0xc, 0x18, 0x8d, 0x69, 0x15, 0xaf, 0x83, 0x54, 0x2a, 0x51, 0xa1, 0xe0, 0xba, 0xcd, 0xd0, 0x7e, 0x25, 0x6, 0x4e, 0x29, 0x15, 0xea, 0x78, 0xc8, 0xca, 0x83, 0x27, 0xe2, 0x37, 0x5e, 0xea, 0x19, 0xc5, 0x65, 0xaf, 0x6b, 0x83, 0x7c, 0xa5, 0x4, 0x4a, 0xcf, 0xc4, 0xdf, 0x68, 0xee, 0x32, 0x4d, 0x5b, 0xb8, 0xef, 0x4d, 0x97, 0x43, 0x68, 0xea, 0x9b, 0x13, 0x69, 0xb5, 0x67, 0xe6, 0xd5, 0xa4, 0x45, 0x73, 0xda, 0x12, 0x49, 0xc8, 0x4a, 0x78, 0x94, 0x42, 0xce, 0x16, 0x60, 0x4a, 0x94, 0x78, 0x86, 0x31, 0xe8, 0x90, 0x63, 0x98, 0xea, 0x3c, 0x2b, 0x8e, 0xa3, 0x4, 0xb1, 0x1e, 0x52, 0x2b, 0xa8, 0x24, 0x1, 0xfa, 0x23, 0x38, 0xce, 0x92, 0x5d, 0x31, 0xae, 0x37, 0xbb, 0x3a, 0x67, 0x16, 0xd, 0xff, 0x3d, 0xb6, 0xf7, 0xed, 0xc, 0x2d, 0xf6, 0x45, 0xbf, 0xaa, 0x5e, 0x27, 0x6f, 0x2c, 0xbf, 0xc4, 0xca, 0x28, 0x8f, 0x2c, 0x3b, 0x24, 0x6c, 0x67, 0x31, 0x52, 0x35, 0xc0, 0x54, 0x6b, 0xcf, 0xd3, 0xe4, 0xdd, 0xc2, 0xd6, 0xa2, 0xfa, 0x2, 0xab, 0x78, 0xe, 0xb0, 0xfb, 0x34, 0x91, 0x23, 0x9a, 0x2f, 0xa1, 0xb5, 0xec, 0x90, 0xa0, 0x20, 0x3d, 0xed, 0x37, 0x2d, 0x5f, 0x59, 0x48, 0x47, 0xd2, 0x79, 0x39, 0x67, 0x30, 0xa9, 0xd8, 0xce, 0x5c, 0xc9, 0x2a, 0xe3, 0x4f, 0x7c, 0x75, 0xa0, 0x7b, 0xb4, 0x87, 0x3a, 0x5c, 0x5e, 0xe7, 0x82, 0x68, 0xdd, 0xd0, 0xd8, 0xa3, 0x51, 0x79, 0x4f, 0xbd, 0x6c, 0x80, 0x15, 0x51, 0xb3, 0x9f, 0xad, 0x39, 0xe6, 0xcd, 0x2c, 0xac, 0x30, 0xd4, 0x53, 0x8e, 0x90, 0xee, 0x24, 0x78, 0x4b, 0xa1, 0xac, 0xb, 0xa9, 0xcb, 0xc2, 0x87, 0x15, 0x1c, 0x7d, 0x8e, 0xe7, 0xff, 0x94, 0x52, 0x4f, 0xad, 0x65, 0xb3, 0xdc, 0x45, 0x26, 0x5e, 0xf3, 0xb7, 0x8, 0xca, 0x2b, 0xcc, 0x5d},
+               output224: []byte{0x68, 0x61, 0xb5, 0xe0, 0xcf, 0xc2, 0x23, 0xeb, 0x2b, 0x9b, 0x73, 0x55, 0x67, 0x1, 0x9f, 0x90, 0xb6, 0x1a, 0x76, 0x84, 0xc, 0x89, 0x0, 0x55, 0x11, 0xb6, 0x63, 0x85},
+               output256: []byte{0xe4, 0x31, 0x20, 0x8e, 0x1a, 0x69, 0xa, 0x1c, 0x9f, 0x83, 0x9, 0x2c, 0xb5, 0x7b, 0xf0, 0x12, 0x6d, 0xd, 0x3a, 0xfc, 0xe, 0xa0, 0xd1, 0x88, 0x46, 0xa, 0x25, 0x9f, 0x42, 0x12, 0xd1, 0x27},
+               output384: []byte{0xff, 0xb1, 0x55, 0x23, 0x2a, 0x1e, 0xf4, 0xa, 0x53, 0x1e, 0xed, 0x1a, 0xa6, 0x1c, 0x7f, 0xcc, 0xa0, 0xf2, 0x13, 0x32, 0x65, 0x1b, 0xef, 0xe, 0x71, 0xfc, 0x11, 0xa3, 0x57, 0x6c, 0x85, 0x5f, 0xe9, 0x8c, 0xbd, 0x7e, 0x75, 0xff, 0x2, 0x6a, 0x18, 0xa6, 0x91, 0xa9, 0x6a, 0x75, 0x3d, 0x68},
+               output512: []byte{0x54, 0xb2, 0xef, 0xf1, 0x73, 0xb4, 0x6, 0xba, 0x66, 0x3e, 0x39, 0x90, 0x8a, 0xf6, 0x76, 0x8f, 0x33, 0x28, 0x3b, 0x8b, 0xfb, 0xf, 0x48, 0xa5, 0x8c, 0x10, 0x4, 0xc5, 0x23, 0x15, 0x9a, 0x68, 0x1e, 0x60, 0x63, 0xfe, 0x22, 0x51, 0x67, 0xbd, 0xcb, 0xc, 0x90, 0x2e, 0x53, 0x3c, 0xe, 0x53, 0x54, 0x15, 0x63, 0x49, 0x10, 0xe1, 0xc8, 0xa6, 0x9f, 0x62, 0x49, 0x87, 0x1b, 0x1b, 0x17, 0x94}},
+       testcase{
+               msg:       []byte{0xa8, 0x67, 0x33, 0xd, 0xc, 0x93, 0x8, 0x3f, 0xbb, 0x15, 0x9e, 0xfe, 0xef, 0x90, 0x7a, 0xa5, 0x3a, 0xce, 0x39, 0x95, 0xac, 0xfe, 0x75, 0x87, 0xb4, 0x4, 0xaf, 0x8c, 0x83, 0x34, 0xe3, 0x2f, 0x9d, 0x35, 0x97, 0x6d, 0x4, 0x66, 0x65, 0x9f, 0x26, 0x48, 0x26, 0x10, 0x9b, 0x23, 0xa0, 0xdf, 0x20, 0x56, 0xa5, 0x47, 0x9d, 0xc, 0xc, 0x5e, 0xa5, 0x16, 0x6c, 0xa2, 0x31, 0x52, 0x5d, 0xa9, 0xb, 0x38, 0x8c, 0x43, 0x25, 0x9b, 0xa1, 0x69, 0x6f, 0xd3, 0x92, 0xfa, 0x10, 0xd1, 0x46, 0x25, 0x80, 0x40, 0x4, 0xb, 0x6a, 0xc2, 0xc3, 0xe9, 0x1d, 0x1f, 0x22, 0x4e, 0x2a, 0x2a, 0xa, 0xb3, 0x23, 0xb4, 0xcd, 0xe6, 0xee, 0x57, 0xb, 0x4d, 0xce, 0xda, 0x79, 0x58, 0xd6, 0x9a, 0x2f, 0xb8, 0x5f, 0xd, 0x9d, 0xae, 0xfb, 0x37, 0x15, 0xe5, 0x82, 0x52, 0x98, 0xb7, 0xd3, 0xd8, 0xf0, 0x92, 0x68, 0x41, 0x3a, 0x11, 0xb3, 0xa, 0x24, 0x35, 0x87, 0x55, 0xf7, 0xed, 0x9d, 0xf6, 0xf2, 0xfa, 0x9a, 0xe7, 0xa2, 0x19, 0xe6, 0x5b, 0xea, 0x97, 0x8f, 0xa1, 0x18, 0x78, 0x6, 0x38, 0x6e, 0xba, 0x3, 0xaf, 0x49, 0x1a, 0x1d, 0x57, 0x8, 0xaf, 0x24, 0x9, 0xb8, 0x2d, 0xb0, 0x3a, 0x19, 0xd6, 0x65, 0xec, 0x58, 0x11, 0x9a, 0xc5, 0x37, 0xcb, 0xdc, 0x75, 0xff, 0x3e, 0xd1, 0xe0, 0xd0, 0xa2, 0x6d, 0x29, 0x13, 0x91, 0xde, 0x65, 0x84, 0xbc, 0xc0, 0xd5, 0x5b, 0x99, 0x31, 0x53, 0x7e, 0xbe, 0x21, 0xf4, 0x2a, 0xfe, 0xf0, 0x5a, 0xd7, 0x55, 0xdb, 0x1a, 0xf6, 0x9, 0x88, 0xda, 0xed, 0x8c, 0xb0, 0x87, 0x73, 0x34, 0x21, 0x67, 0x9f, 0x8b, 0x2d, 0x38, 0x1c, 0x65, 0x9c, 0x13, 0x25, 0xd4, 0x76, 0x88, 0xf2, 0x77, 0x1a, 0x3, 0xbf, 0xd3, 0x1c, 0xf8, 0xd3, 0xc2, 0xf, 0xd0, 0x9f, 0x60, 0x3b, 0xe7, 0xa1, 0x3d, 0x1b, 0xa8, 0xd3, 0x7c, 0xf4, 0x92, 0xc9, 0x37, 0x24, 0xa7, 0x28, 0xbf, 0xdb, 0xcb, 0x6d, 0x3e, 0x8f, 0xd, 0x77, 0xb, 0x5c, 0x26, 0xc, 0xfa, 0x35, 0x15, 0xaa, 0xf7, 0xc2, 0x5f, 0xae, 0xc4, 0x2b, 0x23, 0x73, 0x97, 0xd, 0x11, 0xeb, 0x2a, 0x18, 0xc8, 0x63, 0xd0, 0xd7, 0x12, 0x1b, 0xb2, 0xdd, 0xa1, 0xb2, 0x23, 0xb8, 0x83, 0xc4, 0x68, 0x28, 0x1e, 0xff, 0xf0, 0x17, 0xf, 0xfa, 0x48, 0x55, 0x2f, 0x26, 0x3c, 0x30, 0x86, 0x58, 0xd9, 0x69, 0x86, 0x67, 0x81, 0xf0, 0x41, 0xda, 0xa, 0xb1, 0x49, 0xeb, 0x20, 0x20, 0x89, 0x2a, 0x11, 0x4a, 0x4a, 0x77, 0x58, 0xad, 0xae, 0x9f, 0xeb, 0xb4, 0xaa, 0x76, 0x60, 0x4a, 0x65, 0xb8, 0x7a, 0x2a, 0x5d, 0xa, 0x45, 0xa8, 0x9, 0x63, 0x91, 0xb3, 0xd1, 0xc0, 0x9f, 0xc9, 0x57, 0x46, 0xc4, 0x49, 0xba, 0xeb, 0x2f, 0x80, 0x7a, 0xfc, 0x8e, 0x4f, 0x5e, 0xfa, 0xb2, 0x48, 0x8e, 0xc1, 0x98, 0x5, 0x69, 0x11, 0x62, 0xac, 0x8a, 0x3e, 0xac, 0xa1, 0xd2, 0x5f, 0xf, 0x4e, 0xb9, 0x5e, 0xcf, 0x48, 0xc1, 0x34, 0x58, 0x41, 0x25, 0xaa, 0xf, 0xaf, 0xd5, 0x58, 0x98, 0x47, 0xe6, 0x56, 0xbe, 0xca, 0xde, 0xbf, 0xbb, 0xd2, 0x58, 0xef, 0xcc, 0x6f, 0x74, 0x9e, 0x15, 0xba, 0x9, 0xdb, 0xf0, 0x4b, 0x93, 0x87, 0x7f, 0xa0, 0x4e, 0xc2, 0xb6, 0xc3, 0x23, 0x4f, 0xc4, 0x98, 0x72, 0xc3, 0x18, 0xb3, 0x2, 0x25, 0x24, 0x71, 0x70, 0x5b, 0xe6, 0x69, 0x2, 0x27, 0x65, 0xfd, 0x1, 0xd1, 0x57, 0xc4, 0xaa, 0x54, 0x17, 0x33, 0x99, 0x54, 0x8b, 0xde, 0x8d, 0x89, 0x71, 0xa8, 0xcf, 0xd, 0xb6, 0x52, 0x81, 0x43, 0x13, 0xb7, 0x1b, 0xc0, 0x62, 0xdb, 0x9, 0x2f, 0xa5, 0xa5, 0xca, 0xf1, 0x80, 0x9d, 0xef, 0xa1, 0x21, 0x5b, 0x42, 0xb8, 0x0, 0x7, 0x2b, 0x29, 0x90, 0xe6, 0xfa, 0x31, 0xf6, 0x9d, 0x52, 0x7, 0x6a, 0xd2, 0x93, 0xd9, 0x66, 0xcb, 0xe4, 0xf8, 0x9c, 0x6d, 0x4e, 0x45, 0xaf, 0xb7, 0x6f, 0x23, 0xa5, 0x67, 0xe, 0x5b, 0x36, 0xfd, 0x60, 0xd7, 0x84, 0xa7, 0x36, 0xd0, 0x20, 0x1c, 0xd2, 0xa1, 0x19, 0x10, 0x7f, 0x27, 0x8e, 0x54, 0x74, 0xd8, 0x7a, 0x97, 0xf5, 0x3b, 0x12, 0xa8, 0xab, 0x1d, 0x1, 0x91, 0xd1, 0x9e, 0xc4, 0x10, 0x3c, 0x47, 0x2d, 0x1e, 0x7a, 0xbe, 0x73, 0x51, 0x25, 0x8b, 0x26, 0xc4, 0x45, 0x39, 0x7a, 0xa5, 0xa3, 0xba, 0x92, 0x42, 0x38, 0xb2, 0x75, 0xe7, 0xd5, 0x3b, 0x20, 0x25, 0x36, 0x95, 0x86, 0x6e, 0xe8, 0xae, 0x2, 0xf9, 0xdd, 0x8f, 0xa8, 0xbf, 0x4b, 0x76, 0xe5, 0x49, 0xd9, 0x32, 0x2b, 0xae, 0xe5, 0x8d, 0x70, 0xbd, 0xfe, 0x1a, 0xf3, 0x4e, 0xbc, 0xbf, 0xd8, 0xa, 0xed, 0x8e, 0x40, 0x27, 0x37, 0x27, 0xb7, 0xb9, 0x19, 0xa2, 0x88, 0x62, 0x17, 0x1c, 0xda, 0xe6, 0x6e, 0xc8, 0x85, 0xee, 0xf4, 0x1e, 0x5d, 0x23, 0x7b, 0x9c, 0x30, 0x87, 0x72, 0xdb, 0x7c, 0xad, 0x76, 0x73, 0x64, 0x6a, 0x7c, 0xc7, 0xcd, 0x78, 0x80, 0xa, 0xa1, 0x23, 0x95, 0xe6, 0xdd, 0xd5, 0x0, 0x4f, 0xe, 0x4d, 0x48, 0x34, 0xb6, 0x6d, 0x7e, 0xe7, 0xfe, 0xfb, 0xe4, 0xe0, 0x94, 0x7c, 0xc2, 0xfe, 0x9, 0x93, 0xc3, 0xf5, 0x6, 0xea, 0xd5, 0x1c, 0x9e, 0x9b, 0x66, 0x48, 0x22, 0x8f, 0x3, 0x23, 0xf, 0x61, 0xad, 0x23, 0xa7, 0x8, 0xb1, 0x1d, 0xcd, 0x32, 0x8a, 0xb9, 0x8, 0x1d, 0x10, 0x24, 0x55, 0xdb, 0xf1, 0x1a, 0x93, 0x2f, 0x90, 0x94, 0x60, 0x46, 0xd7, 0x2d, 0x91, 0x2, 0x70, 0x21, 0x14, 0xb8, 0x96, 0x5f, 0x32, 0x8d, 0x6f, 0x57, 0xdc, 0xe, 0xce, 0xb, 0x1a, 0xef, 0x76, 0x20, 0x64, 0xb, 0x4f, 0x43, 0x61, 0x5a, 0x11, 0x23, 0xb6, 0xc3, 0xb5, 0x84, 0x38, 0xb5, 0x76, 0xe, 0xf0, 0xbe, 0xe1, 0x30, 0xc5, 0x65, 0x5b, 0x75, 0x6d, 0xab, 0x18, 0x94, 0xfe, 0xc4, 0x73, 0x64, 0x20, 0x18, 0x0, 0x41, 0x69, 0x8d, 0xcd, 0xee, 0xcb, 0x5e, 0xe9, 0x8b, 0x4, 0x3a, 0x87, 0xc, 0x99, 0x49, 0xb1, 0x14, 0x1d, 0x5a, 0x9, 0x20, 0xa1, 0xef, 0xa6, 0xa, 0x30, 0xd8, 0xcb, 0x33, 0xdb, 0xc, 0xc3, 0x36, 0x4c, 0x65, 0x7e, 0xe7, 0xe3, 0xe5, 0x82, 0xa2, 0xa4, 0x96, 0x10, 0xe8, 0xc0, 0x8b, 0x9e, 0xd7, 0x33, 0xd4, 0xf5, 0x84, 0xef, 0x6b, 0x9f, 0xc4, 0x3f, 0x62, 0xcf, 0xe9, 0xf6, 0x9b, 0xd6, 0x4c, 0x2, 0xb1, 0xd2, 0xe, 0xfe, 0x2e, 0xa9, 0xeb, 0xd6, 0xb6, 0xdc, 0xa5, 0xf6, 0xd9, 0xde, 0x62, 0xa4, 0x43, 0xd6, 0x7c, 0x60, 0xcc, 0xe6, 0x7c, 0x47, 0xb4, 0xed, 0xaf, 0x24, 0x80, 0x5d, 0xad, 0x5a, 0xc4, 0x98, 0xbf, 0x16, 0x34, 0x64, 0x6d, 0xc, 0x34, 0xfc, 0x3b, 0x7c, 0x46, 0x61, 0xee, 0x80, 0x29, 0xcd, 0x4f, 0xa2, 0x37, 0x53, 0x1c, 0xff, 0x68, 0x12, 0x13, 0x1, 0x29, 0x93, 0xf9, 0x11, 0x6, 0x8, 0x4d, 0xe2, 0x2, 0x41, 0xcd, 0xe0, 0x59, 0xbb, 0x37, 0xa2, 0x6c, 0xad, 0x85, 0x53, 0x3e, 0x4c, 0x5e, 0x8a, 0x4c, 0x4e, 0x6f, 0x95, 0x21, 0x62, 0x66, 0xc, 0xc, 0x55, 0xd8, 0xe2, 0x66, 0xf0, 0xab, 0xdd, 0x42, 0x24, 0x48, 0x7d, 0x6, 0xf7, 0xda, 0x1f, 0x26, 0xb8, 0x4d, 0x6d, 0x30, 0x10, 0x1b, 0x53, 0x5a, 0x1c, 0xe7, 0x63, 0x55, 0xae, 0x1d, 0x34, 0xda, 0x2e, 0x71, 0xe2, 0x44, 0x46, 0x8, 0x48, 0x21, 0x2d, 0x90, 0x76, 0xff, 0x79, 0xd8, 0xa2, 0x82, 0x35, 0x9b, 0x89, 0x61, 0xc2, 0x7a, 0x15, 0x7e, 0xd6, 0xaa, 0x5e, 0x99, 0x90, 0xd5, 0x6b, 0x4e, 0xd7, 0x11, 0x30, 0x66, 0xbd, 0x56, 0x7, 0x19, 0xa4, 0x31, 0xe3, 0x82, 0x2e, 0xf2, 0x4c, 0x6, 0x30, 0x11, 0xa, 0xb4, 0x48, 0xef, 0x26, 0x9f, 0x4f, 0xfa, 0xfd, 0xce, 0x95, 0xfa, 0x57, 0xad, 0xf3, 0x22, 0x9e, 0x5e, 0xa6, 0x39, 0xcf, 0x46, 0x49, 0xe5, 0x98, 0xe7, 0xf, 0x51, 0x7f, 0x8c, 0xa0, 0x3c, 0x9a, 0xfa, 0xf4, 0xc7, 0x52, 0xf7, 0xd1, 0x4f, 0x96, 0x76, 0x3f, 0x7a, 0xe, 0xb4, 0xe5, 0xbe, 0xab, 0xe5, 0xfd, 0x17, 0xfa, 0x8e, 0xc1, 0x52, 0x71, 0xa5, 0x9, 0xb1, 0xba, 0xde, 0x0, 0xd8, 0x40, 0x7, 0x3b, 0x52, 0xde, 0x95, 0xc6, 0x88, 0xf7, 0xaa, 0xaf, 0x25, 0x75, 0x10, 0x55, 0xc8, 0x82, 0x7d, 0x1c, 0x6b, 0x5b, 0xb2, 0xc9, 0x14, 0xe, 0xdc, 0xa4},
+               output224: []byte{0xc, 0x26, 0x53, 0x20, 0xc0, 0x39, 0x4c, 0x3, 0xfa, 0xe3, 0x4d, 0x80, 0xdf, 0xfd, 0x4, 0x7, 0x4d, 0x0, 0xc7, 0x21, 0x4f, 0x95, 0xce, 0xcd, 0x9c, 0xfc, 0x8f, 0x7b},
+               output256: []byte{0x12, 0xbc, 0xf1, 0x75, 0xba, 0x9f, 0x1a, 0x6e, 0x30, 0x66, 0x85, 0x5e, 0x3c, 0x23, 0xd4, 0x62, 0xb8, 0x39, 0x1, 0x61, 0x8a, 0xbe, 0x53, 0x6e, 0x86, 0xed, 0x14, 0xb2, 0x4a, 0xe5, 0x3e, 0xe},
+               output384: []byte{0xb8, 0x2e, 0x19, 0xa3, 0x28, 0xf6, 0x72, 0x76, 0xba, 0x1b, 0x2, 0x2, 0xf4, 0xfe, 0x37, 0x40, 0x10, 0x2e, 0xe, 0x60, 0x72, 0xeb, 0xae, 0xb1, 0x6c, 0xfe, 0xe7, 0x21, 0xdb, 0x38, 0x1c, 0xa9, 0x35, 0xd3, 0x2e, 0x1a, 0x2f, 0x2d, 0x4e, 0xea, 0xf9, 0x79, 0xf8, 0xf6, 0xb, 0x67, 0x18, 0xde},
+               output512: []byte{0xb9, 0x52, 0xc7, 0x56, 0xf1, 0xdf, 0xd6, 0xa3, 0xf7, 0x65, 0x2e, 0x3b, 0x13, 0xad, 0x5c, 0xd2, 0x93, 0xe3, 0xaf, 0x87, 0xb, 0xf3, 0xe7, 0x39, 0xe2, 0xe5, 0x20, 0xbf, 0x25, 0x45, 0xda, 0xe0, 0x8c, 0x5e, 0x45, 0x91, 0x47, 0xc8, 0x58, 0x9c, 0x33, 0x1a, 0x24, 0x24, 0xd4, 0x8e, 0xac, 0x3a, 0xc2, 0xcc, 0xf1, 0xef, 0x95, 0xfb, 0xb5, 0x91, 0xcc, 0x57, 0x57, 0x18, 0x2a, 0x57, 0xa7, 0xa8}},
+       testcase{
+               msg:       []byte{0x2e, 0xb3, 0x10, 0x26, 0x15, 0x5b, 0x7b, 0xc3, 0x67, 0x2f, 0x6, 0xd, 0x84, 0x7, 0xb1, 0x62, 0x2f, 0x61, 0x62, 0xcf, 0xe4, 0xe, 0x2, 0x86, 0xcf, 0x9b, 0xd7, 0x3b, 0x18, 0x50, 0x3, 0x82, 0x7e, 0xb7, 0x5c, 0xa0, 0x80, 0xf0, 0xfa, 0x81, 0xd9, 0xe5, 0x89, 0x3f, 0x46, 0x21, 0x24, 0xf6, 0x79, 0xeb, 0xad, 0x80, 0x7d, 0xf6, 0xad, 0x87, 0xc8, 0x9, 0xff, 0x55, 0x2d, 0xdf, 0xef, 0x22, 0xc1, 0x1c, 0x4a, 0xef, 0xe1, 0x74, 0x5a, 0x45, 0x74, 0x62, 0xd3, 0x46, 0xa3, 0xe0, 0x41, 0x93, 0x47, 0x27, 0x4f, 0xa, 0x39, 0xf0, 0x9a, 0xc2, 0x11, 0xd7, 0x9b, 0xbc, 0x13, 0xc7, 0x99, 0xbc, 0x26, 0xe9, 0x54, 0xbe, 0xf1, 0x1f, 0xc7, 0xd9, 0xeb, 0xf0, 0xa0, 0x28, 0x3b, 0x59, 0x49, 0x8f, 0x6a, 0x27, 0x1a, 0xfc, 0x54, 0x15, 0xf6, 0x56, 0xf1, 0xc0, 0xa0, 0xe3, 0x11, 0xed, 0xd0, 0xbc, 0xb4, 0x98, 0x53, 0xf0, 0xfb, 0x52, 0xc8, 0x49, 0x84, 0x84, 0x6, 0xa7, 0xdf, 0x6d, 0x7f, 0x3f, 0x32, 0xde, 0xf5, 0xd, 0x80, 0x73, 0xad, 0x2b, 0x1a, 0x19, 0x79, 0x91, 0xd7, 0xd5, 0x33, 0x7e, 0xcd, 0x5c, 0x14, 0x72, 0xe5, 0x8d, 0xfe, 0x42, 0x85, 0x9f, 0xff, 0xaa, 0x4b, 0x85, 0x8c, 0x34, 0xb3, 0x5, 0xb8, 0xf9, 0x21, 0xaf, 0xb3, 0x19, 0xab, 0xc, 0xa, 0x4d, 0x3, 0x2, 0x4b, 0xc2, 0xaf, 0xee, 0x1b, 0xd4, 0xb0, 0xf9, 0x78, 0x48, 0xbb, 0xee, 0x53, 0x54, 0x60, 0x14, 0x4e, 0x30, 0x13, 0x34, 0xb9, 0xc, 0xcc, 0xed, 0xa1, 0x37, 0xa7, 0xe4, 0x4c, 0x44, 0xcb, 0x53, 0x8e, 0x9a, 0x3d, 0x10, 0x96, 0x1e, 0xcf, 0xf2, 0xbb, 0xf1, 0x6b, 0xeb, 0x1a, 0x40, 0x24, 0xf, 0xa6, 0x3e, 0xb0, 0x2f, 0xaf, 0x24, 0x81, 0x91, 0xda, 0xc5, 0x69, 0xf4, 0x4a, 0xa1, 0xb, 0x9e, 0x39, 0x14, 0x16, 0xa4, 0x1a, 0x1a, 0xf9, 0xb0, 0x37, 0x9d, 0x2e, 0x52, 0xeb, 0x6c, 0x2c, 0x1a, 0x11, 0x1, 0x8a, 0xb9, 0x51, 0xd0, 0x30, 0xfe, 0x5f, 0xb6, 0x31, 0x75, 0x38, 0xf4, 0xdd, 0xa3, 0xd4, 0xb3, 0x87, 0x1a, 0xfe, 0x47, 0x9c, 0x4c, 0xcb, 0x4, 0x22, 0x30, 0x1b, 0xca, 0xec, 0x7c, 0xd, 0x6a, 0x12, 0xe1, 0xa4, 0xdb, 0x17, 0xde, 0x25, 0x39, 0x49, 0x2c, 0x3c, 0x0, 0x3c, 0x3c, 0x89, 0xc6, 0x58, 0x7c, 0xe2, 0x5c, 0x7c, 0x7d, 0x69, 0x7a, 0x11, 0xdc, 0xb4, 0x17, 0x64, 0xdc, 0xde, 0x73, 0x72, 0xe6, 0xee, 0xda, 0xb3, 0x8b, 0x40, 0x4, 0xec, 0x8, 0x5, 0xe1, 0xfe, 0xda, 0xb9, 0xed, 0x25, 0x50, 0xd9, 0x76, 0xc2, 0x23, 0xb0, 0xb0, 0xfb, 0x39, 0xfb, 0x0, 0x6d, 0xd4, 0xaa, 0xfe, 0x4, 0x2b, 0xa, 0x77, 0x1e, 0x9, 0x8b, 0xaa, 0xfa, 0x72, 0xaa, 0x48, 0x8a, 0x40, 0xa1, 0x6b, 0xce, 0x62, 0x72, 0xf6, 0x40, 0x23, 0xe8, 0x63, 0x26, 0x2b, 0xb4, 0xd0, 0xa1, 0x37, 0xf6, 0x1f, 0x9e, 0x71, 0x1d, 0xb0, 0x96, 0xdd, 0x93, 0x25, 0x4c, 0x5e, 0x43, 0x82, 0xd3, 0xf7, 0xf1, 0x91, 0x4e, 0x9d, 0x18, 0xf8, 0x66, 0x37, 0xe5, 0xe4, 0xa7, 0xb7, 0xfc, 0xea, 0x80, 0xed, 0xca, 0x63, 0xb3, 0xac, 0xdc, 0x7c, 0x69, 0x27, 0x70, 0xd8, 0xad, 0xe9, 0xab, 0xf, 0xfa, 0x87, 0xa2, 0xc7, 0xdd, 0x33, 0x31, 0x7d, 0xb0, 0x38, 0xc5, 0x70, 0x9b, 0xce, 0x68, 0x6f, 0xe1, 0xbe, 0x39, 0x5b, 0x32, 0x92, 0x3, 0x38, 0x58, 0xa2, 0xfa, 0x3c, 0x81, 0x44, 0xd4, 0xa7, 0x4b, 0x53, 0xcf, 0xa8, 0x22, 0x2e, 0xcb, 0x7e, 0xd, 0x78, 0x8f, 0x4e, 0xbf, 0xd7, 0x5d, 0x88, 0xd, 0xaa, 0xbf, 0x66, 0xd8, 0x88, 0xf3, 0xd7, 0xcf, 0x5d, 0x1e, 0x3d, 0xac, 0xad, 0x33, 0xf3, 0xc6, 0xe0, 0x5e, 0xb0, 0xff, 0xe7, 0xe8, 0xcb, 0x1d, 0xbe, 0x14, 0x3, 0x53, 0xf, 0x1a, 0xa4, 0x4f, 0x70, 0x28, 0x58, 0xc, 0x90, 0x84, 0xdd, 0x6d, 0xfc, 0xd7, 0x78, 0x8b, 0x94, 0x5, 0xb, 0x5f, 0xe6, 0x3e, 0xf0, 0x79, 0x0, 0x3a, 0x51, 0xfa, 0x43, 0xe7, 0x26, 0x89, 0x7e, 0x82, 0xeb, 0xe1, 0x60, 0xf4, 0xf4, 0x8c, 0x98, 0x55, 0xd5, 0x9b, 0xb9, 0x4b, 0x8b, 0xeb, 0x6b, 0x54, 0x92, 0xa6, 0x6b, 0x38, 0xcf, 0xdf, 0x85, 0xb, 0x6f, 0x1c, 0xb3, 0x68, 0x59, 0x84, 0x43, 0xf2, 0xea, 0x96, 0x53, 0xdd, 0x5e, 0x6a, 0x3e, 0xd6, 0x8, 0x81, 0xd4, 0x79, 0x56, 0xcd, 0x24, 0xf1, 0xb0, 0x56, 0x7e, 0xda, 0xcf, 0xe3, 0xf8, 0x7a, 0x67, 0xe1, 0xd9, 0xf, 0xf6, 0x45, 0x96, 0x66, 0x4, 0x3b, 0x4f, 0x55, 0xd, 0x94, 0x80, 0xf4, 0xd1, 0x7f, 0xf0, 0xb4, 0xb, 0x71, 0x36, 0x43, 0x66, 0xb1, 0x7d, 0x95, 0x8d, 0xb4, 0xf, 0x3b, 0x88, 0x18, 0x9d, 0x23, 0x67, 0x57, 0x2a, 0xb8, 0x7a, 0x14, 0xb1, 0x60, 0x34, 0x4b, 0xec, 0x8c, 0x69, 0xbc, 0x3, 0x74, 0xeb, 0xfc, 0x62, 0xfa, 0x8e, 0x9, 0x2, 0x96, 0xe5, 0xcb, 0x43, 0xbb, 0x25, 0x3d, 0x4, 0xf2, 0x4e, 0x21, 0xcc, 0x55, 0x84, 0x9b, 0xe4, 0xcb, 0x7e, 0x3e, 0xe8, 0xa, 0xa0, 0xda, 0x1f, 0x8c, 0x71, 0xa5, 0x5e, 0x1d, 0x98, 0xa8, 0x50, 0x49, 0xcc, 0xa3, 0xf, 0x40, 0x0, 0x50, 0x6e, 0x4f, 0x36, 0xf7, 0x9, 0x6d, 0x4f, 0x88, 0x70, 0x3a, 0x6b, 0x77, 0x26, 0x90, 0x60, 0x20, 0x19, 0xe1, 0x7b, 0xea, 0x59, 0x65, 0xb6, 0x8c, 0xa1, 0xd7, 0x8c, 0xb1, 0x57, 0xe6, 0x40, 0xcc, 0xe3, 0xaf, 0xe0, 0xa, 0x25, 0xb6, 0x17, 0x2e, 0xca, 0x4c, 0xb9, 0x90, 0x2d, 0x3f, 0x39, 0xbd, 0xa2, 0x5d, 0x57, 0xe4, 0x6e, 0xe0, 0x1a, 0x79, 0x4d, 0xa2, 0xfa, 0x30, 0x9c, 0x8, 0x3c, 0xb1, 0x3, 0x22, 0x49, 0x64, 0xf8, 0x91, 0x4e, 0xb, 0xb3, 0x9f, 0x67, 0xbc, 0x50, 0xb4, 0x10, 0x3e, 0x41, 0xdc, 0x29, 0xc9, 0x50, 0x41, 0xd5, 0x83, 0x51, 0x78, 0xfb, 0xee, 0xa6, 0xbd, 0x35, 0xac, 0xdf, 0x51, 0xa6, 0xf5, 0x44, 0x4c, 0xbf, 0xe5, 0x40, 0x4, 0x39, 0xdc, 0x70, 0xcd, 0xff, 0x87, 0xe, 0x30, 0xea, 0x12, 0x39, 0xfa, 0xa2, 0xec, 0xfe, 0xba, 0xcc, 0x73, 0xb2, 0xc1, 0x4, 0xe9, 0x95, 0x94, 0xab, 0x81, 0x89, 0x4f, 0x4e, 0xba, 0x46, 0x4f, 0x0, 0x96, 0xf4, 0x36, 0x8d, 0x86, 0x62, 0xfa, 0x12, 0xb4, 0x6c, 0xff, 0xd7, 0xeb, 0x76, 0x60, 0x72, 0xbc, 0x14, 0x5e, 0x17, 0xb, 0xf6, 0x45, 0x94, 0x29, 0xbe, 0xa5, 0x84, 0x5b, 0xc4, 0xf0, 0x88, 0xb9, 0x8d, 0x9f, 0x1e, 0xc7, 0xb3, 0x1b, 0x5, 0x4f, 0xbf, 0x4, 0xba, 0x5b, 0x7d, 0x44, 0x14, 0x1c, 0xf2, 0x6b, 0x24, 0xf1, 0xd8, 0xe, 0x39, 0xb2, 0xfc, 0x84, 0x4e, 0x2c, 0x3c, 0xdf, 0x5c, 0x75, 0x2f, 0x65, 0x5, 0x7c, 0x9d, 0x4e, 0x98, 0x21, 0x72, 0xce, 0x9, 0x49, 0x7, 0x72, 0x1d, 0xa4, 0x96, 0x77, 0x72, 0x53, 0x36, 0x32, 0x63, 0x2d, 0x73, 0x35, 0x34, 0x23, 0x86, 0x62, 0x84, 0x38, 0xdb, 0xa8, 0xca, 0xcb, 0x60, 0x13, 0x9a, 0x7a, 0x7d, 0x7f, 0xf2, 0xf, 0x4e, 0x20, 0xe4, 0x5, 0xcd, 0x3a, 0x2, 0x9c, 0x3a, 0xf1, 0x3, 0xa9, 0x1b, 0xf2, 0x4, 0x6c, 0x37, 0x2c, 0x20, 0xe9, 0x9e, 0x3b, 0x59, 0x71, 0xca, 0xfd, 0x3e, 0x2c, 0xa4, 0xcc, 0x7e, 0xe, 0x6e, 0xcc, 0x27, 0x2b, 0xdc, 0x50, 0xfb, 0xd3, 0xf0, 0x18, 0x4e, 0x58, 0xe6, 0xb2, 0x6d, 0x32, 0x9a, 0x93, 0x80, 0x4, 0x9b, 0x32, 0x98, 0xce, 0x33, 0xcf, 0x15, 0xcd, 0x75, 0x60, 0xe3, 0xd3, 0xe0, 0xc5, 0x3c, 0xb0, 0x29, 0x33, 0x72, 0x36, 0xf9, 0xd8, 0x48, 0x76, 0x2d, 0x37, 0x1d, 0x32, 0x79, 0xa8, 0xb1, 0x19, 0x2d, 0x83, 0xcf, 0x1f, 0xf8, 0xc4, 0xf1, 0x2d, 0xbe, 0xaf, 0xa3, 0x83, 0xb4, 0x7c, 0xd3, 0xf1, 0x72, 0xb8, 0x2d, 0x4d, 0x94, 0x2d, 0x99, 0x76, 0xa4, 0xcf, 0x2e, 0x3e, 0xf, 0x69, 0xe1, 0x3f, 0x1d, 0x8e, 0xde, 0x15, 0x29, 0x38, 0xb9, 0x78, 0xd2, 0xb1, 0xcb, 0xaf, 0x27, 0x8, 0x8a, 0x10, 0x93, 0x5e, 0xda, 0x68, 0xb2, 0xe3, 0x14, 0x48, 0xb0, 0x9e, 0x58, 0x6e, 0x9f, 0xca, 0xc1, 0x1c, 0x6c, 0xb0, 0x56, 0xfc, 0x92, 0x51, 0x22, 0x10, 0xc3, 0xa8, 0x28, 0xb5, 0x49, 0xa1, 0xcf, 0xd3, 0x51, 0x6c, 0x4a, 0x5b, 0x4a, 0x59, 0xff, 0xaf, 0x22, 0xd3, 0xba, 0x32, 0x4d, 0xa5, 0xe9, 0x2c, 0x60, 0x7a, 0x45, 0xc1, 0x89, 0xd7, 0x48, 0x2f, 0x9c, 0xe1, 0xfb, 0x0, 0x5b, 0x31, 0x4d, 0x6d, 0x8a, 0xc0, 0xcf, 0x52, 0x3c, 0xb2, 0x1b, 0x3d, 0x86, 0xcb, 0x21, 0xd4, 0x51, 0x40, 0x6, 0x95, 0xd1, 0x34, 0x13, 0x45, 0xdb, 0xc9, 0xe6, 0xcb, 0xf0, 0x2f, 0x56, 0x5e, 0x8b, 0x2, 0xf7, 0xb2, 0x15, 0x11, 0x31, 0x51, 0x4e, 0xe7, 0xd3, 0x19, 0x5c, 0xcc, 0x26, 0x2e, 0xb6, 0x15, 0xa6, 0xc6},
+               output224: []byte{0xff, 0x5d, 0xc9, 0xce, 0x96, 0xc, 0x60, 0x43, 0x23, 0xcd, 0x9d, 0x2d, 0x5d, 0x8d, 0x52, 0x10, 0xd, 0xc1, 0x84, 0xd2, 0x89, 0x5b, 0xa8, 0x76, 0xa5, 0x35, 0xdb, 0xd3},
+               output256: []byte{0x33, 0xc1, 0xc, 0xcc, 0x7e, 0xac, 0x44, 0xf3, 0x7d, 0xc5, 0xd0, 0xd5, 0x8e, 0xd5, 0x90, 0xc8, 0x4, 0x40, 0x2d, 0x64, 0xd2, 0xf1, 0xdd, 0xfc, 0xac, 0xf3, 0xb3, 0x3, 0xef, 0xcc, 0xa8, 0x4b},
+               output384: []byte{0xd7, 0x9a, 0xca, 0x6f, 0x2d, 0xdd, 0x22, 0x5b, 0x1b, 0x72, 0xc6, 0x59, 0x88, 0x9, 0x6f, 0xd, 0xd2, 0x12, 0xee, 0x63, 0x61, 0x24, 0xf7, 0xfb, 0x95, 0x83, 0xde, 0x56, 0xf2, 0xf6, 0x32, 0x61, 0x68, 0x6d, 0xe1, 0xdd, 0x6, 0x94, 0xd2, 0x18, 0x7d, 0xf3, 0x25, 0x4c, 0x37, 0x97, 0x83, 0xa6},
+               output512: []byte{0xd9, 0x98, 0x2c, 0xc7, 0x53, 0xea, 0x96, 0xda, 0xab, 0xb5, 0xee, 0x67, 0x12, 0x4a, 0x29, 0x83, 0xc6, 0x18, 0xe2, 0x5b, 0x0, 0xb4, 0x8e, 0x3d, 0xbb, 0xc7, 0xa5, 0x7b, 0xba, 0x38, 0x34, 0x17, 0x2f, 0x11, 0xf0, 0xf3, 0x5, 0xad, 0x6c, 0xe, 0x99, 0x83, 0x2d, 0xe6, 0x25, 0x0, 0x5c, 0x6d, 0x8d, 0x2c, 0xb7, 0x89, 0xb0, 0x16, 0x33, 0x8d, 0x2e, 0xe8, 0x83, 0x35, 0xda, 0xb8, 0x34, 0xcb}},
+       testcase{
+               msg:       []byte{0x21, 0x8a, 0x31, 0x57, 0x34, 0x65, 0xb8, 0xa5, 0x43, 0xe2, 0x93, 0xe5, 0xa5, 0x91, 0x11, 0x3e, 0x9c, 0xcc, 0xd2, 0x9, 0x5f, 0x51, 0x9d, 0x2b, 0xd, 0x7a, 0x19, 0x5a, 0x62, 0x59, 0x50, 0xae, 0x2f, 0xd5, 0x2a, 0xd7, 0xd5, 0xe5, 0xc9, 0x84, 0xe5, 0xbc, 0xa8, 0x9f, 0x7f, 0xba, 0xeb, 0xaa, 0xf4, 0x68, 0x6d, 0xb9, 0x68, 0x26, 0xe8, 0xe0, 0xcd, 0xef, 0x1b, 0x78, 0x7c, 0xd0, 0x81, 0x29, 0xf7, 0xac, 0x7b, 0xb0, 0xe1, 0x63, 0x5f, 0x7f, 0x52, 0xc5, 0xb6, 0xd6, 0x49, 0x7a, 0xd, 0xb6, 0x12, 0x5b, 0xf0, 0xb2, 0xfd, 0xc0, 0x6c, 0x8f, 0x72, 0xfe, 0x16, 0xf4, 0xd7, 0x5d, 0x5e, 0xf9, 0x62, 0x7, 0x86, 0xc8, 0x5d, 0xc, 0x12, 0x8a, 0xec, 0xdd, 0x36, 0x23, 0x90, 0x3, 0x9e, 0x25, 0x48, 0xd1, 0xdc, 0xaa, 0x0, 0x8b, 0xf, 0xd8, 0x70, 0xbe, 0x34, 0xe4, 0xe, 0x66, 0xc0, 0xae, 0xfc, 0xa2, 0x8b, 0xc6, 0x31, 0xb8, 0xfd, 0x80, 0x31, 0xfe, 0x7a, 0x5f, 0x39, 0xe8, 0x1d, 0x19, 0xc0, 0xcc, 0xa1, 0x8f, 0x1a, 0xec, 0xbb, 0x8a, 0xe0, 0xc9, 0xa4, 0xd1, 0xb, 0x85, 0x39, 0x3c, 0xb5, 0x84, 0x12, 0xb5, 0x65, 0xa2, 0x99, 0x99, 0xcd, 0x3, 0x98, 0x83, 0xeb, 0x9, 0x55, 0x47, 0xe8, 0xcb, 0xf5, 0x89, 0xb0, 0x86, 0x44, 0x4f, 0xe, 0xc3, 0x2, 0x23, 0x6e, 0x6e, 0xfc, 0x50, 0x8c, 0x3c, 0x8, 0x87, 0x3c, 0xfe, 0x13, 0xd5, 0x65, 0xf5, 0x50, 0x87, 0x90, 0xfd, 0xac, 0x23, 0x91, 0x58, 0xae, 0x65, 0xa2, 0x38, 0x19, 0xf3, 0x65, 0xec, 0xbf, 0x45, 0x86, 0xea, 0xaf, 0x39, 0xa5, 0xb7, 0x3c, 0xe6, 0xaf, 0xef, 0x65, 0x33, 0xd5, 0x6d, 0x20, 0x75, 0x87, 0x20, 0xf2, 0x2e, 0x27, 0xe2, 0xa4, 0xbe, 0x8, 0x65, 0x9b, 0x5b, 0x74, 0x9a, 0xc2, 0x9, 0x91, 0xe, 0xaf, 0x59, 0xe, 0x5d, 0x12, 0x76, 0xb8, 0xce, 0x3b, 0xcc, 0x49, 0x33, 0x1f, 0xe7, 0x38, 0x13, 0x41, 0x7c, 0xb, 0x1e, 0x6e, 0xfb, 0xb2, 0x41, 0x8c, 0x82, 0x72, 0x46, 0x7, 0x3, 0x24, 0x33, 0xa0, 0xd7, 0x20, 0xc3, 0x81, 0x47, 0x4e, 0xba, 0x57, 0x49, 0x30, 0x5d, 0x8f, 0xee, 0x12, 0x30, 0xee, 0xb, 0xef, 0x48, 0x28, 0x6e, 0x60, 0x2c, 0x59, 0x3b, 0x9c, 0x54, 0x34, 0xcd, 0x5e, 0x4d, 0xaa, 0x36, 0xed, 0x48, 0xc4, 0x7b, 0xb9, 0xb5, 0x40, 0xf0, 0x77, 0xd2, 0x1f, 0xef, 0xf3, 0x69, 0x17, 0x9c, 0x44, 0x36, 0x65, 0xcc, 0xb9, 0x8b, 0xa0, 0xd5, 0xa7, 0xb8, 0x93, 0x2a, 0x8d, 0xd7, 0xd5, 0xdc, 0x2, 0xf, 0x62, 0x61, 0xe2, 0x4f, 0xde, 0xa9, 0xc6, 0x61, 0x1a, 0x9, 0x6b, 0xbf, 0xfc, 0x44, 0xaa, 0xd9, 0x97, 0xc7, 0xbb, 0x3e, 0xa3, 0x23, 0x5, 0xa6, 0xab, 0x41, 0xe3, 0x3c, 0x55, 0xf0, 0x27, 0xd3, 0xa9, 0x90, 0x52, 0x0, 0x17, 0xcb, 0x8c, 0xc9, 0x50, 0x94, 0xd2, 0x25, 0xc9, 0x8f, 0xe7, 0xff, 0xc2, 0x1c, 0x44, 0x80, 0x96, 0x73, 0x76, 0xec, 0x8a, 0x22, 0xb2, 0x21, 0x6f, 0xe4, 0x67, 0xc4, 0x9e, 0x50, 0xed, 0x8c, 0xcc, 0x42, 0xfe, 0x9b, 0xb3, 0xc5, 0x21, 0xb, 0x8, 0x6a, 0x9f, 0xf1, 0x94, 0x7, 0x48, 0x42, 0xaf, 0xff, 0xfd, 0xa8, 0xf4, 0x73, 0x4e, 0x35, 0x4c, 0x97, 0x1d, 0xda, 0xa4, 0x8f, 0x38, 0xfb, 0xa1, 0xb7, 0xd5, 0xcd, 0x74, 0xf7, 0x43, 0x3e, 0xf5, 0xa4, 0x5d, 0xf, 0x6c, 0xf1, 0xd9, 0x90, 0x80, 0xc2, 0xa7, 0xc0, 0xde, 0xa6, 0xe8, 0xad, 0xf5, 0x1b, 0xd5, 0x9a, 0xaa, 0x50, 0x2e, 0x75, 0xc9, 0x6b, 0xf6, 0xd5, 0x39, 0x74, 0xda, 0x31, 0xaf, 0x2, 0x78, 0x43, 0xf3, 0xaf, 0xcc, 0x34, 0xce, 0x1e, 0xcb, 0x81, 0xb6, 0x14, 0xe9, 0xd2, 0xc3, 0x82, 0xd8, 0xb0, 0xb6, 0x0, 0x7c, 0xb4, 0xc5, 0x4e, 0xc5, 0x7, 0xfe, 0xeb, 0xed, 0x99, 0x92, 0xdf, 0x8d, 0x12, 0x51, 0xc7, 0x4e, 0x79, 0xb5, 0x70, 0xee, 0x4c, 0x26, 0x8d, 0x8e, 0x3, 0xcd, 0x85, 0x73, 0x0, 0x5f, 0x17, 0xdc, 0xe2, 0x4c, 0x6a, 0x52, 0xc0, 0x76, 0x99, 0x5e, 0x72, 0xab, 0x5f, 0x72, 0xf2, 0x90, 0x68, 0x20, 0x81, 0x93, 0x2e, 0x33, 0x57, 0xf4, 0xcf, 0x6, 0x59, 0xf5, 0xac, 0x6a, 0xd, 0x32, 0x4c, 0x9f, 0x52, 0x81, 0x1b, 0xb5, 0x2c, 0x9c, 0xd0, 0xcc, 0x85, 0x81, 0x78, 0xb9, 0x28, 0x3a, 0xa5, 0x3c, 0x52, 0x30, 0x45, 0x0, 0x4b, 0x2b, 0x55, 0xbc, 0x27, 0x3a, 0x49, 0xca, 0xc1, 0x7b, 0x95, 0xe3, 0x6f, 0x8d, 0x39, 0xc6, 0x48, 0x77, 0x53, 0x1, 0x41, 0xc6, 0x68, 0xda, 0x71, 0x5c, 0x3e, 0x1b, 0x2e, 0x21, 0x72, 0x42, 0x27, 0x28, 0xc1, 0xf7, 0xc1, 0xfd, 0xd3, 0x47, 0x6d, 0x13, 0x48, 0x7f, 0x19, 0x3c, 0xb1, 0x8c, 0x1f, 0xce, 0xf4, 0x3c, 0xce, 0x59, 0x4b, 0x54, 0x8f, 0x16, 0x4a, 0x24, 0xd2, 0xe0, 0xc1, 0x5d, 0xd4, 0xf6, 0x56, 0x14, 0xc0, 0xf0, 0xbe, 0xd2, 0x59, 0x7b, 0x45, 0x3a, 0x93, 0x49, 0xec, 0x79, 0xf1, 0x54, 0xe5, 0x2e, 0x9f, 0xb7, 0x4e, 0xb5, 0x51, 0x61, 0x46, 0x66, 0x17, 0x94, 0x3c, 0xc9, 0x18, 0x9e, 0x68, 0x1a, 0x3c, 0xa5, 0x11, 0x50, 0xce, 0x23, 0xb3, 0x0, 0x9a, 0xe9, 0x91, 0x64, 0x9c, 0x88, 0x26, 0x29, 0xf7, 0x6f, 0xfa, 0x91, 0x61, 0xba, 0xa1, 0xd0, 0x20, 0x42, 0xba, 0xf0, 0xd8, 0x16, 0xba, 0xcc, 0x3d, 0x3a, 0x5c, 0x90, 0x27, 0x9f, 0x39, 0x94, 0xd4, 0xa5, 0xee, 0xd4, 0xda, 0x64, 0x95, 0xcd, 0xf9, 0x56, 0xe, 0x90, 0xd, 0x7a, 0x7e, 0x58, 0x2c, 0xcb, 0x92, 0xe5, 0x43, 0xc3, 0xe4, 0x2a, 0xbc, 0xbf, 0xc2, 0xa8, 0xd5, 0x3e, 0x91, 0x41, 0x94, 0x2e, 0x3b, 0x58, 0x11, 0x5b, 0x6b, 0x64, 0xaa, 0x65, 0x4f, 0x9c, 0x8e, 0xa1, 0xb8, 0x56, 0x58, 0x8d, 0x46, 0x4b, 0x9a, 0x6a, 0x64, 0x2d, 0xf, 0xcf, 0x44, 0x30, 0xb8, 0x86, 0x37, 0x20, 0x67, 0x58, 0xaf, 0x50, 0xd, 0xaa, 0x35, 0xc7, 0xb6, 0x52, 0xa8, 0x44, 0xed, 0xbb, 0xfd, 0x90, 0x8a, 0xa9, 0x3b, 0x79, 0x29, 0x24, 0x82, 0x80, 0xdb, 0xf4, 0x8c, 0xf1, 0xcb, 0xab, 0xe1, 0x5a, 0xca, 0x2, 0xfe, 0x6d, 0x72, 0xbf, 0xe7, 0xfb, 0xac, 0x98, 0xa0, 0x3, 0x2a, 0x32, 0x34, 0x6f, 0x40, 0xb2, 0xec, 0xeb, 0x6d, 0xe2, 0xbe, 0x6e, 0x58, 0xf, 0x89, 0xa8, 0x6e, 0x4e, 0xac, 0xaf, 0xe, 0x95, 0x2e, 0x50, 0x85, 0x37, 0x56, 0x65, 0x77, 0xdd, 0x6d, 0xe6, 0xbe, 0xf2, 0xfc, 0x93, 0x55, 0x9b, 0x96, 0xe6, 0x4a, 0x2a, 0x9f, 0x93, 0x34, 0xc3, 0xc2, 0x6d, 0xb, 0xbd, 0x84, 0x97, 0x88, 0xf3, 0x28, 0x42, 0x9d, 0x3a, 0x8b, 0x26, 0x64, 0x7c, 0x96, 0xb3, 0xd5, 0x53, 0xf3, 0x80, 0x61, 0x9a, 0xd4, 0xf7, 0x99, 0xbb, 0xbd, 0x56, 0xaf, 0xf2, 0x2c, 0xe8, 0xb6, 0x1f, 0xe7, 0xc1, 0x8e, 0xd8, 0x8e, 0xbb, 0x5d, 0xbc, 0x47, 0x96, 0xbc, 0xe0, 0x16, 0x6, 0xd1, 0xeb, 0x76, 0x2f, 0xb1, 0x1f, 0xdb, 0xbd, 0x3c, 0xc6, 0xc5, 0x5a, 0xeb, 0x68, 0xbd, 0x93, 0xe9, 0xf3, 0x55, 0xcf, 0x7b, 0x7, 0xcf, 0xd0, 0x5c, 0x25, 0x2, 0xf0, 0xba, 0x79, 0x2c, 0x77, 0x3, 0xa0, 0x30, 0xc5, 0x2c, 0xbd, 0x54, 0x5f, 0x39, 0x41, 0x8, 0x14, 0xc, 0xb9, 0xb5, 0xa1, 0x49, 0xb6, 0x16, 0xfb, 0x6a, 0x45, 0xdb, 0xa5, 0x9b, 0x51, 0x18, 0xb6, 0x6c, 0xb0, 0x94, 0x9a, 0x3d, 0xb9, 0xe3, 0x9e, 0xde, 0xa, 0xbc, 0x2e, 0x2e, 0x4f, 0x76, 0xcb, 0xfc, 0x32, 0xd7, 0xd9, 0x8d, 0x36, 0xd2, 0x3e, 0x75, 0x7f, 0x3c, 0x5b, 0x3c, 0xd3, 0xb3, 0x79, 0x16, 0xb2, 0xcc, 0x32, 0xe4, 0xfb, 0x4c, 0xe1, 0x91, 0xc0, 0x3e, 0xdd, 0x7a, 0xb4, 0xf0, 0x61, 0xc5, 0xf1, 0x7, 0x5e, 0x59, 0x32, 0x8e, 0xb6, 0x96, 0xe7, 0xd0, 0x0, 0xc9, 0x14, 0x9c, 0x93, 0x12, 0x6a, 0xad, 0x94, 0xe3, 0x8, 0x84, 0xc9, 0x76, 0x17, 0x2e, 0x75, 0xbf, 0x25, 0x96, 0x77, 0x85, 0xeb, 0xb5, 0xaf, 0xa6, 0x84, 0x9, 0xda, 0xe8, 0x73, 0xa6, 0x12, 0xa7, 0x44, 0xa1, 0x52, 0x4c, 0x2b, 0x96, 0x84, 0x3d, 0xe6, 0x1b, 0xb9, 0x59, 0xdb, 0xc7, 0xdc, 0x78, 0x2b, 0x42, 0xc3, 0x91, 0x71, 0xf6, 0xc, 0x42, 0x4, 0x97, 0xdb, 0x5f, 0x77, 0xbd, 0x5f, 0x84, 0xb5, 0x2c, 0xc3, 0x92, 0x46, 0x5, 0xf5, 0x34, 0x0, 0x5f, 0x80, 0x68, 0xd2, 0x4c, 0x47, 0xef, 0x82, 0xed, 0x7c, 0xd4, 0xe5, 0x21, 0x65, 0x1, 0xc3, 0x30, 0x4b, 0xda, 0x36, 0x59, 0x90, 0x6e, 0x8a, 0xfb, 0x98, 0xc7, 0x4f, 0x86, 0x5d, 0xab, 0x33, 0xa7, 0x0, 0xa6, 0xc8, 0x83, 0x9e, 0x40, 0x5b, 0xc6, 0xce, 0xe1, 0xc3, 0x61, 0xa7, 0x2f, 0xb6, 0xba, 0xf4, 0xb1, 0x18, 0x3f, 0xc8, 0x0, 0xbd, 0xee, 0xdb, 0xef, 0x14, 0x1a, 0x59, 0x72, 0x53, 0xad, 0x54, 0xfe, 0x11, 0xd6, 0xdb, 0x36, 0x18, 0x65, 0xdd, 0x58, 0x82, 0x51, 0x16, 0xb5, 0x34, 0xae, 0x8, 0xb0, 0x75, 0x86, 0x37, 0x1a, 0x37, 0x91, 0xfc, 0x62, 0x71, 0xc, 0x43, 0x56, 0xe2, 0xbe, 0x12, 0x70, 0xd, 0xdf, 0xc7, 0xf3, 0xe3, 0x9, 0xf5, 0xec, 0xac, 0x47, 0x54, 0xa4, 0xa2, 0xce, 0xe2, 0x66, 0xa3, 0x7d, 0x67, 0xa3, 0xf8, 0xcf, 0x97, 0xc4, 0x5d, 0x37},
+               output224: []byte{0x99, 0x98, 0x71, 0xb0, 0x57, 0xe1, 0x4, 0xe8, 0xa, 0x48, 0x85, 0xe3, 0x5b, 0x72, 0xe0, 0xd5, 0x79, 0xb5, 0x2b, 0x29, 0xc4, 0x4c, 0xfc, 0x36, 0xb9, 0xd4, 0x4, 0x6c},
+               output256: []byte{0xf3, 0x3c, 0x45, 0xd1, 0x42, 0xe, 0xee, 0xac, 0x9f, 0xa7, 0x38, 0x46, 0xc0, 0x80, 0xae, 0xaa, 0x5, 0x25, 0x34, 0x4, 0xf7, 0xd4, 0x2, 0x8f, 0x57, 0x45, 0x7c, 0x4a, 0xfe, 0x15, 0x45, 0xde},
+               output384: []byte{0x5c, 0xb2, 0x75, 0xf4, 0x61, 0x2f, 0xb, 0x3a, 0xf3, 0x1e, 0xa2, 0x9b, 0x1e, 0xbf, 0xc7, 0xd8, 0x8, 0xd1, 0x45, 0xe6, 0x95, 0x4f, 0x33, 0x7e, 0x9e, 0xb5, 0xd9, 0xef, 0x45, 0x20, 0x97, 0xf3, 0xd, 0x44, 0x18, 0x27, 0xed, 0x72, 0x72, 0x9c, 0xc9, 0x5, 0x1e, 0x45, 0x83, 0xcd, 0x4f, 0x11},
+               output512: []byte{0xf1, 0xc0, 0x97, 0x6f, 0xfd, 0xfb, 0xbd, 0x9e, 0xb4, 0x6f, 0xbf, 0xaa, 0x34, 0x10, 0x94, 0x91, 0x91, 0xc, 0xef, 0x2f, 0x2b, 0xce, 0x2, 0x4a, 0x60, 0x89, 0x6e, 0x80, 0xe9, 0x2e, 0x60, 0xc5, 0xc, 0x99, 0x35, 0x23, 0xe, 0x5e, 0x16, 0x52, 0x4c, 0x17, 0x5, 0x3f, 0xc, 0x71, 0x9d, 0xba, 0xba, 0xe3, 0xfe, 0xa9, 0xfd, 0x4a, 0x88, 0xff, 0xc0, 0x2d, 0x6a, 0x2a, 0x48, 0x3f, 0x33, 0x8d}},
+       testcase{
+               msg:       []byte{0x4f, 0xa3, 0xdf, 0x1d, 0xea, 0x75, 0xad, 0x4b, 0x9c, 0x37, 0x92, 0x6, 0xa9, 0x5f, 0xed, 0x93, 0x0, 0x0, 0x48, 0x2e, 0x5b, 0x68, 0x3f, 0xd2, 0xb1, 0x7d, 0xc8, 0xe7, 0xd5, 0xc4, 0xbc, 0x1b, 0x73, 0x18, 0x6c, 0xcc, 0x13, 0xc9, 0xff, 0x2d, 0xd0, 0x9f, 0xc1, 0xd4, 0xf6, 0x80, 0x34, 0xd1, 0x20, 0xe8, 0x4c, 0xa7, 0x3a, 0x0, 0xb7, 0x1a, 0x3b, 0x46, 0xd1, 0xef, 0xc6, 0xff, 0x88, 0xcf, 0x2e, 0xda, 0x65, 0x81, 0xb, 0x9, 0x8c, 0xc5, 0xe6, 0x51, 0xd9, 0xcf, 0x6, 0x4e, 0x87, 0x7, 0x6d, 0x5a, 0x87, 0x18, 0x49, 0xf3, 0xb4, 0x5, 0xd3, 0xd5, 0x8e, 0xf5, 0xb1, 0xf1, 0x5, 0x20, 0xa9, 0xfb, 0x4f, 0xc8, 0x4a, 0x81, 0xa8, 0x7b, 0x13, 0xdb, 0xfb, 0xf9, 0xd8, 0x67, 0x49, 0x43, 0xe2, 0x8c, 0x25, 0x7e, 0x46, 0xd8, 0xad, 0x7b, 0xe1, 0x78, 0x5f, 0x1d, 0xc7, 0xc9, 0xb1, 0xbd, 0x57, 0x4a, 0xd1, 0xdd, 0xa4, 0x8f, 0x2, 0x55, 0xc8, 0x53, 0xd2, 0x49, 0xb, 0xd3, 0xd6, 0x3d, 0xa2, 0x2a, 0x83, 0x69, 0xcf, 0xd0, 0x25, 0x94, 0x99, 0x9a, 0x2e, 0xf4, 0x43, 0x30, 0x8f, 0xb8, 0x29, 0x82, 0x66, 0xa1, 0x1e, 0xfa, 0x17, 0x71, 0x2, 0xc7, 0x5d, 0xc6, 0x74, 0xe8, 0x9f, 0xc9, 0xdc, 0xc1, 0xa0, 0xd3, 0xc8, 0x63, 0xbc, 0x26, 0x14, 0x11, 0x2, 0x17, 0x5d, 0x26, 0x78, 0xeb, 0x6e, 0x13, 0xd9, 0xb, 0xbd, 0x9a, 0x5e, 0xb8, 0x9a, 0xe8, 0xc0, 0xcb, 0x47, 0xd7, 0xf3, 0x40, 0xd3, 0xd3, 0x20, 0x42, 0xa2, 0x76, 0x2b, 0xc9, 0xbf, 0x2b, 0x40, 0xeb, 0x40, 0xe8, 0x7f, 0xb4, 0x26, 0x10, 0xfe, 0x7e, 0x35, 0x70, 0x51, 0xf0, 0x14, 0x94, 0x70, 0x4f, 0xbf, 0xf7, 0x33, 0x21, 0xb4, 0x73, 0x1, 0xa0, 0x79, 0x9b, 0x7e, 0xe3, 0xfe, 0x5e, 0x62, 0x20, 0xf, 0x39, 0x7a, 0x61, 0xed, 0x45, 0x9, 0xa6, 0x2f, 0x71, 0x6, 0xed, 0xe, 0xfb, 0xa, 0xbd, 0x6a, 0xe9, 0xe4, 0xa1, 0xfe, 0x9b, 0x2, 0xc0, 0x92, 0xdc, 0xdc, 0x75, 0x1, 0x5c, 0xf6, 0x2, 0xf3, 0xb9, 0xa8, 0x98, 0x8b, 0x60, 0x9e, 0x6c, 0xd, 0x1c, 0x5c, 0x3e, 0x21, 0x9f, 0xf5, 0x78, 0x75, 0xc2, 0xef, 0x1, 0x61, 0x5f, 0x89, 0x44, 0x7e, 0xa6, 0x2, 0xdf, 0xc9, 0x4e, 0xec, 0x17, 0xa3, 0x98, 0xc0, 0x14, 0xbd, 0x34, 0x66, 0x91, 0xfe, 0x20, 0x9a, 0x0, 0x27, 0x71, 0xdc, 0x81, 0x64, 0x42, 0x2c, 0xd1, 0x66, 0xaf, 0xb4, 0x57, 0xa8, 0xb3, 0x7, 0x12, 0x82, 0x17, 0x8a, 0x3e, 0xbd, 0x20, 0x1d, 0x9b, 0x7, 0xb2, 0x7e, 0x71, 0x1e, 0x7e, 0xe7, 0xd3, 0x3a, 0xa5, 0x21, 0xe, 0xd4, 0xe4, 0xe9, 0x24, 0x86, 0x77, 0x5d, 0x14, 0xa6, 0xce, 0xd0, 0x92, 0xe3, 0x4a, 0x7a, 0xc8, 0x26, 0x70, 0x93, 0x99, 0x48, 0xfe, 0xc1, 0x49, 0xf9, 0xc0, 0x18, 0xfc, 0xaa, 0xd3, 0xfc, 0x59, 0x7d, 0x31, 0x57, 0x13, 0xf4, 0x4f, 0xc5, 0xe1, 0x72, 0x5f, 0x44, 0x8e, 0xca, 0xed, 0x40, 0xe8, 0xd8, 0x41, 0xbd, 0x2, 0xf1, 0xe8, 0x1c, 0x1, 0x9b, 0x8, 0xf9, 0x94, 0x12, 0xe3, 0x60, 0xc0, 0xbd, 0x37, 0x83, 0x91, 0xc6, 0x7d, 0x96, 0x4b, 0x47, 0xf5, 0xc, 0x26, 0xf0, 0xa4, 0x83, 0xed, 0x66, 0x40, 0x23, 0x61, 0x6b, 0xf, 0xc9, 0xaf, 0xe4, 0x36, 0x20, 0xdb, 0xe9, 0xcc, 0xfe, 0x7, 0xe, 0xf2, 0x95, 0xc0, 0x49, 0xea, 0xc7, 0x54, 0xc2, 0x12, 0x31, 0x30, 0xc6, 0xb2, 0xc0, 0x23, 0x2f, 0x64, 0x3, 0xaa, 0x7f, 0xd, 0xc3, 0x5a, 0x59, 0x99, 0xbf, 0x95, 0xd3, 0x4a, 0xd6, 0x12, 0x23, 0x4c, 0x62, 0x89, 0x27, 0x7a, 0xdb, 0x60, 0xe4, 0xf7, 0x2e, 0xc2, 0xdf, 0x57, 0xf, 0x5, 0x39, 0x5b, 0x3b, 0xe8, 0xa0, 0xa3, 0xc7, 0x8b, 0x73, 0x28, 0x21, 0xaa, 0x8, 0x92, 0x7c, 0x52, 0x4e, 0x15, 0xd6, 0x5f, 0x66, 0xa3, 0xdb, 0x8c, 0x1c, 0x96, 0xfb, 0x70, 0xbc, 0x6, 0x86, 0xaa, 0xc3, 0x10, 0x5, 0x1f, 0x46, 0x9f, 0xc5, 0xef, 0x88, 0xc, 0xf, 0x66, 0x94, 0x7c, 0x1c, 0x32, 0x8f, 0x97, 0x68, 0x4e, 0xa2, 0x4c, 0xbe, 0x63, 0xba, 0xed, 0x8d, 0x11, 0x4f, 0x40, 0x50, 0x7c, 0x29, 0x1, 0x3, 0x4e, 0x6a, 0xb3, 0x89, 0x3f, 0x36, 0x6d, 0x53, 0xf1, 0xcf, 0xca, 0x30, 0x93, 0x9, 0x21, 0x8c, 0xab, 0xce, 0xca, 0x47, 0x22, 0xfa, 0x9c, 0xcb, 0xc7, 0x24, 0x9b, 0x87, 0xc1, 0x2f, 0xf8, 0x39, 0x7f, 0x40, 0x48, 0x7e, 0xb0, 0x0, 0x82, 0xe7, 0xf5, 0x51, 0xd2, 0x7e, 0x30, 0x1c, 0x3b, 0xc7, 0xb5, 0x38, 0x9f, 0x70, 0x42, 0x53, 0x4b, 0xf7, 0xe6, 0x92, 0xdf, 0xea, 0x4d, 0xa2, 0x4f, 0x7c, 0x34, 0xb8, 0xd2, 0xff, 0x14, 0x5f, 0x54, 0xb5, 0x17, 0xfc, 0x97, 0x13, 0x4e, 0xc5, 0xac, 0x2c, 0xb9, 0x25, 0xc5, 0x8, 0xd7, 0xa6, 0xbd, 0x1, 0xfe, 0x7b, 0x76, 0x46, 0x48, 0x27, 0x49, 0x72, 0xbf, 0x8, 0x56, 0xd, 0x30, 0x80, 0x2e, 0xe, 0xb7, 0xed, 0xcc, 0x57, 0xaf, 0x47, 0x97, 0xbb, 0xf9, 0x2e, 0x86, 0x88, 0x26, 0x86, 0x6, 0xb0, 0xf1, 0xbc, 0x90, 0x1f, 0xcc, 0x22, 0x13, 0x62, 0x81, 0x66, 0x5e, 0xc1, 0x63, 0x93, 0xfa, 0x96, 0x1, 0xc4, 0xfb, 0xdb, 0x18, 0xcd, 0x1d, 0x1e, 0xe3, 0x82, 0xbc, 0x7, 0x97, 0x39, 0x3, 0xe9, 0x1f, 0xfa, 0x87, 0x39, 0x9d, 0x11, 0x41, 0xd4, 0x9f, 0x4f, 0xc, 0x6, 0x4a, 0xcf, 0x3a, 0xc9, 0x89, 0x78, 0x91, 0xdf, 0x10, 0xbc, 0xa0, 0x11, 0x6f, 0x2c, 0x3f, 0xef, 0x18, 0xf, 0xe6, 0xa8, 0xe9, 0x37, 0xc4, 0x78, 0xf2, 0xef, 0x29, 0x3a, 0xe9, 0x18, 0x6d, 0xcb, 0x1f, 0x76, 0xb6, 0xe4, 0x81, 0x1, 0xdf, 0x64, 0xe5, 0x7e, 0xa7, 0xc6, 0x4c, 0x5c, 0x0, 0x25, 0xe2, 0x21, 0xc8, 0xf5, 0xcb, 0xa5, 0xcc, 0x92, 0xd9, 0xce, 0xc6, 0x28, 0x14, 0x9, 0x96, 0xb2, 0x6d, 0x17, 0xf4, 0x39, 0xb7, 0x80, 0xf5, 0x9a, 0x99, 0x93, 0x1, 0x12, 0x2f, 0x82, 0xd0, 0x49, 0x5f, 0x8a, 0xb5, 0xae, 0x1e, 0xa5, 0x79, 0xf, 0x45, 0xe9, 0x92, 0xdf, 0xe0, 0xd, 0x5f, 0x82, 0xa7, 0xff, 0x13, 0x54, 0xae, 0xfd, 0xce, 0xfc, 0xd, 0x2d, 0x17, 0x31, 0xd2, 0x2f, 0xa2, 0xb7, 0x5a, 0xfd, 0x4f, 0xda, 0x25, 0xab, 0x19, 0x40, 0x55, 0xfa, 0x96, 0x28, 0x38, 0x10, 0x55, 0x24, 0x7c, 0x8c, 0x75, 0x87, 0xd2, 0x2e, 0x73, 0xc6, 0x1, 0x36, 0xc4, 0x28, 0x24, 0x52, 0xd4, 0x7a, 0xe0, 0x3a, 0xa0, 0x35, 0xfe, 0xbc, 0x26, 0xfc, 0xcd, 0x42, 0xa1, 0xcb, 0x79, 0xcf, 0x86, 0x6d, 0xb6, 0x41, 0x8a, 0x49, 0xfd, 0x82, 0x61, 0xe8, 0x77, 0xdd, 0xbb, 0x83, 0x9c, 0xc3, 0x95, 0x14, 0xdd, 0xb8, 0x7a, 0x8a, 0x40, 0xd7, 0x95, 0x53, 0x26, 0x26, 0xfe, 0xa4, 0xa4, 0xc3, 0x5d, 0x13, 0xe0, 0x28, 0xf9, 0xed, 0x1b, 0xc0, 0x9b, 0x6, 0xbe, 0x99, 0x9b, 0x8d, 0xdd, 0x22, 0x58, 0xaa, 0x5, 0x96, 0xbc, 0xbb, 0xf7, 0x2a, 0xf6, 0x7e, 0x10, 0xbe, 0xdd, 0x58, 0xd5, 0x99, 0xb8, 0xd5, 0x77, 0xa5, 0x83, 0xd6, 0x76, 0xbf, 0x55, 0x61, 0xf8, 0xc, 0xe5, 0xe9, 0x52, 0x87, 0x29, 0xa9, 0x2d, 0xf5, 0x78, 0xfe, 0x75, 0xdb, 0xc7, 0x4, 0x74, 0xb7, 0x57, 0x47, 0xa8, 0xd5, 0x5d, 0xe7, 0xe, 0x57, 0xbd, 0xd6, 0x2d, 0x43, 0x44, 0xdc, 0x21, 0x15, 0xed, 0x4d, 0xd6, 0x2f, 0x1f, 0xc9, 0x8b, 0xfa, 0x1e, 0x74, 0x21, 0xfc, 0x7, 0x0, 0x2, 0x5c, 0x46, 0xd0, 0xed, 0x1b, 0xef, 0x35, 0xc3, 0xb7, 0x78, 0x56, 0x32, 0x11, 0xb9, 0xfa, 0x9e, 0x8b, 0xa4, 0xbb, 0xcb, 0xf0, 0x1c, 0x2f, 0xb6, 0x26, 0xab, 0x7e, 0xf3, 0x25, 0xce, 0x9f, 0x46, 0x8d, 0xf2, 0xca, 0xcd, 0xb1, 0x78, 0xd3, 0x65, 0x57, 0xcd, 0x85, 0xd5, 0x42, 0xc0, 0x67, 0xc2, 0x89, 0xe9, 0x26, 0xc1, 0xea, 0x2f, 0x20, 0xab, 0xd3, 0x29, 0xe9, 0x84, 0x16, 0x8b, 0xb6, 0xde, 0xf1, 0xdd, 0xcc, 0xf2, 0x14, 0xdc, 0xb6, 0xa5, 0x3a, 0xfd, 0x46, 0x2f, 0xe, 0x7e, 0x7a, 0x19, 0xe8, 0xc8, 0x8f, 0x4, 0x92, 0x44, 0x12, 0x5a, 0x6d, 0x7d, 0xd4, 0x1e, 0x58, 0xbc, 0x9b, 0x2f, 0xf7, 0xfa, 0x24, 0x78, 0xdf, 0x76, 0xaf, 0x73, 0x9, 0xc, 0xb1, 0xab, 0x59, 0xe3, 0x88, 0xba, 0x20, 0xe2, 0xc2, 0x97, 0xc9, 0x67, 0x73, 0x7a, 0x1a, 0xf6, 0x17, 0x93, 0xb6, 0x8e, 0xcd, 0x74, 0x39, 0x44, 0x4c, 0x48, 0xe2, 0x8e, 0x2d, 0x9, 0xc4, 0x8f, 0xad, 0xa5, 0xe0, 0xd1, 0xd1, 0x5e, 0x5b, 0x34, 0xa, 0x52, 0xf8, 0xb3, 0xb8, 0x54, 0xcc, 0xa4, 0x79, 0xf0, 0xa5, 0x98, 0x44, 0x5e, 0x14, 0xf5, 0x3b, 0x3b, 0xa3, 0x68, 0x91, 0x5, 0xc, 0x79, 0x67, 0x3d, 0xf3, 0xe2, 0xb5, 0x82, 0x5c, 0x95, 0x5a, 0x29, 0xe5, 0xc9, 0xa2, 0x2f, 0x39, 0x91, 0xd0, 0xaa, 0x78, 0x57, 0x18, 0xcf, 0xea, 0x1d, 0x23, 0x85, 0xf8, 0xe4, 0x7e, 0x4a, 0x75, 0xac, 0xbc, 0x79, 0x88, 0xd0, 0x55, 0x8d, 0x54, 0x1d, 0x71, 0xc4, 0xe6, 0xc5, 0xf1, 0xcb, 0x15, 0xb6, 0xc, 0xea, 0xc, 0x34, 0xa6, 0x7b, 0xbc, 0xe1, 0x5, 0xd7, 0xa8, 0x96, 0x2, 0x5e, 0x2, 0x54, 0xde, 0x7d, 0x7a, 0xf7, 0x24, 0xc9, 0x2, 0x7d, 0x44, 0xb8, 0x64, 0x21, 0x92, 0xa0, 0x8a, 0xb8, 0xe1, 0xef, 0x30, 0x46, 0xdd, 0xa6, 0x1, 0x4d, 0xf7, 0xf4, 0xc9, 0xe6, 0x3c, 0x63, 0x5e, 0x48, 0xab, 0x2e, 0x70, 0xb6, 0x40, 0xd4, 0x80, 0x99, 0x8e, 0xc9, 0x35, 0x7e, 0x66, 0x5f, 0x99, 0xd7, 0x6f, 0xe5, 0x52, 0x9e, 0xf2, 0x3c, 0x1b, 0xdf, 0xe0, 0x17, 0xc3, 0xa6, 0x6c, 0xd4, 0xeb, 0x2d, 0xdb, 0x42, 0xef, 0x85, 0xea, 0xc, 0xd6, 0x55, 0x34},
+               output224: []byte{0x62, 0x97, 0xda, 0xbd, 0xc6, 0x6a, 0x68, 0xa2, 0x8e, 0x2f, 0x32, 0xfc, 0x95, 0xe5, 0x86, 0x40, 0x35, 0x0, 0x1c, 0xcb, 0x7a, 0xd, 0xcf, 0x59, 0x24, 0x67, 0xd4, 0x15},
+               output256: []byte{0xeb, 0x35, 0x18, 0x38, 0xfe, 0x82, 0x25, 0xfb, 0xeb, 0xea, 0x91, 0x68, 0xdb, 0xb7, 0x8, 0x87, 0x2c, 0xa4, 0x3a, 0xc9, 0x34, 0x80, 0xc3, 0xaf, 0xfb, 0xe6, 0xcc, 0x3a, 0x15, 0xa2, 0x26, 0x3c},
+               output384: []byte{0x3c, 0xb4, 0x48, 0x2b, 0x4f, 0x5f, 0xa1, 0x5b, 0x8c, 0x24, 0xa, 0xde, 0x9d, 0x99, 0x53, 0x4e, 0x8d, 0x91, 0x4a, 0x4c, 0x1, 0x29, 0xe, 0xf4, 0xb9, 0x41, 0x75, 0x97, 0x43, 0x1e, 0xdb, 0x1e, 0xce, 0x45, 0x6d, 0xc6, 0xb, 0x26, 0xfb, 0xd9, 0xc8, 0x8d, 0xb5, 0x80, 0x2d, 0x1c, 0xdc, 0xd9},
+               output512: []byte{0x7a, 0xee, 0x30, 0x93, 0x3, 0x55, 0x71, 0x86, 0x79, 0xd3, 0x87, 0xdf, 0xbe, 0xd0, 0x8e, 0xb7, 0x0, 0xb3, 0x24, 0xbb, 0x27, 0x75, 0xbc, 0xfd, 0x11, 0xa8, 0x8d, 0x37, 0xaa, 0x69, 0xa5, 0xb1, 0xb0, 0x1, 0xe, 0x8a, 0x5c, 0x38, 0xbb, 0x20, 0xe5, 0xe5, 0xdd, 0xcf, 0x5b, 0xb2, 0x43, 0x68, 0x30, 0xdc, 0xe8, 0xda, 0x20, 0x48, 0x19, 0x77, 0x56, 0xfc, 0x85, 0xb2, 0xc, 0x16, 0xf0, 0xa0}},
+       testcase{
+               msg:       []byte{0xbc, 0x25, 0x99, 0x72, 0xad, 0x10, 0x9b, 0xde, 0x60, 0x39, 0x99, 0x72, 0x8e, 0xf0, 0xbb, 0xf2, 0x3a, 0x91, 0x18, 0x29, 0xc1, 0xc9, 0x10, 0xf0, 0x51, 0x7a, 0xd7, 0x58, 0x4a, 0xab, 0x80, 0xb2, 0x7d, 0x4a, 0x59, 0x52, 0x3d, 0xb1, 0x1e, 0xf7, 0xb8, 0x6d, 0x73, 0xe4, 0x80, 0xf8, 0x26, 0x99, 0xe4, 0x4e, 0x2e, 0x28, 0x11, 0x72, 0xd4, 0x1c, 0xef, 0xe2, 0xa1, 0x5a, 0xae, 0x50, 0xe1, 0x39, 0x18, 0xef, 0xb6, 0x3d, 0xe0, 0x78, 0x5b, 0xa4, 0x15, 0xc7, 0xda, 0x37, 0x46, 0xa6, 0x69, 0xc7, 0xf6, 0xad, 0xac, 0x8c, 0x7e, 0xd0, 0x4f, 0xb5, 0xf8, 0xec, 0x70, 0x20, 0x76, 0x15, 0xc5, 0xb6, 0x15, 0x7f, 0x3b, 0xd9, 0xac, 0x31, 0x47, 0x8f, 0x50, 0x5, 0xf0, 0xe8, 0xde, 0x11, 0x39, 0xfd, 0xf4, 0xd, 0x2e, 0x1, 0xdb, 0xf5, 0x49, 0x73, 0xf7, 0x22, 0x5c, 0xa5, 0x45, 0xad, 0x7b, 0x8f, 0xac, 0x82, 0x33, 0xcc, 0x57, 0x9d, 0x4e, 0x6, 0x39, 0x5b, 0xae, 0x79, 0x1a, 0x5e, 0x49, 0x83, 0x8a, 0x80, 0x6f, 0x69, 0xb5, 0x78, 0x58, 0x61, 0x20, 0x63, 0x93, 0x52, 0x84, 0xf7, 0xaa, 0x2e, 0x37, 0x69, 0x10, 0x4f, 0x13, 0xf0, 0xd3, 0xc5, 0x31, 0xa3, 0xc7, 0x66, 0xb1, 0xf0, 0x8, 0xdb, 0x43, 0x7a, 0x2b, 0xbb, 0x4, 0x16, 0x91, 0xbb, 0x93, 0x77, 0x1, 0x2a, 0x9a, 0x73, 0x59, 0xba, 0x41, 0x8, 0x36, 0xef, 0x7b, 0xa9, 0x49, 0xe5, 0xf5, 0x6f, 0x70, 0xe8, 0x3c, 0x99, 0xdf, 0x96, 0x1c, 0xc3, 0xf4, 0x9d, 0x41, 0x33, 0xbe, 0xc5, 0x43, 0xdd, 0xaa, 0x14, 0xda, 0xba, 0xa5, 0x4f, 0xb6, 0xe5, 0xf5, 0x26, 0x3b, 0x83, 0xdf, 0x68, 0x63, 0xe8, 0x41, 0x79, 0x72, 0x25, 0x77, 0x10, 0x1c, 0xf3, 0xf6, 0x7c, 0x8, 0xc7, 0x53, 0xc5, 0xb0, 0x79, 0xde, 0x79, 0x5d, 0x29, 0x22, 0xfa, 0x21, 0xab, 0x23, 0xe2, 0x43, 0x7a, 0x64, 0xc6, 0x2a, 0xf6, 0x34, 0x98, 0x52, 0x66, 0x3, 0x9f, 0x7c, 0xbf, 0x1e, 0x1d, 0x76, 0x2d, 0xf4, 0x9f, 0x12, 0xa4, 0xff, 0x7e, 0xb9, 0x84, 0x6e, 0x8e, 0x5d, 0xce, 0xe5, 0x59, 0x8, 0x4f, 0xa, 0xd1, 0x75, 0xe0, 0xc6, 0xfc, 0xa9, 0x84, 0xb1, 0x68, 0xb7, 0x51, 0x25, 0x41, 0xb7, 0x56, 0xb, 0x68, 0xc8, 0xaf, 0xd0, 0x2f, 0xec, 0xe1, 0x15, 0xf0, 0xe9, 0x32, 0x7d, 0x3d, 0x6d, 0x57, 0xbc, 0x28, 0xc8, 0xf9, 0x14, 0xe9, 0xa5, 0xb3, 0x1d, 0x82, 0x2b, 0x48, 0xe0, 0xe4, 0x86, 0x5f, 0x65, 0x2e, 0x93, 0x13, 0xf0, 0xad, 0xe5, 0x66, 0x52, 0x29, 0x63, 0x19, 0x23, 0xa4, 0x97, 0xd6, 0x5e, 0x70, 0x17, 0x78, 0x73, 0x9c, 0x58, 0x42, 0xa0, 0x8a, 0x9, 0xfb, 0x25, 0x68, 0x3c, 0x38, 0xbb, 0x17, 0xeb, 0x95, 0xba, 0xb4, 0xb3, 0x58, 0xef, 0x56, 0x47, 0xbb, 0x29, 0xd3, 0xbf, 0x86, 0xe1, 0x58, 0x68, 0xe0, 0x2d, 0xa7, 0xe0, 0x22, 0x9e, 0x82, 0x13, 0x7, 0x1a, 0x24, 0xb4, 0xcd, 0x37, 0x32, 0x66, 0x56, 0x3e, 0x36, 0x46, 0x4c, 0x8b, 0x24, 0x5d, 0xe4, 0xa6, 0x2b, 0xe1, 0xaf, 0x9c, 0x70, 0x22, 0xf6, 0xc3, 0x89, 0x4d, 0xe6, 0xad, 0x8b, 0x9b, 0x17, 0xa6, 0xdf, 0x84, 0xaf, 0x65, 0x46, 0x6c, 0x31, 0x9b, 0xa4, 0x3a, 0x5e, 0xbd, 0xbf, 0x24, 0x83, 0x3c, 0xbc, 0xf1, 0x74, 0x10, 0xe7, 0x96, 0x37, 0xad, 0x5b, 0x77, 0x1b, 0x21, 0x57, 0x61, 0x13, 0xb8, 0x51, 0xbb, 0x73, 0xaf, 0x7b, 0xa9, 0xfa, 0x19, 0xe5, 0xcd, 0x7a, 0x53, 0x69, 0x6, 0x8a, 0x51, 0xf5, 0xd6, 0xa9, 0x28, 0xa8, 0x30, 0x68, 0x29, 0xb8, 0x10, 0xf5, 0x9c, 0xdd, 0xfb, 0x42, 0xc3, 0xb5, 0x8f, 0x6b, 0x9, 0x26, 0x87, 0x7d, 0xd3, 0x5c, 0x41, 0x73, 0x62, 0x8b, 0xb5, 0x54, 0xc7, 0x3, 0x67, 0x79, 0xc0, 0x0, 0xe8, 0xf, 0x93, 0xd2, 0x6c, 0x85, 0x60, 0xde, 0x78, 0x5, 0x7e, 0xa7, 0x4e, 0xb1, 0x22, 0x30, 0xc8, 0x31, 0xd, 0x57, 0x74, 0x73, 0xd9, 0x4c, 0x2d, 0xf1, 0x45, 0x77, 0xb4, 0x36, 0x1b, 0x30, 0x7d, 0x8b, 0xb6, 0x37, 0x1b, 0xa7, 0xb3, 0xf8, 0x64, 0x14, 0x88, 0xb1, 0x49, 0xb, 0x24, 0xda, 0x9c, 0xef, 0x1f, 0xfc, 0x73, 0x2c, 0xac, 0x6f, 0x9f, 0xcd, 0x69, 0x72, 0x8c, 0x1b, 0x7b, 0x4e, 0x72, 0xe8, 0xfc, 0x5c, 0x42, 0xb6, 0x68, 0x7f, 0x32, 0xfc, 0xf7, 0xb3, 0xa9, 0xa, 0x46, 0xe, 0x30, 0x2f, 0x3a, 0x4e, 0x33, 0xb5, 0x7b, 0x29, 0x80, 0x3c, 0x61, 0x1a, 0xd9, 0x3b, 0xe3, 0xe6, 0xc3, 0x3a, 0x8c, 0xef, 0xd2, 0xa5, 0x29, 0x7c, 0x28, 0x24, 0x9f, 0xb6, 0x4c, 0xe4, 0xc1, 0xa3, 0xd, 0xc1, 0xf8, 0x67, 0x4, 0x82, 0xcf, 0x6e, 0x22, 0xa, 0x3e, 0x17, 0xcc, 0x95, 0xad, 0xb2, 0x89, 0x19, 0x2f, 0xfc, 0xf0, 0x15, 0x5f, 0x7, 0x1a, 0xfe, 0x47, 0x3d, 0x5b, 0xbd, 0x42, 0x4, 0xfb, 0x43, 0x8, 0xcd, 0x5c, 0xe0, 0xf1, 0x30, 0x88, 0xa2, 0x58, 0x7f, 0x10, 0x36, 0x2d, 0x86, 0x46, 0x5c, 0x3a, 0xaa, 0xa7, 0x30, 0xcb, 0x82, 0x93, 0x3f, 0x56, 0x91, 0x2b, 0xe6, 0x2f, 0x78, 0xbd, 0x6a, 0x41, 0x3b, 0xd9, 0x84, 0x2d, 0x71, 0xf1, 0x25, 0xec, 0x8a, 0x7, 0x44, 0x2e, 0x1b, 0xb6, 0xae, 0x8b, 0x9a, 0xad, 0xa6, 0xbc, 0x47, 0xcc, 0x2f, 0xf7, 0x9b, 0x68, 0xf, 0x83, 0x26, 0x85, 0x18, 0x4f, 0xfc, 0xe0, 0x5e, 0xf1, 0x28, 0xd9, 0xd6, 0x46, 0x2c, 0xf7, 0x72, 0x8f, 0x2e, 0x58, 0x2f, 0x8b, 0xa7, 0x7e, 0xff, 0x16, 0x8, 0x5c, 0x26, 0x2f, 0x94, 0x5e, 0x3f, 0xb0, 0x6b, 0x23, 0x8b, 0x4a, 0x53, 0x45, 0xd1, 0xf8, 0x33, 0x73, 0xde, 0x40, 0xf9, 0x5e, 0xa, 0xe3, 0xc5, 0xf6, 0x2e, 0xf4, 0xbe, 0xc3, 0x66, 0x36, 0x88, 0x29, 0x4f, 0x64, 0xd1, 0x53, 0x10, 0xb6, 0xcc, 0xf4, 0xaa, 0xb0, 0x3a, 0x35, 0x8b, 0x0, 0x71, 0x11, 0x4b, 0xb3, 0x68, 0xff, 0x48, 0x9a, 0xc, 0xaf, 0x7b, 0x22, 0x2c, 0x1, 0x3d, 0xd5, 0xd9, 0xac, 0x39, 0xc7, 0x36, 0xfb, 0xc2, 0xf7, 0xea, 0xb5, 0xb4, 0xf5, 0xda, 0x46, 0x1c, 0x8e, 0x65, 0xd9, 0x59, 0x14, 0xb, 0xdf, 0xfd, 0x2a, 0x87, 0x18, 0x58, 0xac, 0xd3, 0xf9, 0xdd, 0xae, 0xce, 0x49, 0x7b, 0x44, 0x56, 0x55, 0x60, 0xfa, 0x96, 0xca, 0x9b, 0x76, 0x17, 0x64, 0xc6, 0xba, 0x9d, 0x8, 0x88, 0xcf, 0x52, 0x24, 0x10, 0xb6, 0x5, 0x56, 0x7d, 0x1f, 0xec, 0x21, 0x26, 0x4a, 0xd4, 0xf, 0x1c, 0xaf, 0x60, 0xf7, 0x94, 0x52, 0xca, 0x4f, 0x12, 0x61, 0x6d, 0x6a, 0xd8, 0xae, 0x73, 0xbb, 0x57, 0x11, 0x2f, 0x6f, 0x77, 0x90, 0x1f, 0xf4, 0x44, 0x15, 0x2b, 0xc2, 0x87, 0xa9, 0xf, 0xd2, 0xc7, 0x71, 0x87, 0xd5, 0xd, 0xb1, 0xf6, 0x48, 0x1, 0xb8, 0x23, 0x5f, 0xa4, 0x10, 0x56, 0x3c, 0x6e, 0xb4, 0xe5, 0xf3, 0xd3, 0xd2, 0x85, 0xc1, 0xbb, 0x22, 0x3, 0xc6, 0x18, 0xd1, 0xf4, 0xdf, 0x27, 0x4f, 0x6c, 0x47, 0xa0, 0xcc, 0x6a, 0x89, 0x22, 0x17, 0xc6, 0x8, 0xcb, 0x3e, 0x9d, 0xa3, 0xe1, 0x5a, 0x5e, 0x5, 0x9b, 0x6c, 0x26, 0xcd, 0x53, 0x57, 0xf9, 0xae, 0x1c, 0xa6, 0x71, 0xe, 0x2d, 0xdc, 0x79, 0xb5, 0x47, 0x5b, 0x42, 0xe8, 0xdf, 0x2d, 0x9d, 0x68, 0x7, 0x69, 0x21, 0x35, 0xb9, 0x22, 0x61, 0x1d, 0xd4, 0x1a, 0x75, 0xb, 0x44, 0xbe, 0xe, 0x4f, 0xee, 0xdd, 0x63, 0x26, 0x59, 0xbf, 0xd, 0xad, 0x6e, 0xeb, 0xe9, 0xfa, 0x92, 0x36, 0xe8, 0x4a, 0xaa, 0xf2, 0x78, 0xf6, 0x9d, 0xa6, 0x54, 0x28, 0x28, 0x3b, 0x66, 0xe4, 0x33, 0x38, 0x7b, 0x3a, 0x4f, 0xad, 0x80, 0x32, 0x17, 0x5e, 0x7e, 0x9c, 0x56, 0x5c, 0x95, 0xdc, 0x94, 0xa5, 0x3e, 0x8c, 0x52, 0xb3, 0xbd, 0x25, 0xa6, 0x6a, 0xe5, 0xc6, 0x97, 0x5f, 0x32, 0xc4, 0x52, 0x76, 0xd6, 0xdc, 0x4c, 0xbd, 0xe1, 0x55, 0xb2, 0xb7, 0xbd, 0xb7, 0xe2, 0x38, 0xd9, 0x3f, 0x1, 0xb1, 0x8b, 0xff, 0xbc, 0x30, 0x1e, 0xa, 0x8a, 0x70, 0x36, 0xa7, 0xc, 0x4a, 0x65, 0x6c, 0x66, 0xb9, 0xa1, 0xa8, 0x5b, 0x51, 0xf6, 0x90, 0xf2, 0x71, 0xb7, 0xee, 0x68, 0xba, 0x63, 0x67, 0xb4, 0xc5, 0x12, 0x20, 0x9f, 0xc2, 0x4c, 0xd2, 0x86, 0xf0, 0xce, 0xd9, 0xf6, 0x25, 0x72, 0xe2, 0x2c, 0x5c, 0x6e, 0xa4, 0x8b, 0xb9, 0x21, 0x37, 0xf7, 0xb8, 0x19, 0xcf, 0x54, 0xf6, 0x2e, 0x4c, 0xd1, 0xf8, 0x51, 0xf1, 0x1d, 0x8, 0xcb, 0xd0, 0x9a, 0xc2, 0x4a, 0x6b, 0xd3, 0xfd, 0xdf, 0x65, 0xab, 0xf0, 0x5c, 0xb8, 0xde, 0xaf, 0x2b, 0x94, 0xc7, 0xa3, 0xc8, 0xcb, 0x99, 0x13, 0xbd, 0x6f, 0xa9, 0xb6, 0x8e, 0x22, 0xaa, 0xef, 0x51, 0x72, 0x90, 0x11, 0xda, 0x21, 0x21, 0x55, 0x71, 0xb3, 0x99, 0x20, 0xfd, 0xd4, 0x70, 0xcd, 0x2b, 0x4a, 0xb, 0xd0, 0x8c, 0x40, 0x55, 0x78, 0x37, 0x7c, 0x88, 0x94, 0x18, 0xa8, 0x7d, 0xbf, 0x14, 0xa8, 0xe4, 0xfd, 0xe2, 0x3, 0xa2, 0xac, 0x85, 0x5f, 0x18, 0xdb, 0xf, 0x9d, 0x91, 0xc, 0xa4, 0x1a, 0xed, 0x5a, 0xc5, 0xec, 0x7d, 0x8, 0xae, 0x7f, 0x6a, 0xbc, 0xda, 0x6, 0x46, 0x99, 0x7b, 0x63, 0x34, 0x3b, 0x35, 0x0, 0x8e, 0xad, 0x44, 0xcf, 0x3a, 0x8e, 0xdf, 0xe, 0xb1, 0x4, 0xba, 0xc1, 0xec, 0x3b, 0xa1, 0xdc, 0xa8, 0x8, 0x53, 0x3, 0x32, 0xd9, 0xc2, 0x49, 0xc6, 0x27, 0x1d, 0x25, 0xce, 0x33, 0xb5, 0x36, 0xcb, 0xa3, 0xd2, 0xf8, 0xd6, 0xc8, 0xb6, 0xa0, 0xdf, 0xc8, 0x30, 0xcc, 0x42, 0x6f, 0xe1, 0x3d, 0x69, 0xac, 0xbc, 0x24, 0xba, 0xce, 0x7c, 0xbe, 0x27, 0x31, 0x8a, 0xcb, 0xa7, 0xfb, 0x54, 0xbd, 0xa4, 0x10, 0x4d, 0x7, 0x56, 0x1b, 0x5b, 0xf0, 0xd8, 0xf0, 0x67, 0xf, 0xe6, 0xe, 0x63, 0x89, 0xb2, 0xd6, 0xe9, 0x69, 0x24, 0xec, 0x4e, 0x4b, 0xd8, 0x27, 0x47, 0x36, 0x68, 0xd4, 0xf2, 0x84, 0x12, 0x12, 0x3c, 0x31, 0xcf, 0x49, 0x91, 0x2e, 0x73, 0xab, 0x8f, 0x40, 0xcd, 0xbe, 0x30, 0x32, 0xbe, 0x12, 0x7f, 0x36, 0xaf, 0x2d, 0xd7, 0x5a, 0xb2, 0xd3, 0xde, 0x8d, 0x2e, 0x1, 0x74, 0x70, 0xa7, 0xaa, 0x3c, 0xbb, 0xca, 0xe3, 0x18, 0xb2, 0xd},
+               output224: []byte{0x5f, 0x70, 0xa3, 0x54, 0x53, 0xb9, 0xbb, 0xb5, 0xa, 0x14, 0xf2, 0x34, 0x98, 0x6, 0xce, 0xdd, 0x49, 0xf0, 0x6e, 0x3e, 0xeb, 0x98, 0x44, 0xc4, 0x2c, 0x79, 0x63, 0xa3},
+               output256: []byte{0xa2, 0x63, 0x70, 0xed, 0xef, 0xba, 0x1a, 0xa5, 0x16, 0xfa, 0x4e, 0x49, 0x2, 0x29, 0x4f, 0x9f, 0xf7, 0xb4, 0x91, 0xd0, 0xea, 0xac, 0xee, 0xc7, 0x48, 0x6e, 0xb2, 0x62, 0xe8, 0xb1, 0x24, 0x9a},
+               output384: []byte{0x8c, 0x3d, 0xe4, 0xc9, 0x79, 0x46, 0xdd, 0x88, 0x4e, 0x47, 0xae, 0x66, 0x18, 0xf9, 0xb0, 0xb6, 0xbc, 0xb7, 0x14, 0xf, 0xc3, 0x6c, 0x8b, 0x39, 0x2c, 0xdd, 0x75, 0x89, 0xcd, 0x61, 0x1e, 0x62, 0x52, 0x22, 0xfe, 0x85, 0xab, 0x38, 0x59, 0x60, 0xa7, 0xe0, 0x35, 0xfe, 0x70, 0x5a, 0xa, 0x49},
+               output512: []byte{0x6c, 0x1b, 0x14, 0xa6, 0xa3, 0x1, 0x26, 0xd1, 0xac, 0x4c, 0x84, 0xc2, 0xe, 0x2f, 0x1d, 0x14, 0xca, 0x93, 0x8b, 0x19, 0xa0, 0xfe, 0x8c, 0xca, 0x81, 0x16, 0xca, 0xf4, 0x89, 0xb0, 0xfe, 0x43, 0x59, 0xe5, 0x92, 0xcf, 0xe7, 0x62, 0x55, 0xa7, 0xf8, 0xd0, 0x85, 0xee, 0xb6, 0x55, 0xfc, 0xeb, 0x12, 0x7c, 0x12, 0xbb, 0xba, 0x74, 0xb1, 0x9, 0x2f, 0x37, 0xba, 0x1c, 0x9b, 0xb1, 0x3b, 0xd2}},
+       testcase{
+               msg:       []byte{0x82, 0x4a, 0x15, 0x5d, 0x77, 0x98, 0xe1, 0x29, 0x62, 0xf4, 0x46, 0x4e, 0xad, 0x9a, 0xf1, 0x32, 0xa2, 0x26, 0xda, 0x4d, 0xa6, 0xe8, 0x99, 0x62, 0x9e, 0xfb, 0x93, 0x8e, 0xa2, 0x9a, 0x86, 0x93, 0x7f, 0xb1, 0x44, 0x86, 0x6d, 0x8c, 0x7b, 0x2d, 0xf9, 0x98, 0x86, 0x4, 0xce, 0xd9, 0x68, 0x92, 0xda, 0x48, 0x2d, 0x4d, 0xd, 0xeb, 0x46, 0x58, 0x84, 0x4f, 0x41, 0x83, 0x5f, 0xd, 0x9c, 0x20, 0xc7, 0x96, 0x92, 0x9c, 0x83, 0xcf, 0xb4, 0x91, 0x13, 0xf5, 0xd9, 0x5a, 0x7b, 0x66, 0xd9, 0x11, 0x6a, 0x46, 0x97, 0xbf, 0xe3, 0x35, 0xbc, 0x83, 0x62, 0x96, 0x78, 0xcd, 0x5d, 0xee, 0xdb, 0x7c, 0x9f, 0x8f, 0x11, 0xdd, 0xa0, 0x79, 0xbd, 0xce, 0x8c, 0x27, 0x19, 0xb6, 0xcd, 0x40, 0xc, 0x2, 0xa6, 0xa5, 0x65, 0x4f, 0x19, 0xb6, 0xd5, 0x68, 0x47, 0x3d, 0x37, 0x17, 0x4f, 0x62, 0xab, 0x66, 0x84, 0xc9, 0xc9, 0x19, 0xc1, 0xcf, 0xaf, 0x35, 0x11, 0x6f, 0xf7, 0xae, 0x4f, 0x5b, 0xf, 0xb, 0xd2, 0x43, 0xc7, 0x43, 0x84, 0xc2, 0xc9, 0x39, 0x2f, 0x11, 0x89, 0xb2, 0xad, 0x44, 0x8b, 0x9d, 0x79, 0x46, 0xc2, 0xcc, 0xad, 0x4, 0xd2, 0xf2, 0xc, 0xb8, 0xcf, 0x1f, 0x95, 0x90, 0xd1, 0x50, 0x4b, 0x1e, 0x1b, 0x1d, 0x74, 0xa0, 0x44, 0x24, 0xbd, 0x27, 0xd0, 0x11, 0x76, 0x76, 0xb8, 0xc8, 0x23, 0x2, 0x28, 0x58, 0xa4, 0xc1, 0x2a, 0xad, 0xf2, 0x1f, 0xa4, 0x5c, 0x99, 0xfa, 0xd6, 0x1, 0x20, 0xb2, 0x4f, 0xe0, 0x4b, 0xa3, 0x3, 0x6b, 0x80, 0xac, 0x5f, 0x46, 0xe9, 0x83, 0x3, 0x2b, 0x6d, 0x78, 0x83, 0xf, 0x51, 0xe6, 0x5a, 0x62, 0x31, 0xb, 0x90, 0x58, 0xa4, 0xdd, 0x3f, 0x3f, 0x8f, 0x90, 0xed, 0x53, 0x11, 0xe1, 0xf4, 0x79, 0x87, 0xe0, 0xd4, 0x10, 0xf7, 0x8b, 0x2a, 0x76, 0x58, 0xf, 0xbf, 0xdd, 0xa0, 0xf9, 0x44, 0xbb, 0xe4, 0x66, 0xc8, 0xa8, 0x17, 0xb, 0x5c, 0x77, 0xe8, 0x13, 0x2c, 0xcd, 0x7d, 0x5e, 0x99, 0x46, 0xa5, 0xfe, 0xdc, 0x73, 0xab, 0x94, 0x65, 0xe3, 0xb, 0xee, 0xe9, 0xcf, 0xad, 0x68, 0xb7, 0xa, 0x21, 0x76, 0x39, 0x3a, 0xd8, 0xa1, 0x73, 0xcd, 0x9a, 0xfe, 0x8f, 0x9b, 0x33, 0x2, 0x3e, 0x85, 0x28, 0x76, 0x82, 0x4b, 0x72, 0x3, 0x65, 0xe6, 0x88, 0xb3, 0xfb, 0x4b, 0xa9, 0x25, 0x4, 0x3, 0x85, 0x55, 0x9f, 0xef, 0x7b, 0xdc, 0xfa, 0x7d, 0xd1, 0x8b, 0xbc, 0x31, 0xb2, 0x49, 0x36, 0x55, 0x7e, 0xdd, 0x67, 0x9b, 0x50, 0x28, 0x64, 0x58, 0x8c, 0xd4, 0xbc, 0x27, 0x0, 0x99, 0xa3, 0xd, 0xc3, 0xb3, 0xef, 0x7a, 0x39, 0x2f, 0x3e, 0x33, 0xe2, 0x1a, 0x53, 0xfb, 0x83, 0x75, 0x6e, 0xe3, 0x71, 0xa1, 0x98, 0x69, 0x30, 0xc4, 0xa3, 0x4a, 0xe1, 0x30, 0x1e, 0xc4, 0x4e, 0x18, 0x9e, 0x23, 0xad, 0xb7, 0xea, 0xaa, 0x12, 0x1c, 0x6d, 0x78, 0x70, 0x7, 0xa4, 0x4e, 0x99, 0x8d, 0x11, 0x24, 0x84, 0x1, 0x9f, 0x7d, 0x7d, 0x8e, 0x16, 0x98, 0x5b, 0x3, 0x9c, 0x8c, 0xe0, 0x1e, 0xc8, 0xcc, 0xef, 0xb6, 0x47, 0xf0, 0x7f, 0x9f, 0xac, 0x11, 0x4b, 0xab, 0xc3, 0xd8, 0x31, 0xaf, 0xd6, 0xf0, 0x85, 0x97, 0x22, 0x2a, 0x4d, 0xa8, 0xc4, 0xf6, 0xcb, 0x22, 0xc6, 0x73, 0xc0, 0x43, 0x7c, 0x16, 0xfc, 0xce, 0x7e, 0xeb, 0x64, 0xe7, 0x5, 0xa, 0xf9, 0xbf, 0x41, 0xe9, 0x5d, 0x3a, 0x1, 0x12, 0xfc, 0x4, 0x9d, 0x40, 0x5d, 0xf0, 0xe3, 0x22, 0x42, 0x20, 0x72, 0xa1, 0x6d, 0xf2, 0x48, 0xe1, 0xa, 0xa2, 0x2e, 0xe5, 0xf1, 0x98, 0xc6, 0x7c, 0x59, 0xeb, 0x81, 0x98, 0x42, 0x1d, 0xa8, 0x55, 0xdb, 0xf2, 0xc7, 0x8b, 0x36, 0x35, 0x2b, 0x13, 0x73, 0xf7, 0xf6, 0x6b, 0x5a, 0x5b, 0xdc, 0xff, 0xd4, 0x4c, 0x76, 0xb7, 0xcd, 0xf5, 0x6d, 0x89, 0x41, 0x87, 0xde, 0x7b, 0xfb, 0x5, 0xc0, 0x53, 0x5c, 0x3d, 0x2a, 0xa4, 0x91, 0xf3, 0x7d, 0x35, 0xc3, 0x17, 0x7e, 0xf, 0x31, 0x2a, 0x9f, 0xc7, 0xf1, 0xc6, 0x66, 0x8a, 0xe0, 0xb6, 0xb4, 0xb6, 0xc1, 0x95, 0xeb, 0x4a, 0xea, 0x21, 0x9f, 0x14, 0x7a, 0x97, 0x99, 0xa9, 0xc8, 0x44, 0x49, 0xd7, 0x47, 0x7f, 0xce, 0xea, 0xa0, 0xab, 0xb8, 0x36, 0x15, 0x4, 0x87, 0xab, 0xee, 0x7a, 0x19, 0x2, 0x54, 0xb, 0x90, 0x5e, 0x99, 0x8a, 0x53, 0x2a, 0xdd, 0x68, 0xb2, 0xd1, 0x5a, 0x1f, 0xbb, 0x63, 0xdd, 0xec, 0xc5, 0x4c, 0x8c, 0x20, 0x6e, 0xe6, 0x55, 0x35, 0x3c, 0x7d, 0x1d, 0xb4, 0x11, 0xbd, 0x33, 0x41, 0x9f, 0x6f, 0x90, 0x5b, 0xea, 0x56, 0x7f, 0x8d, 0x67, 0xb5, 0x46, 0x1f, 0x15, 0xac, 0xfb, 0x8f, 0x85, 0x5, 0xcc, 0xdc, 0x29, 0xcd, 0x70, 0x8b, 0xe6, 0x79, 0x23, 0x8c, 0xe3, 0xe, 0xa3, 0xd1, 0xaa, 0x18, 0x3b, 0xef, 0xc3, 0x59, 0x38, 0xd7, 0x55, 0xc5, 0x9, 0x63, 0xff, 0x9c, 0x89, 0xce, 0xb2, 0x87, 0x64, 0xa7, 0xba, 0x8e, 0x72, 0xa2, 0xd2, 0x2d, 0x16, 0x81, 0x72, 0xdc, 0x5d, 0x91, 0xf4, 0xad, 0x59, 0x80, 0xb1, 0x24, 0x74, 0xa9, 0x6d, 0xb7, 0x5e, 0x1f, 0x7a, 0x9e, 0xf9, 0xcf, 0x1a, 0x3, 0x18, 0xd1, 0x8b, 0x1, 0xb1, 0x8, 0xcd, 0x16, 0x5a, 0x37, 0x34, 0xd6, 0x71, 0xd4, 0x36, 0x70, 0x8b, 0xa0, 0x30, 0xc1, 0xe8, 0x60, 0xee, 0xe8, 0x60, 0xb4, 0xe, 0x61, 0xee, 0x5b, 0x72, 0xa4, 0xa9, 0x8a, 0xea, 0x24, 0xac, 0x34, 0x3b, 0xb6, 0xd4, 0x9, 0x5f, 0x79, 0xfd, 0x9f, 0x1c, 0x8d, 0x64, 0x5, 0x7b, 0x66, 0x72, 0x82, 0x1b, 0x96, 0xf9, 0x54, 0xdf, 0x23, 0xcf, 0x29, 0x4f, 0x51, 0x6b, 0xdc, 0x10, 0x45, 0x17, 0xe, 0x16, 0x2b, 0xf5, 0x8e, 0x75, 0xdb, 0x11, 0x28, 0x8b, 0x46, 0x6a, 0x4b, 0x83, 0x12, 0x5f, 0x1b, 0x54, 0x28, 0x6f, 0x14, 0xba, 0xb, 0x55, 0x26, 0x73, 0x97, 0xd9, 0x60, 0x5a, 0x57, 0xf1, 0x6e, 0xc3, 0x57, 0x85, 0x3d, 0xf6, 0xf3, 0xc8, 0x94, 0x3a, 0x73, 0xf7, 0xd2, 0x6, 0x59, 0xee, 0x1, 0xb3, 0xcf, 0x70, 0xba, 0xfe, 0x43, 0x20, 0x89, 0xbf, 0xd9, 0xdc, 0xe1, 0xe3, 0x1d, 0x44, 0x1c, 0x17, 0x4f, 0x42, 0xd3, 0xbc, 0x4, 0x8, 0x47, 0x5, 0xd0, 0xda, 0x30, 0x8c, 0x21, 0xf3, 0x8, 0x75, 0xd6, 0x8f, 0x86, 0x11, 0xb6, 0x2f, 0x49, 0xaf, 0x1b, 0x93, 0x73, 0x19, 0x34, 0x6d, 0xcd, 0xde, 0xe9, 0x63, 0x2f, 0x5c, 0x70, 0x44, 0x10, 0x7c, 0x3c, 0x5b, 0x49, 0xcd, 0x59, 0x16, 0x90, 0x8, 0xd4, 0x97, 0xc4, 0xbd, 0x9c, 0xf2, 0x12, 0x3f, 0xf7, 0x63, 0x6a, 0x5b, 0x20, 0x50, 0x1b, 0xa3, 0x68, 0xac, 0x6d, 0x18, 0xa3, 0x2b, 0xf7, 0x98, 0x41, 0x9b, 0xf9, 0x3b, 0xf7, 0xcd, 0x7b, 0x1e, 0x99, 0x84, 0x71, 0xd4, 0xc8, 0x5a, 0x2b, 0xc5, 0xe, 0x31, 0x6e, 0x89, 0xd1, 0x7a, 0xcf, 0x32, 0x74, 0x69, 0xf1, 0xf4, 0x5a, 0x68, 0xfd, 0xe5, 0x47, 0x14, 0xcf, 0xfa, 0x97, 0x6d, 0x48, 0x89, 0x89, 0xf6, 0x5f, 0xb4, 0xe8, 0xf9, 0xf8, 0x5d, 0x43, 0x1, 0xf, 0x98, 0x24, 0x53, 0x22, 0x3b, 0xd0, 0x60, 0xba, 0xbe, 0xfd, 0xeb, 0x9d, 0xc1, 0xd, 0xbd, 0x28, 0xcf, 0xf8, 0x42, 0x36, 0x6d, 0xd5, 0x51, 0x70, 0xc3, 0x3e, 0xaa, 0xaf, 0xe9, 0x4, 0x28, 0xd9, 0xe6, 0x32, 0x78, 0x56, 0x21, 0xc5, 0xf8, 0x36, 0xd1, 0x18, 0xc4, 0xbb, 0x97, 0xbd, 0x2d, 0xfc, 0x2a, 0x73, 0x4c, 0x64, 0xf6, 0x14, 0xa9, 0xfd, 0x31, 0x79, 0x51, 0x27, 0x20, 0xc9, 0x51, 0x1a, 0x1d, 0xf2, 0x9e, 0xa9, 0x79, 0x22, 0x26, 0xfa, 0x5d, 0x3b, 0x74, 0xd0, 0xd2, 0x9d, 0x47, 0x41, 0xed, 0xd5, 0x82, 0x19, 0x4, 0xf5, 0x2a, 0xa7, 0x96, 0x1d, 0x30, 0x3b, 0x51, 0xe5, 0x4a, 0x6c, 0xcb, 0x80, 0xbb, 0x85, 0x1a, 0xe5, 0x7d, 0xb1, 0xf9, 0x7b, 0x65, 0x67, 0x72, 0x89, 0x71, 0x90, 0x71, 0x4a, 0x5d, 0xf7, 0x45, 0xd, 0x7e, 0xef, 0xb9, 0x82, 0x18, 0x81, 0x31, 0xd8, 0x1c, 0x6d, 0x27, 0x30, 0x21, 0xa2, 0xaa, 0xac, 0x77, 0x7b, 0x0, 0x83, 0xf0, 0xcc, 0x36, 0x3e, 0x61, 0x9a, 0x1f, 0xae, 0xd4, 0xcc, 0x2c, 0xc7, 0xf2, 0x8e, 0x24, 0xf6, 0x82, 0xc9, 0xf9, 0xee, 0xd9, 0x9e, 0x9, 0xe1, 0x9a, 0x82, 0x0, 0xe6, 0x8a, 0xb9, 0xdc, 0xae, 0x56, 0xaa, 0x92, 0xc9, 0x98, 0x23, 0x1, 0x5f, 0x82, 0xc8, 0xf9, 0xa, 0x40, 0xdf, 0xf, 0x72, 0x98, 0x88, 0xc8, 0x32, 0xa, 0x7f, 0xb, 0x1e, 0x2f, 0x61, 0x55, 0xc8, 0x2a, 0xad, 0x1b, 0x4a, 0xca, 0x8, 0x70, 0xde, 0xb6, 0x9f, 0x4, 0xcd, 0x13, 0x7b, 0x55, 0x6b, 0x99, 0x19, 0xbd, 0x92, 0xd, 0xb2, 0xa, 0x1c, 0x1d, 0xcf, 0xc4, 0x52, 0x36, 0xe6, 0xe9, 0xf, 0xa3, 0x5, 0x4a, 0x8e, 0x29, 0x21, 0x1b, 0xf7, 0x6b, 0x13, 0x80, 0xf, 0x3a, 0xc4, 0x65, 0x74, 0x49, 0xc8, 0x9f, 0xb7, 0x6d, 0x32, 0x89, 0x20, 0x24, 0xe6, 0xfe, 0x76, 0x64, 0xbd, 0x23, 0x3, 0x84, 0x57, 0xfa, 0x0, 0xb1, 0xeb, 0x88, 0x33, 0x4f, 0x4c, 0x8a, 0xd0, 0x56, 0x91, 0xc8, 0xe3, 0x10, 0xf, 0x28, 0x89, 0xc0, 0xe9, 0x6a, 0x32, 0x7c, 0x9b, 0x36, 0xdb, 0xe6, 0xd9, 0xcb, 0xfb, 0xf9, 0xde, 0x93, 0xad, 0xc8, 0xc1, 0x78, 0x64, 0xce, 0xe6, 0xd3, 0xe, 0xbf, 0xb, 0xdf, 0x8f, 0x6b, 0x9d, 0x65, 0xd2, 0xd6, 0x47, 0x1d, 0x26, 0x33, 0x40, 0x89, 0xb4, 0xc, 0x9b, 0xe, 0xdc, 0xc3, 0xd0, 0xda, 0x47, 0x10, 0xe7, 0x6b, 0x28, 0xb3, 0x92, 0xf7, 0xc3, 0xba, 0xd6, 0xf3, 0x4c, 0x77, 0x6a, 0x72, 0xab, 0x21, 0x1b, 0x72, 0xc, 0xcb, 0xe6, 0xe, 0x84, 0x4c, 0xec, 0x48, 0x32, 0xec, 0xb8, 0x1, 0x4b, 0xb2, 0x36, 0xe0, 0xaf, 0x9a, 0x39, 0x91, 0x2c, 0xe1, 0x2a, 0x53, 0x86, 0xd4, 0x9, 0xf5, 0x11, 0x7c, 0x1, 0x47, 0x8d, 0x75, 0x29, 0x6e, 0xda, 0xb3, 0x3e, 0x1c, 0x52, 0x73, 0x71, 0x87, 0x9, 0x48, 0x7a, 0xd0, 0xab, 0x5b, 0x18, 0xa, 0x2d, 0x6, 0x5c, 0x31, 0xdb, 0xc1, 0xe0, 0x73, 0x7d, 0x9a, 0x80, 0x2, 0x60, 0xc7, 0x1a, 0x2, 0x44, 0xf1, 0x95, 0x28, 0xe7, 0x90, 0x72, 0xd8, 0xb8, 0x32, 0x22, 0x25, 0xc6, 0xc6, 0xae, 0x84, 0x71, 0x6, 0x8b, 0xfe, 0xb6, 0x1c, 0x57, 0x8b, 0xeb, 0x30, 0xf9, 0xab, 0x6a, 0x17, 0x3d, 0x70, 0x37, 0x3d, 0x5f, 0x28, 0xe7, 0xc3, 0x53, 0xfe, 0x72, 0x33, 0x16, 0x14, 0x3b, 0x2a, 0x6e, 0xdf, 0x78, 0xea, 0xbd, 0x60, 0x12, 0x41, 0x38, 0xb6, 0x7, 0xd9, 0xa0, 0x9d, 0x6a, 0xce, 0x70, 0x88, 0x2d, 0x43, 0x3, 0xee, 0xf2, 0xc2},
+               output224: []byte{0xa3, 0xd5, 0x12, 0x8d, 0x5b, 0xc7, 0x85, 0x2e, 0xc6, 0xb5, 0x9d, 0x3d, 0x33, 0xab, 0xe7, 0xf, 0x73, 0x52, 0x39, 0xd1, 0x49, 0x59, 0x3e, 0x9d, 0x17, 0x98, 0xd1, 0xa9},
+               output256: []byte{0x9f, 0x4e, 0xa3, 0x42, 0x76, 0x42, 0xd8, 0xa8, 0xb3, 0x92, 0xa5, 0x7e, 0x3f, 0x0, 0xa5, 0xca, 0xbc, 0xcf, 0x56, 0x8e, 0xb, 0x81, 0x21, 0x88, 0x14, 0xb1, 0x8e, 0xa4, 0x7c, 0x85, 0x27, 0x26},
+               output384: []byte{0x9d, 0x5a, 0x13, 0x7, 0x73, 0xc6, 0x96, 0xac, 0xd0, 0xf3, 0xa, 0xd5, 0x3a, 0x93, 0xa7, 0x1f, 0x18, 0x93, 0x2a, 0x25, 0xec, 0x31, 0x3b, 0x29, 0xed, 0x9b, 0x70, 0x1d, 0xec, 0xd4, 0xdb, 0xb7, 0x89, 0xd3, 0xa, 0x33, 0xe6, 0x24, 0x64, 0x86, 0x9, 0x5d, 0xe3, 0xb0, 0xfa, 0x3, 0x3d, 0x2f},
+               output512: []byte{0x62, 0xd9, 0xff, 0x2d, 0x86, 0x2f, 0xd2, 0xc6, 0xdc, 0x57, 0xdc, 0x25, 0xcc, 0x51, 0xef, 0xe5, 0x24, 0x47, 0x2, 0x7b, 0x9a, 0x34, 0xf4, 0x8, 0x48, 0xc2, 0x13, 0x33, 0x70, 0xc1, 0xe0, 0xfd, 0xb5, 0xa8, 0xa0, 0x8f, 0xd1, 0x95, 0x41, 0xb5, 0xa6, 0x7b, 0x51, 0x42, 0x65, 0x67, 0x6b, 0xe1, 0x4c, 0xf7, 0x1d, 0x19, 0xf6, 0x6f, 0x1d, 0x8a, 0xbe, 0x30, 0x75, 0x68, 0xfe, 0xca, 0x39, 0x65}},
+       testcase{
+               msg:       []byte{0xfd, 0x76, 0xa3, 0xe9, 0xe0, 0xe3, 0x3, 0xcf, 0xc3, 0xc2, 0xa8, 0x4c, 0x43, 0xd1, 0x9b, 0x60, 0x69, 0x16, 0x7f, 0x7c, 0x70, 0x94, 0xbb, 0x37, 0x9e, 0xc9, 0x29, 0xaa, 0xa4, 0xf1, 0x9e, 0x2e, 0x1a, 0x77, 0xe3, 0x12, 0xc0, 0xcb, 0x8, 0xc5, 0x44, 0xc9, 0x5e, 0xbb, 0xab, 0xb5, 0x98, 0x8f, 0x45, 0x1b, 0x1, 0xcf, 0x92, 0x14, 0xb3, 0x7c, 0x34, 0x1a, 0x52, 0x7c, 0xa5, 0x84, 0x84, 0x1, 0x11, 0x23, 0x67, 0x57, 0x10, 0x8f, 0xf1, 0x38, 0xe3, 0x64, 0xd9, 0x3b, 0xb7, 0x66, 0x29, 0xc0, 0x95, 0x11, 0x7f, 0xce, 0x45, 0x8e, 0xc0, 0x3b, 0x87, 0xbf, 0x19, 0xf8, 0xc9, 0x93, 0x6b, 0x3e, 0x1c, 0x4c, 0x79, 0xf9, 0x37, 0x58, 0x15, 0xa6, 0x58, 0x63, 0x8e, 0x93, 0xc5, 0x10, 0x2c, 0x66, 0x56, 0x3f, 0x3a, 0x37, 0x2e, 0x63, 0x48, 0xc6, 0xc1, 0xb9, 0xdf, 0xa6, 0xa4, 0xe4, 0x27, 0xf4, 0x18, 0xcc, 0x65, 0xef, 0x67, 0xee, 0x52, 0x41, 0xa8, 0x5f, 0x78, 0x96, 0xb1, 0xa0, 0xe9, 0x41, 0x45, 0x39, 0x16, 0x0, 0x7c, 0x67, 0xb4, 0x71, 0x94, 0x35, 0x26, 0x36, 0xdf, 0x36, 0xe2, 0x23, 0xf, 0x45, 0x2, 0xb2, 0x56, 0x9a, 0xa8, 0xaf, 0xc7, 0x9c, 0x71, 0xb8, 0xb6, 0x75, 0x80, 0x53, 0x75, 0xe1, 0xff, 0xd2, 0x76, 0x4a, 0xa8, 0xb8, 0xd5, 0x8e, 0xa9, 0xc9, 0xb5, 0x80, 0xd4, 0x89, 0xb0, 0x9e, 0xfe, 0xb1, 0xd7, 0x7, 0x71, 0x9f, 0x3a, 0xa9, 0x9c, 0x44, 0x7c, 0x11, 0x2c, 0xc7, 0x7b, 0x3f, 0x83, 0x39, 0x89, 0xbd, 0x2d, 0xf9, 0x8f, 0x32, 0xf0, 0x68, 0xb9, 0xc0, 0xf7, 0xee, 0xf2, 0x40, 0x71, 0x98, 0x17, 0xb1, 0x1e, 0xd5, 0x83, 0xc8, 0x2c, 0xf3, 0xbb, 0xda, 0x26, 0x8d, 0x60, 0xb0, 0x3f, 0xee, 0x5, 0x79, 0x7e, 0x3e, 0xbf, 0x65, 0xc1, 0x53, 0xac, 0x84, 0xe8, 0x99, 0xe3, 0xda, 0x34, 0x32, 0x88, 0xf, 0x18, 0xb0, 0x91, 0x94, 0xa1, 0xd1, 0x70, 0xdc, 0x23, 0xa1, 0xd1, 0x7f, 0x53, 0xde, 0x6f, 0x31, 0x9, 0xca, 0x8a, 0x88, 0xe1, 0x39, 0xf, 0xd, 0x49, 0x90, 0x2a, 0x48, 0x52, 0xb, 0x92, 0x83, 0xc0, 0x67, 0x46, 0xa5, 0x5b, 0x4, 0x1f, 0x4a, 0x7d, 0xdc, 0x7, 0x27, 0xa0, 0x8d, 0xd5, 0x71, 0x7f, 0xba, 0x55, 0x84, 0x67, 0xc, 0xd0, 0xaf, 0xc7, 0xa9, 0x59, 0x77, 0x49, 0xc7, 0x18, 0xb8, 0xfd, 0x11, 0x22, 0x2e, 0xc4, 0x15, 0x6, 0x50, 0x5e, 0xd3, 0xdb, 0x5b, 0x82, 0x88, 0xfd, 0x23, 0x4e, 0xa, 0x92, 0x37, 0xd6, 0x71, 0x5f, 0x89, 0x96, 0x98, 0xd, 0x98, 0x55, 0x87, 0xa8, 0x64, 0x53, 0x57, 0xb0, 0xf5, 0x3c, 0x48, 0xf, 0x72, 0xc8, 0x6, 0x5f, 0x51, 0x88, 0xa0, 0xe1, 0x32, 0xad, 0x31, 0x5f, 0x3e, 0x7c, 0x12, 0xa8, 0x54, 0xe9, 0x3d, 0x1c, 0xc2, 0xfe, 0x92, 0x52, 0xfb, 0xe6, 0x8b, 0x3b, 0xef, 0xbb, 0xea, 0xce, 0x38, 0x53, 0x1e, 0x5b, 0xf5, 0xf2, 0xc6, 0x71, 0xfe, 0xc8, 0xea, 0x58, 0xf5, 0xe3, 0x1a, 0x4b, 0xb0, 0x5b, 0x8a, 0x6e, 0xa8, 0x7e, 0xa7, 0xbc, 0xca, 0xb5, 0xc, 0xa6, 0x5f, 0xb2, 0xa2, 0xf3, 0x12, 0xf1, 0x83, 0xb5, 0xb1, 0x50, 0x4e, 0xd0, 0x47, 0x39, 0xba, 0x85, 0x4a, 0xb4, 0x36, 0xb8, 0xfc, 0x2e, 0x50, 0xc3, 0x43, 0x4f, 0xdf, 0xd5, 0x6, 0x82, 0xfd, 0x79, 0xb1, 0x9c, 0xbb, 0xce, 0x2c, 0x76, 0xec, 0x1f, 0xfe, 0xa, 0xc9, 0xe5, 0x4c, 0x2f, 0x9b, 0xf5, 0x14, 0x97, 0xab, 0x95, 0x13, 0x5b, 0x87, 0x73, 0x28, 0x86, 0x8d, 0x6a, 0xc2, 0xb7, 0xf7, 0x64, 0xfe, 0xc8, 0x66, 0xcb, 0xb6, 0xa5, 0x3f, 0x34, 0x61, 0x22, 0x12, 0x40, 0xf1, 0xbd, 0x6d, 0x99, 0xc3, 0x8d, 0xf6, 0x12, 0x1e, 0x37, 0x51, 0xce, 0xcb, 0x1e, 0xa, 0xe1, 0xa0, 0x2f, 0xe0, 0x54, 0x5, 0x9b, 0x78, 0xdd, 0x96, 0xfa, 0xc, 0xb3, 0xd1, 0x95, 0x2a, 0x80, 0xb8, 0xab, 0x55, 0xe, 0xaa, 0x82, 0xd7, 0x52, 0x4c, 0x2, 0x77, 0x84, 0x16, 0xe0, 0x35, 0x56, 0x1d, 0x31, 0xae, 0x99, 0xf2, 0xea, 0x52, 0xcc, 0xd1, 0xe, 0xa0, 0x9e, 0xcd, 0x6e, 0xf2, 0x44, 0x57, 0x6d, 0x18, 0xe3, 0xc1, 0x21, 0x10, 0xe6, 0xd2, 0x24, 0xc3, 0xd2, 0x96, 0xa8, 0xbe, 0x95, 0xf4, 0x7f, 0x5a, 0x31, 0x50, 0xb3, 0x2f, 0x67, 0xb2, 0xc1, 0x8f, 0x5b, 0xac, 0xe7, 0x6d, 0xbc, 0xf9, 0xf4, 0xa7, 0xf5, 0x8a, 0x81, 0x87, 0x57, 0xed, 0x6, 0xeb, 0x3e, 0x5c, 0x98, 0x7b, 0x58, 0xab, 0x40, 0x1, 0x6b, 0xe4, 0x66, 0x6c, 0xba, 0x84, 0x3b, 0xa4, 0xa0, 0x9c, 0x57, 0x9b, 0x22, 0x74, 0x13, 0xa, 0x8b, 0xdd, 0x7d, 0xc3, 0x75, 0x57, 0xcc, 0xa3, 0x65, 0x30, 0x2a, 0xed, 0x9c, 0xcf, 0x46, 0x5f, 0x3f, 0x97, 0xd, 0x97, 0x99, 0x64, 0x6c, 0xfb, 0x9b, 0x2b, 0x69, 0x21, 0x80, 0x45, 0xf6, 0xdd, 0xf5, 0x18, 0xd, 0x4e, 0x5d, 0x36, 0xa0, 0xf6, 0x3f, 0xea, 0x6b, 0x71, 0xe6, 0xc, 0x20, 0xf, 0x34, 0x18, 0xa8, 0xfd, 0x35, 0xc4, 0xf2, 0x68, 0x4c, 0x81, 0xe3, 0xd7, 0x15, 0x36, 0x20, 0x61, 0xde, 0x34, 0xb4, 0xab, 0x7a, 0x11, 0x82, 0x49, 0xd4, 0xe7, 0x4e, 0xf7, 0xc6, 0x89, 0x80, 0x73, 0x1, 0x41, 0x20, 0xff, 0x2d, 0x80, 0xee, 0xb2, 0x66, 0x4e, 0x47, 0xc2, 0x34, 0x9c, 0x44, 0x90, 0x53, 0x96, 0xf0, 0xb9, 0xcd, 0xe, 0xc3, 0x43, 0xd6, 0x1e, 0xc4, 0xc6, 0x65, 0x7a, 0xf7, 0x96, 0x4c, 0xcf, 0x38, 0x4e, 0x83, 0xae, 0xd, 0xf1, 0x73, 0x64, 0x35, 0xf9, 0xb, 0x76, 0x65, 0x28, 0xef, 0xc6, 0x9d, 0x9a, 0xb2, 0x4, 0xd2, 0xd8, 0xa6, 0xd7, 0x9d, 0x23, 0x88, 0x6d, 0xe9, 0x71, 0x85, 0x2c, 0xca, 0x92, 0x83, 0xef, 0x87, 0x12, 0x5c, 0x28, 0x44, 0x2e, 0xb0, 0x82, 0xbe, 0x6f, 0xe6, 0x8f, 0x45, 0xf1, 0xb3, 0xc4, 0x40, 0xc3, 0xf9, 0x3b, 0xac, 0x49, 0xca, 0x85, 0x56, 0x4, 0x13, 0x4c, 0xeb, 0x4e, 0x96, 0x86, 0x54, 0xb4, 0xc0, 0xd, 0x1e, 0x7a, 0x81, 0x95, 0x94, 0x35, 0xfa, 0x36, 0xd0, 0xdc, 0x43, 0x40, 0xa, 0x8d, 0xdb, 0xf2, 0x6e, 0xac, 0x87, 0x14, 0x22, 0x3b, 0x4d, 0x55, 0xaf, 0x42, 0xe7, 0x5d, 0x3e, 0xd3, 0x87, 0xe5, 0x2e, 0x52, 0x22, 0xb3, 0x64, 0x6b, 0xf0, 0x18, 0xc7, 0x94, 0x86, 0x78, 0x9a, 0x67, 0x2b, 0xb8, 0x26, 0x84, 0x17, 0x45, 0xf4, 0x76, 0x9a, 0x6b, 0xe8, 0xf4, 0x67, 0xab, 0x22, 0x94, 0xcd, 0xec, 0xa2, 0xd9, 0x74, 0xe8, 0xd3, 0xfe, 0xe4, 0x17, 0xab, 0x6d, 0x2, 0xcf, 0x16, 0xe9, 0xec, 0x3f, 0xb2, 0x20, 0x5, 0xa6, 0x32, 0xce, 0xbd, 0x64, 0xb5, 0x81, 0x72, 0x86, 0x80, 0x74, 0x5, 0xb9, 0xd7, 0x80, 0x50, 0xe6, 0x1b, 0x5d, 0x97, 0x59, 0x89, 0x28, 0x2d, 0x7d, 0xbd, 0xf2, 0xbb, 0x81, 0xad, 0x2e, 0x15, 0xc0, 0x7f, 0x9a, 0xf2, 0x2d, 0xe7, 0xb8, 0x9, 0x77, 0xe3, 0x44, 0x2c, 0x1f, 0x11, 0x93, 0x12, 0xa2, 0xb, 0x46, 0x12, 0x61, 0xe8, 0xb6, 0x81, 0xca, 0x61, 0x2e, 0x7c, 0x7a, 0x67, 0xa2, 0x7, 0x67, 0x81, 0x60, 0xf, 0x5, 0x7a, 0x6e, 0xb3, 0xf8, 0xa0, 0x65, 0x4f, 0xb9, 0x82, 0x77, 0x1b, 0x6c, 0x66, 0x19, 0x54, 0xb6, 0x6d, 0x96, 0x8, 0x6a, 0xfd, 0x11, 0xb, 0x2, 0x39, 0xe0, 0xbf, 0x96, 0x88, 0x0, 0x40, 0x18, 0xe4, 0x18, 0xca, 0x2e, 0x3d, 0xf9, 0x9d, 0xf0, 0x14, 0x5, 0x50, 0x8b, 0x8d, 0x69, 0xcd, 0x6a, 0x75, 0xa7, 0xfb, 0xdb, 0x52, 0xd3, 0x78, 0xc2, 0xbf, 0x79, 0x80, 0x45, 0xd0, 0x2a, 0x9d, 0xb7, 0xb1, 0xd9, 0xd2, 0x75, 0xfb, 0xce, 0xc5, 0xcd, 0xab, 0x92, 0x3c, 0x57, 0x42, 0xa, 0xa2, 0x6c, 0x31, 0xc0, 0xb6, 0x32, 0xd2, 0x3e, 0xa2, 0xdb, 0x8c, 0x19, 0x3e, 0x55, 0xa1, 0xdf, 0x6c, 0xe8, 0xfe, 0x61, 0xb, 0xd9, 0x1c, 0x4b, 0xa8, 0x1a, 0x41, 0xc8, 0xc, 0xab, 0x69, 0x74, 0x4b, 0x8c, 0x88, 0x55, 0x4f, 0x1f, 0xe8, 0xcc, 0x14, 0xa0, 0xc2, 0x94, 0x67, 0xd7, 0xab, 0x48, 0x40, 0xac, 0x9e, 0x86, 0x1f, 0x8a, 0x24, 0xc9, 0x53, 0xd6, 0x8c, 0xaa, 0x58, 0x32, 0x91, 0xf1, 0xba, 0x86, 0x3, 0xee, 0xd2, 0xc8, 0x43, 0x0, 0x14, 0x2, 0xaa, 0x21, 0x34, 0xa0, 0x67, 0xeb, 0x6e, 0xe2, 0x83, 0xc, 0x49, 0x72, 0x53, 0xa, 0x5e, 0x4e, 0x26, 0x28, 0xe6, 0x32, 0x66, 0xa5, 0x1b, 0xb3, 0x53, 0x7e, 0xe4, 0x8e, 0xbb, 0x6d, 0xe8, 0x69, 0x99, 0x79, 0x43, 0xb0, 0x85, 0x11, 0xad, 0xc9, 0x64, 0x7e, 0x82, 0x24, 0xd0, 0x8d, 0xaa, 0x3c, 0x0, 0x9f, 0x4d, 0x65, 0xf0, 0xc9, 0xa1, 0xaf, 0x4e, 0x8b, 0x22, 0x5a, 0x30, 0xda, 0xba, 0x35, 0x2f, 0xd5, 0xd1, 0xf6, 0xc3, 0x66, 0x83, 0xaa, 0x4f, 0x44, 0x60, 0x2e, 0x32, 0xbf, 0x4, 0x48, 0x4a, 0x7c, 0xe8, 0x87, 0x9, 0xaa, 0xfc, 0xe1, 0xf9, 0x3e, 0xae, 0x9, 0x5f, 0xcb, 0x89, 0xa1, 0xe3, 0x2d, 0xc9, 0x2c, 0x41, 0x50, 0x59, 0x2e, 0xcf, 0xe9, 0x9a, 0xa5, 0x99, 0x38, 0xa2, 0x11, 0xfb, 0x13, 0x73, 0x3f, 0x30, 0xed, 0x47, 0x6b, 0xac, 0x2d, 0xb3, 0x4f, 0x5f, 0xd, 0xa6, 0x7a, 0x60, 0x9c, 0x49, 0xcf, 0x3b, 0xcf, 0xbb, 0x90, 0xe1, 0xa7, 0x97, 0x4b, 0x33, 0xd0, 0x25, 0x2c, 0x5d, 0xc1, 0x8e, 0x5c, 0x67, 0xbf, 0x5c, 0x1, 0x33, 0x44, 0x99, 0x36, 0xe3, 0x87, 0xb3, 0xc3, 0x58, 0x23, 0xc9, 0xee, 0xb2, 0xe5, 0xbf, 0x63, 0x37, 0x66, 0x5a, 0xd4, 0x1e, 0xba, 0x13, 0x46, 0xe7, 0x43, 0x62, 0xd3, 0xe5, 0xfd, 0x86, 0x36, 0xba, 0x54, 0xc4, 0xad, 0xb7, 0x54, 0x48, 0xd7, 0x65, 0xf, 0xbb, 0x54, 0x26, 0x84, 0xfd, 0x92, 0x4f, 0x82, 0x34, 0x89, 0x65, 0x69, 0xaa, 0x46, 0x66, 0x22, 0xa5, 0x3c, 0x4, 0x2c, 0xa8, 0x43, 0xed, 0x6b, 0xb6, 0x3, 0xf2, 0xd7, 0xb7, 0x5, 0x8d, 0xfd, 0xa1, 0x39, 0x83, 0xed, 0x91, 0x3e, 0xd5, 0x65, 0xc2, 0xe1, 0x7, 0x8f, 0x67, 0x31, 0xc7, 0x6e, 0xc7, 0x96, 0xcb, 0x41, 0x29, 0x7c, 0xbc, 0xf3, 0xbc, 0xf4, 0x42, 0x26, 0x1d, 0x22, 0x93, 0xb8, 0x13, 0x70, 0x3a, 0xe9, 0x92, 0x6b, 0x22, 0xf5, 0x5e, 0x33, 0xaf, 0x40, 0x49, 0x6, 0x3e, 0xa4, 0x43, 0xd2, 0x30, 0xaf, 0x25, 0x59, 0x7c, 0xe2, 0x8, 0x27, 0x95, 0x27, 0x49, 0xd0, 0x20, 0xff, 0xf0, 0x7a, 0x58, 0xae, 0xd9, 0x51, 0xfd, 0x9c, 0xa9, 0xb2, 0xac, 0xb1, 0x53, 0x46, 0xd5, 0x13, 0xb3, 0x49, 0xe, 0x2c, 0x12, 0x94, 0x60, 0x5d, 0x91, 0xec, 0x67, 0xcc, 0x73, 0xf7, 0x6a, 0x38, 0xff, 0xbd, 0x86, 0xd7, 0x9c, 0x55, 0xc8, 0x65, 0x15, 0x16, 0x4a, 0x8b, 0xea, 0xcc, 0xb3, 0x86, 0xe7, 0x5e, 0xa1, 0x81, 0xc7, 0x62, 0x33, 0xc1, 0x85, 0x49, 0xd4, 0x1d, 0x5e, 0xf5, 0xf4, 0xda, 0x25, 0x80, 0x9d, 0xc7, 0x1b, 0x5c, 0x3f, 0x83, 0xa1, 0xdc, 0x31, 0xd4, 0xd1, 0x17, 0xa5, 0x75, 0x1d, 0x77, 0x38, 0xb, 0x54, 0x19, 0xa2, 0xa4, 0xa8, 0xcf, 0xd2, 0x39, 0x1d, 0xd9, 0x7f, 0x88, 0xc7, 0xc8, 0xf3, 0x9a, 0x22, 0xea, 0xe, 0xa3},
+               output224: []byte{0xda, 0x3b, 0x6c, 0x90, 0x8d, 0x94, 0x7a, 0x2, 0x59, 0x2, 0x39, 0xe1, 0x11, 0xbb, 0xe4, 0xd6, 0x43, 0x66, 0x55, 0xa3, 0xf, 0x7f, 0x6f, 0x17, 0xdd, 0xf5, 0x25, 0xcf},
+               output256: []byte{0x3, 0xb5, 0xa9, 0x21, 0x8a, 0xf0, 0xfb, 0x5a, 0xbd, 0x1a, 0xd6, 0xdf, 0xb1, 0xb3, 0x2e, 0x2e, 0xe8, 0x2b, 0x5, 0x4c, 0xbb, 0x4, 0x6a, 0xbc, 0x65, 0x6c, 0xc5, 0x26, 0x20, 0x82, 0x85, 0x53},
+               output384: []byte{0x8a, 0x12, 0x49, 0xf0, 0xaf, 0x80, 0x50, 0x79, 0xb5, 0xf1, 0xd8, 0x23, 0xc7, 0x10, 0x1e, 0xdb, 0x47, 0x91, 0x7b, 0xf0, 0x92, 0xa8, 0xaf, 0x98, 0xda, 0x8e, 0x1b, 0x1e, 0xe1, 0xe8, 0x22, 0xa8, 0x9, 0x83, 0x55, 0xd4, 0x51, 0x42, 0xe, 0xe2, 0x41, 0x43, 0xc9, 0x97, 0x81, 0x96, 0x96, 0x98},
+               output512: []byte{0xd2, 0x3b, 0x6e, 0x24, 0x24, 0x7a, 0xce, 0x20, 0xa, 0xae, 0xd6, 0x9f, 0x42, 0x5b, 0x65, 0xfc, 0xa3, 0x78, 0x11, 0x2a, 0x2b, 0x53, 0xbe, 0x7e, 0x59, 0x12, 0x52, 0x2d, 0x95, 0xa2, 0x5a, 0xde, 0x40, 0xf5, 0xc7, 0xca, 0x9f, 0x7c, 0xb9, 0xf1, 0x50, 0xa9, 0xfe, 0xd4, 0x78, 0x2b, 0xdd, 0x3f, 0xb8, 0x63, 0xbc, 0x2, 0xe9, 0xeb, 0xe, 0xfc, 0xec, 0x44, 0x23, 0x4a, 0xf7, 0x66, 0x37, 0x71}},
+       testcase{
+               msg:       []byte{0xaf, 0x3, 0x37, 0x72, 0x47, 0x8b, 0x6c, 0x7a, 0x40, 0x59, 0x6, 0x81, 0x1d, 0x78, 0x7a, 0xcd, 0xa7, 0xb7, 0x75, 0xc2, 0x8e, 0xbf, 0xfa, 0x6, 0xae, 0xab, 0x37, 0xee, 0x36, 0x34, 0x76, 0x23, 0x9a, 0x4f, 0xa0, 0xaf, 0x7a, 0xfc, 0xed, 0xad, 0xeb, 0x2d, 0xed, 0x7c, 0xa3, 0x99, 0x7c, 0x82, 0xa5, 0x4d, 0x6f, 0xd, 0x10, 0x16, 0xc4, 0xbc, 0x2d, 0x18, 0x2f, 0x61, 0x16, 0x23, 0x26, 0x86, 0xf7, 0xb5, 0xba, 0xec, 0x0, 0x75, 0x9e, 0x7b, 0x2a, 0xcf, 0xa, 0x2f, 0x9d, 0xec, 0x55, 0xf3, 0xe3, 0xc7, 0x2, 0xf2, 0x1d, 0x76, 0xa, 0x85, 0x32, 0x83, 0xc7, 0x5b, 0x1e, 0xdd, 0x75, 0x44, 0x2e, 0x30, 0xda, 0x1d, 0xe7, 0x41, 0x97, 0x91, 0x3b, 0xca, 0xab, 0x1a, 0x61, 0x9e, 0x44, 0xc6, 0x5f, 0x41, 0xe, 0x9b, 0x8f, 0x23, 0x5d, 0x68, 0xd1, 0xef, 0xb, 0x78, 0x53, 0xac, 0x83, 0x62, 0x59, 0xc7, 0x6b, 0x4a, 0x84, 0xf4, 0x2, 0xc2, 0xe9, 0xf, 0x58, 0x79, 0x76, 0x13, 0x51, 0xdd, 0x28, 0x1e, 0x19, 0x21, 0x9e, 0x27, 0x4a, 0xc8, 0xd7, 0x65, 0x89, 0x15, 0x3f, 0xb5, 0xe6, 0x87, 0xcc, 0xd, 0xe9, 0xb5, 0x43, 0xf7, 0x63, 0xe6, 0x32, 0xa4, 0x65, 0xbe, 0x81, 0xf2, 0xfa, 0xde, 0xf, 0xee, 0xb9, 0x6d, 0x41, 0x2, 0xbc, 0xfa, 0x27, 0x6d, 0x7c, 0x9d, 0x6, 0x94, 0x5c, 0xfe, 0xa6, 0xc8, 0x2c, 0xaf, 0xed, 0x68, 0xb, 0xdd, 0x37, 0xf6, 0xeb, 0xe9, 0xb8, 0x1, 0x3b, 0xc2, 0xe7, 0xde, 0xc5, 0x2a, 0x87, 0xa1, 0xc5, 0x39, 0xd8, 0xaa, 0x5a, 0xd5, 0x25, 0xf9, 0x40, 0x5b, 0x1d, 0xb1, 0xef, 0x94, 0x2d, 0x4e, 0x98, 0xf4, 0xa, 0x1, 0xc3, 0xe5, 0xe5, 0x55, 0xc9, 0x2d, 0x18, 0xf3, 0x6e, 0xf4, 0xdd, 0x8c, 0xbb, 0x5a, 0xa7, 0x20, 0x7f, 0xef, 0xfa, 0xf2, 0x8a, 0x57, 0x62, 0xdd, 0xaf, 0xab, 0x4c, 0x84, 0x10, 0x63, 0xc6, 0x4f, 0xf, 0xbc, 0x32, 0xaa, 0xa6, 0x9c, 0xc1, 0x30, 0xc9, 0xa2, 0xad, 0xd7, 0x8c, 0x79, 0x5f, 0x5e, 0x41, 0x7b, 0x57, 0x26, 0x39, 0x9, 0x52, 0x6d, 0x2a, 0x74, 0x12, 0x76, 0xe4, 0x4d, 0x5, 0xa3, 0xc1, 0x75, 0xb5, 0x1f, 0xba, 0x17, 0xfd, 0xaf, 0x7d, 0x83, 0xef, 0xfc, 0xe3, 0x48, 0x71, 0x59, 0xcd, 0x92, 0xf4, 0xa, 0x19, 0xc5, 0x67, 0xda, 0x4e, 0x66, 0x7a, 0x0, 0x8c, 0x5a, 0xe8, 0xe6, 0xe0, 0x4f, 0x85, 0x26, 0x64, 0x2c, 0xb4, 0xa2, 0xf4, 0xcf, 0xa, 0x7, 0xaf, 0x44, 0xa6, 0x5d, 0x4f, 0x1d, 0x67, 0x1, 0xd6, 0xe3, 0x3b, 0xad, 0x2b, 0x1a, 0xe2, 0xbc, 0x18, 0xef, 0x45, 0x22, 0xf6, 0x4f, 0x28, 0x56, 0x52, 0xa1, 0x15, 0x54, 0x87, 0xb8, 0xa4, 0x9e, 0x9b, 0xe, 0xb9, 0x96, 0x56, 0x7f, 0xde, 0xfe, 0x7, 0xb8, 0xef, 0x97, 0xda, 0x55, 0xc4, 0x93, 0x44, 0x8f, 0xb0, 0xee, 0xd5, 0x32, 0x8, 0x8a, 0xdb, 0xd3, 0x55, 0xe4, 0x96, 0x6e, 0xd5, 0x99, 0x6e, 0xf8, 0x8c, 0xfb, 0x94, 0x25, 0x43, 0xd5, 0x6, 0x5f, 0x88, 0x26, 0xf8, 0x56, 0x18, 0xda, 0xab, 0xa9, 0xf1, 0xce, 0xae, 0x14, 0x83, 0x8, 0x3c, 0xfd, 0x52, 0x72, 0xbe, 0x7, 0xfa, 0xa6, 0x27, 0xd, 0x51, 0xb7, 0xdf, 0x74, 0x25, 0x8f, 0xf6, 0x2c, 0x20, 0xa8, 0xb6, 0x92, 0xa4, 0xfd, 0xf0, 0xf6, 0x95, 0x5c, 0x1f, 0xfb, 0xb4, 0x8c, 0x5b, 0xd5, 0x2, 0x6b, 0xb2, 0x57, 0x97, 0x2a, 0x81, 0x84, 0x9d, 0xb7, 0xb4, 0xee, 0xcd, 0xac, 0x95, 0x31, 0xc2, 0xef, 0x50, 0xf9, 0x15, 0x11, 0x90, 0x86, 0xd8, 0xe3, 0xb5, 0x21, 0x91, 0xb7, 0x65, 0xd6, 0xe3, 0x8d, 0xda, 0x2b, 0x12, 0x5d, 0xeb, 0x8b, 0xa9, 0xbb, 0x84, 0x14, 0x60, 0xb9, 0x75, 0x5d, 0x1f, 0xe3, 0x8c, 0x17, 0x65, 0xb7, 0x2e, 0xff, 0x98, 0xb9, 0x3d, 0xfa, 0x87, 0xe0, 0xcd, 0x47, 0x87, 0xb7, 0x4a, 0xe3, 0x35, 0xa9, 0xa6, 0x1b, 0x93, 0x4e, 0x25, 0x8e, 0xcb, 0x76, 0x42, 0x84, 0xf0, 0x71, 0x5d, 0xe4, 0x38, 0xe5, 0xf2, 0xf5, 0x96, 0x39, 0x2, 0x1e, 0xf2, 0xb2, 0x1f, 0xbf, 0x49, 0xd5, 0x3b, 0x63, 0x5f, 0x68, 0x3e, 0x37, 0x11, 0xa2, 0xaf, 0x1d, 0x1e, 0x25, 0x55, 0xf5, 0xae, 0x93, 0x15, 0x8b, 0xb5, 0xf6, 0x67, 0xc, 0xcc, 0xc, 0x99, 0xd2, 0x3c, 0xcd, 0x4d, 0x22, 0x8f, 0x2a, 0x63, 0x74, 0xbc, 0x7a, 0xa2, 0xc3, 0x21, 0xf0, 0x3a, 0x8a, 0xbb, 0x4d, 0x9d, 0xb6, 0x73, 0xa6, 0x3e, 0xa1, 0xce, 0x5d, 0x5b, 0xa5, 0x13, 0x3a, 0xf9, 0xeb, 0xdb, 0xcc, 0xef, 0x97, 0x1, 0x6b, 0x81, 0x3a, 0x97, 0x65, 0xb9, 0xac, 0x1e, 0xb5, 0x1a, 0x93, 0xd7, 0x76, 0xb, 0x36, 0x75, 0x1c, 0x76, 0x62, 0x83, 0xab, 0x13, 0xe7, 0x73, 0xa1, 0x28, 0x55, 0x91, 0x55, 0x45, 0x51, 0x31, 0xb8, 0x46, 0x67, 0x1, 0xf6, 0xc1, 0x6a, 0xcc, 0x82, 0x26, 0x12, 0xc1, 0xbe, 0x81, 0xe1, 0x4f, 0x5d, 0x9b, 0xdf, 0x8b, 0x9d, 0xcb, 0xaa, 0x7f, 0x3e, 0x10, 0xc3, 0x56, 0x34, 0x0, 0x4d, 0xaa, 0x50, 0x6a, 0x26, 0x87, 0x8a, 0xe7, 0x51, 0xd, 0xda, 0xc3, 0xfc, 0x9f, 0x8d, 0xf0, 0xf5, 0x2e, 0xb, 0xe1, 0x5, 0x13, 0xd6, 0x41, 0xfd, 0xa7, 0x41, 0xfd, 0x26, 0x5f, 0x9e, 0xe, 0x3d, 0xed, 0xee, 0xe4, 0x55, 0x13, 0xd1, 0x88, 0x44, 0x58, 0x90, 0xc3, 0x84, 0xdd, 0xa5, 0x1b, 0xa4, 0xcd, 0x1a, 0xc6, 0x31, 0x37, 0x55, 0xb, 0x59, 0x5f, 0xb2, 0xc3, 0xab, 0xa5, 0xb6, 0xa, 0x79, 0x8c, 0x44, 0x18, 0xc9, 0x40, 0x23, 0x33, 0x23, 0x2e, 0x1a, 0x26, 0x61, 0xc8, 0x97, 0x7d, 0xcc, 0xe6, 0x6, 0xf4, 0xba, 0x89, 0xe8, 0x3a, 0x1b, 0xca, 0xb8, 0x8b, 0xa6, 0xf3, 0xdb, 0x59, 0x34, 0xc2, 0x27, 0xd3, 0xca, 0x82, 0x0, 0x63, 0xa1, 0xdc, 0x2e, 0xeb, 0xc, 0x18, 0x22, 0xdd, 0x2c, 0xb8, 0x9b, 0xaa, 0x12, 0xd8, 0x1b, 0xeb, 0xdf, 0xfb, 0xd0, 0x54, 0xdb, 0xc4, 0xa0, 0x63, 0x35, 0x5e, 0xd3, 0x82, 0x5e, 0x81, 0x96, 0xca, 0x4, 0xd6, 0xd1, 0x2d, 0x8c, 0x8c, 0x52, 0x1d, 0x63, 0x3e, 0x2f, 0x21, 0x4e, 0x84, 0x68, 0x53, 0xde, 0x5d, 0x8, 0x77, 0xd4, 0x10, 0x58, 0xce, 0xb7, 0x75, 0x45, 0xe7, 0x73, 0xc0, 0xb5, 0xd5, 0x15, 0x5d, 0x4b, 0x61, 0xb4, 0xcb, 0x6, 0xd, 0xba, 0x7d, 0xfc, 0xe8, 0x4d, 0x3e, 0x25, 0xf3, 0x9e, 0xa6, 0xb9, 0x5c, 0xdf, 0x83, 0x11, 0xe, 0x9c, 0x10, 0x51, 0xd7, 0x46, 0xf0, 0x18, 0x3c, 0x1, 0xb0, 0x6e, 0x31, 0x10, 0x35, 0xa2, 0x88, 0x9, 0xf4, 0xcd, 0xda, 0x7, 0x84, 0xd7, 0x90, 0x3e, 0x13, 0x2d, 0xe9, 0x1e, 0xf, 0x42, 0x6d, 0x93, 0x7c, 0x5e, 0x98, 0xff, 0x81, 0x23, 0xad, 0x11, 0xac, 0x3e, 0x11, 0x33, 0xcf, 0xa6, 0x29, 0x8b, 0xe0, 0xab, 0x58, 0xb5, 0xdf, 0x55, 0xd6, 0x6, 0xd, 0x51, 0x63, 0xd8, 0x47, 0xee, 0x59, 0x65, 0xfa, 0xd6, 0xa, 0x85, 0x3, 0xc3, 0xbb, 0x54, 0x93, 0x58, 0x56, 0x54, 0x4d, 0x57, 0x40, 0x42, 0x15, 0xfc, 0x84, 0x3d, 0x41, 0xe5, 0xc7, 0x3f, 0x1a, 0x8e, 0x50, 0xf, 0xb, 0xab, 0x3f, 0xba, 0x3f, 0xe5, 0x54, 0x75, 0xf8, 0x9a, 0x96, 0x7e, 0x7e, 0x7, 0xed, 0x21, 0xd6, 0xd8, 0x21, 0xa7, 0x97, 0xa9, 0xb3, 0xe9, 0x33, 0x41, 0x68, 0xfd, 0x6d, 0x1f, 0x19, 0xf3, 0x12, 0xa5, 0xbb, 0x69, 0x42, 0x2c, 0xad, 0x50, 0x68, 0x51, 0x77, 0xc, 0x38, 0x97, 0xdf, 0x83, 0x83, 0x3, 0xb2, 0x78, 0x3f, 0x86, 0xc8, 0xa5, 0x6, 0xee, 0x32, 0x6e, 0xe4, 0xd8, 0xc4, 0x92, 0xcd, 0x11, 0x50, 0xf4, 0x77, 0x1a, 0x53, 0x34, 0x40, 0xe7, 0x4d, 0x7e, 0x90, 0x80, 0x19, 0x3f, 0x6d, 0x4b, 0x44, 0xbc, 0x26, 0x65, 0x8d, 0x8b, 0xbb, 0x53, 0xa1, 0x32, 0xaf, 0xce, 0x18, 0x99, 0x22, 0x4b, 0xce, 0xa0, 0x37, 0x5a, 0x5e, 0x3e, 0x56, 0x3f, 0xc1, 0x69, 0x39, 0xbd, 0x3e, 0xc0, 0x85, 0xd2, 0xa5, 0x36, 0x4f, 0xaf, 0x11, 0xed, 0xa4, 0x1e, 0xef, 0xf4, 0x44, 0x9, 0xc5, 0x10, 0xf, 0xa, 0xc2, 0xef, 0x60, 0xea, 0x8a, 0xb9, 0x8c, 0x35, 0xf9, 0xfd, 0x65, 0xfa, 0x61, 0xd6, 0xa6, 0xa, 0xb0, 0xc3, 0x54, 0x37, 0x86, 0x72, 0x21, 0xdd, 0xb6, 0xa8, 0x77, 0x2, 0xed, 0x44, 0xe1, 0x15, 0xba, 0xef, 0x16, 0xf2, 0x5c, 0xce, 0x2b, 0x11, 0xb8, 0x6, 0x2a, 0x8c, 0x2a, 0x6, 0xe3, 0x4c, 0x40, 0x0, 0xea, 0xe8, 0x81, 0xbe, 0x36, 0x71, 0xc5, 0x66, 0xb4, 0xc2, 0xb5, 0x2b, 0xe2, 0x84, 0xfa, 0x70, 0x73, 0x36, 0x4b, 0x7e, 0x9a, 0x6d, 0xbb, 0xa8, 0xae, 0x7e, 0xbc, 0xf6, 0x0, 0x84, 0x91, 0xc6, 0x6c, 0x7e, 0xe4, 0x9e, 0xd4, 0x26, 0xe7, 0xa3, 0xee, 0x3d, 0xe2, 0x55, 0xb0, 0xb2, 0x4f, 0x88, 0xa2, 0xe7, 0x38, 0x17, 0x7c, 0xf7, 0xae, 0xe4, 0xff, 0xb5, 0xf2, 0xce, 0x40, 0x54, 0xca, 0xb2, 0x37, 0x8b, 0xa, 0xf8, 0xa5, 0xa2, 0xbe, 0x2f, 0xba, 0x43, 0xe5, 0x85, 0x94, 0x36, 0xa4, 0xf3, 0x21, 0xf8, 0x52, 0x2c, 0x75, 0x7, 0x53, 0x8b, 0x74, 0xd0, 0xd3, 0xe2, 0xb1, 0xb9, 0x4e, 0x92, 0x60, 0xd, 0x71, 0x16, 0xba, 0x31, 0x9d, 0x88, 0x68, 0x24, 0x90, 0x8b, 0x4, 0x80, 0x35, 0x31, 0x91, 0x4a, 0xc7, 0xa8, 0x15, 0x39, 0x37, 0xfc, 0xf2, 0x8, 0x59, 0x68, 0xa7, 0xb9, 0x24, 0xcf, 0xbc, 0x49, 0x32, 0x4b, 0xf0, 0x14, 0x4b, 0xe3, 0x7f, 0xf3, 0x9a, 0x23, 0x5a, 0x15, 0x18, 0x73, 0xf9, 0xbf, 0xeb, 0x57, 0x36, 0x6b, 0xf9, 0xc8, 0xa0, 0xa9, 0xdc, 0x9c, 0x2e, 0x84, 0x7c, 0x7b, 0x87, 0xd6, 0x44, 0xa0, 0xbc, 0xf0, 0x91, 0xf6, 0x8e, 0x46, 0x3c, 0xbb, 0x51, 0x66, 0xa, 0xd, 0xc7, 0xc0, 0x2, 0x76, 0x5f, 0x6d, 0x15, 0xc4, 0x46, 0xa1, 0xd8, 0x4d, 0x62, 0x5b, 0xd1, 0xc, 0xc9, 0x7b, 0x81, 0x80, 0x66, 0x61, 0x84, 0x82, 0x80, 0x3e, 0xc0, 0xc7, 0x3b, 0x66, 0xbe, 0xe4, 0xfa, 0x71, 0xee, 0x72, 0xad, 0xd4, 0x5d, 0x5b, 0xb6, 0x71, 0xfc, 0xe5, 0xb2, 0x78, 0xf7, 0xf1, 0x9d, 0x90, 0x9e, 0xc6, 0xe9, 0x20, 0x19, 0xcc, 0xe4, 0x41, 0x87, 0x96, 0xed, 0x5b, 0x97, 0xe3, 0xa7, 0xd9, 0x0, 0x6d, 0x2c, 0x3d, 0x82, 0x28, 0x7c, 0x65, 0x9a, 0x52, 0x6d, 0xf5, 0x19, 0xc1, 0x1b, 0x21, 0xda, 0xfa, 0x78, 0x7b, 0xfd, 0xd0, 0x3f, 0x4a, 0x2e, 0xd8, 0x32, 0xef, 0xe8, 0xc9, 0x20, 0x6b, 0x59, 0x29, 0xc, 0xc3, 0xd1, 0xef, 0x74, 0x97, 0x6e, 0x38, 0xb0, 0x5d, 0x2b, 0x9a, 0xa3, 0x1c, 0x18, 0xe6, 0x6c, 0xa7, 0xfe, 0xc, 0xd8, 0x3, 0xeb, 0x58, 0x3f, 0x4a, 0x6a, 0xdc, 0xe, 0x90, 0xa5, 0x21, 0x49, 0x2e, 0xfc, 0x83, 0xf9, 0xe5, 0x19, 0x66, 0xfa, 0x69, 0x68, 0x4e, 0xdd, 0x67, 0xf4, 0xa1, 0x11, 0xfa, 0x89, 0x42, 0x41, 0xe9, 0xdf, 0x30, 0xfa, 0x8d, 0x22, 0x27, 0xd7, 0xdb, 0x2e, 0x79, 0xfa, 0xcb, 0x7a, 0x2d, 0x9b, 0x94, 0xd7, 0xd5, 0xb7, 0x41, 0xcd, 0x92, 0x24, 0xf9, 0x61, 0x55, 0xbe, 0x98, 0x8e, 0x3, 0x20, 0x5d, 0x2c, 0x47, 0x54, 0x1a, 0x0, 0x1e, 0x2a, 0x7e, 0xee, 0xa3, 0xbe, 0x70, 0xde, 0xc1, 0x9b, 0xcc, 0x61, 0x25, 0xdc, 0x9d, 0xc0, 0xca, 0xa9, 0x4f, 0xeb, 0x63, 0x8f, 0xcb, 0x60, 0x5a, 0x46, 0xa2, 0x24, 0xfa, 0x3b, 0xd1, 0x80, 0xf6, 0x76, 0x1d, 0x4d, 0x92, 0x89, 0xdb, 0x2d, 0x2e, 0x76, 0x26, 0x99, 0x58, 0x3f, 0xb, 0x86, 0x4d, 0x90, 0x81, 0x61, 0x1d, 0xe2, 0xb1, 0xc0, 0x32, 0xca, 0x0, 0xc7},
+               output224: []byte{0xa6, 0x35, 0x1b, 0x5, 0xaf, 0xe1, 0x91, 0x21, 0xb1, 0x59, 0x81, 0xa3, 0xd4, 0x8a, 0xfa, 0x6f, 0xd5, 0xcd, 0x7b, 0x65, 0x89, 0xa9, 0x47, 0xbc, 0xc, 0xcd, 0xf5, 0xab},
+               output256: []byte{0xe2, 0x59, 0x70, 0x3b, 0xe7, 0x2c, 0xc3, 0x26, 0x9, 0x4d, 0x4d, 0x53, 0x1c, 0xd7, 0xff, 0xc6, 0xf2, 0xe5, 0xd, 0xdf, 0x39, 0x4d, 0x96, 0x4e, 0x8d, 0x29, 0xfe, 0xe3, 0xd7, 0x58, 0xe4, 0x56},
+               output384: []byte{0xa7, 0xcf, 0xbb, 0x3e, 0x0, 0x67, 0x35, 0x2, 0x57, 0xab, 0xe8, 0x8f, 0x84, 0x8e, 0x17, 0x4d, 0xaa, 0xf4, 0xb9, 0x57, 0xe2, 0x2f, 0x2e, 0xea, 0x4a, 0xc3, 0xa3, 0x6f, 0x6f, 0x3c, 0x1, 0x4e, 0x19, 0xca, 0xd5, 0x83, 0x45, 0x78, 0x5e, 0xaa, 0x37, 0xcc, 0x52, 0x33, 0x87, 0xc8, 0xed, 0x54},
+               output512: []byte{0x27, 0x73, 0x9b, 0xda, 0x63, 0x9d, 0x10, 0x72, 0x75, 0xfa, 0x9f, 0x84, 0x8e, 0x40, 0xf9, 0x3c, 0x20, 0xa8, 0x89, 0x45, 0xa6, 0x2a, 0x15, 0x21, 0x8f, 0xb, 0x26, 0xc4, 0xa5, 0x37, 0xee, 0x42, 0x9c, 0x1f, 0xd, 0x6, 0xe9, 0x81, 0x12, 0x38, 0x4d, 0xa6, 0xb0, 0x1f, 0xeb, 0x15, 0x80, 0x60, 0x52, 0xb5, 0xc8, 0x35, 0xc8, 0x29, 0x6d, 0x75, 0x19, 0x8f, 0xb5, 0x99, 0x5c, 0xf3, 0xdd, 0x79}},
+       testcase{
+               msg:       []byte{0x8f, 0x1c, 0x1e, 0x85, 0x39, 0x3b, 0x9c, 0x2a, 0x2b, 0x59, 0x33, 0x63, 0xdc, 0xeb, 0x81, 0x8b, 0x10, 0x2d, 0xf, 0x57, 0xd4, 0xe1, 0xd3, 0x1b, 0xd3, 0x3c, 0x3, 0x4d, 0xfb, 0x1f, 0x17, 0xe2, 0xa9, 0xdb, 0x96, 0xd, 0x70, 0xd2, 0xfa, 0xa, 0xae, 0xbb, 0x7b, 0x56, 0xc8, 0x9, 0xea, 0x6, 0x7e, 0x93, 0xc4, 0x49, 0xf4, 0x2, 0x6a, 0x25, 0x8a, 0xc0, 0x4b, 0x6c, 0xe8, 0x9, 0xa7, 0x34, 0xd1, 0x5b, 0x7f, 0xe1, 0x3e, 0x4f, 0xaf, 0x8f, 0x26, 0x14, 0xdb, 0x9c, 0x3a, 0x42, 0x43, 0x5f, 0xbf, 0x15, 0x8e, 0x3e, 0x6c, 0xb3, 0xa, 0xa7, 0x27, 0x27, 0x2a, 0x4e, 0x32, 0x3d, 0xf2, 0x17, 0x20, 0xad, 0x65, 0xd7, 0x2b, 0x18, 0xa4, 0xa6, 0xba, 0xff, 0x9d, 0xde, 0x47, 0xca, 0xbb, 0x34, 0x3d, 0xb2, 0x82, 0x17, 0x5d, 0x85, 0xff, 0x51, 0xb3, 0x4a, 0x19, 0x77, 0x52, 0x13, 0x8a, 0xf3, 0xa0, 0x17, 0xd1, 0x99, 0x39, 0xdf, 0x72, 0x8a, 0x9, 0xc8, 0xf2, 0x8c, 0xde, 0xf4, 0xce, 0x5f, 0xf5, 0x40, 0xa6, 0xc9, 0x96, 0x8f, 0x46, 0x35, 0xd8, 0xd3, 0x28, 0x1f, 0x1a, 0x51, 0x26, 0xfc, 0x3a, 0x7e, 0xd3, 0x68, 0xdf, 0xfd, 0x41, 0xb5, 0xaa, 0xdf, 0xaa, 0xfc, 0xe5, 0xfc, 0x6, 0x90, 0x56, 0x85, 0x4a, 0x78, 0x5, 0x49, 0x17, 0xd3, 0x9a, 0x34, 0x94, 0x5f, 0xb5, 0xe6, 0x8, 0xfe, 0xba, 0xc8, 0x8f, 0xa, 0x53, 0x60, 0xa5, 0x24, 0xd9, 0xc8, 0x87, 0x24, 0x1d, 0x29, 0x53, 0xbd, 0x36, 0xe4, 0x6d, 0xb7, 0x5a, 0x45, 0x8f, 0x4d, 0xf4, 0x94, 0xe, 0xd7, 0x11, 0x10, 0x33, 0x44, 0x7, 0xdd, 0x0, 0x8, 0xa6, 0xdc, 0xae, 0x7d, 0x13, 0xfa, 0x5c, 0xbf, 0xce, 0xfd, 0x66, 0x67, 0xba, 0xc6, 0x57, 0xdc, 0xbe, 0x1d, 0xfb, 0xab, 0x48, 0x3d, 0xae, 0xc6, 0x86, 0xab, 0x87, 0xe, 0xb6, 0x2, 0x25, 0x68, 0x96, 0x33, 0xf7, 0x1f, 0xd, 0x3c, 0x4c, 0x87, 0xb, 0xfe, 0x60, 0x90, 0x29, 0x8b, 0x37, 0x2b, 0x73, 0xd5, 0xac, 0xa2, 0x22, 0x5a, 0xd7, 0x24, 0x20, 0xc, 0xe2, 0x40, 0xa, 0x77, 0xd4, 0x78, 0x8e, 0xe6, 0xd4, 0xb5, 0x60, 0x33, 0x2a, 0x2, 0xd, 0xa0, 0x35, 0xda, 0x3d, 0x52, 0xa, 0xa9, 0xcc, 0x52, 0x22, 0x93, 0x29, 0xa8, 0x18, 0x47, 0xac, 0xf6, 0x80, 0xb3, 0xaf, 0xeb, 0x2c, 0x1b, 0xc8, 0x4b, 0x6, 0x80, 0xa, 0xf3, 0x81, 0xcd, 0xb9, 0xaa, 0xa, 0x68, 0x7c, 0x50, 0xd0, 0x30, 0x29, 0xa0, 0xa6, 0xb5, 0x64, 0x1a, 0x8d, 0x3a, 0x8e, 0x40, 0xfd, 0x93, 0x18, 0xd3, 0xc5, 0xad, 0xd5, 0x1a, 0x4a, 0xbe, 0x66, 0x1b, 0xc3, 0xc5, 0xc4, 0x7d, 0x38, 0x50, 0x7a, 0x8a, 0xa7, 0xd6, 0x27, 0x5d, 0xf3, 0x8, 0x26, 0x33, 0x63, 0x7e, 0x57, 0x0, 0x78, 0x77, 0x14, 0xfc, 0x97, 0x76, 0x98, 0xed, 0xd2, 0x21, 0x8f, 0xfd, 0x47, 0xa8, 0x1d, 0x42, 0x8b, 0xf, 0xd6, 0x1b, 0xe6, 0x51, 0x47, 0x8d, 0xf0, 0x1, 0xd, 0xdd, 0xf9, 0x36, 0x3e, 0x93, 0xd8, 0xb3, 0x7b, 0x3d, 0x8e, 0x1b, 0x12, 0x2b, 0x76, 0xe1, 0x59, 0x85, 0xd9, 0xf4, 0xec, 0xcf, 0x55, 0x93, 0x6d, 0x91, 0x8f, 0xc, 0xbe, 0x39, 0x73, 0x4a, 0x1c, 0x41, 0xb3, 0x3b, 0x3e, 0xfd, 0x34, 0xd8, 0x45, 0xde, 0x55, 0x26, 0xc1, 0x83, 0xd9, 0x18, 0x78, 0x6c, 0x8e, 0xd3, 0xfa, 0xf1, 0xde, 0xb9, 0x2e, 0x85, 0xcd, 0x6f, 0xc3, 0x4, 0x21, 0xd2, 0x9, 0xd6, 0xcc, 0xa4, 0x7e, 0x9d, 0xb5, 0x34, 0x12, 0x51, 0xe2, 0x53, 0xe9, 0x32, 0xc8, 0xf0, 0x86, 0x28, 0xd2, 0x11, 0x5e, 0x56, 0x5c, 0x2d, 0x58, 0x1f, 0x8c, 0x89, 0x55, 0xd7, 0x19, 0x36, 0xdd, 0x50, 0x5e, 0x85, 0x58, 0xde, 0xa1, 0x40, 0x9e, 0x84, 0xea, 0x31, 0xba, 0x53, 0x55, 0xd7, 0xe2, 0xd0, 0x11, 0xf7, 0xdf, 0x83, 0xac, 0xb9, 0xce, 0xc, 0x6d, 0xef, 0xa5, 0x1b, 0x16, 0x18, 0x5a, 0x66, 0xd3, 0xd6, 0xd1, 0xd1, 0xd7, 0x14, 0x21, 0x68, 0xd9, 0xb8, 0xa0, 0x83, 0x2f, 0xd2, 0xec, 0xad, 0xad, 0x64, 0xca, 0xbe, 0xe8, 0xc7, 0x93, 0x28, 0xb9, 0x51, 0x33, 0x28, 0xfd, 0x4c, 0x70, 0x6, 0x22, 0x26, 0x85, 0xaf, 0x6c, 0x39, 0xab, 0x5f, 0x8, 0x1e, 0xdd, 0x49, 0x15, 0x4b, 0x5a, 0x25, 0x37, 0x5e, 0xeb, 0xa3, 0xf6, 0x63, 0xf7, 0x79, 0x9a, 0xed, 0xc4, 0xf, 0xd7, 0x47, 0x48, 0xbe, 0x95, 0x6e, 0xc6, 0x6f, 0x77, 0xec, 0x97, 0x45, 0x7d, 0x1c, 0x8, 0xc4, 0xa0, 0x3b, 0xa3, 0x24, 0x36, 0x54, 0x99, 0xd8, 0xd0, 0xaf, 0xe4, 0xa4, 0x5e, 0x75, 0x63, 0xbc, 0xe, 0x4e, 0x33, 0xaf, 0x70, 0x4e, 0x7c, 0xbd, 0x8f, 0x85, 0xce, 0x14, 0xfe, 0x1f, 0x84, 0xe1, 0xbb, 0xb8, 0x71, 0xd3, 0x61, 0xd4, 0x6e, 0xe, 0xb0, 0xb0, 0x44, 0xd4, 0xaf, 0x33, 0xb8, 0x67, 0x2b, 0x68, 0x48, 0x3e, 0x71, 0x87, 0xf1, 0xf8, 0x9b, 0xde, 0x3d, 0xa2, 0x9c, 0x40, 0x50, 0x29, 0xdd, 0x3d, 0xa3, 0xb2, 0xeb, 0x8c, 0x24, 0x8e, 0x32, 0x35, 0xcd, 0x8d, 0x2e, 0xc1, 0x72, 0x71, 0xba, 0x55, 0x63, 0xa0, 0x9f, 0x5d, 0xaa, 0xa5, 0xe9, 0xd1, 0x18, 0xb1, 0xe2, 0xaa, 0x61, 0xd2, 0x32, 0xf4, 0xef, 0x92, 0x8d, 0xe1, 0xa1, 0xc, 0x78, 0x6c, 0xe3, 0x27, 0xb, 0x88, 0x9b, 0x6d, 0x85, 0x9f, 0x35, 0xee, 0x0, 0xda, 0x10, 0xfb, 0xbc, 0xde, 0x1, 0xa9, 0xcd, 0x47, 0x27, 0x17, 0xe1, 0xbb, 0x35, 0xda, 0xac, 0x57, 0x53, 0x1d, 0x44, 0xc0, 0xb6, 0x2b, 0xf8, 0x60, 0x63, 0xbf, 0x35, 0x5e, 0xc, 0x8, 0xe3, 0xba, 0xf6, 0x49, 0x9f, 0xa0, 0xba, 0x8e, 0xa9, 0x6f, 0xc3, 0x38, 0x50, 0x7b, 0x67, 0x5d, 0x1a, 0x31, 0x0, 0x8f, 0x97, 0x98, 0x7b, 0x2c, 0xc3, 0x66, 0xe7, 0x15, 0xf4, 0x34, 0x46, 0xf9, 0xde, 0x4d, 0xc8, 0xc0, 0xaa, 0x7d, 0x81, 0xbb, 0x3b, 0x2e, 0x7b, 0xa7, 0x23, 0x6d, 0x31, 0x7b, 0x32, 0xc, 0x93, 0x4a, 0xd8, 0xa, 0x7b, 0x17, 0xf0, 0xf5, 0x91, 0xfd, 0x9d, 0xbb, 0xdb, 0x18, 0x0, 0xbc, 0x37, 0x7b, 0x6b, 0x4, 0xdf, 0xf1, 0xd2, 0x68, 0xf3, 0xf6, 0x19, 0x1d, 0x3a, 0x37, 0x1, 0x56, 0x24, 0xa8, 0xb4, 0xef, 0xdd, 0xc1, 0xf6, 0x88, 0x2d, 0x66, 0x79, 0xfb, 0xf, 0xd9, 0x2b, 0xfc, 0x95, 0x26, 0x27, 0x2c, 0xd6, 0xa2, 0xcf, 0x76, 0x8e, 0x6d, 0xbf, 0x3f, 0xd1, 0x73, 0x2f, 0x6b, 0x46, 0xcd, 0x4c, 0xde, 0x5d, 0x7, 0xb7, 0xaa, 0xb4, 0x67, 0xfb, 0x87, 0x16, 0xe4, 0x1c, 0xa9, 0xb8, 0xea, 0x91, 0x39, 0xd0, 0x97, 0x1, 0x73, 0x6b, 0x3, 0x8d, 0x25, 0x1, 0x36, 0x66, 0xa8, 0xdb, 0xe6, 0x3e, 0xb, 0x60, 0xf9, 0x3f, 0x6e, 0x77, 0xbd, 0x27, 0x5, 0x59, 0x84, 0x73, 0xa, 0x6c, 0xc5, 0x79, 0x1c, 0x6b, 0x55, 0x85, 0xa1, 0xa5, 0x1f, 0x78, 0x7e, 0xaa, 0x42, 0xb3, 0xdb, 0x7c, 0xe6, 0x15, 0x94, 0x71, 0xdc, 0x54, 0x54, 0xb7, 0x31, 0x3a, 0xba, 0x20, 0xf2, 0xdf, 0x10, 0x4b, 0xf9, 0x88, 0x62, 0x34, 0xf, 0xe0, 0xa7, 0x4, 0x3a, 0x55, 0x5f, 0xfd, 0x7, 0xdd, 0x11, 0x12, 0xf9, 0xc1, 0x62, 0x7d, 0x54, 0x1a, 0x89, 0x6b, 0xc6, 0x6e, 0x78, 0xa0, 0x1a, 0xf4, 0xac, 0x30, 0x80, 0x3, 0xcf, 0x97, 0xa, 0x5c, 0x11, 0xd2, 0x88, 0xe, 0x39, 0x5b, 0xd9, 0x2d, 0x45, 0x59, 0x60, 0x44, 0x6a, 0x67, 0xcc, 0xdc, 0xee, 0x71, 0xcb, 0x6e, 0x76, 0xf9, 0x88, 0x7c, 0xeb, 0xdd, 0x1d, 0x5a, 0x60, 0x13, 0x1d, 0x2b, 0xae, 0x75, 0x31, 0xe1, 0x4f, 0x3e, 0x4, 0xa4, 0xea, 0xf5, 0xbd, 0x36, 0x6d, 0x4e, 0x17, 0x10, 0x29, 0x31, 0x89, 0x13, 0x1d, 0x2b, 0x9d, 0x8f, 0x28, 0xb8, 0x91, 0x9b, 0x27, 0xf5, 0x4a, 0x1, 0xfb, 0x80, 0x4c, 0x2d, 0x1a, 0x66, 0xb4, 0x93, 0x66, 0xc5, 0x94, 0x65, 0xed, 0xe6, 0xd6, 0x28, 0x1b, 0xa5, 0x65, 0x6e, 0xb, 0xc1, 0x45, 0x78, 0xed, 0x3a, 0xe2, 0x18, 0x9b, 0x1d, 0xc7, 0x3d, 0xb5, 0x3a, 0x21, 0x7f, 0x53, 0x4e, 0x27, 0x54, 0x30, 0x4, 0xaf, 0x45, 0x45, 0x1e, 0x6a, 0x8f, 0xb9, 0x64, 0xb3, 0xfa, 0x2c, 0x8a, 0xf0, 0x14, 0x4a, 0x3b, 0x22, 0xca, 0x3b, 0xd, 0x5f, 0x38, 0x24, 0x17, 0x13, 0x9d, 0xd8, 0xb1, 0xe6, 0x24, 0x69, 0xac, 0xeb, 0x17, 0x81, 0xac, 0xb4, 0x98, 0x6d, 0x97, 0x25, 0xbd, 0xcb, 0x8b, 0xd8, 0x21, 0xa2, 0xc4, 0x49, 0xa, 0x6e, 0x75, 0xfa, 0x4e, 0x5, 0x40, 0x53, 0x3c, 0x39, 0xa9, 0xdc, 0xc8, 0x69, 0x7c, 0x16, 0x9d, 0x53, 0x5e, 0xc7, 0x1b, 0xf1, 0xdb, 0x4, 0xa6, 0x44, 0x6c, 0xcc, 0x7, 0xcf, 0x34, 0xea, 0x44, 0xb, 0x4d, 0x45, 0xcd, 0x8d, 0x66, 0x4a, 0x8a, 0x35, 0xaa, 0xe7, 0xa1, 0x6f, 0xf8, 0xac, 0x4d, 0x23, 0x60, 0xd4, 0x0, 0xea, 0x19, 0xe9, 0xf0, 0x0, 0xe6, 0xb, 0x92, 0x22, 0x9c, 0x51, 0xbe, 0xf3, 0x9, 0xf, 0xfe, 0x9c, 0x54, 0x61, 0xfe, 0x79, 0xd3, 0x95, 0xee, 0xcf, 0x4c, 0x11, 0xaa, 0x54, 0x6c, 0xa0, 0xc, 0xda, 0x99, 0xb5, 0xcd, 0x5c, 0xe4, 0xf4, 0x1e, 0xf, 0x0, 0xbe, 0x6c, 0x2a, 0xe3, 0xc4, 0xee, 0xc7, 0xdf, 0x60, 0xd7, 0xe7, 0x60, 0xcd, 0x30, 0x76, 0xec, 0xf5, 0xfa, 0x61, 0xda, 0xc1, 0x63, 0xdf, 0xe1, 0x2, 0xe3, 0x91, 0x7f, 0x69, 0x2b, 0x36, 0xcc, 0x1b, 0xce, 0xe7, 0x9f, 0xf8, 0xfd, 0xcf, 0x8e, 0x18, 0xac, 0x90, 0xd4, 0xab, 0x0, 0x69, 0xca, 0xdc, 0x2e, 0xe6, 0xe4, 0xa9, 0x2e, 0x52, 0x97, 0xe, 0x63, 0x15, 0x2e, 0x77, 0xfb, 0x4a, 0x4, 0x7d, 0x20, 0xe3, 0x35, 0x26, 0xa4, 0xde, 0xf6, 0x3a, 0xb8, 0x12, 0xa1, 0x7f, 0x9, 0x6, 0x5e, 0x60, 0xaa, 0xbb, 0x7a, 0x2b, 0x89, 0x8c, 0xfa, 0x10, 0xa3, 0x5b, 0x7b, 0x7c, 0xa9, 0xfa, 0xb1, 0x58, 0x3f, 0x35, 0x78, 0x94, 0xcc, 0xd8, 0xaa, 0xab, 0x8, 0xc6, 0xd9, 0xf6, 0xfd, 0xf1, 0xb8, 0xee, 0xe4, 0xd9, 0x38, 0x6, 0x8d, 0x35, 0xb3, 0xeb, 0xb, 0x1a, 0xea, 0xc3, 0xd6, 0x76, 0xca, 0x50, 0x34, 0x44, 0x8c, 0x6b, 0x7, 0xdf, 0xc, 0x9e, 0x10, 0x58, 0x90, 0x91, 0x26, 0x93, 0xa8, 0x4c, 0x98, 0x1c, 0x63, 0x6e, 0x7f, 0xc8, 0xd3, 0x1b, 0x19, 0xfc, 0x2d, 0xeb, 0x42, 0x3f, 0x13, 0xe4, 0x22, 0x59, 0x4b, 0xf3, 0x4f, 0x74, 0xdb, 0x5a, 0xb0, 0x80, 0x6f, 0x9f, 0x2e, 0x7c, 0xf, 0x22, 0x4f, 0x37, 0xe6, 0xc4, 0x3c, 0xb1, 0x92, 0x59, 0x3c, 0x85, 0x1a, 0x7c, 0xc1, 0x90, 0x27, 0x41, 0xb5, 0x5b, 0x86, 0x36, 0x5b, 0xeb, 0xbb, 0xf1, 0x18, 0x80, 0x5, 0x10, 0x5f, 0x49, 0x2d, 0x43, 0xe0, 0xa9, 0xa0, 0x7c, 0x7a, 0xf5, 0xc6, 0x5, 0xa3, 0xc0, 0x56, 0x9b, 0xb4, 0x5, 0x26, 0x97, 0x77, 0x5a, 0x99, 0x5, 0xc7, 0xa0, 0x23, 0x3b, 0xcb, 0x96, 0x99, 0xe6, 0xbb, 0x9, 0x82, 0xea, 0x7d, 0xc2, 0x52, 0x40, 0x44, 0x51, 0xce, 0x6d, 0xfd, 0x1a, 0x47, 0xc2, 0x98, 0xc5, 0xab, 0xff, 0xa1, 0x50, 0x41, 0xca, 0x28, 0x15, 0x7f, 0xcb, 0x4f, 0x48, 0x47, 0x72, 0x76, 0x7c, 0x2, 0x5d, 0xc, 0x4a, 0x8e, 0x89, 0xa1, 0xf5, 0x95, 0x17, 0xd7, 0x26, 0x93, 0xa4, 0x5d, 0x13, 0x99, 0x88, 0x16, 0x69, 0x8e, 0xc2, 0x1c, 0x64, 0xe, 0xb8, 0xe9, 0xf7, 0x5d, 0x40, 0x1b, 0x81, 0x18, 0xaa, 0x3a, 0x79, 0xf6, 0x5e, 0x25, 0x92, 0xb5, 0x6, 0x11, 0x11, 0x3c, 0xf4, 0x5, 0x0, 0x2d, 0x61, 0x62, 0x54, 0xa, 0xb, 0xa0, 0x3, 0xd4, 0x9, 0xc1, 0xd5, 0x8e, 0x81, 0xd2, 0xf4, 0xa7, 0x17, 0x57, 0x47, 0xea, 0xec, 0x68, 0xcb, 0x60, 0xa8, 0x54, 0x58, 0xb, 0x7e, 0x99, 0x30, 0x52, 0x4c, 0xda, 0x26, 0xe9, 0xb7, 0x4c, 0x48, 0x8f, 0x98, 0xba, 0x2b, 0xb0, 0x8b, 0x6, 0x11, 0x4b, 0x8d, 0x1f, 0x24, 0xb5, 0x1f, 0x5b, 0x7a, 0xbf, 0x7e, 0x45, 0x61, 0x78, 0xad, 0xa8, 0xc7, 0x7d, 0x9c, 0xa1, 0xa9, 0x32, 0xf8, 0x5d, 0xf4, 0xdb, 0x0, 0xca, 0x44, 0xc4, 0x83},
+               output224: []byte{0xd9, 0xad, 0x6, 0x79, 0x21, 0x61, 0xe7, 0x4b, 0x19, 0x11, 0x70, 0xaa, 0x23, 0x65, 0xa0, 0x44, 0x3e, 0x67, 0xea, 0x9d, 0xff, 0xea, 0xf1, 0x15, 0x3a, 0xba, 0xbf, 0xe5},
+               output256: []byte{0xc4, 0x2c, 0x1, 0x3, 0x3, 0x45, 0x6f, 0xbf, 0x39, 0xc4, 0x3a, 0xa9, 0x96, 0xd4, 0x2a, 0xc8, 0x6b, 0x36, 0x3b, 0xc6, 0x36, 0x5f, 0xdb, 0xd9, 0xea, 0x75, 0x8c, 0xc8, 0x96, 0x1c, 0xd9, 0xde},
+               output384: []byte{0x49, 0xaa, 0xeb, 0x1a, 0x48, 0xa1, 0x89, 0x2f, 0x4d, 0xae, 0x92, 0x8d, 0x6c, 0x40, 0xf0, 0x3e, 0x49, 0x61, 0x4b, 0xcd, 0xfa, 0xa2, 0xd9, 0xbf, 0x2b, 0xe0, 0x73, 0x87, 0x54, 0x3e, 0x66, 0x71, 0x69, 0x40, 0xc5, 0xe, 0x36, 0xc3, 0x46, 0x46, 0xd0, 0xc3, 0x8d, 0x7b, 0x90, 0xc7, 0x4b, 0x1e},
+               output512: []byte{0xbc, 0xb9, 0xe2, 0x7b, 0x76, 0xf, 0xd6, 0xe3, 0x15, 0x1f, 0xef, 0x53, 0xae, 0xd0, 0xa9, 0xcb, 0x8e, 0x43, 0xc0, 0x8a, 0x4b, 0xd5, 0x4f, 0xc5, 0x70, 0x34, 0x0, 0x64, 0x7e, 0x5, 0xc0, 0x6, 0x1, 0xd, 0xdd, 0xa0, 0xac, 0x7a, 0xf9, 0x64, 0xaf, 0x45, 0x22, 0x41, 0x4e, 0x13, 0xcb, 0x4c, 0x26, 0xcb, 0xa7, 0x1c, 0x13, 0xf3, 0x34, 0x61, 0x31, 0xc9, 0x35, 0x27, 0xc4, 0x2, 0xa0, 0x97}},
+       testcase{
+               msg:       []byte{0xa8, 0xb7, 0x48, 0xdd, 0x69, 0x59, 0xfa, 0x87, 0x70, 0xad, 0x66, 0x73, 0xb8, 0xe7, 0xe, 0x35, 0x74, 0x8d, 0xfd, 0xc, 0x3b, 0xde, 0xda, 0xaa, 0x46, 0x7c, 0xe4, 0xe5, 0x2, 0xeb, 0x86, 0x6d, 0x73, 0x26, 0x83, 0xcb, 0x64, 0xe7, 0x8c, 0x52, 0x32, 0x8, 0xcb, 0x67, 0xdd, 0x9a, 0x6f, 0x3d, 0x32, 0x47, 0xf5, 0xb4, 0x13, 0xb1, 0x2, 0x5a, 0x33, 0xb2, 0x8c, 0x63, 0xb4, 0x28, 0x2, 0xcf, 0x6d, 0x74, 0x26, 0xdb, 0x5c, 0x7a, 0x26, 0x5f, 0xd8, 0x20, 0x61, 0xa, 0x14, 0x45, 0x3c, 0x28, 0x0, 0xb1, 0xf5, 0xd7, 0x76, 0x71, 0xb1, 0x5b, 0xc7, 0x92, 0xc0, 0xb0, 0xdd, 0x64, 0xaa, 0xd3, 0x53, 0x27, 0x21, 0xfd, 0xa0, 0xad, 0x87, 0xad, 0x7a, 0x57, 0xd1, 0x99, 0xdc, 0xf5, 0xb2, 0xff, 0xc, 0xc8, 0x4a, 0x7f, 0x74, 0x4e, 0xa7, 0x36, 0x9e, 0x6f, 0x4d, 0x8f, 0xf, 0x77, 0xda, 0xaa, 0x7d, 0xa0, 0xa8, 0x25, 0x5e, 0x32, 0xc4, 0x73, 0xd9, 0x81, 0xfd, 0xd4, 0xe9, 0xc8, 0x55, 0x28, 0x2b, 0xa0, 0xd5, 0x88, 0x97, 0xef, 0x23, 0x29, 0x65, 0x5d, 0xfa, 0xf8, 0x75, 0x37, 0xcf, 0xfc, 0x25, 0xa2, 0x2a, 0xa0, 0x87, 0x4e, 0xe8, 0xb5, 0x4a, 0x37, 0x3, 0x90, 0x60, 0x1a, 0x54, 0x92, 0xe7, 0x63, 0x4f, 0xef, 0x8e, 0x24, 0xab, 0xe3, 0x20, 0x35, 0x50, 0xee, 0x87, 0x88, 0x92, 0x6f, 0x1b, 0xcb, 0x8b, 0xd, 0xf7, 0xa, 0x6, 0x30, 0x35, 0x7d, 0x99, 0x1b, 0xb8, 0xf4, 0x5d, 0xf6, 0xa0, 0x3a, 0x17, 0xc0, 0x0, 0xe9, 0x78, 0x40, 0xfe, 0xce, 0xad, 0xf9, 0x45, 0x16, 0x5c, 0xac, 0x49, 0x41, 0xcf, 0x36, 0x3d, 0xb4, 0x98, 0x91, 0xc8, 0x6a, 0x54, 0xfa, 0x81, 0xb4, 0x86, 0xa5, 0x63, 0x49, 0x2a, 0xa0, 0x1f, 0x76, 0x9a, 0x1, 0xbb, 0xfc, 0x7e, 0x86, 0x97, 0xb1, 0x2b, 0x28, 0xcd, 0x1f, 0xcf, 0x60, 0x8b, 0xd, 0xa5, 0xec, 0x7f, 0x5b, 0x65, 0x36, 0x93, 0x64, 0xcb, 0x75, 0x2c, 0x83, 0xd6, 0x89, 0x1b, 0x7d, 0x87, 0xd, 0x52, 0xb3, 0xb6, 0x5c, 0x36, 0x96, 0x4, 0x34, 0x74, 0xf9, 0x1a, 0x3, 0x45, 0xcc, 0xb7, 0xaf, 0x34, 0xcd, 0x5b, 0x30, 0x8b, 0x1d, 0xbf, 0x23, 0x32, 0x9, 0x9f, 0x67, 0x1a, 0x8c, 0xf4, 0xd8, 0x9, 0xe4, 0x60, 0x56, 0x28, 0xb1, 0xb, 0x27, 0x5f, 0xc5, 0xba, 0xd4, 0xca, 0xf2, 0x99, 0xbb, 0x58, 0x1, 0x12, 0x4b, 0xc8, 0x63, 0x59, 0xac, 0x83, 0xb3, 0x3b, 0xd8, 0x4d, 0xcf, 0x6d, 0x6d, 0xb4, 0x19, 0x17, 0xa9, 0xa2, 0x17, 0xcc, 0x68, 0x2a, 0xec, 0x18, 0x59, 0xa4, 0x27, 0xa3, 0x2b, 0xc1, 0xb1, 0x1f, 0xfe, 0xef, 0x82, 0x5d, 0xf4, 0x51, 0xc7, 0xcd, 0xc0, 0x33, 0xe9, 0x14, 0x87, 0x79, 0xf7, 0x53, 0xcb, 0x4c, 0x5, 0x67, 0x4e, 0xde, 0x8e, 0xdc, 0xea, 0xc8, 0xc, 0xd2, 0x3d, 0xf3, 0x72, 0x46, 0x4f, 0x3, 0x90, 0x0, 0xfa, 0x3a, 0xa4, 0x7d, 0x5a, 0x99, 0xe1, 0x48, 0x94, 0xca, 0xa2, 0xff, 0x5b, 0x90, 0x5, 0x7d, 0x3f, 0x41, 0x1b, 0x14, 0x59, 0x16, 0x8a, 0x85, 0xc2, 0x84, 0xd5, 0xc2, 0x81, 0x48, 0x11, 0xba, 0xa7, 0x70, 0xe, 0x5e, 0xd9, 0x6e, 0x45, 0x17, 0x46, 0x4f, 0xf1, 0x75, 0x78, 0x11, 0xbf, 0x36, 0x91, 0xce, 0x33, 0xd0, 0x24, 0x45, 0x98, 0xb, 0xcc, 0x40, 0xe2, 0x4e, 0x1f, 0x9d, 0xc6, 0xf9, 0xdf, 0x45, 0x34, 0x2c, 0xa4, 0xe1, 0x4e, 0x1, 0x3c, 0x1f, 0xa0, 0x66, 0x76, 0xd5, 0x82, 0x55, 0x5e, 0xd5, 0x5d, 0x6, 0x9f, 0xd2, 0xdb, 0x26, 0x7c, 0x92, 0xdb, 0x57, 0x7a, 0x55, 0x6e, 0x61, 0x3, 0xe6, 0x9d, 0x1d, 0x73, 0x33, 0x51, 0x83, 0xe2, 0x6e, 0xd8, 0x8a, 0x5e, 0xfd, 0x87, 0xeb, 0xdd, 0xca, 0xa5, 0x92, 0x7b, 0x97, 0xf0, 0x94, 0x20, 0x9d, 0xbc, 0x7f, 0xb3, 0x37, 0xdc, 0xf, 0x7c, 0x98, 0xa9, 0x75, 0xa7, 0x41, 0x69, 0x60, 0xf, 0x3f, 0x1a, 0x1c, 0x74, 0x33, 0xec, 0xfc, 0x74, 0xb3, 0x19, 0xba, 0x3d, 0xd8, 0xef, 0x69, 0xfd, 0x1c, 0xc6, 0xce, 0x83, 0xd1, 0xb4, 0xa0, 0x12, 0x49, 0x69, 0xf6, 0xcd, 0x24, 0xb7, 0xe3, 0xd3, 0x41, 0x8a, 0x80, 0xc7, 0x35, 0xb4, 0xf7, 0xad, 0xd0, 0x91, 0x88, 0x26, 0x73, 0xf0, 0x1f, 0xf2, 0xe, 0x38, 0x46, 0x1a, 0x2b, 0x38, 0x9d, 0xca, 0x81, 0xe5, 0xe6, 0xca, 0x22, 0x13, 0xaf, 0x19, 0x48, 0x95, 0x13, 0x9c, 0xdb, 0x2, 0x13, 0xc, 0x1f, 0xe0, 0x43, 0xe5, 0x87, 0x83, 0xc1, 0x30, 0xc3, 0x6b, 0xb8, 0x8a, 0x9a, 0xf6, 0x56, 0xe4, 0x6, 0xdc, 0xa1, 0x14, 0xe9, 0x6f, 0x2f, 0xc9, 0xf0, 0xe, 0xaa, 0xf5, 0xca, 0x99, 0x11, 0x70, 0x8a, 0x4a, 0x2e, 0x6c, 0xfe, 0xda, 0x25, 0x3, 0xc4, 0x9b, 0x64, 0x4d, 0xd2, 0x56, 0x26, 0x37, 0x13, 0x4c, 0xfa, 0x33, 0xc5, 0xc, 0x62, 0x19, 0x9e, 0x99, 0xa8, 0xa2, 0xec, 0xcc, 0xfc, 0xc3, 0xc6, 0xa1, 0xfa, 0x62, 0xbc, 0x1a, 0xd9, 0x70, 0x1b, 0x7c, 0x9c, 0xe1, 0x48, 0x24, 0x45, 0x10, 0x59, 0x41, 0x4e, 0xd5, 0x2a, 0xd3, 0x6a, 0x69, 0xb3, 0xe0, 0xa4, 0xfb, 0x54, 0x3f, 0x40, 0x9, 0x9c, 0x43, 0x7e, 0x89, 0xfb, 0x12, 0xf6, 0xae, 0xd8, 0x16, 0xc9, 0xaf, 0x77, 0x78, 0xd9, 0x1a, 0xdc, 0x62, 0x18, 0xa1, 0x13, 0xad, 0x9c, 0x9c, 0xc, 0xaa, 0x4e, 0x60, 0x28, 0x6, 0xc4, 0x33, 0x9e, 0xb4, 0x56, 0xda, 0x4c, 0x9, 0x21, 0x80, 0xfc, 0x8a, 0x91, 0xfb, 0x9f, 0xe3, 0x5, 0xc9, 0x5c, 0xc4, 0xae, 0x5c, 0xcb, 0x6, 0xdd, 0xc6, 0x4f, 0x41, 0x27, 0x90, 0x6b, 0xe2, 0x8f, 0x70, 0x14, 0xa9, 0xee, 0x2e, 0xf9, 0xf9, 0xf0, 0x75, 0x98, 0x2f, 0x72, 0x73, 0xb1, 0x46, 0x9d, 0xf1, 0x4b, 0xb9, 0x2c, 0xf2, 0x9b, 0xbd, 0xb4, 0x87, 0xb8, 0xdd, 0xf3, 0x7f, 0x5e, 0x10, 0xda, 0x60, 0xc7, 0x2, 0x93, 0x44, 0x8b, 0x7e, 0x8c, 0x5d, 0x92, 0x14, 0x8f, 0xb4, 0x66, 0xa2, 0x8a, 0x16, 0xf2, 0xea, 0x8a, 0x3f, 0xb1, 0x2c, 0x8e, 0x86, 0x78, 0xbf, 0x4d, 0x13, 0x9a, 0xa2, 0xdb, 0x2f, 0x17, 0x11, 0x22, 0xe5, 0x97, 0x5, 0xea, 0x34, 0x9, 0xfd, 0xb3, 0x24, 0xfc, 0xaf, 0x27, 0x90, 0x9a, 0x66, 0xed, 0x1c, 0xde, 0x7b, 0x92, 0xb9, 0x49, 0xe9, 0x7, 0x3a, 0xde, 0x44, 0x8, 0xe9, 0xd5, 0x53, 0x7d, 0x3b, 0x14, 0x36, 0x85, 0x3a, 0x2, 0x94, 0xb7, 0x75, 0x64, 0xb7, 0xb, 0x1e, 0x43, 0xab, 0x13, 0x32, 0x7d, 0x61, 0x7e, 0x86, 0x97, 0x1d, 0x0, 0x9c, 0x7d, 0xc1, 0xbe, 0x3, 0x37, 0xb1, 0x85, 0x70, 0x1a, 0x5, 0x21, 0xda, 0xf4, 0x94, 0xb, 0xf5, 0xa1, 0x51, 0xc6, 0xd2, 0xef, 0xd0, 0x77, 0xa3, 0x4, 0x8e, 0xb7, 0xb3, 0x7a, 0xce, 0xa0, 0x84, 0xe3, 0xa3, 0xac, 0xeb, 0x4f, 0x2f, 0x44, 0xe4, 0xb4, 0x2e, 0x91, 0x12, 0xfe, 0x67, 0x27, 0xf5, 0xb6, 0x5a, 0xfd, 0xf2, 0x82, 0x52, 0xf3, 0x41, 0xda, 0xbc, 0x9f, 0xc8, 0xc8, 0xd5, 0xdd, 0x2f, 0xa6, 0xf2, 0x63, 0xf9, 0x5c, 0x0, 0x66, 0x58, 0x54, 0x21, 0x7e, 0x91, 0x5d, 0x84, 0x2c, 0xcb, 0x2f, 0x33, 0x31, 0x1, 0x24, 0xe5, 0xb5, 0x79, 0x2b, 0xf0, 0x86, 0x3e, 0x2c, 0x10, 0x84, 0xdf, 0xa5, 0x11, 0x38, 0x7a, 0xeb, 0x1a, 0xc4, 0x4, 0xd3, 0x2a, 0xdb, 0x5c, 0x3, 0x6, 0xef, 0xec, 0x84, 0x68, 0x8a, 0x95, 0x6c, 0x70, 0x41, 0xc7, 0x24, 0xe8, 0x74, 0x1e, 0xf4, 0x9d, 0xe2, 0x77, 0x2f, 0xc3, 0xe1, 0x74, 0xe0, 0x2f, 0x81, 0xb7, 0xd9, 0x70, 0xe5, 0x1, 0x29, 0x13, 0xdc, 0xcd, 0x2c, 0xb0, 0x92, 0x5c, 0xe5, 0x1d, 0x72, 0x5e, 0x89, 0x0, 0xba, 0x58, 0x9a, 0x97, 0xf, 0x19, 0xb5, 0x58, 0xcd, 0xc5, 0x7b, 0x30, 0xa7, 0xdb, 0x60, 0xfe, 0xc9, 0x1a, 0xd0, 0x0, 0x5b, 0xd, 0xef, 0xc0, 0x5d, 0xfa, 0xaa, 0x26, 0x13, 0x9, 0x5f, 0x53, 0xa4, 0x78, 0x45, 0x9b, 0x4e, 0x89, 0x17, 0xf, 0xcb, 0xb5, 0x7f, 0x60, 0xb2, 0x80, 0x1e, 0xf8, 0x7f, 0x6, 0x65, 0x23, 0x5c, 0x0, 0x4b, 0x8f, 0x61, 0xa1, 0x66, 0xdd, 0x58, 0x85, 0xda, 0x1b, 0x4, 0x76, 0x8c, 0x8, 0xf9, 0xee, 0xde, 0xab, 0x78, 0xa1, 0xd7, 0xbb, 0x49, 0x29, 0x4f, 0xfc, 0xd1, 0x34, 0x52, 0x20, 0x76, 0xc3, 0xe0, 0xb0, 0xa2, 0xa8, 0xfb, 0xca, 0xe3, 0xd0, 0x1, 0xf4, 0xe1, 0xdf, 0xd, 0xe1, 0x66, 0x9e, 0x53, 0x3f, 0x4c, 0x9d, 0x95, 0xcc, 0x2a, 0xe0, 0xc4, 0x2b, 0x67, 0xa6, 0x28, 0xd0, 0x87, 0x1b, 0x83, 0xcc, 0x59, 0x9a, 0x8a, 0xc4, 0x82, 0x8f, 0xda, 0x49, 0xec, 0x2f, 0x9c, 0x5, 0x7c, 0xc9, 0x95, 0xe7, 0x9e, 0xe5, 0xfc, 0x51, 0x90, 0x5b, 0xbe, 0xdc, 0x75, 0x6a, 0x74, 0x86, 0xe7, 0x95, 0x37, 0xb5, 0x59, 0xb4, 0x9e, 0xa5, 0x7e, 0x87, 0x40, 0x6c, 0x20, 0xef, 0x94, 0xfa, 0x73, 0x2, 0x5f, 0xe1, 0x6a, 0xb5, 0x88, 0x59, 0x1d, 0x8e, 0x89, 0xc7, 0x9c, 0x3f, 0x91, 0x4f, 0x97, 0xab, 0x15, 0x42, 0xdc, 0x6f, 0x86, 0x43, 0x5f, 0x13, 0x24, 0x5, 0xff, 0x49, 0x46, 0x3f, 0x6b, 0x83, 0x6f, 0x83, 0x51, 0xbe, 0x8c, 0x1e, 0x21, 0xdd, 0x14, 0xb6, 0x19, 0xb5, 0x19, 0x3b, 0xcd, 0x4, 0x47, 0xe, 0xdc, 0x4b, 0x86, 0x31, 0x74, 0xe4, 0xf1, 0xb2, 0xe, 0xda, 0x5c, 0x3d, 0xe3, 0x25, 0x32, 0x41, 0xd6, 0x1c, 0xc1, 0x7f, 0x4f, 0xe1, 0xdd, 0x6a, 0xb0, 0xa7, 0xcd, 0x10, 0x22, 0x58, 0xf6, 0x36, 0x64, 0x2, 0xb4, 0x4d, 0xa9, 0xd7, 0xc4, 0x15, 0xab, 0xea, 0x13, 0x41, 0x1a, 0x89, 0xe7, 0x79, 0x6, 0xde, 0xd4, 0x30, 0x75, 0x13, 0x57, 0x87, 0x82, 0x6, 0x92, 0xa3, 0x78, 0x5d, 0x9, 0x94, 0x8c, 0x5e, 0x6, 0x35, 0x51, 0xf5, 0x1a, 0xb, 0x8f, 0xe7, 0xba, 0x9a, 0x7, 0xa, 0x6e, 0x6, 0x48, 0xb0, 0x7c, 0x9c, 0xb9, 0x9b, 0xea, 0x75, 0x93, 0x39, 0x36, 0x92, 0xea, 0x6a, 0x36, 0x5d, 0xb, 0x25, 0x76, 0xaa, 0x3, 0xb, 0xb4, 0xcd, 0x28, 0x8c, 0x42, 0x50, 0xc, 0x42, 0x97, 0xcb, 0x7, 0x3b, 0xf, 0x73, 0x70, 0xdf, 0xb7, 0xaa, 0xdb, 0xd8, 0x56, 0x9e, 0x51, 0xed, 0x6a, 0x9e, 0x74, 0xab, 0x58, 0xe6, 0x47, 0x87, 0x9f, 0x7a, 0x53, 0x7d, 0xd1, 0xb3, 0xe4, 0x81, 0x6a, 0xe9, 0xf, 0x63, 0x32, 0xa2, 0x19, 0x43, 0x9a, 0xba, 0x6c, 0x9d, 0x77, 0x22, 0xa3, 0xc, 0x93, 0x2a, 0x25, 0x42, 0xf2, 0x57, 0x11, 0x14, 0x50, 0xfc, 0x27, 0x9, 0x71, 0xd2, 0xe6, 0xc1, 0xb9, 0xeb, 0xb3, 0x4b, 0x78, 0x6d, 0x21, 0x5a, 0x1, 0xe8, 0x9d, 0x53, 0x65, 0x58, 0xd9, 0x4, 0x42, 0x2d, 0x8e, 0x5a, 0x5b, 0x3e, 0x2b, 0x2c, 0x54, 0xda, 0x19, 0x1b, 0x94, 0x7c, 0x48, 0xee, 0xe, 0xd2, 0x96, 0x35, 0x5b, 0xe5, 0x2e, 0xd1, 0x92, 0xda, 0x91, 0xc, 0xd4, 0x7d, 0x8b, 0x4f, 0xe7, 0xa2, 0x9a, 0x23, 0xba, 0x2f, 0xa2, 0x3b, 0x8c, 0x6c, 0xbf, 0x4c, 0xa5, 0x72, 0xb9, 0xa7, 0x2e, 0xa9, 0x68, 0x8c, 0xa0, 0xdf, 0xb2, 0xf7, 0x4a, 0xe6, 0xd7, 0x8c, 0x2d, 0x96, 0x74, 0x8e, 0x58, 0x7d, 0x2d, 0x1f, 0x5d, 0x3c, 0x99, 0xab, 0xd, 0x98, 0xdf, 0x94, 0x94, 0x56, 0xe0, 0x67, 0xaa, 0x2, 0xb3, 0xb4, 0x3d, 0x29, 0x16, 0xf0, 0x51, 0xd6, 0x36, 0xf2, 0x8f, 0xcf, 0x97, 0x19, 0x50, 0xe9, 0xd9, 0xc1, 0xc0, 0xc9, 0x4b, 0x89, 0x4e, 0xee, 0x76, 0xe9, 0xae, 0x94, 0x22, 0x83, 0xb5, 0x16, 0xc0, 0xe4, 0xa1, 0x5, 0x27, 0xd0, 0xf1, 0x20, 0xe1, 0x5c, 0xae, 0xdd, 0x19, 0x54, 0x6a, 0xcb, 0xf1, 0xab, 0x85, 0xca, 0xba, 0x76, 0x4c, 0x74, 0xde, 0xc2, 0xad, 0x19, 0x5, 0x70, 0xd7, 0xd4, 0x4b, 0x5d, 0xd6, 0x37, 0x97, 0x4e, 0x8b, 0xa2, 0x6b, 0x60, 0xf0, 0xa4, 0x8, 0xb7, 0xc5, 0x6d, 0xb7, 0x33, 0x95, 0xc1, 0xf1, 0xe7, 0x60, 0x60, 0x16, 0xb6, 0x61, 0x11, 0x9c, 0xa4, 0x68, 0x9b, 0x12, 0xaf, 0x8f, 0x60, 0x8a, 0x18, 0x10, 0x70, 0x3c, 0xb4, 0x89, 0xbe, 0xaa, 0x12, 0xcd, 0x72, 0xcf, 0x37, 0xbe, 0x43, 0xff, 0xcf, 0x2f, 0x7f, 0x8c, 0x21, 0xa8, 0x31, 0x1a, 0x52, 0x78, 0x31, 0xbf, 0xe5, 0xb7, 0xcf, 0x5e, 0x98, 0x39, 0xba, 0x13, 0x81, 0x87, 0xba, 0xbd, 0x9a, 0xdc, 0xa8, 0x4c, 0x35, 0xb9, 0xaa, 0xfa, 0xba, 0x6b, 0xcf, 0x7e, 0xd0, 0xd2, 0x2d, 0xa8, 0x7f, 0xb6, 0xeb, 0x81, 0x45, 0x59, 0x1c, 0x9b, 0x36, 0x52, 0xa4, 0xea, 0xc2, 0x56},
+               output224: []byte{0xb1, 0xa2, 0x9c, 0x0, 0xab, 0x23, 0x41, 0xa7, 0x7c, 0xfe, 0xd8, 0x39, 0x8f, 0x23, 0x2b, 0x1f, 0xb5, 0x7b, 0xf4, 0x57, 0x2e, 0xaa, 0xb7, 0x56, 0xd, 0x7d, 0x4c, 0xd6},
+               output256: []byte{0x1b, 0xae, 0x63, 0x99, 0x40, 0xec, 0x63, 0xdc, 0xb6, 0x7f, 0x9e, 0x80, 0x6c, 0x4b, 0x2e, 0xde, 0x67, 0x51, 0xcf, 0x54, 0xe, 0x63, 0xbc, 0xec, 0xa, 0xd8, 0x3d, 0x79, 0x6, 0xa8, 0x91, 0x37},
+               output384: []byte{0x1d, 0x67, 0xe9, 0x94, 0xaf, 0x91, 0x86, 0xa2, 0x1a, 0xbb, 0x67, 0xaa, 0x4c, 0x54, 0x41, 0xfb, 0xd8, 0x6f, 0x7, 0x81, 0x4a, 0xa9, 0xeb, 0x38, 0x50, 0x8f, 0x9, 0x9c, 0x5c, 0xb, 0xbb, 0x41, 0x96, 0xf5, 0x17, 0x3d, 0xe4, 0x8f, 0x19, 0xbb, 0xab, 0x68, 0x42, 0xea, 0x51, 0x96, 0x2d, 0x8c},
+               output512: []byte{0x26, 0xd9, 0x3e, 0x60, 0x41, 0x3e, 0x83, 0x23, 0xbc, 0xf6, 0x71, 0x44, 0xe8, 0x46, 0xe1, 0x97, 0x51, 0x10, 0x3c, 0xd1, 0xec, 0x47, 0x49, 0x93, 0x9, 0x25, 0x17, 0xa6, 0x3f, 0x40, 0x10, 0x1b, 0xea, 0x10, 0xc8, 0xd1, 0x20, 0xfa, 0x7, 0x7a, 0xf7, 0x43, 0xee, 0xc1, 0x6c, 0x38, 0x12, 0x70, 0x88, 0x7d, 0xef, 0xe3, 0xf4, 0x1c, 0xa4, 0xa5, 0x1, 0xd8, 0x38, 0x42, 0x94, 0xbc, 0x53, 0x7f}},
+       testcase{
+               msg:       []byte{0x5b, 0x4d, 0x29, 0x85, 0xe6, 0x1a, 0xa7, 0x14, 0x5b, 0x5e, 0x76, 0x4, 0x35, 0xff, 0xd, 0x8e, 0x12, 0xb5, 0x46, 0xea, 0xd8, 0x25, 0x40, 0xf, 0xa6, 0x67, 0x7b, 0x5e, 0x44, 0x43, 0x55, 0x93, 0xa3, 0x8a, 0xe2, 0xfe, 0x15, 0x2d, 0x8b, 0x55, 0x87, 0x9a, 0x6f, 0xb0, 0x5d, 0x72, 0xda, 0x1d, 0xf4, 0xf5, 0xcc, 0xad, 0x61, 0x71, 0x2b, 0x8e, 0x76, 0xbd, 0x69, 0xa9, 0xd3, 0xef, 0x9, 0xda, 0xb, 0x2f, 0xfe, 0xa, 0x0, 0xfb, 0xcf, 0xfc, 0x83, 0x26, 0x3d, 0x48, 0xe3, 0xa2, 0x63, 0xa9, 0x75, 0x82, 0xd2, 0xd, 0x91, 0x95, 0xb2, 0x38, 0x75, 0x17, 0x6f, 0xfb, 0x45, 0xcb, 0x8a, 0x94, 0x2c, 0x48, 0x60, 0xe3, 0xce, 0x6c, 0x26, 0x43, 0x78, 0x26, 0xdd, 0xce, 0x61, 0xd4, 0xda, 0x4f, 0xda, 0x38, 0x78, 0x18, 0x7d, 0x55, 0x1c, 0x3b, 0xaa, 0xb3, 0x7e, 0xd6, 0x6e, 0xb1, 0xd, 0x71, 0xa1, 0x8e, 0xa6, 0xe4, 0x8b, 0x96, 0xfd, 0xe7, 0xcc, 0x1c, 0xec, 0xb8, 0x21, 0xe7, 0xae, 0x5b, 0xe0, 0x7e, 0x34, 0xc6, 0xf5, 0xc2, 0x6, 0x4, 0x42, 0x45, 0x91, 0xa4, 0xea, 0xc3, 0x72, 0x8d, 0xdc, 0x78, 0x6e, 0x23, 0xb0, 0x70, 0x6, 0x44, 0x1b, 0xaa, 0x56, 0xe1, 0x74, 0xab, 0x4c, 0x5c, 0xb4, 0x17, 0x0, 0x8a, 0x3d, 0x66, 0x56, 0xab, 0xd0, 0x7b, 0xb7, 0x17, 0x87, 0xcc, 0x39, 0xf, 0x4e, 0x90, 0x4, 0x47, 0x6d, 0xd, 0xd9, 0xe9, 0xcb, 0x33, 0xda, 0xc6, 0x8a, 0x1c, 0x6c, 0xc, 0xe4, 0x55, 0x14, 0xdb, 0x44, 0x61, 0xf7, 0x99, 0x27, 0x14, 0xb9, 0xdd, 0x28, 0x19, 0x48, 0x56, 0x81, 0x3c, 0x9f, 0x24, 0xc1, 0xdc, 0x4a, 0xcf, 0xfd, 0x0, 0x65, 0xb9, 0xd5, 0xc, 0x26, 0x62, 0xb4, 0x16, 0x33, 0x47, 0x2b, 0x25, 0xc3, 0x58, 0xda, 0xb5, 0x3f, 0x85, 0x19, 0x8d, 0x76, 0xc9, 0x3a, 0xa2, 0xc, 0x74, 0x83, 0xa1, 0xdb, 0x21, 0xc3, 0x73, 0x62, 0x75, 0x38, 0xdb, 0x87, 0x3, 0x5e, 0xed, 0xe, 0x78, 0xba, 0xf5, 0x20, 0x5a, 0x2b, 0xe0, 0xca, 0xb9, 0x25, 0xa0, 0xfb, 0xcf, 0x14, 0x15, 0x43, 0xb0, 0x4f, 0xac, 0x7a, 0xaa, 0xef, 0xc3, 0xa5, 0x3f, 0x64, 0xab, 0x3a, 0x71, 0x0, 0x46, 0x84, 0xa3, 0x50, 0x75, 0x35, 0xd2, 0x53, 0xd, 0x8f, 0xeb, 0xb4, 0xe7, 0x90, 0x9a, 0x37, 0x37, 0xf9, 0xa4, 0x96, 0x47, 0x16, 0x10, 0x8b, 0x19, 0xc4, 0x91, 0x8, 0x9a, 0x1, 0x24, 0x9e, 0x45, 0x71, 0x74, 0x2f, 0xf8, 0x58, 0x72, 0xe9, 0xfc, 0x8e, 0x8e, 0x75, 0x69, 0xac, 0x15, 0x65, 0x5b, 0xa0, 0x84, 0xef, 0x6a, 0xbc, 0x58, 0x2f, 0x6e, 0x91, 0xfe, 0x23, 0x9, 0xd5, 0xe4, 0xe3, 0xfa, 0xdc, 0x55, 0x4d, 0xcd, 0x87, 0xe1, 0x18, 0x26, 0x2d, 0xc4, 0x8, 0x39, 0x8a, 0xf5, 0xdd, 0xad, 0xae, 0xf2, 0xca, 0xfa, 0x99, 0xf6, 0xe0, 0x33, 0xb3, 0xa4, 0x22, 0x52, 0x1f, 0x43, 0xdf, 0x2d, 0x72, 0x6, 0x93, 0x12, 0x4d, 0x6d, 0xa2, 0xba, 0xf5, 0xfe, 0x2b, 0x37, 0xe7, 0x75, 0xae, 0x3a, 0xdc, 0x46, 0x10, 0x80, 0x7c, 0xe, 0x9b, 0x43, 0xab, 0xf8, 0xfa, 0x71, 0xab, 0x97, 0x7c, 0xf9, 0xd3, 0xed, 0xb0, 0x7c, 0x56, 0x44, 0xf8, 0x55, 0x6d, 0x84, 0x9b, 0x2c, 0x40, 0xf5, 0x23, 0xea, 0xe9, 0x27, 0xbc, 0xcc, 0xcf, 0x9f, 0xd7, 0xb7, 0x68, 0x92, 0xba, 0x4f, 0xce, 0x9d, 0xe7, 0x1f, 0x71, 0xfa, 0x70, 0x6, 0xe7, 0x74, 0xf7, 0xee, 0xfc, 0x20, 0x1a, 0x5b, 0xbc, 0x69, 0x40, 0x8, 0xf8, 0x7, 0x6e, 0xde, 0x5b, 0x85, 0xea, 0x3f, 0xff, 0x18, 0x67, 0xc8, 0xe2, 0x15, 0xe1, 0x92, 0xea, 0xa9, 0xcc, 0x88, 0x83, 0xca, 0xad, 0xd6, 0x8b, 0xe5, 0x7d, 0xfa, 0xc9, 0x89, 0xb2, 0x5d, 0x92, 0xab, 0x8d, 0x53, 0x70, 0x94, 0x90, 0xc6, 0x76, 0x6a, 0xe8, 0xc2, 0x17, 0x20, 0xe6, 0xa1, 0x5, 0x88, 0x8c, 0x23, 0x16, 0xbb, 0x30, 0x1d, 0x39, 0x2e, 0x8e, 0xca, 0x46, 0x4c, 0x86, 0x94, 0x30, 0x4, 0x55, 0x57, 0x1f, 0xda, 0xb6, 0xce, 0x25, 0xbf, 0xe3, 0xef, 0xcd, 0xf0, 0x8c, 0x7c, 0xef, 0x99, 0x86, 0x9, 0x26, 0xaa, 0x8c, 0xfc, 0xe6, 0x80, 0x3d, 0xf0, 0xa7, 0xd0, 0xee, 0xa8, 0x83, 0xc2, 0xa5, 0x48, 0x62, 0xe0, 0xb4, 0x1, 0x35, 0xc3, 0xb3, 0xfb, 0x9d, 0xe, 0xb2, 0x18, 0xe5, 0xe1, 0x95, 0x7e, 0x45, 0xfa, 0x64, 0xe2, 0xf7, 0xf8, 0xf2, 0xe2, 0x94, 0xed, 0xf6, 0x9f, 0x26, 0xa8, 0xd6, 0x53, 0x72, 0xa2, 0xcd, 0xbd, 0x79, 0x2b, 0x75, 0x14, 0xef, 0xfe, 0xe4, 0xa3, 0x8f, 0xf2, 0xa7, 0x87, 0x74, 0xff, 0x84, 0x70, 0xff, 0x3a, 0xf1, 0xa1, 0xb2, 0x1d, 0x5, 0x4b, 0x97, 0x8a, 0x3f, 0x8e, 0x16, 0xd5, 0xd7, 0x61, 0x99, 0xdd, 0xde, 0xa8, 0x7f, 0xda, 0x4c, 0x29, 0xb, 0x67, 0x89, 0x6, 0x73, 0x62, 0xfa, 0x6e, 0x6c, 0x37, 0xce, 0x66, 0x60, 0xed, 0x90, 0x5e, 0xbd, 0x31, 0x61, 0xb9, 0xd0, 0x5f, 0xce, 0xc8, 0xe1, 0x32, 0x95, 0x68, 0x85, 0x51, 0x8e, 0xba, 0xbf, 0x85, 0x25, 0xbb, 0x3c, 0x35, 0x63, 0x1, 0x4, 0x81, 0x51, 0xbf, 0x6d, 0xaa, 0x28, 0xef, 0x6f, 0x12, 0x5f, 0x16, 0x5a, 0x79, 0xb8, 0xee, 0x31, 0x4a, 0x7f, 0xe2, 0xf, 0x25, 0xa7, 0xe2, 0xac, 0x8c, 0xa3, 0x65, 0x50, 0x96, 0xb1, 0xe7, 0x7c, 0x10, 0x5, 0x58, 0x2d, 0x82, 0xf2, 0x8f, 0xfa, 0x10, 0x8b, 0x38, 0xd1, 0xc2, 0x51, 0xc, 0x40, 0xf0, 0x6a, 0x5f, 0x90, 0x19, 0x5b, 0x8b, 0x23, 0x67, 0x31, 0x35, 0x23, 0x98, 0x1f, 0x2c, 0x7a, 0xf6, 0x3f, 0x53, 0x6d, 0xd3, 0xdc, 0x19, 0x1a, 0x5f, 0xb0, 0x98, 0x4a, 0x7a, 0xd0, 0xcf, 0x99, 0x4d, 0xbf, 0xb8, 0xa5, 0xc8, 0x99, 0x1d, 0xca, 0x74, 0xbc, 0x18, 0x48, 0xc6, 0xcb, 0xca, 0xe6, 0xea, 0xad, 0xe0, 0xab, 0xc4, 0xa4, 0x5e, 0xf0, 0x35, 0x75, 0xe8, 0x2a, 0x2c, 0x3e, 0xb, 0xf5, 0xef, 0xc1, 0x9f, 0xc9, 0xf2, 0xeb, 0x36, 0xc0, 0x7e, 0x42, 0x69, 0x30, 0x4, 0x39, 0x74, 0x59, 0xd5, 0x55, 0xf0, 0xd6, 0xf2, 0x67, 0x50, 0x4e, 0xb3, 0x5a, 0xb7, 0x98, 0x85, 0x63, 0x0, 0xd9, 0x60, 0x25, 0xa1, 0xa0, 0x17, 0x43, 0x3c, 0xbf, 0x49, 0x2f, 0x7f, 0x30, 0x28, 0x38, 0x1c, 0xfd, 0x13, 0x75, 0xc3, 0xd2, 0xc5, 0xb7, 0x1c, 0xe2, 0x85, 0xfb, 0xd1, 0xcb, 0x22, 0x98, 0x7f, 0x5a, 0x21, 0x46, 0x4, 0x3d, 0x2c, 0x1f, 0x26, 0xe6, 0xe9, 0x37, 0x84, 0x99, 0x35, 0xb6, 0xd6, 0xcd, 0x89, 0x60, 0x18, 0x94, 0xaf, 0x6a, 0xa, 0x7c, 0x94, 0xfc, 0xc1, 0x0, 0xe8, 0xf1, 0x67, 0xa7, 0x54, 0x7d, 0x7c, 0x72, 0xa3, 0xb4, 0x25, 0xfd, 0xc0, 0xea, 0xff, 0x68, 0xcd, 0x36, 0x74, 0xf9, 0xc0, 0x7b, 0x45, 0x39, 0xbe, 0xe7, 0xe8, 0x85, 0x74, 0x90, 0x8, 0xcf, 0x53, 0x8d, 0xfc, 0x36, 0x57, 0xf3, 0x70, 0x8d, 0x77, 0x8a, 0x8f, 0x39, 0xe5, 0xd7, 0xb1, 0x3a, 0xd8, 0xec, 0xf8, 0x4d, 0xd4, 0xc0, 0xac, 0xb6, 0x5a, 0x41, 0x34, 0xc7, 0x1d, 0xd5, 0x90, 0xaa, 0xd9, 0x7d, 0x6e, 0xef, 0xd0, 0x15, 0xfd, 0xe1, 0xeb, 0x53, 0x15, 0x3, 0x8b, 0x48, 0x36, 0x28, 0xcc, 0xae, 0xbd, 0x9, 0x5b, 0x1b, 0x42, 0x3, 0xb6, 0x60, 0x95, 0x73, 0x1e, 0x62, 0x92, 0xbd, 0x80, 0x6c, 0x6d, 0xde, 0x41, 0x7c, 0xe9, 0xb5, 0x64, 0xe2, 0xa7, 0xc9, 0xf6, 0x98, 0x93, 0xf0, 0xb0, 0x1f, 0xa8, 0xaa, 0xf3, 0x71, 0x22, 0x58, 0xa3, 0xbb, 0x7, 0xc, 0xc5, 0x2, 0x6, 0x3b, 0x9, 0xc3, 0x3, 0xee, 0xa0, 0xa6, 0x46, 0xa2, 0x4, 0xe1, 0xec, 0xb, 0x31, 0xab, 0xd6, 0xed, 0x56, 0xf4, 0xfe, 0x3c, 0xd7, 0xf2, 0x69, 0x4e, 0xba, 0x27, 0xca, 0xa4, 0xf5, 0x81, 0xf3, 0x12, 0x54, 0xc4, 0x20, 0xb9, 0xa5, 0x1b, 0x43, 0x39, 0xfd, 0xc8, 0x13, 0xa4, 0x46, 0xd2, 0x9c, 0x61, 0xcf, 0x81, 0x74, 0x67, 0xf4, 0xf, 0x6f, 0x55, 0xeb, 0x7, 0xc0, 0xc7, 0xa8, 0x61, 0x82, 0xa1, 0x47, 0x2b, 0xb, 0xdb, 0x9b, 0xeb, 0x87, 0x4b, 0x25, 0x72, 0xa2, 0xa1, 0xea, 0x65, 0x24, 0x2a, 0xc5, 0xee, 0x41, 0x2, 0x5d, 0xbf, 0xd, 0x4b, 0xc3, 0x38, 0xf0, 0x91, 0x46, 0xce, 0x59, 0xed, 0x65, 0x6f, 0x93, 0xc8, 0xd8, 0x7b, 0xe9, 0xf0, 0xd7, 0x39, 0x9, 0x29, 0x1a, 0xd1, 0x33, 0x61, 0x3, 0xe0, 0x5f, 0xde, 0x9e, 0x9b, 0xcc, 0x77, 0xed, 0x75, 0x22, 0xa, 0x2b, 0x63, 0x39, 0xff, 0x6c, 0xd8, 0xa3, 0x88, 0x15, 0x3f, 0x55, 0xc9, 0xca, 0x3, 0xbe, 0x9d, 0xb5, 0xda, 0x24, 0x2b, 0x9e, 0x9f, 0x29, 0x9e, 0x23, 0x21, 0x7b, 0xc9, 0x37, 0xad, 0xc6, 0xfb, 0xba, 0x90, 0x98, 0xa, 0x29, 0xb6, 0x19, 0x98, 0x83, 0x60, 0x30, 0x1f, 0x7d, 0x8d, 0xdc, 0xf7, 0xb8, 0xfa, 0xd0, 0x65, 0x1f, 0x31, 0x23, 0x1b, 0x81, 0x66, 0x20, 0xa2, 0x95, 0xd1, 0xd6, 0xc6, 0xc9, 0x6, 0x43, 0xe2, 0xf2, 0x59, 0x3a, 0xd, 0xcf, 0xb7, 0x0, 0xc0, 0x17, 0xf0, 0xa8, 0x8e, 0x3, 0xd3, 0xd6, 0x87, 0x1e, 0xbe, 0x42, 0xb, 0x7f, 0x43, 0x5a, 0x58, 0x40, 0x7c, 0x66, 0x7e, 0xa6, 0x84, 0xd5, 0x90, 0x6c, 0x91, 0xd6, 0x99, 0xd0, 0xf3, 0x86, 0x82, 0x94, 0x43, 0x2f, 0xd7, 0xfe, 0xcb, 0xec, 0x52, 0x7d, 0x21, 0x3f, 0xf7, 0xd9, 0x40, 0x12, 0xa5, 0x2c, 0x9f, 0x81, 0x8c, 0xc1, 0x9b, 0x3f, 0xf9, 0xf3, 0xd8, 0x34, 0xdf, 0xba, 0xb4, 0xb1, 0xa6, 0xb0, 0x69, 0x37, 0x5d, 0x5c, 0x3c, 0xa6, 0xc1, 0x70, 0x4a, 0xc5, 0xcb, 0x39, 0x1a, 0x3f, 0x4d, 0xa4, 0xee, 0x35, 0x88, 0x55, 0x16, 0x33, 0xb6, 0xb0, 0x14, 0x76, 0xf9, 0xb1, 0x3f, 0x1b, 0x36, 0xba, 0xaa, 0x3b, 0xb6, 0xb5, 0xef, 0xea, 0xd, 0x9d, 0x15, 0xe, 0x33, 0x25, 0x35, 0x71, 0x51, 0x7, 0x11, 0x25, 0x84, 0x70, 0x38, 0xdb, 0x3e, 0xa6, 0xec, 0xa1, 0x14, 0xac, 0x55, 0xf5, 0xdb, 0x1f, 0xce, 0x80, 0x89, 0xe1, 0x8d, 0x47, 0x8d, 0x7a, 0xe8, 0x2d, 0x17, 0x35, 0x99, 0xa0, 0x2d, 0xd6, 0x70, 0xb4, 0x67, 0x94, 0xe9, 0xe2, 0xce, 0x91, 0xba, 0xf9, 0xd, 0xba, 0x5a, 0xfe, 0xfc, 0xd1, 0xba, 0xbb, 0xb8, 0xea, 0x21, 0x6, 0x40, 0xe1, 0x4e, 0xa8, 0xe0, 0x85, 0xa4, 0x4, 0xdb, 0xd9, 0xfe, 0x15, 0xdc, 0x3c, 0xd0, 0xbc, 0x3a, 0x59, 0xbf, 0x99, 0x7b, 0xc6, 0xa1, 0xd, 0xd4, 0xec, 0x89, 0x70, 0xfb, 0x39, 0x65, 0x5, 0xfb, 0xc1, 0x7f, 0xa5, 0xd6, 0x1d, 0x90, 0xc9, 0x89, 0xb4, 0x7f, 0xb3, 0x67, 0xf7, 0xb2, 0xeb, 0x17, 0x70, 0x2f, 0xd0, 0x39, 0xfe, 0x16, 0xec, 0x87, 0x45, 0x91, 0x20, 0x3, 0xaa, 0xae, 0xda, 0x9, 0xcb, 0x64, 0x44, 0x49, 0xdd, 0x85, 0xef, 0x1, 0x4, 0x88, 0xfb, 0xf, 0xcd, 0xe2, 0xd8, 0x4, 0xa0, 0xab, 0xb5, 0x9f, 0x2c, 0x4f, 0x59, 0x4b, 0x34, 0x66, 0xb6, 0x26, 0x20, 0x57, 0x3, 0x50, 0x77, 0x1, 0xbd, 0x4f, 0xb2, 0x5a, 0xf8, 0x33, 0x43, 0xaf, 0xf8, 0xa0, 0x9a, 0x0, 0x4a, 0x55, 0x9f, 0x75, 0xc, 0xdf, 0x6b, 0x2a, 0xdb, 0x2c, 0xab, 0x16, 0xe2, 0xae, 0xd2, 0xbd, 0xc0, 0x48, 0x1a, 0xdd, 0xe1, 0xa8, 0xa7, 0x95, 0x13, 0xe9, 0x4e, 0x6f, 0x95, 0x9f, 0x4e, 0x42, 0x65, 0xcf, 0x2a, 0xba, 0xdb, 0xbf, 0x17, 0x3a, 0x89, 0x7c, 0x50, 0xfd, 0xc2, 0xa2, 0x19, 0xd2, 0x60, 0xaf, 0xd0, 0xc3, 0x47, 0x51, 0x48, 0xc6, 0x45, 0xe6, 0x5e, 0x34, 0x3d, 0x40, 0x85, 0xb7, 0x6c, 0xf1, 0x4e, 0xcc, 0x83, 0x9e, 0x4f, 0x7c, 0x72, 0x51, 0x30, 0x77, 0x75, 0x35, 0xac, 0xb1, 0x54, 0xf7, 0x4b, 0x67, 0x38, 0xfd, 0xc8, 0x23, 0x27, 0xf0, 0xbe, 0x57, 0x94, 0xd6, 0x30, 0xcc, 0x81, 0xb8, 0x7d, 0x5a, 0x19, 0x63, 0x74, 0x68, 0xb1, 0x91, 0xcc, 0x2a, 0xe6, 0xb6, 0x7f, 0xd5, 0xc3, 0x99, 0xf, 0xae, 0xed, 0x6a, 0x5, 0xf4, 0x82, 0xe5, 0xda, 0xc9, 0x1d, 0xae, 0xde, 0xcb, 0xa3, 0x79, 0xfa, 0x68, 0xbf, 0xd8, 0x5a, 0x21, 0x82, 0x75, 0xf4, 0x4a, 0x80, 0x11, 0xa7, 0x4d, 0xe3, 0x3, 0x0, 0x7e, 0x9f, 0x5e, 0x95, 0x5d, 0xf0, 0x52, 0xd6, 0x74, 0x65, 0xd4, 0xa1, 0xc1, 0x79, 0x1b, 0x88, 0xc7, 0x1d, 0xbb, 0xb6, 0xd1, 0x4f, 0x3c, 0xfd, 0x49, 0xf4, 0x14, 0xad, 0xc2, 0x6c, 0xf8, 0xfb, 0xb7, 0x97, 0xc7, 0xf4, 0xd6, 0x5a, 0xb1, 0xb2, 0x60, 0xc4, 0x3d, 0xd, 0xa0, 0x63, 0x83, 0x78, 0x77, 0x88, 0x3e, 0x87, 0x85, 0x9f, 0x99, 0xa3, 0x6f, 0xf2, 0x18, 0x52, 0x89, 0xfb, 0x3b, 0x26, 0x5c, 0xa1, 0xd0, 0x17, 0xc7, 0x31, 0xd6, 0xfa, 0x64, 0x37, 0xf9, 0x54, 0xe5, 0x5c, 0x4e, 0x7b, 0x90, 0x15, 0x51, 0x56, 0x95, 0x5d, 0x24, 0x95, 0xc3, 0x30, 0x5e, 0xf1, 0x96, 0xf9, 0xbd, 0x62, 0x20, 0x4b, 0xf1, 0x8d, 0xc1, 0xf3, 0xe8, 0xb6, 0xbe, 0x2c, 0x38, 0x95, 0x6b, 0x16, 0x9b, 0x75},
+               output224: []byte{0xc, 0x79, 0xf3, 0xd, 0xa2, 0xa4, 0xab, 0x99, 0x68, 0xd5, 0xa7, 0xd9, 0x96, 0x9d, 0x6c, 0x96, 0x9d, 0x68, 0x91, 0x8, 0xeb, 0xff, 0xee, 0x3e, 0xa4, 0xe1, 0x8e, 0x1d},
+               output256: []byte{0x83, 0xf1, 0x11, 0x1a, 0x37, 0xec, 0x61, 0xe9, 0xd5, 0x23, 0x10, 0x24, 0xb8, 0x1e, 0x88, 0x83, 0xf7, 0xbd, 0x11, 0xbb, 0xa9, 0xa5, 0xda, 0x46, 0xfa, 0xf, 0x6f, 0x19, 0xb3, 0x81, 0xb2, 0xa7},
+               output384: []byte{0xa, 0x82, 0x2a, 0xe2, 0x4c, 0x6d, 0xd0, 0x72, 0x95, 0x7a, 0x8c, 0x74, 0x9, 0xb8, 0xd8, 0xbb, 0x40, 0x9, 0x7d, 0x8c, 0xe8, 0x33, 0xc9, 0x28, 0x20, 0x9b, 0xb7, 0x3c, 0xd3, 0xfa, 0x91, 0x73, 0x19, 0xeb, 0x93, 0xae, 0x77, 0xda, 0x8b, 0xa5, 0x37, 0x3c, 0x5e, 0x5f, 0x94, 0xa9, 0x54, 0x8},
+               output512: []byte{0x4a, 0xb1, 0x4, 0x33, 0xd2, 0xaf, 0xe4, 0x54, 0x3d, 0xbb, 0x59, 0x11, 0x14, 0x14, 0x9b, 0x28, 0x3d, 0xf0, 0x3c, 0x8d, 0x18, 0x57, 0x52, 0x24, 0xe1, 0xb, 0x5d, 0xbf, 0xa7, 0x15, 0xe5, 0xde, 0x7e, 0xc2, 0x7b, 0xd5, 0x8, 0xd1, 0xb8, 0x92, 0xce, 0x66, 0x8f, 0x36, 0x93, 0xd8, 0x9f, 0x9e, 0x35, 0xc3, 0xdd, 0x2a, 0xb, 0xad, 0xcc, 0x1c, 0x7b, 0xbd, 0xe6, 0x2, 0xeb, 0xa4, 0x73, 0x3c}},
+       testcase{
+               msg:       []byte{0x52, 0x3d, 0xe8, 0xb1, 0xf4, 0xcb, 0xb6, 0x5e, 0x81, 0xff, 0xb, 0x6c, 0xcd, 0x6e, 0xb8, 0xef, 0xa, 0xf, 0xa, 0x69, 0x1a, 0xca, 0xf4, 0xa7, 0x7f, 0x25, 0xac, 0xd2, 0xd6, 0x6a, 0xd4, 0xb3, 0xef, 0xd2, 0x5b, 0xe7, 0x3, 0x8, 0x85, 0x3c, 0x9, 0x44, 0x12, 0xa5, 0x18, 0xa3, 0x20, 0x20, 0xe3, 0x2, 0xa, 0x9f, 0x6a, 0xb3, 0x2f, 0xc, 0xd6, 0xe, 0xc0, 0xd7, 0xa1, 0x94, 0x91, 0x7d, 0x6c, 0x45, 0x7b, 0x16, 0x8a, 0x54, 0xa4, 0xb4, 0x6f, 0x7b, 0xd, 0xc, 0x71, 0xbd, 0x61, 0xcd, 0x20, 0x2f, 0x4c, 0x71, 0x87, 0x76, 0xa7, 0x1, 0xe0, 0x77, 0xb, 0xe, 0xfa, 0x5, 0x41, 0x87, 0x70, 0xf9, 0x8e, 0x4e, 0x79, 0xcd, 0x6, 0x63, 0x66, 0xfb, 0x33, 0x0, 0xe8, 0xbe, 0x35, 0x9a, 0x98, 0xb8, 0x2b, 0x76, 0x4b, 0xc2, 0xfb, 0xbf, 0x59, 0xc7, 0xe8, 0xf9, 0x4a, 0x15, 0x7b, 0x1, 0xc6, 0xc7, 0x57, 0x7b, 0x14, 0x28, 0x13, 0x8c, 0xd4, 0x22, 0xbc, 0x47, 0x33, 0xf, 0x8e, 0xd9, 0x9f, 0x4c, 0xa, 0xab, 0xd, 0x98, 0x42, 0x87, 0x44, 0x55, 0x39, 0x83, 0x93, 0x89, 0xee, 0x8, 0xd6, 0x34, 0x51, 0x8, 0xaf, 0x26, 0xad, 0xed, 0xe, 0xc1, 0xd7, 0xbe, 0x77, 0x4c, 0xfb, 0x8c, 0x52, 0x5, 0xdf, 0xe0, 0x7c, 0xf6, 0xca, 0xf8, 0xc1, 0xaf, 0xe3, 0x7c, 0x7a, 0x2e, 0x4f, 0xe6, 0x1, 0x3b, 0x93, 0xeb, 0x24, 0x63, 0xde, 0x4e, 0x9, 0x71, 0xc7, 0x17, 0x8d, 0x6a, 0x76, 0xb1, 0x6a, 0xe, 0x89, 0x60, 0xc9, 0x84, 0xce, 0x8b, 0xbe, 0x71, 0xb3, 0xb4, 0x66, 0xed, 0xf0, 0x44, 0x5b, 0x83, 0x5f, 0x9, 0x41, 0x4d, 0x1, 0xf1, 0x4c, 0x7b, 0x61, 0x67, 0xff, 0x78, 0xff, 0x11, 0x81, 0x27, 0xbb, 0xd5, 0xf8, 0x12, 0xc2, 0x7f, 0xac, 0xd5, 0x7b, 0x3b, 0x12, 0xe, 0x2b, 0xcf, 0xe8, 0x73, 0x15, 0xc7, 0xa9, 0x2b, 0x82, 0xef, 0x5d, 0x50, 0xca, 0x14, 0xa7, 0x17, 0x4d, 0x1b, 0xea, 0x7e, 0x5, 0x65, 0x23, 0xe0, 0x55, 0xa6, 0xae, 0x42, 0xea, 0x37, 0x65, 0x9, 0x4e, 0x55, 0x44, 0xe5, 0xed, 0x0, 0x3c, 0x98, 0x9c, 0x2f, 0x98, 0xf3, 0x8a, 0x17, 0xe3, 0xdd, 0xa7, 0x4d, 0xba, 0xf9, 0xc6, 0x69, 0xa3, 0x19, 0x63, 0x8a, 0x26, 0x98, 0xb0, 0xe4, 0xa6, 0x11, 0x48, 0xd, 0x8a, 0xd3, 0xcf, 0x1, 0x67, 0x92, 0xec, 0xd1, 0x3, 0x49, 0x25, 0xf4, 0x2b, 0x98, 0x11, 0xa7, 0x21, 0x4d, 0x62, 0x3d, 0x4, 0x7a, 0xbc, 0xa3, 0x19, 0x97, 0xdd, 0xeb, 0x3, 0x27, 0x5f, 0x80, 0xdd, 0x21, 0xf4, 0xd, 0xdc, 0x80, 0x61, 0x6e, 0x7a, 0xd3, 0xd4, 0x81, 0xe8, 0xeb, 0xc0, 0xa1, 0xa6, 0xa3, 0x98, 0xe1, 0x6a, 0x78, 0x36, 0x92, 0x15, 0x54, 0x1e, 0xd1, 0xb, 0x75, 0x67, 0x1a, 0xde, 0xb1, 0xaa, 0xe6, 0xe1, 0x11, 0x42, 0xa1, 0xcf, 0x66, 0x5f, 0xc1, 0xb7, 0x33, 0x2d, 0xfb, 0xb0, 0xe1, 0xc, 0x21, 0xa2, 0xb4, 0x8f, 0x78, 0xe5, 0x73, 0x19, 0xac, 0x9c, 0x58, 0xdf, 0xa8, 0xb1, 0xc2, 0x54, 0x8e, 0x29, 0x79, 0xef, 0x1a, 0xcc, 0xfe, 0xb2, 0x15, 0xaf, 0xcd, 0x6c, 0x2c, 0x1b, 0x46, 0xfe, 0x97, 0xdd, 0x49, 0x17, 0x58, 0x37, 0x83, 0x30, 0xef, 0xfc, 0x72, 0x83, 0x66, 0x1d, 0x2c, 0xb8, 0x4f, 0xa0, 0x52, 0x81, 0xe9, 0xe5, 0x17, 0x40, 0x85, 0x8, 0xd2, 0x4d, 0x4, 0x2e, 0x7b, 0x9b, 0xcd, 0x34, 0xdb, 0x87, 0xce, 0x97, 0x2e, 0x4c, 0xbc, 0xdb, 0x98, 0x61, 0x5f, 0xb9, 0x30, 0x93, 0x36, 0x9d, 0xfe, 0xdc, 0x78, 0x2f, 0x44, 0xbc, 0xd0, 0x3e, 0x81, 0xcf, 0x93, 0x5, 0x13, 0x18, 0xb2, 0x40, 0x1f, 0xf2, 0x9f, 0x75, 0x3a, 0x26, 0x4b, 0xda, 0x65, 0xaf, 0x19, 0x9e, 0x3f, 0xcb, 0xb8, 0xb5, 0xd3, 0x9c, 0x83, 0x8a, 0x67, 0xd6, 0xc7, 0xa3, 0xdb, 0x4, 0x6d, 0xc5, 0x6c, 0x32, 0x3d, 0xdb, 0xb5, 0x34, 0xc, 0xbc, 0x22, 0x9e, 0x47, 0xcf, 0xf8, 0xc9, 0xd2, 0x9b, 0x7a, 0x49, 0xac, 0xe, 0xc8, 0xc1, 0x44, 0xa, 0xe4, 0x98, 0xc7, 0xd1, 0x50, 0xef, 0x91, 0xc2, 0x9b, 0xea, 0x7d, 0xf3, 0xef, 0xcc, 0x28, 0x71, 0xa1, 0x3a, 0x1d, 0x72, 0xd1, 0x39, 0xcb, 0x46, 0x3, 0xd9, 0xff, 0xfe, 0x85, 0xf6, 0xdd, 0xd5, 0x44, 0x85, 0xe, 0xf6, 0x3c, 0x39, 0x44, 0xfb, 0x35, 0xdb, 0xc0, 0xd, 0x43, 0x8, 0xce, 0xaa, 0x63, 0x94, 0xb6, 0xe2, 0x3f, 0x65, 0xd, 0x32, 0x3f, 0x8f, 0x7e, 0xf5, 0xd, 0xdb, 0x68, 0xf1, 0x48, 0x6e, 0xab, 0xf9, 0x89, 0xbf, 0x44, 0x45, 0x1f, 0x62, 0xe, 0xc9, 0x48, 0x5c, 0xb, 0x52, 0xd1, 0x41, 0x5d, 0x3c, 0x90, 0x9a, 0x2c, 0xfb, 0xe9, 0xd7, 0x7d, 0xb1, 0x9d, 0x6, 0x9d, 0x33, 0xba, 0xee, 0x4d, 0x77, 0x29, 0x2e, 0x63, 0xfc, 0xbf, 0x65, 0xc1, 0xeb, 0xa2, 0x4b, 0xff, 0xdd, 0xef, 0xe9, 0x52, 0x11, 0xef, 0xa, 0xaf, 0x8a, 0xbf, 0xda, 0x9f, 0x94, 0x44, 0x5e, 0x58, 0x29, 0x76, 0xf9, 0x86, 0xf5, 0x38, 0x2c, 0xb6, 0x69, 0x50, 0x6a, 0xf2, 0xb4, 0xa5, 0xa0, 0xc4, 0x30, 0x0, 0xa3, 0xc7, 0x2c, 0x5c, 0xa4, 0xaa, 0xcd, 0xc9, 0xd3, 0xd3, 0x9f, 0xc5, 0xc4, 0x92, 0xa3, 0x93, 0xb6, 0xc3, 0x41, 0xb8, 0x6d, 0xac, 0xbb, 0xf6, 0xba, 0x8b, 0x46, 0x51, 0x0, 0xcc, 0x68, 0x3e, 0xdb, 0x2d, 0x9b, 0x9f, 0x83, 0xed, 0xf9, 0xc6, 0xa3, 0x26, 0x45, 0xf5, 0x1c, 0xc7, 0x9a, 0xdc, 0x22, 0xa5, 0x2a, 0x0, 0x7b, 0xaa, 0xca, 0x61, 0x8b, 0xe3, 0x5e, 0x35, 0x6d, 0x1f, 0xd1, 0xcf, 0xbd, 0xa7, 0x3f, 0x1e, 0xd0, 0x92, 0x53, 0x3, 0x9d, 0xef, 0x60, 0x94, 0x50, 0xfd, 0x2d, 0x59, 0x43, 0xb9, 0xcd, 0x49, 0xcb, 0xd5, 0x2a, 0x31, 0x8e, 0xe3, 0x51, 0xd, 0x7c, 0xf3, 0xfd, 0x8f, 0xb3, 0x88, 0xac, 0x6c, 0xb9, 0xc6, 0xee, 0xfe, 0xf3, 0xd3, 0xca, 0xd8, 0x50, 0x1b, 0x91, 0xcc, 0x4, 0xa8, 0x88, 0xd3, 0x3e, 0x16, 0xd6, 0xa4, 0xc9, 0x66, 0x6f, 0x5f, 0x5f, 0x3b, 0x25, 0x71, 0x93, 0xf2, 0xb4, 0x6d, 0xed, 0xde, 0x11, 0x84, 0x29, 0x9, 0xd8, 0xc4, 0x8a, 0xde, 0x57, 0x77, 0x5b, 0xb, 0x27, 0x2e, 0x2d, 0xc9, 0xce, 0xf1, 0xa0, 0x83, 0xeb, 0x2c, 0xe5, 0x8f, 0x4d, 0x1f, 0x21, 0x19, 0x22, 0xfd, 0x6a, 0xde, 0xd1, 0xb8, 0x2f, 0xe6, 0xf5, 0xb1, 0x12, 0x51, 0xcd, 0x39, 0x6e, 0x5a, 0x36, 0x66, 0xed, 0x96, 0x26, 0x3, 0x6e, 0x4e, 0x35, 0x62, 0x31, 0xc1, 0x46, 0xbb, 0xa0, 0xa9, 0x1a, 0xfd, 0x36, 0x48, 0xeb, 0x7b, 0xfe, 0xb, 0x9c, 0x14, 0xf1, 0x5a, 0xf2, 0xf9, 0x23, 0x9, 0x82, 0x6f, 0x46, 0x89, 0x45, 0xca, 0xd0, 0xac, 0x42, 0x2d, 0xe3, 0xd6, 0xa7, 0x73, 0xb7, 0x61, 0x78, 0x42, 0x21, 0x7, 0xce, 0x2, 0x70, 0xe7, 0xf5, 0x80, 0xb5, 0xcc, 0xeb, 0xa8, 0x2c, 0xa0, 0x18, 0x4a, 0xaf, 0xa8, 0x34, 0x11, 0x41, 0xe6, 0x5e, 0x39, 0x85, 0x98, 0x85, 0x76, 0x8f, 0xbc, 0x5c, 0xe6, 0x3b, 0x96, 0x5a, 0x6, 0x4, 0xb6, 0x59, 0xe7, 0x1d, 0x9d, 0xa2, 0xc7, 0xa4, 0x36, 0x46, 0x8, 0x8d, 0x80, 0x71, 0xd7, 0x69, 0x26, 0x16, 0x3a, 0xaf, 0xc6, 0x9e, 0x25, 0x35, 0x5b, 0xb0, 0xa2, 0x22, 0xb7, 0xb2, 0xda, 0x9f, 0xa, 0x20, 0xc0, 0x21, 0xad, 0xc4, 0x62, 0xe9, 0x5, 0xa9, 0xc3, 0xbf, 0x31, 0xc1, 0x6d, 0x87, 0xfb, 0xec, 0x3f, 0x1, 0x4f, 0x39, 0x57, 0xa7, 0x20, 0xf1, 0x43, 0x2e, 0x17, 0x41, 0x55, 0x30, 0x92, 0x5, 0x2f, 0xb5, 0x8a, 0x19, 0x86, 0x40, 0x47, 0x9a, 0xbc, 0xaa, 0x51, 0xb1, 0x4, 0xcc, 0x93, 0xe2, 0x63, 0x6e, 0x14, 0x60, 0x64, 0x3e, 0xa8, 0x12, 0xbd, 0x44, 0xe8, 0x19, 0xc2, 0x16, 0x6e, 0xb6, 0xb3, 0x49, 0xba, 0x5b, 0xde, 0xba, 0xd5, 0x90, 0x78, 0x91, 0xb, 0x5c, 0x22, 0xa5, 0x6f, 0x0, 0x4b, 0x8d, 0x9e, 0x4b, 0x12, 0x24, 0xd8, 0xd2, 0x4, 0xb4, 0x8a, 0xbe, 0x73, 0x55, 0x54, 0x8a, 0x40, 0x27, 0x36, 0xc5, 0xcb, 0x11, 0xf, 0x3a, 0x14, 0x76, 0xed, 0x63, 0x1f, 0xf1, 0x68, 0xf4, 0xf3, 0xef, 0xd8, 0x9b, 0x38, 0xde, 0x47, 0x51, 0x53, 0x65, 0x48, 0x64, 0x75, 0x23, 0xd3, 0x34, 0xfa, 0xd7, 0xcc, 0x2d, 0x14, 0x29, 0x73, 0xf2, 0xdb, 0x3c, 0x1f, 0xe0, 0x8f, 0xc5, 0xcf, 0x83, 0xf9, 0xf2, 0xbd, 0x2d, 0xaa, 0x52, 0x4b, 0x37, 0x86, 0x48, 0x16, 0xaf, 0x29, 0xee, 0x5, 0x95, 0x1f, 0xa0, 0x9d, 0x1c, 0x51, 0xd9, 0xd1, 0x4e, 0xe4, 0xf7, 0x2f, 0xd7, 0xbb, 0xf1, 0x8b, 0x1a, 0x72, 0x4f, 0xf5, 0xa0, 0x95, 0x8a, 0x6, 0x39, 0x47, 0xc4, 0x30, 0x14, 0x2a, 0xd2, 0x35, 0x6e, 0x44, 0x0, 0xaa, 0xec, 0xa4, 0x42, 0xe1, 0x63, 0x37, 0x2a, 0x8f, 0x1c, 0xd3, 0x6e, 0x2d, 0xb9, 0x88, 0xe7, 0x78, 0x11, 0x65, 0xe5, 0xd4, 0xe7, 0x7, 0x4a, 0xce, 0x40, 0x85, 0x8e, 0x83, 0x70, 0xe8, 0x83, 0x69, 0x4a, 0xf0, 0x99, 0x77, 0x70, 0x43, 0x47, 0xfb, 0x73, 0x5c, 0x87, 0x17, 0xc4, 0x2b, 0xc4, 0xee, 0xeb, 0x2a, 0xaa, 0x50, 0xdf, 0xe6, 0x37, 0xc6, 0x40, 0x90, 0x9c, 0xe3, 0x79, 0xbf, 0xb9, 0xe2, 0x60, 0x8f, 0x88, 0x75, 0x13, 0x77, 0x3, 0x8d, 0x16, 0x69, 0xf2, 0x48, 0x17, 0x8a, 0xd5, 0x80, 0xa9, 0x8, 0xd7, 0xa1, 0xb8, 0xdc, 0xc7, 0xe5, 0x3e, 0x1, 0x80, 0x1f, 0x1e, 0x48, 0x5b, 0x58, 0x93, 0xf1, 0x3, 0xf0, 0x3e, 0xf, 0x53, 0xb2, 0xb1, 0x44, 0xb, 0xe9, 0x56, 0x44, 0xd8, 0x5a, 0xa7, 0xf6, 0xeb, 0x7e, 0xdf, 0xbb, 0x46, 0x65, 0x21, 0x96, 0x69, 0x5e, 0xa2, 0x3c, 0x8, 0x57, 0x33, 0x97, 0xb1, 0x11, 0xff, 0x90, 0x90, 0x25, 0xe2, 0xc, 0x52, 0x1, 0x29, 0x3b, 0x4d, 0x22, 0x3b, 0xf7, 0xaa, 0x1, 0xde, 0x7c, 0xb2, 0x8b, 0x94, 0x71, 0x43, 0x70, 0x43, 0x4b, 0x95, 0x88, 0x9, 0x7e, 0x24, 0x1, 0xb6, 0x2c, 0x7a, 0xd, 0xef, 0x1f, 0xbf, 0x89, 0x80, 0x9e, 0x81, 0x7, 0x49, 0xfd, 0x3c, 0xe9, 0xec, 0x3c, 0x7, 0xce, 0x4b, 0xf4, 0xc4, 0x3d, 0xc9, 0x66, 0x42, 0x9b, 0x2b, 0xeb, 0x4d, 0x71, 0x1f, 0xc6, 0xc4, 0x48, 0xa1, 0x20, 0x97, 0xb3, 0x6f, 0x1e, 0x68, 0x17, 0xea, 0xf4, 0x93, 0x7a, 0x98, 0x3f, 0x85, 0xd9, 0xcf, 0x3e, 0x62, 0xcc, 0x1b, 0x2a, 0xc6, 0xae, 0x1e, 0xc9, 0xea, 0xa8, 0xcd, 0x8e, 0xe2, 0xc3, 0x32, 0x22, 0x39, 0xcf, 0xe5, 0xdb, 0x3d, 0x4e, 0x87, 0x86, 0x28, 0x2e, 0x63, 0xa, 0x7d, 0x25, 0x9c, 0x2f, 0xef, 0xec, 0xa0, 0x30, 0x31, 0xc9, 0x60, 0xa6, 0x6a, 0x71, 0xe4, 0x36, 0xa3, 0xed, 0x6f, 0x2f, 0x3c, 0xfa, 0xb4, 0xbd, 0x77, 0xc6, 0x60, 0xd1, 0x42, 0x5, 0xab, 0xf6, 0x6, 0xfe, 0x56, 0x1a, 0x34, 0x6f, 0x7d, 0x84, 0x9b, 0x69, 0x47, 0x5a, 0xc9, 0xf6, 0x82, 0x2d, 0x80, 0xb9, 0xa2, 0xe5, 0x6d, 0x5d, 0x49, 0x5e, 0x4b, 0x30, 0x9b, 0xe, 0xa9, 0x63, 0xc9, 0xfc, 0x5c, 0x7e, 0xf9, 0x4b, 0x21, 0x7e, 0xe5, 0x33, 0x79, 0x89, 0xaf, 0xbc, 0x71, 0x7, 0xd2, 0x33, 0xa8, 0xb3, 0x62, 0xac, 0x27, 0xc4, 0xf6, 0x9d, 0xf9, 0xe1, 0x91, 0xcd, 0x65, 0xae, 0x97, 0xd6, 0xeb, 0x9e, 0x54, 0x84, 0xeb, 0x6f, 0x10, 0x34, 0x95, 0x75, 0xe4, 0xca, 0xe5, 0x14, 0x52, 0x38, 0x1, 0x51, 0xf9, 0x2, 0x41, 0x5a, 0xc9, 0xcf, 0x42, 0xc8, 0x24, 0xeb, 0x23, 0xc9, 0x54, 0x1d, 0x2d, 0xa1, 0xc2, 0x6d, 0xb8, 0x5f, 0x53, 0xcd, 0xaf, 0xb0, 0x6a, 0x12, 0xb8, 0x39, 0x3c, 0xd5, 0x80, 0xa8, 0xe4, 0x94, 0xed, 0xb6, 0x71, 0xc, 0x72, 0xd, 0xca, 0xe3, 0x8, 0x32, 0x96, 0x7e, 0x33, 0xe6, 0x30, 0x3a, 0x92, 0xb1, 0xdf, 0x8, 0x41, 0xd7, 0x72, 0x42, 0x84, 0xff, 0xd2, 0xe0, 0xb, 0x95, 0xc6, 0xd6, 0x23, 0xb1, 0x68, 0xd2, 0x1a, 0xc1, 0xbd, 0x3c, 0x67, 0x5e, 0xda, 0x33, 0x18, 0x2a, 0x2c, 0x22, 0x37, 0x9, 0x98, 0xde, 0x1e, 0x5e, 0xb9, 0x5, 0x37, 0x2c, 0xc6, 0xef, 0x32, 0xd5, 0xb7, 0x65, 0xf5, 0xc9, 0x48, 0x70, 0xdf, 0x48, 0x42, 0xd0, 0x11, 0x60, 0x3b, 0xe4, 0xcd, 0xb1, 0xc2, 0x27, 0xe4, 0x1e, 0xb2, 0xf2, 0xe8, 0x54, 0x2c, 0xd3, 0x25, 0x88, 0x4f, 0xed, 0xc9, 0xc5, 0xc7, 0xbb, 0x7, 0xa9, 0x2d, 0x20, 0xd6, 0x4b, 0x83, 0x62, 0x15, 0xc5, 0x9f, 0x16, 0x2a, 0x3d, 0xa8, 0xbb, 0x67, 0xd6, 0xfc, 0x13, 0xfe, 0xf9, 0x7c, 0xab, 0x6e, 0xcb, 0x8a, 0x29, 0xe4, 0x31, 0xa6, 0x51, 0x9a, 0x62, 0x61, 0xc4, 0x52, 0x1c, 0xcb, 0x90, 0xe6, 0xe6, 0x9, 0x86, 0x9e, 0x6f, 0xe3, 0x98, 0x40, 0x4a, 0xe0, 0x47, 0xf6, 0x4e, 0xc4, 0x26, 0x35, 0x66, 0xde, 0xfe, 0xe6, 0x63, 0x29, 0xdd, 0x40, 0xac, 0x98, 0x5e, 0xb8, 0xa0, 0x8d, 0x26, 0x52, 0x9a, 0x54, 0x48, 0x91, 0xb6, 0xf5, 0x7c, 0xc2, 0x35, 0xc6, 0x3c, 0x9, 0x5, 0x7a, 0xb6, 0xb6, 0xed, 0x72, 0xe, 0xf4, 0x1a, 0x3c, 0x9a, 0xe6, 0x57, 0x68, 0xb4, 0x3f, 0x6d, 0xcf, 0x49, 0x62, 0xa1, 0x3, 0xdd, 0x93, 0xc2, 0x13, 0x17, 0x1d, 0xc2, 0xc9, 0x19, 0x4e, 0x43, 0x26, 0x5c, 0x68, 0x9b, 0x49, 0x33, 0x14, 0x50, 0x28, 0x1a, 0x3f, 0xeb, 0xc6, 0x18, 0xd1, 0xaa, 0x4d, 0x65, 0xa1, 0x35, 0x13, 0x70, 0x51, 0xfd, 0x46, 0xb5, 0x68, 0xce, 0x29, 0x4c, 0x89},
+               output224: []byte{0x2c, 0x70, 0xb, 0x40, 0x59, 0x91, 0x6a, 0xf3, 0xf4, 0x7d, 0x90, 0x17, 0xf5, 0x72, 0x5f, 0x42, 0xb0, 0xd5, 0x18, 0x95, 0x33, 0x1f, 0x9, 0x0, 0x48, 0xc2, 0x76, 0xa0},
+               output256: []byte{0x96, 0xba, 0xee, 0x8e, 0xca, 0x9d, 0xcd, 0xbd, 0xc4, 0x67, 0x54, 0x9e, 0x30, 0x7d, 0x95, 0xc2, 0xa, 0x7, 0xfe, 0xb7, 0x2e, 0xcc, 0xc7, 0x80, 0xdb, 0xc2, 0x9d, 0x40, 0xae, 0x7c, 0xae, 0x45},
+               output384: []byte{0xe1, 0x7a, 0x2a, 0x66, 0x7, 0x82, 0xbd, 0xe, 0xb5, 0x7b, 0x46, 0x3a, 0xfa, 0xa7, 0x45, 0xf6, 0x58, 0xbd, 0x6d, 0x7, 0x3c, 0x56, 0xf6, 0x9d, 0xea, 0xdb, 0x62, 0x9d, 0x4e, 0xa9, 0x3c, 0x1c, 0x36, 0x3, 0x39, 0x2d, 0xc6, 0xd8, 0x41, 0x45, 0x27, 0xa9, 0x62, 0xae, 0x34, 0x77, 0xfd, 0x34},
+               output512: []byte{0x76, 0x58, 0x3e, 0x74, 0xe, 0xef, 0xb6, 0x39, 0x4f, 0x6a, 0xf3, 0x10, 0xae, 0x89, 0x6e, 0x1b, 0x2d, 0x18, 0x15, 0x81, 0x16, 0x5c, 0xe1, 0xdc, 0xc2, 0x31, 0x7d, 0x7e, 0xb0, 0x44, 0x67, 0x7a, 0xc0, 0xaa, 0x63, 0x23, 0xb5, 0xb1, 0x42, 0x43, 0xd0, 0x82, 0x2e, 0xe4, 0x9d, 0xa1, 0xc6, 0x76, 0xfb, 0xbc, 0x1f, 0x18, 0x9b, 0x91, 0x9b, 0xce, 0x8a, 0xa, 0xb2, 0x83, 0xd6, 0x3, 0x8, 0xc8}},
+       testcase{
+               msg:       []byte{0x24, 0xb1, 0x19, 0x1, 0x70, 0x41, 0x81, 0x26, 0xdd, 0x7a, 0x5a, 0x81, 0xfc, 0x8, 0xa, 0x98, 0x4, 0x31, 0x1b, 0x48, 0xc4, 0xe4, 0xda, 0x68, 0x7, 0x27, 0xb8, 0x74, 0x31, 0x8d, 0x17, 0xbd, 0xd3, 0x4b, 0xe7, 0x26, 0xda, 0xa7, 0x60, 0xa4, 0x2, 0x8, 0xbb, 0x6f, 0x51, 0x2e, 0x5a, 0xa8, 0x89, 0xb1, 0x35, 0xd2, 0x77, 0xcf, 0xfe, 0x6a, 0xf8, 0x2, 0x95, 0x4b, 0xc9, 0x18, 0xe4, 0xd5, 0x99, 0xee, 0x18, 0x5d, 0x59, 0x87, 0x1, 0xc2, 0xfa, 0x3c, 0x28, 0xf7, 0xed, 0xb3, 0x55, 0xd7, 0x4a, 0x8d, 0x2f, 0x1a, 0x9e, 0xff, 0x8b, 0x6c, 0x2a, 0xbe, 0xd7, 0x76, 0xbe, 0x8b, 0xac, 0xdc, 0xfc, 0x6c, 0x98, 0xc5, 0xe7, 0x3c, 0x24, 0xfa, 0x9, 0x67, 0xb6, 0xf2, 0xf7, 0x90, 0x51, 0xe6, 0x48, 0xec, 0xd9, 0x53, 0xab, 0x54, 0x30, 0xb8, 0xc7, 0xd9, 0x63, 0x52, 0xe6, 0x0, 0xa6, 0xfc, 0x4, 0xfd, 0x42, 0x25, 0xd, 0x24, 0xe4, 0xa5, 0x96, 0x9b, 0xae, 0x77, 0x12, 0xc6, 0xc1, 0xbf, 0x8b, 0x95, 0x48, 0x1a, 0xf, 0x81, 0x86, 0x29, 0x8e, 0xd2, 0xa7, 0xe, 0x16, 0xff, 0x82, 0x9, 0xc0, 0x51, 0x1a, 0xd4, 0xe2, 0xea, 0x17, 0xf5, 0x39, 0x78, 0x9f, 0x9a, 0x1d, 0x47, 0xee, 0x29, 0x1e, 0x15, 0x78, 0x6, 0xcf, 0x68, 0x0, 0x67, 0xd3, 0x72, 0x31, 0x3, 0x2b, 0x3, 0x2d, 0x5e, 0xfb, 0x15, 0x52, 0x92, 0x54, 0x97, 0xe5, 0x7d, 0x8, 0x8e, 0xce, 0x2b, 0x38, 0x69, 0x68, 0x43, 0x57, 0xc4, 0x66, 0xdb, 0x45, 0x4d, 0x4f, 0xd9, 0xee, 0x9b, 0xcf, 0xc5, 0xdf, 0xd7, 0xad, 0x36, 0x20, 0xb3, 0xfb, 0x24, 0x4f, 0x71, 0x7a, 0x48, 0xfa, 0xcf, 0x1, 0x57, 0xf8, 0x7c, 0xbb, 0xa9, 0x4b, 0x91, 0xc0, 0xc3, 0x90, 0x2, 0xf7, 0x83, 0x51, 0xe3, 0xea, 0x6d, 0x41, 0x1c, 0xa5, 0x87, 0xb9, 0x1a, 0xc, 0xba, 0x4c, 0xe2, 0x1a, 0x89, 0x32, 0xec, 0x9f, 0xf, 0x6e, 0x8f, 0xed, 0x5d, 0xe7, 0xdd, 0xd0, 0x3a, 0x3b, 0x90, 0xb6, 0xc6, 0xd8, 0x28, 0xf7, 0x83, 0x1a, 0xae, 0x1f, 0x87, 0x9f, 0xca, 0xff, 0x77, 0xb7, 0x6f, 0xba, 0x1c, 0x0, 0x13, 0xcd, 0xdb, 0x19, 0xe9, 0x3d, 0x87, 0x8b, 0x34, 0x28, 0xfa, 0x91, 0xf1, 0xa5, 0x17, 0x9f, 0x72, 0x40, 0xa5, 0xb4, 0x7b, 0x14, 0x6f, 0xa3, 0x4e, 0x39, 0x97, 0x73, 0xb, 0x60, 0x1d, 0xd5, 0x6f, 0x58, 0x76, 0x22, 0x11, 0x48, 0x13, 0xb5, 0x72, 0x39, 0xa2, 0x89, 0xdb, 0xa2, 0x34, 0x8b, 0x2b, 0xd8, 0x20, 0x7f, 0xcd, 0xb1, 0xce, 0x0, 0x32, 0x98, 0x4d, 0x93, 0x89, 0xd7, 0x31, 0x94, 0x2e, 0xdc, 0x5a, 0x44, 0xd8, 0x72, 0xeb, 0x86, 0x3, 0x8e, 0x28, 0x1f, 0x49, 0xc8, 0x68, 0xdb, 0xa2, 0x78, 0xd1, 0xc9, 0x4a, 0xd1, 0xac, 0x37, 0x6d, 0x57, 0x8, 0x5e, 0xbe, 0x87, 0x5c, 0xba, 0x7a, 0xd0, 0x71, 0xd5, 0xcb, 0x38, 0x43, 0xdd, 0xad, 0xc6, 0xec, 0xf8, 0xaf, 0x7d, 0x6c, 0x54, 0x69, 0x38, 0x95, 0x76, 0x68, 0xe4, 0xe8, 0xdc, 0x5, 0x70, 0x9, 0x0, 0xff, 0x2a, 0xa, 0x2e, 0x8d, 0xba, 0x72, 0x6c, 0xce, 0xa4, 0x43, 0xf8, 0x68, 0x16, 0x44, 0xa3, 0x77, 0xd7, 0xfb, 0x39, 0xfd, 0x15, 0x9f, 0x72, 0xb8, 0xb6, 0xed, 0xab, 0xab, 0x76, 0xe4, 0xaf, 0x39, 0xfa, 0x6, 0x5c, 0x9b, 0x94, 0x7f, 0x53, 0x70, 0x2a, 0x37, 0x97, 0x55, 0x2e, 0x92, 0xd3, 0x13, 0x54, 0xa, 0x50, 0xe7, 0x39, 0x81, 0xc4, 0x34, 0xe, 0x88, 0x72, 0x2c, 0xe1, 0x97, 0x97, 0xdd, 0x53, 0x5, 0xe5, 0x61, 0x15, 0x6b, 0xcc, 0xfa, 0xd1, 0x47, 0x68, 0x5f, 0xef, 0x2b, 0x76, 0xf4, 0xcf, 0x80, 0x83, 0x51, 0x5c, 0xe8, 0xf0, 0xc6, 0xa, 0x52, 0x69, 0x9f, 0x8, 0xe6, 0xab, 0x24, 0xc1, 0xdf, 0x61, 0x2d, 0x93, 0xd7, 0xca, 0x26, 0xcc, 0xb2, 0xd5, 0x15, 0x6b, 0xac, 0xe4, 0xda, 0x28, 0xe8, 0xf1, 0xe9, 0x99, 0x2b, 0xb8, 0x48, 0xd, 0x30, 0x10, 0x46, 0xba, 0xbf, 0x55, 0x95, 0x4f, 0xd5, 0xf2, 0x9c, 0x7, 0x48, 0x6, 0x48, 0x2f, 0xac, 0xec, 0x43, 0x2d, 0xa1, 0xb, 0xb7, 0x55, 0x62, 0x87, 0xf2, 0xf1, 0x8, 0xb1, 0x14, 0x90, 0x4c, 0x12, 0x2d, 0xe4, 0x3e, 0x6a, 0x77, 0x4, 0x8a, 0xf3, 0xb4, 0x79, 0x20, 0x51, 0x5d, 0x1b, 0x3, 0xe2, 0x80, 0xc1, 0xe7, 0xc0, 0x5b, 0xc7, 0x10, 0x89, 0xec, 0x76, 0x9f, 0x7f, 0xa0, 0x4e, 0xc, 0x49, 0x84, 0xd1, 0x86, 0xf8, 0xc8, 0xee, 0x30, 0x5b, 0x1f, 0xb2, 0x1d, 0x3, 0xf0, 0x25, 0xc9, 0x5c, 0x8c, 0xe9, 0xc5, 0xa, 0xd6, 0xfb, 0x52, 0x7e, 0xf5, 0x5, 0xbd, 0x20, 0x3a, 0xcb, 0x5b, 0x12, 0xd4, 0xcf, 0xe0, 0x8f, 0x45, 0x79, 0x97, 0x15, 0x90, 0xbd, 0x43, 0x75, 0x5a, 0x85, 0xa0, 0x3b, 0xd2, 0x96, 0x88, 0x51, 0x28, 0xae, 0x64, 0x33, 0x3d, 0xc3, 0x3, 0x1, 0xdd, 0x7c, 0x9b, 0x8e, 0x3, 0x5e, 0x22, 0xf7, 0x5f, 0x41, 0x10, 0x50, 0xdb, 0x6a, 0x17, 0x26, 0x5d, 0xcf, 0x3f, 0x3d, 0xcd, 0xf8, 0xfe, 0xb, 0x72, 0x8a, 0x68, 0xb, 0x60, 0xee, 0xad, 0x7f, 0xbe, 0x14, 0x1f, 0x6d, 0x92, 0x98, 0xed, 0xbd, 0xd0, 0x7d, 0x52, 0xde, 0xcd, 0xe1, 0x53, 0xaa, 0xfd, 0xa6, 0x69, 0x8f, 0x41, 0x5e, 0xaf, 0x86, 0x22, 0x86, 0x1e, 0x54, 0xa2, 0xb2, 0x79, 0xe3, 0xb1, 0xc0, 0xea, 0xfd, 0x5a, 0x58, 0x9e, 0x71, 0x21, 0xdf, 0x6e, 0x51, 0xe4, 0xd7, 0x69, 0x85, 0x66, 0xbc, 0xd5, 0x2, 0x10, 0x13, 0x18, 0xd, 0x77, 0xa1, 0x90, 0x8c, 0x17, 0x16, 0x9c, 0x9b, 0xba, 0x1b, 0xca, 0xcd, 0x5a, 0xa4, 0x79, 0x9d, 0xf8, 0x45, 0x93, 0x1, 0x3e, 0x21, 0xc3, 0x3, 0xac, 0xb6, 0x70, 0xde, 0x66, 0xb5, 0xcf, 0x8, 0xfa, 0xd0, 0x47, 0x69, 0xcd, 0x5, 0xd6, 0x9e, 0x3a, 0xdc, 0xd5, 0xb0, 0x0, 0x2c, 0x75, 0x61, 0x8a, 0x6a, 0x1f, 0x44, 0x9, 0x18, 0xb0, 0x4d, 0xf7, 0xb2, 0xde, 0x36, 0x36, 0x39, 0x15, 0x2c, 0xb6, 0xa2, 0x6d, 0x77, 0xdb, 0x7f, 0x40, 0x2, 0x91, 0xe2, 0x14, 0x79, 0xd5, 0xa7, 0xe0, 0xfa, 0xcd, 0x36, 0xed, 0x9, 0xf2, 0xa2, 0xe7, 0x4f, 0x56, 0x4b, 0x8b, 0x67, 0x6d, 0x3e, 0x3d, 0xe0, 0x77, 0x12, 0xe1, 0xf6, 0x98, 0x40, 0xbf, 0xb4, 0x8d, 0xe6, 0x31, 0x41, 0xa2, 0x45, 0x5d, 0xeb, 0xe2, 0xe9, 0xfb, 0x81, 0x86, 0xa0, 0x19, 0x21, 0xbf, 0xc8, 0xd6, 0x44, 0xdb, 0xe3, 0x15, 0xee, 0xa9, 0x43, 0xd3, 0x70, 0xec, 0x64, 0x8a, 0xe7, 0x46, 0x57, 0xaa, 0x57, 0x51, 0x2b, 0x39, 0xb6, 0xd8, 0x72, 0x21, 0x2d, 0xd1, 0x3b, 0xbc, 0x7f, 0xdc, 0xb4, 0x81, 0xf7, 0x20, 0x1f, 0x65, 0x34, 0x80, 0x17, 0xd0, 0x25, 0x9f, 0xa9, 0x9a, 0x69, 0x8, 0x4d, 0xb, 0x62, 0xe6, 0x3a, 0x74, 0x8, 0xaa, 0xb2, 0x4d, 0xa4, 0xd3, 0xba, 0x6f, 0x7b, 0x18, 0x7d, 0x1, 0x4a, 0x37, 0x2f, 0xa8, 0x16, 0x1, 0x75, 0xf3, 0xb3, 0x73, 0x99, 0xee, 0xdd, 0x7f, 0x6f, 0xe8, 0x69, 0xa1, 0xf0, 0xab, 0x8b, 0xa, 0x3b, 0x83, 0x5c, 0x9d, 0x8, 0x69, 0x27, 0xda, 0x75, 0xad, 0x48, 0x3c, 0xdb, 0xf8, 0x3f, 0x75, 0x71, 0xfe, 0x10, 0x41, 0x37, 0x6b, 0x8b, 0x57, 0xa1, 0x5d, 0xd1, 0xda, 0x70, 0x75, 0xec, 0xd0, 0x40, 0xae, 0x2f, 0x5b, 0xd6, 0xd3, 0x71, 0xed, 0x3e, 0xdd, 0xcc, 0x13, 0xf8, 0xd6, 0x11, 0xc2, 0x2b, 0x29, 0xfe, 0x9f, 0x24, 0x61, 0x25, 0xb2, 0xb8, 0x68, 0xad, 0xae, 0xae, 0xed, 0x40, 0xba, 0x1c, 0x31, 0x50, 0xbe, 0xb5, 0x9, 0x40, 0x87, 0x5b, 0x8, 0xe6, 0x50, 0xc0, 0xa, 0x9, 0x5e, 0xc2, 0xab, 0xff, 0x72, 0x3f, 0x7f, 0x1f, 0x5b, 0x97, 0x98, 0x5b, 0x7d, 0x1c, 0x1d, 0x81, 0xbf, 0xc0, 0x31, 0xf6, 0x4e, 0x45, 0x21, 0x25, 0xcd, 0xd1, 0x37, 0x32, 0xd8, 0x6a, 0x9c, 0xb7, 0xee, 0x1d, 0x89, 0x38, 0x14, 0x34, 0xd9, 0x39, 0xb5, 0x15, 0xf3, 0xf4, 0x61, 0x56, 0x7b, 0x90, 0x5c, 0xce, 0x4d, 0x6a, 0x7a, 0x5a, 0xb, 0x7f, 0x96, 0x4f, 0xd6, 0xd5, 0xfe, 0x90, 0xfa, 0x72, 0x6e, 0xfe, 0x18, 0x78, 0x7d, 0x26, 0xb0, 0x83, 0xbb, 0xc8, 0xab, 0x5d, 0x7e, 0xe7, 0xf9, 0xd7, 0x9d, 0x35, 0x56, 0x61, 0x6e, 0x2, 0x82, 0xfc, 0x14, 0xb8, 0xc, 0x9c, 0xfe, 0x2, 0xa3, 0xbd, 0x84, 0x5b, 0x1a, 0x3e, 0xad, 0x1d, 0xec, 0x61, 0x39, 0x3f, 0x0, 0x49, 0xb8, 0x5e, 0xa6, 0x4a, 0x7b, 0xbc, 0x5, 0x85, 0xa0, 0xe2, 0x4c, 0x53, 0xd7, 0x74, 0xe5, 0xa0, 0x85, 0xfc, 0x21, 0x7e, 0xf6, 0xf0, 0x37, 0xa, 0x79, 0x4a, 0x96, 0xe6, 0xbf, 0x57, 0x2a, 0x4c, 0x31, 0x95, 0xe9, 0x16, 0xc9, 0xa5, 0x18, 0x14, 0x98, 0x9d, 0xc4, 0xae, 0x65, 0xd0, 0x90, 0x97, 0x6b, 0xab, 0x97, 0x9, 0xfb, 0xb5, 0x1b, 0x0, 0x46, 0x94, 0xab, 0x9c, 0x8, 0x33, 0x63, 0x7f, 0xe1, 0x0, 0x18, 0x3e, 0xbe, 0xcf, 0xa6, 0xf7, 0x8d, 0x26, 0x1, 0x4a, 0x0, 0xdb, 0xb2, 0x4, 0x47, 0x1a, 0x6a, 0x37, 0x9d, 0x9e, 0x42, 0x94, 0xa5, 0xda, 0x78, 0xf3, 0x8e, 0xf2, 0xb0, 0xa4, 0x74, 0xe9, 0x2a, 0xe6, 0xd8, 0x11, 0xe1, 0x12, 0xff, 0xb2, 0x24, 0xc6, 0xee, 0x2f, 0x5b, 0x2a, 0x3a, 0x5e, 0xd5, 0xb5, 0x29, 0xef, 0xd2, 0xb9, 0x10, 0x6d, 0x87, 0x8b, 0x38, 0x6a, 0xc9, 0x74, 0xcd, 0x5d, 0xa9, 0x91, 0x13, 0xf1, 0x17, 0x0, 0x78, 0x32, 0x26, 0x31, 0x5a, 0xe8, 0xb9, 0xcc, 0x9c, 0x41, 0x42, 0x3e, 0x47, 0xb5, 0x1d, 0x10, 0xb5, 0x1a, 0xd5, 0x3, 0xba, 0x96, 0x8a, 0x70, 0x46, 0x75, 0x3d, 0x3f, 0x5f, 0xb0, 0xcb, 0x60, 0x1f, 0x4a, 0x8d, 0x59, 0x4b, 0x12, 0xe2, 0x83, 0x84, 0x39, 0x11, 0x71, 0xb, 0x89, 0x77, 0x41, 0x2c, 0x3b, 0x64, 0xe8, 0x61, 0x17, 0x28, 0xad, 0x46, 0x84, 0xd7, 0xe2, 0x42, 0xa1, 0xd8, 0x5f, 0xfa, 0x5d, 0x1, 0xe7, 0xf3, 0xda, 0xdb, 0xc1, 0xb1, 0x69, 0x10, 0x30, 0xc8, 0xaa, 0x51, 0x9, 0x5c, 0xd2, 0xba, 0xf3, 0x6e, 0x5b, 0x45, 0xd1, 0xfb, 0x7d, 0xa2, 0x89, 0x73, 0xa9, 0x8f, 0xb3, 0xbc, 0xe8, 0x35, 0x93, 0x2a, 0x47, 0x5e, 0xda, 0xa1, 0x2c, 0x23, 0x2b, 0xba, 0xe4, 0xf7, 0x93, 0x32, 0x4f, 0x82, 0xbb, 0xb4, 0xe1, 0x9c, 0xc9, 0xe4, 0x48, 0x23, 0x93, 0x43, 0x8f, 0x94, 0x0, 0x62, 0x46, 0xc3, 0xa8, 0x1a, 0xb5, 0x1b, 0xe7, 0x72, 0x13, 0x11, 0xeb, 0xf1, 0x92, 0x74, 0x88, 0xf1, 0xbc, 0xbb, 0xb2, 0x67, 0x92, 0xd6, 0x18, 0xd, 0xc, 0xe5, 0x9b, 0x69, 0xe3, 0x97, 0xa6, 0xd6, 0xd, 0xb8, 0x3c, 0x32, 0x1b, 0xf9, 0x71, 0xf5, 0xd8, 0x4, 0x51, 0x2d, 0x55, 0x4f, 0xc3, 0x45, 0x3a, 0xec, 0x14, 0xf6, 0xb0, 0xb5, 0xe8, 0x2b, 0x8a, 0x87, 0xbc, 0x8e, 0xaf, 0xdf, 0x7c, 0xad, 0x1e, 0xb0, 0x7e, 0x16, 0x4d, 0xf6, 0x1b, 0x6d, 0xd, 0xea, 0xae, 0xd3, 0x3d, 0x4b, 0x56, 0xb1, 0x75, 0x18, 0x47, 0x30, 0x10, 0x2e, 0x77, 0xcf, 0x81, 0x82, 0x3e, 0xe8, 0x2b, 0xfe, 0x94, 0x5e, 0x3b, 0x79, 0x23, 0x81, 0x81, 0x57, 0xc5, 0x79, 0xa7, 0x74, 0xe8, 0xd0, 0x5f, 0xd7, 0x7f, 0xe8, 0x4a, 0xb3, 0x6a, 0x3d, 0x26, 0x6b, 0xe1, 0xf0, 0x94, 0x4, 0x8b, 0x8e, 0x41, 0x7f, 0xf0, 0x55, 0x6c, 0x95, 0xc2, 0xc, 0xc, 0xc1, 0xf3, 0x96, 0x39, 0x65, 0xe5, 0xc3, 0x7d, 0xf5, 0xb4, 0xd8, 0x86, 0x53, 0xf8, 0x31, 0xbb, 0x22, 0x2f, 0x39, 0x9d, 0x86, 0x7e, 0xd7, 0x7b, 0xf8, 0xc8, 0x9b, 0xf6, 0x16, 0x4, 0x49, 0xa3, 0x4e, 0xa7, 0x8a, 0xb7, 0xd9, 0x92, 0x80, 0x1, 0xfd, 0x8d, 0xde, 0x94, 0xf3, 0xc, 0x8c, 0xbd, 0xee, 0x4d, 0x6, 0xfb, 0xa1, 0x50, 0x85, 0x2e, 0xc2, 0x55, 0xc6, 0x9c, 0x59, 0xd, 0x7, 0xb5, 0xa8, 0x3, 0x70, 0x7e, 0x11, 0xa0, 0xef, 0x68, 0x9c, 0xee, 0xa9, 0xdc, 0xe, 0xf8, 0x80, 0x9a, 0xf6, 0x85, 0xe4, 0x8b, 0x79, 0xb4, 0x33, 0x7c, 0x75, 0x6b, 0xe, 0x56, 0x7d, 0x3b, 0xec, 0x43, 0xb4, 0x43, 0x1e, 0x86, 0xb7, 0x9d, 0x65, 0x22, 0xc5, 0x6d, 0xc3, 0x18, 0x2, 0xb7, 0x68, 0x93, 0xd5, 0x48, 0xf8, 0xf8, 0x51, 0xd7, 0x69, 0x6d, 0x8f, 0xd8, 0xdd, 0x15, 0xf6, 0x2, 0x53, 0x16, 0x3f, 0x83, 0x35, 0xb9, 0x89, 0x7c, 0x47, 0x7e, 0x6d, 0x4c, 0x74, 0x3b, 0xe2, 0x2b, 0x1d, 0xea, 0xff, 0x90, 0x69, 0x33, 0x37, 0xba, 0x80, 0x32, 0x97, 0x8e, 0x97, 0xbf, 0x73, 0xbd, 0x3f, 0xa1, 0xb5, 0x3a, 0x46, 0xa7, 0x79, 0xb1, 0x3c, 0xbb, 0xa4, 0x53, 0x34, 0x62, 0x34, 0xc3, 0xa6, 0x8f, 0x36, 0x9a, 0xfc, 0xdd, 0xa2, 0x3, 0xc0, 0x58, 0xe3, 0xf3, 0xa2, 0x1a, 0xdf, 0x8b, 0x7c, 0x87, 0x2c, 0x8a, 0xcd, 0xec, 0xc0, 0xc2, 0x92, 0xdc, 0xc4, 0x36, 0x38, 0xd1, 0x32, 0x6b, 0x5d, 0x2e, 0x18, 0x70, 0x53, 0x77, 0x77, 0xec, 0x8a, 0x47, 0xe6, 0x9e, 0xb5, 0x4a, 0x30, 0xf9, 0xb1, 0xae, 0x21, 0x4e, 0xd0, 0xa1, 0x45, 0x6, 0xec, 0x21, 0x8b, 0x5, 0xcc, 0x44, 0x8, 0x6f, 0x65, 0x30, 0x48, 0xd7, 0xe0, 0x69, 0x49, 0xd6, 0x1, 0x7b, 0xdc, 0xc7, 0x71, 0x39, 0x83, 0xb6, 0xea, 0x9d, 0xd7, 0xd7, 0x93, 0x65, 0x43, 0x1d, 0xfe, 0xca, 0x3a, 0xf4, 0xf6, 0xcf, 0x1e, 0xfa, 0x18, 0xad, 0x23, 0xb7, 0x16, 0x81, 0x4f, 0x61, 0x4e, 0xd2, 0xa2, 0x2a, 0x5d, 0x8b, 0x37, 0x7f, 0x44, 0x2f, 0x2c, 0x40, 0x2d, 0xe0, 0x5c, 0xc8, 0xc2, 0xdb, 0xaa, 0x50, 0x76, 0x13, 0x3e, 0x9, 0x5, 0xff, 0x84, 0x3d, 0x64, 0x54, 0x5a, 0x74, 0x9, 0x71, 0x1e, 0x15, 0x63, 0x7, 0x1c, 0x5d, 0x48, 0xe2, 0xae, 0x76, 0x5a, 0xfd, 0xba, 0xa8, 0x4c, 0x24, 0x99, 0xfa, 0xc8, 0xf1, 0x84, 0x8d, 0xb6, 0x5b, 0x74, 0x57, 0x76, 0xa4, 0x92, 0x11, 0xd0},
+               output224: []byte{0xf6, 0x2e, 0xd9, 0xff, 0x9d, 0x91, 0xda, 0xa0, 0x54, 0xc2, 0x59, 0x27, 0xa1, 0xea, 0x4c, 0x85, 0x3e, 0xd9, 0xb3, 0xca, 0x63, 0xfe, 0xa7, 0x8a, 0x67, 0x12, 0x13, 0xe6},
+               output256: []byte{0xfb, 0xf2, 0xfb, 0xa4, 0x5d, 0x6f, 0x2, 0xbc, 0xfa, 0x87, 0x88, 0xc4, 0x43, 0x70, 0x11, 0x4, 0xfe, 0xc7, 0xc8, 0x17, 0x0, 0xaa, 0xf2, 0xd0, 0x31, 0x11, 0x32, 0x95, 0x8e, 0x1b, 0xa5, 0x7f},
+               output384: []byte{0xc8, 0xaa, 0x4a, 0xaa, 0x57, 0xd5, 0x24, 0x1a, 0xbf, 0xa4, 0xb4, 0x98, 0x64, 0xa, 0x36, 0x5d, 0x98, 0x76, 0x82, 0xcf, 0x66, 0xa0, 0xdd, 0x23, 0x59, 0xb8, 0x23, 0x92, 0x1b, 0x94, 0x62, 0x35, 0x65, 0x69, 0xc9, 0x66, 0xfc, 0x39, 0x11, 0xec, 0xfc, 0x40, 0xa7, 0x14, 0xed, 0xd2, 0xb3, 0x58},
+               output512: []byte{0x31, 0x6, 0x1c, 0x59, 0xc5, 0xc6, 0xc, 0x55, 0xf0, 0xd3, 0x3e, 0xa7, 0x74, 0x94, 0x94, 0x7e, 0x6f, 0xdb, 0x71, 0xe8, 0x4e, 0x3c, 0x20, 0x7, 0xaf, 0xf1, 0x25, 0x7a, 0xda, 0x79, 0x71, 0xd, 0x41, 0x6b, 0x3a, 0x71, 0xa4, 0x10, 0x8f, 0x31, 0x89, 0xe2, 0x89, 0x8a, 0x19, 0x12, 0x47, 0xf0, 0xf2, 0xe0, 0x2c, 0xb9, 0xf2, 0x1a, 0x93, 0x3d, 0x14, 0x5, 0xb1, 0x55, 0xd9, 0xab, 0x33, 0x32}},
+       testcase{
+               msg:       []byte{0xb8, 0xb2, 0x7e, 0xf9, 0x41, 0x79, 0x2b, 0xd6, 0x81, 0x97, 0x47, 0x43, 0x2c, 0xb8, 0x44, 0xd1, 0x1d, 0x32, 0x75, 0xe2, 0x35, 0xd6, 0xa0, 0x48, 0x42, 0xd0, 0xea, 0x1b, 0xe5, 0xa7, 0x27, 0xe, 0x3d, 0x32, 0x92, 0x4d, 0x2f, 0x74, 0xde, 0xb9, 0xac, 0x5a, 0x86, 0x91, 0x61, 0x7a, 0x1c, 0xbc, 0x10, 0x46, 0xa5, 0xab, 0x8f, 0x89, 0xa6, 0xe5, 0xa8, 0x4e, 0x7c, 0xf3, 0xb3, 0x19, 0xb0, 0xef, 0xe2, 0x19, 0x28, 0xaa, 0x0, 0xdf, 0x31, 0xfe, 0xd3, 0x4e, 0x2f, 0xce, 0x50, 0x76, 0x10, 0xf, 0xd3, 0x84, 0x27, 0x3d, 0xc5, 0xb3, 0xed, 0x56, 0x7, 0x9a, 0xdc, 0x94, 0x8e, 0x47, 0x91, 0x9e, 0x8c, 0xe5, 0xdc, 0xe4, 0x47, 0x26, 0xf9, 0x36, 0x88, 0x54, 0xd5, 0xeb, 0x7e, 0xa9, 0xdf, 0x44, 0x45, 0xf4, 0xe9, 0xa3, 0xea, 0x55, 0x65, 0x24, 0x4, 0xb7, 0x1e, 0x16, 0xcf, 0xf4, 0x5e, 0x40, 0x7c, 0x8e, 0x86, 0xa5, 0x6b, 0x4d, 0x23, 0x28, 0xaf, 0x7d, 0xc9, 0xa1, 0x1c, 0x74, 0x90, 0xd0, 0x2d, 0xda, 0xd8, 0xbc, 0x81, 0x31, 0x6b, 0xc, 0x70, 0xc2, 0xe0, 0xbd, 0xf3, 0xc4, 0xbf, 0xdf, 0xf2, 0xc6, 0x61, 0x39, 0x95, 0x31, 0xe1, 0x34, 0xa5, 0x99, 0xf9, 0xc2, 0xf8, 0xb5, 0x39, 0x72, 0x85, 0xef, 0x54, 0x47, 0x90, 0x3c, 0xb, 0x43, 0xa5, 0xad, 0xd9, 0x6c, 0xd5, 0xc6, 0x88, 0x92, 0x9d, 0xc, 0x5, 0xb5, 0x7b, 0x5c, 0x46, 0x32, 0x8a, 0x4b, 0xd, 0x85, 0x1, 0xdc, 0xcc, 0xd6, 0xb0, 0xd2, 0x2f, 0x1c, 0xbb, 0x40, 0xf9, 0xf, 0xb3, 0xd2, 0x83, 0x38, 0xef, 0x4e, 0x1c, 0xed, 0x2d, 0xd5, 0x6c, 0xb5, 0x69, 0xee, 0x63, 0xa1, 0x4a, 0x54, 0x20, 0x17, 0x6b, 0x2f, 0x1f, 0x8f, 0xa1, 0xb3, 0x92, 0x96, 0xad, 0x88, 0xb5, 0x2e, 0x7d, 0x3d, 0x13, 0xae, 0x6, 0x66, 0x68, 0xe6, 0x8, 0x35, 0xa0, 0x4a, 0xe8, 0x15, 0xd4, 0x81, 0x42, 0x8a, 0x5d, 0x39, 0xdf, 0x18, 0xe6, 0x7c, 0x4f, 0xe0, 0xf3, 0x27, 0x7c, 0xd7, 0x42, 0x73, 0xb5, 0xf7, 0x8f, 0x9f, 0xcb, 0x93, 0xd7, 0xe, 0xcc, 0xf9, 0x76, 0x47, 0x98, 0x82, 0x7b, 0xf4, 0xd6, 0xcf, 0xa8, 0xee, 0xb6, 0x85, 0xa7, 0x69, 0xce, 0xf9, 0x64, 0xfd, 0xa3, 0xe1, 0xe1, 0x3c, 0x96, 0x66, 0xe, 0xb0, 0xe1, 0x85, 0x1e, 0x30, 0xf1, 0xec, 0x4b, 0x9d, 0x91, 0x5c, 0x6b, 0x62, 0x2, 0x4, 0xa7, 0xf0, 0x98, 0x8a, 0xd3, 0x99, 0x8, 0x14, 0xa0, 0x95, 0xdc, 0xeb, 0x3e, 0xba, 0x9b, 0x70, 0x23, 0xf2, 0x33, 0x7b, 0x9, 0xb3, 0x26, 0x8d, 0xf4, 0x1c, 0xb5, 0xc7, 0x21, 0xdf, 0x9a, 0x28, 0x51, 0x85, 0x83, 0xb1, 0x1, 0x17, 0x63, 0xab, 0xe6, 0x23, 0x77, 0xcc, 0xaa, 0x5b, 0x32, 0x77, 0x47, 0x5a, 0x9c, 0xf7, 0x2e, 0x36, 0xb0, 0x7b, 0xbe, 0x8f, 0x2e, 0x2b, 0xd, 0x2f, 0xe2, 0x6e, 0x8b, 0x81, 0xa5, 0xb0, 0x4a, 0xd6, 0xbd, 0xc, 0xb8, 0xc8, 0xc, 0xc3, 0x59, 0xc4, 0xeb, 0x38, 0xea, 0x25, 0x5, 0x77, 0xd2, 0xd0, 0x6d, 0x14, 0xcc, 0xcd, 0x76, 0x1e, 0xe, 0x51, 0xc8, 0x30, 0x78, 0x51, 0x7a, 0x50, 0xa, 0x81, 0xc, 0xf0, 0x84, 0xa, 0x9f, 0xe5, 0x2f, 0x41, 0x5f, 0x96, 0xea, 0x1d, 0x16, 0x44, 0xfe, 0x3e, 0x81, 0x82, 0x3b, 0xc2, 0x19, 0x60, 0x51, 0xda, 0x58, 0x19, 0x31, 0x64, 0x61, 0x93, 0x66, 0x6e, 0x0, 0xeb, 0x80, 0x3, 0xa1, 0xdb, 0x1f, 0x95, 0xe0, 0xd4, 0x16, 0x5d, 0x8, 0x4d, 0x58, 0x91, 0x15, 0x3b, 0x6f, 0x27, 0xb1, 0x57, 0xce, 0xd6, 0x67, 0x5a, 0xdf, 0xc5, 0x37, 0x77, 0x84, 0x3b, 0x1f, 0x33, 0xa4, 0x33, 0x7a, 0x2d, 0xa2, 0x39, 0x5b, 0xfa, 0x28, 0xb, 0xe7, 0x11, 0xf3, 0xcb, 0xa2, 0xa9, 0x61, 0xb6, 0x1, 0x1e, 0xdc, 0xa3, 0x5c, 0x57, 0xdc, 0x20, 0xd9, 0x26, 0x98, 0x2e, 0x20, 0x74, 0x24, 0x3d, 0x64, 0x4f, 0xe6, 0xc, 0x76, 0xae, 0x70, 0xab, 0x1e, 0x2d, 0x90, 0x4c, 0x3b, 0xa6, 0x8d, 0x8d, 0xc7, 0xb5, 0x81, 0x35, 0x65, 0xf1, 0x46, 0x1e, 0x52, 0xd4, 0x62, 0x53, 0xde, 0xb1, 0x87, 0xf6, 0x9, 0x59, 0x2b, 0x1e, 0x92, 0xe0, 0x62, 0xa8, 0xae, 0xd5, 0x76, 0xca, 0x33, 0x81, 0xb7, 0x62, 0x5c, 0x2e, 0x84, 0xb3, 0xef, 0x93, 0xa3, 0x38, 0xb9, 0x7d, 0x69, 0x93, 0x77, 0xe9, 0x96, 0x19, 0xa1, 0x16, 0xee, 0xf9, 0xeb, 0xf0, 0x5a, 0x7f, 0x3e, 0xaa, 0x96, 0xf3, 0x2b, 0x6b, 0x49, 0x1a, 0x2a, 0xa7, 0x85, 0x30, 0x3a, 0xe0, 0x35, 0x52, 0x31, 0x1b, 0x11, 0x3b, 0x6e, 0x8, 0xf2, 0xe1, 0x8f, 0x60, 0xd7, 0x19, 0x80, 0x35, 0xd2, 0xc8, 0xa6, 0x0, 0xd9, 0xc5, 0x72, 0x25, 0x1b, 0x54, 0x2a, 0xdb, 0x19, 0x8c, 0x3b, 0x5b, 0x59, 0x78, 0xe0, 0x93, 0x93, 0x27, 0x4d, 0x9, 0x79, 0x7b, 0xf2, 0xac, 0xc0, 0xcb, 0xe6, 0xc9, 0xe5, 0x1, 0xa3, 0xc6, 0x7a, 0x3c, 0x54, 0xb8, 0xbc, 0xc1, 0x69, 0xa6, 0x8a, 0x38, 0x89, 0xff, 0x5c, 0x2, 0x5, 0x97, 0x62, 0x77, 0x1e, 0xa9, 0xb8, 0x7b, 0x74, 0x84, 0xb4, 0x60, 0x4b, 0x20, 0xe1, 0xd3, 0x24, 0xf4, 0x8b, 0xc, 0x80, 0x7d, 0xcd, 0x88, 0x59, 0x7, 0x0, 0x31, 0x87, 0x69, 0x6a, 0xb, 0xbd, 0xbe, 0x5f, 0xa0, 0xb0, 0xb3, 0x73, 0x45, 0xf, 0xc4, 0x40, 0xf6, 0x98, 0x96, 0x7b, 0xaa, 0xb6, 0x7b, 0x62, 0x1d, 0x83, 0x46, 0xcc, 0x43, 0x46, 0x2b, 0x17, 0x1d, 0xe, 0x2e, 0x71, 0xd, 0x69, 0x6e, 0xc0, 0x5d, 0xfd, 0x51, 0x57, 0x8d, 0x62, 0x44, 0x37, 0x5a, 0xc6, 0xed, 0x69, 0x56, 0x82, 0x23, 0xf1, 0x7a, 0x67, 0xbd, 0xb1, 0x8c, 0x86, 0xaa, 0x9a, 0x98, 0x2b, 0x72, 0x69, 0xfd, 0x4, 0xe2, 0x78, 0xb9, 0xef, 0x1f, 0x37, 0x96, 0x86, 0xcd, 0x5b, 0x6f, 0x5e, 0xea, 0xd9, 0x1b, 0xf7, 0xd8, 0x54, 0x7e, 0xe8, 0x68, 0xd7, 0x1b, 0x6e, 0x7, 0xe9, 0x7, 0xe8, 0x88, 0x30, 0x18, 0xb2, 0x63, 0x80, 0xa1, 0x6e, 0x77, 0x9a, 0x3a, 0x86, 0x48, 0x3c, 0xcd, 0x67, 0x84, 0x73, 0xc3, 0x18, 0x38, 0xa0, 0x4e, 0x1a, 0xef, 0x78, 0x79, 0x37, 0x88, 0x33, 0xd, 0x16, 0x2d, 0x1a, 0xdb, 0xf9, 0xe0, 0xcb, 0x15, 0x51, 0xfc, 0x14, 0xec, 0xb8, 0x73, 0x56, 0xc6, 0x2e, 0xe1, 0x7f, 0x95, 0xd3, 0x8a, 0x63, 0x49, 0x17, 0xdd, 0x3a, 0x63, 0xc0, 0x7c, 0xd5, 0x93, 0x24, 0x19, 0x8d, 0x3f, 0xe6, 0xeb, 0x4a, 0xbd, 0x92, 0x8d, 0x78, 0xd8, 0xcf, 0xd9, 0xd0, 0x5b, 0x74, 0xf4, 0x4f, 0x69, 0x1c, 0x8c, 0xc3, 0x53, 0x3f, 0xac, 0x92, 0x6e, 0xcb, 0xf, 0xfa, 0x98, 0x9f, 0x50, 0x4a, 0x9d, 0xc7, 0x9c, 0xf8, 0x6f, 0x39, 0x52, 0x5a, 0x8d, 0xd3, 0xee, 0xcc, 0x4f, 0xd4, 0x84, 0x2f, 0xae, 0x92, 0xb0, 0x2c, 0xff, 0x25, 0xdd, 0xe9, 0xb0, 0x80, 0x14, 0xc3, 0x71, 0xf4, 0x1d, 0xf2, 0x26, 0x23, 0x52, 0x53, 0xb9, 0xb3, 0x6e, 0x1e, 0xa8, 0xc7, 0xe8, 0xf0, 0x81, 0xdc, 0xe, 0x95, 0x89, 0x91, 0x51, 0x5e, 0xea, 0x8, 0x55, 0xce, 0x7b, 0xdf, 0x3f, 0x2e, 0xfb, 0x1, 0x83, 0x16, 0x32, 0xc5, 0x5e, 0x6, 0x5a, 0x2e, 0xc4, 0xd1, 0x60, 0x48, 0x40, 0x73, 0x96, 0xb2, 0xdd, 0xc2, 0x33, 0xfa, 0x4, 0x22, 0xf8, 0x33, 0x94, 0x6a, 0xc3, 0x2c, 0xe1, 0x43, 0x20, 0x82, 0x0, 0x51, 0xd5, 0xa6, 0x8a, 0x76, 0x95, 0x85, 0x41, 0x67, 0x26, 0x4a, 0x64, 0x15, 0xbc, 0x7, 0x8d, 0xc3, 0x7c, 0x71, 0x7c, 0x83, 0xed, 0x78, 0x79, 0xd7, 0x76, 0xfd, 0x85, 0x99, 0xa7, 0x1f, 0x99, 0x9d, 0xd5, 0xaa, 0x2a, 0x53, 0xe9, 0xb6, 0xa3, 0x8c, 0xc1, 0x77, 0x5, 0x8f, 0x7a, 0x14, 0x7b, 0x6e, 0x4, 0x3b, 0x2b, 0x5a, 0xe5, 0x1, 0xd, 0x1, 0x7d, 0x32, 0x78, 0x5, 0xc8, 0x58, 0x61, 0x30, 0x81, 0xab, 0x49, 0x43, 0x98, 0x1c, 0xb7, 0x45, 0x74, 0x26, 0xb7, 0xa8, 0x57, 0xd2, 0xfe, 0xfa, 0x6, 0x3d, 0xfb, 0x65, 0x59, 0x97, 0x3, 0x64, 0x37, 0xd1, 0x8d, 0x82, 0x3, 0xf6, 0x8d, 0x89, 0xff, 0x56, 0x60, 0xd3, 0x10, 0xcb, 0x99, 0xf5, 0xca, 0x37, 0x8a, 0x9f, 0xb8, 0xf, 0xd8, 0x48, 0x52, 0xa0, 0x59, 0x1f, 0xe, 0x41, 0x31, 0x11, 0x0, 0xd1, 0x68, 0xac, 0x78, 0x67, 0xe5, 0x4d, 0x5c, 0x69, 0x38, 0xd7, 0x27, 0x23, 0xf2, 0x20, 0x16, 0xc9, 0x62, 0xeb, 0xaa, 0x67, 0x36, 0x8a, 0x17, 0x3c, 0xac, 0xa2, 0x65, 0x57, 0xb2, 0x76, 0xa2, 0x9e, 0xd4, 0x69, 0x7a, 0xfb, 0x6a, 0xe9, 0xbe, 0x48, 0xd7, 0xc4, 0x11, 0xa9, 0x17, 0x79, 0x85, 0xce, 0x34, 0xc0, 0xc1, 0xbc, 0x1f, 0xf8, 0x7d, 0x47, 0x68, 0x76, 0x70, 0x5d, 0x31, 0x57, 0xa7, 0x89, 0xb4, 0xf0, 0xa7, 0xdb, 0x6c, 0x27, 0x2e, 0xf4, 0xaf, 0x61, 0x4b, 0xd4, 0x21, 0x2, 0x9c, 0xf7, 0x4f, 0xd1, 0x7f, 0xf1, 0xb8, 0x2d, 0xb1, 0x90, 0xca, 0x13, 0xf0, 0x2e, 0x60, 0xa6, 0xf2, 0xb2, 0x61, 0xaa, 0x4f, 0xdf, 0xf7, 0x4e, 0x2d, 0xea, 0xb1, 0x82, 0x22, 0xc6, 0x74, 0xff, 0xed, 0x71, 0x1e, 0xf8, 0x87, 0xf7, 0xe4, 0xe6, 0x5, 0xe3, 0x24, 0x1b, 0x75, 0x1c, 0x58, 0x1e, 0x96, 0xe8, 0xb9, 0x18, 0x97, 0x4e, 0x90, 0x2, 0x2f, 0x8, 0x6e, 0xf, 0x92, 0xb6, 0x3f, 0xd7, 0x96, 0x3d, 0xc1, 0xd0, 0xf5, 0xca, 0xfa, 0x1e, 0xb9, 0xdf, 0x69, 0xc3, 0x2b, 0x9d, 0x1b, 0xde, 0x99, 0xe8, 0x91, 0x93, 0xb9, 0x74, 0xd4, 0x14, 0x53, 0xef, 0xd3, 0x67, 0x83, 0xf9, 0x2b, 0xf2, 0xcb, 0xe1, 0xef, 0x6d, 0xc5, 0x6e, 0xa2, 0xe, 0xe9, 0xac, 0x1f, 0x3a, 0x74, 0x35, 0xdc, 0xc2, 0x1a, 0x20, 0x66, 0xc6, 0x3b, 0x74, 0x63, 0x43, 0xe5, 0x65, 0x18, 0x2a, 0x94, 0x1c, 0xd2, 0x29, 0x98, 0xaa, 0x34, 0x13, 0x8, 0x8a, 0xd2, 0x80, 0x11, 0x20, 0xf5, 0x62, 0xf6, 0x4b, 0x7a, 0xf5, 0x5d, 0x3c, 0x66, 0x21, 0xba, 0x13, 0x1, 0xee, 0xed, 0x65, 0x26, 0x61, 0xbc, 0x22, 0x18, 0x4b, 0xdb, 0x9a, 0x9a, 0xea, 0xb6, 0x7c, 0xb1, 0x8d, 0x85, 0x61, 0x2e, 0x7d, 0x8f, 0x7a, 0xa2, 0xf7, 0xd2, 0xa6, 0xb3, 0xc4, 0x54, 0x5b, 0x40, 0x51, 0x7a, 0x4a, 0x74, 0xcb, 0xf, 0xbd, 0x46, 0x10, 0xaf, 0x86, 0x87, 0xbd, 0x69, 0x29, 0xdd, 0xef, 0x85, 0xc0, 0xf7, 0x4c, 0x66, 0xdb, 0xf6, 0x4a, 0x83, 0xbe, 0x10, 0x77, 0xec, 0xab, 0xc, 0x5e, 0xc9, 0x29, 0x91, 0xc6, 0xb8, 0x65, 0x2b, 0xda, 0x8e, 0x6c, 0x8, 0x8b, 0xe, 0xba, 0x61, 0xc9, 0x0, 0x61, 0x58, 0xb4, 0x8f, 0x88, 0xd8, 0x25, 0x7a, 0xd3, 0xf, 0x7a, 0xa5, 0xf, 0xa0, 0xed, 0xfa, 0x2, 0x5f, 0xbb, 0x70, 0x28, 0xbb, 0x97, 0x83, 0x96, 0x71, 0x4b, 0xcd, 0xc2, 0x62, 0x22, 0x90, 0xf9, 0x7, 0xb8, 0x42, 0x47, 0xb7, 0xb, 0x71, 0xaa, 0xf6, 0x8, 0x31, 0x5d, 0xdf, 0xc7, 0x8c, 0x9a, 0xe4, 0x29, 0x71, 0x95, 0xeb, 0x95, 0x6a, 0x79, 0x90, 0x89, 0x1d, 0x5c, 0x83, 0xda, 0x71, 0xd4, 0x5c, 0x8e, 0xc9, 0x37, 0x9e, 0xee, 0xe0, 0xf8, 0xf0, 0x1a, 0x29, 0xcb, 0xb5, 0x8b, 0x41, 0xec, 0x75, 0xd9, 0x5, 0xc7, 0x7a, 0xe5, 0x33, 0xc5, 0x12, 0x2b, 0x90, 0x7b, 0x6d, 0x2c, 0x6e, 0x4f, 0x42, 0x3f, 0x69, 0x14, 0xc5, 0x8d, 0x1, 0xb, 0xd4, 0xf2, 0x6b, 0xef, 0x38, 0x23, 0x58, 0x7c, 0x95, 0xc7, 0xbb, 0x86, 0x70, 0xca, 0x75, 0x12, 0xe8, 0xd7, 0x22, 0x36, 0x19, 0xcc, 0xd9, 0xb8, 0x8c, 0x61, 0x58, 0xb1, 0x50, 0xb, 0x92, 0x23, 0xae, 0x31, 0xbe, 0x27, 0xd5, 0x9, 0xdd, 0xee, 0x72, 0xbb, 0x1c, 0x29, 0x8e, 0x30, 0x8c, 0x46, 0xcd, 0xdb, 0x93, 0xe5, 0x0, 0xa0, 0xb5, 0x4b, 0x41, 0x81, 0x3b, 0xba, 0x52, 0x8e, 0xc1, 0xf8, 0xfd, 0x6e, 0x7, 0xf, 0x73, 0xe0, 0x28, 0x9a, 0xf5, 0x34, 0x67, 0xc, 0x8d, 0x2d, 0xdc, 0x98, 0xe9, 0x5f, 0xee, 0x6b, 0x39, 0xf3, 0xf3, 0x68, 0x10, 0x12, 0xb5, 0xbe, 0x2, 0x8c, 0x3c, 0xfe, 0x7b, 0x2d, 0xa5, 0xd7, 0xef, 0xf3, 0xff, 0x35, 0x2b, 0x64, 0x50, 0xeb, 0x47, 0x10, 0xee, 0x54, 0x89, 0x9d, 0x9a, 0x9, 0xb0, 0xf2, 0xd1, 0xa, 0x8b, 0xb1, 0x77, 0xbc, 0x30, 0xea, 0xd3, 0x8c, 0xd2, 0x99, 0x33, 0xa7, 0x15, 0x60, 0x8e, 0x62, 0x5d, 0x35, 0xd9, 0x19, 0xab, 0xcc, 0xbb, 0x58, 0xf7, 0xc2, 0x3a, 0x4, 0x7f, 0xec, 0xf9, 0xa9, 0x22, 0x69, 0x30, 0x43, 0x8e, 0x30, 0xf2, 0x62, 0x18, 0x7c, 0x7f, 0xc7, 0xaa, 0x87, 0x2c, 0x36, 0x51, 0xc6, 0x32, 0x47, 0x9c, 0x26, 0x87, 0x77, 0x7e, 0x15, 0x22, 0x58, 0x97, 0x2f, 0xa4, 0xfa, 0xa6, 0x76, 0x33, 0x86, 0x2b, 0xd2, 0x42, 0x32, 0x48, 0x43, 0xd, 0x1f, 0x44, 0x45, 0x65, 0xac, 0x1a, 0x6a, 0x39, 0xd9, 0x15, 0x36, 0xe0, 0x3, 0x66, 0x7d, 0x88, 0xdf, 0x89, 0xd9, 0xd1, 0xcf, 0x90, 0x94, 0x51, 0xc4, 0xfc, 0xe3, 0x55, 0x6b, 0x25, 0x10, 0x1e, 0x88, 0x7f, 0xa8, 0xed, 0x5a, 0xa8, 0xd6, 0xfc, 0x2d, 0xa1, 0x4c, 0xf3, 0x79, 0xa5, 0x4e, 0x3d, 0xa7, 0x98, 0x7f, 0xf2, 0xc8, 0x11, 0xda, 0xd, 0xe4, 0x86, 0x25, 0xbc, 0x8c, 0x4d, 0xc3, 0x45, 0xc4, 0xd1, 0x95, 0xec, 0xed, 0xe0, 0xd1, 0x8a, 0xc3, 0x70, 0x9b, 0x4b, 0x6a, 0x8a, 0xea, 0x78, 0xa9, 0x79, 0xa6, 0x46, 0x2c, 0xc0, 0xf1, 0x94, 0x43, 0x9, 0x6e, 0x39, 0x2b, 0x3e, 0x14, 0x26, 0x90, 0x16, 0x3c, 0xa2, 0x8f, 0x1, 0xbd, 0x60, 0x69, 0x58, 0xf6, 0xa5, 0x11, 0xaf, 0x5b, 0x19, 0x1f, 0xf, 0x37, 0x37, 0x3f, 0xb4, 0x51, 0xe2, 0x8e, 0xeb, 0xe2, 0x71, 0xe6, 0x31, 0xce, 0x1f, 0xaf, 0x9, 0x56, 0x6d, 0x8c, 0x6e, 0x1d, 0x4b, 0xb3, 0x89, 0x68, 0x78, 0x58, 0x29, 0x66, 0x7e, 0x37, 0x53, 0x87, 0x12, 0x30, 0x6a, 0x69, 0xce, 0x67, 0xdd, 0x50, 0x2f, 0x1, 0xca, 0xd3, 0x56, 0xa, 0xb6, 0x96, 0xfc, 0x2a, 0x51, 0x44, 0xb5, 0x53, 0xfc, 0x44, 0xb5, 0xf1, 0xba, 0xe4, 0x64, 0xb, 0x13, 0x47, 0xa9, 0x9c, 0xe9, 0x8e, 0x22, 0x4f, 0x88, 0x10, 0x98, 0x3d, 0x64, 0x15, 0x4a, 0x7f, 0xf5, 0xcc, 0xab, 0xc1, 0x38, 0xe4, 0xc4, 0x22, 0x57, 0xdc, 0x2b, 0x5e, 0x56, 0x91, 0xfc, 0xe4, 0xbf, 0x4a, 0x88, 0x96, 0x5a, 0xa3, 0x46, 0x8, 0x71, 0xa6, 0xea, 0xa3},
+               output224: []byte{0x88, 0xf4, 0x69, 0x98, 0x92, 0xc2, 0x1e, 0x5, 0x64, 0x5a, 0x3, 0x5a, 0xe6, 0x62, 0x59, 0xd4, 0x46, 0xaf, 0xba, 0xa2, 0x2e, 0x35, 0x2a, 0xe1, 0x8f, 0x66, 0x8c, 0x9e},
+               output256: []byte{0xa3, 0xba, 0xd4, 0x19, 0x5, 0xd8, 0xd5, 0x9, 0x95, 0x1e, 0xbe, 0xcc, 0xf3, 0x14, 0x8d, 0x52, 0x34, 0xd3, 0x98, 0x7b, 0x34, 0x84, 0x42, 0x70, 0xdc, 0xe8, 0x15, 0x8f, 0x15, 0x4, 0x51, 0x1e},
+               output384: []byte{0x92, 0xce, 0x8d, 0xbe, 0xab, 0xa7, 0x35, 0x97, 0x51, 0x93, 0x9f, 0x3b, 0x5c, 0x8f, 0xa6, 0xdf, 0x41, 0xc2, 0xe5, 0x4b, 0x42, 0x86, 0x41, 0xac, 0xa9, 0x1e, 0x41, 0xeb, 0x52, 0xc5, 0x8d, 0x41, 0xe1, 0x34, 0x84, 0xa7, 0x41, 0x43, 0xaa, 0xd5, 0x45, 0xc8, 0xfe, 0x62, 0xf, 0xb7, 0xfa, 0x72},
+               output512: []byte{0x39, 0x20, 0x5e, 0x6d, 0xff, 0x23, 0x16, 0xf0, 0x0, 0xa6, 0xe8, 0x2d, 0x56, 0x3e, 0x79, 0xa9, 0x2, 0x72, 0x80, 0xa5, 0xef, 0xbd, 0x6e, 0xf2, 0x46, 0x43, 0x62, 0xcf, 0xc9, 0x3f, 0xe, 0x25, 0xfd, 0xa2, 0xc6, 0x11, 0xd, 0x40, 0x45, 0x1a, 0x63, 0x52, 0xf9, 0x5e, 0x32, 0xb6, 0x66, 0x20, 0x42, 0x7e, 0x3a, 0x95, 0x9e, 0x21, 0x55, 0xa1, 0x46, 0x97, 0xc0, 0x75, 0x61, 0x18, 0x5e, 0xae}},
+       testcase{
+               msg:       []byte{0xfb, 0xb3, 0x6a, 0x6d, 0x35, 0xfa, 0x8c, 0x1, 0x74, 0xbf, 0x87, 0xfd, 0x3c, 0x23, 0x2d, 0x1f, 0x60, 0x59, 0xb8, 0xc4, 0x3c, 0xbd, 0x71, 0x6, 0xae, 0xa4, 0x6, 0xca, 0x2e, 0xfd, 0xca, 0xbe, 0xcf, 0x3b, 0x5, 0xdb, 0x8a, 0xe5, 0x3c, 0xf9, 0x8e, 0x86, 0x6d, 0xfc, 0x5e, 0xe7, 0x14, 0xea, 0x3c, 0x55, 0x58, 0x2, 0xf7, 0x51, 0x55, 0x98, 0x56, 0xb, 0xb3, 0x5e, 0xf, 0xb, 0x26, 0xd5, 0xf5, 0x1b, 0x81, 0xfd, 0xce, 0x91, 0x4e, 0x36, 0x51, 0xc2, 0x19, 0x51, 0xcc, 0x45, 0xdb, 0x3b, 0x48, 0x8, 0x21, 0xe4, 0x16, 0x54, 0x36, 0x8b, 0x32, 0x59, 0xe9, 0x53, 0x50, 0x16, 0x21, 0xfa, 0x54, 0x91, 0x14, 0xd8, 0xa, 0x53, 0x4f, 0xee, 0x58, 0x3a, 0xd6, 0x1d, 0x68, 0x1c, 0x4f, 0xe4, 0x2, 0x92, 0x5d, 0x3b, 0xc7, 0x2a, 0x7a, 0x63, 0xd0, 0x42, 0xcf, 0x5, 0x1e, 0xa2, 0xfb, 0xd2, 0xb1, 0x10, 0x1, 0x7d, 0x31, 0x21, 0x8f, 0xa0, 0xbd, 0xa8, 0x42, 0x86, 0x46, 0x57, 0x40, 0xd5, 0x49, 0xf7, 0x3, 0x54, 0x92, 0xb2, 0xc0, 0xa2, 0x82, 0x54, 0x4c, 0xc5, 0x36, 0xb8, 0xe4, 0xeb, 0x86, 0x95, 0x43, 0x7d, 0x60, 0x38, 0xb1, 0x3f, 0x91, 0x25, 0xf8, 0xc4, 0x79, 0x9c, 0xea, 0xf8, 0x53, 0x39, 0x53, 0xe, 0x47, 0x8a, 0xe2, 0xec, 0xd4, 0xff, 0x90, 0x9b, 0xab, 0x84, 0x9a, 0x18, 0xcd, 0xd7, 0x75, 0xb6, 0x75, 0x88, 0x8, 0x14, 0x1b, 0x94, 0xf1, 0xa2, 0x43, 0xbc, 0xa4, 0x98, 0x1c, 0x9d, 0x4b, 0x7a, 0x29, 0xce, 0x53, 0xa2, 0xc1, 0x7c, 0x3e, 0x62, 0xe6, 0x57, 0xbf, 0x51, 0xb6, 0x16, 0x34, 0x2, 0xd6, 0xc3, 0x3f, 0x17, 0xfc, 0xea, 0x97, 0x9e, 0x40, 0xb0, 0xd6, 0xad, 0xaf, 0x57, 0x2a, 0x79, 0x3, 0xa, 0xac, 0x63, 0xe0, 0x2e, 0x99, 0x31, 0xb, 0x13, 0x3b, 0xc0, 0x7, 0xaa, 0xc9, 0xfc, 0x85, 0x64, 0x20, 0xa, 0x9b, 0xbb, 0xa0, 0xf5, 0xb1, 0x22, 0x8b, 0x7d, 0x9e, 0x86, 0x9d, 0xd8, 0x24, 0x31, 0x95, 0x68, 0xce, 0xee, 0xd7, 0xa9, 0xc8, 0x7e, 0x5a, 0x5c, 0x20, 0xa6, 0xf6, 0x58, 0x79, 0x15, 0xd, 0x8d, 0x27, 0x9f, 0x13, 0x76, 0x96, 0xe, 0x80, 0xa6, 0xe1, 0xcc, 0x92, 0x9b, 0x30, 0x40, 0x67, 0x65, 0xba, 0xe9, 0x7b, 0x22, 0xd0, 0x8e, 0x2, 0x25, 0xbc, 0x32, 0xe, 0xb5, 0x0, 0x4d, 0xb4, 0xf4, 0x64, 0x8e, 0x6b, 0x8f, 0x8f, 0x1f, 0xf1, 0x31, 0x82, 0xd1, 0xb2, 0x8, 0x38, 0xca, 0xf6, 0x9b, 0x5, 0x4e, 0x72, 0xdf, 0x7, 0xe3, 0xe5, 0xc5, 0x3c, 0x66, 0x92, 0x81, 0xe2, 0x27, 0xa1, 0x3f, 0xf0, 0xf6, 0x35, 0x5, 0x78, 0xf2, 0xe2, 0x57, 0xd9, 0xa2, 0xdb, 0xbe, 0x67, 0x3f, 0x8d, 0x46, 0x66, 0xf3, 0xfe, 0x6b, 0x46, 0xe0, 0x7, 0xa0, 0x8d, 0x4c, 0x79, 0xfc, 0xcd, 0x4c, 0x82, 0x44, 0xde, 0xf3, 0xda, 0x4b, 0x86, 0x19, 0xb2, 0x38, 0x9f, 0xc7, 0x9d, 0x5c, 0x15, 0x43, 0x2b, 0x67, 0x21, 0x21, 0xff, 0x14, 0xb5, 0x87, 0x42, 0xdc, 0xd5, 0x65, 0xec, 0x5e, 0xac, 0x78, 0xb, 0xb8, 0x83, 0x2d, 0xa1, 0x6c, 0x33, 0x7, 0xb8, 0xe6, 0x3d, 0x41, 0x50, 0xe, 0x61, 0x8c, 0x8f, 0xa9, 0xee, 0x7, 0x7f, 0x4a, 0x98, 0x23, 0x68, 0x9, 0xca, 0xa3, 0xf3, 0xdf, 0xfc, 0xea, 0x6e, 0xec, 0x7d, 0xc3, 0x76, 0x22, 0x6c, 0x80, 0xc5, 0xb1, 0xdf, 0x3e, 0xc1, 0x61, 0xc9, 0x99, 0x3d, 0xef, 0x39, 0x3, 0xd5, 0x42, 0xeb, 0xec, 0x84, 0x4c, 0x2e, 0x7e, 0x69, 0xfc, 0x21, 0x5b, 0xc5, 0x9f, 0xe8, 0x6d, 0x5e, 0x98, 0xf9, 0x8e, 0x3b, 0x82, 0x37, 0xd5, 0x4c, 0xb2, 0xc2, 0x8b, 0x41, 0x47, 0x0, 0xe1, 0xe9, 0x77, 0xb1, 0x45, 0xc7, 0x68, 0x30, 0x1e, 0x78, 0xb9, 0x31, 0x1, 0x19, 0xbe, 0xad, 0xf6, 0x95, 0xa0, 0x5c, 0x50, 0x9d, 0x95, 0x86, 0x3c, 0x42, 0x36, 0xa3, 0xb9, 0x9c, 0x19, 0x97, 0xec, 0x73, 0x9e, 0xf4, 0xf3, 0xd7, 0x4d, 0xad, 0x5f, 0xdc, 0x66, 0xe4, 0x94, 0xea, 0xc4, 0x63, 0x84, 0x48, 0x74, 0xd6, 0xa9, 0xad, 0xba, 0x89, 0x1c, 0x61, 0x7a, 0x9f, 0x98, 0xd8, 0x30, 0xfb, 0xe, 0x24, 0xcc, 0x9, 0xb7, 0x1, 0x14, 0xb3, 0x2c, 0xf2, 0x42, 0xb7, 0xc1, 0x10, 0x71, 0x5f, 0x29, 0x58, 0x21, 0x95, 0x96, 0xe0, 0xaa, 0xcc, 0xab, 0x5d, 0xca, 0x7a, 0xeb, 0x2c, 0x16, 0x49, 0x35, 0x8d, 0xd9, 0x58, 0x17, 0xeb, 0x35, 0xce, 0xf4, 0xdf, 0x99, 0x72, 0x42, 0xec, 0xf3, 0x87, 0xd6, 0xa0, 0x61, 0x49, 0xe6, 0xb4, 0x66, 0x12, 0x3, 0x62, 0x75, 0x16, 0x81, 0x2d, 0x74, 0x72, 0xb4, 0xd3, 0xf0, 0x5f, 0x1a, 0xa2, 0x0, 0xd5, 0x99, 0x2, 0x1, 0xe9, 0x7d, 0xa0, 0xf3, 0xd3, 0xac, 0xc8, 0x13, 0x77, 0x75, 0x2c, 0x7b, 0x94, 0x55, 0xb5, 0x91, 0xab, 0x6b, 0x46, 0xaf, 0xe8, 0xdb, 0xde, 0x73, 0x2a, 0x96, 0x64, 0xa4, 0x21, 0x75, 0xc2, 0x9, 0x89, 0xb5, 0xa3, 0x7, 0x20, 0x9f, 0x64, 0xb0, 0xf2, 0xaa, 0x0, 0xbd, 0x29, 0x7f, 0x8e, 0xb7, 0x2e, 0xca, 0x72, 0x55, 0xb9, 0x9f, 0x7, 0x29, 0x8b, 0x1c, 0x59, 0xe3, 0xd4, 0x13, 0x32, 0x7e, 0xf9, 0x94, 0xeb, 0xcc, 0xae, 0xd1, 0xd9, 0x86, 0x50, 0xa, 0xd2, 0xde, 0x59, 0x15, 0x90, 0x8d, 0xbe, 0xaf, 0xa0, 0x4, 0x98, 0xfa, 0x37, 0x4e, 0xed, 0x25, 0x37, 0xe0, 0x45, 0x5e, 0xc5, 0x6, 0xf, 0x8c, 0xbc, 0xa7, 0x70, 0x29, 0xcf, 0x2f, 0x21, 0xb0, 0xd2, 0xef, 0x29, 0x95, 0x2, 0x22, 0x94, 0x7d, 0x3b, 0x92, 0x6b, 0xcd, 0xaf, 0x61, 0x61, 0x5f, 0x73, 0xf0, 0x19, 0x5e, 0xbf, 0x18, 0x9c, 0xbf, 0xbd, 0x25, 0x7, 0x5e, 0x6c, 0x70, 0x64, 0xa, 0x81, 0xe6, 0x4c, 0x36, 0xb5, 0x42, 0x32, 0xcd, 0x76, 0xef, 0x24, 0xae, 0xcd, 0x8e, 0x61, 0x9f, 0x65, 0x2a, 0xff, 0xaa, 0x27, 0xa3, 0x9f, 0xec, 0x7e, 0xf7, 0xdf, 0x3b, 0x6c, 0x9d, 0x3, 0xb5, 0x1c, 0x9, 0x75, 0xec, 0xc0, 0xce, 0x4c, 0x9, 0xca, 0x29, 0xf5, 0x63, 0x80, 0xf0, 0xb2, 0xb2, 0x93, 0x32, 0x1e, 0xca, 0x37, 0xa6, 0x67, 0x5f, 0x43, 0xcc, 0x7d, 0x7a, 0x4a, 0x19, 0x6d, 0x3d, 0x11, 0xac, 0xa3, 0x5a, 0x54, 0xec, 0xa6, 0xd, 0xb9, 0x65, 0xee, 0x1d, 0xb7, 0x9, 0x5d, 0x48, 0x1f, 0x1f, 0x27, 0x6f, 0x6a, 0xb4, 0xc0, 0xb3, 0x73, 0x98, 0xc7, 0x6e, 0xd4, 0xa5, 0xcf, 0x2b, 0xb7, 0xb9, 0xc4, 0x1, 0xe2, 0x68, 0x6f, 0xf8, 0x67, 0x8a, 0xc6, 0xc1, 0xd1, 0x41, 0xc3, 0xa4, 0xd, 0x41, 0xc4, 0x4b, 0x3f, 0x29, 0x33, 0xdd, 0x4b, 0x25, 0x8e, 0xdb, 0x45, 0xdb, 0x56, 0x75, 0x98, 0x4e, 0x68, 0x80, 0xc3, 0x92, 0x7d, 0xd5, 0x8, 0x7f, 0x94, 0xe1, 0x22, 0x28, 0x3f, 0xb7, 0x6c, 0xf, 0x62, 0x2b, 0x67, 0x14, 0x77, 0xb2, 0xc5, 0x35, 0x19, 0x3d, 0x1f, 0x43, 0x30, 0xec, 0x9, 0xcd, 0xa0, 0x3a, 0x1e, 0x4c, 0xcd, 0x1a, 0x6, 0x44, 0x7e, 0x7, 0x8a, 0xb7, 0xa3, 0x7e, 0x34, 0xe5, 0x4c, 0x2e, 0xd, 0x91, 0x15, 0x93, 0xff, 0x52, 0x2e, 0xd9, 0x4b, 0x5f, 0xfc, 0x14, 0xe6, 0x2f, 0xd2, 0x1d, 0x0, 0xd7, 0xe5, 0xbc, 0xbe, 0xc5, 0x19, 0xd, 0x5a, 0x40, 0x61, 0x5f, 0xf6, 0x47, 0x40, 0xa1, 0xd3, 0x1d, 0xc, 0xdd, 0x7, 0xe3, 0x9b, 0xbb, 0x4f, 0x61, 0x5a, 0x4a, 0x3, 0x45, 0xaf, 0x40, 0xd0, 0x64, 0x7f, 0x35, 0x4f, 0x96, 0xff, 0x2a, 0xf3, 0xef, 0xbe, 0x25, 0xb9, 0xe3, 0x8e, 0x1c, 0x55, 0x50, 0x96, 0x8a, 0x18, 0xbe, 0x6d, 0xa2, 0x52, 0xa5, 0xbc, 0x86, 0x1c, 0xfe, 0x2d, 0x9c, 0xe8, 0x4f, 0x56, 0xb0, 0x7, 0x1c, 0xba, 0xd9, 0x37, 0xc9, 0x47, 0xc5, 0x8d, 0x3, 0x1, 0xe5, 0x1d, 0xd1, 0xc3, 0x14, 0x6f, 0x78, 0x10, 0xd7, 0x95, 0x20, 0x4b, 0xc0, 0xc7, 0xfb, 0x71, 0xf9, 0x62, 0x24, 0xbe, 0x40, 0x9f, 0xf7, 0x32, 0xe1, 0x4d, 0xb1, 0xc2, 0xcd, 0xab, 0xa7, 0xcc, 0x74, 0x6c, 0x4f, 0xee, 0xd8, 0x29, 0xa7, 0x7, 0x7f, 0x48, 0xc7, 0xf4, 0x66, 0xd1, 0xec, 0xc, 0x89, 0xe3, 0xe2, 0x47, 0xd1, 0x5a, 0x4a, 0x63, 0x11, 0x4e, 0xa1, 0xe6, 0xfd, 0x85, 0x5c, 0x98, 0xcd, 0x78, 0x70, 0xce, 0xfc, 0x75, 0xec, 0xc8, 0x11, 0x4f, 0x11, 0x35, 0xa1, 0x54, 0xd, 0xe6, 0xa8, 0xe1, 0xc0, 0x5c, 0x9d, 0x6d, 0xc5, 0x54, 0xa6, 0xb0, 0x8e, 0x86, 0xc8, 0x15, 0x8e, 0xb3, 0xd8, 0x44, 0xc5, 0x34, 0x8a, 0x61, 0xd5, 0x4a, 0x65, 0x59, 0xb0, 0xb7, 0xf4, 0xbc, 0x59, 0x25, 0x58, 0x20, 0xa, 0x28, 0x9c, 0xcc, 0xf3, 0x9a, 0xa3, 0x8, 0x78, 0x23, 0x70, 0xb2, 0x98, 0x1c, 0xb5, 0xee, 0x5, 0x7, 0x10, 0xe0, 0x12, 0xd4, 0xf5, 0x8a, 0x9d, 0x1e, 0x2e, 0xb, 0x9d, 0xd5, 0xa3, 0x53, 0x24, 0x55, 0xfb, 0xcc, 0x1d, 0xba, 0xbd, 0xf0, 0x41, 0xf0, 0xe7, 0xb9, 0xdb, 0xac, 0x80, 0x5a, 0x50, 0x38, 0x32, 0xdf, 0x59, 0xb2, 0x9d, 0xd, 0x1d, 0xd6, 0xe7, 0x5e, 0x73, 0x5d, 0xf9, 0x8, 0x2b, 0x45, 0x8d, 0xd1, 0x9, 0x20, 0xc2, 0xcb, 0x72, 0xca, 0x4a, 0xe2, 0x8b, 0x63, 0x81, 0x57, 0x85, 0x65, 0x6a, 0x7b, 0xd8, 0x97, 0xf1, 0x43, 0x63, 0x93, 0x78, 0xd, 0xac, 0x60, 0x4, 0xf6, 0x8a, 0x74, 0x5b, 0x23, 0x59, 0x13, 0xc5, 0x36, 0xdb, 0xd5, 0xc2, 0x3e, 0xac, 0xc6, 0xba, 0xe6, 0x35, 0xc9, 0x49, 0xef, 0xdd, 0x29, 0x41, 0xd9, 0xf1, 0xa9, 0x3e, 0xd9, 0x44, 0x18, 0x4, 0x27, 0xff, 0x57, 0xd0, 0xae, 0x76, 0xa5, 0xd5, 0x84, 0x43, 0xf, 0xa0, 0x31, 0xd8, 0x96, 0x98, 0x83, 0xe0, 0x9e, 0x85, 0x3e, 0x6a, 0x29, 0x92, 0x1d, 0x70, 0x21, 0x4b, 0xbe, 0x2f, 0x74, 0x77, 0xcc, 0xc9, 0xf1, 0x6d, 0x18, 0xef, 0x69, 0x11, 0x9, 0x1d, 0x2e, 0x62, 0xa8, 0xc0, 0x5, 0x67, 0xb8, 0x31, 0xfc, 0x79, 0xce, 0x5d, 0xd6, 0x5a, 0x95, 0x30, 0x4f, 0xb7, 0xb0, 0xc5, 0x6c, 0xd4, 0xd7, 0xfe, 0xf1, 0x5d, 0xe5, 0xfb, 0xd1, 0x9e, 0x31, 0x2e, 0xf7, 0x6c, 0x58, 0xc6, 0x76, 0x45, 0x0, 0x3b, 0xf0, 0xa5, 0x56, 0x10, 0xf7, 0xa6, 0xc, 0x7d, 0x7c, 0x54, 0x18, 0xee, 0x4, 0xc4, 0x5f, 0xfb, 0xdf, 0x3d, 0x9c, 0x3c, 0x79, 0x2a, 0x5e, 0x92, 0x97, 0x9d, 0x6f, 0x8d, 0x19, 0x98, 0xc0, 0xa, 0x2, 0xc, 0xf, 0x19, 0x74, 0xbb, 0x86, 0x73, 0x35, 0x28, 0x8f, 0x0, 0x6d, 0xd0, 0xe9, 0x73, 0xa3, 0x76, 0xf3, 0x53, 0xac, 0xd, 0x97, 0x64, 0x69, 0x24, 0xc1, 0xb3, 0x5c, 0x27, 0x4e, 0x6a, 0xd1, 0x10, 0x3a, 0x1b, 0xde, 0xce, 0xe5, 0x3d, 0x2c, 0xde, 0x46, 0x86, 0xbd, 0x6a, 0xab, 0x94, 0x7, 0xa5, 0x68, 0xc7, 0xe0, 0x29, 0xb8, 0x65, 0x57, 0x61, 0x7c, 0x26, 0x15, 0x90, 0x38, 0x42, 0x59, 0xb3, 0x9, 0x3e, 0x0, 0x98, 0xf1, 0x1c, 0x17, 0xde, 0x72, 0x10, 0x11, 0x3d, 0x58, 0x6b, 0x46, 0x24, 0xc2, 0xe0, 0x52, 0xae, 0x67, 0x38, 0xef, 0x10, 0xcc, 0xcc, 0x72, 0x8f, 0x2a, 0xe1, 0x11, 0x45, 0x8e, 0x5f, 0xa1, 0xa9, 0x3e, 0xa3, 0xa5, 0x94, 0xe0, 0x3a, 0xa1, 0xc6, 0x5e, 0x54, 0x71, 0xf2, 0x4f, 0x3b, 0x8a, 0xa1, 0x26, 0xc3, 0x85, 0x6, 0x2a, 0x2f, 0xbc, 0x2a, 0xe2, 0xf2, 0x95, 0x18, 0x74, 0xbb, 0xb6, 0x4e, 0x2, 0xf3, 0x0, 0x9a, 0x57, 0x59, 0x41, 0xd4, 0x23, 0x5b, 0x6, 0xc1, 0xfe, 0x45, 0x1a, 0x82, 0x5c, 0xe9, 0x1b, 0xe5, 0x9b, 0xab, 0x85, 0xda, 0x91, 0x64, 0x5e, 0xe, 0x2b, 0x8c, 0xe3, 0x74, 0xdf, 0xb0, 0x54, 0xa4, 0x8, 0x9, 0xf2, 0x6d, 0xb0, 0xae, 0xc5, 0x34, 0xab, 0x5c, 0xc2, 0x7e, 0x27, 0x47, 0x7f, 0x1c, 0x1a, 0x72, 0x9f, 0x2c, 0xc0, 0xc1, 0x1f, 0xc5, 0x14, 0x17, 0xb7, 0x14, 0x43, 0xb6, 0x57, 0xfd, 0x79, 0xda, 0x80, 0x7b, 0xb0, 0x1c, 0xd0, 0x1b, 0x3, 0x6c, 0x67, 0x37, 0x25, 0x8e, 0x60, 0xda, 0x37, 0x6d, 0xf0, 0x80, 0x89, 0xf4, 0x10, 0x56, 0xfc, 0x45, 0x40, 0x44, 0xe0, 0xf1, 0xd1, 0x73, 0xa7, 0xe6, 0xf1, 0x13, 0x55, 0x85, 0x1d, 0x36, 0x62, 0x6a, 0x4c, 0x3e, 0x89, 0x72, 0x1f, 0xe6, 0x59, 0xbf, 0x58, 0xb7, 0x2e, 0x41, 0x1b, 0x1, 0x5b, 0xf1, 0x33, 0x96, 0xb2, 0x69, 0x14, 0x2c, 0x57, 0x6a, 0x59, 0x76, 0xab, 0x35, 0x2e, 0x17, 0x8, 0xc1, 0x90, 0x8c, 0x43, 0xd8, 0x73, 0x96, 0x4a, 0x9, 0x77, 0x21, 0xa6, 0x4, 0x85, 0x0, 0x2f, 0x46, 0x75, 0xc5, 0xa5, 0xf5, 0x82, 0xed, 0x4b, 0xc7, 0x78, 0x6e, 0xeb, 0x2d, 0x49, 0x23, 0x2d, 0xad, 0xd6, 0x64, 0x9b, 0xd9, 0xce, 0xc3, 0x2d, 0x69, 0x1, 0xea, 0x5c, 0xda, 0x7b, 0xa8, 0x38, 0x81, 0x7d, 0xb8, 0xc0, 0xaf, 0xc2, 0x54, 0xb9, 0x4e, 0x4a, 0xa3, 0x9c, 0x6, 0x71, 0xec, 0x45, 0xca, 0xc7, 0xa, 0x73, 0xbd, 0xc7, 0x7e, 0x82, 0x1c, 0xd8, 0xba, 0xa7, 0x7d, 0xf6, 0xed, 0xf, 0x3f, 0x79, 0x38, 0x6d, 0xe1, 0xfd, 0x7d, 0x7d, 0x81, 0xae, 0x7e, 0x5, 0xdb, 0x6d, 0x1d, 0x9c, 0xce, 0x8f, 0x42, 0xed, 0x4f, 0xfb, 0x1a, 0x7f, 0xbe, 0xc6, 0x29, 0x84, 0xde, 0xa7, 0x4c, 0x94, 0x80, 0x94, 0x5e, 0xb9, 0x16, 0x75, 0x2e, 0xc9, 0xe0, 0x60, 0x68, 0x15, 0xf8, 0xd5, 0x77, 0x9c, 0xee, 0xfd, 0x2d, 0xf4, 0x97, 0x75, 0xa1, 0xca, 0x29, 0x46, 0x5a, 0xc9, 0x78, 0x39, 0x44, 0xa0, 0x61, 0x72, 0x79, 0x30, 0x3a, 0xb8, 0x6c, 0x2a, 0xee, 0xb1, 0xab, 0x4e, 0xf1, 0xff, 0xf7, 0x46, 0x5e, 0xa6, 0x85, 0x1, 0x9, 0xd7, 0x70, 0xc9, 0x90, 0xb8, 0x42, 0xa0, 0xa5, 0xdb, 0xb1, 0xcc, 0x14, 0xea, 0x49, 0x47, 0xa3, 0x56, 0x67, 0x8f, 0xda, 0x4e, 0xc4, 0x4f, 0xc9, 0xd8, 0xfa, 0x35, 0x2a, 0x54, 0x6a, 0x24, 0x85, 0xf8, 0x42, 0xa6, 0xbf, 0xac, 0x20, 0xde, 0xb0, 0x45, 0x87, 0x62, 0xa7, 0x2d, 0xd4, 0xa0, 0x39, 0xd6, 0x4a, 0xd8, 0x48, 0x5d, 0x9f, 0x1c, 0x4d, 0x67, 0xeb, 0xb8, 0x7b, 0x99, 0xfa, 0x95, 0xcd, 0x5b, 0x38, 0xdf, 0x8e, 0x32, 0xcb, 0x6e, 0xff, 0x14, 0x1, 0xd0, 0xd2, 0xcd, 0x20, 0xa7, 0xdb, 0xbc, 0x39, 0x77, 0xb0, 0x85, 0x4e, 0xb9, 0xf9, 0x45, 0x51, 0x1, 0x25, 0x46, 0x43, 0x0, 0xc9, 0x15, 0x77, 0xb2, 0x1b, 0x6a, 0xa, 0x61, 0x34, 0x13, 0x79, 0xd1, 0xf1, 0xe1, 0x59, 0x37, 0xc4, 0xea, 0xc4, 0x35, 0xd0, 0x5b, 0xe9, 0x28, 0x2f, 0x63, 0x2f, 0x84, 0xc2, 0xae, 0x12, 0x90, 0xc6, 0xde, 0x6c, 0xa6, 0xc5, 0xab, 0xae, 0x90, 0xa6, 0xc9, 0xf3, 0x73, 0x21, 0x96, 0x6c, 0xd3, 0x3d, 0x86, 0xc6, 0x27, 0x5c, 0x1, 0x8f, 0xd2, 0xc1, 0x5a, 0xec, 0x46, 0xc0, 0x95, 0xac, 0xc, 0xd5, 0x15, 0x93, 0xcf, 0xb6, 0x46, 0xe8, 0xa5, 0xf8},
+               output224: []byte{0x86, 0x89, 0xce, 0x87, 0x86, 0x4b, 0x65, 0x86, 0x6e, 0x50, 0xae, 0x81, 0x73, 0xbf, 0x9f, 0xde, 0x1e, 0x6c, 0x0, 0xf5, 0xd, 0x27, 0x99, 0xf5, 0xaf, 0x77, 0xed, 0x4f},
+               output256: []byte{0x54, 0x21, 0x6e, 0x68, 0xa6, 0xbb, 0xdd, 0xd2, 0x78, 0x27, 0xd5, 0xfc, 0xa1, 0x1b, 0x1, 0x10, 0xff, 0xa8, 0x9d, 0x78, 0x96, 0xe5, 0x91, 0x4d, 0x57, 0x49, 0x5b, 0xd2, 0xc3, 0x9e, 0x94, 0x95},
+               output384: []byte{0x53, 0xcc, 0xe2, 0xb5, 0x93, 0xe0, 0xd1, 0xfa, 0xbd, 0x91, 0xb6, 0x2e, 0x33, 0x49, 0x15, 0x66, 0xf9, 0x5d, 0xa2, 0x10, 0x6a, 0xda, 0xed, 0x5, 0x5e, 0x1, 0x6, 0x15, 0xc9, 0x3f, 0x7, 0x34, 0xcd, 0x27, 0x79, 0x21, 0x23, 0xc3, 0xf4, 0x3f, 0x44, 0xa9, 0x4f, 0xd5, 0x2d, 0x5e, 0xca, 0x97},
+               output512: []byte{0xf7, 0x15, 0xdd, 0xae, 0x51, 0xac, 0xe7, 0xb5, 0xbb, 0xd9, 0x13, 0x32, 0x98, 0x4a, 0x92, 0x17, 0xb3, 0x39, 0xfa, 0xc4, 0xc1, 0xc7, 0xb1, 0x76, 0x18, 0xf5, 0xa, 0xf, 0x2d, 0x16, 0xd8, 0x6a, 0xe3, 0x85, 0x66, 0x64, 0x65, 0x4, 0x6, 0x5f, 0x67, 0xcd, 0xf3, 0xc6, 0xc8, 0xe4, 0xc8, 0xf6, 0x5f, 0x7d, 0x73, 0xd6, 0xf3, 0x81, 0x23, 0xf2, 0x5d, 0xe0, 0x45, 0x90, 0x7b, 0x51, 0x2f, 0x46}},
+       testcase{
+               msg:       []byte{0x6e, 0x1c, 0xad, 0xfb, 0x2a, 0x14, 0xc5, 0xff, 0xb1, 0xdd, 0x69, 0x91, 0x9c, 0x1, 0x24, 0xed, 0x1b, 0x9a, 0x41, 0x4b, 0x2b, 0xea, 0x1e, 0x5e, 0x42, 0x2d, 0x53, 0xb0, 0x22, 0xbd, 0xd1, 0x3a, 0x9c, 0x88, 0xe1, 0x62, 0x97, 0x2e, 0xbb, 0x98, 0x52, 0x33, 0x0, 0x6, 0xb1, 0x3c, 0x5b, 0x2f, 0x2a, 0xfb, 0xe7, 0x54, 0xab, 0x7b, 0xac, 0xf1, 0x24, 0x79, 0xd4, 0x55, 0x8d, 0x19, 0xdd, 0xbb, 0x1a, 0x62, 0x89, 0x38, 0x7b, 0x3a, 0xc0, 0x84, 0x98, 0x1d, 0xf3, 0x35, 0x33, 0xd, 0x15, 0x70, 0x85, 0xb, 0x97, 0x20, 0x3d, 0xba, 0x5f, 0x20, 0xcf, 0x7f, 0xf2, 0x17, 0x75, 0x36, 0x7a, 0x84, 0x1, 0xb6, 0xeb, 0xe5, 0xb8, 0x22, 0xed, 0x16, 0xc3, 0x93, 0x83, 0x23, 0x20, 0x3, 0xab, 0xc4, 0x12, 0xb0, 0xce, 0xd, 0xd7, 0xc7, 0xda, 0x6, 0x4e, 0x4b, 0xb7, 0x3e, 0x8c, 0x58, 0xf2, 0x22, 0xa1, 0x51, 0x2d, 0x5f, 0xe6, 0xd9, 0x47, 0x31, 0x6e, 0x2, 0xf8, 0xaa, 0x87, 0xe7, 0xaa, 0x7a, 0x3a, 0xa1, 0xc2, 0x99, 0xd9, 0x2e, 0x64, 0x14, 0xae, 0x3b, 0x92, 0x7d, 0xb8, 0xff, 0x70, 0x8a, 0xc8, 0x6a, 0x9, 0xb2, 0x4e, 0x18, 0x84, 0x74, 0x3b, 0xc3, 0x40, 0x67, 0xbb, 0x4, 0x12, 0x45, 0x3b, 0x4a, 0x6a, 0x65, 0x9, 0x50, 0x4b, 0x55, 0xf, 0x53, 0xd5, 0x18, 0xe4, 0xbc, 0xc3, 0xd9, 0xc1, 0xef, 0xdb, 0x33, 0xda, 0x2e, 0xac, 0xcb, 0x84, 0xc9, 0xf1, 0xca, 0xec, 0x81, 0x5, 0x7a, 0x85, 0x8, 0xf4, 0x23, 0xb2, 0x5d, 0xb5, 0x50, 0xe, 0x5f, 0xc8, 0x6a, 0xb3, 0xb5, 0xeb, 0x10, 0xd6, 0xd0, 0xbf, 0x3, 0x3a, 0x71, 0x6d, 0xde, 0x55, 0xb0, 0x9f, 0xd5, 0x34, 0x51, 0xbb, 0xea, 0x64, 0x42, 0x17, 0xae, 0x1e, 0xf9, 0x1f, 0xad, 0x2b, 0x5d, 0xcc, 0x65, 0x15, 0x24, 0x9c, 0x96, 0xee, 0x7e, 0xab, 0xfd, 0x12, 0xf1, 0xef, 0x65, 0x25, 0x6b, 0xd1, 0xcf, 0xf2, 0x8, 0x7d, 0xab, 0xf2, 0xf6, 0x9a, 0xd1, 0xff, 0xb9, 0xcf, 0x3b, 0xc8, 0xca, 0x43, 0x7c, 0x7f, 0x18, 0xb6, 0x9, 0x5b, 0xc0, 0x8d, 0x65, 0xdf, 0x99, 0xcc, 0x7f, 0x65, 0x7c, 0x41, 0x8d, 0x8e, 0xb1, 0x9, 0xfd, 0xc9, 0x1a, 0x13, 0xdc, 0x20, 0xa4, 0x38, 0x94, 0x17, 0x26, 0xef, 0x24, 0xf9, 0x73, 0x8b, 0x65, 0x52, 0x75, 0x1a, 0x32, 0xc, 0x4e, 0xa9, 0xc8, 0xd7, 0xe8, 0xe8, 0x59, 0x2a, 0x3b, 0x69, 0xd3, 0xa, 0x41, 0x9c, 0x55, 0xfb, 0x6c, 0xb0, 0x85, 0x9, 0x89, 0xc0, 0x29, 0xaa, 0xae, 0x66, 0x30, 0x5e, 0x2c, 0x14, 0x53, 0xb, 0x39, 0xea, 0xa8, 0x6e, 0xa3, 0xba, 0x2a, 0x7d, 0xec, 0xf4, 0xb2, 0x84, 0x8b, 0x1, 0xfa, 0xa8, 0xaa, 0x91, 0xf2, 0x44, 0xb, 0x7c, 0xc4, 0x33, 0x4f, 0x63, 0x6, 0x1c, 0xe7, 0x8a, 0xa1, 0x58, 0x9b, 0xef, 0xa3, 0x8b, 0x19, 0x47, 0x11, 0x69, 0x7a, 0xe3, 0xaa, 0xdc, 0xb1, 0x5c, 0x9f, 0xbf, 0x6, 0x74, 0x33, 0x15, 0xe2, 0xf9, 0x7f, 0x1a, 0x8b, 0x52, 0x23, 0x6a, 0xcb, 0x44, 0x40, 0x69, 0x55, 0xc, 0x23, 0x45, 0xf4, 0xed, 0x12, 0xe5, 0xb8, 0xe8, 0x81, 0xcd, 0xd4, 0x72, 0xe8, 0x3, 0xe5, 0xdc, 0xe6, 0x3a, 0xe4, 0x85, 0xc2, 0x71, 0x3f, 0x81, 0xbc, 0x30, 0x7f, 0x25, 0xac, 0x74, 0xd3, 0x9b, 0xaf, 0x7e, 0x3b, 0xc5, 0xe7, 0x61, 0x74, 0x65, 0xc2, 0xb9, 0xc3, 0x9, 0xcb, 0xa, 0xc0, 0xa5, 0x70, 0xa7, 0xe4, 0x6c, 0x61, 0x16, 0xb2, 0x24, 0x2e, 0x1c, 0x54, 0xf4, 0x56, 0xf6, 0x58, 0x9e, 0x20, 0xb1, 0xc0, 0x92, 0x5b, 0xf1, 0xcd, 0x5f, 0x93, 0x44, 0xe0, 0x1f, 0x63, 0xb5, 0xba, 0x9d, 0x46, 0x71, 0xab, 0xbf, 0x92, 0xc, 0x7e, 0xd3, 0x29, 0x37, 0xa0, 0x74, 0xc3, 0x38, 0x36, 0xf0, 0xe0, 0x19, 0xdf, 0xb6, 0xb3, 0x5d, 0x86, 0x53, 0x12, 0xc6, 0x5, 0x8d, 0xfd, 0xaf, 0xf8, 0x44, 0xc8, 0xd5, 0x8b, 0x75, 0x7, 0x15, 0x23, 0xe7, 0x9d, 0xfb, 0xab, 0x2e, 0xa3, 0x74, 0x79, 0xdf, 0x12, 0xc4, 0x74, 0x58, 0x4f, 0x4f, 0xf4, 0xf, 0x0, 0xf9, 0x2c, 0x6b, 0xad, 0xa0, 0x25, 0xce, 0x4d, 0xf8, 0xfa, 0xf0, 0xaf, 0xb2, 0xce, 0x75, 0xc0, 0x77, 0x73, 0x90, 0x7c, 0xa2, 0x88, 0x16, 0x7d, 0x6b, 0x1, 0x15, 0x99, 0xc3, 0xde, 0xf, 0xff, 0x16, 0xc1, 0x16, 0x1d, 0x31, 0xdf, 0x1c, 0x1d, 0xde, 0x21, 0x7c, 0xb5, 0x74, 0xed, 0x5a, 0x33, 0x75, 0x17, 0x59, 0xf8, 0xed, 0x2b, 0x1e, 0x69, 0x79, 0xc5, 0x8, 0x8b, 0x94, 0x9, 0x26, 0xb9, 0x15, 0x5c, 0x9d, 0x25, 0xb, 0x47, 0x99, 0x48, 0xc2, 0xa, 0xcb, 0x55, 0x78, 0xdc, 0x2, 0xc9, 0x75, 0x93, 0xf6, 0x46, 0xcc, 0x5c, 0x55, 0x8a, 0x6a, 0xf, 0x3d, 0x8d, 0x27, 0x32, 0x58, 0x88, 0x7c, 0xcf, 0xf2, 0x59, 0x19, 0x7c, 0xb1, 0xa7, 0x38, 0x6, 0x22, 0xe3, 0x71, 0xfd, 0x2e, 0xb5, 0x37, 0x62, 0x25, 0xec, 0x4, 0xf9, 0xed, 0x1d, 0x1f, 0x2f, 0x8, 0xfa, 0x23, 0x76, 0xdb, 0x5b, 0x79, 0xe, 0x73, 0x8, 0x6f, 0x58, 0x10, 0x64, 0xed, 0x1c, 0x5f, 0x47, 0xe9, 0x89, 0xe9, 0x55, 0xd7, 0x77, 0x16, 0xb5, 0xf, 0xb6, 0x4b, 0x85, 0x33, 0x88, 0xfb, 0xa0, 0x1d, 0xac, 0x2c, 0xea, 0xe9, 0x96, 0x42, 0x34, 0x1f, 0x2d, 0xa6, 0x4c, 0x56, 0xbe, 0xfc, 0x47, 0x89, 0xc0, 0x51, 0xe5, 0xeb, 0x79, 0xb0, 0x63, 0xf2, 0xf0, 0x84, 0xdb, 0x44, 0x91, 0xc3, 0xc5, 0xaa, 0x7b, 0x4b, 0xcf, 0x7d, 0xd7, 0xa1, 0xd7, 0xce, 0xd1, 0x55, 0x4f, 0xa6, 0x7d, 0xca, 0x1f, 0x95, 0x15, 0x74, 0x6a, 0x23, 0x75, 0x47, 0xa4, 0xa1, 0xd2, 0x2a, 0xcf, 0x64, 0x9f, 0xa1, 0xed, 0x3b, 0x9b, 0xb5, 0x2b, 0xde, 0xc, 0x69, 0x96, 0x62, 0xf, 0x8c, 0xfd, 0xb2, 0x93, 0xf8, 0xba, 0xca, 0xd0, 0x2b, 0xce, 0x42, 0x83, 0x63, 0xd0, 0xbb, 0x3d, 0x39, 0x14, 0x69, 0x46, 0x1d, 0x21, 0x27, 0x69, 0x4, 0x82, 0x19, 0x22, 0xa, 0x7e, 0xd3, 0x9d, 0x1f, 0x91, 0x57, 0xdf, 0xea, 0x3b, 0x43, 0x94, 0xca, 0x8f, 0x5f, 0x61, 0x2d, 0x9a, 0xc1, 0x62, 0xbf, 0xb, 0x96, 0x1b, 0xfb, 0xc1, 0x57, 0xe5, 0xf8, 0x63, 0xce, 0x65, 0x9e, 0xb2, 0x35, 0xcf, 0x98, 0xe8, 0x44, 0x4b, 0xc8, 0xc7, 0x88, 0xb, 0xdd, 0xcd, 0xb, 0x3b, 0x38, 0x9a, 0xaa, 0x89, 0xd5, 0xe0, 0x5f, 0x84, 0xd0, 0x64, 0x9e, 0xeb, 0xac, 0xab, 0x4f, 0x1c, 0x75, 0x35, 0x2e, 0x89, 0xf0, 0xe9, 0xd9, 0x1e, 0x4a, 0xca, 0x26, 0x44, 0x93, 0xa5, 0xd, 0x2f, 0x4a, 0xed, 0x66, 0xbd, 0x13, 0x65, 0xd, 0x1f, 0x18, 0xe7, 0x19, 0x9e, 0x93, 0x1c, 0x78, 0xae, 0xb7, 0x63, 0xe9, 0x3, 0x80, 0x74, 0x99, 0xf1, 0xcd, 0x99, 0xaf, 0x81, 0x27, 0x6b, 0x61, 0x5b, 0xe8, 0xec, 0x70, 0x9b, 0x3, 0x95, 0x84, 0xb2, 0xb5, 0x74, 0x45, 0xb0, 0x14, 0xf6, 0x16, 0x25, 0x77, 0xf3, 0x54, 0x83, 0x29, 0xfd, 0x28, 0x8b, 0x8, 0x0, 0xf9, 0x36, 0xfc, 0x5e, 0xa1, 0xa4, 0x12, 0xe3, 0x14, 0x2e, 0x60, 0x9f, 0xc8, 0xe3, 0x99, 0x88, 0xca, 0x53, 0xdf, 0x4d, 0x8f, 0xb5, 0xb5, 0xfb, 0x5f, 0x42, 0xc0, 0xa0, 0x16, 0x48, 0x94, 0x6a, 0xc6, 0x86, 0x4c, 0xfb, 0xe, 0x92, 0x85, 0x63, 0x45, 0xb0, 0x8e, 0x5d, 0xf0, 0xd2, 0x35, 0x26, 0x1e, 0x44, 0xcf, 0xe7, 0x76, 0x45, 0x6b, 0x40, 0xae, 0xf0, 0xac, 0x1a, 0xd, 0xfa, 0x2f, 0xe6, 0x39, 0x48, 0x66, 0x66, 0xc0, 0x5e, 0xa1, 0x96, 0xb0, 0xc1, 0xa9, 0xd3, 0x46, 0x43, 0x5e, 0x3, 0x96, 0x5e, 0x61, 0x39, 0xb1, 0xce, 0x10, 0x12, 0x9f, 0x8a, 0x53, 0x74, 0x5f, 0x80, 0x10, 0xa, 0x94, 0xae, 0x4, 0xd9, 0x96, 0xc1, 0x3a, 0xc1, 0x4c, 0xf2, 0x71, 0x3e, 0x39, 0xdf, 0xbb, 0x19, 0xa9, 0x36, 0xcf, 0x38, 0x61, 0x31, 0x8b, 0xd7, 0x49, 0xb1, 0xfb, 0x82, 0xf4, 0xd, 0x73, 0xd7, 0x14, 0xe4, 0x6, 0xcb, 0xeb, 0x3d, 0x92, 0xe, 0xa0, 0x37, 0xb7, 0xde, 0x56, 0x64, 0x55, 0xcc, 0xa5, 0x19, 0x80, 0xf0, 0xf5, 0x3a, 0x76, 0x2d, 0x5b, 0xf8, 0xa4, 0xdb, 0xb5, 0x5a, 0xac, 0xe, 0xdd, 0xb4, 0xb1, 0xf2, 0xae, 0xd2, 0xaa, 0x3d, 0x1, 0x44, 0x9d, 0x34, 0xa5, 0x7f, 0xde, 0x43, 0x29, 0xe7, 0xff, 0x3f, 0x6b, 0xec, 0xe4, 0x45, 0x62, 0x7, 0xa4, 0x22, 0x52, 0x18, 0xee, 0x9f, 0x17, 0x4c, 0x2d, 0xe0, 0xff, 0x51, 0xce, 0xaf, 0x2a, 0x7, 0xcf, 0x84, 0xf0, 0x3d, 0x1d, 0xf3, 0x16, 0x33, 0x1e, 0x3e, 0x72, 0x5c, 0x54, 0x21, 0x35, 0x6c, 0x40, 0xed, 0x25, 0xd5, 0xab, 0xf9, 0xd2, 0x4c, 0x45, 0x70, 0xfe, 0xd6, 0x18, 0xca, 0x41, 0x0, 0x4, 0x55, 0xdb, 0xd7, 0x59, 0xe3, 0x2e, 0x2b, 0xf0, 0xb6, 0xc5, 0xe6, 0x12, 0x97, 0xc2, 0xf, 0x75, 0x2c, 0x30, 0x42, 0x39, 0x4c, 0xe8, 0x40, 0xc7, 0x9, 0x43, 0xc4, 0x51, 0xdd, 0x55, 0x98, 0xeb, 0xe, 0x49, 0x53, 0xce, 0x26, 0xe8, 0x33, 0xe5, 0xaf, 0x64, 0xfc, 0x10, 0x7, 0xc0, 0x44, 0x56, 0xd1, 0x9f, 0x87, 0xe4, 0x56, 0x36, 0xf4, 0x56, 0xb7, 0xdc, 0x9d, 0x31, 0xe7, 0x57, 0x62, 0x2e, 0x27, 0x39, 0x57, 0x33, 0x42, 0xde, 0x75, 0x49, 0x7a, 0xe1, 0x81, 0xaa, 0xe7, 0xa5, 0x42, 0x57, 0x56, 0xc8, 0xe2, 0xa7, 0xee, 0xf9, 0x18, 0xe5, 0xc6, 0xa9, 0x68, 0xae, 0xfe, 0x92, 0xe8, 0xb2, 0x61, 0xbb, 0xfe, 0x93, 0x6b, 0x19, 0xf9, 0xe6, 0x9a, 0x3c, 0x90, 0x9, 0x40, 0x96, 0xda, 0xe8, 0x96, 0x45, 0xe, 0x15, 0x5, 0xed, 0x58, 0x28, 0xee, 0x2a, 0x7f, 0xe, 0xa3, 0xa2, 0x8e, 0x6e, 0xc4, 0x7c, 0xa, 0xf7, 0x11, 0x82, 0x3e, 0x76, 0x89, 0x16, 0x6e, 0xa0, 0x7e, 0xca, 0x0, 0xff, 0xc4, 0x93, 0x13, 0x1d, 0x65, 0xf9, 0x3a, 0x4e, 0x1d, 0x3, 0xe0, 0x35, 0x4a, 0xfc, 0x21, 0x15, 0xcf, 0xb8, 0xd2, 0x3d, 0xae, 0x8c, 0x6f, 0x96, 0x89, 0x10, 0x31, 0xb2, 0x32, 0x26, 0xb8, 0xbc, 0x82, 0xf1, 0xa7, 0x3d, 0xaa, 0x5b, 0xb7, 0x40, 0xfc, 0x8c, 0xc3, 0x6c, 0x9, 0x75, 0xbe, 0xfa, 0xc, 0x78, 0x95, 0xa9, 0xbb, 0xc2, 0x61, 0xed, 0xb7, 0xfd, 0x38, 0x41, 0x3, 0x96, 0x8f, 0x7a, 0x18, 0x35, 0x3d, 0x5f, 0xe5, 0x62, 0x74, 0xe4, 0x51, 0x57, 0x68, 0xe4, 0x35, 0x30, 0x46, 0xc7, 0x85, 0x26, 0x7d, 0xe0, 0x1e, 0x81, 0x6a, 0x28, 0x73, 0xf9, 0x7a, 0xad, 0x3a, 0xb4, 0xd7, 0x23, 0x4e, 0xbf, 0xd9, 0x83, 0x27, 0x16, 0xf4, 0x3b, 0xe8, 0x24, 0x5c, 0xf0, 0xb4, 0x40, 0x8b, 0xa0, 0xf0, 0xf7, 0x64, 0xce, 0x9d, 0x24, 0x94, 0x7a, 0xb6, 0xab, 0xdd, 0x98, 0x79, 0xf2, 0x4f, 0xcf, 0xf1, 0x0, 0x78, 0xf5, 0x89, 0x4b, 0xd, 0x64, 0xf6, 0xa8, 0xd3, 0xea, 0x3d, 0xd9, 0x2a, 0xc, 0x38, 0x60, 0x9d, 0x3c, 0x14, 0xfd, 0xc0, 0xa4, 0x40, 0x64, 0xd5, 0x1, 0x92, 0x6b, 0xe8, 0x4b, 0xf8, 0x3, 0x4f, 0x1d, 0x7a, 0x8c, 0x5f, 0x38, 0x2e, 0x69, 0x89, 0xbf, 0xfa, 0x21, 0x9, 0xd4, 0xfb, 0xc5, 0x6d, 0x1f, 0x9, 0x1e, 0x8b, 0x6f, 0xab, 0xff, 0x4, 0xd2, 0x1b, 0xb1, 0x96, 0x56, 0x92, 0x9d, 0x19, 0xde, 0xcb, 0x8e, 0x82, 0x91, 0xe6, 0xae, 0x55, 0x37, 0xa1, 0x69, 0x87, 0x4e, 0xf, 0xe9, 0x89, 0xd, 0xff, 0x11, 0xff, 0xd1, 0x59, 0xad, 0x23, 0xd7, 0x49, 0xfb, 0x9e, 0x8b, 0x67, 0x6e, 0x2c, 0x31, 0x31, 0x3c, 0x16, 0xd1, 0xef, 0xa0, 0x6f, 0x4d, 0x7b, 0xc1, 0x91, 0x28, 0xa, 0x4e, 0xe6, 0x30, 0x49, 0xfc, 0xef, 0x23, 0x4, 0x2b, 0x20, 0x30, 0x3a, 0xec, 0xdd, 0x41, 0x2a, 0x52, 0x6d, 0x7a, 0x53, 0xf7, 0x60, 0xa0, 0x89, 0xfb, 0xdf, 0x13, 0xf3, 0x61, 0x58, 0x6f, 0xd, 0xca, 0x76, 0xbb, 0x92, 0x8e, 0xdb, 0x41, 0x93, 0x1d, 0x11, 0xf6, 0x79, 0x61, 0x9f, 0x94, 0x8a, 0x6a, 0x9e, 0x8d, 0xba, 0x91, 0x93, 0x27, 0x76, 0x90, 0x6, 0x30, 0x3c, 0x6e, 0xf8, 0x41, 0x43, 0x8a, 0x72, 0x55, 0xc8, 0x6, 0x24, 0x2e, 0x2e, 0x7f, 0xf4, 0x62, 0x1b, 0xb0, 0xf8, 0xaf, 0xa0, 0xb4, 0xa2, 0x48, 0xea, 0xd1, 0xa1, 0xe9, 0x46, 0xf3, 0xe8, 0x26, 0xfb, 0xfb, 0xbf, 0x80, 0x13, 0xce, 0x5c, 0xc8, 0x14, 0xe2, 0xf, 0xef, 0x21, 0xfa, 0x5d, 0xb1, 0x9e, 0xc7, 0xff, 0xb, 0x6, 0xc5, 0x92, 0x24, 0x7b, 0x27, 0xe5, 0x0, 0xeb, 0x47, 0x5, 0xe6, 0xc3, 0x7d, 0x41, 0xd0, 0x9e, 0x83, 0xcb, 0xa, 0x61, 0x80, 0x8, 0xca, 0x1a, 0xaa, 0xe8, 0xa2, 0x15, 0x17, 0x1d, 0x81, 0x76, 0x59, 0x6, 0x3c, 0x2f, 0xa3, 0x85, 0xcf, 0xa3, 0xc1, 0x7, 0x8d, 0x5c, 0x2b, 0x28, 0xce, 0x73, 0x12, 0x87, 0x6a, 0x27, 0x67, 0x73, 0x82, 0x1b, 0xe1, 0x45, 0x78, 0x5d, 0xff, 0x24, 0xbb, 0xb2, 0x4d, 0x59, 0x6, 0x78, 0x15, 0x8a, 0x61, 0xea, 0x49, 0xf2, 0xbe, 0x56, 0xfd, 0xac, 0x8c, 0xe7, 0xf9, 0x4b, 0x5, 0xd6, 0x2f, 0x15, 0xad, 0xd3, 0x51, 0xe5, 0x93, 0xf, 0xd4, 0xf3, 0x1b, 0x3e, 0x74, 0x1, 0xd5, 0xc0, 0xff, 0x7f, 0xc8, 0x45, 0xb1, 0x65, 0xfb, 0x6a, 0xba, 0xfd, 0x47, 0x88, 0xa8, 0xb0, 0x61, 0x5f, 0xec, 0x91, 0x9, 0x2b, 0x34, 0xb7, 0x10, 0xa6, 0x8d, 0xa5, 0x18, 0x63, 0x16, 0x22, 0xba, 0x2a, 0xae, 0x5d, 0x19, 0x1, 0xd, 0x30, 0x7e, 0x56, 0x5a, 0x16, 0x1e, 0x64, 0xa4, 0x31, 0x9a, 0x6b, 0x26, 0x1f, 0xb2, 0xf6, 0xa9, 0x5, 0x33, 0x99, 0x7b, 0x1a, 0xec, 0x32, 0xef, 0x89, 0xcf, 0x1f, 0x23, 0x26, 0x96, 0xe2, 0x13, 0xda, 0xfe, 0x4d, 0xbe, 0xb1, 0xcf, 0x1d, 0x5b, 0xbd, 0x12, 0xe5, 0xff, 0x2e, 0xbb, 0x28, 0x9, 0x18, 0x4e, 0x37, 0xcd, 0x9a, 0xe, 0x58, 0xa4, 0xe0, 0xaf, 0x9, 0x94, 0x93, 0xe6, 0xd8, 0xcc, 0x98, 0xb0, 0x5a, 0x2f, 0x4, 0xa, 0x7e, 0x39, 0x51, 0x50, 0x38, 0xf6, 0xee, 0x21, 0xfc, 0x25, 0xf8, 0xd4, 0x59, 0xa3, 0x27, 0xb8, 0x3e, 0xc1, 0xa2, 0x8a, 0x23, 0x42, 0x37, 0xac, 0xd5, 0x24, 0x65, 0x50, 0x69, 0x42, 0x64, 0x6a, 0xc2, 0x48, 0xec, 0x96, 0xeb, 0xba, 0x6e, 0x1b, 0x9, 0x24, 0x75, 0xf7, 0xad, 0xae, 0x4d, 0x35, 0xe0, 0x9, 0xfd, 0x33, 0x86, 0x13, 0xc7, 0xd4, 0xc1, 0x2e, 0x38, 0x18, 0x47, 0x31, 0xa, 0x10, 0xe6, 0xf0, 0x2c, 0x2, 0x39, 0x2f, 0xc3, 0x20, 0x84, 0xfb, 0xe9, 0x39, 0x68, 0x9b, 0xc6, 0x51, 0x8b, 0xe2, 0x7a, 0xf7, 0x84, 0x2d, 0xee, 0xa8, 0x4, 0x38, 0x28, 0xe3, 0xdf, 0xfe, 0x3b, 0xba, 0xc4, 0x79, 0x4c, 0xa0, 0xcc, 0x78, 0x69, 0x97, 0x22, 0x70, 0x9f, 0x2e, 0x4b, 0xe, 0xae, 0x72, 0x87, 0xde, 0xb0, 0x6a, 0x27, 0xb4, 0x62, 0x42, 0x3e, 0xc3, 0xf0, 0xdf, 0x22, 0x7a, 0xcf, 0x58, 0x90, 0x43, 0x29, 0x26, 0x85, 0xf2, 0xc0, 0xe7, 0x32, 0x3, 0xe8, 0x58, 0x8b, 0x62, 0x55, 0x4f, 0xf1, 0x9d, 0x62, 0x60, 0xc7, 0xfe, 0x48, 0xdf, 0x30, 0x15, 0x9, 0xd3, 0x3b, 0xe0, 0xd8, 0xb3, 0x1d, 0x3f, 0x65, 0x8c, 0x92, 0x1e, 0xf7, 0xf5, 0x54, 0x49, 0xff, 0x38, 0x87, 0xd9, 0x1b, 0xfb, 0x89, 0x41, 0x16, 0xdf, 0x57, 0x20, 0x60, 0x98, 0xe8, 0xc5, 0x83, 0x5b},
+               output224: []byte{0x3a, 0x44, 0x7c, 0x96, 0xe9, 0x7c, 0xab, 0xba, 0x2a, 0xed, 0xfb, 0x3d, 0xfd, 0x1a, 0x56, 0x3f, 0xe0, 0x5d, 0xf, 0x13, 0x32, 0x6b, 0xa5, 0x43, 0x75, 0x27, 0x4e, 0xb1},
+               output256: []byte{0x3c, 0x79, 0xa3, 0xbd, 0x82, 0x45, 0x42, 0xc2, 0xa, 0xf7, 0x1f, 0x21, 0xd6, 0xc2, 0x8d, 0xf2, 0x21, 0x3a, 0x4, 0x1f, 0x77, 0xdd, 0x79, 0xa3, 0x28, 0xa0, 0x7, 0x81, 0x23, 0x95, 0x4e, 0x7b},
+               output384: []byte{0x2a, 0xad, 0x66, 0x1e, 0xbc, 0x40, 0x4e, 0xfe, 0xdc, 0xfb, 0x7, 0x11, 0xe6, 0x9d, 0x0, 0xf1, 0xfb, 0x7d, 0x40, 0x3d, 0x97, 0x25, 0xaa, 0x1f, 0xb9, 0xa4, 0x3e, 0x40, 0xd0, 0xf3, 0x24, 0x95, 0x71, 0xa3, 0xad, 0xa0, 0x1f, 0x73, 0xf8, 0x3b, 0x2d, 0x46, 0x99, 0x57, 0x48, 0x5, 0x3f, 0x77},
+               output512: []byte{0x5f, 0xb5, 0x2a, 0xb6, 0xba, 0xdf, 0xe3, 0xd5, 0xf1, 0xee, 0x5a, 0x56, 0x9b, 0x77, 0xc4, 0x3b, 0x3f, 0x37, 0x56, 0x16, 0xf1, 0xcc, 0x88, 0x38, 0x39, 0x8b, 0xa6, 0x54, 0x93, 0xfe, 0xc6, 0x7e, 0x66, 0x5c, 0x1a, 0x6, 0x7c, 0xa4, 0x62, 0x9b, 0x22, 0x68, 0x55, 0x43, 0xd6, 0x5, 0x1f, 0x6f, 0xbd, 0x4f, 0x25, 0x80, 0x50, 0xd3, 0xa2, 0x71, 0x11, 0xc, 0x13, 0x37, 0xf6, 0xe5, 0x4c, 0x3d}},
+       testcase{
+               msg:       []byte{0xd7, 0x75, 0x1a, 0xac, 0xb, 0x43, 0xc4, 0xae, 0x8c, 0x2c, 0xe3, 0x66, 0x25, 0x6f, 0x95, 0xe3, 0x57, 0xc, 0xd6, 0xad, 0x64, 0x3c, 0x7, 0x6f, 0x5, 0x65, 0x22, 0x14, 0xb6, 0xca, 0x4d, 0xc1, 0x34, 0xe6, 0x40, 0x77, 0xcb, 0x1b, 0x46, 0x8c, 0xc1, 0x95, 0x0, 0xba, 0x1d, 0x3f, 0xb0, 0xd3, 0xc5, 0xba, 0xfa, 0x26, 0x7d, 0xce, 0xe9, 0x72, 0xeb, 0x4b, 0xa3, 0xb7, 0xa, 0xf3, 0x2a, 0x0, 0xe4, 0x81, 0x41, 0x6b, 0xa6, 0x91, 0x7d, 0xa4, 0x77, 0x1d, 0xb3, 0xdf, 0x2d, 0xf3, 0x88, 0x62, 0xd9, 0xad, 0xc8, 0x15, 0x0, 0x7, 0xe6, 0xc3, 0x69, 0xf3, 0xea, 0xeb, 0xe2, 0x9d, 0x50, 0xe9, 0xa5, 0xa6, 0x87, 0x79, 0x3b, 0x3a, 0x41, 0x48, 0x7d, 0x20, 0x96, 0x62, 0x5a, 0x2d, 0xa, 0xd4, 0x6e, 0xe4, 0x40, 0x21, 0x20, 0x9e, 0xf, 0x75, 0x26, 0x15, 0xef, 0x13, 0x23, 0x2c, 0x3e, 0xb9, 0x59, 0x7b, 0xf, 0x75, 0xbf, 0x17, 0x52, 0x50, 0xe7, 0x26, 0x40, 0xf2, 0x45, 0xdb, 0x41, 0xb6, 0xe1, 0x8d, 0xd0, 0x67, 0xdc, 0x62, 0x8e, 0x36, 0x4a, 0x92, 0xfc, 0x96, 0xcc, 0xba, 0xab, 0xa0, 0xe9, 0x24, 0xc8, 0xfa, 0x4e, 0x2e, 0xb, 0xd8, 0xd5, 0xeb, 0x1f, 0x90, 0x1e, 0x15, 0x3d, 0xf1, 0x28, 0x4f, 0x80, 0xb6, 0xb8, 0x59, 0x16, 0xe2, 0xbc, 0xb3, 0xf0, 0xac, 0xf, 0x35, 0x7c, 0x58, 0xca, 0x35, 0x64, 0x81, 0xc3, 0xe9, 0x2, 0x3, 0x31, 0xea, 0x63, 0xe8, 0x76, 0x84, 0x3, 0x24, 0x89, 0x65, 0x88, 0x67, 0xf7, 0xbc, 0x88, 0xbd, 0x98, 0xfd, 0xaf, 0x8, 0x1a, 0xe7, 0x46, 0xa5, 0x27, 0x14, 0xad, 0x1b, 0xd8, 0x30, 0xc1, 0xd6, 0x5a, 0x9e, 0xa5, 0xe8, 0xf0, 0xb6, 0x53, 0x85, 0xca, 0xad, 0x9e, 0x2b, 0xa9, 0x49, 0x52, 0x23, 0xbe, 0xa6, 0x61, 0xe6, 0x9a, 0x5b, 0xa0, 0x35, 0x23, 0x50, 0x63, 0xf2, 0x75, 0xc5, 0xc6, 0x55, 0xfa, 0xd, 0x16, 0x55, 0x33, 0xfb, 0xfe, 0x70, 0xa4, 0x8d, 0xe5, 0x45, 0xde, 0xd7, 0xbe, 0xb7, 0x2f, 0xd9, 0x5, 0xfe, 0xfa, 0xeb, 0xd6, 0x83, 0xf8, 0x53, 0x44, 0x10, 0x3d, 0xf0, 0xb8, 0xda, 0x66, 0x33, 0x48, 0x0, 0x54, 0x92, 0xd8, 0xbe, 0x2a, 0xe9, 0x5c, 0x30, 0xfc, 0x62, 0x9c, 0x4d, 0x2, 0x7d, 0x50, 0x3d, 0x68, 0x6b, 0x5a, 0x34, 0xbf, 0xb6, 0x85, 0x6f, 0x24, 0xe8, 0xfd, 0x9e, 0x56, 0xeb, 0x58, 0x9b, 0x79, 0xc2, 0x8f, 0x72, 0x7d, 0x42, 0x49, 0xc6, 0xa8, 0xcc, 0x50, 0x72, 0xbb, 0x19, 0x22, 0x9d, 0x6, 0xf2, 0xa5, 0xf7, 0xb0, 0x22, 0x33, 0x64, 0xb4, 0xa0, 0xcc, 0x55, 0xe5, 0x3e, 0xdb, 0x77, 0x1a, 0x2e, 0xdc, 0xd7, 0xf2, 0x78, 0xed, 0x52, 0x86, 0x72, 0x1c, 0xdf, 0xf0, 0x69, 0x66, 0x16, 0x56, 0x66, 0x42, 0xca, 0x4, 0x51, 0x3b, 0x58, 0xd6, 0x23, 0x71, 0xd8, 0xc5, 0x33, 0xfa, 0xdb, 0x90, 0xe4, 0x3d, 0x78, 0xe4, 0x88, 0x90, 0xe, 0x55, 0x6c, 0x86, 0x5e, 0x5c, 0xee, 0x9c, 0x65, 0x2f, 0x94, 0x44, 0x5, 0x6, 0x71, 0x3e, 0x48, 0x33, 0xcc, 0x6e, 0x11, 0x9d, 0x5b, 0xaf, 0xb0, 0xfc, 0xde, 0xcf, 0x25, 0x7d, 0xa9, 0xc7, 0xdb, 0xae, 0xe, 0x98, 0x25, 0xd4, 0x45, 0x95, 0x32, 0xa2, 0xd7, 0x1b, 0x22, 0x6a, 0xdf, 0x88, 0x49, 0xd6, 0x91, 0xd3, 0x27, 0xb, 0x73, 0xd9, 0x5e, 0x1d, 0x39, 0x3f, 0x6d, 0x32, 0x3f, 0xe, 0x39, 0xa4, 0x43, 0xbb, 0x5d, 0xb5, 0x5, 0x50, 0x95, 0x91, 0x23, 0xe5, 0x90, 0x35, 0x41, 0x3f, 0xe4, 0xb1, 0x5f, 0x32, 0xf3, 0xad, 0xcb, 0x42, 0x58, 0x1, 0xd8, 0x81, 0xa2, 0x4b, 0x24, 0x1b, 0x1d, 0x95, 0xe8, 0xbe, 0xb2, 0x75, 0x94, 0x11, 0xba, 0x7f, 0x34, 0xdb, 0x3, 0xc8, 0x8e, 0x55, 0x71, 0x6a, 0x64, 0xbb, 0xa0, 0xa2, 0xf4, 0x1f, 0x50, 0x0, 0x8a, 0x57, 0xc3, 0x1d, 0xb3, 0xa6, 0xea, 0x1b, 0xe6, 0x46, 0x91, 0xb3, 0x88, 0xe9, 0x3c, 0x3c, 0x4c, 0xff, 0xc9, 0x7a, 0xe4, 0xef, 0x45, 0x5a, 0x1b, 0xdd, 0x1, 0x3d, 0x44, 0xf2, 0xbc, 0xbf, 0x4a, 0x45, 0xc0, 0xc4, 0xa6, 0x2, 0x1c, 0x22, 0x2, 0x70, 0x70, 0x7c, 0x36, 0x43, 0x58, 0x35, 0xca, 0xdd, 0x61, 0x13, 0x86, 0xb5, 0xff, 0x31, 0xe, 0x44, 0x97, 0x78, 0x23, 0x46, 0x3, 0xfd, 0x77, 0xa3, 0xdc, 0x17, 0x6b, 0xb9, 0x65, 0xa0, 0xea, 0xb2, 0x14, 0x2c, 0x1f, 0x48, 0x90, 0x87, 0xd4, 0xba, 0xc3, 0xd7, 0xaa, 0x3, 0xda, 0x55, 0x7d, 0x23, 0xc9, 0x43, 0xf6, 0x58, 0x8d, 0x64, 0xc3, 0xe1, 0x47, 0x69, 0x89, 0x8c, 0xd4, 0x5a, 0x6f, 0xfe, 0xf5, 0xb, 0xa4, 0x53, 0x91, 0x46, 0xe, 0x24, 0x3a, 0x90, 0x4b, 0x1, 0xa8, 0xb3, 0xd8, 0x8, 0x14, 0xad, 0xd1, 0xe6, 0xaf, 0x63, 0x5e, 0x6b, 0x7d, 0xb4, 0x57, 0xa4, 0x7b, 0xbf, 0x70, 0x78, 0x25, 0xfc, 0x72, 0x92, 0x9d, 0xd1, 0xf8, 0x88, 0x49, 0x4, 0xfb, 0x5d, 0x4f, 0x8c, 0x1a, 0x33, 0x1b, 0x44, 0x3b, 0x1, 0xb3, 0xec, 0x89, 0x78, 0x92, 0x7c, 0x16, 0x2, 0xad, 0xc6, 0xa9, 0x45, 0x5b, 0x33, 0x2a, 0xd3, 0xd5, 0x7, 0x4b, 0x7a, 0x40, 0xd, 0x22, 0x36, 0x7a, 0x5, 0x7e, 0xeb, 0xd3, 0xff, 0x91, 0xdd, 0xe2, 0xfc, 0x3e, 0x36, 0x7f, 0x57, 0x80, 0xa6, 0x7f, 0x5e, 0x22, 0xb8, 0x45, 0xd, 0x2b, 0x73, 0x8c, 0xea, 0xa9, 0x9a, 0xd2, 0x9e, 0x0, 0x32, 0xd1, 0x7d, 0x8, 0x77, 0x25, 0xda, 0xcd, 0xda, 0x29, 0x5, 0xcc, 0x79, 0xfb, 0x94, 0xbd, 0x83, 0x55, 0x84, 0x62, 0xa, 0xd7, 0x70, 0xf9, 0x1f, 0x96, 0x26, 0x48, 0x4b, 0xdb, 0x65, 0x35, 0xb0, 0x8e, 0x13, 0x4, 0x6, 0xa3, 0x97, 0xca, 0x73, 0x21, 0x75, 0xe3, 0xa9, 0xb1, 0xd2, 0x6a, 0x83, 0x3d, 0xa2, 0xce, 0xf7, 0x5, 0x96, 0xd8, 0xde, 0x6d, 0x2c, 0x54, 0x4a, 0xc0, 0x1, 0xae, 0xfa, 0xc, 0x57, 0x9, 0x22, 0xa, 0xf3, 0x49, 0x94, 0xf3, 0x2a, 0x20, 0xcd, 0x98, 0x2c, 0x67, 0xec, 0x3c, 0x3a, 0xcd, 0xf4, 0xde, 0x6e, 0xdb, 0x4e, 0xd4, 0x61, 0xf3, 0xb0, 0x5c, 0x2e, 0xc, 0xdb, 0x38, 0xc6, 0x6, 0x37, 0x6f, 0xa, 0xf4, 0x68, 0x7b, 0x9c, 0xff, 0x71, 0xeb, 0xfe, 0xdc, 0x3b, 0x3d, 0x4e, 0x25, 0x3c, 0xa4, 0xfb, 0xe8, 0x9f, 0x4b, 0x19, 0xb8, 0x20, 0xe9, 0xba, 0x1d, 0x4f, 0xd4, 0xac, 0x40, 0xd0, 0x5b, 0xbd, 0x81, 0x50, 0x93, 0xfa, 0x0, 0xcd, 0x53, 0x38, 0x50, 0x8c, 0x71, 0xd5, 0xa5, 0xf7, 0x3f, 0x3d, 0xe1, 0xe, 0x58, 0xa3, 0xab, 0x8d, 0x55, 0x5e, 0x5b, 0x32, 0x85, 0x49, 0x43, 0xb9, 0x24, 0x93, 0x97, 0x92, 0xbb, 0x16, 0xf, 0xbc, 0xf1, 0xd8, 0x2a, 0xd6, 0xe1, 0xda, 0x7e, 0x3f, 0x86, 0xee, 0x46, 0x27, 0x4b, 0xc7, 0x75, 0xc4, 0x2d, 0x2f, 0x54, 0x1c, 0x4f, 0xf0, 0x76, 0x4e, 0xe1, 0xd9, 0xd6, 0x35, 0xd7, 0x1d, 0x84, 0x9c, 0x1d, 0xb9, 0x17, 0x37, 0x72, 0x18, 0xf4, 0x9a, 0x11, 0x84, 0x54, 0xb4, 0xdf, 0xdc, 0xc, 0xdc, 0xa2, 0xe, 0x43, 0x97, 0x13, 0x7d, 0x6c, 0x57, 0x44, 0xf3, 0x87, 0xfa, 0x3e, 0xad, 0xb2, 0x45, 0xb0, 0x75, 0x7c, 0x50, 0xbc, 0xa8, 0x3, 0xa9, 0xf0, 0xfb, 0x76, 0x4a, 0x76, 0x1c, 0x77, 0x59, 0x90, 0x27, 0xff, 0x88, 0x22, 0xb2, 0x50, 0x85, 0x97, 0xf4, 0x6a, 0x41, 0xa0, 0x39, 0x71, 0xad, 0x32, 0xe5, 0x9a, 0x26, 0x68, 0xaa, 0xd2, 0xe9, 0x79, 0x83, 0x6, 0x80, 0xc, 0xbe, 0xfa, 0x4, 0x8, 0xed, 0x52, 0x8e, 0x58, 0xb1, 0xd5, 0xf3, 0x12, 0xc4, 0xea, 0xe7, 0xf7, 0xe, 0x7d, 0xac, 0xde, 0xf0, 0xb2, 0x23, 0x4f, 0x5b, 0x96, 0xba, 0xc9, 0x78, 0x17, 0x1, 0x1d, 0xbd, 0x88, 0x22, 0x0, 0x6b, 0x1f, 0xe5, 0x65, 0x4b, 0x5a, 0x3e, 0x79, 0x59, 0x77, 0x24, 0x2c, 0x25, 0xf5, 0x6c, 0xf3, 0xad, 0x61, 0x23, 0x1e, 0xd8, 0x8e, 0x39, 0xb, 0x4a, 0x1, 0x99, 0xa5, 0xd0, 0x6f, 0xb, 0x3b, 0x9d, 0x9e, 0x91, 0x8b, 0xf6, 0x6b, 0xf3, 0x76, 0x43, 0x1f, 0x62, 0xd4, 0x7, 0x21, 0x80, 0x59, 0x45, 0x92, 0x49, 0x38, 0xd8, 0xc4, 0x73, 0x74, 0xeb, 0xe6, 0x97, 0xfe, 0xab, 0x83, 0x9e, 0x6c, 0x26, 0xb6, 0xf3, 0x98, 0x4f, 0xcd, 0x14, 0x9c, 0x17, 0x3e, 0x2f, 0xd8, 0x5d, 0x9a, 0x45, 0xe5, 0x35, 0xc, 0x55, 0x4d, 0xda, 0x97, 0x8e, 0xfe, 0x22, 0xc8, 0x1b, 0x89, 0x78, 0xb6, 0x51, 0xee, 0x87, 0x75, 0xed, 0x85, 0xd6, 0x88, 0xab, 0xc7, 0x98, 0xe7, 0xd4, 0x2d, 0x25, 0x6c, 0xb3, 0x6c, 0x9, 0x78, 0x8d, 0x38, 0x76, 0x99, 0xcb, 0x44, 0x97, 0xa, 0xc4, 0xa0, 0x56, 0x14, 0x7b, 0xe9, 0xbf, 0x54, 0x80, 0xa9, 0x52, 0x72, 0x4e, 0xe1, 0x33, 0x68, 0xbd, 0xab, 0xe8, 0x12, 0xec, 0x8b, 0x16, 0xe4, 0xe1, 0x68, 0x1, 0x3f, 0xd, 0xfd, 0x17, 0x47, 0x26, 0x7d, 0xe2, 0xb1, 0x9e, 0xe4, 0x90, 0xee, 0xb8, 0xdd, 0x47, 0x93, 0xa0, 0xc, 0x7e, 0xd8, 0xf7, 0x79, 0xb9, 0xf, 0x2c, 0x0, 0x4b, 0x30, 0xa6, 0x7, 0xac, 0xd, 0xca, 0xe6, 0xbe, 0x6d, 0x1d, 0xd6, 0xdb, 0xf2, 0xdb, 0xbb, 0xf0, 0xbc, 0xb5, 0x39, 0x49, 0x4, 0xfc, 0x7c, 0x43, 0x51, 0xbd, 0xe6, 0x12, 0x51, 0x15, 0xba, 0x1f, 0xaa, 0xb7, 0x6a, 0xdf, 0xd0, 0xa4, 0x11, 0x2d, 0x96, 0x21, 0x17, 0xc6, 0xc3, 0x4, 0xb8, 0xb5, 0x52, 0xa9, 0xdc, 0xad, 0x1b, 0x9f, 0x7e, 0xa9, 0x59, 0x5d, 0xc1, 0xa4, 0x32, 0xba, 0x85, 0x34, 0xc6, 0x1d, 0xc7, 0x86, 0x9e, 0xda, 0xbb, 0x46, 0xf9, 0x9d, 0x5f, 0xbf, 0x13, 0xb2, 0x57, 0xca, 0x28, 0x3, 0xc7, 0x36, 0x17, 0xcc, 0x32, 0xa3, 0xd3, 0x9c, 0x2b, 0x8e, 0x55, 0x23, 0x32, 0x6e, 0xe4, 0x97, 0x55, 0xb3, 0xb4, 0x9d, 0xb1, 0x14, 0x71, 0x92, 0x5d, 0x71, 0xc6, 0x6f, 0x4e, 0x92, 0xe9, 0xc4, 0xb6, 0x83, 0x2b, 0x23, 0x65, 0x39, 0xdd, 0x88, 0x68, 0x35, 0x25, 0x3b, 0x96, 0x81, 0x72, 0x9f, 0x49, 0x3d, 0x30, 0x45, 0x18, 0xea, 0xea, 0xf8, 0x37, 0xcf, 0xae, 0xa9, 0x79, 0x8a, 0x6d, 0x4f, 0x87, 0x36, 0xf0, 0x6f, 0xf3, 0x75, 0x86, 0xd1, 0x90, 0x78, 0x37, 0x63, 0xa6, 0x60, 0x46, 0x5d, 0xf3, 0x97, 0x88, 0x36, 0x16, 0xa5, 0xcd, 0x11, 0x34, 0xaa, 0x8b, 0x63, 0x38, 0x5d, 0xa8, 0xbd, 0xe8, 0x74, 0x35, 0xf6, 0xef, 0x79, 0xf0, 0x69, 0xcd, 0x67, 0x6e, 0xb7, 0xd1, 0x41, 0xb1, 0xfe, 0x4d, 0x51, 0xd, 0xde, 0x94, 0x2f, 0x50, 0x3f, 0x1, 0xba, 0xd2, 0xfe, 0x5f, 0xe3, 0xdf, 0xa8, 0x48, 0x3e, 0x88, 0x70, 0xe2, 0xa0, 0xc3, 0xf4, 0x5e, 0x6e, 0x8b, 0x49, 0xe0, 0xbc, 0x7b, 0x1f, 0x47, 0x3e, 0x5c, 0x38, 0x20, 0x85, 0xaa, 0xa6, 0x1f, 0x66, 0x3b, 0x3a, 0xf, 0x81, 0x5b, 0x48, 0x5f, 0xfd, 0xf9, 0xe7, 0x6d, 0x18, 0xba, 0xa6, 0x43, 0x29, 0x3a, 0x73, 0x6e, 0xc6, 0xd8, 0x48, 0x7d, 0x76, 0xf7, 0x2b, 0xa9, 0xd2, 0x10, 0xce, 0x2c, 0x90, 0x91, 0x6, 0x32, 0x95, 0x67, 0x1b, 0x36, 0x4c, 0xac, 0x70, 0xa6, 0xb1, 0xc7, 0xb8, 0x59, 0xf2, 0x80, 0x75, 0xa8, 0xe4, 0x6, 0x2b, 0xbc, 0xa7, 0x2e, 0xec, 0x1e, 0x39, 0x90, 0xf0, 0x11, 0x25, 0x1a, 0xdb, 0x36, 0xb9, 0x2f, 0x5e, 0x14, 0xf, 0x6e, 0xb7, 0x3, 0x4a, 0xec, 0xb1, 0xa, 0x86, 0x5c, 0x77, 0x4f, 0x2b, 0x29, 0x7f, 0x8, 0x87, 0x80, 0xc6, 0xc5, 0x6b, 0xbd, 0x5e, 0xe5, 0x60, 0x20, 0xab, 0xb2, 0xba, 0x1f, 0xe7, 0xb2, 0x53, 0xfb, 0x79, 0x9d, 0xe9, 0x2, 0x61, 0xab, 0xb, 0x87, 0x30, 0x6b, 0xae, 0x8, 0x77, 0x5, 0x3a, 0xa5, 0xbd, 0x62, 0x89, 0xb0, 0x76, 0x91, 0x4e, 0xaa, 0x98, 0x7d, 0x63, 0x1e, 0x5d, 0x11, 0xdc, 0x67, 0xe8, 0x5b, 0x81, 0xf5, 0x93, 0xd9, 0x6c, 0xb6, 0xd9, 0x9e, 0x62, 0xe5, 0xef, 0xb5, 0x49, 0x2b, 0xdb, 0xa4, 0x55, 0x55, 0x40, 0xbd, 0x64, 0xdd, 0x1f, 0x34, 0x33, 0x52, 0xab, 0xa2, 0x73, 0x39, 0x5e, 0x1, 0x55, 0xb3, 0x7e, 0xf2, 0x17, 0x2c, 0x16, 0x4e, 0xcf, 0xd2, 0xe4, 0xcf, 0x88, 0x6c, 0x22, 0xd4, 0x97, 0x54, 0xa7, 0x42, 0x1f, 0xe4, 0xa1, 0x26, 0x89, 0xab, 0x6f, 0x28, 0x71, 0x86, 0x11, 0xf2, 0xa4, 0x8a, 0xd1, 0xcb, 0xc0, 0x11, 0x7d, 0x2a, 0x66, 0x8c, 0x9b, 0x2f, 0x54, 0x3d, 0xef, 0xe7, 0x35, 0x95, 0xf9, 0xb2, 0x77, 0x1, 0x8, 0xdd, 0x26, 0x19, 0xcf, 0xae, 0xb0, 0xc4, 0xe, 0x65, 0xd6, 0x57, 0x84, 0x74, 0x8f, 0x5a, 0x5b, 0xa2, 0x44, 0x83, 0x64, 0x73, 0xa4, 0x2f, 0x64, 0xe7, 0x1b, 0xfd, 0x2f, 0x41, 0x96, 0xcd, 0x54, 0x47, 0xb7, 0xcf, 0x1c, 0x8a, 0x46, 0x0, 0xe8, 0xcd, 0xaf, 0x51, 0x0, 0x5f, 0xff, 0x2c, 0xb, 0x43, 0x45, 0x89, 0x66, 0xd7, 0x9c, 0xe0, 0x39, 0xe7, 0xab, 0x1a, 0x1f, 0x48, 0x58, 0x87, 0x90, 0x9e, 0xd2, 0x42, 0xbd, 0xcd, 0xfd, 0x4a, 0x26, 0xc2, 0x94, 0x50, 0x64, 0x78, 0xe1, 0x6e, 0x71, 0xe7, 0x14, 0x5f, 0x10, 0x9a, 0x48, 0xe5, 0x73, 0xce, 0x65, 0x8f, 0x62, 0xef, 0xb6, 0xf6, 0x67, 0xb4, 0x86, 0x42, 0x7e, 0x7c, 0x92, 0x34, 0x86, 0x47, 0xdf, 0xb1, 0xeb, 0x23, 0xca, 0x6e, 0x47, 0xb5, 0x7d, 0x8f, 0x69, 0x12, 0x6f, 0x89, 0xf2, 0xef, 0xab, 0xd8, 0x76, 0x23, 0x67, 0x59, 0x41, 0x4e, 0x77, 0x5f, 0x6b, 0xb9, 0x8a, 0xec, 0x33, 0x2b, 0xd, 0xb2, 0x89, 0xdd, 0x5b, 0x2b, 0x7b, 0xa3, 0xdb, 0xbc, 0xa2, 0x82, 0x5b, 0x3, 0x3, 0xb4, 0x4c, 0x3b, 0x90, 0xba, 0x6d, 0x2, 0x9a, 0x5b, 0x77, 0x55, 0x66, 0x10, 0xae, 0xd3, 0x2f, 0xf2, 0x1d, 0x13, 0xbf, 0x38, 0x66, 0x7c, 0xb3, 0x15, 0x71, 0xf5, 0xfd, 0x2a, 0xe9, 0xd, 0xce, 0x95, 0x3d, 0x8d, 0xad, 0x9c, 0x16, 0xa3, 0xec, 0x34, 0xf0, 0xc3, 0x8, 0x5a, 0x44, 0xc0, 0x21, 0x3d, 0xf1, 0x15, 0x39, 0xef, 0xb8, 0xa, 0x1, 0x3c, 0x31, 0xc6, 0xd7, 0x2c, 0xf6, 0x2a, 0xbc, 0xa1, 0xbe, 0x59, 0x4f, 0x7d, 0x9a, 0x47, 0x83, 0x3a, 0x86, 0x3f, 0xcf, 0x58, 0x10, 0x14, 0xa8, 0x3e, 0x73, 0xd7, 0xe6, 0x61, 0x78, 0xc0, 0xa0, 0x7, 0xaa, 0x21, 0xb2, 0x31, 0x4e, 0xd0, 0xb6, 0xe1, 0x6f, 0x41, 0x49, 0x14, 0x5c, 0x51, 0xad, 0x8c, 0xbb, 0x68, 0x97, 0xa6, 0xe9, 0x4e, 0xc0, 0x91, 0xd9, 0xb8, 0xa1, 0x1b, 0x44, 0x36, 0x21, 0x3e, 0x7e, 0xa0, 0xd3, 0x4d, 0x34, 0x95, 0x3a, 0xcf, 0x49, 0x72, 0xa6, 0xe0, 0x8b, 0x13, 0x7f, 0xa, 0x11, 0x68, 0x32, 0x4b, 0xcb, 0x9d, 0x9b, 0xd4, 0xf0, 0x3f, 0xe0, 0xca, 0xea, 0x55, 0x88, 0xc8, 0xc0, 0xa9, 0x37, 0x22, 0xfa, 0x4a, 0x96, 0x73, 0xea, 0xb, 0x31, 0x75, 0xc3, 0x70, 0xdc, 0xc2, 0x3c, 0x28, 0x72, 0x76, 0xda, 0x6d, 0x5, 0xd, 0xe8, 0x9b, 0x45, 0xa4, 0xbf, 0x2f, 0x0, 0x56, 0xb7, 0x90, 0x63, 0x4a, 0x77, 0x37, 0x6e, 0xf0, 0x2e, 0xd3, 0x51, 0xcd, 0x5d, 0x33, 0xc5, 0x4f, 0xf1, 0x50, 0xda, 0xeb, 0xfc, 0xe8, 0xd4, 0x2e, 0xf3, 0xcc, 0xfc, 0x90, 0x21, 0xf8, 0x3d, 0xa1, 0x18, 0x61, 0x66, 0xff, 0x2d, 0x52, 0x62, 0x30, 0xd7, 0xef, 0xb2, 0x89, 0x58, 0xd6, 0x6e, 0x2d, 0xe4, 0x1b, 0x5d, 0x43, 0xc3, 0xdc, 0x3, 0x50, 0x25, 0xb0, 0xd1, 0xa7, 0xc8, 0x62, 0x7b, 0x92, 0x84, 0x5f, 0xe, 0x38, 0x8e, 0xd2, 0x99, 0x0, 0x7, 0x5e, 0x84, 0xa6, 0xe2, 0xd, 0x9f, 0x7c, 0xe0, 0x46, 0x88, 0x52, 0x9f, 0x94, 0x52, 0xbb, 0xdf, 0xb6, 0x8c, 0x91, 0x2b, 0xf, 0xec, 0xc2, 0xec, 0x9c, 0x92, 0x83, 0xd6, 0x5e, 0x22, 0xbc, 0x65, 0x8f, 0xa3, 0xde, 0xb3, 0xeb, 0xf0, 0xb5, 0x67, 0x9e},
+               output224: []byte{0x9e, 0x49, 0xfe, 0x7, 0x5b, 0x54, 0xf3, 0xc9, 0xc9, 0x43, 0x62, 0x75, 0x56, 0x45, 0xd9, 0x6, 0x79, 0xcb, 0xca, 0xf7, 0xed, 0x7f, 0x75, 0x1, 0xd0, 0xc2, 0x93, 0x7b},
+               output256: []byte{0x22, 0x61, 0x4d, 0x37, 0x96, 0x59, 0xde, 0xc8, 0xf3, 0x4b, 0x89, 0x26, 0xf9, 0x19, 0x15, 0x16, 0x38, 0xc1, 0xeb, 0xb8, 0x71, 0x30, 0x4e, 0x51, 0x90, 0x6, 0xe1, 0x85, 0xf8, 0xe2, 0x25, 0xde},
+               output384: []byte{0xd, 0x25, 0xfc, 0xc6, 0x35, 0x27, 0xef, 0xf5, 0x2d, 0x6e, 0x4c, 0x3e, 0x3f, 0x96, 0x63, 0xa9, 0xf, 0x8d, 0xbb, 0xfb, 0x50, 0xbc, 0x20, 0x35, 0x5c, 0x4e, 0x88, 0x79, 0x26, 0xe8, 0xdd, 0x45, 0xcc, 0x4, 0x15, 0x2c, 0x88, 0xf4, 0x23, 0x1, 0x3c, 0x3c, 0x40, 0xca, 0xc7, 0x6e, 0xa7, 0x80},
+               output512: []byte{0x8b, 0x6, 0xcd, 0x2b, 0x1e, 0xba, 0x5b, 0x4f, 0x60, 0x7b, 0x2e, 0xf6, 0x1e, 0x1d, 0xc2, 0x4b, 0x26, 0xce, 0x8a, 0x50, 0xf2, 0x26, 0xfd, 0x78, 0x61, 0x35, 0x40, 0x67, 0x50, 0x9, 0xe9, 0x46, 0x88, 0x1f, 0xa1, 0x9d, 0x4e, 0xf0, 0x17, 0x2c, 0x90, 0xe5, 0xd1, 0xa1, 0x99, 0x27, 0xc6, 0xd9, 0x2d, 0x86, 0x2f, 0xd5, 0x13, 0xda, 0x66, 0x42, 0x8b, 0x8, 0x49, 0x16, 0x23, 0x58, 0x49, 0x38}},
+       testcase{
+               msg:       []byte{0xcf, 0xf5, 0x45, 0x96, 0xc3, 0x15, 0x40, 0x30, 0x90, 0xb3, 0xdf, 0x12, 0x53, 0xc9, 0x77, 0x9b, 0x89, 0xe8, 0x66, 0xf1, 0x42, 0x1e, 0x13, 0xf7, 0x64, 0x6e, 0x3c, 0xc1, 0x6d, 0x9, 0x78, 0xc4, 0x1b, 0x95, 0x94, 0x99, 0xc2, 0x49, 0xd2, 0x29, 0xdc, 0xed, 0x6e, 0x26, 0x7c, 0xb4, 0xcb, 0x66, 0x99, 0xe0, 0x47, 0x8b, 0xe8, 0xde, 0x4e, 0x13, 0xbe, 0x4b, 0x58, 0xd6, 0xb6, 0x30, 0x83, 0xe9, 0x73, 0x45, 0x73, 0x9, 0x3f, 0xd3, 0x3f, 0xf2, 0xfd, 0xef, 0x48, 0x75, 0x4c, 0x9, 0xe8, 0x91, 0xc4, 0x1d, 0xdb, 0x62, 0xc2, 0xb4, 0x20, 0x8f, 0x77, 0x9c, 0x44, 0xbd, 0x44, 0x5d, 0x85, 0x2e, 0x2b, 0xe9, 0xda, 0x7f, 0xca, 0x6c, 0x5d, 0x7c, 0x1, 0x5f, 0x31, 0x9e, 0x4b, 0xaf, 0x9f, 0x9b, 0x8c, 0x59, 0x71, 0x8, 0x16, 0xa9, 0x78, 0xf6, 0x70, 0xeb, 0xdb, 0xf5, 0xef, 0x45, 0x57, 0x48, 0x20, 0x4b, 0x3c, 0xf1, 0x50, 0x18, 0x82, 0x53, 0xf, 0x7f, 0x95, 0x35, 0x7b, 0x7c, 0xc, 0x66, 0xb3, 0x54, 0xab, 0x94, 0x7f, 0xad, 0xd4, 0x19, 0x74, 0x10, 0x16, 0x2, 0xc9, 0x26, 0x92, 0x8d, 0x8a, 0x2b, 0x3a, 0xe1, 0x45, 0x97, 0xde, 0x32, 0x7d, 0xe0, 0x7b, 0x72, 0x4f, 0x96, 0x5, 0xbb, 0xb7, 0xa, 0x19, 0x3f, 0x4b, 0xf6, 0xdb, 0xf, 0x12, 0x50, 0xbb, 0xe0, 0x73, 0x2c, 0xe9, 0xcd, 0xa1, 0x3f, 0x22, 0x3, 0xee, 0x4, 0x16, 0x44, 0x38, 0xb8, 0x89, 0x32, 0x38, 0xa1, 0x86, 0x3c, 0x19, 0xf2, 0x23, 0x26, 0x6a, 0x4, 0x77, 0x92, 0xe1, 0x38, 0xb8, 0xce, 0x77, 0xa9, 0x63, 0x30, 0x38, 0x6c, 0x86, 0x6, 0x7c, 0x7f, 0x10, 0x97, 0xc1, 0xa4, 0x43, 0x7a, 0xcc, 0xb9, 0xdf, 0xec, 0xc9, 0x65, 0xd5, 0x76, 0x95, 0x54, 0x26, 0xf0, 0x66, 0xd1, 0xce, 0x72, 0xba, 0xb6, 0xaa, 0x25, 0xb9, 0x44, 0xeb, 0x7c, 0xd9, 0x85, 0x99, 0x88, 0xc9, 0xfc, 0x38, 0xc7, 0x73, 0x98, 0x83, 0x9e, 0x5c, 0x3a, 0x6a, 0x94, 0xe9, 0x19, 0x3, 0x35, 0xfa, 0x8a, 0x20, 0xf2, 0x40, 0xb6, 0x75, 0xa5, 0xe1, 0xf2, 0x54, 0x4f, 0x95, 0x76, 0x59, 0xb5, 0x57, 0xf2, 0xc9, 0x39, 0x3a, 0xa7, 0x99, 0xab, 0xaf, 0xd4, 0xd0, 0xa3, 0x16, 0x96, 0x27, 0xa7, 0x98, 0x51, 0x31, 0xc7, 0xc2, 0xbd, 0xac, 0x9c, 0xce, 0x99, 0xc8, 0xc7, 0x44, 0x37, 0x3c, 0x19, 0x58, 0x2a, 0x14, 0xbe, 0xdb, 0x71, 0x3b, 0x20, 0x68, 0xf1, 0x1, 0xfa, 0xd7, 0x6, 0x0, 0x4c, 0x63, 0xda, 0x2f, 0x56, 0x75, 0x34, 0x7a, 0x9, 0x53, 0x93, 0xbd, 0xe6, 0xe5, 0xeb, 0xac, 0xd2, 0xf8, 0x8b, 0xa, 0xec, 0x69, 0x99, 0xfa, 0xa, 0x16, 0x73, 0xd8, 0xf5, 0x30, 0xc5, 0xa4, 0x3e, 0x65, 0xa7, 0xbb, 0x24, 0x20, 0x2a, 0x7d, 0xdb, 0x5b, 0xe1, 0xb2, 0x30, 0x3b, 0xde, 0xb0, 0x6, 0x5d, 0x3d, 0x2, 0xb8, 0xa3, 0xa7, 0xb7, 0x46, 0x3a, 0xde, 0x75, 0x56, 0x48, 0x19, 0x7f, 0x99, 0x1d, 0xb4, 0xe7, 0x33, 0x79, 0x94, 0x8d, 0x1, 0xd6, 0x6f, 0x88, 0xe6, 0x5, 0x28, 0x5a, 0x14, 0x15, 0x1c, 0x6a, 0x3, 0x26, 0x43, 0x2c, 0x40, 0x5, 0xa8, 0x52, 0xb6, 0xfe, 0x74, 0x10, 0xe7, 0xa7, 0x74, 0xba, 0x17, 0xd8, 0x6f, 0x8b, 0xed, 0x48, 0xd8, 0x3a, 0x77, 0x7f, 0xcc, 0xfa, 0x8, 0xff, 0x6c, 0xf, 0x4a, 0xf9, 0xb4, 0x4d, 0x20, 0x2, 0x2d, 0xd7, 0x11, 0xb1, 0xf9, 0xfa, 0x88, 0xa3, 0x38, 0xae, 0x41, 0x28, 0x68, 0xde, 0xef, 0xd9, 0xad, 0x16, 0x1a, 0x91, 0xc, 0xd5, 0x5f, 0x33, 0x75, 0xca, 0x69, 0x9f, 0x8f, 0x3f, 0x2c, 0x32, 0x76, 0xe3, 0xc, 0x2e, 0xec, 0xce, 0x99, 0xbd, 0x8f, 0x25, 0x4c, 0xfc, 0xa7, 0x47, 0xfc, 0x39, 0x8d, 0x96, 0xc3, 0xc9, 0xb5, 0x62, 0x1e, 0xcf, 0x8d, 0xc7, 0x77, 0xd4, 0x7, 0x53, 0x44, 0xfd, 0xd0, 0xe9, 0x92, 0x91, 0x55, 0x6c, 0x9c, 0xa5, 0x86, 0xcb, 0x5f, 0x6, 0xf1, 0xcc, 0xa3, 0x2c, 0x11, 0x94, 0xff, 0x82, 0xf2, 0x7, 0x92, 0x44, 0xa, 0xdf, 0x15, 0xc1, 0x76, 0xd0, 0x1a, 0x4c, 0x4f, 0xf0, 0x4a, 0x2, 0xd2, 0xd8, 0xa, 0x47, 0x6a, 0x5b, 0xbb, 0xb1, 0xeb, 0x3b, 0x56, 0xf1, 0xdc, 0x76, 0xc4, 0xb0, 0x60, 0x2c, 0x50, 0xb6, 0x2a, 0x6d, 0xb0, 0xe1, 0x60, 0xc4, 0x3d, 0xf6, 0xc8, 0x78, 0x82, 0x96, 0x6b, 0xce, 0x7c, 0x33, 0xcc, 0xe7, 0x9b, 0xca, 0x7c, 0xd2, 0x65, 0x1, 0x48, 0x58, 0xac, 0xd6, 0xf0, 0x60, 0x6e, 0x2d, 0x25, 0xb9, 0xa4, 0x94, 0x9, 0xe4, 0x1b, 0x2b, 0x17, 0xde, 0xb2, 0x4e, 0xf5, 0xeb, 0xe3, 0x4c, 0xc7, 0x13, 0xd5, 0xce, 0xcf, 0xd5, 0xeb, 0x56, 0xa, 0x8a, 0xdb, 0xb4, 0x56, 0x99, 0xb2, 0xea, 0x19, 0x87, 0x6e, 0xc9, 0xf2, 0x16, 0xbe, 0xb5, 0x41, 0x44, 0x60, 0x4, 0x89, 0x8e, 0xe0, 0xfb, 0x56, 0x3, 0x3a, 0xbe, 0xe5, 0xda, 0xfe, 0x1b, 0x2a, 0x19, 0x6f, 0x11, 0xe7, 0x41, 0xe1, 0x64, 0x45, 0xb1, 0xe8, 0x82, 0xc2, 0xce, 0x6e, 0x5f, 0x43, 0x3c, 0x6b, 0xbf, 0x25, 0x8a, 0xc9, 0xaf, 0xc8, 0x14, 0x53, 0xd4, 0xf9, 0x5d, 0x9c, 0x37, 0x56, 0x8, 0x8e, 0x42, 0x88, 0xfb, 0xfd, 0xb8, 0x1a, 0x72, 0xe1, 0xf2, 0xe5, 0xa4, 0xad, 0xb9, 0x9e, 0xb6, 0x6, 0xe6, 0xb5, 0xaa, 0x48, 0x4e, 0x57, 0x8d, 0x97, 0xeb, 0x10, 0xbe, 0xc9, 0x72, 0xd2, 0x7a, 0xef, 0x24, 0x44, 0xf3, 0x40, 0x63, 0x4e, 0xad, 0x3a, 0xa6, 0x81, 0xc0, 0xa4, 0x3f, 0x4, 0x73, 0x5e, 0xd7, 0x44, 0x52, 0x5e, 0x18, 0xc3, 0xec, 0x9d, 0xd2, 0x22, 0x13, 0xf8, 0xf9, 0x9e, 0xa6, 0x33, 0x41, 0x27, 0xbf, 0xc0, 0xd7, 0x3, 0x67, 0x7e, 0x15, 0xa4, 0x13, 0xb1, 0xf2, 0x88, 0x6, 0x23, 0x4a, 0xd5, 0x10, 0x6d, 0x1c, 0x93, 0xa0, 0xa5, 0x44, 0x67, 0x33, 0x6b, 0xc0, 0x2a, 0xd7, 0x12, 0x91, 0x60, 0x5a, 0x87, 0xbf, 0x26, 0xc9, 0x5a, 0x38, 0x28, 0x52, 0xc4, 0x8e, 0x1, 0x7f, 0x8, 0x2f, 0x72, 0x89, 0xc5, 0x7e, 0x3e, 0x92, 0x43, 0x65, 0x8e, 0x9c, 0x10, 0x52, 0x36, 0x37, 0xfe, 0xdb, 0x5b, 0x36, 0x87, 0x30, 0x50, 0x31, 0x62, 0x1a, 0x6a, 0x62, 0xf6, 0x50, 0x72, 0xd5, 0x72, 0xe3, 0x53, 0x25, 0xf3, 0xf4, 0x7b, 0xb3, 0x68, 0x3e, 0x43, 0x7c, 0x1f, 0x64, 0x82, 0x50, 0x4, 0x6f, 0x46, 0x2f, 0xf6, 0x14, 0x3a, 0x37, 0x2a, 0xec, 0x2a, 0x80, 0xa9, 0x99, 0x82, 0x3a, 0xdb, 0x2b, 0xa6, 0x58, 0x64, 0xa7, 0xc8, 0x5, 0x5a, 0x1f, 0x38, 0xe8, 0xa4, 0x55, 0x31, 0x3f, 0xa4, 0xf0, 0x91, 0x8, 0x76, 0x9, 0xc8, 0x48, 0x99, 0x64, 0x1b, 0x94, 0x4a, 0x2d, 0x76, 0x4f, 0x5a, 0xff, 0x93, 0x59, 0x94, 0x4b, 0x33, 0xd0, 0xad, 0x0, 0x5, 0xc0, 0x8b, 0xac, 0x0, 0x3b, 0xa1, 0x4d, 0x50, 0x86, 0xa8, 0x8d, 0x3c, 0x12, 0xfb, 0xff, 0x8c, 0xa5, 0xd5, 0x19, 0x50, 0x68, 0xbc, 0x84, 0xef, 0x66, 0x82, 0xac, 0x2e, 0x27, 0x9c, 0x0, 0x82, 0xdd, 0xa, 0xbf, 0x42, 0x33, 0x3e, 0x7e, 0x52, 0xcf, 0x8b, 0xd1, 0x25, 0x3b, 0xc2, 0x66, 0xf4, 0x12, 0xd0, 0x50, 0xc9, 0xcd, 0x2e, 0x2d, 0xd3, 0xa8, 0x14, 0xc5, 0x92, 0x19, 0x32, 0x3, 0x54, 0x7a, 0x6f, 0xd0, 0xce, 0x70, 0x43, 0x60, 0xfd, 0x98, 0x44, 0xfa, 0x1f, 0xb7, 0x89, 0x18, 0x11, 0x75, 0xd0, 0x89, 0xdb, 0x4d, 0xb8, 0x65, 0x9c, 0x5e, 0x2b, 0xc9, 0x91, 0xf2, 0x13, 0x44, 0x22, 0x85, 0x87, 0x94, 0x15, 0x61, 0x85, 0x93, 0xea, 0x76, 0xfb, 0xcf, 0x34, 0x6, 0x7e, 0x7e, 0xe0, 0xb5, 0xba, 0xb7, 0x8d, 0x26, 0xb2, 0xa4, 0x96, 0x4b, 0xfa, 0xdd, 0x9f, 0xcf, 0x47, 0x70, 0xed, 0xc6, 0x2c, 0x7, 0x47, 0x80, 0xc, 0xe5, 0x82, 0xbe, 0x6c, 0x3d, 0x44, 0xdc, 0xf6, 0xb4, 0x48, 0x98, 0x81, 0x3, 0xc4, 0xff, 0x81, 0xc5, 0x22, 0x48, 0x38, 0xf7, 0x21, 0x68, 0x98, 0x5b, 0x24, 0x1e, 0x88, 0xd2, 0xce, 0x3b, 0x5, 0x86, 0x4b, 0x3d, 0xaa, 0xbf, 0xe8, 0x6, 0x33, 0x30, 0x76, 0x5b, 0xd1, 0x9, 0x37, 0x83, 0xae, 0x2a, 0x2a, 0x10, 0x4d, 0x32, 0x58, 0xcf, 0x2, 0x82, 0xe5, 0x16, 0x58, 0x57, 0xfc, 0xe9, 0x61, 0xfa, 0xd5, 0x62, 0x7f, 0x50, 0x8c, 0x40, 0x12, 0xa4, 0x5f, 0x61, 0x60, 0x2d, 0x7, 0x6c, 0xb2, 0x10, 0x8e, 0xfb, 0x8d, 0x96, 0x3f, 0x26, 0x6e, 0xdc, 0xc1, 0x72, 0xf0, 0x72, 0x9f, 0x3b, 0x43, 0x91, 0xb1, 0x92, 0x86, 0x8c, 0x90, 0xb5, 0x8e, 0xf8, 0x3c, 0xfd, 0x71, 0x3a, 0x27, 0xcc, 0x84, 0x94, 0xba, 0x5a, 0xb9, 0xec, 0x88, 0xb3, 0x3b, 0xe6, 0xf5, 0xdd, 0x3, 0xc1, 0x5e, 0x1c, 0x2a, 0x84, 0xc1, 0xbb, 0x9a, 0x13, 0xff, 0x49, 0x67, 0xfb, 0x20, 0x88, 0x4f, 0xcf, 0xd9, 0xf1, 0x7, 0xe1, 0x34, 0x5, 0x30, 0x7a, 0x1e, 0x52, 0x4a, 0xb8, 0x80, 0x43, 0x34, 0x10, 0x86, 0x10, 0xb1, 0x2b, 0xc3, 0xec, 0xb2, 0xe7, 0xb6, 0xc0, 0x20, 0x85, 0xa5, 0x93, 0x20, 0x80, 0x27, 0xa4, 0xe5, 0x25, 0xbe, 0x7d, 0x4a, 0x15, 0x6b, 0x97, 0x56, 0x25, 0xdb, 0x2d, 0x87, 0x9, 0x7d, 0xe, 0xa3, 0x69, 0x17, 0x92, 0xc, 0x47, 0xd9, 0xd, 0xac, 0xbf, 0xd5, 0x97, 0x8d, 0xc6, 0x2e, 0x11, 0x91, 0x20, 0x17, 0xe2, 0x8d, 0x43, 0x28, 0xb4, 0xce, 0xa1, 0xc5, 0xd4, 0xbb, 0x8f, 0x17, 0x6a, 0xa7, 0x93, 0xbc, 0x82, 0x48, 0xf3, 0xf4, 0xf8, 0xf, 0x52, 0x15, 0x67, 0x83, 0xc4, 0x71, 0x48, 0xce, 0x93, 0xf6, 0xe, 0x33, 0xfb, 0xcc, 0x70, 0x52, 0xa8, 0xcd, 0x49, 0xb, 0xf5, 0x85, 0xa6, 0x7b, 0x27, 0x93, 0x7, 0x76, 0xc7, 0xb6, 0xa7, 0x34, 0xd7, 0xe7, 0x71, 0xb7, 0xde, 0x92, 0x9c, 0xf2, 0x4c, 0x3, 0xb7, 0x7a, 0x27, 0xaf, 0x2f, 0x86, 0xa7, 0x5a, 0xf5, 0x9d, 0x6b, 0xe5, 0x81, 0xe3, 0xd1, 0xbb, 0xfe, 0x1f, 0x6e, 0xf0, 0x70, 0xc7, 0x3f, 0xa4, 0xbf, 0x58, 0xe, 0x87, 0xe7, 0x86, 0x10, 0x9e, 0x57, 0xa0, 0xcc, 0x1d, 0x2, 0x7c, 0xee, 0x30, 0x30, 0xd7, 0x9e, 0xb6, 0x7f, 0x4b, 0xf7, 0x1b, 0xfb, 0x3a, 0x52, 0xf, 0xd6, 0x82, 0x9e, 0xae, 0xe6, 0xf5, 0xac, 0xbc, 0x45, 0xc4, 0xd, 0x2d, 0x19, 0xbf, 0xff, 0xc7, 0x31, 0xe, 0xb0, 0x82, 0xd6, 0x7e, 0x4c, 0xeb, 0x2b, 0x12, 0xbb, 0x77, 0xc3, 0x34, 0xac, 0x9b, 0x24, 0xa5, 0x59, 0xa6, 0x79, 0x47, 0x4a, 0x86, 0x55, 0x9f, 0x52, 0x94, 0x33, 0xb, 0x15, 0x5b, 0x9f, 0x8c, 0x9d, 0x84, 0x58, 0x56, 0xc3, 0x7f, 0x75, 0x60, 0xfc, 0xd9, 0x26, 0xed, 0x8, 0x41, 0xc8, 0xd0, 0x77, 0x24, 0x9b, 0xbc, 0xcb, 0x28, 0xbc, 0x41, 0x8d, 0xdc, 0x7d, 0x18, 0x9f, 0xc0, 0xae, 0xe6, 0x70, 0x74, 0xe9, 0x5f, 0x81, 0x61, 0x9b, 0x87, 0x27, 0x50, 0xf, 0x16, 0x31, 0x7, 0xee, 0x17, 0xf0, 0x6f, 0xda, 0xaa, 0x1e, 0x61, 0x6, 0xfe, 0x55, 0x8c, 0xd0, 0x70, 0x7a, 0xd8, 0x58, 0x84, 0xc5, 0x1e, 0xb5, 0xca, 0x10, 0x86, 0x44, 0xc9, 0x8, 0xed, 0xe0, 0x43, 0x3d, 0xb7, 0x45, 0x93, 0x4, 0x28, 0xb5, 0x64, 0x6, 0xe0, 0x63, 0xcd, 0xdd, 0xb1, 0xa5, 0xc8, 0x35, 0x44, 0x4a, 0x7, 0x33, 0xba, 0x4, 0x97, 0xfe, 0x2c, 0xc, 0xc2, 0x73, 0x9c, 0x37, 0x3e, 0x8f, 0x74, 0xb2, 0x4b, 0xc1, 0xb3, 0xa0, 0x9c, 0x28, 0x65, 0x4e, 0x74, 0xc4, 0x84, 0x2c, 0x5b, 0x17, 0x76, 0x0, 0x97, 0x84, 0xa4, 0x5, 0xb9, 0xf8, 0x1e, 0xa9, 0x61, 0x63, 0x3d, 0xf7, 0xbe, 0x90, 0x85, 0x93, 0xb1, 0xef, 0x82, 0x4e, 0x43, 0xac, 0xb9, 0xeb, 0x4c, 0x39, 0x72, 0xa6, 0x62, 0x46, 0x2c, 0x42, 0xee, 0x1c, 0xe4, 0x6, 0xed, 0x55, 0xdf, 0xe6, 0x24, 0x5e, 0x9c, 0xe1, 0x24, 0xfe, 0x7c, 0x3, 0x8d, 0xea, 0xa1, 0x5e, 0x48, 0x7c, 0xbc, 0x1f, 0xb9, 0xb0, 0xfe, 0xec, 0x15, 0x36, 0xaa, 0x90, 0xf2, 0xec, 0x9f, 0xc, 0x97, 0x9f, 0x36, 0x9f, 0xf5, 0xf, 0xb9, 0x9a, 0x14, 0xd3, 0xc0, 0xaa, 0x9f, 0x94, 0xe6, 0x68, 0xa9, 0x80, 0x1d, 0x51, 0x4d, 0xe6, 0x90, 0x1d, 0xfa, 0x18, 0x91, 0x96, 0xd0, 0xfd, 0xb1, 0xe4, 0x31, 0x3d, 0x55, 0xa3, 0xed, 0x19, 0xe8, 0x76, 0x8e, 0xd8, 0x45, 0xb, 0x38, 0x7b, 0x84, 0x4, 0xbb, 0x9a, 0xd9, 0xdb, 0x1f, 0xa4, 0x8f, 0xb4, 0x3a, 0x2f, 0x5, 0x61, 0x68, 0xf2, 0x36, 0x96, 0x55, 0xd8, 0x38, 0x3c, 0xde, 0xff, 0xcc, 0xdd, 0xb9, 0x21, 0xf0, 0x94, 0x21, 0x34, 0x2, 0x41, 0x68, 0x2c, 0xf1, 0xad, 0x23, 0x3e, 0x48, 0x8d, 0xa9, 0x58, 0x48, 0x95, 0xbb, 0xef, 0xec, 0x36, 0x2, 0x69, 0x3e, 0xbb, 0x7e, 0xca, 0x32, 0xbe, 0x77, 0x3c, 0x91, 0x42, 0x56, 0x9a, 0xcf, 0xc1, 0x88, 0xa9, 0x7d, 0x46, 0x80, 0x1f, 0x61, 0x3d, 0xec, 0x22, 0x6e, 0x82, 0xf2, 0x9e, 0xf0, 0x7c, 0x1e, 0x1, 0x97, 0xf4, 0x46, 0x2b, 0x4f, 0x1f, 0x22, 0xed, 0xe1, 0x3e, 0x12, 0x42, 0xff, 0x51, 0x1, 0x69, 0x31, 0x12, 0xa4, 0x10, 0xaa, 0x59, 0xd4, 0x93, 0x1d, 0x2e, 0x98, 0x99, 0x21, 0x72, 0xaa, 0x4d, 0xf8, 0x18, 0xd, 0x57, 0x1f, 0xea, 0x9e, 0xf9, 0x45, 0x15, 0x91, 0xd, 0x6c, 0xe1, 0x4d, 0x81, 0xed, 0x8f, 0x6, 0xe, 0x8e, 0x6c, 0xfc, 0xcd, 0x16, 0x78, 0xa8, 0x27, 0x73, 0x60, 0x9, 0xdb, 0xc3, 0x8d, 0xe3, 0xd6, 0x3d, 0x2b, 0xf7, 0xab, 0x78, 0xb0, 0xc9, 0xcf, 0x35, 0x24, 0x37, 0x95, 0x27, 0xa7, 0xfe, 0x4a, 0x3, 0x4e, 0x36, 0xdf, 0xaf, 0xb0, 0x18, 0xb5, 0x4f, 0x8, 0xef, 0x3d, 0xd4, 0x19, 0x4, 0xfb, 0xb2, 0x78, 0x2d, 0x63, 0xeb, 0x7b, 0x75, 0x5a, 0x6d, 0x30, 0x6b, 0xcb, 0x0, 0x4f, 0xa, 0x8c, 0xee, 0x31, 0x82, 0xb9, 0x9e, 0xd6, 0xa0, 0x1d, 0xf1, 0x98, 0xa0, 0x2, 0x7d, 0xe4, 0x29, 0x38, 0x6, 0x4d, 0x32, 0xe4, 0x5d, 0x37, 0xa6, 0x13, 0xfa, 0xee, 0x1f, 0x10, 0x75, 0xf6, 0x99, 0x12, 0x56, 0x75, 0xb1, 0x89, 0x8, 0xc2, 0x3a, 0xb0, 0xbe, 0x24, 0x8a, 0x5a, 0x1a, 0xe8, 0xa0, 0x1b, 0x1b, 0xf7, 0x6c, 0xe7, 0x13, 0x71, 0xaf, 0xa5, 0x6c, 0xb3, 0x46, 0x2a, 0x1c, 0x52, 0x46, 0x9a, 0x46, 0xa, 0x35, 0x7e, 0x4c, 0x78, 0x74, 0x22, 0x4c, 0x37, 0xc1, 0x36, 0x6d, 0xb9, 0xfd, 0xd3, 0xa6, 0xf1, 0xf0, 0x8a, 0x67, 0x18, 0xca, 0x45, 0xbb, 0xd3, 0xb1, 0x85, 0xe, 0x74, 0xe2, 0x7e, 0x76, 0x57, 0x1d, 0xc8, 0x9e, 0x53, 0x96, 0xef, 0xd5, 0xc2, 0x8a, 0xa3, 0x7a, 0x61, 0xdd, 0x3f, 0x82, 0xfc, 0x42, 0x57, 0xc0, 0x80, 0xaa, 0xd2, 0x5a, 0xcb, 0x8b, 0x33, 0x6e, 0x5d, 0x9, 0x39, 0x55, 0xdc, 0x68, 0x47, 0xaf, 0x1a, 0xa4, 0xbb, 0xae, 0x31, 0xa0, 0xe6, 0x4b, 0xa5, 0xc0, 0x21, 0x5, 0x3e, 0x85, 0x1e, 0x5, 0xe1, 0xfd, 0x39, 0x8b, 0x5e, 0xca, 0x21, 0x49, 0x21, 0x98, 0x92, 0xec, 0xa, 0x64, 0x4d, 0xf2, 0x27, 0x7b, 0x77, 0xbd, 0xa8, 0x35, 0x72, 0xa7, 0x90, 0x6b, 0x16, 0x8a, 0x9a, 0xb1, 0x73, 0x70, 0xab, 0x9e, 0x24, 0xb5, 0x76, 0x67, 0xf9, 0xde, 0x50, 0x3f, 0xf0, 0xb1, 0xf9, 0xb7, 0x98, 0xdd, 0xa9, 0x99, 0x96, 0x35, 0x6c, 0xf6, 0x5, 0x55, 0xdc, 0x63, 0xee, 0x40, 0xb2, 0x3c, 0x77, 0xfc, 0xe4, 0x38, 0x79, 0xc, 0x8f, 0x25, 0x0, 0x30, 0x3, 0x32, 0xa, 0xba, 0x73, 0x1a, 0x2f, 0x23, 0x37, 0x25, 0xff, 0x7d, 0x62, 0xa4, 0x9e, 0x76, 0xbc, 0xeb, 0x7e, 0xc7, 0x6f, 0x58, 0x55, 0x8c, 0x2, 0x56, 0x72, 0xd7, 0x14, 0x4e, 0x59, 0x43, 0x40, 0x8f, 0x4d, 0xaf, 0x60, 0xe4, 0xd9, 0x91, 0x99, 0xb, 0x51, 0xf, 0x54, 0x85, 0x51, 0xf2, 0xab, 0xac, 0x99, 0x6e, 0x60, 0x3f, 0x55, 0x90, 0x51, 0xc4, 0xa8, 0x2c, 0x81, 0x81, 0xe9, 0x67, 0xee, 0xe7, 0x2e, 0x5, 0xae, 0x35, 0x8, 0xe1, 0x81, 0xdb, 0x54, 0xc8, 0xee, 0xa4, 0xc0, 0x5d, 0x2c, 0x94, 0x40, 0x52, 0x1e, 0xb1, 0x93, 0x8, 0xb3, 0xd5, 0xf0, 0xb5, 0x48, 0x59, 0x2, 0xa6, 0xb0, 0x1a, 0x5a, 0xe0, 0x4f, 0xa, 0x4d, 0x57, 0x12, 0xc2, 0x83, 0x8c, 0x81, 0x50, 0x98},
+               output224: []byte{0x13, 0xb7, 0x2f, 0x2c, 0xba, 0x9f, 0x9a, 0x26, 0x92, 0x2e, 0xe7, 0xa8, 0xe5, 0x72, 0x2a, 0xed, 0xd6, 0x27, 0x82, 0xd4, 0x67, 0x96, 0x49, 0xec, 0xa6, 0xcb, 0x48, 0xc6},
+               output256: []byte{0xab, 0x9b, 0xeb, 0xef, 0x5, 0x3a, 0xd5, 0x70, 0x60, 0xfb, 0xa, 0x7c, 0xbf, 0xc7, 0xe4, 0x2a, 0x6d, 0x78, 0xb4, 0x9f, 0x60, 0xcd, 0xb5, 0xaa, 0x8b, 0xd3, 0xbc, 0xe1, 0x73, 0xb5, 0xc2, 0xb7},
+               output384: []byte{0x92, 0x91, 0xd0, 0x1c, 0x91, 0x3e, 0xe2, 0x5e, 0x11, 0xc1, 0x6a, 0x2f, 0xd2, 0x4e, 0x89, 0xab, 0x9, 0x14, 0x91, 0xfb, 0xfb, 0xe8, 0x5a, 0xde, 0x41, 0x12, 0x28, 0xac, 0x35, 0xc2, 0x8d, 0xc0, 0xce, 0x9b, 0x2e, 0x9a, 0x9, 0x8, 0xad, 0x28, 0x8b, 0x3b, 0xf8, 0x8c, 0x49, 0x29, 0xae, 0x5},
+               output512: []byte{0x6, 0x7, 0x15, 0xba, 0xf2, 0x20, 0xba, 0xce, 0xab, 0x6e, 0xf1, 0x57, 0x56, 0x98, 0x5c, 0xc0, 0xcc, 0x2d, 0x60, 0x85, 0x40, 0x99, 0x51, 0x6, 0x20, 0x89, 0x6b, 0x76, 0x53, 0x20, 0x4d, 0xfa, 0x9e, 0x57, 0xfd, 0xbb, 0xa3, 0x45, 0x5c, 0x63, 0x7e, 0xd4, 0x88, 0xc1, 0xa1, 0x3e, 0x6c, 0x67, 0x89, 0x38, 0x49, 0xbc, 0x1, 0x7c, 0x34, 0x18, 0x45, 0x48, 0x5a, 0x3a, 0x8c, 0x38, 0x8c, 0xf3}},
+       testcase{
+               msg:       []byte{0x94, 0x13, 0x3b, 0x8e, 0x14, 0x78, 0x5f, 0xc1, 0x95, 0x65, 0xa3, 0xaf, 0xa, 0xef, 0x60, 0x46, 0x2b, 0xb7, 0xf8, 0x4, 0x5e, 0x2e, 0xdf, 0x4a, 0x83, 0x67, 0x18, 0x56, 0x1a, 0xee, 0xfb, 0xd0, 0x38, 0x24, 0x34, 0xd3, 0x19, 0x21, 0x1c, 0x67, 0xf, 0xc6, 0x99, 0xd2, 0x5f, 0x2, 0xec, 0x60, 0x8c, 0xfe, 0xd9, 0x78, 0x6b, 0x7d, 0xa7, 0xe, 0x55, 0x95, 0xac, 0x81, 0x66, 0x88, 0x45, 0x5c, 0xbc, 0xb4, 0x44, 0x95, 0x36, 0xe8, 0xad, 0x20, 0x86, 0x3d, 0x76, 0x93, 0x77, 0x96, 0xcb, 0xc, 0x59, 0x99, 0x18, 0xa2, 0x1a, 0x1, 0x33, 0xb6, 0xc6, 0x25, 0xb2, 0x0, 0xb, 0xed, 0x88, 0x84, 0xfc, 0x86, 0x35, 0x6f, 0xd7, 0x42, 0xaf, 0x78, 0xbb, 0x55, 0xd6, 0x52, 0xce, 0x48, 0x92, 0xe7, 0xc2, 0x96, 0x85, 0x3a, 0x40, 0xaf, 0x29, 0x11, 0x6c, 0xc9, 0x8d, 0x38, 0x87, 0x4c, 0xa0, 0xf8, 0xbb, 0x5f, 0x6e, 0xc8, 0xc0, 0x4d, 0xd7, 0xf3, 0xf9, 0x68, 0x18, 0x58, 0xe0, 0xcd, 0x54, 0xd8, 0xf9, 0xb5, 0xa, 0x83, 0xc, 0x31, 0xa9, 0x78, 0x1e, 0x70, 0xf6, 0x3e, 0x59, 0x22, 0xb0, 0x86, 0x17, 0x80, 0x21, 0x4, 0x4, 0x4e, 0xc2, 0xed, 0x28, 0x56, 0x6e, 0x39, 0x53, 0x4f, 0xa8, 0x85, 0x95, 0x73, 0xf0, 0x24, 0xca, 0x38, 0x1d, 0x87, 0xbd, 0x6e, 0x4, 0x60, 0x7b, 0x94, 0x40, 0xd3, 0xb7, 0xd4, 0xef, 0xf, 0xd1, 0x72, 0xa6, 0xb8, 0xfd, 0xfa, 0x22, 0x35, 0xd4, 0x6b, 0xaa, 0xe0, 0x77, 0x84, 0x67, 0xbf, 0xed, 0x91, 0xd3, 0x3c, 0x8d, 0xac, 0x9d, 0xb5, 0xe7, 0xeb, 0x6c, 0x69, 0xff, 0xcc, 0x2e, 0x9f, 0x2d, 0x6b, 0x5f, 0x53, 0xec, 0xc8, 0x0, 0x30, 0x61, 0x3, 0xd8, 0x6c, 0xcb, 0x1e, 0x34, 0x83, 0xea, 0x2a, 0xc3, 0x49, 0xeb, 0xa3, 0x83, 0x31, 0x74, 0xd5, 0xcf, 0x5, 0x8b, 0x8c, 0xa8, 0x28, 0x55, 0xa9, 0x38, 0xa6, 0xd3, 0x82, 0x72, 0x85, 0x1b, 0x19, 0x77, 0x31, 0x9a, 0xd7, 0x8a, 0x96, 0xa5, 0x9b, 0x7d, 0x63, 0x0, 0x83, 0x6b, 0xb, 0x21, 0x99, 0x74, 0xca, 0xf8, 0x77, 0x6b, 0xab, 0x7a, 0xbf, 0x46, 0x65, 0x75, 0x7f, 0x9c, 0xc9, 0x41, 0x29, 0x9a, 0x96, 0x99, 0x8d, 0x3a, 0x91, 0xd, 0xd4, 0x1f, 0xaf, 0x26, 0xd4, 0xab, 0x54, 0x40, 0x8f, 0xdb, 0x92, 0xf, 0xde, 0x1d, 0x61, 0x4a, 0x8, 0xc2, 0xf0, 0x27, 0x16, 0xa1, 0x7a, 0xc3, 0xa9, 0x85, 0x54, 0xd9, 0x27, 0x1f, 0x64, 0x4d, 0xd, 0x74, 0xc0, 0xd4, 0xa7, 0x5c, 0x66, 0x3a, 0xb8, 0xfd, 0xcb, 0xcb, 0xb7, 0x5b, 0x25, 0x0, 0x96, 0xc1, 0x56, 0x36, 0x6e, 0xe1, 0xa3, 0xdf, 0xdc, 0x6b, 0x28, 0x29, 0x9b, 0x38, 0xc0, 0xc1, 0x4b, 0xb6, 0x85, 0xa8, 0x9a, 0xcf, 0x6c, 0x41, 0xac, 0xab, 0xf6, 0xb3, 0xc6, 0x74, 0x5d, 0x8, 0xf7, 0x38, 0x11, 0x0, 0x9e, 0x9e, 0x5e, 0xa8, 0x68, 0xd4, 0x69, 0xa0, 0xc8, 0xcc, 0x35, 0xd8, 0x3e, 0x99, 0xb2, 0xda, 0x57, 0xd2, 0x2, 0x32, 0x4e, 0xdf, 0x5, 0x58, 0xe7, 0x63, 0x2d, 0xe7, 0x82, 0x74, 0xc, 0xea, 0x7d, 0x6c, 0x4d, 0xb9, 0x59, 0xf, 0x67, 0x5c, 0xed, 0x9e, 0x6c, 0x27, 0xc8, 0xd3, 0x98, 0x84, 0x99, 0xd, 0x7b, 0x68, 0x5c, 0x89, 0xf7, 0xe, 0x55, 0xe0, 0x84, 0xac, 0x8c, 0x1f, 0x36, 0x6a, 0x2b, 0x8e, 0xa8, 0x93, 0x70, 0xe7, 0xf7, 0xd7, 0x24, 0xeb, 0x91, 0x70, 0x72, 0x9e, 0x20, 0xbb, 0x18, 0xc7, 0x2, 0x6b, 0xfd, 0xa8, 0xbe, 0x4a, 0x98, 0x13, 0x17, 0x2b, 0x76, 0xf7, 0x2b, 0x7f, 0xf8, 0xfd, 0xd3, 0x1f, 0x3a, 0xd4, 0x72, 0x82, 0x97, 0x9d, 0xfa, 0x87, 0x4, 0x92, 0x80, 0x42, 0xc2, 0x4a, 0xe3, 0x98, 0x5, 0xa, 0x4f, 0x43, 0x84, 0x51, 0x79, 0x1, 0xa3, 0xa2, 0xd4, 0x23, 0xc, 0x56, 0xa0, 0xcf, 0x3b, 0xca, 0x92, 0x8a, 0xb2, 0x11, 0xbc, 0xd2, 0xbc, 0xd4, 0xef, 0xb, 0x73, 0xda, 0xf6, 0x2, 0x40, 0xf3, 0x9a, 0xc0, 0x1a, 0x7a, 0xb2, 0x9d, 0xc8, 0x8, 0x96, 0xf6, 0x11, 0x8a, 0x56, 0xdb, 0x95, 0x76, 0x62, 0xc2, 0x5, 0x8f, 0x4, 0x58, 0x24, 0xda, 0x79, 0xda, 0x35, 0xef, 0xdb, 0xa1, 0xf8, 0xd7, 0x10, 0x94, 0x15, 0x46, 0x43, 0xa5, 0x70, 0xde, 0xa9, 0x5f, 0x30, 0xcd, 0x28, 0xf2, 0x8a, 0xac, 0x3f, 0x32, 0x4, 0x13, 0x25, 0x71, 0xcf, 0x9c, 0xb6, 0x88, 0xd2, 0x7a, 0xdc, 0x77, 0x66, 0x2a, 0xe9, 0x25, 0xb7, 0x5f, 0x3f, 0xa3, 0x85, 0x4f, 0xb8, 0x49, 0xc4, 0x45, 0xd, 0x4c, 0xb6, 0x16, 0x97, 0x88, 0xe2, 0xaa, 0x6a, 0xf6, 0x3a, 0x30, 0xc3, 0x65, 0x4b, 0x81, 0xd0, 0x8a, 0xa1, 0x18, 0x77, 0x3b, 0x87, 0xd0, 0xf7, 0x6b, 0x7a, 0xc4, 0x43, 0x24, 0x66, 0x58, 0x66, 0x2b, 0xef, 0x13, 0x2e, 0xd1, 0x32, 0x18, 0x49, 0x8f, 0xe, 0x46, 0x46, 0xec, 0x77, 0x82, 0xf6, 0x3b, 0x1, 0x69, 0xda, 0x78, 0x90, 0xc6, 0x82, 0xa2, 0xd0, 0x46, 0xe1, 0x3c, 0x9, 0x6f, 0xe5, 0x21, 0xe4, 0xe4, 0x28, 0x51, 0x61, 0x7d, 0xfe, 0xaf, 0x85, 0xcb, 0x36, 0x6c, 0x6d, 0xa7, 0xce, 0x65, 0x65, 0x53, 0x26, 0x4b, 0xf6, 0x73, 0x90, 0x68, 0x72, 0xce, 0x8e, 0xf4, 0x45, 0x2c, 0x9, 0x93, 0xb2, 0xf5, 0x19, 0x1f, 0x2e, 0x83, 0x11, 0x7e, 0x2e, 0x8d, 0x66, 0xd3, 0xfd, 0x83, 0x33, 0xf0, 0xde, 0xbb, 0xc9, 0xd2, 0xb1, 0xad, 0xd3, 0x1e, 0xd8, 0x7, 0xbf, 0x3d, 0xd2, 0xdc, 0x5, 0x6a, 0x25, 0x90, 0xf8, 0xfb, 0x1c, 0xaa, 0x31, 0xd1, 0x10, 0xf3, 0x89, 0xdf, 0xb0, 0x45, 0xc2, 0x67, 0x6, 0x80, 0x2a, 0xcb, 0x2b, 0x4e, 0x7a, 0x2c, 0x1e, 0x59, 0x71, 0xd0, 0x79, 0x20, 0xa5, 0x8f, 0xdf, 0x2e, 0x30, 0xa4, 0x87, 0x56, 0xa2, 0xbe, 0x92, 0xfc, 0x47, 0x29, 0xe5, 0xa7, 0x79, 0xd6, 0x1e, 0x82, 0x47, 0x76, 0x3, 0xce, 0xc7, 0x30, 0x88, 0xc1, 0x23, 0x14, 0xcc, 0x89, 0xc9, 0x9c, 0xa, 0xc9, 0x1e, 0x41, 0xf7, 0x2e, 0x83, 0x9, 0x56, 0xf3, 0x51, 0xd5, 0x60, 0x13, 0x6f, 0xa2, 0x41, 0x2f, 0x5a, 0x47, 0xf6, 0x27, 0xf5, 0x72, 0x4a, 0x73, 0xfd, 0x4c, 0x58, 0x4c, 0x9a, 0xb6, 0x2f, 0x2, 0x83, 0x42, 0x27, 0x8e, 0x96, 0xb7, 0xf3, 0xf1, 0xed, 0xd2, 0x70, 0xca, 0x45, 0xbc, 0x8b, 0x56, 0x73, 0x97, 0x10, 0x7, 0xfc, 0x55, 0x7e, 0x9c, 0x3f, 0x1c, 0xf7, 0xa6, 0x5c, 0x80, 0x42, 0x65, 0x2, 0x21, 0x3e, 0xe2, 0xd5, 0xf3, 0x2a, 0xa7, 0x26, 0xc3, 0x36, 0x89, 0x4e, 0x35, 0xae, 0x3f, 0xa3, 0xdc, 0x45, 0x2f, 0x1e, 0x13, 0xf9, 0x4d, 0x6a, 0xa2, 0xba, 0x5a, 0xe7, 0x97, 0x5c, 0x14, 0xc3, 0xc2, 0x80, 0x4f, 0xe7, 0x19, 0x98, 0xac, 0x48, 0x12, 0x41, 0xc6, 0x6f, 0xb8, 0x1a, 0xd6, 0x21, 0x57, 0xe4, 0x5, 0x88, 0x84, 0x93, 0x1c, 0x93, 0xda, 0x6c, 0x37, 0x7f, 0xac, 0x5d, 0xfa, 0xd4, 0xc6, 0xfa, 0xa5, 0x5, 0x46, 0x1b, 0xab, 0x4f, 0xa8, 0x52, 0x66, 0x92, 0x2b, 0x28, 0x27, 0xbf, 0x3b, 0x9a, 0x43, 0x1e, 0xaf, 0x25, 0xc5, 0xac, 0xcf, 0x83, 0x9f, 0x78, 0xa0, 0x2, 0x9e, 0xd, 0xba, 0xba, 0x8a, 0x2d, 0x52, 0xb7, 0xe0, 0x20, 0x32, 0x63, 0xb6, 0xc2, 0x65, 0xb0, 0x3c, 0x97, 0x60, 0xc, 0x75, 0x39, 0x12, 0x9c, 0x3e, 0xba, 0x3b, 0x55, 0xca, 0x88, 0x20, 0x32, 0x79, 0x20, 0x55, 0x9d, 0x86, 0x87, 0x81, 0x36, 0xe4, 0x4, 0x60, 0xc4, 0x5f, 0x5e, 0x3e, 0xd4, 0xd0, 0xa8, 0x4e, 0x81, 0xbc, 0x2a, 0xf6, 0x84, 0x73, 0xae, 0x7c, 0x9e, 0xec, 0xa6, 0x2e, 0x55, 0x91, 0x72, 0x9d, 0xea, 0xe7, 0x4c, 0x4a, 0xcc, 0x97, 0x4b, 0xb9, 0x98, 0xbf, 0x6f, 0xe0, 0x1c, 0xd2, 0xa7, 0x81, 0xf1, 0x1, 0x46, 0xca, 0xca, 0xc6, 0x6a, 0x49, 0x29, 0x5, 0x97, 0x3b, 0x6, 0xc3, 0x91, 0x7c, 0x72, 0x26, 0x8f, 0xf8, 0x9e, 0x84, 0x73, 0x6a, 0xe3, 0x86, 0xec, 0xa2, 0x91, 0x3c, 0xef, 0xea, 0x3d, 0x55, 0xc6, 0xcc, 0xb3, 0x92, 0xd1, 0xb1, 0xc1, 0x62, 0x72, 0x69, 0xc0, 0x60, 0x96, 0x2a, 0xbe, 0xee, 0xa3, 0x88, 0x79, 0x1f, 0x5b, 0xd4, 0xea, 0xeb, 0x1f, 0xe0, 0x33, 0x8b, 0xf1, 0x8f, 0xc3, 0x40, 0x1b, 0xe0, 0xb7, 0xab, 0x55, 0xc2, 0x8f, 0xbc, 0xda, 0xda, 0x3a, 0xd2, 0xb3, 0x9e, 0x7b, 0xff, 0x28, 0xf4, 0xf8, 0xf3, 0x11, 0x73, 0x39, 0xe, 0xef, 0xdc, 0x99, 0x27, 0xa0, 0x66, 0xa5, 0x54, 0xe8, 0x17, 0x5b, 0x92, 0xef, 0xb8, 0x80, 0x8c, 0x92, 0x52, 0x74, 0x89, 0x19, 0x4c, 0x61, 0x92, 0xd7, 0xf1, 0xcd, 0xa7, 0x8a, 0xce, 0xea, 0xc7, 0x7e, 0x67, 0xba, 0x50, 0x2f, 0x79, 0x4e, 0x6d, 0xa3, 0xda, 0xdb, 0x8c, 0x12, 0xe5, 0xec, 0x43, 0x6a, 0x1a, 0xe0, 0xaf, 0x57, 0x1f, 0x34, 0xa9, 0xb5, 0xed, 0xcc, 0x64, 0xa8, 0xed, 0x34, 0x35, 0x4e, 0x36, 0xeb, 0x67, 0xe8, 0xd6, 0x16, 0x31, 0x70, 0x75, 0x16, 0xf, 0x72, 0x52, 0x2, 0xb8, 0x32, 0xc7, 0xac, 0xd6, 0x49, 0xa8, 0x6f, 0xf7, 0xb1, 0x35, 0x96, 0xa, 0x3f, 0x29, 0x57, 0x86, 0x97, 0x6d, 0xac, 0x96, 0x63, 0x7d, 0x94, 0x9e, 0xcd, 0xda, 0x43, 0xe7, 0x1, 0x4c, 0x45, 0x1e, 0xe5, 0xe, 0xc7, 0x52, 0xbb, 0x20, 0xc8, 0xde, 0xfb, 0x19, 0x92, 0x7, 0xc6, 0xb2, 0xbb, 0xd, 0xcd, 0x1f, 0xb2, 0x12, 0xe6, 0xdb, 0x26, 0x47, 0x6b, 0xb3, 0xe9, 0xf, 0x5e, 0xd2, 0xb9, 0xcb, 0xb3, 0xf1, 0xc2, 0x43, 0xda, 0xdc, 0xc6, 0x22, 0xcb, 0x50, 0x3d, 0x8, 0xff, 0x4b, 0x26, 0x6a, 0x74, 0x2c, 0x5c, 0x61, 0xa4, 0xff, 0xf2, 0x3d, 0xe2, 0x5c, 0xad, 0x7c, 0x3d, 0x13, 0xc2, 0xab, 0x50, 0xad, 0x2a, 0xe7, 0x7b, 0xff, 0x6e, 0x1b, 0x18, 0xe5, 0x93, 0x28, 0x3a, 0xb, 0xb4, 0xaf, 0xd6, 0x11, 0x1c, 0x9b, 0x5d, 0x5d, 0x6, 0x2f, 0x77, 0xeb, 0x2c, 0xe8, 0x7, 0x15, 0x61, 0xa7, 0x96, 0xce, 0xdd, 0x4c, 0x4f, 0x81, 0x93, 0x73, 0x68, 0x5b, 0x4c, 0x3d, 0x3d, 0x14, 0xbe, 0x5b, 0xc2, 0xa, 0x72, 0xeb, 0x9c, 0x6c, 0x2c, 0x17, 0x65, 0xba, 0x88, 0x76, 0x8, 0x15, 0x73, 0x54, 0xd0, 0xa5, 0xbc, 0x1f, 0x41, 0x58, 0xd2, 0x3e, 0xcf, 0x30, 0xae, 0x3b, 0x3b, 0xef, 0x24, 0xbc, 0xf8, 0x53, 0xf, 0x13, 0xb7, 0xfe, 0xa5, 0x47, 0x22, 0xb5, 0x7a, 0x76, 0x11, 0x69, 0xcc, 0x82, 0x76, 0x34, 0xa8, 0x43, 0x14, 0xf6, 0x97, 0xb0, 0x90, 0x42, 0x5b, 0xdf, 0x9e, 0xbd, 0xf8, 0x8a, 0x6b, 0x53, 0x51, 0x5e, 0x1, 0xd3, 0x19, 0x4a, 0x8d, 0xec, 0x7b, 0x8e, 0x15, 0xba, 0xba, 0xff, 0x42, 0xe0, 0xe0, 0xcb, 0xd1, 0xdf, 0x28, 0x6a, 0x25, 0xc1, 0xfe, 0x39, 0x34, 0x20, 0x1e, 0xe1, 0x94, 0x47, 0xeb, 0x1e, 0x29, 0xbf, 0x9d, 0xdc, 0xd1, 0x4e, 0xc9, 0x50, 0x8a, 0xc2, 0x13, 0xce, 0x17, 0xc6, 0xa5, 0xba, 0x3b, 0xcd, 0x20, 0x7d, 0x1e, 0x41, 0xac, 0xc4, 0xfc, 0xf9, 0xef, 0x40, 0xee, 0xa8, 0x94, 0x3d, 0xff, 0xa2, 0x82, 0x20, 0xf, 0x37, 0x72, 0x44, 0x13, 0xa4, 0x38, 0xba, 0xdc, 0x59, 0xa1, 0x3a, 0x7, 0xca, 0xf1, 0x63, 0x35, 0xf, 0x26, 0x63, 0xd2, 0xb3, 0x81, 0xc1, 0x43, 0x63, 0xe2, 0x37, 0x2e, 0x30, 0xfa, 0xf1, 0x38, 0x1a, 0x89, 0x36, 0xb6, 0x1d, 0xf5, 0x37, 0x5, 0x62, 0xbd, 0xba, 0xa1, 0x10, 0x2b, 0x65, 0x89, 0xdb, 0x74, 0xc6, 0x35, 0xc7, 0x91, 0x94, 0x2a, 0x5e, 0xc1, 0x48, 0xf6, 0x6d, 0xab, 0x80, 0x3f, 0x46, 0x9f, 0x6c, 0x39, 0xdc, 0x22, 0x5f, 0xba, 0x4e, 0xc8, 0x7b, 0xde, 0x2d, 0x5e, 0xa3, 0x1e, 0xb5, 0x17, 0xf3, 0xa4, 0x38, 0x35, 0xd4, 0xb8, 0x8c, 0x55, 0x6e, 0x84, 0xd6, 0x3b, 0x26, 0x89, 0x4b, 0xda, 0xdf, 0xc4, 0x62, 0x4e, 0xcb, 0x43, 0x27, 0x20, 0xd1, 0x64, 0xbf, 0xa5, 0xf9, 0xd2, 0xa6, 0x85, 0x72, 0x8b, 0xdf, 0x11, 0x95, 0x91, 0xa, 0x94, 0xc3, 0x4, 0x36, 0x9d, 0xe6, 0x1c, 0x34, 0xbb, 0xe3, 0x2f, 0xde, 0xd4, 0x51, 0x53, 0x42, 0x76, 0xde, 0x8e, 0x36, 0x97, 0x49, 0xa, 0xf8, 0x35, 0xfb, 0xd8, 0x15, 0x3b, 0x80, 0x7c, 0x8a, 0x45, 0xc1, 0xe7, 0x5, 0x73, 0x33, 0xf9, 0x9e, 0x82, 0x0, 0x32, 0xf8, 0x5, 0x1f, 0xe8, 0xfd, 0x60, 0x75, 0x2, 0x70, 0x41, 0xdb, 0x4b, 0xaf, 0x76, 0x93, 0xba, 0x22, 0x0, 0xa6, 0x71, 0xb3, 0x76, 0x79, 0xb7, 0xdd, 0x8, 0x81, 0x22, 0xf4, 0x89, 0x25, 0xc6, 0x4e, 0x4c, 0x3e, 0x99, 0x9b, 0xe8, 0x43, 0x48, 0x44, 0x58, 0x98, 0xc3, 0xa1, 0x69, 0xa, 0x26, 0x59, 0x86, 0xff, 0x55, 0x8d, 0x8c, 0x6e, 0xf, 0x2f, 0xd1, 0x42, 0xe1, 0xa9, 0x3f, 0x4e, 0xb3, 0x7, 0xe4, 0xcf, 0x20, 0x47, 0x21, 0x1e, 0x0, 0x5a, 0x42, 0xc9, 0x2a, 0x43, 0x1d, 0x11, 0x1d, 0x48, 0xef, 0xe4, 0x76, 0x2d, 0xae, 0x2, 0x5b, 0x18, 0x3a, 0x2d, 0xbc, 0x57, 0xc4, 0x5d, 0x98, 0x48, 0x4d, 0xd8, 0x53, 0x39, 0xee, 0xc6, 0x8e, 0x4a, 0x6c, 0xeb, 0x31, 0x57, 0x16, 0x12, 0x17, 0xda, 0x7d, 0xf4, 0x40, 0x29, 0xc1, 0xd0, 0x42, 0xe4, 0xfc, 0x30, 0x20, 0x79, 0xb2, 0x22, 0x4, 0x33, 0x23, 0x7, 0x9b, 0xb6, 0x85, 0x1f, 0xa7, 0x32, 0xa9, 0xa2, 0xa9, 0x1a, 0x6d, 0x94, 0xc1, 0xea, 0x5e, 0xca, 0xaf, 0x91, 0x31, 0x29, 0x53, 0xea, 0xd, 0x24, 0x6c, 0xcb, 0x56, 0xc9, 0xc2, 0x34, 0xea, 0x53, 0x3, 0x1c, 0x36, 0xd3, 0x55, 0x8, 0x14, 0xaa, 0x8c, 0xb3, 0x9d, 0x77, 0xf7, 0x7a, 0xe8, 0x42, 0xcd, 0xff, 0xde, 0x17, 0xd9, 0x15, 0xae, 0x29, 0xb8, 0xf1, 0x18, 0xa4, 0x6e, 0xdb, 0x8, 0xec, 0x5e, 0x42, 0x6e, 0x30, 0xdc, 0x4d, 0xcd, 0xb, 0x14, 0x57, 0x37, 0x1e, 0xe1, 0x8c, 0x78, 0x53, 0xb9, 0x39, 0x36, 0xb8, 0xeb, 0x4b, 0x43, 0x34, 0xcd, 0xf6, 0x41, 0x3a, 0xce, 0x28, 0xd6, 0x8b, 0x1e, 0x6e, 0xf7, 0x20, 0x50, 0xc1, 0x21, 0x28, 0x9d, 0xcc, 0x10, 0x7d, 0x5e, 0x85, 0x97, 0x30, 0xf9, 0x7a, 0xee, 0x44, 0x7, 0x4, 0x8e, 0x4d, 0xb2, 0xb7, 0x1c, 0x91, 0xc3, 0xb, 0x63, 0xf0, 0x1c, 0x2d, 0x2, 0x84, 0x5f, 0x31, 0x92, 0xe8, 0x61, 0x85, 0x39, 0x42, 0xe6, 0xdf, 0x81, 0x60, 0x67, 0xf4, 0xc2, 0xa8, 0xff, 0xc4, 0x75, 0xfa, 0x71, 0x92, 0x24, 0x5a, 0x54, 0x63, 0xc9, 0x79, 0x3f, 0x47, 0x31, 0xdc, 0x4a, 0x4a, 0xc3, 0xca, 0x20, 0x3a, 0x27, 0xb, 0xbf, 0xc9, 0xbd, 0x84, 0x1a, 0x22, 0x4d, 0x34, 0x7f, 0x8d, 0x30, 0xef, 0x84, 0xaf, 0xdf, 0x9a, 0x70, 0x96, 0x93, 0x30, 0xe0, 0x77, 0x66, 0x70, 0xed, 0xf1, 0x34, 0x7c, 0x71, 0x6a, 0xd9, 0x31, 0xee, 0x7b, 0x21, 0x8b, 0xef, 0x3b, 0x62, 0xc3, 0xec, 0x4f, 0xcd, 0xb6, 0xb4, 0x1b, 0x9d, 0x42, 0x50, 0x9b, 0xf4, 0xe8, 0x44, 0xe7, 0xc8, 0x5e, 0xd2, 0xcb, 0x6d, 0x40, 0xe0, 0xbd, 0x12, 0x59, 0x63, 0x45, 0x8f, 0x8e, 0x6, 0xc, 0x1d, 0xd7, 0xd3, 0x98, 0x61, 0x53, 0x57, 0xd7, 0xc2, 0x66, 0x2e, 0xb4, 0x13, 0x9d, 0x95, 0x2d, 0x67, 0x57, 0x3c, 0x2d, 0xdc, 0x83, 0x4, 0x8a, 0x7d, 0xa7, 0xb9, 0xd6, 0x69, 0xcc, 0x50, 0x2, 0xbd, 0xbc, 0xe1, 0x83, 0x88, 0x9a, 0xaf, 0x43, 0x4a, 0x61, 0x82, 0xe3, 0x2f, 0x5, 0x1d, 0xcf, 0xd9, 0x36, 0x92, 0xb9, 0xc0, 0x96, 0xb5, 0x7e, 0x6b, 0xab, 0x5d, 0x22, 0xe7, 0x2a, 0xfa, 0x2a, 0xfe, 0xb5, 0x3b, 0x48, 0x70, 0xb5, 0x2f, 0x5f, 0x3a, 0xeb, 0xce, 0x58, 0xad, 0xdc, 0x0, 0x5d, 0xb1, 0x5, 0x80, 0xfb, 0xee, 0x6c, 0xb9, 0xc5, 0x98, 0x26, 0xf, 0x36, 0x49, 0x62, 0x91, 0x7a, 0x73, 0x23, 0xaf, 0x20, 0xea, 0xf3, 0xf5, 0x11, 0xe2, 0x34, 0x6b, 0x19, 0x62, 0xed, 0x24, 0x7a, 0xeb, 0x7d, 0xe6, 0x4e, 0x68, 0xd6, 0xc5, 0xc1, 0xc1, 0x4a, 0x92, 0xf6, 0x6, 0xb1, 0x9b, 0xbd, 0xe4, 0xa6, 0x84, 0x94, 0xbf, 0xc0, 0x6d, 0x76, 0xdf, 0x42, 0x2e, 0xc1, 0x82, 0xfc, 0xa8, 0xc0, 0xd1, 0xe3, 0x0, 0x89, 0x64, 0x55, 0xdf, 0xbd, 0x49, 0xc2, 0x9c, 0x85, 0x8c, 0x64, 0xe8, 0xa, 0x17, 0xc8, 0xb, 0x51, 0x96, 0x1c, 0xe, 0xd3, 0x12, 0xf0, 0x71, 0xb0, 0xd6, 0x2d, 0x76, 0x25, 0xdd, 0x35, 0x4, 0xa2, 0xce, 0x21, 0x4a, 0xae, 0xa5, 0x1a, 0xc8, 0x1c, 0xed, 0x44, 0x79, 0xfd, 0x9d, 0xa0, 0x6c, 0x7c, 0xb0, 0x20, 0x21, 0xf4, 0xf3, 0x47, 0xe1, 0xf2, 0xd, 0x62, 0xc7, 0x8a, 0x50, 0xa3, 0xa, 0x82, 0xf2, 0x88, 0x40, 0x79, 0x66, 0xd6, 0x9d, 0x83, 0x7f, 0x88, 0x1f, 0xce, 0x43, 0x1e, 0xf0},
+               output224: []byte{0xc7, 0xc4, 0xd1, 0x80, 0xc1, 0xcd, 0x83, 0xc9, 0x28, 0x4e, 0x38, 0x7, 0x8a, 0x5e, 0x48, 0x50, 0x74, 0x89, 0x65, 0x55, 0x72, 0x71, 0xff, 0xa, 0x84, 0x84, 0x89, 0xd2},
+               output256: []byte{0x20, 0x52, 0x6a, 0xd, 0x4e, 0x6f, 0x6, 0x24, 0x52, 0x1b, 0x3, 0x69, 0x83, 0xfd, 0xd4, 0xf3, 0x7b, 0xc7, 0x9b, 0x79, 0xf, 0xe2, 0xaa, 0x8a, 0xed, 0x1b, 0x16, 0x6b, 0x40, 0xcd, 0x99, 0x9d},
+               output384: []byte{0xfc, 0xf, 0x4, 0xe5, 0xc1, 0x67, 0x21, 0x10, 0x1e, 0x7a, 0x92, 0x54, 0xd2, 0x78, 0x3b, 0x61, 0x9f, 0x78, 0xa5, 0x26, 0xe4, 0x0, 0x6c, 0x43, 0xe6, 0xd1, 0x23, 0x51, 0x28, 0x12, 0x27, 0xd1, 0x3b, 0xc5, 0x7c, 0x8c, 0xf3, 0x86, 0x52, 0xff, 0xdf, 0x56, 0xa8, 0x88, 0xcd, 0x90, 0x22, 0x9d},
+               output512: []byte{0x50, 0x59, 0x3e, 0xd5, 0xad, 0xf3, 0x21, 0x50, 0x10, 0x53, 0x1e, 0x3a, 0x1b, 0xb6, 0x58, 0x5f, 0x94, 0xca, 0xd6, 0xb5, 0x7f, 0x34, 0x72, 0x74, 0x18, 0xc2, 0x9d, 0xa1, 0xdd, 0xf9, 0xd0, 0x61, 0xb, 0xac, 0x77, 0x81, 0xff, 0xf7, 0x96, 0x62, 0x7c, 0x9f, 0x51, 0xc1, 0x8b, 0x1f, 0xf, 0x4, 0x60, 0xf9, 0xba, 0x9c, 0x13, 0xb0, 0x95, 0x61, 0x7c, 0xc7, 0x8d, 0x18, 0xa, 0x71, 0x9b, 0x1}},
+       testcase{
+               msg:       []byte{0xf5, 0x8, 0xd, 0x4c, 0x59, 0xe8, 0x4, 0xbf, 0x8f, 0x34, 0xb3, 0x34, 0xca, 0xbb, 0xcc, 0x7d, 0x32, 0x1, 0x1b, 0xde, 0x36, 0x77, 0xf4, 0xb9, 0x6, 0x94, 0x16, 0xac, 0x20, 0x41, 0x14, 0xcd, 0x9d, 0xa7, 0xa0, 0xed, 0xf, 0x4b, 0x4d, 0x83, 0x44, 0x41, 0x63, 0x36, 0xee, 0xc1, 0x55, 0x53, 0xef, 0x52, 0x6b, 0x6d, 0xec, 0x26, 0x7b, 0x12, 0x42, 0x65, 0x7d, 0xd0, 0xb5, 0x8, 0xaf, 0x81, 0xfe, 0xcf, 0x9c, 0xff, 0x9c, 0x82, 0xa6, 0xa7, 0xa9, 0x53, 0x98, 0x14, 0xdd, 0x7e, 0x9, 0x76, 0x15, 0xef, 0x15, 0x37, 0x38, 0x36, 0xb5, 0xd2, 0xf7, 0x65, 0xcc, 0x8d, 0x5f, 0x82, 0xe9, 0x4, 0x49, 0xf1, 0x3a, 0xa7, 0x41, 0xd5, 0xee, 0x2f, 0xe6, 0x38, 0x98, 0xe5, 0x5a, 0xcd, 0x85, 0x11, 0x68, 0x46, 0x80, 0x76, 0x6, 0xfe, 0x1e, 0x2e, 0x29, 0xf9, 0x8f, 0x99, 0x40, 0xb0, 0x67, 0xd0, 0xd1, 0xdf, 0x1, 0xf0, 0x80, 0x21, 0x1b, 0x2e, 0xe4, 0xb0, 0xa3, 0x8, 0x3, 0x78, 0x2a, 0x7b, 0xc2, 0xea, 0xfd, 0xc5, 0xeb, 0xdb, 0xa9, 0x1e, 0xb0, 0x5f, 0x7d, 0x7d, 0xc8, 0xe3, 0x4b, 0xf6, 0xd4, 0x4f, 0xec, 0x5, 0x82, 0x4f, 0x53, 0x41, 0x8f, 0x23, 0x5f, 0xb6, 0x4e, 0x89, 0x9e, 0xe1, 0x47, 0xbc, 0xb4, 0x3, 0xc8, 0x85, 0x5e, 0x94, 0xaf, 0x37, 0x8d, 0x18, 0x2d, 0x79, 0xc3, 0xea, 0xf9, 0x77, 0xcb, 0x4e, 0x9d, 0x4a, 0x16, 0xd9, 0x90, 0xa6, 0xc3, 0x88, 0xce, 0xb5, 0x67, 0xb9, 0x77, 0x85, 0xe6, 0xf2, 0xbc, 0x67, 0x45, 0x10, 0x2b, 0x99, 0xae, 0x76, 0x5e, 0x96, 0xb, 0x6b, 0x32, 0xba, 0xf0, 0x1e, 0x23, 0x79, 0xcd, 0x6e, 0xcb, 0x74, 0xd3, 0xe1, 0xa5, 0x65, 0x52, 0xf5, 0x97, 0x6d, 0xfe, 0x5c, 0x74, 0x2b, 0xc9, 0x2b, 0xe5, 0x96, 0xca, 0x74, 0x2f, 0xfc, 0x3d, 0xf, 0xa0, 0x32, 0xac, 0x29, 0xf9, 0xf7, 0xc1, 0xa5, 0xc4, 0x3b, 0xcc, 0xa6, 0x2d, 0xf7, 0xd9, 0xde, 0x35, 0xd0, 0xc7, 0xc1, 0x79, 0xdb, 0x2e, 0x1a, 0xa2, 0x55, 0xce, 0xdc, 0xca, 0x55, 0x6, 0x4c, 0x20, 0x49, 0xfe, 0xe1, 0xaf, 0x2c, 0xe5, 0xef, 0x69, 0x6e, 0xd4, 0xbc, 0x46, 0xb7, 0xc5, 0x5b, 0xdd, 0x51, 0xf2, 0xd4, 0x4c, 0x87, 0x13, 0xfb, 0x24, 0x75, 0xc0, 0xb8, 0x52, 0x46, 0xac, 0x1, 0x3, 0xcc, 0x38, 0x63, 0xb7, 0xeb, 0x2, 0x6a, 0xe0, 0x76, 0xa6, 0x0, 0x31, 0x3f, 0x6f, 0xb4, 0xa, 0x4d, 0xf6, 0x2a, 0x2a, 0xf8, 0x1b, 0x7e, 0x91, 0x79, 0x51, 0xea, 0x87, 0xe, 0xcb, 0x31, 0xb3, 0x40, 0x19, 0x28, 0xb5, 0x4, 0x6d, 0x9a, 0x1e, 0x62, 0xd1, 0x4b, 0x30, 0xfd, 0xeb, 0xaf, 0x26, 0x28, 0x68, 0x51, 0x73, 0x18, 0xfe, 0x17, 0xec, 0x3c, 0xd, 0x52, 0x52, 0x4f, 0x44, 0x12, 0xe, 0xd8, 0xed, 0x3b, 0xa7, 0xc, 0x64, 0x33, 0x0, 0xcd, 0xb, 0xc7, 0xd, 0xa7, 0x2c, 0x96, 0x4a, 0x88, 0xf5, 0x2c, 0x3a, 0x91, 0xec, 0x20, 0xbf, 0xeb, 0x5c, 0xae, 0xfc, 0xd4, 0xd9, 0xc7, 0x68, 0x5d, 0x84, 0x7, 0x47, 0x6b, 0x5f, 0x34, 0x67, 0x6c, 0x5e, 0xbd, 0x1e, 0x88, 0xa6, 0xcf, 0xf1, 0xc6, 0x25, 0x32, 0x2f, 0x8c, 0xd5, 0x9b, 0x9e, 0xd6, 0xc, 0xef, 0xb2, 0x1f, 0x94, 0x91, 0xb9, 0x5e, 0x72, 0x79, 0x1f, 0x7a, 0xc7, 0xea, 0xa3, 0xc1, 0x61, 0x59, 0xfe, 0x9d, 0xf7, 0xa9, 0x89, 0xad, 0xd6, 0xc2, 0x28, 0x2c, 0x47, 0x58, 0x5e, 0x11, 0x39, 0x7e, 0xda, 0x9f, 0x47, 0xdf, 0x2b, 0x40, 0x16, 0x6e, 0x3, 0xbc, 0xdd, 0x61, 0x86, 0xb4, 0x6c, 0x68, 0x35, 0x11, 0x82, 0x68, 0xdd, 0xbe, 0xf1, 0x9a, 0x28, 0xbb, 0xad, 0xe1, 0xbd, 0xe0, 0x22, 0x8f, 0xfd, 0x7e, 0x8b, 0x3c, 0x3c, 0x59, 0x8d, 0x89, 0xe2, 0x4b, 0x8c, 0xde, 0xe7, 0x9c, 0x94, 0x2, 0x54, 0xde, 0x26, 0xcc, 0x68, 0x14, 0xba, 0x27, 0x22, 0xe4, 0x2f, 0x75, 0x71, 0x60, 0xb, 0x73, 0x25, 0xe1, 0xff, 0x30, 0x2, 0x51, 0xd5, 0x2a, 0x89, 0x5b, 0x8c, 0xcb, 0xd0, 0x49, 0xb2, 0x95, 0x3b, 0x8d, 0x23, 0x14, 0x45, 0xf6, 0x8f, 0x7c, 0x26, 0xec, 0x25, 0xa4, 0xb8, 0x69, 0x5c, 0x8a, 0xc1, 0x16, 0xf7, 0x36, 0xbe, 0x93, 0x9e, 0xdd, 0x76, 0x2c, 0x9b, 0x47, 0x43, 0xe4, 0x63, 0xc9, 0xb9, 0xb2, 0xf8, 0x8e, 0xb, 0xc0, 0xce, 0x78, 0x78, 0x1c, 0xdd, 0xc3, 0xbc, 0xa8, 0x25, 0xac, 0xd4, 0x63, 0xc7, 0xca, 0xc2, 0xaa, 0x6c, 0x43, 0xb, 0xbe, 0x82, 0xe, 0xa9, 0x4a, 0xf9, 0xa4, 0xb, 0x1b, 0x5c, 0x0, 0x6e, 0x96, 0x41, 0xa2, 0xff, 0xa6, 0xe4, 0x27, 0x37, 0x9e, 0x1a, 0xd4, 0x9c, 0x81, 0xb9, 0x83, 0x20, 0xb3, 0x43, 0x1f, 0xf0, 0x3, 0xd, 0xc6, 0x83, 0xd6, 0x10, 0x26, 0x43, 0x8b, 0xc6, 0xa6, 0xd3, 0x4b, 0x2c, 0x73, 0x70, 0x4d, 0x9f, 0x62, 0xea, 0xeb, 0x13, 0xab, 0xb3, 0xe4, 0xb0, 0x56, 0x2b, 0x4e, 0x4, 0x82, 0xcd, 0x6b, 0x2d, 0x7a, 0xeb, 0xc0, 0x36, 0x7e, 0xa2, 0x9a, 0x88, 0xf4, 0xa7, 0x6f, 0x3d, 0x76, 0xfa, 0x11, 0x97, 0xe1, 0xdc, 0xa9, 0x2c, 0x82, 0x16, 0xc8, 0x4c, 0x1a, 0xf9, 0xb8, 0xc7, 0x8c, 0x9e, 0x3a, 0x77, 0x99, 0xa4, 0xa7, 0x9a, 0x78, 0x30, 0x33, 0xb0, 0xf5, 0x54, 0x7e, 0x8e, 0x75, 0xe6, 0x9c, 0xf3, 0x61, 0x5a, 0xb0, 0x4e, 0xf9, 0x89, 0xfe, 0x1a, 0x46, 0x3b, 0x16, 0x72, 0xc5, 0x71, 0xd5, 0xa, 0xb5, 0x69, 0x72, 0x89, 0x6e, 0x8a, 0x50, 0xc2, 0x42, 0xf2, 0x2c, 0x7f, 0x6e, 0x27, 0xca, 0x4c, 0xa7, 0x93, 0xf6, 0x27, 0xe7, 0x96, 0x8, 0x68, 0xf, 0x54, 0x21, 0xb2, 0x8b, 0xdd, 0x25, 0x89, 0xf0, 0x5e, 0x65, 0x43, 0xd, 0xf7, 0x74, 0xee, 0x87, 0x3f, 0xcd, 0x12, 0x34, 0x6, 0x4f, 0x7a, 0x33, 0xcf, 0x5a, 0x1f, 0xa4, 0xe3, 0x68, 0x13, 0x7f, 0xf9, 0xc1, 0x59, 0x7f, 0x1f, 0xa0, 0xfa, 0x36, 0x49, 0x3f, 0x20, 0x53, 0x80, 0x77, 0x66, 0x9e, 0xad, 0xfd, 0x3b, 0x6, 0xf7, 0x88, 0xc9, 0x12, 0xc7, 0x15, 0xfb, 0x5d, 0x33, 0x4d, 0xb6, 0xbe, 0xd1, 0x33, 0xa8, 0xfd, 0xc4, 0xf, 0x54, 0x96, 0xe6, 0x6a, 0xd6, 0x38, 0x81, 0xf0, 0xba, 0x37, 0x27, 0x41, 0x67, 0x15, 0x86, 0x52, 0x53, 0xdc, 0x52, 0x90, 0x32, 0x7b, 0x51, 0x5b, 0xf6, 0x8d, 0xa1, 0x88, 0xdd, 0x5b, 0x4b, 0xe, 0xac, 0x7c, 0xa7, 0x12, 0xca, 0xfa, 0x8f, 0xca, 0xe0, 0xc5, 0x50, 0x3f, 0xe5, 0x8a, 0x21, 0x91, 0x82, 0xf1, 0xc3, 0xd, 0xa6, 0xd0, 0xc1, 0x9c, 0xfe, 0xe8, 0x97, 0xb7, 0xd8, 0x37, 0xc9, 0x79, 0x96, 0xa3, 0x5f, 0x4c, 0xa8, 0xcf, 0x5, 0x37, 0xa0, 0x1d, 0x17, 0xe7, 0xde, 0xc, 0xc9, 0xc1, 0x29, 0xe4, 0xda, 0xa, 0xda, 0xf1, 0xfd, 0xa8, 0x50, 0x30, 0xdf, 0x91, 0x27, 0xbe, 0x62, 0x82, 0x63, 0xb0, 0x62, 0x4f, 0x37, 0x2c, 0x47, 0xc3, 0xac, 0x87, 0xeb, 0x94, 0x5a, 0x57, 0xf5, 0xc7, 0x32, 0xbe, 0xee, 0x81, 0xa7, 0x40, 0x30, 0x1, 0x79, 0x89, 0x92, 0xf3, 0xdc, 0x94, 0x41, 0x14, 0xff, 0x3d, 0x54, 0xc4, 0x66, 0x6a, 0xc5, 0xac, 0x8c, 0x98, 0xd0, 0xd5, 0x59, 0x6c, 0xbd, 0xeb, 0x42, 0x6, 0x65, 0xf5, 0xed, 0xaa, 0xe7, 0x47, 0xd5, 0x4c, 0xf7, 0xed, 0xd3, 0x7b, 0x16, 0x2e, 0x37, 0x22, 0x49, 0xd1, 0x35, 0x93, 0x8c, 0xf1, 0x7d, 0x17, 0x4d, 0x12, 0xd8, 0x82, 0x79, 0xcb, 0x4c, 0x32, 0xbd, 0x6f, 0x1, 0x8c, 0x76, 0x6d, 0xa6, 0x98, 0x3d, 0x4e, 0xa5, 0x1d, 0x6b, 0xd8, 0xff, 0xa, 0x9b, 0x34, 0xe9, 0xa9, 0x3b, 0xbd, 0xa7, 0xc, 0xf1, 0xb4, 0xb8, 0x67, 0xd6, 0xa, 0x74, 0x81, 0x1f, 0xd9, 0x8d, 0x52, 0xfa, 0xa5, 0x59, 0xb5, 0x2c, 0x75, 0x5c, 0xb7, 0xa, 0x76, 0xc9, 0x4b, 0xd1, 0x96, 0x54, 0xca, 0xe7, 0x1, 0x7c, 0xcd, 0x70, 0x22, 0x2b, 0xf0, 0x8c, 0x5d, 0x7a, 0xd1, 0xf5, 0xe4, 0xe6, 0x34, 0x4f, 0xdb, 0x3a, 0xbe, 0x70, 0x34, 0x52, 0xc2, 0x9a, 0x69, 0x6f, 0x39, 0xf9, 0x82, 0x6e, 0xd8, 0xbc, 0x51, 0xa, 0x4a, 0x14, 0x8e, 0x5b, 0xf8, 0xa5, 0xdb, 0xe6, 0xb8, 0x2d, 0x72, 0x20, 0x16, 0x4f, 0x8, 0x1, 0x1c, 0x5, 0xac, 0x51, 0x59, 0xd5, 0x2c, 0xe9, 0xd4, 0x5d, 0x75, 0x8b, 0x64, 0x5b, 0xbb, 0x24, 0x8c, 0x2d, 0x34, 0x1d, 0xbe, 0xfa, 0x1f, 0x86, 0x2, 0xc5, 0xd4, 0x58, 0xa6, 0x4f, 0x38, 0xf3, 0xb0, 0x4d, 0xb3, 0x90, 0x89, 0x80, 0x7b, 0x6a, 0x10, 0xe1, 0xbb, 0x52, 0x77, 0xb, 0x92, 0xce, 0x72, 0xe2, 0xd3, 0xbb, 0xc, 0x22, 0x41, 0xcd, 0xed, 0x35, 0x5, 0x4b, 0x84, 0x55, 0x8d, 0x1c, 0xc0, 0x99, 0xef, 0x7b, 0x22, 0x96, 0x95, 0x19, 0x51, 0xd5, 0xb6, 0xa2, 0x2f, 0x93, 0xbf, 0x96, 0x2a, 0xc5, 0xef, 0x8f, 0xb5, 0x5e, 0xc6, 0xcc, 0x2b, 0x31, 0x64, 0x28, 0xed, 0xf1, 0x20, 0x78, 0xed, 0x1b, 0x66, 0xd5, 0x25, 0xd0, 0x22, 0x81, 0x9c, 0xbd, 0x48, 0x9e, 0x1b, 0xed, 0xb0, 0x2f, 0xfb, 0xd5, 0x7, 0xd5, 0x5f, 0x9b, 0x5d, 0x4e, 0x22, 0xf6, 0x39, 0x6e, 0xa2, 0x33, 0x45, 0x37, 0x54, 0x68, 0x8d, 0x20, 0x15, 0x1a, 0x9, 0xc7, 0x0, 0x44, 0xb8, 0xa5, 0xa9, 0xac, 0x3, 0x3c, 0x3c, 0x3b, 0x84, 0x7a, 0xd8, 0x33, 0xd5, 0xc0, 0x5b, 0x33, 0x40, 0x76, 0x66, 0xee, 0x82, 0xf9, 0x58, 0x1d, 0xf9, 0x3, 0x4e, 0xe1, 0x5a, 0x9c, 0xa6, 0x7d, 0x52, 0xf1, 0xd9, 0xb6, 0x34, 0xb8, 0x4c, 0x1b, 0x8b, 0xa9, 0xe5, 0x15, 0xf1, 0xf0, 0x60, 0xa5, 0xac, 0x5c, 0xba, 0xe2, 0xde, 0x75, 0xf9, 0x4e, 0x11, 0x2f, 0x71, 0x98, 0xe2, 0x39, 0xdf, 0x8, 0xd3, 0x10, 0x3f, 0x6, 0x56, 0x27, 0x43, 0x89, 0x95, 0x2, 0x6d, 0xf5, 0x11, 0xc6, 0xe5, 0xbf, 0xde, 0xee, 0x56, 0x67, 0xd5, 0x11, 0xd4, 0x18, 0x18, 0x50, 0xc7, 0xc5, 0xd1, 0x79, 0x10, 0x7c, 0x1b, 0x86, 0xd2, 0x4d, 0x55, 0x32, 0xa8, 0x8a, 0x41, 0x49, 0xa2, 0x81, 0xd, 0xca, 0xe7, 0x37, 0x31, 0xb0, 0xe1, 0x24, 0x72, 0x81, 0xa6, 0xfd, 0x31, 0x61, 0x3d, 0xf6, 0x89, 0x1b, 0x4c, 0x17, 0xb7, 0xa6, 0xa9, 0xad, 0x9b, 0x77, 0x46, 0x82, 0x54, 0xb9, 0x3f, 0x85, 0x95, 0x8a, 0xa0, 0xf0, 0x1c, 0xef, 0xc1, 0xb, 0x25, 0x16, 0x9d, 0xc4, 0x6e, 0x3, 0x5d, 0x3f, 0x24, 0x55, 0x7b, 0x4b, 0xf0, 0xe7, 0xd6, 0x1, 0x74, 0x21, 0x91, 0x8, 0xd9, 0x16, 0xff, 0xdc, 0x55, 0xe2, 0x5b, 0xff, 0xd9, 0x80, 0x9e, 0xfd, 0x5, 0x8e, 0x12, 0xc1, 0x4f, 0x39, 0xc6, 0x9d, 0x8f, 0xb7, 0x3d, 0x3e, 0xc6, 0x45, 0x8f, 0x47, 0xf2, 0xf8, 0xdb, 0x90, 0x1b, 0xa7, 0x6c, 0x86, 0x55, 0xb, 0x11, 0xb5, 0x4d, 0x6, 0x41, 0xd4, 0xdb, 0x3e, 0xb0, 0x0, 0x5, 0x7d, 0xd0, 0xf, 0x2e, 0x51, 0x1f, 0xb7, 0xa4, 0x7e, 0x95, 0x9a, 0x44, 0x2, 0xa3, 0xac, 0x54, 0x62, 0x23, 0x4b, 0x40, 0xb1, 0x84, 0x2, 0xf, 0xcf, 0x7a, 0x3, 0x96, 0xc4, 0xd0, 0xa, 0x98, 0x7c, 0x87, 0x41, 0xa4, 0x53, 0x7b, 0xc1, 0x71, 0x2, 0xa5, 0xc4, 0x2a, 0xfe, 0xab, 0x9f, 0x71, 0xea, 0x66, 0xed, 0x4c, 0xbc, 0x7b, 0x5e, 0xe6, 0x82, 0xff, 0x4, 0xf5, 0x6f, 0x4b, 0xa1, 0xea, 0xb, 0xb3, 0x26, 0xc4, 0x8, 0x99, 0x30, 0xf9, 0xe3, 0xf3, 0xff, 0xa3, 0xe0, 0x66, 0x37, 0xcc, 0xe3, 0x21, 0x13, 0x88, 0x1a, 0x6, 0xcc, 0x3a, 0x13, 0x83, 0x74, 0x48, 0x14, 0x5c, 0x2b, 0xd0, 0x13, 0x7, 0xa5, 0x80, 0xfd, 0xbc, 0x38, 0x5d, 0x8f, 0x46, 0xfb, 0x92, 0xff, 0xed, 0xbc, 0x89, 0x18, 0xd2, 0x69, 0xdd, 0x18, 0x71, 0x16, 0x4d, 0x4b, 0x3e, 0x20, 0x23, 0x44, 0x1e, 0xc8, 0xb9, 0x9c, 0x82, 0xa5, 0xf0, 0x98, 0x21, 0xcd, 0xdf, 0x6b, 0x38, 0xc9, 0xac, 0xc3, 0xbf, 0x3a, 0x38, 0xd5, 0x62, 0x80, 0x16, 0x15, 0x95, 0x88, 0xc3, 0x3e, 0xaa, 0x29, 0xd9, 0x46, 0x3a, 0x53, 0x7c, 0x0, 0xa, 0x16, 0xad, 0x8c, 0x17, 0x7d, 0xc4, 0xcf, 0x71, 0x6e, 0x62, 0x5f, 0x46, 0xfc, 0x4c, 0xa8, 0xc1, 0x9f, 0xbd, 0x8e, 0xf3, 0x20, 0xf1, 0xd6, 0x80, 0x63, 0x91, 0x95, 0xc8, 0xb1, 0x95, 0xb0, 0xa0, 0x27, 0x38, 0xe0, 0x66, 0x5f, 0x41, 0x90, 0xd6, 0x28, 0x7e, 0x58, 0x9c, 0xd6, 0xdd, 0x45, 0xb9, 0xe8, 0xcc, 0x23, 0xb0, 0x8e, 0x16, 0x81, 0xbf, 0xc6, 0xf6, 0x6b, 0x88, 0xde, 0x6b, 0x9, 0x1e, 0x82, 0x5e, 0xa4, 0xbb, 0xfb, 0xd6, 0x97, 0xe1, 0xb, 0xc4, 0x7, 0x57, 0xa, 0xe4, 0xf2, 0xa3, 0xeb, 0xe5, 0x69, 0x55, 0x46, 0x39, 0xc2, 0xb8, 0xe0, 0x51, 0x65, 0x6c, 0xc3, 0xc, 0x83, 0x7f, 0x5a, 0x92, 0x26, 0xe, 0xad, 0x1d, 0x55, 0x2b, 0x45, 0x80, 0x1b, 0x6d, 0x28, 0x13, 0x41, 0x66, 0x79, 0x6c, 0x87, 0xf9, 0x0, 0x22, 0x5c, 0xfd, 0xc3, 0xcc, 0x49, 0xd7, 0x2d, 0xfb, 0xc1, 0x8d, 0x8d, 0x95, 0xb1, 0xe1, 0x60, 0xed, 0x3c, 0xaf, 0xd5, 0xc3, 0x46, 0x7d, 0x48, 0xaf, 0xf8, 0x74, 0x2, 0xcb, 0xcb, 0x1e, 0x14, 0x20, 0xe3, 0xfc, 0xb5, 0x88, 0xaa, 0x19, 0xc8, 0xf4, 0x27, 0x53, 0xb5, 0x9d, 0xb6, 0xfb, 0x6a, 0x9f, 0xdb, 0xa1, 0x27, 0xca, 0x80, 0x6d, 0xba, 0x7d, 0xd9, 0x7f, 0x24, 0x88, 0xfc, 0x2e, 0x43, 0x8e, 0xef, 0x57, 0xa4, 0xcc, 0x85, 0xb8, 0x8d, 0xcf, 0xde, 0x76, 0xae, 0x1f, 0xf6, 0x12, 0x25, 0xa1, 0xca, 0x8b, 0xf4, 0xa1, 0x4f, 0x72, 0x99, 0x50, 0x32, 0x2e, 0xa6, 0x81, 0xb1, 0x6d, 0x64, 0x92, 0x90, 0x25, 0x6, 0x70, 0x2d, 0xc8, 0xf3, 0x48, 0xe4, 0xd3, 0xae, 0x7f, 0xb5, 0x5f, 0xac, 0x12, 0x31, 0xfd, 0xe8, 0x20, 0x91, 0xb3, 0x4f, 0x17, 0x91, 0xb6, 0xae, 0x37, 0x58, 0x7b, 0x10, 0x32, 0x5f, 0x6f, 0xf5, 0xe2, 0x3b, 0x85, 0x58, 0x45, 0xb8, 0x6e, 0xae, 0x90, 0x78, 0x5b, 0x9d, 0x10, 0xd9, 0xa, 0x16, 0x64, 0x4d, 0x1, 0xbb, 0x62, 0x6f, 0x34, 0x3b, 0x90, 0x8a, 0x95, 0x91, 0xf4, 0x6, 0x9b, 0x21, 0x82, 0x2c, 0xa4, 0xec, 0xf9, 0x85, 0xc1, 0xe7, 0x10, 0x47, 0x5f, 0x33, 0xdf, 0x9a, 0xf4, 0x76, 0x4c, 0xfb, 0xf, 0xfe, 0x64, 0x90, 0x63, 0x77, 0x53, 0x38, 0xf1, 0x5b, 0xea, 0x7c, 0xff, 0x29, 0xf1, 0x64, 0x67, 0x81, 0x60, 0x96, 0xa, 0x80, 0xed, 0x14, 0x8c, 0x9b, 0x7f, 0xaa, 0x58, 0xe9, 0x13, 0x99, 0x11, 0xd3, 0xdd, 0x95, 0x36, 0xf6, 0x96, 0x46, 0xf7, 0x18, 0xf0, 0x83, 0xdc, 0x90, 0x29, 0xd6, 0x29, 0x4f, 0xc4, 0xc6, 0x7, 0x68, 0x8a, 0xa7, 0x5a, 0xf3, 0x50, 0xac, 0x2c, 0xb, 0x0, 0x1a, 0x15, 0x7d, 0x2, 0x3d, 0x73, 0xd8, 0x6e, 0xd8, 0x13, 0x38, 0x9, 0xfc, 0xb9, 0x59, 0x2d, 0x12, 0x8, 0x9c, 0xbd, 0x7a, 0x1b, 0xb6, 0xbb, 0xa8, 0x82, 0xfe, 0x22, 0x7c, 0x9, 0xa5, 0x3f, 0xf0, 0x88, 0x90, 0x7c, 0xb4, 0xbc, 0x2f, 0xb4, 0xb7, 0xf6, 0x2d, 0x41, 0xd3, 0xd3, 0x97, 0xc4, 0xfe, 0xa, 0xd1, 0x2b, 0xb3, 0x96, 0x43, 0x70, 0xe2, 0x17, 0x12, 0x95, 0x1c, 0x67, 0x98, 0x14, 0xd5, 0x6, 0xe7, 0x38, 0xc0, 0x20, 0x1e, 0x42, 0x18, 0x1d, 0x23, 0x11, 0x36, 0xa4, 0x35, 0xae, 0x3, 0x97, 0xb6, 0x1c, 0xcb, 0xc5, 0xe8, 0xbb, 0xeb, 0xf8, 0xea, 0x77, 0xc8, 0xbc, 0x48, 0xbd, 0x62, 0x11, 0xf2, 0x92, 0x48, 0xf9, 0xd4, 0x98, 0xd8, 0x18, 0xe2, 0xb5, 0x44, 0xd2, 0x8a, 0x5e, 0x60, 0xba, 0x72, 0x7f, 0x32, 0xef, 0x4b, 0xa2, 0x70, 0x79, 0x62, 0x23, 0xc, 0x90, 0x0, 0x76, 0xfb, 0x76, 0x4d, 0xe, 0xd5, 0xce, 0x7, 0x8c, 0x9d, 0xb1, 0x4d, 0xe8, 0x94, 0xbb, 0xb8, 0x36, 0xc6, 0xde, 0x9e, 0x83, 0x20, 0x2a, 0xe8, 0x9f, 0x9a, 0x8d, 0x8c, 0xb0, 0x34, 0x1e, 0x1c, 0x81, 0xb5, 0xfa, 0x8b, 0x16, 0x73, 0x1b, 0x8e, 0x23, 0x1e, 0x96, 0x9c, 0xf, 0x1e, 0xf9, 0x53, 0x36, 0xd4, 0xe7, 0x3e, 0xad, 0x6d, 0xa2, 0x3d, 0xe3, 0xad, 0x1e, 0xb6, 0x8, 0xac, 0xce, 0x4d, 0x4d, 0x93, 0x99, 0x6d, 0xd7, 0x6e, 0xc1, 0xf5, 0xf2, 0xc5, 0x76, 0xf6, 0xb3, 0xb7, 0x6e, 0x7, 0xbd, 0x8a, 0x81, 0xf, 0xf5, 0xd8, 0x8b, 0x0, 0xff, 0xe4, 0x8c, 0x42, 0x70, 0xb, 0x61, 0xcc, 0x49, 0x93, 0x36, 0xe7, 0xfb, 0x57, 0xad, 0x72, 0xff, 0x44, 0xfc, 0x63, 0x1c, 0x72, 0x22, 0xc9, 0xa3, 0xd1, 0xab, 0xf6, 0xe7, 0x7b, 0x5e, 0xd7, 0xfe, 0x2f, 0x72, 0x28, 0xfe, 0xd6, 0xc8, 0x49, 0xbf, 0x71, 0x42, 0xc4, 0x10, 0x39, 0x89, 0xa8, 0xf, 0x7c, 0x15, 0x64, 0x2a, 0xe6, 0x16, 0x50, 0xcd, 0xca, 0x7e, 0x85, 0x4e, 0xb2, 0x5e, 0x9e, 0x72, 0xf4, 0xc3, 0xe3, 0x76, 0x8e, 0x6c, 0xcc, 0x8b, 0xfd, 0x55, 0x6b, 0x56, 0xd3, 0x50, 0x7e, 0xdd, 0xe9, 0xe5, 0xc3, 0x31, 0xdd, 0xea, 0x75, 0x56, 0x8b, 0x7, 0x81, 0x3d, 0x20, 0xe8, 0xf4, 0xc9, 0x54, 0x78, 0x38, 0xed, 0x28, 0x44, 0x8f, 0x2e, 0x67, 0x15, 0x8a, 0xcf, 0xc, 0x0, 0xb1, 0x31, 0x47, 0x38, 0x47, 0x81, 0x6c, 0x5e, 0x2d, 0xc2, 0x15},
+               output224: []byte{0xb4, 0x97, 0x8f, 0x5d, 0xe0, 0x29, 0x5, 0x35, 0x5d, 0x9d, 0x40, 0xfa, 0x9, 0xe6, 0xf8, 0xa2, 0x97, 0xca, 0x54, 0x6a, 0xc8, 0x38, 0x2c, 0xf1, 0x1, 0x52, 0xb2, 0xb3},
+               output256: []byte{0x6c, 0x87, 0x23, 0xda, 0x27, 0xcd, 0x98, 0xe2, 0xf, 0x25, 0x83, 0xd0, 0x18, 0x68, 0x5, 0x1e, 0xf2, 0xda, 0xfa, 0x64, 0x59, 0x1, 0xf8, 0x2c, 0x74, 0xd5, 0x32, 0xe, 0xaf, 0xc1, 0x8a, 0xac},
+               output384: []byte{0x74, 0xb1, 0x9a, 0x3c, 0xc5, 0x77, 0x84, 0x7c, 0x75, 0x7b, 0x8, 0xc2, 0xe1, 0x9c, 0x9e, 0x94, 0x92, 0xf8, 0xc5, 0xa8, 0xeb, 0x9e, 0x98, 0x3c, 0x68, 0xdc, 0xef, 0x4a, 0xd4, 0xee, 0x30, 0x28, 0xd2, 0xe6, 0x26, 0xd3, 0x43, 0xed, 0x2d, 0xbe, 0x90, 0x90, 0x6e, 0xdc, 0xba, 0x51, 0x3e, 0x8b},
+               output512: []byte{0x68, 0xcf, 0xeb, 0x4a, 0xfc, 0x84, 0xfd, 0xe5, 0xb1, 0xa2, 0xf7, 0x3a, 0x91, 0x4c, 0x70, 0x5b, 0xc2, 0x11, 0xca, 0xc6, 0x9f, 0xc6, 0x81, 0x89, 0xe3, 0x58, 0x74, 0x12, 0xea, 0x74, 0x1e, 0x46, 0xfd, 0x23, 0xa, 0xf5, 0x4b, 0xab, 0x9a, 0xf6, 0x5a, 0xd5, 0x32, 0x2c, 0xb6, 0x91, 0xb0, 0x4e, 0xf0, 0x45, 0xc1, 0x5a, 0x18, 0x7f, 0xec, 0xc7, 0xae, 0xe9, 0xfa, 0xf2, 0xc, 0x8f, 0xc6, 0x58}},
+       testcase{
+               msg:       []byte{0x34, 0xa8, 0xb8, 0x95, 0x6b, 0xf5, 0xad, 0xfa, 0x5e, 0xf8, 0xf1, 0xb, 0x67, 0x3f, 0x6e, 0x53, 0xbc, 0x3f, 0xef, 0x8d, 0xd1, 0xf9, 0x42, 0x80, 0x78, 0xc2, 0x56, 0xa8, 0xfa, 0x1d, 0x8d, 0xa1, 0xe7, 0x24, 0xba, 0x90, 0xb6, 0x5b, 0xd4, 0x39, 0x4e, 0xac, 0xac, 0x54, 0x69, 0xc5, 0x20, 0xba, 0xc2, 0xce, 0xd1, 0x64, 0xb, 0xa2, 0x6e, 0xfe, 0xf4, 0x4f, 0x50, 0xba, 0xa7, 0x2a, 0x9e, 0x7c, 0xc8, 0xbf, 0xf6, 0x9e, 0xb8, 0x71, 0x9a, 0xa1, 0xd8, 0x8a, 0x24, 0x50, 0xf5, 0xc3, 0xb4, 0xfa, 0x54, 0xa2, 0x97, 0x7c, 0xed, 0x1a, 0x90, 0x4c, 0x9, 0x35, 0x6f, 0x48, 0x33, 0x1, 0xad, 0xd6, 0x10, 0x6, 0x52, 0x4f, 0xf8, 0x14, 0xca, 0xb, 0x1f, 0xd5, 0xd, 0x3f, 0x3a, 0x30, 0x49, 0x2b, 0xa7, 0xc, 0x29, 0x21, 0xe3, 0xb9, 0xda, 0x58, 0xcf, 0x8f, 0x5b, 0xee, 0x32, 0xac, 0x15, 0xe3, 0x93, 0x71, 0xfd, 0x9d, 0x78, 0x42, 0x56, 0x5, 0x4a, 0x3d, 0x14, 0x55, 0x63, 0xc6, 0x2e, 0x72, 0x58, 0xff, 0xf3, 0xa1, 0x65, 0x24, 0xd3, 0x87, 0x67, 0xa7, 0x5f, 0xc2, 0x7f, 0xc3, 0xd0, 0xa9, 0xf0, 0xf5, 0x85, 0xa0, 0x4, 0x6d, 0x63, 0x69, 0xdc, 0x6d, 0xd1, 0x7f, 0xc6, 0x5b, 0x53, 0x38, 0x1, 0x84, 0xb4, 0xd9, 0xee, 0xaf, 0xf2, 0x45, 0xfc, 0xe1, 0xae, 0xa0, 0xd4, 0xe8, 0x40, 0x7d, 0x2e, 0xbf, 0xf6, 0xec, 0xf, 0xae, 0x8b, 0x65, 0x47, 0x47, 0xee, 0xcc, 0xe1, 0x3b, 0xea, 0x89, 0xd4, 0x87, 0x9e, 0xc, 0x92, 0xe1, 0xf4, 0x7e, 0xad, 0x8e, 0x5c, 0xd7, 0xf5, 0x6b, 0x4, 0xc6, 0x2c, 0x2b, 0x7c, 0xc1, 0x3c, 0x5c, 0xc2, 0xd9, 0xe6, 0xa8, 0x7d, 0x77, 0xde, 0x73, 0xe5, 0x4d, 0xcb, 0x98, 0x29, 0x0, 0x1a, 0x3a, 0x98, 0x13, 0xdc, 0x19, 0x58, 0xe4, 0xfa, 0x10, 0xbb, 0xe4, 0x2, 0x78, 0x22, 0xf8, 0x92, 0x3a, 0xf1, 0x7d, 0xb, 0x4, 0xbd, 0xe9, 0x7b, 0x98, 0x10, 0xb3, 0x1e, 0x26, 0xff, 0x74, 0xf9, 0xae, 0x95, 0xe5, 0xc, 0x6e, 0xa2, 0x5a, 0x49, 0xee, 0x55, 0x75, 0x59, 0xc2, 0xc9, 0xc8, 0x3d, 0x1, 0x73, 0x7b, 0x6c, 0xd7, 0x21, 0x6c, 0x46, 0x85, 0x9d, 0x28, 0x33, 0xf0, 0x4d, 0xef, 0x7a, 0x7e, 0xfc, 0x84, 0x9f, 0x8b, 0x13, 0xf6, 0x27, 0xe2, 0xf, 0xcf, 0xc, 0xd3, 0xe0, 0xb1, 0xcc, 0x7d, 0xb, 0x22, 0xb4, 0xeb, 0xd5, 0x76, 0xcb, 0xc2, 0xa3, 0x97, 0x82, 0x8e, 0xae, 0xd2, 0xe4, 0xaf, 0xe5, 0x11, 0x4, 0x50, 0x7c, 0xb, 0x31, 0x76, 0xa7, 0x4a, 0x2, 0x61, 0xa1, 0x59, 0x52, 0x5e, 0x8, 0x83, 0xf4, 0x51, 0x4f, 0x18, 0x56, 0xd1, 0xbc, 0xa3, 0xce, 0xb1, 0x8, 0x44, 0x41, 0xe9, 0x9f, 0xac, 0xdc, 0xc5, 0xb7, 0xed, 0xbc, 0x5a, 0x4c, 0x80, 0x3f, 0x64, 0x48, 0x11, 0x97, 0x45, 0xc2, 0x3e, 0x5d, 0x79, 0x5a, 0xa, 0xa9, 0x6f, 0x31, 0xa4, 0x8f, 0x43, 0x19, 0x60, 0xb3, 0xc4, 0x1c, 0x9c, 0x6b, 0x13, 0xa2, 0x28, 0x26, 0x74, 0x38, 0x39, 0xe5, 0x71, 0xf4, 0xb, 0xf5, 0xc9, 0x65, 0xee, 0xed, 0xb2, 0x93, 0xdd, 0x5d, 0xdd, 0x22, 0x44, 0x20, 0x71, 0x89, 0x5b, 0xd9, 0xc3, 0x4d, 0x8a, 0x34, 0x49, 0x7, 0xe1, 0x7a, 0xf7, 0xef, 0x48, 0x0, 0x88, 0x1, 0x6, 0x6a, 0xa8, 0xf4, 0x34, 0x1, 0x9d, 0x95, 0xa0, 0x1c, 0xe3, 0x4c, 0x30, 0xdc, 0x11, 0x6d, 0x6a, 0x5d, 0x9f, 0x6d, 0x43, 0xbc, 0x2c, 0xae, 0x32, 0x7b, 0x61, 0x3e, 0x61, 0x29, 0x9e, 0x75, 0xd5, 0x80, 0xc7, 0x32, 0x3e, 0xce, 0xaf, 0x49, 0x4d, 0x54, 0x82, 0x55, 0x53, 0xc9, 0x85, 0x14, 0xd8, 0x41, 0x56, 0x8f, 0x5b, 0xce, 0x9c, 0x97, 0x19, 0x4e, 0xc3, 0x6a, 0x16, 0xf6, 0xb1, 0xd, 0x9f, 0x18, 0x8, 0xec, 0xc1, 0xda, 0x80, 0xbe, 0x4d, 0x37, 0x73, 0x5a, 0xdb, 0x6d, 0x1b, 0x83, 0xa1, 0x57, 0xed, 0xec, 0x26, 0x66, 0x12, 0xe6, 0x5e, 0x57, 0xee, 0x41, 0x9a, 0xbf, 0xc3, 0x5e, 0x34, 0x2a, 0x67, 0x72, 0xb5, 0xff, 0xe8, 0xab, 0x1d, 0x80, 0x95, 0xbc, 0x92, 0xbf, 0x99, 0x82, 0xa7, 0xa3, 0x2e, 0x85, 0x5, 0xd8, 0xf2, 0xbd, 0xdd, 0xd6, 0x26, 0xd0, 0x9f, 0x20, 0x89, 0x30, 0x42, 0x7f, 0x14, 0x11, 0x1b, 0x91, 0xad, 0x66, 0xeb, 0xf7, 0x10, 0xd9, 0xb1, 0xea, 0xfb, 0x22, 0xfc, 0x34, 0xb2, 0x61, 0x64, 0x58, 0x28, 0x3e, 0x9f, 0xe1, 0x21, 0x8a, 0x28, 0x86, 0xa7, 0xb7, 0x37, 0x42, 0x34, 0x29, 0x62, 0xbf, 0xe5, 0xdf, 0xc2, 0xf8, 0x29, 0xa7, 0x72, 0x26, 0xfa, 0x8b, 0xb6, 0x16, 0x5e, 0xfc, 0x66, 0x87, 0x3d, 0x61, 0x8d, 0x8b, 0x6a, 0xce, 0xce, 0x4, 0x12, 0x51, 0x5c, 0x5a, 0x3, 0x2e, 0x44, 0x68, 0x5f, 0x73, 0x54, 0xf2, 0xdf, 0x2c, 0xa1, 0xf9, 0x3, 0xec, 0xf1, 0xa5, 0x38, 0x94, 0xa9, 0xa8, 0x7e, 0x7, 0xfb, 0x36, 0x75, 0x9f, 0xf6, 0x66, 0x56, 0x6, 0x5, 0xca, 0x55, 0x48, 0x8a, 0x7b, 0x3b, 0xfc, 0xfe, 0xbf, 0x6a, 0xd, 0x61, 0x64, 0x17, 0xc9, 0x38, 0x35, 0xec, 0xe0, 0x8f, 0xb6, 0x94, 0x50, 0xe0, 0x41, 0xa7, 0xc2, 0x39, 0x81, 0x52, 0xc, 0xe0, 0x3d, 0x51, 0x94, 0xdc, 0xe2, 0xac, 0x49, 0x2f, 0x2e, 0x48, 0x92, 0xb8, 0x2, 0x8a, 0x7e, 0xaf, 0xbb, 0x91, 0x39, 0x30, 0x94, 0x2f, 0xb2, 0x66, 0x43, 0x39, 0x4b, 0xfd, 0xd6, 0x7b, 0x93, 0x81, 0xb1, 0x58, 0x1f, 0x9f, 0x62, 0x99, 0x37, 0x8, 0xa3, 0xc4, 0x61, 0xff, 0xa4, 0x3f, 0x11, 0xaf, 0x67, 0x9b, 0x68, 0xf6, 0x2f, 0x25, 0x53, 0x50, 0xe, 0xd3, 0xd7, 0xd0, 0x49, 0x90, 0xa6, 0xfc, 0x10, 0x17, 0xd8, 0xd7, 0xaf, 0xf9, 0xb6, 0xdd, 0x58, 0xb2, 0x2f, 0x16, 0x81, 0x61, 0xe7, 0x1e, 0xad, 0x31, 0x18, 0x3e, 0xb3, 0x38, 0xc7, 0x5c, 0xb, 0xfa, 0x0, 0xa7, 0x1, 0xa1, 0x9f, 0x72, 0xb7, 0x3c, 0x5a, 0x77, 0x20, 0x90, 0xa8, 0x6b, 0xec, 0x3, 0xe4, 0xf9, 0xf2, 0x55, 0x49, 0x48, 0xd9, 0x4e, 0x15, 0x3, 0x10, 0xc5, 0xaa, 0xee, 0xe4, 0x6d, 0x1a, 0xee, 0x5b, 0x83, 0x76, 0x95, 0xfb, 0x49, 0x36, 0x8e, 0x59, 0xd1, 0x76, 0xe0, 0x19, 0x9c, 0xdd, 0xea, 0x60, 0x85, 0xc8, 0x97, 0xae, 0x28, 0x29, 0xb1, 0xc, 0x59, 0x25, 0x53, 0xd5, 0x4e, 0xc9, 0xa0, 0xa7, 0xb8, 0xb7, 0x88, 0x9, 0xa5, 0x1b, 0x9d, 0xea, 0xd6, 0x6d, 0x8, 0x79, 0xe8, 0xd7, 0x16, 0xb0, 0x51, 0x98, 0x1, 0xad, 0x71, 0xfc, 0xa6, 0x2d, 0x84, 0x83, 0x13, 0xd4, 0xf, 0x82, 0x24, 0x86, 0x1e, 0x58, 0xf0, 0xd1, 0x7, 0xef, 0x85, 0x5a, 0x6f, 0xe9, 0x31, 0x5d, 0xf8, 0xee, 0x62, 0x4c, 0x4, 0xc5, 0x64, 0x73, 0xc6, 0x1c, 0x40, 0x6, 0xe9, 0x37, 0x2c, 0xb2, 0x2b, 0x4c, 0xc3, 0xdd, 0xe1, 0xe, 0x60, 0xed, 0x3, 0xd6, 0xd6, 0xfc, 0x92, 0x8e, 0xfe, 0xfe, 0x11, 0xba, 0x7c, 0xec, 0x15, 0x35, 0x1f, 0xc0, 0xb0, 0xa5, 0x59, 0x7d, 0xea, 0xbc, 0x58, 0xb9, 0x10, 0x40, 0xb7, 0xb, 0xbd, 0xaf, 0x8e, 0x16, 0x15, 0xea, 0x52, 0x46, 0xca, 0x99, 0x3b, 0xbf, 0x65, 0x3e, 0xfe, 0xc3, 0xfa, 0xff, 0x58, 0x74, 0x67, 0xa1, 0x8a, 0x4f, 0x38, 0x68, 0xc1, 0x10, 0x9f, 0xb3, 0x55, 0x33, 0x8e, 0x54, 0xef, 0xf5, 0x8a, 0x1c, 0x90, 0xe2, 0xbb, 0xda, 0xdb, 0x2, 0x20, 0xf2, 0x25, 0x11, 0xc5, 0xd8, 0xcb, 0xa9, 0xa, 0xc4, 0x74, 0xfc, 0xcb, 0xf, 0x9d, 0xab, 0x7b, 0x66, 0x10, 0x9b, 0xaf, 0xba, 0x8e, 0x82, 0x38, 0x2c, 0xbb, 0x85, 0x1c, 0x2f, 0x8, 0x69, 0xb3, 0xbf, 0xf0, 0x9a, 0x90, 0x75, 0x1b, 0x59, 0x1b, 0xdc, 0xb6, 0x17, 0xc6, 0x87, 0x1f, 0xd8, 0xe2, 0x2b, 0xf5, 0x54, 0xf3, 0xaf, 0x80, 0x97, 0xe9, 0x44, 0x3d, 0xd, 0x85, 0xf9, 0xa7, 0xac, 0x34, 0x32, 0xdc, 0x8b, 0x3e, 0x3f, 0xc, 0x8a, 0x57, 0xe, 0x2f, 0x97, 0xdf, 0xb0, 0xe4, 0x44, 0x51, 0x52, 0xe4, 0xdd, 0xb, 0xe, 0xf1, 0xe6, 0x56, 0xdd, 0x7b, 0x7a, 0x50, 0xb3, 0x3, 0xb6, 0xbb, 0xc7, 0x34, 0x39, 0xf8, 0x73, 0x73, 0x7b, 0x47, 0xaf, 0x21, 0xaf, 0x43, 0x5c, 0x97, 0x3, 0xf7, 0x4, 0xdd, 0xc1, 0x53, 0xb2, 0x67, 0x88, 0xfe, 0x93, 0x2c, 0xfc, 0xf0, 0xe, 0x87, 0xe3, 0x3e, 0xb1, 0x95, 0xa3, 0x8c, 0x58, 0x12, 0x8a, 0x43, 0x5c, 0x81, 0xa0, 0xdf, 0xb4, 0x2e, 0xdb, 0xb0, 0xb9, 0xeb, 0x27, 0xf6, 0x4c, 0xf, 0xfe, 0x83, 0x57, 0xfd, 0x99, 0x5e, 0x8a, 0xc7, 0xb, 0xf0, 0xc7, 0xfb, 0xb2, 0x62, 0x2a, 0xb5, 0x47, 0x7c, 0xa8, 0xf6, 0x5e, 0xf1, 0xcc, 0xbf, 0xdd, 0xe0, 0xdd, 0xf2, 0xd6, 0x10, 0xf7, 0x91, 0x3d, 0x7f, 0xf6, 0x92, 0x79, 0xdd, 0x33, 0xea, 0xf4, 0xa4, 0x9e, 0x3a, 0x53, 0x26, 0xe5, 0x7a, 0xe3, 0xe8, 0xdf, 0xb7, 0x52, 0xe9, 0x89, 0xc9, 0x9d, 0x17, 0x3, 0x89, 0xc0, 0x1c, 0x9a, 0xdb, 0xda, 0x22, 0x84, 0x68, 0x68, 0xcb, 0xad, 0x5f, 0x62, 0xb9, 0x74, 0xbf, 0xc6, 0xa5, 0xa4, 0xa8, 0x8e, 0xb6, 0xe0, 0x4a, 0x28, 0x75, 0x2d, 0xe0, 0x94, 0x39, 0x15, 0x76, 0xfc, 0x17, 0x27, 0x5d, 0x87, 0x6a, 0x5d, 0x3b, 0x47, 0x8, 0x45, 0xa7, 0xa0, 0x64, 0xe0, 0xb, 0xe7, 0x91, 0xb2, 0xd, 0xad, 0xdb, 0xe5, 0x88, 0x12, 0xce, 0xb2, 0x96, 0x88, 0x4f, 0xd7, 0x24, 0x6f, 0xf6, 0x74, 0x11, 0xaa, 0xb7, 0x3d, 0x4, 0x9f, 0xc3, 0x25, 0xd, 0xa9, 0x11, 0x1d, 0x1b, 0x3f, 0x19, 0x2b, 0xd8, 0xbc, 0x65, 0xf, 0xc4, 0xac, 0x93, 0x92, 0xeb, 0x18, 0x84, 0xb, 0x36, 0xd8, 0x46, 0xa, 0x80, 0xd7, 0x96, 0x7b, 0x20, 0x75, 0x5b, 0xfc, 0xf8, 0x25, 0x18, 0x36, 0x96, 0x1f, 0x98, 0xb5, 0xe7, 0x17, 0xd7, 0xf0, 0x78, 0xd3, 0xa2, 0xcb, 0xb0, 0x9b, 0xfe, 0xda, 0x3, 0x42, 0x74, 0xb9, 0x3e, 0x80, 0x92, 0xd3, 0x7f, 0x6, 0xc, 0xee, 0x6, 0x59, 0x26, 0x9a, 0x9, 0xa1, 0x1c, 0xac, 0x90, 0x7c, 0xe, 0xc0, 0x27, 0xda, 0x78, 0xa7, 0x23, 0xa2, 0x7, 0xb2, 0x17, 0x73, 0x5b, 0x15, 0x99, 0x8e, 0xcf, 0xb3, 0xc4, 0x3d, 0x87, 0xae, 0xf6, 0x67, 0x1b, 0x54, 0xa7, 0x66, 0x66, 0x93, 0x3d, 0xd9, 0x8d, 0x5d, 0xb4, 0xc7, 0xa7, 0x38, 0xc4, 0x31, 0x73, 0xe7, 0x7b, 0x25, 0x73, 0xc7, 0x61, 0x82, 0x39, 0xf4, 0xb6, 0x64, 0x3, 0x14, 0x77, 0x2, 0x96, 0x66, 0xfb, 0x8d, 0x3b, 0xc2, 0x3, 0xf1, 0x19, 0xd, 0xcc, 0x27, 0xba, 0x6, 0x8, 0xb2, 0x76, 0xb5, 0x1f, 0x7c, 0xfb, 0xbc, 0x70, 0xf5, 0xd4, 0xb1, 0x44, 0x3d, 0xbe, 0x37, 0xdc, 0xea, 0x3, 0x54, 0xdd, 0x28, 0x8d, 0xd4, 0xd8, 0x51, 0xf1, 0x82, 0x28, 0x3f, 0xba, 0xd3, 0x1d, 0x4a, 0x8e, 0x57, 0x34, 0xa2, 0x8c, 0x49, 0x9, 0x4d, 0xe6, 0x1a, 0xf6, 0x67, 0x49, 0x60, 0xda, 0xbb, 0x2e, 0x63, 0x32, 0xfd, 0x5a, 0x92, 0x17, 0xa9, 0x2e, 0x5c, 0xb1, 0x1, 0x22, 0x3d, 0x98, 0xa4, 0xbd, 0x50, 0xe5, 0x68, 0x24, 0xc7, 0xda, 0x9, 0xaf, 0x16, 0x68, 0xb1, 0xe9, 0x8b, 0xee, 0xfa, 0x8c, 0xc9, 0xda, 0x8f, 0x5b, 0x64, 0x89, 0xff, 0x1f, 0x79, 0x5b, 0x6f, 0x2e, 0x3d, 0xa9, 0x65, 0x26, 0xec, 0x2, 0x33, 0x60, 0x4a, 0x5c, 0x30, 0xc, 0xa9, 0x91, 0xd5, 0x9, 0xa, 0x35, 0x8a, 0xd2, 0x1b, 0x1, 0xe9, 0x18, 0xe5, 0xfb, 0x9f, 0xc0, 0x7, 0xd, 0x3e, 0xc1, 0xa8, 0x64, 0x7a, 0x1f, 0x40, 0xfd, 0x9a, 0x66, 0x2d, 0xb1, 0x6a, 0xaf, 0x39, 0xb8, 0xfc, 0x35, 0x1d, 0x2f, 0xb0, 0x77, 0xba, 0x37, 0x80, 0x2, 0x58, 0x20, 0x24, 0x49, 0xdb, 0x1f, 0x1a, 0x95, 0xfa, 0x9d, 0xef, 0x31, 0xe4, 0x8c, 0xbb, 0xcc, 0x59, 0x4f, 0x6a, 0xd6, 0x3c, 0xca, 0x4f, 0xc3, 0xeb, 0x3b, 0xb5, 0x72, 0x8c, 0xbf, 0xe4, 0x2, 0x6c, 0x4a, 0x7a, 0xba, 0x1f, 0xed, 0x99, 0x26, 0x61, 0xe5, 0x8e, 0xdd, 0x33, 0x4b, 0x55, 0x5d, 0xc9, 0x3d, 0x34, 0xbf, 0x34, 0x64, 0x10, 0x12, 0x2c, 0xac, 0x14, 0xf7, 0x74, 0xb3, 0x99, 0xe, 0x68, 0x50, 0x8d, 0xd2, 0x1e, 0xf2, 0x7a, 0x83, 0xd6, 0xbb, 0x6c, 0xe2, 0x1e, 0xef, 0xdb, 0xaa, 0xa2, 0xca, 0x63, 0x44, 0x30, 0x0, 0xeb, 0xfa, 0xfd, 0xfc, 0x18, 0xc0, 0xc9, 0x6d, 0x7f, 0xf7, 0xeb, 0x47, 0x44, 0x8f, 0xc9, 0x46, 0xa1, 0xa0, 0x96, 0xb0, 0x0, 0x8e, 0xad, 0x10, 0x75, 0x20, 0xe2, 0x53, 0x6c, 0xff, 0x86, 0xce, 0xdd, 0xc9, 0x3f, 0x5f, 0x8f, 0x72, 0x78, 0x25, 0x57, 0x5c, 0x7f, 0xd7, 0xd5, 0x28, 0x47, 0x7e, 0x14, 0x54, 0x9c, 0x91, 0xfd, 0x86, 0xfb, 0xee, 0xa8, 0x32, 0xd1, 0xf6, 0x9d, 0x21, 0xd0, 0x5f, 0x22, 0xd, 0x81, 0xaf, 0x9c, 0x24, 0x17, 0x66, 0xca, 0xd8, 0xaa, 0x61, 0x54, 0xdd, 0x66, 0x61, 0x78, 0x9e, 0xbd, 0x44, 0xb6, 0x79, 0x15, 0xf2, 0xf5, 0x5b, 0x38, 0xea, 0xb1, 0x7, 0x4e, 0x48, 0xb1, 0x13, 0x7c, 0xfb, 0x1c, 0x44, 0xf, 0x1b, 0xef, 0x43, 0x8a, 0xc1, 0xdb, 0x41, 0x80, 0xb4, 0xd5, 0xc, 0xf7, 0x35, 0xd3, 0x9a, 0xf8, 0x20, 0x1e, 0x92, 0x36, 0xdc, 0x60, 0x56, 0xd2, 0x97, 0x4b, 0x95, 0x1a, 0xb4, 0x17, 0x47, 0x51, 0x96, 0x9f, 0xa0, 0xb3, 0x37, 0x5, 0xfb, 0x60, 0x5d, 0x2e, 0x92, 0x6a, 0x76, 0x4d, 0xa3, 0xca, 0x29, 0x92, 0xcc, 0x93, 0x8, 0x54, 0x7, 0x5c, 0xd, 0xa0, 0xe5, 0xd1, 0xb7, 0xbc, 0xc8, 0xb6, 0x6c, 0xb9, 0x37, 0xfd, 0x6b, 0x92, 0xa2, 0x77, 0x6c, 0x88, 0xc0, 0x2b, 0x39, 0x1d, 0x35, 0x37, 0x59, 0xa0, 0x4b, 0x5a, 0xba, 0x50, 0x34, 0x90, 0x5a, 0xad, 0x61, 0xd0, 0xc3, 0x30, 0xc9, 0xb0, 0x9, 0x69, 0xd1, 0xfd, 0x1d, 0xd9, 0x92, 0x84, 0xd2, 0x31, 0x3e, 0x90, 0xa5, 0xb8, 0xb0, 0x80, 0x3b, 0xcc, 0x19, 0xd7, 0x2, 0xe1, 0x31, 0xb4, 0x13, 0x3b, 0xb9, 0x1c, 0xed, 0x8a, 0xab, 0x62, 0xb0, 0x10, 0x6c, 0xbe, 0x3d, 0xb, 0xa5, 0x97, 0xc6, 0x9c, 0xbb, 0xab, 0xe0, 0xcf, 0x66, 0x9f, 0xe4, 0x46, 0xaa, 0xd7, 0xdf, 0x1e, 0x4e, 0x68, 0x27, 0xe2, 0x80, 0xfe, 0x8f, 0x2e, 0xe9, 0x1c, 0x99, 0xb1, 0xdb, 0x44, 0xd1, 0xa, 0x65, 0x76, 0xa5, 0x35, 0xb4, 0xfb, 0xc6, 0xc7, 0x62, 0x69, 0xd1, 0xb0, 0x25, 0x2c, 0xf4, 0x82, 0xb9, 0x21, 0x88, 0x9a, 0xac, 0xba, 0x14, 0xb4, 0xc0, 0xa2, 0xeb, 0x59, 0x7, 0x61, 0x12, 0x90, 0xce, 0x4, 0xb2, 0x9a, 0xc5, 0x43, 0x6e, 0xdb, 0x8d, 0x5d, 0x77, 0xa6, 0xe8, 0xac, 0x5c, 0x67, 0x2d, 0x67, 0xe1, 0x7, 0xb6, 0xa8, 0x66, 0xc4, 0xba, 0xe3, 0x6e, 0x82, 0xe2, 0x2f, 0xe6, 0xfc, 0x5b, 0x31, 0x53, 0x84, 0x84, 0x40, 0x2a, 0x30, 0xa5, 0x22, 0x1f, 0xa2, 0x35, 0x7c, 0x3d, 0x17, 0xa1, 0x31, 0x7e, 0xf8, 0xe5, 0xac, 0xf7, 0x32, 0x9c, 0x67, 0xb, 0x67, 0xd3, 0x8f, 0x1c, 0xe6, 0xa, 0x5, 0xdd, 0x99, 0x1b, 0xa8, 0x55, 0xc5, 0x98, 0xf9, 0xc3, 0x2e, 0x51, 0x8b, 0x95, 0xb6, 0xae, 0xb8, 0x45, 0x87, 0x10, 0x38, 0x15, 0x1, 0x9e, 0x39, 0x75, 0x3d, 0x43, 0xa7, 0x1a, 0x8c, 0x82, 0x58, 0x95, 0xcf, 0x25, 0x69, 0x78, 0x63, 0x58, 0xb7, 0x8a, 0x74, 0xa5, 0xb4, 0x7b, 0x7d, 0xfc, 0x32, 0x92, 0x14, 0x6b, 0xad, 0xbe, 0x8, 0x67, 0xa3, 0x53, 0xa7, 0x28, 0x54, 0x87, 0xba, 0xdd, 0xe2, 0x8e, 0x9d, 0x78, 0xf7, 0xe8, 0xb2, 0xfe, 0xe, 0x7c, 0xf7, 0x83, 0x30, 0xd4, 0xba, 0xda, 0xd, 0x60, 0x6d, 0x6d, 0x40, 0xfe, 0x92, 0x96, 0xeb, 0x50, 0xc, 0xc9, 0x6, 0x54, 0x5d, 0x72, 0x59, 0x6c, 0x8c, 0x98, 0x18, 0x86, 0x73, 0xf4, 0x10, 0x57, 0x6d, 0x15, 0x4e, 0x3b, 0xcb, 0x1f, 0x88, 0x87, 0xe5, 0x61, 0x3c, 0x3c, 0xf2, 0x79, 0xbe, 0x30, 0x7c, 0x2, 0x24, 0xda, 0xdf, 0x58, 0xa9, 0x1e, 0x93, 0x21, 0x1f, 0x11, 0x73, 0xc4, 0x61, 0xef, 0x42, 0xf3, 0x51, 0xc7, 0xdb, 0xa4, 0x99, 0xd6, 0x97, 0x42, 0x45, 0xe1, 0xd8, 0x8b, 0xa2, 0x28, 0x30, 0xb0, 0x7f, 0x6d, 0x73, 0x5c, 0x5a, 0x74, 0xde, 0x47, 0x5c, 0x7f, 0x8, 0xa9, 0x40, 0x46, 0x5, 0x12, 0xee, 0xe2, 0xca, 0xa4, 0x67, 0x5, 0x58, 0x8, 0x68, 0xd6, 0x39, 0xe4, 0x6b, 0x3f, 0xde, 0x80, 0x5a, 0xa1, 0x34, 0x3c, 0xec, 0x38, 0x5, 0xce, 0xb7, 0xe6, 0x24, 0x53, 0x9f, 0xb2, 0xb3, 0x62, 0x38, 0x2f, 0x5b, 0xf0, 0xd5, 0x5e, 0x6f, 0x3b, 0x90, 0xd2, 0x12, 0x51, 0x62, 0xae, 0x7b, 0xab, 0xdf, 0x96, 0xfe, 0xe5, 0x4b, 0x29, 0xbf, 0xa9, 0xef, 0xfd, 0x80, 0xa5, 0x8, 0xe8, 0xb, 0x47, 0x8e, 0xf6, 0x79, 0x97, 0xaf, 0x16, 0x6b, 0x54, 0x17, 0x62, 0xb, 0xa5, 0x88, 0x6d, 0x63, 0x1d, 0xf5, 0x1, 0xee, 0xb2, 0x42, 0xcc, 0x40, 0xd0, 0x53, 0x87, 0xc9, 0x73, 0xb, 0xbe, 0x8c, 0xb0, 0x70, 0xb2, 0x21, 0xa, 0x87, 0x75, 0xdd, 0x25, 0xa5, 0xb7, 0x67, 0x55, 0x38, 0xb, 0xa7, 0xe2, 0xea, 0x2, 0x14, 0x2e, 0x43, 0xa3, 0xff, 0xfb, 0x6f, 0x1b, 0xed, 0x55, 0x9c, 0xaa, 0x68, 0xb0, 0x9d, 0xfc, 0x8d, 0xfc, 0x18, 0x64, 0xed, 0xaf, 0xf7, 0x5, 0xbb, 0x1e, 0x30, 0xfb, 0x58, 0xc3, 0xa2, 0x7c, 0x5b, 0x1c, 0x42, 0x5b, 0x22, 0xd0, 0xc1, 0x7, 0x37, 0x26, 0xa2, 0xca, 0xae, 0x5c, 0xfa, 0x63, 0x1c, 0xc2, 0xed, 0xac, 0x96, 0xc1, 0xf, 0xb2, 0x53, 0x29, 0xf0, 0xe6, 0xd1, 0x5e, 0x4d, 0x52, 0x69, 0x4f, 0x86, 0x70, 0xd3, 0xd0, 0x54, 0xe9, 0xfb, 0xb2},
+               output224: []byte{0xdf, 0x76, 0x57, 0x85, 0xbb, 0x97, 0xba, 0x37, 0x86, 0xea, 0x56, 0xdf, 0xe8, 0x5a, 0xf5, 0xc7, 0x34, 0x47, 0x13, 0xeb, 0x5f, 0xee, 0xf3, 0x74, 0xed, 0xe9, 0xe6, 0x60},
+               output256: []byte{0xc3, 0x6a, 0xc1, 0x51, 0xbe, 0x54, 0x58, 0x23, 0x9a, 0xe7, 0xa0, 0xe6, 0xb4, 0x70, 0x69, 0x50, 0xa1, 0xc6, 0xb0, 0x46, 0xf0, 0x2d, 0x64, 0x29, 0x5d, 0xc1, 0xe5, 0xe9, 0x6e, 0x7f, 0xfd, 0x5b},
+               output384: []byte{0x2e, 0xf1, 0x6b, 0xfe, 0xf6, 0xea, 0x7a, 0x6, 0xc3, 0x80, 0xb8, 0x8d, 0xbc, 0x41, 0x27, 0x7b, 0xea, 0x79, 0x6e, 0xf1, 0xba, 0x8d, 0x7c, 0xdd, 0x32, 0xef, 0x15, 0xcf, 0x6e, 0xb0, 0x7a, 0x23, 0x4, 0xfb, 0xbc, 0xe0, 0x55, 0x47, 0x8d, 0xa5, 0xa, 0x1c, 0xea, 0x34, 0x5e, 0xa0, 0x27, 0x9f},
+               output512: []byte{0x1c, 0xb0, 0xd8, 0x98, 0x95, 0xfa, 0xbc, 0x4, 0xe0, 0xb1, 0x9a, 0x71, 0xb2, 0x74, 0x2, 0x4a, 0x67, 0xf0, 0x8a, 0x3d, 0x88, 0x11, 0x93, 0xef, 0x43, 0x8a, 0xfb, 0x3a, 0x8f, 0xfb, 0x3, 0x3a, 0x47, 0x2a, 0x35, 0x7f, 0x9d, 0xa3, 0x51, 0xc7, 0xd5, 0xbd, 0xde, 0x9b, 0x88, 0x8e, 0x9c, 0x4d, 0x8f, 0xc9, 0x21, 0x6a, 0x17, 0x1, 0xfe, 0xa2, 0x60, 0x6f, 0x8a, 0x5a, 0x64, 0x75, 0xd3, 0x2f}},
+       testcase{
+               msg:       []byte{0xb7, 0x20, 0x2c, 0x31, 0xc3, 0x3e, 0x55, 0x79, 0x59, 0x9d, 0x14, 0xd1, 0x25, 0x11, 0xcd, 0x70, 0xe, 0x5a, 0x7, 0x76, 0x79, 0x26, 0x6b, 0x94, 0xb4, 0x45, 0x86, 0xb3, 0x63, 0x67, 0x76, 0x92, 0xa4, 0xf2, 0x83, 0x8f, 0x50, 0xd4, 0x37, 0xc9, 0x9, 0xe5, 0xa4, 0x1b, 0xa7, 0x47, 0xa6, 0xf2, 0xc7, 0x2b, 0xe8, 0x51, 0x49, 0xd5, 0x3a, 0x83, 0x4f, 0x7e, 0x66, 0xb6, 0xdc, 0x74, 0x92, 0x72, 0x50, 0xb5, 0x43, 0x12, 0x1b, 0x6b, 0x47, 0x80, 0x54, 0x2a, 0xb5, 0x11, 0xad, 0xf2, 0x1, 0x13, 0x80, 0xf0, 0xd7, 0x13, 0x3b, 0xf8, 0x2b, 0x38, 0xa2, 0xe3, 0x77, 0xb5, 0xc7, 0x75, 0x5e, 0x49, 0xbb, 0x1a, 0xbc, 0x16, 0xee, 0xa, 0x4a, 0x77, 0x2f, 0x56, 0x53, 0xbb, 0xfe, 0x6, 0xbe, 0x77, 0x73, 0x29, 0xa, 0xa4, 0xa9, 0xa0, 0x59, 0xb9, 0x86, 0x47, 0xc1, 0x88, 0xbb, 0xa6, 0x9, 0xd3, 0x1a, 0xf5, 0x94, 0xd0, 0x59, 0x4b, 0x37, 0x59, 0x63, 0xf2, 0x49, 0x29, 0x6f, 0xc6, 0x97, 0x4d, 0x25, 0x20, 0xcf, 0xe9, 0xeb, 0xab, 0x8c, 0x41, 0x54, 0xf1, 0xb9, 0xa7, 0xee, 0xe6, 0x69, 0x68, 0xb8, 0x53, 0xf1, 0x9f, 0x74, 0xd3, 0x12, 0x5b, 0x82, 0x83, 0xe5, 0xf1, 0x67, 0x39, 0x5e, 0xe1, 0x7, 0x72, 0x63, 0xee, 0xf9, 0x1c, 0xf5, 0x73, 0xf1, 0xa2, 0x58, 0x38, 0x4d, 0x36, 0x9c, 0xa, 0x1b, 0x8f, 0x4e, 0x12, 0xc0, 0x5f, 0x94, 0x2b, 0x33, 0xd, 0x43, 0xa1, 0x68, 0x29, 0xd, 0x82, 0x32, 0x5e, 0xb2, 0xb7, 0x7d, 0x49, 0xf2, 0x5e, 0x2, 0x8a, 0xa3, 0x77, 0x51, 0xa2, 0x8c, 0x40, 0x5a, 0x6a, 0xb1, 0x90, 0xb7, 0x44, 0xc5, 0xf9, 0x98, 0xd7, 0xca, 0xba, 0xe1, 0x8c, 0xe1, 0x84, 0xd9, 0x6b, 0xa9, 0xbe, 0x24, 0x28, 0x15, 0x56, 0x38, 0x7d, 0x71, 0xe, 0x66, 0xfd, 0x77, 0x80, 0xeb, 0x1a, 0xd, 0x91, 0xa3, 0xf6, 0x39, 0x6c, 0xca, 0xa5, 0x4a, 0x7b, 0x2b, 0x22, 0x3a, 0xbc, 0x19, 0x2, 0xa6, 0x60, 0xa4, 0x4e, 0xd1, 0xfc, 0x26, 0x6, 0xaa, 0x5, 0x4e, 0x1c, 0xf, 0xd9, 0x12, 0x4e, 0xeb, 0xcc, 0x9, 0x93, 0x92, 0x2b, 0x79, 0xab, 0x6d, 0xc2, 0x25, 0x82, 0x6c, 0xc3, 0xfb, 0xb0, 0xb9, 0x90, 0x46, 0x52, 0x9a, 0xb3, 0xcf, 0xc7, 0x9e, 0xab, 0x58, 0xea, 0x68, 0xa1, 0x53, 0xf0, 0xc1, 0x4e, 0x57, 0x35, 0xcb, 0x42, 0x96, 0xfb, 0xfc, 0xb2, 0x3a, 0xcd, 0x15, 0x8a, 0xdc, 0x1b, 0x4, 0x9b, 0xbf, 0x85, 0x40, 0x54, 0xa7, 0xe0, 0x8b, 0xfe, 0xb, 0x7d, 0x4c, 0x88, 0x96, 0x67, 0xa, 0x90, 0xbc, 0x1a, 0x3a, 0x9d, 0x4a, 0x2f, 0x74, 0xd1, 0xfb, 0x5e, 0x14, 0x3a, 0x4d, 0x22, 0xed, 0xe7, 0x9c, 0x73, 0x8b, 0x41, 0xb9, 0x1b, 0x93, 0xab, 0x34, 0xa9, 0x1c, 0x8e, 0x32, 0x7b, 0xf1, 0x7a, 0x1e, 0x86, 0x88, 0x45, 0x44, 0xb7, 0x5, 0x57, 0xd4, 0xec, 0x18, 0x4f, 0x82, 0xea, 0x5b, 0x5c, 0x56, 0x82, 0xe3, 0x3a, 0xf7, 0xcc, 0x38, 0xc5, 0xf9, 0x1b, 0xf5, 0xd0, 0x24, 0xcf, 0xff, 0xd1, 0x45, 0xa5, 0xae, 0xa6, 0xfd, 0x7b, 0x6b, 0x4, 0x56, 0xaf, 0x14, 0xbd, 0xcf, 0x60, 0x73, 0x4c, 0xc9, 0x3c, 0x13, 0x87, 0xa4, 0x8d, 0xfb, 0x97, 0xb9, 0x1b, 0xb2, 0x3d, 0x7f, 0x68, 0xeb, 0x78, 0x3e, 0xb0, 0xcd, 0xbd, 0xb, 0xbe, 0x41, 0x4, 0xab, 0x21, 0x21, 0x47, 0xc9, 0xca, 0xa9, 0xdd, 0x92, 0x3e, 0x88, 0x3c, 0x3e, 0x24, 0xb5, 0x3a, 0xeb, 0xcc, 0x3f, 0x7f, 0xa5, 0xaa, 0x5c, 0x88, 0x70, 0x78, 0x62, 0x8e, 0xfd, 0x7e, 0x82, 0x54, 0x3f, 0x86, 0x0, 0xfd, 0xf8, 0x9a, 0x33, 0x12, 0xad, 0x69, 0x2, 0x27, 0x13, 0x21, 0xb7, 0x7c, 0x1f, 0x8d, 0xff, 0x1b, 0x92, 0x25, 0xc, 0x59, 0xe0, 0x37, 0x41, 0x1c, 0x67, 0x91, 0xc7, 0xe9, 0x30, 0xd6, 0x86, 0xe7, 0xbf, 0x35, 0x9e, 0xc4, 0x80, 0xc6, 0xd0, 0xbd, 0x5, 0xd2, 0x0, 0x9f, 0x2d, 0x33, 0x9d, 0x20, 0x89, 0xd5, 0x20, 0x2c, 0x65, 0xb8, 0xfe, 0x73, 0x7e, 0xbe, 0xa6, 0xcb, 0x6d, 0x92, 0x71, 0xb0, 0xbb, 0xd3, 0xec, 0xd6, 0x32, 0x8a, 0xa2, 0x7e, 0xc7, 0x72, 0x2c, 0xbb, 0x3e, 0x70, 0x6, 0x62, 0xee, 0x6a, 0xfe, 0xbd, 0xc4, 0xff, 0x5e, 0x9b, 0x0, 0x94, 0x9e, 0xc3, 0xda, 0x53, 0xa, 0xa2, 0x71, 0xa7, 0x8c, 0xa7, 0x32, 0x82, 0x17, 0xbd, 0xb5, 0x60, 0x4, 0x48, 0xd9, 0xf8, 0x25, 0x83, 0x6e, 0x4, 0x89, 0x2c, 0xef, 0x50, 0xa9, 0x5f, 0x8c, 0xea, 0xaa, 0x5c, 0x28, 0xf2, 0xb9, 0xb1, 0x85, 0x53, 0x6f, 0xf2, 0xdd, 0xf3, 0x80, 0x80, 0x8e, 0xa3, 0x51, 0xbb, 0xd7, 0xa0, 0x68, 0xbd, 0x43, 0xbf, 0xe8, 0xee, 0xa7, 0xa3, 0x29, 0x2c, 0x65, 0x13, 0x9, 0x15, 0xe8, 0x28, 0x20, 0x4c, 0xe, 0xc1, 0x93, 0x9f, 0x1e, 0x30, 0x88, 0x5, 0x8c, 0xce, 0x4b, 0x29, 0x21, 0x53, 0xe, 0x3a, 0x2c, 0x8c, 0xbd, 0x3f, 0xca, 0x2e, 0xe3, 0x95, 0x4, 0xb7, 0x2e, 0xe7, 0x2d, 0xe1, 0x20, 0x31, 0x64, 0xab, 0xa, 0xf7, 0x8b, 0x66, 0x60, 0xb, 0x27, 0xa0, 0x67, 0xcd, 0x62, 0xd7, 0xdf, 0xac, 0x48, 0x15, 0xb2, 0x3a, 0x71, 0x28, 0x70, 0xaa, 0x4f, 0x26, 0x59, 0x15, 0x70, 0x37, 0x28, 0x53, 0x86, 0xbe, 0xaf, 0x26, 0x49, 0x74, 0x1d, 0xa7, 0xf, 0xb7, 0xe0, 0x31, 0xb4, 0xe1, 0xf3, 0x77, 0x68, 0xa0, 0xc3, 0x49, 0xc7, 0xb8, 0xc9, 0xa, 0x3d, 0xa6, 0x13, 0x84, 0x47, 0xdb, 0x7c, 0xda, 0x0, 0xc9, 0xfb, 0x1, 0x64, 0x7e, 0x32, 0x39, 0xa6, 0x80, 0xff, 0xb6, 0xc8, 0xd4, 0xd5, 0x36, 0xde, 0xa7, 0x13, 0x14, 0x80, 0xfa, 0x95, 0xc5, 0x97, 0xbf, 0xf6, 0x7a, 0xb5, 0xba, 0xe2, 0x57, 0x89, 0x54, 0xbe, 0x1, 0xbe, 0x5f, 0x38, 0x92, 0x68, 0x8a, 0x98, 0xb0, 0xad, 0xa, 0x21, 0xb0, 0xaf, 0x40, 0xe5, 0x62, 0x17, 0x51, 0x64, 0x1, 0x8d, 0x32, 0xd6, 0xa8, 0x86, 0xdc, 0xcb, 0x25, 0x6e, 0xd7, 0xc4, 0x14, 0x8e, 0xeb, 0x96, 0x30, 0x42, 0xbc, 0xa3, 0x4b, 0x68, 0x9c, 0x44, 0xbc, 0x48, 0x5f, 0x28, 0x6a, 0x65, 0xd1, 0xec, 0x44, 0xe5, 0xa0, 0xc9, 0xf, 0x5a, 0x1e, 0x8d, 0x6a, 0x29, 0xdc, 0x30, 0x81, 0x9, 0x17, 0xb8, 0xa3, 0xa6, 0xde, 0xb0, 0x36, 0x2d, 0x59, 0x67, 0xf7, 0x58, 0x2, 0xe8, 0x17, 0x47, 0x25, 0xb7, 0x34, 0xb6, 0x17, 0x87, 0x43, 0x7a, 0xa6, 0xff, 0x8a, 0x4f, 0xea, 0x6c, 0x23, 0x90, 0xc4, 0x77, 0xdd, 0xa0, 0x85, 0xa6, 0x2c, 0x64, 0x77, 0xe9, 0x94, 0x91, 0x35, 0x2, 0xb8, 0x62, 0xba, 0xe5, 0x48, 0x79, 0x8a, 0x17, 0x71, 0x6a, 0x48, 0xfc, 0xec, 0xf3, 0x15, 0x48, 0x78, 0x44, 0xa1, 0xd9, 0x8e, 0xaf, 0x12, 0x25, 0x21, 0x17, 0x38, 0x7, 0xcb, 0x72, 0x30, 0x8c, 0xdf, 0xc6, 0xcf, 0xa2, 0xf1, 0xb9, 0x32, 0x4a, 0x30, 0x58, 0x69, 0xe4, 0x7c, 0xe1, 0x5c, 0xd1, 0x8c, 0xb3, 0x8c, 0xe8, 0x3e, 0xd3, 0xb4, 0x1a, 0x71, 0x20, 0x5b, 0xe4, 0x9c, 0xab, 0x4b, 0x93, 0x14, 0x2d, 0x8e, 0x20, 0xa4, 0xc4, 0x36, 0x5e, 0x4b, 0xe, 0x72, 0xb4, 0x8e, 0x54, 0x40, 0xc8, 0xe8, 0xf5, 0xa8, 0xab, 0xbe, 0x22, 0xe5, 0xc2, 0x4d, 0x2f, 0xfa, 0xe, 0x6, 0x24, 0x34, 0xfb, 0x17, 0x11, 0x90, 0x28, 0x29, 0x9a, 0xd5, 0xae, 0x73, 0x2f, 0xf, 0xa3, 0x91, 0x27, 0xe5, 0x33, 0xd5, 0x91, 0xa2, 0x7c, 0x7a, 0x1, 0x7, 0xa9, 0x44, 0x2b, 0x7c, 0x22, 0x11, 0xc2, 0xf7, 0xfd, 0xad, 0xe8, 0x6b, 0xf0, 0x32, 0xce, 0x72, 0xe9, 0x4e, 0x71, 0xd6, 0x7, 0x24, 0x66, 0xe7, 0xc5, 0xc, 0x62, 0xe0, 0x1c, 0x35, 0xaf, 0x9b, 0xf5, 0xde, 0x70, 0x8a, 0x30, 0x9c, 0x56, 0x94, 0xc8, 0x4e, 0xd4, 0x7a, 0xb3, 0x97, 0xc4, 0x9, 0x5, 0x72, 0x19, 0xb2, 0xb8, 0x1d, 0x9b, 0xca, 0x75, 0x26, 0x76, 0x5c, 0x11, 0x70, 0x1e, 0x69, 0x93, 0x37, 0x8b, 0xed, 0x5, 0xf5, 0xe5, 0xba, 0x5f, 0x9c, 0x5f, 0xc3, 0xe3, 0xe6, 0x9, 0x7d, 0x39, 0xc8, 0x6b, 0x29, 0x95, 0xa9, 0xfe, 0x75, 0xdb, 0xdd, 0xc, 0xbd, 0x3a, 0x9d, 0x96, 0xc3, 0x35, 0xc8, 0xf3, 0xf, 0xb0, 0x4, 0x19, 0x62, 0x2f, 0x8d, 0x61, 0x19, 0x24, 0x6f, 0x1b, 0x94, 0xee, 0x85, 0x24, 0xa2, 0x75, 0x73, 0x8a, 0x2b, 0x31, 0x2d, 0x3, 0x6a, 0xd0, 0xa8, 0xab, 0x72, 0xac, 0x50, 0xf7, 0x6c, 0x86, 0x42, 0xb0, 0xf, 0x35, 0x4b, 0x0, 0xe0, 0x31, 0x1a, 0xc1, 0xc1, 0x1c, 0x13, 0x32, 0x37, 0x2e, 0x4a, 0xd1, 0xa9, 0x82, 0x2, 0x72, 0x30, 0x53, 0x6e, 0x7a, 0x3d, 0x45, 0x1b, 0xb1, 0xe5, 0x5e, 0x50, 0x9a, 0xd0, 0x26, 0x18, 0x86, 0x68, 0xbe, 0x90, 0xb1, 0x2c, 0xdc, 0xb6, 0x4a, 0xb4, 0xc1, 0x9e, 0x46, 0xbd, 0x19, 0x98, 0x3f, 0x4e, 0x1d, 0x26, 0xf8, 0x52, 0x58, 0x50, 0x4a, 0xf4, 0xda, 0xaa, 0x3c, 0x18, 0x8f, 0xc2, 0xac, 0xaf, 0x6a, 0xde, 0x8f, 0xef, 0xa7, 0xa4, 0x2a, 0xba, 0x19, 0xdc, 0x7d, 0x1f, 0x22, 0x69, 0xfd, 0xdf, 0xb1, 0x5e, 0xd2, 0xc6, 0x59, 0x72, 0x58, 0x29, 0xe0, 0x73, 0x69, 0x47, 0xda, 0xcc, 0x67, 0xd8, 0x3b, 0xf, 0xf4, 0xf1, 0xdf, 0xdb, 0x8b, 0x99, 0x8e, 0xfd, 0x4e, 0x50, 0xd8, 0xe5, 0x5, 0x58, 0x38, 0x14, 0xe0, 0x49, 0xa3, 0x19, 0x23, 0xfe, 0xbe, 0x47, 0x9e, 0xa8, 0x88, 0x16, 0xa7, 0xfd, 0x4, 0x4a, 0x52, 0x33, 0x9b, 0x76, 0x1f, 0x9e, 0x6, 0x9c, 0x75, 0x85, 0xd9, 0xed, 0x7f, 0x23, 0x97, 0xad, 0x4c, 0x20, 0x8a, 0xb0, 0x6c, 0x5f, 0xe4, 0xbc, 0x6f, 0xf9, 0xb3, 0x67, 0xd1, 0x9, 0xdd, 0x3f, 0xbb, 0xbb, 0x48, 0xf3, 0x19, 0x5, 0x3c, 0x8b, 0xcf, 0x64, 0x3e, 0x1b, 0x83, 0x46, 0xea, 0x42, 0x92, 0xe, 0x9c, 0xda, 0x20, 0x2e, 0xa0, 0xa7, 0x4e, 0x44, 0x30, 0x5f, 0x8e, 0xf7, 0xb1, 0x8c, 0xfa, 0x5c, 0x92, 0x1c, 0x9e, 0x5e, 0x54, 0x62, 0x76, 0xd3, 0xea, 0xd2, 0x56, 0x8a, 0x9d, 0xf7, 0xb7, 0x88, 0x3d, 0x4c, 0x20, 0xb0, 0xf3, 0x8b, 0xed, 0x53, 0x8d, 0x9b, 0x41, 0xab, 0xa4, 0x91, 0xa4, 0xba, 0x3e, 0x4c, 0x47, 0x87, 0xfb, 0xb6, 0xf7, 0x5b, 0x18, 0xdc, 0x6c, 0x35, 0x6a, 0x95, 0xde, 0xbd, 0x89, 0x85, 0xa0, 0x28, 0xc1, 0xd0, 0xc5, 0x6a, 0xb5, 0xd0, 0x64, 0x6, 0xe5, 0x47, 0xcb, 0x4f, 0xe8, 0x8b, 0xea, 0x7d, 0xf, 0x8b, 0x3d, 0x24, 0x4f, 0xd, 0x57, 0x65, 0x2a, 0x18, 0xd1, 0x22, 0xfb, 0xd1, 0xc6, 0xdf, 0x0, 0x2, 0xf3, 0xbf, 0xa0, 0x71, 0x97, 0x13, 0x99, 0xc7, 0x49, 0xa0, 0x55, 0x69, 0xf9, 0x72, 0xac, 0xc, 0x79, 0xcf, 0x65, 0x32, 0x50, 0x77, 0x40, 0xc3, 0xb9, 0x6, 0xe1, 0xc5, 0x66, 0x41, 0x94, 0x2e, 0x21, 0x5f, 0xe6, 0x0, 0x2, 0xac, 0xb2, 0xf3, 0x30, 0xc9, 0x98, 0x0, 0xb8, 0x41, 0x0, 0x98, 0x21, 0x23, 0x21, 0x1a, 0x1b, 0xb9, 0xc0, 0x58, 0x45, 0xc2, 0x9e, 0xd0, 0x3e, 0x35, 0x49, 0x86, 0x17, 0x87, 0x86, 0x8c, 0xdf, 0x9f, 0x20, 0xc9, 0xdc, 0x3d, 0xd9, 0xc6, 0x38, 0xa9, 0xd5, 0xec, 0x2, 0x38, 0xab, 0x5, 0xbb, 0x2c, 0x31, 0xe4, 0x75, 0xf0, 0x8, 0xdd, 0x3e, 0x5c, 0x9a, 0xdc, 0xb0, 0x96, 0x8d, 0x2, 0x2b, 0x99, 0xf1, 0xc8, 0x48, 0x33, 0x9e, 0xd3, 0x86, 0x1, 0xfd, 0x59, 0x4f, 0x2b, 0xe5, 0x43, 0x84, 0x40, 0xf6, 0x37, 0x1a, 0xc9, 0x54, 0x57, 0x30, 0x12, 0xd6, 0x26, 0xf9, 0xcf, 0xff, 0xb0, 0x6a, 0xf4, 0xdc, 0x2f, 0xc, 0x52, 0x2e, 0x52, 0x58, 0x96, 0x8a, 0x6e, 0xb2, 0x88, 0x22, 0x58, 0x48, 0x35, 0xcb, 0x64, 0xdc, 0xb1, 0xa1, 0x59, 0x30, 0x29, 0x58, 0x85, 0x94, 0x66, 0x5b, 0xe0, 0xf5, 0x68, 0x48, 0xe2, 0x4f, 0x6b, 0xa9, 0x14, 0xd3, 0xac, 0x6d, 0xf6, 0xee, 0x1, 0x9a, 0x43, 0x71, 0xd8, 0xd7, 0xcf, 0xc7, 0x47, 0x33, 0xf2, 0x97, 0x84, 0xef, 0x56, 0xe0, 0x18, 0x36, 0x39, 0xdb, 0xd8, 0xfe, 0x0, 0x1c, 0x63, 0xe8, 0x5f, 0xc3, 0x20, 0x6b, 0x29, 0x9f, 0x1e, 0xc1, 0x3, 0x6d, 0xdd, 0xc0, 0x18, 0x51, 0xd1, 0x89, 0xb5, 0xee, 0x27, 0xe, 0xe5, 0x29, 0x3b, 0x77, 0xab, 0xf4, 0xa4, 0xbc, 0x6f, 0x98, 0x68, 0x14, 0xfc, 0xe, 0xd6, 0x50, 0x11, 0x75, 0x4f, 0x40, 0x30, 0xdd, 0xca, 0x7d, 0xc6, 0x7d, 0x60, 0x51, 0x24, 0x61, 0x36, 0x95, 0x1c, 0xfc, 0xb6, 0xaa, 0xfe, 0x14, 0x5f, 0x5c, 0x14, 0xdf, 0x53, 0x90, 0xb1, 0x5, 0xff, 0x1e, 0xf9, 0xd3, 0x5d, 0x31, 0xec, 0xbb, 0x5, 0xb2, 0xd8, 0x81, 0x40, 0xa7, 0xc6, 0x62, 0xca, 0x6f, 0x58, 0xe2, 0x68, 0x2c, 0xb2, 0x1f, 0x1d, 0xa8, 0x37, 0x19, 0x12, 0x20, 0xe3, 0xb2, 0xdb, 0xf9, 0x25, 0x46, 0xd5, 0x76, 0xe2, 0x77, 0x9, 0xc6, 0x7f, 0xb3, 0xea, 0x8a, 0xb8, 0xb5, 0x3f, 0x39, 0x4c, 0x82, 0x83, 0x4d, 0xd9, 0xfc, 0xb3, 0x17, 0xa1, 0xb5, 0x1d, 0x17, 0x23, 0xbb, 0xda, 0x7a, 0xb5, 0x31, 0x57, 0x78, 0xb2, 0x7a, 0xfa, 0x89, 0xd1, 0x91, 0xf1, 0xa4, 0x7f, 0x8a, 0xe, 0xc, 0x15, 0xe3, 0x3f, 0xb, 0xdf, 0x57, 0x7f, 0x92, 0xef, 0xe3, 0xea, 0xed, 0x65, 0x46, 0xa9, 0x48, 0x72, 0x33, 0xcf, 0x9c, 0x77, 0x55, 0xd, 0x48, 0x2d, 0xa1, 0xb9, 0x9f, 0xb3, 0xb7, 0x21, 0xab, 0x7e, 0xf7, 0x82, 0x65, 0x50, 0xfc, 0x4b, 0xf9, 0x53, 0x42, 0x6b, 0x69, 0xcc, 0xa8, 0x5, 0x49, 0x56, 0x9e, 0x1e, 0xc6, 0xe5, 0x23, 0x82, 0x20, 0x60, 0xb4, 0xcb, 0x8a, 0x88, 0xbc, 0xae, 0x1b, 0x9f, 0x48, 0xe, 0x7, 0x3a, 0x90, 0xe4, 0xcd, 0xbc, 0x8e, 0x60, 0x99, 0x4b, 0x6b, 0x95, 0x3e, 0xd1, 0x53, 0xc9, 0xda, 0x14, 0x6f, 0x4a, 0xc0, 0xd2, 0x3, 0x1, 0x5, 0xbd, 0xee, 0x29, 0x6d, 0xc6, 0xbf, 0xdb, 0xeb, 0xf7, 0x5e, 0x63, 0x53, 0xad, 0xd8, 0x43, 0x30, 0xe8, 0x1, 0x1f, 0x94, 0x83, 0xf8, 0x3a, 0x39, 0xf8, 0xd0, 0x6a, 0x50, 0x96, 0x1a, 0x7, 0x55, 0x7d, 0x4e, 0xd8, 0x3d, 0xbf, 0xd9, 0xe5, 0xcc, 0x43, 0x4f, 0xe, 0xaa, 0x70, 0xd6, 0x9d, 0xe7, 0xd0, 0x34, 0xe3, 0x59, 0xa4, 0x12, 0x86, 0x4d, 0x8b, 0xe2, 0x92, 0xf5, 0x88, 0xd6, 0x7, 0x29, 0x4a, 0x57, 0xcc, 0x3c, 0x50, 0x65, 0x78, 0x1e, 0x11, 0x14, 0x39, 0xa2, 0x3, 0x3d, 0xd6, 0x4b, 0x94, 0xb7, 0x15, 0x5a, 0xa5, 0x65, 0x36, 0x80, 0x45, 0x21, 0x4c, 0x58, 0x8d, 0x3e, 0xbe, 0x4, 0xa0, 0x4b, 0x7f, 0x7d, 0xf5, 0x63, 0xa, 0x46, 0xb, 0xbf, 0xbc, 0x39, 0xde, 0xdd, 0xe1, 0x4d, 0x59, 0xb, 0x2c, 0x79, 0x66, 0x45, 0x4, 0xef, 0x2, 0x7f, 0x4a, 0xc2, 0x27, 0x12, 0xf8, 0xee, 0x8b, 0x43, 0x99, 0xf0, 0x1a, 0x74, 0x18, 0xa8, 0xab, 0x9c, 0xdd, 0xc4, 0xda, 0x64, 0x9f, 0x52, 0x3, 0xa9, 0xca, 0x15, 0xeb, 0x75, 0x80, 0x59, 0xb9, 0x11, 0xb7, 0x43, 0x1e, 0xc0, 0x7a, 0xc5, 0x41, 0xd4, 0xd2, 0xac, 0xbb, 0x3d, 0x67, 0x83, 0x8f, 0x4b, 0xe5, 0x4a, 0x38, 0x77, 0x57, 0xf1, 0xd1, 0x9d, 0x9c, 0xdc, 0xd7, 0xca, 0x1e, 0x5e, 0x6e, 0xdd, 0x25, 0x4, 0x6b, 0xa1, 0x17, 0x84, 0x4d, 0x98, 0x15, 0x30, 0x8, 0x40, 0x1a, 0x83, 0x98, 0x9c, 0x67, 0x88, 0x27, 0x48, 0x52, 0x48, 0x8d, 0x9c, 0x3a, 0x90, 0xa3, 0xc0, 0x93, 0x6d, 0xc0, 0x90, 0x87, 0xa4, 0xdd, 0x6c, 0x8, 0xeb, 0x28, 0x13, 0xcc, 0xdb, 0x49, 0xf1, 0xea, 0x86, 0x80, 0xf6, 0x6d, 0x58, 0xb, 0x10, 0xeb, 0xb3, 0x9, 0x1, 0xc8, 0x32, 0xd8, 0x33, 0xce, 0xd1, 0x9b, 0x52, 0xb4, 0x19, 0xca, 0xcc, 0x1e, 0x1, 0xa6, 0x1d, 0x16, 0x91, 0x33, 0x96, 0xcb, 0xcb, 0xd3, 0x1e, 0xfa, 0xef, 0xcf, 0x1f, 0xda, 0x31, 0x7, 0x2a, 0xf0, 0x8c, 0x1f, 0x12, 0x13, 0x65, 0x8c, 0x4c, 0x6d, 0xd7, 0x64, 0xc, 0xea, 0x2c, 0x2c, 0x41, 0x11, 0xa4, 0xe2, 0xe3, 0x9b, 0x80, 0x6c, 0xdd, 0xdd, 0x6c, 0x60, 0x83, 0xce, 0x78, 0x76, 0xbd, 0x19, 0x64, 0x0, 0xba, 0x7, 0xfb, 0xb9, 0xf6, 0xbe, 0xb7, 0x65, 0x62, 0x81, 0xd9, 0x65, 0x3, 0x17, 0xd8, 0xf2, 0xed, 0xeb, 0x96, 0x2e, 0x62, 0xe3, 0x1f, 0xe7, 0x3d, 0x53, 0x75, 0x9a, 0x35, 0x7d, 0xa4, 0xb8, 0x57, 0x13, 0x37, 0xe3, 0xc7, 0x58, 0x8b, 0x99, 0x86, 0x28, 0xf5, 0x67, 0x90, 0x9c, 0xfb, 0xec, 0x3d, 0x6b, 0xd8, 0x18, 0x21, 0x4f, 0xc7, 0xf0, 0xfe, 0x72, 0x25, 0xe0, 0xf8, 0xab, 0x64, 0xbb, 0x4b, 0xd, 0x74, 0xaa, 0x79, 0xd9, 0x94, 0x5e, 0x56, 0x17, 0x7f, 0xe, 0x81, 0x79, 0x35, 0x52, 0xb5, 0xf2, 0xd7, 0x82, 0x89, 0x30, 0x9e, 0x13, 0x2d, 0x16, 0xfc, 0x74, 0x24, 0x15, 0x51, 0x95, 0xe1, 0xf5, 0xdb, 0x8c, 0xc3, 0x27, 0xb6, 0x50, 0xf2, 0xe3, 0xf1, 0xaf, 0x98, 0x7a, 0xf8, 0x41, 0x49, 0x5, 0x2f, 0x27, 0xa1, 0xda, 0x66, 0x25, 0x1b, 0x8, 0xa5, 0x62, 0xe8, 0xbe, 0x10, 0xe9, 0x2f, 0x97, 0x6c, 0xea, 0x41, 0xcd, 0xa5, 0x31, 0x70, 0x35, 0xdd, 0x78, 0xb3, 0x27, 0xd9, 0xfa, 0xaa, 0xb, 0x3c, 0x89, 0x7c, 0xe1, 0x10, 0x6b, 0x7, 0x46, 0x60, 0x6f, 0xc4, 0xb6, 0xac, 0x5f, 0x35, 0x8d, 0x2f, 0x2e, 0x10, 0xf7, 0x93, 0x8e, 0x5f, 0xef, 0x61, 0xe5, 0x40, 0x18, 0x1b, 0xdc, 0xed, 0x5a, 0x74, 0xd3, 0xae, 0xad, 0x42, 0x7, 0xe1, 0x83, 0x5, 0xa4, 0xee, 0x2e, 0x99, 0x94, 0x35, 0xa7, 0x59, 0x14, 0xf2, 0x12, 0x2, 0xfe, 0x3f, 0x39, 0xc3, 0x9e, 0x5f, 0xac, 0xe4, 0xe3, 0x91, 0x91, 0xb, 0x93, 0x7f, 0xb5, 0xab, 0xe0, 0x43, 0xd6, 0x33, 0x41, 0xe, 0x47, 0xf9, 0x9c, 0xde, 0x9d, 0xb8, 0x50, 0x15, 0xad, 0xcb, 0xdf, 0x48, 0xf4, 0x51, 0x90, 0x19, 0x3a, 0xcf, 0x6e, 0x62, 0x51, 0xe9, 0x9b, 0x65, 0xa5, 0x68, 0x68, 0xcd, 0x24, 0x8f, 0x69, 0x35, 0xaa, 0x9c, 0x67, 0x20, 0xc2, 0x97, 0x9f, 0xb5, 0xa5, 0xd5, 0x4b, 0x45, 0xfe, 0x84, 0xfc, 0xe1},
+               output224: []byte{0xe1, 0xcc, 0xc5, 0xe6, 0x57, 0x1c, 0x4, 0xc6, 0x76, 0xf7, 0x2, 0xb5, 0x2f, 0xf5, 0xc5, 0x2b, 0x2a, 0xa4, 0xff, 0x1b, 0x30, 0x76, 0x48, 0x2b, 0x99, 0x76, 0xc9, 0x55},
+               output256: []byte{0x26, 0xa, 0xfc, 0xf3, 0x8d, 0xed, 0xd0, 0xa2, 0x3c, 0x5f, 0x75, 0xb4, 0xf0, 0x44, 0xa6, 0x65, 0xfb, 0x64, 0x8b, 0xd7, 0x99, 0x7c, 0x28, 0xe2, 0xd4, 0xdc, 0x6e, 0x64, 0xee, 0x5e, 0x24, 0x20},
+               output384: []byte{0x53, 0xc1, 0x19, 0xf, 0x68, 0xf5, 0xad, 0xff, 0x7, 0xe0, 0x51, 0xc7, 0xbc, 0xa8, 0x96, 0x1c, 0x48, 0xe9, 0x76, 0x84, 0xb3, 0xa2, 0x9c, 0xf6, 0xa6, 0x8, 0x23, 0x23, 0x30, 0x0, 0x73, 0x67, 0xcf, 0xb4, 0xe3, 0x9d, 0xd9, 0x3, 0x98, 0xd9, 0x30, 0x3e, 0x1f, 0x85, 0xf5, 0x1d, 0x14, 0x66},
+               output512: []byte{0x7b, 0x4d, 0xff, 0x95, 0xfa, 0x73, 0x60, 0xe9, 0xec, 0xa6, 0x86, 0x29, 0x30, 0x3d, 0x9, 0x3f, 0x3c, 0xa9, 0x29, 0x44, 0xf9, 0x91, 0xb0, 0xa7, 0x19, 0xfc, 0xc3, 0x16, 0xf6, 0x57, 0xbb, 0xa3, 0xfa, 0xae, 0xf5, 0xd4, 0x35, 0x68, 0xeb, 0x88, 0x59, 0x1e, 0x86, 0x42, 0x7d, 0xef, 0x6b, 0xd7, 0xc8, 0x8f, 0xc7, 0xdb, 0x27, 0x11, 0x82, 0xee, 0x8c, 0x49, 0x5b, 0xdf, 0x4d, 0xec, 0x74, 0xe8}},
+       testcase{
+               msg:       []byte{0xca, 0xd9, 0xef, 0x7, 0x7a, 0x98, 0xe3, 0xf2, 0xe5, 0x70, 0x6e, 0xbe, 0xc4, 0x96, 0xd, 0x5a, 0x5b, 0x78, 0xb5, 0x7c, 0xc8, 0x1, 0x7d, 0xb1, 0x11, 0x2f, 0x2c, 0x53, 0x70, 0x76, 0x35, 0xc, 0x80, 0x7d, 0x5c, 0xb1, 0x42, 0x1c, 0x23, 0x5a, 0xd2, 0xf8, 0xab, 0xf7, 0xce, 0x90, 0x5c, 0x26, 0xb1, 0x85, 0x66, 0xd8, 0xfd, 0x6a, 0xf4, 0x49, 0x8, 0x26, 0x97, 0x85, 0xe7, 0x89, 0xca, 0xaf, 0xa1, 0x0, 0x2b, 0xea, 0x64, 0xed, 0x46, 0xb1, 0xab, 0xe2, 0xa8, 0x81, 0x2f, 0xfd, 0xf4, 0x0, 0xb1, 0x8a, 0x39, 0xb7, 0x31, 0x4, 0xa, 0x8c, 0x70, 0x3d, 0x83, 0x7e, 0x46, 0x3f, 0x29, 0xd4, 0x21, 0x8c, 0xc4, 0xac, 0xe, 0x38, 0x94, 0x5f, 0x5c, 0x79, 0x26, 0x3d, 0x2e, 0xa8, 0x6a, 0xe5, 0x28, 0x11, 0x72, 0x44, 0x24, 0x64, 0x4e, 0xe2, 0x74, 0xc5, 0x5f, 0xb6, 0xa0, 0x50, 0x78, 0x28, 0x7, 0xf3, 0xdf, 0x60, 0x54, 0x7b, 0xa0, 0x58, 0x46, 0x53, 0x72, 0xc8, 0xa6, 0x64, 0xe8, 0x33, 0xb5, 0x17, 0x6c, 0xed, 0x42, 0xc4, 0x1, 0x77, 0xcd, 0x34, 0x83, 0xe6, 0x36, 0xae, 0x6f, 0xb, 0x9c, 0x7a, 0xab, 0x5d, 0xde, 0x53, 0x9, 0xe5, 0xf3, 0x77, 0xaf, 0x74, 0x31, 0x46, 0x80, 0xa7, 0x2d, 0xc1, 0x8, 0x8a, 0xfb, 0x86, 0x1e, 0x6d, 0x56, 0x4d, 0xb6, 0xdb, 0x6e, 0x6d, 0x3e, 0x66, 0xda, 0x3f, 0x3d, 0x53, 0x96, 0x16, 0x40, 0x8d, 0x7b, 0x7, 0x27, 0xcd, 0xb9, 0x24, 0xbb, 0xa3, 0x8c, 0x3b, 0xd5, 0xeb, 0xb8, 0x23, 0xe7, 0xf4, 0x41, 0xd2, 0x56, 0x7f, 0xb3, 0x6d, 0x31, 0x31, 0x3c, 0x58, 0x34, 0x15, 0x4a, 0xbe, 0x16, 0x23, 0x72, 0x34, 0x49, 0xfa, 0x83, 0x24, 0xc8, 0x5a, 0x14, 0x9e, 0xd1, 0xeb, 0x86, 0x87, 0xbe, 0xe, 0x8a, 0x6c, 0x7, 0x52, 0x7b, 0xc0, 0xd9, 0x28, 0x26, 0x51, 0xcf, 0x36, 0xd5, 0x59, 0x6e, 0x1e, 0x7, 0x48, 0x91, 0x31, 0xac, 0x3c, 0x71, 0xb7, 0x55, 0x13, 0xac, 0x3a, 0xce, 0xe7, 0xcf, 0x90, 0x98, 0xd1, 0xd5, 0xc7, 0x10, 0xd3, 0x1a, 0x80, 0xb2, 0xa6, 0x3, 0x7b, 0x37, 0x22, 0x88, 0x10, 0xb8, 0x85, 0x16, 0xb, 0x76, 0x42, 0x23, 0xd4, 0xb0, 0x16, 0x48, 0xc, 0xc9, 0x83, 0x5a, 0x69, 0x5d, 0xec, 0x0, 0x13, 0xe9, 0xe0, 0x64, 0xc0, 0x83, 0x4b, 0x58, 0xc, 0x25, 0x4c, 0x6f, 0x4, 0x68, 0x9d, 0xf, 0xf8, 0xc, 0x69, 0x99, 0x88, 0x2c, 0xe2, 0xae, 0x5b, 0x4d, 0x8f, 0x1, 0xcd, 0xc5, 0xc2, 0x72, 0x88, 0x90, 0xc7, 0xc7, 0x95, 0xb1, 0xc, 0x5b, 0x7e, 0x1, 0xad, 0x20, 0x54, 0xe7, 0x50, 0x78, 0x3d, 0x4d, 0xaf, 0xa6, 0x77, 0xce, 0xf7, 0xca, 0x61, 0x41, 0xb0, 0xc5, 0xfc, 0x6e, 0x5f, 0xc3, 0x8b, 0xd, 0x1a, 0xe0, 0x88, 0xb1, 0x6a, 0x2, 0xc3, 0x1f, 0xfe, 0x24, 0x2a, 0xfa, 0x42, 0x64, 0xc2, 0x1d, 0x4a, 0xad, 0xee, 0x3f, 0xe6, 0xb3, 0xf4, 0x3a, 0xfd, 0x38, 0xfc, 0x55, 0x4b, 0xf1, 0x68, 0xc4, 0x33, 0x1a, 0x38, 0x85, 0x8, 0xad, 0xb6, 0x6a, 0x12, 0xb8, 0x5a, 0xf2, 0x5, 0xe6, 0xf2, 0xa6, 0x0, 0xc, 0x7f, 0x22, 0x2b, 0x5e, 0x3e, 0x32, 0x6a, 0xe9, 0xe5, 0x72, 0x95, 0x63, 0x30, 0x57, 0x5a, 0x7, 0x71, 0x3e, 0xe3, 0x2f, 0x42, 0x78, 0x78, 0xa6, 0x21, 0x46, 0x81, 0xb, 0x85, 0x48, 0x3f, 0x10, 0x36, 0x37, 0x22, 0x27, 0x9a, 0xf7, 0x12, 0x90, 0xe5, 0x8f, 0xd7, 0xda, 0x3c, 0x79, 0xc8, 0xfa, 0x3, 0x78, 0x64, 0x84, 0x23, 0xe1, 0x8f, 0x2b, 0xc4, 0x64, 0x9e, 0x8e, 0xba, 0xc7, 0xe2, 0x8a, 0xb3, 0xf8, 0xd1, 0xab, 0x64, 0x75, 0x7, 0x91, 0xfa, 0x91, 0x58, 0xb0, 0xc9, 0x26, 0x1b, 0x2d, 0xa1, 0xa8, 0x17, 0x4f, 0x50, 0x2, 0xaa, 0xfa, 0xca, 0x12, 0x2e, 0xb2, 0x85, 0x78, 0x51, 0xde, 0x26, 0x27, 0x8f, 0x59, 0x4b, 0x59, 0x64, 0x6b, 0x3b, 0x2f, 0x6b, 0x51, 0xa4, 0x1, 0x1d, 0xed, 0x61, 0x88, 0xee, 0x52, 0xd6, 0x43, 0x11, 0xdb, 0x7e, 0x50, 0xdd, 0x81, 0x97, 0xea, 0x1, 0x87, 0xef, 0x0, 0xf0, 0x41, 0x1d, 0x50, 0x1e, 0x5d, 0x1b, 0xe9, 0x46, 0xe3, 0x16, 0x3, 0x24, 0x27, 0x57, 0xb2, 0x8f, 0x3d, 0x5, 0xcf, 0x17, 0x44, 0xd6, 0x2c, 0xed, 0x24, 0x36, 0x65, 0x66, 0xdd, 0x16, 0xa3, 0xf8, 0xf3, 0xdd, 0x4d, 0x52, 0xd7, 0xfc, 0x89, 0x1a, 0x31, 0xe8, 0x3e, 0xe8, 0x3, 0x8d, 0xd7, 0x8a, 0xfe, 0xa8, 0x4e, 0xc8, 0x89, 0x69, 0x58, 0x39, 0x7a, 0xa7, 0xab, 0xa0, 0x5, 0x6d, 0xb3, 0xb1, 0x6a, 0x4, 0xa2, 0x2, 0x3a, 0xf6, 0x7a, 0x19, 0x48, 0xdc, 0xba, 0xd4, 0xa0, 0xa5, 0x37, 0x64, 0x75, 0xa3, 0x20, 0x37, 0x11, 0x94, 0x91, 0x9c, 0x93, 0x9f, 0x4e, 0x63, 0x97, 0x1b, 0xca, 0xdd, 0xc3, 0x44, 0x79, 0x9a, 0xaa, 0x15, 0x14, 0x34, 0xd2, 0xa5, 0xc4, 0x2, 0xd0, 0x2d, 0x4c, 0xcc, 0x29, 0xec, 0xb1, 0xbc, 0x40, 0xb2, 0x97, 0xd9, 0xbf, 0x72, 0xaa, 0x9, 0xca, 0x9d, 0xd2, 0xcc, 0x52, 0x68, 0xf2, 0xc3, 0xf4, 0x9e, 0x10, 0xfb, 0xe4, 0x73, 0x3e, 0xe8, 0x36, 0x47, 0xb9, 0xef, 0xc1, 0xf5, 0x9b, 0xb9, 0xf7, 0xd8, 0xe2, 0xbd, 0xdf, 0xce, 0x71, 0x7c, 0xb1, 0xaf, 0xe7, 0xdf, 0x9f, 0xfe, 0x8b, 0x4a, 0x7b, 0xc7, 0x93, 0x71, 0xb7, 0x4f, 0x1a, 0x3, 0x8c, 0x9c, 0x4f, 0xb8, 0xb7, 0xb1, 0xee, 0xfd, 0x38, 0x98, 0x8b, 0xd5, 0x91, 0xdd, 0x28, 0x17, 0xe1, 0x9e, 0x9d, 0x6c, 0x52, 0xb5, 0x22, 0xe9, 0xd, 0xcd, 0x89, 0xc7, 0xd, 0x3e, 0xed, 0x91, 0xb1, 0x28, 0x6c, 0x38, 0x91, 0xd5, 0x46, 0xf4, 0xe1, 0x98, 0xbf, 0xb3, 0x85, 0x55, 0x4e, 0x88, 0x2a, 0xde, 0x7, 0xaa, 0xaa, 0x45, 0x59, 0xad, 0x51, 0x7c, 0x5c, 0xd7, 0xce, 0xa7, 0xcc, 0x65, 0x9b, 0xea, 0xf8, 0x21, 0x47, 0x16, 0xed, 0x9d, 0x75, 0xd, 0x38, 0x23, 0x89, 0xee, 0x8a, 0xb7, 0xc3, 0xc8, 0xaa, 0xc4, 0x89, 0x68, 0x22, 0x0, 0x27, 0xed, 0xe8, 0x5f, 0x93, 0x90, 0x98, 0xfd, 0x67, 0x9d, 0x97, 0x86, 0x59, 0x26, 0xf1, 0x20, 0xd8, 0xa9, 0xa3, 0x60, 0x42, 0x9c, 0xf0, 0xa, 0x7c, 0x1d, 0xef, 0x83, 0x6a, 0x99, 0x33, 0x65, 0x5a, 0xbc, 0xb3, 0x84, 0xe9, 0xf6, 0x30, 0xb4, 0x16, 0x3f, 0x20, 0x42, 0x38, 0xe9, 0xa3, 0x8e, 0xd9, 0x49, 0xaf, 0x36, 0xf5, 0x20, 0x4b, 0x74, 0xdc, 0xc4, 0x52, 0x66, 0xf8, 0x9a, 0xf9, 0xe, 0x6d, 0xb2, 0xc9, 0x48, 0xe7, 0xd7, 0x73, 0xd7, 0x2e, 0x65, 0x3d, 0x35, 0xc8, 0x48, 0xc7, 0x79, 0x36, 0xe6, 0xe6, 0x89, 0xf7, 0x5d, 0xd7, 0x8e, 0xc2, 0x75, 0x4e, 0x2, 0xfb, 0xe1, 0x19, 0xc5, 0x72, 0x88, 0x5b, 0xf0, 0x90, 0xb0, 0x4a, 0x43, 0x90, 0xbc, 0x7d, 0x59, 0x83, 0x80, 0x9e, 0x5a, 0xc7, 0xe4, 0xa1, 0x6f, 0x6a, 0xd0, 0x23, 0xc8, 0xb2, 0x8e, 0x6b, 0x1, 0x59, 0x1b, 0xf, 0xab, 0x80, 0xdf, 0xf9, 0xe1, 0x30, 0xd, 0xe1, 0x1b, 0xe3, 0x16, 0x8b, 0xa2, 0xf1, 0x69, 0x1e, 0x6c, 0xb7, 0xc4, 0x16, 0xc3, 0x20, 0x1f, 0xae, 0x3f, 0x17, 0x19, 0x75, 0xba, 0xcd, 0xff, 0xa5, 0x20, 0x57, 0x1f, 0x51, 0x8f, 0xd8, 0x47, 0x75, 0x53, 0xbe, 0x92, 0x53, 0x9a, 0xe, 0xcc, 0x5f, 0xfc, 0x16, 0x10, 0x43, 0x13, 0x9c, 0xbf, 0xa3, 0x56, 0x73, 0xf7, 0x19, 0x49, 0xff, 0xbd, 0xa6, 0x46, 0x93, 0xa0, 0x32, 0xcd, 0xe6, 0xa3, 0x44, 0x32, 0xcc, 0x77, 0x36, 0xf1, 0x85, 0x6b, 0x4d, 0xaf, 0x68, 0xd3, 0x93, 0x69, 0x32, 0x77, 0x44, 0x35, 0x5a, 0xfb, 0x6a, 0x4e, 0x89, 0xb8, 0x2e, 0x5b, 0xbb, 0x1d, 0x53, 0xb5, 0xec, 0xd1, 0xeb, 0xbc, 0xa2, 0x5f, 0x6b, 0x51, 0xf1, 0xb0, 0x7, 0x6c, 0x34, 0x6, 0x86, 0x76, 0xb2, 0xb8, 0x79, 0xc1, 0x3f, 0x64, 0xd9, 0x1b, 0x27, 0x7f, 0xc8, 0x2e, 0xad, 0x74, 0x20, 0xf2, 0x49, 0x7b, 0x86, 0xc9, 0xfe, 0xb5, 0x34, 0x1a, 0xa5, 0x53, 0xc7, 0x91, 0x6e, 0xbe, 0x66, 0x20, 0xde, 0x18, 0xeb, 0xa7, 0xf4, 0x53, 0x88, 0x3a, 0x6e, 0x8a, 0x3, 0x7c, 0x31, 0x4e, 0xc1, 0x59, 0x86, 0x91, 0x32, 0xe1, 0x85, 0x69, 0x43, 0xca, 0x6d, 0xa2, 0x41, 0x18, 0x30, 0xd6, 0xaf, 0x83, 0x54, 0x34, 0x6a, 0xcb, 0x6, 0x57, 0x8c, 0xe8, 0x9e, 0x27, 0x7e, 0x26, 0x19, 0x59, 0x63, 0x30, 0x47, 0x6e, 0xe1, 0xb8, 0xa1, 0xec, 0xd2, 0x8e, 0x20, 0x1c, 0x6, 0x5b, 0xc3, 0xe, 0xce, 0x1f, 0xee, 0xe5, 0xe7, 0xae, 0x18, 0x2e, 0xfa, 0x8d, 0x3, 0x10, 0xeb, 0x73, 0x1c, 0x30, 0xca, 0x71, 0x84, 0xd6, 0xe9, 0xf3, 0xc9, 0xcf, 0x8, 0xef, 0x2b, 0x2e, 0x63, 0xcc, 0xb3, 0x69, 0xa3, 0x6a, 0xd6, 0x32, 0x7, 0xdd, 0xe3, 0xcc, 0xb0, 0x4d, 0xe3, 0x41, 0xb5, 0xd0, 0x93, 0xa0, 0xa1, 0x40, 0xaa, 0xa, 0x8d, 0xbe, 0x81, 0x1f, 0x3, 0x11, 0x4b, 0x23, 0x5f, 0x7, 0x49, 0x9e, 0x62, 0x2e, 0xbe, 0xc3, 0x95, 0x21, 0xfa, 0xc6, 0x71, 0x18, 0x3f, 0x7, 0x98, 0xac, 0x50, 0x91, 0x9d, 0x26, 0x9, 0x41, 0x41, 0x58, 0x32, 0xb1, 0xc5, 0x68, 0x6d, 0x7c, 0x27, 0xa7, 0xa5, 0xd0, 0xe6, 0x22, 0x2a, 0x99, 0x1e, 0x34, 0x1c, 0x9a, 0x8b, 0x10, 0xa7, 0x6e, 0x1, 0xe7, 0x9b, 0x1e, 0x7a, 0xc, 0x18, 0x22, 0x7a, 0x39, 0x7, 0x9d, 0x50, 0xf5, 0xee, 0x94, 0xb1, 0x8b, 0x62, 0xc5, 0x1a, 0xc3, 0x66, 0x50, 0xed, 0x3a, 0xdf, 0xe1, 0x42, 0xba, 0x5a, 0x34, 0xa8, 0x39, 0x44, 0x95, 0x99, 0x35, 0x5d, 0x4a, 0xc9, 0x54, 0x2b, 0x14, 0x61, 0x56, 0xbe, 0x4f, 0xc4, 0xdb, 0xfd, 0xd1, 0xc, 0xb8, 0xdd, 0x15, 0xd0, 0xc5, 0x1a, 0xb2, 0x3a, 0xb1, 0x9c, 0x16, 0x50, 0xf, 0x77, 0x6, 0x93, 0xc9, 0x4e, 0xf6, 0x1d, 0xf2, 0x6d, 0xa4, 0x3a, 0x9, 0xb0, 0xd, 0x4e, 0xb7, 0x20, 0x6e, 0x93, 0x25, 0xcd, 0x66, 0x78, 0xa, 0xb4, 0x7a, 0x7e, 0x95, 0xb5, 0xd, 0xf4, 0x23, 0xc4, 0x7, 0x67, 0x22, 0x9d, 0xf1, 0xdd, 0x41, 0xa8, 0x8, 0xfa, 0x70, 0xda, 0x64, 0x77, 0x1f, 0xb9, 0x1b, 0x5f, 0x6f, 0x76, 0x87, 0x27, 0x59, 0xa8, 0xcb, 0x77, 0xfd, 0xa8, 0x7e, 0x2f, 0x2d, 0x7f, 0x3, 0xb, 0x9c, 0xdb, 0x45, 0x60, 0x5, 0xdb, 0x9a, 0x88, 0xd0, 0xf2, 0x7d, 0x47, 0x96, 0x80, 0x3b, 0xd5, 0x70, 0x44, 0xf, 0xd0, 0xb7, 0xe9, 0x9c, 0x3d, 0x8, 0xfd, 0x8e, 0x60, 0x3c, 0x92, 0x9, 0x8a, 0xa4, 0x15, 0xd, 0x5a, 0x87, 0xc2, 0x91, 0x7c, 0xd7, 0x50, 0xbf, 0x0, 0x77, 0xe9, 0xd7, 0x1c, 0x43, 0xf5, 0xbd, 0x3d, 0xab, 0x91, 0x9c, 0x23, 0xe1, 0x6b, 0xb9, 0x5, 0x37, 0xe7, 0xfe, 0x69, 0x4a, 0x84, 0x7e, 0xe8, 0x43, 0xdf, 0x4c, 0x82, 0x62, 0xd4, 0x4c, 0x39, 0xbc, 0xe4, 0xd9, 0xc4, 0x90, 0x69, 0xb2, 0x13, 0xf1, 0x7, 0x44, 0x53, 0xec, 0x66, 0xea, 0x5, 0x48, 0x33, 0xfb, 0xdb, 0x72, 0xb8, 0x11, 0x61, 0xdb, 0xa4, 0x24, 0x39, 0x4, 0x13, 0xdb, 0xcf, 0x96, 0xcb, 0xd5, 0x6a, 0x35, 0xfc, 0xe6, 0x51, 0xd, 0xdc, 0x2b, 0xd9, 0x29, 0x6f, 0x7c, 0xd2, 0xf7, 0x47, 0x4f, 0x86, 0xfe, 0x24, 0xcd, 0x61, 0xc9, 0x66, 0x5c, 0xee, 0x25, 0x14, 0x20, 0xc0, 0xa0, 0xd1, 0xf5, 0x6f, 0x9f, 0xb0, 0x6c, 0x83, 0xff, 0xdf, 0xcf, 0x3, 0x4a, 0x5c, 0x27, 0xb8, 0xc6, 0x89, 0x35, 0xc4, 0xb2, 0xab, 0xd2, 0xfb, 0x92, 0xd5, 0x70, 0xf1, 0xfb, 0x61, 0xb, 0x3f, 0xf4, 0xf6, 0x6a, 0x31, 0x10, 0xa7, 0xa0, 0xb8, 0x9c, 0x7, 0x19, 0x1b, 0xd5, 0x92, 0x8a, 0x39, 0xd5, 0x79, 0x19, 0x16, 0x33, 0xb9, 0x6f, 0x11, 0x23, 0xe5, 0x53, 0x59, 0x53, 0xf0, 0xd2, 0x5d, 0x28, 0x67, 0x5f, 0x5d, 0xde, 0xe3, 0x1f, 0xf2, 0xb6, 0xe1, 0x3f, 0xf2, 0x1a, 0x2d, 0xb1, 0x99, 0xf, 0x4e, 0xa8, 0xd0, 0xab, 0x5d, 0x4a, 0x73, 0xaf, 0x9a, 0x41, 0xd5, 0xff, 0x8b, 0x14, 0x67, 0xa1, 0x1c, 0xd2, 0x97, 0xec, 0x41, 0x6f, 0x44, 0x8c, 0x5b, 0xd, 0x77, 0xdf, 0x8d, 0x2, 0xe6, 0x88, 0xa, 0x7d, 0xca, 0x28, 0x30, 0x54, 0xbe, 0xaf, 0x1f, 0xb9, 0x86, 0xac, 0xbf, 0x83, 0x8b, 0x68, 0xa3, 0x2c, 0x6a, 0x4d, 0xfd, 0x9, 0x7c, 0x9f, 0xc9, 0x98, 0xfa, 0x13, 0xe3, 0x82, 0x39, 0x96, 0x77, 0xcc, 0x94, 0x7a, 0xf6, 0xe4, 0xca, 0x5b, 0x37, 0xbd, 0xbd, 0xe3, 0x94, 0xb8, 0x95, 0x82, 0xc0, 0x4b, 0xd0, 0x5d, 0xc7, 0xc0, 0x40, 0x38, 0xc6, 0x26, 0xc5, 0xb7, 0x27, 0x88, 0x18, 0x9f, 0xc0, 0x17, 0x99, 0xa4, 0xca, 0x3, 0xa1, 0xe6, 0x5c, 0x74, 0x4f, 0x6c, 0x48, 0x93, 0xb1, 0x9d, 0x27, 0x49, 0x70, 0x9b, 0x23, 0xaf, 0x92, 0x59, 0x20, 0x44, 0x22, 0x4a, 0xba, 0x18, 0xe1, 0x5, 0x28, 0x20, 0x25, 0xd, 0xc, 0x35, 0xcf, 0x8d, 0x76, 0xe5, 0x1c, 0x73, 0xc9, 0x43, 0x86, 0xc6, 0xe0, 0xf1, 0x47, 0xc7, 0x70, 0xec, 0x37, 0x99, 0x76, 0xb5, 0x74, 0xef, 0x2e, 0xc6, 0xd6, 0x8c, 0x39, 0xff, 0x2c, 0x28, 0x7f, 0xe5, 0x14, 0x9f, 0x71, 0x49, 0x7e, 0x1a, 0xbf, 0x7, 0x17, 0x6b, 0x2, 0x4e, 0x40, 0x84, 0x79, 0xbb, 0x7b, 0x56, 0xb3, 0x73, 0x36, 0x7d, 0x40, 0xa5, 0xbd, 0x8, 0xaa, 0x38, 0xbc, 0xfc, 0xcc, 0x70, 0x55, 0x31, 0xd2, 0x98, 0x4c, 0xd3, 0x86, 0xf0, 0xf4, 0x7f, 0x8, 0x64, 0xe0, 0xd, 0x75, 0x8e, 0xec, 0x1b, 0xa0, 0xed, 0x9, 0x71, 0xa0, 0xa2, 0xa8, 0x4e, 0xec, 0x66, 0x3f, 0x19, 0x83, 0x26, 0xaa, 0x62, 0xf9, 0x31, 0xda, 0xab, 0xe3, 0x81, 0xde, 0xa6, 0x92, 0xa7, 0xc4, 0x34, 0x25, 0xd5, 0x4a, 0xcd, 0x99, 0xe2, 0xff, 0x5b, 0x74, 0x64, 0xf5, 0xbb, 0x79, 0x4d, 0x20, 0x9, 0x3, 0x5c, 0xa9, 0xff, 0x72, 0x1b, 0x1b, 0x44, 0x94, 0xcd, 0x8c, 0xc5, 0xcc, 0xa9, 0x95, 0x76, 0x60, 0xf2, 0x9b, 0x77, 0xdd, 0xf1, 0x73, 0xd7, 0x8a, 0xc5, 0x6b, 0x36, 0xaa, 0xc5, 0xe2, 0x83, 0x74, 0xc3, 0x82, 0x53, 0xb2, 0x2e, 0x16, 0xbd, 0xb9, 0x3e, 0x4c, 0xbd, 0xf9, 0xf0, 0xe8, 0x54, 0xea, 0x1d, 0x79, 0x98, 0x3f, 0x8f, 0x9c, 0xf6, 0xd2, 0x5d, 0xda, 0xa7, 0x64, 0x80, 0x55, 0x35, 0x4a, 0x8c, 0xea, 0x37, 0x2b, 0xa5, 0x4e, 0xef, 0xca, 0x4c, 0xd0, 0x40, 0xd3, 0xea, 0xdd, 0x23, 0xb8, 0x9a, 0xb6, 0x4c, 0x54, 0x5b, 0x74, 0x62, 0xd2, 0xd6, 0xd2, 0xd2, 0x49, 0xa9, 0x19, 0x70, 0x3b, 0xcc, 0xbe, 0xa4, 0x71, 0x25, 0x1d, 0x36, 0xa1, 0xa2, 0x7b, 0xf0, 0xfd, 0x65, 0x3f, 0x5f, 0x1d, 0x84, 0x90, 0x58, 0x6d, 0x95, 0x68, 0xaa, 0xb1, 0x41, 0x38, 0x3b, 0x18, 0x66, 0x30, 0xa2, 0x70, 0xbc, 0x7d, 0x2a, 0x8a, 0x29, 0x9b, 0x4c, 0x90, 0xbb, 0x22, 0xfd, 0xf0, 0x8c, 0x30, 0xb2, 0x74, 0x5d, 0xbe, 0x6d, 0x6a, 0xe7, 0xde, 0xc9, 0xbf, 0xd1, 0x12, 0xf5, 0x61, 0x1a, 0x83, 0xf9, 0xde, 0xff, 0x40, 0x83, 0x46, 0xdd, 0x62, 0xf7, 0x5d, 0xe0, 0x5, 0x50, 0xf6, 0xe5, 0x6b, 0x3f, 0x9f, 0x9b, 0x80, 0xd7, 0x2, 0x7a, 0xc, 0x7b, 0xf6, 0x30, 0x6a, 0xca, 0x15, 0x99, 0x72, 0xf2, 0xae, 0x43, 0x34, 0x69, 0x85, 0xa4, 0x60, 0x1b, 0x48, 0x17, 0x22, 0xea, 0xbf, 0x37, 0x86, 0x69, 0x6f, 0x96, 0x23, 0xe1, 0x36, 0x6f, 0x93, 0xdc, 0x58, 0x57, 0x58, 0xfe, 0x8f, 0x24, 0x5e, 0x82, 0x21, 0x1e, 0xf9, 0x84, 0xbd, 0x31, 0xdc, 0xc9, 0xfc, 0x7d, 0x7c, 0xec, 0xd0, 0x99, 0xda, 0xc9, 0xe4, 0x5c, 0xbe, 0x65, 0x5d, 0xac, 0xd6, 0x87, 0xa8, 0x48, 0xf5, 0x33, 0x53, 0xd7, 0xbc, 0x1d, 0x68, 0x10, 0x3d, 0x4c, 0x8c, 0x74, 0xc, 0x91, 0xb6, 0x95, 0x17, 0xb1, 0x64, 0xf4, 0x7e, 0xd7, 0x18, 0xe5, 0x26, 0x87, 0x75, 0x7a, 0x51, 0xf0, 0x86, 0xa4, 0xdd, 0xef, 0x8e, 0xa4, 0xc8, 0x58, 0x58, 0xd, 0x6e, 0xb8, 0x6, 0x4a, 0x4, 0x45, 0x34, 0xe2, 0x77, 0xa7, 0xdd, 0x59, 0x75, 0xaf, 0x13, 0xef, 0x5c, 0x43, 0x6, 0x6e, 0xa2, 0x69, 0x2, 0xe7, 0xa3, 0x6d, 0xf3, 0x95, 0xf2, 0x49, 0x5e, 0xd4, 0x31, 0x1c, 0x37, 0x36, 0xe9, 0x14, 0x50, 0x65, 0x8, 0x43, 0xa1, 0x82, 0x8f, 0xee, 0xb4, 0x2e, 0x6b, 0xd5, 0xa0, 0x5d, 0xf, 0xe4, 0xaf, 0x8d, 0x7a, 0x54, 0x34, 0x63, 0x3, 0x8b, 0xcc, 0x3d, 0x31, 0xa5, 0x89, 0x10, 0x80, 0x38, 0xdc, 0xff, 0xc8, 0xc7, 0xa3, 0xcb, 0x86, 0xc5, 0x7c, 0xed, 0x3a, 0x1e, 0x3e, 0x22, 0x35, 0x7c, 0xba, 0xca, 0x32, 0x8e, 0xbe, 0x1d, 0xbd, 0x16, 0xc1, 0xb8, 0x82, 0xfb, 0x0, 0x9a, 0x69, 0x7c, 0x1e, 0xfe, 0xb3, 0xef, 0xca, 0x0, 0x77, 0x53, 0xdd, 0xc5, 0x1f, 0x6e, 0x7d, 0xa8, 0x90, 0xb, 0x3a, 0x37, 0x31, 0x2e, 0xbb, 0xf4, 0x1c, 0xa, 0x7e, 0xcf, 0x23, 0xc3, 0x92, 0x13, 0xfc, 0x8a, 0x23, 0xc2, 0xc5, 0xee, 0x6d, 0x78, 0x3a, 0x1b, 0x65, 0x20, 0xb0, 0x7f, 0xf7, 0x47, 0xa1, 0x43, 0xf6, 0xa8, 0xdc, 0x51, 0x22, 0x9, 0xc3, 0x7a, 0xdb, 0xed, 0x27, 0x6d, 0xe1, 0x3c, 0x5c, 0xa2, 0x7f, 0xf7, 0xa5, 0x95, 0x54, 0x5c, 0x2, 0x4b, 0x11, 0xf5, 0xee, 0xfe, 0xdc, 0xbf, 0x61, 0xd9, 0x2e, 0xc0, 0xa1, 0x7, 0xbd, 0x1c, 0xa0, 0x9, 0x34, 0x61, 0x89, 0x27, 0xda, 0x45, 0xc, 0x94, 0xf, 0x6d, 0xab, 0x1c, 0x18, 0xb, 0x29, 0xe7, 0x2c, 0xe, 0x87, 0x9, 0x62, 0x7e, 0x51, 0xe9, 0x16, 0x32, 0xc3, 0x64, 0xfe, 0x45, 0xfb, 0xda, 0xe4, 0x3a, 0xb8, 0x76, 0xd3, 0x30, 0x0, 0xfb, 0x1a, 0xb4, 0x37, 0xd4, 0x99, 0xb3, 0x32, 0x50, 0xd7, 0x5a, 0x1d, 0x23, 0x19, 0x2a, 0x55, 0xf8, 0x13, 0x85, 0x9c, 0xb6, 0x93, 0x77, 0x3d, 0xdd, 0xe6, 0x16, 0xe5, 0x57, 0xe, 0x75, 0x31, 0x28, 0x57, 0x2b, 0xc1, 0x19, 0xa4, 0x69, 0x51, 0xc8, 0x6f, 0x99, 0xb3, 0xf9, 0x31, 0x41, 0x6c, 0x3, 0x47, 0xd9, 0x5d, 0x5a, 0x6b, 0xe5, 0x2, 0xc3, 0xc8, 0xf6, 0x96, 0xee, 0x2, 0x6c, 0x3e, 0x66, 0xe4, 0xf0, 0xa3, 0x84, 0x7a, 0xa4, 0x98, 0x15, 0xcf, 0x40, 0xc9, 0x2, 0xba, 0x79, 0xec, 0x7c, 0x4e, 0x3d, 0x82, 0xee, 0x14, 0xc, 0x8c, 0x9, 0xf7, 0x3e, 0xba, 0xac, 0xb, 0x5c, 0xa1, 0x17, 0x23, 0xb0, 0x87, 0x93, 0xfe, 0x17, 0xdf, 0xf3, 0xef, 0xca, 0xc0, 0xc5, 0x76, 0xd8, 0xf5, 0xd9, 0x69, 0x9b, 0x74, 0x18, 0x61, 0xe6, 0xe2, 0xe9, 0x77, 0xa},
+               output224: []byte{0xfd, 0x1, 0xd3, 0x42, 0xd2, 0x1, 0xaf, 0x1, 0x2a, 0xd2, 0xc, 0xd5, 0x86, 0x30, 0xdf, 0x41, 0x12, 0xec, 0xcf, 0xe4, 0xcf, 0x2e, 0x87, 0x26, 0x28, 0xd9, 0xfb, 0x80},
+               output256: []byte{0xa0, 0x20, 0xf8, 0xf6, 0x46, 0x48, 0x53, 0xc4, 0x64, 0x91, 0xd1, 0x7d, 0xe7, 0x6e, 0xd9, 0x81, 0x57, 0xe, 0x18, 0x20, 0x57, 0xea, 0x64, 0xbf, 0xc4, 0xc9, 0x88, 0xae, 0x58, 0x1b, 0xb8, 0x9e},
+               output384: []byte{0xad, 0x99, 0xc9, 0x7f, 0xc, 0xa5, 0xa5, 0x68, 0xf, 0x2a, 0x89, 0x5f, 0xf7, 0x9e, 0xa0, 0x9a, 0x42, 0x20, 0xdc, 0x74, 0x28, 0xdd, 0x5e, 0x78, 0x8, 0x1b, 0xc5, 0x4c, 0x7a, 0x49, 0xa4, 0xde, 0x4f, 0x1, 0x83, 0x61, 0x3, 0x88, 0x28, 0x7e, 0xa0, 0xde, 0x88, 0xa, 0xc6, 0xea, 0xbe, 0xfa},
+               output512: []byte{0xf2, 0x9c, 0x92, 0xba, 0x7a, 0xe0, 0x87, 0xbf, 0x53, 0x51, 0x26, 0xed, 0x9c, 0xe3, 0x18, 0x58, 0xbb, 0xf5, 0xcc, 0x7, 0xf7, 0x38, 0xfa, 0x68, 0x62, 0x91, 0xaf, 0x9c, 0xb4, 0x76, 0x39, 0xc7, 0xf5, 0xd, 0x6e, 0xa5, 0xa2, 0x11, 0xfd, 0xbd, 0xa7, 0x3d, 0xd9, 0x9f, 0xea, 0x7a, 0xdf, 0x79, 0xa8, 0xbd, 0xfb, 0xbb, 0x5b, 0x47, 0xe3, 0x4, 0x59, 0x37, 0xfa, 0xda, 0xfa, 0x55, 0x3b, 0x36}},
+       testcase{
+               msg:       []byte{0x19, 0x26, 0x32, 0xfd, 0xde, 0x8f, 0x5d, 0x5c, 0x75, 0xb3, 0x1a, 0x51, 0xa9, 0x41, 0xb6, 0x9d, 0x80, 0xe5, 0xb6, 0xa5, 0xa0, 0x5f, 0xcb, 0xeb, 0xd9, 0xb8, 0xbe, 0x91, 0x2e, 0xbe, 0xde, 0x89, 0x35, 0xcd, 0x45, 0xc6, 0x3a, 0xaa, 0xcb, 0x84, 0x5e, 0x84, 0x33, 0xc6, 0xc3, 0xa2, 0xb4, 0xa2, 0xa0, 0x82, 0x20, 0x1, 0x1, 0x86, 0x11, 0xce, 0x54, 0xe8, 0xb1, 0x4, 0x5d, 0xd, 0x4a, 0xb4, 0x5f, 0xe0, 0x87, 0x14, 0x75, 0x4f, 0xc6, 0xb8, 0xc7, 0x10, 0x4, 0x33, 0x5f, 0x36, 0x15, 0x53, 0x4e, 0xfa, 0xc, 0x19, 0xee, 0xb0, 0x6d, 0xea, 0x36, 0x12, 0xda, 0xe6, 0x7f, 0x40, 0xd2, 0xee, 0x6a, 0xfd, 0xfb, 0x11, 0x9e, 0x1d, 0x87, 0xf2, 0x34, 0xf3, 0x80, 0xb8, 0xd7, 0xe2, 0xf4, 0x4f, 0x5c, 0xf2, 0x8f, 0xae, 0x69, 0x98, 0xec, 0x8d, 0xd6, 0x38, 0x10, 0x33, 0xad, 0x37, 0x9, 0xea, 0xea, 0xd1, 0xeb, 0xc3, 0xa5, 0x1a, 0x3b, 0xb5, 0x34, 0xdd, 0xfc, 0x16, 0x97, 0xbc, 0x49, 0xd9, 0xd9, 0xf0, 0xc2, 0xe0, 0x6e, 0xda, 0xc9, 0xb6, 0x6c, 0x49, 0x25, 0x0, 0xbd, 0x80, 0xc2, 0x5c, 0x38, 0x3c, 0x2b, 0xcc, 0x8, 0x2e, 0xb6, 0xe6, 0xda, 0x4f, 0x1c, 0x2c, 0x41, 0x49, 0xcd, 0x3b, 0xf8, 0x49, 0x57, 0xb8, 0x36, 0x12, 0xb3, 0x35, 0x1d, 0x27, 0x7, 0x54, 0x9, 0x5, 0x2, 0x4, 0x4e, 0x2e, 0x81, 0xd8, 0x23, 0x64, 0x12, 0xa6, 0x90, 0x5f, 0x96, 0x52, 0x8c, 0xb0, 0xc4, 0x37, 0x60, 0xc3, 0x28, 0x9, 0x52, 0x7a, 0x85, 0x72, 0x9a, 0x3c, 0x3b, 0x15, 0x1f, 0xe, 0xdf, 0x53, 0x73, 0x3, 0x68, 0xb6, 0xe8, 0x44, 0xe1, 0xe0, 0x95, 0x24, 0xcd, 0xa2, 0x22, 0xe7, 0x28, 0x4d, 0xdc, 0xf3, 0x7e, 0x1, 0xe4, 0xb6, 0xae, 0x1f, 0xb4, 0x22, 0x90, 0x71, 0x36, 0x43, 0x44, 0x6, 0x5, 0x9e, 0x69, 0xc8, 0xdb, 0x71, 0xa4, 0x3c, 0x50, 0x7c, 0x72, 0x56, 0x7e, 0x66, 0xd5, 0xed, 0x6f, 0x17, 0xab, 0x75, 0x7c, 0xc1, 0xf5, 0xbd, 0x57, 0xf2, 0x46, 0xa3, 0x8, 0xe5, 0xa9, 0x35, 0x10, 0xad, 0x80, 0xa5, 0x65, 0x75, 0x12, 0x74, 0xff, 0xaa, 0x46, 0x79, 0xb1, 0x31, 0x34, 0x32, 0x23, 0xee, 0xfa, 0xca, 0xeb, 0xdb, 0x52, 0x3b, 0xd3, 0xed, 0x31, 0x3a, 0xa2, 0x8, 0x99, 0xff, 0x15, 0xcc, 0xa0, 0xe7, 0x8, 0xf3, 0x62, 0x20, 0x54, 0x98, 0x1b, 0xb5, 0x67, 0x0, 0x1, 0x91, 0x80, 0x7e, 0xd9, 0xdc, 0x2f, 0xfe, 0xb7, 0x92, 0x8d, 0xf8, 0x68, 0xdf, 0x13, 0xa4, 0xcd, 0xfb, 0x8e, 0x90, 0x9f, 0xde, 0x78, 0x67, 0x99, 0x9d, 0xa2, 0x48, 0xe5, 0xbd, 0xd3, 0x61, 0xb3, 0xc1, 0x2, 0x2c, 0xfc, 0x46, 0xfd, 0xe1, 0xdf, 0xec, 0x94, 0xe9, 0x6d, 0x60, 0x97, 0x23, 0xe3, 0xc7, 0xf4, 0xd2, 0x3a, 0x8c, 0x47, 0x7b, 0x31, 0x96, 0x50, 0xc9, 0x97, 0xee, 0x7a, 0x20, 0x60, 0x88, 0xa5, 0xcb, 0x95, 0x9d, 0x8b, 0x27, 0x99, 0xca, 0x59, 0x7b, 0x11, 0x93, 0xe4, 0x3a, 0x75, 0x67, 0x23, 0x95, 0xb8, 0xc2, 0x5, 0xe3, 0xca, 0x17, 0x7d, 0xf6, 0x97, 0x6e, 0x9f, 0x87, 0x85, 0x3a, 0x18, 0x9f, 0x33, 0xf7, 0x66, 0xa4, 0x52, 0xf1, 0x11, 0xe9, 0x9a, 0x3f, 0xb2, 0x6b, 0xc1, 0xe3, 0xe5, 0x78, 0x69, 0x90, 0x63, 0x3f, 0x9c, 0x86, 0x95, 0x18, 0x8b, 0xc3, 0xf8, 0xc8, 0x54, 0x51, 0x72, 0xfc, 0x64, 0xe4, 0xa9, 0x89, 0x65, 0x37, 0xb4, 0x4f, 0x13, 0xd6, 0x3e, 0x56, 0x20, 0xc3, 0x12, 0x9e, 0xc9, 0x5c, 0xd9, 0x4d, 0x4e, 0x26, 0x7c, 0xa7, 0xfa, 0xd4, 0xf4, 0x23, 0x34, 0xe3, 0xa6, 0x57, 0xc7, 0x42, 0xe7, 0xee, 0x75, 0x69, 0x9b, 0x81, 0x85, 0x6b, 0x1d, 0xe3, 0x3d, 0x4f, 0x2b, 0xd8, 0x40, 0x22, 0x86, 0xdc, 0xd8, 0xaf, 0xd5, 0x98, 0x5d, 0xd3, 0x8d, 0xda, 0x6c, 0x85, 0x3e, 0xa7, 0x3b, 0x83, 0x82, 0x9b, 0x60, 0x71, 0xaf, 0x5a, 0x69, 0x77, 0x8d, 0x8f, 0xa0, 0xa5, 0xa0, 0x0, 0xd, 0xf4, 0xfa, 0xcd, 0x72, 0x3c, 0x6c, 0x9c, 0x9f, 0x50, 0xd6, 0x12, 0x14, 0x6d, 0xc2, 0x29, 0xf0, 0x71, 0xde, 0xed, 0x32, 0x58, 0xe4, 0xef, 0xa, 0xa3, 0x76, 0x93, 0xa7, 0xc2, 0xdc, 0xe6, 0x15, 0x24, 0x69, 0x97, 0x46, 0x94, 0x0, 0x5e, 0x8d, 0x82, 0xcf, 0xc, 0xa0, 0xf9, 0xf0, 0x34, 0x36, 0x96, 0x7c, 0xed, 0x5c, 0xa8, 0x27, 0x8f, 0x6, 0x5c, 0x9b, 0x52, 0x41, 0xd2, 0xd8, 0x1a, 0xdc, 0x1a, 0xed, 0xbd, 0xef, 0x5a, 0xf4, 0x49, 0x5a, 0x79, 0x79, 0x75, 0x63, 0x5c, 0x71, 0x18, 0xb, 0x6b, 0x3f, 0x80, 0x2b, 0xe0, 0x8f, 0x2a, 0xb4, 0xec, 0x7b, 0xe3, 0xd1, 0x59, 0xdf, 0x1, 0xd1, 0xb, 0x33, 0xe5, 0xf7, 0x66, 0xcc, 0x3c, 0x9e, 0x26, 0x37, 0xe6, 0xaa, 0x39, 0xf4, 0x6f, 0xdc, 0xec, 0xc3, 0x7d, 0xc0, 0x4b, 0x45, 0xb8, 0x1c, 0x6e, 0x11, 0x3b, 0xad, 0x69, 0x2a, 0x3, 0x7e, 0xc3, 0x92, 0xb0, 0x75, 0xc0, 0x5a, 0x7b, 0x61, 0x72, 0xbe, 0x9c, 0xf0, 0xd1, 0x54, 0xcc, 0xe3, 0xca, 0x84, 0xf5, 0xd7, 0x8e, 0x95, 0x80, 0xbc, 0x31, 0xbf, 0x9e, 0x43, 0xfb, 0x6c, 0x10, 0xc6, 0xd8, 0xa7, 0x91, 0x7c, 0x20, 0x28, 0xcb, 0x89, 0xf0, 0x8d, 0x20, 0x5e, 0x33, 0xa9, 0xd5, 0xa3, 0x9a, 0xe, 0xf1, 0xe6, 0x19, 0x90, 0xdc, 0xbb, 0x64, 0xc0, 0x63, 0x61, 0xff, 0xe9, 0xb1, 0x61, 0xa5, 0x95, 0xbe, 0x16, 0x5f, 0x33, 0x3a, 0x2e, 0x14, 0x85, 0x22, 0xd0, 0x2e, 0xab, 0x28, 0xaf, 0xce, 0x37, 0x82, 0x40, 0x3f, 0xbf, 0xd8, 0x8c, 0x14, 0xe5, 0x3c, 0xb0, 0x9e, 0xc3, 0xf0, 0xa0, 0xf5, 0x3, 0x8c, 0x9, 0x73, 0x59, 0x6, 0x47, 0x95, 0x8c, 0x64, 0xe3, 0x46, 0x90, 0xce, 0xf, 0xf1, 0x33, 0x96, 0xaa, 0x45, 0x32, 0x97, 0x95, 0xd5, 0x9, 0x1, 0xc5, 0xe9, 0x84, 0xe2, 0x89, 0xe2, 0xfc, 0x7e, 0x91, 0xc4, 0xd, 0xf0, 0xd4, 0x44, 0x22, 0x70, 0x2, 0x2, 0xab, 0x3b, 0xde, 0x48, 0x1f, 0xce, 0xcc, 0x3d, 0xe9, 0x9d, 0xf9, 0x60, 0x91, 0x11, 0xc3, 0xf5, 0x7a, 0x8f, 0xc3, 0x93, 0x12, 0xc5, 0x2a, 0xb7, 0x61, 0xca, 0x37, 0x6f, 0x3e, 0xcf, 0xc7, 0xa9, 0x51, 0x41, 0x92, 0xe9, 0x8f, 0x7c, 0x89, 0xf4, 0x3f, 0xa7, 0x95, 0x93, 0x1c, 0xf0, 0x97, 0x1, 0x42, 0xd4, 0x7, 0xcf, 0xdd, 0x8a, 0x4a, 0x5f, 0x27, 0xdb, 0x8f, 0x6e, 0x1d, 0xe3, 0x52, 0xda, 0x58, 0x20, 0xab, 0x4a, 0x88, 0xf8, 0xac, 0x4b, 0x5c, 0x19, 0x9e, 0x6e, 0x46, 0xfd, 0x37, 0x77, 0xd0, 0x68, 0xfd, 0x97, 0xc5, 0x66, 0x90, 0x31, 0xd5, 0x8a, 0x83, 0x12, 0x9b, 0xc0, 0x95, 0xbf, 0xfc, 0xf0, 0x5f, 0x83, 0x1d, 0xa8, 0x11, 0x4b, 0x18, 0x98, 0xbf, 0x76, 0x49, 0xcd, 0xf5, 0x46, 0x59, 0x23, 0xf1, 0x3b, 0x82, 0x9, 0x8d, 0x6b, 0x3, 0x38, 0x8, 0xd2, 0xbe, 0xa2, 0xc3, 0x3, 0x7e, 0x9e, 0xf2, 0x5e, 0xba, 0xaa, 0xf0, 0x58, 0xab, 0x69, 0xe6, 0xfa, 0x69, 0xd6, 0x63, 0xa5, 0x7, 0xb, 0xea, 0xbc, 0x93, 0x3f, 0x5d, 0x12, 0xa1, 0x34, 0x6b, 0x1b, 0x7c, 0xdf, 0x46, 0xe1, 0x63, 0x8c, 0xe1, 0x63, 0x6, 0xf, 0x18, 0x5d, 0x5b, 0xd8, 0x8a, 0xb7, 0x37, 0x4, 0xda, 0x4f, 0x38, 0x54, 0xcd, 0xd3, 0x15, 0x6a, 0x7f, 0x93, 0x84, 0x41, 0xb1, 0x3c, 0x61, 0x6e, 0x6a, 0xd1, 0x80, 0xd9, 0xb7, 0x70, 0xa6, 0xa7, 0xa4, 0xac, 0x6f, 0xa3, 0x79, 0x8a, 0xce, 0xbd, 0x24, 0xc8, 0xe0, 0xd3, 0x45, 0x8f, 0x5a, 0x82, 0x79, 0x1b, 0x50, 0xed, 0x17, 0xeb, 0xe, 0xf0, 0x5c, 0x8e, 0xb8, 0xe, 0xd5, 0x92, 0xf1, 0x73, 0xf0, 0x39, 0x95, 0x6c, 0x67, 0x82, 0x76, 0x84, 0x22, 0x70, 0x63, 0xa4, 0x2, 0xa3, 0x7c, 0x0, 0x9a, 0x5f, 0x5a, 0x7, 0x5c, 0xf5, 0xc3, 0x9, 0xee, 0xfc, 0x8d, 0xa5, 0x17, 0x5, 0x4b, 0xba, 0x9, 0x4a, 0xe7, 0xb0, 0xa1, 0x12, 0x6a, 0x79, 0x1b, 0xa8, 0xe9, 0x4e, 0x44, 0xb5, 0x65, 0xc1, 0x26, 0x18, 0x51, 0xb, 0x9e, 0x93, 0x6e, 0x1c, 0x15, 0xed, 0xa1, 0x52, 0x2f, 0x7, 0x31, 0x42, 0x43, 0x30, 0xea, 0xaa, 0x3a, 0x9f, 0xfe, 0x94, 0x72, 0x7f, 0x9c, 0xaf, 0x8e, 0xb4, 0x4, 0xb0, 0x1b, 0x4e, 0x10, 0x71, 0xbe, 0x6b, 0xf7, 0xe2, 0xe5, 0x85, 0x13, 0xc1, 0x93, 0xed, 0x9c, 0xe2, 0x2c, 0x87, 0x5, 0x72, 0xfc, 0x39, 0x76, 0xef, 0x10, 0xa2, 0x25, 0x5c, 0x59, 0x80, 0x6, 0x2f, 0x8b, 0xb9, 0x87, 0x7b, 0x50, 0x48, 0xcd, 0x1, 0xb4, 0x2, 0x9f, 0xf1, 0xc7, 0xd2, 0x66, 0xb4, 0x2d, 0xad, 0x9d, 0x2, 0xf8, 0xc8, 0x9c, 0x3b, 0xd7, 0x81, 0x3c, 0x2, 0xde, 0x27, 0xde, 0x1f, 0x3b, 0xdc, 0xf8, 0xf, 0x6d, 0xc4, 0xff, 0x1c, 0x80, 0xf3, 0xd, 0x10, 0x37, 0x5b, 0xc1, 0x68, 0x4b, 0xe8, 0xe9, 0xc8, 0x18, 0x87, 0x4c, 0x38, 0x57, 0x5b, 0x51, 0x1a, 0x2d, 0x80, 0xf9, 0xfb, 0x65, 0x39, 0xbb, 0x0, 0x3d, 0xa8, 0x71, 0xdf, 0xf2, 0x62, 0x14, 0xde, 0x6e, 0x80, 0x6c, 0x31, 0xaf, 0x96, 0x81, 0xa0, 0x75, 0xba, 0x9a, 0xc4, 0xa4, 0xe0, 0x7f, 0x70, 0x4, 0x48, 0xe, 0x4e, 0x3d, 0x8c, 0xc0, 0x6a, 0x53, 0x98, 0x17, 0x19, 0x98, 0xf0, 0x3b, 0xde, 0x21, 0x91, 0x89, 0xc0, 0x62, 0x7b, 0x8a, 0x4a, 0x4f, 0x8a, 0xe1, 0x74, 0xc5, 0xde, 0x72, 0x1e, 0x29, 0xd7, 0xb9, 0x87, 0x4f, 0x22, 0x34, 0x9a, 0xcc, 0x6b, 0x35, 0xe7, 0x60, 0x16, 0xa7, 0x49, 0x27, 0x3f, 0xea, 0xae, 0x94, 0x11, 0x6c, 0x4e, 0x6c, 0x9f, 0xfe, 0x62, 0xb8, 0x71, 0x89, 0xe6, 0x10, 0x51, 0xeb, 0x9c, 0xfa, 0xad, 0x72, 0xf2, 0xfe, 0x36, 0x82, 0x58, 0xc4, 0xed, 0x2d, 0x36, 0x34, 0x2c, 0x81, 0xb7, 0x83, 0x51, 0x34, 0x8e, 0xb, 0xde, 0xcf, 0x63, 0xa0, 0x9f, 0xd2, 0x4d, 0xf8, 0x9c, 0x93, 0xeb, 0x18, 0x1d, 0xec, 0xbe, 0x3f, 0x93, 0x7b, 0x53, 0x7a, 0x1b, 0xe0, 0x22, 0x1f, 0x7c, 0xe, 0x25, 0x7b, 0x82, 0xd6, 0x79, 0xcd, 0xd6, 0xb2, 0x6a, 0x9, 0x9b, 0x2e, 0x9b, 0xc1, 0xe5, 0xf9, 0xd5, 0x4f, 0x97, 0x94, 0x9, 0xa7, 0xbc, 0x4f, 0x4b, 0x37, 0x5f, 0x5a, 0x37, 0x99, 0x1e, 0x4, 0x6e, 0x9b, 0x33, 0xc0, 0x1e, 0x60, 0x19, 0xfe, 0x93, 0xf6, 0xd8, 0x5, 0x28, 0x19, 0x5d, 0x92, 0x81, 0xe6, 0x17, 0x94, 0xd8, 0x77, 0x76, 0x91, 0x4c, 0xdf, 0x1e, 0x46, 0x15, 0xdc, 0x15, 0xeb, 0x0, 0x7, 0xe3, 0x97, 0x97, 0xd1, 0x4f, 0xa7, 0xda, 0xc2, 0xe9, 0x2c, 0x12, 0x35, 0x3b, 0x25, 0x12, 0xa3, 0x9, 0x97, 0x61, 0xf7, 0x73, 0x7a, 0xad, 0x3a, 0x5a, 0xd7, 0xf7, 0x64, 0xc4, 0xe, 0x88, 0x78, 0xab, 0x99, 0x3, 0xb8, 0xfa, 0xd5, 0x11, 0x3a, 0x84, 0x60, 0x33, 0x26, 0xfb, 0x23, 0x7e, 0x8f, 0x2b, 0x11, 0x23, 0xf6, 0x78, 0xca, 0x9, 0x11, 0x7a, 0xc3, 0x6b, 0x50, 0x5c, 0xa6, 0xbc, 0xab, 0x8c, 0x4f, 0x75, 0xd5, 0xa3, 0x6b, 0xf8, 0xe8, 0x56, 0xe0, 0x4b, 0xda, 0xe1, 0x99, 0x98, 0xa2, 0xb9, 0x8f, 0xd3, 0xd6, 0x8a, 0xfc, 0xd1, 0xdc, 0x5e, 0x33, 0xa5, 0xc2, 0x6e, 0x4e, 0x85, 0x6, 0xd0, 0x5e, 0xf8, 0x79, 0xb9, 0x8f, 0xd2, 0x3e, 0x74, 0x98, 0x9d, 0x4b, 0x8d, 0xf6, 0x9c, 0x33, 0x21, 0x7f, 0xde, 0x5e, 0x40, 0x3d, 0x85, 0xc0, 0x2b, 0xc9, 0xc3, 0x3a, 0x85, 0x56, 0xf0, 0xb0, 0x2d, 0x92, 0xab, 0xbe, 0x3a, 0x5e, 0xdb, 0xdd, 0x6b, 0x34, 0x58, 0x1d, 0xa3, 0x7e, 0x77, 0xbc, 0x81, 0x6f, 0x50, 0xb6, 0xdd, 0x74, 0x3e, 0x59, 0x4e, 0x35, 0x48, 0xda, 0xc5, 0x7a, 0xac, 0x17, 0x40, 0xfd, 0x8, 0xf4, 0x16, 0xf1, 0x13, 0xd6, 0xbd, 0x80, 0xe1, 0x27, 0xcd, 0xf8, 0x7e, 0x68, 0x1e, 0xf2, 0x23, 0xcb, 0x70, 0x9f, 0x1a, 0xe4, 0xc7, 0xc, 0x81, 0x36, 0x3c, 0x7e, 0x83, 0xf9, 0x5f, 0x95, 0x78, 0x4e, 0x29, 0x44, 0xab, 0x1c, 0xa, 0x5f, 0x4f, 0x15, 0x10, 0x7f, 0x89, 0x44, 0xbe, 0xdc, 0x66, 0x9d, 0x38, 0xd9, 0x7e, 0x2c, 0xfc, 0xd6, 0x86, 0x2d, 0x97, 0xcb, 0xe3, 0xcb, 0xe8, 0x80, 0xc3, 0x97, 0x35, 0x6d, 0xe4, 0x1f, 0x4c, 0xb4, 0xa6, 0x4c, 0x63, 0x3, 0x9c, 0x83, 0x3b, 0x2e, 0x18, 0x57, 0xf, 0xe4, 0xb0, 0x61, 0xd, 0xb5, 0xa9, 0x43, 0xb, 0xca, 0xc8, 0x9f, 0xad, 0x40, 0x62, 0x78, 0x3e, 0x22, 0xed, 0x97, 0x16, 0xc9, 0xb3, 0x30, 0xae, 0xf9, 0xb9, 0xcc, 0xad, 0xd7, 0x8a, 0xb, 0x54, 0x3a, 0x5b, 0x7, 0xf, 0xd5, 0x32, 0xd1, 0xb0, 0x5, 0x61, 0x2e, 0x68, 0xe6, 0x22, 0x2e, 0x74, 0xa1, 0xbf, 0x2b, 0x1b, 0x67, 0x7b, 0x15, 0x82, 0x19, 0x6e, 0x8a, 0x6, 0x23, 0x92, 0x26, 0x9a, 0xa3, 0xae, 0xa9, 0x1e, 0xa0, 0xa6, 0xbb, 0x96, 0x45, 0x9e, 0x65, 0x2c, 0x4e, 0xc5, 0x5, 0x34, 0x40, 0x58, 0xca, 0xec, 0x53, 0x5, 0x98, 0xda, 0x6f, 0x42, 0x36, 0x22, 0xdd, 0xa7, 0x81, 0x3b, 0x59, 0xc8, 0x33, 0xeb, 0x6e, 0x66, 0x6c, 0x5b, 0x8c, 0x2f, 0xa4, 0xff, 0xe3, 0x58, 0xb3, 0xd6, 0x9f, 0x17, 0x5f, 0x88, 0x38, 0x83, 0xe6, 0x77, 0xc1, 0x59, 0xaf, 0x94, 0x44, 0x95, 0x9f, 0xb, 0xc3, 0x45, 0xfa, 0x81, 0x87, 0x7a, 0x16, 0x2, 0xf9, 0xc6, 0x51, 0x72, 0x66, 0x9c, 0x33, 0x75, 0x0, 0x52, 0xdc, 0x1a, 0xec, 0xff, 0x64, 0x41, 0x1, 0xaf, 0xa2, 0x55, 0xdc, 0x7e, 0xf3, 0xc2, 0xf0, 0xf7, 0x90, 0xb6, 0x1a, 0x30, 0x62, 0xd6, 0x8e, 0x47, 0x5a, 0x75, 0xfc, 0x6a, 0xba, 0xb8, 0xe, 0x6d, 0xc9, 0x58, 0xc7, 0xcd, 0x1d, 0x87, 0xcb, 0xea, 0x87, 0xba, 0x27, 0xd1, 0x86, 0xf7, 0xa2, 0xa5, 0x2b, 0xa4, 0x46, 0xe2, 0x5e, 0x16, 0x3b, 0x18, 0x18, 0x9d, 0xac, 0x6d, 0xc9, 0x35, 0x1d, 0x24, 0xc7, 0xe1, 0x7b, 0x72, 0x5b, 0x38, 0x34, 0x31, 0x96, 0xa7, 0x32, 0xa9, 0xc4, 0xc6, 0x28, 0x5d, 0xc1, 0xf, 0x33, 0x45, 0xd0, 0xce, 0x32, 0x8, 0xa8, 0x47, 0xd5, 0x10, 0xfb, 0xa7, 0xaa, 0x4b, 0x88, 0xfc, 0xd8, 0x12, 0xf6, 0x73, 0x10, 0xb1, 0x1d, 0x3e, 0x7d, 0xdc, 0x1b, 0xd, 0xd3, 0xb, 0x1f, 0x86, 0xf6, 0xce, 0x35, 0xc, 0xe2, 0x68, 0x46, 0xda, 0x8d, 0xa, 0xd2, 0x1a, 0xdc, 0x2f, 0x62, 0xbc, 0x48, 0x32, 0x98, 0x8f, 0x30, 0xa4, 0x79, 0x71, 0x6c, 0x2f, 0x90, 0xa6, 0xbf, 0xa0, 0xfe, 0xfe, 0x75, 0xfc, 0xb0, 0x8e, 0xf5, 0xac, 0xa5, 0x54, 0x78, 0x1c, 0xfb, 0xea, 0x1c, 0x84, 0x67, 0xaa, 0x45, 0x85, 0x4e, 0xa0, 0x26, 0xb9, 0xff, 0xe1, 0xe9, 0xcf, 0x1d, 0xb5, 0xf3, 0xfc, 0x48, 0xe1, 0x89, 0xc6, 0x5f, 0xf2, 0xa7, 0x43, 0x88, 0x3b, 0x99, 0x98, 0x8e, 0x2f, 0x6, 0x7e, 0xe3, 0xcd, 0x9f, 0x2c, 0xc4, 0xf8, 0x41, 0xc1, 0xc, 0xcb, 0xd7, 0xb5, 0x25, 0x8, 0x25, 0x2a, 0xe3, 0xf, 0x12, 0xb7, 0xc7, 0x61, 0x9c, 0x55, 0x73, 0x85, 0x33, 0x3d, 0x46, 0x92, 0x4, 0x5, 0x68, 0x29, 0xc3, 0xa3, 0xe3, 0x55, 0x86, 0x4, 0xda, 0x89, 0xa2, 0x14, 0xb8, 0xa6, 0x6e, 0xad, 0xbb, 0x71, 0xd0, 0x73, 0x6a, 0xa, 0x3, 0xc4, 0x43, 0x30, 0xe6, 0x6b, 0xce, 0x1a, 0x5f, 0xdf, 0x4f, 0x63, 0xfc, 0x46, 0xf6, 0x66, 0x4f, 0xc9, 0xc1, 0x45, 0x42, 0x90, 0x50, 0x4c, 0x4a, 0xe2, 0x42, 0x5d, 0x8f, 0xeb, 0x95, 0x77, 0xca, 0xad, 0x4e, 0x32, 0x6b, 0x79, 0x3a, 0xb6, 0x88, 0xae, 0x62, 0x1c, 0x76, 0x99, 0x95, 0x64, 0xa4, 0x8, 0xbe, 0xcf, 0x26, 0xc3, 0x1b, 0x5d, 0x15, 0xc, 0xbd, 0x78, 0xe5, 0xd, 0x3a, 0xd3, 0x40, 0x3e, 0x28, 0x5e, 0x96, 0xea, 0x57, 0xda, 0xdf, 0x6f, 0xe9, 0x96, 0x23, 0x47, 0x6, 0x9f, 0x6e, 0xcb, 0xc2, 0xf0, 0xe, 0xb0, 0x94, 0x99, 0xc1, 0x6c, 0x4c, 0x44, 0x53, 0xae, 0x16, 0xf9, 0xa7, 0x82, 0x55, 0x6a, 0xe5, 0x67, 0xf9, 0x22, 0x2, 0x8c, 0x30, 0xff, 0x88, 0xa2, 0xcc, 0xc9, 0x24, 0x28, 0xc9, 0xf5, 0xab, 0xfb, 0x12, 0xac, 0xfe, 0xbb, 0xdf, 0xfb, 0xf, 0x1f, 0x2f, 0xf9, 0x70, 0xc3, 0xbe, 0x37, 0x8d, 0x22, 0x1c, 0xfb, 0x34, 0xd, 0x10, 0x7d, 0x92, 0x59, 0x7c, 0x77, 0x86, 0x57, 0xc8, 0x65, 0x3c, 0x76, 0xbf, 0x9a, 0xfd, 0x18, 0x5e, 0x9f, 0xf4, 0x80, 0x74, 0x6d, 0x88, 0x31, 0xb0, 0xcb, 0xc3, 0x4f, 0x79, 0x88, 0xf2, 0xb8, 0x31, 0x6c, 0xb0, 0xac, 0x2, 0xe9, 0xde, 0xe4, 0x14, 0x90, 0x56, 0x6, 0x7a, 0x91, 0x28, 0x66, 0x78, 0x7d, 0x5f, 0x55, 0x29, 0x67, 0xd1, 0xd, 0x6, 0x7d, 0x50, 0xc6, 0x79, 0x59, 0xef, 0xfd, 0x9, 0x98, 0xa5, 0xab, 0xab, 0x4a, 0x1e, 0x7f, 0x98, 0x9c, 0x3a, 0x15, 0xa9, 0x9c, 0xbd, 0x42, 0xe2, 0xf0, 0x3b, 0xbe, 0xe7, 0x19, 0xfe, 0x14, 0xc5, 0xb8, 0xd9, 0x17, 0xc6, 0xa, 0xd0, 0x2, 0xcf, 0x75, 0xd5, 0xac, 0x13, 0x71, 0x9d, 0x1a, 0x1, 0xfa, 0x70, 0xba, 0x83, 0xda, 0x1a, 0xe5, 0x3a, 0xfa, 0x8f, 0xa9, 0x37, 0x84, 0x8, 0x51, 0xcc, 0xae, 0x5, 0x7, 0x3a, 0x65, 0x0, 0x45, 0x41, 0x12, 0x5b, 0x58, 0xc6, 0xf8, 0xd0, 0xbc, 0x7d, 0x70, 0x6d, 0x70, 0x46, 0x83, 0xdd, 0x4, 0x6d, 0x5e, 0x73, 0x60, 0xb6, 0x66, 0x94, 0x32, 0xf8, 0x72, 0x5, 0x17, 0x6, 0x24, 0xf2, 0x31, 0xd1, 0xee, 0xa8, 0xab, 0xf2, 0xbc, 0xd6, 0x11, 0xe8, 0xfd, 0x7c, 0x2c, 0x92, 0x3d, 0x8c, 0xef, 0x8e, 0x1a, 0xe9, 0x2b, 0xa3, 0xe6, 0x6a, 0xa8, 0x5a, 0x24, 0x17, 0x6, 0x6b, 0xb7, 0xba, 0x68, 0xba, 0x14, 0x56, 0xde, 0x9d, 0x35, 0x3a, 0x94, 0xb1, 0x46, 0xa3, 0x63, 0x15, 0x7, 0xf0, 0x68, 0x8c, 0xc6, 0xca, 0x40, 0x6f, 0x7b, 0xe4, 0x7e, 0xe6, 0xcb, 0x94, 0x88, 0xc2, 0x93, 0xc4, 0xfb, 0x2b, 0xee, 0x62, 0x76, 0x3f, 0x2c, 0xcc, 0x7f, 0x3d, 0x7c, 0x81, 0x77, 0x4e, 0xfb, 0x79, 0x23, 0x8b, 0x1c, 0x39, 0x2, 0x37, 0xe, 0x5e, 0x9d, 0x94, 0xb4, 0x1e, 0x7d, 0xb, 0x81, 0x82, 0x87, 0x87, 0x12, 0x31, 0x9b, 0x8f, 0xe8, 0x56, 0xcb, 0xc5, 0x6e, 0x1c, 0x85, 0x30, 0xc4, 0x19, 0x31, 0xd6, 0xc2, 0xb5, 0xa9, 0x80, 0xa6, 0x49, 0x38, 0x98, 0x8e, 0xd8, 0x4e, 0x7, 0x6, 0x18, 0x8a, 0x56, 0xac, 0xec, 0x67, 0xec, 0x4b, 0xa0, 0xea, 0xf8, 0x81, 0xd1, 0x77, 0xcc, 0x1c, 0xfe, 0xb8, 0xe1, 0x3, 0x4f, 0xc3, 0x57, 0x74, 0xc6, 0xcf, 0x9a, 0x65, 0xf3, 0xb, 0xb0, 0x1d, 0x82, 0x2e, 0x64, 0x40, 0x1d, 0x98, 0xff, 0xb9, 0x36, 0xfd, 0xdd, 0xd8, 0xcf, 0xe, 0x70, 0xa4, 0x82, 0xf2, 0x24, 0xe0, 0xf4, 0xf3, 0xcc, 0xde, 0xaa, 0x55, 0xa2, 0x26, 0x55, 0xb4, 0x48, 0x2e, 0xe2, 0x3f, 0x7b, 0x5d, 0x3e, 0xe1, 0x3, 0x68, 0x89, 0xfe, 0x5f, 0xf8, 0x88, 0x56, 0xc0, 0x54, 0x5b, 0x9, 0xf6, 0x2f, 0xf8, 0xa5, 0x4a, 0xad, 0x8e, 0x5c, 0x19, 0x64, 0x49, 0x1d, 0x3a},
+               output224: []byte{0x3d, 0xe2, 0x74, 0x84, 0xa9, 0xaa, 0xf9, 0x42, 0x7b, 0x6d, 0x7c, 0xe9, 0xf2, 0x34, 0x55, 0xda, 0x77, 0x1d, 0xcd, 0x2, 0x1a, 0x74, 0x3b, 0x4, 0x9c, 0xe8, 0x56, 0x42},
+               output256: []byte{0x72, 0xf0, 0xbb, 0x32, 0xeb, 0x6e, 0x4b, 0xb9, 0x70, 0xa1, 0x2b, 0xac, 0xe8, 0xa, 0x7e, 0x3c, 0xa8, 0x61, 0x6a, 0x3f, 0xa5, 0x1f, 0x40, 0x43, 0x8f, 0xc9, 0xb, 0x32, 0x7f, 0xe, 0x75, 0xf6},
+               output384: []byte{0x18, 0x3c, 0x13, 0xeb, 0x17, 0xc6, 0x6f, 0x15, 0xf2, 0xd7, 0x3d, 0x51, 0xca, 0x70, 0x17, 0x72, 0x82, 0x48, 0x95, 0x7d, 0x60, 0xe, 0x89, 0xa7, 0xcc, 0xb, 0xc0, 0x67, 0xc9, 0x75, 0xbc, 0x32, 0xf4, 0xe0, 0x78, 0x6f, 0xf4, 0xe, 0x62, 0x5c, 0xc7, 0xc0, 0xe0, 0xac, 0x78, 0x7f, 0x62, 0x36},
+               output512: []byte{0xe, 0xa2, 0xc8, 0x58, 0x7e, 0x46, 0x46, 0x22, 0x6f, 0x46, 0x95, 0x23, 0x50, 0xe3, 0xbf, 0xe, 0x71, 0xb0, 0xb8, 0xab, 0xf7, 0x7, 0xc8, 0xc1, 0xec, 0x99, 0x87, 0x7e, 0x38, 0x31, 0xee, 0x3d, 0x3d, 0x22, 0x4d, 0xfd, 0xac, 0x17, 0xb0, 0xac, 0xae, 0x62, 0xf5, 0x7, 0xce, 0x2a, 0x17, 0x5, 0xd5, 0x18, 0xef, 0x45, 0x2b, 0x97, 0x2f, 0x33, 0xf6, 0x0, 0x23, 0x8, 0xc9, 0x72, 0x69, 0x94}},
+       testcase{
+               msg:       []byte{0x28, 0x10, 0x9f, 0x1e, 0x97, 0x64, 0x1e, 0x7c, 0x24, 0x6c, 0xa9, 0xde, 0xe6, 0xfb, 0xaa, 0x15, 0xd9, 0x85, 0xa8, 0x42, 0x92, 0xec, 0xaf, 0xfe, 0x2, 0x5f, 0x66, 0xa9, 0xdc, 0xae, 0xb1, 0xf0, 0xf8, 0xcd, 0x72, 0x48, 0x96, 0xa0, 0xbc, 0x2e, 0x6f, 0x7b, 0x17, 0x63, 0xd7, 0xc1, 0x5b, 0x61, 0xac, 0xbb, 0xf1, 0x3f, 0xce, 0x74, 0x78, 0x2b, 0x8a, 0x71, 0x51, 0x52, 0x7c, 0x9b, 0xd3, 0x75, 0xd4, 0xbf, 0x37, 0xc1, 0x5c, 0xa3, 0x9e, 0x20, 0xc3, 0x52, 0xb2, 0xe0, 0xb0, 0xd8, 0x47, 0x4f, 0x90, 0x4f, 0xca, 0x4e, 0x3, 0x9d, 0xcd, 0x6e, 0x1e, 0x54, 0xe8, 0x72, 0xa4, 0x81, 0xf8, 0xe1, 0xe5, 0xff, 0xd3, 0xd6, 0x52, 0x57, 0xff, 0x81, 0x4f, 0xa0, 0xe5, 0x9b, 0x5e, 0xce, 0xcc, 0x30, 0xfb, 0x1e, 0xe1, 0xb7, 0x3a, 0x87, 0xc0, 0x50, 0xb9, 0xc0, 0xc8, 0xdb, 0x6b, 0xab, 0x93, 0xa2, 0x4a, 0xda, 0x3f, 0xa4, 0x80, 0xf2, 0x15, 0xe1, 0x9f, 0x63, 0x30, 0x8c, 0xec, 0x77, 0xd1, 0xbd, 0x5a, 0xc1, 0x86, 0x4a, 0xe2, 0x46, 0x7, 0x12, 0x3, 0xc7, 0x49, 0x9f, 0x3, 0xea, 0xbc, 0xa4, 0x9, 0x30, 0x58, 0xd9, 0xa9, 0x8e, 0x26, 0xf2, 0x9d, 0xd9, 0x1a, 0xb0, 0xac, 0x55, 0x6b, 0xf1, 0xa6, 0xed, 0x76, 0x49, 0xe5, 0x55, 0x9d, 0x6e, 0x3c, 0x93, 0x25, 0x4e, 0x6f, 0x4c, 0xd7, 0x94, 0x35, 0x85, 0xd6, 0xe1, 0x50, 0x2b, 0xbc, 0x6c, 0xfa, 0x4a, 0x38, 0x22, 0x3b, 0x35, 0xee, 0xd2, 0xbf, 0x65, 0x84, 0x48, 0x25, 0x9f, 0x82, 0x78, 0x30, 0xd8, 0x97, 0x94, 0x2a, 0x3a, 0xd0, 0xa8, 0xa5, 0xcc, 0x7e, 0x30, 0x18, 0x45, 0x1e, 0x4f, 0xc8, 0x84, 0xc5, 0xb7, 0xcc, 0x65, 0xf5, 0x4e, 0xe7, 0x5e, 0xbf, 0xd7, 0xc1, 0xd4, 0xc8, 0x8c, 0x71, 0xa3, 0x63, 0x41, 0x32, 0x7b, 0x97, 0x72, 0xce, 0xb9, 0xf8, 0xb7, 0xb4, 0xb7, 0x25, 0x16, 0x50, 0x11, 0xb8, 0x48, 0xc2, 0xdc, 0x91, 0x7f, 0xd5, 0x51, 0x41, 0x82, 0xe2, 0x69, 0x8f, 0x9e, 0xa1, 0x81, 0xfe, 0x6c, 0x97, 0x11, 0x90, 0x6d, 0x29, 0x6a, 0xb9, 0x83, 0x5d, 0xb7, 0x50, 0x1e, 0x2e, 0xbf, 0x79, 0xec, 0xc4, 0x47, 0x50, 0x91, 0xe6, 0x71, 0x9c, 0x8c, 0x6, 0x59, 0x9d, 0xd2, 0xb8, 0x86, 0x70, 0xbd, 0xb8, 0xc4, 0xa2, 0x8b, 0xdd, 0xf7, 0x8c, 0x97, 0xb8, 0x1b, 0xd2, 0xfd, 0x67, 0x3d, 0x59, 0x10, 0xe1, 0x24, 0x7c, 0x43, 0xfd, 0xef, 0xad, 0xd3, 0xd, 0x92, 0xe0, 0xd9, 0xb6, 0xe0, 0xb4, 0x56, 0x63, 0x5f, 0x96, 0xfa, 0x47, 0x7f, 0xe5, 0xec, 0xfc, 0xfa, 0x9f, 0x94, 0xf5, 0xc1, 0xd7, 0x66, 0x64, 0xc, 0x59, 0x62, 0x98, 0x50, 0x2b, 0x20, 0xcf, 0xb3, 0xbd, 0xfe, 0x7f, 0x3f, 0xd2, 0x37, 0xfc, 0xbe, 0xa9, 0x47, 0xd2, 0x4d, 0x3, 0x60, 0x77, 0x60, 0x30, 0xb0, 0xb6, 0x61, 0xa9, 0xbd, 0xd2, 0x14, 0x76, 0x4d, 0xe, 0x70, 0xe6, 0xe, 0xfc, 0x69, 0x6b, 0x9b, 0xb6, 0x3e, 0x3b, 0xf1, 0x71, 0xc6, 0x2d, 0x1b, 0xc2, 0xb6, 0xe5, 0x3f, 0x94, 0x1b, 0x39, 0x15, 0xf8, 0x5f, 0xb4, 0xb9, 0xb2, 0xe7, 0x4f, 0x39, 0x1b, 0x5d, 0xad, 0x29, 0x1f, 0xe9, 0xf9, 0x62, 0x9e, 0x2, 0xfc, 0x3f, 0xc5, 0x39, 0x5e, 0xc6, 0x6f, 0xa6, 0xfc, 0xc5, 0x33, 0x8d, 0x35, 0x3c, 0xfc, 0xd4, 0x9, 0xa1, 0xcf, 0x4b, 0x6b, 0xbe, 0xa5, 0x17, 0xef, 0x59, 0x79, 0xd0, 0x86, 0xdd, 0xe3, 0x5c, 0x8, 0xc8, 0x85, 0xc3, 0xb9, 0xee, 0x5c, 0x8c, 0x59, 0x28, 0x4e, 0x10, 0xa5, 0x4, 0x1c, 0x9d, 0xeb, 0x78, 0x60, 0xb1, 0x12, 0xe0, 0x5e, 0x5, 0x16, 0x55, 0xdc, 0x37, 0x42, 0x71, 0x1, 0x2e, 0xce, 0x9e, 0xac, 0x4c, 0x84, 0xd, 0x2c, 0x47, 0x46, 0x90, 0x74, 0xb7, 0x7f, 0x80, 0x81, 0x89, 0xa0, 0xea, 0x64, 0x5e, 0xee, 0x5f, 0x5e, 0xec, 0x17, 0xfd, 0xcb, 0x51, 0xd0, 0xd1, 0xb2, 0xd8, 0x29, 0x3b, 0x4c, 0x8a, 0x25, 0x93, 0x75, 0x70, 0xc, 0x3f, 0xa8, 0xfc, 0x48, 0xa3, 0x9c, 0xc8, 0xb3, 0x2b, 0x22, 0xcf, 0x7b, 0xb7, 0x14, 0xfd, 0xc7, 0xea, 0xcd, 0x71, 0x90, 0xba, 0xce, 0x15, 0x98, 0x7c, 0x7f, 0x86, 0x74, 0xf3, 0xf, 0x46, 0x63, 0xf1, 0xbb, 0x50, 0x47, 0xd, 0x25, 0x43, 0x79, 0x48, 0xd4, 0x35, 0x3f, 0xc2, 0xb9, 0x6e, 0x79, 0xc, 0x19, 0x41, 0x3e, 0x9f, 0x28, 0xec, 0x4, 0xa0, 0x2b, 0x37, 0xcb, 0x0, 0x36, 0x48, 0x18, 0x3, 0xbb, 0x67, 0x28, 0xb6, 0xd8, 0x81, 0x4b, 0xcd, 0xd8, 0x9d, 0xcf, 0xe4, 0x58, 0x8, 0x4b, 0x8c, 0x84, 0x95, 0xc4, 0xbe, 0x33, 0xb5, 0xf0, 0x2e, 0xc6, 0x9f, 0x22, 0x46, 0x5d, 0x5f, 0xac, 0x7d, 0x85, 0x33, 0x1e, 0x8e, 0xd2, 0x90, 0x78, 0x73, 0x36, 0xa7, 0x32, 0x38, 0x44, 0x82, 0x71, 0xa2, 0x37, 0xa3, 0x47, 0x30, 0x76, 0x4c, 0x2a, 0x4d, 0xf6, 0x47, 0x74, 0xac, 0x6a, 0x25, 0x12, 0x23, 0x1c, 0x54, 0xfa, 0x7d, 0x68, 0xfb, 0xa4, 0xe8, 0x88, 0x33, 0x1f, 0xa2, 0x8d, 0x1b, 0x41, 0x43, 0xa2, 0xc, 0xec, 0x22, 0x34, 0x52, 0x4c, 0x52, 0x20, 0x70, 0xa2, 0xf3, 0xac, 0x33, 0x6a, 0x41, 0x6c, 0x7, 0x9b, 0x58, 0xe2, 0xea, 0x8b, 0x2d, 0x71, 0x18, 0x81, 0x70, 0xb6, 0x41, 0x6b, 0x70, 0x57, 0xb1, 0x1b, 0x99, 0x90, 0x26, 0xbd, 0x67, 0x2e, 0x1, 0x59, 0xfa, 0x85, 0xbc, 0xa, 0x1a, 0x26, 0x57, 0xaa, 0xa1, 0x1b, 0x67, 0x42, 0xf1, 0x21, 0xf0, 0x8d, 0xc8, 0xcb, 0xa4, 0xcd, 0x16, 0x24, 0xa2, 0xa3, 0x37, 0x98, 0xd5, 0xf7, 0xed, 0x9, 0x6b, 0x76, 0x9b, 0x79, 0xb8, 0x10, 0xed, 0xc8, 0x1c, 0x4e, 0x5, 0xc1, 0x7b, 0x62, 0xd8, 0xb2, 0xdf, 0x21, 0x40, 0xc5, 0xdc, 0xac, 0xe, 0xa9, 0xb5, 0x9, 0x8, 0x4, 0x34, 0x25, 0xce, 0xe2, 0xec, 0x17, 0xc3, 0xc3, 0xe5, 0x22, 0xd1, 0x27, 0x29, 0x69, 0xf1, 0xf8, 0xab, 0xeb, 0xe8, 0x2e, 0x1e, 0x1d, 0x2a, 0xe7, 0xb6, 0x4b, 0xa1, 0x4e, 0x0, 0xc1, 0x7a, 0x66, 0x35, 0x49, 0x8f, 0xd7, 0xfe, 0xcc, 0x64, 0x21, 0xc8, 0x9b, 0xad, 0x4c, 0xb7, 0x80, 0x5, 0xee, 0xaa, 0xe9, 0x69, 0x78, 0xbb, 0xfa, 0x20, 0x15, 0xb2, 0x82, 0x91, 0x7a, 0xcc, 0xea, 0x60, 0xb0, 0xe0, 0xaa, 0xa2, 0xcf, 0x1e, 0xd7, 0xa6, 0xe7, 0xed, 0xc, 0x95, 0x88, 0xd6, 0xa6, 0xc0, 0x6e, 0x49, 0x33, 0x98, 0x23, 0xc6, 0x18, 0xb, 0x9a, 0x1d, 0xe, 0x61, 0x14, 0xc0, 0xde, 0x9d, 0x89, 0xec, 0xa8, 0x17, 0x29, 0x8c, 0x6e, 0x3b, 0xe3, 0xf5, 0x34, 0x4, 0x78, 0x76, 0x38, 0xb2, 0xf8, 0x83, 0x24, 0x8e, 0xee, 0xf0, 0x55, 0xc1, 0x8f, 0xd4, 0x76, 0xe0, 0x7a, 0x7e, 0xb5, 0xf1, 0x79, 0xc8, 0x61, 0x3c, 0xf4, 0xdf, 0x1, 0x41, 0x9c, 0x1c, 0x6d, 0x63, 0x9, 0xbc, 0x53, 0xe2, 0x14, 0xbd, 0xa5, 0x46, 0xf2, 0x72, 0xa3, 0x72, 0xb8, 0x13, 0xef, 0x8, 0x3b, 0xb3, 0x90, 0x5a, 0x99, 0x62, 0x74, 0xbd, 0xb, 0xe7, 0x3c, 0x9b, 0x79, 0x13, 0x5d, 0x81, 0x67, 0xfa, 0x5a, 0x5, 0x8a, 0x7f, 0x92, 0x6f, 0x9f, 0x31, 0x5f, 0x4f, 0x82, 0x3c, 0x44, 0xba, 0x6f, 0x28, 0x0, 0xe2, 0x5e, 0xd8, 0xe1, 0x65, 0x94, 0x44, 0xd3, 0xce, 0x47, 0xf1, 0xa5, 0x8e, 0x50, 0x11, 0x66, 0xb, 0x40, 0x39, 0x2a, 0x94, 0x2e, 0x90, 0x1d, 0xc9, 0xab, 0x94, 0x90, 0x94, 0xd2, 0x8a, 0xc3, 0x8d, 0x1d, 0x7a, 0x13, 0x35, 0x7f, 0x71, 0x65, 0x11, 0xd1, 0xb1, 0x2a, 0x29, 0x4b, 0xaa, 0x1f, 0xe6, 0xda, 0x6b, 0xf6, 0xd8, 0x1b, 0x83, 0xd, 0xcb, 0xac, 0xa4, 0xf4, 0xc0, 0x9a, 0x53, 0x33, 0x13, 0x79, 0xcb, 0x6c, 0x42, 0xc3, 0xad, 0xa8, 0xd6, 0x13, 0x22, 0xde, 0x1f, 0xfe, 0xcb, 0xb1, 0xa7, 0xaf, 0xe3, 0x27, 0x9f, 0x6e, 0xb6, 0x3c, 0x8f, 0x2, 0xa, 0x51, 0x92, 0x58, 0x62, 0x33, 0x4, 0x51, 0xa0, 0x0, 0x2a, 0x6e, 0x17, 0x55, 0xeb, 0x26, 0x4f, 0x3c, 0x74, 0xfb, 0x62, 0xdc, 0x92, 0xe9, 0xe6, 0xab, 0x82, 0x2c, 0x87, 0x62, 0xcb, 0x9f, 0x93, 0xcd, 0xf0, 0x65, 0x9a, 0x54, 0xa5, 0x69, 0x6a, 0xd1, 0x3e, 0xc6, 0xce, 0xcb, 0xae, 0xde, 0xba, 0x6a, 0x41, 0x32, 0x3d, 0x75, 0x40, 0xad, 0x59, 0x25, 0xf, 0x1f, 0xff, 0xe6, 0x16, 0xdd, 0xe6, 0x71, 0xd6, 0x73, 0xe3, 0x7d, 0x4a, 0x52, 0x13, 0x5, 0xe4, 0x7a, 0x64, 0x55, 0x76, 0xd6, 0xaf, 0x9a, 0x69, 0x91, 0xb1, 0x7f, 0x3c, 0x71, 0x19, 0xdb, 0x46, 0x3a, 0x76, 0xec, 0x93, 0x3f, 0x5, 0x90, 0x5a, 0x1d, 0xd6, 0x21, 0xad, 0x15, 0x77, 0x5e, 0xb9, 0x47, 0x5e, 0xb0, 0xcd, 0xeb, 0x6c, 0xd9, 0x3a, 0xcc, 0x12, 0xb, 0x39, 0x67, 0x82, 0x44, 0x56, 0x37, 0xf4, 0xf8, 0xdb, 0xb3, 0x8a, 0x3a, 0xa1, 0x75, 0x37, 0xd9, 0x17, 0xd, 0xaa, 0xe4, 0xe4, 0xdd, 0xd8, 0x99, 0xb1, 0x61, 0x68, 0xa2, 0xf9, 0xdc, 0x4b, 0xfd, 0xf7, 0xa9, 0xbe, 0xe0, 0x7b, 0xb9, 0xf7, 0xc3, 0x12, 0xef, 0xb7, 0x8d, 0x37, 0xae, 0x43, 0x73, 0x92, 0xda, 0xa7, 0x55, 0xb1, 0x84, 0xfc, 0x51, 0x10, 0xc, 0x54, 0xe8, 0x2f, 0xc1, 0x79, 0x2a, 0xa8, 0x7e, 0x58, 0x77, 0x8f, 0xbc, 0x15, 0xe, 0xdc, 0xb8, 0xc9, 0xf3, 0x37, 0x22, 0x7b, 0x4f, 0x6e, 0xa5, 0x83, 0x7d, 0xf8, 0xa0, 0x87, 0x19, 0x78, 0x93, 0x56, 0x28, 0x1c, 0x8f, 0xc7, 0xce, 0x6, 0x63, 0xea, 0xc9, 0xba, 0x76, 0xca, 0xa, 0xb5, 0x89, 0xcd, 0x3c, 0x5a, 0x82, 0xea, 0x2a, 0x1a, 0x99, 0x6d, 0x2c, 0xfd, 0xb2, 0x45, 0xf1, 0x90, 0x8a, 0xd7, 0x49, 0x34, 0x82, 0x3b, 0x93, 0x52, 0xff, 0x9, 0x39, 0xab, 0x22, 0x8f, 0x6f, 0x8c, 0x59, 0x98, 0xc, 0xcd, 0xa9, 0x84, 0xc2, 0x12, 0xa0, 0x89, 0x29, 0x28, 0xb8, 0x8d, 0xfc, 0x52, 0xc4, 0xfc, 0x34, 0x99, 0x7a, 0x6f, 0x2, 0x85, 0xf4, 0x51, 0xdb, 0x3a, 0x1d, 0x5d, 0xc4, 0xc8, 0x0, 0xb3, 0x3a, 0x68, 0x63, 0x85, 0x2c, 0x44, 0xa2, 0xe6, 0x75, 0xa9, 0x8b, 0x38, 0xee, 0x85, 0x26, 0xfb, 0x79, 0x4e, 0xee, 0x59, 0x29, 0x62, 0xa9, 0x38, 0x66, 0xe, 0x1b, 0x71, 0x14, 0xab, 0xcd, 0x42, 0x92, 0x4c, 0xa4, 0xd7, 0x0, 0x45, 0x80, 0x7c, 0x50, 0x98, 0x55, 0x65, 0xef, 0xe2, 0x4f, 0x33, 0x3, 0x98, 0x7c, 0x30, 0x7d, 0xe7, 0x54, 0xd8, 0x62, 0x5a, 0x5b, 0x73, 0x39, 0xf0, 0x54, 0xa9, 0xd, 0xb3, 0x7c, 0xe0, 0xb9, 0xf5, 0xba, 0x5, 0x95, 0x42, 0x5b, 0x26, 0x71, 0x2a, 0xf4, 0x43, 0x5a, 0xb8, 0x8, 0x2a, 0xe5, 0xbc, 0x1b, 0x21, 0x1f, 0xc6, 0xee, 0x44, 0x26, 0x2d, 0x26, 0xd8, 0x2a, 0x88, 0xe6, 0x62, 0xa4, 0x76, 0x88, 0xe3, 0xde, 0x67, 0xcf, 0x82, 0x5b, 0xc6, 0x2e, 0x1b, 0x3e, 0x3f, 0x62, 0x5b, 0x54, 0x81, 0x46, 0xe, 0xb, 0xac, 0x45, 0x1d, 0xb6, 0xb6, 0x7f, 0x40, 0xe9, 0xcb, 0x6b, 0x87, 0xc7, 0x7f, 0x2e, 0xe6, 0x37, 0x92, 0x30, 0x5e, 0xb6, 0x97, 0xb1, 0xf2, 0xf7, 0x57, 0x31, 0x80, 0xb8, 0x52, 0x61, 0x58, 0x41, 0xf6, 0xb9, 0xdc, 0x8e, 0x5b, 0xe4, 0x5, 0x19, 0xe9, 0xc2, 0xc7, 0x82, 0xfd, 0x0, 0x69, 0xb8, 0xd3, 0xb2, 0xac, 0xa3, 0x38, 0x53, 0xcd, 0x29, 0xcd, 0xb1, 0xfe, 0xc7, 0x35, 0xd2, 0x66, 0xab, 0x25, 0xef, 0xe2, 0xa0, 0xfd, 0x47, 0x47, 0x6e, 0x5c, 0xc1, 0x17, 0x3e, 0x97, 0x17, 0xbf, 0x40, 0x2c, 0x2, 0x84, 0x3e, 0x56, 0xbc, 0x70, 0xd9, 0x56, 0xa3, 0xda, 0xeb, 0xb0, 0xeb, 0x5f, 0x2, 0xa4, 0x2, 0x1e, 0x62, 0x59, 0xdf, 0x33, 0xb6, 0x5a, 0x36, 0x33, 0x65, 0xab, 0x7e, 0xae, 0xab, 0x33, 0x20, 0x71, 0x68, 0x42, 0xe7, 0xa, 0x86, 0xd3, 0xef, 0xa3, 0x55, 0xc, 0x59, 0xbc, 0xe, 0x14, 0xb0, 0x5e, 0x38, 0xab, 0x9c, 0x4e, 0x38, 0xfe, 0x9e, 0x7d, 0xcf, 0x9b, 0x30, 0x2, 0xef, 0x85, 0xb, 0x78, 0x99, 0xa0, 0xe1, 0x75, 0x39, 0x35, 0x9a, 0xd4, 0x32, 0x2d, 0x1d, 0x53, 0xaf, 0xbf, 0x9e, 0xc4, 0x5e, 0x1a, 0x63, 0x7e, 0x4f, 0xb, 0xa1, 0xd, 0x9d, 0x3b, 0x24, 0x4c, 0xd9, 0xf, 0xdb, 0xb4, 0x4f, 0x9e, 0x72, 0x0, 0xdc, 0xa9, 0x87, 0xb1, 0xa5, 0xe1, 0x25, 0x5c, 0x83, 0x3f, 0x3f, 0x9d, 0x5a, 0xf3, 0x50, 0x44, 0x79, 0xd6, 0xa9, 0x0, 0xd3, 0x19, 0x6, 0x64, 0xab, 0x93, 0x75, 0x54, 0x78, 0xcc, 0xe9, 0xa1, 0x60, 0xad, 0x79, 0x3d, 0x20, 0x61, 0xfe, 0x3b, 0xf8, 0xc2, 0x8e, 0x60, 0x11, 0x72, 0xd2, 0xb4, 0x68, 0x5d, 0x51, 0x70, 0x83, 0x14, 0x8c, 0x13, 0x68, 0xc4, 0xd8, 0x53, 0xb3, 0xa4, 0x18, 0x27, 0x20, 0xd4, 0x7c, 0xc7, 0x36, 0x3d, 0x95, 0x61, 0xef, 0x31, 0xf3, 0xc1, 0x8, 0xbb, 0x9f, 0x66, 0x42, 0xa3, 0x4f, 0xf3, 0x88, 0x46, 0xf3, 0x84, 0x64, 0x77, 0x1f, 0x49, 0x43, 0x47, 0x83, 0x9a, 0xb0, 0x72, 0xe8, 0xe9, 0xb7, 0x88, 0xce, 0xa5, 0x3, 0x30, 0xff, 0x72, 0x97, 0xf9, 0x42, 0x8f, 0x97, 0xd0, 0x95, 0xf7, 0x76, 0xb9, 0xde, 0x59, 0xe, 0x65, 0x50, 0xdf, 0xe2, 0xf3, 0x32, 0x73, 0xa3, 0x6d, 0x6a, 0x20, 0x11, 0x3, 0x97, 0x30, 0x32, 0x14, 0x74, 0x74, 0x33, 0x5a, 0x63, 0xe8, 0x3f, 0x4, 0xd7, 0xdb, 0xb9, 0x40, 0xf3, 0x89, 0x19, 0xbb, 0x45, 0xfc, 0xf7, 0xa4, 0xd2, 0xef, 0x84, 0x6e, 0xb2, 0x4f, 0xdc, 0x4d, 0xa6, 0x5d, 0xe5, 0x3e, 0x29, 0x22, 0xac, 0x7, 0xe1, 0x77, 0xf0, 0xfe, 0x1e, 0x65, 0xe8, 0x2c, 0xda, 0xf8, 0xf6, 0x59, 0x48, 0xeb, 0x1e, 0xaa, 0x3, 0x1f, 0x3, 0x71, 0xbc, 0x49, 0xf5, 0x47, 0xee, 0xce, 0x7c, 0x4c, 0xe9, 0x5, 0xae, 0x97, 0xee, 0x7d, 0xbb, 0xc7, 0x8a, 0xb3, 0x47, 0x57, 0x7a, 0xe3, 0x98, 0x51, 0x21, 0xfe, 0xb8, 0x11, 0x0, 0xd2, 0xbe, 0x2e, 0x57, 0x71, 0xc4, 0x11, 0x8f, 0x24, 0xe, 0xae, 0xbc, 0x3c, 0xed, 0xc9, 0x11, 0xec, 0x75, 0x88, 0x35, 0x9d, 0xa1, 0x89, 0x8, 0xee, 0x3d, 0x83, 0x2, 0xd5, 0xe5, 0x44, 0x38, 0x1b, 0x66, 0xdb, 0xed, 0x78, 0x5d, 0xd6, 0x84, 0xcd, 0xd, 0xb2, 0x74, 0xe6, 0x48, 0xad, 0xfc, 0xc3, 0x6a, 0xc8, 0x70, 0xdb, 0x86, 0x89, 0xdc, 0xcf, 0xea, 0x3c, 0xa0, 0x97, 0x11, 0xb0, 0xbf, 0xc3, 0x2c, 0x8b, 0x7f, 0x6, 0x76, 0xd6, 0x5d, 0x63, 0x76, 0x14, 0x22, 0xf0, 0x77, 0xc9, 0xcc, 0xaa, 0x2e, 0xc8, 0xb, 0xbd, 0xf7, 0x42, 0x62, 0x9e, 0xfa, 0x5d, 0x9c, 0x4c, 0xe5, 0xb3, 0x23, 0x8e, 0xcc, 0x5, 0xe1, 0x80, 0x4a, 0x7c, 0x4, 0x4b, 0xae, 0x3b, 0xb4, 0xdc, 0x3a, 0xd6, 0xaa, 0x3c, 0x59, 0x2f, 0x71, 0xda, 0x7f, 0x54, 0x81, 0x48, 0xaa, 0x11, 0xf3, 0x52, 0xd2, 0xf0, 0xd0, 0x9b, 0x84, 0xfb, 0x8f, 0x5b, 0xe6, 0x29, 0xc3, 0xaa, 0x7c, 0x68, 0xd9, 0x80, 0x29, 0x4a, 0x6a, 0x17, 0x26, 0x69, 0xbe, 0x5d, 0x98, 0x75, 0x88, 0x1, 0x4b, 0xdc, 0x1e, 0x91, 0x74, 0x63, 0xb8, 0x29, 0xed, 0x62, 0x3b, 0x87, 0xbc, 0x5f, 0xf2, 0x6, 0x75, 0xdf, 0x37, 0xbe, 0x1, 0x97, 0xa5, 0xe2, 0xf4, 0x88, 0x91, 0xe6, 0xca, 0xdd, 0x2e, 0xd8, 0x60, 0xce, 0x15, 0x43, 0x54, 0xd4, 0x85, 0x4e, 0x6d, 0x8, 0xf0, 0xa2, 0x8e, 0x67, 0x3c, 0x7a, 0x15, 0x2f, 0xf2, 0xfe, 0xb7, 0x63, 0x4f, 0x0, 0x85, 0xfb, 0xca, 0xb1, 0xfb, 0x20, 0x5c, 0xcf, 0x36, 0x60, 0xfa, 0x28, 0x8f, 0x5d, 0x21, 0x42, 0x12, 0x34, 0x3b, 0x54, 0x85, 0x93, 0x4a, 0x25, 0x6f, 0x4, 0x33, 0x96, 0xa0, 0x39, 0x53, 0x9c, 0xda, 0x52, 0xdb, 0x6c, 0x47, 0xa3, 0xab, 0x7e, 0x23, 0x74, 0xcb, 0x28, 0x70, 0xe1, 0x4c, 0xa6, 0x42, 0x33, 0x12, 0xd2, 0xa9, 0xc4, 0x8f, 0x67, 0x35, 0x2e, 0x1e, 0xa2, 0x73, 0x27, 0x7, 0xca, 0x11, 0x78, 0x5d, 0x8c, 0x27, 0x35, 0x1c, 0xa7, 0x69, 0x14, 0x1d, 0x20, 0x90, 0xe7, 0x94, 0x72, 0x64, 0x5a, 0xf2, 0x72, 0x9c, 0x15, 0x84, 0x79, 0xb4, 0xd1, 0x38, 0xb1, 0xbc, 0xea, 0xac, 0x70, 0xab, 0x7d, 0xd2, 0x21, 0xbd, 0x89, 0xee, 0xdd, 0x8e, 0x15, 0x32, 0x15, 0xe5, 0x22, 0xc8, 0x37, 0xd7, 0x55, 0x4f, 0x45, 0xe8, 0x87, 0x7b, 0x65, 0x44, 0xf7, 0x7, 0x1d, 0x45, 0xe7, 0xec, 0x54, 0x5f, 0x7f, 0x9b, 0xb2, 0x7d, 0xb9, 0x5e, 0x9a, 0xb2, 0x29, 0x8c, 0x8a, 0x51, 0x3d, 0x2a, 0x2f, 0xf8, 0x82, 0x8f, 0x24, 0x39, 0x82, 0xfd, 0xf2, 0x3e, 0x48, 0x29, 0xd0, 0xfd, 0x81, 0x1e, 0x9c, 0x19, 0xe7, 0xb2, 0x96, 0xd, 0x8c, 0x97, 0x6e, 0x3e, 0xe6, 0x53, 0x78, 0x8c, 0x26, 0x26, 0x92, 0x21, 0xb, 0x5d, 0x10, 0x5c, 0x73, 0x26, 0x8f, 0x92, 0xa5, 0xb2, 0xec, 0xf6, 0xc2, 0x83, 0xd8, 0x58, 0x74, 0xb5, 0xae, 0x3f, 0x37, 0xbd, 0xc5, 0x20, 0xe2, 0xf4, 0x17, 0x5f, 0xcf, 0xb2, 0x17, 0x5c, 0x57, 0xf4, 0x60, 0x96, 0xf9, 0xee, 0xa1, 0xe0, 0xc7, 0x60, 0x80, 0xc7, 0x65, 0xc7, 0x51, 0x93, 0xa9, 0x56, 0x3e, 0xd5, 0xad, 0x6e, 0xa, 0xae, 0xa, 0xb0, 0xf3, 0xf9, 0x44, 0x59, 0xae, 0x4b, 0x9a, 0xb0, 0xba, 0xaf, 0x30, 0x2e, 0x70, 0xc0, 0x8d, 0x58, 0xc1, 0xe1, 0xda, 0x83, 0x8, 0xfd, 0xca, 0x1b, 0xab, 0x17, 0x2a, 0xeb, 0x7, 0xd3, 0x7e, 0x79, 0xaf, 0xee, 0x3f, 0x30, 0x67, 0xdd, 0xad, 0x92, 0xbd, 0x4f, 0x51, 0xf5, 0x1e, 0xc8, 0xe6, 0x47, 0xb2, 0x12, 0xff, 0x9, 0x7, 0xc9, 0x7, 0x8c, 0xdd, 0xbd, 0x40, 0x59, 0xfd, 0xf2, 0x23, 0x50, 0x24, 0x1c, 0xa5, 0x8, 0x93, 0x54, 0x42, 0x46, 0x3a, 0x6c, 0x23, 0xac, 0x28, 0xb2, 0xc2, 0xa9, 0x68, 0xa7, 0xdb, 0x22, 0xe8, 0xe7, 0xd4, 0xcc, 0x9d, 0xcb, 0x3f, 0xb1, 0x17, 0x97, 0x43, 0x9c, 0xc0, 0x9, 0x5f, 0x45, 0xd2, 0x1e, 0x7, 0x53, 0x90, 0xce, 0x34, 0x83, 0xdc, 0xd0, 0x94, 0x63, 0xa4, 0xe9, 0x77, 0xb5, 0x6c, 0xa1, 0x9f, 0xfe, 0x4c, 0x6f, 0xba, 0x28, 0x87, 0x4d, 0x96, 0xac, 0x2c, 0x66, 0xb6, 0x57, 0x31, 0x43, 0x3, 0xaa, 0x68, 0x83, 0x92, 0x62, 0x73, 0x3e, 0x90, 0x3f, 0x7, 0x4a, 0x14, 0x63, 0xa2, 0xdd, 0xc8, 0xea, 0x1, 0x6f, 0x68, 0x2, 0xf9, 0x17, 0x61, 0x4c, 0x3c, 0xf4, 0x4d, 0xae, 0x4b, 0x4f, 0x6e, 0x78, 0xf5, 0x6, 0x21, 0xb0, 0x17, 0xb6, 0xd4, 0x22, 0x65, 0x99, 0x7f, 0x59, 0x6e, 0xbf, 0xd7, 0xc1, 0x38, 0x8b, 0xdf, 0xef, 0x98, 0x3c, 0xc9, 0x1b, 0x9f, 0x98, 0xc1, 0x7f, 0x85, 0xc1, 0x0, 0xcb, 0x37, 0xdc, 0x40, 0xc3, 0x1f, 0xfa, 0xf2, 0xc8, 0x82, 0xa2, 0x71, 0xc7, 0xf6, 0xdd, 0xfa, 0x94, 0xbf, 0x69, 0xc7, 0xe5, 0xc, 0xb6, 0xd7, 0x8e, 0x48, 0x9f, 0x6d, 0xdf, 0xd2, 0x6e, 0x34, 0xed, 0xbd, 0xc9, 0xa6, 0xfe, 0xa4, 0xff, 0xcb, 0x76, 0x78, 0xfa, 0x60, 0x9c, 0x8d, 0x0, 0x69, 0x33, 0xf4, 0xbe, 0xcb, 0x85, 0x28, 0x3b, 0x13, 0xc0, 0x4c, 0x6a, 0x27, 0xa8, 0x9b, 0xc, 0x2c, 0xd2, 0x71, 0x25, 0xde, 0xc2, 0xc4, 0x96, 0x46, 0x49, 0x62, 0x88, 0xeb, 0xb1, 0x62, 0xce, 0xc4, 0xd5, 0xa3, 0xe, 0x3b, 0x83, 0xa9, 0xb, 0x54, 0xac, 0x61, 0x81, 0x2a, 0x90, 0x80, 0x14, 0xf9, 0xd2, 0x2c, 0xa2, 0x1f, 0x98, 0xc1, 0x23, 0x57, 0x2, 0x89, 0x71, 0x90, 0xe, 0x57, 0xac, 0xf8, 0xeb, 0xf0, 0x95, 0x68, 0x7e, 0x2d},
+               output224: []byte{0xae, 0x53, 0x34, 0xfb, 0x23, 0x39, 0xd2, 0x88, 0xd3, 0x73, 0xf4, 0x36, 0x73, 0x25, 0xf6, 0xa0, 0x6a, 0x3e, 0x78, 0x16, 0x9b, 0xf8, 0x1b, 0x3c, 0xca, 0x8, 0x8a, 0x82},
+               output256: []byte{0x62, 0xe8, 0x37, 0xa8, 0x3d, 0x1c, 0xc3, 0xf6, 0x30, 0x64, 0x20, 0xf0, 0x91, 0xea, 0x71, 0xf6, 0x1d, 0xdc, 0x73, 0xe4, 0xbc, 0x1d, 0x3a, 0xd6, 0x38, 0xae, 0x28, 0xda, 0xae, 0x69, 0xb5, 0x83},
+               output384: []byte{0x68, 0x7a, 0xb7, 0xc4, 0xb4, 0xda, 0xc4, 0xa, 0xf8, 0x40, 0x80, 0xb3, 0xea, 0x25, 0x13, 0x7c, 0x1, 0xb0, 0x7b, 0x54, 0x66, 0x51, 0xdd, 0xbf, 0xa9, 0x8f, 0x35, 0x9e, 0xea, 0xf3, 0x4, 0x31, 0x3d, 0xd2, 0x7b, 0x95, 0x50, 0x0, 0xaa, 0x7b, 0x35, 0x66, 0x50, 0xf6, 0x85, 0x4c, 0x67, 0xee},
+               output512: []byte{0xe, 0xd0, 0x15, 0x74, 0xe6, 0x5, 0x4a, 0x13, 0xdc, 0x63, 0x67, 0xfc, 0x47, 0xda, 0xa2, 0x42, 0x8, 0xf0, 0x25, 0x11, 0x51, 0x48, 0x84, 0x5b, 0x4, 0xb4, 0xa, 0xc2, 0x38, 0xf6, 0x15, 0x89, 0x37, 0x8d, 0xc1, 0x9c, 0x65, 0x2a, 0x50, 0x91, 0xd0, 0xc7, 0xf9, 0x25, 0xff, 0x1d, 0x5c, 0x7e, 0x6, 0x27, 0x28, 0xae, 0xf4, 0x6, 0xa2, 0xad, 0x75, 0xf6, 0x1f, 0xb8, 0x78, 0xfb, 0x5e, 0x78}},
+       testcase{
+               msg:       []byte{0x6, 0x72, 0x90, 0x47, 0xc0, 0xd4, 0xa7, 0xb3, 0x2, 0x8, 0x65, 0xf5, 0x27, 0xf0, 0x65, 0x7e, 0xa5, 0x39, 0x7e, 0xb5, 0x80, 0x90, 0xab, 0xd0, 0x19, 0x12, 0xc4, 0x85, 0xe7, 0x38, 0x54, 0xaa, 0x9a, 0xa0, 0x39, 0x4c, 0xb5, 0x3d, 0x53, 0xe3, 0xd2, 0x40, 0xd1, 0xbd, 0x6c, 0xbd, 0x1e, 0x1e, 0x35, 0x35, 0x29, 0xcb, 0x87, 0x83, 0x3b, 0x5f, 0x47, 0x64, 0x83, 0xe6, 0x84, 0xf1, 0x17, 0x48, 0xd5, 0xab, 0x7a, 0x1f, 0x18, 0xf5, 0xb7, 0x6e, 0x59, 0x38, 0x45, 0x84, 0x86, 0xd4, 0xd5, 0xb1, 0xfe, 0x1a, 0xf7, 0xec, 0x2a, 0x13, 0x9c, 0xf5, 0xc4, 0xb7, 0x55, 0x16, 0x5e, 0x18, 0x2f, 0x23, 0xb9, 0xe6, 0x9e, 0xde, 0xdc, 0x39, 0x37, 0x5f, 0xf, 0x87, 0xb2, 0x4d, 0xab, 0x23, 0x30, 0x49, 0xdb, 0xb, 0x34, 0x62, 0x7d, 0x53, 0xda, 0xba, 0xd0, 0xac, 0x33, 0x51, 0xfd, 0xd9, 0x40, 0x10, 0xdb, 0x51, 0xad, 0x31, 0x82, 0xf1, 0xb1, 0x27, 0x6c, 0x49, 0x82, 0x96, 0xdd, 0xd7, 0x59, 0xad, 0xc3, 0x38, 0x4e, 0xe9, 0x49, 0xe4, 0xb2, 0xb6, 0x41, 0x2c, 0xfe, 0x3e, 0x8e, 0xf7, 0x69, 0xdc, 0xaf, 0x76, 0xbe, 0x4b, 0x2f, 0xed, 0xce, 0x5, 0x45, 0x15, 0xee, 0x24, 0xf7, 0x60, 0x1e, 0xb1, 0x55, 0x35, 0x16, 0x18, 0x79, 0x54, 0xbc, 0x6, 0x89, 0xef, 0x27, 0x80, 0x71, 0xea, 0x7b, 0x95, 0xd5, 0x8e, 0x7f, 0xf2, 0x11, 0x6b, 0x45, 0x7, 0x28, 0xe4, 0x75, 0x71, 0x14, 0xa, 0xb1, 0xa, 0x32, 0x7c, 0x8e, 0x6d, 0x33, 0x3e, 0xf0, 0x44, 0xdf, 0xa1, 0x8, 0x66, 0xa8, 0x2b, 0x97, 0x28, 0xd3, 0xf5, 0xf3, 0x43, 0xe1, 0xb3, 0x30, 0x64, 0xe1, 0xe8, 0x60, 0x88, 0x1d, 0xf0, 0x5d, 0x78, 0xb7, 0x7b, 0x1f, 0x36, 0x3d, 0xa7, 0xd3, 0xee, 0x42, 0x9, 0xe8, 0xe2, 0x42, 0x6b, 0x69, 0x69, 0xb5, 0x54, 0x4a, 0xfd, 0x81, 0x34, 0x3f, 0xaa, 0xce, 0xe9, 0x15, 0x26, 0x9c, 0x6d, 0x3b, 0x12, 0xc2, 0x2f, 0x2a, 0x5f, 0xa4, 0xe7, 0xa5, 0x18, 0xc5, 0x53, 0x92, 0x28, 0x37, 0x31, 0x92, 0xf8, 0x5d, 0x81, 0x23, 0x10, 0x5b, 0x4, 0xc2, 0x86, 0x6d, 0xeb, 0x89, 0x67, 0xe7, 0xce, 0xc3, 0xc0, 0xfc, 0xce, 0xda, 0x19, 0xfd, 0xb8, 0x4c, 0x72, 0x59, 0x7e, 0xe, 0xdf, 0xee, 0xc6, 0x20, 0xf8, 0x38, 0xe, 0x3c, 0xd5, 0xb5, 0xac, 0x20, 0x53, 0xea, 0xe4, 0x4, 0xcd, 0x60, 0x52, 0xaa, 0xe7, 0xbc, 0x7c, 0x66, 0x66, 0x28, 0xaa, 0xc1, 0xfc, 0x72, 0x22, 0x44, 0xa6, 0xe8, 0x5, 0x36, 0x24, 0x6c, 0x98, 0x94, 0xc4, 0x7b, 0xdc, 0xda, 0x71, 0xc2, 0x39, 0xe2, 0xfd, 0x27, 0x6e, 0x6e, 0x4, 0x1d, 0xf8, 0xa9, 0x30, 0x63, 0x9f, 0x79, 0x93, 0x30, 0xd, 0x68, 0xfd, 0xa7, 0xe2, 0xea, 0xcb, 0x31, 0xf, 0x49, 0xd4, 0x80, 0x49, 0xa8, 0xb6, 0xb1, 0xbe, 0x42, 0xfe, 0xd5, 0xbb, 0x26, 0x17, 0x9d, 0x6e, 0x43, 0x28, 0xe6, 0x4, 0x11, 0xaf, 0xa7, 0xbb, 0xea, 0x12, 0x2e, 0xa9, 0x3, 0x74, 0x50, 0xd8, 0xe, 0x5f, 0xdf, 0x13, 0xc9, 0x3b, 0xb7, 0x19, 0xb, 0xf4, 0x47, 0xe3, 0x0, 0x8a, 0x34, 0xec, 0xa6, 0xea, 0xe0, 0x8a, 0xc7, 0x1a, 0x54, 0x46, 0xbb, 0x56, 0x8d, 0x4d, 0xf8, 0xca, 0x45, 0x12, 0xb9, 0xbb, 0xef, 0x21, 0x64, 0x8a, 0xcf, 0x2d, 0xfe, 0xc9, 0x5c, 0xd2, 0xd2, 0x98, 0x5c, 0x97, 0xc4, 0x61, 0xda, 0x65, 0x1c, 0x1c, 0x87, 0xdf, 0xae, 0x35, 0x66, 0x8c, 0x0, 0x80, 0x1, 0x1, 0x7a, 0x48, 0x29, 0x2b, 0x4b, 0xb, 0x5, 0xc, 0x0, 0x12, 0x44, 0x46, 0x59, 0x4f, 0xb2, 0x7a, 0x41, 0x8e, 0x35, 0x49, 0x17, 0x1d, 0x15, 0x1e, 0x57, 0x94, 0x7, 0xa, 0xca, 0xaa, 0xa9, 0x7b, 0x88, 0x4, 0x5a, 0xeb, 0x3b, 0xdf, 0xfe, 0xa9, 0xcb, 0x33, 0x72, 0x95, 0xc, 0xdd, 0x72, 0x73, 0x50, 0xee, 0xfd, 0xf0, 0x6e, 0x76, 0x52, 0xbc, 0xd1, 0x91, 0x3, 0x12, 0xb3, 0x5f, 0x5d, 0x4e, 0xf3, 0xb8, 0x41, 0x8b, 0xbe, 0xeb, 0x52, 0x65, 0x7a, 0x36, 0xcc, 0xb7, 0x97, 0x9c, 0xca, 0xbe, 0xc0, 0xc4, 0xb2, 0xd2, 0x20, 0x14, 0xf6, 0xf, 0xe, 0x84, 0x7d, 0xed, 0x96, 0x69, 0x8a, 0x81, 0xa7, 0xf2, 0xf3, 0xe3, 0x59, 0x32, 0xcc, 0x5d, 0x34, 0xd3, 0xa5, 0xec, 0x36, 0x65, 0x7, 0xdc, 0xf1, 0x79, 0x30, 0x9c, 0x1f, 0x4d, 0xe6, 0x1, 0x88, 0x6, 0x28, 0x48, 0x76, 0xa9, 0x6c, 0xc9, 0xbc, 0x54, 0xfb, 0x5d, 0x9e, 0x5b, 0x31, 0x27, 0xc7, 0x47, 0x23, 0xe0, 0xc3, 0xaf, 0x1f, 0xff, 0xb0, 0x1e, 0x4e, 0xde, 0x2c, 0x59, 0x41, 0x3f, 0x1f, 0xf5, 0x6f, 0x83, 0x46, 0xc7, 0x1e, 0x30, 0xde, 0x5a, 0x66, 0xfe, 0x94, 0x87, 0x8c, 0xd, 0x7a, 0x21, 0x7d, 0x75, 0x4c, 0x94, 0xa7, 0xc3, 0xac, 0xae, 0x3a, 0xd2, 0x64, 0xa3, 0xd2, 0xc7, 0xdf, 0x93, 0xaa, 0x29, 0xb4, 0xe0, 0xa1, 0xab, 0x96, 0x6e, 0x36, 0xfc, 0x8a, 0x81, 0xcd, 0xde, 0x9c, 0x49, 0x2e, 0x4a, 0x9, 0xa9, 0xc6, 0x1e, 0x63, 0xc5, 0x40, 0xa4, 0x57, 0x48, 0x9c, 0x7c, 0xe6, 0xd9, 0xef, 0x30, 0x46, 0xc7, 0x78, 0x12, 0xb9, 0x72, 0x37, 0x83, 0x3d, 0xa0, 0xd8, 0xe6, 0xda, 0x30, 0x3, 0x2, 0x21, 0xc, 0xc0, 0x9, 0xf3, 0x9b, 0xea, 0xaa, 0xe, 0xd1, 0xaa, 0x10, 0x7f, 0xf0, 0xc0, 0x6d, 0x21, 0xc, 0xa6, 0x78, 0xac, 0xd3, 0x57, 0x70, 0x9b, 0x25, 0x24, 0x2d, 0xa3, 0xde, 0x14, 0x4b, 0xb3, 0x97, 0xd9, 0xa3, 0xcf, 0x84, 0x41, 0x3, 0x97, 0x66, 0x40, 0x7a, 0x67, 0xbc, 0x92, 0x97, 0xc1, 0x8, 0xe7, 0xa1, 0x1e, 0x98, 0xb0, 0x90, 0x46, 0xb4, 0x86, 0x6c, 0x9a, 0x91, 0x28, 0x17, 0xb6, 0x56, 0x8a, 0x4, 0xce, 0x10, 0xf4, 0x3b, 0xac, 0x7b, 0xf2, 0x11, 0xda, 0xeb, 0x90, 0xec, 0x1a, 0x28, 0x14, 0x37, 0xb5, 0x5f, 0x88, 0xc6, 0xe8, 0x83, 0xef, 0x9a, 0x27, 0x1d, 0x85, 0x73, 0xea, 0xcd, 0x96, 0x53, 0x60, 0xfd, 0x8f, 0x84, 0xda, 0xdd, 0x72, 0xea, 0xa1, 0x23, 0x77, 0xa7, 0xe1, 0xf4, 0x7f, 0xa4, 0x9b, 0xd7, 0xc3, 0x96, 0x1a, 0x15, 0xef, 0x5c, 0x31, 0x1c, 0xe6, 0x2c, 0xcb, 0x43, 0x3, 0x2c, 0xd8, 0x6c, 0x50, 0x9a, 0x10, 0xe, 0xf8, 0xa2, 0x50, 0xee, 0x84, 0xb9, 0xf7, 0xf9, 0x73, 0x1, 0x96, 0xa8, 0x6a, 0xde, 0xe9, 0x2f, 0xa9, 0x32, 0x33, 0xb2, 0xe3, 0x2c, 0x87, 0xaf, 0x90, 0x91, 0x5b, 0x23, 0xb4, 0x4c, 0xda, 0x91, 0x86, 0xdd, 0x51, 0xeb, 0x9a, 0x4, 0x9c, 0x47, 0x8c, 0x2a, 0x5b, 0x36, 0x38, 0x31, 0xac, 0x5f, 0xd1, 0x70, 0xdc, 0x84, 0x31, 0x24, 0x40, 0xaa, 0x8c, 0x83, 0xb7, 0xfc, 0x44, 0x25, 0x4b, 0xe6, 0xf4, 0xe8, 0x1f, 0xf2, 0xd6, 0x6f, 0x57, 0xb1, 0x2d, 0x78, 0x90, 0x5b, 0x89, 0x60, 0xe, 0x53, 0x77, 0x54, 0xa4, 0x6c, 0xc5, 0xb6, 0xc5, 0xce, 0x2b, 0x6b, 0x4, 0xf8, 0xd6, 0xf1, 0xcb, 0x60, 0x35, 0x95, 0x39, 0x2, 0x3b, 0xaf, 0xc7, 0x8a, 0xa0, 0xe8, 0x34, 0xba, 0x87, 0x9, 0x43, 0x3f, 0x8c, 0x6f, 0xa, 0xdd, 0x3d, 0x4d, 0x74, 0x3f, 0x4b, 0x6f, 0xb4, 0x84, 0xc1, 0xa, 0x42, 0x67, 0x50, 0x50, 0x97, 0x8, 0x2f, 0x30, 0xba, 0x7d, 0xb8, 0x1b, 0xdb, 0x24, 0x76, 0xca, 0xe4, 0x52, 0xb4, 0xf, 0x67, 0x40, 0x95, 0x36, 0x14, 0x14, 0x28, 0xb2, 0x64, 0xcd, 0xb8, 0x32, 0xd1, 0xd6, 0x11, 0xce, 0xfb, 0x5d, 0x4d, 0x13, 0x26, 0x42, 0x8f, 0x97, 0x78, 0xf9, 0x29, 0xc8, 0xc1, 0x82, 0x34, 0x60, 0x42, 0xcf, 0xa5, 0xfa, 0xff, 0x8, 0x19, 0x66, 0x7e, 0xf4, 0xed, 0x29, 0xe8, 0xd9, 0x22, 0x79, 0xa2, 0x99, 0x95, 0x45, 0xc3, 0x33, 0x52, 0x85, 0xf0, 0x72, 0xdc, 0x95, 0x2e, 0x7c, 0x7f, 0xc1, 0x11, 0x6e, 0xd0, 0xc5, 0x11, 0x5c, 0x6c, 0xe7, 0xad, 0xc9, 0x93, 0xc2, 0x3a, 0x8b, 0xc, 0x96, 0xc2, 0x88, 0x4f, 0x70, 0x81, 0x7b, 0x5c, 0x90, 0x63, 0xc7, 0x5f, 0xf1, 0x87, 0x5a, 0x7b, 0x8, 0xb, 0x76, 0xb9, 0xaa, 0x32, 0xe6, 0xf7, 0xe4, 0xe8, 0x46, 0x4a, 0xfa, 0x40, 0xf7, 0x12, 0x3a, 0xc7, 0x9c, 0x45, 0xd8, 0x8d, 0xaa, 0xc7, 0x1d, 0x76, 0xf7, 0x95, 0xf1, 0x92, 0xc6, 0xce, 0xbd, 0xe8, 0xc9, 0x9f, 0x10, 0xce, 0xb9, 0xe9, 0xf, 0x2, 0x2e, 0x58, 0x1, 0xa7, 0x89, 0x22, 0xf3, 0x89, 0x72, 0x5b, 0xb2, 0x36, 0xaf, 0xb5, 0xdc, 0x28, 0xcb, 0xbf, 0x1c, 0x9b, 0xe9, 0x61, 0x7c, 0xea, 0x56, 0xc8, 0xc, 0x53, 0x1b, 0xb7, 0xac, 0x22, 0x7f, 0x6b, 0x99, 0x6c, 0x68, 0x58, 0x3b, 0x74, 0xbf, 0xf7, 0x8e, 0xf4, 0x4d, 0x18, 0x5e, 0xd, 0xe, 0x5e, 0x9d, 0x6f, 0x34, 0xb2, 0x50, 0xdc, 0xc4, 0x63, 0x9e, 0x3a, 0x1a, 0x93, 0x7c, 0xdb, 0x96, 0xe7, 0x8a, 0x21, 0x7e, 0x3, 0xac, 0x90, 0x8, 0x34, 0xb4, 0xab, 0xaa, 0x49, 0x5c, 0x9b, 0xd9, 0xdb, 0xc2, 0xc4, 0xe8, 0x54, 0x63, 0xcd, 0x1c, 0x6d, 0x1f, 0x4d, 0x87, 0x46, 0xee, 0x4b, 0x58, 0xba, 0xd7, 0x8c, 0xbe, 0xe2, 0x1c, 0xa3, 0xe5, 0x3e, 0x6b, 0x6d, 0x42, 0x64, 0x5f, 0xb9, 0x6c, 0x94, 0x17, 0xa3, 0x74, 0xeb, 0x62, 0xdf, 0x7f, 0x7d, 0x23, 0x98, 0x3b, 0x53, 0xe1, 0xda, 0x75, 0x44, 0x87, 0xf3, 0xc0, 0x71, 0x17, 0x12, 0x49, 0x9d, 0xae, 0xea, 0x9e, 0x6a, 0xb9, 0x39, 0xcb, 0xeb, 0xea, 0x79, 0xd5, 0xb9, 0xc7, 0x29, 0x9c, 0x6, 0xce, 0x53, 0xcc, 0x8b, 0xc, 0x8f, 0x83, 0x81, 0xe0, 0x4c, 0x52, 0x5c, 0xc6, 0x91, 0x44, 0x33, 0x18, 0xb7, 0xe, 0x44, 0x7e, 0x83, 0xf4, 0x85, 0xe1, 0x8e, 0xbe, 0x45, 0x24, 0xdf, 0xf, 0xe0, 0xf4, 0x7e, 0xcb, 0xba, 0x87, 0xee, 0xfe, 0x4f, 0x70, 0x9b, 0x7c, 0x84, 0x27, 0x4f, 0x3, 0x7e, 0x89, 0xd3, 0xe1, 0x40, 0xdc, 0x2b, 0xd6, 0x8, 0xf8, 0xbc, 0xd5, 0xf5, 0x1b, 0x3f, 0xbf, 0x4e, 0xf9, 0x3e, 0xdb, 0xd4, 0x5a, 0xa7, 0xae, 0x53, 0x26, 0xd1, 0x8b, 0x71, 0x9a, 0x5d, 0xc6, 0xae, 0x91, 0x40, 0xe, 0x2b, 0x6c, 0x88, 0xe6, 0x99, 0xc9, 0xf9, 0xa9, 0x5b, 0xab, 0xe3, 0x3e, 0x98, 0x39, 0x7f, 0x77, 0xfb, 0xf, 0xcc, 0xea, 0x59, 0xf3, 0xbc, 0x2, 0xa4, 0x79, 0xe6, 0xfe, 0x10, 0x59, 0xdf, 0xed, 0x54, 0x66, 0x44, 0xdf, 0xbe, 0xc3, 0xf2, 0xf, 0xbd, 0xf4, 0xaa, 0x53, 0xd0, 0x25, 0xc6, 0x6d, 0xab, 0x24, 0x87, 0x50, 0x21, 0xd7, 0x93, 0x4e, 0xcb, 0xcc, 0x6, 0x19, 0xaa, 0xbe, 0x7f, 0x55, 0x3c, 0x92, 0x87, 0xdd, 0x6f, 0xb9, 0x16, 0xd2, 0xc5, 0xb8, 0xda, 0x77, 0x55, 0x5d, 0x91, 0x59, 0x7d, 0x89, 0x5b, 0x9f, 0x8e, 0xc, 0x60, 0x1e, 0xbc, 0xd3, 0x83, 0x64, 0xc9, 0x1f, 0x28, 0x44, 0x5c, 0xe0, 0x9d, 0x44, 0x5a, 0x9e, 0x71, 0x49, 0x3f, 0xe3, 0x5f, 0xf7, 0x23, 0x14, 0x9e, 0x73, 0xde, 0xa9, 0xee, 0xd1, 0xe1, 0x95, 0x17, 0xb5, 0xa7, 0x35, 0xf7, 0xab, 0xd8, 0xd9, 0x2d, 0x45, 0x47, 0x2e, 0xef, 0x1d, 0x2c, 0x4e, 0xaa, 0xad, 0x6f, 0xdb, 0xbe, 0x95, 0x70, 0x95, 0xb, 0xee, 0x94, 0x61, 0x3a, 0xe2, 0xa9, 0x34, 0xe1, 0xa2, 0xc7, 0xee, 0x89, 0x9f, 0x28, 0x61, 0xae, 0x17, 0xbf, 0x8d, 0x60, 0xfc, 0xc1, 0x0, 0x5a, 0xbe, 0xc7, 0x24, 0xc, 0x7e, 0xf9, 0x8e, 0x7d, 0xf4, 0x42, 0xe5, 0x87, 0xfe, 0x24, 0x7, 0xcd, 0xed, 0xaf, 0x6c, 0x4a, 0xd7, 0x25, 0xfe, 0x54, 0xac, 0x88, 0xa, 0x47, 0x53, 0xe, 0x8, 0xb6, 0x45, 0x2f, 0x5d, 0x9d, 0x4, 0x48, 0x33, 0xcd, 0x11, 0x7e, 0xe4, 0xe1, 0xa2, 0x42, 0xfd, 0xc0, 0x75, 0x45, 0xaa, 0x74, 0xb5, 0x59, 0xd3, 0x94, 0xd8, 0x37, 0xe5, 0x5e, 0xbf, 0x7, 0xfd, 0x2d, 0x67, 0x71, 0x81, 0x1d, 0xf9, 0x57, 0x91, 0xe2, 0x93, 0xa5, 0x2a, 0x97, 0x2b, 0x68, 0x24, 0x46, 0xa2, 0x9c, 0x4c, 0xe3, 0xe0, 0x2f, 0x71, 0x56, 0x5d, 0x53, 0x7d, 0x12, 0xee, 0xe2, 0x1e, 0x1f, 0xf5, 0x58, 0xc9, 0xb7, 0x4f, 0xd4, 0x91, 0x4c, 0x66, 0x84, 0xab, 0x89, 0x7d, 0x9c, 0x4f, 0xcc, 0x4a, 0x5f, 0x26, 0x85, 0xb7, 0x8a, 0x81, 0x62, 0xdc, 0x1b, 0xb7, 0x2, 0x3, 0xf5, 0x0, 0x5a, 0xcc, 0x2, 0x57, 0x25, 0x2e, 0xf, 0xf9, 0xef, 0xc4, 0x3b, 0x10, 0x2e, 0x9, 0xe9, 0x22, 0x1b, 0xf9, 0x8, 0xb8, 0x3b, 0x49, 0x7a, 0x88, 0xed, 0x83, 0xd0, 0xdb, 0x7c, 0x8f, 0xac, 0xa7, 0x41, 0xa2, 0x8b, 0xc5, 0xa9, 0x10, 0x4, 0x87, 0x64, 0xc5, 0x9, 0x8a, 0xa7, 0xb4, 0x19, 0xf2, 0x4a, 0xe5, 0xe1, 0xe2, 0xb0, 0x13, 0x40, 0x5e, 0x39, 0x76, 0xd9, 0x38, 0xe7, 0x81, 0xfb, 0xb1, 0xb, 0xa6, 0x79, 0xe8, 0x55, 0xd2, 0xfd, 0xcb, 0x77, 0x2e, 0xe9, 0x6b, 0xa2, 0x64, 0x20, 0x8c, 0xf4, 0x81, 0x26, 0x7, 0xee, 0xb, 0xe5, 0x8c, 0x30, 0x75, 0x68, 0x6, 0x37, 0x89, 0xac, 0x78, 0x3e, 0xc9, 0x37, 0xc6, 0x86, 0x7, 0xc8, 0x7c, 0xd0, 0xf, 0x34, 0xeb, 0xfc, 0xfd, 0x26, 0x35, 0xe5, 0xc6, 0xb2, 0xf7, 0xd8, 0x84, 0x69, 0xfd, 0xf8, 0x72, 0x3b, 0x81, 0x31, 0x2d, 0x34, 0x2, 0xc1, 0xae, 0x85, 0xc3, 0xc1, 0x20, 0x23, 0x88, 0x9, 0x40, 0x59, 0x51, 0x75, 0xd5, 0x86, 0x29, 0x8d, 0x21, 0x56, 0x61, 0xa3, 0x8a, 0x36, 0x3d, 0xf4, 0x26, 0x3a, 0x51, 0xf4, 0x34, 0x36, 0x2f, 0xd5, 0xa1, 0x1b, 0xf6, 0x9b, 0x12, 0x10, 0x65, 0xbb, 0x8, 0xce, 0xb2, 0xda, 0xf2, 0xd9, 0xf8, 0x44, 0x64, 0x69, 0x16, 0xe4, 0xa2, 0xaf, 0xba, 0xba, 0x77, 0x99, 0x9e, 0x76, 0x64, 0xaf, 0x96, 0x70, 0xcb, 0xf6, 0x8e, 0x7e, 0x4b, 0x10, 0x83, 0x4a, 0x52, 0xcc, 0xf0, 0x2e, 0x45, 0xa4, 0x31, 0xe0, 0x6a, 0x27, 0x60, 0x8, 0x44, 0x75, 0xa7, 0x4c, 0x4c, 0x66, 0xf8, 0xff, 0x90, 0xf3, 0x4c, 0x1d, 0x83, 0xd7, 0xe, 0xf8, 0xd6, 0xa3, 0x79, 0xa, 0x6e, 0x3b, 0xc9, 0xd8, 0x16, 0xf1, 0xab, 0x3, 0x8d, 0x5c, 0x31, 0x40, 0xc8, 0xf3, 0x6e, 0x66, 0xd3, 0x97, 0x6b, 0xd8, 0x31, 0xcc, 0xfd, 0x88, 0xc8, 0x4e, 0x77, 0x88, 0xcf, 0x2a, 0x32, 0x46, 0xc8, 0x15, 0x3a, 0x27, 0x45, 0x4b, 0xe, 0x7a, 0x3c, 0x59, 0xe2, 0x92, 0x92, 0x7f, 0x1d, 0xc0, 0x4e, 0xe8, 0x1e, 0x2a, 0xa2, 0x91, 0xc0, 0x6c, 0x8b, 0xb1, 0x73, 0xb5, 0x3f, 0xbf, 0x39, 0xec, 0xfd, 0x6e, 0xc1, 0xf5, 0x7a, 0x74, 0x78, 0xe3, 0x71, 0x99, 0xdc, 0x39, 0xd0, 0x58, 0x28, 0x3b, 0xd0, 0x46, 0xab, 0xe2, 0x5e, 0x91, 0x42, 0x2b, 0xb, 0x25, 0x32, 0x9d, 0x17, 0x5a, 0x7d, 0xb, 0xfa, 0x21, 0xe2, 0x97, 0xc9, 0x6a, 0x5c, 0x3f, 0x19, 0x79, 0xaf, 0x84, 0x75, 0x2a, 0x2f, 0xb6, 0x7b, 0xcb, 0x5, 0x11, 0xb7, 0x90, 0x12, 0x4b, 0xd9, 0x6e, 0xd1, 0x37, 0x49, 0xf1, 0xe9, 0x22, 0xc4, 0xac, 0xe3, 0x55, 0xdb, 0x86, 0x60, 0x11, 0xa1, 0x55, 0x1d, 0xcc, 0x95, 0x48, 0xeb, 0x46, 0xb9, 0x61, 0xfe, 0xff, 0x4f, 0x28, 0x51, 0x5, 0x58, 0x33, 0xbc, 0x40, 0x83, 0xba, 0x71, 0x2e, 0x4f, 0xb9, 0xc3, 0xc, 0x49, 0x92, 0x86, 0x83, 0xad, 0x78, 0x3f, 0xc3, 0x70, 0x39, 0x3a, 0x55, 0xf9, 0x4, 0xfd, 0xef, 0x27, 0x9c, 0xa, 0x4e, 0x1d, 0xc9, 0xe1, 0xed, 0x7e, 0x90, 0x58, 0xfa, 0x5f, 0xe3, 0x63, 0xab, 0x1e, 0x17, 0xa7, 0x24, 0x2d, 0x9, 0x21, 0x80, 0x9c, 0xca, 0xe1, 0xb9, 0xe5, 0xf2, 0x8f, 0xa5, 0x53, 0xf7, 0xca, 0x3e, 0x58, 0xfc, 0xef, 0x7b, 0xae, 0xb8, 0x8d, 0x3, 0xda, 0x5e, 0x2c, 0x6, 0xfe, 0xcd, 0x35, 0x7c, 0x12, 0xcb, 0x4, 0xc5, 0xab, 0x12, 0xda, 0xfe, 0x4d, 0x68, 0xad, 0x3c, 0x7a, 0xa9, 0x30, 0x2c, 0x9e, 0x2e, 0x6e, 0x4b, 0x86, 0xd1, 0xc9, 0x6c, 0x55, 0xfa, 0xc6, 0xf7, 0xb6, 0x31, 0x96, 0xa1, 0x5e, 0x81, 0x82, 0xc1, 0xbf, 0x2, 0x6, 0x11, 0x9d, 0x67, 0xdf, 0x74, 0x9e, 0x14, 0x28, 0xb3, 0xfb, 0x13, 0x7a, 0xe7, 0xc6, 0xeb, 0xaf, 0x75, 0xa0, 0xfc, 0x64, 0x16, 0x3c, 0x21, 0xc4, 0x43, 0x29, 0xcb, 0x44, 0x57, 0xf7, 0xd4, 0xf3, 0x69, 0x59, 0xe8, 0xa9, 0x34, 0x62, 0xaa, 0xf1, 0xbf, 0xfc, 0xfd, 0xe0, 0x2e, 0xc1, 0xa2, 0xc7, 0xe6, 0x78, 0x91, 0xdc, 0x64, 0xc1, 0xea, 0xf2, 0xa4, 0x4d, 0xd7, 0xd8, 0xec, 0xfa, 0x5f, 0x7d, 0x59, 0x6c, 0x2c, 0x66, 0xc1, 0x8a, 0x4d, 0x8b, 0x7, 0xe1, 0x90, 0x9f, 0xa8, 0x78, 0x84, 0x81, 0x6f, 0x51, 0x4e, 0xc1, 0x7a, 0xf2, 0x86, 0xdb, 0xf, 0xb3, 0x53, 0xbe, 0xff, 0xf9, 0x4f, 0x81, 0x9, 0x42, 0xb5, 0x60, 0x62, 0xa4, 0xa8, 0x4a, 0x45, 0x32, 0x47, 0x73, 0xbd, 0x26, 0xed, 0x4b, 0x5c, 0xcf, 0x4e, 0x10, 0xbf, 0x71, 0x51, 0x10, 0xfd, 0xac, 0x5c, 0x4c, 0x5, 0xa3, 0xef, 0x4a, 0x31, 0x34, 0xbc, 0x9c, 0x9a, 0x7b, 0x57, 0x74, 0xd5, 0xd, 0xc8, 0x17, 0xeb, 0x6a, 0x5a, 0xa3, 0xba, 0xc0, 0x29, 0xae, 0xb5, 0x50, 0x52, 0x4, 0xdb, 0x40, 0x81, 0x1f, 0x69, 0xec, 0xf1, 0x7e, 0xbc, 0x20, 0x67, 0x46, 0xd7, 0xfa, 0xec, 0x59, 0xb2, 0x61, 0x70, 0xff, 0x23, 0xef, 0x45, 0x62, 0x35, 0xa6, 0x6c, 0xda, 0x3b, 0x84, 0x18, 0x84, 0x95, 0x77, 0x1e, 0x53, 0x42, 0x1c, 0x72, 0x56, 0x71, 0x78, 0x86, 0x33, 0x47, 0x23, 0x65, 0xd4, 0x74, 0x16, 0x7a, 0xb, 0xf9, 0xba, 0x7b, 0x21, 0x2b, 0xc6, 0xfd, 0x91, 0xc4, 0x21, 0x5, 0x70, 0xfa, 0x3f, 0xed, 0xb1, 0xec, 0xf6, 0xfc, 0x77, 0xd0, 0x49, 0x83, 0xe, 0xb1, 0xe9, 0x91, 0x95, 0x1d, 0xf4, 0x39, 0xdc, 0x21, 0x16, 0xf7, 0x2e, 0x9a, 0xe1, 0x67, 0x9b, 0x45, 0x20, 0x88, 0xff, 0xd, 0x8c, 0x76, 0xa4, 0x48, 0x6e, 0xff, 0x15, 0xef, 0x9e, 0x7d, 0x80, 0xe5, 0x29, 0xa9, 0x7b, 0x36, 0x87, 0x0, 0xa4, 0xc6, 0xc7, 0x88, 0x47, 0x8, 0x45, 0x5, 0xc8, 0xd9, 0x17, 0x7f, 0x8, 0xc9, 0x6f, 0xc4, 0xba, 0xf5, 0xbe, 0x3f, 0x40, 0x43, 0xa2, 0x1b, 0x6f, 0xcc, 0x20, 0xe, 0x7f, 0x59, 0xcf, 0xc8, 0xbc, 0xb7, 0x1a, 0x1e, 0x2f, 0xb9, 0xd9, 0xae, 0x85, 0x41, 0x4d, 0x92, 0xd0, 0x9b, 0xc6, 0xe2, 0x68, 0x6e, 0xda, 0x67, 0xe, 0xb5, 0xe9, 0x3, 0xfc, 0x94, 0x6, 0xcc, 0xb0, 0x50, 0x1f, 0x8b, 0xfa, 0x16, 0xc0, 0x16, 0x7e, 0x2f, 0x48, 0x89, 0x9b, 0xd1, 0x42, 0x58, 0xd5, 0x9e, 0x58, 0xaa, 0xa8, 0xf4, 0x50, 0x38, 0x7c, 0x9d, 0x80, 0xf6, 0x6a, 0x6f, 0x9d, 0x15, 0xfa, 0xbe, 0xc9, 0xce, 0x12, 0x18, 0x66, 0xb2, 0xb6, 0xba, 0x9, 0xcc, 0x93, 0x16, 0x5b, 0x8a, 0x56, 0x7f, 0x86, 0xfe, 0x4, 0x23, 0x81, 0x3d, 0x7a, 0xb, 0x9a, 0xcd, 0xc5, 0x5, 0xdb, 0x6f, 0xbf, 0x6d, 0x50, 0x63, 0xdc, 0x23, 0x1b, 0xe1, 0xe2, 0xd8, 0x1, 0xe8, 0xd, 0xcf, 0xa, 0x82, 0xd3, 0xd8, 0xc9, 0x8e, 0x80, 0xe3, 0xad, 0xe2, 0xcd, 0xf4, 0xd8, 0xeb, 0xfb, 0x99, 0x66, 0xca, 0x1c, 0x68, 0xfa, 0xbf, 0xe, 0x31, 0x36, 0x38, 0xe, 0x6a, 0xd1, 0x75, 0x17, 0x60, 0x7e, 0x2a, 0x36, 0xd4, 0x10, 0x17, 0xe6, 0xe, 0xc0, 0xd2, 0xd, 0x6b, 0x17, 0xe5, 0x50, 0x44, 0x93, 0xc9, 0x4f, 0xbd, 0xa6, 0x47, 0xe3, 0xc2, 0x19, 0x53, 0x79, 0xb9, 0x8d, 0x84, 0xc1, 0xda, 0x6, 0x34, 0x57, 0x7d, 0xc5, 0xfb, 0xc3, 0x63, 0x8d, 0x94, 0x33, 0xfd, 0xb3, 0x2f, 0x7d, 0xc2, 0x5e, 0x52, 0xb6, 0x21, 0xdb, 0x7f, 0x3a, 0x1, 0x94, 0xf3, 0xcc, 0xbb, 0xe5, 0x1b, 0xe6, 0x1b, 0x55, 0xb4, 0xe5, 0xd2, 0x7e, 0xb, 0xcb, 0x27, 0x12, 0xf6, 0xcd, 0x3a, 0x29, 0xae, 0x2c, 0x5c, 0x8f, 0x9a, 0x29, 0xfe, 0x83, 0x6c, 0x2, 0xb6, 0xe9, 0x8, 0x6a, 0xa4, 0xd9, 0x2c, 0x57, 0xc5, 0xaa, 0x89, 0x96, 0xf4, 0x56, 0x1f},
+               output224: []byte{0xed, 0x18, 0xda, 0xe7, 0x7c, 0x77, 0x57, 0xf7, 0xae, 0x75, 0xfd, 0xb0, 0x85, 0xca, 0x7f, 0xd, 0x50, 0x29, 0x36, 0xe, 0xc0, 0xde, 0x88, 0x9d, 0x7, 0x9, 0xb, 0xc5},
+               output256: []byte{0xfc, 0x98, 0xc1, 0x67, 0x23, 0xd8, 0xb8, 0x53, 0x12, 0x51, 0x97, 0x93, 0xbf, 0x97, 0xba, 0x50, 0xf4, 0x20, 0xdf, 0x68, 0x71, 0xc6, 0x18, 0x11, 0x77, 0x8f, 0xc1, 0x55, 0xc4, 0xac, 0xb2, 0x47},
+               output384: []byte{0xae, 0x31, 0xed, 0xa8, 0xd6, 0xb7, 0x4f, 0x3e, 0x4a, 0x7d, 0xf3, 0x3d, 0xbe, 0x75, 0xa1, 0x46, 0xbc, 0xfe, 0xb5, 0x16, 0x1, 0x2d, 0xed, 0x58, 0xa7, 0xb, 0x32, 0xda, 0xce, 0x5, 0x5a, 0x79, 0xc8, 0x98, 0x20, 0x43, 0x13, 0x65, 0xd6, 0xa0, 0xe2, 0x8c, 0x8, 0x16, 0x28, 0xd9, 0x5e, 0x1f},
+               output512: []byte{0x31, 0x9d, 0x56, 0x7c, 0xe6, 0xc7, 0x16, 0x29, 0xf4, 0xd0, 0x80, 0x1e, 0x38, 0x8a, 0x4b, 0xe3, 0x39, 0x33, 0x8f, 0x68, 0x94, 0xab, 0x47, 0x47, 0x50, 0x33, 0x2e, 0x95, 0x6e, 0xb3, 0xf1, 0xb0, 0xd4, 0x97, 0x83, 0xf, 0x8a, 0x4e, 0xce, 0xd8, 0xde, 0x90, 0xea, 0x8, 0x81, 0xcf, 0x5d, 0x1a, 0x73, 0x3b, 0x86, 0xdc, 0xe9, 0xd9, 0x9e, 0x40, 0x29, 0x30, 0x96, 0x46, 0x32, 0x1b, 0x4d, 0xb2}},
+       testcase{
+               msg:       []byte{0xfa, 0x82, 0x3, 0x12, 0x35, 0x66, 0xc3, 0x34, 0x55, 0x9f, 0x12, 0xf1, 0xc3, 0x71, 0x81, 0xda, 0x32, 0x75, 0x9d, 0xa, 0xc6, 0xcd, 0xee, 0x69, 0x66, 0x10, 0x44, 0x5d, 0xa4, 0x48, 0x4a, 0x51, 0xa8, 0x67, 0x26, 0x3a, 0xb6, 0x4, 0x3a, 0xb5, 0x2c, 0x6c, 0x9, 0x73, 0x46, 0xd5, 0xbd, 0x6c, 0x83, 0xa2, 0x51, 0x9b, 0x28, 0xd3, 0x78, 0x44, 0xae, 0x1d, 0xbb, 0x55, 0xcb, 0x8b, 0x86, 0x74, 0x3d, 0x51, 0x88, 0x1d, 0x1b, 0xc8, 0x10, 0xf0, 0xe4, 0xa9, 0xe1, 0xf5, 0x89, 0xd8, 0xe4, 0xce, 0xcd, 0xfe, 0x58, 0x59, 0xab, 0x24, 0x5a, 0x79, 0xe0, 0xd8, 0x80, 0x53, 0x47, 0x99, 0x1f, 0x23, 0xec, 0xc8, 0x3a, 0x30, 0x78, 0x71, 0xc3, 0xd1, 0xa2, 0x2d, 0x6b, 0xdb, 0x2a, 0x70, 0xdd, 0xa2, 0xe, 0xeb, 0x51, 0x49, 0x62, 0x16, 0xad, 0xab, 0x2c, 0xac, 0x4b, 0xc4, 0x34, 0x60, 0x53, 0xa4, 0x1a, 0x6f, 0xac, 0x5c, 0xd7, 0x8b, 0x5d, 0x2c, 0x51, 0xaf, 0x83, 0xa7, 0x54, 0xf8, 0xf3, 0x8c, 0xc, 0xa7, 0xeb, 0x48, 0x24, 0x1e, 0x34, 0xb7, 0x38, 0xff, 0x4c, 0xe7, 0x42, 0x14, 0x71, 0xf8, 0xa7, 0x92, 0xe3, 0x6f, 0x32, 0xc1, 0x6e, 0x6, 0x7b, 0x85, 0x56, 0x2b, 0xd7, 0x52, 0xee, 0x5e, 0x73, 0xc7, 0x92, 0xd, 0xf0, 0x8f, 0x10, 0x90, 0xad, 0x8c, 0xd2, 0x51, 0x87, 0x4d, 0x11, 0x64, 0xe1, 0x5d, 0xc9, 0xc1, 0x31, 0xaf, 0xe3, 0x18, 0xc4, 0xca, 0xf0, 0x4d, 0xd0, 0x44, 0xad, 0x6, 0x8c, 0xa8, 0x56, 0xeb, 0x44, 0xf1, 0x2c, 0x5, 0x7a, 0x67, 0x6c, 0xf2, 0xf5, 0xbe, 0x9c, 0x72, 0xc7, 0x4c, 0x47, 0x9, 0xec, 0xbe, 0x90, 0xa8, 0x16, 0xad, 0x2a, 0xf4, 0x3e, 0xe8, 0x92, 0xad, 0xde, 0xdb, 0x70, 0x89, 0xc8, 0x9d, 0xa5, 0xec, 0xdd, 0x20, 0xe7, 0xbd, 0x8, 0x2c, 0xe5, 0x48, 0x5d, 0x55, 0x9b, 0xc9, 0xc7, 0x71, 0xe4, 0x9f, 0x87, 0x23, 0x39, 0x25, 0x2d, 0x66, 0xc3, 0x68, 0xc9, 0xe9, 0x4f, 0x4e, 0x23, 0xc8, 0x57, 0x34, 0xcd, 0x56, 0x7c, 0x4d, 0xe7, 0xed, 0x49, 0xf9, 0x24, 0x26, 0xa5, 0xd3, 0x87, 0x83, 0xfb, 0xfc, 0xde, 0xcb, 0x7e, 0xf6, 0x2a, 0xdc, 0x53, 0x19, 0xcc, 0x63, 0x34, 0x35, 0x7c, 0x2d, 0x83, 0x89, 0xda, 0x87, 0x1, 0x46, 0x32, 0x6b, 0x1b, 0xc1, 0x2e, 0x9f, 0x70, 0xb3, 0xc2, 0xaf, 0xad, 0x6c, 0x4f, 0x51, 0xf7, 0x10, 0xdd, 0x77, 0x66, 0x3e, 0xaf, 0x37, 0xc1, 0x1, 0x70, 0xd, 0x64, 0xaf, 0xd4, 0x40, 0x47, 0x73, 0xab, 0x57, 0x2a, 0x24, 0x4b, 0x36, 0xc3, 0x27, 0x37, 0xfe, 0xf7, 0xe1, 0x68, 0xd4, 0x16, 0x21, 0x12, 0x30, 0x78, 0xaf, 0x2, 0x5f, 0x4c, 0x25, 0xaa, 0xab, 0x8c, 0x9c, 0x84, 0x4e, 0x74, 0x0, 0xcd, 0x2d, 0x8e, 0x43, 0xb3, 0xbc, 0x62, 0x1d, 0xb1, 0x59, 0x2d, 0x32, 0x12, 0xe2, 0x76, 0xc9, 0xa5, 0x2e, 0xf5, 0x6b, 0x6b, 0x4c, 0xf3, 0x9a, 0x49, 0x67, 0x3c, 0x48, 0x38, 0x5, 0xd2, 0x45, 0xc, 0xb2, 0xee, 0x4, 0x5e, 0x3b, 0x8b, 0x5b, 0xbc, 0xf7, 0xfd, 0x41, 0x3e, 0x8d, 0x34, 0xa8, 0x71, 0x63, 0x63, 0xee, 0xc4, 0x8f, 0x76, 0xf5, 0x4b, 0x4f, 0x2f, 0xd0, 0x8e, 0x81, 0xc1, 0x19, 0x97, 0xc5, 0x64, 0x71, 0x73, 0x77, 0x5d, 0x26, 0x7, 0xed, 0xe1, 0x74, 0x3e, 0x2a, 0x22, 0x42, 0xb, 0x3c, 0x87, 0xee, 0xe4, 0xd7, 0x5d, 0x14, 0x34, 0x3c, 0x87, 0x35, 0xe2, 0xb6, 0xa7, 0xd2, 0x76, 0xc7, 0x39, 0xfc, 0xc7, 0x5d, 0x3d, 0x10, 0x74, 0xc4, 0x3e, 0xfc, 0x5a, 0x62, 0x43, 0x4, 0xc4, 0xcd, 0xba, 0xc9, 0xf1, 0x23, 0x12, 0x4, 0x6, 0x15, 0xd, 0x26, 0x5d, 0x36, 0xc5, 0xd4, 0xde, 0x44, 0x41, 0xc7, 0xfc, 0x63, 0x7f, 0xa4, 0xb4, 0x23, 0x7a, 0x40, 0x3a, 0x54, 0x15, 0xea, 0x1, 0xac, 0xb3, 0x3e, 0x5a, 0xc6, 0x50, 0x7d, 0xbc, 0xb0, 0xe3, 0x57, 0x24, 0x59, 0x16, 0xcf, 0xd6, 0xb0, 0xd0, 0xe3, 0x5e, 0x2, 0xca, 0x15, 0x58, 0xd, 0x52, 0x66, 0x8, 0x72, 0xb6, 0xc2, 0x86, 0x9c, 0x4f, 0x1d, 0xa4, 0x9b, 0x60, 0xa, 0xa3, 0xb3, 0x99, 0x3d, 0xc5, 0x69, 0xe3, 0x5e, 0x4a, 0xf3, 0x80, 0xde, 0x74, 0x0, 0xae, 0xa9, 0x28, 0xe9, 0xd2, 0x55, 0x10, 0xb3, 0xbf, 0x9a, 0xff, 0x50, 0x7c, 0xec, 0x72, 0x0, 0x68, 0xd4, 0x72, 0x1f, 0x42, 0xc8, 0xec, 0xae, 0x2a, 0x48, 0xae, 0xe3, 0x1d, 0xa, 0xf6, 0xf8, 0x44, 0x45, 0x8c, 0x44, 0x1b, 0x93, 0xb3, 0x50, 0x8d, 0x74, 0xcd, 0x43, 0xa4, 0x40, 0x33, 0xb7, 0x61, 0x8a, 0xa4, 0xd8, 0x52, 0xba, 0xa4, 0x20, 0xcd, 0xd6, 0xb7, 0x42, 0x8a, 0x84, 0x1, 0xe1, 0xb5, 0x3e, 0xa2, 0xce, 0x33, 0xb3, 0xf0, 0x99, 0x91, 0xe6, 0x91, 0xe5, 0x33, 0x44, 0x16, 0x3b, 0x2a, 0x88, 0x35, 0xe0, 0xf9, 0xe, 0x83, 0xc7, 0x27, 0x8f, 0x9a, 0xd, 0x8c, 0x64, 0x20, 0xc, 0x50, 0x2d, 0x8d, 0xc1, 0xae, 0x1b, 0x96, 0xf9, 0x94, 0x7e, 0x60, 0x69, 0x0, 0x32, 0x92, 0xe, 0x79, 0x59, 0x50, 0xeb, 0xf6, 0x64, 0x2c, 0xd5, 0x42, 0x1c, 0xec, 0xd2, 0x82, 0xcc, 0x47, 0xf, 0xa4, 0x62, 0x8, 0x3e, 0x22, 0x1a, 0x90, 0x1, 0x40, 0xbd, 0x51, 0x1e, 0x61, 0x6a, 0xa7, 0x47, 0x1a, 0x75, 0x26, 0x18, 0x7, 0x71, 0xb8, 0x3, 0xa2, 0x26, 0x50, 0x21, 0xbe, 0x28, 0x76, 0xae, 0x4, 0xe4, 0xe4, 0xe8, 0x6e, 0x83, 0x4, 0x52, 0xba, 0x79, 0xd4, 0x30, 0x6a, 0xe4, 0x5c, 0x7f, 0xd7, 0x57, 0x16, 0xc6, 0x13, 0x12, 0x11, 0x90, 0x4f, 0x72, 0xe1, 0xf5, 0x2d, 0x3a, 0x1d, 0xe2, 0x8, 0x17, 0x70, 0x59, 0x86, 0x28, 0xe3, 0x3e, 0x24, 0x4d, 0x93, 0xfb, 0x97, 0x14, 0x88, 0x82, 0x3d, 0xa9, 0x72, 0x91, 0x69, 0xb6, 0x99, 0x92, 0x28, 0x76, 0x81, 0x8d, 0xd, 0x91, 0x84, 0x8a, 0x3e, 0xba, 0xa7, 0x85, 0xb7, 0x2, 0x99, 0x15, 0xf3, 0xd9, 0x23, 0x8a, 0x41, 0x51, 0x91, 0xa, 0x88, 0xe2, 0xef, 0xe6, 0xf4, 0x18, 0x41, 0xeb, 0x85, 0x4, 0x44, 0x43, 0x9, 0x83, 0x22, 0xb0, 0x59, 0x38, 0x26, 0xf8, 0xcb, 0x6b, 0xb, 0x76, 0xe5, 0x31, 0x20, 0xa0, 0x4, 0xe9, 0x13, 0xce, 0x42, 0xe4, 0x48, 0xd4, 0xba, 0x1f, 0x29, 0x30, 0x84, 0x91, 0x85, 0xe7, 0xc8, 0xe0, 0x29, 0x53, 0x3b, 0x27, 0x5a, 0xa4, 0xc1, 0xb1, 0xde, 0xd8, 0xd3, 0x88, 0x18, 0xef, 0xe9, 0x53, 0x5f, 0x4d, 0x7, 0x24, 0xa5, 0xef, 0xbc, 0xe4, 0x85, 0xcf, 0x49, 0x3b, 0xa5, 0x3f, 0x61, 0x9b, 0x56, 0xc2, 0x51, 0x46, 0x5e, 0x8a, 0x7, 0xf3, 0xa0, 0x85, 0x62, 0x7e, 0x13, 0xd0, 0xe2, 0x4e, 0xe6, 0x15, 0x7d, 0xd7, 0x6f, 0x4f, 0xb2, 0xfb, 0xad, 0x7b, 0x58, 0x39, 0x6b, 0xae, 0x69, 0x19, 0x6, 0x9e, 0xb0, 0xd3, 0x2b, 0x8d, 0x57, 0xf9, 0x33, 0xe6, 0x5, 0x9f, 0xa2, 0xff, 0x6, 0x2b, 0xdc, 0x7f, 0xd8, 0x6c, 0xde, 0xbb, 0xa4, 0xe2, 0x6, 0xa4, 0xc3, 0xcb, 0xb2, 0xa8, 0x68, 0xd7, 0xe0, 0x98, 0x67, 0xd3, 0x16, 0xc8, 0x80, 0x1a, 0x39, 0xdc, 0x7c, 0x71, 0xf2, 0xe7, 0xfe, 0x43, 0xea, 0xe3, 0xc1, 0xcf, 0xc7, 0x1e, 0xc, 0xcf, 0x8e, 0xe9, 0x46, 0x5e, 0x53, 0xf9, 0x36, 0xa9, 0xab, 0x60, 0x8f, 0x29, 0xc9, 0xf2, 0xe0, 0xde, 0xe8, 0xe4, 0x50, 0xcd, 0x42, 0x63, 0x77, 0x85, 0xcf, 0x84, 0x54, 0x3d, 0x39, 0xba, 0x6f, 0xda, 0xb7, 0x7f, 0x1c, 0x93, 0xd0, 0x8c, 0x5d, 0x5d, 0x87, 0x41, 0x95, 0x40, 0xb3, 0xa5, 0x10, 0xd0, 0x4b, 0x2, 0x98, 0x88, 0xd0, 0xf2, 0xfa, 0x64, 0xcf, 0x5a, 0x62, 0xed, 0xb4, 0xdb, 0x7f, 0x4a, 0x8f, 0xef, 0x45, 0xb8, 0xd2, 0x7a, 0x22, 0xc6, 0x89, 0x52, 0xc4, 0x5, 0x98, 0x4b, 0xa9, 0x4c, 0xd2, 0xfc, 0xd, 0x79, 0xdb, 0x81, 0xa7, 0xb, 0xfa, 0xf9, 0x23, 0x7d, 0xf9, 0xb8, 0x6f, 0x3a, 0x7e, 0x3c, 0xd0, 0x8d, 0x4a, 0x1c, 0xe6, 0xb1, 0xe2, 0x5c, 0x3b, 0xbc, 0x5b, 0x20, 0x6e, 0x4a, 0x1, 0x80, 0x70, 0xf0, 0xb0, 0xec, 0xde, 0x81, 0xca, 0x83, 0x4f, 0xe2, 0x11, 0x62, 0xcc, 0xe9, 0xed, 0x32, 0xe1, 0xb5, 0x7, 0xfb, 0x5d, 0x93, 0xa6, 0x25, 0x60, 0x2e, 0x12, 0x3e, 0xd1, 0xef, 0x25, 0xb3, 0xc2, 0x91, 0x79, 0x1c, 0x56, 0xb4, 0x50, 0xf, 0xb7, 0xb1, 0x26, 0x46, 0x77, 0x3b, 0x1f, 0x59, 0xe2, 0x4, 0x19, 0x3d, 0xba, 0xa2, 0x3c, 0x9a, 0xe7, 0x9b, 0x29, 0x31, 0x32, 0xcd, 0x5e, 0xc9, 0xb6, 0x9, 0x65, 0x28, 0xa, 0xd0, 0x82, 0x4f, 0x3e, 0x4a, 0x56, 0xff, 0xcf, 0x96, 0x6f, 0x6b, 0x23, 0x9, 0xf3, 0xcb, 0x78, 0xea, 0x7e, 0x4c, 0xc5, 0x87, 0xc4, 0x66, 0x1a, 0x10, 0xd1, 0xe2, 0x2a, 0xb2, 0x68, 0x9, 0x1e, 0x95, 0xe8, 0x70, 0x2f, 0xd2, 0xd, 0xb7, 0x1d, 0x73, 0xa6, 0xb9, 0xfa, 0x66, 0x96, 0xa5, 0xc0, 0xc8, 0xa6, 0x71, 0x88, 0xff, 0xcc, 0xb9, 0x6, 0x96, 0xd7, 0x3d, 0x8a, 0xea, 0x1d, 0x9a, 0xc, 0x0, 0x16, 0xcd, 0x44, 0x9f, 0x9c, 0x9d, 0xd1, 0x8d, 0xa9, 0xb, 0x25, 0xd1, 0x82, 0xf5, 0x56, 0xdf, 0x18, 0x57, 0xee, 0xb, 0x3e, 0x48, 0xc2, 0x88, 0x82, 0xb1, 0x10, 0xe2, 0xc, 0x9c, 0x91, 0x26, 0xff, 0x73, 0xdf, 0x84, 0xc, 0xa, 0x3f, 0x72, 0x47, 0x4a, 0x14, 0xc9, 0x16, 0x79, 0xeb, 0x5f, 0x5d, 0x9a, 0x20, 0x95, 0xa5, 0xac, 0xf1, 0x1, 0x55, 0x98, 0xcb, 0x5d, 0xe4, 0x29, 0x4b, 0x4a, 0x78, 0xc7, 0xe5, 0x81, 0x8c, 0x8f, 0x13, 0x23, 0x23, 0x4b, 0x4, 0xe7, 0x9c, 0x5a, 0x43, 0x85, 0xaa, 0x42, 0x9c, 0xc3, 0xbb, 0x41, 0x25, 0x5b, 0xe8, 0x79, 0x61, 0x65, 0xca, 0x3b, 0x2d, 0xa, 0xdd, 0xca, 0x42, 0x2f, 0xe8, 0xca, 0x3c, 0x75, 0x89, 0x2a, 0xbc, 0x86, 0x31, 0x6b, 0x2e, 0xb9, 0x3d, 0x6e, 0x75, 0x60, 0x6, 0x68, 0xe8, 0xaf, 0xe9, 0x9d, 0xde, 0x20, 0x5e, 0xfa, 0xfa, 0x47, 0x2b, 0xec, 0x72, 0xcd, 0x31, 0x2d, 0xd8, 0x15, 0x70, 0x15, 0x44, 0x90, 0x93, 0x16, 0x13, 0xe8, 0xf0, 0xff, 0x9f, 0xb0, 0x50, 0x7d, 0xe5, 0x65, 0x9, 0xa3, 0xc2, 0xe7, 0xc9, 0x7c, 0x3b, 0xbf, 0xce, 0xad, 0x92, 0x3a, 0x3f, 0x2f, 0xf1, 0x1d, 0xd8, 0xb0, 0x52, 0xd1, 0x54, 0xc2, 0x20, 0xd4, 0x4e, 0x7b, 0x2e, 0x45, 0xbd, 0x65, 0x2b, 0x6c, 0x88, 0x57, 0x70, 0xe0, 0xe4, 0x86, 0x32, 0x5f, 0x54, 0xfd, 0xac, 0x28, 0xad, 0x7a, 0x76, 0xe, 0xfa, 0xf7, 0xc5, 0x5, 0x16, 0x4d, 0x52, 0x9, 0x55, 0xe1, 0x35, 0x27, 0xd1, 0x86, 0xc2, 0x48, 0x8a, 0x80, 0x17, 0xa5, 0x30, 0xe0, 0x2a, 0x57, 0xf6, 0x1b, 0x5c, 0x5f, 0x37, 0x39, 0x7, 0x71, 0x4e, 0x6d, 0xf7, 0x8, 0xd4, 0x7c, 0x99, 0x23, 0xb7, 0x0, 0x82, 0xfa, 0x64, 0x1c, 0xe2, 0xd7, 0xb9, 0xca, 0x4f, 0x30, 0x87, 0xd8, 0xfd, 0x88, 0xd2, 0xba, 0x15, 0x33, 0xcc, 0x67, 0x51, 0x50, 0x6a, 0x64, 0xe0, 0x6e, 0xc9, 0x2b, 0x4a, 0xbd, 0xa8, 0xde, 0x2d, 0x75, 0xb0, 0x20, 0xb2, 0xc0, 0x11, 0x3c, 0x15, 0xb7, 0xfd, 0x92, 0xee, 0x84, 0x94, 0xb5, 0x72, 0x20, 0x9c, 0xb, 0x4c, 0x61, 0x4e, 0xff, 0x2f, 0xd8, 0x9a, 0xf1, 0xfd, 0xcf, 0x48, 0x9b, 0xb5, 0xbb, 0xb7, 0x76, 0x8a, 0xad, 0x64, 0xea, 0x49, 0xa7, 0xdf, 0xd7, 0x96, 0xff, 0x75, 0x1, 0xd7, 0x5d, 0xa4, 0x39, 0x2, 0x85, 0x75, 0xed, 0xb, 0xf0, 0xce, 0xdb, 0x1f, 0xc7, 0x1e, 0x68, 0xe3, 0xc6, 0xcb, 0x3d, 0xa3, 0xcb, 0xfe, 0xf8, 0xd1, 0x2a, 0xc0, 0x52, 0xcc, 0xcc, 0x1d, 0xe4, 0x6b, 0xbb, 0x43, 0x83, 0x5c, 0xeb, 0xd9, 0xa1, 0x11, 0x1e, 0x83, 0xd6, 0x17, 0x9e, 0x6c, 0xd1, 0xf, 0x67, 0x73, 0x3e, 0xaa, 0xd, 0x9b, 0xb1, 0x66, 0x89, 0x7, 0x29, 0xa4, 0x8a, 0xba, 0x5, 0xec, 0x77, 0x45, 0x40, 0x92, 0x9, 0x94, 0x2b, 0xe4, 0x4a, 0x27, 0x84, 0x86, 0xf3, 0x8c, 0xdd, 0xb6, 0xe9, 0x85, 0x2b, 0xe, 0xe4, 0xea, 0xd9, 0x81, 0xa8, 0xe8, 0xbc, 0xc4, 0x6e, 0xf2, 0x5a, 0x4c, 0x7, 0xf8, 0x74, 0xa8, 0x87, 0xf2, 0x9c, 0xd6, 0x1d, 0x47, 0xc3, 0x8c, 0x90, 0x20, 0xa0, 0xf1, 0xf2, 0xd4, 0xa1, 0xbd, 0xd3, 0xc0, 0xb8, 0xe2, 0xc5, 0x3c, 0x9b, 0x43, 0x12, 0xb5, 0x4f, 0xfb, 0xdf, 0x69, 0x48, 0xb, 0x2a, 0x37, 0x7, 0xf0, 0xcf, 0x89, 0x63, 0x8d, 0x7b, 0x76, 0x79, 0xaa, 0x91, 0x86, 0x9a, 0x53, 0x66, 0x4b, 0x15, 0xad, 0x7, 0xef, 0xa0, 0x1e, 0x71, 0x88, 0x71, 0xec, 0x94, 0x10, 0xa1, 0x48, 0x6a, 0x8d, 0xc2, 0xb4, 0x1f, 0xf0, 0xd, 0xf7, 0xfa, 0x6, 0x9a, 0x6e, 0x68, 0xa3, 0x3f, 0x27, 0xa2, 0xea, 0xb, 0xa4, 0xa3, 0x19, 0x1c, 0xde, 0xfd, 0xf2, 0x34, 0x9b, 0xe5, 0xdf, 0x72, 0x7b, 0x73, 0x54, 0x76, 0x7a, 0x29, 0x9f, 0xaf, 0x5e, 0x87, 0xcc, 0xbe, 0xb9, 0x8c, 0x4a, 0xf0, 0x36, 0x89, 0x8a, 0x80, 0xb5, 0xc4, 0x85, 0x88, 0x16, 0x45, 0x73, 0x9f, 0xbc, 0x5a, 0x76, 0xc3, 0x93, 0x47, 0x74, 0xf6, 0xa0, 0x78, 0xae, 0xf2, 0x81, 0x83, 0xa0, 0x14, 0x83, 0x5, 0xf8, 0xc0, 0x89, 0x18, 0x32, 0x40, 0x2d, 0xde, 0xb9, 0x93, 0xe1, 0xca, 0xe, 0xab, 0xd5, 0x2d, 0x2f, 0xd5, 0xc5, 0x94, 0x6a, 0x94, 0xb2, 0x3b, 0x5, 0x7b, 0x85, 0x93, 0x1b, 0x69, 0x8b, 0x46, 0xf6, 0x8a, 0xd8, 0x85, 0x80, 0xf, 0xf2, 0x5a, 0xb1, 0xb5, 0xdb, 0xe4, 0x26, 0x61, 0xfa, 0xa9, 0x2, 0x7, 0x4a, 0x3d, 0x45, 0xce, 0x2, 0xfb, 0xde, 0x7c, 0x1c, 0x38, 0x1, 0x3b, 0x10, 0x0, 0xd9, 0xcf, 0x9c, 0x2f, 0x42, 0x26, 0xb5, 0xed, 0x1a, 0xdf, 0xd1, 0x8d, 0x67, 0x6d, 0x14, 0xe7, 0xb1, 0x42, 0x2c, 0x63, 0x21, 0xc0, 0xfa, 0x51, 0x71, 0x93, 0x30, 0x41, 0xab, 0xe9, 0x63, 0xdb, 0x7, 0xc0, 0x69, 0x53, 0x90, 0x6c, 0x5, 0x1d, 0x7a, 0xc1, 0xd3, 0x56, 0xbc, 0xc0, 0xb8, 0x0, 0xa7, 0xd5, 0xf1, 0x9d, 0xc0, 0xed, 0xf4, 0xd0, 0xcb, 0xd1, 0x6a, 0x22, 0x54, 0x20, 0x82, 0x35, 0xf9, 0x72, 0xf5, 0x9e, 0x71, 0xe4, 0x10, 0xbb, 0x6d, 0x51, 0xa8, 0x9e, 0x12, 0xa3, 0x39, 0x79, 0xba, 0x6a, 0x6f, 0x8f, 0x5c, 0xd5, 0xc1, 0xcb, 0x3, 0x29, 0xc7, 0x3f, 0xde, 0xcb, 0xe2, 0x4d, 0x66, 0xc6, 0xb5, 0xd5, 0xa1, 0x12, 0x5d, 0x16, 0x2a, 0x9b, 0xe, 0x98, 0x2b, 0xad, 0x23, 0xd4, 0x4e, 0xf9, 0x92, 0x4c, 0x6e, 0x29, 0x3, 0xfe, 0xe8, 0x35, 0x52, 0x23, 0x72, 0x7e, 0x4f, 0xbe, 0x40, 0xe, 0x86, 0xe4, 0xba, 0x82, 0x82, 0x59, 0x36, 0x95, 0x1, 0x8f, 0x50, 0xd9, 0x6b, 0x7d, 0x1f, 0x5f, 0x83, 0x6, 0x6f, 0x2, 0x3b, 0xb7, 0xd0, 0xa5, 0x68, 0xd0, 0xc3, 0x96, 0x66, 0x1b, 0x87, 0x6a, 0x15, 0xa8, 0x59, 0xab, 0x8, 0x42, 0x5a, 0xc1, 0xcc, 0x15, 0x63, 0xc7, 0xa0, 0x94, 0xbf, 0x8d, 0x9a, 0x34, 0x8b, 0x2e, 0xbe, 0x8c, 0xd8, 0x82, 0x6c, 0x25, 0x21, 0x23, 0x96, 0x8a, 0xa9, 0xd, 0x94, 0x4, 0xbe, 0x82, 0x1, 0x9d, 0xf5, 0xba, 0x76, 0x4d, 0x5e, 0x79, 0x6c, 0xa4, 0x3f, 0x5b, 0xcb, 0x34, 0xa1, 0xd4, 0xf9, 0x8, 0xe7, 0x96, 0x6d, 0x89, 0x83, 0x3e, 0x5a, 0xe, 0x8b, 0x0, 0xa9, 0xc0, 0xb3, 0x85, 0x4, 0x5c, 0xff, 0x25, 0xaf, 0x35, 0xc4, 0xf5, 0x66, 0x49, 0x27, 0x69, 0x18, 0x98, 0x73, 0xba, 0x43, 0x80, 0xbf, 0xef, 0x1a, 0xd5, 0x2f, 0xa9, 0x6e, 0xe0, 0x49, 0xba, 0xcf, 0x89, 0x2d, 0xba, 0x6d, 0xda, 0x60, 0x5c, 0x1c, 0x0, 0x24, 0x4c, 0x7c, 0x59, 0x75, 0x43, 0xfd, 0x2b, 0x6a, 0xa6, 0xf0, 0xf0, 0x44, 0xab, 0x4a, 0x52, 0x19, 0x58, 0x8d, 0x54, 0x80, 0xe7, 0x59, 0xab, 0x44, 0xe7, 0x9c, 0x57, 0x59, 0xf1, 0x8, 0x3f, 0x68, 0x16, 0x5d, 0x42, 0xda, 0x6c, 0xf0, 0x4d, 0x16, 0xec, 0xa, 0x71, 0x40, 0xc, 0x1c, 0x6a, 0x50, 0xff, 0xfb, 0x6, 0xa0, 0x6a, 0xc0, 0xfc, 0xd2, 0x3f, 0x5, 0xee, 0x84, 0x31, 0x51, 0x94, 0x7, 0xc4, 0x70, 0xda, 0x99, 0xbc, 0xa4, 0xb1, 0x1e, 0xc2, 0x33, 0xed, 0x32, 0xc1, 0xb1, 0xf6, 0xe5, 0x6, 0xe3, 0x42, 0x70, 0xc5, 0x92, 0x7f, 0x8c, 0x34, 0xcf, 0x30, 0x83, 0x3c, 0x94, 0xa2, 0x3c, 0xf, 0x90, 0xab, 0xe0, 0xfe, 0xe4, 0x3d, 0xd, 0xb8, 0xbc, 0x56, 0xef, 0xf9, 0xa0, 0xc, 0x40, 0x3a, 0x4c, 0x12, 0xf8, 0x81, 0x11, 0x9d, 0xb8, 0xb7, 0xc2, 0x59, 0x5, 0x16, 0x1f, 0x20, 0x30, 0xef, 0xda, 0xf8, 0x8, 0x64, 0x88, 0xf, 0x6f, 0x93, 0xc5, 0xb, 0x7f, 0xb7, 0x46, 0x44, 0xbc, 0xe0, 0x61, 0xc2, 0xe, 0x9f, 0x20, 0xdb, 0xdd, 0xcd, 0x98, 0xe6, 0x3c, 0xdc, 0x69, 0xe0, 0xf4, 0x8a, 0x4, 0x97, 0x53, 0x4b, 0xf5, 0x9c, 0x6, 0x26, 0x31, 0x8, 0x17, 0x1d, 0x5e, 0x48, 0xf, 0x9, 0x54, 0x82, 0x6, 0x34, 0x34, 0x9d, 0x5b, 0xaf, 0xe9, 0xa4, 0xe8, 0xd9, 0x6a, 0xe1, 0xc2, 0x9c, 0x46, 0xc2, 0x89, 0x52, 0x27, 0xb0, 0x4a, 0x44, 0x12, 0x99, 0x3b, 0x8b, 0x6b, 0xbe, 0x5d, 0x66, 0xd5, 0xd0, 0x26, 0x63, 0x5b, 0xce, 0xfb, 0x16, 0x2a, 0x53, 0xe4, 0x84, 0xa9, 0xd9, 0x17, 0x3d, 0x3a, 0x2a, 0xa6, 0xe, 0x60, 0x24, 0x42, 0x93, 0x40, 0xb3, 0x44, 0x85, 0xfd, 0xd6, 0x8b, 0x7, 0x7b, 0x13, 0xf4, 0x13, 0x4c, 0xaf, 0x6d, 0xd7, 0xf3, 0x86, 0x89, 0xe4, 0x93, 0x63, 0x25, 0xb3, 0x14, 0x22, 0x3c, 0x68, 0x4e, 0xd9, 0x9d, 0x50, 0x16, 0x36, 0x46, 0xa7, 0xb7, 0x25, 0xf3, 0x21, 0xc7, 0xbb, 0x60, 0x15, 0x3f, 0x40, 0xe3, 0xcf, 0xec, 0xe9, 0xde, 0x2a, 0x26, 0x3f, 0x3a, 0x10, 0x30, 0x12, 0x48, 0x32, 0x33, 0x6e, 0x12, 0xbe, 0xd3, 0xb8, 0x1d, 0x99, 0xf3, 0xb6, 0xce, 0x3a, 0xcf, 0x87, 0xbb, 0x1d, 0x57, 0x29, 0x8b, 0xca, 0x23, 0xbf, 0xf9, 0x3, 0x40, 0x76, 0xef, 0xa9, 0xa3, 0x62, 0xf3, 0xb, 0x3b, 0x9b, 0x3e, 0x2e, 0xe8, 0x3b, 0x45, 0x5d, 0x8a, 0x63, 0xde, 0xff, 0x54, 0x5e, 0xb6, 0x34, 0x19, 0x10, 0xc7, 0x67, 0xab, 0x1f, 0xca, 0x29, 0x60, 0xc7, 0x24, 0x91, 0x5d, 0xb6, 0x9, 0x26, 0xae, 0x6d, 0x40, 0xf5, 0xe8, 0x7e, 0xf2, 0x8d, 0xb3, 0xa1, 0x33, 0xb6, 0x9f, 0xd6, 0x73, 0xf6, 0xbf, 0x10, 0x88, 0xd7, 0x27, 0xca, 0x8d, 0x62, 0x37, 0xd1, 0x5, 0x5b, 0xd6, 0xb1, 0xcd, 0xa4, 0xe1, 0xbc, 0xc8, 0x49, 0xb6, 0xbc, 0xff, 0x96, 0x2, 0xae, 0xb7, 0x3a, 0x3f, 0x59, 0xbd, 0x3a, 0xac, 0x6d, 0xe, 0x54, 0xe9, 0xd5, 0x33, 0x6f, 0xa3, 0xbc, 0xc, 0xf, 0xd2, 0x27, 0x82, 0xed, 0xbb, 0xb, 0x9b, 0x35, 0xec, 0xfb, 0xd9, 0x97, 0x93, 0xfd, 0x91, 0x3, 0x99, 0xd3, 0x5e, 0x8, 0x9, 0xf1, 0x6b, 0x53, 0x59, 0x7c, 0x24, 0xe4, 0x84, 0x1f, 0xb8, 0xe7, 0xec, 0x3c, 0x4c, 0x43, 0x4b, 0x96, 0x53, 0xe0, 0xc1, 0xf9, 0xd8, 0x59, 0xdc, 0x9a, 0x36, 0x5e, 0x46, 0x1d, 0xb6, 0x82, 0x7c, 0x2a, 0xd1, 0xe0, 0x7c, 0x61, 0x30, 0xda, 0x1b, 0x84, 0xab, 0xf3, 0x1a, 0x76, 0x8, 0x4b, 0xd7, 0xef, 0xb4, 0xf, 0x30, 0x2d, 0xe7, 0x5d, 0x62, 0xee, 0xd0, 0xeb, 0x4a, 0x29, 0x85, 0x34, 0x5c, 0x85, 0xb8, 0xa, 0xe5, 0x32, 0x26, 0x6b, 0x39, 0xa7, 0x4, 0xd8, 0x4b, 0xb1, 0x6e, 0x9a, 0x9f, 0xae, 0xa7, 0xb3, 0xe7, 0x92, 0x43, 0x6, 0xf6, 0x50, 0xc2, 0xf3, 0x38, 0x29, 0x8c, 0xb3, 0x8f, 0x7, 0xc0, 0x4b, 0x1f, 0x41, 0x73, 0x68, 0x76, 0x79, 0x9c, 0xd, 0x17, 0xc4, 0x87, 0xbc, 0x5e, 0x0, 0x47, 0xe8, 0x53, 0x4e, 0xd3, 0x56, 0xc6, 0xf3, 0xd, 0xaf, 0x21, 0x61, 0x6, 0x18, 0xd1, 0x9b, 0xf1, 0x0, 0xb, 0xb8, 0x86, 0xc, 0x27, 0x9b, 0x7e, 0xc2, 0x7c, 0x62, 0x70, 0x70, 0x9c, 0x0, 0xe3, 0xcc, 0xf7, 0x8b, 0xc9, 0x5c, 0xd5, 0x50, 0x20, 0x22, 0x75, 0x1, 0x32, 0x35, 0xbc, 0x2b, 0x3f, 0xe, 0x11, 0x79, 0x1d, 0xf, 0x87, 0xd1, 0x25, 0xb2, 0xb1, 0x77, 0x5f, 0x4a, 0x86, 0x6d, 0xaa, 0x90, 0xa7, 0xcc, 0xb1, 0xc7, 0xd2, 0x14, 0xb1, 0x9f, 0x2, 0x28, 0x25, 0xaa, 0xa, 0x22, 0xdb, 0x78, 0x4, 0x12, 0x50, 0xf6, 0x3b, 0x5a, 0x68, 0x3d, 0xc9, 0xff, 0xe7, 0x6a, 0xb0, 0x35},
+               output224: []byte{0x62, 0xee, 0x8f, 0xc4, 0xe7, 0x72, 0xf3, 0xb2, 0xc5, 0x5, 0x15, 0x44, 0x43, 0xcc, 0xa1, 0x4d, 0xd4, 0xff, 0xc8, 0xd4, 0xf4, 0xf, 0x91, 0xc7, 0xc4, 0xb8, 0xc5, 0xe6},
+               output256: []byte{0x95, 0xc8, 0xe6, 0x82, 0x59, 0xdc, 0xa8, 0xb8, 0x5e, 0x81, 0x68, 0x8c, 0x12, 0x82, 0x80, 0xb5, 0x9f, 0x7e, 0x10, 0x5d, 0x8e, 0xdd, 0x89, 0xcb, 0x9f, 0x29, 0x5b, 0x93, 0xea, 0x40, 0xe2, 0x91},
+               output384: []byte{0xde, 0x42, 0xc7, 0xb0, 0x7, 0x9d, 0x73, 0x8b, 0x18, 0xc7, 0x2, 0xfe, 0x81, 0x28, 0x39, 0x1a, 0xe1, 0x3e, 0x5b, 0x9f, 0xb3, 0xc, 0xdc, 0x43, 0xe3, 0x3d, 0x2, 0xcd, 0x63, 0xd7, 0xca, 0x8c, 0xae, 0x2f, 0xd3, 0xc7, 0x17, 0xd7, 0xca, 0xce, 0x83, 0xc0, 0x7d, 0x41, 0x42, 0x5b, 0xa7, 0x37},
+               output512: []byte{0x51, 0x46, 0xcc, 0x4c, 0x42, 0xa2, 0x65, 0x2e, 0x95, 0x8a, 0x2c, 0xe8, 0x67, 0x4f, 0x5e, 0x17, 0x48, 0xe3, 0xbd, 0x67, 0x4d, 0x49, 0x6c, 0x97, 0x6f, 0xe2, 0x8d, 0x9, 0x85, 0x17, 0xda, 0x3c, 0xd4, 0x4c, 0x1a, 0xcd, 0xd4, 0xbc, 0x47, 0x18, 0x26, 0x0, 0x15, 0x67, 0xb7, 0x66, 0x8c, 0xad, 0x39, 0x60, 0xf4, 0x55, 0xf4, 0x53, 0x0, 0x9, 0x5d, 0xcc, 0xf1, 0xb8, 0xf5, 0x68, 0x1a, 0xe2}},
+       testcase{
+               msg:       []byte{0x8, 0x94, 0x4c, 0xb4, 0x73, 0xb8, 0x28, 0xb1, 0x18, 0xa3, 0x19, 0x86, 0xdb, 0x67, 0xfc, 0x75, 0x7f, 0x23, 0x81, 0x82, 0xe7, 0x90, 0x55, 0x34, 0x4, 0xb7, 0x92, 0xaa, 0x4f, 0x0, 0x95, 0xa6, 0xa8, 0x32, 0x91, 0xe2, 0x87, 0xcd, 0xd1, 0x65, 0x21, 0xa3, 0xae, 0x8c, 0x48, 0xf5, 0x6f, 0xbc, 0x90, 0x9d, 0xfc, 0xcf, 0xaa, 0x7b, 0xcc, 0x57, 0xc, 0x21, 0x59, 0xf2, 0x65, 0x92, 0xdc, 0xd6, 0xb1, 0x5b, 0xc4, 0xdd, 0x55, 0xcc, 0x5, 0x59, 0x5a, 0xc6, 0x34, 0xb2, 0xc3, 0xde, 0x15, 0x36, 0xb, 0xf, 0x7, 0xa0, 0x3b, 0x59, 0x57, 0xbc, 0x93, 0x33, 0xcc, 0x50, 0x97, 0x91, 0x93, 0x99, 0xdd, 0x99, 0x73, 0xac, 0xe1, 0x5e, 0x55, 0x94, 0x1, 0x78, 0xc4, 0xc9, 0x6b, 0xb5, 0xe0, 0xa0, 0xa1, 0xb, 0xae, 0x17, 0x57, 0x69, 0x54, 0x8e, 0xbc, 0xe1, 0x1e, 0xd, 0x7d, 0x9d, 0xb2, 0x96, 0x47, 0xf1, 0x97, 0xd4, 0xb8, 0x7f, 0x70, 0x39, 0xf5, 0xd4, 0xe5, 0x9e, 0x1, 0x65, 0x31, 0xdb, 0xeb, 0xf5, 0x5a, 0x79, 0x7a, 0xc9, 0xa6, 0x83, 0x50, 0x32, 0xcd, 0xf3, 0x42, 0x40, 0xa7, 0xee, 0x74, 0x23, 0xe8, 0x9c, 0x9, 0x12, 0x48, 0x29, 0xca, 0xfc, 0x5f, 0x89, 0x43, 0x1c, 0x8a, 0xfc, 0x54, 0xfd, 0x97, 0x9e, 0x50, 0xd4, 0x8a, 0x82, 0xb4, 0x7a, 0x53, 0x52, 0x3c, 0x84, 0xb6, 0x0, 0x4d, 0xaa, 0x32, 0x3e, 0xfb, 0x70, 0x82, 0x3, 0xe5, 0x38, 0x8a, 0x6a, 0x51, 0x10, 0xc6, 0xce, 0x2e, 0x34, 0x10, 0x48, 0xa6, 0x5f, 0xde, 0xad, 0xeb, 0x38, 0x37, 0xa0, 0x34, 0x20, 0xf9, 0xfa, 0xdd, 0xc3, 0xf0, 0x2a, 0x54, 0x4f, 0x1e, 0x46, 0xd9, 0x6b, 0x7, 0xc9, 0xc, 0x79, 0x71, 0xa7, 0x4, 0xa, 0x17, 0x9e, 0x81, 0x98, 0xe9, 0xa, 0xa0, 0x19, 0x26, 0x8e, 0x0, 0x36, 0x71, 0x20, 0xd5, 0xf3, 0xd9, 0x8a, 0x5c, 0xce, 0x82, 0xc8, 0x85, 0xe7, 0x71, 0x44, 0xb1, 0xaa, 0xd6, 0x6e, 0xe6, 0x82, 0x84, 0x77, 0x76, 0xb0, 0x4f, 0x1, 0xf5, 0x1, 0xdc, 0xbe, 0xfe, 0x39, 0x3, 0x8, 0xa, 0x80, 0x58, 0xb3, 0xb8, 0xf1, 0xd8, 0x23, 0xd9, 0x17, 0xec, 0xf3, 0x1f, 0xc2, 0xd5, 0xb0, 0x79, 0x5b, 0xf9, 0x5a, 0x55, 0xc7, 0x9, 0x3e, 0xca, 0x7c, 0x80, 0x1d, 0xd0, 0xbd, 0xd, 0xbd, 0xbe, 0xde, 0x7d, 0x56, 0x51, 0x31, 0x28, 0xb2, 0x9f, 0xc0, 0xb4, 0xd2, 0x5a, 0x62, 0x40, 0xb2, 0x4c, 0x99, 0xe0, 0x17, 0xbd, 0xff, 0x7a, 0xca, 0xfc, 0x8f, 0x8d, 0xe9, 0xfa, 0xf5, 0xa2, 0x94, 0x43, 0x84, 0xae, 0xce, 0x82, 0xbe, 0xa0, 0x4d, 0xcc, 0xc6, 0xd5, 0x1f, 0xc6, 0xe6, 0xf2, 0x7a, 0xa3, 0x8f, 0x13, 0x1b, 0x79, 0x59, 0xb1, 0x36, 0x81, 0xa0, 0x9b, 0x31, 0x1d, 0x24, 0x2e, 0x62, 0x22, 0xa1, 0xce, 0x56, 0x87, 0xde, 0x5c, 0x8, 0x5, 0x8, 0xb1, 0xdb, 0x16, 0xb6, 0xf8, 0x29, 0xd, 0x33, 0xa3, 0xcc, 0xd, 0x1, 0x38, 0xac, 0x61, 0xfd, 0x90, 0x93, 0x82, 0x5e, 0x9d, 0x37, 0x52, 0x88, 0x9e, 0x9f, 0x20, 0xdb, 0x9f, 0x80, 0xf9, 0x27, 0x50, 0xea, 0xc8, 0x8b, 0x38, 0xac, 0x81, 0xc0, 0x1, 0x6d, 0x40, 0x37, 0x1e, 0xab, 0x4a, 0x87, 0xe8, 0x45, 0xe9, 0x14, 0x46, 0xb0, 0xa0, 0x70, 0x81, 0xb8, 0x4f, 0x55, 0x9c, 0xdb, 0x95, 0x34, 0xc, 0xb0, 0x20, 0xaf, 0x22, 0xae, 0xa1, 0xbf, 0xf2, 0xfd, 0xa1, 0x2f, 0x7a, 0x42, 0x97, 0x3f, 0xf1, 0x63, 0xa1, 0xc6, 0xf3, 0x3d, 0xb8, 0xb8, 0x21, 0x4a, 0xe2, 0x7a, 0xbd, 0xf1, 0xc5, 0x4f, 0x5b, 0x3, 0xe2, 0x93, 0x10, 0xfa, 0x21, 0x1, 0x25, 0xe1, 0x29, 0x6e, 0x8a, 0xf9, 0x3a, 0x29, 0x96, 0xdb, 0xae, 0xfb, 0xad, 0xd4, 0xc5, 0x1c, 0x2c, 0x3b, 0x8a, 0x3e, 0x2b, 0xc9, 0xfe, 0x6, 0xc, 0x42, 0xba, 0x32, 0x76, 0x8f, 0x69, 0x92, 0xa9, 0x95, 0x99, 0x20, 0x6c, 0xd2, 0x29, 0x1c, 0xcc, 0x5b, 0xbd, 0x50, 0x85, 0x6f, 0x7f, 0x8d, 0x2d, 0xa, 0xe1, 0xef, 0xb5, 0x89, 0x2c, 0x15, 0xa7, 0x99, 0xb7, 0x74, 0x82, 0xde, 0x45, 0x53, 0x73, 0x6b, 0x16, 0x2a, 0xbb, 0x6, 0x63, 0x1f, 0x16, 0x88, 0xf6, 0x74, 0x6e, 0x7d, 0x7a, 0x37, 0xee, 0x7e, 0xf2, 0x4e, 0x6c, 0xc9, 0x1, 0x17, 0x5f, 0x4, 0x96, 0xc, 0x1, 0x99, 0x1, 0x78, 0xf8, 0x1e, 0x95, 0x7e, 0x94, 0x1d, 0xea, 0xac, 0x88, 0x46, 0xb3, 0x70, 0x4e, 0x24, 0x20, 0x4f, 0x43, 0xdd, 0xb0, 0x76, 0x5c, 0x43, 0x3f, 0x3f, 0x7d, 0x4d, 0x20, 0x14, 0x59, 0xcd, 0x65, 0x68, 0x2b, 0x7d, 0xdf, 0x3d, 0x47, 0xe9, 0x5c, 0xdb, 0x31, 0xb9, 0x6a, 0x4c, 0xb2, 0x29, 0x7, 0xf0, 0x8b, 0xa6, 0xe9, 0x2a, 0x4a, 0x7, 0x70, 0x3b, 0x2d, 0xcf, 0x15, 0xf, 0x92, 0x2c, 0x4b, 0x7c, 0xf1, 0x81, 0x38, 0x3, 0x3, 0xfb, 0x72, 0x54, 0x78, 0x47, 0x30, 0x59, 0x99, 0xc3, 0xc8, 0xf9, 0xac, 0x87, 0x7d, 0x5, 0xd9, 0xdc, 0x41, 0x59, 0xde, 0xb8, 0xa1, 0x3d, 0x36, 0xad, 0x1d, 0x53, 0x3a, 0x56, 0x95, 0xe, 0x20, 0xf9, 0x6, 0xd2, 0x9d, 0x51, 0xdd, 0xc4, 0x5b, 0xd1, 0x5c, 0x17, 0x73, 0x99, 0x17, 0x7, 0x48, 0xe, 0x37, 0xb8, 0x27, 0x4, 0x4b, 0xdc, 0x64, 0x73, 0x18, 0x1b, 0x76, 0xa, 0x90, 0x36, 0xe0, 0xd3, 0xfa, 0x49, 0x1c, 0x2f, 0x8, 0xc5, 0x51, 0x30, 0xd8, 0xcd, 0xd5, 0xac, 0x8e, 0x97, 0xd0, 0x81, 0x31, 0x64, 0xaf, 0x3d, 0x28, 0xa5, 0x85, 0xf0, 0xc2, 0xec, 0x70, 0x4, 0xd4, 0x98, 0xf9, 0x5c, 0x6b, 0x62, 0x23, 0x1a, 0x63, 0x2a, 0x56, 0xc2, 0xd0, 0xc4, 0x8f, 0xc3, 0xa6, 0x99, 0x2d, 0x40, 0x51, 0x95, 0x7b, 0x9e, 0xd6, 0xd9, 0xa8, 0x6d, 0xbc, 0xcd, 0x96, 0x2a, 0x88, 0x83, 0xcf, 0x82, 0xca, 0xf0, 0x1d, 0xa2, 0xf5, 0x1a, 0x20, 0x3d, 0x56, 0xb6, 0x8, 0x9b, 0xc8, 0xfd, 0xb, 0x1b, 0xd4, 0x14, 0xc8, 0x6, 0x30, 0x31, 0xed, 0x46, 0x95, 0x55, 0xe2, 0x2e, 0xf8, 0x72, 0x68, 0x9c, 0x13, 0xb, 0x1c, 0x10, 0x10, 0x34, 0xd5, 0x72, 0xfd, 0x8c, 0xd0, 0xed, 0xda, 0xbe, 0xc9, 0xef, 0x15, 0x3, 0xd7, 0xf7, 0x28, 0xb0, 0x94, 0x1e, 0xfe, 0x2b, 0x95, 0x12, 0x43, 0x8c, 0x7d, 0xdb, 0x17, 0x6b, 0xe2, 0xec, 0x2d, 0x9f, 0xfc, 0xd5, 0x64, 0x95, 0xa4, 0x51, 0x14, 0x28, 0xdf, 0x2, 0x81, 0x9c, 0xdd, 0xa1, 0x8d, 0x1e, 0xd5, 0xd3, 0xb1, 0x6c, 0x6f, 0x42, 0xaa, 0xa, 0xc6, 0x81, 0xa9, 0xfa, 0xb5, 0x1e, 0x8a, 0x1a, 0x85, 0x6c, 0x15, 0xc5, 0x1a, 0x3e, 0xc1, 0x3, 0x14, 0x27, 0x14, 0x2e, 0xa1, 0x25, 0x43, 0x1, 0x4d, 0xd4, 0xac, 0xac, 0x64, 0xb, 0x8a, 0x77, 0x29, 0xe6, 0x3a, 0xb7, 0xdf, 0x10, 0x51, 0x11, 0x2c, 0xde, 0xfd, 0x4b, 0x98, 0x8a, 0x22, 0x58, 0x33, 0x4f, 0xa9, 0xa7, 0xf5, 0xb3, 0xa8, 0x7a, 0x2, 0x7, 0x4b, 0x9f, 0x69, 0xdd, 0x81, 0xb8, 0x3f, 0xc7, 0x40, 0x89, 0xa9, 0x1d, 0x76, 0xaa, 0x40, 0x41, 0x25, 0x9e, 0x80, 0xfa, 0x25, 0x5f, 0x20, 0x84, 0x90, 0x2a, 0xeb, 0x9e, 0x99, 0x6a, 0xc2, 0x28, 0x8a, 0xb4, 0x64, 0xbd, 0xec, 0x47, 0xaa, 0xb2, 0x6a, 0x28, 0xa2, 0xa8, 0x19, 0x49, 0x89, 0x75, 0x5d, 0x48, 0xfc, 0x9a, 0x5c, 0x92, 0x79, 0x28, 0x5f, 0x2f, 0x1d, 0xbb, 0x8b, 0x80, 0x18, 0xf3, 0xe4, 0xe1, 0x31, 0x15, 0xd7, 0x8a, 0x87, 0x97, 0x92, 0xe4, 0x5a, 0x8f, 0x4f, 0x24, 0xed, 0x4a, 0x31, 0x74, 0x40, 0xba, 0x63, 0xe6, 0x92, 0x90, 0x56, 0xef, 0xc1, 0xd2, 0x52, 0x9b, 0x75, 0xa7, 0x9, 0xd6, 0xc0, 0x9, 0x7d, 0xc2, 0xd9, 0x7f, 0x64, 0x6f, 0x33, 0x4e, 0xbe, 0x61, 0x95, 0xec, 0x56, 0x30, 0x13, 0x2f, 0xde, 0x58, 0xe2, 0x5d, 0xbc, 0x17, 0xda, 0xd8, 0x22, 0xd9, 0xfa, 0x9, 0x38, 0xa2, 0xa2, 0xc9, 0x26, 0xb1, 0x5, 0xd1, 0x8, 0x40, 0x3d, 0xc2, 0x9c, 0xf3, 0x71, 0xc3, 0x50, 0x4f, 0xf7, 0x3b, 0xce, 0x9c, 0x7a, 0xcf, 0x9a, 0x74, 0xc4, 0x95, 0x4c, 0xe6, 0xa3, 0x2d, 0xa9, 0x6b, 0x21, 0xcf, 0x32, 0x11, 0xb3, 0xe4, 0x99, 0x53, 0xda, 0xb7, 0x8c, 0x49, 0xc3, 0xe5, 0x32, 0xa3, 0x49, 0x0, 0x3c, 0x59, 0xc6, 0x2f, 0x7d, 0x40, 0x26, 0x1c, 0xba, 0x63, 0xa9, 0xea, 0x21, 0xc8, 0x9a, 0x38, 0xaa, 0x63, 0xce, 0x43, 0x1c, 0x43, 0xae, 0x26, 0x1c, 0x4d, 0x99, 0x99, 0xb1, 0xca, 0xf4, 0x91, 0xfa, 0xb8, 0xe7, 0xbe, 0x6e, 0x8c, 0x34, 0x54, 0xf1, 0xbe, 0x87, 0x93, 0xb2, 0xd2, 0x71, 0x41, 0xfc, 0x10, 0x7d, 0xa5, 0x99, 0xa4, 0x69, 0x4c, 0x41, 0x35, 0x3d, 0x77, 0x85, 0xc0, 0x5b, 0x5e, 0x31, 0x44, 0x4, 0x58, 0xd1, 0x7c, 0x6d, 0xb6, 0x6f, 0xeb, 0x8a, 0x9c, 0x5c, 0x7, 0x3f, 0xb9, 0x46, 0xa6, 0x7a, 0xc0, 0x31, 0x2b, 0xb6, 0x69, 0xd9, 0xb1, 0x2f, 0xab, 0xaa, 0x52, 0x72, 0xca, 0x66, 0x31, 0x37, 0x9e, 0xf4, 0xed, 0x42, 0xa, 0x44, 0x24, 0xa5, 0xcd, 0x8, 0x52, 0x63, 0x84, 0xc0, 0x47, 0xc3, 0x3a, 0x84, 0xd5, 0xd7, 0xdc, 0xc, 0x21, 0x53, 0x66, 0x3b, 0x54, 0xc7, 0x3d, 0xd7, 0x99, 0xa3, 0x56, 0x8c, 0x1, 0xb8, 0x18, 0x99, 0x2c, 0xdf, 0x81, 0x43, 0xf1, 0xda, 0xdd, 0x6b, 0x50, 0xca, 0xe6, 0xea, 0xe1, 0x3a, 0xc6, 0x6f, 0x31, 0xff, 0xa2, 0xb3, 0x62, 0xcc, 0x4d, 0x28, 0x80, 0x59, 0x2b, 0x7f, 0xee, 0x4b, 0x9e, 0x4c, 0xd6, 0xaa, 0x5e, 0x5d, 0xe2, 0x7a, 0xab, 0x9b, 0x5d, 0xad, 0x9f, 0x7d, 0x39, 0x40, 0x7a, 0xe9, 0x27, 0x53, 0xc, 0xab, 0x2b, 0x61, 0xcd, 0x73, 0x94, 0xa2, 0x1e, 0xf4, 0x7b, 0xfb, 0x81, 0x3b, 0x5e, 0xa6, 0x9, 0x14, 0x58, 0xd2, 0x39, 0x66, 0x49, 0x23, 0x28, 0xe, 0xd0, 0xd5, 0xcc, 0xa8, 0x28, 0x5b, 0xb2, 0x28, 0x1a, 0x2f, 0x9f, 0xb3, 0xff, 0xec, 0xc8, 0xe9, 0x14, 0x7e, 0x1e, 0x8f, 0xac, 0x95, 0x7d, 0x90, 0xc9, 0xe5, 0xf5, 0x13, 0x73, 0x87, 0x45, 0xa4, 0x7c, 0x2a, 0xd0, 0xc3, 0x1f, 0xd8, 0x98, 0x6e, 0xf3, 0xb6, 0x38, 0x8c, 0x6e, 0x82, 0x1f, 0x16, 0x65, 0x13, 0x81, 0x1d, 0x54, 0x7a, 0xb4, 0x33, 0x6b, 0x5e, 0x4, 0x64, 0x34, 0x97, 0xfc, 0x9f, 0x8d, 0x6e, 0x38, 0xe, 0xf6, 0x47, 0x8b, 0x82, 0xb6, 0xe2, 0xf5, 0xf6, 0x5d, 0xd9, 0x8a, 0x63, 0xc6, 0x8c, 0x32, 0xb9, 0x46, 0x10, 0xe1, 0xd3, 0xb9, 0x53, 0x8f, 0x13, 0xa7, 0x68, 0x8f, 0xbb, 0x1e, 0xc3, 0x44, 0x8b, 0xe9, 0xbd, 0x77, 0xbb, 0x93, 0xa3, 0x45, 0x46, 0x17, 0x2a, 0xe8, 0xd6, 0x14, 0xf8, 0x52, 0x28, 0x98, 0x8e, 0x7f, 0xeb, 0x18, 0xc9, 0xa0, 0xc9, 0x82, 0x76, 0x99, 0xe8, 0xb3, 0xcb, 0xc6, 0x97, 0x50, 0xbd, 0xfe, 0xcd, 0xa8, 0x26, 0x8f, 0x69, 0x4f, 0x4c, 0x50, 0x9b, 0xef, 0xc1, 0xa1, 0x16, 0x6f, 0x85, 0xc8, 0x29, 0x72, 0x52, 0x99, 0xd1, 0x73, 0xf8, 0x67, 0xa3, 0x0, 0x98, 0x7a, 0x2d, 0x36, 0xd1, 0xbb, 0xbe, 0x37, 0xbe, 0x32, 0x8, 0xfb, 0x8e, 0xfe, 0x91, 0x52, 0xa4, 0x1a, 0x5f, 0xe, 0x93, 0x1b, 0x63, 0x82, 0xff, 0x7f, 0x9b, 0x18, 0x93, 0x79, 0x58, 0xfb, 0x18, 0xe, 0x61, 0xf2, 0xa8, 0xc2, 0x8f, 0x36, 0xc3, 0xc8, 0xc, 0x37, 0x22, 0x93, 0x5a, 0xac, 0xb8, 0x1c, 0x24, 0xaa, 0x17, 0xfb, 0x3e, 0x7a, 0x10, 0x26, 0xf7, 0x3, 0x1a, 0x74, 0x49, 0x81, 0x8e, 0xd6, 0x2b, 0xa7, 0x70, 0x5c, 0xa2, 0x7c, 0x2d, 0x32, 0x68, 0xf9, 0xb, 0x63, 0x22, 0x92, 0x16, 0x83, 0xdf, 0xf8, 0x0, 0xa3, 0x6, 0xcf, 0xc1, 0x86, 0xcf, 0x2a, 0x61, 0xb3, 0x7f, 0x35, 0x83, 0x7b, 0x21, 0x7e, 0x3b, 0x2c, 0xec, 0xb0, 0x84, 0x3d, 0x84, 0xea, 0xc6, 0x74, 0x31, 0xe3, 0xd6, 0x89, 0xf0, 0x15, 0x22, 0xd4, 0xa4, 0xc7, 0x36, 0x18, 0xb7, 0xc2, 0x96, 0x5c, 0x9d, 0xab, 0xb1, 0x5c, 0xb, 0xe6, 0x37, 0xd1, 0xc, 0xee, 0xf7, 0x22, 0x71, 0xcf, 0x39, 0xa7, 0xb8, 0x3, 0xb4, 0x17, 0x67, 0xbc, 0x34, 0x43, 0x3c, 0x3e, 0x6f, 0xf4, 0x49, 0xa4, 0x39, 0xae, 0x13, 0xda, 0x1e, 0xaf, 0xa0, 0x38, 0xcb, 0x9f, 0x2e, 0x1c, 0x84, 0xf1, 0xce, 0x39, 0xc0, 0x5d, 0xf5, 0x6f, 0xe3, 0xd7, 0xb8, 0x23, 0x86, 0xc4, 0xe6, 0x28, 0xb6, 0xe2, 0x7c, 0xbc, 0x5d, 0x57, 0x5c, 0x66, 0xad, 0xa3, 0x51, 0xc, 0x24, 0x6b, 0xd0, 0x4d, 0xb4, 0x8f, 0x4a, 0xfc, 0x2d, 0x73, 0x52, 0x96, 0x6d, 0xa2, 0x26, 0x6c, 0x2b, 0xc9, 0x83, 0x15, 0x32, 0xf5, 0x36, 0x55, 0xd8, 0xbe, 0x42, 0xb4, 0x21, 0xac, 0xd, 0x70, 0xd8, 0xad, 0x1d, 0x35, 0x87, 0x25, 0x78, 0x86, 0xdb, 0xf9, 0x36, 0x68, 0xe9, 0x7, 0xe8, 0x61, 0xba, 0x64, 0xf4, 0x59, 0x99, 0xba, 0xdb, 0xf, 0x76, 0x6e, 0xad, 0xce, 0x52, 0x38, 0xb5, 0xed, 0x39, 0x7f, 0x26, 0x59, 0x35, 0x19, 0x48, 0x12, 0xc0, 0x3c, 0x57, 0x69, 0x13, 0x7b, 0xac, 0x97, 0x14, 0x5, 0x25, 0x30, 0x3c, 0xf4, 0x8d, 0x65, 0xf3, 0x90, 0x4, 0xa3, 0xf5, 0x9b, 0x1f, 0xab, 0x9, 0x89, 0x5c, 0xee, 0x5, 0x33, 0x5d, 0x15, 0xb9, 0xb1, 0x22, 0x65, 0x89, 0x2f, 0x4a, 0xbb, 0x92, 0xab, 0x1d, 0xd2, 0x0, 0x2e, 0xd0, 0xc, 0xf3, 0x56, 0x2c, 0xb6, 0x7d, 0xfe, 0x10, 0x55, 0x96, 0x8e, 0x4a, 0xb3, 0x30, 0x6b, 0xb3, 0x4b, 0xb8, 0x7d, 0xf, 0x64, 0xb2, 0x68, 0x48, 0x81, 0x2a, 0x2f, 0x7b, 0x50, 0x42, 0x4a, 0x21, 0xff, 0x94, 0x8, 0x1a, 0x7f, 0x70, 0xf7, 0xb6, 0x84, 0xab, 0xf, 0x9, 0x2b, 0x2b, 0x8, 0x5d, 0xcf, 0x84, 0xca, 0x38, 0x41, 0x4c, 0xf7, 0x29, 0xf, 0x60, 0x7b, 0xf7, 0x9c, 0x37, 0xea, 0x84, 0x25, 0x3a, 0xbc, 0xa8, 0xd4, 0x18, 0x4d, 0x2d, 0xbe, 0x2e, 0x90, 0x2, 0x0, 0xb8, 0x14, 0x79, 0xe1, 0xce, 0x8b, 0x71, 0xdc, 0xf2, 0xbd, 0x6e, 0x3c, 0x55, 0x7a, 0x8e, 0x43, 0x1d, 0x62, 0x7b, 0xa6, 0x69, 0xc2, 0xea, 0x3, 0x6, 0x8e, 0xf, 0x7e, 0xa6, 0x2c, 0x29, 0x77, 0x7b, 0x22, 0x14, 0x2d, 0x7a, 0x1d, 0x45, 0x1b, 0xd5, 0x41, 0xef, 0x8e, 0xbd, 0xdb, 0xba, 0x4e, 0x3b, 0xd8, 0xff, 0xcd, 0x34, 0xe, 0x93, 0x5b, 0xe7, 0xc6, 0x6e, 0xfc, 0x14, 0xa1, 0x3e, 0xa4, 0x81, 0x34, 0xf6, 0x55, 0xb0, 0xde, 0x31, 0x80, 0x10, 0x1f, 0x9, 0xd2, 0x4, 0xc3, 0x79, 0x74, 0x3a, 0x35, 0x7e, 0x6d, 0xf1, 0x26, 0x8b, 0x55, 0xa9, 0xf7, 0x52, 0x43, 0x98, 0xec, 0xf3, 0xa5, 0x98, 0x49, 0xa2, 0x7b, 0x14, 0x22, 0x39, 0x5, 0x99, 0x98, 0x8, 0x3e, 0x8f, 0xa9, 0x17, 0x85, 0xe9, 0x1c, 0x4d, 0x22, 0xb, 0x2f, 0xb1, 0x7e, 0x33, 0x89, 0xeb, 0xaa, 0x38, 0x4a, 0x49, 0xd8, 0x9b, 0x5d, 0x78, 0x13, 0x6d, 0xd2, 0x45, 0x4f, 0x6, 0xcd, 0xe9, 0x83, 0x7f, 0x9, 0x6b, 0x74, 0x4d, 0x53, 0x22, 0x11, 0x27, 0x86, 0x99, 0x4, 0xac, 0x22, 0x7c, 0xdf, 0x30, 0xbf, 0xea, 0x78, 0xcc, 0x55, 0x45, 0x58, 0x3f, 0x99, 0x9b, 0x9c, 0x42, 0xa1, 0x18, 0x4e, 0x2f, 0xb9, 0xff, 0x3e, 0xc0, 0x95, 0xb9, 0xda, 0xd, 0x13, 0x82, 0x5, 0xc4, 0xea, 0xc4, 0xc8, 0xc4, 0x80, 0xc4, 0x31, 0x53, 0x60, 0x88, 0x49, 0xf6, 0x3e, 0x16, 0x11, 0x35, 0xc7, 0x9d, 0x8b, 0x6c, 0x9c, 0xfe, 0x9b, 0x8d, 0xfd, 0x8a, 0xfa, 0xb5, 0x59, 0xd8, 0xb5, 0x95, 0xdd, 0xd4, 0x38, 0x35, 0x3, 0x3b, 0x4b, 0xbd, 0x39, 0x1e, 0x2, 0x8b, 0xb2, 0xa6, 0x8, 0x32, 0xd9, 0xb6, 0x97, 0xee, 0x61, 0x40, 0x8f, 0x14, 0x97, 0x44, 0xdc, 0xe7, 0x1a, 0xa1, 0x1b, 0xb2, 0xb0, 0x43, 0x6c, 0x1e, 0x26, 0x26, 0xac, 0x3a, 0x27, 0xcd, 0xa2, 0x93, 0x36, 0x6b, 0x90, 0xb9, 0xcd, 0xe2, 0xd9, 0x27, 0x85, 0x51, 0x30, 0x75, 0x8d, 0x39, 0x46, 0xb8, 0x67, 0x19, 0x2d, 0xcf, 0x3f, 0xce, 0x9a, 0x3b, 0x9a, 0x52, 0x76, 0xe8, 0xc3, 0x7b, 0x8c, 0xb1, 0x36, 0xfc, 0x90, 0xa6, 0xdc, 0x22, 0x65, 0xf, 0x95, 0xe7, 0x96, 0xa9, 0x88, 0x6e, 0xfd, 0x3f, 0x42, 0x4b, 0xe6, 0x3a, 0x66, 0xdb, 0xb1, 0x4, 0x1c, 0xb3, 0xd4, 0xa0, 0x6f, 0x4e, 0x7e, 0xee, 0x89, 0xf0, 0xb6, 0xd1, 0x5c, 0x36, 0xf9, 0xea, 0x1, 0xc, 0x66, 0xb3, 0x32, 0x1, 0x1c, 0x88, 0x88, 0xe8, 0xe4, 0xab, 0x2b, 0x3a, 0xb5, 0x22, 0x31, 0x91, 0xe1, 0x38, 0x86, 0x13, 0xa0, 0xfd, 0xf, 0x7, 0xc1, 0xb2, 0x6d, 0x7c, 0xc7, 0xcd, 0xf1, 0xac, 0x62, 0xa2, 0x26, 0x45, 0x4d, 0x62, 0x91, 0xb4, 0x31, 0xcc, 0x3e, 0xf2, 0xdb, 0x2b, 0x24, 0x42, 0xb3, 0x7d, 0xef, 0xb9, 0x42, 0x11, 0x7f, 0xa2, 0x47, 0x9, 0x6b, 0xea, 0xe5, 0x98, 0x61, 0x1b, 0x81, 0x4, 0xf3, 0x7b, 0xeb, 0xed, 0xd8, 0xbb, 0x8b, 0x94, 0x9a, 0x89, 0xb5, 0xbf, 0x8e, 0x22, 0x8e, 0xca, 0x1d, 0x8f, 0x16, 0xbf, 0xec, 0x75, 0xa0, 0x2f, 0xfb, 0xb4, 0xee, 0xe3, 0xa6, 0xd4, 0xa6, 0x8, 0x7c, 0x43, 0x63, 0x4d, 0x67, 0x53, 0x11, 0xe7, 0x2a, 0x9f, 0x32, 0x53, 0xbb, 0x5d, 0xd3, 0x64, 0xe0, 0x7e, 0xb4, 0xb9, 0xc8, 0x4f, 0x58, 0x6b, 0xa2, 0x67, 0xba, 0xff, 0xae, 0xfe, 0xc7, 0x9e, 0x3, 0xb8, 0x3b, 0x18, 0x59, 0x5f, 0xe0, 0x6d, 0x7e, 0x6, 0x3e, 0xe6, 0x4, 0xff, 0x28, 0x70, 0x4, 0xd1, 0x41, 0xc1, 0xa4, 0x3a, 0xf0, 0xca, 0x7c, 0x56, 0x51, 0xd9, 0x8f, 0x63, 0x3f, 0xa8, 0x75, 0xb4, 0x74, 0x33, 0x53, 0xfb, 0x7, 0xbd, 0xe5, 0x9b, 0x65, 0x67, 0xae, 0x25, 0xf7, 0x9, 0x5f, 0x1d, 0x9e, 0xdf, 0x30, 0x57, 0xe, 0x2f, 0x7d, 0x7e, 0xc1, 0x94, 0x21, 0x68, 0x98, 0xd9, 0x10, 0xf9, 0xe2, 0x95, 0xa4, 0x1d, 0xfe, 0xe0, 0x72, 0xcb, 0x56, 0xf9, 0x14, 0xbb, 0x78, 0xcc, 0x98, 0x54, 0x12, 0x92, 0x50, 0xf9, 0x87, 0x4b, 0x63, 0xbb, 0x3e, 0xbe, 0x9a, 0x1c, 0xdc, 0x6e, 0xbc, 0xb0, 0x91, 0x6e, 0x1c, 0x44, 0x3, 0x54, 0xde, 0xd6, 0xaa, 0x81, 0x8f, 0x28, 0x11, 0xda, 0x91, 0x39, 0x12, 0xa2, 0x1d, 0x39, 0x61, 0xac, 0x94, 0xa3, 0x9f, 0x8, 0x27, 0xd3, 0xa4, 0x19, 0x61, 0x69, 0x5, 0xdc, 0x45, 0x84, 0x2c, 0x8e, 0x69, 0xa4, 0x30, 0x4, 0xb8, 0xae, 0x92, 0x2c, 0x8d, 0xe1, 0xe8, 0xcd, 0x6, 0x68, 0x67, 0x4a, 0x77, 0x60, 0x15, 0x32, 0x13, 0x83, 0x5b, 0xc6, 0x3f, 0xae, 0x4f, 0x8d, 0x65, 0x61, 0x4a, 0xfd, 0x74, 0xa3, 0x4d, 0x42, 0xab, 0xad, 0x50, 0x25, 0xb8, 0x84, 0xb3, 0x46, 0x39, 0x34, 0xb, 0x45, 0xd4, 0x9c, 0xce, 0xd4, 0x23, 0x77, 0x19, 0x16, 0xe1, 0x8a, 0xa0, 0x77, 0x29, 0x19, 0x23, 0x1, 0x7c, 0xa5, 0x7, 0x95, 0xf3, 0xb7, 0xa3, 0xf3, 0x49, 0xa3, 0xd2, 0x99, 0x23, 0x83, 0x3c, 0xe5, 0x78, 0x1, 0xc6, 0x31, 0x57, 0x6e, 0x23, 0xb8, 0x38, 0xa7, 0x76, 0x7c, 0xa1, 0xbd, 0xa9, 0x2b, 0x82, 0xac, 0x50, 0x2d, 0xb3, 0x68, 0x8f, 0xfc, 0x83, 0xc0, 0x9a, 0x4e, 0x40, 0xca, 0xc3, 0x1d, 0x20, 0xd9, 0xd3, 0x2f, 0xa6, 0x72, 0x4a, 0x80, 0xbe, 0x70, 0x91, 0xcd, 0xe9, 0xc7, 0xa6, 0x56, 0xc, 0xfb, 0x32, 0x6b, 0x46, 0x7c, 0xad, 0xdb, 0x9e, 0x9b, 0x7a, 0x49, 0x1e, 0xda, 0x28, 0x3e, 0xfb, 0xb, 0x61, 0xb4, 0xa1, 0x11, 0x6d, 0xd8, 0x59, 0xd5, 0xc0, 0x89, 0x7e, 0xaa, 0x2a, 0x3f, 0xb2, 0xcd, 0x82, 0xff, 0xb3, 0x37, 0x70, 0xbf, 0x9e, 0x8, 0x9, 0x13, 0x63, 0xb6, 0xb8, 0x1d, 0x23, 0xe6, 0x1c, 0x2a, 0x64, 0x7d, 0x2b, 0xe4, 0x40, 0xc5, 0xc7, 0x9e, 0xa8, 0x96, 0x90, 0x65, 0x6d, 0x9f, 0x10, 0xb1, 0xf0, 0x79, 0x42, 0x83, 0x4e, 0x1c, 0xb6, 0xe2, 0xd2, 0xdf, 0x10, 0x6e, 0xb6, 0xd6, 0xa2, 0x1f, 0xa2, 0x38, 0x19, 0xe6, 0x50, 0x28, 0x51, 0x5e, 0x88, 0xbd, 0x27, 0x9f, 0x93, 0x17, 0xbe, 0xaf, 0xfd, 0x39, 0x4e, 0xa5, 0x1f, 0x86, 0x39, 0x37, 0x1c, 0x3a, 0x89, 0xf1, 0x13, 0x5, 0xa4, 0xca, 0x35, 0xfb, 0x7, 0x11, 0xf5, 0xe2, 0xc7, 0xc3, 0xdd, 0x16, 0x59, 0xc7, 0x90, 0x24, 0x58, 0x12, 0x11, 0x32, 0x4, 0xb4, 0xed, 0x8a, 0xae, 0x9f, 0xf0, 0x9d, 0x43, 0xc6, 0xdd, 0xb1, 0x3f, 0x50, 0x70, 0xd9, 0x88, 0x31, 0xb2, 0xc7, 0x63, 0x9f, 0xb6, 0xb9, 0xb0, 0x1c, 0x28, 0x88, 0x12, 0xdd, 0xfa, 0x88, 0x61, 0xdb, 0x32, 0xdc, 0x82, 0x68, 0xc0, 0x7d, 0x30, 0xcf, 0x96, 0x99, 0x53, 0x4, 0x2b, 0x3d, 0xad, 0x53, 0xd, 0x9d, 0x74, 0x4c, 0x6, 0xaa, 0xbe, 0x7a, 0x88, 0x6c, 0xf, 0xe5, 0x7b, 0x9, 0xb7, 0xf4, 0x2d, 0x19, 0x3f, 0xb3, 0xe9, 0xc0, 0x63, 0x29, 0x81, 0x82, 0x51, 0xa2, 0xf7, 0xe6, 0x47, 0x44, 0x62, 0xc9, 0x5d, 0xed},
+               output224: []byte{0xc1, 0x75, 0x6c, 0x1, 0xc, 0x17, 0x3e, 0x99, 0x9b, 0x6c, 0xf1, 0x1e, 0x3b, 0x6b, 0xf4, 0x40, 0xc, 0x8c, 0x86, 0x6a, 0x18, 0xc2, 0x67, 0x3a, 0x47, 0x5, 0xdf, 0x79},
+               output256: []byte{0x3d, 0x20, 0x74, 0x6d, 0xda, 0x87, 0x1a, 0x10, 0x42, 0x2, 0xec, 0x1a, 0xd7, 0xd6, 0xd, 0x8e, 0x16, 0x5f, 0xbf, 0x97, 0xaf, 0xc1, 0x92, 0x95, 0x11, 0xe4, 0x17, 0x81, 0xa3, 0x5c, 0xba, 0x45},
+               output384: []byte{0x55, 0x31, 0xa3, 0x4d, 0x85, 0x65, 0xa9, 0x4b, 0x73, 0x57, 0xba, 0x71, 0x71, 0xae, 0x7e, 0xdd, 0x1e, 0x61, 0xac, 0xaf, 0xc1, 0x74, 0x7d, 0xba, 0xc4, 0xd4, 0xc0, 0x22, 0xb8, 0xac, 0xc6, 0x64, 0x9c, 0x8e, 0x44, 0xec, 0x2d, 0x64, 0x55, 0xe6, 0x23, 0xbc, 0xac, 0xf1, 0xc, 0x39, 0x15, 0xe4},
+               output512: []byte{0xb1, 0x41, 0x28, 0x9f, 0xc8, 0xe9, 0x71, 0x91, 0xc3, 0xa4, 0x5a, 0x12, 0x5e, 0xb2, 0x98, 0x31, 0xc5, 0x32, 0xf7, 0x64, 0xc9, 0x92, 0x4a, 0x5e, 0xc1, 0x75, 0x52, 0x67, 0xe7, 0xdb, 0xac, 0xe6, 0x8c, 0x9e, 0xc4, 0xa6, 0x85, 0x45, 0x5b, 0xe0, 0x6a, 0x75, 0xdd, 0xfa, 0x80, 0x42, 0x1f, 0x16, 0xa3, 0xfc, 0x96, 0x20, 0x32, 0x77, 0xe3, 0xcb, 0x22, 0x54, 0x3b, 0x9c, 0x7, 0xa9, 0x4c, 0x7f}},
+       testcase{
+               msg:       []byte{0x3d, 0x85, 0xe0, 0x3, 0x73, 0x43, 0xfa, 0x7, 0x6a, 0xe1, 0xa5, 0xac, 0x3b, 0x9b, 0x3a, 0x29, 0x96, 0x54, 0xa9, 0xf5, 0x2e, 0x73, 0x31, 0x21, 0x13, 0xe0, 0xeb, 0xd7, 0x8f, 0x4b, 0x59, 0x98, 0x48, 0x2, 0x3a, 0xa9, 0x75, 0x50, 0xdc, 0x77, 0xc9, 0x1d, 0xbf, 0xc9, 0x22, 0xbb, 0x96, 0x55, 0x8, 0xd5, 0xce, 0xcb, 0x13, 0x91, 0x53, 0xd6, 0xd6, 0xfa, 0xa4, 0xf8, 0xba, 0xbf, 0xa2, 0x25, 0xd, 0x29, 0xae, 0x12, 0xbb, 0x1, 0xd, 0x6d, 0x3e, 0xe7, 0x1f, 0x91, 0x7, 0x73, 0xa1, 0x52, 0x83, 0xac, 0x91, 0x6f, 0x8c, 0xa7, 0x6d, 0x35, 0x9a, 0xc6, 0xb6, 0x54, 0xbe, 0x15, 0xcf, 0xc8, 0xed, 0xf2, 0x46, 0xd, 0xe, 0x99, 0x3d, 0x1d, 0xf5, 0xed, 0x9c, 0x73, 0xe9, 0x5d, 0x35, 0x7d, 0x3c, 0xff, 0x5, 0x2b, 0x3f, 0x4c, 0xe3, 0x58, 0xf9, 0x6a, 0x63, 0x1f, 0xf, 0x7b, 0xe4, 0xc1, 0xb9, 0xd8, 0x8c, 0x7e, 0x6c, 0x4, 0x68, 0x2c, 0xe6, 0x5c, 0xdb, 0xca, 0x2c, 0x4e, 0x9c, 0xd0, 0x5d, 0x2f, 0x51, 0x2, 0x7e, 0x5e, 0x99, 0x2a, 0xdd, 0x31, 0x2, 0x6d, 0x37, 0xfd, 0x91, 0xda, 0x8c, 0x41, 0xa3, 0x3e, 0xe7, 0x26, 0xfa, 0xdd, 0x3d, 0x51, 0x69, 0x23, 0xc6, 0xcf, 0x58, 0x49, 0xe5, 0x84, 0x22, 0x91, 0x3, 0x9b, 0xc2, 0xea, 0x94, 0xd9, 0x3b, 0x2a, 0x8a, 0xc7, 0xfe, 0x72, 0x75, 0xfe, 0x86, 0x89, 0x28, 0xf3, 0xfa, 0xc2, 0xbe, 0xaa, 0x44, 0xf0, 0x63, 0x75, 0xd8, 0xb9, 0x2c, 0xde, 0x7c, 0x40, 0x3a, 0xb9, 0xf3, 0x5b, 0x4f, 0xf, 0x34, 0xeb, 0x66, 0xa5, 0xa3, 0x1d, 0xda, 0x32, 0xdf, 0x9d, 0xcd, 0x77, 0xdc, 0xb0, 0x40, 0xa6, 0xcc, 0x12, 0x7f, 0xd1, 0x9, 0xcf, 0xd5, 0x44, 0x10, 0xd7, 0xb3, 0xe4, 0xe8, 0x49, 0x8b, 0x4, 0x8, 0x94, 0x0, 0xd6, 0x1f, 0x0, 0x82, 0xca, 0x48, 0xa9, 0xd1, 0xd9, 0x56, 0x54, 0x87, 0xd7, 0x8, 0x75, 0x6a, 0x9b, 0x16, 0x94, 0x7e, 0x9c, 0x5, 0xf9, 0x40, 0x78, 0xe9, 0x1c, 0x56, 0x5a, 0x56, 0xc9, 0xf7, 0x20, 0x5a, 0xde, 0x6d, 0x8e, 0x94, 0x13, 0xd6, 0xdd, 0xf, 0xc8, 0x88, 0x5f, 0xe0, 0x1a, 0xc7, 0xfa, 0xee, 0x36, 0x5, 0xe2, 0x27, 0x25, 0xc9, 0xa5, 0x2f, 0xc1, 0xda, 0xe9, 0x2b, 0x11, 0xc, 0x38, 0xee, 0xb8, 0x77, 0x29, 0xa9, 0xbb, 0x22, 0x63, 0xb6, 0xd4, 0x3f, 0xfa, 0xa5, 0x7a, 0xbe, 0x9c, 0x84, 0x38, 0xb3, 0x1d, 0x15, 0xcd, 0xc8, 0xd8, 0xd, 0xc8, 0x13, 0x72, 0xb4, 0xd9, 0x81, 0x54, 0x93, 0x7e, 0x7e, 0xaa, 0xe, 0xec, 0xb, 0xf9, 0xc7, 0x1f, 0xb7, 0x7e, 0x2f, 0x7c, 0x36, 0xb, 0x64, 0x11, 0x2a, 0xc8, 0xd8, 0xfa, 0xb5, 0xb5, 0x74, 0xc2, 0x1f, 0xd3, 0x16, 0x0, 0xd3, 0x41, 0xa9, 0x17, 0x3a, 0x3e, 0xd0, 0x5b, 0xf, 0x41, 0x7c, 0x18, 0xc5, 0x8e, 0x52, 0x6a, 0x1, 0xe, 0xc9, 0xff, 0xca, 0x19, 0x46, 0x1a, 0xa9, 0xea, 0x5f, 0x85, 0x41, 0x6d, 0x2, 0x96, 0x89, 0xaf, 0xe7, 0xf6, 0x98, 0x36, 0xf8, 0x9d, 0x17, 0x12, 0x0, 0x4b, 0x8c, 0x79, 0x2, 0xd, 0x6c, 0xff, 0x2, 0x45, 0xc7, 0xd4, 0xb1, 0xc1, 0x96, 0x75, 0xd, 0x44, 0x52, 0x7d, 0xed, 0x40, 0x75, 0x95, 0xa7, 0xb2, 0x8e, 0xe8, 0xc9, 0x5a, 0x85, 0xc6, 0xce, 0xd8, 0x26, 0xbb, 0x7f, 0x61, 0xd8, 0xea, 0xd9, 0xe0, 0xbe, 0x20, 0xe6, 0x7d, 0x30, 0xd5, 0xad, 0x6d, 0x2d, 0x4d, 0xcb, 0x38, 0xf2, 0xe, 0x41, 0xce, 0xad, 0x52, 0x15, 0x11, 0x75, 0x49, 0x1, 0xf1, 0x8, 0x31, 0xf8, 0xba, 0x88, 0x67, 0x9a, 0xa4, 0x2e, 0x9c, 0x47, 0x30, 0x8b, 0xc5, 0xa7, 0xf3, 0xae, 0x7, 0xc1, 0x4a, 0x8a, 0xb9, 0x92, 0xcf, 0x7, 0xa2, 0x67, 0x15, 0xf5, 0x64, 0xb1, 0x15, 0x38, 0xe4, 0xc4, 0x41, 0xa9, 0xae, 0x54, 0xa5, 0xa8, 0x27, 0x1b, 0x66, 0x96, 0x6c, 0x2c, 0x90, 0x65, 0xa4, 0xea, 0xed, 0x98, 0x84, 0x36, 0xc, 0xe6, 0x4, 0x15, 0xe9, 0x53, 0xbc, 0x31, 0x7, 0x2b, 0x4b, 0x2e, 0x3f, 0x75, 0x79, 0xd6, 0xfd, 0xb7, 0xf, 0xc7, 0x37, 0xc7, 0xc, 0xf5, 0x5e, 0xa5, 0xf7, 0x27, 0x43, 0xda, 0xff, 0x86, 0x6b, 0xa4, 0x82, 0x19, 0x9f, 0x85, 0x94, 0xd6, 0xd7, 0x2e, 0x1b, 0xd0, 0x7b, 0xb8, 0x24, 0x76, 0xea, 0x95, 0xb7, 0xdf, 0x92, 0x43, 0xb0, 0x1, 0x35, 0x42, 0xec, 0x95, 0xaf, 0x48, 0x6a, 0xb1, 0x84, 0xbb, 0xd9, 0x3e, 0x6e, 0xcc, 0xea, 0xfe, 0xcd, 0x1a, 0x64, 0xec, 0xa3, 0x4, 0x68, 0x12, 0x96, 0x83, 0xf1, 0x50, 0x65, 0x7a, 0xd0, 0x50, 0x1, 0x49, 0x1, 0xd0, 0xd4, 0xef, 0x10, 0x5, 0xc5, 0xb8, 0x6f, 0x98, 0xf2, 0xd7, 0x55, 0x3f, 0xb5, 0x29, 0xd7, 0x52, 0x4c, 0x3f, 0x1b, 0x27, 0x69, 0x6f, 0xd9, 0x83, 0x59, 0x35, 0x5c, 0xdc, 0x39, 0xde, 0x67, 0xcf, 0x18, 0xd8, 0xef, 0x58, 0x65, 0x3f, 0x3c, 0x4, 0x99, 0xe0, 0x85, 0xa8, 0xf9, 0xbf, 0x55, 0x5d, 0xb9, 0xa1, 0x60, 0x4a, 0x9d, 0x64, 0xc, 0x9, 0xc4, 0x5d, 0x2b, 0x4a, 0x8d, 0x81, 0xbe, 0x36, 0x93, 0x49, 0x38, 0x9a, 0xa8, 0x33, 0x35, 0x63, 0x38, 0x58, 0x47, 0x4, 0xf8, 0x64, 0xf0, 0x42, 0x27, 0x53, 0x6b, 0x5f, 0x95, 0x81, 0x99, 0x19, 0xc8, 0x36, 0x1, 0x11, 0xfa, 0x2f, 0x1c, 0x9f, 0x4b, 0x27, 0x5a, 0x18, 0xf7, 0x24, 0x64, 0x7b, 0xdf, 0x2a, 0x78, 0x30, 0xbc, 0xb, 0x6a, 0xf3, 0x86, 0xe9, 0xb5, 0xfd, 0xff, 0x2, 0x31, 0x16, 0xfb, 0x4e, 0x22, 0xe, 0x9e, 0xac, 0xe1, 0xb6, 0xe6, 0xb4, 0xc6, 0x8c, 0x1c, 0x7d, 0xc9, 0x19, 0x2, 0x36, 0x6a, 0x6c, 0xef, 0x4c, 0x41, 0x63, 0x61, 0x6b, 0x85, 0xdb, 0x15, 0xc3, 0xd3, 0x57, 0x33, 0x72, 0x72, 0x14, 0xb1, 0x7a, 0x47, 0xa6, 0xd9, 0xc5, 0xe0, 0x59, 0xcd, 0x1, 0x74, 0xb1, 0xe5, 0xfa, 0x76, 0x4a, 0xc1, 0x1d, 0x1e, 0x85, 0x9b, 0x8f, 0x9, 0x2a, 0x4d, 0xfd, 0xe1, 0x25, 0x43, 0xe5, 0xac, 0x4c, 0x27, 0xe3, 0x96, 0x18, 0x3a, 0x63, 0xfc, 0xa, 0x76, 0xa5, 0x24, 0x69, 0x14, 0x5c, 0xe8, 0xb0, 0x1b, 0xa7, 0x33, 0xc1, 0xbf, 0x4a, 0xe0, 0xd3, 0xda, 0x35, 0xf5, 0xb1, 0x7, 0xf3, 0x8, 0x3c, 0xf0, 0x7b, 0xfb, 0xf0, 0xe0, 0xe7, 0x6b, 0x3f, 0xc7, 0xfb, 0xf5, 0xe5, 0x15, 0xc6, 0xb7, 0x94, 0x3, 0x52, 0x3d, 0xb6, 0xd6, 0x68, 0xef, 0xfc, 0xec, 0x49, 0xda, 0xd4, 0x19, 0x66, 0x9d, 0xad, 0xd3, 0x43, 0x87, 0xc, 0x82, 0xbf, 0x5b, 0x76, 0x24, 0xc0, 0x6b, 0x9f, 0x8d, 0xbe, 0x66, 0xe4, 0x9a, 0x35, 0x49, 0x5b, 0xb, 0x17, 0xc2, 0x5a, 0xc8, 0x14, 0xa0, 0xa5, 0x8e, 0x54, 0x67, 0xda, 0xd9, 0x61, 0x34, 0x9c, 0xcc, 0x2e, 0x64, 0xc2, 0x17, 0xb8, 0xc3, 0x2d, 0xd2, 0x8d, 0xb4, 0xb7, 0xa4, 0xd8, 0xfc, 0x84, 0x1b, 0xc1, 0xad, 0xbf, 0x9f, 0x1e, 0x3c, 0x1f, 0x87, 0x1a, 0xc9, 0xe3, 0xd0, 0x3b, 0xe, 0x7f, 0xe2, 0x5a, 0xa7, 0x93, 0x91, 0xde, 0x96, 0x1b, 0x87, 0x20, 0x9c, 0x6e, 0x41, 0xd7, 0x36, 0x69, 0xc3, 0xa8, 0x88, 0x38, 0x56, 0x40, 0x37, 0x36, 0x23, 0x63, 0x17, 0x24, 0x7f, 0x33, 0x2b, 0xc4, 0xfa, 0x1b, 0x14, 0xf1, 0x98, 0x78, 0xe2, 0xdf, 0x79, 0x25, 0x19, 0x2a, 0xd5, 0xc4, 0xf7, 0xbf, 0x43, 0x1a, 0x1, 0xa1, 0x57, 0x2d, 0xa9, 0x8f, 0x2b, 0x1, 0xd1, 0x84, 0x67, 0x60, 0xdb, 0xfe, 0x3e, 0x38, 0x73, 0x57, 0xd1, 0x15, 0x13, 0x5f, 0x1d, 0xf6, 0xe4, 0xb1, 0x38, 0x5d, 0xa5, 0xe5, 0x91, 0xe0, 0xee, 0x22, 0x95, 0x85, 0x87, 0x5, 0xa2, 0xf1, 0x67, 0x30, 0xb0, 0xcd, 0x74, 0x68, 0xc0, 0x86, 0x12, 0x17, 0x9e, 0x3c, 0x44, 0x9f, 0x99, 0x77, 0xc0, 0xef, 0x66, 0x88, 0x41, 0x71, 0x90, 0xd7, 0x36, 0x1b, 0xb9, 0x4c, 0x47, 0x82, 0xd6, 0x7b, 0x3, 0x8c, 0x22, 0x5e, 0xa7, 0x3, 0xb8, 0xbc, 0x73, 0x9, 0x76, 0x15, 0x61, 0xbb, 0xf1, 0xa3, 0xae, 0x49, 0x25, 0xcb, 0xe, 0x8e, 0x33, 0x33, 0x16, 0x15, 0xee, 0x3f, 0x6, 0x62, 0x64, 0x1c, 0xef, 0x39, 0x42, 0xf9, 0xa0, 0x3, 0x14, 0x3, 0x76, 0x39, 0x3c, 0x58, 0xea, 0xa4, 0x6f, 0x6e, 0x99, 0x4a, 0x37, 0x53, 0x69, 0x27, 0x73, 0x31, 0x79, 0x5d, 0x9a, 0xe7, 0x5, 0x5d, 0x4d, 0xfe, 0x87, 0xad, 0x41, 0xa8, 0x43, 0x20, 0x2e, 0x59, 0x8e, 0x49, 0x20, 0x11, 0x83, 0x35, 0x25, 0xd2, 0xd5, 0x68, 0xb6, 0x99, 0x84, 0x1e, 0x6a, 0x82, 0xcc, 0xe5, 0x9b, 0x51, 0xd4, 0x0, 0xed, 0x6f, 0x89, 0x6c, 0x27, 0x11, 0x94, 0xf2, 0xc8, 0x23, 0xe, 0x27, 0x1b, 0xd2, 0x1a, 0xd4, 0x34, 0x5c, 0xb8, 0xcd, 0x89, 0xba, 0xde, 0xa7, 0xfb, 0x61, 0x88, 0xb0, 0x16, 0x74, 0x90, 0xe1, 0x49, 0x32, 0x64, 0xb6, 0x8b, 0xd9, 0x95, 0xd5, 0x6c, 0x93, 0xe6, 0x95, 0x1c, 0xa8, 0xc5, 0x54, 0xb1, 0xe0, 0xaf, 0x35, 0x85, 0x3, 0x77, 0xbb, 0x87, 0xc1, 0x3b, 0xaf, 0xdc, 0x81, 0xe3, 0xc4, 0x33, 0xff, 0x3b, 0x5f, 0x13, 0xfc, 0xb5, 0x33, 0x8b, 0x31, 0xee, 0x61, 0x9c, 0x59, 0xeb, 0x16, 0xe, 0x4e, 0x6e, 0x51, 0x85, 0xed, 0x41, 0xec, 0xb1, 0x87, 0x91, 0xe6, 0xae, 0xc2, 0xdb, 0xb8, 0x98, 0xc4, 0xf9, 0x51, 0xf7, 0x17, 0x9b, 0x3a, 0x52, 0x3a, 0x3e, 0xe8, 0xd7, 0x5b, 0xd3, 0x75, 0xf0, 0x3a, 0x18, 0x33, 0xe5, 0x4, 0x67, 0x27, 0xa5, 0x1, 0x17, 0x8e, 0x8e, 0xaa, 0xb4, 0xe2, 0x5a, 0x5, 0x79, 0x98, 0x37, 0xf1, 0xc9, 0x1f, 0xfd, 0x4e, 0xf3, 0x64, 0xed, 0x73, 0x1f, 0x39, 0xac, 0x65, 0x63, 0x71, 0xcc, 0xe0, 0x1d, 0xa7, 0x3a, 0x85, 0x59, 0x5a, 0xb9, 0xae, 0x3c, 0xe4, 0x1e, 0x79, 0x9f, 0xf9, 0x4c, 0x67, 0x6a, 0x45, 0x9, 0xd7, 0x74, 0xb7, 0x20, 0xf3, 0x8c, 0x1d, 0x92, 0x4d, 0x17, 0xb0, 0x9e, 0xaa, 0x4, 0x83, 0x55, 0x13, 0xc9, 0x65, 0x30, 0x65, 0x4d, 0xca, 0xf0, 0x5, 0x21, 0xb8, 0xa7, 0x4e, 0x40, 0x77, 0x4f, 0x14, 0x6b, 0x0, 0xaf, 0x65, 0xbc, 0xcb, 0xf4, 0x77, 0xb5, 0x8d, 0xe5, 0x28, 0xaa, 0x2b, 0xb7, 0x93, 0xf4, 0x7d, 0x55, 0xf4, 0xf2, 0x89, 0x3a, 0x11, 0x4e, 0xed, 0x9, 0xf2, 0x1c, 0xd7, 0x91, 0x68, 0xc5, 0x21, 0x34, 0xfe, 0xfe, 0xc9, 0xa7, 0x96, 0x59, 0xd4, 0xae, 0x45, 0xf2, 0x8a, 0x56, 0xa6, 0xe6, 0x53, 0x76, 0x18, 0x80, 0x24, 0x65, 0x2c, 0xc, 0xbc, 0xde, 0xb6, 0xdc, 0x8a, 0xed, 0x36, 0x60, 0x4e, 0x3, 0xdd, 0x61, 0xd4, 0xac, 0xe9, 0xa8, 0xb7, 0xc5, 0x4e, 0xbd, 0x35, 0xa1, 0x9c, 0xec, 0x99, 0xc7, 0x88, 0xfa, 0x2, 0xe4, 0x5e, 0x5a, 0xa2, 0x91, 0x60, 0xc6, 0x61, 0x5, 0x1b, 0x26, 0x20, 0x80, 0x84, 0x1d, 0xa9, 0xf3, 0xbe, 0x61, 0xad, 0x42, 0x1b, 0x4c, 0xeb, 0xe7, 0xee, 0xc7, 0x7d, 0xa, 0x2c, 0x2f, 0x14, 0x65, 0x81, 0x9, 0xcd, 0xe4, 0x74, 0x1a, 0x8f, 0x9, 0x67, 0xd3, 0xe6, 0x9d, 0x95, 0xe6, 0x90, 0x90, 0x98, 0xa6, 0x10, 0x85, 0xae, 0x12, 0x37, 0xba, 0x8b, 0xfc, 0xdb, 0xfc, 0x33, 0x9d, 0xeb, 0x4a, 0x11, 0xad, 0x80, 0xc1, 0x18, 0x2, 0x3d, 0x82, 0xd9, 0x4, 0xa0, 0x28, 0x2e, 0xe5, 0x8d, 0xa, 0xcc, 0x18, 0xf, 0x9e, 0x9a, 0x62, 0x9c, 0x8, 0x3c, 0xc7, 0xb, 0x6b, 0xcb, 0xaa, 0x47, 0xad, 0xad, 0x76, 0xbf, 0xa0, 0xbf, 0x3, 0x93, 0xe9, 0xfc, 0x86, 0xc6, 0xd4, 0x37, 0x4b, 0x1f, 0xff, 0x93, 0xe9, 0xad, 0x8f, 0x76, 0x43, 0xbc, 0xc7, 0x69, 0xd2, 0xe1, 0xb9, 0x1a, 0x57, 0x1f, 0xd0, 0x4f, 0x46, 0x2, 0xad, 0x8, 0xa7, 0xca, 0xa9, 0x23, 0x19, 0x13, 0x72, 0x91, 0x88, 0x3f, 0xf0, 0xce, 0xe2, 0x2, 0x3b, 0xd4, 0x12, 0x5, 0x77, 0x61, 0x1d, 0x68, 0x7e, 0x71, 0xfd, 0x39, 0xbe, 0xe2, 0x5d, 0x23, 0xd0, 0x6, 0x19, 0x8, 0x31, 0x71, 0xde, 0x81, 0xa0, 0x47, 0x5b, 0xf7, 0x69, 0xc9, 0x72, 0xa0, 0x69, 0x60, 0x31, 0x71, 0x97, 0x19, 0x18, 0x7f, 0xb5, 0xc1, 0x72, 0xea, 0x5, 0xc7, 0xcf, 0x57, 0x40, 0x29, 0x66, 0x83, 0x88, 0x9f, 0xc, 0xe5, 0xb2, 0x86, 0x65, 0xc0, 0xef, 0xcf, 0xbc, 0x95, 0xa4, 0xbf, 0x7b, 0x9c, 0x6c, 0xee, 0x9e, 0x3a, 0xbe, 0xf3, 0x17, 0xaa, 0xd2, 0xc8, 0x29, 0xe5, 0x95, 0x33, 0xdc, 0xe7, 0x1, 0x86, 0x65, 0x7c, 0x6d, 0xb4, 0x4d, 0xa4, 0x28, 0x20, 0xbd, 0x1f, 0x91, 0x91, 0xab, 0xcd, 0x34, 0x95, 0xaa, 0x6d, 0x16, 0x61, 0xfe, 0x7, 0x35, 0xf4, 0xae, 0x7d, 0x56, 0x7e, 0xf0, 0xcc, 0xab, 0x73, 0x10, 0x36, 0xb2, 0x43, 0x90, 0xc5, 0x60, 0x96, 0xd3, 0xb5, 0x6a, 0x1f, 0xfd, 0xc9, 0xcf, 0x36, 0xf1, 0x75, 0xb5, 0x87, 0x61, 0x2d, 0xd7, 0xec, 0xb4, 0x13, 0x86, 0xf8, 0x2b, 0xa6, 0xf8, 0x1a, 0xf6, 0xe6, 0x84, 0xbf, 0xd6, 0x5, 0x5e, 0xe2, 0x37, 0xe5, 0xa2, 0x2a, 0x25, 0xdb, 0xa, 0xc2, 0x98, 0x5b, 0x8f, 0x4e, 0x7c, 0x55, 0x3b, 0x10, 0x28, 0x3c, 0x76, 0xab, 0xff, 0x2c, 0xfd, 0x41, 0x5d, 0x6d, 0x39, 0x72, 0x3b, 0xfd, 0xf8, 0x8f, 0x2a, 0x8c, 0x58, 0x7c, 0x5c, 0x92, 0x1d, 0x4f, 0xd4, 0xa8, 0xe7, 0x29, 0x8d, 0xe0, 0xe7, 0xb2, 0xe8, 0x97, 0xfa, 0xa2, 0x51, 0x3d, 0x5a, 0xe1, 0xc3, 0x15, 0xa5, 0x93, 0x42, 0x1d, 0xb0, 0x7d, 0xae, 0x69, 0x63, 0x44, 0xef, 0x88, 0x24, 0x14, 0xe3, 0x23, 0xbd, 0x3, 0xbf, 0x8b, 0x97, 0xee, 0xdd, 0x73, 0x2e, 0x44, 0xc7, 0x37, 0xca, 0x23, 0x2e, 0x4e, 0x6a, 0x1d, 0x26, 0xf, 0x36, 0x7d, 0xbb, 0xac, 0x25, 0x0, 0xc4, 0x61, 0x9e, 0xd7, 0xd7, 0x17, 0xd, 0x24, 0x82, 0xa1, 0xa9, 0x8f, 0x99, 0xf9, 0xd4, 0xd6, 0xf1, 0x83, 0x2d, 0x7, 0xe8, 0x3f, 0x58, 0xe6, 0x82, 0xd8, 0x9e, 0xea, 0x2, 0x3f, 0xb4, 0xa3, 0xa9, 0x43, 0x8c, 0x90, 0x6a, 0xa3, 0x64, 0x11, 0xe3, 0x73, 0x56, 0xd9, 0x56, 0x89, 0xe4, 0xed, 0x4d, 0x49, 0x54, 0x8d, 0xa8, 0xe8, 0xfb, 0x59, 0xc9, 0xc8, 0x80, 0xe7, 0x76, 0xe2, 0xed, 0x87, 0x7, 0xdc, 0xf4, 0xb5, 0x7a, 0xe1, 0x65, 0x7a, 0x5c, 0xdf, 0x77, 0xa4, 0xa7, 0x57, 0x88, 0x6a, 0xa5, 0x9b, 0x49, 0x61, 0x82, 0xa6, 0x8b, 0x62, 0xcb, 0x41, 0x36, 0x9, 0x56, 0xb5, 0x11, 0x52, 0x6e, 0x89, 0x55, 0xa8, 0x16, 0x58, 0x98, 0x70, 0x62, 0x58, 0xb3, 0xf6, 0xf9, 0xd5, 0x4, 0xef, 0xf7, 0xc2, 0xf5, 0x73, 0xe7, 0xdb, 0x10, 0x64, 0xf9, 0xa1, 0x63, 0x91, 0xb1, 0x1d, 0x1d, 0x53, 0x7c, 0xf7, 0x9, 0x57, 0x2e, 0xae, 0xa0, 0x23, 0x95, 0x2f, 0xab, 0x7c, 0x70, 0xbb, 0x4b, 0xe3, 0x87, 0x2e, 0x79, 0x49, 0x30, 0xcb, 0xe2, 0xcc, 0xea, 0x92, 0xcd, 0xbb, 0xc8, 0x58, 0x68, 0x30, 0xaf, 0xf8, 0x12, 0x64, 0xcc, 0xa, 0x4f, 0x3a, 0x3f, 0xf1, 0x1a, 0x4d, 0x1a, 0x7d, 0x52, 0x1a, 0x8e, 0xe7, 0x37, 0xc4, 0xff, 0xa4, 0x70, 0x63, 0xd8, 0xe8, 0x8d, 0x69, 0xd3, 0x81, 0xa0, 0x85, 0xd7, 0x1e, 0xfe, 0xa5, 0x1a, 0x3d, 0xc1, 0x73, 0xf6, 0xf7, 0x6f, 0x2f, 0x4e, 0x12, 0x9, 0xa5, 0x36, 0x95, 0x1f, 0xe9, 0x46, 0xe5, 0x48, 0x91, 0x4b, 0xcd, 0x7b, 0xc4, 0xdd, 0x50, 0x6b, 0x41, 0xb1, 0xdc, 0x5b, 0xaa, 0xb3, 0x48, 0x74, 0x36, 0x2c, 0xe0, 0xff, 0x3, 0xbd, 0xa1, 0x9c, 0xb5, 0x93, 0x8b, 0x81, 0x3c, 0x57, 0xe4, 0x4e, 0xd, 0x61, 0xdb, 0x66, 0x44, 0x50, 0x1c, 0xba, 0x3d, 0x59, 0xb6, 0xcf, 0xeb, 0xe2, 0xe, 0x35, 0xe4, 0xf6, 0x70, 0xe1, 0xe8, 0x78, 0xe3, 0xda, 0xf7, 0x2, 0x45, 0xd9, 0xc4, 0x2a, 0x19, 0xd, 0x57, 0x5b, 0x98, 0xf9, 0xba, 0xf8, 0x8e, 0xf5, 0x9e, 0x55, 0x64, 0x63, 0xd, 0x1c, 0xb, 0xe4, 0xe5, 0x66, 0x70, 0x8c, 0x4c, 0xa9, 0x13, 0x18, 0x13, 0x33, 0x2d, 0xfd, 0x7f, 0x26, 0x7e, 0x37, 0xca, 0xf7, 0x68, 0x1e, 0xc9, 0xbf, 0x5a, 0xc8, 0x45, 0x86, 0xfa, 0x9a, 0x97, 0xc6, 0xc8, 0x88, 0x2f, 0xc2, 0x43, 0x58, 0xbf, 0x88, 0x51, 0x68, 0x88, 0x60, 0xe8, 0x38, 0x70, 0x3d, 0x3e, 0xbe, 0x14, 0x98, 0xee, 0xc2, 0x7d, 0x8c, 0xee, 0xac, 0xc0, 0xaf, 0xb1, 0x58, 0xf5, 0xcc, 0xf1, 0x84, 0x65, 0x25, 0x47, 0x7d, 0x3b, 0xf0, 0x69, 0xf6, 0x3f, 0xe2, 0x6e, 0xde, 0x5f, 0xf5, 0x56, 0x38, 0x7b, 0x7d, 0x92, 0xf9, 0x54, 0x8, 0x57, 0xd7, 0x99, 0xd7, 0x7d, 0x1d, 0x33, 0x19, 0xc8, 0x66, 0x95, 0xb0, 0x62, 0x2f, 0x82, 0xc5, 0x7a, 0x5, 0x95, 0x2f, 0x6d, 0xcf, 0x11, 0x4b, 0x1d, 0x36, 0xf5, 0x62, 0x99, 0x62, 0xdf, 0x10, 0x72, 0x7b, 0x2b, 0x3f, 0x9a, 0x9e, 0x58, 0x3d, 0xab, 0xc8, 0xb5, 0x61, 0xdf, 0xf5, 0x3b, 0x3e, 0x17, 0xd7, 0x2c, 0xbc, 0xab, 0x8c, 0xa9, 0x74, 0x1, 0x8d, 0x65, 0xc4, 0xe3, 0x5, 0x4b, 0xa5, 0x12, 0x11, 0xc3, 0x1f, 0x81, 0x34, 0x4c, 0xff, 0x43, 0x54, 0xf8, 0x12, 0x2b, 0x6b, 0x2b, 0x28, 0x19, 0x2e, 0x80, 0x99, 0x95, 0x37, 0xd7, 0x83, 0xdd, 0x5b, 0x34, 0xa4, 0x77, 0x52, 0x57, 0x5b, 0x3b, 0xae, 0xfb, 0x4, 0x24, 0x77, 0x3, 0x27, 0x1f, 0x9e, 0xbd, 0x89, 0x64, 0x9d, 0xd, 0xf3, 0xb, 0xf0, 0x30, 0xc9, 0xdf, 0xe3, 0x9e, 0x61, 0x64, 0x70, 0xf3, 0xdd, 0x75, 0xe0, 0xf0, 0x59, 0x5e, 0x57, 0x2e, 0x70, 0xa9, 0x3d, 0x1c, 0xc2, 0xed, 0x8c, 0xac, 0xb4, 0xdc, 0x24, 0x31, 0x54, 0x6b, 0x12, 0x39, 0x72, 0x64, 0x9b, 0x82, 0xd5, 0x87, 0x6e, 0x9, 0xd6, 0xc4, 0xd9, 0xe1, 0xd2, 0xc, 0xf4, 0x6c, 0x75, 0xc4, 0xe2, 0xef, 0x76, 0xc1, 0x62, 0xe5, 0x26, 0x7b, 0xb, 0x9c, 0x11, 0xb6, 0xdf, 0x4f, 0x32, 0x92, 0x50, 0x42, 0xe1, 0x91, 0xb6, 0xed, 0x5d, 0xa0, 0x24, 0x5b, 0x68, 0xde, 0xb, 0x9, 0x8, 0x7e, 0x64, 0xe1, 0x77, 0xe4, 0x1a, 0x5a, 0x6b, 0xde, 0xdd, 0xb4, 0x84, 0x2d, 0xd0, 0x86, 0x64, 0xe0, 0x3f, 0xa5, 0x94, 0x57, 0x29, 0x82, 0xd4, 0x15, 0xa6, 0x4b, 0x70, 0x74, 0x9e, 0xd5, 0x36, 0xea, 0x12, 0x85, 0x11, 0x77, 0x7, 0x9d, 0xa7, 0x93, 0x5b, 0x85, 0xa8, 0x1f, 0x0, 0xaf, 0x1, 0x18, 0xfa, 0xa6, 0x2b, 0x87, 0x9b, 0xf5, 0xc0, 0x41, 0x6, 0x72, 0xc5, 0x94, 0x8e, 0x54, 0x52, 0x18, 0xca, 0xf9, 0xce, 0xa6, 0x4b, 0x60, 0xc9, 0xc0, 0x54, 0xa1, 0x28, 0xe7, 0x86, 0x75, 0x72, 0xe0, 0x22, 0x89, 0x65, 0x34, 0xd1, 0x4b, 0x97, 0xab, 0x66, 0x8b, 0xdc, 0x9b, 0x50, 0xce, 0x34, 0xc2, 0x69, 0x7, 0x88, 0xf4, 0x7c, 0xc3, 0x11, 0xb8, 0x66, 0xd4, 0xde, 0x1f, 0xac, 0xeb, 0xc1, 0xbc, 0xc3, 0x6, 0xef, 0xdd, 0x69, 0x56, 0xe5, 0x8d, 0x39, 0x13, 0x4, 0x76, 0x97, 0x42, 0xa6, 0x5c, 0xba, 0x3f, 0x81, 0xd6, 0xc4, 0x5a, 0x79, 0xcf, 0xc2, 0xe9, 0x4b, 0xa4, 0x4f, 0x9c, 0x73, 0x98, 0x6b, 0xdc, 0xd6, 0x8e, 0x91, 0x62, 0xd9, 0xfd, 0x52, 0xaf, 0xba, 0xf0, 0x15, 0x4e, 0x20, 0xe4, 0x26, 0x83, 0x6a, 0x68, 0xe6, 0xfc, 0x5d, 0x22, 0x73, 0xcd, 0x11, 0xf0, 0x9d, 0xa0, 0xb3, 0x1, 0x9b, 0x7a, 0x52, 0x88, 0xbb, 0xf2, 0x1e, 0xb3, 0xed, 0x2, 0xa6, 0x6d, 0x78, 0x74, 0x2, 0x49, 0x4d, 0x51, 0xf1, 0xfc, 0xc3, 0x72, 0x81, 0x3b, 0xdd, 0xb5, 0x1, 0x7b, 0xb, 0xd4, 0x68, 0xa8, 0x8a, 0x50, 0xd6, 0x5a, 0xe0, 0x80, 0x76, 0xd7, 0xc7, 0x54, 0xe6, 0x48, 0x98, 0x7, 0x4f, 0x30, 0x48, 0xc8, 0xe3, 0xce, 0x1b, 0x9, 0x54, 0xde, 0x60, 0xdd, 0x97, 0xe9, 0x4f, 0xad, 0xdf, 0x31, 0xb3, 0x83, 0xf7, 0xb1, 0x36, 0x5c, 0xb8, 0x3a, 0xb0, 0xb4, 0xd3, 0xa, 0x7f, 0x89, 0x53, 0xa7, 0x34, 0x35, 0xf9, 0x16, 0xd, 0x45, 0xc3, 0x70, 0xf3, 0x9f, 0x3d, 0xb1, 0x3e, 0xe4, 0x6a, 0x37, 0xb5, 0xac, 0xe3, 0x5, 0x7b, 0x83, 0x99, 0x3f, 0x3, 0x5e, 0x8c, 0x1f, 0x8c, 0xee, 0x6e, 0xf7, 0xc3, 0x59, 0x12, 0x77, 0xce, 0xf6, 0x93, 0x1, 0xd5, 0x4e, 0xca, 0x46, 0x70, 0x25, 0x58, 0x37, 0x50, 0x4b, 0x70, 0x9b, 0xa3, 0xb2, 0xdd, 0x9, 0x1d, 0x95, 0xef, 0x6e, 0x6c, 0x55, 0x91, 0xde, 0x43, 0x9f, 0x5a, 0x88, 0x2e, 0x86, 0xe1, 0x9d, 0x1a, 0x2d, 0x6d, 0xf5, 0x6f, 0xd, 0xd2, 0x6e, 0x8e, 0x95, 0x4d, 0xe5, 0xf3, 0xd1, 0x43, 0x89, 0x87, 0xad, 0x2f, 0xf1, 0xa2, 0x2f, 0x43, 0x20, 0xe9, 0x6f, 0xeb, 0x55, 0xdf, 0xac, 0xb8, 0x3a, 0x53, 0xd1, 0xc8, 0x4b, 0x6b, 0x25, 0xfa, 0xde, 0xea, 0x49, 0x70, 0xc8, 0x5e, 0x82, 0x86, 0x6a, 0xae, 0x5e, 0x7a, 0x7c, 0xbe, 0x85, 0xdd, 0xa0, 0xab, 0x5e, 0x7b, 0xb0, 0xa0, 0x74, 0x30, 0x2c, 0x49, 0x60, 0x91, 0x18, 0xc8, 0xe3, 0x4a, 0xaf, 0xa5, 0xec, 0x7b, 0xd1, 0xbe, 0xf5, 0xd8, 0x1b, 0x25, 0xb5, 0xf8, 0xf4, 0xcc, 0x8f, 0x26, 0x40, 0x86, 0xd3, 0xb0, 0x46, 0xa5, 0xee, 0xb8, 0x9a, 0x30, 0x7d, 0x4, 0x4c, 0x7, 0x6c, 0x3e, 0x46, 0x98, 0xe6, 0x7, 0x89, 0xda, 0xdc, 0xf2, 0x65, 0x17, 0x2b, 0x75, 0xfb, 0x5e, 0x80, 0xb5, 0x9c, 0xff, 0x93, 0x9c, 0x6, 0xf9, 0x37, 0x85, 0x64, 0x8, 0xf7, 0x9},
+               output224: []byte{0xb6, 0xcd, 0xea, 0x9d, 0xec, 0x93, 0x7e, 0x45, 0x7f, 0xb9, 0x45, 0x43, 0x3e, 0x14, 0x6, 0x10, 0xa5, 0xd5, 0xd9, 0x3d, 0xc2, 0x5f, 0x30, 0x7, 0x99, 0x24, 0x77, 0xca},
+               output256: []byte{0xea, 0x2d, 0xbc, 0xe6, 0x65, 0x27, 0x8a, 0xa9, 0xbf, 0x9a, 0xfe, 0xe3, 0x4a, 0x0, 0x60, 0x21, 0x5f, 0x1d, 0x25, 0x71, 0x43, 0xd7, 0x3f, 0xf, 0xbe, 0x54, 0x1b, 0x29, 0x42, 0xf1, 0xbc, 0xbc},
+               output384: []byte{0xb3, 0xfb, 0xb5, 0x6b, 0x7f, 0x1c, 0xe4, 0x4e, 0x8, 0x39, 0x4f, 0x8e, 0x21, 0xe2, 0x8b, 0x97, 0xb5, 0xec, 0x2d, 0x60, 0x37, 0xfc, 0xa4, 0x55, 0x67, 0x4b, 0x40, 0x64, 0x91, 0x57, 0x68, 0x4d, 0x5a, 0x19, 0x14, 0x3d, 0x8d, 0x9a, 0x9f, 0xc9, 0x51, 0xba, 0x98, 0xe5, 0x40, 0x7d, 0x2, 0x9a},
+               output512: []byte{0xf2, 0xcd, 0x7, 0x45, 0xf5, 0x9f, 0x2e, 0x40, 0xd2, 0x9e, 0xc5, 0xc9, 0xc3, 0xf6, 0x69, 0x1a, 0x1b, 0xf6, 0x2d, 0x19, 0x46, 0x53, 0x93, 0x4f, 0x3d, 0xbc, 0x87, 0xb4, 0xa2, 0x7d, 0xe3, 0xe2, 0x15, 0x3a, 0xec, 0x97, 0xc, 0x51, 0xf5, 0x20, 0x1f, 0xb7, 0x55, 0x8, 0x44, 0xa7, 0xe4, 0xb6, 0x96, 0x45, 0x70, 0xb2, 0xa4, 0xbd, 0x87, 0x39, 0x4, 0xf9, 0xfd, 0x9c, 0x70, 0x49, 0x0, 0xda}},
+       testcase{
+               msg:       []byte{0x16, 0xf8, 0x5f, 0x57, 0x82, 0x6, 0xf4, 0xd6, 0x25, 0xa5, 0x83, 0x1c, 0xb3, 0xb0, 0x29, 0xf0, 0x9d, 0x6f, 0x9e, 0x13, 0xf8, 0xe4, 0x27, 0x1f, 0xd4, 0x1a, 0x42, 0x9c, 0xeb, 0x63, 0x8a, 0x13, 0x0, 0xe5, 0x1b, 0x40, 0x3e, 0xd6, 0x12, 0x44, 0x20, 0xb3, 0x63, 0x19, 0x1f, 0x55, 0xb3, 0x2e, 0x14, 0xd2, 0x86, 0x58, 0x4b, 0x51, 0xd3, 0x57, 0x25, 0x36, 0xa0, 0xb7, 0x2, 0x2b, 0x63, 0xf8, 0x44, 0xf8, 0x5c, 0x45, 0x77, 0x19, 0xf8, 0x8d, 0x4b, 0x91, 0xb1, 0x3, 0x4d, 0x2b, 0x58, 0xe7, 0x7c, 0x3f, 0xaa, 0x34, 0xa3, 0x3d, 0xb8, 0x8, 0x92, 0x84, 0xad, 0x13, 0xc9, 0x93, 0xc2, 0x34, 0xca, 0x88, 0x3e, 0x2, 0x63, 0xd4, 0xfb, 0xe2, 0x9, 0xaf, 0xa3, 0x1a, 0x44, 0x50, 0x21, 0xa2, 0xfb, 0x4f, 0x45, 0x76, 0x33, 0xa5, 0x4d, 0x15, 0x8d, 0x94, 0xf2, 0x34, 0x2b, 0xed, 0xb2, 0xcb, 0x65, 0xdd, 0x67, 0x8, 0x8f, 0x8e, 0x1, 0x7b, 0x58, 0xbb, 0x78, 0x7e, 0xd0, 0x40, 0xa, 0xe3, 0x4, 0x66, 0x8, 0x5e, 0xb7, 0x2f, 0x19, 0x1, 0x18, 0xbc, 0xd6, 0xb0, 0xa, 0x7e, 0x1b, 0xe1, 0x2d, 0x3e, 0x86, 0x55, 0x39, 0x48, 0x85, 0x9f, 0xdb, 0x93, 0x5, 0x22, 0xac, 0x99, 0x39, 0x96, 0x85, 0xfa, 0x8d, 0x29, 0x27, 0xd4, 0xc9, 0x76, 0x37, 0xea, 0x57, 0x73, 0xc, 0x12, 0x16, 0xe0, 0xc, 0x2b, 0xd8, 0xe8, 0xba, 0x68, 0x4e, 0x1e, 0x82, 0x2, 0x28, 0x9f, 0x87, 0x8, 0xd5, 0xe4, 0x3f, 0x68, 0xef, 0xbd, 0x1d, 0xce, 0x5d, 0xb6, 0x40, 0x88, 0x89, 0xe5, 0xe6, 0xd3, 0x2b, 0xc6, 0xb2, 0xc, 0x1e, 0x40, 0x30, 0x14, 0x71, 0xee, 0x65, 0x8a, 0x2b, 0x89, 0x87, 0x35, 0x89, 0xa9, 0x5f, 0x1b, 0x19, 0x23, 0x97, 0x23, 0x77, 0xe6, 0x59, 0x9d, 0xc7, 0xa0, 0x27, 0x6d, 0x52, 0xb5, 0x4b, 0x18, 0x24, 0x5a, 0x38, 0xcf, 0x56, 0xb9, 0xe4, 0x60, 0x3b, 0xb9, 0xbf, 0xb7, 0xf9, 0xa6, 0x8c, 0xb6, 0x31, 0x84, 0x22, 0x13, 0x45, 0x89, 0x5d, 0xfa, 0xef, 0xb6, 0xdb, 0x77, 0xc8, 0xfc, 0x11, 0xa2, 0xb0, 0x63, 0x7e, 0xe6, 0x47, 0x8d, 0xb7, 0x4f, 0x2d, 0xc7, 0x71, 0xae, 0x29, 0x3c, 0x9d, 0x1b, 0x49, 0x6a, 0x41, 0xa, 0xd0, 0x12, 0x13, 0x3f, 0x65, 0xea, 0xf4, 0xd3, 0x73, 0x7e, 0x1, 0xb4, 0x14, 0x2b, 0x50, 0xc7, 0x39, 0xb0, 0x76, 0x6e, 0x84, 0x6e, 0x3a, 0x37, 0x29, 0x36, 0xe8, 0xf0, 0x5d, 0x0, 0xcc, 0x91, 0xfc, 0x4b, 0x1, 0xdf, 0x2e, 0x39, 0x15, 0x1d, 0xec, 0x6c, 0x11, 0xc3, 0xe0, 0x59, 0xae, 0xeb, 0x88, 0x4a, 0xd4, 0xb1, 0x46, 0xf0, 0xcc, 0xc6, 0x6c, 0xe4, 0x8d, 0x89, 0x59, 0xd7, 0xab, 0x99, 0x20, 0xf8, 0x95, 0xfa, 0x91, 0x1d, 0x6f, 0x12, 0x7c, 0x97, 0xf1, 0xe8, 0x58, 0x3d, 0x5a, 0xc8, 0xb0, 0xbb, 0xb9, 0x59, 0xca, 0x80, 0xe6, 0xf0, 0x25, 0xb4, 0xdf, 0x44, 0x7, 0x47, 0x64, 0x8d, 0xab, 0x69, 0x66, 0x2e, 0xdb, 0x9f, 0x4e, 0xe4, 0x4a, 0x6e, 0xb7, 0xb3, 0xa0, 0x86, 0x87, 0xb, 0x16, 0x74, 0x18, 0xc4, 0xca, 0xdf, 0xdf, 0x64, 0x8, 0xe8, 0x6f, 0xc0, 0x74, 0x59, 0xd3, 0x78, 0x70, 0xf9, 0x5d, 0x1a, 0xa1, 0x1d, 0x3c, 0xaa, 0xdb, 0x3f, 0xd6, 0x50, 0x38, 0xcf, 0xad, 0xc7, 0x58, 0xc6, 0x9e, 0x8e, 0x77, 0xb9, 0xf0, 0xd0, 0x88, 0x44, 0xf9, 0x42, 0xa7, 0x3b, 0x2a, 0x16, 0xb9, 0x9f, 0xe5, 0x8f, 0x35, 0x44, 0x4c, 0x3e, 0x5c, 0xbf, 0xf0, 0x3c, 0xc7, 0xcb, 0x4b, 0x95, 0xda, 0x6c, 0xa7, 0xd9, 0xa7, 0xf, 0xfd, 0x84, 0x62, 0x27, 0xcd, 0xa9, 0xbb, 0x71, 0xa7, 0x21, 0x2c, 0xb7, 0xf6, 0x6b, 0xd6, 0x35, 0xb2, 0xb2, 0x51, 0x16, 0xf1, 0xa6, 0x8c, 0xcc, 0x23, 0x9f, 0xb5, 0xc5, 0x10, 0xe8, 0x76, 0xbc, 0x60, 0x2d, 0xbc, 0x51, 0x8f, 0x6, 0x8f, 0x55, 0x2, 0x47, 0x15, 0xc2, 0x23, 0x6b, 0xea, 0x45, 0xf4, 0x29, 0x64, 0xac, 0xc0, 0x22, 0xec, 0xc3, 0x65, 0x3c, 0x12, 0x39, 0x9f, 0xd6, 0x50, 0x95, 0xe0, 0xe3, 0x6, 0x14, 0xd0, 0x2d, 0x82, 0x74, 0xc6, 0x3b, 0xc4, 0xb8, 0x8f, 0x3d, 0x11, 0xdf, 0xea, 0xd0, 0xe4, 0x6, 0xb1, 0xcf, 0xbe, 0xc3, 0x40, 0x65, 0x5, 0x9d, 0xdc, 0xe7, 0x63, 0x27, 0x97, 0x3e, 0xf8, 0x2d, 0x5b, 0xa, 0x6d, 0xb9, 0xb3, 0x1, 0x46, 0x7, 0x20, 0x7e, 0x54, 0x5b, 0xb9, 0x65, 0x5, 0x18, 0xe4, 0xbe, 0x41, 0xbf, 0x94, 0x54, 0xac, 0x5f, 0xbf, 0xc9, 0x84, 0x58, 0x6f, 0x6f, 0xc5, 0x71, 0x42, 0x93, 0xad, 0xc8, 0x43, 0x8c, 0x89, 0x75, 0x22, 0xfe, 0x2c, 0xc6, 0xb1, 0xb8, 0x0, 0xbf, 0x64, 0x38, 0x1d, 0x91, 0xab, 0xfb, 0x2e, 0xf2, 0xb7, 0x70, 0x3e, 0x33, 0x7a, 0xd6, 0x31, 0xd2, 0x44, 0x98, 0xfa, 0x36, 0xfc, 0x94, 0x8f, 0x7b, 0x7b, 0xd6, 0x68, 0x18, 0x7c, 0xe9, 0xd9, 0x4c, 0x39, 0x6f, 0xc3, 0x22, 0xe5, 0x3f, 0x34, 0x19, 0x71, 0xf8, 0xb7, 0x9d, 0x50, 0x42, 0x89, 0xda, 0x46, 0x19, 0x9d, 0x7d, 0xf8, 0x41, 0xb9, 0x85, 0xd0, 0xeb, 0xe2, 0xf8, 0x2d, 0x9b, 0x74, 0x2a, 0x92, 0xcd, 0x18, 0x79, 0xce, 0xf6, 0xa9, 0xfe, 0x96, 0x8f, 0x3d, 0xd0, 0x87, 0x5f, 0x4c, 0x17, 0x2a, 0xfc, 0x3a, 0x28, 0x9a, 0x86, 0xda, 0xf, 0x4d, 0x3, 0xe8, 0xe5, 0xe2, 0x7d, 0xf2, 0xe, 0xb1, 0xc8, 0x19, 0xb2, 0x56, 0x6a, 0x63, 0x62, 0xa3, 0xa2, 0x2, 0xed, 0x31, 0x88, 0x51, 0xf2, 0x18, 0xd3, 0x93, 0x64, 0xc4, 0xc4, 0x7e, 0x5b, 0x47, 0xe1, 0x68, 0x94, 0xb6, 0x45, 0xfc, 0xc7, 0xa8, 0x4f, 0xf4, 0xae, 0x8a, 0x7, 0x5a, 0x65, 0x23, 0x75, 0x59, 0xe6, 0x9f, 0x6f, 0x63, 0x47, 0x36, 0x12, 0x9a, 0x67, 0x83, 0xb7, 0xc1, 0x3b, 0xfb, 0xbb, 0xc9, 0xe3, 0xfb, 0xf5, 0xf8, 0xfe, 0x52, 0xdc, 0xac, 0xf5, 0x63, 0xef, 0x41, 0xc1, 0xe8, 0x76, 0x75, 0x12, 0x6, 0xe5, 0xfb, 0x7c, 0xf8, 0x69, 0xf3, 0xf6, 0xbf, 0x38, 0x2c, 0x1e, 0x73, 0x33, 0x4f, 0x1c, 0x5, 0xe5, 0xf6, 0xfe, 0x81, 0x34, 0x4b, 0x7d, 0x5c, 0xdf, 0x58, 0x6, 0x17, 0x75, 0xcb, 0x34, 0x57, 0xd7, 0x47, 0x6c, 0x30, 0x85, 0xf9, 0xfe, 0x62, 0xc, 0xca, 0x92, 0x67, 0x9b, 0x1a, 0x54, 0x90, 0xd1, 0x62, 0xf, 0x61, 0x3b, 0x7e, 0x8c, 0xe1, 0x37, 0xc2, 0xf3, 0x9b, 0xa5, 0xcc, 0xbc, 0xb7, 0xc6, 0x1b, 0xcc, 0xbd, 0x6a, 0x2, 0x4e, 0xaa, 0x79, 0xe5, 0x89, 0x39, 0xb7, 0xca, 0xef, 0x19, 0x34, 0x8f, 0x74, 0x5a, 0x46, 0x40, 0xd1, 0x52, 0x26, 0xc0, 0x53, 0x2f, 0x1a, 0xc3, 0x57, 0x40, 0xae, 0x23, 0xcd, 0xf1, 0xc5, 0xf7, 0x11, 0x37, 0x25, 0x2, 0x2a, 0x79, 0x48, 0x61, 0x5a, 0x33, 0x46, 0x8a, 0x3f, 0x2e, 0x84, 0x50, 0x15, 0x4e, 0x4d, 0x9d, 0xe4, 0x52, 0xd3, 0xb9, 0xd5, 0x36, 0x89, 0x80, 0x7, 0x58, 0x58, 0xac, 0x6, 0xab, 0x9b, 0x30, 0xfd, 0xd4, 0x32, 0xe4, 0x4e, 0xdd, 0x9d, 0xd3, 0xc5, 0x72, 0x81, 0xbf, 0xb5, 0xf4, 0xe6, 0x82, 0x2d, 0x8b, 0xac, 0xc2, 0xe3, 0x51, 0x28, 0x34, 0xaf, 0x79, 0xe0, 0xf8, 0xe1, 0x3f, 0x86, 0x4, 0xc6, 0xcc, 0x83, 0x8e, 0x2b, 0xd3, 0x56, 0xbc, 0x32, 0x24, 0xd3, 0x51, 0x18, 0x7c, 0x89, 0xcf, 0xa, 0x35, 0x6, 0x9c, 0x78, 0x91, 0xbb, 0xf9, 0xf2, 0xe7, 0xd6, 0xb5, 0xd1, 0x86, 0xec, 0x92, 0xca, 0x96, 0xa1, 0x7a, 0x75, 0xb5, 0x31, 0x5c, 0xa5, 0xec, 0xa9, 0x4c, 0x3, 0x76, 0x7c, 0x50, 0xb, 0x27, 0x28, 0xe3, 0x6b, 0x7c, 0x7c, 0x10, 0xa3, 0x91, 0x55, 0xaf, 0x28, 0xa8, 0xc2, 0x62, 0x15, 0x20, 0x65, 0xcb, 0x68, 0xae, 0x92, 0x96, 0x5f, 0xa, 0x2, 0x89, 0xfb, 0xc4, 0x70, 0xfd, 0xf7, 0x12, 0xcc, 0xe4, 0xa0, 0x3c, 0xd0, 0xaf, 0xa7, 0xd9, 0xd3, 0xda, 0x1e, 0x7, 0x99, 0x17, 0x7d, 0x78, 0xc5, 0xe8, 0x7e, 0xa5, 0xae, 0x6a, 0xa1, 0xfc, 0xf4, 0xa5, 0x14, 0x81, 0x2d, 0xe, 0xd0, 0x58, 0x74, 0x17, 0xf7, 0x6, 0x89, 0x1c, 0xab, 0x15, 0x84, 0x29, 0xa3, 0x26, 0xbf, 0xda, 0x7, 0xf6, 0xc3, 0x11, 0x2f, 0x72, 0x12, 0x75, 0x6e, 0x6a, 0xed, 0xe, 0x54, 0x8c, 0xfd, 0x78, 0x8a, 0xed, 0xc7, 0xcb, 0xd, 0x3, 0xd1, 0x34, 0x5b, 0x2a, 0x28, 0xc6, 0xd3, 0x86, 0x4e, 0xc6, 0x73, 0x60, 0xce, 0x23, 0x7f, 0x0, 0x8a, 0x22, 0x5d, 0xe3, 0x8b, 0x3c, 0x3d, 0x95, 0x4, 0x7d, 0x2e, 0xa9, 0x19, 0xe4, 0x7d, 0xed, 0x2b, 0x2b, 0x81, 0x39, 0xcd, 0x37, 0xd3, 0x0, 0xa5, 0x29, 0x65, 0x50, 0xa1, 0x62, 0xca, 0xfa, 0x5b, 0xc0, 0xe8, 0x1, 0x48, 0x30, 0x49, 0x54, 0x87, 0xa3, 0xc2, 0xc4, 0xc4, 0x92, 0x82, 0xb8, 0xe0, 0x4b, 0xb9, 0x88, 0xd7, 0x44, 0xc0, 0xc7, 0x24, 0x8a, 0xe2, 0x0, 0x3f, 0x41, 0xcc, 0xd4, 0x46, 0x66, 0xe0, 0x67, 0x96, 0xc6, 0xa, 0xe, 0x58, 0x5b, 0xb1, 0xe1, 0xb, 0x5c, 0xb8, 0xd3, 0x46, 0xe5, 0x8f, 0x98, 0x43, 0x42, 0x5f, 0xa3, 0x27, 0x1b, 0x52, 0x27, 0xd0, 0x49, 0x8a, 0xed, 0x29, 0x6, 0xf3, 0x6d, 0x90, 0x76, 0xb1, 0x8, 0x3b, 0xc2, 0x6f, 0xa3, 0xf5, 0x5, 0xd9, 0x8, 0xf0, 0xb2, 0x94, 0x14, 0x8c, 0x79, 0x6e, 0xe2, 0x8a, 0xab, 0x11, 0x91, 0xb9, 0xf4, 0x6f, 0x5a, 0x49, 0x50, 0x48, 0x5d, 0xbe, 0x91, 0x3b, 0x9e, 0x22, 0x36, 0x5f, 0x0, 0x64, 0x72, 0xe, 0x9f, 0x9, 0x68, 0x84, 0xc0, 0xb3, 0x6d, 0x18, 0x40, 0x5f, 0x35, 0xec, 0x92, 0x81, 0x1, 0xad, 0xcc, 0x82, 0xe3, 0xd5, 0x6d, 0xd5, 0x78, 0xb6, 0xe8, 0x1d, 0xd0, 0xef, 0x2a, 0x98, 0xdc, 0x94, 0x16, 0x68, 0x28, 0x83, 0x52, 0x2a, 0x5f, 0x35, 0x7c, 0x36, 0xf2, 0x92, 0xed, 0xb5, 0x33, 0x7e, 0xe, 0x6b, 0x33, 0xdb, 0x17, 0x71, 0xed, 0xd2, 0xe9, 0x8c, 0xf4, 0x40, 0xa6, 0x11, 0x6e, 0xee, 0x24, 0xc7, 0xeb, 0xa0, 0xbc, 0xfd, 0xb2, 0xff, 0x1e, 0x1c, 0x85, 0x2a, 0x69, 0x27, 0xcd, 0x12, 0x2e, 0xd0, 0x5a, 0x2d, 0x41, 0x4c, 0x51, 0xa5, 0x69, 0x44, 0xb3, 0x1, 0x2f, 0x5f, 0x9e, 0xb5, 0x45, 0xb8, 0x38, 0x78, 0x1c, 0x96, 0x4b, 0xed, 0x1c, 0x55, 0xf0, 0xb4, 0xe3, 0x6f, 0x25, 0x8f, 0x4d, 0xf, 0xfd, 0x1a, 0x1, 0xd5, 0xca, 0xd9, 0xa2, 0xed, 0x53, 0xdf, 0x6a, 0x19, 0x2e, 0xe7, 0x4d, 0xf6, 0x3d, 0xf7, 0xf6, 0x58, 0x7e, 0xb3, 0x1e, 0xd3, 0x65, 0xf5, 0x8f, 0x16, 0x66, 0x34, 0x3c, 0x33, 0xe4, 0x2d, 0x75, 0x32, 0x2f, 0xe5, 0x85, 0x75, 0x43, 0xca, 0xe1, 0x91, 0xb7, 0x99, 0xe3, 0x12, 0xd1, 0xeb, 0xb8, 0xf7, 0xd, 0xb1, 0x9f, 0x83, 0x1f, 0x13, 0x6e, 0xc1, 0x1f, 0x3f, 0xdb, 0x80, 0xb6, 0x93, 0xcd, 0x2d, 0x2c, 0x2a, 0x56, 0xa3, 0xd5, 0xa1, 0xf4, 0x8c, 0x63, 0xdd, 0x69, 0x1e, 0x3, 0x63, 0x87, 0xd6, 0x60, 0xee, 0x98, 0x88, 0x85, 0xf0, 0x8e, 0x4d, 0xb4, 0x7a, 0x72, 0xe5, 0x7c, 0x8b, 0x16, 0xc5, 0x83, 0xa7, 0xba, 0x9c, 0x13, 0xd6, 0xf6, 0x86, 0xe6, 0xc7, 0x16, 0x4e, 0x91, 0x19, 0x70, 0x9b, 0xed, 0xd8, 0x92, 0xdb, 0x2e, 0xd2, 0x44, 0xe7, 0x32, 0x5c, 0x31, 0x1e, 0x3f, 0xff, 0x48, 0x27, 0xcd, 0xe0, 0xac, 0x75, 0x7, 0xdd, 0x2d, 0x23, 0x88, 0xbb, 0x97, 0x8c, 0x62, 0x80, 0xac, 0x6e, 0x9, 0x6a, 0x12, 0xcc, 0x8b, 0x44, 0xc7, 0x7a, 0x5e, 0x4b, 0x4c, 0x79, 0xe2, 0xcc, 0xeb, 0x84, 0xe2, 0x4c, 0xe7, 0xe3, 0x4, 0x68, 0x67, 0xf2, 0xb9, 0x6a, 0xa3, 0xdc, 0x66, 0x3a, 0x2d, 0x66, 0xd4, 0x81, 0xf4, 0x7d, 0x81, 0xab, 0x48, 0x7b, 0x1a, 0x7f, 0xb0, 0x4b, 0x6b, 0x14, 0x43, 0xe1, 0xed, 0xd6, 0xa2, 0xc8, 0xfa, 0x9, 0x1, 0x5b, 0xc1, 0x7c, 0xda, 0x3d, 0x7a, 0x82, 0xb9, 0xdf, 0xa4, 0x19, 0x40, 0x94, 0xb4, 0x3, 0x53, 0xe0, 0xb2, 0x3b, 0x1f, 0x87, 0x8c, 0x3f, 0x3f, 0xba, 0x50, 0x5d, 0x70, 0x17, 0xed, 0x16, 0xef, 0xa, 0x3, 0x72, 0xf1, 0x44, 0x3e, 0x81, 0xd6, 0x9d, 0xbe, 0x1f, 0xff, 0x79, 0x94, 0x3a, 0xc8, 0xb6, 0xfa, 0x31, 0xaa, 0xbd, 0x9, 0x7, 0x33, 0x10, 0x99, 0x17, 0x73, 0x3, 0x33, 0xb8, 0x6c, 0x9, 0x3d, 0x72, 0x27, 0xdd, 0x54, 0xfc, 0xb5, 0x90, 0x61, 0x4d, 0x8f, 0x19, 0x59, 0x22, 0xb1, 0x20, 0x90, 0x43, 0x93, 0x97, 0x45, 0x60, 0xcc, 0xc4, 0x4e, 0x22, 0x5d, 0x17, 0x40, 0xf5, 0x59, 0xa, 0xd8, 0x73, 0xe3, 0x9, 0x3b, 0xbb, 0x1e, 0xaa, 0xc5, 0x4a, 0xc7, 0x70, 0x47, 0xaf, 0xf1, 0xb8, 0xb1, 0x43, 0x99, 0x44, 0xb5, 0xec, 0x78, 0x4c, 0xe8, 0xa4, 0xb1, 0xa1, 0x16, 0xf7, 0xd0, 0x8, 0xc3, 0xb2, 0x3f, 0x2f, 0x7c, 0x9e, 0xa1, 0xb, 0x80, 0x2b, 0x3b, 0xd0, 0xc5, 0x7d, 0x0, 0xba, 0x7d, 0x5f, 0xca, 0xc1, 0x2f, 0xc3, 0xb0, 0x33, 0xc3, 0x5e, 0xca, 0xb3, 0xc, 0x25, 0x63, 0xa0, 0x14, 0x3c, 0x7b, 0x54, 0xeb, 0xf3, 0xb5, 0xee, 0x18, 0xd8, 0x0, 0xff, 0xea, 0x1a, 0x4, 0xe9, 0x2a, 0x41, 0x75, 0x4b, 0x1b, 0xf, 0x71, 0x90, 0xe9, 0xaa, 0xf, 0x12, 0xf3, 0x49, 0x86, 0x25, 0xf2, 0x22, 0xde, 0x62, 0x1e, 0xc3, 0x11, 0x18, 0x6e, 0x22, 0x99, 0xf7, 0xf8, 0x6b, 0x4d, 0x95, 0xe3, 0x2, 0x4b, 0x46, 0xa5, 0x89, 0x89, 0x72, 0x3e, 0xd8, 0x8a, 0xd5, 0x7b, 0x9b, 0x99, 0x17, 0x64, 0x7f, 0x94, 0x84, 0x20, 0xfb, 0xc, 0xfb, 0x24, 0xa8, 0x65, 0x61, 0xf, 0x6, 0x50, 0xba, 0x77, 0x3c, 0x25, 0x8d, 0xf0, 0x9d, 0x73, 0x9f, 0x73, 0xfd, 0xa7, 0x6b, 0x12, 0xe7, 0xb5, 0x6c, 0x17, 0x74, 0xe6, 0x2e, 0xcb, 0xa2, 0x4a, 0xe, 0x0, 0xda, 0x25, 0xcb, 0x89, 0x6, 0x42, 0xe4, 0x9a, 0xb6, 0x63, 0x6c, 0xe5, 0xb2, 0xdd, 0xb5, 0x72, 0xd6, 0xca, 0xa0, 0xa9, 0x23, 0x1d, 0x16, 0x3a, 0x72, 0xd5, 0x66, 0x6f, 0xbd, 0x46, 0x67, 0x24, 0xde, 0x80, 0xf7, 0xbc, 0x67, 0xa4, 0x7f, 0x9e, 0xd5, 0x13, 0x67, 0x16, 0x4b, 0x9f, 0x87, 0x62, 0xb7, 0xb4, 0xa0, 0xcb, 0x4e, 0x91, 0xfe, 0xc5, 0x51, 0x42, 0x7c, 0xc9, 0xdb, 0x52, 0x85, 0x5c, 0x64, 0x57, 0xca, 0xd5, 0x35, 0x99, 0xae, 0x41, 0x6d, 0x2e, 0x94, 0x34, 0xaa, 0x4a, 0xd7, 0x2d, 0x19, 0x1e, 0x16, 0x25, 0x2, 0xd9, 0xaf, 0xd3, 0x54, 0xe8, 0xa3, 0xbe, 0xf8, 0xb8, 0x5a, 0x7c, 0xa1, 0xd5, 0x27, 0x35, 0xf5, 0xc1, 0xae, 0xe0, 0xa7, 0xf9, 0x8e, 0x3d, 0x1d, 0x79, 0x31, 0x48, 0xf0, 0x16, 0x3e, 0x4f, 0x86, 0x39, 0xc0, 0x79, 0x80, 0xc9, 0x78, 0xb, 0x2, 0x5a, 0x8f, 0x2f, 0x78, 0x79, 0x1, 0x86, 0xbc, 0x38, 0x2b, 0x76, 0x6d, 0x80, 0x18, 0xa1, 0xc3, 0xf6, 0xfc, 0x8, 0x8e, 0x14, 0xfb, 0xaa, 0xcc, 0xd9, 0xe9, 0x7d, 0x67, 0xca, 0x25, 0x93, 0x87, 0x99, 0x79, 0x8f, 0x11, 0xed, 0xee, 0xfa, 0xec, 0x5f, 0x96, 0xd1, 0x78, 0x2f, 0x10, 0x73, 0xa1, 0x4b, 0x97, 0x1f, 0xb0, 0x9f, 0xcd, 0x37, 0xbe, 0x34, 0xd3, 0x9a, 0x6b, 0x5e, 0x13, 0x8, 0xf5, 0x3f, 0xf2, 0x91, 0xcd, 0x19, 0xbb, 0xae, 0x6a, 0xbb, 0x79, 0x97, 0x83, 0x61, 0x78, 0xc0, 0x74, 0xf7, 0x18, 0x1d, 0x26, 0x93, 0x16, 0x11, 0xe1, 0xc8, 0x6e, 0x90, 0xba, 0x8e, 0xf3, 0x78, 0x1c, 0x81, 0xca, 0x4c, 0x93, 0x8, 0x6d, 0xd2, 0xf4, 0xda, 0xab, 0xc2, 0xf7, 0xef, 0x30, 0xce, 0xd5, 0x3a, 0xaf, 0xb9, 0xf, 0x97, 0x2b, 0x75, 0x77, 0x4c, 0xf7, 0xd3, 0x11, 0x2c, 0xd1, 0xca, 0x5b, 0xff, 0x8c, 0x1b, 0x46, 0x3f, 0xdf, 0x46, 0xae, 0xcc, 0xee, 0x30, 0xa2, 0x24, 0x7e, 0x9a, 0x20, 0x23, 0xec, 0x1e, 0x3e, 0xc2, 0x1b, 0x22, 0x50, 0xb8, 0xe9, 0xfe, 0x2b, 0x4b, 0xcc, 0xa8, 0x2c, 0x84, 0xf0, 0xbe, 0x24, 0x60, 0x5, 0x89, 0xf7, 0xb9, 0xd6, 0xbe, 0x5b, 0xea, 0x4d, 0x2a, 0xe5, 0x43, 0xd7, 0x38, 0xd0, 0xf2, 0xb7, 0xb0, 0x86, 0xc8, 0x8e, 0x92, 0xf7, 0xe1, 0x8b, 0x32, 0x3b, 0xeb, 0xc4, 0x4e, 0xae, 0xea, 0x26, 0xbe, 0x12, 0xfe, 0x32, 0x75, 0x3e, 0x3d, 0x20, 0x64, 0xe3, 0xde, 0xb7, 0xec, 0x9e, 0xa4, 0x92, 0x5e, 0x69, 0xde, 0x6b, 0x41, 0xe3, 0x18, 0x20, 0xd4, 0x9d, 0x6f, 0xa8, 0xe3, 0x3, 0xde, 0xf, 0xaf, 0x1b, 0x1f, 0xe6, 0xc7, 0xc2, 0x3a, 0x4e, 0x1d, 0xcc, 0x23, 0xbc, 0x62, 0x6c, 0x10, 0x8d, 0x51, 0x84, 0x14, 0x1d, 0x69, 0x14, 0xc4, 0xdb, 0xbb, 0x15, 0xd0, 0xa2, 0xf5, 0x5b, 0xc2, 0xdd, 0x4e, 0xcb, 0xed, 0x4c, 0x41, 0x9b, 0x9b, 0x0, 0xa6, 0x44, 0x4d, 0x63, 0x95, 0x22, 0x60, 0xc, 0x8f, 0x92, 0x4, 0xb0, 0xde, 0x1f, 0xce, 0x3b, 0x6b, 0xe5, 0x7e, 0x5a, 0x9b, 0xe, 0x3c, 0xde, 0x2a, 0x45, 0x59, 0x59, 0x78, 0xfe, 0xfa, 0xa4, 0x0, 0x8c, 0xf7, 0x4b, 0x13, 0xce, 0x86, 0xdb, 0x5c, 0x9a, 0xf0, 0xff, 0x4c, 0xe1, 0x22, 0xf6, 0xf, 0x7, 0x6, 0x94, 0x23, 0xf5, 0xe8, 0xc5, 0x13, 0xb5, 0xb9, 0x55, 0xd2, 0xa5, 0xc2, 0x2b, 0x11, 0xd4, 0x10, 0x3f, 0x9f, 0x37, 0xaf, 0xab, 0xd6, 0x6, 0xd5, 0xf, 0x79, 0x76, 0xc8, 0x8f, 0xe0, 0xf0, 0x1c, 0xac, 0xd0, 0x75, 0xf4, 0x82, 0x56, 0x15, 0xd3, 0xb9, 0x89, 0xf, 0x9d, 0xfe, 0xbe, 0x49, 0xab, 0x86, 0xe6, 0xf, 0x39, 0xe, 0xd2, 0xd7, 0x56, 0x59, 0x4e, 0x94, 0x82, 0x7a, 0x49, 0x46, 0x17, 0x22, 0x32, 0x97, 0x96, 0x65, 0xfa, 0x82, 0x64, 0xb7, 0xc0, 0xce, 0x1d, 0x8b, 0xfc, 0xa2, 0x3, 0xed, 0xbd, 0x7d, 0x39, 0x4a, 0x9d, 0xd0, 0x6b, 0x90, 0xd4, 0x28, 0xda, 0x3f, 0x7d, 0x58, 0xf9, 0x61, 0xd3, 0x68, 0x6, 0x8, 0xae, 0x82, 0xa0, 0x46, 0x9b, 0xf3, 0xb3, 0xea, 0xde, 0xdd, 0x34, 0x48, 0x98, 0x24, 0x6, 0x63, 0x8, 0x8b, 0x62, 0xb6, 0xfd, 0x38, 0x23, 0x5b, 0xc0, 0xd3, 0x91, 0x15, 0x12, 0x38, 0x96, 0x3c, 0x80, 0x61, 0x47, 0xf, 0x7, 0xe2, 0x1d, 0x3b, 0x7f, 0xe3, 0xbc, 0x6c, 0xfc, 0x4e, 0xfc, 0x55, 0xe, 0x29, 0x40, 0x87, 0x2b, 0x67, 0x32, 0x23, 0x53, 0xbd, 0xe6, 0x2, 0x5c, 0xd6, 0xd6, 0x5c, 0x16, 0x9b, 0x9d, 0x66, 0x74, 0x8d, 0x73, 0xb9, 0xde, 0x6b, 0xf9, 0xed, 0xc5, 0x7d, 0xa1, 0xd7, 0xaa, 0x7, 0x2b, 0xb2, 0xc3, 0x59, 0x61, 0xdf, 0x26, 0xfc, 0x7b, 0xc5, 0xa4, 0x92, 0x8a, 0x4c, 0x6a, 0x95, 0x37, 0x1b, 0x87, 0xe0, 0x3f, 0xc5, 0x2c, 0x2a, 0x6, 0x34, 0x29, 0x59, 0xf7, 0xa1, 0xbb, 0xe8, 0x96, 0x1d, 0x69, 0xff, 0x17, 0x4, 0xfa, 0xb2, 0x83, 0xb4, 0xa5, 0xbd, 0x41, 0x7a, 0x80, 0xe4, 0x5d, 0x92, 0x72, 0x7e, 0x5, 0x47, 0xa4, 0x3a, 0xb0, 0x4a, 0x59, 0x27, 0x2e, 0xe8, 0xb3, 0xf6, 0xc4, 0x49, 0x54, 0x14, 0xd0, 0xb, 0x88, 0xaa, 0x8a, 0x10, 0xe2, 0x2a, 0x1a, 0x68, 0x29, 0xdc, 0x2b, 0x3e, 0xa2, 0xf9, 0xd2, 0xa5, 0x44, 0xad, 0xa9, 0x33, 0xfb, 0x44, 0x25, 0x1d, 0xc6, 0xfb, 0x81, 0x4c, 0x82, 0xb0, 0xe2, 0xab, 0x1d, 0xad, 0x9f, 0x86, 0x9, 0xfe, 0x86, 0xeb, 0xef, 0xa6, 0x27, 0x7a, 0x67, 0x74, 0xc8, 0x1d, 0x49, 0x63, 0x57, 0x8d, 0x56, 0xa4, 0x9c, 0xa1, 0xa5, 0xb8, 0x4, 0x23, 0xa6, 0xb1, 0xd1, 0x73, 0x5b, 0xa3, 0xe6, 0xc0, 0xa0, 0xcd, 0x4a, 0xec, 0x87, 0x7d, 0x9a, 0xae, 0xa8, 0x42, 0x45, 0xca, 0xba, 0x67, 0x86, 0x66, 0xcb, 0x5c, 0x2b, 0x48, 0xae, 0x67, 0x1b, 0xef, 0xed, 0x3e, 0xd3, 0x27, 0x18, 0x8f, 0xf2, 0xc, 0x1a, 0x5e, 0x44, 0xa7, 0xe1, 0x4e, 0x4e, 0xaa, 0x6b, 0xe3, 0xa0, 0x1c, 0x8a, 0x65, 0x8e, 0x37, 0xf3, 0x37, 0xf3, 0xcc, 0x80, 0x74, 0xd6, 0x5e, 0xb3, 0x72, 0x55, 0x95, 0x44, 0x1f, 0xe7, 0xd6, 0x6e, 0x13, 0x21, 0x38, 0x5b, 0x21, 0x81, 0x6, 0xe, 0xfc, 0xd9, 0x2f, 0xdd, 0x5a, 0x55, 0x6b, 0x83, 0x39, 0x89, 0x8, 0x84, 0xa5, 0x4e, 0xdf, 0xa, 0xfe, 0x41, 0x33, 0x12, 0x3f, 0x1, 0x8e, 0x9a, 0x27, 0x5, 0x1a, 0x9b, 0xcd, 0x4, 0x73, 0x1e, 0x9e, 0xad, 0x92, 0x33, 0xef, 0x5, 0x64, 0xe1, 0x62, 0xd5, 0x46, 0x31, 0x9b, 0x13, 0xfc, 0x43, 0xb, 0x8d, 0x43, 0x4e, 0x2d, 0xdb, 0x6, 0x9d, 0x98, 0x3c, 0xc1, 0x2b, 0xf1, 0x78, 0x98, 0x38, 0x68, 0xd3, 0x4f, 0x39, 0xf2, 0x52, 0xa8, 0xf1, 0xf1, 0xe8, 0x27, 0xf8, 0x3a, 0x53, 0xbd, 0x7c, 0x4, 0xfd, 0x83, 0x4, 0x9d, 0xae, 0x31, 0xe2, 0xdf, 0x2b, 0x5e, 0xfb, 0x6a, 0xb8, 0x53, 0x8d, 0x9, 0x1, 0x89, 0xa0, 0xa9, 0x55, 0x70, 0xe3, 0xae, 0xde, 0x41, 0xe9, 0x38, 0xf4, 0xaf, 0x84, 0xd1, 0x95, 0x45, 0x84, 0x2, 0x82, 0x9b, 0xd2, 0x77, 0x59, 0xd3, 0xa4, 0x29, 0x15, 0x3a, 0xa, 0x86, 0x66, 0x1, 0x1a, 0x2, 0x3e, 0xc5, 0xc, 0xfd, 0xf7, 0x65, 0xc5, 0x5e, 0xcf, 0x5, 0x42, 0x6b, 0x87, 0x2b, 0x95, 0xfc, 0xf2, 0x81, 0xdb, 0x66, 0x2d, 0xd8, 0xf1, 0x68, 0x9d, 0x8, 0xee, 0x83, 0xbb, 0x32, 0x24, 0x1b, 0x29, 0x76, 0x5a, 0x1b, 0xe2, 0xd8, 0xc9, 0xe5, 0x34, 0x27, 0x89, 0xda, 0x43, 0x9e, 0x7d, 0x94, 0xa4, 0xe6, 0x73, 0x7, 0x41, 0x18, 0x2d, 0xf1, 0xe6, 0x1e, 0x18, 0xe5, 0xb8, 0x20, 0xd1, 0x90, 0xe4, 0x6f, 0xa4, 0x61, 0xee, 0x4f, 0xaf, 0x5e, 0x79, 0x72, 0x90, 0xd3, 0x45, 0x8f, 0xe4, 0xba, 0x80, 0x57, 0x50, 0xad, 0x85, 0x67, 0x9a, 0x16, 0x77, 0x18, 0xfd, 0xc1, 0xb3, 0x5b, 0x7, 0x64, 0x5d, 0x9e, 0x82, 0x19, 0x46, 0x59, 0xfa, 0x4d, 0x52, 0x43, 0x27, 0x60, 0xc, 0xbf, 0x69, 0xe1, 0x9a, 0x76, 0x94, 0x4e, 0xe7},
+               output224: []byte{0x5, 0x69, 0x2e, 0x46, 0xa9, 0x53, 0xae, 0x4a, 0x49, 0x57, 0x73, 0xc8, 0x7c, 0x6c, 0xcc, 0xa2, 0xd7, 0x6f, 0xfa, 0xbf, 0x55, 0x9e, 0xf2, 0xd, 0x24, 0x7, 0x9a, 0x54},
+               output256: []byte{0x25, 0x97, 0xaa, 0xb9, 0x21, 0x4e, 0x2c, 0xa7, 0x37, 0x3c, 0x7e, 0x7e, 0x7, 0xb4, 0xf2, 0x4b, 0xc9, 0x29, 0x3c, 0x50, 0xff, 0x22, 0x6f, 0xfe, 0xd8, 0xf0, 0x20, 0x24, 0x12, 0x7d, 0xe8, 0x28},
+               output384: []byte{0xa9, 0x8c, 0x5e, 0xff, 0x26, 0xd2, 0x7c, 0x8d, 0xda, 0x17, 0xe9, 0x19, 0xa4, 0x5b, 0xf9, 0xa, 0x60, 0xf, 0x23, 0x6e, 0x3f, 0xb, 0xd8, 0xdb, 0x1f, 0x2f, 0x61, 0x1f, 0xa, 0x77, 0x6, 0x96, 0xce, 0xe4, 0x59, 0x8e, 0xcd, 0xa, 0x15, 0xd3, 0xa1, 0xdb, 0x7e, 0xa9, 0x98, 0x94, 0x9f, 0xf6},
+               output512: []byte{0x51, 0x8a, 0xa2, 0x64, 0xff, 0xe3, 0x82, 0x3, 0x82, 0xc9, 0x8e, 0xa1, 0x25, 0x4a, 0xc8, 0x2c, 0x30, 0x45, 0xbb, 0xcb, 0xc9, 0xaf, 0x9d, 0x7e, 0x7f, 0xa3, 0x68, 0x52, 0x5b, 0xb9, 0x5b, 0x7, 0x4c, 0xe3, 0xb4, 0x7c, 0xe6, 0xd6, 0xa7, 0x6f, 0xf1, 0x21, 0x2b, 0x79, 0x1a, 0xef, 0x6f, 0xf1, 0x91, 0xa0, 0xa0, 0x4a, 0xd3, 0x8e, 0x6a, 0x98, 0xc3, 0xd2, 0x6e, 0x24, 0x28, 0x4c, 0xee, 0x3d}},
+       testcase{
+               msg:       []byte{0x85, 0x98, 0xb3, 0x2e, 0x7e, 0xe9, 0x46, 0x9b, 0x6d, 0x33, 0x24, 0x7a, 0xeb, 0x8a, 0xfb, 0x12, 0xd6, 0xbd, 0xc3, 0xee, 0x4a, 0xe5, 0xa4, 0x96, 0x83, 0xe8, 0x4c, 0x73, 0xfb, 0x35, 0x3a, 0x7b, 0xa6, 0xfd, 0xd9, 0x5c, 0x49, 0x7f, 0x42, 0x9e, 0x82, 0xf0, 0x7b, 0x2b, 0x65, 0x2d, 0x7e, 0x41, 0x5e, 0x9b, 0x93, 0xb5, 0x9e, 0x54, 0x1a, 0xbf, 0x46, 0xc8, 0x8f, 0xa5, 0x4e, 0xe0, 0x68, 0xf9, 0x7, 0x64, 0x56, 0x4a, 0x11, 0xa5, 0x9f, 0x1d, 0x4, 0xd8, 0xb8, 0x8d, 0xe1, 0x86, 0xc4, 0x21, 0x72, 0x85, 0xb7, 0x27, 0x96, 0xd5, 0xc0, 0x57, 0x5d, 0xae, 0xcc, 0x30, 0x92, 0xf, 0x6b, 0xfd, 0xbe, 0xa7, 0x72, 0xa7, 0xb1, 0x83, 0x39, 0xa1, 0xe2, 0xcc, 0xfc, 0x79, 0xfc, 0x8a, 0x98, 0x39, 0xb2, 0xa, 0x98, 0x1d, 0x52, 0x91, 0x2, 0x5f, 0x34, 0x1e, 0x5d, 0x7a, 0xcc, 0x1a, 0x3b, 0xb4, 0x12, 0x90, 0x91, 0xa5, 0x6, 0x2b, 0x9e, 0x54, 0xbe, 0x7e, 0xd8, 0xaf, 0x81, 0x96, 0xca, 0x7a, 0x9e, 0xca, 0xf1, 0x8c, 0xcc, 0xe4, 0xa1, 0xd7, 0x18, 0x14, 0x98, 0x9, 0xd0, 0x8a, 0x8a, 0xc8, 0x6c, 0x9a, 0x12, 0xe7, 0x63, 0x79, 0xf6, 0x34, 0xac, 0x16, 0x15, 0xaf, 0x3, 0xab, 0xb9, 0x28, 0x7c, 0x4b, 0x4a, 0x79, 0x84, 0x7b, 0x52, 0xed, 0x4f, 0xa1, 0x7e, 0x15, 0x27, 0x49, 0x53, 0x62, 0xb6, 0x25, 0x15, 0x5e, 0x9f, 0x1a, 0xa3, 0xa3, 0xe5, 0xd0, 0x82, 0x12, 0x40, 0xd8, 0x36, 0x8, 0x94, 0xe1, 0x9a, 0x56, 0x20, 0xbd, 0xbe, 0x0, 0xa7, 0xaf, 0x6c, 0x40, 0xb1, 0xe5, 0x13, 0x49, 0x6, 0x71, 0xbd, 0xbe, 0x40, 0x23, 0x79, 0xf4, 0x95, 0xc5, 0x28, 0xe2, 0x18, 0x2, 0x8d, 0x31, 0x5f, 0x6e, 0xf8, 0x20, 0xc3, 0x83, 0xc8, 0x36, 0x30, 0xf7, 0x56, 0x44, 0x53, 0xf0, 0xe2, 0xd3, 0x87, 0x27, 0x38, 0x54, 0xfa, 0x5, 0xf4, 0xda, 0x7b, 0xc2, 0x4c, 0xab, 0xb, 0x71, 0xd4, 0x9, 0x2a, 0x43, 0x2c, 0xb0, 0x85, 0x49, 0x16, 0xf7, 0x1c, 0x3b, 0x86, 0x40, 0xca, 0x60, 0x25, 0x47, 0x92, 0x2c, 0x98, 0x67, 0xb0, 0x2, 0xdf, 0x73, 0x82, 0xaf, 0x29, 0xe4, 0xe1, 0xb9, 0x93, 0xd1, 0xfa, 0x74, 0xd9, 0x50, 0x6, 0x3e, 0x52, 0x7d, 0xb6, 0xca, 0xb, 0x73, 0x6b, 0x89, 0x6, 0x96, 0x24, 0x12, 0xea, 0x1d, 0xae, 0x21, 0x8a, 0xc, 0x86, 0xaa, 0xcf, 0x51, 0x36, 0x2b, 0xb8, 0xbc, 0xeb, 0x38, 0x26, 0xbc, 0x32, 0x49, 0xf1, 0xc5, 0x15, 0x5f, 0xc, 0xb5, 0x1, 0x33, 0xd0, 0x52, 0x7b, 0x98, 0xba, 0x21, 0xf7, 0x57, 0xf7, 0x2a, 0x9c, 0x52, 0xd3, 0x42, 0xde, 0x1, 0x3b, 0xb3, 0x8e, 0xa5, 0x27, 0x74, 0xa7, 0xc0, 0x12, 0xdc, 0xc0, 0xa5, 0x80, 0x51, 0xcd, 0xa5, 0x65, 0xfd, 0xb4, 0x5a, 0x1f, 0x6, 0x50, 0x41, 0xba, 0x5f, 0xe6, 0x2d, 0xc, 0x46, 0xcb, 0xb1, 0xb9, 0xef, 0x7d, 0x66, 0x9b, 0xe3, 0x19, 0xd9, 0x88, 0x34, 0x78, 0x6f, 0x55, 0x32, 0x22, 0x5d, 0x26, 0xd1, 0x84, 0xab, 0xb3, 0x8e, 0x34, 0x5c, 0x4c, 0xda, 0x3f, 0xe3, 0xb8, 0x52, 0x25, 0xd6, 0xf6, 0xc7, 0xa, 0xee, 0xc8, 0x1, 0xbb, 0x57, 0x1c, 0x5e, 0x44, 0xd9, 0x29, 0x8f, 0x2, 0xf6, 0x32, 0x45, 0x3c, 0x14, 0xd1, 0xc7, 0x10, 0xcd, 0xec, 0x58, 0x43, 0xb7, 0xa0, 0x55, 0x81, 0x75, 0x87, 0xd7, 0x90, 0xfc, 0x58, 0x90, 0x17, 0x34, 0x8d, 0xac, 0xc1, 0x8b, 0x68, 0x6b, 0xa0, 0xee, 0x29, 0xd0, 0x74, 0xcf, 0xfa, 0x70, 0x1, 0x7d, 0x97, 0x24, 0x49, 0xf4, 0xd7, 0x2, 0xc0, 0x51, 0x12, 0x5f, 0xec, 0xa4, 0x8a, 0xd3, 0xc5, 0xf8, 0x84, 0x31, 0x78, 0x97, 0x14, 0xc9, 0xf, 0x48, 0xed, 0xfc, 0x38, 0x2c, 0x28, 0xf5, 0xd9, 0x43, 0x9b, 0x88, 0x53, 0x1b, 0x0, 0x3b, 0xe7, 0x93, 0x5a, 0x84, 0x5d, 0xcf, 0x5e, 0xe5, 0x45, 0xa6, 0x61, 0x7a, 0x3b, 0x5, 0xee, 0xea, 0xd8, 0x9e, 0xd5, 0xb9, 0x50, 0xed, 0xd0, 0x91, 0x9b, 0xee, 0x24, 0x3e, 0xbf, 0x5c, 0xef, 0x53, 0x6a, 0xa, 0x7c, 0x28, 0x15, 0x8b, 0xed, 0x2f, 0x83, 0x8f, 0x49, 0x4a, 0x2e, 0x82, 0x8c, 0x58, 0xb, 0x48, 0xd8, 0x8e, 0x21, 0x6f, 0x50, 0x49, 0x2e, 0x75, 0x42, 0x75, 0x69, 0x78, 0x82, 0xc9, 0x4d, 0x1a, 0xdd, 0x46, 0xfe, 0x44, 0x3b, 0x76, 0x6d, 0xab, 0xe2, 0xf9, 0xad, 0xa1, 0x42, 0xa5, 0xbb, 0x1a, 0x9, 0x6d, 0x3d, 0xbb, 0x71, 0xfd, 0x6b, 0x55, 0x81, 0xe, 0xe5, 0xb2, 0x98, 0x97, 0x45, 0x69, 0x5d, 0x4b, 0xfa, 0x14, 0x30, 0x13, 0xf7, 0xea, 0x34, 0x42, 0x48, 0x33, 0xfe, 0x9, 0xd8, 0x96, 0x6a, 0xb, 0x97, 0xb6, 0x29, 0x53, 0xc4, 0xcb, 0xca, 0xc8, 0x6c, 0xfc, 0x83, 0xe1, 0x4a, 0xb3, 0x6a, 0x4d, 0x9f, 0x8e, 0x8c, 0xd9, 0x1, 0x7, 0x13, 0x70, 0x2e, 0x1d, 0xb6, 0xc2, 0x7b, 0xd0, 0x16, 0x67, 0x77, 0xe2, 0xbd, 0xb5, 0x26, 0x8c, 0xa3, 0x88, 0x39, 0x49, 0x86, 0x68, 0x3d, 0xb8, 0x3a, 0xe0, 0x60, 0x3f, 0xa6, 0x11, 0xac, 0xad, 0x58, 0x7f, 0xdf, 0xf4, 0x71, 0x71, 0x8f, 0x20, 0xf4, 0x23, 0x60, 0xfb, 0x5c, 0x3d, 0xe8, 0xa3, 0xb3, 0xfe, 0xc0, 0x68, 0xe9, 0xdc, 0x49, 0x6f, 0x66, 0x4f, 0xdc, 0xc, 0x30, 0x5a, 0xe9, 0x36, 0xc7, 0xae, 0x56, 0xa, 0x5, 0x68, 0xcc, 0x50, 0x9f, 0x99, 0xae, 0x62, 0xc6, 0x28, 0x4f, 0x8b, 0xf2, 0xa2, 0x80, 0x1c, 0x39, 0xc7, 0x92, 0x95, 0x60, 0x9b, 0x62, 0x22, 0x47, 0xb9, 0xf1, 0xf6, 0xe0, 0xe7, 0x7a, 0xd8, 0x9f, 0xd5, 0x44, 0x9c, 0xd9, 0xbb, 0xb8, 0x4a, 0x52, 0x37, 0x95, 0xf5, 0x79, 0x43, 0x2c, 0x19, 0xe9, 0x2b, 0x27, 0xb, 0x68, 0x46, 0xd7, 0x29, 0x86, 0xef, 0x5, 0x2d, 0xec, 0x37, 0x2b, 0x3d, 0xb6, 0xd8, 0x44, 0x9f, 0x36, 0x2, 0xfb, 0xcd, 0x66, 0x2e, 0x2d, 0xcd, 0x4e, 0xdc, 0xc5, 0x9e, 0x2a, 0x6d, 0x15, 0xe8, 0xa4, 0x1c, 0xa7, 0x93, 0x23, 0x43, 0x98, 0x17, 0x70, 0x12, 0x1a, 0x78, 0xd3, 0x4b, 0x74, 0x0, 0x77, 0x80, 0x72, 0xc8, 0x9d, 0xe9, 0x69, 0xd0, 0x46, 0x8a, 0xc0, 0x52, 0xae, 0x54, 0xd6, 0x7, 0x66, 0x60, 0xc6, 0x7e, 0x47, 0xab, 0x93, 0x31, 0x3e, 0x9a, 0x97, 0x9d, 0x80, 0xe0, 0x54, 0x42, 0xb4, 0xe3, 0x28, 0xe8, 0x9e, 0x79, 0x81, 0x58, 0xb7, 0x47, 0xab, 0x23, 0x7c, 0xa5, 0x77, 0xac, 0xba, 0xa0, 0x7c, 0xb8, 0x5f, 0x8a, 0xe7, 0xb1, 0xc9, 0x32, 0x5f, 0xe8, 0xb2, 0x69, 0x76, 0x53, 0x99, 0xea, 0xd3, 0x75, 0x22, 0xcd, 0xe1, 0xf0, 0x71, 0xdc, 0x26, 0xbb, 0xc4, 0xd1, 0xe7, 0xaa, 0x8f, 0x5f, 0x4d, 0xd6, 0x6a, 0x86, 0x1a, 0x8f, 0x4f, 0xa3, 0x81, 0x83, 0xb3, 0x96, 0x2b, 0x97, 0x39, 0x34, 0x14, 0x4, 0x25, 0x3c, 0x93, 0xd7, 0xde, 0xc6, 0xb4, 0x54, 0xdd, 0xba, 0xc9, 0xf9, 0x42, 0xf2, 0xf7, 0x8d, 0x6f, 0x75, 0x89, 0x7e, 0x67, 0x3b, 0x9e, 0xca, 0xcb, 0x15, 0x79, 0xe2, 0x98, 0xb8, 0xb9, 0x44, 0x6b, 0x11, 0xaa, 0x43, 0xc6, 0xba, 0x75, 0x11, 0xed, 0x9c, 0xa8, 0x31, 0x15, 0x2d, 0x3c, 0x3e, 0xf0, 0xef, 0x39, 0xa, 0x2c, 0xe6, 0x5f, 0x4f, 0x5f, 0x6e, 0x17, 0x7b, 0x50, 0xc9, 0xaf, 0x91, 0x2b, 0xa4, 0xb4, 0x54, 0x82, 0x8, 0x57, 0x1a, 0x43, 0xd6, 0x85, 0x4a, 0x8e, 0xd4, 0x47, 0x9d, 0x95, 0x38, 0x45, 0x65, 0x39, 0x20, 0x3d, 0x49, 0x1, 0x3, 0xdd, 0x23, 0xba, 0xce, 0x9, 0x5d, 0xb, 0xf6, 0x6c, 0x17, 0xf2, 0x41, 0x1d, 0x51, 0x40, 0x84, 0xe0, 0x47, 0x97, 0x6, 0x96, 0x40, 0xe, 0x1b, 0xc9, 0xce, 0x48, 0x98, 0xca, 0x62, 0xfb, 0x35, 0x8b, 0x9, 0x6d, 0xaf, 0x8a, 0x38, 0x57, 0xac, 0x39, 0x8a, 0x7, 0x88, 0x2e, 0x22, 0x1, 0xf8, 0xca, 0xe, 0x4d, 0x1c, 0xf0, 0xca, 0x4e, 0x47, 0xbb, 0x26, 0x8a, 0x91, 0xdb, 0xaf, 0xa8, 0x37, 0x37, 0x53, 0x84, 0xa1, 0xbd, 0x68, 0xf8, 0x78, 0x94, 0xaf, 0x81, 0xbb, 0xf1, 0xe2, 0x20, 0xc2, 0xd3, 0xc3, 0xb2, 0xb9, 0x3a, 0x87, 0x7c, 0xf6, 0xa7, 0xc2, 0x53, 0xcf, 0x66, 0xb, 0x49, 0x8d, 0x3e, 0xfa, 0x4f, 0x38, 0xb9, 0xb4, 0x1, 0x81, 0x6c, 0xa, 0xa5, 0x1f, 0xfd, 0x3b, 0xe9, 0xf3, 0x6a, 0xa1, 0xd2, 0x33, 0x5f, 0x4c, 0x7, 0x94, 0x87, 0xbe, 0x16, 0xe5, 0x32, 0xbb, 0xf, 0xdf, 0x8e, 0x0, 0xd5, 0xd8, 0x37, 0x9c, 0xf, 0x61, 0x7f, 0x71, 0x48, 0x0, 0x9e, 0xc5, 0x7d, 0xae, 0x98, 0xcd, 0x41, 0xac, 0x1, 0xd3, 0xd0, 0xb5, 0x68, 0xe0, 0x8, 0x57, 0x75, 0x69, 0x4c, 0x74, 0xfc, 0x33, 0x9f, 0xb5, 0xf5, 0xa5, 0x7c, 0x27, 0x4d, 0xa0, 0x7c, 0xb4, 0xda, 0xe5, 0x48, 0x33, 0xbb, 0x74, 0xb0, 0x79, 0x3e, 0x93, 0xe8, 0xf1, 0xb5, 0xa7, 0xf5, 0xa0, 0x92, 0xe9, 0x4, 0x59, 0xf2, 0xc6, 0xb7, 0xe7, 0xa6, 0xf4, 0x88, 0xe3, 0xc7, 0xae, 0x10, 0xac, 0x90, 0xc3, 0x58, 0xc5, 0xbf, 0xd6, 0x3, 0x8, 0xa, 0x54, 0x48, 0x22, 0xb4, 0x66, 0x3a, 0xec, 0x1a, 0x42, 0xd3, 0xf1, 0x6e, 0x33, 0x50, 0x47, 0xa1, 0xc9, 0xef, 0x69, 0x39, 0xc3, 0x6c, 0xc3, 0x4d, 0xaf, 0xc9, 0xee, 0xdb, 0x13, 0xe1, 0xa9, 0x55, 0x92, 0x79, 0x86, 0x6a, 0x6d, 0x71, 0xa9, 0x7f, 0xfd, 0x31, 0x7f, 0xbb, 0xcd, 0x8c, 0xf8, 0x4, 0x76, 0xd5, 0x92, 0x71, 0x13, 0x6e, 0xde, 0xa5, 0xa1, 0x86, 0xe7, 0xea, 0xb7, 0xfc, 0x28, 0x88, 0x1c, 0x8, 0xfa, 0xf7, 0xc5, 0x41, 0x6e, 0xa4, 0x80, 0x1a, 0x1e, 0xb9, 0xe0, 0xc8, 0x83, 0xdb, 0xdf, 0xd5, 0xcf, 0xf, 0xc, 0x9a, 0x61, 0x9d, 0x91, 0x48, 0x1e, 0x41, 0x3a, 0x74, 0xf0, 0x1d, 0x86, 0xbc, 0x76, 0x2f, 0x4b, 0x5, 0x49, 0x7e, 0x20, 0x89, 0x3c, 0xd5, 0x5c, 0xc, 0x57, 0xc, 0xaa, 0x3f, 0xa0, 0xb, 0xd5, 0x37, 0xd6, 0x37, 0x3b, 0x60, 0xd3, 0x2c, 0xa1, 0x4a, 0x36, 0xbd, 0x2f, 0xdb, 0x3e, 0xac, 0x13, 0x44, 0xe4, 0x5, 0x2e, 0xfe, 0x7d, 0x1a, 0xbc, 0xc7, 0x74, 0x80, 0xee, 0x43, 0x30, 0x8, 0xde, 0xba, 0xf7, 0x1c, 0x9f, 0xb7, 0x7, 0x0, 0x5, 0xd8, 0x36, 0x5a, 0xc1, 0x12, 0xf1, 0x51, 0xb3, 0x74, 0xda, 0x14, 0x1e, 0x1f, 0xc6, 0x2b, 0x3e, 0x40, 0xa7, 0x4f, 0x35, 0x46, 0xbf, 0x4f, 0x2, 0xea, 0x80, 0x50, 0xb8, 0x23, 0xcf, 0x2c, 0xd5, 0xfd, 0x13, 0x4f, 0x10, 0xab, 0xc2, 0xdb, 0xb, 0x9b, 0x27, 0xf5, 0xc0, 0xa4, 0x4e, 0x32, 0xe, 0xff, 0x81, 0xa0, 0xf7, 0xef, 0xd4, 0x27, 0x1b, 0xc9, 0xd5, 0x74, 0xd6, 0xa8, 0x2f, 0xa8, 0x7, 0xb0, 0x5f, 0x38, 0x92, 0x56, 0x4d, 0x8b, 0xf5, 0x4d, 0xb7, 0xb8, 0x1a, 0xc8, 0x7b, 0x63, 0x3c, 0x53, 0xf8, 0x18, 0x74, 0x36, 0xc1, 0xdf, 0x43, 0x5b, 0xa2, 0xd1, 0x6d, 0x72, 0x35, 0x3e, 0xf7, 0xb3, 0x9c, 0xc5, 0x50, 0xcf, 0xec, 0x1e, 0xc2, 0x50, 0x29, 0x2, 0xaa, 0x6b, 0xf4, 0xd5, 0x5, 0x63, 0x30, 0x1f, 0xb, 0x39, 0xa9, 0xd2, 0x1, 0xfc, 0x2, 0xb0, 0xc9, 0xac, 0xba, 0x14, 0x78, 0x43, 0xa5, 0xab, 0xa, 0xd1, 0x5e, 0x1f, 0xbd, 0x9d, 0x38, 0x80, 0xd9, 0x97, 0x79, 0xd0, 0xfb, 0xcd, 0x21, 0x77, 0x46, 0xae, 0xba, 0xcc, 0x23, 0x1a, 0x12, 0x85, 0x92, 0x7f, 0xb, 0xc8, 0x8, 0xb2, 0xa5, 0x27, 0x71, 0x79, 0x8a, 0x91, 0x4, 0x79, 0x2d, 0xd0, 0xe9, 0xc9, 0x38, 0xf6, 0x69, 0x29, 0xd3, 0x3, 0x90, 0xd1, 0x6f, 0x57, 0x59, 0x1d, 0xfe, 0xd8, 0x42, 0x47, 0x92, 0xc1, 0xa0, 0xcf, 0xea, 0x7c, 0xd2, 0xda, 0x90, 0xc6, 0xc2, 0xa8, 0x2, 0x34, 0xf3, 0xb3, 0x50, 0xd, 0xce, 0xc0, 0x78, 0xbd, 0xae, 0x33, 0x38, 0x16, 0xce, 0xaa, 0xbe, 0x9b, 0x68, 0x6a, 0xd0, 0xbb, 0x24, 0xf6, 0x5b, 0xfc, 0xa8, 0x62, 0x22, 0xbf, 0xc6, 0x28, 0x84, 0x3b, 0xb4, 0xd3, 0x28, 0xda, 0x1e, 0xa2, 0x82, 0x81, 0xd9, 0xa3, 0xd2, 0x9e, 0xd, 0x7e, 0xeb, 0x9f, 0xe2, 0x4b, 0x33, 0x28, 0x4d, 0x73, 0x48, 0x6d, 0x8d, 0x5f, 0x37, 0xdf, 0x74, 0x50, 0x40, 0x97, 0x22, 0xe8, 0x28, 0xb8, 0x79, 0xb8, 0xf7, 0xd1, 0x7a, 0xab, 0x0, 0x2e, 0xd2, 0xc2, 0xfd, 0x7f, 0x3, 0xfa, 0x46, 0x47, 0xf4, 0x9d, 0x4f, 0x1b, 0x20, 0x4c, 0xd, 0xe0, 0xb4, 0x13, 0xc6, 0x13, 0x96, 0x3a, 0xc, 0x3a, 0xd0, 0x2, 0x6a, 0xde, 0xc9, 0x27, 0x97, 0x79, 0xa0, 0xc7, 0x98, 0x65, 0x26, 0xf8, 0xc9, 0x74, 0x2b, 0xaa, 0x0, 0xc0, 0x88, 0xb6, 0x82, 0x6c, 0x24, 0x49, 0x37, 0x8f, 0x47, 0xeb, 0x6d, 0xb7, 0x5c, 0xfa, 0x1, 0x3b, 0xc1, 0x91, 0x6, 0xe1, 0x8d, 0x6, 0x2b, 0x6, 0x98, 0xba, 0x2, 0x5, 0x4d, 0x87, 0x19, 0xf7, 0x56, 0x28, 0x41, 0x91, 0x46, 0x1f, 0xdc, 0x5d, 0x33, 0xcf, 0xd, 0x15, 0x41, 0x9a, 0xbe, 0xa0, 0x10, 0xc8, 0xba, 0xd6, 0xe1, 0xb, 0x79, 0xcc, 0x39, 0x33, 0x4f, 0xa8, 0x78, 0x93, 0x83, 0xca, 0x3, 0x73, 0x2e, 0x3d, 0xe9, 0xe4, 0x54, 0xd2, 0x94, 0x49, 0x13, 0xed, 0x2c, 0x74, 0x2, 0x1b, 0x7b, 0x39, 0x3b, 0x36, 0x41, 0x44, 0x8a, 0x62, 0x33, 0xa9, 0xee, 0xde, 0x72, 0xb8, 0xdd, 0x5a, 0x46, 0x3e, 0x5a, 0x2d, 0xd7, 0xb4, 0x41, 0x28, 0xb0, 0x9c, 0x1d, 0x25, 0x6f, 0x69, 0x42, 0xcd, 0x7d, 0xb7, 0x4e, 0x48, 0x93, 0x40, 0x2b, 0x6a, 0xec, 0x1c, 0x1, 0x17, 0x5, 0x23, 0xbb, 0xf3, 0x30, 0x15, 0x57, 0x5f, 0xac, 0x45, 0x34, 0x70, 0xe, 0x91, 0x15, 0x33, 0x70, 0x0, 0x6d, 0x82, 0x9e, 0x4b, 0x76, 0x21, 0x6b, 0x94, 0xf, 0x19, 0x45, 0xfe, 0xd3, 0x13, 0x78, 0x80, 0xb, 0xae, 0x38, 0x5a, 0x54, 0xc4, 0xd3, 0x2d, 0xd7, 0xa9, 0x60, 0xe8, 0xb2, 0xed, 0x1e, 0x34, 0xfe, 0x8d, 0xb1, 0xcb, 0xc7, 0xd1, 0xe7, 0xa8, 0x68, 0x47, 0xa6, 0x9f, 0xf5, 0xfa, 0xbd, 0x40, 0xb0, 0xe9, 0x19, 0x1e, 0x42, 0x68, 0x43, 0xfb, 0x79, 0xa1, 0xde, 0xe7, 0xdd, 0xb, 0xae, 0x4c, 0x55, 0xe5, 0x8f, 0x32, 0x2a, 0x4f, 0x65, 0x86, 0x22, 0xb, 0xa, 0x5d, 0x48, 0x3e, 0x70, 0xf9, 0x98, 0xb1, 0x6, 0x56, 0xd1, 0xf5, 0x6f, 0xe9, 0x11, 0xcf, 0xb0, 0xd1, 0xcf, 0x9c, 0xe1, 0xa2, 0x4c, 0x4b, 0xd, 0x4f, 0x19, 0xa0, 0x41, 0x29, 0xdd, 0xa0, 0x63, 0xfe, 0x17, 0xcb, 0x8f, 0x0, 0xcf, 0x9d, 0x51, 0x6d, 0x44, 0xba, 0xd, 0x1a, 0xf9, 0xac, 0x23, 0xbe, 0xe5, 0x5c, 0xa3, 0x7, 0xfe, 0x69, 0xf6, 0xd1, 0x75, 0x3a, 0xce, 0x1b, 0x18, 0x93, 0xdc, 0xb4, 0x55, 0x93, 0x4f, 0x73, 0x48, 0x5c, 0xa3, 0xd8, 0xc1, 0x41, 0xb5, 0x6c, 0xc8, 0x3, 0x9b, 0xa3, 0xcf, 0x7f, 0x29, 0xdc, 0x68, 0x5, 0x31, 0xfa, 0xcf, 0x11, 0x7b, 0xd0, 0xf6, 0xd1, 0xb, 0xe2, 0x95, 0x42, 0x6e, 0x18, 0x16, 0x7a, 0x33, 0xd2, 0x2a, 0x83, 0xb4, 0x16, 0xdd, 0x1b, 0x84, 0x8b, 0x55, 0x8a, 0x94, 0x4b, 0x16, 0x8a, 0x2b, 0xb1, 0x1b, 0xde, 0xc, 0x55, 0xf9, 0xf9, 0xb9, 0x65, 0x74, 0x5b, 0xe, 0x8e, 0x36, 0x7f, 0xcd, 0xc5, 0x70, 0x30, 0x14, 0xb, 0x87, 0xb8, 0x86, 0x13, 0xd5, 0xec, 0x81, 0x36, 0x67, 0x5f, 0xb3, 0xcd, 0xd, 0xbd, 0x20, 0x35, 0xf1, 0xa7, 0x28, 0x44, 0xea, 0xc0, 0xc2, 0x39, 0x4f, 0x2c, 0x45, 0x46, 0x67, 0x4b, 0xda, 0x13, 0x16, 0x33, 0x70, 0xb1, 0xe3, 0xd6, 0x23, 0xff, 0x30, 0x17, 0x80, 0xf0, 0x6d, 0x13, 0x48, 0xe9, 0x9c, 0x13, 0x86, 0x41, 0x1d, 0xd1, 0x52, 0xff, 0x42, 0x55, 0xe8, 0x69, 0xdb, 0x6e, 0x31, 0x87, 0xe7, 0x36, 0xf7, 0x1, 0x5a, 0xb4, 0xb8, 0xd7, 0x2b, 0x45, 0xa2, 0x2b, 0xf, 0x4f, 0x3f, 0x5, 0xff, 0xa7, 0x3, 0xc3, 0xb5, 0x76, 0xb3, 0x76, 0xfe, 0xc2, 0xaa, 0x14, 0x2e, 0x68, 0xbd, 0x1b, 0x52, 0x85, 0xc1, 0x38, 0xaf, 0xee, 0x11, 0x19, 0x87, 0xa1, 0x0, 0xbf, 0x56, 0xda, 0xc6, 0x62, 0x17, 0xc6, 0xcc, 0x3a, 0xa1, 0xf1, 0x5b, 0x49, 0x94, 0x2c, 0x9c, 0x3c, 0x0, 0x74, 0x9e, 0x2c, 0xd7, 0x8a, 0x4, 0x38, 0x44, 0x41, 0x65, 0xe7, 0x2d, 0xae, 0x65, 0xb1, 0xbc, 0xe9, 0x85, 0x32, 0x5e, 0x34, 0x1e, 0x27, 0x36, 0xf1, 0x1e, 0xa5, 0xaf, 0x9c, 0x8d, 0x0, 0xc4, 0xdd, 0x1c, 0x15, 0x23, 0xa0, 0x96, 0x3, 0x37, 0x4a, 0xc3, 0x2a, 0xae, 0xf8, 0x2b, 0xa4, 0x6, 0x2a, 0xc, 0xd9, 0x37, 0x90, 0xc9, 0x95, 0x95, 0xb9, 0xa8, 0x22, 0x5, 0xfb, 0x5f, 0x96, 0x80, 0x98, 0xe2, 0x19, 0x0, 0x2f, 0xb8, 0x4c, 0xd5, 0x87, 0xdd, 0x68, 0xf9, 0xbe, 0x29, 0xb, 0xc4, 0x75, 0x2a, 0x5d, 0x9d, 0xfc, 0x86, 0x4e, 0xa1, 0xbb, 0x67, 0x87, 0x8c, 0x97, 0x14, 0x7c, 0xf5, 0x47, 0xda, 0x95, 0x9e, 0xe3, 0xca, 0x1c, 0x43, 0x3b, 0x72, 0x86, 0x85, 0x27, 0x74, 0x4d, 0x29, 0xbf, 0xcd, 0x2e, 0x32, 0x35, 0x30, 0xa6, 0x54, 0x73, 0x89, 0x97, 0x8b, 0xc2, 0x31, 0x5d, 0x5b, 0x34, 0xbe, 0x36, 0x32, 0xb6, 0x41, 0x42, 0x9c, 0xdf, 0x93, 0x55, 0xc4, 0x8b, 0xe2, 0x3a, 0xd6, 0x59, 0x15, 0x81, 0xc7, 0x6, 0xa0, 0xcd, 0x25, 0x79, 0x30, 0x15, 0xd9, 0xd8, 0x88, 0x87, 0x80, 0x6c, 0x2f, 0xe8, 0x50, 0x4b, 0xe, 0xd1, 0x9e, 0xe7, 0x4b, 0x75, 0x62, 0x70, 0x74, 0xa7, 0x12, 0x4d, 0xc0, 0x1f, 0xd, 0x33, 0x7f, 0x52, 0x4, 0x4b, 0xda, 0x1b, 0xe, 0x5, 0x74, 0x70, 0xed, 0x88, 0x61, 0x26, 0xa8, 0xa8, 0xb4, 0xbe, 0xbe, 0x21, 0xed, 0xc2, 0x1d, 0x6e, 0x3b, 0x9b, 0xdf, 0x88, 0x87, 0x27, 0x77, 0x78, 0x7e, 0xc4, 0x2e, 0x98, 0x13, 0xf7, 0x53, 0xcc, 0x77, 0x6b, 0xfd, 0xe5, 0xc, 0xde, 0xa0, 0x90, 0xe5, 0xf6, 0x94, 0x5f, 0x24, 0x2e, 0xfe, 0xa, 0x77, 0x6d, 0xc4, 0x2d, 0xe1, 0xb4, 0x42, 0xe5, 0x10, 0xab, 0x87, 0xb0, 0x8d, 0x97, 0xa5, 0x63, 0x99, 0xd1, 0x71, 0xbd, 0xe5, 0xf7, 0x46, 0x15, 0x17, 0xf0, 0x4b, 0x9b, 0x50, 0xc3, 0xc4, 0x28, 0x24, 0xc3, 0x1, 0x95, 0x5e, 0xb9, 0x28, 0x77, 0x56, 0xc3, 0xb, 0xab, 0x6b, 0xe7, 0x53, 0x19, 0x89, 0xbf, 0xc5, 0x52, 0x27, 0x2f, 0xaa, 0x23, 0x7b, 0x10, 0x99, 0xc7, 0x8f, 0x8e, 0xf3, 0xf7, 0x81, 0x21, 0xb6, 0x1b, 0xb2, 0x69, 0xc, 0x17, 0x28, 0xdd, 0x3, 0x0, 0xd1, 0x29, 0x94, 0x39, 0xcb, 0x99, 0xd9, 0x6, 0xc3, 0x57, 0x67, 0x21, 0x12, 0xa1, 0xea, 0x35, 0xf8, 0x3e, 0x91, 0x44, 0xf5, 0x1f, 0x92, 0xdc, 0xac, 0xfb, 0x92, 0x85, 0xc7, 0x5c, 0x73, 0xe2, 0x38, 0x14, 0x33, 0xcd, 0xf3, 0x93, 0x27, 0xa8, 0xb2, 0xd1, 0x30, 0xca, 0x2a, 0x73, 0xf5, 0xa7, 0x69, 0xb0, 0xa, 0x85, 0x85, 0x5a, 0xe9, 0x67, 0x8, 0x9a, 0xc9, 0x41, 0xa5, 0xf1, 0xb5, 0x35, 0xea, 0x5b, 0x3c, 0x68, 0xd0, 0x1a, 0xf7, 0x2f, 0x69, 0x2b, 0x70, 0xf, 0x66, 0x4, 0xfb, 0xee, 0x54, 0x51, 0x19, 0x73, 0x26, 0x99, 0x84, 0xfd, 0x17, 0x44, 0x16, 0x9a, 0x33, 0x2, 0x9f, 0xbe, 0x76, 0xa4, 0x36, 0x47, 0xf9, 0xa3, 0x11, 0x90, 0x63, 0x6, 0x5d, 0xcf, 0x34, 0x56, 0xcc, 0x75, 0xf7, 0x4c, 0x5b, 0x9e, 0x17, 0xdb, 0xeb, 0x8c, 0xda, 0xcf, 0x9c, 0xdb, 0x55, 0x3, 0x68, 0x75, 0x9, 0xe4, 0xb5, 0x14, 0xbc, 0x1f, 0x9f, 0x90, 0xb4, 0xe1, 0x7f, 0x16, 0x7c, 0xc4, 0x26, 0xf9, 0x56, 0x60, 0x2f, 0xb4, 0x2c, 0x64, 0x1, 0x33, 0xd7, 0xda, 0xf0, 0x22, 0x7a, 0x48, 0xdc, 0xf2, 0x28, 0x85, 0xf5, 0x8e, 0xa8, 0x7f, 0xeb, 0x44, 0xcc, 0x4e, 0x67, 0x20, 0x91, 0x16, 0xdc, 0x9e, 0x60, 0x8, 0xf2, 0xbc, 0x7a, 0x4, 0x4, 0x5b, 0x9a, 0xe, 0xf3, 0xeb, 0xdd, 0xc3, 0xae, 0xae, 0xb7, 0x76, 0xcf, 0x63, 0xad, 0xc4, 0xde, 0x7f, 0x9, 0x1f, 0xea, 0x13, 0x9e, 0xfc, 0x26, 0x8f, 0xe2, 0x43, 0xf1, 0x90, 0x24, 0x34, 0xee, 0xd5, 0xa8, 0xd4, 0x7f, 0x39, 0x1b, 0xde, 0xb5, 0x2e, 0x4a, 0x49, 0x18, 0xac, 0x40, 0xcb, 0x56, 0xc8, 0xa7, 0x3c, 0xc0, 0xf8, 0x9a, 0x64, 0x3e, 0x61, 0x35, 0x36, 0x1d, 0x9, 0x8d, 0x9e, 0x46, 0x82, 0xd2, 0x52, 0x6f, 0xf2, 0x84, 0x8b, 0x8f, 0xa0, 0xda, 0xa7, 0x95, 0x73, 0xbf, 0x6, 0xfa, 0xd2, 0xd6, 0x13, 0x81, 0xce, 0x7, 0x1b, 0xd8, 0xa7, 0x11, 0x47, 0xb9, 0x16, 0x4e, 0x6f, 0x83, 0x61, 0xa9, 0x4b, 0xfa, 0x34, 0xf1, 0xe5, 0x8c, 0xa8, 0xd4, 0x4a, 0x80, 0x66, 0x29, 0xf8, 0x11, 0x14, 0x80, 0x51, 0xf0, 0xce, 0x62, 0xb, 0x3c, 0x4f, 0xf8, 0xf0, 0x94, 0xc9, 0xef, 0x5e, 0xcd, 0x24, 0xc0, 0xc6, 0x10, 0x90, 0xbf, 0x4c, 0x8c, 0x6c, 0x99, 0x24, 0x75, 0x57, 0x36, 0x1a, 0xe4, 0x22, 0x8e, 0x8a, 0xdd, 0x68, 0x31, 0xbc, 0x67, 0xd6, 0xff, 0x9c, 0x2, 0x47, 0xbd, 0x89, 0x6e, 0x15, 0x2, 0x81, 0x59, 0x8f, 0x10, 0x97, 0x59, 0x49, 0x19, 0x7, 0xb, 0x97, 0x1c, 0x23, 0xf4, 0xed, 0xbf, 0x87, 0x87, 0x1e, 0xa8, 0x8a, 0x15, 0x42, 0x3, 0x2, 0x96, 0x8b, 0x1, 0x66, 0x33, 0x66, 0xda, 0xd4, 0xbe, 0xd, 0xce, 0xa3, 0x75, 0x11, 0x1b, 0xeb, 0xac, 0xc3, 0x33, 0x72, 0x3f, 0x17, 0xc2, 0xf3, 0x6c, 0xac, 0x75, 0xb9, 0xa8, 0x90, 0xf3, 0x4d, 0x4b, 0xf0, 0xbe, 0x5b, 0x94, 0x3b, 0xb3, 0xdc, 0xa5, 0xc8, 0x97, 0xbe, 0x37, 0x73, 0x81, 0x8d, 0x6e, 0x78, 0x4d, 0x73, 0x30, 0x21, 0xaa, 0x7, 0x10, 0x6f, 0x36, 0x9b, 0xca, 0x54, 0x3e, 0xbc, 0x7e, 0x9b, 0xbe, 0xce, 0x36, 0xae, 0x83, 0x35, 0x96, 0x7d, 0xdc, 0xc2, 0x8e, 0xe4, 0x9b, 0x58, 0x69, 0xc1, 0xa2, 0x12, 0xec, 0x3d, 0x4e, 0xc5, 0x21, 0x4a, 0x90, 0xd6, 0x56, 0xbb, 0x87, 0xe6, 0x2f, 0x7b, 0x25, 0xea, 0xbe, 0x97, 0xd0, 0x6, 0x6c, 0x69, 0x96, 0x3c, 0x73, 0x62, 0x8a, 0xea, 0xa3, 0x2a, 0x3f, 0xcf, 0x44, 0x3b, 0x29, 0xef, 0x1e, 0xe3, 0x89, 0x73, 0x6c, 0xbb, 0xdf, 0x99, 0xfc, 0x7e, 0x1b, 0x77, 0xd4, 0xf, 0x65, 0x1a, 0xe3, 0x58, 0x81, 0xd2, 0xff, 0x43, 0xe7, 0xd4, 0xa1, 0x3a, 0x56, 0xe8, 0xdd},
+               output224: []byte{0xa, 0xf7, 0xe1, 0x35, 0x1c, 0x6a, 0x6b, 0x73, 0x59, 0xb5, 0x9e, 0x22, 0xbf, 0x9c, 0x9b, 0xa2, 0x41, 0x10, 0xa2, 0xce, 0xfb, 0x64, 0x7a, 0x79, 0xf, 0xab, 0x41, 0xf1},
+               output256: []byte{0x3f, 0x3d, 0x3a, 0xfa, 0xf6, 0x17, 0x3d, 0xc5, 0xa3, 0x81, 0x1a, 0xdd, 0x40, 0x9f, 0xf2, 0x53, 0x1, 0x2, 0x9c, 0xc0, 0xbc, 0xbd, 0xe4, 0xc7, 0xd, 0x21, 0xec, 0xb5, 0x87, 0x2c, 0x1c, 0x12},
+               output384: []byte{0x1, 0x63, 0xb6, 0xf7, 0x68, 0xa, 0xd7, 0x18, 0xf4, 0xcf, 0xcc, 0x39, 0x75, 0x4, 0x82, 0xcb, 0xb0, 0xcf, 0x6e, 0x93, 0xa8, 0x5e, 0x99, 0x6b, 0x9c, 0xde, 0xa9, 0xf8, 0x40, 0x97, 0xb0, 0x62, 0xd3, 0xb0, 0x1c, 0x66, 0xeb, 0xf8, 0x22, 0xdb, 0x3b, 0x8b, 0xdb, 0x27, 0x9, 0x1b, 0x8, 0x19},
+               output512: []byte{0x91, 0x2e, 0x6a, 0xe7, 0x27, 0x8f, 0xeb, 0x20, 0x3c, 0x33, 0xd4, 0x4d, 0x7a, 0xc3, 0x1a, 0x4c, 0x3e, 0x87, 0xf1, 0x3c, 0x2, 0xdb, 0x14, 0x97, 0x7d, 0x2c, 0xbf, 0x8e, 0xdf, 0x3, 0x3c, 0xf4, 0x9e, 0xb3, 0x8e, 0x67, 0xb9, 0x1, 0x9c, 0xb0, 0xb4, 0xc1, 0x6b, 0x7b, 0xd4, 0xa6, 0xce, 0x8a, 0x9, 0x8c, 0x68, 0x4a, 0xdd, 0x42, 0x23, 0xa3, 0x6d, 0x6d, 0xea, 0xda, 0x9c, 0x83, 0xa0, 0x4b}},
+       testcase{
+               msg:       []byte{0xd3, 0x39, 0x61, 0x1e, 0x4d, 0x57, 0xf8, 0x58, 0xa0, 0xb7, 0x49, 0x8, 0x8d, 0x12, 0x9c, 0xf1, 0x25, 0x8c, 0x20, 0x35, 0xee, 0x4, 0x9d, 0x5f, 0x47, 0x81, 0x6c, 0xb, 0x82, 0xd6, 0x40, 0x45, 0x8c, 0x8f, 0xfa, 0x13, 0x1a, 0xfd, 0xa4, 0x5b, 0xef, 0x31, 0x5, 0xdd, 0x60, 0x46, 0x9a, 0x70, 0xea, 0xcd, 0x18, 0xee, 0x59, 0x4c, 0xcb, 0xac, 0x48, 0x7d, 0x94, 0x8, 0x5e, 0x95, 0x7f, 0x8a, 0x82, 0x8, 0x6e, 0xcb, 0xdf, 0xca, 0xbb, 0x8a, 0xce, 0xda, 0x51, 0x20, 0xa7, 0xe1, 0x5a, 0x12, 0x57, 0x79, 0x85, 0xde, 0xf9, 0xce, 0xd3, 0x21, 0xa1, 0xc8, 0xd3, 0x50, 0x25, 0x5c, 0xce, 0x7d, 0x33, 0x68, 0x25, 0x48, 0x4c, 0x86, 0xf9, 0xdd, 0x18, 0x23, 0x56, 0x5d, 0x26, 0x24, 0x98, 0x25, 0x16, 0xa6, 0x2, 0x7a, 0x21, 0xfb, 0xa2, 0x70, 0x25, 0x71, 0xcd, 0xc0, 0x5c, 0x51, 0x4f, 0x6b, 0x9a, 0x71, 0x38, 0xab, 0x8a, 0x44, 0x1d, 0x80, 0x5f, 0xd3, 0x7b, 0xda, 0xfe, 0xee, 0xe3, 0x1, 0x59, 0x13, 0xe, 0xe5, 0xf9, 0xc, 0x90, 0xde, 0x3, 0xf, 0x9a, 0x90, 0x4e, 0x6d, 0x2a, 0x3, 0xcd, 0xbb, 0xe2, 0x41, 0xf0, 0x43, 0xf, 0xa8, 0x13, 0xa2, 0x51, 0xd4, 0x46, 0x43, 0xc0, 0x4c, 0x4b, 0xef, 0x5d, 0x7, 0x27, 0x3c, 0x92, 0x37, 0xf7, 0x5, 0x30, 0xc3, 0xc, 0xb2, 0x69, 0xd7, 0xe7, 0xb6, 0xe7, 0xf1, 0x8, 0x31, 0x6, 0x9e, 0xee, 0x54, 0x1d, 0x5e, 0xf9, 0x86, 0xcc, 0xf0, 0xe1, 0xe8, 0x70, 0x56, 0x4f, 0xe5, 0x58, 0xbc, 0x1c, 0x21, 0x9d, 0xd8, 0x70, 0xaf, 0x28, 0x70, 0x32, 0x1a, 0xb6, 0x2d, 0xec, 0x23, 0x11, 0x8b, 0x77, 0xd1, 0x64, 0x18, 0x46, 0x5b, 0x54, 0xef, 0x71, 0xa6, 0x8d, 0xd1, 0x7e, 0x2a, 0xa, 0xd1, 0x6e, 0x31, 0xb6, 0x18, 0x19, 0x15, 0x77, 0xbc, 0xaa, 0x5c, 0x29, 0xc2, 0xf3, 0x6c, 0x2b, 0x56, 0xdc, 0x93, 0x2e, 0xf2, 0xf8, 0xef, 0x64, 0x11, 0x18, 0xfa, 0x3a, 0x78, 0xb6, 0x5b, 0x56, 0x4, 0xe0, 0x91, 0x3a, 0x48, 0x53, 0x9c, 0x4b, 0x26, 0xf0, 0xb5, 0xe7, 0x3f, 0x77, 0xde, 0x1d, 0x6d, 0x86, 0xeb, 0xe0, 0x3, 0x8c, 0x78, 0x83, 0xc2, 0xf6, 0x9c, 0xf, 0xf4, 0x62, 0x90, 0x7d, 0xc3, 0xb8, 0x5c, 0xcb, 0xd8, 0x7b, 0x85, 0xb0, 0x67, 0x81, 0x39, 0x29, 0x7a, 0xa4, 0x78, 0xf0, 0x3a, 0x58, 0x8c, 0x6c, 0xd9, 0xba, 0xcf, 0x2d, 0x5c, 0xb5, 0x54, 0xc, 0x6, 0x6a, 0x5d, 0x52, 0x88, 0x9b, 0xc3, 0x70, 0xa0, 0x8a, 0xce, 0x6, 0x95, 0x3c, 0x23, 0x98, 0xe9, 0x2e, 0x2a, 0x6a, 0xa1, 0x16, 0x16, 0xb4, 0x9, 0x27, 0xc4, 0x22, 0x3, 0x32, 0x6b, 0x38, 0x88, 0xce, 0xcb, 0x70, 0xf7, 0x42, 0x5c, 0x10, 0x38, 0xe5, 0x7d, 0x6d, 0x3b, 0xb1, 0x9b, 0xb6, 0x43, 0x70, 0x4f, 0x83, 0xae, 0x6a, 0x55, 0xfe, 0x8b, 0x32, 0x34, 0xdc, 0x25, 0x17, 0x5d, 0x24, 0x3f, 0xfd, 0x7e, 0x16, 0xbc, 0x5c, 0xb8, 0x4e, 0x85, 0x79, 0xe6, 0x19, 0xcf, 0x69, 0x9b, 0x54, 0xbf, 0x98, 0x89, 0xc, 0x5, 0x63, 0xc4, 0x24, 0x47, 0x7b, 0x5b, 0x18, 0xe5, 0x93, 0x14, 0x99, 0x9f, 0xbc, 0x4c, 0x13, 0xd2, 0x86, 0x6d, 0xbe, 0xdd, 0x98, 0x36, 0xc1, 0x1a, 0x62, 0xc4, 0xe1, 0xe5, 0x19, 0x9b, 0xda, 0x93, 0xd2, 0xc9, 0x4, 0x83, 0xa4, 0xfc, 0x35, 0x90, 0xbf, 0x66, 0x47, 0x2b, 0xb8, 0xb1, 0xf4, 0x99, 0xdb, 0xf9, 0x4a, 0x56, 0xd8, 0xa2, 0xd2, 0x7f, 0x96, 0x7, 0xb0, 0x19, 0x22, 0x8a, 0xcc, 0x75, 0xf8, 0xda, 0x8f, 0x3f, 0x9a, 0x24, 0xea, 0xf, 0xbe, 0xf5, 0x5c, 0xbe, 0x6c, 0x3b, 0x55, 0x50, 0x6a, 0xe4, 0xfe, 0xd8, 0x49, 0x95, 0x43, 0xb0, 0xf0, 0x4b, 0xba, 0x76, 0xf7, 0xf1, 0x64, 0xf3, 0x1d, 0xfc, 0x76, 0x81, 0x5, 0x1e, 0xf0, 0x5b, 0x32, 0x84, 0x69, 0x33, 0xce, 0x4c, 0x12, 0x61, 0x65, 0x9d, 0x6c, 0x41, 0x4b, 0xdf, 0xf5, 0x97, 0xaf, 0x14, 0xd0, 0x1d, 0x73, 0xd4, 0xf3, 0x27, 0xd, 0xb3, 0x9, 0xb8, 0xe8, 0xb6, 0x20, 0x1, 0xea, 0x17, 0xb3, 0x5b, 0xb7, 0xb7, 0xcc, 0x7c, 0xbb, 0xfc, 0xdc, 0x84, 0x6a, 0x3d, 0x19, 0x92, 0x9b, 0x7f, 0xed, 0x56, 0x93, 0x8, 0x9a, 0x3f, 0x81, 0xa4, 0x67, 0xa5, 0x39, 0xbe, 0x1c, 0xeb, 0xcc, 0xeb, 0xfb, 0x5b, 0x38, 0x4c, 0xd0, 0x25, 0xeb, 0x2d, 0xed, 0xf5, 0xc4, 0x39, 0xf, 0x60, 0x7f, 0x7c, 0x9e, 0xe3, 0xef, 0x27, 0x3d, 0x72, 0x70, 0xe5, 0x15, 0xa, 0x24, 0x1a, 0xbe, 0xb9, 0x7b, 0x67, 0x8c, 0xa3, 0x80, 0x8f, 0x31, 0x8d, 0xa5, 0xe3, 0x8f, 0x68, 0x42, 0xa2, 0xa3, 0xc0, 0x9c, 0xdf, 0x25, 0xc8, 0xd0, 0x93, 0xca, 0xee, 0x7c, 0x5a, 0xdb, 0xab, 0x43, 0x6b, 0x8d, 0xa1, 0x5a, 0xe3, 0xfe, 0x3f, 0xb, 0x84, 0xab, 0x2b, 0x43, 0xcf, 0x1c, 0xf9, 0xae, 0x3c, 0xd, 0x44, 0x77, 0x2, 0x82, 0xb6, 0xf1, 0xcc, 0x1c, 0xd7, 0xe8, 0x2d, 0x19, 0x5b, 0xe2, 0xa5, 0xe5, 0xaf, 0x40, 0x73, 0x54, 0x49, 0xf6, 0x94, 0x8c, 0x70, 0x37, 0xf6, 0xe1, 0x73, 0x31, 0x89, 0x98, 0x4b, 0x4d, 0x1d, 0xa1, 0xf0, 0xbb, 0xcb, 0xab, 0x83, 0x73, 0xc3, 0xa9, 0xa3, 0xc0, 0xda, 0xe2, 0x36, 0x76, 0x88, 0x83, 0x63, 0x4e, 0xb4, 0x2e, 0x57, 0x45, 0x25, 0x26, 0x44, 0x3, 0xe9, 0xa, 0x50, 0x3a, 0x7d, 0x89, 0x5, 0x30, 0x83, 0x4b, 0x47, 0x1, 0xad, 0xc1, 0xa9, 0xc6, 0xb9, 0x53, 0x98, 0x1b, 0x95, 0x81, 0x72, 0x1a, 0xe3, 0x7a, 0xb0, 0x1c, 0xfc, 0x2b, 0x95, 0x71, 0xf2, 0xd6, 0x5d, 0x4e, 0x35, 0xf3, 0x38, 0x1f, 0x7f, 0x5, 0xf2, 0xcd, 0xa1, 0x60, 0xed, 0x61, 0x43, 0xe2, 0x5c, 0x6d, 0x9d, 0x2a, 0xd6, 0xdc, 0x9b, 0x3f, 0x69, 0xed, 0x69, 0x3a, 0x32, 0x51, 0x10, 0xf4, 0x91, 0x92, 0xe1, 0x69, 0xab, 0x5e, 0xed, 0x6b, 0xe8, 0x8a, 0x3e, 0xb, 0xe0, 0x3d, 0x1f, 0xa2, 0x9f, 0xc0, 0x2, 0x33, 0x59, 0x79, 0x97, 0x1c, 0x16, 0xf0, 0x96, 0xbd, 0xdc, 0x4d, 0x88, 0xeb, 0x23, 0x0, 0xba, 0x51, 0x4b, 0x16, 0x7d, 0x4a, 0x9d, 0xcb, 0x35, 0x3d, 0x7a, 0xb0, 0xc3, 0xdb, 0x7a, 0xd9, 0x91, 0x41, 0x5d, 0xa3, 0x62, 0x27, 0x5d, 0x32, 0x64, 0x36, 0xd, 0x5, 0x68, 0xbc, 0x5b, 0x60, 0xb5, 0xeb, 0xcd, 0xaa, 0x5b, 0xd6, 0x2e, 0xdb, 0x4, 0xc, 0x65, 0x83, 0xa9, 0xb9, 0x97, 0xd9, 0x83, 0x84, 0x79, 0xa5, 0x8, 0xf7, 0x9e, 0x9a, 0xca, 0xaf, 0xa6, 0x3f, 0x90, 0x66, 0xf, 0xb0, 0xc0, 0xd0, 0xee, 0xca, 0xa7, 0x2b, 0xde, 0x7f, 0xc7, 0xab, 0x4b, 0x77, 0xd2, 0x9c, 0x21, 0xf, 0xe6, 0xae, 0xbc, 0x6a, 0xbe, 0xec, 0x7f, 0x20, 0x1c, 0x8c, 0x64, 0xcb, 0x30, 0x6a, 0xee, 0xd1, 0x11, 0x7, 0x68, 0xb3, 0x36, 0xb, 0x8b, 0x2f, 0x30, 0xf8, 0xd1, 0xd2, 0xc1, 0xee, 0x7b, 0x5d, 0xfc, 0xfd, 0x5d, 0x56, 0x51, 0x5f, 0x3f, 0x61, 0x7d, 0xec, 0x24, 0xf5, 0x6c, 0x4f, 0xbe, 0x66, 0x4, 0x59, 0x7e, 0xda, 0xcb, 0x6a, 0x42, 0xf9, 0x44, 0x7b, 0xac, 0x63, 0xc5, 0x3b, 0x54, 0x1, 0xb, 0x5a, 0xd6, 0xf3, 0xa5, 0xa8, 0xc3, 0x7f, 0x89, 0xcd, 0x34, 0x5d, 0xef, 0x63, 0x14, 0x50, 0xc2, 0xb4, 0x91, 0xe7, 0xad, 0x64, 0x36, 0xf6, 0xf9, 0x23, 0xa0, 0xce, 0xc8, 0x5a, 0x76, 0xfb, 0x4, 0xc0, 0xb5, 0x59, 0xa6, 0x97, 0x22, 0x84, 0x14, 0x59, 0x54, 0xec, 0x82, 0xcf, 0x84, 0xb0, 0x63, 0x7e, 0x4b, 0xa1, 0x1b, 0x3f, 0x8b, 0xd6, 0x8d, 0xc1, 0x25, 0xeb, 0x56, 0x93, 0xa3, 0xed, 0x2c, 0xb3, 0xa6, 0x29, 0x59, 0xcb, 0xf4, 0x1c, 0x94, 0x9, 0xd8, 0x4f, 0x2a, 0xc9, 0x26, 0x4e, 0x99, 0xff, 0x69, 0x54, 0x43, 0xff, 0xe6, 0x89, 0x46, 0x4b, 0x34, 0x9b, 0x29, 0x9a, 0xb2, 0x40, 0xd5, 0x42, 0xb2, 0x9c, 0xed, 0xea, 0x37, 0xf2, 0x22, 0x1b, 0x54, 0x44, 0xb9, 0x26, 0x16, 0x38, 0x6a, 0x2b, 0xc7, 0x44, 0x14, 0x39, 0x5b, 0x97, 0xeb, 0xd3, 0xdf, 0x78, 0xc5, 0x83, 0x23, 0x48, 0x83, 0xaf, 0x5c, 0x79, 0x7, 0xcd, 0x68, 0xba, 0x81, 0xe1, 0x9a, 0xe6, 0x16, 0xb4, 0x95, 0x3, 0x26, 0xe5, 0x26, 0xcd, 0xec, 0x80, 0x44, 0x34, 0x97, 0xb1, 0xbc, 0x42, 0xcb, 0xc4, 0x11, 0x15, 0x73, 0xd3, 0x9e, 0xd2, 0x36, 0x32, 0x3a, 0x8e, 0xab, 0x36, 0xab, 0x7d, 0xd4, 0x5d, 0x65, 0xdb, 0xbb, 0x9f, 0x5f, 0x7d, 0x65, 0x7c, 0xcf, 0x94, 0x4f, 0x0, 0xce, 0xd4, 0xf1, 0x28, 0x17, 0xde, 0x3d, 0x3, 0x19, 0x60, 0xbc, 0x33, 0x4e, 0xd3, 0xf8, 0x64, 0x64, 0x37, 0x37, 0xb2, 0x64, 0x1c, 0x6f, 0x39, 0x2a, 0x4a, 0x60, 0x52, 0x72, 0x52, 0x27, 0x2e, 0x13, 0x34, 0xbc, 0xed, 0x47, 0x63, 0x7d, 0xce, 0x95, 0x29, 0x2a, 0x8e, 0x42, 0x73, 0xcb, 0xa0, 0x3e, 0x17, 0xe1, 0x66, 0x70, 0x22, 0x5c, 0x2e, 0x27, 0x33, 0xd7, 0x85, 0x8e, 0x2c, 0x7d, 0x9d, 0xa6, 0xe1, 0x43, 0x33, 0xf2, 0x91, 0x7c, 0x6d, 0xf9, 0x2f, 0x23, 0x3a, 0xcb, 0x60, 0x55, 0x3b, 0xed, 0xc6, 0x8d, 0xa7, 0xa9, 0x9f, 0x18, 0xc2, 0xd3, 0x85, 0x4f, 0xec, 0x8c, 0x7, 0x6, 0x98, 0xc, 0x5d, 0xda, 0xc1, 0x17, 0x4b, 0xef, 0xad, 0x6a, 0x7d, 0xa0, 0x3d, 0xc1, 0xdf, 0x37, 0x2c, 0xae, 0xd2, 0xb7, 0xb5, 0x62, 0x5e, 0xef, 0xe9, 0x3d, 0x64, 0x19, 0x49, 0x4c, 0x3d, 0xd1, 0x89, 0x1, 0x13, 0xe1, 0x90, 0x71, 0x9a, 0xbc, 0x2b, 0x69, 0x5f, 0x7f, 0x2a, 0xac, 0xcd, 0x37, 0x2e, 0xf7, 0x81, 0x81, 0xc4, 0x28, 0xf1, 0x99, 0x18, 0xbc, 0x2e, 0x2c, 0xc1, 0x6f, 0xd9, 0x7f, 0x1a, 0xef, 0x7e, 0x4f, 0xc3, 0x29, 0x75, 0x78, 0xe0, 0xbe, 0x19, 0xb8, 0xb2, 0xce, 0x6d, 0xdf, 0xa2, 0x0, 0xe5, 0x93, 0x69, 0x2e, 0xfa, 0x8b, 0x11, 0xfb, 0x5a, 0x55, 0x91, 0x93, 0x93, 0xb9, 0x8a, 0x2f, 0xe3, 0x1b, 0xf7, 0xb8, 0x7, 0x1, 0xb6, 0x74, 0x30, 0xf1, 0xb3, 0x39, 0x11, 0xaf, 0x41, 0x50, 0x4b, 0x2c, 0x3c, 0xd0, 0x0, 0xe3, 0xea, 0xe1, 0x48, 0x1, 0x4c, 0x45, 0x1d, 0x16, 0x6c, 0x47, 0xb6, 0xfe, 0x82, 0x66, 0xf4, 0x4e, 0x62, 0xed, 0x75, 0x15, 0xc6, 0xf3, 0x5, 0x11, 0x74, 0x31, 0x43, 0x48, 0x59, 0x82, 0xc3, 0x24, 0x53, 0x32, 0xfe, 0x19, 0x89, 0xf, 0xc8, 0xe7, 0xdb, 0x99, 0x79, 0x1a, 0x36, 0xe7, 0x7a, 0xbf, 0xaf, 0xbd, 0xb, 0x65, 0xcd, 0xd8, 0x61, 0xee, 0xff, 0x1f, 0x29, 0xe1, 0x42, 0xdf, 0x90, 0x3e, 0x72, 0x3b, 0x2e, 0xc3, 0xb4, 0xa4, 0xff, 0xf8, 0xc5, 0xb4, 0xf3, 0xf4, 0x37, 0x7e, 0x38, 0x37, 0xcf, 0x13, 0x4d, 0x74, 0x2d, 0x46, 0xef, 0x14, 0x8c, 0x98, 0x6d, 0xd1, 0x61, 0xa9, 0x39, 0x48, 0x2f, 0xdf, 0x40, 0xd4, 0xbb, 0x4a, 0x42, 0x31, 0xb7, 0xd5, 0x64, 0x8e, 0x2d, 0xbd, 0x8a, 0x9d, 0x85, 0x16, 0xc6, 0xbd, 0xa0, 0xa3, 0x70, 0xfa, 0x53, 0x62, 0xd, 0x52, 0x55, 0x34, 0x18, 0x30, 0xb8, 0x4c, 0x75, 0x1e, 0x31, 0xb8, 0xe1, 0x7f, 0x3f, 0xce, 0x2, 0x79, 0x6, 0xaf, 0xcc, 0x2a, 0xe7, 0xe5, 0xe1, 0x4, 0xa1, 0x10, 0x9e, 0x86, 0xfb, 0x20, 0x89, 0x7e, 0x31, 0x9, 0xd0, 0x7e, 0x70, 0xc, 0x13, 0xe6, 0xff, 0xa7, 0x1, 0x6e, 0xad, 0x35, 0x96, 0x92, 0x45, 0xa1, 0x6b, 0xe0, 0x32, 0xca, 0xda, 0xf, 0x23, 0x27, 0x84, 0x4d, 0xfb, 0x3b, 0x45, 0xd9, 0xb3, 0xe9, 0xe3, 0x9, 0xa9, 0x8d, 0xd9, 0x27, 0xc5, 0xe7, 0x5a, 0xed, 0x32, 0x70, 0x71, 0x40, 0x41, 0xe3, 0x5a, 0x70, 0x3c, 0x3e, 0xa7, 0xc1, 0x3, 0x48, 0xfe, 0x52, 0x1c, 0xfc, 0xdf, 0xb7, 0xc0, 0x2e, 0xa9, 0xe1, 0x23, 0xb2, 0x67, 0xc2, 0x2f, 0x9, 0x1a, 0x4b, 0x98, 0x47, 0x33, 0x30, 0xe9, 0x3a, 0x36, 0x2c, 0x35, 0x8f, 0x92, 0x51, 0x9f, 0x9f, 0x42, 0xb0, 0xe6, 0xd2, 0xaa, 0xfa, 0x5, 0x38, 0xec, 0x32, 0xaf, 0x4a, 0x52, 0x35, 0x8e, 0xfe, 0x45, 0xb5, 0x9a, 0x9a, 0xc0, 0x5c, 0xf4, 0xd6, 0xd8, 0x2a, 0xf2, 0xb8, 0x8b, 0xbf, 0x32, 0x7d, 0x3e, 0xe6, 0x1a, 0x4f, 0x34, 0x11, 0x78, 0xba, 0xd4, 0xb2, 0x28, 0xca, 0x86, 0xd9, 0xce, 0xff, 0xb4, 0x59, 0xc6, 0x4e, 0xf1, 0x2e, 0x5c, 0x53, 0x39, 0x47, 0x10, 0x54, 0xfe, 0x9, 0xde, 0x9, 0x33, 0x59, 0x5c, 0x2b, 0x1a, 0x5c, 0xd9, 0x85, 0x81, 0x67, 0x5d, 0xfa, 0xb, 0x9c, 0x4, 0xdb, 0x65, 0xdd, 0xcf, 0x45, 0x2c, 0x49, 0xd7, 0x20, 0xc0, 0x87, 0x6b, 0xe8, 0x8e, 0x9d, 0x72, 0x32, 0x73, 0x78, 0x65, 0xc5, 0x98, 0xa5, 0xd2, 0x8, 0x62, 0xd7, 0x49, 0xd3, 0x80, 0x7a, 0x7f, 0x5, 0x2f, 0x4f, 0xc0, 0xe0, 0x96, 0x1f, 0xf3, 0x14, 0xdf, 0x69, 0x82, 0x9b, 0x3a, 0x30, 0x85, 0x14, 0x8a, 0x81, 0x8b, 0xf, 0x53, 0x84, 0xb, 0x92, 0xeb, 0xba, 0x2, 0x66, 0xa4, 0x27, 0x19, 0xd4, 0x99, 0x2, 0x77, 0x5b, 0x72, 0xd1, 0x51, 0x62, 0xb1, 0x64, 0x3f, 0x80, 0x99, 0x33, 0x93, 0xa9, 0x28, 0xa, 0x99, 0xe7, 0x2a, 0xca, 0x1f, 0xc8, 0xb2, 0xf8, 0x45, 0x4e, 0x56, 0x6b, 0xc7, 0x9c, 0xd9, 0x7, 0x5f, 0xe0, 0x91, 0xf5, 0xed, 0xb4, 0xeb, 0xd, 0xa5, 0xe0, 0xdc, 0x5c, 0x4e, 0xd8, 0x5a, 0x8f, 0xc3, 0x99, 0x73, 0x89, 0xd2, 0x35, 0xcb, 0x54, 0x36, 0xe9, 0xa8, 0xae, 0xd1, 0xd4, 0x60, 0x45, 0x75, 0x83, 0x4c, 0x1e, 0xb2, 0xfc, 0xf1, 0x37, 0x8e, 0x46, 0x5f, 0x77, 0xcf, 0x3, 0x75, 0x3, 0x63, 0x94, 0x82, 0xa2, 0x85, 0xa9, 0xd0, 0xb4, 0x76, 0xcb, 0x9d, 0xdf, 0xfc, 0xb, 0x82, 0xe6, 0x4b, 0xbd, 0x17, 0x55, 0x38, 0xc2, 0x64, 0x73, 0x82, 0xd2, 0xd7, 0x58, 0x72, 0x25, 0xc8, 0x45, 0xd8, 0xc1, 0x4f, 0x38, 0x74, 0xc1, 0x45, 0x62, 0x5, 0x7, 0x1c, 0xc, 0xb, 0x39, 0x65, 0xfe, 0x30, 0xe9, 0xce, 0x3b, 0x61, 0x6e, 0x4d, 0xe7, 0x8b, 0x39, 0x53, 0xa9, 0xec, 0x52, 0x5e, 0x43, 0xce, 0xea, 0xcc, 0xc, 0x30, 0x3c, 0x64, 0x0, 0xcb, 0x4d, 0x52, 0xfd, 0xfd, 0x14, 0x23, 0x76, 0x7, 0x5d, 0x26, 0xac, 0x11, 0x23, 0xec, 0x4c, 0xfb, 0xf8, 0x2e, 0x77, 0xcb, 0x4, 0xef, 0xc0, 0x9c, 0xc9, 0x56, 0x1, 0xb1, 0x46, 0x81, 0xc9, 0xa, 0x7b, 0x8, 0x40, 0xef, 0xc8, 0x19, 0x61, 0x3a, 0xa0, 0x6f, 0xaf, 0xe2, 0xda, 0xb4, 0xb0, 0x36, 0x95, 0x1f, 0x82, 0x57, 0x9a, 0x2, 0xef, 0xef, 0xd0, 0x8d, 0xf0, 0xee, 0xef, 0xd2, 0x14, 0x60, 0x80, 0x73, 0x49, 0x61, 0x72, 0x5b, 0x6e, 0x91, 0x77, 0x39, 0xfb, 0x80, 0xde, 0xb9, 0xb8, 0xbb, 0x6d, 0xce, 0x39, 0xe2, 0x3, 0x72, 0xcc, 0xc0, 0x79, 0xad, 0xd9, 0x3, 0x7, 0x99, 0x6, 0x1e, 0xf1, 0xf0, 0x11, 0x69, 0x94, 0x45, 0x57, 0xe, 0xf0, 0xcb, 0x96, 0x34, 0x83, 0x9, 0x9e, 0xb1, 0x7f, 0x22, 0x22, 0x66, 0x98, 0xde, 0xb1, 0x10, 0x49, 0x5c, 0x15, 0x9e, 0xb6, 0x3d, 0xa7, 0x50, 0xd2, 0x31, 0xe7, 0x8c, 0x4a, 0x7c, 0x73, 0x49, 0x41, 0xe4, 0x43, 0xaf, 0x7f, 0x2b, 0x5a, 0x3a, 0x6, 0xcc, 0x53, 0x34, 0xef, 0x76, 0x74, 0x3f, 0xcb, 0xe8, 0xed, 0xd3, 0x93, 0x9a, 0xbd, 0x48, 0xce, 0x32, 0xa0, 0x3d, 0xd5, 0x9d, 0x25, 0x53, 0xba, 0x40, 0x8b, 0x44, 0x4d, 0x95, 0x99, 0xc2, 0x35, 0x84, 0x43, 0x29, 0x4c, 0x40, 0x6d, 0x3, 0xd8, 0x6a, 0x23, 0xf8, 0x72, 0x99, 0x2a, 0x1c, 0x45, 0x50, 0x27, 0xaa, 0x4d, 0x7e, 0xa3, 0x5a, 0xfc, 0xe3, 0x5a, 0xf0, 0xa4, 0xa, 0x8b, 0x58, 0xce, 0x2c, 0x14, 0x9c, 0x0, 0xed, 0x49, 0xdd, 0xfb, 0xf0, 0x1f, 0x1e, 0xfb, 0xad, 0x3d, 0xb5, 0x9d, 0x22, 0x14, 0xb7, 0x95, 0xc7, 0xf7, 0x82, 0x29, 0x88, 0x9d, 0xa7, 0x7c, 0x4a, 0x4f, 0xaa, 0xb9, 0x44, 0xeb, 0xb0, 0x33, 0xa0, 0x45, 0x15, 0x6a, 0xae, 0xb5, 0xb4, 0x57, 0xba, 0x7f, 0xe0, 0xa9, 0x70, 0xfa, 0xc1, 0x95, 0xef, 0x5d, 0x20, 0x6e, 0x28, 0xff, 0x91, 0x51, 0x31, 0xc, 0xc9, 0x19, 0x37, 0xfc, 0x33, 0xe6, 0x1a, 0x50, 0x75, 0x5a, 0xb1, 0xc1, 0x9, 0xe4, 0xdd, 0x87, 0xdc, 0x51, 0x19, 0x64, 0xf9, 0x70, 0x78, 0x4b, 0xc3, 0x1, 0x9a, 0xfc, 0xf0, 0x15, 0xc6, 0xeb, 0xad, 0xd5, 0xc4, 0xc3, 0x22, 0x56, 0x31, 0x1e, 0x89, 0x96, 0xfa, 0xb7, 0xdc, 0x39, 0x45, 0xcd, 0x87, 0xd5, 0x5f, 0xc9, 0xc8, 0x51, 0xe8, 0x63, 0xda, 0xd3, 0x71, 0xd6, 0xe9, 0xd6, 0x91, 0x57, 0xc5, 0x4, 0xb, 0xd7, 0x2, 0xf8, 0x28, 0xc0, 0x88, 0xc5, 0xa8, 0xe4, 0xe3, 0x5e, 0xd1, 0x9e, 0x87, 0x31, 0xeb, 0x9a, 0xdd, 0xc7, 0xd3, 0x1e, 0xde, 0xb9, 0x5e, 0x2f, 0xa5, 0x7e, 0xc5, 0x14, 0xd9, 0x7f, 0xe5, 0x91, 0x42, 0x64, 0xdd, 0x0, 0x16, 0xbb, 0x43, 0xf, 0xdd, 0x7d, 0xcd, 0x5a, 0x16, 0x17, 0x32, 0x80, 0x29, 0x63, 0xbe, 0xc1, 0x54, 0x9e, 0x5c, 0xd5, 0x15, 0x1c, 0xe9, 0xc8, 0xbd, 0x46, 0xb2, 0x6f, 0x44, 0x1c, 0xb6, 0x8b, 0xbc, 0x9d, 0xcc, 0x8, 0xc1, 0x39, 0xdd, 0x9a, 0xda, 0xc1, 0xa1, 0x58, 0xb5, 0xf9, 0xe5, 0x4d, 0x2c, 0x20, 0xf0, 0x1a, 0xe6, 0x6b, 0xe7, 0x88, 0xc1, 0x0, 0x67, 0xc6, 0xe, 0x8, 0x8f, 0xdc, 0xf8, 0x28, 0xf7, 0xbe, 0x90, 0x8d, 0x86, 0x36, 0x4, 0xe1, 0x9f, 0x31, 0x83, 0x89, 0xe5, 0xac, 0x14, 0x82, 0x37, 0xe1, 0x1b, 0xe7, 0x11, 0xff, 0x43, 0x28, 0x69, 0xc5, 0xa9, 0x8, 0x2e, 0x5f, 0xd9, 0xfd, 0x24, 0xc3, 0x9e, 0x57, 0x86, 0x3d, 0x63, 0xbd, 0x85, 0xd5, 0xb7, 0x8c, 0x63, 0x29, 0xc6, 0x64, 0x9f, 0x56, 0x23, 0x24, 0x39, 0x8c, 0x21, 0xce, 0xca, 0x17, 0xcc, 0x78, 0x75, 0xa, 0xe9, 0xad, 0xab, 0x61, 0x2c, 0xa3, 0xbd, 0xa, 0xb6, 0xff, 0xaa, 0x9f, 0x23, 0x6, 0x37, 0x92, 0x7d, 0xa9, 0xde, 0xc3, 0x7, 0x7a, 0xb6, 0xf4, 0x25, 0xd2, 0x1e, 0xe9, 0x71, 0xa0, 0x74, 0x47, 0x32, 0xf3, 0x9e, 0xd8, 0x2f, 0x6b, 0x6, 0xf1, 0xe8, 0x4c, 0xd7, 0x77, 0xf1, 0x91, 0xa, 0x92, 0x90, 0xa6, 0x6c, 0x77, 0x26, 0x4e, 0x48, 0x46, 0x93, 0x10, 0x8d, 0x97, 0x3a, 0x25, 0x90, 0x8a, 0x97, 0x1, 0xc4, 0x14, 0x92, 0xc, 0xb0, 0xe3, 0xb8, 0x2a, 0x74, 0xd1, 0xea, 0x83, 0x4, 0xe8, 0x59, 0x4c, 0x77, 0x72, 0x90, 0xcd, 0x32, 0x86, 0x47, 0x38, 0xc6, 0x57, 0xbd, 0xbb, 0xd5, 0x7e, 0xdf, 0x42, 0xec, 0x9a, 0x2f, 0x52, 0x2c, 0xe9, 0x11, 0xc1, 0x37, 0x82, 0x75, 0xad, 0x43, 0x88, 0x9c, 0xc2, 0x6e, 0x9a, 0x38, 0x18, 0x98, 0x7f, 0xf0, 0x67, 0x1a, 0x7a, 0x94, 0x57, 0x3c, 0x1, 0x3e, 0xee, 0xbd, 0xfc, 0xfa, 0xb5, 0xd9, 0xbb, 0x40, 0x5d, 0x5, 0xb6, 0x6e, 0xb6, 0x41, 0xc9, 0x76, 0xa4, 0x23, 0x31, 0x69, 0xa4, 0x63, 0x38, 0x89, 0x54, 0x67, 0xf3, 0x6f, 0x9f, 0xe7, 0xfc, 0x1c, 0xb3, 0xea, 0xb8, 0x30, 0xf4, 0x6f, 0x26, 0x12, 0x52, 0xaa, 0xc0, 0x49, 0x2c, 0x6, 0x99, 0x44, 0x33, 0x3, 0x94, 0x95, 0x30, 0x68, 0x75, 0x33, 0xcd, 0x9, 0xcb, 0xff, 0x9, 0xdc, 0xc8, 0xf1, 0x2a, 0x49, 0xe8, 0x92, 0xa4, 0x7a, 0xb0, 0xa2, 0xbf, 0xfe, 0x1b, 0x7a, 0x49, 0x3b, 0xfd, 0x66, 0xd9, 0xe4, 0x82, 0x25, 0x98, 0x78, 0x1b, 0xb8, 0xa9, 0x4a, 0x4d, 0x7d, 0x63, 0xd7, 0x7c, 0x8f, 0x1b, 0x41, 0x12, 0xf8, 0x9c, 0xa2, 0x15, 0xde, 0xcb, 0x61, 0xf, 0x13, 0x39, 0x18, 0x4f, 0x8c, 0xf6, 0x6b, 0xb5, 0x91, 0x69, 0x55, 0x30, 0x13, 0x27, 0x64, 0x72, 0xbb, 0xf7, 0x75, 0x3a, 0x7e, 0xab, 0x4, 0x6f, 0x55, 0xe7, 0x20, 0xc0, 0xb2, 0x35, 0x40, 0x77, 0x48, 0xb8, 0xcf, 0xa0, 0x7e, 0x74, 0x88, 0x8, 0x87, 0x5a, 0x89, 0x66, 0x61, 0xa5, 0x4d, 0xde, 0x93, 0x9e, 0xd, 0x64, 0xcb, 0x30, 0x31, 0xa4, 0xd4, 0x8d, 0x56, 0x5e, 0x24, 0xa5, 0x6a, 0xe1, 0x17, 0xec, 0xfe, 0xb2, 0x79, 0x28, 0xe4, 0x2c, 0x6, 0x61, 0x4b, 0x43, 0x27, 0xb9, 0x26, 0x1b, 0xe4, 0xab, 0x24, 0x16, 0x9b, 0x26, 0xf9, 0xa7, 0xa4, 0x63, 0xa4, 0x2f, 0xa, 0xda, 0x30, 0x53, 0x59, 0x31, 0x4e, 0x7d, 0x48, 0x99, 0x3e, 0xbf, 0xe4, 0x6f, 0xed, 0x1e, 0xf6, 0xf6, 0x5f, 0x73, 0x34, 0x83, 0xb8, 0x83, 0xb7, 0x2d, 0xee, 0xfd, 0x5a, 0xe8, 0x3, 0xa0, 0xcb, 0xce, 0x91, 0xe5, 0x16, 0x10, 0x90, 0xda, 0x18, 0x8c, 0x47, 0x5b, 0x38, 0x37, 0x9f, 0xa2, 0xcb, 0x19, 0x1d, 0xc, 0x17, 0x2e, 0x96, 0x63, 0x76, 0xfc, 0x8c, 0x7a, 0x5e, 0xf4, 0x26, 0x39, 0x49, 0xd7, 0x5a, 0x95, 0x5e, 0xe9, 0x4e, 0x3, 0x91, 0xe7, 0xc, 0xe0, 0x4c, 0x61, 0xd3, 0xf4, 0xf4, 0x9c, 0xc5, 0xf1, 0x77, 0x45, 0x15, 0xf0, 0x1b, 0xa6, 0xcf, 0x83, 0xbe, 0xa9, 0xbd, 0xfb, 0x7f, 0x15, 0x8f, 0x6c, 0xed, 0x3b, 0xc3, 0x3b, 0xef, 0xfa, 0xcb, 0x80, 0xba, 0x37, 0x67, 0xe4, 0x76, 0xf3, 0x18, 0xc, 0x39, 0x2f, 0x17, 0xde, 0x1f, 0x72, 0x71, 0x94, 0x66, 0xb4, 0xe8, 0x14, 0xd7, 0x57, 0xc, 0x9b, 0x8, 0xeb, 0x3f, 0x5, 0x3d, 0x72, 0x8e, 0x5e, 0xfa, 0x2c, 0x28, 0xae, 0xb4, 0xfa, 0x55, 0x7a, 0x2c, 0x80, 0x9e, 0x35, 0x7f, 0x9c, 0xca, 0xb2, 0x1f, 0x4e, 0x9f, 0xc3, 0x29, 0x1c, 0xee, 0x7c, 0xcd, 0xe2, 0xed, 0xf7, 0xb0, 0x86, 0xf8, 0x44, 0xb5, 0x31, 0xc6, 0xd6, 0xd5, 0x74, 0x4a, 0xb2, 0xc3, 0xfa, 0x27, 0x95, 0xa7, 0xc2, 0xb2, 0x6a, 0x3f, 0xde, 0x44, 0xac, 0x46, 0x73, 0x89, 0x72, 0xd3, 0x74, 0xe5, 0x34, 0xd1, 0x97, 0x23, 0x22, 0xd4, 0xdc, 0x8b, 0x34, 0x9f, 0xdd, 0x5d, 0x3a, 0xee, 0x82, 0x7b, 0xc4, 0xde, 0x6d, 0xed, 0x71, 0x5b, 0x87, 0xf1, 0xa2, 0x6f, 0xe0, 0x9f, 0xa1, 0x2a, 0x49, 0x59, 0x19, 0x99, 0x7e, 0x7, 0xe7, 0x5e, 0x26, 0x88, 0x99, 0xd5, 0x99, 0xbe, 0xf, 0xc6, 0x99, 0x43, 0x36, 0x19, 0xd7, 0x3c, 0x63, 0xb3, 0x4a, 0x37, 0x7f, 0x6c, 0xd5, 0x11, 0xd0, 0x95, 0xda, 0x8e, 0xd2, 0x9a, 0x9f, 0xa8, 0x69, 0x44, 0xb3, 0x79, 0x5b, 0xb6, 0x9f, 0xb8, 0xf5, 0x1f, 0xbc, 0x34, 0xd0, 0x78, 0x9, 0xde, 0xc6, 0xfc, 0x64, 0x6b, 0xa6, 0x3b, 0xa4, 0x83, 0x22, 0x71, 0x7a, 0x1e, 0xe0, 0x1e, 0xc9, 0xb1, 0xca, 0xdc, 0xe5, 0x56, 0xb0, 0x7e, 0x94, 0x3f, 0x61, 0x9a, 0x7, 0x3f, 0xae, 0xc0, 0x3, 0xec, 0xfa, 0x65, 0x7d, 0x7c, 0x0, 0x86, 0x63, 0x1f, 0x41, 0x90, 0x9b, 0xfd, 0xda, 0xae, 0x9, 0x5, 0x49, 0x48, 0x93, 0x42, 0x25, 0xa3},
+               output224: []byte{0xd6, 0x20, 0x41, 0x96, 0x40, 0x8a, 0xf4, 0xc7, 0x39, 0x1, 0xe8, 0xf2, 0xcb, 0xd, 0xa, 0xd2, 0x81, 0xfd, 0x60, 0x71, 0x30, 0x1c, 0x6b, 0x70, 0x46, 0xd8, 0x24, 0x7e},
+               output256: []byte{0xa6, 0x3, 0x77, 0xb7, 0xdc, 0xb5, 0xe0, 0x23, 0x32, 0x85, 0xfd, 0xa3, 0xa5, 0x4e, 0x5b, 0x91, 0x11, 0x93, 0x80, 0xa8, 0x25, 0x1a, 0xf2, 0xf4, 0xc2, 0x16, 0xda, 0x33, 0x63, 0x75, 0x4e, 0x11},
+               output384: []byte{0xed, 0x58, 0xeb, 0x86, 0xd5, 0x95, 0x70, 0x54, 0x7f, 0xef, 0x42, 0xbb, 0xe2, 0x46, 0x92, 0xd0, 0x67, 0x9d, 0xa7, 0x64, 0x11, 0x5d, 0xf8, 0x98, 0x74, 0xf3, 0x7f, 0xf0, 0xe0, 0xd4, 0x7b, 0xed, 0x71, 0x82, 0x56, 0xe0, 0x92, 0x6c, 0x85, 0xd0, 0x62, 0xed, 0x73, 0x50, 0x47, 0x4c, 0xb8, 0xf1},
+               output512: []byte{0xee, 0xf3, 0x1f, 0x98, 0x11, 0xd7, 0x80, 0xb1, 0xa6, 0xf0, 0xed, 0xfc, 0x47, 0x63, 0x52, 0x80, 0x1e, 0x90, 0x84, 0xfc, 0xa3, 0xec, 0x4b, 0xb2, 0xbe, 0xf8, 0x22, 0xdf, 0xd, 0x95, 0x80, 0xa6, 0x98, 0xd3, 0x6c, 0x57, 0xd9, 0xd2, 0xd6, 0x66, 0x6d, 0x8b, 0xfc, 0xa, 0xae, 0x48, 0x59, 0x31, 0x59, 0x8, 0xd7, 0x55, 0xf6, 0x16, 0x7f, 0xd8, 0x6d, 0x46, 0x4d, 0xb0, 0xbd, 0x84, 0x87, 0x2f}},
+       testcase{
+               msg:       []byte{0x93, 0xb7, 0x16, 0x1e, 0x99, 0xfd, 0xee, 0x38, 0x71, 0x33, 0x76, 0xa6, 0x9f, 0xc4, 0xbc, 0xcc, 0x66, 0xc0, 0x92, 0xcf, 0x4a, 0xc5, 0xb7, 0x1c, 0x35, 0x0, 0x89, 0x25, 0x3c, 0xd1, 0x7e, 0x7d, 0xb2, 0x8a, 0x41, 0x49, 0xa, 0x35, 0x42, 0x21, 0x1, 0x79, 0x95, 0xab, 0xba, 0xec, 0xb6, 0x7a, 0x2a, 0x98, 0x9d, 0x81, 0x98, 0x4f, 0x34, 0xd0, 0x21, 0xff, 0xf3, 0x64, 0xe8, 0xd1, 0x8f, 0xa5, 0x8e, 0xf3, 0xdf, 0x9, 0x7, 0x26, 0xde, 0x78, 0x20, 0xf5, 0x98, 0xde, 0x62, 0x5f, 0x90, 0xf1, 0x0, 0x7, 0xf6, 0x2c, 0x9, 0xf3, 0xe7, 0x9e, 0xb2, 0x1e, 0x84, 0x7d, 0x28, 0xa8, 0x86, 0x9e, 0xb2, 0x17, 0x30, 0xc, 0xb4, 0x1, 0x4a, 0xa8, 0x3d, 0x7d, 0x7a, 0xc6, 0xdb, 0xb9, 0xac, 0xb1, 0xe1, 0x9a, 0x2b, 0xc7, 0x62, 0x91, 0x52, 0x7c, 0x57, 0x1e, 0xf5, 0x93, 0xb5, 0x9, 0xaa, 0xb4, 0x54, 0xf2, 0xb, 0xdc, 0xa4, 0xab, 0xcd, 0x33, 0x7b, 0x50, 0x87, 0xba, 0x30, 0xbf, 0x4a, 0x87, 0xa9, 0x36, 0xf4, 0x0, 0xa1, 0x3d, 0x4c, 0x45, 0x5e, 0x60, 0x14, 0x65, 0x96, 0x57, 0x7c, 0x30, 0x9f, 0xf2, 0x5c, 0x22, 0x48, 0x9d, 0x3d, 0x51, 0xa4, 0xbf, 0x1c, 0xea, 0xc5, 0xb8, 0xe2, 0xa, 0x70, 0xc5, 0x41, 0x92, 0x2b, 0x78, 0xee, 0xd7, 0xf2, 0xc3, 0xc2, 0xde, 0x68, 0x9, 0xd4, 0x74, 0x23, 0x7f, 0xf6, 0xb9, 0x22, 0x1b, 0x6a, 0x20, 0xcc, 0x70, 0x46, 0xbd, 0x7a, 0x29, 0x2a, 0x4a, 0x7e, 0x1a, 0xdb, 0x16, 0xb2, 0x1d, 0xa6, 0x81, 0x24, 0x22, 0xf0, 0xa2, 0x93, 0x24, 0x94, 0xda, 0xd, 0xa8, 0xea, 0xfc, 0x50, 0x26, 0xe, 0xdc, 0xe6, 0x1d, 0x50, 0x6f, 0xf, 0x9d, 0xec, 0xe6, 0x24, 0xe9, 0xb5, 0xc6, 0xec, 0x55, 0x59, 0x63, 0xd5, 0xf6, 0x5b, 0xf5, 0xf9, 0x78, 0xe4, 0x41, 0x95, 0x5b, 0x2, 0x76, 0xf1, 0x56, 0x20, 0x2c, 0x67, 0xab, 0xab, 0x3e, 0xa7, 0x90, 0x13, 0x42, 0x8d, 0xdf, 0xd8, 0x80, 0xd8, 0x61, 0xdf, 0x4e, 0x7a, 0x1b, 0xff, 0xce, 0xe6, 0x19, 0xd0, 0x4c, 0x8, 0x63, 0xb2, 0xd6, 0x75, 0xde, 0x97, 0x64, 0x2b, 0x44, 0xfe, 0x71, 0x14, 0xc8, 0x45, 0xb5, 0x1e, 0x57, 0x30, 0x6b, 0x2d, 0x0, 0x72, 0xda, 0xda, 0x86, 0x73, 0xc0, 0xc0, 0x56, 0xec, 0xaf, 0x4b, 0x48, 0x66, 0x53, 0xa6, 0xdc, 0xc0, 0xf, 0x33, 0x7f, 0x1a, 0xca, 0xb6, 0xb9, 0xb2, 0xd6, 0x65, 0xb1, 0xa5, 0xbf, 0xee, 0x45, 0xa7, 0x54, 0x71, 0x1d, 0x45, 0xc9, 0xac, 0x63, 0x36, 0x6c, 0x15, 0x14, 0x3f, 0x89, 0xa5, 0xd3, 0x2d, 0xe0, 0x3c, 0x24, 0x4c, 0xcf, 0x83, 0x1c, 0x95, 0xa9, 0x7d, 0x44, 0xc2, 0xba, 0xef, 0x5c, 0x90, 0xd8, 0x75, 0x2e, 0x2c, 0xac, 0xcc, 0x11, 0x31, 0x6e, 0x1b, 0x78, 0xe0, 0xf1, 0xc4, 0xb5, 0xb0, 0xa4, 0x38, 0x71, 0xc7, 0x84, 0xcf, 0x5d, 0x97, 0x70, 0x58, 0xef, 0x4c, 0xca, 0x6, 0x17, 0x2d, 0x60, 0x81, 0x99, 0x69, 0x63, 0xf3, 0xda, 0x12, 0x70, 0x76, 0x49, 0x33, 0x22, 0xd9, 0xbf, 0x39, 0x58, 0xf, 0x9, 0x6a, 0x44, 0x16, 0x9c, 0x9a, 0x93, 0xdd, 0x7c, 0x84, 0xa6, 0xaa, 0xf1, 0x5, 0x27, 0xd, 0xb3, 0x87, 0x99, 0xc, 0xa1, 0xbe, 0x0, 0x94, 0xbb, 0x28, 0xad, 0x74, 0x1d, 0xcb, 0x42, 0x95, 0xb1, 0x6a, 0xf1, 0x8c, 0x97, 0xe1, 0x5a, 0x61, 0xae, 0xc1, 0x2e, 0x10, 0x8d, 0x61, 0xd5, 0xf2, 0x72, 0x15, 0xdc, 0x24, 0xdf, 0xa8, 0xb0, 0x9c, 0xe5, 0xe3, 0x5f, 0x61, 0xb2, 0x30, 0x96, 0x17, 0x27, 0xed, 0xdb, 0xb9, 0x7, 0xf6, 0x9e, 0xa3, 0x98, 0x8e, 0xa9, 0x5f, 0x73, 0x29, 0x9e, 0x4f, 0x3c, 0xba, 0xb4, 0xa6, 0x50, 0x6f, 0xb, 0x4e, 0x8, 0x3e, 0xda, 0x4a, 0x24, 0xa7, 0xc3, 0x9, 0xd4, 0x78, 0x5a, 0xa1, 0xf2, 0xb1, 0xd6, 0x3b, 0xb, 0x2, 0x1e, 0x3d, 0x72, 0x27, 0xaf, 0xbb, 0x66, 0x62, 0xc3, 0xe6, 0x15, 0x86, 0xcb, 0xe8, 0xac, 0xa2, 0x27, 0xc6, 0x1b, 0xd3, 0x4e, 0xf7, 0xb7, 0x34, 0x6f, 0x1e, 0x99, 0xda, 0x95, 0x88, 0xde, 0xb4, 0x9b, 0xba, 0x8a, 0x83, 0x9a, 0x7d, 0x4c, 0xfb, 0xa9, 0xcf, 0x43, 0xa7, 0xb2, 0xee, 0x85, 0xa9, 0x7e, 0x37, 0x54, 0xeb, 0x9d, 0x1c, 0x73, 0x9, 0xba, 0x8f, 0xca, 0xdd, 0x45, 0x64, 0x1a, 0xca, 0x4a, 0xe0, 0x61, 0x2a, 0x9a, 0xc6, 0x87, 0x2c, 0xce, 0x7b, 0x6e, 0xc5, 0x49, 0x3c, 0xcb, 0x45, 0x59, 0x30, 0x17, 0xe6, 0xf9, 0x18, 0x49, 0x3b, 0x68, 0x82, 0xba, 0x66, 0xfe, 0x8f, 0x96, 0xda, 0x93, 0xd7, 0x1c, 0xe4, 0xc4, 0x35, 0xe4, 0x5, 0xc4, 0x4f, 0x4b, 0x67, 0xde, 0xc0, 0xf8, 0x96, 0xda, 0x96, 0x1f, 0x7b, 0xed, 0x78, 0x49, 0x58, 0xf, 0x3c, 0x88, 0xdd, 0x15, 0x6e, 0xb8, 0xe3, 0x1e, 0x7e, 0x32, 0x5c, 0xab, 0xc1, 0xbc, 0x4f, 0x58, 0xe8, 0x3b, 0xcf, 0x8e, 0x62, 0x4, 0xda, 0xd7, 0x58, 0x53, 0x78, 0x8f, 0x12, 0x1d, 0x91, 0x61, 0x42, 0x7a, 0x43, 0x5b, 0x6, 0xf0, 0x85, 0x7, 0x25, 0x89, 0x31, 0xfd, 0x7c, 0x36, 0xd3, 0x9b, 0x48, 0x68, 0xdc, 0x57, 0x5a, 0x70, 0x6, 0x21, 0x68, 0x20, 0x3d, 0x8b, 0xdd, 0x60, 0x67, 0xb4, 0x58, 0xeb, 0x25, 0xaa, 0x5e, 0xc8, 0xaa, 0xbb, 0xf9, 0xb1, 0x19, 0x8d, 0xf0, 0xae, 0xcf, 0xcd, 0xa2, 0x6, 0xde, 0xe2, 0xdc, 0x4e, 0xe5, 0x72, 0x16, 0x80, 0xca, 0x36, 0x44, 0x64, 0xa9, 0xe7, 0xed, 0xd2, 0x96, 0x8, 0xa3, 0xc6, 0xa2, 0x67, 0x7a, 0x64, 0x92, 0xa5, 0x49, 0x44, 0x6e, 0x53, 0x4e, 0x9a, 0x66, 0xc9, 0x9b, 0x46, 0x9f, 0x5d, 0xcc, 0x14, 0xd9, 0x14, 0x8e, 0x28, 0xb, 0x39, 0xfe, 0xf7, 0x7a, 0xfc, 0x6d, 0x97, 0xa4, 0x8f, 0x19, 0x45, 0x44, 0xa2, 0x85, 0xdb, 0xf1, 0xb1, 0xd4, 0xda, 0xbe, 0x9e, 0x12, 0xe, 0x77, 0x77, 0x4a, 0xd5, 0x5, 0xda, 0x8, 0x34, 0xe5, 0x5d, 0x3e, 0x76, 0xfe, 0xb4, 0xf6, 0x17, 0x79, 0xb8, 0x6b, 0x88, 0x3d, 0x6b, 0x39, 0x0, 0xb9, 0xda, 0x38, 0xf3, 0xbc, 0x92, 0xe0, 0x36, 0x43, 0xe7, 0xe0, 0xc7, 0x16, 0x2b, 0x79, 0xfc, 0x62, 0x47, 0xc3, 0xf8, 0x87, 0xe9, 0xc4, 0xf7, 0x63, 0xb1, 0xf5, 0x44, 0x50, 0x4f, 0xe1, 0xc2, 0xd4, 0xa9, 0x5b, 0xe2, 0x15, 0x8a, 0x31, 0xfb, 0xb5, 0x15, 0x43, 0x1b, 0xe2, 0xb9, 0x54, 0x27, 0x5c, 0x70, 0x6f, 0x3a, 0x3e, 0xd2, 0xb6, 0xa6, 0xa9, 0x70, 0x59, 0x60, 0xc8, 0x68, 0x27, 0x1d, 0xf, 0x3f, 0xe5, 0x2d, 0x71, 0x1b, 0xf3, 0x77, 0x74, 0x6f, 0x28, 0xf7, 0xbc, 0x1f, 0xee, 0xd6, 0xbf, 0x7d, 0xf6, 0x4a, 0xbb, 0x5c, 0x61, 0xe3, 0xde, 0xe6, 0xdd, 0xab, 0x1f, 0xfa, 0x93, 0x8e, 0xe2, 0x1e, 0xa4, 0x5c, 0xea, 0xec, 0x5f, 0x6, 0x4f, 0x84, 0x36, 0x94, 0x2b, 0xb4, 0x89, 0x52, 0xe3, 0x70, 0xc3, 0x5a, 0x4d, 0xcf, 0xa8, 0xd7, 0x3d, 0x9c, 0x75, 0xad, 0xf8, 0xf3, 0xaf, 0x1d, 0x6f, 0xb9, 0x86, 0x27, 0x25, 0x8d, 0x96, 0xa6, 0x3a, 0x39, 0x8d, 0x90, 0xfd, 0xaa, 0x7f, 0x5c, 0x77, 0x9d, 0xc8, 0xfd, 0x97, 0x33, 0xe4, 0x32, 0xac, 0x54, 0x2b, 0xdd, 0x39, 0x95, 0xe5, 0xac, 0x33, 0x5e, 0xe3, 0x3, 0x17, 0xa4, 0xd, 0x2, 0xfd, 0xc3, 0x47, 0x20, 0xb8, 0x4f, 0x25, 0x34, 0x71, 0x65, 0x4a, 0x70, 0x97, 0x52, 0xd9, 0xed, 0x2e, 0xa3, 0xdb, 0x8, 0x9a, 0x5, 0xa5, 0x79, 0xa9, 0x29, 0x9d, 0xf1, 0xf4, 0xfe, 0x63, 0x78, 0xc, 0xbc, 0xee, 0xce, 0x5e, 0x21, 0xb2, 0x36, 0x36, 0x8e, 0xac, 0x70, 0x16, 0x89, 0xb, 0x53, 0x3b, 0xf9, 0x4b, 0xe, 0xe, 0xab, 0xd, 0x74, 0xd9, 0xbc, 0x9c, 0xb2, 0x9, 0x84, 0x5, 0x3, 0xb2, 0x37, 0x82, 0x1d, 0x3, 0xb7, 0x1b, 0xc9, 0x22, 0xfb, 0x4b, 0x74, 0x44, 0x1c, 0xb8, 0xee, 0xa8, 0x45, 0xd6, 0x70, 0x35, 0x25, 0x6, 0x53, 0x95, 0xb6, 0xa7, 0x2d, 0x47, 0xf9, 0x1, 0xd0, 0x52, 0x66, 0x24, 0x65, 0xc4, 0x8c, 0x11, 0x0, 0xc8, 0x8a, 0xa, 0x6, 0x79, 0x9b, 0x40, 0x76, 0xb0, 0x77, 0x4, 0xd6, 0x56, 0x75, 0xfc, 0x3b, 0x52, 0xf1, 0xd0, 0xfd, 0x99, 0xe4, 0x70, 0xb3, 0x20, 0x9c, 0x6a, 0x90, 0x94, 0x9a, 0xde, 0x31, 0xae, 0xb6, 0x27, 0x2e, 0x94, 0xfb, 0x53, 0x39, 0x8f, 0xf, 0x28, 0x91, 0x58, 0xfb, 0xbd, 0xae, 0xcb, 0x5c, 0xfe, 0xde, 0x54, 0x9d, 0x1b, 0xab, 0xd7, 0xe3, 0x4a, 0x3b, 0xa9, 0x93, 0x93, 0x31, 0xff, 0x19, 0xa5, 0xcc, 0xdd, 0x53, 0xbb, 0x38, 0xd8, 0x9a, 0x5b, 0x92, 0x55, 0xc0, 0x5, 0x1b, 0x73, 0x92, 0xed, 0x7, 0xb0, 0xd7, 0x55, 0xe0, 0x4b, 0x51, 0x79, 0x34, 0xdc, 0x3f, 0xb6, 0xbf, 0xb9, 0x33, 0x11, 0x98, 0xed, 0x28, 0x5b, 0x40, 0xa4, 0xb4, 0x38, 0x8b, 0xa2, 0xe7, 0xc0, 0x2, 0xc4, 0x7a, 0x37, 0xc0, 0xb6, 0x8b, 0xfd, 0xd7, 0x2b, 0x61, 0x77, 0xd, 0xae, 0xc3, 0x9a, 0x9a, 0x1, 0x39, 0x1d, 0x83, 0x9b, 0x84, 0xaf, 0x6b, 0x71, 0x7, 0x1c, 0xef, 0xe6, 0x66, 0xc, 0x58, 0x53, 0x72, 0xb3, 0xc6, 0xf9, 0xf7, 0x35, 0x53, 0x6e, 0xd0, 0xdf, 0xda, 0x55, 0xf5, 0xf3, 0x52, 0x76, 0x8f, 0x71, 0x6c, 0x4f, 0x6d, 0x41, 0x21, 0x39, 0xa4, 0x7b, 0x43, 0x4, 0xe5, 0xfd, 0xda, 0x71, 0x4c, 0x5e, 0x14, 0xf1, 0x61, 0x87, 0xb9, 0xd8, 0xac, 0xe5, 0x3f, 0x6d, 0x3d, 0xd2, 0x22, 0x98, 0x5f, 0x8b, 0xc1, 0x4e, 0xea, 0xbc, 0x1b, 0xa8, 0xef, 0x7e, 0xb, 0x68, 0x53, 0x5d, 0xc5, 0xb, 0xc2, 0xe0, 0x32, 0x29, 0x42, 0xfd, 0xf1, 0x23, 0x3e, 0xf9, 0xcf, 0x4d, 0xbe, 0xbe, 0x20, 0x5f, 0xc5, 0xe4, 0x60, 0x48, 0x89, 0xbc, 0xa0, 0xf9, 0x53, 0x81, 0xc1, 0x1b, 0xad, 0xc6, 0xa3, 0xff, 0xc7, 0x1d, 0x7b, 0x28, 0xf0, 0x60, 0x3e, 0xc7, 0x20, 0xe7, 0xf8, 0xfb, 0x60, 0xed, 0x46, 0x3e, 0x72, 0xde, 0x15, 0x9a, 0xf0, 0xd4, 0x96, 0x18, 0xe3, 0xdf, 0x16, 0xaf, 0xe2, 0x72, 0xdd, 0x62, 0x81, 0x6, 0xe3, 0xfe, 0x4d, 0xd1, 0x98, 0xc6, 0x85, 0xb6, 0x48, 0x70, 0x60, 0xec, 0xbb, 0xe, 0x69, 0xdf, 0x99, 0x5e, 0xa9, 0x7e, 0x37, 0xa7, 0x97, 0x89, 0xf1, 0x47, 0xfc, 0x3, 0x2b, 0x39, 0x98, 0x89, 0x4, 0x56, 0x23, 0x82, 0x14, 0x73, 0xfd, 0x4d, 0x6c, 0xdb, 0x45, 0x4c, 0x7b, 0x46, 0x8d, 0x26, 0xef, 0xbe, 0xa0, 0xda, 0x4b, 0xba, 0x85, 0xd9, 0x93, 0x66, 0x65, 0x60, 0xe1, 0xfa, 0xf8, 0xc0, 0x9c, 0x2e, 0xc3, 0x3e, 0xdb, 0x37, 0x92, 0x45, 0xd8, 0xa5, 0xd2, 0x61, 0xba, 0xa6, 0xa, 0x6f, 0x36, 0x7a, 0x51, 0x7c, 0x2e, 0xa1, 0xcd, 0xf8, 0x77, 0xae, 0x26, 0x41, 0xed, 0x22, 0xbb, 0x3c, 0x8a, 0x5, 0xa7, 0xfe, 0x28, 0x76, 0x32, 0xc8, 0x52, 0x30, 0xa4, 0x1c, 0x44, 0xd9, 0x66, 0x3d, 0x30, 0x8, 0xdf, 0x8e, 0x89, 0x7e, 0x13, 0x97, 0xe, 0x3f, 0x1, 0x3a, 0xb2, 0xf5, 0x9a, 0x7a, 0xae, 0x3b, 0xc5, 0xd, 0x28, 0x15, 0x2e, 0x84, 0xef, 0x60, 0x7b, 0x1f, 0x19, 0x8, 0x81, 0x2f, 0xdd, 0xd, 0xa3, 0x28, 0x5d, 0x98, 0x2d, 0xd7, 0xc2, 0x1c, 0x76, 0x73, 0xf9, 0x3a, 0x32, 0x40, 0xcd, 0x1, 0xac, 0xc8, 0x8f, 0x6d, 0x70, 0xb9, 0x58, 0xf8, 0x9f, 0xc4, 0x68, 0x55, 0xb, 0x6d, 0xde, 0xbe, 0x8f, 0x3b, 0xc2, 0xe5, 0xc1, 0x6f, 0xa9, 0xe3, 0x27, 0x46, 0x68, 0xc3, 0xc5, 0x48, 0x84, 0x41, 0x2a, 0x55, 0xdd, 0x1e, 0xb3, 0xe8, 0x1a, 0xb8, 0x18, 0x69, 0x6a, 0x76, 0x24, 0x70, 0x5b, 0xf5, 0x15, 0xe6, 0xb1, 0xef, 0xb1, 0xd5, 0xcd, 0x50, 0x4b, 0x6a, 0x73, 0x3b, 0xc7, 0x46, 0x66, 0x1c, 0x5a, 0xb8, 0xc, 0xa5, 0xd9, 0xf5, 0x69, 0x4b, 0x4e, 0x1d, 0xd6, 0x64, 0xc4, 0x19, 0x52, 0xbc, 0x18, 0x35, 0xe2, 0x30, 0x87, 0xa6, 0x1c, 0x5, 0xb, 0x32, 0x8d, 0xe9, 0xcc, 0xbf, 0xc8, 0x8b, 0xff, 0xc, 0xa6, 0x4f, 0xbf, 0xf0, 0x92, 0xea, 0x7e, 0x61, 0xef, 0x4a, 0x61, 0x23, 0x2a, 0xd3, 0x3, 0x78, 0x5, 0x3c, 0xc5, 0x9c, 0xe7, 0x7c, 0x6b, 0xd2, 0x62, 0xad, 0x8, 0x3, 0x42, 0xa4, 0x57, 0x8e, 0x4e, 0xc2, 0x1d, 0x33, 0x8c, 0x71, 0x7c, 0x56, 0x71, 0x6, 0x48, 0x2d, 0x11, 0x1, 0xeb, 0xc3, 0x6, 0x69, 0x91, 0x2d, 0x6b, 0x1f, 0xd3, 0xd1, 0xa2, 0xd1, 0x30, 0x2d, 0x94, 0xbb, 0x8f, 0x44, 0x22, 0x96, 0xc0, 0xa6, 0x37, 0x7a, 0x90, 0xbd, 0x6c, 0xf6, 0x27, 0xb7, 0x92, 0x3b, 0xe4, 0x91, 0x6f, 0x74, 0x42, 0x55, 0x9b, 0x29, 0x64, 0xa7, 0xc, 0xe3, 0xb7, 0xf1, 0x8a, 0x3, 0x2d, 0xc0, 0xdd, 0x8f, 0x4c, 0x25, 0x3, 0xd6, 0x0, 0x7f, 0xf7, 0xfb, 0xfb, 0x45, 0xf2, 0xf4, 0xcb, 0x61, 0xef, 0xa7, 0x9c, 0x74, 0xb3, 0x1, 0xbd, 0x7c, 0x67, 0x4d, 0x8c, 0xd5, 0xaf, 0xa3, 0x80, 0x2, 0x74, 0x4d, 0x56, 0x69, 0xd8, 0xf5, 0x2f, 0x67, 0xa8, 0x78, 0x33, 0x63, 0xb0, 0x15, 0x9, 0x25, 0x87, 0xdb, 0x9e, 0xc4, 0xf2, 0x53, 0x29, 0x38, 0x2d, 0x42, 0x6a, 0xb9, 0xca, 0x27, 0x31, 0xc8, 0xc2, 0xbe, 0xd2, 0x42, 0xe0, 0xd7, 0x36, 0xf1, 0x8d, 0x68, 0xba, 0x90, 0x6d, 0x5e, 0xfc, 0xf8, 0x84, 0x5b, 0xca, 0x9e, 0x0, 0x62, 0x12, 0xc7, 0x89, 0x35, 0x5a, 0xbd, 0x40, 0x3, 0x3d, 0x32, 0xbe, 0xf4, 0xe, 0x43, 0x12, 0x3d, 0xa1, 0xb5, 0x60, 0xd1, 0x9b, 0xe7, 0xb2, 0xbe, 0xde, 0xb3, 0x16, 0x5a, 0x27, 0xfa, 0xf5, 0xad, 0x3c, 0x8f, 0x8a, 0x6c, 0xbf, 0x1b, 0x2c, 0xd3, 0x85, 0xf6, 0x24, 0xe5, 0x2f, 0x7e, 0x6, 0x35, 0xd6, 0xf2, 0x3, 0xb0, 0x4f, 0xaa, 0xc9, 0x60, 0x4a, 0x44, 0x21, 0x9c, 0x96, 0x3c, 0x90, 0x2b, 0x20, 0x5d, 0x34, 0x49, 0xe9, 0x44, 0x52, 0x23, 0xe9, 0x49, 0x4f, 0xd4, 0xf6, 0xbc, 0x2c, 0xb3, 0xea, 0xdb, 0xd7, 0x69, 0xc3, 0xf, 0xc3, 0x9f, 0x62, 0xdf, 0xb, 0x45, 0x41, 0xfc, 0xed, 0x20, 0xf9, 0x6d, 0xde, 0x44, 0x20, 0x18, 0x8c, 0x80, 0x8d, 0xa3, 0x6d, 0x7f, 0x25, 0x2d, 0x8d, 0x15, 0xd2, 0xcb, 0xfd, 0xd9, 0xd1, 0x46, 0xa2, 0xc3, 0xc9, 0xeb, 0xdf, 0x4e, 0x7f, 0x16, 0xa3, 0xce, 0x9d, 0x7e, 0xbb, 0xec, 0xf6, 0xe3, 0x4f, 0x36, 0xad, 0x52, 0xfb, 0xd7, 0xa4, 0xa9, 0xa, 0x70, 0x83, 0x80, 0xd8, 0xc9, 0xaf, 0x17, 0xc1, 0x42, 0x2, 0x47, 0xe, 0x61, 0x96, 0x2a, 0xe1, 0x30, 0x57, 0x89, 0xe4, 0xda, 0xce, 0x5, 0x21, 0x88, 0x36, 0xcc, 0xe5, 0x67, 0x15, 0x3c, 0x85, 0x9, 0x79, 0x6d, 0xe7, 0xf6, 0xc5, 0x9c, 0x61, 0x84, 0x3f, 0x31, 0xad, 0xca, 0x2, 0xb0, 0xac, 0x14, 0x83, 0x22, 0x4b, 0x67, 0x5d, 0xd3, 0x12, 0x3c, 0xe7, 0x20, 0xfb, 0xfc, 0xdf, 0x6f, 0x10, 0xe3, 0xc2, 0xd, 0x53, 0x43, 0xf6, 0x3b, 0xd2, 0xd9, 0x5c, 0x4f, 0xea, 0xe8, 0x9, 0xb2, 0xa2, 0xd7, 0xe3, 0x5, 0x1, 0xe8, 0x36, 0x1a, 0x1a, 0x3b, 0xdd, 0x4a, 0xca, 0x1, 0xe9, 0xd1, 0x9, 0x69, 0xc0, 0x73, 0x55, 0x13, 0x36, 0x80, 0xdf, 0x2f, 0xce, 0x12, 0x2e, 0x43, 0x95, 0xa3, 0x69, 0x2a, 0x97, 0x2f, 0xdb, 0x4a, 0xa1, 0xed, 0xa5, 0x98, 0x75, 0x39, 0xb1, 0x93, 0x59, 0xc4, 0x59, 0xc2, 0x7a, 0xbe, 0xe0, 0xc0, 0xbd, 0xfa, 0xa7, 0xa3, 0x77, 0x6b, 0x41, 0x14, 0x7c, 0x61, 0xbc, 0x38, 0x91, 0x6b, 0x74, 0xcb, 0xc6, 0xdc, 0xca, 0x58, 0x7d, 0xa2, 0xcd, 0xd6, 0x73, 0x2c, 0x7b, 0xf1, 0x35, 0x5c, 0xf1, 0x82, 0xcd, 0x2f, 0xa3, 0x31, 0x7f, 0x8d, 0xc4, 0x91, 0x23, 0x44, 0x25, 0x29, 0xe9, 0xd0, 0x4, 0x26, 0x33, 0xae, 0x5d, 0xd6, 0x67, 0x24, 0x8e, 0xfb, 0x1d, 0x85, 0xd6, 0x35, 0x1a, 0x62, 0x59, 0x75, 0x43, 0x3b, 0x6d, 0x51, 0xf7, 0xb7, 0xc, 0xad, 0xab, 0x21, 0x5b, 0xcb, 0xea, 0xa4, 0xcc, 0x5a, 0xbd, 0x33, 0x71, 0x56, 0x81, 0x9, 0xdd, 0x1f, 0x7a, 0x83, 0x39, 0xee, 0xbc, 0x1d, 0x11, 0xe3, 0xa7, 0x72, 0x80, 0xbc, 0x44, 0x5b, 0x3f, 0xff, 0x98, 0x4a, 0x53, 0xaa, 0x3d, 0xc3, 0xc9, 0x6b, 0xe7, 0x5a, 0xb2, 0x6b, 0xb4, 0xc1, 0x3d, 0xa4, 0x96, 0xf, 0x7c, 0xeb, 0x17, 0xef, 0x36, 0x44, 0x31, 0x49, 0xe0, 0xf, 0xe7, 0x4, 0x1a, 0x83, 0xbe, 0x6d, 0xba, 0xb7, 0x1a, 0x62, 0x7e, 0x13, 0x68, 0xfe, 0xbb, 0xf, 0x98, 0xf7, 0x10, 0xd5, 0x60, 0x98, 0x6d, 0x5a, 0x89, 0x6f, 0xb9, 0x12, 0x5b, 0xcc, 0x19, 0xd3, 0x97, 0x66, 0x1a, 0x10, 0xd2, 0x7a, 0x65, 0xbc, 0xae, 0xd9, 0x5c, 0xfc, 0x3a, 0x31, 0xf9, 0x17, 0xca, 0x93, 0x95, 0xcd, 0xc2, 0x5c, 0x17, 0xaa, 0x3e, 0x1a, 0xc0, 0xd7, 0x4, 0x3b, 0x41, 0xd4, 0x99, 0x57, 0xfc, 0x93, 0x23, 0x7e, 0xf2, 0x2e, 0xa, 0xe7, 0x79, 0x1b, 0xdd, 0x30, 0x36, 0x9a, 0xf5, 0xca, 0xf6, 0x72, 0xc4, 0x32, 0x3e, 0xea, 0xf5, 0x33, 0x60, 0x34, 0x1d, 0x4, 0x6b, 0x69, 0x74, 0x3b, 0xf7, 0xd8, 0xc3, 0x4d, 0xe2, 0x79, 0x13, 0x21, 0x37, 0x25, 0x90, 0xb7, 0x24, 0xb0, 0x2, 0x79, 0x57, 0x5c, 0xb4, 0x4f, 0x41, 0xa5, 0xfd, 0x66, 0x18, 0x68, 0xa7, 0xf7, 0xf7, 0xa4, 0xe0, 0x35, 0xe9, 0xc3, 0xa2, 0x88, 0x9a, 0x58, 0x6, 0x3c, 0x65, 0xcc, 0x41, 0xfa, 0xcc, 0x1e, 0x57, 0x6d, 0x32, 0xbc, 0x2, 0x70, 0x46, 0x10, 0xa9, 0xc1, 0x5e, 0xd0, 0xf4, 0x5d, 0xd4, 0xf3, 0x65, 0xfb, 0x81, 0x57, 0xff, 0x8, 0xe7, 0xcb, 0xe7, 0x58, 0x5e, 0x31, 0x45, 0x81, 0x75, 0xb, 0x56, 0x94, 0xcf, 0xb3, 0x82, 0xfa, 0x16, 0x34, 0xe, 0xe7, 0x35, 0xf, 0x24, 0xe, 0x27, 0x7e, 0xeb, 0x71, 0xe4, 0xcc, 0xe7, 0xcc, 0x9d, 0xf5, 0x8d, 0xed, 0xc7, 0x69, 0x61, 0x20, 0xaa, 0x77, 0xfd, 0x8e, 0x6b, 0xfa, 0xe7, 0x58, 0xca, 0xdb, 0xfd, 0x97, 0xed, 0x29, 0xf8, 0xf0, 0xe6, 0x2f, 0x4b, 0x14, 0x2f, 0x1c, 0xbd, 0x43, 0xc8, 0xf9, 0xf4, 0xeb, 0xab, 0x25, 0xb0, 0x35, 0x9f, 0x9b, 0xa0, 0x2e, 0x37, 0x1a, 0x25, 0xf9, 0x57, 0x3f, 0x1c, 0x77, 0x3f, 0x86, 0xe5, 0x3d, 0x75, 0x48, 0xd4, 0x9f, 0x19, 0xf, 0xb7, 0xbf, 0x31, 0xfc, 0x72, 0x6a, 0xa5, 0x9e, 0x89, 0xd3, 0x10, 0x39, 0x32, 0x2e, 0xe5, 0x3e, 0x20, 0x3b, 0x47, 0x6f, 0x5f, 0x32, 0xd6, 0x8c, 0x2b, 0xeb, 0x6e, 0xc3, 0x8d, 0xd9, 0x90, 0x14, 0x34, 0xb8, 0x77, 0x40, 0x8d, 0xbb, 0xe8, 0xb3, 0xa8, 0x8c, 0x2e, 0xd7, 0xf9, 0x44, 0x5c, 0xf2, 0xae, 0x9, 0x1c, 0x85, 0xe4, 0x27, 0x3f, 0xf, 0xb7, 0x74, 0x5b, 0xc6, 0x93, 0x64, 0x8f, 0xba, 0xe3, 0xa4, 0xc7, 0x67, 0x26, 0xe9, 0x5f, 0x20, 0xa7, 0xfe, 0x1e, 0xdd, 0x8e, 0x43, 0xbf, 0x8c, 0xbc, 0x12, 0x37, 0x9a, 0x7c, 0xc6, 0x40, 0xd4, 0x85, 0xbd, 0xd4, 0x74, 0x73, 0x99, 0xba, 0x5c, 0x20, 0x6e, 0x1d, 0x22, 0x4c, 0xed, 0xc9, 0x56, 0x17, 0xbc, 0xc2, 0x4, 0xcb, 0xf8, 0xc2, 0xdb, 0xe, 0x2c, 0x4f, 0x26, 0x96, 0x44, 0xe3, 0xcc, 0xfc, 0x3d, 0x43, 0xa8, 0x96, 0xb4, 0x73, 0xa1, 0xe1, 0xbe, 0xa1, 0x55, 0xcd, 0xb2, 0x2, 0x3, 0x6e, 0x57, 0x49, 0xc1, 0x1c, 0x98, 0x1f, 0xd8, 0xf, 0xe0, 0xe, 0x8e, 0xa8, 0x5a, 0xe0, 0x4a, 0x94, 0x50, 0x8, 0x91, 0xae, 0x66, 0xf, 0x9, 0x65, 0x5a, 0xb9, 0x61, 0xc, 0xb5, 0x1c, 0x7e, 0x80, 0xf2, 0xa7, 0xe6, 0x38, 0xb2, 0x69, 0x67, 0x2a, 0x98, 0x26, 0x6f, 0x9a, 0x35, 0x8d, 0x51, 0xf9, 0x37, 0xe5, 0xfc, 0x7e, 0x9b, 0xf5, 0xd8, 0x9a, 0xfe, 0x8f, 0x5a, 0xeb, 0xc9, 0x37, 0x50, 0xf6, 0xc1, 0xc5, 0xf5, 0xfa, 0xb8, 0x0, 0xa1, 0x71, 0x1, 0xfe, 0x7a, 0xd6, 0xe8, 0x5b, 0x4b, 0xb7, 0x9e, 0x7, 0x41, 0xaf, 0xf6, 0x41, 0x8e, 0xd4, 0xb6, 0xc9, 0xc2, 0x77, 0x27, 0x4, 0xfa, 0xad, 0xf6, 0x95, 0x1f, 0x17, 0xcd, 0x76, 0xf5, 0x18, 0xbc, 0x9e, 0x7a, 0x77, 0xff, 0xee, 0xe4, 0x74, 0x8d, 0x80, 0x43, 0xd3, 0x96, 0x99, 0xa4, 0x63, 0x58, 0x58, 0xb, 0x63, 0x9f, 0x93, 0x62, 0xea, 0x1a, 0xcc, 0x62, 0x79, 0x59, 0xf, 0x9b, 0x69, 0x1c, 0xe1, 0x7d, 0xb4, 0xac, 0x83, 0x5d, 0x98, 0x74, 0x71, 0xb, 0xc3, 0xbc, 0xf0, 0xc1, 0x8d, 0xb6, 0xb4, 0x8b, 0x62, 0x54, 0x95, 0x31, 0xc1, 0x36, 0xab, 0xb, 0x8d, 0x75, 0x6b, 0x8, 0xf9, 0xbc, 0x36, 0xaa, 0x13, 0x12, 0x55, 0x69, 0x37, 0xd, 0xff, 0xcc, 0x6c, 0x80, 0xe6, 0xf6, 0x38, 0x8d, 0x1f, 0x46, 0x5e, 0x3, 0x95, 0xe1, 0x44, 0xff, 0xd7, 0xa7, 0xf7, 0xce, 0x8, 0x1a, 0xd9, 0x9c, 0x59, 0xd8, 0x94, 0x40, 0x17, 0x1a, 0x9e, 0x8c, 0xd6, 0x6, 0xbf, 0xcd, 0x17, 0x56, 0x7f, 0xf3, 0xfe, 0x63, 0xbe, 0x15, 0x79, 0x4e, 0xc3, 0xb5, 0x51, 0xe4, 0x2a, 0x22, 0x86, 0xff, 0xfe, 0xaf, 0x49, 0xd9, 0x9, 0x6e, 0x63, 0xb7, 0x5b, 0x1f, 0x75, 0x0, 0x3f, 0xfe, 0x4, 0x47, 0x55, 0x20, 0xb6, 0x40, 0xe7, 0x7e, 0x8d, 0x87, 0x38, 0xe1, 0x55, 0xc4, 0x57, 0xac, 0x62, 0xde, 0xce, 0xe0, 0x8a, 0xbd, 0x4a, 0xf3, 0x48, 0x40, 0x23, 0x95, 0xbb, 0x6d, 0x57, 0x9d, 0x7b, 0x84, 0xe, 0xeb, 0x95, 0xe1, 0x86, 0xce, 0x20, 0x6c, 0x1a, 0x85, 0x27, 0xa, 0x9e, 0x54, 0x18, 0x76, 0xbb, 0x10, 0xd5, 0x60, 0xc3, 0xae, 0x4a, 0xe, 0x5e, 0x9b, 0xab, 0xb8, 0xb8, 0x84, 0x1e, 0xa3, 0x63, 0xef, 0x8e, 0xe4, 0x3, 0xb3, 0x2, 0x49, 0xe, 0x5c, 0xf5, 0x13, 0x79, 0x6a, 0xe5, 0x9, 0x2c, 0x7c, 0x98, 0x81, 0xa6, 0x50, 0x64, 0xfc, 0x13, 0xb7, 0x3a, 0x47, 0x56, 0xb8, 0x86, 0xb8, 0xf0, 0x16, 0xcf, 0x1d, 0x99, 0x76, 0x86, 0x19, 0x9a, 0xc2, 0x4a, 0x21, 0x71, 0x9a, 0xb2, 0x93, 0xba, 0x22, 0x7e, 0x61, 0xee, 0x8b, 0xd6, 0xa, 0x37, 0x38, 0x4b, 0x55, 0x68, 0x45, 0x54, 0x2, 0x66, 0x5a, 0xf1, 0x1d, 0x3d, 0x5d, 0x3f, 0xf9, 0x41, 0xc1, 0xfe, 0x17, 0xcf, 0x49, 0x6, 0x91, 0xbb, 0xdd, 0x74, 0xa2, 0x5, 0xef, 0x6e, 0x4e, 0x10, 0xaf, 0xd3, 0x57, 0xf5, 0x54, 0x6d, 0xeb, 0x18, 0x54, 0x22, 0x88, 0x25, 0x35, 0xce, 0xf8, 0x8a, 0x1c, 0x8a, 0x74, 0xbd, 0xc7, 0xdd, 0x72, 0x2a, 0x9b, 0xd9, 0xdb, 0x55, 0xb8, 0xc, 0x2f, 0x6c, 0xf1, 0x1a, 0xc6, 0xe3, 0x81, 0x16, 0x4b, 0x6f, 0xba, 0x41, 0xec, 0xbb, 0x33, 0xaf, 0x31, 0x27, 0x8a, 0x19, 0xd6, 0xf2, 0x1, 0x4, 0xd0, 0x40, 0x11, 0xc2, 0xa2, 0x28, 0x7d, 0x75, 0x97, 0xdb, 0xda, 0x5f, 0xaf, 0xdf, 0x63, 0x58, 0x4e, 0xdc, 0x37, 0x39, 0x67, 0x4f, 0x2b, 0xdb, 0xc9, 0x1, 0x2e, 0xb, 0x77, 0x41, 0xf4, 0xc8, 0x84, 0xca, 0x74, 0x2f, 0x7d, 0x5c, 0xeb, 0xb5, 0x94, 0xad, 0x7f, 0x55, 0x82, 0x6e, 0xe8, 0x5e, 0x3c, 0x6, 0xcc, 0x77, 0x68, 0x6c, 0xbc, 0xda, 0x8, 0x0, 0xfb, 0x4b, 0x8, 0x56, 0x9d, 0x1d, 0x8f, 0x39, 0x6b, 0xfc, 0xa7, 0xcf, 0x61, 0xff, 0xbd, 0x39, 0x11, 0xb4, 0x44, 0xe1, 0xc6, 0x3},
+               output224: []byte{0x1a, 0x32, 0xe, 0xa5, 0xd2, 0xc3, 0xb7, 0x20, 0x9f, 0xe9, 0xaa, 0x5, 0x34, 0xc, 0xa2, 0x8e, 0x51, 0x4e, 0x18, 0x90, 0x80, 0x64, 0x6, 0xc5, 0x76, 0x81, 0xe4, 0x20},
+               output256: []byte{0xa9, 0x32, 0x87, 0x95, 0x2d, 0xbf, 0x85, 0x98, 0xd6, 0x9d, 0x81, 0x77, 0x70, 0x55, 0x83, 0x30, 0xc5, 0xda, 0xe8, 0x7c, 0x12, 0x68, 0x82, 0x48, 0xe7, 0x0, 0x31, 0x4e, 0xe7, 0x89, 0x62, 0x8b},
+               output384: []byte{0xa3, 0x32, 0x9b, 0xa, 0xb3, 0x58, 0xf0, 0x10, 0xce, 0xad, 0x13, 0x6f, 0xa0, 0x76, 0x7c, 0x84, 0xc9, 0x62, 0x4f, 0xa2, 0xa6, 0xde, 0x47, 0xf, 0x23, 0xda, 0x87, 0x32, 0xfe, 0x65, 0x63, 0x9f, 0x71, 0xb1, 0xdd, 0x47, 0x63, 0x3f, 0x9, 0xae, 0x86, 0x34, 0x9e, 0x97, 0x7e, 0x4d, 0xe8, 0x4},
+               output512: []byte{0xb5, 0xbd, 0xb3, 0xfa, 0xd8, 0xb5, 0xb8, 0x9e, 0xd4, 0x7d, 0xb1, 0x48, 0x9e, 0x19, 0xe2, 0x7b, 0x84, 0x6d, 0xcc, 0x9d, 0x96, 0x5d, 0x32, 0x54, 0x3e, 0x94, 0xa5, 0x30, 0x51, 0x49, 0x9e, 0xee, 0xfe, 0x88, 0xcd, 0x12, 0x3c, 0x58, 0xd5, 0xee, 0x25, 0x81, 0x12, 0xd3, 0xec, 0x7f, 0x44, 0x34, 0x19, 0x99, 0x76, 0x23, 0x7f, 0x69, 0x97, 0x1f, 0x69, 0xba, 0x8a, 0xda, 0x7d, 0x8d, 0x3d, 0xa7}},
+       testcase{
+               msg:       []byte{0x85, 0x8e, 0xf3, 0x4c, 0x28, 0xb8, 0x93, 0x9b, 0xfb, 0x46, 0x44, 0xd1, 0xe4, 0x58, 0xa6, 0x7a, 0x3, 0x4b, 0x9a, 0xf9, 0xf8, 0x2d, 0xb7, 0x86, 0x89, 0x2d, 0x81, 0xc3, 0x43, 0xd2, 0x7b, 0x96, 0xee, 0x49, 0xcf, 0xfb, 0xf2, 0xc3, 0x41, 0x9e, 0xb1, 0x1e, 0xfa, 0xeb, 0x9f, 0x8d, 0x4, 0x10, 0xb0, 0xeb, 0x68, 0x81, 0x56, 0x65, 0x4a, 0x8e, 0x32, 0xee, 0x2a, 0x57, 0xc, 0x5a, 0x88, 0x0, 0x76, 0x56, 0xa1, 0x83, 0x80, 0xdf, 0x33, 0xf7, 0x75, 0x6a, 0x60, 0x4, 0x76, 0x6a, 0x6b, 0x96, 0xbb, 0x27, 0xa7, 0x41, 0x5, 0x7a, 0x7a, 0xe, 0x22, 0xd7, 0x32, 0xd7, 0x97, 0xc4, 0x88, 0xeb, 0x61, 0x3f, 0x17, 0x9d, 0xc3, 0xf1, 0x9, 0x4b, 0x2b, 0x5c, 0x8e, 0x5a, 0x34, 0xbd, 0x57, 0xf2, 0x6d, 0xe8, 0x5e, 0x23, 0x4f, 0xd8, 0x94, 0xa2, 0xd2, 0x76, 0xe8, 0xf3, 0x1d, 0xf, 0x7f, 0x23, 0xe5, 0x70, 0xa0, 0xa4, 0xe1, 0x3b, 0xdb, 0x63, 0x5c, 0xc8, 0x89, 0x72, 0x82, 0xa1, 0xae, 0x0, 0xcb, 0xc, 0x8f, 0x4, 0x12, 0x4e, 0xdc, 0x6e, 0xde, 0x14, 0x4, 0x27, 0x2f, 0x1b, 0xfd, 0xf5, 0x5a, 0xb2, 0xa0, 0xb3, 0xd5, 0xb3, 0x53, 0x4a, 0x4c, 0x1, 0xcb, 0xe, 0x1d, 0x57, 0x50, 0xee, 0x71, 0x32, 0x8f, 0xe3, 0xda, 0xcc, 0xe5, 0x42, 0x3, 0x44, 0x10, 0x89, 0x96, 0xb6, 0xde, 0x1a, 0x44, 0x38, 0x34, 0xb6, 0xba, 0xdf, 0xe6, 0x16, 0x53, 0x4e, 0xaa, 0xea, 0x32, 0x68, 0x1d, 0x57, 0xa2, 0xe4, 0x1c, 0x77, 0x17, 0x3d, 0x6d, 0xc0, 0x75, 0x1d, 0xa2, 0x6a, 0x17, 0x73, 0x1b, 0x1, 0x83, 0x3a, 0xd0, 0xb9, 0xc4, 0xd3, 0xb4, 0x8b, 0xa2, 0x37, 0x73, 0xaa, 0x6d, 0x2b, 0xb7, 0x2, 0x93, 0x77, 0xf4, 0x53, 0x48, 0x4a, 0x44, 0xe6, 0x73, 0x4a, 0x3a, 0xcb, 0x37, 0x25, 0xff, 0xba, 0x5, 0x47, 0xf1, 0x4, 0x5f, 0x18, 0xba, 0xcb, 0x1e, 0x9c, 0x9c, 0x80, 0x17, 0x59, 0xb9, 0xa1, 0x62, 0x9, 0xf0, 0x15, 0x8a, 0x4e, 0x8f, 0x21, 0xcc, 0xa9, 0x11, 0x2f, 0xde, 0x82, 0x38, 0x8c, 0xf1, 0xfe, 0x58, 0xad, 0xfa, 0x1f, 0x68, 0x4c, 0x31, 0x58, 0x93, 0x5e, 0xdf, 0x93, 0x88, 0xb4, 0x2a, 0xc0, 0xe5, 0xb3, 0xb6, 0x8e, 0x6e, 0x6a, 0x4d, 0x44, 0x76, 0xc4, 0xea, 0xc7, 0x8f, 0x16, 0x6e, 0xc5, 0xfa, 0x46, 0x4b, 0x56, 0x5d, 0x48, 0x1f, 0x57, 0xa9, 0xd2, 0x63, 0xba, 0xb7, 0xa1, 0xfe, 0xd0, 0x5d, 0x73, 0x79, 0x74, 0xc4, 0xf7, 0xbd, 0xaf, 0x2c, 0xe5, 0xba, 0x40, 0xb2, 0xa9, 0x93, 0xe8, 0x67, 0xe5, 0x84, 0x4c, 0x77, 0x50, 0x1, 0x4e, 0x66, 0xbc, 0xc5, 0xbb, 0xf5, 0xe5, 0x0, 0x40, 0x25, 0x29, 0xdd, 0xab, 0xf1, 0xea, 0x2e, 0x39, 0x5d, 0xb0, 0x84, 0xc4, 0xbb, 0x85, 0x76, 0x6f, 0xda, 0x99, 0x3b, 0x54, 0x77, 0x88, 0xfc, 0xef, 0x35, 0x38, 0x1f, 0xb1, 0x6a, 0xf0, 0x96, 0x5a, 0x8, 0xee, 0x5c, 0xbb, 0x4d, 0x68, 0xc9, 0x34, 0x78, 0x55, 0x94, 0xb3, 0x7f, 0x78, 0xe7, 0x6a, 0x65, 0x58, 0xae, 0xe7, 0x3e, 0x57, 0xe, 0x40, 0xcc, 0xc8, 0x89, 0xb0, 0xd5, 0x26, 0x97, 0x56, 0xbc, 0x40, 0x89, 0x7e, 0xc0, 0xc2, 0xd6, 0xc3, 0x3a, 0x33, 0xb1, 0x89, 0x7a, 0xef, 0x29, 0x7f, 0x37, 0x7c, 0xb5, 0x8a, 0x7a, 0x1a, 0x38, 0x9e, 0xa6, 0xf, 0x4b, 0x5f, 0x25, 0xd1, 0x30, 0x5d, 0x4, 0x6e, 0x48, 0xd5, 0xbf, 0xb1, 0x8, 0x3a, 0x82, 0xc5, 0xae, 0xed, 0x9, 0x20, 0x8f, 0xf8, 0x30, 0x76, 0x36, 0x71, 0x56, 0xb9, 0x7, 0x1b, 0xea, 0xb5, 0xaa, 0x12, 0xd9, 0xdc, 0xa9, 0xf8, 0xaa, 0x9, 0x38, 0x72, 0xc4, 0xc9, 0x5b, 0x84, 0xcd, 0xbb, 0xb, 0x84, 0xab, 0xbb, 0x3, 0xf3, 0x3b, 0x63, 0xa7, 0xc6, 0x3, 0xd7, 0x23, 0xdd, 0x99, 0x70, 0x52, 0x45, 0x48, 0xe6, 0x1f, 0x38, 0x4, 0xb7, 0xa9, 0x14, 0x85, 0x2a, 0xe5, 0x5d, 0x37, 0x7e, 0x25, 0xa8, 0x43, 0x1b, 0x1e, 0x7c, 0xe7, 0x8f, 0x12, 0x94, 0x66, 0x49, 0x25, 0xd6, 0x2b, 0x7d, 0x8c, 0xa3, 0xc8, 0x80, 0xc4, 0xac, 0x80, 0xe9, 0x2f, 0x8e, 0x86, 0x55, 0x4b, 0xca, 0xfc, 0xd3, 0x9c, 0xa4, 0x4c, 0xac, 0x1, 0x7f, 0x4c, 0x45, 0x50, 0xbe, 0x11, 0x9e, 0xbd, 0xec, 0x7a, 0xee, 0xcc, 0xd5, 0x27, 0xef, 0xb4, 0x78, 0x34, 0x84, 0x25, 0xfc, 0x36, 0x68, 0x14, 0x16, 0x7, 0xd1, 0x4d, 0xfa, 0xc9, 0x4, 0x51, 0xb2, 0x99, 0x6d, 0xd4, 0x6b, 0x23, 0x68, 0x32, 0x10, 0x91, 0x6b, 0x90, 0xe6, 0x3e, 0xa2, 0xa4, 0xa0, 0x6, 0xbf, 0x72, 0xc4, 0xdb, 0xb6, 0xab, 0xf3, 0xd0, 0x50, 0x53, 0x79, 0xc5, 0xb3, 0x60, 0x96, 0x6a, 0x25, 0x47, 0x1e, 0x65, 0x8e, 0xe2, 0x4c, 0xab, 0xce, 0xbb, 0x5c, 0x6e, 0xd5, 0xf8, 0xdc, 0xcc, 0x84, 0x61, 0x4d, 0x64, 0xbc, 0xa5, 0x4f, 0x35, 0x18, 0x9f, 0x57, 0x9c, 0x17, 0xf, 0x2a, 0x2b, 0x77, 0x3a, 0xad, 0xfc, 0xf3, 0xc1, 0xc4, 0x35, 0x88, 0x5d, 0xa, 0xde, 0x71, 0x21, 0xa4, 0xd2, 0xfc, 0xc9, 0x6a, 0xfa, 0x88, 0xdf, 0x6e, 0xa2, 0xc5, 0x19, 0xa9, 0x8a, 0xb2, 0x79, 0xe9, 0xf7, 0x54, 0x0, 0xab, 0x5, 0x3d, 0x45, 0x7e, 0xd3, 0xff, 0x95, 0x7c, 0x20, 0xf2, 0x82, 0xbd, 0x12, 0x1e, 0xf6, 0x7f, 0x53, 0x5, 0x3f, 0xb4, 0x96, 0x3d, 0x8, 0xf7, 0xe, 0xb2, 0x87, 0xe0, 0x11, 0xdf, 0xd0, 0x15, 0xcf, 0xe4, 0x92, 0xad, 0xcb, 0x92, 0x7b, 0xb8, 0x0, 0x93, 0x54, 0x50, 0x14, 0x73, 0x6a, 0x12, 0xe2, 0x36, 0x56, 0x9e, 0xcc, 0x34, 0x53, 0x35, 0xa, 0x5e, 0x57, 0xd5, 0xb, 0x1b, 0xbc, 0xa5, 0xc8, 0xa0, 0x1a, 0x94, 0x62, 0x48, 0x37, 0xc, 0xde, 0x61, 0x77, 0xd7, 0xb8, 0xc8, 0x4f, 0x11, 0xea, 0xba, 0xb0, 0xc3, 0xa5, 0xce, 0x65, 0x4f, 0xf8, 0x57, 0x83, 0xee, 0x8e, 0xef, 0xea, 0xb5, 0x84, 0x51, 0xce, 0x73, 0xe1, 0x64, 0xa9, 0xdf, 0x47, 0xdc, 0xdc, 0x9e, 0xd2, 0x4b, 0xf, 0x7a, 0x87, 0xe0, 0xec, 0xd1, 0xa3, 0xdd, 0x15, 0xe6, 0xd6, 0x56, 0xb8, 0x94, 0x5f, 0x9, 0x64, 0x92, 0xec, 0x72, 0xc0, 0xb5, 0x1d, 0x13, 0x61, 0x3b, 0x31, 0x34, 0xc3, 0xe3, 0x1c, 0xd1, 0xa3, 0x9, 0x3b, 0x80, 0x23, 0x64, 0x9c, 0x1b, 0x3a, 0x3e, 0xe8, 0xa0, 0x9e, 0x5a, 0x8d, 0x61, 0x2a, 0x91, 0xb4, 0xb1, 0x46, 0x46, 0xe2, 0x2d, 0x57, 0x5c, 0xc0, 0x93, 0x48, 0xa5, 0xa5, 0x8e, 0xf, 0x9b, 0x64, 0x10, 0x37, 0xd7, 0xb6, 0x3d, 0x32, 0xb4, 0xe, 0xa5, 0xfc, 0x16, 0xc5, 0x5a, 0x8, 0x75, 0xf3, 0xe6, 0x4f, 0x25, 0xca, 0x97, 0xf2, 0xa7, 0xd, 0xa0, 0xf4, 0x56, 0x7c, 0x96, 0x26, 0x3, 0xb, 0x5b, 0x84, 0x63, 0xd8, 0xa5, 0x5c, 0x34, 0x66, 0x54, 0x81, 0xf2, 0xfc, 0x30, 0x8d, 0x2b, 0x87, 0x11, 0x1d, 0x23, 0xb1, 0xb6, 0xca, 0x96, 0x1, 0x3f, 0xf0, 0x33, 0xb2, 0x32, 0x16, 0xc2, 0x7c, 0x9d, 0x2e, 0x12, 0x22, 0xde, 0xe2, 0x5b, 0x29, 0x5e, 0x18, 0xc, 0xb6, 0xeb, 0x9b, 0xbf, 0x72, 0xf5, 0x9a, 0xec, 0x7, 0xa, 0xc8, 0x9, 0xa7, 0x9b, 0x33, 0x6, 0xe0, 0xbd, 0xb7, 0x1, 0x52, 0x1d, 0x4d, 0xe1, 0xd7, 0x55, 0xf7, 0x5e, 0xea, 0xd5, 0xd7, 0x9a, 0x72, 0xdc, 0xa5, 0x5b, 0x6e, 0x25, 0xfd, 0x10, 0xc4, 0xec, 0x68, 0xbc, 0x5c, 0x58, 0x5a, 0xa1, 0xc3, 0x92, 0xda, 0x26, 0xbe, 0x5d, 0xcb, 0x75, 0xcf, 0x2f, 0xf4, 0xb3, 0x1c, 0x3c, 0x57, 0x8f, 0x97, 0x8, 0x19, 0x1f, 0x59, 0xd0, 0x4c, 0x2e, 0x0, 0xab, 0xea, 0xbc, 0x6b, 0x21, 0x7d, 0x89, 0xba, 0x9b, 0xcd, 0xc, 0xbe, 0x76, 0xe7, 0x2e, 0x31, 0x6a, 0x4c, 0x7f, 0x18, 0xaf, 0x64, 0x2d, 0x9f, 0xaf, 0x3e, 0x76, 0xa6, 0xe4, 0xf4, 0xf5, 0xe8, 0xe, 0x12, 0x52, 0xe5, 0x2f, 0x99, 0x6d, 0xde, 0xa2, 0x79, 0xba, 0xe6, 0xd8, 0x8e, 0xf8, 0x66, 0xae, 0x6f, 0x3d, 0x77, 0xe0, 0xe1, 0x5, 0x11, 0x1d, 0x4, 0xd4, 0x14, 0x5f, 0x9, 0x69, 0x19, 0x25, 0xce, 0xfc, 0x2a, 0x8d, 0xf9, 0x6f, 0xd, 0x34, 0xa, 0xc8, 0x6c, 0xb, 0x48, 0xef, 0x5d, 0x18, 0xec, 0x1d, 0xf5, 0x97, 0x48, 0xbf, 0x5f, 0x26, 0x15, 0x80, 0xac, 0xdc, 0x4f, 0x58, 0xcd, 0xd2, 0xc2, 0x64, 0x9e, 0x4b, 0x35, 0x78, 0x72, 0xdd, 0x98, 0x2d, 0x9f, 0xcb, 0x59, 0x91, 0x60, 0x37, 0xa8, 0x24, 0x7c, 0x6e, 0x37, 0x4f, 0xc, 0xea, 0x92, 0x4a, 0x25, 0xed, 0x9a, 0xb, 0x5d, 0xc1, 0x5d, 0xa9, 0xae, 0xec, 0xa8, 0xa9, 0xa9, 0xde, 0x98, 0x11, 0xe1, 0xdc, 0xc4, 0xf0, 0x53, 0x57, 0x86, 0x78, 0x71, 0xb9, 0x59, 0xac, 0x9e, 0x1d, 0x3c, 0x4a, 0xa2, 0x63, 0x3c, 0x94, 0x45, 0xaa, 0x22, 0x39, 0xd0, 0x2e, 0x9e, 0x5c, 0x7d, 0x22, 0xfe, 0xba, 0x47, 0xe7, 0xa0, 0x33, 0x2f, 0x2, 0x5e, 0x83, 0xda, 0x6, 0xea, 0xa8, 0x2f, 0x30, 0xad, 0xbf, 0xc8, 0xe1, 0x16, 0x73, 0x91, 0xc6, 0xf3, 0xfa, 0x82, 0xb8, 0x78, 0x57, 0xde, 0xec, 0x2f, 0x39, 0xd0, 0x8d, 0x4a, 0xa3, 0xba, 0x59, 0xe1, 0x59, 0x8b, 0x54, 0xd6, 0x65, 0xba, 0x68, 0x43, 0x8f, 0xc7, 0x49, 0x3b, 0x35, 0x1a, 0xb5, 0x4b, 0x90, 0x7a, 0x80, 0x94, 0x5f, 0xed, 0xa0, 0xed, 0x5a, 0xba, 0xc5, 0x75, 0x84, 0x18, 0x2e, 0x40, 0xcd, 0x4c, 0x8b, 0x48, 0xf6, 0x19, 0x87, 0xa0, 0x7a, 0xe6, 0xff, 0x61, 0x96, 0xe5, 0x43, 0x53, 0x24, 0xb3, 0x54, 0x6f, 0x77, 0x12, 0xbf, 0x45, 0x3a, 0x1f, 0x31, 0xca, 0xc5, 0x77, 0x8f, 0x94, 0x64, 0x7b, 0x65, 0x6d, 0xcb, 0x4f, 0xdd, 0x8b, 0x58, 0xad, 0x36, 0x45, 0xfa, 0x1d, 0x54, 0xfa, 0x7d, 0x8e, 0xa1, 0xb6, 0x27, 0xf6, 0x5d, 0x68, 0xd4, 0xb, 0x92, 0x56, 0x77, 0x8b, 0x46, 0x95, 0xc, 0xc2, 0xd1, 0xe4, 0xc3, 0x31, 0x3d, 0x54, 0x21, 0x5, 0xa3, 0x47, 0x6a, 0x7a, 0xe2, 0xe5, 0x18, 0x77, 0x25, 0x4b, 0xd7, 0x56, 0xe7, 0xfb, 0x55, 0xa5, 0x55, 0x26, 0xa3, 0x2b, 0x78, 0xc9, 0x5a, 0xbd, 0x16, 0x9d, 0xa1, 0x92, 0x9c, 0xb3, 0xa1, 0xa0, 0x98, 0xd2, 0x46, 0xf0, 0x29, 0xaf, 0x5d, 0xcd, 0xb, 0xed, 0x45, 0x46, 0xb2, 0x55, 0x9a, 0x6a, 0x47, 0x39, 0x39, 0x6c, 0x2e, 0x22, 0x2c, 0x77, 0xcc, 0x4d, 0x3a, 0xb4, 0x72, 0x62, 0xcb, 0xe3, 0x63, 0x46, 0x5c, 0xcb, 0x32, 0x23, 0x45, 0x2a, 0x35, 0xb9, 0x1c, 0x15, 0xd4, 0xf2, 0x82, 0x2f, 0xd7, 0x5a, 0x91, 0xa1, 0x91, 0xed, 0xb, 0x19, 0xef, 0xd, 0x46, 0x89, 0xa2, 0xf7, 0x93, 0xd3, 0x16, 0x7, 0xdd, 0xfa, 0xb5, 0xfe, 0x2, 0x92, 0xeb, 0x31, 0x26, 0xc6, 0x72, 0x9b, 0x37, 0xbd, 0xf4, 0xee, 0xf8, 0x8, 0xa1, 0xa7, 0x15, 0x98, 0x2b, 0xeb, 0x2f, 0x9d, 0x6a, 0xd6, 0x57, 0x1d, 0x23, 0x46, 0xac, 0x4c, 0xc7, 0x53, 0x74, 0xb4, 0x64, 0x1a, 0x2b, 0xe6, 0x21, 0x40, 0xdc, 0xef, 0x6a, 0x10, 0x5e, 0xb3, 0xaa, 0x59, 0x32, 0x7, 0xde, 0x59, 0x5c, 0x43, 0x9c, 0x8e, 0x94, 0xe8, 0x59, 0x6f, 0x8d, 0x99, 0x56, 0x90, 0x81, 0x3b, 0x89, 0x7f, 0x15, 0x6, 0x70, 0x37, 0x4d, 0xfd, 0x9b, 0xa0, 0x58, 0x8c, 0x7a, 0xb7, 0x60, 0x39, 0x58, 0x56, 0x5b, 0xc3, 0x1c, 0x27, 0x4e, 0xd4, 0x2d, 0xa1, 0xba, 0x94, 0x37, 0x2e, 0xbe, 0xb, 0x4f, 0x8, 0x61, 0x1d, 0xfe, 0x26, 0x12, 0x7e, 0x7d, 0x5, 0xaf, 0xf7, 0xb9, 0xde, 0x63, 0xb3, 0x60, 0xb8, 0xc3, 0xe7, 0x9b, 0x0, 0x57, 0xf9, 0x2b, 0x40, 0x34, 0x8c, 0x4a, 0x6c, 0xf8, 0xc2, 0x38, 0xbd, 0xd3, 0x3c, 0x20, 0x49, 0x26, 0xc3, 0x42, 0x17, 0xd, 0x9c, 0x15, 0xdc, 0x3d, 0x69, 0xc7, 0xe6, 0x1f, 0x2a, 0x94, 0x80, 0x7a, 0x4b, 0x84, 0xd0, 0x4d, 0xf5, 0x99, 0x41, 0x1c, 0x11, 0xde, 0xeb, 0xea, 0xc2, 0x43, 0x68, 0x1f, 0xde, 0xc8, 0xbe, 0x38, 0x2e, 0xee, 0xad, 0xed, 0xf6, 0x1f, 0x72, 0x86, 0x46, 0xfd, 0xf9, 0xa4, 0x21, 0xea, 0x23, 0x1f, 0xbb, 0xde, 0x66, 0x13, 0xde, 0x7a, 0x4f, 0x7b, 0xda, 0x12, 0x5a, 0xf5, 0xdf, 0x11, 0x49, 0xac, 0xca, 0xaa, 0xbe, 0x2c, 0x2a, 0x1, 0x84, 0x1d, 0x24, 0xe1, 0x65, 0xae, 0x76, 0x80, 0x8c, 0xa9, 0xaf, 0x94, 0xef, 0xfb, 0x1c, 0xf3, 0xb1, 0xe3, 0x1c, 0x76, 0x55, 0x59, 0xae, 0xfe, 0xfd, 0xcc, 0xe1, 0x22, 0xbd, 0xfe, 0x56, 0x7e, 0x67, 0xc9, 0x70, 0xe6, 0xb4, 0xb, 0x46, 0x8d, 0xa0, 0xad, 0x6b, 0x82, 0xba, 0xcc, 0xcd, 0xcb, 0x29, 0x37, 0x22, 0x45, 0xa, 0xea, 0xae, 0x80, 0x1a, 0x34, 0x2a, 0xdc, 0x7f, 0x1f, 0x44, 0x3d, 0x99, 0x35, 0xf5, 0xd4, 0x38, 0xa1, 0x63, 0x61, 0xa0, 0x87, 0x22, 0x8c, 0x2e, 0x26, 0xc1, 0x2c, 0xb5, 0x9b, 0xc9, 0x87, 0x74, 0xcb, 0xdd, 0x9b, 0x49, 0xb2, 0xa0, 0x65, 0xc8, 0xa7, 0x67, 0x33, 0x4c, 0xf1, 0x6d, 0xd2, 0x71, 0x7c, 0xf4, 0x5a, 0xc, 0x8e, 0xde, 0x97, 0xb4, 0xf4, 0xfa, 0xf9, 0x9a, 0xcb, 0x1, 0x3b, 0x5e, 0x0, 0x79, 0xf2, 0xb3, 0xa6, 0xa2, 0xcb, 0x82, 0xb6, 0x11, 0xdc, 0x78, 0x18, 0x22, 0x1a, 0x67, 0x9c, 0x0, 0x73, 0x77, 0xed, 0xbb, 0x9f, 0xd0, 0xa2, 0x0, 0xb, 0x32, 0xc6, 0xa1, 0x7e, 0x1b, 0xb, 0xe9, 0xb9, 0x12, 0x8, 0xed, 0xd3, 0xe4, 0x17, 0xe6, 0x31, 0xc2, 0xe6, 0xd2, 0x3d, 0xfa, 0x76, 0x3f, 0xd7, 0x92, 0x97, 0x2f, 0x9a, 0x9b, 0x1c, 0x8f, 0xa4, 0x2f, 0xa, 0xf5, 0x29, 0x7e, 0xb4, 0x9b, 0x7, 0x76, 0xba, 0xb8, 0x10, 0xb6, 0x85, 0x6e, 0x1, 0x75, 0xeb, 0x1b, 0x87, 0xec, 0x83, 0xcd, 0x2c, 0xd1, 0x2e, 0x2c, 0x5c, 0x16, 0x10, 0xe1, 0xee, 0xbe, 0x9e, 0x66, 0x5a, 0x6c, 0x34, 0x67, 0xb8, 0x70, 0xa1, 0x57, 0x4e, 0x6f, 0x2c, 0xfc, 0x86, 0x56, 0x87, 0x51, 0x5d, 0x8a, 0x35, 0xf5, 0xe9, 0xd, 0x85, 0x13, 0x8c, 0x3d, 0x2c, 0x98, 0x23, 0x69, 0x6e, 0x25, 0x31, 0x7b, 0x1b, 0xa5, 0xb0, 0xbe, 0x62, 0x3f, 0xdc, 0x6c, 0xaa, 0x10, 0x41, 0x37, 0x4d, 0x39, 0x85, 0x78, 0x16, 0x7f, 0x43, 0x52, 0xf3, 0x15, 0xae, 0x9d, 0xb4, 0x25, 0x5a, 0x32, 0xee, 0x49, 0x10, 0xf2, 0x74, 0x26, 0x33, 0xd7, 0x9d, 0x5b, 0x5f, 0x10, 0x5a, 0xdb, 0x63, 0xb0, 0xa3, 0xd7, 0x76, 0x35, 0xb, 0x85, 0x74, 0x47, 0x7e, 0x57, 0x2e, 0xfd, 0xca, 0x9, 0x57, 0x44, 0x45, 0xec, 0xe8, 0xdd, 0x63, 0x82, 0xfc, 0x21, 0xd7, 0xb9, 0xd6, 0x8b, 0x3a, 0x4b, 0xfc, 0xa1, 0x58, 0xdf, 0x4a, 0x7a, 0xa4, 0xcc, 0x1c, 0xd, 0xa1, 0x1, 0x6c, 0x36, 0x4c, 0x9f, 0xdc, 0x62, 0xab, 0xc9, 0x91, 0xa3, 0x50, 0x4e, 0xab, 0xb5, 0x90, 0x80, 0x9b, 0x2d, 0x41, 0xe4, 0xd5, 0x1c, 0xcb, 0xb0, 0xe9, 0x2e, 0x87, 0x52, 0xa4, 0xc0, 0xf7, 0x2e, 0x74, 0xca, 0x7e, 0x45, 0xeb, 0x19, 0x68, 0x19, 0x1d, 0x56, 0x4d, 0x81, 0x31, 0x31, 0xdb, 0x2b, 0x32, 0x12, 0x79, 0xfe, 0x7a, 0x10, 0x4a, 0xbc, 0x6e, 0x33, 0xff, 0xac, 0xc5, 0x53, 0xd0, 0xa6, 0x2d, 0x69, 0xed, 0x3c, 0xb6, 0x77, 0x98, 0xbf, 0x8e, 0x92, 0x7d, 0x4d, 0xb0, 0x2a, 0x35, 0x33, 0x4e, 0x94, 0x66, 0x5, 0x28, 0x58, 0xe6, 0x82, 0x8e, 0xc, 0x28, 0x54, 0x8, 0x80, 0x74, 0x2e, 0xd5, 0x49, 0x23, 0xba, 0xab, 0x85, 0x92, 0x2e, 0x5, 0xe0, 0xb6, 0x6e, 0xeb, 0x40, 0x14, 0x53, 0xc8, 0x2d, 0x5b, 0x4d, 0x7f, 0xf2, 0x52, 0x97, 0xc1, 0xf9, 0xf1, 0x35, 0x8b, 0xcf, 0xeb, 0x5d, 0x52, 0x94, 0x77, 0x3d, 0xe2, 0x3, 0xd7, 0xf2, 0xff, 0x9f, 0xad, 0x19, 0xfe, 0xdc, 0xe6, 0xc1, 0x28, 0x96, 0xc1, 0xae, 0x44, 0xab, 0xe0, 0x90, 0x5e, 0xa8, 0xd, 0x24, 0xbc, 0xaa, 0xd9, 0x27, 0xaa, 0xfc, 0x6a, 0xfd, 0x48, 0xdd, 0xe5, 0x26, 0xf3, 0xdd, 0xf4, 0xe6, 0xcf, 0x94, 0xea, 0xbb, 0x9e, 0x99, 0xca, 0x68, 0x52, 0x36, 0xd, 0xf3, 0xdd, 0x2b, 0xfc, 0x79, 0x7, 0xe4, 0x2a, 0x35, 0x74, 0x4b, 0xa7, 0x20, 0xfb, 0xf, 0x36, 0x6e, 0xed, 0xaa, 0x8e, 0x86, 0xe4, 0x40, 0x59, 0xf6, 0x4b, 0x38, 0x4e, 0x29, 0x6f, 0x0, 0xac, 0xfb, 0x46, 0x94, 0x72, 0xad, 0x1, 0x23, 0x2e, 0x4a, 0x48, 0x33, 0xd1, 0x1a, 0x2c, 0xf0, 0x97, 0xc7, 0x54, 0x92, 0xe2, 0xaa, 0x1f, 0xd7, 0xe4, 0x25, 0x8, 0x21, 0x95, 0xbf, 0x43, 0xf4, 0xce, 0xf3, 0xb3, 0x47, 0x7d, 0x16, 0xb6, 0x6, 0x86, 0x6f, 0x1a, 0xa6, 0x26, 0x44, 0xf1, 0xa3, 0x11, 0x19, 0xb9, 0xbc, 0x78, 0x7e, 0xcf, 0x70, 0x68, 0x64, 0x68, 0xa9, 0x6a, 0xfc, 0xce, 0x82, 0x62, 0x5c, 0x86, 0xc, 0xeb, 0xe8, 0x2, 0xc2, 0x70, 0x60, 0x5e, 0xa0, 0x3, 0xb2, 0xb4, 0x1, 0x24, 0xe8, 0xca, 0x4e, 0xbc, 0x78, 0xa9, 0xce, 0x22, 0x6c, 0xbb, 0x3a, 0xe7, 0x4a, 0x7f, 0xc8, 0x29, 0xf5, 0x3a, 0x51, 0xd9, 0x25, 0x3, 0x8c, 0xe9, 0xa3, 0xd3, 0x68, 0x1c, 0xd5, 0xd, 0xc4, 0x63, 0xac, 0x34, 0x88, 0xc9, 0x81, 0xdb, 0xb0, 0xed, 0x6e, 0x4b, 0xe1, 0x27, 0xcd, 0x3a, 0xec, 0x47, 0x37, 0x65, 0xc2, 0xaa, 0x76, 0x26, 0x11, 0xa6, 0x41, 0x84, 0x80, 0x22, 0xe3, 0x3a, 0xe6, 0xb5, 0xa1, 0xbd, 0x57, 0xd1, 0x72, 0x21, 0xd1, 0x72, 0xa1, 0x77, 0x5a, 0xc5, 0x4d, 0xae, 0x58, 0xa1, 0xb0, 0xe2, 0x1c, 0x54, 0x85, 0x3b, 0xa5, 0x9b, 0xa4, 0x6c, 0xce, 0xc, 0x62, 0x39, 0x9a, 0x54, 0x7d, 0xe3, 0x75, 0x57, 0xff, 0x4b, 0x66, 0x94, 0xb8, 0x6f, 0xef, 0xe0, 0x62, 0xaf, 0x6e, 0xfc, 0xc1, 0x3, 0xc4, 0xa1, 0xa2, 0xbd, 0x6, 0x70, 0xe, 0x87, 0x69, 0xe4, 0xc7, 0x6, 0x41, 0x1, 0x1e, 0x54, 0x24, 0xc2, 0xa2, 0xf0, 0xa6, 0xa2, 0xc8, 0xef, 0x98, 0x97, 0x74, 0xfd, 0x59, 0xc0, 0x80, 0xe, 0xb0, 0xcb, 0x19, 0xed, 0xb5, 0x1b, 0x69, 0xe8, 0x8b, 0xf4, 0xfa, 0xea, 0x43, 0xf5, 0xc2, 0xc2, 0x81, 0x8f, 0x9b, 0x95, 0xe2, 0x7b, 0xc6, 0x8f, 0x60, 0xbf, 0xbb, 0xbc, 0xdc, 0x77, 0x8c, 0x6f, 0x6b, 0x11, 0x63, 0x33, 0xdb, 0xc1, 0x7d, 0xd3, 0x52, 0xe2, 0xe9, 0x7b, 0xfb, 0x5e, 0x33, 0xeb, 0xe9, 0xb3, 0xe5, 0x18, 0xf9, 0x3e, 0x86, 0x6, 0x7e, 0x75, 0xf0, 0x64, 0xa7, 0x14, 0xdb, 0x63, 0x4e, 0x37, 0xce, 0x71, 0xd4, 0xba, 0xd6, 0x5f, 0xe2, 0xbb, 0xf3, 0x26, 0xea, 0x27, 0x93, 0xc8, 0x7c, 0xb4, 0x45, 0x72, 0xc9, 0x65, 0xad, 0x65, 0x98, 0x31, 0x2b, 0xd9, 0x83, 0x8d, 0xfa, 0x8e, 0x1b, 0x59, 0x9c, 0xcb, 0x87, 0x1, 0xdc, 0xb3, 0x97, 0xe8, 0x46, 0x6a, 0x85, 0x24, 0xb5, 0x68, 0xe7, 0x7b, 0xe9, 0x5c, 0xb9, 0x6c, 0x79, 0xa6, 0x4d, 0xc1, 0x80, 0xa7, 0x36, 0xa6, 0xd9, 0x96, 0xee, 0xb8, 0x96, 0xdc, 0xd9, 0xd9, 0xaa, 0xa8, 0xb6, 0xa4, 0xa9, 0xae, 0xee, 0x6f, 0x21, 0x3d, 0xf1, 0xa0, 0x71, 0xf6, 0xf3, 0x9, 0xc1, 0xab, 0xad, 0x52, 0xfd, 0x47, 0x7f, 0x6f, 0x70, 0x7f, 0x87, 0x6f, 0x40, 0xeb, 0xff, 0x35, 0x30, 0x19, 0x5e, 0xc3, 0x98, 0x87, 0xe3, 0xd7, 0x64, 0x48, 0x8e, 0xc4, 0xc7, 0x61, 0x8f, 0xfb, 0xe7, 0x92, 0x65, 0xee, 0xe0, 0x8c, 0xb8, 0x9, 0xcd, 0xbd, 0xf, 0x7d, 0x38, 0xa8, 0xa2, 0xd2, 0x92, 0x82, 0x26, 0x61, 0xc2, 0x27, 0x3d, 0x82, 0x70, 0xd1, 0xe0, 0xb2, 0xbd, 0xa7, 0xdb, 0xf1, 0x36, 0x23, 0x49, 0xa9, 0x20, 0x6b, 0xa2, 0x5c, 0xd, 0xc1, 0xc6, 0x68, 0xb3, 0x9d, 0xb7, 0x72, 0x4e, 0x29, 0x5, 0x6, 0x18, 0xe4, 0x3b, 0xba, 0x5, 0xf5, 0xf, 0x20, 0x2d, 0x9a, 0x2, 0x68, 0x94, 0xeb, 0x20, 0xfe, 0xe7, 0xd6, 0xfc, 0xbb, 0x22, 0xd7, 0xde, 0x3e, 0xb8, 0x9e, 0xef, 0xf4, 0x28, 0xaa, 0xa1, 0xb3, 0xf1, 0x8a, 0x98, 0x47, 0xfd, 0x5f, 0xcf, 0xe6, 0xaf, 0xb9, 0xea, 0xd2, 0xc8, 0x64, 0xe0, 0xdb, 0x5c, 0xc, 0x75, 0x33, 0xe5, 0x74, 0xcf, 0xcb, 0xd8, 0x2f, 0x14, 0xdb, 0x20, 0xf8, 0x51, 0x97, 0x97, 0x22, 0x27, 0x7a, 0xeb, 0xe, 0xf5, 0x79, 0x80, 0x23, 0x36, 0xc9, 0xd, 0x3b, 0xe7, 0x8b, 0x47, 0xde, 0xd5, 0xc8, 0x29, 0xe8, 0x39, 0x56, 0xfc, 0x95, 0x87, 0xac, 0xd1, 0xb0, 0x15, 0x79, 0x18, 0xc4, 0xa1, 0xdb, 0x36, 0x76, 0xe4, 0x0, 0x1f, 0x6, 0x81, 0x28, 0xcd, 0x4c, 0x45, 0x11, 0x38, 0x5f, 0x4a, 0xc3, 0x9e, 0xbc, 0x68, 0x7a, 0xee, 0xe6, 0xec, 0x7d, 0x75, 0x35, 0x39, 0x10, 0x62, 0x19, 0x1f, 0x86, 0xb4, 0xa2, 0xf1, 0x81, 0x8e, 0x6d, 0x1d, 0xdb, 0xb2, 0x4e, 0x1e, 0x7c, 0xf7, 0x43, 0xe3, 0x99, 0x10, 0x6a, 0xa1, 0xc3, 0x9e, 0x52, 0xad, 0x7e, 0xc2, 0xbe, 0x7b, 0xdf, 0xb3, 0x2b, 0x54, 0xe9, 0x23, 0xd5, 0xe, 0xf8, 0xad, 0x4e, 0xbc, 0x6a, 0x80, 0xc6, 0x56, 0x14, 0xee, 0xa4, 0xaa, 0x5d, 0x7, 0xf4, 0x8f, 0xc5, 0x97, 0xa2, 0x9e, 0xe2, 0x0, 0x26, 0xde, 0xf2, 0xf3, 0x0, 0xc7, 0xd3, 0xca, 0x72, 0x7e, 0x88, 0x57, 0xa0, 0x98, 0xa0, 0xfb, 0x22, 0xf2, 0xc6, 0x75, 0x72, 0x68, 0xe3, 0x90, 0xf8, 0x39, 0xbe, 0x20, 0xd4, 0x59, 0x83, 0xa, 0x9e, 0x3d, 0xac, 0x71, 0xef, 0x41, 0x82, 0x15, 0xd9, 0xb8, 0x9b, 0xa5, 0x59, 0xa8, 0x3, 0x41, 0xe1, 0x59, 0xd, 0xc9, 0x64, 0xb8, 0xa6, 0xab, 0xa0, 0x7f, 0xaa, 0xe4, 0xa9, 0xad, 0x8e, 0x59, 0x69, 0xe9, 0x47, 0x1d, 0x53, 0xe4, 0xda, 0x76, 0x88, 0x9a, 0xf5, 0xf9, 0x92, 0x3b, 0x18, 0xbb, 0x58, 0x4d, 0x71, 0xe3, 0x2, 0x31, 0xe0, 0xeb, 0xfd, 0x9f, 0xa4, 0x89, 0x1a, 0xf3, 0x40, 0x7, 0xc1, 0x23, 0x5a, 0x9c, 0xfb, 0x2b, 0xd, 0xb0, 0xef, 0xc1, 0xa5, 0x41, 0x7c, 0xbd, 0x53, 0xf6, 0x94, 0xc6, 0xf3, 0x88, 0x2e, 0x85, 0x53, 0xa0, 0xe0, 0x1f, 0x7a, 0xe3, 0x4c, 0x24, 0x43, 0x9a, 0x97, 0xde, 0xea, 0xce, 0x8b, 0xdd, 0x2f, 0x59, 0x51, 0x5d, 0xe0, 0x76, 0x5, 0x89, 0xff, 0x62, 0x30, 0xd6, 0x2, 0xbe, 0x38, 0x93, 0xd2, 0x7e, 0x34, 0xdc, 0xec, 0xce, 0x7b, 0x8e, 0x31, 0xd, 0x87, 0x79, 0xf, 0xff, 0x49, 0xae, 0x5b, 0x53, 0xf, 0xdf, 0xdf, 0xf7, 0x1e, 0x61, 0xbe, 0x2e, 0x1b, 0x90, 0xd4, 0x20, 0x41, 0x94, 0xef, 0xd2, 0x63, 0xd1, 0xcc, 0xff, 0x45, 0x84, 0x93, 0x8c, 0x6, 0x66, 0x6b, 0xa, 0xb6, 0x75, 0xa6, 0xcc, 0x5c, 0xa0, 0xc6, 0x57, 0x88, 0x51, 0x73, 0xe, 0x28, 0x1c, 0x10, 0x7b, 0x58, 0xa2, 0x70, 0x99, 0x64, 0x75, 0x41, 0xcb, 0x2b, 0x9c, 0x46, 0x62, 0x66, 0x62, 0x45, 0x11, 0x37, 0xbe, 0x1b, 0x34, 0x43, 0x8e, 0xd8, 0x25, 0xc4, 0x56, 0x28, 0xd7, 0xdd, 0x49, 0x30, 0x37, 0x70, 0xbc, 0x33, 0x30, 0xe5, 0xe9, 0x8e, 0x9a, 0xda, 0x7a, 0x1c, 0xcb, 0x69, 0x4e, 0xe5, 0xe0, 0xb, 0x27, 0xf7, 0xa5, 0xaa, 0x0, 0xd, 0x1d, 0x9d, 0x1f, 0x76, 0x14, 0x53, 0x2b, 0xa4, 0xb8, 0xab, 0x8a, 0x92, 0x36, 0x7b, 0x69, 0x46, 0x24, 0x7b, 0x5f, 0x69, 0xf8, 0x70, 0xde, 0x10, 0x77, 0x53, 0x25, 0xc6, 0x5a, 0xde, 0x56, 0xa7, 0xd0, 0x63, 0x75, 0x73, 0x71, 0x73, 0x9e, 0x5, 0x3e, 0x97, 0x11, 0x79, 0xd2, 0xbb, 0x65, 0x17, 0xc7, 0xd9, 0xf8, 0xef, 0x37, 0xa7, 0x8d, 0xd3, 0xb9, 0xd1, 0x5c, 0x9d, 0x2f, 0x2, 0x1d, 0x4b, 0x81, 0xff, 0xe9, 0x43, 0x73, 0x53, 0xa9, 0x65, 0xd7, 0x9b, 0x82, 0x17, 0x7b, 0x67, 0x98, 0xa7, 0xe, 0xf8, 0x51, 0x1d, 0x27, 0xff, 0xf2, 0x15, 0xb7, 0x41, 0xb9},
+               output224: []byte{0xaf, 0x82, 0x8b, 0x69, 0x42, 0x3d, 0x5b, 0x66, 0x7a, 0xa9, 0x2c, 0xf1, 0x65, 0x8c, 0x9a, 0x70, 0xd2, 0x3b, 0xe6, 0x4f, 0x61, 0xbc, 0xd8, 0x7, 0x82, 0xde, 0x58, 0x86},
+               output256: []byte{0xc8, 0xd6, 0x55, 0x66, 0xe3, 0x46, 0xb9, 0xd8, 0xd5, 0xee, 0x75, 0xc, 0x13, 0x45, 0x7d, 0xd, 0x5b, 0x18, 0x22, 0x3b, 0x5a, 0x92, 0xe3, 0xa5, 0x42, 0x1d, 0xd1, 0x5b, 0x33, 0x49, 0xfe, 0xef},
+               output384: []byte{0x74, 0xb8, 0x63, 0x43, 0xaa, 0xfc, 0x1b, 0xb0, 0x7d, 0x40, 0xbe, 0x7b, 0xfe, 0xbe, 0xcc, 0xf4, 0xba, 0x3b, 0x12, 0xdc, 0xf6, 0x81, 0xf3, 0x45, 0x8d, 0xe2, 0x8, 0x82, 0x9f, 0x70, 0x4d, 0x35, 0x12, 0xb7, 0xc6, 0xc, 0x7d, 0x21, 0x1a, 0x54, 0x9e, 0xc8, 0xc9, 0xd4, 0xf4, 0x80, 0x62, 0x57},
+               output512: []byte{0xc3, 0x4, 0xb2, 0x9c, 0x9f, 0x46, 0x71, 0x87, 0xfc, 0xad, 0xa4, 0x2b, 0xc3, 0x61, 0x16, 0x58, 0x4d, 0xee, 0x21, 0x52, 0x1, 0xd2, 0xe8, 0xb7, 0xd9, 0xcf, 0x95, 0x5, 0x88, 0x82, 0x22, 0xa4, 0x43, 0xd0, 0x58, 0xf3, 0x7a, 0x7e, 0x1d, 0xda, 0x5, 0xd9, 0x1a, 0xcc, 0x35, 0x39, 0x15, 0x95, 0xb6, 0xaa, 0x7b, 0x67, 0x86, 0xe2, 0x24, 0xfe, 0xbe, 0x70, 0x59, 0x70, 0x1d, 0x99, 0x64, 0xb2}},
+       testcase{
+               msg:       []byte{0xae, 0x82, 0xef, 0x9, 0xb7, 0x11, 0x95, 0x1f, 0x60, 0x82, 0xb1, 0xbd, 0xc5, 0xb1, 0x75, 0xc8, 0x10, 0x10, 0xe3, 0x98, 0xb8, 0xf3, 0xb1, 0x8f, 0x5a, 0xb9, 0x9f, 0x78, 0xcb, 0x53, 0xa5, 0xf9, 0x53, 0xbe, 0x9, 0xc9, 0x8b, 0xd9, 0x72, 0x37, 0x40, 0xc7, 0xa4, 0xe6, 0xd2, 0x6a, 0x64, 0xaa, 0x62, 0xc6, 0x97, 0x3f, 0x60, 0xda, 0x56, 0xe, 0x14, 0xee, 0xd6, 0x3d, 0x0, 0x1f, 0x6e, 0x28, 0x17, 0x1, 0x77, 0x3c, 0x34, 0xa4, 0x12, 0x60, 0xa2, 0xae, 0x67, 0x5d, 0xe5, 0x43, 0xf2, 0xbf, 0x2f, 0xee, 0xa4, 0xb1, 0x7e, 0xbd, 0x92, 0x8a, 0xad, 0x65, 0xa1, 0x7f, 0x7f, 0xbc, 0x4b, 0x75, 0x70, 0xfe, 0xfc, 0xa8, 0x4, 0x95, 0x6d, 0x4d, 0x93, 0x53, 0x93, 0x7c, 0x3f, 0xaa, 0x15, 0x51, 0x6c, 0x8f, 0xc1, 0x40, 0xee, 0x8f, 0x91, 0xf2, 0x71, 0x1e, 0x3a, 0xc0, 0x87, 0x9a, 0x1d, 0x3c, 0xf7, 0xaf, 0x79, 0x63, 0xcf, 0x82, 0xe0, 0x8e, 0xee, 0x5, 0xd3, 0xd9, 0x13, 0xd2, 0xb7, 0xe5, 0x68, 0xca, 0xb7, 0x65, 0x5a, 0x8b, 0xc5, 0x43, 0x61, 0x93, 0x64, 0x1d, 0x76, 0xf7, 0x44, 0x3b, 0xef, 0x83, 0xd5, 0xf4, 0x68, 0xd8, 0x4c, 0x80, 0xb8, 0xd3, 0x72, 0x50, 0xf0, 0x6b, 0x37, 0x78, 0x1e, 0xfc, 0xd, 0x88, 0x5b, 0xc7, 0x35, 0x8a, 0x2b, 0x90, 0xfd, 0xd5, 0xcb, 0xa3, 0xdf, 0xdd, 0xc, 0x57, 0xb8, 0xf6, 0x67, 0x50, 0x16, 0x75, 0x46, 0x49, 0x4e, 0x31, 0xbb, 0x75, 0x1a, 0x9e, 0x8, 0xe2, 0x9, 0x95, 0x2d, 0xc1, 0xef, 0xaa, 0x2b, 0x12, 0x10, 0xe6, 0x9d, 0x97, 0x44, 0x54, 0xef, 0x55, 0x95, 0x2e, 0x35, 0xca, 0x7f, 0x40, 0xcd, 0xe9, 0x44, 0xc6, 0x65, 0xd9, 0x58, 0x55, 0x80, 0xc7, 0xb, 0x8f, 0xcf, 0xf5, 0xbb, 0xb5, 0x63, 0x5f, 0x5d, 0x8d, 0x54, 0x93, 0x56, 0xf4, 0x8d, 0x4b, 0x5f, 0x17, 0x3c, 0x54, 0x1c, 0xfc, 0x0, 0xc3, 0xf4, 0x26, 0x95, 0x54, 0x1c, 0xb7, 0x78, 0x44, 0xf, 0x64, 0xed, 0xea, 0x6d, 0xa, 0xc8, 0xdf, 0xd3, 0x80, 0x23, 0xc7, 0xa0, 0x13, 0xfd, 0xc2, 0x8a, 0xb3, 0xc5, 0x7f, 0xad, 0x93, 0x89, 0x37, 0xcb, 0xcf, 0xbc, 0xd9, 0x41, 0xd3, 0x15, 0xe7, 0x51, 0x46, 0x54, 0x28, 0xb8, 0x22, 0x0, 0xb7, 0x5b, 0x3a, 0xec, 0x17, 0x76, 0xc1, 0x80, 0x15, 0xaa, 0x39, 0xe2, 0x5e, 0x16, 0x2a, 0xdb, 0xa, 0xe2, 0x4c, 0x19, 0x60, 0x9f, 0x36, 0x5f, 0x45, 0xbb, 0xb8, 0x19, 0xf, 0xab, 0xde, 0xbf, 0xa0, 0x42, 0x7, 0x6f, 0xcb, 0xf, 0x2c, 0xba, 0x3b, 0xf2, 0x58, 0xf6, 0xfe, 0xee, 0xbe, 0x38, 0x23, 0xbe, 0xbd, 0x9d, 0xba, 0x95, 0xcd, 0xe0, 0x36, 0x97, 0xd6, 0x72, 0x2a, 0x3a, 0x64, 0xb9, 0x26, 0x31, 0x1e, 0xc0, 0x3e, 0x6b, 0x56, 0xea, 0x4, 0x7d, 0x2f, 0x5c, 0x28, 0x73, 0xc, 0xe7, 0xb5, 0x60, 0xfd, 0xe8, 0xeb, 0xfb, 0x1b, 0xa7, 0x4a, 0xa1, 0xcd, 0x2e, 0x57, 0xa1, 0x28, 0x47, 0xbf, 0x51, 0xc, 0x9b, 0x16, 0xae, 0xf0, 0xc2, 0x5a, 0xe3, 0x97, 0xdd, 0x60, 0x22, 0xce, 0xb1, 0x90, 0x2c, 0x8e, 0xd2, 0xe2, 0x40, 0x54, 0x87, 0x5b, 0x5c, 0xc, 0x9e, 0x6b, 0xe8, 0x7e, 0x9f, 0x40, 0xc9, 0x9b, 0x85, 0xf9, 0xa, 0x47, 0x79, 0xc1, 0x9, 0x13, 0xf, 0x2, 0x36, 0xd1, 0xc1, 0x29, 0xdc, 0x29, 0x62, 0xbb, 0x57, 0x47, 0x9e, 0x65, 0xbc, 0x99, 0xd5, 0xdf, 0xb6, 0xbb, 0xc7, 0xd9, 0x6a, 0x29, 0xa, 0xdc, 0xf3, 0xae, 0x9e, 0xcc, 0xa7, 0x55, 0x87, 0xdc, 0xcb, 0x2c, 0xc3, 0x18, 0xda, 0x3a, 0x66, 0x9d, 0xa9, 0x2c, 0xe2, 0xaf, 0x33, 0x38, 0x97, 0x44, 0x8a, 0x66, 0x9f, 0x1a, 0x4c, 0x12, 0x8d, 0xa3, 0xf9, 0x64, 0xa0, 0x1a, 0xd6, 0x4e, 0x13, 0x2c, 0xd9, 0x40, 0x16, 0x5f, 0x57, 0x8, 0xb1, 0x58, 0x36, 0x23, 0xd2, 0xc, 0xc5, 0xa3, 0xad, 0x9f, 0xb8, 0x60, 0xf3, 0x42, 0xa4, 0xd4, 0x7e, 0x2c, 0xbe, 0x1c, 0x43, 0x57, 0x7c, 0x9b, 0x98, 0x34, 0x1e, 0x15, 0xb2, 0x85, 0xa2, 0x53, 0xc3, 0x2b, 0x3b, 0x0, 0xc3, 0x9f, 0x3f, 0x8f, 0x99, 0x83, 0xfb, 0xfd, 0x2d, 0x4f, 0x21, 0x7c, 0x85, 0x79, 0x60, 0xa7, 0xee, 0x6c, 0x96, 0x2c, 0x2c, 0xde, 0x25, 0x47, 0x24, 0x9f, 0xa5, 0x6f, 0x97, 0xb6, 0x85, 0x73, 0x48, 0xd8, 0xa4, 0x49, 0xce, 0x8d, 0xc8, 0x3c, 0xc9, 0x9f, 0xb, 0xfc, 0x29, 0xe2, 0x14, 0xe0, 0xa3, 0xdb, 0x6a, 0x63, 0x6b, 0xfc, 0xdf, 0xb1, 0x5a, 0x53, 0x79, 0x79, 0x56, 0x51, 0x61, 0xec, 0xdf, 0xe6, 0xa4, 0xc2, 0x9d, 0x88, 0xf4, 0xe4, 0x65, 0x66, 0xe, 0x4b, 0x4a, 0x49, 0x3b, 0x33, 0x95, 0xac, 0x96, 0x96, 0xe5, 0xbf, 0x5f, 0x4d, 0x2f, 0xc6, 0x58, 0x7e, 0x67, 0x3f, 0x8b, 0x65, 0xbe, 0xce, 0x1c, 0xa4, 0x41, 0x73, 0x82, 0xa3, 0xfe, 0x11, 0x21, 0x5c, 0x5e, 0xac, 0x59, 0x1d, 0xda, 0xb, 0xe4, 0xa9, 0xf2, 0xfe, 0xb, 0x1b, 0x18, 0x32, 0x52, 0x80, 0x24, 0x1b, 0xf7, 0xdf, 0xc6, 0x21, 0x90, 0x1a, 0xe, 0x9f, 0x4c, 0xd4, 0x71, 0x40, 0x10, 0x64, 0xfa, 0xb7, 0x33, 0x73, 0xbe, 0xd, 0x80, 0xf, 0xe1, 0xca, 0x29, 0x6b, 0x27, 0x20, 0xd, 0xe5, 0x15, 0x8c, 0x17, 0xe6, 0x42, 0x16, 0xf0, 0x1e, 0xb1, 0x6e, 0x58, 0xb9, 0xc9, 0xdd, 0x51, 0x83, 0x71, 0x1, 0x44, 0x75, 0x58, 0xdc, 0xd0, 0x7c, 0x7b, 0x78, 0x2b, 0x60, 0x16, 0x31, 0x3c, 0xbd, 0xfa, 0x95, 0xc0, 0x7b, 0x9c, 0x2d, 0xd2, 0x5d, 0xfb, 0x36, 0x45, 0xd8, 0xf2, 0x2c, 0x3d, 0xee, 0x68, 0xb1, 0xa4, 0x3c, 0xba, 0x11, 0x4e, 0xd2, 0x7a, 0x6f, 0x3e, 0x55, 0xcd, 0xdc, 0x7f, 0xa8, 0x56, 0xfb, 0xd0, 0x7d, 0xdb, 0x72, 0xf5, 0x40, 0xd4, 0x6f, 0x78, 0xe, 0xf5, 0xed, 0xfa, 0x68, 0xf9, 0xc2, 0x8f, 0xec, 0xfc, 0xd3, 0xe9, 0x67, 0xa0, 0x30, 0x57, 0xa, 0xba, 0x49, 0xc8, 0xcb, 0x2a, 0x17, 0x8d, 0x25, 0x57, 0xe6, 0xb9, 0xa3, 0xfb, 0x38, 0x7e, 0xd2, 0xf6, 0xed, 0xc7, 0x85, 0x6c, 0x2b, 0x5, 0x16, 0x81, 0x80, 0xbd, 0x6b, 0xd7, 0xa8, 0x8a, 0x8b, 0xcc, 0x8a, 0x81, 0xc5, 0xa0, 0x33, 0x1e, 0x9, 0x53, 0x63, 0x50, 0x8c, 0xd3, 0x29, 0xec, 0x50, 0x4e, 0xa3, 0x21, 0xa6, 0x76, 0x6c, 0x58, 0xd6, 0x58, 0xe0, 0xfa, 0xb9, 0x42, 0xe1, 0xdc, 0x2a, 0x30, 0x8b, 0xa7, 0xe1, 0x22, 0x25, 0x87, 0x19, 0x87, 0x7b, 0xb8, 0xaf, 0xe6, 0x92, 0xd1, 0xcd, 0xf2, 0xbc, 0xdb, 0xb4, 0x10, 0xcb, 0xa4, 0xe5, 0xe5, 0xe4, 0xb8, 0xfc, 0x8e, 0x14, 0x49, 0x79, 0x3f, 0xda, 0x1c, 0x14, 0xaa, 0x33, 0x7a, 0x1f, 0x88, 0x84, 0xc, 0x3a, 0x6, 0x75, 0x82, 0x63, 0x2b, 0x65, 0x2e, 0x2a, 0xf7, 0x2e, 0xc8, 0x87, 0x49, 0x19, 0xf4, 0xd8, 0xaa, 0x94, 0xde, 0x30, 0xeb, 0x3f, 0x1e, 0x44, 0xae, 0xfe, 0xbc, 0x66, 0xf5, 0x8e, 0x5e, 0xbd, 0xc7, 0x66, 0xb7, 0xa3, 0xa8, 0xcd, 0x16, 0x1c, 0xeb, 0x65, 0xb9, 0x4, 0x7e, 0x52, 0xb9, 0x31, 0xac, 0x59, 0xa0, 0x3b, 0x13, 0xea, 0x6e, 0x3f, 0x41, 0xe3, 0x8b, 0x40, 0x51, 0x9a, 0xf3, 0x85, 0xb5, 0x7c, 0x72, 0xde, 0xc9, 0x9b, 0xb7, 0xbf, 0x37, 0xd7, 0x1f, 0x4a, 0x40, 0x91, 0x0, 0xa3, 0xbf, 0xe2, 0x4, 0x5b, 0x29, 0x2f, 0x92, 0x77, 0x5a, 0xea, 0xf7, 0xc2, 0x39, 0x4a, 0x15, 0x13, 0x5f, 0x97, 0x17, 0x84, 0x44, 0x16, 0x37, 0xd5, 0x14, 0x67, 0xbf, 0xfe, 0x9b, 0x4b, 0xc8, 0x53, 0xea, 0x4c, 0xff, 0x5d, 0xc8, 0xe2, 0x51, 0x26, 0x3a, 0x76, 0x6, 0x2c, 0xaa, 0xb0, 0xb7, 0x58, 0x24, 0xd2, 0x1c, 0x76, 0x3d, 0x33, 0x40, 0x5a, 0x95, 0x66, 0x8a, 0x53, 0xda, 0x22, 0x95, 0x1e, 0x96, 0x26, 0xa0, 0x91, 0xa5, 0x7f, 0x8a, 0x5a, 0x27, 0xdb, 0xe0, 0xb6, 0x1c, 0xf, 0x1c, 0x65, 0x2d, 0xd0, 0xf0, 0x4c, 0x12, 0xa3, 0xe3, 0xcf, 0x1, 0x4d, 0x95, 0xbf, 0xd3, 0x5e, 0x56, 0x44, 0x70, 0x47, 0xab, 0xe7, 0x9b, 0x8f, 0xe0, 0x4c, 0xec, 0x13, 0x75, 0x16, 0xc3, 0xeb, 0xa6, 0xd0, 0x2e, 0x68, 0x29, 0xf, 0x91, 0xa4, 0x78, 0x68, 0xaf, 0x42, 0x4e, 0x1d, 0xbf, 0x55, 0x84, 0x64, 0x7e, 0xda, 0x7f, 0xad, 0xa8, 0xf0, 0x51, 0xbe, 0xba, 0xdd, 0x65, 0x4b, 0x14, 0x91, 0x24, 0x4, 0xf5, 0xab, 0x54, 0xcb, 0x79, 0x27, 0xc4, 0x13, 0xee, 0x2, 0x71, 0x4d, 0x74, 0xe8, 0x2b, 0x14, 0x45, 0xf9, 0x2e, 0xaf, 0x64, 0xc2, 0x86, 0x61, 0x47, 0x8b, 0x50, 0x89, 0x96, 0xed, 0xb8, 0x20, 0x14, 0xe0, 0x14, 0xa9, 0x68, 0x24, 0x21, 0x35, 0xd4, 0xa, 0xf9, 0x66, 0xf0, 0xcf, 0x69, 0x87, 0xe7, 0x61, 0x6e, 0xae, 0x58, 0x8c, 0x29, 0x81, 0x10, 0xae, 0x42, 0x33, 0x3b, 0x91, 0x8b, 0x2d, 0xcc, 0xfe, 0x4c, 0x6a, 0x60, 0xe9, 0x7e, 0x65, 0xb6, 0x3e, 0x41, 0x9d, 0x5f, 0x6b, 0x64, 0x2, 0x50, 0x24, 0x42, 0x68, 0x76, 0x5b, 0x5a, 0xd9, 0xb7, 0x3a, 0x5d, 0x1, 0x6d, 0x50, 0x83, 0x31, 0xc4, 0x2f, 0x69, 0x4c, 0x97, 0xc, 0x2b, 0xcb, 0x74, 0x5b, 0xf0, 0x37, 0xa4, 0xd2, 0x2e, 0xb2, 0xb4, 0x97, 0x1d, 0x96, 0xf3, 0x68, 0x9e, 0xbf, 0x51, 0x3b, 0xcb, 0x2a, 0x2b, 0xe7, 0x88, 0x93, 0xe9, 0x88, 0x8b, 0x62, 0x35, 0x28, 0x67, 0x6d, 0x94, 0xef, 0xbc, 0x76, 0x81, 0x74, 0x14, 0x5f, 0x21, 0x2c, 0x94, 0x19, 0x38, 0x9, 0x64, 0x72, 0x55, 0x11, 0x78, 0xfc, 0xcf, 0x31, 0x25, 0x3, 0x8, 0x4, 0x1f, 0xcc, 0x72, 0xaf, 0xdc, 0x3b, 0x84, 0x5a, 0x45, 0xfa, 0xd6, 0x54, 0x87, 0xa7, 0x40, 0x4c, 0x89, 0x70, 0xbf, 0x8a, 0x3b, 0xa2, 0xc8, 0xab, 0x5e, 0x76, 0x8b, 0xb0, 0xcd, 0x85, 0xb3, 0xa6, 0xf0, 0xf1, 0xc9, 0xeb, 0x66, 0xc1, 0x3, 0x6, 0x21, 0x61, 0xd6, 0xae, 0xdb, 0xe7, 0x6c, 0x43, 0xf8, 0xe3, 0x9f, 0x6b, 0xbc, 0xa5, 0x99, 0x56, 0xa5, 0x28, 0x1b, 0x5f, 0x15, 0x4c, 0xe2, 0xe6, 0x64, 0x97, 0x1, 0xd0, 0x3a, 0xca, 0xee, 0xc7, 0x97, 0x26, 0x7a, 0xa0, 0x62, 0x3b, 0x70, 0xc1, 0x32, 0x3d, 0x22, 0xfe, 0x6a, 0x1, 0x39, 0x11, 0x43, 0x90, 0x1e, 0x4f, 0x8c, 0xb9, 0xe8, 0xc7, 0x6f, 0x40, 0xfb, 0xc4, 0x43, 0x42, 0x7f, 0xdf, 0x93, 0xee, 0x90, 0x9f, 0xbd, 0xc2, 0x68, 0x91, 0xd4, 0x45, 0x20, 0x28, 0x91, 0x38, 0x94, 0x10, 0xeb, 0x8, 0xf5, 0x2f, 0xcc, 0x19, 0xe, 0x4, 0x21, 0x9f, 0x2a, 0x75, 0xfb, 0xb5, 0x1, 0x94, 0xa5, 0xde, 0x57, 0xcf, 0xc0, 0xd0, 0xf, 0x1a, 0x7d, 0x3, 0xa0, 0x4, 0x8b, 0x3, 0xc5, 0xb1, 0x2f, 0x6f, 0x5b, 0xee, 0xc8, 0xce, 0xfc, 0xaa, 0x7b, 0xd4, 0x11, 0x92, 0x86, 0x58, 0x10, 0x25, 0x2f, 0xad, 0x91, 0x65, 0xc, 0xba, 0xdc, 0x85, 0xbc, 0x79, 0xf3, 0x3a, 0x94, 0xd, 0x45, 0xa3, 0x9e, 0x9, 0xa2, 0xd5, 0xef, 0x50, 0x6e, 0xea, 0x56, 0x7f, 0x69, 0x55, 0x60, 0xc5, 0x18, 0x9e, 0x9a, 0x68, 0x6e, 0x3b, 0x36, 0x3b, 0x99, 0x9c, 0xbe, 0xfc, 0xc2, 0x60, 0x70, 0x15, 0x8e, 0xfa, 0x1a, 0x26, 0x7a, 0x9b, 0x53, 0x2d, 0x6c, 0x86, 0xc0, 0x7c, 0xa4, 0x74, 0x54, 0xb3, 0x46, 0xcb, 0xaa, 0x4b, 0x4d, 0x78, 0xef, 0x9f, 0x48, 0x4c, 0xd1, 0x1b, 0x2f, 0xbc, 0x26, 0xe3, 0x52, 0xfc, 0x18, 0xc6, 0x92, 0x3, 0xf8, 0xe9, 0xbc, 0xd8, 0xd4, 0xf1, 0xbc, 0xd1, 0xc3, 0xd4, 0xf7, 0xb1, 0x2a, 0xbd, 0xbc, 0xc5, 0x8e, 0xb6, 0xe6, 0x14, 0x68, 0xeb, 0x8d, 0xe, 0x73, 0x3d, 0x90, 0x21, 0xb6, 0x79, 0xeb, 0x1b, 0x51, 0x46, 0xaa, 0x68, 0x29, 0x4d, 0xc5, 0x8, 0xee, 0x15, 0xbd, 0x67, 0x15, 0x17, 0x1, 0x45, 0xa6, 0x70, 0x4d, 0x3e, 0x3f, 0xa3, 0x6, 0xe1, 0xf4, 0x7a, 0x60, 0x64, 0x17, 0x5d, 0xfc, 0xfb, 0x46, 0x85, 0x6f, 0x52, 0x4f, 0xfe, 0xc0, 0x88, 0x51, 0xd5, 0x58, 0x56, 0x4b, 0xf9, 0x43, 0xd9, 0x21, 0x6d, 0x61, 0x99, 0xe7, 0x54, 0x9, 0x51, 0x6b, 0x85, 0x55, 0xa1, 0x42, 0x92, 0x54, 0xd3, 0x67, 0x7c, 0xeb, 0x19, 0x3f, 0x16, 0x3d, 0x1, 0xb4, 0x44, 0xf4, 0x18, 0xec, 0x63, 0x3f, 0xf9, 0xed, 0x42, 0x7f, 0xe2, 0x86, 0x76, 0xb6, 0xb6, 0x50, 0xc0, 0xb4, 0x67, 0xef, 0x2e, 0x79, 0x30, 0xec, 0x43, 0xd3, 0xaf, 0x92, 0xd6, 0xc7, 0xb6, 0x2, 0xac, 0xd2, 0x1c, 0xe6, 0xf2, 0x2e, 0x1e, 0x46, 0x3f, 0xcd, 0xb2, 0x2b, 0xe9, 0xf2, 0x23, 0x4a, 0x93, 0x31, 0xe3, 0x9b, 0x3a, 0x55, 0x5, 0xb1, 0x15, 0x31, 0xac, 0x72, 0x9e, 0x6f, 0x1a, 0x84, 0x52, 0xc9, 0xc2, 0x25, 0xfa, 0x4, 0x1, 0x32, 0xc6, 0x21, 0x65, 0xa2, 0x6c, 0x59, 0xe4, 0x87, 0x9d, 0x93, 0xfb, 0xa9, 0xc7, 0x5d, 0x37, 0x62, 0xfd, 0x1b, 0xb8, 0xd3, 0xef, 0xf5, 0x9d, 0x62, 0x8a, 0x19, 0x3c, 0x9b, 0xec, 0x89, 0x81, 0x5, 0x7, 0xf4, 0x5e, 0xdb, 0x21, 0x56, 0x2, 0xfb, 0x65, 0x38, 0x5f, 0x99, 0x34, 0x35, 0x93, 0x88, 0x1a, 0xea, 0x6d, 0x16, 0xb5, 0x65, 0xf4, 0x1d, 0x6c, 0xfa, 0xa0, 0x16, 0x3f, 0x2a, 0x28, 0x71, 0xd2, 0x1f, 0xa3, 0xdc, 0x94, 0xfc, 0xfd, 0x57, 0x6f, 0x7d, 0xf9, 0xd3, 0x70, 0x89, 0xbb, 0x3b, 0x4b, 0x1a, 0xd, 0xb0, 0x9e, 0xf4, 0x2d, 0x91, 0xce, 0xf3, 0xe3, 0x53, 0x47, 0xd7, 0xb7, 0x6f, 0x5b, 0x5, 0x7c, 0x9c, 0xf0, 0x9c, 0x5a, 0x41, 0x8a, 0xfe, 0x3a, 0xf0, 0x6d, 0x27, 0xa4, 0xd9, 0x5b, 0xb2, 0x76, 0x23, 0x8c, 0xe0, 0x69, 0x80, 0xb1, 0xfc, 0x92, 0x15, 0x83, 0x8f, 0xb0, 0x73, 0xc, 0x35, 0x4c, 0x4e, 0xeb, 0xa8, 0x49, 0x1a, 0x5b, 0x79, 0x3a, 0xd0, 0x85, 0xdc, 0x5f, 0xc2, 0x69, 0x7a, 0x19, 0x48, 0x91, 0x32, 0xca, 0x61, 0x93, 0xd9, 0x6c, 0x4e, 0x1b, 0xb2, 0x9d, 0xa6, 0xd7, 0x19, 0xf8, 0x6d, 0x3e, 0x8d, 0x17, 0x97, 0x3e, 0x76, 0xb5, 0x74, 0x10, 0xb2, 0x98, 0xbb, 0x72, 0xb7, 0x9, 0xad, 0xdb, 0xde, 0xbb, 0xa6, 0x61, 0x8a, 0xbb, 0x26, 0xd5, 0x57, 0xc9, 0xc8, 0x83, 0xc8, 0xf1, 0x59, 0xc9, 0x1e, 0xf6, 0x20, 0xd2, 0xff, 0xf2, 0x2, 0xa1, 0x80, 0x5d, 0xe6, 0xc3, 0xec, 0x47, 0x87, 0x29, 0xa7, 0x61, 0xe3, 0x6, 0xa6, 0xec, 0xc3, 0x62, 0xc1, 0xc1, 0xf2, 0xca, 0x18, 0xc7, 0xb5, 0xb3, 0xf9, 0xfe, 0xc4, 0x2e, 0x41, 0xd6, 0x1a, 0xb5, 0x96, 0x3a, 0x7a, 0x27, 0x83, 0xaa, 0xc5, 0xe5, 0x15, 0x9c, 0xf5, 0x59, 0xf3, 0x47, 0xc8, 0x5, 0xfb, 0x7b, 0x45, 0xeb, 0x82, 0x98, 0x6a, 0xad, 0x4a, 0xb6, 0xfe, 0x71, 0xa1, 0x12, 0xea, 0x3, 0x9c, 0xbc, 0xe6, 0x63, 0xea, 0x37, 0xce, 0x6f, 0xc8, 0xa2, 0x62, 0x77, 0xc8, 0x90, 0x8c, 0xa6, 0xec, 0xd9, 0xc4, 0xa, 0x70, 0x22, 0x14, 0xff, 0x22, 0xcf, 0x2a, 0x55, 0x8e, 0x3b, 0x9b, 0xfd, 0xa2, 0xdd, 0xf6, 0xba, 0xb5, 0xc7, 0xf1, 0x82, 0xb8, 0x39, 0x3a, 0xaf, 0x6e, 0xa, 0xa1, 0x11, 0xa, 0x56, 0x7f, 0xee, 0x52, 0x49, 0x6b, 0xd8, 0x61, 0xa9, 0x2e, 0xb1, 0x75, 0xea, 0xd0, 0xe7, 0x28, 0xd2, 0x8b, 0x28, 0x23, 0xba, 0xe9, 0xe4, 0x6, 0x36, 0xb6, 0x79, 0x7a, 0x6c, 0xa4, 0x57, 0x1d, 0x76, 0x85, 0x8c, 0x44, 0x77, 0x4f, 0xe1, 0x4e, 0x2b, 0x99, 0xa3, 0x15, 0x62, 0x1a, 0x83, 0xc, 0xaf, 0xc9, 0xb8, 0x49, 0x4d, 0x7d, 0x97, 0x3b, 0x4f, 0xa8, 0xcd, 0xb8, 0xfc, 0xcb, 0x6e, 0x5a, 0xa, 0x1f, 0x47, 0x15, 0x20, 0x32, 0x74, 0x7a, 0xfa, 0xcd, 0xa1, 0x30, 0x2, 0x1b, 0x55, 0xc6, 0xd9, 0x16, 0x11, 0x49, 0x93, 0x6f, 0x19, 0x66, 0x8d, 0x8c, 0xf5, 0x62, 0xb8, 0xf4, 0x2a, 0xcf, 0x41, 0x65, 0x37, 0x74, 0x77, 0xe2, 0x44, 0x75, 0x65, 0x86, 0x1d, 0xcb, 0xfb, 0xe5, 0x30, 0x1d, 0xa8, 0x66, 0x3c, 0x11, 0xd8, 0x6c, 0x91, 0x16, 0xd3, 0x8d, 0x59, 0xc4, 0xea, 0xc0, 0xf6, 0x34, 0x79, 0xc9, 0xf, 0xc8, 0xe4, 0xf1, 0x5, 0xd7, 0x18, 0x2, 0x3a, 0x1d, 0xc0, 0x64, 0xcd, 0x13, 0x38, 0x82, 0x5e, 0xa1, 0x24, 0x12, 0x21, 0x69, 0x81, 0x50, 0xaf, 0xa4, 0x7b, 0xd6, 0x30, 0x65, 0x95, 0xca, 0x5d, 0xd3, 0x7b, 0x1b, 0x2b, 0x8, 0x19, 0xc9, 0xe2, 0xa2, 0xa8, 0x80, 0x20, 0x7, 0x88, 0x6d, 0xe7, 0xc4, 0x7, 0xc3, 0x12, 0xf4, 0xdb, 0xd3, 0xe2, 0xec, 0x5e, 0xc7, 0x8f, 0x62, 0x3f, 0x4, 0xed, 0x7e, 0x4b, 0x27, 0x29, 0x8, 0x31, 0xca, 0x1c, 0xc9, 0xcb, 0x80, 0xae, 0xa1, 0x57, 0xeb, 0x73, 0x62, 0xd3, 0x7, 0x9c, 0xdf, 0xb1, 0x2, 0x34, 0x25, 0x12, 0xbf, 0xb1, 0xae, 0xb, 0x97, 0x9e, 0x4f, 0x16, 0x24, 0x10, 0xd3, 0x1e, 0x9, 0x59, 0xe8, 0xbe, 0xc4, 0xdd, 0xe2, 0xbd, 0x9f, 0xc2, 0x7f, 0xb, 0x48, 0x78, 0x7c, 0xc5, 0x41, 0xc1, 0x84, 0xc5, 0x8, 0x9d, 0x39, 0xc9, 0x16, 0x6f, 0x83, 0x7, 0x98, 0x8, 0xa9, 0x90, 0x4, 0x4, 0x9f, 0xf1, 0xc3, 0xcc, 0x45, 0x2b, 0x12, 0xa8, 0x84, 0x75, 0xe9, 0x0, 0xae, 0x5, 0x66, 0x93, 0x1, 0x51, 0xa8, 0x50, 0xbf, 0x57, 0x2a, 0x8e, 0x6f, 0x16, 0x81, 0x26, 0x25, 0x22, 0x80, 0x85, 0x3b, 0x16, 0xe3, 0xb8, 0x15, 0xa8, 0xfe, 0x5c, 0x8a, 0x13, 0x59, 0xff, 0x78, 0xbb, 0x8, 0x61, 0xb2, 0x4b, 0xf8, 0xc5, 0x59, 0x2c, 0x49, 0xb0, 0x7c, 0x73, 0x33, 0xe, 0x34, 0x2b, 0xd2, 0x1, 0xc0, 0x36, 0x29, 0xdd, 0xe2, 0x38, 0xcc, 0x7b, 0x85, 0xd1, 0x3c, 0xd2, 0x13, 0x1b, 0x1e, 0x1f, 0xcb, 0x39, 0x57, 0xfc, 0x51, 0xe6, 0xcc, 0xfc, 0x9e, 0x4a, 0x26, 0xaf, 0xc, 0x23, 0x64, 0xce, 0x35, 0xd7, 0xa4, 0x73, 0x75, 0xae, 0x86, 0x27, 0x75, 0x46, 0xca, 0xf7, 0x76, 0x35, 0x94, 0x7e, 0xf7, 0x34, 0x87, 0x59, 0x51, 0x2b, 0xa6, 0xde, 0xd2, 0x67, 0x85, 0xb1, 0xf9, 0x5, 0xb3, 0x9c, 0x9d, 0x1d, 0xb5, 0xbb, 0x34, 0x7f, 0x1f, 0x9c, 0x46, 0xc0, 0xad, 0xf8, 0xf0, 0x2d, 0x3c, 0x3, 0xd, 0x6b, 0xbc, 0x2c, 0x89, 0x24, 0x7e, 0x87, 0x5, 0xc7, 0xb1, 0xa9, 0x1, 0xed, 0xb7, 0x62, 0xf1, 0xab, 0xb4, 0xe6, 0x2e, 0x87, 0x4a, 0xd7, 0x53, 0x8a, 0x7, 0x98, 0x68, 0x3, 0xc4, 0x91, 0x71, 0xf5, 0x6d, 0xfe, 0x5, 0x5f, 0x63, 0x23, 0xb3, 0xea, 0x4, 0x16, 0x6b, 0x9, 0x61, 0xbc, 0xb7, 0xf4, 0x7d, 0xdd, 0xfe, 0xc3, 0x44, 0x62, 0x8b, 0x44, 0xb9, 0x2e, 0x14, 0xcb, 0xf2, 0x42, 0x91, 0x1c, 0xcd, 0xd5, 0x71, 0x9b, 0xcc, 0x8e, 0x79, 0x9, 0x78, 0x2d, 0x89, 0x2, 0x65, 0xcb, 0xb3, 0x74, 0x50, 0x51, 0xba, 0x36, 0x79, 0x2d, 0xa2, 0x2a, 0x55, 0x6c, 0x76, 0x2a, 0xdb, 0x22, 0x88, 0x9, 0xf8, 0x5f, 0xcb, 0xd1, 0xe5, 0x21, 0x38, 0x79, 0x6, 0xd4, 0xbe, 0x38, 0x4f, 0x32, 0x37, 0x9a, 0xd5, 0x67, 0x4b, 0x52, 0x3d, 0x6, 0x57, 0xea, 0x7e, 0xbe, 0x7e, 0x15, 0x77, 0xa5, 0x54, 0x86, 0x4c, 0x87, 0x25, 0xdd, 0x87, 0x9, 0xc9, 0xb4, 0xa1, 0x6d, 0xcb, 0xa3, 0xfc, 0x7a, 0x3b, 0x34, 0xb2, 0xe7, 0xc1, 0x1, 0x7e, 0x40, 0x1d, 0xe1, 0x5d, 0xf0, 0x6c, 0x8, 0x20, 0x23, 0x37, 0x60, 0xb1, 0xda, 0xc6, 0x93, 0x53, 0xc2, 0x5e, 0x98, 0x1d, 0x11, 0x67, 0x1b, 0x2a, 0x28, 0x34, 0xfa, 0x53, 0x94, 0x23, 0xc7, 0x71, 0x71, 0x73, 0xea, 0xa9, 0xd8, 0x3d, 0x88, 0x88, 0x52, 0x19, 0xc7, 0xf7, 0xf4, 0x4, 0x9b, 0x22, 0xcb, 0x9c, 0x3e, 0xd5, 0xd1, 0x67, 0xce, 0xe1, 0x41, 0xa0, 0xd8, 0x70, 0xbb, 0xc0, 0x17, 0x66, 0x27, 0x8d, 0x41, 0x30, 0x27, 0xb4, 0xb1, 0x1d, 0x1, 0x6d, 0x53, 0x93, 0x6b, 0x77, 0x70, 0xb, 0x24, 0x3d, 0x3c, 0xf4, 0x31, 0x82, 0xbc, 0x22, 0xea, 0xd, 0x86, 0xaa, 0x2f, 0xd, 0x68, 0x21, 0x93, 0x91, 0x5a, 0x93, 0x3b, 0xf6, 0x93, 0xc4, 0x4d, 0xa0, 0x24, 0xc6, 0x56, 0x94, 0xd, 0xdd, 0xcd, 0x46, 0x9d, 0xa4, 0x74, 0x94, 0xe, 0x50, 0x9c, 0x58, 0x43, 0x9, 0xd6, 0x79, 0x5c, 0x85, 0x7a, 0xdf, 0x9a, 0xe6, 0x9f, 0xfa, 0xd2, 0xfa, 0x2a, 0x97, 0xd3, 0x67, 0x52, 0xf, 0xb4, 0xa6, 0x2f, 0xfa, 0x54, 0x7f, 0x46, 0x15, 0xe3, 0x43, 0xb6, 0x62, 0x6f, 0xb2, 0x63, 0xc4, 0x3a, 0x87, 0x77, 0x9e, 0xd7, 0x9f, 0xe9, 0xc4, 0x2d, 0xfb, 0xa6, 0xf3, 0x59, 0x52, 0xfe, 0x39, 0x45, 0x50, 0x3c, 0x7e, 0x99, 0xf3, 0xc4, 0xb1, 0xd1, 0x1a, 0x8b, 0xd9, 0x2b, 0xa3, 0x4b, 0x61, 0x73, 0x8f, 0xe2, 0xca, 0xf3, 0x33, 0x45, 0x58, 0x7f, 0x60, 0xec, 0x2e, 0xd6, 0xc6, 0xb9, 0x14, 0x25, 0x3e, 0x89, 0x4c, 0xcb, 0x7f, 0x6, 0x26, 0x2, 0x61, 0x46, 0x5f, 0x12, 0xa6, 0x6b, 0xa9, 0x36, 0x45, 0xff, 0xe, 0xa9, 0x68, 0x99, 0xff, 0xe0, 0xdd, 0xfa, 0xdc, 0x96, 0x3, 0xbc, 0x66, 0xa8, 0x9e, 0x5, 0x5f, 0xdb, 0x75, 0x80, 0x9f, 0xc6, 0xd0, 0xb9, 0x74, 0xb0, 0xd7, 0xbd, 0x7e, 0x47, 0x0, 0x90, 0xcd, 0xad, 0xbc, 0x91, 0x6, 0x9f, 0xe2, 0xe1, 0x7d, 0xc7, 0xff, 0x91, 0x58, 0x86, 0x1b, 0x81, 0xbf, 0xac, 0x6a, 0xe5, 0x44, 0xa3, 0xf0, 0xbc, 0xed, 0x71, 0x1a, 0x3b, 0x55, 0x3d, 0xfd, 0xac, 0x7a, 0xf, 0xd4, 0x89, 0x34, 0xb7, 0xc, 0x31, 0xf8, 0x64, 0x4f, 0x85, 0x95, 0xb6, 0x3a, 0xea, 0x85, 0x36, 0xc3, 0x46, 0xb5, 0x5, 0x58, 0x3f, 0x84, 0x77, 0x96, 0xab, 0xf0, 0xe8, 0x93, 0x71, 0xcf, 0xce, 0x93, 0x8c, 0x4d, 0x21, 0x48, 0xb9, 0x9d, 0xdd, 0xde, 0x67, 0x7e, 0xa0, 0x4a, 0xe4, 0xaa, 0x33, 0xc5, 0x8d, 0xb, 0x2d, 0xba, 0x36, 0xa8, 0xb7, 0xb6, 0xd3, 0x36, 0x2c, 0x7b, 0x2c, 0x7a, 0x3b, 0xe4, 0x54, 0x83, 0x3e, 0x2e, 0x19, 0xc1, 0xc8, 0xf8, 0x28, 0xf0, 0x5d, 0x3, 0x4d, 0x7d, 0x21, 0x66, 0x41, 0x20, 0x5f, 0x91, 0x6c, 0x1a, 0x72, 0xe5, 0x12, 0x9, 0xf, 0x92, 0x4c, 0x45, 0x74, 0xdd, 0xb2, 0x4b, 0xa8, 0x9f, 0x76, 0xd, 0x6f, 0x52, 0xf4, 0xc, 0xd5, 0x11, 0xca, 0x21, 0x72, 0xfc, 0xf, 0xec, 0x36, 0x63, 0x90, 0xb7, 0xa2, 0x6c, 0x1f, 0x96, 0xb5, 0x26, 0xac, 0xe6, 0x49, 0x4c, 0x9d, 0x25, 0x2d, 0x68, 0xa9, 0xda, 0x2a, 0x93, 0xfc, 0x4e, 0x42, 0x16, 0xd7, 0xa, 0x86, 0xe0, 0x9f, 0xa5, 0x70, 0x75, 0x62, 0x10, 0xf, 0xc6, 0x9e, 0xfc, 0x66, 0x31, 0x82, 0x3b, 0x5, 0x76, 0xd5, 0xae, 0x8c, 0x66, 0x8e, 0xa6, 0xaf, 0xbd, 0x78, 0x43, 0xa7, 0xa1, 0x10, 0x43, 0x55, 0xce, 0xc3, 0xb2, 0x3, 0x2f, 0x46, 0x93, 0x99, 0x5a, 0xe5, 0xf0, 0x18, 0xc8, 0xa1, 0x63, 0xd5, 0x93, 0xf8, 0x3c, 0x86, 0xb3, 0x87, 0x3d, 0xf8, 0x12, 0xd8, 0x77, 0xad, 0x92, 0x97, 0x5, 0x3, 0xcd, 0xab, 0xf, 0x4f, 0x77, 0xf1, 0xb, 0x1d, 0xf1, 0xaf, 0x10, 0x2f, 0x92, 0x1, 0xf6, 0xd9, 0x2c, 0x51, 0x2e, 0xff, 0x44, 0xd1, 0xdb, 0x32, 0x67, 0x8f, 0xf7, 0xa5, 0x83, 0xab, 0x6f, 0x1a, 0xcd, 0xf6, 0xc7, 0x7d, 0x16, 0x8e, 0x88, 0xe6, 0x35, 0xf0, 0x52, 0x97, 0xbf, 0xe, 0x31, 0xe4, 0x82, 0x6a, 0x27, 0xd8, 0xad, 0x97, 0x70, 0x2b, 0x9a, 0x1f, 0xef, 0x99, 0x58, 0xd3, 0x4b, 0xa0, 0x49, 0x84, 0xde, 0x2, 0x7b, 0x22, 0x99, 0x6d, 0xa1, 0x43, 0x9d, 0xed, 0x3f, 0x85, 0x9a, 0x39, 0x14, 0xea, 0x27, 0xe4, 0xff, 0x3e, 0xd4, 0x54, 0x9c, 0x4a, 0xab, 0x5d, 0x80, 0x5d, 0x59, 0x3c, 0x9a, 0xcf, 0x76, 0x64, 0x88, 0x37, 0xc4, 0x56, 0x6e, 0xed, 0xe6, 0xd3, 0x7, 0xca, 0x8b, 0x7a, 0xab, 0x4d, 0xdc, 0xc7, 0xf9, 0x3f, 0x22, 0x71, 0x56, 0x77, 0xa2, 0x30, 0x55, 0x56, 0x6a, 0x83, 0xc1, 0x2d, 0x83, 0x30, 0x91, 0x6b, 0x49, 0x17, 0x9b, 0xe2, 0xb2, 0x97, 0x9d, 0xba, 0x70, 0x64, 0x3a, 0x33, 0x7, 0xe4, 0xe0, 0xc6, 0xfc, 0x59, 0x66, 0x49, 0x30, 0x5, 0x57, 0xe3, 0xb7, 0xb5, 0x87, 0xbf, 0xc8, 0xd, 0xcb, 0x36, 0xc7, 0xe8, 0xfb, 0xa9},
+               output224: []byte{0xd2, 0x5b, 0x2d, 0x47, 0x4f, 0x62, 0xf6, 0xca, 0x7d, 0xb, 0xb2, 0x8, 0xac, 0xfb, 0x8b, 0xd7, 0x7a, 0x71, 0xb, 0x26, 0x44, 0xe0, 0x3a, 0xff, 0x27, 0x5b, 0x13, 0x91},
+               output256: []byte{0x31, 0x6d, 0xba, 0xab, 0xd7, 0x3c, 0xb3, 0x31, 0xe4, 0xca, 0xd8, 0x99, 0xb4, 0x46, 0xdf, 0xf6, 0x5e, 0xb8, 0x66, 0x8f, 0x5c, 0x4e, 0xf9, 0xa1, 0xdb, 0x8e, 0x8a, 0xe4, 0x24, 0x12, 0x8f, 0x66},
+               output384: []byte{0xf7, 0x65, 0x2a, 0xb4, 0xec, 0x1e, 0xbe, 0xf1, 0x18, 0x3c, 0x8d, 0xb0, 0xbd, 0x21, 0x7f, 0x8b, 0xd5, 0x57, 0xf6, 0x4, 0xf4, 0x59, 0xf5, 0xa2, 0x6d, 0x17, 0xf5, 0xb3, 0xe5, 0xd, 0x9d, 0xad, 0xaf, 0x13, 0x85, 0x36, 0x7d, 0x1c, 0x37, 0x5f, 0xa9, 0xba, 0x42, 0xd2, 0x51, 0x4c, 0x78, 0xb5},
+               output512: []byte{0xfd, 0x90, 0xed, 0x9a, 0x58, 0x20, 0x44, 0x3e, 0x58, 0xf1, 0x18, 0xfa, 0xd2, 0xed, 0xf, 0x65, 0x93, 0x89, 0x76, 0x87, 0x3e, 0x1c, 0xe6, 0xde, 0x77, 0xa3, 0x37, 0xfc, 0xfe, 0xc3, 0x92, 0xb3, 0x27, 0x5f, 0xd8, 0x5, 0xcc, 0xc6, 0x44, 0x26, 0x87, 0x1a, 0xbc, 0xca, 0x32, 0x50, 0xd3, 0x1a, 0x9f, 0xdb, 0x6c, 0x8c, 0x7b, 0xd8, 0x5b, 0x1e, 0x9e, 0x9, 0xf4, 0x29, 0x84, 0x3f, 0xa9, 0x26}},
+       testcase{
+               msg:       []byte{0x1a, 0x3d, 0xea, 0xfc, 0xe7, 0xa, 0xf6, 0xf3, 0xf5, 0x5d, 0x66, 0xad, 0x9c, 0xe7, 0x8d, 0x5f, 0x4d, 0x5c, 0x5f, 0x26, 0x38, 0xa8, 0x10, 0xaf, 0xcd, 0x7, 0xd6, 0x7e, 0x9f, 0x9a, 0x13, 0x80, 0xd6, 0xb3, 0x4b, 0xe4, 0x82, 0xef, 0x3, 0xc, 0x22, 0xf1, 0xe9, 0x78, 0xf5, 0x44, 0x60, 0x9c, 0xce, 0x35, 0xa7, 0x4c, 0x51, 0x9, 0xee, 0x70, 0x38, 0x49, 0x5b, 0x62, 0x10, 0xcd, 0xbc, 0xa8, 0xdc, 0x82, 0xc6, 0xe9, 0xe7, 0xb0, 0xd5, 0x93, 0xfa, 0xd9, 0x66, 0x53, 0x82, 0xb3, 0xc4, 0x1, 0xab, 0x89, 0x41, 0xdf, 0x71, 0x30, 0x7d, 0xd7, 0x7e, 0xba, 0xf1, 0x40, 0xaa, 0x66, 0xa1, 0xf7, 0x63, 0x16, 0x47, 0x88, 0x50, 0xe5, 0x88, 0x86, 0xa9, 0x61, 0x6, 0x31, 0xe9, 0xc7, 0x22, 0xf4, 0x59, 0xfa, 0x0, 0xc0, 0xb5, 0x31, 0x24, 0xfb, 0x4f, 0x12, 0x77, 0x8b, 0xbb, 0xa3, 0x76, 0x8, 0x26, 0xd3, 0xdb, 0xa6, 0x7c, 0xd0, 0x30, 0xa9, 0x6b, 0x65, 0x4a, 0xf9, 0x3f, 0x8e, 0x39, 0x5f, 0x5f, 0x43, 0x95, 0x49, 0x48, 0x9f, 0x81, 0x61, 0x68, 0x3f, 0x12, 0x4b, 0xc9, 0x80, 0xe6, 0x93, 0x9c, 0x83, 0xa6, 0x8, 0x5e, 0x4b, 0x6c, 0xaa, 0xf8, 0xbc, 0xd8, 0x9a, 0xe, 0x1, 0xed, 0x70, 0xdb, 0x48, 0x71, 0x66, 0xcc, 0x29, 0x73, 0x5d, 0x92, 0x35, 0xa9, 0xcd, 0xc5, 0x7b, 0x80, 0xc9, 0xc2, 0xe5, 0x91, 0xdf, 0x63, 0x22, 0xf5, 0xbe, 0xdd, 0x32, 0x93, 0x70, 0x73, 0xf7, 0x81, 0xa3, 0x3, 0x89, 0x55, 0x2a, 0xe8, 0x3f, 0xbe, 0x14, 0x7d, 0x1b, 0x3d, 0x34, 0x61, 0xa3, 0xdf, 0x96, 0xc1, 0x5c, 0xd9, 0x69, 0x0, 0xc5, 0x67, 0x18, 0xea, 0xae, 0x83, 0x84, 0x17, 0x5, 0x75, 0x79, 0x11, 0x59, 0x36, 0x86, 0x26, 0x79, 0xf5, 0xf2, 0xa4, 0x5d, 0xad, 0xf6, 0x5d, 0x14, 0x10, 0x8a, 0xf1, 0x64, 0x1d, 0xf9, 0x87, 0xb5, 0x79, 0x86, 0x38, 0x4f, 0xa1, 0x43, 0x37, 0x89, 0xf5, 0xdf, 0xbe, 0x87, 0xe9, 0xb, 0xd4, 0xe9, 0xd8, 0xd4, 0xd0, 0x74, 0x1f, 0xcd, 0xa7, 0x34, 0x83, 0x22, 0xb9, 0x67, 0xb5, 0x66, 0xb1, 0x86, 0x12, 0xdb, 0xb8, 0xfe, 0x64, 0xf1, 0x51, 0x94, 0x7c, 0x3f, 0x7e, 0x36, 0x1e, 0xe8, 0x68, 0x67, 0x6b, 0xcc, 0xd0, 0xcb, 0x3a, 0x1a, 0xfe, 0x4, 0x6b, 0xe7, 0x0, 0x57, 0xa0, 0x5a, 0xdd, 0x3e, 0x65, 0xaf, 0x31, 0xe3, 0xff, 0x41, 0x4a, 0x62, 0x7c, 0x1, 0x83, 0xe8, 0xff, 0x58, 0x3b, 0x41, 0xb7, 0x5b, 0x20, 0x36, 0x50, 0x42, 0x2, 0x16, 0xe6, 0xdf, 0xca, 0xb2, 0x89, 0x66, 0x5f, 0x5, 0x4c, 0xfe, 0x3e, 0xa0, 0x94, 0x36, 0x47, 0x52, 0x85, 0x18, 0x57, 0x3b, 0xbb, 0x1d, 0xf, 0x27, 0xe1, 0x44, 0x9e, 0x98, 0x73, 0x9e, 0xaf, 0xd, 0x0, 0x94, 0x32, 0xdf, 0xc, 0x1e, 0xdc, 0x16, 0x25, 0x26, 0x4b, 0x94, 0xa7, 0x1d, 0xb7, 0x62, 0x65, 0x9f, 0xf5, 0xa3, 0xa7, 0xa8, 0x67, 0xf1, 0x82, 0xd1, 0xf1, 0xfd, 0x34, 0xb3, 0x41, 0xa4, 0xa1, 0x81, 0x22, 0x18, 0x70, 0xdc, 0x4a, 0x49, 0x40, 0x13, 0x9, 0x1a, 0x7e, 0x3b, 0x2b, 0x7, 0xe0, 0x16, 0xc, 0x43, 0x8f, 0x1e, 0xe1, 0xe8, 0xa2, 0xb9, 0x89, 0xc4, 0xff, 0xec, 0x36, 0xb5, 0x8, 0x3e, 0xa4, 0x27, 0x60, 0x67, 0x67, 0xc2, 0x96, 0x72, 0xf4, 0x47, 0x79, 0xa8, 0x50, 0x5b, 0x42, 0x2b, 0x25, 0xa5, 0x69, 0x7, 0xf5, 0x65, 0xb2, 0x76, 0x90, 0xd0, 0x11, 0x42, 0x6a, 0x62, 0xdf, 0x0, 0x36, 0xd5, 0x7d, 0x96, 0x7c, 0xd1, 0xd1, 0x4e, 0x91, 0x5b, 0xbc, 0x26, 0x91, 0xe7, 0xaf, 0x81, 0x8c, 0x76, 0x9d, 0x9e, 0x1f, 0x9e, 0xdd, 0x40, 0x89, 0x4b, 0xe8, 0x8f, 0xa1, 0xd7, 0xa5, 0x95, 0x2a, 0xfd, 0x89, 0x8e, 0x83, 0x77, 0x16, 0xac, 0xd7, 0x39, 0x53, 0xbf, 0x2d, 0x1d, 0x44, 0x81, 0x23, 0xfd, 0x1a, 0x2, 0x76, 0xd2, 0xc2, 0xeb, 0xdc, 0x76, 0xa, 0x4b, 0x78, 0x74, 0x16, 0xcf, 0xae, 0x5e, 0x96, 0x3f, 0xcb, 0xdc, 0x8b, 0x55, 0x1c, 0xb7, 0xf, 0x91, 0xda, 0xe, 0xd4, 0xa8, 0x9, 0xf, 0xef, 0x17, 0x8e, 0x87, 0x9f, 0x2c, 0x34, 0xf3, 0xa2, 0x69, 0xdf, 0xff, 0xf0, 0x97, 0x72, 0xd4, 0x4a, 0x13, 0xd7, 0xa1, 0x74, 0x68, 0xb5, 0x83, 0x4c, 0x46, 0x9, 0x57, 0xd5, 0x24, 0x3c, 0x32, 0x5f, 0x63, 0xf0, 0x5f, 0x89, 0xd4, 0xed, 0x98, 0xd3, 0x61, 0xe7, 0xf0, 0xab, 0x8a, 0x83, 0x94, 0x8a, 0x64, 0xd0, 0xcf, 0xf8, 0x51, 0x48, 0x41, 0xaa, 0x21, 0xc7, 0xf3, 0x37, 0x92, 0xa, 0x99, 0x83, 0xe5, 0x9b, 0xe4, 0xa0, 0xf1, 0x33, 0x9e, 0x1e, 0x46, 0x2f, 0x92, 0xdc, 0x1f, 0xc0, 0x70, 0x12, 0x62, 0x6, 0x1, 0x24, 0x58, 0xa4, 0x99, 0xa8, 0x11, 0x1f, 0xae, 0x7, 0x8e, 0x0, 0xb0, 0xca, 0x3b, 0xc1, 0xd6, 0xc7, 0x8, 0x7c, 0xd3, 0x18, 0xd5, 0x60, 0x3c, 0x1c, 0x7e, 0x4, 0x25, 0xe6, 0xf7, 0x29, 0xce, 0xec, 0xa5, 0xf3, 0x5b, 0x82, 0xf8, 0xa4, 0x2e, 0xe, 0x9b, 0x95, 0xe, 0xfb, 0x9, 0x4, 0xc5, 0xfb, 0x5c, 0x6, 0xd9, 0x1d, 0x23, 0x99, 0x13, 0x66, 0x5e, 0xd1, 0xf1, 0xee, 0x4b, 0x82, 0x18, 0x5a, 0x1, 0xba, 0x86, 0xca, 0x2d, 0x3e, 0xa9, 0x4e, 0x5a, 0x88, 0x42, 0x23, 0x1a, 0x94, 0xc0, 0x52, 0x80, 0x18, 0x3b, 0x7a, 0xca, 0x28, 0x99, 0x84, 0x10, 0x3f, 0x12, 0x22, 0x3, 0xec, 0x2f, 0xba, 0x4a, 0x38, 0x2e, 0x6f, 0x52, 0x36, 0xd6, 0xf6, 0x8d, 0xa0, 0x5e, 0x3b, 0xb0, 0xc5, 0x58, 0x42, 0x1f, 0xe, 0xfa, 0xb9, 0x1d, 0xce, 0xef, 0x6d, 0x1e, 0xcd, 0xc6, 0xf, 0x9b, 0x88, 0xf8, 0xbe, 0xfe, 0x31, 0xcd, 0xc3, 0xc2, 0xf0, 0x24, 0xa1, 0xaf, 0x2c, 0x73, 0x36, 0xaa, 0x5d, 0x15, 0x1e, 0x8c, 0xda, 0x81, 0x4a, 0x5f, 0xe8, 0x98, 0xba, 0xde, 0xb9, 0xdd, 0x68, 0xe, 0x33, 0x7e, 0x68, 0x2e, 0xbc, 0x22, 0xbf, 0xae, 0x44, 0x54, 0x17, 0xe3, 0x7d, 0x2d, 0x89, 0xa3, 0x38, 0x65, 0x9a, 0x28, 0xa, 0xb1, 0x20, 0x6d, 0xb7, 0x4d, 0xd4, 0x2c, 0x6f, 0x25, 0x63, 0x9c, 0x18, 0x3, 0xbf, 0xdf, 0x21, 0x56, 0xdf, 0x61, 0x3b, 0xf, 0x59, 0x24, 0xd2, 0x9, 0xf7, 0xf9, 0x0, 0x3c, 0xe8, 0x79, 0x4f, 0x98, 0x9f, 0x4f, 0x27, 0xb8, 0x21, 0x21, 0x21, 0xf, 0x4f, 0x65, 0xec, 0x5a, 0x1f, 0x77, 0x23, 0x30, 0x5c, 0xee, 0x43, 0x8c, 0x41, 0xf7, 0x93, 0xee, 0x4, 0x49, 0x6b, 0xbe, 0x33, 0x7b, 0xbd, 0x2f, 0xd3, 0x2, 0x38, 0x30, 0xb1, 0xc8, 0x88, 0x9c, 0x6f, 0x4d, 0xc, 0x11, 0x92, 0xe3, 0x64, 0xed, 0xbe, 0x1c, 0xd9, 0x87, 0xba, 0x5d, 0x66, 0x22, 0x4e, 0xe9, 0xc9, 0x40, 0x5e, 0x1d, 0xfc, 0xec, 0xe, 0xef, 0xfc, 0x5c, 0x73, 0xd3, 0x12, 0x3f, 0x67, 0x31, 0xc6, 0x29, 0x5d, 0x1e, 0x6b, 0x85, 0x4b, 0x88, 0x4f, 0xd2, 0x2b, 0x6a, 0x3b, 0xbb, 0xe5, 0x39, 0x53, 0x12, 0x58, 0x5c, 0xd1, 0x38, 0xbc, 0xa6, 0x75, 0x32, 0xc6, 0xab, 0x71, 0xbe, 0xbc, 0x66, 0x57, 0xc5, 0xd, 0xa8, 0x7d, 0x2a, 0xc6, 0x6, 0x8f, 0xa3, 0x97, 0x2, 0x2, 0xc5, 0xe1, 0x5e, 0xb7, 0xb4, 0xb3, 0xd2, 0x67, 0x6c, 0x1, 0x34, 0xbc, 0xf1, 0xea, 0xc2, 0xb2, 0x6b, 0xa4, 0x69, 0x30, 0xb5, 0xe6, 0x60, 0xb1, 0x60, 0x60, 0x89, 0x48, 0x84, 0xc8, 0x8b, 0xfa, 0xcd, 0x67, 0x79, 0x27, 0x6b, 0x86, 0xf6, 0x85, 0xab, 0x6f, 0x17, 0xc6, 0xd5, 0x3f, 0x62, 0x12, 0x75, 0xfa, 0xd6, 0x6d, 0x2, 0x1d, 0x26, 0xd1, 0xd4, 0x80, 0xaf, 0xab, 0x4b, 0x5e, 0xc7, 0x5e, 0xe, 0x76, 0x3f, 0xfc, 0x45, 0xf5, 0x99, 0xea, 0x2, 0x50, 0x4d, 0xa5, 0xd9, 0x1e, 0xb5, 0xef, 0xc3, 0xe4, 0xae, 0x19, 0x6f, 0x21, 0x9e, 0x45, 0xe7, 0xcb, 0x5, 0x59, 0x49, 0x58, 0xc8, 0x76, 0xff, 0x47, 0x4a, 0x2, 0xe, 0xf7, 0x3c, 0x1f, 0x9, 0xb1, 0xf7, 0xf7, 0x45, 0x7e, 0x81, 0x6d, 0x3a, 0xf5, 0x1d, 0x86, 0x66, 0x3d, 0x4d, 0x46, 0x17, 0x54, 0xcd, 0x5e, 0x90, 0x74, 0x56, 0x69, 0x1e, 0x2, 0x44, 0x6d, 0x6c, 0xac, 0xfd, 0x33, 0x51, 0x62, 0x6, 0xa3, 0x18, 0x70, 0x54, 0x3d, 0x57, 0x45, 0x92, 0x8, 0x77, 0x73, 0x65, 0x3d, 0x40, 0x86, 0xc2, 0xbd, 0xcb, 0xab, 0x3c, 0x9b, 0x65, 0xca, 0x11, 0xad, 0xd, 0x4e, 0x58, 0xdd, 0xda, 0x8b, 0x44, 0x3, 0x9, 0x98, 0x98, 0x57, 0x10, 0x39, 0x29, 0x54, 0x9b, 0x73, 0x0, 0xce, 0xd4, 0x26, 0x51, 0xd4, 0x8, 0x66, 0x61, 0x69, 0x40, 0x92, 0xc4, 0x28, 0x75, 0xcb, 0x62, 0x85, 0x8e, 0x6d, 0x1b, 0xe5, 0xf7, 0x27, 0x4b, 0x4b, 0xcd, 0x83, 0xaa, 0x4d, 0xa0, 0x5c, 0xac, 0xa1, 0x86, 0xa3, 0x9, 0x2, 0x83, 0x7, 0x90, 0xf9, 0xff, 0xa2, 0x44, 0x18, 0xe1, 0xf9, 0xdb, 0x0, 0xfa, 0x40, 0x47, 0x7e, 0x83, 0xb0, 0x5c, 0x2d, 0x11, 0xad, 0x7d, 0x81, 0xdd, 0xdb, 0x1e, 0x31, 0xf9, 0x4a, 0x9d, 0xd5, 0xe9, 0xe1, 0x33, 0x91, 0xc2, 0x24, 0x79, 0xb5, 0x70, 0x97, 0x6e, 0x3a, 0xfc, 0x1b, 0xe4, 0x10, 0x86, 0xd3, 0xbe, 0x66, 0x89, 0xd8, 0x7c, 0xa4, 0x32, 0x6a, 0x7c, 0xde, 0x8e, 0x5b, 0x39, 0x6a, 0x67, 0x8d, 0x3c, 0xdb, 0x2c, 0x80, 0xfe, 0xcf, 0xba, 0x2b, 0xc7, 0x99, 0xae, 0x8b, 0x15, 0x28, 0xe9, 0x6d, 0x88, 0xc, 0xd0, 0x98, 0xdd, 0xe9, 0x10, 0xd0, 0x97, 0xea, 0xae, 0x66, 0xa, 0xd4, 0xd7, 0xea, 0x51, 0xc1, 0x8f, 0x18, 0xaa, 0x1b, 0x39, 0x61, 0x42, 0x99, 0xa1, 0x72, 0x51, 0x25, 0x21, 0xdf, 0xd2, 0x31, 0xb9, 0x84, 0x9, 0x9, 0x83, 0x9e, 0xb6, 0x9c, 0x89, 0x2e, 0xe2, 0x3f, 0x1b, 0xce, 0xec, 0x1f, 0xad, 0xba, 0x75, 0x78, 0x6c, 0x7d, 0xed, 0x93, 0xbc, 0x99, 0x83, 0xf7, 0x4c, 0xea, 0xb3, 0x97, 0xeb, 0x8b, 0xa8, 0x4f, 0x7e, 0x41, 0x30, 0xb3, 0x42, 0x58, 0xd6, 0x28, 0x59, 0x4a, 0x6f, 0x9e, 0x23, 0x48, 0xfd, 0x91, 0xba, 0x25, 0x94, 0xe0, 0x7b, 0x80, 0x57, 0xe8, 0xa2, 0xae, 0x3a, 0xdf, 0xea, 0xe, 0xf9, 0x19, 0x55, 0x53, 0x85, 0x97, 0x70, 0x41, 0xc5, 0xb6, 0xdc, 0x4f, 0x38, 0x80, 0x56, 0x91, 0x71, 0xf7, 0x21, 0x7a, 0xaa, 0x9a, 0x85, 0xf2, 0xf5, 0xbb, 0xdf, 0xe3, 0xff, 0xdf, 0x79, 0x24, 0x8f, 0x2a, 0x35, 0xfd, 0x4d, 0xec, 0x34, 0x98, 0xc, 0x67, 0x29, 0x3, 0x39, 0xb1, 0xc0, 0xa5, 0xa6, 0xab, 0x88, 0x38, 0x15, 0x7a, 0xe2, 0xf5, 0x14, 0xb, 0x4a, 0x24, 0x92, 0x4a, 0x66, 0x88, 0xae, 0x5c, 0xe7, 0x2a, 0x48, 0x10, 0x3e, 0xe9, 0x2, 0x9c, 0xe8, 0xa0, 0xf1, 0x5b, 0x1f, 0xbb, 0x19, 0xa1, 0x2f, 0xaa, 0xb8, 0xa, 0x7c, 0xd9, 0xc0, 0xe3, 0x89, 0xfc, 0x27, 0x75, 0x83, 0x3e, 0x31, 0x90, 0xf1, 0xcf, 0x73, 0x5e, 0xcd, 0xfe, 0x7f, 0x6b, 0x6c, 0x32, 0x65, 0x6, 0xaa, 0x82, 0x61, 0x3c, 0xbe, 0xda, 0x8d, 0xd3, 0x69, 0x1b, 0x81, 0xf4, 0xc1, 0xe3, 0xb0, 0xfc, 0x32, 0xd7, 0xe6, 0x71, 0x9c, 0xbf, 0xc1, 0x2f, 0x4a, 0x26, 0xe0, 0xfc, 0x29, 0xd6, 0x41, 0x79, 0x53, 0xab, 0xc9, 0x56, 0x8d, 0xb4, 0xed, 0x9a, 0x29, 0x4b, 0x9f, 0xd5, 0xf2, 0xa6, 0x66, 0xdd, 0xa5, 0x46, 0xab, 0xa3, 0x1, 0xb1, 0xc6, 0x9, 0x85, 0x3, 0x39, 0x53, 0xef, 0xd6, 0xf4, 0x53, 0x83, 0x33, 0xb5, 0xc7, 0xdd, 0x31, 0x48, 0x81, 0x4a, 0x3f, 0xd7, 0x92, 0x7c, 0x36, 0x6f, 0x40, 0xb3, 0xd7, 0xab, 0xbd, 0xeb, 0x23, 0x32, 0xdd, 0xb5, 0x86, 0xaf, 0x80, 0x95, 0x90, 0x97, 0x66, 0x3c, 0xfa, 0xb2, 0xfe, 0xec, 0xad, 0x6d, 0x36, 0x8a, 0xe1, 0xe, 0xff, 0x96, 0x63, 0xd5, 0xf8, 0xba, 0xb9, 0x59, 0x35, 0xd2, 0x5f, 0x45, 0x77, 0x6f, 0x7f, 0x4, 0xb4, 0x68, 0x17, 0xd0, 0x51, 0x65, 0xa9, 0xdd, 0x47, 0x70, 0x50, 0x9a, 0xbb, 0x92, 0xf8, 0xb9, 0xe7, 0x37, 0x3c, 0xa7, 0x80, 0x70, 0x35, 0x69, 0x98, 0x17, 0x54, 0xa5, 0x1d, 0x6d, 0x37, 0x6d, 0x65, 0xc5, 0x7f, 0x55, 0xcd, 0x70, 0xe2, 0xdf, 0x5f, 0xdf, 0x5a, 0x6b, 0x82, 0x9a, 0xe3, 0xc, 0xe3, 0xbf, 0x94, 0x28, 0x15, 0xc8, 0xb4, 0xbe, 0x85, 0x8d, 0xb5, 0x81, 0x51, 0xd0, 0x2a, 0x68, 0xaa, 0xb9, 0xfd, 0x37, 0x3e, 0x4, 0x7e, 0xfa, 0x51, 0xbd, 0x1a, 0xc, 0xd1, 0xb6, 0x17, 0x44, 0xd9, 0xe9, 0x7c, 0xeb, 0xa3, 0x33, 0x4b, 0x3b, 0xaa, 0xfe, 0xa3, 0xbc, 0x9e, 0x43, 0xae, 0x9, 0x7c, 0xf2, 0xc3, 0xd7, 0x13, 0xee, 0xcc, 0x24, 0x7f, 0xf4, 0x3e, 0xc7, 0x4d, 0x54, 0x90, 0x7d, 0x8b, 0xf4, 0x5e, 0x45, 0xb2, 0xe0, 0xe1, 0x1d, 0x82, 0xb1, 0x26, 0xa8, 0x17, 0x9d, 0x3f, 0x66, 0xc0, 0x55, 0xe1, 0x1f, 0x69, 0xea, 0x67, 0xaa, 0xcc, 0x5f, 0xee, 0x8a, 0xf0, 0x1f, 0xaa, 0x37, 0x9e, 0x51, 0x99, 0x8f, 0x50, 0x70, 0xf9, 0xee, 0xf, 0xd3, 0xa, 0x2e, 0xb2, 0x2a, 0x92, 0x55, 0x86, 0xfb, 0x1b, 0x39, 0x2, 0x4e, 0xb5, 0xeb, 0x1e, 0x12, 0x7c, 0x76, 0xa1, 0x49, 0xe7, 0xf0, 0x2a, 0xf1, 0xb7, 0x3c, 0x16, 0xe9, 0xe5, 0xa5, 0xdb, 0xe3, 0x78, 0xe0, 0x8a, 0x9f, 0xad, 0xf1, 0x19, 0x4c, 0x62, 0x51, 0x32, 0xab, 0x3f, 0xde, 0xfe, 0x8f, 0xe9, 0xa8, 0x9b, 0xb8, 0xe0, 0x3, 0x5a, 0x1a, 0x3a, 0xc5, 0x27, 0x8f, 0x5d, 0x3d, 0xa, 0xde, 0xe, 0x41, 0xc8, 0x1c, 0x68, 0x53, 0xa4, 0x1c, 0x4a, 0xc4, 0x5b, 0xe3, 0xf6, 0x81, 0x80, 0xfe, 0x23, 0xf2, 0x7f, 0x18, 0xbe, 0x2e, 0x33, 0x9d, 0xe1, 0xd5, 0x59, 0xd7, 0x5d, 0xe6, 0x3a, 0xdf, 0x7a, 0x32, 0xba, 0xe4, 0x2b, 0x3, 0x7a, 0xea, 0xa3, 0xe1, 0x23, 0xa5, 0x31, 0x48, 0x91, 0xbc, 0xd3, 0x5c, 0xa4, 0x8d, 0x57, 0xdf, 0x4c, 0x17, 0x54, 0xe, 0x97, 0x20, 0x2a, 0x8e, 0xa1, 0x32, 0x8d, 0xa2, 0x5b, 0x1f, 0xd6, 0xbe, 0x2b, 0x56, 0xae, 0xc1, 0xe5, 0xde, 0xb2, 0x9, 0xf3, 0xb7, 0xa1, 0x3a, 0xdb, 0x1c, 0xbe, 0x53, 0xeb, 0x64, 0x59, 0x56, 0xe5, 0x77, 0xa7, 0x62, 0x1d, 0x74, 0xe4, 0x23, 0x76, 0xd7, 0xb, 0xc5, 0xc4, 0xaa, 0xcd, 0x23, 0x9a, 0x85, 0x2f, 0xbb, 0x7b, 0x3f, 0x62, 0xcf, 0x59, 0xfe, 0x10, 0x43, 0x8c, 0x1d, 0xc8, 0xe1, 0xe4, 0x65, 0x66, 0x32, 0x5d, 0xa0, 0xca, 0x43, 0xaa, 0xa6, 0x3f, 0xb7, 0xe0, 0xb4, 0x50, 0xa2, 0xdb, 0x3e, 0x3a, 0x22, 0x4, 0x70, 0x4d, 0x89, 0x4d, 0xb2, 0x4b, 0x72, 0xb3, 0x7, 0x81, 0x6, 0xe0, 0x96, 0xcd, 0x54, 0x3d, 0xcf, 0x2, 0x76, 0x50, 0xcb, 0x49, 0x65, 0xe3, 0x8a, 0xc3, 0x6a, 0x8a, 0xd5, 0x88, 0xc5, 0x96, 0x2b, 0x4e, 0x26, 0x54, 0x8a, 0xb8, 0x8f, 0xb, 0xc2, 0xe, 0x10, 0xac, 0xc1, 0xc3, 0xfc, 0x0, 0xef, 0x41, 0x5b, 0x3c, 0x32, 0x49, 0x92, 0x64, 0x55, 0x2b, 0x14, 0xe2, 0xc0, 0xe7, 0x89, 0xa3, 0xb8, 0xa8, 0xbf, 0xf9, 0x62, 0xf, 0xd9, 0x39, 0xd0, 0xb3, 0x4e, 0x80, 0x61, 0x77, 0xec, 0x69, 0x6a, 0x4b, 0x3b, 0x1c, 0xa4, 0xb3, 0x2b, 0xa9, 0x79, 0xb2, 0x69, 0xc, 0xfb, 0x3a, 0x6b, 0x17, 0xbc, 0xee, 0x68, 0x77, 0xff, 0xce, 0x75, 0x7e, 0x41, 0x16, 0xda, 0x1, 0x9, 0x9f, 0xfe, 0x82, 0xad, 0xd5, 0xa0, 0xc5, 0x93, 0xe7, 0x34, 0x49, 0xa9, 0x6d, 0xb9, 0xcc, 0x2b, 0x9e, 0x84, 0x6d, 0x16, 0x6b, 0x9, 0x51, 0x74, 0xf2, 0xca, 0xf8, 0xb3, 0x5d, 0xd8, 0x78, 0xc8, 0x36, 0xd9, 0xbb, 0x6e, 0xee, 0xaf, 0x8e, 0x1b, 0xc5, 0xd0, 0xe1, 0x49, 0xc7, 0x39, 0x82, 0x8c, 0xc4, 0x80, 0xd7, 0x31, 0xdc, 0x16, 0xb3, 0x5b, 0x80, 0xd4, 0xad, 0x82, 0xed, 0x7d, 0x29, 0xbd, 0x5, 0x1, 0x82, 0x39, 0xef, 0xec, 0xf8, 0xde, 0xae, 0x18, 0xc, 0x6a, 0x45, 0x9d, 0xbc, 0xbf, 0xe4, 0xaa, 0xb9, 0xa5, 0xe2, 0xc1, 0xe1, 0xbc, 0x31, 0x41, 0x8c, 0xf2, 0xee, 0xeb, 0x31, 0xfd, 0xf8, 0xba, 0x2, 0xc9, 0xa9, 0x15, 0x25, 0xe9, 0x16, 0x3f, 0x67, 0x2b, 0xae, 0x2e, 0xde, 0xc3, 0x8c, 0x1b, 0xdb, 0x84, 0xea, 0x23, 0x7b, 0x4e, 0xf8, 0x6b, 0xf5, 0xc0, 0xf0, 0xff, 0xe1, 0x78, 0xe3, 0x76, 0x1e, 0x82, 0xd9, 0x4f, 0x66, 0xe5, 0xea, 0x40, 0xba, 0x81, 0x70, 0xbf, 0x76, 0x84, 0x9, 0xe1, 0xb4, 0x17, 0x7a, 0xaf, 0xd9, 0x93, 0x7b, 0xce, 0x3f, 0xbf, 0xf5, 0x90, 0x32, 0xd, 0x7c, 0x44, 0x53, 0x72, 0x46, 0x3f, 0xbb, 0xfb, 0x34, 0xf5, 0x74, 0x47, 0xf4, 0x2c, 0x16, 0xe0, 0x26, 0xf1, 0x79, 0xcb, 0xf8, 0x2f, 0x61, 0x7c, 0x86, 0xd1, 0xe8, 0xd4, 0x2f, 0x6c, 0x90, 0x8f, 0x9c, 0x6b, 0x77, 0xe3, 0x8d, 0x25, 0xd5, 0x13, 0x3, 0xdb, 0xd7, 0x81, 0xff, 0xab, 0x56, 0x9b, 0x4c, 0xf3, 0x1f, 0xd0, 0xb9, 0x47, 0xc4, 0x5e, 0x17, 0x68, 0xa2, 0xe9, 0xdf, 0xe8, 0x36, 0x9f, 0x52, 0xd, 0xc3, 0x8d, 0x77, 0x93, 0x7b, 0x69, 0xb8, 0x21, 0xdb, 0x4f, 0xfe, 0xa8, 0xf5, 0xe, 0xbc, 0x40, 0x4f, 0x5, 0x87, 0xb5, 0x59, 0x81, 0x89, 0xf5, 0x4b, 0x5a, 0x5b, 0x98, 0x96, 0x6f, 0xd1, 0x68, 0x1, 0xc8, 0x7d, 0xe2, 0xc3, 0xc7, 0x81, 0x3d, 0xd7, 0xd, 0xc6, 0x0, 0x82, 0x4d, 0x42, 0x6d, 0x88, 0xc5, 0x5e, 0x89, 0xd4, 0x72, 0x14, 0xd5, 0x92, 0x6, 0xa7, 0xa6, 0x5a, 0x65, 0xda, 0x7c, 0xa2, 0xe4, 0x2f, 0xa6, 0x2e, 0xd1, 0x7e, 0x7a, 0xa5, 0xb3, 0xed, 0x44, 0x6b, 0xcc, 0x71, 0xf1, 0x7f, 0xec, 0x85, 0x93, 0xbe, 0x96, 0xd2, 0x3, 0x7b, 0xd0, 0x7f, 0x94, 0x76, 0xd4, 0xd7, 0x32, 0xb3, 0x2b, 0xc5, 0xdf, 0x8c, 0x92, 0x13, 0x16, 0xb4, 0x56, 0x99, 0x0, 0x47, 0x16, 0xfc, 0x89, 0xf8, 0xd4, 0x5b, 0xae, 0x40, 0x2c, 0x26, 0xdb, 0xcd, 0xf1, 0xa3, 0x40, 0x84, 0x7b, 0x93, 0x2f, 0xf8, 0x82, 0xdb, 0xea, 0xfb, 0xed, 0xd2, 0x52, 0xe1, 0x26, 0xc8, 0x9a, 0x1e, 0x1f, 0xdd, 0x89, 0x8, 0xa1, 0xf6, 0x7d, 0x15, 0xd8, 0xe4, 0x32, 0xda, 0xd8, 0xe0, 0x8e, 0x95, 0xa, 0x3b, 0xc4, 0x6b, 0x96, 0xcb, 0x89, 0xcc, 0x5b, 0xda, 0xc7, 0x3, 0xb3, 0xfa, 0x3e, 0x98, 0x6e, 0xf1, 0xc6, 0xe7, 0xe6, 0x60, 0x6e, 0x68, 0x45, 0xba, 0x1e, 0xb2, 0xfb, 0xdc, 0xfe, 0xe7, 0x44, 0xb5, 0xe4, 0x52, 0x6, 0xf4, 0xa4, 0x19, 0xe1, 0xcb, 0x10, 0x3c, 0x84, 0x90, 0xeb, 0x29, 0x3e, 0xe9, 0xae, 0xc1, 0xf0, 0xa0, 0xd2, 0x94, 0xf9, 0xd3, 0x84, 0x77, 0x37, 0x41, 0x3d, 0x30, 0x87, 0x3f, 0x3c, 0x94, 0x74, 0xe, 0x8f, 0xd0, 0x72, 0x81, 0x78, 0x15, 0xeb, 0xbc, 0xe3, 0xf0, 0x9e, 0xde, 0xc9, 0xd1, 0x21, 0x1a, 0x9e, 0x99, 0x54, 0x7d, 0x62, 0xb, 0x2e, 0xc5, 0x6c, 0x89, 0xe9, 0xcb, 0x81, 0x44, 0xae, 0x9e, 0x46, 0x63, 0x63, 0x24, 0xbd, 0x13, 0xc6, 0xcc, 0xa3, 0xab, 0x9c, 0xd9, 0xfd, 0x8f, 0x7f, 0x93, 0x7a, 0xba, 0xbc, 0x59, 0x82, 0x32, 0x38, 0x44, 0x27, 0xa2, 0xd4, 0xce, 0xc, 0xbf, 0x97, 0x65, 0xf7, 0x22, 0x5e, 0x20, 0x8c, 0x3c, 0xe1, 0x28, 0x60, 0x2b, 0xa, 0xd0, 0x8a, 0x1b, 0xaa, 0xb7, 0x7e, 0xdb, 0x31, 0x11, 0xf0, 0xc6, 0xca, 0x7b, 0xa0, 0xea, 0xc9, 0xd8, 0x9d, 0x5b, 0x43, 0x78, 0xeb, 0x82, 0xc1, 0x7f, 0x6e, 0xa0, 0x83, 0x8, 0xa7, 0x9a, 0x53, 0xd1, 0x50, 0xd3, 0xf8, 0x5e, 0xfa, 0xb7, 0x72, 0x94, 0xf0, 0x2e, 0xe0, 0xe2, 0x88, 0x5e, 0xe2, 0xab, 0x27, 0x93, 0x39, 0x2b, 0x87, 0xdb, 0x11, 0xfa, 0x77, 0x99, 0x2f, 0x5b, 0x4f, 0xd7, 0x5e, 0xf2, 0xf1, 0xa8, 0x22, 0xe8, 0x74, 0x7, 0xa4, 0x87, 0x88, 0x94, 0x21, 0x5a, 0xb8, 0x9b, 0x6c, 0xc4, 0xa1, 0x20, 0xf5, 0xa7, 0x8b, 0x3c, 0x31, 0xab, 0x80, 0xff, 0xcc, 0x9a, 0xce, 0xf5, 0x3f, 0xc6, 0xf7, 0xf8, 0x56, 0x85, 0xeb, 0x9d, 0x56, 0xd3, 0xd, 0x87, 0xc2, 0x1a, 0xbb, 0xf1, 0x65, 0x2e, 0xef, 0x8f, 0x32, 0xc7, 0xc5, 0x67, 0xbd, 0x1f, 0x8, 0x62, 0x3b, 0x9, 0xc2, 0x9f, 0x33, 0x56, 0x1d, 0x42, 0x72, 0x7a, 0x56, 0x49, 0xa3, 0x85, 0x0, 0x71, 0xaa, 0x6c, 0x11, 0x73, 0x5a, 0xe6, 0x3c, 0x4f, 0xd3, 0x15, 0x59, 0xce, 0x56, 0xb, 0x27, 0xa3, 0x62, 0x78, 0x6a, 0x83, 0x35, 0x3f, 0xe4, 0x60, 0xb3, 0x70, 0x74, 0x66, 0x4a, 0x94, 0x21, 0xd3, 0xb2, 0xf6, 0xa8, 0x64, 0xd5, 0xac, 0xa0, 0x87, 0x18, 0x7b, 0x27, 0xe2, 0xb8, 0x2f, 0x31, 0xcb, 0x3d, 0xf5, 0xe9, 0x85, 0xce, 0xa2, 0x71, 0xc6, 0x9, 0xb9, 0x4b, 0x4e, 0x58, 0x35, 0x6d, 0x40, 0xc7, 0xd5, 0xc7, 0xff, 0x2e, 0x59, 0x90, 0xfb, 0x39, 0x58, 0x81, 0x54, 0x84, 0x3e, 0xa5, 0xfc, 0xa9, 0x2f, 0x12, 0x0, 0x75, 0xd4, 0xc4, 0xd0, 0x6, 0x66, 0x1a, 0xf, 0xa1, 0xb0, 0x58, 0x54, 0x54, 0xbe, 0xa7, 0x25, 0x47, 0x3e, 0xef, 0x7d, 0x58, 0x11, 0x7d, 0x58, 0x40, 0xc8, 0x34, 0x89, 0x99, 0x0, 0x37, 0x36, 0xc5, 0xee, 0xb7, 0x85, 0x8f, 0xfd, 0x27, 0x3a, 0x1c, 0x3e, 0xb2, 0x81, 0x2f, 0x56, 0x97, 0xc5, 0x91, 0x10, 0x27, 0x5b, 0x8, 0xf6, 0xbe, 0xfb, 0xe8, 0x4c, 0x92, 0x49, 0x7d, 0x5f, 0x73, 0xb7, 0xb6, 0xf7, 0x94, 0xa8, 0x49, 0x71, 0x3b, 0x23, 0xac, 0x5f, 0x29, 0xd5, 0xc7, 0x11, 0x2f, 0xb2, 0xe7, 0xa6, 0xe8, 0x9e, 0xb5, 0x4d, 0xdf, 0xa3, 0x12, 0x2e, 0x6c, 0x79, 0x62, 0x4c, 0x1b, 0xf2, 0x5e, 0xbf, 0xb9, 0xfe, 0x5c, 0xe6, 0xda, 0xa7, 0x79, 0xf3, 0xec, 0xb2, 0x98, 0x4d, 0xa4, 0x2f, 0x8c, 0x6a, 0xdc, 0x77, 0xb2, 0x1d, 0xd2, 0x91, 0xe6, 0x84, 0xfc, 0xa5, 0xe, 0x46, 0x7, 0x9, 0x62, 0xa2, 0xd4, 0xf0, 0x8, 0x13, 0xd8, 0xde, 0x1b, 0x8e, 0xd3, 0x3f, 0xed, 0x97, 0x15, 0x18, 0xc, 0x7e, 0xa8, 0xe2, 0xbb, 0x74, 0xfa, 0x65, 0xd9, 0xc7, 0xf6, 0xe1, 0x42, 0xf3, 0xc8, 0x1c, 0xdc, 0x59, 0x17, 0x2e, 0x10, 0x20, 0xf6, 0x2f, 0x65, 0xca, 0x5a, 0x12, 0xcf, 0x2b, 0xed, 0x9d, 0xea, 0x4, 0xa4, 0xd8, 0xca, 0xbc, 0x29, 0x48, 0xf7, 0xbe, 0x82, 0x3a, 0x3e, 0x79, 0x26, 0x25, 0x27, 0x5b, 0x39, 0x25, 0xa6, 0xc8, 0xd8, 0xe2, 0xb4, 0x28, 0xc7, 0x5a, 0x5d, 0xb0, 0xf7, 0x12, 0x2, 0x78, 0xcd, 0x7d, 0x6c, 0xab, 0x76, 0x87, 0x55, 0xc7, 0xfe, 0x2f, 0xbf, 0x89, 0xfd, 0xed, 0x1f, 0xb3, 0x8a, 0xc7, 0xf7, 0x6a, 0x2f, 0x87, 0x98, 0xca, 0x36, 0xed, 0x42, 0xcb, 0x7c, 0x7, 0xf0, 0x6, 0x27, 0x12, 0x5, 0xf5, 0x46, 0xa4, 0x81, 0x2c, 0x20, 0x7, 0x7f, 0x5, 0xd, 0x4c, 0xdc, 0x79, 0x45, 0x9f, 0xa6, 0x86, 0xe9, 0x7f, 0x7, 0x4, 0xb7, 0xa9, 0xff, 0x7d, 0xe1, 0x63, 0x18, 0xe8, 0x62, 0xc5, 0x3d, 0x36, 0x1b, 0xc6, 0x35, 0xa5, 0x5a, 0x26, 0x4b, 0xe1, 0x50, 0x16, 0x54, 0x5d, 0xbf, 0xce, 0x3c, 0x6d, 0x68, 0x49, 0x57, 0x6a, 0xde, 0xfb, 0x68, 0x84, 0xed, 0xd7, 0x68, 0x21, 0x4e, 0xb, 0x43, 0x8b, 0x2, 0x31, 0xb4, 0xf2, 0x69, 0x2c, 0x2c, 0xb, 0x5c, 0x17, 0x76, 0x74, 0xf8, 0xa0, 0xde, 0x23, 0x6e, 0xac, 0xd9, 0xe0, 0xce, 0xc7, 0xc8, 0x64, 0x7e, 0x4e, 0x9a, 0x58, 0x61, 0xb9, 0x57, 0xec, 0x83, 0x4a, 0x2f, 0x85, 0x72, 0xf0, 0x13, 0x4, 0xc3, 0xfd, 0x6a, 0x6, 0x1, 0x9e, 0x5f, 0x14, 0x99, 0xb6, 0x2b, 0xaa, 0x86, 0x70, 0xb6, 0x52, 0x46, 0x7f, 0xa9, 0xa4, 0xf1, 0xf, 0x5, 0x32, 0x63, 0xbf, 0xe9, 0x74, 0x3c, 0xc7, 0xd9, 0x33, 0xf8, 0x61, 0x36, 0xaa, 0xe3, 0xa6, 0xfb, 0x56, 0x75, 0x4d, 0x7d, 0x23, 0x83, 0x97, 0xa0, 0x3, 0xc, 0xeb, 0xea, 0x87, 0xcb, 0x25, 0x5a, 0xf3, 0x61, 0x38, 0xc3, 0x73, 0xdb, 0xba, 0xc4, 0x1d, 0xd4, 0xa6, 0x97, 0x3, 0x2e, 0x47, 0x96, 0xc5, 0x52, 0xad, 0x9c, 0x9b, 0x3f, 0xa7, 0x13, 0xc3, 0xa4, 0xe0, 0x9e, 0xe, 0xc5, 0x58, 0x1e, 0x94, 0xbe, 0x7f, 0x31, 0x6, 0x51, 0x57, 0x66, 0x2f, 0x9e, 0x9c, 0x67, 0x8b, 0x1e, 0xf1, 0xb8, 0xb8, 0xa8, 0x47, 0xc5, 0x17, 0x89, 0xc2, 0x2b, 0x18, 0x41, 0xbc, 0xfc, 0x85, 0x58, 0x20, 0xaf, 0x32, 0x58, 0xaf, 0x9e, 0x8, 0x23, 0x10, 0x90, 0xb4, 0x5d, 0x10, 0x4, 0x6a, 0x0, 0x17, 0x8e, 0x89, 0xbd, 0x51, 0x56, 0x16, 0xb8, 0xa4, 0x4e, 0x77, 0xbf, 0x57, 0x79, 0x5d, 0xab, 0xaf, 0x40, 0x68, 0x7b, 0x2c, 0xda, 0x7a, 0x50, 0x14, 0x16, 0x8f},
+               output224: []byte{0x98, 0xe4, 0xc, 0x17, 0x6c, 0x8c, 0x8e, 0xc4, 0x6a, 0xb9, 0x40, 0x68, 0x8d, 0x47, 0x97, 0x8b, 0x8d, 0x1c, 0xac, 0xef, 0xf3, 0x7c, 0x70, 0xf, 0xdd, 0x6, 0xcb, 0xb5},
+               output256: []byte{0x4b, 0xa1, 0x50, 0xc2, 0xf4, 0xdb, 0x24, 0x49, 0x51, 0x5c, 0xc9, 0xb5, 0x45, 0xec, 0x0, 0x12, 0x74, 0x73, 0x24, 0x70, 0xd, 0xa, 0xc1, 0xe5, 0x54, 0xea, 0xb8, 0x4a, 0x26, 0x2b, 0xaf, 0x0},
+               output384: []byte{0x97, 0x8a, 0x5c, 0x74, 0xca, 0xb4, 0xd5, 0xb7, 0x73, 0xad, 0xf6, 0x4c, 0xab, 0xec, 0xd, 0xe0, 0x36, 0xd0, 0x87, 0xe0, 0x41, 0xf6, 0xc1, 0xa9, 0x85, 0x53, 0xc, 0x22, 0x50, 0xd2, 0x83, 0xfa, 0xaa, 0x7f, 0xfa, 0xa0, 0x14, 0x25, 0x88, 0x69, 0x4e, 0x67, 0x24, 0x5b, 0xba, 0x56, 0xb9, 0xc8},
+               output512: []byte{0x29, 0xe5, 0xcd, 0x96, 0x9, 0x9c, 0x48, 0x34, 0xfd, 0xe, 0xcb, 0xe8, 0x13, 0x26, 0x21, 0xd0, 0x34, 0x5b, 0xe3, 0xdf, 0xc, 0x7a, 0xb9, 0xb8, 0xb8, 0x6d, 0x91, 0xe8, 0x7f, 0xd8, 0xaf, 0xa0, 0xa4, 0xf2, 0x9, 0x50, 0x6b, 0x8d, 0x8f, 0xba, 0xba, 0x15, 0x4a, 0xc6, 0x55, 0x52, 0xbe, 0x5f, 0x5c, 0x6b, 0xef, 0xea, 0x1d, 0xb6, 0x64, 0xbc, 0x55, 0x8f, 0x57, 0x48, 0xa, 0x31, 0x26, 0xb4}},
+       testcase{
+               msg:       []byte{0x93, 0xb0, 0x1f, 0x62, 0xe3, 0xcb, 0x96, 0x58, 0xb4, 0x80, 0x93, 0x61, 0xda, 0x42, 0xe9, 0x7, 0x4e, 0x31, 0x1b, 0x9d, 0x63, 0x27, 0x76, 0xd3, 0x2a, 0x2a, 0x3e, 0x1b, 0xf1, 0x68, 0xc7, 0xa6, 0x17, 0x3e, 0x44, 0x9f, 0x5e, 0xe4, 0x83, 0xff, 0x20, 0xb6, 0x3, 0x3, 0x62, 0xa4, 0x71, 0xfb, 0x3f, 0x2, 0x66, 0x3d, 0x9d, 0x86, 0x2a, 0x5, 0x76, 0x7c, 0xbc, 0x32, 0x21, 0x1d, 0x47, 0xef, 0xa5, 0x46, 0x7, 0xc0, 0x52, 0xbe, 0xe3, 0xec, 0xbc, 0x21, 0x1c, 0x7d, 0xe6, 0xe, 0xa8, 0x3b, 0xff, 0x16, 0x38, 0xf8, 0xf, 0x20, 0x3a, 0xc6, 0x67, 0x5a, 0x7, 0x75, 0x6c, 0xe1, 0x49, 0xa5, 0x69, 0x3, 0xf7, 0x8d, 0xb2, 0x1, 0x8d, 0xba, 0xfe, 0xf1, 0xb9, 0x3f, 0xca, 0xda, 0xfb, 0x63, 0x9a, 0x18, 0x41, 0x55, 0xee, 0x7a, 0x2a, 0xa9, 0xe4, 0x9d, 0xc6, 0x67, 0x1, 0x22, 0x98, 0xb1, 0xd4, 0x89, 0x14, 0x3f, 0xf2, 0x3, 0xf9, 0x39, 0xe8, 0xa8, 0x26, 0x29, 0xb, 0x95, 0xcc, 0x4c, 0x45, 0xa6, 0xfb, 0x25, 0xa4, 0x68, 0x7e, 0x58, 0x23, 0x28, 0xce, 0x2d, 0x96, 0x90, 0x95, 0xa, 0x32, 0xfd, 0xc5, 0xb5, 0xf0, 0x5f, 0x39, 0x58, 0x2c, 0x8c, 0x68, 0x90, 0x40, 0xcd, 0x4f, 0xed, 0xd7, 0x91, 0x9c, 0x5b, 0xb9, 0xdd, 0xcc, 0xef, 0xb1, 0x27, 0x75, 0xf, 0x27, 0x76, 0xb9, 0x1, 0xed, 0xaf, 0x71, 0x73, 0xe9, 0xc, 0x3, 0x54, 0xfb, 0x37, 0x5c, 0x62, 0x49, 0xc9, 0x35, 0x89, 0x6, 0x32, 0xb8, 0x6d, 0xfb, 0x37, 0xe4, 0x75, 0xfc, 0x48, 0xe, 0x4a, 0xce, 0xb7, 0x2, 0xf9, 0x35, 0x3d, 0x25, 0xe, 0xf7, 0x3a, 0xc0, 0x75, 0xb0, 0xbb, 0x6c, 0x6b, 0x2f, 0x3, 0x16, 0x84, 0x2b, 0x19, 0xac, 0xca, 0xe8, 0xe0, 0x84, 0xf0, 0x73, 0x95, 0x33, 0xe3, 0xe3, 0xd6, 0x2c, 0x5f, 0xc1, 0x7, 0x3, 0x39, 0x37, 0xed, 0xbf, 0x1e, 0xc9, 0x5e, 0x92, 0x51, 0x2d, 0xbd, 0xda, 0xea, 0xac, 0x8b, 0xdd, 0xc2, 0xcb, 0x8e, 0xc3, 0x48, 0x8e, 0xef, 0xeb, 0x62, 0xa1, 0xfe, 0x84, 0x49, 0x1, 0xbc, 0x12, 0xd9, 0xa0, 0xab, 0xdd, 0x8d, 0xa4, 0xa0, 0x6f, 0x7b, 0x9a, 0x9f, 0x9, 0x57, 0x61, 0xdd, 0x80, 0xe8, 0x91, 0xd2, 0x24, 0x5e, 0x5d, 0x35, 0x9b, 0x39, 0xc2, 0xe4, 0x61, 0xba, 0x80, 0xe3, 0x3e, 0x1b, 0xf7, 0xc5, 0x32, 0xa8, 0xc7, 0xcb, 0x35, 0x0, 0x2d, 0xeb, 0x5d, 0xdd, 0x49, 0xcb, 0x11, 0x3c, 0x4e, 0xa2, 0x14, 0xc0, 0x4b, 0x95, 0xc4, 0xa5, 0xa6, 0x8f, 0x68, 0xf5, 0x13, 0xd9, 0xb4, 0x70, 0x45, 0x9c, 0xd8, 0x74, 0x89, 0xe7, 0xe1, 0x3, 0xd1, 0x9b, 0xfe, 0x1e, 0xc3, 0xaa, 0x82, 0x69, 0xa6, 0x11, 0xf0, 0xa5, 0x16, 0x40, 0x82, 0x32, 0xe3, 0x96, 0x46, 0x3d, 0xad, 0x84, 0x2d, 0xc, 0x1e, 0x92, 0xb2, 0x5e, 0x9a, 0x3c, 0xa1, 0x69, 0x6a, 0x5f, 0x2a, 0x68, 0x4c, 0x23, 0xdd, 0xe0, 0xa6, 0xb3, 0xf2, 0xff, 0x2e, 0xa1, 0xd9, 0x56, 0xd5, 0xe6, 0xaf, 0x67, 0xf7, 0xd7, 0x2e, 0x3d, 0x6, 0x92, 0x93, 0xe, 0x44, 0x6a, 0xaa, 0xe1, 0x83, 0x73, 0x86, 0x1a, 0x95, 0x21, 0xd6, 0x7c, 0xf7, 0x41, 0xc6, 0x1e, 0xea, 0xb4, 0xe8, 0xd7, 0xa3, 0xf4, 0x96, 0xee, 0xfa, 0xc6, 0x78, 0xb, 0xfb, 0x82, 0x6b, 0x53, 0x2b, 0xc8, 0x68, 0xb7, 0x56, 0x9, 0xb1, 0xbe, 0x86, 0xf9, 0xec, 0x24, 0x97, 0x32, 0xa8, 0x31, 0xa6, 0xa8, 0xa4, 0x90, 0xe2, 0xbb, 0x60, 0xba, 0x62, 0x8d, 0x14, 0x4b, 0xe1, 0x95, 0x2, 0xeb, 0x99, 0x91, 0xe, 0x31, 0x30, 0xe5, 0x65, 0x8f, 0xb5, 0xe3, 0x34, 0x8c, 0xe9, 0xdd, 0x3, 0xe, 0x68, 0xa5, 0x19, 0x40, 0x71, 0x97, 0xf5, 0x63, 0xb3, 0x65, 0xf2, 0x37, 0x81, 0x6d, 0x9f, 0x68, 0x3c, 0x5b, 0x73, 0x6c, 0x40, 0xb2, 0x36, 0xfa, 0x4a, 0xc9, 0xce, 0xc9, 0xa0, 0xcf, 0x8d, 0x5b, 0x54, 0xd5, 0xab, 0x36, 0x9, 0x13, 0x1a, 0x5a, 0xe, 0x6b, 0xb4, 0xc4, 0xca, 0xca, 0x24, 0xaa, 0xe1, 0x98, 0x9f, 0x18, 0x59, 0xd1, 0xcd, 0x55, 0x4c, 0xef, 0x5, 0xfd, 0x31, 0x22, 0xf, 0x7f, 0x46, 0xcc, 0x2e, 0x2d, 0x94, 0xc7, 0xb9, 0x48, 0x40, 0x73, 0x5a, 0xf, 0x3a, 0x70, 0xa5, 0x56, 0xd7, 0xe5, 0xf4, 0x84, 0x51, 0x23, 0xcf, 0x16, 0xdd, 0xfb, 0x56, 0x33, 0x46, 0xb9, 0x3, 0x5c, 0xcb, 0x34, 0x22, 0x19, 0x7b, 0x2f, 0x88, 0x5, 0xed, 0x2d, 0x3f, 0x6a, 0x15, 0xbc, 0xc0, 0x22, 0x9, 0xb4, 0xf, 0xa7, 0x60, 0x9a, 0xa8, 0x6f, 0xb6, 0xb9, 0x1f, 0x76, 0x5a, 0xa1, 0x89, 0xe2, 0x83, 0x14, 0x85, 0x17, 0x93, 0x1e, 0xde, 0xf, 0x19, 0x55, 0x2c, 0x94, 0x5a, 0x34, 0x1b, 0x1d, 0x69, 0x3c, 0xef, 0x1, 0x67, 0xeb, 0xb3, 0x82, 0x93, 0x3f, 0xdc, 0xa1, 0xe9, 0xd5, 0xb5, 0xe2, 0xf0, 0xd8, 0x81, 0xae, 0x12, 0x65, 0xe6, 0x7e, 0x39, 0x79, 0x3a, 0xbf, 0x65, 0x2b, 0x2d, 0xf9, 0x81, 0x39, 0x51, 0xd4, 0x33, 0x5d, 0x98, 0x86, 0x70, 0xff, 0xbc, 0x2b, 0x9c, 0x98, 0xeb, 0xae, 0xc7, 0x16, 0xd1, 0x3d, 0x22, 0x1d, 0x8c, 0x44, 0x84, 0x74, 0xed, 0x81, 0x3c, 0x1d, 0xfa, 0x3e, 0xe8, 0xf8, 0xbc, 0xde, 0x51, 0x79, 0x2e, 0x87, 0xf7, 0x97, 0xa4, 0xef, 0xd8, 0x0, 0x3e, 0xcc, 0x9b, 0x27, 0x4d, 0xf, 0x86, 0x93, 0xae, 0x56, 0x57, 0x62, 0x9d, 0xa8, 0xe1, 0x24, 0x68, 0x52, 0x4e, 0xe8, 0xff, 0x1e, 0x67, 0x90, 0xdf, 0x8, 0xe9, 0xaf, 0x5, 0xb1, 0xc6, 0xc0, 0x61, 0xe6, 0xa2, 0x4c, 0xf9, 0x52, 0xba, 0xf4, 0xce, 0x54, 0x40, 0xf, 0x3a, 0x1e, 0x22, 0x3c, 0xc, 0x18, 0x1c, 0xe9, 0x74, 0xeb, 0x41, 0x36, 0x64, 0xdb, 0x47, 0xbd, 0xcd, 0x62, 0xa0, 0xc3, 0x68, 0xf8, 0xd4, 0xc2, 0xeb, 0x45, 0x7b, 0xc5, 0xe7, 0x55, 0x4b, 0x0, 0xe9, 0xda, 0x62, 0x18, 0x5, 0xd9, 0x7f, 0x67, 0x72, 0x2, 0x39, 0x0, 0x79, 0xbd, 0xd8, 0x17, 0x17, 0x96, 0xdc, 0x51, 0xb1, 0xad, 0xc2, 0x77, 0x23, 0xce, 0x76, 0xf4, 0xfc, 0x19, 0x77, 0xb1, 0xb0, 0xf8, 0x82, 0x59, 0x9c, 0x8c, 0x4a, 0x12, 0x76, 0xb9, 0x90, 0x91, 0x20, 0x3, 0xb2, 0xd2, 0xbc, 0x9e, 0x8e, 0xf9, 0x95, 0xbf, 0xc3, 0xd2, 0x99, 0x37, 0x83, 0x68, 0x8e, 0x1d, 0x7f, 0xf5, 0x3e, 0xaa, 0x16, 0x70, 0xa, 0x4f, 0xd1, 0x50, 0x34, 0xf, 0x84, 0x63, 0xd, 0x1c, 0xf9, 0xf, 0x9d, 0xa0, 0xc9, 0x69, 0xa4, 0xac, 0xda, 0x92, 0xc7, 0xc7, 0xad, 0xc9, 0xbb, 0x3f, 0xb, 0x22, 0xb7, 0x4e, 0x95, 0x6f, 0xcf, 0xf9, 0x0, 0x5b, 0x5, 0x94, 0x51, 0xad, 0xd0, 0xe9, 0x9, 0x78, 0x43, 0xf4, 0x3e, 0x98, 0xf, 0x5c, 0xad, 0x99, 0x42, 0x1, 0x8c, 0x6a, 0x80, 0x1f, 0x77, 0x9f, 0x4, 0x72, 0x1d, 0x68, 0x96, 0x97, 0x6b, 0xdd, 0x27, 0x48, 0xb3, 0xf2, 0xb2, 0xe2, 0xda, 0x69, 0x2, 0x14, 0xaf, 0xd6, 0xaf, 0xd2, 0x17, 0x2a, 0xe2, 0x9b, 0xfd, 0x6b, 0x7, 0x1c, 0xe2, 0xd6, 0x93, 0x81, 0x4a, 0x79, 0xae, 0x8, 0x3e, 0x9b, 0x1d, 0xad, 0x64, 0x74, 0xec, 0xeb, 0x54, 0x7c, 0xb1, 0x8d, 0x55, 0xd2, 0x4f, 0x98, 0xe8, 0xd5, 0xa3, 0x43, 0x69, 0xa, 0xf, 0xfb, 0x96, 0xf7, 0xf3, 0x21, 0x3e, 0xb1, 0xa1, 0x1a, 0x7b, 0xdd, 0x6c, 0x37, 0x7a, 0x2d, 0x9e, 0x85, 0xbf, 0xb7, 0xd0, 0x9c, 0x53, 0xa1, 0x36, 0x40, 0xf0, 0x41, 0x7b, 0xd0, 0x36, 0x6b, 0x31, 0xf4, 0x82, 0xc2, 0xd8, 0xb5, 0x58, 0xdd, 0xfb, 0x3a, 0xb4, 0xe6, 0xfa, 0x99, 0xdf, 0xfa, 0x64, 0x4b, 0xd6, 0x93, 0xde, 0x92, 0x4, 0xa1, 0xb6, 0x1e, 0xa, 0xd7, 0x90, 0xf8, 0x3e, 0xcb, 0xa5, 0xd4, 0x45, 0xb3, 0xed, 0x1c, 0x7d, 0x4a, 0x68, 0x6d, 0x2a, 0xb0, 0x14, 0xeb, 0xa7, 0x80, 0x7a, 0x40, 0xa8, 0x4f, 0xd3, 0x9e, 0x5a, 0x75, 0x26, 0xa9, 0xeb, 0x5b, 0xe1, 0xca, 0x25, 0x4b, 0x2, 0xb5, 0x29, 0x52, 0x6e, 0xce, 0x40, 0x1a, 0xac, 0x18, 0x99, 0xf6, 0xfb, 0x8c, 0x9e, 0xb0, 0xcd, 0xc5, 0x9, 0x2b, 0x22, 0x8, 0x36, 0x8b, 0xaf, 0x9a, 0xae, 0x50, 0x12, 0x83, 0xf8, 0xe7, 0x2, 0x3c, 0xba, 0x4f, 0x17, 0xbe, 0xd1, 0xb6, 0xbc, 0x52, 0xc8, 0xcd, 0xe3, 0xf8, 0x4f, 0xae, 0xc6, 0xfc, 0x1f, 0x11, 0xfc, 0xd1, 0xf7, 0xdd, 0x3c, 0x60, 0x99, 0x48, 0x6c, 0xc8, 0xf6, 0xcc, 0x75, 0x89, 0xff, 0x18, 0xa4, 0xfb, 0x7e, 0xf2, 0x3, 0xf6, 0xfc, 0xce, 0xc1, 0x61, 0x60, 0xd9, 0x19, 0x7a, 0xc4, 0x19, 0xe0, 0x44, 0xd3, 0xbb, 0xaa, 0x2a, 0x42, 0xe0, 0x33, 0x60, 0x58, 0x5e, 0xf3, 0x83, 0xc4, 0xb8, 0xc8, 0xc1, 0x2, 0x5b, 0x8c, 0xe9, 0xcc, 0x99, 0xfc, 0xd3, 0xaf, 0x5f, 0xe, 0xdc, 0x45, 0x40, 0x9d, 0x5e, 0x35, 0x45, 0xcd, 0x66, 0xcd, 0xaa, 0x1d, 0xbc, 0xfb, 0xf7, 0x27, 0xbd, 0xe4, 0x14, 0x1d, 0x2e, 0x65, 0x9a, 0x78, 0x88, 0xff, 0xaf, 0x73, 0xaa, 0xed, 0xff, 0x9a, 0x79, 0xbd, 0x5e, 0x89, 0xa2, 0x8f, 0x4f, 0xd6, 0x92, 0xda, 0x3f, 0xf4, 0x32, 0xd2, 0x25, 0x7, 0x74, 0x90, 0x6b, 0x73, 0x7a, 0xdf, 0xdb, 0x6, 0xfb, 0x70, 0xbf, 0x3f, 0x6d, 0x90, 0xcc, 0x3b, 0xb, 0x27, 0x35, 0xf6, 0x6a, 0x0, 0x52, 0x97, 0xea, 0xb3, 0xe3, 0xbc, 0xef, 0x42, 0x99, 0xbd, 0x81, 0x27, 0xbc, 0x86, 0x48, 0xbf, 0x35, 0xf4, 0xf8, 0xa1, 0x47, 0x66, 0xf1, 0x92, 0x19, 0x85, 0xc9, 0x39, 0x79, 0x9e, 0x2d, 0xcf, 0x4, 0x24, 0x3b, 0x14, 0x2e, 0x21, 0x51, 0x6b, 0x42, 0x91, 0x11, 0xec, 0x94, 0x72, 0xeb, 0xcc, 0x9d, 0x8, 0x2c, 0xe7, 0x2a, 0xd4, 0x1d, 0xfd, 0x2c, 0x88, 0x7b, 0xcb, 0x86, 0xc3, 0x14, 0x35, 0x56, 0x4d, 0xf1, 0xb3, 0x97, 0x89, 0x7d, 0xc7, 0xbf, 0x55, 0x65, 0xa1, 0xd5, 0x9a, 0x4c, 0x7e, 0x3a, 0x1d, 0x5e, 0x28, 0x84, 0x4a, 0x3c, 0x3e, 0x98, 0xee, 0x11, 0xcf, 0xac, 0x4e, 0x91, 0xda, 0xec, 0x76, 0x1b, 0x79, 0x66, 0x17, 0xb0, 0x92, 0xca, 0x92, 0x27, 0x25, 0xb0, 0x94, 0x92, 0xb6, 0xbd, 0xf7, 0xcb, 0xb0, 0x2f, 0x32, 0x78, 0x75, 0xd2, 0x31, 0x2c, 0xae, 0x9f, 0x31, 0x2e, 0x18, 0x47, 0x2e, 0x3e, 0xfe, 0x74, 0x97, 0xa3, 0xeb, 0xd4, 0xec, 0x10, 0x5b, 0xf6, 0xcc, 0x8, 0x19, 0xbe, 0xae, 0xb6, 0xbe, 0xfd, 0x4d, 0x23, 0xce, 0xf5, 0xe7, 0x7, 0xd, 0x3e, 0x6e, 0xfd, 0x79, 0xa6, 0x4b, 0x4d, 0xb4, 0xff, 0xf8, 0x72, 0x6c, 0xca, 0x73, 0xe1, 0x80, 0xc8, 0x22, 0x49, 0x7d, 0xa, 0x23, 0xa1, 0xb9, 0x80, 0x2a, 0x90, 0x44, 0x71, 0x56, 0x80, 0x9e, 0xfe, 0xf2, 0x5c, 0xbd, 0x74, 0x14, 0xbb, 0x94, 0x5c, 0x8d, 0xc7, 0x8d, 0x5e, 0x3e, 0x53, 0x1e, 0x4a, 0xa9, 0x3c, 0xbb, 0x12, 0xb1, 0xbe, 0x22, 0x7a, 0xa6, 0xc9, 0xb9, 0x5, 0x38, 0x63, 0x4b, 0x1, 0xa5, 0xf, 0xda, 0x8e, 0x78, 0x66, 0x19, 0xa4, 0xc4, 0xeb, 0x17, 0x17, 0x72, 0x6f, 0x83, 0x65, 0xce, 0x56, 0x8f, 0x83, 0x83, 0x1f, 0xef, 0x3d, 0x70, 0xd1, 0xa1, 0xbf, 0xce, 0x19, 0x3b, 0x48, 0x59, 0x3a, 0xb2, 0x70, 0xc0, 0xae, 0x15, 0x6b, 0x2e, 0x4b, 0xaa, 0xba, 0xf9, 0xf0, 0xfa, 0xe9, 0x6d, 0x0, 0x75, 0xa5, 0x96, 0x20, 0xe9, 0xad, 0x57, 0x45, 0x70, 0xc1, 0xf2, 0x2d, 0x3f, 0xac, 0x28, 0xa6, 0x64, 0x1b, 0xd2, 0x9e, 0x51, 0xd4, 0xd1, 0xd6, 0xbc, 0xfd, 0xc6, 0x84, 0xc1, 0x47, 0xd, 0xe7, 0x33, 0x27, 0x28, 0xa8, 0x2f, 0x91, 0xd, 0x52, 0x4c, 0xd3, 0xb8, 0x9e, 0xb5, 0x68, 0xee, 0xa6, 0x58, 0x99, 0x6, 0x7d, 0x8e, 0x2d, 0x41, 0xa2, 0xb6, 0xbc, 0xa6, 0x48, 0x71, 0xbf, 0x53, 0x61, 0x6c, 0xcb, 0xb0, 0x6d, 0x50, 0xae, 0xfc, 0xeb, 0xba, 0x94, 0x2e, 0xf0, 0xd7, 0x93, 0xc3, 0xe5, 0x82, 0x77, 0x50, 0xd5, 0xc1, 0x80, 0x17, 0xeb, 0xa0, 0xb8, 0x82, 0x98, 0x20, 0xbe, 0xb3, 0xe8, 0xa9, 0x38, 0xd5, 0xb2, 0xaf, 0xed, 0xb9, 0x84, 0x46, 0x9c, 0x93, 0xdf, 0xf6, 0x3d, 0xb1, 0x75, 0x69, 0xbf, 0xc9, 0xd3, 0x4b, 0xcf, 0x1f, 0x68, 0xd0, 0x8e, 0xe2, 0x4c, 0x43, 0x10, 0xce, 0x97, 0x30, 0xbd, 0x5c, 0x8b, 0xe, 0xe8, 0x4a, 0xf, 0xa6, 0xbb, 0x5e, 0x9f, 0xcc, 0xa, 0x1d, 0xbc, 0x5, 0xde, 0x24, 0xc1, 0x9f, 0xf3, 0x17, 0x13, 0xee, 0xd5, 0x5a, 0x67, 0x2f, 0x47, 0x66, 0x5, 0xd3, 0x10, 0x19, 0xd, 0xbf, 0xa3, 0x13, 0xc9, 0xc7, 0xb3, 0x9c, 0x41, 0xbf, 0xc5, 0x72, 0x7d, 0xc5, 0x6, 0x3d, 0xc0, 0xf8, 0x6c, 0xb5, 0x68, 0x5e, 0x72, 0x1f, 0xaa, 0x85, 0xe4, 0x2b, 0xd7, 0x86, 0x20, 0x6b, 0x2f, 0x8b, 0xe2, 0x8, 0x48, 0x81, 0x3a, 0xce, 0x13, 0xaf, 0xea, 0xc1, 0xa, 0x6f, 0xa, 0x5c, 0xdb, 0x11, 0xb6, 0x7f, 0xdc, 0x6d, 0xb8, 0x11, 0x65, 0x39, 0x3b, 0xd4, 0xef, 0xc2, 0x1a, 0x63, 0x44, 0x50, 0xbc, 0xcd, 0xae, 0xe3, 0x78, 0xb7, 0x1a, 0xe9, 0xe3, 0xa8, 0x3a, 0x21, 0xa6, 0xb7, 0xc5, 0xd8, 0xa2, 0xb7, 0x97, 0xd9, 0x17, 0x82, 0x25, 0xc1, 0xe3, 0xe0, 0xa0, 0x19, 0x5, 0x10, 0x5c, 0xeb, 0x8f, 0x8a, 0x36, 0xfa, 0xf0, 0xf7, 0xa7, 0xb9, 0x3b, 0x69, 0x5a, 0xac, 0x54, 0x6b, 0xb7, 0x35, 0x4a, 0xe0, 0x59, 0x6e, 0x9b, 0xc4, 0x9c, 0x15, 0x4, 0xcc, 0x21, 0x67, 0xba, 0x95, 0x9f, 0x58, 0xb0, 0xa2, 0xbe, 0x26, 0x30, 0x72, 0x6, 0x7d, 0x5d, 0x89, 0x31, 0x1f, 0x0, 0x5f, 0xbc, 0x14, 0x68, 0x23, 0xe9, 0xf1, 0x0, 0x17, 0x57, 0x52, 0x23, 0xc9, 0x34, 0x27, 0x57, 0xf6, 0xea, 0xe3, 0xc0, 0x2, 0x89, 0xfd, 0xad, 0x15, 0x5f, 0x5d, 0x5d, 0xf8, 0x76, 0x51, 0xed, 0x2e, 0x1d, 0x1e, 0xc4, 0x3a, 0xd3, 0xab, 0xf5, 0x21, 0xe7, 0x82, 0x20, 0xe, 0x8a, 0x24, 0x38, 0xdc, 0x6a, 0xd4, 0x0, 0xd5, 0x49, 0xf6, 0x22, 0xac, 0x6d, 0xd0, 0xf9, 0x9d, 0x16, 0xcf, 0x50, 0x35, 0xfb, 0x61, 0x45, 0x7b, 0xe6, 0x6d, 0x1c, 0x79, 0x77, 0x42, 0xe, 0xac, 0x76, 0x7e, 0xdb, 0x3e, 0xe3, 0x50, 0xd, 0x7, 0x2b, 0x4, 0xcb, 0xb3, 0x48, 0x1b, 0xe8, 0x45, 0xec, 0x9, 0x88, 0x38, 0x86, 0xa8, 0xa0, 0x66, 0xd, 0xff, 0x30, 0xf2, 0x55, 0x67, 0xab, 0xc2, 0xde, 0x5, 0x77, 0x8d, 0x22, 0x79, 0x7b, 0x4c, 0x1b, 0x25, 0x88, 0xce, 0x38, 0x3f, 0x28, 0xba, 0xc, 0x6c, 0xee, 0x62, 0x1f, 0xb4, 0x64, 0xc5, 0xce, 0xec, 0xbe, 0xdd, 0xef, 0x1d, 0x9a, 0x26, 0xf4, 0x50, 0x46, 0xd5, 0x33, 0x2b, 0x33, 0xde, 0xab, 0xda, 0xb7, 0xdc, 0x2e, 0x7, 0xc7, 0x73, 0x2b, 0xee, 0x25, 0xf6, 0xb9, 0xe7, 0x2e, 0x8, 0x5d, 0x89, 0x65, 0xce, 0x2a, 0x55, 0x5a, 0x8b, 0x7d, 0xbf, 0x72, 0x8b, 0xb8, 0x55, 0x81, 0x12, 0xe, 0x16, 0xd4, 0xb4, 0xb5, 0x3d, 0x5e, 0x8b, 0xf8, 0xa0, 0x7d, 0x6f, 0x97, 0x1, 0x8, 0x24, 0xe1, 0x1b, 0x24, 0xa8, 0x56, 0x6a, 0xd4, 0xd1, 0x7, 0x59, 0x88, 0xaa, 0xa4, 0x94, 0x14, 0x2d, 0x3f, 0xbc, 0x9e, 0x5b, 0x29, 0x86, 0x6b, 0x6c, 0x0, 0x90, 0x0, 0x6c, 0x5e, 0x7a, 0x21, 0xad, 0x53, 0x4d, 0x5f, 0xd4, 0xfb, 0xc2, 0xab, 0xf5, 0x64, 0x6b, 0x3c, 0xd3, 0xfd, 0x3f, 0x3c, 0x32, 0x1d, 0x18, 0x8b, 0x60, 0x8c, 0xf6, 0xb6, 0x65, 0x78, 0x39, 0xae, 0x7a, 0x7e, 0x12, 0x49, 0x84, 0xe7, 0xae, 0xf6, 0x7a, 0x99, 0xc9, 0x39, 0xeb, 0x3b, 0xf3, 0xb5, 0x68, 0x58, 0x3c, 0xf9, 0xff, 0x13, 0xfd, 0xde, 0xfb, 0xac, 0x6b, 0x63, 0xd4, 0xe1, 0xd9, 0x96, 0x8f, 0xf, 0xdc, 0x22, 0x3d, 0x16, 0x4, 0x6b, 0x5a, 0xdb, 0x63, 0x1c, 0x89, 0xc, 0x89, 0xed, 0x79, 0x5d, 0xd3, 0x51, 0xcc, 0x51, 0x14, 0x48, 0x72, 0xe5, 0x7c, 0x75, 0xe, 0x7c, 0x1, 0x62, 0x6a, 0x81, 0xb3, 0x6b, 0xea, 0x86, 0x8d, 0x80, 0xd3, 0x19, 0xa4, 0xd0, 0xeb, 0xa3, 0xde, 0x56, 0xc4, 0x1e, 0x70, 0x6c, 0xe8, 0xd0, 0xb7, 0x7, 0x1b, 0x13, 0xb, 0xd9, 0x46, 0xbf, 0x5a, 0x7f, 0xd1, 0xf0, 0x77, 0x7b, 0x6c, 0x7a, 0xb9, 0xf0, 0x3d, 0xaf, 0x3e, 0xef, 0xa6, 0x2c, 0x63, 0xf4, 0xc, 0xd6, 0x5f, 0x4d, 0xc4, 0xf9, 0x57, 0xac, 0xf9, 0xc4, 0x85, 0x98, 0x19, 0x99, 0x1c, 0xd0, 0x37, 0x73, 0x70, 0xc5, 0x8a, 0x71, 0xb2, 0xe7, 0x8e, 0xe0, 0x82, 0xe2, 0xe, 0xc0, 0x9f, 0xda, 0x69, 0x12, 0x90, 0x24, 0x1f, 0x72, 0x2c, 0xa, 0x54, 0x12, 0x69, 0x6, 0xb9, 0x71, 0xc1, 0x8d, 0x76, 0x69, 0xb7, 0x95, 0x6d, 0xb, 0x20, 0xcf, 0xe4, 0x54, 0xf9, 0x3d, 0x88, 0x49, 0x23, 0x3, 0x40, 0xa9, 0x9e, 0xa2, 0x3b, 0x7f, 0x7, 0xdc, 0x75, 0x86, 0xc2, 0x93, 0xdd, 0xa, 0x96, 0xf9, 0xc2, 0xc9, 0x73, 0x19, 0x46, 0x54, 0x2c, 0xb, 0x39, 0xa8, 0xbd, 0x98, 0xf7, 0x7f, 0xa3, 0xf3, 0xcd, 0x1f, 0x7d, 0xc6, 0xaf, 0x97, 0x86, 0x29, 0x73, 0x0, 0xe7, 0xb0, 0xfb, 0x2c, 0x9a, 0x46, 0xdf, 0x2, 0x73, 0x2d, 0x76, 0x14, 0x43, 0xba, 0x36, 0xda, 0xab, 0xb8, 0xdf, 0xf1, 0xb8, 0x36, 0x47, 0x38, 0xb6, 0x5e, 0x4a, 0xd6, 0x56, 0x4b, 0x98, 0x2, 0x10, 0xc, 0x91, 0x0, 0xcb, 0x6b, 0x4c, 0x32, 0x59, 0xae, 0x7d, 0xb0, 0x0, 0x31, 0xda, 0x4d, 0x7b, 0x36, 0x3, 0x23, 0x44, 0xa1, 0x66, 0xde, 0xe3, 0x86, 0x7a, 0xe1, 0xae, 0x49, 0x9b, 0x89, 0xee, 0x27, 0xd, 0xd5, 0xe8, 0x7f, 0x42, 0x18, 0x73, 0x1, 0x2e, 0x24, 0x98, 0xb7, 0xae, 0x63, 0xd4, 0xf, 0x68, 0xa1, 0x23, 0xbd, 0xb2, 0x38, 0x19, 0x26, 0x53, 0x27, 0x3e, 0xb3, 0x60, 0xd8, 0x52, 0x25, 0x0, 0x24, 0xe2, 0x47, 0x17, 0x3, 0x77, 0x70, 0x45, 0x4e, 0x23, 0x4, 0x6c, 0x7d, 0xd8, 0x4f, 0x98, 0xd, 0x76, 0xc4, 0xa0, 0xfe, 0x11, 0xef, 0x4f, 0x2, 0xb9, 0x43, 0x5f, 0xdf, 0x33, 0x78, 0xe2, 0x1, 0x7f, 0x62, 0x27, 0x49, 0x33, 0xaa, 0x23, 0x60, 0x8f, 0x9a, 0xc4, 0x26, 0xd9, 0xaa, 0xec, 0xe6, 0x9, 0x74, 0x5c, 0x71, 0x46, 0x5e, 0xc8, 0x78, 0x6d, 0x4e, 0x7d, 0x6, 0xa9, 0x1b, 0x24, 0x49, 0x2f, 0x9f, 0x98, 0xca, 0x43, 0x70, 0x3f, 0xc, 0x4f, 0xa9, 0x7c, 0x7, 0x6e, 0xf, 0x5f, 0xf4, 0x60, 0x36, 0x50, 0x6b, 0x4e, 0xba, 0x5b, 0xa7, 0xa2, 0x67, 0x34, 0x6d, 0xab, 0x8e, 0x1a, 0x94, 0x62, 0xc9, 0x56, 0xe8, 0xf4, 0xc3, 0x78, 0x2c, 0x13, 0x53, 0xfd, 0x55, 0x84, 0xbb, 0xeb, 0xe9, 0xef, 0x40, 0xf9, 0x2c, 0x9e, 0x8f, 0xbb, 0x28, 0x60, 0x1b, 0x11, 0x38, 0xff, 0x8a, 0x38, 0x2, 0x13, 0xb6, 0x72, 0xf4, 0x26, 0x50, 0x18, 0xce, 0xd7, 0x63, 0xb, 0x51, 0x21, 0x80, 0x7b, 0xa5, 0xa9, 0xdd, 0x2f, 0xf1, 0x8, 0x6f, 0x7b, 0x70, 0x43, 0x1a, 0x9f, 0x22, 0x9f, 0x86, 0x95, 0xd6, 0xc6, 0x6e, 0xb8, 0xb9, 0xfb, 0x83, 0x72, 0xf, 0x7c, 0x1f, 0x6c, 0x3e, 0xa5, 0xa, 0xed, 0x0, 0xab, 0x32, 0x47, 0xdf, 0x97, 0x92, 0x88, 0xba, 0x61, 0x85, 0xd4, 0x24, 0xd5, 0x54, 0x85, 0x7, 0xd6, 0xa7, 0x3f, 0xb8, 0x16, 0x9b, 0x1e, 0x17, 0xdc, 0xe9, 0x27, 0xe0, 0xcc, 0xe7, 0x13, 0x23, 0xce, 0x25, 0xbc, 0x45, 0xb2, 0xd7, 0xac, 0x5, 0xe9, 0x27, 0x23, 0xad, 0x35, 0x7f, 0x8c, 0x90, 0xab, 0xb6, 0xa4, 0xb9, 0x6e, 0xdf, 0xf1, 0xa7, 0x69, 0x41, 0xf2, 0xc2, 0x4b, 0xfc, 0x57, 0x7d, 0x5b, 0x7d, 0x15, 0xd6, 0x25, 0xf, 0x87, 0xdb, 0xfe, 0x6, 0x33, 0x6, 0xf1, 0x93, 0x6, 0xd0, 0xed, 0x32, 0x9f, 0xdb, 0x6e, 0x5c, 0xdd, 0x6d, 0x6f, 0x6f, 0x21, 0xe0, 0x19, 0xe5, 0x8c, 0x3f, 0xfe, 0xc8, 0xbe, 0xdc, 0x57, 0x3, 0x6a, 0xb6, 0x9d, 0x9a, 0xe, 0x19, 0xda, 0x5c, 0x1d, 0xb8, 0xd0, 0xc6, 0xac, 0x80, 0x16, 0x87, 0xed, 0x61, 0x7d, 0xa9, 0x4f, 0x85, 0x16, 0x1d, 0x10, 0x86, 0x8a, 0x27, 0x7d, 0x93, 0x54, 0xce, 0x1e, 0x7a, 0xef, 0xec, 0xbf, 0xfc, 0xbb, 0xcd, 0x44, 0x1c, 0xa9, 0xfe, 0xfd, 0x36, 0x64, 0x6b, 0x28, 0xac, 0x5c, 0xe2, 0xd9, 0xaa, 0x6, 0x24, 0xa5, 0x50, 0x1b, 0xd8, 0xc5, 0xc2, 0xb2, 0xed, 0x8d, 0x1c, 0x89, 0xec, 0xbe, 0x58, 0xbd, 0xb, 0x37, 0x3b, 0x8, 0xe4, 0x2f, 0xb2, 0x22, 0xe7, 0xc4, 0xef, 0x4b, 0xc8, 0x6, 0x1e, 0x35, 0x55, 0x73, 0x42, 0x67, 0xc0, 0x74, 0x74, 0xb6, 0x75, 0xdc, 0xcf, 0x91, 0x56, 0xcd, 0x94, 0x73, 0x16, 0x4, 0xd0, 0x6f, 0x7c, 0xbf, 0x5f, 0xa2, 0x2c, 0x31, 0x69, 0x20, 0xfd, 0x64, 0x48, 0xc9, 0x35, 0xb5, 0xe5, 0x66, 0x3c, 0x95, 0x55, 0xd, 0x6, 0x34, 0xc2, 0x0, 0x65, 0x6a, 0x4, 0xc, 0xa2, 0x93, 0xfb, 0xda, 0xc3, 0xe0, 0x32, 0x39, 0xe0, 0xc6, 0xae, 0x4b, 0x19, 0x26, 0xa1, 0x60, 0x29, 0xd3, 0xfb, 0x0, 0xbd, 0x59, 0x5e, 0x8e, 0x83, 0x5b, 0x2, 0x88, 0x52, 0x75, 0x31, 0xe, 0xc2, 0x8b, 0x52, 0xb9, 0x8c, 0x5c, 0x7, 0x96, 0x29, 0xb8, 0x75, 0x4a, 0x14, 0xdd, 0x4d, 0x88, 0xb3, 0xfe, 0xa9, 0x48, 0xdf, 0xaf, 0xb2, 0x35, 0xda, 0x71, 0x2a, 0x6, 0x78, 0x43, 0x91, 0xd3, 0xbb, 0xb9, 0x1, 0x8d, 0x0, 0x54, 0x42, 0x7c, 0x1e, 0x92, 0x26, 0x6e, 0x98, 0xd, 0x87, 0x6b, 0x25, 0xd8, 0xd8, 0xd3, 0xe1, 0x63, 0xa9, 0xe5, 0x81, 0x2e, 0x4f, 0xab, 0x12, 0xa, 0x2e, 0x29, 0x7d, 0x2f, 0xac, 0xc6, 0x51, 0x25, 0x42, 0xb2, 0x54, 0x68, 0x2c, 0x8d, 0xc7, 0xbe, 0x6b, 0xd1, 0xac, 0xaa, 0x5d, 0x91, 0x73, 0x21, 0x71, 0x8f, 0x2a, 0x2c, 0x42, 0x4b, 0x3b, 0xce, 0x4e, 0x15, 0x7e, 0xe4, 0x42, 0x6e, 0xda, 0x54, 0xe2, 0x1c, 0xa2, 0xd3, 0x5f, 0x6b, 0x38, 0x76, 0x6a, 0x7f, 0x68, 0x4d, 0x39, 0xf8, 0xf3, 0xb9, 0x50, 0xc3, 0x68, 0xff, 0xb3, 0x3a, 0x8, 0xa7, 0x53, 0x37, 0x69, 0xcd, 0x77, 0x19, 0x95, 0x52, 0xd7, 0x73, 0x29, 0x4c, 0xec, 0x13, 0x5, 0xf, 0x4e, 0x7f, 0x65, 0xb5, 0x17, 0x5a, 0x54, 0xa8, 0x59, 0x1b, 0x7, 0x9e, 0x9b, 0xdb, 0x49, 0x6d, 0x59, 0x7c, 0x6, 0x54, 0x70, 0xe, 0x1f, 0xcf, 0x3a, 0xb5, 0xc9, 0x94, 0x21, 0x41, 0xc7, 0xbe, 0x48, 0x7b, 0x1d, 0x57, 0x38, 0x3d, 0x33, 0x4b, 0xe0, 0x37, 0xf4, 0x50, 0x20, 0x88, 0x5c, 0xfe, 0x71, 0xe4, 0x36, 0xa, 0xab, 0x5c, 0xf4, 0x7b, 0x12, 0x4f, 0xd, 0x35, 0x62, 0x77, 0xf, 0x1, 0x6, 0xf2, 0xa6, 0x6f, 0xc, 0xd7, 0xb5, 0xcb, 0xa8, 0x69, 0xee, 0x27, 0xec, 0x6a, 0xf4, 0xd6, 0x13, 0xea, 0x8a, 0x86, 0xfa, 0x99, 0xea, 0x78, 0xbd, 0x51, 0xf5, 0x5e, 0x89, 0x51, 0xaf, 0xdd, 0x38, 0xd, 0x2a, 0x3f, 0x7e, 0xa0, 0x77, 0xe6, 0x2b, 0x21, 0x5d, 0x78, 0x71, 0xfa, 0xff, 0x18, 0xd2, 0xf8, 0x7, 0xf6, 0xce, 0xcb, 0x50, 0xc1, 0x96, 0xc, 0x2a, 0x80, 0x1d, 0x7f, 0x4, 0x36, 0x79, 0x8, 0x77, 0xd1, 0xf1, 0x9b, 0x70, 0x8a, 0x18, 0x3b, 0x3a, 0x94, 0x9e, 0x35, 0x3, 0x46, 0x40, 0xd3, 0x80, 0x93, 0xa8, 0x9f, 0xcb, 0x7f, 0xd3, 0xba, 0xdb, 0x7, 0x7e, 0xc1, 0x50, 0x21, 0x87, 0xf4, 0xa1, 0x10, 0xf2, 0x6c, 0x69, 0xa1, 0x18, 0xf4, 0xdd, 0xe2, 0x29, 0x6f, 0x20, 0xa7, 0xc2, 0xd4, 0x44, 0x20, 0xe, 0x3b, 0x0, 0xb3, 0x12, 0xd8, 0x86, 0x3e, 0x47, 0x8f, 0xbf, 0xf8, 0xfc, 0x4f, 0x9a, 0x1f, 0x79, 0x2c, 0x2e, 0xde, 0xb4, 0xf7, 0x3f, 0x9a, 0x7c, 0x7c, 0x9e, 0x9a, 0xb4, 0xdc, 0xb7, 0xd7, 0xf5, 0xa3, 0x94, 0x3, 0xd3, 0xb0, 0xd1, 0x94, 0x5c, 0x2a, 0xf7, 0xc8, 0xf, 0x54, 0xff, 0x3e, 0xaa, 0xb8, 0xd7, 0xee, 0x5f, 0xf2, 0xb6, 0x69, 0xff, 0xfa, 0xae, 0x31, 0x9e, 0x6f, 0x4c, 0xfc, 0xc5, 0x4f, 0x6c, 0xff, 0xa7, 0x15, 0x69, 0x19, 0x59, 0xe3, 0x50, 0x4f, 0x33, 0x49, 0xe9, 0xd, 0x6f, 0x4, 0xef, 0x7b, 0xd0, 0x22, 0x2f, 0x57, 0xf1, 0x1c, 0x91, 0x2f, 0x44, 0x74, 0x4c, 0x2a, 0xd3, 0x10, 0x8d, 0xa3, 0x4, 0x99, 0x5c, 0xa7, 0xd9, 0xbd, 0xb3, 0x83, 0xb3, 0x2a, 0x81, 0x10, 0x82, 0x3d, 0x59, 0xa6, 0x2b, 0xc3, 0x2d, 0x61, 0xe, 0x8, 0x3b, 0xf4, 0x95, 0x60, 0xd7, 0x6d, 0xba, 0xec, 0x82, 0x29, 0x28, 0x18, 0x37, 0x7e, 0xa5, 0xea, 0x68, 0xed, 0x76, 0xda, 0xa1, 0x5b, 0x2b, 0xfa, 0xe0, 0x9d, 0x17, 0x29, 0xb4, 0x4a, 0xde, 0xeb, 0x45, 0xbd, 0x47, 0x9, 0xcc, 0x30, 0x6e, 0x31, 0x95, 0x3c, 0x74, 0xfb, 0x6f, 0xf0, 0x57, 0x57, 0xcd, 0xa9, 0xb0, 0xb4, 0x22, 0x74, 0x6b, 0x1c, 0xca, 0x7f, 0xa6, 0x7c, 0x29, 0xa, 0x8c, 0x50, 0xa8, 0x3c, 0x24, 0x2f, 0xb, 0xdf, 0x8a, 0xdd, 0xae, 0x3d, 0xac, 0xc6, 0x87, 0xf4, 0xf8, 0xa8, 0x9f, 0xd9, 0x7, 0x75, 0x90, 0x63, 0x4f, 0x98, 0x4a, 0x18, 0x71, 0xaa, 0xfb, 0xd9, 0xf2, 0xc3, 0x5b},
+               output224: []byte{0x35, 0x70, 0x7d, 0xd2, 0xa4, 0x4d, 0xe6, 0x66, 0x41, 0xdc, 0xfb, 0x35, 0xa0, 0x6f, 0xdc, 0x0, 0x1c, 0x74, 0xee, 0xc, 0x96, 0xec, 0xc1, 0x6b, 0x34, 0x69, 0x6f, 0xe1},
+               output256: []byte{0x17, 0xc8, 0xa5, 0xf5, 0x23, 0x64, 0xc9, 0xf6, 0x51, 0xde, 0x5f, 0x10, 0x2, 0x1e, 0x5, 0xda, 0xf6, 0xcc, 0x63, 0xd6, 0x8f, 0x66, 0x66, 0x6e, 0x76, 0x2e, 0xdb, 0xd7, 0x57, 0x52, 0x58, 0x82},
+               output384: []byte{0xd5, 0xf3, 0x78, 0x42, 0x1c, 0xac, 0x5, 0x82, 0xd1, 0xa2, 0xd1, 0x2c, 0x8c, 0x9b, 0x75, 0xc6, 0xa9, 0xa9, 0x5c, 0x74, 0x89, 0xb6, 0x94, 0xc0, 0xa6, 0x0, 0xae, 0xc6, 0x4, 0x7f, 0x54, 0xd3, 0x8b, 0x22, 0xdf, 0xff, 0xb6, 0x3b, 0x95, 0xe2, 0x35, 0xf3, 0x68, 0x28, 0x28, 0xae, 0xe6, 0x1e},
+               output512: []byte{0x9b, 0x73, 0x59, 0xf3, 0x5d, 0xf4, 0x10, 0x49, 0xe9, 0xf2, 0xd8, 0x47, 0xfe, 0xdc, 0xf2, 0xb7, 0x49, 0xbd, 0xec, 0x88, 0x62, 0x8a, 0x58, 0xbd, 0xd2, 0xf, 0xa7, 0xee, 0x57, 0x73, 0x5b, 0xb5, 0x42, 0x84, 0x3c, 0x48, 0x32, 0x2d, 0xe5, 0xa6, 0x11, 0x44, 0x13, 0x54, 0x6e, 0xf5, 0xe4, 0x3c, 0x4, 0x34, 0x5d, 0x98, 0xa8, 0xb3, 0x9e, 0x1e, 0x4a, 0x6b, 0xb, 0x97, 0xd0, 0x90, 0x5f, 0x69}},
+       testcase{
+               msg:       []byte{0xd8, 0xe, 0x6f, 0xe5, 0x9b, 0x72, 0x28, 0xd2, 0x5e, 0x78, 0x58, 0x6f, 0x94, 0xf2, 0x68, 0xea, 0x62, 0xeb, 0xe0, 0x42, 0x38, 0xab, 0x44, 0xe9, 0x73, 0x16, 0xb2, 0x2e, 0x96, 0xc9, 0x1d, 0x18, 0x6f, 0xac, 0x86, 0x2e, 0xba, 0x92, 0x12, 0xce, 0x84, 0x5b, 0xed, 0xc2, 0x3c, 0xec, 0x43, 0xfc, 0x3d, 0xa4, 0x2a, 0xa7, 0x2, 0x56, 0x37, 0xe0, 0xef, 0x65, 0x82, 0x3e, 0xba, 0x6f, 0xed, 0x26, 0x1a, 0xfe, 0x9a, 0x48, 0x7, 0x42, 0x58, 0xb2, 0x35, 0x55, 0x9a, 0x91, 0x6e, 0x64, 0x4b, 0xfb, 0xc9, 0xc3, 0xb6, 0xf4, 0x4d, 0x76, 0xe, 0x30, 0x47, 0xbf, 0x7c, 0x88, 0x5f, 0x9c, 0x70, 0xc4, 0x42, 0x46, 0xa8, 0x1d, 0x29, 0xf9, 0xc1, 0x5, 0x94, 0xb9, 0x35, 0x9e, 0xaa, 0x8c, 0x8c, 0x57, 0x2c, 0x71, 0x42, 0x6a, 0x93, 0xf, 0x2, 0xf2, 0x69, 0x2d, 0x50, 0x4e, 0xf, 0x19, 0xe1, 0x2f, 0x6b, 0xd1, 0x15, 0xc0, 0x85, 0x98, 0x8b, 0xbd, 0xf2, 0x74, 0x8a, 0x2e, 0xdc, 0xdc, 0xca, 0xa3, 0xd2, 0x93, 0x29, 0xb4, 0xe8, 0xa1, 0xa1, 0x7c, 0xc2, 0x2, 0x43, 0x19, 0x1d, 0x2a, 0xbc, 0x7a, 0x4c, 0xfe, 0x38, 0x42, 0x91, 0xfa, 0x8d, 0x7e, 0xc5, 0x78, 0x21, 0xe1, 0x21, 0x75, 0xa1, 0x56, 0xf8, 0x93, 0x58, 0x7e, 0x2d, 0xbd, 0x5f, 0xd3, 0x2c, 0x2c, 0x1a, 0x78, 0x4, 0x75, 0x6a, 0xec, 0x8f, 0xf1, 0x2b, 0xca, 0xd4, 0x30, 0x8d, 0xd3, 0x3e, 0xef, 0x5c, 0xff, 0x29, 0x83, 0x65, 0xf, 0xef, 0xc0, 0x4d, 0xdf, 0xc4, 0x30, 0x11, 0x7, 0x19, 0x3d, 0xfa, 0x9e, 0xb7, 0xe8, 0xa6, 0xea, 0x27, 0x48, 0x7, 0x28, 0x79, 0xb0, 0x63, 0xc7, 0xb0, 0x95, 0x56, 0x54, 0xae, 0x2a, 0x68, 0xbf, 0xf, 0x0, 0xc3, 0x7f, 0x3, 0x23, 0xc6, 0x45, 0x83, 0x10, 0xb4, 0x70, 0x7d, 0xd2, 0x46, 0x4d, 0xa5, 0xa5, 0x2b, 0x8a, 0x8e, 0x7c, 0xe6, 0x58, 0x99, 0x70, 0x11, 0x6b, 0xa9, 0x3e, 0xab, 0x20, 0x24, 0x4, 0xc, 0x45, 0xf2, 0x2e, 0x9b, 0x47, 0x8b, 0x34, 0xed, 0xff, 0x4b, 0xc8, 0x76, 0x89, 0x6d, 0x14, 0x31, 0x52, 0x56, 0x57, 0x32, 0xff, 0xf0, 0x4e, 0xfe, 0x65, 0x6e, 0x6, 0xea, 0xc3, 0x8f, 0x19, 0xf4, 0xee, 0xbf, 0xf2, 0x24, 0xe3, 0x21, 0x59, 0xab, 0x37, 0x55, 0x11, 0xb4, 0x2b, 0x6f, 0x74, 0x0, 0x1d, 0xdb, 0x15, 0xac, 0xc, 0xb4, 0xf6, 0xba, 0xec, 0x84, 0x90, 0x10, 0x59, 0x88, 0x2f, 0x58, 0xeb, 0xf9, 0x40, 0xcc, 0x97, 0x34, 0x22, 0xf6, 0xf6, 0x94, 0xa, 0x94, 0xc5, 0x10, 0x1e, 0xb2, 0x4e, 0xd2, 0x1b, 0xc0, 0xc4, 0x17, 0xd9, 0x59, 0xb4, 0xf0, 0x86, 0x93, 0x17, 0x3e, 0x88, 0xc6, 0xdb, 0xe2, 0x8b, 0x48, 0x7b, 0x3d, 0xc, 0xa0, 0xa, 0xf2, 0x62, 0x39, 0xb5, 0xb8, 0x99, 0x2c, 0x60, 0xec, 0x3b, 0xcd, 0x38, 0x55, 0xd2, 0xdb, 0x19, 0x7a, 0xc9, 0x5c, 0x48, 0x62, 0xb9, 0xb9, 0xc, 0x5b, 0x4a, 0xe3, 0x66, 0x75, 0x9a, 0x38, 0x86, 0x8a, 0x2b, 0x83, 0x8e, 0x36, 0xd7, 0xe4, 0x25, 0x52, 0xb3, 0x56, 0x6d, 0x7a, 0x28, 0xfe, 0x6e, 0x20, 0x8a, 0xe9, 0xc6, 0xae, 0xe5, 0x5, 0x24, 0x88, 0x1c, 0x48, 0x2b, 0x8f, 0x48, 0xe9, 0x13, 0x3a, 0xe2, 0xa9, 0xd9, 0x37, 0x7a, 0x6f, 0x96, 0x6f, 0x30, 0x60, 0x3e, 0x25, 0xa0, 0xff, 0x6, 0x10, 0x6b, 0x29, 0x25, 0x1, 0x23, 0x13, 0xcb, 0x3e, 0x79, 0xfa, 0x3f, 0xd, 0xad, 0xa7, 0xcc, 0x3d, 0x1, 0x5b, 0x4c, 0xb, 0xae, 0xa4, 0xa7, 0x9e, 0xc8, 0xe3, 0x7d, 0x79, 0x2f, 0xa1, 0x3c, 0x19, 0xaa, 0x17, 0x3e, 0x13, 0x47, 0x74, 0xdf, 0x39, 0x3e, 0x1d, 0xe9, 0x13, 0x33, 0x69, 0xe8, 0x58, 0xe4, 0x72, 0x0, 0x64, 0x8b, 0x44, 0x74, 0xf, 0x18, 0xbc, 0x5, 0x50, 0x26, 0x6f, 0x7e, 0xe7, 0x80, 0x5b, 0x85, 0xd8, 0xa1, 0x93, 0x68, 0xc6, 0x81, 0x10, 0xcd, 0x11, 0xf1, 0x40, 0x32, 0xa0, 0x99, 0xcc, 0x79, 0x7d, 0xb3, 0x93, 0x90, 0xc2, 0x93, 0xf, 0x68, 0x5, 0x9c, 0xa3, 0x15, 0x92, 0xfb, 0xe7, 0x36, 0x19, 0x4, 0x3e, 0x1c, 0x9, 0x57, 0x77, 0xd2, 0x97, 0x15, 0x8a, 0xe6, 0xc2, 0x8c, 0x86, 0x3f, 0xac, 0xe2, 0x29, 0x9e, 0xa4, 0x35, 0xcc, 0x1e, 0x7a, 0x9, 0xfb, 0x29, 0x7, 0x1c, 0x21, 0x78, 0x9, 0x24, 0xd2, 0xec, 0xc4, 0x1c, 0x9c, 0x97, 0x49, 0xda, 0x3e, 0xf0, 0x81, 0x9a, 0x41, 0xec, 0x8, 0x6c, 0xd2, 0xb7, 0x37, 0x8, 0x70, 0x69, 0x4b, 0x3, 0x92, 0xd1, 0x8b, 0x6b, 0x72, 0x1b, 0x81, 0x28, 0x2d, 0xad, 0xfe, 0x3c, 0x3c, 0x3f, 0xe2, 0x12, 0x88, 0xe9, 0x92, 0xc7, 0xe3, 0xa8, 0xfa, 0x68, 0x5f, 0x32, 0x30, 0x75, 0x29, 0xe6, 0xd5, 0xa, 0xcb, 0x42, 0x52, 0xd3, 0xe1, 0x70, 0x33, 0x4c, 0x42, 0xc7, 0xf, 0xab, 0x2, 0xdf, 0x83, 0x25, 0x69, 0xc7, 0xe5, 0xe0, 0x50, 0x42, 0xf7, 0x1a, 0x4f, 0xa9, 0x39, 0xb5, 0x85, 0x72, 0xcc, 0x8b, 0xc, 0xee, 0x43, 0x31, 0x22, 0x7, 0x42, 0xd2, 0xea, 0x9b, 0x11, 0x17, 0x36, 0x2a, 0x18, 0x31, 0xc8, 0x24, 0x7e, 0x1f, 0x6e, 0x1f, 0x42, 0xa8, 0x8f, 0xf5, 0xeb, 0x9a, 0xa6, 0x65, 0xf9, 0xa6, 0x37, 0xdb, 0x1b, 0xe7, 0xe4, 0xff, 0x5a, 0x75, 0xdc, 0x21, 0x13, 0x7a, 0x50, 0xd0, 0x70, 0x87, 0x18, 0x5d, 0xe1, 0x31, 0xb, 0xc5, 0xeb, 0x9, 0x84, 0x50, 0x91, 0x4b, 0x9c, 0x6a, 0xd8, 0xdd, 0xf6, 0x7a, 0xc0, 0xdc, 0xc9, 0x9a, 0xc6, 0x1c, 0x3c, 0xb0, 0x9b, 0x10, 0x1d, 0xf6, 0x27, 0x3e, 0xc, 0x3a, 0xbb, 0x37, 0x68, 0xf2, 0x4f, 0xd2, 0xc4, 0xbd, 0x2e, 0xf6, 0xdb, 0xec, 0xb1, 0xa1, 0xec, 0xde, 0x14, 0x18, 0xae, 0x5f, 0xca, 0x22, 0xd4, 0x1d, 0xba, 0xc, 0xb6, 0xc1, 0x6b, 0x6, 0xf2, 0xcd, 0x26, 0xfe, 0x16, 0x57, 0xc1, 0xea, 0x7a, 0xbe, 0xbc, 0x5b, 0xbc, 0x8d, 0xcb, 0x58, 0x73, 0x8f, 0x85, 0x5b, 0xf3, 0x8c, 0xd9, 0x6f, 0x29, 0xbf, 0x77, 0x32, 0xe9, 0x1b, 0x26, 0x1b, 0x70, 0xa7, 0x76, 0xee, 0xe6, 0x41, 0x45, 0xc1, 0x42, 0x1f, 0xa3, 0x0, 0xbd, 0xf8, 0xb, 0xdf, 0x64, 0x57, 0xe3, 0x18, 0xf9, 0xbe, 0xba, 0x22, 0x43, 0xce, 0x8c, 0xf5, 0x7d, 0xfa, 0x8b, 0xa0, 0xd5, 0xf1, 0x24, 0xaf, 0xc6, 0x85, 0x9d, 0xdb, 0xf, 0x3e, 0xd4, 0x57, 0xfc, 0xa6, 0x46, 0x23, 0xb5, 0x4a, 0x49, 0xbe, 0x58, 0x99, 0x53, 0x7, 0x8d, 0xfd, 0xa6, 0x57, 0x45, 0xfa, 0x39, 0xcf, 0xc, 0x4d, 0x98, 0x66, 0xc3, 0x8f, 0x76, 0x23, 0x1f, 0xcb, 0x44, 0xd3, 0x13, 0x1f, 0x8d, 0xf3, 0x89, 0xab, 0x75, 0x57, 0x42, 0xf1, 0x6d, 0xb2, 0x18, 0xb3, 0x97, 0x85, 0x28, 0x79, 0x97, 0x46, 0xa9, 0x9d, 0xc7, 0xe3, 0xa9, 0x58, 0x63, 0x25, 0x63, 0x74, 0x80, 0x39, 0xfd, 0xd9, 0xff, 0xcb, 0xff, 0x6f, 0x93, 0xbd, 0x83, 0xda, 0xcf, 0x6, 0xba, 0x93, 0xe3, 0x92, 0x51, 0x62, 0x1a, 0xf0, 0x2f, 0x81, 0x75, 0xcf, 0x54, 0x1f, 0xc, 0x80, 0xc, 0x5d, 0x2f, 0x5a, 0xf0, 0x68, 0x94, 0xb2, 0xfa, 0x14, 0xb9, 0xa6, 0xfa, 0xa3, 0xa3, 0xc9, 0x55, 0x70, 0x42, 0x36, 0x13, 0x29, 0x9f, 0x14, 0x1c, 0xe2, 0x5e, 0xe7, 0x7c, 0x2, 0x59, 0xa4, 0x2, 0x79, 0xa2, 0xff, 0x60, 0xb5, 0x1a, 0xca, 0xfc, 0xf8, 0x2c, 0xae, 0x42, 0x97, 0xe5, 0x78, 0x61, 0x64, 0x5d, 0xc7, 0x44, 0x2e, 0xb0, 0x52, 0x30, 0x90, 0x1, 0xe8, 0x9f, 0xf2, 0xff, 0x5b, 0xa4, 0x1f, 0x2f, 0x7d, 0x48, 0xfc, 0x9a, 0x49, 0xbd, 0x30, 0x62, 0xb8, 0xc, 0x75, 0xbe, 0x51, 0xfb, 0xcc, 0x87, 0x64, 0xad, 0x6d, 0x2e, 0x64, 0x75, 0x74, 0xed, 0xc0, 0x36, 0x60, 0xc9, 0xf4, 0xb7, 0xae, 0x58, 0x88, 0x86, 0x78, 0xde, 0xa4, 0xd6, 0xa5, 0xc2, 0x51, 0x2f, 0x12, 0xa6, 0xae, 0xcd, 0x30, 0x47, 0xad, 0x8, 0xcf, 0xec, 0xb6, 0xa4, 0xc9, 0x59, 0x93, 0x16, 0x4c, 0x58, 0x3c, 0x91, 0xfc, 0x85, 0x58, 0xca, 0xd1, 0x46, 0xc7, 0x3c, 0x7f, 0x4c, 0x24, 0x70, 0x4e, 0xbb, 0xd0, 0xd, 0x9d, 0xc2, 0xc7, 0x2f, 0x4a, 0xf1, 0xb2, 0x4f, 0x1d, 0xd5, 0xc0, 0xbf, 0x97, 0xc2, 0x83, 0xb7, 0xf6, 0x99, 0x37, 0xa6, 0xaf, 0xc, 0x5a, 0xb1, 0x95, 0xac, 0x8d, 0x17, 0x91, 0x69, 0xba, 0xb6, 0xb1, 0x41, 0xa5, 0xa6, 0x1f, 0x7f, 0xab, 0xd2, 0xb0, 0xa2, 0x3e, 0xa2, 0x9c, 0xc2, 0x95, 0xab, 0x4, 0xde, 0x12, 0x32, 0x90, 0x48, 0x50, 0x48, 0xe0, 0x6a, 0xf0, 0xec, 0x21, 0x1d, 0x93, 0xcd, 0xf8, 0xfe, 0xad, 0xa7, 0x22, 0xb8, 0x2b, 0x99, 0x41, 0x34, 0x91, 0x1b, 0x5e, 0xbc, 0xbf, 0x21, 0xd0, 0x13, 0xf, 0x91, 0xd, 0xde, 0x8c, 0xf7, 0xcd, 0x3e, 0x46, 0xc2, 0xbe, 0x4a, 0xe2, 0x67, 0x96, 0xf2, 0x5b, 0x65, 0x3f, 0x92, 0x65, 0x69, 0x37, 0x1e, 0xa0, 0x9c, 0x7a, 0x5e, 0x2f, 0x38, 0x56, 0x5d, 0x8, 0xc9, 0xd3, 0x77, 0xba, 0xf5, 0x1b, 0x6d, 0xc8, 0x54, 0x86, 0x6c, 0x50, 0x56, 0x3b, 0x9d, 0xa2, 0x6f, 0xa3, 0xe, 0xa, 0x87, 0xf5, 0xb2, 0xfc, 0x64, 0x72, 0x29, 0x15, 0x50, 0xfc, 0xc7, 0xa0, 0xc4, 0x23, 0xce, 0x82, 0xd0, 0xae, 0xf2, 0x4f, 0x54, 0xc0, 0x50, 0x87, 0x62, 0x7f, 0xde, 0x9c, 0x9e, 0xe2, 0xeb, 0xf2, 0x28, 0xd1, 0x22, 0x91, 0xb2, 0xb2, 0x5c, 0xc8, 0xfa, 0xca, 0xe9, 0xc6, 0x20, 0x9d, 0xc4, 0x35, 0x47, 0xba, 0x2, 0x8, 0xd3, 0x59, 0x67, 0x7c, 0x94, 0xfd, 0x17, 0xa7, 0x6d, 0xd, 0x84, 0xd9, 0xb1, 0x80, 0x84, 0xc8, 0xaf, 0xe1, 0x54, 0x8e, 0xf4, 0xb7, 0xfc, 0x94, 0xd7, 0x4, 0x50, 0x8, 0x7e, 0xdf, 0x3, 0x74, 0xcc, 0x41, 0x45, 0x61, 0xe6, 0x57, 0x5a, 0xd4, 0x1, 0xc9, 0x99, 0x8, 0xec, 0xf2, 0x8c, 0x6a, 0xee, 0x82, 0xf3, 0x41, 0x23, 0x79, 0xa8, 0x6f, 0x78, 0xea, 0x98, 0x41, 0xce, 0xa2, 0xd5, 0x97, 0x66, 0x43, 0x40, 0xe9, 0x7, 0x14, 0xc4, 0xf7, 0x54, 0x53, 0xcb, 0xc4, 0xc2, 0x4c, 0x96, 0x32, 0x64, 0xdc, 0x8f, 0x13, 0x48, 0x7a, 0xb, 0xfd, 0x4f, 0xd0, 0x4a, 0xca, 0x13, 0x15, 0xa1, 0xb7, 0xe, 0xb4, 0x88, 0x82, 0x65, 0x14, 0x3d, 0x82, 0xcd, 0x63, 0x4, 0x6f, 0xd, 0xaf, 0x27, 0xd8, 0xf1, 0xa6, 0xef, 0x98, 0x8f, 0x48, 0xd1, 0x3c, 0x56, 0xea, 0xbb, 0xbf, 0x27, 0xb5, 0x78, 0x5e, 0x51, 0xd6, 0x8d, 0xb0, 0x8b, 0x4a, 0xe2, 0xb9, 0x41, 0x15, 0x96, 0xae, 0x87, 0xc7, 0x60, 0xd2, 0x8a, 0x4e, 0x2c, 0x38, 0xa7, 0x6b, 0xd6, 0xb7, 0x15, 0x29, 0x3c, 0x59, 0x13, 0x1d, 0x3d, 0x63, 0x8, 0xc7, 0x22, 0x28, 0x24, 0x95, 0xbe, 0xa6, 0x90, 0x9, 0xca, 0x71, 0xaa, 0x78, 0xa2, 0x8b, 0x68, 0x1c, 0xb7, 0x82, 0xfe, 0x42, 0x74, 0xd4, 0x99, 0xa8, 0x56, 0xaa, 0xb6, 0xf1, 0x9f, 0xe9, 0xf8, 0x79, 0x31, 0xea, 0x93, 0x77, 0x4a, 0xb1, 0x3c, 0xa5, 0xb3, 0xe2, 0x9c, 0x1e, 0xc6, 0xb3, 0x0, 0xe6, 0x7e, 0x52, 0x5b, 0x94, 0x38, 0xc2, 0xf3, 0xc3, 0xaf, 0x3c, 0x38, 0x27, 0x60, 0x39, 0xfe, 0x82, 0xbb, 0x15, 0xca, 0xc8, 0x10, 0x13, 0xb1, 0x95, 0xea, 0x9c, 0x43, 0xb, 0x83, 0x81, 0xf7, 0x3b, 0x5f, 0x95, 0xcd, 0xfc, 0xe4, 0x3, 0xc0, 0x27, 0x7b, 0xe7, 0x7f, 0xb7, 0xd8, 0xcc, 0x38, 0xf5, 0xc0, 0x75, 0x34, 0x7c, 0xdf, 0x1d, 0xa4, 0x68, 0x98, 0x45, 0xd8, 0x3, 0xc9, 0x36, 0x9, 0x11, 0xf0, 0x15, 0x6f, 0x6c, 0x92, 0xb5, 0xf7, 0x75, 0xd5, 0x2, 0x67, 0x4c, 0xcd, 0x63, 0x5f, 0x64, 0x2b, 0x26, 0x6a, 0x2b, 0x3, 0x74, 0x8e, 0xd6, 0x24, 0x72, 0x50, 0xba, 0x23, 0x87, 0x88, 0x53, 0xec, 0xc6, 0x9c, 0xab, 0x7e, 0xef, 0x2a, 0x29, 0xa0, 0x8e, 0x29, 0x7, 0x2b, 0xdf, 0x32, 0xdb, 0x74, 0x2d, 0xe3, 0x68, 0x12, 0x5c, 0xdd, 0xb3, 0x69, 0x53, 0xd1, 0x57, 0x12, 0x30, 0x2a, 0x9e, 0x4a, 0xd5, 0x8c, 0x8c, 0x63, 0xc7, 0x72, 0x1d, 0x46, 0x47, 0xbd, 0xe4, 0xa1, 0x6e, 0x58, 0x21, 0x81, 0x14, 0x4a, 0xd9, 0xee, 0x4d, 0x51, 0x13, 0x3a, 0x55, 0x34, 0x93, 0x6f, 0xa3, 0xa7, 0x88, 0x4d, 0x9, 0x81, 0x78, 0x5f, 0x8e, 0xc5, 0x56, 0x50, 0x57, 0x38, 0xe5, 0x29, 0x30, 0x20, 0xa2, 0xfc, 0x31, 0xbc, 0x3d, 0x95, 0x8, 0xe, 0x1f, 0x74, 0x7b, 0x2e, 0x25, 0x28, 0x1e, 0xd2, 0x56, 0x54, 0xd, 0x27, 0x9c, 0x7, 0xfe, 0x32, 0x18, 0xa3, 0x5d, 0x45, 0x74, 0xd2, 0x2d, 0x41, 0x55, 0xe3, 0xf1, 0x2f, 0x74, 0x50, 0xf3, 0x7f, 0x8f, 0xec, 0x6c, 0x46, 0x75, 0x66, 0x74, 0x67, 0x20, 0x53, 0x8b, 0xd1, 0xa2, 0x97, 0xdd, 0x9b, 0x98, 0x7d, 0xba, 0xbf, 0x2d, 0x61, 0x10, 0xfe, 0xf5, 0x1b, 0x69, 0x91, 0x1, 0x2c, 0xf3, 0x38, 0xf2, 0x37, 0x1e, 0x39, 0x4f, 0x2d, 0x49, 0x67, 0xa7, 0xa4, 0x62, 0xc0, 0x54, 0xe4, 0x3b, 0xca, 0x22, 0x79, 0x4a, 0x20, 0x67, 0x58, 0x54, 0xd7, 0x42, 0xd4, 0x41, 0xf0, 0xaa, 0x28, 0x9b, 0xd, 0xbf, 0x55, 0xe4, 0x8f, 0xd, 0x49, 0x58, 0x64, 0xe3, 0xef, 0x5b, 0x14, 0x53, 0x51, 0xb9, 0x3a, 0x24, 0x59, 0xb6, 0xca, 0x84, 0x8f, 0x40, 0xdf, 0x1d, 0x8b, 0x58, 0x8f, 0xf6, 0x79, 0x77, 0x1c, 0xd, 0xcb, 0x69, 0xa7, 0x19, 0x6d, 0x19, 0xc1, 0x41, 0xea, 0x8, 0x46, 0xd5, 0xd2, 0x93, 0x4a, 0xa5, 0xc6, 0x62, 0xac, 0xf1, 0xa7, 0x85, 0x9d, 0xb2, 0xc0, 0x2c, 0x79, 0x12, 0x50, 0xbd, 0xc1, 0xf5, 0xac, 0xba, 0x56, 0x38, 0x81, 0x5d, 0xcf, 0xff, 0xc8, 0x58, 0xb0, 0xbf, 0x1e, 0x8, 0x6e, 0xad, 0xb, 0xe4, 0x6e, 0x9c, 0x40, 0x18, 0x15, 0x97, 0x29, 0xe6, 0x45, 0xc4, 0x86, 0xa4, 0x97, 0x3e, 0x6e, 0x13, 0x80, 0xf9, 0x85, 0x1, 0x28, 0xf0, 0x8f, 0x31, 0x5e, 0x9f, 0x9d, 0x6e, 0xfe, 0x64, 0xea, 0x21, 0xf, 0xb8, 0x7, 0xa, 0x49, 0x8f, 0x98, 0xa1, 0xec, 0xe8, 0xff, 0x42, 0x79, 0xb4, 0x2, 0x8e, 0xfc, 0x7d, 0x36, 0x34, 0xfa, 0x3c, 0xa8, 0xcf, 0xc1, 0xc, 0x58, 0xe3, 0x49, 0xb9, 0x88, 0xd3, 0xf6, 0xa1, 0x3a, 0x18, 0xb6, 0x48, 0x7b, 0x52, 0x6a, 0xc7, 0x79, 0xc8, 0x24, 0x73, 0xd1, 0x21, 0x45, 0x6e, 0xb2, 0xc1, 0x81, 0x67, 0xcd, 0xd7, 0x40, 0x18, 0xc0, 0x7, 0x9a, 0x53, 0x47, 0xc1, 0xf9, 0x87, 0x3c, 0xec, 0x0, 0x71, 0x5f, 0xf, 0xa5, 0x30, 0x55, 0xc, 0x81, 0x4c, 0xec, 0x5b, 0x96, 0x12, 0x1a, 0x99, 0x14, 0xa8, 0x29, 0x17, 0x13, 0xd6, 0xc7, 0xb9, 0xf6, 0x5a, 0x9e, 0x45, 0xb8, 0x5e, 0xa4, 0x3e, 0x93, 0xa7, 0x9d, 0xcf, 0xb9, 0xdc, 0x6a, 0x6b, 0xdc, 0xef, 0x82, 0x2, 0x42, 0xdf, 0xe7, 0xcf, 0xa4, 0xc2, 0xa5, 0x32, 0xe6, 0x37, 0x16, 0x81, 0xc8, 0xf3, 0x9f, 0xd6, 0x59, 0xa1, 0xf5, 0x45, 0x36, 0xec, 0xeb, 0x20, 0xfb, 0x52, 0x8c, 0x8b, 0x8b, 0xfa, 0x96, 0x6, 0x9f, 0xaf, 0xc4, 0xa8, 0xb2, 0x3d, 0xea, 0xf0, 0xab, 0x27, 0xd8, 0xe1, 0x90, 0xfa, 0x84, 0x66, 0x69, 0xf4, 0x3, 0xbe, 0xc4, 0xf3, 0x2, 0xc7, 0xcd, 0x5a, 0xb9, 0x97, 0x25, 0x29, 0x82, 0x7d, 0x58, 0x19, 0xe6, 0xd1, 0xfd, 0xf2, 0xb6, 0xcf, 0x2a, 0xfa, 0x57, 0x89, 0x9f, 0x8f, 0x9c, 0xbe, 0x1f, 0xcc, 0xbe, 0xbe, 0x8d, 0x73, 0x8e, 0x84, 0x77, 0x91, 0x34, 0x54, 0x56, 0x14, 0x24, 0x3a, 0x15, 0x56, 0xce, 0xb4, 0x60, 0x1e, 0xd1, 0xa6, 0xda, 0x90, 0x59, 0x9b, 0xd3, 0xb2, 0xe2, 0xae, 0xf9, 0xb0, 0x60, 0xe2, 0x7d, 0x87, 0x9d, 0x1e, 0x8, 0x12, 0x6, 0x51, 0x73, 0x94, 0x56, 0x6, 0x2a, 0x18, 0xca, 0xb9, 0x4a, 0xae, 0x28, 0x7, 0xce, 0x12, 0xfe, 0x7, 0x61, 0xaa, 0x96, 0x59, 0x8a, 0xc4, 0xd, 0x1d, 0xb8, 0x68, 0x87, 0x70, 0x80, 0x41, 0xa9, 0xd, 0x59, 0xc6, 0x6b, 0x37, 0xba, 0x63, 0xab, 0x40, 0x9c, 0x9f, 0xb0, 0x25, 0xc5, 0x99, 0x2b, 0x98, 0x5a, 0x35, 0xc1, 0xbc, 0x3f, 0xea, 0x87, 0xb7, 0x79, 0x1b, 0x6d, 0x8, 0x32, 0xa4, 0x61, 0xa5, 0x8b, 0x22, 0x19, 0x33, 0xd2, 0xb9, 0xad, 0x6c, 0xcd, 0x80, 0xe0, 0x8c, 0xb8, 0xf8, 0x5f, 0x52, 0xd3, 0xb9, 0xa0, 0xdd, 0x6e, 0xd5, 0x7a, 0xb7, 0xa6, 0x2f, 0x1a, 0xc7, 0x78, 0x34, 0xbb, 0x86, 0xfc, 0x54, 0x21, 0x31, 0xc7, 0x79, 0xda, 0xfe, 0xe3, 0xdf, 0x16, 0xe2, 0x6c, 0xeb, 0x9, 0x53, 0x66, 0x1a, 0xff, 0x0, 0x84, 0x3d, 0xef, 0x77, 0x21, 0x0, 0x11, 0x96, 0x50, 0x16, 0x94, 0x2b, 0x3f, 0xfa, 0xd4, 0x79, 0x74, 0x98, 0x17, 0xba, 0x8a, 0x85, 0xef, 0x28, 0x80, 0x91, 0xf9, 0x2e, 0xdb, 0xa1, 0x1d, 0x7f, 0xc0, 0x16, 0x81, 0xa8, 0x5, 0x13, 0xb3, 0x28, 0x18, 0x0, 0x63, 0x2a, 0x33, 0xb3, 0xa7, 0x3b, 0x4f, 0xf9, 0x18, 0x7c, 0x12, 0xa5, 0x70, 0x15, 0x20, 0x72, 0x4e, 0x77, 0xaf, 0xc8, 0x4e, 0x6a, 0x3f, 0xfc, 0xee, 0xc4, 0x39, 0xd5, 0x30, 0xb3, 0x8a, 0xbd, 0x98, 0x5, 0xee, 0xa, 0x80, 0x16, 0x83, 0x1c, 0xbf, 0xb5, 0x4b, 0x16, 0x7b, 0x65, 0xd4, 0x66, 0xf9, 0xee, 0xc8, 0x5, 0x8e, 0x13, 0xd2, 0x5f, 0x97, 0x7b, 0xcd, 0xcc, 0xf8, 0x2c, 0x72, 0x74, 0xad, 0x9a, 0x71, 0xdd, 0xac, 0x8a, 0x9, 0x28, 0xe5, 0x7b, 0x4c, 0xb7, 0x32, 0xde, 0xd8, 0xd3, 0x14, 0xe8, 0x31, 0x2f, 0x99, 0xef, 0xfa, 0xea, 0x2, 0x8c, 0xd4, 0x8b, 0xe6, 0x14, 0x25, 0x6c, 0x6d, 0x39, 0xca, 0xb, 0x2f, 0x77, 0xa1, 0x38, 0x29, 0xf1, 0x72, 0xaf, 0x85, 0xfa, 0x85, 0x7b, 0xb7, 0x34, 0x38, 0x3e, 0x75, 0x7a, 0xe, 0x52, 0x6b, 0x1, 0x9d, 0x18, 0x8d, 0xf1, 0x7b, 0xdd, 0x90, 0x81, 0x5c, 0xc9, 0xd, 0x28, 0x9e, 0x6f, 0xd1, 0x4, 0x8c, 0x9, 0x63, 0xd6, 0x5b, 0x5b, 0xda, 0x59, 0x5d, 0x34, 0xed, 0x76, 0xa, 0xa1, 0x6, 0x6f, 0x1e, 0x3d, 0x9e, 0x48, 0xae, 0x2a, 0x2d, 0xc4, 0x92, 0x70, 0x1e, 0x9c, 0xe4, 0x65, 0xbb, 0x5a, 0x39, 0xff, 0x72, 0x2c, 0xf5, 0x5e, 0x9e, 0x2f, 0x86, 0x11, 0x79, 0x9, 0x20, 0xa3, 0xee, 0xaa, 0xb9, 0xab, 0xb, 0xf8, 0x6e, 0xd2, 0x70, 0xfe, 0x65, 0x8c, 0x3a, 0x5f, 0x63, 0x3f, 0xff, 0x63, 0x3e, 0xce, 0x63, 0x9a, 0x93, 0x33, 0x2f, 0x3b, 0xff, 0x7, 0x46, 0xb5, 0xc4, 0xa5, 0xef, 0xe9, 0xae, 0x48, 0x44, 0xf9, 0x96, 0xfb, 0x84, 0x27, 0x48, 0xc2, 0xe2, 0x5e, 0xf2, 0x4b, 0x6d, 0xf, 0x8d, 0x5a, 0x47, 0x6b, 0xde, 0xb8, 0x32, 0x84, 0x44, 0xe4, 0x63, 0x93, 0xc0, 0x54, 0x4e, 0xc9, 0xf1, 0xd2, 0x8c, 0xb8, 0x3a, 0x8c, 0x96, 0x5e, 0xd, 0x9b, 0x6, 0x6d, 0xb0, 0x36, 0x6b, 0x43, 0x13, 0x6, 0x45, 0x9b, 0x6c, 0x83, 0x7d, 0xc9, 0xe6, 0x72, 0xfd, 0xba, 0x23, 0x4a, 0x12, 0xab, 0xec, 0x8c, 0x8c, 0x81, 0x3d, 0x2f, 0xf6, 0xfc, 0x62, 0x5d, 0xe9, 0x6d, 0x35, 0x46, 0x1c, 0xf7, 0x2e, 0xf1, 0x52, 0x9e, 0x54, 0x25, 0xea, 0x19, 0x88, 0xec, 0xda, 0x73, 0x81, 0xc0, 0xf8, 0x4d, 0x86, 0xeb, 0xa9, 0x8f, 0x4f, 0x4d, 0xf, 0x45, 0xf1, 0xc1, 0x6f, 0x5c, 0xb3, 0xf8, 0x45, 0x6d, 0xa4, 0xbe, 0xa3, 0x3, 0xf, 0x97, 0xb5, 0x6d, 0xd4, 0x94, 0xee, 0x97, 0xc6, 0x30, 0x65, 0x6e, 0x58, 0xab, 0xb7, 0xac, 0x6f, 0x2d, 0x86, 0x76, 0xc0, 0x4a, 0x34, 0xc2, 0xee, 0x4a, 0xb1, 0xbd, 0x10, 0xd1, 0x63, 0xd, 0xd5, 0x9b, 0x69, 0x99, 0xac, 0xda, 0x44, 0x7e, 0x64, 0x6a, 0x84, 0xaa, 0x66, 0xd5, 0x3c, 0x6a, 0xc0, 0xe3, 0xbe, 0xdd, 0xf, 0xc0, 0x1a, 0xea, 0x8a, 0xa9, 0xfc, 0x76, 0x48, 0xd4, 0x4b, 0xf5, 0x85, 0xf6, 0xf1, 0x33, 0xa2, 0x5a, 0x59, 0xd, 0x63, 0xb4, 0xa8, 0x3e, 0x65, 0x19, 0xf5, 0x28, 0xb3, 0x10, 0xbc, 0x3, 0xb9, 0xc9, 0x7f, 0xda, 0x5f, 0xe7, 0x0, 0x97, 0x8a, 0x66, 0xf1, 0xef, 0x42, 0x27, 0xaf, 0xb3, 0xcb, 0xec, 0x11, 0x2c, 0xc4, 0x55, 0x2d, 0xe5, 0xf6, 0x5, 0xd9, 0xcd, 0x7, 0x72, 0x12, 0x2b, 0x9, 0xae, 0x19, 0x6e, 0x87, 0x25, 0x82, 0x75, 0x38, 0xc4, 0x47, 0x3f, 0x82, 0xa3, 0xaa, 0xf, 0x69, 0x5c, 0x5c, 0x5d, 0x71, 0xf9, 0x1f, 0x16, 0xcc, 0x86, 0x74, 0x44, 0x5b, 0x79, 0x90, 0x77, 0xe5, 0x51, 0x6a, 0xb5, 0x58, 0x53, 0xd8, 0x6c, 0x1f, 0xe9, 0xe4, 0xbe, 0xe0, 0x6c, 0xbf, 0x8f, 0x96, 0x1, 0xe1, 0x46, 0x84, 0xb0, 0x5, 0x79, 0xf2, 0x77, 0x96, 0x4a, 0xa1, 0x62, 0xbe, 0xb9, 0x2a, 0xb4, 0x76, 0xe3, 0x22, 0xe7, 0xab, 0xa4, 0x64, 0xc0, 0x65, 0x7b, 0xcb, 0x65, 0x5, 0x9b, 0x47, 0x66, 0x8a, 0x82, 0x19, 0xf, 0xc0, 0x93, 0xba, 0x43, 0x3a, 0x16, 0xf3, 0x6b, 0x22, 0x93, 0x6a, 0xb3, 0xf, 0x67, 0x90, 0x60, 0x19, 0x7, 0x4, 0x8c, 0x6e, 0xcf, 0x7c, 0x4a, 0x41, 0xa4, 0x6, 0xec, 0xf8, 0x66, 0xd7, 0xa, 0x3a, 0x3a, 0xa2, 0xa1, 0xbc, 0x64, 0x72, 0xdd, 0xac, 0x9f, 0x97, 0xd3, 0x7a, 0xc7, 0x90, 0xc1, 0x17, 0xa6, 0x9, 0xdd, 0x37, 0x41, 0xfa, 0xc7, 0xa0, 0x11, 0x96, 0xa, 0xa6, 0xe2, 0x78, 0x10, 0xf, 0xa0, 0x4d, 0x34, 0x57, 0x96, 0x64, 0x5e, 0x59, 0x58, 0xa0, 0xae, 0xa, 0x68, 0xb3, 0xb6, 0xd3, 0xf1, 0x1d, 0xf7, 0x40, 0x39, 0x32, 0xe6, 0xaa, 0xbc, 0x33, 0x2a, 0x77, 0x41, 0x7f, 0x2f, 0xed, 0x36, 0x51, 0x66, 0x7b, 0xb0, 0x85, 0x91, 0x33, 0xc0, 0x73, 0x2c, 0x56, 0xec, 0x52, 0xac, 0xdf, 0x86, 0x14, 0x53, 0x4e, 0x4a, 0x2e, 0x0, 0x73, 0x43, 0x83, 0x33, 0x89, 0x7, 0x3d, 0xb6, 0xc2, 0x12, 0xe5, 0x67, 0xb7, 0x58, 0x8b, 0xb, 0xc8, 0x1f, 0xd, 0x62, 0x2e, 0x16, 0x46, 0xac, 0xda, 0xf, 0x5d, 0xfc, 0x80, 0x70, 0x73, 0xef, 0xa7, 0x79, 0xd6, 0x87, 0x35, 0x7c, 0xcd, 0x1d, 0x10, 0x2b, 0x2b, 0x61, 0x89, 0x68, 0xc, 0x50, 0x24, 0x35, 0xbc, 0x65, 0x22, 0xca, 0xf5, 0xcc, 0x16, 0xbe, 0xc7, 0x95, 0x17, 0x45, 0x3, 0xa8, 0x84, 0xfb, 0xf2, 0x9, 0xd0, 0xa2, 0x35, 0x76, 0x2c, 0x71, 0x62, 0xeb, 0xc6, 0x68, 0x28, 0xbb, 0x8f, 0x23, 0xdf, 0xdb, 0xb6, 0x46, 0x8a, 0x5e, 0x62, 0x29, 0x4d, 0x45, 0x97, 0xff, 0x4f, 0x91, 0xd9, 0x9c, 0xb1, 0x41, 0x7b, 0x68, 0x5c, 0xf1, 0x84, 0x9d, 0x9a, 0xbb, 0x58, 0xe6, 0x3f, 0xc7, 0x7f, 0x38, 0xe, 0xde, 0x5a, 0xc5, 0xe6, 0x58, 0xc1, 0x3, 0x41, 0x4f, 0x68, 0xde, 0x7e, 0xaf, 0xeb, 0x3e, 0x69, 0xe6, 0x64, 0x1c, 0x4, 0xb0, 0xca, 0x57, 0xc7, 0xe9, 0x38, 0xd9, 0xeb, 0xb2, 0x90, 0xd6, 0x1a, 0x2d, 0x42, 0xe1, 0xb5, 0xc0, 0xf9, 0x56, 0x0, 0x9a, 0x6a, 0x80, 0x40, 0x3e, 0xc, 0x77, 0x77, 0x3f, 0x28, 0x1e, 0xf6, 0x4, 0xc1, 0x95, 0x9e, 0xdf, 0xd1, 0xdf, 0x21, 0xd, 0xf1, 0x27, 0xc3, 0x2, 0x31, 0x1e, 0x4a, 0x71, 0xa7, 0x56, 0x22, 0xde, 0xf0, 0xf9, 0x1e, 0xca, 0x47, 0x17, 0xfa, 0xe4, 0x55, 0xdd, 0x9f, 0xea, 0x55, 0x7d, 0xeb, 0xa0, 0xeb, 0xe1, 0xaa, 0xb6, 0x18, 0x6a, 0xac, 0x0, 0x94, 0xef, 0x34, 0x44, 0x7c, 0x24, 0x12, 0x57, 0x6, 0x10, 0x2c, 0xb, 0x27, 0xe1, 0x7f, 0xdf, 0x4f, 0x1d, 0x22, 0xeb, 0xc6, 0x50, 0x6f, 0x28, 0x68, 0x5e, 0xd, 0x1d, 0x88, 0x6d, 0xd4, 0x17, 0x29, 0xf9, 0xba, 0xb6, 0x44, 0x86, 0xe7, 0xe9, 0x61, 0x55, 0xa2, 0x6c, 0xfe, 0xd6, 0x9d, 0xf3, 0xbd, 0xeb, 0x62, 0x77, 0x51, 0x89, 0xe9, 0xed, 0xe3, 0x9d, 0x7a, 0xd, 0x3, 0xc5, 0x11, 0xab, 0x4d, 0x60, 0x53, 0x43, 0x35, 0x6b, 0xad, 0x7a, 0xe8, 0x6f, 0x43, 0xe1, 0xe9, 0xea, 0xe2, 0x30, 0x30, 0x28, 0xd1, 0x87, 0xbc, 0x81, 0xfd, 0x33, 0x65, 0xd7, 0xb8, 0xe, 0x9, 0x4b, 0xa6, 0x29, 0xad, 0x56, 0xca, 0x35, 0x2f, 0x3d, 0xe8, 0xed, 0x6d, 0xfd, 0xbb, 0xe7, 0xd2, 0x6, 0x4c, 0x75, 0x7a, 0xf3, 0x6b, 0x7d, 0xb4, 0xef, 0xc0, 0xe9, 0xe8, 0xf2, 0xf2, 0x5e, 0x62, 0x82, 0x78, 0xf, 0x7e, 0x5, 0x9e, 0xc9, 0xab, 0xa8, 0xc0, 0x4f, 0x59, 0x13, 0xe9, 0x63, 0x29, 0x81, 0x24, 0x1f, 0x75, 0x51, 0x4c, 0x50, 0xd6, 0x50, 0x2d, 0x7b, 0x1, 0xf4, 0x0, 0x84, 0x22, 0x31, 0x8c, 0xb, 0xac, 0xe5, 0xd1, 0x35, 0x32, 0x7e, 0x9, 0xe4, 0xf9, 0x7f, 0xdb, 0xfd, 0x7c, 0xec, 0xda, 0xbb, 0xf1, 0x6b, 0xa2, 0x88, 0x7f, 0x76, 0xd9, 0x72, 0xe, 0x34, 0xc2, 0x6c, 0xb8, 0xd1, 0x99, 0xfb, 0x46, 0xb4, 0x86, 0xd4, 0x7e, 0x24, 0xff, 0x94, 0x3c, 0x1c, 0x23, 0xf3, 0xe9, 0x9e, 0x47, 0x2d, 0x96, 0xfb, 0x4b, 0x64, 0x77, 0xea, 0xc3, 0xf3, 0x64, 0xe0, 0x2f, 0xf1, 0x92, 0xf3, 0xfe, 0xfe, 0x13, 0xc6, 0x95, 0x60, 0xfd, 0x4f, 0x4a, 0x28, 0x30, 0xa3, 0xa7, 0x4b, 0xa8, 0xc8, 0xea, 0xeb, 0x82, 0xe8, 0x4d, 0x8e, 0xce, 0xb9, 0x83, 0xa6, 0xf1, 0xcb, 0x2, 0x4a, 0x9d, 0xff, 0xce, 0x69, 0xae, 0xd, 0xc7, 0x66, 0xfe, 0x28, 0x36, 0x19, 0xc1, 0x1c, 0x58, 0x85, 0xb2, 0xfd, 0xf3, 0x8e, 0x23, 0xb, 0x18, 0x7d, 0x82, 0x2c, 0xc6, 0xa5, 0x4a, 0x2b, 0x64, 0x30, 0x29, 0xa5, 0xd9, 0xaf, 0x17, 0xc5, 0xc7, 0x5, 0xf4, 0x14, 0x3, 0xae, 0x62, 0x95, 0x6d, 0x97, 0x7b, 0xbb, 0xc7, 0xce, 0x90, 0xc, 0xee, 0xc2, 0xb7},
+               output224: []byte{0x96, 0x56, 0xf2, 0x73, 0xcf, 0x78, 0xf3, 0x61, 0x3d, 0x93, 0x1d, 0x50, 0x27, 0x8e, 0x27, 0x36, 0x43, 0xcd, 0x66, 0x62, 0xc4, 0x8d, 0x24, 0x3a, 0x11, 0x5c, 0xad, 0x65},
+               output256: []byte{0x2, 0x38, 0xb0, 0xa1, 0xe3, 0x57, 0xc7, 0x38, 0x21, 0x29, 0xad, 0x29, 0x40, 0xed, 0x71, 0x82, 0xf, 0x7d, 0x45, 0xa7, 0xf0, 0xf2, 0x62, 0x93, 0x91, 0xc1, 0x8, 0x29, 0xae, 0x80, 0x1b, 0xf5},
+               output384: []byte{0x0, 0x6, 0x2a, 0x3e, 0xcb, 0x49, 0x1a, 0x34, 0x68, 0x1a, 0x52, 0xd1, 0x16, 0xde, 0x2f, 0xa, 0x66, 0x1a, 0x53, 0x52, 0x24, 0xca, 0xd8, 0x82, 0x86, 0x2f, 0xd8, 0xa6, 0x8b, 0x15, 0x2a, 0x5f, 0x54, 0xd3, 0x4, 0xbf, 0x8f, 0x1b, 0x7d, 0x61, 0x47, 0x16, 0x4c, 0xb6, 0x6a, 0x43, 0xc6, 0xb7},
+               output512: []byte{0xe6, 0x67, 0x4b, 0x97, 0x8b, 0x94, 0xaa, 0xfa, 0x19, 0xe4, 0x49, 0xd3, 0xdb, 0xf9, 0xc8, 0xd5, 0x87, 0x1, 0x8, 0x4b, 0x0, 0x29, 0x62, 0xca, 0xd7, 0x99, 0xc5, 0x68, 0x83, 0x17, 0x10, 0x13, 0xd, 0xa7, 0x78, 0x28, 0x19, 0x54, 0x55, 0x8a, 0x61, 0x94, 0xd5, 0x1c, 0xb7, 0x79, 0x31, 0xc5, 0x17, 0x89, 0xb9, 0xf8, 0xdf, 0x2, 0x55, 0xa8, 0x1b, 0x2a, 0xad, 0xf4, 0xf, 0x7f, 0x2, 0x3f}},
+       testcase{
+               msg:       []byte{0x35, 0x81, 0xd4, 0xae, 0xf0, 0x86, 0xc, 0x17, 0x29, 0xeb, 0x3e, 0x6b, 0x50, 0x4f, 0x0, 0x91, 0x9c, 0x65, 0x6a, 0x1c, 0x56, 0xc1, 0x1, 0x11, 0xd2, 0x1a, 0x2f, 0x9a, 0x77, 0xec, 0xe, 0xf7, 0x11, 0x8b, 0xff, 0x2a, 0x88, 0x19, 0x73, 0xcb, 0xa4, 0x66, 0x86, 0xd4, 0xf1, 0x4, 0xcc, 0x94, 0xc3, 0xb, 0x93, 0xf6, 0x27, 0x69, 0xaa, 0x2c, 0xf, 0x4c, 0x7f, 0x3f, 0xb9, 0x31, 0xb6, 0x96, 0xdd, 0xb6, 0x32, 0xb0, 0xfe, 0x71, 0xd5, 0x7c, 0xad, 0xfe, 0x27, 0x57, 0x39, 0x13, 0xce, 0xa4, 0x88, 0xa6, 0x8d, 0xe, 0x45, 0xb9, 0xc, 0xce, 0xda, 0x68, 0xd9, 0x66, 0xb7, 0x25, 0x15, 0x2c, 0xcf, 0x5, 0x47, 0x57, 0x21, 0x1d, 0x4e, 0x9e, 0xb4, 0x2a, 0x97, 0x30, 0x8c, 0x6a, 0xf1, 0xe0, 0xb7, 0xa0, 0xdf, 0x67, 0xc6, 0x1f, 0x93, 0x57, 0xa1, 0x54, 0x2c, 0xea, 0xbf, 0x0, 0xc, 0xfd, 0xaa, 0x1f, 0xbe, 0x71, 0xd3, 0x5, 0x30, 0xd, 0x43, 0xa4, 0x48, 0xa4, 0x84, 0x5e, 0xc9, 0x4d, 0xf6, 0x96, 0xc7, 0xc0, 0x12, 0x9b, 0x8, 0x8a, 0xaa, 0xc2, 0x9a, 0x43, 0xbc, 0xe1, 0x97, 0x26, 0xf9, 0x4d, 0xfb, 0xad, 0xe2, 0xd0, 0xf7, 0xcd, 0x7c, 0x4e, 0xf0, 0xfc, 0xe1, 0x26, 0x81, 0xfb, 0xe4, 0x96, 0xbe, 0xe9, 0xd7, 0x72, 0x5f, 0x54, 0x92, 0x81, 0xf4, 0xae, 0x66, 0x61, 0x10, 0xbf, 0x40, 0xf5, 0x23, 0x55, 0x26, 0x60, 0x61, 0x27, 0xee, 0x4, 0x1c, 0x9, 0x87, 0x4c, 0x10, 0x3c, 0xae, 0xc8, 0xee, 0x32, 0xd, 0x5e, 0x9f, 0x2d, 0x62, 0xbd, 0xbc, 0xe3, 0x21, 0xfd, 0xf7, 0x68, 0x1f, 0xc9, 0x88, 0xf4, 0x53, 0xef, 0x99, 0x9b, 0x9f, 0xff, 0xd9, 0xdc, 0x28, 0x5b, 0xed, 0xd0, 0xeb, 0xd3, 0x6f, 0xc2, 0x2b, 0x61, 0x37, 0x65, 0xa3, 0x4b, 0xc0, 0x97, 0xdc, 0xd1, 0xf1, 0x9b, 0x14, 0xc6, 0x1, 0x40, 0xc8, 0xe2, 0x3d, 0x78, 0x94, 0x13, 0x23, 0x43, 0xff, 0xc2, 0xb8, 0xed, 0x14, 0x4d, 0x90, 0x55, 0xd2, 0x79, 0x5c, 0xbb, 0x20, 0xb8, 0xfe, 0xe9, 0x23, 0x63, 0xf6, 0x67, 0x2b, 0xea, 0x4d, 0x40, 0xf9, 0xac, 0xd5, 0x5a, 0x2b, 0xe2, 0x7c, 0xf8, 0x13, 0xb0, 0x59, 0x9c, 0xab, 0x2e, 0x8, 0x22, 0x5c, 0x4f, 0x90, 0x9e, 0x7b, 0x64, 0x7a, 0x39, 0xf8, 0x88, 0xb9, 0x37, 0xe, 0xc6, 0x9b, 0x2a, 0x6e, 0x65, 0x91, 0x60, 0x4a, 0x38, 0xa5, 0xbc, 0x2e, 0xa, 0xbf, 0x8b, 0x72, 0x2e, 0x9a, 0xa2, 0xf0, 0x5a, 0xd9, 0xae, 0xde, 0xf5, 0x5a, 0x37, 0x81, 0xf, 0x93, 0x5a, 0x46, 0xee, 0xe3, 0x33, 0x89, 0xc3, 0x75, 0x61, 0x39, 0x41, 0x10, 0x2d, 0x67, 0xc, 0xa6, 0x70, 0x95, 0x6, 0x86, 0x1b, 0xed, 0xd3, 0xdc, 0xd0, 0xf1, 0x46, 0x7f, 0x4a, 0xa, 0xb6, 0x81, 0x8, 0x4b, 0xd4, 0x82, 0x73, 0xf, 0x7c, 0x75, 0x3f, 0xa3, 0xf5, 0xab, 0x47, 0xb7, 0x84, 0x5c, 0x5c, 0xb1, 0x7d, 0x17, 0x39, 0x25, 0x81, 0x21, 0x9a, 0xf4, 0x40, 0xcd, 0x67, 0x1, 0x39, 0x86, 0xca, 0xc4, 0xff, 0xa4, 0xb6, 0xfa, 0x0, 0x4e, 0x7b, 0x5e, 0xee, 0x95, 0x74, 0x2e, 0x7c, 0x40, 0x4, 0x4b, 0x9c, 0x5a, 0x46, 0x91, 0xc2, 0xb5, 0x84, 0xdd, 0xe6, 0xa8, 0xa4, 0x5a, 0x36, 0x48, 0x1e, 0x71, 0x5d, 0x6d, 0x9f, 0xb2, 0x73, 0x4e, 0x53, 0x39, 0xdd, 0x5a, 0x18, 0x56, 0x39, 0x2e, 0x8f, 0xec, 0xc4, 0x16, 0x77, 0x88, 0x5, 0x11, 0x79, 0x89, 0xe3, 0xd, 0x42, 0x2a, 0xb8, 0xd3, 0x58, 0xb6, 0x90, 0x78, 0x7e, 0x9f, 0xed, 0x37, 0x67, 0xa4, 0x8, 0xdd, 0x99, 0x23, 0x44, 0x63, 0xb2, 0x5b, 0x91, 0xc3, 0xa, 0xbb, 0x93, 0xf3, 0xce, 0xec, 0x89, 0x82, 0x3c, 0x37, 0x2, 0x3e, 0x73, 0x93, 0xf2, 0x9f, 0x50, 0x65, 0xac, 0xd4, 0x99, 0xd2, 0x2e, 0x13, 0xb5, 0x90, 0x98, 0x57, 0x18, 0xf, 0x77, 0x85, 0x74, 0x97, 0x34, 0x2, 0x7a, 0xeb, 0x84, 0x32, 0x45, 0xf5, 0x56, 0x9c, 0x71, 0x5a, 0x88, 0x1a, 0x1e, 0x75, 0x54, 0x17, 0x9d, 0x5d, 0x99, 0x3f, 0xad, 0xff, 0x2a, 0xae, 0x71, 0xcb, 0x0, 0x16, 0xe1, 0x45, 0x9a, 0xe6, 0xc2, 0xec, 0x79, 0x54, 0xc0, 0xb6, 0xcc, 0x8b, 0xb1, 0x11, 0x6b, 0xbb, 0x8c, 0xbd, 0x81, 0xcb, 0x62, 0xdd, 0xe5, 0x74, 0x42, 0xf6, 0x2, 0x14, 0x7c, 0xbc, 0x64, 0xc2, 0xa4, 0xc4, 0x56, 0xc1, 0x52, 0x3b, 0x80, 0x75, 0xd0, 0xde, 0xfa, 0x5, 0x35, 0x78, 0xc3, 0x14, 0x92, 0xb3, 0x23, 0x4c, 0xc7, 0x37, 0xa, 0xea, 0x59, 0x3a, 0xec, 0x3, 0x59, 0xab, 0xe3, 0xd1, 0xc7, 0x43, 0x1c, 0xb6, 0x29, 0x73, 0xe9, 0x3b, 0xc, 0xf3, 0xc3, 0x70, 0x18, 0xb4, 0x68, 0x26, 0x7b, 0x66, 0x4d, 0xb3, 0xf4, 0x5f, 0xce, 0xe7, 0x37, 0xcf, 0xf9, 0x76, 0xbc, 0xe3, 0x5e, 0x6, 0x1a, 0xef, 0x48, 0xe8, 0xcb, 0x20, 0xf0, 0x46, 0x1d, 0x72, 0x9f, 0xd1, 0x69, 0x1e, 0xd, 0x2f, 0x8f, 0x2e, 0xd, 0x44, 0xf7, 0x7b, 0x64, 0x1, 0x31, 0xb9, 0xe6, 0x2b, 0x80, 0xc7, 0x51, 0xd0, 0x18, 0x6f, 0x18, 0x37, 0x60, 0xb6, 0x32, 0x96, 0xb6, 0xbd, 0xce, 0x97, 0xa9, 0xc0, 0xab, 0x4c, 0xc3, 0x7a, 0x27, 0xa8, 0x5e, 0x18, 0x97, 0xf6, 0xde, 0x52, 0xdf, 0x9f, 0xb, 0x8, 0xf3, 0x7c, 0x85, 0xf, 0x24, 0x5, 0x83, 0x1c, 0xbe, 0x98, 0x26, 0xf3, 0x58, 0x4e, 0x99, 0xf7, 0x81, 0x1f, 0x8, 0xfd, 0x5, 0xb3, 0x35, 0xf6, 0xd0, 0x74, 0x9, 0xa8, 0x2, 0x29, 0xa5, 0x67, 0x76, 0x3a, 0xd8, 0xf2, 0x5, 0x39, 0xe1, 0x64, 0x12, 0x36, 0xe8, 0x7a, 0x7c, 0xd3, 0xc8, 0x47, 0xc9, 0xe8, 0xec, 0x6, 0x3a, 0x5a, 0x8d, 0x21, 0xf7, 0x7f, 0x94, 0x1c, 0xa7, 0xa5, 0x6e, 0x23, 0xf9, 0x1, 0x30, 0xb7, 0x47, 0x98, 0xb7, 0x1e, 0x7a, 0x9c, 0xf8, 0x41, 0x67, 0x39, 0xa4, 0xc7, 0x50, 0xc0, 0xd5, 0x75, 0x2a, 0x78, 0x1b, 0x11, 0xf9, 0x94, 0xa0, 0xb0, 0xe1, 0xcb, 0x6d, 0x83, 0x77, 0x48, 0x8e, 0xc2, 0xde, 0x64, 0x29, 0x3, 0xf9, 0xb4, 0x46, 0x57, 0xe8, 0x5d, 0x8a, 0x21, 0x3f, 0x1f, 0xc8, 0xe, 0x67, 0x4d, 0xff, 0xb7, 0x47, 0xc6, 0x3a, 0xac, 0x85, 0xe6, 0x2e, 0x29, 0x54, 0x28, 0xaa, 0x31, 0x5f, 0x60, 0x58, 0x5b, 0xb5, 0xd5, 0x20, 0x35, 0x98, 0xdb, 0x4f, 0x6b, 0xa7, 0x8f, 0xbf, 0x3f, 0x5, 0x3d, 0x57, 0x95, 0x34, 0xa0, 0xc2, 0x70, 0xb5, 0x42, 0xda, 0x82, 0x84, 0x8b, 0x81, 0x89, 0xde, 0x8a, 0x77, 0xa3, 0x39, 0xd0, 0x5, 0x2b, 0x74, 0xb2, 0x1d, 0x80, 0x62, 0x17, 0xe9, 0x2, 0xd9, 0xde, 0xee, 0x2f, 0xbe, 0x97, 0xdb, 0x9e, 0x41, 0x4c, 0xa9, 0x43, 0x9e, 0xce, 0x35, 0x3f, 0xe0, 0xea, 0x8a, 0x72, 0xed, 0x21, 0x16, 0xf0, 0x2, 0x36, 0x5c, 0x88, 0xaf, 0x5, 0xd0, 0xe8, 0x3, 0xab, 0x49, 0x4c, 0x3d, 0x17, 0x20, 0x29, 0x7a, 0xce, 0x85, 0x8c, 0xad, 0x90, 0xd3, 0xe, 0x81, 0x85, 0xd0, 0x2d, 0xe9, 0xbb, 0x4c, 0xc3, 0x40, 0x97, 0x72, 0xc0, 0x87, 0x34, 0xcd, 0xbc, 0xe2, 0x2b, 0x49, 0x86, 0x61, 0xd7, 0x3a, 0x18, 0xfe, 0x27, 0x38, 0x29, 0x7f, 0x25, 0xf5, 0x46, 0x6b, 0xec, 0xf4, 0xdf, 0x3b, 0xe1, 0xf3, 0xd9, 0x16, 0xd, 0xef, 0x55, 0x66, 0x31, 0x86, 0x20, 0xa2, 0x2c, 0xb, 0xcc, 0x27, 0xe9, 0x1c, 0xbb, 0x3f, 0x1c, 0x58, 0x6f, 0xc8, 0xe0, 0x9c, 0x60, 0xdc, 0xd4, 0x24, 0xe8, 0xc6, 0x84, 0x18, 0xec, 0xce, 0x19, 0x3f, 0xe2, 0x9e, 0x45, 0x29, 0xe1, 0x41, 0x9b, 0x1b, 0xe, 0xa3, 0x59, 0x7a, 0x98, 0xf1, 0x9e, 0x99, 0x9c, 0x78, 0xe, 0x54, 0x30, 0x68, 0xca, 0xc8, 0x4d, 0x7e, 0xa2, 0x26, 0xff, 0xd5, 0x35, 0xf7, 0x5d, 0xe1, 0x51, 0x34, 0x55, 0x6d, 0x8d, 0x63, 0x70, 0x64, 0xcf, 0x85, 0xf6, 0x27, 0x99, 0xcb, 0xc1, 0x5f, 0xa4, 0x6a, 0x62, 0xc0, 0x3b, 0x0, 0x12, 0xaf, 0x46, 0x15, 0xf7, 0xcc, 0x4a, 0x6f, 0xd0, 0x93, 0x96, 0xa1, 0xa6, 0xd1, 0x3d, 0x55, 0xd2, 0x7c, 0xc7, 0x6e, 0x9d, 0xd0, 0x95, 0x97, 0xd6, 0xbe, 0xcc, 0x4, 0x67, 0xb0, 0x98, 0xf5, 0xde, 0xc0, 0x34, 0xeb, 0xca, 0xe7, 0xa6, 0x60, 0x39, 0x45, 0x21, 0xcf, 0xf7, 0xd8, 0x2b, 0xd4, 0x18, 0xff, 0x8c, 0xef, 0x7c, 0x1e, 0x5c, 0xf, 0xbe, 0x1c, 0x1f, 0x26, 0x2b, 0x4d, 0xfa, 0x18, 0x6c, 0x78, 0x5b, 0x0, 0xce, 0x61, 0x4c, 0x45, 0x58, 0xd9, 0x37, 0x16, 0xe1, 0x77, 0x66, 0xd4, 0xd5, 0xea, 0xc4, 0xb0, 0xb8, 0x1c, 0xb, 0x86, 0x6e, 0x41, 0xe6, 0x8b, 0xa0, 0xbe, 0x22, 0x2d, 0x32, 0xf8, 0xd8, 0x35, 0x7, 0x92, 0x54, 0x17, 0xba, 0xfe, 0xc4, 0xb7, 0xee, 0x39, 0xc3, 0x74, 0x41, 0x2f, 0x71, 0x76, 0x7d, 0xf7, 0x83, 0x76, 0x60, 0x5a, 0x0, 0x29, 0x90, 0x84, 0x5b, 0x9e, 0x79, 0x10, 0x11, 0x72, 0x41, 0x51, 0xcd, 0x3e, 0xf2, 0x61, 0x91, 0xe6, 0xc2, 0xdb, 0x99, 0xae, 0xe, 0xca, 0x55, 0x79, 0xf3, 0xa2, 0x4d, 0x2, 0x1f, 0x15, 0xa0, 0x93, 0x19, 0x23, 0x55, 0x8, 0x13, 0x5b, 0x39, 0x6e, 0x97, 0x81, 0x9d, 0xcf, 0xf8, 0x36, 0x17, 0xe6, 0x41, 0xd6, 0x77, 0x88, 0x29, 0xd6, 0xe3, 0xa2, 0x6f, 0x71, 0x86, 0xef, 0xb1, 0x4d, 0xde, 0xaf, 0x21, 0x13, 0xb9, 0xea, 0x53, 0x8f, 0xfb, 0x2c, 0x22, 0x7, 0xb7, 0x37, 0xf7, 0xb7, 0x8, 0xef, 0x54, 0xc1, 0x62, 0x52, 0xf2, 0xa6, 0x32, 0x97, 0xfe, 0x57, 0x10, 0x34, 0xfb, 0x4b, 0xca, 0xa1, 0xea, 0x6c, 0x4b, 0x65, 0x1, 0x7f, 0xb4, 0xec, 0x70, 0x50, 0xbd, 0xfa, 0x24, 0xba, 0xcb, 0x1a, 0xfe, 0x2e, 0x2d, 0x52, 0x6e, 0xe2, 0x78, 0x4e, 0x1a, 0xc9, 0x25, 0x12, 0xe4, 0xef, 0xdd, 0xb7, 0x2e, 0x4b, 0x12, 0x81, 0x9, 0x97, 0xcd, 0xc3, 0x9e, 0xa1, 0xa8, 0x27, 0xfa, 0x8, 0xdd, 0x2d, 0x7d, 0x88, 0xe7, 0x81, 0x86, 0x2e, 0x7c, 0x5b, 0xd9, 0x64, 0xa1, 0x43, 0xf6, 0x12, 0x23, 0x42, 0x36, 0x89, 0xb8, 0x16, 0x75, 0x23, 0x1c, 0xf9, 0x7c, 0x64, 0xa3, 0xa7, 0x16, 0x18, 0xf7, 0xcf, 0x6a, 0x44, 0xce, 0x45, 0x80, 0x37, 0x73, 0xa, 0x25, 0x92, 0x71, 0x15, 0x82, 0xea, 0x9d, 0x9e, 0xff, 0x63, 0x40, 0xf, 0xca, 0x70, 0xb7, 0xb5, 0x25, 0x1d, 0xa7, 0xd, 0xa3, 0xd3, 0x39, 0xb7, 0x68, 0x76, 0x21, 0x11, 0xd2, 0x7b, 0x1a, 0x2e, 0x9c, 0xa5, 0x59, 0xf5, 0x44, 0xad, 0xf0, 0xf, 0x8c, 0x23, 0x72, 0xcf, 0xbf, 0x3, 0xc2, 0x15, 0xb7, 0x5c, 0xef, 0xbd, 0xd6, 0xb3, 0x63, 0x4a, 0x8f, 0xd1, 0x5, 0x4a, 0x5c, 0x1, 0x6f, 0xf1, 0xfe, 0xaf, 0x5, 0x26, 0xed, 0x8b, 0x96, 0x8c, 0xb4, 0x4d, 0x27, 0x9c, 0x4, 0x15, 0x9e, 0x77, 0xa0, 0x28, 0x97, 0x17, 0xd3, 0xe2, 0x51, 0x5d, 0xb6, 0xa7, 0xb5, 0xb4, 0x86, 0x6, 0x81, 0xcf, 0x8c, 0x7a, 0x15, 0x89, 0xa3, 0xd8, 0x5c, 0x57, 0x24, 0xa2, 0x89, 0x76, 0x19, 0x33, 0x12, 0xad, 0xa2, 0x4c, 0x23, 0x97, 0xd2, 0xc1, 0xb, 0xaf, 0x2f, 0xa9, 0x33, 0xd7, 0x1f, 0x2b, 0xb2, 0x79, 0x41, 0x90, 0x73, 0x2, 0x42, 0xe1, 0x17, 0xc9, 0xf, 0xaa, 0x63, 0x91, 0xfd, 0xac, 0x1e, 0xc6, 0x1c, 0xe7, 0x80, 0xa7, 0x86, 0x4f, 0x6f, 0x1d, 0x6d, 0x8c, 0xc1, 0x9c, 0x2, 0x4f, 0x47, 0x91, 0xb4, 0x92, 0x8f, 0x1a, 0x2b, 0x5e, 0xc9, 0x1c, 0xdc, 0xc1, 0xfb, 0xc1, 0xe8, 0x9e, 0x7c, 0xf5, 0xfe, 0xb9, 0x74, 0xa0, 0x23, 0x1d, 0xd7, 0x1d, 0x43, 0x57, 0x41, 0xd8, 0xfd, 0xc3, 0x73, 0x0, 0x12, 0x79, 0x5f, 0xcd, 0xb4, 0xb1, 0x52, 0x67, 0xcd, 0x20, 0xe, 0x57, 0x6b, 0x7d, 0x1e, 0xb9, 0xc5, 0x21, 0xf, 0x24, 0xb9, 0x16, 0xa0, 0x1d, 0xdd, 0x1b, 0xfb, 0x13, 0x78, 0xaa, 0x86, 0x5e, 0xd8, 0x6d, 0x0, 0x56, 0xca, 0x5c, 0x92, 0xe5, 0xf7, 0xbd, 0x57, 0xd4, 0x47, 0x57, 0x25, 0x60, 0xed, 0x23, 0x10, 0x7e, 0xe6, 0xc0, 0x8f, 0x5, 0x10, 0xe2, 0x59, 0x4f, 0x47, 0xe1, 0x9a, 0xd6, 0x72, 0x5b, 0xb3, 0x3, 0xee, 0xd6, 0x3b, 0xe2, 0xf9, 0x4c, 0x5, 0x1, 0xc6, 0x9, 0xc5, 0x65, 0xe4, 0xa, 0xd7, 0x42, 0x11, 0xfe, 0x97, 0xde, 0x80, 0xcd, 0xc8, 0x2b, 0x20, 0x97, 0x7a, 0x1d, 0x24, 0xa7, 0xe3, 0x5c, 0x3e, 0xdc, 0xac, 0x3a, 0x59, 0xe, 0xbf, 0x65, 0xee, 0x6f, 0x5d, 0x4, 0x4f, 0x43, 0xee, 0xfe, 0xe6, 0xca, 0x71, 0x32, 0x6a, 0xa7, 0x13, 0xfd, 0xd8, 0x78, 0xcc, 0xb6, 0xf5, 0x3d, 0x9, 0x91, 0x34, 0x20, 0x11, 0x32, 0x20, 0xaf, 0x1e, 0x37, 0xce, 0xc5, 0xfd, 0x5b, 0x1f, 0x17, 0x43, 0xec, 0x12, 0x92, 0x67, 0xa6, 0xd5, 0x50, 0x39, 0x43, 0xbb, 0x5d, 0x4d, 0x21, 0xbd, 0xbe, 0x14, 0x9e, 0x1f, 0xf7, 0x46, 0x26, 0xb1, 0x91, 0xbf, 0x75, 0xb1, 0x9b, 0x5a, 0x2e, 0x42, 0x25, 0xfa, 0x8e, 0xc8, 0x87, 0x91, 0x47, 0x87, 0xa7, 0x5e, 0xbd, 0x7c, 0xc, 0xaf, 0xbf, 0xe0, 0xf5, 0xca, 0xee, 0x5, 0xf2, 0xcf, 0x46, 0x8a, 0x16, 0x4, 0xbb, 0xb1, 0xc5, 0xff, 0xc7, 0x89, 0x44, 0x1, 0x7a, 0x81, 0x40, 0x77, 0xb0, 0x7e, 0xdf, 0x48, 0x52, 0x4e, 0xb9, 0xa9, 0xba, 0xdc, 0xed, 0x4e, 0x56, 0x26, 0x74, 0x21, 0xa, 0x5e, 0xa2, 0x65, 0x7, 0xdf, 0xe2, 0x62, 0x11, 0xb5, 0x7a, 0xd3, 0xf6, 0x13, 0xcf, 0x95, 0x13, 0x6, 0xae, 0x51, 0xd4, 0xda, 0x53, 0xa9, 0x76, 0xe1, 0x39, 0xb3, 0xef, 0xf7, 0x83, 0xd, 0x66, 0x1c, 0xed, 0xb0, 0x59, 0xc9, 0x2f, 0x93, 0xbd, 0xe0, 0x20, 0x9c, 0x18, 0x4b, 0xed, 0x15, 0xe3, 0x83, 0x73, 0xa5, 0x8e, 0x8e, 0x10, 0x7b, 0x1f, 0xb0, 0xdf, 0x85, 0xdf, 0xff, 0xca, 0xfe, 0x9b, 0x0, 0x5c, 0xe, 0xf9, 0xc8, 0xc7, 0xbd, 0x31, 0x66, 0xf7, 0x77, 0xfa, 0x5d, 0x6, 0x1e, 0xe8, 0x27, 0xcd, 0x45, 0xba, 0xe3, 0x4b, 0xcf, 0x7e, 0xbc, 0xa1, 0xa4, 0x7f, 0x76, 0xf4, 0x59, 0xd6, 0xdc, 0x5f, 0x85, 0xef, 0xb0, 0xd9, 0xb5, 0xfa, 0x5c, 0x4b, 0xf1, 0x94, 0x94, 0xef, 0x7b, 0xb5, 0xf7, 0x6f, 0xcc, 0xec, 0x4e, 0xde, 0x71, 0xb4, 0xbb, 0x4a, 0x4b, 0x37, 0x11, 0x32, 0x89, 0x87, 0x3f, 0x3d, 0x57, 0xd0, 0x6b, 0x3d, 0x42, 0xce, 0x54, 0x3c, 0x11, 0x3c, 0x78, 0x9c, 0xfb, 0x88, 0xdb, 0x82, 0x7, 0xd2, 0x60, 0x7, 0xc8, 0x9, 0xbe, 0x20, 0x98, 0xc2, 0x0, 0x34, 0xec, 0xa5, 0x53, 0x9a, 0xc8, 0x12, 0x26, 0x40, 0xa7, 0x14, 0xb0, 0xee, 0x35, 0xf6, 0xb4, 0x66, 0xdd, 0xd, 0xa, 0x1d, 0x7, 0xd6, 0x54, 0x7e, 0x6e, 0xf4, 0xb2, 0x43, 0xce, 0x98, 0x35, 0xb9, 0xbf, 0x6c, 0xe2, 0xd1, 0x71, 0x17, 0x44, 0xbe, 0x3a, 0x40, 0x5f, 0x6e, 0x46, 0xe1, 0x82, 0x4a, 0x62, 0x5b, 0xeb, 0xc4, 0x2f, 0xf3, 0x40, 0x22, 0xe, 0x68, 0xb7, 0x85, 0xaf, 0x5c, 0xd5, 0xc0, 0x5c, 0x21, 0x5a, 0x6d, 0x3e, 0x31, 0xdf, 0x1c, 0xa9, 0x7d, 0x5, 0x42, 0x98, 0xc0, 0x39, 0x9f, 0xfb, 0x8, 0xb4, 0xce, 0x8b, 0x2d, 0x6d, 0x8, 0xa3, 0xca, 0xfb, 0x33, 0xee, 0x53, 0x6b, 0xb0, 0x1f, 0xef, 0xa5, 0xfc, 0xc7, 0xaa, 0x90, 0x5c, 0x83, 0xaf, 0x89, 0x50, 0x47, 0xcc, 0x7b, 0xb6, 0x5, 0x14, 0x82, 0xdc, 0xd5, 0xaa, 0xda, 0x28, 0xe9, 0x6, 0xea, 0xd9, 0xb9, 0xc, 0xee, 0x2b, 0x32, 0xf9, 0xb9, 0x17, 0x12, 0x36, 0x51, 0x25, 0x8d, 0x47, 0x4c, 0xc6, 0x99, 0x93, 0x4f, 0xe7, 0x32, 0xa9, 0xdb, 0x3d, 0x83, 0xc, 0xe1, 0xc3, 0x3f, 0xf3, 0x9e, 0x94, 0x6f, 0x6b, 0xbe, 0x36, 0x3a, 0xeb, 0x3a, 0x3f, 0x8, 0x95, 0xca, 0x9, 0xf7, 0x8e, 0xd3, 0x7b, 0x66, 0xc9, 0x19, 0xa1, 0x5d, 0x85, 0xe9, 0xea, 0x68, 0xf9, 0xae, 0xf3, 0x83, 0xa7, 0xab, 0x61, 0x10, 0x1b, 0xc6, 0xd4, 0xbe, 0xb7, 0xe3, 0x6b, 0xb9, 0xbc, 0xc0, 0x44, 0x21, 0xa0, 0xbf, 0x7a, 0x26, 0x36, 0x51, 0xc3, 0xa, 0x40, 0xb6, 0x52, 0x28, 0x6a, 0x56, 0x78, 0xea, 0xd, 0xa5, 0x16, 0xd4, 0xba, 0xf8, 0x9d, 0x74, 0x7d, 0x5, 0x59, 0xb1, 0x19, 0x19, 0x9a, 0x7a, 0x61, 0x55, 0x28, 0xcc, 0xdb, 0x2d, 0x5b, 0x10, 0xe9, 0x9b, 0x2b, 0xec, 0x59, 0xb7, 0x42, 0xb4, 0xf, 0x8a, 0x30, 0x46, 0x48, 0x18, 0x58, 0xf7, 0xd, 0x18, 0xb5, 0x44, 0x19, 0x74, 0xd4, 0xa5, 0xf4, 0xa7, 0x32, 0x4, 0x1b, 0x99, 0x97, 0x73, 0xa9, 0x3c, 0x3f, 0xb4, 0x32, 0x5b, 0x6e, 0x5f, 0x5e, 0xb7, 0x84, 0x99, 0x23, 0x40, 0x7e, 0x15, 0xa5, 0x5b, 0xa4, 0x6f, 0x38, 0x4, 0xde, 0x3e, 0x8c, 0xa9, 0x56, 0x1b, 0xf8, 0x76, 0x22, 0xec, 0x8e, 0x91, 0x69, 0x8c, 0xf, 0xd9, 0x7b, 0x64, 0x13, 0xd3, 0x21, 0x2f, 0x14, 0x10, 0xd9, 0xad, 0x7, 0x54, 0xb4, 0x57, 0xf0, 0x41, 0xa6, 0x80, 0x5f, 0xc3, 0xd, 0x7a, 0x7a, 0x98, 0x70, 0xc, 0x5d, 0x6a, 0xdc, 0xef, 0x4a, 0x1f, 0x23, 0xe5, 0x19, 0x50, 0xf2, 0xfa, 0x40, 0xf7, 0x4f, 0xdd, 0x6a, 0xee, 0xd4, 0x7c, 0xba, 0xe6, 0xcb, 0xcc, 0xb9, 0x3e, 0x8a, 0x6, 0x95, 0xd, 0x98, 0xc, 0xa2, 0x61, 0x70, 0x5a, 0x8e, 0xfb, 0x5b, 0x7b, 0xc8, 0x66, 0xf5, 0x45, 0x1f, 0x70, 0x9e, 0x8f, 0x1, 0x79, 0x16, 0x0, 0xaa, 0x7e, 0x93, 0xad, 0x41, 0x8, 0x8d, 0xab, 0x6a, 0xc9, 0xea, 0x25, 0x28, 0x52, 0x14, 0xd4, 0xfa, 0x5a, 0x1c, 0x4c, 0x31, 0xed, 0x4e, 0x1, 0x57, 0xa3, 0xa6, 0xbb, 0x94, 0xf8, 0xe0, 0xac, 0xb6, 0x6b, 0xe, 0x5f, 0xb3, 0x23, 0x28, 0x4c, 0x54, 0xfa, 0x9e, 0x7, 0x54, 0x20, 0x30, 0x67, 0x93, 0x84, 0xaa, 0xea, 0x81, 0x75, 0x76, 0x32, 0x9f, 0xad, 0x20, 0xbf, 0x28, 0xd8, 0xc, 0xf8, 0x24, 0xd7, 0x51, 0x20, 0x6b, 0xe1, 0x7a, 0xc, 0xe1, 0x6a, 0x9c, 0x2e, 0xbd, 0xd, 0x80, 0xc7, 0xe6, 0x43, 0x86, 0x7c, 0xc3, 0x2f, 0xf9, 0xca, 0x92, 0xe9, 0xad, 0xab, 0x3e, 0x10, 0x96, 0xcd, 0xde, 0x69, 0xb6, 0xc2, 0x99, 0x4, 0x66, 0x61, 0x14, 0x89, 0xbe, 0xda, 0xec, 0xcb, 0x9b, 0xc1, 0x35, 0xeb, 0x2e, 0xf5, 0x45, 0x2, 0xac, 0xfa, 0xfe, 0x49, 0x7e, 0xd6, 0x68, 0xaf, 0x4c, 0x98, 0x49, 0x59, 0xcf, 0xf2, 0x84, 0xb2, 0xae, 0x81, 0x63, 0x8f, 0x2e, 0x11, 0xcd, 0xc4, 0x63, 0x31, 0x88, 0x45, 0xa3, 0x63, 0xeb, 0x8, 0x38, 0x5b, 0x40, 0x2, 0xe3, 0x63, 0x8f, 0xff, 0xa3, 0x47, 0x3, 0x9b, 0x40, 0xef, 0x73, 0x15, 0xc8, 0x8e, 0xfb, 0xf0, 0x1f, 0x9e, 0xab, 0x73, 0xa6, 0xf0, 0x59, 0x6a, 0x1a, 0x16, 0x94, 0x3b, 0x3, 0x13, 0x9f, 0x4e, 0x1a, 0x3e, 0xa5, 0x18, 0x2b, 0x40, 0x1f, 0x8d, 0xbe, 0x8, 0x52, 0x7d, 0x81, 0xed, 0x45, 0x68, 0x2d, 0x64, 0x59, 0xbc, 0xc9, 0x36, 0x2d, 0xe5, 0xd3, 0x51, 0xa5, 0xb8, 0x43, 0x7d, 0x79, 0xd2, 0x48, 0x99, 0xbf, 0x53, 0x16, 0xe8, 0x1a, 0x18, 0x2a, 0xcf, 0x4f, 0x74, 0xe, 0xaf, 0xff, 0xef, 0x36, 0x5a, 0xe5, 0x48, 0x32, 0x82, 0x2a, 0xb4, 0xf5, 0x8d, 0x89, 0x59, 0x60, 0x14, 0xfe, 0xdd, 0x5b, 0x99, 0xca, 0xab, 0xc0, 0xe8, 0x77, 0x60, 0x4b, 0xf4, 0xda, 0x5a, 0x4a, 0x8f, 0x8a, 0x93, 0xda, 0xc8, 0xb5, 0xff, 0x7f, 0x68, 0xbf, 0x41, 0x67, 0x56, 0x5, 0x79, 0x31, 0x7a, 0x77, 0x99, 0xd9, 0xed, 0x14, 0xb7, 0xc4, 0x71, 0x9e, 0x34, 0xaa, 0x33, 0x12, 0xf2, 0xb9, 0xf0, 0x73, 0x21, 0xbd, 0x38, 0xfe, 0x23, 0x2b, 0x66, 0xfc, 0xeb, 0xcf, 0xa5, 0xa1, 0x5e, 0xa6, 0x97, 0x1c, 0x92, 0xc0, 0xeb, 0x37, 0x7c, 0x44, 0xa8, 0xb2, 0xc9, 0x2b, 0xe3, 0x63, 0x47, 0x5, 0xf7, 0xfd, 0x1, 0xf8, 0xe2, 0xb1, 0xf, 0x61, 0xa7, 0xad, 0xaa, 0xb9, 0x30, 0x9, 0xb0, 0xb6, 0x12, 0xcf, 0xca, 0xc9, 0x31, 0x5e, 0xbf, 0xaf, 0x32, 0x1c, 0x27, 0xb9, 0xfb, 0x2d, 0xa0, 0x12, 0xa, 0x8, 0xf5, 0x12, 0xa9, 0xa9, 0x14, 0x9b, 0x47, 0x97, 0xe4, 0x0, 0xda, 0x17, 0xe7, 0x49, 0xbf, 0xd1, 0x68, 0x3d, 0xf6, 0x28, 0xde, 0xd, 0x6, 0x2a, 0x86, 0xb9, 0x31, 0xdd, 0x19, 0xa6, 0x39, 0xaa, 0x7e, 0xe3, 0x32, 0xc5, 0x3a, 0x8c, 0x77, 0x1e, 0x78, 0x7f, 0x7b, 0x7c, 0x6d, 0x81, 0x7f, 0x53, 0xb6, 0xe5, 0x71, 0x53, 0xc3, 0x2b, 0x25, 0xf8, 0x7a, 0x1d, 0xf9, 0x40, 0x7d, 0x23, 0x90, 0xf0, 0x2c, 0xf6, 0xda, 0x3a, 0x50, 0x8d, 0x17, 0x21, 0xf5, 0x5e, 0x15, 0x5e, 0x6e, 0x20, 0xbf, 0xec, 0xd, 0x25, 0x50, 0x59, 0x8d, 0x81, 0x5f, 0x71, 0xe0, 0x65, 0x42, 0x6e, 0x4a, 0xfd, 0x67, 0x7a, 0x1f, 0xcf, 0x41, 0xa2, 0x4c, 0xbd, 0x82, 0xdb, 0x61, 0x35, 0xf4, 0x5d, 0x74, 0xd0, 0xe8, 0xae, 0xd9, 0x4b, 0xda, 0x26, 0xa0, 0xf4, 0x2d, 0x19, 0xf5, 0x20, 0x28, 0x12, 0x2d, 0xf5, 0x51, 0x6, 0xe4, 0x5f, 0x8b, 0x36, 0x4f, 0x65, 0xe3, 0x14, 0xef, 0x77, 0xef, 0xb, 0x7b, 0xcd, 0xd8, 0x24, 0x25, 0xd8, 0xe3, 0x21, 0x2e, 0x3c, 0x7d, 0xdb, 0x4e, 0xa1, 0xd3, 0x78, 0xe2, 0x30, 0xf, 0x10, 0xae, 0x70, 0x74, 0x66, 0x75, 0x2b, 0x15, 0xeb, 0x44, 0x89, 0xce, 0xa8, 0x7, 0xe9, 0xaa, 0x3, 0xb8, 0x86, 0xf3, 0xd6, 0x23, 0x51, 0x4a, 0x7d, 0x16, 0x67, 0x2b, 0x6d, 0xc0, 0x25, 0x50, 0x2b, 0xbb, 0x69, 0xa8, 0xac, 0x5e, 0x37, 0x4b, 0x94, 0xa0, 0xf1, 0x53, 0xdd, 0x86, 0xb3, 0xb5, 0x53, 0x8, 0xac, 0x5, 0xae, 0x58, 0x69, 0xc0, 0xae, 0x5e, 0x18, 0x20, 0x8b, 0xb0, 0xae, 0xce, 0xc3, 0xd5, 0xe3, 0x99, 0x93, 0x6d, 0x58, 0xff, 0x9f, 0xb9, 0x33, 0xba, 0x34, 0x9a, 0xd5, 0x67, 0xf9, 0xcc, 0xf7, 0x43, 0xc2, 0x64, 0x60, 0x6b, 0x41, 0xd8, 0xaa, 0x1a, 0x4c, 0x16, 0x4f, 0xfd, 0xfc, 0x98, 0x53, 0xfb, 0xe6, 0xac, 0xf1, 0x1f, 0x21, 0x34, 0x90, 0xa4, 0x71, 0xe8, 0xc, 0x15, 0xde, 0xf7, 0xd9, 0x85, 0xaa, 0x9c, 0x34, 0xc, 0x12, 0x64, 0x73, 0xd1, 0xd1, 0x4b, 0xcc, 0x82, 0x6c, 0x12, 0xc2, 0x0, 0xd7, 0x2e, 0x1a, 0x0, 0xb3, 0x92, 0x76, 0x7b, 0xde, 0x8, 0x84, 0x0, 0x5d, 0x27, 0xa, 0x1c, 0x62, 0x41, 0x3a, 0xef, 0x75, 0x48, 0x4, 0xa2, 0xf0, 0x4b, 0xa3, 0xc9, 0xb4, 0xa4, 0xfc, 0x90, 0x76, 0x95, 0x18, 0x60, 0xf9, 0xa0, 0xde, 0xa8, 0xb, 0xd6, 0xcf, 0x5f, 0xd6, 0xe5, 0x19, 0x83, 0xaf, 0x34, 0x4b, 0x88, 0x7a, 0xc3, 0xf9, 0x7, 0xa4, 0xa, 0x69, 0x4d, 0xed, 0x88, 0x40, 0x99, 0x8c, 0x3a, 0x27, 0x3f, 0xb1, 0x26, 0x7c, 0x4c, 0x7c, 0xbc, 0x2f, 0xd0, 0xa5, 0x13, 0x15, 0xf3, 0x13, 0xe3, 0x28, 0x18, 0xb4, 0x5d, 0x6c, 0x7f, 0xbe, 0xdb, 0x5a, 0xa6, 0x73, 0xe7, 0xa8, 0x6, 0x9c, 0x93, 0x1a, 0xb8, 0x38, 0xde, 0x20, 0x45, 0xe7, 0x98, 0x52, 0xfd, 0x83, 0x2c, 0x5, 0x46, 0x22, 0x8a, 0xee, 0x6b, 0xc7, 0x7d, 0x72, 0xd8, 0xe9, 0x84, 0x57, 0x5e, 0x27, 0xec, 0x61, 0xe, 0x41, 0x1d, 0xe7, 0xe0, 0x27, 0x25, 0x8, 0x5a, 0xab, 0xb, 0xa9, 0x67, 0xa9, 0x30, 0x5, 0x83, 0xf2, 0x7a, 0x18, 0x93, 0xc1, 0x43, 0x2f, 0x3e, 0x65, 0x1b, 0xe3, 0xe4, 0x9d, 0x60, 0x69, 0x6, 0x52, 0xd6, 0x17, 0x7b, 0x39, 0xbc, 0xd6, 0xb8, 0xe0, 0xa6, 0xa6, 0xa8, 0x12, 0x4, 0x8f, 0xb2, 0xcc, 0xfc, 0x6c, 0xc6, 0x36, 0xa0, 0xfe, 0xa9, 0x89, 0xce, 0xac, 0xa7, 0xbf, 0xdb, 0x52, 0x86, 0xe9, 0xf9, 0xb3, 0x4e, 0xe5, 0xbb, 0xe0, 0xce, 0x93, 0xd4, 0xa4, 0x61, 0x4a, 0x35, 0x4e, 0xa9, 0x1d, 0xea, 0x8b, 0xa0, 0xfe, 0x6a, 0xf3, 0xa4, 0x35, 0x2, 0x88, 0xb0, 0xca, 0xab, 0x1f, 0xcc, 0x13, 0x52, 0x75, 0xae, 0x5a, 0x65, 0x9e, 0x4c, 0x3a, 0x8, 0xc9, 0xe2, 0x48, 0x1f, 0xeb, 0xd1, 0x50, 0x59, 0x6e, 0x68, 0x40, 0x9, 0x13, 0x7d, 0xe6, 0xa0, 0xf1, 0x75, 0x2e, 0x25, 0x24, 0x2, 0x83, 0xdf, 0xa5, 0x84, 0x51, 0xc9, 0x4f, 0x9a, 0xb9, 0x6b, 0xc4, 0xf3, 0xdf, 0x55, 0x7, 0x23, 0xe, 0x15, 0x2b, 0xb0, 0xc7, 0xf0, 0xf4, 0xc0, 0xf0, 0xd, 0x94, 0x80, 0x50, 0x95, 0x95, 0xeb, 0x25, 0xbd, 0xd3, 0xf3, 0xb2, 0x99, 0xcd, 0xd, 0x16, 0x5e, 0xa4, 0xc2, 0xf2, 0xba, 0x5b, 0x2, 0x2b, 0xf5, 0x7a, 0x30, 0xe8, 0xe3, 0x9c, 0xbb, 0xdd, 0xe0, 0x47, 0xf1, 0xc9, 0x1f, 0x87, 0xb6, 0x58, 0x21, 0x50, 0x76, 0xef, 0x53, 0x4f, 0xde, 0xc7, 0x55, 0x80, 0xe2, 0x10, 0xa9, 0x48, 0xbb, 0x1c, 0x3e, 0xd8, 0xbe, 0x98, 0x18, 0x1d, 0xfb, 0x6e, 0x15, 0xff, 0xde, 0x2b, 0xb7, 0xf3, 0xec, 0x5d, 0xa5, 0x90, 0x7a, 0x71, 0xfa, 0xb7, 0x70, 0xd2, 0x9a, 0xda, 0x27, 0x62, 0xd5, 0x88, 0x7b, 0x30, 0x6f, 0x7a, 0x85, 0x86, 0x22, 0x3d, 0x8c, 0xb8, 0x9a, 0x8e, 0x84, 0x21, 0x60, 0x9c, 0xd8, 0xf, 0x21, 0x75, 0xf2, 0xda, 0xa6, 0x1a, 0xe3, 0xbd, 0x7b, 0xd1, 0x35, 0xbe, 0x39, 0xed, 0xdd, 0x2b, 0x26, 0x87, 0x38, 0x14, 0x20, 0xe2, 0xc9, 0x2a, 0x10, 0x7e, 0x28, 0xe3, 0xe0, 0xb, 0x50, 0x7e, 0x32, 0x5f, 0x4a, 0xce, 0x54, 0x13, 0x7b, 0x37, 0xa0, 0xa7, 0x50, 0xe3, 0x62, 0x9d, 0x64, 0x59, 0x6e, 0x1c, 0x1b, 0x50, 0x91, 0xf1, 0x76, 0x1f, 0x3e, 0xb7, 0xc3, 0x4a, 0xb6, 0xc5, 0x4e, 0x10, 0x8a, 0x89, 0xdd, 0x1e, 0xdb, 0x83, 0x3d, 0x21, 0xec, 0x68, 0x8e, 0xf3, 0xc3, 0x7a, 0xb1, 0xf7, 0x62, 0xe5, 0xaa, 0xd7, 0xc6, 0xb3, 0x76, 0x4b, 0x5e, 0xc0, 0x4b, 0x3c, 0x3f, 0x31, 0x97, 0x32, 0xc1, 0xa3, 0xd2, 0x5, 0x82, 0xd9, 0xef, 0x30, 0xc4, 0xb3, 0x53, 0x6b, 0x7c, 0x47, 0x19, 0x7c, 0x97, 0xc7, 0x67, 0x92, 0x14, 0x5c, 0xb8, 0x47, 0xbd, 0x2f, 0xb8, 0x4a, 0x7c, 0xb4, 0x60, 0x84, 0x2f, 0x9, 0x56, 0x2, 0xc, 0x32, 0xd, 0x48},
+               output224: []byte{0x15, 0xe1, 0x5, 0x8, 0xa9, 0x79, 0x46, 0xcf, 0x7d, 0x8, 0x42, 0xc5, 0x1e, 0x63, 0xd3, 0x4b, 0xd9, 0x93, 0x56, 0x3d, 0x9b, 0x3c, 0x6b, 0x81, 0xb7, 0x56, 0xf6, 0xcd},
+               output256: []byte{0xdf, 0x6e, 0x9b, 0x8, 0x44, 0x15, 0x3e, 0x3c, 0xd6, 0x54, 0xd4, 0x60, 0xd5, 0x37, 0xe, 0xe1, 0x91, 0x77, 0x62, 0xf6, 0x7d, 0xc2, 0x9b, 0xec, 0xe4, 0x4d, 0xf2, 0x65, 0x2e, 0xa6, 0xae, 0x59},
+               output384: []byte{0xdb, 0x72, 0x2f, 0xd0, 0x96, 0x99, 0x2d, 0x5f, 0x25, 0xfb, 0xfe, 0xf7, 0x99, 0x1e, 0xa8, 0xc1, 0xbc, 0xe6, 0xb1, 0xc2, 0xad, 0x49, 0x21, 0xac, 0x61, 0x9f, 0xe1, 0x9c, 0x50, 0x5e, 0x3e, 0x2d, 0x82, 0xd1, 0xca, 0x64, 0x4d, 0xed, 0xad, 0xec, 0x87, 0x6f, 0x51, 0xfd, 0xb2, 0x15, 0x78, 0xb},
+               output512: []byte{0x81, 0x30, 0x7d, 0xa5, 0x51, 0xcf, 0x5, 0x76, 0x6e, 0x29, 0xb8, 0xfe, 0x5c, 0x33, 0xfa, 0x5a, 0x12, 0x4b, 0xd0, 0x20, 0x2b, 0xc5, 0xe3, 0x9, 0xd6, 0x48, 0xe0, 0xec, 0xfa, 0xdb, 0x44, 0x28, 0x6, 0xdc, 0x5e, 0x2f, 0x8a, 0xe9, 0xc4, 0x66, 0x14, 0xc2, 0x39, 0x9e, 0xf9, 0x1c, 0xd2, 0x15, 0x91, 0x5d, 0xfd, 0x48, 0x55, 0x59, 0x85, 0xa5, 0xc6, 0x31, 0x38, 0x91, 0x5b, 0xbe, 0x27, 0x37}},
+       testcase{
+               msg:       []byte{0x97, 0x40, 0xcb, 0xe9, 0xeb, 0x65, 0xad, 0x1c, 0xe9, 0x13, 0xf4, 0xb, 0xe2, 0x36, 0xb1, 0xad, 0x71, 0x41, 0xf8, 0xea, 0x72, 0x10, 0x4b, 0x12, 0x2f, 0xe9, 0xac, 0x99, 0xb6, 0x55, 0x2b, 0x1b, 0x3a, 0x34, 0xfd, 0x6c, 0x1b, 0x96, 0x2f, 0x1e, 0xca, 0xdd, 0x53, 0xb5, 0x30, 0x86, 0x6b, 0xfd, 0xad, 0x8d, 0x81, 0xf8, 0x40, 0x5c, 0x1d, 0x54, 0xe2, 0xd, 0x99, 0xf3, 0xf, 0xb0, 0x41, 0x97, 0x5f, 0x70, 0xdd, 0x97, 0x1c, 0x17, 0x42, 0x4c, 0x60, 0x1f, 0x46, 0x51, 0x6c, 0x13, 0x53, 0x49, 0x67, 0x31, 0x8d, 0x3c, 0x5d, 0x60, 0xec, 0xbe, 0xc6, 0x7, 0xc4, 0x2d, 0x8, 0x25, 0xff, 0xb8, 0x4d, 0x7c, 0x5c, 0x69, 0x85, 0x85, 0x12, 0xa3, 0xc5, 0x9e, 0xae, 0xed, 0x3f, 0x61, 0x12, 0x4d, 0xf7, 0x9f, 0x13, 0xd6, 0x3c, 0x38, 0x2c, 0xff, 0x70, 0xeb, 0xd2, 0x50, 0xff, 0x94, 0xe1, 0x68, 0x4e, 0xb5, 0xad, 0x80, 0x67, 0x14, 0xb4, 0x13, 0x2e, 0x85, 0x5c, 0xb2, 0xc, 0x9, 0x95, 0x1e, 0x3d, 0x1f, 0x18, 0x5d, 0xa0, 0x9b, 0xd, 0xfc, 0x4c, 0x2, 0x6f, 0xef, 0x5d, 0x34, 0x87, 0xe5, 0xf6, 0x7, 0x57, 0x8d, 0x34, 0xc5, 0xa4, 0xe9, 0xc3, 0x1, 0xc0, 0x7d, 0xfb, 0xb7, 0x22, 0x33, 0x54, 0x2c, 0x4, 0xfe, 0xc1, 0x8e, 0xce, 0x50, 0xc, 0x4c, 0xa4, 0x79, 0xa4, 0x76, 0x2e, 0x5d, 0xa2, 0xbf, 0xe6, 0x30, 0xf6, 0xe4, 0x55, 0x81, 0x92, 0xd6, 0x56, 0x1b, 0x69, 0xbe, 0x36, 0x95, 0x68, 0x83, 0x62, 0xdc, 0x88, 0xde, 0xfc, 0xf8, 0x59, 0x85, 0x83, 0x96, 0xf9, 0x74, 0xe5, 0x97, 0x44, 0xbd, 0x2, 0x24, 0xf5, 0x78, 0xf3, 0xb1, 0xc6, 0xf4, 0x6c, 0x7e, 0xaa, 0x52, 0x3f, 0x67, 0x2b, 0x52, 0x90, 0x6d, 0xda, 0x5a, 0xd7, 0xa4, 0x10, 0xac, 0x6e, 0xd5, 0xd3, 0xab, 0x82, 0x3e, 0xb7, 0x23, 0x5b, 0x1c, 0xab, 0x4b, 0xfa, 0xc9, 0x2d, 0xd7, 0x3f, 0x4f, 0xb7, 0x96, 0xa2, 0x99, 0xc5, 0xf3, 0x9d, 0xe5, 0x90, 0xcf, 0x90, 0x30, 0x7c, 0x6b, 0xd8, 0xa7, 0x71, 0x7c, 0x32, 0x51, 0xcd, 0x61, 0x39, 0x17, 0x35, 0x8d, 0xb8, 0x37, 0xdb, 0xaa, 0xc6, 0x15, 0xac, 0xbe, 0x28, 0x85, 0x55, 0x8f, 0xc7, 0xa0, 0xbe, 0xa8, 0xe1, 0x51, 0x76, 0x75, 0x6c, 0xf5, 0xc9, 0x20, 0x4c, 0x3e, 0x3b, 0x2, 0x76, 0x4e, 0xd6, 0x8, 0xdd, 0xfc, 0x52, 0xa3, 0xbc, 0xcc, 0x2c, 0xf4, 0xae, 0xd6, 0xf8, 0xaf, 0x14, 0x95, 0x33, 0x63, 0xb0, 0x8a, 0x8, 0x85, 0xc1, 0x31, 0xcb, 0xb5, 0x71, 0x5e, 0xef, 0xa, 0x4, 0xd1, 0x8c, 0x4e, 0x6e, 0xfd, 0x59, 0xe9, 0x99, 0xf7, 0x4e, 0xe6, 0x9c, 0x79, 0xe9, 0x6a, 0x9c, 0xe7, 0xa5, 0xd9, 0xfe, 0x27, 0xa6, 0xa6, 0x51, 0xfe, 0xf5, 0x4b, 0x9, 0x76, 0x8c, 0x1a, 0xa4, 0x9f, 0xb0, 0x3b, 0x9, 0xb6, 0xae, 0xb1, 0x9b, 0x38, 0xb0, 0x0, 0x65, 0xec, 0x6d, 0xa0, 0x1f, 0xb4, 0x71, 0xd1, 0x79, 0x2f, 0x7e, 0x3d, 0x5d, 0x8c, 0x14, 0x38, 0x1c, 0xf6, 0x8c, 0x42, 0x70, 0x8a, 0x43, 0xef, 0x34, 0x31, 0x35, 0x92, 0x9f, 0xcc, 0xff, 0x2f, 0x66, 0x42, 0xc1, 0x3e, 0xd2, 0x0, 0x8f, 0xeb, 0xfe, 0x99, 0x72, 0xbc, 0x16, 0x4e, 0x37, 0x53, 0x83, 0xf5, 0x7, 0x98, 0xcb, 0x84, 0xff, 0x34, 0xe1, 0xfd, 0x7, 0x94, 0xa, 0x21, 0x8d, 0xd1, 0x74, 0xdc, 0x86, 0x90, 0x25, 0xe5, 0xfc, 0x45, 0x9b, 0xb0, 0xbb, 0xa9, 0x69, 0xa2, 0x24, 0xe, 0xbf, 0xe0, 0xef, 0xc1, 0xcd, 0x34, 0x15, 0x4e, 0xc1, 0xae, 0xa7, 0x3f, 0xf7, 0x85, 0x87, 0x49, 0x73, 0x5f, 0x1b, 0x27, 0x22, 0xc6, 0xdd, 0xd4, 0xa6, 0x99, 0x1d, 0x20, 0x69, 0xfc, 0x3d, 0x61, 0xa8, 0xb2, 0x39, 0x77, 0xfa, 0xae, 0x5c, 0x32, 0xd9, 0x5f, 0x3f, 0x18, 0x97, 0xb0, 0xe8, 0x6b, 0xc8, 0x70, 0x5c, 0xfb, 0x69, 0x84, 0xd4, 0x9c, 0x1e, 0xe2, 0x6a, 0x90, 0xb3, 0xc8, 0x67, 0x9e, 0xff, 0xab, 0x5a, 0xdb, 0x87, 0x1a, 0x3e, 0x21, 0x98, 0x1, 0xc7, 0xb1, 0x5d, 0x6d, 0xfc, 0x62, 0xe9, 0xdc, 0xcc, 0x88, 0x7c, 0xd7, 0xf2, 0x5b, 0xb7, 0x3e, 0xa2, 0xc3, 0xfe, 0xf7, 0x64, 0x96, 0x22, 0x46, 0x39, 0xa, 0x4a, 0xd9, 0x66, 0x10, 0xf5, 0xe0, 0xe7, 0xeb, 0x59, 0xb3, 0x2e, 0x7e, 0xc2, 0x1, 0x45, 0x30, 0x8d, 0x81, 0xf6, 0xf6, 0x38, 0x29, 0x90, 0x57, 0xb2, 0x27, 0x6e, 0xd0, 0x45, 0xae, 0xa7, 0x10, 0x3b, 0x44, 0xbc, 0x85, 0xd3, 0x3c, 0xdd, 0xf, 0xcd, 0x73, 0x80, 0x35, 0xe6, 0x70, 0xb2, 0x85, 0x76, 0x2c, 0x65, 0xc3, 0xef, 0x52, 0x45, 0x2a, 0xce, 0x98, 0xc, 0x41, 0x16, 0x1d, 0x85, 0x93, 0xf4, 0x6d, 0xd2, 0x81, 0x6d, 0x43, 0x5d, 0xf7, 0xfe, 0x90, 0x87, 0x1a, 0x9b, 0x4c, 0xa1, 0xc5, 0xcb, 0xe6, 0x36, 0x2e, 0x22, 0x5e, 0x89, 0x50, 0x88, 0x9f, 0xeb, 0xc4, 0x75, 0x45, 0xf6, 0x7, 0xa7, 0xae, 0x4b, 0xa8, 0xb8, 0x63, 0x50, 0xb5, 0x54, 0xf6, 0x1d, 0x42, 0x4f, 0xb5, 0x1c, 0x8e, 0x98, 0x86, 0x0, 0xe, 0x4e, 0x7, 0xde, 0xc3, 0x24, 0xbb, 0x51, 0x19, 0xa5, 0xb5, 0x9, 0x9b, 0xbb, 0x12, 0x6b, 0xc, 0xc, 0xa0, 0xcd, 0x8f, 0xbc, 0x30, 0x47, 0x80, 0xa9, 0xbb, 0x44, 0xa4, 0xab, 0xf5, 0x8d, 0x30, 0xdb, 0x42, 0x45, 0xb6, 0x5c, 0xe2, 0xb, 0x9, 0x75, 0xc7, 0x86, 0x9b, 0x39, 0xb9, 0x66, 0xa5, 0x9f, 0xe6, 0x92, 0x90, 0xd5, 0xab, 0x3f, 0xab, 0xb1, 0x2d, 0xf5, 0x2, 0x4d, 0xaa, 0x6, 0x5a, 0x48, 0xa0, 0x7a, 0x8c, 0x8, 0x4d, 0xd6, 0x10, 0x16, 0x17, 0x8e, 0x69, 0xfb, 0xaf, 0x1f, 0xd8, 0x7c, 0xdf, 0x78, 0xe1, 0xaa, 0xba, 0x8a, 0x3a, 0x3, 0xb9, 0xfb, 0x89, 0x3a, 0xb7, 0xb6, 0x74, 0x54, 0x4e, 0x6b, 0x1e, 0x46, 0xf9, 0x43, 0xb1, 0x49, 0xcd, 0xfb, 0x85, 0x98, 0xf9, 0x8a, 0xc0, 0x8e, 0xfd, 0x87, 0x22, 0x83, 0x6b, 0xa3, 0x20, 0xaa, 0x13, 0xb4, 0x6, 0x89, 0x4, 0x49, 0xf9, 0x85, 0xff, 0x8a, 0x56, 0x8c, 0x66, 0x43, 0xb2, 0x4d, 0xb3, 0x5c, 0x25, 0xdf, 0x8f, 0xb, 0xaa, 0x2a, 0x17, 0xef, 0x66, 0xc2, 0xee, 0xe, 0x6f, 0x6e, 0x2b, 0x42, 0xe1, 0x84, 0x47, 0x59, 0x21, 0x50, 0x8f, 0xa6, 0x46, 0x32, 0xa4, 0x62, 0x9b, 0x72, 0xf7, 0xf3, 0x95, 0x13, 0xa0, 0x8c, 0x6b, 0x55, 0xa8, 0xf0, 0x48, 0x3f, 0x3f, 0xe1, 0xae, 0x75, 0x28, 0xe1, 0x28, 0xfa, 0x30, 0x74, 0x5f, 0x5, 0x83, 0xc2, 0x3c, 0x27, 0xb9, 0xd1, 0xeb, 0xe5, 0x6a, 0xe8, 0x6a, 0xbc, 0x1e, 0x24, 0x48, 0xb1, 0x5c, 0x46, 0x49, 0xe5, 0xe2, 0x6e, 0x18, 0x90, 0x90, 0xea, 0x98, 0x62, 0x23, 0x68, 0x8f, 0x31, 0xf, 0x70, 0x75, 0x75, 0xf7, 0x37, 0x8c, 0x7a, 0xeb, 0x7, 0xe, 0xd, 0xdf, 0xac, 0xff, 0x6, 0x9d, 0xeb, 0xec, 0x77, 0x3b, 0x8b, 0x50, 0xdc, 0x86, 0xa0, 0x12, 0xdb, 0x58, 0x61, 0x2e, 0xc9, 0xd, 0x64, 0xae, 0xee, 0xa0, 0x37, 0xc3, 0xcf, 0x40, 0xe4, 0x2f, 0x19, 0x48, 0xef, 0x83, 0x79, 0x37, 0xd6, 0x7c, 0x70, 0x59, 0x73, 0x2b, 0xb3, 0x2f, 0xc6, 0x18, 0xa2, 0x3, 0xad, 0x6, 0xd5, 0xf8, 0xb4, 0x72, 0xd0, 0xd6, 0x92, 0xd9, 0x37, 0x7, 0xb6, 0xb1, 0xb8, 0x5f, 0x83, 0x16, 0x1d, 0x13, 0xbd, 0x9, 0x30, 0xfc, 0xdb, 0xcf, 0xf9, 0x44, 0x95, 0x27, 0x7d, 0x9e, 0x39, 0xa, 0xb6, 0x71, 0x37, 0x1d, 0x45, 0x40, 0xe6, 0x6a, 0xc1, 0x8f, 0x3, 0xd6, 0x25, 0xc8, 0xd3, 0x8e, 0x75, 0xf6, 0x28, 0xb0, 0x6f, 0x47, 0x8e, 0x6c, 0xc4, 0xa4, 0x98, 0xbd, 0xe8, 0x11, 0xb9, 0xdd, 0x8b, 0x63, 0x6f, 0x7c, 0x76, 0x12, 0x77, 0xa5, 0x61, 0x22, 0xe5, 0x9d, 0xa, 0xd8, 0x5, 0x2a, 0xe0, 0xc, 0x8d, 0x8, 0x43, 0x64, 0x8, 0xea, 0x54, 0x33, 0xd6, 0x2, 0x7f, 0x79, 0x8f, 0x48, 0xdd, 0xf1, 0x5b, 0xa7, 0x60, 0x3, 0x63, 0xc7, 0xef, 0x67, 0x23, 0x6f, 0xa6, 0xef, 0x37, 0x74, 0x25, 0xcd, 0x9f, 0x63, 0x47, 0x88, 0xe9, 0xce, 0x34, 0xd0, 0x8a, 0x95, 0x6e, 0x24, 0xe3, 0x13, 0x71, 0x49, 0xb0, 0x8a, 0xe, 0xaa, 0x2d, 0x83, 0x1b, 0xf, 0x32, 0x85, 0xbf, 0xd2, 0x30, 0x85, 0x9a, 0xd0, 0x2d, 0x50, 0xfe, 0xb1, 0xb, 0x63, 0xee, 0xa8, 0x4, 0x4d, 0xbe, 0x97, 0x69, 0x3c, 0x29, 0xc1, 0x5, 0xc2, 0x16, 0x4e, 0xf4, 0x36, 0xb8, 0x8d, 0x5d, 0x87, 0xf, 0x88, 0xad, 0x59, 0x19, 0xfd, 0xe8, 0x14, 0x9b, 0x39, 0xaa, 0x65, 0xe9, 0x31, 0xbf, 0x5d, 0x46, 0x1a, 0x10, 0x9a, 0x42, 0x3e, 0x81, 0xc3, 0x76, 0xf1, 0x14, 0x95, 0xc0, 0x67, 0x1f, 0x3c, 0xf3, 0x71, 0xf8, 0x9f, 0x81, 0xd5, 0x22, 0x35, 0xd3, 0x41, 0x39, 0x92, 0x71, 0x31, 0x41, 0xc3, 0xf2, 0x8f, 0x14, 0xa9, 0x26, 0x40, 0x7a, 0x23, 0x9d, 0x6a, 0xd9, 0xcf, 0xe5, 0x65, 0xcc, 0x29, 0xf8, 0xa8, 0x36, 0xe5, 0x64, 0x3f, 0x5e, 0xad, 0x4c, 0xbd, 0x6b, 0xc9, 0x36, 0xef, 0xfd, 0xc6, 0x87, 0xb7, 0x58, 0x38, 0x4d, 0x7, 0x2, 0x73, 0xc8, 0xc2, 0xd2, 0xdb, 0xb8, 0x11, 0x23, 0xb5, 0x24, 0x14, 0x79, 0x79, 0xa8, 0xe0, 0xc0, 0xd9, 0x9b, 0x9, 0x81, 0x2e, 0xfa, 0xc7, 0x39, 0x46, 0x5d, 0x1a, 0x85, 0x8e, 0xf2, 0x33, 0xcd, 0xd1, 0x37, 0x69, 0xbb, 0x89, 0x96, 0x85, 0x6c, 0xcf, 0x50, 0x9d, 0x50, 0xcb, 0x33, 0xe4, 0x48, 0xa, 0x6a, 0xd9, 0x51, 0xe4, 0x51, 0xcc, 0x63, 0x79, 0x33, 0xbf, 0x8d, 0xbd, 0x51, 0x68, 0xc0, 0x6a, 0x76, 0xdd, 0x8, 0xd4, 0x2e, 0x6f, 0xb0, 0xba, 0x10, 0x44, 0xfc, 0x33, 0x47, 0x5a, 0x23, 0x42, 0xa5, 0x37, 0x65, 0xbd, 0x40, 0x99, 0x54, 0x6c, 0x9e, 0xf9, 0x6d, 0xe5, 0xb7, 0x8c, 0x59, 0xca, 0x61, 0x23, 0x22, 0x3e, 0x6f, 0x72, 0x68, 0xa, 0xb, 0x9d, 0xd9, 0xa1, 0x2b, 0x24, 0xca, 0xfe, 0xe3, 0x2f, 0xb, 0x6e, 0x14, 0x55, 0x15, 0x22, 0x2c, 0xbf, 0x2a, 0xbb, 0xd7, 0x33, 0xb, 0x9a, 0x91, 0x30, 0x3b, 0x68, 0x8d, 0xcc, 0x35, 0xdb, 0x23, 0x3c, 0x71, 0x4, 0x67, 0x16, 0x82, 0x1e, 0xe4, 0x9, 0x8, 0x3c, 0x79, 0xb, 0xca, 0xa8, 0x93, 0xd0, 0x4c, 0x9, 0xa8, 0xf6, 0xa9, 0xc3, 0x5c, 0x7, 0x2e, 0x50, 0x33, 0x10, 0x84, 0x6, 0x0, 0x95, 0x64, 0xb4, 0x13, 0x5c, 0x0, 0xfe, 0x40, 0x37, 0xd2, 0xd5, 0x1a, 0xb1, 0xd7, 0x21, 0xae, 0x6b, 0x74, 0xe8, 0x67, 0x7, 0x41, 0x99, 0xb7, 0x3b, 0x93, 0xa6, 0xd8, 0x9d, 0xdb, 0x8e, 0xe7, 0x46, 0x81, 0x21, 0x3b, 0xb6, 0x77, 0x1, 0x4d, 0x1c, 0xd7, 0x58, 0x21, 0xea, 0xdd, 0xdd, 0x7c, 0x1c, 0x78, 0xb6, 0xb7, 0x5a, 0xcf, 0x57, 0x4c, 0xbb, 0x28, 0x8d, 0x2b, 0x77, 0x8d, 0x84, 0xf8, 0x59, 0x9a, 0x42, 0x1c, 0x5b, 0x8b, 0x9a, 0x3b, 0x12, 0xf, 0x8b, 0x8f, 0x98, 0xb5, 0xcf, 0xb8, 0x1f, 0x4f, 0x8b, 0xbc, 0x41, 0x6e, 0x3e, 0x1e, 0x94, 0x62, 0xee, 0xa5, 0x84, 0xb, 0x96, 0xea, 0x87, 0x4a, 0x6c, 0x82, 0x67, 0xf5, 0xd1, 0x64, 0x51, 0xb9, 0x3b, 0x72, 0xdd, 0x59, 0x51, 0xde, 0x2c, 0x4d, 0x6d, 0x3f, 0x94, 0xba, 0x87, 0xa6, 0x2a, 0x19, 0xda, 0x58, 0xe3, 0xc, 0xcf, 0x7f, 0xb7, 0x82, 0x74, 0x5c, 0x23, 0x3c, 0xdc, 0xe1, 0xb0, 0xae, 0x1b, 0x1f, 0x14, 0x76, 0x98, 0x3d, 0x12, 0x34, 0x40, 0xa7, 0x65, 0xd5, 0xdb, 0xc, 0x3e, 0x38, 0xc4, 0x7b, 0xbf, 0xec, 0x5c, 0xe3, 0x7b, 0x94, 0x96, 0x93, 0x77, 0x39, 0x4a, 0x25, 0xa9, 0x4, 0x71, 0xaa, 0x9d, 0xdc, 0x98, 0xd5, 0x59, 0xdc, 0x98, 0x2a, 0x76, 0x30, 0xb6, 0x0, 0x9a, 0x77, 0x48, 0xe9, 0xe5, 0xf6, 0xfe, 0x93, 0x97, 0xfe, 0x4a, 0xfb, 0xa1, 0xeb, 0xe5, 0x30, 0xb8, 0xc4, 0x6f, 0x4f, 0x18, 0xcc, 0xa2, 0x71, 0x85, 0x6e, 0xfb, 0xfe, 0x57, 0x91, 0xfb, 0x92, 0x97, 0x11, 0x4d, 0x95, 0x2f, 0xe, 0x37, 0x94, 0x9e, 0x3d, 0xd5, 0xa3, 0x8f, 0xd3, 0x80, 0x5e, 0xff, 0x33, 0xdb, 0xec, 0x3b, 0xae, 0xb2, 0x2a, 0x8e, 0xe9, 0x3b, 0x42, 0xf8, 0x5c, 0x84, 0x5c, 0xf3, 0xc2, 0xc0, 0xc, 0x70, 0x6e, 0x11, 0xec, 0x79, 0x75, 0xf6, 0x36, 0x6c, 0x6a, 0x38, 0xc2, 0x41, 0x7e, 0xdf, 0xde, 0xfa, 0xf0, 0x3a, 0xed, 0x1, 0xa9, 0x87, 0xe4, 0x64, 0x83, 0xd, 0x78, 0x91, 0xb0, 0xab, 0x7f, 0x67, 0xf0, 0x80, 0x96, 0xe8, 0x1f, 0x93, 0x7d, 0xf9, 0xab, 0x60, 0x5c, 0x3a, 0xbf, 0xd1, 0xf2, 0x67, 0x3f, 0xa3, 0x2, 0x88, 0x28, 0x6, 0x71, 0x8c, 0xb, 0x87, 0x50, 0xc5, 0x9d, 0xb, 0x5f, 0x27, 0xbd, 0x16, 0x57, 0x9e, 0x5e, 0x5a, 0xa1, 0xb5, 0xa9, 0x82, 0x57, 0x62, 0x7f, 0x97, 0xae, 0x38, 0xbb, 0xd7, 0x9a, 0xc, 0x21, 0xe4, 0x8e, 0xf7, 0xba, 0xe4, 0x36, 0xc, 0x0, 0x3e, 0x8f, 0x86, 0xb8, 0x9b, 0x4, 0x2b, 0x65, 0xf4, 0x36, 0xce, 0xdf, 0x39, 0xca, 0x3, 0xd, 0xfc, 0xe9, 0xff, 0x77, 0x2c, 0xd9, 0x92, 0x74, 0xbd, 0xd0, 0xe6, 0x25, 0x2d, 0x8e, 0xae, 0x87, 0x73, 0x30, 0xa2, 0x1b, 0xbf, 0x6f, 0x26, 0x6f, 0x27, 0xd1, 0x19, 0x70, 0xe, 0xa5, 0x97, 0xa3, 0x9a, 0xcc, 0x8c, 0x21, 0x2b, 0x43, 0xda, 0x9a, 0x77, 0x5a, 0x6e, 0x16, 0x5c, 0x60, 0xf6, 0xef, 0xb7, 0x57, 0x1, 0xb7, 0xae, 0xca, 0x10, 0x1f, 0x70, 0xae, 0x54, 0x1a, 0x44, 0xeb, 0xa7, 0x50, 0xd, 0xf1, 0x4e, 0xfc, 0x38, 0xf2, 0xe8, 0xe1, 0x22, 0x38, 0xcb, 0x74, 0x79, 0xfd, 0x41, 0x48, 0x32, 0x2f, 0x10, 0x55, 0x68, 0xb, 0xbc, 0xa8, 0xe5, 0x35, 0xcb, 0x5e, 0xca, 0x77, 0xa5, 0x56, 0x12, 0xe5, 0x63, 0xf6, 0xce, 0x2a, 0x57, 0xb1, 0xfb, 0x9b, 0x66, 0x3a, 0xd0, 0xb5, 0x5e, 0xf2, 0x7b, 0x2e, 0xe3, 0x2e, 0x6f, 0x77, 0x9c, 0x6f, 0x9e, 0x74, 0x32, 0x32, 0x56, 0xd3, 0xd0, 0xa2, 0xe2, 0x47, 0x94, 0x3d, 0xdd, 0x75, 0x83, 0x6f, 0x4b, 0x7, 0xb1, 0x48, 0xa, 0x0, 0xcf, 0x4f, 0x62, 0x9, 0x2e, 0x5f, 0xf6, 0xd, 0xbe, 0x75, 0x41, 0x8b, 0x6b, 0xdb, 0xdb, 0xa5, 0x9d, 0xa3, 0x97, 0xf2, 0x3b, 0x54, 0x70, 0xbb, 0x33, 0x74, 0x87, 0xc8, 0x63, 0xad, 0xa5, 0xcd, 0x84, 0x83, 0xe6, 0xc5, 0x4d, 0x20, 0x18, 0x83, 0xa3, 0x36, 0x7d, 0xa2, 0xb2, 0xf4, 0x9c, 0x66, 0xb7, 0xfc, 0x67, 0x5a, 0xc4, 0x7d, 0xdf, 0x7d, 0x26, 0xcb, 0x3b, 0x40, 0xdd, 0x86, 0x4c, 0xea, 0x1a, 0x17, 0x8b, 0xb1, 0x27, 0x7b, 0x28, 0xf1, 0x98, 0x93, 0x7c, 0x12, 0xbd, 0xd8, 0xc1, 0x45, 0x73, 0xc4, 0x29, 0xfb, 0x13, 0x9b, 0xce, 0x19, 0xec, 0x9b, 0x44, 0x65, 0x52, 0x80, 0x8d, 0x25, 0xf8, 0x61, 0xd, 0xbf, 0x94, 0x9d, 0x33, 0xa0, 0x65, 0x50, 0x38, 0x3d, 0xf5, 0xf3, 0xcb, 0xf7, 0x99, 0xb0, 0xfa, 0x41, 0xdc, 0x59, 0x35, 0xda, 0xb1, 0x18, 0xa7, 0x17, 0x83, 0x81, 0xed, 0x3e, 0xf9, 0xbd, 0xbd, 0x63, 0x24, 0x72, 0xcb, 0xc4, 0x8f, 0x21, 0xde, 0xb7, 0xb5, 0xb2, 0x6c, 0x6d, 0x6a, 0x4c, 0x6d, 0x8b, 0xbc, 0xa6, 0x9, 0xee, 0x39, 0xc5, 0x1, 0x78, 0x7f, 0x6e, 0xf2, 0xa9, 0xb4, 0x5f, 0xff, 0x5c, 0x6c, 0x57, 0x35, 0x5d, 0xdb, 0x17, 0xb7, 0xa2, 0x71, 0xc7, 0xb5, 0x6f, 0x1b, 0x7b, 0x4c, 0xca, 0xe8, 0xdf, 0x84, 0xc0, 0x15, 0x14, 0xcf, 0x9f, 0x81, 0x38, 0x15, 0xc, 0x77, 0xac, 0x95, 0xea, 0x22, 0xb5, 0xc7, 0xda, 0x74, 0xdf, 0x60, 0xef, 0xb0, 0x60, 0x5f, 0x31, 0xd, 0x42, 0xee, 0x7, 0x14, 0x38, 0xc5, 0x14, 0xa4, 0x18, 0xb6, 0x22, 0x47, 0xdc, 0x2c, 0x55, 0xa2, 0x3d, 0xe, 0x73, 0x1e, 0xf9, 0xe5, 0x14, 0xd1, 0xdd, 0xa7, 0x3f, 0x57, 0xb2, 0xb6, 0xfc, 0x4b, 0x4f, 0xce, 0x62, 0xf1, 0xf0, 0xd0, 0xb5, 0x45, 0xab, 0x8f, 0xc0, 0x8a, 0xd4, 0x44, 0x9b, 0x96, 0x62, 0x19, 0xe1, 0xd5, 0x33, 0xf2, 0x6a, 0x4c, 0x4f, 0x62, 0x8c, 0x29, 0x48, 0x53, 0xc, 0x5, 0x18, 0xb9, 0x6f, 0xa8, 0xb9, 0x79, 0x25, 0x62, 0x9d, 0xad, 0x65, 0xfa, 0x65, 0x51, 0xbf, 0xe9, 0x10, 0x2c, 0xf1, 0xb9, 0xb7, 0xc4, 0x3c, 0x41, 0xf8, 0xbf, 0x4d, 0xe9, 0x93, 0xfd, 0x53, 0xc4, 0xe5, 0x82, 0x54, 0x8a, 0xcc, 0x64, 0xf6, 0x7b, 0x2e, 0x9f, 0xfa, 0x34, 0xb8, 0xb9, 0xe2, 0xf6, 0x4c, 0x87, 0x43, 0x6c, 0xa6, 0xd1, 0xd0, 0xf2, 0x2a, 0x2c, 0xa2, 0x36, 0xfb, 0xa1, 0xd, 0x91, 0x92, 0x40, 0xb, 0x11, 0xd7, 0x73, 0x7, 0xb5, 0x14, 0x87, 0xd9, 0x86, 0xdd, 0xf4, 0x18, 0x7, 0x68, 0x33, 0xcc, 0xa1, 0x63, 0x9a, 0x2c, 0x9b, 0x80, 0xc3, 0x9, 0xa3, 0xa4, 0xec, 0x9e, 0xd9, 0x10, 0x8a, 0x69, 0xec, 0x13, 0x6b, 0x73, 0x98, 0x24, 0x41, 0x67, 0x42, 0x39, 0xa6, 0xa3, 0x80, 0x85, 0xa, 0x7e, 0x18, 0x58, 0x4e, 0x95, 0x56, 0xb7, 0xa6, 0x29, 0x55, 0x78, 0xe4, 0xad, 0xb0, 0x10, 0xd5, 0xec, 0x2a, 0x3c, 0x5b, 0xfd, 0xd3, 0x6, 0x2a, 0x9b, 0xc5, 0xa2, 0xa8, 0xac, 0x6e, 0xaa, 0x45, 0xf6, 0x3b, 0xe5, 0x0, 0x2a, 0x5b, 0x53, 0xa0, 0x37, 0xcd, 0x2e, 0x99, 0x6d, 0x3e, 0xb, 0x25, 0x6a, 0xff, 0x17, 0x78, 0x35, 0x28, 0xab, 0x93, 0xeb, 0x48, 0xb2, 0x80, 0x6e, 0xd0, 0xd4, 0xca, 0x4a, 0x3, 0x70, 0x22, 0xc5, 0x85, 0xee, 0x77, 0x89, 0xf8, 0xf2, 0x53, 0x80, 0x3d, 0x89, 0x7e, 0xa6, 0xf0, 0xc4, 0xf, 0x7, 0xf0, 0x45, 0x74, 0xaa, 0xbc, 0xec, 0x46, 0x9c, 0xd9, 0x8b, 0x7c, 0xf1, 0xb3, 0x52, 0x85, 0x7a, 0xe3, 0x2d, 0xcd, 0xb2, 0xed, 0xf8, 0xcc, 0x2e, 0x35, 0x94, 0x67, 0x9b, 0x9, 0x69, 0x9, 0x5c, 0xc4, 0x50, 0x7d, 0xc3, 0xe9, 0x5, 0x9c, 0xde, 0x8a, 0xa2, 0xbf, 0x16, 0xff, 0x73, 0x6, 0x96, 0xfe, 0x75, 0xcb, 0x63, 0x55, 0x56, 0x93, 0xc9, 0xe0, 0x3, 0xb4, 0x7e, 0x29, 0x2, 0xa0, 0x51, 0x32, 0x74, 0x5d, 0x5d, 0x48, 0xc0, 0xa3, 0x6f, 0x10, 0x17, 0x78, 0xc6, 0x6e, 0xb9, 0xca, 0x32, 0x87, 0x39, 0x7e, 0x27, 0x8b, 0xa4, 0xa3, 0xd1, 0xe8, 0xe, 0x5d, 0x7e, 0x1f, 0xa0, 0x41, 0x34, 0x4e, 0x2f, 0xf0, 0xd4, 0x79, 0x54, 0x76, 0xb5, 0xd2, 0x9, 0x8e, 0x39, 0xdd, 0xc7, 0x73, 0x8f, 0x5b, 0x9a, 0x87, 0x1e, 0x4d, 0x96, 0x34, 0x83, 0xeb, 0x72, 0x86, 0x68, 0x1a, 0x3d, 0xfa, 0xc3, 0x8d, 0x58, 0x66, 0xbb, 0x95, 0xf2, 0xd6, 0xbc, 0x43, 0xf, 0xf1, 0x1e, 0x39, 0x52, 0x79, 0xdb, 0x71, 0x16, 0x57, 0x2, 0x3e, 0x2f, 0x4e, 0x54, 0x2d, 0x9f, 0x39, 0x42, 0x19, 0x10, 0xca, 0x2, 0xed, 0x7b, 0xc7, 0x67, 0xb4, 0x7a, 0x33, 0xd0, 0x96, 0x96, 0x98, 0x2f, 0xc6, 0xa0, 0x84, 0x8f, 0x12, 0xf0, 0xa8, 0x4b, 0xfb, 0xa1, 0xa0, 0xb4, 0x2a, 0xb, 0x55, 0xc3, 0xe3, 0xd9, 0x8b, 0x5, 0x97, 0x8b, 0x53, 0xba, 0xa8, 0x13, 0x13, 0xd, 0x18, 0xad, 0xd7, 0x6d, 0xb7, 0xee, 0x84, 0x83, 0xa2, 0xd6, 0xb3, 0x41, 0xb, 0x8, 0xc7, 0x62, 0x3c, 0x6b, 0x46, 0x3e, 0x4, 0xd4, 0xd5, 0x3b, 0xab, 0x51, 0xf0, 0xa5, 0xa3, 0xf2, 0x6b, 0x9e, 0xb, 0xec, 0xf9, 0x8c, 0x10, 0x67, 0xa2, 0x16, 0x77, 0xc0, 0x78, 0x22, 0xf5, 0xf7, 0x30, 0xfc, 0xf5, 0x23, 0x9d, 0x69, 0xd6, 0xd3, 0x4b, 0x1d, 0x83, 0xea, 0xe3, 0x40, 0x9c, 0x4a, 0x9c, 0xb2, 0x6b, 0x75, 0x4f, 0x24, 0x82, 0x71, 0xdf, 0xc7, 0x75, 0xcf, 0x45, 0x53, 0x72, 0xc6, 0x1c, 0x60, 0x99, 0xf2, 0xd8, 0x17, 0x22, 0x74, 0xea, 0x4f, 0xa4, 0xd, 0x87, 0x75, 0x9c, 0x2e, 0xf2, 0xf5, 0xf4, 0xb9, 0x8, 0x6c, 0xa4, 0xa7, 0xdc, 0x6a, 0x5a, 0x20, 0x1, 0xa3, 0xb8, 0x50, 0x76, 0xa6, 0x43, 0x6a, 0xed, 0xc3, 0x8, 0x8e, 0x26, 0xaf, 0x74, 0xc9, 0x8f, 0x18, 0x50, 0x57, 0xe0, 0x78, 0x1b, 0xbf, 0x8d, 0x52, 0xc0, 0xe4, 0xeb, 0x3c, 0x4a, 0xd, 0x3e, 0x22, 0xcc, 0xa0, 0xa8, 0xe2, 0xd1, 0x5f, 0xe7, 0x5d, 0x87, 0xaa, 0xea, 0x72, 0x3a, 0x99, 0x1d, 0x81, 0x3a, 0x67, 0xd9, 0x3e, 0x26, 0xb3, 0x12, 0x89, 0xb4, 0x6e, 0x21, 0x41, 0x6a, 0x0, 0xee, 0x86, 0xb7, 0x85, 0xe0, 0xf4, 0x70, 0xc2, 0xa3, 0xd0, 0xbe, 0xb1, 0x83, 0x5, 0x91, 0x5a, 0xe2, 0x1d, 0xe, 0x7d, 0x3c, 0x27, 0xc2, 0xd3, 0x7a, 0x5, 0xc8, 0xfb, 0x80, 0x89, 0x21, 0xd4, 0xe7, 0x59, 0xa4, 0xd3, 0x13, 0x96, 0x24, 0xbf, 0x2a, 0xc8, 0xd5, 0xca, 0x8a, 0xec, 0xb, 0xa0, 0x7d, 0x5a, 0x3, 0xe1, 0x3b, 0xa4, 0x5a, 0xc7, 0x1a, 0xfc, 0xea, 0xe9, 0xf2, 0xb5, 0x5d, 0xf, 0xe7, 0xa, 0xf8, 0x33, 0x42, 0x45, 0xe7, 0x16, 0xfb, 0xd6, 0x41, 0x18, 0x0, 0xd6, 0x4, 0x3f, 0x30, 0xd6, 0x69, 0x9a, 0x81, 0xe1, 0xa9, 0x2, 0xf8, 0xfb, 0x1d, 0xd2, 0x3f, 0xc0, 0xd9, 0x44, 0x3f, 0x5, 0xab, 0xff, 0xa7, 0xfd, 0x25, 0xb6, 0xf0, 0xd8, 0x37, 0x1, 0x57, 0x8c, 0x54, 0xe0, 0x51, 0x5, 0x5a, 0x5d, 0x27, 0x85, 0x94, 0x1b, 0xee, 0x2c, 0xed, 0x39, 0xe8, 0xfc, 0xab, 0x99, 0x23, 0xb7, 0xc3, 0x5, 0xfd, 0x23, 0xcd, 0xac, 0xd5, 0xc6, 0xf7, 0x1e, 0x64, 0x55, 0x17, 0xd0, 0xbf, 0x34, 0xda, 0x56, 0xf7, 0xcc, 0x6, 0x17, 0x5e, 0xd9, 0x20, 0xcd, 0x1a, 0x6e, 0xb7, 0x13, 0x20, 0xa, 0x21, 0x25, 0x38, 0x69, 0xf, 0x48, 0x1c, 0xbc, 0x44, 0x33, 0xb3, 0x7b, 0xf7, 0x33, 0x7c, 0x61, 0xed, 0xf6, 0xd2, 0x7f, 0xfa, 0xe8, 0x55, 0x69, 0x41, 0xaa, 0xa5, 0xf4, 0x3a, 0x5e, 0xb6, 0x11, 0xa, 0xe7, 0x3e, 0x28, 0xe1, 0x90, 0xae, 0xe, 0xc6, 0xe6, 0xa4, 0x36, 0x31, 0x2f, 0xa7, 0x2d, 0xa, 0xff, 0xdd, 0x9e, 0xba, 0xe4, 0x33, 0xf6, 0x5, 0x7, 0xf6, 0x24, 0xbb, 0x7a, 0x5f, 0xc4, 0x8c, 0x3a, 0xe8, 0x53, 0xa8, 0xc1, 0x46, 0xa3, 0x32, 0x78, 0x56, 0x66, 0x36, 0x7a, 0x8b, 0x7f, 0x9f, 0xb5, 0x86, 0x3a, 0xe7, 0x5b, 0x9, 0xfc, 0x31, 0x94, 0xd8, 0x90, 0xa3, 0xf7, 0x24, 0xd6, 0x16, 0x1b, 0xc, 0x8d, 0x24, 0xe0, 0xf0, 0xf2, 0x6b, 0xda, 0xe7, 0x11, 0xae, 0x13, 0xba, 0x8b, 0xcc, 0xa5, 0x5f, 0x9a, 0xc3, 0xbb, 0xd9, 0xee, 0x43, 0xcb, 0x3a, 0x45, 0x1a, 0x13, 0xf9, 0xd5, 0x3f, 0xbc, 0x4d, 0x50, 0x3f, 0x91, 0xec, 0x77, 0x30, 0x22, 0x15, 0x8f, 0xc6, 0x66, 0x62, 0xa7, 0xb7, 0x5a, 0x61, 0x7f, 0xd1, 0xb9, 0xd0, 0x30, 0x72, 0x7f, 0x2d, 0x25, 0x5, 0x23, 0x1c, 0x59, 0xd9, 0x22, 0x34, 0x64, 0xad, 0x71, 0x31, 0x52, 0xfd, 0xd3, 0x53, 0xad, 0x50, 0xd, 0x60, 0x5c, 0x38, 0x31, 0x7f, 0xb5, 0xc6, 0xa9, 0xe0, 0x52, 0xb9, 0x52, 0x61, 0xba, 0x64, 0x5, 0x38, 0x9a, 0xee, 0xa7, 0x8, 0x55, 0xc0, 0xcb, 0x28, 0x70, 0xe9, 0x70, 0x89, 0xd7, 0xf6, 0xa6, 0x23, 0x1e, 0xaa, 0xdc, 0x11, 0x6a, 0xad, 0xfe, 0x35, 0x81, 0xd9, 0x1b, 0x30, 0xb7, 0xee, 0x22, 0xe1, 0xd8, 0xd9, 0x1d, 0x81, 0x2e, 0x64, 0x1b, 0x77, 0x86, 0xc0, 0x4c, 0xb, 0xb4, 0xab, 0x5a, 0x58, 0xf9, 0x3d, 0xbc, 0x48, 0x49, 0x3a, 0x51, 0x75, 0x5b, 0x5c, 0xcd, 0xdd, 0xa3, 0x73, 0xcd, 0xe4, 0xd7, 0x1e, 0x20, 0x7, 0xf5, 0xbc, 0xc9, 0x3, 0x21, 0x59, 0x83, 0xba, 0x84, 0x79, 0x9, 0x73, 0x9c, 0x8d, 0x80, 0x95, 0x5c, 0x35, 0x2, 0x8, 0xc6, 0x10, 0x49, 0xf4, 0x2, 0x72, 0x49, 0x6d, 0x55, 0xe, 0x1, 0x39, 0x7e, 0x8d, 0x81, 0x7b, 0x91, 0xfe, 0xc0, 0xd1, 0x5d, 0x61, 0xa2, 0x8d, 0xba, 0x51, 0x61, 0x8f, 0xf3, 0xe8, 0x61, 0x9a, 0xd9, 0xde, 0x3c, 0xc3, 0xa9, 0xe3, 0x5f, 0xc1, 0x77, 0x7b, 0xb6, 0x18, 0x9a, 0x1a, 0x50, 0xef, 0x42, 0xcf, 0xf1, 0xee, 0xb7, 0x16, 0xc8, 0x27, 0xf7, 0x93, 0xd8, 0xa, 0xe5, 0x50, 0x65, 0x67, 0x1a, 0x29, 0xaf, 0x4b, 0xc1, 0x36, 0xc, 0x36, 0xf7, 0x3d, 0x32, 0x81, 0xc6, 0x90, 0xf7, 0xcf, 0x2e, 0xf, 0x94, 0x24, 0x5f, 0x9c, 0xe8, 0xa9, 0x6c, 0xe5, 0x3a, 0x99, 0xcb, 0x23, 0x2, 0x94, 0xd, 0x9, 0xbe, 0x86, 0xcf, 0x7, 0xcc, 0x7a, 0x37, 0x7, 0x33, 0x82, 0xd2, 0xf5, 0x60, 0xd7, 0x33, 0x73, 0x9f, 0xa9, 0xd9, 0x9e, 0xd4, 0xd1, 0x6f, 0xa5, 0xa8, 0x10, 0x66, 0xf5, 0xaf, 0x1, 0xe1, 0x7e, 0x75, 0x7c, 0xff, 0xbf, 0x9e, 0xf6, 0xca, 0x9e, 0xca, 0xcc, 0x81, 0x28, 0xb0, 0x36, 0x1b, 0x3a, 0xbd, 0xce, 0x84, 0xc, 0x50, 0x4c, 0x31, 0x49, 0x7b, 0xa5, 0xe1, 0x59, 0x33, 0xf1, 0x8a, 0x1b, 0xba, 0x12, 0x14, 0xcf, 0x2f, 0x1, 0x97, 0x52, 0xcb, 0x5a, 0xe6, 0x1f, 0x90, 0x0, 0xc8, 0x5c, 0xaa, 0xba, 0x22, 0x52, 0x75, 0x49, 0x36, 0xba, 0x35, 0xa, 0x60, 0xc0, 0x2b, 0x33, 0xeb, 0x41, 0x8d, 0xa3, 0x57, 0x2a, 0xf1, 0x43, 0xcb, 0xb2, 0xe9, 0x9d, 0x6b, 0xfd, 0x88, 0x56, 0xa8, 0x8d, 0xbf, 0xd5, 0x32, 0x9b, 0x11, 0x81, 0x3e, 0x41, 0xa, 0x56, 0xb0, 0xd5, 0x70, 0xee, 0x39, 0xe2, 0x62, 0xf9, 0x2, 0xa8, 0x2f, 0x89, 0x1, 0x36, 0xe1, 0xaf, 0xee, 0xda, 0xc5, 0x91, 0x90, 0x47, 0x64, 0xcd, 0x5e, 0xf0, 0x67, 0x6b, 0x7e, 0xf2, 0xa4, 0x31, 0x7a, 0x48, 0x4b, 0x99, 0x45, 0x6, 0xe9, 0xa7, 0xff, 0xd9, 0x35, 0x50, 0x76, 0x29, 0x75, 0xba, 0xc0, 0x17, 0x3c, 0x90, 0x99, 0x2a, 0x9e, 0x93, 0x8e, 0x6d, 0xea, 0xc5, 0x63, 0xd7, 0xf3, 0x60, 0xab, 0x7d, 0xa0, 0x3, 0x24, 0x8a, 0x1c, 0xbf, 0x3f, 0xd4, 0x30, 0x67, 0x2e, 0x21, 0xf8, 0x7f, 0xaf, 0xa, 0x1a, 0x91, 0xb3, 0x5, 0xba, 0x1f, 0x6a, 0xb4, 0x6b, 0xf3, 0x7b, 0xcb, 0xf7, 0x2, 0x10, 0xb4, 0xa, 0xa2, 0x2b, 0xea, 0xef, 0x8c, 0x87, 0x83, 0x15, 0xc2, 0x4e, 0x50, 0x3b, 0x5a, 0xfa, 0xd8, 0xb9, 0xd2, 0x38, 0x4f, 0x82, 0x2a, 0xe8, 0xc3, 0xa7, 0x94, 0x1f, 0x58, 0xf3, 0x6c, 0x48, 0x4b, 0x82, 0x98, 0xc3, 0x9c, 0x40, 0x9c, 0x32, 0xcd, 0xf2, 0x55, 0x1c, 0xf8, 0xa9, 0xd, 0xf0, 0x8d, 0xf6, 0xc4, 0x31, 0x37, 0x99, 0xb0, 0xb7, 0x81, 0xa4, 0xaa, 0x5, 0xd7, 0x63, 0x1b, 0x73, 0x96, 0x9c, 0x54, 0x4, 0xd0, 0xc, 0xb0, 0x53, 0xb7, 0x86, 0xb5, 0xea, 0x67, 0xdb, 0xfa, 0x9c},
+               output224: []byte{0x4c, 0x5, 0x2d, 0x37, 0x5b, 0x7, 0xb3, 0xbe, 0x2b, 0xcb, 0xf5, 0x4b, 0x29, 0xc0, 0xbd, 0x26, 0xc3, 0xbf, 0xd5, 0x16, 0xac, 0x26, 0x4f, 0x4d, 0xe5, 0xe6, 0x7b, 0xb9},
+               output256: []byte{0xe3, 0x79, 0x77, 0x5a, 0xe8, 0x0, 0x3b, 0x80, 0xa8, 0x25, 0xf7, 0x94, 0xc8, 0x3e, 0xb6, 0x52, 0x96, 0x9f, 0xb0, 0x64, 0xc5, 0x41, 0xa7, 0x99, 0xe1, 0x74, 0x54, 0x95, 0x80, 0xcb, 0x76, 0x59},
+               output384: []byte{0x3d, 0x43, 0x7a, 0x92, 0x1b, 0x29, 0xae, 0xce, 0xe0, 0x6b, 0x46, 0xa2, 0x6b, 0x8d, 0xde, 0x14, 0xdd, 0x95, 0xcb, 0x62, 0x43, 0x3d, 0x75, 0x52, 0xc9, 0xf9, 0x4c, 0xaf, 0x82, 0x99, 0xfb, 0xb6, 0xa0, 0xbd, 0xc8, 0x22, 0x94, 0xd3, 0x1, 0x6c, 0x25, 0x4b, 0x9a, 0x41, 0xca, 0xd9, 0xcc, 0x15},
+               output512: []byte{0x56, 0x14, 0xa6, 0xd6, 0xf5, 0x52, 0xd4, 0xc9, 0xda, 0xd4, 0x86, 0x41, 0xec, 0xe0, 0xce, 0xf2, 0xa3, 0xf0, 0x50, 0x11, 0x45, 0x26, 0xf8, 0x12, 0x36, 0xae, 0x53, 0xad, 0x7e, 0x8f, 0x84, 0x99, 0x94, 0x6, 0x73, 0xa8, 0xac, 0x51, 0x31, 0x93, 0x69, 0xb8, 0x21, 0x4a, 0x35, 0x8b, 0x4e, 0x4, 0x76, 0xc9, 0x49, 0x69, 0x11, 0x22, 0xb4, 0x67, 0x7a, 0xb1, 0x3c, 0x3b, 0x98, 0xb2, 0x47, 0x9b}},
+       testcase{
+               msg:       []byte{0xe6, 0x91, 0xe8, 0xfe, 0xb7, 0x44, 0x95, 0x7b, 0x27, 0x5e, 0x5f, 0xd8, 0x79, 0xa3, 0xab, 0xe5, 0x4d, 0x6d, 0x6c, 0x8c, 0x7f, 0x58, 0x9f, 0xb, 0x1a, 0x17, 0xc0, 0x8c, 0x29, 0x9c, 0x55, 0x9e, 0x5f, 0x7, 0xc9, 0xea, 0xa1, 0x2b, 0x3d, 0xbf, 0xe, 0x6, 0x34, 0x2e, 0x63, 0x44, 0x22, 0x9e, 0x99, 0x31, 0x21, 0x7e, 0x77, 0xf3, 0x4b, 0x53, 0x1, 0x45, 0x77, 0xab, 0x76, 0xfb, 0xee, 0x38, 0xec, 0x3f, 0x49, 0x1e, 0x7e, 0xa, 0x12, 0x95, 0x0, 0xbe, 0xec, 0xae, 0x77, 0x74, 0x5f, 0x98, 0x37, 0xc, 0xf6, 0xd4, 0xd0, 0xe3, 0x9c, 0x42, 0x73, 0xae, 0xf3, 0x66, 0xb9, 0xbb, 0x28, 0x64, 0xc, 0xcd, 0x6b, 0x11, 0xb4, 0xa7, 0xea, 0x7f, 0x4b, 0xe9, 0xc5, 0xc9, 0xee, 0x52, 0x9d, 0xa, 0x1b, 0xfd, 0x14, 0x50, 0xb5, 0xfb, 0x91, 0x90, 0xc1, 0xd8, 0xbb, 0xcf, 0x1b, 0x80, 0x33, 0x6c, 0x21, 0x29, 0x92, 0xd4, 0x28, 0xc2, 0x0, 0xb5, 0xcd, 0x34, 0xca, 0x3c, 0xdd, 0x75, 0xe1, 0x75, 0x99, 0x7a, 0xc6, 0x18, 0x1e, 0x3d, 0x49, 0x72, 0x88, 0x6f, 0xc9, 0xd4, 0x10, 0x38, 0xb0, 0x77, 0xcd, 0x1e, 0x78, 0x6a, 0xb3, 0xac, 0x82, 0xc3, 0xc8, 0xad, 0x6d, 0xd5, 0xd0, 0x1e, 0xff, 0xa3, 0x96, 0x29, 0x54, 0xa, 0x3d, 0x60, 0x2, 0xc9, 0xab, 0x63, 0xa1, 0x83, 0xa8, 0xa8, 0x5b, 0x3b, 0xdf, 0xcf, 0x4d, 0x81, 0x7f, 0x65, 0x5, 0xc7, 0x74, 0x7a, 0xbe, 0xb7, 0x63, 0xdc, 0x78, 0x24, 0x6b, 0x6f, 0x56, 0xa3, 0xe1, 0x2e, 0x10, 0x1, 0x52, 0xf, 0x5d, 0x35, 0xc8, 0xe3, 0xf2, 0x51, 0x70, 0x2a, 0x66, 0xde, 0x66, 0x3c, 0x9c, 0xb9, 0xc5, 0x3e, 0x5, 0x84, 0x20, 0x7b, 0xef, 0x86, 0xec, 0xd0, 0x46, 0x97, 0x90, 0x44, 0xde, 0xe5, 0x5e, 0x26, 0x39, 0xf4, 0xa, 0x4d, 0x5, 0x20, 0x96, 0x8b, 0xe4, 0x43, 0xc4, 0x6d, 0x71, 0xf9, 0xb6, 0xc7, 0x5a, 0x82, 0xd8, 0xf7, 0xcf, 0x5, 0xa0, 0xd4, 0xa1, 0xa8, 0x97, 0xe6, 0xb5, 0x7c, 0x93, 0x92, 0x2a, 0x5f, 0x82, 0xe4, 0xe7, 0x57, 0x86, 0x12, 0xb3, 0xc6, 0x8b, 0x79, 0x94, 0xd8, 0xef, 0x2f, 0x85, 0xb3, 0x5b, 0xd0, 0xdd, 0xdd, 0x14, 0x9c, 0xcd, 0xd8, 0xc9, 0x8, 0x4f, 0x6f, 0x8f, 0xf6, 0x19, 0x0, 0xfe, 0x8c, 0xbe, 0xae, 0x65, 0x25, 0xdf, 0xb8, 0x20, 0x90, 0x26, 0xf6, 0x38, 0xa, 0xe6, 0x77, 0x26, 0x3b, 0x1d, 0x7c, 0xed, 0x5f, 0x8b, 0x2b, 0xb, 0x31, 0x34, 0x66, 0x96, 0x69, 0x95, 0xa7, 0xaf, 0x76, 0x8a, 0x33, 0x83, 0x21, 0x5a, 0xd8, 0x32, 0x77, 0x7, 0xc8, 0xcb, 0x26, 0x56, 0xdc, 0x1e, 0x91, 0x90, 0x28, 0x6, 0xb6, 0x13, 0xba, 0xcb, 0x93, 0xd0, 0x4b, 0x1c, 0xaa, 0xee, 0x75, 0x9b, 0x97, 0xd7, 0xd1, 0x3c, 0xd0, 0x77, 0xa, 0x20, 0xa3, 0xf2, 0x29, 0x6, 0x8b, 0x28, 0xff, 0x36, 0xc7, 0x4, 0x82, 0x8, 0xa4, 0x69, 0x3d, 0x48, 0x96, 0xa9, 0xf1, 0x21, 0x62, 0xf3, 0xdc, 0xf1, 0x8e, 0x97, 0xdd, 0xb8, 0x49, 0x46, 0xfa, 0xbd, 0x8f, 0xd5, 0x3, 0x9f, 0x6e, 0xf6, 0xdd, 0x9, 0x54, 0xd, 0xf8, 0xd5, 0xa6, 0xb7, 0x92, 0x6c, 0xac, 0xba, 0x50, 0x9f, 0x98, 0x5f, 0xdf, 0x23, 0xa1, 0xf4, 0xee, 0xe5, 0x14, 0x5d, 0x13, 0xd7, 0xd0, 0xe3, 0xe4, 0xbf, 0xdd, 0x18, 0x9, 0xa3, 0x91, 0x8c, 0xac, 0x77, 0x34, 0x60, 0x9f, 0x6c, 0x3f, 0x38, 0xbe, 0xbe, 0xea, 0x3f, 0xfc, 0x3e, 0x4b, 0x4a, 0x8a, 0xca, 0xa1, 0x38, 0x74, 0x40, 0xc9, 0x2d, 0x1c, 0xed, 0x43, 0x51, 0x16, 0x54, 0xe9, 0x5b, 0x33, 0xb5, 0x6f, 0x98, 0x8d, 0xd4, 0x3e, 0xde, 0x14, 0x3a, 0xff, 0xfe, 0x3b, 0x6e, 0x4, 0xf4, 0xb3, 0x8b, 0x59, 0x32, 0x51, 0xe0, 0xfd, 0xda, 0xd3, 0xd2, 0x6b, 0xfc, 0x1b, 0x40, 0xc5, 0xfe, 0x5, 0x73, 0xf0, 0x10, 0x67, 0x1a, 0xc3, 0xe3, 0xe6, 0x21, 0xe, 0x87, 0x99, 0xf2, 0x56, 0xb1, 0x53, 0xe1, 0xd9, 0x50, 0x93, 0xbd, 0x45, 0x2d, 0x70, 0x96, 0x8c, 0xe6, 0x51, 0xc7, 0x71, 0x7b, 0xc9, 0x35, 0xbf, 0x2f, 0xb7, 0x7c, 0x21, 0x2, 0x9b, 0x65, 0x50, 0xf5, 0x35, 0xc3, 0xbd, 0xf8, 0x4, 0xe7, 0xc2, 0xb1, 0xa5, 0x72, 0x8a, 0xe2, 0x31, 0xc0, 0x5, 0xe3, 0x19, 0x13, 0xbe, 0x6a, 0xea, 0x15, 0xbd, 0x90, 0x49, 0x1f, 0x70, 0xcd, 0xd2, 0x22, 0xa5, 0x48, 0xc3, 0xf3, 0x8c, 0x7b, 0x2c, 0xb4, 0x54, 0xb3, 0xb5, 0x50, 0x69, 0x9f, 0x6e, 0xea, 0x35, 0x1a, 0x5b, 0xd6, 0x9b, 0x97, 0xc2, 0xc8, 0x23, 0xac, 0xb2, 0x1f, 0x48, 0xa5, 0x25, 0x33, 0x58, 0x7b, 0x3b, 0x2b, 0x51, 0xef, 0xf4, 0xf4, 0x53, 0xea, 0x66, 0xa1, 0xec, 0x55, 0x9f, 0x11, 0xc3, 0x87, 0xe7, 0xb5, 0xa1, 0x11, 0xc7, 0xd8, 0x85, 0xbf, 0xbb, 0x55, 0x79, 0x59, 0x95, 0x9a, 0xea, 0xfd, 0xac, 0x86, 0x93, 0xb2, 0x2d, 0xea, 0xc, 0xd3, 0x4, 0x54, 0xb2, 0xc4, 0xb1, 0xa0, 0x7a, 0xa6, 0x4e, 0x3d, 0xf3, 0xe4, 0xa3, 0x6f, 0xa4, 0x66, 0x6b, 0x70, 0xe0, 0x74, 0x4f, 0x24, 0x5d, 0xc0, 0x16, 0x1a, 0xe2, 0xcf, 0xc5, 0xcd, 0xf, 0x7a, 0x35, 0xe6, 0x76, 0x51, 0x54, 0x9e, 0x86, 0x40, 0x7c, 0xf8, 0xd2, 0xef, 0x25, 0x9b, 0xf6, 0x5e, 0xe7, 0x5f, 0x20, 0x32, 0xe3, 0xa0, 0xd3, 0xcc, 0x6e, 0xa8, 0xea, 0xf5, 0xfb, 0x16, 0x56, 0x36, 0x71, 0xae, 0x9f, 0x11, 0x85, 0xfd, 0xa5, 0x52, 0x63, 0x90, 0x83, 0x55, 0x8d, 0xde, 0x88, 0x3a, 0xdf, 0x86, 0xcb, 0x31, 0xbb, 0xb8, 0x76, 0x4b, 0xcc, 0x9, 0x6d, 0xf6, 0x2, 0x7, 0xe3, 0x7c, 0xf5, 0xaa, 0x87, 0xe0, 0xd3, 0x56, 0x5d, 0x55, 0x10, 0xff, 0xa, 0xc9, 0x35, 0x9a, 0xf6, 0x54, 0xc, 0x51, 0x3b, 0xd3, 0xac, 0x35, 0xf1, 0x82, 0x9c, 0x5b, 0x34, 0x2e, 0x66, 0xec, 0x78, 0xbe, 0x3, 0x56, 0x73, 0x5e, 0xe, 0xcd, 0x97, 0xd2, 0xf, 0x85, 0x40, 0x94, 0xd1, 0x24, 0xcd, 0x91, 0x8a, 0x3b, 0xfd, 0x4, 0x55, 0x45, 0xb1, 0xa7, 0xe1, 0x7f, 0xe3, 0xe1, 0xe, 0xed, 0x4d, 0x11, 0xf8, 0xaa, 0x1b, 0xe, 0x33, 0x28, 0x5c, 0x78, 0x37, 0xdb, 0x70, 0x33, 0xac, 0xd, 0x71, 0x27, 0x30, 0xc0, 0xbc, 0xe1, 0xc3, 0x85, 0x14, 0xfd, 0x2, 0x98, 0x5f, 0x99, 0xb8, 0x8a, 0x20, 0x5, 0x7c, 0x97, 0x81, 0xff, 0x4, 0x44, 0xc2, 0x90, 0xa7, 0xe0, 0x64, 0x5e, 0x17, 0xd0, 0xbe, 0xb2, 0xcd, 0x3a, 0x45, 0x81, 0x84, 0xf6, 0xb4, 0xb5, 0xe1, 0x0, 0xcb, 0xd, 0x69, 0x27, 0x9a, 0x9a, 0x18, 0x57, 0x36, 0xe7, 0xee, 0xc4, 0x2d, 0x87, 0x40, 0xe6, 0x3d, 0x5b, 0x26, 0x1c, 0xae, 0x6, 0x1b, 0x54, 0x18, 0x3e, 0x4c, 0x21, 0x99, 0x4c, 0xfe, 0x6c, 0xd5, 0xc5, 0x44, 0x1d, 0x6c, 0x3d, 0x23, 0x0, 0x50, 0x9a, 0x40, 0xcc, 0x2e, 0xfe, 0x67, 0xe6, 0x3d, 0xe, 0x19, 0x66, 0xc7, 0x81, 0xbd, 0xf5, 0x46, 0xe9, 0xe9, 0x17, 0xfd, 0x28, 0x3c, 0xff, 0x73, 0x5b, 0x0, 0x17, 0x55, 0xb, 0x5c, 0xfb, 0x8b, 0x5a, 0xb2, 0x2a, 0xda, 0xfc, 0xee, 0x1e, 0x3e, 0xc1, 0x9e, 0x6, 0x16, 0xde, 0xc2, 0xe5, 0xe7, 0xb4, 0x5c, 0x2e, 0x54, 0x7e, 0x48, 0x42, 0x5b, 0xe2, 0x71, 0x23, 0xaa, 0xf9, 0x1b, 0x44, 0x68, 0xb4, 0xb1, 0x38, 0x9a, 0x9, 0x5b, 0x3b, 0xcd, 0xc2, 0xcf, 0xa4, 0x3, 0xb9, 0x42, 0x31, 0x41, 0x1e, 0xd8, 0x35, 0x69, 0x41, 0x90, 0xe5, 0x45, 0x39, 0xf9, 0x12, 0x66, 0x88, 0xf6, 0x23, 0x2e, 0xa1, 0x30, 0x2, 0x25, 0x3e, 0x93, 0x7e, 0x50, 0x8c, 0x0, 0x16, 0x5a, 0x3e, 0xf5, 0x23, 0x62, 0x1f, 0x6, 0xfe, 0xa1, 0x44, 0xb, 0x81, 0xe8, 0x49, 0x9c, 0x20, 0xbd, 0x2d, 0x81, 0x74, 0x22, 0xb4, 0x8f, 0x8e, 0x83, 0x13, 0x1e, 0xa, 0xf7, 0x7, 0x12, 0x6c, 0xca, 0xd0, 0x3a, 0x23, 0x23, 0x7a, 0x4a, 0xd2, 0x3, 0x53, 0xeb, 0xca, 0x6a, 0xf4, 0x9f, 0x7e, 0x85, 0x99, 0xb3, 0x2b, 0x70, 0x8f, 0x9c, 0x3b, 0xaf, 0xea, 0xa, 0x7b, 0xe2, 0x4c, 0x22, 0x7f, 0xb0, 0x86, 0x67, 0x3, 0x67, 0x7e, 0xd8, 0x57, 0x74, 0xf1, 0x6, 0x96, 0x65, 0xcd, 0x8e, 0xf8, 0x8c, 0x96, 0xca, 0xb5, 0xec, 0x3f, 0x5c, 0xeb, 0x4c, 0xea, 0x91, 0x53, 0x61, 0xde, 0xc9, 0x6, 0xa6, 0x75, 0x39, 0xab, 0xe4, 0x12, 0x79, 0x54, 0xfd, 0x53, 0xb2, 0xd7, 0x34, 0xd5, 0x8f, 0x84, 0xe4, 0xc2, 0xe6, 0xe9, 0xc, 0xc1, 0x95, 0x8c, 0x20, 0xb7, 0x8, 0xe, 0x6e, 0x6, 0x70, 0x32, 0x18, 0x6f, 0x2b, 0x38, 0xb8, 0xe, 0xdd, 0x45, 0xfd, 0xf1, 0xc7, 0xf1, 0xe, 0x2c, 0xdc, 0xf, 0xc, 0xcb, 0x73, 0x4e, 0x7c, 0xb2, 0x86, 0xa9, 0x75, 0x94, 0xb6, 0xd9, 0x2, 0x28, 0x91, 0x13, 0x79, 0xff, 0x4c, 0x61, 0x74, 0xb9, 0xaa, 0x1c, 0x8b, 0x29, 0x1c, 0xe0, 0x61, 0xa9, 0x7c, 0x82, 0xad, 0xd4, 0x14, 0xf5, 0x51, 0xa1, 0xee, 0xb9, 0xfc, 0x89, 0xdb, 0xe6, 0x45, 0xcf, 0x82, 0xde, 0xc0, 0x48, 0xd6, 0xbd, 0xe9, 0x48, 0x35, 0xd6, 0xd4, 0x76, 0xf6, 0xe5, 0xe0, 0x8e, 0x47, 0x61, 0x6e, 0xd5, 0x76, 0x6c, 0xb3, 0x69, 0xa9, 0x4d, 0x51, 0xf2, 0xa5, 0xf0, 0x3e, 0x5f, 0xee, 0x94, 0x30, 0x58, 0xc0, 0x9d, 0xad, 0x21, 0xe0, 0x8b, 0x82, 0x2d, 0x7f, 0x51, 0xbe, 0x52, 0x96, 0xdf, 0xc3, 0x98, 0xb1, 0x41, 0x81, 0x7f, 0x56, 0x71, 0xdf, 0x7b, 0x3, 0x2b, 0x5c, 0x4b, 0xee, 0x77, 0x9b, 0x7b, 0x5e, 0xcf, 0xd2, 0x28, 0xfa, 0xd0, 0xa6, 0xf1, 0x2, 0xed, 0x8d, 0x7a, 0x62, 0xf, 0xb0, 0xc6, 0xe8, 0xe8, 0x4a, 0x2, 0x9, 0x48, 0xee, 0xcb, 0x10, 0xfa, 0x27, 0xee, 0xdf, 0x71, 0xff, 0x5e, 0x11, 0xd0, 0xe1, 0xa2, 0xda, 0x41, 0xbe, 0x40, 0x29, 0x47, 0x2c, 0xf6, 0xf2, 0x6d, 0xd3, 0xf6, 0xed, 0x6e, 0x4a, 0x5a, 0x7f, 0xd4, 0x41, 0x20, 0xd, 0xc6, 0x90, 0x30, 0x76, 0x73, 0xff, 0x9b, 0xbe, 0x81, 0xd7, 0x16, 0x49, 0x68, 0xe, 0x3f, 0x62, 0xd6, 0x24, 0x33, 0xce, 0x34, 0x96, 0x26, 0x95, 0x7, 0xaa, 0x4a, 0xf5, 0xb1, 0xe0, 0x2, 0xcb, 0x1, 0xca, 0xd3, 0xae, 0x50, 0x80, 0xb1, 0x52, 0xd5, 0xea, 0xc, 0x91, 0x3, 0x76, 0xbd, 0x6, 0xe4, 0xc6, 0x3f, 0x72, 0xaf, 0x73, 0x17, 0x21, 0xe8, 0xae, 0x38, 0xe9, 0x17, 0x56, 0xd8, 0x16, 0xa4, 0x68, 0x30, 0xa1, 0x1c, 0xcf, 0x5a, 0xde, 0x12, 0x18, 0xa0, 0x30, 0x17, 0x11, 0xd4, 0x88, 0x9a, 0x90, 0xcf, 0x5, 0x27, 0xb8, 0xc2, 0x99, 0x11, 0xcd, 0xab, 0xc8, 0x32, 0x52, 0x8d, 0x93, 0xb9, 0xea, 0x9d, 0x80, 0xad, 0xe8, 0x1b, 0x5a, 0x1b, 0x8b, 0x26, 0x19, 0x95, 0xcc, 0xc4, 0x82, 0x3b, 0x9, 0xe3, 0xb4, 0x23, 0x6c, 0xa9, 0xbf, 0xcf, 0xf, 0x43, 0x3, 0x90, 0x55, 0x4e, 0x4c, 0x3b, 0x3a, 0xe, 0xf0, 0xfb, 0xaf, 0x13, 0x7, 0x78, 0xee, 0x84, 0x42, 0xc, 0xb2, 0x44, 0x90, 0xc5, 0x86, 0x3c, 0xe5, 0xf3, 0xd8, 0x4a, 0x46, 0xfa, 0x4d, 0xad, 0x6, 0xa9, 0x9e, 0xc0, 0xa, 0x17, 0x65, 0x6b, 0x4c, 0x84, 0x97, 0xc5, 0xdd, 0xd4, 0x51, 0x8a, 0xd3, 0xf, 0x92, 0x9a, 0x1f, 0xc4, 0xf2, 0x1d, 0xf7, 0x8f, 0x87, 0xf9, 0x9f, 0xc1, 0xf9, 0xd7, 0x52, 0x8e, 0x63, 0x15, 0x2a, 0x16, 0x68, 0x0, 0x7, 0x76, 0xda, 0x46, 0x58, 0xd3, 0x18, 0x1d, 0x25, 0x99, 0x3, 0x44, 0x3f, 0xb9, 0xaa, 0x32, 0xd5, 0xe0, 0x7d, 0x3f, 0x24, 0x64, 0xbb, 0xf2, 0x41, 0xcb, 0x2f, 0xb6, 0xc, 0xd4, 0xc6, 0xa9, 0x3d, 0xe4, 0xa6, 0xa9, 0x3c, 0x6c, 0xc4, 0x8d, 0xf8, 0x85, 0xa8, 0xa8, 0x17, 0x5e, 0x1a, 0x38, 0x5, 0xad, 0xc5, 0x39, 0xc1, 0xc9, 0x8e, 0x10, 0x91, 0xa6, 0xb5, 0xdf, 0xa3, 0x8e, 0xac, 0xaa, 0xc4, 0xeb, 0xd5, 0xfb, 0xa7, 0x7, 0xda, 0x54, 0x12, 0x5a, 0x3d, 0xa9, 0xbc, 0x1f, 0xd1, 0xbe, 0x1, 0xe9, 0xbe, 0x53, 0x42, 0x6e, 0x74, 0x15, 0x79, 0x6e, 0xc7, 0xc5, 0x67, 0x3b, 0xda, 0x85, 0x3b, 0x9a, 0x9a, 0x42, 0xfb, 0x76, 0x2a, 0x63, 0x94, 0x3d, 0x57, 0xf6, 0x55, 0x47, 0x64, 0xa3, 0x33, 0x1, 0x22, 0xa, 0xf0, 0xff, 0x66, 0x48, 0xf8, 0x70, 0x9c, 0xef, 0x52, 0x44, 0xad, 0xd7, 0x5, 0x44, 0x58, 0x6b, 0x3, 0x37, 0x54, 0xf9, 0xc, 0xe0, 0xd, 0xd9, 0xb3, 0x88, 0x4e, 0x27, 0xc2, 0x5f, 0xd0, 0x32, 0x26, 0x1d, 0x57, 0x32, 0xc, 0xd8, 0xdc, 0x34, 0x35, 0xa2, 0x27, 0x10, 0x56, 0x9b, 0x22, 0xf9, 0x5e, 0xae, 0x3b, 0x98, 0xef, 0x5b, 0xa7, 0x23, 0xc0, 0x4c, 0x49, 0xd5, 0x3a, 0x87, 0x40, 0x60, 0x3f, 0xda, 0x45, 0x51, 0xa5, 0x27, 0x16, 0xaa, 0x8b, 0xca, 0xed, 0x8e, 0x50, 0x5d, 0xf7, 0xab, 0xf6, 0xd8, 0x53, 0x83, 0xb9, 0xac, 0x93, 0xf2, 0x12, 0xb7, 0x11, 0xc, 0xc9, 0xaa, 0x68, 0x2, 0x21, 0xaa, 0x14, 0x87, 0x57, 0xb3, 0x1, 0x85, 0xe2, 0x11, 0x7b, 0xe1, 0xe3, 0x1d, 0x6a, 0x91, 0xcb, 0xd, 0x4c, 0xba, 0xa3, 0x97, 0x70, 0x6b, 0xd1, 0xa9, 0x54, 0x1a, 0x21, 0xd3, 0x8a, 0x42, 0xb9, 0xc8, 0x6e, 0xf1, 0x46, 0x88, 0xd, 0x0, 0xec, 0xfc, 0xb2, 0x93, 0xab, 0x9e, 0x4, 0xd3, 0xb4, 0xbc, 0x12, 0xbe, 0x7d, 0x35, 0xda, 0x30, 0xd8, 0xef, 0x2b, 0xaa, 0xf8, 0x68, 0x4c, 0x7, 0x14, 0x4a, 0x33, 0x22, 0xd3, 0x55, 0xb9, 0x93, 0xf1, 0x96, 0x7b, 0xb6, 0xbf, 0xfa, 0xae, 0x16, 0x36, 0x31, 0xc4, 0xb7, 0xa8, 0x65, 0xac, 0x7c, 0x1b, 0xe3, 0xbe, 0x4b, 0x99, 0x5b, 0x6c, 0x34, 0xf9, 0x6a, 0x5e, 0x4, 0xbc, 0x54, 0xbb, 0x5, 0xb6, 0xca, 0xdc, 0xb6, 0xb8, 0x28, 0x49, 0xee, 0x9f, 0xc0, 0xb4, 0xa7, 0x19, 0x72, 0xbb, 0xc3, 0x6a, 0x0, 0x83, 0x2b, 0x52, 0xb4, 0x6e, 0xcd, 0x27, 0x11, 0x7c, 0x60, 0xab, 0xb0, 0x7, 0x5e, 0x43, 0x8b, 0xd5, 0x86, 0x11, 0xef, 0x61, 0xb4, 0xe5, 0xfb, 0x16, 0xd5, 0x8e, 0x2c, 0x34, 0x81, 0xad, 0x2c, 0xd1, 0x0, 0x2, 0xa7, 0x92, 0x9d, 0x67, 0x64, 0xa1, 0x16, 0x99, 0xcd, 0x1e, 0xaf, 0xda, 0x71, 0x8a, 0x15, 0x24, 0xc6, 0xbf, 0x18, 0xd9, 0xfb, 0x14, 0x1f, 0xc9, 0xcb, 0xe2, 0x24, 0x35, 0x1c, 0x6b, 0x69, 0x33, 0x16, 0xaa, 0x81, 0xfe, 0xe4, 0x36, 0xa3, 0x7, 0x98, 0xb8, 0x17, 0xc7, 0xb0, 0x17, 0x87, 0xfb, 0x85, 0x10, 0x3e, 0x73, 0xe, 0x62, 0x34, 0x1a, 0xc2, 0xe8, 0x3, 0xea, 0x54, 0x50, 0x6e, 0xe3, 0x6e, 0x13, 0xc8, 0xde, 0x28, 0x2, 0xa8, 0x4e, 0x9f, 0x55, 0x62, 0xe8, 0xb1, 0x4e, 0xf5, 0x54, 0x96, 0x81, 0x1e, 0x2c, 0x17, 0x32, 0xca, 0xae, 0xb3, 0x9b, 0x3, 0xd, 0x75, 0x21, 0x76, 0xf4, 0xb, 0x95, 0xcd, 0x5d, 0x55, 0x4, 0xb0, 0x55, 0xe1, 0xa9, 0x6e, 0x8c, 0xd1, 0x90, 0xd9, 0x56, 0x81, 0x43, 0x44, 0x82, 0x3f, 0x3b, 0xd5, 0x7b, 0x52, 0x86, 0x6, 0x7c, 0xb2, 0x9a, 0x10, 0xed, 0x94, 0x28, 0x8e, 0xe8, 0xbc, 0x16, 0x58, 0x20, 0x15, 0x71, 0xc1, 0x5d, 0x79, 0x17, 0x1a, 0x3f, 0xee, 0xa4, 0x8d, 0xf6, 0xd1, 0x75, 0x3f, 0x99, 0x57, 0xdf, 0x79, 0xd7, 0x67, 0x1e, 0x16, 0x97, 0xf1, 0x7b, 0xe0, 0x8c, 0xc0, 0x21, 0x33, 0xc9, 0x6f, 0x72, 0x5a, 0x2f, 0x67, 0xd6, 0xea, 0xe2, 0x6d, 0xc6, 0x7f, 0xf8, 0x33, 0x24, 0xc4, 0xad, 0xb4, 0xe1, 0x1b, 0x73, 0x25, 0x13, 0xc7, 0xc4, 0x6f, 0x81, 0x42, 0xec, 0xe3, 0x15, 0x68, 0xc2, 0x61, 0x76, 0x32, 0x6f, 0xa4, 0xdf, 0x3, 0x76, 0xb0, 0x15, 0x62, 0xc, 0x5a, 0xdf, 0x3c, 0x5e, 0xad, 0x45, 0xe5, 0x47, 0xed, 0xe9, 0x3e, 0x63, 0xf7, 0x21, 0x87, 0xde, 0x80, 0x66, 0x81, 0xd6, 0xf6, 0x9c, 0xfe, 0x7e, 0x3, 0xcf, 0xa4, 0xcc, 0x9b, 0x39, 0xf6, 0xf1, 0xb6, 0xa3, 0xa3, 0xaf, 0x90, 0xf5, 0x5, 0xa, 0x8a, 0x83, 0x6b, 0x59, 0x7d, 0xa1, 0xa0, 0x54, 0x4c, 0x2f, 0xe8, 0xf1, 0xea, 0x7f, 0xfb, 0x27, 0x78, 0x4d, 0x8b, 0xb8, 0xd8, 0x3, 0x0, 0x72, 0x94, 0x7b, 0xeb, 0x28, 0x3a, 0xf7, 0x8, 0xfe, 0xbc, 0xc0, 0xe, 0x1b, 0x37, 0x8, 0xb6, 0x4a, 0x20, 0x19, 0xd0, 0x16, 0x73, 0xa2, 0xb5, 0x7d, 0x12, 0x5c, 0xb2, 0x44, 0xe0, 0x37, 0x8f, 0xa8, 0xfd, 0x9c, 0x36, 0xe5, 0x8e, 0x53, 0x80, 0xbf, 0x1b, 0x8e, 0x29, 0x86, 0xb2, 0x3, 0xf0, 0x90, 0x78, 0xc, 0x8d, 0x2e, 0xfa, 0xbe, 0xc, 0x82, 0x4, 0xa6, 0xa8, 0x6b, 0xc2, 0x28, 0x17, 0x9b, 0x16, 0x5a, 0x6b, 0x52, 0x43, 0xc1, 0xa0, 0x24, 0xa9, 0xa4, 0xfc, 0x2b, 0x60, 0xce, 0x15, 0xb, 0xa1, 0x12, 0xb, 0xe3, 0x33, 0xb8, 0xc7, 0x53, 0xa6, 0x19, 0x3d, 0x3d, 0xd2, 0x4f, 0xb4, 0x10, 0xb, 0x29, 0xf9, 0xf5, 0xe0, 0xcd, 0x41, 0xd7, 0xa1, 0x5d, 0x5f, 0xd4, 0xc6, 0xfc, 0xb1, 0x1e, 0xb9, 0x3, 0xc5, 0x7a, 0x10, 0xd2, 0x64, 0xe0, 0xfa, 0xe6, 0x32, 0x52, 0x6d, 0xc, 0xeb, 0xb4, 0x32, 0x36, 0xcf, 0xa2, 0x60, 0x5f, 0x80, 0x28, 0xa4, 0xd5, 0x4, 0xa0, 0x65, 0x3, 0x58, 0xf5, 0xf5, 0xbc, 0x9, 0xfd, 0xd7, 0xbd, 0x31, 0x91, 0x9c, 0x2a, 0xd1, 0xca, 0xde, 0x90, 0xcd, 0xfc, 0x5d, 0x91, 0x16, 0x91, 0xeb, 0x16, 0xd9, 0x5c, 0x6f, 0xa0, 0x44, 0x1f, 0x2, 0x94, 0x59, 0x2a, 0x75, 0x65, 0x20, 0x3c, 0x65, 0x1c, 0x30, 0x57, 0xd9, 0x85, 0x7c, 0xd1, 0x70, 0x96, 0x62, 0x8, 0x1d, 0x8c, 0xb, 0x9d, 0x60, 0x62, 0x5f, 0x66, 0xd5, 0x1c, 0xcf, 0x94, 0x60, 0x3e, 0xaa, 0x32, 0xd1, 0x18, 0x3d, 0x12, 0x86, 0xb2, 0x48, 0x3d, 0x25, 0x1d, 0x4b, 0x4b, 0x16, 0xde, 0x16, 0x47, 0xe4, 0xba, 0xfb, 0x56, 0xe, 0x60, 0xf7, 0xc7, 0xf1, 0xb2, 0x89, 0x7b, 0x45, 0x1, 0x62, 0xd3, 0xfd, 0x2b, 0x49, 0x1b, 0x38, 0xe1, 0xf4, 0x2e, 0xad, 0x2b, 0xa9, 0x2a, 0xc5, 0xa0, 0xbb, 0x51, 0x7c, 0xba, 0x10, 0x80, 0xec, 0xfc, 0xe7, 0x26, 0x10, 0x45, 0x15, 0x25, 0x70, 0xc9, 0x8f, 0x43, 0x49, 0x49, 0x60, 0x77, 0x2d, 0xd8, 0xf2, 0x60, 0x1c, 0x19, 0xd2, 0x2c, 0xcb, 0x58, 0x6a, 0x6c, 0x72, 0x68, 0xaf, 0x93, 0x45, 0x97, 0xa5, 0x5c, 0x79, 0xb3, 0xf, 0xcd, 0x44, 0xf9, 0x85, 0x9c, 0xcc, 0xf4, 0xf0, 0x4a, 0x8d, 0x93, 0x41, 0xa2, 0xf, 0x9c, 0x24, 0xb, 0xfa, 0x32, 0x36, 0xa1, 0x15, 0xde, 0xd0, 0x21, 0x93, 0x6b, 0xfa, 0x3e, 0xc9, 0x1, 0x94, 0xdd, 0x61, 0x7f, 0xb2, 0xd7, 0x3e, 0xe3, 0xc, 0xc3, 0x9e, 0x7d, 0x8d, 0xb9, 0x4e, 0xda, 0xc8, 0x5d, 0xd2, 0x47, 0x9b, 0x3b, 0x1d, 0xfa, 0xaa, 0xd2, 0xac, 0x1c, 0x77, 0xdb, 0x58, 0x55, 0x86, 0xda, 0x14, 0x2d, 0x52, 0xb0, 0xbb, 0x48, 0x54, 0xf, 0x46, 0x48, 0x28, 0x1e, 0xd4, 0xc2, 0xfd, 0xd2, 0xd0, 0xd, 0xdf, 0x7a, 0x38, 0x9, 0x6b, 0xc6, 0xc6, 0x84, 0x20, 0x38, 0xc5, 0xa6, 0xbf, 0xb9, 0x4e, 0xdd, 0x67, 0x6a, 0x69, 0xa, 0xbe, 0x8a, 0x82, 0xd3, 0x6c, 0x53, 0xa, 0xde, 0x4, 0xdd, 0x73, 0xf9, 0x12, 0x18, 0x88, 0x8d, 0x67, 0x8c, 0x80, 0xbc, 0xbc, 0x53, 0xc, 0x88, 0x6f, 0x9, 0xd6, 0x1a, 0xdd, 0x74, 0x74, 0xbe, 0x81, 0x53, 0xbd, 0x95, 0xa2, 0x5f, 0x18, 0xf8, 0xb0, 0xc7, 0x8, 0x4d, 0xde, 0xb3, 0xb3, 0x2a, 0x29, 0x5d, 0xdc, 0xa5, 0x60, 0x68, 0xfa, 0x5a, 0x48, 0x8c, 0x1a, 0x69, 0x49, 0xf2, 0x48, 0x3, 0x34, 0xa5, 0x45, 0x61, 0xd8, 0x1b, 0xad, 0x1e, 0x63, 0xb9, 0x24, 0x85, 0xa0, 0x57, 0x86, 0xcd, 0xae, 0xcd, 0x5f, 0x57, 0x31, 0xfa, 0x72, 0xa6, 0x9b, 0x69, 0xe4, 0x70, 0x61, 0x80, 0xd0, 0x12, 0x99, 0xad, 0x26, 0xa7, 0xa0, 0x73, 0x59, 0xf9, 0xb5, 0xad, 0xdc, 0xaf, 0xcc, 0x56, 0xc7, 0x3f, 0xb, 0x3e, 0x3a, 0x53, 0xea, 0x8e, 0xf3, 0x57, 0x57, 0xb3, 0x9b, 0x46, 0xaa, 0xc1, 0x21, 0x37, 0x2f, 0x50, 0xaa, 0xb7, 0xee, 0x71, 0xda, 0x1d, 0xb3, 0x29, 0xe0, 0xd, 0x59, 0x77, 0xc2, 0x44, 0x25, 0x5d, 0x43, 0xba, 0x52, 0x32, 0x70, 0x1d, 0x79, 0x25, 0x34, 0xf4, 0x41, 0xe2, 0xfc, 0x6c, 0x52, 0x2a, 0xcf, 0xf4, 0x5e, 0xe1, 0x85, 0x77, 0xcf, 0x94, 0x8d, 0x78, 0x4, 0x88, 0xf5, 0xac, 0x4c, 0x59, 0x3d, 0x14, 0xd9, 0x43, 0x8a, 0xb1, 0xf, 0x4, 0xd3, 0x4b, 0x6c, 0xd1, 0x18, 0x62, 0x4c, 0x93, 0x1e, 0x85, 0x62, 0x3b, 0x4a, 0x7f, 0x8, 0xf8, 0x44, 0x8, 0x68, 0x82, 0xed, 0xf0, 0xad, 0x22, 0xfb, 0x15, 0x94, 0x51, 0x1a, 0xb2, 0x1c, 0x79, 0xf4, 0x76, 0xe4, 0x8b, 0xdd, 0x43, 0x21, 0x28, 0x51, 0x92, 0x1e, 0x55, 0xcf, 0x6c, 0x83, 0xff, 0x3e, 0x8f, 0xb3, 0x8d, 0x17, 0x18, 0x2e, 0xea, 0x92, 0x3, 0xa8, 0xd0, 0x1f, 0xdb, 0xe8, 0xdc, 0x76, 0xfa, 0x8b, 0x88, 0xf2, 0x90, 0xa2, 0x5e, 0xc, 0x46, 0xea, 0xc2, 0x8e, 0xce, 0xa4, 0x4c, 0xf4, 0x36, 0xb3, 0x4a, 0xf6, 0x68, 0x29, 0x8a, 0x4b, 0x29, 0x11, 0xfa, 0xb6, 0xff, 0x58, 0x5f, 0x17, 0x5e, 0x82, 0x66, 0xf9, 0xe8, 0x70, 0x91, 0x77, 0x30, 0x5a, 0x81, 0x10, 0x1c, 0xfc, 0x52, 0xb3, 0x51, 0x7c, 0xbe, 0xf6, 0xec, 0x44, 0xb1, 0xa2, 0x7d, 0x32, 0x36, 0x14, 0x63, 0x86, 0x4e, 0x4d, 0x15, 0x73, 0x9d, 0x85, 0xba, 0xde, 0xba, 0xf7, 0xc2, 0xf5, 0x8f, 0xaf, 0xa8, 0xea, 0x6a, 0x6d, 0x37, 0x37, 0x9a, 0x30, 0xca, 0x64, 0xe4, 0x41, 0x39, 0xc6, 0x85, 0x12, 0xd2, 0x71, 0x3a, 0xa7, 0x0, 0xc6, 0xff, 0x25, 0x35, 0xb8, 0xed, 0xb7, 0x95, 0xf6, 0xe3, 0xc4, 0x68, 0x29, 0xed, 0xd1, 0xcd, 0x34, 0x2f, 0xdb, 0xd, 0xdd, 0xf2, 0x30, 0x2a, 0x1c, 0xa5, 0x93, 0xb4, 0xaa, 0x39, 0x56, 0x57, 0x3d, 0x10, 0xbf, 0x2a, 0x92, 0xb, 0x5, 0x77, 0x7a, 0xbe, 0x2e, 0x72, 0xa3, 0x13, 0xc2, 0x6a, 0x4e, 0xa3, 0x85, 0x23, 0x7e, 0xf, 0xb, 0x3f, 0xc6, 0x3, 0x9c, 0x4a, 0xe5, 0xdb, 0xb0, 0x55, 0xa4, 0x94, 0x5c, 0xe7, 0x4c, 0xc9, 0x6, 0x27, 0xa5, 0x83, 0x2c, 0x82, 0xd7, 0x66, 0x7c, 0xbc, 0xff, 0xd, 0x3c, 0xb6, 0x42, 0x5d, 0x2e, 0x1b, 0xa4, 0x79, 0xd9, 0x28, 0x57, 0x6b, 0xd4, 0x60, 0x56, 0xe8, 0xaf, 0xc, 0x3b, 0xa, 0xec, 0xa0, 0xa9, 0x44, 0x85, 0x8c, 0x97, 0xc0, 0xe6, 0x48, 0x22, 0xfd, 0x3e, 0x91, 0xc2, 0xb7, 0x63, 0xf8, 0x88, 0xef, 0x4a, 0x65, 0x9b, 0xbb, 0xae, 0x14, 0x9f, 0xc4, 0xbd, 0xac, 0x76, 0xab, 0x6a, 0x50, 0x7f, 0xf2, 0xd5, 0xc6, 0x4, 0x71, 0x9b, 0x8, 0xcf, 0xf8, 0x4c, 0x87, 0x13, 0x56, 0xf3, 0x44, 0x29, 0x4f, 0xda, 0xdf, 0xbd, 0x56, 0xb, 0xba, 0xd, 0x1e, 0xef, 0xb6, 0x44, 0x2f, 0xc8, 0x8f, 0xf1, 0xca, 0x10, 0x11, 0x20, 0x31, 0xd3, 0x4, 0x6d, 0x6e, 0x83, 0xd0, 0x2c, 0xf9, 0xe8, 0xf3, 0x1c, 0x59, 0x18, 0xed, 0x87, 0x98, 0x7d, 0xd1, 0xba, 0x2a, 0xb8, 0x73, 0x11, 0x26, 0xee, 0x50, 0x6b, 0x3, 0xf8, 0x5d, 0x6f, 0x9f, 0xfa, 0xe3, 0x44, 0x79, 0xc6, 0xa7, 0xd2, 0xd0, 0xfa, 0xca, 0xb8, 0xdc, 0xdb, 0xaf, 0xa9, 0xb2, 0xf0, 0x2e, 0x21, 0xc6, 0x66, 0xd7, 0x8f, 0xa0, 0x34, 0x89, 0x3f, 0x2d, 0x10, 0x26, 0x60, 0x89, 0x84, 0xd6, 0x8f, 0x93, 0x33, 0x39, 0x5e, 0xb, 0xf1, 0x95, 0xbc, 0xaf, 0x7f, 0x15, 0xcb, 0x12, 0x24, 0x19, 0xe1, 0xf2, 0xbf, 0x3b, 0x3e, 0x1e, 0x83, 0x1a, 0x61, 0xe2, 0x73, 0x36, 0xe2, 0x5e, 0xb6, 0x48, 0x4, 0x3, 0xc9, 0x9, 0x80, 0xbc, 0x59, 0x7e, 0x87, 0xb5, 0x2c, 0xf5, 0xd0, 0xff, 0x77, 0x70, 0x35, 0x5e, 0xd5, 0x2, 0x81, 0xd, 0x26, 0x5f, 0x32, 0x65, 0x24, 0x1b, 0x75, 0xfe, 0x2c, 0xf3, 0x7f, 0xe0, 0xd5, 0xac, 0xc2, 0xfd, 0x37, 0x58, 0xa0, 0x41, 0x4c, 0x47, 0x98, 0xbb, 0xa7, 0x78, 0xe2, 0x45, 0x2d, 0xbe, 0x86, 0xbf, 0x9e, 0x2c, 0x7a, 0x3a, 0x55, 0x63, 0x1, 0x9f, 0x60, 0xdd, 0xd5, 0x34, 0x4f, 0x29, 0xcc, 0xeb, 0xdb, 0x9d, 0xef, 0xbb, 0x60, 0xc6, 0xc0, 0xf5, 0x3, 0x43, 0x2d, 0x76, 0xee, 0xb4, 0x7f, 0xe3, 0x6d, 0x63, 0x7a, 0x67, 0x35, 0x96, 0xdb, 0xca, 0x4e, 0x55, 0xa8, 0x80, 0xfb, 0x28, 0xf4, 0xcb, 0x81, 0x93, 0xc7, 0xa4, 0x8, 0x44, 0x30, 0x9b, 0x55, 0xe4, 0xc0, 0x10, 0xfa, 0xed, 0x3f, 0xae, 0x5, 0xd8, 0x56, 0x48, 0xa3, 0x39, 0xb4, 0x7d, 0x5a, 0xe3, 0xcd, 0x14, 0x27, 0x59, 0xf6, 0xd0, 0x9, 0x2, 0x97, 0x19, 0xf9, 0xaf, 0x5f, 0x81, 0xc8, 0x8e, 0xca, 0x88, 0xed, 0xd4, 0x37, 0x2c, 0x7a, 0x82, 0x7e, 0xce, 0x87, 0x6, 0xf, 0x25, 0x76, 0xea, 0x82, 0x38, 0x9a, 0x5f, 0x3f, 0x3e, 0xe5, 0x1f, 0x50, 0x37, 0x9, 0xb4, 0x6a, 0x6d, 0x3b, 0x7f, 0x2a, 0x97, 0xfe, 0xdc, 0x9b, 0xae, 0x4f, 0x15, 0x6a, 0xa, 0xbd, 0xd7, 0x74, 0x44, 0xdd, 0x59, 0x81, 0xa9, 0x88, 0x2e, 0x55, 0x34, 0xca, 0x71, 0xe3, 0x15, 0xfe, 0xae, 0xca, 0x7d, 0x5d, 0x6, 0xa9, 0xf7, 0x4b, 0x6f, 0x8, 0x9c, 0x36, 0x7, 0xa1, 0x7e, 0xac, 0x3a, 0x20, 0x5, 0x57, 0x66, 0x68, 0x17, 0xdb, 0x7e, 0xfd, 0x52, 0x4b, 0xf3, 0x7c, 0x58, 0xff, 0xbf, 0xb0, 0xfe, 0xae, 0x9d, 0x0, 0xf7, 0x8d, 0x6e, 0xb7, 0x24, 0xc, 0x87, 0xdf, 0x54, 0xd1, 0x77, 0x4f, 0x87, 0xbe, 0x2d, 0xcb, 0x26, 0xc9, 0xf0, 0xac, 0x70, 0xb8, 0x5c, 0x48, 0x2c, 0x67, 0x20, 0x51, 0xea, 0x0, 0x20, 0xc2, 0x42, 0x65, 0xcd, 0x97, 0xf2, 0x65, 0xea, 0x3e, 0x2d, 0xb3, 0xc9, 0x3f, 0xe1, 0x4d, 0xb8, 0x32, 0xd2, 0xf, 0x5b, 0xca, 0x7f, 0xe, 0x57, 0xa3, 0xb7, 0xe4, 0x38, 0xaf, 0xbd, 0xf3, 0x49, 0x21, 0x5a, 0x8d, 0x83, 0xb6, 0xdd, 0x80, 0xbf, 0x29, 0x97, 0x40, 0x3d, 0xe3, 0x50, 0xbc, 0xfa, 0x83, 0x2e, 0x2f, 0x39, 0x3b, 0x43, 0x4e, 0xe5, 0x15, 0xb4, 0x6e, 0x41, 0x25, 0x3, 0x9e, 0xa, 0xb0, 0x5b, 0x79, 0x14, 0xdd, 0xae, 0xdb, 0x87, 0xc2, 0xc0, 0xa5, 0xbc, 0x32, 0xb2, 0xde, 0x45, 0x68, 0xfd, 0xff, 0x23, 0x8c, 0x9c, 0x39, 0x40, 0x8c, 0x60, 0x4e, 0xad, 0x6f, 0x4c, 0x5a, 0x24, 0xa7, 0xc3, 0x6d, 0x96, 0xcb, 0xd8, 0x97, 0xcc, 0x38, 0xbf, 0x60, 0xd, 0x51, 0xce, 0x9, 0x3b, 0x71, 0xc6, 0x3a, 0x1c, 0x8c, 0x36, 0xf4, 0x57, 0x30, 0xd1, 0x8e, 0xbd, 0x95, 0x1a, 0x6a, 0xb7, 0x4b, 0x1, 0x4d, 0x91, 0x5e, 0xb2, 0xa9, 0x51, 0x45, 0x8c, 0xbe, 0xec, 0xb4, 0x51, 0x22, 0x40, 0x34, 0x2a, 0x83, 0xc5, 0x83, 0x79, 0xb5, 0xc9, 0x86, 0x64, 0x20, 0x2f, 0x78, 0x34, 0x53, 0xb8, 0xc8, 0xca, 0xb8, 0x93, 0x2, 0x88, 0x31, 0x95},
+               output224: []byte{0x85, 0x81, 0xaa, 0xd3, 0x9, 0xe2, 0x38, 0xd2, 0xdc, 0xd2, 0x83, 0xb9, 0x65, 0x49, 0x7b, 0x86, 0x74, 0xcc, 0x8f, 0x1b, 0x99, 0x9, 0x6f, 0x82, 0xd7, 0x80, 0x1, 0xf0},
+               output256: []byte{0x31, 0x20, 0x83, 0xd9, 0x69, 0x68, 0x97, 0x40, 0xc2, 0x3c, 0xc2, 0x87, 0x7, 0x7b, 0x60, 0xad, 0x35, 0x31, 0x6a, 0x14, 0xf2, 0xeb, 0x1, 0x5f, 0xa0, 0xa1, 0x12, 0x5c, 0xb6, 0x34, 0x7f, 0x76},
+               output384: []byte{0x55, 0x27, 0x4f, 0x25, 0x79, 0xa, 0xdf, 0x33, 0x32, 0x2a, 0xe0, 0x8f, 0xa3, 0x3b, 0x3e, 0x48, 0xb4, 0x93, 0x99, 0x1d, 0x11, 0x64, 0xcb, 0x7d, 0x11, 0xb7, 0x4f, 0x4c, 0x76, 0xec, 0x32, 0x72, 0x6, 0xec, 0x11, 0xee, 0x2f, 0x2b, 0x7b, 0x3b, 0x4, 0xee, 0x58, 0x1a, 0xa8, 0x35, 0xd5, 0x3f},
+               output512: []byte{0x85, 0x47, 0x66, 0x87, 0x16, 0x77, 0xe0, 0xf, 0xc9, 0x80, 0x37, 0x82, 0x32, 0x9b, 0xf0, 0x8b, 0x93, 0x5f, 0xe6, 0x2, 0x6, 0xe1, 0xf5, 0xd0, 0x26, 0x52, 0x88, 0x1e, 0xd4, 0x7e, 0xb3, 0xed, 0x6b, 0x92, 0xdf, 0x1f, 0x18, 0x93, 0xaa, 0x17, 0x39, 0xe6, 0xb7, 0x4c, 0x49, 0xd, 0x56, 0xb0, 0x81, 0x8e, 0x41, 0xb1, 0xd7, 0x6b, 0xaa, 0x19, 0x64, 0x71, 0x54, 0x3a, 0x13, 0xc2, 0x25, 0x95}},
+       testcase{
+               msg:       []byte{0x63, 0xd0, 0x16, 0xd6, 0x4a, 0x4, 0x18, 0x3e, 0xa6, 0xab, 0xfd, 0x3d, 0x35, 0x37, 0x90, 0xe2, 0x2b, 0x4, 0xca, 0x89, 0xd7, 0xcd, 0xe3, 0xf2, 0xc6, 0xe, 0x8d, 0x36, 0xc7, 0x14, 0x3a, 0xfa, 0xe9, 0x6d, 0xe6, 0x71, 0xc2, 0xcd, 0x91, 0x5a, 0x7d, 0x8f, 0x41, 0xc9, 0xf8, 0xb, 0xf3, 0xc4, 0x7a, 0xa3, 0x74, 0x87, 0xcb, 0x9c, 0x93, 0x8c, 0xd5, 0xaf, 0x8a, 0xee, 0xb4, 0xa3, 0xc6, 0x29, 0x4d, 0x2e, 0x12, 0xca, 0xf1, 0xf2, 0xc7, 0xab, 0x70, 0xdd, 0x14, 0x40, 0x74, 0xfe, 0x8, 0x3c, 0xf8, 0x2d, 0x37, 0xcb, 0x38, 0x4, 0x28, 0x62, 0xda, 0x9f, 0xde, 0x75, 0xc0, 0x12, 0x1f, 0xb7, 0xc0, 0x4f, 0x7a, 0x9f, 0x71, 0x14, 0xf8, 0x9a, 0x7e, 0xe3, 0x48, 0x69, 0xc1, 0xbb, 0x3f, 0x78, 0xbb, 0x58, 0xfc, 0x64, 0x6c, 0x8b, 0x16, 0xca, 0x22, 0x88, 0xa2, 0x5a, 0x5, 0xe, 0x34, 0xb8, 0xf6, 0x31, 0x5a, 0xf6, 0x84, 0xac, 0xf3, 0x62, 0x9a, 0xb2, 0x4e, 0xe6, 0xde, 0xd7, 0x35, 0x71, 0xc1, 0x83, 0x7f, 0xe9, 0x9, 0xef, 0xd3, 0xde, 0x34, 0x98, 0x51, 0x58, 0x57, 0x9f, 0x4, 0x92, 0x50, 0xb1, 0x87, 0x40, 0x21, 0x35, 0x4f, 0xb1, 0x71, 0x50, 0x47, 0xd9, 0x15, 0x8a, 0x31, 0xe9, 0x6, 0x73, 0x8f, 0xb3, 0x2d, 0x3b, 0xa0, 0x1f, 0x55, 0x9b, 0x19, 0xee, 0xf2, 0x48, 0x78, 0x1e, 0x23, 0xdc, 0x47, 0xfe, 0x2a, 0x3b, 0x12, 0xf1, 0xfc, 0x70, 0xd0, 0xae, 0x92, 0x2f, 0x60, 0x78, 0xf8, 0xbd, 0x1a, 0x9c, 0xe1, 0x3e, 0x3c, 0x18, 0xdf, 0x4c, 0x51, 0x21, 0xc1, 0x32, 0xf0, 0xdd, 0xed, 0xc5, 0x96, 0x14, 0x29, 0xad, 0xf7, 0xb3, 0x2d, 0x62, 0x5, 0x8b, 0x4e, 0x7b, 0x7a, 0xab, 0xe5, 0xc5, 0xd0, 0x50, 0xa8, 0xea, 0x33, 0xd3, 0xb5, 0xb6, 0xe9, 0xd, 0x22, 0x4, 0x4e, 0x58, 0xba, 0xab, 0xce, 0xb2, 0x23, 0x53, 0x9a, 0x33, 0x9d, 0xe9, 0x91, 0x7d, 0x7f, 0x5b, 0x3d, 0x72, 0xb9, 0x10, 0xc1, 0xc8, 0x3, 0x6c, 0x24, 0xc, 0xb1, 0xa5, 0x8b, 0x7b, 0xca, 0xd, 0x77, 0xad, 0x82, 0xe, 0xd1, 0xfb, 0x2f, 0xe, 0xcf, 0x85, 0xa5, 0xd0, 0xc0, 0xf0, 0x79, 0x76, 0xea, 0x27, 0x87, 0x1e, 0xc7, 0xd1, 0xfe, 0x9e, 0xa5, 0x1a, 0xb1, 0xf2, 0x0, 0x52, 0x30, 0x7b, 0x3f, 0x9, 0x95, 0xc, 0x6d, 0x1e, 0x38, 0x22, 0x44, 0xe, 0x7a, 0xbc, 0xc3, 0x4d, 0xba, 0x27, 0x83, 0x79, 0x11, 0x5c, 0xa0, 0x69, 0x1, 0x12, 0xef, 0xe4, 0xb9, 0x56, 0x99, 0xe6, 0xe1, 0x35, 0xca, 0x8d, 0xeb, 0xb1, 0x73, 0xcf, 0x7a, 0x3a, 0xd5, 0x51, 0xdc, 0x41, 0xe5, 0x2e, 0x23, 0x7c, 0x8, 0x4c, 0x31, 0x8d, 0xe2, 0x90, 0xbe, 0x7a, 0xef, 0xeb, 0xf1, 0x2a, 0xde, 0xb0, 0x24, 0x3a, 0xe5, 0x76, 0x39, 0x2c, 0x76, 0x7f, 0x8, 0x71, 0x80, 0xa1, 0x25, 0xbb, 0x30, 0xd8, 0xd5, 0x6b, 0xfa, 0xf7, 0x3, 0xa8, 0x5c, 0x93, 0x59, 0x18, 0x28, 0x94, 0xf5, 0xd, 0xaa, 0x69, 0x42, 0x55, 0xd0, 0x1a, 0xcb, 0x1d, 0x43, 0x6b, 0x27, 0xa, 0x7b, 0xd, 0x88, 0x77, 0x26, 0x59, 0xe7, 0x49, 0x10, 0x27, 0x7c, 0x2e, 0x2e, 0x9a, 0xb0, 0xe9, 0xd3, 0xc7, 0x22, 0x3, 0xe5, 0x97, 0x70, 0x90, 0x47, 0x89, 0xc1, 0x2a, 0x38, 0xd0, 0x46, 0x50, 0x90, 0xac, 0x62, 0x85, 0xca, 0x8b, 0x57, 0x75, 0x5, 0xa2, 0x5c, 0xc8, 0x7c, 0xab, 0xa9, 0x9b, 0x43, 0x16, 0x6b, 0x52, 0x1b, 0xc2, 0xbb, 0x68, 0x57, 0xb0, 0xfe, 0x26, 0xd9, 0x9f, 0xbd, 0xba, 0xa3, 0x48, 0x49, 0xb2, 0x7, 0x5b, 0x67, 0x2d, 0x1f, 0xb6, 0x22, 0x92, 0x54, 0xbd, 0x71, 0x8, 0xb1, 0x99, 0x97, 0x1e, 0x85, 0x93, 0xe1, 0xc8, 0xe8, 0x3c, 0x2a, 0x63, 0x17, 0x98, 0xdb, 0x5e, 0x84, 0x9, 0x8a, 0x67, 0xf2, 0x16, 0x4f, 0x16, 0x78, 0x4, 0x81, 0x11, 0xc, 0xe6, 0xa9, 0xeb, 0x4c, 0x1b, 0xbc, 0x12, 0xe6, 0x81, 0xe5, 0xd2, 0x48, 0xb1, 0xe8, 0xe2, 0xfa, 0xaa, 0x8, 0x1b, 0x37, 0x62, 0xf6, 0x4d, 0xad, 0x22, 0xc9, 0xe1, 0xc2, 0xab, 0x45, 0xea, 0x3a, 0xba, 0xf5, 0x47, 0xce, 0x40, 0x5a, 0xd5, 0x67, 0x94, 0xf8, 0x9e, 0x20, 0x86, 0x80, 0x72, 0x79, 0x82, 0x87, 0x82, 0xd4, 0xba, 0x5e, 0x82, 0xd, 0x5d, 0x77, 0xd0, 0x20, 0xb0, 0x65, 0x36, 0xa2, 0x58, 0x4d, 0x78, 0xd3, 0x92, 0xb4, 0xec, 0xe4, 0x56, 0x60, 0x6a, 0x6b, 0x7a, 0xa9, 0xc8, 0xb, 0x8d, 0x5a, 0xb0, 0x75, 0x8a, 0x36, 0xe7, 0x7f, 0x97, 0xda, 0xa2, 0x4c, 0x8, 0xf, 0xa4, 0x24, 0x9f, 0x12, 0x7b, 0x16, 0xcd, 0xf5, 0xbb, 0xf0, 0xf6, 0x9b, 0x4d, 0xd4, 0x25, 0xd2, 0xc4, 0x22, 0xc0, 0x11, 0x7e, 0x90, 0x85, 0x35, 0x62, 0x35, 0xf4, 0x9d, 0x7b, 0xd2, 0x77, 0x3f, 0xed, 0x4e, 0x17, 0x71, 0x29, 0x35, 0xbc, 0x44, 0x68, 0xa9, 0xad, 0xaa, 0x30, 0xe9, 0xcc, 0xb9, 0xb1, 0x60, 0x22, 0x30, 0x64, 0xa2, 0xee, 0x4e, 0x17, 0xe8, 0x85, 0xeb, 0x3e, 0xab, 0x5b, 0x72, 0xcf, 0x7b, 0x37, 0x15, 0xe5, 0x18, 0xaa, 0x1b, 0xcf, 0xdf, 0x6c, 0xc3, 0xeb, 0x73, 0x4f, 0xc7, 0x5e, 0x6a, 0xd7, 0x93, 0xa4, 0x39, 0xb1, 0x22, 0x1f, 0x89, 0x5f, 0x67, 0xe6, 0xa9, 0x24, 0xdc, 0x58, 0x63, 0x97, 0x3b, 0x53, 0x4, 0xa0, 0x7e, 0xa1, 0x11, 0x8e, 0x7c, 0x72, 0xd4, 0x60, 0x29, 0x4, 0x8a, 0xa7, 0x3a, 0x8b, 0xae, 0xa1, 0xd8, 0xc9, 0x7, 0x3f, 0x2e, 0xd3, 0xc0, 0x86, 0x7f, 0x5a, 0xff, 0x73, 0xae, 0xb4, 0xbf, 0x47, 0x7e, 0x58, 0xa8, 0xb6, 0xa5, 0xa5, 0x7b, 0xee, 0xb3, 0x82, 0x11, 0x7d, 0x3d, 0x40, 0x6f, 0x3f, 0x1c, 0xf9, 0x9c, 0x3c, 0x4d, 0x28, 0xd6, 0x9a, 0xb, 0xc0, 0x5f, 0xc3, 0x77, 0x35, 0xfc, 0x26, 0xab, 0x83, 0xf1, 0x1b, 0x6b, 0x31, 0x96, 0x68, 0x31, 0x7, 0x2e, 0xb9, 0x60, 0x9, 0x6e, 0x2c, 0x8b, 0x79, 0x6, 0x79, 0xe8, 0x16, 0xa5, 0x86, 0x88, 0x28, 0x11, 0x0, 0x47, 0xc4, 0x74, 0xba, 0x31, 0xf0, 0x95, 0xb3, 0xed, 0xa5, 0x71, 0xb6, 0xcd, 0x8c, 0xc9, 0xfd, 0x3b, 0x6b, 0x96, 0xb8, 0x31, 0x24, 0x82, 0xa6, 0x9e, 0x3c, 0xae, 0xe4, 0x23, 0xae, 0xb6, 0x2, 0x76, 0x45, 0xaf, 0x2a, 0xae, 0xf2, 0x74, 0x14, 0x32, 0x7e, 0x45, 0xaf, 0xb1, 0xc9, 0x26, 0xe3, 0x9, 0x4b, 0x36, 0xa5, 0xb3, 0xeb, 0xba, 0x3a, 0xcf, 0x29, 0xe3, 0x68, 0x7b, 0x66, 0x88, 0x32, 0x1e, 0x4e, 0x24, 0x4e, 0x50, 0xea, 0x72, 0x5a, 0xa0, 0x30, 0x3a, 0xcd, 0x52, 0x25, 0x5, 0x86, 0x6a, 0xd9, 0xa6, 0xe4, 0xe7, 0xd5, 0xcd, 0xbd, 0xda, 0xf2, 0xf7, 0xe3, 0x27, 0x43, 0x6a, 0xc5, 0x1f, 0xc2, 0x43, 0xbd, 0xed, 0xbb, 0xfb, 0x7c, 0x27, 0xad, 0xab, 0x5d, 0xfb, 0x41, 0x44, 0x6a, 0xc2, 0x4, 0x83, 0x32, 0x70, 0xac, 0xb7, 0x16, 0x92, 0x9a, 0xb0, 0x7c, 0xa6, 0xd, 0xa8, 0x47, 0xa1, 0x4a, 0x2b, 0x24, 0x8b, 0x56, 0xac, 0x8, 0x2b, 0x3b, 0xd8, 0xc6, 0x43, 0x87, 0x8d, 0xe6, 0x62, 0xf6, 0xbf, 0x76, 0x4e, 0x45, 0xdc, 0x25, 0xfd, 0xed, 0x62, 0x49, 0x50, 0x29, 0x21, 0x1a, 0x57, 0x88, 0xd0, 0x49, 0x5f, 0x86, 0xc4, 0xcd, 0x46, 0x81, 0x10, 0x32, 0x33, 0x34, 0xcc, 0xea, 0x98, 0x55, 0x8d, 0x5f, 0x9e, 0x23, 0x70, 0xd4, 0x6d, 0x36, 0x28, 0x6b, 0x54, 0x94, 0x4, 0x2f, 0x97, 0x8b, 0xcd, 0xa3, 0xbc, 0x8b, 0x89, 0xbc, 0x7b, 0xb7, 0xcc, 0x2e, 0x5c, 0x90, 0x50, 0xbd, 0x13, 0x15, 0xc7, 0x4c, 0xe3, 0xe5, 0x3a, 0x4c, 0x5a, 0xdc, 0x25, 0x12, 0x1d, 0x15, 0xc7, 0xe5, 0x5d, 0x4e, 0x29, 0x0, 0x18, 0x20, 0x9b, 0x3a, 0x7, 0x7c, 0x73, 0xb1, 0x90, 0x8d, 0xad, 0xbf, 0x21, 0xa4, 0x2d, 0x25, 0x41, 0xfc, 0xe9, 0x67, 0x92, 0xee, 0xbe, 0xf0, 0x91, 0xf6, 0x6, 0x72, 0x94, 0xbc, 0x54, 0x16, 0x71, 0x91, 0x83, 0x74, 0xe5, 0x34, 0x50, 0x17, 0xbc, 0x39, 0xfd, 0x64, 0xa4, 0xcc, 0x56, 0x30, 0x33, 0x89, 0xcd, 0x5b, 0xca, 0x80, 0x3e, 0x89, 0x74, 0x14, 0xf7, 0x83, 0x25, 0x2d, 0x93, 0x7a, 0x61, 0xae, 0x42, 0x29, 0x56, 0xf8, 0xe6, 0xb0, 0xef, 0x73, 0x3d, 0xe2, 0x6c, 0xe2, 0x9d, 0x7d, 0x54, 0xa8, 0x6c, 0xf5, 0x1a, 0xa0, 0x9, 0xe4, 0xed, 0x1c, 0x5c, 0x85, 0x9a, 0x3e, 0x23, 0xc7, 0xcd, 0x9f, 0xd, 0xbb, 0xf0, 0x40, 0x9d, 0x46, 0x55, 0x48, 0xaa, 0x53, 0x16, 0xda, 0x3f, 0xa5, 0xc1, 0x61, 0xf4, 0xfa, 0x13, 0x2, 0xf, 0x92, 0x73, 0x6d, 0x93, 0x37, 0xd2, 0xc1, 0x72, 0xf1, 0x9e, 0xa9, 0xc4, 0x53, 0x2b, 0xa6, 0xcc, 0xe8, 0xe0, 0xf, 0x13, 0x3b, 0x21, 0x3b, 0x8, 0x16, 0xd8, 0x5d, 0x83, 0xe3, 0xa3, 0x90, 0xd0, 0xfd, 0xf, 0x7c, 0xdb, 0x99, 0x3c, 0x35, 0x56, 0x14, 0x54, 0xb, 0x27, 0x3, 0x9f, 0x45, 0xe5, 0x18, 0x4d, 0xce, 0x4c, 0x1, 0xf1, 0xce, 0x6a, 0xdf, 0xfc, 0xfd, 0x35, 0xf3, 0xcf, 0xf6, 0x82, 0xb5, 0x14, 0x8b, 0xfd, 0xd3, 0x90, 0x26, 0x24, 0x4, 0x62, 0x18, 0xe5, 0xe8, 0x43, 0x99, 0xe1, 0xf9, 0xf8, 0xf3, 0xdb, 0x5a, 0xcb, 0xb2, 0xe5, 0xf6, 0x1c, 0xe5, 0x12, 0x23, 0xff, 0xaa, 0x86, 0x7d, 0x80, 0xbf, 0x9, 0xa7, 0xfa, 0xb7, 0xe2, 0x21, 0xa5, 0xb6, 0x90, 0xe7, 0x4d, 0x1, 0xc4, 0x68, 0x26, 0x9e, 0xe7, 0x1d, 0xf6, 0x9f, 0xa2, 0xf0, 0x56, 0x25, 0x12, 0x9c, 0x9c, 0xeb, 0xa4, 0x12, 0x52, 0x8, 0xa9, 0xdd, 0x8, 0xfd, 0x68, 0xd6, 0x18, 0xc6, 0x87, 0xa4, 0x3e, 0xa5, 0xac, 0x1e, 0x6f, 0xb2, 0x5, 0x7, 0xdc, 0xe2, 0x96, 0x99, 0x51, 0x1c, 0x2f, 0xd7, 0xb5, 0x65, 0x30, 0x7e, 0xdc, 0x53, 0xd7, 0x7c, 0xd6, 0xed, 0xea, 0x24, 0xa0, 0x14, 0x20, 0x65, 0x9c, 0xa9, 0x71, 0x2d, 0x8a, 0x76, 0xa8, 0xb1, 0xa, 0xc, 0xd7, 0x4c, 0xd1, 0x44, 0xb0, 0x63, 0xb1, 0xc3, 0x14, 0xa0, 0xe9, 0x65, 0x83, 0x9e, 0x29, 0xc, 0x7f, 0x17, 0x7e, 0x51, 0xb4, 0x1c, 0xb9, 0x2b, 0xfb, 0xca, 0xbf, 0xc6, 0x26, 0x59, 0x1, 0xcd, 0x42, 0x2b, 0xa1, 0x82, 0xa2, 0x18, 0xae, 0x32, 0x9d, 0x3a, 0x50, 0xef, 0xa1, 0x56, 0x26, 0xd6, 0x6d, 0xf2, 0xf0, 0x5a, 0xd2, 0xa9, 0xc0, 0xc6, 0xb9, 0xf1, 0xe4, 0x45, 0xe9, 0xb0, 0xb5, 0x2d, 0x37, 0xd6, 0xf3, 0xf5, 0x18, 0x65, 0xe, 0x17, 0x92, 0x7, 0x1b, 0x6e, 0x7f, 0xd9, 0xe1, 0xec, 0x4b, 0x90, 0x49, 0x33, 0x2b, 0x62, 0x53, 0x60, 0x36, 0x83, 0xb4, 0x32, 0x61, 0x20, 0xd9, 0xa9, 0x78, 0xe8, 0xeb, 0xa2, 0xac, 0x3b, 0x84, 0xc5, 0x6c, 0x2b, 0x32, 0x2d, 0x61, 0xbc, 0x69, 0x3e, 0x3e, 0x1d, 0x15, 0x1e, 0xd4, 0x8b, 0x9b, 0xd2, 0xb2, 0x55, 0xc3, 0xc9, 0xc6, 0x0, 0xbb, 0xdd, 0xaf, 0x72, 0x8e, 0x7e, 0x74, 0xb, 0x40, 0xbd, 0x56, 0x47, 0x98, 0xf7, 0xbe, 0x87, 0xd7, 0x4e, 0xc0, 0x64, 0x7b, 0xa3, 0xfa, 0x9, 0x4b, 0x62, 0x55, 0xdb, 0x44, 0x96, 0xc0, 0xc6, 0xff, 0x7b, 0xc0, 0x80, 0xf4, 0x69, 0xe6, 0xb4, 0x88, 0x4d, 0x99, 0x8a, 0x40, 0x0, 0x9, 0xb, 0x93, 0xaa, 0x18, 0xb8, 0x72, 0x22, 0xe4, 0x1a, 0xe8, 0xe1, 0xb9, 0x63, 0x49, 0xb2, 0xef, 0x2a, 0x4c, 0xa1, 0xd3, 0x4c, 0x59, 0x73, 0xb3, 0x83, 0xc, 0x89, 0x4e, 0xd, 0xa0, 0x76, 0x81, 0x9e, 0xce, 0x77, 0x4e, 0xa2, 0x46, 0x35, 0xc2, 0x81, 0x27, 0x36, 0x14, 0x8d, 0x69, 0x42, 0xb, 0xd3, 0x11, 0x2c, 0xd3, 0x8f, 0x45, 0x10, 0x3, 0x2, 0xad, 0x4c, 0xe4, 0x1e, 0x93, 0x2c, 0x44, 0x7a, 0xb2, 0x5b, 0x79, 0xa1, 0xf5, 0xbd, 0xf8, 0x6b, 0x11, 0xbb, 0x52, 0x9, 0x81, 0x2, 0x35, 0x97, 0x98, 0xe8, 0x91, 0xd3, 0x93, 0x96, 0x30, 0x22, 0x3f, 0x97, 0x3b, 0x90, 0x4d, 0x74, 0x2, 0xc6, 0x1e, 0x34, 0x1f, 0x64, 0x2f, 0x9c, 0x81, 0x23, 0xe4, 0x72, 0xb7, 0x14, 0x38, 0x75, 0x56, 0x4f, 0x87, 0x20, 0x9e, 0x94, 0xaf, 0x82, 0x0, 0x81, 0x0, 0x92, 0xbe, 0x1f, 0xe1, 0x68, 0xb, 0x49, 0x88, 0x99, 0x95, 0xc7, 0xe5, 0x3c, 0x60, 0xaf, 0x9d, 0x4a, 0xae, 0x25, 0x8c, 0xad, 0x2a, 0xaa, 0xad, 0x1b, 0x2c, 0x8, 0x85, 0xd5, 0xbd, 0xc6, 0xa0, 0x5c, 0x23, 0xae, 0xc3, 0x3a, 0x58, 0xc0, 0x85, 0x54, 0x28, 0xc3, 0xf7, 0x2c, 0xf1, 0x9d, 0x53, 0xdf, 0x5b, 0xca, 0xb8, 0x70, 0x2b, 0x11, 0x69, 0xd0, 0xd3, 0xf9, 0x20, 0xf1, 0x1a, 0x1d, 0x52, 0x84, 0xcf, 0x6f, 0x9b, 0x21, 0x56, 0x68, 0xd8, 0xaa, 0xd8, 0xbb, 0xea, 0xca, 0x19, 0xcd, 0x28, 0xa2, 0xee, 0xd4, 0x78, 0x8d, 0x75, 0x34, 0x5, 0xea, 0xac, 0x40, 0xac, 0x97, 0x79, 0xe, 0xd7, 0x6f, 0x24, 0x65, 0x1d, 0xa, 0x30, 0xce, 0x10, 0xb, 0x83, 0x94, 0x3a, 0xd1, 0x38, 0xd8, 0x8c, 0x9e, 0x96, 0x64, 0x8c, 0x30, 0x61, 0x38, 0x4c, 0xb0, 0xff, 0x87, 0xa3, 0x31, 0xc3, 0x26, 0xdc, 0x90, 0x27, 0xe1, 0x3e, 0xcb, 0x70, 0x31, 0x99, 0x47, 0xb3, 0x45, 0x97, 0x9c, 0x0, 0x1c, 0xc4, 0x48, 0x23, 0xa5, 0x92, 0x71, 0x98, 0x26, 0x5d, 0xd2, 0x1, 0x8c, 0x18, 0xbd, 0x8d, 0x16, 0x4b, 0x93, 0x62, 0x29, 0xd6, 0x9d, 0xec, 0x5d, 0xfd, 0x65, 0x6c, 0x74, 0x64, 0x85, 0x32, 0xe5, 0x5, 0xca, 0x8c, 0xeb, 0xf8, 0x78, 0xd, 0x8c, 0x4e, 0x10, 0x79, 0x45, 0x40, 0x3d, 0xa3, 0xd3, 0xf2, 0x72, 0x2e, 0x1b, 0xec, 0x6a, 0x6c, 0x47, 0x32, 0x71, 0x74, 0x86, 0x99, 0x9b, 0x57, 0x16, 0x9b, 0xfd, 0x62, 0x7c, 0x25, 0x5c, 0xbb, 0x1d, 0x67, 0xac, 0x5b, 0x5c, 0xf0, 0x31, 0x6e, 0xdc, 0xe1, 0xc1, 0x31, 0x8e, 0xa3, 0x5a, 0x53, 0xb2, 0x8c, 0x6f, 0xb6, 0x17, 0x28, 0xf0, 0xc4, 0x7e, 0x6, 0x79, 0x36, 0x94, 0x57, 0x2a, 0xa, 0xa1, 0xb5, 0xb1, 0x56, 0x18, 0x10, 0xbc, 0x99, 0xe9, 0x65, 0x4e, 0x2f, 0xe1, 0x72, 0x5e, 0xf2, 0xf, 0x8d, 0x1f, 0x9c, 0xc, 0xb7, 0x4b, 0x2, 0x5e, 0xc7, 0x62, 0x7a, 0x18, 0xfc, 0xb2, 0xc4, 0x24, 0x17, 0x93, 0x72, 0x7f, 0x12, 0x21, 0x83, 0xe5, 0x61, 0x3f, 0x20, 0xeb, 0x3c, 0x7a, 0xe3, 0x71, 0xf, 0xf7, 0xb8, 0xda, 0x1b, 0xfd, 0x52, 0x72, 0xc, 0xc2, 0x4, 0xa1, 0xd7, 0x96, 0xbd, 0x40, 0x99, 0x6a, 0x74, 0xe7, 0x7b, 0xb2, 0x34, 0xd3, 0xec, 0xc3, 0xd6, 0x62, 0x7c, 0x69, 0x81, 0xa4, 0x5e, 0xb1, 0x8f, 0x3, 0xab, 0x5b, 0x70, 0xe9, 0xe3, 0x30, 0x59, 0xfa, 0xaa, 0x61, 0x84, 0x1e, 0x8a, 0x3b, 0x24, 0x94, 0x32, 0x8c, 0x96, 0x5b, 0xc4, 0x6d, 0x5b, 0x3a, 0xff, 0x6, 0xc2, 0x69, 0xf0, 0xc7, 0xe0, 0x66, 0xe3, 0xe7, 0xa, 0x5d, 0x42, 0x79, 0x21, 0x65, 0x11, 0xa7, 0x8f, 0x2f, 0x68, 0xfe, 0x7b, 0x7d, 0x95, 0xc8, 0xb8, 0x18, 0x8a, 0x4c, 0xa1, 0xdd, 0xe, 0xb1, 0x64, 0x2f, 0xf4, 0xdc, 0x25, 0xa5, 0xca, 0xb, 0x40, 0x7d, 0x4e, 0x87, 0x28, 0x49, 0x25, 0x47, 0x31, 0x53, 0xb4, 0xe4, 0xab, 0x1e, 0x97, 0xbd, 0x14, 0xc7, 0x4b, 0xb5, 0x2d, 0x7, 0xdb, 0x40, 0x9c, 0xc1, 0x1e, 0x1f, 0xc0, 0x7d, 0xc7, 0x97, 0x21, 0x26, 0xcb, 0xd8, 0x19, 0xad, 0xc8, 0x36, 0x2, 0x22, 0xb4, 0x89, 0x3e, 0x2d, 0xd6, 0xdc, 0x63, 0x5, 0xd4, 0xcb, 0x0, 0x2, 0x92, 0x8f, 0x45, 0xc7, 0xf7, 0x76, 0x63, 0x16, 0x75, 0xc6, 0x74, 0x76, 0x72, 0xff, 0xb3, 0x5a, 0x86, 0x16, 0xc2, 0x4c, 0xbb, 0xc, 0x7, 0x9c, 0x1d, 0x20, 0x1f, 0xbd, 0x2, 0xf9, 0x34, 0x13, 0x8e, 0x1a, 0xdf, 0xa8, 0x2d, 0x50, 0x6c, 0x88, 0x30, 0x60, 0xb4, 0x63, 0xa, 0xb8, 0x38, 0xae, 0x8b, 0xb1, 0x36, 0x8, 0x11, 0xae, 0x8c, 0xa3, 0xaf, 0x4, 0x7e, 0x24, 0x7c, 0x2, 0x63, 0x0, 0x2, 0x5b, 0xe2, 0x14, 0xa3, 0x92, 0xeb, 0x5, 0x38, 0x2c, 0xd5, 0xee, 0x86, 0x65, 0x53, 0xb7, 0xb3, 0xa8, 0x19, 0xd9, 0xda, 0x3b, 0x3, 0xb4, 0x12, 0x58, 0xaf, 0x30, 0x8, 0xcb, 0x7d, 0xf0, 0x6a, 0x32, 0x55, 0x46, 0x67, 0x7b, 0x95, 0x4d, 0xd8, 0x3, 0x1f, 0x2b, 0x23, 0x91, 0xf7, 0xb8, 0xe9, 0xb0, 0xda, 0x93, 0x7a, 0x7a, 0x47, 0xe4, 0x3a, 0xf3, 0x4b, 0xda, 0xb, 0xe6, 0xd4, 0x52, 0x8b, 0xae, 0x57, 0xbf, 0xf8, 0x9b, 0x1b, 0x74, 0x39, 0x12, 0xaa, 0xfd, 0x7a, 0x16, 0x9a, 0x16, 0x29, 0xc2, 0x85, 0xbb, 0x0, 0x63, 0x31, 0x1, 0xef, 0xb6, 0xe2, 0xc7, 0x17, 0x30, 0x5f, 0x57, 0xfa, 0x99, 0x67, 0xd1, 0x74, 0x27, 0x5c, 0xc6, 0x3, 0xeb, 0x12, 0x29, 0x41, 0xe0, 0x4, 0x7b, 0x75, 0xe7, 0xa9, 0x2c, 0x38, 0x1d, 0x18, 0x54, 0x9e, 0x22, 0x2c, 0x4e, 0x30, 0x87, 0xde, 0x67, 0x8, 0x98, 0xd7, 0x89, 0x21, 0x5a, 0xbe, 0xf3, 0x3c, 0xe7, 0xb, 0x2c, 0x2e, 0xb7, 0x2e, 0xd5, 0x16, 0x54, 0xd1, 0xfe, 0x3f, 0xff, 0x93, 0xf8, 0x13, 0xdd, 0xd8, 0x66, 0x82, 0xa6, 0x4a, 0xb7, 0x95, 0xd1, 0x94, 0x59, 0xae, 0xd7, 0xe0, 0xba, 0xf9, 0xb9, 0xc0, 0x1c, 0xe5, 0x22, 0xe7, 0x18, 0x75, 0x5a, 0x23, 0x26, 0x4d, 0x67, 0x48, 0xb5, 0xe7, 0x47, 0x5e, 0x1d, 0xf, 0xde, 0x8d, 0x98, 0x28, 0xac, 0xd5, 0x74, 0x76, 0xfa, 0xe1, 0x19, 0x19, 0x5f, 0xab, 0xa7, 0x68, 0xa1, 0xac, 0x66, 0xbd, 0x3b, 0xa, 0xf3, 0xaf, 0x80, 0xe1, 0x4b, 0xa8, 0x6b, 0xe0, 0x75, 0xc7, 0x85, 0x3, 0x24, 0x55, 0x31, 0x14, 0xce, 0xa9, 0x89, 0x0, 0x89, 0xdc, 0x97, 0x3, 0x21, 0xc, 0x82, 0x4a, 0xbf, 0xe3, 0xf6, 0x56, 0x59, 0x5e, 0xcd, 0xf0, 0xa9, 0xe9, 0xe5, 0x9c, 0x2e, 0xf5, 0x8b, 0xe8, 0x26, 0xa5, 0xf1, 0x35, 0xf3, 0x94, 0x2c, 0x63, 0xa6, 0xd3, 0xeb, 0x40, 0xb3, 0x9c, 0x8e, 0x23, 0x4e, 0x8e, 0x23, 0x71, 0xae, 0x94, 0xbf, 0x17, 0xe3, 0x78, 0xd4, 0xe9, 0xde, 0x4f, 0xbe, 0xa5, 0x79, 0x5, 0x2d, 0x8e, 0xd, 0xc1, 0xbd, 0xb0, 0xdc, 0xe3, 0x19, 0xd4, 0xda, 0xb6, 0xc7, 0xf5, 0x3a, 0x1f, 0xb7, 0x59, 0x3, 0xfd, 0x2c, 0x28, 0x1f, 0x3, 0x3d, 0x98, 0x58, 0x6, 0xe4, 0x76, 0x79, 0x4f, 0x40, 0xdb, 0x73, 0x8b, 0xf7, 0x74, 0x45, 0x4d, 0xf1, 0x14, 0x46, 0x6e, 0x47, 0xbf, 0x57, 0xd9, 0x34, 0x32, 0xdc, 0xfc, 0x3b, 0xfc, 0x9, 0xa5, 0x9c, 0xee, 0xe9, 0x87, 0x71, 0x17, 0x28, 0x7b, 0xb4, 0x8b, 0xbc, 0xd5, 0x6, 0x9e, 0xe3, 0xa2, 0x15, 0x3a, 0x9c, 0x8c, 0xce, 0xf2, 0xd2, 0x78, 0x38, 0x84, 0xc3, 0x99, 0xe5, 0x90, 0x71, 0xf6, 0x98, 0xe1, 0xe8, 0x5d, 0xbe, 0xaa, 0xc2, 0x3, 0x27, 0x18, 0x52, 0xa0, 0x56, 0xd2, 0x87, 0xef, 0x30, 0x84, 0x36, 0x8a, 0xe3, 0x27, 0x33, 0xd7, 0xad, 0xc8, 0xca, 0x4c, 0x1e, 0x73, 0x2f, 0xe4, 0xa0, 0xee, 0x41, 0xb5, 0x3d, 0x2e, 0xd5, 0xc, 0xcc, 0xd, 0x79, 0xe1, 0x27, 0xa5, 0xce, 0x58, 0xbc, 0x48, 0xe, 0x43, 0x2d, 0x8c, 0x85, 0x56, 0x48, 0xbd, 0x44, 0xeb, 0x87, 0xff, 0x98, 0xd5, 0x8e, 0x3e, 0xfc, 0x5e, 0xaa, 0xd3, 0x6b, 0xf8, 0x45, 0x72, 0x35, 0x6, 0x72, 0xf7, 0xfc, 0xf0, 0x7c, 0x47, 0xc2, 0x3a, 0xc9, 0x46, 0x59, 0x31, 0xba, 0xa9, 0x44, 0x31, 0xde, 0x7e, 0xf4, 0x4a, 0xa9, 0x57, 0xeb, 0xca, 0x26, 0x90, 0x6, 0x3f, 0x3e, 0xc9, 0xa9, 0x66, 0xb0, 0x4c, 0x69, 0xb3, 0x41, 0xc9, 0x5, 0x24, 0x82, 0x6d, 0x27, 0x86, 0x9c, 0xc2, 0x30, 0x32, 0x7b, 0x88, 0x3f, 0xe5, 0x29, 0xee, 0xa2, 0x4b, 0xc1, 0x13, 0x34, 0xf0, 0x8c, 0xf8, 0x36, 0x70, 0x5c, 0x3c, 0xc2, 0x2a, 0x46, 0xd, 0x14, 0x2f, 0xf2, 0x1a, 0x29, 0x2b, 0x97, 0x63, 0x48, 0x5, 0xb8, 0x73, 0xa9, 0xd, 0x32, 0xbd, 0xc3, 0x54, 0xd5, 0x74, 0xa0, 0xaf, 0xdb, 0xb6, 0xb0, 0xbc, 0x47, 0x2d, 0x27, 0xfd, 0x91, 0x16, 0xd6, 0xd9, 0x11, 0x74, 0x6b, 0xb1, 0x4, 0xdd, 0x9c, 0x65, 0xa6, 0xa2, 0x77, 0xe4, 0xe6, 0xa, 0x6a, 0x5d, 0x77, 0xb1, 0x91, 0xc9, 0x4, 0xa4, 0xba, 0xbc, 0xed, 0x9c, 0xd7, 0x7f, 0x7a, 0x7b, 0x5c, 0x4b, 0x7b, 0x8c, 0x47, 0x3a, 0x5, 0x1b, 0x5e, 0xff, 0x46, 0xd7, 0x1c, 0x4a, 0xc, 0xe8, 0x1b, 0x87, 0xd4, 0x49, 0xf5, 0x83, 0xe6, 0xbb, 0xfe, 0xae, 0x99, 0x9d, 0x6e, 0xfb, 0xdf, 0xd6, 0xb4, 0xa7, 0xff, 0x70, 0x9d, 0xe3, 0xec, 0xe9, 0x39, 0xcb, 0x5b, 0x12, 0x7d, 0xcb, 0x4d, 0xec, 0x94, 0xec, 0xb1, 0xce, 0xbf, 0xfd, 0xd3, 0xd2, 0x22, 0x37, 0xbe, 0x58, 0x0, 0xc3, 0x71, 0xaf, 0xb5, 0x64, 0x56, 0x88, 0x2a, 0xb3, 0xdd, 0xe8, 0x14, 0xea, 0xfc, 0xd1, 0x3a, 0x39, 0x8c, 0x17, 0x39, 0x17, 0x73, 0x12, 0xf8, 0xf7, 0xdd, 0xef, 0x23, 0x86, 0xe0, 0x84, 0x26, 0x35, 0x5c, 0xa, 0xd2, 0xac, 0x21, 0x11, 0xea, 0xfc, 0x57, 0xa1, 0x6e, 0xa2, 0x38, 0x5d, 0x38, 0xdd, 0xb8, 0x5e, 0x32, 0x82, 0x7b, 0xef, 0x10, 0x53, 0x66, 0x61, 0x7b, 0xf8, 0x58, 0x5a, 0x25, 0xed, 0xdd, 0x66, 0x3, 0x7b, 0x8f, 0x1b, 0x67, 0xc3, 0x91, 0x1c, 0xe1, 0x5, 0x2b, 0x22, 0x55, 0xb4, 0x4f, 0x15, 0x7e, 0x3e, 0x73, 0xf8, 0x45, 0xb3, 0xf1, 0x79, 0xef, 0x54, 0xc, 0xec, 0xc3, 0xe, 0x41, 0x73, 0x1b, 0x2, 0xa9, 0xbb, 0x3c, 0xe6, 0xf3, 0x90, 0xd2, 0x73, 0xef, 0x30, 0x11, 0xc9, 0x22, 0x7d, 0x27, 0x43, 0x37, 0x67, 0xd, 0x2c, 0xe9, 0x6, 0x29, 0x63, 0x9e, 0x62, 0xa5, 0x17, 0x1c, 0xf2, 0x6d, 0x30, 0xda, 0xed, 0x75, 0xef, 0x9a, 0x2, 0x66, 0x36, 0x27, 0xc1, 0x42, 0xf9, 0xb8, 0x4c, 0x9f, 0xb5, 0xce, 0xcb, 0xe0, 0x70, 0xb4, 0x85, 0x4e, 0x6e, 0x40, 0x6b, 0xfc, 0x93, 0x7c, 0x8a, 0x6b, 0x44, 0xe7, 0xef, 0x5f, 0x56, 0xcb, 0xbe, 0x6d, 0x57, 0xfd, 0x5d, 0x5c, 0x15, 0x4, 0xd7, 0x7a, 0x2a, 0x14, 0xd8, 0x44, 0xaa, 0x14, 0xea, 0x52, 0xad, 0x88, 0x86, 0x0, 0xfd, 0x7d, 0xda, 0x4f, 0x81, 0x97, 0x16, 0x96, 0x33, 0x69, 0xe8, 0x39, 0xb8, 0x47, 0xe9, 0x5c, 0xa7, 0xd8, 0x9f, 0xbf, 0xbf, 0x11, 0x77, 0x89, 0x3, 0xa8, 0x84, 0xed, 0xe8, 0xfc, 0xd1, 0xe0, 0xd, 0x80, 0xf9, 0xbb, 0x24, 0x1e, 0x8e, 0x6c, 0xdd, 0xdf, 0x7, 0xa2, 0xdf, 0xcb, 0xb5, 0xca, 0x70, 0x28, 0xa3, 0x39, 0x99, 0x97, 0x4, 0xd1, 0x29, 0x3, 0x51, 0x8f, 0xd3, 0x38, 0x98, 0xad, 0x3, 0x84, 0xd6, 0x7d, 0x22, 0xcc, 0x63, 0x52, 0x2a, 0xe6, 0x4d, 0x57, 0xfe, 0x19, 0xcd, 0xb, 0x77, 0x8b, 0x56, 0xfb, 0x53, 0x1c, 0x0, 0xb9, 0xf9, 0x15, 0xc5, 0x86, 0xa0, 0xdc, 0xa0, 0x70, 0xea, 0xac, 0x22, 0xe8, 0x4f, 0xf4, 0xdc, 0x71, 0x89, 0x15, 0xae, 0xb3, 0x7a, 0x30, 0x5b, 0xe0, 0x2d, 0xa, 0xf2, 0xf4, 0x10, 0x84, 0x13, 0xff, 0xd5, 0xdf, 0x74, 0xea, 0x1b, 0xb5, 0xa, 0x6f, 0x7b, 0x17, 0x2e, 0xae, 0x5, 0x31, 0x38, 0x4f, 0x6b, 0x11, 0x69, 0x3d, 0x9a, 0xd6, 0x58, 0x8c, 0x4f, 0xfa, 0x1c, 0x13, 0x1a, 0xf8, 0xbc, 0xc3, 0x9f, 0xb4, 0x9d, 0x3, 0xc8, 0x50, 0xeb, 0x45, 0xc3, 0x60, 0xf9, 0x94, 0x1d, 0x27, 0xc4, 0xce, 0xeb, 0xf4, 0xd5, 0x4d, 0xc7, 0x5f, 0x40, 0xe3, 0x92, 0x6, 0x13, 0xc3, 0x72, 0x97, 0x8d, 0xb8, 0xf9, 0xf5, 0x0, 0x5a, 0x63, 0x4e, 0x22, 0xce, 0x15, 0xcd, 0x95, 0xf3, 0xeb, 0x73, 0xcb, 0x35, 0x85, 0x4f, 0xb5, 0xfa, 0x9e, 0xaf, 0xd, 0x86, 0x74, 0x93, 0x4d, 0x2e, 0x44, 0xac, 0xe7, 0x4f, 0x47, 0x3b, 0x1b, 0xf1, 0xda, 0xea, 0x7c, 0xbb, 0x91, 0xff, 0xb, 0x75, 0x24, 0xb5, 0x1f, 0xcb, 0x51, 0xd7, 0x6a, 0x21, 0x38, 0x2d, 0x1e, 0x68, 0xdc, 0x6c, 0xca, 0xa3, 0x24, 0x32, 0x26, 0x6a, 0x60, 0xec, 0x5a, 0x15, 0xf1, 0x54, 0xf3, 0x90, 0xf1, 0x7f, 0x2a, 0x32, 0xf2, 0x2e, 0xc3, 0x7f, 0x95, 0x46, 0xb0, 0x66, 0xe5, 0x31, 0x44, 0x28, 0xf1, 0x6, 0x5e, 0xe2, 0x4f, 0xa7, 0x4e, 0x7c, 0x10, 0x4b, 0x88, 0x9, 0x91, 0x12, 0x4d, 0x5f, 0x9c, 0x2c, 0x43, 0x1c, 0x20, 0x49, 0x7c, 0xb4, 0x4, 0xf0, 0x46, 0x62, 0xf5, 0x83, 0xd9, 0xe5, 0x45, 0xc0, 0x8e, 0x10, 0x71, 0x7d, 0x4a, 0x3, 0x31, 0xed, 0xfa, 0x1, 0x89, 0x33, 0xc7, 0x22, 0x0, 0x66, 0x7b, 0xee, 0xf4, 0xa3, 0x4, 0x2e, 0x34, 0xcb, 0x81, 0x77, 0x7c, 0x20, 0x17, 0x1f, 0x13, 0x34, 0xec, 0x18, 0x63, 0xf5, 0xa7, 0x7e, 0xbc, 0x55, 0xaa, 0x6, 0xe4, 0xed, 0xd8, 0x37, 0xc2, 0xfe, 0x5, 0x7f, 0x8d, 0xa8, 0x7d, 0xff, 0xbf, 0x61, 0x7, 0x38, 0x65, 0x73, 0x34, 0x6a, 0x17, 0xbd, 0xc3, 0xfb, 0xd8, 0x73, 0xae, 0x7c, 0xbd, 0x3e, 0x78, 0x57, 0x9c, 0xe3, 0x8, 0xbb, 0x6c, 0xbe, 0x6d, 0xee, 0xc7, 0xa2, 0x4c, 0x5c, 0x7d, 0xe6, 0x4c, 0x2c, 0x85, 0x77, 0x87, 0xa2, 0x2b, 0xb7, 0xa9, 0xe6, 0x98, 0xe9, 0xa6, 0xbc, 0xe8, 0x54, 0xd3, 0xbe, 0x63, 0xea, 0xcb, 0xe4, 0xe1, 0xf, 0x1b, 0x17, 0x5, 0xcb, 0xda, 0xdb, 0xa7, 0xda, 0x8c, 0x20, 0x37, 0xa0, 0x43, 0x8a, 0x6f, 0xa5, 0x4e, 0x3, 0x25, 0x47, 0x47, 0x4e, 0xe8, 0xa2, 0x83, 0x86, 0xb4, 0xf0, 0xf6, 0x38, 0x39, 0x6e, 0xf7, 0x12, 0x5e, 0x77, 0xcd, 0xb7, 0x60, 0x46, 0x5a, 0xe, 0x19, 0x6f, 0x1e, 0x44, 0xcf, 0x77, 0x6e, 0xcf, 0xff, 0xff, 0x94, 0xda, 0x9d, 0x45, 0xa6, 0xc2, 0xa7, 0x74, 0x70, 0x34, 0xff, 0x61, 0x10, 0xf8, 0xc8, 0x18, 0xa0, 0xb4, 0xdd, 0x74, 0x68, 0xd5, 0x23, 0x7b, 0x6d, 0xc5, 0xc5, 0x9b, 0x24, 0x3, 0xfb, 0xb, 0xf2, 0xcd, 0xe5, 0x53, 0xe0, 0xe7, 0x20, 0x3a, 0xd2, 0xe0, 0x8a, 0xc4, 0x47, 0xbd, 0x36, 0xcc, 0x42, 0x59, 0xd4, 0x4, 0x5, 0x8d, 0x49, 0x9f, 0x7d, 0x51, 0xbb, 0xf7, 0xd8, 0xa1, 0x8f, 0xc5, 0x98, 0xa9, 0xf3, 0x22, 0x15, 0x4d, 0xb7, 0xa4, 0x6, 0xfc, 0x67, 0xc6, 0x5b, 0x60, 0xad, 0x2f, 0x9e, 0x4a, 0xef, 0x5a, 0x20, 0xca, 0x1a, 0x98, 0x82, 0x92, 0x23, 0x5d, 0x9e, 0x37, 0xf2, 0xcc, 0x6c, 0xaa, 0x46, 0x6, 0x31, 0x24, 0xe4, 0xed, 0xef, 0x6f, 0x6d, 0xb0, 0x29, 0x46, 0x37, 0xe0, 0xf5, 0xc2, 0x44, 0x43, 0xfd, 0x9e, 0x8f, 0x14, 0xd0, 0x4d, 0x44, 0xe6, 0xa0, 0xf8, 0x9d, 0x39, 0x3, 0x34, 0x10, 0x29, 0x90, 0x99, 0x1d, 0xad, 0xe0, 0x76, 0x7, 0xf4, 0xf, 0xec, 0xcf, 0x1, 0xa, 0xfb, 0xd7, 0x32, 0xda, 0x1d, 0x70, 0x30, 0x5e, 0x61, 0xa5, 0xc3, 0x6a, 0xb8, 0x61, 0x3b, 0xb2, 0x75, 0x24, 0xcb, 0x64, 0xb8, 0x76, 0x6f, 0x47, 0xe1, 0xc5, 0xd4, 0x2f, 0x17, 0x78, 0xfa, 0x2, 0xed, 0x13, 0xc2, 0x75, 0xb1, 0x29, 0x6, 0xfa, 0x1d, 0x6f, 0xfc, 0xc1, 0x14, 0x31, 0xc, 0xde, 0x81, 0x9d, 0x3b, 0x42, 0x84, 0x81, 0xaf, 0x47, 0x39, 0xe9, 0x62, 0xe3, 0xa2, 0xd9, 0xd, 0x86, 0x4d, 0x43, 0x19, 0xdc, 0x67, 0xf4, 0xbd, 0xda, 0xc7, 0x64, 0x48, 0xb6, 0x7f, 0xb4, 0x39, 0x79, 0x3b, 0x68, 0xb7, 0x9c, 0x1d, 0xea, 0xa6, 0xde, 0xf0, 0x4a, 0x44, 0xad, 0x66, 0xf2, 0x59, 0x6c, 0xbb, 0x3a, 0x9b, 0x54, 0x60, 0xdd, 0xf0, 0x52, 0x35, 0xd5},
+               output224: []byte{0xe0, 0x1a, 0x40, 0xef, 0xa7, 0x8d, 0xe5, 0xbb, 0x50, 0x5, 0x13, 0xcc, 0x1a, 0xd7, 0x73, 0x26, 0xc9, 0x50, 0xd9, 0x91, 0xc0, 0x70, 0x6a, 0xc6, 0x67, 0x58, 0xef, 0xa1},
+               output256: []byte{0x7, 0x12, 0x8f, 0x94, 0x52, 0xcf, 0x60, 0x1e, 0x2a, 0x30, 0x5a, 0xb7, 0x5c, 0xdd, 0x13, 0x1, 0x7b, 0xbf, 0x79, 0xb0, 0xae, 0x3b, 0x5b, 0x43, 0xc2, 0xce, 0x7, 0x71, 0xb0, 0x4f, 0x57, 0x19},
+               output384: []byte{0x92, 0xb0, 0xef, 0xc8, 0x24, 0x8e, 0x8c, 0x6a, 0x96, 0x46, 0xdf, 0x49, 0xb8, 0x75, 0x99, 0x21, 0xbe, 0xa6, 0xf4, 0x4, 0x2e, 0x1b, 0xdd, 0x1c, 0x12, 0x8c, 0x42, 0x1e, 0x6c, 0xa6, 0xfe, 0xb4, 0xb7, 0x85, 0xcd, 0x8a, 0xe0, 0xa4, 0x8a, 0xd1, 0x8a, 0x1d, 0x5, 0xa6, 0x5d, 0xbd, 0xe2, 0x81},
+               output512: []byte{0x46, 0x19, 0x3d, 0x20, 0x10, 0x98, 0x71, 0x2e, 0x16, 0xfa, 0x95, 0x7d, 0x9b, 0x9f, 0x95, 0x40, 0xcf, 0xb, 0x53, 0xb6, 0xa1, 0xe0, 0xbd, 0x5e, 0xfe, 0x6b, 0x6d, 0xbb, 0x40, 0x18, 0x16, 0xfc, 0x5a, 0x78, 0xb8, 0xf7, 0x6, 0xc6, 0xfb, 0x57, 0x9d, 0xe4, 0x5b, 0x7e, 0x33, 0xb3, 0xf9, 0xbc, 0xae, 0x1, 0xf4, 0x56, 0xc9, 0xc, 0x76, 0x2f, 0x36, 0xfa, 0x62, 0x4b, 0x75, 0x85, 0x83, 0x84}},
+       testcase{
+               msg:       []byte{0x86, 0xa9, 0xe1, 0xce, 0x8c, 0x1f, 0x20, 0x45, 0x86, 0x83, 0xca, 0xd7, 0x2c, 0xba, 0x1a, 0x63, 0x78, 0x9e, 0x61, 0xf8, 0xcb, 0xd6, 0xa5, 0x43, 0x43, 0x6, 0x4d, 0x72, 0x49, 0x5a, 0x8c, 0x68, 0x6a, 0x7, 0x3a, 0x81, 0x9d, 0xab, 0x85, 0x82, 0xa2, 0x9e, 0xd7, 0x5b, 0x32, 0x7f, 0x2, 0xe0, 0x1, 0xf6, 0x4b, 0xf5, 0x4d, 0x4c, 0x7a, 0x42, 0xdf, 0x21, 0xb, 0x5f, 0xd2, 0xe2, 0x25, 0x60, 0x72, 0x89, 0xdd, 0xb6, 0x7d, 0x0, 0x24, 0x92, 0xec, 0xb, 0x27, 0x73, 0xe8, 0x60, 0x97, 0xe6, 0x31, 0x70, 0x9a, 0xd7, 0x77, 0xe9, 0xa1, 0x2b, 0x14, 0xe6, 0xfb, 0xb, 0x27, 0xd7, 0xa6, 0xb0, 0x72, 0xa0, 0xcf, 0x10, 0x71, 0x36, 0x5d, 0x4, 0xe7, 0x64, 0x84, 0x70, 0xb6, 0xbe, 0x0, 0xd5, 0x88, 0xd9, 0x37, 0x8c, 0x8e, 0x1a, 0xf2, 0xf3, 0x17, 0x68, 0xc5, 0x6d, 0xaa, 0xc4, 0x28, 0x2b, 0xb3, 0x91, 0x19, 0x69, 0xb3, 0x81, 0x37, 0x1c, 0xa4, 0x6b, 0x62, 0xf3, 0xeb, 0x1f, 0x50, 0xdf, 0x99, 0x53, 0x5c, 0x0, 0xff, 0x52, 0x3d, 0x78, 0x1b, 0x25, 0x19, 0xe1, 0xbc, 0xfe, 0x43, 0x9, 0xae, 0x56, 0x8b, 0x1a, 0xb9, 0x22, 0x93, 0xfb, 0xce, 0xdc, 0xae, 0x52, 0xb1, 0xbd, 0x6c, 0x60, 0x5b, 0xd3, 0x5e, 0xf6, 0x33, 0xa, 0x61, 0xad, 0xfd, 0x5c, 0xeb, 0xe6, 0x2b, 0x78, 0xdf, 0x1c, 0x95, 0x16, 0x8e, 0x41, 0x26, 0xb, 0x52, 0xb, 0x76, 0xc4, 0xc, 0xb7, 0x67, 0xce, 0x84, 0x48, 0x37, 0xcc, 0x48, 0x6e, 0x66, 0xa6, 0xd6, 0x89, 0x26, 0x32, 0xb8, 0x7a, 0xfd, 0x27, 0xa, 0x96, 0x53, 0x52, 0xee, 0xe8, 0xa8, 0xd2, 0x34, 0xc5, 0x66, 0xbf, 0x78, 0xb5, 0x39, 0xd, 0x94, 0x9, 0x48, 0xf3, 0xdc, 0xe2, 0xe9, 0x73, 0xd6, 0x86, 0x56, 0x97, 0x79, 0x39, 0xa7, 0x87, 0x91, 0x69, 0x22, 0xcc, 0xd9, 0x49, 0xbd, 0x41, 0xa0, 0x64, 0xb, 0xd4, 0x4a, 0x33, 0xcd, 0x77, 0x20, 0x40, 0x40, 0x7b, 0xaa, 0x11, 0xd9, 0x5a, 0x6f, 0x2e, 0xf1, 0x8e, 0x9f, 0x29, 0x74, 0xf1, 0x3, 0x9c, 0x63, 0xc1, 0x4f, 0xff, 0x47, 0x6d, 0x97, 0x6c, 0xe5, 0x7c, 0xae, 0x6f, 0x2a, 0xca, 0x2, 0x18, 0xae, 0xd3, 0x85, 0xb6, 0xd9, 0x12, 0x62, 0x97, 0x7d, 0x23, 0xe5, 0xa0, 0xac, 0x9f, 0xff, 0xbd, 0xa8, 0x7c, 0x54, 0xc8, 0x95, 0x90, 0x24, 0x65, 0xba, 0xc9, 0xc5, 0xc6, 0xbb, 0x3e, 0x10, 0xa2, 0x76, 0xc3, 0xaa, 0x7e, 0xf9, 0x2, 0xb2, 0xff, 0xeb, 0xff, 0xb0, 0x14, 0xa7, 0x7f, 0x65, 0x38, 0x3a, 0x27, 0x7b, 0x10, 0xd1, 0xea, 0x73, 0x6b, 0x6d, 0x8b, 0x84, 0x54, 0x8, 0x25, 0x10, 0x46, 0xa1, 0xc5, 0x54, 0x8f, 0x71, 0x8e, 0x94, 0x8e, 0x29, 0xb, 0xc9, 0x4c, 0x86, 0xa0, 0x5e, 0x3, 0xd, 0x7c, 0x1, 0x83, 0xcd, 0x2b, 0xd3, 0xf3, 0x16, 0x6c, 0x8d, 0xf6, 0x48, 0xfc, 0xc3, 0x76, 0x4a, 0xb9, 0xc2, 0x7e, 0x77, 0xf0, 0x6b, 0xa7, 0x2d, 0xe8, 0x7c, 0x79, 0xcf, 0x7f, 0x8d, 0x6e, 0x83, 0xa8, 0xd5, 0xce, 0x62, 0x87, 0xd2, 0xb1, 0x7b, 0x9e, 0x7d, 0x90, 0xb2, 0x5b, 0x9e, 0x75, 0x7b, 0xec, 0xa7, 0x23, 0x68, 0xf9, 0x90, 0x9d, 0x89, 0x35, 0x17, 0x95, 0x24, 0xc1, 0x36, 0xb0, 0xea, 0x32, 0x40, 0xd4, 0x10, 0x82, 0x65, 0x55, 0x89, 0x44, 0xd8, 0xe7, 0x77, 0x1, 0xca, 0x4f, 0x18, 0x7b, 0xcb, 0x48, 0x70, 0x8f, 0x4c, 0x1, 0x5c, 0xbd, 0xb8, 0x1d, 0xdb, 0x9, 0xcc, 0x6a, 0xfa, 0x46, 0xf4, 0x73, 0x4f, 0x78, 0x53, 0xb1, 0x40, 0x94, 0x13, 0xad, 0xa5, 0xd5, 0x58, 0x44, 0x94, 0x3, 0x4f, 0x5b, 0x45, 0x17, 0xfa, 0x7d, 0xe3, 0xdf, 0xc0, 0x75, 0x31, 0xcb, 0x6f, 0xd2, 0x13, 0xa6, 0x87, 0x4c, 0x21, 0x28, 0x5, 0xdf, 0xc, 0x8d, 0xae, 0x74, 0x96, 0x9e, 0x54, 0xcd, 0x9a, 0xc4, 0xae, 0x77, 0x8a, 0xba, 0x8c, 0xa5, 0x26, 0x19, 0xe3, 0x79, 0xea, 0x17, 0xfd, 0x10, 0x95, 0x72, 0xf2, 0xdd, 0x38, 0xc0, 0x31, 0xcd, 0xf5, 0x8d, 0xe8, 0xf0, 0xe, 0x1e, 0x5f, 0xa2, 0xf1, 0xcf, 0x2e, 0xa3, 0x94, 0x42, 0x11, 0x6f, 0xd9, 0xd, 0xff, 0x3d, 0xbc, 0x92, 0xcb, 0x52, 0xaf, 0xae, 0x95, 0xeb, 0x17, 0x53, 0x5d, 0x48, 0x41, 0x59, 0x98, 0xf1, 0x23, 0x5f, 0xd9, 0x66, 0x49, 0x9f, 0xad, 0xdc, 0x41, 0x35, 0xb2, 0x69, 0xf6, 0xdb, 0x55, 0xe3, 0x92, 0xc0, 0xd0, 0xb5, 0xe, 0x2a, 0x94, 0xd5, 0x3b, 0x13, 0xf2, 0x20, 0x56, 0x77, 0x29, 0x69, 0x8f, 0x4a, 0x64, 0x65, 0xef, 0xce, 0x13, 0x8a, 0x5d, 0xb3, 0xae, 0xca, 0x6e, 0xa2, 0xda, 0x5a, 0x43, 0x11, 0x70, 0x6b, 0xb8, 0xe3, 0xac, 0x2f, 0xef, 0x19, 0xce, 0xe7, 0x58, 0x77, 0x15, 0x18, 0x98, 0xbe, 0xcc, 0xf7, 0x5b, 0x5, 0x55, 0x34, 0x7e, 0x52, 0xc5, 0x71, 0xb8, 0xc0, 0x0, 0x1a, 0xcc, 0x8, 0xc3, 0xbf, 0xe6, 0x4f, 0xd4, 0x55, 0x62, 0x8d, 0xc7, 0xb8, 0xbf, 0xe3, 0x8, 0x73, 0x76, 0x3, 0x6, 0xc5, 0x48, 0xac, 0xea, 0xb, 0x7e, 0x8c, 0x61, 0x24, 0x6, 0x5a, 0x16, 0xb0, 0x4a, 0xc5, 0x9, 0x98, 0xbf, 0xa5, 0x7f, 0xa1, 0xf5, 0x95, 0xdf, 0x82, 0x72, 0xa0, 0xcf, 0x7d, 0x4c, 0xb4, 0x1, 0x97, 0x7f, 0x4, 0x8d, 0x95, 0x30, 0xe5, 0xa1, 0xe5, 0xca, 0xdb, 0xcd, 0xb0, 0xa3, 0xd5, 0x24, 0xb6, 0xce, 0xb7, 0xd1, 0x6b, 0x5d, 0x62, 0x72, 0x5a, 0xa0, 0x83, 0xb5, 0x5b, 0xa5, 0x95, 0xb4, 0x6d, 0x68, 0x31, 0xe, 0xdf, 0x2d, 0xa3, 0xd6, 0xe0, 0xd5, 0xd, 0x87, 0x41, 0x4e, 0x64, 0x21, 0xc6, 0xc3, 0x1f, 0x51, 0xfa, 0x56, 0xbf, 0x9b, 0x46, 0xed, 0x52, 0x16, 0x54, 0x9e, 0x2a, 0x2e, 0x9, 0x0, 0xeb, 0x21, 0x94, 0xfd, 0x41, 0x3a, 0x40, 0xe5, 0xbd, 0xe5, 0x2a, 0x85, 0x6, 0x3a, 0xa1, 0x1e, 0x51, 0x73, 0x9f, 0x73, 0x25, 0xe1, 0x9, 0xe1, 0x68, 0x82, 0xb9, 0xb8, 0xe0, 0xe2, 0xdf, 0x4, 0x72, 0x7f, 0xb3, 0xea, 0x6c, 0x66, 0xe4, 0x15, 0xf2, 0xfa, 0xeb, 0x65, 0xcb, 0x2, 0xdb, 0x10, 0x1d, 0x97, 0xb4, 0x79, 0x32, 0xfc, 0xde, 0x8f, 0x12, 0x10, 0x51, 0x36, 0x3f, 0xfc, 0x17, 0xde, 0xba, 0xaf, 0x55, 0x7d, 0xe6, 0x31, 0x4e, 0x8b, 0xae, 0xed, 0xa9, 0xd7, 0x9c, 0xf7, 0xcb, 0x61, 0x2b, 0xa8, 0x7c, 0x7a, 0x29, 0x10, 0xa7, 0x2b, 0xa2, 0xe, 0xdf, 0x2f, 0x69, 0x27, 0xcd, 0xd6, 0xd6, 0x79, 0x2b, 0x1c, 0x79, 0x73, 0xa6, 0x4, 0xb7, 0xee, 0x96, 0x73, 0xea, 0xcf, 0xa9, 0xc0, 0x14, 0xfb, 0xd0, 0x88, 0xf3, 0x70, 0x6c, 0xd7, 0x62, 0x72, 0x71, 0x69, 0xbb, 0xae, 0xd0, 0x92, 0xd8, 0xc, 0x75, 0xb4, 0x7c, 0xff, 0xf0, 0xc6, 0xaf, 0xfd, 0x8b, 0x78, 0x83, 0xd8, 0xa8, 0xe1, 0xfe, 0x97, 0xff, 0x1f, 0xf6, 0xe6, 0xf3, 0x9c, 0xb4, 0x7d, 0x87, 0x6b, 0xba, 0xce, 0x34, 0x5e, 0x20, 0x59, 0x0, 0xec, 0xa0, 0xf6, 0xa1, 0x93, 0xc1, 0x15, 0x7, 0x48, 0xc2, 0xc5, 0xee, 0x97, 0xea, 0x88, 0x20, 0xb8, 0x46, 0xac, 0x7a, 0xf9, 0x6, 0x34, 0xaa, 0x62, 0xcb, 0x6e, 0x9b, 0xa3, 0x9c, 0x5d, 0x94, 0x43, 0x4e, 0x9d, 0xa3, 0xa5, 0x66, 0xca, 0x2a, 0x8, 0x99, 0x27, 0xaa, 0x9a, 0xc9, 0xa5, 0xe1, 0x3f, 0x2c, 0xab, 0x62, 0x4f, 0x2a, 0x72, 0x77, 0xca, 0x41, 0x5f, 0xb3, 0xcf, 0x19, 0xca, 0xdc, 0xaf, 0xe6, 0xfc, 0x58, 0x6e, 0x4, 0x39, 0xbf, 0xb1, 0x20, 0x58, 0x9c, 0x29, 0x1, 0x2c, 0x87, 0x3d, 0x5e, 0xd7, 0x51, 0xe3, 0x77, 0x27, 0xf8, 0x67, 0xd0, 0xfd, 0x4e, 0x2d, 0xfe, 0x3b, 0x3c, 0xd5, 0x39, 0x95, 0xa0, 0xf4, 0x26, 0x9a, 0x3d, 0xb4, 0x7, 0xf5, 0xac, 0xe9, 0xfc, 0xe4, 0x99, 0x98, 0x31, 0x35, 0xfe, 0x2e, 0xbc, 0x48, 0xcd, 0x7e, 0x70, 0x86, 0x80, 0x44, 0x4a, 0xfb, 0xbe, 0x55, 0x83, 0x8c, 0x92, 0xd2, 0x3b, 0xef, 0x7, 0x13, 0xa9, 0xfa, 0x38, 0x17, 0x89, 0xe7, 0x60, 0xfc, 0x64, 0xab, 0xa8, 0x45, 0x48, 0x46, 0x1f, 0x62, 0xdc, 0xf9, 0x33, 0x0, 0xbf, 0x8e, 0x1f, 0xd, 0xe9, 0xb1, 0xe2, 0xfb, 0x54, 0xf3, 0x72, 0x2e, 0x7, 0x48, 0x80, 0x27, 0x4, 0x53, 0x2a, 0x15, 0x63, 0x67, 0x98, 0x46, 0x4, 0xb6, 0x4e, 0xb4, 0x0, 0x55, 0x9e, 0x90, 0x7c, 0x1a, 0x2f, 0xf2, 0x7d, 0x3d, 0x91, 0xc5, 0x23, 0xaf, 0xb0, 0xab, 0xcc, 0xc7, 0x57, 0x5d, 0xe3, 0xc, 0x1a, 0xab, 0xcc, 0x4d, 0xa, 0xe4, 0x25, 0x9f, 0xa, 0xca, 0xc4, 0xb2, 0xed, 0xa7, 0x98, 0x97, 0xe, 0x4e, 0xe9, 0x9c, 0x39, 0xc0, 0x9e, 0x85, 0xac, 0x28, 0x1e, 0xfe, 0x13, 0x6b, 0x83, 0x5e, 0xca, 0x8f, 0xd7, 0x9, 0xd9, 0x3c, 0x13, 0x8e, 0x2c, 0x32, 0xe3, 0xd7, 0x44, 0x44, 0xaf, 0xc, 0xf0, 0x14, 0x6f, 0xa8, 0xe9, 0xc, 0x25, 0x86, 0x9e, 0xdb, 0x12, 0xed, 0x7f, 0xb8, 0x7c, 0xf1, 0x70, 0xb6, 0x5f, 0x20, 0x34, 0x31, 0xf6, 0xc7, 0x4c, 0x98, 0x2f, 0xcf, 0xdd, 0x6a, 0x7, 0x9e, 0x14, 0x87, 0xf1, 0xa8, 0xf2, 0xf1, 0xb2, 0x90, 0x25, 0x64, 0x3, 0x1a, 0x1e, 0xce, 0xfa, 0x43, 0x5b, 0x6e, 0x6a, 0x6f, 0x61, 0xbb, 0x1a, 0x8b, 0x6a, 0xc5, 0x5d, 0x6e, 0x7c, 0x87, 0x9, 0x29, 0x1f, 0x1d, 0xbf, 0x62, 0x7e, 0xa1, 0x56, 0x5f, 0x1b, 0x83, 0x4c, 0x37, 0x65, 0xce, 0x94, 0xa3, 0xa0, 0xe0, 0x12, 0xdb, 0xe7, 0xd7, 0x1, 0x46, 0xad, 0xa1, 0xc7, 0x4b, 0x8, 0xf2, 0x1c, 0x38, 0xf0, 0x5c, 0x5, 0x14, 0x9e, 0xb0, 0xe7, 0xa6, 0xcf, 0xe7, 0xc1, 0x6a, 0x19, 0x9, 0xcc, 0x3b, 0x57, 0x96, 0x76, 0x80, 0x36, 0x81, 0x31, 0x42, 0xce, 0xa6, 0x2c, 0xc4, 0x96, 0x34, 0xe0, 0x7c, 0xa2, 0xfb, 0x27, 0x47, 0x60, 0x19, 0xd3, 0xf5, 0xd3, 0x26, 0x70, 0xad, 0x88, 0x91, 0x95, 0x79, 0xb9, 0x1f, 0x79, 0x12, 0x64, 0x15, 0x89, 0x6b, 0xfe, 0x30, 0xe1, 0x6b, 0x82, 0x28, 0x9d, 0x8b, 0xc7, 0x75, 0xb5, 0xd1, 0xca, 0xbf, 0x9e, 0xc2, 0x8c, 0x4c, 0xec, 0x19, 0xe6, 0xeb, 0xc9, 0x1e, 0x40, 0x97, 0x6e, 0xd3, 0xc7, 0x9b, 0x2, 0xdb, 0xb2, 0x57, 0x45, 0x8b, 0x84, 0xcd, 0x25, 0x6c, 0xfc, 0x55, 0x9e, 0x5b, 0xe5, 0xb9, 0xee, 0x9a, 0xe2, 0x42, 0x70, 0xe1, 0x4, 0x48, 0xd4, 0x97, 0x92, 0x3a, 0x71, 0xfe, 0x42, 0x8f, 0x13, 0xfd, 0x1d, 0x9f, 0xbb, 0x49, 0xf5, 0x8e, 0xc6, 0x2c, 0x5b, 0xdd, 0xfb, 0xd3, 0x42, 0x76, 0x87, 0x2b, 0xb3, 0xe7, 0xd5, 0x5f, 0xdd, 0x16, 0x68, 0xf8, 0x85, 0x6c, 0xd0, 0x4b, 0x4f, 0x61, 0x6b, 0x7b, 0x21, 0xe2, 0xb4, 0xec, 0xa9, 0xf7, 0x27, 0x90, 0x3d, 0x93, 0x5a, 0x80, 0x75, 0xff, 0xa7, 0xf3, 0x88, 0xdf, 0x6a, 0x89, 0xf5, 0xee, 0xda, 0x1d, 0xe4, 0x6e, 0x26, 0x27, 0x5e, 0xf5, 0xe5, 0xcb, 0xb6, 0xa, 0xa, 0x74, 0x5a, 0x38, 0x58, 0x6f, 0xcb, 0x5b, 0xbd, 0x48, 0x31, 0x2e, 0x6a, 0x66, 0x55, 0x58, 0xcd, 0xf3, 0x15, 0x96, 0x9c, 0x27, 0x78, 0xf2, 0x70, 0xca, 0x2a, 0x23, 0x20, 0xab, 0x4b, 0x99, 0x8, 0xa, 0x0, 0x8c, 0x56, 0xe0, 0x5d, 0x7b, 0xaa, 0x9e, 0x82, 0xfa, 0x53, 0xb0, 0x46, 0x3d, 0x74, 0xce, 0x40, 0x9b, 0xec, 0xaa, 0xdf, 0xbe, 0x45, 0xa3, 0x66, 0x59, 0x45, 0xba, 0xc2, 0x18, 0x8d, 0x96, 0x7, 0xde, 0xf5, 0x54, 0x6b, 0xb8, 0x95, 0xe5, 0xea, 0x89, 0xea, 0x1e, 0xf, 0x77, 0xec, 0x53, 0x39, 0x29, 0xa7, 0xdb, 0x48, 0x41, 0xe, 0xab, 0xbd, 0xb3, 0x46, 0xa3, 0x9, 0xbe, 0x64, 0xdf, 0xd2, 0x7, 0xdd, 0x20, 0x70, 0x23, 0x41, 0xf1, 0x81, 0x9f, 0xaa, 0xf9, 0x38, 0x92, 0x3e, 0x44, 0xb0, 0x41, 0xf1, 0x12, 0x76, 0x79, 0x54, 0x9e, 0x3b, 0xbc, 0xcc, 0x5f, 0x8f, 0x6e, 0xc7, 0x13, 0x19, 0x52, 0x52, 0x21, 0x66, 0xb5, 0x35, 0x24, 0x20, 0xcb, 0x21, 0xc, 0x9, 0xc2, 0x3, 0x57, 0xcc, 0xaa, 0xb7, 0x9, 0x62, 0x8a, 0x92, 0xf5, 0x7c, 0x92, 0xa2, 0x1c, 0x1c, 0x9a, 0x7a, 0x7f, 0x4f, 0x83, 0xce, 0x87, 0xc6, 0x3, 0x33, 0x5, 0x81, 0x4a, 0xcc, 0x81, 0x1, 0x1, 0x37, 0x60, 0xac, 0x25, 0xdd, 0x61, 0x14, 0x8a, 0xd6, 0x3f, 0x8b, 0x96, 0xf1, 0xd6, 0x29, 0xee, 0x5f, 0x42, 0xa0, 0x9e, 0xc4, 0x13, 0x59, 0x3f, 0xa0, 0x3b, 0x60, 0xe3, 0xba, 0x22, 0x42, 0x34, 0x13, 0x32, 0xc, 0x67, 0x4a, 0x8e, 0xcb, 0x1a, 0xfe, 0xe2, 0xd6, 0xa7, 0xb0, 0x35, 0x5e, 0xb8, 0x91, 0x57, 0x9, 0xc1, 0xd4, 0xa0, 0xb4, 0x27, 0x41, 0xe2, 0x95, 0x89, 0x88, 0xec, 0xdc, 0x18, 0xab, 0xe8, 0x9a, 0xc5, 0x55, 0x54, 0x3b, 0xb9, 0xae, 0xbc, 0x35, 0x24, 0x33, 0x97, 0xf9, 0xa3, 0xf7, 0xa5, 0x3b, 0xaf, 0xfe, 0xe6, 0xba, 0xdc, 0x82, 0xd8, 0xa5, 0xd5, 0x8f, 0x20, 0x85, 0x62, 0x19, 0xf2, 0x8d, 0x56, 0x95, 0xee, 0x59, 0xbc, 0xf1, 0x4d, 0xdf, 0xd5, 0xb7, 0x3, 0xd9, 0x3f, 0x37, 0x1c, 0xb6, 0x8, 0xfe, 0x1, 0xd, 0xc9, 0x66, 0x88, 0x6, 0xb, 0x59, 0xc1, 0x85, 0xb0, 0x43, 0xdd, 0x84, 0x40, 0x55, 0x8b, 0xf6, 0x97, 0x5f, 0xa7, 0xb7, 0x93, 0x33, 0x50, 0xfd, 0x69, 0xd7, 0xf, 0x9c, 0x9c, 0x1b, 0x89, 0x67, 0x5f, 0x4b, 0x8, 0xcc, 0xb7, 0xcc, 0xf6, 0x7c, 0xa4, 0x57, 0xab, 0x33, 0x8f, 0x74, 0x4a, 0xd9, 0xd5, 0x95, 0x8e, 0x8e, 0xf5, 0x1f, 0x32, 0x3, 0xf8, 0xd7, 0xe, 0x5, 0xc2, 0x8, 0xa3, 0x10, 0xad, 0x2e, 0xd9, 0x89, 0x8b, 0x16, 0x1, 0xec, 0x3b, 0xf5, 0x69, 0x3b, 0x2, 0xa, 0xbd, 0x7f, 0xe2, 0xb5, 0x1, 0x99, 0x1, 0xb1, 0x1d, 0x74, 0x7, 0xf1, 0x31, 0x82, 0x31, 0x1c, 0xb4, 0xe7, 0xe2, 0x36, 0x85, 0x42, 0x10, 0x6e, 0x3, 0xb5, 0xb3, 0xb8, 0x64, 0xa4, 0x26, 0x49, 0x48, 0x59, 0x15, 0xb2, 0x58, 0x4c, 0x62, 0xfe, 0xae, 0x5, 0xc0, 0x47, 0xb1, 0xea, 0xd2, 0x30, 0x32, 0x45, 0xc3, 0x45, 0xd, 0x7e, 0x87, 0x2b, 0xf3, 0xd3, 0xa6, 0x5d, 0x9e, 0x6a, 0xc6, 0xdd, 0x62, 0x3d, 0x53, 0xf8, 0x79, 0x0, 0xa, 0x35, 0x56, 0xd4, 0x67, 0x60, 0xd0, 0x54, 0x8a, 0x55, 0x2b, 0x83, 0xad, 0xc9, 0x17, 0xec, 0x86, 0x17, 0xe9, 0x53, 0xf4, 0xd8, 0x40, 0x64, 0xe3, 0xa4, 0x8a, 0x79, 0x52, 0x91, 0x24, 0xe, 0xce, 0x56, 0xdb, 0xed, 0xad, 0x22, 0xd0, 0x5c, 0x78, 0x75, 0x2a, 0xcd, 0xd3, 0xb5, 0x85, 0x4f, 0xe5, 0x9c, 0x21, 0x7e, 0xfa, 0x6f, 0x53, 0x8d, 0x15, 0xee, 0x1a, 0x78, 0xb5, 0xc4, 0x79, 0x1b, 0x6, 0x5, 0x7e, 0x59, 0x3b, 0x3b, 0xb7, 0x54, 0xaa, 0xad, 0xc0, 0x8d, 0x71, 0xf7, 0x91, 0x3a, 0x22, 0x2, 0xd5, 0x3c, 0x8b, 0xd1, 0xd8, 0x3b, 0x21, 0x42, 0xde, 0x9b, 0x70, 0xab, 0xfc, 0x4, 0x36, 0x31, 0x2c, 0x1c, 0x59, 0x19, 0x3f, 0x63, 0xe2, 0xd2, 0x9, 0xf1, 0xd5, 0xf1, 0xf8, 0x1f, 0xb4, 0xe8, 0xfb, 0x13, 0x4f, 0x65, 0x68, 0x87, 0xa7, 0x1f, 0x68, 0xc0, 0x73, 0x23, 0xfc, 0x53, 0x4c, 0xf6, 0xac, 0xce, 0x14, 0x4c, 0x4f, 0x7c, 0x7c, 0x41, 0x81, 0x8b, 0x18, 0xe7, 0x6e, 0x15, 0xc1, 0xc0, 0x25, 0x8e, 0x5b, 0xc6, 0x38, 0x87, 0xdc, 0xea, 0x5f, 0x99, 0x73, 0x8b, 0xe8, 0x5c, 0xb1, 0xf4, 0xc9, 0xfd, 0xf1, 0xfa, 0xeb, 0xc5, 0x34, 0xae, 0x8a, 0x28, 0x5c, 0x80, 0xf1, 0x3b, 0x2e, 0x20, 0x8c, 0x5f, 0xe4, 0xaf, 0xba, 0xf5, 0xf6, 0xc3, 0x8e, 0xcc, 0xcb, 0xc8, 0xb1, 0xe9, 0xaf, 0xda, 0xda, 0x59, 0x12, 0x47, 0xba, 0x7, 0xf1, 0x6b, 0xa9, 0xe4, 0xe3, 0x6f, 0x94, 0xe, 0x56, 0x98, 0x34, 0xf1, 0xf8, 0xc, 0xbc, 0xa9, 0xce, 0x8e, 0x3e, 0xdd, 0x4c, 0xaf, 0x4d, 0x32, 0xd3, 0x7e, 0xf4, 0x52, 0x64, 0x86, 0x4b, 0x36, 0xa2, 0x9e, 0x17, 0x29, 0xb2, 0xab, 0x9a, 0xed, 0xc, 0x45, 0xb, 0x45, 0xf9, 0xd6, 0x0, 0xe7, 0x73, 0xda, 0x9d, 0x6c, 0x5f, 0x78, 0x0, 0x55, 0x30, 0x6e, 0xaa, 0x6d, 0x19, 0xe7, 0xaa, 0xaf, 0xa8, 0xf4, 0x14, 0x28, 0x24, 0x73, 0x60, 0xfe, 0x13, 0xbd, 0xd8, 0x73, 0xbb, 0xc7, 0x49, 0xdc, 0xb5, 0x9, 0xb0, 0x2a, 0x76, 0xe7, 0x9e, 0x2f, 0x2e, 0x52, 0x8e, 0x4f, 0x38, 0x1b, 0x7b, 0xb3, 0xae, 0x24, 0xb2, 0x6f, 0xa3, 0x2a, 0x21, 0xd7, 0x72, 0x3e, 0xcb, 0x98, 0x53, 0xc1, 0xb6, 0x6, 0xa5, 0x4f, 0x14, 0xb8, 0x81, 0xba, 0xb0, 0xc, 0x22, 0x31, 0xc7, 0x70, 0x44, 0x86, 0x56, 0x15, 0x1f, 0x7e, 0xd9, 0xe4, 0x79, 0x56, 0x0, 0x12, 0x2c, 0x2f, 0xc4, 0x59, 0xc8, 0x72, 0xcf, 0x53, 0xe8, 0xe, 0x42, 0x41, 0x22, 0x8, 0x82, 0x5, 0x47, 0x8, 0xca, 0x33, 0xb2, 0xf3, 0xb4, 0xf2, 0x1f, 0xa3, 0x84, 0x88, 0x4c, 0x81, 0x5, 0x12, 0xab, 0x5e, 0xea, 0x4b, 0x66, 0x12, 0xd3, 0xe4, 0xde, 0xf6, 0x4, 0xd, 0x9e, 0x5f, 0x36, 0x3, 0xe6, 0xea, 0xc7, 0x3c, 0x73, 0xcb, 0x79, 0xcd, 0x54, 0x4, 0x35, 0xad, 0xa4, 0xa5, 0xd9, 0xb8, 0x2d, 0xf4, 0x54, 0x5b, 0x69, 0xee, 0xf, 0x48, 0x40, 0xd2, 0x95, 0x4e, 0x2, 0x3b, 0x48, 0xda, 0x4, 0x44, 0x56, 0x4f, 0xa3, 0xff, 0x42, 0x59, 0xb7, 0xd8, 0xa2, 0xf, 0xcb, 0x66, 0x24, 0x1c, 0x6f, 0x6, 0x41, 0x26, 0x69, 0xce, 0xfb, 0x3c, 0x8b, 0x9e, 0x9e, 0xa, 0x83, 0xe9, 0xca, 0xa, 0xc7, 0x44, 0xec, 0x7a, 0x26, 0xd8, 0x96, 0xcd, 0x43, 0xe9, 0x94, 0x58, 0x82, 0x78, 0xa5, 0x6d, 0xd5, 0x82, 0x7e, 0x25, 0x39, 0xb5, 0x5f, 0x8d, 0xd9, 0xf1, 0x21, 0x72, 0x55, 0x27, 0xb0, 0x76, 0x23, 0xd4, 0x87, 0x6a, 0xde, 0xde, 0xcb, 0xfe, 0xb, 0x4b, 0xd4, 0x15, 0x10, 0xbd, 0x30, 0xe3, 0xaa, 0xb2, 0x53, 0x9, 0x88, 0x44, 0xc6, 0xa, 0xb, 0x59, 0x8e, 0x69, 0xdb, 0x2e, 0x1c, 0xdd, 0xd7, 0x7a, 0x96, 0x4d, 0xb8, 0x43, 0x37, 0x56, 0xb5, 0xf9, 0x54, 0x45, 0x3a, 0x2a, 0xe8, 0x62, 0xf, 0xab, 0xe6, 0x73, 0x7b, 0x61, 0x5d, 0xc4, 0x0, 0x6d, 0x3, 0x32, 0x7d, 0xf0, 0x4e, 0x65, 0xc8, 0xe8, 0x9, 0x46, 0xd9, 0xfe, 0x5a, 0xe5, 0xff, 0x38, 0xa5, 0x82, 0x32, 0xee, 0xeb, 0xe8, 0x57, 0x97, 0xa0, 0xd3, 0x32, 0xb5, 0x5b, 0x21, 0x77, 0xb, 0x10, 0x1, 0x53, 0x79, 0xa9, 0xa5, 0x29, 0x44, 0x4, 0xf4, 0xd3, 0x56, 0xee, 0xee, 0xa4, 0x7c, 0x12, 0x9e, 0x40, 0xb6, 0x1, 0x4c, 0x19, 0xf8, 0x4c, 0xc1, 0xb9, 0x6e, 0x34, 0x45, 0x93, 0x5a, 0xed, 0x67, 0xab, 0x3a, 0x1a, 0xa5, 0x3d, 0xba, 0x57, 0xa, 0xa0, 0xf2, 0x9b, 0xa1, 0x9b, 0x2a, 0xe1, 0xa6, 0xc4, 0x8e, 0x34, 0x5f, 0x39, 0xa1, 0xe1, 0xa2, 0x8b, 0x2b, 0xf6, 0x37, 0x72, 0x3e, 0xb7, 0x8, 0xd9, 0x89, 0xeb, 0x25, 0xde, 0xcd, 0xea, 0x9e, 0xca, 0xe0, 0xb2, 0xb2, 0xd9, 0x3f, 0xdd, 0xcc, 0x68, 0x37, 0x7e, 0xa3, 0xfc, 0xd2, 0xa9, 0x38, 0x6b, 0xc, 0xec, 0x68, 0x93, 0xbc, 0x3a, 0x57, 0x86, 0x7b, 0x2e, 0x48, 0x20, 0x1a, 0x6c, 0x1, 0x9a, 0xde, 0xfd, 0xf, 0x5, 0x55, 0x3b, 0x5, 0x54, 0xb9, 0x38, 0xd7, 0x44, 0x87, 0x2d, 0x6, 0x1f, 0xac, 0x64, 0x9a, 0x68, 0xd8, 0x34, 0xca, 0x52, 0xa4, 0x75, 0x2a, 0xb4, 0xb3, 0x64, 0x71, 0xc5, 0xd4, 0xc6, 0x57, 0x54, 0x86, 0x8c, 0x3, 0x1f, 0xc3, 0x5d, 0x80, 0x50, 0xe5, 0xe, 0x80, 0x39, 0x60, 0xf8, 0x17, 0x5f, 0xf0, 0xba, 0xcc, 0x8, 0x64, 0x4b, 0x51, 0xd3, 0x16, 0xdc, 0xfd, 0x99, 0x82, 0xd0, 0x76, 0xa6, 0xa2, 0xcb, 0xad, 0xf7, 0x0, 0x61, 0x67, 0xfa, 0xbc, 0x77, 0x53, 0x8, 0x4b, 0x7f, 0x75, 0xc1, 0x38, 0xb0, 0x59, 0xf1, 0x45, 0xa6, 0x68, 0xc5, 0x99, 0x57, 0x63, 0x7b, 0xb8, 0xf7, 0xab, 0xef, 0xb8, 0x92, 0x2d, 0x50, 0x9f, 0xef, 0xbc, 0xdd, 0x35, 0x7f, 0x15, 0xed, 0xf1, 0xf6, 0x2b, 0xb1, 0x6b, 0x94, 0xb6, 0xa1, 0xe7, 0xb4, 0xe3, 0x53, 0x25, 0x6d, 0xbe, 0x17, 0xb2, 0xa4, 0x66, 0xe6, 0xc4, 0xad, 0x72, 0xd2, 0x5a, 0x17, 0x7a, 0xc3, 0x33, 0xbe, 0x50, 0x5d, 0xb8, 0xba, 0xfd, 0x92, 0x44, 0xb5, 0x6, 0x8b, 0xa7, 0xd4, 0xdd, 0x28, 0x3e, 0xe0, 0x84, 0x59, 0xbd, 0x47, 0xb2, 0x27, 0x6f, 0x3c, 0x25, 0xda, 0xc5, 0xd7, 0x0, 0x1e, 0xbd, 0xe, 0x88, 0x92, 0xbe, 0xf4, 0xf0, 0xf1, 0x72, 0x72, 0xdb, 0xc7, 0xd, 0x15, 0xb6, 0x26, 0xe3, 0x64, 0x3e, 0x16, 0x64, 0xcb, 0x7b, 0xcb, 0x5c, 0xb6, 0x52, 0x1c, 0xc, 0xc8, 0xe2, 0xe0, 0x83, 0x57, 0xff, 0xc3, 0xa3, 0x29, 0xc7, 0x2d, 0xff, 0x9b, 0x4f, 0x0, 0x9, 0xa3, 0x1, 0x19, 0x31, 0xa1, 0x63, 0x0, 0x20, 0xad, 0x83, 0xdf, 0x6a, 0x80, 0x3d, 0xc1, 0x1d, 0xed, 0xa4, 0x48, 0x26, 0x2, 0x6, 0x47, 0x5f, 0xd7, 0xb2, 0xd0, 0xc4, 0xae, 0x80, 0x57, 0xee, 0x93, 0x58, 0xac, 0x8e, 0xfe, 0xfe, 0xad, 0xd2, 0x83, 0x5d, 0xe0, 0xee, 0x6d, 0x8f, 0x5a, 0x25, 0x93, 0xb7, 0xea, 0xb, 0xd5, 0xf8, 0xa7, 0xfb, 0xd, 0x0, 0x3e, 0x5c, 0x17, 0x5e, 0x40, 0x80, 0xef, 0x77, 0xfc, 0xef, 0xe8, 0xc3, 0x4f, 0xd0, 0x9a, 0xc0, 0xc5, 0x62, 0x1e, 0x3, 0x4b, 0xa4, 0x75, 0xde, 0x9d, 0xde, 0x49, 0xd2, 0xd8, 0xd, 0xde, 0x83, 0x6e, 0x6a, 0x75, 0xe9, 0xb2, 0x57, 0xe4, 0x63, 0x73, 0xac, 0x2c, 0xd1, 0xc8, 0x1f, 0x88, 0x98, 0xcf, 0xe8, 0xb2, 0xda, 0xb0, 0x5d, 0x35, 0xc4, 0x4, 0x47, 0x7c, 0x13, 0x30, 0x34, 0x38, 0xea, 0xdc, 0xd2, 0x50, 0x2e, 0xca, 0xb5, 0x68, 0x9c, 0x3b, 0xb, 0x1, 0xcc, 0x61, 0x28, 0xd2, 0x77, 0x84, 0xbb, 0x28, 0x3e, 0xd8, 0x88, 0x8b, 0x20, 0x41, 0x60, 0x36, 0x1d, 0xae, 0x14, 0xae, 0xc9, 0x7c, 0xbc, 0xd8, 0x1a, 0x9c, 0x1c, 0xdf, 0xb3, 0x72, 0xa5, 0x43, 0xfb, 0xe7, 0xc0, 0x31, 0x46, 0x13, 0xfa, 0x7a, 0x11, 0x49, 0x22, 0x1a, 0x16, 0x9f, 0x58, 0xf2, 0x6c, 0xf, 0x0, 0x86, 0x14, 0x12, 0x92, 0xb1, 0xb, 0x91, 0x24, 0xd9, 0x11, 0x23, 0xd9, 0x50, 0x74, 0xe5, 0x3e, 0xa0, 0x29, 0x80, 0x1e, 0x6b, 0x18, 0x7e, 0x5d, 0x28, 0xd8, 0x3e, 0xc9, 0xa, 0xd5, 0x1c, 0x80, 0xd9, 0xb3, 0x50, 0x81, 0x3c, 0xc0, 0x19, 0xc7, 0xe5, 0xa2, 0xbe, 0x39, 0xbf, 0xce, 0xa0, 0x2b, 0xf0, 0x8b, 0x86, 0x5e, 0x6b, 0x31, 0xc3, 0x2, 0xf4, 0x9, 0x1, 0x66, 0xae, 0x3a, 0x62, 0x4f, 0x19, 0xa2, 0x19, 0xdd, 0x7e, 0x6e, 0xcb, 0xb2, 0x95, 0x78, 0xbc, 0x96, 0xa9, 0x19, 0xe0, 0x4b, 0x65, 0xd, 0x79, 0x4f, 0xd1, 0x7c, 0x81, 0xee, 0x27, 0xae, 0x97, 0x45, 0x59, 0x39, 0x72, 0x7f, 0xfe, 0xcf, 0x7b, 0xf3, 0x67, 0x89, 0xba, 0x34, 0xb0, 0x4e, 0x88, 0x92, 0xfd, 0x22, 0x36, 0xd6, 0x40, 0x2c, 0x80, 0x88, 0x4e, 0xef, 0xc9, 0x38, 0x8d, 0xe1, 0x62, 0x1c, 0x74, 0x6d, 0x66, 0x35, 0x82, 0x30, 0x5b, 0x6a, 0x7b, 0x3e, 0x1d, 0x88, 0x54, 0xaf, 0xd6, 0x33, 0x97, 0x85, 0x76, 0x9d, 0x4a, 0xbe, 0x41, 0x1b, 0x9f, 0x99, 0xa, 0x42, 0xa5, 0xef, 0x9b, 0x43, 0xc8, 0xf5, 0xc4, 0x59, 0xd5, 0x5, 0x59, 0xf6, 0x16, 0x90, 0xd7, 0x81, 0x6d, 0x43, 0xca, 0x9b, 0x15, 0xbf, 0xc4, 0xc5, 0xdd, 0x5a, 0x2f, 0x52, 0x5, 0x27, 0x72, 0x9b, 0xb1, 0x87, 0xc1, 0x4c, 0xb4, 0x94, 0x88, 0x51, 0x42, 0xbc, 0xce, 0x3d, 0x9d, 0x17, 0x37, 0xee, 0x57, 0x51, 0x8a, 0x1c, 0xbb, 0x8e, 0x91, 0x94, 0xdd, 0x9d, 0x27, 0x27, 0x6e, 0x87, 0x5e, 0xde, 0xae, 0xc9, 0x31, 0xb1, 0x22, 0x7b, 0xda, 0x3b, 0xec, 0x2f, 0x7c, 0x3f, 0xf, 0x56, 0x90, 0xc5, 0xde, 0x5e, 0x9d, 0xb8, 0xac, 0xed, 0x68, 0xb0, 0x96, 0x3d, 0x35, 0x53, 0x5e, 0x6f, 0x89, 0x62, 0xff, 0x45, 0x26, 0x4b, 0x1, 0x12, 0xb8, 0x8c, 0x9b, 0xfc, 0x92, 0x12, 0x2, 0x7d, 0xe6, 0x46, 0x8e, 0x86, 0xf1, 0xac, 0x63, 0x2d, 0x4c, 0x8b, 0x26, 0x4a, 0xd1, 0xee, 0xfc, 0xf2, 0xf5, 0x97, 0x1a, 0xcf, 0xea, 0xe6, 0xb8, 0x92, 0x56, 0x17, 0x3, 0x48, 0x14, 0xcb, 0x3c, 0x96, 0x10, 0xe3, 0xb3, 0x42, 0x84, 0xad, 0x38, 0xfa, 0xdd, 0x7, 0xde, 0xf4, 0x91, 0xdd, 0xfd, 0x66, 0xf, 0x4a, 0x54, 0x88, 0xc, 0x6b, 0x71, 0xd9, 0xda, 0xff, 0x18, 0xb5, 0xae, 0x53, 0xa7, 0x27, 0x4a, 0xa6, 0xf6, 0x2c, 0x9a, 0xbc, 0xe4, 0x53, 0x8e, 0x5c, 0xc7, 0x6e, 0x9f, 0xd8, 0xb2, 0x71, 0x77, 0x8f, 0xb8, 0x58, 0x7f, 0x15, 0x4b, 0xfb, 0xe, 0xd9, 0x8e, 0x20, 0xa4, 0xa5, 0xe5, 0x8d, 0x21, 0xc7, 0x20, 0x1e, 0x70, 0xd2, 0x68, 0xa7, 0x44, 0xfb, 0x9d, 0xaa, 0x1a, 0x3d, 0xbe, 0xe5, 0x1, 0xc6, 0x55, 0x2e, 0xe5, 0xeb, 0x7e, 0x98, 0xfb, 0x42, 0x6d, 0xec, 0xb5, 0xdb, 0x87, 0x71, 0xf0, 0xd1, 0xe8, 0x69, 0x2a, 0xb8, 0xfc, 0xa7, 0xb6, 0x2a, 0x5b, 0x14, 0x9, 0x3d, 0xb3, 0xa, 0xc6, 0x85, 0x18, 0xcf, 0x72, 0x8f, 0xa8, 0x75, 0x76, 0x77, 0xb6, 0x7b, 0x95, 0xa7, 0x32, 0xd8, 0x31, 0x7d, 0x47, 0xa6, 0x15, 0xeb, 0x67, 0x72, 0x81, 0x7e, 0x89, 0xaa, 0x52, 0x39, 0x40, 0xb9, 0xb0, 0x8a, 0xa5, 0x3, 0xe7, 0x4a, 0x5d, 0x75, 0x5e, 0x8c, 0x26, 0x74, 0x80, 0xb5, 0x7f, 0x39, 0x8b, 0xac, 0x10, 0xfc, 0x87, 0x17, 0x68, 0x8d, 0x23, 0xa7, 0x37, 0x82, 0x2f, 0x7a, 0x3, 0x1a, 0x3e, 0x2, 0x99, 0x38, 0x96, 0xc5, 0x73, 0x24, 0xb0, 0xc0, 0x49, 0xe0, 0xd0, 0xa3, 0xb6, 0xec, 0x32, 0xbf, 0x78, 0xdc, 0x16, 0xd5, 0x43, 0x6b, 0x10, 0xa3, 0x98, 0x81, 0x12, 0xac, 0x87, 0xae, 0xa1, 0x64, 0xc0, 0x61, 0x2d, 0xac, 0xd8, 0xfa, 0xc6, 0xad, 0xe0, 0x9e, 0xaa, 0x14, 0xb4, 0x43, 0x52, 0x4d, 0xad, 0xc6, 0x96, 0x57, 0xf, 0x8b, 0xb9, 0x21, 0x9f, 0xda, 0x4a, 0xf0, 0x4d, 0xda, 0xbc, 0xc8, 0x3b, 0xec, 0x86, 0xa4, 0xe3, 0x7, 0x88, 0x24, 0x23, 0x37, 0xc1, 0x7d, 0x72, 0x1d, 0xb5, 0xfa, 0x20, 0x88, 0x83, 0xd2, 0xf0, 0xa, 0xf1, 0xd1, 0x59, 0x9c, 0xd5, 0x8d, 0x80, 0xdf, 0xea, 0xce, 0x67, 0xf1, 0x80, 0xea, 0x89, 0x53, 0xf9, 0x2c, 0x16, 0xbd, 0xa7, 0xe6, 0x20, 0x31, 0x2c, 0xf4, 0x59, 0x9b, 0x48, 0x7, 0xa7, 0x5, 0xc5, 0x3, 0x54, 0xd8, 0xdc, 0xdc, 0x2d, 0x4b, 0x51, 0x8c, 0xd6, 0x62, 0x25, 0xbc, 0x9c, 0x90, 0xbd, 0x33, 0x83, 0x16, 0x3b, 0x24, 0xef, 0xf6, 0xde, 0x76, 0x8e, 0xab, 0xd7, 0x7e, 0x6e, 0xbf, 0xa2, 0xc2, 0xed, 0xae, 0xbc, 0xe4, 0x6e, 0x58, 0xed, 0x8b, 0x85, 0x8b, 0x55, 0xed, 0x87, 0xfb, 0x14, 0xe3, 0x48, 0x9b, 0xa1, 0x18, 0x61, 0xed, 0x4, 0x34, 0xd1, 0xc3, 0xc4, 0xd2, 0x9, 0xd, 0x28, 0xbf, 0x72, 0xec, 0xd2, 0x52, 0xdf, 0x9d, 0xc3, 0x4b, 0xdc, 0x41, 0xdd, 0x40, 0x90, 0x49, 0x81, 0x1f, 0xab, 0x93, 0x25, 0x4b, 0x23, 0x95, 0x27, 0x12, 0x44, 0x77, 0x2d, 0xbd, 0xb5, 0x94, 0xe2, 0xda, 0x7, 0x69, 0x6, 0xd0, 0xe0, 0xf8, 0x5a, 0x2, 0x5b, 0x2f, 0xf3, 0xc6, 0xec, 0x10, 0x88, 0xc5, 0xc3, 0x7f, 0x85, 0xb9, 0x2f, 0x6e, 0xe7, 0xdb, 0x41, 0xf7, 0xc8, 0x67, 0xe3, 0x5b, 0x1a, 0xae, 0x99, 0xa4, 0xe6, 0xb6, 0xf, 0x73, 0x4e, 0x1, 0xe5, 0x98, 0xb, 0x60, 0x80, 0x22, 0xef, 0x24, 0x39, 0xd5, 0x82, 0x68, 0x5e, 0x5e, 0x12, 0x32, 0xb2, 0x5c, 0x71, 0xbc, 0xed, 0x4a, 0x91, 0xe3, 0xac, 0xee, 0xd3, 0xe6, 0xa1, 0x48, 0x8d, 0x8b, 0x58, 0x2d, 0x10, 0xb7, 0x97, 0x1e, 0x98, 0x71, 0xe5, 0xac, 0x2e, 0x69, 0x36, 0xef, 0x2d, 0x55, 0x35, 0x3d},
+               output224: []byte{0x9b, 0xdb, 0xeb, 0x56, 0xbb, 0xf0, 0x60, 0xfd, 0x4, 0xe8, 0x54, 0xc7, 0x48, 0xa, 0x64, 0x6a, 0xca, 0x77, 0xc8, 0xee, 0x8a, 0x60, 0xae, 0x7, 0xa2, 0xce, 0x6d, 0x7c},
+               output256: []byte{0xc6, 0xc2, 0x5c, 0xfb, 0x97, 0xe8, 0x5b, 0x3d, 0x59, 0xc5, 0xf7, 0xce, 0xae, 0xf6, 0xd0, 0x6f, 0xc3, 0x14, 0xc0, 0xb2, 0x3f, 0x37, 0xc3, 0xc0, 0x45, 0x48, 0x90, 0x82, 0x1a, 0x9c, 0xc8, 0x16},
+               output384: []byte{0xbd, 0x9c, 0x83, 0xb7, 0x53, 0xe6, 0xce, 0xab, 0x4e, 0x92, 0xdf, 0x62, 0x6f, 0x64, 0x70, 0xf8, 0x81, 0xb5, 0x85, 0xbc, 0xee, 0xd8, 0x95, 0x9e, 0x51, 0x2d, 0x3a, 0x23, 0x8a, 0xc2, 0xd5, 0x81, 0xfe, 0x42, 0x94, 0xbd, 0x8e, 0xf, 0x69, 0xf8, 0x64, 0x72, 0x56, 0xcc, 0x29, 0xa9, 0x39, 0x3f},
+               output512: []byte{0xcc, 0xa3, 0x47, 0xe, 0xf3, 0xca, 0xfc, 0x49, 0xc2, 0x3f, 0x74, 0xc8, 0xeb, 0xed, 0x8, 0x12, 0x75, 0x71, 0x3a, 0x8e, 0x5c, 0xea, 0x53, 0xd5, 0x90, 0x83, 0x5, 0x52, 0xe6, 0x69, 0x8f, 0xeb, 0x7f, 0xb9, 0xde, 0x3f, 0x72, 0x81, 0x17, 0x64, 0x68, 0xa1, 0xd6, 0xf3, 0x7d, 0xb7, 0xe4, 0xc1, 0x0, 0x68, 0x3a, 0x1a, 0x51, 0xda, 0x23, 0x3f, 0x90, 0x3b, 0x8, 0x2a, 0xbf, 0x64, 0x8d, 0xaa}},
+       testcase{
+               msg:       []byte{0x16, 0x33, 0x25, 0x6a, 0xb0, 0x3b, 0x20, 0xce, 0x7, 0x91, 0x96, 0xb7, 0x8, 0xa1, 0xc0, 0x2d, 0x1b, 0x60, 0x72, 0x21, 0x90, 0x70, 0x71, 0x2c, 0x85, 0x89, 0xee, 0x21, 0x34, 0x1d, 0x50, 0x75, 0x2a, 0xcb, 0x6c, 0xfd, 0xa1, 0x7e, 0x98, 0x2d, 0x82, 0x8b, 0xbd, 0x6c, 0xdf, 0x54, 0xbc, 0x72, 0x32, 0xfd, 0x41, 0x8a, 0x32, 0x3d, 0x64, 0x93, 0x99, 0x28, 0x59, 0x7b, 0x9b, 0x52, 0xf0, 0x7c, 0xf4, 0x88, 0x25, 0xc, 0x5e, 0x42, 0xbf, 0xd3, 0xab, 0x48, 0x1, 0x2d, 0x70, 0x9f, 0x8d, 0x74, 0x72, 0x25, 0x83, 0x92, 0x96, 0x38, 0x6f, 0xce, 0x5f, 0xc5, 0xae, 0xcc, 0x4b, 0xa7, 0xa1, 0x7, 0x6d, 0x8, 0x9d, 0xea, 0x8e, 0xce, 0xfa, 0xa0, 0xcf, 0x66, 0xfc, 0xa8, 0x60, 0x23, 0x95, 0x71, 0x9c, 0x12, 0xa0, 0x4f, 0x92, 0x93, 0x21, 0x78, 0x4d, 0x7a, 0xb8, 0x23, 0x9f, 0xce, 0x2f, 0xf3, 0xbd, 0xae, 0x4, 0x6a, 0x26, 0x61, 0x32, 0xb5, 0xc2, 0xad, 0x9f, 0x72, 0x61, 0xf3, 0x1, 0x4e, 0x87, 0xb3, 0x89, 0xa6, 0x69, 0x59, 0x78, 0x69, 0x3d, 0x93, 0x71, 0xd0, 0xb1, 0xff, 0x9c, 0x40, 0x5f, 0x33, 0x8c, 0x2f, 0xde, 0x46, 0x87, 0x35, 0x96, 0x3, 0x95, 0xa, 0x54, 0xcf, 0x4b, 0x9c, 0xdd, 0x9b, 0x24, 0x48, 0xb, 0x23, 0x9a, 0xcc, 0x54, 0x5, 0xc1, 0x4c, 0x88, 0x6b, 0xbb, 0x3, 0x78, 0x39, 0x1c, 0xef, 0x6, 0x62, 0xa3, 0x88, 0x82, 0xbd, 0xd0, 0x9e, 0x38, 0x66, 0xab, 0x9a, 0x66, 0xcf, 0xbd, 0x28, 0xeb, 0x5e, 0xe4, 0xf8, 0x0, 0x9b, 0xde, 0xfc, 0x4a, 0xeb, 0x16, 0x70, 0xe, 0xba, 0x7d, 0xc5, 0x57, 0xb4, 0x89, 0x19, 0xa, 0x71, 0xfd, 0xa7, 0x5e, 0x85, 0xf7, 0xef, 0x84, 0x16, 0x97, 0xf7, 0xf, 0xfd, 0x4f, 0xea, 0x18, 0x5e, 0x7a, 0x67, 0xc8, 0x1c, 0x5b, 0x8f, 0x27, 0x3b, 0xfb, 0x97, 0xb2, 0xce, 0xf6, 0x95, 0xc1, 0xc7, 0x44, 0x46, 0xc4, 0xb4, 0x25, 0xbe, 0x6b, 0x2e, 0x66, 0xdc, 0xa, 0xaa, 0xcb, 0x24, 0x7e, 0x44, 0x67, 0xb7, 0xc7, 0xd8, 0x4e, 0xc3, 0x3b, 0x6b, 0x5a, 0xb8, 0xfa, 0x19, 0x79, 0xf5, 0x3, 0x0, 0x8b, 0xdc, 0xff, 0x94, 0x8c, 0xdb, 0xf1, 0x22, 0x6b, 0x1b, 0x6, 0x6c, 0xbc, 0xf3, 0x47, 0x97, 0x29, 0x8f, 0x3b, 0xa8, 0xc6, 0xf, 0xa0, 0x1e, 0xa, 0xc8, 0xb8, 0x3, 0x22, 0x3c, 0x65, 0x61, 0x12, 0xfb, 0x91, 0x43, 0x5d, 0x75, 0x45, 0x3b, 0xae, 0x47, 0x7, 0xb6, 0x33, 0x30, 0x46, 0x7d, 0xd1, 0x3e, 0xa, 0x4b, 0x99, 0x2e, 0x6f, 0x7e, 0x46, 0x99, 0x58, 0x99, 0xa2, 0xd9, 0x5d, 0x23, 0xf4, 0xac, 0x3d, 0x8, 0x2, 0xb2, 0xa6, 0xe7, 0xd0, 0x24, 0xde, 0xa1, 0x9c, 0xa4, 0x8, 0xc4, 0xbb, 0xe0, 0x53, 0xf1, 0x4c, 0x9c, 0xe2, 0x64, 0xf1, 0x29, 0x72, 0x4a, 0x18, 0xbc, 0xb1, 0x8f, 0x38, 0x5b, 0x1c, 0xa0, 0x91, 0xa1, 0x14, 0x34, 0xea, 0x96, 0xd9, 0x8c, 0x8d, 0x6, 0x2, 0xe9, 0x8e, 0xdc, 0x8d, 0xfa, 0x14, 0x14, 0x1a, 0xf9, 0x3e, 0xd0, 0xba, 0x66, 0xe8, 0x85, 0xe9, 0xfa, 0x10, 0x85, 0x91, 0xae, 0x59, 0xe1, 0x9, 0xae, 0x34, 0xd6, 0xb9, 0xf5, 0x58, 0x6e, 0x4b, 0x4d, 0x75, 0xe7, 0xdf, 0x7c, 0x32, 0x95, 0x8a, 0x65, 0xe8, 0x8a, 0x9b, 0xaf, 0x41, 0x8, 0x2a, 0xa, 0x3f, 0x11, 0x53, 0x9d, 0xc4, 0xea, 0x2c, 0xbd, 0x9e, 0x1c, 0x6c, 0x3c, 0x43, 0x9b, 0x62, 0x2f, 0x1d, 0xe5, 0x74, 0xfa, 0x75, 0x47, 0xc, 0x8c, 0x93, 0x9b, 0x51, 0xd2, 0xd1, 0xc2, 0xa7, 0x20, 0x4b, 0x85, 0x98, 0x81, 0xd4, 0x30, 0x86, 0xbf, 0xd8, 0xfb, 0x90, 0x34, 0x62, 0x18, 0xd0, 0x99, 0xc5, 0xab, 0x36, 0x84, 0x6f, 0x3b, 0x98, 0xa7, 0xc8, 0x47, 0x31, 0x8b, 0xdf, 0xa0, 0x1e, 0x9, 0x71, 0x79, 0x43, 0xfc, 0xd8, 0x64, 0xc5, 0xa8, 0xa1, 0x7b, 0x6c, 0xeb, 0x89, 0xd9, 0x8e, 0x87, 0x2d, 0x38, 0x8f, 0x20, 0xad, 0xc2, 0xbe, 0x5e, 0x20, 0x6, 0x84, 0x69, 0x4, 0xf4, 0x16, 0x82, 0xfb, 0x12, 0x83, 0x21, 0x4f, 0x3d, 0x20, 0xdb, 0xc9, 0xfc, 0x9e, 0xf, 0xf5, 0x71, 0x84, 0x4a, 0x12, 0x82, 0xe8, 0x85, 0x90, 0xd7, 0xc0, 0x85, 0xb2, 0xc5, 0x68, 0xec, 0x5a, 0xcc, 0x44, 0x62, 0xb3, 0x89, 0xfe, 0xaa, 0x57, 0x57, 0xf7, 0x3, 0x31, 0x87, 0xe2, 0xde, 0x31, 0x95, 0x5f, 0xce, 0x55, 0xfe, 0xdc, 0x90, 0x92, 0x55, 0x4, 0x8b, 0x32, 0x7c, 0xca, 0xb2, 0xe5, 0x82, 0xbb, 0xc9, 0xd8, 0x5, 0x4b, 0xf5, 0xcb, 0x45, 0x14, 0x5c, 0x7d, 0x3a, 0x3a, 0xf9, 0xcd, 0x5c, 0xf6, 0xec, 0xba, 0x49, 0xc, 0x63, 0x4e, 0xcf, 0x0, 0xe6, 0x46, 0xbf, 0x95, 0xe8, 0x64, 0x2c, 0x43, 0xa4, 0x97, 0x8e, 0xf0, 0x8a, 0x57, 0x4e, 0xf1, 0xf7, 0x8f, 0x6c, 0xe5, 0x7c, 0x3b, 0x34, 0xb5, 0xa1, 0x23, 0xd1, 0x23, 0x61, 0x7f, 0xc8, 0xec, 0x9b, 0x2a, 0xc0, 0xf9, 0xb7, 0xa, 0x7f, 0x60, 0x62, 0xd3, 0x8d, 0xd7, 0xb8, 0xe9, 0xfb, 0x4e, 0xcc, 0xef, 0x13, 0xde, 0xd5, 0xc0, 0x47, 0x74, 0x83, 0xad, 0xda, 0xe4, 0xf1, 0xcc, 0xc, 0xfc, 0xa2, 0x74, 0xb1, 0x30, 0x7e, 0xd0, 0xde, 0x72, 0xfb, 0xcb, 0x81, 0x91, 0x54, 0xcd, 0xa8, 0x97, 0xd7, 0x57, 0x52, 0x13, 0x4, 0x26, 0x15, 0xf1, 0x74, 0x1a, 0x8c, 0xb6, 0x46, 0xa3, 0x9f, 0x8d, 0x13, 0x4f, 0xdf, 0x9e, 0x60, 0xe0, 0x0, 0xeb, 0x82, 0x20, 0xf6, 0x5c, 0xc3, 0xf, 0x5f, 0xa5, 0x2c, 0x43, 0x1b, 0x9e, 0x3b, 0x61, 0x1, 0xb9, 0x6e, 0x25, 0xb8, 0xd0, 0x44, 0xb, 0x96, 0xe5, 0x72, 0xa1, 0x8a, 0x1, 0x74, 0x7c, 0x2, 0xaf, 0xcd, 0x75, 0x13, 0x54, 0x2f, 0x7a, 0xac, 0xe1, 0x94, 0x63, 0x20, 0x99, 0xd1, 0x62, 0x74, 0xf3, 0x1e, 0xba, 0xbb, 0x60, 0xdd, 0xd9, 0x4f, 0xe4, 0x3d, 0xac, 0xce, 0x90, 0xe, 0xc0, 0x90, 0x2e, 0xb5, 0xe6, 0x86, 0xd4, 0x8e, 0xd8, 0xd0, 0x9a, 0xe6, 0x3d, 0xa0, 0xe1, 0x5c, 0x73, 0x68, 0x9, 0x90, 0x3a, 0x2, 0x97, 0xa9, 0x2d, 0xe8, 0x4e, 0x2, 0x60, 0xf1, 0x1f, 0x44, 0x6e, 0x1f, 0xc4, 0x48, 0xe0, 0xeb, 0xf5, 0x9f, 0xae, 0xa3, 0xc7, 0x26, 0xf9, 0x79, 0x25, 0xc5, 0x7c, 0xbd, 0xf8, 0x5b, 0x1f, 0x77, 0x7, 0x8d, 0x36, 0x25, 0x7c, 0x85, 0xd5, 0x6c, 0xbb, 0xed, 0xce, 0x18, 0xf, 0xe1, 0x2b, 0x68, 0x7a, 0xda, 0x2d, 0xc9, 0x91, 0x2f, 0xac, 0x60, 0x33, 0x41, 0x66, 0xbd, 0x2c, 0xef, 0x6, 0xb0, 0x89, 0xed, 0x5c, 0x95, 0x63, 0x84, 0x4d, 0x71, 0xd8, 0xfe, 0xad, 0x2f, 0x3a, 0x93, 0xf3, 0xc0, 0x7c, 0x52, 0x53, 0x73, 0x36, 0xa8, 0xa7, 0xb, 0xf5, 0xb5, 0x96, 0xb9, 0x0, 0x7b, 0x9f, 0xdf, 0x2d, 0x8, 0x20, 0x0, 0xf2, 0xe, 0x6b, 0x70, 0xd2, 0xa7, 0xe6, 0xc7, 0xed, 0x27, 0xc4, 0x14, 0x68, 0x95, 0xa6, 0xd8, 0x5a, 0x24, 0x6f, 0x62, 0x3c, 0x1b, 0x92, 0x58, 0xa2, 0xf8, 0x91, 0xf8, 0x23, 0xad, 0xe4, 0xce, 0xff, 0xd5, 0x9d, 0x4f, 0xfa, 0xd0, 0x77, 0x35, 0x1e, 0x2f, 0x50, 0x6e, 0x9a, 0x5b, 0xdd, 0x39, 0x0, 0xf0, 0x20, 0x4b, 0x9e, 0x89, 0x69, 0xaf, 0xe7, 0x2f, 0x5d, 0xcc, 0xb9, 0xcd, 0xf9, 0x86, 0xd1, 0x97, 0xae, 0x4c, 0x4d, 0xb5, 0x30, 0x14, 0x4, 0x1a, 0xe6, 0x22, 0x1b, 0x75, 0xe, 0x52, 0x90, 0xe3, 0x7, 0xad, 0x29, 0x2c, 0x8d, 0xe6, 0xb8, 0x99, 0x23, 0x52, 0x12, 0xef, 0x8c, 0xe9, 0x54, 0x78, 0x55, 0x37, 0xdc, 0x94, 0x35, 0xaf, 0x11, 0xe0, 0xf3, 0x42, 0x7a, 0x9c, 0x7b, 0x22, 0xef, 0xa7, 0x52, 0xea, 0xb, 0x7e, 0xad, 0xe5, 0xf6, 0xeb, 0x40, 0x93, 0xba, 0xcb, 0x78, 0x67, 0x6e, 0x50, 0x66, 0x98, 0x13, 0x9e, 0x4f, 0x77, 0x44, 0x23, 0xb8, 0x94, 0x21, 0x66, 0xf9, 0xa7, 0xd2, 0x24, 0x80, 0xd8, 0x14, 0xfc, 0xa, 0xe1, 0x9c, 0xf4, 0x96, 0xf, 0xbf, 0x6e, 0x1, 0xff, 0xa6, 0x5c, 0x8d, 0xa5, 0xbe, 0xd4, 0xf1, 0xae, 0x2b, 0x9e, 0xce, 0xc5, 0xbe, 0x7b, 0x3c, 0x38, 0xdd, 0x40, 0x45, 0xb0, 0xc9, 0x3e, 0xe6, 0xcc, 0x77, 0xa7, 0xe6, 0x1e, 0x85, 0xd3, 0x31, 0xb2, 0x3c, 0xd, 0x16, 0x4b, 0x10, 0x45, 0x18, 0xb3, 0x40, 0x54, 0x97, 0x5, 0x44, 0x45, 0xa3, 0x53, 0xe9, 0xb4, 0x8f, 0x2a, 0xc5, 0xe8, 0xe9, 0x62, 0x98, 0xd6, 0x65, 0x56, 0x14, 0x33, 0x6c, 0xff, 0xe6, 0xd8, 0xc9, 0xc9, 0x15, 0xe3, 0x87, 0x39, 0x15, 0x19, 0xad, 0x26, 0x32, 0x36, 0x6a, 0xa3, 0xbc, 0x93, 0x50, 0x30, 0xfd, 0x12, 0x92, 0x7e, 0xfc, 0xa1, 0x75, 0x5, 0xed, 0x74, 0xc9, 0x46, 0x50, 0xc7, 0x78, 0x53, 0x90, 0x4, 0x85, 0x4d, 0xf6, 0xc2, 0x42, 0x69, 0xaa, 0xb9, 0xc2, 0x73, 0xa4, 0x93, 0xd3, 0xe5, 0xb0, 0xb1, 0xd6, 0x87, 0xc3, 0x3c, 0x2f, 0xac, 0xe4, 0x6b, 0x4b, 0xb3, 0x74, 0x2d, 0x6d, 0xf7, 0x43, 0xd0, 0x91, 0x64, 0xd2, 0xe0, 0xee, 0x7f, 0x6b, 0xa1, 0x28, 0xbd, 0x5f, 0xba, 0x2e, 0x3b, 0x33, 0xc1, 0x99, 0xae, 0x80, 0xfa, 0x9d, 0xee, 0x3a, 0xd8, 0x11, 0xd0, 0x2b, 0xaa, 0x3d, 0x42, 0xa6, 0x36, 0x2b, 0x2a, 0xd4, 0x7b, 0xba, 0x8a, 0x2c, 0x5c, 0xd0, 0xb, 0x46, 0xcf, 0x22, 0xcf, 0xe3, 0x67, 0x28, 0x14, 0x88, 0xa4, 0x85, 0x2e, 0xb8, 0xb7, 0xfa, 0xce, 0x79, 0xf0, 0xca, 0x6f, 0x8e, 0x78, 0xd3, 0x25, 0x78, 0xdf, 0xee, 0x1, 0x71, 0x1c, 0x4d, 0xcf, 0x3c, 0x26, 0xd0, 0xba, 0x13, 0xf3, 0x7, 0x54, 0x78, 0xe7, 0x8, 0xc5, 0xc5, 0x31, 0x5a, 0xfd, 0xc2, 0xe4, 0xc0, 0x6, 0x2d, 0x16, 0x45, 0x82, 0x13, 0xbe, 0xc5, 0x6, 0xa9, 0xe9, 0x91, 0xa6, 0x18, 0x25, 0xff, 0x78, 0xda, 0x9b, 0xa1, 0xba, 0xab, 0xbe, 0xfa, 0x56, 0xb4, 0xa8, 0xc9, 0xe2, 0xe7, 0xb6, 0xe, 0xc4, 0xb7, 0xb5, 0x41, 0xc8, 0xe0, 0xf7, 0x9c, 0x86, 0xbb, 0x5f, 0x3, 0xf7, 0x36, 0x76, 0x1a, 0x37, 0x16, 0x9b, 0x2a, 0xab, 0x88, 0x84, 0xec, 0x6e, 0xa2, 0x17, 0xb0, 0x2c, 0x59, 0x3, 0x5f, 0x5b, 0xb3, 0x27, 0x24, 0x3d, 0x12, 0x6b, 0x78, 0xd4, 0xaa, 0xb4, 0x30, 0x21, 0x24, 0x39, 0xb5, 0xa7, 0x5b, 0x80, 0x61, 0x8d, 0xaf, 0xeb, 0x66, 0xaa, 0x3a, 0xff, 0x86, 0x6c, 0x4d, 0xae, 0xe4, 0x7d, 0x37, 0x4b, 0x51, 0x2e, 0x74, 0xad, 0xa9, 0x33, 0xef, 0x24, 0xa8, 0x41, 0xba, 0x27, 0x1c, 0x6f, 0x2, 0xc8, 0x70, 0xe8, 0xab, 0x95, 0xf, 0xe0, 0x6e, 0x93, 0xc9, 0x1d, 0xf0, 0xe9, 0x91, 0x65, 0xdc, 0x1, 0xbc, 0xb1, 0x90, 0xe4, 0x11, 0xec, 0xcd, 0x85, 0x35, 0x8f, 0xd4, 0xa8, 0x81, 0x27, 0xa2, 0x2e, 0x4c, 0xf4, 0x26, 0x6a, 0x90, 0x84, 0x51, 0x24, 0xbf, 0x97, 0xb2, 0x5d, 0x7b, 0x1c, 0x46, 0xd3, 0xa0, 0xd6, 0x8a, 0x68, 0x4f, 0x84, 0xe2, 0xa6, 0x38, 0xc6, 0x92, 0xa5, 0x2c, 0xb6, 0xe8, 0xc6, 0x51, 0xa3, 0xac, 0x49, 0x2b, 0x4, 0x60, 0x0, 0x40, 0x73, 0xd5, 0x34, 0x9e, 0x35, 0x55, 0x23, 0x59, 0xca, 0x37, 0x66, 0xf, 0x77, 0xb2, 0x77, 0xd, 0x6b, 0x2b, 0x3f, 0x7b, 0x19, 0x22, 0x42, 0x4a, 0xc4, 0xa8, 0x59, 0x8b, 0x4c, 0x61, 0xa6, 0xdb, 0x50, 0x76, 0x8, 0xa7, 0x2a, 0x6a, 0x7d, 0x57, 0x3c, 0xc0, 0x55, 0x20, 0x62, 0x76, 0xe1, 0x40, 0x5, 0xa2, 0x8a, 0xe, 0xc4, 0x1f, 0x28, 0xd7, 0xe2, 0x60, 0x61, 0x1d, 0x40, 0xf0, 0x89, 0xff, 0xe5, 0xe5, 0x29, 0x37, 0x56, 0x91, 0x41, 0x2f, 0x4e, 0x9e, 0x12, 0xe6, 0x2c, 0x3b, 0xe2, 0xc5, 0x63, 0xc2, 0x6d, 0x24, 0x44, 0xea, 0x9c, 0x69, 0xe6, 0xc9, 0x35, 0xfe, 0xb4, 0xdc, 0x4e, 0x80, 0x2e, 0x5f, 0xe3, 0x90, 0x6f, 0x8a, 0xce, 0xf4, 0x79, 0x8d, 0x94, 0xc, 0x3c, 0xd5, 0x74, 0xbb, 0x5e, 0x74, 0x50, 0x6c, 0x3e, 0xb, 0x70, 0xcb, 0x62, 0x45, 0x4a, 0x25, 0xf5, 0x89, 0xea, 0xdb, 0x6b, 0x7, 0x9, 0xfe, 0x3b, 0x50, 0x41, 0x7c, 0xd1, 0xd9, 0x8f, 0x8, 0xe0, 0x8b, 0x7c, 0xf6, 0x8a, 0x4, 0xcc, 0xcf, 0x8d, 0x65, 0x88, 0xf9, 0xfc, 0x2f, 0x31, 0xe5, 0x33, 0xcd, 0xa6, 0x15, 0x9b, 0xaa, 0x42, 0x97, 0xfa, 0x44, 0x64, 0x50, 0xd7, 0x1c, 0x16, 0xea, 0x23, 0x24, 0xec, 0x9, 0x77, 0x3e, 0x7c, 0x88, 0x17, 0xec, 0xf6, 0x80, 0xed, 0x12, 0xf6, 0x4a, 0x4, 0x86, 0x3e, 0xfe, 0x3d, 0x9d, 0x87, 0x60, 0xf3, 0x4d, 0xe5, 0xb0, 0x86, 0xb, 0x39, 0x91, 0xff, 0xe, 0xe5, 0xed, 0xba, 0x22, 0xc4, 0xd6, 0x91, 0x20, 0xde, 0x19, 0xd5, 0x42, 0x9e, 0x4a, 0xae, 0x91, 0xc9, 0xe7, 0xcf, 0x5, 0xcc, 0x80, 0x71, 0x59, 0xa5, 0x8f, 0x13, 0xb4, 0x80, 0x87, 0x2a, 0xc1, 0x60, 0x9d, 0x87, 0xe7, 0x0, 0x9d, 0xed, 0xb7, 0x1c, 0x9, 0xce, 0xaa, 0xb6, 0x40, 0xa2, 0xb6, 0x13, 0x58, 0x55, 0xce, 0xae, 0x4a, 0xc2, 0x95, 0x49, 0x33, 0xa0, 0x25, 0x5b, 0x42, 0x5d, 0x9f, 0xdc, 0xd9, 0xc2, 0x46, 0xf8, 0x2a, 0xeb, 0x7c, 0x3b, 0xb7, 0x8c, 0x6e, 0x73, 0xe0, 0x3d, 0xb7, 0xae, 0xc4, 0x24, 0x5a, 0x28, 0x69, 0x3f, 0xbd, 0x36, 0xef, 0x49, 0x38, 0xd5, 0x9c, 0xce, 0x19, 0xea, 0xfc, 0x0, 0x67, 0x1a, 0x8, 0x51, 0x61, 0x24, 0x6, 0xa0, 0x75, 0x71, 0x3c, 0x5d, 0x11, 0x54, 0xd8, 0xe1, 0x3b, 0x59, 0xb7, 0xc5, 0xb0, 0x90, 0x22, 0x39, 0xd4, 0xba, 0xcf, 0xa3, 0x86, 0xac, 0x81, 0x7a, 0xc5, 0xee, 0x2, 0xa1, 0x81, 0xa9, 0xa4, 0x7c, 0x62, 0x2b, 0x3e, 0xcf, 0x28, 0x7e, 0x14, 0x84, 0x3d, 0x45, 0x2a, 0xf3, 0x47, 0x11, 0x4, 0x98, 0xa6, 0x20, 0xb3, 0x4a, 0xb4, 0xe1, 0x16, 0x30, 0x8d, 0x97, 0x60, 0x62, 0xc9, 0xee, 0x9c, 0xd3, 0x5d, 0xb6, 0xcb, 0x79, 0x80, 0x5b, 0x93, 0xac, 0x9a, 0x15, 0xaf, 0xbc, 0xb5, 0x2f, 0x1e, 0xd4, 0x30, 0x98, 0x79, 0xd1, 0x92, 0x4a, 0x4b, 0xa1, 0x90, 0xb0, 0xb8, 0x6e, 0x60, 0xa5, 0x16, 0xe7, 0x7d, 0x34, 0xb4, 0xe0, 0xa4, 0x9d, 0x4e, 0xf2, 0xce, 0xf3, 0xcc, 0x2f, 0x41, 0xf, 0xd8, 0xec, 0x90, 0x13, 0x63, 0xfc, 0x9e, 0xbd, 0x75, 0xeb, 0x46, 0xd, 0x4d, 0x89, 0x10, 0xbd, 0xf2, 0x7c, 0xe2, 0x6a, 0x8b, 0x4a, 0xeb, 0x94, 0xf9, 0xf7, 0x62, 0x42, 0x40, 0x1d, 0xc3, 0x5d, 0x6, 0x44, 0x84, 0x2b, 0x99, 0xfb, 0x6c, 0x43, 0x9b, 0x82, 0xd8, 0x2e, 0xcf, 0xe1, 0xaf, 0xd, 0x1, 0xf9, 0xbe, 0xcb, 0x15, 0xbe, 0xc8, 0x3f, 0x13, 0xb2, 0x60, 0xf7, 0xf7, 0x14, 0xaa, 0x38, 0x10, 0x32, 0x92, 0x3f, 0xde, 0x8f, 0x80, 0x18, 0xf3, 0x51, 0x85, 0x47, 0x45, 0x14, 0x35, 0xc9, 0xa5, 0x20, 0x72, 0x94, 0xd0, 0x8a, 0x90, 0x7c, 0x73, 0x69, 0x6f, 0x6c, 0xb0, 0x0, 0x74, 0x5e, 0x7, 0x2e, 0x25, 0xb7, 0x3b, 0x3e, 0xe1, 0x15, 0x95, 0x43, 0x3d, 0x27, 0xa1, 0xf1, 0x14, 0x68, 0x68, 0x6f, 0x8, 0x9, 0x4f, 0x1d, 0x31, 0xf5, 0xad, 0xa8, 0x1f, 0x11, 0xf0, 0x67, 0x7a, 0x29, 0xd7, 0x2e, 0xbb, 0x2e, 0x1c, 0x47, 0x92, 0xcc, 0xc6, 0x7, 0xcb, 0x93, 0x86, 0x47, 0xe1, 0xf1, 0x53, 0xf9, 0xee, 0xf0, 0x3d, 0x98, 0x25, 0x95, 0xc6, 0x31, 0xe4, 0x9b, 0x6b, 0x7c, 0x1f, 0xa0, 0x3, 0xa6, 0xeb, 0x8d, 0x59, 0xcb, 0x88, 0x92, 0xcd, 0x8, 0x88, 0xb0, 0x52, 0x40, 0xf1, 0x27, 0x1, 0x75, 0x3f, 0x89, 0x0, 0x7c, 0x85, 0x95, 0x15, 0xa2, 0xfe, 0xf9, 0x44, 0xbc, 0x60, 0xb3, 0x60, 0x3, 0xa2, 0x67, 0x2, 0xac, 0x6f, 0xe0, 0x4d, 0x2e, 0x94, 0x29, 0x78, 0xfc, 0x31, 0xa9, 0x7e, 0xb2, 0x98, 0x71, 0xd6, 0x75, 0x23, 0x99, 0xd3, 0x52, 0x17, 0x20, 0x72, 0x90, 0x7, 0xb6, 0xa7, 0x21, 0x5a, 0x42, 0x82, 0xb2, 0xa4, 0xef, 0xc2, 0xc5, 0x6b, 0xd1, 0x29, 0xe7, 0x4c, 0x9b, 0x0, 0x84, 0x76, 0x92, 0xb9, 0x6f, 0xcc, 0x71, 0xcf, 0x7a, 0x7f, 0x19, 0xf3, 0xfd, 0x6b, 0x45, 0xc5, 0x19, 0xfd, 0x73, 0xb4, 0x86, 0x8, 0x80, 0xa2, 0xdd, 0x74, 0xe5, 0x72, 0x7b, 0x31, 0xa9, 0x3f, 0xa, 0x87, 0xf0, 0x7, 0x81, 0x55, 0x34, 0x4a, 0xe9, 0xf7, 0xbd, 0xbf, 0x0, 0xd8, 0x33, 0x93, 0xb6, 0x34, 0xb5, 0xdc, 0xa8, 0x8a, 0x39, 0x8e, 0x42, 0xc3, 0x20, 0xeb, 0x95, 0xc4, 0xa8, 0x26, 0xac, 0xea, 0x90, 0xb6, 0x5e, 0x47, 0x67, 0xb2, 0xeb, 0xa7, 0x48, 0xf9, 0x7c, 0x24, 0x75, 0x68, 0x39, 0x3e, 0x2f, 0xd3, 0xa6, 0x60, 0x75, 0xcc, 0x12, 0x93, 0x5b, 0x6d, 0x7e, 0xb5, 0xc2, 0xff, 0x52, 0x82, 0x18, 0x5c, 0xb6, 0x2c, 0x73, 0x97, 0x2a, 0x37, 0xb3, 0xca, 0x50, 0x80, 0x4, 0xb4, 0xf7, 0x96, 0xbd, 0xf8, 0x2b, 0x83, 0xb5, 0xbd, 0xf9, 0xd, 0x6b, 0xfd, 0x32, 0xb5, 0x8, 0x9b, 0xc, 0xa2, 0x68, 0x3d, 0xc7, 0xfb, 0x23, 0x37, 0xde, 0x42, 0xe6, 0x50, 0xed, 0x91, 0x1d, 0xbe, 0xe1, 0xef, 0x98, 0x25, 0x7f, 0x9b, 0xa5, 0xaf, 0x54, 0xb1, 0xa5, 0x4b, 0x4, 0xc0, 0x8, 0x7a, 0x5a, 0x64, 0xba, 0x77, 0x9d, 0x86, 0x46, 0x1b, 0xa1, 0x53, 0x37, 0xc2, 0xe7, 0xd4, 0x95, 0x5f, 0xdd, 0x77, 0x7a, 0x2, 0x5d, 0xe2, 0x26, 0x30, 0x6a, 0x17, 0xc3, 0x84, 0xf1, 0xc5, 0x2c, 0xdb, 0x59, 0x46, 0xfb, 0xb, 0x46, 0xdd, 0x5c, 0x13, 0xbd, 0x7a, 0x55, 0xfe, 0x2e, 0x27, 0xe4, 0xc6, 0xd4, 0xd, 0x61, 0xd6, 0xff, 0xc0, 0x24, 0x46, 0x8f, 0x8e, 0xdf, 0xc7, 0xc7, 0x99, 0x2d, 0xf5, 0xdc, 0x5d, 0x5, 0x6, 0x3f, 0xe7, 0x23, 0x19, 0x92, 0x24, 0xf5, 0x36, 0x78, 0xe4, 0x8f, 0x25, 0x25, 0xe, 0xa2, 0x8b, 0xdf, 0x10, 0x89, 0x71, 0x8e, 0xb8, 0xb7, 0x30, 0xd1, 0xc0, 0x67, 0x35, 0xc2, 0xf8, 0x71, 0x16, 0x4e, 0x2e, 0xb5, 0xe8, 0x85, 0xa8, 0xdf, 0xd2, 0xa0, 0x83, 0xbe, 0x97, 0xed, 0xc9, 0x41, 0x59, 0xce, 0x9b, 0xf7, 0x5d, 0x24, 0x33, 0xf1, 0xd7, 0x82, 0x76, 0x2f, 0x77, 0x19, 0x3, 0xcb, 0xf9, 0xa1, 0xc9, 0xd1, 0x3f, 0x71, 0xb, 0xa0, 0xe1, 0x51, 0xb0, 0x79, 0xdc, 0xa, 0x82, 0x62, 0xbc, 0xeb, 0x1d, 0xbc, 0xbb, 0xc0, 0xf3, 0x5d, 0xf6, 0xee, 0xcf, 0x7b, 0xaa, 0x71, 0x5, 0xb9, 0x80, 0x87, 0x45, 0x85, 0x3c, 0x96, 0xb4, 0x37, 0x2e, 0x95, 0xe4, 0x82, 0x3, 0x59, 0x16, 0xb7, 0x26, 0xda, 0xc7, 0xbe, 0x95, 0xa7, 0x2b, 0x19, 0xda, 0xd4, 0x8d, 0xb1, 0xb1, 0x9e, 0x6e, 0xb2, 0xed, 0xab, 0x5a, 0xc1, 0xb3, 0x1, 0x38, 0x39, 0xe7, 0x80, 0x66, 0x25, 0xab, 0xc1, 0x29, 0xf4, 0x18, 0x13, 0xe6, 0xd7, 0x1e, 0xe4, 0xab, 0x20, 0x40, 0xd8, 0x1e, 0x42, 0xe6, 0xed, 0x73, 0xab, 0xba, 0x64, 0xff, 0x2e, 0xb4, 0x33, 0xb9, 0x10, 0xea, 0x7d, 0x4f, 0x5e, 0xd3, 0xd8, 0xd2, 0x7d, 0x39, 0xbb, 0x45, 0x4e, 0xc0, 0x19, 0xdf, 0x61, 0x14, 0xf5, 0x44, 0xd7, 0xb1, 0x55, 0x54, 0x9d, 0xc, 0x56, 0xd1, 0x45, 0x51, 0xfa, 0xf3, 0x53, 0x99, 0x4a, 0x80, 0xf3, 0xf, 0x3c, 0x97, 0xe8, 0x63, 0xa4, 0xf2, 0xaf, 0x31, 0x64, 0x68, 0xa5, 0x68, 0x3, 0x8e, 0xb4, 0xd7, 0x99, 0x35, 0xa, 0x6f, 0xac, 0xaf, 0xf9, 0xe, 0xcd, 0x44, 0xe0, 0xf4, 0x4e, 0xfb, 0x6d, 0xc4, 0x2e, 0xe4, 0xb0, 0xdc, 0x2c, 0x59, 0xea, 0x9c, 0x18, 0x27, 0x32, 0x6d, 0xf0, 0x8c, 0xa, 0x6e, 0x55, 0xcf, 0x4f, 0x9c, 0x3e, 0xa0, 0xe7, 0x8c, 0xff, 0x36, 0x35, 0xf5, 0xd0, 0x8e, 0x44, 0xf1, 0x40, 0xd, 0x20, 0xf6, 0x38, 0xd5, 0x6b, 0xa8, 0x4b, 0x48, 0x32, 0x9, 0x4, 0x54, 0xde, 0x57, 0xef, 0x4, 0xb6, 0xc8, 0x80, 0x5a, 0x36, 0xf6, 0x3e, 0x5c, 0xcc, 0x6e, 0x83, 0xc, 0x87, 0xff, 0xc1, 0x64, 0x64, 0x7c, 0xed, 0x20, 0xe4, 0xc4, 0x86, 0xd0, 0x9d, 0xe7, 0xa5, 0xf9, 0xe4, 0xb6, 0x8d, 0x54, 0x56, 0xcd, 0xb2, 0x2b, 0xd, 0xde, 0xd2, 0xb9, 0x5b, 0x3b, 0xca, 0xe5, 0x29, 0x21, 0x5c, 0x2d, 0x25, 0xd6, 0x82, 0x3c, 0x7d, 0x66, 0xa4, 0xfa, 0xe0, 0xa1, 0xe9, 0xf0, 0x22, 0xba, 0x56, 0x63, 0x20, 0x4f, 0x23, 0x14, 0xdf, 0xa5, 0x1a, 0x1f, 0x10, 0xe1, 0x1d, 0x6d, 0x62, 0xa8, 0xba, 0x6c, 0x28, 0xb6, 0xae, 0x7d, 0xa1, 0xde, 0xb5, 0xb5, 0x7f, 0x2b, 0x65, 0xd7, 0x45, 0x60, 0x59, 0xad, 0x9f, 0x3, 0xdc, 0x5a, 0x52, 0x40, 0x54, 0xda, 0x39, 0xdd, 0x10, 0xd, 0x74, 0xeb, 0x65, 0x7d, 0xe2, 0x19, 0x79, 0x5e, 0x3c, 0x45, 0xa0, 0xe4, 0xc7, 0x62, 0xba, 0x22, 0xf9, 0xda, 0x9d, 0x81, 0x59, 0xe4, 0x25, 0xa1, 0xee, 0x78, 0x3b, 0x4b, 0x22, 0xc2, 0x50, 0xd8, 0x89, 0x4c, 0xbe, 0xc7, 0x6, 0xce, 0x16, 0xd5, 0xca, 0x39, 0x34, 0x4, 0xff, 0x47, 0x8f, 0x14, 0x1b, 0xe7, 0xcc, 0x69, 0xe4, 0x5b, 0x7, 0x7b, 0xa1, 0x95, 0x5f, 0x1f, 0x49, 0xef, 0xbe, 0x48, 0x47, 0xc7, 0x95, 0x34, 0x7f, 0x70, 0x33, 0x0, 0xf6, 0x72, 0x33, 0x4f, 0x49, 0xa, 0xbf, 0x8b, 0x64, 0x4a, 0x34, 0xb5, 0x6d, 0xa0, 0xe, 0xc4, 0x5a, 0x35, 0x3, 0x14, 0xb9, 0xad, 0xf2, 0x7c, 0xaf, 0x7c, 0x51, 0xcb, 0x7d, 0xba, 0xc, 0x54, 0x77, 0xe7, 0xd3, 0x76, 0x62, 0xf4, 0xf2, 0x32, 0x47, 0xbc, 0xb8, 0xf7, 0xdd, 0x5f, 0x3e, 0x9c, 0xb8, 0xbd, 0xa4, 0xf, 0xa9, 0x75, 0x68, 0x83, 0x2a, 0xf0, 0xad, 0xc6, 0x8f, 0x71, 0x42, 0x2e, 0x41, 0x22, 0x54, 0xa6, 0xbf, 0xc8, 0x94, 0x3b, 0xb4, 0x65, 0xb0, 0x1f, 0xcc, 0x8d, 0xe0, 0xb9, 0x57, 0x67, 0x7c, 0x78, 0xbc, 0x1f, 0x75, 0x66, 0x95, 0x3e, 0x9d, 0x24, 0x46, 0x23, 0x9f, 0x60, 0x2c, 0x68, 0x2a, 0x52, 0x1c, 0x14, 0xf7, 0x41, 0xfe, 0xa9, 0x8c, 0x7e, 0x27, 0xaa, 0xbe, 0xc3, 0x39, 0xb6, 0xf5, 0xb9, 0x4c, 0x78, 0x28, 0x7a, 0x89, 0x4a, 0xfd, 0xae, 0x97, 0x1f, 0x8d, 0xa7, 0xc7, 0xe4, 0xa4, 0xc9, 0x2c, 0x8d, 0xa4, 0x7b, 0xe8, 0x2d, 0xc2, 0x53, 0x2e, 0xc2, 0xda, 0x9b, 0xac, 0xed, 0xd2, 0xbe, 0x6d, 0xb2, 0xb2, 0xfb, 0x34, 0xdc, 0xcd, 0xcb, 0x34, 0x11, 0x65, 0x7, 0x37, 0x65, 0x78, 0xcb, 0xca, 0x10, 0x5e, 0x5e, 0x44, 0x3b, 0xec, 0xf, 0x2e, 0xf2, 0x3b, 0xe3, 0x4c, 0xdf, 0x86, 0x2e, 0xda, 0xb3, 0x4f, 0xf, 0xf2, 0x13, 0x35, 0xe3, 0xac, 0xd9, 0x2f, 0x59, 0x68, 0x8b, 0x41, 0x9f, 0x82, 0x4e, 0xa6, 0x1e, 0xea, 0x82, 0xbc, 0x80, 0xe3, 0x46, 0x34, 0x52, 0x19, 0x23, 0x77, 0x13, 0x1b, 0xa5, 0x1f, 0xb0, 0x79, 0x5e, 0x8, 0x9f, 0xc0, 0x77, 0xd0, 0xec, 0xa8, 0x1, 0x2e, 0x58, 0xb0, 0x63, 0x7a, 0xd7, 0x2, 0x22, 0x6, 0x88, 0x7f, 0xe9, 0xec, 0x0, 0xee, 0x5d, 0xf7, 0xad, 0x2e, 0x26, 0xfe, 0x81, 0x9e, 0xe3, 0x5c, 0x7a, 0x17, 0x9c, 0x57, 0x90, 0x98, 0xaa, 0x3d, 0xf6, 0x45, 0xd9, 0x6, 0x4c, 0xd5, 0x57, 0xda, 0x90, 0xbd, 0xd2, 0x1f, 0x87, 0x1c, 0xeb, 0x4, 0x8c, 0xa5, 0x6d, 0xf9, 0x65, 0x3a, 0x10, 0xed, 0x60, 0xf5, 0xe9, 0xf0, 0xed, 0x7f, 0x8d, 0x89, 0xbc, 0xf5, 0xc2, 0x2d, 0x11, 0x43, 0xcf, 0x44, 0x71, 0x8f, 0xf2, 0xdf, 0xd8, 0xe1, 0xc, 0xef, 0x8a, 0xab, 0xb6, 0x7d, 0x23, 0x5, 0xf1, 0x81, 0x77, 0xc1, 0x42, 0x6b, 0xd4, 0xcd, 0x3, 0xf2, 0x62, 0x5e, 0x45, 0x9c, 0xe9, 0x5, 0x6, 0x78, 0x26, 0xa2, 0x14, 0xe0, 0x8e, 0x56, 0xd8, 0xf9, 0x45, 0x55, 0x93, 0xe6, 0xb3, 0x24, 0xe7, 0x2d, 0xed, 0xcc, 0x42, 0x9d, 0x3b, 0xef, 0xe2, 0xae, 0x5, 0x99, 0xe3, 0x60, 0xdf, 0x95, 0xe8, 0xd, 0x45, 0x3a, 0x3a, 0x84, 0x9e, 0x48, 0x38, 0x9f, 0xa7, 0x45, 0x63, 0x5b, 0xed, 0xe3, 0xe, 0x79, 0x32, 0xde, 0x6a, 0x38, 0x16, 0xe3, 0x1a, 0x22, 0x17, 0xf9, 0x8d, 0x5e, 0x40, 0x23, 0x89, 0x63, 0xd0, 0xa3, 0x6c, 0x15, 0x9f, 0xd4, 0xec, 0x32, 0xd8, 0xa5, 0xcf, 0x59, 0xd4, 0x33, 0xde, 0xf3, 0x37, 0x86, 0x34, 0xaf, 0x68, 0x87, 0xfd, 0xb3, 0xf3, 0xed, 0xb9, 0x6f, 0xc8, 0x84, 0xf, 0xe1, 0xb5, 0x38, 0xc3, 0x29, 0x67, 0x4a, 0xe8, 0x10, 0xe8, 0xc8, 0xb2, 0xb4, 0x6d, 0xb2, 0x8, 0x71, 0x6d, 0x38, 0xe9, 0xd1, 0xae, 0xab, 0x9, 0x70, 0x68, 0xad, 0x83, 0xad, 0xd7, 0xdd, 0x26, 0x47, 0x83, 0x9b, 0x3a, 0x73, 0x88, 0xb0, 0x61, 0x5b, 0xde, 0x26, 0xf8, 0x69, 0x2e, 0x9c, 0x7, 0xd8, 0xad, 0xec, 0xc2, 0xa8, 0x75, 0x20, 0x3c, 0x3d, 0x3a, 0x9c, 0x6c, 0xb1, 0xd7, 0xd0, 0x63, 0x7, 0xe9, 0xe1, 0xd9, 0xc3, 0xbc, 0x53, 0x6d, 0xd8, 0xeb, 0x27, 0x1e, 0x9a, 0x21, 0x59, 0xc9, 0x4, 0xe6, 0x1e, 0x8c, 0x93, 0x57, 0xfe, 0x75, 0x9f, 0x36, 0x36, 0x6a, 0xef, 0x5a, 0x3d, 0x14, 0xce, 0xe8, 0x29, 0x13, 0xcd, 0x27, 0x8, 0xaa, 0x60, 0x69, 0x36, 0x9c, 0xed, 0x76, 0x3c, 0x8e, 0x83, 0xd, 0x70, 0x92, 0x4e, 0x82, 0xe9, 0x1, 0x5c, 0x29, 0x98, 0xe8, 0x6e, 0xfc, 0x1d, 0xce, 0x6a, 0xc2, 0xeb, 0xcb, 0x49, 0x45, 0x55, 0x42, 0xa6, 0xd7, 0xda, 0xb2, 0x65, 0xad, 0x6d, 0x73, 0x81, 0xff, 0xee, 0xe1, 0xaa, 0x40, 0xf8, 0xfa, 0xc0, 0x65, 0x9b, 0x6f, 0xb5, 0x6b, 0xb0, 0x3c, 0xd8, 0xca, 0xfa, 0xac, 0xd4, 0x8d, 0x13, 0x67, 0x2f, 0x7d, 0x52, 0x4e, 0xb9, 0x68, 0x4c, 0xfe, 0xd4, 0xdb, 0xb7, 0x47, 0x6e, 0x99, 0x14, 0x9c, 0x28, 0xec, 0x8, 0xf3, 0x3b, 0xa6, 0xaf, 0xf8, 0x39, 0xaa, 0x17, 0x8f, 0x86, 0xb8, 0xee, 0xaf, 0x17, 0x39, 0xc8, 0x29, 0x17, 0x7b, 0xa7, 0x85, 0x47, 0xad, 0x39, 0x41, 0x36, 0xaa, 0x3f, 0xad, 0x45, 0x1a, 0x11, 0xe9, 0x64, 0x25, 0x6, 0x56, 0x8b, 0x39, 0x66, 0x8b, 0x24, 0x36, 0x61, 0xe, 0x6, 0xea, 0x45, 0xfa, 0x11, 0xd0, 0x4d, 0x37, 0x59, 0xb0, 0x33, 0xb5, 0x38, 0x26, 0x45, 0xf1, 0x5b, 0x3c, 0x39, 0x27, 0xb, 0x81, 0xb8, 0x4, 0x87, 0x64, 0x39, 0x13, 0xa2, 0x4f, 0x2f, 0x1c, 0x1a, 0x1e, 0xd5, 0x7c, 0x85, 0xcc, 0xdd, 0xc8, 0xcd, 0x6d, 0x59, 0xb6, 0x2f, 0xa6, 0x7c, 0xc8, 0x5, 0x72, 0x96, 0x8c, 0x8f, 0xd0, 0x18, 0x94, 0xf0, 0x15, 0x36, 0x34, 0xc8, 0x87, 0x92, 0xa7, 0xc4, 0xa4, 0x7, 0xa4, 0xa4, 0xce, 0x46, 0xce, 0xc5, 0xfe, 0x5d, 0x25, 0x69, 0xf9, 0x5a, 0x27, 0xde, 0x24, 0x24, 0x44, 0xea, 0xc, 0x71, 0x5b, 0x35, 0x75, 0x18, 0xca, 0xea, 0x23, 0xe7, 0x67, 0xe8, 0x54, 0x59, 0x83, 0xf0, 0xd3, 0xa4, 0xdf, 0x66, 0x11, 0x1b, 0x4a, 0xa1, 0xd3, 0x99, 0xcc, 0xaf, 0xd7, 0x96, 0xd7, 0xa8, 0xe, 0x59, 0x2d, 0x5a, 0x51, 0xd2, 0xb3, 0xf6, 0xb, 0x5b, 0x4, 0xf8, 0xd9, 0xc0, 0x9, 0xca, 0x56, 0xcb, 0xd4, 0xdd, 0x84, 0x12, 0x7a, 0x29, 0xb7, 0x2a, 0xdb, 0x76, 0x45, 0xfb, 0x72, 0x79, 0xc9, 0x81, 0x8b, 0x2b, 0x43, 0x96, 0x3b, 0xd6, 0x5, 0xf4, 0x5b, 0x65, 0x75, 0xa5, 0xe2, 0xe3, 0x69, 0xe0, 0xb4, 0x1, 0xf5, 0xec, 0x10, 0xec, 0x70, 0x3f, 0x11, 0x79, 0xb0, 0xab, 0x9d, 0x4a, 0x89, 0xd6, 0xf0, 0x96, 0x57, 0x39, 0x52, 0xe5, 0x13, 0x82, 0x73, 0x64, 0xa8, 0x4d, 0x38, 0x92, 0x27, 0x34, 0x13, 0x7e, 0x96, 0x9d, 0x81, 0x67, 0xd6, 0x95, 0x9b, 0x70, 0xf4, 0x2f, 0x2b, 0xda, 0x37, 0xe4, 0xc9, 0x89, 0xab, 0xaa, 0x80, 0x24, 0xc1, 0xa8, 0x4e, 0xd6, 0xbe, 0xb7, 0x47, 0x80, 0x92, 0x7f, 0x78, 0xb3, 0x2e, 0xa7, 0x36, 0xb9, 0xb2, 0xb4, 0xa7, 0x95, 0xc3, 0x55, 0xc0, 0x31, 0x98, 0x11, 0x72, 0x9d, 0x9c, 0xc3, 0x99, 0xd2, 0x35, 0x19, 0x73, 0x3, 0x38, 0xd6, 0x2e, 0x16, 0xe5, 0x3, 0x5f, 0xc5, 0x2a, 0x81, 0x70, 0x90, 0x70, 0x3f, 0xe7, 0x76, 0xd6, 0x5e, 0xf9, 0xfe, 0xf5, 0xba, 0x5f, 0x4f, 0xfe, 0xc3, 0xcc, 0x8e, 0x9e, 0xb2, 0xe3, 0x12, 0xc5, 0xa, 0x47, 0x9b, 0xdd, 0x4e, 0x6a, 0xb0, 0xa5, 0x6c, 0x18, 0xc2, 0xdf, 0x69, 0xed, 0x40, 0x84, 0x17, 0xbe, 0xe2, 0x8b, 0xb4, 0x1d, 0xd1, 0x3f, 0x83, 0x66, 0xff, 0x6e, 0xda, 0x4b, 0x34, 0x9, 0xf, 0xc9, 0xbc, 0x4, 0x52, 0x71},
+               output224: []byte{0x82, 0x69, 0x8a, 0xd7, 0x8d, 0xfc, 0x9e, 0x39, 0x66, 0x5c, 0x9d, 0xfd, 0x54, 0xc7, 0xbc, 0x44, 0xdb, 0xe, 0xbb, 0xa2, 0xe7, 0x41, 0xe8, 0xd, 0x52, 0x92, 0x66, 0x9b},
+               output256: []byte{0x19, 0x2e, 0xae, 0xa8, 0x40, 0x38, 0xd5, 0x88, 0xad, 0x55, 0xdc, 0x51, 0x43, 0xf2, 0xbb, 0x10, 0x4, 0xe, 0xf7, 0x8b, 0xfc, 0x7f, 0xb9, 0x1f, 0x6b, 0x5e, 0x4c, 0x5, 0x34, 0x66, 0xaf, 0x0},
+               output384: []byte{0xdd, 0x29, 0xed, 0x94, 0x68, 0xbb, 0x12, 0xde, 0x8f, 0x9c, 0xf6, 0x4a, 0xa7, 0x66, 0xb0, 0x44, 0x77, 0xd6, 0x59, 0xf0, 0x32, 0x74, 0x6a, 0xb4, 0xd0, 0x9d, 0x56, 0xa5, 0x40, 0xdb, 0x1a, 0x3d, 0x13, 0xf7, 0xc9, 0x1b, 0x27, 0xfc, 0xe1, 0xc, 0x4c, 0xa8, 0x46, 0x6f, 0x4a, 0x6, 0xc2, 0xc2},
+               output512: []byte{0xfc, 0x4e, 0x8e, 0xef, 0x8a, 0x77, 0x59, 0x8a, 0x38, 0x9b, 0xd5, 0x8a, 0x31, 0xc3, 0x48, 0xb2, 0x2c, 0x63, 0x28, 0x23, 0x5a, 0x39, 0xf1, 0xf0, 0x97, 0xc0, 0x6d, 0x18, 0x9d, 0xfe, 0x8, 0x65, 0x8b, 0x89, 0xc1, 0x6d, 0x9b, 0x26, 0xa4, 0x3d, 0x17, 0xa2, 0x5f, 0x1b, 0x40, 0x7, 0x85, 0x2c, 0xed, 0x21, 0x28, 0x56, 0x5, 0x9d, 0x8b, 0x5e, 0xb4, 0x2e, 0xf6, 0x6, 0x6c, 0x84, 0x58, 0x50}},
+       testcase{
+               msg:       []byte{0xd1, 0xfa, 0x12, 0x3c, 0x46, 0x8d, 0x0, 0x52, 0xc5, 0x8c, 0x93, 0xbf, 0x30, 0x6c, 0x7c, 0x1d, 0xc9, 0x9, 0x68, 0xec, 0xca, 0xc6, 0xb0, 0xc2, 0xf4, 0xe3, 0xec, 0xc3, 0xf9, 0x8, 0xf2, 0xbe, 0x6a, 0x54, 0xab, 0x69, 0xae, 0xc5, 0xc4, 0x96, 0xd2, 0x91, 0xd0, 0x26, 0x32, 0x43, 0xbf, 0x18, 0x27, 0x77, 0x3d, 0xbf, 0xfc, 0x2, 0xa9, 0xd5, 0xfb, 0xf7, 0xaf, 0xf6, 0x3d, 0xa5, 0x35, 0x5d, 0x58, 0x69, 0xf4, 0x92, 0xb0, 0xca, 0xe8, 0x2b, 0x22, 0x9a, 0x36, 0x33, 0x1d, 0xfa, 0x64, 0x25, 0x57, 0xc6, 0xf6, 0x62, 0x7f, 0xfb, 0x9, 0x95, 0xe5, 0x93, 0xdf, 0x8e, 0xf, 0xbd, 0x3a, 0xbe, 0x66, 0x12, 0x6b, 0x7e, 0x5d, 0xa1, 0xf1, 0x89, 0x1b, 0xd2, 0x88, 0x73, 0xfd, 0x9c, 0x96, 0xc0, 0x7, 0x62, 0x15, 0xb6, 0x5, 0x48, 0x7, 0x5d, 0x16, 0xcd, 0xa9, 0x2a, 0x2b, 0x99, 0xea, 0xe5, 0x77, 0x6f, 0x6d, 0x1e, 0x7a, 0xe2, 0xd8, 0xca, 0x30, 0x54, 0x6b, 0xd3, 0x32, 0x71, 0xd5, 0xa, 0x6f, 0xd3, 0x4b, 0x23, 0x80, 0x95, 0x34, 0xae, 0x6e, 0x4a, 0x87, 0x5d, 0x69, 0x81, 0x49, 0x2f, 0x23, 0x75, 0x2a, 0x68, 0xd1, 0xe8, 0x70, 0xd1, 0x74, 0xa0, 0x21, 0xff, 0x8c, 0x55, 0xe, 0x1, 0x99, 0x3e, 0x3d, 0xc3, 0x35, 0x82, 0x74, 0xe4, 0xda, 0x2b, 0x45, 0xc0, 0x0, 0xc4, 0x3f, 0xac, 0x30, 0x7d, 0x82, 0xee, 0x2b, 0x5d, 0x42, 0xa6, 0xd9, 0x84, 0x9c, 0x11, 0xa8, 0xa5, 0x67, 0x66, 0x5, 0xb7, 0xb3, 0xc4, 0x52, 0x20, 0xbf, 0xa5, 0xbf, 0xc7, 0x11, 0x8e, 0x24, 0x87, 0xda, 0x14, 0x3d, 0xf0, 0x79, 0x78, 0x70, 0x30, 0x3c, 0x18, 0x5c, 0x92, 0x33, 0xaf, 0x63, 0xf4, 0x47, 0xce, 0x53, 0xd8, 0x19, 0x9b, 0x98, 0x6a, 0xba, 0x36, 0x77, 0x35, 0xfd, 0x74, 0x5f, 0x84, 0xf8, 0xd9, 0x4b, 0xa0, 0xc1, 0xa0, 0x8d, 0xb2, 0x80, 0xd8, 0x60, 0xbf, 0x65, 0x6e, 0xe8, 0x71, 0xad, 0x10, 0x94, 0xfc, 0xb4, 0x1c, 0x7b, 0xfb, 0xf0, 0xfb, 0xe0, 0x95, 0x9a, 0x31, 0xb3, 0xed, 0x57, 0x34, 0x98, 0xad, 0x35, 0x2, 0x66, 0x94, 0xab, 0xfb, 0x90, 0x68, 0x4b, 0x35, 0xbe, 0x28, 0x4b, 0x18, 0xd4, 0xb6, 0x63, 0xcb, 0x2e, 0xa5, 0xde, 0x1a, 0x88, 0xe2, 0x94, 0x7b, 0xe8, 0x1, 0x28, 0x58, 0xc5, 0x7a, 0xd8, 0x60, 0x1c, 0xfd, 0x17, 0x44, 0x57, 0x3f, 0x79, 0x90, 0x68, 0x49, 0xb4, 0xa5, 0x55, 0x2a, 0xa8, 0x7d, 0x5e, 0x64, 0xc2, 0x1a, 0x5, 0x4a, 0x7f, 0xd3, 0x1b, 0x7e, 0xfe, 0x2a, 0x5e, 0x40, 0x15, 0x53, 0x46, 0x3f, 0xdd, 0xb8, 0x81, 0x35, 0x5f, 0xd9, 0x4c, 0x9e, 0xf7, 0xf6, 0xf9, 0xe3, 0xda, 0x4c, 0xd8, 0x45, 0xee, 0x16, 0xdb, 0x2d, 0x1a, 0x7d, 0x4e, 0x31, 0xc9, 0xe8, 0xb4, 0x2c, 0xe, 0xe5, 0xd3, 0x2, 0x96, 0xa6, 0x6, 0xb0, 0xa, 0xad, 0x9e, 0xa0, 0x95, 0x9, 0x20, 0x81, 0x88, 0xd4, 0xa1, 0x5b, 0x32, 0x8e, 0xf7, 0x56, 0x4c, 0x2e, 0x36, 0xfe, 0x79, 0xc0, 0x6e, 0x46, 0x6a, 0xf5, 0x98, 0xeb, 0x64, 0x28, 0xf, 0x0, 0x19, 0xa3, 0xac, 0x81, 0xb1, 0x8f, 0xa2, 0x54, 0xb0, 0xb7, 0x9d, 0x7b, 0x80, 0xec, 0xdc, 0x9a, 0xda, 0x3d, 0xd3, 0xd1, 0x3f, 0x18, 0x99, 0xcd, 0x3e, 0xeb, 0x6c, 0xeb, 0xda, 0xcc, 0x7f, 0x69, 0xe6, 0xed, 0x2, 0xb2, 0x55, 0xe, 0xb3, 0xc7, 0x6e, 0x17, 0x74, 0xe1, 0x89, 0x66, 0x1b, 0xf7, 0x91, 0xab, 0x88, 0x42, 0xa9, 0x2d, 0x86, 0xaf, 0x94, 0x89, 0x77, 0x1d, 0x1d, 0x6f, 0xe8, 0x30, 0x2b, 0xe3, 0x95, 0xd6, 0x75, 0xe, 0xbb, 0xfb, 0x1e, 0xd7, 0x23, 0x7c, 0x2c, 0x97, 0xab, 0x65, 0x5c, 0x7a, 0x6c, 0x71, 0x57, 0xa5, 0xea, 0x5c, 0x51, 0x3, 0x6a, 0xcd, 0x9f, 0x1c, 0x3, 0x12, 0x77, 0xa9, 0x4, 0x50, 0xbd, 0xba, 0xb5, 0xd4, 0xa9, 0xb3, 0x6d, 0xa5, 0x2a, 0x6e, 0xf7, 0x86, 0x5b, 0xd0, 0xb5, 0x57, 0x1f, 0x22, 0x8d, 0x5d, 0x61, 0xd1, 0x5a, 0x1, 0xc3, 0x6c, 0x3a, 0x7d, 0x2f, 0x13, 0x3f, 0x4, 0xd0, 0xa1, 0x72, 0x55, 0x27, 0x1a, 0x1f, 0xa0, 0xbc, 0x7c, 0xd6, 0xa, 0x85, 0xbf, 0xf1, 0x7e, 0xfe, 0x1d, 0x49, 0xa2, 0x4d, 0x7e, 0x87, 0x80, 0x7f, 0x67, 0xa0, 0x13, 0x58, 0xb7, 0xce, 0xd0, 0x1a, 0x11, 0x2d, 0x8b, 0x71, 0xa6, 0xdd, 0x70, 0x51, 0x8b, 0xf6, 0xaa, 0x8b, 0x65, 0xa5, 0xd5, 0x10, 0xe6, 0xf5, 0x8, 0x4f, 0x5e, 0xca, 0xef, 0x10, 0x8f, 0x6e, 0x65, 0x64, 0x3, 0x2a, 0xd9, 0x25, 0x9e, 0x84, 0x6, 0x7, 0x6b, 0x93, 0x48, 0xce, 0x33, 0x70, 0x5, 0xfa, 0x4b, 0x20, 0x5f, 0x47, 0x73, 0x6a, 0x79, 0x69, 0x3c, 0x7e, 0x96, 0x36, 0x35, 0xea, 0x63, 0x4c, 0xa6, 0x7b, 0x97, 0x49, 0xa0, 0x98, 0xb2, 0x99, 0x87, 0x99, 0x73, 0xca, 0x9c, 0xb3, 0x55, 0xb1, 0x8, 0xd, 0xe5, 0xa9, 0x5, 0x4c, 0x7f, 0x39, 0xc1, 0x58, 0xaa, 0xe4, 0xe2, 0x5b, 0xf7, 0x2c, 0x5, 0x47, 0xfd, 0xa9, 0xf6, 0x6a, 0x23, 0x4a, 0xc3, 0xe2, 0xdf, 0x8d, 0xd2, 0x27, 0x52, 0xae, 0x66, 0xd2, 0x6f, 0xdb, 0x32, 0x51, 0x5b, 0x9e, 0x92, 0x39, 0xd1, 0xb5, 0x83, 0xa3, 0x14, 0xae, 0x23, 0x1d, 0xbd, 0xce, 0x90, 0x13, 0xda, 0x4f, 0x98, 0x21, 0x3c, 0xd6, 0xab, 0x9f, 0x42, 0x58, 0x2f, 0x62, 0xd6, 0x39, 0xe2, 0xc, 0xd1, 0x83, 0x56, 0xf, 0x34, 0x10, 0x7, 0xc6, 0x0, 0xb2, 0xe0, 0x12, 0x33, 0x9, 0x8f, 0xc6, 0x1a, 0x50, 0xc2, 0x7d, 0x94, 0x98, 0x22, 0xc6, 0xf9, 0x9f, 0xda, 0x51, 0xad, 0x78, 0x8b, 0xae, 0x10, 0x1c, 0xc3, 0x79, 0xb4, 0x8a, 0xc8, 0xcf, 0xac, 0x3b, 0x5d, 0xf8, 0x1c, 0x9f, 0x7b, 0x4e, 0x1e, 0x3, 0x53, 0xf7, 0xf1, 0xa, 0xb3, 0x40, 0x15, 0x7f, 0xc7, 0xa8, 0xf9, 0x2f, 0xfc, 0x43, 0xd3, 0x1f, 0x24, 0xb4, 0x98, 0xb3, 0x81, 0xc7, 0xb2, 0xb, 0xf0, 0xa3, 0x1b, 0x74, 0xc4, 0x56, 0x27, 0xb9, 0xe9, 0x85, 0x8d, 0x84, 0x79, 0xaf, 0x59, 0x77, 0x78, 0x2a, 0x5f, 0xa8, 0x8d, 0x25, 0x8e, 0xbc, 0xe9, 0x7e, 0x6d, 0xf, 0xa0, 0x97, 0x1d, 0xbf, 0xca, 0xb6, 0xaf, 0xbb, 0x30, 0x11, 0xf9, 0xcc, 0x24, 0xd8, 0xc4, 0xe3, 0xdb, 0x57, 0x69, 0x8e, 0x29, 0x9f, 0x67, 0x93, 0x74, 0x18, 0x10, 0xe2, 0xa9, 0x42, 0x95, 0xd0, 0xd9, 0x1f, 0x3f, 0x76, 0x9f, 0x18, 0x4d, 0xa2, 0xff, 0xfc, 0xa7, 0x71, 0xa1, 0x48, 0x72, 0x8a, 0x2f, 0x95, 0x23, 0x7b, 0x77, 0x86, 0x4d, 0xea, 0x20, 0xd8, 0xe, 0x9, 0xe7, 0xa0, 0xa3, 0x66, 0x37, 0x6, 0x28, 0x0, 0x6, 0x5a, 0xcf, 0x15, 0x57, 0x23, 0x55, 0xbe, 0xa8, 0xdf, 0xe2, 0x75, 0x9, 0xf4, 0xa7, 0x57, 0x7, 0x9b, 0xea, 0x6d, 0x6d, 0xf3, 0x42, 0x93, 0x53, 0xaa, 0xeb, 0x77, 0x77, 0xa1, 0x43, 0xe3, 0xed, 0x1a, 0x20, 0xde, 0x48, 0x71, 0x62, 0xf6, 0x66, 0x6b, 0xa5, 0xd2, 0x7e, 0xb9, 0xd3, 0x50, 0xd6, 0xa5, 0xc7, 0x24, 0xbf, 0x19, 0xa1, 0xd0, 0x58, 0xac, 0xde, 0xf1, 0x26, 0xf6, 0x0, 0x8e, 0xbc, 0xd1, 0x92, 0x51, 0x6f, 0xb0, 0xd4, 0x79, 0x7d, 0xd5, 0xfd, 0x32, 0x16, 0xa9, 0xcd, 0xcd, 0x2e, 0xe2, 0x4a, 0x2c, 0x40, 0xbb, 0x2c, 0xbf, 0xf7, 0x5c, 0xc5, 0x9d, 0xb2, 0xe3, 0xcd, 0xd8, 0xdf, 0x4e, 0xb, 0x36, 0xa6, 0x70, 0x95, 0x2b, 0x7, 0x87, 0x1a, 0x2, 0x99, 0xee, 0xda, 0x93, 0x77, 0xe8, 0x29, 0x6a, 0xd3, 0x78, 0x8c, 0x78, 0x72, 0x8d, 0xe7, 0x1d, 0x31, 0x24, 0x1f, 0x20, 0xc2, 0xb2, 0x4, 0x69, 0x28, 0xca, 0x27, 0x51, 0xbe, 0xbd, 0x10, 0xbc, 0xc, 0x45, 0x5f, 0x49, 0xf3, 0xd, 0x7a, 0xd9, 0x79, 0xb0, 0xd8, 0x6b, 0x66, 0xa5, 0x54, 0x29, 0x85, 0x3a, 0xab, 0x62, 0x57, 0x5f, 0x92, 0x19, 0x48, 0x36, 0x3, 0x92, 0x4b, 0x4d, 0x39, 0x93, 0x54, 0x89, 0xe8, 0xb2, 0xad, 0x6e, 0x10, 0x5b, 0x8d, 0x11, 0xe7, 0x47, 0x85, 0xfe, 0xa9, 0xd1, 0xa9, 0x37, 0x7d, 0x18, 0x9b, 0xa2, 0x90, 0xcd, 0x41, 0x4f, 0x57, 0xed, 0x67, 0x13, 0x75, 0x23, 0xa3, 0x55, 0xf9, 0xc, 0x9f, 0xf5, 0xff, 0x2c, 0xb7, 0x60, 0xd4, 0xa3, 0x1f, 0xaa, 0x2f, 0x1c, 0x47, 0x8f, 0x95, 0x47, 0xfe, 0x4c, 0x4b, 0xb, 0x1c, 0xbb, 0xd7, 0x1b, 0x69, 0xf, 0xb3, 0xee, 0xae, 0xf8, 0x7a, 0x53, 0xea, 0xa1, 0xeb, 0x65, 0x26, 0xb7, 0x48, 0x89, 0x63, 0xfb, 0x64, 0xd1, 0x7b, 0x37, 0xbb, 0x38, 0x71, 0x5, 0xe3, 0x99, 0x69, 0xdb, 0xab, 0xcd, 0x79, 0xec, 0x28, 0xdf, 0xfb, 0x5a, 0x61, 0xa1, 0x10, 0x1b, 0x34, 0xc1, 0x42, 0x2, 0xbd, 0xe, 0xc1, 0xcf, 0x80, 0xe, 0x21, 0xd6, 0x95, 0xab, 0xab, 0xa4, 0x94, 0x43, 0x1d, 0xda, 0xa2, 0xd, 0x88, 0xed, 0x75, 0x1, 0xad, 0x36, 0xf, 0x9b, 0x6e, 0xd4, 0x1b, 0x4c, 0xcd, 0xd0, 0xfb, 0x57, 0x78, 0xcf, 0x53, 0xd7, 0xc1, 0x8c, 0x36, 0xc4, 0xba, 0x78, 0x3e, 0x68, 0xb9, 0xb0, 0xd2, 0x6c, 0x7b, 0xbc, 0xb3, 0xb2, 0xa0, 0x15, 0xbb, 0x1e, 0x2f, 0xb5, 0x1f, 0xa9, 0xc3, 0x23, 0xc0, 0x8a, 0x72, 0x51, 0xe4, 0x8f, 0x14, 0xa, 0x4e, 0x51, 0x9b, 0x1c, 0x38, 0x9e, 0xf, 0xe4, 0xa8, 0x7b, 0x9d, 0x65, 0xb8, 0xd9, 0x1a, 0x20, 0x81, 0x40, 0x5f, 0x5, 0xd0, 0x1f, 0x71, 0x2, 0x4a, 0x56, 0xba, 0x89, 0x55, 0xa, 0x41, 0x8b, 0xfa, 0xc2, 0x86, 0x39, 0x28, 0xbc, 0x87, 0x4, 0x13, 0xce, 0xde, 0x14, 0x11, 0xf0, 0xd7, 0xc3, 0xe7, 0x7c, 0x76, 0xb, 0x76, 0xe0, 0xd9, 0x4f, 0x7d, 0x9a, 0xde, 0xda, 0xbe, 0x9e, 0x4a, 0x63, 0x2b, 0x6a, 0x1f, 0xb5, 0xcc, 0xbf, 0x8e, 0xb2, 0xcf, 0xe7, 0x72, 0xfc, 0x31, 0xdc, 0xd, 0x1b, 0xa6, 0x3a, 0xde, 0xf2, 0x1c, 0xae, 0xbf, 0x84, 0x64, 0x18, 0xc6, 0xad, 0xf2, 0xe4, 0x74, 0xed, 0xb4, 0xa0, 0x20, 0x72, 0x71, 0xc3, 0x26, 0xf1, 0x4d, 0x20, 0xc0, 0xb9, 0x5e, 0x1a, 0xf7, 0xd8, 0x63, 0x31, 0xf0, 0xd4, 0xf7, 0x92, 0xd7, 0x54, 0x58, 0x74, 0xf5, 0x50, 0x89, 0x2b, 0x3e, 0x8, 0x1f, 0xcf, 0xac, 0x60, 0x74, 0xe1, 0x72, 0xf8, 0x82, 0x6e, 0x4, 0xf2, 0x89, 0x20, 0x14, 0x20, 0xf0, 0x64, 0xff, 0x3c, 0x53, 0xac, 0x7b, 0x9a, 0x15, 0xa2, 0x91, 0xe8, 0x78, 0xb5, 0x90, 0xb3, 0xf4, 0x7f, 0x53, 0xe6, 0xcc, 0xbb, 0xa8, 0x97, 0x65, 0x3d, 0x6f, 0xf4, 0xc6, 0xcb, 0xfa, 0xc9, 0xc, 0xb8, 0x66, 0x6c, 0x86, 0xdf, 0xca, 0x4d, 0x55, 0x4d, 0x8b, 0x87, 0xad, 0x1e, 0xd5, 0xbd, 0x39, 0x41, 0x1e, 0xa3, 0x5a, 0x41, 0x7a, 0x51, 0xf9, 0x11, 0x9b, 0x63, 0x9, 0x4, 0xbe, 0x65, 0x75, 0xaa, 0x25, 0x7b, 0xe5, 0x47, 0x16, 0xa7, 0x88, 0x92, 0x29, 0x72, 0xcf, 0xdc, 0x5a, 0x5b, 0xcb, 0x4b, 0x60, 0x54, 0x53, 0x2a, 0xab, 0x91, 0x3e, 0x7d, 0x8b, 0xf, 0x5a, 0x45, 0x1, 0x80, 0xa3, 0xe7, 0xde, 0xef, 0x61, 0xbb, 0x8, 0x15, 0x12, 0xd, 0x78, 0x69, 0x8, 0x62, 0x91, 0xc3, 0xf3, 0xdf, 0xb7, 0x10, 0x14, 0xbc, 0x66, 0xe3, 0xd5, 0xc8, 0x85, 0x4b, 0x52, 0xe8, 0x0, 0xc8, 0xf6, 0x47, 0x65, 0xc4, 0x8, 0x9e, 0x48, 0x20, 0x12, 0x55, 0xe, 0x23, 0x77, 0x10, 0x4f, 0x93, 0xae, 0x57, 0xf0, 0x47, 0xa3, 0x5c, 0xd, 0xb2, 0x43, 0xbd, 0xc7, 0xe1, 0x84, 0x6b, 0xa0, 0xd0, 0xeb, 0x42, 0xaa, 0xf9, 0x77, 0x42, 0x98, 0x4d, 0x26, 0x37, 0xc2, 0xf2, 0xbe, 0xfa, 0x40, 0x21, 0x39, 0x0, 0xc3, 0xaf, 0x5a, 0x75, 0x8f, 0x85, 0xfd, 0x43, 0x42, 0xf9, 0xfc, 0xb, 0x38, 0x21, 0xff, 0x97, 0xb5, 0x30, 0x23, 0x32, 0xdb, 0x2d, 0xde, 0xb6, 0x88, 0xc8, 0x57, 0x26, 0x91, 0xaa, 0xc5, 0xaf, 0xd7, 0x77, 0xc5, 0xac, 0x88, 0x20, 0x9, 0x93, 0xd3, 0xef, 0x10, 0xa, 0x5f, 0x95, 0xb5, 0x1a, 0xa9, 0x28, 0x81, 0xac, 0xaa, 0x5f, 0xaf, 0x68, 0xe6, 0x13, 0x42, 0x21, 0x39, 0x1c, 0x4, 0xa8, 0x8c, 0x7c, 0x7, 0xcb, 0x39, 0xd0, 0x7d, 0x5a, 0x24, 0x5a, 0xee, 0xd, 0x63, 0x39, 0x50, 0x18, 0xc0, 0xc8, 0xe1, 0xd4, 0x5b, 0xb6, 0x40, 0x22, 0xc, 0x2f, 0x99, 0x38, 0x31, 0xdc, 0xe2, 0x59, 0x71, 0x33, 0xc8, 0x70, 0x14, 0xd1, 0x2f, 0x5c, 0xed, 0x52, 0x1a, 0xa4, 0x52, 0x73, 0xf7, 0x43, 0x4d, 0xa8, 0xac, 0xca, 0x2f, 0xe3, 0x5a, 0x26, 0xfe, 0xed, 0xcf, 0x70, 0x1a, 0xf1, 0x32, 0x8e, 0x4c, 0x23, 0x58, 0xbf, 0x74, 0x51, 0x3c, 0xdf, 0xbb, 0x6a, 0x8, 0x64, 0xea, 0x96, 0x70, 0xc2, 0x81, 0xc5, 0xe7, 0xc5, 0x1e, 0x26, 0xf3, 0xde, 0x15, 0x64, 0x99, 0x85, 0xde, 0x90, 0xab, 0xbc, 0xfc, 0x2d, 0x85, 0xc2, 0x68, 0x86, 0xf0, 0xa0, 0xc3, 0x3c, 0x8f, 0xd7, 0x4e, 0x33, 0x12, 0x2c, 0x42, 0x1, 0x2f, 0x1c, 0x5e, 0xcd, 0xd0, 0x1f, 0xf9, 0x6f, 0xd7, 0x5c, 0x6b, 0x6, 0x7c, 0x60, 0xf2, 0x50, 0x10, 0x88, 0xe2, 0xc8, 0xc2, 0x53, 0xa, 0x1, 0x91, 0xc1, 0x7a, 0x11, 0x3b, 0x38, 0x24, 0x3, 0x45, 0x41, 0x45, 0x69, 0xb3, 0xb8, 0xf, 0x8d, 0xb7, 0x55, 0xdc, 0x33, 0x62, 0xc5, 0x2d, 0xd1, 0xd3, 0x6c, 0x6, 0xd0, 0x24, 0x42, 0xc3, 0xaf, 0xd2, 0x40, 0x58, 0x34, 0x3f, 0x9c, 0xfc, 0x69, 0x31, 0xcc, 0xa0, 0x44, 0x2d, 0x3c, 0xa2, 0xcc, 0xc8, 0x4c, 0x62, 0x67, 0xc4, 0x2c, 0xc8, 0x5f, 0x4d, 0x6b, 0xb7, 0x8f, 0x34, 0xdf, 0x54, 0xd4, 0xe2, 0x2, 0x5, 0xd7, 0xc3, 0x79, 0xd9, 0x24, 0xc6, 0x49, 0xac, 0x7e, 0xa8, 0xfc, 0x12, 0x7b, 0x7e, 0xe2, 0x88, 0x6, 0x4b, 0x2b, 0x69, 0xfa, 0x95, 0xc9, 0x3f, 0xe, 0xd, 0xf1, 0xe8, 0x63, 0xc5, 0x90, 0xe2, 0x6, 0x9a, 0x9, 0x98, 0xa3, 0xc2, 0xb9, 0x9c, 0x95, 0xb6, 0x90, 0xb5, 0xf7, 0x1, 0x4f, 0x40, 0x1b, 0xef, 0xaa, 0x83, 0x5c, 0xfb, 0x41, 0x4c, 0xca, 0x8a, 0x5b, 0x7c, 0xd0, 0x27, 0xe5, 0x2a, 0xe3, 0xac, 0xd2, 0x1b, 0x61, 0x8b, 0x6c, 0x9d, 0x1e, 0x24, 0xe, 0x5d, 0xa3, 0xa5, 0xf9, 0xd2, 0xef, 0x4f, 0x9a, 0xae, 0x6b, 0x32, 0x24, 0x7, 0xf, 0xc4, 0x1c, 0x13, 0x2, 0x51, 0xd9, 0x3e, 0x8e, 0x4a, 0x94, 0x52, 0xa3, 0xa2, 0xac, 0xe2, 0xe9, 0x19, 0xb6, 0xcb, 0xe2, 0x48, 0xa3, 0xea, 0xb6, 0x47, 0x9f, 0xfe, 0x4a, 0xcc, 0x55, 0xea, 0xf5, 0x4d, 0xad, 0xa9, 0xa8, 0x41, 0x30, 0xcd, 0x6b, 0xbb, 0xb, 0xe4, 0x16, 0x37, 0x55, 0x8a, 0x17, 0x9, 0x82, 0xea, 0xe9, 0xa8, 0x88, 0x53, 0xfc, 0xbf, 0xa6, 0xcb, 0x7, 0x68, 0x41, 0xa8, 0xe3, 0x6e, 0x88, 0x24, 0xd2, 0x1a, 0xd2, 0xe3, 0xad, 0x1d, 0x7f, 0x82, 0x9a, 0x5b, 0x13, 0x29, 0x6b, 0x15, 0xd0, 0x5, 0x3b, 0xdd, 0x52, 0x1d, 0x7d, 0x15, 0xe7, 0x6b, 0x35, 0x6d, 0x62, 0xf0, 0x2e, 0xe2, 0xe, 0xb7, 0x8d, 0x4, 0x83, 0x8a, 0xf7, 0xe4, 0xb0, 0x84, 0xb0, 0xd2, 0x57, 0x5e, 0xde, 0x7d, 0xe2, 0x13, 0xc, 0x54, 0x72, 0xd8, 0xeb, 0x18, 0x39, 0xc1, 0x9f, 0xde, 0x6, 0xd7, 0xe7, 0x7b, 0xac, 0xfa, 0xe1, 0x5, 0x8a, 0xa, 0x19, 0xee, 0xc6, 0x48, 0x54, 0x85, 0xd4, 0x1, 0xa7, 0xa, 0x89, 0x20, 0x29, 0xa, 0xee, 0x1d, 0xf, 0x36, 0xc6, 0x73, 0x24, 0xa6, 0xd8, 0x7d, 0x3b, 0x96, 0x28, 0xff, 0x69, 0x47, 0x9a, 0xea, 0x47, 0x40, 0xab, 0x9f, 0x25, 0x63, 0x89, 0x5d, 0x41, 0x8f, 0x9a, 0x5f, 0x4, 0xc6, 0x7c, 0xb4, 0x52, 0x91, 0x15, 0x14, 0x66, 0x29, 0xca, 0xdf, 0x3c, 0x19, 0x49, 0xb3, 0xaf, 0xf5, 0xe, 0x89, 0x76, 0x0, 0x36, 0x88, 0xa3, 0x76, 0xc5, 0xe8, 0x89, 0xaa, 0xb, 0x76, 0x40, 0x27, 0x33, 0x5f, 0xd8, 0x17, 0x4f, 0x64, 0x8c, 0x3e, 0x7, 0x2c, 0xf4, 0x61, 0x8f, 0xf2, 0xc2, 0x18, 0x95, 0x21, 0x5, 0x6c, 0x3, 0xbc, 0x2e, 0x53, 0xf, 0xb8, 0x9b, 0x39, 0x1c, 0xc5, 0x62, 0x79, 0x64, 0xa6, 0x55, 0x5e, 0x8c, 0xcf, 0x10, 0x2d, 0x62, 0x8c, 0xf1, 0xb3, 0xef, 0x1c, 0x32, 0x49, 0x90, 0x13, 0xcc, 0x37, 0xd8, 0x1a, 0xe, 0x8e, 0x3e, 0x3, 0x3f, 0xac, 0xf4, 0x1c, 0x12, 0x95, 0xf3, 0xf8, 0xab, 0xe3, 0x17, 0xd1, 0xcf, 0x1d, 0x2b, 0x1c, 0x5f, 0xb8, 0x91, 0xe1, 0x97, 0xcc, 0xa3, 0x42, 0x25, 0x22, 0xa4, 0xb6, 0x8c, 0x64, 0x81, 0xd4, 0xc7, 0x45, 0x56, 0xe0, 0x5e, 0x6, 0xd0, 0xe4, 0x5b, 0xe2, 0x94, 0xe9, 0x10, 0x63, 0x2b, 0x74, 0x7f, 0x3f, 0xb3, 0x4f, 0xe5, 0xd3, 0xac, 0x1, 0x26, 0x90, 0xd9, 0xe3, 0xb7, 0xa4, 0x33, 0x8f, 0xd5, 0x88, 0x18, 0xe6, 0x22, 0xae, 0x7f, 0x71, 0xdd, 0x90, 0xa3, 0x40, 0x81, 0x49, 0x62, 0x15, 0xd8, 0xf2, 0x24, 0x25, 0x2c, 0x50, 0xcb, 0x1b, 0xbf, 0xaa, 0x8, 0x81, 0xf, 0xb6, 0xb4, 0xd0, 0xda, 0x50, 0xd0, 0x7, 0xad, 0x6d, 0x53, 0x9, 0xe5, 0xc0, 0xe2, 0x7f, 0xd9, 0x1b, 0x8b, 0x34, 0x37, 0x46, 0xb6, 0xcb, 0xed, 0x10, 0x83, 0xf9, 0x15, 0x23, 0xa7, 0xb5, 0x1b, 0x90, 0x46, 0x73, 0x7f, 0x71, 0x14, 0xf5, 0x7, 0xbd, 0x76, 0x68, 0x83, 0x5c, 0xe2, 0xea, 0xe7, 0x39, 0x86, 0x17, 0xe3, 0xf2, 0x98, 0xf5, 0xb8, 0xb3, 0x89, 0x66, 0xa9, 0xbd, 0xb3, 0xbe, 0xb3, 0x42, 0xee, 0xfb, 0xe6, 0x13, 0x68, 0xdd, 0x83, 0x2, 0x74, 0x7c, 0x68, 0x2b, 0x83, 0xc3, 0xad, 0x4e, 0x18, 0x4a, 0x5f, 0x8d, 0xa2, 0xcc, 0xc4, 0xf7, 0xee, 0x99, 0xa3, 0x31, 0x56, 0x27, 0x4d, 0x97, 0x13, 0x41, 0x26, 0xb0, 0xb8, 0x96, 0x27, 0xd8, 0x11, 0xbf, 0x7, 0xf7, 0x68, 0x3e, 0x84, 0xc, 0x51, 0xf1, 0x5b, 0x71, 0x1d, 0x1d, 0xb0, 0xc3, 0xc4, 0x1b, 0xe9, 0x89, 0xe0, 0xf1, 0x56, 0xa5, 0xb9, 0x48, 0xdb, 0xff, 0xc1, 0x9b, 0x40, 0x47, 0xa7, 0xd9, 0x3c, 0x9d, 0x9a, 0x22, 0xdc, 0xdf, 0xc, 0x14, 0x89, 0x7b, 0x5c, 0xf2, 0x9d, 0x3, 0xcd, 0x42, 0x6c, 0x62, 0xe6, 0x1, 0x4e, 0xe3, 0x96, 0xc1, 0x14, 0x83, 0xee, 0xe8, 0x5a, 0x2d, 0x32, 0x12, 0x38, 0x7b, 0x5c, 0x48, 0xdf, 0x82, 0x52, 0xb2, 0x1d, 0xb4, 0xa, 0xec, 0x9f, 0x8a, 0x2a, 0x1a, 0xd8, 0xa5, 0x5b, 0xaf, 0x26, 0x38, 0x12, 0x9, 0x4e, 0x9c, 0x81, 0xd5, 0xc1, 0x8f, 0xe1, 0xfb, 0x56, 0x59, 0x3e, 0x51, 0x88, 0x8c, 0x8a, 0x2, 0x72, 0xea, 0x2f, 0x81, 0x89, 0x78, 0x2f, 0x46, 0x27, 0x83, 0xbc, 0x99, 0x65, 0x41, 0xb8, 0x6e, 0xee, 0x4f, 0x7b, 0xe5, 0x3d, 0x53, 0x5b, 0x4e, 0x85, 0xdd, 0x78, 0x6b, 0xd9, 0x82, 0xc5, 0xd4, 0x94, 0xea, 0x1, 0x7c, 0xbf, 0x35, 0x46, 0x17, 0xd2, 0x19, 0xa4, 0x95, 0xe6, 0x44, 0x8b, 0x0, 0x99, 0x2d, 0xf8, 0x3c, 0x94, 0xfa, 0xbb, 0x35, 0x67, 0xe7, 0x52, 0x20, 0x70, 0x5b, 0xc4, 0x49, 0xc2, 0x36, 0x7c, 0x11, 0x8c, 0x76, 0xef, 0x74, 0x82, 0xc9, 0xab, 0x77, 0xa1, 0xe0, 0xaf, 0xcd, 0x3d, 0xae, 0x4d, 0xbf, 0xb, 0x21, 0x1a, 0xd7, 0x9e, 0xf1, 0x41, 0x21, 0x7d, 0xb5, 0x99, 0xf4, 0xf7, 0x45, 0x57, 0xb9, 0x33, 0x36, 0x29, 0xa1, 0x1a, 0xb4, 0x82, 0xec, 0x3d, 0x70, 0x50, 0xd9, 0x5a, 0xe0, 0x52, 0xf3, 0xe1, 0xf8, 0x14, 0xf6, 0x30, 0xe9, 0x80, 0x9b, 0x87, 0x4, 0x6d, 0x1c, 0xc4, 0x8, 0x7, 0x6b, 0x5c, 0xdd, 0xdb, 0x90, 0xa3, 0x89, 0xf8, 0xeb, 0x3f, 0xdf, 0x64, 0xfc, 0x7d, 0xd7, 0x1e, 0x6c, 0xd, 0x5d, 0x6c, 0x2c, 0x2c, 0x50, 0x76, 0x22, 0xa3, 0x87, 0xc5, 0xa3, 0xae, 0x60, 0xa6, 0xd7, 0x23, 0xdf, 0xcc, 0xcd, 0x1b, 0x6a, 0x8, 0xb4, 0xc, 0xae, 0x54, 0xd6, 0xfa, 0x51, 0x9b, 0x58, 0x97, 0x49, 0x7e, 0xb, 0x97, 0x2b, 0xfa, 0x19, 0x66, 0xce, 0x2a, 0x3d, 0xb3, 0xfe, 0xfc, 0x41, 0xab, 0x33, 0x93, 0x17, 0x1b, 0xa4, 0x6b, 0xac, 0x2f, 0xa9, 0x3a, 0xe3, 0x61, 0x3c, 0xe8, 0x82, 0x73, 0xab, 0x92, 0x92, 0x1f, 0x4c, 0xf8, 0xa5, 0x84, 0xc, 0xce, 0x3f, 0x3b, 0x3c, 0x41, 0x62, 0x2e, 0xda, 0x57, 0xe3, 0x3b, 0x43, 0x6f, 0xf8, 0x10, 0x82, 0x68, 0xe3, 0x58, 0xcf, 0xe0, 0xaa, 0x72, 0xfd, 0xd, 0x2a, 0xd5, 0x57, 0x67, 0x12, 0x19, 0x5f, 0x63, 0x36, 0x29, 0x3b, 0xb3, 0x6, 0x7e, 0xd3, 0x89, 0xd6, 0x9b, 0x86, 0x18, 0xdf, 0xea, 0xa8, 0xcb, 0x1d, 0x12, 0xb4, 0x3b, 0x37, 0xb, 0x17, 0xd2, 0x9e, 0xc2, 0x3, 0x5e, 0xe9, 0x34, 0x8d, 0x69, 0xf0, 0xe6, 0x4d, 0xff, 0xd8, 0x9, 0x61, 0x68, 0xf6, 0xcf, 0x2, 0x6, 0x61, 0xe7, 0x2b, 0xf6, 0x4f, 0xa0, 0xd0, 0x3e, 0x6, 0x2, 0x75, 0xa, 0x7d, 0xa0, 0xda, 0xf4, 0xa4, 0xed, 0x90, 0x9b, 0xcf, 0x17, 0xe, 0x76, 0xea, 0xb0, 0x88, 0x9f, 0xf1, 0x5d, 0x84, 0xe9, 0xf8, 0x23, 0x3b, 0x3c, 0x57, 0xb3, 0x40, 0x84, 0xbf, 0xbe, 0x77, 0x32, 0x50, 0xa, 0x40, 0x34, 0xbf, 0xf2, 0x41, 0xae, 0x4b, 0x89, 0xf9, 0xbc, 0xb2, 0xbe, 0x60, 0x71, 0x5c, 0x14, 0xd3, 0xb2, 0xf5, 0xf8, 0xe3, 0xc9, 0xb9, 0xc7, 0xf7, 0xeb, 0x11, 0xe6, 0xb0, 0xeb, 0xe7, 0xc, 0x9b, 0x63, 0x57, 0x1a, 0xbd, 0xd5, 0xa1, 0xa, 0x86, 0xc8, 0xf9, 0xc2, 0xeb, 0x64, 0xf7, 0x7, 0x5e, 0xa1, 0xf0, 0xbc, 0x2, 0x57, 0x3b, 0xf8, 0x3c, 0x3a, 0xf6, 0x8c, 0xa8, 0x31, 0xe1, 0x6f, 0x5f, 0x40, 0xe5, 0x58, 0xae, 0x5, 0x57, 0xde, 0x3b, 0x4, 0x6d, 0x54, 0x18, 0xa1, 0xb, 0x9e, 0x23, 0xc, 0xcd, 0x22, 0xd4, 0xca, 0xdd, 0x50, 0xcc, 0x91, 0x2d, 0xf9, 0xa4, 0x2a, 0xf8, 0x2e, 0xc9, 0x7c, 0x91, 0xaa, 0xcf, 0x2, 0x72, 0x40, 0xf9, 0x5b, 0x19, 0xfa, 0xe3, 0xdd, 0xd3, 0x6e, 0xae, 0xb1, 0x1f, 0xa7, 0x9c, 0x6c, 0x17, 0xbc, 0x6a, 0x43, 0x79, 0x61, 0x51, 0x70, 0xf, 0x58, 0x7b, 0x64, 0xcf, 0x3a, 0x2e, 0xd5, 0x21, 0xb2, 0x2e, 0x36, 0xc8, 0x25, 0x9d, 0xad, 0x86, 0xde, 0x55, 0xf4, 0x6e, 0xb6, 0x65, 0xac, 0xc, 0xe9, 0xc5, 0x9d, 0x91, 0xd5, 0x31, 0x3, 0x69, 0xf8, 0x87, 0x54, 0xcc, 0xb1, 0x48, 0x4f, 0x49, 0x99, 0xb9, 0xdb, 0xe3, 0x1a, 0x90, 0x85, 0xc5, 0xd8, 0xac, 0x64, 0xb6, 0x24, 0x90, 0x4a, 0x63, 0xdf, 0x3d, 0x1d, 0xab, 0x99, 0x4e, 0xa, 0x84, 0x53, 0x65, 0xcc, 0x6d, 0xaa, 0xf4, 0x76, 0x33, 0xf3, 0x2a, 0x92, 0x9a, 0xc7, 0x4b, 0x9e, 0x8a, 0x76, 0xf4, 0x9, 0x1d, 0xa8, 0xe, 0x49, 0xf3, 0xaa, 0xeb, 0xba, 0x70, 0x54, 0x4d, 0x17, 0x5, 0xb6, 0xe, 0x40, 0x80, 0x55, 0xf0, 0x7e, 0x3c, 0xc7, 0x1f, 0xd, 0x2c, 0xea, 0x3b, 0x4b, 0x16, 0xd5, 0x99, 0x5a, 0x6a, 0x9f, 0x47, 0x64, 0x66, 0x76, 0x5b, 0xed, 0xb2, 0xbd, 0x44, 0xf9, 0x7d, 0x45, 0x85, 0x8d, 0x14, 0x3, 0xc6, 0x34, 0x88, 0x84, 0xac, 0x71, 0x63, 0xae, 0xb2, 0x13, 0x64, 0x53, 0x4d, 0x8c, 0x19, 0xb0, 0x79, 0x6c, 0xcb, 0x50, 0x7d, 0x94, 0x41, 0xf6, 0x26, 0x67, 0x25, 0xfd, 0xb3, 0x40, 0xac, 0x11, 0x59, 0xd7, 0xc6, 0x3e, 0xd0, 0xc5, 0xab, 0x42, 0xda, 0xa9, 0x91, 0x8c, 0xa, 0x3d, 0xab, 0x2f, 0xa7, 0xf, 0x84, 0xd4, 0x99, 0xac, 0xdb, 0xac, 0x62, 0xf7, 0x42, 0x1, 0x30, 0x2d, 0x6e, 0x2b, 0x85, 0x4e, 0x37, 0xb1, 0xc7, 0x90, 0x19, 0x6e, 0x87, 0x8a, 0xdc, 0x3, 0xc0, 0x1, 0xf0, 0x6, 0xd2, 0x19, 0x6c, 0x28, 0x5f, 0xe5, 0x0, 0x1f, 0xe3, 0x95, 0x79, 0x5d, 0x84, 0x3b, 0x2a, 0xee, 0x6f, 0x7d, 0x6c, 0x22, 0xac, 0xc3, 0xa4, 0x23, 0x7, 0xf5, 0xf3, 0xff, 0xa8, 0x61, 0xe9, 0x96, 0xf1, 0x69, 0x31, 0x82, 0x48, 0xc3, 0xc4, 0x1b, 0xf9, 0xd1, 0xa5, 0x1b, 0xdb, 0xcf, 0x5a, 0x33, 0xa7, 0x98, 0x15, 0x6, 0x3e, 0x7, 0xcd, 0xf5, 0xa0, 0xc4, 0x67, 0x6e, 0xc9, 0x6a, 0xb5, 0x76, 0xd2, 0x7e, 0x11, 0x7b, 0x3d, 0xff, 0x7a, 0x2f, 0x1d, 0xd2, 0x19, 0xa1, 0xf1, 0xb1, 0x63, 0x7a, 0x64, 0xf3, 0x8b, 0x12, 0x2d, 0x60, 0xb9, 0x50, 0x1b, 0xbe, 0x36, 0x39, 0xcb, 0x76, 0xd8, 0xe7, 0x46, 0x16, 0x5e, 0xbb, 0xeb, 0xb9, 0x6, 0x92, 0x46, 0x1b, 0x61, 0x8, 0x6e, 0xae, 0x6f, 0x6f, 0x5a, 0xa5, 0xe0, 0x5, 0x3d, 0x84, 0xb6, 0xfc, 0xa8, 0x14, 0x7d, 0x97, 0x6d, 0xe8, 0x1, 0xb1, 0x1b, 0x30, 0x6c, 0x1a, 0x50, 0x61, 0x10, 0xc6, 0xa8, 0xb0, 0xff, 0x62, 0x23, 0x68, 0x89, 0x71, 0x8b, 0x18, 0xb5, 0x50, 0x7c, 0xc2, 0xed, 0x7, 0x3f, 0x1a, 0xc4, 0x8a, 0xd1, 0xdb, 0x1a, 0xa7, 0x71, 0x29, 0x56, 0x34, 0x27, 0x2f, 0x33, 0x83, 0x23, 0xae, 0x5d, 0xc1, 0xfb, 0x19, 0xb9, 0x37, 0xd8, 0x91, 0xef, 0xe2, 0xe9, 0x60, 0xb1, 0x7d, 0x34, 0x3e, 0x38, 0xf2, 0xf2, 0x8, 0xd4, 0xb8, 0xce, 0x21, 0xf2, 0x5f, 0xe8, 0x7b, 0x5f, 0x12, 0x3, 0x8e, 0xc5, 0x7e, 0x29, 0xc7, 0x40, 0x79, 0x14, 0x47, 0x3e, 0x96, 0xc3, 0x65, 0x41, 0x62, 0xe5, 0xdf, 0xab, 0x99, 0x39, 0xa0, 0x11, 0xba, 0xac, 0xce, 0x48, 0x1, 0x8, 0x98, 0xf1, 0x15, 0x77, 0x40, 0x78, 0x9, 0x46, 0xb6, 0x7e, 0x5a, 0x44, 0xd4, 0x92, 0x40, 0xb1, 0xa6, 0x94, 0xf6, 0x79, 0xcd, 0x68, 0x9e, 0x72, 0xb, 0x3, 0x81, 0xad, 0xc6, 0x91, 0xc8, 0xb2, 0x4d, 0xe8, 0xea, 0x99, 0xa4, 0xc7, 0x39, 0xfd, 0x5a, 0x82, 0xc0, 0x6c, 0xe1, 0x2c, 0x9d, 0xf3, 0x34, 0xe9, 0x1c, 0x63, 0xb4, 0x8c, 0xb8, 0x33, 0xcd, 0xe, 0x57, 0xd2, 0x43, 0x5f, 0xbe, 0x1a, 0x60, 0x83, 0x27, 0x8a, 0xaf, 0x57, 0x4e, 0x2c, 0xb, 0x70, 0x6a, 0x27, 0x62, 0x5f, 0xb4, 0x93, 0x4e, 0x13, 0x91, 0x63, 0x0, 0x6f, 0xf9, 0x13, 0x19, 0x77, 0x3e, 0x99, 0x6e, 0x8, 0xe9, 0x1e, 0xb, 0xbf, 0x55, 0x77, 0x99, 0x71, 0xd4, 0x58, 0x24, 0x1c, 0xc2, 0x7b, 0x4a, 0xdb, 0x43, 0xf3, 0xc5, 0x25, 0x33, 0xf4, 0xa6, 0x13, 0x65, 0x95, 0x6f, 0x49, 0x63, 0x32, 0xaf, 0x91, 0xa4, 0xb5, 0xc, 0x21, 0x36, 0x5c, 0x5d, 0xa8, 0x2f, 0xea, 0xfc, 0x6e, 0xd8, 0x19, 0x54, 0x5c, 0x23, 0xe3, 0x15, 0x30, 0x20, 0xb8, 0x64, 0x71, 0x56, 0x3a, 0xf4, 0x1, 0x43, 0xa9, 0x21, 0x36, 0x58, 0xea, 0xb2, 0x32, 0x1f, 0x56, 0x67, 0xa8, 0x5d, 0xe8, 0x8d, 0x6a, 0xd7, 0x7d, 0x3a, 0xcc, 0x20, 0x5d, 0x13, 0xd, 0xb4, 0xd8, 0x89, 0x1, 0xe9, 0x2f, 0x6c, 0xc8, 0x38, 0x6a, 0x60, 0xcd, 0xbe, 0x8c, 0x60, 0x4d, 0x2c, 0x57, 0x79, 0x39, 0xb4, 0x4f, 0x6b, 0x6e, 0x8d, 0xb7, 0x38, 0x3, 0x30, 0x84, 0xf8, 0x49, 0x90, 0x93, 0x2a, 0x21, 0xf8, 0xff, 0x91, 0xa0, 0x9a, 0x28, 0xba, 0x11, 0x73, 0xb2, 0xdd, 0xb3, 0x24, 0x22, 0xc9, 0x99, 0xeb, 0x42, 0xaf, 0xea, 0x2, 0x17, 0x2a, 0x14, 0x51, 0xbd, 0x90, 0x70, 0xe2, 0x81, 0x88, 0x50, 0x24, 0xbb, 0xbe, 0x70, 0x8, 0xe3, 0x40, 0x88, 0x1b, 0xb2, 0xcd, 0x61, 0xeb, 0x36, 0xb6, 0xdd, 0x4a, 0xa3, 0x88, 0x3a, 0x79, 0xb8, 0x39, 0x9a, 0xcb, 0x86, 0x56, 0xd0, 0xdf, 0xd7, 0x52, 0x0, 0x63, 0xff, 0x1f, 0xf9, 0x5a, 0x62, 0x37, 0x6c, 0x1c, 0x99, 0xad, 0xf2, 0xdc, 0xdf, 0xe, 0x62, 0xe0, 0x6f, 0xdd, 0x1c, 0x23, 0xe8, 0xb4, 0xb2, 0x5d, 0xaa, 0xc3, 0x17, 0x91, 0xec, 0x77, 0x2d, 0xc9, 0x6e, 0xc1, 0xe8, 0xcc, 0xc4, 0xfb, 0x54, 0x55, 0x35, 0x7d, 0xd6, 0xc3, 0x26, 0x82, 0xb2, 0x7f, 0xc9, 0x29, 0xe5, 0xf2, 0x8c, 0xaf, 0x9f, 0xd9, 0xeb, 0xfe, 0xd7, 0x3a, 0x13, 0xb0, 0xd7, 0x4d, 0x9d, 0x47, 0x48, 0xd, 0xbc, 0x7d, 0x95, 0x50, 0x7, 0x8b, 0x25, 0x49, 0x2c, 0x9e, 0x2d, 0x3e, 0x3f, 0x5a, 0x86, 0xf5, 0x8f, 0xa, 0xd3, 0x57, 0x44, 0xed, 0xf2, 0x14, 0xe3, 0xf8, 0x10, 0x7, 0x5e, 0x77, 0xbe, 0x79, 0x7d, 0xe0, 0x86, 0x2d, 0x4b, 0x3e, 0x77, 0x14, 0x6, 0xf6, 0x0, 0x7f, 0x7c, 0x29, 0x42, 0x6c, 0x16, 0xfb, 0x3c, 0xc5, 0x48, 0x34, 0x98, 0x64, 0x6f, 0xdd, 0xe6, 0x44, 0xc5, 0x54, 0x2b, 0x28, 0x37, 0x10, 0x19, 0xef, 0xef, 0xe5, 0xf, 0x29, 0xb2, 0x47, 0x9c, 0xc6, 0x8e, 0x7c, 0x40, 0xd6, 0x81, 0xd8, 0xe4, 0x96, 0x35, 0x6d, 0x71, 0xbe, 0x30, 0x79, 0x88, 0x97, 0xae, 0x49, 0x64, 0x16, 0xd7, 0xa3, 0xab, 0x97, 0x51, 0xcf, 0xeb, 0xb1, 0x43, 0xe0, 0xc, 0x3, 0x6c, 0x54, 0x2f, 0x79, 0xf6, 0x9f, 0x5, 0x18, 0x87, 0xe4, 0x29, 0x84, 0x95, 0x4e, 0xa5, 0x84, 0x4d, 0xad, 0xf5, 0x6b, 0x9b, 0xbd, 0x19, 0xe8, 0xd2, 0xc, 0xb9, 0xa4, 0xea},
+               output224: []byte{0x1a, 0x74, 0x28, 0xb, 0x21, 0x7a, 0x3d, 0xa3, 0x2a, 0xce, 0x42, 0xd8, 0xae, 0x85, 0xdc, 0xf9, 0x4c, 0x33, 0x19, 0x98, 0xc2, 0xb1, 0x16, 0xff, 0x56, 0x86, 0x8d, 0x90},
+               output256: []byte{0x7c, 0x96, 0xcf, 0xf2, 0xd7, 0xca, 0xf0, 0x2d, 0x6f, 0xcd, 0x46, 0xa3, 0x12, 0xc, 0x1d, 0xd9, 0x40, 0xfa, 0xb7, 0xbc, 0x5b, 0x70, 0xcf, 0x97, 0xe1, 0x82, 0xcc, 0xf7, 0x1a, 0xbe, 0xb6, 0x43},
+               output384: []byte{0x6b, 0xdf, 0x6f, 0xd1, 0x83, 0xad, 0x49, 0xa1, 0xed, 0x91, 0xd9, 0xa0, 0x2d, 0xa0, 0x99, 0xf9, 0x56, 0x89, 0xf4, 0x37, 0x3e, 0xb5, 0x31, 0xd, 0xd4, 0xc1, 0xad, 0xd4, 0x51, 0xc8, 0xf6, 0x82, 0xe8, 0x89, 0x5e, 0xde, 0xf3, 0x4b, 0x5e, 0xf1, 0xe3, 0x5f, 0x3c, 0xab, 0x4e, 0x6e, 0xeb, 0x83},
+               output512: []byte{0x1e, 0x63, 0x25, 0xee, 0xe, 0x57, 0xfc, 0x92, 0x97, 0xed, 0x58, 0xd3, 0x5c, 0xa2, 0x9e, 0xb0, 0x6b, 0x3, 0x4f, 0xc3, 0x37, 0xa0, 0xad, 0xb, 0x45, 0x3a, 0xf7, 0x67, 0x76, 0xc5, 0x9f, 0xc9, 0xa1, 0x15, 0xae, 0x1c, 0x3d, 0xf9, 0x1b, 0x2, 0x58, 0x32, 0x81, 0xaf, 0xf8, 0x3b, 0xff, 0x91, 0x8f, 0x63, 0xb1, 0xd, 0x98, 0x22, 0x25, 0xf, 0xc4, 0xe2, 0x97, 0xb1, 0x7, 0x72, 0xe1, 0x81}},
+       testcase{
+               msg:       []byte{0x3, 0x97, 0x8f, 0xa9, 0xdb, 0xf1, 0xef, 0x4b, 0xea, 0xcb, 0x8f, 0x58, 0xd4, 0xc8, 0x2e, 0x29, 0x17, 0x70, 0x93, 0x52, 0xc, 0xdd, 0x8f, 0x3a, 0xf0, 0x19, 0xfd, 0x34, 0xee, 0x23, 0xb5, 0x89, 0x66, 0xbd, 0x79, 0x3d, 0x87, 0x83, 0xae, 0x53, 0xb4, 0xd0, 0x2, 0x38, 0xb8, 0x33, 0xeb, 0x41, 0xd7, 0x2a, 0x61, 0x69, 0x3, 0xa1, 0xc4, 0xd9, 0x72, 0xb, 0x6, 0x67, 0x45, 0xce, 0x4c, 0xb3, 0x20, 0x96, 0x7f, 0x9b, 0xee, 0xd5, 0x66, 0x90, 0x3e, 0x1d, 0xb3, 0xc3, 0x12, 0x4b, 0x64, 0x7, 0x2c, 0xe0, 0x48, 0xd2, 0xfc, 0x4c, 0x12, 0x38, 0xf9, 0x9, 0xe1, 0x52, 0xf4, 0x61, 0x78, 0xad, 0xd, 0x59, 0x72, 0x99, 0x32, 0x3f, 0x58, 0x43, 0x6b, 0xa3, 0xe1, 0x56, 0x27, 0xbd, 0xf9, 0x62, 0x34, 0x3f, 0x86, 0x2c, 0x76, 0x63, 0x79, 0x26, 0x9, 0x94, 0xb7, 0x1b, 0x4a, 0x5a, 0x8f, 0x54, 0xb9, 0xb, 0xc, 0x5a, 0x6b, 0x6b, 0x6b, 0x5c, 0x3c, 0x54, 0xbb, 0x7e, 0x41, 0x12, 0xeb, 0x7c, 0x86, 0xc4, 0xa6, 0x6b, 0x73, 0xc3, 0xa0, 0x10, 0xa5, 0x72, 0x32, 0xfd, 0xc7, 0x9a, 0xf0, 0x2b, 0xea, 0xfd, 0xcb, 0x97, 0x99, 0xef, 0xd4, 0x34, 0xa9, 0x88, 0x3c, 0xdb, 0x73, 0x42, 0xbc, 0x29, 0xbf, 0xb1, 0x76, 0xd2, 0xc6, 0x67, 0xf6, 0x55, 0x6a, 0xb4, 0x15, 0xf5, 0x48, 0x21, 0xca, 0xc1, 0xd7, 0x56, 0xa1, 0xc3, 0x30, 0xd, 0x8e, 0x66, 0x3b, 0x24, 0x18, 0xa6, 0x44, 0x3e, 0xd4, 0x79, 0x65, 0xb0, 0x5e, 0x2f, 0x2d, 0xdf, 0x33, 0x9d, 0xae, 0xf0, 0x37, 0x83, 0x15, 0xaa, 0xc, 0x55, 0xaf, 0xd9, 0xc4, 0x16, 0xba, 0xdf, 0xe0, 0x90, 0xe5, 0x16, 0xa1, 0x32, 0x61, 0x19, 0xa9, 0x7b, 0xb8, 0x42, 0x1a, 0x67, 0xaa, 0xd2, 0x5, 0x1c, 0xaa, 0xce, 0x47, 0x12, 0x2a, 0x86, 0xdc, 0x9, 0x23, 0x83, 0xeb, 0x35, 0xba, 0xe8, 0x36, 0x67, 0x6a, 0x23, 0x8d, 0xf8, 0x13, 0xe6, 0x1, 0x3a, 0xf9, 0x42, 0x3, 0x71, 0xe7, 0xca, 0x95, 0xc9, 0xda, 0x9e, 0x77, 0x20, 0x2a, 0x74, 0xb0, 0x24, 0xb, 0xd9, 0x74, 0x12, 0xb7, 0xb7, 0xbd, 0x13, 0x14, 0xf2, 0xea, 0xe0, 0xf1, 0xbe, 0x89, 0x7d, 0x7d, 0xda, 0xe8, 0xcb, 0x96, 0xcd, 0x77, 0x88, 0x75, 0x89, 0xf6, 0x6a, 0x90, 0x68, 0x73, 0x4f, 0x9c, 0xf, 0xf7, 0x77, 0x8a, 0xb4, 0x5c, 0x1a, 0x59, 0xec, 0x7d, 0xe3, 0x5e, 0x6a, 0xb5, 0xfd, 0x6f, 0xa0, 0xfe, 0x5, 0x54, 0x74, 0xcd, 0xf0, 0xcd, 0x1f, 0x27, 0xcc, 0xa4, 0x35, 0xa6, 0x62, 0x91, 0xdf, 0x8c, 0x1d, 0xb2, 0x31, 0xe1, 0xad, 0x3b, 0x38, 0xec, 0xd9, 0x27, 0x12, 0x59, 0xc7, 0x70, 0xc6, 0x9e, 0xd3, 0x62, 0x2a, 0x86, 0x90, 0x89, 0xcb, 0x91, 0x76, 0x92, 0xf5, 0xfe, 0x5, 0xbe, 0xda, 0x10, 0xd6, 0x76, 0x5b, 0x15, 0xfd, 0xf9, 0xab, 0xa, 0x1f, 0x5d, 0x20, 0x9c, 0xb5, 0x76, 0x68, 0x42, 0xa0, 0x6f, 0x6d, 0x8a, 0x29, 0x8a, 0xd0, 0x1b, 0x73, 0x5f, 0xa4, 0xfd, 0x63, 0x0, 0xe4, 0x6b, 0xf, 0x54, 0xc9, 0xbf, 0x47, 0x8, 0x92, 0x74, 0xdc, 0xb5, 0xdc, 0xd0, 0xd1, 0x4c, 0xad, 0x4, 0xec, 0xe2, 0x4a, 0x97, 0x19, 0x6a, 0xe5, 0x11, 0x76, 0xd4, 0xe1, 0x2, 0x44, 0x87, 0xc0, 0x75, 0xc8, 0x85, 0x3c, 0x9f, 0xaf, 0x36, 0x29, 0x1b, 0x9a, 0xb7, 0xb8, 0x85, 0x3e, 0x36, 0x6c, 0x90, 0x79, 0x54, 0x4c, 0x52, 0x8e, 0x10, 0x3a, 0xd5, 0x9, 0xc2, 0xa4, 0x86, 0x5, 0x1, 0x53, 0xf6, 0x6, 0x27, 0x3b, 0x72, 0x52, 0x69, 0x1e, 0x83, 0xbe, 0x3e, 0xf6, 0x89, 0xd3, 0x7e, 0x70, 0x48, 0x39, 0x6c, 0x17, 0x5c, 0x7e, 0x83, 0xa5, 0xa2, 0xd4, 0x5b, 0xb4, 0x8f, 0xd8, 0x67, 0xb0, 0x16, 0x95, 0x63, 0x6e, 0x38, 0x13, 0x91, 0x4a, 0x77, 0x15, 0xad, 0xa0, 0x4c, 0xad, 0x83, 0x8d, 0xd9, 0x8d, 0x94, 0x48, 0x93, 0x5c, 0x0, 0x4c, 0x8a, 0x90, 0x5c, 0xab, 0x6, 0xb4, 0xd6, 0xb3, 0x16, 0x23, 0x54, 0x53, 0x1e, 0x8a, 0xa7, 0x4b, 0xc5, 0x8f, 0x65, 0x70, 0x70, 0xed, 0x5f, 0x10, 0xe8, 0x55, 0x9a, 0x5b, 0x52, 0xc3, 0xee, 0x34, 0x44, 0x1a, 0x0, 0x3, 0xd8, 0x49, 0xaf, 0xe0, 0xe6, 0xd6, 0x39, 0x9d, 0x79, 0xa6, 0xb6, 0xb0, 0x63, 0x58, 0x11, 0x9b, 0xb8, 0xf6, 0x58, 0x68, 0x5e, 0xea, 0xe9, 0xa3, 0x92, 0xa6, 0xe8, 0xd5, 0x58, 0xf3, 0x42, 0xea, 0xf8, 0x6b, 0x1c, 0x83, 0x32, 0x18, 0xe0, 0xde, 0x3d, 0x4e, 0x69, 0xad, 0x82, 0x5c, 0x1d, 0xbb, 0x96, 0x6e, 0x9e, 0x13, 0x81, 0x2b, 0x64, 0x16, 0xd9, 0xcc, 0xf0, 0x36, 0x50, 0xf1, 0xfa, 0x85, 0x98, 0x2e, 0xb3, 0x7c, 0xb9, 0x26, 0xe4, 0x72, 0x63, 0x42, 0x34, 0xf9, 0x4b, 0xe6, 0xb2, 0x27, 0xe0, 0x3a, 0xb2, 0x7a, 0x60, 0xb8, 0x9c, 0x76, 0xf, 0x8a, 0x9b, 0x8c, 0x9a, 0xe8, 0xda, 0xb4, 0x31, 0x76, 0x27, 0x64, 0x4a, 0xa2, 0xb1, 0xca, 0x99, 0x66, 0xc4, 0x46, 0xdd, 0x59, 0x7d, 0xa3, 0x67, 0xa6, 0x3a, 0x30, 0xb1, 0xe3, 0xd4, 0x4d, 0x10, 0x79, 0x59, 0x8f, 0x23, 0x55, 0x74, 0x20, 0x2c, 0xa6, 0xf6, 0x4e, 0xad, 0xd, 0xb6, 0xe0, 0xd1, 0x40, 0x20, 0x97, 0x86, 0x6b, 0x14, 0x74, 0x30, 0xbe, 0xb0, 0xc6, 0xec, 0x3e, 0xbd, 0xd0, 0x2b, 0x42, 0x61, 0x4, 0x10, 0xce, 0xcc, 0x3c, 0xed, 0xa0, 0x9c, 0x9c, 0xcc, 0xfa, 0xd4, 0xba, 0x95, 0xc3, 0x2f, 0x26, 0x6b, 0x84, 0x86, 0x84, 0x3f, 0xf7, 0xc8, 0x54, 0xbb, 0x8d, 0xe, 0x44, 0xe1, 0x77, 0xca, 0x29, 0x4d, 0xea, 0x15, 0xf6, 0xa8, 0x65, 0x26, 0x63, 0x43, 0xca, 0x11, 0x44, 0xa7, 0xd3, 0xb, 0xbf, 0x48, 0xb0, 0xb4, 0xb4, 0xfb, 0x48, 0xee, 0x2b, 0xfa, 0x53, 0x1e, 0x23, 0x79, 0xf9, 0x7e, 0x5d, 0x78, 0x5f, 0x7f, 0xdc, 0x24, 0x27, 0xe, 0x98, 0x1f, 0x8d, 0xe2, 0xdd, 0x4, 0x5b, 0x36, 0xd6, 0xb2, 0xce, 0x12, 0xab, 0x79, 0x9, 0xc6, 0xcf, 0x28, 0x56, 0x55, 0xd, 0x60, 0xc, 0xa9, 0x94, 0x22, 0x90, 0x5c, 0x36, 0x17, 0x9c, 0x61, 0x87, 0x6e, 0x5c, 0x76, 0x33, 0x24, 0x52, 0x25, 0x27, 0xa2, 0xba, 0xe8, 0xb6, 0xac, 0xf3, 0x54, 0x22, 0x58, 0x3c, 0x88, 0x1b, 0xe7, 0x4d, 0x94, 0x3d, 0xfa, 0xcc, 0x1c, 0x25, 0xdf, 0xb, 0x16, 0xde, 0x5e, 0xf8, 0xfd, 0x43, 0x4f, 0xc3, 0x39, 0x6f, 0xdf, 0xd, 0xcf, 0x27, 0x2a, 0xba, 0x55, 0x16, 0xa8, 0x22, 0x1c, 0x29, 0xf0, 0x1d, 0x7d, 0xc0, 0xce, 0x38, 0x58, 0xf1, 0xc5, 0x56, 0xdb, 0xaa, 0x8e, 0x50, 0x16, 0xfc, 0xf8, 0xa4, 0xe2, 0xbe, 0x7b, 0x7d, 0xeb, 0x5d, 0x38, 0x8d, 0x61, 0x73, 0x97, 0xd6, 0x7b, 0xb7, 0x98, 0xc7, 0x5d, 0x7f, 0xd6, 0x99, 0xa7, 0xcc, 0xf1, 0xe4, 0x1, 0x92, 0xd6, 0x36, 0xc1, 0xab, 0x19, 0xcf, 0xd6, 0x29, 0x74, 0x66, 0xb7, 0x6, 0x7d, 0x2c, 0x43, 0x4d, 0xc1, 0xfc, 0xa9, 0x21, 0x51, 0x13, 0xa2, 0xc8, 0xca, 0xac, 0xef, 0xe, 0x29, 0x42, 0x82, 0x34, 0x7c, 0x65, 0xe, 0x41, 0xe3, 0x76, 0xcc, 0xfc, 0x3d, 0x88, 0x3e, 0xbe, 0x1a, 0x60, 0x96, 0xfc, 0xd2, 0x74, 0xfe, 0x72, 0xd4, 0x8, 0xaa, 0xef, 0x73, 0xcd, 0xdf, 0xe8, 0x57, 0x35, 0x86, 0xa6, 0x76, 0xa9, 0x42, 0xa8, 0xd, 0xdf, 0xd2, 0xab, 0xd8, 0x60, 0xb1, 0xd6, 0xe6, 0xe7, 0x7e, 0x65, 0x64, 0x66, 0x76, 0x94, 0x7, 0x50, 0xc0, 0x91, 0xc0, 0xaa, 0x37, 0x10, 0xe3, 0xe3, 0xec, 0x51, 0x4, 0xcc, 0xe4, 0xbf, 0x7c, 0x65, 0xcb, 0x32, 0xcb, 0x16, 0x8e, 0xa, 0xf7, 0xf6, 0x38, 0x52, 0xbf, 0x6e, 0x40, 0xd6, 0x76, 0x19, 0xc0, 0xa5, 0x76, 0x9a, 0xcc, 0x96, 0x3b, 0xed, 0xa4, 0x82, 0xa0, 0x60, 0xb9, 0xd6, 0xe1, 0xf5, 0x1b, 0x7f, 0x24, 0x4b, 0x4e, 0x0, 0x32, 0xe1, 0xa6, 0x9, 0x3a, 0x89, 0xb4, 0xba, 0x1a, 0xb9, 0xfc, 0x7, 0x6f, 0x25, 0xd1, 0xe5, 0x5f, 0x64, 0x93, 0xf3, 0xda, 0xcb, 0x5b, 0x9a, 0x6e, 0x61, 0xbf, 0xd6, 0x29, 0x67, 0xed, 0x30, 0x45, 0x18, 0x39, 0x3d, 0x3d, 0x3d, 0xc5, 0x7, 0x54, 0x69, 0x95, 0x23, 0x68, 0x25, 0x78, 0x51, 0xfc, 0x78, 0xc8, 0x5a, 0x20, 0x39, 0xab, 0x20, 0x4f, 0xfc, 0xfe, 0xc5, 0xf1, 0x40, 0xb4, 0xac, 0x99, 0x90, 0x21, 0xe5, 0x3c, 0x49, 0xc0, 0xb5, 0xb7, 0xb9, 0xf9, 0x59, 0x7, 0xcb, 0x6b, 0xbe, 0xef, 0x40, 0x8, 0x8a, 0xc8, 0xf, 0x4a, 0x2c, 0xaa, 0xab, 0x81, 0x5, 0xca, 0x5a, 0x4, 0x12, 0x3a, 0xb4, 0xd8, 0x3a, 0x1f, 0xa1, 0xe7, 0x73, 0x8a, 0xd2, 0x59, 0xe, 0x8, 0x38, 0x55, 0x63, 0x22, 0x2, 0xb, 0xfd, 0x5d, 0x60, 0x35, 0x29, 0x43, 0x5f, 0xbd, 0xbb, 0x95, 0x1b, 0x76, 0xaa, 0xe8, 0xa9, 0xd6, 0x3e, 0x68, 0xba, 0x7, 0x79, 0xf1, 0x97, 0xd9, 0xe5, 0xf, 0xa3, 0x1d, 0x11, 0x2a, 0x5c, 0xe4, 0xaf, 0xde, 0x8f, 0x1f, 0xec, 0x94, 0x41, 0x2d, 0xf4, 0x4d, 0x78, 0xc9, 0x88, 0x5f, 0xf6, 0x78, 0x14, 0xf, 0xd6, 0x36, 0xad, 0x28, 0xd9, 0x2, 0x8a, 0x6e, 0x19, 0x3b, 0x5d, 0xb8, 0x56, 0x69, 0xd8, 0x5d, 0x13, 0xfa, 0x7f, 0xf5, 0xb9, 0x29, 0x4a, 0x4, 0x23, 0xb3, 0xdb, 0xce, 0x88, 0x45, 0x4b, 0xa6, 0xc6, 0x38, 0x61, 0x49, 0xb4, 0x71, 0xe5, 0xe2, 0xe, 0x5c, 0x39, 0xf5, 0xfe, 0x85, 0x86, 0x9d, 0xb, 0x23, 0x52, 0x1d, 0xff, 0x66, 0x7e, 0x57, 0x44, 0xc2, 0xe0, 0xc2, 0x73, 0xa9, 0xdb, 0x6, 0x40, 0x5e, 0x95, 0x34, 0x6a, 0x94, 0xc3, 0xa9, 0x40, 0x59, 0xc9, 0xc7, 0xa2, 0x3b, 0xea, 0x47, 0x6f, 0xc1, 0xaf, 0xbf, 0x91, 0xc0, 0x7, 0x18, 0xb8, 0x44, 0xba, 0x4f, 0x3a, 0xf8, 0x15, 0x89, 0x6e, 0xcd, 0xcb, 0x58, 0x12, 0x4d, 0x1d, 0x2, 0x18, 0xf2, 0x92, 0xb6, 0x5d, 0x15, 0x24, 0x7, 0x97, 0x54, 0x23, 0x33, 0x2a, 0x8f, 0xa7, 0x67, 0x6a, 0xdd, 0x34, 0x1d, 0x4b, 0xb8, 0xf8, 0x10, 0x86, 0xc4, 0x17, 0xaa, 0x48, 0x9c, 0x41, 0x25, 0x72, 0x7f, 0x42, 0xcf, 0x52, 0xdf, 0x31, 0x64, 0xea, 0x72, 0x88, 0x6c, 0xb8, 0xca, 0xbb, 0x78, 0x72, 0xe3, 0x89, 0x8c, 0xc5, 0x57, 0xef, 0xa6, 0xbe, 0x5f, 0x74, 0x31, 0xe9, 0x9c, 0xcd, 0xcc, 0x2e, 0x8, 0x74, 0x94, 0xda, 0x48, 0x37, 0x51, 0xf9, 0x61, 0xed, 0x7b, 0x60, 0xf5, 0xe7, 0xf9, 0x3e, 0x10, 0x28, 0x7d, 0x68, 0x6d, 0xde, 0xc6, 0x75, 0x7, 0x1f, 0x5d, 0xc0, 0xba, 0xdd, 0x6f, 0x4f, 0xff, 0x7, 0xcb, 0x27, 0xd2, 0x51, 0xfa, 0x41, 0x58, 0x2a, 0x4f, 0x70, 0x8e, 0xd9, 0xbd, 0x77, 0x66, 0x20, 0x96, 0xe0, 0xf2, 0xbe, 0x33, 0xc4, 0x37, 0x5b, 0xb5, 0x1a, 0x5, 0x17, 0x9, 0xc4, 0xf4, 0x10, 0x26, 0xec, 0x22, 0xd9, 0x75, 0x9a, 0x82, 0x9d, 0x65, 0x4f, 0x16, 0x6d, 0xa6, 0xbc, 0x15, 0x8d, 0x7, 0x6e, 0x75, 0x3f, 0x6c, 0x0, 0x4f, 0x3f, 0x2e, 0xa5, 0x56, 0x2c, 0xb6, 0x5a, 0xbc, 0x5d, 0x53, 0x2b, 0xd3, 0xd7, 0x82, 0xf9, 0xce, 0x9c, 0x60, 0x6, 0xa0, 0xeb, 0xb8, 0xf0, 0x9e, 0xea, 0xf4, 0xfa, 0xe4, 0xa, 0x77, 0x70, 0x81, 0xbc, 0xa8, 0x21, 0x10, 0xca, 0x6d, 0x3f, 0xe2, 0x5b, 0x56, 0x58, 0x9b, 0xbe, 0xcb, 0x52, 0xda, 0x66, 0x8b, 0x22, 0xf5, 0xfa, 0x38, 0xe1, 0x68, 0x4f, 0x18, 0x68, 0xca, 0xf0, 0x18, 0xe4, 0x9d, 0xba, 0x28, 0xc4, 0x5d, 0xb8, 0x6f, 0xd7, 0x9, 0x21, 0xaa, 0xfa, 0x4e, 0x56, 0xb5, 0x89, 0xa0, 0x1a, 0xfe, 0xbd, 0xda, 0xb7, 0x84, 0x36, 0xc0, 0x50, 0xa4, 0xdb, 0xf2, 0x6a, 0xa8, 0x2b, 0x76, 0x18, 0xae, 0x1b, 0x2e, 0xac, 0x7f, 0xd1, 0xd, 0x2d, 0x3c, 0x97, 0x45, 0x31, 0x76, 0xa, 0xc0, 0xed, 0x2a, 0xb4, 0xf1, 0xd4, 0x2d, 0x92, 0xb0, 0xe4, 0x45, 0xf3, 0x2a, 0x6f, 0xa6, 0x97, 0xec, 0xba, 0x29, 0x9f, 0xd0, 0x61, 0xa2, 0x9a, 0x84, 0x8e, 0xc6, 0x36, 0xe0, 0xb7, 0xf0, 0xe, 0x63, 0x10, 0x20, 0x8f, 0x9d, 0x21, 0xd2, 0x29, 0xcc, 0xa2, 0x50, 0x55, 0x28, 0xad, 0x91, 0xdd, 0x22, 0xe4, 0xee, 0xf4, 0xe7, 0x23, 0x31, 0x4c, 0xac, 0x64, 0x8c, 0x26, 0xcc, 0x85, 0xa9, 0xf6, 0x80, 0x8, 0x76, 0x38, 0x38, 0x2, 0x5b, 0xe8, 0xaa, 0x59, 0x8f, 0x1e, 0x43, 0x33, 0x1c, 0x34, 0x96, 0x9, 0x5b, 0xc0, 0xc5, 0xe0, 0x39, 0x9e, 0xe1, 0xcc, 0x56, 0xaa, 0xf8, 0x8a, 0xef, 0x50, 0x71, 0x6b, 0x37, 0xeb, 0x15, 0x6f, 0xcb, 0xbe, 0x1b, 0x10, 0xc2, 0x1b, 0xa3, 0x1, 0x15, 0x8e, 0x42, 0x2d, 0x63, 0x11, 0x6d, 0x7d, 0xb8, 0xc6, 0x93, 0x57, 0x1, 0xfa, 0x7b, 0x3c, 0x2a, 0xce, 0x99, 0x68, 0xa8, 0x1f, 0x90, 0x63, 0xea, 0xcc, 0xe5, 0x79, 0x4a, 0x25, 0x5d, 0xd5, 0xa, 0x41, 0x2d, 0x68, 0xa4, 0xd1, 0xdd, 0x12, 0x18, 0x9d, 0xa6, 0x12, 0xc2, 0x93, 0xaa, 0x9a, 0x47, 0x56, 0xad, 0xb2, 0x5b, 0x58, 0x54, 0x52, 0xe6, 0xf3, 0x84, 0x79, 0xd6, 0x3b, 0xff, 0xab, 0xe4, 0xe8, 0x7e, 0xc4, 0x39, 0x56, 0x68, 0x46, 0x93, 0x2, 0x5f, 0xf5, 0x90, 0x87, 0x42, 0x3c, 0x9, 0xe8, 0xdf, 0x4b, 0xc2, 0x4, 0xf8, 0x9a, 0xa9, 0xc0, 0x76, 0x9b, 0x32, 0xa7, 0x0, 0x4d, 0xbe, 0x9f, 0x45, 0x21, 0xb9, 0x93, 0xca, 0x92, 0x94, 0x57, 0x31, 0xca, 0xc8, 0x0, 0xea, 0xe7, 0x38, 0xfb, 0x17, 0x43, 0x2b, 0xee, 0x22, 0xa9, 0x31, 0x95, 0x2d, 0x7a, 0x93, 0x42, 0xe0, 0x49, 0xe5, 0xc4, 0x22, 0x7, 0xeb, 0xa1, 0x59, 0x27, 0xbf, 0x16, 0x30, 0xe0, 0x3a, 0x2, 0xae, 0xf6, 0xdf, 0xe2, 0xf4, 0xd, 0x5a, 0x45, 0xf7, 0x71, 0x0, 0x2, 0x13, 0xf6, 0x4c, 0xc0, 0x7d, 0xca, 0x61, 0xc5, 0xb2, 0xa6, 0x8d, 0xfb, 0x38, 0xe4, 0x2b, 0xc0, 0x8b, 0xf3, 0xb6, 0x4c, 0x14, 0x6e, 0xd3, 0xc2, 0x91, 0xe5, 0xb9, 0x4f, 0x9, 0xed, 0xe9, 0xd, 0x6c, 0x9c, 0x6f, 0xfe, 0x75, 0x2a, 0xad, 0x17, 0xf9, 0x77, 0x7a, 0xa8, 0x6b, 0xf1, 0xa6, 0xb5, 0xc4, 0x87, 0x6c, 0xea, 0x63, 0x1e, 0x13, 0x44, 0x3c, 0x0, 0x70, 0xf, 0x93, 0xb4, 0xf7, 0x97, 0x2a, 0xa7, 0xfa, 0x21, 0x17, 0x3e, 0x71, 0x70, 0xde, 0x5f, 0x3e, 0x3b, 0x7f, 0x6f, 0x75, 0x5b, 0xae, 0xee, 0xc9, 0xd8, 0x80, 0x15, 0x5a, 0x64, 0xb, 0xe6, 0x12, 0x67, 0xce, 0xb0, 0x5c, 0xea, 0x10, 0x2c, 0x94, 0x4a, 0xa4, 0x5c, 0x6d, 0x40, 0x23, 0xea, 0x25, 0x87, 0x37, 0xdd, 0x75, 0x2a, 0x44, 0xb2, 0x7e, 0x2b, 0x5c, 0x16, 0x90, 0x61, 0x56, 0xa7, 0x74, 0xdd, 0x40, 0xd4, 0x7d, 0x13, 0xe2, 0x21, 0xc2, 0x7e, 0xff, 0xb4, 0xcc, 0xe1, 0x0, 0xb3, 0xeb, 0x54, 0x29, 0xff, 0x11, 0x5b, 0x27, 0x0, 0x6e, 0x33, 0x8f, 0x5f, 0xdf, 0x66, 0x3b, 0xdc, 0x90, 0x69, 0x4d, 0x32, 0x53, 0xc1, 0x1a, 0x24, 0xbc, 0xe4, 0x5, 0x3, 0xbb, 0x4, 0x91, 0x7e, 0xa4, 0xfe, 0x22, 0xba, 0x5e, 0x8d, 0x87, 0x83, 0x7c, 0x34, 0x4c, 0x2f, 0xb1, 0x7e, 0xac, 0x54, 0x87, 0xaa, 0x73, 0x72, 0xec, 0x20, 0x2a, 0x6b, 0xc8, 0x1d, 0x80, 0xde, 0xc3, 0x52, 0xcd, 0x9, 0xc, 0x4, 0xf, 0x1a, 0xd3, 0x38, 0x59, 0xc0, 0x2b, 0x7e, 0x21, 0x38, 0x1b, 0xea, 0x28, 0xff, 0xe, 0x97, 0x1d, 0x52, 0xd9, 0x0, 0x64, 0x24, 0xee, 0xdd, 0x72, 0xa9, 0x29, 0x51, 0xda, 0x1f, 0xe3, 0xc4, 0x8b, 0x45, 0xd5, 0x1b, 0xe8, 0x43, 0xa, 0x99, 0xc9, 0xca, 0x15, 0x90, 0x93, 0xdd, 0xa7, 0x5c, 0xe2, 0xfa, 0x8a, 0xcd, 0x7e, 0x6, 0xa3, 0x1a, 0x1c, 0xd3, 0xa6, 0xf, 0xe3, 0x3a, 0x24, 0x1b, 0x9a, 0x64, 0x9f, 0xf5, 0x53, 0x33, 0x3b, 0x9c, 0x9c, 0xd7, 0x3, 0x80, 0xb4, 0x94, 0xa7, 0x31, 0x47, 0x86, 0x98, 0xd8, 0x33, 0xb8, 0x9d, 0xeb, 0x3a, 0xd7, 0x9c, 0x5f, 0xa8, 0xe, 0xd8, 0xbb, 0x3, 0xad, 0x1d, 0x42, 0xf2, 0xc8, 0xd2, 0xfe, 0x4c, 0x45, 0x7a, 0x1, 0x9b, 0xe9, 0x5f, 0x26, 0x70, 0x80, 0xb3, 0x20, 0x38, 0xe5, 0x5a, 0x57, 0xe4, 0x8d, 0x58, 0x4, 0x4a, 0xcc, 0x69, 0x1d, 0xab, 0x6d, 0x7e, 0x17, 0xbc, 0x62, 0x9e, 0x78, 0xef, 0x78, 0x79, 0xbe, 0x8d, 0x39, 0x8c, 0x77, 0xc1, 0x15, 0xf4, 0x54, 0x7f, 0x32, 0xb1, 0xcf, 0xa1, 0x81, 0xaf, 0xf8, 0xf3, 0xdf, 0xc6, 0x6c, 0x6e, 0x9a, 0x75, 0x4b, 0x64, 0xba, 0x93, 0x2e, 0x70, 0x1, 0x27, 0x47, 0x6c, 0x59, 0x4, 0x1, 0x45, 0x44, 0x96, 0xf6, 0x27, 0x42, 0xb8, 0x5c, 0x17, 0x68, 0x71, 0x40, 0xe1, 0x32, 0x22, 0x51, 0x2c, 0x36, 0x9f, 0xa0, 0x82, 0x5c, 0x7, 0xd2, 0x6e, 0x5f, 0x1, 0xa7, 0x74, 0xff, 0x7a, 0x75, 0x5d, 0x4c, 0xf1, 0x7f, 0xd7, 0xf2, 0x1d, 0xed, 0x83, 0xa9, 0xfe, 0xe4, 0x3e, 0xcb, 0x42, 0xd4, 0x49, 0x8a, 0xb1, 0xc3, 0xa9, 0x37, 0xaa, 0xe6, 0x92, 0x19, 0xfc, 0xc7, 0xc2, 0x7, 0x80, 0xcc, 0x5a, 0xe8, 0x6f, 0x96, 0x9f, 0xaa, 0x6, 0x7b, 0xca, 0x9c, 0x6c, 0x3c, 0x7c, 0x86, 0x6d, 0xa5, 0xc, 0xd1, 0xce, 0xb2, 0x55, 0xd1, 0x4, 0xa3, 0x14, 0xd9, 0x50, 0x69, 0x57, 0x78, 0x2f, 0xcd, 0xf1, 0xdb, 0xe0, 0x39, 0x45, 0xc3, 0x6d, 0x38, 0xa4, 0x32, 0x2, 0xd7, 0xb3, 0x44, 0x41, 0xb8, 0x2e, 0x61, 0xe7, 0x2a, 0xd4, 0x1, 0x35, 0x5f, 0xae, 0x75, 0x57, 0xef, 0xee, 0xb, 0xb6, 0xa9, 0x7, 0x60, 0xee, 0x54, 0xcc, 0x50, 0xe3, 0x9a, 0x84, 0x4e, 0x8f, 0x3, 0x7f, 0xc9, 0xca, 0xc0, 0xb0, 0x55, 0xf7, 0x1d, 0xce, 0xa1, 0xaa, 0xfb, 0xa7, 0xf0, 0xe7, 0x70, 0xe6, 0x1e, 0xc8, 0x37, 0x1, 0x59, 0xf8, 0x34, 0xc, 0x6f, 0xcb, 0x1f, 0x37, 0x27, 0xe, 0x4a, 0x71, 0xcf, 0x11, 0x10, 0xb7, 0xda, 0x39, 0x9f, 0xef, 0x7e, 0x46, 0x4, 0xfe, 0x7b, 0xc4, 0x1c, 0x71, 0xf3, 0x66, 0xa4, 0x51, 0xb4, 0xcb, 0x53, 0xcf, 0x45, 0x69, 0xc8, 0xc9, 0xa8, 0xa1, 0x98, 0x97, 0xa4, 0xb, 0xe9, 0x6a, 0x92, 0xee, 0x6b, 0xc8, 0x88, 0xe8, 0x58, 0x58, 0x32, 0xdc, 0x4f, 0xea, 0xb3, 0x1a, 0x40, 0x74, 0x32, 0x37, 0xbf, 0xb0, 0xa3, 0x46, 0xea, 0x90, 0xac, 0xd8, 0x48, 0xcc, 0x64, 0x8b, 0x9f, 0x84, 0x4c, 0x60, 0x6c, 0x1, 0x88, 0x16, 0xca, 0xd, 0xcc, 0x18, 0x90, 0x36, 0xa2, 0xcf, 0xff, 0xc, 0x41, 0x89, 0x1b, 0xd4, 0xc3, 0x26, 0x6, 0xd8, 0x7d, 0x67, 0xa6, 0xea, 0x61, 0x75, 0x4a, 0x15, 0xb, 0xba, 0x6f, 0xff, 0x9a, 0xe, 0x57, 0x41, 0x4a, 0xb, 0x91, 0xcf, 0xd0, 0x87, 0x95, 0x5a, 0xae, 0x7b, 0xc4, 0xfd, 0xa9, 0x5a, 0x44, 0x99, 0xfe, 0xde, 0x1b, 0x4d, 0x84, 0x4a, 0xe0, 0x57, 0x4, 0x5a, 0xdb, 0x7c, 0x86, 0xb7, 0x2d, 0xe4, 0xb2, 0x5f, 0xac, 0x9, 0x95, 0xef, 0xfb, 0x5c, 0xfa, 0xb3, 0x72, 0xad, 0x89, 0x57, 0x96, 0xf9, 0x87, 0x3f, 0x5b, 0xb, 0x95, 0x45, 0x83, 0xed, 0x81, 0x5b, 0x45, 0x23, 0xb3, 0xb5, 0xa1, 0x40, 0xa2, 0xdd, 0xb7, 0xa5, 0xaa, 0x2b, 0x61, 0xad, 0x8d, 0x6, 0xbb, 0x70, 0xef, 0xad, 0x3e, 0xa2, 0x37, 0xf6, 0x60, 0x6a, 0x5d, 0xbc, 0xb8, 0x8f, 0x46, 0xdd, 0x75, 0xac, 0x84, 0x32, 0x3, 0x90, 0x90, 0xae, 0x24, 0x58, 0x67, 0x2d, 0xb7, 0x80, 0xa, 0x75, 0x14, 0xa2, 0x26, 0x51, 0x6f, 0x41, 0xcc, 0xfd, 0x8, 0xa1, 0xf0, 0x72, 0xa, 0x77, 0xe5, 0xfc, 0x1, 0x6b, 0x1b, 0x92, 0x7b, 0x82, 0x87, 0x84, 0xe4, 0x21, 0xc0, 0xc9, 0xe0, 0x4c, 0x45, 0xa7, 0x9c, 0x2e, 0x8d, 0xb1, 0x6e, 0x7a, 0x4e, 0x9, 0x2d, 0x73, 0xc5, 0x12, 0x4d, 0x2b, 0xd1, 0x46, 0x38, 0x13, 0xc7, 0x95, 0x81, 0xab, 0x46, 0x8e, 0x2d, 0x37, 0xdf, 0x39, 0x25, 0x18, 0x98, 0x33, 0xf8, 0xb3, 0x72, 0x83, 0x8a, 0x9f, 0x89, 0xae, 0xc3, 0x58, 0x7e, 0x2b, 0x19, 0x4, 0x4c, 0x9, 0x51, 0x7, 0xac, 0xd4, 0x35, 0xb9, 0x34, 0xf, 0xa4, 0x9a, 0xdf, 0x11, 0xf1, 0x5, 0xd2, 0xc8, 0x7b, 0x9f, 0x5a, 0xb6, 0x2e, 0x38, 0x2e, 0xb5, 0x69, 0xd7, 0x9c, 0xd8, 0x67, 0x8a, 0x5b, 0x1a, 0x1f, 0x7d, 0x0, 0xf3, 0x80, 0x31, 0x69, 0x4e, 0xe6, 0xaa, 0xed, 0x22, 0x3b, 0xa1, 0x23, 0xe8, 0x82, 0x2b, 0xe1, 0x18, 0x1a, 0x7b, 0xbc, 0xe5, 0xdc, 0x90, 0xf8, 0xdf, 0x9e, 0x3f, 0xba, 0xf9, 0x6e, 0x4d, 0x82, 0xb3, 0x88, 0x88, 0x9f, 0x2b, 0xca, 0xcd, 0xd8, 0x1a, 0xbd, 0x5b, 0x77, 0x7d, 0x78, 0xca, 0xb2, 0xea, 0xca, 0x14, 0xca, 0x97, 0x28, 0x16, 0x3, 0xe5, 0xfd, 0xc, 0x67, 0x8, 0xcc, 0x9e, 0x22, 0x3d, 0x4, 0x5e, 0xe2, 0xd1, 0x99, 0x4b, 0x5d, 0xee, 0x24, 0x83, 0x90, 0xfa, 0x1, 0xcb, 0x40, 0x47, 0x47, 0x33, 0x12, 0xf1, 0x42, 0x93, 0xbd, 0x9f, 0x57, 0x45, 0x35, 0x1, 0x5a, 0x5f, 0xd0, 0xd1, 0x6f, 0xac, 0xe6, 0xb0, 0xf8, 0x8f, 0xfc, 0x94, 0x9a, 0xb4, 0x58, 0xa2, 0xc4, 0xf, 0xc9, 0x80, 0x64, 0x1, 0xbc, 0x5e, 0x91, 0x7e, 0xaf, 0xc5, 0x6a, 0x8d, 0xb3, 0x23, 0xc1, 0xfb, 0xe6, 0xa5, 0x7c, 0xee, 0xf5, 0xe6, 0x38, 0x28, 0x8c, 0x9, 0x17, 0xf0, 0xbe, 0x1b, 0x8d, 0x71, 0x8b, 0xc0, 0xe7, 0xb2, 0xb9, 0x6e, 0x46, 0x1e, 0xde, 0xc2, 0xd0, 0xc5, 0x3b, 0x48, 0x18, 0x45, 0xbd, 0x90, 0x6a, 0x97, 0x23, 0x36, 0xdb, 0x93, 0xdb, 0x64, 0x99, 0xd2, 0x7b, 0x9b, 0x2a, 0x5c, 0xad, 0xcb, 0xc9, 0x4d, 0xc0, 0x93, 0xb8, 0xb1, 0x1c, 0x9d, 0x8b, 0xf0, 0x63, 0x30, 0xd1, 0x5a, 0x22, 0x32, 0x36, 0xd6, 0xe1, 0x67, 0xce, 0xa4, 0x57, 0xc4, 0x6b, 0x2, 0xbe, 0xf9, 0x4a, 0x93, 0x6e, 0xb, 0xb9, 0x8e, 0x14, 0xc8, 0x94, 0x4c, 0x5, 0x3d, 0xfc, 0xd7, 0xa2, 0x43, 0xe7, 0x48, 0x70, 0x9a, 0x1c, 0x62, 0x5a, 0x38, 0xeb, 0x15, 0x6d, 0x94, 0x3f, 0x12, 0x91, 0x7a, 0xa0, 0x77, 0xdb, 0xfa, 0x57, 0xb2, 0x4e, 0x26, 0xc2, 0x84, 0x50, 0x9d, 0x53, 0x4c, 0x14, 0x51, 0xf4, 0x25, 0xd5, 0xd2, 0x54, 0x56, 0x78, 0x7f, 0x97, 0x40, 0x12, 0x13, 0x37, 0x4e, 0xf7, 0x7d, 0x6c, 0x86, 0xbe, 0x8e, 0xd, 0x31, 0x15, 0x43, 0xb1, 0x5c, 0xe7, 0xe4, 0x2a, 0x15, 0x2f, 0xfd, 0x10, 0x30, 0x3b, 0x50, 0x4, 0x6b, 0xe0, 0x74, 0x64, 0xc9, 0xb9, 0x9b, 0x51, 0x1, 0x8a, 0x42, 0x6, 0x20, 0x54, 0xdd, 0x76, 0x54, 0x19, 0x3e, 0x81, 0xa0, 0x59, 0x9, 0xca, 0x7b, 0xb2, 0x8c, 0x61, 0x7f, 0x6, 0x4f, 0x99, 0x36, 0xc0, 0xd3, 0x59, 0x8, 0x82, 0xf0, 0xc2, 0x6b, 0xa8, 0x9f, 0xe6, 0xd2, 0xb2, 0xf5, 0xb, 0x3c, 0x67, 0xda, 0x8c, 0xfc, 0xdc, 0xde, 0xa6, 0xe6, 0x0, 0xcd, 0xb6, 0xb0, 0x9f, 0xb3, 0xc1, 0x70, 0x97, 0x9b, 0xc9, 0xb1, 0xab, 0xff, 0x44, 0xeb, 0x22, 0xe6, 0x6e, 0x74, 0xfc, 0xe4, 0xff, 0xb6, 0xe5, 0xb3, 0x73, 0xf2, 0xf1, 0xb, 0xc, 0xa5, 0xee, 0x4c, 0x62, 0x1f, 0x21, 0xf7, 0xa6, 0xf8, 0x63, 0xfa, 0x73, 0x91, 0x72, 0xc1, 0x35, 0x56, 0x6b, 0x55, 0x91, 0x6f, 0xb, 0xcc, 0x6e, 0xe4, 0xcf, 0xd, 0x35, 0xb1, 0x60, 0xac, 0x8a, 0x15, 0x56, 0xe4, 0x32, 0x71, 0x99, 0xdb, 0xf5, 0x36, 0x82, 0x47, 0x1b, 0xae, 0xf0, 0x9f, 0xab, 0x7a, 0xbe, 0xdf, 0x51, 0x84, 0x27, 0xba, 0xff, 0x19, 0xf2, 0x94, 0x29, 0xc2, 0xdf, 0xd9, 0x58, 0x78, 0x43, 0xd5, 0xce, 0xd1, 0x22, 0x72, 0xa8, 0xb, 0x17, 0xa5, 0xfb, 0xdb, 0x1e, 0xf7, 0x7a, 0x51, 0xc, 0xff, 0xe7, 0xb, 0x7a, 0xb6, 0xf5, 0x92, 0x76, 0x34, 0x18, 0xaf, 0x4c, 0xb5, 0x55, 0xc0, 0x80, 0xd9, 0x19, 0x6b, 0xd8, 0x95, 0x1a, 0x20, 0x47, 0x4, 0x6d, 0x8e, 0x1e, 0xd6, 0xa, 0x67, 0xdc, 0x63, 0xe0, 0x12, 0x94, 0xe7, 0x34, 0xcd, 0x77, 0xf4, 0x30, 0xae, 0x77, 0x1e, 0x72, 0xa2, 0x9a, 0x9a, 0x15, 0xf0, 0xdc, 0x10, 0xa4, 0xb, 0x18, 0x72, 0x91, 0x73, 0xa5, 0x4b, 0x62, 0xcc, 0xf0, 0xcb, 0xb5, 0xb6, 0x86, 0x4, 0x43, 0x16, 0x61, 0xb6, 0x13, 0xde, 0xeb, 0xc2, 0x0, 0xd0, 0xf1, 0x9f, 0x14, 0x2b, 0x85, 0x50, 0xec, 0xf2, 0x56, 0xdc, 0xb2, 0x23, 0x30, 0x69, 0xbc, 0xa8, 0x39, 0x36, 0x5e, 0xb8, 0xba, 0x87, 0x20, 0x4f, 0x83, 0xa8, 0xfc, 0xa2, 0x37, 0xb1, 0x1f, 0x1a, 0xda, 0x6c, 0x44, 0xea, 0xf2, 0xaa, 0xeb, 0xb1, 0xb8, 0xb5, 0xfa, 0xee, 0xbd, 0x2e, 0xfa, 0xfc, 0x7, 0x64, 0x17, 0x5a, 0xaf, 0x9a, 0x9a, 0x96, 0x20, 0xf5, 0x33, 0xc2, 0x6c, 0xc2, 0x37, 0xb2, 0x8, 0xad, 0x67, 0x89, 0xca, 0x6f, 0x60, 0xb3, 0x9f, 0xd5, 0xa0, 0xe0, 0x7a, 0xd5, 0x82, 0xf7, 0x1, 0x11, 0xc2, 0x56, 0x16, 0xd0, 0xa3, 0x46, 0x67, 0x69, 0xb3, 0xe9, 0x45, 0xfa, 0x23, 0xdc, 0xfc, 0x72, 0x55, 0xc0, 0x3a, 0xad, 0x9, 0x97, 0x7e, 0xbc, 0xb0, 0x46, 0x70, 0x7b, 0x6a, 0xae, 0x59, 0xea, 0x80, 0x3c, 0xb5, 0x6d, 0x22, 0x38, 0x16, 0xf0, 0x6, 0xb3, 0xef, 0x6, 0xfb, 0x67, 0x78, 0x7b, 0xb0, 0x9f, 0x41, 0xa6, 0xb4, 0x1d, 0x6f, 0xad, 0x4, 0xad, 0xe0, 0x14, 0x43, 0x4e, 0x3c, 0xde, 0x87, 0xf5, 0xcf, 0xe8, 0xf1, 0x4d, 0x98, 0x22, 0xd9, 0x90, 0x74, 0x5b, 0x26, 0xa6, 0xc0, 0xbd, 0x49, 0xa7, 0xd, 0x34, 0xc, 0x62, 0x88, 0xc1, 0x33, 0xee, 0x43, 0xa1, 0xb2, 0x2b, 0xb1, 0xff, 0xc3, 0x94, 0x8f, 0x1f, 0xb0, 0x30, 0x47, 0xcf, 0x6e, 0xa6, 0x4, 0x6, 0x7d, 0x33, 0xd0, 0xf, 0x3a, 0x1c, 0x88, 0xca, 0x52, 0x9b, 0x7b, 0x51, 0x5f, 0x3f, 0xec, 0xaa, 0x3b, 0xf1, 0xcf, 0x56, 0x86, 0xe5, 0xe, 0x55, 0xa2, 0xc3, 0xe4, 0x17, 0x6e, 0x7b, 0x2, 0x80, 0x13, 0x2a, 0x8f, 0x21, 0x69, 0x81, 0x37, 0x74, 0x5a, 0x3c, 0xf2, 0xb5, 0xd6, 0xd3, 0x2e, 0xc9, 0x1e, 0x34, 0xc, 0xdb, 0x63, 0x28, 0xab, 0xec, 0xc4, 0x36, 0x4f, 0x32, 0x85, 0xd1, 0xfb, 0x9d, 0xd5, 0x2, 0xc1, 0xd3, 0xa8, 0x4f, 0x47, 0xee, 0x9, 0x44, 0x8, 0x99, 0x9, 0x4a, 0xe5, 0x39, 0x71, 0xc, 0xef, 0x43, 0x3f, 0x6, 0x6d, 0x30, 0x55, 0xa4, 0x66, 0xfc, 0x9b, 0xf5, 0x80, 0x3b, 0xf9, 0x2b, 0xc6, 0x5c, 0xb5, 0xe0, 0xb1, 0xab, 0xb4, 0x98, 0x5e, 0xf8, 0x5b, 0x0, 0xa3, 0xaf, 0xab, 0x4f, 0x8f, 0x59, 0x35, 0x2e, 0xcd, 0x7e, 0x85, 0x50, 0xbf, 0x46, 0xb4, 0xd9, 0xaa, 0xab, 0xe8, 0x58, 0x76, 0x67, 0x51, 0xef, 0x9a, 0x99, 0x88, 0x90, 0x83, 0xa2, 0xad, 0x6f, 0xc1, 0x78, 0xd6, 0xb1, 0x42, 0xe1, 0xd9, 0xe0, 0x2, 0xe0, 0x74, 0x30, 0xf2, 0x7c, 0xad, 0xf6, 0x48, 0x16, 0x83, 0x26, 0x4b, 0x1f, 0x66, 0x29, 0xf9, 0xe1, 0x86, 0xa1, 0x6c, 0x48, 0x28, 0x62, 0x57, 0xd3, 0xb3, 0x54, 0x27, 0xd7, 0x65, 0xa1, 0x2e, 0x91, 0x8c, 0xed, 0x15, 0x7c, 0xb1, 0xe5, 0x74, 0x57, 0x13, 0xb0, 0xec, 0xcb, 0xe5, 0x29, 0xc7, 0xb3, 0x4, 0xce, 0x7e, 0x67, 0xce, 0xb5, 0x43, 0x1b, 0x83, 0x20, 0x19, 0x99, 0x5f, 0x89, 0xdf, 0xfd, 0xc9, 0x6c, 0xf6, 0x55, 0xf, 0xe0, 0x56, 0xaa, 0xd8, 0x75, 0xc8, 0xd3, 0x70, 0x99, 0xed, 0xf8, 0x2d, 0x1d, 0xf1, 0x2, 0x6d, 0x60, 0x5c, 0xd9, 0x39, 0x98, 0x5c, 0x37, 0x2f, 0x4e, 0x95, 0xb6, 0xae, 0xe3, 0x86, 0x77, 0x95, 0x27, 0xf7, 0x9a, 0xfc, 0x24, 0xe1, 0x87, 0x50, 0xa4, 0xef, 0xa, 0x93, 0xe1, 0xe3, 0x15, 0xc0, 0x9f, 0x78, 0x5c, 0x31, 0x0, 0xfb, 0x43, 0xe4, 0x4d, 0x62, 0x48, 0xbb, 0x7b, 0xcb, 0xcd, 0x29, 0xa7, 0xb4, 0x6b, 0xa9, 0xbe, 0xca, 0x59, 0x47, 0xec, 0xa2, 0xf5, 0xd7, 0xfd, 0x12, 0xf5, 0x88, 0xaa, 0x30, 0xe2, 0x42, 0x4f, 0xdf, 0xf, 0x20, 0x20, 0x0, 0xc6, 0x78, 0xc9, 0xae, 0x59, 0x83, 0x45, 0xd6, 0xaa, 0xce, 0x4e, 0x29, 0xf8, 0x57, 0x31, 0xb7, 0x75, 0xcb, 0x49, 0xe7, 0x51, 0x7e, 0x38, 0x10, 0x4b, 0x7b, 0x28, 0x7d, 0xc3, 0xa4, 0x90, 0xc2, 0xe3, 0xd, 0x3e, 0x35, 0xae, 0xb1, 0xe6, 0xd3, 0x5d, 0x2a, 0xbc, 0x8d, 0x45, 0xd, 0x7, 0x46, 0x3e, 0x3e, 0x46, 0xb9, 0x8, 0x12, 0x6d, 0xc8, 0x31, 0xf6, 0x24, 0xea, 0x1, 0xe, 0xe, 0x2f, 0xf8, 0x7d, 0x7f, 0x47, 0x93, 0xc8, 0xf0, 0x75, 0x21, 0x5c, 0x29, 0xd4, 0x53, 0x96, 0xf4, 0xa6, 0x5d, 0x49, 0xd, 0xc1, 0xc2, 0x90, 0x2b, 0xab, 0xef, 0x3a, 0xb1, 0xd2, 0xff, 0x8c, 0x9a, 0x24, 0xd9, 0xc5, 0x95, 0x6c, 0x9a, 0x92, 0x5c, 0x7b, 0x88, 0x70, 0x3c, 0x7b, 0xb8, 0xe2, 0xc6, 0xf3, 0xa1, 0xbd, 0x6f, 0xc5, 0xea, 0xa, 0xcb, 0x4e, 0xc6, 0x69, 0xc0, 0xfc, 0x3, 0xe9, 0x74, 0x38, 0x91, 0x87, 0xd9, 0x7f, 0x49, 0xd2, 0xa6, 0x64, 0x3d, 0xdb, 0xe1, 0xb1, 0xaa, 0x9c, 0xd2, 0x33, 0x5a, 0x90, 0x74, 0x1e, 0xa0, 0xbd, 0x4, 0x4d, 0xa6, 0xfd, 0x28, 0xe7, 0x8d, 0x35, 0x99, 0x2b, 0x5b, 0x1a, 0x85, 0x1f, 0x2c, 0xf5, 0xd9, 0x35, 0x3a, 0x5, 0x2c, 0xbf, 0x1e, 0x57, 0xb9, 0x78, 0x2a, 0xb3, 0x62, 0x0, 0x53, 0xc8, 0x9d},
+               output224: []byte{0x77, 0xab, 0x76, 0x68, 0x83, 0x2a, 0x56, 0x7e, 0x4f, 0x7f, 0x2e, 0xf3, 0x21, 0x3c, 0x59, 0x9a, 0xe9, 0x3a, 0x48, 0x51, 0xed, 0xa5, 0x6b, 0xfd, 0xb8, 0x14, 0x80, 0x9a},
+               output256: []byte{0x96, 0x80, 0x5c, 0x12, 0xa7, 0x52, 0xa2, 0x69, 0x0, 0xcf, 0xbe, 0x7a, 0x47, 0xfb, 0x94, 0xd0, 0x3c, 0x94, 0x9a, 0x8d, 0xd3, 0xd7, 0xec, 0x15, 0x21, 0xdd, 0x1c, 0x9a, 0xef, 0x0, 0x68, 0xb2},
+               output384: []byte{0xd2, 0x58, 0x71, 0x99, 0x4d, 0x47, 0x8f, 0xc, 0xc4, 0x6, 0x76, 0xf0, 0xc5, 0x3c, 0x9c, 0x60, 0x1d, 0x96, 0x2, 0xda, 0xc2, 0xb8, 0x42, 0x20, 0xaf, 0x46, 0xcd, 0xb3, 0x3c, 0x47, 0x59, 0xed, 0x97, 0x1c, 0x52, 0x92, 0x2e, 0x66, 0x23, 0x63, 0x90, 0xcb, 0xe9, 0x53, 0x68, 0xa2, 0x63, 0xa4},
+               output512: []byte{0x2c, 0xb3, 0xf8, 0xe2, 0xd3, 0x22, 0x7d, 0x32, 0x13, 0x93, 0x1c, 0xc, 0xd4, 0x54, 0x6, 0xed, 0xe, 0xce, 0x37, 0x3e, 0x93, 0xa5, 0x74, 0x61, 0x8d, 0x5b, 0x6c, 0xfd, 0xc3, 0x1a, 0x75, 0x6f, 0xff, 0xe8, 0xe, 0xfa, 0xcf, 0xf9, 0x3a, 0x70, 0x8e, 0xe7, 0x2b, 0x76, 0xbc, 0x8e, 0xa0, 0xab, 0x40, 0xbf, 0x53, 0x3e, 0x44, 0x21, 0x10, 0x28, 0x43, 0x43, 0x72, 0x1b, 0x43, 0xc1, 0xa1, 0x7e}},
+       testcase{
+               msg:       []byte{0x9, 0xa9, 0x6a, 0x1, 0x12, 0xb8, 0x23, 0xc2, 0x21, 0x2a, 0xba, 0x52, 0xee, 0xa1, 0x3c, 0x48, 0xca, 0xe3, 0xf5, 0xe0, 0x88, 0x83, 0x45, 0x3e, 0x20, 0x85, 0xa8, 0x3, 0xea, 0x85, 0x2a, 0x9d, 0x6a, 0xe0, 0x75, 0x39, 0x2b, 0xbd, 0x8f, 0xce, 0xc5, 0x67, 0xa1, 0x52, 0x4a, 0xa6, 0x5c, 0x70, 0xc3, 0xee, 0x17, 0x22, 0xaa, 0x7, 0x9a, 0xfd, 0x41, 0x69, 0x6c, 0xc5, 0x39, 0x1f, 0x52, 0x92, 0x99, 0xc7, 0x1e, 0x99, 0xb0, 0xe0, 0x8e, 0x41, 0x1d, 0x3e, 0x1e, 0x5, 0xc4, 0x3e, 0x97, 0x9c, 0xe1, 0xa, 0xc9, 0xc2, 0xea, 0x80, 0xcb, 0xf4, 0xb5, 0x83, 0x71, 0x27, 0x3c, 0x3d, 0x3a, 0x8d, 0xf4, 0x8e, 0x2d, 0xe7, 0xf5, 0x5, 0x60, 0xff, 0xed, 0x25, 0xf6, 0xe6, 0x5e, 0x9d, 0x96, 0xcb, 0xb3, 0x79, 0x57, 0x3b, 0xdb, 0xdd, 0x28, 0x59, 0xd1, 0x3f, 0x86, 0x6e, 0xbf, 0x3a, 0xf4, 0x88, 0xc6, 0xd2, 0xe3, 0x65, 0x5, 0xa7, 0xd, 0x81, 0xaf, 0xd0, 0x7e, 0x32, 0x11, 0x57, 0x79, 0x5c, 0xdf, 0x40, 0xc1, 0x88, 0x5d, 0xba, 0xeb, 0xf3, 0xd4, 0xe4, 0x25, 0xeb, 0x4c, 0xe0, 0xcf, 0xd6, 0xca, 0x50, 0x19, 0xc8, 0xdf, 0xd5, 0x4b, 0xc2, 0xa3, 0x0, 0x95, 0xb3, 0x12, 0xaf, 0x45, 0x48, 0xb9, 0xac, 0xeb, 0xb6, 0xa2, 0x7, 0xad, 0x3b, 0xca, 0x29, 0xf4, 0xda, 0x44, 0x3a, 0xfc, 0x7f, 0xa7, 0x89, 0xaa, 0xdb, 0xd6, 0x5c, 0x9d, 0x45, 0xaf, 0x71, 0x59, 0x4b, 0x79, 0xf, 0xdf, 0x84, 0xd9, 0x23, 0x59, 0x33, 0xee, 0x96, 0xff, 0xd8, 0x3d, 0x1a, 0x1d, 0xac, 0x8c, 0x1f, 0x3c, 0x2b, 0xaf, 0xe6, 0x68, 0xb8, 0xea, 0x5c, 0x96, 0x49, 0xd1, 0xd8, 0xda, 0xf2, 0x80, 0x6f, 0x5, 0x19, 0x44, 0x8a, 0x97, 0xaf, 0x11, 0x4, 0xdb, 0xa3, 0xfb, 0x5, 0xcc, 0x46, 0xd3, 0x3f, 0xa0, 0x11, 0x2d, 0xd0, 0x92, 0x2c, 0xf1, 0xac, 0x84, 0xd4, 0xa3, 0x43, 0xf1, 0xae, 0x59, 0x79, 0x30, 0x4, 0x2a, 0xff, 0x6d, 0xaa, 0x75, 0x1, 0x1b, 0xe4, 0xb1, 0x8a, 0xcb, 0x25, 0x7d, 0x88, 0x9a, 0x80, 0xf0, 0xc3, 0xd4, 0x9, 0x4e, 0xf7, 0x29, 0x5e, 0xd4, 0xe8, 0xc2, 0xf1, 0xe2, 0xb8, 0xf5, 0x6e, 0xdb, 0xc9, 0xb8, 0x31, 0x33, 0x36, 0x77, 0xa4, 0xe6, 0xcf, 0x61, 0x10, 0x21, 0x8b, 0x23, 0x52, 0x3e, 0xee, 0xe1, 0xe0, 0x24, 0xb6, 0x39, 0x8d, 0x1c, 0xc5, 0x72, 0xdf, 0x7a, 0xa1, 0x3, 0xcf, 0x7f, 0x50, 0xfa, 0x48, 0x8e, 0x19, 0x93, 0x6d, 0x20, 0x39, 0x3a, 0x55, 0x84, 0x3c, 0x4, 0x2b, 0x27, 0x5b, 0x78, 0xca, 0xa9, 0xee, 0xfc, 0x77, 0xc4, 0x44, 0x37, 0xc3, 0x75, 0xd4, 0xd1, 0x10, 0xb, 0xc4, 0x86, 0xfc, 0xb0, 0xd2, 0x50, 0x52, 0x60, 0x86, 0xeb, 0xd4, 0xd2, 0xd3, 0x8f, 0xbc, 0x8e, 0x3e, 0x55, 0xf9, 0x26, 0x2b, 0x4b, 0xe5, 0xe6, 0xce, 0x6a, 0xa3, 0x16, 0x4d, 0xc0, 0x4d, 0x7f, 0xb1, 0x2b, 0xe7, 0xa, 0xf6, 0x86, 0x1a, 0xe0, 0xc2, 0x1a, 0x4, 0x46, 0x83, 0x39, 0xd3, 0x35, 0xbe, 0x15, 0xf6, 0xa7, 0x7a, 0x8b, 0xb8, 0x4c, 0xa4, 0xbb, 0xe9, 0x4b, 0x7, 0x82, 0x24, 0x15, 0x0, 0xb5, 0x95, 0xfd, 0x67, 0x1b, 0x30, 0xdc, 0x6c, 0x26, 0x31, 0x7d, 0xb3, 0xaf, 0x8d, 0xb1, 0x21, 0x4b, 0x14, 0x4f, 0xc4, 0x2f, 0xe9, 0x36, 0x77, 0x14, 0x69, 0xd3, 0x83, 0x8e, 0x41, 0xc1, 0x6e, 0xac, 0xa8, 0xb4, 0x4a, 0x59, 0x15, 0xd1, 0xcb, 0x45, 0x50, 0xa4, 0x51, 0xbe, 0x5f, 0x6, 0x73, 0xff, 0xe8, 0x46, 0xf6, 0xa2, 0x2b, 0xbd, 0x19, 0x4c, 0x88, 0x70, 0x19, 0x3e, 0x1b, 0x68, 0x45, 0x9b, 0x5, 0x93, 0x93, 0xe, 0x17, 0x8b, 0x76, 0x5d, 0x5c, 0x19, 0xb0, 0xf9, 0xd6, 0x5b, 0x1e, 0x25, 0xd6, 0xb, 0x72, 0x7e, 0x50, 0xee, 0x4c, 0x39, 0xd1, 0xb8, 0x98, 0xce, 0xa9, 0xc8, 0xe9, 0x5e, 0x40, 0x11, 0xe, 0x40, 0xdd, 0xf8, 0x82, 0xa7, 0xc8, 0x93, 0x3, 0xbf, 0x1b, 0x6a, 0xf9, 0x5, 0x6, 0xe4, 0x70, 0x9a, 0x79, 0x16, 0xf2, 0x7, 0xbe, 0xec, 0xb8, 0x50, 0xc9, 0xe2, 0x27, 0xc9, 0x55, 0x75, 0x36, 0x13, 0x85, 0x94, 0x51, 0x30, 0x43, 0xfe, 0xbe, 0x77, 0x8c, 0x47, 0x1d, 0xff, 0x8, 0xed, 0x2e, 0xd7, 0xf8, 0xa5, 0x49, 0x52, 0xf6, 0xf5, 0x24, 0x22, 0xae, 0xe3, 0x24, 0xe, 0xef, 0x81, 0xd3, 0x4c, 0xbb, 0xe4, 0x7c, 0xc, 0xc5, 0x9a, 0x23, 0x9d, 0x7a, 0xd7, 0x58, 0x52, 0xcf, 0x62, 0x47, 0x3f, 0xdf, 0xa9, 0xc7, 0x23, 0xfe, 0xc8, 0x2c, 0x38, 0x4d, 0x6, 0xf2, 0x32, 0xc, 0x8c, 0x3e, 0x5a, 0x14, 0x83, 0xd9, 0xb5, 0x73, 0xae, 0xe0, 0x3f, 0xe0, 0xf8, 0x50, 0x87, 0x8, 0x7b, 0x89, 0x6a, 0x56, 0x9d, 0x9a, 0x7, 0xb0, 0x2a, 0x38, 0x7e, 0xe0, 0x9e, 0xd6, 0xb7, 0xc8, 0xd6, 0xc0, 0xec, 0xa7, 0x6e, 0xa6, 0x13, 0x1, 0x79, 0x1c, 0x9f, 0x83, 0x5e, 0x5c, 0xad, 0xd1, 0x48, 0x62, 0x39, 0x3a, 0x69, 0x8d, 0xb2, 0x35, 0x77, 0xa6, 0x8e, 0xff, 0xdb, 0x68, 0x7, 0x6f, 0xd8, 0xa0, 0xe7, 0xbb, 0xe9, 0xd9, 0x30, 0x98, 0xe7, 0x3f, 0x5a, 0x17, 0x4c, 0xe4, 0x6, 0x44, 0x1d, 0xf4, 0x8b, 0x96, 0x9b, 0x4d, 0x25, 0x2, 0xeb, 0xbb, 0xd9, 0x93, 0x78, 0x56, 0x77, 0x7d, 0x6f, 0x13, 0x85, 0x2d, 0x9a, 0xd3, 0xa3, 0x97, 0x2, 0xbd, 0x55, 0x60, 0x9, 0x8, 0x2d, 0xc2, 0x7, 0xc4, 0x42, 0xd3, 0x27, 0xeb, 0x33, 0xa2, 0x4f, 0x18, 0xdc, 0x56, 0x42, 0x8b, 0x18, 0x1c, 0x7b, 0x44, 0x5, 0xd0, 0xb2, 0x72, 0xb, 0x8c, 0x4c, 0x62, 0x41, 0x7a, 0xb9, 0xf9, 0xda, 0x55, 0x66, 0xbd, 0x85, 0xfb, 0x7f, 0xc5, 0x67, 0xf5, 0x42, 0xd0, 0x51, 0x11, 0x84, 0x2d, 0xe0, 0x91, 0x14, 0xd2, 0x7a, 0x38, 0x2f, 0x0, 0x9b, 0xf7, 0x37, 0xea, 0x2d, 0x8d, 0x8e, 0x4f, 0x9, 0x0, 0xa0, 0xde, 0xba, 0x8, 0xc, 0xe6, 0xb0, 0xfd, 0x7f, 0xe, 0xcb, 0x3f, 0x81, 0x79, 0x17, 0x17, 0xeb, 0x12, 0x11, 0x76, 0x41, 0x2e, 0x7c, 0xa6, 0x18, 0x73, 0x5b, 0xb0, 0x65, 0xa6, 0x59, 0xb6, 0x89, 0xa1, 0x80, 0x69, 0xb2, 0xc4, 0x3b, 0x0, 0xeb, 0xde, 0x9d, 0xe2, 0x72, 0x10, 0x6e, 0x18, 0xe, 0xea, 0x44, 0x62, 0x42, 0xf7, 0x88, 0x9e, 0x50, 0x92, 0xe, 0xe5, 0xda, 0x2b, 0x70, 0x26, 0x96, 0x5b, 0x6d, 0xfc, 0xf4, 0x23, 0x9e, 0xd8, 0xec, 0x7f, 0x73, 0x63, 0x90, 0x3f, 0x10, 0xef, 0x6c, 0xd8, 0xd, 0x76, 0xcb, 0x42, 0x29, 0x8e, 0x91, 0x3c, 0x82, 0x9b, 0x66, 0xce, 0x1a, 0x5b, 0x18, 0x4, 0x7e, 0xf0, 0x6f, 0xad, 0x79, 0xde, 0x36, 0x9, 0x8, 0x6, 0x5e, 0x3a, 0xf, 0x61, 0xaa, 0xe3, 0x34, 0x7a, 0x1d, 0x76, 0x1, 0x18, 0x8d, 0xcf, 0xd6, 0x2c, 0x56, 0xd6, 0x75, 0x73, 0xee, 0x45, 0x50, 0xd6, 0x26, 0x9f, 0xf7, 0x18, 0x1c, 0xad, 0xcf, 0x84, 0x5, 0x97, 0x49, 0xc8, 0xa4, 0xac, 0x1a, 0x46, 0x74, 0x6f, 0xfc, 0xab, 0x7c, 0xbf, 0xa1, 0x84, 0xe, 0x59, 0x90, 0x48, 0x37, 0x95, 0x45, 0x2e, 0xf9, 0x30, 0x75, 0xc9, 0x2a, 0x4d, 0x11, 0x5e, 0xca, 0x32, 0xeb, 0xe5, 0xef, 0x2, 0x11, 0x76, 0x4a, 0xc8, 0xf6, 0xd6, 0x1e, 0xa5, 0xa7, 0x55, 0x30, 0x50, 0x8a, 0x87, 0x24, 0xcd, 0x11, 0x84, 0x62, 0xca, 0x6c, 0xe3, 0x7e, 0x85, 0xe3, 0x37, 0xe3, 0x12, 0xc6, 0xe, 0x43, 0x34, 0x24, 0x97, 0xa9, 0xc5, 0xc, 0x5, 0xb3, 0x8a, 0x6d, 0x5c, 0x25, 0x3e, 0x1c, 0x0, 0x15, 0x38, 0xb4, 0x3d, 0x13, 0x12, 0xa3, 0x69, 0xd8, 0x30, 0x15, 0x44, 0xcc, 0x24, 0xb3, 0xbf, 0x30, 0x89, 0xc5, 0xd1, 0x19, 0xaf, 0xe9, 0x97, 0x94, 0x30, 0x22, 0x31, 0x91, 0xad, 0xde, 0x6b, 0x68, 0x13, 0x5b, 0x5d, 0x8a, 0xd5, 0xce, 0x4a, 0x80, 0x85, 0x80, 0xbb, 0x1c, 0x34, 0xf6, 0x50, 0xeb, 0x63, 0xee, 0xf3, 0xd5, 0x92, 0xbb, 0xc4, 0x5b, 0xb7, 0xf2, 0xde, 0x9a, 0xcf, 0x2d, 0x4b, 0xc2, 0x82, 0xe, 0xc1, 0xaa, 0x76, 0x5f, 0x35, 0xfc, 0xb3, 0xf7, 0x1d, 0x86, 0x2a, 0xaa, 0x11, 0x56, 0xd0, 0x83, 0x8e, 0xf0, 0x62, 0x41, 0x91, 0x4a, 0xa4, 0xb8, 0x63, 0x27, 0x33, 0xb8, 0x23, 0xac, 0xa5, 0x80, 0x1b, 0xd2, 0x81, 0xd1, 0x27, 0x23, 0x86, 0x76, 0x38, 0xd, 0xd8, 0x8e, 0x9b, 0xe0, 0xd6, 0xdd, 0xd0, 0xac, 0x7e, 0x87, 0xcd, 0xc1, 0x75, 0xa2, 0x43, 0x43, 0xb7, 0x52, 0xa4, 0x6a, 0xfe, 0xec, 0xac, 0x75, 0x61, 0x76, 0x6b, 0xc3, 0x3d, 0xe4, 0x36, 0x3d, 0xdf, 0x7, 0xf4, 0x3e, 0x9b, 0xc4, 0xa1, 0xec, 0x5f, 0xf, 0xe3, 0x6f, 0x40, 0xc3, 0x0, 0x1f, 0x16, 0x47, 0x5, 0x81, 0x31, 0x62, 0x9e, 0x2c, 0xca, 0xf0, 0x56, 0xb3, 0x81, 0xfc, 0x3b, 0x57, 0x6d, 0x8d, 0xd0, 0x72, 0xb8, 0xb2, 0xab, 0xd, 0x25, 0x1b, 0x90, 0x60, 0xa9, 0xf7, 0x6b, 0x3d, 0x99, 0xf2, 0xd0, 0xeb, 0xf6, 0x57, 0x81, 0xb9, 0x51, 0x1d, 0xe3, 0x10, 0x27, 0xd8, 0x28, 0x62, 0x99, 0xde, 0x9f, 0xbc, 0x9c, 0x1c, 0x28, 0xbe, 0x2e, 0x4d, 0xf9, 0xce, 0x82, 0x40, 0x85, 0x2f, 0xe0, 0x42, 0xd5, 0x72, 0x23, 0x6a, 0xc5, 0x4b, 0x42, 0xb6, 0x90, 0xd2, 0x5a, 0xdf, 0x27, 0xc2, 0x6a, 0x96, 0xd0, 0xfd, 0x4, 0x8f, 0x1d, 0x11, 0x29, 0x96, 0x36, 0xb5, 0x56, 0x31, 0xd3, 0x78, 0x82, 0x63, 0x70, 0xaf, 0x97, 0xd7, 0x6e, 0x40, 0x2c, 0xf4, 0x9c, 0xa5, 0x68, 0x7c, 0x17, 0xe2, 0xf8, 0xbb, 0xea, 0xe, 0xd8, 0x35, 0x35, 0x53, 0x55, 0x66, 0xd6, 0x5f, 0xc, 0x6f, 0x7b, 0x2d, 0x88, 0x7d, 0xcd, 0x39, 0x1d, 0xf0, 0xe9, 0xce, 0xb2, 0x7b, 0xc0, 0xa8, 0xa3, 0x30, 0x39, 0xcd, 0xca, 0x51, 0x5c, 0x88, 0x6d, 0x89, 0xd, 0x69, 0xa3, 0x89, 0xaf, 0x7b, 0xcb, 0x9c, 0x9e, 0x58, 0xde, 0x6, 0x36, 0x44, 0x13, 0x97, 0xa5, 0x3a, 0xf0, 0x9a, 0x44, 0x7b, 0xff, 0xd4, 0x9b, 0xef, 0x72, 0x87, 0xaa, 0xd0, 0x1a, 0x18, 0x27, 0xfc, 0xb8, 0x64, 0x1f, 0x9b, 0xcb, 0x76, 0x42, 0x95, 0x2d, 0x7e, 0x19, 0x44, 0x8c, 0x4e, 0x88, 0xdc, 0x5a, 0xbb, 0x28, 0xe2, 0x4b, 0xfe, 0xac, 0x16, 0xbb, 0xcb, 0x9f, 0x8e, 0x99, 0x62, 0xf5, 0x32, 0xb4, 0x28, 0xcc, 0xf8, 0x6e, 0xf6, 0x35, 0x69, 0x7e, 0x17, 0x9e, 0xa3, 0x28, 0x38, 0x79, 0xe9, 0x37, 0x5f, 0xfd, 0xd4, 0xdd, 0x99, 0x86, 0xcf, 0x86, 0x21, 0x70, 0xd3, 0xd8, 0x57, 0x43, 0x40, 0x42, 0xb, 0x43, 0x51, 0x2d, 0x5a, 0x36, 0x8c, 0xf3, 0x38, 0xb7, 0x32, 0xef, 0x44, 0x7a, 0x66, 0x9c, 0x51, 0x14, 0x66, 0xdf, 0xd, 0xdd, 0x9e, 0x5e, 0x26, 0xa1, 0x9a, 0x2a, 0xdf, 0xb1, 0x7c, 0xfc, 0x59, 0x35, 0x70, 0xf6, 0xc6, 0x77, 0x5d, 0x70, 0x31, 0x9e, 0x4d, 0xcd, 0xc4, 0xbe, 0xaf, 0x70, 0xac, 0x76, 0x8e, 0x78, 0x37, 0xfe, 0xf9, 0x4c, 0x78, 0x5e, 0xb5, 0x4b, 0x1a, 0x6c, 0x16, 0x4e, 0x9, 0xfe, 0x88, 0x79, 0x1b, 0x3d, 0xb6, 0xd1, 0xbc, 0xfa, 0x4e, 0xc1, 0x70, 0xa3, 0x69, 0x5f, 0xbc, 0x21, 0xc9, 0xad, 0x19, 0x42, 0xd3, 0xa4, 0x83, 0xcb, 0xd4, 0x33, 0xd3, 0xfc, 0xc8, 0x99, 0xf1, 0x2b, 0xb9, 0xcf, 0x78, 0x86, 0x66, 0xc0, 0x65, 0x8c, 0xfd, 0xea, 0x7f, 0x29, 0xd5, 0xca, 0xfb, 0xf3, 0xb1, 0x6b, 0x3e, 0xd9, 0x5e, 0x52, 0xae, 0x21, 0xe5, 0x99, 0xe6, 0x35, 0x4d, 0x65, 0x30, 0x5d, 0x7, 0x3d, 0xe3, 0x4b, 0x67, 0x7c, 0xfd, 0x9f, 0xf, 0xf0, 0xcc, 0xef, 0x95, 0x6b, 0xf5, 0x61, 0x4, 0x3e, 0xd, 0xb9, 0x67, 0x62, 0xc3, 0xb9, 0x36, 0x52, 0x47, 0xc1, 0x51, 0xcd, 0x6, 0x7, 0x55, 0x1b, 0xf8, 0xd7, 0x81, 0xe0, 0xce, 0x84, 0xd2, 0x3e, 0xf7, 0xb6, 0xa3, 0xb6, 0x7b, 0x69, 0x8c, 0xf3, 0xed, 0xc2, 0xdb, 0x9d, 0x96, 0x81, 0x74, 0xc0, 0xa2, 0x60, 0x10, 0xfa, 0x7f, 0xcc, 0xc5, 0xf8, 0x7e, 0x8b, 0x25, 0xd1, 0x24, 0x63, 0x39, 0x2b, 0xbc, 0x40, 0x4b, 0x22, 0xe0, 0x46, 0xb5, 0x3d, 0x18, 0x3a, 0x68, 0x61, 0xf6, 0x67, 0x71, 0x8, 0x48, 0x4f, 0xe5, 0x9e, 0x41, 0x7, 0x7b, 0xcf, 0x6c, 0x37, 0x59, 0x66, 0x31, 0x12, 0xba, 0x95, 0x10, 0x14, 0xf4, 0x9, 0x52, 0xd2, 0x9a, 0x15, 0x9b, 0xa3, 0xf8, 0x38, 0xa8, 0xce, 0xd3, 0x70, 0x7e, 0x45, 0xe0, 0x83, 0x7d, 0xc6, 0x2d, 0x5, 0x76, 0xa6, 0xdd, 0x12, 0xf3, 0xc7, 0x5c, 0xf9, 0x2, 0x63, 0x6d, 0xf5, 0xfb, 0xbd, 0xcd, 0x9b, 0x19, 0x3, 0x7e, 0x69, 0x9, 0x1b, 0x26, 0x8, 0x2b, 0x7d, 0xe2, 0xed, 0xc1, 0xec, 0x5b, 0xc2, 0x18, 0xea, 0x76, 0xc, 0x4b, 0x53, 0x4a, 0xaf, 0x35, 0x22, 0x52, 0x4, 0x3d, 0xc5, 0xb4, 0xad, 0xa6, 0xa, 0x9d, 0xee, 0x32, 0x18, 0xf1, 0x8d, 0xe6, 0xb, 0xc6, 0x54, 0xa9, 0xd, 0x82, 0x43, 0x5, 0x67, 0xf0, 0xc5, 0x91, 0xc7, 0x21, 0x90, 0x42, 0x18, 0xf, 0xc8, 0x44, 0xb, 0x5e, 0x42, 0x2a, 0x4b, 0xca, 0xaf, 0x92, 0x55, 0x3b, 0xa8, 0x6b, 0x14, 0x9c, 0x7d, 0x5e, 0x76, 0x13, 0x90, 0xc5, 0x2e, 0xe0, 0x13, 0x90, 0x0, 0x59, 0x5e, 0x17, 0x12, 0x93, 0x80, 0x30, 0xf3, 0x87, 0xbc, 0x88, 0x6c, 0x7e, 0x66, 0xbb, 0x11, 0xf7, 0x4a, 0x6c, 0xcb, 0x5c, 0xa9, 0x30, 0x99, 0xde, 0x6, 0xa0, 0x66, 0x5a, 0x1a, 0x99, 0xe1, 0x46, 0xe4, 0x80, 0xfd, 0x80, 0xd7, 0xed, 0x36, 0xe, 0x95, 0xfb, 0x3b, 0x2b, 0x8, 0xbc, 0x23, 0x54, 0xdf, 0xd5, 0x6b, 0xfd, 0x40, 0x31, 0x53, 0x8f, 0x43, 0x8a, 0xc1, 0x2, 0xb7, 0x34, 0x72, 0xdf, 0xf3, 0xdd, 0xc9, 0x3b, 0xbe, 0xc4, 0xf9, 0x98, 0x7d, 0xca, 0x8d, 0xf7, 0x91, 0x15, 0x89, 0x2a, 0x0, 0x4e, 0x86, 0xf4, 0xfe, 0x8e, 0x76, 0xbe, 0xc1, 0x45, 0xa1, 0x9c, 0x1, 0x36, 0x30, 0xde, 0x21, 0x8b, 0x3a, 0xe3, 0xc3, 0x25, 0xdd, 0x62, 0x2d, 0xbf, 0x17, 0x89, 0x7d, 0x68, 0x83, 0x3b, 0x43, 0xe8, 0x70, 0x83, 0x49, 0x68, 0xa, 0xd1, 0x83, 0x60, 0x44, 0xf0, 0x9d, 0xa, 0x36, 0xa0, 0xa, 0xbb, 0xfb, 0x9e, 0xb9, 0xb9, 0xfb, 0xc3, 0x9e, 0xb7, 0x1d, 0xef, 0xed, 0x6b, 0x2b, 0x86, 0xf4, 0xb8, 0x50, 0x91, 0xa2, 0xa1, 0xc6, 0x14, 0x1a, 0x2d, 0x74, 0xa8, 0xb2, 0xf1, 0x1e, 0x7c, 0xf4, 0xb5, 0xbd, 0xa, 0x76, 0x5, 0xf4, 0x3b, 0x75, 0x2f, 0x1f, 0xe2, 0xb5, 0x52, 0x9b, 0xc0, 0xb9, 0x13, 0xb5, 0x98, 0x11, 0x49, 0xf8, 0xe3, 0xe2, 0x38, 0x8, 0x19, 0x37, 0x41, 0xf1, 0x52, 0xd7, 0x7a, 0x10, 0x18, 0x49, 0x8b, 0x4, 0x59, 0x82, 0xa, 0x8e, 0x6e, 0xb6, 0x61, 0xb6, 0x33, 0x25, 0xd4, 0x1e, 0xa2, 0xe8, 0xd, 0x7, 0x14, 0x17, 0x81, 0x65, 0x51, 0x27, 0x2e, 0xdb, 0x51, 0x9d, 0xf3, 0x79, 0xe5, 0xcb, 0x7, 0x30, 0xed, 0x93, 0x35, 0x97, 0xe0, 0xd6, 0x28, 0x58, 0x27, 0x53, 0x90, 0x33, 0x1b, 0xb0, 0x48, 0xd2, 0x1f, 0x75, 0x3f, 0xa5, 0x2, 0x62, 0xfe, 0x9e, 0xd6, 0xff, 0x0, 0xf5, 0x4f, 0xc0, 0x75, 0x2d, 0xb0, 0x16, 0xa3, 0xf5, 0xf8, 0xdc, 0x41, 0x14, 0xdf, 0xb7, 0x60, 0xe8, 0xe9, 0xe1, 0x7a, 0x3b, 0x87, 0x6c, 0xb7, 0xfb, 0xc3, 0xf4, 0x43, 0x84, 0x3a, 0x9d, 0xf4, 0x62, 0x67, 0x40, 0xbd, 0xc, 0x51, 0x1b, 0xff, 0xfe, 0x4f, 0x78, 0x49, 0xc7, 0x7e, 0xa6, 0x48, 0x57, 0xc4, 0x89, 0xc2, 0x4, 0xda, 0x3f, 0xbf, 0x6c, 0x8, 0xac, 0xdd, 0x70, 0x5d, 0x75, 0x24, 0x24, 0x5b, 0xd2, 0x3e, 0x37, 0x67, 0xc6, 0x58, 0x7b, 0xa, 0x70, 0x74, 0x3a, 0xab, 0xda, 0x34, 0x34, 0xf0, 0x96, 0x9d, 0x0, 0x7b, 0xbf, 0xdd, 0x27, 0x96, 0x8c, 0x4e, 0x7f, 0xbb, 0xab, 0x26, 0x21, 0xec, 0x26, 0xfc, 0x28, 0xfa, 0x98, 0x4a, 0xe, 0x75, 0x13, 0xc5, 0x48, 0xf5, 0xbe, 0x67, 0xba, 0xe1, 0x39, 0x9, 0x88, 0x73, 0x93, 0x2b, 0xd6, 0x51, 0xfa, 0x85, 0xf8, 0x97, 0x8f, 0x8a, 0x52, 0xca, 0x11, 0x11, 0xc3, 0x54, 0xaa, 0xf0, 0x77, 0x28, 0xa1, 0xa4, 0xd8, 0xe8, 0xbc, 0x45, 0xcd, 0xfb, 0x17, 0x4f, 0xd8, 0xcf, 0xfd, 0xb8, 0xb2, 0x3c, 0xee, 0x7c, 0xb7, 0xc7, 0xcf, 0x2c, 0xa5, 0x90, 0xb9, 0x3c, 0x4e, 0xeb, 0x40, 0x31, 0x23, 0xb2, 0xe1, 0x2, 0x93, 0x2, 0x1a, 0x73, 0x7b, 0x21, 0x46, 0xb2, 0x13, 0x27, 0xc0, 0xf2, 0xff, 0xb5, 0x91, 0x76, 0xd1, 0xb2, 0x6d, 0xd3, 0xa1, 0xb7, 0xdf, 0xe3, 0x46, 0x76, 0x13, 0x20, 0x74, 0x26, 0xb3, 0x25, 0x3f, 0xb6, 0x1b, 0xe, 0x42, 0x96, 0x9e, 0x5f, 0x6f, 0x1, 0xa1, 0x2, 0x69, 0x90, 0x83, 0x1, 0xd, 0x5f, 0x53, 0xf1, 0xc, 0x36, 0xf0, 0xc6, 0x9e, 0xf7, 0x3b, 0x35, 0xb, 0x14, 0x4f, 0xd2, 0x95, 0x6, 0x3b, 0x19, 0x77, 0x5, 0x52, 0xcb, 0x2b, 0x6, 0xf2, 0x15, 0xcd, 0x5f, 0x30, 0x86, 0x58, 0xdd, 0x34, 0xc1, 0x2e, 0x66, 0xeb, 0xf3, 0xa4, 0x8d, 0xf9, 0xc8, 0x1e, 0xa4, 0xa, 0x72, 0x8a, 0x3, 0x5e, 0x4d, 0x20, 0xae, 0x41, 0x72, 0xa6, 0x55, 0x6d, 0x3c, 0xd5, 0xda, 0x10, 0x9e, 0xd, 0x2c, 0x5c, 0x40, 0xf5, 0x8f, 0x10, 0x4b, 0xe1, 0x15, 0x9, 0x28, 0x2b, 0x67, 0x82, 0x68, 0x31, 0xa9, 0x56, 0x5, 0x84, 0x46, 0x6a, 0x93, 0x86, 0x7, 0x31, 0xc3, 0xf8, 0x8a, 0x29, 0x36, 0x85, 0xf6, 0x58, 0xc1, 0x5d, 0x4e, 0x3a, 0x12, 0xb3, 0x8e, 0xf6, 0x3a, 0x4a, 0x17, 0x5f, 0x74, 0x54, 0x1f, 0xa, 0xac, 0x49, 0x9e, 0x39, 0x16, 0xa5, 0xc7, 0xfa, 0x3a, 0x2b, 0x30, 0x85, 0xcf, 0xed, 0xa4, 0x59, 0x39, 0xc3, 0x19, 0xb3, 0x9f, 0x88, 0x77, 0x5, 0xb9, 0xf0, 0x89, 0xc9, 0xf, 0xa3, 0x8d, 0x62, 0x69, 0xf0, 0x47, 0x56, 0x15, 0x2d, 0x6b, 0x58, 0xfc, 0x22, 0xae, 0x8a, 0x16, 0xd1, 0xf0, 0x93, 0x54, 0x80, 0x19, 0xe9, 0xea, 0xfd, 0x24, 0x32, 0x3a, 0xed, 0xc6, 0x5f, 0xb8, 0xf, 0xb9, 0xa9, 0x95, 0xf, 0x96, 0xb9, 0xaa, 0x56, 0x88, 0x6a, 0x96, 0x95, 0xbb, 0xaf, 0xa1, 0x9a, 0x9d, 0xf7, 0xa, 0x97, 0xeb, 0x73, 0x72, 0x99, 0x15, 0xaf, 0x44, 0x33, 0xd3, 0x8a, 0x2e, 0xce, 0xa4, 0xe, 0xce, 0xd, 0xa7, 0x1c, 0xe, 0xae, 0xbb, 0x61, 0xd5, 0xc9, 0x6, 0x81, 0x51, 0x35, 0x88, 0x29, 0x32, 0xb2, 0x44, 0x29, 0x1, 0xdd, 0x71, 0x9b, 0xfb, 0x33, 0x86, 0xdc, 0xb4, 0x57, 0x46, 0xfc, 0x76, 0x3, 0xe1, 0xb5, 0x7c, 0x30, 0x32, 0xd5, 0x4a, 0xf9, 0x8a, 0x52, 0x8f, 0x3d, 0x2f, 0x8d, 0x80, 0x10, 0x26, 0xca, 0xf9, 0x4f, 0xfc, 0xa, 0x95, 0x25, 0x8f, 0x28, 0xaf, 0x7b, 0xfa, 0x5, 0xa6, 0xcd, 0xc6, 0xdb, 0xc8, 0x4d, 0xad, 0x9f, 0x7f, 0xa5, 0x20, 0xa7, 0x8, 0xee, 0x18, 0xe6, 0xac, 0xb3, 0x16, 0x23, 0x54, 0x79, 0xc4, 0x9c, 0xe5, 0xb8, 0xf0, 0xd8, 0x96, 0xee, 0xe7, 0x2, 0x93, 0xf8, 0x22, 0xfe, 0x85, 0xe9, 0xd1, 0x5b, 0x5f, 0x45, 0x11, 0xcb, 0x2e, 0x5c, 0x49, 0x26, 0xd9, 0xef, 0xc1, 0x1f, 0xf9, 0x31, 0xb4, 0x65, 0x60, 0x95, 0x32, 0xd3, 0xf7, 0x8a, 0xcc, 0xb0, 0x8b, 0x3c, 0x25, 0x97, 0xaa, 0xd0, 0x82, 0x85, 0x22, 0x38, 0xf2, 0x4d, 0xe9, 0x5, 0xd4, 0x33, 0x48, 0x4d, 0x4, 0x1c, 0x9c, 0x90, 0xe1, 0xf9, 0xbd, 0xd1, 0x45, 0x24, 0xef, 0x59, 0x3a, 0xda, 0xc2, 0x5b, 0xe, 0xaa, 0x59, 0xf5, 0xd0, 0x22, 0x3d, 0xe1, 0x57, 0xdd, 0x2a, 0xef, 0x43, 0x64, 0x22, 0x7f, 0xce, 0xfc, 0x25, 0xdc, 0x1e, 0x98, 0x78, 0x5c, 0x40, 0xb8, 0xf4, 0x91, 0xdb, 0xe8, 0x34, 0x71, 0x3c, 0x9c, 0x9e, 0x8c, 0xcb, 0x72, 0x13, 0x33, 0x51, 0xc8, 0xaa, 0xc3, 0x62, 0x5a, 0x33, 0x37, 0xd6, 0x37, 0xc2, 0x64, 0xd9, 0xab, 0x2, 0xde, 0x30, 0xd7, 0x8a, 0x7a, 0xa5, 0x48, 0x91, 0xea, 0x52, 0xc9, 0x6e, 0x7f, 0x6, 0x1a, 0xfa, 0x55, 0x8f, 0x5f, 0x66, 0x1d, 0x87, 0x52, 0xf5, 0x4d, 0xbe, 0xe0, 0x25, 0xa6, 0x8b, 0x72, 0xe2, 0x5, 0xec, 0xb2, 0xd1, 0x4e, 0xe8, 0x4c, 0x7d, 0xff, 0xca, 0xad, 0x8f, 0x28, 0x29, 0xf2, 0x1b, 0x77, 0x8d, 0x85, 0xba, 0x3c, 0x59, 0x3, 0x94, 0xad, 0x4d, 0xe3, 0x95, 0x87, 0xd4, 0xe, 0xab, 0x9, 0x15, 0xa3, 0xc7, 0xe7, 0xbc, 0x89, 0xbf, 0xcc, 0x75, 0x66, 0xd1, 0xf4, 0x4d, 0x25, 0xf, 0xc3, 0xdc, 0xa3, 0x27, 0xe7, 0xdf, 0xd2, 0xdc, 0x7e, 0x4, 0xc0, 0x1c, 0x57, 0x73, 0xb7, 0xde, 0xee, 0x55, 0x81, 0x6, 0xa3, 0xa4, 0xd7, 0xbd, 0xa8, 0x34, 0x7c, 0x8f, 0x5c, 0x11, 0x50, 0x5, 0x51, 0x34, 0x5e, 0x96, 0x3a, 0x34, 0xfa, 0xde, 0x1a, 0xad, 0xa6, 0xf8, 0x8b, 0x7f, 0x73, 0xc3, 0x20, 0x61, 0x73, 0xc5, 0xb5, 0xa8, 0x31, 0xcb, 0x30, 0x8a, 0xa3, 0x38, 0xde, 0xc5, 0x7f, 0xb, 0xb4, 0xd0, 0xd4, 0x3b, 0x9, 0x88, 0xe, 0x2e, 0x15, 0xd, 0x43, 0x8d, 0xba, 0x83, 0xab, 0x9f, 0x49, 0xb4, 0xc3, 0xb8, 0x12, 0x38, 0x6d, 0xd2, 0xe1, 0x1f, 0xe9, 0x92, 0xb3, 0x2d, 0xde, 0xb5, 0xf0, 0xb3, 0xf2, 0xf1, 0x0, 0xd9, 0x89, 0xa6, 0x48, 0x2b, 0xf7, 0x5, 0xe1, 0x90, 0xe8, 0x20, 0x1b, 0x61, 0x4a, 0xfb, 0x5b, 0xa6, 0x73, 0x6d, 0xe, 0xc8, 0x1d, 0xbb, 0x35, 0x77, 0x8e, 0x65, 0x65, 0x3f, 0x38, 0xf4, 0x96, 0x94, 0xb8, 0x5b, 0xe, 0x78, 0x20, 0x2c, 0x3f, 0x80, 0x5f, 0xed, 0xbf, 0x6e, 0xc5, 0x79, 0x5f, 0x93, 0x96, 0x6d, 0xb9, 0x65, 0x60, 0x66, 0x94, 0x4b, 0xc2, 0xe5, 0x2c, 0x10, 0xa5, 0xdc, 0xff, 0x5b, 0xa6, 0x8f, 0x0, 0x8c, 0x40, 0xe6, 0xc8, 0x1, 0xd1, 0x6e, 0xdd, 0x3, 0x35, 0x12, 0xb2, 0xf2, 0xf5, 0xe5, 0x1f, 0x3b, 0x49, 0xc4, 0x15, 0xee, 0xad, 0xae, 0x4f, 0x87, 0x8f, 0xa4, 0x4b, 0x3a, 0xa6, 0x96, 0x5b, 0xa6, 0xb7, 0xa1, 0x18, 0x29, 0x7f, 0xe5, 0x99, 0x3c, 0x9a, 0x3e, 0xfc, 0x22, 0xdd, 0x57, 0x36, 0x9c, 0xe8, 0xff, 0x70, 0x9d, 0x83, 0x5c, 0x97, 0x78, 0x74, 0xad, 0xfe, 0xf7, 0xd8, 0xd2, 0x52, 0xd1, 0xe8, 0xf6, 0xf5, 0xad, 0x54, 0x8d, 0x8d, 0x14, 0xd8, 0x9c, 0x72, 0xf2, 0x29, 0x4f, 0x95, 0x4c, 0x6c, 0xe3, 0x53, 0xd0, 0xc3, 0xf4, 0x3a, 0x76, 0xbc, 0x5e, 0x3b, 0xa7, 0xc0, 0x70, 0x7b, 0xf2, 0x1e, 0x4a, 0x4d, 0x6e, 0xbc, 0x4b, 0x99, 0xd3, 0x45, 0x6, 0xb4, 0xab, 0x78, 0xe6, 0x22, 0xbc, 0x32, 0xaa, 0xa7, 0x30, 0x7d, 0xed, 0x2f, 0x55, 0xe5, 0x75, 0xea, 0xa6, 0xa6, 0x1, 0xe6, 0x27, 0xf0, 0x9d, 0xfe, 0x2, 0xe1, 0xcf, 0x3d, 0x59, 0xd0, 0x27, 0xe7, 0xae, 0x1d, 0xbf, 0x4c, 0x13, 0x65, 0x23, 0x1b, 0x72, 0x4b, 0x3, 0x45, 0x1e, 0x79, 0xa3, 0x51, 0x23, 0x93, 0xc8, 0x43, 0xeb, 0xe4, 0x74, 0xd2, 0x9e, 0x3e, 0xe1, 0x82, 0x8b, 0x10, 0x10, 0xa7, 0x46, 0xfb, 0xa2, 0xe6, 0x48, 0x3a, 0x5f, 0x29, 0x33, 0x6a, 0x6c, 0xf0, 0xc9, 0x5e, 0x9d, 0x3b, 0x92, 0x9d, 0x1f, 0xac, 0x33, 0x4d, 0x2f, 0x39, 0x1b, 0xee, 0xde, 0x2f, 0xd, 0xad, 0xf3, 0x99, 0x80, 0x5b, 0x4c, 0x3, 0x9e, 0x66, 0xfc, 0x20, 0x76, 0x73, 0x4d, 0xf2, 0x6, 0x2a, 0x9, 0xaa, 0xdc, 0x69, 0xdf, 0x10, 0xaf, 0xde, 0xf8, 0xed, 0x1a, 0x15, 0xb5, 0xd8, 0x10, 0x41, 0xc3, 0xb0, 0xa0, 0x4e, 0x1a, 0x12, 0x95, 0x86, 0x27, 0xb5, 0x80, 0x56, 0xfe, 0x33, 0x39, 0x7b, 0xcf, 0x5e, 0xbf, 0xff, 0x54, 0xd3, 0x4f, 0xcb, 0xad, 0x32, 0x90, 0x6a, 0x56, 0x85, 0xee, 0x8a, 0x4d, 0xd3, 0x4d, 0xbe, 0xdf, 0x4d, 0xba, 0x83, 0x2f, 0x24, 0x64, 0xf, 0x9, 0xc, 0xcc, 0x21, 0x70, 0x1a, 0x4b, 0x35, 0xed, 0x37, 0xda, 0xc3, 0xe6, 0x96, 0x1e, 0xc8, 0x9e, 0xa0, 0x81, 0x57, 0x51, 0xd5, 0x58, 0x71, 0xa1, 0x31, 0x25, 0xd7, 0x34, 0xef, 0x17, 0x81, 0x24, 0xae, 0x1f, 0x59, 0x3d, 0x89, 0x60, 0x9d, 0x12, 0x18, 0x78, 0xb3, 0x15, 0x1b, 0xa9, 0x6c, 0x83, 0x47, 0xb1, 0x66, 0x55, 0x8f, 0xbd, 0x27, 0xd4, 0xd2, 0x1, 0xd7, 0x6c, 0xdf, 0x47, 0x74, 0x24, 0x4c, 0xea, 0x52, 0x78, 0x96, 0x87, 0x4e, 0xbd, 0xaf, 0x9a, 0xf7, 0x29, 0x3a, 0xfb, 0x14, 0xa4, 0xe3, 0x71, 0x9d, 0x50, 0xd9, 0xc9, 0x90, 0x2b, 0x92, 0x74, 0x1b, 0xcf, 0xe0, 0x57, 0x2d, 0x37, 0xea, 0x11, 0xda, 0x57, 0x29, 0x8d, 0xc9, 0xf7, 0x10, 0xf3, 0xd2, 0x29, 0x4e, 0x48, 0xf6, 0x8c, 0x47, 0xd9, 0x72, 0xcd, 0x2, 0x61, 0x50, 0x84, 0x82, 0xef, 0xf8, 0xb2, 0x90, 0xf5, 0x27, 0x37, 0xe6, 0x41, 0xb6, 0x1e, 0x99, 0x26, 0xee, 0xc0, 0x20, 0xfd, 0xd7, 0x4a, 0x1a, 0x7, 0x22, 0xba, 0x53, 0x49, 0x54, 0xd4, 0xce, 0xdb, 0x3e, 0xd4, 0x4e, 0xb2, 0x55, 0x6, 0x97, 0x8, 0xbc, 0xe9, 0xa2, 0x25, 0x64, 0xf5, 0xb4, 0x99, 0x5, 0x62, 0x27, 0x8e, 0x2e, 0x89, 0x24, 0x5c, 0x54, 0xb8, 0x27, 0x8e, 0xc1, 0x7c, 0x8b, 0x56, 0x41, 0x57, 0xe8, 0x7d, 0xd5, 0x2c, 0xdc, 0x1a, 0x67, 0xd6, 0xd, 0xfd, 0xb6, 0xcc, 0x9a, 0xce, 0x96, 0xa5, 0xbc, 0xc7, 0x7c, 0xd3, 0x3a, 0x10, 0xc5, 0x6, 0x66, 0x5, 0x48, 0xa1, 0x67, 0x19, 0x3a, 0x6a, 0x13, 0xfa, 0x6f, 0xbf, 0x31, 0xd, 0x80, 0x3b, 0xd7, 0x32, 0xa5, 0x1b, 0xf8, 0x5c, 0x72, 0xaa, 0xf8, 0x68, 0x89, 0x79, 0x59, 0x1c, 0x5d, 0x82, 0x9e, 0xf4, 0xa7, 0xee, 0xec, 0x82, 0x1, 0x7c, 0xad, 0x8, 0x80, 0x20, 0x9c, 0x4a, 0x64, 0xa0, 0xea, 0x4b, 0xa2, 0x2f, 0x40, 0xd2, 0x6c, 0xd5, 0x59, 0xec, 0xeb, 0x9c, 0x87, 0x9a, 0xe4, 0x13, 0xd6, 0x2, 0x40, 0xe2, 0x6f, 0x88, 0xa7, 0xdf, 0x5, 0x57, 0xdb, 0x1e, 0xb, 0xf9, 0x38, 0x32, 0x7d, 0xc4, 0xcc, 0x6, 0x64, 0xe0, 0xb4, 0xe, 0x9d, 0xc, 0x67, 0xa4, 0x31, 0xc1, 0x58, 0x6, 0x35, 0xbd, 0xe0, 0x40, 0xff, 0x20, 0x79, 0xfb, 0xd5, 0x24, 0xd, 0x2d, 0xe2, 0xdb, 0x11, 0x2a, 0xe4, 0xf3, 0x41, 0x1d, 0xf, 0x59, 0x8, 0xdb, 0xda, 0xed, 0x15, 0x15, 0x16, 0x3b, 0x62, 0x1a, 0x66, 0xcf, 0xf, 0x3d, 0x80, 0xaf, 0xa0, 0xe0, 0xb5, 0x63, 0xf3, 0xab, 0x81, 0xfd, 0x6, 0x11, 0x7a, 0x7f, 0x21, 0xe7, 0xae, 0x2f, 0xaa, 0x46, 0x1e, 0xfc, 0xe9, 0x61, 0xfe, 0xfd, 0xab, 0xcd, 0xca, 0xe2, 0x7c, 0x20, 0xf0, 0x11, 0x43, 0x8, 0xba, 0xae, 0x2, 0x28, 0xd8, 0x49, 0xa, 0xa, 0x84, 0xe, 0x39, 0xbc, 0x9a, 0x50, 0x1c, 0xc, 0x59, 0x1c, 0xa2, 0x8f, 0xba, 0x2, 0x5e, 0x14, 0x5e, 0x4f, 0xff, 0x4b, 0x43, 0x2a, 0x16, 0x1b, 0xd8, 0x21, 0xfd, 0x86, 0x28, 0x55, 0xa9, 0x55, 0x3, 0x5c, 0x1a, 0xde, 0xad, 0xe9, 0x8c, 0xde, 0xdd, 0x8e, 0xc0, 0xbf, 0x8, 0x81, 0xce, 0x6f, 0x3f, 0xb3, 0xb6, 0x95, 0x1, 0xb1, 0x64, 0xfa, 0xe0, 0x89, 0xff, 0x0, 0x7a, 0x92, 0x3f, 0x42, 0x54, 0x60, 0x19, 0x84, 0x4c, 0x6, 0x38, 0x7b, 0x84, 0x70, 0x71, 0x71, 0x6b, 0x30, 0x49, 0x1a, 0x50, 0xa8, 0x36, 0xdf, 0x91, 0x3d, 0xc2, 0xba, 0x22, 0xd0, 0xdb, 0x14, 0xd1, 0x8f, 0x84, 0x81, 0x26, 0xac, 0x12, 0x4e, 0x5e, 0x9a, 0x0, 0x4b, 0x54, 0x73, 0xc6, 0x6, 0xae, 0x54, 0x2, 0x35, 0x7a, 0x93, 0xfb, 0xc7, 0x14, 0x63, 0x24, 0xe2, 0x69, 0xb6, 0x24, 0x8b, 0x43, 0xcf, 0xc2, 0x29, 0x10, 0x31, 0xf7, 0x20, 0x21, 0x53, 0xcb, 0xc4, 0x56, 0x3f, 0xbb, 0xe, 0x6d, 0x0, 0x8d, 0x6b, 0xd, 0xad, 0x9a, 0x2, 0xd0, 0x3f, 0x33, 0xfb, 0xf8, 0xbc, 0x92, 0x7, 0x19, 0x9b, 0xbc, 0x19, 0xec, 0xa8, 0x0, 0xef, 0xae, 0xbb, 0x5b, 0x7e, 0x1f, 0x89, 0x29, 0x84, 0x6a, 0xa2, 0xcf, 0xca, 0x4b, 0x13, 0xee, 0x36, 0x52, 0x47, 0x7f, 0xe3, 0xee, 0xed, 0x93, 0xb6, 0x3c, 0xf2, 0x50, 0x8a, 0x1e, 0x54, 0xb, 0xd3, 0x52, 0x50, 0xfa, 0x40, 0xf9, 0x3a, 0x41, 0xad, 0x70, 0xa4, 0xe5, 0xb5, 0x47, 0x0, 0x69, 0x68, 0x10, 0x65, 0x31, 0x41, 0x9e, 0x8d, 0xc6, 0xe, 0x42, 0x31, 0x29, 0xfd, 0x62, 0x7b, 0xcd, 0xf1, 0x4b, 0xf0, 0xd2, 0x94, 0x98, 0x4b, 0xe3, 0x3, 0x7d, 0x4f, 0x5c, 0xe6, 0xeb, 0x8a, 0xac, 0x28, 0x74, 0x4a, 0xa3, 0x13, 0x25, 0xbb, 0x32, 0xcf, 0x85, 0xd9, 0x5f, 0x4, 0x57, 0x30, 0x40, 0xfa, 0xf5, 0x54, 0xd8, 0x7b, 0xa7, 0xe1, 0xbf, 0xd9, 0xcb, 0x37, 0xd4, 0x3e, 0x2d, 0xf6, 0xa8, 0xee, 0x9, 0xb8, 0x42, 0x3f, 0x8f, 0xaa, 0x8f, 0x7, 0x44, 0xb0, 0xf3, 0x83, 0xfe, 0x9a, 0xb4, 0x3, 0xd5, 0xb7, 0x7f, 0x8b, 0x2d, 0xa1, 0xe2, 0x6e, 0x3b, 0xf2, 0xe, 0x5c, 0x19, 0x5e, 0xf3, 0x41, 0x5f, 0xf2, 0xda, 0x74, 0x0, 0x3b, 0x9f, 0x82, 0xd7, 0x4f, 0x5a, 0x4a, 0xf4, 0xec, 0x1f, 0x9e, 0x87, 0xe2, 0xec, 0xf5, 0xb, 0x36, 0x29, 0x90, 0xff, 0xf4, 0x32, 0xfc, 0x7a, 0x98, 0x65, 0x78, 0xb0, 0xd0, 0x16, 0x61, 0x75, 0xf0, 0x87, 0xdc, 0x8d, 0x72, 0x4f, 0xe4, 0x3e, 0xa6, 0xd7, 0xa5, 0x41, 0xaa, 0x7e, 0x54, 0x45, 0xb0, 0x27, 0x3b, 0x41, 0xba, 0x78, 0x18, 0xa9, 0x6c, 0x28, 0x26, 0x5d, 0xb7, 0xfc, 0x72, 0x9f, 0xf7, 0x2c, 0x8d, 0xd6, 0x35, 0x26, 0x9f, 0xc, 0x35, 0xd4, 0x3d, 0x8c, 0xd2, 0xa0, 0xd4, 0xac, 0xed, 0xf1, 0x3c, 0x75, 0x13, 0xf, 0x17, 0xd6, 0x5c, 0x57, 0xa9, 0xed, 0x2d, 0x26, 0xd5, 0xa6, 0xab, 0xe0, 0x6e, 0x40, 0xcc, 0x7b, 0x78, 0xd2, 0xa5, 0x54, 0xc0, 0xa2},
+               output224: []byte{0xae, 0x38, 0xd7, 0x76, 0x3d, 0x84, 0xce, 0xa8, 0x8e, 0x46, 0x8e, 0xd4, 0x33, 0x8d, 0xa5, 0x8f, 0x4e, 0x10, 0x80, 0x1e, 0x15, 0x19, 0xe6, 0x5a, 0xac, 0xc3, 0xc6, 0xda},
+               output256: []byte{0x0, 0x85, 0x6e, 0xec, 0xb7, 0xb7, 0x2e, 0x76, 0xd8, 0x15, 0xf7, 0xae, 0x4, 0x24, 0x51, 0x9e, 0xb5, 0xb5, 0xc, 0x81, 0x28, 0xc4, 0xb1, 0x7d, 0x15, 0xdf, 0x1, 0x13, 0xbc, 0x30, 0x2a, 0xb},
+               output384: []byte{0x85, 0xeb, 0x70, 0xf7, 0xc2, 0xbb, 0x4, 0x8, 0x53, 0x52, 0x33, 0x3d, 0xf7, 0x69, 0x38, 0x1, 0x2d, 0x15, 0x1d, 0x76, 0xa5, 0xe1, 0x65, 0xe6, 0xe1, 0x79, 0x6c, 0x69, 0x32, 0xf3, 0xa7, 0x19, 0x88, 0xab, 0xff, 0xae, 0xbe, 0x1b, 0x14, 0x8, 0xae, 0x4e, 0xcc, 0xde, 0xf7, 0x19, 0x8b, 0xd9},
+               output512: []byte{0xa9, 0x17, 0xf7, 0x7e, 0xad, 0xc2, 0xb7, 0xa0, 0x14, 0x40, 0x9f, 0xd1, 0x24, 0xab, 0x38, 0x0, 0x5, 0xff, 0x9e, 0xa6, 0xda, 0xf9, 0x24, 0x54, 0xb, 0x72, 0x16, 0x42, 0xc0, 0xc7, 0x3d, 0x30, 0xd2, 0x40, 0x3c, 0xa7, 0x8b, 0xaa, 0x5b, 0x79, 0x13, 0x60, 0x46, 0x8d, 0xfb, 0x47, 0x5a, 0x55, 0x8e, 0x61, 0xe1, 0x5e, 0xf7, 0x12, 0xc7, 0x9f, 0xa2, 0xa8, 0xd6, 0xc3, 0x83, 0x41, 0xcb, 0x1b}},
+       testcase{
+               msg:       []byte{0xe, 0x31, 0xc8, 0xa, 0x1c, 0x41, 0xdf, 0x5f, 0x70, 0x6d, 0xb8, 0xda, 0x40, 0xdc, 0xc0, 0x6e, 0x61, 0xb4, 0xd6, 0x96, 0x97, 0x15, 0xea, 0x2, 0x11, 0x3e, 0x2a, 0x63, 0x66, 0x3d, 0xa6, 0xaa, 0x3d, 0xf8, 0xba, 0x75, 0x51, 0x9, 0xa5, 0x80, 0x44, 0x6e, 0x7e, 0x94, 0xe9, 0xe3, 0x3d, 0xc9, 0x8e, 0xe6, 0xb1, 0x19, 0xd3, 0xab, 0xe7, 0x8b, 0x3b, 0x9f, 0x99, 0x3, 0x49, 0xa6, 0x3d, 0xd6, 0x9, 0x0, 0x8f, 0xf7, 0x2e, 0x2c, 0xb6, 0x71, 0xb, 0x99, 0x52, 0x20, 0x21, 0xae, 0xd5, 0x1b, 0x74, 0x85, 0xb7, 0xb3, 0xb8, 0x9c, 0x4c, 0x5f, 0x81, 0xe0, 0xce, 0x61, 0xb5, 0x31, 0x7, 0x89, 0x55, 0x6d, 0x93, 0x64, 0x6d, 0x53, 0x17, 0x44, 0xe6, 0xb3, 0x93, 0xaa, 0x38, 0xe1, 0xac, 0xa0, 0xd6, 0x56, 0x57, 0x28, 0x56, 0x4, 0x3, 0x42, 0x3c, 0x5c, 0x5b, 0xf3, 0xb8, 0xb, 0x4e, 0x99, 0xbb, 0xa5, 0xfa, 0x53, 0x76, 0x5a, 0x8f, 0xb, 0x67, 0xe9, 0x9b, 0xbd, 0xf, 0x1e, 0x31, 0x92, 0x97, 0x31, 0x17, 0x5b, 0x49, 0xe2, 0x37, 0xee, 0xc4, 0x48, 0xd0, 0x8d, 0x28, 0x2c, 0xa6, 0x34, 0xd7, 0x20, 0xce, 0x74, 0xc5, 0x59, 0x25, 0xb6, 0x8f, 0xb, 0xcf, 0x8, 0xb6, 0x49, 0x3b, 0x18, 0x4, 0x65, 0xce, 0x3, 0xab, 0x4d, 0xb3, 0xc7, 0x4b, 0xea, 0x45, 0xd2, 0x45, 0xd2, 0x16, 0x98, 0xe9, 0xf1, 0xcc, 0x8e, 0xd4, 0x6e, 0xc4, 0xbf, 0x4a, 0xd4, 0xff, 0xda, 0xaa, 0xb9, 0xca, 0x2b, 0xd7, 0x5a, 0xf8, 0x17, 0x80, 0xae, 0x59, 0x61, 0xb, 0x65, 0x27, 0x15, 0xa3, 0xf, 0x45, 0x81, 0x2a, 0xd1, 0x7, 0x5f, 0xb9, 0x5, 0x13, 0x40, 0x16, 0x7f, 0x69, 0xcc, 0xd0, 0x1b, 0x5, 0xfd, 0xf1, 0xf4, 0xcf, 0xa3, 0x6c, 0x5, 0x32, 0x69, 0xb0, 0x6e, 0x40, 0xd9, 0x9c, 0x5c, 0xbc, 0x68, 0x5d, 0xc1, 0x8e, 0x26, 0x6f, 0x60, 0xb2, 0x3c, 0x19, 0x56, 0x57, 0x76, 0xa5, 0xf7, 0x6c, 0x5e, 0xa9, 0x17, 0xaa, 0xb0, 0x8d, 0xb8, 0x63, 0xdc, 0x88, 0xc2, 0x34, 0x2c, 0x7f, 0x7f, 0xe, 0x0, 0x24, 0x6b, 0x66, 0xea, 0xfe, 0x2d, 0x3d, 0xe1, 0x38, 0x4a, 0x10, 0x8d, 0xf5, 0xdd, 0x5a, 0xac, 0x8f, 0xce, 0x8b, 0xed, 0xbf, 0x49, 0x5f, 0x6, 0x5d, 0xbf, 0x43, 0x7, 0xc9, 0x8b, 0x87, 0x9a, 0x6b, 0x38, 0x6f, 0x8a, 0x42, 0x61, 0xda, 0xea, 0xa0, 0xa, 0x33, 0x1f, 0xd2, 0xd8, 0x27, 0xe8, 0x95, 0xd2, 0xfd, 0xeb, 0x84, 0x1, 0x26, 0x56, 0x4e, 0xd5, 0x61, 0x62, 0x4a, 0xbb, 0xef, 0x25, 0xb0, 0x42, 0x7f, 0xaf, 0xef, 0xd7, 0x5, 0xf5, 0x6e, 0x2f, 0x36, 0x2a, 0xb7, 0x41, 0xc, 0xb7, 0x77, 0x59, 0x1b, 0xb0, 0x12, 0x6c, 0xf7, 0xe, 0x39, 0xe, 0xfb, 0xb4, 0xe7, 0xa1, 0x3b, 0x7, 0x45, 0xd7, 0xed, 0xd8, 0x64, 0xe6, 0xf9, 0xe, 0x8e, 0x38, 0xb6, 0x1c, 0x70, 0x6e, 0x14, 0x4b, 0xd5, 0xf, 0xbc, 0x6b, 0x5a, 0x5a, 0xbb, 0x81, 0xb, 0x5b, 0x82, 0xe2, 0xc0, 0xd1, 0x3b, 0xc4, 0xe, 0xfc, 0x83, 0xe9, 0xe7, 0x90, 0xf9, 0x90, 0xd3, 0x4a, 0x7, 0xa5, 0xf3, 0x12, 0xe2, 0x53, 0x90, 0xb, 0x57, 0xb0, 0x4e, 0xb6, 0x34, 0xdd, 0xfe, 0xaa, 0x53, 0x7a, 0xaf, 0x8d, 0x11, 0x8f, 0x1f, 0xd, 0xb5, 0x7d, 0x6e, 0x62, 0x6, 0xc0, 0xea, 0xf9, 0x4c, 0xe2, 0xd5, 0x40, 0xf6, 0xee, 0x2e, 0x2e, 0x20, 0x49, 0x41, 0x84, 0x8a, 0x53, 0x7d, 0x86, 0x8f, 0x9d, 0x95, 0xd6, 0x81, 0xf0, 0xc5, 0x93, 0x58, 0x81, 0x28, 0x8e, 0xd, 0x91, 0xc1, 0x2d, 0xe1, 0xc, 0x36, 0x29, 0xe4, 0x3e, 0x9d, 0xc4, 0x36, 0x20, 0x18, 0x9f, 0x44, 0x98, 0x5b, 0x59, 0x42, 0x7a, 0xc1, 0x31, 0xb3, 0x5a, 0xb4, 0x57, 0x4a, 0x3c, 0xe2, 0x88, 0x80, 0x6b, 0x9f, 0x4c, 0xd2, 0x3e, 0xe2, 0x46, 0x3f, 0x3a, 0xe9, 0x47, 0xfe, 0x6e, 0xee, 0x2f, 0xd3, 0xca, 0x9b, 0x77, 0x80, 0xe0, 0x93, 0x9b, 0x61, 0x5e, 0x8d, 0xcf, 0x94, 0xff, 0x68, 0x4f, 0xb4, 0x1b, 0x76, 0xd2, 0x5c, 0x61, 0x43, 0xc2, 0x82, 0xce, 0xd5, 0xd9, 0x79, 0x9e, 0xe1, 0x9f, 0xce, 0x19, 0x4b, 0x4, 0x7e, 0x80, 0x72, 0xb8, 0x15, 0x4e, 0x9c, 0x3c, 0xef, 0x1a, 0x34, 0xe7, 0xdf, 0xca, 0x73, 0xd4, 0xea, 0x16, 0x36, 0xcd, 0x81, 0x20, 0xa8, 0x48, 0x32, 0x85, 0xb2, 0x1a, 0xff, 0xd0, 0x2e, 0xe0, 0x6e, 0xc8, 0x82, 0xf7, 0x4b, 0xb8, 0xed, 0x8, 0xd0, 0x11, 0xa9, 0xa1, 0x70, 0x43, 0xd1, 0x2c, 0x4b, 0xfe, 0x83, 0xef, 0xc8, 0x20, 0x85, 0x49, 0xe5, 0x38, 0x74, 0x49, 0x77, 0x41, 0xaf, 0xf8, 0xe5, 0xb8, 0xfc, 0x59, 0x41, 0x91, 0xe1, 0xb9, 0x2e, 0x58, 0x1b, 0x1b, 0x73, 0x61, 0xee, 0x57, 0xbd, 0x39, 0xc5, 0xb2, 0xdf, 0xd4, 0x9f, 0x15, 0xc7, 0x58, 0xb5, 0x7d, 0xe8, 0xfd, 0x5f, 0x2d, 0x65, 0xf7, 0x25, 0x80, 0x41, 0x48, 0xa6, 0x41, 0xa2, 0xe3, 0xa, 0x73, 0x2b, 0x59, 0x32, 0xfe, 0x8c, 0xe4, 0x3a, 0x21, 0x2c, 0x6b, 0xe5, 0x56, 0x3f, 0xee, 0x85, 0x10, 0xe3, 0xb8, 0xa9, 0xfe, 0x21, 0xa0, 0xff, 0xb6, 0x49, 0x79, 0x18, 0xe, 0xc1, 0xd0, 0x84, 0x2f, 0x61, 0x2f, 0x1d, 0x58, 0xea, 0x55, 0x5f, 0x5b, 0x5c, 0x7d, 0xc8, 0x2e, 0xbf, 0x2e, 0x4a, 0xe7, 0x83, 0xf6, 0x8, 0xa3, 0x7d, 0xea, 0x30, 0x18, 0x6f, 0x55, 0x8e, 0xe7, 0x43, 0xc3, 0xc2, 0xd2, 0xc9, 0xd, 0x5f, 0x51, 0x26, 0x92, 0x0, 0xa2, 0x84, 0x55, 0xd1, 0x5f, 0xd4, 0x6, 0x51, 0x66, 0xae, 0x51, 0xd5, 0xa8, 0x26, 0x87, 0x93, 0x1, 0x1b, 0x77, 0x77, 0xbb, 0x8d, 0xfb, 0x52, 0x3c, 0x27, 0x8c, 0x9a, 0x7d, 0x1f, 0x69, 0xa, 0xaf, 0x5, 0xbd, 0xf9, 0xe, 0x7, 0x6b, 0x3d, 0xb8, 0x76, 0x6, 0xe6, 0x57, 0x5a, 0x8e, 0xc0, 0xa5, 0xc5, 0xbd, 0xa9, 0x63, 0x5f, 0xde, 0x17, 0x9d, 0x40, 0xde, 0xb4, 0x46, 0x6d, 0xcd, 0x2c, 0xf2, 0xf0, 0xce, 0x93, 0x55, 0x4c, 0xa6, 0xc4, 0x53, 0xb3, 0x2, 0x49, 0x8f, 0xdc, 0x5d, 0xfc, 0x4f, 0xe1, 0xcc, 0x71, 0x75, 0x29, 0xc3, 0x32, 0xc7, 0x77, 0x15, 0x40, 0xb2, 0x9c, 0xb3, 0xa3, 0xba, 0xbb, 0x52, 0x2d, 0xcc, 0x7c, 0xc, 0x10, 0x82, 0x96, 0x89, 0x3b, 0x4d, 0x90, 0x62, 0x94, 0x92, 0xde, 0xcd, 0x4a, 0xf2, 0x3e, 0xe8, 0xc8, 0x48, 0x30, 0xfe, 0xa1, 0x48, 0x2c, 0x9b, 0x9c, 0xbf, 0xa, 0xf1, 0x43, 0xaf, 0x68, 0x35, 0x4e, 0xc5, 0x7c, 0xdd, 0x8b, 0x3e, 0x1a, 0x50, 0x39, 0x68, 0xa9, 0x69, 0x12, 0x33, 0xd7, 0x6b, 0x36, 0x30, 0xb1, 0x8e, 0x1c, 0x79, 0x26, 0x3e, 0xb0, 0x5f, 0x81, 0x5, 0xd1, 0xe1, 0x7, 0x7, 0x1, 0xd3, 0x5c, 0xc0, 0x32, 0xdb, 0xfd, 0x5b, 0x2e, 0x87, 0x72, 0x12, 0xe7, 0xa1, 0x19, 0x40, 0xdf, 0x6c, 0xdc, 0xa8, 0x4d, 0x5c, 0xf7, 0xf7, 0x43, 0x6e, 0x65, 0x57, 0x16, 0xa0, 0x9, 0xd, 0x21, 0x24, 0xcb, 0xd, 0xc6, 0xf0, 0x7b, 0xd0, 0x51, 0xee, 0x93, 0x56, 0x28, 0x7a, 0x91, 0x96, 0xf4, 0x3b, 0x17, 0xf7, 0x3d, 0x3f, 0x5, 0x6d, 0xcd, 0x38, 0xcf, 0x9, 0x83, 0xf5, 0xda, 0xe8, 0xdb, 0x93, 0x98, 0x3, 0xd6, 0x86, 0x6a, 0xd4, 0xf2, 0x80, 0xc, 0xf1, 0xb3, 0x16, 0xca, 0x31, 0x4, 0x1e, 0xab, 0xbd, 0x59, 0xd0, 0xdf, 0x83, 0x80, 0xfc, 0xe7, 0xf3, 0xb6, 0x24, 0x61, 0xa4, 0xdd, 0x6e, 0x14, 0xf9, 0xe4, 0x8d, 0xc1, 0x30, 0x79, 0x1c, 0x4, 0xff, 0x7c, 0x6e, 0x3e, 0x84, 0x62, 0xf3, 0x85, 0x94, 0xb6, 0x2b, 0x11, 0xd6, 0xb8, 0x65, 0x62, 0x21, 0x70, 0xb9, 0x54, 0xff, 0x99, 0x9, 0xaf, 0x29, 0x99, 0xa, 0xb4, 0x13, 0x4d, 0x48, 0xd4, 0x94, 0xbe, 0xd3, 0xbf, 0x8f, 0x93, 0x9f, 0xfb, 0xa7, 0x6e, 0x3a, 0x3a, 0x8a, 0x26, 0x3f, 0x75, 0xf8, 0xa1, 0xf3, 0xb2, 0x19, 0x42, 0x25, 0x25, 0xd8, 0xac, 0x91, 0x94, 0x88, 0x72, 0xf2, 0x21, 0xf8, 0xc0, 0x79, 0x87, 0xa4, 0xee, 0x85, 0x29, 0xf7, 0x1a, 0x9f, 0x2b, 0x8a, 0xe7, 0xc7, 0xa0, 0x54, 0xc7, 0x3f, 0x13, 0xf, 0x97, 0xa2, 0xea, 0x8e, 0xbe, 0xae, 0xea, 0xc3, 0x8, 0xae, 0x9e, 0x98, 0x44, 0x47, 0x57, 0x3b, 0xcb, 0x29, 0x56, 0x54, 0x26, 0x1e, 0x9, 0x80, 0x4c, 0x65, 0xd3, 0xac, 0xcc, 0x93, 0x2c, 0x32, 0xd2, 0x65, 0xe8, 0x26, 0x12, 0x50, 0xbc, 0x4, 0x5f, 0xdb, 0x58, 0x96, 0xab, 0x26, 0x6c, 0xf3, 0xba, 0x5b, 0x92, 0x54, 0xdd, 0x8e, 0x54, 0x11, 0x2f, 0x2b, 0xfc, 0xc9, 0xf1, 0x19, 0xef, 0x4e, 0x20, 0x59, 0xa9, 0xec, 0xf, 0xf6, 0x2b, 0x42, 0xc3, 0xdf, 0xfb, 0xa2, 0x86, 0x8e, 0x4a, 0xa1, 0xc7, 0x2, 0x1a, 0xc3, 0x5c, 0x9a, 0xec, 0x2c, 0xb5, 0xd1, 0x33, 0xe2, 0xdb, 0x8e, 0x11, 0xce, 0x6b, 0x2c, 0xce, 0x87, 0x75, 0x4f, 0x4d, 0xa3, 0xa4, 0x7, 0x89, 0xf9, 0x5e, 0xf5, 0x60, 0xbc, 0x90, 0x57, 0x8f, 0x50, 0xf8, 0x8, 0x7f, 0x4e, 0x53, 0x44, 0x4a, 0xf8, 0xc4, 0x53, 0x77, 0x4d, 0x99, 0x8e, 0x13, 0xbc, 0xbf, 0xc, 0xe5, 0x4c, 0xbc, 0xf5, 0x69, 0x58, 0x25, 0x49, 0x59, 0x68, 0x59, 0x79, 0xe5, 0x6f, 0xc, 0xfb, 0xee, 0x65, 0x7f, 0xae, 0xb, 0xdb, 0x4, 0x80, 0x90, 0x76, 0x27, 0xac, 0x22, 0x31, 0xee, 0xdc, 0xf, 0x78, 0xba, 0xc2, 0x8b, 0x5a, 0xbe, 0x1d, 0x20, 0xa0, 0xe4, 0x28, 0x97, 0x3d, 0x15, 0xe6, 0xf1, 0x29, 0x6e, 0x3b, 0xa, 0xb8, 0x76, 0x1d, 0x77, 0xdc, 0x92, 0x8a, 0x43, 0xae, 0xce, 0x9c, 0xa5, 0xc5, 0x2, 0xef, 0x74, 0x66, 0x87, 0x4b, 0x68, 0x10, 0x85, 0xdd, 0xb5, 0xe7, 0x37, 0x7e, 0x16, 0xd1, 0x1e, 0xa2, 0xf, 0xd9, 0x31, 0xf9, 0xbc, 0x21, 0x3a, 0xe0, 0xf5, 0x44, 0xaa, 0xed, 0xea, 0x9e, 0x4f, 0xb7, 0xf5, 0x46, 0x5b, 0x94, 0xc1, 0x49, 0x79, 0xf3, 0xbb, 0x23, 0x16, 0x76, 0x83, 0x1e, 0xe7, 0x3f, 0xb7, 0xa3, 0x79, 0xb7, 0x89, 0x36, 0x57, 0x1, 0xd6, 0xe2, 0xe2, 0xa2, 0x47, 0xc1, 0xc2, 0x1a, 0xe5, 0xeb, 0xf6, 0xf3, 0xed, 0xd9, 0xc4, 0x68, 0x98, 0x97, 0x4b, 0x73, 0x43, 0x6, 0xe7, 0xc, 0x9b, 0x55, 0x73, 0xb4, 0xd0, 0x52, 0xe6, 0x3f, 0x9c, 0x44, 0x39, 0x6b, 0xc8, 0x9c, 0x95, 0x66, 0x80, 0xa, 0x7e, 0x2a, 0x9a, 0x4c, 0x32, 0x90, 0x2f, 0x79, 0x9b, 0x4f, 0xf2, 0x2c, 0xc9, 0xbc, 0x21, 0xf3, 0x9b, 0x8a, 0x8a, 0xf4, 0xe3, 0x40, 0x7, 0xca, 0xe3, 0x7a, 0xde, 0x40, 0xcb, 0x85, 0x9d, 0xec, 0xea, 0x4d, 0x27, 0x4b, 0xd1, 0x1d, 0xbb, 0x2f, 0x5b, 0xa3, 0x4, 0x31, 0x3c, 0x66, 0xa7, 0x7f, 0x7a, 0x43, 0xb5, 0xaa, 0x7d, 0xfe, 0x18, 0xbe, 0x40, 0xa9, 0xf4, 0x99, 0xb9, 0x5e, 0x4b, 0x82, 0x5e, 0xa0, 0xb, 0xb8, 0x3a, 0xd, 0x4f, 0x11, 0xf2, 0xf6, 0x2f, 0x5e, 0xa7, 0xf, 0xb8, 0x17, 0xdc, 0x6c, 0x66, 0x6b, 0x9, 0xbb, 0x6c, 0x91, 0x99, 0x72, 0xb2, 0xa0, 0xc7, 0xbf, 0xb1, 0xc, 0x5b, 0x46, 0x74, 0x92, 0xb8, 0x29, 0x1a, 0x2b, 0x98, 0x20, 0xe2, 0xd8, 0xbc, 0x6e, 0x72, 0x50, 0x35, 0x5e, 0x23, 0xf5, 0x6, 0x62, 0xda, 0xfe, 0xec, 0xe0, 0xc, 0xc8, 0xc0, 0xb7, 0x4f, 0xe2, 0x2, 0x78, 0xdd, 0xdf, 0x87, 0xd, 0xdd, 0xaf, 0x8, 0x34, 0x80, 0xb1, 0x50, 0x4e, 0x11, 0xb5, 0x18, 0xd3, 0xf9, 0xe9, 0x93, 0x3c, 0x3f, 0xf2, 0xf0, 0xca, 0x3c, 0x42, 0x3b, 0x86, 0x91, 0x68, 0x3e, 0x3e, 0xa1, 0x90, 0x20, 0x4, 0xaa, 0x51, 0xcd, 0x82, 0x37, 0x9, 0xbb, 0x5, 0x14, 0x1a, 0x8b, 0x8c, 0xfb, 0xcb, 0x4e, 0xf9, 0xf7, 0x3a, 0xca, 0x2f, 0x9, 0x71, 0x65, 0x58, 0xd8, 0x79, 0x41, 0x8d, 0xc7, 0xb0, 0x88, 0x2f, 0xaa, 0x38, 0x1a, 0xac, 0xef, 0xaa, 0xb6, 0x11, 0xec, 0xc3, 0x36, 0xf3, 0x6d, 0x6f, 0xd7, 0x89, 0xeb, 0x73, 0x46, 0x52, 0xa0, 0x8b, 0xbf, 0xc6, 0x1d, 0x19, 0x92, 0x50, 0x67, 0xc6, 0xe5, 0xdc, 0xac, 0x4f, 0x5, 0xbf, 0xda, 0xb6, 0xfc, 0xf0, 0x83, 0x59, 0x9f, 0x28, 0x45, 0xd0, 0x42, 0x9c, 0x5, 0xa6, 0x16, 0xd1, 0x97, 0x70, 0x4, 0x80, 0x3b, 0xff, 0xf9, 0x8, 0x74, 0x51, 0x4a, 0x79, 0xc0, 0xf4, 0x5e, 0x4c, 0xc5, 0xb3, 0x18, 0x2b, 0xe7, 0xc4, 0x5a, 0x9e, 0x2f, 0x9a, 0xd, 0xd9, 0x76, 0xfe, 0x3c, 0x22, 0x5, 0x42, 0xcf, 0x11, 0xcb, 0x52, 0x78, 0x61, 0xcd, 0x74, 0x61, 0xe0, 0x3f, 0x53, 0x35, 0x29, 0xe, 0x24, 0xc4, 0x83, 0xb1, 0x5d, 0xd2, 0x61, 0x7b, 0x31, 0x37, 0x1a, 0x6f, 0xf9, 0x8c, 0xd6, 0x2f, 0xd8, 0xe7, 0x13, 0xf1, 0x66, 0xc3, 0x95, 0x4f, 0x8, 0x67, 0xdc, 0x8c, 0x36, 0x41, 0xc9, 0xcd, 0xb1, 0xa2, 0x4f, 0x3a, 0x9e, 0xf2, 0x70, 0xd5, 0x63, 0x37, 0x53, 0x7c, 0x98, 0xd3, 0xfe, 0x90, 0x4c, 0xfc, 0x32, 0xd, 0x8d, 0x19, 0xa2, 0x41, 0xe1, 0x54, 0xc, 0xf5, 0xcb, 0xfc, 0x5a, 0x55, 0x79, 0xc7, 0x60, 0x26, 0xcd, 0xf9, 0x61, 0xae, 0x88, 0xd3, 0x22, 0x48, 0x18, 0xe8, 0xea, 0xcd, 0x70, 0xae, 0x43, 0x7, 0xb3, 0x35, 0xbb, 0x75, 0x9f, 0x8e, 0xb7, 0x1d, 0x4a, 0x32, 0xd1, 0x2f, 0x61, 0x18, 0x4d, 0x91, 0xcb, 0x8, 0x17, 0x37, 0xeb, 0x9e, 0xf5, 0xc3, 0x6b, 0x8b, 0xd5, 0xa7, 0x62, 0xb3, 0x78, 0x12, 0x53, 0x40, 0x3a, 0x9d, 0x62, 0x1b, 0x90, 0x70, 0xeb, 0x22, 0xb7, 0x7d, 0x41, 0xdb, 0x6a, 0x8b, 0x23, 0xb6, 0xb6, 0xdf, 0xfb, 0xa9, 0x2b, 0x4d, 0x54, 0xd4, 0xc6, 0x25, 0xff, 0x55, 0xba, 0x5b, 0xb0, 0xd1, 0xbf, 0x49, 0x9f, 0xee, 0x64, 0x81, 0x3e, 0x76, 0x2c, 0xbe, 0x9b, 0xe8, 0xa6, 0x65, 0x66, 0xa5, 0xf7, 0x33, 0xb0, 0xeb, 0x40, 0x7c, 0xb0, 0x25, 0xa0, 0xd9, 0xe, 0x6e, 0x2e, 0x8a, 0x41, 0x5d, 0x9c, 0xed, 0x32, 0x17, 0xa5, 0x41, 0xc2, 0x8d, 0xea, 0xff, 0x17, 0xab, 0x86, 0x55, 0xdb, 0x0, 0x1f, 0x52, 0x3f, 0xf3, 0x3, 0x92, 0x13, 0x37, 0xed, 0x2e, 0xe0, 0xae, 0xac, 0x60, 0x70, 0xf8, 0xad, 0xf9, 0xff, 0xd6, 0x13, 0x32, 0xec, 0xbf, 0xd2, 0xdf, 0x68, 0xab, 0x36, 0x67, 0x51, 0xc8, 0x38, 0x85, 0x36, 0x7e, 0xff, 0x7f, 0x58, 0x9e, 0xcc, 0x4b, 0x7d, 0xa6, 0x51, 0x3, 0xf8, 0x14, 0xeb, 0xc2, 0xb3, 0x99, 0x93, 0x3, 0x16, 0x24, 0x13, 0x23, 0xa1, 0xf5, 0xa2, 0xbf, 0xc7, 0x1f, 0xca, 0x1, 0x9b, 0xf8, 0x88, 0xf6, 0xd5, 0x63, 0x2a, 0xc9, 0x16, 0xd7, 0x3a, 0x3e, 0x91, 0x5d, 0x26, 0xdd, 0x11, 0xa2, 0x81, 0x6a, 0x27, 0xe2, 0x38, 0x56, 0x8e, 0xd0, 0xbb, 0x4d, 0x2d, 0xbb, 0x13, 0xfe, 0x6b, 0x6d, 0xb5, 0x7b, 0xe, 0xd9, 0xed, 0x50, 0x5, 0x59, 0x79, 0x1b, 0x1, 0x75, 0x51, 0x79, 0xea, 0x68, 0xf5, 0x7f, 0xc4, 0xb, 0xc3, 0x57, 0x92, 0x5d, 0x11, 0x44, 0x1, 0xf3, 0x28, 0xbf, 0x6a, 0xfb, 0x7a, 0x35, 0x48, 0xf9, 0x57, 0xea, 0x12, 0xf7, 0x69, 0x76, 0x67, 0x1a, 0x8b, 0x5c, 0xc2, 0xa5, 0xb0, 0xd0, 0x85, 0xec, 0xa8, 0x7c, 0xdb, 0x91, 0x1d, 0x13, 0x44, 0xaa, 0x7f, 0xe0, 0x2c, 0x92, 0xf1, 0xe, 0x5c, 0x86, 0xb6, 0xbd, 0x4c, 0x1f, 0xc2, 0xc6, 0xf0, 0x2c, 0xcc, 0xec, 0x98, 0xaa, 0xeb, 0x75, 0x20, 0x57, 0xcb, 0x4e, 0x64, 0x43, 0x4d, 0x1e, 0x9, 0x86, 0xb9, 0x3e, 0x3f, 0x98, 0x1d, 0x1b, 0x58, 0x35, 0xd7, 0x56, 0x91, 0xcf, 0x58, 0x6, 0x54, 0xb5, 0xab, 0x34, 0x68, 0x85, 0x9b, 0x21, 0x4b, 0xf, 0x3b, 0xf6, 0xa7, 0x56, 0x5, 0x90, 0x1a, 0x6a, 0x1e, 0xc1, 0xef, 0xe, 0xe0, 0xa6, 0xce, 0x1, 0x32, 0xd2, 0x8c, 0xd7, 0x9e, 0x63, 0x65, 0xec, 0x6a, 0x99, 0x2f, 0x8a, 0xd7, 0x30, 0xa4, 0x4, 0xc, 0x8b, 0xc2, 0xa0, 0xfe, 0xb8, 0x31, 0x5a, 0x90, 0x63, 0x95, 0x16, 0xb0, 0xd3, 0xd, 0xb4, 0xa6, 0x6f, 0x7e, 0x72, 0x48, 0xb0, 0x4f, 0xfe, 0xc3, 0x98, 0x5b, 0x2a, 0x19, 0x95, 0xdf, 0x3e, 0xd5, 0x8c, 0x35, 0x31, 0x67, 0x5c, 0x4b, 0xa8, 0x85, 0xd5, 0xa4, 0x88, 0xa7, 0x73, 0xdd, 0xb3, 0xe9, 0x4d, 0x29, 0x82, 0xfa, 0x22, 0xa7, 0xd4, 0x24, 0x41, 0x43, 0x5, 0xa3, 0x36, 0x17, 0x19, 0x92, 0xde, 0x1, 0xe3, 0x1e, 0x72, 0x45, 0xcb, 0xd3, 0xb5, 0x4d, 0x46, 0x20, 0x90, 0x14, 0x92, 0x1d, 0x5f, 0xbd, 0xd3, 0x7, 0x7f, 0x3b, 0xfd, 0x86, 0xa3, 0xa9, 0x9c, 0xf9, 0x98, 0xd1, 0x41, 0xc3, 0xa4, 0x33, 0xe7, 0xd6, 0x8a, 0xad, 0x54, 0x7c, 0xe, 0xc9, 0x9c, 0xa3, 0xf, 0x2d, 0x15, 0xff, 0x5f, 0x26, 0xcd, 0x0, 0xf0, 0xd4, 0x5f, 0x2f, 0x4, 0x61, 0xef, 0x70, 0xa, 0x30, 0x3, 0x88, 0x77, 0x0, 0x4a, 0x22, 0xd5, 0x4c, 0xe3, 0xf1, 0x98, 0xb4, 0x4a, 0xd4, 0x70, 0xf2, 0xa, 0xde, 0xad, 0x37, 0xbd, 0x7f, 0x74, 0x82, 0xe7, 0x27, 0xc1, 0x20, 0x21, 0x45, 0x33, 0x54, 0x88, 0xa7, 0x39, 0xe6, 0x88, 0xf7, 0x82, 0x32, 0x54, 0xdd, 0x66, 0x9d, 0xf5, 0x9b, 0xfd, 0x94, 0xec, 0x7b, 0x8, 0xc5, 0x26, 0x28, 0x6a, 0xab, 0xde, 0xd0, 0xec, 0x28, 0x71, 0x4e, 0x7c, 0x5c, 0x56, 0x37, 0x9f, 0x5f, 0x2, 0x97, 0xe5, 0x35, 0x12, 0xdd, 0x1e, 0x71, 0xde, 0x49, 0x3e, 0x46, 0x3d, 0x3f, 0x4d, 0x18, 0x0, 0x97, 0xb8, 0x77, 0x1b, 0x5e, 0x5, 0x5f, 0xc7, 0xe4, 0x36, 0xc5, 0x7b, 0x53, 0x36, 0x54, 0x23, 0xd3, 0x59, 0xee, 0xa4, 0x14, 0x96, 0xef, 0xfc, 0x10, 0xf9, 0xb, 0x46, 0xa2, 0x20, 0x4e, 0xf4, 0xcf, 0x3d, 0xae, 0xbb, 0x60, 0xa3, 0x4, 0x78, 0x66, 0xd7, 0x36, 0xda, 0x1a, 0x35, 0x53, 0xbd, 0x32, 0xa7, 0x8a, 0x37, 0xa, 0xd1, 0x49, 0x31, 0x9e, 0xa4, 0xcd, 0xfe, 0xb9, 0x92, 0x1f, 0xf9, 0x20, 0xb4, 0xd6, 0xa2, 0x75, 0x2e, 0x9f, 0x63, 0x96, 0xda, 0x5f, 0x32, 0xab, 0x8d, 0x79, 0xe7, 0x17, 0xf0, 0x4f, 0xf9, 0xd, 0x19, 0x8d, 0x24, 0x99, 0x76, 0xc0, 0x81, 0xcd, 0x29, 0x81, 0x59, 0xba, 0xce, 0x7d, 0x72, 0x0, 0xe3, 0x4c, 0x82, 0xd0, 0xc7, 0x6a, 0x61, 0xdc, 0x8, 0x98, 0x28, 0x7c, 0xa0, 0xa7, 0x7e, 0x9f, 0x4d, 0x64, 0x95, 0x57, 0xe0, 0xcd, 0x4c, 0x5e, 0x13, 0x8d, 0xa5, 0x3d, 0x30, 0xd4, 0x7c, 0x5b, 0xb4, 0xca, 0xd5, 0x26, 0x77, 0x32, 0x1c, 0xa0, 0xde, 0xc3, 0x9, 0xcb, 0x65, 0x8f, 0x73, 0xd9, 0x3d, 0x6c, 0x5, 0x72, 0x6b, 0xba, 0x12, 0x4, 0xd7, 0x8c, 0xbe, 0x97, 0xbb, 0x3f, 0xb7, 0x6c, 0x7b, 0x9f, 0x64, 0xd, 0x6f, 0x96, 0x17, 0xa, 0x87, 0x39, 0xf7, 0x74, 0x30, 0x11, 0x17, 0x11, 0xe1, 0x3d, 0x9e, 0x4e, 0x73, 0x48, 0x63, 0xcb, 0x39, 0xa3, 0xe3, 0x66, 0xc4, 0x6, 0xde, 0x7b, 0xd0, 0xa7, 0x16, 0x38, 0x4e, 0x5a, 0xe, 0xef, 0xee, 0x58, 0x1c, 0xd1, 0x67, 0x5, 0xd1, 0x74, 0x5f, 0x13, 0xd5, 0x6b, 0xb5, 0x5, 0x3d, 0xd1, 0x86, 0x6b, 0xf9, 0xcd, 0xe1, 0xad, 0x9c, 0x46, 0x2a, 0x76, 0xd8, 0x82, 0x42, 0x2f, 0x5c, 0x9a, 0x60, 0x25, 0x13, 0x1f, 0x8b, 0x58, 0x78, 0xad, 0xf9, 0x7d, 0x32, 0xa0, 0xfd, 0x89, 0x32, 0x1d, 0x62, 0xea, 0x5f, 0x5b, 0x8b, 0xa3, 0xc3, 0x80, 0x90, 0x57, 0xc4, 0xd5, 0x53, 0xa3, 0x91, 0xde, 0xe7, 0x5b, 0x93, 0xc8, 0x52, 0x9a, 0xc4, 0x98, 0xa4, 0x9b, 0x52, 0xf2, 0xe3, 0xab, 0x6b, 0xf6, 0x59, 0xcd, 0xe1, 0xb2, 0x10, 0xae, 0xbc, 0x3a, 0x85, 0xec, 0x87, 0x9, 0xe9, 0xab, 0x6c, 0x61, 0x34, 0x8, 0x1e, 0xa0, 0xb0, 0x20, 0xe0, 0xb0, 0x86, 0x7c, 0x72, 0xa6, 0x54, 0x58, 0x3b, 0x95, 0x4c, 0xbc, 0xf8, 0xef, 0x2a, 0x73, 0xce, 0x98, 0x3c, 0x2f, 0x8f, 0xb, 0x5d, 0xb5, 0x77, 0x6c, 0x16, 0xf5, 0x60, 0x79, 0x23, 0x9a, 0x6d, 0x74, 0x64, 0x69, 0x6a, 0x18, 0x2a, 0xc5, 0x18, 0x55, 0x24, 0x6f, 0x8d, 0xdf, 0x8, 0x7f, 0xb4, 0x3, 0x84, 0xf, 0xbf, 0xaf, 0x21, 0x5b, 0x1c, 0x49, 0xd2, 0xe7, 0xb8, 0xcd, 0xc5, 0x67, 0x43, 0x1f, 0x1d, 0x0, 0xc3, 0x79, 0x54, 0xdc, 0x7b, 0x40, 0xbe, 0xe9, 0xa8, 0x68, 0xf2, 0xea, 0xda, 0x29, 0xe6, 0xf0, 0xa7, 0x31, 0x86, 0xc1, 0x19, 0x27, 0x81, 0x97, 0xaf, 0x5, 0x4c, 0x7e, 0x3f, 0x88, 0xe5, 0xf6, 0x96, 0xb0, 0xd4, 0xc9, 0x4c, 0x11, 0x96, 0xf0, 0x58, 0xff, 0xd7, 0x27, 0x22, 0xf6, 0x49, 0x5f, 0x16, 0xdc, 0x41, 0xe6, 0x75, 0x83, 0x3d, 0xf9, 0xe4, 0x39, 0x4a, 0xfb, 0xcc, 0x7a, 0x32, 0xb1, 0x1c, 0xc2, 0x38, 0x8e, 0x49, 0x29, 0x78, 0x68, 0x65, 0xbe, 0x41, 0x78, 0xf5, 0x40, 0xca, 0x52, 0x5d, 0x6, 0x7f, 0xa, 0x78, 0x6b, 0xe5, 0x96, 0xf1, 0x6, 0x70, 0xa2, 0x5f, 0xc6, 0xf2, 0xf5, 0x25, 0xca, 0xc4, 0xe, 0x7e, 0x34, 0x1a, 0xdd, 0xcf, 0xcb, 0x91, 0xf0, 0x69, 0xa5, 0xc2, 0xae, 0xcd, 0x7b, 0x86, 0xed, 0x1f, 0xbe, 0xbe, 0x8e, 0x3b, 0xdb, 0xc3, 0xfe, 0x27, 0xf9, 0x4, 0x2c, 0xc5, 0x3b, 0xec, 0x16, 0x19, 0x8a, 0xd4, 0x22, 0x30, 0x25, 0x6c, 0x83, 0x86, 0xb4, 0x6c, 0x4a, 0xd9, 0x87, 0xea, 0xfc, 0xb6, 0xf0, 0x7e, 0x34, 0x7c, 0xc7, 0xc4, 0xab, 0x4b, 0x4, 0xef, 0x9d, 0x20, 0xcb, 0x58, 0x12, 0x45, 0xc9, 0xc1, 0x2, 0xcc, 0xba, 0x4, 0x4a, 0x18, 0x84, 0x14, 0x6, 0x66, 0xf3, 0x8b, 0xe3, 0xe6, 0x4f, 0xac, 0x46, 0x35, 0xc, 0x4b, 0x3e, 0x98, 0x3d, 0x96, 0x78, 0x84, 0x5e, 0x9c, 0xfc, 0xc6, 0x55, 0xa2, 0x4b, 0xf8, 0x9a, 0x8f, 0xd4, 0x60, 0x5, 0x36, 0xd6, 0x5, 0x8, 0x26, 0x68, 0x61, 0x20, 0x38, 0xb6, 0x25, 0x52, 0x85, 0xbe, 0x6e, 0x62, 0x66, 0xc9, 0x7, 0x56, 0xa3, 0xcb, 0x11, 0x69, 0x31, 0xf7, 0xd7, 0x41, 0x2d, 0x17, 0x25, 0x14, 0x37, 0x60, 0xfe, 0xb8, 0x6f, 0x4f, 0x8c, 0x4c, 0xdf, 0x1f, 0x4b, 0x6, 0xbe, 0xed, 0xf, 0x69, 0xe3, 0xf6, 0x4c, 0x5d, 0xc7, 0x97, 0x5f, 0xac, 0xe5, 0xf2, 0x9, 0xb4, 0xb6, 0x7c, 0xed, 0xb7, 0x34, 0xc2, 0x30, 0x73, 0xf9, 0xae, 0x1d, 0x82, 0x4e, 0xf8, 0x49, 0xbe, 0x83, 0x6f, 0x2, 0xd4, 0x8a, 0xa4, 0x3, 0x48, 0x22, 0x1f, 0xd0, 0x9e, 0x11, 0x1c, 0x7, 0x6e, 0x61, 0x73, 0x74, 0xcc, 0x43, 0xf, 0x31, 0x20, 0x38, 0x3f, 0xce, 0xb3, 0x8c, 0x42, 0xdd, 0x6f, 0x4b, 0x53, 0xe6, 0x6e, 0xf6, 0xc8, 0x3, 0x68, 0xe0, 0xfb, 0x96, 0x51, 0x2f, 0xcb, 0x25, 0xec, 0xbc, 0x4c, 0x2c, 0x3b, 0x99, 0xa0, 0x77, 0x89, 0xe6, 0x92, 0x3, 0x11, 0xda, 0xca, 0x59, 0x9d, 0xd8, 0xc9, 0xf0, 0xca, 0x41, 0x3a, 0x4b, 0xf9, 0xb9, 0xb9, 0x86, 0xd9, 0x20, 0x21, 0x37, 0xc9, 0xdd, 0xdd, 0x36, 0xf9, 0xb1, 0x6b, 0x4, 0x82, 0x68, 0xf8, 0x33, 0x4a, 0xf0, 0xcf, 0xb1, 0x3d, 0xcc, 0x25, 0x89, 0x0, 0x7e, 0x4d, 0xdc, 0x4b, 0x34, 0xa2, 0x16, 0xf7, 0x35, 0x8f, 0x31, 0x6e, 0xff, 0xff, 0x9d, 0xc3, 0x3a, 0x8d, 0x5f, 0xd9, 0x1a, 0x95, 0xbd, 0x43, 0x3b, 0xad, 0x8b, 0xb3, 0x1d, 0x4a, 0x14, 0xd6, 0xd4, 0x5f, 0x6c, 0xb5, 0xe8, 0xa8, 0xec, 0x31, 0x18, 0xa, 0x76, 0xaa, 0x3, 0xe8, 0x3a, 0xb3, 0xb2, 0xcb, 0x9a, 0x7d, 0xe0, 0x74, 0xe, 0xc7, 0xbb, 0xb5, 0x5d, 0xdb, 0x56, 0x32, 0xd4, 0xbe, 0x11, 0x82, 0xe2, 0xab, 0xe3, 0xf6, 0x25, 0x92, 0x3b, 0xf5, 0xb9, 0x44, 0x88, 0xa0, 0x0, 0x72, 0x41, 0x4d, 0xeb, 0x2f, 0xbf, 0xc7, 0x94, 0x44, 0x46, 0x5e, 0xf1, 0xa, 0xa7, 0xea, 0xab, 0xcc, 0x52, 0xe1, 0x3f, 0x68, 0x60, 0x12, 0x50, 0xf3, 0x13, 0xb4, 0xd, 0x3d, 0xde, 0x69, 0x4f, 0xd9, 0x35, 0xe9, 0x2d, 0x4, 0xa9, 0x40, 0xa8, 0xbb, 0x7d, 0x56, 0x70, 0xed, 0x45, 0x4b, 0x47, 0x72, 0x5d, 0x93, 0x3e, 0x64, 0xea, 0x64, 0x85, 0xe4, 0x58, 0x9f, 0x1d, 0x9e, 0x53, 0xde, 0x5e, 0xb1, 0xc9, 0x45, 0x0, 0x49, 0xf3, 0x5d, 0x14, 0xbc, 0xf8, 0xc3, 0x8d, 0x20, 0xbe, 0x81, 0x5d, 0x5a, 0x61, 0x70, 0x3f, 0x36, 0x36, 0xf6, 0xe2, 0x93, 0xea, 0x38, 0x4b, 0x74, 0x2a, 0x90, 0x88, 0xae, 0x0, 0x6d, 0x3a, 0xcb, 0xa, 0x29, 0x6e, 0xad, 0x46, 0x80, 0xf3, 0x15, 0x2d, 0xeb, 0x56, 0x80, 0x15, 0x30, 0xd6, 0x4, 0x4a, 0xa0, 0x40, 0x50, 0x5e, 0xa4, 0xfb, 0x65, 0x6e, 0xca, 0xe9, 0xe3, 0x89, 0xa3, 0xe5, 0x4, 0xf, 0xb6, 0x64, 0x90, 0xc7, 0x9f, 0x26, 0xe9, 0x80, 0xaf, 0x88, 0x56, 0xbc, 0xd3, 0x81, 0xa5, 0x3e, 0x7, 0x36, 0xa9, 0xa4, 0xbc, 0x0, 0x4c, 0xea, 0x3, 0xf1, 0x27, 0xc4, 0x2d, 0x3a, 0xa7, 0x5a, 0xb, 0x9d, 0x90, 0x84, 0x32, 0x6f, 0x57, 0xca, 0xf3, 0x46, 0x22, 0x9f, 0x81, 0x8a, 0x94, 0xfd, 0xf9, 0x2c, 0xf3, 0x2f, 0xc3, 0xdf, 0x8, 0x8, 0xc, 0x57, 0xe2, 0xbd, 0x93, 0x42, 0xfa, 0xe, 0x60, 0x0, 0x4e, 0x90, 0x91, 0xd5, 0x14, 0xc5, 0x0, 0xd4, 0xc3, 0x10, 0xc, 0x73, 0x61, 0xe, 0xd9, 0x89, 0xcc, 0xf5, 0xc2, 0xd4, 0x9, 0x96, 0xf5, 0x2e, 0x4f, 0xa4, 0x69, 0xbb, 0xce, 0xf2, 0xce, 0x1a, 0x7b, 0x2e, 0xfb, 0x9d, 0x70, 0xdd, 0xb3, 0xb, 0x28, 0x72, 0x8f, 0x7b, 0x59, 0x9f, 0x50, 0x3d, 0x92, 0x1c, 0x59, 0x37, 0xf, 0xca, 0xe3, 0xe0, 0x7b, 0xab, 0x48, 0x85, 0xe1, 0x97, 0x26, 0x1f, 0x9d, 0x9, 0x59, 0xad, 0x49, 0xb4, 0x18, 0xb2, 0xf4, 0x45, 0xc0, 0x27, 0x28, 0xdb, 0x3, 0x90, 0x42, 0x82, 0x42, 0x45, 0xcc, 0xc7, 0x75, 0x42, 0xe0, 0xc0, 0xb1, 0x5c, 0x73, 0xc8, 0xe0, 0x17, 0x67, 0xbe, 0x6a, 0x2b, 0xa, 0xb3, 0x70, 0x9f, 0x35, 0x63, 0x2, 0x25, 0xd9, 0x74, 0x9e, 0x23, 0x11, 0xb, 0xc9, 0x6f, 0x59, 0x1b, 0x8d, 0x82, 0x24, 0x91, 0xb9, 0xd, 0x7f, 0x89, 0x3d, 0xc1, 0x12, 0x78, 0x12, 0x18, 0x15, 0x65, 0x95, 0x4e, 0xe6, 0xb8, 0x12, 0x28, 0x65, 0xbd, 0xb4, 0x96, 0xad, 0x53, 0x3e, 0xb7, 0x48, 0x18, 0x6, 0xd4, 0xbb, 0x6, 0x1e, 0x18, 0x17, 0xa, 0x1d, 0xa3, 0x7c, 0xb4, 0x35, 0xcf, 0x35, 0x6d, 0xbf, 0xa5, 0x70, 0xad, 0x4e, 0xeb, 0x26, 0x34, 0x26, 0x12, 0xbc, 0x73, 0xf6, 0xe0, 0xd3, 0x9c, 0xa4, 0x5e, 0xe, 0xb4, 0x4c, 0xeb, 0x7, 0xe4, 0x9d, 0x29, 0xe1, 0xb7, 0x26, 0x71, 0x2f, 0x51, 0xb, 0x68, 0xef, 0x29, 0x75, 0xcf, 0xcf, 0xeb, 0x65, 0x61, 0x64, 0xb, 0xf, 0xc, 0x2e, 0xf9, 0x23, 0xfc, 0x68, 0x10, 0xfa, 0x5c, 0xc5, 0xe5, 0xf7, 0xe5, 0xc2, 0x99, 0x2f, 0xc7, 0xe0, 0x23, 0xcc, 0xab, 0xc7, 0x8b, 0x8d, 0x9f, 0x3e, 0xea, 0xbf, 0xff, 0xf3, 0xa3, 0xc3, 0xc3, 0x8d, 0x32, 0x16, 0x57, 0xe5, 0x95, 0xbb, 0x4e, 0x6c, 0xf1, 0x4, 0xf8, 0xb5, 0x9d, 0xd4, 0x49, 0x1a, 0x88, 0xc9, 0x6b, 0x11, 0xaa, 0x51, 0x79, 0xc3, 0xe2, 0x30, 0x63, 0x5, 0xf4, 0x9f, 0x81, 0x3a, 0x5, 0x98, 0x3, 0x7c, 0xdf, 0xa9, 0x5a, 0x24, 0x49, 0x29, 0x6, 0x59, 0xc8, 0xc1, 0xf1, 0x67, 0x1c, 0xa6, 0x88, 0xa1, 0x9c, 0xa4, 0x98, 0xed, 0xa4, 0xf5, 0x77, 0x1a, 0x97, 0x2b, 0x23, 0x4f, 0x2, 0xfa, 0x70, 0xcf, 0x19, 0x8e, 0xa4, 0x22, 0x27, 0x1, 0xd1, 0xf3, 0x1, 0x31, 0x31, 0xf, 0x1b, 0xa4, 0x40, 0x1e, 0xab, 0xc0, 0x61, 0x90, 0xac, 0x9d, 0xbc, 0x8e, 0xb1, 0xc7, 0x52, 0x6d, 0x4, 0x5f, 0xee, 0xa, 0x9c, 0xbd, 0xcb, 0x24, 0xe0, 0x44, 0x64, 0xe0, 0x3, 0x31, 0x23, 0xd6, 0xf8, 0xf2, 0xf2, 0x4f, 0x12, 0x3c, 0x5e, 0x6d, 0xfd, 0x75, 0xd9, 0x43, 0x63, 0x9c, 0x47, 0xa6, 0x11, 0x4f, 0x8d, 0xdb, 0x7a, 0xf9, 0x65, 0xb8, 0xdd, 0xa8, 0x46, 0xf, 0xdb, 0xc4, 0xb2, 0x58, 0x48, 0x94, 0x90, 0xe6, 0x63, 0x26, 0x69, 0x74, 0x4, 0x59, 0x2a, 0x4a, 0xd4, 0x12, 0x4e, 0x3d, 0x87, 0x9d, 0xb8, 0x64, 0x18, 0x62, 0x79, 0xd3, 0x7, 0x1, 0x5d, 0x2c, 0x3a, 0xdf, 0x96, 0xe2, 0xf5, 0x71, 0x60, 0xf0, 0xe4, 0xa2, 0x3, 0x7d, 0x6c, 0x76, 0xc, 0x5c, 0x4c, 0x85, 0x2d, 0x40, 0x0, 0xad, 0xe5, 0x1e, 0xbc, 0x66, 0x13, 0xa7, 0xb4, 0x8c, 0xa, 0xa4, 0x0, 0xd0, 0xfc, 0xed, 0x3c, 0x5e, 0x47, 0x7, 0x4c, 0x3b, 0x91, 0x77, 0x3, 0xd2, 0xfb, 0x1b, 0x4, 0xb0, 0x58, 0xec, 0xf3, 0x3f, 0xf5, 0x4e, 0xfe, 0xa3, 0x74, 0x95, 0xe4, 0x5c, 0x9b, 0xba, 0x1c, 0x1b, 0x26, 0xf1, 0x60, 0xde, 0xb, 0xee, 0xf2, 0x1d, 0x26, 0xf1, 0x91, 0x31, 0x4, 0x11, 0x63, 0xba, 0xbf, 0xe1, 0x6e, 0x4d, 0x38, 0xd8, 0x35, 0x19, 0xbb, 0xc1, 0x66, 0x22, 0xef, 0x69, 0xe, 0x3f, 0xd0, 0xa6, 0x1a, 0x96, 0x8f, 0x6, 0x32, 0xa, 0x44, 0x54, 0xaa, 0x43, 0x88, 0x3d, 0xa5, 0x80, 0xa3, 0x96, 0xbc, 0x65, 0xe8, 0xaf, 0x87, 0x27, 0x49, 0x5c, 0xde, 0x4, 0x2a, 0x5, 0x87, 0x8, 0x53, 0x99, 0xfd, 0xbd, 0xf6, 0x8f, 0x77, 0xae, 0x2b, 0xec, 0x13, 0x2d, 0x66, 0x79, 0x4, 0xd1, 0xff, 0xbf, 0xf7, 0xa2, 0xb3, 0x61, 0xe6, 0x7d, 0xba, 0x50, 0x18, 0xd0, 0xd7, 0x5c, 0x2, 0x5d, 0x2f, 0xd7, 0x7e, 0x48, 0x27, 0x44, 0x8b, 0xeb, 0xa2, 0xe9, 0x1c, 0x3c, 0x4f, 0x45, 0x65, 0x65, 0xaa, 0xbf, 0x8f, 0x9e, 0x1c, 0xaa, 0xb0, 0x20, 0xa7, 0x97, 0xd6, 0xb8, 0xc2, 0xc9, 0xa7, 0x30, 0xfd, 0xd8, 0xf, 0x5d, 0x22, 0x7e, 0xf9, 0xda, 0xf8, 0x8b, 0xb0, 0x2, 0x6a, 0x9e, 0x93, 0xc3, 0xd8, 0xa, 0x16, 0x36, 0x83, 0xc, 0xe8, 0x32, 0xb0, 0x9b, 0x94, 0x2c, 0xc6, 0xd6, 0x27, 0x8c, 0xec, 0x5e, 0x29, 0x42, 0x9a, 0xa6, 0xd6, 0x72, 0xf2, 0xba, 0x7, 0x12, 0xd5, 0xa8, 0x45, 0x80, 0xc1, 0x54, 0xc0, 0xdf, 0x8, 0xb6, 0x3, 0x2e, 0x59, 0x2, 0x35, 0x3c, 0xeb, 0x67, 0x93, 0xad, 0x9c, 0x8e, 0xc9, 0x53, 0x53, 0x1b, 0x4f, 0x6, 0x2, 0xed, 0xbf, 0x3d, 0x6, 0x9a, 0x7, 0xf, 0x41, 0x66, 0xf1, 0x2a, 0x3a, 0xe3, 0xd3},
+               output224: []byte{0x48, 0x47, 0x85, 0xc8, 0xdb, 0x75, 0xcd, 0x2b, 0x16, 0xcf, 0x81, 0x65, 0xa0, 0xb6, 0x1f, 0xca, 0xd8, 0x6f, 0x80, 0x38, 0xe0, 0xee, 0x83, 0x93, 0x94, 0x43, 0xf0, 0x14},
+               output256: []byte{0xec, 0x23, 0xf3, 0xc4, 0x52, 0x43, 0x23, 0x39, 0x33, 0xa5, 0x81, 0xab, 0x55, 0x4e, 0xa3, 0x91, 0xac, 0xb3, 0xaf, 0xff, 0x8c, 0xed, 0x26, 0xe7, 0xed, 0x29, 0x44, 0x50, 0x40, 0xa8, 0xd5, 0x27},
+               output384: []byte{0x9, 0x6a, 0xfc, 0x47, 0xcf, 0x56, 0x86, 0xfb, 0x78, 0x50, 0x70, 0xa2, 0xe0, 0x9f, 0xbf, 0x69, 0xf5, 0x9, 0xff, 0x92, 0x0, 0xb3, 0x45, 0x85, 0x7f, 0xb0, 0xb8, 0xe7, 0xc, 0xbb, 0xb0, 0x12, 0xb9, 0x28, 0x62, 0x71, 0x59, 0xab, 0xdb, 0x35, 0x63, 0x1a, 0xfa, 0xe8, 0x4c, 0x6d, 0xc, 0x58},
+               output512: []byte{0xab, 0x2c, 0xd6, 0x17, 0x71, 0x32, 0x92, 0x54, 0x97, 0x7d, 0x33, 0x31, 0xb3, 0xbb, 0x8b, 0x94, 0x40, 0xba, 0x1b, 0x32, 0x36, 0xa, 0x58, 0x1f, 0x44, 0xc1, 0x7c, 0xc7, 0x83, 0x23, 0x17, 0x37, 0xaf, 0xf1, 0x4e, 0xa9, 0x52, 0x78, 0x6b, 0x2f, 0x5c, 0xe2, 0xdb, 0xe2, 0xb2, 0x76, 0xf2, 0x84, 0x8b, 0x25, 0xd7, 0xbd, 0x1d, 0x84, 0xf0, 0x73, 0xe5, 0x3, 0x6f, 0xc7, 0xb8, 0xd0, 0x8d, 0xa1}},
+       testcase{
+               msg:       []byte{0x61, 0xcc, 0x4d, 0x97, 0xf4, 0x11, 0xd9, 0x59, 0x56, 0x2a, 0xf, 0xc4, 0x10, 0x9b, 0x44, 0x2a, 0xff, 0xf5, 0x9b, 0xdb, 0x15, 0x84, 0x15, 0xe8, 0x65, 0x8f, 0x95, 0x45, 0xa4, 0xaa, 0x2b, 0xa8, 0xb6, 0x4a, 0x65, 0xb0, 0xc7, 0x1f, 0xdf, 0x33, 0x8d, 0x2f, 0x48, 0xee, 0x3, 0x1d, 0x8b, 0x6f, 0xc2, 0xb0, 0x49, 0xc2, 0xbe, 0x4f, 0x25, 0xcf, 0xb5, 0xd9, 0x59, 0xc7, 0x70, 0x99, 0x68, 0x9b, 0x4c, 0x60, 0x7a, 0x2f, 0x81, 0xc5, 0xfa, 0xfe, 0xcb, 0x32, 0x90, 0x63, 0x3c, 0x5e, 0x77, 0x66, 0xc2, 0xe7, 0x66, 0xb4, 0xcb, 0xb1, 0xf9, 0x7f, 0x8a, 0x4d, 0x61, 0xc6, 0xc5, 0x5c, 0xa9, 0x96, 0xc8, 0xff, 0xef, 0x51, 0xef, 0x28, 0xa9, 0xc, 0x6, 0xdc, 0x75, 0xe2, 0xa, 0xff, 0x33, 0x9a, 0x28, 0xa4, 0x4f, 0xc0, 0x57, 0xfe, 0x51, 0xfe, 0xde, 0x72, 0x60, 0x93, 0x8e, 0x89, 0xad, 0x74, 0xac, 0xfe, 0x13, 0x76, 0x7b, 0xcd, 0xb8, 0xd2, 0x5b, 0xb8, 0x90, 0xc1, 0x40, 0x1c, 0x59, 0x86, 0xc6, 0xa1, 0xdd, 0xd3, 0x66, 0xeb, 0x5e, 0xdc, 0xa5, 0x5e, 0xc9, 0xb6, 0x5c, 0x10, 0x14, 0xde, 0xa4, 0x75, 0x97, 0xda, 0xb8, 0x11, 0x44, 0x6e, 0xd3, 0xc7, 0xa3, 0x57, 0x1b, 0xc7, 0x7d, 0x1e, 0x3e, 0x97, 0xca, 0xc5, 0x60, 0x8c, 0x43, 0xcd, 0x3, 0x2c, 0x63, 0x45, 0x54, 0x6, 0xea, 0x98, 0xb3, 0x11, 0x68, 0x8f, 0x11, 0xa0, 0x79, 0x2a, 0xb, 0x8e, 0x65, 0xff, 0x80, 0x45, 0x26, 0x63, 0x8a, 0x73, 0xe, 0xf2, 0x5a, 0x6f, 0x4a, 0x7b, 0x18, 0x92, 0xde, 0x22, 0x6b, 0x6f, 0xa4, 0xb, 0x65, 0xe4, 0xfe, 0xf5, 0x38, 0x7a, 0xc4, 0xee, 0xda, 0x6e, 0xec, 0xcf, 0x15, 0x57, 0x12, 0xe7, 0x53, 0x6c, 0x1a, 0x4a, 0xaa, 0xd5, 0xf7, 0x8f, 0x8c, 0x86, 0x68, 0x42, 0xd, 0xa7, 0xa4, 0x8d, 0x48, 0x6f, 0x4c, 0x4f, 0x0, 0x63, 0x29, 0xe7, 0xbd, 0x87, 0x50, 0x16, 0x55, 0x12, 0x0, 0x5d, 0x88, 0x6, 0x1e, 0xf2, 0x35, 0x4a, 0x84, 0x74, 0x9e, 0xf2, 0x9f, 0xc0, 0xd5, 0xd4, 0x75, 0x30, 0x6, 0x87, 0x86, 0x86, 0xd0, 0x98, 0x25, 0x82, 0x5d, 0x25, 0x58, 0x9a, 0xa3, 0xf3, 0x86, 0xab, 0xd0, 0x79, 0x39, 0x63, 0x12, 0xe8, 0xcb, 0x26, 0xcc, 0x92, 0x42, 0xc, 0xca, 0xc1, 0x74, 0x92, 0x89, 0x5b, 0x2a, 0xbd, 0x20, 0x17, 0xa, 0x1d, 0xf0, 0x11, 0x18, 0x1f, 0x40, 0x51, 0xae, 0xff, 0x2d, 0xe7, 0x84, 0x91, 0x3c, 0xc4, 0xf, 0xa8, 0x5e, 0x5f, 0x26, 0xc3, 0xfb, 0x36, 0xbc, 0x39, 0x6f, 0x6b, 0x1e, 0xe7, 0x11, 0x7e, 0x77, 0xd2, 0x9a, 0x25, 0x3e, 0x37, 0xf0, 0x27, 0x69, 0xf7, 0x57, 0x4d, 0x6c, 0xa2, 0x3a, 0x56, 0xf9, 0x25, 0x14, 0xaa, 0x61, 0x5a, 0x42, 0x4b, 0x48, 0x4f, 0x90, 0xf3, 0x82, 0xe1, 0xad, 0xd, 0x3a, 0xc3, 0x91, 0x5e, 0x4, 0x8d, 0x99, 0xd7, 0x47, 0x79, 0xbe, 0x14, 0x3, 0xe4, 0x9c, 0x61, 0xf6, 0x76, 0x9, 0x49, 0xe8, 0x94, 0x55, 0x93, 0xf7, 0xa0, 0xde, 0x5d, 0x88, 0x4b, 0xdc, 0x2e, 0x94, 0xf4, 0xbb, 0xef, 0xd5, 0x1d, 0x83, 0xe3, 0x31, 0xfd, 0xb7, 0xfe, 0x8e, 0x4c, 0x4b, 0x4, 0x29, 0xa2, 0x4e, 0xc0, 0x2e, 0xd9, 0xf3, 0xdf, 0x54, 0x40, 0x4f, 0x6d, 0x7c, 0x8f, 0xf5, 0x28, 0x95, 0xe5, 0x85, 0x34, 0x42, 0xc0, 0x3d, 0xcd, 0xb9, 0xa9, 0x80, 0x37, 0x7e, 0x9, 0xc2, 0x1a, 0xb8, 0x81, 0x9b, 0x29, 0xec, 0x96, 0xad, 0xd, 0xf, 0xab, 0xdb, 0x77, 0xe4, 0x2b, 0xcc, 0xc7, 0xfc, 0x7a, 0x70, 0xb8, 0x3e, 0xe0, 0x53, 0xf5, 0x56, 0xb9, 0x5, 0xc6, 0x3f, 0x81, 0x14, 0xc1, 0x7a, 0x45, 0xae, 0x8d, 0x19, 0xce, 0xca, 0x6e, 0x52, 0x18, 0x33, 0x6e, 0xc1, 0x16, 0x13, 0xdc, 0x11, 0x53, 0x2d, 0x91, 0x65, 0x2e, 0x78, 0xf8, 0x67, 0x26, 0xa8, 0x7, 0x49, 0xd7, 0xc, 0xc5, 0x4c, 0xa4, 0x1c, 0x33, 0xd6, 0x43, 0xf2, 0x80, 0xf1, 0x9, 0xf6, 0x26, 0x9c, 0x3d, 0xa3, 0x77, 0xbf, 0xe8, 0x7b, 0xfa, 0x60, 0xa1, 0xd1, 0x67, 0x88, 0x1a, 0xf2, 0x20, 0xfc, 0x8d, 0x2a, 0x6e, 0x29, 0x2, 0x26, 0xfc, 0x2d, 0xf, 0x66, 0xd2, 0xa1, 0xa7, 0xfa, 0xbe, 0x47, 0xaa, 0x80, 0x7, 0xee, 0xc3, 0x1, 0xe8, 0x2f, 0xf5, 0xb, 0xf7, 0x14, 0x84, 0x63, 0x64, 0x5d, 0xd2, 0x47, 0x19, 0x27, 0xf9, 0x54, 0x6d, 0xa7, 0x8e, 0x15, 0xd1, 0x2, 0xe7, 0x1, 0xbf, 0x6, 0xc9, 0x72, 0xee, 0xd2, 0xb4, 0x89, 0xde, 0x28, 0xbc, 0x21, 0x48, 0x57, 0x7f, 0xb4, 0x89, 0x14, 0x1d, 0xe8, 0xcb, 0x51, 0xd2, 0x42, 0x82, 0xe6, 0x21, 0x26, 0x7a, 0x41, 0x39, 0xd1, 0xf0, 0xbc, 0x35, 0xdc, 0x9d, 0x9c, 0x42, 0xbc, 0x33, 0xa0, 0x4f, 0x81, 0x9, 0x5a, 0xb3, 0xf1, 0x76, 0xc4, 0x21, 0x2e, 0x50, 0xb7, 0x7e, 0xa2, 0xd1, 0x32, 0xc9, 0xa5, 0xb9, 0xb, 0x1e, 0x32, 0xe6, 0x31, 0xcf, 0x1e, 0x10, 0xc5, 0x58, 0x35, 0x14, 0x32, 0x59, 0x78, 0x58, 0x1c, 0x1e, 0x55, 0xf7, 0x52, 0xd7, 0x6d, 0xbf, 0xfc, 0x85, 0x76, 0xf5, 0x64, 0x22, 0xc5, 0xda, 0x1c, 0xe2, 0xe, 0x77, 0x38, 0x7f, 0x51, 0x73, 0x89, 0x44, 0x67, 0xab, 0x5, 0x88, 0x65, 0x3b, 0xbb, 0x44, 0xbc, 0xbe, 0xbe, 0x48, 0x53, 0xfd, 0xb9, 0xcd, 0x39, 0x15, 0x70, 0x68, 0xc9, 0x7, 0xb3, 0x2c, 0xfc, 0x4a, 0xa5, 0xda, 0xf2, 0xd0, 0x24, 0xe0, 0xc3, 0xb2, 0xa8, 0x4, 0xfe, 0x5f, 0x2c, 0xde, 0x75, 0xd2, 0x99, 0xb3, 0x7c, 0x5f, 0xb4, 0x42, 0x2d, 0x7e, 0x61, 0xe9, 0x59, 0xab, 0xf9, 0xc, 0x9a, 0x3d, 0x8d, 0xf6, 0x29, 0xe7, 0x6f, 0x4a, 0x44, 0xb7, 0x62, 0x63, 0xe9, 0xeb, 0x7a, 0xd1, 0x64, 0x9e, 0xa8, 0x9f, 0x88, 0x38, 0x70, 0x5e, 0x1a, 0x63, 0x2f, 0xa0, 0xb9, 0x14, 0x82, 0xe9, 0x7, 0xf0, 0x77, 0xb9, 0x92, 0xc9, 0x6b, 0x30, 0x64, 0xd6, 0xd7, 0x60, 0x4d, 0x9, 0xe6, 0x82, 0xa5, 0x88, 0x6a, 0x2d, 0x93, 0x34, 0x13, 0x81, 0x61, 0xdf, 0x51, 0x41, 0xc3, 0xf0, 0x62, 0x51, 0xbd, 0x47, 0x1, 0x63, 0x87, 0x53, 0x87, 0xaf, 0xb3, 0x81, 0x63, 0x39, 0x4b, 0x33, 0x5b, 0x79, 0x21, 0xb, 0xad, 0x92, 0xac, 0xa5, 0x68, 0xbd, 0x1a, 0xe1, 0xe5, 0x11, 0xc2, 0x28, 0x3, 0xbb, 0xa3, 0x60, 0x79, 0xfe, 0xf0, 0x28, 0x35, 0x3a, 0xa0, 0xf5, 0x73, 0x4a, 0x1c, 0x7c, 0x6c, 0x4e, 0x6e, 0xd6, 0x84, 0x74, 0x2b, 0xab, 0xad, 0xe, 0x93, 0xed, 0xbc, 0xd0, 0xde, 0x50, 0x47, 0x3a, 0x5f, 0x46, 0xcb, 0xd9, 0xc5, 0x92, 0xfa, 0x92, 0xd4, 0x2e, 0xbe, 0x1, 0xa, 0xce, 0xa9, 0x7b, 0xb3, 0x6f, 0xba, 0xbe, 0x2f, 0x14, 0xbd, 0x2, 0xb1, 0xa0, 0x7b, 0x35, 0x70, 0x1d, 0x13, 0x16, 0x23, 0xbd, 0xd5, 0x26, 0xbe, 0xdd, 0xad, 0xb, 0x4f, 0xc6, 0xfb, 0xbf, 0xd4, 0xcf, 0xca, 0x8e, 0x51, 0x37, 0x67, 0xed, 0x4d, 0x10, 0xec, 0x64, 0xf9, 0x20, 0xe9, 0xe6, 0xcd, 0x52, 0x86, 0x76, 0x87, 0x5a, 0x7, 0xc, 0xa6, 0xd7, 0xaa, 0xc6, 0x80, 0x7b, 0x53, 0xb7, 0xb1, 0x37, 0x49, 0xcb, 0xe3, 0x50, 0xd5, 0xfc, 0xfe, 0x1b, 0x34, 0xe4, 0xdf, 0x2e, 0x89, 0x50, 0x70, 0x19, 0xbd, 0x6f, 0xcb, 0x24, 0xaf, 0xc3, 0xa1, 0xc9, 0xbd, 0x64, 0xca, 0x4c, 0x75, 0x72, 0xfa, 0xc9, 0xd8, 0x76, 0x49, 0x51, 0xd, 0x5f, 0x91, 0xb3, 0x73, 0xef, 0xa0, 0xb9, 0x7e, 0xde, 0x7b, 0x87, 0x68, 0xd0, 0x18, 0x6b, 0x96, 0x8e, 0x5a, 0x7f, 0x6d, 0x18, 0x1c, 0xb5, 0xf4, 0x5b, 0xe2, 0xeb, 0xb9, 0x42, 0xe2, 0x3d, 0x82, 0x1b, 0xd7, 0xa8, 0xa1, 0xd7, 0xb0, 0xe2, 0xa7, 0x35, 0xde, 0xe8, 0x94, 0x4c, 0x37, 0x8f, 0xf9, 0xa9, 0x8e, 0x13, 0xad, 0x73, 0x44, 0x19, 0x8b, 0x57, 0x6c, 0x6c, 0xc7, 0x70, 0xc0, 0x82, 0xd6, 0x40, 0x93, 0x6d, 0x3f, 0x7, 0x2, 0x12, 0x93, 0x76, 0x46, 0x62, 0xf7, 0x71, 0x95, 0xcf, 0x95, 0x6e, 0x91, 0xaa, 0x7d, 0x14, 0xeb, 0xdd, 0x6, 0xc4, 0x1b, 0x57, 0xc9, 0xe8, 0x81, 0xf2, 0xde, 0x46, 0x7a, 0xef, 0x5, 0xfe, 0x9e, 0xa1, 0x80, 0x9c, 0x45, 0xa, 0x45, 0xf3, 0xf0, 0xd6, 0x7d, 0x74, 0x47, 0xf8, 0xaf, 0x8f, 0x87, 0xdd, 0x52, 0xb3, 0x3, 0x62, 0xf4, 0x4a, 0xfa, 0xff, 0x54, 0xa2, 0xa0, 0x33, 0x1a, 0xd8, 0xc1, 0x8c, 0x2f, 0x35, 0x94, 0xa1, 0xe1, 0x87, 0xa1, 0xd9, 0x4a, 0x4c, 0x18, 0x29, 0xd8, 0x7e, 0xa6, 0x7e, 0xce, 0x4, 0x57, 0x72, 0xbb, 0xc8, 0x2c, 0x23, 0x1f, 0xea, 0xaf, 0xa8, 0x1e, 0x2f, 0x6e, 0x18, 0xd7, 0xf4, 0x50, 0x20, 0xae, 0xd2, 0xb2, 0x2f, 0xee, 0x1d, 0xf1, 0x3f, 0xc3, 0x18, 0x47, 0xeb, 0xc9, 0xf8, 0xca, 0x14, 0xe, 0x49, 0x44, 0xf8, 0xd1, 0x11, 0xa4, 0xde, 0xb5, 0x6c, 0x8, 0x88, 0x88, 0xe, 0xb9, 0x56, 0x1, 0xfb, 0xac, 0xe7, 0x99, 0x18, 0xa6, 0xbe, 0x2f, 0xb, 0xd3, 0x70, 0x21, 0x56, 0x89, 0x98, 0x87, 0x25, 0xe9, 0xaf, 0xa9, 0x88, 0x55, 0x38, 0x67, 0xf8, 0x98, 0xc9, 0x39, 0xa8, 0xdc, 0x4a, 0x58, 0xfa, 0xab, 0x9b, 0x10, 0x51, 0x85, 0x90, 0x4c, 0xd5, 0x43, 0x38, 0x2f, 0x7d, 0xde, 0x81, 0x1e, 0xbd, 0x11, 0x4a, 0xe1, 0x9, 0xb9, 0x7e, 0xfb, 0x4a, 0x7b, 0xd4, 0xe5, 0x82, 0xc3, 0xf6, 0x4, 0x23, 0xb4, 0x8c, 0x1e, 0x35, 0xb8, 0xc0, 0xf2, 0x91, 0x4, 0x8c, 0x29, 0x37, 0x5f, 0x9c, 0xc2, 0xd4, 0xc0, 0x10, 0x79, 0xa2, 0x7, 0xbb, 0x7b, 0xcf, 0x87, 0x5f, 0xc7, 0x53, 0x5b, 0xf4, 0x7d, 0xb2, 0x51, 0xed, 0x8a, 0x60, 0xf0, 0x3d, 0x84, 0xe4, 0x9e, 0x32, 0xec, 0x5e, 0x72, 0xf6, 0xdf, 0x26, 0xf1, 0x8b, 0xa0, 0x40, 0xf5, 0x8, 0xa0, 0x2e, 0xce, 0x21, 0x59, 0x7b, 0xd7, 0x10, 0xc3, 0x60, 0x52, 0xeb, 0xf7, 0xa0, 0xcf, 0xa8, 0xc1, 0xfd, 0xa1, 0x32, 0xee, 0x3f, 0x9d, 0xff, 0x88, 0x14, 0xcf, 0xdf, 0xe0, 0xa5, 0x14, 0xc9, 0x1f, 0xc7, 0x95, 0x46, 0xb8, 0x24, 0x47, 0x92, 0x6d, 0x42, 0x2b, 0x8a, 0xab, 0x87, 0xb9, 0x4c, 0xc2, 0x9f, 0x16, 0x5e, 0x1f, 0x97, 0xf, 0xf2, 0x74, 0xfe, 0x2a, 0x66, 0x21, 0xea, 0xc5, 0xf1, 0x28, 0x16, 0x12, 0x9d, 0x27, 0xb8, 0xdf, 0x6, 0xe3, 0x2a, 0x41, 0x75, 0x2a, 0x65, 0xde, 0xb, 0x47, 0x28, 0x3e, 0xf0, 0x49, 0x42, 0x2a, 0x9a, 0xf5, 0x8a, 0x9b, 0xfc, 0xb0, 0x42, 0xac, 0xe1, 0xce, 0x47, 0x1, 0x24, 0x36, 0x9a, 0x91, 0x5e, 0x2b, 0xdd, 0xcc, 0x29, 0x24, 0x31, 0xe8, 0x89, 0x82, 0xbc, 0x6f, 0x9c, 0x51, 0xac, 0x4c, 0x8b, 0x3e, 0x2a, 0xa9, 0x6b, 0xfd, 0x6b, 0x57, 0x4a, 0xe9, 0xd7, 0x2, 0xa2, 0x67, 0x30, 0x81, 0xeb, 0xf5, 0x4f, 0xb3, 0x32, 0xf5, 0x52, 0xee, 0x17, 0xba, 0x63, 0x81, 0x12, 0x81, 0x62, 0x86, 0xe9, 0x4f, 0xe4, 0x3c, 0x66, 0x95, 0x75, 0x2e, 0x67, 0xf6, 0x9c, 0xe6, 0xdc, 0x48, 0x93, 0xe1, 0xdb, 0xe8, 0xc5, 0xdf, 0x8f, 0x29, 0x22, 0x71, 0xf4, 0xf5, 0xc1, 0x40, 0xf3, 0x24, 0xaf, 0xb4, 0x9a, 0x15, 0x65, 0x71, 0x7f, 0xf0, 0xe0, 0x68, 0x1f, 0x1, 0xcb, 0x7c, 0xf9, 0x6d, 0x2f, 0x8c, 0x50, 0xa2, 0xd7, 0x6f, 0xa6, 0xb4, 0x50, 0x97, 0x1, 0x21, 0x1e, 0x7, 0xc7, 0x14, 0x2d, 0x22, 0xa2, 0xfc, 0x40, 0xc2, 0xcb, 0x47, 0xe9, 0x1a, 0xd, 0xde, 0x3c, 0xd8, 0x6f, 0xbd, 0x2, 0xee, 0x53, 0xf8, 0x36, 0x7d, 0x1f, 0x25, 0xe6, 0xbc, 0xc, 0x4, 0xf1, 0x90, 0x80, 0xac, 0x19, 0x68, 0x9e, 0x72, 0x13, 0x27, 0x63, 0x42, 0x89, 0x26, 0x18, 0x27, 0x33, 0x35, 0x94, 0xcf, 0x23, 0xa7, 0xcc, 0xb, 0xc, 0x95, 0x26, 0x12, 0x57, 0xf2, 0xf2, 0xa4, 0xd9, 0xea, 0xf7, 0x27, 0x4, 0x89, 0xf, 0x29, 0xa5, 0xc6, 0xf1, 0x23, 0x94, 0xc6, 0xa5, 0x76, 0x88, 0xbb, 0xf6, 0x1e, 0x18, 0x70, 0x12, 0xcb, 0x7c, 0x92, 0xd7, 0x20, 0x58, 0x59, 0x76, 0xae, 0xe3, 0x44, 0xbc, 0xcb, 0xa6, 0x7, 0xe7, 0x4f, 0x50, 0x32, 0xc1, 0x45, 0x92, 0xc3, 0x17, 0xd2, 0x11, 0xc3, 0x84, 0x8f, 0xd7, 0x6c, 0xbf, 0xd8, 0x4d, 0x7a, 0x62, 0x1e, 0x3d, 0x89, 0xfe, 0xca, 0x1a, 0xc8, 0xd1, 0xc0, 0x9, 0x8, 0x55, 0xd5, 0x30, 0xdf, 0x5, 0x97, 0x8e, 0xa5, 0xc, 0x36, 0xdb, 0x86, 0xd3, 0x11, 0xfd, 0xe0, 0xf8, 0xc6, 0x59, 0x8d, 0xff, 0xa9, 0x4f, 0x9, 0x4e, 0x4c, 0x3, 0x4f, 0xcb, 0x13, 0x98, 0x6e, 0xcc, 0xf0, 0x9d, 0xcc, 0xa0, 0x3f, 0x2b, 0xa0, 0x6f, 0x86, 0xd2, 0xe4, 0x9a, 0xa9, 0x11, 0x5b, 0xd8, 0xc, 0xf4, 0x95, 0x49, 0xe6, 0xfb, 0x23, 0xa8, 0x14, 0x19, 0x82, 0x6f, 0x7f, 0x37, 0x4, 0xa1, 0xfe, 0xac, 0xaa, 0x45, 0x6d, 0xa4, 0xc1, 0x7, 0x61, 0x4c, 0x99, 0x24, 0x43, 0xd5, 0xdb, 0xc8, 0x94, 0xf, 0x66, 0xc2, 0xf3, 0x96, 0x78, 0x6c, 0xe6, 0x52, 0xe, 0x8, 0xb7, 0x15, 0xd1, 0xdc, 0x3a, 0xc0, 0xe6, 0x95, 0xb7, 0xbe, 0x34, 0x89, 0x72, 0x52, 0x2d, 0xc4, 0xc8, 0x31, 0xf0, 0x2b, 0x42, 0x53, 0xdc, 0x76, 0x18, 0x1f, 0x97, 0x9c, 0x6f, 0x4, 0x50, 0xa7, 0x30, 0x32, 0x88, 0xab, 0xe8, 0xb9, 0xfd, 0x6f, 0x8a, 0x9f, 0x46, 0xaa, 0x93, 0xc4, 0xe6, 0x72, 0x4e, 0x29, 0xc9, 0x89, 0x1b, 0xa4, 0xeb, 0x84, 0x3, 0x1, 0x3d, 0xef, 0x60, 0x68, 0x41, 0x3b, 0xcb, 0x4d, 0x41, 0x3e, 0xab, 0xd6, 0x9b, 0x81, 0x2f, 0x47, 0x9a, 0x2b, 0x63, 0x43, 0x7a, 0xbe, 0x8c, 0xc, 0xe4, 0xaa, 0xb3, 0x43, 0x86, 0xde, 0x58, 0xb, 0xd7, 0x4, 0xaa, 0x36, 0x4f, 0x17, 0xc0, 0x31, 0x19, 0x5f, 0xd, 0xef, 0x63, 0xcf, 0xd8, 0x8f, 0x12, 0x46, 0xa5, 0x89, 0x5d, 0x3d, 0x6, 0xc2, 0xbf, 0xc9, 0x19, 0x93, 0x92, 0x80, 0xec, 0xb8, 0xd1, 0x17, 0x7d, 0x79, 0x90, 0x62, 0xb4, 0xf4, 0xf0, 0xb3, 0xc7, 0xd8, 0x55, 0xaa, 0xd7, 0x6a, 0x52, 0x53, 0x1, 0xeb, 0x67, 0x6, 0x69, 0x56, 0x39, 0xd0, 0x3a, 0x4c, 0xc, 0xfa, 0xb1, 0x1a, 0x1e, 0xa7, 0x4a, 0xad, 0x65, 0xd6, 0x8b, 0xae, 0xff, 0x5b, 0x3, 0x55, 0xae, 0xc1, 0xbc, 0xdf, 0xf9, 0xfc, 0xa7, 0xf3, 0xba, 0x5d, 0xfa, 0x9f, 0x7e, 0x1d, 0x7, 0x33, 0x5, 0xbd, 0x96, 0xf9, 0xab, 0xf5, 0xec, 0x76, 0xa1, 0x4b, 0xe2, 0x1e, 0xe5, 0x36, 0xe0, 0x98, 0x66, 0xc1, 0xe0, 0xc4, 0xb9, 0xab, 0x8e, 0x70, 0x43, 0xb, 0xc7, 0x8, 0xdd, 0xe6, 0x17, 0xf6, 0x68, 0x6c, 0x2b, 0x61, 0x65, 0x98, 0x1b, 0xf5, 0xc7, 0xc, 0x74, 0x7a, 0xb2, 0x22, 0x48, 0x2b, 0x7, 0x6f, 0x50, 0x32, 0x65, 0x6e, 0xa7, 0x80, 0xe0, 0x79, 0x8c, 0x5f, 0x18, 0x22, 0x35, 0x90, 0xd3, 0x87, 0x28, 0x4, 0xc3, 0x79, 0xe5, 0x11, 0x4c, 0x6a, 0x49, 0xc8, 0xdb, 0xfc, 0x14, 0xbe, 0xe6, 0x80, 0x46, 0x12, 0xeb, 0x21, 0xb2, 0x5, 0x5a, 0xfc, 0xc7, 0xc1, 0xb2, 0xa8, 0xe8, 0xbe, 0x67, 0xfa, 0xd7, 0xfd, 0x8b, 0x5e, 0x26, 0x41, 0xfe, 0x8c, 0xf3, 0x77, 0x92, 0xfe, 0x47, 0xbf, 0xc3, 0x5c, 0x76, 0x94, 0x96, 0x10, 0xf6, 0x71, 0x8d, 0xb9, 0x40, 0x3b, 0x29, 0xf5, 0x36, 0xde, 0x9, 0xce, 0x4a, 0x25, 0x4f, 0x9d, 0x61, 0x2d, 0xcb, 0x93, 0x17, 0x5f, 0x55, 0x92, 0x46, 0x6c, 0xf9, 0xb7, 0xed, 0x5, 0x85, 0xf8, 0x3d, 0x1e, 0xb7, 0xae, 0x64, 0xcd, 0x83, 0xc1, 0x17, 0xa7, 0xf7, 0xa0, 0x2a, 0x85, 0x9a, 0x73, 0x37, 0x7b, 0xaf, 0x46, 0x24, 0xbc, 0xb5, 0xb7, 0xc3, 0x13, 0xf6, 0xc2, 0x61, 0x31, 0x38, 0x24, 0x5f, 0xa0, 0xa4, 0xb, 0x84, 0x4c, 0xd8, 0x67, 0x1, 0x11, 0xaa, 0x27, 0xbb, 0xb0, 0x1a, 0x73, 0x68, 0xaa, 0x56, 0xbf, 0x24, 0xdc, 0x7d, 0x8e, 0x21, 0xfc, 0xa5, 0x6e, 0x84, 0xa3, 0x27, 0x76, 0x57, 0x1f, 0xf6, 0xb, 0x3a, 0xe3, 0x8b, 0x3a, 0xd1, 0xed, 0x3e, 0xd3, 0xbd, 0xd1, 0x9e, 0xde, 0x8c, 0x24, 0xc2, 0xaa, 0x71, 0xec, 0xc2, 0xb2, 0x81, 0x24, 0xdd, 0xa, 0xfc, 0x38, 0x2b, 0x78, 0x4e, 0x27, 0x3e, 0x83, 0x8a, 0xfb, 0x69, 0x8d, 0x8a, 0xa3, 0x36, 0x1, 0x6c, 0x49, 0x88, 0xa5, 0x8e, 0xce, 0xd, 0x8a, 0x2a, 0x2d, 0x94, 0x36, 0x2d, 0x73, 0x83, 0x46, 0xc9, 0x50, 0xbf, 0x5, 0x0, 0x8a, 0x10, 0xe2, 0x9b, 0xf2, 0x7f, 0x15, 0xb8, 0x2, 0xf2, 0x13, 0xb8, 0xe6, 0x94, 0x73, 0xb0, 0x23, 0x33, 0x29, 0x52, 0x91, 0x2f, 0x20, 0x47, 0x2f, 0xdc, 0xf1, 0x93, 0x7, 0x7a, 0xf, 0x46, 0xe, 0x68, 0x4f, 0x9f, 0xde, 0xcd, 0x2d, 0x77, 0x93, 0xdd, 0xb3, 0x3d, 0x54, 0x57, 0xba, 0x30, 0xb4, 0xd9, 0x1e, 0xc2, 0x72, 0xd1, 0xe6, 0xe5, 0xd2, 0x79, 0x56, 0x98, 0xa9, 0xaf, 0x40, 0x6a, 0x8c, 0x5, 0xd1, 0xba, 0x2a, 0x64, 0xf8, 0x83, 0xd3, 0x7e, 0xa1, 0x85, 0x5, 0xa0, 0xf5, 0x74, 0x5a, 0x2d, 0xda, 0x21, 0x7e, 0xab, 0x17, 0x74, 0xa9, 0xd8, 0x13, 0xb8, 0x38, 0x7e, 0xa1, 0x6c, 0x48, 0xec, 0x8e, 0x56, 0x0, 0xc1, 0x6d, 0x98, 0xfd, 0x4b, 0xa0, 0xa1, 0xef, 0x28, 0x88, 0xfd, 0xfc, 0xef, 0x53, 0x65, 0x40, 0x10, 0x4, 0xb0, 0x2c, 0xf7, 0x4, 0x62, 0x32, 0x77, 0xce, 0x50, 0x2a, 0x54, 0xe4, 0xe0, 0x3d, 0x91, 0x91, 0x4b, 0xa8, 0x29, 0xc5, 0x67, 0x40, 0xf7, 0x77, 0xa5, 0xc2, 0x8f, 0xbd, 0x45, 0xea, 0xc5, 0x71, 0xdd, 0xa7, 0xb8, 0x9e, 0xc7, 0xfc, 0x98, 0x2f, 0x65, 0xe5, 0xcb, 0x38, 0x24, 0x15, 0x44, 0x1, 0x62, 0x9, 0x1c, 0x2f, 0x4, 0x1f, 0xc0, 0xf9, 0x7f, 0x20, 0x69, 0x33, 0x5, 0xc2, 0x5d, 0xe7, 0x83, 0x7a, 0x2f, 0x65, 0x5, 0x77, 0xac, 0x6c, 0xbf, 0xfc, 0x9, 0xf1, 0xf6, 0x95, 0x41, 0x7c, 0xd5, 0xec, 0xc5, 0x55, 0x69, 0x76, 0x93, 0xb1, 0x21, 0x66, 0xcd, 0xa4, 0x7b, 0x8a, 0x74, 0x5f, 0x48, 0x94, 0x6, 0x94, 0x2c, 0x59, 0x9a, 0xf5, 0xf0, 0x85, 0x30, 0x6e, 0xfa, 0xa5, 0x8, 0xb5, 0xbf, 0xa, 0x40, 0x62, 0x69, 0xf6, 0x0, 0xb6, 0x8b, 0x58, 0xce, 0x3e, 0x20, 0x4c, 0x3b, 0xea, 0x59, 0xe4, 0xf3, 0xc1, 0x91, 0x57, 0xc6, 0x2, 0x46, 0xed, 0xf1, 0x81, 0x41, 0x59, 0x7b, 0xc0, 0xcf, 0xff, 0x83, 0x8, 0x87, 0x8e, 0x4f, 0x36, 0xe4, 0xc4, 0x43, 0xba, 0x87, 0x4b, 0xe5, 0x82, 0x78, 0xfd, 0x5b, 0x33, 0x2c, 0xa7, 0x3c, 0xba, 0xba, 0x2a, 0x30, 0x25, 0x79, 0xe5, 0xdf, 0x86, 0x3d, 0xb9, 0x22, 0x51, 0xc5, 0x97, 0xcd, 0x45, 0xf8, 0x36, 0xd0, 0xb9, 0xd3, 0xad, 0xd5, 0x9e, 0xf9, 0x24, 0x68, 0x54, 0x2b, 0x37, 0x7e, 0x32, 0x50, 0xfb, 0xad, 0xe0, 0x83, 0x39, 0x14, 0x6, 0x6a, 0x39, 0x56, 0x60, 0x9, 0x50, 0x7d, 0x4c, 0x3d, 0x57, 0x58, 0x51, 0x22, 0x4e, 0x86, 0x4, 0x29, 0xf6, 0x17, 0xac, 0x7e, 0xbe, 0xbd, 0xf5, 0x34, 0xde, 0xa8, 0xf3, 0xac, 0x3f, 0x7a, 0x14, 0xf8, 0x15, 0x75, 0x1c, 0x8e, 0x72, 0xe9, 0x7, 0xf9, 0x7, 0x7b, 0x54, 0xaa, 0xc6, 0x45, 0xb4, 0xbd, 0xad, 0xbf, 0xd9, 0x69, 0xab, 0x38, 0x31, 0x2c, 0xba, 0x88, 0x8f, 0x5, 0x68, 0x17, 0xc, 0x2, 0xf3, 0x6a, 0x4c, 0x5f, 0x0, 0x55, 0xe6, 0x70, 0x2f, 0x39, 0xd6, 0x2b, 0x23, 0x83, 0x83, 0x5a, 0x71, 0x9a, 0x60, 0xe3, 0xa6, 0x5, 0x5d, 0xf5, 0x50, 0xb3, 0x59, 0x3, 0x41, 0xb6, 0x67, 0x70, 0x89, 0x7b, 0xcc, 0x66, 0xf8, 0xa5, 0x20, 0x16, 0xf1, 0x49, 0x19, 0x73, 0xd5, 0x65, 0xee, 0xd5, 0xd1, 0xc7, 0x18, 0xca, 0x89, 0x97, 0xc8, 0xa6, 0x4d, 0x46, 0x71, 0x70, 0x60, 0x89, 0x91, 0xd1, 0x4f, 0x1e, 0x50, 0xa8, 0xfc, 0x63, 0xc4, 0xa3, 0xb4, 0x64, 0xd0, 0x8d, 0x5, 0xf7, 0x2e, 0x9c, 0xeb, 0x8a, 0xc6, 0x9b, 0x5f, 0x88, 0x9e, 0xe1, 0x6f, 0x99, 0x45, 0x4b, 0xb5, 0xf8, 0x22, 0xf1, 0x53, 0xc9, 0xd9, 0xdc, 0xf4, 0xf0, 0xbb, 0xbe, 0xb5, 0x10, 0xd7, 0x6, 0xf2, 0xc7, 0xce, 0x5e, 0x51, 0x6e, 0x1a, 0xf5, 0xcb, 0xb8, 0x38, 0xc9, 0x5d, 0x97, 0x3b, 0x34, 0x23, 0x3, 0x79, 0xcc, 0x30, 0x29, 0x9d, 0xa5, 0x85, 0xbd, 0xd8, 0xad, 0x8b, 0xdd, 0x43, 0xea, 0x6a, 0xd8, 0xaa, 0x8f, 0x44, 0x47, 0xed, 0x4f, 0x41, 0x1e, 0x4a, 0x3c, 0xe2, 0x5c, 0x4b, 0x33, 0x88, 0x82, 0xc6, 0xdd, 0xda, 0x40, 0xa8, 0xc2, 0x22, 0x84, 0x91, 0xcb, 0x6c, 0xb3, 0x3a, 0x5a, 0xe7, 0x3, 0xd2, 0x98, 0x65, 0xa1, 0x51, 0xbe, 0xbb, 0xfc, 0x59, 0x10, 0xb6, 0x44, 0x1b, 0x10, 0xcf, 0x64, 0xc1, 0x89, 0xa7, 0x19, 0x11, 0x67, 0x7c, 0x10, 0xf1, 0x1d, 0xec, 0xba, 0x96, 0xa4, 0x20, 0xde, 0xe, 0xf9, 0xc1, 0x24, 0xf3, 0x6f, 0xc5, 0xd2, 0x7f, 0xdd, 0x75, 0xc3, 0x88, 0x53, 0x3c, 0x88, 0x66, 0x73, 0x47, 0xb5, 0x27, 0x7c, 0x2e, 0x1f, 0xc0, 0x2, 0x6b, 0x75, 0xe3, 0x8e, 0x6e, 0x46, 0xac, 0xec, 0xb2, 0xba, 0x8e, 0xfa, 0xdb, 0xaf, 0x14, 0x89, 0xcf, 0x45, 0xf4, 0xa9, 0x22, 0x56, 0x91, 0x49, 0x2b, 0xc6, 0x37, 0x85, 0x96, 0x6c, 0x1, 0x8a, 0x8f, 0xbe, 0xfe, 0x58, 0xc5, 0x53, 0x3e, 0x2b, 0xf2, 0xc6, 0x1, 0xa0, 0xa5, 0xef, 0x8, 0xcb, 0xf1, 0xb1, 0x15, 0xbf, 0x34, 0x52, 0xc9, 0x49, 0x53, 0xac, 0xb7, 0x29, 0x4f, 0xf0, 0x9c, 0x7f, 0xce, 0x12, 0xf8, 0xcb, 0x86, 0x33, 0x3a, 0xd7, 0xee, 0xa5, 0x14, 0xae, 0x12, 0x33, 0x35, 0x58, 0xf2, 0x55, 0xf5, 0xd7, 0x3, 0x9a, 0xf7, 0x7d, 0x72, 0x4f, 0x66, 0xc9, 0x62, 0x19, 0x25, 0x9, 0xc5, 0xb5, 0xe0, 0x7c, 0xa8, 0x16, 0x1d, 0x60, 0x2, 0x41, 0x7b, 0x79, 0x3f, 0x25, 0xb9, 0x25, 0x32, 0xc6, 0x1d, 0x67, 0xca, 0x6c, 0xe4, 0xe1, 0x71, 0x8b, 0x41, 0x4a, 0x86, 0xb2, 0x37, 0xfc, 0xf0, 0x19, 0x9d, 0x7e, 0x56, 0xc, 0x21, 0x36, 0xaf, 0xb2, 0x90, 0x71, 0x1b, 0x3e, 0x2b, 0x8d, 0x40, 0x3e, 0xe0, 0x53, 0x7c, 0x35, 0x19, 0x72, 0xe8, 0x65, 0x51, 0xe5, 0xeb, 0x9a, 0x35, 0x35, 0xd7, 0xd6, 0x2, 0xe5, 0xc4, 0x44, 0x21, 0x9b, 0x3b, 0x3d, 0x63, 0x41, 0x25, 0x92, 0x39, 0x9a, 0x7e, 0xe9, 0x1b, 0xf3, 0xbf, 0xc2, 0x6f, 0x5a, 0x3a, 0x91, 0xbf, 0xe9, 0xef, 0x9a, 0x87, 0x5c, 0xca, 0x8c, 0x6c, 0xde, 0x2f, 0xcc, 0x7c, 0xdd, 0xc9, 0x71, 0x89, 0x7e, 0x55, 0x9b, 0xa5, 0x67, 0x61, 0x59, 0x9c, 0x5f, 0x88, 0x3a, 0x7c, 0x2a, 0xa2, 0xe4, 0xcc, 0xb7, 0x53, 0xc6, 0x59, 0x67, 0x8d, 0x16, 0xd1, 0x58, 0xef, 0x12, 0xaf, 0x98, 0x72, 0x60, 0xfe, 0x98, 0x8, 0x7c, 0x23, 0x77, 0x3a, 0xe2, 0xf, 0x81, 0xfd, 0x59, 0xe, 0x1c, 0xf7, 0x38, 0xd3, 0xc0, 0x4b, 0x9, 0x55, 0xf2, 0xb2, 0xb, 0x30, 0xf5, 0x43, 0x81, 0xc1, 0x6, 0x11, 0x5d, 0x4e, 0xd8, 0x3f, 0xc7, 0xf6, 0xbe, 0x6d, 0x14, 0x3b, 0x61, 0xc2, 0xd5, 0x89, 0xa3, 0x17, 0xe9, 0x8e, 0x18, 0x33, 0x61, 0x50, 0xb3, 0x35, 0xc, 0xe0, 0xe1, 0x6e, 0x82, 0x14, 0xda, 0x55, 0x47, 0x68, 0x87, 0xda, 0x6f, 0xc6, 0x4d, 0x61, 0xba, 0x49, 0x42, 0x5d, 0xa1, 0xc1, 0x56, 0xdb, 0x5e, 0xca, 0x1, 0x41, 0x1f, 0xa0, 0x62, 0x18, 0x3d, 0xd2, 0x9f, 0xa1, 0xce, 0xd4, 0x91, 0xe5, 0xe1, 0xe2, 0xe3, 0xce, 0x16, 0xa, 0x8e, 0x9e, 0x4f, 0xf1, 0x0, 0xb, 0xaf, 0x63, 0x2a, 0x92, 0xd8, 0xe9, 0x72, 0x7, 0x7c, 0x23, 0xc6, 0x66, 0x81, 0x3, 0x39, 0xe9, 0xd9, 0xb5, 0xf6, 0x2f, 0xda, 0x5b, 0xcd, 0xc4, 0x5d, 0x31, 0x5b, 0xf8, 0xdb, 0x41, 0xb8, 0x1a, 0xa1, 0x65, 0x76, 0x37, 0x80, 0xbe, 0xcb, 0x54, 0x4f, 0x27, 0x7b, 0xf1, 0x4, 0x91, 0xcd, 0x8, 0x5a, 0x8f, 0x5a, 0xd9, 0x1e, 0xb6, 0xdc, 0xe7, 0x93, 0xf4, 0x80, 0xa2, 0x7c, 0x44, 0x8a, 0xc8, 0xdb, 0x95, 0x73, 0x8e, 0x36, 0xad, 0xf, 0x15, 0xfa, 0xe2, 0x3a, 0x98, 0xf7, 0x3e, 0x1b, 0xd9, 0x6a, 0x6d, 0xfa, 0x6b, 0x1a, 0x4d, 0xf4, 0xd3, 0x44, 0x41, 0xd9, 0x73, 0xaf, 0x7e, 0x19, 0x94, 0xc0, 0x67, 0x63, 0xbb, 0xab, 0x81, 0xac, 0x19, 0xb0, 0xbe, 0x9e, 0xc8, 0x56, 0x36, 0x5d, 0xe6, 0x72, 0x18, 0x40, 0xb2, 0xa4, 0x80, 0xf, 0x27, 0xe3, 0x2d, 0x90, 0x46, 0xfc, 0x67, 0xb7, 0xf4, 0x43, 0xa8, 0x8c, 0x3b, 0xae, 0x70, 0x13, 0x83, 0x5, 0xe9, 0xf1, 0x62, 0xdb, 0xa6, 0x21, 0x9e, 0x6f, 0x8f, 0xd6, 0x84, 0x94, 0xfe, 0x64, 0x4b, 0xf6, 0xf1, 0x98, 0xd1, 0xb3, 0xa9, 0x34, 0x41, 0x6e, 0x96, 0xac, 0x21, 0x9c, 0x72, 0xea, 0x95, 0x64, 0x8b, 0x1d, 0x96, 0x77, 0xc7, 0xdb, 0xa1, 0xe3, 0xcc, 0x6e, 0x6b, 0x1, 0x19, 0x8e, 0xa8, 0x5a, 0x6f, 0xa3, 0xdb, 0xe6, 0x8f, 0xfd, 0x5b, 0x93, 0x67, 0x47, 0xbf, 0x86, 0x25, 0x36, 0x22, 0xbf, 0x6, 0x56, 0xc4, 0x17, 0x8e, 0x9b, 0x25, 0x9f, 0x1, 0xfb, 0xfb, 0xef, 0x7d, 0xbb, 0x6f, 0x45, 0xea, 0x2d, 0x1, 0xcf, 0x4a, 0xd0, 0x75, 0x71, 0x84, 0x40, 0xc0, 0xd, 0xc6, 0x63, 0x21, 0xb3, 0x11, 0xf3, 0x99, 0x43, 0x60, 0x64, 0xe7, 0xf5, 0x6d, 0x25, 0x4b, 0xaa, 0xe8, 0x5a, 0x31, 0x99, 0xc3, 0x13, 0x57, 0xb7, 0xe, 0x81, 0x18, 0xd, 0x1b, 0xed, 0xe7, 0xfc, 0xe1, 0x28, 0xd2, 0xaa, 0x7f, 0xe5, 0xc5, 0x9, 0x5a, 0x5, 0x31, 0x4b, 0x5, 0x62, 0x5, 0xe7, 0x19, 0xf1, 0x3c, 0x73, 0x8f, 0xc4, 0x43, 0xf9, 0x4d, 0xd3, 0xdd, 0x8b, 0xf2, 0x8a, 0x80, 0x24, 0x49, 0x1d, 0x36, 0x25, 0x79, 0x4c, 0xef, 0x85, 0xb2, 0xc2, 0xc8, 0x10, 0x20, 0x8a, 0x85, 0x57, 0xb0, 0x4f, 0x51, 0x7c, 0x42, 0xef, 0xd9, 0x50, 0x2a, 0x1b, 0x4d, 0xe4, 0x12, 0xb4, 0x7c, 0x53, 0xe, 0xe6, 0xf0, 0x5, 0x6b, 0x5e, 0xac, 0x5b, 0xe8, 0x7a, 0xe7, 0x44, 0x2a, 0xa8, 0x4f, 0x30, 0xad, 0x9b, 0x6c, 0x50, 0xd8, 0x51, 0x86, 0x32, 0xbd, 0x45, 0x12, 0x78, 0x3b, 0xd3, 0xfb, 0x35, 0x8b, 0x9c, 0xbe, 0xe1, 0xec, 0xd5, 0xd6, 0x34, 0xd6, 0x17, 0xa5, 0x7b, 0xa8, 0xac, 0x2d, 0x8f, 0x12, 0xc9, 0x9c, 0x1a, 0x14, 0x6d, 0x6f, 0xcb, 0x99, 0x1, 0xf4, 0x6c, 0x5, 0xfd, 0xb5, 0xbc, 0x3d, 0xdb, 0x7d, 0x8c, 0xd, 0x69, 0x4b, 0x5e, 0x4, 0x32, 0xe2, 0x9a, 0x2b, 0xb3, 0xbd, 0xa7, 0xd, 0x39, 0x77, 0xd7, 0x96, 0x70, 0x82, 0x6, 0x9a, 0xa3, 0x6f, 0x42, 0x5c, 0x60, 0xd3, 0xed, 0xa2, 0x92, 0x2f, 0xd4, 0x1d, 0xdb, 0x7d, 0x1f, 0xa2, 0xce, 0x76, 0x25, 0x6e, 0x3e, 0xc5, 0x3a, 0x55, 0x75, 0xde, 0xb, 0x9, 0x19, 0xbb, 0x71, 0x9c, 0xd7, 0x38, 0x84, 0xf0, 0x52, 0xa3, 0x5f, 0xda, 0x47, 0x86, 0x1c, 0x13, 0xbb, 0x52, 0x35, 0x9, 0xbf, 0x91, 0x23, 0x3a, 0xcf, 0xb8, 0x2c, 0x67, 0x4b, 0xc4, 0x6f, 0xb5, 0xaa, 0xba, 0x97, 0xe, 0x29, 0xea, 0x48, 0xaf, 0x84, 0xfe, 0xae, 0xe9, 0xaa, 0xc0, 0xcd, 0xe8, 0xad, 0xf, 0xf2, 0xb3, 0x8a, 0xa3, 0x78, 0x96, 0x3d, 0x62, 0x21, 0x7b, 0x8c, 0x7, 0x9b, 0xee, 0x27, 0x98, 0x5b, 0x72, 0x5e, 0xc8, 0x32, 0x7f, 0x8a, 0x49, 0x6c, 0xbc, 0xa3, 0xeb, 0xc7, 0x63, 0x79, 0x3c, 0xdd, 0xa9, 0xc5, 0xc8, 0x4b, 0x42, 0x67, 0x8a, 0xa, 0xa6, 0xb9, 0xba, 0xa0, 0x3a, 0x5c, 0xbd, 0x7e, 0x2f, 0x73, 0x3e, 0x95, 0x6d, 0xd9, 0xb5, 0x71, 0x23, 0x17, 0x6, 0x8e, 0xa3, 0x69, 0xd7, 0x82, 0x1e, 0x3c, 0x28, 0x8c, 0x1, 0x91, 0x10, 0xc0, 0xeb, 0x79, 0x2e, 0xf4, 0xfe, 0x7b, 0xde, 0x19, 0x9e, 0xf1, 0xc, 0x97, 0x31, 0x38, 0xaf, 0x40, 0xfa, 0x52, 0xfb, 0x35, 0xdf, 0xfa, 0x93, 0x9e, 0x3d, 0x84, 0x3a, 0xda, 0x77, 0x50, 0x89, 0x69, 0x17, 0x77, 0x21, 0x1, 0xe4, 0x90, 0x76, 0x81, 0x2e, 0x62, 0x3f, 0x8f, 0xe4, 0x35, 0x45, 0x2c, 0xc3, 0x9c, 0xfc, 0x3c, 0x6b, 0xd3, 0x66, 0x5b, 0xb7, 0xe2, 0xf, 0xd0, 0x9e, 0x28, 0xc0, 0x8d, 0x9d, 0x29, 0xcd, 0xb7, 0xa4, 0xc5, 0xf7, 0x30, 0x2a, 0xcf, 0xb6, 0x3a, 0x56, 0xbd, 0x48, 0x1f, 0x53, 0x5a, 0x13, 0x61, 0x82, 0x57, 0x7e, 0xa, 0xf1, 0x43, 0x6c, 0x5, 0xe, 0xa3, 0x76, 0xb3, 0x35, 0xda, 0x9c, 0xf9, 0x60, 0x4, 0x2a, 0x11, 0x58, 0xfa, 0x84, 0x2a, 0x85, 0xdc, 0xc9, 0x23, 0xbb, 0x7e, 0xe9, 0x60, 0x16, 0x86, 0xc, 0x22, 0x31, 0xa1, 0xf0, 0xd8, 0x59, 0x27, 0x58, 0x1, 0x95, 0x8c, 0xeb, 0xdb, 0x37, 0x4c, 0xc1, 0xbc, 0xee, 0x20, 0x69, 0xae, 0x9a, 0x2e, 0x97, 0x3, 0x91, 0x17, 0x2a, 0xb7, 0xbb, 0x9d, 0x39, 0xd9, 0x91, 0xf6, 0x8c, 0x2e, 0x8, 0x7a, 0x7, 0x73, 0x38, 0x7b, 0x62, 0xa6, 0x8, 0x64, 0x1e, 0xc5, 0x4a, 0x7e, 0x89, 0x76, 0xb7, 0xa9, 0xad, 0x1f, 0xa9, 0x90, 0x4b, 0xb3, 0xfa, 0x98, 0xfb, 0xb3, 0x32, 0xd1, 0x4b, 0x6b, 0x23, 0xa8, 0x2f, 0x4f, 0xfa, 0x69, 0xa8, 0xdb, 0xee, 0xb4, 0x73, 0x3b, 0x7e, 0x69, 0x43, 0xb, 0xf6, 0xb1, 0xec, 0x5c, 0x8e, 0x5b, 0xd, 0x78, 0x1, 0xb4, 0xc7, 0x45, 0xd9, 0x2d, 0xfe, 0x7, 0x12, 0x24, 0xc7, 0xda, 0x68, 0x7a, 0x7e, 0x19, 0x91, 0xb0, 0x38, 0x67, 0xe8, 0x2e, 0x7f, 0x3d, 0x3d, 0xcc, 0x2c, 0x63, 0xad, 0x5e, 0xe9, 0xcf, 0xc2, 0x4, 0x51, 0xbe, 0xc8, 0x62, 0xd4, 0x21, 0xe0, 0x3b, 0x11, 0x19, 0x5b, 0xca, 0xf0, 0x1e, 0xc4, 0x42, 0x86, 0x91, 0xcd, 0xe6, 0x61, 0x8d, 0xb6, 0x3a, 0xe7, 0x3c, 0x8, 0x18, 0x13, 0x4, 0xd4, 0xb0, 0x65, 0x61, 0x38, 0x31, 0x76, 0x66, 0x4d, 0x20, 0x5, 0x2b, 0xd5, 0xb7, 0x37, 0x3a, 0x7e, 0xc5, 0x3d, 0x1a, 0x4f, 0xcd, 0x63, 0xd7, 0x39, 0xd, 0x0, 0xd2, 0x21, 0x7c, 0xfd, 0xe4, 0x99, 0x3, 0x6e, 0x6e, 0xa3, 0x89, 0xdb, 0xac, 0x12, 0xd0, 0x8f, 0x40, 0xd6, 0x32, 0x2a, 0x26, 0xc5, 0x68, 0x1f, 0xf0, 0xc1, 0xf9, 0xb6, 0x38, 0xcc, 0x8, 0xce, 0xd6, 0x15, 0x24, 0xec, 0x48, 0xa8, 0xe8, 0xbf, 0x93, 0xd2, 0x2, 0x8d, 0xc1, 0xf, 0xfe, 0x6, 0x3c, 0xb8, 0x7, 0xc9, 0x4c, 0xad, 0x3c, 0x2b, 0x69, 0x4e, 0xd9, 0x74, 0x73, 0x85, 0xef, 0x59, 0x34, 0xf4, 0xc8, 0x4f, 0x90, 0x7a, 0xf7, 0x99, 0x9e, 0x47, 0x6c, 0x27, 0x35, 0xe1, 0x31, 0x8a, 0xad, 0x6e, 0xbb, 0x79, 0x47, 0xd9, 0xa6, 0x4b, 0x2f, 0x62, 0x5e, 0x2d, 0xab, 0x7e, 0x77, 0xb6, 0xfd, 0xbf},
+               output224: []byte{0x3b, 0xe8, 0x19, 0x8d, 0x48, 0x41, 0xd5, 0x7b, 0x66, 0x75, 0x57, 0x18, 0x50, 0x54, 0x36, 0x35, 0xdd, 0x9f, 0x22, 0x88, 0x2d, 0x49, 0x32, 0x8b, 0x75, 0x55, 0x98, 0xd9},
+               output256: []byte{0x94, 0x71, 0x60, 0x79, 0x46, 0x3, 0x1a, 0x2e, 0x58, 0x9d, 0xdf, 0x6f, 0x7a, 0xe6, 0x89, 0x6c, 0xd9, 0x4e, 0x7d, 0xf, 0x86, 0x30, 0x6e, 0xd, 0x1a, 0x75, 0x77, 0x45, 0x13, 0xac, 0x95, 0x53},
+               output384: []byte{0xa4, 0x1a, 0xa8, 0xf9, 0x43, 0x11, 0x7d, 0xe4, 0x1b, 0x2f, 0xa4, 0x24, 0x5b, 0xc9, 0x75, 0x8d, 0x67, 0x2f, 0x5d, 0xf, 0xec, 0xf4, 0x32, 0xac, 0x44, 0x63, 0x5b, 0xff, 0x2a, 0x46, 0xd3, 0x8f, 0x16, 0x8e, 0x23, 0x1e, 0xad, 0xef, 0x2c, 0x77, 0xd3, 0x44, 0x1f, 0x1d, 0x36, 0xd2, 0xb2, 0x2a},
+               output512: []byte{0x8, 0xcd, 0x2e, 0xca, 0xa8, 0x95, 0xc0, 0xe2, 0xb3, 0x19, 0x94, 0xdc, 0xaa, 0xe2, 0xc1, 0xf7, 0x6b, 0x2, 0xe7, 0x61, 0xfb, 0x5f, 0x92, 0x94, 0x49, 0xac, 0x32, 0xa4, 0x77, 0xcc, 0x16, 0x7a, 0xb1, 0xd4, 0xe2, 0x38, 0x43, 0xc3, 0xbd, 0x1, 0xf7, 0xd, 0x83, 0x1c, 0x4a, 0x77, 0xc5, 0xb7, 0xcc, 0x90, 0x12, 0x31, 0x8a, 0xd8, 0x7c, 0x65, 0x51, 0xa5, 0xb6, 0xaa, 0x5b, 0xfd, 0xf8, 0x6f}},
+       testcase{
+               msg:       []byte{0x69, 0x64, 0xe2, 0xd6, 0x50, 0xb1, 0x9a, 0xa6, 0xd3, 0x1b, 0x83, 0x9c, 0x60, 0x4a, 0x90, 0xaa, 0x3d, 0x10, 0x58, 0x34, 0xf3, 0x85, 0x4d, 0xf4, 0xa4, 0x1d, 0x47, 0x87, 0xa3, 0x87, 0x4, 0x2c, 0xc4, 0x13, 0xde, 0x27, 0x50, 0x3a, 0x1e, 0xfc, 0x36, 0x6b, 0x87, 0xed, 0x67, 0x7e, 0xa6, 0x3d, 0xcc, 0xd4, 0xd, 0x9c, 0x7f, 0x69, 0x9f, 0xff, 0x9b, 0x8a, 0x42, 0xb5, 0x96, 0x17, 0x30, 0x14, 0xb9, 0xe8, 0x11, 0xd4, 0x2d, 0x2d, 0xe5, 0x74, 0xed, 0x5c, 0x80, 0xfc, 0x6a, 0x5a, 0x86, 0xb7, 0x72, 0xa3, 0xee, 0xbe, 0x56, 0x40, 0x10, 0x25, 0x27, 0x40, 0x1c, 0xe, 0x9b, 0xef, 0x57, 0xe0, 0x5b, 0xbf, 0x6, 0x98, 0x65, 0x35, 0xd3, 0x16, 0x37, 0x88, 0xc6, 0xc, 0x92, 0xec, 0x74, 0x60, 0xb7, 0xfc, 0x68, 0x5f, 0xb4, 0x5f, 0xb8, 0xa1, 0x8f, 0xa8, 0x4e, 0xf5, 0xa3, 0x7c, 0x94, 0xa2, 0xec, 0x3a, 0x94, 0x8d, 0xca, 0xfc, 0x69, 0xb8, 0x3e, 0x24, 0x34, 0xab, 0xcf, 0xda, 0xfc, 0xe9, 0x48, 0xd8, 0xc7, 0x6e, 0xd9, 0xba, 0x78, 0xd, 0x39, 0xac, 0x3d, 0xd0, 0x98, 0xeb, 0xb3, 0x20, 0x85, 0x38, 0xa6, 0x66, 0xce, 0xd8, 0xac, 0xf1, 0xb3, 0x3, 0x1c, 0x5e, 0xf2, 0x35, 0x92, 0xfc, 0x43, 0x2a, 0xc2, 0x5b, 0xe0, 0x55, 0x2c, 0x1a, 0x64, 0x63, 0xe3, 0xcc, 0x77, 0x8d, 0x45, 0x6a, 0x52, 0x4, 0x32, 0xa8, 0xc5, 0x54, 0x36, 0x57, 0x32, 0x19, 0xc4, 0x9e, 0x6b, 0xc2, 0x74, 0x74, 0xaa, 0x4b, 0xd9, 0xb1, 0xb3, 0xbc, 0x64, 0x91, 0x7d, 0x1, 0x6b, 0x65, 0x80, 0xae, 0xf2, 0xa0, 0xba, 0x41, 0xac, 0xfb, 0x98, 0xea, 0x86, 0x9d, 0x39, 0x95, 0x1, 0x27, 0x15, 0xd0, 0x6d, 0x64, 0xe0, 0xaa, 0xef, 0xb2, 0x62, 0x71, 0x25, 0xf2, 0x25, 0xe2, 0xef, 0xea, 0x21, 0xaf, 0x7e, 0xc4, 0x93, 0x4, 0xb8, 0xe6, 0x39, 0x96, 0x23, 0xfa, 0xc1, 0x5d, 0x6c, 0xdf, 0x39, 0xc4, 0x17, 0x7a, 0x12, 0x25, 0x4e, 0x5d, 0x80, 0x7b, 0x4a, 0xae, 0xce, 0xd6, 0xd5, 0x91, 0xf4, 0xd0, 0xbf, 0x50, 0xc0, 0x7f, 0x5b, 0x69, 0xe7, 0xd6, 0x0, 0x55, 0x6, 0x26, 0x54, 0xe7, 0xb1, 0xc8, 0xb9, 0x6a, 0xf7, 0x26, 0xbc, 0xb3, 0x4b, 0x10, 0xc6, 0xb, 0x7f, 0xc3, 0xb1, 0xd, 0xbc, 0x69, 0x10, 0x7c, 0x7d, 0x81, 0x4, 0x3b, 0xca, 0xa6, 0x81, 0xeb, 0x35, 0x4c, 0xf1, 0x9a, 0xf2, 0x6a, 0xe3, 0xc7, 0xcb, 0x32, 0x1b, 0x89, 0x2c, 0x33, 0xcd, 0x4, 0x4a, 0x24, 0xa5, 0x24, 0x9f, 0x2f, 0x2e, 0xa3, 0xf8, 0x4, 0x94, 0x4b, 0x50, 0x49, 0xca, 0x88, 0x7e, 0xaa, 0x6d, 0x4c, 0xd5, 0xe5, 0x2d, 0x17, 0xcf, 0x1, 0xcb, 0xf, 0xce, 0xcd, 0xa4, 0x74, 0x25, 0xec, 0x85, 0xf8, 0x36, 0x2a, 0xe0, 0x45, 0xed, 0xd, 0x10, 0x97, 0x58, 0xc9, 0x1, 0x34, 0xea, 0x27, 0xc4, 0xcb, 0xf6, 0xe3, 0xab, 0xe7, 0xf2, 0x83, 0xf4, 0xc3, 0xff, 0xc4, 0x45, 0x5e, 0xae, 0x47, 0x90, 0x32, 0x9a, 0xe4, 0x76, 0x58, 0xdb, 0x28, 0x50, 0xb0, 0x9a, 0x79, 0xa8, 0x9b, 0xdb, 0xf7, 0x2a, 0x20, 0xdc, 0x88, 0x7b, 0x6a, 0xd7, 0xad, 0xec, 0xbd, 0x5a, 0x86, 0xc0, 0x84, 0x79, 0xd4, 0x46, 0xef, 0x81, 0x7e, 0x13, 0xa3, 0x78, 0x19, 0xc2, 0x27, 0x79, 0x2e, 0x3e, 0xf, 0xf8, 0xa, 0x28, 0x31, 0xb2, 0x7, 0x60, 0xb8, 0x79, 0xa4, 0x89, 0xa4, 0xae, 0x50, 0xaf, 0xf9, 0xfb, 0x1d, 0xff, 0x39, 0x13, 0x2d, 0xd8, 0x43, 0x0, 0xef, 0x7a, 0xbe, 0x5, 0xe9, 0x8c, 0x59, 0x29, 0x68, 0x3a, 0x2d, 0xdf, 0xea, 0x99, 0x46, 0x89, 0x96, 0xd6, 0x52, 0xdc, 0xcc, 0x69, 0x81, 0x83, 0xf9, 0xa3, 0x10, 0x3f, 0x7c, 0x4, 0x9a, 0x72, 0x27, 0x73, 0x3d, 0xc, 0x14, 0xed, 0x1b, 0xb8, 0x9, 0xb4, 0xef, 0x75, 0xd, 0xf1, 0x90, 0x94, 0x88, 0x59, 0x61, 0xd3, 0x27, 0x39, 0x4d, 0x6c, 0xfa, 0xa, 0x21, 0xb3, 0x41, 0x68, 0x17, 0x38, 0xb7, 0xe6, 0xfe, 0xef, 0xcb, 0xf4, 0xdd, 0x47, 0x4b, 0x7b, 0x45, 0xea, 0x64, 0xa3, 0xa6, 0xb, 0x97, 0xbf, 0xf2, 0x97, 0xe8, 0xa5, 0x2c, 0xd4, 0xaa, 0x6e, 0x92, 0xd6, 0xdb, 0xb7, 0xfe, 0xf7, 0xf7, 0x36, 0xd2, 0x9c, 0xe3, 0xb0, 0x41, 0x48, 0x8a, 0x6d, 0xb6, 0x8d, 0x28, 0xf3, 0xc0, 0x20, 0x4c, 0xff, 0xf8, 0x2c, 0xe6, 0xea, 0xd1, 0x1e, 0x11, 0xd7, 0xb0, 0x60, 0xa0, 0xff, 0x55, 0x7, 0x11, 0xbe, 0x33, 0x28, 0x8a, 0xcc, 0x63, 0xb6, 0xdc, 0xf2, 0x6, 0x22, 0x51, 0x77, 0x15, 0x44, 0xad, 0x41, 0xb3, 0x5b, 0x1e, 0xa5, 0xf1, 0x1c, 0x4b, 0x19, 0x6c, 0x48, 0xf5, 0xfb, 0xfc, 0xb4, 0xb3, 0x9c, 0x60, 0x4, 0x4a, 0x70, 0xe1, 0xdb, 0xb2, 0xcf, 0xbf, 0x9d, 0x8f, 0xcc, 0x85, 0x5d, 0xec, 0x9a, 0xb, 0x33, 0xf2, 0x2, 0x1c, 0xc7, 0x6b, 0x23, 0x6a, 0xde, 0xb5, 0xa1, 0x35, 0x6c, 0xfb, 0x85, 0x90, 0xfc, 0x1d, 0xdf, 0x8a, 0x72, 0x1d, 0x93, 0x31, 0x86, 0x1d, 0xb6, 0x4, 0xad, 0xc, 0x8c, 0x89, 0x87, 0x1e, 0x96, 0x0, 0x19, 0xa0, 0xda, 0xba, 0x43, 0x20, 0x2a, 0xdd, 0xd5, 0x26, 0xc1, 0x70, 0x6e, 0x78, 0x2f, 0xac, 0x5f, 0x98, 0x29, 0x5f, 0x4c, 0x60, 0x36, 0xb8, 0xe2, 0xdf, 0x6d, 0x22, 0x5b, 0x63, 0x35, 0xd1, 0x31, 0x41, 0x43, 0x57, 0x3a, 0xb8, 0xe6, 0x6a, 0x77, 0x50, 0xbd, 0xb6, 0x42, 0x4, 0x52, 0xfa, 0x6, 0xb, 0x24, 0xfb, 0xbc, 0x36, 0x18, 0xd9, 0x51, 0x49, 0x5, 0x34, 0x71, 0x8d, 0x97, 0xe3, 0xae, 0x99, 0x4d, 0x5e, 0x77, 0xd, 0x10, 0x3e, 0x1f, 0x40, 0x5a, 0x53, 0x57, 0xa2, 0x52, 0x1e, 0x93, 0x93, 0xed, 0x2e, 0xd1, 0x97, 0xe7, 0xaa, 0xc8, 0x7e, 0x14, 0x22, 0x5, 0xc6, 0x9d, 0xbe, 0xe8, 0x46, 0x3, 0x4f, 0xe6, 0xf2, 0x16, 0x8d, 0xc2, 0x7, 0xd1, 0x30, 0x22, 0xe1, 0x14, 0x27, 0xe8, 0xf0, 0x20, 0x87, 0xd2, 0xf4, 0xe8, 0x50, 0xe7, 0xfd, 0x21, 0x23, 0x7d, 0x56, 0xbe, 0x97, 0x7, 0x81, 0xcd, 0x77, 0x9f, 0x7b, 0xd, 0x8e, 0x9f, 0x68, 0x9e, 0x6c, 0xad, 0xa3, 0x38, 0x6b, 0x5e, 0x77, 0x9e, 0x38, 0x2a, 0xe3, 0xde, 0xb6, 0xcb, 0x20, 0xdb, 0xa1, 0x6a, 0x94, 0xd1, 0x47, 0x10, 0x1f, 0xe5, 0x94, 0x79, 0xa, 0x5b, 0x33, 0x1d, 0x40, 0x55, 0x1c, 0x8c, 0x1d, 0x81, 0x5, 0x2c, 0xe0, 0x6, 0x42, 0xf5, 0x6e, 0x40, 0x48, 0xf6, 0x83, 0x1d, 0x71, 0x3e, 0x74, 0xe3, 0xf4, 0xc6, 0xed, 0x23, 0x52, 0x85, 0x48, 0x54, 0xe3, 0x5c, 0x6, 0x31, 0x3f, 0x1, 0x4, 0xfa, 0x47, 0xee, 0xb2, 0x82, 0xaf, 0xf9, 0xa3, 0xed, 0x3d, 0x68, 0x3f, 0xc8, 0x8e, 0x96, 0x84, 0xaa, 0xc, 0x46, 0xc, 0x3e, 0xc3, 0x33, 0x8, 0xd, 0x5f, 0x55, 0x75, 0x20, 0xa3, 0x59, 0x80, 0x35, 0x63, 0xa1, 0xd8, 0xba, 0x7c, 0x71, 0x60, 0x82, 0xcb, 0xea, 0x80, 0x8d, 0xff, 0x62, 0x96, 0x94, 0x7c, 0xef, 0x7e, 0xa3, 0xc, 0xba, 0xd4, 0x58, 0xc0, 0xb9, 0xa, 0x7, 0x84, 0x7e, 0x3e, 0x55, 0x7c, 0xfc, 0x33, 0xb0, 0xe3, 0x89, 0x3d, 0x32, 0x92, 0x49, 0x34, 0xda, 0x96, 0x6f, 0x6d, 0x45, 0x1f, 0xf8, 0xc6, 0xb2, 0x8e, 0xca, 0xd7, 0x48, 0xc, 0xc1, 0x37, 0x32, 0x7e, 0x5d, 0xb1, 0xd, 0x18, 0xd, 0x41, 0xe8, 0x8, 0x86, 0x60, 0x29, 0x7d, 0xfa, 0x99, 0x12, 0x6f, 0x7e, 0x2a, 0xb2, 0x90, 0xf2, 0x6, 0xc0, 0x26, 0x44, 0xb4, 0xf2, 0x8a, 0x60, 0x3e, 0x95, 0x90, 0x77, 0xe1, 0x3d, 0x65, 0xc6, 0x50, 0xcc, 0x5, 0x13, 0x25, 0x9c, 0x36, 0x32, 0x4c, 0xb5, 0x22, 0x3e, 0x82, 0x93, 0x50, 0xeb, 0xa, 0x56, 0x73, 0x17, 0xfa, 0x17, 0x62, 0x13, 0xeb, 0xef, 0xd4, 0xb, 0x98, 0xc3, 0x80, 0x55, 0xb2, 0x4a, 0xd8, 0x51, 0x71, 0xff, 0x7, 0x24, 0x41, 0x9, 0x26, 0xb3, 0x8d, 0x8a, 0x6, 0xde, 0x50, 0x7, 0x75, 0xd3, 0x9e, 0x47, 0x2b, 0xb, 0x32, 0x12, 0x12, 0x22, 0x4, 0x13, 0x6d, 0x7, 0x93, 0xed, 0x28, 0xf6, 0xea, 0x7, 0xe, 0xd5, 0x7, 0x45, 0x74, 0x5d, 0xf5, 0x70, 0x79, 0xf7, 0xd4, 0xc6, 0x3c, 0x6b, 0x5a, 0x86, 0x2a, 0x3, 0x1d, 0xa9, 0x3f, 0x4e, 0x57, 0x68, 0x73, 0xe6, 0xed, 0x3, 0xea, 0xab, 0xc2, 0xa5, 0x9d, 0x4f, 0xde, 0x5a, 0x67, 0x8, 0x50, 0xa5, 0x2b, 0x17, 0xdf, 0xb0, 0x59, 0xad, 0x5a, 0x8, 0x22, 0xff, 0x68, 0xb9, 0xa3, 0xa1, 0x1a, 0x26, 0xbd, 0xe5, 0x19, 0xe8, 0x6a, 0x2c, 0x7f, 0x74, 0x3b, 0xc9, 0x32, 0xbb, 0x29, 0x20, 0x83, 0x83, 0x62, 0x1d, 0x50, 0x9d, 0xa4, 0x38, 0xa5, 0x6b, 0x56, 0xe1, 0xaa, 0xad, 0xc3, 0x30, 0xa0, 0xce, 0xad, 0xe5, 0x1e, 0xa6, 0x5e, 0xca, 0x25, 0x6e, 0x3d, 0xee, 0x44, 0x95, 0xc3, 0xfb, 0x94, 0xf4, 0x1c, 0x12, 0x1b, 0x3, 0xb6, 0x99, 0x69, 0x81, 0x3, 0x3d, 0x5d, 0x9e, 0x55, 0x40, 0x71, 0x9e, 0x29, 0xeb, 0x1a, 0xd9, 0xa1, 0xc, 0x21, 0x82, 0x81, 0x16, 0x29, 0xbb, 0x5a, 0x7d, 0x22, 0x96, 0x84, 0x2f, 0xca, 0x60, 0x18, 0xe4, 0x4b, 0x1b, 0x2b, 0xe, 0xe5, 0x6d, 0xb6, 0x3e, 0xda, 0xcf, 0xfa, 0x83, 0x7a, 0x1, 0x47, 0xd1, 0xfb, 0xea, 0x73, 0x7f, 0xd6, 0x6b, 0x61, 0x4f, 0xa0, 0x97, 0x81, 0x94, 0x22, 0xda, 0xeb, 0x9e, 0x1f, 0x4, 0xb8, 0x1d, 0x4b, 0x1e, 0x56, 0x9a, 0xa8, 0x47, 0x8, 0xaf, 0xac, 0x7a, 0x9d, 0xd9, 0x2f, 0x95, 0xd9, 0xca, 0xc1, 0x13, 0x74, 0x4, 0xf9, 0x50, 0xc7, 0xd, 0xe, 0x33, 0x7c, 0x95, 0x6b, 0xfd, 0x2c, 0x7b, 0x64, 0xa3, 0xb9, 0x9f, 0x14, 0x99, 0xf9, 0xb2, 0x97, 0x39, 0x1b, 0x9, 0x96, 0xb4, 0x22, 0x89, 0xe2, 0x5, 0xb4, 0x79, 0x0, 0x16, 0x8f, 0x8b, 0xc3, 0xa3, 0xc, 0x84, 0xcd, 0xf0, 0xa, 0xf5, 0x2e, 0xf1, 0x4d, 0x8b, 0x4a, 0x87, 0x67, 0x5f, 0x88, 0x59, 0xe9, 0xc3, 0x98, 0x5, 0x24, 0xc2, 0x8, 0x1d, 0x3a, 0x8, 0xde, 0x57, 0x6c, 0x1f, 0xd5, 0xb4, 0x4, 0x59, 0xe2, 0x99, 0xba, 0x89, 0xfb, 0xd0, 0x5c, 0x8e, 0xd0, 0x1e, 0x3b, 0xed, 0xd8, 0x93, 0xf7, 0xec, 0x17, 0xdd, 0x1b, 0xe1, 0xee, 0xe0, 0xb1, 0x91, 0x86, 0xe7, 0x39, 0xdd, 0xe6, 0x50, 0x56, 0x6c, 0x39, 0x5e, 0xb1, 0x43, 0x45, 0x1c, 0x9, 0xeb, 0x51, 0xc6, 0xe1, 0x4e, 0xef, 0x3f, 0xc3, 0xe2, 0x2, 0x10, 0xce, 0x62, 0xc4, 0x9d, 0xb, 0xb8, 0x62, 0xce, 0xc2, 0x88, 0x72, 0xc0, 0xcd, 0x98, 0x90, 0x50, 0xb5, 0x6e, 0xee, 0xb0, 0x62, 0xae, 0x26, 0x45, 0xc1, 0x51, 0x6, 0x35, 0xe4, 0x8, 0x5f, 0x59, 0x40, 0xee, 0xc6, 0x27, 0x4c, 0xa9, 0x82, 0xe3, 0x12, 0xab, 0x21, 0xba, 0x9, 0x30, 0xbe, 0x4d, 0x6b, 0x57, 0xad, 0x8d, 0x36, 0xbb, 0xf5, 0x8d, 0xc0, 0x5d, 0x35, 0x3e, 0x32, 0xa5, 0xcf, 0xcc, 0x4e, 0xb0, 0x8, 0x61, 0xe, 0x24, 0xa8, 0xf2, 0xa1, 0xfc, 0xb5, 0x7b, 0xf6, 0xe4, 0xad, 0xcf, 0x80, 0xd3, 0x40, 0x89, 0x97, 0xd6, 0x87, 0x2a, 0x2e, 0xa5, 0xe9, 0x4e, 0x74, 0xcc, 0x18, 0x4e, 0xcc, 0xbb, 0xa1, 0x58, 0x82, 0x74, 0x5e, 0x3, 0x14, 0x60, 0x45, 0xdb, 0xf6, 0xe9, 0x41, 0x27, 0x58, 0x1c, 0xee, 0x20, 0xf2, 0xf4, 0x8, 0x84, 0x1d, 0x19, 0x82, 0x13, 0x2e, 0x5b, 0x7f, 0x58, 0x2b, 0x91, 0x78, 0x47, 0x40, 0x76, 0x1e, 0xfd, 0xc9, 0x34, 0x6b, 0xd9, 0xeb, 0xb3, 0xc1, 0xfd, 0x34, 0x1c, 0x30, 0x56, 0xf4, 0xdb, 0xb4, 0xb3, 0x6e, 0xa9, 0xe4, 0xbf, 0x5, 0xc9, 0x65, 0xb3, 0x67, 0x34, 0x64, 0x72, 0xd0, 0xeb, 0x55, 0xb8, 0x40, 0xed, 0x49, 0xef, 0x24, 0x5c, 0x6f, 0x86, 0xec, 0x53, 0x94, 0x6, 0x33, 0x5, 0xba, 0xd, 0xf4, 0x5d, 0xb3, 0xf, 0x76, 0x58, 0xd2, 0x8a, 0xa9, 0x88, 0xcc, 0x9a, 0xd9, 0x7f, 0xa, 0x9c, 0xb, 0x3e, 0x59, 0xfb, 0x62, 0x3d, 0x55, 0xc6, 0x1f, 0x2e, 0x20, 0x25, 0x21, 0x71, 0x49, 0x70, 0xc2, 0x28, 0x5b, 0xdb, 0xf7, 0xc6, 0x11, 0x9f, 0xa3, 0x9, 0x7d, 0x82, 0xf6, 0xa1, 0xeb, 0xc3, 0x3d, 0x42, 0xc8, 0x5a, 0x93, 0x63, 0xa, 0xe1, 0x85, 0x21, 0xa2, 0xf8, 0xaa, 0x78, 0x5a, 0x17, 0xc2, 0xd9, 0x35, 0x40, 0x33, 0xfe, 0x29, 0x7b, 0x17, 0x2e, 0xa1, 0xf0, 0x6c, 0xca, 0x68, 0x6d, 0xe4, 0xe1, 0xa2, 0x88, 0x36, 0xda, 0x55, 0x9e, 0x44, 0x5, 0x85, 0x64, 0x11, 0xd5, 0x85, 0x33, 0xce, 0x33, 0xc6, 0xb5, 0x73, 0xec, 0x51, 0xf0, 0xf5, 0x65, 0x49, 0x9f, 0x6f, 0xca, 0x88, 0x37, 0xfc, 0x80, 0xbc, 0x49, 0x25, 0x86, 0x7e, 0xeb, 0x6b, 0xdc, 0xab, 0x15, 0xef, 0x1c, 0x70, 0xb1, 0x7e, 0x2, 0xa5, 0x35, 0xe2, 0xf4, 0x23, 0xd3, 0x65, 0x91, 0xa2, 0x2c, 0xf5, 0x27, 0xd1, 0x18, 0xd5, 0xc5, 0x40, 0xa6, 0x74, 0x9e, 0x1c, 0x20, 0x60, 0x58, 0xc0, 0x45, 0x2b, 0xd9, 0xc8, 0xf5, 0x88, 0x5e, 0xb5, 0x82, 0x3b, 0xa8, 0x51, 0x5c, 0x10, 0x5f, 0x8d, 0x96, 0xfd, 0x5f, 0x4a, 0xf9, 0x33, 0x7e, 0x66, 0xd3, 0x50, 0x69, 0xd1, 0x9e, 0xc0, 0x41, 0xa7, 0xd9, 0x79, 0x45, 0x2e, 0x57, 0x43, 0xa6, 0xa2, 0x2d, 0xa0, 0xdf, 0x66, 0x2f, 0xd9, 0xd1, 0xa2, 0xac, 0x3f, 0x8d, 0x43, 0x1a, 0x61, 0xf4, 0xfb, 0x94, 0x40, 0x89, 0xc5, 0x22, 0x33, 0x16, 0x7e, 0xd, 0x53, 0x89, 0x9b, 0x6d, 0x45, 0xc5, 0x13, 0x93, 0xf3, 0xef, 0x68, 0x94, 0x92, 0x14, 0x86, 0xd2, 0xf9, 0xf4, 0xd5, 0xe6, 0xe9, 0x51, 0x7, 0xfb, 0x97, 0x5c, 0x8e, 0x85, 0x6a, 0xfc, 0x76, 0xb0, 0x6b, 0xf3, 0x64, 0x86, 0x68, 0xea, 0xff, 0x6a, 0xa5, 0x9f, 0xc9, 0xa3, 0xaa, 0x53, 0x6e, 0x54, 0x88, 0x80, 0xd4, 0xd7, 0x9c, 0x9e, 0xb5, 0xcf, 0xeb, 0xa4, 0xd6, 0xd5, 0xd4, 0x2, 0x19, 0x7c, 0xe, 0x16, 0x8, 0x50, 0xd, 0x69, 0x83, 0x3c, 0x6, 0x9b, 0xd1, 0xc4, 0x5d, 0x76, 0x6a, 0x7b, 0xc7, 0x83, 0xc0, 0x19, 0x4a, 0x2c, 0x81, 0x3b, 0x22, 0x3f, 0x14, 0x1d, 0x8a, 0xe2, 0x86, 0x8f, 0xd6, 0x5d, 0x68, 0xdd, 0x67, 0xef, 0x46, 0x3e, 0x34, 0xe4, 0xfc, 0x20, 0xc7, 0x77, 0x7b, 0xe1, 0x7a, 0x3f, 0xcf, 0xa5, 0x1a, 0x9d, 0x98, 0xfb, 0x23, 0xb3, 0x41, 0xb1, 0x2c, 0xdd, 0x2b, 0x43, 0xb, 0x6, 0x2, 0xca, 0xb0, 0x3a, 0x22, 0x6c, 0x7c, 0xee, 0x4f, 0x94, 0x88, 0xc8, 0x31, 0x9d, 0xdb, 0xf4, 0xef, 0xf1, 0xb6, 0x14, 0xba, 0x9c, 0x1f, 0xe0, 0x9, 0x8e, 0x9c, 0xe1, 0xb5, 0x7e, 0xa4, 0xd8, 0xd7, 0x77, 0xee, 0x89, 0xf4, 0xc2, 0xe3, 0xc7, 0x29, 0x21, 0x6b, 0x6b, 0x2e, 0xe2, 0x68, 0x5d, 0xb9, 0xc1, 0x94, 0x5b, 0x27, 0x98, 0x6c, 0x74, 0x8d, 0xca, 0x51, 0xbb, 0x36, 0x18, 0x24, 0x82, 0x4f, 0xb2, 0xa3, 0x1e, 0xf9, 0xd7, 0x24, 0x4b, 0x73, 0x47, 0x79, 0xb8, 0x63, 0x54, 0xbc, 0xd, 0xba, 0x43, 0x8d, 0x37, 0x81, 0x93, 0xa8, 0x47, 0x85, 0xb6, 0xb8, 0x64, 0x30, 0x6e, 0xb6, 0xe6, 0xa0, 0xa8, 0xf, 0xa2, 0xaf, 0x4, 0x98, 0x5f, 0xc5, 0x40, 0x47, 0x7b, 0x91, 0x1d, 0x7e, 0xa8, 0x59, 0xd8, 0xf9, 0x56, 0xdd, 0x1d, 0xf3, 0xe4, 0x64, 0xd8, 0x84, 0xa6, 0x35, 0x5e, 0x8b, 0x24, 0xca, 0x3f, 0x5, 0xf2, 0x5e, 0xe5, 0x3b, 0x23, 0xeb, 0xe4, 0x3c, 0xe6, 0xc3, 0x27, 0x74, 0xfb, 0x74, 0xba, 0xce, 0x33, 0xa1, 0x2e, 0x7c, 0x17, 0x98, 0xb7, 0x11, 0x6b, 0xee, 0x12, 0x45, 0xcb, 0xe3, 0x23, 0x88, 0x24, 0x64, 0xc4, 0x9b, 0x64, 0x7d, 0x61, 0x35, 0xa, 0xde, 0xb8, 0x4c, 0xae, 0x9c, 0x61, 0xb0, 0x2b, 0xd7, 0x2, 0xe6, 0xd8, 0xde, 0x84, 0x9f, 0xad, 0x57, 0xa5, 0x7a, 0xd2, 0x97, 0x15, 0x3, 0x12, 0x19, 0x8d, 0x89, 0xef, 0x13, 0x66, 0xe4, 0x52, 0x86, 0xf4, 0xbc, 0xc8, 0x21, 0x7d, 0xb2, 0xed, 0xd3, 0x9b, 0x14, 0x4d, 0x6b, 0xa1, 0xd6, 0xcb, 0xd, 0x1c, 0x74, 0xbe, 0x39, 0x6c, 0xb5, 0x35, 0xe6, 0xff, 0x99, 0x0, 0xac, 0x37, 0x1a, 0x6f, 0x9e, 0x8d, 0xaa, 0x45, 0xdd, 0x1b, 0x18, 0x42, 0xfc, 0x68, 0x5d, 0x1f, 0xde, 0xe0, 0xfc, 0x12, 0x7a, 0x16, 0x5b, 0x3, 0xb5, 0x61, 0x0, 0x2c, 0xa5, 0x6f, 0x19, 0x14, 0x30, 0x24, 0xc4, 0x15, 0x20, 0x48, 0x9b, 0xef, 0xa8, 0x2a, 0xf9, 0x2f, 0xce, 0x5b, 0xb2, 0x20, 0xdc, 0xec, 0x1a, 0xa0, 0x47, 0xb2, 0x99, 0xf7, 0xfa, 0xc2, 0xbc, 0xb4, 0x89, 0xc9, 0x90, 0x44, 0xae, 0xfa, 0xf2, 0x92, 0xc, 0x32, 0x45, 0x97, 0xda, 0xac, 0xab, 0x92, 0xf6, 0x34, 0x7b, 0xc0, 0xef, 0x95, 0xca, 0x61, 0x9d, 0xc1, 0x9a, 0x7f, 0x28, 0xa1, 0xcb, 0xba, 0xce, 0xfc, 0x85, 0xea, 0x2b, 0xd7, 0xa7, 0x69, 0xe6, 0xbe, 0x42, 0x4f, 0x4a, 0xf0, 0x8a, 0xf7, 0xf2, 0x4f, 0x54, 0x75, 0xee, 0x24, 0x34, 0xac, 0xee, 0xce, 0xc1, 0x8b, 0xfb, 0xcf, 0xd3, 0x47, 0x92, 0x26, 0x36, 0x3b, 0x2b, 0xfa, 0x91, 0x5d, 0xa7, 0x6b, 0x83, 0x98, 0x57, 0xa3, 0x36, 0x41, 0xb4, 0xb9, 0xf6, 0x4f, 0x15, 0x70, 0x2a, 0xdb, 0x39, 0x64, 0xe5, 0xdb, 0x19, 0xfa, 0xf4, 0x84, 0x89, 0xa7, 0xf6, 0xf9, 0xf5, 0x6a, 0x2a, 0x25, 0x8c, 0x54, 0xe0, 0xe5, 0xf9, 0x7f, 0x38, 0x2f, 0xa9, 0x92, 0x74, 0xb2, 0x60, 0x7d, 0x3d, 0x6a, 0x6b, 0x94, 0xca, 0x7, 0x5e, 0xb4, 0x54, 0x8, 0xb, 0x1, 0x43, 0x5c, 0x5a, 0xba, 0x8b, 0x45, 0xad, 0x6e, 0xdf, 0xd0, 0xd, 0xdc, 0x2, 0x70, 0xc7, 0xe5, 0x49, 0x19, 0xa4, 0x3d, 0xc7, 0x15, 0xcb, 0x7b, 0x37, 0xe8, 0x42, 0x3c, 0x7d, 0x22, 0x85, 0xd2, 0x22, 0xae, 0xc6, 0x6e, 0x4d, 0xc4, 0xb5, 0x5b, 0xc6, 0xee, 0xd3, 0xce, 0xd1, 0xb8, 0xd5, 0xb3, 0x64, 0xf5, 0xfe, 0xd3, 0x5b, 0xa0, 0x31, 0x2e, 0x46, 0x41, 0x81, 0x92, 0x93, 0x77, 0x92, 0xe8, 0x65, 0xeb, 0xf5, 0xd5, 0x31, 0x5f, 0x1e, 0x39, 0x51, 0x94, 0x0, 0x4b, 0x77, 0xf1, 0xd1, 0x5e, 0x48, 0x20, 0x3e, 0x3e, 0x5b, 0xd2, 0xc5, 0x8, 0xe3, 0xcd, 0x8d, 0x1e, 0x20, 0x75, 0xb3, 0xd6, 0xdb, 0xa, 0x5b, 0x28, 0xc1, 0xf, 0x15, 0x5b, 0x13, 0x95, 0x42, 0x97, 0xdb, 0x51, 0x8a, 0x3e, 0x47, 0xdb, 0x5d, 0xa1, 0xc0, 0xed, 0x85, 0x36, 0xfa, 0x7b, 0x59, 0x45, 0xe9, 0x52, 0xbb, 0x5c, 0x4e, 0x24, 0xc4, 0xf, 0xca, 0xc, 0x34, 0x43, 0x2, 0xa5, 0x20, 0x2b, 0x92, 0xa3, 0x51, 0x73, 0x82, 0x25, 0x50, 0x52, 0x9, 0xd8, 0x10, 0x78, 0x9f, 0x7a, 0x59, 0x6, 0x72, 0xec, 0xaa, 0xd8, 0x66, 0xac, 0xe7, 0x71, 0xa3, 0xf9, 0x9, 0x1a, 0x16, 0x95, 0xda, 0x17, 0xb3, 0x57, 0x62, 0x13, 0xa0, 0xdb, 0x5c, 0x46, 0x41, 0xe7, 0x80, 0x45, 0x82, 0x2a, 0xfd, 0x93, 0x9b, 0x62, 0x72, 0xd1, 0x2e, 0x5, 0xcd, 0xd1, 0x4, 0x6, 0x81, 0xaa, 0xee, 0x55, 0x52, 0x3b, 0xe6, 0x37, 0x1c, 0x53, 0xfc, 0xed, 0x13, 0x63, 0x8a, 0x94, 0x48, 0xc0, 0xe9, 0xaf, 0x8a, 0xef, 0x55, 0xac, 0xaf, 0x72, 0x3d, 0x51, 0x3d, 0xab, 0x51, 0x38, 0xf6, 0x2e, 0x28, 0xfe, 0xb4, 0x89, 0xe7, 0x5b, 0xe0, 0x72, 0x41, 0x80, 0x51, 0xcd, 0xfd, 0xab, 0xc7, 0xce, 0xb0, 0xc9, 0x9f, 0x18, 0x1c, 0x6a, 0xd9, 0x5e, 0x7e, 0xff, 0x52, 0x26, 0xbe, 0x5c, 0x4f, 0x4e, 0xde, 0xe7, 0xa8, 0xc4, 0xa0, 0x50, 0x2, 0x41, 0xed, 0xbc, 0x36, 0x3c, 0xb4, 0xc3, 0xac, 0x12, 0xdd, 0x4, 0x6e, 0xf0, 0xc8, 0x40, 0x93, 0x37, 0x40, 0xf4, 0x8c, 0x63, 0xde, 0x39, 0xc0, 0x82, 0xff, 0x43, 0x74, 0xc2, 0xd8, 0x45, 0x3f, 0x2b, 0x81, 0x3f, 0x39, 0x7b, 0x82, 0x2e, 0x90, 0xfd, 0x59, 0xb4, 0x48, 0x26, 0x2c, 0x0, 0xfd, 0xca, 0xe7, 0x3b, 0xcf, 0x90, 0xca, 0xe1, 0x64, 0xba, 0xe3, 0x30, 0x41, 0xcb, 0x80, 0x9e, 0x7c, 0xaf, 0xcf, 0xdd, 0x65, 0x80, 0x65, 0xb8, 0x4b, 0x7c, 0x37, 0xc, 0xe3, 0xe0, 0x8d, 0x50, 0x5f, 0x7a, 0x2b, 0xa7, 0x83, 0xa6, 0x66, 0xef, 0x74, 0xd8, 0x74, 0x33, 0x36, 0xfa, 0x4d, 0xf4, 0xe2, 0xa, 0x1f, 0x8d, 0x58, 0xcd, 0xb, 0xe, 0xff, 0x66, 0xfa, 0x77, 0x80, 0x3f, 0x42, 0x16, 0x9f, 0x51, 0x10, 0x9a, 0x4c, 0xcf, 0xd0, 0x8, 0xf3, 0x6e, 0x23, 0xed, 0xba, 0xaa, 0x6a, 0xbf, 0x53, 0xb8, 0x22, 0xc9, 0xef, 0x35, 0x6b, 0x79, 0x2, 0x7c, 0xf2, 0x8d, 0xf9, 0xe5, 0xd5, 0xd7, 0xca, 0x36, 0xa, 0xeb, 0x40, 0x7c, 0xf0, 0x2c, 0xa2, 0x68, 0x9f, 0x81, 0x31, 0xc7, 0x8c, 0xe6, 0xde, 0x7c, 0x5d, 0x8a, 0x2d, 0xc6, 0x5a, 0x91, 0xdf, 0x7a, 0xca, 0x77, 0x87, 0xec, 0xd5, 0x14, 0x5c, 0x5c, 0x79, 0x1b, 0x74, 0x28, 0xf3, 0xf9, 0xcb, 0xb2, 0x2f, 0x58, 0x4e, 0xb5, 0x64, 0xaf, 0x89, 0x26, 0x3f, 0x57, 0x50, 0xcb, 0x37, 0xc8, 0x15, 0x1f, 0x20, 0x5b, 0x2f, 0xca, 0x7d, 0xf7, 0x46, 0x22, 0x6d, 0x5a, 0xfe, 0x10, 0x17, 0x7c, 0x8b, 0xc4, 0x56, 0x45, 0x2e, 0xa6, 0x5d, 0x44, 0x9e, 0x19, 0xb4, 0x25, 0x3d, 0x66, 0x25, 0xd5, 0xc3, 0x34, 0x9f, 0x3e, 0xc3, 0xbe, 0x55, 0x4d, 0x41, 0x58, 0xdf, 0x21, 0x9d, 0xe2, 0x26, 0xaf, 0x37, 0x9a, 0x42, 0x2a, 0x8d, 0xac, 0x91, 0xb9, 0x7c, 0x64, 0xe1, 0x9c, 0x12, 0x1, 0x41, 0xd8, 0x6, 0x76, 0x7f, 0x7e, 0xe9, 0x31, 0xd8, 0x8e, 0x29, 0x3e, 0xe8, 0xae, 0x1e, 0xfd, 0x27, 0x66, 0xee, 0x83, 0x17, 0x4d, 0xe1, 0x9b, 0xb6, 0x45, 0xee, 0x34, 0x55, 0x13, 0x3b, 0x81, 0xe2, 0x27, 0xa, 0xc1, 0xc7, 0xcc, 0xeb, 0x3, 0x7a, 0x50, 0xa5, 0xcc, 0xd5, 0x40, 0xf0, 0xa, 0xbe, 0x27, 0xf0, 0x5b, 0xbc, 0x29, 0xa2, 0xf1, 0x5, 0x42, 0xca, 0xa, 0xe1, 0x30, 0xd2, 0xb2, 0xa1, 0x46, 0x4d, 0xb0, 0x3c, 0xb, 0x25, 0x10, 0xa9, 0xe7, 0xfb, 0x98, 0xab, 0x24, 0xfd, 0x39, 0x1c, 0xba, 0xe0, 0xa1, 0x12, 0xa6, 0x6e, 0xac, 0x5, 0x30, 0x41, 0x27, 0xd1, 0x54, 0x5b, 0xe6, 0x63, 0x8b, 0x6d, 0x35, 0x60, 0x68, 0x77, 0x71, 0x9c, 0x3c, 0xd7, 0x82, 0xfa, 0xe3, 0xfa, 0xad, 0x1b, 0x89, 0xeb, 0x60, 0x37, 0x50, 0xc7, 0xb5, 0xc3, 0xce, 0x84, 0xf9, 0x3f, 0xac, 0x14, 0x73, 0x46, 0x35, 0xc, 0x75, 0xc, 0xf2, 0xca, 0x7e, 0xf9, 0x9, 0x9d, 0x67, 0x25, 0xbd, 0x31, 0x17, 0x2c, 0x37, 0xfa, 0xe6, 0xe, 0x7, 0xf3, 0x35, 0x72, 0xcb, 0x84, 0x3e, 0x67, 0xe8, 0x66, 0x2d, 0xd, 0xd5, 0x5e, 0x42, 0x4a, 0xfa, 0x9b, 0x1d, 0x57, 0xcb, 0xf9, 0xdd, 0xcd, 0xe4, 0x47, 0xa3, 0xb8, 0xb6, 0x4, 0xef, 0xa2, 0x53, 0xeb, 0xb2, 0xce, 0xbe, 0x1, 0x52, 0x1f, 0x3, 0x53, 0xc5, 0x21, 0xf4, 0x57, 0xf4, 0x51, 0xcd, 0x93, 0x34, 0x6d, 0x81, 0x5d, 0x6b, 0xcb, 0xa8, 0x7b, 0x3d, 0x2f, 0x96, 0xa2, 0x2e, 0xd1, 0x7c, 0x17, 0xb9, 0xb, 0xe3, 0xdd, 0xf7, 0xe0, 0x48, 0x38, 0xc4, 0xf7, 0x80, 0xbe, 0x2c, 0x96, 0xb7, 0x81, 0x55, 0x8b, 0x4a, 0x49, 0x99, 0xb3, 0xad, 0xba, 0xac, 0xa1, 0x22, 0x9f, 0x22, 0xff, 0x63, 0x7c, 0xfc, 0x6, 0x8c, 0xe8, 0x80, 0x2f, 0x86, 0x84, 0xaa, 0xc3, 0x2a, 0xe3, 0x2b, 0xd0, 0x9c, 0xd5, 0xc1, 0xd7, 0x70, 0x90, 0xc, 0xc7, 0xc5, 0xfe, 0x8d, 0xf4, 0x1e, 0x81, 0x10, 0xfa, 0xad, 0x78, 0x2c, 0x15, 0xc3, 0xcd, 0x63, 0x7b, 0xa6, 0x19, 0xa0, 0x3, 0x7d, 0x73, 0x78, 0xc7, 0x2c, 0xb0, 0xc9, 0x5a, 0x35, 0xa9, 0x10, 0x9b, 0xe1, 0x1f, 0x8c, 0x4b, 0xf0, 0xd3, 0xbb, 0x80, 0x94, 0x9a, 0x15, 0xc6, 0x4a, 0xd, 0x6f, 0x52, 0xa9, 0xb5, 0x2a, 0x52, 0x1d, 0x6, 0xdc, 0x74, 0x9c, 0xd0, 0xe5, 0x53, 0x41, 0x8e, 0x12, 0x7f, 0xb5, 0x19, 0xbd, 0xa4, 0x1, 0xf5, 0x9e, 0x5a, 0xe5, 0x17, 0xcb, 0xc2, 0xf5, 0x38, 0xb6, 0xc3, 0x2f, 0x9c, 0xe5, 0xc3, 0x40, 0x88, 0xcf, 0xff, 0xe0, 0x3f, 0xdc, 0x7d, 0x36, 0xa7, 0xa9, 0x12, 0xed, 0xe8, 0x25, 0x4b, 0x7e, 0xa4, 0x6f, 0x12, 0x62, 0x97, 0x3b, 0xe5, 0x64, 0x8, 0x9c, 0x44, 0x82, 0x54, 0x37, 0xd8, 0xdb, 0xa9, 0x8b, 0xe0, 0x4c, 0xf7, 0xf6, 0xab, 0x5d, 0x3, 0xc5, 0xc1, 0xa, 0xb5, 0x15, 0x57, 0xf3, 0x31, 0xd0, 0xb1, 0xb9, 0x19, 0xb9, 0x64, 0x3e, 0xfa, 0xd7, 0x9, 0x8, 0xd, 0x2f, 0xf4, 0x6b, 0xe8, 0x3e, 0x8, 0x15, 0x51, 0xf6, 0x4e, 0xcd, 0x82, 0x6d, 0xb0, 0x94, 0x69, 0x17, 0x9f, 0xf4, 0xb0, 0x68, 0xcc, 0xa1, 0x72, 0xd1, 0xe1, 0x67, 0x50, 0xbd, 0x6d, 0x4c, 0x80, 0x51, 0x46, 0xdc, 0x2, 0x21, 0xa5, 0x55, 0xc8, 0x19, 0x31, 0xa6, 0x2, 0x6, 0xaf, 0x7c, 0xb4, 0x85, 0xd2, 0xfb, 0x7f, 0xa9, 0xd7, 0xaa, 0xcb, 0xc3, 0xe3, 0x72, 0x9e, 0xb0, 0x99, 0x79, 0xd2, 0xe6, 0x83, 0xea, 0x3e, 0xd8, 0xad, 0x3b, 0x4b, 0xaa, 0xf4, 0xfe, 0x25, 0xf8, 0xb2, 0x27, 0x56, 0x87, 0x95, 0x56, 0x3d, 0x3f, 0x29, 0x2, 0xa9, 0x73, 0x75, 0xc5, 0x21, 0xba, 0x20, 0xf9, 0xc5, 0xe8, 0x60, 0xdf, 0xac, 0x83, 0xa0, 0xf0, 0xed, 0x34, 0x75, 0x88, 0xf2, 0x50, 0xa4, 0x4f, 0x1, 0xc9, 0x36, 0x11, 0x40, 0x5a, 0xeb, 0x4, 0xc6, 0xe7, 0x51, 0x53, 0xf0, 0xa6, 0xe0, 0x64, 0xe1, 0x9d, 0x89, 0x5d, 0xf7, 0x59, 0x6c, 0x6a, 0x48, 0xa0, 0xbb, 0x38, 0x4, 0xa7, 0x89, 0x37, 0xa4, 0x5b, 0xcd, 0x5, 0x48, 0x63, 0x14, 0xba, 0xf7, 0x26, 0x61, 0x34, 0x9e, 0x8e, 0xb5, 0x16, 0xfc, 0xfb, 0xaf, 0xfb, 0x31, 0x63, 0x97, 0x16, 0xc5, 0xb8, 0x8c, 0xaf, 0x42, 0x55, 0xe2, 0xe, 0xe9, 0xa, 0x6e, 0xf4, 0x2, 0xe7, 0xa3, 0x9c, 0x5c, 0xcd, 0xc5, 0xb1, 0x96, 0xa9, 0x9c, 0x54, 0x55, 0x63, 0x9e, 0x9e, 0xcb, 0x78, 0x8f, 0x94, 0xab, 0xd7, 0xa7, 0x11, 0x83, 0x3b, 0x92, 0xdb, 0x9f, 0xd5, 0x6b, 0x64, 0x12, 0xbf, 0x84, 0xc6, 0xbe, 0xe9, 0x50, 0x56, 0x82, 0xea, 0x30, 0xc, 0xee, 0xda, 0x49, 0x6e, 0xf0, 0x6c, 0xc4, 0x77, 0xc2, 0x72, 0x31, 0x8f, 0x98, 0x83, 0x21, 0x27, 0x94, 0xe9, 0xad, 0x88, 0x17, 0x7b, 0x65, 0xce, 0xcc, 0x1b, 0xa8, 0x47, 0x4d, 0x3d, 0xe7, 0x65, 0x6b, 0x61, 0xa3, 0xb8, 0x32, 0x24, 0x5, 0x78, 0xa4, 0xff, 0x70, 0x4c, 0xaa, 0x65, 0xe0, 0x1a, 0x29, 0xf3, 0x65, 0xc1, 0xab, 0xb1, 0xdf, 0x23, 0xd6, 0x1a, 0xd4, 0x1c, 0x8, 0xb0, 0x92, 0xce, 0x87, 0xb, 0xa1, 0x10, 0x38, 0x57, 0xda, 0x37, 0xd8, 0xf5, 0x64, 0x7a, 0x5d, 0x5a, 0xda, 0x7b, 0xb1, 0xd9, 0x80, 0x4c, 0x54, 0x7c, 0x18, 0x7b, 0xd1, 0x76, 0x72, 0x58, 0x29, 0x25, 0x14, 0x49, 0x1c, 0xec, 0x97, 0xba, 0x41, 0xf4, 0x8c, 0x6b, 0x58, 0x1f, 0xe8, 0xe7, 0x45, 0x20, 0xd0, 0xf0, 0xf6, 0xb0, 0xe4, 0x4c, 0x99, 0x20, 0x29, 0xf, 0x68, 0x68, 0x4d, 0x16, 0x92, 0x53, 0x8, 0x75, 0x40, 0xeb, 0xe7, 0x33, 0xae, 0x24, 0x65, 0x25, 0x4b, 0xa0, 0x4b, 0xeb, 0x70, 0x3f, 0x3a, 0x30, 0x9b, 0xe1, 0x4b, 0x4f, 0x22, 0xea, 0x63, 0xaa, 0x2d, 0xe8, 0xe6, 0x74, 0xd2, 0xad, 0x44, 0x6f, 0x35, 0x6d, 0x1c, 0xfe, 0x12, 0x7, 0xa5, 0xed, 0x7c, 0x2d, 0x56, 0x5c, 0xcd, 0x5c, 0xc1, 0xef, 0xe, 0xb1, 0xe7, 0x91, 0x9c, 0x26, 0xe9, 0x2b, 0x85, 0x1f, 0x74, 0x78, 0xc8, 0x3d, 0xe6, 0xcd, 0x21, 0xa3, 0x54, 0x7c, 0xd4, 0x46, 0x4a, 0x6b, 0x6b, 0x4d, 0xa6, 0xa8, 0xd8, 0xf7, 0x36, 0xd1, 0x6d, 0x81, 0x80, 0x63, 0xd1, 0xfb, 0x95, 0xa8, 0xd6, 0xa4, 0x69, 0x11, 0xfc, 0x56, 0x4a, 0xa5, 0xcf, 0xb1, 0xcf, 0x76, 0xef, 0x9, 0xd0, 0xc1, 0x4, 0x64, 0x8f, 0x92, 0xdb, 0x9b, 0x28, 0x81, 0x6f, 0x56, 0xa, 0x24, 0x93, 0x59, 0x23, 0xa9, 0x45, 0xa1, 0xfb, 0x52, 0xad, 0x9f, 0xac, 0x6e, 0xa2, 0xe6, 0x40, 0xa6, 0x4f, 0x79, 0xf2, 0x56, 0x93, 0x39, 0x8b, 0xa, 0xe, 0x56, 0x75, 0x18, 0xd9, 0x50, 0x71, 0x4a, 0x8a, 0xaf, 0x34, 0x3a, 0x68, 0xa4, 0xeb, 0x1e, 0xe1, 0xf5, 0x18, 0xac, 0xbe, 0x99, 0xe0, 0x50, 0x41, 0xca, 0x50, 0x5a, 0xd5, 0x9, 0xf6, 0xeb, 0xcc, 0x68, 0xc8, 0x4d, 0x85, 0xdc, 0x17, 0xe6, 0xf, 0x2, 0x40, 0xec, 0x84, 0x8a, 0x84, 0x2f, 0x4a, 0x1a, 0xbf, 0x11, 0x37, 0x1f, 0x46, 0xce, 0x69, 0xd5, 0xb5, 0x35, 0xfa, 0xb5, 0x63, 0x45, 0x23, 0xe3, 0x59, 0xae, 0x14, 0xdd, 0x7, 0x74, 0x9f, 0xbc, 0x63, 0x90, 0xee, 0xb9, 0xe5, 0x33, 0xf, 0xc0, 0x79, 0x26, 0xc9, 0x71, 0xc7, 0x19, 0xcd, 0x2, 0xaa, 0x56, 0x50, 0x48, 0xcd, 0xa7, 0xe5, 0x34, 0x36, 0x5a, 0x3f, 0x39, 0x55, 0x5f, 0x25, 0xbe, 0xc8, 0x47, 0xc0, 0xfe, 0x5a, 0x76, 0xef, 0x68, 0xf0, 0x38, 0xff, 0x55, 0x2d, 0xa2, 0x72, 0x25, 0x81, 0xcc, 0x14, 0xec, 0xed, 0xa1, 0x29, 0x79, 0x42, 0xa1, 0xa6, 0x7d, 0x5, 0x1, 0x81, 0x57, 0x47, 0xc6, 0x15, 0x17, 0xa9, 0xac, 0x87, 0x6d, 0xb6, 0x62, 0x64, 0x1f, 0x75, 0xa, 0x91, 0x7e, 0xdf, 0xd8, 0xea, 0x19, 0x9d, 0x27, 0xe5, 0xd5, 0x68, 0x55, 0xe5, 0x20, 0x7, 0x91, 0xcd, 0x40, 0x4d, 0x15, 0xb6, 0xef, 0x6f, 0x57, 0x71, 0x23, 0x4b, 0x9, 0x2, 0xc9, 0xdb, 0x5b, 0x3, 0x3f, 0x26, 0x3, 0x59, 0xf1, 0xa5, 0x2e, 0x66, 0x46, 0xdb, 0xde, 0x9e, 0x4f, 0x98, 0x76, 0xa7, 0xbf, 0x2c, 0x5f, 0xd7, 0xba, 0x2, 0x8b, 0xaa, 0x30, 0x6f, 0xf9, 0xd4, 0x28, 0x7d, 0xf8, 0x8a, 0xa0, 0x55, 0xc8, 0x33, 0xed, 0x8a, 0xc6, 0xa5, 0x6d, 0x2c, 0x83, 0xad, 0x69, 0xad, 0x3f, 0xd6, 0xff, 0xa9, 0x6a, 0xb7, 0x17, 0x44, 0x40, 0x35, 0xd3, 0xb8, 0xda, 0xe9, 0xd2, 0x6d, 0x47, 0x57, 0x67, 0xca, 0xd4, 0x52, 0xb6, 0x7, 0xb3, 0xec, 0xa6, 0xc5, 0x73, 0xc3, 0x85, 0x30, 0xdb, 0x7, 0x19, 0x68, 0xb7, 0xe1, 0xdc, 0x26, 0x5, 0x88, 0x27, 0xc5, 0x7a, 0xd8, 0x4a, 0x14, 0xb4, 0x95, 0xfe, 0x8, 0x24, 0x19, 0x25, 0x5c, 0x49, 0x5c, 0x5e, 0x13, 0xf5, 0xbc, 0x34, 0xd9, 0x6c, 0xb4, 0x98, 0x37, 0x8c, 0xc1, 0x6d, 0xbf, 0x66, 0x83, 0xd5, 0x48, 0x36, 0xe1, 0x2d, 0x44, 0xd7, 0x69, 0x56, 0xa6, 0xb0, 0xce, 0x78, 0x8a, 0xf5, 0x28, 0x2b, 0x9f, 0x6, 0xb5, 0xba, 0xd3, 0x3, 0x47, 0xa1, 0xd5, 0x37, 0xef, 0x86, 0x4b, 0xb0, 0xc1, 0x49, 0x61, 0x76, 0xb1, 0xb1, 0x1, 0x18, 0xd0, 0x2a, 0x56, 0x40, 0x76, 0x9, 0xc0, 0x20, 0x8e, 0x86, 0xb, 0x86, 0xa4, 0x7c, 0x82, 0xb6, 0xfd, 0xe7, 0x6c, 0xec, 0x5a, 0xa7, 0xc, 0xf5, 0x8b, 0x4b, 0x11, 0xd, 0x67, 0xe7, 0xe, 0x7b, 0x37, 0xdf, 0xe3, 0xa1, 0xd5, 0x30, 0x18, 0x31, 0x11, 0xe2, 0xac, 0x6b, 0x30, 0x73, 0x6b, 0xe4, 0xff, 0xd6, 0xdb, 0xae, 0xc5, 0xdc, 0xbb, 0x71, 0x94, 0xb9, 0xf0, 0xcc, 0x73, 0x3f, 0xa, 0x3a},
+               output224: []byte{0x93, 0x43, 0x6c, 0xf5, 0x50, 0x14, 0xb5, 0x33, 0xda, 0x3f, 0x89, 0xb, 0xd3, 0x18, 0x79, 0xb4, 0xdc, 0xdd, 0x88, 0xfb, 0xd8, 0x3, 0x43, 0xb6, 0x24, 0x8c, 0x8d, 0x7c},
+               output256: []byte{0x89, 0xd2, 0x23, 0x1f, 0xc6, 0x58, 0xe2, 0x8b, 0xe2, 0xa1, 0xca, 0x23, 0x82, 0x18, 0x71, 0x37, 0x47, 0x9e, 0x38, 0x34, 0xb4, 0x98, 0xd8, 0xe0, 0x70, 0x71, 0x15, 0x15, 0xef, 0x67, 0xb, 0x4d},
+               output384: []byte{0xe7, 0x3f, 0x2b, 0xa0, 0xdd, 0x0, 0x57, 0xb8, 0xe3, 0xa2, 0x9f, 0x8d, 0xc4, 0x3f, 0x52, 0x5c, 0x36, 0xa2, 0xe0, 0x3e, 0xc7, 0x71, 0xdb, 0x1d, 0x76, 0xd8, 0x7d, 0x86, 0xd5, 0x7c, 0x94, 0x80, 0x84, 0xae, 0xf3, 0x6d, 0x92, 0x31, 0xc7, 0xd0, 0x99, 0xb7, 0xb4, 0x2d, 0xf4, 0x56, 0x8d, 0x5b},
+               output512: []byte{0x93, 0x61, 0x91, 0xdc, 0xb9, 0x6f, 0x5a, 0x3a, 0x3a, 0xc1, 0x6c, 0xd8, 0x17, 0x22, 0x38, 0xa5, 0x13, 0xcf, 0x1f, 0x9c, 0xc1, 0x96, 0x20, 0xbd, 0x7c, 0xcb, 0x7e, 0xb1, 0x13, 0x5a, 0x7a, 0xc5, 0x7f, 0xd2, 0xe7, 0x6b, 0xe8, 0x86, 0x65, 0x13, 0x60, 0x24, 0xc4, 0x8d, 0x87, 0x74, 0x5e, 0x76, 0xce, 0xe0, 0x9e, 0xef, 0xc3, 0xb3, 0x52, 0xac, 0xb7, 0xc7, 0xf2, 0x7d, 0x17, 0xc8, 0x2e, 0x15}},
+       testcase{
+               msg:       []byte{0xe, 0xbf, 0x64, 0xac, 0x1, 0x7f, 0xeb, 0xdc, 0xa4, 0xf, 0xf8, 0x5f, 0xd4, 0xae, 0xb8, 0xf1, 0xa8, 0x27, 0x56, 0x1c, 0x15, 0xf, 0x74, 0xcd, 0x5e, 0x86, 0x48, 0x57, 0xfb, 0xba, 0x9c, 0x8, 0xa4, 0x6e, 0xfb, 0x9f, 0xf7, 0xa1, 0x69, 0x19, 0x61, 0x8c, 0x9f, 0xb0, 0x6b, 0xf8, 0xfe, 0x3f, 0x8, 0x59, 0x77, 0x4d, 0xa6, 0xc3, 0x8c, 0x5a, 0xc, 0x54, 0xd4, 0x40, 0x75, 0xd1, 0xba, 0xf6, 0x48, 0x2b, 0x77, 0x5, 0xc8, 0xe1, 0xa8, 0x6e, 0x79, 0xb0, 0xfb, 0xf0, 0x32, 0x82, 0x46, 0xb5, 0xe6, 0xbe, 0x1, 0x3f, 0x93, 0x4d, 0x4e, 0xcc, 0x34, 0x80, 0x8a, 0x36, 0x39, 0xc4, 0x94, 0x64, 0x30, 0x9d, 0xf5, 0xad, 0x25, 0xb, 0xf4, 0x52, 0x1e, 0x41, 0xb4, 0xcd, 0xe5, 0x63, 0x56, 0x6b, 0x86, 0x25, 0x7, 0x6a, 0xd7, 0xe2, 0x60, 0x1, 0x8e, 0xee, 0x2f, 0x32, 0x52, 0xd1, 0x5f, 0x36, 0xbd, 0xbb, 0xce, 0x3c, 0x74, 0x75, 0x8c, 0x68, 0xa0, 0xe7, 0x2d, 0x83, 0xa3, 0x7d, 0xb4, 0xd2, 0x2, 0x2a, 0x80, 0xa4, 0xf6, 0xb1, 0x6f, 0x45, 0x15, 0x5, 0x3e, 0x1f, 0xe3, 0x98, 0xcc, 0x6a, 0x74, 0xd3, 0x43, 0xd4, 0xcb, 0xb4, 0x3, 0x59, 0x7a, 0xe6, 0x85, 0x33, 0xe1, 0x8e, 0xf8, 0x93, 0xf7, 0x56, 0xf6, 0xf5, 0x54, 0xf9, 0x8b, 0xcc, 0xbc, 0x84, 0x70, 0x2d, 0x19, 0xf8, 0x75, 0xd3, 0x47, 0xc3, 0x45, 0xb0, 0x9e, 0xdf, 0xcb, 0x1c, 0x71, 0xbd, 0x69, 0x55, 0xc5, 0x17, 0x8d, 0xfc, 0xb0, 0x73, 0x76, 0x72, 0x8c, 0xfc, 0x3a, 0xb9, 0x56, 0x5c, 0xa, 0x1a, 0x8d, 0xca, 0x78, 0x22, 0x10, 0x28, 0xb0, 0xb, 0x51, 0xb1, 0x75, 0xa2, 0xda, 0x2c, 0xc0, 0xa9, 0xc, 0x33, 0xc1, 0x69, 0xea, 0x8a, 0x1a, 0x2e, 0x37, 0x5c, 0x8, 0x7a, 0xc3, 0x65, 0x7d, 0x28, 0xac, 0x48, 0x1d, 0x5b, 0x5c, 0x22, 0x5a, 0xef, 0xa8, 0x59, 0x19, 0xfb, 0x86, 0x28, 0xf3, 0x2f, 0x42, 0xf1, 0xfc, 0x8, 0x6, 0xa2, 0x50, 0x14, 0x3c, 0x8, 0x43, 0x22, 0xfe, 0x9e, 0x30, 0xbc, 0xc8, 0xb8, 0x9f, 0x3d, 0xa7, 0x34, 0x69, 0xce, 0xb9, 0x35, 0xee, 0x25, 0x88, 0x7d, 0x84, 0x33, 0x21, 0xcc, 0x8a, 0xbb, 0x3c, 0x75, 0xe1, 0x5f, 0x48, 0x94, 0xcb, 0xb5, 0x73, 0x17, 0x82, 0x37, 0x2a, 0x56, 0x31, 0x97, 0x9b, 0xbe, 0x6a, 0xea, 0xcd, 0xfb, 0x71, 0x1a, 0x84, 0xf8, 0x3b, 0xb8, 0x9e, 0xf, 0x92, 0xb8, 0x8c, 0x5e, 0xe8, 0x3e, 0x4f, 0x9a, 0x3c, 0x4f, 0x80, 0x62, 0x4a, 0x17, 0xed, 0x55, 0x49, 0xb7, 0x7e, 0xd7, 0xd9, 0x39, 0xc3, 0x68, 0xcd, 0x9a, 0x92, 0xea, 0xae, 0x59, 0x51, 0x5, 0xde, 0x7e, 0x28, 0x89, 0xca, 0xd7, 0x1d, 0x1, 0x20, 0x15, 0x80, 0x3, 0x8f, 0xcf, 0x4a, 0xb4, 0xd2, 0x85, 0xa1, 0x3b, 0xef, 0xaa, 0xa1, 0x4f, 0xac, 0xfe, 0x50, 0x99, 0xa8, 0x3f, 0x9e, 0x71, 0xd5, 0x12, 0x51, 0x9d, 0x5, 0x5f, 0x44, 0xf7, 0x57, 0x75, 0x7b, 0xce, 0xbb, 0xd2, 0x73, 0x4c, 0xb9, 0x1c, 0x5c, 0x4c, 0xe7, 0xb4, 0x11, 0xd1, 0xe8, 0x3b, 0x42, 0x68, 0x9f, 0xdf, 0x8a, 0x69, 0xe6, 0x3d, 0xdf, 0xd2, 0x55, 0xb9, 0x77, 0xd7, 0x43, 0x5b, 0xee, 0xb5, 0xde, 0xbb, 0xba, 0x7a, 0x47, 0xb1, 0x9c, 0xda, 0xb3, 0xf1, 0xc4, 0xe, 0x79, 0xb9, 0x26, 0xa4, 0x81, 0xa1, 0x62, 0x9a, 0x81, 0x85, 0x25, 0xc2, 0xa1, 0x98, 0x98, 0x3f, 0x23, 0xf0, 0xda, 0x5d, 0xa8, 0xb9, 0x96, 0x33, 0x68, 0x92, 0x92, 0x33, 0x2b, 0xcc, 0x2a, 0x4a, 0xd4, 0x97, 0x69, 0xb3, 0xe4, 0x48, 0xf8, 0xce, 0xdb, 0x87, 0xc1, 0xde, 0x2e, 0xf5, 0xd0, 0x4e, 0x1c, 0x3a, 0x81, 0x16, 0xc3, 0x32, 0x8f, 0x6b, 0x19, 0xb5, 0x9c, 0x31, 0x8e, 0x18, 0xf8, 0xdb, 0x29, 0x87, 0x5c, 0x22, 0xa0, 0xa0, 0xc8, 0xea, 0x61, 0x5a, 0x59, 0x34, 0x39, 0xf7, 0xb9, 0xa, 0xa2, 0xad, 0x9c, 0x16, 0xca, 0x57, 0x30, 0x40, 0xa8, 0x19, 0xa, 0x83, 0x43, 0x70, 0x37, 0x85, 0x54, 0xbd, 0xa9, 0xda, 0x94, 0x86, 0xaa, 0x3c, 0xe3, 0xf1, 0xb0, 0x1d, 0xba, 0x14, 0xb0, 0x32, 0xb3, 0xc3, 0x34, 0xf7, 0xa1, 0xe9, 0x61, 0x42, 0x63, 0x2, 0xed, 0x2d, 0x38, 0xc3, 0x4f, 0x61, 0xd7, 0xb4, 0xd1, 0x82, 0xc0, 0xca, 0x30, 0x3c, 0x2f, 0x37, 0x9e, 0x74, 0xea, 0xf6, 0x5a, 0x48, 0xd3, 0xd8, 0xa9, 0x56, 0x16, 0xb2, 0xab, 0xa5, 0xc8, 0x8d, 0xbf, 0x62, 0x84, 0xc5, 0xcd, 0x68, 0xd9, 0x2, 0xe3, 0x95, 0x8a, 0x7b, 0x95, 0x29, 0xf4, 0x9d, 0x38, 0x9, 0x1b, 0xac, 0x28, 0x87, 0x34, 0x24, 0x7f, 0xce, 0x88, 0x6d, 0x49, 0xbc, 0xe0, 0xa, 0xb9, 0x8b, 0x1b, 0x96, 0x2a, 0x8d, 0xa8, 0xb4, 0x71, 0x6, 0x44, 0xe9, 0xda, 0x41, 0x85, 0x29, 0xe7, 0x9a, 0x27, 0x40, 0x8b, 0x52, 0xeb, 0x65, 0x5f, 0xde, 0x2, 0x5a, 0x12, 0x9a, 0x38, 0xee, 0xeb, 0xa9, 0x36, 0x65, 0x7f, 0x72, 0x5f, 0xe, 0xc6, 0x68, 0x38, 0xb, 0x9d, 0xd5, 0xc, 0x7, 0x59, 0xac, 0x15, 0xf, 0x81, 0xb6, 0x96, 0xb8, 0x86, 0xe8, 0x6a, 0x54, 0x47, 0xcc, 0xdc, 0xb3, 0xfb, 0xec, 0x8, 0xc7, 0x94, 0x71, 0xdc, 0x31, 0x11, 0x4, 0x2f, 0xcf, 0xff, 0xad, 0xc1, 0xa9, 0x73, 0x34, 0xd, 0xd6, 0x86, 0x10, 0x63, 0x1f, 0xdd, 0xa6, 0xad, 0x25, 0x14, 0x8c, 0x2d, 0xb, 0x48, 0xad, 0xa2, 0x4e, 0x6b, 0x2d, 0x42, 0xea, 0x75, 0x10, 0x99, 0x1c, 0x4, 0x55, 0xba, 0x1b, 0x7f, 0x39, 0x3c, 0xa1, 0xfa, 0x58, 0x1, 0xf1, 0x82, 0xf8, 0x91, 0x17, 0x88, 0x54, 0x55, 0xdb, 0xf8, 0x8f, 0x63, 0xce, 0xb, 0x77, 0x66, 0x9b, 0xa9, 0x65, 0xb7, 0x3a, 0x34, 0x4d, 0x3c, 0x4c, 0x78, 0x7e, 0x3b, 0x4a, 0xaf, 0x58, 0xc5, 0x6f, 0xb2, 0x58, 0x99, 0x67, 0xc7, 0x19, 0x69, 0xb1, 0xfe, 0x92, 0xc5, 0xe7, 0xd9, 0x10, 0x94, 0xdb, 0xa8, 0x4f, 0x47, 0x4, 0x37, 0x33, 0x9c, 0x1d, 0xc6, 0x91, 0x8d, 0xd5, 0xfb, 0x83, 0x5c, 0xbe, 0x69, 0x75, 0x3, 0x63, 0x69, 0x1b, 0xc, 0xee, 0x7b, 0x80, 0xf0, 0xd0, 0xae, 0xb3, 0x1d, 0xdb, 0xda, 0xc5, 0x2f, 0x90, 0x4a, 0x3a, 0x91, 0x5, 0x1b, 0x54, 0xad, 0xf7, 0x5b, 0xd, 0x19, 0x57, 0x63, 0xd2, 0x9f, 0xd1, 0xb8, 0x82, 0x44, 0xf6, 0x1d, 0x6a, 0x30, 0x48, 0x7, 0xb6, 0x46, 0x32, 0x6e, 0x76, 0xfb, 0x88, 0xd, 0x1d, 0xf3, 0x72, 0x81, 0xa1, 0x1c, 0xed, 0x52, 0xd5, 0xb5, 0x87, 0x36, 0x68, 0x64, 0x2c, 0x72, 0xcd, 0x7c, 0x70, 0xe3, 0x68, 0x25, 0xcc, 0x17, 0xda, 0x6e, 0x3, 0xc5, 0x77, 0xd1, 0x2f, 0x79, 0xcc, 0xef, 0xd6, 0xb7, 0xb7, 0x6c, 0x88, 0xb1, 0x9f, 0x76, 0x6, 0x53, 0x67, 0x93, 0xd8, 0xd3, 0x3f, 0x7e, 0xa, 0x59, 0x87, 0x69, 0x88, 0x3b, 0x41, 0x7c, 0x36, 0x62, 0xb6, 0x26, 0x70, 0x1, 0xbe, 0x7d, 0x9, 0x14, 0x56, 0x3b, 0x24, 0x2, 0x14, 0x93, 0x57, 0xd1, 0xc6, 0x46, 0x80, 0xda, 0x80, 0xb3, 0x22, 0x7, 0xa6, 0x76, 0x11, 0xed, 0xf0, 0xe8, 0xd9, 0xa7, 0x67, 0xe2, 0xbe, 0x2a, 0xbb, 0x21, 0x95, 0x6f, 0xc7, 0x64, 0x20, 0x9, 0x45, 0xe4, 0xbc, 0x58, 0x30, 0xac, 0xcc, 0xdc, 0x80, 0xde, 0x48, 0x50, 0x86, 0x51, 0x4c, 0x63, 0xda, 0x7f, 0x78, 0x5c, 0xba, 0xc, 0x1e, 0x9c, 0xe5, 0xb2, 0x49, 0xb5, 0x2e, 0x7e, 0xe5, 0x70, 0xd8, 0x65, 0x7c, 0x63, 0xc4, 0xfc, 0x90, 0x85, 0x6d, 0xfb, 0xbb, 0x24, 0xc8, 0xd2, 0xa7, 0x11, 0xcb, 0x3a, 0x9, 0x60, 0x68, 0x5e, 0xc5, 0x55, 0x40, 0xf6, 0xec, 0x26, 0x41, 0xa4, 0x29, 0xd3, 0xdc, 0x99, 0xd8, 0x2f, 0x26, 0xd2, 0xc7, 0xea, 0xcc, 0x61, 0x4f, 0xfe, 0x98, 0x81, 0x17, 0xd8, 0xf1, 0x3b, 0x74, 0x42, 0xa9, 0xae, 0x29, 0x29, 0xd3, 0xe1, 0xf6, 0x7b, 0x97, 0x4b, 0xb4, 0xa4, 0xaa, 0x96, 0x0, 0x15, 0xc9, 0x21, 0x6a, 0xfa, 0x84, 0x4a, 0x24, 0x30, 0x95, 0xf1, 0x67, 0xb1, 0x14, 0x70, 0xf, 0xb1, 0x12, 0x15, 0xeb, 0x54, 0x35, 0x7b, 0xcb, 0x1d, 0x47, 0x92, 0xa0, 0xb6, 0x76, 0xc7, 0x8, 0xe7, 0x10, 0x21, 0x1c, 0x3a, 0xf7, 0x3d, 0x61, 0xb8, 0x2f, 0x4d, 0x4, 0xbc, 0x40, 0xc8, 0x98, 0xce, 0x0, 0xa2, 0xd3, 0x4c, 0x77, 0xf5, 0xe2, 0x2d, 0xb7, 0x1f, 0x46, 0xc9, 0x39, 0xa0, 0xec, 0x9c, 0x37, 0xd1, 0x64, 0x7e, 0x23, 0xa0, 0xf4, 0x4c, 0xc2, 0x3d, 0x71, 0xa, 0x1d, 0xb2, 0xe, 0x38, 0xd0, 0x9, 0xc6, 0x58, 0x1, 0x92, 0x29, 0x5c, 0x40, 0xb4, 0x78, 0xa8, 0x5a, 0x9, 0x30, 0x18, 0x1d, 0x9, 0x62, 0xc3, 0xb1, 0x8b, 0x6a, 0xac, 0x7f, 0x5b, 0xe9, 0x96, 0x7, 0xad, 0xd2, 0x5b, 0xbc, 0x23, 0xa7, 0x53, 0xe, 0x7e, 0x58, 0xc9, 0x3f, 0x9f, 0xd4, 0xaf, 0xe5, 0x13, 0x3f, 0xd2, 0x28, 0xc6, 0xb4, 0xd9, 0xe4, 0x35, 0x38, 0xcd, 0x9d, 0xcb, 0xe7, 0x6c, 0x4d, 0x7d, 0xed, 0xf2, 0x27, 0x41, 0x83, 0x95, 0x58, 0xa6, 0xb5, 0x61, 0x84, 0x73, 0x27, 0xdf, 0x7c, 0xff, 0x1c, 0x17, 0xe0, 0x3e, 0xb0, 0xed, 0x9d, 0xd9, 0x21, 0x97, 0x49, 0x54, 0x63, 0x8c, 0xad, 0xbf, 0x64, 0x5a, 0x4b, 0xaa, 0x4a, 0x62, 0x77, 0x4b, 0xa6, 0x6e, 0x2e, 0x45, 0x8a, 0x1f, 0x7a, 0xc6, 0x7e, 0xc3, 0x94, 0x42, 0x93, 0x39, 0xc2, 0xf6, 0x20, 0xd4, 0x57, 0xf5, 0xdd, 0x6, 0xae, 0x55, 0x1b, 0x69, 0xba, 0xdd, 0xee, 0x99, 0xa6, 0xc9, 0x3e, 0xdc, 0x7b, 0xf7, 0xcd, 0x56, 0x89, 0x8c, 0xec, 0x4a, 0xb4, 0xe6, 0x33, 0x48, 0x9d, 0xd1, 0x93, 0x4b, 0x3e, 0xab, 0x68, 0x60, 0x1e, 0x35, 0x60, 0x9, 0x2c, 0xb9, 0xb1, 0xc6, 0x4b, 0x90, 0xc9, 0xfb, 0xb6, 0xf6, 0x2b, 0xe6, 0xb, 0xe, 0x22, 0x1f, 0x1f, 0x6e, 0x1d, 0x58, 0x44, 0x4b, 0x73, 0x1b, 0x30, 0xab, 0x4, 0xc4, 0x9, 0x88, 0x9, 0x3f, 0xbd, 0x39, 0x6e, 0x65, 0xba, 0x70, 0x3f, 0x52, 0xac, 0xe0, 0x69, 0x50, 0x35, 0xee, 0x78, 0xe7, 0xa4, 0x96, 0x9d, 0x3e, 0xb5, 0x83, 0x4c, 0x58, 0xef, 0x60, 0xfe, 0xe1, 0xde, 0xf, 0xe, 0x3, 0xe4, 0x20, 0x3f, 0xf5, 0xf, 0x95, 0x7e, 0xd6, 0x85, 0x13, 0xf9, 0x13, 0x4a, 0x43, 0x32, 0xb5, 0x60, 0x44, 0xee, 0x14, 0xce, 0x80, 0xea, 0xd7, 0xce, 0x53, 0x2a, 0xca, 0x58, 0xb1, 0xf9, 0x84, 0x23, 0xc3, 0xca, 0xbd, 0x99, 0x21, 0xf8, 0x3a, 0x81, 0xc7, 0x46, 0x7b, 0x3c, 0x6f, 0x6d, 0xe4, 0xb1, 0x2a, 0xd7, 0x41, 0xc7, 0x34, 0x5b, 0xd6, 0x45, 0x85, 0x4b, 0xbf, 0x85, 0x9d, 0x11, 0xc, 0x8d, 0x60, 0xf5, 0x3a, 0xfe, 0x65, 0xf6, 0xa8, 0xa0, 0x85, 0x6b, 0xbf, 0x78, 0x95, 0x4f, 0x8e, 0xcc, 0x83, 0x1f, 0xbb, 0x43, 0xf0, 0x30, 0x44, 0x9a, 0x9f, 0xe7, 0x2a, 0x3c, 0x86, 0xab, 0x79, 0x62, 0xac, 0xd2, 0x89, 0x75, 0x53, 0xc, 0xb5, 0x67, 0xce, 0xa7, 0x13, 0xbe, 0x76, 0xb2, 0x26, 0x2a, 0x70, 0x89, 0x6b, 0x8a, 0x3c, 0xac, 0x66, 0x77, 0x2c, 0x56, 0xa9, 0xed, 0x13, 0x9f, 0x3f, 0x43, 0x49, 0x89, 0x8a, 0xec, 0xcd, 0xeb, 0xd5, 0x62, 0x2f, 0x32, 0xa7, 0x5e, 0xbb, 0xc9, 0xfe, 0x20, 0x2f, 0xe5, 0x6c, 0x95, 0x73, 0x56, 0xd4, 0xa, 0xfe, 0xe4, 0x71, 0x8c, 0x52, 0xd3, 0xf, 0xbf, 0x68, 0x3c, 0xe1, 0x70, 0x56, 0xe6, 0x72, 0xf9, 0x9, 0x11, 0xc, 0x8, 0x7d, 0x36, 0x1c, 0x19, 0x6f, 0xe3, 0x3c, 0x6d, 0x80, 0xdc, 0x69, 0x25, 0x76, 0x9f, 0x6a, 0x93, 0xdd, 0x41, 0xb5, 0xbb, 0x5f, 0xea, 0x80, 0x6f, 0x3b, 0xf5, 0x6c, 0x50, 0xd6, 0x9b, 0x45, 0xa3, 0x71, 0xac, 0x5d, 0xcf, 0x5c, 0xf3, 0x56, 0xbc, 0x55, 0x2e, 0xc, 0xf8, 0x7e, 0x22, 0xaf, 0xf, 0x12, 0x1b, 0x21, 0x27, 0x8b, 0x6, 0x71, 0x38, 0xe2, 0xaf, 0xa0, 0x98, 0xe7, 0xed, 0xe1, 0xc0, 0xa8, 0xab, 0x29, 0xb6, 0xcc, 0xf6, 0xb8, 0x5d, 0x39, 0xad, 0xb9, 0xce, 0xdd, 0x1, 0x38, 0x86, 0xd2, 0xc2, 0x3c, 0x27, 0x3a, 0x21, 0x26, 0x7b, 0x2f, 0x2c, 0x22, 0xb5, 0xbf, 0x25, 0xd5, 0xa5, 0xcb, 0xd0, 0x83, 0x68, 0x4b, 0x45, 0x4a, 0xb5, 0xfb, 0x85, 0x4f, 0x90, 0xcb, 0x49, 0xb2, 0xf5, 0x37, 0x95, 0xbb, 0xfd, 0x46, 0x34, 0x8b, 0x30, 0x95, 0x83, 0x98, 0x34, 0x4f, 0x9c, 0x36, 0x20, 0x40, 0xe1, 0x41, 0x2f, 0x33, 0x1e, 0x2d, 0xd1, 0x67, 0x9f, 0x31, 0xad, 0xbc, 0xf8, 0xd4, 0xb, 0xd3, 0xbf, 0x70, 0x7a, 0x4f, 0x35, 0x58, 0x23, 0x9a, 0xb, 0x94, 0x88, 0xb3, 0xd6, 0xa2, 0x64, 0xe6, 0xda, 0x39, 0x11, 0xb0, 0xbe, 0x47, 0xdf, 0xf3, 0x25, 0x7b, 0x19, 0x31, 0x29, 0xdd, 0xa9, 0xf3, 0xc0, 0xd9, 0xad, 0xeb, 0x16, 0x1f, 0x84, 0x26, 0xcc, 0xd0, 0x1a, 0xd2, 0xd0, 0x85, 0x4f, 0x73, 0x19, 0xe1, 0x2d, 0xf8, 0x9d, 0xa8, 0x8c, 0x98, 0xfb, 0xfe, 0xa9, 0x6d, 0x1f, 0x40, 0xbd, 0x9, 0x8a, 0xa4, 0x6b, 0xeb, 0x47, 0x18, 0x34, 0xb0, 0x39, 0xd6, 0xf0, 0x1, 0xf8, 0x4, 0xed, 0x3d, 0xc4, 0x7c, 0xde, 0x1, 0xd5, 0xb5, 0x94, 0xd5, 0x65, 0xd9, 0x4f, 0x70, 0xba, 0x73, 0x87, 0x82, 0x2d, 0xbe, 0x8d, 0xe, 0x44, 0x64, 0x5a, 0x91, 0x4f, 0x25, 0xd1, 0xd1, 0x5f, 0x38, 0xeb, 0x4e, 0x5c, 0x9b, 0x4f, 0x48, 0xc6, 0x14, 0x6d, 0xbe, 0xff, 0x8d, 0x36, 0xc1, 0x7e, 0x5e, 0x57, 0xa3, 0xf0, 0x7e, 0x56, 0x1a, 0xf3, 0x90, 0xed, 0xfa, 0x4e, 0x2c, 0xfe, 0xca, 0x19, 0x72, 0x2a, 0x3b, 0xee, 0xea, 0x23, 0x78, 0x2c, 0xd7, 0xaf, 0x8a, 0x61, 0x76, 0x7b, 0x1, 0xf, 0x89, 0xa7, 0x8, 0x2e, 0x4, 0xe8, 0x7, 0xf5, 0xce, 0xc4, 0x9b, 0xf5, 0xac, 0x71, 0xdb, 0x3d, 0xfd, 0xc5, 0x66, 0x5c, 0xd1, 0xfa, 0x5b, 0x9e, 0xb0, 0xc3, 0xc7, 0x34, 0x3c, 0x67, 0x47, 0x30, 0xec, 0x65, 0xa, 0x13, 0xba, 0xe4, 0x12, 0x12, 0x6c, 0x68, 0xda, 0xf9, 0x17, 0x86, 0x2a, 0xdb, 0x4e, 0x22, 0x4, 0x61, 0xa6, 0xcd, 0xc, 0x75, 0x11, 0xf4, 0xf3, 0x1c, 0x47, 0xf8, 0xa4, 0x1a, 0xc5, 0x4f, 0xc0, 0xb3, 0x4f, 0x7, 0xdc, 0x15, 0x6, 0xe, 0x9a, 0x43, 0x85, 0x5d, 0xa0, 0xa1, 0x62, 0x43, 0x6b, 0x1d, 0x3a, 0x4b, 0x6d, 0x8e, 0xa8, 0x72, 0x29, 0xfa, 0xec, 0xbb, 0xd9, 0xa2, 0xf0, 0x79, 0x22, 0x66, 0xdd, 0x16, 0xe, 0xf, 0x86, 0x71, 0x69, 0x4, 0x11, 0xf8, 0xa9, 0xbc, 0x74, 0x29, 0xf8, 0xe0, 0xf4, 0xeb, 0x0, 0x98, 0xe3, 0x3f, 0x5, 0x32, 0x5, 0x7d, 0x1e, 0x5, 0xe6, 0xa7, 0x8f, 0xf4, 0x8a, 0x6b, 0xdf, 0x78, 0x17, 0x6f, 0xb4, 0x62, 0xe5, 0x6b, 0x30, 0x54, 0x76, 0xa7, 0x8f, 0x9, 0x97, 0x86, 0xa6, 0x79, 0x3d, 0x2f, 0xc3, 0xf4, 0xf7, 0x4d, 0xab, 0xd3, 0xa3, 0x4b, 0xc2, 0xe5, 0x2, 0x67, 0xf0, 0x61, 0x57, 0x49, 0x4b, 0x99, 0x66, 0xe1, 0xbf, 0x1f, 0x87, 0x8, 0xcb, 0xb7, 0x70, 0x58, 0xc, 0xbb, 0x24, 0x67, 0xfc, 0x1b, 0x35, 0x95, 0x34, 0x5a, 0x49, 0xa5, 0xd8, 0xec, 0x52, 0x8f, 0x3e, 0x2b, 0x3f, 0x91, 0xb0, 0x6e, 0x6, 0x93, 0xf8, 0x7f, 0xda, 0x3b, 0x68, 0xcf, 0x99, 0xdf, 0x5c, 0x47, 0xbb, 0x18, 0xb7, 0x67, 0xfb, 0xe7, 0x4e, 0xc0, 0xb6, 0x64, 0xac, 0xf, 0x1c, 0xc6, 0x59, 0x2f, 0x1, 0xa5, 0x65, 0x9a, 0x7f, 0x3b, 0x42, 0x93, 0xbf, 0xb8, 0x54, 0x1f, 0xa, 0x9e, 0x3f, 0x92, 0x3a, 0x54, 0x7d, 0xd1, 0xc7, 0x84, 0xed, 0x62, 0x4c, 0xd3, 0xa2, 0xc9, 0xd1, 0xb8, 0xc3, 0x8, 0xb3, 0x23, 0x6e, 0x41, 0x46, 0xc9, 0x3c, 0xdc, 0x36, 0xe1, 0x7d, 0xfe, 0xda, 0x5c, 0x12, 0x3e, 0x73, 0x5a, 0xd4, 0xfe, 0xaa, 0xdc, 0xaa, 0xbf, 0x95, 0x81, 0xbc, 0x10, 0x60, 0x72, 0x6f, 0x54, 0x5c, 0x30, 0x8e, 0x56, 0xc7, 0x31, 0x0, 0x93, 0xf7, 0x93, 0x8a, 0x20, 0x83, 0xdc, 0x46, 0x8b, 0xf5, 0xff, 0x3c, 0x84, 0xc2, 0x27, 0x1e, 0xc7, 0x53, 0x38, 0x38, 0xff, 0x15, 0xe6, 0xf7, 0xee, 0x8c, 0x71, 0x11, 0x5e, 0xa8, 0xe3, 0x42, 0xbc, 0x33, 0xad, 0x64, 0x46, 0x76, 0x40, 0xb1, 0x1e, 0xfe, 0x5f, 0x33, 0xce, 0xcd, 0xee, 0x30, 0x58, 0xe8, 0xc1, 0x7f, 0x8c, 0xa0, 0x48, 0x89, 0x18, 0x50, 0x6f, 0xe2, 0xfa, 0x10, 0xb9, 0x2b, 0x9f, 0xa8, 0x7d, 0xd7, 0x30, 0x53, 0x62, 0xd2, 0x4d, 0x4c, 0xe4, 0x54, 0xa7, 0x79, 0x61, 0x2b, 0x11, 0x2c, 0x7c, 0x7e, 0x6d, 0x4b, 0x63, 0x2a, 0x84, 0x75, 0xed, 0xad, 0xbe, 0xa1, 0x34, 0x86, 0xcf, 0xaf, 0x56, 0x47, 0xe4, 0xdf, 0x1f, 0xb1, 0x35, 0xae, 0x79, 0x3f, 0x8e, 0x6d, 0x23, 0x21, 0x6b, 0xa, 0xdf, 0x66, 0x4a, 0x14, 0x39, 0x7d, 0xae, 0x7, 0xe1, 0x33, 0xa1, 0xa5, 0x8e, 0x15, 0xb2, 0x5e, 0x90, 0x92, 0xb6, 0x1f, 0xad, 0x36, 0x19, 0xbd, 0x55, 0x18, 0x58, 0x14, 0x4b, 0x80, 0xd9, 0x7, 0x5d, 0x34, 0x12, 0x8c, 0x35, 0x16, 0x43, 0xf1, 0x1, 0xba, 0xdd, 0xfa, 0x99, 0xc, 0xe9, 0x10, 0xf2, 0xa8, 0xd7, 0x21, 0xb6, 0x4c, 0x49, 0x5a, 0x12, 0xf0, 0x7a, 0xf3, 0xd3, 0x2c, 0xed, 0xac, 0x92, 0xe2, 0xd, 0xd9, 0x63, 0x8c, 0xd, 0xb3, 0x6e, 0xb7, 0xb1, 0x28, 0x61, 0x38, 0xfe, 0x5, 0x6e, 0xae, 0x9d, 0x91, 0xc4, 0xa0, 0xab, 0x7d, 0xc5, 0x26, 0x7f, 0xb1, 0x6a, 0x41, 0xb7, 0x71, 0xeb, 0x1, 0xd5, 0x47, 0x1, 0xfb, 0x43, 0x57, 0x4, 0x82, 0x15, 0x7b, 0xe1, 0xc, 0x6f, 0xa9, 0xe4, 0xd8, 0x66, 0xb8, 0xb5, 0xd6, 0x50, 0xee, 0x6f, 0x3f, 0xe1, 0x17, 0xb1, 0xfa, 0x79, 0xcb, 0xe4, 0xf8, 0xa9, 0xb9, 0x79, 0x28, 0xeb, 0xa2, 0xfc, 0xa6, 0xd7, 0x66, 0x9b, 0x38, 0x41, 0x84, 0x89, 0x5b, 0xfe, 0x76, 0xab, 0xf4, 0x84, 0xb0, 0x3b, 0x9f, 0x7c, 0xa1, 0x3, 0x8, 0xc6, 0xce, 0x31, 0x19, 0x7c, 0xa1, 0x5b, 0x1a, 0x36, 0xce, 0xdc, 0x37, 0x74, 0xb6, 0xb9, 0xdd, 0xcc, 0x24, 0x31, 0xe7, 0x32, 0xdb, 0x36, 0x53, 0x7f, 0x1f, 0x4f, 0x48, 0x83, 0xe8, 0x1e, 0x7b, 0x3c, 0x6d, 0x36, 0x8b, 0x4e, 0xbd, 0xce, 0x34, 0xc6, 0x57, 0x71, 0x1d, 0x2c, 0xbb, 0x41, 0x58, 0xd5, 0x19, 0xe0, 0x27, 0xc5, 0xb4, 0xb6, 0x45, 0x75, 0xaf, 0xcd, 0x87, 0xce, 0x73, 0x6c, 0x45, 0x2, 0x8d, 0x37, 0x8d, 0x70, 0xc0, 0xfd, 0xe7, 0x3b, 0x54, 0x99, 0xff, 0xb3, 0x7, 0xb9, 0xdd, 0x82, 0x7, 0x38, 0x33, 0xc0, 0xa8, 0x47, 0x69, 0x96, 0x4f, 0xbd, 0x7d, 0x1, 0xc4, 0xec, 0xe8, 0x5, 0xe1, 0x22, 0x36, 0x4b, 0x2b, 0x48, 0x5b, 0x6d, 0xac, 0x77, 0x93, 0xf1, 0xee, 0x7f, 0x1c, 0xb2, 0xa5, 0xa, 0xe6, 0x56, 0x5c, 0xd2, 0x10, 0x30, 0x82, 0x60, 0xef, 0x64, 0xd9, 0xb2, 0xfe, 0x83, 0x78, 0x51, 0x6a, 0xd0, 0x93, 0x96, 0xd, 0x5c, 0xa8, 0xcf, 0xa9, 0xfc, 0xf2, 0x87, 0x62, 0x99, 0x80, 0x20, 0x74, 0x30, 0x86, 0xb9, 0x3e, 0xed, 0xec, 0x32, 0x47, 0x84, 0x42, 0x8e, 0xba, 0x23, 0x14, 0x14, 0x66, 0x18, 0x5c, 0x74, 0x0, 0x55, 0xb1, 0xe8, 0x7b, 0xf7, 0xf6, 0xbe, 0xf5, 0xce, 0x8e, 0x28, 0xdd, 0x27, 0xf, 0x9d, 0xa6, 0x4d, 0x6f, 0xff, 0x2c, 0xb0, 0xd7, 0x3a, 0x73, 0x4d, 0x45, 0xdc, 0x56, 0xcd, 0x3, 0xbe, 0x94, 0x14, 0xdb, 0x56, 0x8e, 0xe2, 0x36, 0x6f, 0x21, 0x66, 0xfd, 0x6d, 0x43, 0xaf, 0x9e, 0xee, 0xcb, 0x13, 0xc4, 0xa5, 0xd3, 0xa8, 0xe7, 0x75, 0xbe, 0xe5, 0x94, 0x21, 0x94, 0x3, 0x3a, 0xe3, 0xee, 0x17, 0x54, 0xfc, 0x4, 0x6b, 0xe9, 0x11, 0x30, 0x97, 0x9a, 0xb8, 0x8e, 0x47, 0xa4, 0xce, 0xa3, 0x79, 0xed, 0x9e, 0x77, 0xbc, 0x43, 0x10, 0xdd, 0xae, 0x2b, 0xdb, 0x7a, 0x5b, 0x94, 0x1e, 0x3f, 0xb6, 0x8, 0x1c, 0xc3, 0xed, 0x71, 0xe, 0xc, 0x60, 0x3d, 0x47, 0xef, 0xa8, 0x2f, 0xcc, 0xc0, 0xd5, 0x56, 0xd4, 0xab, 0x58, 0x82, 0x5e, 0xbe, 0x6e, 0xc7, 0x70, 0xf, 0x2, 0xfb, 0x7a, 0xe, 0xed, 0x44, 0xcd, 0x2f, 0x87, 0x72, 0xcc, 0xde, 0xe4, 0xba, 0x4b, 0x88, 0x3d, 0xaa, 0xb4, 0x62, 0x64, 0xa5, 0x69, 0xaa, 0xae, 0x97, 0xa0, 0xe4, 0x36, 0x9e, 0xc0, 0xf, 0x59, 0xd8, 0x41, 0xa1, 0xa7, 0xcf, 0x2d, 0x39, 0xbc, 0x58, 0x72, 0x5b, 0x24, 0x8c, 0x7b, 0x15, 0x9d, 0x6d, 0x68, 0xb3, 0xd9, 0x72, 0x12, 0x31, 0xca, 0xca, 0xad, 0x38, 0xf2, 0x6f, 0x35, 0x7b, 0xfd, 0x31, 0xff, 0xce, 0xc1, 0x8c, 0xf3, 0x4e, 0xe4, 0x2c, 0x3b, 0x37, 0x5c, 0x82, 0x7c, 0x42, 0x84, 0xb3, 0x1f, 0xcd, 0x43, 0x74, 0xcf, 0xe8, 0xc2, 0xc7, 0xa6, 0xb9, 0x52, 0x58, 0x1c, 0x98, 0x37, 0x58, 0x7c, 0xb1, 0x61, 0xee, 0xca, 0x23, 0x72, 0x90, 0xaf, 0xe8, 0x9, 0x5e, 0x6, 0x9a, 0x99, 0x51, 0x4d, 0xfa, 0xfc, 0x2f, 0xd8, 0xcf, 0xc7, 0x34, 0xb4, 0xae, 0x64, 0x80, 0x7d, 0x3a, 0xca, 0x26, 0x81, 0xad, 0xe0, 0xfa, 0x1, 0x8b, 0x17, 0xd2, 0xa6, 0x1f, 0x30, 0xf0, 0x30, 0x7a, 0xe8, 0x6d, 0x67, 0xd4, 0xa1, 0x4d, 0x9c, 0xe2, 0x14, 0xcf, 0x41, 0xed, 0xb7, 0x2, 0x73, 0x5f, 0x99, 0xd5, 0x8b, 0xda, 0xce, 0x7f, 0x28, 0xc7, 0xd9, 0x5a, 0x9c, 0xae, 0x8b, 0x7, 0x97, 0x8, 0xc6, 0xc7, 0xe7, 0x8a, 0xcc, 0xab, 0x67, 0xf6, 0x7a, 0x59, 0x8f, 0x7c, 0x86, 0xfe, 0x8b, 0x8a, 0xb6, 0x53, 0x9b, 0x2e, 0xbb, 0x37, 0x6b, 0x6a, 0x17, 0x14, 0x4a, 0x3a, 0xda, 0xd6, 0xbe, 0x5d, 0x61, 0x7d, 0x30, 0x60, 0x7a, 0xb4, 0xd9, 0x4c, 0x11, 0xa7, 0xc1, 0x85, 0x8e, 0x19, 0xb5, 0xc7, 0xb1, 0x2f, 0x9b, 0xe4, 0xac, 0x24, 0x5a, 0x9e, 0x91, 0xa2, 0x2e, 0xe5, 0x47, 0x1a, 0xa5, 0x85, 0x38, 0xaf, 0xb3, 0x53, 0x19, 0xf5, 0x3d, 0x6d, 0xd6, 0x9b, 0xc2, 0xae, 0x48, 0xd2, 0xb6, 0x49, 0xdf, 0xf6, 0xe7, 0x1d, 0xea, 0x3b, 0x79, 0x7c, 0x7, 0x1a, 0xc, 0x34, 0x5f, 0x66, 0xdf, 0x5, 0x34, 0x75, 0xa4, 0x0, 0x31, 0xf3, 0x23, 0x90, 0x8c, 0x71, 0xa1, 0x98, 0xc7, 0xfb, 0x2d, 0x54, 0x2a, 0xa8, 0xdd, 0x97, 0xb2, 0xf1, 0xce, 0x1, 0xd1, 0x1e, 0x7f, 0xc4, 0x58, 0x51, 0x8c, 0xe1, 0xcb, 0x45, 0x1b, 0xb9, 0xb1, 0xd5, 0x75, 0x30, 0xd1, 0x5e, 0xc9, 0x5b, 0xa7, 0x3b, 0xd5, 0xa3, 0x86, 0x94, 0x7f, 0xf8, 0xd0, 0xf5, 0x65, 0x54, 0x9a, 0x11, 0xb8, 0x87, 0x59, 0xd6, 0xab, 0xa3, 0xa8, 0x39, 0x67, 0xbf, 0x95, 0x43, 0xe6, 0x40, 0xa3, 0x3f, 0x6f, 0x9d, 0x96, 0x55, 0xa5, 0x47, 0x78, 0x5b, 0x42, 0xb1, 0x12, 0x16, 0xec, 0x1c, 0xce, 0x6, 0x76, 0x30, 0xe8, 0x97, 0x8, 0xca, 0x89, 0x67, 0x33, 0x12, 0x9d, 0xb5, 0x31, 0x21, 0x69, 0x0, 0x3b, 0x8f, 0xac, 0xb8, 0xde, 0x3f, 0x99, 0xe6, 0x54, 0x27, 0xae, 0xf5, 0x1c, 0xc1, 0xc9, 0x10, 0x5, 0xbb, 0x7f, 0x5b, 0x65, 0x21, 0x8b, 0x1b, 0x49, 0x2f, 0xdd, 0x67, 0x76, 0x1e, 0xf, 0x7c, 0x2f, 0xc6, 0xf, 0x7e, 0xca, 0x13, 0xb0, 0x9d, 0xf6, 0xb2, 0xa5, 0x3b, 0x5b, 0x9c, 0xea, 0xb4, 0x3d, 0x5a, 0x1e, 0xc3, 0x26, 0xa, 0x89, 0xb5, 0x4b, 0xc2, 0x57, 0x85, 0xf, 0x6, 0x59, 0xe3, 0x24, 0xd, 0xaf, 0x7, 0x3c, 0xc5, 0x23, 0x6f, 0x65, 0xb1, 0x59, 0xcf, 0x8f, 0xde, 0xc7, 0x71, 0x91, 0x1c, 0x5, 0x4b, 0xb4, 0x17, 0xf6, 0x79, 0x93, 0x30, 0xd4, 0x43, 0xa7, 0x35, 0x70, 0x4e, 0x66, 0xea, 0x9f, 0x1d, 0x33, 0x51, 0x83, 0x71, 0x97, 0xc1, 0x9e, 0x82, 0x26, 0xd2, 0x7a, 0x1e, 0xb5, 0xb6, 0x64, 0x78, 0x1c, 0xf0, 0x65, 0x12, 0x31, 0xab, 0x25, 0x67, 0x8a, 0x4c, 0x9f, 0x99, 0x73, 0xda, 0x83, 0xe, 0xd3, 0x87, 0x1a, 0x6e, 0xe6, 0x38, 0xdd, 0xa3, 0xc7, 0x89, 0xb0, 0xac, 0x27, 0xdf, 0x49, 0x71, 0x7c, 0xa2, 0xa1, 0xdf, 0x46, 0x96, 0x8d, 0x56, 0x3, 0x5e, 0xf0, 0x2b, 0x71, 0x2d, 0x12, 0x6, 0x7e, 0x72, 0xb1, 0xe6, 0x61, 0x12, 0xf, 0xc1, 0xfd, 0xe4, 0xfe, 0x6b, 0x11, 0xbb, 0x4d, 0x18, 0x9f, 0x29, 0x11, 0x2d, 0xbb, 0xd6, 0xdd, 0xd, 0x9e, 0x4e, 0x78, 0x50, 0x1c, 0x8e, 0x5e, 0xee, 0xcc, 0x33, 0x3b, 0x20, 0x8d, 0x7b, 0x86, 0x52, 0x2c, 0x61, 0xde, 0x4e, 0xd0, 0xd4, 0x45, 0x4d, 0x19, 0xca, 0x62, 0x2, 0x76, 0x27, 0x34, 0x4f, 0x45, 0x5c, 0x5, 0xf4, 0x29, 0xfa, 0x17, 0xe4, 0xa6, 0xf0, 0xba, 0xfc, 0xd4, 0xb5, 0x75, 0xcb, 0xa3, 0x75, 0x5b, 0x4, 0x23, 0x82, 0x94, 0x21, 0x90, 0xb6, 0xea, 0xf7, 0x62, 0xdf, 0x77, 0x14, 0x79, 0x7e, 0x91, 0x6d, 0x58, 0xe7, 0xdd, 0xd, 0xe2, 0xcf, 0xc4, 0x1d, 0x8e, 0x6e, 0x41, 0xd, 0xe6, 0x23, 0xea, 0x5c, 0x54, 0x73, 0x34, 0xd3, 0xa2, 0x14, 0x88, 0xcd, 0x2d, 0x65, 0xe6, 0xf9, 0xe0, 0xf1, 0x23, 0x16, 0x6f, 0xd8, 0x30, 0x43, 0x9, 0xd0, 0x16, 0xb, 0x5a, 0x60, 0x53, 0x17, 0xe0, 0x12, 0x23, 0x8, 0xf9, 0xff, 0x6, 0x5a, 0xe6, 0xed, 0x42, 0x24, 0x37, 0xc9, 0x62, 0xa1, 0x36, 0x2e, 0xc1, 0xf2, 0x80, 0x4b, 0x27, 0x4e, 0x3b, 0xae, 0x11, 0x82, 0x92, 0xff, 0x93, 0xb, 0xd5, 0x19, 0xef, 0xd3, 0xa9, 0x3e, 0x40, 0xf9, 0x49, 0xab, 0xc6, 0xe, 0x8e, 0x91, 0x90, 0xda, 0xaf, 0x9f, 0xc8, 0x9, 0x9a, 0x44, 0x31, 0x18, 0x61, 0xb0, 0x2f, 0xfb, 0x4f, 0x9a, 0xa, 0xea, 0x81, 0x99, 0x91, 0x70, 0xed, 0x5b, 0xd1, 0x4b, 0x72, 0x7b, 0x42, 0xeb, 0x44, 0xb0, 0xb5, 0x59, 0x83, 0xf1, 0xac, 0x2f, 0x2b, 0xa8, 0x7, 0x34, 0x63, 0xd, 0x6b, 0x75, 0x0, 0xd6, 0x5e, 0xab, 0x42, 0xf6, 0x77, 0x1e, 0xea, 0x68, 0x72, 0x67, 0x7e, 0x25, 0x2d, 0xa4, 0xc7, 0x17, 0xba, 0xa0, 0x77, 0x60, 0xbf, 0xc5, 0xfe, 0x9, 0xd4, 0x83, 0x5a, 0x65, 0x20, 0xa, 0x80, 0xc2, 0x75, 0x9a, 0x47, 0x6a, 0x93, 0xb, 0x7f, 0xb4, 0xa7, 0x38, 0x24, 0x1c, 0x3e, 0x73, 0xa9, 0xc7, 0x5d, 0x5a, 0x7f, 0xa, 0xb, 0xe5, 0x21, 0x38, 0xdd, 0xa2, 0x81, 0x2a, 0xef, 0xba, 0x8f, 0xd7, 0x8d, 0x58, 0x40, 0xe6, 0xea, 0x1d, 0x15, 0xc5, 0x7e, 0xa6, 0x6a, 0x59, 0xb3, 0xa8, 0x82, 0xa8, 0xfd, 0x4, 0x9, 0x3a, 0x58, 0x15, 0xa5, 0x32, 0x4b, 0xe7, 0x5c, 0x4f, 0x83, 0xcf, 0x16, 0xb7, 0x85, 0xd2, 0xd3, 0xbd, 0x36, 0x60, 0x2a, 0x0, 0x26, 0xa9, 0x89, 0x5c, 0xb3, 0x43, 0x68, 0x8e, 0xea, 0x40, 0xcd, 0xb4, 0x83, 0xed, 0xcd, 0x87, 0x78, 0x8b, 0x66, 0x8a, 0x69, 0xd0, 0xbc, 0x75, 0xb0, 0x7d, 0x8c, 0x82, 0x47, 0xa9, 0x78, 0xe, 0x4c, 0x1e, 0xc3, 0x42, 0xc1, 0x19, 0x82, 0x95, 0xd6, 0x99, 0xf0, 0x82, 0x9e, 0x41, 0xa7, 0x8f, 0xf, 0x99, 0x78, 0xdd, 0x52, 0xd6, 0x49, 0x18, 0x98, 0xf1, 0xf0, 0x5b, 0x97, 0x9e, 0x58, 0x7f, 0x71, 0x1d, 0xf6, 0x6f, 0x38, 0xc2, 0x3c, 0x2b, 0xff, 0x9c, 0x69, 0x8, 0x6a, 0xb9, 0x70, 0xc4, 0x68, 0x31, 0x5b, 0x3b, 0x6c, 0x36, 0xd5, 0x8a, 0x7a, 0xe9, 0xc7, 0x49, 0xfa, 0x6, 0x42, 0x9e, 0x67, 0x81, 0xae, 0x7d, 0x49, 0xb3, 0xb3, 0x68, 0x4, 0x86, 0x41, 0xa6, 0x3d, 0xb9, 0x5e, 0xe2, 0x93, 0xa1, 0x95, 0x42, 0x1, 0xca, 0xd7, 0x2e, 0x92, 0xa8, 0x5e, 0x34, 0xc7, 0xa7, 0x4b, 0x2f, 0xd1, 0xbc, 0xa6, 0xaa, 0x61, 0x43, 0x5a, 0xf2, 0xdc, 0x32, 0xc1, 0xa2, 0xf5, 0x59, 0xf6, 0x3e, 0x71, 0x6a, 0x6c, 0x96, 0xf0, 0x76, 0x9, 0x7e, 0x6c, 0x45, 0xf4, 0x37, 0x2a, 0xe6, 0x82, 0x8e, 0x9e, 0xaa, 0xe3, 0xeb, 0x82, 0x36, 0x17, 0x10, 0xec, 0x14, 0xf6, 0x7f, 0x7d, 0xe, 0xd9, 0x85, 0x92, 0x49, 0xc1, 0x8d, 0x14, 0x98, 0x53, 0x2, 0x84, 0x7f, 0xc8, 0xf3, 0x30, 0x1b, 0xd3, 0x1c, 0x7e, 0x1e, 0x9, 0xb2, 0x5, 0x7e, 0x9e, 0xe4, 0x6f, 0xcc, 0x7c, 0x9b, 0xd8, 0xdb, 0x59, 0xeb, 0xd, 0xeb, 0xb, 0x1d, 0x8d, 0x29, 0x15, 0x8, 0xcb, 0x38, 0x37, 0xc9, 0xb2, 0xf1, 0x91, 0xa4, 0x95, 0x95, 0xd6, 0xaa, 0xdd, 0xce, 0xfe, 0xf0, 0xdd, 0x59, 0xed, 0x3a, 0x5, 0xfa, 0x8f, 0x6e, 0xf0, 0x3d, 0x38, 0xf5, 0x34, 0x13, 0x9d, 0x56, 0xbc, 0xbd, 0x4b, 0xc3, 0x25, 0x6e, 0x1a, 0x12, 0xd, 0x49, 0xa5, 0xdb, 0x1b, 0xad, 0xb5, 0x28, 0xb0, 0x25, 0x6c, 0x61, 0xa2, 0xf1, 0x79, 0xa2, 0x3c, 0x49, 0x92, 0x87, 0x38, 0xf9, 0xc0, 0xfa, 0x81, 0xfc, 0x19, 0x6d, 0x1a, 0x74, 0x50, 0x79, 0x98, 0x41, 0x5f, 0x7, 0xe, 0xf9, 0xc3, 0x8b, 0xaa, 0x53, 0x95, 0x1f, 0xee, 0x7b, 0x68, 0x0, 0x8b, 0xc6, 0x75, 0xe0, 0xe1, 0x5b, 0xc3, 0x2a, 0x61, 0xc3, 0xb, 0xc1, 0x32, 0xe7, 0x9c, 0x58, 0xa3, 0xa9, 0x70, 0xff, 0xdd, 0xb8, 0xb8, 0x6, 0x78, 0x2d, 0xd3, 0x12, 0x42, 0xb3, 0xc3, 0xcf, 0x98, 0x10, 0xbe, 0xea, 0x5f, 0xb5, 0xa1, 0xb2, 0x50, 0xea, 0x62, 0x33, 0x64, 0x56, 0xe7, 0x69, 0x4b, 0x4c, 0x82, 0x95, 0x8, 0xc7, 0xdb, 0xfe, 0x9, 0xa, 0xf6, 0xa8, 0x50, 0xf7, 0x9d, 0x4, 0xd2, 0xc6, 0x98, 0x63, 0x78, 0x16, 0x1, 0x7f, 0x8a, 0x92, 0xe, 0x1b, 0x1a, 0xde, 0x23, 0x6e, 0x22, 0x7b, 0x34, 0x80, 0x89, 0x9b, 0xcb, 0xb9, 0x91, 0xf6, 0xc6, 0xc2, 0x40, 0xbb, 0xd4, 0x11, 0x4a, 0xaf, 0x98, 0x75, 0x93, 0x55, 0x58, 0x39, 0x4a, 0x48, 0x66, 0x52, 0xb0, 0x94, 0x2f, 0x34, 0x9, 0xb6, 0x6f, 0xaf, 0x8b, 0x8b, 0xf7, 0x11, 0xcc, 0x8c, 0x34, 0xcc, 0xa4, 0x1b, 0x8e, 0x16, 0xc2, 0xcd, 0xf0, 0x16, 0xb, 0x92, 0xa3, 0x32, 0xc1, 0xf0, 0x4b, 0xc6, 0x45, 0x82, 0x44, 0x6b, 0x98, 0xaf, 0xf3, 0x41, 0x89, 0x67, 0x5b, 0x7a, 0x10, 0xff, 0xc6, 0xf1, 0x3b, 0x3f, 0x74, 0x65, 0x4e, 0xd7, 0xc0, 0x59, 0xd, 0x4a, 0xf7, 0xf4, 0xd7, 0x47, 0xbf, 0x89, 0xbb, 0x2a, 0x8f, 0x5c, 0x8c, 0xe6, 0x10, 0xcf, 0x4f, 0xa4, 0xab, 0x71, 0x4a, 0x84, 0x5e, 0x15, 0x64, 0x9b, 0x53, 0xe5, 0x4a, 0x95, 0x21, 0x3d, 0x5a, 0x73, 0x90, 0x59, 0x41, 0xd9, 0x46, 0x7b, 0xb, 0xed, 0xda, 0x2b, 0xec, 0xc1, 0xc2, 0x19, 0xe1, 0xca, 0xb6, 0x99, 0x65, 0x2d, 0x85, 0xb8, 0xcd, 0x7e, 0xc, 0xd1, 0x1c, 0xe5, 0xb0, 0xca, 0xc7, 0x6f, 0x9e, 0xf3, 0xd7, 0x4b, 0xd8, 0x29, 0x87, 0x78, 0x98, 0xe7, 0x35, 0xc, 0xca, 0x72, 0x10, 0x10, 0x76, 0xa9, 0x70, 0xbe, 0xc6, 0x75, 0x6c, 0x3f, 0xd1, 0xaa, 0xf3, 0x39, 0x6f, 0x72, 0x83, 0x3f, 0x8d, 0x4e, 0x71, 0x6a, 0xec, 0x6f, 0x93, 0x71, 0x8b, 0x26, 0x27, 0x10, 0xb0, 0xda, 0x2f, 0x3f, 0xd6, 0xcb, 0xdb, 0x20, 0x4e, 0xd0, 0xe9, 0x1d, 0x65, 0xca, 0xb3, 0x9e, 0xd3, 0x5f, 0x22, 0xa0, 0x1e, 0x5d, 0x50, 0x92, 0x82, 0x75, 0x28, 0x37, 0xeb, 0xee, 0x96, 0x8b, 0x14, 0x9, 0x89, 0xef, 0x5f, 0x4d, 0x51, 0x34, 0x52, 0x78, 0x4b, 0xdb, 0x89, 0x2c, 0xaf, 0xd8, 0x38, 0x7e, 0x5, 0xb3, 0x1, 0x2c, 0x4, 0x58, 0xa3, 0x69, 0xe6, 0x21, 0x91, 0xf5, 0xbd, 0xc5, 0x7d, 0xd6, 0x3c, 0xe4, 0x2e, 0x94, 0x5f, 0x49, 0x3c, 0x2b, 0x42, 0x30, 0x6b, 0x80, 0x84, 0xf3, 0xb2, 0x5e, 0x94, 0xab, 0xac, 0xf0, 0x8e, 0xe1, 0x55, 0xf3, 0x62, 0x1a, 0xcc, 0x96, 0x26, 0xee, 0x48, 0x7c, 0x7a, 0x7e, 0x46, 0x67, 0xf0, 0x37, 0x7a, 0xe4, 0xb2},
+               output224: []byte{0xba, 0xdf, 0x58, 0xa, 0x48, 0x5b, 0x27, 0x90, 0x58, 0x18, 0x3b, 0x4d, 0x53, 0x75, 0x5f, 0xba, 0xa8, 0x88, 0x9d, 0x34, 0xb0, 0x41, 0x61, 0x9b, 0xc2, 0x92, 0xe8, 0xd0},
+               output256: []byte{0x86, 0xec, 0x53, 0x42, 0xab, 0x76, 0x7, 0x10, 0x35, 0x47, 0x98, 0x5b, 0xd8, 0x32, 0xa2, 0x71, 0x42, 0x6a, 0xcd, 0xe8, 0xdc, 0xac, 0x94, 0x1a, 0xa7, 0xc4, 0xff, 0x17, 0xcf, 0xb1, 0x76, 0x2},
+               output384: []byte{0xbe, 0x96, 0x4d, 0x9a, 0xf6, 0x7d, 0x2a, 0x10, 0x60, 0x2d, 0xdc, 0x5f, 0x5e, 0x5c, 0x79, 0xd2, 0x39, 0x51, 0x11, 0x2c, 0x56, 0x24, 0x6e, 0xc7, 0x59, 0x31, 0xd9, 0xdf, 0xb3, 0xf0, 0xb0, 0x6d, 0xe4, 0x47, 0x88, 0x38, 0xda, 0xd9, 0xde, 0x9f, 0x8c, 0x76, 0xfe, 0xf0, 0xaa, 0xa7, 0xc6, 0x28},
+               output512: []byte{0xdb, 0xd1, 0x99, 0x4, 0x88, 0x1f, 0x49, 0x12, 0xf9, 0x9e, 0xc3, 0x9b, 0x67, 0x3, 0x72, 0x70, 0x36, 0xc7, 0x67, 0xd2, 0x9, 0x7b, 0x9d, 0x14, 0x60, 0xb4, 0x83, 0xfb, 0x18, 0x2, 0xce, 0x5f, 0x6f, 0x5d, 0xe3, 0x83, 0xa3, 0xcf, 0x40, 0x67, 0x9d, 0x2a, 0x64, 0x15, 0xfe, 0x6e, 0xed, 0x2e, 0xbb, 0xff, 0xa3, 0xa5, 0xbd, 0xd4, 0x25, 0x29, 0x5b, 0xe, 0xbc, 0xf9, 0x81, 0xad, 0x1d, 0x3e}},
+}

diff --git a/vendor/github.com/gxed/hashland/keccakpg/package.json b/vendor/github.com/gxed/hashland/keccakpg/package.json
new file mode 100644 (file)
index 0000000..9bc01c5
--- /dev/null
+++ b/vendor/github.com/gxed/hashland/keccakpg/package.json
@@ -0,0 +1,14 @@
+{
+  "author": "whyrusleeping",
+  "bugs": {},
+  "gx": {
+    "dvcsimport": "github.com/gxed/hashland/keccakpg"
+  },
+  "gxVersion": "0.10.0",
+  "language": "go",
+  "license": "",
+  "name": "keccakpg",
+  "releaseCmd": "git commit -a -m \"gx publish $VERSION\"",
+  "version": "0.0.1"
+}
+

diff --git a/vendor/github.com/gxed/hashland/murmur3/LICENSE b/vendor/github.com/gxed/hashland/murmur3/LICENSE
new file mode 100644 (file)
index 0000000..2a46fd7
--- /dev/null
+++ b/vendor/github.com/gxed/hashland/murmur3/LICENSE
@@ -0,0 +1,24 @@
+Copyright 2013, Sébastien Paolacci.
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+    * Redistributions of source code must retain the above copyright
+      notice, this list of conditions and the following disclaimer.
+    * Redistributions in binary form must reproduce the above copyright
+      notice, this list of conditions and the following disclaimer in the
+      documentation and/or other materials provided with the distribution.
+    * Neither the name of the library nor the
+      names of its contributors may be used to endorse or promote products
+      derived from this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL <COPYRIGHT HOLDER> BE LIABLE FOR ANY
+DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

diff --git a/vendor/github.com/gxed/hashland/murmur3/README.md b/vendor/github.com/gxed/hashland/murmur3/README.md
new file mode 100644 (file)
index 0000000..1edf623
--- /dev/null
+++ b/vendor/github.com/gxed/hashland/murmur3/README.md
@@ -0,0 +1,84 @@
+murmur3
+=======
+
+Native Go implementation of Austin Appleby's third MurmurHash revision (aka
+MurmurHash3).
+
+Reference algorithm has been slightly hacked as to support the streaming mode
+required by Go's standard [Hash interface](http://golang.org/pkg/hash/#Hash).
+
+
+Benchmarks
+----------
+
+Go tip as of 2014-06-12 (i.e almost go1.3), core i7 @ 3.4 Ghz. All runs
+include hasher instantiation and sequence finalization.
+
+<pre>
+
+Benchmark32_1        500000000     7.69 ns/op      130.00 MB/s
+Benchmark32_2        200000000     8.83 ns/op      226.42 MB/s
+Benchmark32_4        500000000     7.99 ns/op      500.39 MB/s
+Benchmark32_8        200000000     9.47 ns/op      844.69 MB/s
+Benchmark32_16       100000000     12.1 ns/op     1321.61 MB/s
+Benchmark32_32       100000000     18.3 ns/op     1743.93 MB/s
+Benchmark32_64        50000000     30.9 ns/op     2071.64 MB/s
+Benchmark32_128       50000000     57.6 ns/op     2222.96 MB/s
+Benchmark32_256       20000000      116 ns/op     2188.60 MB/s
+Benchmark32_512       10000000      226 ns/op     2260.59 MB/s
+Benchmark32_1024       5000000      452 ns/op     2263.73 MB/s
+Benchmark32_2048       2000000      891 ns/op     2296.02 MB/s
+Benchmark32_4096       1000000     1787 ns/op     2290.92 MB/s
+Benchmark32_8192        500000     3593 ns/op     2279.68 MB/s
+Benchmark128_1       100000000     26.1 ns/op       38.33 MB/s
+Benchmark128_2       100000000     29.0 ns/op       69.07 MB/s
+Benchmark128_4        50000000     29.8 ns/op      134.17 MB/s
+Benchmark128_8        50000000     31.6 ns/op      252.86 MB/s
+Benchmark128_16      100000000     26.5 ns/op      603.42 MB/s
+Benchmark128_32      100000000     28.6 ns/op     1117.15 MB/s
+Benchmark128_64       50000000     35.5 ns/op     1800.97 MB/s
+Benchmark128_128      50000000     50.9 ns/op     2515.50 MB/s
+Benchmark128_256      20000000     76.9 ns/op     3330.11 MB/s
+Benchmark128_512      20000000      135 ns/op     3769.09 MB/s
+Benchmark128_1024     10000000      250 ns/op     4094.38 MB/s
+Benchmark128_2048      5000000      477 ns/op     4290.75 MB/s
+Benchmark128_4096      2000000      940 ns/op     4353.29 MB/s
+Benchmark128_8192      1000000     1838 ns/op     4455.47 MB/s
+
+</pre>
+
+
+<pre>
+
+benchmark              Go1.0 MB/s    Go1.1 MB/s  speedup    Go1.2 MB/s  speedup    Go1.3 MB/s  speedup
+Benchmark32_1               98.90        118.59    1.20x        114.79    0.97x        130.00    1.13x
+Benchmark32_2              168.04        213.31    1.27x        210.65    0.99x        226.42    1.07x
+Benchmark32_4              414.01        494.19    1.19x        490.29    0.99x        500.39    1.02x
+Benchmark32_8              662.19        836.09    1.26x        836.46    1.00x        844.69    1.01x
+Benchmark32_16             917.46       1304.62    1.42x       1297.63    0.99x       1321.61    1.02x
+Benchmark32_32            1141.93       1737.54    1.52x       1728.24    0.99x       1743.93    1.01x
+Benchmark32_64            1289.47       2039.51    1.58x       2038.20    1.00x       2071.64    1.02x
+Benchmark32_128           1299.23       2097.63    1.61x       2177.13    1.04x       2222.96    1.02x
+Benchmark32_256           1369.90       2202.34    1.61x       2213.15    1.00x       2188.60    0.99x
+Benchmark32_512           1399.56       2255.72    1.61x       2264.49    1.00x       2260.59    1.00x
+Benchmark32_1024          1410.90       2285.82    1.62x       2270.99    0.99x       2263.73    1.00x
+Benchmark32_2048          1422.14       2297.62    1.62x       2269.59    0.99x       2296.02    1.01x
+Benchmark32_4096          1420.53       2307.81    1.62x       2273.43    0.99x       2290.92    1.01x
+Benchmark32_8192          1424.79       2312.87    1.62x       2286.07    0.99x       2279.68    1.00x
+Benchmark128_1               8.32         30.15    3.62x         30.84    1.02x         38.33    1.24x
+Benchmark128_2              16.38         59.72    3.65x         59.37    0.99x         69.07    1.16x
+Benchmark128_4              32.26        112.96    3.50x        114.24    1.01x        134.17    1.17x
+Benchmark128_8              62.68        217.88    3.48x        218.18    1.00x        252.86    1.16x
+Benchmark128_16            128.47        451.57    3.51x        474.65    1.05x        603.42    1.27x
+Benchmark128_32            246.18        910.42    3.70x        871.06    0.96x       1117.15    1.28x
+Benchmark128_64            449.05       1477.64    3.29x       1449.24    0.98x       1800.97    1.24x
+Benchmark128_128           762.61       2222.42    2.91x       2217.30    1.00x       2515.50    1.13x
+Benchmark128_256          1179.92       3005.46    2.55x       2931.55    0.98x       3330.11    1.14x
+Benchmark128_512          1616.51       3590.75    2.22x       3592.08    1.00x       3769.09    1.05x
+Benchmark128_1024         1964.36       3979.67    2.03x       4034.01    1.01x       4094.38    1.01x
+Benchmark128_2048         2225.07       4156.93    1.87x       4244.17    1.02x       4290.75    1.01x
+Benchmark128_4096         2360.15       4299.09    1.82x       4392.35    1.02x       4353.29    0.99x
+Benchmark128_8192         2411.50       4356.84    1.81x       4480.68    1.03x       4455.47    0.99x
+
+</pre>
+

diff --git a/vendor/github.com/gxed/hashland/murmur3/go.mod b/vendor/github.com/gxed/hashland/murmur3/go.mod
new file mode 100644 (file)
index 0000000..bef2395
--- /dev/null
+++ b/vendor/github.com/gxed/hashland/murmur3/go.mod
@@ -0,0 +1 @@
+module github.com/gxed/hashland/murmur3

diff --git a/vendor/github.com/gxed/hashland/murmur3/murmur.go b/vendor/github.com/gxed/hashland/murmur3/murmur.go
new file mode 100644 (file)
index 0000000..f99557c
--- /dev/null
+++ b/vendor/github.com/gxed/hashland/murmur3/murmur.go
@@ -0,0 +1,65 @@
+// Copyright 2013, Sébastien Paolacci. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+/*
+Native (and fast) implementation of Austin Appleby's MurmurHash3.
+
+Package murmur3 implements Austin Appleby's non-cryptographic MurmurHash3.
+
+ Reference implementation:
+    http://code.google.com/p/smhasher/wiki/MurmurHash3
+
+ History, characteristics and (legacy) perfs:
+    https://sites.google.com/site/murmurhash/
+    https://sites.google.com/site/murmurhash/statistics
+*/
+package murmur3
+
+type bmixer interface {
+       bmix(p []byte) (tail []byte)
+       Size() (n int)
+       reset()
+}
+
+type digest struct {
+       clen int      // Digested input cumulative length.
+       tail []byte   // 0 to Size()-1 bytes view of `buf'.
+       buf  [16]byte // Expected (but not required) to be Size() large.
+       bmixer
+}
+
+func (d *digest) BlockSize() int { return 1 }
+
+func (d *digest) Write(p []byte) (n int, err error) {
+       n = len(p)
+       d.clen += n
+
+       if len(d.tail) > 0 {
+               // Stick back pending bytes.
+               nfree := d.Size() - len(d.tail) // nfree ∈ [1, d.Size()-1].
+               if nfree < len(p) {
+                       // One full block can be formed.
+                       block := append(d.tail, p[:nfree]...)
+                       p = p[nfree:]
+                       _ = d.bmix(block) // No tail.
+               } else {
+                       // Tail's buf is large enough to prevent reallocs.
+                       p = append(d.tail, p...)
+               }
+       }
+
+       d.tail = d.bmix(p)
+
+       // Keep own copy of the 0 to Size()-1 pending bytes.
+       nn := copy(d.buf[:], d.tail)
+       d.tail = d.buf[:nn]
+
+       return n, nil
+}
+
+func (d *digest) Reset() {
+       d.clen = 0
+       d.tail = nil
+       d.bmixer.reset()
+}

diff --git a/vendor/github.com/gxed/hashland/murmur3/murmur128.go b/vendor/github.com/gxed/hashland/murmur3/murmur128.go
new file mode 100644 (file)
index 0000000..16c34d6
--- /dev/null
+++ b/vendor/github.com/gxed/hashland/murmur3/murmur128.go
@@ -0,0 +1,189 @@
+package murmur3
+
+import (
+       //"encoding/binary"
+       "hash"
+       "unsafe"
+)
+
+const (
+       c1_128 = 0x87c37b91114253d5
+       c2_128 = 0x4cf5ad432745937f
+)
+
+// Make sure interfaces are correctly implemented.
+var (
+       _ hash.Hash = new(digest128)
+       _ Hash128   = new(digest128)
+       _ bmixer    = new(digest128)
+)
+
+// Hack: the standard api doesn't define any Hash128 interface.
+type Hash128 interface {
+       hash.Hash
+       Sum128() (uint64, uint64)
+}
+
+// digest128 represents a partial evaluation of a 128 bites hash.
+type digest128 struct {
+       digest
+       h1 uint64 // Unfinalized running hash part 1.
+       h2 uint64 // Unfinalized running hash part 2.
+}
+
+func New128() Hash128 {
+       d := new(digest128)
+       d.bmixer = d
+       d.Reset()
+       return d
+}
+
+func (d *digest128) Size() int { return 16 }
+
+func (d *digest128) reset() { d.h1, d.h2 = 0, 0 }
+
+func (d *digest128) Sum(b []byte) []byte {
+       h1, h2 := d.h1, d.h2
+       return append(b,
+               byte(h1>>56), byte(h1>>48), byte(h1>>40), byte(h1>>32),
+               byte(h1>>24), byte(h1>>16), byte(h1>>8), byte(h1),
+
+               byte(h2>>56), byte(h2>>48), byte(h2>>40), byte(h2>>32),
+               byte(h2>>24), byte(h2>>16), byte(h2>>8), byte(h2),
+       )
+}
+
+func (d *digest128) bmix(p []byte) (tail []byte) {
+       h1, h2 := d.h1, d.h2
+
+       nblocks := len(p) / 16
+       for i := 0; i < nblocks; i++ {
+               t := (*[2]uint64)(unsafe.Pointer(&p[i*16]))
+               k1, k2 := t[0], t[1]
+
+               k1 *= c1_128
+               k1 = (k1 << 31) | (k1 >> 33) // rotl64(k1, 31)
+               k1 *= c2_128
+               h1 ^= k1
+
+               h1 = (h1 << 27) | (h1 >> 37) // rotl64(h1, 27)
+               h1 += h2
+               h1 = h1*5 + 0x52dce729
+
+               k2 *= c2_128
+               k2 = (k2 << 33) | (k2 >> 31) // rotl64(k2, 33)
+               k2 *= c1_128
+               h2 ^= k2
+
+               h2 = (h2 << 31) | (h2 >> 33) // rotl64(h2, 31)
+               h2 += h1
+               h2 = h2*5 + 0x38495ab5
+       }
+       d.h1, d.h2 = h1, h2
+       return p[nblocks*d.Size():]
+}
+
+func (d *digest128) Sum128() (h1, h2 uint64) {
+
+       h1, h2 = d.h1, d.h2
+
+       var k1, k2 uint64
+       switch len(d.tail) & 15 {
+       case 15:
+               k2 ^= uint64(d.tail[14]) << 48
+               fallthrough
+       case 14:
+               k2 ^= uint64(d.tail[13]) << 40
+               fallthrough
+       case 13:
+               k2 ^= uint64(d.tail[12]) << 32
+               fallthrough
+       case 12:
+               k2 ^= uint64(d.tail[11]) << 24
+               fallthrough
+       case 11:
+               k2 ^= uint64(d.tail[10]) << 16
+               fallthrough
+       case 10:
+               k2 ^= uint64(d.tail[9]) << 8
+               fallthrough
+       case 9:
+               k2 ^= uint64(d.tail[8]) << 0
+
+               k2 *= c2_128
+               k2 = (k2 << 33) | (k2 >> 31) // rotl64(k2, 33)
+               k2 *= c1_128
+               h2 ^= k2
+
+               fallthrough
+
+       case 8:
+               k1 ^= uint64(d.tail[7]) << 56
+               fallthrough
+       case 7:
+               k1 ^= uint64(d.tail[6]) << 48
+               fallthrough
+       case 6:
+               k1 ^= uint64(d.tail[5]) << 40
+               fallthrough
+       case 5:
+               k1 ^= uint64(d.tail[4]) << 32
+               fallthrough
+       case 4:
+               k1 ^= uint64(d.tail[3]) << 24
+               fallthrough
+       case 3:
+               k1 ^= uint64(d.tail[2]) << 16
+               fallthrough
+       case 2:
+               k1 ^= uint64(d.tail[1]) << 8
+               fallthrough
+       case 1:
+               k1 ^= uint64(d.tail[0]) << 0
+               k1 *= c1_128
+               k1 = (k1 << 31) | (k1 >> 33) // rotl64(k1, 31)
+               k1 *= c2_128
+               h1 ^= k1
+       }
+
+       h1 ^= uint64(d.clen)
+       h2 ^= uint64(d.clen)
+
+       h1 += h2
+       h2 += h1
+
+       h1 = fmix64(h1)
+       h2 = fmix64(h2)
+
+       h1 += h2
+       h2 += h1
+
+       return h1, h2
+}
+
+func fmix64(k uint64) uint64 {
+       k ^= k >> 33
+       k *= 0xff51afd7ed558ccd
+       k ^= k >> 33
+       k *= 0xc4ceb9fe1a85ec53
+       k ^= k >> 33
+       return k
+}
+
+/*
+func rotl64(x uint64, r byte) uint64 {
+       return (x << r) | (x >> (64 - r))
+}
+*/
+
+// Sum128 returns the MurmurHash3 sum of data. It is equivalent to the
+// following sequence (without the extra burden and the extra allocation):
+//     hasher := New128()
+//     hasher.Write(data)
+//     return hasher.Sum128()
+func Sum128(data []byte) (h1 uint64, h2 uint64) {
+       d := &digest128{h1: 0, h2: 0}
+       d.tail = d.bmix(data)
+       d.clen = len(data)
+       return d.Sum128()
+}

diff --git a/vendor/github.com/gxed/hashland/murmur3/murmur32.go b/vendor/github.com/gxed/hashland/murmur3/murmur32.go
new file mode 100644 (file)
index 0000000..bc89d26
--- /dev/null
+++ b/vendor/github.com/gxed/hashland/murmur3/murmur32.go
@@ -0,0 +1,154 @@
+package murmur3
+
+// http://code.google.com/p/guava-libraries/source/browse/guava/src/com/google/common/hash/Murmur3_32HashFunction.java
+
+import (
+       "hash"
+       "unsafe"
+)
+
+// Make sure interfaces are correctly implemented.
+var (
+       _ hash.Hash   = new(digest32)
+       _ hash.Hash32 = new(digest32)
+)
+
+const (
+       c1_32 uint32 = 0xcc9e2d51
+       c2_32 uint32 = 0x1b873593
+)
+
+// digest32 represents a partial evaluation of a 32 bites hash.
+type digest32 struct {
+       digest
+       h1 uint32 // Unfinalized running hash.
+}
+
+func New32() hash.Hash32 {
+       d := new(digest32)
+       d.bmixer = d
+       d.Reset()
+       return d
+}
+
+func (d *digest32) Size() int { return 4 }
+
+func (d *digest32) reset() { d.h1 = 0 }
+
+func (d *digest32) Sum(b []byte) []byte {
+       h := d.h1
+       return append(b, byte(h>>24), byte(h>>16), byte(h>>8), byte(h))
+}
+
+// Digest as many blocks as possible.
+func (d *digest32) bmix(p []byte) (tail []byte) {
+       h1 := d.h1
+
+       nblocks := len(p) / 4
+       for i := 0; i < nblocks; i++ {
+               k1 := *(*uint32)(unsafe.Pointer(&p[i*4]))
+
+               k1 *= c1_32
+               k1 = (k1 << 15) | (k1 >> 17) // rotl32(k1, 15)
+               k1 *= c2_32
+
+               h1 ^= k1
+               h1 = (h1 << 13) | (h1 >> 19) // rotl32(h1, 13)
+               h1 = h1*5 + 0xe6546b64
+       }
+       d.h1 = h1
+       return p[nblocks*d.Size():]
+}
+
+func (d *digest32) Sum32() (h1 uint32) {
+
+       h1 = d.h1
+
+       var k1 uint32
+       switch len(d.tail) & 3 {
+       case 3:
+               k1 ^= uint32(d.tail[2]) << 16
+               fallthrough
+       case 2:
+               k1 ^= uint32(d.tail[1]) << 8
+               fallthrough
+       case 1:
+               k1 ^= uint32(d.tail[0])
+               k1 *= c1_32
+               k1 = (k1 << 15) | (k1 >> 17) // rotl32(k1, 15)
+               k1 *= c2_32
+               h1 ^= k1
+       }
+
+       h1 ^= uint32(d.clen)
+
+       h1 ^= h1 >> 16
+       h1 *= 0x85ebca6b
+       h1 ^= h1 >> 13
+       h1 *= 0xc2b2ae35
+       h1 ^= h1 >> 16
+
+       return h1
+}
+
+/*
+func rotl32(x uint32, r byte) uint32 {
+       return (x << r) | (x >> (32 - r))
+}
+*/
+
+// Sum32 returns the MurmurHash3 sum of data. It is equivalent to the
+// following sequence (without the extra burden and the extra allocation):
+//     hasher := New32()
+//     hasher.Write(data)
+//     return hasher.Sum32()
+func Sum32(data []byte) uint32 {
+
+       var h1 uint32 = 0
+
+       nblocks := len(data) / 4
+       var p uintptr
+       if len(data) > 0 {
+               p = uintptr(unsafe.Pointer(&data[0]))
+       }
+       p1 := p + uintptr(4*nblocks)
+       for ; p < p1; p += 4 {
+               k1 := *(*uint32)(unsafe.Pointer(p))
+
+               k1 *= c1_32
+               k1 = (k1 << 15) | (k1 >> 17) // rotl32(k1, 15)
+               k1 *= c2_32
+
+               h1 ^= k1
+               h1 = (h1 << 13) | (h1 >> 19) // rotl32(h1, 13)
+               h1 = h1*5 + 0xe6546b64
+       }
+
+       tail := data[nblocks*4:]
+
+       var k1 uint32
+       switch len(tail) & 3 {
+       case 3:
+               k1 ^= uint32(tail[2]) << 16
+               fallthrough
+       case 2:
+               k1 ^= uint32(tail[1]) << 8
+               fallthrough
+       case 1:
+               k1 ^= uint32(tail[0])
+               k1 *= c1_32
+               k1 = (k1 << 15) | (k1 >> 17) // rotl32(k1, 15)
+               k1 *= c2_32
+               h1 ^= k1
+       }
+
+       h1 ^= uint32(len(data))
+
+       h1 ^= h1 >> 16
+       h1 *= 0x85ebca6b
+       h1 ^= h1 >> 13
+       h1 *= 0xc2b2ae35
+       h1 ^= h1 >> 16
+
+       return h1
+}

diff --git a/vendor/github.com/gxed/hashland/murmur3/murmur64.go b/vendor/github.com/gxed/hashland/murmur3/murmur64.go
new file mode 100644 (file)
index 0000000..fdd4398
--- /dev/null
+++ b/vendor/github.com/gxed/hashland/murmur3/murmur64.go
@@ -0,0 +1,45 @@
+package murmur3
+
+import (
+       "hash"
+)
+
+// Make sure interfaces are correctly implemented.
+var (
+       _ hash.Hash   = new(digest64)
+       _ hash.Hash64 = new(digest64)
+       _ bmixer      = new(digest64)
+)
+
+// digest64 is half a digest128.
+type digest64 digest128
+
+func New64() hash.Hash64 {
+       d := (*digest64)(New128().(*digest128))
+       return d
+}
+
+func (d *digest64) Sum(b []byte) []byte {
+       h1 := d.h1
+       return append(b,
+               byte(h1>>56), byte(h1>>48), byte(h1>>40), byte(h1>>32),
+               byte(h1>>24), byte(h1>>16), byte(h1>>8), byte(h1))
+}
+
+func (d *digest64) Sum64() uint64 {
+       h1, _ := (*digest128)(d).Sum128()
+       return h1
+}
+
+// Sum64 returns the MurmurHash3 sum of data. It is equivalent to the
+// following sequence (without the extra burden and the extra allocation):
+//     hasher := New64()
+//     hasher.Write(data)
+//     return hasher.Sum64()
+func Sum64(data []byte) uint64 {
+       d := &digest128{h1: 0, h2: 0}
+       d.tail = d.bmix(data)
+       d.clen = len(data)
+       h1, _ := d.Sum128()
+       return h1
+}

diff --git a/vendor/github.com/gxed/hashland/murmur3/murmur_test.go b/vendor/github.com/gxed/hashland/murmur3/murmur_test.go
new file mode 100644 (file)
index 0000000..32789bd
--- /dev/null
+++ b/vendor/github.com/gxed/hashland/murmur3/murmur_test.go
@@ -0,0 +1,229 @@
+package murmur3
+
+import (
+       "hash"
+       "testing"
+)
+
+var data = []struct {
+       h32   uint32
+       h64_1 uint64
+       h64_2 uint64
+       s     string
+}{
+       {0x00000000, 0x0000000000000000, 0x0000000000000000, ""},
+       {0x248bfa47, 0xcbd8a7b341bd9b02, 0x5b1e906a48ae1d19, "hello"},
+       {0x149bbb7f, 0x342fac623a5ebc8e, 0x4cdcbc079642414d, "hello, world"},
+       {0xe31e8a70, 0xb89e5988b737affc, 0x664fc2950231b2cb, "19 Jan 2038 at 3:14:07 AM"},
+       {0xd5c48bfc, 0xcd99481f9ee902c9, 0x695da1a38987b6e7, "The quick brown fox jumps over the lazy dog."},
+}
+
+func TestRef(t *testing.T) {
+       for _, elem := range data {
+
+               var h32 hash.Hash32 = New32()
+               h32.Write([]byte(elem.s))
+               if v := h32.Sum32(); v != elem.h32 {
+                       t.Errorf("'%s': 0x%x (want 0x%x)", elem.s, v, elem.h32)
+               }
+
+               if v := Sum32([]byte(elem.s)); v != elem.h32 {
+                       t.Errorf("'%s': 0x%x (want 0x%x)", elem.s, v, elem.h32)
+               }
+
+               var h64 hash.Hash64 = New64()
+               h64.Write([]byte(elem.s))
+               if v := h64.Sum64(); v != elem.h64_1 {
+                       t.Errorf("'%s': 0x%x (want 0x%x)", elem.s, v, elem.h64_1)
+               }
+
+               if v := Sum64([]byte(elem.s)); v != elem.h64_1 {
+                       t.Errorf("'%s': 0x%x (want 0x%x)", elem.s, v, elem.h64_1)
+               }
+
+               var h128 Hash128 = New128()
+               h128.Write([]byte(elem.s))
+               if v1, v2 := h128.Sum128(); v1 != elem.h64_1 || v2 != elem.h64_2 {
+                       t.Errorf("'%s': 0x%x-0x%x (want 0x%x-0x%x)", elem.s, v1, v2, elem.h64_1, elem.h64_2)
+               }
+
+               if v1, v2 := Sum128([]byte(elem.s)); v1 != elem.h64_1 || v2 != elem.h64_2 {
+                       t.Errorf("'%s': 0x%x-0x%x (want 0x%x-0x%x)", elem.s, v1, v2, elem.h64_1, elem.h64_2)
+               }
+       }
+}
+
+func TestIncremental(t *testing.T) {
+       for _, elem := range data {
+               h32 := New32()
+               h128 := New128()
+               for i, j, k := 0, 0, len(elem.s); i < k; i = j {
+                       j = 2*i + 3
+                       if j > k {
+                               j = k
+                       }
+                       s := elem.s[i:j]
+                       print(s + "|")
+                       h32.Write([]byte(s))
+                       h128.Write([]byte(s))
+               }
+               println()
+               if v := h32.Sum32(); v != elem.h32 {
+                       t.Errorf("'%s': 0x%x (want 0x%x)", elem.s, v, elem.h32)
+               }
+               if v1, v2 := h128.Sum128(); v1 != elem.h64_1 || v2 != elem.h64_2 {
+                       t.Errorf("'%s': 0x%x-0x%x (want 0x%x-0x%x)", elem.s, v1, v2, elem.h64_1, elem.h64_2)
+               }
+       }
+}
+
+//---
+
+func bench32(b *testing.B, length int) {
+       buf := make([]byte, length)
+       b.SetBytes(int64(length))
+       b.ResetTimer()
+       for i := 0; i < b.N; i++ {
+               Sum32(buf)
+       }
+}
+
+func Benchmark32_1(b *testing.B) {
+       bench32(b, 1)
+}
+func Benchmark32_2(b *testing.B) {
+       bench32(b, 2)
+}
+func Benchmark32_4(b *testing.B) {
+       bench32(b, 4)
+}
+func Benchmark32_8(b *testing.B) {
+       bench32(b, 8)
+}
+func Benchmark32_16(b *testing.B) {
+       bench32(b, 16)
+}
+func Benchmark32_32(b *testing.B) {
+       bench32(b, 32)
+}
+func Benchmark32_64(b *testing.B) {
+       bench32(b, 64)
+}
+func Benchmark32_128(b *testing.B) {
+       bench32(b, 128)
+}
+func Benchmark32_256(b *testing.B) {
+       bench32(b, 256)
+}
+func Benchmark32_512(b *testing.B) {
+       bench32(b, 512)
+}
+func Benchmark32_1024(b *testing.B) {
+       bench32(b, 1024)
+}
+func Benchmark32_2048(b *testing.B) {
+       bench32(b, 2048)
+}
+func Benchmark32_4096(b *testing.B) {
+       bench32(b, 4096)
+}
+func Benchmark32_8192(b *testing.B) {
+       bench32(b, 8192)
+}
+
+//---
+
+func benchPartial32(b *testing.B, length int) {
+       buf := make([]byte, length)
+       b.SetBytes(int64(length))
+
+       start := (32 / 8) / 2
+       chunks := 7
+       k := length / chunks
+       tail := (length - start) % k
+
+       b.ResetTimer()
+       for i := 0; i < b.N; i++ {
+               hasher := New32()
+               hasher.Write(buf[0:start])
+
+               for j := start; j+k <= length; j += k {
+                       hasher.Write(buf[j : j+k])
+               }
+
+               hasher.Write(buf[length-tail:])
+               hasher.Sum32()
+       }
+}
+
+func BenchmarkPartial32_8(b *testing.B) {
+       benchPartial32(b, 8)
+}
+func BenchmarkPartial32_16(b *testing.B) {
+       benchPartial32(b, 16)
+}
+func BenchmarkPartial32_32(b *testing.B) {
+       benchPartial32(b, 32)
+}
+func BenchmarkPartial32_64(b *testing.B) {
+       benchPartial32(b, 64)
+}
+func BenchmarkPartial32_128(b *testing.B) {
+       benchPartial32(b, 128)
+}
+
+//---
+
+func bench128(b *testing.B, length int) {
+       buf := make([]byte, length)
+       b.SetBytes(int64(length))
+       b.ResetTimer()
+       for i := 0; i < b.N; i++ {
+               Sum128(buf)
+       }
+}
+
+func Benchmark128_1(b *testing.B) {
+       bench128(b, 1)
+}
+func Benchmark128_2(b *testing.B) {
+       bench128(b, 2)
+}
+func Benchmark128_4(b *testing.B) {
+       bench128(b, 4)
+}
+func Benchmark128_8(b *testing.B) {
+       bench128(b, 8)
+}
+func Benchmark128_16(b *testing.B) {
+       bench128(b, 16)
+}
+func Benchmark128_32(b *testing.B) {
+       bench128(b, 32)
+}
+func Benchmark128_64(b *testing.B) {
+       bench128(b, 64)
+}
+func Benchmark128_128(b *testing.B) {
+       bench128(b, 128)
+}
+func Benchmark128_256(b *testing.B) {
+       bench128(b, 256)
+}
+func Benchmark128_512(b *testing.B) {
+       bench128(b, 512)
+}
+func Benchmark128_1024(b *testing.B) {
+       bench128(b, 1024)
+}
+func Benchmark128_2048(b *testing.B) {
+       bench128(b, 2048)
+}
+func Benchmark128_4096(b *testing.B) {
+       bench128(b, 4096)
+}
+func Benchmark128_8192(b *testing.B) {
+       bench128(b, 8192)
+}
+
+//---

diff --git a/vendor/github.com/ipfs/go-ipfs-files/.gx/lastpubver b/vendor/github.com/ipfs/go-ipfs-files/.gx/lastpubver
new file mode 100644 (file)
index 0000000..1580b52
--- /dev/null
+++ b/vendor/github.com/ipfs/go-ipfs-files/.gx/lastpubver
@@ -0,0 +1 @@
+2.0.6: QmQmhotPUzVrMEWNK3x1R5jQ5ZHWyL7tVUrmRPjrBrvyCb

diff --git a/vendor/github.com/ipfs/go-ipfs-files/LICENSE b/vendor/github.com/ipfs/go-ipfs-files/LICENSE
new file mode 100644 (file)
index 0000000..6cccfc2
--- /dev/null
+++ b/vendor/github.com/ipfs/go-ipfs-files/LICENSE
@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2018 Protocol Labs
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

diff --git a/vendor/github.com/ipfs/go-ipfs-files/README.md b/vendor/github.com/ipfs/go-ipfs-files/README.md
new file mode 100644 (file)
index 0000000..4f70469
--- /dev/null
+++ b/vendor/github.com/ipfs/go-ipfs-files/README.md
@@ -0,0 +1,27 @@
+# go-ipfs-files
+
+[![](https://img.shields.io/badge/made%20by-Protocol%20Labs-blue.svg?style=flat-square)](http://ipn.io)
+[![](https://img.shields.io/badge/project-IPFS-blue.svg?style=flat-square)](http://ipfs.io/)
+[![](https://img.shields.io/badge/freenode-%23ipfs-blue.svg?style=flat-square)](http://webchat.freenode.net/?channels=%23ipfs)
+[![standard-readme compliant](https://img.shields.io/badge/standard--readme-OK-green.svg?style=flat-square)](https://github.com/RichardLitt/standard-readme)
+
+> File interfaces and utils used in IPFS
+
+## Documentation
+
+https://godoc.org/github.com/ipfs/go-ipfs-files
+
+## Contribute
+
+Feel free to join in. All welcome. Open an [issue](https://github.com/ipfs/go-ipfs-files/issues)!
+
+This repository falls under the IPFS [Code of Conduct](https://github.com/ipfs/community/blob/master/code-of-conduct.md).
+
+### Want to hack on IPFS?
+
+[![](https://cdn.rawgit.com/jbenet/contribute-ipfs-gif/master/img/contribute.gif)](https://github.com/ipfs/community/blob/master/contributing.md)
+
+## License
+
+MIT
+

diff --git a/vendor/github.com/ipfs/go-ipfs-files/ci/Jenkinsfile b/vendor/github.com/ipfs/go-ipfs-files/ci/Jenkinsfile
new file mode 100644 (file)
index 0000000..b2067e6
--- /dev/null
+++ b/vendor/github.com/ipfs/go-ipfs-files/ci/Jenkinsfile
@@ -0,0 +1 @@
+golang()

diff --git a/vendor/github.com/ipfs/go-ipfs-files/file.go b/vendor/github.com/ipfs/go-ipfs-files/file.go
new file mode 100644 (file)
index 0000000..4d7ef11
--- /dev/null
+++ b/vendor/github.com/ipfs/go-ipfs-files/file.go
@@ -0,0 +1,94 @@
+package files
+
+import (
+       "errors"
+       "io"
+       "os"
+)
+
+var (
+       ErrNotDirectory = errors.New("file isn't a directory")
+       ErrNotReader    = errors.New("file isn't a regular file")
+
+       ErrNotSupported = errors.New("operation not supported")
+)
+
+// Node is a common interface for files, directories and other special files
+type Node interface {
+       io.Closer
+
+       // Size returns size of this file (if this file is a directory, total size of
+       // all files stored in the tree should be returned). Some implementations may
+       // choose not to implement this
+       Size() (int64, error)
+}
+
+// Node represents a regular Unix file
+type File interface {
+       Node
+
+       io.Reader
+       io.Seeker
+}
+
+// DirEntry exposes information about a directory entry
+type DirEntry interface {
+       // Name returns base name of this entry, which is the base name of referenced
+       // file
+       Name() string
+
+       // Node returns the file referenced by this DirEntry
+       Node() Node
+}
+
+// DirIterator is a iterator over directory entries.
+// See Directory.Entries for more
+type DirIterator interface {
+       // DirEntry holds information about current directory entry.
+       // Note that after creating new iterator you MUST call Next() at least once
+       // before accessing these methods. Calling these methods without prior calls
+       // to Next() and after Next() returned false may result in undefined behavior
+       DirEntry
+
+       // Next advances iterator to the next file.
+       Next() bool
+
+       // Err may return an error after previous call to Next() returned `false`.
+       // If previous call to Next() returned `true`, Err() is guaranteed to
+       // return nil
+       Err() error
+}
+
+// Directory is a special file which can link to any number of files.
+type Directory interface {
+       Node
+
+       // Entries returns a stateful iterator over directory entries.
+       //
+       // Example usage:
+       //
+       // it := dir.Entries()
+       // for it.Next() {
+       //   name := it.Name()
+       //   file := it.Node()
+       //   [...]
+       // }
+       // if it.Err() != nil {
+       //   return err
+       // }
+       //
+       // Note that you can't store the result of it.Node() and use it after
+       // advancing the iterator
+       Entries() DirIterator
+}
+
+// FileInfo exposes information on files in local filesystem
+type FileInfo interface {
+       Node
+
+       // AbsPath returns full real file path.
+       AbsPath() string
+
+       // Stat returns os.Stat of this file, may be nil for some files
+       Stat() os.FileInfo
+}

diff --git a/vendor/github.com/ipfs/go-ipfs-files/file_test.go b/vendor/github.com/ipfs/go-ipfs-files/file_test.go
new file mode 100644 (file)
index 0000000..8c6c622
--- /dev/null
+++ b/vendor/github.com/ipfs/go-ipfs-files/file_test.go
@@ -0,0 +1,142 @@
+package files
+
+import (
+       "io"
+       "mime/multipart"
+       "strings"
+       "testing"
+)
+
+func TestSliceFiles(t *testing.T) {
+       sf := NewMapDirectory(map[string]Node{
+               "1": NewBytesFile([]byte("Some text!\n")),
+               "2": NewBytesFile([]byte("beep")),
+               "3": NewBytesFile([]byte("boop")),
+       })
+
+       CheckDir(t, sf, []Event{
+               {
+                       kind:  TFile,
+                       name:  "1",
+                       value: "Some text!\n",
+               },
+               {
+                       kind:  TFile,
+                       name:  "2",
+                       value: "beep",
+               },
+               {
+                       kind:  TFile,
+                       name:  "3",
+                       value: "boop",
+               },
+       })
+}
+
+func TestReaderFiles(t *testing.T) {
+       message := "beep boop"
+       rf := NewBytesFile([]byte(message))
+       buf := make([]byte, len(message))
+
+       if n, err := rf.Read(buf); n == 0 || err != nil {
+               t.Fatal("Expected to be able to read")
+       }
+       if err := rf.Close(); err != nil {
+               t.Fatal("Should be able to close")
+       }
+       if n, err := rf.Read(buf); n != 0 || err != io.EOF {
+               t.Fatal("Expected EOF when reading after close")
+       }
+}
+func TestMultipartFiles(t *testing.T) {
+       data := `
+--Boundary!
+Content-Type: text/plain
+Content-Disposition: file; filename="name"
+Some-Header: beep
+
+beep
+--Boundary!
+Content-Type: application/x-directory
+Content-Disposition: file; filename="dir"
+
+--Boundary!
+Content-Type: text/plain
+Content-Disposition: file; filename="dir/nested"
+
+some content
+--Boundary!
+Content-Type: application/symlink
+Content-Disposition: file; filename="dir/simlynk"
+
+anotherfile
+--Boundary!
+Content-Type: text/plain
+Content-Disposition: file; filename="implicit1/implicit2/deep_implicit"
+
+implicit file1
+--Boundary!
+Content-Type: text/plain
+Content-Disposition: file; filename="implicit1/shallow_implicit"
+
+implicit file2
+--Boundary!--
+
+`
+
+       reader := strings.NewReader(data)
+       mpReader := multipart.NewReader(reader, "Boundary!")
+       dir, err := NewFileFromPartReader(mpReader, multipartFormdataType)
+       if err != nil {
+               t.Fatal(err)
+       }
+
+       CheckDir(t, dir, []Event{
+               {
+                       kind:  TFile,
+                       name:  "name",
+                       value: "beep",
+               },
+               {
+                       kind: TDirStart,
+                       name: "dir",
+               },
+               {
+                       kind:  TFile,
+                       name:  "nested",
+                       value: "some content",
+               },
+               {
+                       kind:  TSymlink,
+                       name:  "simlynk",
+                       value: "anotherfile",
+               },
+               {
+                       kind: TDirEnd,
+               },
+               {
+                       kind: TDirStart,
+                       name: "implicit1",
+               },
+               {
+                       kind: TDirStart,
+                       name: "implicit2",
+               },
+               {
+                       kind:  TFile,
+                       name:  "deep_implicit",
+                       value: "implicit file1",
+               },
+               {
+                       kind: TDirEnd,
+               },
+               {
+                       kind:  TFile,
+                       name:  "shallow_implicit",
+                       value: "implicit file2",
+               },
+               {
+                       kind: TDirEnd,
+               },
+       })
+}

diff --git a/vendor/github.com/ipfs/go-ipfs-files/helpers_test.go b/vendor/github.com/ipfs/go-ipfs-files/helpers_test.go
new file mode 100644 (file)
index 0000000..ec420bd
--- /dev/null
+++ b/vendor/github.com/ipfs/go-ipfs-files/helpers_test.go
@@ -0,0 +1,126 @@
+package files
+
+import (
+       "io/ioutil"
+       "testing"
+)
+
+type Kind int
+
+const (
+       TFile Kind = iota
+       TSymlink
+       TDirStart
+       TDirEnd
+)
+
+type Event struct {
+       kind  Kind
+       name  string
+       value string
+}
+
+func CheckDir(t *testing.T, dir Directory, expected []Event) {
+       expectedIndex := 0
+       expect := func() (Event, int) {
+               t.Helper()
+
+               if expectedIndex > len(expected) {
+                       t.Fatal("no more expected entries")
+               }
+               i := expectedIndex
+               expectedIndex++
+
+               // Add an implicit "end" event at the end. It makes this
+               // function a bit easier to write.
+               next := Event{kind: TDirEnd}
+               if i < len(expected) {
+                       next = expected[i]
+               }
+               return next, i
+       }
+       var check func(d Directory)
+       check = func(d Directory) {
+               it := d.Entries()
+
+               for it.Next() {
+                       next, i := expect()
+
+                       if it.Name() != next.name {
+                               t.Fatalf("[%d] expected filename to be %q", i, next.name)
+                       }
+
+                       switch next.kind {
+                       case TFile:
+                               mf, ok := it.Node().(File)
+                               if !ok {
+                                       t.Fatalf("[%d] expected file to be a normal file: %T", i, it.Node())
+                               }
+                               out, err := ioutil.ReadAll(mf)
+                               if err != nil {
+                                       t.Errorf("[%d] failed to read file", i)
+                                       continue
+                               }
+                               if string(out) != next.value {
+                                       t.Errorf(
+                                               "[%d] while reading %q, expected %q, got %q",
+                                               i,
+                                               it.Name(),
+                                               next.value,
+                                               string(out),
+                                       )
+                                       continue
+                               }
+                       case TSymlink:
+                               mf, ok := it.Node().(*Symlink)
+                               if !ok {
+                                       t.Errorf("[%d] expected file to be a symlink: %T", i, it.Node())
+                                       continue
+                               }
+                               if mf.Target != next.value {
+                                       t.Errorf(
+                                               "[%d] target of symlink %q should have been %q but was %q",
+                                               i,
+                                               it.Name(),
+                                               next.value,
+                                               mf.Target,
+                                       )
+                                       continue
+                               }
+                       case TDirStart:
+                               mf, ok := it.Node().(Directory)
+                               if !ok {
+                                       t.Fatalf(
+                                               "[%d] expected file to be a directory: %T",
+                                               i,
+                                               it.Node(),
+                                       )
+                               }
+                               check(mf)
+                       case TDirEnd:
+                               t.Errorf(
+                                       "[%d] expected end of directory, found %#v at %q",
+                                       i,
+                                       it.Node(),
+                                       it.Name(),
+                               )
+                               return
+                       default:
+                               t.Fatal("unhandled type", next.kind)
+                       }
+                       if err := it.Node().Close(); err != nil {
+                               t.Fatalf("[%d] expected to be able to close node", i)
+                       }
+               }
+               next, i := expect()
+
+               if it.Err() != nil {
+                       t.Fatalf("[%d] got error: %s", i, it.Err())
+               }
+
+               if next.kind != TDirEnd {
+                       t.Fatalf("[%d] found end of directory, expected %#v", i, next)
+               }
+       }
+       check(dir)
+}

diff --git a/vendor/github.com/ipfs/go-ipfs-files/is_hidden.go b/vendor/github.com/ipfs/go-ipfs-files/is_hidden.go
new file mode 100644 (file)
index 0000000..4ebca60
--- /dev/null
+++ b/vendor/github.com/ipfs/go-ipfs-files/is_hidden.go
@@ -0,0 +1,18 @@
+// +build !windows
+
+package files
+
+import (
+       "path/filepath"
+       "strings"
+)
+
+func IsHidden(name string, f Node) bool {
+       fName := filepath.Base(name)
+
+       if strings.HasPrefix(fName, ".") && len(fName) > 1 {
+               return true
+       }
+
+       return false
+}

diff --git a/vendor/github.com/ipfs/go-ipfs-files/is_hidden_windows.go b/vendor/github.com/ipfs/go-ipfs-files/is_hidden_windows.go
new file mode 100644 (file)
index 0000000..7419f93
--- /dev/null
+++ b/vendor/github.com/ipfs/go-ipfs-files/is_hidden_windows.go
@@ -0,0 +1,35 @@
+// +build windows
+
+package files
+
+import (
+       "path/filepath"
+       "strings"
+
+       windows "golang.org/x/sys/windows"
+)
+
+func IsHidden(name string, f Node) bool {
+
+       fName := filepath.Base(name)
+
+       if strings.HasPrefix(fName, ".") && len(fName) > 1 {
+               return true
+       }
+
+       fi, ok := f.(FileInfo)
+       if !ok {
+               return false
+       }
+
+       p, e := windows.UTF16PtrFromString(fi.AbsPath())
+       if e != nil {
+               return false
+       }
+
+       attrs, e := windows.GetFileAttributes(p)
+       if e != nil {
+               return false
+       }
+       return attrs&windows.FILE_ATTRIBUTE_HIDDEN != 0
+}

diff --git a/vendor/github.com/ipfs/go-ipfs-files/linkfile.go b/vendor/github.com/ipfs/go-ipfs-files/linkfile.go
new file mode 100644 (file)
index 0000000..409309b
--- /dev/null
+++ b/vendor/github.com/ipfs/go-ipfs-files/linkfile.go
@@ -0,0 +1,53 @@
+package files
+
+import (
+       "io"
+       "os"
+       "strings"
+)
+
+type Symlink struct {
+       Target string
+       stat   os.FileInfo
+
+       reader io.Reader
+}
+
+func NewLinkFile(target string, stat os.FileInfo) File {
+       return &Symlink{
+               Target: target,
+               stat:   stat,
+               reader: strings.NewReader(target),
+       }
+}
+
+func (lf *Symlink) Close() error {
+       if c, ok := lf.reader.(io.Closer); ok {
+               return c.Close()
+       }
+
+       return nil
+}
+
+func (lf *Symlink) Read(b []byte) (int, error) {
+       return lf.reader.Read(b)
+}
+
+func (lf *Symlink) Seek(offset int64, whence int) (int64, error) {
+       if s, ok := lf.reader.(io.Seeker); ok {
+               return s.Seek(offset, whence)
+       }
+
+       return 0, ErrNotSupported
+}
+
+func (lf *Symlink) Size() (int64, error) {
+       return 0, ErrNotSupported
+}
+
+func ToSymlink(n Node) *Symlink {
+       l, _ := n.(*Symlink)
+       return l
+}
+
+var _ File = &Symlink{}

diff --git a/vendor/github.com/ipfs/go-ipfs-files/multifilereader.go b/vendor/github.com/ipfs/go-ipfs-files/multifilereader.go
new file mode 100644 (file)
index 0000000..cf3d14c
--- /dev/null
+++ b/vendor/github.com/ipfs/go-ipfs-files/multifilereader.go
@@ -0,0 +1,147 @@
+package files
+
+import (
+       "bytes"
+       "fmt"
+       "io"
+       "mime/multipart"
+       "net/textproto"
+       "net/url"
+       "path"
+       "sync"
+)
+
+// MultiFileReader reads from a `commands.Node` (which can be a directory of files
+// or a regular file) as HTTP multipart encoded data.
+type MultiFileReader struct {
+       io.Reader
+
+       // directory stack for NextFile
+       files []DirIterator
+       path  []string
+
+       currentFile Node
+       buf         bytes.Buffer
+       mpWriter    *multipart.Writer
+       closed      bool
+       mutex       *sync.Mutex
+
+       // if true, the data will be type 'multipart/form-data'
+       // if false, the data will be type 'multipart/mixed'
+       form bool
+}
+
+// NewMultiFileReader constructs a MultiFileReader. `file` can be any `commands.Directory`.
+// If `form` is set to true, the multipart data will have a Content-Type of 'multipart/form-data',
+// if `form` is false, the Content-Type will be 'multipart/mixed'.
+func NewMultiFileReader(file Directory, form bool) *MultiFileReader {
+       it := file.Entries()
+
+       mfr := &MultiFileReader{
+               files: []DirIterator{it},
+               path:  []string{""},
+               form:  form,
+               mutex: &sync.Mutex{},
+       }
+       mfr.mpWriter = multipart.NewWriter(&mfr.buf)
+
+       return mfr
+}
+
+func (mfr *MultiFileReader) Read(buf []byte) (written int, err error) {
+       mfr.mutex.Lock()
+       defer mfr.mutex.Unlock()
+
+       // if we are closed and the buffer is flushed, end reading
+       if mfr.closed && mfr.buf.Len() == 0 {
+               return 0, io.EOF
+       }
+
+       // if the current file isn't set, advance to the next file
+       if mfr.currentFile == nil {
+               var entry DirEntry
+
+               for entry == nil {
+                       if len(mfr.files) == 0 {
+                               mfr.mpWriter.Close()
+                               mfr.closed = true
+                               return mfr.buf.Read(buf)
+                       }
+
+                       if !mfr.files[len(mfr.files)-1].Next() {
+                               if mfr.files[len(mfr.files)-1].Err() != nil {
+                                       return 0, mfr.files[len(mfr.files)-1].Err()
+                               }
+                               mfr.files = mfr.files[:len(mfr.files)-1]
+                               mfr.path = mfr.path[:len(mfr.path)-1]
+                               continue
+                       }
+
+                       entry = mfr.files[len(mfr.files)-1]
+               }
+
+               // handle starting a new file part
+               if !mfr.closed {
+
+                       mfr.currentFile = entry.Node()
+
+                       // write the boundary and headers
+                       header := make(textproto.MIMEHeader)
+                       filename := url.QueryEscape(path.Join(path.Join(mfr.path...), entry.Name()))
+                       header.Set("Content-Disposition", fmt.Sprintf("file; filename=\"%s\"", filename))
+
+                       var contentType string
+
+                       switch f := entry.Node().(type) {
+                       case *Symlink:
+                               contentType = "application/symlink"
+                       case Directory:
+                               newIt := f.Entries()
+                               mfr.files = append(mfr.files, newIt)
+                               mfr.path = append(mfr.path, entry.Name())
+                               contentType = "application/x-directory"
+                       case File:
+                               // otherwise, use the file as a reader to read its contents
+                               contentType = "application/octet-stream"
+                       default:
+                               return 0, ErrNotSupported
+                       }
+
+                       header.Set("Content-Type", contentType)
+                       if rf, ok := entry.Node().(FileInfo); ok {
+                               header.Set("abspath", rf.AbsPath())
+                       }
+
+                       _, err := mfr.mpWriter.CreatePart(header)
+                       if err != nil {
+                               return 0, err
+                       }
+               }
+       }
+
+       // if the buffer has something in it, read from it
+       if mfr.buf.Len() > 0 {
+               return mfr.buf.Read(buf)
+       }
+
+       // otherwise, read from file data
+       switch f := mfr.currentFile.(type) {
+       case File:
+               written, err = f.Read(buf)
+               if err != io.EOF {
+                       return written, err
+               }
+       }
+
+       if err := mfr.currentFile.Close(); err != nil {
+               return written, err
+       }
+
+       mfr.currentFile = nil
+       return written, nil
+}
+
+// Boundary returns the boundary string to be used to separate files in the multipart data
+func (mfr *MultiFileReader) Boundary() string {
+       return mfr.mpWriter.Boundary()
+}

diff --git a/vendor/github.com/ipfs/go-ipfs-files/multifilereader_test.go b/vendor/github.com/ipfs/go-ipfs-files/multifilereader_test.go
new file mode 100644 (file)
index 0000000..34cdd15
--- /dev/null
+++ b/vendor/github.com/ipfs/go-ipfs-files/multifilereader_test.go
@@ -0,0 +1,205 @@
+package files
+
+import (
+       "io"
+       "mime/multipart"
+       "testing"
+)
+
+var text = "Some text! :)"
+
+func getTestMultiFileReader(t *testing.T) *MultiFileReader {
+       sf := NewMapDirectory(map[string]Node{
+               "file.txt": NewBytesFile([]byte(text)),
+               "boop": NewMapDirectory(map[string]Node{
+                       "a.txt": NewBytesFile([]byte("bleep")),
+                       "b.txt": NewBytesFile([]byte("bloop")),
+               }),
+               "beep.txt": NewBytesFile([]byte("beep")),
+       })
+
+       // testing output by reading it with the go stdlib "mime/multipart" Reader
+       return NewMultiFileReader(sf, true)
+}
+
+func TestMultiFileReaderToMultiFile(t *testing.T) {
+       mfr := getTestMultiFileReader(t)
+       mpReader := multipart.NewReader(mfr, mfr.Boundary())
+       mf, err := NewFileFromPartReader(mpReader, multipartFormdataType)
+       if err != nil {
+               t.Fatal(err)
+       }
+
+       md, ok := mf.(Directory)
+       if !ok {
+               t.Fatal("Expected a directory")
+       }
+       it := md.Entries()
+
+       if !it.Next() || it.Name() != "beep.txt" {
+               t.Fatal("iterator didn't work as expected")
+       }
+
+       if !it.Next() || it.Name() != "boop" || DirFromEntry(it) == nil {
+               t.Fatal("iterator didn't work as expected")
+       }
+
+       subIt := DirFromEntry(it).Entries()
+
+       if !subIt.Next() || subIt.Name() != "a.txt" || DirFromEntry(subIt) != nil {
+               t.Fatal("iterator didn't work as expected")
+       }
+
+       if !subIt.Next() || subIt.Name() != "b.txt" || DirFromEntry(subIt) != nil {
+               t.Fatal("iterator didn't work as expected")
+       }
+
+       if subIt.Next() || it.Err() != nil {
+               t.Fatal("iterator didn't work as expected")
+       }
+
+       // try to break internal state
+       if subIt.Next() || it.Err() != nil {
+               t.Fatal("iterator didn't work as expected")
+       }
+
+       if !it.Next() || it.Name() != "file.txt" || DirFromEntry(it) != nil || it.Err() != nil {
+               t.Fatal("iterator didn't work as expected")
+       }
+
+       if it.Next() || it.Err() != nil {
+               t.Fatal("iterator didn't work as expected")
+       }
+}
+
+func TestMultiFileReaderToMultiFileSkip(t *testing.T) {
+       mfr := getTestMultiFileReader(t)
+       mpReader := multipart.NewReader(mfr, mfr.Boundary())
+       mf, err := NewFileFromPartReader(mpReader, multipartFormdataType)
+       if err != nil {
+               t.Fatal(err)
+       }
+
+       md, ok := mf.(Directory)
+       if !ok {
+               t.Fatal("Expected a directory")
+       }
+       it := md.Entries()
+
+       if !it.Next() || it.Name() != "beep.txt" {
+               t.Fatal("iterator didn't work as expected")
+       }
+
+       if !it.Next() || it.Name() != "boop" || DirFromEntry(it) == nil {
+               t.Fatal("iterator didn't work as expected")
+       }
+
+       if !it.Next() || it.Name() != "file.txt" || DirFromEntry(it) != nil || it.Err() != nil {
+               t.Fatal("iterator didn't work as expected")
+       }
+
+       if it.Next() || it.Err() != nil {
+               t.Fatal("iterator didn't work as expected")
+       }
+}
+
+func TestOutput(t *testing.T) {
+       mfr := getTestMultiFileReader(t)
+       walker := &multipartWalker{reader: multipart.NewReader(mfr, mfr.Boundary())}
+       buf := make([]byte, 20)
+
+       mpf, err := walker.nextFile()
+       if mpf == nil || err != nil {
+               t.Fatal("Expected non-nil multipartFile, nil error")
+       }
+       mpr, ok := mpf.(File)
+       if !ok {
+               t.Fatal("Expected file to be a regular file")
+       }
+       if n, err := mpr.Read(buf); n != 4 || err != nil {
+               t.Fatal("Expected to read from file", n, err)
+       }
+       if string(buf[:4]) != "beep" {
+               t.Fatal("Data read was different than expected")
+       }
+
+       mpf, err = walker.nextFile()
+       if mpf == nil || err != nil {
+               t.Fatal("Expected non-nil multipartFile, nil error")
+       }
+       mpd, ok := mpf.(Directory)
+       if !ok {
+               t.Fatal("Expected file to be a directory")
+       }
+
+       child, err := walker.nextFile()
+       if child == nil || err != nil {
+               t.Fatal("Expected to be able to read a child file")
+       }
+       if _, ok := child.(File); !ok {
+               t.Fatal("Expected file to not be a directory")
+       }
+
+       child, err = walker.nextFile()
+       if child == nil || err != nil {
+               t.Fatal("Expected to be able to read a child file")
+       }
+       if _, ok := child.(File); !ok {
+               t.Fatal("Expected file to not be a directory")
+       }
+
+       it := mpd.Entries()
+       if it.Next() {
+               t.Fatal("Expected to get false")
+       }
+
+       mpf, err = walker.nextFile()
+       if mpf == nil || err != nil {
+               t.Fatal("Expected non-nil multipartFile, nil error")
+       }
+
+       part, err := walker.getPart()
+       if part != nil || err != io.EOF {
+               t.Fatal("Expected to get (nil, io.EOF)")
+       }
+}
+
+func TestCommonPrefix(t *testing.T) {
+       sf := NewMapDirectory(map[string]Node{
+               "boop": NewMapDirectory(map[string]Node{
+                       "a":   NewBytesFile([]byte("bleep")),
+                       "aa":  NewBytesFile([]byte("bleep")),
+                       "aaa": NewBytesFile([]byte("bleep")),
+               }),
+       })
+       mfr := NewMultiFileReader(sf, true)
+       reader, err := NewFileFromPartReader(multipart.NewReader(mfr, mfr.Boundary()), multipartFormdataType)
+       if err != nil {
+               t.Fatal(err)
+       }
+
+       CheckDir(t, reader, []Event{
+               {
+                       kind: TDirStart,
+                       name: "boop",
+               },
+               {
+                       kind:  TFile,
+                       name:  "a",
+                       value: "bleep",
+               },
+               {
+                       kind:  TFile,
+                       name:  "aa",
+                       value: "bleep",
+               },
+               {
+                       kind:  TFile,
+                       name:  "aaa",
+                       value: "bleep",
+               },
+               {
+                       kind: TDirEnd,
+               },
+       })
+}

diff --git a/vendor/github.com/ipfs/go-ipfs-files/multipartfile.go b/vendor/github.com/ipfs/go-ipfs-files/multipartfile.go
new file mode 100644 (file)
index 0000000..1768165
--- /dev/null
+++ b/vendor/github.com/ipfs/go-ipfs-files/multipartfile.go
@@ -0,0 +1,236 @@
+package files
+
+import (
+       "io"
+       "io/ioutil"
+       "mime"
+       "mime/multipart"
+       "net/url"
+       "path"
+       "strings"
+)
+
+const (
+       multipartFormdataType = "multipart/form-data"
+       multipartMixedType    = "multipart/mixed"
+
+       applicationDirectory = "application/x-directory"
+       applicationSymlink   = "application/symlink"
+       applicationFile      = "application/octet-stream"
+
+       contentTypeHeader = "Content-Type"
+)
+
+type multipartDirectory struct {
+       path   string
+       walker *multipartWalker
+
+       // part is the part describing the directory. It's nil when implicit.
+       part *multipart.Part
+}
+
+type multipartWalker struct {
+       part   *multipart.Part
+       reader *multipart.Reader
+}
+
+func (m *multipartWalker) consumePart() {
+       m.part = nil
+}
+
+func (m *multipartWalker) getPart() (*multipart.Part, error) {
+       if m.part != nil {
+               return m.part, nil
+       }
+       if m.reader == nil {
+               return nil, io.EOF
+       }
+
+       var err error
+       m.part, err = m.reader.NextPart()
+       if err == io.EOF {
+               m.reader = nil
+       }
+       return m.part, err
+}
+
+func NewFileFromPartReader(reader *multipart.Reader, mediatype string) (Directory, error) {
+       if !isDirectory(mediatype) {
+               return nil, ErrNotDirectory
+       }
+
+       return &multipartDirectory{
+               path: "/",
+               walker: &multipartWalker{
+                       reader: reader,
+               },
+       }, nil
+}
+
+func (w *multipartWalker) nextFile() (Node, error) {
+       part, err := w.getPart()
+       if err != nil {
+               return nil, err
+       }
+       w.consumePart()
+
+       contentType := part.Header.Get(contentTypeHeader)
+       switch contentType {
+       case applicationSymlink:
+               out, err := ioutil.ReadAll(part)
+               if err != nil {
+                       return nil, err
+               }
+
+               return NewLinkFile(string(out), nil), nil
+       case "": // default to application/octet-stream
+               fallthrough
+       case applicationFile:
+               return &ReaderFile{
+                       reader:  part,
+                       abspath: part.Header.Get("abspath"),
+               }, nil
+       }
+
+       mediatype, _, err := mime.ParseMediaType(contentType)
+       if err != nil {
+               return nil, err
+       }
+
+       if !isDirectory(mediatype) {
+               return &ReaderFile{
+                       reader:  part,
+                       abspath: part.Header.Get("abspath"),
+               }, nil
+       }
+
+       return &multipartDirectory{
+               part:   part,
+               path:   fileName(part),
+               walker: w,
+       }, nil
+}
+
+// fileName returns a normalized filename from a part.
+func fileName(part *multipart.Part) string {
+       filename := part.FileName()
+       if escaped, err := url.QueryUnescape(filename); err == nil {
+               filename = escaped
+       } // if there is a unescape error, just treat the name as unescaped
+
+       return path.Clean("/" + filename)
+}
+
+// dirName appends a slash to the end of the filename, if not present.
+// expects a _cleaned_ path.
+func dirName(filename string) string {
+       if !strings.HasSuffix(filename, "/") {
+               filename += "/"
+       }
+       return filename
+}
+
+// isDirectory checks if the media type is a valid directory media type.
+func isDirectory(mediatype string) bool {
+       return mediatype == multipartFormdataType || mediatype == applicationDirectory
+}
+
+// isChild checks if child is a child of parent directory.
+// expects a _cleaned_ path.
+func isChild(child, parent string) bool {
+       return strings.HasPrefix(child, dirName(parent))
+}
+
+// makeRelative makes the child path relative to the parent path.
+// expects a _cleaned_ path.
+func makeRelative(child, parent string) string {
+       return strings.TrimPrefix(child, dirName(parent))
+}
+
+type multipartIterator struct {
+       f *multipartDirectory
+
+       curFile Node
+       curName string
+       err     error
+}
+
+func (it *multipartIterator) Name() string {
+       return it.curName
+}
+
+func (it *multipartIterator) Node() Node {
+       return it.curFile
+}
+
+func (it *multipartIterator) Next() bool {
+       if it.f.walker.reader == nil || it.err != nil {
+               return false
+       }
+       var part *multipart.Part
+       for {
+               part, it.err = it.f.walker.getPart()
+               if it.err != nil {
+                       return false
+               }
+
+               name := fileName(part)
+
+               // Is the file in a different directory?
+               if !isChild(name, it.f.path) {
+                       return false
+               }
+
+               // Have we already entered this directory?
+               if it.curName != "" && isChild(name, path.Join(it.f.path, it.curName)) {
+                       it.f.walker.consumePart()
+                       continue
+               }
+
+               // Make the path relative to the current directory.
+               name = makeRelative(name, it.f.path)
+
+               // Check if we need to create a fake directory (more than one
+               // path component).
+               if idx := strings.IndexByte(name, '/'); idx >= 0 {
+                       it.curName = name[:idx]
+                       it.curFile = &multipartDirectory{
+                               path:   path.Join(it.f.path, it.curName),
+                               walker: it.f.walker,
+                       }
+                       return true
+               }
+               it.curName = name
+
+               // Finally, advance to the next file.
+               it.curFile, it.err = it.f.walker.nextFile()
+
+               return it.err == nil
+       }
+}
+
+func (it *multipartIterator) Err() error {
+       // We use EOF to signal that this iterator is done. That way, we don't
+       // need to check every time `Next` is called.
+       if it.err == io.EOF {
+               return nil
+       }
+       return it.err
+}
+
+func (f *multipartDirectory) Entries() DirIterator {
+       return &multipartIterator{f: f}
+}
+
+func (f *multipartDirectory) Close() error {
+       if f.part != nil {
+               return f.part.Close()
+       }
+       return nil
+}
+
+func (f *multipartDirectory) Size() (int64, error) {
+       return 0, ErrNotSupported
+}
+
+var _ Directory = &multipartDirectory{}

diff --git a/vendor/github.com/ipfs/go-ipfs-files/package.json b/vendor/github.com/ipfs/go-ipfs-files/package.json
new file mode 100644 (file)
index 0000000..07fdc7a
--- /dev/null
+++ b/vendor/github.com/ipfs/go-ipfs-files/package.json
@@ -0,0 +1,24 @@
+{
+  "author": "magik6k",
+  "bugs": {
+    "url": "https://github.com/ipfs/go-ipfs-files"
+  },
+  "gx": {
+    "dvcsimport": "github.com/ipfs/go-ipfs-files"
+  },
+  "gxDependencies": [
+    {
+      "author": "The Go Authors",
+      "hash": "QmVGjyM9i2msKvLXwh9VosCTgP4mL91kC7hDmqnwTTx6Hu",
+      "name": "sys",
+      "version": "0.2.0"
+    }
+  ],
+  "gxVersion": "0.11.0",
+  "language": "go",
+  "license": "",
+  "name": "go-ipfs-files",
+  "releaseCmd": "git commit -a -m \"gx publish $VERSION\"",
+  "version": "2.0.6"
+}
+

diff --git a/vendor/github.com/ipfs/go-ipfs-files/readerfile.go b/vendor/github.com/ipfs/go-ipfs-files/readerfile.go
new file mode 100644 (file)
index 0000000..c233001
--- /dev/null
+++ b/vendor/github.com/ipfs/go-ipfs-files/readerfile.go
@@ -0,0 +1,82 @@
+package files
+
+import (
+       "bytes"
+       "io"
+       "io/ioutil"
+       "os"
+       "path/filepath"
+)
+
+// ReaderFile is a implementation of File created from an `io.Reader`.
+// ReaderFiles are never directories, and can be read from and closed.
+type ReaderFile struct {
+       abspath string
+       reader  io.ReadCloser
+       stat    os.FileInfo
+
+       fsize   int64
+}
+
+func NewBytesFile(b []byte) File {
+       return &ReaderFile{"", NewReaderFile(bytes.NewReader(b)), nil, int64(len(b))}
+}
+
+func NewReaderFile(reader io.Reader) File {
+       return NewReaderStatFile(reader, nil)
+}
+
+func NewReaderStatFile(reader io.Reader, stat os.FileInfo) File {
+       rc, ok := reader.(io.ReadCloser)
+       if !ok {
+               rc = ioutil.NopCloser(reader)
+       }
+
+       return &ReaderFile{"", rc, stat, -1}
+}
+
+func NewReaderPathFile(path string, reader io.ReadCloser, stat os.FileInfo) (*ReaderFile, error) {
+       abspath, err := filepath.Abs(path)
+       if err != nil {
+               return nil, err
+       }
+
+       return &ReaderFile{abspath, reader, stat, -1}, nil
+}
+
+func (f *ReaderFile) AbsPath() string {
+       return f.abspath
+}
+
+func (f *ReaderFile) Read(p []byte) (int, error) {
+       return f.reader.Read(p)
+}
+
+func (f *ReaderFile) Close() error {
+       return f.reader.Close()
+}
+
+func (f *ReaderFile) Stat() os.FileInfo {
+       return f.stat
+}
+
+func (f *ReaderFile) Size() (int64, error) {
+       if f.stat == nil {
+               if f.fsize >= 0 {
+                       return f.fsize, nil
+               }
+               return 0, ErrNotSupported
+       }
+       return f.stat.Size(), nil
+}
+
+func (f *ReaderFile) Seek(offset int64, whence int) (int64, error) {
+       if s, ok := f.reader.(io.Seeker); ok {
+               return s.Seek(offset, whence)
+       }
+
+       return 0, ErrNotSupported
+}
+
+var _ File = &ReaderFile{}
+var _ FileInfo = &ReaderFile{}

diff --git a/vendor/github.com/ipfs/go-ipfs-files/serialfile.go b/vendor/github.com/ipfs/go-ipfs-files/serialfile.go
new file mode 100644 (file)
index 0000000..e29752d
--- /dev/null
+++ b/vendor/github.com/ipfs/go-ipfs-files/serialfile.go
@@ -0,0 +1,178 @@
+package files
+
+import (
+       "errors"
+       "fmt"
+       "io"
+       "io/ioutil"
+       "os"
+       "path/filepath"
+       "strings"
+)
+
+// serialFile implements Node, and reads from a path on the OS filesystem.
+// No more than one file will be opened at a time (directories will advance
+// to the next file when NextFile() is called).
+type serialFile struct {
+       path              string
+       files             []os.FileInfo
+       stat              os.FileInfo
+       handleHiddenFiles bool
+}
+
+type serialIterator struct {
+       files             []os.FileInfo
+       handleHiddenFiles bool
+       path              string
+
+       curName string
+       curFile Node
+
+       err error
+}
+
+// TODO: test/document limitations
+func NewSerialFile(path string, hidden bool, stat os.FileInfo) (Node, error) {
+       switch mode := stat.Mode(); {
+       case mode.IsRegular():
+               file, err := os.Open(path)
+               if err != nil {
+                       return nil, err
+               }
+               return NewReaderPathFile(path, file, stat)
+       case mode.IsDir():
+               // for directories, stat all of the contents first, so we know what files to
+               // open when NextFile() is called
+               contents, err := ioutil.ReadDir(path)
+               if err != nil {
+                       return nil, err
+               }
+               return &serialFile{path, contents, stat, hidden}, nil
+       case mode&os.ModeSymlink != 0:
+               target, err := os.Readlink(path)
+               if err != nil {
+                       return nil, err
+               }
+               return NewLinkFile(target, stat), nil
+       default:
+               return nil, fmt.Errorf("unrecognized file type for %s: %s", path, mode.String())
+       }
+}
+
+func (it *serialIterator) Name() string {
+       return it.curName
+}
+
+func (it *serialIterator) Node() Node {
+       return it.curFile
+}
+
+func (it *serialIterator) Next() bool {
+       // if there aren't any files left in the root directory, we're done
+       if len(it.files) == 0 {
+               return false
+       }
+
+       stat := it.files[0]
+       it.files = it.files[1:]
+       for !it.handleHiddenFiles && strings.HasPrefix(stat.Name(), ".") {
+               if len(it.files) == 0 {
+                       return false
+               }
+
+               stat = it.files[0]
+               it.files = it.files[1:]
+       }
+
+       // open the next file
+       filePath := filepath.ToSlash(filepath.Join(it.path, stat.Name()))
+
+       // recursively call the constructor on the next file
+       // if it's a regular file, we will open it as a ReaderFile
+       // if it's a directory, files in it will be opened serially
+       sf, err := NewSerialFile(filePath, it.handleHiddenFiles, stat)
+       if err != nil {
+               it.err = err
+               return false
+       }
+
+       it.curName = stat.Name()
+       it.curFile = sf
+       return true
+}
+
+func (it *serialIterator) Err() error {
+       return it.err
+}
+
+func (f *serialFile) Entries() DirIterator {
+       return &serialIterator{
+               path:              f.path,
+               files:             f.files,
+               handleHiddenFiles: f.handleHiddenFiles,
+       }
+}
+
+func (f *serialFile) NextFile() (string, Node, error) {
+       // if there aren't any files left in the root directory, we're done
+       if len(f.files) == 0 {
+               return "", nil, io.EOF
+       }
+
+       stat := f.files[0]
+       f.files = f.files[1:]
+
+       for !f.handleHiddenFiles && strings.HasPrefix(stat.Name(), ".") {
+               if len(f.files) == 0 {
+                       return "", nil, io.EOF
+               }
+
+               stat = f.files[0]
+               f.files = f.files[1:]
+       }
+
+       // open the next file
+       filePath := filepath.ToSlash(filepath.Join(f.path, stat.Name()))
+
+       // recursively call the constructor on the next file
+       // if it's a regular file, we will open it as a ReaderFile
+       // if it's a directory, files in it will be opened serially
+       sf, err := NewSerialFile(filePath, f.handleHiddenFiles, stat)
+       if err != nil {
+               return "", nil, err
+       }
+
+       return stat.Name(), sf, nil
+}
+
+func (f *serialFile) Close() error {
+       return nil
+}
+
+func (f *serialFile) Stat() os.FileInfo {
+       return f.stat
+}
+
+func (f *serialFile) Size() (int64, error) {
+       if !f.stat.IsDir() {
+               //something went terribly, terribly wrong
+               return 0, errors.New("serialFile is not a directory")
+       }
+
+       var du int64
+       err := filepath.Walk(f.path, func(p string, fi os.FileInfo, err error) error {
+               if err != nil {
+                       return err
+               }
+
+               if fi != nil && fi.Mode().IsRegular() {
+                       du += fi.Size()
+               }
+               return nil
+       })
+
+       return du, err
+}
+
+var _ Directory = &serialFile{}
+var _ DirIterator = &serialIterator{}

diff --git a/vendor/github.com/ipfs/go-ipfs-files/slicedirectory.go b/vendor/github.com/ipfs/go-ipfs-files/slicedirectory.go
new file mode 100644 (file)
index 0000000..d116562
--- /dev/null
+++ b/vendor/github.com/ipfs/go-ipfs-files/slicedirectory.go
@@ -0,0 +1,97 @@
+package files
+
+import "sort"
+
+type fileEntry struct {
+       name string
+       file Node
+}
+
+func (e fileEntry) Name() string {
+       return e.name
+}
+
+func (e fileEntry) Node() Node {
+       return e.file
+}
+
+func FileEntry(name string, file Node) DirEntry {
+       return fileEntry{
+               name: name,
+               file: file,
+       }
+}
+
+type sliceIterator struct {
+       files []DirEntry
+       n     int
+}
+
+func (it *sliceIterator) Name() string {
+       return it.files[it.n].Name()
+}
+
+func (it *sliceIterator) Node() Node {
+       return it.files[it.n].Node()
+}
+
+func (it *sliceIterator) Next() bool {
+       it.n++
+       return it.n < len(it.files)
+}
+
+func (it *sliceIterator) Err() error {
+       return nil
+}
+
+// SliceFile implements Node, and provides simple directory handling.
+// It contains children files, and is created from a `[]Node`.
+// SliceFiles are always directories, and can't be read from or closed.
+type SliceFile struct {
+       files []DirEntry
+}
+
+func NewMapDirectory(f map[string]Node) Directory {
+       ents := make([]DirEntry, 0, len(f))
+       for name, nd := range f {
+               ents = append(ents, FileEntry(name, nd))
+       }
+       sort.Slice(ents, func(i, j int) bool {
+               return ents[i].Name() < ents[j].Name()
+       })
+
+       return NewSliceDirectory(ents)
+}
+
+func NewSliceDirectory(files []DirEntry) Directory {
+       return &SliceFile{files}
+}
+
+func (f *SliceFile) Entries() DirIterator {
+       return &sliceIterator{files: f.files, n: -1}
+}
+
+func (f *SliceFile) Close() error {
+       return nil
+}
+
+func (f *SliceFile) Length() int {
+       return len(f.files)
+}
+
+func (f *SliceFile) Size() (int64, error) {
+       var size int64
+
+       for _, file := range f.files {
+               s, err := file.Node().Size()
+               if err != nil {
+                       return 0, err
+               }
+               size += s
+       }
+
+       return size, nil
+}
+
+var _ Directory = &SliceFile{}
+var _ DirEntry = fileEntry{}

diff --git a/vendor/github.com/ipfs/go-ipfs-files/tarwriter.go b/vendor/github.com/ipfs/go-ipfs-files/tarwriter.go
new file mode 100644 (file)
index 0000000..101d4c8
--- /dev/null
+++ b/vendor/github.com/ipfs/go-ipfs-files/tarwriter.go
@@ -0,0 +1,101 @@
+package files
+
+import (
+       "archive/tar"
+       "fmt"
+       "io"
+       "path"
+       "time"
+)
+
+type TarWriter struct {
+       TarW *tar.Writer
+}
+
+// NewTarWriter wraps given io.Writer into a new tar writer
+func NewTarWriter(w io.Writer) (*TarWriter, error) {
+       return &TarWriter{
+               TarW: tar.NewWriter(w),
+       }, nil
+}
+
+func (w *TarWriter) writeDir(f Directory, fpath string) error {
+       if err := writeDirHeader(w.TarW, fpath); err != nil {
+               return err
+       }
+
+       it := f.Entries()
+       for it.Next() {
+               if err := w.WriteFile(it.Node(), path.Join(fpath, it.Name())); err != nil {
+                       return err
+               }
+       }
+       return it.Err()
+}
+
+func (w *TarWriter) writeFile(f File, fpath string) error {
+       size, err := f.Size()
+       if err != nil {
+               return err
+       }
+
+       if err := writeFileHeader(w.TarW, fpath, uint64(size)); err != nil {
+               return err
+       }
+
+       if _, err := io.Copy(w.TarW, f); err != nil {
+               return err
+       }
+       w.TarW.Flush()
+       return nil
+}
+
+// WriteNode adds a node to the archive.
+func (w *TarWriter) WriteFile(nd Node, fpath string) error {
+       switch nd := nd.(type) {
+       case *Symlink:
+               return writeSymlinkHeader(w.TarW, nd.Target, fpath)
+       case File:
+               return w.writeFile(nd, fpath)
+       case Directory:
+               return w.writeDir(nd, fpath)
+       default:
+               return fmt.Errorf("file type %T is not supported", nd)
+       }
+}
+
+// Close closes the tar writer.
+func (w *TarWriter) Close() error {
+       return w.TarW.Close()
+}
+
+func writeDirHeader(w *tar.Writer, fpath string) error {
+       return w.WriteHeader(&tar.Header{
+               Name:     fpath,
+               Typeflag: tar.TypeDir,
+               Mode:     0777,
+               ModTime:  time.Now(),
+               // TODO: set mode, dates, etc. when added to unixFS
+       })
+}
+
+func writeFileHeader(w *tar.Writer, fpath string, size uint64) error {
+       return w.WriteHeader(&tar.Header{
+               Name:     fpath,
+               Size:     int64(size),
+               Typeflag: tar.TypeReg,
+               Mode:     0644,
+               ModTime:  time.Now(),
+               // TODO: set mode, dates, etc. when added to unixFS
+       })
+}
+
+func writeSymlinkHeader(w *tar.Writer, target, fpath string) error {
+       return w.WriteHeader(&tar.Header{
+               Name:     fpath,
+               Linkname: target,
+               Mode:     0777,
+               Typeflag: tar.TypeSymlink,
+       })
+}
+

diff --git a/vendor/github.com/ipfs/go-ipfs-files/tarwriter_test.go b/vendor/github.com/ipfs/go-ipfs-files/tarwriter_test.go
new file mode 100644 (file)
index 0000000..38101d0
--- /dev/null
+++ b/vendor/github.com/ipfs/go-ipfs-files/tarwriter_test.go
@@ -0,0 +1,80 @@
+package files
+
+import (
+       "archive/tar"
+       "io"
+       "testing"
+)
+
+func TestTarWriter(t *testing.T) {
+       tf := NewMapDirectory(map[string]Node{
+               "file.txt": NewBytesFile([]byte(text)),
+               "boop": NewMapDirectory(map[string]Node{
+                       "a.txt": NewBytesFile([]byte("bleep")),
+                       "b.txt": NewBytesFile([]byte("bloop")),
+               }),
+               "beep.txt": NewBytesFile([]byte("beep")),
+       })
+
+       pr, pw := io.Pipe()
+       tw, err := NewTarWriter(pw)
+       if err != nil {
+               t.Fatal(err)
+       }
+       tr := tar.NewReader(pr)
+
+       go func() {
+               defer tw.Close()
+               if err := tw.WriteFile(tf, ""); err != nil {
+                       t.Fatal(err)
+               }
+       }()
+
+       var cur *tar.Header
+
+       checkHeader := func(name string, typ byte, size int64) {
+               if cur.Name != name {
+                       t.Errorf("got wrong name: %s != %s", cur.Name, name)
+               }
+               if cur.Typeflag != typ {
+                       t.Errorf("got wrong type: %d != %d", cur.Typeflag, typ)
+               }
+               if cur.Size != size {
+                       t.Errorf("got wrong size: %d != %d", cur.Size, size)
+               }
+       }
+
+       if cur, err = tr.Next(); err != nil {
+               t.Fatal(err)
+       }
+       checkHeader("", tar.TypeDir, 0)
+
+       if cur, err = tr.Next(); err != nil {
+               t.Fatal(err)
+       }
+       checkHeader("beep.txt", tar.TypeReg, 4)
+
+       if cur, err = tr.Next(); err != nil {
+               t.Fatal(err)
+       }
+       checkHeader("boop", tar.TypeDir, 0)
+
+       if cur, err = tr.Next(); err != nil {
+               t.Fatal(err)
+       }
+       checkHeader("boop/a.txt", tar.TypeReg, 5)
+
+       if cur, err = tr.Next(); err != nil {
+               t.Fatal(err)
+       }
+       checkHeader("boop/b.txt", tar.TypeReg, 5)
+
+       if cur, err = tr.Next(); err != nil {
+               t.Fatal(err)
+       }
+       checkHeader("file.txt", tar.TypeReg, 13)
+
+       if cur, err = tr.Next(); err != io.EOF {
+               t.Fatal(err)
+       }
+}
\ No newline at end of file

diff --git a/vendor/github.com/ipfs/go-ipfs-files/util.go b/vendor/github.com/ipfs/go-ipfs-files/util.go
new file mode 100644 (file)
index 0000000..e727e7a
--- /dev/null
+++ b/vendor/github.com/ipfs/go-ipfs-files/util.go
@@ -0,0 +1,25 @@
+package files
+
+// ToFile is an alias for n.(File). If the file isn't a regular file, nil value
+// will be returned
+func ToFile(n Node) File {
+       f, _ := n.(File)
+       return f
+}
+
+// ToDir is an alias for n.(Directory). If the file isn't directory, a nil value
+// will be returned
+func ToDir(n Node) Directory {
+       d, _ := n.(Directory)
+       return d
+}
+
+// FileFromEntry calls ToFile on Node in the given entry
+func FileFromEntry(e DirEntry) File {
+       return ToFile(e.Node())
+}
+
+// DirFromEntry calls ToDir on Node in the given entry
+func DirFromEntry(e DirEntry) Directory {
+       return ToDir(e.Node())
+}

diff --git a/vendor/github.com/ipfs/go-ipfs-files/webfile.go b/vendor/github.com/ipfs/go-ipfs-files/webfile.go
new file mode 100644 (file)
index 0000000..dbc813b
--- /dev/null
+++ b/vendor/github.com/ipfs/go-ipfs-files/webfile.go
@@ -0,0 +1,64 @@
+package files
+
+import (
+       "errors"
+       "io"
+       "net/http"
+       "net/url"
+)
+
+// WebFile is an implementation of File which reads it
+// from a Web URL (http). A GET request will be performed
+// against the source when calling Read().
+type WebFile struct {
+       body          io.ReadCloser
+       url           *url.URL
+       contentLength int64
+}
+
+// NewWebFile creates a WebFile with the given URL, which
+// will be used to perform the GET request on Read().
+func NewWebFile(url *url.URL) *WebFile {
+       return &WebFile{
+               url: url,
+       }
+}
+
+// Read reads the File from it's web location. On the first
+// call to Read, a GET request will be performed against the
+// WebFile's URL, using Go's default HTTP client. Any further
+// reads will keep reading from the HTTP Request body.
+func (wf *WebFile) Read(b []byte) (int, error) {
+       if wf.body == nil {
+               resp, err := http.Get(wf.url.String())
+               if err != nil {
+                       return 0, err
+               }
+               wf.body = resp.Body
+               wf.contentLength = resp.ContentLength
+       }
+       return wf.body.Read(b)
+}
+
+// Close closes the WebFile (or the request body).
+func (wf *WebFile) Close() error {
+       if wf.body == nil {
+               return nil
+       }
+       return wf.body.Close()
+}
+
+// TODO: implement
+func (wf *WebFile) Seek(offset int64, whence int) (int64, error) {
+       return 0, ErrNotSupported
+}
+
+func (wf *WebFile) Size() (int64, error) {
+       if wf.contentLength < 0 {
+               return -1, errors.New("Content-Length hearer was not set")
+       }
+
+       return wf.contentLength, nil
+}
+
+var _ File = &WebFile{}

diff --git a/vendor/github.com/ipfs/go-ipfs-files/webfile_test.go b/vendor/github.com/ipfs/go-ipfs-files/webfile_test.go
new file mode 100644 (file)
index 0000000..889cdc4
--- /dev/null
+++ b/vendor/github.com/ipfs/go-ipfs-files/webfile_test.go
@@ -0,0 +1,34 @@
+package files
+
+import (
+       "fmt"
+       "io/ioutil"
+       "net/http"
+       "net/http/httptest"
+       "net/url"
+       "testing"
+)
+
+func TestWebFile(t *testing.T) {
+       http.HandleFunc("/my/url/content.txt", func(w http.ResponseWriter, r *http.Request) {
+               fmt.Fprintf(w, "Hello world!")
+       })
+
+       s := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+               fmt.Fprintf(w, "Hello world!")
+       }))
+       defer s.Close()
+
+       u, err := url.Parse(s.URL)
+       if err != nil {
+               t.Fatal(err)
+       }
+       wf := NewWebFile(u)
+       body, err := ioutil.ReadAll(wf)
+       if err != nil {
+               t.Fatal(err)
+       }
+       if string(body) != "Hello world!" {
+               t.Fatal("should have read the web file")
+       }
+}

diff --git a/vendor/github.com/libp2p/go-libp2p-crypto/.gitignore b/vendor/github.com/libp2p/go-libp2p-crypto/.gitignore
new file mode 100644 (file)
index 0000000..cc53fd5
--- /dev/null
+++ b/vendor/github.com/libp2p/go-libp2p-crypto/.gitignore
@@ -0,0 +1,7 @@
+.DS_Store
+
+# vim
+.swp
+*~
+*.swp
+*.swo

diff --git a/vendor/github.com/libp2p/go-libp2p-crypto/.gx/lastpubver b/vendor/github.com/libp2p/go-libp2p-crypto/.gx/lastpubver
new file mode 100644 (file)
index 0000000..2ae4980
--- /dev/null
+++ b/vendor/github.com/libp2p/go-libp2p-crypto/.gx/lastpubver
@@ -0,0 +1 @@
+2.0.7: QmTW4SdgBWq9GjsBsHeUx8WuGxzhgzAf88UMH2w62PC8yK

diff --git a/vendor/github.com/libp2p/go-libp2p-crypto/.travis.yml b/vendor/github.com/libp2p/go-libp2p-crypto/.travis.yml
new file mode 100644 (file)
index 0000000..9a7e494
--- /dev/null
+++ b/vendor/github.com/libp2p/go-libp2p-crypto/.travis.yml
@@ -0,0 +1,20 @@
+language: go
+sudo: true
+
+go:
+  - 1.11.x
+
+install:
+  - make deps
+
+script:
+  - bash <(curl -s https://raw.githubusercontent.com/ipfs/ci-helpers/master/travis-ci/run-standard-tests.sh)
+
+cache:
+  directories:
+    - $GOPATH/src/gx
+
+notifications:
+  email: false
+
+env: GOTFLAGS="-race"

diff --git a/vendor/github.com/libp2p/go-libp2p-crypto/LICENSE b/vendor/github.com/libp2p/go-libp2p-crypto/LICENSE
new file mode 100644 (file)
index 0000000..2610033
--- /dev/null
+++ b/vendor/github.com/libp2p/go-libp2p-crypto/LICENSE
@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2016 Jeromy Johnson
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

diff --git a/vendor/github.com/libp2p/go-libp2p-crypto/Makefile b/vendor/github.com/libp2p/go-libp2p-crypto/Makefile
new file mode 100644 (file)
index 0000000..7c146b1
--- /dev/null
+++ b/vendor/github.com/libp2p/go-libp2p-crypto/Makefile
@@ -0,0 +1,14 @@
+test: deps
+       go test -race -v ./...
+
+export IPFS_API ?= v04x.ipfs.io
+
+gx:
+       go get -u github.com/whyrusleeping/gx
+       go get -u github.com/whyrusleeping/gx-go
+
+deps: gx
+       gx --verbose install --global
+       gx-go rewrite
+       go get -t ./...
+

diff --git a/vendor/github.com/libp2p/go-libp2p-crypto/README.md b/vendor/github.com/libp2p/go-libp2p-crypto/README.md
new file mode 100644 (file)
index 0000000..ac1b554
--- /dev/null
+++ b/vendor/github.com/libp2p/go-libp2p-crypto/README.md
@@ -0,0 +1,40 @@
+# go-libp2p-crypto
+[![](https://img.shields.io/badge/project-libp2p-yellow.svg?style=flat-square)](http://libp2p.io/)
+[![](https://img.shields.io/badge/pm-waffle-yellow.svg?style=flat-square)](http://github.com/libp2p/libp2p)
+[![](https://img.shields.io/badge/freenode-%23libp2p-yellow.svg?style=flat-square)](http://webchat.freenode.net/?channels=%23libp2p)
+[![standard-readme compliant](https://img.shields.io/badge/standard--readme-OK-green.svg?style=flat-square)](https://github.com/RichardLitt/standard-readme)
+[![GoDoc](https://godoc.org/github.com/libp2p/go-libp2p-crypto?status.svg)](https://godoc.org/github.com/ipfs/go-libp2p-crypto)
+[![Coverage Status](https://coveralls.io/repos/github/ipfs/go-libp2p-crypto/badge.svg?branch=master)](https://coveralls.io/github/ipfs/go-libp2p-crypto?branch=master)
+[![Build Status](https://travis-ci.org/libp2p/go-libp2p-crypto.svg?branch=master)](https://travis-ci.org/libp2p/go-libp2p-crypto)
+
+> Various cryptographic utilities used by ipfs
+
+## Table of Contents
+
+- [Install](#install)
+- [Usage](#usage)
+- [Contribute](#contribute)
+  - [Want to hack on IPFS?](#want-to-hack-on-ipfs)
+- [License](#license)
+
+## Install
+
+```sh
+go get github.com/libp2p/go-libp2p-crypto
+```
+
+## Usage
+
+Go to https://godoc.org/github.com/libp2p/go-libp2p-crypto.
+
+## Contribute
+
+Feel free to join in. All welcome. Open an [issue](https://github.com/libp2p/go-libp2p-crypto/issues)!
+
+Check out our [contributing document](https://github.com/libp2p/community/blob/master/CONTRIBUTE.md) for more information on how we work, and about contributing in general. Please be aware that all interactions related to libp2p are subject to the IPFS [Code of Conduct](https://github.com/ipfs/community/blob/master/code-of-conduct.md).
+
+Small note: If editing the README, please conform to the [standard-readme](https://github.com/RichardLitt/standard-readme) specification.
+
+## License
+
+[MIT](LICENSE) © 2016 Jeromy Johnson

diff --git a/vendor/github.com/libp2p/go-libp2p-crypto/bench_test.go b/vendor/github.com/libp2p/go-libp2p-crypto/bench_test.go
new file mode 100644 (file)
index 0000000..fffc3bb
--- /dev/null
+++ b/vendor/github.com/libp2p/go-libp2p-crypto/bench_test.go
@@ -0,0 +1,84 @@
+package crypto
+
+import "testing"
+
+func BenchmarkSignRSA1B(b *testing.B)      { RunBenchmarkSignRSA(b, 1) }
+func BenchmarkSignRSA10B(b *testing.B)     { RunBenchmarkSignRSA(b, 10) }
+func BenchmarkSignRSA100B(b *testing.B)    { RunBenchmarkSignRSA(b, 100) }
+func BenchmarkSignRSA1000B(b *testing.B)   { RunBenchmarkSignRSA(b, 1000) }
+func BenchmarkSignRSA10000B(b *testing.B)  { RunBenchmarkSignRSA(b, 10000) }
+func BenchmarkSignRSA100000B(b *testing.B) { RunBenchmarkSignRSA(b, 100000) }
+
+func BenchmarkVerifyRSA1B(b *testing.B)      { RunBenchmarkVerifyRSA(b, 1) }
+func BenchmarkVerifyRSA10B(b *testing.B)     { RunBenchmarkVerifyRSA(b, 10) }
+func BenchmarkVerifyRSA100B(b *testing.B)    { RunBenchmarkVerifyRSA(b, 100) }
+func BenchmarkVerifyRSA1000B(b *testing.B)   { RunBenchmarkVerifyRSA(b, 1000) }
+func BenchmarkVerifyRSA10000B(b *testing.B)  { RunBenchmarkVerifyRSA(b, 10000) }
+func BenchmarkVerifyRSA100000B(b *testing.B) { RunBenchmarkVerifyRSA(b, 100000) }
+
+func BenchmarkSignEd255191B(b *testing.B)      { RunBenchmarkSignEd25519(b, 1) }
+func BenchmarkSignEd2551910B(b *testing.B)     { RunBenchmarkSignEd25519(b, 10) }
+func BenchmarkSignEd25519100B(b *testing.B)    { RunBenchmarkSignEd25519(b, 100) }
+func BenchmarkSignEd255191000B(b *testing.B)   { RunBenchmarkSignEd25519(b, 1000) }
+func BenchmarkSignEd2551910000B(b *testing.B)  { RunBenchmarkSignEd25519(b, 10000) }
+func BenchmarkSignEd25519100000B(b *testing.B) { RunBenchmarkSignEd25519(b, 100000) }
+
+func BenchmarkVerifyEd255191B(b *testing.B)      { RunBenchmarkVerifyEd25519(b, 1) }
+func BenchmarkVerifyEd2551910B(b *testing.B)     { RunBenchmarkVerifyEd25519(b, 10) }
+func BenchmarkVerifyEd25519100B(b *testing.B)    { RunBenchmarkVerifyEd25519(b, 100) }
+func BenchmarkVerifyEd255191000B(b *testing.B)   { RunBenchmarkVerifyEd25519(b, 1000) }
+func BenchmarkVerifyEd2551910000B(b *testing.B)  { RunBenchmarkVerifyEd25519(b, 10000) }
+func BenchmarkVerifyEd25519100000B(b *testing.B) { RunBenchmarkVerifyEd25519(b, 100000) }
+
+func RunBenchmarkSignRSA(b *testing.B, numBytes int) {
+       runBenchmarkSign(b, numBytes, RSA)
+}
+
+func RunBenchmarkSignEd25519(b *testing.B, numBytes int) {
+       runBenchmarkSign(b, numBytes, Ed25519)
+}
+
+func runBenchmarkSign(b *testing.B, numBytes int, t int) {
+       secret, _, err := GenerateKeyPair(t, 1024)
+       if err != nil {
+               b.Fatal(err)
+       }
+       someData := make([]byte, numBytes)
+       b.ResetTimer()
+       for i := 0; i < b.N; i++ {
+               _, err := secret.Sign(someData)
+               if err != nil {
+                       b.Fatal(err)
+               }
+       }
+}
+
+func RunBenchmarkVerifyRSA(b *testing.B, numBytes int) {
+       runBenchmarkSign(b, numBytes, RSA)
+}
+
+func RunBenchmarkVerifyEd25519(b *testing.B, numBytes int) {
+       runBenchmarkSign(b, numBytes, Ed25519)
+}
+
+func runBenchmarkVerify(b *testing.B, numBytes int, t int) {
+       secret, public, err := GenerateKeyPair(t, 1024)
+       if err != nil {
+               b.Fatal(err)
+       }
+       someData := make([]byte, numBytes)
+       signature, err := secret.Sign(someData)
+       if err != nil {
+               b.Fatal(err)
+       }
+       b.ResetTimer()
+       for i := 0; i < b.N; i++ {
+               valid, err := public.Verify(someData, signature)
+               if err != nil {
+                       b.Fatal(err)
+               }
+               if !valid {
+                       b.Fatal("signature should be valid")
+               }
+       }
+}

diff --git a/vendor/github.com/libp2p/go-libp2p-crypto/codecov.yml b/vendor/github.com/libp2p/go-libp2p-crypto/codecov.yml
new file mode 100644 (file)
index 0000000..5f88a9e
--- /dev/null
+++ b/vendor/github.com/libp2p/go-libp2p-crypto/codecov.yml
@@ -0,0 +1,3 @@
+coverage:
+  range: "50...100"
+comment: off

diff --git a/vendor/github.com/libp2p/go-libp2p-crypto/ecdsa.go b/vendor/github.com/libp2p/go-libp2p-crypto/ecdsa.go
new file mode 100644 (file)
index 0000000..80229a4
--- /dev/null
+++ b/vendor/github.com/libp2p/go-libp2p-crypto/ecdsa.go
@@ -0,0 +1,186 @@
+package crypto
+
+import (
+       "crypto/ecdsa"
+       "crypto/elliptic"
+       "crypto/rand"
+       "crypto/x509"
+       "encoding/asn1"
+       "errors"
+       "io"
+       "math/big"
+
+       pb "github.com/libp2p/go-libp2p-crypto/pb"
+
+       sha256 "github.com/minio/sha256-simd"
+)
+
+// ECDSAPrivateKey is an implementation of an ECDSA private key
+type ECDSAPrivateKey struct {
+       priv *ecdsa.PrivateKey
+}
+
+// ECDSAPublicKey is an implementation of an ECDSA public key
+type ECDSAPublicKey struct {
+       pub *ecdsa.PublicKey
+}
+
+// ECDSASig holds the r and s values of an ECDSA signature
+type ECDSASig struct {
+       R, S *big.Int
+}
+
+var (
+       // ErrNotECDSAPubKey is returned when the public key passed is not an ecdsa public key
+       ErrNotECDSAPubKey = errors.New("not an ecdsa public key")
+       // ErrNilSig is returned when the signature is nil
+       ErrNilSig = errors.New("sig is nil")
+       // ErrNilPrivateKey is returned when a nil private key is provided
+       ErrNilPrivateKey = errors.New("private key is nil")
+       // ECDSACurve is the default ecdsa curve used
+       ECDSACurve = elliptic.P256()
+)
+
+// GenerateECDSAKeyPair generates a new ecdsa private and public key
+func GenerateECDSAKeyPair(src io.Reader) (PrivKey, PubKey, error) {
+       return GenerateECDSAKeyPairWithCurve(ECDSACurve, src)
+}
+
+// GenerateECDSAKeyPairWithCurve generates a new ecdsa private and public key with a speicified curve
+func GenerateECDSAKeyPairWithCurve(curve elliptic.Curve, src io.Reader) (PrivKey, PubKey, error) {
+       priv, err := ecdsa.GenerateKey(curve, src)
+       if err != nil {
+               return nil, nil, err
+       }
+
+       return &ECDSAPrivateKey{priv}, &ECDSAPublicKey{&priv.PublicKey}, nil
+}
+
+// ECDSAKeyPairFromKey generates a new ecdsa private and public key from an input private key
+func ECDSAKeyPairFromKey(priv *ecdsa.PrivateKey) (PrivKey, PubKey, error) {
+       if priv == nil {
+               return nil, nil, ErrNilPrivateKey
+       }
+
+       return &ECDSAPrivateKey{priv}, &ECDSAPublicKey{&priv.PublicKey}, nil
+}
+
+// MarshalECDSAPrivateKey returns x509 bytes from a private key
+func MarshalECDSAPrivateKey(ePriv ECDSAPrivateKey) ([]byte, error) {
+       return x509.MarshalECPrivateKey(ePriv.priv)
+}
+
+// MarshalECDSAPublicKey returns x509 bytes from a public key
+func MarshalECDSAPublicKey(ePub ECDSAPublicKey) ([]byte, error) {
+       return x509.MarshalPKIXPublicKey(ePub.pub)
+}
+
+// UnmarshalECDSAPrivateKey returns a private key from x509 bytes
+func UnmarshalECDSAPrivateKey(data []byte) (PrivKey, error) {
+       priv, err := x509.ParseECPrivateKey(data)
+       if err != nil {
+               return nil, err
+       }
+
+       return &ECDSAPrivateKey{priv}, nil
+}
+
+// UnmarshalECDSAPublicKey returns the public key from x509 bytes
+func UnmarshalECDSAPublicKey(data []byte) (PubKey, error) {
+       pubIfc, err := x509.ParsePKIXPublicKey(data)
+       if err != nil {
+               return nil, err
+       }
+
+       pub, ok := pubIfc.(*ecdsa.PublicKey)
+       if !ok {
+               return nil, ErrNotECDSAPubKey
+       }
+
+       return &ECDSAPublicKey{pub}, nil
+}
+
+// Bytes returns the private key as protobuf bytes
+func (ePriv *ECDSAPrivateKey) Bytes() ([]byte, error) {
+       return MarshalPrivateKey(ePriv)
+}
+
+// Type returns the key type
+func (ePriv *ECDSAPrivateKey) Type() pb.KeyType {
+       return pb.KeyType_ECDSA
+}
+
+// Raw returns x509 bytes from a private key
+func (ePriv *ECDSAPrivateKey) Raw() ([]byte, error) {
+       return x509.MarshalECPrivateKey(ePriv.priv)
+}
+
+// Equals compares to private keys
+func (ePriv *ECDSAPrivateKey) Equals(o Key) bool {
+       oPriv, ok := o.(*ECDSAPrivateKey)
+       if !ok {
+               return false
+       }
+
+       return ePriv.priv.D.Cmp(oPriv.priv.D) == 0
+}
+
+// Sign returns the signature of the input data
+func (ePriv *ECDSAPrivateKey) Sign(data []byte) ([]byte, error) {
+       hash := sha256.Sum256(data)
+       r, s, err := ecdsa.Sign(rand.Reader, ePriv.priv, hash[:])
+       if err != nil {
+               return nil, err
+       }
+
+       return asn1.Marshal(ECDSASig{
+               R: r,
+               S: s,
+       })
+}
+
+// GetPublic returns a public key
+func (ePriv *ECDSAPrivateKey) GetPublic() PubKey {
+       return &ECDSAPublicKey{&ePriv.priv.PublicKey}
+}
+
+// Bytes returns the public key as protobuf bytes
+func (ePub *ECDSAPublicKey) Bytes() ([]byte, error) {
+       return MarshalPublicKey(ePub)
+}
+
+// Type returns the key type
+func (ePub *ECDSAPublicKey) Type() pb.KeyType {
+       return pb.KeyType_ECDSA
+}
+
+// Raw returns x509 bytes from a public key
+func (ePub ECDSAPublicKey) Raw() ([]byte, error) {
+       return x509.MarshalPKIXPublicKey(ePub.pub)
+}
+
+// Equals compares to public keys
+func (ePub *ECDSAPublicKey) Equals(o Key) bool {
+       oPub, ok := o.(*ECDSAPublicKey)
+       if !ok {
+               return false
+       }
+
+       return ePub.pub.X != nil && ePub.pub.Y != nil && oPub.pub.X != nil && oPub.pub.Y != nil &&
+               0 == ePub.pub.X.Cmp(oPub.pub.X) && 0 == ePub.pub.Y.Cmp(oPub.pub.Y)
+}
+
+// Verify compares data to a signature
+func (ePub *ECDSAPublicKey) Verify(data, sigBytes []byte) (bool, error) {
+       sig := new(ECDSASig)
+       if _, err := asn1.Unmarshal(sigBytes, sig); err != nil {
+               return false, err
+       }
+       if sig == nil {
+               return false, ErrNilSig
+       }
+
+       hash := sha256.Sum256(data)
+
+       return ecdsa.Verify(ePub.pub, hash[:], sig.R, sig.S), nil
+}

diff --git a/vendor/github.com/libp2p/go-libp2p-crypto/ecdsa_test.go b/vendor/github.com/libp2p/go-libp2p-crypto/ecdsa_test.go
new file mode 100644 (file)
index 0000000..328b9a7
--- /dev/null
+++ b/vendor/github.com/libp2p/go-libp2p-crypto/ecdsa_test.go
@@ -0,0 +1,96 @@
+package crypto
+
+import (
+       "crypto/rand"
+       "testing"
+)
+
+func TestECDSABasicSignAndVerify(t *testing.T) {
+       priv, pub, err := GenerateECDSAKeyPair(rand.Reader)
+       if err != nil {
+               t.Fatal(err)
+       }
+
+       data := []byte("hello! and welcome to some awesome crypto primitives")
+
+       sig, err := priv.Sign(data)
+       if err != nil {
+               t.Fatal(err)
+       }
+
+       ok, err := pub.Verify(data, sig)
+       if err != nil {
+               t.Fatal(err)
+       }
+
+       if !ok {
+               t.Fatal("signature didnt match")
+       }
+
+       // change data
+       data[0] = ^data[0]
+       ok, err = pub.Verify(data, sig)
+       if err != nil {
+               t.Fatal(err)
+       }
+
+       if ok {
+               t.Fatal("signature matched and shouldn't")
+       }
+}
+
+func TestECDSASignZero(t *testing.T) {
+       priv, pub, err := GenerateECDSAKeyPair(rand.Reader)
+       if err != nil {
+               t.Fatal(err)
+       }
+
+       data := make([]byte, 0)
+       sig, err := priv.Sign(data)
+       if err != nil {
+               t.Fatal(err)
+       }
+
+       ok, err := pub.Verify(data, sig)
+       if err != nil {
+               t.Fatal(err)
+       }
+       if !ok {
+               t.Fatal("signature didn't match")
+       }
+}
+
+func TestECDSAMarshalLoop(t *testing.T) {
+       priv, pub, err := GenerateECDSAKeyPair(rand.Reader)
+       if err != nil {
+               t.Fatal(err)
+       }
+
+       privB, err := priv.Bytes()
+       if err != nil {
+               t.Fatal(err)
+       }
+
+       privNew, err := UnmarshalPrivateKey(privB)
+       if err != nil {
+               t.Fatal(err)
+       }
+
+       if !priv.Equals(privNew) || !privNew.Equals(priv) {
+               t.Fatal("keys are not equal")
+       }
+
+       pubB, err := pub.Bytes()
+       if err != nil {
+               t.Fatal(err)
+       }
+       pubNew, err := UnmarshalPublicKey(pubB)
+       if err != nil {
+               t.Fatal(err)
+       }
+
+       if !pub.Equals(pubNew) || !pubNew.Equals(pub) {
+               t.Fatal("keys are not equal")
+       }
+
+}

diff --git a/vendor/github.com/libp2p/go-libp2p-crypto/ed25519.go b/vendor/github.com/libp2p/go-libp2p-crypto/ed25519.go
new file mode 100644 (file)
index 0000000..960ad31
--- /dev/null
+++ b/vendor/github.com/libp2p/go-libp2p-crypto/ed25519.go
@@ -0,0 +1,155 @@
+package crypto
+
+import (
+       "bytes"
+       "errors"
+       "fmt"
+       "io"
+
+       pb "github.com/libp2p/go-libp2p-crypto/pb"
+
+       "golang.org/x/crypto/ed25519"
+)
+
+// Ed25519PrivateKey is an ed25519 private key.
+type Ed25519PrivateKey struct {
+       k ed25519.PrivateKey
+}
+
+// Ed25519PublicKey is an ed25519 public key.
+type Ed25519PublicKey struct {
+       k ed25519.PublicKey
+}
+
+// GenerateEd25519Key generate a new ed25519 private and public key pair.
+func GenerateEd25519Key(src io.Reader) (PrivKey, PubKey, error) {
+       pub, priv, err := ed25519.GenerateKey(src)
+       if err != nil {
+               return nil, nil, err
+       }
+
+       return &Ed25519PrivateKey{
+                       k: priv,
+               },
+               &Ed25519PublicKey{
+                       k: pub,
+               },
+               nil
+}
+
+// Type of the private key (Ed25519).
+func (k *Ed25519PrivateKey) Type() pb.KeyType {
+       return pb.KeyType_Ed25519
+}
+
+// Bytes marshals an ed25519 private key to protobuf bytes.
+func (k *Ed25519PrivateKey) Bytes() ([]byte, error) {
+       return MarshalPrivateKey(k)
+}
+
+// Raw private key bytes.
+func (k *Ed25519PrivateKey) Raw() ([]byte, error) {
+       // The Ed25519 private key contains two 32-bytes curve points, the private
+       // key and the public key.
+       // It makes it more efficient to get the public key without re-computing an
+       // elliptic curve multiplication.
+       buf := make([]byte, len(k.k))
+       copy(buf, k.k)
+
+       return buf, nil
+}
+
+func (k *Ed25519PrivateKey) pubKeyBytes() []byte {
+       return k.k[ed25519.PrivateKeySize-ed25519.PublicKeySize:]
+}
+
+// Equals compares two ed25519 private keys.
+func (k *Ed25519PrivateKey) Equals(o Key) bool {
+       edk, ok := o.(*Ed25519PrivateKey)
+       if !ok {
+               return false
+       }
+
+       return bytes.Equal(k.k, edk.k)
+}
+
+// GetPublic returns an ed25519 public key from a private key.
+func (k *Ed25519PrivateKey) GetPublic() PubKey {
+       return &Ed25519PublicKey{k: k.pubKeyBytes()}
+}
+
+// Sign returns a signature from an input message.
+func (k *Ed25519PrivateKey) Sign(msg []byte) ([]byte, error) {
+       return ed25519.Sign(k.k, msg), nil
+}
+
+// Type of the public key (Ed25519).
+func (k *Ed25519PublicKey) Type() pb.KeyType {
+       return pb.KeyType_Ed25519
+}
+
+// Bytes returns a ed25519 public key as protobuf bytes.
+func (k *Ed25519PublicKey) Bytes() ([]byte, error) {
+       return MarshalPublicKey(k)
+}
+
+// Raw public key bytes.
+func (k *Ed25519PublicKey) Raw() ([]byte, error) {
+       return k.k, nil
+}
+
+// Equals compares two ed25519 public keys.
+func (k *Ed25519PublicKey) Equals(o Key) bool {
+       edk, ok := o.(*Ed25519PublicKey)
+       if !ok {
+               return false
+       }
+
+       return bytes.Equal(k.k, edk.k)
+}
+
+// Verify checks a signature agains the input data.
+func (k *Ed25519PublicKey) Verify(data []byte, sig []byte) (bool, error) {
+       return ed25519.Verify(k.k, data, sig), nil
+}
+
+// UnmarshalEd25519PublicKey returns a public key from input bytes.
+func UnmarshalEd25519PublicKey(data []byte) (PubKey, error) {
+       if len(data) != 32 {
+               return nil, errors.New("expect ed25519 public key data size to be 32")
+       }
+
+       return &Ed25519PublicKey{
+               k: ed25519.PublicKey(data),
+       }, nil
+}
+
+// UnmarshalEd25519PrivateKey returns a private key from input bytes.
+func UnmarshalEd25519PrivateKey(data []byte) (PrivKey, error) {
+       switch len(data) {
+       case ed25519.PrivateKeySize + ed25519.PublicKeySize:
+               // Remove the redundant public key. See issue #36.
+               redundantPk := data[ed25519.PrivateKeySize:]
+               pk := data[ed25519.PrivateKeySize-ed25519.PublicKeySize : ed25519.PrivateKeySize]
+               if !bytes.Equal(pk, redundantPk) {
+                       return nil, errors.New("expected redundant ed25519 public key to be redundant")
+               }
+
+               // No point in storing the extra data.
+               newKey := make([]byte, ed25519.PrivateKeySize)
+               copy(newKey, data[:ed25519.PrivateKeySize])
+               data = newKey
+       case ed25519.PrivateKeySize:
+       default:
+               return nil, fmt.Errorf(
+                       "expected ed25519 data size to be %d or %d, got %d",
+                       ed25519.PrivateKeySize,
+                       ed25519.PrivateKeySize+ed25519.PublicKeySize,
+                       len(data),
+               )
+       }
+
+       return &Ed25519PrivateKey{
+               k: ed25519.PrivateKey(data),
+       }, nil
+}

diff --git a/vendor/github.com/libp2p/go-libp2p-crypto/ed25519_test.go b/vendor/github.com/libp2p/go-libp2p-crypto/ed25519_test.go
new file mode 100644 (file)
index 0000000..b57de9b
--- /dev/null
+++ b/vendor/github.com/libp2p/go-libp2p-crypto/ed25519_test.go
@@ -0,0 +1,220 @@
+package crypto
+
+import (
+       "crypto/rand"
+       "testing"
+
+       pb "github.com/libp2p/go-libp2p-crypto/pb"
+
+       "golang.org/x/crypto/ed25519"
+)
+
+func TestBasicSignAndVerify(t *testing.T) {
+       priv, pub, err := GenerateEd25519Key(rand.Reader)
+       if err != nil {
+               t.Fatal(err)
+       }
+
+       data := []byte("hello! and welcome to some awesome crypto primitives")
+
+       sig, err := priv.Sign(data)
+       if err != nil {
+               t.Fatal(err)
+       }
+
+       ok, err := pub.Verify(data, sig)
+       if err != nil {
+               t.Fatal(err)
+       }
+
+       if !ok {
+               t.Fatal("signature didn't match")
+       }
+
+       // change data
+       data[0] = ^data[0]
+       ok, err = pub.Verify(data, sig)
+       if err != nil {
+               t.Fatal(err)
+       }
+
+       if ok {
+               t.Fatal("signature matched and shouldn't")
+       }
+}
+
+func TestSignZero(t *testing.T) {
+       priv, pub, err := GenerateEd25519Key(rand.Reader)
+       if err != nil {
+               t.Fatal(err)
+       }
+
+       data := make([]byte, 0)
+       sig, err := priv.Sign(data)
+       if err != nil {
+               t.Fatal(err)
+       }
+
+       ok, err := pub.Verify(data, sig)
+       if err != nil {
+               t.Fatal(err)
+       }
+       if !ok {
+               t.Fatal("signature didn't match")
+       }
+}
+
+func TestMarshalLoop(t *testing.T) {
+       priv, pub, err := GenerateEd25519Key(rand.Reader)
+       if err != nil {
+               t.Fatal(err)
+       }
+
+       t.Run("PrivateKey", func(t *testing.T) {
+               for name, f := range map[string]func() ([]byte, error){
+                       "Bytes": priv.Bytes,
+                       "Marshal": func() ([]byte, error) {
+                               return MarshalPrivateKey(priv)
+                       },
+                       "Redundant": func() ([]byte, error) {
+                               // See issue #36.
+                               // Ed25519 private keys used to contain the public key twice.
+                               // For backwards-compatibility, we need to continue supporting
+                               // that scenario.
+                               pbmes := new(pb.PrivateKey)
+                               pbmes.Type = priv.Type()
+                               data, err := priv.Raw()
+                               if err != nil {
+                                       t.Fatal(err)
+                               }
+
+                               pbmes.Data = append(data, data[len(data)-ed25519.PublicKeySize:]...)
+                               return pbmes.Marshal()
+                       },
+               } {
+                       t.Run(name, func(t *testing.T) {
+                               bts, err := f()
+                               if err != nil {
+                                       t.Fatal(err)
+                               }
+
+                               privNew, err := UnmarshalPrivateKey(bts)
+                               if err != nil {
+                                       t.Fatal(err)
+                               }
+
+                               if !priv.Equals(privNew) || !privNew.Equals(priv) {
+                                       t.Fatal("keys are not equal")
+                               }
+
+                               msg := []byte("My child, my sister,\nThink of the rapture\nOf living together there!")
+                               signed, err := privNew.Sign(msg)
+                               if err != nil {
+                                       t.Fatal(err)
+                               }
+
+                               ok, err := privNew.GetPublic().Verify(msg, signed)
+                               if err != nil {
+                                       t.Fatal(err)
+                               }
+
+                               if !ok {
+                                       t.Fatal("signature didn't match")
+                               }
+                       })
+               }
+       })
+
+       t.Run("PublicKey", func(t *testing.T) {
+               for name, f := range map[string]func() ([]byte, error){
+                       "Bytes": pub.Bytes,
+                       "Marshal": func() ([]byte, error) {
+                               return MarshalPublicKey(pub)
+                       },
+               } {
+                       t.Run(name, func(t *testing.T) {
+                               bts, err := f()
+                               if err != nil {
+                                       t.Fatal(err)
+                               }
+                               pubNew, err := UnmarshalPublicKey(bts)
+                               if err != nil {
+                                       t.Fatal(err)
+                               }
+
+                               if !pub.Equals(pubNew) || !pubNew.Equals(pub) {
+                                       t.Fatal("keys are not equal")
+                               }
+                       })
+               }
+       })
+}
+
+func TestUnmarshalErrors(t *testing.T) {
+       t.Run("PublicKey", func(t *testing.T) {
+               t.Run("Invalid data length", func(t *testing.T) {
+                       pbmes := &pb.PublicKey{
+                               Type: pb.KeyType_Ed25519,
+                               Data: []byte{42},
+                       }
+
+                       data, err := pbmes.Marshal()
+                       if err != nil {
+                               t.Fatal(err)
+                       }
+
+                       _, err = UnmarshalPublicKey(data)
+                       if err == nil {
+                               t.Fatal("expected an error")
+                       }
+               })
+       })
+
+       t.Run("PrivateKey", func(t *testing.T) {
+               t.Run("Redundant public key mismatch", func(t *testing.T) {
+                       priv, _, err := GenerateEd25519Key(rand.Reader)
+                       if err != nil {
+                               t.Fatal(err)
+                       }
+
+                       pbmes := new(pb.PrivateKey)
+                       pbmes.Type = priv.Type()
+                       data, err := priv.Raw()
+                       if err != nil {
+                               t.Fatal(err)
+                       }
+
+                       // Append the private key instead of the public key.
+                       pbmes.Data = append(data, data[:ed25519.PublicKeySize]...)
+                       b, err := pbmes.Marshal()
+                       if err != nil {
+                               t.Fatal(err)
+                       }
+
+                       _, err = UnmarshalPrivateKey(b)
+                       if err == nil {
+                               t.Fatal("expected an error")
+                       }
+                       if err.Error() != "expected redundant ed25519 public key to be redundant" {
+                               t.Fatalf("invalid error received: %s", err.Error())
+                       }
+               })
+
+               t.Run("Invalid data length", func(t *testing.T) {
+                       pbmes := &pb.PrivateKey{
+                               Type: pb.KeyType_Ed25519,
+                               Data: []byte{42},
+                       }
+
+                       data, err := pbmes.Marshal()
+                       if err != nil {
+                               t.Fatal(err)
+                       }
+
+                       _, err = UnmarshalPrivateKey(data)
+                       if err == nil {
+                               t.Fatal("expected an error")
+                       }
+               })
+       })
+}

diff --git a/vendor/github.com/libp2p/go-libp2p-crypto/key.go b/vendor/github.com/libp2p/go-libp2p-crypto/key.go
new file mode 100644 (file)
index 0000000..9900772
--- /dev/null
+++ b/vendor/github.com/libp2p/go-libp2p-crypto/key.go
@@ -0,0 +1,352 @@
+// Package crypto implements various cryptographic utilities used by ipfs.
+// This includes a Public and Private key interface and an RSA key implementation
+// that satisfies it.
+package crypto
+
+import (
+       "bytes"
+       "crypto/elliptic"
+       "crypto/hmac"
+       "crypto/rand"
+       "crypto/sha1"
+       "crypto/sha512"
+       "encoding/base64"
+       "errors"
+       "fmt"
+       "hash"
+       "io"
+
+       pb "github.com/libp2p/go-libp2p-crypto/pb"
+
+       "github.com/gogo/protobuf/proto"
+       sha256 "github.com/minio/sha256-simd"
+)
+
+const (
+       // RSA is an enum for the supported RSA key type
+       RSA = iota
+       // Ed25519 is an enum for the supported Ed25519 key type
+       Ed25519
+       // Secp256k1 is an enum for the supported Secp256k1 key type
+       Secp256k1
+       // ECDSA is an enum for the supported ECDSA key type
+       ECDSA
+)
+
+var (
+       // ErrBadKeyType is returned when a key is not supported
+       ErrBadKeyType = errors.New("invalid or unsupported key type")
+       // KeyTypes is a list of supported keys
+       KeyTypes = []int{
+               RSA,
+               Ed25519,
+               Secp256k1,
+               ECDSA,
+       }
+)
+
+// PubKeyUnmarshaller is a func that creates a PubKey from a given slice of bytes
+type PubKeyUnmarshaller func(data []byte) (PubKey, error)
+
+// PrivKeyUnmarshaller is a func that creates a PrivKey from a given slice of bytes
+type PrivKeyUnmarshaller func(data []byte) (PrivKey, error)
+
+// PubKeyUnmarshallers is a map of unmarshallers by key type
+var PubKeyUnmarshallers = map[pb.KeyType]PubKeyUnmarshaller{
+       pb.KeyType_RSA:       UnmarshalRsaPublicKey,
+       pb.KeyType_Ed25519:   UnmarshalEd25519PublicKey,
+       pb.KeyType_Secp256k1: UnmarshalSecp256k1PublicKey,
+       pb.KeyType_ECDSA:     UnmarshalECDSAPublicKey,
+}
+
+// PrivKeyUnmarshallers is a map of unmarshallers by key type
+var PrivKeyUnmarshallers = map[pb.KeyType]PrivKeyUnmarshaller{
+       pb.KeyType_RSA:       UnmarshalRsaPrivateKey,
+       pb.KeyType_Ed25519:   UnmarshalEd25519PrivateKey,
+       pb.KeyType_Secp256k1: UnmarshalSecp256k1PrivateKey,
+       pb.KeyType_ECDSA:     UnmarshalECDSAPrivateKey,
+}
+
+// Key represents a crypto key that can be compared to another key
+type Key interface {
+       // Bytes returns a serialized, storeable representation of this key
+       // DEPRECATED in favor of Marshal / Unmarshal
+       Bytes() ([]byte, error)
+
+       // Equals checks whether two PubKeys are the same
+       Equals(Key) bool
+
+       // Raw returns the raw bytes of the key (not wrapped in the
+       // libp2p-crypto protobuf).
+       //
+       // This function is the inverse of {Priv,Pub}KeyUnmarshaler.
+       Raw() ([]byte, error)
+
+       // Type returns the protobof key type.
+       Type() pb.KeyType
+}
+
+// PrivKey represents a private key that can be used to generate a public key,
+// sign data, and decrypt data that was encrypted with a public key
+type PrivKey interface {
+       Key
+
+       // Cryptographically sign the given bytes
+       Sign([]byte) ([]byte, error)
+
+       // Return a public key paired with this private key
+       GetPublic() PubKey
+}
+
+// PubKey is a public key
+type PubKey interface {
+       Key
+
+       // Verify that 'sig' is the signed hash of 'data'
+       Verify(data []byte, sig []byte) (bool, error)
+}
+
+// GenSharedKey generates the shared key from a given private key
+type GenSharedKey func([]byte) ([]byte, error)
+
+// GenerateKeyPair generates a private and public key
+func GenerateKeyPair(typ, bits int) (PrivKey, PubKey, error) {
+       return GenerateKeyPairWithReader(typ, bits, rand.Reader)
+}
+
+// GenerateKeyPairWithReader returns a keypair of the given type and bitsize
+func GenerateKeyPairWithReader(typ, bits int, src io.Reader) (PrivKey, PubKey, error) {
+       switch typ {
+       case RSA:
+               return GenerateRSAKeyPair(bits, src)
+       case Ed25519:
+               return GenerateEd25519Key(src)
+       case Secp256k1:
+               return GenerateSecp256k1Key(src)
+       case ECDSA:
+               return GenerateECDSAKeyPair(src)
+       default:
+               return nil, nil, ErrBadKeyType
+       }
+}
+
+// GenerateEKeyPair returns an ephemeral public key and returns a function that will compute
+// the shared secret key.  Used in the identify module.
+//
+// Focuses only on ECDH now, but can be made more general in the future.
+func GenerateEKeyPair(curveName string) ([]byte, GenSharedKey, error) {
+       var curve elliptic.Curve
+
+       switch curveName {
+       case "P-256":
+               curve = elliptic.P256()
+       case "P-384":
+               curve = elliptic.P384()
+       case "P-521":
+               curve = elliptic.P521()
+       }
+
+       priv, x, y, err := elliptic.GenerateKey(curve, rand.Reader)
+       if err != nil {
+               return nil, nil, err
+       }
+
+       pubKey := elliptic.Marshal(curve, x, y)
+
+       done := func(theirPub []byte) ([]byte, error) {
+               // Verify and unpack node's public key.
+               x, y := elliptic.Unmarshal(curve, theirPub)
+               if x == nil {
+                       return nil, fmt.Errorf("malformed public key: %d %v", len(theirPub), theirPub)
+               }
+
+               if !curve.IsOnCurve(x, y) {
+                       return nil, errors.New("invalid public key")
+               }
+
+               // Generate shared secret.
+               secret, _ := curve.ScalarMult(x, y, priv)
+
+               return secret.Bytes(), nil
+       }
+
+       return pubKey, done, nil
+}
+
+// StretchedKeys ...
+type StretchedKeys struct {
+       IV        []byte
+       MacKey    []byte
+       CipherKey []byte
+}
+
+// KeyStretcher returns a set of keys for each party by stretching the shared key.
+// (myIV, theirIV, myCipherKey, theirCipherKey, myMACKey, theirMACKey)
+func KeyStretcher(cipherType string, hashType string, secret []byte) (StretchedKeys, StretchedKeys) {
+       var cipherKeySize int
+       var ivSize int
+       switch cipherType {
+       case "AES-128":
+               ivSize = 16
+               cipherKeySize = 16
+       case "AES-256":
+               ivSize = 16
+               cipherKeySize = 32
+       case "Blowfish":
+               ivSize = 8
+               // Note: 24 arbitrarily selected, needs more thought
+               cipherKeySize = 32
+       }
+
+       hmacKeySize := 20
+
+       seed := []byte("key expansion")
+
+       result := make([]byte, 2*(ivSize+cipherKeySize+hmacKeySize))
+
+       var h func() hash.Hash
+
+       switch hashType {
+       case "SHA1":
+               h = sha1.New
+       case "SHA256":
+               h = sha256.New
+       case "SHA512":
+               h = sha512.New
+       default:
+               panic("Unrecognized hash function, programmer error?")
+       }
+
+       m := hmac.New(h, secret)
+       // note: guaranteed to never return an error
+       m.Write(seed)
+
+       a := m.Sum(nil)
+
+       j := 0
+       for j < len(result) {
+               m.Reset()
+
+               // note: guaranteed to never return an error.
+               m.Write(a)
+               m.Write(seed)
+
+               b := m.Sum(nil)
+
+               todo := len(b)
+
+               if j+todo > len(result) {
+                       todo = len(result) - j
+               }
+
+               copy(result[j:j+todo], b)
+
+               j += todo
+
+               m.Reset()
+
+               // note: guaranteed to never return an error.
+               m.Write(a)
+
+               a = m.Sum(nil)
+       }
+
+       half := len(result) / 2
+       r1 := result[:half]
+       r2 := result[half:]
+
+       var k1 StretchedKeys
+       var k2 StretchedKeys
+
+       k1.IV = r1[0:ivSize]
+       k1.CipherKey = r1[ivSize : ivSize+cipherKeySize]
+       k1.MacKey = r1[ivSize+cipherKeySize:]
+
+       k2.IV = r2[0:ivSize]
+       k2.CipherKey = r2[ivSize : ivSize+cipherKeySize]
+       k2.MacKey = r2[ivSize+cipherKeySize:]
+
+       return k1, k2
+}
+
+// UnmarshalPublicKey converts a protobuf serialized public key into its
+// representative object
+func UnmarshalPublicKey(data []byte) (PubKey, error) {
+       pmes := new(pb.PublicKey)
+       err := proto.Unmarshal(data, pmes)
+       if err != nil {
+               return nil, err
+       }
+
+       um, ok := PubKeyUnmarshallers[pmes.GetType()]
+       if !ok {
+               return nil, ErrBadKeyType
+       }
+
+       return um(pmes.GetData())
+}
+
+// MarshalPublicKey converts a public key object into a protobuf serialized
+// public key
+func MarshalPublicKey(k PubKey) ([]byte, error) {
+       pbmes := new(pb.PublicKey)
+       pbmes.Type = k.Type()
+       data, err := k.Raw()
+       if err != nil {
+               return nil, err
+       }
+       pbmes.Data = data
+
+       return proto.Marshal(pbmes)
+}
+
+// UnmarshalPrivateKey converts a protobuf serialized private key into its
+// representative object
+func UnmarshalPrivateKey(data []byte) (PrivKey, error) {
+       pmes := new(pb.PrivateKey)
+       err := proto.Unmarshal(data, pmes)
+       if err != nil {
+               return nil, err
+       }
+
+       um, ok := PrivKeyUnmarshallers[pmes.GetType()]
+       if !ok {
+               return nil, ErrBadKeyType
+       }
+
+       return um(pmes.GetData())
+}
+
+// MarshalPrivateKey converts a key object into its protobuf serialized form.
+func MarshalPrivateKey(k PrivKey) ([]byte, error) {
+       pbmes := new(pb.PrivateKey)
+       pbmes.Type = k.Type()
+       data, err := k.Raw()
+       if err != nil {
+               return nil, err
+       }
+
+       pbmes.Data = data
+       return proto.Marshal(pbmes)
+}
+
+// ConfigDecodeKey decodes from b64 (for config file), and unmarshals.
+func ConfigDecodeKey(b string) ([]byte, error) {
+       return base64.StdEncoding.DecodeString(b)
+}
+
+// ConfigEncodeKey encodes to b64 (for config file), and marshals.
+func ConfigEncodeKey(b []byte) string {
+       return base64.StdEncoding.EncodeToString(b)
+}
+
+// KeyEqual checks whether two
+func KeyEqual(k1, k2 Key) bool {
+       if k1 == k2 {
+               return true
+       }
+
+       b1, err1 := k1.Bytes()
+       b2, err2 := k2.Bytes()
+       return bytes.Equal(b1, b2) && err1 == err2
+}

diff --git a/vendor/github.com/libp2p/go-libp2p-crypto/key_test.go b/vendor/github.com/libp2p/go-libp2p-crypto/key_test.go
new file mode 100644 (file)
index 0000000..1d2d8d8
--- /dev/null
+++ b/vendor/github.com/libp2p/go-libp2p-crypto/key_test.go
@@ -0,0 +1,147 @@
+package crypto_test
+
+import (
+       "bytes"
+       "crypto/rand"
+       "testing"
+
+       . "github.com/libp2p/go-libp2p-crypto"
+       pb "github.com/libp2p/go-libp2p-crypto/pb"
+       tu "github.com/libp2p/go-libp2p-crypto/test"
+)
+
+func TestKeys(t *testing.T) {
+       for _, typ := range KeyTypes {
+               testKeyType(typ, t)
+       }
+}
+
+func testKeyType(typ int, t *testing.T) {
+       sk, pk, err := tu.RandTestKeyPair(typ, 512)
+       if err != nil {
+               t.Fatal(err)
+       }
+
+       testKeySignature(t, sk)
+       testKeyEncoding(t, sk)
+       testKeyEquals(t, sk)
+       testKeyEquals(t, pk)
+}
+
+func testKeySignature(t *testing.T, sk PrivKey) {
+       pk := sk.GetPublic()
+
+       text := make([]byte, 16)
+       if _, err := rand.Read(text); err != nil {
+               t.Fatal(err)
+       }
+
+       sig, err := sk.Sign(text)
+       if err != nil {
+               t.Fatal(err)
+       }
+
+       valid, err := pk.Verify(text, sig)
+       if err != nil {
+               t.Fatal(err)
+       }
+
+       if !valid {
+               t.Fatal("Invalid signature.")
+       }
+}
+
+func testKeyEncoding(t *testing.T, sk PrivKey) {
+       skbm, err := MarshalPrivateKey(sk)
+       if err != nil {
+               t.Fatal(err)
+       }
+
+       sk2, err := UnmarshalPrivateKey(skbm)
+       if err != nil {
+               t.Fatal(err)
+       }
+
+       if !sk.Equals(sk2) {
+               t.Error("Unmarshaled private key didn't match original.\n")
+       }
+
+       skbm2, err := MarshalPrivateKey(sk2)
+       if err != nil {
+               t.Fatal(err)
+       }
+
+       if !bytes.Equal(skbm, skbm2) {
+               t.Error("skb -> marshal -> unmarshal -> skb failed.\n", skbm, "\n", skbm2)
+       }
+
+       pk := sk.GetPublic()
+       pkbm, err := MarshalPublicKey(pk)
+       if err != nil {
+               t.Fatal(err)
+       }
+
+       pk2, err := UnmarshalPublicKey(pkbm)
+       if err != nil {
+               t.Fatal(err)
+       }
+
+       if !pk.Equals(pk2) {
+               t.Error("Unmarshaled public key didn't match original.\n")
+       }
+
+       pkbm2, err := MarshalPublicKey(pk)
+       if err != nil {
+               t.Fatal(err)
+       }
+
+       if !bytes.Equal(pkbm, pkbm2) {
+               t.Error("skb -> marshal -> unmarshal -> skb failed.\n", pkbm, "\n", pkbm2)
+       }
+}
+
+func testKeyEquals(t *testing.T, k Key) {
+       kb, err := k.Bytes()
+       if err != nil {
+               t.Fatal(err)
+       }
+
+       if !KeyEqual(k, k) {
+               t.Fatal("Key not equal to itself.")
+       }
+
+       if !KeyEqual(k, testkey(kb)) {
+               t.Fatal("Key not equal to key with same bytes.")
+       }
+
+       sk, pk, err := tu.RandTestKeyPair(RSA, 512)
+       if err != nil {
+               t.Fatal(err)
+       }
+
+       if KeyEqual(k, sk) {
+               t.Fatal("Keys should not equal.")
+       }
+
+       if KeyEqual(k, pk) {
+               t.Fatal("Keys should not equal.")
+       }
+}
+
+type testkey []byte
+
+func (pk testkey) Bytes() ([]byte, error) {
+       return pk, nil
+}
+
+func (pk testkey) Type() pb.KeyType {
+       return pb.KeyType_RSA
+}
+
+func (pk testkey) Raw() ([]byte, error) {
+       return pk, nil
+}
+
+func (pk testkey) Equals(k Key) bool {
+       return KeyEqual(pk, k)
+}

diff --git a/vendor/github.com/libp2p/go-libp2p-crypto/package.json b/vendor/github.com/libp2p/go-libp2p-crypto/package.json
new file mode 100644 (file)
index 0000000..f44acbf
--- /dev/null
+++ b/vendor/github.com/libp2p/go-libp2p-crypto/package.json
@@ -0,0 +1,42 @@
+{
+  "author": "whyrusleeping",
+  "bugs": {
+    "url": "https://github.com/libp2p/go-libp2p-transport"
+  },
+  "gx": {
+    "dvcsimport": "github.com/libp2p/go-libp2p-crypto"
+  },
+  "gxDependencies": [
+    {
+      "author": "btcsuite",
+      "hash": "QmWq5PJgAQKDWQerAijYUVKW8mN5MDatK5j7VMp8rizKQd",
+      "name": "btcec",
+      "version": "0.0.1"
+    },
+    {
+      "author": "minio",
+      "hash": "QmcTzQXRcU2vf8yX5EEboz1BSvWC7wWmeYAKVQmhp8WZYU",
+      "name": "sha256-simd",
+      "version": "0.1.2"
+    },
+    {
+      "author": "whyrusleeping",
+      "hash": "QmddjPSGZb3ieihSseFeCfVRpZzcqczPNsD2DvarSwnjJB",
+      "name": "gogo-protobuf",
+      "version": "1.2.1"
+    },
+    {
+      "author": "golang",
+      "hash": "QmW7VUmSvhvSGbYbdsh7uRjhGmsYkc9fL8aJ5CorxxrU5N",
+      "name": "go-crypto",
+      "version": "0.2.1"
+    }
+  ],
+  "gxVersion": "0.4.0",
+  "language": "go",
+  "license": "MIT",
+  "name": "go-libp2p-crypto",
+  "releaseCmd": "git commit -a -m \"gx publish $VERSION\"",
+  "version": "2.0.7"
+}
+

diff --git a/vendor/github.com/libp2p/go-libp2p-crypto/pb/Makefile b/vendor/github.com/libp2p/go-libp2p-crypto/pb/Makefile
new file mode 100644 (file)
index 0000000..df34e54
--- /dev/null
+++ b/vendor/github.com/libp2p/go-libp2p-crypto/pb/Makefile
@@ -0,0 +1,11 @@
+PB = $(wildcard *.proto)
+GO = $(PB:.proto=.pb.go)
+
+all: $(GO)
+
+%.pb.go: %.proto
+               protoc --proto_path=$(GOPATH)/src:. --gogofaster_out=. $<
+
+clean:
+               rm -f *.pb.go
+               rm -f *.go

diff --git a/vendor/github.com/libp2p/go-libp2p-crypto/pb/crypto.pb.go b/vendor/github.com/libp2p/go-libp2p-crypto/pb/crypto.pb.go
new file mode 100644 (file)
index 0000000..5fa7aec
--- /dev/null
+++ b/vendor/github.com/libp2p/go-libp2p-crypto/pb/crypto.pb.go
@@ -0,0 +1,643 @@
+// Code generated by protoc-gen-gogo. DO NOT EDIT.
+// source: crypto.proto
+
+package crypto_pb
+
+import (
+       fmt "fmt"
+       github_com_gogo_protobuf_proto "github.com/gogo/protobuf/proto"
+       proto "github.com/gogo/protobuf/proto"
+       io "io"
+       math "math"
+)
+
+// Reference imports to suppress errors if they are not otherwise used.
+var _ = proto.Marshal
+var _ = fmt.Errorf
+var _ = math.Inf
+
+// This is a compile-time assertion to ensure that this generated file
+// is compatible with the proto package it is being compiled against.
+// A compilation error at this line likely means your copy of the
+// proto package needs to be updated.
+const _ = proto.GoGoProtoPackageIsVersion2 // please upgrade the proto package
+
+type KeyType int32
+
+const (
+       KeyType_RSA       KeyType = 0
+       KeyType_Ed25519   KeyType = 1
+       KeyType_Secp256k1 KeyType = 2
+       KeyType_ECDSA     KeyType = 3
+)
+
+var KeyType_name = map[int32]string{
+       0: "RSA",
+       1: "Ed25519",
+       2: "Secp256k1",
+       3: "ECDSA",
+}
+
+var KeyType_value = map[string]int32{
+       "RSA":       0,
+       "Ed25519":   1,
+       "Secp256k1": 2,
+       "ECDSA":     3,
+}
+
+func (x KeyType) Enum() *KeyType {
+       p := new(KeyType)
+       *p = x
+       return p
+}
+
+func (x KeyType) String() string {
+       return proto.EnumName(KeyType_name, int32(x))
+}
+
+func (x *KeyType) UnmarshalJSON(data []byte) error {
+       value, err := proto.UnmarshalJSONEnum(KeyType_value, data, "KeyType")
+       if err != nil {
+               return err
+       }
+       *x = KeyType(value)
+       return nil
+}
+
+func (KeyType) EnumDescriptor() ([]byte, []int) {
+       return fileDescriptor_527278fb02d03321, []int{0}
+}
+
+type PublicKey struct {
+       Type KeyType `protobuf:"varint,1,req,name=Type,enum=crypto.pb.KeyType" json:"Type"`
+       Data []byte  `protobuf:"bytes,2,req,name=Data" json:"Data"`
+}
+
+func (m *PublicKey) Reset()         { *m = PublicKey{} }
+func (m *PublicKey) String() string { return proto.CompactTextString(m) }
+func (*PublicKey) ProtoMessage()    {}
+func (*PublicKey) Descriptor() ([]byte, []int) {
+       return fileDescriptor_527278fb02d03321, []int{0}
+}
+func (m *PublicKey) XXX_Unmarshal(b []byte) error {
+       return m.Unmarshal(b)
+}
+func (m *PublicKey) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+       if deterministic {
+               return xxx_messageInfo_PublicKey.Marshal(b, m, deterministic)
+       } else {
+               b = b[:cap(b)]
+               n, err := m.MarshalTo(b)
+               if err != nil {
+                       return nil, err
+               }
+               return b[:n], nil
+       }
+}
+func (m *PublicKey) XXX_Merge(src proto.Message) {
+       xxx_messageInfo_PublicKey.Merge(m, src)
+}
+func (m *PublicKey) XXX_Size() int {
+       return m.Size()
+}
+func (m *PublicKey) XXX_DiscardUnknown() {
+       xxx_messageInfo_PublicKey.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_PublicKey proto.InternalMessageInfo
+
+func (m *PublicKey) GetType() KeyType {
+       if m != nil {
+               return m.Type
+       }
+       return KeyType_RSA
+}
+
+func (m *PublicKey) GetData() []byte {
+       if m != nil {
+               return m.Data
+       }
+       return nil
+}
+
+type PrivateKey struct {
+       Type KeyType `protobuf:"varint,1,req,name=Type,enum=crypto.pb.KeyType" json:"Type"`
+       Data []byte  `protobuf:"bytes,2,req,name=Data" json:"Data"`
+}
+
+func (m *PrivateKey) Reset()         { *m = PrivateKey{} }
+func (m *PrivateKey) String() string { return proto.CompactTextString(m) }
+func (*PrivateKey) ProtoMessage()    {}
+func (*PrivateKey) Descriptor() ([]byte, []int) {
+       return fileDescriptor_527278fb02d03321, []int{1}
+}
+func (m *PrivateKey) XXX_Unmarshal(b []byte) error {
+       return m.Unmarshal(b)
+}
+func (m *PrivateKey) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+       if deterministic {
+               return xxx_messageInfo_PrivateKey.Marshal(b, m, deterministic)
+       } else {
+               b = b[:cap(b)]
+               n, err := m.MarshalTo(b)
+               if err != nil {
+                       return nil, err
+               }
+               return b[:n], nil
+       }
+}
+func (m *PrivateKey) XXX_Merge(src proto.Message) {
+       xxx_messageInfo_PrivateKey.Merge(m, src)
+}
+func (m *PrivateKey) XXX_Size() int {
+       return m.Size()
+}
+func (m *PrivateKey) XXX_DiscardUnknown() {
+       xxx_messageInfo_PrivateKey.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_PrivateKey proto.InternalMessageInfo
+
+func (m *PrivateKey) GetType() KeyType {
+       if m != nil {
+               return m.Type
+       }
+       return KeyType_RSA
+}
+
+func (m *PrivateKey) GetData() []byte {
+       if m != nil {
+               return m.Data
+       }
+       return nil
+}
+
+func init() {
+       proto.RegisterEnum("crypto.pb.KeyType", KeyType_name, KeyType_value)
+       proto.RegisterType((*PublicKey)(nil), "crypto.pb.PublicKey")
+       proto.RegisterType((*PrivateKey)(nil), "crypto.pb.PrivateKey")
+}
+
+func init() { proto.RegisterFile("crypto.proto", fileDescriptor_527278fb02d03321) }
+
+var fileDescriptor_527278fb02d03321 = []byte{
+       // 203 bytes of a gzipped FileDescriptorProto
+       0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xe2, 0xe2, 0x49, 0x2e, 0xaa, 0x2c,
+       0x28, 0xc9, 0xd7, 0x2b, 0x28, 0xca, 0x2f, 0xc9, 0x17, 0xe2, 0x84, 0xf1, 0x92, 0x94, 0x82, 0xb9,
+       0x38, 0x03, 0x4a, 0x93, 0x72, 0x32, 0x93, 0xbd, 0x53, 0x2b, 0x85, 0x74, 0xb8, 0x58, 0x42, 0x2a,
+       0x0b, 0x52, 0x25, 0x18, 0x15, 0x98, 0x34, 0xf8, 0x8c, 0x84, 0xf4, 0xe0, 0xca, 0xf4, 0xbc, 0x53,
+       0x2b, 0x41, 0x32, 0x4e, 0x2c, 0x27, 0xee, 0xc9, 0x33, 0x04, 0x81, 0x55, 0x09, 0x49, 0x70, 0xb1,
+       0xb8, 0x24, 0x96, 0x24, 0x4a, 0x30, 0x29, 0x30, 0x69, 0xf0, 0xc0, 0x64, 0x40, 0x22, 0x4a, 0x21,
+       0x5c, 0x5c, 0x01, 0x45, 0x99, 0x65, 0x89, 0x25, 0xa9, 0x54, 0x34, 0x55, 0xcb, 0x92, 0x8b, 0x1d,
+       0xaa, 0x41, 0x88, 0x9d, 0x8b, 0x39, 0x28, 0xd8, 0x51, 0x80, 0x41, 0x88, 0x9b, 0x8b, 0xdd, 0x35,
+       0xc5, 0xc8, 0xd4, 0xd4, 0xd0, 0x52, 0x80, 0x51, 0x88, 0x97, 0x8b, 0x33, 0x38, 0x35, 0xb9, 0xc0,
+       0xc8, 0xd4, 0x2c, 0xdb, 0x50, 0x80, 0x49, 0x88, 0x93, 0x8b, 0xd5, 0xd5, 0xd9, 0x25, 0xd8, 0x51,
+       0x80, 0xd9, 0x49, 0xe2, 0xc4, 0x23, 0x39, 0xc6, 0x0b, 0x8f, 0xe4, 0x18, 0x1f, 0x3c, 0x92, 0x63,
+       0x9c, 0xf0, 0x58, 0x8e, 0xe1, 0xc2, 0x63, 0x39, 0x86, 0x1b, 0x8f, 0xe5, 0x18, 0x00, 0x01, 0x00,
+       0x00, 0xff, 0xff, 0x13, 0xbe, 0xd4, 0xff, 0x19, 0x01, 0x00, 0x00,
+}
+
+func (m *PublicKey) Marshal() (dAtA []byte, err error) {
+       size := m.Size()
+       dAtA = make([]byte, size)
+       n, err := m.MarshalTo(dAtA)
+       if err != nil {
+               return nil, err
+       }
+       return dAtA[:n], nil
+}
+
+func (m *PublicKey) MarshalTo(dAtA []byte) (int, error) {
+       var i int
+       _ = i
+       var l int
+       _ = l
+       dAtA[i] = 0x8
+       i++
+       i = encodeVarintCrypto(dAtA, i, uint64(m.Type))
+       if m.Data != nil {
+               dAtA[i] = 0x12
+               i++
+               i = encodeVarintCrypto(dAtA, i, uint64(len(m.Data)))
+               i += copy(dAtA[i:], m.Data)
+       }
+       return i, nil
+}
+
+func (m *PrivateKey) Marshal() (dAtA []byte, err error) {
+       size := m.Size()
+       dAtA = make([]byte, size)
+       n, err := m.MarshalTo(dAtA)
+       if err != nil {
+               return nil, err
+       }
+       return dAtA[:n], nil
+}
+
+func (m *PrivateKey) MarshalTo(dAtA []byte) (int, error) {
+       var i int
+       _ = i
+       var l int
+       _ = l
+       dAtA[i] = 0x8
+       i++
+       i = encodeVarintCrypto(dAtA, i, uint64(m.Type))
+       if m.Data != nil {
+               dAtA[i] = 0x12
+               i++
+               i = encodeVarintCrypto(dAtA, i, uint64(len(m.Data)))
+               i += copy(dAtA[i:], m.Data)
+       }
+       return i, nil
+}
+
+func encodeVarintCrypto(dAtA []byte, offset int, v uint64) int {
+       for v >= 1<<7 {
+               dAtA[offset] = uint8(v&0x7f | 0x80)
+               v >>= 7
+               offset++
+       }
+       dAtA[offset] = uint8(v)
+       return offset + 1
+}
+func (m *PublicKey) Size() (n int) {
+       if m == nil {
+               return 0
+       }
+       var l int
+       _ = l
+       n += 1 + sovCrypto(uint64(m.Type))
+       if m.Data != nil {
+               l = len(m.Data)
+               n += 1 + l + sovCrypto(uint64(l))
+       }
+       return n
+}
+
+func (m *PrivateKey) Size() (n int) {
+       if m == nil {
+               return 0
+       }
+       var l int
+       _ = l
+       n += 1 + sovCrypto(uint64(m.Type))
+       if m.Data != nil {
+               l = len(m.Data)
+               n += 1 + l + sovCrypto(uint64(l))
+       }
+       return n
+}
+
+func sovCrypto(x uint64) (n int) {
+       for {
+               n++
+               x >>= 7
+               if x == 0 {
+                       break
+               }
+       }
+       return n
+}
+func sozCrypto(x uint64) (n int) {
+       return sovCrypto(uint64((x << 1) ^ uint64((int64(x) >> 63))))
+}
+func (m *PublicKey) Unmarshal(dAtA []byte) error {
+       var hasFields [1]uint64
+       l := len(dAtA)
+       iNdEx := 0
+       for iNdEx < l {
+               preIndex := iNdEx
+               var wire uint64
+               for shift := uint(0); ; shift += 7 {
+                       if shift >= 64 {
+                               return ErrIntOverflowCrypto
+                       }
+                       if iNdEx >= l {
+                               return io.ErrUnexpectedEOF
+                       }
+                       b := dAtA[iNdEx]
+                       iNdEx++
+                       wire |= uint64(b&0x7F) << shift
+                       if b < 0x80 {
+                               break
+                       }
+               }
+               fieldNum := int32(wire >> 3)
+               wireType := int(wire & 0x7)
+               if wireType == 4 {
+                       return fmt.Errorf("proto: PublicKey: wiretype end group for non-group")
+               }
+               if fieldNum <= 0 {
+                       return fmt.Errorf("proto: PublicKey: illegal tag %d (wire type %d)", fieldNum, wire)
+               }
+               switch fieldNum {
+               case 1:
+                       if wireType != 0 {
+                               return fmt.Errorf("proto: wrong wireType = %d for field Type", wireType)
+                       }
+                       m.Type = 0
+                       for shift := uint(0); ; shift += 7 {
+                               if shift >= 64 {
+                                       return ErrIntOverflowCrypto
+                               }
+                               if iNdEx >= l {
+                                       return io.ErrUnexpectedEOF
+                               }
+                               b := dAtA[iNdEx]
+                               iNdEx++
+                               m.Type |= KeyType(b&0x7F) << shift
+                               if b < 0x80 {
+                                       break
+                               }
+                       }
+                       hasFields[0] |= uint64(0x00000001)
+               case 2:
+                       if wireType != 2 {
+                               return fmt.Errorf("proto: wrong wireType = %d for field Data", wireType)
+                       }
+                       var byteLen int
+                       for shift := uint(0); ; shift += 7 {
+                               if shift >= 64 {
+                                       return ErrIntOverflowCrypto
+                               }
+                               if iNdEx >= l {
+                                       return io.ErrUnexpectedEOF
+                               }
+                               b := dAtA[iNdEx]
+                               iNdEx++
+                               byteLen |= int(b&0x7F) << shift
+                               if b < 0x80 {
+                                       break
+                               }
+                       }
+                       if byteLen < 0 {
+                               return ErrInvalidLengthCrypto
+                       }
+                       postIndex := iNdEx + byteLen
+                       if postIndex < 0 {
+                               return ErrInvalidLengthCrypto
+                       }
+                       if postIndex > l {
+                               return io.ErrUnexpectedEOF
+                       }
+                       m.Data = append(m.Data[:0], dAtA[iNdEx:postIndex]...)
+                       if m.Data == nil {
+                               m.Data = []byte{}
+                       }
+                       iNdEx = postIndex
+                       hasFields[0] |= uint64(0x00000002)
+               default:
+                       iNdEx = preIndex
+                       skippy, err := skipCrypto(dAtA[iNdEx:])
+                       if err != nil {
+                               return err
+                       }
+                       if skippy < 0 {
+                               return ErrInvalidLengthCrypto
+                       }
+                       if (iNdEx + skippy) < 0 {
+                               return ErrInvalidLengthCrypto
+                       }
+                       if (iNdEx + skippy) > l {
+                               return io.ErrUnexpectedEOF
+                       }
+                       iNdEx += skippy
+               }
+       }
+       if hasFields[0]&uint64(0x00000001) == 0 {
+               return github_com_gogo_protobuf_proto.NewRequiredNotSetError("Type")
+       }
+       if hasFields[0]&uint64(0x00000002) == 0 {
+               return github_com_gogo_protobuf_proto.NewRequiredNotSetError("Data")
+       }
+
+       if iNdEx > l {
+               return io.ErrUnexpectedEOF
+       }
+       return nil
+}
+func (m *PrivateKey) Unmarshal(dAtA []byte) error {
+       var hasFields [1]uint64
+       l := len(dAtA)
+       iNdEx := 0
+       for iNdEx < l {
+               preIndex := iNdEx
+               var wire uint64
+               for shift := uint(0); ; shift += 7 {
+                       if shift >= 64 {
+                               return ErrIntOverflowCrypto
+                       }
+                       if iNdEx >= l {
+                               return io.ErrUnexpectedEOF
+                       }
+                       b := dAtA[iNdEx]
+                       iNdEx++
+                       wire |= uint64(b&0x7F) << shift
+                       if b < 0x80 {
+                               break
+                       }
+               }
+               fieldNum := int32(wire >> 3)
+               wireType := int(wire & 0x7)
+               if wireType == 4 {
+                       return fmt.Errorf("proto: PrivateKey: wiretype end group for non-group")
+               }
+               if fieldNum <= 0 {
+                       return fmt.Errorf("proto: PrivateKey: illegal tag %d (wire type %d)", fieldNum, wire)
+               }
+               switch fieldNum {
+               case 1:
+                       if wireType != 0 {
+                               return fmt.Errorf("proto: wrong wireType = %d for field Type", wireType)
+                       }
+                       m.Type = 0
+                       for shift := uint(0); ; shift += 7 {
+                               if shift >= 64 {
+                                       return ErrIntOverflowCrypto
+                               }
+                               if iNdEx >= l {
+                                       return io.ErrUnexpectedEOF
+                               }
+                               b := dAtA[iNdEx]
+                               iNdEx++
+                               m.Type |= KeyType(b&0x7F) << shift
+                               if b < 0x80 {
+                                       break
+                               }
+                       }
+                       hasFields[0] |= uint64(0x00000001)
+               case 2:
+                       if wireType != 2 {
+                               return fmt.Errorf("proto: wrong wireType = %d for field Data", wireType)
+                       }
+                       var byteLen int
+                       for shift := uint(0); ; shift += 7 {
+                               if shift >= 64 {
+                                       return ErrIntOverflowCrypto
+                               }
+                               if iNdEx >= l {
+                                       return io.ErrUnexpectedEOF
+                               }
+                               b := dAtA[iNdEx]
+                               iNdEx++
+                               byteLen |= int(b&0x7F) << shift
+                               if b < 0x80 {
+                                       break
+                               }
+                       }
+                       if byteLen < 0 {
+                               return ErrInvalidLengthCrypto
+                       }
+                       postIndex := iNdEx + byteLen
+                       if postIndex < 0 {
+                               return ErrInvalidLengthCrypto
+                       }
+                       if postIndex > l {
+                               return io.ErrUnexpectedEOF
+                       }
+                       m.Data = append(m.Data[:0], dAtA[iNdEx:postIndex]...)
+                       if m.Data == nil {
+                               m.Data = []byte{}
+                       }
+                       iNdEx = postIndex
+                       hasFields[0] |= uint64(0x00000002)
+               default:
+                       iNdEx = preIndex
+                       skippy, err := skipCrypto(dAtA[iNdEx:])
+                       if err != nil {
+                               return err
+                       }
+                       if skippy < 0 {
+                               return ErrInvalidLengthCrypto
+                       }
+                       if (iNdEx + skippy) < 0 {
+                               return ErrInvalidLengthCrypto
+                       }
+                       if (iNdEx + skippy) > l {
+                               return io.ErrUnexpectedEOF
+                       }
+                       iNdEx += skippy
+               }
+       }
+       if hasFields[0]&uint64(0x00000001) == 0 {
+               return github_com_gogo_protobuf_proto.NewRequiredNotSetError("Type")
+       }
+       if hasFields[0]&uint64(0x00000002) == 0 {
+               return github_com_gogo_protobuf_proto.NewRequiredNotSetError("Data")
+       }
+
+       if iNdEx > l {
+               return io.ErrUnexpectedEOF
+       }
+       return nil
+}
+func skipCrypto(dAtA []byte) (n int, err error) {
+       l := len(dAtA)
+       iNdEx := 0
+       for iNdEx < l {
+               var wire uint64
+               for shift := uint(0); ; shift += 7 {
+                       if shift >= 64 {
+                               return 0, ErrIntOverflowCrypto
+                       }
+                       if iNdEx >= l {
+                               return 0, io.ErrUnexpectedEOF
+                       }
+                       b := dAtA[iNdEx]
+                       iNdEx++
+                       wire |= (uint64(b) & 0x7F) << shift
+                       if b < 0x80 {
+                               break
+                       }
+               }
+               wireType := int(wire & 0x7)
+               switch wireType {
+               case 0:
+                       for shift := uint(0); ; shift += 7 {
+                               if shift >= 64 {
+                                       return 0, ErrIntOverflowCrypto
+                               }
+                               if iNdEx >= l {
+                                       return 0, io.ErrUnexpectedEOF
+                               }
+                               iNdEx++
+                               if dAtA[iNdEx-1] < 0x80 {
+                                       break
+                               }
+                       }
+                       return iNdEx, nil
+               case 1:
+                       iNdEx += 8
+                       return iNdEx, nil
+               case 2:
+                       var length int
+                       for shift := uint(0); ; shift += 7 {
+                               if shift >= 64 {
+                                       return 0, ErrIntOverflowCrypto
+                               }
+                               if iNdEx >= l {
+                                       return 0, io.ErrUnexpectedEOF
+                               }
+                               b := dAtA[iNdEx]
+                               iNdEx++
+                               length |= (int(b) & 0x7F) << shift
+                               if b < 0x80 {
+                                       break
+                               }
+                       }
+                       if length < 0 {
+                               return 0, ErrInvalidLengthCrypto
+                       }
+                       iNdEx += length
+                       if iNdEx < 0 {
+                               return 0, ErrInvalidLengthCrypto
+                       }
+                       return iNdEx, nil
+               case 3:
+                       for {
+                               var innerWire uint64
+                               var start int = iNdEx
+                               for shift := uint(0); ; shift += 7 {
+                                       if shift >= 64 {
+                                               return 0, ErrIntOverflowCrypto
+                                       }
+                                       if iNdEx >= l {
+                                               return 0, io.ErrUnexpectedEOF
+                                       }
+                                       b := dAtA[iNdEx]
+                                       iNdEx++
+                                       innerWire |= (uint64(b) & 0x7F) << shift
+                                       if b < 0x80 {
+                                               break
+                                       }
+                               }
+                               innerWireType := int(innerWire & 0x7)
+                               if innerWireType == 4 {
+                                       break
+                               }
+                               next, err := skipCrypto(dAtA[start:])
+                               if err != nil {
+                                       return 0, err
+                               }
+                               iNdEx = start + next
+                               if iNdEx < 0 {
+                                       return 0, ErrInvalidLengthCrypto
+                               }
+                       }
+                       return iNdEx, nil
+               case 4:
+                       return iNdEx, nil
+               case 5:
+                       iNdEx += 4
+                       return iNdEx, nil
+               default:
+                       return 0, fmt.Errorf("proto: illegal wireType %d", wireType)
+               }
+       }
+       panic("unreachable")
+}
+
+var (
+       ErrInvalidLengthCrypto = fmt.Errorf("proto: negative length found during unmarshaling")
+       ErrIntOverflowCrypto   = fmt.Errorf("proto: integer overflow")
+)

diff --git a/vendor/github.com/libp2p/go-libp2p-crypto/pb/crypto.proto b/vendor/github.com/libp2p/go-libp2p-crypto/pb/crypto.proto
new file mode 100644 (file)
index 0000000..cb5cee8
--- /dev/null
+++ b/vendor/github.com/libp2p/go-libp2p-crypto/pb/crypto.proto
@@ -0,0 +1,20 @@
+syntax = "proto2";
+
+package crypto.pb;
+
+enum KeyType {
+       RSA = 0;
+       Ed25519 = 1;
+       Secp256k1 = 2;
+       ECDSA = 3;
+}
+
+message PublicKey {
+       required KeyType Type = 1;
+       required bytes Data = 2;
+}
+
+message PrivateKey {
+       required KeyType Type = 1;
+       required bytes Data = 2;
+}

diff --git a/vendor/github.com/libp2p/go-libp2p-crypto/rsa.go b/vendor/github.com/libp2p/go-libp2p-crypto/rsa.go
new file mode 100644 (file)
index 0000000..e1ab22d
--- /dev/null
+++ b/vendor/github.com/libp2p/go-libp2p-crypto/rsa.go
@@ -0,0 +1,152 @@
+package crypto
+
+import (
+       "crypto"
+       "crypto/rand"
+       "crypto/rsa"
+       "crypto/x509"
+       "errors"
+       "io"
+
+       pb "github.com/libp2p/go-libp2p-crypto/pb"
+
+       sha256 "github.com/minio/sha256-simd"
+)
+
+// ErrRsaKeyTooSmall is returned when trying to generate or parse an RSA key
+// that's smaller than 512 bits. Keys need to be larger enough to sign a 256bit
+// hash so this is a reasonable absolute minimum.
+var ErrRsaKeyTooSmall = errors.New("rsa keys must be >= 512 bits to be useful")
+
+// RsaPrivateKey is an rsa private key
+type RsaPrivateKey struct {
+       sk *rsa.PrivateKey
+       pk *rsa.PublicKey
+}
+
+// RsaPublicKey is an rsa public key
+type RsaPublicKey struct {
+       k *rsa.PublicKey
+}
+
+// GenerateRSAKeyPair generates a new rsa private and public key
+func GenerateRSAKeyPair(bits int, src io.Reader) (PrivKey, PubKey, error) {
+       if bits < 512 {
+               return nil, nil, ErrRsaKeyTooSmall
+       }
+       priv, err := rsa.GenerateKey(src, bits)
+       if err != nil {
+               return nil, nil, err
+       }
+       pk := &priv.PublicKey
+       return &RsaPrivateKey{sk: priv}, &RsaPublicKey{pk}, nil
+}
+
+// Verify compares a signature against input data
+func (pk *RsaPublicKey) Verify(data, sig []byte) (bool, error) {
+       hashed := sha256.Sum256(data)
+       err := rsa.VerifyPKCS1v15(pk.k, crypto.SHA256, hashed[:], sig)
+       if err != nil {
+               return false, err
+       }
+       return true, nil
+}
+
+func (pk *RsaPublicKey) Type() pb.KeyType {
+       return pb.KeyType_RSA
+}
+
+// Bytes returns protobuf bytes of a public key
+func (pk *RsaPublicKey) Bytes() ([]byte, error) {
+       return MarshalPublicKey(pk)
+}
+
+func (pk *RsaPublicKey) Raw() ([]byte, error) {
+       return x509.MarshalPKIXPublicKey(pk.k)
+}
+
+// Encrypt returns encrypted bytes from the inpu data
+func (pk *RsaPublicKey) Encrypt(b []byte) ([]byte, error) {
+       return rsa.EncryptPKCS1v15(rand.Reader, pk.k, b)
+}
+
+// Equals checks whether this key is equal to another
+func (pk *RsaPublicKey) Equals(k Key) bool {
+       return KeyEqual(pk, k)
+}
+
+// Sign returns a signature of the input data
+func (sk *RsaPrivateKey) Sign(message []byte) ([]byte, error) {
+       hashed := sha256.Sum256(message)
+       return rsa.SignPKCS1v15(rand.Reader, sk.sk, crypto.SHA256, hashed[:])
+}
+
+// GetPublic returns a public key
+func (sk *RsaPrivateKey) GetPublic() PubKey {
+       if sk.pk == nil {
+               sk.pk = &sk.sk.PublicKey
+       }
+       return &RsaPublicKey{sk.pk}
+}
+
+// Decrypt returns decrypted bytes of the input encrypted bytes
+func (sk *RsaPrivateKey) Decrypt(b []byte) ([]byte, error) {
+       return rsa.DecryptPKCS1v15(rand.Reader, sk.sk, b)
+}
+
+func (sk *RsaPrivateKey) Type() pb.KeyType {
+       return pb.KeyType_RSA
+}
+
+// Bytes returns protobuf bytes from a private key
+func (sk *RsaPrivateKey) Bytes() ([]byte, error) {
+       return MarshalPrivateKey(sk)
+}
+
+func (sk *RsaPrivateKey) Raw() ([]byte, error) {
+       b := x509.MarshalPKCS1PrivateKey(sk.sk)
+       return b, nil
+}
+
+// Equals checks whether this key is equal to another
+func (sk *RsaPrivateKey) Equals(k Key) bool {
+       return KeyEqual(sk, k)
+}
+
+// UnmarshalRsaPrivateKey returns a private key from the input x509 bytes
+func UnmarshalRsaPrivateKey(b []byte) (PrivKey, error) {
+       sk, err := x509.ParsePKCS1PrivateKey(b)
+       if err != nil {
+               return nil, err
+       }
+       if sk.N.BitLen() < 512 {
+               return nil, ErrRsaKeyTooSmall
+       }
+       return &RsaPrivateKey{sk: sk}, nil
+}
+
+// MarshalRsaPrivateKey returns the x509 bytes of the private key
+func MarshalRsaPrivateKey(k *RsaPrivateKey) []byte {
+       return x509.MarshalPKCS1PrivateKey(k.sk)
+}
+
+// UnmarshalRsaPublicKey returns a public key from the input x509 bytes
+func UnmarshalRsaPublicKey(b []byte) (PubKey, error) {
+       pub, err := x509.ParsePKIXPublicKey(b)
+       if err != nil {
+               return nil, err
+       }
+       pk, ok := pub.(*rsa.PublicKey)
+       if !ok {
+               return nil, errors.New("not actually an rsa public key")
+       }
+       if pk.N.BitLen() < 512 {
+               return nil, ErrRsaKeyTooSmall
+       }
+       return &RsaPublicKey{pk}, nil
+}
+
+// MarshalRsaPublicKey returns the x509 bytes from the public key
+func MarshalRsaPublicKey(k *RsaPublicKey) ([]byte, error) {
+       return x509.MarshalPKIXPublicKey(k.k)
+}

diff --git a/vendor/github.com/libp2p/go-libp2p-crypto/rsa_test.go b/vendor/github.com/libp2p/go-libp2p-crypto/rsa_test.go
new file mode 100644 (file)
index 0000000..7ee520a
--- /dev/null
+++ b/vendor/github.com/libp2p/go-libp2p-crypto/rsa_test.go
@@ -0,0 +1,102 @@
+package crypto
+
+import (
+       "crypto/rand"
+       "testing"
+)
+
+func TestRSABasicSignAndVerify(t *testing.T) {
+       priv, pub, err := GenerateRSAKeyPair(512, rand.Reader)
+       if err != nil {
+               t.Fatal(err)
+       }
+
+       data := []byte("hello! and welcome to some awesome crypto primitives")
+
+       sig, err := priv.Sign(data)
+       if err != nil {
+               t.Fatal(err)
+       }
+
+       ok, err := pub.Verify(data, sig)
+       if err != nil {
+               t.Fatal(err)
+       }
+
+       if !ok {
+               t.Fatal("signature didnt match")
+       }
+
+       // change data
+       data[0] = ^data[0]
+       ok, err = pub.Verify(data, sig)
+       if err == nil {
+               t.Fatal("should have produced a verification error")
+       }
+
+       if ok {
+               t.Fatal("signature matched and shouldn't")
+       }
+}
+
+func TestRSASmallKey(t *testing.T) {
+       _, _, err := GenerateRSAKeyPair(384, rand.Reader)
+       if err != ErrRsaKeyTooSmall {
+               t.Fatal("should have refused to create small RSA key")
+       }
+}
+
+func TestRSASignZero(t *testing.T) {
+       priv, pub, err := GenerateRSAKeyPair(512, rand.Reader)
+       if err != nil {
+               t.Fatal(err)
+       }
+
+       data := make([]byte, 0)
+       sig, err := priv.Sign(data)
+       if err != nil {
+               t.Fatal(err)
+       }
+
+       ok, err := pub.Verify(data, sig)
+       if err != nil {
+               t.Fatal(err)
+       }
+       if !ok {
+               t.Fatal("signature didn't match")
+       }
+}
+
+func TestRSAMarshalLoop(t *testing.T) {
+       priv, pub, err := GenerateRSAKeyPair(512, rand.Reader)
+       if err != nil {
+               t.Fatal(err)
+       }
+
+       privB, err := priv.Bytes()
+       if err != nil {
+               t.Fatal(err)
+       }
+
+       privNew, err := UnmarshalPrivateKey(privB)
+       if err != nil {
+               t.Fatal(err)
+       }
+
+       if !priv.Equals(privNew) || !privNew.Equals(priv) {
+               t.Fatal("keys are not equal")
+       }
+
+       pubB, err := pub.Bytes()
+       if err != nil {
+               t.Fatal(err)
+       }
+       pubNew, err := UnmarshalPublicKey(pubB)
+       if err != nil {
+               t.Fatal(err)
+       }
+
+       if !pub.Equals(pubNew) || !pubNew.Equals(pub) {
+               t.Fatal("keys are not equal")
+       }
+}

diff --git a/vendor/github.com/libp2p/go-libp2p-crypto/secp256k1.go b/vendor/github.com/libp2p/go-libp2p-crypto/secp256k1.go
new file mode 100644 (file)
index 0000000..8bca33e
--- /dev/null
+++ b/vendor/github.com/libp2p/go-libp2p-crypto/secp256k1.go
@@ -0,0 +1,125 @@
+package crypto
+
+import (
+       "fmt"
+       "io"
+
+       pb "github.com/libp2p/go-libp2p-crypto/pb"
+
+       btcec "github.com/btcsuite/btcd/btcec"
+       sha256 "github.com/minio/sha256-simd"
+)
+
+// Secp256k1PrivateKey is an Secp256k1 private key
+type Secp256k1PrivateKey btcec.PrivateKey
+
+// Secp256k1PublicKey is an Secp256k1 public key
+type Secp256k1PublicKey btcec.PublicKey
+
+// GenerateSecp256k1Key generates a new Secp256k1 private and public key pair
+func GenerateSecp256k1Key(src io.Reader) (PrivKey, PubKey, error) {
+       privk, err := btcec.NewPrivateKey(btcec.S256())
+       if err != nil {
+               return nil, nil, err
+       }
+
+       k := (*Secp256k1PrivateKey)(privk)
+       return k, k.GetPublic(), nil
+}
+
+// UnmarshalSecp256k1PrivateKey returns a private key from bytes
+func UnmarshalSecp256k1PrivateKey(data []byte) (PrivKey, error) {
+       if len(data) != btcec.PrivKeyBytesLen {
+               return nil, fmt.Errorf("expected secp256k1 data size to be %d", btcec.PrivKeyBytesLen)
+       }
+
+       privk, _ := btcec.PrivKeyFromBytes(btcec.S256(), data)
+       return (*Secp256k1PrivateKey)(privk), nil
+}
+
+// UnmarshalSecp256k1PublicKey returns a public key from bytes
+func UnmarshalSecp256k1PublicKey(data []byte) (PubKey, error) {
+       k, err := btcec.ParsePubKey(data, btcec.S256())
+       if err != nil {
+               return nil, err
+       }
+
+       return (*Secp256k1PublicKey)(k), nil
+}
+
+// Bytes returns protobuf bytes from a private key
+func (k *Secp256k1PrivateKey) Bytes() ([]byte, error) {
+       return MarshalPrivateKey(k)
+}
+
+// Type returns the private key type
+func (k *Secp256k1PrivateKey) Type() pb.KeyType {
+       return pb.KeyType_Secp256k1
+}
+
+// Raw returns the bytes of the key
+func (k *Secp256k1PrivateKey) Raw() ([]byte, error) {
+       return (*btcec.PrivateKey)(k).Serialize(), nil
+}
+
+// Equals compares two private keys
+func (k *Secp256k1PrivateKey) Equals(o Key) bool {
+       sk, ok := o.(*Secp256k1PrivateKey)
+       if !ok {
+               return false
+       }
+
+       return k.D.Cmp(sk.D) == 0
+}
+
+// Sign returns a signature from input data
+func (k *Secp256k1PrivateKey) Sign(data []byte) ([]byte, error) {
+       hash := sha256.Sum256(data)
+       sig, err := (*btcec.PrivateKey)(k).Sign(hash[:])
+       if err != nil {
+               return nil, err
+       }
+
+       return sig.Serialize(), nil
+}
+
+// GetPublic returns a public key
+func (k *Secp256k1PrivateKey) GetPublic() PubKey {
+       return (*Secp256k1PublicKey)((*btcec.PrivateKey)(k).PubKey())
+}
+
+// Bytes returns protobuf bytes from a public key
+func (k *Secp256k1PublicKey) Bytes() ([]byte, error) {
+       return MarshalPublicKey(k)
+}
+
+// Type returns the public key type
+func (k *Secp256k1PublicKey) Type() pb.KeyType {
+       return pb.KeyType_Secp256k1
+}
+
+// Raw returns the bytes of the key
+func (k *Secp256k1PublicKey) Raw() ([]byte, error) {
+       return (*btcec.PublicKey)(k).SerializeCompressed(), nil
+}
+
+// Equals compares two public keys
+func (k *Secp256k1PublicKey) Equals(o Key) bool {
+       sk, ok := o.(*Secp256k1PublicKey)
+       if !ok {
+               return false
+       }
+
+       return (*btcec.PublicKey)(k).IsEqual((*btcec.PublicKey)(sk))
+}
+
+// Verify compares a signature against the input data
+func (k *Secp256k1PublicKey) Verify(data []byte, sigStr []byte) (bool, error) {
+       sig, err := btcec.ParseDERSignature(sigStr, btcec.S256())
+       if err != nil {
+               return false, err
+       }
+
+       hash := sha256.Sum256(data)
+       return sig.Verify(hash[:], (*btcec.PublicKey)(k)), nil
+}

diff --git a/vendor/github.com/libp2p/go-libp2p-crypto/secp256k1_test.go b/vendor/github.com/libp2p/go-libp2p-crypto/secp256k1_test.go
new file mode 100644 (file)
index 0000000..aff2bd9
--- /dev/null
+++ b/vendor/github.com/libp2p/go-libp2p-crypto/secp256k1_test.go
@@ -0,0 +1,96 @@
+package crypto
+
+import (
+       "crypto/rand"
+       "testing"
+)
+
+func TestSecp256k1BasicSignAndVerify(t *testing.T) {
+       priv, pub, err := GenerateSecp256k1Key(rand.Reader)
+       if err != nil {
+               t.Fatal(err)
+       }
+
+       data := []byte("hello! and welcome to some awesome crypto primitives")
+
+       sig, err := priv.Sign(data)
+       if err != nil {
+               t.Fatal(err)
+       }
+
+       ok, err := pub.Verify(data, sig)
+       if err != nil {
+               t.Fatal(err)
+       }
+
+       if !ok {
+               t.Fatal("signature didnt match")
+       }
+
+       // change data
+       data[0] = ^data[0]
+       ok, err = pub.Verify(data, sig)
+       if err != nil {
+               t.Fatal(err)
+       }
+
+       if ok {
+               t.Fatal("signature matched and shouldn't")
+       }
+}
+
+func TestSecp256k1SignZero(t *testing.T) {
+       priv, pub, err := GenerateSecp256k1Key(rand.Reader)
+       if err != nil {
+               t.Fatal(err)
+       }
+
+       data := make([]byte, 0)
+       sig, err := priv.Sign(data)
+       if err != nil {
+               t.Fatal(err)
+       }
+
+       ok, err := pub.Verify(data, sig)
+       if err != nil {
+               t.Fatal(err)
+       }
+       if !ok {
+               t.Fatal("signature didn't match")
+       }
+}
+
+func TestSecp256k1MarshalLoop(t *testing.T) {
+       priv, pub, err := GenerateSecp256k1Key(rand.Reader)
+       if err != nil {
+               t.Fatal(err)
+       }
+
+       privB, err := priv.Bytes()
+       if err != nil {
+               t.Fatal(err)
+       }
+
+       privNew, err := UnmarshalPrivateKey(privB)
+       if err != nil {
+               t.Fatal(err)
+       }
+
+       if !priv.Equals(privNew) || !privNew.Equals(priv) {
+               t.Fatal("keys are not equal")
+       }
+
+       pubB, err := pub.Bytes()
+       if err != nil {
+               t.Fatal(err)
+       }
+       pubNew, err := UnmarshalPublicKey(pubB)
+       if err != nil {
+               t.Fatal(err)
+       }
+
+       if !pub.Equals(pubNew) || !pubNew.Equals(pub) {
+               t.Fatal("keys are not equal")
+       }
+
+}

diff --git a/vendor/github.com/libp2p/go-libp2p-crypto/test/utils.go b/vendor/github.com/libp2p/go-libp2p-crypto/test/utils.go
new file mode 100644 (file)
index 0000000..f1c1f98
--- /dev/null
+++ b/vendor/github.com/libp2p/go-libp2p-crypto/test/utils.go
@@ -0,0 +1,17 @@
+package testutil
+
+import (
+       "math/rand"
+       "time"
+
+       ci "github.com/libp2p/go-libp2p-crypto"
+)
+
+func RandTestKeyPair(typ, bits int) (ci.PrivKey, ci.PubKey, error) {
+       return SeededTestKeyPair(typ, bits, time.Now().UnixNano())
+}
+
+func SeededTestKeyPair(typ, bits int, seed int64) (ci.PrivKey, ci.PubKey, error) {
+       r := rand.New(rand.NewSource(seed))
+       return ci.GenerateKeyPairWithReader(typ, bits, r)
+}

diff --git a/vendor/github.com/libp2p/go-libp2p-peer/.gx/lastpubver b/vendor/github.com/libp2p/go-libp2p-peer/.gx/lastpubver
new file mode 100644 (file)
index 0000000..dd887da
--- /dev/null
+++ b/vendor/github.com/libp2p/go-libp2p-peer/.gx/lastpubver
@@ -0,0 +1 @@
+3.1.1: QmTu65MVbemtUxJEWgsTtzv9Zv9P8rvmqNA4eG9TrTRGYc

diff --git a/vendor/github.com/libp2p/go-libp2p-peer/.travis.yml b/vendor/github.com/libp2p/go-libp2p-peer/.travis.yml
new file mode 100644 (file)
index 0000000..84756a1
--- /dev/null
+++ b/vendor/github.com/libp2p/go-libp2p-peer/.travis.yml
@@ -0,0 +1,20 @@
+os:
+  - linux
+  - osx
+
+language: go
+
+sudo: false
+
+go:
+  - 1.11.x
+
+install:
+  - make deps
+
+script:
+  - bash <(curl -s https://raw.githubusercontent.com/ipfs/ci-helpers/master/travis-ci/run-standard-tests.sh)
+
+cache:
+    directories:
+        - $GOPATH/src/gx

diff --git a/vendor/github.com/libp2p/go-libp2p-peer/LICENSE b/vendor/github.com/libp2p/go-libp2p-peer/LICENSE
new file mode 100644 (file)
index 0000000..2610033
--- /dev/null
+++ b/vendor/github.com/libp2p/go-libp2p-peer/LICENSE
@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2016 Jeromy Johnson
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

diff --git a/vendor/github.com/libp2p/go-libp2p-peer/Makefile b/vendor/github.com/libp2p/go-libp2p-peer/Makefile
new file mode 100644 (file)
index 0000000..2061941
--- /dev/null
+++ b/vendor/github.com/libp2p/go-libp2p-peer/Makefile
@@ -0,0 +1,11 @@
+gx:
+       go get github.com/whyrusleeping/gx
+       go get github.com/whyrusleeping/gx-go
+
+deps: gx
+       gx --verbose install --global
+       gx-go rewrite
+
+publish:
+       gx-go rewrite --undo
+

diff --git a/vendor/github.com/libp2p/go-libp2p-peer/README.md b/vendor/github.com/libp2p/go-libp2p-peer/README.md
new file mode 100644 (file)
index 0000000..035e168
--- /dev/null
+++ b/vendor/github.com/libp2p/go-libp2p-peer/README.md
@@ -0,0 +1,33 @@
+# go-libp2p-peer
+
+[![](https://img.shields.io/badge/made%20by-Protocol%20Labs-blue.svg?style=flat-square)](https://protocol.ai)
+[![](https://img.shields.io/badge/freenode-%23ipfs-blue.svg?style=flat-square)](https://webchat.freenode.net/?channels=%23ipfs)
+[![](https://img.shields.io/badge/project-IPFS-blue.svg?style=flat-square)](https://ipfs.io/)
+[![standard-readme compliant](https://img.shields.io/badge/standard--readme-OK-green.svg?style=flat-square)](https://github.com/RichardLitt/standard-readme)
+[![GoDoc](https://godoc.org/github.com/libp2p/go-libp2p-peer?status.svg)](https://godoc.org/github.com/libp2p/go-libp2p-peer)
+[![Coverage Status](https://codecov.io/gh/libp2p/go-libp2p-peer/branch/master/graph/badge.svg)](https://codecov.io/gh/libp2p/go-libp2p-peer/branch/master)
+[![Build Status](https://travis-ci.org/libp2p/go-libp2p-peer.svg?branch=master)](https://travis-ci.org/libp2p/go-libp2p-peer)
+
+> PKI based identities for use in go-libp2p
+
+## Install
+
+TODO
+
+## Usage
+
+TODO
+
+## Contribute
+
+Feel free to join in. All welcome. Open an [issue](https://github.com/libp2p/go-libp2p-peer/issues)!
+
+This repository falls under the IPFS [Code of Conduct](https://github.com/ipfs/community/blob/master/code-of-conduct.md).
+
+### Want to hack on IPFS?
+
+[![](https://cdn.rawgit.com/jbenet/contribute-ipfs-gif/master/img/contribute.gif)](https://github.com/ipfs/community/blob/master/contributing.md)
+
+## License
+
+MIT

diff --git a/vendor/github.com/libp2p/go-libp2p-peer/codecov.yml b/vendor/github.com/libp2p/go-libp2p-peer/codecov.yml
new file mode 100644 (file)
index 0000000..5f88a9e
--- /dev/null
+++ b/vendor/github.com/libp2p/go-libp2p-peer/codecov.yml
@@ -0,0 +1,3 @@
+coverage:
+  range: "50...100"
+comment: off

diff --git a/vendor/github.com/libp2p/go-libp2p-peer/package.json b/vendor/github.com/libp2p/go-libp2p-peer/package.json
new file mode 100644 (file)
index 0000000..d226725
--- /dev/null
+++ b/vendor/github.com/libp2p/go-libp2p-peer/package.json
@@ -0,0 +1,36 @@
+{
+  "author": "whyrusleeping",
+  "bugs": {
+    "url": "https://github.com/libp2p/go-libp2p-peer"
+  },
+  "gx": {
+    "dvcsimport": "github.com/libp2p/go-libp2p-peer"
+  },
+  "gxDependencies": [
+    {
+      "author": "whyrusleeping",
+      "hash": "QmTW4SdgBWq9GjsBsHeUx8WuGxzhgzAf88UMH2w62PC8yK",
+      "name": "go-libp2p-crypto",
+      "version": "2.0.7"
+    },
+    {
+      "author": "multiformats",
+      "hash": "QmerPMzPk1mJVowm8KgmoknWa4yCYvvugMPsgWmDNUvDLW",
+      "name": "go-multihash",
+      "version": "1.0.9"
+    },
+    {
+      "author": "mr-tron",
+      "hash": "QmWFAMPqsEyUX7gDUsRVmMWz59FxSpJ1b2v6bJ1yYzo7jY",
+      "name": "go-base58-fast",
+      "version": "0.1.1"
+    }
+  ],
+  "gxVersion": "0.4.0",
+  "language": "go",
+  "license": "MIT",
+  "name": "go-libp2p-peer",
+  "releaseCmd": "git commit -a -m \"gx publish $VERSION\"",
+  "version": "3.1.1"
+}
+

diff --git a/vendor/github.com/libp2p/go-libp2p-peer/peer.go b/vendor/github.com/libp2p/go-libp2p-peer/peer.go
new file mode 100644 (file)
index 0000000..6189d1d
--- /dev/null
+++ b/vendor/github.com/libp2p/go-libp2p-peer/peer.go
@@ -0,0 +1,177 @@
+// Package peer implements an object used to represent peers in the ipfs network.
+package peer
+
+import (
+       "encoding/hex"
+       "errors"
+       "fmt"
+
+       ic "github.com/libp2p/go-libp2p-crypto"
+       b58 "github.com/mr-tron/base58/base58"
+       mh "github.com/multiformats/go-multihash"
+)
+
+var (
+       // ErrEmptyPeerID is an error for empty peer ID.
+       ErrEmptyPeerID = errors.New("empty peer ID")
+       // ErrNoPublicKey is an error for peer IDs that don't embed public keys
+       ErrNoPublicKey = errors.New("public key is not embedded in peer ID")
+)
+
+// AdvancedEnableInlining enables automatically inlining keys shorter than
+// 42 bytes into the peer ID (using the "identity" multihash function).
+//
+// WARNING: This flag will likely be set to false in the future and eventually
+// be removed in favor of using a hash function specified by the key itself.
+// See: https://github.com/libp2p/specs/issues/138
+//
+// DO NOT change this flag unless you know what you're doing.
+//
+// This currently defaults to true for backwards compatibility but will likely
+// be set to false by default when an upgrade path is determined.
+var AdvancedEnableInlining = true
+
+const maxInlineKeyLength = 42
+
+// ID is a libp2p peer identity.
+type ID string
+
+// Pretty returns a b58-encoded string of the ID
+func (id ID) Pretty() string {
+       return IDB58Encode(id)
+}
+
+// Loggable returns a pretty peerID string in loggable JSON format
+func (id ID) Loggable() map[string]interface{} {
+       return map[string]interface{}{
+               "peerID": id.Pretty(),
+       }
+}
+
+// String prints out the peer.
+//
+// TODO(brian): ensure correctness at ID generation and
+// enforce this by only exposing functions that generate
+// IDs safely. Then any peer.ID type found in the
+// codebase is known to be correct.
+func (id ID) String() string {
+       pid := id.Pretty()
+       if len(pid) <= 10 {
+               return fmt.Sprintf("<peer.ID %s>", pid)
+       }
+       return fmt.Sprintf("<peer.ID %s*%s>", pid[:2], pid[len(pid)-6:])
+}
+
+// MatchesPrivateKey tests whether this ID was derived from sk
+func (id ID) MatchesPrivateKey(sk ic.PrivKey) bool {
+       return id.MatchesPublicKey(sk.GetPublic())
+}
+
+// MatchesPublicKey tests whether this ID was derived from pk
+func (id ID) MatchesPublicKey(pk ic.PubKey) bool {
+       oid, err := IDFromPublicKey(pk)
+       if err != nil {
+               return false
+       }
+       return oid == id
+}
+
+// ExtractPublicKey attempts to extract the public key from an ID
+//
+// This method returns ErrNoPublicKey if the peer ID looks valid but it can't extract
+// the public key.
+func (id ID) ExtractPublicKey() (ic.PubKey, error) {
+       decoded, err := mh.Decode([]byte(id))
+       if err != nil {
+               return nil, err
+       }
+       if decoded.Code != mh.ID {
+               return nil, ErrNoPublicKey
+       }
+       pk, err := ic.UnmarshalPublicKey(decoded.Digest)
+       if err != nil {
+               return nil, err
+       }
+       return pk, nil
+}
+
+// Validate check if ID is empty or not
+func (id ID) Validate() error {
+       if id == ID("") {
+               return ErrEmptyPeerID
+       }
+
+       return nil
+}
+
+// IDFromString cast a string to ID type, and validate
+// the id to make sure it is a multihash.
+func IDFromString(s string) (ID, error) {
+       if _, err := mh.Cast([]byte(s)); err != nil {
+               return ID(""), err
+       }
+       return ID(s), nil
+}
+
+// IDFromBytes cast a string to ID type, and validate
+// the id to make sure it is a multihash.
+func IDFromBytes(b []byte) (ID, error) {
+       if _, err := mh.Cast(b); err != nil {
+               return ID(""), err
+       }
+       return ID(b), nil
+}
+
+// IDB58Decode returns a b58-decoded Peer
+func IDB58Decode(s string) (ID, error) {
+       m, err := mh.FromB58String(s)
+       if err != nil {
+               return "", err
+       }
+       return ID(m), err
+}
+
+// IDB58Encode returns b58-encoded string
+func IDB58Encode(id ID) string {
+       return b58.Encode([]byte(id))
+}
+
+// IDHexDecode returns a hex-decoded Peer
+func IDHexDecode(s string) (ID, error) {
+       m, err := mh.FromHexString(s)
+       if err != nil {
+               return "", err
+       }
+       return ID(m), err
+}
+
+// IDHexEncode returns hex-encoded string
+func IDHexEncode(id ID) string {
+       return hex.EncodeToString([]byte(id))
+}
+
+// IDFromPublicKey returns the Peer ID corresponding to pk
+func IDFromPublicKey(pk ic.PubKey) (ID, error) {
+       b, err := pk.Bytes()
+       if err != nil {
+               return "", err
+       }
+       var alg uint64 = mh.SHA2_256
+       if AdvancedEnableInlining && len(b) <= maxInlineKeyLength {
+               alg = mh.ID
+       }
+       hash, _ := mh.Sum(b, alg, -1)
+       return ID(hash), nil
+}
+
+// IDFromPrivateKey returns the Peer ID corresponding to sk
+func IDFromPrivateKey(sk ic.PrivKey) (ID, error) {
+       return IDFromPublicKey(sk.GetPublic())
+}
+
+// IDSlice for sorting peers
+type IDSlice []ID
+
+func (es IDSlice) Len() int           { return len(es) }
+func (es IDSlice) Swap(i, j int)      { es[i], es[j] = es[j], es[i] }
+func (es IDSlice) Less(i, j int) bool { return string(es[i]) < string(es[j]) }

diff --git a/vendor/github.com/libp2p/go-libp2p-peer/peer_serde.go b/vendor/github.com/libp2p/go-libp2p-peer/peer_serde.go
new file mode 100644 (file)
index 0000000..161feb8
--- /dev/null
+++ b/vendor/github.com/libp2p/go-libp2p-peer/peer_serde.go
@@ -0,0 +1,44 @@
+// This file contains Protobuf and JSON serialization/deserialization methods for peer IDs.
+package peer
+
+import (
+       "encoding/json"
+)
+
+// Interface assertions commented out to avoid introducing hard dependencies to protobuf.
+// var _ proto.Marshaler = (*ID)(nil)
+// var _ proto.Unmarshaler = (*ID)(nil)
+var _ json.Marshaler = (*ID)(nil)
+var _ json.Unmarshaler = (*ID)(nil)
+
+func (id ID) Marshal() ([]byte, error) {
+       return []byte(id), nil
+}
+
+func (id ID) MarshalTo(data []byte) (n int, err error) {
+       return copy(data, []byte(id)), nil
+}
+
+func (id *ID) Unmarshal(data []byte) (err error) {
+       *id, err = IDFromBytes(data)
+       return err
+}
+
+// Implements Gogo's proto.Sizer, but we omit the compile-time assertion to avoid introducing a hard
+// dependency on gogo.
+func (id ID) Size() int {
+       return len([]byte(id))
+}
+
+func (id ID) MarshalJSON() ([]byte, error) {
+       return json.Marshal(IDB58Encode(id))
+}
+
+func (id *ID) UnmarshalJSON(data []byte) (err error) {
+       var v string
+       if err = json.Unmarshal(data, &v); err != nil {
+               return err
+       }
+       *id, err = IDB58Decode(v)
+       return err
+}

diff --git a/vendor/github.com/libp2p/go-libp2p-peer/peer_serde_test.go b/vendor/github.com/libp2p/go-libp2p-peer/peer_serde_test.go
new file mode 100644 (file)
index 0000000..fe8cc0c
--- /dev/null
+++ b/vendor/github.com/libp2p/go-libp2p-peer/peer_serde_test.go
@@ -0,0 +1,45 @@
+package peer_test
+
+import (
+       "testing"
+
+       "github.com/libp2p/go-libp2p-peer"
+       "github.com/libp2p/go-libp2p-peer/test"
+)
+
+func TestPeerSerdePB(t *testing.T) {
+       id, err := testutil.RandPeerID()
+       if err != nil {
+               t.Fatal(err)
+       }
+       b, err := id.Marshal()
+       if err != nil {
+               t.Fatal(err)
+       }
+
+       var id2 peer.ID
+       if err = id2.Unmarshal(b); err != nil {
+               t.Fatal(err)
+       }
+       if id != id2 {
+               t.Error("expected equal ids in circular serde test")
+       }
+}
+
+func TestPeerSerdeJSON(t *testing.T) {
+       id, err := testutil.RandPeerID()
+       if err != nil {
+               t.Fatal(err)
+       }
+       b, err := id.MarshalJSON()
+       if err != nil {
+               t.Fatal(err)
+       }
+       var id2 peer.ID
+       if err = id2.UnmarshalJSON(b); err != nil {
+               t.Fatal(err)
+       }
+       if id != id2 {
+               t.Error("expected equal ids in circular serde test")
+       }
+}

diff --git a/vendor/github.com/libp2p/go-libp2p-peer/peer_test.go b/vendor/github.com/libp2p/go-libp2p-peer/peer_test.go
new file mode 100644 (file)
index 0000000..2f0cb91
--- /dev/null
+++ b/vendor/github.com/libp2p/go-libp2p-peer/peer_test.go
@@ -0,0 +1,242 @@
+package peer_test
+
+import (
+       "crypto/rand"
+       "encoding/base64"
+       "fmt"
+       "strings"
+       "testing"
+
+       ic "github.com/libp2p/go-libp2p-crypto"
+       . "github.com/libp2p/go-libp2p-peer"
+       tu "github.com/libp2p/go-libp2p-peer/test"
+       mh "github.com/multiformats/go-multihash"
+
+       b58 "github.com/mr-tron/base58/base58"
+)
+
+var gen1 keyset // generated
+var gen2 keyset // generated
+var man keyset  // manual
+
+func hash(b []byte) []byte {
+       h, _ := mh.Sum(b, mh.SHA2_256, -1)
+       return []byte(h)
+}
+
+func init() {
+       if err := gen1.generate(); err != nil {
+               panic(err)
+       }
+       if err := gen2.generate(); err != nil {
+               panic(err)
+       }
+
+       skManBytes = strings.Replace(skManBytes, "\n", "", -1)
+       if err := man.load(hpkpMan, skManBytes); err != nil {
+               panic(err)
+       }
+}
+
+type keyset struct {
+       sk   ic.PrivKey
+       pk   ic.PubKey
+       hpk  string
+       hpkp string
+}
+
+func (ks *keyset) generate() error {
+       var err error
+       ks.sk, ks.pk, err = tu.RandTestKeyPair(512)
+       if err != nil {
+               return err
+       }
+
+       bpk, err := ks.pk.Bytes()
+       if err != nil {
+               return err
+       }
+
+       ks.hpk = string(hash(bpk))
+       ks.hpkp = b58.Encode([]byte(ks.hpk))
+       return nil
+}
+
+func (ks *keyset) load(hpkp, skBytesStr string) error {
+       skBytes, err := base64.StdEncoding.DecodeString(skBytesStr)
+       if err != nil {
+               return err
+       }
+
+       ks.sk, err = ic.UnmarshalPrivateKey(skBytes)
+       if err != nil {
+               return err
+       }
+
+       ks.pk = ks.sk.GetPublic()
+       bpk, err := ks.pk.Bytes()
+       if err != nil {
+               return err
+       }
+
+       ks.hpk = string(hash(bpk))
+       ks.hpkp = b58.Encode([]byte(ks.hpk))
+       if ks.hpkp != hpkp {
+               return fmt.Errorf("hpkp doesn't match key. %s", hpkp)
+       }
+       return nil
+}
+
+func TestIDMatchesPublicKey(t *testing.T) {
+
+       test := func(ks keyset) {
+               p1, err := IDB58Decode(ks.hpkp)
+               if err != nil {
+                       t.Fatal(err)
+               }
+
+               if ks.hpk != string(p1) {
+                       t.Error("p1 and hpk differ")
+               }
+
+               if !p1.MatchesPublicKey(ks.pk) {
+                       t.Fatal("p1 does not match pk")
+               }
+
+               p2, err := IDFromPublicKey(ks.pk)
+               if err != nil {
+                       t.Fatal(err)
+               }
+
+               if p1 != p2 {
+                       t.Error("p1 and p2 differ", p1.Pretty(), p2.Pretty())
+               }
+
+               if p2.Pretty() != ks.hpkp {
+                       t.Error("hpkp and p2.Pretty differ", ks.hpkp, p2.Pretty())
+               }
+       }
+
+       test(gen1)
+       test(gen2)
+       test(man)
+}
+
+func TestIDMatchesPrivateKey(t *testing.T) {
+
+       test := func(ks keyset) {
+               p1, err := IDB58Decode(ks.hpkp)
+               if err != nil {
+                       t.Fatal(err)
+               }
+
+               if ks.hpk != string(p1) {
+                       t.Error("p1 and hpk differ")
+               }
+
+               if !p1.MatchesPrivateKey(ks.sk) {
+                       t.Fatal("p1 does not match sk")
+               }
+
+               p2, err := IDFromPrivateKey(ks.sk)
+               if err != nil {
+                       t.Fatal(err)
+               }
+
+               if p1 != p2 {
+                       t.Error("p1 and p2 differ", p1.Pretty(), p2.Pretty())
+               }
+       }
+
+       test(gen1)
+       test(gen2)
+       test(man)
+}
+
+func TestPublicKeyExtraction(t *testing.T) {
+       t.Skip("disabled until libp2p/go-libp2p-crypto#51 is fixed")
+       // Happy path
+       _, originalPub, err := ic.GenerateEd25519Key(rand.Reader)
+       if err != nil {
+               t.Fatal(err)
+       }
+
+       id, err := IDFromPublicKey(originalPub)
+       if err != nil {
+               t.Fatal(err)
+       }
+
+       extractedPub, err := id.ExtractPublicKey()
+       if err != nil {
+               t.Fatal(err)
+       }
+       if extractedPub == nil {
+               t.Fatal("failed to extract public key")
+       }
+       if !originalPub.Equals(extractedPub) {
+               t.Fatal("extracted public key doesn't match")
+       }
+
+       // Test invalid multihash (invariant of the type of public key)
+       pk, err := ID("").ExtractPublicKey()
+       if err == nil {
+               t.Fatal("expected an error")
+       }
+       if pk != nil {
+               t.Fatal("expected a nil public key")
+       }
+
+       // Shouldn't work for, e.g. RSA keys (too large)
+
+       _, rsaPub, err := ic.GenerateKeyPair(ic.RSA, 2048)
+       if err != nil {
+               t.Fatal(err)
+       }
+       rsaId, err := IDFromPublicKey(rsaPub)
+       if err != nil {
+               t.Fatal(err)
+       }
+       extractedRsaPub, err := rsaId.ExtractPublicKey()
+       if err != ErrNoPublicKey {
+               t.Fatal(err)
+       }
+       if extractedRsaPub != nil {
+               t.Fatal("expected to fail to extract public key from rsa ID")
+       }
+}
+
+func TestValidate(t *testing.T) {
+       // Empty peer ID invalidates
+       err := ID("").Validate()
+       if err == nil {
+               t.Error("expected error")
+       } else if err != ErrEmptyPeerID {
+               t.Error("expected error message: " + ErrEmptyPeerID.Error())
+       }
+
+       // Non-empty peer ID validates
+       p, err := tu.RandPeerID()
+       if err != nil {
+               t.Fatal(err)
+       }
+
+       err = p.Validate()
+       if err != nil {
+               t.Error("expected nil, but found " + err.Error())
+       }
+}
+
+var hpkpMan = `QmRK3JgmVEGiewxWbhpXLJyjWuGuLeSTMTndA1coMHEy5o`
+var skManBytes = `
+CAAS4AQwggJcAgEAAoGBAL7w+Wc4VhZhCdM/+Hccg5Nrf4q9NXWwJylbSrXz/unFS24wyk6pEk0zi3W
+7li+vSNVO+NtJQw9qGNAMtQKjVTP+3Vt/jfQRnQM3s6awojtjueEWuLYVt62z7mofOhCtj+VwIdZNBo
+/EkLZ0ETfcvN5LVtLYa8JkXybnOPsLvK+PAgMBAAECgYBdk09HDM7zzL657uHfzfOVrdslrTCj6p5mo
+DzvCxLkkjIzYGnlPuqfNyGjozkpSWgSUc+X+EGLLl3WqEOVdWJtbM61fewEHlRTM5JzScvwrJ39t7o6
+CCAjKA0cBWBd6UWgbN/t53RoWvh9HrA2AW5YrT0ZiAgKe9y7EMUaENVJ8QJBAPhpdmb4ZL4Fkm4OKia
+NEcjzn6mGTlZtef7K/0oRC9+2JkQnCuf6HBpaRhJoCJYg7DW8ZY+AV6xClKrgjBOfERMCQQDExhnzu2
+dsQ9k8QChBlpHO0TRbZBiQfC70oU31kM1AeLseZRmrxv9Yxzdl8D693NNWS2JbKOXl0kMHHcuGQLMVA
+kBZ7WvkmPV3aPL6jnwp2pXepntdVnaTiSxJ1dkXShZ/VSSDNZMYKY306EtHrIu3NZHtXhdyHKcggDXr
+qkBrdgErAkAlpGPojUwemOggr4FD8sLX1ot2hDJyyV7OK2FXfajWEYJyMRL1Gm9Uk1+Un53RAkJneqp
+JGAzKpyttXBTIDO51AkEA98KTiROMnnU8Y6Mgcvr68/SMIsvCYMt9/mtwSBGgl80VaTQ5Hpaktl6Xbh
+VUt5Wv0tRxlXZiViCGCD1EtrrwTw==
+`

diff --git a/vendor/github.com/libp2p/go-libp2p-peer/peerset/peerset.go b/vendor/github.com/libp2p/go-libp2p-peer/peerset/peerset.go
new file mode 100644 (file)
index 0000000..0cc87dd
--- /dev/null
+++ b/vendor/github.com/libp2p/go-libp2p-peer/peerset/peerset.go
@@ -0,0 +1,72 @@
+package peerset
+
+import (
+       "sync"
+
+       peer "github.com/libp2p/go-libp2p-peer"
+)
+
+// PeerSet is a threadsafe set of peers
+type PeerSet struct {
+       ps   map[peer.ID]struct{}
+       lk   sync.RWMutex
+       size int
+}
+
+func New() *PeerSet {
+       ps := new(PeerSet)
+       ps.ps = make(map[peer.ID]struct{})
+       ps.size = -1
+       return ps
+}
+
+func NewLimited(size int) *PeerSet {
+       ps := new(PeerSet)
+       ps.ps = make(map[peer.ID]struct{})
+       ps.size = size
+       return ps
+}
+
+func (ps *PeerSet) Add(p peer.ID) {
+       ps.lk.Lock()
+       ps.ps[p] = struct{}{}
+       ps.lk.Unlock()
+}
+
+func (ps *PeerSet) Contains(p peer.ID) bool {
+       ps.lk.RLock()
+       _, ok := ps.ps[p]
+       ps.lk.RUnlock()
+       return ok
+}
+
+func (ps *PeerSet) Size() int {
+       ps.lk.RLock()
+       defer ps.lk.RUnlock()
+       return len(ps.ps)
+}
+
+// TryAdd Attempts to add the given peer into the set.
+// This operation can fail for one of two reasons:
+// 1) The given peer is already in the set
+// 2) The number of peers in the set is equal to size
+func (ps *PeerSet) TryAdd(p peer.ID) bool {
+       var success bool
+       ps.lk.Lock()
+       if _, ok := ps.ps[p]; !ok && (len(ps.ps) < ps.size || ps.size == -1) {
+               success = true
+               ps.ps[p] = struct{}{}
+       }
+       ps.lk.Unlock()
+       return success
+}
+
+func (ps *PeerSet) Peers() []peer.ID {
+       ps.lk.Lock()
+       out := make([]peer.ID, 0, len(ps.ps))
+       for p, _ := range ps.ps {
+               out = append(out, p)
+       }
+       ps.lk.Unlock()
+       return out
+}

diff --git a/vendor/github.com/libp2p/go-libp2p-peer/test/utils.go b/vendor/github.com/libp2p/go-libp2p-peer/test/utils.go
new file mode 100644 (file)
index 0000000..fd23d1d
--- /dev/null
+++ b/vendor/github.com/libp2p/go-libp2p-peer/test/utils.go
@@ -0,0 +1,39 @@
+package testutil
+
+import (
+       "io"
+       "math/rand"
+       "sync/atomic"
+       "time"
+
+       ci "github.com/libp2p/go-libp2p-crypto"
+       peer "github.com/libp2p/go-libp2p-peer"
+       mh "github.com/multiformats/go-multihash"
+)
+
+var generatedPairs int64 = 0
+
+func RandPeerID() (peer.ID, error) {
+       r := rand.New(rand.NewSource(time.Now().UnixNano()))
+       buf := make([]byte, 16)
+       if _, err := io.ReadFull(r, buf); err != nil {
+               return "", err
+       }
+       h, _ := mh.Sum(buf, mh.SHA2_256, -1)
+       return peer.ID(h), nil
+}
+
+func RandTestKeyPair(bits int) (ci.PrivKey, ci.PubKey, error) {
+       seed := time.Now().UnixNano()
+
+       // workaround for low time resolution
+       seed += atomic.AddInt64(&generatedPairs, 1) << 32
+
+       r := rand.New(rand.NewSource(seed))
+       return ci.GenerateKeyPairWithReader(ci.RSA, bits, r)
+}
+
+func SeededTestKeyPair(seed int64) (ci.PrivKey, ci.PubKey, error) {
+       r := rand.New(rand.NewSource(seed))
+       return ci.GenerateKeyPairWithReader(ci.RSA, 512, r)
+}

diff --git a/vendor/github.com/minio/blake2b-simd/.gitignore b/vendor/github.com/minio/blake2b-simd/.gitignore
new file mode 100644 (file)
index 0000000..c56069f
--- /dev/null
+++ b/vendor/github.com/minio/blake2b-simd/.gitignore
@@ -0,0 +1 @@
+*.test
\ No newline at end of file

diff --git a/vendor/github.com/minio/blake2b-simd/.travis.yml b/vendor/github.com/minio/blake2b-simd/.travis.yml
new file mode 100644 (file)
index 0000000..545066e
--- /dev/null
+++ b/vendor/github.com/minio/blake2b-simd/.travis.yml
@@ -0,0 +1,21 @@
+sudo: required
+dist: trusty
+language: go
+
+os:
+- linux
+- osx
+
+osx_image: xcode7.2
+
+go:
+- 1.6
+- 1.5
+
+env:
+- ARCH=x86_64
+- ARCH=i686
+
+script:
+- diff -au <(gofmt -d .) <(printf "")
+- go test -race -v ./...

diff --git a/vendor/github.com/minio/blake2b-simd/LICENSE b/vendor/github.com/minio/blake2b-simd/LICENSE
new file mode 100644 (file)
index 0000000..d645695
--- /dev/null
+++ b/vendor/github.com/minio/blake2b-simd/LICENSE
@@ -0,0 +1,202 @@
+
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
+
+   APPENDIX: How to apply the Apache License to your work.
+
+      To apply the Apache License to your work, attach the following
+      boilerplate notice, with the fields enclosed by brackets "[]"
+      replaced with your own identifying information. (Don't include
+      the brackets!)  The text should be enclosed in the appropriate
+      comment syntax for the file format. We also recommend that a
+      file or class name and description of purpose be included on the
+      same "printed page" as the copyright notice for easier
+      identification within third-party archives.
+
+   Copyright [yyyy] [name of copyright owner]
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.

diff --git a/vendor/github.com/minio/blake2b-simd/README.md b/vendor/github.com/minio/blake2b-simd/README.md
new file mode 100644 (file)
index 0000000..31fcbf7
--- /dev/null
+++ b/vendor/github.com/minio/blake2b-simd/README.md
@@ -0,0 +1,144 @@
+BLAKE2b-SIMD
+============
+
+Pure Go implementation of BLAKE2b using SIMD optimizations.
+
+Introduction
+------------
+
+This package was initially based on the pure go [BLAKE2b](https://github.com/dchest/blake2b) implementation of Dmitry Chestnykh and merged with the (`cgo` dependent) AVX optimized [BLAKE2](https://github.com/codahale/blake2) implementation (which in turn is based on the [official implementation](https://github.com/BLAKE2/BLAKE2). It does so by using [Go's Assembler](https://golang.org/doc/asm) for amd64 architectures with a golang only fallback for other architectures.
+
+In addition to AVX there is also support for AVX2 as well as SSE. Best performance is obtained with AVX2 which gives roughly a **4X** performance increase approaching hashing speeds of **1GB/sec** on a single core.
+
+Benchmarks
+----------
+
+This is a summary of the performance improvements. Full details are shown below.
+
+| Technology |  128K |
+| ---------- |:-----:|
+| AVX2       | 3.94x |
+| AVX        | 3.28x |
+| SSE        | 2.85x |
+
+asm2plan9s
+----------
+
+In order to be able to work more easily with AVX2/AVX instructions, a separate tool was developed to convert AVX2/AVX instructions into the corresponding BYTE sequence as accepted by Go assembly. See [asm2plan9s](https://github.com/minio/asm2plan9s) for more information.
+
+bt2sum
+------
+
+[bt2sum](https://github.com/s3git/bt2sum) is a utility that takes advantages of the BLAKE2b SIMD optimizations to compute check sums using the BLAKE2 Tree hashing mode in so called 'unlimited fanout' mode.
+
+Technical details
+-----------------
+
+BLAKE2b is a hashing algorithm that operates on 64-bit integer values. The AVX2 version uses the 256-bit wide YMM registers in order to essentially process four operations in parallel. AVX and SSE operate on 128-bit values simultaneously (two operations in parallel). Below are excerpts from `compressAvx2_amd64.s`, `compressAvx_amd64.s`, and `compress_generic.go` respectively.
+
+```
+    VPADDQ  YMM0,YMM0,YMM1   /* v0 += v4, v1 += v5, v2 += v6, v3 += v7 */
+```
+
+```
+    VPADDQ  XMM0,XMM0,XMM2   /* v0 += v4, v1 += v5 */
+    VPADDQ  XMM1,XMM1,XMM3   /* v2 += v6, v3 += v7 */
+```
+
+```
+    v0 += v4
+    v1 += v5
+    v2 += v6
+    v3 += v7
+```
+
+Detailed benchmarks
+-------------------
+
+Example performance metrics were generated on  Intel(R) Xeon(R) CPU E5-2620 v3 @ 2.40GHz - 6 physical cores, 12 logical cores running Ubuntu GNU/Linux with kernel version 4.4.0-24-generic (vanilla with no optimizations).
+
+### AVX2
+
+```
+$ benchcmp go.txt avx2.txt
+benchmark                old ns/op     new ns/op     delta
+BenchmarkHash64-12       1481          849           -42.67%
+BenchmarkHash128-12      1428          746           -47.76%
+BenchmarkHash1K-12       6379          2227          -65.09%
+BenchmarkHash8K-12       37219         11714         -68.53%
+BenchmarkHash32K-12      140716        35935         -74.46%
+BenchmarkHash128K-12     561656        142634        -74.60%
+
+benchmark                old MB/s     new MB/s     speedup
+BenchmarkHash64-12       43.20        75.37        1.74x
+BenchmarkHash128-12      89.64        171.35       1.91x
+BenchmarkHash1K-12       160.52       459.69       2.86x
+BenchmarkHash8K-12       220.10       699.32       3.18x
+BenchmarkHash32K-12      232.87       911.85       3.92x
+BenchmarkHash128K-12     233.37       918.93       3.94x
+```
+
+### AVX2: Comparison to other hashing techniques
+
+```
+$ go test -bench=Comparison
+BenchmarkComparisonMD5-12          1000           1726121 ns/op         607.48 MB/s
+BenchmarkComparisonSHA1-12          500           2005164 ns/op         522.94 MB/s
+BenchmarkComparisonSHA256-12        300           5531036 ns/op         189.58 MB/s
+BenchmarkComparisonSHA512-12        500           3423030 ns/op         306.33 MB/s
+BenchmarkComparisonBlake2B-12      1000           1232690 ns/op         850.64 MB/s
+```
+
+Benchmarks below were generated on a MacBook Pro with a 2.7 GHz Intel Core i7.
+
+### AVX
+
+```
+$ benchcmp go.txt  avx.txt 
+benchmark               old ns/op     new ns/op     delta
+BenchmarkHash64-8       813           458           -43.67%
+BenchmarkHash128-8      766           401           -47.65%
+BenchmarkHash1K-8       4881          1763          -63.88%
+BenchmarkHash8K-8       36127         12273         -66.03%
+BenchmarkHash32K-8      140582        43155         -69.30%
+BenchmarkHash128K-8     567850        173246        -69.49%
+
+benchmark               old MB/s     new MB/s     speedup
+BenchmarkHash64-8       78.63        139.57       1.78x
+BenchmarkHash128-8      166.98       318.73       1.91x
+BenchmarkHash1K-8       209.76       580.68       2.77x
+BenchmarkHash8K-8       226.76       667.46       2.94x
+BenchmarkHash32K-8      233.09       759.29       3.26x
+BenchmarkHash128K-8     230.82       756.56       3.28x
+```
+
+### SSE
+
+```
+$ benchcmp go.txt sse.txt 
+benchmark               old ns/op     new ns/op     delta
+BenchmarkHash64-8       813           478           -41.21%
+BenchmarkHash128-8      766           411           -46.34%
+BenchmarkHash1K-8       4881          1870          -61.69%
+BenchmarkHash8K-8       36127         12427         -65.60%
+BenchmarkHash32K-8      140582        49512         -64.78%
+BenchmarkHash128K-8     567850        199040        -64.95%
+
+benchmark               old MB/s     new MB/s     speedup
+BenchmarkHash64-8       78.63        133.78       1.70x
+BenchmarkHash128-8      166.98       311.23       1.86x
+BenchmarkHash1K-8       209.76       547.37       2.61x
+BenchmarkHash8K-8       226.76       659.20       2.91x
+BenchmarkHash32K-8      233.09       661.81       2.84x
+BenchmarkHash128K-8     230.82       658.52       2.85x
+```
+
+License
+-------
+
+Released under the Apache License v2.0. You can find the complete text in the file LICENSE.
+
+Contributing
+------------
+
+Contributions are welcome, please send PRs for any enhancements.

diff --git a/vendor/github.com/minio/blake2b-simd/appveyor.yml b/vendor/github.com/minio/blake2b-simd/appveyor.yml
new file mode 100644 (file)
index 0000000..77595fe
--- /dev/null
+++ b/vendor/github.com/minio/blake2b-simd/appveyor.yml
@@ -0,0 +1,32 @@
+# version format
+version: "{build}"
+
+# Operating system (build VM template)
+os: Windows Server 2012 R2
+
+# Platform.
+platform: x64
+
+clone_folder: c:\gopath\src\github.com\minio\blake2b-simd
+
+# environment variables
+environment:
+  GOPATH: c:\gopath
+  GO15VENDOREXPERIMENT: 1
+
+# scripts that run after cloning repository
+install:
+  - set PATH=%GOPATH%\bin;c:\go\bin;%PATH%
+  - go version
+  - go env
+
+# to run your custom scripts instead of automatic MSBuild
+build_script:
+  - go test .
+  - go test -race .
+
+# to disable automatic tests
+test: off
+
+# to disable deployment
+deploy: off

diff --git a/vendor/github.com/minio/blake2b-simd/benchmarks_test.go b/vendor/github.com/minio/blake2b-simd/benchmarks_test.go
new file mode 100644 (file)
index 0000000..f8d4c15
--- /dev/null
+++ b/vendor/github.com/minio/blake2b-simd/benchmarks_test.go
@@ -0,0 +1,101 @@
+/*
+ * Minio Cloud Storage, (C) 2016 Minio, Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package blake2b
+
+import (
+       "crypto/md5"
+       "crypto/sha1"
+       "crypto/sha256"
+       "crypto/sha512"
+       "hash"
+       "testing"
+)
+
+func benchmarkHash(b *testing.B, hash func() hash.Hash) {
+       b.SetBytes(1024 * 1024)
+       var data [1024]byte
+       for i := 0; i < b.N; i++ {
+               h := hash()
+               for j := 0; j < 1024; j++ {
+                       h.Write(data[:])
+               }
+               h.Sum(nil)
+       }
+}
+
+func BenchmarkComparisonMD5(b *testing.B) {
+       benchmarkHash(b, md5.New)
+}
+
+func BenchmarkComparisonSHA1(b *testing.B) {
+       benchmarkHash(b, sha1.New)
+}
+
+func BenchmarkComparisonSHA256(b *testing.B) {
+       benchmarkHash(b, sha256.New)
+}
+
+func BenchmarkComparisonSHA512(b *testing.B) {
+       benchmarkHash(b, sha512.New)
+}
+
+func BenchmarkComparisonBlake2B(b *testing.B) {
+       benchmarkHash(b, New512)
+}
+
+// Benchmark blake2b implementation.
+var bench = New512()
+var buf [128 * 1024]byte
+
+func benchmarkSize(b *testing.B, size int) {
+       b.SetBytes(int64(size))
+       for i := 0; i < b.N; i++ {
+               bench.Reset()
+               bench.Write(buf[:size])
+               bench.Sum(nil)
+       }
+}
+
+// Benchmark writes of 64 bytes.
+func BenchmarkSize64(b *testing.B) {
+       benchmarkSize(b, 64)
+}
+
+// Benchmark writes of 128 bytes.
+func BenchmarkSize128(b *testing.B) {
+       benchmarkSize(b, 128)
+}
+
+// Benchmark writes of 1KiB bytes.
+func BenchmarkSize1K(b *testing.B) {
+       benchmarkSize(b, 1024)
+}
+
+// Benchmark writes of 8KiB bytes.
+func BenchmarkSize8K(b *testing.B) {
+       benchmarkSize(b, 8*1024)
+}
+
+// Benchmark writes of 32KiB bytes.
+func BenchmarkSize32K(b *testing.B) {
+       benchmarkSize(b, 32*1024)
+}
+
+// Benchmark writes of 128KiB bytes.
+func BenchmarkSize128K(b *testing.B) {
+       benchmarkSize(b, 128*1024)
+}

diff --git a/vendor/github.com/minio/blake2b-simd/blake2b.go b/vendor/github.com/minio/blake2b-simd/blake2b.go
new file mode 100644 (file)
index 0000000..538466a
--- /dev/null
+++ b/vendor/github.com/minio/blake2b-simd/blake2b.go
@@ -0,0 +1,301 @@
+// Written in 2012 by Dmitry Chestnykh.
+//
+// To the extent possible under law, the author have dedicated all copyright
+// and related and neighboring rights to this software to the public domain
+// worldwide. This software is distributed without any warranty.
+// http://creativecommons.org/publicdomain/zero/1.0/
+
+// Package blake2b implements BLAKE2b cryptographic hash function.
+package blake2b
+
+import (
+       "encoding/binary"
+       "errors"
+       "hash"
+)
+
+const (
+       BlockSize  = 128 // block size of algorithm
+       Size       = 64  // maximum digest size
+       SaltSize   = 16  // maximum salt size
+       PersonSize = 16  // maximum personalization string size
+       KeySize    = 64  // maximum size of key
+)
+
+type digest struct {
+       h  [8]uint64       // current chain value
+       t  [2]uint64       // message bytes counter
+       f  [2]uint64       // finalization flags
+       x  [BlockSize]byte // buffer for data not yet compressed
+       nx int             // number of bytes in buffer
+
+       ih         [8]uint64       // initial chain value (after config)
+       paddedKey  [BlockSize]byte // copy of key, padded with zeros
+       isKeyed    bool            // indicates whether hash was keyed
+       size       uint8           // digest size in bytes
+       isLastNode bool            // indicates processing of the last node in tree hashing
+}
+
+// Initialization values.
+var iv = [8]uint64{
+       0x6a09e667f3bcc908, 0xbb67ae8584caa73b,
+       0x3c6ef372fe94f82b, 0xa54ff53a5f1d36f1,
+       0x510e527fade682d1, 0x9b05688c2b3e6c1f,
+       0x1f83d9abfb41bd6b, 0x5be0cd19137e2179,
+}
+
+// Config is used to configure hash function parameters and keying.
+// All parameters are optional.
+type Config struct {
+       Size   uint8  // digest size (if zero, default size of 64 bytes is used)
+       Key    []byte // key for prefix-MAC
+       Salt   []byte // salt (if < 16 bytes, padded with zeros)
+       Person []byte // personalization (if < 16 bytes, padded with zeros)
+       Tree   *Tree  // parameters for tree hashing
+}
+
+// Tree represents parameters for tree hashing.
+type Tree struct {
+       Fanout        uint8  // fanout
+       MaxDepth      uint8  // maximal depth
+       LeafSize      uint32 // leaf maximal byte length (0 for unlimited)
+       NodeOffset    uint64 // node offset (0 for first, leftmost or leaf)
+       NodeDepth     uint8  // node depth (0 for leaves)
+       InnerHashSize uint8  // inner hash byte length
+       IsLastNode    bool   // indicates processing of the last node of layer
+}
+
+var (
+       defaultConfig = &Config{Size: Size}
+       config256     = &Config{Size: 32}
+)
+
+func verifyConfig(c *Config) error {
+       if c.Size > Size {
+               return errors.New("digest size is too large")
+       }
+       if len(c.Key) > KeySize {
+               return errors.New("key is too large")
+       }
+       if len(c.Salt) > SaltSize {
+               // Smaller salt is okay: it will be padded with zeros.
+               return errors.New("salt is too large")
+       }
+       if len(c.Person) > PersonSize {
+               // Smaller personalization is okay: it will be padded with zeros.
+               return errors.New("personalization is too large")
+       }
+       if c.Tree != nil {
+               if c.Tree.Fanout == 1 {
+                       return errors.New("fanout of 1 is not allowed in tree mode")
+               }
+               if c.Tree.MaxDepth < 2 {
+                       return errors.New("incorrect tree depth")
+               }
+               if c.Tree.InnerHashSize < 1 || c.Tree.InnerHashSize > Size {
+                       return errors.New("incorrect tree inner hash size")
+               }
+       }
+       return nil
+}
+
+// New returns a new hash.Hash configured with the given Config.
+// Config can be nil, in which case the default one is used, calculating 64-byte digest.
+// Returns non-nil error if Config contains invalid parameters.
+func New(c *Config) (hash.Hash, error) {
+       if c == nil {
+               c = defaultConfig
+       } else {
+               if c.Size == 0 {
+                       // Set default size if it's zero.
+                       c.Size = Size
+               }
+               if err := verifyConfig(c); err != nil {
+                       return nil, err
+               }
+       }
+       d := new(digest)
+       d.initialize(c)
+       return d, nil
+}
+
+// initialize initializes digest with the given
+// config, which must be non-nil and verified.
+func (d *digest) initialize(c *Config) {
+       // Create parameter block.
+       var p [BlockSize]byte
+       p[0] = c.Size
+       p[1] = uint8(len(c.Key))
+       if c.Salt != nil {
+               copy(p[32:], c.Salt)
+       }
+       if c.Person != nil {
+               copy(p[48:], c.Person)
+       }
+       if c.Tree != nil {
+               p[2] = c.Tree.Fanout
+               p[3] = c.Tree.MaxDepth
+               binary.LittleEndian.PutUint32(p[4:], c.Tree.LeafSize)
+               binary.LittleEndian.PutUint64(p[8:], c.Tree.NodeOffset)
+               p[16] = c.Tree.NodeDepth
+               p[17] = c.Tree.InnerHashSize
+       } else {
+               p[2] = 1
+               p[3] = 1
+       }
+
+       // Initialize.
+       d.size = c.Size
+       for i := 0; i < 8; i++ {
+               d.h[i] = iv[i] ^ binary.LittleEndian.Uint64(p[i*8:])
+       }
+       if c.Tree != nil && c.Tree.IsLastNode {
+               d.isLastNode = true
+       }
+
+       // Process key.
+       if c.Key != nil {
+               copy(d.paddedKey[:], c.Key)
+               d.Write(d.paddedKey[:])
+               d.isKeyed = true
+       }
+       // Save a copy of initialized state.
+       copy(d.ih[:], d.h[:])
+}
+
+// New512 returns a new hash.Hash computing the BLAKE2b 64-byte checksum.
+func New512() hash.Hash {
+       d := new(digest)
+       d.initialize(defaultConfig)
+       return d
+}
+
+// New256 returns a new hash.Hash computing the BLAKE2b 32-byte checksum.
+func New256() hash.Hash {
+       d := new(digest)
+       d.initialize(config256)
+       return d
+}
+
+// NewMAC returns a new hash.Hash computing BLAKE2b prefix-
+// Message Authentication Code of the given size in bytes
+// (up to 64) with the given key (up to 64 bytes in length).
+func NewMAC(outBytes uint8, key []byte) hash.Hash {
+       d, err := New(&Config{Size: outBytes, Key: key})
+       if err != nil {
+               panic(err.Error())
+       }
+       return d
+}
+
+// Reset resets the state of digest to the initial state
+// after configuration and keying.
+func (d *digest) Reset() {
+       copy(d.h[:], d.ih[:])
+       d.t[0] = 0
+       d.t[1] = 0
+       d.f[0] = 0
+       d.f[1] = 0
+       d.nx = 0
+       if d.isKeyed {
+               d.Write(d.paddedKey[:])
+       }
+}
+
+// Size returns the digest size in bytes.
+func (d *digest) Size() int { return int(d.size) }
+
+// BlockSize returns the algorithm block size in bytes.
+func (d *digest) BlockSize() int { return BlockSize }
+
+func (d *digest) Write(p []byte) (nn int, err error) {
+       nn = len(p)
+       left := BlockSize - d.nx
+       if len(p) > left {
+               // Process buffer.
+               copy(d.x[d.nx:], p[:left])
+               p = p[left:]
+               compress(d, d.x[:])
+               d.nx = 0
+       }
+       // Process full blocks except for the last one.
+       if len(p) > BlockSize {
+               n := len(p) &^ (BlockSize - 1)
+               if n == len(p) {
+                       n -= BlockSize
+               }
+               compress(d, p[:n])
+               p = p[n:]
+       }
+       // Fill buffer.
+       d.nx += copy(d.x[d.nx:], p)
+       return
+}
+
+// Sum returns the calculated checksum.
+func (d *digest) Sum(in []byte) []byte {
+       // Make a copy of d so that caller can keep writing and summing.
+       d0 := *d
+       hash := d0.checkSum()
+       return append(in, hash[:d0.size]...)
+}
+
+func (d *digest) checkSum() [Size]byte {
+       // Do not create unnecessary copies of the key.
+       if d.isKeyed {
+               for i := 0; i < len(d.paddedKey); i++ {
+                       d.paddedKey[i] = 0
+               }
+       }
+
+       dec := BlockSize - uint64(d.nx)
+       if d.t[0] < dec {
+               d.t[1]--
+       }
+       d.t[0] -= dec
+
+       // Pad buffer with zeros.
+       for i := d.nx; i < len(d.x); i++ {
+               d.x[i] = 0
+       }
+       // Set last block flag.
+       d.f[0] = 0xffffffffffffffff
+       if d.isLastNode {
+               d.f[1] = 0xffffffffffffffff
+       }
+       // Compress last block.
+       compress(d, d.x[:])
+
+       var out [Size]byte
+       j := 0
+       for _, s := range d.h[:(d.size-1)/8+1] {
+               out[j+0] = byte(s >> 0)
+               out[j+1] = byte(s >> 8)
+               out[j+2] = byte(s >> 16)
+               out[j+3] = byte(s >> 24)
+               out[j+4] = byte(s >> 32)
+               out[j+5] = byte(s >> 40)
+               out[j+6] = byte(s >> 48)
+               out[j+7] = byte(s >> 56)
+               j += 8
+       }
+       return out
+}
+
+// Sum512 returns a 64-byte BLAKE2b hash of data.
+func Sum512(data []byte) [64]byte {
+       var d digest
+       d.initialize(defaultConfig)
+       d.Write(data)
+       return d.checkSum()
+}
+
+// Sum256 returns a 32-byte BLAKE2b hash of data.
+func Sum256(data []byte) (out [32]byte) {
+       var d digest
+       d.initialize(config256)
+       d.Write(data)
+       sum := d.checkSum()
+       copy(out[:], sum[:32])
+       return
+}

diff --git a/vendor/github.com/minio/blake2b-simd/blake2b_test.go b/vendor/github.com/minio/blake2b-simd/blake2b_test.go
new file mode 100644 (file)
index 0000000..63ce6d3
--- /dev/null
+++ b/vendor/github.com/minio/blake2b-simd/blake2b_test.go
@@ -0,0 +1,598 @@
+/*
+ * Minio Cloud Storage, (C) 2016 Minio, Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package blake2b
+
+import (
+       "fmt"
+       "testing"
+)
+
+// TestSum - tests and validates golden set of values again
+// pre-defined set of inputs and matches blake2b output.
+func TestSum(t *testing.T) {
+       buf := make([]byte, len(golden))
+       for i := range buf {
+               buf[i] = byte(i)
+       }
+       h := New512()
+       for i, v := range golden {
+               if v != fmt.Sprintf("%x", Sum512(buf[:i])) {
+                       t.Errorf("%d: Sum512(): \nexpected %s\ngot      %x", i, v, Sum512(buf[:i]))
+               }
+               h.Reset()
+               h.Write(buf[:i])
+               sum := h.Sum(nil)
+               if fmt.Sprintf("%x", sum) != v {
+                       t.Errorf("%d:\nexpected %s\ngot      %x", i, v, sum)
+               }
+
+       }
+}
+
+func TestSum256(t *testing.T) {
+       // Simple one-hash test.
+       in := "The cryptographic hash function BLAKE2 is an improved version of the SHA-3 finalist BLAKE"
+       good := "e5866d0c42b4e27e89a316fa5c3ba8cacae754e53d8267da37ba1893c2fcd92c"
+       if good != fmt.Sprintf("%x", Sum256([]byte(in))) {
+               t.Errorf("Sum256(): \nexpected %s\ngot      %x", good, Sum256([]byte(in)))
+       }
+
+}
+
+func TestSumLength(t *testing.T) {
+       h, _ := New(&Config{Size: 19})
+       sum := h.Sum(nil)
+       if len(sum) != 19 {
+               t.Fatalf("Sum() returned a slice larger than the given hash size")
+       }
+}
+
+func TestKeyedSum(t *testing.T) {
+       buf := make([]byte, len(goldenKeyed))
+       for i := range buf {
+               buf[i] = byte(i)
+       }
+       h := NewMAC(64, buf[:64])
+       for i, v := range goldenKeyed {
+               h.Reset()
+               h.Write(buf[:i])
+               sum := h.Sum(nil)
+               if fmt.Sprintf("%x", sum) != v {
+                       t.Errorf("%d:\nexpected %s\ngot      %x", i, v, sum)
+               }
+
+       }
+}
+
+// Test vectors taken from reference implementation in C#.
+var golden = []string{
+       "786a02f742015903c6c6fd852552d272912f4740e15847618a86e217f71f5419d25e1031afee585313896444934eb04b903a685b1448b755d56f701afe9be2ce",
+       "2fa3f686df876995167e7c2e5d74c4c7b6e48f8068fe0e44208344d480f7904c36963e44115fe3eb2a3ac8694c28bcb4f5a0f3276f2e79487d8219057a506e4b",
+       "1c08798dc641aba9dee435e22519a4729a09b2bfe0ff00ef2dcd8ed6f8a07d15eaf4aee52bbf18ab5608a6190f70b90486c8a7d4873710b1115d3debbb4327b5",
+       "40a374727302d9a4769c17b5f409ff32f58aa24ff122d7603e4fda1509e919d4107a52c57570a6d94e50967aea573b11f86f473f537565c66f7039830a85d186",
+       "77ddf4b14425eb3d053c1e84e3469d92c4cd910ed20f92035e0c99d8a7a86cecaf69f9663c20a7aa230bc82f60d22fb4a00b09d3eb8fc65ef547fe63c8d3ddce",
+       "cbaa0ba7d482b1f301109ae41051991a3289bc1198005af226c5e4f103b66579f461361044c8ba3439ff12c515fb29c52161b7eb9c2837b76a5dc33f7cb2e2e8",
+       "f95d45cf69af5c2023bdb505821e62e85d7caedf7beda12c0248775b0c88205eeb35af3a90816f6608ce7dd44ec28db1140614e1ddebf3aa9cd1843e0fad2c36",
+       "8f945ba700f2530e5c2a7df7d5dce0f83f9efc78c073fe71ae1f88204a4fd1cf70a073f5d1f942ed623aa16e90a871246c90c45b621b3401a5ddbd9df6264165",
+       "e998e0dc03ec30eb99bb6bfaaf6618acc620320d7220b3af2b23d112d8e9cb1262f3c0d60d183b1ee7f096d12dae42c958418600214d04f5ed6f5e718be35566",
+       "6a9a090c61b3410aede7ec9138146ceb2c69662f460c3da53c6515c1eb31f41ca3d280e567882f95cf664a94147d78f42cfc714a40d22ef19470e053493508a2",
+       "29102511d749db3cc9b4e335fa1f5e8faca8421d558f6a3f3321d50d044a248ba595cfc3efd3d2adc97334da732413f5cbf4751c362ba1d53862ac1e8dabeee8",
+       "c97a4779d47e6f77729b5917d0138abb35980ab641bd73a8859eb1ac98c05362ed7d608f2e9587d6ba9e271d343125d40d933a8ed04ec1fe75ec407c7a53c34e",
+       "10f0dc91b9f845fb95fad6860e6ce1adfa002c7fc327116d44d047cd7d5870d772bb12b5fac00e02b08ac2a0174d0446c36ab35f14ca31894cd61c78c849b48a",
+       "dea9101cac62b8f6a3c650f90eea5bfae2653a4eafd63a6d1f0f132db9e4f2b1b662432ec85b17bcac41e775637881f6aab38dd66dcbd080f0990a7a6e9854fe",
+       "441ffaa08cd79dff4afc9b9e5b5620eec086730c25f661b1d6fbfbd1cec3148dd72258c65641f2fca5eb155fadbcabb13c6e21dc11faf72c2a281b7d56145f19",
+       "444b240fe3ed86d0e2ef4ce7d851edde22155582aa0914797b726cd058b6f45932e0e129516876527b1dd88fc66d7119f4ab3bed93a61a0e2d2d2aeac336d958",
+       "bfbabbef45554ccfa0dc83752a19cc35d5920956b301d558d772282bc867009168e9e98606bb5ba73a385de5749228c925a85019b71f72fe29b3cd37ca52efe6",
+       "9c4d0c3e1cdbbf485bec86f41cec7c98373f0e09f392849aaa229ebfbf397b22085529cb7ef39f9c7c2222a514182b1effaa178cc3687b1b2b6cbcb6fdeb96f8",
+       "477176b3bfcbadd7657c23c24625e4d0d674d1868f006006398af97aa41877c8e70d3d14c3bbc9bbcdcea801bd0e1599af1f3eec67405170f4e26c964a57a8b7",
+       "a78c490eda3173bb3f10dee52f110fb1c08e0302230b85ddd7c11257d92de148785ef00c039c0bb8eb9808a35b2d8c080f572859714c9d4069c5bcaf090e898e",
+       "58d023397beb5b4145cb2255b07d74290b36d9fd1e594afbd8eea47c205b2efbfe6f46190faf95af504ab072e36f6c85d767a321bfd7f22687a4abbf494a689c",
+       "4001ec74d5a46fd29c2c3cdbe5d1b9f20e51a941be98d2a4e1e2fbf866a672121db6f81a514cfd10e7358d571bdba48e4ce708b9d124894bc0b5ed554935f73a",
+       "ccd1b22dab6511225d2401ea2d8625d206a12473cc732b615e5640cefff0a4adf971b0e827a619e0a80f5db9ccd0962329010d07e34a2064e731c520817b2183",
+       "b4a0a9e3574edb9e1e72aa31e39cc5f30dbf943f8cabc408449654a39131e66d718a18819143e3ea96b4a1895988a1c0056cf2b6e04f9ac19d657383c2910c44",
+       "447becab16630608d39f4f058b16f7af95b85a76aa0fa7cea2b80755fb76e9c804f2ca78f02643c915fbf2fce5e19de86000de03b18861815a83126071f8a37b",
+       "54e6dab9977380a5665822db93374eda528d9beb626f9b94027071cb26675e112b4a7fec941ee60a81e4d2ea3ff7bc52cfc45dfbfe735a1c646b2cf6d6a49b62",
+       "3ea62625949e3646704d7e3c906f82f6c028f540f5f72a794b0c57bf97b7649bfeb90b01d3ca3e829de21b3826e6f87014d3c77350cb5a15ff5d468a81bec160",
+       "213cfe145c54a33691569980e5938c8883a46d84d149c8ff1a67cd287b4d49c6da69d3a035443db085983d0efe63706bd5b6f15a7da459e8d50a19093db55e80",
+       "5716c4a38f38db104e494a0a27cbe89a26a6bb6f499ec01c8c01aa7cb88497e75148cd6eee12a7168b6f78ab74e4be749251a1a74c38c86d6129177e2889e0b6",
+       "030460a98bdf9ff17cd96404f28fc304f2b7c04eaade53677fd28f788ca22186b8bc80dd21d17f8549c711aff0e514e19d4e15f5990252a03e082f28dc2052f6",
+       "19e7f1ccee88a10672333e390cf22013a8c734c6cb9eab41f17c3c8032a2e4aca0569ea36f0860c7a1af28fa476840d66011168859334a9e4ef9cc2e61a0e29e",
+       "29f8b8c78c80f2fcb4bdf7825ed90a70d625ff785d262677e250c04f3720c888d03f8045e4edf3f5285bd39d928a10a7d0a5df00b8484ac2868142a1e8bea351",
+       "5c52920a7263e39d57920ca0cb752ac6d79a04fef8a7a216a1ecb7115ce06d89fd7d735bd6f4272555dba22c2d1c96e6352322c62c5630fde0f4777a76c3de2c",
+       "83b098f262251bf660064a9d3511ce7687a09e6dfbb878299c30e93dfb43a9314db9a600337db26ebeedaf2256a96dabe9b29e7573ad11c3523d874dde5be7ed",
+       "9447d98aa5c9331352f43d3e56d0a9a9f9581865998e2885cc56dd0a0bd5a7b50595bd10f7529bcd31f37dc16a1465d594079667da2a3fcb70401498837cedeb",
+       "867732f2feeb23893097561ac710a4bff453be9cfbedba8ba324f9d312a82d732e1b83b829fdcd177b882ca0c1bf544b223be529924a246a63cf059bfdc50a1b",
+       "f15ab26d4cdfcf56e196bb6ba170a8fccc414de9285afd98a3d3cf2fb88fcbc0f19832ac433a5b2cc2392a4ce34332987d8d2c2bef6c3466138db0c6e42fa47b",
+       "2813516d68ed4a08b39d648aa6aacd81e9d655ecd5f0c13556c60fdf0d333ea38464b36c02baccd746e9575e96c63014f074ae34a0a25b320f0fbedd6acf7665",
+       "d3259afca8a48962fa892e145acf547f26923ae8d4924c8a531581526b04b44c7af83c643ef5a0bc282d36f3fb04c84e28b351f40c74b69dc7840bc717b6f15f",
+       "f14b061ae359fa31b989e30332bfe8de8cc8cdb568e14be214a2223b84caab7419549ecfcc96ce2acec119485d87d157d3a8734fc426597d64f36570ceaf224d",
+       "55e70b01d1fbf8b23b57fb62e26c2ce54f13f8fa2464e6eb98d16a6117026d8b90819012496d4071ebe2e59557ece3519a7aa45802f9615374877332b73490b3",
+       "25261eb296971d6e4a71b2928e64839c67d422872bf9f3c31993615222de9f8f0b2c4be8548559b4b354e736416e3218d4e8a1e219a4a6d43e1a9a521d0e75fc",
+       "08307f347c41294e34bb54cb42b1522d22f824f7b6e5db50fda096798e181a8f026fa27b4ae45d52a62caf9d5198e24a4913c6671775b2d723c1239bfbf016d7",
+       "1e5c62e7e9bfa1b118747a2de08b3ca10112af96a46e4b22c3fc06f9bfee4eb5c49e057a4a4886234324572576bb9b5ecfde0d99b0de4f98ec16e4d1b85fa947",
+       "c74a77395fb8bc126447454838e561e962853dc7eb49a1e3cb67c3d0851f3e39517be8c350ac910903d49cd2bfdf545c99316d0346170b739f0add5d533c2cfc",
+       "0dd57b423cc01eb2861391eb886a0d17079b933fc76eb3fc08a19f8a74952cb68f6bcdc644f77370966e4d13e80560bcf082ef0479d48fbbab4df03b53a4e178",
+       "4d8dc3923edccdfce70072398b8a3da5c31fcb3ee3b645c85f717cbaeb4b673a19394425a585bfb464d92f1597d0b754d163f97ced343b25db5a70ef48ebb34f",
+       "f0a50553e4dfb0c4e3e3d3ba82034857e3b1e50918f5b8a7d698e10d242b0fb544af6c92d0c3aaf9932220416117b4e78ecb8a8f430e13b82a5915290a5819c5",
+       "b15543f3f736086627cc5365e7e8988c2ef155c0fd4f428961b00d1526f04d6d6a658b4b8ed32c5d8621e7f4f8e8a933d9ecc9dd1b8333cbe28cfc37d9719e1c",
+       "7b4fa158e415fef023247264cbbe15d16d91a44424a8db707eb1e2033c30e9e1e7c8c0864595d2cb8c580eb47e9d16abbd7e44e824f7cedb7def57130e52cfe9",
+       "60424ff23234c34dc9687ad502869372cc31a59380186bc2361c835d972f49666eb1ac69629de646f03f9b4db9e2ace093fbfdf8f20ab5f98541978be8ef549f",
+       "7406018ce704d84f5eb9c79fea97da345699468a350ee0b2d0f3a4bf2070304ea862d72a51c57d3064947286f531e0eaf7563702262e6c724abf5ed8c8398d17",
+       "14ef5c6d647b3bd1e6e32006c231199810de5c4dc88e70240273b0ea18e651a3eb4f5ca3114b8a56716969c7cda27e0c8db832ad5e89a2dc6cb0adbe7d93abd1",
+       "38cf6c24e3e08bcf1f6cf3d1b1f65b905239a3118033249e448113ec632ea6dc346feeb2571c38bd9a7398b2221280328002b23e1a45adaffe66d93f6564eaa2",
+       "6cd7208a4bc7e7e56201bbba02a0f489cd384abe40afd4222f158b3d986ee72a54c50fb64fd4ed2530eda2c8af2928a0da6d4f830ae1c9db469dfd970f12a56f",
+       "659858f0b5c9edab5b94fd732f6e6b17c51cc096104f09beb3afc3aa467c2ecf885c4c6541effa9023d3b5738ae5a14d867e15db06fe1f9d1127b77e1aabb516",
+       "26cca0126f5d1a813c62e5c71001c046f9c92095704550be5873a495a999ad010a4f79491f24f286500adce1a137bc2084e4949f5b7294cefe51ecaff8e95cba",
+       "4147c1f55172788c5567c561feef876f621fff1ce87786b8467637e70dfbcd0dbdb6415cb600954ab9c04c0e457e625b407222c0fe1ae21b2143688ada94dc58",
+       "5b1bf154c62a8af6e93d35f18f7f90abb16a6ef0e8d1aecd118bf70167bab2af08935c6fdc0663ce74482d17a8e54b546d1c296631c65f3b522a515839d43d71",
+       "9f600419a4e8f4fb834c24b0f7fc13bf4e279d98e8a3c765ee934917403e3a66097182ea21453cb63ebbe8b73a9c2167596446438c57627f330badd4f569f7d6",
+       "457ef6466a8924fd8011a34471a5a1ac8ccd9bd0d07a97414ac943021ce4b9e4b9c8db0a28f016ed43b1542481990022147b313e194671131e708dd43a3ed7dc",
+       "9997b2194d9af6dfcb9143f41c0ed83d3a3f4388361103d38c2a49b280a581212715fd908d41c651f5c715ca38c0ce2830a37e00e508ced1bcdc320e5e4d1e2e",
+       "5c6bbf16baa180f986bd40a1287ed4c549770e7284858fc47bc21ab95ebbf3374b4ee3fd9f2af60f3395221b2acc76f2d34c132954049f8a3a996f1e32ec84e5",
+       "d10bf9a15b1c9fc8d41f89bb140bf0be08d2f3666176d13baac4d381358ad074c9d4748c300520eb026daeaea7c5b158892fde4e8ec17dc998dcd507df26eb63",
+       "2fc6e69fa26a89a5ed269092cb9b2a449a4409a7a44011eecad13d7c4b0456602d402fa5844f1a7a758136ce3d5d8d0e8b86921ffff4f692dd95bdc8e5ff0052",
+       "fcbe8be7dcb49a32dbdf239459e26308b84dff1ea480df8d104eeff34b46fae98627b450c2267d48c0946a697c5b59531452ac0484f1c84e3a33d0c339bb2e28",
+       "a19093a6e3bcf5952f850f2030f69b9606f147f90b8baee3362da71d9f35b44ef9d8f0a7712ba1877fddcd2d8ea8f1e5a773d0b745d4725605983a2de901f803",
+       "3c2006423f73e268fa59d2920377eb29a4f9a8b462be15983ee3b85ae8a78e992633581a9099893b63db30241c34f643027dc878279af5850d7e2d4a2653073a",
+       "d0f2f2e3787653f77cce2fa24835785bbd0c433fc779465a115149905a9dd1cb827a628506d457fcf124a0c2aef9ce2d2a0a0f63545570d8667ff9e2eba07334",
+       "78a9fc048e25c6dcb5de45667de8ffdd3a93711141d594e9fa62a959475da6075ea8f0916e84e45ad911b75467077ee52d2c9aebf4d58f20ce4a3a00458b05d4",
+       "45813f441769ab6ed37d349ff6e72267d76ae6bb3e3c612ec05c6e02a12af5a37c918b52bf74267c3f6a3f183a8064ff84c07b193d08066789a01accdb6f9340",
+       "956da1c68d83a7b881e01b9a966c3c0bf27f68606a8b71d457bd016d4c41dd8a380c709a296cb4c6544792920fd788835771a07d4a16fb52ed48050331dc4c8b",
+       "df186c2dc09caa48e14e942f75de5ac1b7a21e4f9f072a5b371e09e07345b0740c76177b01278808fec025eded9822c122afd1c63e6f0ce2e32631041063145c",
+       "87475640966a9fdcd6d3a3b5a2cca5c08f0d882b10243c0ec1bf3c6b1c37f2cd3212f19a057864477d5eaf8faed73f2937c768a0af415e84bbce6bd7de23b660",
+       "c3b573bbe10949a0fbd4ff884c446f2229b76902f9dfdbb8a0353da5c83ca14e8151bbaac82fd1576a009adc6f1935cf26edd4f1fb8da483e6c5cd9d8923adc3",
+       "b09d8d0bba8a7286e43568f7907550e42036d674e3c8fc34d8ca46f771d6466b70fb605875f6a863c877d12f07063fdc2e90ccd459b1910dcd52d8f10b2b0a15",
+       "af3a22bf75b21abfb0acd54422ba1b7300a952eff02ebeb65b5c234471a98df32f4f9643ce1904108a168767924280bd76c83f8c82d9a79d9259b195362a2a04",
+       "bf4ff2221b7e6957a724cd964aa3d5d0d9941f540413752f4699d8101b3e537508bf09f8508b317736ffd265f2847aa7d84bd2d97569c49d632aed9945e5fa5e",
+       "9c6b6b78199b1bdacb4300e31479fa622a6b5bc80d4678a6078f88a8268cd7206a2799e8d4621a464ef6b43dd8adffe97caf221b22b6b8778b149a822aefbb09",
+       "890656f09c99d280b5ecb381f56427b813751bc652c7828078b23a4af83b4e3a61fdbac61f89bee84ea6bee760c047f25c6b0a201c69a38fd6fd971af18588bb",
+       "31a046f7882ffe6f83ce472e9a0701832ec7b3f76fbcfd1df60fe3ea48fde1651254247c3fd95e100f9172731e17fd5297c11f4bb328363ca361624a81af797c",
+       "27a60b2d00e7a671d47d0aec2a686a0ac04b52f40ab6629028eb7d13f4baa99ac0fe46ee6c814944f2f4b4d20e9378e4847ea44c13178091e277b87ea7a55711",
+       "8b5ccef194162c1f19d68f91e0b0928f289ec5283720840c2f73d253111238dcfe94af2b59c2c1ca2591901a7bc060e7459b6c47df0f71701a35cc0aa831b5b6",
+       "57ab6c4b2229aeb3b70476d803cd63812f107ce6da17fed9b17875e8f86c724f49e024cbf3a1b8b119c50357652b81879d2ade2d588b9e4f7cedba0e4644c9ee",
+       "0190a8dac320a739f322e15731aa140ddaf5bed294d5c82e54fef29f214e18aafaa84f8be99af62950266b8f901f15dd4c5d35516fc35b4cab2e96e4695bbe1c",
+       "d14d7c4c415eeb0e10b159224bea127ebd84f9591c702a330f5bb7bb7aa44ea39de6ed01f18da7adf40cfb97c5d152c27528824b21e239526af8f36b214e0cfb",
+       "be28c4be706970488fac7d29c3bd5c4e986085c4c3332f1f3fd30973db614164ba2f31a78875ffdc150325c88327a9443ed04fdfe5be93876d1628560c764a80",
+       "031da1069e3a2e9c3382e436ffd79df74b1ca6a8adb2deabe676ab45994cbc054f037d2f0eace858d32c14e2d1c8b46077308e3bdc2c1b53172ecf7a8c14e349",
+       "4665cef8ba4db4d0acb118f2987f0bb09f8f86aa445aa3d5fc9a8b346864787489e8fcecc125d17e9b56e12988eac5ecc7286883db0661b8ff05da2afff30fe4",
+       "63b7032e5f930cc9939517f9e986816cfbec2be59b9568b13f2ead05bae7777cab620c6659404f7409e4199a3be5f7865aa7cbdf8c4253f7e8219b1bd5f46fea",
+       "9f09bf093a2b0ff8c2634b49e37f1b2135b447aa9144c9787dbfd92129316c99e88aab8a21fdef2372d1189aec500f95775f1f92bfb45545e4259fb9b7b02d14",
+       "f9f8493c68088807df7f6a2693d64ea59f03e9e05a223e68524ca32195a4734b654fcea4d2734c866cf95c889fb10c49159be2f5043dc98bb55e02ef7bdcb082",
+       "3c9a7359ab4febce07b20ac447b06a240b7fe1dae5439c49b60b5819f7812e4c172406c1aac316713cf0dded1038077258e2eff5b33913d9d95caeb4e6c6b970",
+       "ad6aab8084510e822cfce8625d62cf4de655f4763884c71e80bab9ac9d5318dba4a6033ed29084e65216c031606ca17615dcfe3ba11d26851ae0999ca6e232cf",
+       "156e9e6261374c9dc884f36e70f0fe1ab9297997b836fa7d170a9c9ebf575b881e7bcea44d6c0248d35597907154828955be19135852f9228815eca024a8adfb",
+       "4215407633f4cca9b6788be93e6aa3d963c7d6ce4b147247099f46a3acb500a30038cb3e788c3d29f132ad844e80e9e99251f6db96acd8a091cfc770af53847b",
+       "1c077e279de6548523502b6df800ffdab5e2c3e9442eb838f58c295f3b147cef9d701c41c321283f00c71affa0619310399126295b78dd4d1a74572ef9ed5135",
+       "f07a555f49fe481cf4cd0a87b71b82e4a95064d06677fdd90a0eb598877ba1c83d4677b393c3a3b6661c421f5b12cb99d20376ba7275c2f3a8f5a9b7821720da",
+       "b5911b380d20c7b04323e4026b38e200f534259233b581e02c1e3e2d8438d6c66d5a4eb201d5a8b75072c4ec29106334da70bc79521b0ced2cfd533f5ff84f95",
+       "01f070a09bae911296361f91aa0e8e0d09a7725478536d9d48c5fe1e5e7c3c5b9b9d6eb07796f6da57ae562a7d70e882e37adfde83f0c433c2cd363536bb22c8",
+       "6f793eb4374a48b0775acaf9adcf8e45e54270c9475f004ad8d5973e2aca52747ff4ed04ae967275b9f9eb0e1ff75fb4f794fa8be9add7a41304868d103fab10",
+       "965f20f139765fcc4ce4ba3794675863cac24db472cd2b799d035bce3dbea502da7b524865f6b811d8c5828d3a889646fe64a380da1aa7c7044e9f245dced128",
+       "ec295b5783601244c30e4641e3b45be222c4dce77a58700f53bc8ec52a941690b4d0b087fb6fcb3f39832b9de8f75ec20bd43079811749cdc907edb94157d180",
+       "61c72f8ccc91dbb54ca6750bc489672de09faedb8fdd4f94ff2320909a303f5d5a98481c0bc1a625419fb4debfbf7f8a53bb07ec3d985e8ea11e72d559940780",
+       "afd8145b259eefc8d12620c3c5b03e1ed8fd2ccefe0365078c80fd42c1770e28b44948f27e65a1886690110db814397b68e43d80d1ba16dfa358e739c898cfa3",
+       "552fc7893cf1ce933ada35c0da98844e41545e244c3157a1428d7b4c21f9cd7e4071aed77b7ca9f1c38fba32237412ef21a342742ec8324378f21e507fafdd88",
+       "467a33fbadf5ebc52596ef86aaaefc6faba8ee651b1ce04de368a03a5a9040ef2835e00adb09abb3fbd2bce818a2413d0b0253b5bda4fc5b2f6f85f3fd5b55f2",
+       "22eff8e6dd5236f5f57d94ede874d6c9428e8f5d566f17cd6d1848cd752fe13c655cb10fbaaff76872f2bf2da99e15dc624075e1ec2f58a3f64072121838569e",
+       "9cec6bbf62c4bce4138abae1cbec8dad31950444e90321b1347196834c114b864af3f3cc3508f83751ffb4eda7c84d140734bb4263c3625c00f04f4c8068981b",
+       "a8b60fa4fc2442f6f1514ad7402626920cc7c2c9f72124b8cba8ee2cb7c4586f658a4410cffcc0ab88343955e094c6af0d20d0c714fb0a988f543f300f58d389",
+       "8271cc45dfa5e4170e847e8630b952cf9c2aa777d06f26a7585b8381f188dacc7337391cfcc94b053dc4ec29cc17f077870428f1ac23fddda165ef5a3f155f39",
+       "bf23c0c25c8060e4f6995f1623a3bebecaa96e308680000a8aa3cd56bb1a6da099e10d9231b37f4519b2efd2c24de72f31a5f19535241b4a59fa3c03ceb790e7",
+       "877fd652c05281009c0a5250e7a3a671f8b18c108817fe4a874de22da8e45db11958a600c5f62e67d36cbf84474cf244a9c2b03a9fb9dc711cd1a2cab6f3fae0",
+       "29df4d87ea444baf5bcdf5f4e41579e28a67de84149f06c03f110ea84f572a9f676addd04c4878f49c5c00accda441b1a387caceb2e993bb7a10cd8c2d6717e1",
+       "710dacb166844639cd7b637c274209424e2449dc35d790bbfa4f76177054a36b3b76fac0ca6e61df1e687000678ac0746df75d0a3954897681fd393a155a1bb4",
+       "c1d5f93b8dea1f2571babccbc01764541a0cda87e444d673c50966ca559c33354b3acb26e5d5781ffb28847a4b4754d77008c62a835835f500dea7c3b58bdae2",
+       "a41e41271cdab8af4d72b104bfb2ad041ac4df14677da671d85640c4b187f50c2b66513c4619fbd5d5dc4fe65dd37b9042e9848dda556a504caa2b1c6afe4730",
+       "e7bcbacdc379c43d81ebadcb37781552fc1d753e8cf310d968392d06c91f1d64cc9e90ce1d22c32d277fc6cda433a4d442c762e9eacf2c259f32d64cf9da3a22",
+       "51755b4ac5456b13218a19c5b9242f57c4a981e4d4ecdce09a3193362b808a579345d4881c2607a56534dd7f21956aff72c2f4173a6e7b6cc2212ba0e3daee1f",
+       "dcc2c4beb9c1f2607b786c20c631972347034c1cc02fcc7d02ff01099cfe1c6989840ac213923629113aa8bad713ccf0fe4ce13264fb32b8b0fe372da382544a",
+       "3d55176acea4a7e3a65ffa9fb10a7a1767199cf077cee9f71532d67cd7c73c9f93cfc37ccdcc1fdef50aad46a504a650d298d597a3a9fa95c6c40cb71fa5e725",
+       "d07713c005de96dd21d2eb8bbeca66746ea51a31ae922a3e74864889540a48db27d7e4c90311638b224bf0201b501891754848113c266108d0adb13db71909c7",
+       "58983c21433d950caa23e4bc18543b8e601c204318532152daf5e159a0cd1480183d29285c05f129cb0cc3164687928086ffe380158df1d394c6ac0d4288bca8",
+       "8100a8dc528d2b682ab4250801ba33f02a3e94c54dac0ae1482aa21f51ef3a82f3807e6facb0aeb05947bf7aa2adcb034356f90fa4560ede02201a37e411ec1a",
+       "07025f1bb6c784f3fe49de5c14b936a5acacacaab33f6ac4d0e00ab6a12483d6bec00b4fe67c7ca5cc508c2a53efb5bfa5398769d843ff0d9e8b14d36a01a77f",
+       "ba6aefd972b6186e027a76273a4a723321a3f580cfa894da5a9ce8e721c828552c64dacee3a7fd2d743b5c35ad0c8efa71f8ce99bf96334710e2c2346e8f3c52",
+       "e0721e02517aedfa4e7e9ba503e025fd46e714566dc889a84cbfe56a55dfbe2fc4938ac4120588335deac8ef3fa229adc9647f54ad2e3472234f9b34efc46543",
+       "b6292669ccd38d5f01caae96ba272c76a879a45743afa0725d83b9ebb26665b731f1848c52f11972b6644f554c064fa90780dbbbf3a89d4fc31f67df3e5857ef",
+       "2319e3789c47e2daa5fe807f61bec2a1a6537fa03f19ff32e87eecbfd64b7e0e8ccff439ac333b040f19b0c4ddd11a61e24ac1fe0f10a039806c5dcc0da3d115",
+       "f59711d44a031d5f97a9413c065d1e614c417ede998590325f49bad2fd444d3e4418be19aec4e11449ac1a57207898bc57d76a1bcf3566292c20c683a5c4648f",
+       "df0a9d0c212843a6a934e3902b2dd30d17fba5f969d2030b12a546d8a6a45e80cf5635f071f0452e9c919275da99bed51eb1173c1af0518726b75b0ec3bae2b5",
+       "a3eb6e6c7bf2fb8b28bfe8b15e15bb500f781ecc86f778c3a4e655fc5869bf2846a245d4e33b7b14436a17e63be79b36655c226a50ffbc7124207b0202342db5",
+       "56d4cbcd070563426a017069425c2cd2ae540668287a5fb9dac432eb8ab1a353a30f2fe1f40d83333afe696a267795408a92fe7da07a0c1814cf77f36e105ee8",
+       "e59b9987d428b3eda37d80abdb16cd2b0aef674c2b1dda4432ea91ee6c935c684b48b4428a8cc740e579a30deff35a803013820dd23f14ae1d8413b5c8672aec",
+       "cd9fcc99f99d4cc16d031900b2a736e1508db4b586814e6345857f354a70ccecb1df3b50a19adaf43c278efa423ff4bb6c523ec7fd7859b97b168a7ebff8467c",
+       "0602185d8c3a78738b99164b8bc6ffb21c7debebbf806372e0da44d121545597b9c662a255dc31542cf995ecbe6a50fb5e6e0ee4ef240fe557eded1188087e86",
+       "c08afa5b927bf08097afc5fff9ca4e7800125c1f52f2af3553fa2b89e1e3015c4f87d5e0a48956ad31450b083dad147ffb5ec03434a26830cf37d103ab50c5da",
+       "36f1e1c11d6ef6bc3b536d505d544a871522c5c2a253067ec9933b6ec25464daf985525f5b9560a16d890259ac1bb5cc67c0c469cde133def000ea1d686f4f5d",
+       "bf2ab2e2470f5438c3b689e66e7686fffa0cb1e1798ad3a86ff99075bf6138e33d9c0ce59afb24ac67a02af34428191a9a0a6041c07471b7c3b1a752d6fc0b8b",
+       "d400601f9728ccc4c92342d9787d8d28ab323af375ca5624b4bb91d17271fbae862e413be73f1f68e615b8c5c391be0dbd9144746eb339ad541547ba9c468a17",
+       "79fe2fe157eb85a038abb8ebbc647731d2c83f51b0ac6ee14aa284cb6a3549a4dcceb300740a825f52f5fb30b03b8c4d8b0f4aa67a63f4a94e3303c4eda4c02b",
+       "75351313b52a8529298d8c186b1768666dcca8595317d7a4816eb88c062020c0c8efc554bb341b64688db5ccafc35f3c3cd09d6564b36d7b04a248e146980d4b",
+       "e3128b1d311d02179d7f25f97a5a8bee2cc8c86303644fcd664e157d1fef00f23e46f9a5e8e5c890ce565bb6abd4302ce06469d52a5bd53e1c5a54d04649dc03",
+       "c2382a72d2d3ace9d5933d00b60827ed380cda08d0ba5f6dd41e29ee6dbe8ecb9235f06be95d83b6816a2fb7a5ad47035e8a4b69a4884b99e4bece58cab25d44",
+       "6b1c69460bbd50ac2ed6f32e6e887cfed407d47dcf0aaa60387fe320d780bd03eab6d7baeb2a07d10cd552a300341354ea9a5f03183a623f92a2d4d9f00926af",
+       "6cda206c80cdc9c44ba990e0328c314f819b142d00630404c48c05dc76d1b00ce4d72fc6a48e1469ddef609412c364820854214b4869af090f00d3c1ba443e1b",
+       "7ffc8c26fbd6a0f7a609e6e1939f6a9edf1b0b066641fb76c4f9602ed748d11602496b35355b1aa255850a509d2f8ee18c8f3e1d7dcbc37a136598f56a59ed17",
+       "70de1f08dd4e09d5fc151f17fc991a23abfc05104290d50468882efaf582b6ec2f14f577c0d68c3ad06626916e3c86e6daab6c53e5163e82b6bd0ce49fc0d8df",
+       "4f81935756ed35ee2058ee0c6a6110d6fac5cb6a4f46aa9411603f99965823b6da4838276c5c06bc7880e376d92758369ee7305bcec8d3cfd28ccabb7b4f0579",
+       "abcb61cb3683d18f27ad527908ed2d32a0426cb7bb4bf18061903a7dc42e7e76f982382304d18af8c80d91dd58dd47af76f8e2c36e28af2476b4bccf82e89fdf",
+       "02d261ad56a526331b643dd2186de9a82e72a58223cd1e723686c53d869b83b94632b7b647ab2afc0d522e29da3a5615b741d82852e0df41b66007dbcba90543",
+       "c5832741fa30c5436823015383d297ff4c4a5d7276c3f902122066e04be5431b1a85faf73b918434f9300963d1dea9e8ac3924ef490226edeea5f743e410669f",
+       "cfaeab268cd075a5a6aed515023a032d54f2f2ff733ce0cbc78db51db4504d675923f82746d6594606ad5d67734b11a67cc6a468c2032e43ca1a94c6273a985e",
+       "860850f92eb268272b67d133609bd64e34f61bf03f4c1738645c17fec818465d7ecd2be2907641130025fda79470ab731646e7f69440e8367ea76ac4cee8a1df",
+       "84b154ed29bbedefa648286839046f4b5aa34430e2d67f7496e4c39f2c7ea78995f69e1292200016f16ac3b37700e6c7e7861afc396b64a59a1dbf47a55c4bbc",
+       "aeeec260a5d8eff5ccab8b95da435a63ed7a21ea7fc7559413fd617e33609f8c290e64bbacc528f6c080262288b0f0a3219be223c991bee92e72349593e67638",
+       "8ad78a9f26601d127e8d2f2f976e63d19a054a17dcf59e0f013ab54a6887bbdffde7aaae117e0fbf3271016595b9d9c712c01b2c53e9655a382bc4522e616645",
+       "8934159dade1ac74147dfa282c75954fcef443ef25f80dfe9fb6ea633b8545111d08b34ef43fff17026c7964f5deac6d2b3c29dacf2747f022df5967dfdc1a0a",
+       "cd36dd0b240614cf2fa2b9e959679dcdd72ec0cd58a43da3790a92f6cdeb9e1e795e478a0a47d371100d340c5cedcdbbc9e68b3f460818e5bdff7b4cda4c2744",
+       "00df4e099b807137a85990f49d3a94315e5a5f7f7a6076b303e96b056fb93800111f479628e2f8db59aeb6ac70c3b61f51f9b46e80ffdeae25ebddb4af6cb4ee",
+       "2b9c955e6caed4b7c9e246b86f9a1726e810c59d126cee66ed71bf015b83558a4b6d84d18dc3ff4620c2ffb722359fdef85ba0d4e2d22ecbe0ed784f99afe587",
+       "181df0a261a2f7d29ea5a15772715105d450a4b6c236f699f462d60ca76487feedfc9f5eb92df838e8fb5dc3694e84c5e0f4a10b761f506762be052c745a6ee8",
+       "21fb203458bf3a7e9a80439f9a902899cd5de0139dfd56f7110c9dec8437b26bda63de2f565926d85edb1d6c6825669743dd9992653d13979544d5dc8228bfaa",
+       "ef021f29c5ffb830e64b9aa9058dd660fd2fcb81c497a7e698bcfbf59de5ad4a86ff93c10a4b9d1ae5774725f9072dcde9e1f199bab91f8bff921864aa502eee",
+       "b3cfda40526b7f1d37569bdfcdf911e5a6efe6b2ec90a0454c47b2c046bf130fc3b352b34df4813d48d33ab8e269b69b075676cb6d00a8dcf9e1f967ec191b2c",
+       "b4c6c3b267071eefb9c8c72e0e2b941293641f8673cb70c1cc26ad1e73cf141755860ad19b34c2f34ed35bb52ec4507cc1fe59047743a5f0c6febde625e26091",
+       "57a34f2bcca60d4b85103b830c9d7952a416be5263ae429c9e5e53fe8590a8f78ec65a51109ea85dcdf7b6223f9f2b340539fad81923dbf8edabf95129e4dff6",
+       "9cf46662fcd61a232277b685663b8b5da832dfd9a3b8ccfeec993ec6ac415ad07e048adfe414df272770dba867da5c1224c6fd0aa0c2187d426ac647e9887361",
+       "5ce1042ab4d542c2f9ee9d17262af8164098935bef173d0e18489b04841746cd2f2df866bd7da6e5ef9024c648023ec723ab9c62fd80285739d84f15d2ab515a",
+       "8488396bd4a8729b7a473178f232dadf3f0f8e22678ba5a43e041e72da1e2cf82194c307207a54cb8156293339eaec693ff66bfcd5efc65e95e4ecaf54530abd",
+       "f598da901c3835bca560779037dfde9f0c51dc61c0b760fc1522d7b470ee63f5bdc6498476e86049ad86e4e21af2854a984cc905427d2f17f66b1f41c3da6f61",
+       "5f93269798cf02132107337660a8d7a177354c0212eb93e555e7c37a08aef3d8dce01217011cd965c04dd2c105f2e2b6cae5e4e6bcaf09dfbee3e0a6a6357c37",
+       "0ecf581d47bac9230986faabd70c2f5b80e91066f0ec55a842937882286d2ca007bb4e973b0b091d52167ff7c4009c7ab4ad38fff1dceacdb7be81ef4a452952",
+       "5aeca8abe1528582b2a307b4009585498a3d467ca6101cb0c5126f9976056e9ffc123cc20c302b2a737f492c75d21f01512c90ca0541dfa56e950a321dcb28d8",
+       "732fbf8f1cb2b8329263ede27858fe46f8d3354d376bcda0548e7ce1fa9dd11f85eb661fe950b543aa635ca4d3f04ede5b32d6b656e5ce1c44d35c4a6c56cff8",
+       "d5e938735d63788c80100aefd18648d18cf272f69f20ff24cfe2895c088ad08b0104da1672a4eb26fc52545cc7d7a01b266cf546c403c45bd129eb41bdd9200b",
+       "65a245b49352ee297d91af8c8be00528ac6e046dd83ac7bd465a98816dd68f3e00e1ae8f895327a7e9a8c9326598379a29c9fc91ec0c6eef08f3e2b216c11008",
+       "c95654b63019130ab45dd0fb4941b98aeb3af2a123913eca2ce99b3e97410a7bf8661cc7fbaa2bc1cf2b13113b1ed40a0118b88e5fffc3542759ea007ed4c58d",
+       "1eb262f38fa494431f017dad44c0dfb69324ac032f04b657fc91a88647bb74760f24e7c956514f0cf002990b182c1642b9b2426e96a61187e4e012f00e217d84",
+       "3b955aeebfa5151ac1ab8e3f5cc1e3767084c842a575d36269836e97353d41622b731dddcd5f269550a3a5b87be1e90326340b6e0e62555815d9600597ac6ef9",
+       "68289f6605473ba0e4f241baf7477a9885426a858f19ef2a18b0d40ef8e41282ed5526b519799e270f13881327918278755711071d8511fe963e3b5606aa3716",
+       "80a33787542612c38f6bcd7cd86cab460227509b1cbad5ec408a91413d51155a0476dadbf3a2518e4a6e77cc346622e347a469bf8baa5f04eb2d98705355d063",
+       "34629bc6d831391c4cdf8af1b4b7b6b8e8ee17cf98c70e5dd586cd99f14b11df945166236a9571e6d591bb83ee4d164d46f6b9d8ef86ff865a81bfb91b00424b",
+       "8b7cc339163863bb4383e542b0ef0e7cf36b84ad932cdf5a80419ec9ad692e7a7e784d2c7cb3796a18b8f800035f3aa06c824100611120a7bdeb35618ccb81b7",
+       "4f084e4939dd5a7f5a658fad58a18a15c25c32ec1c7fd5c5c6c3e892b3971aeaac308304ef17b1c47239ea4bb398b3fd6d4528d8de8e768ae0f1a5a5c6b5c297",
+       "48f407a1af5b8009b2051742e8cf5cd5656669e7d722ee8e7bd202060849442168d8facc117c012bfb7bf449d99befff6a34aea203f1d8d352722be5014ec818",
+       "a6aa82cd1e426f9a73bfa39a29037876114655b8c22d6d3ff8b638ae7dea6b17843e09e52eb66fa1e475e4a8a3de429b7d0f4a776fcb8bdc9b9fede7d52e815f",
+       "5817027d6bdd00c5dd10ac593cd560372270775a18526d7e6f13872a2e20eab664625be7168ac4bd7c9e0ce7fc4099e0f48442e2c767191c6e1284e9b2ccea8c",
+       "08e41028340a45c74e4052b3a8d6389e22e043a1adab5e28d97619450d723469b620caa519b81c14523854f619fd3027e3847bd03276e60604a80ddb4de876d6",
+       "130b8420537eb07d72abda07c85acbd8b9a44f16321dd0422145f809673d30f2b5321326e2bff317ef3fef983c51c4f8ab24a325d298e34afce569a82555774c",
+       "ac49b844afaa012e31c474ca263648844fd2f6307992c2f752aca02c3828965175794deee2d2ee95c61cd284f6b5a2d75e2ef2b29ee8149e77fb81447b2fd04b",
+       "b9d7ca81cc60bb9578e44024e5a0a0be80f27336a6a9f4e53df3999cb191280b090e2ac2d29c5baad9d71415bdc129e69aa2667af6a7fd5e189fccdcee817340",
+       "a755e113386572c75ced61d719706070b9146048e42a9f8cd35667a088b42f08808abdf77e618abd959afc757379ca2c00bcc1a48390fa2bff618b1e0078a613",
+       "a73c7debed326f1c0db0795ee7d6e3946894b826b1f8101c56c823ba17168312e7f53fc7dbe52c3e11e69852c40485e2ef182477862ea6a34ec136e2dfeea6f4",
+       "6cb8f9d52c56d82cac28f39ea1593e8bb2506293ac0d68376a1709b62a46df14a4ae64b2d8fab76733a1ced2d548e3f3c6fcb49d40c3d5808e449cd83d1c2aa2",
+       "683fa2b2369a10162c1c1c7b24bc970ee67da220564f32203f625696c0352a0b9ad96624362d952d84463c1106a2dba7a092599884b35a0b89c8f1b6a9b5a61e",
+       "aad9ad44610118b77d508aeb1bbcd1c1b7d0171397fb510a401bbc0ec34623670d86a2dc3c8f3ab5a2044df730256727545f0860ce21a1eac717dfc48f5d228e",
+       "c42578de23b4c987d5e1ac4d689ed5de4b0417f9704bc6bce969fa13471585d62c2cb1212a944f397fc9ca2c3747c3beb694ec4c5be68828dda53ef43faec6c0",
+       "470f00841ee8244e63ed2c7ea30e2e419897c197462ecccecf713b42a5065fff5914bc9b79affe8f6b657875e789ae213bd914cd35bd174d46e9d18bd843773d",
+       "34fc4213730f47a5e9a3580f643e12945cfcb31bf206f6ad450ce528da3fa432e005d6b0ecce10dca7c5995f6aacc5150e1b009e19751e8309f8859531844374",
+       "fb3c1f0f56a56f8e316fdf5d853c8c872c39635d083634c3904fc3ac07d1b578e85ff0e480e92d44ade33b62e893ee32343e79ddf6ef292e89b582d312502314",
+       "c7c97fc65dd2b9e3d3d607d31598d3f84261e9919251e9c8e57bb5f829377d5f73eabbed55c6c381180f29ad02e5be797ffec7e57bdecbc50ad3d062f0993ab0",
+       "a57a49cdbe67ae7d9f797bb5cc7efc2df07f4e1b15955f85dae74b76e2ecb85afb6cd9eeed8888d5ca3ec5ab65d27a7b19e578475760a045ac3c92e13a938e77",
+       "c7143fce9614a17fd653aeb140726dc9c3dbb1de6cc581b2726897ec24b7a50359ad492243be66d9edd8c933b5b80e0b91bb61ea98056006516976fae8d99a35",
+       "65bb58d07f937e2d3c7e65385f9c54730b704105ccdb691f6e146d4ee8f6c086f49511035110a9ad6031fdceb943e0f9613bcb276dd40f0624ef0f924f809783",
+       "e540277f683b1186dd3b5b3f61433396581a35feb12002be8c6a6231fc40ffa70f08081bc58b2d94f7649543614a435faa2d62110e13dabc7b86629b63af9c24",
+       "418500878c5fbcb584c432f4285e05e49f2e3e075399a0dbfcf874ebf8c03d02bf16bc6989d161c77ca0786b05053c6c709433712319192128835cf0b660595b",
+       "889090dbb1944bdc9433ee5ef1010c7a4a24a8e71ecea8e12a31318ce49dcab0aca5c3802334aab2cc84b14c6b9321fe586bf3f876f19cd406eb1127fb944801",
+       "53b6a28910aa92e27e536fb549cf9b9918791060898e0b9fe183577ff43b5e9c7689c745b32e412269837c31b89e6cc12bf76e13cad366b74ece48bb85fd09e9",
+       "7c092080c6a80d672409d081d3d177106bcd63567785140719490950ae07ae8fcaabbaaab330cfbcf7374482c220af2eadeeb73dcbb35ed823344e144e7d4899",
+       "9ccde566d2400509181111f32dde4cd63209fe59a30c114546ad2776d889a41bad8fa1bb468cb2f9d42ca9928a7770fef8e8ba4d0c812d9a1e75c3d8d2ccd75a",
+       "6e293bf5d03fe43977cfe3f57ccdb3ae282a85455dca33f37f4b74f8398cc612433d755cbec412f8f82a3bd3bc4a278f7ecd0dfa9bbdc40be7a787c8f159b2df",
+       "c56546fb2178456f336164c18b90deffc83ae2b5a3aca77b6884d36d2c1db39501b3e65e36c758c66e3188451fdb3515ee162c001f06c3e8cb573adf30f7a101",
+       "6f82f89f299ebca2fe014b59bffe1aa84e88b1915fe256afb646fd8448af2b8891a7fab37a4ea6f9a50e6c317039d8cf878f4c8e1a0dd464f0b4d6ff1c7ea853",
+       "2b8599ff9c3d6198637ad51e57d1998b0d75313fe2dd61a533c964a6dd9607c6f723e9452ce46e014b1c1d6de77ba5b88c914d1c597bf1eae13474b4290e89b2",
+       "08bf346d38e1df06c8260edb1da75579275948d5c0a0aa9ed2886f8856de5417a156998758f5b17e52f101ca957a71137473dfd18d7d209c4c10d9233c93691d",
+       "6df2156d773114d310b63db9ee5350d77e6bcf25b05fcd910f9b31bc42bb13fe8225ebcb2a23a62280777b6bf74e2cd0917c7640b43defe468cd1e18c943c66a",
+       "7c7038bc13a91151828a5ba82b4a96040f258a4dfb1b1373f0d359168afb0517a20b28a12d3644046be66b8d08d8ae7f6a923ea1c00187c6d11dc502bac71305",
+       "bcd1b30d808fb739b987cbf154bea00da9d40380b861d4c1d6377122dadd61c0e59018b71941cfb62e00dcd70aeb9abf0473e80f0a7eca6b6dea246ab229dd2b",
+       "7ed4468d968530fe7ab2c33540b26d8c3bd3ed44b34fbe8c2a9d7f805b5ada0ea252eeade4fce97f89728ad85bc8bb2430b1bef2cddd32c8446e59b8e8ba3c67",
+       "6d30b7c6ce8a3236c0ca2f8d728b1088ca06983a8043e621d5dcf0c537d13b08791edeb01a3cf0943ec1c890ab6e29b146a236cd46bcb9d93bf516fb67c63fe5",
+       "97fe03cef31438508911bded975980a66029305dc5e3fa8ad1b4fb22fcdf5a19a733320327d8f71ccf496cb3a44a77af56e3dde73d3a5f176896cc57c9a5ad99",
+       "785a9d0fbd21136dbce8fa7eafd63c9dad220052978416b31d9753eaa149097847ed9b30a65c70507eff01879149ed5cf0471d37798edc05abd56ad4a2cccb1d",
+       "ad408d2abddfd37b3bf34794c1a3371d928ed7fc8d966225333584c5665817832a37c07f0dc7cb5aa874cd7d20fe8fab8eabcb9b33d2e0841f6e200960899d95",
+       "97668f745b6032fc815d9579322769dccd9501a5080029b8ae826befb6742331bd9f76efeb3e2b8e81a9786b282f5068a3a2424697a77c41876b7e753f4c7767",
+       "26bb985f47e7fee0cfd252d4ef96bed42b9c370c1c6a3e8c9eb04ef7f7818b833a0d1f043ebafb911dc779e02740a02a44d3a1ea45ed4ad55e686c927cafe97e",
+       "5bfe2b1dcf7fe9b95088acedb575c19016c743b2e763bf5851ac407c9eda43715edfa48b4825492c5179593fff21351b76e8b7e034e4c53c79f61f29c479bd08",
+       "c76509ef72f4a6f9c9c40618ed52b2084f83502232e0ac8bdaf3264368e4d0180f6854c4abf4f6509c79caafc44cf3194afc57bd077bd7b3c9bda3d4b8775816",
+       "d66f2beab990e354ccb910e4e9c7ac618c7b63ef292a96b552341de78dc46d3ec8cfabc699b50af41fda39cf1b0173660923510ad67faedef5207cffe8641d20",
+       "7d8f0672992b79be3a364d8e5904f4ab713bbc8ab01b4f309ad8ccf223ce1034a860dcb0b00550612cc2fa17f2969e18f22e1427d254b4a82b3a03a3eb394adf",
+       "a56d6725bfb3de47c1414adf25fc8f0fc9846f6987722bc06366d5ca4e89722925ebbc881418844075397a0ca89842c7b9e9e07e1d9d183ebeb39e120b483bf7",
+       "af5e03d7fe60c67e10313344434e79485a03a758d6dce985574745763c1c5c77d4fb3e6fb12230368370993bf90feed0c5d1607524562d7c09c0c210ed393d7c",
+       "7a20540cc07bf72b582421fc342e82f52134b69841ec28ed189e2ea6a29dd2f82a640352d222b52f2911dc72a7dab31caadd80c6118f13c56b2a1e4373be0ea3",
+       "486f02c63e5467ea1fdde7e82bfacc2c1ba5d636d9f3d08b210da3f372f706ec218cc17ff60aef703bbe0c15c38ae55d286a684f864c78211ccab4178c92adba",
+       "1c7a5c1dedcd04a921788f7eb23361ca1953b04b9c7aec35d65ea3e4996db26f281278ea4ae666ad81027d98af57262cdbfa4c085f4210568c7e15eec7805114",
+       "9ce3fa9a860bdbd5378fd6d7b8b671c6cb7692910ce8f9b6cb4122cbcbe6ac06ca0422cef1225935053b7d193a81b9e972eb85a1d3074f14cbb5ec9f0573892d",
+       "a91187be5c371c4265c174fd4653b8ab708551f83d1fee1cc1479581bc006d6fb78fcc9a5dee1db3666f508f9780a37593ebcccf5fbed39667dc6361e921f779",
+       "4625767d7b1d3d3ed2fbc674af14e0244152f2a4021fcf3311505d89bd81e2f9f9a500c3b199914db49500b3c98d03ea93286751a686a3b875daab0ccd63b44f",
+       "43dfdfe1b014fed3a2acabb7f3e9a182f2aa18019d27e3e6cdcf31a15b428e91e7b08cf5e5c376fce2d8a28ff85ab0a0a1656edb4a0a91532620096d9a5a652d",
+       "279e3202be3989ba3112772585177487e4fe3ee3eab49c2f7fa7fe87cfe7b80d3e0355edff6d031e6c96c795db1c6f041880ec3824defacf9263820a8e7327de",
+       "ea2d066ac229d4d4b616a8bedec734325224e4b4e58f1ae6dad7e40c2da29196c3b1ea9571dacc81e87328caa0211e09027b0524aa3f4a849917b3586747ebbb",
+       "49f014f5c61822c899ab5cae51be4044a4495e777deb7da9b6d8490efbb87530adf293daf079f94c33b7044ef62e2e5bb3eb11e17304f8453ee6ce24f033ddb0",
+       "9233490344e5b0dc5912671b7ae54cee7730dbe1f4c7d92a4d3e3aab50571708db51dcf9c2944591db651db32d22935b86944969be77d5b5feae6c3840a8db26",
+       "b6e75e6f4c7f453b7465d25b5ac8c7196902eaa953875228c8634e16e2ae1f38bc3275304335f5989eccc1e34167d4e68d7719968fba8e2fe67947c35c48e806",
+       "cc14ca665af1483efbc3af80080e650d5046a3932f4f51f3fe90a0705ec25104adf07839265dc51d43401411246e474f0d5e5637af94767283d53e0617e981f4",
+       "230a1c857cb2e7852e41b647e90e4585d2d881e1734dc38955356e8dd7bff39053092c6b38e236e1899525647073dddf6895d64206325e7647f275567b255909",
+       "cbb65321ac436e2ffdab2936359ce49023f7dee7614ef28d173c3d27c5d1bffa51553d433f8ee3c9e49c05a2b883cce954c9a8093b80612a0cdd4732e041f995",
+       "3e7e570074337275efb51315588034c3cf0dddca20b4612e0bd5b881e7e5476d319ce4fe9f19186e4c0826f44f131eb048e65be242b1172c63badb123ab0cbe8",
+       "d32e9ec02d38d4e1b8249df8dcb00c5b9c68eb8922672e3505393b6a210ba56f9496e5ee0490ef387c3cdec061f06bc0382d9304cafbb8e0cd33d57029e62df2",
+       "8c1512466089f05b3775c262b62d22b83854a83218130b4ec91b3ccbd293d2a54302cecaab9b100c68d1e6ddc8f07cddbdfe6fdaaaf099cc09d6b725879c6369",
+       "91a7f61c97c2911e4c812ef71d780ad8fa788794561d08303fd1c1cb608a46a12563086ec5b39d471aed94fb0f6c678a43b8792932f9028d772a22768ea23a9b",
+       "4f6bb222a395e8b18f6ba155477aed3f0729ac9e83e16d31a2a8bc655422b837c891c6199e6f0d75799e3b691525c581953517f252c4b9e3a27a28fbaf49644c",
+       "5d06c07e7a646c413a501c3f4bb2fc38127de7509b7077c4d9b5613201c1aa02fd5f79d2745915dd57fbcb4ce08695f6efc0cb3d2d330e19b4b0e6004ea6471e",
+       "b96756e57909968f14b796a5d30f4c9d671472cf82c8cfb2caca7ac7a44ca0a14c9842d00c82e337502c94d5960aca4c492ea7b0df919ddf1aada2a275bb10d4",
+       "ff0a015e98db9c99f03977710aac3e658c0d896f6d71d618ba79dc6cf72ac75b7c038eb6862dede4543e145413a6368d69f5722c827ba3ef25b6ae6440d39276",
+       "5b21c5fd8868367612474fa2e70e9cfa2201ffeee8fafab5797ad58fefa17c9b5b107da4a3db6320baaf2c8617d5a51df914ae88da3867c2d41f0cc14fa67928",
+}
+
+var goldenKeyed = []string{
+       "10ebb67700b1868efb4417987acf4690ae9d972fb7a590c2f02871799aaa4786b5e996e8f0f4eb981fc214b005f42d2ff4233499391653df7aefcbc13fc51568",
+       "961f6dd1e4dd30f63901690c512e78e4b45e4742ed197c3c5e45c549fd25f2e4187b0bc9fe30492b16b0d0bc4ef9b0f34c7003fac09a5ef1532e69430234cebd",
+       "da2cfbe2d8409a0f38026113884f84b50156371ae304c4430173d08a99d9fb1b983164a3770706d537f49e0c916d9f32b95cc37a95b99d857436f0232c88a965",
+       "33d0825dddf7ada99b0e7e307104ad07ca9cfd9692214f1561356315e784f3e5a17e364ae9dbb14cb2036df932b77f4b292761365fb328de7afdc6d8998f5fc1",
+       "beaa5a3d08f3807143cf621d95cd690514d0b49efff9c91d24b59241ec0eefa5f60196d407048bba8d2146828ebcb0488d8842fd56bb4f6df8e19c4b4daab8ac",
+       "098084b51fd13deae5f4320de94a688ee07baea2800486689a8636117b46c1f4c1f6af7f74ae7c857600456a58a3af251dc4723a64cc7c0a5ab6d9cac91c20bb",
+       "6044540d560853eb1c57df0077dd381094781cdb9073e5b1b3d3f6c7829e12066bbaca96d989a690de72ca3133a83652ba284a6d62942b271ffa2620c9e75b1f",
+       "7a8cfe9b90f75f7ecb3acc053aaed6193112b6f6a4aeeb3f65d3de541942deb9e2228152a3c4bbbe72fc3b12629528cfbb09fe630f0474339f54abf453e2ed52",
+       "380beaf6ea7cc9365e270ef0e6f3a64fb902acae51dd5512f84259ad2c91f4bc4108db73192a5bbfb0cbcf71e46c3e21aee1c5e860dc96e8eb0b7b8426e6abe9",
+       "60fe3c4535e1b59d9a61ea8500bfac41a69dffb1ceadd9aca323e9a625b64da5763bad7226da02b9c8c4f1a5de140ac5a6c1124e4f718ce0b28ea47393aa6637",
+       "4fe181f54ad63a2983feaaf77d1e7235c2beb17fa328b6d9505bda327df19fc37f02c4b6f0368ce23147313a8e5738b5fa2a95b29de1c7f8264eb77b69f585cd",
+       "f228773ce3f3a42b5f144d63237a72d99693adb8837d0e112a8a0f8ffff2c362857ac49c11ec740d1500749dac9b1f4548108bf3155794dcc9e4082849e2b85b",
+       "962452a8455cc56c8511317e3b1f3b2c37df75f588e94325fdd77070359cf63a9ae6e930936fdf8e1e08ffca440cfb72c28f06d89a2151d1c46cd5b268ef8563",
+       "43d44bfa18768c59896bf7ed1765cb2d14af8c260266039099b25a603e4ddc5039d6ef3a91847d1088d401c0c7e847781a8a590d33a3c6cb4df0fab1c2f22355",
+       "dcffa9d58c2a4ca2cdbb0c7aa4c4c1d45165190089f4e983bb1c2cab4aaeff1fa2b5ee516fecd780540240bf37e56c8bcca7fab980e1e61c9400d8a9a5b14ac6",
+       "6fbf31b45ab0c0b8dad1c0f5f4061379912dde5aa922099a030b725c73346c524291adef89d2f6fd8dfcda6d07dad811a9314536c2915ed45da34947e83de34e",
+       "a0c65bddde8adef57282b04b11e7bc8aab105b99231b750c021f4a735cb1bcfab87553bba3abb0c3e64a0b6955285185a0bd35fb8cfde557329bebb1f629ee93",
+       "f99d815550558e81eca2f96718aed10d86f3f1cfb675cce06b0eff02f617c5a42c5aa760270f2679da2677c5aeb94f1142277f21c7f79f3c4f0cce4ed8ee62b1",
+       "95391da8fc7b917a2044b3d6f5374e1ca072b41454d572c7356c05fd4bc1e0f40b8bb8b4a9f6bce9be2c4623c399b0dca0dab05cb7281b71a21b0ebcd9e55670",
+       "04b9cd3d20d221c09ac86913d3dc63041989a9a1e694f1e639a3ba7e451840f750c2fc191d56ad61f2e7936bc0ac8e094b60caeed878c18799045402d61ceaf9",
+       "ec0e0ef707e4ed6c0c66f9e089e4954b058030d2dd86398fe84059631f9ee591d9d77375355149178c0cf8f8e7c49ed2a5e4f95488a2247067c208510fadc44c",
+       "9a37cce273b79c09913677510eaf7688e89b3314d3532fd2764c39de022a2945b5710d13517af8ddc0316624e73bec1ce67df15228302036f330ab0cb4d218dd",
+       "4cf9bb8fb3d4de8b38b2f262d3c40f46dfe747e8fc0a414c193d9fcf753106ce47a18f172f12e8a2f1c26726545358e5ee28c9e2213a8787aafbc516d2343152",
+       "64e0c63af9c808fd893137129867fd91939d53f2af04be4fa268006100069b2d69daa5c5d8ed7fddcb2a70eeecdf2b105dd46a1e3b7311728f639ab489326bc9",
+       "5e9c93158d659b2def06b0c3c7565045542662d6eee8a96a89b78ade09fe8b3dcc096d4fe48815d88d8f82620156602af541955e1f6ca30dce14e254c326b88f",
+       "7775dff889458dd11aef417276853e21335eb88e4dec9cfb4e9edb49820088551a2ca60339f12066101169f0dfe84b098fddb148d9da6b3d613df263889ad64b",
+       "f0d2805afbb91f743951351a6d024f9353a23c7ce1fc2b051b3a8b968c233f46f50f806ecb1568ffaa0b60661e334b21dde04f8fa155ac740eeb42e20b60d764",
+       "86a2af316e7d7754201b942e275364ac12ea8962ab5bd8d7fb276dc5fbffc8f9a28cae4e4867df6780d9b72524160927c855da5b6078e0b554aa91e31cb9ca1d",
+       "10bdf0caa0802705e706369baf8a3f79d72c0a03a80675a7bbb00be3a45e516424d1ee88efb56f6d5777545ae6e27765c3a8f5e493fc308915638933a1dfee55",
+       "b01781092b1748459e2e4ec178696627bf4ebafebba774ecf018b79a68aeb84917bf0b84bb79d17b743151144cd66b7b33a4b9e52c76c4e112050ff5385b7f0b",
+       "c6dbc61dec6eaeac81e3d5f755203c8e220551534a0b2fd105a91889945a638550204f44093dd998c076205dffad703a0e5cd3c7f438a7e634cd59fededb539e",
+       "eba51acffb4cea31db4b8d87e9bf7dd48fe97b0253ae67aa580f9ac4a9d941f2bea518ee286818cc9f633f2a3b9fb68e594b48cdd6d515bf1d52ba6c85a203a7",
+       "86221f3ada52037b72224f105d7999231c5e5534d03da9d9c0a12acb68460cd375daf8e24386286f9668f72326dbf99ba094392437d398e95bb8161d717f8991",
+       "5595e05c13a7ec4dc8f41fb70cb50a71bce17c024ff6de7af618d0cc4e9c32d9570d6d3ea45b86525491030c0d8f2b1836d5778c1ce735c17707df364d054347",
+       "ce0f4f6aca89590a37fe034dd74dd5fa65eb1cbd0a41508aaddc09351a3cea6d18cb2189c54b700c009f4cbf0521c7ea01be61c5ae09cb54f27bc1b44d658c82",
+       "7ee80b06a215a3bca970c77cda8761822bc103d44fa4b33f4d07dcb997e36d55298bceae12241b3fa07fa63be5576068da387b8d5859aeab701369848b176d42",
+       "940a84b6a84d109aab208c024c6ce9647676ba0aaa11f86dbb7018f9fd2220a6d901a9027f9abcf935372727cbf09ebd61a2a2eeb87653e8ecad1bab85dc8327",
+       "2020b78264a82d9f4151141adba8d44bf20c5ec062eee9b595a11f9e84901bf148f298e0c9f8777dcdbc7cc4670aac356cc2ad8ccb1629f16f6a76bcefbee760",
+       "d1b897b0e075ba68ab572adf9d9c436663e43eb3d8e62d92fc49c9be214e6f27873fe215a65170e6bea902408a25b49506f47babd07cecf7113ec10c5dd31252",
+       "b14d0c62abfa469a357177e594c10c194243ed2025ab8aa5ad2fa41ad318e0ff48cd5e60bec07b13634a711d2326e488a985f31e31153399e73088efc86a5c55",
+       "4169c5cc808d2697dc2a82430dc23e3cd356dc70a94566810502b8d655b39abf9e7f902fe717e0389219859e1945df1af6ada42e4ccda55a197b7100a30c30a1",
+       "258a4edb113d66c839c8b1c91f15f35ade609f11cd7f8681a4045b9fef7b0b24c82cda06a5f2067b368825e3914e53d6948ede92efd6e8387fa2e537239b5bee",
+       "79d2d8696d30f30fb34657761171a11e6c3f1e64cbe7bebee159cb95bfaf812b4f411e2f26d9c421dc2c284a3342d823ec293849e42d1e46b0a4ac1e3c86abaa",
+       "8b9436010dc5dee992ae38aea97f2cd63b946d94fedd2ec9671dcde3bd4ce9564d555c66c15bb2b900df72edb6b891ebcadfeff63c9ea4036a998be7973981e7",
+       "c8f68e696ed28242bf997f5b3b34959508e42d613810f1e2a435c96ed2ff560c7022f361a9234b9837feee90bf47922ee0fd5f8ddf823718d86d1e16c6090071",
+       "b02d3eee4860d5868b2c39ce39bfe81011290564dd678c85e8783f29302dfc1399ba95b6b53cd9ebbf400cca1db0ab67e19a325f2d115812d25d00978ad1bca4",
+       "7693ea73af3ac4dad21ca0d8da85b3118a7d1c6024cfaf557699868217bc0c2f44a199bc6c0edd519798ba05bd5b1b4484346a47c2cadf6bf30b785cc88b2baf",
+       "a0e5c1c0031c02e48b7f09a5e896ee9aef2f17fc9e18e997d7f6cac7ae316422c2b1e77984e5f3a73cb45deed5d3f84600105e6ee38f2d090c7d0442ea34c46d",
+       "41daa6adcfdb69f1440c37b596440165c15ada596813e2e22f060fcd551f24dee8e04ba6890387886ceec4a7a0d7fc6b44506392ec3822c0d8c1acfc7d5aebe8",
+       "14d4d40d5984d84c5cf7523b7798b254e275a3a8cc0a1bd06ebc0bee726856acc3cbf516ff667cda2058ad5c3412254460a82c92187041363cc77a4dc215e487",
+       "d0e7a1e2b9a447fee83e2277e9ff8010c2f375ae12fa7aaa8ca5a6317868a26a367a0b69fbc1cf32a55d34eb370663016f3d2110230eba754028a56f54acf57c",
+       "e771aa8db5a3e043e8178f39a0857ba04a3f18e4aa05743cf8d222b0b095825350ba422f63382a23d92e4149074e816a36c1cd28284d146267940b31f8818ea2",
+       "feb4fd6f9e87a56bef398b3284d2bda5b5b0e166583a66b61e538457ff0584872c21a32962b9928ffab58de4af2edd4e15d8b35570523207ff4e2a5aa7754caa",
+       "462f17bf005fb1c1b9e671779f665209ec2873e3e411f98dabf240a1d5ec3f95ce6796b6fc23fe171903b502023467dec7273ff74879b92967a2a43a5a183d33",
+       "d3338193b64553dbd38d144bea71c5915bb110e2d88180dbc5db364fd6171df317fc7268831b5aef75e4342b2fad8797ba39eddcef80e6ec08159350b1ad696d",
+       "e1590d585a3d39f7cb599abd479070966409a6846d4377acf4471d065d5db94129cc9be92573b05ed226be1e9b7cb0cabe87918589f80dadd4ef5ef25a93d28e",
+       "f8f3726ac5a26cc80132493a6fedcb0e60760c09cfc84cad178175986819665e76842d7b9fedf76dddebf5d3f56faaad4477587af21606d396ae570d8e719af2",
+       "30186055c07949948183c850e9a756cc09937e247d9d928e869e20bafc3cd9721719d34e04a0899b92c736084550186886efba2e790d8be6ebf040b209c439a4",
+       "f3c4276cb863637712c241c444c5cc1e3554e0fddb174d035819dd83eb700b4ce88df3ab3841ba02085e1a99b4e17310c5341075c0458ba376c95a6818fbb3e2",
+       "0aa007c4dd9d5832393040a1583c930bca7dc5e77ea53add7e2b3f7c8e231368043520d4a3ef53c969b6bbfd025946f632bd7f765d53c21003b8f983f75e2a6a",
+       "08e9464720533b23a04ec24f7ae8c103145f765387d738777d3d343477fd1c58db052142cab754ea674378e18766c53542f71970171cc4f81694246b717d7564",
+       "d37ff7ad297993e7ec21e0f1b4b5ae719cdc83c5db687527f27516cbffa822888a6810ee5c1ca7bfe3321119be1ab7bfa0a502671c8329494df7ad6f522d440f",
+       "dd9042f6e464dcf86b1262f6accfafbd8cfd902ed3ed89abf78ffa482dbdeeb6969842394c9a1168ae3d481a017842f660002d42447c6b22f7b72f21aae021c9",
+       "bd965bf31e87d70327536f2a341cebc4768eca275fa05ef98f7f1b71a0351298de006fba73fe6733ed01d75801b4a928e54231b38e38c562b2e33ea1284992fa",
+       "65676d800617972fbd87e4b9514e1c67402b7a331096d3bfac22f1abb95374abc942f16e9ab0ead33b87c91968a6e509e119ff07787b3ef483e1dcdccf6e3022",
+       "939fa189699c5d2c81ddd1ffc1fa207c970b6a3685bb29ce1d3e99d42f2f7442da53e95a72907314f4588399a3ff5b0a92beb3f6be2694f9f86ecf2952d5b41c",
+       "c516541701863f91005f314108ceece3c643e04fc8c42fd2ff556220e616aaa6a48aeb97a84bad74782e8dff96a1a2fa949339d722edcaa32b57067041df88cc",
+       "987fd6e0d6857c553eaebb3d34970a2c2f6e89a3548f492521722b80a1c21a153892346d2cba6444212d56da9a26e324dccbc0dcde85d4d2ee4399eec5a64e8f",
+       "ae56deb1c2328d9c4017706bce6e99d41349053ba9d336d677c4c27d9fd50ae6aee17e853154e1f4fe7672346da2eaa31eea53fcf24a22804f11d03da6abfc2b",
+       "49d6a608c9bde4491870498572ac31aac3fa40938b38a7818f72383eb040ad39532bc06571e13d767e6945ab77c0bdc3b0284253343f9f6c1244ebf2ff0df866",
+       "da582ad8c5370b4469af862aa6467a2293b2b28bd80ae0e91f425ad3d47249fdf98825cc86f14028c3308c9804c78bfeeeee461444ce243687e1a50522456a1d",
+       "d5266aa3331194aef852eed86d7b5b2633a0af1c735906f2e13279f14931a9fc3b0eac5ce9245273bd1aa92905abe16278ef7efd47694789a7283b77da3c70f8",
+       "2962734c28252186a9a1111c732ad4de4506d4b4480916303eb7991d659ccda07a9911914bc75c418ab7a4541757ad054796e26797feaf36e9f6ad43f14b35a4",
+       "e8b79ec5d06e111bdfafd71e9f5760f00ac8ac5d8bf768f9ff6f08b8f026096b1cc3a4c973333019f1e3553e77da3f98cb9f542e0a90e5f8a940cc58e59844b3",
+       "dfb320c44f9d41d1efdcc015f08dd5539e526e39c87d509ae6812a969e5431bf4fa7d91ffd03b981e0d544cf72d7b1c0374f8801482e6dea2ef903877eba675e",
+       "d88675118fdb55a5fb365ac2af1d217bf526ce1ee9c94b2f0090b2c58a06ca58187d7fe57c7bed9d26fca067b4110eefcd9a0a345de872abe20de368001b0745",
+       "b893f2fc41f7b0dd6e2f6aa2e0370c0cff7df09e3acfcc0e920b6e6fad0ef747c40668417d342b80d2351e8c175f20897a062e9765e6c67b539b6ba8b9170545",
+       "6c67ec5697accd235c59b486d7b70baeedcbd4aa64ebd4eef3c7eac189561a726250aec4d48cadcafbbe2ce3c16ce2d691a8cce06e8879556d4483ed7165c063",
+       "f1aa2b044f8f0c638a3f362e677b5d891d6fd2ab0765f6ee1e4987de057ead357883d9b405b9d609eea1b869d97fb16d9b51017c553f3b93c0a1e0f1296fedcd",
+       "cbaa259572d4aebfc1917acddc582b9f8dfaa928a198ca7acd0f2aa76a134a90252e6298a65b08186a350d5b7626699f8cb721a3ea5921b753ae3a2dce24ba3a",
+       "fa1549c9796cd4d303dcf452c1fbd5744fd9b9b47003d920b92de34839d07ef2a29ded68f6fc9e6c45e071a2e48bd50c5084e96b657dd0404045a1ddefe282ed",
+       "5cf2ac897ab444dcb5c8d87c495dbdb34e1838b6b629427caa51702ad0f9688525f13bec503a3c3a2c80a65e0b5715e8afab00ffa56ec455a49a1ad30aa24fcd",
+       "9aaf80207bace17bb7ab145757d5696bde32406ef22b44292ef65d4519c3bb2ad41a59b62cc3e94b6fa96d32a7faadae28af7d35097219aa3fd8cda31e40c275",
+       "af88b163402c86745cb650c2988fb95211b94b03ef290eed9662034241fd51cf398f8073e369354c43eae1052f9b63b08191caa138aa54fea889cc7024236897",
+       "48fa7d64e1ceee27b9864db5ada4b53d00c9bc7626555813d3cd6730ab3cc06ff342d727905e33171bde6e8476e77fb1720861e94b73a2c538d254746285f430",
+       "0e6fd97a85e904f87bfe85bbeb34f69e1f18105cf4ed4f87aec36c6e8b5f68bd2a6f3dc8a9ecb2b61db4eedb6b2ea10bf9cb0251fb0f8b344abf7f366b6de5ab",
+       "06622da5787176287fdc8fed440bad187d830099c94e6d04c8e9c954cda70c8bb9e1fc4a6d0baa831b9b78ef6648681a4867a11da93ee36e5e6a37d87fc63f6f",
+       "1da6772b58fabf9c61f68d412c82f182c0236d7d575ef0b58dd22458d643cd1dfc93b03871c316d8430d312995d4197f0874c99172ba004a01ee295abac24e46",
+       "3cd2d9320b7b1d5fb9aab951a76023fa667be14a9124e394513918a3f44096ae4904ba0ffc150b63bc7ab1eeb9a6e257e5c8f000a70394a5afd842715de15f29",
+       "04cdc14f7434e0b4be70cb41db4c779a88eaef6accebcb41f2d42fffe7f32a8e281b5c103a27021d0d08362250753cdf70292195a53a48728ceb5844c2d98bab",
+       "9071b7a8a075d0095b8fb3ae5113785735ab98e2b52faf91d5b89e44aac5b5d4ebbf91223b0ff4c71905da55342e64655d6ef8c89a4768c3f93a6dc0366b5bc8",
+       "ebb30240dd96c7bc8d0abe49aa4edcbb4afdc51ff9aaf720d3f9e7fbb0f9c6d6571350501769fc4ebd0b2141247ff400d4fd4be414edf37757bb90a32ac5c65a",
+       "8532c58bf3c8015d9d1cbe00eef1f5082f8f3632fbe9f1ed4f9dfb1fa79e8283066d77c44c4af943d76b300364aecbd0648c8a8939bd204123f4b56260422dec",
+       "fe9846d64f7c7708696f840e2d76cb4408b6595c2f81ec6a28a7f2f20cb88cfe6ac0b9e9b8244f08bd7095c350c1d0842f64fb01bb7f532dfcd47371b0aeeb79",
+       "28f17ea6fb6c42092dc264257e29746321fb5bdaea9873c2a7fa9d8f53818e899e161bc77dfe8090afd82bf2266c5c1bc930a8d1547624439e662ef695f26f24",
+       "ec6b7d7f030d4850acae3cb615c21dd25206d63e84d1db8d957370737ba0e98467ea0ce274c66199901eaec18a08525715f53bfdb0aacb613d342ebdceeddc3b",
+       "b403d3691c03b0d3418df327d5860d34bbfcc4519bfbce36bf33b208385fadb9186bc78a76c489d89fd57e7dc75412d23bcd1dae8470ce9274754bb8585b13c5",
+       "31fc79738b8772b3f55cd8178813b3b52d0db5a419d30ba9495c4b9da0219fac6df8e7c23a811551a62b827f256ecdb8124ac8a6792ccfecc3b3012722e94463",
+       "bb2039ec287091bcc9642fc90049e73732e02e577e2862b32216ae9bedcd730c4c284ef3968c368b7d37584f97bd4b4dc6ef6127acfe2e6ae2509124e66c8af4",
+       "f53d68d13f45edfcb9bd415e2831e938350d5380d3432278fc1c0c381fcb7c65c82dafe051d8c8b0d44e0974a0e59ec7bf7ed0459f86e96f329fc79752510fd3",
+       "8d568c7984f0ecdf7640fbc483b5d8c9f86634f6f43291841b309a350ab9c1137d24066b09da9944bac54d5bb6580d836047aac74ab724b887ebf93d4b32eca9",
+       "c0b65ce5a96ff774c456cac3b5f2c4cd359b4ff53ef93a3da0778be4900d1e8da1601e769e8f1b02d2a2f8c5b9fa10b44f1c186985468feeb008730283a6657d",
+       "4900bba6f5fb103ece8ec96ada13a5c3c85488e05551da6b6b33d988e611ec0fe2e3c2aa48ea6ae8986a3a231b223c5d27cec2eadde91ce07981ee652862d1e4",
+       "c7f5c37c7285f927f76443414d4357ff789647d7a005a5a787e03c346b57f49f21b64fa9cf4b7e45573e23049017567121a9c3d4b2b73ec5e9413577525db45a",
+       "ec7096330736fdb2d64b5653e7475da746c23a4613a82687a28062d3236364284ac01720ffb406cfe265c0df626a188c9e5963ace5d3d5bb363e32c38c2190a6",
+       "82e744c75f4649ec52b80771a77d475a3bc091989556960e276a5f9ead92a03f718742cdcfeaee5cb85c44af198adc43a4a428f5f0c2ddb0be36059f06d7df73",
+       "2834b7a7170f1f5b68559ab78c1050ec21c919740b784a9072f6e5d69f828d70c919c5039fb148e39e2c8a52118378b064ca8d5001cd10a5478387b966715ed6",
+       "16b4ada883f72f853bb7ef253efcab0c3e2161687ad61543a0d2824f91c1f81347d86be709b16996e17f2dd486927b0288ad38d13063c4a9672c39397d3789b6",
+       "78d048f3a69d8b54ae0ed63a573ae350d89f7c6cf1f3688930de899afa037697629b314e5cd303aa62feea72a25bf42b304b6c6bcb27fae21c16d925e1fbdac3",
+       "0f746a48749287ada77a82961f05a4da4abdb7d77b1220f836d09ec814359c0ec0239b8c7b9ff9e02f569d1b301ef67c4612d1de4f730f81c12c40cc063c5caa",
+       "f0fc859d3bd195fbdc2d591e4cdac15179ec0f1dc821c11df1f0c1d26e6260aaa65b79fafacafd7d3ad61e600f250905f5878c87452897647a35b995bcadc3a3",
+       "2620f687e8625f6a412460b42e2cef67634208ce10a0cbd4dff7044a41b7880077e9f8dc3b8d1216d3376a21e015b58fb279b521d83f9388c7382c8505590b9b",
+       "227e3aed8d2cb10b918fcb04f9de3e6d0a57e08476d93759cd7b2ed54a1cbf0239c528fb04bbf288253e601d3bc38b21794afef90b17094a182cac557745e75f",
+       "1a929901b09c25f27d6b35be7b2f1c4745131fdebca7f3e2451926720434e0db6e74fd693ad29b777dc3355c592a361c4873b01133a57c2e3b7075cbdb86f4fc",
+       "5fd7968bc2fe34f220b5e3dc5af9571742d73b7d60819f2888b629072b96a9d8ab2d91b82d0a9aaba61bbd39958132fcc4257023d1eca591b3054e2dc81c8200",
+       "dfcce8cf32870cc6a503eadafc87fd6f78918b9b4d0737db6810be996b5497e7e5cc80e312f61e71ff3e9624436073156403f735f56b0b01845c18f6caf772e6",
+       "02f7ef3a9ce0fff960f67032b296efca3061f4934d690749f2d01c35c81c14f39a67fa350bc8a0359bf1724bffc3bca6d7c7bba4791fd522a3ad353c02ec5aa8",
+       "64be5c6aba65d594844ae78bb022e5bebe127fd6b6ffa5a13703855ab63b624dcd1a363f99203f632ec386f3ea767fc992e8ed9686586aa27555a8599d5b808f",
+       "f78585505c4eaa54a8b5be70a61e735e0ff97af944ddb3001e35d86c4e2199d976104b6ae31750a36a726ed285064f5981b503889fef822fcdc2898dddb7889a",
+       "e4b5566033869572edfd87479a5bb73c80e8759b91232879d96b1dda36c012076ee5a2ed7ae2de63ef8406a06aea82c188031b560beafb583fb3de9e57952a7e",
+       "e1b3e7ed867f6c9484a2a97f7715f25e25294e992e41f6a7c161ffc2adc6daaeb7113102d5e6090287fe6ad94ce5d6b739c6ca240b05c76fb73f25dd024bf935",
+       "85fd085fdc12a080983df07bd7012b0d402a0f4043fcb2775adf0bad174f9b08d1676e476985785c0a5dcc41dbff6d95ef4d66a3fbdc4a74b82ba52da0512b74",
+       "aed8fa764b0fbff821e05233d2f7b0900ec44d826f95e93c343c1bc3ba5a24374b1d616e7e7aba453a0ada5e4fab5382409e0d42ce9c2bc7fb39a99c340c20f0",
+       "7ba3b2e297233522eeb343bd3ebcfd835a04007735e87f0ca300cbee6d416565162171581e4020ff4cf176450f1291ea2285cb9ebffe4c56660627685145051c",
+       "de748bcf89ec88084721e16b85f30adb1a6134d664b5843569babc5bbd1a15ca9b61803c901a4fef32965a1749c9f3a4e243e173939dc5a8dc495c671ab52145",
+       "aaf4d2bdf200a919706d9842dce16c98140d34bc433df320aba9bd429e549aa7a3397652a4d768277786cf993cde2338673ed2e6b66c961fefb82cd20c93338f",
+       "c408218968b788bf864f0997e6bc4c3dba68b276e2125a4843296052ff93bf5767b8cdce7131f0876430c1165fec6c4f47adaa4fd8bcfacef463b5d3d0fa61a0",
+       "76d2d819c92bce55fa8e092ab1bf9b9eab237a25267986cacf2b8ee14d214d730dc9a5aa2d7b596e86a1fd8fa0804c77402d2fcd45083688b218b1cdfa0dcbcb",
+       "72065ee4dd91c2d8509fa1fc28a37c7fc9fa7d5b3f8ad3d0d7a25626b57b1b44788d4caf806290425f9890a3a2a35a905ab4b37acfd0da6e4517b2525c9651e4",
+       "64475dfe7600d7171bea0b394e27c9b00d8e74dd1e416a79473682ad3dfdbb706631558055cfc8a40e07bd015a4540dcdea15883cbbf31412df1de1cd4152b91",
+       "12cd1674a4488a5d7c2b3160d2e2c4b58371bedad793418d6f19c6ee385d70b3e06739369d4df910edb0b0a54cbff43d54544cd37ab3a06cfa0a3ddac8b66c89",
+       "60756966479dedc6dd4bcff8ea7d1d4ce4d4af2e7b097e32e3763518441147cc12b3c0ee6d2ecabf1198cec92e86a3616fba4f4e872f5825330adbb4c1dee444",
+       "a7803bcb71bc1d0f4383dde1e0612e04f872b715ad30815c2249cf34abb8b024915cb2fc9f4e7cc4c8cfd45be2d5a91eab0941c7d270e2da4ca4a9f7ac68663a",
+       "b84ef6a7229a34a750d9a98ee2529871816b87fbe3bc45b45fa5ae82d5141540211165c3c5d7a7476ba5a4aa06d66476f0d9dc49a3f1ee72c3acabd498967414",
+       "fae4b6d8efc3f8c8e64d001dabec3a21f544e82714745251b2b4b393f2f43e0da3d403c64db95a2cb6e23ebb7b9e94cdd5ddac54f07c4a61bd3cb10aa6f93b49",
+       "34f7286605a122369540141ded79b8957255da2d4155abbf5a8dbb89c8eb7ede8eeef1daa46dc29d751d045dc3b1d658bb64b80ff8589eddb3824b13da235a6b",
+       "3b3b48434be27b9eababba43bf6b35f14b30f6a88dc2e750c358470d6b3aa3c18e47db4017fa55106d8252f016371a00f5f8b070b74ba5f23cffc5511c9f09f0",
+       "ba289ebd6562c48c3e10a8ad6ce02e73433d1e93d7c9279d4d60a7e879ee11f441a000f48ed9f7c4ed87a45136d7dccdca482109c78a51062b3ba4044ada2469",
+       "022939e2386c5a37049856c850a2bb10a13dfea4212b4c732a8840a9ffa5faf54875c5448816b2785a007da8a8d2bc7d71a54e4e6571f10b600cbdb25d13ede3",
+       "e6fec19d89ce8717b1a087024670fe026f6c7cbda11caef959bb2d351bf856f8055d1c0ebdaaa9d1b17886fc2c562b5e99642fc064710c0d3488a02b5ed7f6fd",
+       "94c96f02a8f576aca32ba61c2b206f907285d9299b83ac175c209a8d43d53bfe683dd1d83e7549cb906c28f59ab7c46f8751366a28c39dd5fe2693c9019666c8",
+       "31a0cd215ebd2cb61de5b9edc91e6195e31c59a5648d5c9f737e125b2605708f2e325ab3381c8dce1a3e958886f1ecdc60318f882cfe20a24191352e617b0f21",
+       "91ab504a522dce78779f4c6c6ba2e6b6db5565c76d3e7e7c920caf7f757ef9db7c8fcf10e57f03379ea9bf75eb59895d96e149800b6aae01db778bb90afbc989",
+       "d85cabc6bd5b1a01a5afd8c6734740da9fd1c1acc6db29bfc8a2e5b668b028b6b3154bfb8703fa3180251d589ad38040ceb707c4bad1b5343cb426b61eaa49c1",
+       "d62efbec2ca9c1f8bd66ce8b3f6a898cb3f7566ba6568c618ad1feb2b65b76c3ce1dd20f7395372faf28427f61c9278049cf0140df434f5633048c86b81e0399",
+       "7c8fdc6175439e2c3db15bafa7fb06143a6a23bc90f449e79deef73c3d492a671715c193b6fea9f036050b946069856b897e08c00768f5ee5ddcf70b7cd6d0e0",
+       "58602ee7468e6bc9df21bd51b23c005f72d6cb013f0a1b48cbec5eca299299f97f09f54a9a01483eaeb315a6478bad37ba47ca1347c7c8fc9e6695592c91d723",
+       "27f5b79ed256b050993d793496edf4807c1d85a7b0a67c9c4fa99860750b0ae66989670a8ffd7856d7ce411599e58c4d77b232a62bef64d15275be46a68235ff",
+       "3957a976b9f1887bf004a8dca942c92d2b37ea52600f25e0c9bc5707d0279c00c6e85a839b0d2d8eb59c51d94788ebe62474a791cadf52cccf20f5070b6573fc",
+       "eaa2376d55380bf772ecca9cb0aa4668c95c707162fa86d518c8ce0ca9bf7362b9f2a0adc3ff59922df921b94567e81e452f6c1a07fc817cebe99604b3505d38",
+       "c1e2c78b6b2734e2480ec550434cb5d613111adcc21d475545c3b1b7e6ff12444476e5c055132e2229dc0f807044bb919b1a5662dd38a9ee65e243a3911aed1a",
+       "8ab48713389dd0fcf9f965d3ce66b1e559a1f8c58741d67683cd971354f452e62d0207a65e436c5d5d8f8ee71c6abfe50e669004c302b31a7ea8311d4a916051",
+       "24ce0addaa4c65038bd1b1c0f1452a0b128777aabc94a29df2fd6c7e2f85f8ab9ac7eff516b0e0a825c84a24cfe492eaad0a6308e46dd42fe8333ab971bb30ca",
+       "5154f929ee03045b6b0c0004fa778edee1d139893267cc84825ad7b36c63de32798e4a166d24686561354f63b00709a1364b3c241de3febf0754045897467cd4",
+       "e74e907920fd87bd5ad636dd11085e50ee70459c443e1ce5809af2bc2eba39f9e6d7128e0e3712c316da06f4705d78a4838e28121d4344a2c79c5e0db307a677",
+       "bf91a22334bac20f3fd80663b3cd06c4e8802f30e6b59f90d3035cc9798a217ed5a31abbda7fa6842827bdf2a7a1c21f6fcfccbb54c6c52926f32da816269be1",
+       "d9d5c74be5121b0bd742f26bffb8c89f89171f3f934913492b0903c271bbe2b3395ef259669bef43b57f7fcc3027db01823f6baee66e4f9fead4d6726c741fce",
+       "50c8b8cf34cd879f80e2faab3230b0c0e1cc3e9dcadeb1b9d97ab923415dd9a1fe38addd5c11756c67990b256e95ad6d8f9fedce10bf1c90679cde0ecf1be347",
+       "0a386e7cd5dd9b77a035e09fe6fee2c8ce61b5383c87ea43205059c5e4cd4f4408319bb0a82360f6a58e6c9ce3f487c446063bf813bc6ba535e17fc1826cfc91",
+       "1f1459cb6b61cbac5f0efe8fc487538f42548987fcd56221cfa7beb22504769e792c45adfb1d6b3d60d7b749c8a75b0bdf14e8ea721b95dca538ca6e25711209",
+       "e58b3836b7d8fedbb50ca5725c6571e74c0785e97821dab8b6298c10e4c079d4a6cdf22f0fedb55032925c16748115f01a105e77e00cee3d07924dc0d8f90659",
+       "b929cc6505f020158672deda56d0db081a2ee34c00c1100029bdf8ea98034fa4bf3e8655ec697fe36f40553c5bb46801644a627d3342f4fc92b61f03290fb381",
+       "72d353994b49d3e03153929a1e4d4f188ee58ab9e72ee8e512f29bc773913819ce057ddd7002c0433ee0a16114e3d156dd2c4a7e80ee53378b8670f23e33ef56",
+       "c70ef9bfd775d408176737a0736d68517ce1aaad7e81a93c8c1ed967ea214f56c8a377b1763e676615b60f3988241eae6eab9685a5124929d28188f29eab06f7",
+       "c230f0802679cb33822ef8b3b21bf7a9a28942092901d7dac3760300831026cf354c9232df3e084d9903130c601f63c1f4a4a4b8106e468cd443bbe5a734f45f",
+       "6f43094cafb5ebf1f7a4937ec50f56a4c9da303cbb55ac1f27f1f1976cd96beda9464f0e7b9c54620b8a9fba983164b8be3578425a024f5fe199c36356b88972",
+       "3745273f4c38225db2337381871a0c6aafd3af9b018c88aa02025850a5dc3a42a1a3e03e56cbf1b0876d63a441f1d2856a39b8801eb5af325201c415d65e97fe",
+       "c50c44cca3ec3edaae779a7e179450ebdda2f97067c690aa6c5a4ac7c30139bb27c0df4db3220e63cb110d64f37ffe078db72653e2daacf93ae3f0a2d1a7eb2e",
+       "8aef263e385cbc61e19b28914243262af5afe8726af3ce39a79c27028cf3ecd3f8d2dfd9cfc9ad91b58f6f20778fd5f02894a3d91c7d57d1e4b866a7f364b6be",
+       "28696141de6e2d9bcb3235578a66166c1448d3e905a1b482d423be4bc5369bc8c74dae0acc9cc123e1d8ddce9f97917e8c019c552da32d39d2219b9abf0fa8c8",
+       "2fb9eb2085830181903a9dafe3db428ee15be7662224efd643371fb25646aee716e531eca69b2bdc8233f1a8081fa43da1500302975a77f42fa592136710e9dc",
+       "66f9a7143f7a3314a669bf2e24bbb35014261d639f495b6c9c1f104fe8e320aca60d4550d69d52edbd5a3cdeb4014ae65b1d87aa770b69ae5c15f4330b0b0ad8",
+       "f4c4dd1d594c3565e3e25ca43dad82f62abea4835ed4cd811bcd975e46279828d44d4c62c3679f1b7f7b9dd4571d7b49557347b8c5460cbdc1bef690fb2a08c0",
+       "8f1dc9649c3a84551f8f6e91cac68242a43b1f8f328ee92280257387fa7559aa6db12e4aeadc2d26099178749c6864b357f3f83b2fb3efa8d2a8db056bed6bcc",
+       "3139c1a7f97afd1675d460ebbc07f2728aa150df849624511ee04b743ba0a833092f18c12dc91b4dd243f333402f59fe28abdbbbae301e7b659c7a26d5c0f979",
+       "06f94a2996158a819fe34c40de3cf0379fd9fb85b3e363ba3926a0e7d960e3f4c2e0c70c7ce0ccb2a64fc29869f6e7ab12bd4d3f14fce943279027e785fb5c29",
+       "c29c399ef3eee8961e87565c1ce263925fc3d0ce267d13e48dd9e732ee67b0f69fad56401b0f10fcaac119201046cca28c5b14abdea3212ae65562f7f138db3d",
+       "4cec4c9df52eef05c3f6faaa9791bc7445937183224ecc37a1e58d0132d35617531d7e795f52af7b1eb9d147de1292d345fe341823f8e6bc1e5badca5c656108",
+       "898bfbae93b3e18d00697eab7d9704fa36ec339d076131cefdf30edbe8d9cc81c3a80b129659b163a323bab9793d4feed92d54dae966c77529764a09be88db45",
+       "ee9bd0469d3aaf4f14035be48a2c3b84d9b4b1fff1d945e1f1c1d38980a951be197b25fe22c731f20aeacc930ba9c4a1f4762227617ad350fdabb4e80273a0f4",
+       "3d4d3113300581cd96acbf091c3d0f3c310138cd6979e6026cde623e2dd1b24d4a8638bed1073344783ad0649cc6305ccec04beb49f31c633088a99b65130267",
+       "95c0591ad91f921ac7be6d9ce37e0663ed8011c1cfd6d0162a5572e94368bac02024485e6a39854aa46fe38e97d6c6b1947cd272d86b06bb5b2f78b9b68d559d",
+       "227b79ded368153bf46c0a3ca978bfdbef31f3024a5665842468490b0ff748ae04e7832ed4c9f49de9b1706709d623e5c8c15e3caecae8d5e433430ff72f20eb",
+       "5d34f3952f0105eef88ae8b64c6ce95ebfade0e02c69b08762a8712d2e4911ad3f941fc4034dc9b2e479fdbcd279b902faf5d838bb2e0c6495d372b5b7029813",
+       "7f939bf8353abce49e77f14f3750af20b7b03902e1a1e7fb6aaf76d0259cd401a83190f15640e74f3e6c5a90e839c7821f6474757f75c7bf9002084ddc7a62dc",
+       "062b61a2f9a33a71d7d0a06119644c70b0716a504de7e5e1be49bd7b86e7ed6817714f9f0fc313d06129597e9a2235ec8521de36f7290a90ccfc1ffa6d0aee29",
+       "f29e01eeae64311eb7f1c6422f946bf7bea36379523e7b2bbaba7d1d34a22d5ea5f1c5a09d5ce1fe682cced9a4798d1a05b46cd72dff5c1b355440b2a2d476bc",
+       "ec38cd3bbab3ef35d7cb6d5c914298351d8a9dc97fcee051a8a02f58e3ed6184d0b7810a5615411ab1b95209c3c810114fdeb22452084e77f3f847c6dbaafe16",
+       "c2aef5e0ca43e82641565b8cb943aa8ba53550caef793b6532fafad94b816082f0113a3ea2f63608ab40437ecc0f0229cb8fa224dcf1c478a67d9b64162b92d1",
+       "15f534efff7105cd1c254d074e27d5898b89313b7d366dc2d7d87113fa7d53aae13f6dba487ad8103d5e854c91fdb6e1e74b2ef6d1431769c30767dde067a35c",
+       "89acbca0b169897a0a2714c2df8c95b5b79cb69390142b7d6018bb3e3076b099b79a964152a9d912b1b86412b7e372e9cecad7f25d4cbab8a317be36492a67d7",
+       "e3c0739190ed849c9c962fd9dbb55e207e624fcac1eb417691515499eea8d8267b7e8f1287a63633af5011fde8c4ddf55bfdf722edf88831414f2cfaed59cb9a",
+       "8d6cf87c08380d2d1506eee46fd4222d21d8c04e585fbfd08269c98f702833a156326a0724656400ee09351d57b440175e2a5de93cc5f80db6daf83576cf75fa",
+       "da24bede383666d563eeed37f6319baf20d5c75d1635a6ba5ef4cfa1ac95487e96f8c08af600aab87c986ebad49fc70a58b4890b9c876e091016daf49e1d322e",
+       "f9d1d1b1e87ea7ae753a029750cc1cf3d0157d41805e245c5617bb934e732f0ae3180b78e05bfe76c7c3051e3e3ac78b9b50c05142657e1e03215d6ec7bfd0fc",
+       "11b7bc1668032048aa43343de476395e814bbbc223678db951a1b03a021efac948cfbe215f97fe9a72a2f6bc039e3956bfa417c1a9f10d6d7ba5d3d32ff323e5",
+       "b8d9000e4fc2b066edb91afee8e7eb0f24e3a201db8b6793c0608581e628ed0bcc4e5aa6787992a4bcc44e288093e63ee83abd0bc3ec6d0934a674a4da13838a",
+       "ce325e294f9b6719d6b61278276ae06a2564c03bb0b783fafe785bdf89c7d5acd83e78756d301b445699024eaeb77b54d477336ec2a4f332f2b3f88765ddb0c3",
+       "29acc30e9603ae2fccf90bf97e6cc463ebe28c1b2f9b4b765e70537c25c702a29dcbfbf14c99c54345ba2b51f17b77b5f15db92bbad8fa95c471f5d070a137cc",
+       "3379cbaae562a87b4c0425550ffdd6bfe1203f0d666cc7ea095be407a5dfe61ee91441cd5154b3e53b4f5fb31ad4c7a9ad5c7af4ae679aa51a54003a54ca6b2d",
+       "3095a349d245708c7cf550118703d7302c27b60af5d4e67fc978f8a4e60953c7a04f92fcf41aee64321ccb707a895851552b1e37b00bc5e6b72fa5bcef9e3fff",
+       "07262d738b09321f4dbccec4bb26f48cb0f0ed246ce0b31b9a6e7bc683049f1f3e5545f28ce932dd985c5ab0f43bd6de0770560af329065ed2e49d34624c2cbb",
+       "b6405eca8ee3316c87061cc6ec18dba53e6c250c63ba1f3bae9e55dd3498036af08cd272aa24d713c6020d77ab2f3919af1a32f307420618ab97e73953994fb4",
+       "7ee682f63148ee45f6e5315da81e5c6e557c2c34641fc509c7a5701088c38a74756168e2cd8d351e88fd1a451f360a01f5b2580f9b5a2e8cfc138f3dd59a3ffc",
+       "1d263c179d6b268f6fa016f3a4f29e943891125ed8593c81256059f5a7b44af2dcb2030d175c00e62ecaf7ee96682aa07ab20a611024a28532b1c25b86657902",
+       "106d132cbdb4cd2597812846e2bc1bf732fec5f0a5f65dbb39ec4e6dc64ab2ce6d24630d0f15a805c3540025d84afa98e36703c3dbee713e72dde8465bc1be7e",
+       "0e79968226650667a8d862ea8da4891af56a4e3a8b6d1750e394f0dea76d640d85077bcec2cc86886e506751b4f6a5838f7f0b5fef765d9dc90dcdcbaf079f08",
+       "521156a82ab0c4e566e5844d5e31ad9aaf144bbd5a464fdca34dbd5717e8ff711d3ffebbfa085d67fe996a34f6d3e4e60b1396bf4b1610c263bdbb834d560816",
+       "1aba88befc55bc25efbce02db8b9933e46f57661baeabeb21cc2574d2a518a3cba5dc5a38e49713440b25f9c744e75f6b85c9d8f4681f676160f6105357b8406",
+       "5a9949fcb2c473cda968ac1b5d08566dc2d816d960f57e63b898fa701cf8ebd3f59b124d95bfbbedc5f1cf0e17d5eaed0c02c50b69d8a402cabcca4433b51fd4",
+       "b0cead09807c672af2eb2b0f06dde46cf5370e15a4096b1a7d7cbb36ec31c205fbefca00b7a4162fa89fb4fb3eb78d79770c23f44e7206664ce3cd931c291e5d",
+       "bb6664931ec97044e45b2ae420ae1c551a8874bc937d08e969399c3964ebdba8346cdd5d09caafe4c28ba7ec788191ceca65ddd6f95f18583e040d0f30d0364d",
+       "65bc770a5faa3792369803683e844b0be7ee96f29f6d6a35568006bd5590f9a4ef639b7a8061c7b0424b66b60ac34af3119905f33a9d8c3ae18382ca9b689900",
+       "ea9b4dca333336aaf839a45c6eaa48b8cb4c7ddabffea4f643d6357ea6628a480a5b45f2b052c1b07d1fedca918b6f1139d80f74c24510dcbaa4be70eacc1b06",
+       "e6342fb4a780ad975d0e24bce149989b91d360557e87994f6b457b895575cc02d0c15bad3ce7577f4c63927ff13f3e381ff7e72bdbe745324844a9d27e3f1c01",
+       "3e209c9b33e8e461178ab46b1c64b49a07fb745f1c8bc95fbfb94c6b87c69516651b264ef980937fad41238b91ddc011a5dd777c7efd4494b4b6ecd3a9c22ac0",
+       "fd6a3d5b1875d80486d6e69694a56dbb04a99a4d051f15db2689776ba1c4882e6d462a603b7015dc9f4b7450f05394303b8652cfb404a266962c41bae6e18a94",
+       "951e27517e6bad9e4195fc8671dee3e7e9be69cee1422cb9fecfce0dba875f7b310b93ee3a3d558f941f635f668ff832d2c1d033c5e2f0997e4c66f147344e02",
+       "8eba2f874f1ae84041903c7c4253c82292530fc8509550bfdc34c95c7e2889d5650b0ad8cb988e5c4894cb87fbfbb19612ea93ccc4c5cad17158b9763464b492",
+       "16f712eaa1b7c6354719a8e7dbdfaf55e4063a4d277d947550019b38dfb564830911057d50506136e2394c3b28945cc964967d54e3000c2181626cfb9b73efd2",
+       "c39639e7d5c7fb8cdd0fd3e6a52096039437122f21c78f1679cea9d78a734c56ecbeb28654b4f18e342c331f6f7229ec4b4bc281b2d80a6eb50043f31796c88c",
+       "72d081af99f8a173dcc9a0ac4eb3557405639a29084b54a40172912a2f8a395129d5536f0918e902f9e8fa6000995f4168ddc5f893011be6a0dbc9b8a1a3f5bb",
+       "c11aa81e5efd24d5fc27ee586cfd8847fbb0e27601ccece5ecca0198e3c7765393bb74457c7e7a27eb9170350e1fb53857177506be3e762cc0f14d8c3afe9077",
+       "c28f2150b452e6c0c424bcde6f8d72007f9310fed7f2f87de0dbb64f4479d6c1441ba66f44b2accee61609177ed340128b407ecec7c64bbe50d63d22d8627727",
+       "f63d88122877ec30b8c8b00d22e89000a966426112bd44166e2f525b769ccbe9b286d437a0129130dde1a86c43e04bedb594e671d98283afe64ce331de9828fd",
+       "348b0532880b88a6614a8d7408c3f913357fbb60e995c60205be9139e74998aede7f4581e42f6b52698f7fa1219708c14498067fd1e09502de83a77dd281150c",
+       "5133dc8bef725359dff59792d85eaf75b7e1dcd1978b01c35b1b85fcebc63388ad99a17b6346a217dc1a9622ebd122ecf6913c4d31a6b52a695b86af00d741a0",
+       "2753c4c0e98ecad806e88780ec27fccd0f5c1ab547f9e4bf1659d192c23aa2cc971b58b6802580baef8adc3b776ef7086b2545c2987f348ee3719cdef258c403",
+       "b1663573ce4b9d8caefc865012f3e39714b9898a5da6ce17c25a6a47931a9ddb9bbe98adaa553beed436e89578455416c2a52a525cf2862b8d1d49a2531b7391",
+       "64f58bd6bfc856f5e873b2a2956ea0eda0d6db0da39c8c7fc67c9f9feefcff3072cdf9e6ea37f69a44f0c61aa0da3693c2db5b54960c0281a088151db42b11e8",
+       "0764c7be28125d9065c4b98a69d60aede703547c66a12e17e1c618994132f5ef82482c1e3fe3146cc65376cc109f0138ed9a80e49f1f3c7d610d2f2432f20605",
+       "f748784398a2ff03ebeb07e155e66116a839741a336e32da71ec696001f0ad1b25cd48c69cfca7265eca1dd71904a0ce748ac4124f3571076dfa7116a9cf00e9",
+       "3f0dbc0186bceb6b785ba78d2a2a013c910be157bdaffae81bb6663b1a73722f7f1228795f3ecada87cf6ef0078474af73f31eca0cc200ed975b6893f761cb6d",
+       "d4762cd4599876ca75b2b8fe249944dbd27ace741fdab93616cbc6e425460feb51d4e7adcc38180e7fc47c89024a7f56191adb878dfde4ead62223f5a2610efe",
+       "cd36b3d5b4c91b90fcbba79513cfee1907d8645a162afd0cd4cf4192d4a5f4c892183a8eacdb2b6b6a9d9aa8c11ac1b261b380dbee24ca468f1bfd043c58eefe",
+       "98593452281661a53c48a9d8cd790826c1a1ce567738053d0bee4a91a3d5bd92eefdbabebe3204f2031ca5f781bda99ef5d8ae56e5b04a9e1ecd21b0eb05d3e1",
+       "771f57dd2775ccdab55921d3e8e30ccf484d61fe1c1b9c2ae819d0fb2a12fab9be70c4a7a138da84e8280435daade5bbe66af0836a154f817fb17f3397e725a3",
+       "c60897c6f828e21f16fbb5f15b323f87b6c8955eabf1d38061f707f608abdd993fac3070633e286cf8339ce295dd352df4b4b40b2f29da1dd50b3a05d079e6bb",
+       "8210cd2c2d3b135c2cf07fa0d1433cd771f325d075c6469d9c7f1ba0943cd4ab09808cabf4acb9ce5bb88b498929b4b847f681ad2c490d042db2aec94214b06b",
+       "1d4edfffd8fd80f7e4107840fa3aa31e32598491e4af7013c197a65b7f36dd3ac4b478456111cd4309d9243510782fa31b7c4c95fa951520d020eb7e5c36e4ef",
+       "af8e6e91fab46ce4873e1a50a8ef448cc29121f7f74deef34a71ef89cc00d9274bc6c2454bbb3230d8b2ec94c62b1dec85f3593bfa30ea6f7a44d7c09465a253",
+       "29fd384ed4906f2d13aa9fe7af905990938bed807f1832454a372ab412eea1f5625a1fcc9ac8343b7c67c5aba6e0b1cc4644654913692c6b39eb9187ceacd3ec",
+       "a268c7885d9874a51c44dffed8ea53e94f78456e0b2ed99ff5a3924760813826d960a15edbedbb5de5226ba4b074e71b05c55b9756bb79e55c02754c2c7b6c8a",
+       "0cf8545488d56a86817cd7ecb10f7116b7ea530a45b6ea497b6c72c997e09e3d0da8698f46bb006fc977c2cd3d1177463ac9057fdd1662c85d0c126443c10473",
+       "b39614268fdd8781515e2cfebf89b4d5402bab10c226e6344e6b9ae000fb0d6c79cb2f3ec80e80eaeb1980d2f8698916bd2e9f747236655116649cd3ca23a837",
+       "74bef092fc6f1e5dba3663a3fb003b2a5ba257496536d99f62b9d73f8f9eb3ce9ff3eec709eb883655ec9eb896b9128f2afc89cf7d1ab58a72f4a3bf034d2b4a",
+       "3a988d38d75611f3ef38b8774980b33e573b6c57bee0469ba5eed9b44f29945e7347967fba2c162e1c3be7f310f2f75ee2381e7bfd6b3f0baea8d95dfb1dafb1",
+       "58aedfce6f67ddc85a28c992f1c0bd0969f041e66f1ee88020a125cbfcfebcd61709c9c4eba192c15e69f020d462486019fa8dea0cd7a42921a19d2fe546d43d",
+       "9347bd291473e6b4e368437b8e561e065f649a6d8ada479ad09b1999a8f26b91cf6120fd3bfe014e83f23acfa4c0ad7b3712b2c3c0733270663112ccd9285cd9",
+       "b32163e7c5dbb5f51fdc11d2eac875efbbcb7e7699090a7e7ff8a8d50795af5d74d9ff98543ef8cdf89ac13d0485278756e0ef00c817745661e1d59fe38e7537",
+       "1085d78307b1c4b008c57a2e7e5b234658a0a82e4ff1e4aaac72b312fda0fe27d233bc5b10e9cc17fdc7697b540c7d95eb215a19a1a0e20e1abfa126efd568c7",
+       "4e5c734c7dde011d83eac2b7347b373594f92d7091b9ca34cb9c6f39bdf5a8d2f134379e16d822f6522170ccf2ddd55c84b9e6c64fc927ac4cf8dfb2a17701f2",
+       "695d83bd990a1117b3d0ce06cc888027d12a054c2677fd82f0d4fbfc93575523e7991a5e35a3752e9b70ce62992e268a877744cdd435f5f130869c9a2074b338",
+       "a6213743568e3b3158b9184301f3690847554c68457cb40fc9a4b8cfd8d4a118c301a07737aeda0f929c68913c5f51c80394f53bff1c3e83b2e40ca97eba9e15",
+       "d444bfa2362a96df213d070e33fa841f51334e4e76866b8139e8af3bb3398be2dfaddcbc56b9146de9f68118dc5829e74b0c28d7711907b121f9161cb92b69a9",
+       "142709d62e28fcccd0af97fad0f8465b971e82201dc51070faa0372aa43e92484be1c1e73ba10906d5d1853db6a4106e0a7bf9800d373d6dee2d46d62ef2a461",
+}

diff --git a/vendor/github.com/minio/blake2b-simd/compressAvx2_amd64.go b/vendor/github.com/minio/blake2b-simd/compressAvx2_amd64.go
new file mode 100644 (file)
index 0000000..ec53599
--- /dev/null
+++ b/vendor/github.com/minio/blake2b-simd/compressAvx2_amd64.go
@@ -0,0 +1,47 @@
+//+build !noasm
+//+build !appengine
+
+/*
+ * Minio Cloud Storage, (C) 2016 Minio, Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package blake2b
+
+//go:noescape
+func compressAVX2Loop(p []uint8, in, iv, t, f, shffle, out []uint64)
+
+func compressAVX2(d *digest, p []uint8) {
+       var (
+               in     [8]uint64
+               out    [8]uint64
+               shffle [8]uint64
+       )
+
+       // vector for PSHUFB instruction
+       shffle[0] = 0x0201000706050403
+       shffle[1] = 0x0a09080f0e0d0c0b
+       shffle[2] = 0x0201000706050403
+       shffle[3] = 0x0a09080f0e0d0c0b
+       shffle[4] = 0x0100070605040302
+       shffle[5] = 0x09080f0e0d0c0b0a
+       shffle[6] = 0x0100070605040302
+       shffle[7] = 0x09080f0e0d0c0b0a
+
+       in[0], in[1], in[2], in[3], in[4], in[5], in[6], in[7] = d.h[0], d.h[1], d.h[2], d.h[3], d.h[4], d.h[5], d.h[6], d.h[7]
+
+       compressAVX2Loop(p, in[:], iv[:], d.t[:], d.f[:], shffle[:], out[:])
+
+       d.h[0], d.h[1], d.h[2], d.h[3], d.h[4], d.h[5], d.h[6], d.h[7] = out[0], out[1], out[2], out[3], out[4], out[5], out[6], out[7]
+}

diff --git a/vendor/github.com/minio/blake2b-simd/compressAvx2_amd64.s b/vendor/github.com/minio/blake2b-simd/compressAvx2_amd64.s
new file mode 100644 (file)
index 0000000..24df234
--- /dev/null
+++ b/vendor/github.com/minio/blake2b-simd/compressAvx2_amd64.s
@@ -0,0 +1,671 @@
+//+build !noasm !appengine
+
+//
+// Minio Cloud Storage, (C) 2016 Minio, Inc.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+
+//
+// Based on AVX2 implementation from https://github.com/sneves/blake2-avx2/blob/master/blake2b-common.h
+//
+// Use github.com/fwessels/asm2plan9s on this file to assemble instructions to their Plan9 equivalent
+//
+// Assembly code below essentially follows the ROUND macro (see blake2b-round.h) which is defined as:
+//   #define ROUND(r) \
+//     LOAD_MSG_ ##r ##_1(b0, b1); \
+//     G1(row1l,row2l,row3l,row4l,row1h,row2h,row3h,row4h,b0,b1); \
+//     LOAD_MSG_ ##r ##_2(b0, b1); \
+//     G2(row1l,row2l,row3l,row4l,row1h,row2h,row3h,row4h,b0,b1); \
+//     DIAGONALIZE(row1l,row2l,row3l,row4l,row1h,row2h,row3h,row4h); \
+//     LOAD_MSG_ ##r ##_3(b0, b1); \
+//     G1(row1l,row2l,row3l,row4l,row1h,row2h,row3h,row4h,b0,b1); \
+//     LOAD_MSG_ ##r ##_4(b0, b1); \
+//     G2(row1l,row2l,row3l,row4l,row1h,row2h,row3h,row4h,b0,b1); \
+//     UNDIAGONALIZE(row1l,row2l,row3l,row4l,row1h,row2h,row3h,row4h);
+//
+// as well as the go equivalent in https://github.com/dchest/blake2b/blob/master/block.go
+//
+// As in the macro, G1/G2 in the 1st and 2nd half are identical (so literal copy of assembly)
+//
+// Rounds are also the same, except for the loading of the message (and rounds 1 & 11 and
+// rounds 2 & 12 are identical)
+//
+
+#define G1 \
+    \ // G1(row1l,row2l,row3l,row4l,row1h,row2h,row3h,row4h,b0,b1);
+    BYTE $0xc5; BYTE $0xfd; BYTE $0xd4; BYTE $0xc4             \ // VPADDQ  YMM0,YMM0,YMM4   /* v0 += m[0], v1 += m[2], v2 += m[4], v3 += m[6] */
+    BYTE $0xc5; BYTE $0xfd; BYTE $0xd4; BYTE $0xc1             \ // VPADDQ  YMM0,YMM0,YMM1   /* v0 += v4, v1 += v5, v2 += v6, v3 += v7 */
+    BYTE $0xc5; BYTE $0xe5; BYTE $0xef; BYTE $0xd8             \ // VPXOR   YMM3,YMM3,YMM0   /* v12 ^= v0, v13 ^= v1, v14 ^= v2, v15 ^= v3 */
+    BYTE $0xc5; BYTE $0xfd; BYTE $0x70; BYTE $0xdb; BYTE $0xb1 \ // VPSHUFD YMM3,YMM3,0xb1   /* v12 = v12<<(64-32) | v12>>32, v13 = */
+    BYTE $0xc5; BYTE $0xed; BYTE $0xd4; BYTE $0xd3             \ // VPADDQ  YMM2,YMM2,YMM3   /* v8 += v12, v9 += v13, v10 += v14, v11 += v15 */
+    BYTE $0xc5; BYTE $0xf5; BYTE $0xef; BYTE $0xca             \ // VPXOR   YMM1,YMM1,YMM2   /* v4 ^= v8, v5 ^= v9, v6 ^= v10, v7 ^= v11 */
+    BYTE $0xc4; BYTE $0xe2; BYTE $0x75; BYTE $0x00; BYTE $0xce   // VPSHUFB YMM1,YMM1,YMM6   /* v4 = v4<<(64-24) | v4>>24, ..., ..., v7 = v7<<(64-24) | v7>>24 */
+
+#define G2 \
+    BYTE $0xc5; BYTE $0xfd; BYTE $0xd4; BYTE $0xc5             \ // VPADDQ  YMM0,YMM0,YMM5   /* v0 += m[1], v1 += m[3], v2 += m[5], v3 += m[7] */
+    BYTE $0xc5; BYTE $0xfd; BYTE $0xd4; BYTE $0xc1             \ // VPADDQ  YMM0,YMM0,YMM1   /* v0 += v4, v1 += v5, v2 += v6, v3 += v7 */
+    BYTE $0xc5; BYTE $0xe5; BYTE $0xef; BYTE $0xd8             \ // VPXOR   YMM3,YMM3,YMM0   /* v12 ^= v0, v13 ^= v1, v14 ^= v2, v15 ^= v3 */
+    BYTE $0xc4; BYTE $0xe2; BYTE $0x65; BYTE $0x00; BYTE $0xdf \ // VPSHUFB YMM3,YMM3,YMM7   /* v12 = v12<<(64-16) | v12>>16, ..., ..., v15 = v15<<(64-16) | v15>>16 */
+    BYTE $0xc5; BYTE $0xed; BYTE $0xd4; BYTE $0xd3             \ // VPADDQ  YMM2,YMM2,YMM3   /* v8 += v12, v9 += v13, v10 += v14, v11 += v15 */
+    BYTE $0xc5; BYTE $0xf5; BYTE $0xef; BYTE $0xca             \ // VPXOR   YMM1,YMM1,YMM2   /* v4 ^= v8, v5 ^= v9, v6 ^= v10, v7 ^= v11 */
+    BYTE $0xc5; BYTE $0x75; BYTE $0xd4; BYTE $0xf9             \ // VPADDQ  YMM15,YMM1,YMM1  /* temp reg = reg*2   */
+    BYTE $0xc5; BYTE $0xf5; BYTE $0x73; BYTE $0xd1; BYTE $0x3f \ // VPSRLQ  YMM1,YMM1,0x3f   /*      reg = reg>>63 */
+    BYTE $0xc4; BYTE $0xc1; BYTE $0x75; BYTE $0xef; BYTE $0xcf   // VPXOR   YMM1,YMM1,YMM15  /* ORed together: v4 = v4<<(64-63) | v4>>63, v5 = v5<<(64-63) | v5>>63 */
+
+#define DIAGONALIZE \
+    BYTE $0xc4; BYTE $0xe3; BYTE $0xfd; BYTE $0x00; BYTE $0xdb \ // VPERMQ YMM3, YMM3, 0x93
+                BYTE $0x93                                     \
+    BYTE $0xc4; BYTE $0xe3; BYTE $0xfd; BYTE $0x00; BYTE $0xd2 \ // VPERMQ YMM2, YMM2, 0x4e
+                BYTE $0x4e                                     \
+    BYTE $0xc4; BYTE $0xe3; BYTE $0xfd; BYTE $0x00; BYTE $0xc9 \ // VPERMQ YMM1, YMM1, 0x39
+                BYTE $0x39                                     \
+    // DO NOT DELETE -- macro delimiter (previous line extended)
+
+#define UNDIAGONALIZE \
+    BYTE $0xc4; BYTE $0xe3; BYTE $0xfd; BYTE $0x00; BYTE $0xdb \ // VPERMQ YMM3, YMM3, 0x39
+                BYTE $0x39                                     \
+    BYTE $0xc4; BYTE $0xe3; BYTE $0xfd; BYTE $0x00; BYTE $0xd2 \ // VPERMQ YMM2, YMM2, 0x4e
+                BYTE $0x4e                                     \
+    BYTE $0xc4; BYTE $0xe3; BYTE $0xfd; BYTE $0x00; BYTE $0xc9 \ // VPERMQ YMM1, YMM1, 0x93
+                BYTE $0x93                                     \
+    // DO NOT DELETE -- macro delimiter (previous line extended)
+
+#define LOAD_SHUFFLE \
+    MOVQ   shffle+120(FP), SI \ // SI: &shuffle
+    BYTE $0xc5; BYTE $0xfe; BYTE $0x6f; BYTE $0x36             \ // VMOVDQU YMM6, [rsi]
+    BYTE $0xc5; BYTE $0xfe; BYTE $0x6f; BYTE $0x7e; BYTE $0x20   // VMOVDQU YMM7, 32[rsi]
+
+// func compressAVX2Loop(compressSSE(p []uint8, in, iv, t, f, shffle, out []uint64)
+TEXT ·compressAVX2Loop(SB), 7, $0
+
+    // REGISTER USE
+    //  Y0 - Y3: v0 - v15
+    //  Y4 - Y5: m[0] - m[7]
+    //  Y6 - Y7: shuffle value
+    //  Y8 - Y9: temp registers
+    // Y10 -Y13: copy of full message
+    //      Y15: temp register
+
+    // Load digest
+    MOVQ   in+24(FP),  SI     // SI: &in
+    BYTE $0xc5; BYTE $0xfe; BYTE $0x6f; BYTE $0x06               // VMOVDQU YMM0, [rsi]
+    BYTE $0xc5; BYTE $0xfe; BYTE $0x6f; BYTE $0x4e; BYTE $0x20   // VMOVDQU YMM1, 32[rsi]
+
+    // Already store digest into &out (so we can reload it later generically)
+    MOVQ  out+144(FP), SI     // SI: &out
+    BYTE $0xc5; BYTE $0xfe; BYTE $0x7f; BYTE $0x06               // VMOVDQU [rsi], YMM0
+    BYTE $0xc5; BYTE $0xfe; BYTE $0x7f; BYTE $0x4e; BYTE $0x20   // VMOVDQU 32[rsi], YMM1
+
+    // Initialize message pointer and loop counter
+    MOVQ   message+0(FP), DX  // DX: &p (message)
+    MOVQ   message_len+8(FP), R8 // R8: len(message)
+    SHRQ   $7, R8             // len(message) / 128
+    CMPQ   R8, $0
+    JEQ    complete
+
+loop:
+    // Increment counter
+    MOVQ t+72(FP), SI         // SI: &t
+    MOVQ   0(SI), R9          //
+    ADDQ   $128, R9           //                       /* d.t[0] += BlockSize */
+    MOVQ   R9, 0(SI)          //
+    CMPQ   R9, $128           //                       /* if d.t[0] < BlockSize { */
+    JGE    noincr             //
+    MOVQ   8(SI), R9          //
+    ADDQ   $1, R9             //                       /*     d.t[1]++ */
+    MOVQ   R9, 8(SI)          //
+noincr:                       //                       /* } */
+
+    // Load initialization vector
+    MOVQ iv+48(FP), SI        // SI: &iv
+    BYTE $0xc5; BYTE $0xfe; BYTE $0x6f; BYTE $0x16               // VMOVDQU YMM2, [rsi]
+    BYTE $0xc5; BYTE $0xfe; BYTE $0x6f; BYTE $0x5e; BYTE $0x20   // VMOVDQU YMM3, 32[rsi]
+    MOVQ t+72(FP), SI         // SI: &t
+    BYTE $0xc4; BYTE $0x63; BYTE $0x3d; BYTE $0x38; BYTE $0x06   // VINSERTI128 YMM8, YMM8, [rsi], 0  /* Y8 = t[0]+t[1] */
+                BYTE $0x00
+    MOVQ t+96(FP), SI         // SI: &f
+    BYTE $0xc4; BYTE $0x63; BYTE $0x3d; BYTE $0x38; BYTE $0x06   // VINSERTI128 YMM8, YMM8, [rsi], 1  /* Y8 = t[0]+t[1]+f[0]+f[1] */
+                BYTE $0x01
+    BYTE $0xc4; BYTE $0xc1; BYTE $0x65; BYTE $0xef; BYTE $0xd8   // VPXOR   YMM3,YMM3,YMM8            /* Y3 = Y3 ^ Y8 */
+
+    BYTE $0xc5; BYTE $0x7e; BYTE $0x6f; BYTE $0x12               // VMOVDQU YMM10, [rdx]              /* Y10 =  m[0]+ m[1]+ m[2]+ m[3] */
+    BYTE $0xc5; BYTE $0x7e; BYTE $0x6f; BYTE $0x5a; BYTE $0x20   // VMOVDQU YMM11, 32[rdx]            /* Y11 =  m[4]+ m[5]+ m[6]+ m[7] */
+    BYTE $0xc5; BYTE $0x7e; BYTE $0x6f; BYTE $0x62; BYTE $0x40   // VMOVDQU YMM12, 64[rdx]            /* Y12 =  m[8]+ m[9]+m[10]+m[11] */
+    BYTE $0xc5; BYTE $0x7e; BYTE $0x6f; BYTE $0x6a; BYTE $0x60   // VMOVDQU YMM13, 96[rdx]            /* Y13 = m[12]+m[13]+m[14]+m[15] */
+
+    LOAD_SHUFFLE
+
+    ///////////////////////////////////////////////////////////////////////////
+    // R O U N D   1
+    ///////////////////////////////////////////////////////////////////////////
+
+    BYTE $0xc4; BYTE $0xc1; BYTE $0x2d; BYTE $0x6c; BYTE $0xe3   // VPUNPCKLQDQ  YMM4, YMM10, YMM11 /* m[0], m[4], m[2], m[6] */
+    BYTE $0xc4; BYTE $0xc1; BYTE $0x2d; BYTE $0x6d; BYTE $0xeb   // VPUNPCKHQDQ  YMM5, YMM10, YMM11 /* m[1], m[5], m[3], m[7] */
+    BYTE $0xc4; BYTE $0xe3; BYTE $0xfd; BYTE $0x00; BYTE $0xe4   // VPERMQ       YMM4, YMM4, 0xd8   /* 0x1101 1000 = 0xd8 */
+                BYTE $0xd8
+    BYTE $0xc4; BYTE $0xe3; BYTE $0xfd; BYTE $0x00; BYTE $0xed   // VPERMQ       YMM5, YMM5, 0xd8   /* 0x1101 1000 = 0xd8 */
+                BYTE $0xd8
+
+    G1
+    G2
+
+    DIAGONALIZE
+
+    BYTE $0xc4; BYTE $0xc1; BYTE $0x1d; BYTE $0x6c; BYTE $0xe5   // VPUNPCKLQDQ  YMM4, YMM12, YMM13 /* m[8], m[12], m[10], m[14] */
+    BYTE $0xc4; BYTE $0xc1; BYTE $0x1d; BYTE $0x6d; BYTE $0xed   // VPUNPCKHQDQ  YMM5, YMM12, YMM13 /* m[9], m[13], m[11], m[15] */
+    BYTE $0xc4; BYTE $0xe3; BYTE $0xfd; BYTE $0x00; BYTE $0xe4   // VPERMQ       YMM4, YMM4, 0xd8   /* 0x1101 1000 = 0xd8 */
+                BYTE $0xd8
+    BYTE $0xc4; BYTE $0xe3; BYTE $0xfd; BYTE $0x00; BYTE $0xed   // VPERMQ       YMM5, YMM5, 0xd8   /* 0x1101 1000 = 0xd8 */
+                BYTE $0xd8
+
+    G1
+    G2
+
+    UNDIAGONALIZE
+
+    ///////////////////////////////////////////////////////////////////////////
+    // R O U N D   2
+    ///////////////////////////////////////////////////////////////////////////
+
+    BYTE $0xc4; BYTE $0x41; BYTE $0x25; BYTE $0x6c; BYTE $0xc5   // VPUNPCKLQDQ  YMM8, YMM11, YMM13        /*  m[4],  ____,  ____, m[14] */
+    BYTE $0xc4; BYTE $0x43; BYTE $0xfd; BYTE $0x00; BYTE $0xc0   // VPERMQ       YMM8,  YMM8, 0x03         /* m[14],  m[4],  ____,  ____ */ /* xxxx 0011 = 0x03 */
+                BYTE $0x03
+    BYTE $0xc4; BYTE $0x41; BYTE $0x1d; BYTE $0x6d; BYTE $0xcd   // VPUNPCKHQDQ  YMM9, YMM12, YMM13        /*  m[9], m[13],  ____,  ____ */
+    BYTE $0xc4; BYTE $0xc3; BYTE $0x3d; BYTE $0x46; BYTE $0xe1   // VPERM2I128   YMM4,  YMM8,  YMM9, 0x20  /*  m[9], m[13],  ____,  ____ */ /* 0010 0000 = 0x20 */
+                BYTE $0x20
+
+    BYTE $0xc4; BYTE $0x43; BYTE $0xfd; BYTE $0x00; BYTE $0xc4   // VPERMQ       YMM8,  YMM12, 0x02        /* m[10],  m[8],  ____,  ____ */ /* xxxx 0010 = 0x02 */
+                BYTE $0x02
+    BYTE $0xc4; BYTE $0x43; BYTE $0xfd; BYTE $0x00; BYTE $0xcd   // VPERMQ       YMM9,  YMM13, 0x30        /*  ____,  ____, m[15],  ____ */ /* xx11 xxxx = 0x30 */
+                BYTE $0x30
+    BYTE $0xc4; BYTE $0x41; BYTE $0x35; BYTE $0x6c; BYTE $0xcb   // VPUNPCKLQDQ  YMM9,   YMM9, YMM11       /*  ____,  ____, m[15],  m[6] */
+    BYTE $0xc4; BYTE $0xc3; BYTE $0x3d; BYTE $0x46; BYTE $0xe9   // VPERM2I128   YMM5,   YMM8, YMM9, 0x30  /*  m[9], m[13], m[15],  m[6] */ /* 0011 0000 = 0x30 */
+                BYTE $0x30
+
+    G1
+    G2
+
+    DIAGONALIZE
+
+    BYTE $0xc4; BYTE $0x43; BYTE $0xfd; BYTE $0x00; BYTE $0xc2   // VPERMQ       YMM8, YMM10, 0x01         /*  m[1],  m[0],  ____,  ____ */ /* xxxx 0001 = 0x01 */
+                BYTE $0x01
+    BYTE $0xc4; BYTE $0x41; BYTE $0x25; BYTE $0x6d; BYTE $0xcc   // VPUNPCKHQDQ  YMM9, YMM11, YMM12        /*  m[5],  ____,  ____, m[11] */
+    BYTE $0xc4; BYTE $0x43; BYTE $0xfd; BYTE $0x00; BYTE $0xc9   // VPERMQ       YMM9,  YMM9, 0x03         /* m[11],  m[5],  ____,  ____ */ /* xxxx 0011 = 0x03 */
+                BYTE $0x03
+    BYTE $0xc4; BYTE $0xc3; BYTE $0x3d; BYTE $0x46; BYTE $0xe1   // VPERM2I128   YMM4,  YMM8, YMM9, 0x20   /*  m[1],  m[0], m[11],  m[5] */ /* 0010 0000 = 0x20 */
+                BYTE $0x20
+
+    BYTE $0xc4; BYTE $0x41; BYTE $0x2d; BYTE $0x6c; BYTE $0xc5   // VPUNPCKLQDQ  YMM8, YMM10, YMM13        /*  ___,  m[12],  m[2],  ____ */
+    BYTE $0xc4; BYTE $0x43; BYTE $0xfd; BYTE $0x00; BYTE $0xc0   // VPERMQ       YMM8,  YMM8, 0x09         /* m[12],  m[2],  ____,  ____ */ /* xxxx 1001 = 0x09 */
+                BYTE $0x09
+    BYTE $0xc4; BYTE $0x41; BYTE $0x25; BYTE $0x6d; BYTE $0xca   // VPUNPCKHQDQ  YMM9, YMM11, YMM10        /*  ____,  ____,  m[7],  m[3] */
+    BYTE $0xc4; BYTE $0xc3; BYTE $0x3d; BYTE $0x46; BYTE $0xe9   // VPERM2I128   YMM5,  YMM8, YMM9, 0x30   /*  m[9], m[13], m[15],  m[6] */ /* 0011 0000 = 0x30 */
+                BYTE $0x30
+
+    G1
+    G2
+
+    UNDIAGONALIZE
+
+    ///////////////////////////////////////////////////////////////////////////
+    // R O U N D   3
+    ///////////////////////////////////////////////////////////////////////////
+
+    BYTE $0xc4; BYTE $0x43; BYTE $0xfd; BYTE $0x00; BYTE $0xc5   // VPERMQ       YMM8, YMM13, 0x00
+                BYTE $0x00
+    BYTE $0xc4; BYTE $0x41; BYTE $0x1d; BYTE $0x6d; BYTE $0xc0   // VPUNPCKHQDQ  YMM8, YMM12, YMM8
+    BYTE $0xc4; BYTE $0x41; BYTE $0x25; BYTE $0x6d; BYTE $0xcd   // VPUNPCKHQDQ  YMM9, YMM11, YMM13
+    BYTE $0xc4; BYTE $0x43; BYTE $0xfd; BYTE $0x00; BYTE $0xc9   // VPERMQ       YMM9, YMM9, 0x0c
+                BYTE $0x0c
+    BYTE $0xc4; BYTE $0xc3; BYTE $0x3d; BYTE $0x46; BYTE $0xe1   // VPERM2I128   YMM4, YMM8, YMM9, 0x21
+                BYTE $0x21
+
+    BYTE $0xc4; BYTE $0x41; BYTE $0x1d; BYTE $0x6c; BYTE $0xc2   // VPUNPCKLQDQ  YMM8, YMM12, YMM10
+    BYTE $0xc4; BYTE $0x43; BYTE $0xfd; BYTE $0x00; BYTE $0xcd   // VPERMQ       YMM9, YMM13, 0x55
+                BYTE $0x55
+    BYTE $0xc4; BYTE $0x41; BYTE $0x2d; BYTE $0x6c; BYTE $0xc9   // VPUNPCKLQDQ  YMM9, YMM10, YMM9
+    BYTE $0xc4; BYTE $0xc3; BYTE $0x3d; BYTE $0x46; BYTE $0xe9   // VPERM2I128   YMM5, YMM8, YMM9, 0x30
+                BYTE $0x30
+
+    G1
+    G2
+
+    DIAGONALIZE
+
+    BYTE $0xc4; BYTE $0x43; BYTE $0xfd; BYTE $0x00; BYTE $0xc2   // VPERMQ       YMM8, YMM10, 0xff
+                BYTE $0xff
+    BYTE $0xc4; BYTE $0x41; BYTE $0x1d; BYTE $0x6c; BYTE $0xc0   // VPUNPCKLQDQ  YMM8, YMM12, YMM8
+    BYTE $0xc4; BYTE $0x41; BYTE $0x25; BYTE $0x6d; BYTE $0xcc   // VPUNPCKHQDQ  YMM9, YMM11, YMM12
+    BYTE $0xc4; BYTE $0x43; BYTE $0xfd; BYTE $0x00; BYTE $0xc9   // VPERMQ       YMM9, YMM9, 0x60
+                BYTE $0x60
+    BYTE $0xc4; BYTE $0xc3; BYTE $0x3d; BYTE $0x46; BYTE $0xe1   // VPERM2I128   YMM4, YMM8, YMM9, 0x31
+                BYTE $0x31
+
+    BYTE $0xc4; BYTE $0x41; BYTE $0x15; BYTE $0x6c; BYTE $0xc3   // VPUNPCKLQDQ  YMM8, YMM13, YMM11
+    BYTE $0xc4; BYTE $0x43; BYTE $0xfd; BYTE $0x00; BYTE $0xcb   // VPERMQ       YMM9, YMM11, 0x00
+                BYTE $0x00
+    BYTE $0xc4; BYTE $0x41; BYTE $0x2d; BYTE $0x6d; BYTE $0xc9   // VPUNPCKHQDQ  YMM9, YMM10, YMM9
+    BYTE $0xc4; BYTE $0xc3; BYTE $0x3d; BYTE $0x46; BYTE $0xe9   // VPERM2I128   YMM5, YMM8, YMM9, 0x21
+                BYTE $0x21
+
+    G1
+    G2
+
+    UNDIAGONALIZE
+
+    ///////////////////////////////////////////////////////////////////////////
+    // R O U N D   4
+    ///////////////////////////////////////////////////////////////////////////
+
+    BYTE $0xc4; BYTE $0x41; BYTE $0x25; BYTE $0x6d; BYTE $0xc2   // VPUNPCKHQDQ  YMM8, YMM11, YMM10
+    BYTE $0xc4; BYTE $0x41; BYTE $0x15; BYTE $0x6d; BYTE $0xcc   // VPUNPCKHQDQ  YMM9, YMM13, YMM12
+    BYTE $0xc4; BYTE $0x43; BYTE $0xfd; BYTE $0x00; BYTE $0xc9   // VPERMQ       YMM9, YMM9, 0x0c
+                BYTE $0x0c
+    BYTE $0xc4; BYTE $0xc3; BYTE $0x3d; BYTE $0x46; BYTE $0xe1   // VPERM2I128   YMM4, YMM8, YMM9, 0x21
+                BYTE $0x21
+
+    BYTE $0xc4; BYTE $0x41; BYTE $0x1d; BYTE $0x6d; BYTE $0xc2   // VPUNPCKHQDQ  YMM8, YMM12, YMM10
+    BYTE $0xc4; BYTE $0x43; BYTE $0xfd; BYTE $0x00; BYTE $0xcd   // VPERMQ       YMM9, YMM13, 0x08
+                BYTE $0x08
+    BYTE $0xc4; BYTE $0xc3; BYTE $0x3d; BYTE $0x46; BYTE $0xe9   // VPERM2I128   YMM5, YMM8, YMM9, 0x20
+                BYTE $0x20
+
+    G1
+    G2
+
+    DIAGONALIZE
+
+    BYTE $0xc4; BYTE $0x43; BYTE $0xfd; BYTE $0x00; BYTE $0xc3   // VPERMQ       YMM8, YMM11, 0x55
+                BYTE $0x55
+    BYTE $0xc4; BYTE $0x41; BYTE $0x2d; BYTE $0x6c; BYTE $0xc0   // VPUNPCKLQDQ  YMM8, YMM10, YMM8
+    BYTE $0xc4; BYTE $0x43; BYTE $0xfd; BYTE $0x00; BYTE $0xcd   // VPERMQ       YMM9, YMM13, 0xff
+                BYTE $0xff
+    BYTE $0xc4; BYTE $0x41; BYTE $0x25; BYTE $0x6c; BYTE $0xc9   // VPUNPCKLQDQ  YMM9, YMM11, YMM9
+    BYTE $0xc4; BYTE $0xc3; BYTE $0x3d; BYTE $0x46; BYTE $0xe1   // VPERM2I128   YMM4, YMM8, YMM9, 0x21
+                BYTE $0x21
+
+    BYTE $0xc4; BYTE $0x41; BYTE $0x25; BYTE $0x6c; BYTE $0xc4   // VPUNPCKLQDQ  YMM8, YMM11, YMM12
+    BYTE $0xc4; BYTE $0x41; BYTE $0x2d; BYTE $0x6c; BYTE $0xcc   // VPUNPCKLQDQ  YMM9, YMM10, YMM12
+    BYTE $0xc4; BYTE $0xc3; BYTE $0x3d; BYTE $0x46; BYTE $0xe9   // VPERM2I128   YMM5, YMM8, YMM9, 0x21
+                BYTE $0x21
+
+    G1
+    G2
+
+    UNDIAGONALIZE
+
+    ///////////////////////////////////////////////////////////////////////////
+    // R O U N D   5
+    ///////////////////////////////////////////////////////////////////////////
+
+    BYTE $0xc4; BYTE $0x41; BYTE $0x1d; BYTE $0x6d; BYTE $0xc3   // VPUNPCKHQDQ  YMM8, YMM12, YMM11
+    BYTE $0xc4; BYTE $0x41; BYTE $0x2d; BYTE $0x6c; BYTE $0xcc   // VPUNPCKLQDQ  YMM9, YMM10, YMM12
+    BYTE $0xc4; BYTE $0xc3; BYTE $0x3d; BYTE $0x46; BYTE $0xe1   // VPERM2I128   YMM4, YMM8, YMM9, 0x30
+                BYTE $0x30
+
+    BYTE $0xc4; BYTE $0x43; BYTE $0xfd; BYTE $0x00; BYTE $0xc3   // VPERMQ       YMM8, YMM11, 0xff
+                BYTE $0xff
+    BYTE $0xc4; BYTE $0x41; BYTE $0x2d; BYTE $0x6c; BYTE $0xc0   // VPUNPCKLQDQ  YMM8, YMM10, YMM8
+    BYTE $0xc4; BYTE $0x43; BYTE $0xfd; BYTE $0x00; BYTE $0xcd   // VPERMQ       YMM9, YMM13, 0xff
+                BYTE $0xff
+    BYTE $0xc4; BYTE $0x41; BYTE $0x25; BYTE $0x6c; BYTE $0xc9   // VPUNPCKLQDQ  YMM9, YMM11, YMM9
+    BYTE $0xc4; BYTE $0xc3; BYTE $0x3d; BYTE $0x46; BYTE $0xe9   // VPERM2I128   YMM5, YMM8, YMM9, 0x20
+                BYTE $0x20
+
+    G1
+    G2
+
+    DIAGONALIZE
+
+    BYTE $0xc4; BYTE $0x43; BYTE $0xfd; BYTE $0x00; BYTE $0xc4   // VPERMQ       YMM8, YMM12, 0xff
+                BYTE $0xff
+    BYTE $0xc4; BYTE $0x41; BYTE $0x15; BYTE $0x6c; BYTE $0xc0   // VPUNPCKLQDQ  YMM8, YMM13, YMM8
+    BYTE $0xc4; BYTE $0x43; BYTE $0xfd; BYTE $0x00; BYTE $0xca   // VPERMQ       YMM9, YMM10, 0xff
+                BYTE $0xff
+    BYTE $0xc4; BYTE $0x41; BYTE $0x25; BYTE $0x6c; BYTE $0xc9   // VPUNPCKLQDQ  YMM9, YMM11, YMM9
+    BYTE $0xc4; BYTE $0xc3; BYTE $0x3d; BYTE $0x46; BYTE $0xe1   // VPERM2I128   YMM4, YMM8, YMM9, 0x31
+                BYTE $0x31
+
+    BYTE $0xc4; BYTE $0x43; BYTE $0xfd; BYTE $0x00; BYTE $0xc5   // VPERMQ       YMM8, YMM13, 0x00
+                BYTE $0x00
+    BYTE $0xc4; BYTE $0x41; BYTE $0x2d; BYTE $0x6d; BYTE $0xc0   // VPUNPCKHQDQ  YMM8, YMM10, YMM8
+    BYTE $0xc4; BYTE $0x43; BYTE $0xfd; BYTE $0x00; BYTE $0xcd   // VPERMQ       YMM9, YMM13, 0x55
+                BYTE $0x55
+    BYTE $0xc4; BYTE $0x41; BYTE $0x1d; BYTE $0x6c; BYTE $0xc9   // VPUNPCKLQDQ  YMM9, YMM12, YMM9
+    BYTE $0xc4; BYTE $0xc3; BYTE $0x3d; BYTE $0x46; BYTE $0xe9   // VPERM2I128   YMM5, YMM8, YMM9, 0x20
+                BYTE $0x20
+
+    G1
+    G2
+
+    UNDIAGONALIZE
+
+    ///////////////////////////////////////////////////////////////////////////
+    // R O U N D   6
+    ///////////////////////////////////////////////////////////////////////////
+
+    BYTE $0xc4; BYTE $0x41; BYTE $0x2d; BYTE $0x6c; BYTE $0xc3   // VPUNPCKLQDQ  YMM8, YMM10, YMM11
+    BYTE $0xc4; BYTE $0x41; BYTE $0x2d; BYTE $0x6c; BYTE $0xcc   // VPUNPCKLQDQ  YMM9, YMM10, YMM12
+    BYTE $0xc4; BYTE $0xc3; BYTE $0x3d; BYTE $0x46; BYTE $0xe1   // VPERM2I128   YMM4, YMM8, YMM9, 0x21
+                BYTE $0x21
+
+    BYTE $0xc4; BYTE $0x41; BYTE $0x15; BYTE $0x6c; BYTE $0xc4   // VPUNPCKLQDQ  YMM8, YMM13, YMM12
+    BYTE $0xc4; BYTE $0x43; BYTE $0xfd; BYTE $0x00; BYTE $0xc0   // VPERMQ       YMM8, YMM8, 0x0c
+                BYTE $0x0c
+    BYTE $0xc4; BYTE $0x41; BYTE $0x1d; BYTE $0x6d; BYTE $0xca   // VPUNPCKHQDQ  YMM9, YMM12, YMM10
+    BYTE $0xc4; BYTE $0xc3; BYTE $0x3d; BYTE $0x46; BYTE $0xe9   // VPERM2I128   YMM5, YMM8, YMM9, 0x30
+                BYTE $0x30
+
+    G1
+    G2
+
+    DIAGONALIZE
+
+    BYTE $0xc4; BYTE $0x43; BYTE $0xfd; BYTE $0x00; BYTE $0xc3   // VPERMQ       YMM8, YMM11, 0x0c
+                BYTE $0x0c
+    BYTE $0xc4; BYTE $0x41; BYTE $0x15; BYTE $0x6d; BYTE $0xca   // VPUNPCKHQDQ  YMM9, YMM13, YMM10
+    BYTE $0xc4; BYTE $0x43; BYTE $0xfd; BYTE $0x00; BYTE $0xc9   // VPERMQ       YMM9, YMM9, 0x60
+                BYTE $0x60
+    BYTE $0xc4; BYTE $0xc3; BYTE $0x3d; BYTE $0x46; BYTE $0xe1   // VPERM2I128   YMM4, YMM8, YMM9, 0x30
+                BYTE $0x30
+
+    BYTE $0xc4; BYTE $0x41; BYTE $0x15; BYTE $0x6d; BYTE $0xc3   // VPUNPCKHQDQ  YMM8, YMM13, YMM11
+    BYTE $0xc4; BYTE $0x43; BYTE $0xfd; BYTE $0x00; BYTE $0xcc   // VPERMQ       YMM9, YMM12, 0x55
+                BYTE $0x55
+    BYTE $0xc4; BYTE $0x41; BYTE $0x15; BYTE $0x6c; BYTE $0xc9   // VPUNPCKLQDQ  YMM9, YMM13, YMM9
+    BYTE $0xc4; BYTE $0xc3; BYTE $0x3d; BYTE $0x46; BYTE $0xe9   // VPERM2I128   YMM5, YMM8, YMM9, 0x30
+                BYTE $0x30
+
+    G1
+    G2
+
+    UNDIAGONALIZE
+
+    ///////////////////////////////////////////////////////////////////////////
+    // R O U N D   7
+    ///////////////////////////////////////////////////////////////////////////
+
+    BYTE $0xc4; BYTE $0x43; BYTE $0xfd; BYTE $0x00; BYTE $0xc2   // VPERMQ       YMM8, YMM10, 0x55
+                BYTE $0x55
+    BYTE $0xc4; BYTE $0x41; BYTE $0x15; BYTE $0x6c; BYTE $0xc0   // VPUNPCKLQDQ  YMM8, YMM13, YMM8
+    BYTE $0xc4; BYTE $0x41; BYTE $0x15; BYTE $0x6c; BYTE $0xcb   // VPUNPCKLQDQ  YMM9, YMM13, YMM11
+    BYTE $0xc4; BYTE $0x43; BYTE $0xfd; BYTE $0x00; BYTE $0xc9   // VPERMQ       YMM9, YMM9, 0x60
+                BYTE $0x60
+    BYTE $0xc4; BYTE $0xc3; BYTE $0x3d; BYTE $0x46; BYTE $0xe1   // VPERM2I128   YMM4, YMM8, YMM9, 0x30
+                BYTE $0x30
+
+    BYTE $0xc4; BYTE $0x41; BYTE $0x25; BYTE $0x6d; BYTE $0xc5   // VPUNPCKHQDQ  YMM8, YMM11, YMM13
+    BYTE $0xc4; BYTE $0x43; BYTE $0xfd; BYTE $0x00; BYTE $0xc0   // VPERMQ       YMM8, YMM8, 0x0c
+                BYTE $0x0c
+    BYTE $0xc4; BYTE $0x43; BYTE $0xfd; BYTE $0x00; BYTE $0xcc   // VPERMQ       YMM9, YMM12, 0xaa
+                BYTE $0xaa
+    BYTE $0xc4; BYTE $0x41; BYTE $0x15; BYTE $0x6d; BYTE $0xc9   // VPUNPCKHQDQ  YMM9, YMM13, YMM9
+    BYTE $0xc4; BYTE $0xc3; BYTE $0x3d; BYTE $0x46; BYTE $0xe9   // VPERM2I128   YMM5, YMM8, YMM9, 0x20
+                BYTE $0x20
+
+    G1
+    G2
+
+    DIAGONALIZE
+
+    BYTE $0xc4; BYTE $0x41; BYTE $0x2d; BYTE $0x6c; BYTE $0xc3   // VPUNPCKLQDQ  YMM8, YMM10, YMM11
+    BYTE $0xc4; BYTE $0x43; BYTE $0xfd; BYTE $0x00; BYTE $0xc0   // VPERMQ       YMM8, YMM8, 0x0c
+                BYTE $0x0c
+    BYTE $0xc4; BYTE $0x43; BYTE $0xfd; BYTE $0x00; BYTE $0xcc   // VPERMQ       YMM9, YMM12, 0x01
+                BYTE $0x01
+    BYTE $0xc4; BYTE $0xc3; BYTE $0x3d; BYTE $0x46; BYTE $0xe1   // VPERM2I128   YMM4, YMM8, YMM9, 0x20
+                BYTE $0x20
+
+    BYTE $0xc4; BYTE $0x41; BYTE $0x25; BYTE $0x6d; BYTE $0xc2   // VPUNPCKHQDQ  YMM8, YMM11, YMM10
+    BYTE $0xc4; BYTE $0x43; BYTE $0xfd; BYTE $0x00; BYTE $0xcc   // VPERMQ       YMM9, YMM12, 0xff
+                BYTE $0xff
+    BYTE $0xc4; BYTE $0x41; BYTE $0x2d; BYTE $0x6c; BYTE $0xc9   // VPUNPCKLQDQ  YMM9, YMM10, YMM9
+    BYTE $0xc4; BYTE $0xc3; BYTE $0x3d; BYTE $0x46; BYTE $0xe9   // VPERM2I128   YMM5, YMM8, YMM9, 0x31
+                BYTE $0x31
+
+    G1
+    G2
+
+    UNDIAGONALIZE
+
+    ///////////////////////////////////////////////////////////////////////////
+    // R O U N D   8
+    ///////////////////////////////////////////////////////////////////////////
+
+    BYTE $0xc4; BYTE $0x41; BYTE $0x15; BYTE $0x6d; BYTE $0xc3   // VPUNPCKHQDQ  YMM8, YMM13, YMM11
+    BYTE $0xc4; BYTE $0x43; BYTE $0xfd; BYTE $0x00; BYTE $0xc0   // VPERMQ       YMM8, YMM8, 0x0c
+                BYTE $0x0c
+    BYTE $0xc4; BYTE $0x43; BYTE $0xfd; BYTE $0x00; BYTE $0xca   // VPERMQ       YMM9, YMM10, 0xff
+                BYTE $0xff
+    BYTE $0xc4; BYTE $0x41; BYTE $0x15; BYTE $0x6c; BYTE $0xc9   // VPUNPCKLQDQ  YMM9, YMM13, YMM9
+    BYTE $0xc4; BYTE $0xc3; BYTE $0x3d; BYTE $0x46; BYTE $0xe1   // VPERM2I128   YMM4, YMM8, YMM9, 0x20
+                BYTE $0x20
+
+    BYTE $0xc4; BYTE $0x43; BYTE $0xfd; BYTE $0x00; BYTE $0xc5   // VPERMQ       YMM8, YMM13, 0xaa
+                BYTE $0xaa
+    BYTE $0xc4; BYTE $0x41; BYTE $0x1d; BYTE $0x6d; BYTE $0xc0   // VPUNPCKHQDQ  YMM8, YMM12, YMM8
+    BYTE $0xc4; BYTE $0x41; BYTE $0x2d; BYTE $0x6d; BYTE $0xcc   // VPUNPCKHQDQ  YMM9, YMM10, YMM12
+    BYTE $0xc4; BYTE $0xc3; BYTE $0x3d; BYTE $0x46; BYTE $0xe9   // VPERM2I128   YMM5, YMM8, YMM9, 0x21
+                BYTE $0x21
+
+    G1
+    G2
+
+    DIAGONALIZE
+
+    BYTE $0xc4; BYTE $0x41; BYTE $0x25; BYTE $0x6d; BYTE $0xc5   // VPUNPCKHQDQ  YMM8, YMM11, YMM13
+    BYTE $0xc4; BYTE $0x43; BYTE $0xfd; BYTE $0x00; BYTE $0xc0   // VPERMQ       YMM8, YMM8, 0x0c
+                BYTE $0x0c
+    BYTE $0xc4; BYTE $0x41; BYTE $0x1d; BYTE $0x6c; BYTE $0xca   // VPUNPCKLQDQ  YMM9, YMM12, YMM10
+    BYTE $0xc4; BYTE $0x43; BYTE $0xfd; BYTE $0x00; BYTE $0xc9   // VPERMQ       YMM9, YMM9, 0x0c
+                BYTE $0x0c
+    BYTE $0xc4; BYTE $0xc3; BYTE $0x3d; BYTE $0x46; BYTE $0xe1   // VPERM2I128   YMM4, YMM8, YMM9, 0x20
+                BYTE $0x20
+
+    BYTE $0xc4; BYTE $0x41; BYTE $0x2d; BYTE $0x6c; BYTE $0xc3   // VPUNPCKLQDQ  YMM8, YMM10, YMM11
+    BYTE $0xc4; BYTE $0x41; BYTE $0x25; BYTE $0x6c; BYTE $0xcc   // VPUNPCKLQDQ  YMM9, YMM11, YMM12
+    BYTE $0xc4; BYTE $0xc3; BYTE $0x3d; BYTE $0x46; BYTE $0xe9   // VPERM2I128   YMM5, YMM8, YMM9, 0x30
+                BYTE $0x30
+
+    G1
+    G2
+
+    UNDIAGONALIZE
+
+    ///////////////////////////////////////////////////////////////////////////
+    // R O U N D   9
+    ///////////////////////////////////////////////////////////////////////////
+
+    BYTE $0xc4; BYTE $0x41; BYTE $0x25; BYTE $0x6c; BYTE $0xc5   // VPUNPCKLQDQ  YMM8, YMM11, YMM13
+    BYTE $0xc4; BYTE $0x43; BYTE $0xfd; BYTE $0x00; BYTE $0xca   // VPERMQ       YMM9, YMM10, 0x00
+                BYTE $0x00
+    BYTE $0xc4; BYTE $0x41; BYTE $0x1d; BYTE $0x6d; BYTE $0xc9   // VPUNPCKHQDQ  YMM9, YMM12, YMM9
+    BYTE $0xc4; BYTE $0xc3; BYTE $0x3d; BYTE $0x46; BYTE $0xe1   // VPERM2I128   YMM4, YMM8, YMM9, 0x31
+                BYTE $0x31
+
+    BYTE $0xc4; BYTE $0x41; BYTE $0x15; BYTE $0x6d; BYTE $0xc4   // VPUNPCKHQDQ  YMM8, YMM13, YMM12
+    BYTE $0xc4; BYTE $0x43; BYTE $0xfd; BYTE $0x00; BYTE $0xc0   // VPERMQ       YMM8, YMM8, 0x60
+                BYTE $0x60
+    BYTE $0xc4; BYTE $0x43; BYTE $0xfd; BYTE $0x00; BYTE $0xcc   // VPERMQ       YMM9, YMM12, 0x00
+                BYTE $0x00
+    BYTE $0xc4; BYTE $0x41; BYTE $0x2d; BYTE $0x6d; BYTE $0xc9   // VPUNPCKHQDQ  YMM9, YMM10, YMM9
+    BYTE $0xc4; BYTE $0xc3; BYTE $0x3d; BYTE $0x46; BYTE $0xe9   // VPERM2I128   YMM5, YMM8, YMM9, 0x31
+                BYTE $0x31
+
+    G1
+    G2
+
+    DIAGONALIZE
+
+    BYTE $0xc4; BYTE $0x43; BYTE $0xfd; BYTE $0x00; BYTE $0xcc   // VPERMQ       YMM9, YMM12, 0xaa
+                BYTE $0xaa
+    BYTE $0xc4; BYTE $0x41; BYTE $0x2d; BYTE $0x6d; BYTE $0xc9   // VPUNPCKHQDQ  YMM9, YMM10, YMM9
+    BYTE $0xc4; BYTE $0xc3; BYTE $0x15; BYTE $0x46; BYTE $0xe1   // VPERM2I128   YMM4, YMM13, YMM9, 0x20
+                BYTE $0x20
+
+    BYTE $0xc4; BYTE $0x43; BYTE $0xfd; BYTE $0x00; BYTE $0xc3   // VPERMQ       YMM8, YMM11, 0xff
+                BYTE $0xff
+    BYTE $0xc4; BYTE $0x41; BYTE $0x2d; BYTE $0x6c; BYTE $0xc0   // VPUNPCKLQDQ  YMM8, YMM10, YMM8
+    BYTE $0xc4; BYTE $0x43; BYTE $0xfd; BYTE $0x00; BYTE $0xcb   // VPERMQ       YMM9, YMM11, 0x04
+                BYTE $0x04
+    BYTE $0xc4; BYTE $0xc3; BYTE $0x3d; BYTE $0x46; BYTE $0xe9   // VPERM2I128   YMM5, YMM8, YMM9, 0x21
+                BYTE $0x21
+
+    G1
+    G2
+
+    UNDIAGONALIZE
+
+    ///////////////////////////////////////////////////////////////////////////
+    // R O U N D   10
+    ///////////////////////////////////////////////////////////////////////////
+
+    BYTE $0xc4; BYTE $0x43; BYTE $0xfd; BYTE $0x00; BYTE $0xc4   // VPERMQ       YMM8, YMM12, 0x20
+                BYTE $0x20
+    BYTE $0xc4; BYTE $0x41; BYTE $0x25; BYTE $0x6d; BYTE $0xca   // VPUNPCKHQDQ  YMM9, YMM11, YMM10
+    BYTE $0xc4; BYTE $0x43; BYTE $0xfd; BYTE $0x00; BYTE $0xc9   // VPERMQ       YMM9, YMM9, 0x60
+                BYTE $0x60
+    BYTE $0xc4; BYTE $0xc3; BYTE $0x3d; BYTE $0x46; BYTE $0xe1   // VPERM2I128   YMM4, YMM8, YMM9, 0x31
+                BYTE $0x31
+
+    BYTE $0xc4; BYTE $0x41; BYTE $0x2d; BYTE $0x6c; BYTE $0xc3   // VPUNPCKLQDQ  YMM8, YMM10, YMM11
+    BYTE $0xc4; BYTE $0x43; BYTE $0xfd; BYTE $0x00; BYTE $0xc0   // VPERMQ       YMM8, YMM8, 0x60
+                BYTE $0x60
+    BYTE $0xc4; BYTE $0x43; BYTE $0xfd; BYTE $0x00; BYTE $0xcb   // VPERMQ       YMM9, YMM11, 0x60
+                BYTE $0x60
+    BYTE $0xc4; BYTE $0xc3; BYTE $0x3d; BYTE $0x46; BYTE $0xe9   // VPERM2I128   YMM5, YMM8, YMM9, 0x31
+                BYTE $0x31
+
+    G1
+    G2
+
+    DIAGONALIZE
+
+    BYTE $0xc4; BYTE $0x41; BYTE $0x15; BYTE $0x6d; BYTE $0xc4   // VPUNPCKHQDQ  YMM8, YMM13, YMM12
+    BYTE $0xc4; BYTE $0x43; BYTE $0xfd; BYTE $0x00; BYTE $0xc0   // VPERMQ       YMM8, YMM8, 0x60
+                BYTE $0x60
+    BYTE $0xc4; BYTE $0x41; BYTE $0x2d; BYTE $0x6d; BYTE $0xcd   // VPUNPCKHQDQ  YMM9, YMM10, YMM13
+    BYTE $0xc4; BYTE $0x43; BYTE $0xfd; BYTE $0x00; BYTE $0xc9   // VPERMQ       YMM9, YMM9, 0x60
+                BYTE $0x60
+    BYTE $0xc4; BYTE $0xc3; BYTE $0x3d; BYTE $0x46; BYTE $0xe1   // VPERM2I128   YMM4, YMM8, YMM9, 0x31
+                BYTE $0x31
+
+    BYTE $0xc4; BYTE $0x43; BYTE $0xfd; BYTE $0x00; BYTE $0xc5   // VPERMQ       YMM8, YMM13, 0xaa
+                BYTE $0xaa
+    BYTE $0xc4; BYTE $0x41; BYTE $0x1d; BYTE $0x6d; BYTE $0xc0   // VPUNPCKHQDQ  YMM8, YMM12, YMM8
+    BYTE $0xc4; BYTE $0x41; BYTE $0x15; BYTE $0x6c; BYTE $0xca   // VPUNPCKLQDQ  YMM9, YMM13, YMM10
+    BYTE $0xc4; BYTE $0xc3; BYTE $0x3d; BYTE $0x46; BYTE $0xe9   // VPERM2I128   YMM5, YMM8, YMM9, 0x21
+                BYTE $0x21
+                                                                 
+    G1
+    G2
+
+    UNDIAGONALIZE
+
+    ///////////////////////////////////////////////////////////////////////////
+    // R O U N D   1 1
+    ///////////////////////////////////////////////////////////////////////////
+
+    BYTE $0xc4; BYTE $0xc1; BYTE $0x2d; BYTE $0x6c; BYTE $0xe3   // VPUNPCKLQDQ  YMM4, YMM10, YMM11 /* m[0], m[4], m[2], m[6] */
+    BYTE $0xc4; BYTE $0xc1; BYTE $0x2d; BYTE $0x6d; BYTE $0xeb   // VPUNPCKHQDQ  YMM5, YMM10, YMM11 /* m[1], m[5], m[3], m[7] */
+    BYTE $0xc4; BYTE $0xe3; BYTE $0xfd; BYTE $0x00; BYTE $0xe4   // VPERMQ       YMM4, YMM4, 0xd8   /* 0x1101 1000 = 0xd8 */
+                BYTE $0xd8
+    BYTE $0xc4; BYTE $0xe3; BYTE $0xfd; BYTE $0x00; BYTE $0xed   // VPERMQ       YMM5, YMM5, 0xd8   /* 0x1101 1000 = 0xd8 */
+                BYTE $0xd8
+
+    G1
+    G2
+
+    DIAGONALIZE
+
+    BYTE $0xc4; BYTE $0xc1; BYTE $0x1d; BYTE $0x6c; BYTE $0xe5   // VPUNPCKLQDQ  YMM4, YMM12, YMM13 /* m[8], m[12], m[10], m[14] */
+    BYTE $0xc4; BYTE $0xc1; BYTE $0x1d; BYTE $0x6d; BYTE $0xed   // VPUNPCKHQDQ  YMM5, YMM12, YMM13 /* m[9], m[13], m[11], m[15] */
+    BYTE $0xc4; BYTE $0xe3; BYTE $0xfd; BYTE $0x00; BYTE $0xe4   // VPERMQ       YMM4, YMM4, 0xd8   /* 0x1101 1000 = 0xd8 */
+                BYTE $0xd8
+    BYTE $0xc4; BYTE $0xe3; BYTE $0xfd; BYTE $0x00; BYTE $0xed   // VPERMQ       YMM5, YMM5, 0xd8   /* 0x1101 1000 = 0xd8 */
+                BYTE $0xd8
+
+    G1
+    G2
+
+    UNDIAGONALIZE
+
+    ///////////////////////////////////////////////////////////////////////////
+    // R O U N D   1 2
+    ///////////////////////////////////////////////////////////////////////////
+
+    BYTE $0xc4; BYTE $0x41; BYTE $0x25; BYTE $0x6c; BYTE $0xc5   // VPUNPCKLQDQ  YMM8, YMM11, YMM13        /*  m[4],  ____,  ____, m[14] */
+    BYTE $0xc4; BYTE $0x43; BYTE $0xfd; BYTE $0x00; BYTE $0xc0   // VPERMQ       YMM8,  YMM8, 0x03         /* m[14],  m[4],  ____,  ____ */ /* xxxx 0011 = 0x03 */
+                BYTE $0x03
+    BYTE $0xc4; BYTE $0x41; BYTE $0x1d; BYTE $0x6d; BYTE $0xcd   // VPUNPCKHQDQ  YMM9, YMM12, YMM13        /*  m[9], m[13],  ____,  ____ */
+    BYTE $0xc4; BYTE $0xc3; BYTE $0x3d; BYTE $0x46; BYTE $0xe1   // VPERM2I128   YMM4,  YMM8,  YMM9, 0x20  /*  m[9], m[13],  ____,  ____ */ /* 0010 0000 = 0x20 */
+                BYTE $0x20
+
+    BYTE $0xc4; BYTE $0x43; BYTE $0xfd; BYTE $0x00; BYTE $0xc4   // VPERMQ       YMM8,  YMM12, 0x02        /* m[10],  m[8],  ____,  ____ */ /* xxxx 0010 = 0x02 */
+                BYTE $0x02
+    BYTE $0xc4; BYTE $0x43; BYTE $0xfd; BYTE $0x00; BYTE $0xcd   // VPERMQ       YMM9,  YMM13, 0x30        /*  ____,  ____, m[15],  ____ */ /* xx11 xxxx = 0x30 */
+                BYTE $0x30
+    BYTE $0xc4; BYTE $0x41; BYTE $0x35; BYTE $0x6c; BYTE $0xcb   // VPUNPCKLQDQ  YMM9,   YMM9, YMM11       /*  ____,  ____, m[15],  m[6] */
+    BYTE $0xc4; BYTE $0xc3; BYTE $0x3d; BYTE $0x46; BYTE $0xe9   // VPERM2I128   YMM5,   YMM8, YMM9, 0x30  /*  m[9], m[13], m[15],  m[6] */ /* 0011 0000 = 0x30 */
+                BYTE $0x30
+
+    G1
+    G2
+
+    DIAGONALIZE
+
+    BYTE $0xc4; BYTE $0x43; BYTE $0xfd; BYTE $0x00; BYTE $0xc2   // VPERMQ       YMM8, YMM10, 0x01         /*  m[1],  m[0],  ____,  ____ */ /* xxxx 0001 = 0x01 */
+                BYTE $0x01
+    BYTE $0xc4; BYTE $0x41; BYTE $0x25; BYTE $0x6d; BYTE $0xcc   // VPUNPCKHQDQ  YMM9, YMM11, YMM12        /*  m[5],  ____,  ____, m[11] */
+    BYTE $0xc4; BYTE $0x43; BYTE $0xfd; BYTE $0x00; BYTE $0xc9   // VPERMQ       YMM9,  YMM9, 0x03         /* m[11],  m[5],  ____,  ____ */ /* xxxx 0011 = 0x03 */
+                BYTE $0x03
+    BYTE $0xc4; BYTE $0xc3; BYTE $0x3d; BYTE $0x46; BYTE $0xe1   // VPERM2I128   YMM4,  YMM8, YMM9, 0x20   /*  m[1],  m[0], m[11],  m[5] */ /* 0010 0000 = 0x20 */
+                BYTE $0x20
+
+    BYTE $0xc4; BYTE $0x41; BYTE $0x2d; BYTE $0x6c; BYTE $0xc5   // VPUNPCKLQDQ  YMM8, YMM10, YMM13        /*  ___,  m[12],  m[2],  ____ */
+    BYTE $0xc4; BYTE $0x43; BYTE $0xfd; BYTE $0x00; BYTE $0xc0   // VPERMQ       YMM8,  YMM8, 0x09         /* m[12],  m[2],  ____,  ____ */ /* xxxx 1001 = 0x09 */
+                BYTE $0x09
+    BYTE $0xc4; BYTE $0x41; BYTE $0x25; BYTE $0x6d; BYTE $0xca   // VPUNPCKHQDQ  YMM9, YMM11, YMM10        /*  ____,  ____,  m[7],  m[3] */
+    BYTE $0xc4; BYTE $0xc3; BYTE $0x3d; BYTE $0x46; BYTE $0xe9   // VPERM2I128   YMM5,  YMM8, YMM9, 0x30   /*  m[9], m[13], m[15],  m[6] */ /* 0011 0000 = 0x30 */
+                BYTE $0x30
+
+    G1
+    G2
+
+    UNDIAGONALIZE
+
+    // Reload digest (most current value store in &out)
+    MOVQ  out+144(FP),  SI    // SI: &in
+    BYTE $0xc5; BYTE $0x7e; BYTE $0x6f; BYTE $0x26               // VMOVDQU YMM12, [rsi]
+    BYTE $0xc5; BYTE $0x7e; BYTE $0x6f; BYTE $0x6e; BYTE $0x20   // VMOVDQU YMM13, 32[rsi]
+
+    BYTE $0xc5; BYTE $0xfd; BYTE $0xef; BYTE $0xc2               // VPXOR   YMM0,YMM0,YMM2   /* X0 = X0 ^ X4,  X1 = X1 ^ X5 */
+    BYTE $0xc4; BYTE $0xc1; BYTE $0x7d; BYTE $0xef; BYTE $0xc4   // VPXOR   YMM0,YMM0,YMM12  /* X0 = X0 ^ X12, X1 = X1 ^ X13 */
+    BYTE $0xc5; BYTE $0xf5; BYTE $0xef; BYTE $0xcb               // VPXOR   YMM1,YMM1,YMM3   /* X2 = X2 ^ X6,  X3 = X3 ^ X7 */
+    BYTE $0xc4; BYTE $0xc1; BYTE $0x75; BYTE $0xef; BYTE $0xcd   // VPXOR   YMM1,YMM1,YMM13  /* X2 = X2 ^ X14, X3 = X3 ^ X15 */
+
+    // Store digest into &out
+    MOVQ  out+144(FP), SI     // SI: &out
+    BYTE $0xc5; BYTE $0xfe; BYTE $0x7f; BYTE $0x06               // VMOVDQU [rsi], YMM0
+    BYTE $0xc5; BYTE $0xfe; BYTE $0x7f; BYTE $0x4e; BYTE $0x20   // VMOVDQU 32[rsi], YMM1
+
+    // Increment message pointer and check if there's more to do
+    ADDQ   $128, DX           // message += 128
+    SUBQ   $1, R8
+    JNZ    loop
+
+complete:
+    BYTE $0xc5; BYTE $0xf8; BYTE $0x77                           // VZEROUPPER  /* Prevent further context switches */
+    RET
+

diff --git a/vendor/github.com/minio/blake2b-simd/compressAvx_amd64.go b/vendor/github.com/minio/blake2b-simd/compressAvx_amd64.go
new file mode 100644 (file)
index 0000000..cfa12c0
--- /dev/null
+++ b/vendor/github.com/minio/blake2b-simd/compressAvx_amd64.go
@@ -0,0 +1,41 @@
+//+build !noasm
+//+build !appengine
+
+/*
+ * Minio Cloud Storage, (C) 2016 Minio, Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package blake2b
+
+//go:noescape
+func blockAVXLoop(p []uint8, in, iv, t, f, shffle, out []uint64)
+
+func compressAVX(d *digest, p []uint8) {
+       var (
+               in     [8]uint64
+               out    [8]uint64
+               shffle [2]uint64
+       )
+
+       // vector for PSHUFB instruction
+       shffle[0] = 0x0201000706050403
+       shffle[1] = 0x0a09080f0e0d0c0b
+
+       in[0], in[1], in[2], in[3], in[4], in[5], in[6], in[7] = d.h[0], d.h[1], d.h[2], d.h[3], d.h[4], d.h[5], d.h[6], d.h[7]
+
+       blockAVXLoop(p, in[:], iv[:], d.t[:], d.f[:], shffle[:], out[:])
+
+       d.h[0], d.h[1], d.h[2], d.h[3], d.h[4], d.h[5], d.h[6], d.h[7] = out[0], out[1], out[2], out[3], out[4], out[5], out[6], out[7]
+}

diff --git a/vendor/github.com/minio/blake2b-simd/compressAvx_amd64.s b/vendor/github.com/minio/blake2b-simd/compressAvx_amd64.s
new file mode 100644 (file)
index 0000000..f68e173
--- /dev/null
+++ b/vendor/github.com/minio/blake2b-simd/compressAvx_amd64.s
@@ -0,0 +1,682 @@
+//+build !noasm !appengine
+
+//
+// Minio Cloud Storage, (C) 2016 Minio, Inc.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+
+//
+// Based on SSE implementation from https://github.com/BLAKE2/BLAKE2/blob/master/sse/blake2b.c
+//
+// Use github.com/fwessels/asm2plan9s on this file to assemble instructions to their Plan9 equivalent
+//
+// Assembly code below essentially follows the ROUND macro (see blake2b-round.h) which is defined as:
+//   #define ROUND(r) \
+//     LOAD_MSG_ ##r ##_1(b0, b1); \
+//     G1(row1l,row2l,row3l,row4l,row1h,row2h,row3h,row4h,b0,b1); \
+//     LOAD_MSG_ ##r ##_2(b0, b1); \
+//     G2(row1l,row2l,row3l,row4l,row1h,row2h,row3h,row4h,b0,b1); \
+//     DIAGONALIZE(row1l,row2l,row3l,row4l,row1h,row2h,row3h,row4h); \
+//     LOAD_MSG_ ##r ##_3(b0, b1); \
+//     G1(row1l,row2l,row3l,row4l,row1h,row2h,row3h,row4h,b0,b1); \
+//     LOAD_MSG_ ##r ##_4(b0, b1); \
+//     G2(row1l,row2l,row3l,row4l,row1h,row2h,row3h,row4h,b0,b1); \
+//     UNDIAGONALIZE(row1l,row2l,row3l,row4l,row1h,row2h,row3h,row4h);
+//
+// as well as the go equivalent in https://github.com/dchest/blake2b/blob/master/block.go
+//
+// As in the macro, G1/G2 in the 1st and 2nd half are identical (so literal copy of assembly)
+//
+// Rounds are also the same, except for the loading of the message (and rounds 1 & 11 and
+// rounds 2 & 12 are identical)
+//
+
+#define G1 \
+       \ // G1(row1l,row2l,row3l,row4l,row1h,row2h,row3h,row4h,b0,b1);
+       LONG $0xd479c1c4; BYTE $0xc0 \ // VPADDQ  XMM0,XMM0,XMM8   /* v0 += m[0], v1 += m[2] */
+       LONG $0xd471c1c4; BYTE $0xc9 \ // VPADDQ  XMM1,XMM1,XMM9   /* v2 += m[4], v3 += m[6] */
+       LONG $0xc2d4f9c5             \ // VPADDQ  XMM0,XMM0,XMM2   /* v0 += v4, v1 += v5 */
+       LONG $0xcbd4f1c5             \ // VPADDQ  XMM1,XMM1,XMM3   /* v2 += v6, v3 += v7 */
+       LONG $0xf0efc9c5             \ // VPXOR   XMM6,XMM6,XMM0   /* v12 ^= v0, v13 ^= v1 */
+       LONG $0xf9efc1c5             \ // VPXOR   XMM7,XMM7,XMM1   /* v14 ^= v2, v15 ^= v3 */
+       LONG $0xf670f9c5; BYTE $0xb1 \ // VPSHUFD XMM6,XMM6,0xb1   /* v12 = v12<<(64-32) | v12>>32, v13 = v13<<(64-32) | v13>>32 */
+       LONG $0xff70f9c5; BYTE $0xb1 \ // VPSHUFD XMM7,XMM7,0xb1   /* v14 = v14<<(64-32) | v14>>32, v15 = v15<<(64-32) | v15>>32 */
+       LONG $0xe6d4d9c5             \ // VPADDQ  XMM4,XMM4,XMM6   /* v8 += v12, v9 += v13  */
+       LONG $0xefd4d1c5             \ // VPADDQ  XMM5,XMM5,XMM7   /* v10 += v14, v11 += v15 */
+       LONG $0xd4efe9c5             \ // VPXOR   XMM2,XMM2,XMM4   /* v4 ^= v8, v5 ^= v9 */
+       LONG $0xddefe1c5             \ // VPXOR   XMM3,XMM3,XMM5   /* v6 ^= v10, v7 ^= v11 */
+       LONG $0x0069c2c4; BYTE $0xd4 \ // VPSHUFB XMM2,XMM2,XMM12  /* v4 = v4<<(64-24) | v4>>24, v5 = v5<<(64-24) | v5>>24 */
+       LONG $0x0061c2c4; BYTE $0xdc   // VPSHUFB XMM3,XMM3,XMM12  /* v6 = v6<<(64-24) | v6>>24, v7 = v7<<(64-24) | v7>>24 */
+
+#define G2 \
+       \ // G2(row1l,row2l,row3l,row4l,row1h,row2h,row3h,row4h,b0,b1);
+       LONG $0xd479c1c4; BYTE $0xc2 \ // VPADDQ  XMM0,XMM0,XMM10  /* v0 += m[1], v1 += m[3] */
+       LONG $0xd471c1c4; BYTE $0xcb \ // VPADDQ  XMM1,XMM1,XMM11  /* v2 += m[5], v3 += m[7] */
+       LONG $0xc2d4f9c5             \ // VPADDQ  XMM0,XMM0,XMM2   /* v0 += v4, v1 += v5 */
+       LONG $0xcbd4f1c5             \ // VPADDQ  XMM1,XMM1,XMM3   /* v2 += v6, v3 += v7 */
+       LONG $0xf0efc9c5             \ // VPXOR   XMM6,XMM6,XMM0   /* v12 ^= v0, v13 ^= v1 */
+       LONG $0xf9efc1c5             \ // VPXOR   XMM7,XMM7,XMM1   /* v14 ^= v2, v15 ^= v3 */
+       LONG $0xf670fbc5; BYTE $0x39 \ // VPSHUFLW XMM6,XMM6,0x39  /* combined with next ... */
+       LONG $0xf670fac5; BYTE $0x39 \ // VPSHUFHW XMM6,XMM6,0x39  /* v12 = v12<<(64-16) | v12>>16, v13 = v13<<(64-16) | v13>>16 */
+       LONG $0xff70fbc5; BYTE $0x39 \ // VPSHUFLW XMM7,XMM7,0x39  /* combined with next ... */
+       LONG $0xff70fac5; BYTE $0x39 \ // VPSHUFHW XMM7,XMM7,0x39  /* v14 = v14<<(64-16) | v14>>16, v15 = v15<<(64-16) | v15>>16 */
+       LONG $0xe6d4d9c5             \ // VPADDQ  XMM4,XMM4,XMM6   /* v8 += v12, v9 += v13 */
+       LONG $0xefd4d1c5             \ // VPADDQ  XMM5,XMM5,XMM7   /* v10 += v14, v11 += v15 */
+       LONG $0xd4efe9c5             \ // VPXOR   XMM2,XMM2,XMM4   /* v4 ^= v8, v5 ^= v9 */
+       LONG $0xddefe1c5             \ // VPXOR   XMM3,XMM3,XMM5   /* v6 ^= v10, v7 ^= v11 */
+       LONG $0xfad469c5             \ // VPADDQ  XMM15,XMM2,XMM2  /* temp reg = reg*2   */
+       LONG $0xd273e9c5; BYTE $0x3f \ // VPSRLQ  XMM2,XMM2,0x3f   /*      reg = reg>>63 */
+       LONG $0xef69c1c4; BYTE $0xd7 \ // VPXOR   XMM2,XMM2,XMM15  /* ORed together: v4 = v4<<(64-63) | v4>>63, v5 = v5<<(64-63) | v5>>63 */
+       LONG $0xfbd461c5             \ // VPADDQ XMM15,XMM3,XMM3   /* temp reg = reg*2   */
+       LONG $0xd373e1c5; BYTE $0x3f \ // VPSRLQ XMM3,XMM3,0x3f    /*      reg = reg>>63 */
+       LONG $0xef61c1c4; BYTE $0xdf   // VPXOR  XMM3,XMM3,XMM15   /* ORed together: v6 = v6<<(64-63) | v6>>63, v7 = v7<<(64-63) | v7>>63 */
+
+#define DIAGONALIZE \
+       \ // DIAGONALIZE(row1l,row2l,row3l,row4l,row1h,row2h,row3h,row4h);
+       MOVOU X6, X13                \                                     /* t0 = row4l;\                                                            */
+       MOVOU X2, X14                \                                     /* t1 = row2l;\                                                            */
+       MOVOU X4, X6                 \                                     /* row4l = row3l;\                                                         */
+       MOVOU X5, X4                 \                                     /* row3l = row3h;\                                                         */
+       MOVOU X6, X5                 \                                     /* row3h = row4l;\                                                         */
+       LONG $0x6c1141c4; BYTE $0xfd \ // VPUNPCKLQDQ XMM15, XMM13, XMM13  /*                                    _mm_unpacklo_epi64(t0, t0)           */
+       LONG $0x6d41c1c4; BYTE $0xf7 \ // VPUNPCKHQDQ  XMM6,  XMM7, XMM15  /*  row4l = _mm_unpackhi_epi64(row4h,                           ); \       */
+       LONG $0xff6c41c5             \ // VPUNPCKLQDQ XMM15,  XMM7,  XMM7  /*                                 _mm_unpacklo_epi64(row4h, row4h)        */
+       LONG $0x6d11c1c4; BYTE $0xff \ // VPUNPCKHQDQ  XMM7, XMM13, XMM15  /*  row4h = _mm_unpackhi_epi64(t0,                                 ); \    */
+       LONG $0xfb6c61c5             \ // VPUNPCKLQDQ XMM15,  XMM3,  XMM3  /*                                    _mm_unpacklo_epi64(row2h, row2h)     */
+       LONG $0x6d69c1c4; BYTE $0xd7 \ // VPUNPCKHQDQ  XMM2,  XMM2, XMM15  /*  row2l = _mm_unpackhi_epi64(row2l,                                 ); \ */
+       LONG $0x6c0941c4; BYTE $0xfe \ // VPUNPCKLQDQ XMM15, XMM14, XMM14  /*                                    _mm_unpacklo_epi64(t1, t1)           */
+       LONG $0x6d61c1c4; BYTE $0xdf   // VPUNPCKHQDQ  XMM3,  XMM3, XMM15  /*  row2h = _mm_unpackhi_epi64(row2h,                           )          */
+
+#define UNDIAGONALIZE \
+       \ // UNDIAGONALIZE(row1l,row2l,row3l,row4l,row1h,row2h,row3h,row4h);
+       MOVOU X4, X13                \                                     /* t0 = row3l;\                                                            */
+       MOVOU X5, X4                 \                                     /* row3l = row3h;\                                                         */
+       MOVOU X13, X5                \                                     /* row3h = t0;\                                                            */
+       MOVOU X2, X13                \                                     /* t0 = row2l;\                                                            */
+       MOVOU X6, X14                \                                     /* t1 = row4l;\                                                            */
+       LONG $0xfa6c69c5             \ // VPUNPCKLQDQ XMM15,  XMM2,  XMM2  /*                                    _mm_unpacklo_epi64(row2l, row2l)     */
+       LONG $0x6d61c1c4; BYTE $0xd7 \ // VPUNPCKHQDQ  XMM2,  XMM3, XMM15  /*  row2l = _mm_unpackhi_epi64(row2h,                                 ); \ */
+       LONG $0xfb6c61c5             \ // VPUNPCKLQDQ XMM15,  XMM3,  XMM3  /*                                 _mm_unpacklo_epi64(row2h, row2h)        */
+       LONG $0x6d11c1c4; BYTE $0xdf \ // VPUNPCKHQDQ  XMM3, XMM13, XMM15  /*  row2h = _mm_unpackhi_epi64(t0,                                 ); \    */
+       LONG $0xff6c41c5             \ // VPUNPCKLQDQ XMM15,  XMM7,  XMM7  /*                                    _mm_unpacklo_epi64(row4h, row4h)     */
+       LONG $0x6d49c1c4; BYTE $0xf7 \ // VPUNPCKHQDQ  XMM6,  XMM6, XMM15  /*  row4l = _mm_unpackhi_epi64(row4l,                                 ); \ */
+       LONG $0x6c0941c4; BYTE $0xfe \ // VPUNPCKLQDQ XMM15, XMM14, XMM14  /*                                    _mm_unpacklo_epi64(t1, t1)           */
+       LONG $0x6d41c1c4; BYTE $0xff   // VPUNPCKHQDQ  XMM7,  XMM7, XMM15  /*  row4h = _mm_unpackhi_epi64(row4h,                           )          */
+
+#define LOAD_SHUFFLE \
+       \ // Load shuffle value
+       MOVQ  shffle+120(FP), SI \ // SI: &shuffle
+       MOVOU 0(SI), X12           // X12 = 03040506 07000102 0b0c0d0e 0f08090a
+
+// func blockAVXLoop(p []uint8, in, iv, t, f, shffle, out []uint64)
+TEXT ·blockAVXLoop(SB), 7, $0
+       // REGISTER USE
+       //        R8: loop counter
+       //        DX: message pointer
+       //        SI: temp pointer for loading
+       //  X0 -  X7: v0 - v15
+       //  X8 - X11: m[0] - m[7]
+       //       X12: shuffle value
+       // X13 - X15: temp registers
+
+       // Load digest
+       MOVQ  in+24(FP), SI // SI: &in
+       MOVOU 0(SI), X0     // X0 = in[0]+in[1]      /* row1l = LOAD( &S->h[0] ); */
+       MOVOU 16(SI), X1    // X1 = in[2]+in[3]      /* row1h = LOAD( &S->h[2] ); */
+       MOVOU 32(SI), X2    // X2 = in[4]+in[5]      /* row2l = LOAD( &S->h[4] ); */
+       MOVOU 48(SI), X3    // X3 = in[6]+in[7]      /* row2h = LOAD( &S->h[6] ); */
+
+       // Already store digest into &out (so we can reload it later generically)
+       MOVQ  out+144(FP), SI // SI: &out
+       MOVOU X0, 0(SI)       // out[0]+out[1] = X0
+       MOVOU X1, 16(SI)      // out[2]+out[3] = X1
+       MOVOU X2, 32(SI)      // out[4]+out[5] = X2
+       MOVOU X3, 48(SI)      // out[6]+out[7] = X3
+
+       // Initialize message pointer and loop counter
+       MOVQ message+0(FP), DX     // DX: &p (message)
+       MOVQ message_len+8(FP), R8 // R8: len(message)
+       SHRQ $7, R8                // len(message) / 128
+       CMPQ R8, $0
+       JEQ  complete
+
+loop:
+       // Increment counter
+       MOVQ t+72(FP), SI // SI: &t
+       MOVQ 0(SI), R9
+       ADDQ $128, R9     // /* d.t[0] += BlockSize */
+       MOVQ R9, 0(SI)
+       CMPQ R9, $128     // /* if d.t[0] < BlockSize { */
+       JGE  noincr
+       MOVQ 8(SI), R9
+       ADDQ $1, R9       // /*     d.t[1]++ */
+       MOVQ R9, 8(SI)
+noincr:               // /* } */
+
+       // Load initialization vector
+       MOVQ  iv+48(FP), SI // SI: &iv
+       MOVOU 0(SI), X4     // X4 = iv[0]+iv[1]      /* row3l = LOAD( &blake2b_IV[0] );                                    */
+       MOVOU 16(SI), X5    // X5 = iv[2]+iv[3]      /* row3h = LOAD( &blake2b_IV[2] );                                    */
+       MOVOU 32(SI), X6    // X6 = iv[4]+iv[5]      /*                        LOAD( &blake2b_IV[4] )                      */
+       MOVOU 48(SI), X7    // X7 = iv[6]+iv[7]      /*                        LOAD( &blake2b_IV[6] )                      */
+       MOVQ  t+72(FP), SI  // SI: &t
+       MOVOU 0(SI), X8     // X8 = t[0]+t[1]        /*                                                LOAD( &S->t[0] )    */
+       PXOR  X8, X6        // X6 = X6 ^ X8          /* row4l = _mm_xor_si128(                       ,                  ); */
+       MOVQ  t+96(FP), SI  // SI: &f
+       MOVOU 0(SI), X8     // X8 = f[0]+f[1]        /*                                                LOAD( &S->f[0] )    */
+       PXOR  X8, X7        // X7 = X7 ^ X8          /* row4h = _mm_xor_si128(                       ,                  ); */
+
+       ///////////////////////////////////////////////////////////////////////////
+       // R O U N D   1
+       ///////////////////////////////////////////////////////////////////////////
+
+       // LOAD_MSG_ ##r ##_1 / ##_2(b0, b1); (X12 is temp register)
+       MOVOU 0(DX), X12             // X12 = m[0]+m[1]
+       MOVOU 16(DX), X13            // X13 = m[2]+m[3]
+       MOVOU 32(DX), X14            // X14 = m[4]+m[5]
+       MOVOU 48(DX), X15            // X15 = m[6]+m[7]
+       LONG $0x6c1941c4; BYTE $0xc5 // VPUNPCKLQDQ  XMM8, XMM12, XMM13  /* m[0], m[2] */
+       LONG $0x6c0941c4; BYTE $0xcf // VPUNPCKLQDQ  XMM9, XMM14, XMM15  /* m[4], m[6] */
+       LONG $0x6d1941c4; BYTE $0xd5 // VPUNPCKHQDQ XMM10, XMM12, XMM13  /* m[1], m[3] */
+       LONG $0x6d0941c4; BYTE $0xdf // VPUNPCKHQDQ XMM11, XMM14, XMM15  /* m[5], m[7] */
+
+       LOAD_SHUFFLE
+       G1
+       G2
+       DIAGONALIZE
+
+       // LOAD_MSG_ ##r ##_3 / ##_4(b0, b1); (X12 is temp register)
+       MOVOU 64(DX), X12            // X12 =  m[8]+ m[9]
+       MOVOU 80(DX), X13            // X13 = m[10]+m[11]
+       MOVOU 96(DX), X14            // X14 = m[12]+m[13]
+       MOVOU 112(DX), X15           // X15 = m[14]+m[15]
+       LONG $0x6c1941c4; BYTE $0xc5 // VPUNPCKLQDQ  XMM8, XMM12, XMM13  /*  m[8],m[10] */
+       LONG $0x6c0941c4; BYTE $0xcf // VPUNPCKLQDQ  XMM9, XMM14, XMM15  /* m[12],m[14] */
+       LONG $0x6d1941c4; BYTE $0xd5 // VPUNPCKHQDQ XMM10, XMM12, XMM13  /*  m[9],m[11] */
+       LONG $0x6d0941c4; BYTE $0xdf // VPUNPCKHQDQ XMM11, XMM14, XMM15  /* m[13],m[15] */
+
+       LOAD_SHUFFLE
+       G1
+       G2
+       UNDIAGONALIZE
+
+       ///////////////////////////////////////////////////////////////////////////
+       // R O U N D   2
+       ///////////////////////////////////////////////////////////////////////////
+
+       // LOAD_MSG_ ##r ##_1 / ##_2(b0, b1); (X12 is temp register)
+       MOVOU 112(DX), X12             // X12 = m[14]+m[15]
+       MOVOU 32(DX), X13              // X13 =  m[4]+ m[5]
+       MOVOU 64(DX), X14              // X14 =  m[8]+ m[9]
+       MOVOU 96(DX), X15              // X15 = m[12]+m[13]
+       LONG $0x6c1941c4; BYTE $0xc5   // VPUNPCKLQDQ  XMM8, XMM12, XMM13  /* m[14],  m[4] */
+       LONG $0x6d0941c4; BYTE $0xcf   // VPUNPCKHQDQ  XMM9, XMM14, XMM15  /*  m[9], m[13] */
+       MOVOU 80(DX), X13              // X13 = m[10]+m[11]
+       MOVOU 48(DX), X15              // X15 =  m[6]+ m[7]
+       LONG $0x6c1141c4; BYTE $0xd6   // VPUNPCKLQDQ XMM10, XMM13, XMM14  /* m[10],  m[8] */
+       LONG $0x0f0143c4; WORD $0x08dc // VPALIGNR    XMM11, XMM15, XMM12, 0x8  /* m[15],  m[6] */
+
+       LOAD_SHUFFLE
+       G1
+       G2
+       DIAGONALIZE
+
+       // LOAD_MSG_ ##r ##_3 / ##_4(b0, b1); (X12 is temp register)
+       MOVOU 0(DX), X12               // X12 =  m[0]+ m[1]
+       MOVOU 32(DX), X13              // X13 =  m[4]+ m[5]
+       MOVOU 80(DX), X14              // X14 = m[10]+m[11]
+       LONG $0x0f1943c4; WORD $0x08c4 // VPALIGNR     XMM8, XMM12, XMM12, 0x8  /*  m[1],  m[0] */
+       LONG $0x6d0941c4; BYTE $0xcd   // VPUNPCKHQDQ  XMM9, XMM14, XMM13  /* m[11], m[5] */
+       MOVOU 16(DX), X12              // X12 =  m[2]+ m[3]
+       MOVOU 48(DX), X13              // X13 =  m[6]+ m[7]
+       MOVOU 96(DX), X14              // X14 = m[12]+m[13]
+       LONG $0x6c0941c4; BYTE $0xd4   // VPUNPCKLQDQ XMM10, XMM14, XMM12  /* m[12], m[2] */
+       LONG $0x6d1141c4; BYTE $0xdc   // VPUNPCKHQDQ XMM11, XMM13, XMM12  /*  m[7], m[3] */
+
+       LOAD_SHUFFLE
+       G1
+       G2
+       UNDIAGONALIZE
+
+       ///////////////////////////////////////////////////////////////////////////
+       // R O U N D   3
+       ///////////////////////////////////////////////////////////////////////////
+
+       // LOAD_MSG_ ##r ##_1 / ##_2(b0, b1); (X12 is temp register)
+       MOVOU 32(DX), X12              // X12 =  m[4]+ m[5]
+       MOVOU 80(DX), X13              // X13 = m[10]+m[11]
+       MOVOU 96(DX), X14              // X14 = m[12]+m[13]
+       MOVOU 112(DX), X15             // X15 = m[14]+m[15]
+       LONG $0x0f0943c4; WORD $0x08c5 // VPALIGNR     XMM8, XMM14, XMM13, 0x8  /* m[11],  m[12] */
+       LONG $0x6d1941c4; BYTE $0xcf   // VPUNPCKHQDQ  XMM9, XMM12, XMM15  /*  m[5], m[15] */
+       MOVOU 0(DX), X12               // X12 =  m[0]+ m[1]
+       MOVOU 16(DX), X13              // X13 =  m[2]+ m[3]
+       MOVOU 64(DX), X15              // X15 =  m[8]+ m[9]
+       LONG $0x6c0141c4; BYTE $0xd4   // VPUNPCKLQDQ XMM10, XMM15, XMM12  /*  m[8],  m[0] */
+       LONG $0x6d0941c4; BYTE $0xde   // VPUNPCKHQDQ XMM11, XMM14, XMM14  /*   ___, m[13] */
+       LONG $0x6c1141c4; BYTE $0xdb   // VPUNPCKLQDQ XMM11, XMM13, XMM11  /*  m[2],   ___ */
+
+       LOAD_SHUFFLE
+       G1
+       G2
+       DIAGONALIZE
+
+       // LOAD_MSG_ ##r ##_3 / ##_4(b0, b1); (X12 is temp register)
+       MOVOU 16(DX), X12               // X12 =  m[2]+ m[3]
+       MOVOU 48(DX), X13               // X13 =  m[6]+ m[7]
+       MOVOU 64(DX), X14               // X14 =  m[8]+ m[9]
+       MOVOU 80(DX), X15               // X15 = m[10]+m[11]
+       LONG  $0x6d1941c4; BYTE $0xc4   // VPUNPCKHQDQ  XMM8, XMM12, XMM12  /*   ___, m[3] */
+       LONG  $0x6c0141c4; BYTE $0xc0   // VPUNPCKLQDQ  XMM8, XMM15,  XMM8  /* m[10],  ___ */
+       LONG  $0x6d1141c4; BYTE $0xce   // VPUNPCKHQDQ  XMM9, XMM13, XMM14  /*  m[7], m[9] */
+       MOVOU 0(DX), X12                // X12 =  m[0]+ m[1]
+       MOVOU 32(DX), X14               // X14 =  m[4]+ m[5]
+       MOVOU 112(DX), X15              // X15 = m[14]+m[15]
+       LONG  $0x6c0141c4; BYTE $0xd5   // VPUNPCKLQDQ XMM10, XMM15, XMM13  /* m[14], m[6] */
+       LONG  $0x0f0943c4; WORD $0x08dc // VPALIGNR    XMM11, XMM14, XMM12, 0x8  /*  m[1],  m[4] */
+
+       LOAD_SHUFFLE
+       G1
+       G2
+       UNDIAGONALIZE
+
+       ///////////////////////////////////////////////////////////////////////////
+       // R O U N D   4
+       ///////////////////////////////////////////////////////////////////////////
+
+       // LOAD_MSG_ ##r ##_1 / ##_2(b0, b1); (X12 is temp register)
+       MOVOU 16(DX), X12             // X12 =  m[2]+ m[3]
+       MOVOU 48(DX), X13             // X13 =  m[6]+ m[7]
+       MOVOU 80(DX), X14             // X14 = m[10]+m[11]
+       MOVOU 96(DX), X15             // X15 = m[12]+m[13]
+       LONG  $0x6d1141c4; BYTE $0xc4 // VPUNPCKHQDQ  XMM8, XMM13, XMM12  /*  m[7],  m[3] */
+       LONG  $0x6d0141c4; BYTE $0xce // VPUNPCKHQDQ  XMM9, XMM15, XMM14  /* m[13], m[11] */
+       MOVOU 0(DX), X12              // X12 =  m[0]+ m[1]
+       MOVOU 64(DX), X13             // X13 =  m[8]+ m[9]
+       MOVOU 112(DX), X14            // X14 = m[14]+m[15]
+       LONG  $0x6d1141c4; BYTE $0xd4 // VPUNPCKHQDQ XMM10, XMM13, XMM12  /*  m[9],  m[1] */
+       LONG  $0x6c0141c4; BYTE $0xde // VPUNPCKLQDQ XMM11, XMM15, XMM14  /* m[12], m[14] */
+
+       LOAD_SHUFFLE
+       G1
+       G2
+       DIAGONALIZE
+
+       // LOAD_MSG_ ##r ##_3 / ##_4(b0, b1); (X12 is temp register)
+       MOVOU 16(DX), X12             // X12 =  m[2]+ m[3]
+       MOVOU 32(DX), X13             // X13 =  m[4]+ m[5]
+       MOVOU 80(DX), X14             // X14 = m[10]+m[11]
+       MOVOU 112(DX), X15            // X15 = m[14]+m[15]
+       LONG  $0x6d1141c4; BYTE $0xc5 // VPUNPCKHQDQ  XMM8, XMM13, XMM13  /*   ___,  m[5] */
+       LONG  $0x6c1941c4; BYTE $0xc0 // VPUNPCKLQDQ  XMM8, XMM12,  XMM8  /*  m[2],  ____ */
+       LONG  $0x6d0141c4; BYTE $0xcf // VPUNPCKHQDQ  XMM9, XMM15, XMM15  /*   ___, m[15] */
+       LONG  $0x6c1141c4; BYTE $0xc9 // VPUNPCKLQDQ  XMM9, XMM13,  XMM9  /*  m[4],  ____ */
+       MOVOU 0(DX), X12              // X12 =  m[0]+ m[1]
+       MOVOU 48(DX), X13             // X13 =  m[6]+ m[7]
+       MOVOU 64(DX), X15             // X15 =  m[8]+ m[9]
+       LONG  $0x6c1141c4; BYTE $0xd6 // VPUNPCKLQDQ XMM10, XMM13, XMM14  /*  m[6], m[10] */
+       LONG  $0x6c1941c4; BYTE $0xdf // VPUNPCKLQDQ XMM11, XMM12, XMM15  /*  m[0],  m[8] */
+
+       LOAD_SHUFFLE
+       G1
+       G2
+       UNDIAGONALIZE
+
+       ///////////////////////////////////////////////////////////////////////////
+       // R O U N D   5
+       ///////////////////////////////////////////////////////////////////////////
+
+       // LOAD_MSG_ ##r ##_1 / ##_2(b0, b1); (X12 is temp register)
+       MOVOU 16(DX), X12            // X12 =  m[2]+ m[3]
+       MOVOU 32(DX), X13            // X13 =  m[4]+ m[5]
+       MOVOU 64(DX), X14            // X14 =  m[8]+ m[9]
+       MOVOU 80(DX), X15            // X15 = m[10]+m[11]
+       LONG $0x6d0941c4; BYTE $0xc5 // VPUNPCKHQDQ  XMM8, XMM14, XMM13  /*  m[9],  m[5] */
+       LONG $0x6c1941c4; BYTE $0xcf // VPUNPCKLQDQ  XMM9, XMM12, XMM15  /*  m[2], m[10] */
+       MOVOU 0(DX), X12             // X12 =  m[0]+ m[1]
+       MOVOU 48(DX), X14            // X14 =  m[6]+ m[7]
+       MOVOU 112(DX), X15           // X15 = m[14]+m[15]
+       LONG $0x6d0941c4; BYTE $0xd6 // VPUNPCKHQDQ XMM10, XMM14, XMM14  /*   ___,  m[7] */
+       LONG $0x6c1941c4; BYTE $0xd2 // VPUNPCKLQDQ XMM10, XMM12, XMM10  /*  m[0],  ____ */
+       LONG $0x6d0141c4; BYTE $0xdf // VPUNPCKHQDQ XMM11, XMM15, XMM15  /*   ___, m[15] */
+       LONG $0x6c1141c4; BYTE $0xdb // VPUNPCKLQDQ XMM11, XMM13, XMM11  /*  m[4],  ____ */
+
+       LOAD_SHUFFLE
+       G1
+       G2
+       DIAGONALIZE
+
+       // LOAD_MSG_ ##r ##_3 / ##_4(b0, b1); (X12 is temp register)
+       MOVOU 16(DX), X12              // X12 =  m[2]+ m[3]
+       MOVOU 48(DX), X13              // X13 =  m[6]+ m[7]
+       MOVOU 80(DX), X14              // X14 = m[10]+m[11]
+       MOVOU 112(DX), X15             // X15 = m[14]+m[15]
+       LONG $0x6d0941c4; BYTE $0xc6   // VPUNPCKHQDQ  XMM8, XMM14, XMM14  /*   ___, m[11] */
+       LONG $0x6c0141c4; BYTE $0xc0   // VPUNPCKLQDQ  XMM8, XMM15,  XMM8  /* m[14],  ____ */
+       LONG $0x6d1941c4; BYTE $0xcc   // VPUNPCKHQDQ  XMM9, XMM12, XMM12  /*   ___,  m[3] */
+       LONG $0x6c1141c4; BYTE $0xc9   // VPUNPCKLQDQ  XMM9, XMM13,  XMM9  /*  m[6],  ____ */
+       MOVOU 0(DX), X12               // X12 =  m[0]+ m[1]
+       MOVOU 64(DX), X13              // X13 =  m[8]+ m[9]
+       MOVOU 96(DX), X14              // X14 = m[12]+m[13]
+       LONG $0x0f0943c4; WORD $0x08d4 // VPALIGNR    XMM10, XMM14, XMM12, 0x8  /*  m[1], m[12] */
+       LONG $0x6d0941c4; BYTE $0xde   // VPUNPCKHQDQ XMM11, XMM14, XMM14  /*   ___, m[13] */
+       LONG $0x6c1141c4; BYTE $0xdb   // VPUNPCKLQDQ XMM11, XMM13, XMM11  /*  m[8],  ____ */
+
+       LOAD_SHUFFLE
+       G1
+       G2
+       UNDIAGONALIZE
+
+       ///////////////////////////////////////////////////////////////////////////
+       // R O U N D   6
+       ///////////////////////////////////////////////////////////////////////////
+
+       // LOAD_MSG_ ##r ##_1 / ##_2(b0, b1); (X12 is temp register)
+       MOVOU 0(DX), X12             // X12 =  m[0]+ m[1]
+       MOVOU 16(DX), X13            // X13 =  m[2]+ m[3]
+       MOVOU 48(DX), X14            // X14 =  m[6]+ m[7]
+       MOVOU 64(DX), X15            // X15 =  m[8]+ m[9]
+       LONG $0x6c1141c4; BYTE $0xc6 // VPUNPCKLQDQ  XMM8, XMM13, XMM14  /*  m[2],  m[6] */
+       LONG $0x6c1941c4; BYTE $0xcf // VPUNPCKLQDQ  XMM9, XMM12, XMM15  /*  m[0],  m[8] */
+       MOVOU 80(DX), X12            // X12 = m[10]+m[11]
+       MOVOU 96(DX), X14            // X14 = m[12]+m[13]
+       LONG $0x6c0941c4; BYTE $0xd4 // VPUNPCKLQDQ XMM10, XMM14, XMM12  /* m[12], m[10] */
+       LONG $0x6d1941c4; BYTE $0xdd // VPUNPCKHQDQ XMM11, XMM12, XMM13  /* m[11],  m[3] */
+
+       LOAD_SHUFFLE
+       G1
+       G2
+       DIAGONALIZE
+
+       // LOAD_MSG_ ##r ##_3 / ##_4(b0, b1); (X12 is temp register)
+       MOVOU 0(DX), X12             // X12 =  m[0]+ m[1]
+       MOVOU 32(DX), X13            // X13 =  m[4]+ m[5]
+       MOVOU 48(DX), X14            // X14 =  m[6]+ m[7]
+       MOVOU 112(DX), X15           // X15 = m[14]+m[15]
+       LONG $0x6d0941c4; BYTE $0xc6 // VPUNPCKHQDQ  XMM8, XMM14, XMM14  /*   ___,  m[7] */
+       LONG $0x6c1141c4; BYTE $0xc0 // VPUNPCKLQDQ  XMM8, XMM13,  XMM8  /*  m[4],  ____ */
+       LONG $0x6d0141c4; BYTE $0xcc // VPUNPCKHQDQ  XMM9, XMM15, XMM12  /* m[15],  m[1] */
+       MOVOU 64(DX), X12            // X12 =  m[8]+ m[9]
+       MOVOU 96(DX), X14            // X14 = m[12]+m[13]
+       LONG $0x6d0941c4; BYTE $0xd5 // VPUNPCKHQDQ XMM10, XMM14, XMM13  /* m[13],  m[5] */
+       LONG $0x6d1941c4; BYTE $0xdc // VPUNPCKHQDQ XMM11, XMM12, XMM12  /*   ___,  m[9] */
+       LONG $0x6c0141c4; BYTE $0xdb // VPUNPCKLQDQ XMM11, XMM15, XMM11  /* m[14],  ____ */
+
+       LOAD_SHUFFLE
+       G1
+       G2
+       UNDIAGONALIZE
+
+       ///////////////////////////////////////////////////////////////////////////
+       // R O U N D   7
+       ///////////////////////////////////////////////////////////////////////////
+
+       // LOAD_MSG_ ##r ##_1 / ##_2(b0, b1); (X12 is temp register)
+       MOVOU 0(DX), X12               // X12 =  m[0]+ m[1]
+       MOVOU 32(DX), X13              // X13 =  m[4]+ m[5]
+       MOVOU 96(DX), X14              // X14 = m[12]+m[13]
+       MOVOU 112(DX), X15             // X15 = m[14]+m[15]
+       LONG $0x6d1941c4; BYTE $0xc4   // VPUNPCKHQDQ  XMM8, XMM12, XMM12  /*   ___,  m[1] */
+       LONG $0x6c0941c4; BYTE $0xc0   // VPUNPCKLQDQ  XMM8, XMM14,  XMM8  /* m[12],  ____ */
+       LONG $0x6c0141c4; BYTE $0xcd   // VPUNPCKLQDQ  XMM9, XMM15, XMM13  /* m[14],  m[4] */
+       MOVOU 80(DX), X12              // X12 = m[10]+m[11]
+       LONG $0x6d1141c4; BYTE $0xd7   // VPUNPCKHQDQ XMM10, XMM13, XMM15  /*  m[5], m[15] */
+       LONG $0x0f1943c4; WORD $0x08de // VPALIGNR    XMM11, XMM12, XMM14, 0x8  /* m[13], m[10] */
+
+       LOAD_SHUFFLE
+       G1
+       G2
+       DIAGONALIZE
+
+       // LOAD_MSG_ ##r ##_3 / ##_4(b0, b1); (X12 is temp register)
+       MOVOU 0(DX), X12               // X12 =  m[0]+ m[1]
+       MOVOU 48(DX), X13              // X13 =  m[6]+ m[7]
+       MOVOU 64(DX), X14              // X14 =  m[8]+ m[9]
+       MOVOU 80(DX), X15              // X15 = m[10]+m[11]
+       LONG $0x6c1941c4; BYTE $0xc5   // VPUNPCKLQDQ  XMM8, XMM12, XMM13  /*  m[0],  m[6] */
+       LONG $0x0f0943c4; WORD $0x08ce // VPALIGNR     XMM9, XMM14, XMM14, 0x8  /*  m[9],  m[8] */
+       MOVOU 16(DX), X14              // X14 =  m[2]+ m[3]
+       LONG $0x6d1141c4; BYTE $0xd6   // VPUNPCKHQDQ XMM10, XMM13, XMM14  /*  m[7],  m[3] */
+       LONG $0x6d0141c4; BYTE $0xdf   // VPUNPCKHQDQ XMM11, XMM15, XMM15  /*   ___, m[11] */
+       LONG $0x6c0941c4; BYTE $0xdb   // VPUNPCKLQDQ XMM11, XMM14, XMM11  /*  m[2],  ____ */
+
+       LOAD_SHUFFLE
+       G1
+       G2
+       UNDIAGONALIZE
+
+       ///////////////////////////////////////////////////////////////////////////
+       // R O U N D   8
+       ///////////////////////////////////////////////////////////////////////////
+
+       // LOAD_MSG_ ##r ##_1 / ##_2(b0, b1); (X12 is temp register)
+       MOVOU 16(DX), X12              // X12 =  m[2]+ m[3]
+       MOVOU 48(DX), X13              // X13 =  m[6]+ m[7]
+       MOVOU 96(DX), X14              // X14 = m[12]+m[13]
+       MOVOU 112(DX), X15             // X15 = m[14]+m[15]
+       LONG $0x6d0941c4; BYTE $0xc5   // VPUNPCKHQDQ  XMM8, XMM14, XMM13  /* m[13],  m[7] */
+       LONG $0x6d1941c4; BYTE $0xcc   // VPUNPCKHQDQ  XMM9, XMM12, XMM12  /*   ___,  m[3] */
+       LONG $0x6c0941c4; BYTE $0xc9   // VPUNPCKLQDQ  XMM9, XMM14,  XMM9  /* m[12],  ____ */
+       MOVOU 0(DX), X12               // X12 =  m[0]+ m[1]
+       MOVOU 64(DX), X13              // X13 =  m[8]+ m[9]
+       MOVOU 80(DX), X14              // X14 = m[10]+m[11]
+       LONG $0x0f0143c4; WORD $0x08d6 // VPALIGNR    XMM10, XMM15, XMM14, 0x8  /* m[11], m[14] */
+       LONG $0x6d1941c4; BYTE $0xdd   // VPUNPCKHQDQ XMM11, XMM12, XMM13  /*  m[1],  m[9] */
+
+       LOAD_SHUFFLE
+       G1
+       G2
+       DIAGONALIZE
+
+       // LOAD_MSG_ ##r ##_3 / ##_4(b0, b1); (X12 is temp register)
+       MOVOU 16(DX), X12            // X12 =  m[2]+ m[3]
+       MOVOU 32(DX), X13            // X13 =  m[4]+ m[5]
+       MOVOU 64(DX), X14            // X14 =  m[8]+ m[9]
+       MOVOU 112(DX), X15           // X15 = m[14]+m[15]
+       LONG $0x6d1141c4; BYTE $0xc7 // VPUNPCKHQDQ  XMM8, XMM13, XMM15  /*  m[5], m[15] */
+       LONG $0x6c0941c4; BYTE $0xcc // VPUNPCKLQDQ  XMM9, XMM14, XMM12  /*  m[8],  m[2] */
+       MOVOU 0(DX), X12             // X12 =  m[0]+ m[1]
+       MOVOU 48(DX), X14            // X14 =  m[6]+ m[7]
+       MOVOU 80(DX), X15            // X15 = m[10]+m[11]
+       LONG $0x6c1941c4; BYTE $0xd5 // VPUNPCKLQDQ XMM10, XMM12, XMM13  /*  m[0],  m[4] */
+       LONG $0x6c0941c4; BYTE $0xdf // VPUNPCKLQDQ XMM11, XMM14, XMM15  /*  m[6], m[10] */
+
+       LOAD_SHUFFLE
+       G1
+       G2
+       UNDIAGONALIZE
+
+       ///////////////////////////////////////////////////////////////////////////
+       // R O U N D   9
+       ///////////////////////////////////////////////////////////////////////////
+
+       // LOAD_MSG_ ##r ##_1 / ##_2(b0, b1); (X12 is temp register)
+       MOVOU 0(DX), X12               // X12 =  m[0]+ m[1]
+       MOVOU 48(DX), X13              // X13 =  m[6]+ m[7]
+       MOVOU 80(DX), X14              // X14 = m[10]+m[11]
+       MOVOU 112(DX), X15             // X15 = m[14]+m[15]
+       LONG $0x6c1141c4; BYTE $0xc7   // VPUNPCKLQDQ  XMM8, XMM13, XMM15  /*  m[6], m[14] */
+       LONG $0x0f1943c4; WORD $0x08ce // VPALIGNR     XMM9, XMM12, XMM14, 0x8  /* m[11],  m[0] */
+       MOVOU 16(DX), X13              // X13 =  m[2]+ m[3]
+       MOVOU 64(DX), X14              // X14 =  m[8]+ m[9]
+       LONG $0x6d0141c4; BYTE $0xd6   // VPUNPCKHQDQ XMM10, XMM15, XMM14  /* m[15],  m[9] */
+       LONG $0x0f0943c4; WORD $0x08dd // VPALIGNR    XMM11, XMM14, XMM13, 0x8  /*  m[3],  m[8] */
+
+       LOAD_SHUFFLE
+       G1
+       G2
+       DIAGONALIZE
+
+       // LOAD_MSG_ ##r ##_3 / ##_4(b0, b1); (X12 is temp register)
+       MOVOU 0(DX), X12               // X12 =  m[0]+ m[1]
+       MOVOU 16(DX), X13              // X13 =  m[2]+ m[3]
+       MOVOU 80(DX), X14              // X14 = m[10]+m[11]
+       MOVOU 96(DX), X15              // X15 = m[12]+m[13]
+       LONG $0x6d0141c4; BYTE $0xc7   // VPUNPCKHQDQ  XMM8, XMM15, XMM15  /*   ___, m[13] */
+       LONG $0x6c0141c4; BYTE $0xc0   // VPUNPCKLQDQ  XMM8, XMM15,  XMM8  /* m[12],  ____ */
+       LONG $0x0f0943c4; WORD $0x08cc // VPALIGNR     XMM9, XMM14, XMM12, 0x8  /*  m[1], m[10] */
+       MOVOU 32(DX), X12              // X12 =  m[4]+ m[5]
+       MOVOU 48(DX), X15              // X15 =  m[6]+ m[7]
+       LONG $0x6d0141c4; BYTE $0xd7   // VPUNPCKHQDQ XMM10, XMM15, XMM15  /*   ___,  m[7] */
+       LONG $0x6c1141c4; BYTE $0xd2   // VPUNPCKLQDQ XMM10, XMM13, XMM10  /*  m[2],  ____ */
+       LONG $0x6d1941c4; BYTE $0xdc   // VPUNPCKHQDQ XMM11, XMM12, XMM12  /*   ___,  m[5] */
+       LONG $0x6c1941c4; BYTE $0xdb   // VPUNPCKLQDQ XMM11, XMM12, XMM11  /*  m[4],  ____ */
+
+       LOAD_SHUFFLE
+       G1
+       G2
+       UNDIAGONALIZE
+
+       ///////////////////////////////////////////////////////////////////////////
+       // R O U N D   1 0
+       ///////////////////////////////////////////////////////////////////////////
+
+       // LOAD_MSG_ ##r ##_1 / ##_2(b0, b1); (X12 is temp register)
+       MOVOU 0(DX), X12             // X12 =  m[0]+ m[1]
+       MOVOU 48(DX), X13            // X13 =  m[6]+ m[7]
+       MOVOU 64(DX), X14            // X14 =  m[8]+ m[9]
+       MOVOU 80(DX), X15            // X15 = m[10]+m[11]
+       LONG $0x6c0141c4; BYTE $0xc6 // VPUNPCKLQDQ  XMM8, XMM15, XMM14  /* m[10],  m[8] */
+       LONG $0x6d1141c4; BYTE $0xcc // VPUNPCKHQDQ  XMM9, XMM13, XMM12  /*  m[7],  m[1] */
+       MOVOU 16(DX), X12            // X12 =  m[2]+ m[3]
+       MOVOU 32(DX), X14            // X14 =  m[4]+ m[5]
+       LONG $0x6c1941c4; BYTE $0xd6 // VPUNPCKLQDQ XMM10, XMM12, XMM14  /*  m[2],  m[4] */
+       LONG $0x6d0941c4; BYTE $0xde // VPUNPCKHQDQ XMM11, XMM14, XMM14  /*   ___,  m[5] */
+       LONG $0x6c1141c4; BYTE $0xdb // VPUNPCKLQDQ XMM11, XMM13, XMM11  /*  m[6],  ____ */
+
+       LOAD_SHUFFLE
+       G1
+       G2
+       DIAGONALIZE
+
+       // LOAD_MSG_ ##r ##_3 / ##_4(b0, b1); (X12 is temp register)
+       MOVOU 16(DX), X12              // X12 =  m[2]+ m[3]
+       MOVOU 64(DX), X13              // X13 =  m[8]+ m[9]
+       MOVOU 96(DX), X14              // X14 = m[12]+m[13]
+       MOVOU 112(DX), X15             // X15 = m[14]+m[15]
+       LONG $0x6d0141c4; BYTE $0xc5   // VPUNPCKHQDQ  XMM8, XMM15, XMM13  /* m[15],  m[9] */
+       LONG $0x6d1941c4; BYTE $0xce   // VPUNPCKHQDQ  XMM9, XMM12, XMM14  /*  m[3], m[13] */
+       MOVOU 0(DX), X12               // X12 =  m[0]+ m[1]
+       MOVOU 80(DX), X13              // X13 = m[10]+m[11]
+       LONG $0x0f0143c4; WORD $0x08d5 // VPALIGNR    XMM10, XMM15, XMM13, 0x8  /* m[11], m[14] */
+       LONG $0x6c0941c4; BYTE $0xdc   // VPUNPCKLQDQ XMM11, XMM14, XMM12  /* m[12],  m[0] */
+
+       LOAD_SHUFFLE
+       G1
+       G2
+       UNDIAGONALIZE
+
+       ///////////////////////////////////////////////////////////////////////////
+       // R O U N D   1 1
+       ///////////////////////////////////////////////////////////////////////////
+
+       // LOAD_MSG_ ##r ##_1 / ##_2(b0, b1); (X12 is temp register)
+       MOVOU 0(DX), X12             // X12 = m[0]+m[1]
+       MOVOU 16(DX), X13            // X13 = m[2]+m[3]
+       MOVOU 32(DX), X14            // X14 = m[4]+m[5]
+       MOVOU 48(DX), X15            // X15 = m[6]+m[7]
+       LONG $0x6c1941c4; BYTE $0xc5 // VPUNPCKLQDQ  XMM8, XMM12, XMM13  /* m[0], m[2] */
+       LONG $0x6c0941c4; BYTE $0xcf // VPUNPCKLQDQ  XMM9, XMM14, XMM15  /* m[4], m[6] */
+       LONG $0x6d1941c4; BYTE $0xd5 // VPUNPCKHQDQ XMM10, XMM12, XMM13  /* m[1], m[3] */
+       LONG $0x6d0941c4; BYTE $0xdf // VPUNPCKHQDQ XMM11, XMM14, XMM15  /* m[5], m[7] */
+
+       LOAD_SHUFFLE
+       G1
+       G2
+       DIAGONALIZE
+
+       // LOAD_MSG_ ##r ##_3 / ##_4(b0, b1); (X12 is temp register)
+       MOVOU 64(DX), X12            // X12 =  m[8]+ m[9]
+       MOVOU 80(DX), X13            // X13 = m[10]+m[11]
+       MOVOU 96(DX), X14            // X14 = m[12]+m[13]
+       MOVOU 112(DX), X15           // X15 = m[14]+m[15]
+       LONG $0x6c1941c4; BYTE $0xc5 // VPUNPCKLQDQ  XMM8, XMM12, XMM13  /*  m[8],m[10] */
+       LONG $0x6c0941c4; BYTE $0xcf // VPUNPCKLQDQ  XMM9, XMM14, XMM15  /* m[12],m[14] */
+       LONG $0x6d1941c4; BYTE $0xd5 // VPUNPCKHQDQ XMM10, XMM12, XMM13  /*  m[9],m[11] */
+       LONG $0x6d0941c4; BYTE $0xdf // VPUNPCKHQDQ XMM11, XMM14, XMM15  /* m[13],m[15] */
+
+       LOAD_SHUFFLE
+       G1
+       G2
+       UNDIAGONALIZE
+
+       ///////////////////////////////////////////////////////////////////////////
+       // R O U N D   1 2
+       ///////////////////////////////////////////////////////////////////////////
+
+       // LOAD_MSG_ ##r ##_1 / ##_2(b0, b1); (X12 is temp register)
+       MOVOU 112(DX), X12             // X12 = m[14]+m[15]
+       MOVOU 32(DX), X13              // X13 =  m[4]+ m[5]
+       MOVOU 64(DX), X14              // X14 =  m[8]+ m[9]
+       MOVOU 96(DX), X15              // X15 = m[12]+m[13]
+       LONG $0x6c1941c4; BYTE $0xc5   // VPUNPCKLQDQ  XMM8, XMM12, XMM13  /* m[14],  m[4] */
+       LONG $0x6d0941c4; BYTE $0xcf   // VPUNPCKHQDQ  XMM9, XMM14, XMM15  /*  m[9], m[13] */
+       MOVOU 80(DX), X13              // X13 = m[10]+m[11]
+       MOVOU 48(DX), X15              // X15 =  m[6]+ m[7]
+       LONG $0x6c1141c4; BYTE $0xd6   // VPUNPCKLQDQ XMM10, XMM13, XMM14  /* m[10],  m[8] */
+       LONG $0x0f0143c4; WORD $0x08dc // VPALIGNR    XMM11, XMM15, XMM12, 0x8  /* m[15],  m[6] */
+
+       LOAD_SHUFFLE
+       G1
+       G2
+       DIAGONALIZE
+
+       // LOAD_MSG_ ##r ##_3 / ##_4(b0, b1); (X12 is temp register)
+       MOVOU 0(DX), X12               // X12 =  m[0]+ m[1]
+       MOVOU 32(DX), X13              // X13 =  m[4]+ m[5]
+       MOVOU 80(DX), X14              // X14 = m[10]+m[11]
+       LONG $0x0f1943c4; WORD $0x08c4 // VPALIGNR     XMM8, XMM12, XMM12, 0x8  /*  m[1],  m[0] */
+       LONG $0x6d0941c4; BYTE $0xcd   // VPUNPCKHQDQ  XMM9, XMM14, XMM13  /* m[11], m[5] */
+       MOVOU 16(DX), X12              // X12 =  m[2]+ m[3]
+       MOVOU 48(DX), X13              // X13 =  m[6]+ m[7]
+       MOVOU 96(DX), X14              // X14 = m[12]+m[13]
+       LONG $0x6c0941c4; BYTE $0xd4   // VPUNPCKLQDQ XMM10, XMM14, XMM12  /* m[12], m[2] */
+       LONG $0x6d1141c4; BYTE $0xdc   // VPUNPCKHQDQ XMM11, XMM13, XMM12  /*  m[7], m[3] */
+
+       LOAD_SHUFFLE
+       G1
+       G2
+       UNDIAGONALIZE
+
+       // Reload digest (most current value store in &out)
+       MOVQ  out+144(FP), SI // SI: &in
+       MOVOU 0(SI), X12      // X12 = in[0]+in[1]      /* row1l = LOAD( &S->h[0] ); */
+       MOVOU 16(SI), X13     // X13 = in[2]+in[3]      /* row1h = LOAD( &S->h[2] ); */
+       MOVOU 32(SI), X14     // X14 = in[4]+in[5]      /* row2l = LOAD( &S->h[4] ); */
+       MOVOU 48(SI), X15     // X15 = in[6]+in[7]      /* row2h = LOAD( &S->h[6] ); */
+
+       // Final computations and prepare for storing
+       PXOR X4, X0  // X0 = X0 ^ X4          /* row1l = _mm_xor_si128( row3l, row1l ); */
+       PXOR X5, X1  // X1 = X1 ^ X5          /* row1h = _mm_xor_si128( row3h, row1h ); */
+       PXOR X12, X0 // X0 = X0 ^ X12         /*  STORE( &S->h[0], _mm_xor_si128( LOAD( &S->h[0] ), row1l ) ); */
+       PXOR X13, X1 // X1 = X1 ^ X13         /*  STORE( &S->h[2], _mm_xor_si128( LOAD( &S->h[2] ), row1h ) ); */
+       PXOR X6, X2  // X2 = X2 ^ X6          /*  row2l = _mm_xor_si128( row4l, row2l ); */
+       PXOR X7, X3  // X3 = X3 ^ X7          /*  row2h = _mm_xor_si128( row4h, row2h ); */
+       PXOR X14, X2 // X2 = X2 ^ X14         /*  STORE( &S->h[4], _mm_xor_si128( LOAD( &S->h[4] ), row2l ) ); */
+       PXOR X15, X3 // X3 = X3 ^ X15         /*  STORE( &S->h[6], _mm_xor_si128( LOAD( &S->h[6] ), row2h ) ); */
+
+       // Store digest into &out
+       MOVQ  out+144(FP), SI // SI: &out
+       MOVOU X0, 0(SI)       // out[0]+out[1] = X0
+       MOVOU X1, 16(SI)      // out[2]+out[3] = X1
+       MOVOU X2, 32(SI)      // out[4]+out[5] = X2
+       MOVOU X3, 48(SI)      // out[6]+out[7] = X3
+
+       // Increment message pointer and check if there's more to do
+       ADDQ $128, DX // message += 128
+       SUBQ $1, R8
+       JNZ  loop
+
+complete:
+       RET

diff --git a/vendor/github.com/minio/blake2b-simd/compressSse_amd64.go b/vendor/github.com/minio/blake2b-simd/compressSse_amd64.go
new file mode 100644 (file)
index 0000000..d539a7a
--- /dev/null
+++ b/vendor/github.com/minio/blake2b-simd/compressSse_amd64.go
@@ -0,0 +1,41 @@
+//+build !noasm
+//+build !appengine
+
+/*
+ * Minio Cloud Storage, (C) 2016 Minio, Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package blake2b
+
+//go:noescape
+func blockSSELoop(p []uint8, in, iv, t, f, shffle, out []uint64)
+
+func compressSSE(d *digest, p []uint8) {
+       var (
+               in     [8]uint64
+               out    [8]uint64
+               shffle [2]uint64
+       )
+
+       // vector for PSHUFB instruction
+       shffle[0] = 0x0201000706050403
+       shffle[1] = 0x0a09080f0e0d0c0b
+
+       in[0], in[1], in[2], in[3], in[4], in[5], in[6], in[7] = d.h[0], d.h[1], d.h[2], d.h[3], d.h[4], d.h[5], d.h[6], d.h[7]
+
+       blockSSELoop(p, in[:], iv[:], d.t[:], d.f[:], shffle[:], out[:])
+
+       d.h[0], d.h[1], d.h[2], d.h[3], d.h[4], d.h[5], d.h[6], d.h[7] = out[0], out[1], out[2], out[3], out[4], out[5], out[6], out[7]
+}

diff --git a/vendor/github.com/minio/blake2b-simd/compressSse_amd64.s b/vendor/github.com/minio/blake2b-simd/compressSse_amd64.s
new file mode 100644 (file)
index 0000000..6f31c94
--- /dev/null
+++ b/vendor/github.com/minio/blake2b-simd/compressSse_amd64.s
@@ -0,0 +1,770 @@
+//+build !noasm !appengine
+
+//
+// Minio Cloud Storage, (C) 2016 Minio, Inc.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+
+//
+// Based on SSE implementation from https://github.com/BLAKE2/BLAKE2/blob/master/sse/blake2b.c
+//
+// Use github.com/fwessels/asm2plan9s on this file to assemble instructions to their Plan9 equivalent
+//
+// Assembly code below essentially follows the ROUND macro (see blake2b-round.h) which is defined as:
+//   #define ROUND(r) \
+//     LOAD_MSG_ ##r ##_1(b0, b1); \
+//     G1(row1l,row2l,row3l,row4l,row1h,row2h,row3h,row4h,b0,b1); \
+//     LOAD_MSG_ ##r ##_2(b0, b1); \
+//     G2(row1l,row2l,row3l,row4l,row1h,row2h,row3h,row4h,b0,b1); \
+//     DIAGONALIZE(row1l,row2l,row3l,row4l,row1h,row2h,row3h,row4h); \
+//     LOAD_MSG_ ##r ##_3(b0, b1); \
+//     G1(row1l,row2l,row3l,row4l,row1h,row2h,row3h,row4h,b0,b1); \
+//     LOAD_MSG_ ##r ##_4(b0, b1); \
+//     G2(row1l,row2l,row3l,row4l,row1h,row2h,row3h,row4h,b0,b1); \
+//     UNDIAGONALIZE(row1l,row2l,row3l,row4l,row1h,row2h,row3h,row4h);
+//
+// as well as the go equivalent in https://github.com/dchest/blake2b/blob/master/block.go
+//
+// As in the macro, G1/G2 in the 1st and 2nd half are identical (so literal copy of assembly)
+//
+// Rounds are also the same, except for the loading of the message (and rounds 1 & 11 and
+// rounds 2 & 12 are identical)
+//
+
+#define G1 \
+       \ // G1(row1l,row2l,row3l,row4l,row1h,row2h,row3h,row4h,b0,b1);
+       LONG $0xd40f4166; BYTE $0xc0   \ // PADDQ  XMM0,XMM8        /* v0 += m[0], v1 += m[2] */
+       LONG $0xd40f4166; BYTE $0xc9   \ // PADDQ  XMM1,XMM9        /* v2 += m[4], v3 += m[6] */
+       LONG $0xc2d40f66               \ // PADDQ  XMM0,XMM2        /* v0 += v4, v1 += v5 */
+       LONG $0xcbd40f66               \ // PADDQ  XMM1,XMM3        /* v2 += v6, v3 += v7 */
+       LONG $0xf0ef0f66               \ // PXOR   XMM6,XMM0        /* v12 ^= v0, v13 ^= v1 */
+       LONG $0xf9ef0f66               \ // PXOR   XMM7,XMM1        /* v14 ^= v2, v15 ^= v3 */
+       LONG $0xf6700f66; BYTE $0xb1   \ // PSHUFD XMM6,XMM6,0xb1   /* v12 = v12<<(64-32) | v12>>32, v13 = v13<<(64-32) | v13>>32 */
+       LONG $0xff700f66; BYTE $0xb1   \ // PSHUFD XMM7,XMM7,0xb1   /* v14 = v14<<(64-32) | v14>>32, v15 = v15<<(64-32) | v15>>32 */
+       LONG $0xe6d40f66               \ // PADDQ  XMM4,XMM6        /* v8 += v12, v9 += v13  */
+       LONG $0xefd40f66               \ // PADDQ  XMM5,XMM7        /* v10 += v14, v11 += v15 */
+       LONG $0xd4ef0f66               \ // PXOR   XMM2,XMM4        /* v4 ^= v8, v5 ^= v9 */
+       LONG $0xddef0f66               \ // PXOR   XMM3,XMM5        /* v6 ^= v10, v7 ^= v11 */
+       LONG $0x380f4166; WORD $0xd400 \ // PSHUFB XMM2,XMM12       /* v4 = v4<<(64-24) | v4>>24, v5 = v5<<(64-24) | v5>>24 */
+       LONG $0x380f4166; WORD $0xdc00   // PSHUFB XMM3,XMM12       /* v6 = v6<<(64-24) | v6>>24, v7 = v7<<(64-24) | v7>>24 */
+
+#define G2 \
+       \ // G2(row1l,row2l,row3l,row4l,row1h,row2h,row3h,row4h,b0,b1);
+       LONG  $0xd40f4166; BYTE $0xc2   \ // PADDQ  XMM0,XMM10        /* v0 += m[1], v1 += m[3] */
+       LONG  $0xd40f4166; BYTE $0xcb   \ // PADDQ  XMM1,XMM11        /* v2 += m[5], v3 += m[7] */
+       LONG  $0xc2d40f66               \ // PADDQ  XMM0,XMM2         /* v0 += v4, v1 += v5 */
+       LONG  $0xcbd40f66               \ // PADDQ  XMM1,XMM3         /* v2 += v6, v3 += v7 */
+       LONG  $0xf0ef0f66               \ // PXOR   XMM6,XMM0         /* v12 ^= v0, v13 ^= v1 */
+       LONG  $0xf9ef0f66               \ // PXOR   XMM7,XMM1         /* v14 ^= v2, v15 ^= v3 */
+       LONG  $0xf6700ff2; BYTE $0x39   \ // PSHUFLW XMM6,XMM6,0x39   /* combined with next ... */
+       LONG  $0xf6700ff3; BYTE $0x39   \ // PSHUFHW XMM6,XMM6,0x39   /* v12 = v12<<(64-16) | v12>>16, v13 = v13<<(64-16) | v13>>16 */
+       LONG  $0xff700ff2; BYTE $0x39   \ // PSHUFLW XMM7,XMM7,0x39   /* combined with next ... */
+       LONG  $0xff700ff3; BYTE $0x39   \ // PSHUFHW XMM7,XMM7,0x39   /* v14 = v14<<(64-16) | v14>>16, v15 = v15<<(64-16) | v15>>16 */
+       LONG  $0xe6d40f66               \ // PADDQ  XMM4,XMM6         /* v8 += v12, v9 += v13 */
+       LONG  $0xefd40f66               \ // PADDQ  XMM5,XMM7         /* v10 += v14, v11 += v15 */
+       LONG  $0xd4ef0f66               \ // PXOR   XMM2,XMM4         /* v4 ^= v8, v5 ^= v9 */
+       LONG  $0xddef0f66               \ // PXOR   XMM3,XMM5         /* v6 ^= v10, v7 ^= v11 */
+       MOVOU X2, X15                   \
+       LONG  $0xd40f4466; BYTE $0xfa   \ // PADDQ  XMM15,XMM2        /* temp reg = reg*2   */
+       LONG  $0xd2730f66; BYTE $0x3f   \ // PSRLQ  XMM2,0x3f         /*      reg = reg>>63 */
+       LONG  $0xef0f4166; BYTE $0xd7   \ // PXOR   XMM2,XMM15        /* ORed together: v4 = v4<<(64-63) | v4>>63, v5 = v5<<(64-63) | v5>>63 */
+       MOVOU X3, X15                   \
+       LONG  $0xd40f4466; BYTE $0xfb   \ // PADDQ XMM15,XMM3         /* temp reg = reg*2   */
+       LONG  $0xd3730f66; BYTE $0x3f   \ // PSRLQ XMM3,0x3f          /*      reg = reg>>63 */
+       LONG  $0xef0f4166; BYTE $0xdf     // PXOR  XMM3,XMM15         /* ORed together: v6 = v6<<(64-63) | v6>>63, v7 = v7<<(64-63) | v7>>63 */
+
+#define DIAGONALIZE \
+       \ // DIAGONALIZE(row1l,row2l,row3l,row4l,row1h,row2h,row3h,row4h);
+       MOVOU X6, X13                   \                                     /* t0 = row4l;\                                                            */
+       MOVOU X2, X14                   \                                     /* t1 = row2l;\                                                            */
+       MOVOU X4, X6                    \                                     /* row4l = row3l;\                                                         */
+       MOVOU X5, X4                    \                                     /* row3l = row3h;\                                                         */
+       MOVOU X6, X5                    \                                     /* row3h = row4l;\                                                         */
+       LONG  $0x6c0f4566; BYTE $0xfd   \ // PUNPCKLQDQ XMM15, XMM13          /*                                    _mm_unpacklo_epi64(t0, t0)           */
+       MOVOU X7, X6                    \
+       LONG  $0x6d0f4166; BYTE $0xf7   \ // PUNPCKHQDQ  XMM6, XMM15          /*  row4l = _mm_unpackhi_epi64(row4h,                           ); \       */
+       LONG  $0x6c0f4466; BYTE $0xff   \ // PUNPCKLQDQ XMM15,  XMM7          /*                                 _mm_unpacklo_epi64(row4h, row4h)        */
+       MOVOU X13, X7                   \
+       LONG  $0x6d0f4166; BYTE $0xff   \ // PUNPCKHQDQ  XMM7, XMM15          /*  row4h = _mm_unpackhi_epi64(t0,                                 ); \    */
+       LONG  $0x6c0f4466; BYTE $0xfb   \ // PUNPCKLQDQ XMM15,  XMM3          /*                                    _mm_unpacklo_epi64(row2h, row2h)     */
+       LONG  $0x6d0f4166; BYTE $0xd7   \ // PUNPCKHQDQ  XMM2, XMM15          /*  row2l = _mm_unpackhi_epi64(row2l,                                 ); \ */
+       LONG  $0x6c0f4566; BYTE $0xfe   \ // PUNPCKLQDQ XMM15, XMM14          /*                                    _mm_unpacklo_epi64(t1, t1)           */
+       LONG  $0x6d0f4166; BYTE $0xdf     // PUNPCKHQDQ  XMM3, XMM15          /*  row2h = _mm_unpackhi_epi64(row2h,                           )          */
+
+#define UNDIAGONALIZE \
+       \ // UNDIAGONALIZE(row1l,row2l,row3l,row4l,row1h,row2h,row3h,row4h);
+       MOVOU X4, X13                   \                                     /* t0 = row3l;\                                                            */
+       MOVOU X5, X4                    \                                     /* row3l = row3h;\                                                         */
+       MOVOU X13, X5                   \                                     /* row3h = t0;\                                                            */
+       MOVOU X2, X13                   \                                     /* t0 = row2l;\                                                            */
+       MOVOU X6, X14                   \                                     /* t1 = row4l;\                                                            */
+       LONG  $0x6c0f4466; BYTE $0xfa   \ // PUNPCKLQDQ XMM15,  XMM2          /*                                    _mm_unpacklo_epi64(row2l, row2l)     */
+       MOVOU X3, X2                    \
+       LONG  $0x6d0f4166; BYTE $0xd7   \ // PUNPCKHQDQ  XMM2, XMM15          /*  row2l = _mm_unpackhi_epi64(row2h,                                 ); \ */
+       LONG  $0x6c0f4466; BYTE $0xfb   \ // PUNPCKLQDQ XMM15,  XMM3          /*                                 _mm_unpacklo_epi64(row2h, row2h)        */
+       MOVOU X13, X3                   \
+       LONG  $0x6d0f4166; BYTE $0xdf   \ // PUNPCKHQDQ  XMM3, XMM15          /*  row2h = _mm_unpackhi_epi64(t0,                                 ); \    */
+       LONG  $0x6c0f4466; BYTE $0xff   \ // PUNPCKLQDQ XMM15,  XMM7          /*                                    _mm_unpacklo_epi64(row4h, row4h)     */
+       LONG  $0x6d0f4166; BYTE $0xf7   \ // PUNPCKHQDQ  XMM6, XMM15          /*  row4l = _mm_unpackhi_epi64(row4l,                                 ); \ */
+       LONG  $0x6c0f4566; BYTE $0xfe   \ // PUNPCKLQDQ XMM15, XMM14          /*                                    _mm_unpacklo_epi64(t1, t1)           */
+       LONG  $0x6d0f4166; BYTE $0xff     // PUNPCKHQDQ  XMM7, XMM15          /*  row4h = _mm_unpackhi_epi64(row4h,                           )          */
+
+#define LOAD_SHUFFLE \
+       \ // Load shuffle value
+       MOVQ  shffle+120(FP), SI \ // SI: &shuffle
+       MOVOU 0(SI), X12           // X12 = 03040506 07000102 0b0c0d0e 0f08090a
+
+// func blockSSELoop(p []uint8, in, iv, t, f, shffle, out []uint64)
+TEXT ·blockSSELoop(SB), 7, $0
+       // REGISTER USE
+       //        R8: loop counter
+       //        DX: message pointer
+       //        SI: temp pointer for loading
+       //  X0 -  X7: v0 - v15
+       //  X8 - X11: m[0] - m[7]
+       //       X12: shuffle value
+       // X13 - X15: temp registers
+
+       // Load digest
+       MOVQ  in+24(FP), SI // SI: &in
+       MOVOU 0(SI), X0     // X0 = in[0]+in[1]      /* row1l = LOAD( &S->h[0] ); */
+       MOVOU 16(SI), X1    // X1 = in[2]+in[3]      /* row1h = LOAD( &S->h[2] ); */
+       MOVOU 32(SI), X2    // X2 = in[4]+in[5]      /* row2l = LOAD( &S->h[4] ); */
+       MOVOU 48(SI), X3    // X3 = in[6]+in[7]      /* row2h = LOAD( &S->h[6] ); */
+
+       // Already store digest into &out (so we can reload it later generically)
+       MOVQ  out+144(FP), SI // SI: &out
+       MOVOU X0, 0(SI)       // out[0]+out[1] = X0
+       MOVOU X1, 16(SI)      // out[2]+out[3] = X1
+       MOVOU X2, 32(SI)      // out[4]+out[5] = X2
+       MOVOU X3, 48(SI)      // out[6]+out[7] = X3
+
+       // Initialize message pointer and loop counter
+       MOVQ message+0(FP), DX     // DX: &p (message)
+       MOVQ message_len+8(FP), R8 // R8: len(message)
+       SHRQ $7, R8                // len(message) / 128
+       CMPQ R8, $0
+       JEQ  complete
+
+loop:
+       // Increment counter
+       MOVQ t+72(FP), SI // SI: &t
+       MOVQ 0(SI), R9
+       ADDQ $128, R9     // /* d.t[0] += BlockSize */
+       MOVQ R9, 0(SI)
+       CMPQ R9, $128     // /* if d.t[0] < BlockSize { */
+       JGE  noincr
+       MOVQ 8(SI), R9
+       ADDQ $1, R9       // /*     d.t[1]++ */
+       MOVQ R9, 8(SI)
+
+noincr:  // /* } */
+
+       // Load initialization vector
+       MOVQ  iv+48(FP), SI // SI: &iv
+       MOVOU 0(SI), X4     // X4 = iv[0]+iv[1]      /* row3l = LOAD( &blake2b_IV[0] ); */
+       MOVOU 16(SI), X5    // X5 = iv[2]+iv[3]      /* row3h = LOAD( &blake2b_IV[2] ); */
+       MOVOU 32(SI), X6    // X6 = iv[4]+iv[5]      /*                        LOAD( &blake2b_IV[4] )                      */
+       MOVOU 48(SI), X7    // X7 = iv[6]+iv[7]      /*                        LOAD( &blake2b_IV[6] )                      */
+       MOVQ  t+72(FP), SI  // SI: &t
+       MOVOU 0(SI), X8     // X8 = t[0]+t[1]        /*                                                LOAD( &S->t[0] )    */
+       PXOR  X8, X6        // X6 = X6 ^ X8          /* row4l = _mm_xor_si128(                       ,                  ); */
+       MOVQ  t+96(FP), SI  // SI: &f
+       MOVOU 0(SI), X8     // X8 = f[0]+f[1]        /*                                                LOAD( &S->f[0] )    */
+       PXOR  X8, X7        // X7 = X7 ^ X8          /* row4h = _mm_xor_si128(                       ,                  ); */
+
+       ///////////////////////////////////////////////////////////////////////////
+       // R O U N D   1
+       ///////////////////////////////////////////////////////////////////////////
+
+       // LOAD_MSG_ ##r ##_1 / ##_2(b0, b1); (X12 is temp register)
+       MOVOU 0(DX), X12             // X12 = m[0]+m[1]
+       MOVOU 16(DX), X13            // X13 = m[2]+m[3]
+       MOVOU 32(DX), X14            // X14 = m[4]+m[5]
+       MOVOU 48(DX), X15            // X15 = m[6]+m[7]
+       MOVOU X12, X8
+       LONG $0x6c0f4566; BYTE $0xc5 // PUNPCKLQDQ  XMM8, XMM13  /* m[0], m[2] */
+       MOVOU X14, X9
+       LONG $0x6c0f4566; BYTE $0xcf // PUNPCKLQDQ  XMM9, XMM15  /* m[4], m[6] */
+       MOVOU X12, X10
+       LONG $0x6d0f4566; BYTE $0xd5 // PUNPCKHQDQ XMM10, XMM13  /* m[1], m[3] */
+       MOVOU X14, X11
+       LONG $0x6d0f4566; BYTE $0xdf // PUNPCKHQDQ XMM11, XMM15  /* m[5], m[7] */
+
+       LOAD_SHUFFLE
+       G1
+       G2
+       DIAGONALIZE
+
+       // LOAD_MSG_ ##r ##_3 / ##_4(b0, b1); (X12 is temp register)
+       MOVOU 64(DX), X12            // X12 =  m[8]+ m[9]
+       MOVOU 80(DX), X13            // X13 = m[10]+m[11]
+       MOVOU 96(DX), X14            // X14 = m[12]+m[13]
+       MOVOU 112(DX), X15           // X15 = m[14]+m[15]
+       MOVOU X12, X8
+       LONG $0x6c0f4566; BYTE $0xc5 // PUNPCKLQDQ  XMM8, XMM13  /*  m[8],m[10] */
+       MOVOU X14, X9
+       LONG $0x6c0f4566; BYTE $0xcf // PUNPCKLQDQ  XMM9, XMM15  /* m[12],m[14] */
+       MOVOU X12, X10
+       LONG $0x6d0f4566; BYTE $0xd5 // PUNPCKHQDQ XMM10, XMM13  /*  m[9],m[11] */
+       MOVOU X14, X11
+       LONG $0x6d0f4566; BYTE $0xdf // PUNPCKHQDQ XMM11, XMM15  /* m[13],m[15] */
+
+       LOAD_SHUFFLE
+       G1
+       G2
+       UNDIAGONALIZE
+
+       ///////////////////////////////////////////////////////////////////////////
+       // R O U N D   2
+       ///////////////////////////////////////////////////////////////////////////
+
+       // LOAD_MSG_ ##r ##_1 / ##_2(b0, b1); (X12 is temp register)
+       MOVOU 112(DX), X12                         // X12 = m[14]+m[15]
+       MOVOU 32(DX), X13                          // X13 =  m[4]+ m[5]
+       MOVOU 64(DX), X14                          // X14 =  m[8]+ m[9]
+       MOVOU 96(DX), X15                          // X15 = m[12]+m[13]
+       MOVOU X12, X8
+       LONG $0x6c0f4566; BYTE $0xc5               // PUNPCKLQDQ  XMM8, XMM13  /* m[14],  m[4] */
+       MOVOU X14, X9
+       LONG $0x6d0f4566; BYTE $0xcf               // PUNPCKHQDQ  XMM9, XMM15  /*  m[9], m[13] */
+       MOVOU 80(DX), X10                          // X10 = m[10]+m[11]
+       MOVOU 48(DX), X11                          // X11 =  m[6]+ m[7]
+       LONG $0x6c0f4566; BYTE $0xd6               // PUNPCKLQDQ XMM10, XMM14  /* m[10],  m[8] */
+       LONG $0x3a0f4566; WORD $0xdc0f; BYTE $0x08 // PALIGNR    XMM11, XMM12, 0x8  /* m[15],  m[6] */; ; ; ; ;
+
+       LOAD_SHUFFLE
+       G1
+       G2
+       DIAGONALIZE
+
+       // LOAD_MSG_ ##r ##_3 / ##_4(b0, b1); (X12 is temp register)
+       MOVOU 0(DX), X12                           // X12 =  m[0]+ m[1]
+       MOVOU 32(DX), X13                          // X13 =  m[4]+ m[5]
+       MOVOU 80(DX), X14                          // X14 = m[10]+m[11]
+       MOVOU X12, X8
+       LONG $0x3a0f4566; WORD $0xc40f; BYTE $0x08 // PALIGNR     XMM8, XMM12, 0x8  /*  m[1],  m[0] */
+       MOVOU X14, X9
+       LONG $0x6d0f4566; BYTE $0xcd               // PUNPCKHQDQ  XMM9, XMM13  /* m[11], m[5] */
+       MOVOU 16(DX), X12                          // X12 =  m[2]+ m[3]
+       MOVOU 48(DX), X11                          // X11 =  m[6]+ m[7]
+       MOVOU 96(DX), X10                          // X10 = m[12]+m[13]
+       LONG $0x6c0f4566; BYTE $0xd4               // PUNPCKLQDQ XMM10, XMM12  /* m[12], m[2] */
+       LONG $0x6d0f4566; BYTE $0xdc               // PUNPCKHQDQ XMM11, XMM12  /*  m[7], m[3] */
+
+       LOAD_SHUFFLE
+       G1
+       G2
+       UNDIAGONALIZE
+
+       ///////////////////////////////////////////////////////////////////////////
+       // R O U N D   3
+       ///////////////////////////////////////////////////////////////////////////
+
+       // LOAD_MSG_ ##r ##_1 / ##_2(b0, b1); (X12 is temp register)
+       MOVOU 32(DX), X12                          // X12 =  m[4]+ m[5]
+       MOVOU 80(DX), X13                          // X13 = m[10]+m[11]
+       MOVOU 96(DX), X14                          // X14 = m[12]+m[13]
+       MOVOU 112(DX), X15                         // X15 = m[14]+m[15]
+       MOVOU X14, X8
+       LONG $0x3a0f4566; WORD $0xc50f; BYTE $0x08 // PALIGNR     XMM8, XMM13, 0x8  /* m[11],  m[12] */
+       MOVOU X12, X9
+       LONG $0x6d0f4566; BYTE $0xcf               // PUNPCKHQDQ  XMM9, XMM15  /*  m[5], m[15] */
+       MOVOU 0(DX), X12                           // X12 =  m[0]+ m[1]
+       MOVOU 16(DX), X13                          // X13 =  m[2]+ m[3]
+       MOVOU 64(DX), X10                          // X10 =  m[8]+ m[9]
+       LONG $0x6c0f4566; BYTE $0xd4               // PUNPCKLQDQ XMM10, XMM12  /*  m[8],  m[0] */
+       LONG $0x6d0f4566; BYTE $0xf6               // PUNPCKHQDQ XMM14, XMM14  /*   ___, m[13] */
+       MOVOU X13, X11
+       LONG $0x6c0f4566; BYTE $0xde               // PUNPCKLQDQ XMM11, XMM14  /*  m[2],   ___ */
+
+       LOAD_SHUFFLE
+       G1
+       G2
+       DIAGONALIZE
+
+       // LOAD_MSG_ ##r ##_3 / ##_4(b0, b1); (X12 is temp register)
+       MOVOU 16(DX), X12                          // X12 =  m[2]+ m[3]
+       MOVOU 48(DX), X13                          // X13 =  m[6]+ m[7]
+       MOVOU 64(DX), X14                          // X14 =  m[8]+ m[9]
+       MOVOU 80(DX), X15                          // X15 = m[10]+m[11]
+       MOVOU X12, X9
+       LONG $0x6d0f4566; BYTE $0xcc               // PUNPCKHQDQ  XMM9, XMM12  /*   ___, m[3] */
+       MOVOU X15, X8
+       LONG $0x6c0f4566; BYTE $0xc1               // PUNPCKLQDQ  XMM8,  XMM9  /* m[10],  ___ */
+       MOVOU X13, X9
+       LONG $0x6d0f4566; BYTE $0xce               // PUNPCKHQDQ  XMM9, XMM14  /*  m[7], m[9] */
+       MOVOU 0(DX), X12                           // X12 =  m[0]+ m[1]
+       MOVOU 32(DX), X11                          // X11 =  m[4]+ m[5]
+       MOVOU 112(DX), X10                         // X10 = m[14]+m[15]
+       LONG $0x6c0f4566; BYTE $0xd5               // PUNPCKLQDQ XMM10, XMM13  /* m[14], m[6] */
+       LONG $0x3a0f4566; WORD $0xdc0f; BYTE $0x08 // PALIGNR    XMM11, XMM12, 0x8  /*  m[1],  m[4] */
+
+       LOAD_SHUFFLE
+       G1
+       G2
+       UNDIAGONALIZE
+
+       ///////////////////////////////////////////////////////////////////////////
+       // R O U N D   4
+       ///////////////////////////////////////////////////////////////////////////
+
+       // LOAD_MSG_ ##r ##_1 / ##_2(b0, b1); (X12 is temp register)
+       MOVOU 16(DX), X12            // X12 =  m[2]+ m[3]
+       MOVOU 48(DX), X13            // X13 =  m[6]+ m[7]
+       MOVOU 80(DX), X14            // X14 = m[10]+m[11]
+       MOVOU 96(DX), X15            // X15 = m[12]+m[13]
+       MOVOU X13, X8
+       LONG $0x6d0f4566; BYTE $0xc4 // PUNPCKHQDQ  XMM8, XMM12  /*  m[7],  m[3] */
+       MOVOU X15, X9
+       LONG $0x6d0f4566; BYTE $0xce // PUNPCKHQDQ  XMM9, XMM14  /* m[13], m[11] */
+       MOVOU 0(DX), X12             // X12 =  m[0]+ m[1]
+       MOVOU 64(DX), X10            // X10 =  m[8]+ m[9]
+       MOVOU 112(DX), X14           // X14 = m[14]+m[15]
+       LONG $0x6d0f4566; BYTE $0xd4 // PUNPCKHQDQ XMM10, XMM12  /*  m[9],  m[1] */
+       MOVOU X15, X11
+       LONG $0x6c0f4566; BYTE $0xde // PUNPCKLQDQ XMM11, XMM14  /* m[12], m[14] */
+
+       LOAD_SHUFFLE
+       G1
+       G2
+       DIAGONALIZE
+
+       // LOAD_MSG_ ##r ##_3 / ##_4(b0, b1); (X12 is temp register)
+       MOVOU 16(DX), X12            // X12 =  m[2]+ m[3]
+       MOVOU 32(DX), X13            // X13 =  m[4]+ m[5]
+       MOVOU 80(DX), X14            // X14 = m[10]+m[11]
+       MOVOU 112(DX), X15           // X15 = m[14]+m[15]
+       MOVOU X13, X9
+       LONG $0x6d0f4566; BYTE $0xcd // PUNPCKHQDQ  XMM9, XMM13  /*   ___,  m[5] */
+       MOVOU X12, X8
+       LONG $0x6c0f4566; BYTE $0xc1 // PUNPCKLQDQ  XMM8,  XMM9  /*  m[2],  ____ */
+       MOVOU X15, X10
+       LONG $0x6d0f4566; BYTE $0xd7 // PUNPCKHQDQ XMM10, XMM15  /*   ___, m[15] */
+       MOVOU X13, X9
+       LONG $0x6c0f4566; BYTE $0xca // PUNPCKLQDQ  XMM9, XMM10  /*  m[4],  ____ */
+       MOVOU 0(DX), X11             // X11 =  m[0]+ m[1]
+       MOVOU 48(DX), X10            // X10 =  m[6]+ m[7]
+       MOVOU 64(DX), X15            // X15 =  m[8]+ m[9]
+       LONG $0x6c0f4566; BYTE $0xd6 // PUNPCKLQDQ XMM10, XMM14  /*  m[6], m[10] */
+       LONG $0x6c0f4566; BYTE $0xdf // PUNPCKLQDQ XMM11, XMM15  /*  m[0],  m[8] */
+
+       LOAD_SHUFFLE
+       G1
+       G2
+       UNDIAGONALIZE
+
+       ///////////////////////////////////////////////////////////////////////////
+       // R O U N D   5
+       ///////////////////////////////////////////////////////////////////////////
+
+       // LOAD_MSG_ ##r ##_1 / ##_2(b0, b1); (X12 is temp register)
+       MOVOU 16(DX), X12            // X12 =  m[2]+ m[3]
+       MOVOU 32(DX), X13            // X13 =  m[4]+ m[5]
+       MOVOU 64(DX), X14            // X14 =  m[8]+ m[9]
+       MOVOU 80(DX), X15            // X15 = m[10]+m[11]
+       MOVOU X14, X8
+       LONG $0x6d0f4566; BYTE $0xc5 // PUNPCKHQDQ  XMM8, XMM13  /*  m[9],  m[5] */
+       MOVOU X12, X9
+       LONG $0x6c0f4566; BYTE $0xcf // PUNPCKLQDQ  XMM9, XMM15  /*  m[2], m[10] */
+       MOVOU 0(DX), X10             // X10 =  m[0]+ m[1]
+       MOVOU 48(DX), X14            // X14 =  m[6]+ m[7]
+       MOVOU 112(DX), X15           // X15 = m[14]+m[15]
+       LONG $0x6d0f4566; BYTE $0xf6 // PUNPCKHQDQ XMM14, XMM14  /*   ___,  m[7] */
+       LONG $0x6c0f4566; BYTE $0xd6 // PUNPCKLQDQ XMM10, XMM14  /*  m[0],  ____ */
+       LONG $0x6d0f4566; BYTE $0xff // PUNPCKHQDQ XMM15, XMM15  /*   ___, m[15] */
+       MOVOU X13, X11
+       LONG $0x6c0f4566; BYTE $0xdf // PUNPCKLQDQ XMM11, XMM15  /*  m[4],  ____ */
+
+       LOAD_SHUFFLE
+       G1
+       G2
+       DIAGONALIZE
+
+       // LOAD_MSG_ ##r ##_3 / ##_4(b0, b1); (X12 is temp register)
+       MOVOU 16(DX), X12                          // X12 =  m[2]+ m[3]
+       MOVOU 48(DX), X13                          // X13 =  m[6]+ m[7]
+       MOVOU 80(DX), X14                          // X14 = m[10]+m[11]
+       MOVOU 112(DX), X15                         // X15 = m[14]+m[15]
+       LONG $0x6d0f4566; BYTE $0xf6               // PUNPCKHQDQ  XMM14, XMM14  /*   ___, m[11] */
+       MOVOU X15, X8
+       LONG $0x6c0f4566; BYTE $0xc6               // PUNPCKLQDQ  XMM8,  XMM14  /* m[14],  ____ */
+       LONG $0x6d0f4566; BYTE $0xe4               // PUNPCKHQDQ  XMM12, XMM12  /*   ___,  m[3] */
+       MOVOU X13, X9
+       LONG $0x6c0f4566; BYTE $0xcc               // PUNPCKLQDQ  XMM9,  XMM12  /*  m[6],  ____ */
+       MOVOU 0(DX), X12                           // X12 =  m[0]+ m[1]
+       MOVOU 64(DX), X11                          // X11 =  m[8]+ m[9]
+       MOVOU 96(DX), X14                          // X14 = m[12]+m[13]
+       MOVOU X14, X10
+       LONG $0x3a0f4566; WORD $0xd40f; BYTE $0x08 // PALIGNR    XMM10, XMM12, 0x8  /*  m[1], m[12] */
+       LONG $0x6d0f4566; BYTE $0xf6               // PUNPCKHQDQ XMM14, XMM14  /*   ___, m[13] */
+       LONG $0x6c0f4566; BYTE $0xde               // PUNPCKLQDQ XMM11, XMM14  /*  m[8],  ____ */
+
+       LOAD_SHUFFLE
+       G1
+       G2
+       UNDIAGONALIZE
+
+       ///////////////////////////////////////////////////////////////////////////
+       // R O U N D   6
+       ///////////////////////////////////////////////////////////////////////////
+
+       // LOAD_MSG_ ##r ##_1 / ##_2(b0, b1); (X12 is temp register)
+       MOVOU 0(DX), X12             // X12 =  m[0]+ m[1]
+       MOVOU 16(DX), X13            // X13 =  m[2]+ m[3]
+       MOVOU 48(DX), X14            // X14 =  m[6]+ m[7]
+       MOVOU 64(DX), X15            // X15 =  m[8]+ m[9]
+       MOVOU X13, X8
+       LONG $0x6c0f4566; BYTE $0xc6 // PUNPCKLQDQ  XMM8, XMM14  /*  m[2],  m[6] */
+       MOVOU X12, X9
+       LONG $0x6c0f4566; BYTE $0xcf // PUNPCKLQDQ  XMM9, XMM15  /*  m[0],  m[8] */
+       MOVOU 80(DX), X12            // X12 = m[10]+m[11]
+       MOVOU 96(DX), X10            // X10 = m[12]+m[13]
+       LONG $0x6c0f4566; BYTE $0xd4 // PUNPCKLQDQ XMM10, XMM12  /* m[12], m[10] */
+       MOVOU X12, X11
+       LONG $0x6d0f4566; BYTE $0xdd // PUNPCKHQDQ XMM11, XMM13  /* m[11],  m[3] */
+
+       LOAD_SHUFFLE
+       G1
+       G2
+       DIAGONALIZE
+
+       // LOAD_MSG_ ##r ##_3 / ##_4(b0, b1); (X12 is temp register)
+       MOVOU 0(DX), X12             // X12 =  m[0]+ m[1]
+       MOVOU 32(DX), X13            // X13 =  m[4]+ m[5]
+       MOVOU 48(DX), X14            // X14 =  m[6]+ m[7]
+       MOVOU 112(DX), X15           // X15 = m[14]+m[15]
+       MOVOU X14, X9
+       LONG $0x6d0f4566; BYTE $0xce // PUNPCKHQDQ  XMM9, XMM14  /*   ___,  m[7] */
+       MOVOU X13, X8
+       LONG $0x6c0f4566; BYTE $0xc1 // PUNPCKLQDQ  XMM8,  XMM9  /*  m[4],  ____ */
+       MOVOU X15, X9
+       LONG $0x6d0f4566; BYTE $0xcc // PUNPCKHQDQ  XMM9, XMM12  /* m[15],  m[1] */
+       MOVOU 64(DX), X12            // X12 =  m[8]+ m[9]
+       MOVOU 96(DX), X10            // X10 = m[12]+m[13]
+       LONG $0x6d0f4566; BYTE $0xd5 // PUNPCKHQDQ XMM10, XMM13  /* m[13],  m[5] */
+       LONG $0x6d0f4566; BYTE $0xe4 // PUNPCKHQDQ XMM12, XMM12  /*   ___,  m[9] */
+       MOVOU X15, X11
+       LONG $0x6c0f4566; BYTE $0xdc // PUNPCKLQDQ XMM11, XMM12  /* m[14],  ____ */
+
+       LOAD_SHUFFLE
+       G1
+       G2
+       UNDIAGONALIZE
+
+       ///////////////////////////////////////////////////////////////////////////
+       // R O U N D   7
+       ///////////////////////////////////////////////////////////////////////////
+
+       // LOAD_MSG_ ##r ##_1 / ##_2(b0, b1); (X12 is temp register)
+       MOVOU 0(DX), X12                           // X12 =  m[0]+ m[1]
+       MOVOU 32(DX), X13                          // X13 =  m[4]+ m[5]
+       MOVOU 96(DX), X14                          // X14 = m[12]+m[13]
+       MOVOU 112(DX), X15                         // X15 = m[14]+m[15]
+       MOVOU X12, X9
+       LONG $0x6d0f4566; BYTE $0xcc               // PUNPCKHQDQ  XMM9, XMM12  /*   ___,  m[1] */
+       MOVOU X14, X8
+       LONG $0x6c0f4566; BYTE $0xc1               // PUNPCKLQDQ  XMM8,  XMM9  /* m[12],  ____ */
+       MOVOU X15, X9
+       LONG $0x6c0f4566; BYTE $0xcd               // PUNPCKLQDQ  XMM9, XMM13  /* m[14],  m[4] */
+       MOVOU 80(DX), X11                          // X11 = m[10]+m[11]
+       MOVOU X13, X10
+       LONG $0x6d0f4566; BYTE $0xd7               // PUNPCKHQDQ XMM10, XMM15  /*  m[5], m[15] */
+       LONG $0x3a0f4566; WORD $0xde0f; BYTE $0x08 // PALIGNR    XMM11, XMM14, 0x8  /* m[13], m[10] */
+
+       LOAD_SHUFFLE
+       G1
+       G2
+       DIAGONALIZE
+
+       // LOAD_MSG_ ##r ##_3 / ##_4(b0, b1); (X12 is temp register)
+       MOVOU 0(DX), X12                           // X12 =  m[0]+ m[1]
+       MOVOU 48(DX), X13                          // X13 =  m[6]+ m[7]
+       MOVOU 64(DX), X14                          // X14 =  m[8]+ m[9]
+       MOVOU 80(DX), X15                          // X15 = m[10]+m[11]
+       MOVOU X12, X8
+       LONG $0x6c0f4566; BYTE $0xc5               // PUNPCKLQDQ  XMM8, XMM13  /*  m[0],  m[6] */
+       MOVOU X14, X9
+       LONG $0x3a0f4566; WORD $0xce0f; BYTE $0x08 // PALIGNR     XMM9, XMM14, 0x8  /*  m[9],  m[8] */
+       MOVOU 16(DX), X11                          // X14 =  m[2]+ m[3]
+       MOVOU X13, X10
+       LONG $0x6d0f4566; BYTE $0xd3               // PUNPCKHQDQ XMM10, XMM11  /*  m[7],  m[3] */
+       LONG $0x6d0f4566; BYTE $0xff               // PUNPCKHQDQ XMM15, XMM15  /*   ___, m[11] */
+       LONG $0x6c0f4566; BYTE $0xdf               // PUNPCKLQDQ XMM11, XMM15  /*  m[2],  ____ */
+
+       LOAD_SHUFFLE
+       G1
+       G2
+       UNDIAGONALIZE
+
+       ///////////////////////////////////////////////////////////////////////////
+       // R O U N D   8
+       ///////////////////////////////////////////////////////////////////////////
+
+       // LOAD_MSG_ ##r ##_1 / ##_2(b0, b1); (X12 is temp register)
+       MOVOU 16(DX), X12                          // X12 =  m[2]+ m[3]
+       MOVOU 48(DX), X13                          // X13 =  m[6]+ m[7]
+       MOVOU 96(DX), X14                          // X14 = m[12]+m[13]
+       MOVOU 112(DX), X15                         // X15 = m[14]+m[15]
+       MOVOU X14, X8
+       LONG $0x6d0f4566; BYTE $0xc5               // PUNPCKHQDQ  XMM8, XMM13  /* m[13],  m[7] */
+       MOVOU X12, X10
+       LONG $0x6d0f4566; BYTE $0xd4               // PUNPCKHQDQ XMM10, XMM12  /*   ___,  m[3] */
+       MOVOU X14, X9
+       LONG $0x6c0f4566; BYTE $0xca               // PUNPCKLQDQ  XMM9,  XMM10  /* m[12],  ____ */
+       MOVOU 0(DX), X11                           // X11 =  m[0]+ m[1]
+       MOVOU 64(DX), X13                          // X13 =  m[8]+ m[9]
+       MOVOU 80(DX), X14                          // X14 = m[10]+m[11]
+       MOVOU X15, X10
+       LONG $0x3a0f4566; WORD $0xd60f; BYTE $0x08 // PALIGNR    XMM10, XMM14, 0x8  /* m[11], m[14] */
+       LONG $0x6d0f4566; BYTE $0xdd               // PUNPCKHQDQ XMM11, XMM13  /*  m[1],  m[9] */
+
+       LOAD_SHUFFLE
+       G1
+       G2
+       DIAGONALIZE
+
+       // LOAD_MSG_ ##r ##_3 / ##_4(b0, b1); (X12 is temp register)
+       MOVOU 16(DX), X12            // X12 =  m[2]+ m[3]
+       MOVOU 32(DX), X13            // X13 =  m[4]+ m[5]
+       MOVOU 64(DX), X14            // X14 =  m[8]+ m[9]
+       MOVOU 112(DX), X15           // X15 = m[14]+m[15]
+       MOVOU X13, X8
+       LONG $0x6d0f4566; BYTE $0xc7 // PUNPCKHQDQ  XMM8, XMM15  /*  m[5], m[15] */
+       MOVOU X14, X9
+       LONG $0x6c0f4566; BYTE $0xcc // PUNPCKLQDQ  XMM9, XMM12  /*  m[8],  m[2] */
+       MOVOU 0(DX), X10             // X10 =  m[0]+ m[1]
+       MOVOU 48(DX), X11            // X11 =  m[6]+ m[7]
+       MOVOU 80(DX), X15            // X15 = m[10]+m[11]
+       LONG $0x6c0f4566; BYTE $0xd5 // PUNPCKLQDQ XMM10, XMM13  /*  m[0],  m[4] */
+       LONG $0x6c0f4566; BYTE $0xdf // PUNPCKLQDQ XMM11, XMM15  /*  m[6], m[10] */
+
+       LOAD_SHUFFLE
+       G1
+       G2
+       UNDIAGONALIZE
+
+       ///////////////////////////////////////////////////////////////////////////
+       // R O U N D   9
+       ///////////////////////////////////////////////////////////////////////////
+
+       // LOAD_MSG_ ##r ##_1 / ##_2(b0, b1); (X12 is temp register)
+       MOVOU 0(DX), X12                            // X12 =  m[0]+ m[1]
+       MOVOU 48(DX), X13                           // X13 =  m[6]+ m[7]
+       MOVOU 80(DX), X14                           // X14 = m[10]+m[11]
+       MOVOU 112(DX), X15                          // X15 = m[14]+m[15]
+       MOVOU X13, X8
+       LONG  $0x6c0f4566; BYTE $0xc7               // PUNPCKLQDQ  XMM8, XMM15  /*  m[6], m[14] */
+       MOVOU X12, X9
+       LONG  $0x3a0f4566; WORD $0xce0f; BYTE $0x08 // PALIGNR     XMM9, XMM14, 0x8  /* m[11],  m[0] */
+       MOVOU 16(DX), X13                           // X13 =  m[2]+ m[3]
+       MOVOU 64(DX), X11                           // X11 =  m[8]+ m[9]
+       MOVOU X15, X10
+       LONG  $0x6d0f4566; BYTE $0xd3               // PUNPCKHQDQ XMM10, XMM11  /* m[15],  m[9] */
+       LONG  $0x3a0f4566; WORD $0xdd0f; BYTE $0x08 // PALIGNR    XMM11, XMM13, 0x8  /*  m[3],  m[8] */
+
+       LOAD_SHUFFLE
+       G1
+       G2
+       DIAGONALIZE
+
+       // LOAD_MSG_ ##r ##_3 / ##_4(b0, b1); (X12 is temp register)
+       MOVOU 0(DX), X12                           // X12 =  m[0]+ m[1]
+       MOVOU 16(DX), X13                          // X13 =  m[2]+ m[3]
+       MOVOU 80(DX), X14                          // X14 = m[10]+m[11]
+       MOVOU 96(DX), X15                          // X15 = m[12]+m[13]
+       MOVOU X15, X9
+       LONG $0x6d0f4566; BYTE $0xcf               // PUNPCKHQDQ  XMM9, XMM15  /*   ___, m[13] */
+       MOVOU X15, X8
+       LONG $0x6c0f4566; BYTE $0xc1               // PUNPCKLQDQ  XMM8,  XMM9  /* m[12],  ____ */
+       MOVOU X14, X9
+       LONG $0x3a0f4566; WORD $0xcc0f; BYTE $0x08 // PALIGNR     XMM9, XMM12, 0x8  /*  m[1], m[10] */
+       MOVOU 32(DX), X12                          // X12 =  m[4]+ m[5]
+       MOVOU 48(DX), X15                          // X15 =  m[6]+ m[7]
+       MOVOU X15, X11
+       LONG $0x6d0f4566; BYTE $0xdf               // PUNPCKHQDQ XMM11, XMM15  /*   ___,  m[7] */
+       MOVOU X13, X10
+       LONG $0x6c0f4566; BYTE $0xd3               // PUNPCKLQDQ XMM10, XMM11  /*  m[2],  ____ */
+       MOVOU X12, X15
+       LONG $0x6d0f4566; BYTE $0xfc               // PUNPCKHQDQ XMM15, XMM12  /*   ___,  m[5] */
+       MOVOU X12, X11
+       LONG $0x6c0f4566; BYTE $0xdf               // PUNPCKLQDQ XMM11, XMM15  /*  m[4],  ____ */
+
+       LOAD_SHUFFLE
+       G1
+       G2
+       UNDIAGONALIZE
+
+       ///////////////////////////////////////////////////////////////////////////
+       // R O U N D   1 0
+       ///////////////////////////////////////////////////////////////////////////
+
+       // LOAD_MSG_ ##r ##_1 / ##_2(b0, b1); (X12 is temp register)
+       MOVOU 0(DX), X12             // X12 =  m[0]+ m[1]
+       MOVOU 48(DX), X13            // X13 =  m[6]+ m[7]
+       MOVOU 64(DX), X14            // X14 =  m[8]+ m[9]
+       MOVOU 80(DX), X15            // X15 = m[10]+m[11]
+       MOVOU X15, X8
+       LONG $0x6c0f4566; BYTE $0xc6 // PUNPCKLQDQ  XMM8, XMM14  /* m[10],  m[8] */
+       MOVOU X13, X9
+       LONG $0x6d0f4566; BYTE $0xcc // PUNPCKHQDQ  XMM9, XMM12  /*  m[7],  m[1] */
+       MOVOU 16(DX), X10            // X10 =  m[2]+ m[3]
+       MOVOU 32(DX), X14            // X14 =  m[4]+ m[5]
+       LONG $0x6c0f4566; BYTE $0xd6 // PUNPCKLQDQ XMM10, XMM14  /*  m[2],  m[4] */
+       MOVOU X14, X15
+       LONG $0x6d0f4566; BYTE $0xfe // PUNPCKHQDQ XMM15, XMM14  /*   ___,  m[5] */
+       MOVOU X13, X11
+       LONG $0x6c0f4566; BYTE $0xdf // PUNPCKLQDQ XMM11, XMM15  /*  m[6],  ____ */
+
+       LOAD_SHUFFLE
+       G1
+       G2
+       DIAGONALIZE
+
+       // LOAD_MSG_ ##r ##_3 / ##_4(b0, b1); (X12 is temp register)
+       MOVOU 16(DX), X12                          // X12 =  m[2]+ m[3]
+       MOVOU 64(DX), X13                          // X13 =  m[8]+ m[9]
+       MOVOU 96(DX), X14                          // X14 = m[12]+m[13]
+       MOVOU 112(DX), X15                         // X15 = m[14]+m[15]
+       MOVOU X15, X8
+       LONG $0x6d0f4566; BYTE $0xc5               // PUNPCKHQDQ  XMM8, XMM13  /* m[15],  m[9] */
+       MOVOU X12, X9
+       LONG $0x6d0f4566; BYTE $0xce               // PUNPCKHQDQ  XMM9, XMM14  /*  m[3], m[13] */
+       MOVOU 0(DX), X12                           // X12 =  m[0]+ m[1]
+       MOVOU 80(DX), X13                          // X13 = m[10]+m[11]
+       MOVOU X15, X10
+       LONG $0x3a0f4566; WORD $0xd50f; BYTE $0x08 // PALIGNR    XMM10, XMM13, 0x8  /* m[11], m[14] */
+       MOVOU X14, X11
+       LONG $0x6c0f4566; BYTE $0xdc               // PUNPCKLQDQ XMM11, XMM12  /* m[12],  m[0] */
+
+       LOAD_SHUFFLE
+       G1
+       G2
+       UNDIAGONALIZE
+
+       ///////////////////////////////////////////////////////////////////////////
+       // R O U N D   1 1
+       ///////////////////////////////////////////////////////////////////////////
+
+       // LOAD_MSG_ ##r ##_1 / ##_2(b0, b1); (X12 is temp register)
+       MOVOU 0(DX), X12             // X12 = m[0]+m[1]
+       MOVOU 16(DX), X13            // X13 = m[2]+m[3]
+       MOVOU 32(DX), X14            // X14 = m[4]+m[5]
+       MOVOU 48(DX), X15            // X15 = m[6]+m[7]
+       MOVOU X12, X8
+       LONG $0x6c0f4566; BYTE $0xc5 // PUNPCKLQDQ  XMM8, XMM13  /* m[0], m[2] */
+       MOVOU X14, X9
+       LONG $0x6c0f4566; BYTE $0xcf // PUNPCKLQDQ  XMM9, XMM15  /* m[4], m[6] */
+       MOVOU X12, X10
+       LONG $0x6d0f4566; BYTE $0xd5 // PUNPCKHQDQ XMM10, XMM13  /* m[1], m[3] */
+       MOVOU X14, X11
+       LONG $0x6d0f4566; BYTE $0xdf // PUNPCKHQDQ XMM11, XMM15  /* m[5], m[7] */
+
+       LOAD_SHUFFLE
+       G1
+       G2
+       DIAGONALIZE
+
+       // LOAD_MSG_ ##r ##_3 / ##_4(b0, b1); (X12 is temp register)
+       MOVOU 64(DX), X12            // X12 =  m[8]+ m[9]
+       MOVOU 80(DX), X13            // X13 = m[10]+m[11]
+       MOVOU 96(DX), X14            // X14 = m[12]+m[13]
+       MOVOU 112(DX), X15           // X15 = m[14]+m[15]
+       MOVOU X12, X8
+       LONG $0x6c0f4566; BYTE $0xc5 // PUNPCKLQDQ  XMM8, XMM13  /*  m[8],m[10] */
+       MOVOU X14, X9
+       LONG $0x6c0f4566; BYTE $0xcf // PUNPCKLQDQ  XMM9, XMM15  /* m[12],m[14] */
+       MOVOU X12, X10
+       LONG $0x6d0f4566; BYTE $0xd5 // PUNPCKHQDQ XMM10, XMM13  /*  m[9],m[11] */
+       MOVOU X14, X11
+       LONG $0x6d0f4566; BYTE $0xdf // PUNPCKHQDQ XMM11, XMM15  /* m[13],m[15] */
+
+       LOAD_SHUFFLE
+       G1
+       G2
+       UNDIAGONALIZE
+
+       ///////////////////////////////////////////////////////////////////////////
+       // R O U N D   1 2
+       ///////////////////////////////////////////////////////////////////////////
+
+       // LOAD_MSG_ ##r ##_1 / ##_2(b0, b1); (X12 is temp register)
+       MOVOU 112(DX), X12                         // X12 = m[14]+m[15]
+       MOVOU 32(DX), X13                          // X13 =  m[4]+ m[5]
+       MOVOU 64(DX), X14                          // X14 =  m[8]+ m[9]
+       MOVOU 96(DX), X15                          // X15 = m[12]+m[13]
+       MOVOU X12, X8
+       LONG $0x6c0f4566; BYTE $0xc5               // PUNPCKLQDQ  XMM8, XMM13  /* m[14],  m[4] */
+       MOVOU X14, X9
+       LONG $0x6d0f4566; BYTE $0xcf               // PUNPCKHQDQ  XMM9, XMM15  /*  m[9], m[13] */
+       MOVOU 80(DX), X10                          // X10 = m[10]+m[11]
+       MOVOU 48(DX), X11                          // X11 =  m[6]+ m[7]
+       LONG $0x6c0f4566; BYTE $0xd6               // PUNPCKLQDQ XMM10, XMM14  /* m[10],  m[8] */
+       LONG $0x3a0f4566; WORD $0xdc0f; BYTE $0x08 // PALIGNR    XMM11, XMM12, 0x8  /* m[15],  m[6] */; ; ; ; ;
+
+       LOAD_SHUFFLE
+       G1
+       G2
+       DIAGONALIZE
+
+       // LOAD_MSG_ ##r ##_3 / ##_4(b0, b1); (X12 is temp register)
+       MOVOU 0(DX), X12                           // X12 =  m[0]+ m[1]
+       MOVOU 32(DX), X13                          // X13 =  m[4]+ m[5]
+       MOVOU 80(DX), X14                          // X14 = m[10]+m[11]
+       MOVOU X12, X8
+       LONG $0x3a0f4566; WORD $0xc40f; BYTE $0x08 // PALIGNR     XMM8, XMM12, 0x8  /*  m[1],  m[0] */
+       MOVOU X14, X9
+       LONG $0x6d0f4566; BYTE $0xcd               // PUNPCKHQDQ  XMM9, XMM13  /* m[11], m[5] */
+       MOVOU 16(DX), X12                          // X12 =  m[2]+ m[3]
+       MOVOU 48(DX), X11                          // X11 =  m[6]+ m[7]
+       MOVOU 96(DX), X10                          // X10 = m[12]+m[13]
+       LONG $0x6c0f4566; BYTE $0xd4               // PUNPCKLQDQ XMM10, XMM12  /* m[12], m[2] */
+       LONG $0x6d0f4566; BYTE $0xdc               // PUNPCKHQDQ XMM11, XMM12  /*  m[7], m[3] */
+
+       LOAD_SHUFFLE
+       G1
+       G2
+       UNDIAGONALIZE
+
+       // Reload digest (most current value store in &out)
+       MOVQ  out+144(FP), SI // SI: &in
+       MOVOU 0(SI), X12      // X12 = in[0]+in[1]      /* row1l = LOAD( &S->h[0] ); */
+       MOVOU 16(SI), X13     // X13 = in[2]+in[3]      /* row1h = LOAD( &S->h[2] ); */
+       MOVOU 32(SI), X14     // X14 = in[4]+in[5]      /* row2l = LOAD( &S->h[4] ); */
+       MOVOU 48(SI), X15     // X15 = in[6]+in[7]      /* row2h = LOAD( &S->h[6] ); */
+
+       // Final computations and prepare for storing
+       PXOR X4, X0  // X0 = X0 ^ X4          /* row1l = _mm_xor_si128( row3l, row1l ); */
+       PXOR X5, X1  // X1 = X1 ^ X5          /* row1h = _mm_xor_si128( row3h, row1h ); */
+       PXOR X12, X0 // X0 = X0 ^ X12         /*  STORE( &S->h[0], _mm_xor_si128( LOAD( &S->h[0] ), row1l ) ); */
+       PXOR X13, X1 // X1 = X1 ^ X13         /*  STORE( &S->h[2], _mm_xor_si128( LOAD( &S->h[2] ), row1h ) ); */
+       PXOR X6, X2  // X2 = X2 ^ X6          /*  row2l = _mm_xor_si128( row4l, row2l ); */
+       PXOR X7, X3  // X3 = X3 ^ X7          /*  row2h = _mm_xor_si128( row4h, row2h ); */
+       PXOR X14, X2 // X2 = X2 ^ X14         /*  STORE( &S->h[4], _mm_xor_si128( LOAD( &S->h[4] ), row2l ) ); */
+       PXOR X15, X3 // X3 = X3 ^ X15         /*  STORE( &S->h[6], _mm_xor_si128( LOAD( &S->h[6] ), row2h ) ); */
+
+       // Store digest into &out
+       MOVQ  out+144(FP), SI // SI: &out
+       MOVOU X0, 0(SI)       // out[0]+out[1] = X0
+       MOVOU X1, 16(SI)      // out[2]+out[3] = X1
+       MOVOU X2, 32(SI)      // out[4]+out[5] = X2
+       MOVOU X3, 48(SI)      // out[6]+out[7] = X3
+
+       // Increment message pointer and check if there's more to do
+       ADDQ $128, DX // message += 128
+       SUBQ $1, R8
+       JNZ  loop
+
+complete:
+       RET

diff --git a/vendor/github.com/minio/blake2b-simd/compress_amd64.go b/vendor/github.com/minio/blake2b-simd/compress_amd64.go
new file mode 100644 (file)
index 0000000..4fc5e38
--- /dev/null
+++ b/vendor/github.com/minio/blake2b-simd/compress_amd64.go
@@ -0,0 +1,30 @@
+/*
+ * Minio Cloud Storage, (C) 2016 Minio, Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package blake2b
+
+func compress(d *digest, p []uint8) {
+       // Verifies if AVX2 or AVX is available, use optimized code path.
+       if avx2 {
+               compressAVX2(d, p)
+       } else if avx {
+               compressAVX(d, p)
+       } else if ssse3 {
+               compressSSE(d, p)
+       } else {
+               compressGeneric(d, p)
+       }
+}

diff --git a/vendor/github.com/minio/blake2b-simd/compress_generic.go b/vendor/github.com/minio/blake2b-simd/compress_generic.go
new file mode 100644 (file)
index 0000000..e9e16e8
--- /dev/null
+++ b/vendor/github.com/minio/blake2b-simd/compress_generic.go
@@ -0,0 +1,1419 @@
+// Written in 2012 by Dmitry Chestnykh.
+//
+// To the extent possible under law, the author have dedicated all copyright
+// and related and neighboring rights to this software to the public domain
+// worldwide. This software is distributed without any warranty.
+// http://creativecommons.org/publicdomain/zero/1.0/
+
+package blake2b
+
+func compressGeneric(d *digest, p []uint8) {
+       h0, h1, h2, h3, h4, h5, h6, h7 := d.h[0], d.h[1], d.h[2], d.h[3], d.h[4], d.h[5], d.h[6], d.h[7]
+
+       for len(p) >= BlockSize {
+               // Increment counter.
+               d.t[0] += BlockSize
+               if d.t[0] < BlockSize {
+                       d.t[1]++
+               }
+               // Initialize compression function.
+               v0, v1, v2, v3, v4, v5, v6, v7 := h0, h1, h2, h3, h4, h5, h6, h7
+               v8 := iv[0]
+               v9 := iv[1]
+               v10 := iv[2]
+               v11 := iv[3]
+               v12 := iv[4] ^ d.t[0]
+               v13 := iv[5] ^ d.t[1]
+               v14 := iv[6] ^ d.f[0]
+               v15 := iv[7] ^ d.f[1]
+
+               j := 0
+               var m [16]uint64
+               for i := range m {
+                       m[i] = uint64(p[j]) | uint64(p[j+1])<<8 | uint64(p[j+2])<<16 |
+                               uint64(p[j+3])<<24 | uint64(p[j+4])<<32 | uint64(p[j+5])<<40 |
+                               uint64(p[j+6])<<48 | uint64(p[j+7])<<56
+                       j += 8
+               }
+
+               // Round 1.
+               v0 += m[0]
+               v0 += v4
+               v12 ^= v0
+               v12 = v12<<(64-32) | v12>>32
+               v8 += v12
+               v4 ^= v8
+               v4 = v4<<(64-24) | v4>>24
+               v1 += m[2]
+               v1 += v5
+               v13 ^= v1
+               v13 = v13<<(64-32) | v13>>32
+               v9 += v13
+               v5 ^= v9
+               v5 = v5<<(64-24) | v5>>24
+               v2 += m[4]
+               v2 += v6
+               v14 ^= v2
+               v14 = v14<<(64-32) | v14>>32
+               v10 += v14
+               v6 ^= v10
+               v6 = v6<<(64-24) | v6>>24
+               v3 += m[6]
+               v3 += v7
+               v15 ^= v3
+               v15 = v15<<(64-32) | v15>>32
+               v11 += v15
+               v7 ^= v11
+               v7 = v7<<(64-24) | v7>>24
+               v2 += m[5]
+               v2 += v6
+               v14 ^= v2
+               v14 = v14<<(64-16) | v14>>16
+               v10 += v14
+               v6 ^= v10
+               v6 = v6<<(64-63) | v6>>63
+               v3 += m[7]
+               v3 += v7
+               v15 ^= v3
+               v15 = v15<<(64-16) | v15>>16
+               v11 += v15
+               v7 ^= v11
+               v7 = v7<<(64-63) | v7>>63
+               v1 += m[3]
+               v1 += v5
+               v13 ^= v1
+               v13 = v13<<(64-16) | v13>>16
+               v9 += v13
+               v5 ^= v9
+               v5 = v5<<(64-63) | v5>>63
+               v0 += m[1]
+               v0 += v4
+               v12 ^= v0
+               v12 = v12<<(64-16) | v12>>16
+               v8 += v12
+               v4 ^= v8
+               v4 = v4<<(64-63) | v4>>63
+               v0 += m[8]
+               v0 += v5
+               v15 ^= v0
+               v15 = v15<<(64-32) | v15>>32
+               v10 += v15
+               v5 ^= v10
+               v5 = v5<<(64-24) | v5>>24
+               v1 += m[10]
+               v1 += v6
+               v12 ^= v1
+               v12 = v12<<(64-32) | v12>>32
+               v11 += v12
+               v6 ^= v11
+               v6 = v6<<(64-24) | v6>>24
+               v2 += m[12]
+               v2 += v7
+               v13 ^= v2
+               v13 = v13<<(64-32) | v13>>32
+               v8 += v13
+               v7 ^= v8
+               v7 = v7<<(64-24) | v7>>24
+               v3 += m[14]
+               v3 += v4
+               v14 ^= v3
+               v14 = v14<<(64-32) | v14>>32
+               v9 += v14
+               v4 ^= v9
+               v4 = v4<<(64-24) | v4>>24
+               v2 += m[13]
+               v2 += v7
+               v13 ^= v2
+               v13 = v13<<(64-16) | v13>>16
+               v8 += v13
+               v7 ^= v8
+               v7 = v7<<(64-63) | v7>>63
+               v3 += m[15]
+               v3 += v4
+               v14 ^= v3
+               v14 = v14<<(64-16) | v14>>16
+               v9 += v14
+               v4 ^= v9
+               v4 = v4<<(64-63) | v4>>63
+               v1 += m[11]
+               v1 += v6
+               v12 ^= v1
+               v12 = v12<<(64-16) | v12>>16
+               v11 += v12
+               v6 ^= v11
+               v6 = v6<<(64-63) | v6>>63
+               v0 += m[9]
+               v0 += v5
+               v15 ^= v0
+               v15 = v15<<(64-16) | v15>>16
+               v10 += v15
+               v5 ^= v10
+               v5 = v5<<(64-63) | v5>>63
+
+               // Round 2.
+               v0 += m[14]
+               v0 += v4
+               v12 ^= v0
+               v12 = v12<<(64-32) | v12>>32
+               v8 += v12
+               v4 ^= v8
+               v4 = v4<<(64-24) | v4>>24
+               v1 += m[4]
+               v1 += v5
+               v13 ^= v1
+               v13 = v13<<(64-32) | v13>>32
+               v9 += v13
+               v5 ^= v9
+               v5 = v5<<(64-24) | v5>>24
+               v2 += m[9]
+               v2 += v6
+               v14 ^= v2
+               v14 = v14<<(64-32) | v14>>32
+               v10 += v14
+               v6 ^= v10
+               v6 = v6<<(64-24) | v6>>24
+               v3 += m[13]
+               v3 += v7
+               v15 ^= v3
+               v15 = v15<<(64-32) | v15>>32
+               v11 += v15
+               v7 ^= v11
+               v7 = v7<<(64-24) | v7>>24
+               v2 += m[15]
+               v2 += v6
+               v14 ^= v2
+               v14 = v14<<(64-16) | v14>>16
+               v10 += v14
+               v6 ^= v10
+               v6 = v6<<(64-63) | v6>>63
+               v3 += m[6]
+               v3 += v7
+               v15 ^= v3
+               v15 = v15<<(64-16) | v15>>16
+               v11 += v15
+               v7 ^= v11
+               v7 = v7<<(64-63) | v7>>63
+               v1 += m[8]
+               v1 += v5
+               v13 ^= v1
+               v13 = v13<<(64-16) | v13>>16
+               v9 += v13
+               v5 ^= v9
+               v5 = v5<<(64-63) | v5>>63
+               v0 += m[10]
+               v0 += v4
+               v12 ^= v0
+               v12 = v12<<(64-16) | v12>>16
+               v8 += v12
+               v4 ^= v8
+               v4 = v4<<(64-63) | v4>>63
+               v0 += m[1]
+               v0 += v5
+               v15 ^= v0
+               v15 = v15<<(64-32) | v15>>32
+               v10 += v15
+               v5 ^= v10
+               v5 = v5<<(64-24) | v5>>24
+               v1 += m[0]
+               v1 += v6
+               v12 ^= v1
+               v12 = v12<<(64-32) | v12>>32
+               v11 += v12
+               v6 ^= v11
+               v6 = v6<<(64-24) | v6>>24
+               v2 += m[11]
+               v2 += v7
+               v13 ^= v2
+               v13 = v13<<(64-32) | v13>>32
+               v8 += v13
+               v7 ^= v8
+               v7 = v7<<(64-24) | v7>>24
+               v3 += m[5]
+               v3 += v4
+               v14 ^= v3
+               v14 = v14<<(64-32) | v14>>32
+               v9 += v14
+               v4 ^= v9
+               v4 = v4<<(64-24) | v4>>24
+               v2 += m[7]
+               v2 += v7
+               v13 ^= v2
+               v13 = v13<<(64-16) | v13>>16
+               v8 += v13
+               v7 ^= v8
+               v7 = v7<<(64-63) | v7>>63
+               v3 += m[3]
+               v3 += v4
+               v14 ^= v3
+               v14 = v14<<(64-16) | v14>>16
+               v9 += v14
+               v4 ^= v9
+               v4 = v4<<(64-63) | v4>>63
+               v1 += m[2]
+               v1 += v6
+               v12 ^= v1
+               v12 = v12<<(64-16) | v12>>16
+               v11 += v12
+               v6 ^= v11
+               v6 = v6<<(64-63) | v6>>63
+               v0 += m[12]
+               v0 += v5
+               v15 ^= v0
+               v15 = v15<<(64-16) | v15>>16
+               v10 += v15
+               v5 ^= v10
+               v5 = v5<<(64-63) | v5>>63
+
+               // Round 3.
+               v0 += m[11]
+               v0 += v4
+               v12 ^= v0
+               v12 = v12<<(64-32) | v12>>32
+               v8 += v12
+               v4 ^= v8
+               v4 = v4<<(64-24) | v4>>24
+               v1 += m[12]
+               v1 += v5
+               v13 ^= v1
+               v13 = v13<<(64-32) | v13>>32
+               v9 += v13
+               v5 ^= v9
+               v5 = v5<<(64-24) | v5>>24
+               v2 += m[5]
+               v2 += v6
+               v14 ^= v2
+               v14 = v14<<(64-32) | v14>>32
+               v10 += v14
+               v6 ^= v10
+               v6 = v6<<(64-24) | v6>>24
+               v3 += m[15]
+               v3 += v7
+               v15 ^= v3
+               v15 = v15<<(64-32) | v15>>32
+               v11 += v15
+               v7 ^= v11
+               v7 = v7<<(64-24) | v7>>24
+               v2 += m[2]
+               v2 += v6
+               v14 ^= v2
+               v14 = v14<<(64-16) | v14>>16
+               v10 += v14
+               v6 ^= v10
+               v6 = v6<<(64-63) | v6>>63
+               v3 += m[13]
+               v3 += v7
+               v15 ^= v3
+               v15 = v15<<(64-16) | v15>>16
+               v11 += v15
+               v7 ^= v11
+               v7 = v7<<(64-63) | v7>>63
+               v1 += m[0]
+               v1 += v5
+               v13 ^= v1
+               v13 = v13<<(64-16) | v13>>16
+               v9 += v13
+               v5 ^= v9
+               v5 = v5<<(64-63) | v5>>63
+               v0 += m[8]
+               v0 += v4
+               v12 ^= v0
+               v12 = v12<<(64-16) | v12>>16
+               v8 += v12
+               v4 ^= v8
+               v4 = v4<<(64-63) | v4>>63
+               v0 += m[10]
+               v0 += v5
+               v15 ^= v0
+               v15 = v15<<(64-32) | v15>>32
+               v10 += v15
+               v5 ^= v10
+               v5 = v5<<(64-24) | v5>>24
+               v1 += m[3]
+               v1 += v6
+               v12 ^= v1
+               v12 = v12<<(64-32) | v12>>32
+               v11 += v12
+               v6 ^= v11
+               v6 = v6<<(64-24) | v6>>24
+               v2 += m[7]
+               v2 += v7
+               v13 ^= v2
+               v13 = v13<<(64-32) | v13>>32
+               v8 += v13
+               v7 ^= v8
+               v7 = v7<<(64-24) | v7>>24
+               v3 += m[9]
+               v3 += v4
+               v14 ^= v3
+               v14 = v14<<(64-32) | v14>>32
+               v9 += v14
+               v4 ^= v9
+               v4 = v4<<(64-24) | v4>>24
+               v2 += m[1]
+               v2 += v7
+               v13 ^= v2
+               v13 = v13<<(64-16) | v13>>16
+               v8 += v13
+               v7 ^= v8
+               v7 = v7<<(64-63) | v7>>63
+               v3 += m[4]
+               v3 += v4
+               v14 ^= v3
+               v14 = v14<<(64-16) | v14>>16
+               v9 += v14
+               v4 ^= v9
+               v4 = v4<<(64-63) | v4>>63
+               v1 += m[6]
+               v1 += v6
+               v12 ^= v1
+               v12 = v12<<(64-16) | v12>>16
+               v11 += v12
+               v6 ^= v11
+               v6 = v6<<(64-63) | v6>>63
+               v0 += m[14]
+               v0 += v5
+               v15 ^= v0
+               v15 = v15<<(64-16) | v15>>16
+               v10 += v15
+               v5 ^= v10
+               v5 = v5<<(64-63) | v5>>63
+
+               // Round 4.
+               v0 += m[7]
+               v0 += v4
+               v12 ^= v0
+               v12 = v12<<(64-32) | v12>>32
+               v8 += v12
+               v4 ^= v8
+               v4 = v4<<(64-24) | v4>>24
+               v1 += m[3]
+               v1 += v5
+               v13 ^= v1
+               v13 = v13<<(64-32) | v13>>32
+               v9 += v13
+               v5 ^= v9
+               v5 = v5<<(64-24) | v5>>24
+               v2 += m[13]
+               v2 += v6
+               v14 ^= v2
+               v14 = v14<<(64-32) | v14>>32
+               v10 += v14
+               v6 ^= v10
+               v6 = v6<<(64-24) | v6>>24
+               v3 += m[11]
+               v3 += v7
+               v15 ^= v3
+               v15 = v15<<(64-32) | v15>>32
+               v11 += v15
+               v7 ^= v11
+               v7 = v7<<(64-24) | v7>>24
+               v2 += m[12]
+               v2 += v6
+               v14 ^= v2
+               v14 = v14<<(64-16) | v14>>16
+               v10 += v14
+               v6 ^= v10
+               v6 = v6<<(64-63) | v6>>63
+               v3 += m[14]
+               v3 += v7
+               v15 ^= v3
+               v15 = v15<<(64-16) | v15>>16
+               v11 += v15
+               v7 ^= v11
+               v7 = v7<<(64-63) | v7>>63
+               v1 += m[1]
+               v1 += v5
+               v13 ^= v1
+               v13 = v13<<(64-16) | v13>>16
+               v9 += v13
+               v5 ^= v9
+               v5 = v5<<(64-63) | v5>>63
+               v0 += m[9]
+               v0 += v4
+               v12 ^= v0
+               v12 = v12<<(64-16) | v12>>16
+               v8 += v12
+               v4 ^= v8
+               v4 = v4<<(64-63) | v4>>63
+               v0 += m[2]
+               v0 += v5
+               v15 ^= v0
+               v15 = v15<<(64-32) | v15>>32
+               v10 += v15
+               v5 ^= v10
+               v5 = v5<<(64-24) | v5>>24
+               v1 += m[5]
+               v1 += v6
+               v12 ^= v1
+               v12 = v12<<(64-32) | v12>>32
+               v11 += v12
+               v6 ^= v11
+               v6 = v6<<(64-24) | v6>>24
+               v2 += m[4]
+               v2 += v7
+               v13 ^= v2
+               v13 = v13<<(64-32) | v13>>32
+               v8 += v13
+               v7 ^= v8
+               v7 = v7<<(64-24) | v7>>24
+               v3 += m[15]
+               v3 += v4
+               v14 ^= v3
+               v14 = v14<<(64-32) | v14>>32
+               v9 += v14
+               v4 ^= v9
+               v4 = v4<<(64-24) | v4>>24
+               v2 += m[0]
+               v2 += v7
+               v13 ^= v2
+               v13 = v13<<(64-16) | v13>>16
+               v8 += v13
+               v7 ^= v8
+               v7 = v7<<(64-63) | v7>>63
+               v3 += m[8]
+               v3 += v4
+               v14 ^= v3
+               v14 = v14<<(64-16) | v14>>16
+               v9 += v14
+               v4 ^= v9
+               v4 = v4<<(64-63) | v4>>63
+               v1 += m[10]
+               v1 += v6
+               v12 ^= v1
+               v12 = v12<<(64-16) | v12>>16
+               v11 += v12
+               v6 ^= v11
+               v6 = v6<<(64-63) | v6>>63
+               v0 += m[6]
+               v0 += v5
+               v15 ^= v0
+               v15 = v15<<(64-16) | v15>>16
+               v10 += v15
+               v5 ^= v10
+               v5 = v5<<(64-63) | v5>>63
+
+               // Round 5.
+               v0 += m[9]
+               v0 += v4
+               v12 ^= v0
+               v12 = v12<<(64-32) | v12>>32
+               v8 += v12
+               v4 ^= v8
+               v4 = v4<<(64-24) | v4>>24
+               v1 += m[5]
+               v1 += v5
+               v13 ^= v1
+               v13 = v13<<(64-32) | v13>>32
+               v9 += v13
+               v5 ^= v9
+               v5 = v5<<(64-24) | v5>>24
+               v2 += m[2]
+               v2 += v6
+               v14 ^= v2
+               v14 = v14<<(64-32) | v14>>32
+               v10 += v14
+               v6 ^= v10
+               v6 = v6<<(64-24) | v6>>24
+               v3 += m[10]
+               v3 += v7
+               v15 ^= v3
+               v15 = v15<<(64-32) | v15>>32
+               v11 += v15
+               v7 ^= v11
+               v7 = v7<<(64-24) | v7>>24
+               v2 += m[4]
+               v2 += v6
+               v14 ^= v2
+               v14 = v14<<(64-16) | v14>>16
+               v10 += v14
+               v6 ^= v10
+               v6 = v6<<(64-63) | v6>>63
+               v3 += m[15]
+               v3 += v7
+               v15 ^= v3
+               v15 = v15<<(64-16) | v15>>16
+               v11 += v15
+               v7 ^= v11
+               v7 = v7<<(64-63) | v7>>63
+               v1 += m[7]
+               v1 += v5
+               v13 ^= v1
+               v13 = v13<<(64-16) | v13>>16
+               v9 += v13
+               v5 ^= v9
+               v5 = v5<<(64-63) | v5>>63
+               v0 += m[0]
+               v0 += v4
+               v12 ^= v0
+               v12 = v12<<(64-16) | v12>>16
+               v8 += v12
+               v4 ^= v8
+               v4 = v4<<(64-63) | v4>>63
+               v0 += m[14]
+               v0 += v5
+               v15 ^= v0
+               v15 = v15<<(64-32) | v15>>32
+               v10 += v15
+               v5 ^= v10
+               v5 = v5<<(64-24) | v5>>24
+               v1 += m[11]
+               v1 += v6
+               v12 ^= v1
+               v12 = v12<<(64-32) | v12>>32
+               v11 += v12
+               v6 ^= v11
+               v6 = v6<<(64-24) | v6>>24
+               v2 += m[6]
+               v2 += v7
+               v13 ^= v2
+               v13 = v13<<(64-32) | v13>>32
+               v8 += v13
+               v7 ^= v8
+               v7 = v7<<(64-24) | v7>>24
+               v3 += m[3]
+               v3 += v4
+               v14 ^= v3
+               v14 = v14<<(64-32) | v14>>32
+               v9 += v14
+               v4 ^= v9
+               v4 = v4<<(64-24) | v4>>24
+               v2 += m[8]
+               v2 += v7
+               v13 ^= v2
+               v13 = v13<<(64-16) | v13>>16
+               v8 += v13
+               v7 ^= v8
+               v7 = v7<<(64-63) | v7>>63
+               v3 += m[13]
+               v3 += v4
+               v14 ^= v3
+               v14 = v14<<(64-16) | v14>>16
+               v9 += v14
+               v4 ^= v9
+               v4 = v4<<(64-63) | v4>>63
+               v1 += m[12]
+               v1 += v6
+               v12 ^= v1
+               v12 = v12<<(64-16) | v12>>16
+               v11 += v12
+               v6 ^= v11
+               v6 = v6<<(64-63) | v6>>63
+               v0 += m[1]
+               v0 += v5
+               v15 ^= v0
+               v15 = v15<<(64-16) | v15>>16
+               v10 += v15
+               v5 ^= v10
+               v5 = v5<<(64-63) | v5>>63
+
+               // Round 6.
+               v0 += m[2]
+               v0 += v4
+               v12 ^= v0
+               v12 = v12<<(64-32) | v12>>32
+               v8 += v12
+               v4 ^= v8
+               v4 = v4<<(64-24) | v4>>24
+               v1 += m[6]
+               v1 += v5
+               v13 ^= v1
+               v13 = v13<<(64-32) | v13>>32
+               v9 += v13
+               v5 ^= v9
+               v5 = v5<<(64-24) | v5>>24
+               v2 += m[0]
+               v2 += v6
+               v14 ^= v2
+               v14 = v14<<(64-32) | v14>>32
+               v10 += v14
+               v6 ^= v10
+               v6 = v6<<(64-24) | v6>>24
+               v3 += m[8]
+               v3 += v7
+               v15 ^= v3
+               v15 = v15<<(64-32) | v15>>32
+               v11 += v15
+               v7 ^= v11
+               v7 = v7<<(64-24) | v7>>24
+               v2 += m[11]
+               v2 += v6
+               v14 ^= v2
+               v14 = v14<<(64-16) | v14>>16
+               v10 += v14
+               v6 ^= v10
+               v6 = v6<<(64-63) | v6>>63
+               v3 += m[3]
+               v3 += v7
+               v15 ^= v3
+               v15 = v15<<(64-16) | v15>>16
+               v11 += v15
+               v7 ^= v11
+               v7 = v7<<(64-63) | v7>>63
+               v1 += m[10]
+               v1 += v5
+               v13 ^= v1
+               v13 = v13<<(64-16) | v13>>16
+               v9 += v13
+               v5 ^= v9
+               v5 = v5<<(64-63) | v5>>63
+               v0 += m[12]
+               v0 += v4
+               v12 ^= v0
+               v12 = v12<<(64-16) | v12>>16
+               v8 += v12
+               v4 ^= v8
+               v4 = v4<<(64-63) | v4>>63
+               v0 += m[4]
+               v0 += v5
+               v15 ^= v0
+               v15 = v15<<(64-32) | v15>>32
+               v10 += v15
+               v5 ^= v10
+               v5 = v5<<(64-24) | v5>>24
+               v1 += m[7]
+               v1 += v6
+               v12 ^= v1
+               v12 = v12<<(64-32) | v12>>32
+               v11 += v12
+               v6 ^= v11
+               v6 = v6<<(64-24) | v6>>24
+               v2 += m[15]
+               v2 += v7
+               v13 ^= v2
+               v13 = v13<<(64-32) | v13>>32
+               v8 += v13
+               v7 ^= v8
+               v7 = v7<<(64-24) | v7>>24
+               v3 += m[1]
+               v3 += v4
+               v14 ^= v3
+               v14 = v14<<(64-32) | v14>>32
+               v9 += v14
+               v4 ^= v9
+               v4 = v4<<(64-24) | v4>>24
+               v2 += m[14]
+               v2 += v7
+               v13 ^= v2
+               v13 = v13<<(64-16) | v13>>16
+               v8 += v13
+               v7 ^= v8
+               v7 = v7<<(64-63) | v7>>63
+               v3 += m[9]
+               v3 += v4
+               v14 ^= v3
+               v14 = v14<<(64-16) | v14>>16
+               v9 += v14
+               v4 ^= v9
+               v4 = v4<<(64-63) | v4>>63
+               v1 += m[5]
+               v1 += v6
+               v12 ^= v1
+               v12 = v12<<(64-16) | v12>>16
+               v11 += v12
+               v6 ^= v11
+               v6 = v6<<(64-63) | v6>>63
+               v0 += m[13]
+               v0 += v5
+               v15 ^= v0
+               v15 = v15<<(64-16) | v15>>16
+               v10 += v15
+               v5 ^= v10
+               v5 = v5<<(64-63) | v5>>63
+
+               // Round 7.
+               v0 += m[12]
+               v0 += v4
+               v12 ^= v0
+               v12 = v12<<(64-32) | v12>>32
+               v8 += v12
+               v4 ^= v8
+               v4 = v4<<(64-24) | v4>>24
+               v1 += m[1]
+               v1 += v5
+               v13 ^= v1
+               v13 = v13<<(64-32) | v13>>32
+               v9 += v13
+               v5 ^= v9
+               v5 = v5<<(64-24) | v5>>24
+               v2 += m[14]
+               v2 += v6
+               v14 ^= v2
+               v14 = v14<<(64-32) | v14>>32
+               v10 += v14
+               v6 ^= v10
+               v6 = v6<<(64-24) | v6>>24
+               v3 += m[4]
+               v3 += v7
+               v15 ^= v3
+               v15 = v15<<(64-32) | v15>>32
+               v11 += v15
+               v7 ^= v11
+               v7 = v7<<(64-24) | v7>>24
+               v2 += m[13]
+               v2 += v6
+               v14 ^= v2
+               v14 = v14<<(64-16) | v14>>16
+               v10 += v14
+               v6 ^= v10
+               v6 = v6<<(64-63) | v6>>63
+               v3 += m[10]
+               v3 += v7
+               v15 ^= v3
+               v15 = v15<<(64-16) | v15>>16
+               v11 += v15
+               v7 ^= v11
+               v7 = v7<<(64-63) | v7>>63
+               v1 += m[15]
+               v1 += v5
+               v13 ^= v1
+               v13 = v13<<(64-16) | v13>>16
+               v9 += v13
+               v5 ^= v9
+               v5 = v5<<(64-63) | v5>>63
+               v0 += m[5]
+               v0 += v4
+               v12 ^= v0
+               v12 = v12<<(64-16) | v12>>16
+               v8 += v12
+               v4 ^= v8
+               v4 = v4<<(64-63) | v4>>63
+               v0 += m[0]
+               v0 += v5
+               v15 ^= v0
+               v15 = v15<<(64-32) | v15>>32
+               v10 += v15
+               v5 ^= v10
+               v5 = v5<<(64-24) | v5>>24
+               v1 += m[6]
+               v1 += v6
+               v12 ^= v1
+               v12 = v12<<(64-32) | v12>>32
+               v11 += v12
+               v6 ^= v11
+               v6 = v6<<(64-24) | v6>>24
+               v2 += m[9]
+               v2 += v7
+               v13 ^= v2
+               v13 = v13<<(64-32) | v13>>32
+               v8 += v13
+               v7 ^= v8
+               v7 = v7<<(64-24) | v7>>24
+               v3 += m[8]
+               v3 += v4
+               v14 ^= v3
+               v14 = v14<<(64-32) | v14>>32
+               v9 += v14
+               v4 ^= v9
+               v4 = v4<<(64-24) | v4>>24
+               v2 += m[2]
+               v2 += v7
+               v13 ^= v2
+               v13 = v13<<(64-16) | v13>>16
+               v8 += v13
+               v7 ^= v8
+               v7 = v7<<(64-63) | v7>>63
+               v3 += m[11]
+               v3 += v4
+               v14 ^= v3
+               v14 = v14<<(64-16) | v14>>16
+               v9 += v14
+               v4 ^= v9
+               v4 = v4<<(64-63) | v4>>63
+               v1 += m[3]
+               v1 += v6
+               v12 ^= v1
+               v12 = v12<<(64-16) | v12>>16
+               v11 += v12
+               v6 ^= v11
+               v6 = v6<<(64-63) | v6>>63
+               v0 += m[7]
+               v0 += v5
+               v15 ^= v0
+               v15 = v15<<(64-16) | v15>>16
+               v10 += v15
+               v5 ^= v10
+               v5 = v5<<(64-63) | v5>>63
+
+               // Round 8.
+               v0 += m[13]
+               v0 += v4
+               v12 ^= v0
+               v12 = v12<<(64-32) | v12>>32
+               v8 += v12
+               v4 ^= v8
+               v4 = v4<<(64-24) | v4>>24
+               v1 += m[7]
+               v1 += v5
+               v13 ^= v1
+               v13 = v13<<(64-32) | v13>>32
+               v9 += v13
+               v5 ^= v9
+               v5 = v5<<(64-24) | v5>>24
+               v2 += m[12]
+               v2 += v6
+               v14 ^= v2
+               v14 = v14<<(64-32) | v14>>32
+               v10 += v14
+               v6 ^= v10
+               v6 = v6<<(64-24) | v6>>24
+               v3 += m[3]
+               v3 += v7
+               v15 ^= v3
+               v15 = v15<<(64-32) | v15>>32
+               v11 += v15
+               v7 ^= v11
+               v7 = v7<<(64-24) | v7>>24
+               v2 += m[1]
+               v2 += v6
+               v14 ^= v2
+               v14 = v14<<(64-16) | v14>>16
+               v10 += v14
+               v6 ^= v10
+               v6 = v6<<(64-63) | v6>>63
+               v3 += m[9]
+               v3 += v7
+               v15 ^= v3
+               v15 = v15<<(64-16) | v15>>16
+               v11 += v15
+               v7 ^= v11
+               v7 = v7<<(64-63) | v7>>63
+               v1 += m[14]
+               v1 += v5
+               v13 ^= v1
+               v13 = v13<<(64-16) | v13>>16
+               v9 += v13
+               v5 ^= v9
+               v5 = v5<<(64-63) | v5>>63
+               v0 += m[11]
+               v0 += v4
+               v12 ^= v0
+               v12 = v12<<(64-16) | v12>>16
+               v8 += v12
+               v4 ^= v8
+               v4 = v4<<(64-63) | v4>>63
+               v0 += m[5]
+               v0 += v5
+               v15 ^= v0
+               v15 = v15<<(64-32) | v15>>32
+               v10 += v15
+               v5 ^= v10
+               v5 = v5<<(64-24) | v5>>24
+               v1 += m[15]
+               v1 += v6
+               v12 ^= v1
+               v12 = v12<<(64-32) | v12>>32
+               v11 += v12
+               v6 ^= v11
+               v6 = v6<<(64-24) | v6>>24
+               v2 += m[8]
+               v2 += v7
+               v13 ^= v2
+               v13 = v13<<(64-32) | v13>>32
+               v8 += v13
+               v7 ^= v8
+               v7 = v7<<(64-24) | v7>>24
+               v3 += m[2]
+               v3 += v4
+               v14 ^= v3
+               v14 = v14<<(64-32) | v14>>32
+               v9 += v14
+               v4 ^= v9
+               v4 = v4<<(64-24) | v4>>24
+               v2 += m[6]
+               v2 += v7
+               v13 ^= v2
+               v13 = v13<<(64-16) | v13>>16
+               v8 += v13
+               v7 ^= v8
+               v7 = v7<<(64-63) | v7>>63
+               v3 += m[10]
+               v3 += v4
+               v14 ^= v3
+               v14 = v14<<(64-16) | v14>>16
+               v9 += v14
+               v4 ^= v9
+               v4 = v4<<(64-63) | v4>>63
+               v1 += m[4]
+               v1 += v6
+               v12 ^= v1
+               v12 = v12<<(64-16) | v12>>16
+               v11 += v12
+               v6 ^= v11
+               v6 = v6<<(64-63) | v6>>63
+               v0 += m[0]
+               v0 += v5
+               v15 ^= v0
+               v15 = v15<<(64-16) | v15>>16
+               v10 += v15
+               v5 ^= v10
+               v5 = v5<<(64-63) | v5>>63
+
+               // Round 9.
+               v0 += m[6]
+               v0 += v4
+               v12 ^= v0
+               v12 = v12<<(64-32) | v12>>32
+               v8 += v12
+               v4 ^= v8
+               v4 = v4<<(64-24) | v4>>24
+               v1 += m[14]
+               v1 += v5
+               v13 ^= v1
+               v13 = v13<<(64-32) | v13>>32
+               v9 += v13
+               v5 ^= v9
+               v5 = v5<<(64-24) | v5>>24
+               v2 += m[11]
+               v2 += v6
+               v14 ^= v2
+               v14 = v14<<(64-32) | v14>>32
+               v10 += v14
+               v6 ^= v10
+               v6 = v6<<(64-24) | v6>>24
+               v3 += m[0]
+               v3 += v7
+               v15 ^= v3
+               v15 = v15<<(64-32) | v15>>32
+               v11 += v15
+               v7 ^= v11
+               v7 = v7<<(64-24) | v7>>24
+               v2 += m[3]
+               v2 += v6
+               v14 ^= v2
+               v14 = v14<<(64-16) | v14>>16
+               v10 += v14
+               v6 ^= v10
+               v6 = v6<<(64-63) | v6>>63
+               v3 += m[8]
+               v3 += v7
+               v15 ^= v3
+               v15 = v15<<(64-16) | v15>>16
+               v11 += v15
+               v7 ^= v11
+               v7 = v7<<(64-63) | v7>>63
+               v1 += m[9]
+               v1 += v5
+               v13 ^= v1
+               v13 = v13<<(64-16) | v13>>16
+               v9 += v13
+               v5 ^= v9
+               v5 = v5<<(64-63) | v5>>63
+               v0 += m[15]
+               v0 += v4
+               v12 ^= v0
+               v12 = v12<<(64-16) | v12>>16
+               v8 += v12
+               v4 ^= v8
+               v4 = v4<<(64-63) | v4>>63
+               v0 += m[12]
+               v0 += v5
+               v15 ^= v0
+               v15 = v15<<(64-32) | v15>>32
+               v10 += v15
+               v5 ^= v10
+               v5 = v5<<(64-24) | v5>>24
+               v1 += m[13]
+               v1 += v6
+               v12 ^= v1
+               v12 = v12<<(64-32) | v12>>32
+               v11 += v12
+               v6 ^= v11
+               v6 = v6<<(64-24) | v6>>24
+               v2 += m[1]
+               v2 += v7
+               v13 ^= v2
+               v13 = v13<<(64-32) | v13>>32
+               v8 += v13
+               v7 ^= v8
+               v7 = v7<<(64-24) | v7>>24
+               v3 += m[10]
+               v3 += v4
+               v14 ^= v3
+               v14 = v14<<(64-32) | v14>>32
+               v9 += v14
+               v4 ^= v9
+               v4 = v4<<(64-24) | v4>>24
+               v2 += m[4]
+               v2 += v7
+               v13 ^= v2
+               v13 = v13<<(64-16) | v13>>16
+               v8 += v13
+               v7 ^= v8
+               v7 = v7<<(64-63) | v7>>63
+               v3 += m[5]
+               v3 += v4
+               v14 ^= v3
+               v14 = v14<<(64-16) | v14>>16
+               v9 += v14
+               v4 ^= v9
+               v4 = v4<<(64-63) | v4>>63
+               v1 += m[7]
+               v1 += v6
+               v12 ^= v1
+               v12 = v12<<(64-16) | v12>>16
+               v11 += v12
+               v6 ^= v11
+               v6 = v6<<(64-63) | v6>>63
+               v0 += m[2]
+               v0 += v5
+               v15 ^= v0
+               v15 = v15<<(64-16) | v15>>16
+               v10 += v15
+               v5 ^= v10
+               v5 = v5<<(64-63) | v5>>63
+
+               // Round 10.
+               v0 += m[10]
+               v0 += v4
+               v12 ^= v0
+               v12 = v12<<(64-32) | v12>>32
+               v8 += v12
+               v4 ^= v8
+               v4 = v4<<(64-24) | v4>>24
+               v1 += m[8]
+               v1 += v5
+               v13 ^= v1
+               v13 = v13<<(64-32) | v13>>32
+               v9 += v13
+               v5 ^= v9
+               v5 = v5<<(64-24) | v5>>24
+               v2 += m[7]
+               v2 += v6
+               v14 ^= v2
+               v14 = v14<<(64-32) | v14>>32
+               v10 += v14
+               v6 ^= v10
+               v6 = v6<<(64-24) | v6>>24
+               v3 += m[1]
+               v3 += v7
+               v15 ^= v3
+               v15 = v15<<(64-32) | v15>>32
+               v11 += v15
+               v7 ^= v11
+               v7 = v7<<(64-24) | v7>>24
+               v2 += m[6]
+               v2 += v6
+               v14 ^= v2
+               v14 = v14<<(64-16) | v14>>16
+               v10 += v14
+               v6 ^= v10
+               v6 = v6<<(64-63) | v6>>63
+               v3 += m[5]
+               v3 += v7
+               v15 ^= v3
+               v15 = v15<<(64-16) | v15>>16
+               v11 += v15
+               v7 ^= v11
+               v7 = v7<<(64-63) | v7>>63
+               v1 += m[4]
+               v1 += v5
+               v13 ^= v1
+               v13 = v13<<(64-16) | v13>>16
+               v9 += v13
+               v5 ^= v9
+               v5 = v5<<(64-63) | v5>>63
+               v0 += m[2]
+               v0 += v4
+               v12 ^= v0
+               v12 = v12<<(64-16) | v12>>16
+               v8 += v12
+               v4 ^= v8
+               v4 = v4<<(64-63) | v4>>63
+               v0 += m[15]
+               v0 += v5
+               v15 ^= v0
+               v15 = v15<<(64-32) | v15>>32
+               v10 += v15
+               v5 ^= v10
+               v5 = v5<<(64-24) | v5>>24
+               v1 += m[9]
+               v1 += v6
+               v12 ^= v1
+               v12 = v12<<(64-32) | v12>>32
+               v11 += v12
+               v6 ^= v11
+               v6 = v6<<(64-24) | v6>>24
+               v2 += m[3]
+               v2 += v7
+               v13 ^= v2
+               v13 = v13<<(64-32) | v13>>32
+               v8 += v13
+               v7 ^= v8
+               v7 = v7<<(64-24) | v7>>24
+               v3 += m[13]
+               v3 += v4
+               v14 ^= v3
+               v14 = v14<<(64-32) | v14>>32
+               v9 += v14
+               v4 ^= v9
+               v4 = v4<<(64-24) | v4>>24
+               v2 += m[12]
+               v2 += v7
+               v13 ^= v2
+               v13 = v13<<(64-16) | v13>>16
+               v8 += v13
+               v7 ^= v8
+               v7 = v7<<(64-63) | v7>>63
+               v3 += m[0]
+               v3 += v4
+               v14 ^= v3
+               v14 = v14<<(64-16) | v14>>16
+               v9 += v14
+               v4 ^= v9
+               v4 = v4<<(64-63) | v4>>63
+               v1 += m[14]
+               v1 += v6
+               v12 ^= v1
+               v12 = v12<<(64-16) | v12>>16
+               v11 += v12
+               v6 ^= v11
+               v6 = v6<<(64-63) | v6>>63
+               v0 += m[11]
+               v0 += v5
+               v15 ^= v0
+               v15 = v15<<(64-16) | v15>>16
+               v10 += v15
+               v5 ^= v10
+               v5 = v5<<(64-63) | v5>>63
+
+               // Round 11.
+               v0 += m[0]
+               v0 += v4
+               v12 ^= v0
+               v12 = v12<<(64-32) | v12>>32
+               v8 += v12
+               v4 ^= v8
+               v4 = v4<<(64-24) | v4>>24
+               v1 += m[2]
+               v1 += v5
+               v13 ^= v1
+               v13 = v13<<(64-32) | v13>>32
+               v9 += v13
+               v5 ^= v9
+               v5 = v5<<(64-24) | v5>>24
+               v2 += m[4]
+               v2 += v6
+               v14 ^= v2
+               v14 = v14<<(64-32) | v14>>32
+               v10 += v14
+               v6 ^= v10
+               v6 = v6<<(64-24) | v6>>24
+               v3 += m[6]
+               v3 += v7
+               v15 ^= v3
+               v15 = v15<<(64-32) | v15>>32
+               v11 += v15
+               v7 ^= v11
+               v7 = v7<<(64-24) | v7>>24
+               v2 += m[5]
+               v2 += v6
+               v14 ^= v2
+               v14 = v14<<(64-16) | v14>>16
+               v10 += v14
+               v6 ^= v10
+               v6 = v6<<(64-63) | v6>>63
+               v3 += m[7]
+               v3 += v7
+               v15 ^= v3
+               v15 = v15<<(64-16) | v15>>16
+               v11 += v15
+               v7 ^= v11
+               v7 = v7<<(64-63) | v7>>63
+               v1 += m[3]
+               v1 += v5
+               v13 ^= v1
+               v13 = v13<<(64-16) | v13>>16
+               v9 += v13
+               v5 ^= v9
+               v5 = v5<<(64-63) | v5>>63
+               v0 += m[1]
+               v0 += v4
+               v12 ^= v0
+               v12 = v12<<(64-16) | v12>>16
+               v8 += v12
+               v4 ^= v8
+               v4 = v4<<(64-63) | v4>>63
+               v0 += m[8]
+               v0 += v5
+               v15 ^= v0
+               v15 = v15<<(64-32) | v15>>32
+               v10 += v15
+               v5 ^= v10
+               v5 = v5<<(64-24) | v5>>24
+               v1 += m[10]
+               v1 += v6
+               v12 ^= v1
+               v12 = v12<<(64-32) | v12>>32
+               v11 += v12
+               v6 ^= v11
+               v6 = v6<<(64-24) | v6>>24
+               v2 += m[12]
+               v2 += v7
+               v13 ^= v2
+               v13 = v13<<(64-32) | v13>>32
+               v8 += v13
+               v7 ^= v8
+               v7 = v7<<(64-24) | v7>>24
+               v3 += m[14]
+               v3 += v4
+               v14 ^= v3
+               v14 = v14<<(64-32) | v14>>32
+               v9 += v14
+               v4 ^= v9
+               v4 = v4<<(64-24) | v4>>24
+               v2 += m[13]
+               v2 += v7
+               v13 ^= v2
+               v13 = v13<<(64-16) | v13>>16
+               v8 += v13
+               v7 ^= v8
+               v7 = v7<<(64-63) | v7>>63
+               v3 += m[15]
+               v3 += v4
+               v14 ^= v3
+               v14 = v14<<(64-16) | v14>>16
+               v9 += v14
+               v4 ^= v9
+               v4 = v4<<(64-63) | v4>>63
+               v1 += m[11]
+               v1 += v6
+               v12 ^= v1
+               v12 = v12<<(64-16) | v12>>16
+               v11 += v12
+               v6 ^= v11
+               v6 = v6<<(64-63) | v6>>63
+               v0 += m[9]
+               v0 += v5
+               v15 ^= v0
+               v15 = v15<<(64-16) | v15>>16
+               v10 += v15
+               v5 ^= v10
+               v5 = v5<<(64-63) | v5>>63
+
+               // Round 12.
+               v0 += m[14]
+               v0 += v4
+               v12 ^= v0
+               v12 = v12<<(64-32) | v12>>32
+               v8 += v12
+               v4 ^= v8
+               v4 = v4<<(64-24) | v4>>24
+               v1 += m[4]
+               v1 += v5
+               v13 ^= v1
+               v13 = v13<<(64-32) | v13>>32
+               v9 += v13
+               v5 ^= v9
+               v5 = v5<<(64-24) | v5>>24
+               v2 += m[9]
+               v2 += v6
+               v14 ^= v2
+               v14 = v14<<(64-32) | v14>>32
+               v10 += v14
+               v6 ^= v10
+               v6 = v6<<(64-24) | v6>>24
+               v3 += m[13]
+               v3 += v7
+               v15 ^= v3
+               v15 = v15<<(64-32) | v15>>32
+               v11 += v15
+               v7 ^= v11
+               v7 = v7<<(64-24) | v7>>24
+               v2 += m[15]
+               v2 += v6
+               v14 ^= v2
+               v14 = v14<<(64-16) | v14>>16
+               v10 += v14
+               v6 ^= v10
+               v6 = v6<<(64-63) | v6>>63
+               v3 += m[6]
+               v3 += v7
+               v15 ^= v3
+               v15 = v15<<(64-16) | v15>>16
+               v11 += v15
+               v7 ^= v11
+               v7 = v7<<(64-63) | v7>>63
+               v1 += m[8]
+               v1 += v5
+               v13 ^= v1
+               v13 = v13<<(64-16) | v13>>16
+               v9 += v13
+               v5 ^= v9
+               v5 = v5<<(64-63) | v5>>63
+               v0 += m[10]
+               v0 += v4
+               v12 ^= v0
+               v12 = v12<<(64-16) | v12>>16
+               v8 += v12
+               v4 ^= v8
+               v4 = v4<<(64-63) | v4>>63
+               v0 += m[1]
+               v0 += v5
+               v15 ^= v0
+               v15 = v15<<(64-32) | v15>>32
+               v10 += v15
+               v5 ^= v10
+               v5 = v5<<(64-24) | v5>>24
+               v1 += m[0]
+               v1 += v6
+               v12 ^= v1
+               v12 = v12<<(64-32) | v12>>32
+               v11 += v12
+               v6 ^= v11
+               v6 = v6<<(64-24) | v6>>24
+               v2 += m[11]
+               v2 += v7
+               v13 ^= v2
+               v13 = v13<<(64-32) | v13>>32
+               v8 += v13
+               v7 ^= v8
+               v7 = v7<<(64-24) | v7>>24
+               v3 += m[5]
+               v3 += v4
+               v14 ^= v3
+               v14 = v14<<(64-32) | v14>>32
+               v9 += v14
+               v4 ^= v9
+               v4 = v4<<(64-24) | v4>>24
+               v2 += m[7]
+               v2 += v7
+               v13 ^= v2
+               v13 = v13<<(64-16) | v13>>16
+               v8 += v13
+               v7 ^= v8
+               v7 = v7<<(64-63) | v7>>63
+               v3 += m[3]
+               v3 += v4
+               v14 ^= v3
+               v14 = v14<<(64-16) | v14>>16
+               v9 += v14
+               v4 ^= v9
+               v4 = v4<<(64-63) | v4>>63
+               v1 += m[2]
+               v1 += v6
+               v12 ^= v1
+               v12 = v12<<(64-16) | v12>>16
+               v11 += v12
+               v6 ^= v11
+               v6 = v6<<(64-63) | v6>>63
+               v0 += m[12]
+               v0 += v5
+               v15 ^= v0
+               v15 = v15<<(64-16) | v15>>16
+               v10 += v15
+               v5 ^= v10
+               v5 = v5<<(64-63) | v5>>63
+
+               h0 ^= v0 ^ v8
+               h1 ^= v1 ^ v9
+               h2 ^= v2 ^ v10
+               h3 ^= v3 ^ v11
+               h4 ^= v4 ^ v12
+               h5 ^= v5 ^ v13
+               h6 ^= v6 ^ v14
+               h7 ^= v7 ^ v15
+
+               p = p[BlockSize:]
+       }
+       d.h[0], d.h[1], d.h[2], d.h[3], d.h[4], d.h[5], d.h[6], d.h[7] = h0, h1, h2, h3, h4, h5, h6, h7
+}

diff --git a/vendor/github.com/minio/blake2b-simd/compress_noasm.go b/vendor/github.com/minio/blake2b-simd/compress_noasm.go
new file mode 100644 (file)
index 0000000..d3c6758
--- /dev/null
+++ b/vendor/github.com/minio/blake2b-simd/compress_noasm.go
@@ -0,0 +1,23 @@
+//+build !amd64 noasm appengine
+
+/*
+ * Minio Cloud Storage, (C) 2016 Minio, Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package blake2b
+
+func compress(d *digest, p []uint8) {
+       compressGeneric(d, p)
+}

diff --git a/vendor/github.com/minio/blake2b-simd/cpuid.go b/vendor/github.com/minio/blake2b-simd/cpuid.go
new file mode 100644 (file)
index 0000000..a9f9550
--- /dev/null
+++ b/vendor/github.com/minio/blake2b-simd/cpuid.go
@@ -0,0 +1,60 @@
+// +build 386,!gccgo amd64,!gccgo
+
+// Copyright 2016 Frank Wessels <fwessels@xs4all.nl>
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+
+package blake2b
+
+func cpuid(op uint32) (eax, ebx, ecx, edx uint32)
+func cpuidex(op, op2 uint32) (eax, ebx, ecx, edx uint32)
+func xgetbv(index uint32) (eax, edx uint32)
+
+// True when SIMD instructions are available.
+var avx2 = haveAVX2()
+var avx = haveAVX()
+var ssse3 = haveSSSE3()
+
+// haveAVX returns true when there is AVX support
+func haveAVX() bool {
+       _, _, c, _ := cpuid(1)
+
+       // Check XGETBV, OXSAVE and AVX bits
+       if c&(1<<26) != 0 && c&(1<<27) != 0 && c&(1<<28) != 0 {
+               // Check for OS support
+               eax, _ := xgetbv(0)
+               return (eax & 0x6) == 0x6
+       }
+       return false
+}
+
+// haveAVX2 returns true when there is AVX2 support
+func haveAVX2() bool {
+       mfi, _, _, _ := cpuid(0)
+
+       // Check AVX2, AVX2 requires OS support, but BMI1/2 don't.
+       if mfi >= 7 && haveAVX() {
+               _, ebx, _, _ := cpuidex(7, 0)
+               return (ebx & 0x00000020) != 0
+       }
+       return false
+}
+
+// haveSSSE3 returns true when there is SSSE3 support
+func haveSSSE3() bool {
+
+       _, _, c, _ := cpuid(1)
+
+       return (c & 0x00000200) != 0
+}

diff --git a/vendor/github.com/minio/blake2b-simd/cpuid_386.s b/vendor/github.com/minio/blake2b-simd/cpuid_386.s
new file mode 100644 (file)
index 0000000..fa38814
--- /dev/null
+++ b/vendor/github.com/minio/blake2b-simd/cpuid_386.s
@@ -0,0 +1,33 @@
+// Copyright (c) 2015 Klaus Post, released under MIT License. See LICENSE file.
+
+// +build 386,!gccgo
+
+// func cpuid(op uint32) (eax, ebx, ecx, edx uint32)
+TEXT ·cpuid(SB), 7, $0
+        XORL CX, CX
+        MOVL op+0(FP), AX
+        CPUID
+        MOVL AX, eax+4(FP)
+        MOVL BX, ebx+8(FP)
+        MOVL CX, ecx+12(FP)
+        MOVL DX, edx+16(FP)
+        RET
+
+// func cpuidex(op, op2 uint32) (eax, ebx, ecx, edx uint32)
+TEXT ·cpuidex(SB), 7, $0
+        MOVL op+0(FP), AX
+        MOVL op2+4(FP), CX
+        CPUID
+        MOVL AX, eax+8(FP)
+        MOVL BX, ebx+12(FP)
+        MOVL CX, ecx+16(FP)
+        MOVL DX, edx+20(FP)
+        RET
+
+// func xgetbv(index uint32) (eax, edx uint32)
+TEXT ·xgetbv(SB), 7, $0
+        MOVL index+0(FP), CX
+        BYTE $0x0f; BYTE $0x01; BYTE $0xd0 // XGETBV
+        MOVL AX, eax+4(FP)
+        MOVL DX, edx+8(FP)
+        RET

diff --git a/vendor/github.com/minio/blake2b-simd/cpuid_amd64.s b/vendor/github.com/minio/blake2b-simd/cpuid_amd64.s
new file mode 100644 (file)
index 0000000..fb45a65
--- /dev/null
+++ b/vendor/github.com/minio/blake2b-simd/cpuid_amd64.s
@@ -0,0 +1,34 @@
+// Copyright (c) 2015 Klaus Post, released under MIT License. See LICENSE file.
+
+// +build amd64,!gccgo
+
+// func cpuid(op uint32) (eax, ebx, ecx, edx uint32)
+TEXT ·cpuid(SB), 7, $0
+        XORQ CX, CX
+        MOVL op+0(FP), AX
+        CPUID
+        MOVL AX, eax+8(FP)
+        MOVL BX, ebx+12(FP)
+        MOVL CX, ecx+16(FP)
+        MOVL DX, edx+20(FP)
+        RET
+
+
+// func cpuidex(op, op2 uint32) (eax, ebx, ecx, edx uint32)
+TEXT ·cpuidex(SB), 7, $0
+        MOVL op+0(FP), AX
+        MOVL op2+4(FP), CX
+        CPUID
+        MOVL AX, eax+8(FP)
+        MOVL BX, ebx+12(FP)
+        MOVL CX, ecx+16(FP)
+        MOVL DX, edx+20(FP)
+        RET
+
+// func xgetbv(index uint32) (eax, edx uint32)
+TEXT ·xgetbv(SB), 7, $0
+        MOVL index+0(FP), CX
+        BYTE $0x0f; BYTE $0x01; BYTE $0xd0 // XGETBV
+        MOVL AX, eax+8(FP)
+        MOVL DX, edx+12(FP)
+        RET

diff --git a/vendor/github.com/minio/sha256-simd/.gitignore b/vendor/github.com/minio/sha256-simd/.gitignore
new file mode 100644 (file)
index 0000000..c56069f
--- /dev/null
+++ b/vendor/github.com/minio/sha256-simd/.gitignore
@@ -0,0 +1 @@
+*.test
\ No newline at end of file

diff --git a/vendor/github.com/minio/sha256-simd/.travis.yml b/vendor/github.com/minio/sha256-simd/.travis.yml
new file mode 100644 (file)
index 0000000..744e64c
--- /dev/null
+++ b/vendor/github.com/minio/sha256-simd/.travis.yml
@@ -0,0 +1,24 @@
+sudo: required
+dist: trusty
+language: go
+
+os:
+- linux
+
+go:
+- tip
+- 1.11.x
+
+env:
+- ARCH=x86_64
+- ARCH=i686
+
+matrix:
+  fast_finish: true
+  allow_failures:
+  - go: tip
+
+script:
+- diff -au <(gofmt -d .) <(printf "")
+- go test -race -v ./...
+- go tool vet -asmdecl .

diff --git a/vendor/github.com/minio/sha256-simd/LICENSE b/vendor/github.com/minio/sha256-simd/LICENSE
new file mode 100644 (file)
index 0000000..d645695
--- /dev/null
+++ b/vendor/github.com/minio/sha256-simd/LICENSE
@@ -0,0 +1,202 @@
+
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
+
+   APPENDIX: How to apply the Apache License to your work.
+
+      To apply the Apache License to your work, attach the following
+      boilerplate notice, with the fields enclosed by brackets "[]"
+      replaced with your own identifying information. (Don't include
+      the brackets!)  The text should be enclosed in the appropriate
+      comment syntax for the file format. We also recommend that a
+      file or class name and description of purpose be included on the
+      same "printed page" as the copyright notice for easier
+      identification within third-party archives.
+
+   Copyright [yyyy] [name of copyright owner]
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.

diff --git a/vendor/github.com/minio/sha256-simd/README.md b/vendor/github.com/minio/sha256-simd/README.md
new file mode 100644 (file)
index 0000000..5282d83
--- /dev/null
+++ b/vendor/github.com/minio/sha256-simd/README.md
@@ -0,0 +1,133 @@
+# sha256-simd
+
+Accelerate SHA256 computations in pure Go using AVX512, SHA Extensions and AVX2 for Intel and ARM64 for ARM. On AVX512 it provides an up to 8x improvement (over 3 GB/s per core) in comparison to AVX2. SHA Extensions give a performance boost of close to 4x over AVX2.
+
+## Introduction
+
+This package is designed as a replacement for `crypto/sha256`. For Intel CPUs it has two flavors for AVX512 and AVX2 (AVX/SSE are also supported). For ARM CPUs with the Cryptography Extensions, advantage is taken of the SHA2 instructions resulting in a massive performance improvement.
+
+This package uses Golang assembly. The AVX512 version is based on the Intel's "multi-buffer crypto library for IPSec" whereas the other Intel implementations are described in "Fast SHA-256 Implementations on Intel Architecture Processors" by J. Guilford et al.
+
+## New: Support for Intel SHA Extensions
+
+Support for the Intel SHA Extensions has been added by Kristofer Peterson (@svenski123), originally developed for spacemeshos [here](https://github.com/spacemeshos/POET/issues/23). On CPUs that support it (known thus far Intel Celeron J3455 and AMD Ryzen) it gives a significant boost in performance (with thanks to @AudriusButkevicius for reporting the results; full results [here](https://github.com/minio/sha256-simd/pull/37#issuecomment-451607827)).
+
+```
+$ benchcmp avx2.txt sha-ext.txt
+benchmark           AVX2 MB/s    SHA Ext MB/s  speedup
+BenchmarkHash5M     514.40       1975.17       3.84x
+```
+
+Thanks to Kristofer Peterson, we also added additional performance changes such as optimized padding, endian conversions which sped up all implementations i.e. Intel SHA alone while doubled performance for small sizes, the other changes increased everything roughly 50%.
+
+## Support for AVX512
+
+We have added support for AVX512 which results in an up to 8x performance improvement over AVX2 (3.0 GHz Xeon Platinum 8124M CPU):
+
+```
+$ benchcmp avx2.txt avx512.txt
+benchmark           AVX2 MB/s    AVX512 MB/s  speedup
+BenchmarkHash5M     448.62       3498.20      7.80x
+```
+
+The original code was developed by Intel as part of the [multi-buffer crypto library](https://github.com/intel/intel-ipsec-mb) for IPSec or more specifically this [AVX512](https://github.com/intel/intel-ipsec-mb/blob/master/avx512/sha256_x16_avx512.asm) implementation. The key idea behind it is to process a total of 16 checksums in parallel by “transposing” 16 (independent) messages of 64 bytes between a total of 16 ZMM registers (each 64 bytes wide).
+
+Transposing the input messages means that in order to take full advantage of the speedup you need to have a (server) workload where multiple threads are doing SHA256 calculations in parallel. Unfortunately for this algorithm it is not possible for two message blocks processed in parallel to be dependent on one another — because then the (interim) result of the first part of the message has to be an input into the processing of the second part of the message.
+
+Whereas the original Intel C implementation requires some sort of explicit scheduling of messages to be processed in parallel, for Golang it makes sense to take advantage of channels in order to group messages together and use channels as well for sending back the results (thereby effectively decoupling the calculations). We have implemented a fairly simple scheduling mechanism that seems to work well in practice.
+
+Due to this different way of scheduling, we decided to use an explicit method to instantiate the AVX512 version. Essentially one or more AVX512 processing servers ([`Avx512Server`](https://github.com/minio/sha256-simd/blob/master/sha256blockAvx512_amd64.go#L294)) have to be created whereby each server can hash over 3 GB/s on a single core. An `hash.Hash` object ([`Avx512Digest`](https://github.com/minio/sha256-simd/blob/master/sha256blockAvx512_amd64.go#L45)) is then instantiated using one of these servers and used in the regular fashion:
+
+```go
+import "github.com/minio/sha256-simd"
+
+func main() {
+       server := sha256.NewAvx512Server()
+       h512 := sha256.NewAvx512(server)
+       h512.Write(fileBlock)
+       digest := h512.Sum([]byte{})
+}
+```
+
+Note that, because of the scheduling overhead, for small messages (< 1 MB) you will be better off using the regular SHA256 hashing (but those are typically not performance critical anyway). Some other tips to get the best performance:
+* Have many go routines doing SHA256 calculations in parallel.
+* Try to Write() messages in multiples of 64 bytes.
+* Try to keep the overall length of messages to a roughly similar size ie. 5 MB (this way all 16 ‘lanes’ in the AVX512 computations are contributing as much as possible).
+
+More detailed information can be found in this [blog](https://blog.minio.io/accelerate-sha256-up-to-8x-over-3-gb-s-per-core-with-avx512-a0b1d64f78f) post including scaling across cores.
+
+## Drop-In Replacement
+
+The following code snippet shows how you can use `github.com/minio/sha256-simd`. This will automatically select the fastest method for the architecture on which it will be executed.
+
+```go
+import "github.com/minio/sha256-simd"
+
+func main() {
+        ...
+       shaWriter := sha256.New()
+       io.Copy(shaWriter, file)
+        ...
+}
+```
+
+## Performance
+
+Below is the speed in MB/s for a single core (ranked fast to slow) for blocks larger than 1 MB.
+
+| Processor                         | SIMD    | Speed (MB/s) |
+| --------------------------------- | ------- | ------------:|
+| 3.0 GHz Intel Xeon Platinum 8124M | AVX512  |         3498 |
+| 3.7 GHz AMD Ryzen 7 2700X         | SHA Ext |         1979 |
+| 1.2 GHz ARM Cortex-A53            | ARM64   |          638 |
+| 3.0 GHz Intel Xeon Platinum 8124M | AVX2    |          449 |
+| 3.1 GHz Intel Core i7             | AVX     |          362 |
+| 3.1 GHz Intel Core i7             | SSE     |          299 |
+
+## asm2plan9s
+
+In order to be able to work more easily with AVX512/AVX2 instructions, a separate tool was developed to convert SIMD instructions into the corresponding BYTE sequence as accepted by Go assembly. See [asm2plan9s](https://github.com/minio/asm2plan9s) for more information.
+
+## Why and benefits
+
+One of the most performance sensitive parts of the [Minio](https://github.com/minio/minio) object storage server is related to SHA256 hash sums calculations. For instance during multi part uploads each part that is uploaded needs to be verified for data integrity by the server.
+
+Other applications that can benefit from enhanced SHA256 performance are deduplication in storage systems, intrusion detection, version control systems, integrity checking, etc.
+
+## ARM SHA Extensions
+
+The 64-bit ARMv8 core has introduced new instructions for SHA1 and SHA2 acceleration as part of the [Cryptography Extensions](http://infocenter.arm.com/help/index.jsp?topic=/com.arm.doc.ddi0501f/CHDFJBCJ.html). Below you can see a small excerpt highlighting one of the rounds as is done for the SHA256 calculation process (for full code see [sha256block_arm64.s](https://github.com/minio/sha256-simd/blob/master/sha256block_arm64.s)).
+
+ ```
+ sha256h    q2, q3, v9.4s
+ sha256h2   q3, q4, v9.4s
+ sha256su0  v5.4s, v6.4s
+ rev32      v8.16b, v8.16b
+ add        v9.4s, v7.4s, v18.4s
+ mov        v4.16b, v2.16b
+ sha256h    q2, q3, v10.4s
+ sha256h2   q3, q4, v10.4s
+ sha256su0  v6.4s, v7.4s
+ sha256su1  v5.4s, v7.4s, v8.4s
+ ```
+
+### Detailed benchmarks
+
+Benchmarks generated on a 1.2 Ghz Quad-Core ARM Cortex A53 equipped [Pine64](https://www.pine64.com/).
+
+```
+minio@minio-arm:$ benchcmp golang.txt arm64.txt
+benchmark                 golang         arm64        speedup
+BenchmarkHash8Bytes-4     0.68 MB/s      5.70 MB/s      8.38x
+BenchmarkHash1K-4         5.65 MB/s    326.30 MB/s     57.75x
+BenchmarkHash8K-4         6.00 MB/s    570.63 MB/s     95.11x
+BenchmarkHash1M-4         6.05 MB/s    638.23 MB/s    105.49x
+```
+
+## License
+
+Released under the Apache License v2.0. You can find the complete text in the file LICENSE.
+
+## Contributing
+
+Contributions are welcome, please send PRs for any enhancements.

diff --git a/vendor/github.com/minio/sha256-simd/appveyor.yml b/vendor/github.com/minio/sha256-simd/appveyor.yml
new file mode 100644 (file)
index 0000000..a66bfa9
--- /dev/null
+++ b/vendor/github.com/minio/sha256-simd/appveyor.yml
@@ -0,0 +1,32 @@
+# version format
+version: "{build}"
+
+# Operating system (build VM template)
+os: Windows Server 2012 R2
+
+# Platform.
+platform: x64
+
+clone_folder: c:\gopath\src\github.com\minio\sha256-simd
+
+# environment variables
+environment:
+  GOPATH: c:\gopath
+  GO15VENDOREXPERIMENT: 1
+
+# scripts that run after cloning repository
+install:
+  - set PATH=%GOPATH%\bin;c:\go\bin;%PATH%
+  - go version
+  - go env
+
+# to run your custom scripts instead of automatic MSBuild
+build_script:
+  - go test .
+  - go test -race .
+
+# to disable automatic tests
+test: off
+
+# to disable deployment
+deploy: off

diff --git a/vendor/github.com/minio/sha256-simd/cpuid.go b/vendor/github.com/minio/sha256-simd/cpuid.go
new file mode 100644 (file)
index 0000000..878ad46
--- /dev/null
+++ b/vendor/github.com/minio/sha256-simd/cpuid.go
@@ -0,0 +1,119 @@
+// Minio Cloud Storage, (C) 2016 Minio, Inc.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+
+package sha256
+
+// True when SIMD instructions are available.
+var avx512 bool
+var avx2 bool
+var avx bool
+var sse bool
+var sse2 bool
+var sse3 bool
+var ssse3 bool
+var sse41 bool
+var sse42 bool
+var popcnt bool
+var sha bool
+var armSha = haveArmSha()
+
+func init() {
+       var _xsave bool
+       var _osxsave bool
+       var _avx bool
+       var _avx2 bool
+       var _avx512f bool
+       var _avx512dq bool
+       //      var _avx512pf        bool
+       //      var _avx512er        bool
+       //      var _avx512cd        bool
+       var _avx512bw bool
+       var _avx512vl bool
+       var _sseState bool
+       var _avxState bool
+       var _opmaskState bool
+       var _zmmHI256State bool
+       var _hi16ZmmState bool
+
+       mfi, _, _, _ := cpuid(0)
+
+       if mfi >= 1 {
+               _, _, c, d := cpuid(1)
+
+               sse = (d & (1 << 25)) != 0
+               sse2 = (d & (1 << 26)) != 0
+               sse3 = (c & (1 << 0)) != 0
+               ssse3 = (c & (1 << 9)) != 0
+               sse41 = (c & (1 << 19)) != 0
+               sse42 = (c & (1 << 20)) != 0
+               popcnt = (c & (1 << 23)) != 0
+               _xsave = (c & (1 << 26)) != 0
+               _osxsave = (c & (1 << 27)) != 0
+               _avx = (c & (1 << 28)) != 0
+       }
+
+       if mfi >= 7 {
+               _, b, _, _ := cpuid(7)
+
+               _avx2 = (b & (1 << 5)) != 0
+               _avx512f = (b & (1 << 16)) != 0
+               _avx512dq = (b & (1 << 17)) != 0
+               //              _avx512pf = (b & (1 << 26)) != 0
+               //              _avx512er = (b & (1 << 27)) != 0
+               //              _avx512cd = (b & (1 << 28)) != 0
+               _avx512bw = (b & (1 << 30)) != 0
+               _avx512vl = (b & (1 << 31)) != 0
+               sha = (b & (1 << 29)) != 0
+       }
+
+       // Stop here if XSAVE unsupported or not enabled
+       if !_xsave || !_osxsave {
+               return
+       }
+
+       if _xsave && _osxsave {
+               a, _ := xgetbv(0)
+
+               _sseState = (a & (1 << 1)) != 0
+               _avxState = (a & (1 << 2)) != 0
+               _opmaskState = (a & (1 << 5)) != 0
+               _zmmHI256State = (a & (1 << 6)) != 0
+               _hi16ZmmState = (a & (1 << 7)) != 0
+       } else {
+               _sseState = true
+       }
+
+       // Very unlikely that OS would enable XSAVE and then disable SSE
+       if !_sseState {
+               sse = false
+               sse2 = false
+               sse3 = false
+               ssse3 = false
+               sse41 = false
+               sse42 = false
+       }
+
+       if _avxState {
+               avx = _avx
+               avx2 = _avx2
+       }
+
+       if _opmaskState && _zmmHI256State && _hi16ZmmState {
+               avx512 = (_avx512f &&
+                       _avx512dq &&
+                       _avx512bw &&
+                       _avx512vl)
+       }
+}

diff --git a/vendor/github.com/minio/sha256-simd/cpuid_386.go b/vendor/github.com/minio/sha256-simd/cpuid_386.go
new file mode 100644 (file)
index 0000000..c9890be
--- /dev/null
+++ b/vendor/github.com/minio/sha256-simd/cpuid_386.go
@@ -0,0 +1,24 @@
+// Minio Cloud Storage, (C) 2016 Minio, Inc.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+
+package sha256
+
+func cpuid(op uint32) (eax, ebx, ecx, edx uint32)
+func cpuidex(op, op2 uint32) (eax, ebx, ecx, edx uint32)
+func xgetbv(index uint32) (eax, edx uint32)
+
+func haveArmSha() bool {
+       return false
+}

diff --git a/vendor/github.com/minio/sha256-simd/cpuid_386.s b/vendor/github.com/minio/sha256-simd/cpuid_386.s
new file mode 100644 (file)
index 0000000..1511cd6
--- /dev/null
+++ b/vendor/github.com/minio/sha256-simd/cpuid_386.s
@@ -0,0 +1,53 @@
+// The MIT License (MIT)
+//
+// Copyright (c) 2015 Klaus Post
+//
+// Permission is hereby granted, free of charge, to any person obtaining a copy
+// of this software and associated documentation files (the "Software"), to deal
+// in the Software without restriction, including without limitation the rights
+// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+// copies of the Software, and to permit persons to whom the Software is
+// furnished to do so, subject to the following conditions:
+//
+// The above copyright notice and this permission notice shall be included in all
+// copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+// SOFTWARE.
+
+// +build 386,!gccgo
+
+// func cpuid(op uint32) (eax, ebx, ecx, edx uint32)
+TEXT ·cpuid(SB), 7, $0
+       XORL CX, CX
+       MOVL op+0(FP), AX
+       CPUID
+       MOVL AX, eax+4(FP)
+       MOVL BX, ebx+8(FP)
+       MOVL CX, ecx+12(FP)
+       MOVL DX, edx+16(FP)
+       RET
+
+// func cpuidex(op, op2 uint32) (eax, ebx, ecx, edx uint32)
+TEXT ·cpuidex(SB), 7, $0
+       MOVL op+0(FP), AX
+       MOVL op2+4(FP), CX
+       CPUID
+       MOVL AX, eax+8(FP)
+       MOVL BX, ebx+12(FP)
+       MOVL CX, ecx+16(FP)
+       MOVL DX, edx+20(FP)
+       RET
+
+// func xgetbv(index uint32) (eax, edx uint32)
+TEXT ·xgetbv(SB), 7, $0
+       MOVL index+0(FP), CX
+       BYTE $0x0f; BYTE $0x01; BYTE $0xd0 // XGETBV
+       MOVL AX, eax+4(FP)
+       MOVL DX, edx+8(FP)
+       RET

diff --git a/vendor/github.com/minio/sha256-simd/cpuid_amd64.go b/vendor/github.com/minio/sha256-simd/cpuid_amd64.go
new file mode 100644 (file)
index 0000000..c9890be
--- /dev/null
+++ b/vendor/github.com/minio/sha256-simd/cpuid_amd64.go
@@ -0,0 +1,24 @@
+// Minio Cloud Storage, (C) 2016 Minio, Inc.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+
+package sha256
+
+func cpuid(op uint32) (eax, ebx, ecx, edx uint32)
+func cpuidex(op, op2 uint32) (eax, ebx, ecx, edx uint32)
+func xgetbv(index uint32) (eax, edx uint32)
+
+func haveArmSha() bool {
+       return false
+}

diff --git a/vendor/github.com/minio/sha256-simd/cpuid_amd64.s b/vendor/github.com/minio/sha256-simd/cpuid_amd64.s
new file mode 100644 (file)
index 0000000..b0f4147
--- /dev/null
+++ b/vendor/github.com/minio/sha256-simd/cpuid_amd64.s
@@ -0,0 +1,53 @@
+// The MIT License (MIT)
+//
+// Copyright (c) 2015 Klaus Post
+//
+// Permission is hereby granted, free of charge, to any person obtaining a copy
+// of this software and associated documentation files (the "Software"), to deal
+// in the Software without restriction, including without limitation the rights
+// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+// copies of the Software, and to permit persons to whom the Software is
+// furnished to do so, subject to the following conditions:
+//
+// The above copyright notice and this permission notice shall be included in all
+// copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+// SOFTWARE.
+
+// +build amd64,!gccgo
+
+// func cpuid(op uint32) (eax, ebx, ecx, edx uint32)
+TEXT ·cpuid(SB), 7, $0
+       XORQ CX, CX
+       MOVL op+0(FP), AX
+       CPUID
+       MOVL AX, eax+8(FP)
+       MOVL BX, ebx+12(FP)
+       MOVL CX, ecx+16(FP)
+       MOVL DX, edx+20(FP)
+       RET
+
+// func cpuidex(op, op2 uint32) (eax, ebx, ecx, edx uint32)
+TEXT ·cpuidex(SB), 7, $0
+       MOVL op+0(FP), AX
+       MOVL op2+4(FP), CX
+       CPUID
+       MOVL AX, eax+8(FP)
+       MOVL BX, ebx+12(FP)
+       MOVL CX, ecx+16(FP)
+       MOVL DX, edx+20(FP)
+       RET
+
+// func xgetbv(index uint32) (eax, edx uint32)
+TEXT ·xgetbv(SB), 7, $0
+       MOVL index+0(FP), CX
+       BYTE $0x0f; BYTE $0x01; BYTE $0xd0 // XGETBV
+       MOVL AX, eax+8(FP)
+       MOVL DX, edx+12(FP)
+       RET

diff --git a/vendor/github.com/minio/sha256-simd/cpuid_arm.go b/vendor/github.com/minio/sha256-simd/cpuid_arm.go
new file mode 100644 (file)
index 0000000..351dff4
--- /dev/null
+++ b/vendor/github.com/minio/sha256-simd/cpuid_arm.go
@@ -0,0 +1,32 @@
+// Minio Cloud Storage, (C) 2016 Minio, Inc.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+
+package sha256
+
+func cpuid(op uint32) (eax, ebx, ecx, edx uint32) {
+       return 0, 0, 0, 0
+}
+
+func cpuidex(op, op2 uint32) (eax, ebx, ecx, edx uint32) {
+       return 0, 0, 0, 0
+}
+
+func xgetbv(index uint32) (eax, edx uint32) {
+       return 0, 0
+}
+
+func haveArmSha() bool {
+       return false
+}

diff --git a/vendor/github.com/minio/sha256-simd/cpuid_linux_arm64.go b/vendor/github.com/minio/sha256-simd/cpuid_linux_arm64.go
new file mode 100644 (file)
index 0000000..e739996
--- /dev/null
+++ b/vendor/github.com/minio/sha256-simd/cpuid_linux_arm64.go
@@ -0,0 +1,49 @@
+// +build arm64,linux
+
+// Minio Cloud Storage, (C) 2016 Minio, Inc.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+
+package sha256
+
+import (
+       "bytes"
+       "io/ioutil"
+)
+
+func cpuid(op uint32) (eax, ebx, ecx, edx uint32) {
+       return 0, 0, 0, 0
+}
+
+func cpuidex(op, op2 uint32) (eax, ebx, ecx, edx uint32) {
+       return 0, 0, 0, 0
+}
+
+func xgetbv(index uint32) (eax, edx uint32) {
+       return 0, 0
+}
+
+// File to check for cpu capabilities.
+const procCPUInfo = "/proc/cpuinfo"
+
+// Feature to check for.
+const sha256Feature = "sha2"
+
+func haveArmSha() bool {
+       cpuInfo, err := ioutil.ReadFile(procCPUInfo)
+       if err != nil {
+               return false
+       }
+       return bytes.Contains(cpuInfo, []byte(sha256Feature))
+}

diff --git a/vendor/github.com/minio/sha256-simd/cpuid_other.go b/vendor/github.com/minio/sha256-simd/cpuid_other.go
new file mode 100644 (file)
index 0000000..04f26ce
--- /dev/null
+++ b/vendor/github.com/minio/sha256-simd/cpuid_other.go
@@ -0,0 +1,34 @@
+// Minio Cloud Storage, (C) 2016 Minio, Inc.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+
+// +build ppc64 ppc64le mips mipsle mips64 mips64le s390x wasm
+
+package sha256
+
+func cpuid(op uint32) (eax, ebx, ecx, edx uint32) {
+       return 0, 0, 0, 0
+}
+
+func cpuidex(op, op2 uint32) (eax, ebx, ecx, edx uint32) {
+       return 0, 0, 0, 0
+}
+
+func xgetbv(index uint32) (eax, edx uint32) {
+       return 0, 0
+}
+
+func haveArmSha() bool {
+       return false
+}

diff --git a/vendor/github.com/minio/sha256-simd/cpuid_others_arm64.go b/vendor/github.com/minio/sha256-simd/cpuid_others_arm64.go
new file mode 100644 (file)
index 0000000..0fb4022
--- /dev/null
+++ b/vendor/github.com/minio/sha256-simd/cpuid_others_arm64.go
@@ -0,0 +1,35 @@
+// +build arm64,!linux
+
+// Minio Cloud Storage, (C) 2016 Minio, Inc.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+
+package sha256
+
+func cpuid(op uint32) (eax, ebx, ecx, edx uint32) {
+       return 0, 0, 0, 0
+}
+
+func cpuidex(op, op2 uint32) (eax, ebx, ecx, edx uint32) {
+       return 0, 0, 0, 0
+}
+
+func xgetbv(index uint32) (eax, edx uint32) {
+       return 0, 0
+}
+
+// Check for sha2 instruction flag.
+func haveArmSha() bool {
+       return false
+}

diff --git a/vendor/github.com/minio/sha256-simd/go.mod b/vendor/github.com/minio/sha256-simd/go.mod
new file mode 100644 (file)
index 0000000..b68fb0a
--- /dev/null
+++ b/vendor/github.com/minio/sha256-simd/go.mod
@@ -0,0 +1 @@
+module github.com/minio/sha256-simd

diff --git a/vendor/github.com/minio/sha256-simd/sha256.go b/vendor/github.com/minio/sha256-simd/sha256.go
new file mode 100644 (file)
index 0000000..71b65d2
--- /dev/null
+++ b/vendor/github.com/minio/sha256-simd/sha256.go
@@ -0,0 +1,292 @@
+/*
+ * Minio Cloud Storage, (C) 2016 Minio, Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package sha256
+
+import (
+       "crypto/sha256"
+       "encoding/binary"
+       "hash"
+       "runtime"
+)
+
+// Size - The size of a SHA256 checksum in bytes.
+const Size = 32
+
+// BlockSize - The blocksize of SHA256 in bytes.
+const BlockSize = 64
+
+const (
+       chunk = BlockSize
+       init0 = 0x6A09E667
+       init1 = 0xBB67AE85
+       init2 = 0x3C6EF372
+       init3 = 0xA54FF53A
+       init4 = 0x510E527F
+       init5 = 0x9B05688C
+       init6 = 0x1F83D9AB
+       init7 = 0x5BE0CD19
+)
+
+// digest represents the partial evaluation of a checksum.
+type digest struct {
+       h   [8]uint32
+       x   [chunk]byte
+       nx  int
+       len uint64
+}
+
+// Reset digest back to default
+func (d *digest) Reset() {
+       d.h[0] = init0
+       d.h[1] = init1
+       d.h[2] = init2
+       d.h[3] = init3
+       d.h[4] = init4
+       d.h[5] = init5
+       d.h[6] = init6
+       d.h[7] = init7
+       d.nx = 0
+       d.len = 0
+}
+
+type blockfuncType int
+
+const (
+       blockfuncGeneric blockfuncType = iota
+       blockfuncAvx512  blockfuncType = iota
+       blockfuncAvx2    blockfuncType = iota
+       blockfuncAvx     blockfuncType = iota
+       blockfuncSsse    blockfuncType = iota
+       blockfuncSha     blockfuncType = iota
+       blockfuncArm     blockfuncType = iota
+)
+
+var blockfunc blockfuncType
+
+func block(dig *digest, p []byte) {
+       if blockfunc == blockfuncSha {
+               blockShaGo(dig, p)
+       } else if blockfunc == blockfuncAvx2 {
+               blockAvx2Go(dig, p)
+       } else if blockfunc == blockfuncAvx {
+               blockAvxGo(dig, p)
+       } else if blockfunc == blockfuncSsse {
+               blockSsseGo(dig, p)
+       } else if blockfunc == blockfuncArm {
+               blockArmGo(dig, p)
+       } else if blockfunc == blockfuncGeneric {
+               blockGeneric(dig, p)
+       }
+}
+
+func init() {
+       is386bit := runtime.GOARCH == "386"
+       isARM := runtime.GOARCH == "arm"
+       switch {
+       case is386bit || isARM:
+               blockfunc = blockfuncGeneric
+       case sha && ssse3 && sse41:
+               blockfunc = blockfuncSha
+       case avx2:
+               blockfunc = blockfuncAvx2
+       case avx:
+               blockfunc = blockfuncAvx
+       case ssse3:
+               blockfunc = blockfuncSsse
+       case armSha:
+               blockfunc = blockfuncArm
+       default:
+               blockfunc = blockfuncGeneric
+       }
+}
+
+// New returns a new hash.Hash computing the SHA256 checksum.
+func New() hash.Hash {
+       if blockfunc != blockfuncGeneric {
+               d := new(digest)
+               d.Reset()
+               return d
+       }
+       // Fallback to the standard golang implementation
+       // if no features were found.
+       return sha256.New()
+}
+
+// Sum256 - single caller sha256 helper
+func Sum256(data []byte) (result [Size]byte) {
+       var d digest
+       d.Reset()
+       d.Write(data)
+       result = d.checkSum()
+       return
+}
+
+// Return size of checksum
+func (d *digest) Size() int { return Size }
+
+// Return blocksize of checksum
+func (d *digest) BlockSize() int { return BlockSize }
+
+// Write to digest
+func (d *digest) Write(p []byte) (nn int, err error) {
+       nn = len(p)
+       d.len += uint64(nn)
+       if d.nx > 0 {
+               n := copy(d.x[d.nx:], p)
+               d.nx += n
+               if d.nx == chunk {
+                       block(d, d.x[:])
+                       d.nx = 0
+               }
+               p = p[n:]
+       }
+       if len(p) >= chunk {
+               n := len(p) &^ (chunk - 1)
+               block(d, p[:n])
+               p = p[n:]
+       }
+       if len(p) > 0 {
+               d.nx = copy(d.x[:], p)
+       }
+       return
+}
+
+// Return sha256 sum in bytes
+func (d *digest) Sum(in []byte) []byte {
+       // Make a copy of d0 so that caller can keep writing and summing.
+       d0 := *d
+       hash := d0.checkSum()
+       return append(in, hash[:]...)
+}
+
+// Intermediate checksum function
+func (d *digest) checkSum() (digest [Size]byte) {
+       n := d.nx
+
+       var k [64]byte
+       copy(k[:], d.x[:n])
+
+       k[n] = 0x80
+
+       if n >= 56 {
+               block(d, k[:])
+
+               // clear block buffer - go compiles this to optimal 1x xorps + 4x movups
+               // unfortunately expressing this more succinctly results in much worse code
+               k[0] = 0
+               k[1] = 0
+               k[2] = 0
+               k[3] = 0
+               k[4] = 0
+               k[5] = 0
+               k[6] = 0
+               k[7] = 0
+               k[8] = 0
+               k[9] = 0
+               k[10] = 0
+               k[11] = 0
+               k[12] = 0
+               k[13] = 0
+               k[14] = 0
+               k[15] = 0
+               k[16] = 0
+               k[17] = 0
+               k[18] = 0
+               k[19] = 0
+               k[20] = 0
+               k[21] = 0
+               k[22] = 0
+               k[23] = 0
+               k[24] = 0
+               k[25] = 0
+               k[26] = 0
+               k[27] = 0
+               k[28] = 0
+               k[29] = 0
+               k[30] = 0
+               k[31] = 0
+               k[32] = 0
+               k[33] = 0
+               k[34] = 0
+               k[35] = 0
+               k[36] = 0
+               k[37] = 0
+               k[38] = 0
+               k[39] = 0
+               k[40] = 0
+               k[41] = 0
+               k[42] = 0
+               k[43] = 0
+               k[44] = 0
+               k[45] = 0
+               k[46] = 0
+               k[47] = 0
+               k[48] = 0
+               k[49] = 0
+               k[50] = 0
+               k[51] = 0
+               k[52] = 0
+               k[53] = 0
+               k[54] = 0
+               k[55] = 0
+               k[56] = 0
+               k[57] = 0
+               k[58] = 0
+               k[59] = 0
+               k[60] = 0
+               k[61] = 0
+               k[62] = 0
+               k[63] = 0
+       }
+       binary.BigEndian.PutUint64(k[56:64], uint64(d.len)<<3)
+       block(d, k[:])
+
+       {
+               const i = 0
+               binary.BigEndian.PutUint32(digest[i*4:i*4+4], d.h[i])
+       }
+       {
+               const i = 1
+               binary.BigEndian.PutUint32(digest[i*4:i*4+4], d.h[i])
+       }
+       {
+               const i = 2
+               binary.BigEndian.PutUint32(digest[i*4:i*4+4], d.h[i])
+       }
+       {
+               const i = 3
+               binary.BigEndian.PutUint32(digest[i*4:i*4+4], d.h[i])
+       }
+       {
+               const i = 4
+               binary.BigEndian.PutUint32(digest[i*4:i*4+4], d.h[i])
+       }
+       {
+               const i = 5
+               binary.BigEndian.PutUint32(digest[i*4:i*4+4], d.h[i])
+       }
+       {
+               const i = 6
+               binary.BigEndian.PutUint32(digest[i*4:i*4+4], d.h[i])
+       }
+       {
+               const i = 7
+               binary.BigEndian.PutUint32(digest[i*4:i*4+4], d.h[i])
+       }
+
+       return
+}

diff --git a/vendor/github.com/minio/sha256-simd/sha256_test.go b/vendor/github.com/minio/sha256-simd/sha256_test.go
new file mode 100644 (file)
index 0000000..9433b37
--- /dev/null
+++ b/vendor/github.com/minio/sha256-simd/sha256_test.go
@@ -0,0 +1,2326 @@
+/*
+ * Minio Cloud Storage, (C) 2016 Minio, Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+// Copyright (c) 2009 The Go Authors. All rights reserved.
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//    * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//    * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//    * Neither the name of Google Inc. nor the names of its
+// contributors may be used to endorse or promote products derived from
+// this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+// Using this part of Minio codebase under the license
+// Apache License Version 2.0 with modifications
+
+// SHA256 hash algorithm.  See FIPS 180-2.
+
+package sha256
+
+import (
+       "encoding/hex"
+       "fmt"
+       "strings"
+       "testing"
+)
+
+type sha256Test struct {
+       out [32]byte
+       in  string
+}
+
+var golden = []sha256Test{
+       {[32]byte{(1 * 1) + (1 * 2) + (0 * 4) + (0 * 8) + (0 * 16) + (1 * 32) + (1 * 64) + (1 * 128),
+               (0 * 1) + (0 * 2) + (0 * 4) + (0 * 8) + (1 * 16) + (1 * 32) + (0 * 64) + (1 * 128),
+               (0 * 1) + (0 * 2) + (1 * 4) + (0 * 8) + (0 * 16) + (0 * 32) + (1 * 64) + (1 * 128),
+               (0 * 1) + (1 * 2) + (0 * 4) + (0 * 8) + (0 * 16) + (0 * 32) + (1 * 64) + (0 * 128),
+               (0 * 1) + (0 * 2) + (0 * 4) + (1 * 8) + (1 * 16) + (0 * 32) + (0 * 64) + (1 * 128),
+               (0 * 1) + (0 * 2) + (1 * 4) + (1 * 8) + (1 * 16) + (1 * 32) + (1 * 64) + (1 * 128),
+               (0 * 1) + (0 * 2) + (1 * 4) + (1 * 8) + (1 * 16) + (0 * 32) + (0 * 64) + (0 * 128),
+               (0 * 1) + (0 * 2) + (1 * 4) + (0 * 8) + (1 * 16) + (0 * 32) + (0 * 64) + (0 * 128),
+               (0 * 1) + (1 * 2) + (0 * 4) + (1 * 8) + (1 * 16) + (0 * 32) + (0 * 64) + (1 * 128),
+               (1 * 1) + (1 * 2) + (0 * 4) + (1 * 8) + (1 * 16) + (1 * 32) + (1 * 64) + (1 * 128),
+               (0 * 1) + (0 * 2) + (1 * 4) + (0 * 8) + (1 * 16) + (1 * 32) + (1 * 64) + (1 * 128),
+               (0 * 1) + (0 * 2) + (0 * 4) + (1 * 8) + (0 * 16) + (0 * 32) + (1 * 64) + (1 * 128),
+               (1 * 1) + (0 * 2) + (0 * 4) + (1 * 8) + (1 * 16) + (0 * 32) + (0 * 64) + (1 * 128),
+               (1 * 1) + (1 * 2) + (1 * 4) + (1 * 8) + (0 * 16) + (1 * 32) + (1 * 64) + (0 * 128),
+               (1 * 1) + (0 * 2) + (0 * 4) + (1 * 8) + (1 * 16) + (1 * 32) + (0 * 64) + (1 * 128),
+               (0 * 1) + (0 * 2) + (1 * 4) + (0 * 8) + (0 * 16) + (1 * 32) + (0 * 64) + (0 * 128),
+               (1 * 1) + (1 * 2) + (1 * 4) + (0 * 8) + (0 * 16) + (1 * 32) + (0 * 64) + (0 * 128),
+               (0 * 1) + (1 * 2) + (1 * 4) + (1 * 8) + (0 * 16) + (1 * 32) + (0 * 64) + (1 * 128),
+               (1 * 1) + (0 * 2) + (0 * 4) + (0 * 8) + (0 * 16) + (0 * 32) + (1 * 64) + (0 * 128),
+               (0 * 1) + (0 * 2) + (1 * 4) + (0 * 8) + (0 * 16) + (1 * 32) + (1 * 64) + (1 * 128),
+               (0 * 1) + (0 * 2) + (1 * 4) + (0 * 8) + (0 * 16) + (1 * 32) + (1 * 64) + (0 * 128),
+               (1 * 1) + (1 * 2) + (0 * 4) + (1 * 8) + (1 * 16) + (0 * 32) + (0 * 64) + (1 * 128),
+               (1 * 1) + (1 * 2) + (0 * 4) + (0 * 8) + (1 * 16) + (0 * 32) + (0 * 64) + (1 * 128),
+               (0 * 1) + (0 * 2) + (1 * 4) + (1 * 8) + (0 * 16) + (0 * 32) + (1 * 64) + (0 * 128),
+               (0 * 1) + (0 * 2) + (1 * 4) + (0 * 8) + (0 * 16) + (1 * 32) + (0 * 64) + (1 * 128),
+               (1 * 1) + (0 * 2) + (1 * 4) + (0 * 8) + (1 * 16) + (0 * 32) + (0 * 64) + (1 * 128),
+               (1 * 1) + (0 * 2) + (0 * 4) + (1 * 8) + (1 * 16) + (0 * 32) + (0 * 64) + (1 * 128),
+               (1 * 1) + (1 * 2) + (0 * 4) + (1 * 8) + (1 * 16) + (0 * 32) + (0 * 64) + (0 * 128),
+               (0 * 1) + (0 * 2) + (0 * 4) + (1 * 8) + (1 * 16) + (1 * 32) + (1 * 64) + (0 * 128),
+               (0 * 1) + (1 * 2) + (0 * 4) + (0 * 8) + (1 * 16) + (0 * 32) + (1 * 64) + (0 * 128),
+               (0 * 1) + (0 * 2) + (0 * 4) + (1 * 8) + (1 * 16) + (1 * 32) + (0 * 64) + (1 * 128),
+               (1 * 1) + (0 * 2) + (1 * 4) + (0 * 8) + (1 * 16) + (0 * 32) + (1 * 64) + (0 * 128)},
+               ""},
+       {[32]byte{(0 * 1) + (1 * 2) + (0 * 4) + (1 * 8) + (0 * 16) + (0 * 32) + (1 * 64) + (1 * 128),
+               (1 * 1) + (1 * 2) + (1 * 4) + (0 * 8) + (1 * 16) + (0 * 32) + (0 * 64) + (1 * 128),
+               (1 * 1) + (0 * 2) + (0 * 4) + (0 * 8) + (0 * 16) + (0 * 32) + (0 * 64) + (1 * 128),
+               (0 * 1) + (1 * 2) + (0 * 4) + (0 * 8) + (1 * 16) + (0 * 32) + (0 * 64) + (0 * 128),
+               (0 * 1) + (1 * 2) + (0 * 4) + (1 * 8) + (0 * 16) + (0 * 32) + (1 * 64) + (1 * 128),
+               (1 * 1) + (1 * 2) + (0 * 4) + (1 * 8) + (1 * 16) + (0 * 32) + (0 * 64) + (0 * 128),
+               (1 * 1) + (0 * 2) + (1 * 4) + (1 * 8) + (1 * 16) + (1 * 32) + (0 * 64) + (1 * 128),
+               (0 * 1) + (1 * 2) + (0 * 4) + (1 * 8) + (0 * 16) + (0 * 32) + (1 * 64) + (1 * 128),
+               (0 * 1) + (1 * 2) + (0 * 4) + (1 * 8) + (1 * 16) + (1 * 32) + (1 * 64) + (1 * 128),
+               (0 * 1) + (1 * 2) + (0 * 4) + (0 * 8) + (0 * 16) + (0 * 32) + (1 * 64) + (1 * 128),
+               (1 * 1) + (0 * 2) + (0 * 4) + (0 * 8) + (1 * 16) + (1 * 32) + (0 * 64) + (0 * 128),
+               (1 * 1) + (1 * 2) + (0 * 4) + (0 * 8) + (1 * 16) + (1 * 32) + (0 * 64) + (1 * 128),
+               (0 * 1) + (1 * 2) + (0 * 4) + (1 * 8) + (1 * 16) + (0 * 32) + (0 * 64) + (1 * 128),
+               (1 * 1) + (1 * 2) + (0 * 4) + (0 * 8) + (0 * 16) + (1 * 32) + (0 * 64) + (0 * 128),
+               (0 * 1) + (0 * 2) + (1 * 4) + (1 * 8) + (1 * 16) + (0 * 32) + (1 * 64) + (1 * 128),
+               (1 * 1) + (0 * 2) + (1 * 4) + (1 * 8) + (0 * 16) + (0 * 32) + (1 * 64) + (0 * 128),
+               (1 * 1) + (1 * 2) + (1 * 4) + (0 * 8) + (0 * 16) + (1 * 32) + (0 * 64) + (1 * 128),
+               (0 * 1) + (1 * 2) + (1 * 4) + (0 * 8) + (0 * 16) + (0 * 32) + (0 * 64) + (1 * 128),
+               (1 * 1) + (1 * 2) + (1 * 4) + (1 * 8) + (0 * 16) + (1 * 32) + (1 * 64) + (1 * 128),
+               (0 * 1) + (0 * 2) + (0 * 4) + (1 * 8) + (1 * 16) + (1 * 32) + (1 * 64) + (1 * 128),
+               (0 * 1) + (0 * 2) + (1 * 4) + (0 * 8) + (1 * 16) + (0 * 32) + (0 * 64) + (0 * 128),
+               (0 * 1) + (0 * 2) + (1 * 4) + (1 * 8) + (1 * 16) + (1 * 32) + (1 * 64) + (0 * 128),
+               (0 * 1) + (1 * 2) + (1 * 4) + (1 * 8) + (0 * 16) + (0 * 32) + (1 * 64) + (0 * 128),
+               (0 * 1) + (1 * 2) + (0 * 4) + (0 * 8) + (1 * 16) + (1 * 32) + (1 * 64) + (0 * 128),
+               (1 * 1) + (0 * 2) + (0 * 4) + (1 * 8) + (1 * 16) + (1 * 32) + (0 * 64) + (1 * 128),
+               (0 * 1) + (0 * 2) + (0 * 4) + (0 * 8) + (0 * 16) + (0 * 32) + (0 * 64) + (1 * 128),
+               (1 * 1) + (1 * 2) + (1 * 4) + (0 * 8) + (1 * 16) + (1 * 32) + (1 * 64) + (0 * 128),
+               (1 * 1) + (0 * 2) + (1 * 4) + (0 * 8) + (0 * 16) + (0 * 32) + (0 * 64) + (1 * 128),
+               (1 * 1) + (1 * 2) + (1 * 4) + (1 * 8) + (0 * 16) + (1 * 32) + (0 * 64) + (1 * 128),
+               (0 * 1) + (1 * 2) + (1 * 4) + (1 * 8) + (0 * 16) + (1 * 32) + (1 * 64) + (1 * 128),
+               (0 * 1) + (0 * 2) + (0 * 4) + (1 * 8) + (0 * 16) + (0 * 32) + (1 * 64) + (0 * 128),
+               (1 * 1) + (1 * 2) + (0 * 4) + (1 * 8) + (1 * 16) + (1 * 32) + (0 * 64) + (1 * 128)},
+               "a"},
+       {[32]byte{(1 * 1) + (1 * 2) + (0 * 4) + (1 * 8) + (1 * 16) + (1 * 32) + (1 * 64) + (1 * 128),
+               (0 * 1) + (1 * 2) + (1 * 4) + (1 * 8) + (0 * 16) + (0 * 32) + (0 * 64) + (1 * 128),
+               (0 * 1) + (0 * 2) + (0 * 4) + (0 * 8) + (0 * 16) + (1 * 32) + (0 * 64) + (0 * 128),
+               (0 * 1) + (0 * 2) + (1 * 4) + (1 * 8) + (1 * 16) + (1 * 32) + (1 * 64) + (1 * 128),
+               (0 * 1) + (1 * 2) + (1 * 4) + (1 * 8) + (0 * 16) + (1 * 32) + (0 * 64) + (0 * 128),
+               (0 * 1) + (0 * 2) + (1 * 4) + (1 * 8) + (0 * 16) + (0 * 32) + (1 * 64) + (0 * 128),
+               (1 * 1) + (1 * 2) + (1 * 4) + (1 * 8) + (1 * 16) + (1 * 32) + (0 * 64) + (0 * 128),
+               (0 * 1) + (0 * 2) + (1 * 4) + (0 * 8) + (0 * 16) + (1 * 32) + (0 * 64) + (0 * 128),
+               (0 * 1) + (0 * 2) + (1 * 4) + (1 * 8) + (0 * 16) + (0 * 32) + (0 * 64) + (1 * 128),
+               (0 * 1) + (0 * 2) + (0 * 4) + (0 * 8) + (0 * 16) + (1 * 32) + (1 * 64) + (0 * 128),
+               (1 * 1) + (1 * 2) + (0 * 4) + (0 * 8) + (0 * 16) + (0 * 32) + (1 * 64) + (1 * 128),
+               (1 * 1) + (1 * 2) + (0 * 4) + (1 * 8) + (1 * 16) + (0 * 32) + (0 * 64) + (1 * 128),
+               (0 * 1) + (1 * 2) + (1 * 4) + (0 * 8) + (1 * 16) + (0 * 32) + (1 * 64) + (1 * 128),
+               (0 * 1) + (1 * 2) + (0 * 4) + (0 * 8) + (1 * 16) + (0 * 32) + (1 * 64) + (0 * 128),
+               (1 * 1) + (1 * 2) + (0 * 4) + (0 * 8) + (1 * 16) + (1 * 32) + (1 * 64) + (1 * 128),
+               (1 * 1) + (0 * 2) + (0 * 4) + (0 * 8) + (0 * 16) + (0 * 32) + (1 * 64) + (1 * 128),
+               (0 * 1) + (0 * 2) + (1 * 4) + (0 * 8) + (1 * 16) + (1 * 32) + (0 * 64) + (0 * 128),
+               (0 * 1) + (1 * 2) + (0 * 4) + (0 * 8) + (1 * 16) + (1 * 32) + (1 * 64) + (0 * 128),
+               (0 * 1) + (0 * 2) + (0 * 4) + (1 * 8) + (1 * 16) + (0 * 32) + (0 * 64) + (1 * 128),
+               (1 * 1) + (1 * 2) + (0 * 4) + (1 * 8) + (1 * 16) + (1 * 32) + (0 * 64) + (1 * 128),
+               (1 * 1) + (1 * 2) + (1 * 4) + (0 * 8) + (1 * 16) + (0 * 32) + (0 * 64) + (1 * 128),
+               (1 * 1) + (1 * 2) + (0 * 4) + (1 * 8) + (1 * 16) + (1 * 32) + (1 * 64) + (0 * 128),
+               (1 * 1) + (1 * 2) + (0 * 4) + (1 * 8) + (0 * 16) + (0 * 32) + (0 * 64) + (1 * 128),
+               (1 * 1) + (0 * 2) + (1 * 4) + (1 * 8) + (0 * 16) + (0 * 32) + (1 * 64) + (0 * 128),
+               (1 * 1) + (0 * 2) + (0 * 4) + (1 * 8) + (1 * 16) + (0 * 32) + (1 * 64) + (0 * 128),
+               (1 * 1) + (1 * 2) + (0 * 4) + (0 * 8) + (0 * 16) + (0 * 32) + (0 * 64) + (0 * 128),
+               (0 * 1) + (0 * 2) + (0 * 4) + (1 * 8) + (1 * 16) + (1 * 32) + (0 * 64) + (1 * 128),
+               (0 * 1) + (0 * 2) + (0 * 4) + (0 * 8) + (1 * 16) + (0 * 32) + (1 * 64) + (0 * 128),
+               (1 * 1) + (0 * 2) + (1 * 4) + (0 * 8) + (1 * 16) + (0 * 32) + (1 * 64) + (0 * 128),
+               (0 * 1) + (1 * 2) + (0 * 4) + (0 * 8) + (0 * 16) + (1 * 32) + (1 * 64) + (0 * 128),
+               (0 * 1) + (1 * 2) + (1 * 4) + (0 * 8) + (0 * 16) + (0 * 32) + (0 * 64) + (0 * 128),
+               (1 * 1) + (1 * 2) + (0 * 4) + (0 * 8) + (0 * 16) + (0 * 32) + (0 * 64) + (0 * 128)},
+               "ab"},
+       {[32]byte{(0 * 1) + (1 * 2) + (0 * 4) + (1 * 8) + (1 * 16) + (1 * 32) + (0 * 64) + (1 * 128),
+               (0 * 1) + (0 * 2) + (0 * 4) + (1 * 8) + (1 * 16) + (1 * 32) + (1 * 64) + (0 * 128),
+               (0 * 1) + (1 * 2) + (1 * 4) + (0 * 8) + (1 * 16) + (0 * 32) + (0 * 64) + (0 * 128),
+               (1 * 1) + (1 * 2) + (1 * 4) + (1 * 8) + (1 * 16) + (1 * 32) + (0 * 64) + (1 * 128),
+               (1 * 1) + (1 * 2) + (1 * 4) + (1 * 8) + (0 * 16) + (0 * 32) + (0 * 64) + (1 * 128),
+               (1 * 1) + (0 * 2) + (0 * 4) + (0 * 8) + (0 * 16) + (0 * 32) + (0 * 64) + (0 * 128),
+               (1 * 1) + (1 * 2) + (1 * 4) + (1 * 8) + (0 * 16) + (0 * 32) + (1 * 64) + (1 * 128),
+               (0 * 1) + (1 * 2) + (0 * 4) + (1 * 8) + (0 * 16) + (1 * 32) + (1 * 64) + (1 * 128),
+               (1 * 1) + (0 * 2) + (0 * 4) + (0 * 8) + (0 * 16) + (0 * 32) + (1 * 64) + (0 * 128),
+               (1 * 1) + (0 * 2) + (0 * 4) + (0 * 8) + (0 * 16) + (0 * 32) + (1 * 64) + (0 * 128),
+               (0 * 1) + (0 * 2) + (0 * 4) + (0 * 8) + (0 * 16) + (0 * 32) + (1 * 64) + (0 * 128),
+               (0 * 1) + (1 * 2) + (1 * 4) + (1 * 8) + (1 * 16) + (0 * 32) + (1 * 64) + (1 * 128),
+               (1 * 1) + (0 * 2) + (1 * 4) + (1 * 8) + (1 * 16) + (0 * 32) + (1 * 64) + (0 * 128),
+               (0 * 1) + (1 * 2) + (1 * 4) + (1 * 8) + (0 * 16) + (1 * 32) + (0 * 64) + (1 * 128),
+               (0 * 1) + (1 * 2) + (0 * 4) + (0 * 8) + (0 * 16) + (1 * 32) + (0 * 64) + (0 * 128),
+               (1 * 1) + (1 * 2) + (0 * 4) + (0 * 8) + (0 * 16) + (1 * 32) + (0 * 64) + (0 * 128),
+               (0 * 1) + (0 * 2) + (0 * 4) + (0 * 8) + (1 * 16) + (1 * 32) + (0 * 64) + (1 * 128),
+               (1 * 1) + (1 * 2) + (0 * 4) + (0 * 8) + (0 * 16) + (0 * 32) + (0 * 64) + (0 * 128),
+               (1 * 1) + (0 * 2) + (0 * 4) + (0 * 8) + (0 * 16) + (1 * 32) + (1 * 64) + (0 * 128),
+               (1 * 1) + (1 * 2) + (0 * 4) + (0 * 8) + (0 * 16) + (1 * 32) + (0 * 64) + (1 * 128),
+               (0 * 1) + (1 * 2) + (1 * 4) + (0 * 8) + (1 * 16) + (0 * 32) + (0 * 64) + (1 * 128),
+               (1 * 1) + (1 * 2) + (1 * 4) + (0 * 8) + (1 * 16) + (0 * 32) + (0 * 64) + (0 * 128),
+               (0 * 1) + (1 * 2) + (0 * 4) + (1 * 8) + (1 * 16) + (1 * 32) + (1 * 64) + (0 * 128),
+               (0 * 1) + (0 * 2) + (1 * 4) + (1 * 8) + (1 * 16) + (0 * 32) + (0 * 64) + (1 * 128),
+               (0 * 1) + (0 * 2) + (1 * 4) + (0 * 8) + (1 * 16) + (1 * 32) + (0 * 64) + (1 * 128),
+               (0 * 1) + (0 * 2) + (0 * 4) + (0 * 8) + (1 * 16) + (0 * 32) + (0 * 64) + (0 * 128),
+               (1 * 1) + (1 * 2) + (1 * 4) + (1 * 8) + (1 * 16) + (1 * 32) + (1 * 64) + (1 * 128),
+               (1 * 1) + (0 * 2) + (0 * 4) + (0 * 8) + (0 * 16) + (1 * 32) + (1 * 64) + (0 * 128),
+               (0 * 1) + (1 * 2) + (0 * 4) + (0 * 8) + (1 * 16) + (1 * 32) + (1 * 64) + (1 * 128),
+               (0 * 1) + (0 * 2) + (0 * 4) + (0 * 8) + (0 * 16) + (0 * 32) + (0 * 64) + (0 * 128),
+               (1 * 1) + (0 * 2) + (1 * 4) + (0 * 8) + (1 * 16) + (0 * 32) + (0 * 64) + (0 * 128),
+               (1 * 1) + (0 * 2) + (1 * 4) + (1 * 8) + (0 * 16) + (1 * 32) + (0 * 64) + (1 * 128)},
+               "abc"},
+       {[32]byte{(0 * 1) + (0 * 2) + (0 * 4) + (1 * 8) + (0 * 16) + (0 * 32) + (0 * 64) + (1 * 128),
+               (0 * 1) + (0 * 2) + (1 * 4) + (0 * 8) + (1 * 16) + (0 * 32) + (1 * 64) + (1 * 128),
+               (0 * 1) + (1 * 2) + (1 * 4) + (0 * 8) + (0 * 16) + (1 * 32) + (0 * 64) + (0 * 128),
+               (1 * 1) + (1 * 2) + (1 * 4) + (1 * 8) + (0 * 16) + (1 * 32) + (1 * 64) + (0 * 128),
+               (0 * 1) + (0 * 2) + (1 * 4) + (0 * 8) + (1 * 16) + (0 * 32) + (1 * 64) + (1 * 128),
+               (0 * 1) + (1 * 2) + (1 * 4) + (0 * 8) + (0 * 16) + (1 * 32) + (1 * 64) + (1 * 128),
+               (1 * 1) + (1 * 2) + (0 * 4) + (0 * 8) + (1 * 16) + (1 * 32) + (0 * 64) + (0 * 128),
+               (1 * 1) + (0 * 2) + (1 * 4) + (1 * 8) + (0 * 16) + (0 * 32) + (0 * 64) + (1 * 128),
+               (1 * 1) + (1 * 2) + (0 * 4) + (0 * 8) + (1 * 16) + (0 * 32) + (0 * 64) + (0 * 128),
+               (0 * 1) + (0 * 2) + (0 * 4) + (1 * 8) + (1 * 16) + (1 * 32) + (0 * 64) + (1 * 128),
+               (1 * 1) + (0 * 2) + (1 * 4) + (0 * 8) + (0 * 16) + (0 * 32) + (1 * 64) + (0 * 128),
+               (0 * 1) + (0 * 2) + (1 * 4) + (1 * 8) + (1 * 16) + (1 * 32) + (1 * 64) + (1 * 128),
+               (0 * 1) + (1 * 2) + (0 * 4) + (0 * 8) + (1 * 16) + (1 * 32) + (1 * 64) + (1 * 128),
+               (1 * 1) + (0 * 2) + (0 * 4) + (1 * 8) + (0 * 16) + (0 * 32) + (0 * 64) + (1 * 128),
+               (1 * 1) + (1 * 2) + (1 * 4) + (0 * 8) + (1 * 16) + (0 * 32) + (1 * 64) + (0 * 128),
+               (1 * 1) + (0 * 2) + (1 * 4) + (1 * 8) + (1 * 16) + (0 * 32) + (0 * 64) + (1 * 128),
+               (0 * 1) + (0 * 2) + (0 * 4) + (0 * 8) + (0 * 16) + (1 * 32) + (0 * 64) + (0 * 128),
+               (0 * 1) + (0 * 2) + (1 * 4) + (1 * 8) + (1 * 16) + (0 * 32) + (0 * 64) + (1 * 128),
+               (1 * 1) + (0 * 2) + (0 * 4) + (1 * 8) + (0 * 16) + (0 * 32) + (0 * 64) + (1 * 128),
+               (0 * 1) + (0 * 2) + (0 * 4) + (1 * 8) + (1 * 16) + (1 * 32) + (1 * 64) + (0 * 128),
+               (1 * 1) + (1 * 2) + (0 * 4) + (0 * 8) + (0 * 16) + (1 * 32) + (0 * 64) + (0 * 128),
+               (1 * 1) + (0 * 2) + (0 * 4) + (1 * 8) + (1 * 16) + (1 * 32) + (0 * 64) + (1 * 128),
+               (1 * 1) + (0 * 2) + (0 * 4) + (0 * 8) + (0 * 16) + (1 * 32) + (0 * 64) + (0 * 128),
+               (1 * 1) + (0 * 2) + (1 * 4) + (1 * 8) + (1 * 16) + (1 * 32) + (1 * 64) + (0 * 128),
+               (1 * 1) + (1 * 2) + (0 * 4) + (0 * 8) + (0 * 16) + (1 * 32) + (0 * 64) + (1 * 128),
+               (1 * 1) + (0 * 2) + (0 * 4) + (0 * 8) + (0 * 16) + (1 * 32) + (1 * 64) + (1 * 128),
+               (1 * 1) + (0 * 2) + (0 * 4) + (0 * 8) + (0 * 16) + (1 * 32) + (1 * 64) + (0 * 128),
+               (1 * 1) + (1 * 2) + (0 * 4) + (0 * 8) + (1 * 16) + (0 * 32) + (0 * 64) + (1 * 128),
+               (1 * 1) + (1 * 2) + (1 * 4) + (1 * 8) + (0 * 16) + (1 * 32) + (1 * 64) + (0 * 128),
+               (1 * 1) + (1 * 2) + (0 * 4) + (0 * 8) + (0 * 16) + (0 * 32) + (0 * 64) + (0 * 128),
+               (1 * 1) + (0 * 2) + (1 * 4) + (0 * 8) + (1 * 16) + (0 * 32) + (0 * 64) + (0 * 128),
+               (1 * 1) + (0 * 2) + (0 * 4) + (1 * 8) + (0 * 16) + (0 * 32) + (0 * 64) + (1 * 128)},
+               "abcd"},
+       {[32]byte{(0 * 1) + (1 * 2) + (1 * 4) + (0 * 8) + (1 * 16) + (1 * 32) + (0 * 64) + (0 * 128),
+               (1 * 1) + (1 * 2) + (0 * 4) + (1 * 8) + (1 * 16) + (1 * 32) + (0 * 64) + (1 * 128),
+               (1 * 1) + (0 * 2) + (1 * 4) + (0 * 8) + (0 * 16) + (1 * 32) + (1 * 64) + (1 * 128),
+               (0 * 1) + (1 * 2) + (1 * 4) + (1 * 8) + (0 * 16) + (0 * 32) + (0 * 64) + (0 * 128),
+               (1 * 1) + (0 * 2) + (0 * 4) + (1 * 8) + (1 * 16) + (0 * 32) + (1 * 64) + (1 * 128),
+               (0 * 1) + (0 * 2) + (0 * 4) + (1 * 8) + (0 * 16) + (1 * 32) + (1 * 64) + (0 * 128),
+               (1 * 1) + (0 * 2) + (0 * 4) + (0 * 8) + (0 * 16) + (0 * 32) + (1 * 64) + (0 * 128),
+               (1 * 1) + (0 * 2) + (0 * 4) + (0 * 8) + (1 * 16) + (0 * 32) + (1 * 64) + (1 * 128),
+               (0 * 1) + (0 * 2) + (1 * 4) + (0 * 8) + (0 * 16) + (0 * 32) + (0 * 64) + (0 * 128),
+               (1 * 1) + (1 * 2) + (0 * 4) + (0 * 8) + (0 * 16) + (0 * 32) + (1 * 64) + (0 * 128),
+               (0 * 1) + (0 * 2) + (1 * 4) + (1 * 8) + (1 * 16) + (1 * 32) + (0 * 64) + (1 * 128),
+               (0 * 1) + (1 * 2) + (1 * 4) + (0 * 8) + (1 * 16) + (1 * 32) + (0 * 64) + (1 * 128),
+               (0 * 1) + (0 * 2) + (0 * 4) + (0 * 8) + (1 * 16) + (1 * 32) + (1 * 64) + (0 * 128),
+               (0 * 1) + (1 * 2) + (1 * 4) + (0 * 8) + (1 * 16) + (0 * 32) + (1 * 64) + (1 * 128),
+               (1 * 1) + (0 * 2) + (1 * 4) + (0 * 8) + (1 * 16) + (0 * 32) + (1 * 64) + (0 * 128),
+               (1 * 1) + (1 * 2) + (1 * 4) + (1 * 8) + (0 * 16) + (0 * 32) + (1 * 64) + (0 * 128),
+               (0 * 1) + (1 * 2) + (0 * 4) + (1 * 8) + (0 * 16) + (0 * 32) + (0 * 64) + (0 * 128),
+               (0 * 1) + (0 * 2) + (1 * 4) + (0 * 8) + (1 * 16) + (1 * 32) + (0 * 64) + (0 * 128),
+               (1 * 1) + (1 * 2) + (1 * 4) + (0 * 8) + (1 * 16) + (1 * 32) + (0 * 64) + (1 * 128),
+               (1 * 1) + (0 * 2) + (0 * 4) + (0 * 8) + (0 * 16) + (1 * 32) + (1 * 64) + (0 * 128),
+               (0 * 1) + (1 * 2) + (1 * 4) + (1 * 8) + (1 * 16) + (1 * 32) + (0 * 64) + (1 * 128),
+               (1 * 1) + (1 * 2) + (1 * 4) + (0 * 8) + (0 * 16) + (1 * 32) + (1 * 64) + (0 * 128),
+               (0 * 1) + (0 * 2) + (1 * 4) + (1 * 8) + (0 * 16) + (1 * 32) + (1 * 64) + (1 * 128),
+               (0 * 1) + (0 * 2) + (1 * 4) + (1 * 8) + (1 * 16) + (0 * 32) + (0 * 64) + (1 * 128),
+               (0 * 1) + (1 * 2) + (0 * 4) + (1 * 8) + (0 * 16) + (0 * 32) + (1 * 64) + (0 * 128),
+               (0 * 1) + (1 * 2) + (0 * 4) + (1 * 8) + (0 * 16) + (0 * 32) + (0 * 64) + (1 * 128),
+               (0 * 1) + (1 * 2) + (0 * 4) + (0 * 8) + (1 * 16) + (0 * 32) + (1 * 64) + (1 * 128),
+               (0 * 1) + (0 * 2) + (0 * 4) + (0 * 8) + (0 * 16) + (0 * 32) + (1 * 64) + (1 * 128),
+               (0 * 1) + (0 * 2) + (1 * 4) + (0 * 8) + (0 * 16) + (0 * 32) + (1 * 64) + (1 * 128),
+               (0 * 1) + (0 * 2) + (1 * 4) + (1 * 8) + (0 * 16) + (0 * 32) + (1 * 64) + (0 * 128),
+               (0 * 1) + (0 * 2) + (1 * 4) + (0 * 8) + (0 * 16) + (1 * 32) + (0 * 64) + (1 * 128),
+               (0 * 1) + (0 * 2) + (1 * 4) + (1 * 8) + (0 * 16) + (1 * 32) + (0 * 64) + (0 * 128)},
+               "abcde"},
+       {[32]byte{(0 * 1) + (1 * 2) + (1 * 4) + (1 * 8) + (1 * 16) + (1 * 32) + (0 * 64) + (1 * 128),
+               (1 * 1) + (0 * 2) + (1 * 4) + (0 * 8) + (1 * 16) + (1 * 32) + (1 * 64) + (1 * 128),
+               (0 * 1) + (1 * 2) + (1 * 4) + (1 * 8) + (1 * 16) + (1 * 32) + (1 * 64) + (0 * 128),
+               (1 * 1) + (1 * 2) + (1 * 4) + (0 * 8) + (0 * 16) + (0 * 32) + (1 * 64) + (1 * 128),
+               (1 * 1) + (0 * 2) + (1 * 4) + (0 * 8) + (1 * 16) + (1 * 32) + (1 * 64) + (1 * 128),
+               (0 * 1) + (1 * 2) + (0 * 4) + (1 * 8) + (1 * 16) + (1 * 32) + (0 * 64) + (0 * 128),
+               (1 * 1) + (0 * 2) + (1 * 4) + (1 * 8) + (0 * 16) + (1 * 32) + (1 * 64) + (0 * 128),
+               (0 * 1) + (0 * 2) + (0 * 4) + (0 * 8) + (0 * 16) + (0 * 32) + (1 * 64) + (0 * 128),
+               (0 * 1) + (1 * 2) + (1 * 4) + (1 * 8) + (1 * 16) + (1 * 32) + (0 * 64) + (1 * 128),
+               (0 * 1) + (1 * 2) + (1 * 4) + (0 * 8) + (1 * 16) + (1 * 32) + (0 * 64) + (1 * 128),
+               (0 * 1) + (0 * 2) + (0 * 4) + (0 * 8) + (0 * 16) + (0 * 32) + (1 * 64) + (0 * 128),
+               (1 * 1) + (1 * 2) + (1 * 4) + (0 * 8) + (0 * 16) + (1 * 32) + (0 * 64) + (1 * 128),
+               (0 * 1) + (0 * 2) + (0 * 4) + (0 * 8) + (0 * 16) + (0 * 32) + (0 * 64) + (1 * 128),
+               (0 * 1) + (1 * 2) + (1 * 4) + (0 * 8) + (0 * 16) + (1 * 32) + (0 * 64) + (1 * 128),
+               (1 * 1) + (0 * 2) + (0 * 4) + (1 * 8) + (1 * 16) + (1 * 32) + (0 * 64) + (0 * 128),
+               (0 * 1) + (0 * 2) + (0 * 4) + (1 * 8) + (0 * 16) + (0 * 32) + (1 * 64) + (1 * 128),
+               (1 * 1) + (1 * 2) + (0 * 4) + (1 * 8) + (1 * 16) + (1 * 32) + (0 * 64) + (0 * 128),
+               (0 * 1) + (1 * 2) + (0 * 4) + (0 * 8) + (0 * 16) + (0 * 32) + (1 * 64) + (1 * 128),
+               (0 * 1) + (1 * 2) + (0 * 4) + (1 * 8) + (1 * 16) + (0 * 32) + (0 * 64) + (1 * 128),
+               (0 * 1) + (0 * 2) + (0 * 4) + (1 * 8) + (0 * 16) + (0 * 32) + (1 * 64) + (1 * 128),
+               (1 * 1) + (0 * 2) + (0 * 4) + (1 * 8) + (0 * 16) + (1 * 32) + (0 * 64) + (1 * 128),
+               (1 * 1) + (0 * 2) + (0 * 4) + (0 * 8) + (0 * 16) + (0 * 32) + (0 * 64) + (1 * 128),
+               (1 * 1) + (1 * 2) + (1 * 4) + (1 * 8) + (0 * 16) + (1 * 32) + (1 * 64) + (0 * 128),
+               (1 * 1) + (1 * 2) + (1 * 4) + (1 * 8) + (1 * 16) + (0 * 32) + (0 * 64) + (0 * 128),
+               (0 * 1) + (1 * 2) + (1 * 4) + (0 * 8) + (0 * 16) + (0 * 32) + (1 * 64) + (1 * 128),
+               (1 * 1) + (0 * 2) + (1 * 4) + (0 * 8) + (0 * 16) + (0 * 32) + (1 * 64) + (1 * 128),
+               (0 * 1) + (1 * 2) + (1 * 4) + (0 * 8) + (0 * 16) + (0 * 32) + (1 * 64) + (1 * 128),
+               (0 * 1) + (0 * 2) + (1 * 4) + (1 * 8) + (1 * 16) + (0 * 32) + (1 * 64) + (1 * 128),
+               (1 * 1) + (0 * 2) + (0 * 4) + (1 * 8) + (1 * 16) + (0 * 32) + (1 * 64) + (1 * 128),
+               (0 * 1) + (0 * 2) + (1 * 4) + (1 * 8) + (1 * 16) + (1 * 32) + (0 * 64) + (0 * 128),
+               (1 * 1) + (1 * 2) + (1 * 4) + (0 * 8) + (0 * 16) + (0 * 32) + (1 * 64) + (0 * 128),
+               (1 * 1) + (0 * 2) + (0 * 4) + (0 * 8) + (0 * 16) + (1 * 32) + (0 * 64) + (0 * 128)},
+               "abcdef"},
+       {[32]byte{(1 * 1) + (0 * 2) + (1 * 4) + (1 * 8) + (1 * 16) + (1 * 32) + (1 * 64) + (0 * 128),
+               (0 * 1) + (1 * 2) + (0 * 4) + (1 * 8) + (1 * 16) + (0 * 32) + (0 * 64) + (0 * 128),
+               (0 * 1) + (0 * 2) + (1 * 4) + (0 * 8) + (1 * 16) + (0 * 32) + (1 * 64) + (0 * 128),
+               (0 * 1) + (1 * 2) + (0 * 4) + (0 * 8) + (1 * 16) + (0 * 32) + (0 * 64) + (0 * 128),
+               (1 * 1) + (1 * 2) + (0 * 4) + (1 * 8) + (1 * 16) + (1 * 32) + (1 * 64) + (0 * 128),
+               (0 * 1) + (1 * 2) + (0 * 4) + (0 * 8) + (0 * 16) + (1 * 32) + (0 * 64) + (0 * 128),
+               (1 * 1) + (0 * 2) + (1 * 4) + (0 * 8) + (0 * 16) + (1 * 32) + (0 * 64) + (0 * 128),
+               (0 * 1) + (1 * 2) + (0 * 4) + (0 * 8) + (0 * 16) + (0 * 32) + (0 * 64) + (0 * 128),
+               (1 * 1) + (0 * 2) + (1 * 4) + (0 * 8) + (1 * 16) + (1 * 32) + (1 * 64) + (1 * 128),
+               (1 * 1) + (1 * 2) + (1 * 4) + (0 * 8) + (1 * 16) + (1 * 32) + (0 * 64) + (1 * 128),
+               (1 * 1) + (1 * 2) + (0 * 4) + (1 * 8) + (1 * 16) + (0 * 32) + (0 * 64) + (1 * 128),
+               (1 * 1) + (1 * 2) + (1 * 4) + (1 * 8) + (1 * 16) + (0 * 32) + (1 * 64) + (0 * 128),
+               (0 * 1) + (0 * 2) + (0 * 4) + (0 * 8) + (1 * 16) + (1 * 32) + (0 * 64) + (1 * 128),
+               (0 * 1) + (0 * 2) + (0 * 4) + (0 * 8) + (0 * 16) + (0 * 32) + (0 * 64) + (1 * 128),
+               (0 * 1) + (0 * 2) + (0 * 4) + (0 * 8) + (1 * 16) + (1 * 32) + (0 * 64) + (0 * 128),
+               (1 * 1) + (0 * 2) + (0 * 4) + (0 * 8) + (0 * 16) + (1 * 32) + (1 * 64) + (0 * 128),
+               (1 * 1) + (0 * 2) + (1 * 4) + (0 * 8) + (1 * 16) + (0 * 32) + (0 * 64) + (0 * 128),
+               (0 * 1) + (1 * 2) + (0 * 4) + (1 * 8) + (0 * 16) + (1 * 32) + (0 * 64) + (0 * 128),
+               (0 * 1) + (0 * 2) + (1 * 4) + (0 * 8) + (0 * 16) + (0 * 32) + (1 * 64) + (0 * 128),
+               (1 * 1) + (0 * 2) + (0 * 4) + (1 * 8) + (1 * 16) + (1 * 32) + (1 * 64) + (1 * 128),
+               (1 * 1) + (1 * 2) + (0 * 4) + (1 * 8) + (0 * 16) + (1 * 32) + (0 * 64) + (0 * 128),
+               (1 * 1) + (1 * 2) + (1 * 4) + (0 * 8) + (1 * 16) + (1 * 32) + (0 * 64) + (0 * 128),
+               (0 * 1) + (1 * 2) + (0 * 4) + (0 * 8) + (0 * 16) + (1 * 32) + (1 * 64) + (1 * 128),
+               (0 * 1) + (0 * 2) + (1 * 4) + (1 * 8) + (1 * 16) + (1 * 32) + (0 * 64) + (0 * 128),
+               (1 * 1) + (0 * 2) + (1 * 4) + (0 * 8) + (0 * 16) + (1 * 32) + (1 * 64) + (0 * 128),
+               (1 * 1) + (1 * 2) + (1 * 4) + (0 * 8) + (0 * 16) + (1 * 32) + (0 * 64) + (0 * 128),
+               (0 * 1) + (1 * 2) + (0 * 4) + (1 * 8) + (1 * 16) + (1 * 32) + (0 * 64) + (1 * 128),
+               (0 * 1) + (1 * 2) + (1 * 4) + (0 * 8) + (1 * 16) + (1 * 32) + (1 * 64) + (1 * 128),
+               (1 * 1) + (0 * 2) + (1 * 4) + (0 * 8) + (0 * 16) + (1 * 32) + (1 * 64) + (0 * 128),
+               (0 * 1) + (0 * 2) + (1 * 4) + (0 * 8) + (1 * 16) + (0 * 32) + (1 * 64) + (1 * 128),
+               (0 * 1) + (1 * 2) + (0 * 4) + (1 * 8) + (1 * 16) + (0 * 32) + (1 * 64) + (1 * 128),
+               (0 * 1) + (1 * 2) + (0 * 4) + (1 * 8) + (1 * 16) + (0 * 32) + (0 * 64) + (1 * 128)},
+               "abcdefg"},
+       {[32]byte{(0 * 1) + (0 * 2) + (1 * 4) + (1 * 8) + (1 * 16) + (0 * 32) + (0 * 64) + (1 * 128),
+               (0 * 1) + (1 * 2) + (1 * 4) + (0 * 8) + (1 * 16) + (0 * 32) + (1 * 64) + (0 * 128),
+               (0 * 1) + (0 * 2) + (1 * 4) + (1 * 8) + (0 * 16) + (0 * 32) + (1 * 64) + (1 * 128),
+               (1 * 1) + (0 * 2) + (0 * 4) + (0 * 8) + (1 * 16) + (0 * 32) + (1 * 64) + (0 * 128),
+               (1 * 1) + (1 * 2) + (0 * 4) + (0 * 8) + (1 * 16) + (1 * 32) + (0 * 64) + (1 * 128),
+               (0 * 1) + (0 * 2) + (1 * 4) + (0 * 8) + (1 * 16) + (1 * 32) + (1 * 64) + (0 * 128),
+               (1 * 1) + (1 * 2) + (0 * 4) + (0 * 8) + (0 * 16) + (0 * 32) + (1 * 64) + (1 * 128),
+               (0 * 1) + (1 * 2) + (0 * 4) + (1 * 8) + (1 * 16) + (1 * 32) + (0 * 64) + (1 * 128),
+               (0 * 1) + (0 * 2) + (0 * 4) + (1 * 8) + (1 * 16) + (0 * 32) + (0 * 64) + (0 * 128),
+               (0 * 1) + (1 * 2) + (0 * 4) + (0 * 8) + (1 * 16) + (0 * 32) + (0 * 64) + (1 * 128),
+               (0 * 1) + (0 * 2) + (0 * 4) + (0 * 8) + (1 * 16) + (0 * 32) + (0 * 64) + (0 * 128),
+               (1 * 1) + (0 * 2) + (1 * 4) + (0 * 8) + (1 * 16) + (0 * 32) + (1 * 64) + (1 * 128),
+               (0 * 1) + (1 * 2) + (1 * 4) + (0 * 8) + (1 * 16) + (1 * 32) + (0 * 64) + (1 * 128),
+               (0 * 1) + (0 * 2) + (1 * 4) + (0 * 8) + (1 * 16) + (0 * 32) + (1 * 64) + (1 * 128),
+               (1 * 1) + (1 * 2) + (1 * 4) + (1 * 8) + (1 * 16) + (1 * 32) + (0 * 64) + (1 * 128),
+               (1 * 1) + (1 * 2) + (1 * 4) + (0 * 8) + (1 * 16) + (0 * 32) + (1 * 64) + (0 * 128),
+               (1 * 1) + (0 * 2) + (0 * 4) + (1 * 8) + (1 * 16) + (1 * 32) + (1 * 64) + (0 * 128),
+               (1 * 1) + (0 * 2) + (1 * 4) + (1 * 8) + (0 * 16) + (0 * 32) + (0 * 64) + (0 * 128),
+               (1 * 1) + (0 * 2) + (1 * 4) + (0 * 8) + (1 * 16) + (1 * 32) + (0 * 64) + (0 * 128),
+               (0 * 1) + (0 * 2) + (1 * 4) + (1 * 8) + (1 * 16) + (0 * 32) + (0 * 64) + (0 * 128),
+               (0 * 1) + (1 * 2) + (1 * 4) + (0 * 8) + (1 * 16) + (0 * 32) + (0 * 64) + (1 * 128),
+               (0 * 1) + (0 * 2) + (1 * 4) + (0 * 8) + (0 * 16) + (0 * 32) + (1 * 64) + (1 * 128),
+               (0 * 1) + (0 * 2) + (1 * 4) + (1 * 8) + (1 * 16) + (1 * 32) + (1 * 64) + (0 * 128),
+               (0 * 1) + (1 * 2) + (0 * 4) + (0 * 8) + (0 * 16) + (0 * 32) + (0 * 64) + (0 * 128),
+               (1 * 1) + (0 * 2) + (0 * 4) + (1 * 8) + (1 * 16) + (0 * 32) + (0 * 64) + (0 * 128),
+               (0 * 1) + (1 * 2) + (1 * 4) + (1 * 8) + (0 * 16) + (0 * 32) + (0 * 64) + (0 * 128),
+               (1 * 1) + (1 * 2) + (1 * 4) + (1 * 8) + (0 * 16) + (0 * 32) + (1 * 64) + (1 * 128),
+               (0 * 1) + (1 * 2) + (1 * 4) + (1 * 8) + (1 * 16) + (0 * 32) + (0 * 64) + (0 * 128),
+               (1 * 1) + (1 * 2) + (0 * 4) + (0 * 8) + (0 * 16) + (0 * 32) + (1 * 64) + (0 * 128),
+               (0 * 1) + (1 * 2) + (1 * 4) + (0 * 8) + (0 * 16) + (0 * 32) + (0 * 64) + (0 * 128),
+               (1 * 1) + (0 * 2) + (1 * 4) + (0 * 8) + (1 * 16) + (1 * 32) + (0 * 64) + (0 * 128),
+               (1 * 1) + (1 * 2) + (0 * 4) + (1 * 8) + (0 * 16) + (1 * 32) + (0 * 64) + (1 * 128)},
+               "abcdefgh"},
+       {[32]byte{(1 * 1) + (0 * 2) + (0 * 4) + (1 * 8) + (1 * 16) + (0 * 32) + (0 * 64) + (0 * 128),
+               (0 * 1) + (0 * 2) + (1 * 4) + (1 * 8) + (0 * 16) + (0 * 32) + (1 * 64) + (1 * 128),
+               (0 * 1) + (1 * 2) + (0 * 4) + (0 * 8) + (0 * 16) + (0 * 32) + (0 * 64) + (0 * 128),
+               (0 * 1) + (1 * 2) + (0 * 4) + (0 * 8) + (1 * 16) + (1 * 32) + (1 * 64) + (1 * 128),
+               (1 * 1) + (0 * 2) + (1 * 4) + (1 * 8) + (0 * 16) + (1 * 32) + (1 * 64) + (0 * 128),
+               (0 * 1) + (0 * 2) + (1 * 4) + (0 * 8) + (1 * 16) + (1 * 32) + (1 * 64) + (1 * 128),
+               (0 * 1) + (0 * 2) + (1 * 4) + (1 * 8) + (1 * 16) + (1 * 32) + (0 * 64) + (0 * 128),
+               (1 * 1) + (0 * 2) + (1 * 4) + (0 * 8) + (0 * 16) + (0 * 32) + (1 * 64) + (1 * 128),
+               (1 * 1) + (0 * 2) + (0 * 4) + (0 * 8) + (1 * 16) + (1 * 32) + (1 * 64) + (0 * 128),
+               (0 * 1) + (0 * 2) + (1 * 4) + (1 * 8) + (1 * 16) + (1 * 32) + (0 * 64) + (1 * 128),
+               (0 * 1) + (1 * 2) + (1 * 4) + (1 * 8) + (1 * 16) + (0 * 32) + (0 * 64) + (1 * 128),
+               (1 * 1) + (1 * 2) + (1 * 4) + (0 * 8) + (1 * 16) + (0 * 32) + (1 * 64) + (1 * 128),
+               (0 * 1) + (0 * 2) + (0 * 4) + (0 * 8) + (1 * 16) + (1 * 32) + (0 * 64) + (1 * 128),
+               (0 * 1) + (0 * 2) + (1 * 4) + (0 * 8) + (0 * 16) + (0 * 32) + (1 * 64) + (1 * 128),
+               (0 * 1) + (1 * 2) + (0 * 4) + (0 * 8) + (1 * 16) + (0 * 32) + (1 * 64) + (1 * 128),
+               (0 * 1) + (1 * 2) + (0 * 4) + (0 * 8) + (1 * 16) + (0 * 32) + (0 * 64) + (1 * 128),
+               (0 * 1) + (0 * 2) + (1 * 4) + (0 * 8) + (0 * 16) + (1 * 32) + (0 * 64) + (0 * 128),
+               (1 * 1) + (1 * 2) + (0 * 4) + (0 * 8) + (0 * 16) + (1 * 32) + (0 * 64) + (1 * 128),
+               (0 * 1) + (0 * 2) + (1 * 4) + (1 * 8) + (0 * 16) + (1 * 32) + (1 * 64) + (1 * 128),
+               (0 * 1) + (1 * 2) + (0 * 4) + (0 * 8) + (0 * 16) + (1 * 32) + (0 * 64) + (0 * 128),
+               (1 * 1) + (0 * 2) + (1 * 4) + (0 * 8) + (1 * 16) + (0 * 32) + (0 * 64) + (1 * 128),
+               (1 * 1) + (0 * 2) + (0 * 4) + (1 * 8) + (0 * 16) + (1 * 32) + (0 * 64) + (0 * 128),
+               (0 * 1) + (1 * 2) + (0 * 4) + (0 * 8) + (0 * 16) + (1 * 32) + (0 * 64) + (0 * 128),
+               (1 * 1) + (1 * 2) + (1 * 4) + (0 * 8) + (1 * 16) + (0 * 32) + (0 * 64) + (0 * 128),
+               (1 * 1) + (0 * 2) + (1 * 4) + (0 * 8) + (0 * 16) + (1 * 32) + (0 * 64) + (0 * 128),
+               (1 * 1) + (1 * 2) + (1 * 4) + (1 * 8) + (0 * 16) + (1 * 32) + (1 * 64) + (1 * 128),
+               (0 * 1) + (1 * 2) + (1 * 4) + (0 * 8) + (1 * 16) + (1 * 32) + (1 * 64) + (0 * 128),
+               (0 * 1) + (0 * 2) + (0 * 4) + (0 * 8) + (1 * 16) + (0 * 32) + (1 * 64) + (1 * 128),
+               (1 * 1) + (0 * 2) + (0 * 4) + (0 * 8) + (0 * 16) + (1 * 32) + (0 * 64) + (0 * 128),
+               (0 * 1) + (0 * 2) + (0 * 4) + (1 * 8) + (0 * 16) + (0 * 32) + (1 * 64) + (1 * 128),
+               (0 * 1) + (1 * 2) + (0 * 4) + (0 * 8) + (1 * 16) + (1 * 32) + (0 * 64) + (0 * 128),
+               (1 * 1) + (1 * 2) + (1 * 4) + (1 * 8) + (0 * 16) + (1 * 32) + (1 * 64) + (0 * 128)},
+               "abcdefghi"},
+       {[32]byte{(0 * 1) + (1 * 2) + (0 * 4) + (0 * 8) + (1 * 16) + (1 * 32) + (1 * 64) + (0 * 128),
+               (1 * 1) + (0 * 2) + (0 * 4) + (1 * 8) + (1 * 16) + (1 * 32) + (0 * 64) + (0 * 128),
+               (1 * 1) + (1 * 2) + (0 * 4) + (0 * 8) + (1 * 16) + (0 * 32) + (0 * 64) + (1 * 128),
+               (1 * 1) + (0 * 2) + (0 * 4) + (0 * 8) + (0 * 16) + (1 * 32) + (1 * 64) + (0 * 128),
+               (0 * 1) + (1 * 2) + (0 * 4) + (1 * 8) + (1 * 16) + (0 * 32) + (1 * 64) + (1 * 128),
+               (0 * 1) + (1 * 2) + (0 * 4) + (1 * 8) + (0 * 16) + (1 * 32) + (1 * 64) + (0 * 128),
+               (1 * 1) + (1 * 2) + (1 * 4) + (0 * 8) + (1 * 16) + (1 * 32) + (1 * 64) + (0 * 128),
+               (0 * 1) + (0 * 2) + (1 * 4) + (0 * 8) + (1 * 16) + (0 * 32) + (1 * 64) + (0 * 128),
+               (0 * 1) + (1 * 2) + (1 * 4) + (1 * 8) + (1 * 16) + (1 * 32) + (1 * 64) + (1 * 128),
+               (1 * 1) + (0 * 2) + (0 * 4) + (1 * 8) + (0 * 16) + (0 * 32) + (1 * 64) + (1 * 128),
+               (0 * 1) + (1 * 2) + (1 * 4) + (0 * 8) + (0 * 16) + (0 * 32) + (0 * 64) + (1 * 128),
+               (0 * 1) + (0 * 2) + (1 * 4) + (1 * 8) + (1 * 16) + (0 * 32) + (1 * 64) + (1 * 128),
+               (1 * 1) + (0 * 2) + (1 * 4) + (0 * 8) + (0 * 16) + (1 * 32) + (0 * 64) + (1 * 128),
+               (1 * 1) + (1 * 2) + (1 * 4) + (0 * 8) + (1 * 16) + (1 * 32) + (0 * 64) + (1 * 128),
+               (1 * 1) + (1 * 2) + (0 * 4) + (1 * 8) + (0 * 16) + (0 * 32) + (1 * 64) + (1 * 128),
+               (1 * 1) + (1 * 2) + (1 * 4) + (1 * 8) + (0 * 16) + (1 * 32) + (0 * 64) + (1 * 128),
+               (0 * 1) + (0 * 2) + (1 * 4) + (1 * 8) + (1 * 16) + (0 * 32) + (0 * 64) + (0 * 128),
+               (1 * 1) + (0 * 2) + (0 * 4) + (0 * 8) + (0 * 16) + (0 * 32) + (0 * 64) + (1 * 128),
+               (0 * 1) + (1 * 2) + (0 * 4) + (1 * 8) + (0 * 16) + (0 * 32) + (0 * 64) + (0 * 128),
+               (0 * 1) + (0 * 2) + (0 * 4) + (1 * 8) + (0 * 16) + (1 * 32) + (0 * 64) + (0 * 128),
+               (0 * 1) + (1 * 2) + (1 * 4) + (1 * 8) + (1 * 16) + (0 * 32) + (1 * 64) + (1 * 128),
+               (0 * 1) + (0 * 2) + (1 * 4) + (0 * 8) + (1 * 16) + (0 * 32) + (1 * 64) + (1 * 128),
+               (1 * 1) + (1 * 2) + (0 * 4) + (1 * 8) + (0 * 16) + (1 * 32) + (0 * 64) + (1 * 128),
+               (1 * 1) + (1 * 2) + (1 * 4) + (1 * 8) + (0 * 16) + (1 * 32) + (0 * 64) + (1 * 128),
+               (0 * 1) + (1 * 2) + (1 * 4) + (0 * 8) + (1 * 16) + (0 * 32) + (1 * 64) + (0 * 128),
+               (0 * 1) + (1 * 2) + (0 * 4) + (0 * 8) + (1 * 16) + (1 * 32) + (0 * 64) + (1 * 128),
+               (0 * 1) + (0 * 2) + (0 * 4) + (0 * 8) + (1 * 16) + (0 * 32) + (0 * 64) + (0 * 128),
+               (1 * 1) + (0 * 2) + (1 * 4) + (1 * 8) + (0 * 16) + (1 * 32) + (1 * 64) + (0 * 128),
+               (0 * 1) + (1 * 2) + (1 * 4) + (0 * 8) + (0 * 16) + (0 * 32) + (0 * 64) + (0 * 128),
+               (1 * 1) + (1 * 2) + (0 * 4) + (1 * 8) + (0 * 16) + (0 * 32) + (1 * 64) + (1 * 128),
+               (0 * 1) + (0 * 2) + (0 * 4) + (1 * 8) + (1 * 16) + (1 * 32) + (1 * 64) + (0 * 128),
+               (0 * 1) + (0 * 2) + (0 * 4) + (0 * 8) + (1 * 16) + (1 * 32) + (0 * 64) + (1 * 128)},
+               "abcdefghij"},
+       {[32]byte{(1 * 1) + (0 * 2) + (0 * 4) + (0 * 8) + (0 * 16) + (1 * 32) + (0 * 64) + (1 * 128),
+               (0 * 1) + (0 * 2) + (1 * 4) + (0 * 8) + (0 * 16) + (0 * 32) + (1 * 64) + (0 * 128),
+               (0 * 1) + (1 * 2) + (1 * 4) + (0 * 8) + (0 * 16) + (0 * 32) + (0 * 64) + (0 * 128),
+               (0 * 1) + (0 * 2) + (1 * 4) + (1 * 8) + (1 * 16) + (0 * 32) + (0 * 64) + (0 * 128),
+               (1 * 1) + (1 * 2) + (1 * 4) + (0 * 8) + (0 * 16) + (1 * 32) + (0 * 64) + (0 * 128),
+               (1 * 1) + (1 * 2) + (1 * 4) + (1 * 8) + (1 * 16) + (0 * 32) + (0 * 64) + (0 * 128),
+               (1 * 1) + (0 * 2) + (1 * 4) + (0 * 8) + (1 * 16) + (0 * 32) + (0 * 64) + (0 * 128),
+               (1 * 1) + (0 * 2) + (1 * 4) + (1 * 8) + (0 * 16) + (1 * 32) + (0 * 64) + (0 * 128),
+               (0 * 1) + (0 * 2) + (1 * 4) + (0 * 8) + (0 * 16) + (1 * 32) + (0 * 64) + (1 * 128),
+               (1 * 1) + (0 * 2) + (0 * 4) + (0 * 8) + (1 * 16) + (0 * 32) + (1 * 64) + (1 * 128),
+               (1 * 1) + (0 * 2) + (0 * 4) + (0 * 8) + (1 * 16) + (0 * 32) + (1 * 64) + (0 * 128),
+               (1 * 1) + (1 * 2) + (0 * 4) + (0 * 8) + (0 * 16) + (0 * 32) + (0 * 64) + (0 * 128),
+               (1 * 1) + (0 * 2) + (1 * 4) + (0 * 8) + (0 * 16) + (0 * 32) + (1 * 64) + (0 * 128),
+               (0 * 1) + (0 * 2) + (0 * 4) + (1 * 8) + (0 * 16) + (0 * 32) + (0 * 64) + (0 * 128),
+               (0 * 1) + (1 * 2) + (1 * 4) + (1 * 8) + (1 * 16) + (1 * 32) + (1 * 64) + (1 * 128),
+               (1 * 1) + (0 * 2) + (0 * 4) + (0 * 8) + (1 * 16) + (0 * 32) + (1 * 64) + (1 * 128),
+               (1 * 1) + (0 * 2) + (0 * 4) + (0 * 8) + (0 * 16) + (0 * 32) + (1 * 64) + (1 * 128),
+               (0 * 1) + (0 * 2) + (0 * 4) + (1 * 8) + (1 * 16) + (1 * 32) + (0 * 64) + (0 * 128),
+               (0 * 1) + (0 * 2) + (0 * 4) + (1 * 8) + (1 * 16) + (1 * 32) + (0 * 64) + (1 * 128),
+               (1 * 1) + (0 * 2) + (0 * 4) + (1 * 8) + (0 * 16) + (0 * 32) + (1 * 64) + (1 * 128),
+               (0 * 1) + (1 * 2) + (1 * 4) + (0 * 8) + (1 * 16) + (1 * 32) + (1 * 64) + (0 * 128),
+               (1 * 1) + (1 * 2) + (0 * 4) + (0 * 8) + (1 * 16) + (1 * 32) + (0 * 64) + (0 * 128),
+               (1 * 1) + (0 * 2) + (1 * 4) + (1 * 8) + (1 * 16) + (0 * 32) + (0 * 64) + (1 * 128),
+               (0 * 1) + (1 * 2) + (0 * 4) + (0 * 8) + (0 * 16) + (1 * 32) + (1 * 64) + (1 * 128),
+               (1 * 1) + (0 * 2) + (0 * 4) + (1 * 8) + (0 * 16) + (1 * 32) + (0 * 64) + (0 * 128),
+               (1 * 1) + (1 * 2) + (0 * 4) + (0 * 8) + (0 * 16) + (0 * 32) + (1 * 64) + (1 * 128),
+               (1 * 1) + (1 * 2) + (0 * 4) + (1 * 8) + (1 * 16) + (1 * 32) + (0 * 64) + (1 * 128),
+               (1 * 1) + (0 * 2) + (1 * 4) + (1 * 8) + (0 * 16) + (1 * 32) + (1 * 64) + (0 * 128),
+               (1 * 1) + (1 * 2) + (0 * 4) + (1 * 8) + (0 * 16) + (0 * 32) + (1 * 64) + (0 * 128),
+               (1 * 1) + (1 * 2) + (0 * 4) + (1 * 8) + (1 * 16) + (1 * 32) + (0 * 64) + (1 * 128),
+               (1 * 1) + (1 * 2) + (1 * 4) + (1 * 8) + (0 * 16) + (0 * 32) + (1 * 64) + (0 * 128),
+               (0 * 1) + (1 * 2) + (1 * 4) + (1 * 8) + (0 * 16) + (0 * 32) + (1 * 64) + (1 * 128)},
+               "Discard medicine more than two years old."},
+       {[32]byte{(1 * 1) + (0 * 2) + (1 * 4) + (1 * 8) + (0 * 16) + (1 * 32) + (1 * 64) + (0 * 128),
+               (0 * 1) + (1 * 2) + (1 * 4) + (1 * 8) + (0 * 16) + (1 * 32) + (0 * 64) + (1 * 128),
+               (0 * 1) + (0 * 2) + (1 * 4) + (1 * 8) + (1 * 16) + (0 * 32) + (1 * 64) + (0 * 128),
+               (0 * 1) + (1 * 2) + (0 * 4) + (1 * 8) + (0 * 16) + (1 * 32) + (0 * 64) + (1 * 128),
+               (1 * 1) + (0 * 2) + (0 * 4) + (0 * 8) + (1 * 16) + (1 * 32) + (1 * 64) + (0 * 128),
+               (0 * 1) + (1 * 2) + (0 * 4) + (1 * 8) + (1 * 16) + (1 * 32) + (0 * 64) + (0 * 128),
+               (0 * 1) + (0 * 2) + (0 * 4) + (0 * 8) + (1 * 16) + (0 * 32) + (0 * 64) + (0 * 128),
+               (1 * 1) + (0 * 2) + (1 * 4) + (1 * 8) + (0 * 16) + (1 * 32) + (0 * 64) + (1 * 128),
+               (0 * 1) + (0 * 2) + (1 * 4) + (0 * 8) + (0 * 16) + (0 * 32) + (0 * 64) + (0 * 128),
+               (0 * 1) + (0 * 2) + (1 * 4) + (0 * 8) + (1 * 16) + (1 * 32) + (0 * 64) + (1 * 128),
+               (0 * 1) + (0 * 2) + (0 * 4) + (0 * 8) + (0 * 16) + (1 * 32) + (1 * 64) + (0 * 128),
+               (0 * 1) + (0 * 2) + (0 * 4) + (1 * 8) + (0 * 16) + (1 * 32) + (0 * 64) + (0 * 128),
+               (1 * 1) + (1 * 2) + (1 * 4) + (1 * 8) + (1 * 16) + (1 * 32) + (0 * 64) + (1 * 128),
+               (1 * 1) + (0 * 2) + (1 * 4) + (1 * 8) + (0 * 16) + (1 * 32) + (1 * 64) + (0 * 128),
+               (1 * 1) + (0 * 2) + (1 * 4) + (1 * 8) + (0 * 16) + (1 * 32) + (0 * 64) + (1 * 128),
+               (0 * 1) + (0 * 2) + (0 * 4) + (1 * 8) + (0 * 16) + (1 * 32) + (1 * 64) + (0 * 128),
+               (1 * 1) + (1 * 2) + (0 * 4) + (0 * 8) + (0 * 16) + (0 * 32) + (0 * 64) + (1 * 128),
+               (0 * 1) + (0 * 2) + (1 * 4) + (1 * 8) + (1 * 16) + (1 * 32) + (1 * 64) + (0 * 128),
+               (0 * 1) + (0 * 2) + (0 * 4) + (1 * 8) + (1 * 16) + (0 * 32) + (1 * 64) + (0 * 128),
+               (0 * 1) + (1 * 2) + (1 * 4) + (0 * 8) + (1 * 16) + (0 * 32) + (0 * 64) + (0 * 128),
+               (0 * 1) + (1 * 2) + (1 * 4) + (0 * 8) + (1 * 16) + (0 * 32) + (0 * 64) + (0 * 128),
+               (1 * 1) + (0 * 2) + (0 * 4) + (0 * 8) + (0 * 16) + (1 * 32) + (0 * 64) + (1 * 128),
+               (0 * 1) + (0 * 2) + (0 * 4) + (1 * 8) + (1 * 16) + (0 * 32) + (1 * 64) + (0 * 128),
+               (0 * 1) + (1 * 2) + (0 * 4) + (1 * 8) + (1 * 16) + (0 * 32) + (0 * 64) + (1 * 128),
+               (0 * 1) + (1 * 2) + (1 * 4) + (0 * 8) + (0 * 16) + (1 * 32) + (0 * 64) + (0 * 128),
+               (0 * 1) + (1 * 2) + (0 * 4) + (1 * 8) + (1 * 16) + (0 * 32) + (1 * 64) + (0 * 128),
+               (1 * 1) + (0 * 2) + (0 * 4) + (0 * 8) + (1 * 16) + (0 * 32) + (0 * 64) + (0 * 128),
+               (0 * 1) + (0 * 2) + (0 * 4) + (1 * 8) + (0 * 16) + (1 * 32) + (0 * 64) + (0 * 128),
+               (1 * 1) + (0 * 2) + (1 * 4) + (1 * 8) + (0 * 16) + (0 * 32) + (0 * 64) + (1 * 128),
+               (1 * 1) + (1 * 2) + (0 * 4) + (1 * 8) + (0 * 16) + (0 * 32) + (1 * 64) + (0 * 128),
+               (1 * 1) + (0 * 2) + (1 * 4) + (0 * 8) + (1 * 16) + (1 * 32) + (0 * 64) + (1 * 128),
+               (0 * 1) + (0 * 2) + (1 * 4) + (0 * 8) + (0 * 16) + (0 * 32) + (1 * 64) + (1 * 128)},
+               "He who has a shady past knows that nice guys finish last."},
+       {[32]byte{(0 * 1) + (1 * 2) + (1 * 4) + (1 * 8) + (0 * 16) + (1 * 32) + (0 * 64) + (1 * 128),
+               (0 * 1) + (1 * 2) + (0 * 4) + (1 * 8) + (1 * 16) + (1 * 32) + (1 * 64) + (0 * 128),
+               (0 * 1) + (0 * 2) + (0 * 4) + (0 * 8) + (1 * 16) + (1 * 32) + (1 * 64) + (0 * 128),
+               (0 * 1) + (1 * 2) + (0 * 4) + (1 * 8) + (0 * 16) + (1 * 32) + (0 * 64) + (0 * 128),
+               (1 * 1) + (0 * 2) + (1 * 4) + (0 * 8) + (1 * 16) + (0 * 32) + (0 * 64) + (1 * 128),
+               (1 * 1) + (0 * 2) + (0 * 4) + (1 * 8) + (0 * 16) + (0 * 32) + (0 * 64) + (0 * 128),
+               (1 * 1) + (1 * 2) + (0 * 4) + (0 * 8) + (0 * 16) + (0 * 32) + (0 * 64) + (0 * 128),
+               (1 * 1) + (0 * 2) + (1 * 4) + (1 * 8) + (1 * 16) + (0 * 32) + (0 * 64) + (1 * 128),
+               (1 * 1) + (1 * 2) + (0 * 4) + (1 * 8) + (1 * 16) + (0 * 32) + (1 * 64) + (1 * 128),
+               (0 * 1) + (1 * 2) + (0 * 4) + (0 * 8) + (1 * 16) + (1 * 32) + (1 * 64) + (1 * 128),
+               (1 * 1) + (1 * 2) + (1 * 4) + (1 * 8) + (1 * 16) + (0 * 32) + (0 * 64) + (1 * 128),
+               (1 * 1) + (1 * 2) + (1 * 4) + (0 * 8) + (0 * 16) + (0 * 32) + (0 * 64) + (0 * 128),
+               (1 * 1) + (0 * 2) + (1 * 4) + (0 * 8) + (0 * 16) + (1 * 32) + (1 * 64) + (0 * 128),
+               (1 * 1) + (1 * 2) + (1 * 4) + (0 * 8) + (0 * 16) + (1 * 32) + (1 * 64) + (1 * 128),
+               (1 * 1) + (0 * 2) + (1 * 4) + (1 * 8) + (0 * 16) + (0 * 32) + (0 * 64) + (0 * 128),
+               (0 * 1) + (0 * 2) + (0 * 4) + (0 * 8) + (0 * 16) + (0 * 32) + (0 * 64) + (0 * 128),
+               (1 * 1) + (0 * 2) + (0 * 4) + (0 * 8) + (0 * 16) + (0 * 32) + (0 * 64) + (0 * 128),
+               (1 * 1) + (1 * 2) + (1 * 4) + (0 * 8) + (1 * 16) + (0 * 32) + (0 * 64) + (0 * 128),
+               (1 * 1) + (0 * 2) + (0 * 4) + (1 * 8) + (1 * 16) + (1 * 32) + (1 * 64) + (0 * 128),
+               (0 * 1) + (0 * 2) + (1 * 4) + (0 * 8) + (1 * 16) + (0 * 32) + (0 * 64) + (0 * 128),
+               (0 * 1) + (0 * 2) + (0 * 4) + (1 * 8) + (1 * 16) + (1 * 32) + (0 * 64) + (1 * 128),
+               (0 * 1) + (0 * 2) + (1 * 4) + (0 * 8) + (0 * 16) + (1 * 32) + (1 * 64) + (0 * 128),
+               (1 * 1) + (0 * 2) + (0 * 4) + (1 * 8) + (1 * 16) + (0 * 32) + (1 * 64) + (0 * 128),
+               (0 * 1) + (0 * 2) + (0 * 4) + (1 * 8) + (0 * 16) + (1 * 32) + (0 * 64) + (0 * 128),
+               (1 * 1) + (0 * 2) + (1 * 4) + (1 * 8) + (0 * 16) + (0 * 32) + (1 * 64) + (0 * 128),
+               (1 * 1) + (1 * 2) + (0 * 4) + (1 * 8) + (0 * 16) + (1 * 32) + (0 * 64) + (1 * 128),
+               (1 * 1) + (1 * 2) + (0 * 4) + (1 * 8) + (0 * 16) + (0 * 32) + (0 * 64) + (1 * 128),
+               (0 * 1) + (0 * 2) + (1 * 4) + (0 * 8) + (1 * 16) + (1 * 32) + (0 * 64) + (0 * 128),
+               (0 * 1) + (0 * 2) + (1 * 4) + (1 * 8) + (0 * 16) + (0 * 32) + (0 * 64) + (1 * 128),
+               (1 * 1) + (0 * 2) + (1 * 4) + (1 * 8) + (0 * 16) + (1 * 32) + (0 * 64) + (0 * 128),
+               (0 * 1) + (1 * 2) + (1 * 4) + (1 * 8) + (0 * 16) + (0 * 32) + (1 * 64) + (1 * 128),
+               (1 * 1) + (1 * 2) + (1 * 4) + (1 * 8) + (1 * 16) + (1 * 32) + (0 * 64) + (0 * 128)},
+               "I wouldn't marry him with a ten foot pole."},
+       {[32]byte{(1 * 1) + (1 * 2) + (1 * 4) + (0 * 8) + (0 * 16) + (1 * 32) + (1 * 64) + (0 * 128),
+               (0 * 1) + (0 * 2) + (0 * 4) + (1 * 8) + (0 * 16) + (0 * 32) + (1 * 64) + (0 * 128),
+               (1 * 1) + (0 * 2) + (1 * 4) + (0 * 8) + (0 * 16) + (0 * 32) + (1 * 64) + (0 * 128),
+               (1 * 1) + (1 * 2) + (0 * 4) + (1 * 8) + (0 * 16) + (0 * 32) + (0 * 64) + (0 * 128),
+               (1 * 1) + (0 * 2) + (0 * 4) + (0 * 8) + (0 * 16) + (0 * 32) + (0 * 64) + (0 * 128),
+               (1 * 1) + (0 * 2) + (1 * 4) + (0 * 8) + (0 * 16) + (0 * 32) + (1 * 64) + (1 * 128),
+               (0 * 1) + (0 * 2) + (0 * 4) + (1 * 8) + (0 * 16) + (1 * 32) + (1 * 64) + (0 * 128),
+               (0 * 1) + (0 * 2) + (0 * 4) + (1 * 8) + (1 * 16) + (0 * 32) + (1 * 64) + (0 * 128),
+               (1 * 1) + (1 * 2) + (1 * 4) + (0 * 8) + (0 * 16) + (1 * 32) + (1 * 64) + (0 * 128),
+               (1 * 1) + (0 * 2) + (1 * 4) + (0 * 8) + (1 * 16) + (0 * 32) + (0 * 64) + (0 * 128),
+               (1 * 1) + (0 * 2) + (0 * 4) + (1 * 8) + (0 * 16) + (1 * 32) + (0 * 64) + (0 * 128),
+               (1 * 1) + (0 * 2) + (1 * 4) + (1 * 8) + (1 * 16) + (0 * 32) + (0 * 64) + (0 * 128),
+               (0 * 1) + (1 * 2) + (0 * 4) + (1 * 8) + (1 * 16) + (1 * 32) + (1 * 64) + (1 * 128),
+               (0 * 1) + (1 * 2) + (1 * 4) + (1 * 8) + (1 * 16) + (1 * 32) + (0 * 64) + (0 * 128),
+               (0 * 1) + (0 * 2) + (0 * 4) + (0 * 8) + (0 * 16) + (1 * 32) + (1 * 64) + (1 * 128),
+               (0 * 1) + (0 * 2) + (0 * 4) + (1 * 8) + (1 * 16) + (0 * 32) + (0 * 64) + (0 * 128),
+               (0 * 1) + (1 * 2) + (0 * 4) + (1 * 8) + (1 * 16) + (0 * 32) + (1 * 64) + (1 * 128),
+               (1 * 1) + (1 * 2) + (1 * 4) + (0 * 8) + (0 * 16) + (0 * 32) + (0 * 64) + (0 * 128),
+               (1 * 1) + (1 * 2) + (0 * 4) + (0 * 8) + (1 * 16) + (0 * 32) + (1 * 64) + (1 * 128),
+               (1 * 1) + (1 * 2) + (0 * 4) + (1 * 8) + (0 * 16) + (1 * 32) + (1 * 64) + (0 * 128),
+               (1 * 1) + (1 * 2) + (1 * 4) + (0 * 8) + (1 * 16) + (1 * 32) + (0 * 64) + (1 * 128),
+               (0 * 1) + (1 * 2) + (0 * 4) + (1 * 8) + (0 * 16) + (1 * 32) + (1 * 64) + (1 * 128),
+               (1 * 1) + (1 * 2) + (1 * 4) + (1 * 8) + (0 * 16) + (1 * 32) + (1 * 64) + (0 * 128),
+               (0 * 1) + (0 * 2) + (0 * 4) + (1 * 8) + (1 * 16) + (0 * 32) + (0 * 64) + (0 * 128),
+               (0 * 1) + (0 * 2) + (1 * 4) + (1 * 8) + (0 * 16) + (0 * 32) + (0 * 64) + (0 * 128),
+               (0 * 1) + (1 * 2) + (0 * 4) + (1 * 8) + (1 * 16) + (0 * 32) + (0 * 64) + (0 * 128),
+               (0 * 1) + (1 * 2) + (1 * 4) + (0 * 8) + (1 * 16) + (1 * 32) + (1 * 64) + (1 * 128),
+               (1 * 1) + (1 * 2) + (1 * 4) + (0 * 8) + (0 * 16) + (1 * 32) + (0 * 64) + (0 * 128),
+               (0 * 1) + (1 * 2) + (0 * 4) + (0 * 8) + (0 * 16) + (0 * 32) + (0 * 64) + (0 * 128),
+               (1 * 1) + (0 * 2) + (1 * 4) + (0 * 8) + (1 * 16) + (0 * 32) + (0 * 64) + (0 * 128),
+               (0 * 1) + (1 * 2) + (1 * 4) + (0 * 8) + (0 * 16) + (0 * 32) + (1 * 64) + (1 * 128),
+               (1 * 1) + (1 * 2) + (1 * 4) + (1 * 8) + (0 * 16) + (0 * 32) + (1 * 64) + (0 * 128)},
+               "Free! Free!/A trip/to Mars/for 900/empty jars/Burma Shave"},
+       {[32]byte{(0 * 1) + (0 * 2) + (1 * 4) + (0 * 8) + (1 * 16) + (0 * 32) + (0 * 64) + (0 * 128),
+               (0 * 1) + (0 * 2) + (0 * 4) + (1 * 8) + (1 * 16) + (1 * 32) + (0 * 64) + (1 * 128),
+               (0 * 1) + (0 * 2) + (0 * 4) + (0 * 8) + (0 * 16) + (1 * 32) + (0 * 64) + (0 * 128),
+               (0 * 1) + (0 * 2) + (1 * 4) + (0 * 8) + (1 * 16) + (0 * 32) + (0 * 64) + (0 * 128),
+               (1 * 1) + (0 * 2) + (1 * 4) + (1 * 8) + (0 * 16) + (1 * 32) + (0 * 64) + (1 * 128),
+               (1 * 1) + (1 * 2) + (0 * 4) + (1 * 8) + (0 * 16) + (1 * 32) + (0 * 64) + (0 * 128),
+               (1 * 1) + (0 * 2) + (0 * 4) + (0 * 8) + (1 * 16) + (0 * 32) + (0 * 64) + (0 * 128),
+               (0 * 1) + (1 * 2) + (1 * 4) + (0 * 8) + (1 * 16) + (1 * 32) + (1 * 64) + (1 * 128),
+               (1 * 1) + (0 * 2) + (0 * 4) + (0 * 8) + (0 * 16) + (1 * 32) + (1 * 64) + (0 * 128),
+               (1 * 1) + (0 * 2) + (1 * 4) + (0 * 8) + (1 * 16) + (1 * 32) + (0 * 64) + (1 * 128),
+               (0 * 1) + (1 * 2) + (1 * 4) + (1 * 8) + (0 * 16) + (1 * 32) + (0 * 64) + (1 * 128),
+               (0 * 1) + (1 * 2) + (0 * 4) + (1 * 8) + (0 * 16) + (1 * 32) + (1 * 64) + (0 * 128),
+               (1 * 1) + (0 * 2) + (0 * 4) + (1 * 8) + (1 * 16) + (0 * 32) + (0 * 64) + (1 * 128),
+               (1 * 1) + (1 * 2) + (1 * 4) + (0 * 8) + (1 * 16) + (1 * 32) + (0 * 64) + (1 * 128),
+               (1 * 1) + (0 * 2) + (0 * 4) + (0 * 8) + (1 * 16) + (0 * 32) + (1 * 64) + (0 * 128),
+               (1 * 1) + (0 * 2) + (1 * 4) + (0 * 8) + (0 * 16) + (0 * 32) + (0 * 64) + (0 * 128),
+               (0 * 1) + (1 * 2) + (0 * 4) + (0 * 8) + (0 * 16) + (0 * 32) + (1 * 64) + (1 * 128),
+               (1 * 1) + (1 * 2) + (1 * 4) + (1 * 8) + (1 * 16) + (1 * 32) + (1 * 64) + (1 * 128),
+               (0 * 1) + (0 * 2) + (1 * 4) + (1 * 8) + (0 * 16) + (1 * 32) + (0 * 64) + (1 * 128),
+               (1 * 1) + (1 * 2) + (1 * 4) + (0 * 8) + (0 * 16) + (1 * 32) + (0 * 64) + (0 * 128),
+               (0 * 1) + (0 * 2) + (1 * 4) + (1 * 8) + (0 * 16) + (0 * 32) + (0 * 64) + (1 * 128),
+               (0 * 1) + (0 * 2) + (0 * 4) + (0 * 8) + (1 * 16) + (0 * 32) + (1 * 64) + (1 * 128),
+               (1 * 1) + (0 * 2) + (0 * 4) + (0 * 8) + (1 * 16) + (1 * 32) + (1 * 64) + (0 * 128),
+               (1 * 1) + (0 * 2) + (1 * 4) + (1 * 8) + (0 * 16) + (0 * 32) + (1 * 64) + (1 * 128),
+               (0 * 1) + (0 * 2) + (1 * 4) + (1 * 8) + (0 * 16) + (1 * 32) + (1 * 64) + (0 * 128),
+               (1 * 1) + (0 * 2) + (1 * 4) + (0 * 8) + (0 * 16) + (0 * 32) + (0 * 64) + (0 * 128),
+               (1 * 1) + (1 * 2) + (0 * 4) + (0 * 8) + (0 * 16) + (0 * 32) + (0 * 64) + (1 * 128),
+               (1 * 1) + (1 * 2) + (1 * 4) + (0 * 8) + (0 * 16) + (1 * 32) + (0 * 64) + (0 * 128),
+               (1 * 1) + (1 * 2) + (0 * 4) + (0 * 8) + (1 * 16) + (0 * 32) + (0 * 64) + (1 * 128),
+               (1 * 1) + (1 * 2) + (0 * 4) + (0 * 8) + (0 * 16) + (1 * 32) + (1 * 64) + (0 * 128),
+               (1 * 1) + (1 * 2) + (1 * 4) + (0 * 8) + (1 * 16) + (0 * 32) + (1 * 64) + (0 * 128),
+               (0 * 1) + (0 * 2) + (1 * 4) + (0 * 8) + (1 * 16) + (1 * 32) + (1 * 64) + (0 * 128)},
+               "The days of the digital watch are numbered.  -Tom Stoppard"},
+       {[32]byte{(1 * 1) + (0 * 2) + (0 * 4) + (0 * 8) + (1 * 16) + (1 * 32) + (1 * 64) + (0 * 128),
+               (0 * 1) + (1 * 2) + (0 * 4) + (0 * 8) + (0 * 16) + (0 * 32) + (0 * 64) + (0 * 128),
+               (1 * 1) + (1 * 2) + (1 * 4) + (1 * 8) + (0 * 16) + (0 * 32) + (1 * 64) + (1 * 128),
+               (1 * 1) + (1 * 2) + (1 * 4) + (0 * 8) + (1 * 16) + (0 * 32) + (1 * 64) + (1 * 128),
+               (0 * 1) + (1 * 2) + (1 * 4) + (1 * 8) + (0 * 16) + (1 * 32) + (1 * 64) + (0 * 128),
+               (0 * 1) + (1 * 2) + (1 * 4) + (1 * 8) + (0 * 16) + (1 * 32) + (0 * 64) + (0 * 128),
+               (0 * 1) + (1 * 2) + (0 * 4) + (0 * 8) + (1 * 16) + (1 * 32) + (0 * 64) + (0 * 128),
+               (0 * 1) + (0 * 2) + (0 * 4) + (1 * 8) + (0 * 16) + (0 * 32) + (1 * 64) + (0 * 128),
+               (1 * 1) + (0 * 2) + (0 * 4) + (1 * 8) + (0 * 16) + (0 * 32) + (0 * 64) + (1 * 128),
+               (0 * 1) + (1 * 2) + (1 * 4) + (1 * 8) + (0 * 16) + (1 * 32) + (1 * 64) + (1 * 128),
+               (0 * 1) + (1 * 2) + (1 * 4) + (1 * 8) + (0 * 16) + (0 * 32) + (1 * 64) + (1 * 128),
+               (1 * 1) + (0 * 2) + (1 * 4) + (1 * 8) + (1 * 16) + (0 * 32) + (1 * 64) + (0 * 128),
+               (0 * 1) + (0 * 2) + (1 * 4) + (1 * 8) + (0 * 16) + (1 * 32) + (1 * 64) + (0 * 128),
+               (1 * 1) + (0 * 2) + (0 * 4) + (0 * 8) + (0 * 16) + (0 * 32) + (1 * 64) + (0 * 128),
+               (0 * 1) + (1 * 2) + (0 * 4) + (0 * 8) + (1 * 16) + (0 * 32) + (0 * 64) + (1 * 128),
+               (1 * 1) + (1 * 2) + (0 * 4) + (1 * 8) + (1 * 16) + (0 * 32) + (0 * 64) + (0 * 128),
+               (0 * 1) + (1 * 2) + (1 * 4) + (1 * 8) + (1 * 16) + (0 * 32) + (0 * 64) + (0 * 128),
+               (0 * 1) + (0 * 2) + (1 * 4) + (0 * 8) + (1 * 16) + (0 * 32) + (0 * 64) + (0 * 128),
+               (0 * 1) + (1 * 2) + (0 * 4) + (1 * 8) + (0 * 16) + (1 * 32) + (0 * 64) + (0 * 128),
+               (0 * 1) + (1 * 2) + (0 * 4) + (1 * 8) + (0 * 16) + (0 * 32) + (1 * 64) + (0 * 128),
+               (1 * 1) + (0 * 2) + (1 * 4) + (0 * 8) + (0 * 16) + (0 * 32) + (1 * 64) + (1 * 128),
+               (0 * 1) + (1 * 2) + (0 * 4) + (0 * 8) + (0 * 16) + (1 * 32) + (0 * 64) + (1 * 128),
+               (1 * 1) + (0 * 2) + (0 * 4) + (1 * 8) + (0 * 16) + (1 * 32) + (1 * 64) + (0 * 128),
+               (1 * 1) + (1 * 2) + (0 * 4) + (1 * 8) + (0 * 16) + (1 * 32) + (0 * 64) + (0 * 128),
+               (1 * 1) + (1 * 2) + (1 * 4) + (0 * 8) + (0 * 16) + (1 * 32) + (1 * 64) + (1 * 128),
+               (0 * 1) + (0 * 2) + (0 * 4) + (1 * 8) + (0 * 16) + (0 * 32) + (0 * 64) + (1 * 128),
+               (1 * 1) + (1 * 2) + (0 * 4) + (0 * 8) + (0 * 16) + (0 * 32) + (0 * 64) + (0 * 128),
+               (1 * 1) + (0 * 2) + (0 * 4) + (1 * 8) + (0 * 16) + (0 * 32) + (0 * 64) + (0 * 128),
+               (1 * 1) + (1 * 2) + (1 * 4) + (1 * 8) + (1 * 16) + (1 * 32) + (1 * 64) + (0 * 128),
+               (0 * 1) + (1 * 2) + (0 * 4) + (1 * 8) + (0 * 16) + (1 * 32) + (1 * 64) + (0 * 128),
+               (0 * 1) + (0 * 2) + (0 * 4) + (1 * 8) + (0 * 16) + (0 * 32) + (1 * 64) + (0 * 128),
+               (0 * 1) + (0 * 2) + (0 * 4) + (1 * 8) + (1 * 16) + (0 * 32) + (1 * 64) + (1 * 128)},
+               "Nepal premier won't resign."},
+       {[32]byte{(1 * 1) + (1 * 2) + (0 * 4) + (0 * 8) + (0 * 16) + (1 * 32) + (0 * 64) + (0 * 128),
+               (1 * 1) + (0 * 2) + (0 * 4) + (0 * 8) + (1 * 16) + (1 * 32) + (0 * 64) + (1 * 128),
+               (1 * 1) + (0 * 2) + (0 * 4) + (0 * 8) + (0 * 16) + (0 * 32) + (0 * 64) + (0 * 128),
+               (0 * 1) + (0 * 2) + (1 * 4) + (1 * 8) + (0 * 16) + (0 * 32) + (0 * 64) + (1 * 128),
+               (0 * 1) + (0 * 2) + (0 * 4) + (1 * 8) + (1 * 16) + (0 * 32) + (1 * 64) + (1 * 128),
+               (1 * 1) + (0 * 2) + (1 * 4) + (1 * 8) + (1 * 16) + (0 * 32) + (0 * 64) + (0 * 128),
+               (1 * 1) + (0 * 2) + (0 * 4) + (0 * 8) + (1 * 16) + (1 * 32) + (0 * 64) + (1 * 128),
+               (0 * 1) + (1 * 2) + (1 * 4) + (0 * 8) + (1 * 16) + (0 * 32) + (1 * 64) + (1 * 128),
+               (1 * 1) + (0 * 2) + (0 * 4) + (1 * 8) + (1 * 16) + (1 * 32) + (1 * 64) + (0 * 128),
+               (1 * 1) + (1 * 2) + (0 * 4) + (0 * 8) + (0 * 16) + (0 * 32) + (0 * 64) + (1 * 128),
+               (1 * 1) + (0 * 2) + (1 * 4) + (0 * 8) + (0 * 16) + (0 * 32) + (1 * 64) + (1 * 128),
+               (1 * 1) + (1 * 2) + (1 * 4) + (0 * 8) + (1 * 16) + (1 * 32) + (1 * 64) + (1 * 128),
+               (1 * 1) + (0 * 2) + (0 * 4) + (0 * 8) + (0 * 16) + (0 * 32) + (1 * 64) + (0 * 128),
+               (0 * 1) + (0 * 2) + (1 * 4) + (1 * 8) + (1 * 16) + (1 * 32) + (1 * 64) + (0 * 128),
+               (0 * 1) + (0 * 2) + (1 * 4) + (0 * 8) + (0 * 16) + (0 * 32) + (1 * 64) + (0 * 128),
+               (0 * 1) + (1 * 2) + (0 * 4) + (1 * 8) + (1 * 16) + (0 * 32) + (1 * 64) + (1 * 128),
+               (1 * 1) + (0 * 2) + (1 * 4) + (1 * 8) + (1 * 16) + (0 * 32) + (0 * 64) + (1 * 128),
+               (1 * 1) + (1 * 2) + (0 * 4) + (1 * 8) + (0 * 16) + (1 * 32) + (1 * 64) + (1 * 128),
+               (0 * 1) + (0 * 2) + (0 * 4) + (1 * 8) + (1 * 16) + (0 * 32) + (1 * 64) + (0 * 128),
+               (0 * 1) + (0 * 2) + (1 * 4) + (0 * 8) + (0 * 16) + (1 * 32) + (0 * 64) + (0 * 128),
+               (1 * 1) + (0 * 2) + (0 * 4) + (1 * 8) + (1 * 16) + (0 * 32) + (1 * 64) + (0 * 128),
+               (1 * 1) + (1 * 2) + (0 * 4) + (0 * 8) + (0 * 16) + (1 * 32) + (1 * 64) + (1 * 128),
+               (0 * 1) + (0 * 2) + (0 * 4) + (1 * 8) + (1 * 16) + (1 * 32) + (1 * 64) + (0 * 128),
+               (1 * 1) + (1 * 2) + (1 * 4) + (0 * 8) + (1 * 16) + (0 * 32) + (1 * 64) + (1 * 128),
+               (0 * 1) + (0 * 2) + (0 * 4) + (0 * 8) + (0 * 16) + (1 * 32) + (0 * 64) + (1 * 128),
+               (0 * 1) + (0 * 2) + (0 * 4) + (1 * 8) + (0 * 16) + (1 * 32) + (1 * 64) + (0 * 128),
+               (1 * 1) + (0 * 2) + (1 * 4) + (0 * 8) + (1 * 16) + (0 * 32) + (1 * 64) + (0 * 128),
+               (0 * 1) + (1 * 2) + (1 * 4) + (1 * 8) + (0 * 16) + (1 * 32) + (0 * 64) + (0 * 128),
+               (0 * 1) + (1 * 2) + (1 * 4) + (0 * 8) + (0 * 16) + (1 * 32) + (0 * 64) + (1 * 128),
+               (1 * 1) + (0 * 2) + (0 * 4) + (1 * 8) + (0 * 16) + (0 * 32) + (1 * 64) + (0 * 128),
+               (0 * 1) + (0 * 2) + (1 * 4) + (1 * 8) + (1 * 16) + (0 * 32) + (1 * 64) + (1 * 128),
+               (1 * 1) + (1 * 2) + (1 * 4) + (1 * 8) + (1 * 16) + (0 * 32) + (0 * 64) + (1 * 128)},
+               "For every action there is an equal and opposite government program."},
+       {[32]byte{(0 * 1) + (0 * 2) + (0 * 4) + (0 * 8) + (0 * 16) + (0 * 32) + (0 * 64) + (1 * 128),
+               (1 * 1) + (0 * 2) + (0 * 4) + (0 * 8) + (0 * 16) + (0 * 32) + (0 * 64) + (0 * 128),
+               (1 * 1) + (0 * 2) + (0 * 4) + (0 * 8) + (1 * 16) + (1 * 32) + (1 * 64) + (1 * 128),
+               (0 * 1) + (0 * 2) + (0 * 4) + (0 * 8) + (1 * 16) + (0 * 32) + (0 * 64) + (1 * 128),
+               (1 * 1) + (1 * 2) + (1 * 4) + (1 * 8) + (1 * 16) + (0 * 32) + (1 * 64) + (1 * 128),
+               (1 * 1) + (0 * 2) + (1 * 4) + (0 * 8) + (1 * 16) + (1 * 32) + (0 * 64) + (1 * 128),
+               (1 * 1) + (1 * 2) + (1 * 4) + (0 * 8) + (0 * 16) + (1 * 32) + (0 * 64) + (0 * 128),
+               (0 * 1) + (1 * 2) + (1 * 4) + (0 * 8) + (0 * 16) + (1 * 32) + (0 * 64) + (0 * 128),
+               (0 * 1) + (0 * 2) + (1 * 4) + (1 * 8) + (1 * 16) + (0 * 32) + (0 * 64) + (0 * 128),
+               (0 * 1) + (0 * 2) + (1 * 4) + (1 * 8) + (0 * 16) + (0 * 32) + (1 * 64) + (0 * 128),
+               (0 * 1) + (0 * 2) + (1 * 4) + (1 * 8) + (1 * 16) + (1 * 32) + (1 * 64) + (1 * 128),
+               (1 * 1) + (1 * 2) + (0 * 4) + (1 * 8) + (0 * 16) + (1 * 32) + (0 * 64) + (1 * 128),
+               (0 * 1) + (0 * 2) + (0 * 4) + (0 * 8) + (1 * 16) + (1 * 32) + (1 * 64) + (0 * 128),
+               (1 * 1) + (0 * 2) + (0 * 4) + (1 * 8) + (0 * 16) + (0 * 32) + (1 * 64) + (1 * 128),
+               (0 * 1) + (1 * 2) + (1 * 4) + (1 * 8) + (0 * 16) + (0 * 32) + (0 * 64) + (1 * 128),
+               (0 * 1) + (0 * 2) + (0 * 4) + (0 * 8) + (0 * 16) + (0 * 32) + (0 * 64) + (1 * 128),
+               (1 * 1) + (1 * 2) + (1 * 4) + (0 * 8) + (1 * 16) + (0 * 32) + (0 * 64) + (1 * 128),
+               (1 * 1) + (1 * 2) + (1 * 4) + (0 * 8) + (0 * 16) + (1 * 32) + (0 * 64) + (1 * 128),
+               (1 * 1) + (0 * 2) + (0 * 4) + (0 * 8) + (0 * 16) + (1 * 32) + (0 * 64) + (1 * 128),
+               (0 * 1) + (1 * 2) + (0 * 4) + (0 * 8) + (1 * 16) + (0 * 32) + (0 * 64) + (1 * 128),
+               (1 * 1) + (0 * 2) + (0 * 4) + (0 * 8) + (0 * 16) + (1 * 32) + (0 * 64) + (0 * 128),
+               (1 * 1) + (0 * 2) + (0 * 4) + (1 * 8) + (0 * 16) + (1 * 32) + (0 * 64) + (0 * 128),
+               (0 * 1) + (0 * 2) + (1 * 4) + (1 * 8) + (1 * 16) + (1 * 32) + (0 * 64) + (1 * 128),
+               (0 * 1) + (0 * 2) + (0 * 4) + (0 * 8) + (0 * 16) + (0 * 32) + (1 * 64) + (0 * 128),
+               (0 * 1) + (1 * 2) + (1 * 4) + (0 * 8) + (1 * 16) + (0 * 32) + (0 * 64) + (1 * 128),
+               (1 * 1) + (0 * 2) + (1 * 4) + (0 * 8) + (1 * 16) + (0 * 32) + (0 * 64) + (1 * 128),
+               (0 * 1) + (1 * 2) + (1 * 4) + (1 * 8) + (0 * 16) + (0 * 32) + (0 * 64) + (0 * 128),
+               (1 * 1) + (1 * 2) + (1 * 4) + (0 * 8) + (1 * 16) + (0 * 32) + (1 * 64) + (0 * 128),
+               (1 * 1) + (1 * 2) + (1 * 4) + (0 * 8) + (0 * 16) + (0 * 32) + (1 * 64) + (1 * 128),
+               (1 * 1) + (0 * 2) + (0 * 4) + (1 * 8) + (1 * 16) + (0 * 32) + (0 * 64) + (1 * 128),
+               (0 * 1) + (1 * 2) + (0 * 4) + (1 * 8) + (1 * 16) + (0 * 32) + (0 * 64) + (1 * 128),
+               (0 * 1) + (1 * 2) + (0 * 4) + (1 * 8) + (1 * 16) + (0 * 32) + (1 * 64) + (0 * 128)},
+               "His money is twice tainted: 'taint yours and 'taint mine."},
+       {[32]byte{(0 * 1) + (0 * 2) + (1 * 4) + (1 * 8) + (0 * 16) + (0 * 32) + (0 * 64) + (1 * 128),
+               (1 * 1) + (1 * 2) + (1 * 4) + (0 * 8) + (0 * 16) + (0 * 32) + (0 * 64) + (1 * 128),
+               (0 * 1) + (1 * 2) + (1 * 4) + (1 * 8) + (1 * 16) + (0 * 32) + (1 * 64) + (1 * 128),
+               (0 * 1) + (1 * 2) + (1 * 4) + (0 * 8) + (1 * 16) + (1 * 32) + (0 * 64) + (1 * 128),
+               (1 * 1) + (0 * 2) + (1 * 4) + (0 * 8) + (1 * 16) + (0 * 32) + (1 * 64) + (0 * 128),
+               (1 * 1) + (0 * 2) + (1 * 4) + (0 * 8) + (0 * 16) + (0 * 32) + (0 * 64) + (0 * 128),
+               (1 * 1) + (1 * 2) + (0 * 4) + (0 * 8) + (0 * 16) + (0 * 32) + (1 * 64) + (1 * 128),
+               (1 * 1) + (0 * 2) + (0 * 4) + (1 * 8) + (1 * 16) + (0 * 32) + (0 * 64) + (1 * 128),
+               (0 * 1) + (1 * 2) + (1 * 4) + (1 * 8) + (1 * 16) + (1 * 32) + (0 * 64) + (0 * 128),
+               (0 * 1) + (1 * 2) + (0 * 4) + (0 * 8) + (1 * 16) + (1 * 32) + (0 * 64) + (1 * 128),
+               (1 * 1) + (1 * 2) + (0 * 4) + (1 * 8) + (0 * 16) + (0 * 32) + (1 * 64) + (0 * 128),
+               (0 * 1) + (1 * 2) + (0 * 4) + (1 * 8) + (1 * 16) + (1 * 32) + (1 * 64) + (0 * 128),
+               (1 * 1) + (0 * 2) + (1 * 4) + (0 * 8) + (1 * 16) + (0 * 32) + (0 * 64) + (0 * 128),
+               (0 * 1) + (0 * 2) + (1 * 4) + (1 * 8) + (0 * 16) + (0 * 32) + (0 * 64) + (0 * 128),
+               (1 * 1) + (0 * 2) + (0 * 4) + (0 * 8) + (0 * 16) + (0 * 32) + (1 * 64) + (0 * 128),
+               (1 * 1) + (0 * 2) + (1 * 4) + (0 * 8) + (1 * 16) + (0 * 32) + (1 * 64) + (0 * 128),
+               (0 * 1) + (0 * 2) + (0 * 4) + (1 * 8) + (0 * 16) + (1 * 32) + (1 * 64) + (1 * 128),
+               (0 * 1) + (1 * 2) + (1 * 4) + (1 * 8) + (0 * 16) + (1 * 32) + (0 * 64) + (0 * 128),
+               (0 * 1) + (1 * 2) + (1 * 4) + (1 * 8) + (0 * 16) + (1 * 32) + (1 * 64) + (1 * 128),
+               (1 * 1) + (0 * 2) + (0 * 4) + (1 * 8) + (0 * 16) + (1 * 32) + (1 * 64) + (0 * 128),
+               (0 * 1) + (0 * 2) + (0 * 4) + (0 * 8) + (0 * 16) + (1 * 32) + (1 * 64) + (0 * 128),
+               (1 * 1) + (1 * 2) + (1 * 4) + (1 * 8) + (0 * 16) + (0 * 32) + (1 * 64) + (1 * 128),
+               (0 * 1) + (0 * 2) + (1 * 4) + (1 * 8) + (0 * 16) + (0 * 32) + (0 * 64) + (0 * 128),
+               (0 * 1) + (1 * 2) + (0 * 4) + (1 * 8) + (1 * 16) + (1 * 32) + (0 * 64) + (0 * 128),
+               (1 * 1) + (0 * 2) + (0 * 4) + (0 * 8) + (0 * 16) + (0 * 32) + (0 * 64) + (1 * 128),
+               (0 * 1) + (0 * 2) + (1 * 4) + (0 * 8) + (1 * 16) + (0 * 32) + (0 * 64) + (0 * 128),
+               (1 * 1) + (1 * 2) + (1 * 4) + (1 * 8) + (1 * 16) + (1 * 32) + (1 * 64) + (1 * 128),
+               (1 * 1) + (1 * 2) + (0 * 4) + (0 * 8) + (1 * 16) + (1 * 32) + (1 * 64) + (0 * 128),
+               (1 * 1) + (0 * 2) + (1 * 4) + (1 * 8) + (0 * 16) + (1 * 32) + (1 * 64) + (0 * 128),
+               (1 * 1) + (0 * 2) + (0 * 4) + (1 * 8) + (0 * 16) + (1 * 32) + (1 * 64) + (0 * 128),
+               (0 * 1) + (1 * 2) + (0 * 4) + (1 * 8) + (0 * 16) + (0 * 32) + (1 * 64) + (1 * 128),
+               (1 * 1) + (0 * 2) + (1 * 4) + (0 * 8) + (1 * 16) + (0 * 32) + (1 * 64) + (1 * 128)},
+               "There is no reason for any individual to have a computer in their home. -Ken Olsen, 1977"},
+       {[32]byte{(1 * 1) + (1 * 2) + (1 * 4) + (1 * 8) + (1 * 16) + (1 * 32) + (0 * 64) + (1 * 128),
+               (0 * 1) + (0 * 2) + (0 * 4) + (0 * 8) + (1 * 16) + (1 * 32) + (0 * 64) + (1 * 128),
+               (0 * 1) + (1 * 2) + (1 * 4) + (0 * 8) + (0 * 16) + (1 * 32) + (0 * 64) + (1 * 128),
+               (0 * 1) + (1 * 2) + (0 * 4) + (1 * 8) + (1 * 16) + (1 * 32) + (1 * 64) + (0 * 128),
+               (1 * 1) + (0 * 2) + (0 * 4) + (1 * 8) + (1 * 16) + (0 * 32) + (0 * 64) + (0 * 128),
+               (1 * 1) + (0 * 2) + (1 * 4) + (1 * 8) + (0 * 16) + (0 * 32) + (1 * 64) + (1 * 128),
+               (0 * 1) + (0 * 2) + (1 * 4) + (1 * 8) + (0 * 16) + (1 * 32) + (1 * 64) + (1 * 128),
+               (0 * 1) + (1 * 2) + (1 * 4) + (0 * 8) + (1 * 16) + (1 * 32) + (0 * 64) + (0 * 128),
+               (0 * 1) + (1 * 2) + (1 * 4) + (0 * 8) + (0 * 16) + (0 * 32) + (1 * 64) + (0 * 128),
+               (1 * 1) + (0 * 2) + (0 * 4) + (1 * 8) + (0 * 16) + (0 * 32) + (1 * 64) + (0 * 128),
+               (1 * 1) + (1 * 2) + (0 * 4) + (1 * 8) + (0 * 16) + (0 * 32) + (0 * 64) + (1 * 128),
+               (0 * 1) + (1 * 2) + (1 * 4) + (1 * 8) + (0 * 16) + (1 * 32) + (0 * 64) + (0 * 128),
+               (1 * 1) + (1 * 2) + (1 * 4) + (1 * 8) + (0 * 16) + (0 * 32) + (0 * 64) + (0 * 128),
+               (1 * 1) + (0 * 2) + (1 * 4) + (0 * 8) + (1 * 16) + (1 * 32) + (1 * 64) + (0 * 128),
+               (1 * 1) + (1 * 2) + (0 * 4) + (1 * 8) + (1 * 16) + (0 * 32) + (0 * 64) + (0 * 128),
+               (1 * 1) + (0 * 2) + (1 * 4) + (1 * 8) + (1 * 16) + (0 * 32) + (1 * 64) + (1 * 128),
+               (0 * 1) + (0 * 2) + (1 * 4) + (0 * 8) + (0 * 16) + (0 * 32) + (1 * 64) + (1 * 128),
+               (1 * 1) + (1 * 2) + (0 * 4) + (1 * 8) + (1 * 16) + (0 * 32) + (0 * 64) + (0 * 128),
+               (0 * 1) + (1 * 2) + (0 * 4) + (1 * 8) + (1 * 16) + (1 * 32) + (0 * 64) + (1 * 128),
+               (1 * 1) + (1 * 2) + (0 * 4) + (1 * 8) + (0 * 16) + (0 * 32) + (1 * 64) + (0 * 128),
+               (1 * 1) + (1 * 2) + (1 * 4) + (1 * 8) + (1 * 16) + (1 * 32) + (1 * 64) + (0 * 128),
+               (0 * 1) + (0 * 2) + (0 * 4) + (0 * 8) + (1 * 16) + (1 * 32) + (0 * 64) + (0 * 128),
+               (0 * 1) + (0 * 2) + (0 * 4) + (1 * 8) + (0 * 16) + (0 * 32) + (0 * 64) + (0 * 128),
+               (1 * 1) + (1 * 2) + (0 * 4) + (1 * 8) + (1 * 16) + (0 * 32) + (0 * 64) + (0 * 128),
+               (1 * 1) + (1 * 2) + (0 * 4) + (1 * 8) + (0 * 16) + (0 * 32) + (0 * 64) + (0 * 128),
+               (1 * 1) + (1 * 2) + (0 * 4) + (0 * 8) + (1 * 16) + (0 * 32) + (0 * 64) + (1 * 128),
+               (0 * 1) + (1 * 2) + (0 * 4) + (1 * 8) + (0 * 16) + (1 * 32) + (0 * 64) + (0 * 128),
+               (1 * 1) + (0 * 2) + (1 * 4) + (1 * 8) + (0 * 16) + (1 * 32) + (0 * 64) + (1 * 128),
+               (1 * 1) + (0 * 2) + (0 * 4) + (0 * 8) + (0 * 16) + (1 * 32) + (0 * 64) + (0 * 128),
+               (1 * 1) + (0 * 2) + (1 * 4) + (1 * 8) + (0 * 16) + (0 * 32) + (1 * 64) + (0 * 128),
+               (0 * 1) + (1 * 2) + (1 * 4) + (0 * 8) + (1 * 16) + (0 * 32) + (0 * 64) + (0 * 128),
+               (1 * 1) + (1 * 2) + (1 * 4) + (0 * 8) + (1 * 16) + (0 * 32) + (1 * 64) + (1 * 128)},
+               "It's a tiny change to the code and not completely disgusting. - Bob Manchek"},
+       {[32]byte{(1 * 1) + (1 * 2) + (1 * 4) + (1 * 8) + (1 * 16) + (1 * 32) + (1 * 64) + (0 * 128),
+               (0 * 1) + (1 * 2) + (0 * 4) + (1 * 8) + (1 * 16) + (0 * 32) + (0 * 64) + (1 * 128),
+               (1 * 1) + (1 * 2) + (0 * 4) + (1 * 8) + (0 * 16) + (0 * 32) + (0 * 64) + (0 * 128),
+               (1 * 1) + (1 * 2) + (0 * 4) + (1 * 8) + (1 * 16) + (0 * 32) + (0 * 64) + (1 * 128),
+               (1 * 1) + (0 * 2) + (1 * 4) + (0 * 8) + (1 * 16) + (1 * 32) + (1 * 64) + (1 * 128),
+               (1 * 1) + (1 * 2) + (0 * 4) + (0 * 8) + (0 * 16) + (1 * 32) + (1 * 64) + (0 * 128),
+               (0 * 1) + (1 * 2) + (0 * 4) + (0 * 8) + (1 * 16) + (1 * 32) + (0 * 64) + (0 * 128),
+               (1 * 1) + (0 * 2) + (0 * 4) + (0 * 8) + (0 * 16) + (1 * 32) + (1 * 64) + (1 * 128),
+               (1 * 1) + (1 * 2) + (1 * 4) + (1 * 8) + (1 * 16) + (0 * 32) + (0 * 64) + (1 * 128),
+               (0 * 1) + (1 * 2) + (0 * 4) + (1 * 8) + (1 * 16) + (0 * 32) + (1 * 64) + (0 * 128),
+               (0 * 1) + (1 * 2) + (1 * 4) + (1 * 8) + (0 * 16) + (0 * 32) + (0 * 64) + (0 * 128),
+               (1 * 1) + (0 * 2) + (0 * 4) + (0 * 8) + (0 * 16) + (0 * 32) + (1 * 64) + (1 * 128),
+               (1 * 1) + (0 * 2) + (1 * 4) + (1 * 8) + (0 * 16) + (1 * 32) + (0 * 64) + (1 * 128),
+               (0 * 1) + (0 * 2) + (1 * 4) + (1 * 8) + (1 * 16) + (0 * 32) + (0 * 64) + (1 * 128),
+               (0 * 1) + (0 * 2) + (1 * 4) + (0 * 8) + (1 * 16) + (0 * 32) + (0 * 64) + (0 * 128),
+               (1 * 1) + (0 * 2) + (1 * 4) + (0 * 8) + (0 * 16) + (1 * 32) + (0 * 64) + (0 * 128),
+               (1 * 1) + (0 * 2) + (0 * 4) + (0 * 8) + (0 * 16) + (1 * 32) + (0 * 64) + (1 * 128),
+               (1 * 1) + (1 * 2) + (0 * 4) + (0 * 8) + (1 * 16) + (0 * 32) + (1 * 64) + (0 * 128),
+               (0 * 1) + (1 * 2) + (0 * 4) + (1 * 8) + (1 * 16) + (0 * 32) + (1 * 64) + (1 * 128),
+               (0 * 1) + (0 * 2) + (1 * 4) + (1 * 8) + (1 * 16) + (0 * 32) + (0 * 64) + (0 * 128),
+               (0 * 1) + (1 * 2) + (0 * 4) + (0 * 8) + (0 * 16) + (1 * 32) + (1 * 64) + (0 * 128),
+               (0 * 1) + (0 * 2) + (0 * 4) + (1 * 8) + (0 * 16) + (0 * 32) + (1 * 64) + (0 * 128),
+               (0 * 1) + (0 * 2) + (0 * 4) + (1 * 8) + (0 * 16) + (1 * 32) + (1 * 64) + (0 * 128),
+               (1 * 1) + (0 * 2) + (1 * 4) + (1 * 8) + (1 * 16) + (1 * 32) + (1 * 64) + (1 * 128),
+               (0 * 1) + (0 * 2) + (1 * 4) + (0 * 8) + (0 * 16) + (1 * 32) + (0 * 64) + (1 * 128),
+               (1 * 1) + (0 * 2) + (1 * 4) + (0 * 8) + (0 * 16) + (0 * 32) + (1 * 64) + (0 * 128),
+               (1 * 1) + (0 * 2) + (0 * 4) + (0 * 8) + (0 * 16) + (1 * 32) + (1 * 64) + (0 * 128),
+               (0 * 1) + (1 * 2) + (1 * 4) + (0 * 8) + (1 * 16) + (0 * 32) + (1 * 64) + (1 * 128),
+               (1 * 1) + (1 * 2) + (1 * 4) + (0 * 8) + (1 * 16) + (1 * 32) + (0 * 64) + (1 * 128),
+               (1 * 1) + (0 * 2) + (1 * 4) + (1 * 8) + (0 * 16) + (0 * 32) + (1 * 64) + (0 * 128),
+               (1 * 1) + (1 * 2) + (1 * 4) + (1 * 8) + (0 * 16) + (1 * 32) + (0 * 64) + (1 * 128),
+               (0 * 1) + (1 * 2) + (1 * 4) + (0 * 8) + (1 * 16) + (1 * 32) + (0 * 64) + (0 * 128)},
+               "size:  a.out:  bad magic"},
+       {[32]byte{(1 * 1) + (0 * 2) + (0 * 4) + (0 * 8) + (1 * 16) + (1 * 32) + (0 * 64) + (1 * 128),
+               (1 * 1) + (1 * 2) + (1 * 4) + (1 * 8) + (1 * 16) + (1 * 32) + (0 * 64) + (0 * 128),
+               (1 * 1) + (0 * 2) + (0 * 4) + (0 * 8) + (0 * 16) + (0 * 32) + (0 * 64) + (1 * 128),
+               (0 * 1) + (0 * 2) + (0 * 4) + (1 * 8) + (1 * 16) + (1 * 32) + (0 * 64) + (1 * 128),
+               (0 * 1) + (1 * 2) + (0 * 4) + (1 * 8) + (0 * 16) + (1 * 32) + (0 * 64) + (1 * 128),
+               (1 * 1) + (0 * 2) + (0 * 4) + (1 * 8) + (1 * 16) + (0 * 32) + (1 * 64) + (1 * 128),
+               (1 * 1) + (1 * 2) + (0 * 4) + (0 * 8) + (0 * 16) + (1 * 32) + (1 * 64) + (1 * 128),
+               (0 * 1) + (1 * 2) + (1 * 4) + (0 * 8) + (0 * 16) + (1 * 32) + (1 * 64) + (0 * 128),
+               (0 * 1) + (0 * 2) + (0 * 4) + (1 * 8) + (0 * 16) + (1 * 32) + (1 * 64) + (0 * 128),
+               (1 * 1) + (0 * 2) + (0 * 4) + (1 * 8) + (1 * 16) + (1 * 32) + (1 * 64) + (0 * 128),
+               (1 * 1) + (1 * 2) + (1 * 4) + (1 * 8) + (0 * 16) + (1 * 32) + (0 * 64) + (1 * 128),
+               (1 * 1) + (0 * 2) + (0 * 4) + (1 * 8) + (1 * 16) + (0 * 32) + (0 * 64) + (0 * 128),
+               (0 * 1) + (0 * 2) + (0 * 4) + (1 * 8) + (0 * 16) + (0 * 32) + (0 * 64) + (1 * 128),
+               (1 * 1) + (0 * 2) + (0 * 4) + (0 * 8) + (0 * 16) + (1 * 32) + (1 * 64) + (0 * 128),
+               (0 * 1) + (0 * 2) + (0 * 4) + (0 * 8) + (0 * 16) + (0 * 32) + (1 * 64) + (0 * 128),
+               (0 * 1) + (0 * 2) + (0 * 4) + (0 * 8) + (1 * 16) + (0 * 32) + (0 * 64) + (1 * 128),
+               (1 * 1) + (1 * 2) + (1 * 4) + (1 * 8) + (0 * 16) + (0 * 32) + (1 * 64) + (0 * 128),
+               (1 * 1) + (1 * 2) + (1 * 4) + (1 * 8) + (1 * 16) + (1 * 32) + (1 * 64) + (0 * 128),
+               (0 * 1) + (1 * 2) + (0 * 4) + (0 * 8) + (0 * 16) + (0 * 32) + (1 * 64) + (0 * 128),
+               (0 * 1) + (1 * 2) + (1 * 4) + (1 * 8) + (1 * 16) + (0 * 32) + (0 * 64) + (1 * 128),
+               (0 * 1) + (0 * 2) + (0 * 4) + (0 * 8) + (1 * 16) + (1 * 32) + (1 * 64) + (1 * 128),
+               (1 * 1) + (1 * 2) + (0 * 4) + (0 * 8) + (0 * 16) + (0 * 32) + (0 * 64) + (1 * 128),
+               (0 * 1) + (0 * 2) + (0 * 4) + (1 * 8) + (0 * 16) + (1 * 32) + (0 * 64) + (0 * 128),
+               (1 * 1) + (0 * 2) + (0 * 4) + (0 * 8) + (0 * 16) + (1 * 32) + (1 * 64) + (0 * 128),
+               (1 * 1) + (0 * 2) + (1 * 4) + (0 * 8) + (1 * 16) + (0 * 32) + (0 * 64) + (1 * 128),
+               (0 * 1) + (0 * 2) + (0 * 4) + (1 * 8) + (1 * 16) + (0 * 32) + (0 * 64) + (1 * 128),
+               (0 * 1) + (1 * 2) + (0 * 4) + (1 * 8) + (0 * 16) + (1 * 32) + (0 * 64) + (0 * 128),
+               (1 * 1) + (0 * 2) + (1 * 4) + (0 * 8) + (1 * 16) + (1 * 32) + (1 * 64) + (0 * 128),
+               (0 * 1) + (0 * 2) + (0 * 4) + (1 * 8) + (0 * 16) + (0 * 32) + (0 * 64) + (1 * 128),
+               (1 * 1) + (0 * 2) + (1 * 4) + (0 * 8) + (0 * 16) + (0 * 32) + (0 * 64) + (1 * 128),
+               (0 * 1) + (0 * 2) + (1 * 4) + (1 * 8) + (0 * 16) + (0 * 32) + (0 * 64) + (1 * 128),
+               (0 * 1) + (0 * 2) + (1 * 4) + (1 * 8) + (1 * 16) + (1 * 32) + (1 * 64) + (1 * 128)},
+               "The major problem is with sendmail.  -Mark Horton"},
+       {[32]byte{(0 * 1) + (1 * 2) + (0 * 4) + (0 * 8) + (1 * 16) + (1 * 32) + (0 * 64) + (1 * 128),
+               (0 * 1) + (0 * 2) + (1 * 4) + (1 * 8) + (0 * 16) + (1 * 32) + (1 * 64) + (0 * 128),
+               (0 * 1) + (0 * 2) + (0 * 4) + (1 * 8) + (1 * 16) + (1 * 32) + (0 * 64) + (0 * 128),
+               (0 * 1) + (1 * 2) + (1 * 4) + (0 * 8) + (1 * 16) + (0 * 32) + (1 * 64) + (1 * 128),
+               (1 * 1) + (0 * 2) + (1 * 4) + (0 * 8) + (1 * 16) + (0 * 32) + (0 * 64) + (0 * 128),
+               (1 * 1) + (0 * 2) + (0 * 4) + (1 * 8) + (1 * 16) + (0 * 32) + (0 * 64) + (0 * 128),
+               (0 * 1) + (0 * 2) + (0 * 4) + (1 * 8) + (0 * 16) + (1 * 32) + (1 * 64) + (1 * 128),
+               (0 * 1) + (0 * 2) + (1 * 4) + (0 * 8) + (1 * 16) + (0 * 32) + (0 * 64) + (1 * 128),
+               (0 * 1) + (0 * 2) + (0 * 4) + (1 * 8) + (0 * 16) + (0 * 32) + (1 * 64) + (0 * 128),
+               (0 * 1) + (0 * 2) + (1 * 4) + (1 * 8) + (0 * 16) + (0 * 32) + (0 * 64) + (0 * 128),
+               (0 * 1) + (0 * 2) + (0 * 4) + (0 * 8) + (1 * 16) + (1 * 32) + (1 * 64) + (0 * 128),
+               (0 * 1) + (0 * 2) + (0 * 4) + (1 * 8) + (0 * 16) + (0 * 32) + (1 * 64) + (1 * 128),
+               (1 * 1) + (1 * 2) + (1 * 4) + (0 * 8) + (1 * 16) + (1 * 32) + (0 * 64) + (0 * 128),
+               (0 * 1) + (1 * 2) + (1 * 4) + (1 * 8) + (0 * 16) + (0 * 32) + (1 * 64) + (0 * 128),
+               (1 * 1) + (1 * 2) + (0 * 4) + (0 * 8) + (0 * 16) + (1 * 32) + (0 * 64) + (1 * 128),
+               (0 * 1) + (1 * 2) + (0 * 4) + (1 * 8) + (1 * 16) + (0 * 32) + (1 * 64) + (0 * 128),
+               (0 * 1) + (0 * 2) + (0 * 4) + (0 * 8) + (0 * 16) + (1 * 32) + (0 * 64) + (1 * 128),
+               (1 * 1) + (0 * 2) + (1 * 4) + (1 * 8) + (0 * 16) + (1 * 32) + (0 * 64) + (1 * 128),
+               (1 * 1) + (0 * 2) + (1 * 4) + (0 * 8) + (0 * 16) + (0 * 32) + (0 * 64) + (0 * 128),
+               (0 * 1) + (1 * 2) + (0 * 4) + (0 * 8) + (1 * 16) + (1 * 32) + (0 * 64) + (1 * 128),
+               (0 * 1) + (1 * 2) + (1 * 4) + (1 * 8) + (0 * 16) + (1 * 32) + (0 * 64) + (1 * 128),
+               (1 * 1) + (0 * 2) + (1 * 4) + (1 * 8) + (1 * 16) + (1 * 32) + (0 * 64) + (0 * 128),
+               (0 * 1) + (1 * 2) + (1 * 4) + (0 * 8) + (0 * 16) + (1 * 32) + (1 * 64) + (0 * 128),
+               (0 * 1) + (0 * 2) + (1 * 4) + (0 * 8) + (1 * 16) + (1 * 32) + (1 * 64) + (0 * 128),
+               (0 * 1) + (1 * 2) + (1 * 4) + (1 * 8) + (0 * 16) + (1 * 32) + (1 * 64) + (1 * 128),
+               (1 * 1) + (0 * 2) + (1 * 4) + (0 * 8) + (0 * 16) + (0 * 32) + (1 * 64) + (1 * 128),
+               (1 * 1) + (0 * 2) + (1 * 4) + (0 * 8) + (1 * 16) + (1 * 32) + (1 * 64) + (1 * 128),
+               (0 * 1) + (1 * 2) + (0 * 4) + (1 * 8) + (0 * 16) + (1 * 32) + (0 * 64) + (0 * 128),
+               (1 * 1) + (0 * 2) + (0 * 4) + (1 * 8) + (0 * 16) + (1 * 32) + (1 * 64) + (0 * 128),
+               (0 * 1) + (0 * 2) + (0 * 4) + (0 * 8) + (1 * 16) + (1 * 32) + (0 * 64) + (0 * 128),
+               (0 * 1) + (1 * 2) + (1 * 4) + (1 * 8) + (1 * 16) + (0 * 32) + (1 * 64) + (0 * 128),
+               (0 * 1) + (0 * 2) + (1 * 4) + (0 * 8) + (1 * 16) + (0 * 32) + (1 * 64) + (1 * 128)},
+               "Give me a rock, paper and scissors and I will move the world.  CCFestoon"},
+       {[32]byte{(0 * 1) + (0 * 2) + (1 * 4) + (0 * 8) + (0 * 16) + (0 * 32) + (0 * 64) + (0 * 128),
+               (1 * 1) + (0 * 2) + (1 * 4) + (1 * 8) + (1 * 16) + (0 * 32) + (0 * 64) + (1 * 128),
+               (0 * 1) + (1 * 2) + (1 * 4) + (1 * 8) + (1 * 16) + (0 * 32) + (1 * 64) + (0 * 128),
+               (0 * 1) + (1 * 2) + (1 * 4) + (0 * 8) + (0 * 16) + (1 * 32) + (0 * 64) + (0 * 128),
+               (0 * 1) + (0 * 2) + (1 * 4) + (0 * 8) + (1 * 16) + (0 * 32) + (1 * 64) + (1 * 128),
+               (1 * 1) + (0 * 2) + (0 * 4) + (0 * 8) + (1 * 16) + (1 * 32) + (1 * 64) + (1 * 128),
+               (0 * 1) + (1 * 2) + (0 * 4) + (0 * 8) + (0 * 16) + (0 * 32) + (0 * 64) + (0 * 128),
+               (0 * 1) + (1 * 2) + (0 * 4) + (0 * 8) + (0 * 16) + (1 * 32) + (0 * 64) + (0 * 128),
+               (1 * 1) + (0 * 2) + (1 * 4) + (1 * 8) + (0 * 16) + (0 * 32) + (1 * 64) + (1 * 128),
+               (0 * 1) + (0 * 2) + (1 * 4) + (0 * 8) + (0 * 16) + (0 * 32) + (0 * 64) + (1 * 128),
+               (0 * 1) + (1 * 2) + (0 * 4) + (1 * 8) + (1 * 16) + (0 * 32) + (0 * 64) + (0 * 128),
+               (1 * 1) + (0 * 2) + (0 * 4) + (0 * 8) + (1 * 16) + (0 * 32) + (0 * 64) + (0 * 128),
+               (0 * 1) + (1 * 2) + (1 * 4) + (1 * 8) + (1 * 16) + (0 * 32) + (0 * 64) + (1 * 128),
+               (0 * 1) + (0 * 2) + (0 * 4) + (1 * 8) + (1 * 16) + (1 * 32) + (0 * 64) + (0 * 128),
+               (1 * 1) + (0 * 2) + (1 * 4) + (1 * 8) + (1 * 16) + (1 * 32) + (0 * 64) + (1 * 128),
+               (1 * 1) + (0 * 2) + (1 * 4) + (1 * 8) + (0 * 16) + (0 * 32) + (0 * 64) + (1 * 128),
+               (0 * 1) + (1 * 2) + (1 * 4) + (1 * 8) + (0 * 16) + (1 * 32) + (0 * 64) + (0 * 128),
+               (1 * 1) + (0 * 2) + (1 * 4) + (1 * 8) + (0 * 16) + (0 * 32) + (0 * 64) + (0 * 128),
+               (1 * 1) + (0 * 2) + (0 * 4) + (0 * 8) + (1 * 16) + (0 * 32) + (0 * 64) + (0 * 128),
+               (1 * 1) + (0 * 2) + (0 * 4) + (1 * 8) + (0 * 16) + (1 * 32) + (0 * 64) + (0 * 128),
+               (0 * 1) + (1 * 2) + (0 * 4) + (0 * 8) + (1 * 16) + (1 * 32) + (1 * 64) + (0 * 128),
+               (0 * 1) + (1 * 2) + (1 * 4) + (0 * 8) + (0 * 16) + (0 * 32) + (0 * 64) + (1 * 128),
+               (0 * 1) + (0 * 2) + (0 * 4) + (1 * 8) + (0 * 16) + (0 * 32) + (0 * 64) + (1 * 128),
+               (0 * 1) + (0 * 2) + (1 * 4) + (0 * 8) + (0 * 16) + (0 * 32) + (1 * 64) + (0 * 128),
+               (1 * 1) + (0 * 2) + (1 * 4) + (0 * 8) + (1 * 16) + (0 * 32) + (0 * 64) + (1 * 128),
+               (1 * 1) + (0 * 2) + (1 * 4) + (0 * 8) + (1 * 16) + (1 * 32) + (1 * 64) + (0 * 128),
+               (0 * 1) + (0 * 2) + (1 * 4) + (0 * 8) + (1 * 16) + (0 * 32) + (1 * 64) + (1 * 128),
+               (1 * 1) + (1 * 2) + (1 * 4) + (1 * 8) + (1 * 16) + (1 * 32) + (1 * 64) + (1 * 128),
+               (0 * 1) + (1 * 2) + (0 * 4) + (0 * 8) + (0 * 16) + (0 * 32) + (1 * 64) + (0 * 128),
+               (0 * 1) + (0 * 2) + (0 * 4) + (1 * 8) + (1 * 16) + (1 * 32) + (0 * 64) + (1 * 128),
+               (0 * 1) + (1 * 2) + (0 * 4) + (0 * 8) + (0 * 16) + (0 * 32) + (1 * 64) + (0 * 128),
+               (1 * 1) + (0 * 2) + (0 * 4) + (0 * 8) + (0 * 16) + (0 * 32) + (1 * 64) + (1 * 128)},
+               "If the enemy is within range, then so are you."},
+       {[32]byte{(0 * 1) + (1 * 2) + (1 * 4) + (1 * 8) + (0 * 16) + (0 * 32) + (0 * 64) + (0 * 128),
+               (1 * 1) + (0 * 2) + (0 * 4) + (0 * 8) + (1 * 16) + (0 * 32) + (0 * 64) + (0 * 128),
+               (0 * 1) + (0 * 2) + (0 * 4) + (1 * 8) + (0 * 16) + (1 * 32) + (1 * 64) + (0 * 128),
+               (0 * 1) + (0 * 2) + (0 * 4) + (1 * 8) + (1 * 16) + (1 * 32) + (0 * 64) + (0 * 128),
+               (1 * 1) + (1 * 2) + (0 * 4) + (0 * 8) + (0 * 16) + (1 * 32) + (1 * 64) + (1 * 128),
+               (0 * 1) + (0 * 2) + (1 * 4) + (1 * 8) + (0 * 16) + (0 * 32) + (1 * 64) + (1 * 128),
+               (0 * 1) + (0 * 2) + (1 * 4) + (1 * 8) + (1 * 16) + (0 * 32) + (0 * 64) + (0 * 128),
+               (0 * 1) + (1 * 2) + (0 * 4) + (1 * 8) + (1 * 16) + (0 * 32) + (0 * 64) + (0 * 128),
+               (0 * 1) + (0 * 2) + (1 * 4) + (0 * 8) + (1 * 16) + (0 * 32) + (0 * 64) + (0 * 128),
+               (1 * 1) + (0 * 2) + (1 * 4) + (1 * 8) + (0 * 16) + (0 * 32) + (1 * 64) + (1 * 128),
+               (0 * 1) + (0 * 2) + (1 * 4) + (0 * 8) + (0 * 16) + (0 * 32) + (0 * 64) + (0 * 128),
+               (1 * 1) + (1 * 2) + (0 * 4) + (0 * 8) + (1 * 16) + (0 * 32) + (1 * 64) + (0 * 128),
+               (1 * 1) + (1 * 2) + (1 * 4) + (0 * 8) + (1 * 16) + (0 * 32) + (0 * 64) + (1 * 128),
+               (0 * 1) + (1 * 2) + (0 * 4) + (0 * 8) + (0 * 16) + (1 * 32) + (1 * 64) + (1 * 128),
+               (1 * 1) + (1 * 2) + (0 * 4) + (1 * 8) + (1 * 16) + (0 * 32) + (0 * 64) + (1 * 128),
+               (1 * 1) + (0 * 2) + (1 * 4) + (1 * 8) + (0 * 16) + (0 * 32) + (1 * 64) + (0 * 128),
+               (0 * 1) + (0 * 2) + (0 * 4) + (1 * 8) + (0 * 16) + (0 * 32) + (0 * 64) + (0 * 128),
+               (0 * 1) + (1 * 2) + (0 * 4) + (1 * 8) + (1 * 16) + (1 * 32) + (1 * 64) + (0 * 128),
+               (1 * 1) + (0 * 2) + (0 * 4) + (0 * 8) + (0 * 16) + (1 * 32) + (0 * 64) + (1 * 128),
+               (1 * 1) + (1 * 2) + (0 * 4) + (1 * 8) + (1 * 16) + (0 * 32) + (0 * 64) + (0 * 128),
+               (0 * 1) + (0 * 2) + (0 * 4) + (1 * 8) + (0 * 16) + (0 * 32) + (0 * 64) + (0 * 128),
+               (1 * 1) + (1 * 2) + (0 * 4) + (0 * 8) + (1 * 16) + (0 * 32) + (1 * 64) + (0 * 128),
+               (0 * 1) + (0 * 2) + (1 * 4) + (1 * 8) + (1 * 16) + (1 * 32) + (1 * 64) + (1 * 128),
+               (1 * 1) + (0 * 2) + (0 * 4) + (1 * 8) + (0 * 16) + (1 * 32) + (1 * 64) + (0 * 128),
+               (0 * 1) + (0 * 2) + (1 * 4) + (1 * 8) + (0 * 16) + (1 * 32) + (1 * 64) + (1 * 128),
+               (0 * 1) + (1 * 2) + (0 * 4) + (0 * 8) + (0 * 16) + (0 * 32) + (0 * 64) + (1 * 128),
+               (1 * 1) + (0 * 2) + (0 * 4) + (1 * 8) + (0 * 16) + (1 * 32) + (1 * 64) + (1 * 128),
+               (1 * 1) + (1 * 2) + (0 * 4) + (0 * 8) + (0 * 16) + (0 * 32) + (0 * 64) + (0 * 128),
+               (0 * 1) + (0 * 2) + (0 * 4) + (0 * 8) + (1 * 16) + (1 * 32) + (0 * 64) + (0 * 128),
+               (0 * 1) + (1 * 2) + (1 * 4) + (0 * 8) + (1 * 16) + (0 * 32) + (1 * 64) + (1 * 128),
+               (1 * 1) + (0 * 2) + (0 * 4) + (1 * 8) + (0 * 16) + (0 * 32) + (0 * 64) + (0 * 128),
+               (1 * 1) + (0 * 2) + (0 * 4) + (1 * 8) + (0 * 16) + (0 * 32) + (1 * 64) + (0 * 128)},
+               "It's well we cannot hear the screams/That we create in others' dreams."},
+       {[32]byte{(1 * 1) + (1 * 2) + (1 * 4) + (1 * 8) + (0 * 16) + (0 * 32) + (1 * 64) + (0 * 128),
+               (1 * 1) + (0 * 2) + (1 * 4) + (1 * 8) + (1 * 16) + (1 * 32) + (1 * 64) + (0 * 128),
+               (0 * 1) + (1 * 2) + (1 * 4) + (1 * 8) + (0 * 16) + (0 * 32) + (0 * 64) + (1 * 128),
+               (1 * 1) + (0 * 2) + (1 * 4) + (0 * 8) + (1 * 16) + (1 * 32) + (0 * 64) + (1 * 128),
+               (0 * 1) + (0 * 2) + (1 * 4) + (1 * 8) + (1 * 16) + (1 * 32) + (0 * 64) + (1 * 128),
+               (1 * 1) + (0 * 2) + (0 * 4) + (0 * 8) + (1 * 16) + (1 * 32) + (1 * 64) + (1 * 128),
+               (1 * 1) + (0 * 2) + (1 * 4) + (1 * 8) + (1 * 16) + (0 * 32) + (0 * 64) + (0 * 128),
+               (0 * 1) + (1 * 2) + (0 * 4) + (0 * 8) + (0 * 16) + (1 * 32) + (1 * 64) + (1 * 128),
+               (1 * 1) + (0 * 2) + (1 * 4) + (0 * 8) + (0 * 16) + (1 * 32) + (0 * 64) + (1 * 128),
+               (1 * 1) + (1 * 2) + (0 * 4) + (1 * 8) + (0 * 16) + (1 * 32) + (1 * 64) + (0 * 128),
+               (1 * 1) + (1 * 2) + (1 * 4) + (0 * 8) + (1 * 16) + (0 * 32) + (0 * 64) + (1 * 128),
+               (0 * 1) + (0 * 2) + (0 * 4) + (0 * 8) + (1 * 16) + (0 * 32) + (0 * 64) + (0 * 128),
+               (1 * 1) + (0 * 2) + (0 * 4) + (0 * 8) + (0 * 16) + (1 * 32) + (0 * 64) + (0 * 128),
+               (0 * 1) + (0 * 2) + (1 * 4) + (0 * 8) + (0 * 16) + (1 * 32) + (0 * 64) + (1 * 128),
+               (0 * 1) + (0 * 2) + (1 * 4) + (0 * 8) + (0 * 16) + (0 * 32) + (1 * 64) + (0 * 128),
+               (0 * 1) + (1 * 2) + (0 * 4) + (1 * 8) + (0 * 16) + (1 * 32) + (0 * 64) + (1 * 128),
+               (0 * 1) + (1 * 2) + (1 * 4) + (1 * 8) + (0 * 16) + (0 * 32) + (1 * 64) + (0 * 128),
+               (1 * 1) + (1 * 2) + (1 * 4) + (1 * 8) + (0 * 16) + (1 * 32) + (0 * 64) + (1 * 128),
+               (0 * 1) + (1 * 2) + (1 * 4) + (0 * 8) + (1 * 16) + (0 * 32) + (1 * 64) + (1 * 128),
+               (0 * 1) + (0 * 2) + (1 * 4) + (1 * 8) + (0 * 16) + (1 * 32) + (1 * 64) + (1 * 128),
+               (0 * 1) + (0 * 2) + (0 * 4) + (0 * 8) + (1 * 16) + (0 * 32) + (1 * 64) + (1 * 128),
+               (1 * 1) + (1 * 2) + (0 * 4) + (0 * 8) + (1 * 16) + (1 * 32) + (1 * 64) + (1 * 128),
+               (1 * 1) + (1 * 2) + (1 * 4) + (0 * 8) + (0 * 16) + (0 * 32) + (0 * 64) + (0 * 128),
+               (1 * 1) + (0 * 2) + (1 * 4) + (0 * 8) + (1 * 16) + (1 * 32) + (0 * 64) + (1 * 128),
+               (0 * 1) + (0 * 2) + (0 * 4) + (0 * 8) + (1 * 16) + (0 * 32) + (0 * 64) + (0 * 128),
+               (0 * 1) + (1 * 2) + (1 * 4) + (1 * 8) + (1 * 16) + (0 * 32) + (0 * 64) + (1 * 128),
+               (0 * 1) + (1 * 2) + (1 * 4) + (1 * 8) + (0 * 16) + (0 * 32) + (1 * 64) + (0 * 128),
+               (1 * 1) + (1 * 2) + (1 * 4) + (0 * 8) + (1 * 16) + (1 * 32) + (1 * 64) + (0 * 128),
+               (0 * 1) + (0 * 2) + (1 * 4) + (1 * 8) + (0 * 16) + (1 * 32) + (1 * 64) + (0 * 128),
+               (0 * 1) + (0 * 2) + (0 * 4) + (0 * 8) + (1 * 16) + (0 * 32) + (1 * 64) + (1 * 128),
+               (0 * 1) + (1 * 2) + (1 * 4) + (1 * 8) + (1 * 16) + (1 * 32) + (1 * 64) + (1 * 128),
+               (0 * 1) + (1 * 2) + (1 * 4) + (0 * 8) + (0 * 16) + (0 * 32) + (1 * 64) + (0 * 128)},
+               "You remind me of a TV show, but that's all right: I watch it anyway."},
+       {[32]byte{(1 * 1) + (0 * 2) + (0 * 4) + (0 * 8) + (0 * 16) + (1 * 32) + (1 * 64) + (0 * 128),
+               (0 * 1) + (0 * 2) + (0 * 4) + (0 * 8) + (0 * 16) + (0 * 32) + (1 * 64) + (1 * 128),
+               (0 * 1) + (0 * 2) + (1 * 4) + (1 * 8) + (0 * 16) + (0 * 32) + (1 * 64) + (1 * 128),
+               (0 * 1) + (0 * 2) + (1 * 4) + (1 * 8) + (0 * 16) + (0 * 32) + (1 * 64) + (0 * 128),
+               (1 * 1) + (1 * 2) + (0 * 4) + (1 * 8) + (0 * 16) + (0 * 32) + (1 * 64) + (0 * 128),
+               (0 * 1) + (0 * 2) + (0 * 4) + (1 * 8) + (1 * 16) + (0 * 32) + (1 * 64) + (1 * 128),
+               (0 * 1) + (0 * 2) + (0 * 4) + (0 * 8) + (0 * 16) + (0 * 32) + (1 * 64) + (0 * 128),
+               (1 * 1) + (0 * 2) + (1 * 4) + (1 * 8) + (0 * 16) + (1 * 32) + (1 * 64) + (0 * 128),
+               (1 * 1) + (0 * 2) + (0 * 4) + (0 * 8) + (1 * 16) + (0 * 32) + (1 * 64) + (0 * 128),
+               (0 * 1) + (0 * 2) + (0 * 4) + (0 * 8) + (0 * 16) + (1 * 32) + (0 * 64) + (0 * 128),
+               (1 * 1) + (1 * 2) + (0 * 4) + (0 * 8) + (1 * 16) + (1 * 32) + (0 * 64) + (1 * 128),
+               (1 * 1) + (1 * 2) + (0 * 4) + (1 * 8) + (1 * 16) + (1 * 32) + (1 * 64) + (1 * 128),
+               (0 * 1) + (1 * 2) + (1 * 4) + (1 * 8) + (0 * 16) + (0 * 32) + (1 * 64) + (0 * 128),
+               (0 * 1) + (0 * 2) + (1 * 4) + (1 * 8) + (1 * 16) + (1 * 32) + (0 * 64) + (1 * 128),
+               (1 * 1) + (0 * 2) + (0 * 4) + (0 * 8) + (1 * 16) + (1 * 32) + (0 * 64) + (0 * 128),
+               (0 * 1) + (1 * 2) + (1 * 4) + (1 * 8) + (0 * 16) + (0 * 32) + (1 * 64) + (1 * 128),
+               (1 * 1) + (1 * 2) + (1 * 4) + (0 * 8) + (0 * 16) + (0 * 32) + (0 * 64) + (1 * 128),
+               (0 * 1) + (1 * 2) + (1 * 4) + (0 * 8) + (0 * 16) + (1 * 32) + (1 * 64) + (0 * 128),
+               (0 * 1) + (0 * 2) + (1 * 4) + (1 * 8) + (1 * 16) + (1 * 32) + (1 * 64) + (0 * 128),
+               (0 * 1) + (1 * 2) + (1 * 4) + (0 * 8) + (1 * 16) + (0 * 32) + (0 * 64) + (0 * 128),
+               (1 * 1) + (1 * 2) + (1 * 4) + (1 * 8) + (0 * 16) + (1 * 32) + (0 * 64) + (0 * 128),
+               (1 * 1) + (0 * 2) + (0 * 4) + (1 * 8) + (0 * 16) + (1 * 32) + (0 * 64) + (0 * 128),
+               (0 * 1) + (1 * 2) + (1 * 4) + (0 * 8) + (0 * 16) + (0 * 32) + (1 * 64) + (0 * 128),
+               (1 * 1) + (1 * 2) + (0 * 4) + (1 * 8) + (0 * 16) + (0 * 32) + (0 * 64) + (1 * 128),
+               (0 * 1) + (0 * 2) + (1 * 4) + (1 * 8) + (1 * 16) + (1 * 32) + (0 * 64) + (0 * 128),
+               (1 * 1) + (1 * 2) + (1 * 4) + (0 * 8) + (1 * 16) + (1 * 32) + (1 * 64) + (0 * 128),
+               (0 * 1) + (1 * 2) + (1 * 4) + (0 * 8) + (1 * 16) + (0 * 32) + (0 * 64) + (1 * 128),
+               (1 * 1) + (0 * 2) + (1 * 4) + (0 * 8) + (1 * 16) + (1 * 32) + (1 * 64) + (0 * 128),
+               (0 * 1) + (0 * 2) + (0 * 4) + (1 * 8) + (0 * 16) + (1 * 32) + (0 * 64) + (1 * 128),
+               (0 * 1) + (1 * 2) + (0 * 4) + (1 * 8) + (1 * 16) + (0 * 32) + (1 * 64) + (0 * 128),
+               (1 * 1) + (1 * 2) + (0 * 4) + (1 * 8) + (0 * 16) + (1 * 32) + (1 * 64) + (1 * 128),
+               (0 * 1) + (1 * 2) + (1 * 4) + (1 * 8) + (0 * 16) + (0 * 32) + (1 * 64) + (1 * 128)},
+               "C is as portable as Stonehedge!!"},
+       {[32]byte{(1 * 1) + (1 * 2) + (1 * 4) + (1 * 8) + (1 * 16) + (0 * 32) + (0 * 64) + (0 * 128),
+               (0 * 1) + (1 * 2) + (0 * 4) + (0 * 8) + (1 * 16) + (1 * 32) + (0 * 64) + (1 * 128),
+               (1 * 1) + (1 * 2) + (0 * 4) + (1 * 8) + (0 * 16) + (1 * 32) + (1 * 64) + (1 * 128),
+               (0 * 1) + (1 * 2) + (1 * 4) + (0 * 8) + (1 * 16) + (1 * 32) + (0 * 64) + (0 * 128),
+               (0 * 1) + (0 * 2) + (0 * 4) + (1 * 8) + (0 * 16) + (0 * 32) + (0 * 64) + (1 * 128),
+               (1 * 1) + (0 * 2) + (0 * 4) + (1 * 8) + (0 * 16) + (0 * 32) + (0 * 64) + (0 * 128),
+               (0 * 1) + (0 * 2) + (1 * 4) + (1 * 8) + (1 * 16) + (1 * 32) + (0 * 64) + (0 * 128),
+               (0 * 1) + (1 * 2) + (0 * 4) + (1 * 8) + (0 * 16) + (0 * 32) + (1 * 64) + (0 * 128),
+               (1 * 1) + (1 * 2) + (1 * 4) + (1 * 8) + (1 * 16) + (1 * 32) + (0 * 64) + (0 * 128),
+               (0 * 1) + (0 * 2) + (0 * 4) + (0 * 8) + (0 * 16) + (0 * 32) + (0 * 64) + (1 * 128),
+               (1 * 1) + (0 * 2) + (1 * 4) + (1 * 8) + (0 * 16) + (0 * 32) + (1 * 64) + (1 * 128),
+               (1 * 1) + (1 * 2) + (1 * 4) + (0 * 8) + (0 * 16) + (0 * 32) + (0 * 64) + (1 * 128),
+               (1 * 1) + (0 * 2) + (1 * 4) + (0 * 8) + (0 * 16) + (1 * 32) + (0 * 64) + (1 * 128),
+               (0 * 1) + (0 * 2) + (1 * 4) + (0 * 8) + (1 * 16) + (0 * 32) + (1 * 64) + (0 * 128),
+               (0 * 1) + (1 * 2) + (1 * 4) + (1 * 8) + (1 * 16) + (1 * 32) + (1 * 64) + (0 * 128),
+               (0 * 1) + (0 * 2) + (1 * 4) + (1 * 8) + (0 * 16) + (1 * 32) + (0 * 64) + (0 * 128),
+               (1 * 1) + (0 * 2) + (0 * 4) + (1 * 8) + (0 * 16) + (1 * 32) + (1 * 64) + (1 * 128),
+               (0 * 1) + (0 * 2) + (0 * 4) + (0 * 8) + (0 * 16) + (0 * 32) + (1 * 64) + (0 * 128),
+               (0 * 1) + (0 * 2) + (1 * 4) + (0 * 8) + (0 * 16) + (1 * 32) + (0 * 64) + (1 * 128),
+               (1 * 1) + (0 * 2) + (0 * 4) + (1 * 8) + (1 * 16) + (1 * 32) + (1 * 64) + (1 * 128),
+               (1 * 1) + (1 * 2) + (0 * 4) + (0 * 8) + (0 * 16) + (1 * 32) + (0 * 64) + (0 * 128),
+               (0 * 1) + (0 * 2) + (1 * 4) + (0 * 8) + (0 * 16) + (1 * 32) + (0 * 64) + (0 * 128),
+               (0 * 1) + (1 * 2) + (0 * 4) + (1 * 8) + (1 * 16) + (1 * 32) + (0 * 64) + (0 * 128),
+               (1 * 1) + (0 * 2) + (0 * 4) + (1 * 8) + (1 * 16) + (1 * 32) + (1 * 64) + (0 * 128),
+               (0 * 1) + (1 * 2) + (0 * 4) + (0 * 8) + (0 * 16) + (1 * 32) + (0 * 64) + (1 * 128),
+               (1 * 1) + (0 * 2) + (0 * 4) + (0 * 8) + (0 * 16) + (1 * 32) + (0 * 64) + (1 * 128),
+               (0 * 1) + (1 * 2) + (0 * 4) + (0 * 8) + (0 * 16) + (1 * 32) + (1 * 64) + (1 * 128),
+               (0 * 1) + (1 * 2) + (0 * 4) + (0 * 8) + (0 * 16) + (0 * 32) + (1 * 64) + (0 * 128),
+               (0 * 1) + (1 * 2) + (0 * 4) + (0 * 8) + (0 * 16) + (1 * 32) + (0 * 64) + (0 * 128),
+               (0 * 1) + (1 * 2) + (1 * 4) + (0 * 8) + (0 * 16) + (0 * 32) + (0 * 64) + (0 * 128),
+               (1 * 1) + (1 * 2) + (0 * 4) + (0 * 8) + (1 * 16) + (0 * 32) + (0 * 64) + (1 * 128),
+               (0 * 1) + (0 * 2) + (1 * 4) + (1 * 8) + (0 * 16) + (1 * 32) + (0 * 64) + (1 * 128)},
+               "Even if I could be Shakespeare, I think I should still choose to be Faraday. - A. Huxley"},
+       {[32]byte{(1 * 1) + (0 * 2) + (0 * 4) + (1 * 8) + (1 * 16) + (1 * 32) + (0 * 64) + (0 * 128),
+               (1 * 1) + (0 * 2) + (1 * 4) + (0 * 8) + (1 * 16) + (0 * 32) + (1 * 64) + (0 * 128),
+               (1 * 1) + (0 * 2) + (1 * 4) + (0 * 8) + (0 * 16) + (0 * 32) + (0 * 64) + (1 * 128),
+               (0 * 1) + (1 * 2) + (1 * 4) + (1 * 8) + (0 * 16) + (0 * 32) + (1 * 64) + (1 * 128),
+               (0 * 1) + (0 * 2) + (0 * 4) + (0 * 8) + (1 * 16) + (1 * 32) + (0 * 64) + (0 * 128),
+               (1 * 1) + (0 * 2) + (0 * 4) + (0 * 8) + (0 * 16) + (1 * 32) + (1 * 64) + (0 * 128),
+               (1 * 1) + (1 * 2) + (0 * 4) + (1 * 8) + (1 * 16) + (1 * 32) + (1 * 64) + (0 * 128),
+               (0 * 1) + (1 * 2) + (0 * 4) + (0 * 8) + (0 * 16) + (1 * 32) + (1 * 64) + (0 * 128),
+               (0 * 1) + (0 * 2) + (0 * 4) + (1 * 8) + (0 * 16) + (0 * 32) + (1 * 64) + (1 * 128),
+               (1 * 1) + (1 * 2) + (0 * 4) + (1 * 8) + (0 * 16) + (0 * 32) + (0 * 64) + (0 * 128),
+               (1 * 1) + (1 * 2) + (0 * 4) + (0 * 8) + (1 * 16) + (0 * 32) + (0 * 64) + (1 * 128),
+               (0 * 1) + (0 * 2) + (0 * 4) + (1 * 8) + (0 * 16) + (1 * 32) + (1 * 64) + (1 * 128),
+               (0 * 1) + (0 * 2) + (0 * 4) + (0 * 8) + (0 * 16) + (1 * 32) + (0 * 64) + (0 * 128),
+               (0 * 1) + (0 * 2) + (1 * 4) + (1 * 8) + (0 * 16) + (0 * 32) + (0 * 64) + (1 * 128),
+               (0 * 1) + (0 * 2) + (0 * 4) + (1 * 8) + (0 * 16) + (1 * 32) + (1 * 64) + (1 * 128),
+               (0 * 1) + (1 * 2) + (1 * 4) + (0 * 8) + (0 * 16) + (1 * 32) + (1 * 64) + (0 * 128),
+               (0 * 1) + (0 * 2) + (1 * 4) + (0 * 8) + (1 * 16) + (0 * 32) + (1 * 64) + (1 * 128),
+               (1 * 1) + (0 * 2) + (1 * 4) + (1 * 8) + (0 * 16) + (1 * 32) + (1 * 64) + (1 * 128),
+               (0 * 1) + (0 * 2) + (0 * 4) + (1 * 8) + (0 * 16) + (0 * 32) + (1 * 64) + (1 * 128),
+               (1 * 1) + (0 * 2) + (0 * 4) + (0 * 8) + (1 * 16) + (0 * 32) + (0 * 64) + (0 * 128),
+               (1 * 1) + (0 * 2) + (0 * 4) + (0 * 8) + (0 * 16) + (1 * 32) + (0 * 64) + (1 * 128),
+               (1 * 1) + (1 * 2) + (1 * 4) + (0 * 8) + (1 * 16) + (1 * 32) + (1 * 64) + (0 * 128),
+               (1 * 1) + (0 * 2) + (1 * 4) + (1 * 8) + (1 * 16) + (1 * 32) + (1 * 64) + (1 * 128),
+               (0 * 1) + (0 * 2) + (1 * 4) + (0 * 8) + (1 * 16) + (1 * 32) + (0 * 64) + (1 * 128),
+               (0 * 1) + (0 * 2) + (0 * 4) + (1 * 8) + (1 * 16) + (1 * 32) + (0 * 64) + (1 * 128),
+               (1 * 1) + (0 * 2) + (1 * 4) + (1 * 8) + (0 * 16) + (1 * 32) + (0 * 64) + (0 * 128),
+               (1 * 1) + (0 * 2) + (0 * 4) + (1 * 8) + (1 * 16) + (1 * 32) + (0 * 64) + (0 * 128),
+               (1 * 1) + (0 * 2) + (0 * 4) + (0 * 8) + (1 * 16) + (0 * 32) + (0 * 64) + (0 * 128),
+               (0 * 1) + (0 * 2) + (0 * 4) + (1 * 8) + (1 * 16) + (0 * 32) + (1 * 64) + (1 * 128),
+               (1 * 1) + (0 * 2) + (0 * 4) + (1 * 8) + (0 * 16) + (1 * 32) + (1 * 64) + (0 * 128),
+               (0 * 1) + (0 * 2) + (1 * 4) + (0 * 8) + (0 * 16) + (1 * 32) + (1 * 64) + (0 * 128),
+               (1 * 1) + (1 * 2) + (0 * 4) + (0 * 8) + (0 * 16) + (1 * 32) + (0 * 64) + (0 * 128)},
+               "The fugacity of a constituent in a mixture of gases at a given temperature is proportional to its mole fraction.  Lewis-Randall Rule"},
+       {[32]byte{(1 * 1) + (1 * 2) + (1 * 4) + (1 * 8) + (0 * 16) + (0 * 32) + (1 * 64) + (0 * 128),
+               (1 * 1) + (1 * 2) + (0 * 4) + (1 * 8) + (1 * 16) + (0 * 32) + (0 * 64) + (1 * 128),
+               (0 * 1) + (0 * 2) + (0 * 4) + (1 * 8) + (1 * 16) + (0 * 32) + (0 * 64) + (0 * 128),
+               (0 * 1) + (1 * 2) + (0 * 4) + (1 * 8) + (1 * 16) + (0 * 32) + (0 * 64) + (1 * 128),
+               (1 * 1) + (1 * 2) + (0 * 4) + (0 * 8) + (1 * 16) + (0 * 32) + (0 * 64) + (0 * 128),
+               (0 * 1) + (0 * 2) + (0 * 4) + (0 * 8) + (1 * 16) + (0 * 32) + (1 * 64) + (1 * 128),
+               (0 * 1) + (0 * 2) + (0 * 4) + (0 * 8) + (1 * 16) + (1 * 32) + (0 * 64) + (0 * 128),
+               (1 * 1) + (1 * 2) + (0 * 4) + (0 * 8) + (0 * 16) + (0 * 32) + (0 * 64) + (1 * 128),
+               (0 * 1) + (1 * 2) + (0 * 4) + (0 * 8) + (0 * 16) + (0 * 32) + (0 * 64) + (1 * 128),
+               (1 * 1) + (0 * 2) + (0 * 4) + (1 * 8) + (0 * 16) + (1 * 32) + (1 * 64) + (0 * 128),
+               (0 * 1) + (0 * 2) + (1 * 4) + (1 * 8) + (1 * 16) + (0 * 32) + (1 * 64) + (1 * 128),
+               (0 * 1) + (0 * 2) + (0 * 4) + (1 * 8) + (0 * 16) + (1 * 32) + (1 * 64) + (1 * 128),
+               (0 * 1) + (1 * 2) + (1 * 4) + (0 * 8) + (0 * 16) + (0 * 32) + (1 * 64) + (0 * 128),
+               (1 * 1) + (0 * 2) + (0 * 4) + (0 * 8) + (1 * 16) + (1 * 32) + (0 * 64) + (1 * 128),
+               (0 * 1) + (1 * 2) + (0 * 4) + (1 * 8) + (0 * 16) + (1 * 32) + (1 * 64) + (0 * 128),
+               (0 * 1) + (0 * 2) + (1 * 4) + (1 * 8) + (1 * 16) + (0 * 32) + (0 * 64) + (0 * 128),
+               (1 * 1) + (0 * 2) + (0 * 4) + (1 * 8) + (0 * 16) + (1 * 32) + (1 * 64) + (1 * 128),
+               (0 * 1) + (1 * 2) + (1 * 4) + (1 * 8) + (0 * 16) + (0 * 32) + (1 * 64) + (1 * 128),
+               (1 * 1) + (0 * 2) + (0 * 4) + (0 * 8) + (0 * 16) + (0 * 32) + (0 * 64) + (1 * 128),
+               (0 * 1) + (1 * 2) + (1 * 4) + (1 * 8) + (1 * 16) + (1 * 32) + (1 * 64) + (1 * 128),
+               (1 * 1) + (1 * 2) + (0 * 4) + (0 * 8) + (0 * 16) + (1 * 32) + (1 * 64) + (0 * 128),
+               (0 * 1) + (1 * 2) + (1 * 4) + (0 * 8) + (0 * 16) + (1 * 32) + (1 * 64) + (1 * 128),
+               (1 * 1) + (0 * 2) + (1 * 4) + (1 * 8) + (1 * 16) + (0 * 32) + (1 * 64) + (0 * 128),
+               (0 * 1) + (1 * 2) + (0 * 4) + (0 * 8) + (0 * 16) + (1 * 32) + (1 * 64) + (1 * 128),
+               (0 * 1) + (1 * 2) + (1 * 4) + (0 * 8) + (1 * 16) + (1 * 32) + (1 * 64) + (1 * 128),
+               (0 * 1) + (1 * 2) + (1 * 4) + (0 * 8) + (1 * 16) + (1 * 32) + (0 * 64) + (0 * 128),
+               (0 * 1) + (1 * 2) + (1 * 4) + (0 * 8) + (0 * 16) + (0 * 32) + (0 * 64) + (1 * 128),
+               (1 * 1) + (1 * 2) + (0 * 4) + (0 * 8) + (1 * 16) + (1 * 32) + (0 * 64) + (0 * 128),
+               (0 * 1) + (1 * 2) + (1 * 4) + (0 * 8) + (1 * 16) + (1 * 32) + (0 * 64) + (0 * 128),
+               (1 * 1) + (0 * 2) + (0 * 4) + (1 * 8) + (0 * 16) + (1 * 32) + (0 * 64) + (1 * 128),
+               (1 * 1) + (1 * 2) + (1 * 4) + (1 * 8) + (0 * 16) + (0 * 32) + (0 * 64) + (1 * 128),
+               (0 * 1) + (1 * 2) + (1 * 4) + (0 * 8) + (0 * 16) + (1 * 32) + (1 * 64) + (1 * 128)},
+               "How can you write a big system without C++?  -Paul Glick"},
+       // $ echo -n "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz123" | sha256sum
+       // 13d8b6bf5cc79c03c07c719c48597bd33b79677e65098589b1580fca7f22bb22
+       {[32]byte{(1 * 1) + (1 * 2) + (0 * 4) + (0 * 8) + (1 * 16) + (0 * 32) + (0 * 64) + (0 * 128),
+               (0 * 1) + (0 * 2) + (0 * 4) + (1 * 8) + (1 * 16) + (0 * 32) + (1 * 64) + (1 * 128),
+               (0 * 1) + (1 * 2) + (1 * 4) + (0 * 8) + (1 * 16) + (1 * 32) + (0 * 64) + (1 * 128),
+               (1 * 1) + (1 * 2) + (1 * 4) + (1 * 8) + (1 * 16) + (1 * 32) + (0 * 64) + (1 * 128),
+               (0 * 1) + (0 * 2) + (1 * 4) + (1 * 8) + (1 * 16) + (0 * 32) + (1 * 64) + (0 * 128),
+               (1 * 1) + (1 * 2) + (1 * 4) + (0 * 8) + (0 * 16) + (0 * 32) + (1 * 64) + (1 * 128),
+               (0 * 1) + (0 * 2) + (1 * 4) + (1 * 8) + (1 * 16) + (0 * 32) + (0 * 64) + (1 * 128),
+               (1 * 1) + (1 * 2) + (0 * 4) + (0 * 8) + (0 * 16) + (0 * 32) + (0 * 64) + (0 * 128),
+               (0 * 1) + (0 * 2) + (0 * 4) + (0 * 8) + (0 * 16) + (0 * 32) + (1 * 64) + (1 * 128),
+               (0 * 1) + (0 * 2) + (1 * 4) + (1 * 8) + (1 * 16) + (1 * 32) + (1 * 64) + (0 * 128),
+               (1 * 1) + (0 * 2) + (0 * 4) + (0 * 8) + (1 * 16) + (1 * 32) + (1 * 64) + (0 * 128),
+               (0 * 1) + (0 * 2) + (1 * 4) + (1 * 8) + (1 * 16) + (0 * 32) + (0 * 64) + (1 * 128),
+               (0 * 1) + (0 * 2) + (0 * 4) + (1 * 8) + (0 * 16) + (0 * 32) + (1 * 64) + (0 * 128),
+               (1 * 1) + (0 * 2) + (0 * 4) + (1 * 8) + (1 * 16) + (0 * 32) + (1 * 64) + (0 * 128),
+               (1 * 1) + (1 * 2) + (0 * 4) + (1 * 8) + (1 * 16) + (1 * 32) + (1 * 64) + (0 * 128),
+               (1 * 1) + (1 * 2) + (0 * 4) + (0 * 8) + (1 * 16) + (0 * 32) + (1 * 64) + (1 * 128),
+               (1 * 1) + (1 * 2) + (0 * 4) + (1 * 8) + (1 * 16) + (1 * 32) + (0 * 64) + (0 * 128),
+               (1 * 1) + (0 * 2) + (0 * 4) + (1 * 8) + (1 * 16) + (1 * 32) + (1 * 64) + (0 * 128),
+               (1 * 1) + (1 * 2) + (1 * 4) + (0 * 8) + (0 * 16) + (1 * 32) + (1 * 64) + (0 * 128),
+               (0 * 1) + (1 * 2) + (1 * 4) + (1 * 8) + (1 * 16) + (1 * 32) + (1 * 64) + (0 * 128),
+               (1 * 1) + (0 * 2) + (1 * 4) + (0 * 8) + (0 * 16) + (1 * 32) + (1 * 64) + (0 * 128),
+               (1 * 1) + (0 * 2) + (0 * 4) + (1 * 8) + (0 * 16) + (0 * 32) + (0 * 64) + (0 * 128),
+               (1 * 1) + (0 * 2) + (1 * 4) + (0 * 8) + (0 * 16) + (0 * 32) + (0 * 64) + (1 * 128),
+               (1 * 1) + (0 * 2) + (0 * 4) + (1 * 8) + (0 * 16) + (0 * 32) + (0 * 64) + (1 * 128),
+               (1 * 1) + (0 * 2) + (0 * 4) + (0 * 8) + (1 * 16) + (1 * 32) + (0 * 64) + (1 * 128),
+               (0 * 1) + (0 * 2) + (0 * 4) + (1 * 8) + (1 * 16) + (0 * 32) + (1 * 64) + (0 * 128),
+               (1 * 1) + (1 * 2) + (1 * 4) + (1 * 8) + (0 * 16) + (0 * 32) + (0 * 64) + (0 * 128),
+               (0 * 1) + (1 * 2) + (0 * 4) + (1 * 8) + (0 * 16) + (0 * 32) + (1 * 64) + (1 * 128),
+               (1 * 1) + (1 * 2) + (1 * 4) + (1 * 8) + (1 * 16) + (1 * 32) + (1 * 64) + (0 * 128),
+               (0 * 1) + (1 * 2) + (0 * 4) + (0 * 8) + (0 * 16) + (1 * 32) + (0 * 64) + (0 * 128),
+               (1 * 1) + (1 * 2) + (0 * 4) + (1 * 8) + (1 * 16) + (1 * 32) + (0 * 64) + (1 * 128),
+               (0 * 1) + (1 * 2) + (0 * 4) + (0 * 8) + (0 * 16) + (1 * 32) + (0 * 64) + (0 * 128)},
+               "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz123"},
+       // $ echo -n "BCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz1234" | sha256sum
+       // 624ddef3009879c6874da2dd771d54f7330781b60e1955ceff5f9dce8bf4ea43
+       {[32]byte{(0 * 1) + (1 * 2) + (0 * 4) + (0 * 8) + (0 * 16) + (1 * 32) + (1 * 64) + (0 * 128),
+               (1 * 1) + (0 * 2) + (1 * 4) + (1 * 8) + (0 * 16) + (0 * 32) + (1 * 64) + (0 * 128),
+               (0 * 1) + (1 * 2) + (1 * 4) + (1 * 8) + (1 * 16) + (0 * 32) + (1 * 64) + (1 * 128),
+               (1 * 1) + (1 * 2) + (0 * 4) + (0 * 8) + (1 * 16) + (1 * 32) + (1 * 64) + (1 * 128),
+               (0 * 1) + (0 * 2) + (0 * 4) + (0 * 8) + (0 * 16) + (0 * 32) + (0 * 64) + (0 * 128),
+               (0 * 1) + (0 * 2) + (0 * 4) + (1 * 8) + (1 * 16) + (0 * 32) + (0 * 64) + (1 * 128),
+               (1 * 1) + (0 * 2) + (0 * 4) + (1 * 8) + (1 * 16) + (1 * 32) + (1 * 64) + (0 * 128),
+               (0 * 1) + (1 * 2) + (1 * 4) + (0 * 8) + (0 * 16) + (0 * 32) + (1 * 64) + (1 * 128),
+               (1 * 1) + (1 * 2) + (1 * 4) + (0 * 8) + (0 * 16) + (0 * 32) + (0 * 64) + (1 * 128),
+               (1 * 1) + (0 * 2) + (1 * 4) + (1 * 8) + (0 * 16) + (0 * 32) + (1 * 64) + (0 * 128),
+               (0 * 1) + (1 * 2) + (0 * 4) + (0 * 8) + (0 * 16) + (1 * 32) + (0 * 64) + (1 * 128),
+               (1 * 1) + (0 * 2) + (1 * 4) + (1 * 8) + (1 * 16) + (0 * 32) + (1 * 64) + (1 * 128),
+               (1 * 1) + (1 * 2) + (1 * 4) + (0 * 8) + (1 * 16) + (1 * 32) + (1 * 64) + (0 * 128),
+               (1 * 1) + (0 * 2) + (1 * 4) + (1 * 8) + (1 * 16) + (0 * 32) + (0 * 64) + (0 * 128),
+               (0 * 1) + (0 * 2) + (1 * 4) + (0 * 8) + (1 * 16) + (0 * 32) + (1 * 64) + (0 * 128),
+               (1 * 1) + (1 * 2) + (1 * 4) + (0 * 8) + (1 * 16) + (1 * 32) + (1 * 64) + (1 * 128),
+               (1 * 1) + (1 * 2) + (0 * 4) + (0 * 8) + (1 * 16) + (1 * 32) + (0 * 64) + (0 * 128),
+               (1 * 1) + (1 * 2) + (1 * 4) + (0 * 8) + (0 * 16) + (0 * 32) + (0 * 64) + (0 * 128),
+               (1 * 1) + (0 * 2) + (0 * 4) + (0 * 8) + (0 * 16) + (0 * 32) + (0 * 64) + (1 * 128),
+               (0 * 1) + (1 * 2) + (1 * 4) + (0 * 8) + (1 * 16) + (1 * 32) + (0 * 64) + (1 * 128),
+               (0 * 1) + (1 * 2) + (1 * 4) + (1 * 8) + (0 * 16) + (0 * 32) + (0 * 64) + (0 * 128),
+               (1 * 1) + (0 * 2) + (0 * 4) + (1 * 8) + (1 * 16) + (0 * 32) + (0 * 64) + (0 * 128),
+               (1 * 1) + (0 * 2) + (1 * 4) + (0 * 8) + (1 * 16) + (0 * 32) + (1 * 64) + (0 * 128),
+               (0 * 1) + (1 * 2) + (1 * 4) + (1 * 8) + (0 * 16) + (0 * 32) + (1 * 64) + (1 * 128),
+               (1 * 1) + (1 * 2) + (1 * 4) + (1 * 8) + (1 * 16) + (1 * 32) + (1 * 64) + (1 * 128),
+               (1 * 1) + (1 * 2) + (1 * 4) + (1 * 8) + (1 * 16) + (0 * 32) + (1 * 64) + (0 * 128),
+               (1 * 1) + (0 * 2) + (1 * 4) + (1 * 8) + (1 * 16) + (0 * 32) + (0 * 64) + (1 * 128),
+               (0 * 1) + (1 * 2) + (1 * 4) + (1 * 8) + (0 * 16) + (0 * 32) + (1 * 64) + (1 * 128),
+               (1 * 1) + (1 * 2) + (0 * 4) + (1 * 8) + (0 * 16) + (0 * 32) + (0 * 64) + (1 * 128),
+               (0 * 1) + (0 * 2) + (1 * 4) + (0 * 8) + (1 * 16) + (1 * 32) + (1 * 64) + (1 * 128),
+               (0 * 1) + (1 * 2) + (0 * 4) + (1 * 8) + (0 * 16) + (1 * 32) + (1 * 64) + (1 * 128),
+               (1 * 1) + (1 * 2) + (0 * 4) + (0 * 8) + (0 * 16) + (0 * 32) + (1 * 64) + (0 * 128)},
+               "BCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz1234"},
+       // $ echo -n "CDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz12345" | sha256sum
+       // cc031589b70dd4b24dc6def2121835ef1aa8074ff6952cdd3f81b5099a93c58d
+       {[32]byte{(0 * 1) + (0 * 2) + (1 * 4) + (1 * 8) + (0 * 16) + (0 * 32) + (1 * 64) + (1 * 128),
+               (1 * 1) + (1 * 2) + (0 * 4) + (0 * 8) + (0 * 16) + (0 * 32) + (0 * 64) + (0 * 128),
+               (1 * 1) + (0 * 2) + (1 * 4) + (0 * 8) + (1 * 16) + (0 * 32) + (0 * 64) + (0 * 128),
+               (1 * 1) + (0 * 2) + (0 * 4) + (1 * 8) + (0 * 16) + (0 * 32) + (0 * 64) + (1 * 128),
+               (1 * 1) + (1 * 2) + (1 * 4) + (0 * 8) + (1 * 16) + (1 * 32) + (0 * 64) + (1 * 128),
+               (1 * 1) + (0 * 2) + (1 * 4) + (1 * 8) + (0 * 16) + (0 * 32) + (0 * 64) + (0 * 128),
+               (0 * 1) + (0 * 2) + (1 * 4) + (0 * 8) + (1 * 16) + (0 * 32) + (1 * 64) + (1 * 128),
+               (0 * 1) + (1 * 2) + (0 * 4) + (0 * 8) + (1 * 16) + (1 * 32) + (0 * 64) + (1 * 128),
+               (1 * 1) + (0 * 2) + (1 * 4) + (1 * 8) + (0 * 16) + (0 * 32) + (1 * 64) + (0 * 128),
+               (0 * 1) + (1 * 2) + (1 * 4) + (0 * 8) + (0 * 16) + (0 * 32) + (1 * 64) + (1 * 128),
+               (0 * 1) + (1 * 2) + (1 * 4) + (1 * 8) + (1 * 16) + (0 * 32) + (1 * 64) + (1 * 128),
+               (0 * 1) + (1 * 2) + (0 * 4) + (0 * 8) + (1 * 16) + (1 * 32) + (1 * 64) + (1 * 128),
+               (0 * 1) + (1 * 2) + (0 * 4) + (0 * 8) + (1 * 16) + (0 * 32) + (0 * 64) + (0 * 128),
+               (0 * 1) + (0 * 2) + (0 * 4) + (1 * 8) + (1 * 16) + (0 * 32) + (0 * 64) + (0 * 128),
+               (1 * 1) + (0 * 2) + (1 * 4) + (0 * 8) + (1 * 16) + (1 * 32) + (0 * 64) + (0 * 128),
+               (1 * 1) + (1 * 2) + (1 * 4) + (1 * 8) + (0 * 16) + (1 * 32) + (1 * 64) + (1 * 128),
+               (0 * 1) + (1 * 2) + (0 * 4) + (1 * 8) + (1 * 16) + (0 * 32) + (0 * 64) + (0 * 128),
+               (0 * 1) + (0 * 2) + (0 * 4) + (1 * 8) + (0 * 16) + (1 * 32) + (0 * 64) + (1 * 128),
+               (1 * 1) + (1 * 2) + (1 * 4) + (0 * 8) + (0 * 16) + (0 * 32) + (0 * 64) + (0 * 128),
+               (1 * 1) + (1 * 2) + (1 * 4) + (1 * 8) + (0 * 16) + (0 * 32) + (1 * 64) + (0 * 128),
+               (0 * 1) + (1 * 2) + (1 * 4) + (0 * 8) + (1 * 16) + (1 * 32) + (1 * 64) + (1 * 128),
+               (1 * 1) + (0 * 2) + (1 * 4) + (0 * 8) + (1 * 16) + (0 * 32) + (0 * 64) + (1 * 128),
+               (0 * 1) + (0 * 2) + (1 * 4) + (1 * 8) + (0 * 16) + (1 * 32) + (0 * 64) + (0 * 128),
+               (1 * 1) + (0 * 2) + (1 * 4) + (1 * 8) + (1 * 16) + (0 * 32) + (1 * 64) + (1 * 128),
+               (1 * 1) + (1 * 2) + (1 * 4) + (1 * 8) + (1 * 16) + (1 * 32) + (0 * 64) + (0 * 128),
+               (1 * 1) + (0 * 2) + (0 * 4) + (0 * 8) + (0 * 16) + (0 * 32) + (0 * 64) + (1 * 128),
+               (1 * 1) + (0 * 2) + (1 * 4) + (0 * 8) + (1 * 16) + (1 * 32) + (0 * 64) + (1 * 128),
+               (1 * 1) + (0 * 2) + (0 * 4) + (1 * 8) + (0 * 16) + (0 * 32) + (0 * 64) + (0 * 128),
+               (0 * 1) + (1 * 2) + (0 * 4) + (1 * 8) + (1 * 16) + (0 * 32) + (0 * 64) + (1 * 128),
+               (1 * 1) + (1 * 2) + (0 * 4) + (0 * 8) + (1 * 16) + (0 * 32) + (0 * 64) + (1 * 128),
+               (1 * 1) + (0 * 2) + (1 * 4) + (0 * 8) + (0 * 16) + (0 * 32) + (1 * 64) + (1 * 128),
+               (1 * 1) + (0 * 2) + (1 * 4) + (1 * 8) + (0 * 16) + (0 * 32) + (0 * 64) + (1 * 128)},
+               "CDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz12345"},
+       // $ echo -n "DEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz123456" | sha256sum
+       // d354abb6d538402db3d73daf95537a255ebaf3a943c80205be163e044fc46a70
+       {[32]byte{(1 * 1) + (1 * 2) + (0 * 4) + (0 * 8) + (1 * 16) + (0 * 32) + (1 * 64) + (1 * 128),
+               (0 * 1) + (0 * 2) + (1 * 4) + (0 * 8) + (1 * 16) + (0 * 32) + (1 * 64) + (0 * 128),
+               (1 * 1) + (1 * 2) + (0 * 4) + (1 * 8) + (0 * 16) + (1 * 32) + (0 * 64) + (1 * 128),
+               (0 * 1) + (1 * 2) + (1 * 4) + (0 * 8) + (1 * 16) + (1 * 32) + (0 * 64) + (1 * 128),
+               (1 * 1) + (0 * 2) + (1 * 4) + (0 * 8) + (1 * 16) + (0 * 32) + (1 * 64) + (1 * 128),
+               (0 * 1) + (0 * 2) + (0 * 4) + (1 * 8) + (1 * 16) + (1 * 32) + (0 * 64) + (0 * 128),
+               (0 * 1) + (0 * 2) + (0 * 4) + (0 * 8) + (0 * 16) + (0 * 32) + (1 * 64) + (0 * 128),
+               (1 * 1) + (0 * 2) + (1 * 4) + (1 * 8) + (0 * 16) + (1 * 32) + (0 * 64) + (0 * 128),
+               (1 * 1) + (1 * 2) + (0 * 4) + (0 * 8) + (1 * 16) + (1 * 32) + (0 * 64) + (1 * 128),
+               (1 * 1) + (1 * 2) + (1 * 4) + (0 * 8) + (1 * 16) + (0 * 32) + (1 * 64) + (1 * 128),
+               (1 * 1) + (0 * 2) + (1 * 4) + (1 * 8) + (1 * 16) + (1 * 32) + (0 * 64) + (0 * 128),
+               (1 * 1) + (1 * 2) + (1 * 4) + (1 * 8) + (0 * 16) + (1 * 32) + (0 * 64) + (1 * 128),
+               (1 * 1) + (0 * 2) + (1 * 4) + (0 * 8) + (1 * 16) + (0 * 32) + (0 * 64) + (1 * 128),
+               (1 * 1) + (1 * 2) + (0 * 4) + (0 * 8) + (1 * 16) + (0 * 32) + (1 * 64) + (0 * 128),
+               (0 * 1) + (1 * 2) + (0 * 4) + (1 * 8) + (1 * 16) + (1 * 32) + (1 * 64) + (0 * 128),
+               (1 * 1) + (0 * 2) + (1 * 4) + (0 * 8) + (0 * 16) + (1 * 32) + (0 * 64) + (0 * 128),
+               (0 * 1) + (1 * 2) + (1 * 4) + (1 * 8) + (1 * 16) + (0 * 32) + (1 * 64) + (0 * 128),
+               (0 * 1) + (1 * 2) + (0 * 4) + (1 * 8) + (1 * 16) + (1 * 32) + (0 * 64) + (1 * 128),
+               (1 * 1) + (1 * 2) + (0 * 4) + (0 * 8) + (1 * 16) + (1 * 32) + (1 * 64) + (1 * 128),
+               (1 * 1) + (0 * 2) + (0 * 4) + (1 * 8) + (0 * 16) + (1 * 32) + (0 * 64) + (1 * 128),
+               (1 * 1) + (1 * 2) + (0 * 4) + (0 * 8) + (0 * 16) + (0 * 32) + (1 * 64) + (0 * 128),
+               (0 * 1) + (0 * 2) + (0 * 4) + (1 * 8) + (0 * 16) + (0 * 32) + (1 * 64) + (1 * 128),
+               (0 * 1) + (1 * 2) + (0 * 4) + (0 * 8) + (0 * 16) + (0 * 32) + (0 * 64) + (0 * 128),
+               (1 * 1) + (0 * 2) + (1 * 4) + (0 * 8) + (0 * 16) + (0 * 32) + (0 * 64) + (0 * 128),
+               (0 * 1) + (1 * 2) + (1 * 4) + (1 * 8) + (1 * 16) + (1 * 32) + (0 * 64) + (1 * 128),
+               (0 * 1) + (1 * 2) + (1 * 4) + (0 * 8) + (1 * 16) + (0 * 32) + (0 * 64) + (0 * 128),
+               (0 * 1) + (1 * 2) + (1 * 4) + (1 * 8) + (1 * 16) + (1 * 32) + (0 * 64) + (0 * 128),
+               (0 * 1) + (0 * 2) + (1 * 4) + (0 * 8) + (0 * 16) + (0 * 32) + (0 * 64) + (0 * 128),
+               (1 * 1) + (1 * 2) + (1 * 4) + (1 * 8) + (0 * 16) + (0 * 32) + (1 * 64) + (0 * 128),
+               (0 * 1) + (0 * 2) + (1 * 4) + (0 * 8) + (0 * 16) + (0 * 32) + (1 * 64) + (1 * 128),
+               (0 * 1) + (1 * 2) + (0 * 4) + (1 * 8) + (0 * 16) + (1 * 32) + (1 * 64) + (0 * 128),
+               (0 * 1) + (0 * 2) + (0 * 4) + (0 * 8) + (1 * 16) + (1 * 32) + (1 * 64) + (0 * 128)},
+               "DEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz123456"},
+       // $ echo -n "EFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz1234567" | sha256sum
+       // f78410b90a20b521afb28f41d6388482afab7265ff8884aa6290cc9f9ada30d3
+       {[32]byte{(1 * 1) + (1 * 2) + (1 * 4) + (0 * 8) + (1 * 16) + (1 * 32) + (1 * 64) + (1 * 128),
+               (0 * 1) + (0 * 2) + (1 * 4) + (0 * 8) + (0 * 16) + (0 * 32) + (0 * 64) + (1 * 128),
+               (0 * 1) + (0 * 2) + (0 * 4) + (0 * 8) + (1 * 16) + (0 * 32) + (0 * 64) + (0 * 128),
+               (1 * 1) + (0 * 2) + (0 * 4) + (1 * 8) + (1 * 16) + (1 * 32) + (0 * 64) + (1 * 128),
+               (0 * 1) + (1 * 2) + (0 * 4) + (1 * 8) + (0 * 16) + (0 * 32) + (0 * 64) + (0 * 128),
+               (0 * 1) + (0 * 2) + (0 * 4) + (0 * 8) + (0 * 16) + (1 * 32) + (0 * 64) + (0 * 128),
+               (1 * 1) + (0 * 2) + (1 * 4) + (0 * 8) + (1 * 16) + (1 * 32) + (0 * 64) + (1 * 128),
+               (1 * 1) + (0 * 2) + (0 * 4) + (0 * 8) + (0 * 16) + (1 * 32) + (0 * 64) + (0 * 128),
+               (1 * 1) + (1 * 2) + (1 * 4) + (1 * 8) + (0 * 16) + (1 * 32) + (0 * 64) + (1 * 128),
+               (0 * 1) + (1 * 2) + (0 * 4) + (0 * 8) + (1 * 16) + (1 * 32) + (0 * 64) + (1 * 128),
+               (1 * 1) + (1 * 2) + (1 * 4) + (1 * 8) + (0 * 16) + (0 * 32) + (0 * 64) + (1 * 128),
+               (1 * 1) + (0 * 2) + (0 * 4) + (0 * 8) + (0 * 16) + (0 * 32) + (1 * 64) + (0 * 128),
+               (0 * 1) + (1 * 2) + (1 * 4) + (0 * 8) + (1 * 16) + (0 * 32) + (1 * 64) + (1 * 128),
+               (0 * 1) + (0 * 2) + (0 * 4) + (1 * 8) + (1 * 16) + (1 * 32) + (0 * 64) + (0 * 128),
+               (0 * 1) + (0 * 2) + (1 * 4) + (0 * 8) + (0 * 16) + (0 * 32) + (0 * 64) + (1 * 128),
+               (0 * 1) + (1 * 2) + (0 * 4) + (0 * 8) + (0 * 16) + (0 * 32) + (0 * 64) + (1 * 128),
+               (1 * 1) + (1 * 2) + (1 * 4) + (1 * 8) + (0 * 16) + (1 * 32) + (0 * 64) + (1 * 128),
+               (1 * 1) + (1 * 2) + (0 * 4) + (1 * 8) + (0 * 16) + (1 * 32) + (0 * 64) + (1 * 128),
+               (0 * 1) + (1 * 2) + (0 * 4) + (0 * 8) + (1 * 16) + (1 * 32) + (1 * 64) + (0 * 128),
+               (1 * 1) + (0 * 2) + (1 * 4) + (0 * 8) + (0 * 16) + (1 * 32) + (1 * 64) + (0 * 128),
+               (1 * 1) + (1 * 2) + (1 * 4) + (1 * 8) + (1 * 16) + (1 * 32) + (1 * 64) + (1 * 128),
+               (0 * 1) + (0 * 2) + (0 * 4) + (1 * 8) + (0 * 16) + (0 * 32) + (0 * 64) + (1 * 128),
+               (0 * 1) + (0 * 2) + (1 * 4) + (0 * 8) + (0 * 16) + (0 * 32) + (0 * 64) + (1 * 128),
+               (0 * 1) + (1 * 2) + (0 * 4) + (1 * 8) + (0 * 16) + (1 * 32) + (0 * 64) + (1 * 128),
+               (0 * 1) + (1 * 2) + (0 * 4) + (0 * 8) + (0 * 16) + (1 * 32) + (1 * 64) + (0 * 128),
+               (0 * 1) + (0 * 2) + (0 * 4) + (0 * 8) + (1 * 16) + (0 * 32) + (0 * 64) + (1 * 128),
+               (0 * 1) + (0 * 2) + (1 * 4) + (1 * 8) + (0 * 16) + (0 * 32) + (1 * 64) + (1 * 128),
+               (1 * 1) + (1 * 2) + (1 * 4) + (1 * 8) + (1 * 16) + (0 * 32) + (0 * 64) + (1 * 128),
+               (0 * 1) + (1 * 2) + (0 * 4) + (1 * 8) + (1 * 16) + (0 * 32) + (0 * 64) + (1 * 128),
+               (0 * 1) + (1 * 2) + (0 * 4) + (1 * 8) + (1 * 16) + (0 * 32) + (1 * 64) + (1 * 128),
+               (0 * 1) + (0 * 2) + (0 * 4) + (0 * 8) + (1 * 16) + (1 * 32) + (0 * 64) + (0 * 128),
+               (1 * 1) + (1 * 2) + (0 * 4) + (0 * 8) + (1 * 16) + (0 * 32) + (1 * 64) + (1 * 128)},
+               "EFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz1234567"},
+       // $ echo -n "FGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz12345678" | sha256sum
+       // c93a8cb7ed80166b15b79c8617410ca69e46fa1e3c1d14876699d3ce6090384f
+       {[32]byte{(1 * 1) + (0 * 2) + (0 * 4) + (1 * 8) + (0 * 16) + (0 * 32) + (1 * 64) + (1 * 128),
+               (0 * 1) + (1 * 2) + (0 * 4) + (1 * 8) + (1 * 16) + (1 * 32) + (0 * 64) + (0 * 128),
+               (0 * 1) + (0 * 2) + (1 * 4) + (1 * 8) + (0 * 16) + (0 * 32) + (0 * 64) + (1 * 128),
+               (1 * 1) + (1 * 2) + (1 * 4) + (0 * 8) + (1 * 16) + (1 * 32) + (0 * 64) + (1 * 128),
+               (1 * 1) + (0 * 2) + (1 * 4) + (1 * 8) + (0 * 16) + (1 * 32) + (1 * 64) + (1 * 128),
+               (0 * 1) + (0 * 2) + (0 * 4) + (0 * 8) + (0 * 16) + (0 * 32) + (0 * 64) + (1 * 128),
+               (0 * 1) + (1 * 2) + (1 * 4) + (0 * 8) + (1 * 16) + (0 * 32) + (0 * 64) + (0 * 128),
+               (1 * 1) + (1 * 2) + (0 * 4) + (1 * 8) + (0 * 16) + (1 * 32) + (1 * 64) + (0 * 128),
+               (1 * 1) + (0 * 2) + (1 * 4) + (0 * 8) + (1 * 16) + (0 * 32) + (0 * 64) + (0 * 128),
+               (1 * 1) + (1 * 2) + (1 * 4) + (0 * 8) + (1 * 16) + (1 * 32) + (0 * 64) + (1 * 128),
+               (0 * 1) + (0 * 2) + (1 * 4) + (1 * 8) + (1 * 16) + (0 * 32) + (0 * 64) + (1 * 128),
+               (0 * 1) + (1 * 2) + (1 * 4) + (0 * 8) + (0 * 16) + (0 * 32) + (0 * 64) + (1 * 128),
+               (1 * 1) + (1 * 2) + (1 * 4) + (0 * 8) + (1 * 16) + (0 * 32) + (0 * 64) + (0 * 128),
+               (1 * 1) + (0 * 2) + (0 * 4) + (0 * 8) + (0 * 16) + (0 * 32) + (1 * 64) + (0 * 128),
+               (0 * 1) + (0 * 2) + (1 * 4) + (1 * 8) + (0 * 16) + (0 * 32) + (0 * 64) + (0 * 128),
+               (0 * 1) + (1 * 2) + (1 * 4) + (0 * 8) + (0 * 16) + (1 * 32) + (0 * 64) + (1 * 128),
+               (0 * 1) + (1 * 2) + (1 * 4) + (1 * 8) + (1 * 16) + (0 * 32) + (0 * 64) + (1 * 128),
+               (0 * 1) + (1 * 2) + (1 * 4) + (0 * 8) + (0 * 16) + (0 * 32) + (1 * 64) + (0 * 128),
+               (0 * 1) + (1 * 2) + (0 * 4) + (1 * 8) + (1 * 16) + (1 * 32) + (1 * 64) + (1 * 128),
+               (0 * 1) + (1 * 2) + (1 * 4) + (1 * 8) + (1 * 16) + (0 * 32) + (0 * 64) + (0 * 128),
+               (0 * 1) + (0 * 2) + (1 * 4) + (1 * 8) + (1 * 16) + (1 * 32) + (0 * 64) + (0 * 128),
+               (1 * 1) + (0 * 2) + (1 * 4) + (1 * 8) + (1 * 16) + (0 * 32) + (0 * 64) + (0 * 128),
+               (0 * 1) + (0 * 2) + (1 * 4) + (0 * 8) + (1 * 16) + (0 * 32) + (0 * 64) + (0 * 128),
+               (1 * 1) + (1 * 2) + (1 * 4) + (0 * 8) + (0 * 16) + (0 * 32) + (0 * 64) + (1 * 128),
+               (0 * 1) + (1 * 2) + (1 * 4) + (0 * 8) + (0 * 16) + (1 * 32) + (1 * 64) + (0 * 128),
+               (1 * 1) + (0 * 2) + (0 * 4) + (1 * 8) + (1 * 16) + (0 * 32) + (0 * 64) + (1 * 128),
+               (1 * 1) + (1 * 2) + (0 * 4) + (0 * 8) + (1 * 16) + (0 * 32) + (1 * 64) + (1 * 128),
+               (0 * 1) + (1 * 2) + (1 * 4) + (1 * 8) + (0 * 16) + (0 * 32) + (1 * 64) + (1 * 128),
+               (0 * 1) + (0 * 2) + (0 * 4) + (0 * 8) + (0 * 16) + (1 * 32) + (1 * 64) + (0 * 128),
+               (0 * 1) + (0 * 2) + (0 * 4) + (0 * 8) + (1 * 16) + (0 * 32) + (0 * 64) + (1 * 128),
+               (0 * 1) + (0 * 2) + (0 * 4) + (1 * 8) + (1 * 16) + (1 * 32) + (0 * 64) + (0 * 128),
+               (1 * 1) + (1 * 2) + (1 * 4) + (1 * 8) + (0 * 16) + (0 * 32) + (1 * 64) + (0 * 128)},
+               "FGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz12345678"},
+       // $ echo -n "GHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz123456789" | sha256sum
+       // 6cb808e9a7fb53fa680824f08554b660d29a4afc9a101f990b4bae3a12b7fbd8
+       {[32]byte{(0 * 1) + (0 * 2) + (1 * 4) + (1 * 8) + (0 * 16) + (1 * 32) + (1 * 64) + (0 * 128),
+               (0 * 1) + (0 * 2) + (0 * 4) + (1 * 8) + (1 * 16) + (1 * 32) + (0 * 64) + (1 * 128),
+               (0 * 1) + (0 * 2) + (0 * 4) + (1 * 8) + (0 * 16) + (0 * 32) + (0 * 64) + (0 * 128),
+               (1 * 1) + (0 * 2) + (0 * 4) + (1 * 8) + (0 * 16) + (1 * 32) + (1 * 64) + (1 * 128),
+               (1 * 1) + (1 * 2) + (1 * 4) + (0 * 8) + (0 * 16) + (1 * 32) + (0 * 64) + (1 * 128),
+               (1 * 1) + (1 * 2) + (0 * 4) + (1 * 8) + (1 * 16) + (1 * 32) + (1 * 64) + (1 * 128),
+               (1 * 1) + (1 * 2) + (0 * 4) + (0 * 8) + (1 * 16) + (0 * 32) + (1 * 64) + (0 * 128),
+               (0 * 1) + (1 * 2) + (0 * 4) + (1 * 8) + (1 * 16) + (1 * 32) + (1 * 64) + (1 * 128),
+               (0 * 1) + (0 * 2) + (0 * 4) + (1 * 8) + (0 * 16) + (1 * 32) + (1 * 64) + (0 * 128),
+               (0 * 1) + (0 * 2) + (0 * 4) + (1 * 8) + (0 * 16) + (0 * 32) + (0 * 64) + (0 * 128),
+               (0 * 1) + (0 * 2) + (1 * 4) + (0 * 8) + (0 * 16) + (1 * 32) + (0 * 64) + (0 * 128),
+               (0 * 1) + (0 * 2) + (0 * 4) + (0 * 8) + (1 * 16) + (1 * 32) + (1 * 64) + (1 * 128),
+               (1 * 1) + (0 * 2) + (1 * 4) + (0 * 8) + (0 * 16) + (0 * 32) + (0 * 64) + (1 * 128),
+               (0 * 1) + (0 * 2) + (1 * 4) + (0 * 8) + (1 * 16) + (0 * 32) + (1 * 64) + (0 * 128),
+               (0 * 1) + (1 * 2) + (1 * 4) + (0 * 8) + (1 * 16) + (1 * 32) + (0 * 64) + (1 * 128),
+               (0 * 1) + (0 * 2) + (0 * 4) + (0 * 8) + (0 * 16) + (1 * 32) + (1 * 64) + (0 * 128),
+               (0 * 1) + (1 * 2) + (0 * 4) + (0 * 8) + (1 * 16) + (0 * 32) + (1 * 64) + (1 * 128),
+               (0 * 1) + (1 * 2) + (0 * 4) + (1 * 8) + (1 * 16) + (0 * 32) + (0 * 64) + (1 * 128),
+               (0 * 1) + (1 * 2) + (0 * 4) + (1 * 8) + (0 * 16) + (0 * 32) + (1 * 64) + (0 * 128),
+               (0 * 1) + (0 * 2) + (1 * 4) + (1 * 8) + (1 * 16) + (1 * 32) + (1 * 64) + (1 * 128),
+               (0 * 1) + (1 * 2) + (0 * 4) + (1 * 8) + (1 * 16) + (0 * 32) + (0 * 64) + (1 * 128),
+               (0 * 1) + (0 * 2) + (0 * 4) + (0 * 8) + (1 * 16) + (0 * 32) + (0 * 64) + (0 * 128),
+               (1 * 1) + (1 * 2) + (1 * 4) + (1 * 8) + (1 * 16) + (0 * 32) + (0 * 64) + (0 * 128),
+               (1 * 1) + (0 * 2) + (0 * 4) + (1 * 8) + (1 * 16) + (0 * 32) + (0 * 64) + (1 * 128),
+               (1 * 1) + (1 * 2) + (0 * 4) + (1 * 8) + (0 * 16) + (0 * 32) + (0 * 64) + (0 * 128),
+               (1 * 1) + (1 * 2) + (0 * 4) + (1 * 8) + (0 * 16) + (0 * 32) + (1 * 64) + (0 * 128),
+               (0 * 1) + (1 * 2) + (1 * 4) + (1 * 8) + (0 * 16) + (1 * 32) + (0 * 64) + (1 * 128),
+               (0 * 1) + (1 * 2) + (0 * 4) + (1 * 8) + (1 * 16) + (1 * 32) + (0 * 64) + (0 * 128),
+               (0 * 1) + (1 * 2) + (0 * 4) + (0 * 8) + (1 * 16) + (0 * 32) + (0 * 64) + (0 * 128),
+               (1 * 1) + (1 * 2) + (1 * 4) + (0 * 8) + (1 * 16) + (1 * 32) + (0 * 64) + (1 * 128),
+               (1 * 1) + (1 * 2) + (0 * 4) + (1 * 8) + (1 * 16) + (1 * 32) + (1 * 64) + (1 * 128),
+               (0 * 1) + (0 * 2) + (0 * 4) + (1 * 8) + (1 * 16) + (0 * 32) + (1 * 64) + (1 * 128)},
+               "GHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz123456789"},
+       // $ echo -n "HIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz1234567890" | sha256sum
+       // 84e8dd1afa78db222860ed40b6fcfc7a269469365f81f5712fb589555bdb01fe
+       {[32]byte{(0 * 1) + (0 * 2) + (1 * 4) + (0 * 8) + (0 * 16) + (0 * 32) + (0 * 64) + (1 * 128),
+               (0 * 1) + (0 * 2) + (0 * 4) + (1 * 8) + (0 * 16) + (1 * 32) + (1 * 64) + (1 * 128),
+               (1 * 1) + (0 * 2) + (1 * 4) + (1 * 8) + (1 * 16) + (0 * 32) + (1 * 64) + (1 * 128),
+               (0 * 1) + (1 * 2) + (0 * 4) + (1 * 8) + (1 * 16) + (0 * 32) + (0 * 64) + (0 * 128),
+               (0 * 1) + (1 * 2) + (0 * 4) + (1 * 8) + (1 * 16) + (1 * 32) + (1 * 64) + (1 * 128),
+               (0 * 1) + (0 * 2) + (0 * 4) + (1 * 8) + (1 * 16) + (1 * 32) + (1 * 64) + (0 * 128),
+               (1 * 1) + (1 * 2) + (0 * 4) + (1 * 8) + (1 * 16) + (0 * 32) + (1 * 64) + (1 * 128),
+               (0 * 1) + (1 * 2) + (0 * 4) + (0 * 8) + (0 * 16) + (1 * 32) + (0 * 64) + (0 * 128),
+               (0 * 1) + (0 * 2) + (0 * 4) + (1 * 8) + (0 * 16) + (1 * 32) + (0 * 64) + (0 * 128),
+               (0 * 1) + (0 * 2) + (0 * 4) + (0 * 8) + (0 * 16) + (1 * 32) + (1 * 64) + (0 * 128),
+               (1 * 1) + (0 * 2) + (1 * 4) + (1 * 8) + (0 * 16) + (1 * 32) + (1 * 64) + (1 * 128),
+               (0 * 1) + (0 * 2) + (0 * 4) + (0 * 8) + (0 * 16) + (0 * 32) + (1 * 64) + (0 * 128),
+               (0 * 1) + (1 * 2) + (1 * 4) + (0 * 8) + (1 * 16) + (1 * 32) + (0 * 64) + (1 * 128),
+               (0 * 1) + (0 * 2) + (1 * 4) + (1 * 8) + (1 * 16) + (1 * 32) + (1 * 64) + (1 * 128),
+               (0 * 1) + (0 * 2) + (1 * 4) + (1 * 8) + (1 * 16) + (1 * 32) + (1 * 64) + (1 * 128),
+               (0 * 1) + (1 * 2) + (0 * 4) + (1 * 8) + (1 * 16) + (1 * 32) + (1 * 64) + (0 * 128),
+               (0 * 1) + (1 * 2) + (1 * 4) + (0 * 8) + (0 * 16) + (1 * 32) + (0 * 64) + (0 * 128),
+               (0 * 1) + (0 * 2) + (1 * 4) + (0 * 8) + (1 * 16) + (0 * 32) + (0 * 64) + (1 * 128),
+               (1 * 1) + (0 * 2) + (0 * 4) + (1 * 8) + (0 * 16) + (1 * 32) + (1 * 64) + (0 * 128),
+               (0 * 1) + (1 * 2) + (1 * 4) + (0 * 8) + (1 * 16) + (1 * 32) + (0 * 64) + (0 * 128),
+               (1 * 1) + (1 * 2) + (1 * 4) + (1 * 8) + (1 * 16) + (0 * 32) + (1 * 64) + (0 * 128),
+               (1 * 1) + (0 * 2) + (0 * 4) + (0 * 8) + (0 * 16) + (0 * 32) + (0 * 64) + (1 * 128),
+               (1 * 1) + (0 * 2) + (1 * 4) + (0 * 8) + (1 * 16) + (1 * 32) + (1 * 64) + (1 * 128),
+               (1 * 1) + (0 * 2) + (0 * 4) + (0 * 8) + (1 * 16) + (1 * 32) + (1 * 64) + (0 * 128),
+               (1 * 1) + (1 * 2) + (1 * 4) + (1 * 8) + (0 * 16) + (1 * 32) + (0 * 64) + (0 * 128),
+               (1 * 1) + (0 * 2) + (1 * 4) + (0 * 8) + (1 * 16) + (1 * 32) + (0 * 64) + (1 * 128),
+               (1 * 1) + (0 * 2) + (0 * 4) + (1 * 8) + (0 * 16) + (0 * 32) + (0 * 64) + (1 * 128),
+               (1 * 1) + (0 * 2) + (1 * 4) + (0 * 8) + (1 * 16) + (0 * 32) + (1 * 64) + (0 * 128),
+               (1 * 1) + (1 * 2) + (0 * 4) + (1 * 8) + (1 * 16) + (0 * 32) + (1 * 64) + (0 * 128),
+               (1 * 1) + (1 * 2) + (0 * 4) + (1 * 8) + (1 * 16) + (0 * 32) + (1 * 64) + (1 * 128),
+               (1 * 1) + (0 * 2) + (0 * 4) + (0 * 8) + (0 * 16) + (0 * 32) + (0 * 64) + (0 * 128),
+               (0 * 1) + (1 * 2) + (1 * 4) + (1 * 8) + (1 * 16) + (1 * 32) + (1 * 64) + (1 * 128)},
+               "HIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz1234567890"},
+       // $ echo -n "IJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz1234567890A" | sha256sum
+       // accab8e85b6bd178e975aaaa354aed8258bcd6af3e61bd4f12267635856cab0b
+       {[32]byte{(0 * 1) + (0 * 2) + (1 * 4) + (1 * 8) + (0 * 16) + (1 * 32) + (0 * 64) + (1 * 128),
+               (0 * 1) + (1 * 2) + (0 * 4) + (1 * 8) + (0 * 16) + (0 * 32) + (1 * 64) + (1 * 128),
+               (0 * 1) + (0 * 2) + (0 * 4) + (1 * 8) + (1 * 16) + (1 * 32) + (0 * 64) + (1 * 128),
+               (0 * 1) + (0 * 2) + (0 * 4) + (1 * 8) + (0 * 16) + (1 * 32) + (1 * 64) + (1 * 128),
+               (1 * 1) + (1 * 2) + (0 * 4) + (1 * 8) + (1 * 16) + (0 * 32) + (1 * 64) + (0 * 128),
+               (1 * 1) + (1 * 2) + (0 * 4) + (1 * 8) + (0 * 16) + (1 * 32) + (1 * 64) + (0 * 128),
+               (1 * 1) + (0 * 2) + (0 * 4) + (0 * 8) + (1 * 16) + (0 * 32) + (1 * 64) + (1 * 128),
+               (0 * 1) + (0 * 2) + (0 * 4) + (1 * 8) + (1 * 16) + (1 * 32) + (1 * 64) + (0 * 128),
+               (1 * 1) + (0 * 2) + (0 * 4) + (1 * 8) + (0 * 16) + (1 * 32) + (1 * 64) + (1 * 128),
+               (1 * 1) + (0 * 2) + (1 * 4) + (0 * 8) + (1 * 16) + (1 * 32) + (1 * 64) + (0 * 128),
+               (0 * 1) + (1 * 2) + (0 * 4) + (1 * 8) + (0 * 16) + (1 * 32) + (0 * 64) + (1 * 128),
+               (0 * 1) + (1 * 2) + (0 * 4) + (1 * 8) + (0 * 16) + (1 * 32) + (0 * 64) + (1 * 128),
+               (1 * 1) + (0 * 2) + (1 * 4) + (0 * 8) + (1 * 16) + (1 * 32) + (0 * 64) + (0 * 128),
+               (0 * 1) + (1 * 2) + (0 * 4) + (1 * 8) + (0 * 16) + (0 * 32) + (1 * 64) + (0 * 128),
+               (1 * 1) + (0 * 2) + (1 * 4) + (1 * 8) + (0 * 16) + (1 * 32) + (1 * 64) + (1 * 128),
+               (0 * 1) + (1 * 2) + (0 * 4) + (0 * 8) + (0 * 16) + (0 * 32) + (0 * 64) + (1 * 128),
+               (0 * 1) + (0 * 2) + (0 * 4) + (1 * 8) + (1 * 16) + (0 * 32) + (1 * 64) + (0 * 128),
+               (0 * 1) + (0 * 2) + (1 * 4) + (1 * 8) + (1 * 16) + (1 * 32) + (0 * 64) + (1 * 128),
+               (0 * 1) + (1 * 2) + (1 * 4) + (0 * 8) + (1 * 16) + (0 * 32) + (1 * 64) + (1 * 128),
+               (1 * 1) + (1 * 2) + (1 * 4) + (1 * 8) + (0 * 16) + (1 * 32) + (0 * 64) + (1 * 128),
+               (0 * 1) + (1 * 2) + (1 * 4) + (1 * 8) + (1 * 16) + (1 * 32) + (0 * 64) + (0 * 128),
+               (1 * 1) + (0 * 2) + (0 * 4) + (0 * 8) + (0 * 16) + (1 * 32) + (1 * 64) + (0 * 128),
+               (1 * 1) + (0 * 2) + (1 * 4) + (1 * 8) + (1 * 16) + (1 * 32) + (0 * 64) + (1 * 128),
+               (1 * 1) + (1 * 2) + (1 * 4) + (1 * 8) + (0 * 16) + (0 * 32) + (1 * 64) + (0 * 128),
+               (0 * 1) + (1 * 2) + (0 * 4) + (0 * 8) + (1 * 16) + (0 * 32) + (0 * 64) + (0 * 128),
+               (0 * 1) + (1 * 2) + (1 * 4) + (0 * 8) + (0 * 16) + (1 * 32) + (0 * 64) + (0 * 128),
+               (0 * 1) + (1 * 2) + (1 * 4) + (0 * 8) + (1 * 16) + (1 * 32) + (1 * 64) + (0 * 128),
+               (1 * 1) + (0 * 2) + (1 * 4) + (0 * 8) + (1 * 16) + (1 * 32) + (0 * 64) + (0 * 128),
+               (1 * 1) + (0 * 2) + (1 * 4) + (0 * 8) + (0 * 16) + (0 * 32) + (0 * 64) + (1 * 128),
+               (0 * 1) + (0 * 2) + (1 * 4) + (1 * 8) + (0 * 16) + (1 * 32) + (1 * 64) + (0 * 128),
+               (1 * 1) + (1 * 2) + (0 * 4) + (1 * 8) + (0 * 16) + (1 * 32) + (0 * 64) + (1 * 128),
+               (1 * 1) + (1 * 2) + (0 * 4) + (1 * 8) + (0 * 16) + (0 * 32) + (0 * 64) + (0 * 128)},
+               "IJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz1234567890A"},
+       // $ echo -n "JKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz1234567890AB" | sha256sum
+       // 107f5ad8bc5d427246fc5f9c581134b61d8ba447e877df56cddad2bf53789172
+       {[32]byte{(0 * 1) + (0 * 2) + (0 * 4) + (0 * 8) + (1 * 16) + (0 * 32) + (0 * 64) + (0 * 128),
+               (1 * 1) + (1 * 2) + (1 * 4) + (1 * 8) + (1 * 16) + (1 * 32) + (1 * 64) + (0 * 128),
+               (0 * 1) + (1 * 2) + (0 * 4) + (1 * 8) + (1 * 16) + (0 * 32) + (1 * 64) + (0 * 128),
+               (0 * 1) + (0 * 2) + (0 * 4) + (1 * 8) + (1 * 16) + (0 * 32) + (1 * 64) + (1 * 128),
+               (0 * 1) + (0 * 2) + (1 * 4) + (1 * 8) + (1 * 16) + (1 * 32) + (0 * 64) + (1 * 128),
+               (1 * 1) + (0 * 2) + (1 * 4) + (1 * 8) + (1 * 16) + (0 * 32) + (1 * 64) + (0 * 128),
+               (0 * 1) + (1 * 2) + (0 * 4) + (0 * 8) + (0 * 16) + (0 * 32) + (1 * 64) + (0 * 128),
+               (0 * 1) + (1 * 2) + (0 * 4) + (0 * 8) + (1 * 16) + (1 * 32) + (1 * 64) + (0 * 128),
+               (0 * 1) + (1 * 2) + (1 * 4) + (0 * 8) + (0 * 16) + (0 * 32) + (1 * 64) + (0 * 128),
+               (0 * 1) + (0 * 2) + (1 * 4) + (1 * 8) + (1 * 16) + (1 * 32) + (1 * 64) + (1 * 128),
+               (1 * 1) + (1 * 2) + (1 * 4) + (1 * 8) + (1 * 16) + (0 * 32) + (1 * 64) + (0 * 128),
+               (0 * 1) + (0 * 2) + (1 * 4) + (1 * 8) + (1 * 16) + (0 * 32) + (0 * 64) + (1 * 128),
+               (0 * 1) + (0 * 2) + (0 * 4) + (1 * 8) + (1 * 16) + (0 * 32) + (1 * 64) + (0 * 128),
+               (1 * 1) + (0 * 2) + (0 * 4) + (0 * 8) + (1 * 16) + (0 * 32) + (0 * 64) + (0 * 128),
+               (0 * 1) + (0 * 2) + (1 * 4) + (0 * 8) + (1 * 16) + (1 * 32) + (0 * 64) + (0 * 128),
+               (0 * 1) + (1 * 2) + (1 * 4) + (0 * 8) + (1 * 16) + (1 * 32) + (0 * 64) + (1 * 128),
+               (1 * 1) + (0 * 2) + (1 * 4) + (1 * 8) + (1 * 16) + (0 * 32) + (0 * 64) + (0 * 128),
+               (1 * 1) + (1 * 2) + (0 * 4) + (1 * 8) + (0 * 16) + (0 * 32) + (0 * 64) + (1 * 128),
+               (0 * 1) + (0 * 2) + (1 * 4) + (0 * 8) + (0 * 16) + (1 * 32) + (0 * 64) + (1 * 128),
+               (1 * 1) + (1 * 2) + (1 * 4) + (0 * 8) + (0 * 16) + (0 * 32) + (1 * 64) + (0 * 128),
+               (0 * 1) + (0 * 2) + (0 * 4) + (1 * 8) + (0 * 16) + (1 * 32) + (1 * 64) + (1 * 128),
+               (1 * 1) + (1 * 2) + (1 * 4) + (0 * 8) + (1 * 16) + (1 * 32) + (1 * 64) + (0 * 128),
+               (1 * 1) + (1 * 2) + (1 * 4) + (1 * 8) + (1 * 16) + (0 * 32) + (1 * 64) + (1 * 128),
+               (0 * 1) + (1 * 2) + (1 * 4) + (0 * 8) + (1 * 16) + (0 * 32) + (1 * 64) + (0 * 128),
+               (1 * 1) + (0 * 2) + (1 * 4) + (1 * 8) + (0 * 16) + (0 * 32) + (1 * 64) + (1 * 128),
+               (0 * 1) + (1 * 2) + (0 * 4) + (1 * 8) + (1 * 16) + (0 * 32) + (1 * 64) + (1 * 128),
+               (0 * 1) + (1 * 2) + (0 * 4) + (0 * 8) + (1 * 16) + (0 * 32) + (1 * 64) + (1 * 128),
+               (1 * 1) + (1 * 2) + (1 * 4) + (1 * 8) + (1 * 16) + (1 * 32) + (0 * 64) + (1 * 128),
+               (1 * 1) + (1 * 2) + (0 * 4) + (0 * 8) + (1 * 16) + (0 * 32) + (1 * 64) + (0 * 128),
+               (0 * 1) + (0 * 2) + (0 * 4) + (1 * 8) + (1 * 16) + (1 * 32) + (1 * 64) + (0 * 128),
+               (1 * 1) + (0 * 2) + (0 * 4) + (0 * 8) + (1 * 16) + (0 * 32) + (0 * 64) + (1 * 128),
+               (0 * 1) + (1 * 2) + (0 * 4) + (0 * 8) + (1 * 16) + (1 * 32) + (1 * 64) + (0 * 128)},
+               "JKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz1234567890AB"},
+       // $ echo -n "KLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz1234567890ABC" | sha256sum
+       // 7666f65b234f78aa537c8d098b181091ce8b7866a0285b52e6bf31b6f21ca9bb
+       {[32]byte{(0 * 1) + (1 * 2) + (1 * 4) + (0 * 8) + (1 * 16) + (1 * 32) + (1 * 64) + (0 * 128),
+               (0 * 1) + (1 * 2) + (1 * 4) + (0 * 8) + (0 * 16) + (1 * 32) + (1 * 64) + (0 * 128),
+               (0 * 1) + (1 * 2) + (1 * 4) + (0 * 8) + (1 * 16) + (1 * 32) + (1 * 64) + (1 * 128),
+               (1 * 1) + (1 * 2) + (0 * 4) + (1 * 8) + (1 * 16) + (0 * 32) + (1 * 64) + (0 * 128),
+               (1 * 1) + (1 * 2) + (0 * 4) + (0 * 8) + (0 * 16) + (1 * 32) + (0 * 64) + (0 * 128),
+               (1 * 1) + (1 * 2) + (1 * 4) + (1 * 8) + (0 * 16) + (0 * 32) + (1 * 64) + (0 * 128),
+               (0 * 1) + (0 * 2) + (0 * 4) + (1 * 8) + (1 * 16) + (1 * 32) + (1 * 64) + (0 * 128),
+               (0 * 1) + (1 * 2) + (0 * 4) + (1 * 8) + (0 * 16) + (1 * 32) + (0 * 64) + (1 * 128),
+               (1 * 1) + (1 * 2) + (0 * 4) + (0 * 8) + (1 * 16) + (0 * 32) + (1 * 64) + (0 * 128),
+               (0 * 1) + (0 * 2) + (1 * 4) + (1 * 8) + (1 * 16) + (1 * 32) + (1 * 64) + (0 * 128),
+               (1 * 1) + (0 * 2) + (1 * 4) + (1 * 8) + (0 * 16) + (0 * 32) + (0 * 64) + (1 * 128),
+               (1 * 1) + (0 * 2) + (0 * 4) + (1 * 8) + (0 * 16) + (0 * 32) + (0 * 64) + (0 * 128),
+               (1 * 1) + (1 * 2) + (0 * 4) + (1 * 8) + (0 * 16) + (0 * 32) + (0 * 64) + (1 * 128),
+               (0 * 1) + (0 * 2) + (0 * 4) + (1 * 8) + (1 * 16) + (0 * 32) + (0 * 64) + (0 * 128),
+               (0 * 1) + (0 * 2) + (0 * 4) + (0 * 8) + (1 * 16) + (0 * 32) + (0 * 64) + (0 * 128),
+               (1 * 1) + (0 * 2) + (0 * 4) + (0 * 8) + (1 * 16) + (0 * 32) + (0 * 64) + (1 * 128),
+               (0 * 1) + (1 * 2) + (1 * 4) + (1 * 8) + (0 * 16) + (0 * 32) + (1 * 64) + (1 * 128),
+               (1 * 1) + (1 * 2) + (0 * 4) + (1 * 8) + (0 * 16) + (0 * 32) + (0 * 64) + (1 * 128),
+               (0 * 1) + (0 * 2) + (0 * 4) + (1 * 8) + (1 * 16) + (1 * 32) + (1 * 64) + (0 * 128),
+               (0 * 1) + (1 * 2) + (1 * 4) + (0 * 8) + (0 * 16) + (1 * 32) + (1 * 64) + (0 * 128),
+               (0 * 1) + (0 * 2) + (0 * 4) + (0 * 8) + (0 * 16) + (1 * 32) + (0 * 64) + (1 * 128),
+               (0 * 1) + (0 * 2) + (0 * 4) + (1 * 8) + (0 * 16) + (1 * 32) + (0 * 64) + (0 * 128),
+               (1 * 1) + (1 * 2) + (0 * 4) + (1 * 8) + (1 * 16) + (0 * 32) + (1 * 64) + (0 * 128),
+               (0 * 1) + (1 * 2) + (0 * 4) + (0 * 8) + (1 * 16) + (0 * 32) + (1 * 64) + (0 * 128),
+               (0 * 1) + (1 * 2) + (1 * 4) + (0 * 8) + (0 * 16) + (1 * 32) + (1 * 64) + (1 * 128),
+               (1 * 1) + (1 * 2) + (1 * 4) + (1 * 8) + (1 * 16) + (1 * 32) + (0 * 64) + (1 * 128),
+               (1 * 1) + (0 * 2) + (0 * 4) + (0 * 8) + (1 * 16) + (1 * 32) + (0 * 64) + (0 * 128),
+               (0 * 1) + (1 * 2) + (1 * 4) + (0 * 8) + (1 * 16) + (1 * 32) + (0 * 64) + (1 * 128),
+               (0 * 1) + (1 * 2) + (0 * 4) + (0 * 8) + (1 * 16) + (1 * 32) + (1 * 64) + (1 * 128),
+               (0 * 1) + (0 * 2) + (1 * 4) + (1 * 8) + (1 * 16) + (0 * 32) + (0 * 64) + (0 * 128),
+               (1 * 1) + (0 * 2) + (0 * 4) + (1 * 8) + (0 * 16) + (1 * 32) + (0 * 64) + (1 * 128),
+               (1 * 1) + (1 * 2) + (0 * 4) + (1 * 8) + (1 * 16) + (1 * 32) + (0 * 64) + (1 * 128)},
+               "KLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz1234567890ABC"},
+       // $ echo -n "LMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz1234567890ABCD" | sha256sum
+       // 4eba948ccee7289ab1f01628a1ab756dee39a6894aed217edc9a91a8b35e50ca
+       {[32]byte{(0 * 1) + (1 * 2) + (1 * 4) + (1 * 8) + (0 * 16) + (0 * 32) + (1 * 64) + (0 * 128),
+               (0 * 1) + (1 * 2) + (0 * 4) + (1 * 8) + (1 * 16) + (1 * 32) + (0 * 64) + (1 * 128),
+               (0 * 1) + (0 * 2) + (1 * 4) + (0 * 8) + (1 * 16) + (0 * 32) + (0 * 64) + (1 * 128),
+               (0 * 1) + (0 * 2) + (1 * 4) + (1 * 8) + (0 * 16) + (0 * 32) + (0 * 64) + (1 * 128),
+               (0 * 1) + (1 * 2) + (1 * 4) + (1 * 8) + (0 * 16) + (0 * 32) + (1 * 64) + (1 * 128),
+               (1 * 1) + (1 * 2) + (1 * 4) + (0 * 8) + (0 * 16) + (1 * 32) + (1 * 64) + (1 * 128),
+               (0 * 1) + (0 * 2) + (0 * 4) + (1 * 8) + (0 * 16) + (1 * 32) + (0 * 64) + (0 * 128),
+               (0 * 1) + (1 * 2) + (0 * 4) + (1 * 8) + (1 * 16) + (0 * 32) + (0 * 64) + (1 * 128),
+               (1 * 1) + (0 * 2) + (0 * 4) + (0 * 8) + (1 * 16) + (1 * 32) + (0 * 64) + (1 * 128),
+               (0 * 1) + (0 * 2) + (0 * 4) + (0 * 8) + (1 * 16) + (1 * 32) + (1 * 64) + (1 * 128),
+               (0 * 1) + (1 * 2) + (1 * 4) + (0 * 8) + (1 * 16) + (0 * 32) + (0 * 64) + (0 * 128),
+               (0 * 1) + (0 * 2) + (0 * 4) + (1 * 8) + (0 * 16) + (1 * 32) + (0 * 64) + (0 * 128),
+               (1 * 1) + (0 * 2) + (0 * 4) + (0 * 8) + (0 * 16) + (1 * 32) + (0 * 64) + (1 * 128),
+               (1 * 1) + (1 * 2) + (0 * 4) + (1 * 8) + (0 * 16) + (1 * 32) + (0 * 64) + (1 * 128),
+               (1 * 1) + (0 * 2) + (1 * 4) + (0 * 8) + (1 * 16) + (1 * 32) + (1 * 64) + (0 * 128),
+               (1 * 1) + (0 * 2) + (1 * 4) + (1 * 8) + (0 * 16) + (1 * 32) + (1 * 64) + (0 * 128),
+               (0 * 1) + (1 * 2) + (1 * 4) + (1 * 8) + (0 * 16) + (1 * 32) + (1 * 64) + (1 * 128),
+               (1 * 1) + (0 * 2) + (0 * 4) + (1 * 8) + (1 * 16) + (1 * 32) + (0 * 64) + (0 * 128),
+               (0 * 1) + (1 * 2) + (1 * 4) + (0 * 8) + (0 * 16) + (1 * 32) + (0 * 64) + (1 * 128),
+               (1 * 1) + (0 * 2) + (0 * 4) + (1 * 8) + (0 * 16) + (0 * 32) + (0 * 64) + (1 * 128),
+               (0 * 1) + (1 * 2) + (0 * 4) + (1 * 8) + (0 * 16) + (0 * 32) + (1 * 64) + (0 * 128),
+               (1 * 1) + (0 * 2) + (1 * 4) + (1 * 8) + (0 * 16) + (1 * 32) + (1 * 64) + (1 * 128),
+               (1 * 1) + (0 * 2) + (0 * 4) + (0 * 8) + (0 * 16) + (1 * 32) + (0 * 64) + (0 * 128),
+               (0 * 1) + (1 * 2) + (1 * 4) + (1 * 8) + (1 * 16) + (1 * 32) + (1 * 64) + (0 * 128),
+               (0 * 1) + (0 * 2) + (1 * 4) + (1 * 8) + (1 * 16) + (0 * 32) + (1 * 64) + (1 * 128),
+               (0 * 1) + (1 * 2) + (0 * 4) + (1 * 8) + (1 * 16) + (0 * 32) + (0 * 64) + (1 * 128),
+               (1 * 1) + (0 * 2) + (0 * 4) + (0 * 8) + (1 * 16) + (0 * 32) + (0 * 64) + (1 * 128),
+               (0 * 1) + (0 * 2) + (0 * 4) + (1 * 8) + (0 * 16) + (1 * 32) + (0 * 64) + (1 * 128),
+               (1 * 1) + (1 * 2) + (0 * 4) + (0 * 8) + (1 * 16) + (1 * 32) + (0 * 64) + (1 * 128),
+               (0 * 1) + (1 * 2) + (1 * 4) + (1 * 8) + (1 * 16) + (0 * 32) + (1 * 64) + (0 * 128),
+               (0 * 1) + (0 * 2) + (0 * 4) + (0 * 8) + (1 * 16) + (0 * 32) + (1 * 64) + (0 * 128),
+               (0 * 1) + (1 * 2) + (0 * 4) + (1 * 8) + (0 * 16) + (0 * 32) + (1 * 64) + (1 * 128)},
+               "LMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz1234567890ABCD"},
+       // $ echo -n "MNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz1234567890ABCDE" | sha256sum
+       // 5011218873e7ca84871668d26461e449e7033b7959d69cfb5c2fee773c3d432d
+       {[32]byte{(0 * 1) + (0 * 2) + (0 * 4) + (0 * 8) + (1 * 16) + (0 * 32) + (1 * 64) + (0 * 128),
+               (1 * 1) + (0 * 2) + (0 * 4) + (0 * 8) + (1 * 16) + (0 * 32) + (0 * 64) + (0 * 128),
+               (1 * 1) + (0 * 2) + (0 * 4) + (0 * 8) + (0 * 16) + (1 * 32) + (0 * 64) + (0 * 128),
+               (0 * 1) + (0 * 2) + (0 * 4) + (1 * 8) + (0 * 16) + (0 * 32) + (0 * 64) + (1 * 128),
+               (1 * 1) + (1 * 2) + (0 * 4) + (0 * 8) + (1 * 16) + (1 * 32) + (1 * 64) + (0 * 128),
+               (1 * 1) + (1 * 2) + (1 * 4) + (0 * 8) + (0 * 16) + (1 * 32) + (1 * 64) + (1 * 128),
+               (0 * 1) + (1 * 2) + (0 * 4) + (1 * 8) + (0 * 16) + (0 * 32) + (1 * 64) + (1 * 128),
+               (0 * 1) + (0 * 2) + (1 * 4) + (0 * 8) + (0 * 16) + (0 * 32) + (0 * 64) + (1 * 128),
+               (1 * 1) + (1 * 2) + (1 * 4) + (0 * 8) + (0 * 16) + (0 * 32) + (0 * 64) + (1 * 128),
+               (0 * 1) + (1 * 2) + (1 * 4) + (0 * 8) + (1 * 16) + (0 * 32) + (0 * 64) + (0 * 128),
+               (0 * 1) + (0 * 2) + (0 * 4) + (1 * 8) + (0 * 16) + (1 * 32) + (1 * 64) + (0 * 128),
+               (0 * 1) + (1 * 2) + (0 * 4) + (0 * 8) + (1 * 16) + (0 * 32) + (1 * 64) + (1 * 128),
+               (0 * 1) + (0 * 2) + (1 * 4) + (0 * 8) + (0 * 16) + (1 * 32) + (1 * 64) + (0 * 128),
+               (1 * 1) + (0 * 2) + (0 * 4) + (0 * 8) + (0 * 16) + (1 * 32) + (1 * 64) + (0 * 128),
+               (0 * 1) + (0 * 2) + (1 * 4) + (0 * 8) + (0 * 16) + (1 * 32) + (1 * 64) + (1 * 128),
+               (1 * 1) + (0 * 2) + (0 * 4) + (1 * 8) + (0 * 16) + (0 * 32) + (1 * 64) + (0 * 128),
+               (1 * 1) + (1 * 2) + (1 * 4) + (0 * 8) + (0 * 16) + (1 * 32) + (1 * 64) + (1 * 128),
+               (1 * 1) + (1 * 2) + (0 * 4) + (0 * 8) + (0 * 16) + (0 * 32) + (0 * 64) + (0 * 128),
+               (1 * 1) + (1 * 2) + (0 * 4) + (1 * 8) + (1 * 16) + (1 * 32) + (0 * 64) + (0 * 128),
+               (1 * 1) + (0 * 2) + (0 * 4) + (1 * 8) + (1 * 16) + (1 * 32) + (1 * 64) + (0 * 128),
+               (1 * 1) + (0 * 2) + (0 * 4) + (1 * 8) + (1 * 16) + (0 * 32) + (1 * 64) + (0 * 128),
+               (0 * 1) + (1 * 2) + (1 * 4) + (0 * 8) + (1 * 16) + (0 * 32) + (1 * 64) + (1 * 128),
+               (0 * 1) + (0 * 2) + (1 * 4) + (1 * 8) + (1 * 16) + (0 * 32) + (0 * 64) + (1 * 128),
+               (1 * 1) + (1 * 2) + (0 * 4) + (1 * 8) + (1 * 16) + (1 * 32) + (1 * 64) + (1 * 128),
+               (0 * 1) + (0 * 2) + (1 * 4) + (1 * 8) + (1 * 16) + (0 * 32) + (1 * 64) + (0 * 128),
+               (1 * 1) + (1 * 2) + (1 * 4) + (1 * 8) + (0 * 16) + (1 * 32) + (0 * 64) + (0 * 128),
+               (0 * 1) + (1 * 2) + (1 * 4) + (1 * 8) + (0 * 16) + (1 * 32) + (1 * 64) + (1 * 128),
+               (1 * 1) + (1 * 2) + (1 * 4) + (0 * 8) + (1 * 16) + (1 * 32) + (1 * 64) + (0 * 128),
+               (0 * 1) + (0 * 2) + (1 * 4) + (1 * 8) + (1 * 16) + (1 * 32) + (0 * 64) + (0 * 128),
+               (1 * 1) + (0 * 2) + (1 * 4) + (1 * 8) + (1 * 16) + (1 * 32) + (0 * 64) + (0 * 128),
+               (1 * 1) + (1 * 2) + (0 * 4) + (0 * 8) + (0 * 16) + (0 * 32) + (1 * 64) + (0 * 128),
+               (1 * 1) + (0 * 2) + (1 * 4) + (1 * 8) + (0 * 16) + (1 * 32) + (0 * 64) + (0 * 128)},
+               "MNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz1234567890ABCDE"},
+       // $ echo -n "NOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz1234567890ABCDEF" | sha256sum
+       // 6932b4ddaf3696e5d5270739bdbe6ab120bb8034b877bd3a8e5a5d5ca263e1c5
+       {[32]byte{(1 * 1) + (0 * 2) + (0 * 4) + (1 * 8) + (0 * 16) + (1 * 32) + (1 * 64) + (0 * 128),
+               (0 * 1) + (1 * 2) + (0 * 4) + (0 * 8) + (1 * 16) + (1 * 32) + (0 * 64) + (0 * 128),
+               (0 * 1) + (0 * 2) + (1 * 4) + (0 * 8) + (1 * 16) + (1 * 32) + (0 * 64) + (1 * 128),
+               (1 * 1) + (0 * 2) + (1 * 4) + (1 * 8) + (1 * 16) + (0 * 32) + (1 * 64) + (1 * 128),
+               (1 * 1) + (1 * 2) + (1 * 4) + (1 * 8) + (0 * 16) + (1 * 32) + (0 * 64) + (1 * 128),
+               (0 * 1) + (1 * 2) + (1 * 4) + (0 * 8) + (1 * 16) + (1 * 32) + (0 * 64) + (0 * 128),
+               (0 * 1) + (1 * 2) + (1 * 4) + (0 * 8) + (1 * 16) + (0 * 32) + (0 * 64) + (1 * 128),
+               (1 * 1) + (0 * 2) + (1 * 4) + (0 * 8) + (0 * 16) + (1 * 32) + (1 * 64) + (1 * 128),
+               (1 * 1) + (0 * 2) + (1 * 4) + (0 * 8) + (1 * 16) + (0 * 32) + (1 * 64) + (1 * 128),
+               (1 * 1) + (1 * 2) + (1 * 4) + (0 * 8) + (0 * 16) + (1 * 32) + (0 * 64) + (0 * 128),
+               (1 * 1) + (1 * 2) + (1 * 4) + (0 * 8) + (0 * 16) + (0 * 32) + (0 * 64) + (0 * 128),
+               (1 * 1) + (0 * 2) + (0 * 4) + (1 * 8) + (1 * 16) + (1 * 32) + (0 * 64) + (0 * 128),
+               (1 * 1) + (0 * 2) + (1 * 4) + (1 * 8) + (1 * 16) + (1 * 32) + (0 * 64) + (1 * 128),
+               (0 * 1) + (1 * 2) + (1 * 4) + (1 * 8) + (1 * 16) + (1 * 32) + (0 * 64) + (1 * 128),
+               (0 * 1) + (1 * 2) + (0 * 4) + (1 * 8) + (0 * 16) + (1 * 32) + (1 * 64) + (0 * 128),
+               (1 * 1) + (0 * 2) + (0 * 4) + (0 * 8) + (1 * 16) + (1 * 32) + (0 * 64) + (1 * 128),
+               (0 * 1) + (0 * 2) + (0 * 4) + (0 * 8) + (0 * 16) + (1 * 32) + (0 * 64) + (0 * 128),
+               (1 * 1) + (1 * 2) + (0 * 4) + (1 * 8) + (1 * 16) + (1 * 32) + (0 * 64) + (1 * 128),
+               (0 * 1) + (0 * 2) + (0 * 4) + (0 * 8) + (0 * 16) + (0 * 32) + (0 * 64) + (1 * 128),
+               (0 * 1) + (0 * 2) + (1 * 4) + (0 * 8) + (1 * 16) + (1 * 32) + (0 * 64) + (0 * 128),
+               (0 * 1) + (0 * 2) + (0 * 4) + (1 * 8) + (1 * 16) + (1 * 32) + (0 * 64) + (1 * 128),
+               (1 * 1) + (1 * 2) + (1 * 4) + (0 * 8) + (1 * 16) + (1 * 32) + (1 * 64) + (0 * 128),
+               (1 * 1) + (0 * 2) + (1 * 4) + (1 * 8) + (1 * 16) + (1 * 32) + (0 * 64) + (1 * 128),
+               (0 * 1) + (1 * 2) + (0 * 4) + (1 * 8) + (1 * 16) + (1 * 32) + (0 * 64) + (0 * 128),
+               (0 * 1) + (1 * 2) + (1 * 4) + (1 * 8) + (0 * 16) + (0 * 32) + (0 * 64) + (1 * 128),
+               (0 * 1) + (1 * 2) + (0 * 4) + (1 * 8) + (1 * 16) + (0 * 32) + (1 * 64) + (0 * 128),
+               (1 * 1) + (0 * 2) + (1 * 4) + (1 * 8) + (1 * 16) + (0 * 32) + (1 * 64) + (0 * 128),
+               (0 * 1) + (0 * 2) + (1 * 4) + (1 * 8) + (1 * 16) + (0 * 32) + (1 * 64) + (0 * 128),
+               (0 * 1) + (1 * 2) + (0 * 4) + (0 * 8) + (0 * 16) + (1 * 32) + (0 * 64) + (1 * 128),
+               (1 * 1) + (1 * 2) + (0 * 4) + (0 * 8) + (0 * 16) + (1 * 32) + (1 * 64) + (0 * 128),
+               (1 * 1) + (0 * 2) + (0 * 4) + (0 * 8) + (0 * 16) + (1 * 32) + (1 * 64) + (1 * 128),
+               (1 * 1) + (0 * 2) + (1 * 4) + (0 * 8) + (0 * 16) + (0 * 32) + (1 * 64) + (1 * 128)},
+               "NOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz1234567890ABCDEF"},
+       // $ echo -n "OPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz1234567890ABCDEFG" | sha256sum
+       // 91bb1bcbfcb4c093aab255a0b8c8b5b93605e2f51dd6b0898b70b9f3c10fc1f9
+       {[32]byte{(1 * 1) + (0 * 2) + (0 * 4) + (0 * 8) + (1 * 16) + (0 * 32) + (0 * 64) + (1 * 128),
+               (1 * 1) + (1 * 2) + (0 * 4) + (1 * 8) + (1 * 16) + (1 * 32) + (0 * 64) + (1 * 128),
+               (1 * 1) + (1 * 2) + (0 * 4) + (1 * 8) + (1 * 16) + (0 * 32) + (0 * 64) + (0 * 128),
+               (1 * 1) + (1 * 2) + (0 * 4) + (1 * 8) + (0 * 16) + (0 * 32) + (1 * 64) + (1 * 128),
+               (0 * 1) + (0 * 2) + (1 * 4) + (1 * 8) + (1 * 16) + (1 * 32) + (1 * 64) + (1 * 128),
+               (0 * 1) + (0 * 2) + (1 * 4) + (0 * 8) + (1 * 16) + (1 * 32) + (0 * 64) + (1 * 128),
+               (0 * 1) + (0 * 2) + (0 * 4) + (0 * 8) + (0 * 16) + (0 * 32) + (1 * 64) + (1 * 128),
+               (1 * 1) + (1 * 2) + (0 * 4) + (0 * 8) + (1 * 16) + (0 * 32) + (0 * 64) + (1 * 128),
+               (0 * 1) + (1 * 2) + (0 * 4) + (1 * 8) + (0 * 16) + (1 * 32) + (0 * 64) + (1 * 128),
+               (0 * 1) + (1 * 2) + (0 * 4) + (0 * 8) + (1 * 16) + (1 * 32) + (0 * 64) + (1 * 128),
+               (1 * 1) + (0 * 2) + (1 * 4) + (0 * 8) + (1 * 16) + (0 * 32) + (1 * 64) + (0 * 128),
+               (0 * 1) + (0 * 2) + (0 * 4) + (0 * 8) + (0 * 16) + (1 * 32) + (0 * 64) + (1 * 128),
+               (0 * 1) + (0 * 2) + (0 * 4) + (1 * 8) + (1 * 16) + (1 * 32) + (0 * 64) + (1 * 128),
+               (0 * 1) + (0 * 2) + (0 * 4) + (1 * 8) + (0 * 16) + (0 * 32) + (1 * 64) + (1 * 128),
+               (1 * 1) + (0 * 2) + (1 * 4) + (0 * 8) + (1 * 16) + (1 * 32) + (0 * 64) + (1 * 128),
+               (1 * 1) + (0 * 2) + (0 * 4) + (1 * 8) + (1 * 16) + (1 * 32) + (0 * 64) + (1 * 128),
+               (0 * 1) + (1 * 2) + (1 * 4) + (0 * 8) + (1 * 16) + (1 * 32) + (0 * 64) + (0 * 128),
+               (1 * 1) + (0 * 2) + (1 * 4) + (0 * 8) + (0 * 16) + (0 * 32) + (0 * 64) + (0 * 128),
+               (0 * 1) + (1 * 2) + (0 * 4) + (0 * 8) + (0 * 16) + (1 * 32) + (1 * 64) + (1 * 128),
+               (1 * 1) + (0 * 2) + (1 * 4) + (0 * 8) + (1 * 16) + (1 * 32) + (1 * 64) + (1 * 128),
+               (1 * 1) + (0 * 2) + (1 * 4) + (1 * 8) + (1 * 16) + (0 * 32) + (0 * 64) + (0 * 128),
+               (0 * 1) + (1 * 2) + (1 * 4) + (0 * 8) + (1 * 16) + (0 * 32) + (1 * 64) + (1 * 128),
+               (0 * 1) + (0 * 2) + (0 * 4) + (0 * 8) + (1 * 16) + (1 * 32) + (0 * 64) + (1 * 128),
+               (1 * 1) + (0 * 2) + (0 * 4) + (1 * 8) + (0 * 16) + (0 * 32) + (0 * 64) + (1 * 128),
+               (1 * 1) + (1 * 2) + (0 * 4) + (1 * 8) + (0 * 16) + (0 * 32) + (0 * 64) + (1 * 128),
+               (0 * 1) + (0 * 2) + (0 * 4) + (0 * 8) + (1 * 16) + (1 * 32) + (1 * 64) + (0 * 128),
+               (1 * 1) + (0 * 2) + (0 * 4) + (1 * 8) + (1 * 16) + (1 * 32) + (0 * 64) + (1 * 128),
+               (1 * 1) + (1 * 2) + (0 * 4) + (0 * 8) + (1 * 16) + (1 * 32) + (1 * 64) + (1 * 128),
+               (1 * 1) + (0 * 2) + (0 * 4) + (0 * 8) + (0 * 16) + (0 * 32) + (1 * 64) + (1 * 128),
+               (1 * 1) + (1 * 2) + (1 * 4) + (1 * 8) + (0 * 16) + (0 * 32) + (0 * 64) + (0 * 128),
+               (1 * 1) + (0 * 2) + (0 * 4) + (0 * 8) + (0 * 16) + (0 * 32) + (1 * 64) + (1 * 128),
+               (1 * 1) + (0 * 2) + (0 * 4) + (1 * 8) + (1 * 16) + (1 * 32) + (1 * 64) + (1 * 128)},
+               "OPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz1234567890ABCDEFG"},
+       // $ echo -n "PQRSTUVWXYZabcdefghijklmnopqrstuvwxyz1234567890ABCDEFGH" | sha256sum
+       // 0d1fa5355388e361c4591bd49c004e3d99044be274db43e91036611365aead02
+       {[32]byte{(1 * 1) + (0 * 2) + (1 * 4) + (1 * 8) + (0 * 16) + (0 * 32) + (0 * 64) + (0 * 128),
+               (1 * 1) + (1 * 2) + (1 * 4) + (1 * 8) + (1 * 16) + (0 * 32) + (0 * 64) + (0 * 128),
+               (1 * 1) + (0 * 2) + (1 * 4) + (0 * 8) + (0 * 16) + (1 * 32) + (0 * 64) + (1 * 128),
+               (1 * 1) + (0 * 2) + (1 * 4) + (0 * 8) + (1 * 16) + (1 * 32) + (0 * 64) + (0 * 128),
+               (1 * 1) + (1 * 2) + (0 * 4) + (0 * 8) + (1 * 16) + (0 * 32) + (1 * 64) + (0 * 128),
+               (0 * 1) + (0 * 2) + (0 * 4) + (1 * 8) + (0 * 16) + (0 * 32) + (0 * 64) + (1 * 128),
+               (1 * 1) + (1 * 2) + (0 * 4) + (0 * 8) + (0 * 16) + (1 * 32) + (1 * 64) + (1 * 128),
+               (1 * 1) + (0 * 2) + (0 * 4) + (0 * 8) + (0 * 16) + (1 * 32) + (1 * 64) + (0 * 128),
+               (0 * 1) + (0 * 2) + (1 * 4) + (0 * 8) + (0 * 16) + (0 * 32) + (1 * 64) + (1 * 128),
+               (1 * 1) + (0 * 2) + (0 * 4) + (1 * 8) + (1 * 16) + (0 * 32) + (1 * 64) + (0 * 128),
+               (1 * 1) + (1 * 2) + (0 * 4) + (1 * 8) + (1 * 16) + (0 * 32) + (0 * 64) + (0 * 128),
+               (0 * 1) + (0 * 2) + (1 * 4) + (0 * 8) + (1 * 16) + (0 * 32) + (1 * 64) + (1 * 128),
+               (0 * 1) + (0 * 2) + (1 * 4) + (1 * 8) + (1 * 16) + (0 * 32) + (0 * 64) + (1 * 128),
+               (0 * 1) + (0 * 2) + (0 * 4) + (0 * 8) + (0 * 16) + (0 * 32) + (0 * 64) + (0 * 128),
+               (0 * 1) + (1 * 2) + (1 * 4) + (1 * 8) + (0 * 16) + (0 * 32) + (1 * 64) + (0 * 128),
+               (1 * 1) + (0 * 2) + (1 * 4) + (1 * 8) + (1 * 16) + (1 * 32) + (0 * 64) + (0 * 128),
+               (1 * 1) + (0 * 2) + (0 * 4) + (1 * 8) + (1 * 16) + (0 * 32) + (0 * 64) + (1 * 128),
+               (0 * 1) + (0 * 2) + (1 * 4) + (0 * 8) + (0 * 16) + (0 * 32) + (0 * 64) + (0 * 128),
+               (1 * 1) + (1 * 2) + (0 * 4) + (1 * 8) + (0 * 16) + (0 * 32) + (1 * 64) + (0 * 128),
+               (0 * 1) + (1 * 2) + (0 * 4) + (0 * 8) + (0 * 16) + (1 * 32) + (1 * 64) + (1 * 128),
+               (0 * 1) + (0 * 2) + (1 * 4) + (0 * 8) + (1 * 16) + (1 * 32) + (1 * 64) + (0 * 128),
+               (1 * 1) + (1 * 2) + (0 * 4) + (1 * 8) + (1 * 16) + (0 * 32) + (1 * 64) + (1 * 128),
+               (1 * 1) + (1 * 2) + (0 * 4) + (0 * 8) + (0 * 16) + (0 * 32) + (1 * 64) + (0 * 128),
+               (1 * 1) + (0 * 2) + (0 * 4) + (1 * 8) + (0 * 16) + (1 * 32) + (1 * 64) + (1 * 128),
+               (0 * 1) + (0 * 2) + (0 * 4) + (0 * 8) + (1 * 16) + (0 * 32) + (0 * 64) + (0 * 128),
+               (0 * 1) + (1 * 2) + (1 * 4) + (0 * 8) + (1 * 16) + (1 * 32) + (0 * 64) + (0 * 128),
+               (1 * 1) + (0 * 2) + (0 * 4) + (0 * 8) + (0 * 16) + (1 * 32) + (1 * 64) + (0 * 128),
+               (1 * 1) + (1 * 2) + (0 * 4) + (0 * 8) + (1 * 16) + (0 * 32) + (0 * 64) + (0 * 128),
+               (1 * 1) + (0 * 2) + (1 * 4) + (0 * 8) + (0 * 16) + (1 * 32) + (1 * 64) + (0 * 128),
+               (0 * 1) + (1 * 2) + (1 * 4) + (1 * 8) + (0 * 16) + (1 * 32) + (0 * 64) + (1 * 128),
+               (1 * 1) + (0 * 2) + (1 * 4) + (1 * 8) + (0 * 16) + (1 * 32) + (0 * 64) + (1 * 128),
+               (0 * 1) + (1 * 2) + (0 * 4) + (0 * 8) + (0 * 16) + (0 * 32) + (0 * 64) + (0 * 128)},
+               "PQRSTUVWXYZabcdefghijklmnopqrstuvwxyz1234567890ABCDEFGH"},
+       // $ echo -n "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" | sha256sum
+       // b6ac3cc10386331c765f04f041c147d0f278f2aed8eaa021e2d0057fc6f6ff9e
+       {[32]byte{(0 * 1) + (1 * 2) + (1 * 4) + (0 * 8) + (1 * 16) + (1 * 32) + (0 * 64) + (1 * 128),
+               (0 * 1) + (0 * 2) + (1 * 4) + (1 * 8) + (0 * 16) + (1 * 32) + (0 * 64) + (1 * 128),
+               (0 * 1) + (0 * 2) + (1 * 4) + (1 * 8) + (1 * 16) + (1 * 32) + (0 * 64) + (0 * 128),
+               (1 * 1) + (0 * 2) + (0 * 4) + (0 * 8) + (0 * 16) + (0 * 32) + (1 * 64) + (1 * 128),
+               (1 * 1) + (1 * 2) + (0 * 4) + (0 * 8) + (0 * 16) + (0 * 32) + (0 * 64) + (0 * 128),
+               (0 * 1) + (1 * 2) + (1 * 4) + (0 * 8) + (0 * 16) + (0 * 32) + (0 * 64) + (1 * 128),
+               (1 * 1) + (1 * 2) + (0 * 4) + (0 * 8) + (1 * 16) + (1 * 32) + (0 * 64) + (0 * 128),
+               (0 * 1) + (0 * 2) + (1 * 4) + (1 * 8) + (1 * 16) + (0 * 32) + (0 * 64) + (0 * 128),
+               (0 * 1) + (1 * 2) + (1 * 4) + (0 * 8) + (1 * 16) + (1 * 32) + (1 * 64) + (0 * 128),
+               (1 * 1) + (1 * 2) + (1 * 4) + (1 * 8) + (1 * 16) + (0 * 32) + (1 * 64) + (0 * 128),
+               (0 * 1) + (0 * 2) + (1 * 4) + (0 * 8) + (0 * 16) + (0 * 32) + (0 * 64) + (0 * 128),
+               (0 * 1) + (0 * 2) + (0 * 4) + (0 * 8) + (1 * 16) + (1 * 32) + (1 * 64) + (1 * 128),
+               (1 * 1) + (0 * 2) + (0 * 4) + (0 * 8) + (0 * 16) + (0 * 32) + (1 * 64) + (0 * 128),
+               (1 * 1) + (0 * 2) + (0 * 4) + (0 * 8) + (0 * 16) + (0 * 32) + (1 * 64) + (1 * 128),
+               (1 * 1) + (1 * 2) + (1 * 4) + (0 * 8) + (0 * 16) + (0 * 32) + (1 * 64) + (0 * 128),
+               (0 * 1) + (0 * 2) + (0 * 4) + (0 * 8) + (1 * 16) + (0 * 32) + (1 * 64) + (1 * 128),
+               (0 * 1) + (1 * 2) + (0 * 4) + (0 * 8) + (1 * 16) + (1 * 32) + (1 * 64) + (1 * 128),
+               (0 * 1) + (0 * 2) + (0 * 4) + (1 * 8) + (1 * 16) + (1 * 32) + (1 * 64) + (0 * 128),
+               (0 * 1) + (1 * 2) + (0 * 4) + (0 * 8) + (1 * 16) + (1 * 32) + (1 * 64) + (1 * 128),
+               (0 * 1) + (1 * 2) + (1 * 4) + (1 * 8) + (0 * 16) + (1 * 32) + (0 * 64) + (1 * 128),
+               (0 * 1) + (0 * 2) + (0 * 4) + (1 * 8) + (1 * 16) + (0 * 32) + (1 * 64) + (1 * 128),
+               (0 * 1) + (1 * 2) + (0 * 4) + (1 * 8) + (0 * 16) + (1 * 32) + (1 * 64) + (1 * 128),
+               (0 * 1) + (0 * 2) + (0 * 4) + (0 * 8) + (0 * 16) + (1 * 32) + (0 * 64) + (1 * 128),
+               (1 * 1) + (0 * 2) + (0 * 4) + (0 * 8) + (0 * 16) + (1 * 32) + (0 * 64) + (0 * 128),
+               (0 * 1) + (1 * 2) + (0 * 4) + (0 * 8) + (0 * 16) + (1 * 32) + (1 * 64) + (1 * 128),
+               (0 * 1) + (0 * 2) + (0 * 4) + (0 * 8) + (1 * 16) + (0 * 32) + (1 * 64) + (1 * 128),
+               (1 * 1) + (0 * 2) + (1 * 4) + (0 * 8) + (0 * 16) + (0 * 32) + (0 * 64) + (0 * 128),
+               (1 * 1) + (1 * 2) + (1 * 4) + (1 * 8) + (1 * 16) + (1 * 32) + (1 * 64) + (0 * 128),
+               (0 * 1) + (1 * 2) + (1 * 4) + (0 * 8) + (0 * 16) + (0 * 32) + (1 * 64) + (1 * 128),
+               (0 * 1) + (1 * 2) + (1 * 4) + (0 * 8) + (1 * 16) + (1 * 32) + (1 * 64) + (1 * 128),
+               (1 * 1) + (1 * 2) + (1 * 4) + (1 * 8) + (1 * 16) + (1 * 32) + (1 * 64) + (1 * 128),
+               (0 * 1) + (1 * 2) + (1 * 4) + (1 * 8) + (1 * 16) + (0 * 32) + (0 * 64) + (1 * 128)},
+               strings.Repeat("A", 128)},
+       // $ echo -n "BBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBB" | sha256sum
+       // 7abaa701a6f4bb8d9ea3872a315597eb6f2ccfd03392d8d10560837f6136d06a
+       {[32]byte{(0 * 1) + (1 * 2) + (0 * 4) + (1 * 8) + (1 * 16) + (1 * 32) + (1 * 64) + (0 * 128),
+               (0 * 1) + (1 * 2) + (0 * 4) + (1 * 8) + (1 * 16) + (1 * 32) + (0 * 64) + (1 * 128),
+               (1 * 1) + (1 * 2) + (1 * 4) + (0 * 8) + (0 * 16) + (1 * 32) + (0 * 64) + (1 * 128),
+               (1 * 1) + (0 * 2) + (0 * 4) + (0 * 8) + (0 * 16) + (0 * 32) + (0 * 64) + (0 * 128),
+               (0 * 1) + (1 * 2) + (1 * 4) + (0 * 8) + (0 * 16) + (1 * 32) + (0 * 64) + (1 * 128),
+               (0 * 1) + (0 * 2) + (1 * 4) + (0 * 8) + (1 * 16) + (1 * 32) + (1 * 64) + (1 * 128),
+               (1 * 1) + (1 * 2) + (0 * 4) + (1 * 8) + (1 * 16) + (1 * 32) + (0 * 64) + (1 * 128),
+               (1 * 1) + (0 * 2) + (1 * 4) + (1 * 8) + (0 * 16) + (0 * 32) + (0 * 64) + (1 * 128),
+               (0 * 1) + (1 * 2) + (1 * 4) + (1 * 8) + (1 * 16) + (0 * 32) + (0 * 64) + (1 * 128),
+               (1 * 1) + (1 * 2) + (0 * 4) + (0 * 8) + (0 * 16) + (1 * 32) + (0 * 64) + (1 * 128),
+               (1 * 1) + (1 * 2) + (1 * 4) + (0 * 8) + (0 * 16) + (0 * 32) + (0 * 64) + (1 * 128),
+               (0 * 1) + (1 * 2) + (0 * 4) + (1 * 8) + (0 * 16) + (1 * 32) + (0 * 64) + (0 * 128),
+               (1 * 1) + (0 * 2) + (0 * 4) + (0 * 8) + (1 * 16) + (1 * 32) + (0 * 64) + (0 * 128),
+               (1 * 1) + (0 * 2) + (1 * 4) + (0 * 8) + (1 * 16) + (0 * 32) + (1 * 64) + (0 * 128),
+               (1 * 1) + (1 * 2) + (1 * 4) + (0 * 8) + (1 * 16) + (0 * 32) + (0 * 64) + (1 * 128),
+               (1 * 1) + (1 * 2) + (0 * 4) + (1 * 8) + (0 * 16) + (1 * 32) + (1 * 64) + (1 * 128),
+               (1 * 1) + (1 * 2) + (1 * 4) + (1 * 8) + (0 * 16) + (1 * 32) + (1 * 64) + (0 * 128),
+               (0 * 1) + (0 * 2) + (1 * 4) + (1 * 8) + (0 * 16) + (1 * 32) + (0 * 64) + (0 * 128),
+               (1 * 1) + (1 * 2) + (1 * 4) + (1 * 8) + (0 * 16) + (0 * 32) + (1 * 64) + (1 * 128),
+               (0 * 1) + (0 * 2) + (0 * 4) + (0 * 8) + (1 * 16) + (0 * 32) + (1 * 64) + (1 * 128),
+               (1 * 1) + (1 * 2) + (0 * 4) + (0 * 8) + (1 * 16) + (1 * 32) + (0 * 64) + (0 * 128),
+               (0 * 1) + (1 * 2) + (0 * 4) + (0 * 8) + (1 * 16) + (0 * 32) + (0 * 64) + (1 * 128),
+               (0 * 1) + (0 * 2) + (0 * 4) + (1 * 8) + (1 * 16) + (0 * 32) + (1 * 64) + (1 * 128),
+               (1 * 1) + (0 * 2) + (0 * 4) + (0 * 8) + (1 * 16) + (0 * 32) + (1 * 64) + (1 * 128),
+               (1 * 1) + (0 * 2) + (1 * 4) + (0 * 8) + (0 * 16) + (0 * 32) + (0 * 64) + (0 * 128),
+               (0 * 1) + (0 * 2) + (0 * 4) + (0 * 8) + (0 * 16) + (1 * 32) + (1 * 64) + (0 * 128),
+               (1 * 1) + (1 * 2) + (0 * 4) + (0 * 8) + (0 * 16) + (0 * 32) + (0 * 64) + (1 * 128),
+               (1 * 1) + (1 * 2) + (1 * 4) + (1 * 8) + (1 * 16) + (1 * 32) + (1 * 64) + (0 * 128),
+               (1 * 1) + (0 * 2) + (0 * 4) + (0 * 8) + (0 * 16) + (1 * 32) + (1 * 64) + (0 * 128),
+               (0 * 1) + (1 * 2) + (1 * 4) + (0 * 8) + (1 * 16) + (1 * 32) + (0 * 64) + (0 * 128),
+               (0 * 1) + (0 * 2) + (0 * 4) + (0 * 8) + (1 * 16) + (0 * 32) + (1 * 64) + (1 * 128),
+               (0 * 1) + (1 * 2) + (0 * 4) + (1 * 8) + (0 * 16) + (1 * 32) + (1 * 64) + (0 * 128)},
+               strings.Repeat("B", 128)},
+       // $ echo -n "CCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCC" | sha256sum
+       // 6e8b9325f779dba60c4c148dee5ded43b19ed20d25d66e338abec53b99174fe8
+       {[32]byte{(0 * 1) + (1 * 2) + (1 * 4) + (1 * 8) + (0 * 16) + (1 * 32) + (1 * 64) + (0 * 128),
+               (1 * 1) + (1 * 2) + (0 * 4) + (1 * 8) + (0 * 16) + (0 * 32) + (0 * 64) + (1 * 128),
+               (1 * 1) + (1 * 2) + (0 * 4) + (0 * 8) + (1 * 16) + (0 * 32) + (0 * 64) + (1 * 128),
+               (1 * 1) + (0 * 2) + (1 * 4) + (0 * 8) + (0 * 16) + (1 * 32) + (0 * 64) + (0 * 128),
+               (1 * 1) + (1 * 2) + (1 * 4) + (0 * 8) + (1 * 16) + (1 * 32) + (1 * 64) + (1 * 128),
+               (1 * 1) + (0 * 2) + (0 * 4) + (1 * 8) + (1 * 16) + (1 * 32) + (1 * 64) + (0 * 128),
+               (1 * 1) + (1 * 2) + (0 * 4) + (1 * 8) + (1 * 16) + (0 * 32) + (1 * 64) + (1 * 128),
+               (0 * 1) + (1 * 2) + (1 * 4) + (0 * 8) + (0 * 16) + (1 * 32) + (0 * 64) + (1 * 128),
+               (0 * 1) + (0 * 2) + (1 * 4) + (1 * 8) + (0 * 16) + (0 * 32) + (0 * 64) + (0 * 128),
+               (0 * 1) + (0 * 2) + (1 * 4) + (1 * 8) + (0 * 16) + (0 * 32) + (1 * 64) + (0 * 128),
+               (0 * 1) + (0 * 2) + (1 * 4) + (0 * 8) + (1 * 16) + (0 * 32) + (0 * 64) + (0 * 128),
+               (1 * 1) + (0 * 2) + (1 * 4) + (1 * 8) + (0 * 16) + (0 * 32) + (0 * 64) + (1 * 128),
+               (0 * 1) + (1 * 2) + (1 * 4) + (1 * 8) + (0 * 16) + (1 * 32) + (1 * 64) + (1 * 128),
+               (1 * 1) + (0 * 2) + (1 * 4) + (1 * 8) + (1 * 16) + (0 * 32) + (1 * 64) + (0 * 128),
+               (1 * 1) + (0 * 2) + (1 * 4) + (1 * 8) + (0 * 16) + (1 * 32) + (1 * 64) + (1 * 128),
+               (1 * 1) + (1 * 2) + (0 * 4) + (0 * 8) + (0 * 16) + (0 * 32) + (1 * 64) + (0 * 128),
+               (1 * 1) + (0 * 2) + (0 * 4) + (0 * 8) + (1 * 16) + (1 * 32) + (0 * 64) + (1 * 128),
+               (0 * 1) + (1 * 2) + (1 * 4) + (1 * 8) + (1 * 16) + (0 * 32) + (0 * 64) + (1 * 128),
+               (0 * 1) + (1 * 2) + (0 * 4) + (0 * 8) + (1 * 16) + (0 * 32) + (1 * 64) + (1 * 128),
+               (1 * 1) + (0 * 2) + (1 * 4) + (1 * 8) + (0 * 16) + (0 * 32) + (0 * 64) + (0 * 128),
+               (1 * 1) + (0 * 2) + (1 * 4) + (0 * 8) + (0 * 16) + (1 * 32) + (0 * 64) + (0 * 128),
+               (0 * 1) + (1 * 2) + (1 * 4) + (0 * 8) + (1 * 16) + (0 * 32) + (1 * 64) + (1 * 128),
+               (0 * 1) + (1 * 2) + (1 * 4) + (1 * 8) + (0 * 16) + (1 * 32) + (1 * 64) + (0 * 128),
+               (1 * 1) + (1 * 2) + (0 * 4) + (0 * 8) + (1 * 16) + (1 * 32) + (0 * 64) + (0 * 128),
+               (0 * 1) + (1 * 2) + (0 * 4) + (1 * 8) + (0 * 16) + (0 * 32) + (0 * 64) + (1 * 128),
+               (0 * 1) + (1 * 2) + (1 * 4) + (1 * 8) + (1 * 16) + (1 * 32) + (0 * 64) + (1 * 128),
+               (1 * 1) + (0 * 2) + (1 * 4) + (0 * 8) + (0 * 16) + (0 * 32) + (1 * 64) + (1 * 128),
+               (1 * 1) + (1 * 2) + (0 * 4) + (1 * 8) + (1 * 16) + (1 * 32) + (0 * 64) + (0 * 128),
+               (1 * 1) + (0 * 2) + (0 * 4) + (1 * 8) + (1 * 16) + (0 * 32) + (0 * 64) + (1 * 128),
+               (1 * 1) + (1 * 2) + (1 * 4) + (0 * 8) + (1 * 16) + (0 * 32) + (0 * 64) + (0 * 128),
+               (1 * 1) + (1 * 2) + (1 * 4) + (1 * 8) + (0 * 16) + (0 * 32) + (1 * 64) + (0 * 128),
+               (0 * 1) + (0 * 2) + (0 * 4) + (1 * 8) + (0 * 16) + (1 * 32) + (1 * 64) + (1 * 128)},
+               strings.Repeat("C", 128)},
+       // $ echo -n "DDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDD" | sha256sum
+       // 7aa020c91ac4d32e17efd9b64648b92e375987e0eae7d0a58544ca1e4fc32c3c
+       {[32]byte{(0 * 1) + (1 * 2) + (0 * 4) + (1 * 8) + (1 * 16) + (1 * 32) + (1 * 64) + (0 * 128),
+               (0 * 1) + (0 * 2) + (0 * 4) + (0 * 8) + (0 * 16) + (1 * 32) + (0 * 64) + (1 * 128),
+               (0 * 1) + (0 * 2) + (0 * 4) + (0 * 8) + (0 * 16) + (1 * 32) + (0 * 64) + (0 * 128),
+               (1 * 1) + (0 * 2) + (0 * 4) + (1 * 8) + (0 * 16) + (0 * 32) + (1 * 64) + (1 * 128),
+               (0 * 1) + (1 * 2) + (0 * 4) + (1 * 8) + (1 * 16) + (0 * 32) + (0 * 64) + (0 * 128),
+               (0 * 1) + (0 * 2) + (1 * 4) + (0 * 8) + (0 * 16) + (0 * 32) + (1 * 64) + (1 * 128),
+               (1 * 1) + (1 * 2) + (0 * 4) + (0 * 8) + (1 * 16) + (0 * 32) + (1 * 64) + (1 * 128),
+               (0 * 1) + (1 * 2) + (1 * 4) + (1 * 8) + (0 * 16) + (1 * 32) + (0 * 64) + (0 * 128),
+               (1 * 1) + (1 * 2) + (1 * 4) + (0 * 8) + (1 * 16) + (0 * 32) + (0 * 64) + (0 * 128),
+               (1 * 1) + (1 * 2) + (1 * 4) + (1 * 8) + (0 * 16) + (1 * 32) + (1 * 64) + (1 * 128),
+               (1 * 1) + (0 * 2) + (0 * 4) + (1 * 8) + (1 * 16) + (0 * 32) + (1 * 64) + (1 * 128),
+               (0 * 1) + (1 * 2) + (1 * 4) + (0 * 8) + (1 * 16) + (1 * 32) + (0 * 64) + (1 * 128),
+               (0 * 1) + (1 * 2) + (1 * 4) + (0 * 8) + (0 * 16) + (0 * 32) + (1 * 64) + (0 * 128),
+               (0 * 1) + (0 * 2) + (0 * 4) + (1 * 8) + (0 * 16) + (0 * 32) + (1 * 64) + (0 * 128),
+               (1 * 1) + (0 * 2) + (0 * 4) + (1 * 8) + (1 * 16) + (1 * 32) + (0 * 64) + (1 * 128),
+               (0 * 1) + (1 * 2) + (1 * 4) + (1 * 8) + (0 * 16) + (1 * 32) + (0 * 64) + (0 * 128),
+               (1 * 1) + (1 * 2) + (1 * 4) + (0 * 8) + (1 * 16) + (1 * 32) + (0 * 64) + (0 * 128),
+               (1 * 1) + (0 * 2) + (0 * 4) + (1 * 8) + (1 * 16) + (0 * 32) + (1 * 64) + (0 * 128),
+               (1 * 1) + (1 * 2) + (1 * 4) + (0 * 8) + (0 * 16) + (0 * 32) + (0 * 64) + (1 * 128),
+               (0 * 1) + (0 * 2) + (0 * 4) + (0 * 8) + (0 * 16) + (1 * 32) + (1 * 64) + (1 * 128),
+               (0 * 1) + (1 * 2) + (0 * 4) + (1 * 8) + (0 * 16) + (1 * 32) + (1 * 64) + (1 * 128),
+               (1 * 1) + (1 * 2) + (1 * 4) + (0 * 8) + (0 * 16) + (1 * 32) + (1 * 64) + (1 * 128),
+               (0 * 1) + (0 * 2) + (0 * 4) + (0 * 8) + (1 * 16) + (0 * 32) + (1 * 64) + (1 * 128),
+               (1 * 1) + (0 * 2) + (1 * 4) + (0 * 8) + (0 * 16) + (1 * 32) + (0 * 64) + (1 * 128),
+               (1 * 1) + (0 * 2) + (1 * 4) + (0 * 8) + (0 * 16) + (0 * 32) + (0 * 64) + (1 * 128),
+               (0 * 1) + (0 * 2) + (1 * 4) + (0 * 8) + (0 * 16) + (0 * 32) + (1 * 64) + (0 * 128),
+               (0 * 1) + (1 * 2) + (0 * 4) + (1 * 8) + (0 * 16) + (0 * 32) + (1 * 64) + (1 * 128),
+               (0 * 1) + (1 * 2) + (1 * 4) + (1 * 8) + (1 * 16) + (0 * 32) + (0 * 64) + (0 * 128),
+               (1 * 1) + (1 * 2) + (1 * 4) + (1 * 8) + (0 * 16) + (0 * 32) + (1 * 64) + (0 * 128),
+               (1 * 1) + (1 * 2) + (0 * 4) + (0 * 8) + (0 * 16) + (0 * 32) + (1 * 64) + (1 * 128),
+               (0 * 1) + (0 * 2) + (1 * 4) + (1 * 8) + (0 * 16) + (1 * 32) + (0 * 64) + (0 * 128),
+               (0 * 1) + (0 * 2) + (1 * 4) + (1 * 8) + (1 * 16) + (1 * 32) + (0 * 64) + (0 * 128)},
+               strings.Repeat("D", 128)},
+       // $ echo -n "EEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEE" | sha256sum
+       // 997f6a2fc44f1400e9f64d7eac11fe99e21f4b7a3fc2ff3ec95c2ef016abb9e5
+       {[32]byte{(1 * 1) + (0 * 2) + (0 * 4) + (1 * 8) + (1 * 16) + (0 * 32) + (0 * 64) + (1 * 128),
+               (1 * 1) + (1 * 2) + (1 * 4) + (1 * 8) + (1 * 16) + (1 * 32) + (1 * 64) + (0 * 128),
+               (0 * 1) + (1 * 2) + (0 * 4) + (1 * 8) + (0 * 16) + (1 * 32) + (1 * 64) + (0 * 128),
+               (1 * 1) + (1 * 2) + (1 * 4) + (1 * 8) + (0 * 16) + (1 * 32) + (0 * 64) + (0 * 128),
+               (0 * 1) + (0 * 2) + (1 * 4) + (0 * 8) + (0 * 16) + (0 * 32) + (1 * 64) + (1 * 128),
+               (1 * 1) + (1 * 2) + (1 * 4) + (1 * 8) + (0 * 16) + (0 * 32) + (1 * 64) + (0 * 128),
+               (0 * 1) + (0 * 2) + (1 * 4) + (0 * 8) + (1 * 16) + (0 * 32) + (0 * 64) + (0 * 128),
+               (0 * 1) + (0 * 2) + (0 * 4) + (0 * 8) + (0 * 16) + (0 * 32) + (0 * 64) + (0 * 128),
+               (1 * 1) + (0 * 2) + (0 * 4) + (1 * 8) + (0 * 16) + (1 * 32) + (1 * 64) + (1 * 128),
+               (0 * 1) + (1 * 2) + (1 * 4) + (0 * 8) + (1 * 16) + (1 * 32) + (1 * 64) + (1 * 128),
+               (1 * 1) + (0 * 2) + (1 * 4) + (1 * 8) + (0 * 16) + (0 * 32) + (1 * 64) + (0 * 128),
+               (0 * 1) + (1 * 2) + (1 * 4) + (1 * 8) + (1 * 16) + (1 * 32) + (1 * 64) + (0 * 128),
+               (0 * 1) + (0 * 2) + (1 * 4) + (1 * 8) + (0 * 16) + (1 * 32) + (0 * 64) + (1 * 128),
+               (1 * 1) + (0 * 2) + (0 * 4) + (0 * 8) + (1 * 16) + (0 * 32) + (0 * 64) + (0 * 128),
+               (0 * 1) + (1 * 2) + (1 * 4) + (1 * 8) + (1 * 16) + (1 * 32) + (1 * 64) + (1 * 128),
+               (1 * 1) + (0 * 2) + (0 * 4) + (1 * 8) + (1 * 16) + (0 * 32) + (0 * 64) + (1 * 128),
+               (0 * 1) + (1 * 2) + (0 * 4) + (0 * 8) + (0 * 16) + (1 * 32) + (1 * 64) + (1 * 128),
+               (1 * 1) + (1 * 2) + (1 * 4) + (1 * 8) + (1 * 16) + (0 * 32) + (0 * 64) + (0 * 128),
+               (1 * 1) + (1 * 2) + (0 * 4) + (1 * 8) + (0 * 16) + (0 * 32) + (1 * 64) + (0 * 128),
+               (0 * 1) + (1 * 2) + (0 * 4) + (1 * 8) + (1 * 16) + (1 * 32) + (1 * 64) + (0 * 128),
+               (1 * 1) + (1 * 2) + (1 * 4) + (1 * 8) + (1 * 16) + (1 * 32) + (0 * 64) + (0 * 128),
+               (0 * 1) + (1 * 2) + (0 * 4) + (0 * 8) + (0 * 16) + (0 * 32) + (1 * 64) + (1 * 128),
+               (1 * 1) + (1 * 2) + (1 * 4) + (1 * 8) + (1 * 16) + (1 * 32) + (1 * 64) + (1 * 128),
+               (0 * 1) + (1 * 2) + (1 * 4) + (1 * 8) + (1 * 16) + (1 * 32) + (0 * 64) + (0 * 128),
+               (1 * 1) + (0 * 2) + (0 * 4) + (1 * 8) + (0 * 16) + (0 * 32) + (1 * 64) + (1 * 128),
+               (0 * 1) + (0 * 2) + (1 * 4) + (1 * 8) + (1 * 16) + (0 * 32) + (1 * 64) + (0 * 128),
+               (0 * 1) + (1 * 2) + (1 * 4) + (1 * 8) + (0 * 16) + (1 * 32) + (0 * 64) + (0 * 128),
+               (0 * 1) + (0 * 2) + (0 * 4) + (0 * 8) + (1 * 16) + (1 * 32) + (1 * 64) + (1 * 128),
+               (0 * 1) + (1 * 2) + (1 * 4) + (0 * 8) + (1 * 16) + (0 * 32) + (0 * 64) + (0 * 128),
+               (1 * 1) + (1 * 2) + (0 * 4) + (1 * 8) + (0 * 16) + (1 * 32) + (0 * 64) + (1 * 128),
+               (1 * 1) + (0 * 2) + (0 * 4) + (1 * 8) + (1 * 16) + (1 * 32) + (0 * 64) + (1 * 128),
+               (1 * 1) + (0 * 2) + (1 * 4) + (0 * 8) + (0 * 16) + (1 * 32) + (1 * 64) + (1 * 128)},
+               strings.Repeat("E", 128)},
+       // $ echo -n "FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF" | sha256sum
+       // 5c6cdeb9ccaa1d9c57662605ab738ec4ecf0467f576d4c2d7fae48710215582a
+       {[32]byte{(0 * 1) + (0 * 2) + (1 * 4) + (1 * 8) + (1 * 16) + (0 * 32) + (1 * 64) + (0 * 128),
+               (0 * 1) + (0 * 2) + (1 * 4) + (1 * 8) + (0 * 16) + (1 * 32) + (1 * 64) + (0 * 128),
+               (0 * 1) + (1 * 2) + (1 * 4) + (1 * 8) + (1 * 16) + (0 * 32) + (1 * 64) + (1 * 128),
+               (1 * 1) + (0 * 2) + (0 * 4) + (1 * 8) + (1 * 16) + (1 * 32) + (0 * 64) + (1 * 128),
+               (0 * 1) + (0 * 2) + (1 * 4) + (1 * 8) + (0 * 16) + (0 * 32) + (1 * 64) + (1 * 128),
+               (0 * 1) + (1 * 2) + (0 * 4) + (1 * 8) + (0 * 16) + (1 * 32) + (0 * 64) + (1 * 128),
+               (1 * 1) + (0 * 2) + (1 * 4) + (1 * 8) + (1 * 16) + (0 * 32) + (0 * 64) + (0 * 128),
+               (0 * 1) + (0 * 2) + (1 * 4) + (1 * 8) + (1 * 16) + (0 * 32) + (0 * 64) + (1 * 128),
+               (1 * 1) + (1 * 2) + (1 * 4) + (0 * 8) + (1 * 16) + (0 * 32) + (1 * 64) + (0 * 128),
+               (0 * 1) + (1 * 2) + (1 * 4) + (0 * 8) + (0 * 16) + (1 * 32) + (1 * 64) + (0 * 128),
+               (0 * 1) + (1 * 2) + (1 * 4) + (0 * 8) + (0 * 16) + (1 * 32) + (0 * 64) + (0 * 128),
+               (1 * 1) + (0 * 2) + (1 * 4) + (0 * 8) + (0 * 16) + (0 * 32) + (0 * 64) + (0 * 128),
+               (1 * 1) + (1 * 2) + (0 * 4) + (1 * 8) + (0 * 16) + (1 * 32) + (0 * 64) + (1 * 128),
+               (1 * 1) + (1 * 2) + (0 * 4) + (0 * 8) + (1 * 16) + (1 * 32) + (1 * 64) + (0 * 128),
+               (0 * 1) + (1 * 2) + (1 * 4) + (1 * 8) + (0 * 16) + (0 * 32) + (0 * 64) + (1 * 128),
+               (0 * 1) + (0 * 2) + (1 * 4) + (0 * 8) + (0 * 16) + (0 * 32) + (1 * 64) + (1 * 128),
+               (0 * 1) + (0 * 2) + (1 * 4) + (1 * 8) + (0 * 16) + (1 * 32) + (1 * 64) + (1 * 128),
+               (0 * 1) + (0 * 2) + (0 * 4) + (0 * 8) + (1 * 16) + (1 * 32) + (1 * 64) + (1 * 128),
+               (0 * 1) + (1 * 2) + (1 * 4) + (0 * 8) + (0 * 16) + (0 * 32) + (1 * 64) + (0 * 128),
+               (1 * 1) + (1 * 2) + (1 * 4) + (1 * 8) + (1 * 16) + (1 * 32) + (1 * 64) + (0 * 128),
+               (1 * 1) + (1 * 2) + (1 * 4) + (0 * 8) + (1 * 16) + (0 * 32) + (1 * 64) + (0 * 128),
+               (1 * 1) + (0 * 2) + (1 * 4) + (1 * 8) + (0 * 16) + (1 * 32) + (1 * 64) + (0 * 128),
+               (0 * 1) + (0 * 2) + (1 * 4) + (1 * 8) + (0 * 16) + (0 * 32) + (1 * 64) + (0 * 128),
+               (1 * 1) + (0 * 2) + (1 * 4) + (1 * 8) + (0 * 16) + (1 * 32) + (0 * 64) + (0 * 128),
+               (1 * 1) + (1 * 2) + (1 * 4) + (1 * 8) + (1 * 16) + (1 * 32) + (1 * 64) + (0 * 128),
+               (0 * 1) + (1 * 2) + (1 * 4) + (1 * 8) + (0 * 16) + (1 * 32) + (0 * 64) + (1 * 128),
+               (0 * 1) + (0 * 2) + (0 * 4) + (1 * 8) + (0 * 16) + (0 * 32) + (1 * 64) + (0 * 128),
+               (1 * 1) + (0 * 2) + (0 * 4) + (0 * 8) + (1 * 16) + (1 * 32) + (1 * 64) + (0 * 128),
+               (0 * 1) + (1 * 2) + (0 * 4) + (0 * 8) + (0 * 16) + (0 * 32) + (0 * 64) + (0 * 128),
+               (1 * 1) + (0 * 2) + (1 * 4) + (0 * 8) + (1 * 16) + (0 * 32) + (0 * 64) + (0 * 128),
+               (0 * 1) + (0 * 2) + (0 * 4) + (1 * 8) + (1 * 16) + (0 * 32) + (1 * 64) + (0 * 128),
+               (0 * 1) + (1 * 2) + (0 * 4) + (1 * 8) + (0 * 16) + (1 * 32) + (0 * 64) + (0 * 128)},
+               strings.Repeat("F", 128)},
+       // $ echo -n "GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG" | sha256sum
+       // 394394b5f0e91a21d1e932f9ed55e098c8b05f3668f77134eeee843fef1d1758
+       {[32]byte{(1 * 1) + (0 * 2) + (0 * 4) + (1 * 8) + (1 * 16) + (1 * 32) + (0 * 64) + (0 * 128),
+               (1 * 1) + (1 * 2) + (0 * 4) + (0 * 8) + (0 * 16) + (0 * 32) + (1 * 64) + (0 * 128),
+               (0 * 1) + (0 * 2) + (1 * 4) + (0 * 8) + (1 * 16) + (0 * 32) + (0 * 64) + (1 * 128),
+               (1 * 1) + (0 * 2) + (1 * 4) + (0 * 8) + (1 * 16) + (1 * 32) + (0 * 64) + (1 * 128),
+               (0 * 1) + (0 * 2) + (0 * 4) + (0 * 8) + (1 * 16) + (1 * 32) + (1 * 64) + (1 * 128),
+               (1 * 1) + (0 * 2) + (0 * 4) + (1 * 8) + (0 * 16) + (1 * 32) + (1 * 64) + (1 * 128),
+               (0 * 1) + (1 * 2) + (0 * 4) + (1 * 8) + (1 * 16) + (0 * 32) + (0 * 64) + (0 * 128),
+               (1 * 1) + (0 * 2) + (0 * 4) + (0 * 8) + (0 * 16) + (1 * 32) + (0 * 64) + (0 * 128),
+               (1 * 1) + (0 * 2) + (0 * 4) + (0 * 8) + (1 * 16) + (0 * 32) + (1 * 64) + (1 * 128),
+               (1 * 1) + (0 * 2) + (0 * 4) + (1 * 8) + (0 * 16) + (1 * 32) + (1 * 64) + (1 * 128),
+               (0 * 1) + (1 * 2) + (0 * 4) + (0 * 8) + (1 * 16) + (1 * 32) + (0 * 64) + (0 * 128),
+               (1 * 1) + (0 * 2) + (0 * 4) + (1 * 8) + (1 * 16) + (1 * 32) + (1 * 64) + (1 * 128),
+               (1 * 1) + (0 * 2) + (1 * 4) + (1 * 8) + (0 * 16) + (1 * 32) + (1 * 64) + (1 * 128),
+               (1 * 1) + (0 * 2) + (1 * 4) + (0 * 8) + (1 * 16) + (0 * 32) + (1 * 64) + (0 * 128),
+               (0 * 1) + (0 * 2) + (0 * 4) + (0 * 8) + (0 * 16) + (1 * 32) + (1 * 64) + (1 * 128),
+               (0 * 1) + (0 * 2) + (0 * 4) + (1 * 8) + (1 * 16) + (0 * 32) + (0 * 64) + (1 * 128),
+               (0 * 1) + (0 * 2) + (0 * 4) + (1 * 8) + (0 * 16) + (0 * 32) + (1 * 64) + (1 * 128),
+               (0 * 1) + (0 * 2) + (0 * 4) + (0 * 8) + (1 * 16) + (1 * 32) + (0 * 64) + (1 * 128),
+               (1 * 1) + (1 * 2) + (1 * 4) + (1 * 8) + (1 * 16) + (0 * 32) + (1 * 64) + (0 * 128),
+               (0 * 1) + (1 * 2) + (1 * 4) + (0 * 8) + (1 * 16) + (1 * 32) + (0 * 64) + (0 * 128),
+               (0 * 1) + (0 * 2) + (0 * 4) + (1 * 8) + (0 * 16) + (1 * 32) + (1 * 64) + (0 * 128),
+               (1 * 1) + (1 * 2) + (1 * 4) + (0 * 8) + (1 * 16) + (1 * 32) + (1 * 64) + (1 * 128),
+               (1 * 1) + (0 * 2) + (0 * 4) + (0 * 8) + (1 * 16) + (1 * 32) + (1 * 64) + (0 * 128),
+               (0 * 1) + (0 * 2) + (1 * 4) + (0 * 8) + (1 * 16) + (1 * 32) + (0 * 64) + (0 * 128),
+               (0 * 1) + (1 * 2) + (1 * 4) + (1 * 8) + (0 * 16) + (1 * 32) + (1 * 64) + (1 * 128),
+               (0 * 1) + (1 * 2) + (1 * 4) + (1 * 8) + (0 * 16) + (1 * 32) + (1 * 64) + (1 * 128),
+               (0 * 1) + (0 * 2) + (1 * 4) + (0 * 8) + (0 * 16) + (0 * 32) + (0 * 64) + (1 * 128),
+               (1 * 1) + (1 * 2) + (1 * 4) + (1 * 8) + (1 * 16) + (1 * 32) + (0 * 64) + (0 * 128),
+               (1 * 1) + (1 * 2) + (1 * 4) + (1 * 8) + (0 * 16) + (1 * 32) + (1 * 64) + (1 * 128),
+               (1 * 1) + (0 * 2) + (1 * 4) + (1 * 8) + (1 * 16) + (0 * 32) + (0 * 64) + (0 * 128),
+               (1 * 1) + (1 * 2) + (1 * 4) + (0 * 8) + (1 * 16) + (0 * 32) + (0 * 64) + (0 * 128),
+               (0 * 1) + (0 * 2) + (0 * 4) + (1 * 8) + (1 * 16) + (0 * 32) + (1 * 64) + (0 * 128)},
+               strings.Repeat("G", 128)},
+       // $ echo -n "HHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHH" | sha256sum
+       // cab546612de68eaa849487342baadbac2561df6380ddac66137ef649e0cdfd0a
+       {[32]byte{(0 * 1) + (1 * 2) + (0 * 4) + (1 * 8) + (0 * 16) + (0 * 32) + (1 * 64) + (1 * 128),
+               (1 * 1) + (0 * 2) + (1 * 4) + (0 * 8) + (1 * 16) + (1 * 32) + (0 * 64) + (1 * 128),
+               (0 * 1) + (1 * 2) + (1 * 4) + (0 * 8) + (0 * 16) + (0 * 32) + (1 * 64) + (0 * 128),
+               (1 * 1) + (0 * 2) + (0 * 4) + (0 * 8) + (0 * 16) + (1 * 32) + (1 * 64) + (0 * 128),
+               (1 * 1) + (0 * 2) + (1 * 4) + (1 * 8) + (0 * 16) + (1 * 32) + (0 * 64) + (0 * 128),
+               (0 * 1) + (1 * 2) + (1 * 4) + (0 * 8) + (0 * 16) + (1 * 32) + (1 * 64) + (1 * 128),
+               (0 * 1) + (1 * 2) + (1 * 4) + (1 * 8) + (0 * 16) + (0 * 32) + (0 * 64) + (1 * 128),
+               (0 * 1) + (1 * 2) + (0 * 4) + (1 * 8) + (0 * 16) + (1 * 32) + (0 * 64) + (1 * 128),
+               (0 * 1) + (0 * 2) + (1 * 4) + (0 * 8) + (0 * 16) + (0 * 32) + (0 * 64) + (1 * 128),
+               (0 * 1) + (0 * 2) + (1 * 4) + (0 * 8) + (1 * 16) + (0 * 32) + (0 * 64) + (1 * 128),
+               (1 * 1) + (1 * 2) + (1 * 4) + (0 * 8) + (0 * 16) + (0 * 32) + (0 * 64) + (1 * 128),
+               (0 * 1) + (0 * 2) + (1 * 4) + (0 * 8) + (1 * 16) + (1 * 32) + (0 * 64) + (0 * 128),
+               (1 * 1) + (1 * 2) + (0 * 4) + (1 * 8) + (0 * 16) + (1 * 32) + (0 * 64) + (0 * 128),
+               (0 * 1) + (1 * 2) + (0 * 4) + (1 * 8) + (0 * 16) + (1 * 32) + (0 * 64) + (1 * 128),
+               (1 * 1) + (1 * 2) + (0 * 4) + (1 * 8) + (1 * 16) + (0 * 32) + (1 * 64) + (1 * 128),
+               (0 * 1) + (0 * 2) + (1 * 4) + (1 * 8) + (0 * 16) + (1 * 32) + (0 * 64) + (1 * 128),
+               (1 * 1) + (0 * 2) + (1 * 4) + (0 * 8) + (0 * 16) + (1 * 32) + (0 * 64) + (0 * 128),
+               (1 * 1) + (0 * 2) + (0 * 4) + (0 * 8) + (0 * 16) + (1 * 32) + (1 * 64) + (0 * 128),
+               (1 * 1) + (1 * 2) + (1 * 4) + (1 * 8) + (1 * 16) + (0 * 32) + (1 * 64) + (1 * 128),
+               (1 * 1) + (1 * 2) + (0 * 4) + (0 * 8) + (0 * 16) + (1 * 32) + (1 * 64) + (0 * 128),
+               (0 * 1) + (0 * 2) + (0 * 4) + (0 * 8) + (0 * 16) + (0 * 32) + (0 * 64) + (1 * 128),
+               (1 * 1) + (0 * 2) + (1 * 4) + (1 * 8) + (1 * 16) + (0 * 32) + (1 * 64) + (1 * 128),
+               (0 * 1) + (0 * 2) + (1 * 4) + (1 * 8) + (0 * 16) + (1 * 32) + (0 * 64) + (1 * 128),
+               (0 * 1) + (1 * 2) + (1 * 4) + (0 * 8) + (0 * 16) + (1 * 32) + (1 * 64) + (0 * 128),
+               (1 * 1) + (1 * 2) + (0 * 4) + (0 * 8) + (1 * 16) + (0 * 32) + (0 * 64) + (0 * 128),
+               (0 * 1) + (1 * 2) + (1 * 4) + (1 * 8) + (1 * 16) + (1 * 32) + (1 * 64) + (0 * 128),
+               (0 * 1) + (1 * 2) + (1 * 4) + (0 * 8) + (1 * 16) + (1 * 32) + (1 * 64) + (1 * 128),
+               (1 * 1) + (0 * 2) + (0 * 4) + (1 * 8) + (0 * 16) + (0 * 32) + (1 * 64) + (0 * 128),
+               (0 * 1) + (0 * 2) + (0 * 4) + (0 * 8) + (0 * 16) + (1 * 32) + (1 * 64) + (1 * 128),
+               (1 * 1) + (0 * 2) + (1 * 4) + (1 * 8) + (0 * 16) + (0 * 32) + (1 * 64) + (1 * 128),
+               (1 * 1) + (0 * 2) + (1 * 4) + (1 * 8) + (1 * 16) + (1 * 32) + (1 * 64) + (1 * 128),
+               (0 * 1) + (1 * 2) + (0 * 4) + (1 * 8) + (0 * 16) + (0 * 32) + (0 * 64) + (0 * 128)},
+               strings.Repeat("H", 128)},
+       // $ echo -n "IIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIII" | sha256sum
+       // 2be96cc28445876429be3005db465d1b9c8ed1432e3ac6f1514b6e9eee725ad8
+       {[32]byte{(1 * 1) + (1 * 2) + (0 * 4) + (1 * 8) + (0 * 16) + (1 * 32) + (0 * 64) + (0 * 128),
+               (1 * 1) + (0 * 2) + (0 * 4) + (1 * 8) + (0 * 16) + (1 * 32) + (1 * 64) + (1 * 128),
+               (0 * 1) + (0 * 2) + (1 * 4) + (1 * 8) + (0 * 16) + (1 * 32) + (1 * 64) + (0 * 128),
+               (0 * 1) + (1 * 2) + (0 * 4) + (0 * 8) + (0 * 16) + (0 * 32) + (1 * 64) + (1 * 128),
+               (0 * 1) + (0 * 2) + (1 * 4) + (0 * 8) + (0 * 16) + (0 * 32) + (0 * 64) + (1 * 128),
+               (1 * 1) + (0 * 2) + (1 * 4) + (0 * 8) + (0 * 16) + (0 * 32) + (1 * 64) + (0 * 128),
+               (1 * 1) + (1 * 2) + (1 * 4) + (0 * 8) + (0 * 16) + (0 * 32) + (0 * 64) + (1 * 128),
+               (0 * 1) + (0 * 2) + (1 * 4) + (0 * 8) + (0 * 16) + (1 * 32) + (1 * 64) + (0 * 128),
+               (1 * 1) + (0 * 2) + (0 * 4) + (1 * 8) + (0 * 16) + (1 * 32) + (0 * 64) + (0 * 128),
+               (0 * 1) + (1 * 2) + (1 * 4) + (1 * 8) + (1 * 16) + (1 * 32) + (0 * 64) + (1 * 128),
+               (0 * 1) + (0 * 2) + (0 * 4) + (0 * 8) + (1 * 16) + (1 * 32) + (0 * 64) + (0 * 128),
+               (1 * 1) + (0 * 2) + (1 * 4) + (0 * 8) + (0 * 16) + (0 * 32) + (0 * 64) + (0 * 128),
+               (1 * 1) + (1 * 2) + (0 * 4) + (1 * 8) + (1 * 16) + (0 * 32) + (1 * 64) + (1 * 128),
+               (0 * 1) + (1 * 2) + (1 * 4) + (0 * 8) + (0 * 16) + (0 * 32) + (1 * 64) + (0 * 128),
+               (1 * 1) + (0 * 2) + (1 * 4) + (1 * 8) + (1 * 16) + (0 * 32) + (1 * 64) + (0 * 128),
+               (1 * 1) + (1 * 2) + (0 * 4) + (1 * 8) + (1 * 16) + (0 * 32) + (0 * 64) + (0 * 128),
+               (0 * 1) + (0 * 2) + (1 * 4) + (1 * 8) + (1 * 16) + (0 * 32) + (0 * 64) + (1 * 128),
+               (0 * 1) + (1 * 2) + (1 * 4) + (1 * 8) + (0 * 16) + (0 * 32) + (0 * 64) + (1 * 128),
+               (1 * 1) + (0 * 2) + (0 * 4) + (0 * 8) + (1 * 16) + (0 * 32) + (1 * 64) + (1 * 128),
+               (1 * 1) + (1 * 2) + (0 * 4) + (0 * 8) + (0 * 16) + (0 * 32) + (1 * 64) + (0 * 128),
+               (0 * 1) + (1 * 2) + (1 * 4) + (1 * 8) + (0 * 16) + (1 * 32) + (0 * 64) + (0 * 128),
+               (0 * 1) + (1 * 2) + (0 * 4) + (1 * 8) + (1 * 16) + (1 * 32) + (0 * 64) + (0 * 128),
+               (0 * 1) + (1 * 2) + (1 * 4) + (0 * 8) + (0 * 16) + (0 * 32) + (1 * 64) + (1 * 128),
+               (1 * 1) + (0 * 2) + (0 * 4) + (0 * 8) + (1 * 16) + (1 * 32) + (1 * 64) + (1 * 128),
+               (1 * 1) + (0 * 2) + (0 * 4) + (0 * 8) + (1 * 16) + (0 * 32) + (1 * 64) + (0 * 128),
+               (1 * 1) + (1 * 2) + (0 * 4) + (1 * 8) + (0 * 16) + (0 * 32) + (1 * 64) + (0 * 128),
+               (0 * 1) + (1 * 2) + (1 * 4) + (1 * 8) + (0 * 16) + (1 * 32) + (1 * 64) + (0 * 128),
+               (0 * 1) + (1 * 2) + (1 * 4) + (1 * 8) + (1 * 16) + (0 * 32) + (0 * 64) + (1 * 128),
+               (0 * 1) + (1 * 2) + (1 * 4) + (1 * 8) + (0 * 16) + (1 * 32) + (1 * 64) + (1 * 128),
+               (0 * 1) + (1 * 2) + (0 * 4) + (0 * 8) + (1 * 16) + (1 * 32) + (1 * 64) + (0 * 128),
+               (0 * 1) + (1 * 2) + (0 * 4) + (1 * 8) + (1 * 16) + (0 * 32) + (1 * 64) + (0 * 128),
+               (0 * 1) + (0 * 2) + (0 * 4) + (1 * 8) + (1 * 16) + (0 * 32) + (1 * 64) + (1 * 128)},
+               strings.Repeat("I", 128)},
+       // $ echo -n "JJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJ" | sha256sum
+       // 238e5f81d54f2af58049b944c4a1b9516a36c2ef1e20887450b3482045714444
+       {[32]byte{(1 * 1) + (1 * 2) + (0 * 4) + (0 * 8) + (0 * 16) + (1 * 32) + (0 * 64) + (0 * 128),
+               (0 * 1) + (1 * 2) + (1 * 4) + (1 * 8) + (0 * 16) + (0 * 32) + (0 * 64) + (1 * 128),
+               (1 * 1) + (1 * 2) + (1 * 4) + (1 * 8) + (1 * 16) + (0 * 32) + (1 * 64) + (0 * 128),
+               (1 * 1) + (0 * 2) + (0 * 4) + (0 * 8) + (0 * 16) + (0 * 32) + (0 * 64) + (1 * 128),
+               (1 * 1) + (0 * 2) + (1 * 4) + (0 * 8) + (1 * 16) + (0 * 32) + (1 * 64) + (1 * 128),
+               (1 * 1) + (1 * 2) + (1 * 4) + (1 * 8) + (0 * 16) + (0 * 32) + (1 * 64) + (0 * 128),
+               (0 * 1) + (1 * 2) + (0 * 4) + (1 * 8) + (0 * 16) + (1 * 32) + (0 * 64) + (0 * 128),
+               (1 * 1) + (0 * 2) + (1 * 4) + (0 * 8) + (1 * 16) + (1 * 32) + (1 * 64) + (1 * 128),
+               (0 * 1) + (0 * 2) + (0 * 4) + (0 * 8) + (0 * 16) + (0 * 32) + (0 * 64) + (1 * 128),
+               (1 * 1) + (0 * 2) + (0 * 4) + (1 * 8) + (0 * 16) + (0 * 32) + (1 * 64) + (0 * 128),
+               (1 * 1) + (0 * 2) + (0 * 4) + (1 * 8) + (1 * 16) + (1 * 32) + (0 * 64) + (1 * 128),
+               (0 * 1) + (0 * 2) + (1 * 4) + (0 * 8) + (0 * 16) + (0 * 32) + (1 * 64) + (0 * 128),
+               (0 * 1) + (0 * 2) + (1 * 4) + (0 * 8) + (0 * 16) + (0 * 32) + (1 * 64) + (1 * 128),
+               (1 * 1) + (0 * 2) + (0 * 4) + (0 * 8) + (0 * 16) + (1 * 32) + (0 * 64) + (1 * 128),
+               (1 * 1) + (0 * 2) + (0 * 4) + (1 * 8) + (1 * 16) + (1 * 32) + (0 * 64) + (1 * 128),
+               (1 * 1) + (0 * 2) + (0 * 4) + (0 * 8) + (1 * 16) + (0 * 32) + (1 * 64) + (0 * 128),
+               (0 * 1) + (1 * 2) + (0 * 4) + (1 * 8) + (0 * 16) + (1 * 32) + (1 * 64) + (0 * 128),
+               (0 * 1) + (1 * 2) + (1 * 4) + (0 * 8) + (1 * 16) + (1 * 32) + (0 * 64) + (0 * 128),
+               (0 * 1) + (1 * 2) + (0 * 4) + (0 * 8) + (0 * 16) + (0 * 32) + (1 * 64) + (1 * 128),
+               (1 * 1) + (1 * 2) + (1 * 4) + (1 * 8) + (0 * 16) + (1 * 32) + (1 * 64) + (1 * 128),
+               (0 * 1) + (1 * 2) + (1 * 4) + (1 * 8) + (1 * 16) + (0 * 32) + (0 * 64) + (0 * 128),
+               (0 * 1) + (0 * 2) + (0 * 4) + (0 * 8) + (0 * 16) + (1 * 32) + (0 * 64) + (0 * 128),
+               (0 * 1) + (0 * 2) + (0 * 4) + (1 * 8) + (0 * 16) + (0 * 32) + (0 * 64) + (1 * 128),
+               (0 * 1) + (0 * 2) + (1 * 4) + (0 * 8) + (1 * 16) + (1 * 32) + (1 * 64) + (0 * 128),
+               (0 * 1) + (0 * 2) + (0 * 4) + (0 * 8) + (1 * 16) + (0 * 32) + (1 * 64) + (0 * 128),
+               (1 * 1) + (1 * 2) + (0 * 4) + (0 * 8) + (1 * 16) + (1 * 32) + (0 * 64) + (1 * 128),
+               (0 * 1) + (0 * 2) + (0 * 4) + (1 * 8) + (0 * 16) + (0 * 32) + (1 * 64) + (0 * 128),
+               (0 * 1) + (0 * 2) + (0 * 4) + (0 * 8) + (0 * 16) + (1 * 32) + (0 * 64) + (0 * 128),
+               (1 * 1) + (0 * 2) + (1 * 4) + (0 * 8) + (0 * 16) + (0 * 32) + (1 * 64) + (0 * 128),
+               (1 * 1) + (0 * 2) + (0 * 4) + (0 * 8) + (1 * 16) + (1 * 32) + (1 * 64) + (0 * 128),
+               (0 * 1) + (0 * 2) + (1 * 4) + (0 * 8) + (0 * 16) + (0 * 32) + (1 * 64) + (0 * 128),
+               (0 * 1) + (0 * 2) + (1 * 4) + (0 * 8) + (0 * 16) + (0 * 32) + (1 * 64) + (0 * 128)},
+               strings.Repeat("J", 128)},
+       // $ echo -n "KKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKK" | sha256sum
+       // f3a5b826c64951661ce22dc67f0f79d13f633f0601aca2f5e1cf1a9f17dffd4f
+       {[32]byte{(1 * 1) + (1 * 2) + (0 * 4) + (0 * 8) + (1 * 16) + (1 * 32) + (1 * 64) + (1 * 128),
+               (1 * 1) + (0 * 2) + (1 * 4) + (0 * 8) + (0 * 16) + (1 * 32) + (0 * 64) + (1 * 128),
+               (0 * 1) + (0 * 2) + (0 * 4) + (1 * 8) + (1 * 16) + (1 * 32) + (0 * 64) + (1 * 128),
+               (0 * 1) + (1 * 2) + (1 * 4) + (0 * 8) + (0 * 16) + (1 * 32) + (0 * 64) + (0 * 128),
+               (0 * 1) + (1 * 2) + (1 * 4) + (0 * 8) + (0 * 16) + (0 * 32) + (1 * 64) + (1 * 128),
+               (1 * 1) + (0 * 2) + (0 * 4) + (1 * 8) + (0 * 16) + (0 * 32) + (1 * 64) + (0 * 128),
+               (1 * 1) + (0 * 2) + (0 * 4) + (0 * 8) + (1 * 16) + (0 * 32) + (1 * 64) + (0 * 128),
+               (0 * 1) + (1 * 2) + (1 * 4) + (0 * 8) + (0 * 16) + (1 * 32) + (1 * 64) + (0 * 128),
+               (0 * 1) + (0 * 2) + (1 * 4) + (1 * 8) + (1 * 16) + (0 * 32) + (0 * 64) + (0 * 128),
+               (0 * 1) + (1 * 2) + (0 * 4) + (0 * 8) + (0 * 16) + (1 * 32) + (1 * 64) + (1 * 128),
+               (1 * 1) + (0 * 2) + (1 * 4) + (1 * 8) + (0 * 16) + (1 * 32) + (0 * 64) + (0 * 128),
+               (0 * 1) + (1 * 2) + (1 * 4) + (0 * 8) + (0 * 16) + (0 * 32) + (1 * 64) + (1 * 128),
+               (1 * 1) + (1 * 2) + (1 * 4) + (1 * 8) + (1 * 16) + (1 * 32) + (1 * 64) + (0 * 128),
+               (1 * 1) + (1 * 2) + (1 * 4) + (1 * 8) + (0 * 16) + (0 * 32) + (0 * 64) + (0 * 128),
+               (1 * 1) + (0 * 2) + (0 * 4) + (1 * 8) + (1 * 16) + (1 * 32) + (1 * 64) + (0 * 128),
+               (1 * 1) + (0 * 2) + (0 * 4) + (0 * 8) + (1 * 16) + (0 * 32) + (1 * 64) + (1 * 128),
+               (1 * 1) + (1 * 2) + (1 * 4) + (1 * 8) + (1 * 16) + (1 * 32) + (0 * 64) + (0 * 128),
+               (1 * 1) + (1 * 2) + (0 * 4) + (0 * 8) + (0 * 16) + (1 * 32) + (1 * 64) + (0 * 128),
+               (1 * 1) + (1 * 2) + (1 * 4) + (1 * 8) + (1 * 16) + (1 * 32) + (0 * 64) + (0 * 128),
+               (0 * 1) + (1 * 2) + (1 * 4) + (0 * 8) + (0 * 16) + (0 * 32) + (0 * 64) + (0 * 128),
+               (1 * 1) + (0 * 2) + (0 * 4) + (0 * 8) + (0 * 16) + (0 * 32) + (0 * 64) + (0 * 128),
+               (0 * 1) + (0 * 2) + (1 * 4) + (1 * 8) + (0 * 16) + (1 * 32) + (0 * 64) + (1 * 128),
+               (0 * 1) + (1 * 2) + (0 * 4) + (0 * 8) + (0 * 16) + (1 * 32) + (0 * 64) + (1 * 128),
+               (1 * 1) + (0 * 2) + (1 * 4) + (0 * 8) + (1 * 16) + (1 * 32) + (1 * 64) + (1 * 128),
+               (1 * 1) + (0 * 2) + (0 * 4) + (0 * 8) + (0 * 16) + (1 * 32) + (1 * 64) + (1 * 128),
+               (1 * 1) + (1 * 2) + (1 * 4) + (1 * 8) + (0 * 16) + (0 * 32) + (1 * 64) + (1 * 128),
+               (0 * 1) + (1 * 2) + (0 * 4) + (1 * 8) + (1 * 16) + (0 * 32) + (0 * 64) + (0 * 128),
+               (1 * 1) + (1 * 2) + (1 * 4) + (1 * 8) + (1 * 16) + (0 * 32) + (0 * 64) + (1 * 128),
+               (1 * 1) + (1 * 2) + (1 * 4) + (0 * 8) + (1 * 16) + (0 * 32) + (0 * 64) + (0 * 128),
+               (1 * 1) + (1 * 2) + (1 * 4) + (1 * 8) + (1 * 16) + (0 * 32) + (1 * 64) + (1 * 128),
+               (1 * 1) + (0 * 2) + (1 * 4) + (1 * 8) + (1 * 16) + (1 * 32) + (1 * 64) + (1 * 128),
+               (1 * 1) + (1 * 2) + (1 * 4) + (1 * 8) + (0 * 16) + (0 * 32) + (1 * 64) + (0 * 128)},
+               strings.Repeat("K", 128)},
+       // $ echo -n "LLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLL" | sha256sum
+       // 1e90c05bedd24dc3e297d5b8fb215b95d8b7f4a040ee912069614c7a3382725d
+       {[32]byte{(0 * 1) + (1 * 2) + (1 * 4) + (1 * 8) + (1 * 16) + (0 * 32) + (0 * 64) + (0 * 128),
+               (0 * 1) + (0 * 2) + (0 * 4) + (0 * 8) + (1 * 16) + (0 * 32) + (0 * 64) + (1 * 128),
+               (0 * 1) + (0 * 2) + (0 * 4) + (0 * 8) + (0 * 16) + (0 * 32) + (1 * 64) + (1 * 128),
+               (1 * 1) + (1 * 2) + (0 * 4) + (1 * 8) + (1 * 16) + (0 * 32) + (1 * 64) + (0 * 128),
+               (1 * 1) + (0 * 2) + (1 * 4) + (1 * 8) + (0 * 16) + (1 * 32) + (1 * 64) + (1 * 128),
+               (0 * 1) + (1 * 2) + (0 * 4) + (0 * 8) + (1 * 16) + (0 * 32) + (1 * 64) + (1 * 128),
+               (1 * 1) + (0 * 2) + (1 * 4) + (1 * 8) + (0 * 16) + (0 * 32) + (1 * 64) + (0 * 128),
+               (1 * 1) + (1 * 2) + (0 * 4) + (0 * 8) + (0 * 16) + (0 * 32) + (1 * 64) + (1 * 128),
+               (0 * 1) + (1 * 2) + (0 * 4) + (0 * 8) + (0 * 16) + (1 * 32) + (1 * 64) + (1 * 128),
+               (1 * 1) + (1 * 2) + (1 * 4) + (0 * 8) + (1 * 16) + (0 * 32) + (0 * 64) + (1 * 128),
+               (1 * 1) + (0 * 2) + (1 * 4) + (0 * 8) + (1 * 16) + (0 * 32) + (1 * 64) + (1 * 128),
+               (0 * 1) + (0 * 2) + (0 * 4) + (1 * 8) + (1 * 16) + (1 * 32) + (0 * 64) + (1 * 128),
+               (1 * 1) + (1 * 2) + (0 * 4) + (1 * 8) + (1 * 16) + (1 * 32) + (1 * 64) + (1 * 128),
+               (1 * 1) + (0 * 2) + (0 * 4) + (0 * 8) + (0 * 16) + (1 * 32) + (0 * 64) + (0 * 128),
+               (1 * 1) + (1 * 2) + (0 * 4) + (1 * 8) + (1 * 16) + (0 * 32) + (1 * 64) + (0 * 128),
+               (1 * 1) + (0 * 2) + (1 * 4) + (0 * 8) + (1 * 16) + (0 * 32) + (0 * 64) + (1 * 128),
+               (0 * 1) + (0 * 2) + (0 * 4) + (1 * 8) + (1 * 16) + (0 * 32) + (1 * 64) + (1 * 128),
+               (1 * 1) + (1 * 2) + (1 * 4) + (0 * 8) + (1 * 16) + (1 * 32) + (0 * 64) + (1 * 128),
+               (0 * 1) + (0 * 2) + (1 * 4) + (0 * 8) + (1 * 16) + (1 * 32) + (1 * 64) + (1 * 128),
+               (0 * 1) + (0 * 2) + (0 * 4) + (0 * 8) + (0 * 16) + (1 * 32) + (0 * 64) + (1 * 128),
+               (0 * 1) + (0 * 2) + (0 * 4) + (0 * 8) + (0 * 16) + (0 * 32) + (1 * 64) + (0 * 128),
+               (0 * 1) + (1 * 2) + (1 * 4) + (1 * 8) + (0 * 16) + (1 * 32) + (1 * 64) + (1 * 128),
+               (1 * 1) + (0 * 2) + (0 * 4) + (0 * 8) + (1 * 16) + (0 * 32) + (0 * 64) + (1 * 128),
+               (0 * 1) + (0 * 2) + (0 * 4) + (0 * 8) + (0 * 16) + (1 * 32) + (0 * 64) + (0 * 128),
+               (1 * 1) + (0 * 2) + (0 * 4) + (1 * 8) + (0 * 16) + (1 * 32) + (1 * 64) + (0 * 128),
+               (1 * 1) + (0 * 2) + (0 * 4) + (0 * 8) + (0 * 16) + (1 * 32) + (1 * 64) + (0 * 128),
+               (0 * 1) + (0 * 2) + (1 * 4) + (1 * 8) + (0 * 16) + (0 * 32) + (1 * 64) + (0 * 128),
+               (0 * 1) + (1 * 2) + (0 * 4) + (1 * 8) + (1 * 16) + (1 * 32) + (1 * 64) + (0 * 128),
+               (1 * 1) + (1 * 2) + (0 * 4) + (0 * 8) + (1 * 16) + (1 * 32) + (0 * 64) + (0 * 128),
+               (0 * 1) + (1 * 2) + (0 * 4) + (0 * 8) + (0 * 16) + (0 * 32) + (0 * 64) + (1 * 128),
+               (0 * 1) + (1 * 2) + (0 * 4) + (0 * 8) + (1 * 16) + (1 * 32) + (1 * 64) + (0 * 128),
+               (1 * 1) + (0 * 2) + (1 * 4) + (1 * 8) + (1 * 16) + (0 * 32) + (1 * 64) + (0 * 128)},
+               strings.Repeat("L", 128)},
+       // $ echo -n "MMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMM" | sha256sum
+       // 96239ac6fb99822797308f18d8455778fb5885103aa5ff59afe2219df657df99
+       {[32]byte{(0 * 1) + (1 * 2) + (1 * 4) + (0 * 8) + (1 * 16) + (0 * 32) + (0 * 64) + (1 * 128),
+               (1 * 1) + (1 * 2) + (0 * 4) + (0 * 8) + (0 * 16) + (1 * 32) + (0 * 64) + (0 * 128),
+               (0 * 1) + (1 * 2) + (0 * 4) + (1 * 8) + (1 * 16) + (0 * 32) + (0 * 64) + (1 * 128),
+               (0 * 1) + (1 * 2) + (1 * 4) + (0 * 8) + (0 * 16) + (0 * 32) + (1 * 64) + (1 * 128),
+               (1 * 1) + (1 * 2) + (0 * 4) + (1 * 8) + (1 * 16) + (1 * 32) + (1 * 64) + (1 * 128),
+               (1 * 1) + (0 * 2) + (0 * 4) + (1 * 8) + (1 * 16) + (0 * 32) + (0 * 64) + (1 * 128),
+               (0 * 1) + (1 * 2) + (0 * 4) + (0 * 8) + (0 * 16) + (0 * 32) + (0 * 64) + (1 * 128),
+               (1 * 1) + (1 * 2) + (1 * 4) + (0 * 8) + (0 * 16) + (1 * 32) + (0 * 64) + (0 * 128),
+               (1 * 1) + (1 * 2) + (1 * 4) + (0 * 8) + (1 * 16) + (0 * 32) + (0 * 64) + (1 * 128),
+               (0 * 1) + (0 * 2) + (0 * 4) + (0 * 8) + (1 * 16) + (1 * 32) + (0 * 64) + (0 * 128),
+               (1 * 1) + (1 * 2) + (1 * 4) + (1 * 8) + (0 * 16) + (0 * 32) + (0 * 64) + (1 * 128),
+               (0 * 1) + (0 * 2) + (0 * 4) + (1 * 8) + (1 * 16) + (0 * 32) + (0 * 64) + (0 * 128),
+               (0 * 1) + (0 * 2) + (0 * 4) + (1 * 8) + (1 * 16) + (0 * 32) + (1 * 64) + (1 * 128),
+               (1 * 1) + (0 * 2) + (1 * 4) + (0 * 8) + (0 * 16) + (0 * 32) + (1 * 64) + (0 * 128),
+               (1 * 1) + (1 * 2) + (1 * 4) + (0 * 8) + (1 * 16) + (0 * 32) + (1 * 64) + (0 * 128),
+               (0 * 1) + (0 * 2) + (0 * 4) + (1 * 8) + (1 * 16) + (1 * 32) + (1 * 64) + (0 * 128),
+               (1 * 1) + (1 * 2) + (0 * 4) + (1 * 8) + (1 * 16) + (1 * 32) + (1 * 64) + (1 * 128),
+               (0 * 1) + (0 * 2) + (0 * 4) + (1 * 8) + (1 * 16) + (0 * 32) + (1 * 64) + (0 * 128),
+               (1 * 1) + (0 * 2) + (1 * 4) + (0 * 8) + (0 * 16) + (0 * 32) + (0 * 64) + (1 * 128),
+               (0 * 1) + (0 * 2) + (0 * 4) + (0 * 8) + (1 * 16) + (0 * 32) + (0 * 64) + (0 * 128),
+               (0 * 1) + (1 * 2) + (0 * 4) + (1 * 8) + (1 * 16) + (1 * 32) + (0 * 64) + (0 * 128),
+               (1 * 1) + (0 * 2) + (1 * 4) + (0 * 8) + (0 * 16) + (1 * 32) + (0 * 64) + (1 * 128),
+               (1 * 1) + (1 * 2) + (1 * 4) + (1 * 8) + (1 * 16) + (1 * 32) + (1 * 64) + (1 * 128),
+               (1 * 1) + (0 * 2) + (0 * 4) + (1 * 8) + (1 * 16) + (0 * 32) + (1 * 64) + (0 * 128),
+               (1 * 1) + (1 * 2) + (1 * 4) + (1 * 8) + (0 * 16) + (1 * 32) + (0 * 64) + (1 * 128),
+               (0 * 1) + (1 * 2) + (0 * 4) + (0 * 8) + (0 * 16) + (1 * 32) + (1 * 64) + (1 * 128),
+               (1 * 1) + (0 * 2) + (0 * 4) + (0 * 8) + (0 * 16) + (1 * 32) + (0 * 64) + (0 * 128),
+               (1 * 1) + (0 * 2) + (1 * 4) + (1 * 8) + (1 * 16) + (0 * 32) + (0 * 64) + (1 * 128),
+               (0 * 1) + (1 * 2) + (1 * 4) + (0 * 8) + (1 * 16) + (1 * 32) + (1 * 64) + (1 * 128),
+               (1 * 1) + (1 * 2) + (1 * 4) + (0 * 8) + (1 * 16) + (0 * 32) + (1 * 64) + (0 * 128),
+               (1 * 1) + (1 * 2) + (1 * 4) + (1 * 8) + (1 * 16) + (0 * 32) + (1 * 64) + (1 * 128),
+               (1 * 1) + (0 * 2) + (0 * 4) + (1 * 8) + (1 * 16) + (0 * 32) + (0 * 64) + (1 * 128)},
+               strings.Repeat("M", 128)},
+       // $ echo -n "NNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNN" | sha256sum
+       // 11e7f5a6f15a4addba9b6b21bc4f8ecbdd969e179335269fc68d3a05f0f3da4a
+       {[32]byte{(1 * 1) + (0 * 2) + (0 * 4) + (0 * 8) + (1 * 16) + (0 * 32) + (0 * 64) + (0 * 128),
+               (1 * 1) + (1 * 2) + (1 * 4) + (0 * 8) + (0 * 16) + (1 * 32) + (1 * 64) + (1 * 128),
+               (1 * 1) + (0 * 2) + (1 * 4) + (0 * 8) + (1 * 16) + (1 * 32) + (1 * 64) + (1 * 128),
+               (0 * 1) + (1 * 2) + (1 * 4) + (0 * 8) + (0 * 16) + (1 * 32) + (0 * 64) + (1 * 128),
+               (1 * 1) + (0 * 2) + (0 * 4) + (0 * 8) + (1 * 16) + (1 * 32) + (1 * 64) + (1 * 128),
+               (0 * 1) + (1 * 2) + (0 * 4) + (1 * 8) + (1 * 16) + (0 * 32) + (1 * 64) + (0 * 128),
+               (0 * 1) + (1 * 2) + (0 * 4) + (1 * 8) + (0 * 16) + (0 * 32) + (1 * 64) + (0 * 128),
+               (1 * 1) + (0 * 2) + (1 * 4) + (1 * 8) + (1 * 16) + (0 * 32) + (1 * 64) + (1 * 128),
+               (0 * 1) + (1 * 2) + (0 * 4) + (1 * 8) + (1 * 16) + (1 * 32) + (0 * 64) + (1 * 128),
+               (1 * 1) + (1 * 2) + (0 * 4) + (1 * 8) + (1 * 16) + (0 * 32) + (0 * 64) + (1 * 128),
+               (1 * 1) + (1 * 2) + (0 * 4) + (1 * 8) + (0 * 16) + (1 * 32) + (1 * 64) + (0 * 128),
+               (1 * 1) + (0 * 2) + (0 * 4) + (0 * 8) + (0 * 16) + (1 * 32) + (0 * 64) + (0 * 128),
+               (0 * 1) + (0 * 2) + (1 * 4) + (1 * 8) + (1 * 16) + (1 * 32) + (0 * 64) + (1 * 128),
+               (1 * 1) + (1 * 2) + (1 * 4) + (1 * 8) + (0 * 16) + (0 * 32) + (1 * 64) + (0 * 128),
+               (0 * 1) + (1 * 2) + (1 * 4) + (1 * 8) + (0 * 16) + (0 * 32) + (0 * 64) + (1 * 128),
+               (1 * 1) + (1 * 2) + (0 * 4) + (1 * 8) + (0 * 16) + (0 * 32) + (1 * 64) + (1 * 128),
+               (1 * 1) + (0 * 2) + (1 * 4) + (1 * 8) + (1 * 16) + (0 * 32) + (1 * 64) + (1 * 128),
+               (0 * 1) + (1 * 2) + (1 * 4) + (0 * 8) + (1 * 16) + (0 * 32) + (0 * 64) + (1 * 128),
+               (0 * 1) + (1 * 2) + (1 * 4) + (1 * 8) + (1 * 16) + (0 * 32) + (0 * 64) + (1 * 128),
+               (1 * 1) + (1 * 2) + (1 * 4) + (0 * 8) + (1 * 16) + (0 * 32) + (0 * 64) + (0 * 128),
+               (1 * 1) + (1 * 2) + (0 * 4) + (0 * 8) + (1 * 16) + (0 * 32) + (0 * 64) + (1 * 128),
+               (1 * 1) + (0 * 2) + (1 * 4) + (0 * 8) + (1 * 16) + (1 * 32) + (0 * 64) + (0 * 128),
+               (0 * 1) + (1 * 2) + (1 * 4) + (0 * 8) + (0 * 16) + (1 * 32) + (0 * 64) + (0 * 128),
+               (1 * 1) + (1 * 2) + (1 * 4) + (1 * 8) + (1 * 16) + (0 * 32) + (0 * 64) + (1 * 128),
+               (0 * 1) + (1 * 2) + (1 * 4) + (0 * 8) + (0 * 16) + (0 * 32) + (1 * 64) + (1 * 128),
+               (1 * 1) + (0 * 2) + (1 * 4) + (1 * 8) + (0 * 16) + (0 * 32) + (0 * 64) + (1 * 128),
+               (0 * 1) + (1 * 2) + (0 * 4) + (1 * 8) + (1 * 16) + (1 * 32) + (0 * 64) + (0 * 128),
+               (1 * 1) + (0 * 2) + (1 * 4) + (0 * 8) + (0 * 16) + (0 * 32) + (0 * 64) + (0 * 128),
+               (0 * 1) + (0 * 2) + (0 * 4) + (0 * 8) + (1 * 16) + (1 * 32) + (1 * 64) + (1 * 128),
+               (1 * 1) + (1 * 2) + (0 * 4) + (0 * 8) + (1 * 16) + (1 * 32) + (1 * 64) + (1 * 128),
+               (0 * 1) + (1 * 2) + (0 * 4) + (1 * 8) + (1 * 16) + (0 * 32) + (1 * 64) + (1 * 128),
+               (0 * 1) + (1 * 2) + (0 * 4) + (1 * 8) + (0 * 16) + (0 * 32) + (1 * 64) + (0 * 128)},
+               strings.Repeat("N", 128)},
+       // $ echo -n "OOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOO" | sha256sum
+       // ae843b7e4e00afeb972bf948a345b319cca8bd0bcaa1428c1c67c88ea663c1e0
+       {[32]byte{(0 * 1) + (1 * 2) + (1 * 4) + (1 * 8) + (0 * 16) + (1 * 32) + (0 * 64) + (1 * 128),
+               (0 * 1) + (0 * 2) + (1 * 4) + (0 * 8) + (0 * 16) + (0 * 32) + (0 * 64) + (1 * 128),
+               (1 * 1) + (1 * 2) + (0 * 4) + (1 * 8) + (1 * 16) + (1 * 32) + (0 * 64) + (0 * 128),
+               (0 * 1) + (1 * 2) + (1 * 4) + (1 * 8) + (1 * 16) + (1 * 32) + (1 * 64) + (0 * 128),
+               (0 * 1) + (1 * 2) + (1 * 4) + (1 * 8) + (0 * 16) + (0 * 32) + (1 * 64) + (0 * 128),
+               (0 * 1) + (0 * 2) + (0 * 4) + (0 * 8) + (0 * 16) + (0 * 32) + (0 * 64) + (0 * 128),
+               (1 * 1) + (1 * 2) + (1 * 4) + (1 * 8) + (0 * 16) + (1 * 32) + (0 * 64) + (1 * 128),
+               (1 * 1) + (1 * 2) + (0 * 4) + (1 * 8) + (0 * 16) + (1 * 32) + (1 * 64) + (1 * 128),
+               (1 * 1) + (1 * 2) + (1 * 4) + (0 * 8) + (1 * 16) + (0 * 32) + (0 * 64) + (1 * 128),
+               (1 * 1) + (1 * 2) + (0 * 4) + (1 * 8) + (0 * 16) + (1 * 32) + (0 * 64) + (0 * 128),
+               (1 * 1) + (0 * 2) + (0 * 4) + (1 * 8) + (1 * 16) + (1 * 32) + (1 * 64) + (1 * 128),
+               (0 * 1) + (0 * 2) + (0 * 4) + (1 * 8) + (0 * 16) + (0 * 32) + (1 * 64) + (0 * 128),
+               (1 * 1) + (1 * 2) + (0 * 4) + (0 * 8) + (0 * 16) + (1 * 32) + (0 * 64) + (1 * 128),
+               (1 * 1) + (0 * 2) + (1 * 4) + (0 * 8) + (0 * 16) + (0 * 32) + (1 * 64) + (0 * 128),
+               (1 * 1) + (1 * 2) + (0 * 4) + (0 * 8) + (1 * 16) + (1 * 32) + (0 * 64) + (1 * 128),
+               (1 * 1) + (0 * 2) + (0 * 4) + (1 * 8) + (1 * 16) + (0 * 32) + (0 * 64) + (0 * 128),
+               (0 * 1) + (0 * 2) + (1 * 4) + (1 * 8) + (0 * 16) + (0 * 32) + (1 * 64) + (1 * 128),
+               (0 * 1) + (0 * 2) + (0 * 4) + (1 * 8) + (0 * 16) + (1 * 32) + (0 * 64) + (1 * 128),
+               (1 * 1) + (0 * 2) + (1 * 4) + (1 * 8) + (1 * 16) + (1 * 32) + (0 * 64) + (1 * 128),
+               (1 * 1) + (1 * 2) + (0 * 4) + (1 * 8) + (0 * 16) + (0 * 32) + (0 * 64) + (0 * 128),
+               (0 * 1) + (1 * 2) + (0 * 4) + (1 * 8) + (0 * 16) + (0 * 32) + (1 * 64) + (1 * 128),
+               (1 * 1) + (0 * 2) + (0 * 4) + (0 * 8) + (0 * 16) + (1 * 32) + (0 * 64) + (1 * 128),
+               (0 * 1) + (1 * 2) + (0 * 4) + (0 * 8) + (0 * 16) + (0 * 32) + (1 * 64) + (0 * 128),
+               (0 * 1) + (0 * 2) + (1 * 4) + (1 * 8) + (0 * 16) + (0 * 32) + (0 * 64) + (1 * 128),
+               (0 * 1) + (0 * 2) + (1 * 4) + (1 * 8) + (1 * 16) + (0 * 32) + (0 * 64) + (0 * 128),
+               (1 * 1) + (1 * 2) + (1 * 4) + (0 * 8) + (0 * 16) + (1 * 32) + (1 * 64) + (0 * 128),
+               (0 * 1) + (0 * 2) + (0 * 4) + (1 * 8) + (0 * 16) + (0 * 32) + (1 * 64) + (1 * 128),
+               (0 * 1) + (1 * 2) + (1 * 4) + (1 * 8) + (0 * 16) + (0 * 32) + (0 * 64) + (1 * 128),
+               (0 * 1) + (1 * 2) + (1 * 4) + (0 * 8) + (0 * 16) + (1 * 32) + (0 * 64) + (1 * 128),
+               (1 * 1) + (1 * 2) + (0 * 4) + (0 * 8) + (0 * 16) + (1 * 32) + (1 * 64) + (0 * 128),
+               (1 * 1) + (0 * 2) + (0 * 4) + (0 * 8) + (0 * 16) + (0 * 32) + (1 * 64) + (1 * 128),
+               (0 * 1) + (0 * 2) + (0 * 4) + (0 * 8) + (0 * 16) + (1 * 32) + (1 * 64) + (1 * 128)},
+               strings.Repeat("O", 128)},
+       // $ echo -n "PPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPP" | sha256sum
+       // f16ef3e254ffb74b7e3c97d99486ef8c549e4c80bc6dfed7fe8c5e7e76f4fbcd
+       {[32]byte{(1 * 1) + (0 * 2) + (0 * 4) + (0 * 8) + (1 * 16) + (1 * 32) + (1 * 64) + (1 * 128),
+               (0 * 1) + (1 * 2) + (1 * 4) + (1 * 8) + (0 * 16) + (1 * 32) + (1 * 64) + (0 * 128),
+               (1 * 1) + (1 * 2) + (0 * 4) + (0 * 8) + (1 * 16) + (1 * 32) + (1 * 64) + (1 * 128),
+               (0 * 1) + (1 * 2) + (0 * 4) + (0 * 8) + (0 * 16) + (1 * 32) + (1 * 64) + (1 * 128),
+               (0 * 1) + (0 * 2) + (1 * 4) + (0 * 8) + (1 * 16) + (0 * 32) + (1 * 64) + (0 * 128),
+               (1 * 1) + (1 * 2) + (1 * 4) + (1 * 8) + (1 * 16) + (1 * 32) + (1 * 64) + (1 * 128),
+               (1 * 1) + (1 * 2) + (1 * 4) + (0 * 8) + (1 * 16) + (1 * 32) + (0 * 64) + (1 * 128),
+               (1 * 1) + (1 * 2) + (0 * 4) + (1 * 8) + (0 * 16) + (0 * 32) + (1 * 64) + (0 * 128),
+               (0 * 1) + (1 * 2) + (1 * 4) + (1 * 8) + (1 * 16) + (1 * 32) + (1 * 64) + (0 * 128),
+               (0 * 1) + (0 * 2) + (1 * 4) + (1 * 8) + (1 * 16) + (1 * 32) + (0 * 64) + (0 * 128),
+               (1 * 1) + (1 * 2) + (1 * 4) + (0 * 8) + (1 * 16) + (0 * 32) + (0 * 64) + (1 * 128),
+               (1 * 1) + (0 * 2) + (0 * 4) + (1 * 8) + (1 * 16) + (0 * 32) + (1 * 64) + (1 * 128),
+               (0 * 1) + (0 * 2) + (1 * 4) + (0 * 8) + (1 * 16) + (0 * 32) + (0 * 64) + (1 * 128),
+               (0 * 1) + (1 * 2) + (1 * 4) + (0 * 8) + (0 * 16) + (0 * 32) + (0 * 64) + (1 * 128),
+               (1 * 1) + (1 * 2) + (1 * 4) + (1 * 8) + (0 * 16) + (1 * 32) + (1 * 64) + (1 * 128),
+               (0 * 1) + (0 * 2) + (1 * 4) + (1 * 8) + (0 * 16) + (0 * 32) + (0 * 64) + (1 * 128),
+               (0 * 1) + (0 * 2) + (1 * 4) + (0 * 8) + (1 * 16) + (0 * 32) + (1 * 64) + (0 * 128),
+               (0 * 1) + (1 * 2) + (1 * 4) + (1 * 8) + (1 * 16) + (0 * 32) + (0 * 64) + (1 * 128),
+               (0 * 1) + (0 * 2) + (1 * 4) + (1 * 8) + (0 * 16) + (0 * 32) + (1 * 64) + (0 * 128),
+               (0 * 1) + (0 * 2) + (0 * 4) + (0 * 8) + (0 * 16) + (0 * 32) + (0 * 64) + (1 * 128),
+               (0 * 1) + (0 * 2) + (1 * 4) + (1 * 8) + (1 * 16) + (1 * 32) + (0 * 64) + (1 * 128),
+               (1 * 1) + (0 * 2) + (1 * 4) + (1 * 8) + (0 * 16) + (1 * 32) + (1 * 64) + (0 * 128),
+               (0 * 1) + (1 * 2) + (1 * 4) + (1 * 8) + (1 * 16) + (1 * 32) + (1 * 64) + (1 * 128),
+               (1 * 1) + (1 * 2) + (1 * 4) + (0 * 8) + (1 * 16) + (0 * 32) + (1 * 64) + (1 * 128),
+               (0 * 1) + (1 * 2) + (1 * 4) + (1 * 8) + (1 * 16) + (1 * 32) + (1 * 64) + (1 * 128),
+               (0 * 1) + (0 * 2) + (1 * 4) + (1 * 8) + (0 * 16) + (0 * 32) + (0 * 64) + (1 * 128),
+               (0 * 1) + (1 * 2) + (1 * 4) + (1 * 8) + (1 * 16) + (0 * 32) + (1 * 64) + (0 * 128),
+               (0 * 1) + (1 * 2) + (1 * 4) + (1 * 8) + (1 * 16) + (1 * 32) + (1 * 64) + (0 * 128),
+               (0 * 1) + (1 * 2) + (1 * 4) + (0 * 8) + (1 * 16) + (1 * 32) + (1 * 64) + (0 * 128),
+               (0 * 1) + (0 * 2) + (1 * 4) + (0 * 8) + (1 * 16) + (1 * 32) + (1 * 64) + (1 * 128),
+               (1 * 1) + (1 * 2) + (0 * 4) + (1 * 8) + (1 * 16) + (1 * 32) + (1 * 64) + (1 * 128),
+               (1 * 1) + (0 * 2) + (1 * 4) + (1 * 8) + (0 * 16) + (0 * 32) + (1 * 64) + (1 * 128)},
+               strings.Repeat("P", 128)},
+}
+
+func TestGolden(t *testing.T) {
+       blockfuncSaved := blockfunc
+
+       if sha && ssse3 && sse41 {
+               blockfunc = blockfuncSha
+               for _, g := range golden {
+                       s := fmt.Sprintf("%x", Sum256([]byte(g.in)))
+                       if Sum256([]byte(g.in)) != g.out {
+                               t.Fatalf("SHA: Sum256 function: sha256(%s) = %s want %s", g.in, s, hex.EncodeToString(g.out[:]))
+                       }
+               }
+       }
+       if avx2 {
+               blockfunc = blockfuncAvx2
+               for _, g := range golden {
+                       s := fmt.Sprintf("%x", Sum256([]byte(g.in)))
+                       if Sum256([]byte(g.in)) != g.out {
+                               t.Fatalf("AVX2: Sum256 function: sha256(%s) = %s want %s", g.in, s, hex.EncodeToString(g.out[:]))
+                       }
+               }
+       }
+       if avx {
+               blockfunc = blockfuncAvx
+               for _, g := range golden {
+                       s := fmt.Sprintf("%x", Sum256([]byte(g.in)))
+                       if Sum256([]byte(g.in)) != g.out {
+                               t.Fatalf("AVX: Sum256 function: sha256(%s) = %s want %s", g.in, s, hex.EncodeToString(g.out[:]))
+                       }
+               }
+       }
+       if ssse3 {
+               blockfunc = blockfuncSsse
+               for _, g := range golden {
+                       s := fmt.Sprintf("%x", Sum256([]byte(g.in)))
+                       if Sum256([]byte(g.in)) != g.out {
+                               t.Fatalf("SSSE3: Sum256 function: sha256(%s) = %s want %s", g.in, s, hex.EncodeToString(g.out[:]))
+                       }
+               }
+       }
+       if true {
+               blockfunc = blockfuncGeneric
+               for _, g := range golden {
+                       s := fmt.Sprintf("%x", Sum256([]byte(g.in)))
+                       if Sum256([]byte(g.in)) != g.out {
+                               t.Fatalf("Generic: Sum256 function: sha256(%s) = %s want %s", g.in, s, hex.EncodeToString(g.out[:]))
+                       }
+               }
+       }
+
+       blockfunc = blockfuncSaved
+}
+
+func TestSize(t *testing.T) {
+       c := New()
+       if got := c.Size(); got != Size {
+               t.Errorf("Size = %d; want %d", got, Size)
+       }
+}
+
+func TestBlockSize(t *testing.T) {
+       c := New()
+       if got := c.BlockSize(); got != BlockSize {
+               t.Errorf("BlockSize = %d want %d", got, BlockSize)
+       }
+}
+
+func benchmarkSize(b *testing.B, size int) {
+       var bench = New()
+       var buf = make([]byte, size)
+       b.SetBytes(int64(size))
+       sum := make([]byte, bench.Size())
+       b.ResetTimer()
+       for i := 0; i < b.N; i++ {
+               bench.Reset()
+               bench.Write(buf[:size])
+               bench.Sum(sum[:0])
+       }
+}
+
+func BenchmarkHash(b *testing.B) {
+       algos := []struct {
+               n string
+               t blockfuncType
+               f bool
+       }{
+               {"SHA_", blockfuncSha, sha && sse41 && ssse3},
+               {"AVX2", blockfuncAvx2, avx2},
+               {"AVX_", blockfuncAvx, avx},
+               {"SSSE", blockfuncSsse, ssse3},
+               {"GEN_", blockfuncGeneric, true},
+       }
+
+       sizes := []struct {
+               n string
+               f func(*testing.B, int)
+               s int
+       }{
+               {"8Bytes", benchmarkSize, 1 << 3},
+               {"1K", benchmarkSize, 1 << 10},
+               {"8K", benchmarkSize, 1 << 13},
+               {"1M", benchmarkSize, 1 << 20},
+               {"5M", benchmarkSize, 5 << 20},
+               {"10M", benchmarkSize, 5 << 21},
+       }
+
+       for _, a := range algos {
+               if a.f {
+                       blockfuncSaved := blockfunc
+                       blockfunc = a.t
+                       for _, y := range sizes {
+                               s := a.n + "/" + y.n
+                               b.Run(s, func(b *testing.B) { y.f(b, y.s) })
+                       }
+                       blockfunc = blockfuncSaved
+               }
+       }
+}

diff --git a/vendor/github.com/minio/sha256-simd/sha256blockAvx2_amd64.go b/vendor/github.com/minio/sha256-simd/sha256blockAvx2_amd64.go
new file mode 100644 (file)
index 0000000..43ee7a9
--- /dev/null
+++ b/vendor/github.com/minio/sha256-simd/sha256blockAvx2_amd64.go
@@ -0,0 +1,22 @@
+//+build !noasm
+
+/*
+ * Minio Cloud Storage, (C) 2016 Minio, Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package sha256
+
+//go:noescape
+func blockAvx2(h []uint32, message []uint8)

diff --git a/vendor/github.com/minio/sha256-simd/sha256blockAvx2_amd64.s b/vendor/github.com/minio/sha256-simd/sha256blockAvx2_amd64.s
new file mode 100644 (file)
index 0000000..079d6b9
--- /dev/null
+++ b/vendor/github.com/minio/sha256-simd/sha256blockAvx2_amd64.s
@@ -0,0 +1,1449 @@
+//+build !noasm !appengine
+
+// SHA256 implementation for AVX2
+
+//
+// Minio Cloud Storage, (C) 2016 Minio, Inc.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+
+//
+// This code is based on an Intel White-Paper:
+// "Fast SHA-256 Implementations on Intel Architecture Processors"
+//
+// together with the reference implementation from the following authors:
+//    James Guilford <james.guilford@intel.com>
+//    Kirk Yap <kirk.s.yap@intel.com>
+//    Tim Chen <tim.c.chen@linux.intel.com>
+//
+// For Golang it has been converted to Plan 9 assembly with the help of
+// github.com/minio/asm2plan9s to assemble Intel instructions to their Plan9
+// equivalents
+//
+
+DATA K256<>+0x000(SB)/8, $0x71374491428a2f98
+DATA K256<>+0x008(SB)/8, $0xe9b5dba5b5c0fbcf
+DATA K256<>+0x010(SB)/8, $0x71374491428a2f98
+DATA K256<>+0x018(SB)/8, $0xe9b5dba5b5c0fbcf
+DATA K256<>+0x020(SB)/8, $0x59f111f13956c25b
+DATA K256<>+0x028(SB)/8, $0xab1c5ed5923f82a4
+DATA K256<>+0x030(SB)/8, $0x59f111f13956c25b
+DATA K256<>+0x038(SB)/8, $0xab1c5ed5923f82a4
+DATA K256<>+0x040(SB)/8, $0x12835b01d807aa98
+DATA K256<>+0x048(SB)/8, $0x550c7dc3243185be
+DATA K256<>+0x050(SB)/8, $0x12835b01d807aa98
+DATA K256<>+0x058(SB)/8, $0x550c7dc3243185be
+DATA K256<>+0x060(SB)/8, $0x80deb1fe72be5d74
+DATA K256<>+0x068(SB)/8, $0xc19bf1749bdc06a7
+DATA K256<>+0x070(SB)/8, $0x80deb1fe72be5d74
+DATA K256<>+0x078(SB)/8, $0xc19bf1749bdc06a7
+DATA K256<>+0x080(SB)/8, $0xefbe4786e49b69c1
+DATA K256<>+0x088(SB)/8, $0x240ca1cc0fc19dc6
+DATA K256<>+0x090(SB)/8, $0xefbe4786e49b69c1
+DATA K256<>+0x098(SB)/8, $0x240ca1cc0fc19dc6
+DATA K256<>+0x0a0(SB)/8, $0x4a7484aa2de92c6f
+DATA K256<>+0x0a8(SB)/8, $0x76f988da5cb0a9dc
+DATA K256<>+0x0b0(SB)/8, $0x4a7484aa2de92c6f
+DATA K256<>+0x0b8(SB)/8, $0x76f988da5cb0a9dc
+DATA K256<>+0x0c0(SB)/8, $0xa831c66d983e5152
+DATA K256<>+0x0c8(SB)/8, $0xbf597fc7b00327c8
+DATA K256<>+0x0d0(SB)/8, $0xa831c66d983e5152
+DATA K256<>+0x0d8(SB)/8, $0xbf597fc7b00327c8
+DATA K256<>+0x0e0(SB)/8, $0xd5a79147c6e00bf3
+DATA K256<>+0x0e8(SB)/8, $0x1429296706ca6351
+DATA K256<>+0x0f0(SB)/8, $0xd5a79147c6e00bf3
+DATA K256<>+0x0f8(SB)/8, $0x1429296706ca6351
+DATA K256<>+0x100(SB)/8, $0x2e1b213827b70a85
+DATA K256<>+0x108(SB)/8, $0x53380d134d2c6dfc
+DATA K256<>+0x110(SB)/8, $0x2e1b213827b70a85
+DATA K256<>+0x118(SB)/8, $0x53380d134d2c6dfc
+DATA K256<>+0x120(SB)/8, $0x766a0abb650a7354
+DATA K256<>+0x128(SB)/8, $0x92722c8581c2c92e
+DATA K256<>+0x130(SB)/8, $0x766a0abb650a7354
+DATA K256<>+0x138(SB)/8, $0x92722c8581c2c92e
+DATA K256<>+0x140(SB)/8, $0xa81a664ba2bfe8a1
+DATA K256<>+0x148(SB)/8, $0xc76c51a3c24b8b70
+DATA K256<>+0x150(SB)/8, $0xa81a664ba2bfe8a1
+DATA K256<>+0x158(SB)/8, $0xc76c51a3c24b8b70
+DATA K256<>+0x160(SB)/8, $0xd6990624d192e819
+DATA K256<>+0x168(SB)/8, $0x106aa070f40e3585
+DATA K256<>+0x170(SB)/8, $0xd6990624d192e819
+DATA K256<>+0x178(SB)/8, $0x106aa070f40e3585
+DATA K256<>+0x180(SB)/8, $0x1e376c0819a4c116
+DATA K256<>+0x188(SB)/8, $0x34b0bcb52748774c
+DATA K256<>+0x190(SB)/8, $0x1e376c0819a4c116
+DATA K256<>+0x198(SB)/8, $0x34b0bcb52748774c
+DATA K256<>+0x1a0(SB)/8, $0x4ed8aa4a391c0cb3
+DATA K256<>+0x1a8(SB)/8, $0x682e6ff35b9cca4f
+DATA K256<>+0x1b0(SB)/8, $0x4ed8aa4a391c0cb3
+DATA K256<>+0x1b8(SB)/8, $0x682e6ff35b9cca4f
+DATA K256<>+0x1c0(SB)/8, $0x78a5636f748f82ee
+DATA K256<>+0x1c8(SB)/8, $0x8cc7020884c87814
+DATA K256<>+0x1d0(SB)/8, $0x78a5636f748f82ee
+DATA K256<>+0x1d8(SB)/8, $0x8cc7020884c87814
+DATA K256<>+0x1e0(SB)/8, $0xa4506ceb90befffa
+DATA K256<>+0x1e8(SB)/8, $0xc67178f2bef9a3f7
+DATA K256<>+0x1f0(SB)/8, $0xa4506ceb90befffa
+DATA K256<>+0x1f8(SB)/8, $0xc67178f2bef9a3f7
+
+DATA K256<>+0x200(SB)/8, $0x0405060700010203
+DATA K256<>+0x208(SB)/8, $0x0c0d0e0f08090a0b
+DATA K256<>+0x210(SB)/8, $0x0405060700010203
+DATA K256<>+0x218(SB)/8, $0x0c0d0e0f08090a0b
+DATA K256<>+0x220(SB)/8, $0x0b0a090803020100
+DATA K256<>+0x228(SB)/8, $0xffffffffffffffff
+DATA K256<>+0x230(SB)/8, $0x0b0a090803020100
+DATA K256<>+0x238(SB)/8, $0xffffffffffffffff
+DATA K256<>+0x240(SB)/8, $0xffffffffffffffff
+DATA K256<>+0x248(SB)/8, $0x0b0a090803020100
+DATA K256<>+0x250(SB)/8, $0xffffffffffffffff
+DATA K256<>+0x258(SB)/8, $0x0b0a090803020100
+
+GLOBL K256<>(SB), 8, $608
+
+// We need 0x220 stack space aligned on a 512 boundary, so for the
+// worstcase-aligned SP we need twice this amount, being 1088 (=0x440)
+//
+// SP        aligned   end-aligned  stacksize
+// 100013d0  10001400  10001620     592
+// 100013d8  10001400  10001620     584
+// 100013e0  10001600  10001820     1088
+// 100013e8  10001600  10001820     1080
+
+// func blockAvx2(h []uint32, message []uint8)
+TEXT ·blockAvx2(SB),$1088-48
+
+       MOVQ h+0(FP), DI             // DI: &h
+       MOVQ message_base+24(FP), SI // SI: &message
+       MOVQ message_len+32(FP), DX  // len(message)
+       ADDQ SI, DX                  // end pointer of input
+       MOVQ SP, R11                 // copy stack pointer
+       ADDQ $0x220, SP              // sp += 0x220
+       ANDQ $0xfffffffffffffe00, SP // align stack frame
+       ADDQ $0x1c0, SP
+       MOVQ DI, 0x40(SP)            // save ctx
+       MOVQ SI, 0x48(SP)            // save input
+       MOVQ DX, 0x50(SP)            // save end pointer
+       MOVQ R11, 0x58(SP)           // save copy of stack pointer
+
+       WORD $0xf8c5; BYTE $0x77 // vzeroupper
+       ADDQ $0x40, SI           // input++
+       MOVL (DI), AX
+       MOVQ SI, R12             // borrow $T1
+       MOVL 4(DI), BX
+       CMPQ SI, DX              // $_end
+       MOVL 8(DI), CX
+       LONG $0xe4440f4c         // cmove  r12,rsp            /* next block or random data */
+       MOVL 12(DI), DX
+       MOVL 16(DI), R8
+       MOVL 20(DI), R9
+       MOVL 24(DI), R10
+       MOVL 28(DI), R11
+
+       LEAQ K256<>(SB), BP
+       LONG $0x856f7dc5; LONG $0x00000220 // VMOVDQA YMM8, 0x220[rbp]  /* vmovdqa ymm8,YMMWORD PTR [rip+0x220] */
+       LONG $0x8d6f7dc5; LONG $0x00000240 // VMOVDQA YMM9, 0x240[rbp]  /* vmovdqa ymm9,YMMWORD PTR [rip+0x240] */
+       LONG $0x956f7dc5; LONG $0x00000200 // VMOVDQA YMM10, 0x200[rbp] /* vmovdqa ymm7,YMMWORD PTR [rip+0x200] */
+
+loop0:
+       LONG $0x6f7dc1c4; BYTE $0xfa // VMOVDQA YMM7, YMM10
+
+       // Load first 16 dwords from two blocks
+       MOVOU -64(SI), X0 // vmovdqu xmm0,XMMWORD PTR [rsi-0x40]
+       MOVOU -48(SI), X1 // vmovdqu xmm1,XMMWORD PTR [rsi-0x30]
+       MOVOU -32(SI), X2 // vmovdqu xmm2,XMMWORD PTR [rsi-0x20]
+       MOVOU -16(SI), X3 // vmovdqu xmm3,XMMWORD PTR [rsi-0x10]
+
+       // Byte swap data and transpose data into high/low
+       LONG $0x387dc3c4; WORD $0x2404; BYTE $0x01 // vinserti128 ymm0,ymm0,[r12],0x1
+       LONG $0x3875c3c4; LONG $0x0110244c         // vinserti128 ymm1,ymm1,0x10[r12],0x1
+       LONG $0x007de2c4; BYTE $0xc7               // vpshufb     ymm0,ymm0,ymm7
+       LONG $0x386dc3c4; LONG $0x01202454         // vinserti128 ymm2,ymm2,0x20[r12],0x1
+       LONG $0x0075e2c4; BYTE $0xcf               // vpshufb     ymm1,ymm1,ymm7
+       LONG $0x3865c3c4; LONG $0x0130245c         // vinserti128 ymm3,ymm3,0x30[r12],0x1
+
+       LEAQ K256<>(SB), BP
+       LONG $0x006de2c4; BYTE $0xd7 // vpshufb ymm2,ymm2,ymm7
+       LONG $0x65fefdc5; BYTE $0x00 // vpaddd  ymm4,ymm0,[rbp]
+       LONG $0x0065e2c4; BYTE $0xdf // vpshufb ymm3,ymm3,ymm7
+       LONG $0x6dfef5c5; BYTE $0x20 // vpaddd  ymm5,ymm1,0x20[rbp]
+       LONG $0x75feedc5; BYTE $0x40 // vpaddd  ymm6,ymm2,0x40[rbp]
+       LONG $0x7dfee5c5; BYTE $0x60 // vpaddd  ymm7,ymm3,0x60[rbp]
+
+       LONG $0x247ffdc5; BYTE $0x24   // vmovdqa [rsp],ymm4
+       XORQ R14, R14
+       LONG $0x6c7ffdc5; WORD $0x2024 // vmovdqa [rsp+0x20],ymm5
+
+       ADDQ $-0x40, SP
+       MOVQ BX, DI
+       LONG $0x347ffdc5; BYTE $0x24   // vmovdqa [rsp],ymm6
+       XORQ CX, DI                    // magic
+       LONG $0x7c7ffdc5; WORD $0x2024 // vmovdqa [rsp+0x20],ymm7
+       MOVQ R9, R12
+       ADDQ $0x80, BP
+
+loop1:
+       // Schedule 48 input dwords, by doing 3 rounds of 12 each
+       // Note: SIMD instructions are interleaved with the SHA calculations
+       ADDQ $-0x40, SP
+       LONG $0x0f75e3c4; WORD $0x04e0 // vpalignr ymm4,ymm1,ymm0,0x4
+
+       // ROUND(AX, BX, CX, DX, R8, R9, R10, R11, R12, R13, R14, R15, DI, SP, 0x80)
+       LONG $0x249c0344; LONG $0x00000080 // add    r11d,[rsp+0x80]
+       WORD $0x2145; BYTE $0xc4           // and    r12d,r8d
+       LONG $0xf07b43c4; WORD $0x19e8     // rorx   r13d,r8d,0x19
+       LONG $0x0f65e3c4; WORD $0x04fa     // vpalignr ymm7,ymm3,ymm2,0x4
+       LONG $0xf07b43c4; WORD $0x0bf8     // rorx   r15d,r8d,0xb
+       LONG $0x30048d42                   // lea    eax,[rax+r14*1]
+       LONG $0x231c8d47                   // lea    r11d,[r11+r12*1]
+       LONG $0xd472cdc5; BYTE $0x07       // vpsrld ymm6,ymm4,0x7
+       LONG $0xf23842c4; BYTE $0xe2       // andn   r12d,r8d,r10d
+       WORD $0x3145; BYTE $0xfd           // xor    r13d,r15d
+       LONG $0xf07b43c4; WORD $0x06f0     // rorx   r14d,r8d,0x6
+       LONG $0xc7fefdc5                   // vpaddd ymm0,ymm0,ymm7
+       LONG $0x231c8d47                   // lea    r11d,[r11+r12*1]
+       WORD $0x3145; BYTE $0xf5           // xor    r13d,r14d
+       WORD $0x8941; BYTE $0xc7           // mov    r15d,eax
+       LONG $0xd472c5c5; BYTE $0x03       // vpsrld ymm7,ymm4,0x3
+       LONG $0xf07b63c4; WORD $0x16e0     // rorx   r12d,eax,0x16
+       LONG $0x2b1c8d47                   // lea    r11d,[r11+r13*1]
+       WORD $0x3141; BYTE $0xdf           // xor    r15d,ebx
+       LONG $0xf472d5c5; BYTE $0x0e       // vpslld ymm5,ymm4,0xe
+       LONG $0xf07b63c4; WORD $0x0df0     // rorx   r14d,eax,0xd
+       LONG $0xf07b63c4; WORD $0x02e8     // rorx   r13d,eax,0x2
+       LONG $0x1a148d42                   // lea    edx,[rdx+r11*1]
+       LONG $0xe6efc5c5                   // vpxor  ymm4,ymm7,ymm6
+       WORD $0x2144; BYTE $0xff           // and    edi,r15d
+       WORD $0x3145; BYTE $0xe6           // xor    r14d,r12d
+       WORD $0xdf31                       // xor    edi,ebx
+       LONG $0xfb70fdc5; BYTE $0xfa       // vpshufd ymm7,ymm3,0xfa
+       WORD $0x3145; BYTE $0xee           // xor    r14d,r13d
+       LONG $0x3b1c8d45                   // lea    r11d,[r11+rdi*1]
+       WORD $0x8945; BYTE $0xc4           // mov    r12d,r8d
+       LONG $0xd672cdc5; BYTE $0x0b       // vpsrld ymm6,ymm6,0xb
+
+       // ROUND(R11, AX, BX, CX, DX, R8, R9, R10, R12, R13, R14, DI, R15, SP, 0x84)
+       LONG $0x24940344; LONG $0x00000084 // add    r10d,[rsp+0x84]
+       WORD $0x2141; BYTE $0xd4           // and    r12d,edx
+       LONG $0xf07b63c4; WORD $0x19ea     // rorx   r13d,edx,0x19
+       LONG $0xe5efddc5                   // vpxor  ymm4,ymm4,ymm5
+       LONG $0xf07be3c4; WORD $0x0bfa     // rorx   edi,edx,0xb
+       LONG $0x331c8d47                   // lea    r11d,[r11+r14*1]
+       LONG $0x22148d47                   // lea    r10d,[r10+r12*1]
+       LONG $0xf572d5c5; BYTE $0x0b       // vpslld ymm5,ymm5,0xb
+       LONG $0xf26842c4; BYTE $0xe1       // andn   r12d,edx,r9d
+       WORD $0x3141; BYTE $0xfd           // xor    r13d,edi
+       LONG $0xf07b63c4; WORD $0x06f2     // rorx   r14d,edx,0x6
+       LONG $0xe6efddc5                   // vpxor  ymm4,ymm4,ymm6
+       LONG $0x22148d47                   // lea    r10d,[r10+r12*1]
+       WORD $0x3145; BYTE $0xf5           // xor    r13d,r14d
+       WORD $0x8944; BYTE $0xdf           // mov    edi,r11d
+       LONG $0xd772cdc5; BYTE $0x0a       // vpsrld ymm6,ymm7,0xa
+       LONG $0xf07b43c4; WORD $0x16e3     // rorx   r12d,r11d,0x16
+       LONG $0x2a148d47                   // lea    r10d,[r10+r13*1]
+       WORD $0xc731                       // xor    edi,eax
+       LONG $0xe5efddc5                   // vpxor  ymm4,ymm4,ymm5
+       LONG $0xf07b43c4; WORD $0x0df3     // rorx   r14d,r11d,0xd
+       LONG $0xf07b43c4; WORD $0x02eb     // rorx   r13d,r11d,0x2
+       LONG $0x110c8d42                   // lea    ecx,[rcx+r10*1]
+       LONG $0xd773c5c5; BYTE $0x11       // vpsrlq ymm7,ymm7,0x11
+       WORD $0x2141; BYTE $0xff           // and    r15d,edi
+       WORD $0x3145; BYTE $0xe6           // xor    r14d,r12d
+       WORD $0x3141; BYTE $0xc7           // xor    r15d,eax
+       LONG $0xc4fefdc5                   // vpaddd ymm0,ymm0,ymm4
+       WORD $0x3145; BYTE $0xee           // xor    r14d,r13d
+       LONG $0x3a148d47                   // lea    r10d,[r10+r15*1]
+       WORD $0x8941; BYTE $0xd4           // mov    r12d,edx
+       LONG $0xf7efcdc5                   // vpxor  ymm6,ymm6,ymm7
+
+       // ROUND(R10, R11, AX, BX, CX, DX, R8, R9, R12, R13, R14, R15, DI, SP, 0x88)
+       LONG $0x248c0344; LONG $0x00000088 // add    r9d,[rsp+0x88]
+       WORD $0x2141; BYTE $0xcc           // and    r12d,ecx
+       LONG $0xf07b63c4; WORD $0x19e9     // rorx   r13d,ecx,0x19
+       LONG $0xd773c5c5; BYTE $0x02       // vpsrlq ymm7,ymm7,0x2
+       LONG $0xf07b63c4; WORD $0x0bf9     // rorx   r15d,ecx,0xb
+       LONG $0x32148d47                   // lea    r10d,[r10+r14*1]
+       LONG $0x210c8d47                   // lea    r9d,[r9+r12*1]
+       LONG $0xf7efcdc5                   // vpxor  ymm6,ymm6,ymm7
+       LONG $0xf27042c4; BYTE $0xe0       // andn   r12d,ecx,r8d
+       WORD $0x3145; BYTE $0xfd           // xor    r13d,r15d
+       LONG $0xf07b63c4; WORD $0x06f1     // rorx   r14d,ecx,0x6
+       LONG $0x004dc2c4; BYTE $0xf0       // vpshufb ymm6,ymm6,ymm8
+       LONG $0x210c8d47                   // lea    r9d,[r9+r12*1]
+       WORD $0x3145; BYTE $0xf5           // xor    r13d,r14d
+       WORD $0x8945; BYTE $0xd7           // mov    r15d,r10d
+       LONG $0xc6fefdc5                   // vpaddd ymm0,ymm0,ymm6
+       LONG $0xf07b43c4; WORD $0x16e2     // rorx   r12d,r10d,0x16
+       LONG $0x290c8d47                   // lea    r9d,[r9+r13*1]
+       WORD $0x3145; BYTE $0xdf           // xor    r15d,r11d
+       LONG $0xf870fdc5; BYTE $0x50       // vpshufd ymm7,ymm0,0x50
+       LONG $0xf07b43c4; WORD $0x0df2     // rorx   r14d,r10d,0xd
+       LONG $0xf07b43c4; WORD $0x02ea     // rorx   r13d,r10d,0x2
+       LONG $0x0b1c8d42                   // lea    ebx,[rbx+r9*1]
+       LONG $0xd772cdc5; BYTE $0x0a       // vpsrld ymm6,ymm7,0xa
+       WORD $0x2144; BYTE $0xff           // and    edi,r15d
+       WORD $0x3145; BYTE $0xe6           // xor    r14d,r12d
+       WORD $0x3144; BYTE $0xdf           // xor    edi,r11d
+       LONG $0xd773c5c5; BYTE $0x11       // vpsrlq ymm7,ymm7,0x11
+       WORD $0x3145; BYTE $0xee           // xor    r14d,r13d
+       LONG $0x390c8d45                   // lea    r9d,[r9+rdi*1]
+       WORD $0x8941; BYTE $0xcc           // mov    r12d,ecx
+       LONG $0xf7efcdc5                   // vpxor  ymm6,ymm6,ymm7
+
+       // ROUND(R9, R10, R11, AX, BX, CX, DX, R8, R12, R13, R14, DI, R15, SP, 0x8c)
+       LONG $0x24840344; LONG $0x0000008c // add    r8d,[rsp+0x8c]
+       WORD $0x2141; BYTE $0xdc           // and    r12d,ebx
+       LONG $0xf07b63c4; WORD $0x19eb     // rorx   r13d,ebx,0x19
+       LONG $0xd773c5c5; BYTE $0x02       // vpsrlq ymm7,ymm7,0x2
+       LONG $0xf07be3c4; WORD $0x0bfb     // rorx   edi,ebx,0xb
+       LONG $0x310c8d47                   // lea    r9d,[r9+r14*1]
+       LONG $0x20048d47                   // lea    r8d,[r8+r12*1]
+       LONG $0xf7efcdc5                   // vpxor  ymm6,ymm6,ymm7
+       LONG $0xf26062c4; BYTE $0xe2       // andn   r12d,ebx,edx
+       WORD $0x3141; BYTE $0xfd           // xor    r13d,edi
+       LONG $0xf07b63c4; WORD $0x06f3     // rorx   r14d,ebx,0x6
+       LONG $0x004dc2c4; BYTE $0xf1       // vpshufb ymm6,ymm6,ymm9
+       LONG $0x20048d47                   // lea    r8d,[r8+r12*1]
+       WORD $0x3145; BYTE $0xf5           // xor    r13d,r14d
+       WORD $0x8944; BYTE $0xcf           // mov    edi,r9d
+       LONG $0xc6fefdc5                   // vpaddd ymm0,ymm0,ymm6
+       LONG $0xf07b43c4; WORD $0x16e1     // rorx   r12d,r9d,0x16
+       LONG $0x28048d47                   // lea    r8d,[r8+r13*1]
+       WORD $0x3144; BYTE $0xd7           // xor    edi,r10d
+       LONG $0x75fefdc5; BYTE $0x00       // vpaddd ymm6,ymm0,[rbp+0x0]
+       LONG $0xf07b43c4; WORD $0x0df1     // rorx   r14d,r9d,0xd
+       LONG $0xf07b43c4; WORD $0x02e9     // rorx   r13d,r9d,0x2
+       LONG $0x00048d42                   // lea    eax,[rax+r8*1]
+       WORD $0x2141; BYTE $0xff           // and    r15d,edi
+       WORD $0x3145; BYTE $0xe6           // xor    r14d,r12d
+       WORD $0x3145; BYTE $0xd7           // xor    r15d,r10d
+       WORD $0x3145; BYTE $0xee           // xor    r14d,r13d
+       LONG $0x38048d47                   // lea    r8d,[r8+r15*1]
+       WORD $0x8941; BYTE $0xdc           // mov    r12d,ebx
+
+       LONG $0x347ffdc5; BYTE $0x24   // vmovdqa [rsp],ymm6
+       LONG $0x0f6de3c4; WORD $0x04e1 // vpalignr ymm4,ymm2,ymm1,0x4
+
+       // ROUND(R8, R9, R10, R11, AX, BX, CX, DX, R12, R13, R14, R15, DI, SP, 0xa0)
+       LONG $0xa0249403; WORD $0x0000; BYTE $0x00 // add    edx,[rsp+0xa0]
+       WORD $0x2141; BYTE $0xc4                   // and    r12d,eax
+       LONG $0xf07b63c4; WORD $0x19e8             // rorx   r13d,eax,0x19
+       LONG $0x0f7de3c4; WORD $0x04fb             // vpalignr ymm7,ymm0,ymm3,0x4
+       LONG $0xf07b63c4; WORD $0x0bf8             // rorx   r15d,eax,0xb
+       LONG $0x30048d47                           // lea    r8d,[r8+r14*1]
+       LONG $0x22148d42                           // lea    edx,[rdx+r12*1]
+       LONG $0xd472cdc5; BYTE $0x07               // vpsrld ymm6,ymm4,0x7
+       LONG $0xf27862c4; BYTE $0xe1               // andn   r12d,eax,ecx
+       WORD $0x3145; BYTE $0xfd                   // xor    r13d,r15d
+       LONG $0xf07b63c4; WORD $0x06f0             // rorx   r14d,eax,0x6
+       LONG $0xcffef5c5                           // vpaddd ymm1,ymm1,ymm7
+       LONG $0x22148d42                           // lea    edx,[rdx+r12*1]
+       WORD $0x3145; BYTE $0xf5                   // xor    r13d,r14d
+       WORD $0x8945; BYTE $0xc7                   // mov    r15d,r8d
+       LONG $0xd472c5c5; BYTE $0x03               // vpsrld ymm7,ymm4,0x3
+       LONG $0xf07b43c4; WORD $0x16e0             // rorx   r12d,r8d,0x16
+       LONG $0x2a148d42                           // lea    edx,[rdx+r13*1]
+       WORD $0x3145; BYTE $0xcf                   // xor    r15d,r9d
+       LONG $0xf472d5c5; BYTE $0x0e               // vpslld ymm5,ymm4,0xe
+       LONG $0xf07b43c4; WORD $0x0df0             // rorx   r14d,r8d,0xd
+       LONG $0xf07b43c4; WORD $0x02e8             // rorx   r13d,r8d,0x2
+       LONG $0x131c8d45                           // lea    r11d,[r11+rdx*1]
+       LONG $0xe6efc5c5                           // vpxor  ymm4,ymm7,ymm6
+       WORD $0x2144; BYTE $0xff                   // and    edi,r15d
+       WORD $0x3145; BYTE $0xe6                   // xor    r14d,r12d
+       WORD $0x3144; BYTE $0xcf                   // xor    edi,r9d
+       LONG $0xf870fdc5; BYTE $0xfa               // vpshufd ymm7,ymm0,0xfa
+       WORD $0x3145; BYTE $0xee                   // xor    r14d,r13d
+       WORD $0x148d; BYTE $0x3a                   // lea    edx,[rdx+rdi*1]
+       WORD $0x8941; BYTE $0xc4                   // mov    r12d,eax
+       LONG $0xd672cdc5; BYTE $0x0b               // vpsrld ymm6,ymm6,0xb
+
+       // ROUND(DX, R8, R9, R10, R11, AX, BX, CX, R12, R13, R14, DI, R15, SP, 0xa4)
+       LONG $0xa4248c03; WORD $0x0000; BYTE $0x00 // add    ecx,[rsp+0xa4]
+       WORD $0x2145; BYTE $0xdc                   // and    r12d,r11d
+       LONG $0xf07b43c4; WORD $0x19eb             // rorx   r13d,r11d,0x19
+       LONG $0xe5efddc5                           // vpxor  ymm4,ymm4,ymm5
+       LONG $0xf07bc3c4; WORD $0x0bfb             // rorx   edi,r11d,0xb
+       LONG $0x32148d42                           // lea    edx,[rdx+r14*1]
+       LONG $0x210c8d42                           // lea    ecx,[rcx+r12*1]
+       LONG $0xf572d5c5; BYTE $0x0b               // vpslld ymm5,ymm5,0xb
+       LONG $0xf22062c4; BYTE $0xe3               // andn   r12d,r11d,ebx
+       WORD $0x3141; BYTE $0xfd                   // xor    r13d,edi
+       LONG $0xf07b43c4; WORD $0x06f3             // rorx   r14d,r11d,0x6
+       LONG $0xe6efddc5                           // vpxor  ymm4,ymm4,ymm6
+       LONG $0x210c8d42                           // lea    ecx,[rcx+r12*1]
+       WORD $0x3145; BYTE $0xf5                   // xor    r13d,r14d
+       WORD $0xd789                               // mov    edi,edx
+       LONG $0xd772cdc5; BYTE $0x0a               // vpsrld ymm6,ymm7,0xa
+       LONG $0xf07b63c4; WORD $0x16e2             // rorx   r12d,edx,0x16
+       LONG $0x290c8d42                           // lea    ecx,[rcx+r13*1]
+       WORD $0x3144; BYTE $0xc7                   // xor    edi,r8d
+       LONG $0xe5efddc5                           // vpxor  ymm4,ymm4,ymm5
+       LONG $0xf07b63c4; WORD $0x0df2             // rorx   r14d,edx,0xd
+       LONG $0xf07b63c4; WORD $0x02ea             // rorx   r13d,edx,0x2
+       LONG $0x0a148d45                           // lea    r10d,[r10+rcx*1]
+       LONG $0xd773c5c5; BYTE $0x11               // vpsrlq ymm7,ymm7,0x11
+       WORD $0x2141; BYTE $0xff                   // and    r15d,edi
+       WORD $0x3145; BYTE $0xe6                   // xor    r14d,r12d
+       WORD $0x3145; BYTE $0xc7                   // xor    r15d,r8d
+       LONG $0xccfef5c5                           // vpaddd ymm1,ymm1,ymm4
+       WORD $0x3145; BYTE $0xee                   // xor    r14d,r13d
+       LONG $0x390c8d42                           // lea    ecx,[rcx+r15*1]
+       WORD $0x8945; BYTE $0xdc                   // mov    r12d,r11d
+       LONG $0xf7efcdc5                           // vpxor  ymm6,ymm6,ymm7
+
+       // ROUND(CX, DX, R8, R9, R10, R11, AX, BX, R12, R13, R14, R15, DI, SP, 0xa8)
+       LONG $0xa8249c03; WORD $0x0000; BYTE $0x00 // add    ebx,[rsp+0xa8]
+       WORD $0x2145; BYTE $0xd4                   // and    r12d,r10d
+       LONG $0xf07b43c4; WORD $0x19ea             // rorx   r13d,r10d,0x19
+       LONG $0xd773c5c5; BYTE $0x02               // vpsrlq ymm7,ymm7,0x2
+       LONG $0xf07b43c4; WORD $0x0bfa             // rorx   r15d,r10d,0xb
+       LONG $0x310c8d42                           // lea    ecx,[rcx+r14*1]
+       LONG $0x231c8d42                           // lea    ebx,[rbx+r12*1]
+       LONG $0xf7efcdc5                           // vpxor  ymm6,ymm6,ymm7
+       LONG $0xf22862c4; BYTE $0xe0               // andn   r12d,r10d,eax
+       WORD $0x3145; BYTE $0xfd                   // xor    r13d,r15d
+       LONG $0xf07b43c4; WORD $0x06f2             // rorx   r14d,r10d,0x6
+       LONG $0x004dc2c4; BYTE $0xf0               // vpshufb ymm6,ymm6,ymm8
+       LONG $0x231c8d42                           // lea    ebx,[rbx+r12*1]
+       WORD $0x3145; BYTE $0xf5                   // xor    r13d,r14d
+       WORD $0x8941; BYTE $0xcf                   // mov    r15d,ecx
+       LONG $0xcefef5c5                           // vpaddd ymm1,ymm1,ymm6
+       LONG $0xf07b63c4; WORD $0x16e1             // rorx   r12d,ecx,0x16
+       LONG $0x2b1c8d42                           // lea    ebx,[rbx+r13*1]
+       WORD $0x3141; BYTE $0xd7                   // xor    r15d,edx
+       LONG $0xf970fdc5; BYTE $0x50               // vpshufd ymm7,ymm1,0x50
+       LONG $0xf07b63c4; WORD $0x0df1             // rorx   r14d,ecx,0xd
+       LONG $0xf07b63c4; WORD $0x02e9             // rorx   r13d,ecx,0x2
+       LONG $0x190c8d45                           // lea    r9d,[r9+rbx*1]
+       LONG $0xd772cdc5; BYTE $0x0a               // vpsrld ymm6,ymm7,0xa
+       WORD $0x2144; BYTE $0xff                   // and    edi,r15d
+       WORD $0x3145; BYTE $0xe6                   // xor    r14d,r12d
+       WORD $0xd731                               // xor    edi,edx
+       LONG $0xd773c5c5; BYTE $0x11               // vpsrlq ymm7,ymm7,0x11
+       WORD $0x3145; BYTE $0xee                   // xor    r14d,r13d
+       WORD $0x1c8d; BYTE $0x3b                   // lea    ebx,[rbx+rdi*1]
+       WORD $0x8945; BYTE $0xd4                   // mov    r12d,r10d
+       LONG $0xf7efcdc5                           // vpxor  ymm6,ymm6,ymm7
+
+       // ROUND(BX, CX, DX, R8, R9, R10, R11, AX, R12, R13, R14, DI, R15, SP, 0xac)
+       LONG $0xac248403; WORD $0x0000; BYTE $0x00 // add    eax,[rsp+0xac]
+       WORD $0x2145; BYTE $0xcc                   // and    r12d,r9d
+       LONG $0xf07b43c4; WORD $0x19e9             // rorx   r13d,r9d,0x19
+       LONG $0xd773c5c5; BYTE $0x02               // vpsrlq ymm7,ymm7,0x2
+       LONG $0xf07bc3c4; WORD $0x0bf9             // rorx   edi,r9d,0xb
+       LONG $0x331c8d42                           // lea    ebx,[rbx+r14*1]
+       LONG $0x20048d42                           // lea    eax,[rax+r12*1]
+       LONG $0xf7efcdc5                           // vpxor  ymm6,ymm6,ymm7
+       LONG $0xf23042c4; BYTE $0xe3               // andn   r12d,r9d,r11d
+       WORD $0x3141; BYTE $0xfd                   // xor    r13d,edi
+       LONG $0xf07b43c4; WORD $0x06f1             // rorx   r14d,r9d,0x6
+       LONG $0x004dc2c4; BYTE $0xf1               // vpshufb ymm6,ymm6,ymm9
+       LONG $0x20048d42                           // lea    eax,[rax+r12*1]
+       WORD $0x3145; BYTE $0xf5                   // xor    r13d,r14d
+       WORD $0xdf89                               // mov    edi,ebx
+       LONG $0xcefef5c5                           // vpaddd ymm1,ymm1,ymm6
+       LONG $0xf07b63c4; WORD $0x16e3             // rorx   r12d,ebx,0x16
+       LONG $0x28048d42                           // lea    eax,[rax+r13*1]
+       WORD $0xcf31                               // xor    edi,ecx
+       LONG $0x75fef5c5; BYTE $0x20               // vpaddd ymm6,ymm1,[rbp+0x20]
+       LONG $0xf07b63c4; WORD $0x0df3             // rorx   r14d,ebx,0xd
+       LONG $0xf07b63c4; WORD $0x02eb             // rorx   r13d,ebx,0x2
+       LONG $0x00048d45                           // lea    r8d,[r8+rax*1]
+       WORD $0x2141; BYTE $0xff                   // and    r15d,edi
+       WORD $0x3145; BYTE $0xe6                   // xor    r14d,r12d
+       WORD $0x3141; BYTE $0xcf                   // xor    r15d,ecx
+       WORD $0x3145; BYTE $0xee                   // xor    r14d,r13d
+       LONG $0x38048d42                           // lea    eax,[rax+r15*1]
+       WORD $0x8945; BYTE $0xcc                   // mov    r12d,r9d
+
+       LONG $0x747ffdc5; WORD $0x2024 // vmovdqa [rsp+0x20],ymm6
+
+       LONG $0x24648d48; BYTE $0xc0   // lea    rsp,[rsp-0x40]
+       LONG $0x0f65e3c4; WORD $0x04e2 // vpalignr ymm4,ymm3,ymm2,0x4
+
+       // ROUND(AX, BX, CX, DX, R8, R9, R10, R11, R12, R13, R14, R15, DI, SP, 0x80)
+       LONG $0x249c0344; LONG $0x00000080 // add    r11d,[rsp+0x80]
+       WORD $0x2145; BYTE $0xc4           // and    r12d,r8d
+       LONG $0xf07b43c4; WORD $0x19e8     // rorx   r13d,r8d,0x19
+       LONG $0x0f75e3c4; WORD $0x04f8     // vpalignr ymm7,ymm1,ymm0,0x4
+       LONG $0xf07b43c4; WORD $0x0bf8     // rorx   r15d,r8d,0xb
+       LONG $0x30048d42                   // lea    eax,[rax+r14*1]
+       LONG $0x231c8d47                   // lea    r11d,[r11+r12*1]
+       LONG $0xd472cdc5; BYTE $0x07       // vpsrld ymm6,ymm4,0x7
+       LONG $0xf23842c4; BYTE $0xe2       // andn   r12d,r8d,r10d
+       WORD $0x3145; BYTE $0xfd           // xor    r13d,r15d
+       LONG $0xf07b43c4; WORD $0x06f0     // rorx   r14d,r8d,0x6
+       LONG $0xd7feedc5                   // vpaddd ymm2,ymm2,ymm7
+       LONG $0x231c8d47                   // lea    r11d,[r11+r12*1]
+       WORD $0x3145; BYTE $0xf5           // xor    r13d,r14d
+       WORD $0x8941; BYTE $0xc7           // mov    r15d,eax
+       LONG $0xd472c5c5; BYTE $0x03       // vpsrld ymm7,ymm4,0x3
+       LONG $0xf07b63c4; WORD $0x16e0     // rorx   r12d,eax,0x16
+       LONG $0x2b1c8d47                   // lea    r11d,[r11+r13*1]
+       WORD $0x3141; BYTE $0xdf           // xor    r15d,ebx
+       LONG $0xf472d5c5; BYTE $0x0e       // vpslld ymm5,ymm4,0xe
+       LONG $0xf07b63c4; WORD $0x0df0     // rorx   r14d,eax,0xd
+       LONG $0xf07b63c4; WORD $0x02e8     // rorx   r13d,eax,0x2
+       LONG $0x1a148d42                   // lea    edx,[rdx+r11*1]
+       LONG $0xe6efc5c5                   // vpxor  ymm4,ymm7,ymm6
+       WORD $0x2144; BYTE $0xff           // and    edi,r15d
+       WORD $0x3145; BYTE $0xe6           // xor    r14d,r12d
+       WORD $0xdf31                       // xor    edi,ebx
+       LONG $0xf970fdc5; BYTE $0xfa       // vpshufd ymm7,ymm1,0xfa
+       WORD $0x3145; BYTE $0xee           // xor    r14d,r13d
+       LONG $0x3b1c8d45                   // lea    r11d,[r11+rdi*1]
+       WORD $0x8945; BYTE $0xc4           // mov    r12d,r8d
+       LONG $0xd672cdc5; BYTE $0x0b       // vpsrld ymm6,ymm6,0xb
+
+       // ROUND(R11, AX, BX, CX, DX, R8, R9, R10, R12, R13, R14, DI, R15, SP, 0x84)
+       LONG $0x24940344; LONG $0x00000084 // add    r10d,[rsp+0x84]
+       WORD $0x2141; BYTE $0xd4           // and    r12d,edx
+       LONG $0xf07b63c4; WORD $0x19ea     // rorx   r13d,edx,0x19
+       LONG $0xe5efddc5                   // vpxor  ymm4,ymm4,ymm5
+       LONG $0xf07be3c4; WORD $0x0bfa     // rorx   edi,edx,0xb
+       LONG $0x331c8d47                   // lea    r11d,[r11+r14*1]
+       LONG $0x22148d47                   // lea    r10d,[r10+r12*1]
+       LONG $0xf572d5c5; BYTE $0x0b       // vpslld ymm5,ymm5,0xb
+       LONG $0xf26842c4; BYTE $0xe1       // andn   r12d,edx,r9d
+       WORD $0x3141; BYTE $0xfd           // xor    r13d,edi
+       LONG $0xf07b63c4; WORD $0x06f2     // rorx   r14d,edx,0x6
+       LONG $0xe6efddc5                   // vpxor  ymm4,ymm4,ymm6
+       LONG $0x22148d47                   // lea    r10d,[r10+r12*1]
+       WORD $0x3145; BYTE $0xf5           // xor    r13d,r14d
+       WORD $0x8944; BYTE $0xdf           // mov    edi,r11d
+       LONG $0xd772cdc5; BYTE $0x0a       // vpsrld ymm6,ymm7,0xa
+       LONG $0xf07b43c4; WORD $0x16e3     // rorx   r12d,r11d,0x16
+       LONG $0x2a148d47                   // lea    r10d,[r10+r13*1]
+       WORD $0xc731                       // xor    edi,eax
+       LONG $0xe5efddc5                   // vpxor  ymm4,ymm4,ymm5
+       LONG $0xf07b43c4; WORD $0x0df3     // rorx   r14d,r11d,0xd
+       LONG $0xf07b43c4; WORD $0x02eb     // rorx   r13d,r11d,0x2
+       LONG $0x110c8d42                   // lea    ecx,[rcx+r10*1]
+       LONG $0xd773c5c5; BYTE $0x11       // vpsrlq ymm7,ymm7,0x11
+       WORD $0x2141; BYTE $0xff           // and    r15d,edi
+       WORD $0x3145; BYTE $0xe6           // xor    r14d,r12d
+       WORD $0x3141; BYTE $0xc7           // xor    r15d,eax
+       LONG $0xd4feedc5                   // vpaddd ymm2,ymm2,ymm4
+       WORD $0x3145; BYTE $0xee           // xor    r14d,r13d
+       LONG $0x3a148d47                   // lea    r10d,[r10+r15*1]
+       WORD $0x8941; BYTE $0xd4           // mov    r12d,edx
+       LONG $0xf7efcdc5                   // vpxor  ymm6,ymm6,ymm7
+
+       // ROUND(R10, R11, AX, BX, CX, DX, R8, R9, R12, R13, R14, R15, DI, SP, 0x88)
+       LONG $0x248c0344; LONG $0x00000088 // add    r9d,[rsp+0x88]
+       WORD $0x2141; BYTE $0xcc           // and    r12d,ecx
+       LONG $0xf07b63c4; WORD $0x19e9     // rorx   r13d,ecx,0x19
+       LONG $0xd773c5c5; BYTE $0x02       // vpsrlq ymm7,ymm7,0x2
+       LONG $0xf07b63c4; WORD $0x0bf9     // rorx   r15d,ecx,0xb
+       LONG $0x32148d47                   // lea    r10d,[r10+r14*1]
+       LONG $0x210c8d47                   // lea    r9d,[r9+r12*1]
+       LONG $0xf7efcdc5                   // vpxor  ymm6,ymm6,ymm7
+       LONG $0xf27042c4; BYTE $0xe0       // andn   r12d,ecx,r8d
+       WORD $0x3145; BYTE $0xfd           // xor    r13d,r15d
+       LONG $0xf07b63c4; WORD $0x06f1     // rorx   r14d,ecx,0x6
+       LONG $0x004dc2c4; BYTE $0xf0       // vpshufb ymm6,ymm6,ymm8
+       LONG $0x210c8d47                   // lea    r9d,[r9+r12*1]
+       WORD $0x3145; BYTE $0xf5           // xor    r13d,r14d
+       WORD $0x8945; BYTE $0xd7           // mov    r15d,r10d
+       LONG $0xd6feedc5                   // vpaddd ymm2,ymm2,ymm6
+       LONG $0xf07b43c4; WORD $0x16e2     // rorx   r12d,r10d,0x16
+       LONG $0x290c8d47                   // lea    r9d,[r9+r13*1]
+       WORD $0x3145; BYTE $0xdf           // xor    r15d,r11d
+       LONG $0xfa70fdc5; BYTE $0x50       // vpshufd ymm7,ymm2,0x50
+       LONG $0xf07b43c4; WORD $0x0df2     // rorx   r14d,r10d,0xd
+       LONG $0xf07b43c4; WORD $0x02ea     // rorx   r13d,r10d,0x2
+       LONG $0x0b1c8d42                   // lea    ebx,[rbx+r9*1]
+       LONG $0xd772cdc5; BYTE $0x0a       // vpsrld ymm6,ymm7,0xa
+       WORD $0x2144; BYTE $0xff           // and    edi,r15d
+       WORD $0x3145; BYTE $0xe6           // xor    r14d,r12d
+       WORD $0x3144; BYTE $0xdf           // xor    edi,r11d
+       LONG $0xd773c5c5; BYTE $0x11       // vpsrlq ymm7,ymm7,0x11
+       WORD $0x3145; BYTE $0xee           // xor    r14d,r13d
+       LONG $0x390c8d45                   // lea    r9d,[r9+rdi*1]
+       WORD $0x8941; BYTE $0xcc           // mov    r12d,ecx
+       LONG $0xf7efcdc5                   // vpxor  ymm6,ymm6,ymm7
+
+       // ROUND(R9, R10, R11, AX, BX, CX, DX, R8, R12, R13, R14, DI, R15, SP, 0x8c)
+       LONG $0x24840344; LONG $0x0000008c // add    r8d,[rsp+0x8c]
+       WORD $0x2141; BYTE $0xdc           // and    r12d,ebx
+       LONG $0xf07b63c4; WORD $0x19eb     // rorx   r13d,ebx,0x19
+       LONG $0xd773c5c5; BYTE $0x02       // vpsrlq ymm7,ymm7,0x2
+       LONG $0xf07be3c4; WORD $0x0bfb     // rorx   edi,ebx,0xb
+       LONG $0x310c8d47                   // lea    r9d,[r9+r14*1]
+       LONG $0x20048d47                   // lea    r8d,[r8+r12*1]
+       LONG $0xf7efcdc5                   // vpxor  ymm6,ymm6,ymm7
+       LONG $0xf26062c4; BYTE $0xe2       // andn   r12d,ebx,edx
+       WORD $0x3141; BYTE $0xfd           // xor    r13d,edi
+       LONG $0xf07b63c4; WORD $0x06f3     // rorx   r14d,ebx,0x6
+       LONG $0x004dc2c4; BYTE $0xf1       // vpshufb ymm6,ymm6,ymm9
+       LONG $0x20048d47                   // lea    r8d,[r8+r12*1]
+       WORD $0x3145; BYTE $0xf5           // xor    r13d,r14d
+       WORD $0x8944; BYTE $0xcf           // mov    edi,r9d
+       LONG $0xd6feedc5                   // vpaddd ymm2,ymm2,ymm6
+       LONG $0xf07b43c4; WORD $0x16e1     // rorx   r12d,r9d,0x16
+       LONG $0x28048d47                   // lea    r8d,[r8+r13*1]
+       WORD $0x3144; BYTE $0xd7           // xor    edi,r10d
+       LONG $0x75feedc5; BYTE $0x40       // vpaddd ymm6,ymm2,[rbp+0x40]
+       LONG $0xf07b43c4; WORD $0x0df1     // rorx   r14d,r9d,0xd
+       LONG $0xf07b43c4; WORD $0x02e9     // rorx   r13d,r9d,0x2
+       LONG $0x00048d42                   // lea    eax,[rax+r8*1]
+       WORD $0x2141; BYTE $0xff           // and    r15d,edi
+       WORD $0x3145; BYTE $0xe6           // xor    r14d,r12d
+       WORD $0x3145; BYTE $0xd7           // xor    r15d,r10d
+       WORD $0x3145; BYTE $0xee           // xor    r14d,r13d
+       LONG $0x38048d47                   // lea    r8d,[r8+r15*1]
+       WORD $0x8941; BYTE $0xdc           // mov    r12d,ebx
+
+       LONG $0x347ffdc5; BYTE $0x24   // vmovdqa [rsp],ymm6
+       LONG $0x0f7de3c4; WORD $0x04e3 // vpalignr ymm4,ymm0,ymm3,0x4
+
+       // ROUND(R8, R9, R10, R11, AX, BX, CX, DX, R12, R13, R14, R15, DI, SP, 0xa0)
+       LONG $0xa0249403; WORD $0x0000; BYTE $0x00 // add    edx,[rsp+0xa0]
+       WORD $0x2141; BYTE $0xc4                   // and    r12d,eax
+       LONG $0xf07b63c4; WORD $0x19e8             // rorx   r13d,eax,0x19
+       LONG $0x0f6de3c4; WORD $0x04f9             // vpalignr ymm7,ymm2,ymm1,0x4
+       LONG $0xf07b63c4; WORD $0x0bf8             // rorx   r15d,eax,0xb
+       LONG $0x30048d47                           // lea    r8d,[r8+r14*1]
+       LONG $0x22148d42                           // lea    edx,[rdx+r12*1]
+       LONG $0xd472cdc5; BYTE $0x07               // vpsrld ymm6,ymm4,0x7
+       LONG $0xf27862c4; BYTE $0xe1               // andn   r12d,eax,ecx
+       WORD $0x3145; BYTE $0xfd                   // xor    r13d,r15d
+       LONG $0xf07b63c4; WORD $0x06f0             // rorx   r14d,eax,0x6
+       LONG $0xdffee5c5                           // vpaddd ymm3,ymm3,ymm7
+       LONG $0x22148d42                           // lea    edx,[rdx+r12*1]
+       WORD $0x3145; BYTE $0xf5                   // xor    r13d,r14d
+       WORD $0x8945; BYTE $0xc7                   // mov    r15d,r8d
+       LONG $0xd472c5c5; BYTE $0x03               // vpsrld ymm7,ymm4,0x3
+       LONG $0xf07b43c4; WORD $0x16e0             // rorx   r12d,r8d,0x16
+       LONG $0x2a148d42                           // lea    edx,[rdx+r13*1]
+       WORD $0x3145; BYTE $0xcf                   // xor    r15d,r9d
+       LONG $0xf472d5c5; BYTE $0x0e               // vpslld ymm5,ymm4,0xe
+       LONG $0xf07b43c4; WORD $0x0df0             // rorx   r14d,r8d,0xd
+       LONG $0xf07b43c4; WORD $0x02e8             // rorx   r13d,r8d,0x2
+       LONG $0x131c8d45                           // lea    r11d,[r11+rdx*1]
+       LONG $0xe6efc5c5                           // vpxor  ymm4,ymm7,ymm6
+       WORD $0x2144; BYTE $0xff                   // and    edi,r15d
+       WORD $0x3145; BYTE $0xe6                   // xor    r14d,r12d
+       WORD $0x3144; BYTE $0xcf                   // xor    edi,r9d
+       LONG $0xfa70fdc5; BYTE $0xfa               // vpshufd ymm7,ymm2,0xfa
+       WORD $0x3145; BYTE $0xee                   // xor    r14d,r13d
+       WORD $0x148d; BYTE $0x3a                   // lea    edx,[rdx+rdi*1]
+       WORD $0x8941; BYTE $0xc4                   // mov    r12d,eax
+       LONG $0xd672cdc5; BYTE $0x0b               // vpsrld ymm6,ymm6,0xb
+
+       // ROUND(DX, R8, R9, R10, R11, AX, BX, CX, R12, R13, R14, DI, R15, SP, 0xa4)
+       LONG $0xa4248c03; WORD $0x0000; BYTE $0x00 // add    ecx,[rsp+0xa4]
+       WORD $0x2145; BYTE $0xdc                   // and    r12d,r11d
+       LONG $0xf07b43c4; WORD $0x19eb             // rorx   r13d,r11d,0x19
+       LONG $0xe5efddc5                           // vpxor  ymm4,ymm4,ymm5
+       LONG $0xf07bc3c4; WORD $0x0bfb             // rorx   edi,r11d,0xb
+       LONG $0x32148d42                           // lea    edx,[rdx+r14*1]
+       LONG $0x210c8d42                           // lea    ecx,[rcx+r12*1]
+       LONG $0xf572d5c5; BYTE $0x0b               // vpslld ymm5,ymm5,0xb
+       LONG $0xf22062c4; BYTE $0xe3               // andn   r12d,r11d,ebx
+       WORD $0x3141; BYTE $0xfd                   // xor    r13d,edi
+       LONG $0xf07b43c4; WORD $0x06f3             // rorx   r14d,r11d,0x6
+       LONG $0xe6efddc5                           // vpxor  ymm4,ymm4,ymm6
+       LONG $0x210c8d42                           // lea    ecx,[rcx+r12*1]
+       WORD $0x3145; BYTE $0xf5                   // xor    r13d,r14d
+       WORD $0xd789                               // mov    edi,edx
+       LONG $0xd772cdc5; BYTE $0x0a               // vpsrld ymm6,ymm7,0xa
+       LONG $0xf07b63c4; WORD $0x16e2             // rorx   r12d,edx,0x16
+       LONG $0x290c8d42                           // lea    ecx,[rcx+r13*1]
+       WORD $0x3144; BYTE $0xc7                   // xor    edi,r8d
+       LONG $0xe5efddc5                           // vpxor  ymm4,ymm4,ymm5
+       LONG $0xf07b63c4; WORD $0x0df2             // rorx   r14d,edx,0xd
+       LONG $0xf07b63c4; WORD $0x02ea             // rorx   r13d,edx,0x2
+       LONG $0x0a148d45                           // lea    r10d,[r10+rcx*1]
+       LONG $0xd773c5c5; BYTE $0x11               // vpsrlq ymm7,ymm7,0x11
+       WORD $0x2141; BYTE $0xff                   // and    r15d,edi
+       WORD $0x3145; BYTE $0xe6                   // xor    r14d,r12d
+       WORD $0x3145; BYTE $0xc7                   // xor    r15d,r8d
+       LONG $0xdcfee5c5                           // vpaddd ymm3,ymm3,ymm4
+       WORD $0x3145; BYTE $0xee                   // xor    r14d,r13d
+       LONG $0x390c8d42                           // lea    ecx,[rcx+r15*1]
+       WORD $0x8945; BYTE $0xdc                   // mov    r12d,r11d
+       LONG $0xf7efcdc5                           // vpxor  ymm6,ymm6,ymm7
+
+       // ROUND(CX, DX, R8, R9, R10, R11, AX, BX, R12, R13, R14, R15, DI, SP, 0xa8)
+       LONG $0xa8249c03; WORD $0x0000; BYTE $0x00 // add    ebx,[rsp+0xa8]
+       WORD $0x2145; BYTE $0xd4                   // and    r12d,r10d
+       LONG $0xf07b43c4; WORD $0x19ea             // rorx   r13d,r10d,0x19
+       LONG $0xd773c5c5; BYTE $0x02               // vpsrlq ymm7,ymm7,0x2
+       LONG $0xf07b43c4; WORD $0x0bfa             // rorx   r15d,r10d,0xb
+       LONG $0x310c8d42                           // lea    ecx,[rcx+r14*1]
+       LONG $0x231c8d42                           // lea    ebx,[rbx+r12*1]
+       LONG $0xf7efcdc5                           // vpxor  ymm6,ymm6,ymm7
+       LONG $0xf22862c4; BYTE $0xe0               // andn   r12d,r10d,eax
+       WORD $0x3145; BYTE $0xfd                   // xor    r13d,r15d
+       LONG $0xf07b43c4; WORD $0x06f2             // rorx   r14d,r10d,0x6
+       LONG $0x004dc2c4; BYTE $0xf0               // vpshufb ymm6,ymm6,ymm8
+       LONG $0x231c8d42                           // lea    ebx,[rbx+r12*1]
+       WORD $0x3145; BYTE $0xf5                   // xor    r13d,r14d
+       WORD $0x8941; BYTE $0xcf                   // mov    r15d,ecx
+       LONG $0xdefee5c5                           // vpaddd ymm3,ymm3,ymm6
+       LONG $0xf07b63c4; WORD $0x16e1             // rorx   r12d,ecx,0x16
+       LONG $0x2b1c8d42                           // lea    ebx,[rbx+r13*1]
+       WORD $0x3141; BYTE $0xd7                   // xor    r15d,edx
+       LONG $0xfb70fdc5; BYTE $0x50               // vpshufd ymm7,ymm3,0x50
+       LONG $0xf07b63c4; WORD $0x0df1             // rorx   r14d,ecx,0xd
+       LONG $0xf07b63c4; WORD $0x02e9             // rorx   r13d,ecx,0x2
+       LONG $0x190c8d45                           // lea    r9d,[r9+rbx*1]
+       LONG $0xd772cdc5; BYTE $0x0a               // vpsrld ymm6,ymm7,0xa
+       WORD $0x2144; BYTE $0xff                   // and    edi,r15d
+       WORD $0x3145; BYTE $0xe6                   // xor    r14d,r12d
+       WORD $0xd731                               // xor    edi,edx
+       LONG $0xd773c5c5; BYTE $0x11               // vpsrlq ymm7,ymm7,0x11
+       WORD $0x3145; BYTE $0xee                   // xor    r14d,r13d
+       WORD $0x1c8d; BYTE $0x3b                   // lea    ebx,[rbx+rdi*1]
+       WORD $0x8945; BYTE $0xd4                   // mov    r12d,r10d
+       LONG $0xf7efcdc5                           // vpxor  ymm6,ymm6,ymm7
+
+       // ROUND(BX, CX, DX, R8, R9, R10, R11, AX, R12, R13, R14, DI, R15, SP, 0xac)
+       LONG $0xac248403; WORD $0x0000; BYTE $0x00 // add    eax,[rsp+0xac]
+       WORD $0x2145; BYTE $0xcc                   // and    r12d,r9d
+       LONG $0xf07b43c4; WORD $0x19e9             // rorx   r13d,r9d,0x19
+       LONG $0xd773c5c5; BYTE $0x02               // vpsrlq ymm7,ymm7,0x2
+       LONG $0xf07bc3c4; WORD $0x0bf9             // rorx   edi,r9d,0xb
+       LONG $0x331c8d42                           // lea    ebx,[rbx+r14*1]
+       LONG $0x20048d42                           // lea    eax,[rax+r12*1]
+       LONG $0xf7efcdc5                           // vpxor  ymm6,ymm6,ymm7
+       LONG $0xf23042c4; BYTE $0xe3               // andn   r12d,r9d,r11d
+       WORD $0x3141; BYTE $0xfd                   // xor    r13d,edi
+       LONG $0xf07b43c4; WORD $0x06f1             // rorx   r14d,r9d,0x6
+       LONG $0x004dc2c4; BYTE $0xf1               // vpshufb ymm6,ymm6,ymm9
+       LONG $0x20048d42                           // lea    eax,[rax+r12*1]
+       WORD $0x3145; BYTE $0xf5                   // xor    r13d,r14d
+       WORD $0xdf89                               // mov    edi,ebx
+       LONG $0xdefee5c5                           // vpaddd ymm3,ymm3,ymm6
+       LONG $0xf07b63c4; WORD $0x16e3             // rorx   r12d,ebx,0x16
+       LONG $0x28048d42                           // lea    eax,[rax+r13*1]
+       WORD $0xcf31                               // xor    edi,ecx
+       LONG $0x75fee5c5; BYTE $0x60               // vpaddd ymm6,ymm3,[rbp+0x60]
+       LONG $0xf07b63c4; WORD $0x0df3             // rorx   r14d,ebx,0xd
+       LONG $0xf07b63c4; WORD $0x02eb             // rorx   r13d,ebx,0x2
+       LONG $0x00048d45                           // lea    r8d,[r8+rax*1]
+       WORD $0x2141; BYTE $0xff                   // and    r15d,edi
+       WORD $0x3145; BYTE $0xe6                   // xor    r14d,r12d
+       WORD $0x3141; BYTE $0xcf                   // xor    r15d,ecx
+       WORD $0x3145; BYTE $0xee                   // xor    r14d,r13d
+       LONG $0x38048d42                           // lea    eax,[rax+r15*1]
+       WORD $0x8945; BYTE $0xcc                   // mov    r12d,r9d
+
+       LONG $0x747ffdc5; WORD $0x2024 // vmovdqa [rsp+0x20],ymm6
+       ADDQ $0x80, BP
+
+       CMPB 0x3(BP), $0x0
+       JNE  loop1
+
+       // ROUND(AX, BX, CX, DX, R8, R9, R10, R11, R12, R13, R14, R15, DI, SP, 0x40)
+       LONG $0x245c0344; BYTE $0x40   // add    r11d,[rsp+0x40]
+       WORD $0x2145; BYTE $0xc4       // and    r12d,r8d
+       LONG $0xf07b43c4; WORD $0x19e8 // rorx   r13d,r8d,0x19
+       LONG $0xf07b43c4; WORD $0x0bf8 // rorx   r15d,r8d,0xb
+       LONG $0x30048d42               // lea    eax,[rax+r14*1]
+       LONG $0x231c8d47               // lea    r11d,[r11+r12*1]
+       LONG $0xf23842c4; BYTE $0xe2   // andn   r12d,r8d,r10d
+       WORD $0x3145; BYTE $0xfd       // xor    r13d,r15d
+       LONG $0xf07b43c4; WORD $0x06f0 // rorx   r14d,r8d,0x6
+       LONG $0x231c8d47               // lea    r11d,[r11+r12*1]
+       WORD $0x3145; BYTE $0xf5       // xor    r13d,r14d
+       WORD $0x8941; BYTE $0xc7       // mov    r15d,eax
+       LONG $0xf07b63c4; WORD $0x16e0 // rorx   r12d,eax,0x16
+       LONG $0x2b1c8d47               // lea    r11d,[r11+r13*1]
+       WORD $0x3141; BYTE $0xdf       // xor    r15d,ebx
+       LONG $0xf07b63c4; WORD $0x0df0 // rorx   r14d,eax,0xd
+       LONG $0xf07b63c4; WORD $0x02e8 // rorx   r13d,eax,0x2
+       LONG $0x1a148d42               // lea    edx,[rdx+r11*1]
+       WORD $0x2144; BYTE $0xff       // and    edi,r15d
+       WORD $0x3145; BYTE $0xe6       // xor    r14d,r12d
+       WORD $0xdf31                   // xor    edi,ebx
+       WORD $0x3145; BYTE $0xee       // xor    r14d,r13d
+       LONG $0x3b1c8d45               // lea    r11d,[r11+rdi*1]
+       WORD $0x8945; BYTE $0xc4       // mov    r12d,r8d
+
+       // ROUND(R11, AX, BX, CX, DX, R8, R9, R10, R12, R13, R14, DI, R15, SP, 0x44)
+       LONG $0x24540344; BYTE $0x44   // add    r10d,[rsp+0x44]
+       WORD $0x2141; BYTE $0xd4       // and    r12d,edx
+       LONG $0xf07b63c4; WORD $0x19ea // rorx   r13d,edx,0x19
+       LONG $0xf07be3c4; WORD $0x0bfa // rorx   edi,edx,0xb
+       LONG $0x331c8d47               // lea    r11d,[r11+r14*1]
+       LONG $0x22148d47               // lea    r10d,[r10+r12*1]
+       LONG $0xf26842c4; BYTE $0xe1   // andn   r12d,edx,r9d
+       WORD $0x3141; BYTE $0xfd       // xor    r13d,edi
+       LONG $0xf07b63c4; WORD $0x06f2 // rorx   r14d,edx,0x6
+       LONG $0x22148d47               // lea    r10d,[r10+r12*1]
+       WORD $0x3145; BYTE $0xf5       // xor    r13d,r14d
+       WORD $0x8944; BYTE $0xdf       // mov    edi,r11d
+       LONG $0xf07b43c4; WORD $0x16e3 // rorx   r12d,r11d,0x16
+       LONG $0x2a148d47               // lea    r10d,[r10+r13*1]
+       WORD $0xc731                   // xor    edi,eax
+       LONG $0xf07b43c4; WORD $0x0df3 // rorx   r14d,r11d,0xd
+       LONG $0xf07b43c4; WORD $0x02eb // rorx   r13d,r11d,0x2
+       LONG $0x110c8d42               // lea    ecx,[rcx+r10*1]
+       WORD $0x2141; BYTE $0xff       // and    r15d,edi
+       WORD $0x3145; BYTE $0xe6       // xor    r14d,r12d
+       WORD $0x3141; BYTE $0xc7       // xor    r15d,eax
+       WORD $0x3145; BYTE $0xee       // xor    r14d,r13d
+       LONG $0x3a148d47               // lea    r10d,[r10+r15*1]
+       WORD $0x8941; BYTE $0xd4       // mov    r12d,edx
+
+       // ROUND(R10, R11, AX, BX, CX, DX, R8, R9, R12, R13, R14, R15, DI, SP, 0x48)
+       LONG $0x244c0344; BYTE $0x48   // add    r9d,[rsp+0x48]
+       WORD $0x2141; BYTE $0xcc       // and    r12d,ecx
+       LONG $0xf07b63c4; WORD $0x19e9 // rorx   r13d,ecx,0x19
+       LONG $0xf07b63c4; WORD $0x0bf9 // rorx   r15d,ecx,0xb
+       LONG $0x32148d47               // lea    r10d,[r10+r14*1]
+       LONG $0x210c8d47               // lea    r9d,[r9+r12*1]
+       LONG $0xf27042c4; BYTE $0xe0   // andn   r12d,ecx,r8d
+       WORD $0x3145; BYTE $0xfd       // xor    r13d,r15d
+       LONG $0xf07b63c4; WORD $0x06f1 // rorx   r14d,ecx,0x6
+       LONG $0x210c8d47               // lea    r9d,[r9+r12*1]
+       WORD $0x3145; BYTE $0xf5       // xor    r13d,r14d
+       WORD $0x8945; BYTE $0xd7       // mov    r15d,r10d
+       LONG $0xf07b43c4; WORD $0x16e2 // rorx   r12d,r10d,0x16
+       LONG $0x290c8d47               // lea    r9d,[r9+r13*1]
+       WORD $0x3145; BYTE $0xdf       // xor    r15d,r11d
+       LONG $0xf07b43c4; WORD $0x0df2 // rorx   r14d,r10d,0xd
+       LONG $0xf07b43c4; WORD $0x02ea // rorx   r13d,r10d,0x2
+       LONG $0x0b1c8d42               // lea    ebx,[rbx+r9*1]
+       WORD $0x2144; BYTE $0xff       // and    edi,r15d
+       WORD $0x3145; BYTE $0xe6       // xor    r14d,r12d
+       WORD $0x3144; BYTE $0xdf       // xor    edi,r11d
+       WORD $0x3145; BYTE $0xee       // xor    r14d,r13d
+       LONG $0x390c8d45               // lea    r9d,[r9+rdi*1]
+       WORD $0x8941; BYTE $0xcc       // mov    r12d,ecx
+
+       // ROUND(R9, R10, R11, AX, BX, CX, DX, R8, R12, R13, R14, DI, R15, SP, 0x4c)
+       LONG $0x24440344; BYTE $0x4c   // add    r8d,[rsp+0x4c]
+       WORD $0x2141; BYTE $0xdc       // and    r12d,ebx
+       LONG $0xf07b63c4; WORD $0x19eb // rorx   r13d,ebx,0x19
+       LONG $0xf07be3c4; WORD $0x0bfb // rorx   edi,ebx,0xb
+       LONG $0x310c8d47               // lea    r9d,[r9+r14*1]
+       LONG $0x20048d47               // lea    r8d,[r8+r12*1]
+       LONG $0xf26062c4; BYTE $0xe2   // andn   r12d,ebx,edx
+       WORD $0x3141; BYTE $0xfd       // xor    r13d,edi
+       LONG $0xf07b63c4; WORD $0x06f3 // rorx   r14d,ebx,0x6
+       LONG $0x20048d47               // lea    r8d,[r8+r12*1]
+       WORD $0x3145; BYTE $0xf5       // xor    r13d,r14d
+       WORD $0x8944; BYTE $0xcf       // mov    edi,r9d
+       LONG $0xf07b43c4; WORD $0x16e1 // rorx   r12d,r9d,0x16
+       LONG $0x28048d47               // lea    r8d,[r8+r13*1]
+       WORD $0x3144; BYTE $0xd7       // xor    edi,r10d
+       LONG $0xf07b43c4; WORD $0x0df1 // rorx   r14d,r9d,0xd
+       LONG $0xf07b43c4; WORD $0x02e9 // rorx   r13d,r9d,0x2
+       LONG $0x00048d42               // lea    eax,[rax+r8*1]
+       WORD $0x2141; BYTE $0xff       // and    r15d,edi
+       WORD $0x3145; BYTE $0xe6       // xor    r14d,r12d
+       WORD $0x3145; BYTE $0xd7       // xor    r15d,r10d
+       WORD $0x3145; BYTE $0xee       // xor    r14d,r13d
+       LONG $0x38048d47               // lea    r8d,[r8+r15*1]
+       WORD $0x8941; BYTE $0xdc       // mov    r12d,ebx
+
+       // ROUND(R8, R9, R10, R11, AX, BX, CX, DX, R12, R13, R14, R15, DI, SP, 0x60)
+       LONG $0x60245403               // add    edx,[rsp+0x60]
+       WORD $0x2141; BYTE $0xc4       // and    r12d,eax
+       LONG $0xf07b63c4; WORD $0x19e8 // rorx   r13d,eax,0x19
+       LONG $0xf07b63c4; WORD $0x0bf8 // rorx   r15d,eax,0xb
+       LONG $0x30048d47               // lea    r8d,[r8+r14*1]
+       LONG $0x22148d42               // lea    edx,[rdx+r12*1]
+       LONG $0xf27862c4; BYTE $0xe1   // andn   r12d,eax,ecx
+       WORD $0x3145; BYTE $0xfd       // xor    r13d,r15d
+       LONG $0xf07b63c4; WORD $0x06f0 // rorx   r14d,eax,0x6
+       LONG $0x22148d42               // lea    edx,[rdx+r12*1]
+       WORD $0x3145; BYTE $0xf5       // xor    r13d,r14d
+       WORD $0x8945; BYTE $0xc7       // mov    r15d,r8d
+       LONG $0xf07b43c4; WORD $0x16e0 // rorx   r12d,r8d,0x16
+       LONG $0x2a148d42               // lea    edx,[rdx+r13*1]
+       WORD $0x3145; BYTE $0xcf       // xor    r15d,r9d
+       LONG $0xf07b43c4; WORD $0x0df0 // rorx   r14d,r8d,0xd
+       LONG $0xf07b43c4; WORD $0x02e8 // rorx   r13d,r8d,0x2
+       LONG $0x131c8d45               // lea    r11d,[r11+rdx*1]
+       WORD $0x2144; BYTE $0xff       // and    edi,r15d
+       WORD $0x3145; BYTE $0xe6       // xor    r14d,r12d
+       WORD $0x3144; BYTE $0xcf       // xor    edi,r9d
+       WORD $0x3145; BYTE $0xee       // xor    r14d,r13d
+       WORD $0x148d; BYTE $0x3a       // lea    edx,[rdx+rdi*1]
+       WORD $0x8941; BYTE $0xc4       // mov    r12d,eax
+
+       // ROUND(DX, R8, R9, R10, R11, AX, BX, CX, R12, R13, R14, DI, R15, SP, 0x64)
+       LONG $0x64244c03               // add    ecx,[rsp+0x64]
+       WORD $0x2145; BYTE $0xdc       // and    r12d,r11d
+       LONG $0xf07b43c4; WORD $0x19eb // rorx   r13d,r11d,0x19
+       LONG $0xf07bc3c4; WORD $0x0bfb // rorx   edi,r11d,0xb
+       LONG $0x32148d42               // lea    edx,[rdx+r14*1]
+       LONG $0x210c8d42               // lea    ecx,[rcx+r12*1]
+       LONG $0xf22062c4; BYTE $0xe3   // andn   r12d,r11d,ebx
+       WORD $0x3141; BYTE $0xfd       // xor    r13d,edi
+       LONG $0xf07b43c4; WORD $0x06f3 // rorx   r14d,r11d,0x6
+       LONG $0x210c8d42               // lea    ecx,[rcx+r12*1]
+       WORD $0x3145; BYTE $0xf5       // xor    r13d,r14d
+       WORD $0xd789                   // mov    edi,edx
+       LONG $0xf07b63c4; WORD $0x16e2 // rorx   r12d,edx,0x16
+       LONG $0x290c8d42               // lea    ecx,[rcx+r13*1]
+       WORD $0x3144; BYTE $0xc7       // xor    edi,r8d
+       LONG $0xf07b63c4; WORD $0x0df2 // rorx   r14d,edx,0xd
+       LONG $0xf07b63c4; WORD $0x02ea // rorx   r13d,edx,0x2
+       LONG $0x0a148d45               // lea    r10d,[r10+rcx*1]
+       WORD $0x2141; BYTE $0xff       // and    r15d,edi
+       WORD $0x3145; BYTE $0xe6       // xor    r14d,r12d
+       WORD $0x3145; BYTE $0xc7       // xor    r15d,r8d
+       WORD $0x3145; BYTE $0xee       // xor    r14d,r13d
+       LONG $0x390c8d42               // lea    ecx,[rcx+r15*1]
+       WORD $0x8945; BYTE $0xdc       // mov    r12d,r11d
+
+       // ROUND(CX, DX, R8, R9, R10, R11, AX, BX, R12, R13, R14, R15, DI, SP, 0x68)
+       LONG $0x68245c03               // add    ebx,[rsp+0x68]
+       WORD $0x2145; BYTE $0xd4       // and    r12d,r10d
+       LONG $0xf07b43c4; WORD $0x19ea // rorx   r13d,r10d,0x19
+       LONG $0xf07b43c4; WORD $0x0bfa // rorx   r15d,r10d,0xb
+       LONG $0x310c8d42               // lea    ecx,[rcx+r14*1]
+       LONG $0x231c8d42               // lea    ebx,[rbx+r12*1]
+       LONG $0xf22862c4; BYTE $0xe0   // andn   r12d,r10d,eax
+       WORD $0x3145; BYTE $0xfd       // xor    r13d,r15d
+       LONG $0xf07b43c4; WORD $0x06f2 // rorx   r14d,r10d,0x6
+       LONG $0x231c8d42               // lea    ebx,[rbx+r12*1]
+       WORD $0x3145; BYTE $0xf5       // xor    r13d,r14d
+       WORD $0x8941; BYTE $0xcf       // mov    r15d,ecx
+       LONG $0xf07b63c4; WORD $0x16e1 // rorx   r12d,ecx,0x16
+       LONG $0x2b1c8d42               // lea    ebx,[rbx+r13*1]
+       WORD $0x3141; BYTE $0xd7       // xor    r15d,edx
+       LONG $0xf07b63c4; WORD $0x0df1 // rorx   r14d,ecx,0xd
+       LONG $0xf07b63c4; WORD $0x02e9 // rorx   r13d,ecx,0x2
+       LONG $0x190c8d45               // lea    r9d,[r9+rbx*1]
+       WORD $0x2144; BYTE $0xff       // and    edi,r15d
+       WORD $0x3145; BYTE $0xe6       // xor    r14d,r12d
+       WORD $0xd731                   // xor    edi,edx
+       WORD $0x3145; BYTE $0xee       // xor    r14d,r13d
+       WORD $0x1c8d; BYTE $0x3b       // lea    ebx,[rbx+rdi*1]
+       WORD $0x8945; BYTE $0xd4       // mov    r12d,r10d
+
+       // ROUND(BX, CX, DX, R8, R9, R10, R11, AX, R12, R13, R14, DI, R15, SP, 0x6c)
+       LONG $0x6c244403               // add    eax,[rsp+0x6c]
+       WORD $0x2145; BYTE $0xcc       // and    r12d,r9d
+       LONG $0xf07b43c4; WORD $0x19e9 // rorx   r13d,r9d,0x19
+       LONG $0xf07bc3c4; WORD $0x0bf9 // rorx   edi,r9d,0xb
+       LONG $0x331c8d42               // lea    ebx,[rbx+r14*1]
+       LONG $0x20048d42               // lea    eax,[rax+r12*1]
+       LONG $0xf23042c4; BYTE $0xe3   // andn   r12d,r9d,r11d
+       WORD $0x3141; BYTE $0xfd       // xor    r13d,edi
+       LONG $0xf07b43c4; WORD $0x06f1 // rorx   r14d,r9d,0x6
+       LONG $0x20048d42               // lea    eax,[rax+r12*1]
+       WORD $0x3145; BYTE $0xf5       // xor    r13d,r14d
+       WORD $0xdf89                   // mov    edi,ebx
+       LONG $0xf07b63c4; WORD $0x16e3 // rorx   r12d,ebx,0x16
+       LONG $0x28048d42               // lea    eax,[rax+r13*1]
+       WORD $0xcf31                   // xor    edi,ecx
+       LONG $0xf07b63c4; WORD $0x0df3 // rorx   r14d,ebx,0xd
+       LONG $0xf07b63c4; WORD $0x02eb // rorx   r13d,ebx,0x2
+       LONG $0x00048d45               // lea    r8d,[r8+rax*1]
+       WORD $0x2141; BYTE $0xff       // and    r15d,edi
+       WORD $0x3145; BYTE $0xe6       // xor    r14d,r12d
+       WORD $0x3141; BYTE $0xcf       // xor    r15d,ecx
+       WORD $0x3145; BYTE $0xee       // xor    r14d,r13d
+       LONG $0x38048d42               // lea    eax,[rax+r15*1]
+       WORD $0x8945; BYTE $0xcc       // mov    r12d,r9d
+
+       // ROUND(AX, BX, CX, DX, R8, R9, R10, R11, R12, R13, R14, R15, DI, SP, 0x00)
+       LONG $0x241c0344               // add    r11d,[rsp]
+       WORD $0x2145; BYTE $0xc4       // and    r12d,r8d
+       LONG $0xf07b43c4; WORD $0x19e8 // rorx   r13d,r8d,0x19
+       LONG $0xf07b43c4; WORD $0x0bf8 // rorx   r15d,r8d,0xb
+       LONG $0x30048d42               // lea    eax,[rax+r14*1]
+       LONG $0x231c8d47               // lea    r11d,[r11+r12*1]
+       LONG $0xf23842c4; BYTE $0xe2   // andn   r12d,r8d,r10d
+       WORD $0x3145; BYTE $0xfd       // xor    r13d,r15d
+       LONG $0xf07b43c4; WORD $0x06f0 // rorx   r14d,r8d,0x6
+       LONG $0x231c8d47               // lea    r11d,[r11+r12*1]
+       WORD $0x3145; BYTE $0xf5       // xor    r13d,r14d
+       WORD $0x8941; BYTE $0xc7       // mov    r15d,eax
+       LONG $0xf07b63c4; WORD $0x16e0 // rorx   r12d,eax,0x16
+       LONG $0x2b1c8d47               // lea    r11d,[r11+r13*1]
+       WORD $0x3141; BYTE $0xdf       // xor    r15d,ebx
+       LONG $0xf07b63c4; WORD $0x0df0 // rorx   r14d,eax,0xd
+       LONG $0xf07b63c4; WORD $0x02e8 // rorx   r13d,eax,0x2
+       LONG $0x1a148d42               // lea    edx,[rdx+r11*1]
+       WORD $0x2144; BYTE $0xff       // and    edi,r15d
+       WORD $0x3145; BYTE $0xe6       // xor    r14d,r12d
+       WORD $0xdf31                   // xor    edi,ebx
+       WORD $0x3145; BYTE $0xee       // xor    r14d,r13d
+       LONG $0x3b1c8d45               // lea    r11d,[r11+rdi*1]
+       WORD $0x8945; BYTE $0xc4       // mov    r12d,r8d
+
+       // ROUND(R11, AX, BX, CX, DX, R8, R9, R10, R12, R13, R14, DI, R15, SP, 0x04)
+       LONG $0x24540344; BYTE $0x04   // add    r10d,[rsp+0x4]
+       WORD $0x2141; BYTE $0xd4       // and    r12d,edx
+       LONG $0xf07b63c4; WORD $0x19ea // rorx   r13d,edx,0x19
+       LONG $0xf07be3c4; WORD $0x0bfa // rorx   edi,edx,0xb
+       LONG $0x331c8d47               // lea    r11d,[r11+r14*1]
+       LONG $0x22148d47               // lea    r10d,[r10+r12*1]
+       LONG $0xf26842c4; BYTE $0xe1   // andn   r12d,edx,r9d
+       WORD $0x3141; BYTE $0xfd       // xor    r13d,edi
+       LONG $0xf07b63c4; WORD $0x06f2 // rorx   r14d,edx,0x6
+       LONG $0x22148d47               // lea    r10d,[r10+r12*1]
+       WORD $0x3145; BYTE $0xf5       // xor    r13d,r14d
+       WORD $0x8944; BYTE $0xdf       // mov    edi,r11d
+       LONG $0xf07b43c4; WORD $0x16e3 // rorx   r12d,r11d,0x16
+       LONG $0x2a148d47               // lea    r10d,[r10+r13*1]
+       WORD $0xc731                   // xor    edi,eax
+       LONG $0xf07b43c4; WORD $0x0df3 // rorx   r14d,r11d,0xd
+       LONG $0xf07b43c4; WORD $0x02eb // rorx   r13d,r11d,0x2
+       LONG $0x110c8d42               // lea    ecx,[rcx+r10*1]
+       WORD $0x2141; BYTE $0xff       // and    r15d,edi
+       WORD $0x3145; BYTE $0xe6       // xor    r14d,r12d
+       WORD $0x3141; BYTE $0xc7       // xor    r15d,eax
+       WORD $0x3145; BYTE $0xee       // xor    r14d,r13d
+       LONG $0x3a148d47               // lea    r10d,[r10+r15*1]
+       WORD $0x8941; BYTE $0xd4       // mov    r12d,edx
+
+       // ROUND(R10, R11, AX, BX, CX, DX, R8, R9, R12, R13, R14, R15, DI, SP, 0x08)
+       LONG $0x244c0344; BYTE $0x08   // add    r9d,[rsp+0x8]
+       WORD $0x2141; BYTE $0xcc       // and    r12d,ecx
+       LONG $0xf07b63c4; WORD $0x19e9 // rorx   r13d,ecx,0x19
+       LONG $0xf07b63c4; WORD $0x0bf9 // rorx   r15d,ecx,0xb
+       LONG $0x32148d47               // lea    r10d,[r10+r14*1]
+       LONG $0x210c8d47               // lea    r9d,[r9+r12*1]
+       LONG $0xf27042c4; BYTE $0xe0   // andn   r12d,ecx,r8d
+       WORD $0x3145; BYTE $0xfd       // xor    r13d,r15d
+       LONG $0xf07b63c4; WORD $0x06f1 // rorx   r14d,ecx,0x6
+       LONG $0x210c8d47               // lea    r9d,[r9+r12*1]
+       WORD $0x3145; BYTE $0xf5       // xor    r13d,r14d
+       WORD $0x8945; BYTE $0xd7       // mov    r15d,r10d
+       LONG $0xf07b43c4; WORD $0x16e2 // rorx   r12d,r10d,0x16
+       LONG $0x290c8d47               // lea    r9d,[r9+r13*1]
+       WORD $0x3145; BYTE $0xdf       // xor    r15d,r11d
+       LONG $0xf07b43c4; WORD $0x0df2 // rorx   r14d,r10d,0xd
+       LONG $0xf07b43c4; WORD $0x02ea // rorx   r13d,r10d,0x2
+       LONG $0x0b1c8d42               // lea    ebx,[rbx+r9*1]
+       WORD $0x2144; BYTE $0xff       // and    edi,r15d
+       WORD $0x3145; BYTE $0xe6       // xor    r14d,r12d
+       WORD $0x3144; BYTE $0xdf       // xor    edi,r11d
+       WORD $0x3145; BYTE $0xee       // xor    r14d,r13d
+       LONG $0x390c8d45               // lea    r9d,[r9+rdi*1]
+       WORD $0x8941; BYTE $0xcc       // mov    r12d,ecx
+
+       // ROUND(R9, R10, R11, AX, BX, CX, DX, R8, R12, R13, R14, DI, R15, SP, 0x0c)
+       LONG $0x24440344; BYTE $0x0c   // add    r8d,[rsp+0xc]
+       WORD $0x2141; BYTE $0xdc       // and    r12d,ebx
+       LONG $0xf07b63c4; WORD $0x19eb // rorx   r13d,ebx,0x19
+       LONG $0xf07be3c4; WORD $0x0bfb // rorx   edi,ebx,0xb
+       LONG $0x310c8d47               // lea    r9d,[r9+r14*1]
+       LONG $0x20048d47               // lea    r8d,[r8+r12*1]
+       LONG $0xf26062c4; BYTE $0xe2   // andn   r12d,ebx,edx
+       WORD $0x3141; BYTE $0xfd       // xor    r13d,edi
+       LONG $0xf07b63c4; WORD $0x06f3 // rorx   r14d,ebx,0x6
+       LONG $0x20048d47               // lea    r8d,[r8+r12*1]
+       WORD $0x3145; BYTE $0xf5       // xor    r13d,r14d
+       WORD $0x8944; BYTE $0xcf       // mov    edi,r9d
+       LONG $0xf07b43c4; WORD $0x16e1 // rorx   r12d,r9d,0x16
+       LONG $0x28048d47               // lea    r8d,[r8+r13*1]
+       WORD $0x3144; BYTE $0xd7       // xor    edi,r10d
+       LONG $0xf07b43c4; WORD $0x0df1 // rorx   r14d,r9d,0xd
+       LONG $0xf07b43c4; WORD $0x02e9 // rorx   r13d,r9d,0x2
+       LONG $0x00048d42               // lea    eax,[rax+r8*1]
+       WORD $0x2141; BYTE $0xff       // and    r15d,edi
+       WORD $0x3145; BYTE $0xe6       // xor    r14d,r12d
+       WORD $0x3145; BYTE $0xd7       // xor    r15d,r10d
+       WORD $0x3145; BYTE $0xee       // xor    r14d,r13d
+       LONG $0x38048d47               // lea    r8d,[r8+r15*1]
+       WORD $0x8941; BYTE $0xdc       // mov    r12d,ebx
+
+       // ROUND(R8, R9, R10, R11, AX, BX, CX, DX, R12, R13, R14, R15, DI, SP, 0x20)
+       LONG $0x20245403               // add    edx,[rsp+0x20]
+       WORD $0x2141; BYTE $0xc4       // and    r12d,eax
+       LONG $0xf07b63c4; WORD $0x19e8 // rorx   r13d,eax,0x19
+       LONG $0xf07b63c4; WORD $0x0bf8 // rorx   r15d,eax,0xb
+       LONG $0x30048d47               // lea    r8d,[r8+r14*1]
+       LONG $0x22148d42               // lea    edx,[rdx+r12*1]
+       LONG $0xf27862c4; BYTE $0xe1   // andn   r12d,eax,ecx
+       WORD $0x3145; BYTE $0xfd       // xor    r13d,r15d
+       LONG $0xf07b63c4; WORD $0x06f0 // rorx   r14d,eax,0x6
+       LONG $0x22148d42               // lea    edx,[rdx+r12*1]
+       WORD $0x3145; BYTE $0xf5       // xor    r13d,r14d
+       WORD $0x8945; BYTE $0xc7       // mov    r15d,r8d
+       LONG $0xf07b43c4; WORD $0x16e0 // rorx   r12d,r8d,0x16
+       LONG $0x2a148d42               // lea    edx,[rdx+r13*1]
+       WORD $0x3145; BYTE $0xcf       // xor    r15d,r9d
+       LONG $0xf07b43c4; WORD $0x0df0 // rorx   r14d,r8d,0xd
+       LONG $0xf07b43c4; WORD $0x02e8 // rorx   r13d,r8d,0x2
+       LONG $0x131c8d45               // lea    r11d,[r11+rdx*1]
+       WORD $0x2144; BYTE $0xff       // and    edi,r15d
+       WORD $0x3145; BYTE $0xe6       // xor    r14d,r12d
+       WORD $0x3144; BYTE $0xcf       // xor    edi,r9d
+       WORD $0x3145; BYTE $0xee       // xor    r14d,r13d
+       WORD $0x148d; BYTE $0x3a       // lea    edx,[rdx+rdi*1]
+       WORD $0x8941; BYTE $0xc4       // mov    r12d,eax
+
+       // ROUND(DX, R8, R9, R10, R11, AX, BX, CX, R12, R13, R14, DI, R15, SP, 0x24)
+       LONG $0x24244c03               // add    ecx,[rsp+0x24]
+       WORD $0x2145; BYTE $0xdc       // and    r12d,r11d
+       LONG $0xf07b43c4; WORD $0x19eb // rorx   r13d,r11d,0x19
+       LONG $0xf07bc3c4; WORD $0x0bfb // rorx   edi,r11d,0xb
+       LONG $0x32148d42               // lea    edx,[rdx+r14*1]
+       LONG $0x210c8d42               // lea    ecx,[rcx+r12*1]
+       LONG $0xf22062c4; BYTE $0xe3   // andn   r12d,r11d,ebx
+       WORD $0x3141; BYTE $0xfd       // xor    r13d,edi
+       LONG $0xf07b43c4; WORD $0x06f3 // rorx   r14d,r11d,0x6
+       LONG $0x210c8d42               // lea    ecx,[rcx+r12*1]
+       WORD $0x3145; BYTE $0xf5       // xor    r13d,r14d
+       WORD $0xd789                   // mov    edi,edx
+       LONG $0xf07b63c4; WORD $0x16e2 // rorx   r12d,edx,0x16
+       LONG $0x290c8d42               // lea    ecx,[rcx+r13*1]
+       WORD $0x3144; BYTE $0xc7       // xor    edi,r8d
+       LONG $0xf07b63c4; WORD $0x0df2 // rorx   r14d,edx,0xd
+       LONG $0xf07b63c4; WORD $0x02ea // rorx   r13d,edx,0x2
+       LONG $0x0a148d45               // lea    r10d,[r10+rcx*1]
+       WORD $0x2141; BYTE $0xff       // and    r15d,edi
+       WORD $0x3145; BYTE $0xe6       // xor    r14d,r12d
+       WORD $0x3145; BYTE $0xc7       // xor    r15d,r8d
+       WORD $0x3145; BYTE $0xee       // xor    r14d,r13d
+       LONG $0x390c8d42               // lea    ecx,[rcx+r15*1]
+       WORD $0x8945; BYTE $0xdc       // mov    r12d,r11d
+
+       // ROUND(CX, DX, R8, R9, R10, R11, AX, BX, R12, R13, R14, R15, DI, SP, 0x28)
+       LONG $0x28245c03               // add    ebx,[rsp+0x28]
+       WORD $0x2145; BYTE $0xd4       // and    r12d,r10d
+       LONG $0xf07b43c4; WORD $0x19ea // rorx   r13d,r10d,0x19
+       LONG $0xf07b43c4; WORD $0x0bfa // rorx   r15d,r10d,0xb
+       LONG $0x310c8d42               // lea    ecx,[rcx+r14*1]
+       LONG $0x231c8d42               // lea    ebx,[rbx+r12*1]
+       LONG $0xf22862c4; BYTE $0xe0   // andn   r12d,r10d,eax
+       WORD $0x3145; BYTE $0xfd       // xor    r13d,r15d
+       LONG $0xf07b43c4; WORD $0x06f2 // rorx   r14d,r10d,0x6
+       LONG $0x231c8d42               // lea    ebx,[rbx+r12*1]
+       WORD $0x3145; BYTE $0xf5       // xor    r13d,r14d
+       WORD $0x8941; BYTE $0xcf       // mov    r15d,ecx
+       LONG $0xf07b63c4; WORD $0x16e1 // rorx   r12d,ecx,0x16
+       LONG $0x2b1c8d42               // lea    ebx,[rbx+r13*1]
+       WORD $0x3141; BYTE $0xd7       // xor    r15d,edx
+       LONG $0xf07b63c4; WORD $0x0df1 // rorx   r14d,ecx,0xd
+       LONG $0xf07b63c4; WORD $0x02e9 // rorx   r13d,ecx,0x2
+       LONG $0x190c8d45               // lea    r9d,[r9+rbx*1]
+       WORD $0x2144; BYTE $0xff       // and    edi,r15d
+       WORD $0x3145; BYTE $0xe6       // xor    r14d,r12d
+       WORD $0xd731                   // xor    edi,edx
+       WORD $0x3145; BYTE $0xee       // xor    r14d,r13d
+       WORD $0x1c8d; BYTE $0x3b       // lea    ebx,[rbx+rdi*1]
+       WORD $0x8945; BYTE $0xd4       // mov    r12d,r10d
+
+       // ROUND(BX, CX, DX, R8, R9, R10, R11, AX, R12, R13, R14, DI, R15, SP, 0x2c)
+       LONG $0x2c244403               // add    eax,[rsp+0x2c]
+       WORD $0x2145; BYTE $0xcc       // and    r12d,r9d
+       LONG $0xf07b43c4; WORD $0x19e9 // rorx   r13d,r9d,0x19
+       LONG $0xf07bc3c4; WORD $0x0bf9 // rorx   edi,r9d,0xb
+       LONG $0x331c8d42               // lea    ebx,[rbx+r14*1]
+       LONG $0x20048d42               // lea    eax,[rax+r12*1]
+       LONG $0xf23042c4; BYTE $0xe3   // andn   r12d,r9d,r11d
+       WORD $0x3141; BYTE $0xfd       // xor    r13d,edi
+       LONG $0xf07b43c4; WORD $0x06f1 // rorx   r14d,r9d,0x6
+       LONG $0x20048d42               // lea    eax,[rax+r12*1]
+       WORD $0x3145; BYTE $0xf5       // xor    r13d,r14d
+       WORD $0xdf89                   // mov    edi,ebx
+       LONG $0xf07b63c4; WORD $0x16e3 // rorx   r12d,ebx,0x16
+       LONG $0x28048d42               // lea    eax,[rax+r13*1]
+       WORD $0xcf31                   // xor    edi,ecx
+       LONG $0xf07b63c4; WORD $0x0df3 // rorx   r14d,ebx,0xd
+       LONG $0xf07b63c4; WORD $0x02eb // rorx   r13d,ebx,0x2
+       LONG $0x00048d45               // lea    r8d,[r8+rax*1]
+       WORD $0x2141; BYTE $0xff       // and    r15d,edi
+       WORD $0x3145; BYTE $0xe6       // xor    r14d,r12d
+       WORD $0x3141; BYTE $0xcf       // xor    r15d,ecx
+       WORD $0x3145; BYTE $0xee       // xor    r14d,r13d
+       LONG $0x38048d42               // lea    eax,[rax+r15*1]
+       WORD $0x8945; BYTE $0xcc       // mov    r12d,r9d
+
+       MOVQ 0x200(SP), DI // $_ctx
+       ADDQ R14, AX
+
+       LEAQ 0x1c0(SP), BP
+
+       ADDL (DI), AX
+       ADDL 4(DI), BX
+       ADDL 8(DI), CX
+       ADDL 12(DI), DX
+       ADDL 16(DI), R8
+       ADDL 20(DI), R9
+       ADDL 24(DI), R10
+       ADDL 28(DI), R11
+
+       MOVL AX, (DI)
+       MOVL BX, 4(DI)
+       MOVL CX, 8(DI)
+       MOVL DX, 12(DI)
+       MOVL R8, 16(DI)
+       MOVL R9, 20(DI)
+       MOVL R10, 24(DI)
+       MOVL R11, 28(DI)
+
+       CMPQ SI, 0x50(BP) // $_end
+       JE   done
+
+       XORQ R14, R14
+       MOVQ BX, DI
+       XORQ CX, DI   // magic
+       MOVQ R9, R12
+
+loop2:
+       // ROUND(AX, BX, CX, DX, R8, R9, R10, R11, R12, R13, R14, R15, DI, BP, 0x10)
+       LONG $0x105d0344               // add    r11d,[rbp+0x10]
+       WORD $0x2145; BYTE $0xc4       // and    r12d,r8d
+       LONG $0xf07b43c4; WORD $0x19e8 // rorx   r13d,r8d,0x19
+       LONG $0xf07b43c4; WORD $0x0bf8 // rorx   r15d,r8d,0xb
+       LONG $0x30048d42               // lea    eax,[rax+r14*1]
+       LONG $0x231c8d47               // lea    r11d,[r11+r12*1]
+       LONG $0xf23842c4; BYTE $0xe2   // andn   r12d,r8d,r10d
+       WORD $0x3145; BYTE $0xfd       // xor    r13d,r15d
+       LONG $0xf07b43c4; WORD $0x06f0 // rorx   r14d,r8d,0x6
+       LONG $0x231c8d47               // lea    r11d,[r11+r12*1]
+       WORD $0x3145; BYTE $0xf5       // xor    r13d,r14d
+       WORD $0x8941; BYTE $0xc7       // mov    r15d,eax
+       LONG $0xf07b63c4; WORD $0x16e0 // rorx   r12d,eax,0x16
+       LONG $0x2b1c8d47               // lea    r11d,[r11+r13*1]
+       WORD $0x3141; BYTE $0xdf       // xor    r15d,ebx
+       LONG $0xf07b63c4; WORD $0x0df0 // rorx   r14d,eax,0xd
+       LONG $0xf07b63c4; WORD $0x02e8 // rorx   r13d,eax,0x2
+       LONG $0x1a148d42               // lea    edx,[rdx+r11*1]
+       WORD $0x2144; BYTE $0xff       // and    edi,r15d
+       WORD $0x3145; BYTE $0xe6       // xor    r14d,r12d
+       WORD $0xdf31                   // xor    edi,ebx
+       WORD $0x3145; BYTE $0xee       // xor    r14d,r13d
+       LONG $0x3b1c8d45               // lea    r11d,[r11+rdi*1]
+       WORD $0x8945; BYTE $0xc4       // mov    r12d,r8d
+
+       // ROUND(R11, AX, BX, CX, DX, R8, R9, R10, R12, R13, R14, DI, R15, BP, 0x14)
+       LONG $0x14550344               // add    r10d,[rbp+0x14]
+       WORD $0x2141; BYTE $0xd4       // and    r12d,edx
+       LONG $0xf07b63c4; WORD $0x19ea // rorx   r13d,edx,0x19
+       LONG $0xf07be3c4; WORD $0x0bfa // rorx   edi,edx,0xb
+       LONG $0x331c8d47               // lea    r11d,[r11+r14*1]
+       LONG $0x22148d47               // lea    r10d,[r10+r12*1]
+       LONG $0xf26842c4; BYTE $0xe1   // andn   r12d,edx,r9d
+       WORD $0x3141; BYTE $0xfd       // xor    r13d,edi
+       LONG $0xf07b63c4; WORD $0x06f2 // rorx   r14d,edx,0x6
+       LONG $0x22148d47               // lea    r10d,[r10+r12*1]
+       WORD $0x3145; BYTE $0xf5       // xor    r13d,r14d
+       WORD $0x8944; BYTE $0xdf       // mov    edi,r11d
+       LONG $0xf07b43c4; WORD $0x16e3 // rorx   r12d,r11d,0x16
+       LONG $0x2a148d47               // lea    r10d,[r10+r13*1]
+       WORD $0xc731                   // xor    edi,eax
+       LONG $0xf07b43c4; WORD $0x0df3 // rorx   r14d,r11d,0xd
+       LONG $0xf07b43c4; WORD $0x02eb // rorx   r13d,r11d,0x2
+       LONG $0x110c8d42               // lea    ecx,[rcx+r10*1]
+       WORD $0x2141; BYTE $0xff       // and    r15d,edi
+       WORD $0x3145; BYTE $0xe6       // xor    r14d,r12d
+       WORD $0x3141; BYTE $0xc7       // xor    r15d,eax
+       WORD $0x3145; BYTE $0xee       // xor    r14d,r13d
+       LONG $0x3a148d47               // lea    r10d,[r10+r15*1]
+       WORD $0x8941; BYTE $0xd4       // mov    r12d,edx
+
+       // ROUND(R10, R11, AX, BX, CX, DX, R8, R9, R12, R13, R14, R15, DI, BP, 0x18)
+       LONG $0x184d0344               // add    r9d,[rbp+0x18]
+       WORD $0x2141; BYTE $0xcc       // and    r12d,ecx
+       LONG $0xf07b63c4; WORD $0x19e9 // rorx   r13d,ecx,0x19
+       LONG $0xf07b63c4; WORD $0x0bf9 // rorx   r15d,ecx,0xb
+       LONG $0x32148d47               // lea    r10d,[r10+r14*1]
+       LONG $0x210c8d47               // lea    r9d,[r9+r12*1]
+       LONG $0xf27042c4; BYTE $0xe0   // andn   r12d,ecx,r8d
+       WORD $0x3145; BYTE $0xfd       // xor    r13d,r15d
+       LONG $0xf07b63c4; WORD $0x06f1 // rorx   r14d,ecx,0x6
+       LONG $0x210c8d47               // lea    r9d,[r9+r12*1]
+       WORD $0x3145; BYTE $0xf5       // xor    r13d,r14d
+       WORD $0x8945; BYTE $0xd7       // mov    r15d,r10d
+       LONG $0xf07b43c4; WORD $0x16e2 // rorx   r12d,r10d,0x16
+       LONG $0x290c8d47               // lea    r9d,[r9+r13*1]
+       WORD $0x3145; BYTE $0xdf       // xor    r15d,r11d
+       LONG $0xf07b43c4; WORD $0x0df2 // rorx   r14d,r10d,0xd
+       LONG $0xf07b43c4; WORD $0x02ea // rorx   r13d,r10d,0x2
+       LONG $0x0b1c8d42               // lea    ebx,[rbx+r9*1]
+       WORD $0x2144; BYTE $0xff       // and    edi,r15d
+       WORD $0x3145; BYTE $0xe6       // xor    r14d,r12d
+       WORD $0x3144; BYTE $0xdf       // xor    edi,r11d
+       WORD $0x3145; BYTE $0xee       // xor    r14d,r13d
+       LONG $0x390c8d45               // lea    r9d,[r9+rdi*1]
+       WORD $0x8941; BYTE $0xcc       // mov    r12d,ecx
+
+       // ROUND(R9, R10, R11, AX, BX, CX, DX, R8, R12, R13, R14, DI, R15, BP, 0x1c)
+       LONG $0x1c450344               // add    r8d,[rbp+0x1c]
+       WORD $0x2141; BYTE $0xdc       // and    r12d,ebx
+       LONG $0xf07b63c4; WORD $0x19eb // rorx   r13d,ebx,0x19
+       LONG $0xf07be3c4; WORD $0x0bfb // rorx   edi,ebx,0xb
+       LONG $0x310c8d47               // lea    r9d,[r9+r14*1]
+       LONG $0x20048d47               // lea    r8d,[r8+r12*1]
+       LONG $0xf26062c4; BYTE $0xe2   // andn   r12d,ebx,edx
+       WORD $0x3141; BYTE $0xfd       // xor    r13d,edi
+       LONG $0xf07b63c4; WORD $0x06f3 // rorx   r14d,ebx,0x6
+       LONG $0x20048d47               // lea    r8d,[r8+r12*1]
+       WORD $0x3145; BYTE $0xf5       // xor    r13d,r14d
+       WORD $0x8944; BYTE $0xcf       // mov    edi,r9d
+       LONG $0xf07b43c4; WORD $0x16e1 // rorx   r12d,r9d,0x16
+       LONG $0x28048d47               // lea    r8d,[r8+r13*1]
+       WORD $0x3144; BYTE $0xd7       // xor    edi,r10d
+       LONG $0xf07b43c4; WORD $0x0df1 // rorx   r14d,r9d,0xd
+       LONG $0xf07b43c4; WORD $0x02e9 // rorx   r13d,r9d,0x2
+       LONG $0x00048d42               // lea    eax,[rax+r8*1]
+       WORD $0x2141; BYTE $0xff       // and    r15d,edi
+       WORD $0x3145; BYTE $0xe6       // xor    r14d,r12d
+       WORD $0x3145; BYTE $0xd7       // xor    r15d,r10d
+       WORD $0x3145; BYTE $0xee       // xor    r14d,r13d
+       LONG $0x38048d47               // lea    r8d,[r8+r15*1]
+       WORD $0x8941; BYTE $0xdc       // mov    r12d,ebx
+
+       // ROUND(R8, R9, R10, R11, AX, BX, CX, DX, R12, R13, R14, R15, DI, BP, 0x30)
+       WORD $0x5503; BYTE $0x30       // add    edx,[rbp+0x30]
+       WORD $0x2141; BYTE $0xc4       // and    r12d,eax
+       LONG $0xf07b63c4; WORD $0x19e8 // rorx   r13d,eax,0x19
+       LONG $0xf07b63c4; WORD $0x0bf8 // rorx   r15d,eax,0xb
+       LONG $0x30048d47               // lea    r8d,[r8+r14*1]
+       LONG $0x22148d42               // lea    edx,[rdx+r12*1]
+       LONG $0xf27862c4; BYTE $0xe1   // andn   r12d,eax,ecx
+       WORD $0x3145; BYTE $0xfd       // xor    r13d,r15d
+       LONG $0xf07b63c4; WORD $0x06f0 // rorx   r14d,eax,0x6
+       LONG $0x22148d42               // lea    edx,[rdx+r12*1]
+       WORD $0x3145; BYTE $0xf5       // xor    r13d,r14d
+       WORD $0x8945; BYTE $0xc7       // mov    r15d,r8d
+       LONG $0xf07b43c4; WORD $0x16e0 // rorx   r12d,r8d,0x16
+       LONG $0x2a148d42               // lea    edx,[rdx+r13*1]
+       WORD $0x3145; BYTE $0xcf       // xor    r15d,r9d
+       LONG $0xf07b43c4; WORD $0x0df0 // rorx   r14d,r8d,0xd
+       LONG $0xf07b43c4; WORD $0x02e8 // rorx   r13d,r8d,0x2
+       LONG $0x131c8d45               // lea    r11d,[r11+rdx*1]
+       WORD $0x2144; BYTE $0xff       // and    edi,r15d
+       WORD $0x3145; BYTE $0xe6       // xor    r14d,r12d
+       WORD $0x3144; BYTE $0xcf       // xor    edi,r9d
+       WORD $0x3145; BYTE $0xee       // xor    r14d,r13d
+       WORD $0x148d; BYTE $0x3a       // lea    edx,[rdx+rdi*1]
+       WORD $0x8941; BYTE $0xc4       // mov    r12d,eax
+
+       // ROUND(DX, R8, R9, R10, R11, AX, BX, CX, R12, R13, R14, DI, R15, BP, 0x34)
+       WORD $0x4d03; BYTE $0x34       // add    ecx,[rbp+0x34]
+       WORD $0x2145; BYTE $0xdc       // and    r12d,r11d
+       LONG $0xf07b43c4; WORD $0x19eb // rorx   r13d,r11d,0x19
+       LONG $0xf07bc3c4; WORD $0x0bfb // rorx   edi,r11d,0xb
+       LONG $0x32148d42               // lea    edx,[rdx+r14*1]
+       LONG $0x210c8d42               // lea    ecx,[rcx+r12*1]
+       LONG $0xf22062c4; BYTE $0xe3   // andn   r12d,r11d,ebx
+       WORD $0x3141; BYTE $0xfd       // xor    r13d,edi
+       LONG $0xf07b43c4; WORD $0x06f3 // rorx   r14d,r11d,0x6
+       LONG $0x210c8d42               // lea    ecx,[rcx+r12*1]
+       WORD $0x3145; BYTE $0xf5       // xor    r13d,r14d
+       WORD $0xd789                   // mov    edi,edx
+       LONG $0xf07b63c4; WORD $0x16e2 // rorx   r12d,edx,0x16
+       LONG $0x290c8d42               // lea    ecx,[rcx+r13*1]
+       WORD $0x3144; BYTE $0xc7       // xor    edi,r8d
+       LONG $0xf07b63c4; WORD $0x0df2 // rorx   r14d,edx,0xd
+       LONG $0xf07b63c4; WORD $0x02ea // rorx   r13d,edx,0x2
+       LONG $0x0a148d45               // lea    r10d,[r10+rcx*1]
+       WORD $0x2141; BYTE $0xff       // and    r15d,edi
+       WORD $0x3145; BYTE $0xe6       // xor    r14d,r12d
+       WORD $0x3145; BYTE $0xc7       // xor    r15d,r8d
+       WORD $0x3145; BYTE $0xee       // xor    r14d,r13d
+       LONG $0x390c8d42               // lea    ecx,[rcx+r15*1]
+       WORD $0x8945; BYTE $0xdc       // mov    r12d,r11d
+
+       // ROUND(CX, DX, R8, R9, R10, R11, AX, BX, R12, R13, R14, R15, DI, BP, 0x38)
+       WORD $0x5d03; BYTE $0x38       // add    ebx,[rbp+0x38]
+       WORD $0x2145; BYTE $0xd4       // and    r12d,r10d
+       LONG $0xf07b43c4; WORD $0x19ea // rorx   r13d,r10d,0x19
+       LONG $0xf07b43c4; WORD $0x0bfa // rorx   r15d,r10d,0xb
+       LONG $0x310c8d42               // lea    ecx,[rcx+r14*1]
+       LONG $0x231c8d42               // lea    ebx,[rbx+r12*1]
+       LONG $0xf22862c4; BYTE $0xe0   // andn   r12d,r10d,eax
+       WORD $0x3145; BYTE $0xfd       // xor    r13d,r15d
+       LONG $0xf07b43c4; WORD $0x06f2 // rorx   r14d,r10d,0x6
+       LONG $0x231c8d42               // lea    ebx,[rbx+r12*1]
+       WORD $0x3145; BYTE $0xf5       // xor    r13d,r14d
+       WORD $0x8941; BYTE $0xcf       // mov    r15d,ecx
+       LONG $0xf07b63c4; WORD $0x16e1 // rorx   r12d,ecx,0x16
+       LONG $0x2b1c8d42               // lea    ebx,[rbx+r13*1]
+       WORD $0x3141; BYTE $0xd7       // xor    r15d,edx
+       LONG $0xf07b63c4; WORD $0x0df1 // rorx   r14d,ecx,0xd
+       LONG $0xf07b63c4; WORD $0x02e9 // rorx   r13d,ecx,0x2
+       LONG $0x190c8d45               // lea    r9d,[r9+rbx*1]
+       WORD $0x2144; BYTE $0xff       // and    edi,r15d
+       WORD $0x3145; BYTE $0xe6       // xor    r14d,r12d
+       WORD $0xd731                   // xor    edi,edx
+       WORD $0x3145; BYTE $0xee       // xor    r14d,r13d
+       WORD $0x1c8d; BYTE $0x3b       // lea    ebx,[rbx+rdi*1]
+       WORD $0x8945; BYTE $0xd4       // mov    r12d,r10d
+
+       // ROUND(BX, CX, DX, R8, R9, R10, R11, AX, R12, R13, R14, DI, R15, BP, 0x3c)
+       WORD $0x4503; BYTE $0x3c       // add    eax,[rbp+0x3c]
+       WORD $0x2145; BYTE $0xcc       // and    r12d,r9d
+       LONG $0xf07b43c4; WORD $0x19e9 // rorx   r13d,r9d,0x19
+       LONG $0xf07bc3c4; WORD $0x0bf9 // rorx   edi,r9d,0xb
+       LONG $0x331c8d42               // lea    ebx,[rbx+r14*1]
+       LONG $0x20048d42               // lea    eax,[rax+r12*1]
+       LONG $0xf23042c4; BYTE $0xe3   // andn   r12d,r9d,r11d
+       WORD $0x3141; BYTE $0xfd       // xor    r13d,edi
+       LONG $0xf07b43c4; WORD $0x06f1 // rorx   r14d,r9d,0x6
+       LONG $0x20048d42               // lea    eax,[rax+r12*1]
+       WORD $0x3145; BYTE $0xf5       // xor    r13d,r14d
+       WORD $0xdf89                   // mov    edi,ebx
+       LONG $0xf07b63c4; WORD $0x16e3 // rorx   r12d,ebx,0x16
+       LONG $0x28048d42               // lea    eax,[rax+r13*1]
+       WORD $0xcf31                   // xor    edi,ecx
+       LONG $0xf07b63c4; WORD $0x0df3 // rorx   r14d,ebx,0xd
+       LONG $0xf07b63c4; WORD $0x02eb // rorx   r13d,ebx,0x2
+       LONG $0x00048d45               // lea    r8d,[r8+rax*1]
+       WORD $0x2141; BYTE $0xff       // and    r15d,edi
+       WORD $0x3145; BYTE $0xe6       // xor    r14d,r12d
+       WORD $0x3141; BYTE $0xcf       // xor    r15d,ecx
+       WORD $0x3145; BYTE $0xee       // xor    r14d,r13d
+       LONG $0x38048d42               // lea    eax,[rax+r15*1]
+       WORD $0x8945; BYTE $0xcc       // mov    r12d,r9d
+
+       ADDQ $-0x40, BP
+       CMPQ BP, SP
+       JAE  loop2
+
+       MOVQ 0x200(SP), DI // $_ctx
+       ADDQ R14, AX
+
+       ADDQ $0x1c0, SP
+
+       ADDL (DI), AX
+       ADDL 4(DI), BX
+       ADDL 8(DI), CX
+       ADDL 12(DI), DX
+       ADDL 16(DI), R8
+       ADDL 20(DI), R9
+
+       ADDQ $0x80, SI    // input += 2
+       ADDL 24(DI), R10
+       MOVQ SI, R12
+       ADDL 28(DI), R11
+       CMPQ SI, 0x50(SP) // input == _end
+
+       MOVL AX, (DI)
+       LONG $0xe4440f4c // cmove  r12,rsp                /* next block or stale data */
+       MOVL AX, (DI)
+       MOVL BX, 4(DI)
+       MOVL CX, 8(DI)
+       MOVL DX, 12(DI)
+       MOVL R8, 16(DI)
+       MOVL R9, 20(DI)
+       MOVL R10, 24(DI)
+       MOVL R11, 28(DI)
+
+       JBE  loop0
+       LEAQ (SP), BP
+
+done:
+       MOVQ BP, SP
+       MOVQ 0x58(SP), SP        // restore saved stack pointer
+       WORD $0xf8c5; BYTE $0x77 // vzeroupper
+
+       RET
+

diff --git a/vendor/github.com/minio/sha256-simd/sha256blockAvx512_amd64.asm b/vendor/github.com/minio/sha256-simd/sha256blockAvx512_amd64.asm
new file mode 100644 (file)
index 0000000..c959b1a
--- /dev/null
+++ b/vendor/github.com/minio/sha256-simd/sha256blockAvx512_amd64.asm
@@ -0,0 +1,686 @@
+
+// 16x Parallel implementation of SHA256 for AVX512
+
+//
+// Minio Cloud Storage, (C) 2017 Minio, Inc.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+//
+// This code is based on the Intel Multi-Buffer Crypto for IPSec library
+// and more specifically the following implementation:
+// https://github.com/intel/intel-ipsec-mb/blob/master/avx512/sha256_x16_avx512.asm
+//
+// For Golang it has been converted into Plan 9 assembly with the help of
+// github.com/minio/asm2plan9s to assemble the AVX512 instructions
+//
+
+// Copyright (c) 2017, Intel Corporation
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are met:
+//
+//     * Redistributions of source code must retain the above copyright notice,
+//       this list of conditions and the following disclaimer.
+//     * Redistributions in binary form must reproduce the above copyright
+//       notice, this list of conditions and the following disclaimer in the
+//       documentation and/or other materials provided with the distribution.
+//     * Neither the name of Intel Corporation nor the names of its contributors
+//       may be used to endorse or promote products derived from this software
+//       without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+// AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+// IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+// DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE
+// FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+// DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+// SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+// CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+// OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+#define SHA256_DIGEST_ROW_SIZE 64
+
+// arg1
+#define STATE rdi
+#define STATE_P9 DI
+// arg2
+#define INP_SIZE rsi
+#define INP_SIZE_P9 SI
+
+#define IDX rcx
+#define TBL rdx
+#define TBL_P9 DX
+
+#define INPUT rax
+#define INPUT_P9 AX
+
+#define inp0   r9
+#define SCRATCH_P9 R12
+#define SCRATCH  r12
+#define maskp    r13
+#define MASKP_P9 R13
+#define mask     r14
+#define MASK_P9  R14
+
+#define A       zmm0
+#define B       zmm1
+#define C       zmm2
+#define D       zmm3
+#define E       zmm4
+#define F       zmm5
+#define G       zmm6
+#define H       zmm7
+#define T1      zmm8
+#define TMP0    zmm9
+#define TMP1    zmm10
+#define TMP2    zmm11
+#define TMP3    zmm12
+#define TMP4    zmm13
+#define TMP5    zmm14
+#define TMP6    zmm15
+
+#define W0      zmm16
+#define W1      zmm17
+#define W2      zmm18
+#define W3      zmm19
+#define W4      zmm20
+#define W5      zmm21
+#define W6      zmm22
+#define W7      zmm23
+#define W8      zmm24
+#define W9      zmm25
+#define W10     zmm26
+#define W11     zmm27
+#define W12     zmm28
+#define W13     zmm29
+#define W14     zmm30
+#define W15     zmm31
+
+
+#define TRANSPOSE16(_r0, _r1, _r2, _r3, _r4, _r5, _r6, _r7, _r8, _r9, _r10, _r11, _r12, _r13, _r14, _r15, _t0, _t1) \
+    \
+    \ // input   r0  = {a15 a14 a13 a12   a11 a10  a9  a8    a7  a6  a5  a4    a3  a2  a1  a0}
+    \ //         r1  = {b15 b14 b13 b12   b11 b10  b9  b8    b7  b6  b5  b4    b3  b2  b1  b0}
+    \ //         r2  = {c15 c14 c13 c12   c11 c10  c9  c8    c7  c6  c5  c4    c3  c2  c1  c0}
+    \ //         r3  = {d15 d14 d13 d12   d11 d10  d9  d8    d7  d6  d5  d4    d3  d2  d1  d0}
+    \ //         r4  = {e15 e14 e13 e12   e11 e10  e9  e8    e7  e6  e5  e4    e3  e2  e1  e0}
+    \ //         r5  = {f15 f14 f13 f12   f11 f10  f9  f8    f7  f6  f5  f4    f3  f2  f1  f0}
+    \ //         r6  = {g15 g14 g13 g12   g11 g10  g9  g8    g7  g6  g5  g4    g3  g2  g1  g0}
+    \ //         r7  = {h15 h14 h13 h12   h11 h10  h9  h8    h7  h6  h5  h4    h3  h2  h1  h0}
+    \ //         r8  = {i15 i14 i13 i12   i11 i10  i9  i8    i7  i6  i5  i4    i3  i2  i1  i0}
+    \ //         r9  = {j15 j14 j13 j12   j11 j10  j9  j8    j7  j6  j5  j4    j3  j2  j1  j0}
+    \ //         r10 = {k15 k14 k13 k12   k11 k10  k9  k8    k7  k6  k5  k4    k3  k2  k1  k0}
+    \ //         r11 = {l15 l14 l13 l12   l11 l10  l9  l8    l7  l6  l5  l4    l3  l2  l1  l0}
+    \ //         r12 = {m15 m14 m13 m12   m11 m10  m9  m8    m7  m6  m5  m4    m3  m2  m1  m0}
+    \ //         r13 = {n15 n14 n13 n12   n11 n10  n9  n8    n7  n6  n5  n4    n3  n2  n1  n0}
+    \ //         r14 = {o15 o14 o13 o12   o11 o10  o9  o8    o7  o6  o5  o4    o3  o2  o1  o0}
+    \ //         r15 = {p15 p14 p13 p12   p11 p10  p9  p8    p7  p6  p5  p4    p3  p2  p1  p0}
+    \
+    \ // output  r0  = { p0  o0  n0  m0    l0  k0  j0  i0    h0  g0  f0  e0    d0  c0  b0  a0}
+    \ //         r1  = { p1  o1  n1  m1    l1  k1  j1  i1    h1  g1  f1  e1    d1  c1  b1  a1}
+    \ //         r2  = { p2  o2  n2  m2    l2  k2  j2  i2    h2  g2  f2  e2    d2  c2  b2  a2}
+    \ //         r3  = { p3  o3  n3  m3    l3  k3  j3  i3    h3  g3  f3  e3    d3  c3  b3  a3}
+    \ //         r4  = { p4  o4  n4  m4    l4  k4  j4  i4    h4  g4  f4  e4    d4  c4  b4  a4}
+    \ //         r5  = { p5  o5  n5  m5    l5  k5  j5  i5    h5  g5  f5  e5    d5  c5  b5  a5}
+    \ //         r6  = { p6  o6  n6  m6    l6  k6  j6  i6    h6  g6  f6  e6    d6  c6  b6  a6}
+    \ //         r7  = { p7  o7  n7  m7    l7  k7  j7  i7    h7  g7  f7  e7    d7  c7  b7  a7}
+    \ //         r8  = { p8  o8  n8  m8    l8  k8  j8  i8    h8  g8  f8  e8    d8  c8  b8  a8}
+    \ //         r9  = { p9  o9  n9  m9    l9  k9  j9  i9    h9  g9  f9  e9    d9  c9  b9  a9}
+    \ //         r10 = {p10 o10 n10 m10   l10 k10 j10 i10   h10 g10 f10 e10   d10 c10 b10 a10}
+    \ //         r11 = {p11 o11 n11 m11   l11 k11 j11 i11   h11 g11 f11 e11   d11 c11 b11 a11}
+    \ //         r12 = {p12 o12 n12 m12   l12 k12 j12 i12   h12 g12 f12 e12   d12 c12 b12 a12}
+    \ //         r13 = {p13 o13 n13 m13   l13 k13 j13 i13   h13 g13 f13 e13   d13 c13 b13 a13}
+    \ //         r14 = {p14 o14 n14 m14   l14 k14 j14 i14   h14 g14 f14 e14   d14 c14 b14 a14}
+    \ //         r15 = {p15 o15 n15 m15   l15 k15 j15 i15   h15 g15 f15 e15   d15 c15 b15 a15}
+    \
+    \ // process top half
+    vshufps _t0, _r0, _r1, 0x44      \ // t0 = {b13 b12 a13 a12   b9  b8  a9  a8   b5 b4 a5 a4   b1 b0 a1 a0}
+    vshufps _r0, _r0, _r1, 0xEE      \ // r0 = {b15 b14 a15 a14   b11 b10 a11 a10  b7 b6 a7 a6   b3 b2 a3 a2}
+    vshufps _t1, _r2, _r3, 0x44      \ // t1 = {d13 d12 c13 c12   d9  d8  c9  c8   d5 d4 c5 c4   d1 d0 c1 c0}
+    vshufps _r2, _r2, _r3, 0xEE      \ // r2 = {d15 d14 c15 c14   d11 d10 c11 c10  d7 d6 c7 c6   d3 d2 c3 c2}
+                                     \
+    vshufps    _r3, _t0, _t1, 0xDD      \ // r3 = {d13 c13 b13 a13   d9  c9  b9  a9   d5 c5 b5 a5   d1 c1 b1 a1}
+    vshufps    _r1, _r0, _r2, 0x88      \ // r1 = {d14 c14 b14 a14   d10 c10 b10 a10  d6 c6 b6 a6   d2 c2 b2 a2}
+    vshufps    _r0, _r0, _r2, 0xDD      \ // r0 = {d15 c15 b15 a15   d11 c11 b11 a11  d7 c7 b7 a7   d3 c3 b3 a3}
+    vshufps    _t0, _t0, _t1, 0x88      \ // t0 = {d12 c12 b12 a12   d8  c8  b8  a8   d4 c4 b4 a4   d0 c0 b0 a0}
+                                     \
+    \ // use r2 in place of t0
+    vshufps _r2, _r4, _r5, 0x44      \ // r2 = {f13 f12 e13 e12   f9  f8  e9  e8   f5 f4 e5 e4   f1 f0 e1 e0}
+    vshufps _r4, _r4, _r5, 0xEE      \ // r4 = {f15 f14 e15 e14   f11 f10 e11 e10  f7 f6 e7 e6   f3 f2 e3 e2}
+    vshufps _t1, _r6, _r7, 0x44      \ // t1 = {h13 h12 g13 g12   h9  h8  g9  g8   h5 h4 g5 g4   h1 h0 g1 g0}
+    vshufps _r6, _r6, _r7, 0xEE      \ // r6 = {h15 h14 g15 g14   h11 h10 g11 g10  h7 h6 g7 g6   h3 h2 g3 g2}
+                                     \
+    vshufps _r7, _r2, _t1, 0xDD      \ // r7 = {h13 g13 f13 e13   h9  g9  f9  e9   h5 g5 f5 e5   h1 g1 f1 e1}
+    vshufps _r5, _r4, _r6, 0x88      \ // r5 = {h14 g14 f14 e14   h10 g10 f10 e10  h6 g6 f6 e6   h2 g2 f2 e2}
+    vshufps _r4, _r4, _r6, 0xDD      \ // r4 = {h15 g15 f15 e15   h11 g11 f11 e11  h7 g7 f7 e7   h3 g3 f3 e3}
+    vshufps _r2, _r2, _t1, 0x88      \ // r2 = {h12 g12 f12 e12   h8  g8  f8  e8   h4 g4 f4 e4   h0 g0 f0 e0}
+                                     \
+    \ // use r6 in place of t0
+    vshufps _r6, _r8, _r9,    0x44   \ // r6  = {j13 j12 i13 i12   j9  j8  i9  i8   j5 j4 i5 i4   j1 j0 i1 i0}
+    vshufps _r8, _r8, _r9,    0xEE   \ // r8  = {j15 j14 i15 i14   j11 j10 i11 i10  j7 j6 i7 i6   j3 j2 i3 i2}
+    vshufps _t1, _r10, _r11,  0x44   \ // t1  = {l13 l12 k13 k12   l9  l8  k9  k8   l5 l4 k5 k4   l1 l0 k1 k0}
+    vshufps _r10, _r10, _r11, 0xEE   \ // r10 = {l15 l14 k15 k14   l11 l10 k11 k10  l7 l6 k7 k6   l3 l2 k3 k2}
+                                     \
+    vshufps _r11, _r6, _t1, 0xDD     \ // r11 = {l13 k13 j13 113   l9  k9  j9  i9   l5 k5 j5 i5   l1 k1 j1 i1}
+    vshufps _r9, _r8, _r10, 0x88     \ // r9  = {l14 k14 j14 114   l10 k10 j10 i10  l6 k6 j6 i6   l2 k2 j2 i2}
+    vshufps _r8, _r8, _r10, 0xDD     \ // r8  = {l15 k15 j15 115   l11 k11 j11 i11  l7 k7 j7 i7   l3 k3 j3 i3}
+    vshufps _r6, _r6, _t1,  0x88     \ // r6  = {l12 k12 j12 112   l8  k8  j8  i8   l4 k4 j4 i4   l0 k0 j0 i0}
+                                     \
+    \ // use r10 in place of t0
+    vshufps _r10, _r12, _r13, 0x44   \ // r10 = {n13 n12 m13 m12   n9  n8  m9  m8   n5 n4 m5 m4   n1 n0 a1 m0}
+    vshufps _r12, _r12, _r13, 0xEE   \ // r12 = {n15 n14 m15 m14   n11 n10 m11 m10  n7 n6 m7 m6   n3 n2 a3 m2}
+    vshufps _t1, _r14, _r15,  0x44   \ // t1  = {p13 p12 013 012   p9  p8  09  08   p5 p4 05 04   p1 p0 01 00}
+    vshufps _r14, _r14, _r15, 0xEE   \ // r14 = {p15 p14 015 014   p11 p10 011 010  p7 p6 07 06   p3 p2 03 02}
+                                     \
+    vshufps _r15, _r10, _t1,  0xDD   \ // r15 = {p13 013 n13 m13   p9  09  n9  m9   p5 05 n5 m5   p1 01 n1 m1}
+    vshufps _r13, _r12, _r14, 0x88   \ // r13 = {p14 014 n14 m14   p10 010 n10 m10  p6 06 n6 m6   p2 02 n2 m2}
+    vshufps _r12, _r12, _r14, 0xDD   \ // r12 = {p15 015 n15 m15   p11 011 n11 m11  p7 07 n7 m7   p3 03 n3 m3}
+    vshufps _r10, _r10, _t1,  0x88   \ // r10 = {p12 012 n12 m12   p8  08  n8  m8   p4 04 n4 m4   p0 00 n0 m0}
+                                     \
+    \ // At this point, the registers that contain interesting data are:
+    \ // t0, r3, r1, r0, r2, r7, r5, r4, r6, r11, r9, r8, r10, r15, r13, r12
+    \ // Can use t1 and r14 as scratch registers
+    LEAQ PSHUFFLE_TRANSPOSE16_MASK1<>(SB), BX \
+    LEAQ PSHUFFLE_TRANSPOSE16_MASK2<>(SB), R8 \
+                                     \
+    vmovdqu32 _r14, [rbx]            \
+    vpermi2q  _r14, _t0, _r2         \ // r14 = {h8  g8  f8  e8   d8  c8  b8  a8   h0 g0 f0 e0  d0 c0 b0 a0}
+    vmovdqu32 _t1,  [r8]             \
+    vpermi2q  _t1,  _t0, _r2         \ // t1  = {h12 g12 f12 e12  d12 c12 b12 a12  h4 g4 f4 e4  d4 c4 b4 a4}
+                                     \
+    vmovdqu32 _r2, [rbx]             \
+    vpermi2q  _r2, _r3, _r7          \ // r2  = {h9  g9  f9  e9   d9  c9  b9  a9   h1 g1 f1 e1  d1 c1 b1 a1}
+    vmovdqu32 _t0, [r8]              \
+    vpermi2q  _t0, _r3, _r7          \ // t0  = {h13 g13 f13 e13  d13 c13 b13 a13  h5 g5 f5 e5  d5 c5 b5 a5}
+                                     \
+    vmovdqu32 _r3, [rbx]             \
+    vpermi2q  _r3, _r1, _r5          \ // r3  = {h10 g10 f10 e10  d10 c10 b10 a10  h2 g2 f2 e2  d2 c2 b2 a2}
+    vmovdqu32 _r7, [r8]              \
+    vpermi2q  _r7, _r1, _r5          \ // r7  = {h14 g14 f14 e14  d14 c14 b14 a14  h6 g6 f6 e6  d6 c6 b6 a6}
+                                     \
+    vmovdqu32 _r1, [rbx]             \
+    vpermi2q  _r1, _r0, _r4          \ // r1  = {h11 g11 f11 e11  d11 c11 b11 a11  h3 g3 f3 e3  d3 c3 b3 a3}
+    vmovdqu32 _r5, [r8]              \
+    vpermi2q  _r5, _r0, _r4          \ // r5  = {h15 g15 f15 e15  d15 c15 b15 a15  h7 g7 f7 e7  d7 c7 b7 a7}
+                                     \
+    vmovdqu32 _r0, [rbx]             \
+    vpermi2q  _r0, _r6, _r10         \ // r0  = {p8  o8  n8  m8   l8  k8  j8  i8   p0 o0 n0 m0  l0 k0 j0 i0}
+    vmovdqu32 _r4, [r8]              \
+    vpermi2q  _r4, _r6, _r10         \ // r4  = {p12 o12 n12 m12  l12 k12 j12 i12  p4 o4 n4 m4  l4 k4 j4 i4}
+                                     \
+    vmovdqu32 _r6, [rbx]             \
+    vpermi2q  _r6, _r11, _r15        \ // r6  = {p9  o9  n9  m9   l9  k9  j9  i9   p1 o1 n1 m1  l1 k1 j1 i1}
+    vmovdqu32 _r10, [r8]             \
+    vpermi2q  _r10, _r11, _r15       \ // r10 = {p13 o13 n13 m13  l13 k13 j13 i13  p5 o5 n5 m5  l5 k5 j5 i5}
+                                     \
+    vmovdqu32 _r11, [rbx]            \
+    vpermi2q  _r11, _r9, _r13        \ // r11 = {p10 o10 n10 m10  l10 k10 j10 i10  p2 o2 n2 m2  l2 k2 j2 i2}
+    vmovdqu32 _r15, [r8]             \
+    vpermi2q  _r15, _r9, _r13        \ // r15 = {p14 o14 n14 m14  l14 k14 j14 i14  p6 o6 n6 m6  l6 k6 j6 i6}
+                                     \
+    vmovdqu32 _r9, [rbx]             \
+    vpermi2q  _r9, _r8, _r12         \ // r9  = {p11 o11 n11 m11  l11 k11 j11 i11  p3 o3 n3 m3  l3 k3 j3 i3}
+    vmovdqu32 _r13, [r8]             \
+    vpermi2q  _r13, _r8, _r12        \ // r13 = {p15 o15 n15 m15  l15 k15 j15 i15  p7 o7 n7 m7  l7 k7 j7 i7}
+                                     \
+    \ // At this point r8 and r12 can be used as scratch registers
+    vshuff64x2 _r8, _r14, _r0, 0xEE  \ // r8  = {p8  o8  n8  m8   l8  k8  j8  i8   h8 g8 f8 e8   d8 c8 b8 a8}
+    vshuff64x2 _r0, _r14, _r0, 0x44  \ // r0  = {p0  o0  n0  m0   l0  k0  j0  i0   h0 g0 f0 e0   d0 c0 b0 a0}
+                                     \
+    vshuff64x2 _r12, _t1, _r4, 0xEE  \ // r12 = {p12 o12 n12 m12  l12 k12 j12 i12  h12 g12 f12 e12  d12 c12 b12 a12}
+    vshuff64x2 _r4, _t1, _r4, 0x44   \ // r4  = {p4  o4  n4  m4   l4  k4  j4  i4   h4 g4 f4 e4   d4 c4 b4 a4}
+                                     \
+    vshuff64x2 _r14, _r7, _r15, 0xEE \ // r14 = {p14 o14 n14 m14  l14 k14 j14 i14  h14 g14 f14 e14  d14 c14 b14 a14}
+    vshuff64x2 _t1, _r7, _r15, 0x44  \ // t1  = {p6  o6  n6  m6   l6  k6  j6  i6   h6 g6 f6 e6   d6 c6 b6 a6}
+                                     \
+    vshuff64x2 _r15, _r5, _r13, 0xEE \ // r15 = {p15 o15 n15 m15  l15 k15 j15 i15  h15 g15 f15 e15  d15 c15 b15 a15}
+    vshuff64x2 _r7, _r5, _r13, 0x44  \ // r7  = {p7  o7  n7  m7   l7  k7  j7  i7   h7 g7 f7 e7   d7 c7 b7 a7}
+                                     \
+    vshuff64x2 _r13, _t0, _r10, 0xEE \ // r13 = {p13 o13 n13 m13  l13 k13 j13 i13  h13 g13 f13 e13  d13 c13 b13 a13}
+    vshuff64x2 _r5, _t0, _r10, 0x44  \ // r5  = {p5  o5  n5  m5   l5  k5  j5  i5   h5 g5 f5 e5   d5 c5 b5 a5}
+                                     \
+    vshuff64x2 _r10, _r3, _r11, 0xEE \ // r10 = {p10 o10 n10 m10  l10 k10 j10 i10  h10 g10 f10 e10  d10 c10 b10 a10}
+    vshuff64x2 _t0, _r3, _r11, 0x44  \ // t0  = {p2  o2  n2  m2   l2  k2  j2  i2   h2 g2 f2 e2   d2 c2 b2 a2}
+                                     \
+    vshuff64x2 _r11, _r1, _r9, 0xEE  \ // r11 = {p11 o11 n11 m11  l11 k11 j11 i11  h11 g11 f11 e11  d11 c11 b11 a11}
+    vshuff64x2 _r3, _r1, _r9, 0x44   \ // r3  = {p3  o3  n3  m3   l3  k3  j3  i3   h3 g3 f3 e3   d3 c3 b3 a3}
+                                     \
+    vshuff64x2 _r9, _r2, _r6, 0xEE   \ // r9  = {p9  o9  n9  m9   l9  k9  j9  i9   h9 g9 f9 e9   d9 c9 b9 a9}
+    vshuff64x2 _r1, _r2, _r6, 0x44   \ // r1  = {p1  o1  n1  m1   l1  k1  j1  i1   h1 g1 f1 e1   d1 c1 b1 a1}
+                                     \
+    vmovdqu32 _r2, _t0               \ // r2  = {p2  o2  n2  m2   l2  k2  j2  i2   h2 g2 f2 e2   d2 c2 b2 a2}
+    vmovdqu32 _r6, _t1               \ // r6  = {p6  o6  n6  m6   l6  k6  j6  i6   h6 g6 f6 e6   d6 c6 b6 a6}
+
+
+//  CH(A, B, C) = (A&B) ^ (~A&C)
+// MAJ(E, F, G) = (E&F) ^ (E&G) ^ (F&G)
+// SIGMA0 = ROR_2  ^ ROR_13 ^ ROR_22
+// SIGMA1 = ROR_6  ^ ROR_11 ^ ROR_25
+// sigma0 = ROR_7  ^ ROR_18 ^ SHR_3
+// sigma1 = ROR_17 ^ ROR_19 ^ SHR_10
+
+// Main processing loop per round
+#define PROCESS_LOOP(_WT, _ROUND, _A, _B, _C, _D, _E, _F, _G, _H)  \
+    \ // T1 = H + SIGMA1(E) + CH(E, F, G) + Kt + Wt
+    \ // T2 = SIGMA0(A) + MAJ(A, B, C)
+    \ // H=G, G=F, F=E, E=D+T1, D=C, C=B, B=A, A=T1+T2
+    \
+    \ // H becomes T2, then add T1 for A
+    \ // D becomes D + T1 for E
+    \
+    vpaddd      T1, _H, TMP3           \ // T1 = H + Kt
+    vmovdqu32   TMP0, _E               \
+    vprord      TMP1, _E, 6            \ // ROR_6(E)
+    vprord      TMP2, _E, 11           \ // ROR_11(E)
+    vprord      TMP3, _E, 25           \ // ROR_25(E)
+    vpternlogd  TMP0, _F, _G, 0xCA     \ // TMP0 = CH(E,F,G)
+    vpaddd      T1, T1, _WT            \ // T1 = T1 + Wt
+    vpternlogd  TMP1, TMP2, TMP3, 0x96 \ // TMP1 = SIGMA1(E)
+    vpaddd      T1, T1, TMP0           \ // T1 = T1 + CH(E,F,G)
+    vpaddd      T1, T1, TMP1           \ // T1 = T1 + SIGMA1(E)
+    vpaddd      _D, _D, T1             \ // D = D + T1
+                                       \
+    vprord      _H, _A, 2              \ // ROR_2(A)
+    vprord      TMP2, _A, 13           \ // ROR_13(A)
+    vprord      TMP3, _A, 22           \ // ROR_22(A)
+    vmovdqu32   TMP0, _A               \
+    vpternlogd  TMP0, _B, _C, 0xE8     \ // TMP0 = MAJ(A,B,C)
+    vpternlogd  _H, TMP2, TMP3, 0x96   \ // H(T2) = SIGMA0(A)
+    vpaddd      _H, _H, TMP0           \ // H(T2) = SIGMA0(A) + MAJ(A,B,C)
+    vpaddd      _H, _H, T1             \ // H(A) = H(T2) + T1
+                                       \
+    vmovdqu32   TMP3, [TBL + ((_ROUND+1)*64)] \ // Next Kt
+
+
+#define MSG_SCHED_ROUND_16_63(_WT, _WTp1, _WTp9, _WTp14) \
+    vprord      TMP4, _WTp14, 17                         \ // ROR_17(Wt-2)
+    vprord      TMP5, _WTp14, 19                         \ // ROR_19(Wt-2)
+    vpsrld      TMP6, _WTp14, 10                         \ // SHR_10(Wt-2)
+    vpternlogd  TMP4, TMP5, TMP6, 0x96                   \ // TMP4 = sigma1(Wt-2)
+                                                         \
+    vpaddd      _WT, _WT, TMP4                          \ // Wt = Wt-16 + sigma1(Wt-2)
+    vpaddd      _WT, _WT, _WTp9                                 \ // Wt = Wt-16 + sigma1(Wt-2) + Wt-7
+                                                         \
+    vprord      TMP4, _WTp1, 7                           \ // ROR_7(Wt-15)
+    vprord      TMP5, _WTp1, 18                          \ // ROR_18(Wt-15)
+    vpsrld      TMP6, _WTp1, 3                           \ // SHR_3(Wt-15)
+    vpternlogd  TMP4, TMP5, TMP6, 0x96                   \ // TMP4 = sigma0(Wt-15)
+                                                         \
+    vpaddd      _WT, _WT, TMP4                          \ // Wt = Wt-16 + sigma1(Wt-2) +
+                                                         \ //      Wt-7 + sigma0(Wt-15) +
+
+
+// Note this is reading in a block of data for one lane
+// When all 16 are read, the data must be transposed to build msg schedule
+#define MSG_SCHED_ROUND_00_15(_WT, OFFSET, LABEL)             \
+    TESTQ $(1<<OFFSET), MASK_P9                               \
+    JE    LABEL                                               \
+    MOVQ  OFFSET*24(INPUT_P9), R9                             \
+    vmovups _WT, [inp0+IDX]                                   \
+LABEL:                                                        \
+
+#define MASKED_LOAD(_WT, OFFSET, LABEL) \
+    TESTQ $(1<<OFFSET), MASK_P9         \
+    JE    LABEL                         \
+    MOVQ  OFFSET*24(INPUT_P9), R9       \
+    vmovups _WT,[inp0+IDX]              \
+LABEL:                                  \
+
+TEXT ·sha256_x16_avx512(SB), 7, $0
+    MOVQ  digests+0(FP), STATE_P9       //
+    MOVQ  scratch+8(FP), SCRATCH_P9
+    MOVQ  mask_len+32(FP), INP_SIZE_P9  // number of blocks to process
+    MOVQ  mask+24(FP), MASKP_P9
+    MOVQ (MASKP_P9), MASK_P9
+    kmovq k1, mask
+    LEAQ  inputs+48(FP), INPUT_P9
+
+    // Initialize digests
+    vmovdqu32 A, [STATE + 0*SHA256_DIGEST_ROW_SIZE]
+    vmovdqu32 B, [STATE + 1*SHA256_DIGEST_ROW_SIZE]
+    vmovdqu32 C, [STATE + 2*SHA256_DIGEST_ROW_SIZE]
+    vmovdqu32 D, [STATE + 3*SHA256_DIGEST_ROW_SIZE]
+    vmovdqu32 E, [STATE + 4*SHA256_DIGEST_ROW_SIZE]
+    vmovdqu32 F, [STATE + 5*SHA256_DIGEST_ROW_SIZE]
+    vmovdqu32 G, [STATE + 6*SHA256_DIGEST_ROW_SIZE]
+    vmovdqu32 H, [STATE + 7*SHA256_DIGEST_ROW_SIZE]
+
+    MOVQ  table+16(FP), TBL_P9
+
+    xor IDX, IDX
+
+    // Read in first block of input data
+    MASKED_LOAD( W0,  0, skipInput0)
+    MASKED_LOAD( W1,  1, skipInput1)
+    MASKED_LOAD( W2,  2, skipInput2)
+    MASKED_LOAD( W3,  3, skipInput3)
+    MASKED_LOAD( W4,  4, skipInput4)
+    MASKED_LOAD( W5,  5, skipInput5)
+    MASKED_LOAD( W6,  6, skipInput6)
+    MASKED_LOAD( W7,  7, skipInput7)
+    MASKED_LOAD( W8,  8, skipInput8)
+    MASKED_LOAD( W9,  9, skipInput9)
+    MASKED_LOAD(W10, 10, skipInput10)
+    MASKED_LOAD(W11, 11, skipInput11)
+    MASKED_LOAD(W12, 12, skipInput12)
+    MASKED_LOAD(W13, 13, skipInput13)
+    MASKED_LOAD(W14, 14, skipInput14)
+    MASKED_LOAD(W15, 15, skipInput15)
+
+lloop:
+    LEAQ PSHUFFLE_BYTE_FLIP_MASK<>(SB), TBL_P9
+    vmovdqu32 TMP2, [TBL]
+
+    // Get first K from table
+    MOVQ  table+16(FP), TBL_P9
+    vmovdqu32  TMP3, [TBL]
+
+    // Save digests for later addition
+    vmovdqu32 [SCRATCH + 64*0], A
+    vmovdqu32 [SCRATCH + 64*1], B
+    vmovdqu32 [SCRATCH + 64*2], C
+    vmovdqu32 [SCRATCH + 64*3], D
+    vmovdqu32 [SCRATCH + 64*4], E
+    vmovdqu32 [SCRATCH + 64*5], F
+    vmovdqu32 [SCRATCH + 64*6], G
+    vmovdqu32 [SCRATCH + 64*7], H
+
+    add IDX, 64
+
+    // Transpose input data
+    TRANSPOSE16(W0, W1, W2, W3, W4, W5, W6, W7, W8, W9, W10, W11, W12, W13, W14, W15, TMP0, TMP1)
+
+    vpshufb W0, W0, TMP2
+    vpshufb W1, W1, TMP2
+    vpshufb W2, W2, TMP2
+    vpshufb W3, W3, TMP2
+    vpshufb W4, W4, TMP2
+    vpshufb W5, W5, TMP2
+    vpshufb W6, W6, TMP2
+    vpshufb W7, W7, TMP2
+    vpshufb W8, W8, TMP2
+    vpshufb W9, W9, TMP2
+    vpshufb W10, W10, TMP2
+    vpshufb W11, W11, TMP2
+    vpshufb W12, W12, TMP2
+    vpshufb W13, W13, TMP2
+    vpshufb W14, W14, TMP2
+    vpshufb W15, W15, TMP2
+
+    // MSG Schedule for W0-W15 is now complete in registers
+    // Process first 48 rounds
+    // Calculate next Wt+16 after processing is complete and Wt is unneeded
+
+    PROCESS_LOOP( W0,  0, A, B, C, D, E, F, G, H)
+    MSG_SCHED_ROUND_16_63( W0,  W1,  W9, W14)
+    PROCESS_LOOP( W1,  1, H, A, B, C, D, E, F, G)
+    MSG_SCHED_ROUND_16_63( W1,  W2, W10, W15)
+    PROCESS_LOOP( W2,  2, G, H, A, B, C, D, E, F)
+    MSG_SCHED_ROUND_16_63( W2,  W3, W11,  W0)
+    PROCESS_LOOP( W3,  3, F, G, H, A, B, C, D, E)
+    MSG_SCHED_ROUND_16_63( W3,  W4, W12,  W1)
+    PROCESS_LOOP( W4,  4, E, F, G, H, A, B, C, D)
+    MSG_SCHED_ROUND_16_63( W4,  W5, W13,  W2)
+    PROCESS_LOOP( W5,  5, D, E, F, G, H, A, B, C)
+    MSG_SCHED_ROUND_16_63( W5,  W6, W14,  W3)
+    PROCESS_LOOP( W6,  6, C, D, E, F, G, H, A, B)
+    MSG_SCHED_ROUND_16_63( W6,  W7, W15,  W4)
+    PROCESS_LOOP( W7,  7, B, C, D, E, F, G, H, A)
+    MSG_SCHED_ROUND_16_63( W7,  W8,  W0,  W5)
+    PROCESS_LOOP( W8,  8, A, B, C, D, E, F, G, H)
+    MSG_SCHED_ROUND_16_63( W8,  W9,  W1,  W6)
+    PROCESS_LOOP( W9,  9, H, A, B, C, D, E, F, G)
+    MSG_SCHED_ROUND_16_63( W9, W10,  W2,  W7)
+    PROCESS_LOOP(W10, 10, G, H, A, B, C, D, E, F)
+    MSG_SCHED_ROUND_16_63(W10, W11,  W3,  W8)
+    PROCESS_LOOP(W11, 11, F, G, H, A, B, C, D, E)
+    MSG_SCHED_ROUND_16_63(W11, W12,  W4,  W9)
+    PROCESS_LOOP(W12, 12, E, F, G, H, A, B, C, D)
+    MSG_SCHED_ROUND_16_63(W12, W13,  W5, W10)
+    PROCESS_LOOP(W13, 13, D, E, F, G, H, A, B, C)
+    MSG_SCHED_ROUND_16_63(W13, W14,  W6, W11)
+    PROCESS_LOOP(W14, 14, C, D, E, F, G, H, A, B)
+    MSG_SCHED_ROUND_16_63(W14, W15,  W7, W12)
+    PROCESS_LOOP(W15, 15, B, C, D, E, F, G, H, A)
+    MSG_SCHED_ROUND_16_63(W15,  W0,  W8, W13)
+    PROCESS_LOOP( W0, 16, A, B, C, D, E, F, G, H)
+    MSG_SCHED_ROUND_16_63( W0,  W1,  W9, W14)
+    PROCESS_LOOP( W1, 17, H, A, B, C, D, E, F, G)
+    MSG_SCHED_ROUND_16_63( W1,  W2, W10, W15)
+    PROCESS_LOOP( W2, 18, G, H, A, B, C, D, E, F)
+    MSG_SCHED_ROUND_16_63( W2,  W3, W11,  W0)
+    PROCESS_LOOP( W3, 19, F, G, H, A, B, C, D, E)
+    MSG_SCHED_ROUND_16_63( W3,  W4, W12,  W1)
+    PROCESS_LOOP( W4, 20, E, F, G, H, A, B, C, D)
+    MSG_SCHED_ROUND_16_63( W4,  W5, W13,  W2)
+    PROCESS_LOOP( W5, 21, D, E, F, G, H, A, B, C)
+    MSG_SCHED_ROUND_16_63( W5,  W6, W14,  W3)
+    PROCESS_LOOP( W6, 22, C, D, E, F, G, H, A, B)
+    MSG_SCHED_ROUND_16_63( W6,  W7, W15,  W4)
+    PROCESS_LOOP( W7, 23, B, C, D, E, F, G, H, A)
+    MSG_SCHED_ROUND_16_63( W7,  W8,  W0,  W5)
+    PROCESS_LOOP( W8, 24, A, B, C, D, E, F, G, H)
+    MSG_SCHED_ROUND_16_63( W8,  W9,  W1,  W6)
+    PROCESS_LOOP( W9, 25, H, A, B, C, D, E, F, G)
+    MSG_SCHED_ROUND_16_63( W9, W10,  W2,  W7)
+    PROCESS_LOOP(W10, 26, G, H, A, B, C, D, E, F)
+    MSG_SCHED_ROUND_16_63(W10, W11,  W3,  W8)
+    PROCESS_LOOP(W11, 27, F, G, H, A, B, C, D, E)
+    MSG_SCHED_ROUND_16_63(W11, W12,  W4,  W9)
+    PROCESS_LOOP(W12, 28, E, F, G, H, A, B, C, D)
+    MSG_SCHED_ROUND_16_63(W12, W13,  W5, W10)
+    PROCESS_LOOP(W13, 29, D, E, F, G, H, A, B, C)
+    MSG_SCHED_ROUND_16_63(W13, W14,  W6, W11)
+    PROCESS_LOOP(W14, 30, C, D, E, F, G, H, A, B)
+    MSG_SCHED_ROUND_16_63(W14, W15,  W7, W12)
+    PROCESS_LOOP(W15, 31, B, C, D, E, F, G, H, A)
+    MSG_SCHED_ROUND_16_63(W15,  W0,  W8, W13)
+    PROCESS_LOOP( W0, 32, A, B, C, D, E, F, G, H)
+    MSG_SCHED_ROUND_16_63( W0,  W1,  W9, W14)
+    PROCESS_LOOP( W1, 33, H, A, B, C, D, E, F, G)
+    MSG_SCHED_ROUND_16_63( W1,  W2, W10, W15)
+    PROCESS_LOOP( W2, 34, G, H, A, B, C, D, E, F)
+    MSG_SCHED_ROUND_16_63( W2,  W3, W11,  W0)
+    PROCESS_LOOP( W3, 35, F, G, H, A, B, C, D, E)
+    MSG_SCHED_ROUND_16_63( W3,  W4, W12,  W1)
+    PROCESS_LOOP( W4, 36, E, F, G, H, A, B, C, D)
+    MSG_SCHED_ROUND_16_63( W4,  W5, W13,  W2)
+    PROCESS_LOOP( W5, 37, D, E, F, G, H, A, B, C)
+    MSG_SCHED_ROUND_16_63( W5,  W6, W14,  W3)
+    PROCESS_LOOP( W6, 38, C, D, E, F, G, H, A, B)
+    MSG_SCHED_ROUND_16_63( W6,  W7, W15,  W4)
+    PROCESS_LOOP( W7, 39, B, C, D, E, F, G, H, A)
+    MSG_SCHED_ROUND_16_63( W7,  W8,  W0,  W5)
+    PROCESS_LOOP( W8, 40, A, B, C, D, E, F, G, H)
+    MSG_SCHED_ROUND_16_63( W8,  W9,  W1,  W6)
+    PROCESS_LOOP( W9, 41, H, A, B, C, D, E, F, G)
+    MSG_SCHED_ROUND_16_63( W9, W10,  W2,  W7)
+    PROCESS_LOOP(W10, 42, G, H, A, B, C, D, E, F)
+    MSG_SCHED_ROUND_16_63(W10, W11,  W3,  W8)
+    PROCESS_LOOP(W11, 43, F, G, H, A, B, C, D, E)
+    MSG_SCHED_ROUND_16_63(W11, W12,  W4,  W9)
+    PROCESS_LOOP(W12, 44, E, F, G, H, A, B, C, D)
+    MSG_SCHED_ROUND_16_63(W12, W13,  W5, W10)
+    PROCESS_LOOP(W13, 45, D, E, F, G, H, A, B, C)
+    MSG_SCHED_ROUND_16_63(W13, W14,  W6, W11)
+    PROCESS_LOOP(W14, 46, C, D, E, F, G, H, A, B)
+    MSG_SCHED_ROUND_16_63(W14, W15,  W7, W12)
+    PROCESS_LOOP(W15, 47, B, C, D, E, F, G, H, A)
+    MSG_SCHED_ROUND_16_63(W15,  W0,  W8, W13)
+
+    // Check if this is the last block
+    sub INP_SIZE, 1
+    JE  lastLoop
+
+    // Load next mask for inputs
+    ADDQ $8, MASKP_P9
+    MOVQ (MASKP_P9), MASK_P9
+
+    // Process last 16 rounds
+    // Read in next block msg data for use in first 16 words of msg sched
+
+    PROCESS_LOOP( W0, 48, A, B, C, D, E, F, G, H)
+    MSG_SCHED_ROUND_00_15( W0,  0, skipNext0)
+    PROCESS_LOOP( W1, 49, H, A, B, C, D, E, F, G)
+    MSG_SCHED_ROUND_00_15( W1,  1, skipNext1)
+    PROCESS_LOOP( W2, 50, G, H, A, B, C, D, E, F)
+    MSG_SCHED_ROUND_00_15( W2,  2, skipNext2)
+    PROCESS_LOOP( W3, 51, F, G, H, A, B, C, D, E)
+    MSG_SCHED_ROUND_00_15( W3,  3, skipNext3)
+    PROCESS_LOOP( W4, 52, E, F, G, H, A, B, C, D)
+    MSG_SCHED_ROUND_00_15( W4,  4, skipNext4)
+    PROCESS_LOOP( W5, 53, D, E, F, G, H, A, B, C)
+    MSG_SCHED_ROUND_00_15( W5,  5, skipNext5)
+    PROCESS_LOOP( W6, 54, C, D, E, F, G, H, A, B)
+    MSG_SCHED_ROUND_00_15( W6,  6, skipNext6)
+    PROCESS_LOOP( W7, 55, B, C, D, E, F, G, H, A)
+    MSG_SCHED_ROUND_00_15( W7,  7, skipNext7)
+    PROCESS_LOOP( W8, 56, A, B, C, D, E, F, G, H)
+    MSG_SCHED_ROUND_00_15( W8,  8, skipNext8)
+    PROCESS_LOOP( W9, 57, H, A, B, C, D, E, F, G)
+    MSG_SCHED_ROUND_00_15( W9,  9, skipNext9)
+    PROCESS_LOOP(W10, 58, G, H, A, B, C, D, E, F)
+    MSG_SCHED_ROUND_00_15(W10, 10, skipNext10)
+    PROCESS_LOOP(W11, 59, F, G, H, A, B, C, D, E)
+    MSG_SCHED_ROUND_00_15(W11, 11, skipNext11)
+    PROCESS_LOOP(W12, 60, E, F, G, H, A, B, C, D)
+    MSG_SCHED_ROUND_00_15(W12, 12, skipNext12)
+    PROCESS_LOOP(W13, 61, D, E, F, G, H, A, B, C)
+    MSG_SCHED_ROUND_00_15(W13, 13, skipNext13)
+    PROCESS_LOOP(W14, 62, C, D, E, F, G, H, A, B)
+    MSG_SCHED_ROUND_00_15(W14, 14, skipNext14)
+    PROCESS_LOOP(W15, 63, B, C, D, E, F, G, H, A)
+    MSG_SCHED_ROUND_00_15(W15, 15, skipNext15)
+
+    // Add old digest
+    vmovdqu32  TMP2, A
+    vmovdqu32 A, [SCRATCH + 64*0]
+    vpaddd A{k1}, A, TMP2
+    vmovdqu32  TMP2, B
+    vmovdqu32 B, [SCRATCH + 64*1]
+    vpaddd B{k1}, B, TMP2
+    vmovdqu32  TMP2, C
+    vmovdqu32 C, [SCRATCH + 64*2]
+    vpaddd C{k1}, C, TMP2
+    vmovdqu32  TMP2, D
+    vmovdqu32 D, [SCRATCH + 64*3]
+    vpaddd D{k1}, D, TMP2
+    vmovdqu32  TMP2, E
+    vmovdqu32 E, [SCRATCH + 64*4]
+    vpaddd E{k1}, E, TMP2
+    vmovdqu32  TMP2, F
+    vmovdqu32 F, [SCRATCH + 64*5]
+    vpaddd F{k1}, F, TMP2
+    vmovdqu32  TMP2, G
+    vmovdqu32 G, [SCRATCH + 64*6]
+    vpaddd G{k1}, G, TMP2
+    vmovdqu32  TMP2, H
+    vmovdqu32 H, [SCRATCH + 64*7]
+    vpaddd H{k1}, H, TMP2
+
+    kmovq k1, mask
+    JMP lloop
+
+lastLoop:
+    // Process last 16 rounds
+    PROCESS_LOOP( W0, 48, A, B, C, D, E, F, G, H)
+    PROCESS_LOOP( W1, 49, H, A, B, C, D, E, F, G)
+    PROCESS_LOOP( W2, 50, G, H, A, B, C, D, E, F)
+    PROCESS_LOOP( W3, 51, F, G, H, A, B, C, D, E)
+    PROCESS_LOOP( W4, 52, E, F, G, H, A, B, C, D)
+    PROCESS_LOOP( W5, 53, D, E, F, G, H, A, B, C)
+    PROCESS_LOOP( W6, 54, C, D, E, F, G, H, A, B)
+    PROCESS_LOOP( W7, 55, B, C, D, E, F, G, H, A)
+    PROCESS_LOOP( W8, 56, A, B, C, D, E, F, G, H)
+    PROCESS_LOOP( W9, 57, H, A, B, C, D, E, F, G)
+    PROCESS_LOOP(W10, 58, G, H, A, B, C, D, E, F)
+    PROCESS_LOOP(W11, 59, F, G, H, A, B, C, D, E)
+    PROCESS_LOOP(W12, 60, E, F, G, H, A, B, C, D)
+    PROCESS_LOOP(W13, 61, D, E, F, G, H, A, B, C)
+    PROCESS_LOOP(W14, 62, C, D, E, F, G, H, A, B)
+    PROCESS_LOOP(W15, 63, B, C, D, E, F, G, H, A)
+
+    // Add old digest
+    vmovdqu32  TMP2, A
+    vmovdqu32 A, [SCRATCH + 64*0]
+    vpaddd A{k1}, A, TMP2
+    vmovdqu32  TMP2, B
+    vmovdqu32 B, [SCRATCH + 64*1]
+    vpaddd B{k1}, B, TMP2
+    vmovdqu32  TMP2, C
+    vmovdqu32 C, [SCRATCH + 64*2]
+    vpaddd C{k1}, C, TMP2
+    vmovdqu32  TMP2, D
+    vmovdqu32 D, [SCRATCH + 64*3]
+    vpaddd D{k1}, D, TMP2
+    vmovdqu32  TMP2, E
+    vmovdqu32 E, [SCRATCH + 64*4]
+    vpaddd E{k1}, E, TMP2
+    vmovdqu32  TMP2, F
+    vmovdqu32 F, [SCRATCH + 64*5]
+    vpaddd F{k1}, F, TMP2
+    vmovdqu32  TMP2, G
+    vmovdqu32 G, [SCRATCH + 64*6]
+    vpaddd G{k1}, G, TMP2
+    vmovdqu32  TMP2, H
+    vmovdqu32 H, [SCRATCH + 64*7]
+    vpaddd H{k1}, H, TMP2
+
+    // Write out digest
+    vmovdqu32 [STATE + 0*SHA256_DIGEST_ROW_SIZE], A
+    vmovdqu32 [STATE + 1*SHA256_DIGEST_ROW_SIZE], B
+    vmovdqu32 [STATE + 2*SHA256_DIGEST_ROW_SIZE], C
+    vmovdqu32 [STATE + 3*SHA256_DIGEST_ROW_SIZE], D
+    vmovdqu32 [STATE + 4*SHA256_DIGEST_ROW_SIZE], E
+    vmovdqu32 [STATE + 5*SHA256_DIGEST_ROW_SIZE], F
+    vmovdqu32 [STATE + 6*SHA256_DIGEST_ROW_SIZE], G
+    vmovdqu32 [STATE + 7*SHA256_DIGEST_ROW_SIZE], H
+
+    VZEROUPPER
+    RET
+
+//
+// Tables
+//
+
+DATA PSHUFFLE_BYTE_FLIP_MASK<>+0x000(SB)/8, $0x0405060700010203
+DATA PSHUFFLE_BYTE_FLIP_MASK<>+0x008(SB)/8, $0x0c0d0e0f08090a0b
+DATA PSHUFFLE_BYTE_FLIP_MASK<>+0x010(SB)/8, $0x0405060700010203
+DATA PSHUFFLE_BYTE_FLIP_MASK<>+0x018(SB)/8, $0x0c0d0e0f08090a0b
+DATA PSHUFFLE_BYTE_FLIP_MASK<>+0x020(SB)/8, $0x0405060700010203
+DATA PSHUFFLE_BYTE_FLIP_MASK<>+0x028(SB)/8, $0x0c0d0e0f08090a0b
+DATA PSHUFFLE_BYTE_FLIP_MASK<>+0x030(SB)/8, $0x0405060700010203
+DATA PSHUFFLE_BYTE_FLIP_MASK<>+0x038(SB)/8, $0x0c0d0e0f08090a0b
+GLOBL PSHUFFLE_BYTE_FLIP_MASK<>(SB), 8, $64
+
+DATA PSHUFFLE_TRANSPOSE16_MASK1<>+0x000(SB)/8, $0x0000000000000000
+DATA PSHUFFLE_TRANSPOSE16_MASK1<>+0x008(SB)/8, $0x0000000000000001
+DATA PSHUFFLE_TRANSPOSE16_MASK1<>+0x010(SB)/8, $0x0000000000000008
+DATA PSHUFFLE_TRANSPOSE16_MASK1<>+0x018(SB)/8, $0x0000000000000009
+DATA PSHUFFLE_TRANSPOSE16_MASK1<>+0x020(SB)/8, $0x0000000000000004
+DATA PSHUFFLE_TRANSPOSE16_MASK1<>+0x028(SB)/8, $0x0000000000000005
+DATA PSHUFFLE_TRANSPOSE16_MASK1<>+0x030(SB)/8, $0x000000000000000C
+DATA PSHUFFLE_TRANSPOSE16_MASK1<>+0x038(SB)/8, $0x000000000000000D
+GLOBL PSHUFFLE_TRANSPOSE16_MASK1<>(SB), 8, $64
+
+DATA PSHUFFLE_TRANSPOSE16_MASK2<>+0x000(SB)/8, $0x0000000000000002
+DATA PSHUFFLE_TRANSPOSE16_MASK2<>+0x008(SB)/8, $0x0000000000000003
+DATA PSHUFFLE_TRANSPOSE16_MASK2<>+0x010(SB)/8, $0x000000000000000A
+DATA PSHUFFLE_TRANSPOSE16_MASK2<>+0x018(SB)/8, $0x000000000000000B
+DATA PSHUFFLE_TRANSPOSE16_MASK2<>+0x020(SB)/8, $0x0000000000000006
+DATA PSHUFFLE_TRANSPOSE16_MASK2<>+0x028(SB)/8, $0x0000000000000007
+DATA PSHUFFLE_TRANSPOSE16_MASK2<>+0x030(SB)/8, $0x000000000000000E
+DATA PSHUFFLE_TRANSPOSE16_MASK2<>+0x038(SB)/8, $0x000000000000000F
+GLOBL PSHUFFLE_TRANSPOSE16_MASK2<>(SB), 8, $64

diff --git a/vendor/github.com/minio/sha256-simd/sha256blockAvx512_amd64.go b/vendor/github.com/minio/sha256-simd/sha256blockAvx512_amd64.go
new file mode 100644 (file)
index 0000000..e6bd455
--- /dev/null
+++ b/vendor/github.com/minio/sha256-simd/sha256blockAvx512_amd64.go
@@ -0,0 +1,500 @@
+//+build !noasm
+
+/*
+ * Minio Cloud Storage, (C) 2017 Minio, Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package sha256
+
+import (
+       "encoding/binary"
+       "errors"
+       "hash"
+       "sort"
+       "sync/atomic"
+       "time"
+)
+
+//go:noescape
+func sha256X16Avx512(digests *[512]byte, scratch *[512]byte, table *[512]uint64, mask []uint64, inputs [16][]byte)
+
+// Avx512ServerUID - Do not start at 0 but next multiple of 16 so as to be able to
+// differentiate with default initialiation value of 0
+const Avx512ServerUID = 16
+
+var uidCounter uint64
+
+// NewAvx512 - initialize sha256 Avx512 implementation.
+func NewAvx512(a512srv *Avx512Server) hash.Hash {
+       uid := atomic.AddUint64(&uidCounter, 1)
+       return &Avx512Digest{uid: uid, a512srv: a512srv}
+}
+
+// Avx512Digest - Type for computing SHA256 using Avx512
+type Avx512Digest struct {
+       uid     uint64
+       a512srv *Avx512Server
+       x       [chunk]byte
+       nx      int
+       len     uint64
+       final   bool
+       result  [Size]byte
+}
+
+// Size - Return size of checksum
+func (d *Avx512Digest) Size() int { return Size }
+
+// BlockSize - Return blocksize of checksum
+func (d Avx512Digest) BlockSize() int { return BlockSize }
+
+// Reset - reset sha digest to its initial values
+func (d *Avx512Digest) Reset() {
+       d.a512srv.blocksCh <- blockInput{uid: d.uid, reset: true}
+       d.nx = 0
+       d.len = 0
+       d.final = false
+}
+
+// Write to digest
+func (d *Avx512Digest) Write(p []byte) (nn int, err error) {
+
+       if d.final {
+               return 0, errors.New("Avx512Digest already finalized. Reset first before writing again")
+       }
+
+       nn = len(p)
+       d.len += uint64(nn)
+       if d.nx > 0 {
+               n := copy(d.x[d.nx:], p)
+               d.nx += n
+               if d.nx == chunk {
+                       d.a512srv.blocksCh <- blockInput{uid: d.uid, msg: d.x[:]}
+                       d.nx = 0
+               }
+               p = p[n:]
+       }
+       if len(p) >= chunk {
+               n := len(p) &^ (chunk - 1)
+               d.a512srv.blocksCh <- blockInput{uid: d.uid, msg: p[:n]}
+               p = p[n:]
+       }
+       if len(p) > 0 {
+               d.nx = copy(d.x[:], p)
+       }
+       return
+}
+
+// Sum - Return sha256 sum in bytes
+func (d *Avx512Digest) Sum(in []byte) (result []byte) {
+
+       if d.final {
+               return append(in, d.result[:]...)
+       }
+
+       trail := make([]byte, 0, 128)
+
+       len := d.len
+       // Padding.  Add a 1 bit and 0 bits until 56 bytes mod 64.
+       var tmp [64]byte
+       tmp[0] = 0x80
+       if len%64 < 56 {
+               trail = append(d.x[:d.nx], tmp[0:56-len%64]...)
+       } else {
+               trail = append(d.x[:d.nx], tmp[0:64+56-len%64]...)
+       }
+       d.nx = 0
+
+       // Length in bits.
+       len <<= 3
+       for i := uint(0); i < 8; i++ {
+               tmp[i] = byte(len >> (56 - 8*i))
+       }
+       trail = append(trail, tmp[0:8]...)
+
+       sumCh := make(chan [Size]byte)
+       d.a512srv.blocksCh <- blockInput{uid: d.uid, msg: trail, final: true, sumCh: sumCh}
+       d.result = <-sumCh
+       d.final = true
+       return append(in, d.result[:]...)
+}
+
+var table = [512]uint64{
+       0x428a2f98428a2f98, 0x428a2f98428a2f98, 0x428a2f98428a2f98, 0x428a2f98428a2f98,
+       0x428a2f98428a2f98, 0x428a2f98428a2f98, 0x428a2f98428a2f98, 0x428a2f98428a2f98,
+       0x7137449171374491, 0x7137449171374491, 0x7137449171374491, 0x7137449171374491,
+       0x7137449171374491, 0x7137449171374491, 0x7137449171374491, 0x7137449171374491,
+       0xb5c0fbcfb5c0fbcf, 0xb5c0fbcfb5c0fbcf, 0xb5c0fbcfb5c0fbcf, 0xb5c0fbcfb5c0fbcf,
+       0xb5c0fbcfb5c0fbcf, 0xb5c0fbcfb5c0fbcf, 0xb5c0fbcfb5c0fbcf, 0xb5c0fbcfb5c0fbcf,
+       0xe9b5dba5e9b5dba5, 0xe9b5dba5e9b5dba5, 0xe9b5dba5e9b5dba5, 0xe9b5dba5e9b5dba5,
+       0xe9b5dba5e9b5dba5, 0xe9b5dba5e9b5dba5, 0xe9b5dba5e9b5dba5, 0xe9b5dba5e9b5dba5,
+       0x3956c25b3956c25b, 0x3956c25b3956c25b, 0x3956c25b3956c25b, 0x3956c25b3956c25b,
+       0x3956c25b3956c25b, 0x3956c25b3956c25b, 0x3956c25b3956c25b, 0x3956c25b3956c25b,
+       0x59f111f159f111f1, 0x59f111f159f111f1, 0x59f111f159f111f1, 0x59f111f159f111f1,
+       0x59f111f159f111f1, 0x59f111f159f111f1, 0x59f111f159f111f1, 0x59f111f159f111f1,
+       0x923f82a4923f82a4, 0x923f82a4923f82a4, 0x923f82a4923f82a4, 0x923f82a4923f82a4,
+       0x923f82a4923f82a4, 0x923f82a4923f82a4, 0x923f82a4923f82a4, 0x923f82a4923f82a4,
+       0xab1c5ed5ab1c5ed5, 0xab1c5ed5ab1c5ed5, 0xab1c5ed5ab1c5ed5, 0xab1c5ed5ab1c5ed5,
+       0xab1c5ed5ab1c5ed5, 0xab1c5ed5ab1c5ed5, 0xab1c5ed5ab1c5ed5, 0xab1c5ed5ab1c5ed5,
+       0xd807aa98d807aa98, 0xd807aa98d807aa98, 0xd807aa98d807aa98, 0xd807aa98d807aa98,
+       0xd807aa98d807aa98, 0xd807aa98d807aa98, 0xd807aa98d807aa98, 0xd807aa98d807aa98,
+       0x12835b0112835b01, 0x12835b0112835b01, 0x12835b0112835b01, 0x12835b0112835b01,
+       0x12835b0112835b01, 0x12835b0112835b01, 0x12835b0112835b01, 0x12835b0112835b01,
+       0x243185be243185be, 0x243185be243185be, 0x243185be243185be, 0x243185be243185be,
+       0x243185be243185be, 0x243185be243185be, 0x243185be243185be, 0x243185be243185be,
+       0x550c7dc3550c7dc3, 0x550c7dc3550c7dc3, 0x550c7dc3550c7dc3, 0x550c7dc3550c7dc3,
+       0x550c7dc3550c7dc3, 0x550c7dc3550c7dc3, 0x550c7dc3550c7dc3, 0x550c7dc3550c7dc3,
+       0x72be5d7472be5d74, 0x72be5d7472be5d74, 0x72be5d7472be5d74, 0x72be5d7472be5d74,
+       0x72be5d7472be5d74, 0x72be5d7472be5d74, 0x72be5d7472be5d74, 0x72be5d7472be5d74,
+       0x80deb1fe80deb1fe, 0x80deb1fe80deb1fe, 0x80deb1fe80deb1fe, 0x80deb1fe80deb1fe,
+       0x80deb1fe80deb1fe, 0x80deb1fe80deb1fe, 0x80deb1fe80deb1fe, 0x80deb1fe80deb1fe,
+       0x9bdc06a79bdc06a7, 0x9bdc06a79bdc06a7, 0x9bdc06a79bdc06a7, 0x9bdc06a79bdc06a7,
+       0x9bdc06a79bdc06a7, 0x9bdc06a79bdc06a7, 0x9bdc06a79bdc06a7, 0x9bdc06a79bdc06a7,
+       0xc19bf174c19bf174, 0xc19bf174c19bf174, 0xc19bf174c19bf174, 0xc19bf174c19bf174,
+       0xc19bf174c19bf174, 0xc19bf174c19bf174, 0xc19bf174c19bf174, 0xc19bf174c19bf174,
+       0xe49b69c1e49b69c1, 0xe49b69c1e49b69c1, 0xe49b69c1e49b69c1, 0xe49b69c1e49b69c1,
+       0xe49b69c1e49b69c1, 0xe49b69c1e49b69c1, 0xe49b69c1e49b69c1, 0xe49b69c1e49b69c1,
+       0xefbe4786efbe4786, 0xefbe4786efbe4786, 0xefbe4786efbe4786, 0xefbe4786efbe4786,
+       0xefbe4786efbe4786, 0xefbe4786efbe4786, 0xefbe4786efbe4786, 0xefbe4786efbe4786,
+       0x0fc19dc60fc19dc6, 0x0fc19dc60fc19dc6, 0x0fc19dc60fc19dc6, 0x0fc19dc60fc19dc6,
+       0x0fc19dc60fc19dc6, 0x0fc19dc60fc19dc6, 0x0fc19dc60fc19dc6, 0x0fc19dc60fc19dc6,
+       0x240ca1cc240ca1cc, 0x240ca1cc240ca1cc, 0x240ca1cc240ca1cc, 0x240ca1cc240ca1cc,
+       0x240ca1cc240ca1cc, 0x240ca1cc240ca1cc, 0x240ca1cc240ca1cc, 0x240ca1cc240ca1cc,
+       0x2de92c6f2de92c6f, 0x2de92c6f2de92c6f, 0x2de92c6f2de92c6f, 0x2de92c6f2de92c6f,
+       0x2de92c6f2de92c6f, 0x2de92c6f2de92c6f, 0x2de92c6f2de92c6f, 0x2de92c6f2de92c6f,
+       0x4a7484aa4a7484aa, 0x4a7484aa4a7484aa, 0x4a7484aa4a7484aa, 0x4a7484aa4a7484aa,
+       0x4a7484aa4a7484aa, 0x4a7484aa4a7484aa, 0x4a7484aa4a7484aa, 0x4a7484aa4a7484aa,
+       0x5cb0a9dc5cb0a9dc, 0x5cb0a9dc5cb0a9dc, 0x5cb0a9dc5cb0a9dc, 0x5cb0a9dc5cb0a9dc,
+       0x5cb0a9dc5cb0a9dc, 0x5cb0a9dc5cb0a9dc, 0x5cb0a9dc5cb0a9dc, 0x5cb0a9dc5cb0a9dc,
+       0x76f988da76f988da, 0x76f988da76f988da, 0x76f988da76f988da, 0x76f988da76f988da,
+       0x76f988da76f988da, 0x76f988da76f988da, 0x76f988da76f988da, 0x76f988da76f988da,
+       0x983e5152983e5152, 0x983e5152983e5152, 0x983e5152983e5152, 0x983e5152983e5152,
+       0x983e5152983e5152, 0x983e5152983e5152, 0x983e5152983e5152, 0x983e5152983e5152,
+       0xa831c66da831c66d, 0xa831c66da831c66d, 0xa831c66da831c66d, 0xa831c66da831c66d,
+       0xa831c66da831c66d, 0xa831c66da831c66d, 0xa831c66da831c66d, 0xa831c66da831c66d,
+       0xb00327c8b00327c8, 0xb00327c8b00327c8, 0xb00327c8b00327c8, 0xb00327c8b00327c8,
+       0xb00327c8b00327c8, 0xb00327c8b00327c8, 0xb00327c8b00327c8, 0xb00327c8b00327c8,
+       0xbf597fc7bf597fc7, 0xbf597fc7bf597fc7, 0xbf597fc7bf597fc7, 0xbf597fc7bf597fc7,
+       0xbf597fc7bf597fc7, 0xbf597fc7bf597fc7, 0xbf597fc7bf597fc7, 0xbf597fc7bf597fc7,
+       0xc6e00bf3c6e00bf3, 0xc6e00bf3c6e00bf3, 0xc6e00bf3c6e00bf3, 0xc6e00bf3c6e00bf3,
+       0xc6e00bf3c6e00bf3, 0xc6e00bf3c6e00bf3, 0xc6e00bf3c6e00bf3, 0xc6e00bf3c6e00bf3,
+       0xd5a79147d5a79147, 0xd5a79147d5a79147, 0xd5a79147d5a79147, 0xd5a79147d5a79147,
+       0xd5a79147d5a79147, 0xd5a79147d5a79147, 0xd5a79147d5a79147, 0xd5a79147d5a79147,
+       0x06ca635106ca6351, 0x06ca635106ca6351, 0x06ca635106ca6351, 0x06ca635106ca6351,
+       0x06ca635106ca6351, 0x06ca635106ca6351, 0x06ca635106ca6351, 0x06ca635106ca6351,
+       0x1429296714292967, 0x1429296714292967, 0x1429296714292967, 0x1429296714292967,
+       0x1429296714292967, 0x1429296714292967, 0x1429296714292967, 0x1429296714292967,
+       0x27b70a8527b70a85, 0x27b70a8527b70a85, 0x27b70a8527b70a85, 0x27b70a8527b70a85,
+       0x27b70a8527b70a85, 0x27b70a8527b70a85, 0x27b70a8527b70a85, 0x27b70a8527b70a85,
+       0x2e1b21382e1b2138, 0x2e1b21382e1b2138, 0x2e1b21382e1b2138, 0x2e1b21382e1b2138,
+       0x2e1b21382e1b2138, 0x2e1b21382e1b2138, 0x2e1b21382e1b2138, 0x2e1b21382e1b2138,
+       0x4d2c6dfc4d2c6dfc, 0x4d2c6dfc4d2c6dfc, 0x4d2c6dfc4d2c6dfc, 0x4d2c6dfc4d2c6dfc,
+       0x4d2c6dfc4d2c6dfc, 0x4d2c6dfc4d2c6dfc, 0x4d2c6dfc4d2c6dfc, 0x4d2c6dfc4d2c6dfc,
+       0x53380d1353380d13, 0x53380d1353380d13, 0x53380d1353380d13, 0x53380d1353380d13,
+       0x53380d1353380d13, 0x53380d1353380d13, 0x53380d1353380d13, 0x53380d1353380d13,
+       0x650a7354650a7354, 0x650a7354650a7354, 0x650a7354650a7354, 0x650a7354650a7354,
+       0x650a7354650a7354, 0x650a7354650a7354, 0x650a7354650a7354, 0x650a7354650a7354,
+       0x766a0abb766a0abb, 0x766a0abb766a0abb, 0x766a0abb766a0abb, 0x766a0abb766a0abb,
+       0x766a0abb766a0abb, 0x766a0abb766a0abb, 0x766a0abb766a0abb, 0x766a0abb766a0abb,
+       0x81c2c92e81c2c92e, 0x81c2c92e81c2c92e, 0x81c2c92e81c2c92e, 0x81c2c92e81c2c92e,
+       0x81c2c92e81c2c92e, 0x81c2c92e81c2c92e, 0x81c2c92e81c2c92e, 0x81c2c92e81c2c92e,
+       0x92722c8592722c85, 0x92722c8592722c85, 0x92722c8592722c85, 0x92722c8592722c85,
+       0x92722c8592722c85, 0x92722c8592722c85, 0x92722c8592722c85, 0x92722c8592722c85,
+       0xa2bfe8a1a2bfe8a1, 0xa2bfe8a1a2bfe8a1, 0xa2bfe8a1a2bfe8a1, 0xa2bfe8a1a2bfe8a1,
+       0xa2bfe8a1a2bfe8a1, 0xa2bfe8a1a2bfe8a1, 0xa2bfe8a1a2bfe8a1, 0xa2bfe8a1a2bfe8a1,
+       0xa81a664ba81a664b, 0xa81a664ba81a664b, 0xa81a664ba81a664b, 0xa81a664ba81a664b,
+       0xa81a664ba81a664b, 0xa81a664ba81a664b, 0xa81a664ba81a664b, 0xa81a664ba81a664b,
+       0xc24b8b70c24b8b70, 0xc24b8b70c24b8b70, 0xc24b8b70c24b8b70, 0xc24b8b70c24b8b70,
+       0xc24b8b70c24b8b70, 0xc24b8b70c24b8b70, 0xc24b8b70c24b8b70, 0xc24b8b70c24b8b70,
+       0xc76c51a3c76c51a3, 0xc76c51a3c76c51a3, 0xc76c51a3c76c51a3, 0xc76c51a3c76c51a3,
+       0xc76c51a3c76c51a3, 0xc76c51a3c76c51a3, 0xc76c51a3c76c51a3, 0xc76c51a3c76c51a3,
+       0xd192e819d192e819, 0xd192e819d192e819, 0xd192e819d192e819, 0xd192e819d192e819,
+       0xd192e819d192e819, 0xd192e819d192e819, 0xd192e819d192e819, 0xd192e819d192e819,
+       0xd6990624d6990624, 0xd6990624d6990624, 0xd6990624d6990624, 0xd6990624d6990624,
+       0xd6990624d6990624, 0xd6990624d6990624, 0xd6990624d6990624, 0xd6990624d6990624,
+       0xf40e3585f40e3585, 0xf40e3585f40e3585, 0xf40e3585f40e3585, 0xf40e3585f40e3585,
+       0xf40e3585f40e3585, 0xf40e3585f40e3585, 0xf40e3585f40e3585, 0xf40e3585f40e3585,
+       0x106aa070106aa070, 0x106aa070106aa070, 0x106aa070106aa070, 0x106aa070106aa070,
+       0x106aa070106aa070, 0x106aa070106aa070, 0x106aa070106aa070, 0x106aa070106aa070,
+       0x19a4c11619a4c116, 0x19a4c11619a4c116, 0x19a4c11619a4c116, 0x19a4c11619a4c116,
+       0x19a4c11619a4c116, 0x19a4c11619a4c116, 0x19a4c11619a4c116, 0x19a4c11619a4c116,
+       0x1e376c081e376c08, 0x1e376c081e376c08, 0x1e376c081e376c08, 0x1e376c081e376c08,
+       0x1e376c081e376c08, 0x1e376c081e376c08, 0x1e376c081e376c08, 0x1e376c081e376c08,
+       0x2748774c2748774c, 0x2748774c2748774c, 0x2748774c2748774c, 0x2748774c2748774c,
+       0x2748774c2748774c, 0x2748774c2748774c, 0x2748774c2748774c, 0x2748774c2748774c,
+       0x34b0bcb534b0bcb5, 0x34b0bcb534b0bcb5, 0x34b0bcb534b0bcb5, 0x34b0bcb534b0bcb5,
+       0x34b0bcb534b0bcb5, 0x34b0bcb534b0bcb5, 0x34b0bcb534b0bcb5, 0x34b0bcb534b0bcb5,
+       0x391c0cb3391c0cb3, 0x391c0cb3391c0cb3, 0x391c0cb3391c0cb3, 0x391c0cb3391c0cb3,
+       0x391c0cb3391c0cb3, 0x391c0cb3391c0cb3, 0x391c0cb3391c0cb3, 0x391c0cb3391c0cb3,
+       0x4ed8aa4a4ed8aa4a, 0x4ed8aa4a4ed8aa4a, 0x4ed8aa4a4ed8aa4a, 0x4ed8aa4a4ed8aa4a,
+       0x4ed8aa4a4ed8aa4a, 0x4ed8aa4a4ed8aa4a, 0x4ed8aa4a4ed8aa4a, 0x4ed8aa4a4ed8aa4a,
+       0x5b9cca4f5b9cca4f, 0x5b9cca4f5b9cca4f, 0x5b9cca4f5b9cca4f, 0x5b9cca4f5b9cca4f,
+       0x5b9cca4f5b9cca4f, 0x5b9cca4f5b9cca4f, 0x5b9cca4f5b9cca4f, 0x5b9cca4f5b9cca4f,
+       0x682e6ff3682e6ff3, 0x682e6ff3682e6ff3, 0x682e6ff3682e6ff3, 0x682e6ff3682e6ff3,
+       0x682e6ff3682e6ff3, 0x682e6ff3682e6ff3, 0x682e6ff3682e6ff3, 0x682e6ff3682e6ff3,
+       0x748f82ee748f82ee, 0x748f82ee748f82ee, 0x748f82ee748f82ee, 0x748f82ee748f82ee,
+       0x748f82ee748f82ee, 0x748f82ee748f82ee, 0x748f82ee748f82ee, 0x748f82ee748f82ee,
+       0x78a5636f78a5636f, 0x78a5636f78a5636f, 0x78a5636f78a5636f, 0x78a5636f78a5636f,
+       0x78a5636f78a5636f, 0x78a5636f78a5636f, 0x78a5636f78a5636f, 0x78a5636f78a5636f,
+       0x84c8781484c87814, 0x84c8781484c87814, 0x84c8781484c87814, 0x84c8781484c87814,
+       0x84c8781484c87814, 0x84c8781484c87814, 0x84c8781484c87814, 0x84c8781484c87814,
+       0x8cc702088cc70208, 0x8cc702088cc70208, 0x8cc702088cc70208, 0x8cc702088cc70208,
+       0x8cc702088cc70208, 0x8cc702088cc70208, 0x8cc702088cc70208, 0x8cc702088cc70208,
+       0x90befffa90befffa, 0x90befffa90befffa, 0x90befffa90befffa, 0x90befffa90befffa,
+       0x90befffa90befffa, 0x90befffa90befffa, 0x90befffa90befffa, 0x90befffa90befffa,
+       0xa4506ceba4506ceb, 0xa4506ceba4506ceb, 0xa4506ceba4506ceb, 0xa4506ceba4506ceb,
+       0xa4506ceba4506ceb, 0xa4506ceba4506ceb, 0xa4506ceba4506ceb, 0xa4506ceba4506ceb,
+       0xbef9a3f7bef9a3f7, 0xbef9a3f7bef9a3f7, 0xbef9a3f7bef9a3f7, 0xbef9a3f7bef9a3f7,
+       0xbef9a3f7bef9a3f7, 0xbef9a3f7bef9a3f7, 0xbef9a3f7bef9a3f7, 0xbef9a3f7bef9a3f7,
+       0xc67178f2c67178f2, 0xc67178f2c67178f2, 0xc67178f2c67178f2, 0xc67178f2c67178f2,
+       0xc67178f2c67178f2, 0xc67178f2c67178f2, 0xc67178f2c67178f2, 0xc67178f2c67178f2}
+
+// Interface function to assembly ode
+func blockAvx512(digests *[512]byte, input [16][]byte, mask []uint64) [16][Size]byte {
+
+       scratch := [512]byte{}
+       sha256X16Avx512(digests, &scratch, &table, mask, input)
+
+       output := [16][Size]byte{}
+       for i := 0; i < 16; i++ {
+               output[i] = getDigest(i, digests[:])
+       }
+
+       return output
+}
+
+func getDigest(index int, state []byte) (sum [Size]byte) {
+       for j := 0; j < 16; j += 2 {
+               for i := index*4 + j*Size; i < index*4+(j+1)*Size; i += Size {
+                       binary.BigEndian.PutUint32(sum[j*2:], binary.LittleEndian.Uint32(state[i:i+4]))
+               }
+       }
+       return
+}
+
+// Message to send across input channel
+type blockInput struct {
+       uid   uint64
+       msg   []byte
+       reset bool
+       final bool
+       sumCh chan [Size]byte
+}
+
+// Avx512Server - Type to implement 16x parallel handling of SHA256 invocations
+type Avx512Server struct {
+       blocksCh chan blockInput       // Input channel
+       totalIn  int                   // Total number of inputs waiting to be processed
+       lanes    [16]Avx512LaneInfo    // Array with info per lane (out of 16)
+       digests  map[uint64][Size]byte // Map of uids to (interim) digest results
+}
+
+// Avx512LaneInfo - Info for each lane
+type Avx512LaneInfo struct {
+       uid      uint64          // unique identification for this SHA processing
+       block    []byte          // input block to be processed
+       outputCh chan [Size]byte // channel for output result
+}
+
+// NewAvx512Server - Create new object for parallel processing handling
+func NewAvx512Server() *Avx512Server {
+       a512srv := &Avx512Server{}
+       a512srv.digests = make(map[uint64][Size]byte)
+       a512srv.blocksCh = make(chan blockInput)
+
+       // Start a single thread for reading from the input channel
+       go a512srv.Process()
+       return a512srv
+}
+
+// Process - Sole handler for reading from the input channel
+func (a512srv *Avx512Server) Process() {
+       for {
+               select {
+               case block := <-a512srv.blocksCh:
+                       if block.reset {
+                               a512srv.reset(block.uid)
+                               continue
+                       }
+                       index := block.uid & 0xf
+                       // fmt.Println("Adding message:", block.uid, index)
+
+                       if a512srv.lanes[index].block != nil { // If slot is already filled, process all inputs
+                               //fmt.Println("Invoking Blocks()")
+                               a512srv.blocks()
+                       }
+                       a512srv.totalIn++
+                       a512srv.lanes[index] = Avx512LaneInfo{uid: block.uid, block: block.msg}
+                       if block.final {
+                               a512srv.lanes[index].outputCh = block.sumCh
+                       }
+                       if a512srv.totalIn == len(a512srv.lanes) {
+                               // fmt.Println("Invoking Blocks() while FULL: ")
+                               a512srv.blocks()
+                       }
+
+                       // TODO: test with larger timeout
+               case <-time.After(1 * time.Microsecond):
+                       for _, lane := range a512srv.lanes {
+                               if lane.block != nil { // check if there is any input to process
+                                       // fmt.Println("Invoking Blocks() on TIMEOUT: ")
+                                       a512srv.blocks()
+                                       break // we are done
+                               }
+                       }
+               }
+       }
+}
+
+// Do a reset for this calculation
+func (a512srv *Avx512Server) reset(uid uint64) {
+
+       // Check if there is a message still waiting to be processed (and remove if so)
+       for i, lane := range a512srv.lanes {
+               if lane.uid == uid {
+                       if lane.block != nil {
+                               a512srv.lanes[i] = Avx512LaneInfo{} // clear message
+                               a512srv.totalIn--
+                       }
+               }
+       }
+
+       // Delete entry from hash map
+       delete(a512srv.digests, uid)
+}
+
+// Invoke assembly and send results back
+func (a512srv *Avx512Server) blocks() (err error) {
+
+       inputs := [16][]byte{}
+       for i := range inputs {
+               inputs[i] = a512srv.lanes[i].block
+       }
+
+       mask := expandMask(genMask(inputs))
+       outputs := blockAvx512(a512srv.getDigests(), inputs, mask)
+
+       a512srv.totalIn = 0
+       for i := 0; i < len(outputs); i++ {
+               uid, outputCh := a512srv.lanes[i].uid, a512srv.lanes[i].outputCh
+               a512srv.digests[uid] = outputs[i]
+               a512srv.lanes[i] = Avx512LaneInfo{}
+
+               if outputCh != nil {
+                       // Send back result
+                       outputCh <- outputs[i]
+                       delete(a512srv.digests, uid) // Delete entry from hashmap
+               }
+       }
+       return
+}
+
+func (a512srv *Avx512Server) Write(uid uint64, p []byte) (nn int, err error) {
+       a512srv.blocksCh <- blockInput{uid: uid, msg: p}
+       return len(p), nil
+}
+
+// Sum - return sha256 sum in bytes for a given sum id.
+func (a512srv *Avx512Server) Sum(uid uint64, p []byte) [32]byte {
+       sumCh := make(chan [32]byte)
+       a512srv.blocksCh <- blockInput{uid: uid, msg: p, final: true, sumCh: sumCh}
+       return <-sumCh
+}
+
+func (a512srv *Avx512Server) getDigests() *[512]byte {
+       digests := [512]byte{}
+       for i, lane := range a512srv.lanes {
+               a, ok := a512srv.digests[lane.uid]
+               if ok {
+                       binary.BigEndian.PutUint32(digests[(i+0*16)*4:], binary.LittleEndian.Uint32(a[0:4]))
+                       binary.BigEndian.PutUint32(digests[(i+1*16)*4:], binary.LittleEndian.Uint32(a[4:8]))
+                       binary.BigEndian.PutUint32(digests[(i+2*16)*4:], binary.LittleEndian.Uint32(a[8:12]))
+                       binary.BigEndian.PutUint32(digests[(i+3*16)*4:], binary.LittleEndian.Uint32(a[12:16]))
+                       binary.BigEndian.PutUint32(digests[(i+4*16)*4:], binary.LittleEndian.Uint32(a[16:20]))
+                       binary.BigEndian.PutUint32(digests[(i+5*16)*4:], binary.LittleEndian.Uint32(a[20:24]))
+                       binary.BigEndian.PutUint32(digests[(i+6*16)*4:], binary.LittleEndian.Uint32(a[24:28]))
+                       binary.BigEndian.PutUint32(digests[(i+7*16)*4:], binary.LittleEndian.Uint32(a[28:32]))
+               } else {
+                       binary.LittleEndian.PutUint32(digests[(i+0*16)*4:], init0)
+                       binary.LittleEndian.PutUint32(digests[(i+1*16)*4:], init1)
+                       binary.LittleEndian.PutUint32(digests[(i+2*16)*4:], init2)
+                       binary.LittleEndian.PutUint32(digests[(i+3*16)*4:], init3)
+                       binary.LittleEndian.PutUint32(digests[(i+4*16)*4:], init4)
+                       binary.LittleEndian.PutUint32(digests[(i+5*16)*4:], init5)
+                       binary.LittleEndian.PutUint32(digests[(i+6*16)*4:], init6)
+                       binary.LittleEndian.PutUint32(digests[(i+7*16)*4:], init7)
+               }
+       }
+       return &digests
+}
+
+// Helper struct for sorting blocks based on length
+type lane struct {
+       len uint
+       pos uint
+}
+
+type lanes []lane
+
+func (lns lanes) Len() int           { return len(lns) }
+func (lns lanes) Swap(i, j int)      { lns[i], lns[j] = lns[j], lns[i] }
+func (lns lanes) Less(i, j int) bool { return lns[i].len < lns[j].len }
+
+// Helper struct for
+type maskRounds struct {
+       mask   uint64
+       rounds uint64
+}
+
+func genMask(input [16][]byte) [16]maskRounds {
+
+       // Sort on blocks length small to large
+       var sorted [16]lane
+       for c, inpt := range input {
+               sorted[c] = lane{uint(len(inpt)), uint(c)}
+       }
+       sort.Sort(lanes(sorted[:]))
+
+       // Create mask array including 'rounds' between masks
+       m, round, index := uint64(0xffff), uint64(0), 0
+       var mr [16]maskRounds
+       for _, s := range sorted {
+               if s.len > 0 {
+                       if uint64(s.len)>>6 > round {
+                               mr[index] = maskRounds{m, (uint64(s.len) >> 6) - round}
+                               index++
+                       }
+                       round = uint64(s.len) >> 6
+               }
+               m = m & ^(1 << uint(s.pos))
+       }
+
+       return mr
+}
+
+// TODO: remove function
+func expandMask(mr [16]maskRounds) []uint64 {
+       size := uint64(0)
+       for _, r := range mr {
+               size += r.rounds
+       }
+       result, index := make([]uint64, size), 0
+       for _, r := range mr {
+               for j := uint64(0); j < r.rounds; j++ {
+                       result[index] = r.mask
+                       index++
+               }
+       }
+       return result
+}

diff --git a/vendor/github.com/minio/sha256-simd/sha256blockAvx512_amd64.s b/vendor/github.com/minio/sha256-simd/sha256blockAvx512_amd64.s
new file mode 100644 (file)
index 0000000..14ae8a2
--- /dev/null
+++ b/vendor/github.com/minio/sha256-simd/sha256blockAvx512_amd64.s
@@ -0,0 +1,265 @@
+TEXT ·sha256X16Avx512(SB), 7, $0
+       MOVQ  digests+0(FP), DI
+       MOVQ  scratch+8(FP), R12
+       MOVQ  mask_len+32(FP), SI
+       MOVQ  mask_base+24(FP), R13
+       MOVQ  (R13), R14
+       LONG  $0x92fbc1c4; BYTE $0xce
+       LEAQ  inputs+48(FP), AX
+       QUAD  $0xf162076f487ef162; QUAD $0x7ef162014f6f487e; QUAD $0x487ef16202576f48; QUAD $0x6f487ef162035f6f; QUAD $0x6f6f487ef1620467; QUAD $0x06776f487ef16205; LONG $0x487ef162; WORD $0x7f6f; BYTE $0x07
+       MOVQ  table+16(FP), DX
+       WORD  $0x3148; BYTE $0xc9
+       TESTQ $(1<<0), R14
+       JE    skipInput0
+       MOVQ  0*24(AX), R9
+       LONG  $0x487cc162; WORD $0x0410; BYTE $0x09
+
+skipInput0:
+       TESTQ $(1<<1), R14
+       JE    skipInput1
+       MOVQ  1*24(AX), R9
+       LONG  $0x487cc162; WORD $0x0c10; BYTE $0x09
+
+skipInput1:
+       TESTQ $(1<<2), R14
+       JE    skipInput2
+       MOVQ  2*24(AX), R9
+       LONG  $0x487cc162; WORD $0x1410; BYTE $0x09
+
+skipInput2:
+       TESTQ $(1<<3), R14
+       JE    skipInput3
+       MOVQ  3*24(AX), R9
+       LONG  $0x487cc162; WORD $0x1c10; BYTE $0x09
+
+skipInput3:
+       TESTQ $(1<<4), R14
+       JE    skipInput4
+       MOVQ  4*24(AX), R9
+       LONG  $0x487cc162; WORD $0x2410; BYTE $0x09
+
+skipInput4:
+       TESTQ $(1<<5), R14
+       JE    skipInput5
+       MOVQ  5*24(AX), R9
+       LONG  $0x487cc162; WORD $0x2c10; BYTE $0x09
+
+skipInput5:
+       TESTQ $(1<<6), R14
+       JE    skipInput6
+       MOVQ  6*24(AX), R9
+       LONG  $0x487cc162; WORD $0x3410; BYTE $0x09
+
+skipInput6:
+       TESTQ $(1<<7), R14
+       JE    skipInput7
+       MOVQ  7*24(AX), R9
+       LONG  $0x487cc162; WORD $0x3c10; BYTE $0x09
+
+skipInput7:
+       TESTQ $(1<<8), R14
+       JE    skipInput8
+       MOVQ  8*24(AX), R9
+       LONG  $0x487c4162; WORD $0x0410; BYTE $0x09
+
+skipInput8:
+       TESTQ $(1<<9), R14
+       JE    skipInput9
+       MOVQ  9*24(AX), R9
+       LONG  $0x487c4162; WORD $0x0c10; BYTE $0x09
+
+skipInput9:
+       TESTQ $(1<<10), R14
+       JE    skipInput10
+       MOVQ  10*24(AX), R9
+       LONG  $0x487c4162; WORD $0x1410; BYTE $0x09
+
+skipInput10:
+       TESTQ $(1<<11), R14
+       JE    skipInput11
+       MOVQ  11*24(AX), R9
+       LONG  $0x487c4162; WORD $0x1c10; BYTE $0x09
+
+skipInput11:
+       TESTQ $(1<<12), R14
+       JE    skipInput12
+       MOVQ  12*24(AX), R9
+       LONG  $0x487c4162; WORD $0x2410; BYTE $0x09
+
+skipInput12:
+       TESTQ $(1<<13), R14
+       JE    skipInput13
+       MOVQ  13*24(AX), R9
+       LONG  $0x487c4162; WORD $0x2c10; BYTE $0x09
+
+skipInput13:
+       TESTQ $(1<<14), R14
+       JE    skipInput14
+       MOVQ  14*24(AX), R9
+       LONG  $0x487c4162; WORD $0x3410; BYTE $0x09
+
+skipInput14:
+       TESTQ $(1<<15), R14
+       JE    skipInput15
+       MOVQ  15*24(AX), R9
+       LONG  $0x487c4162; WORD $0x3c10; BYTE $0x09
+
+skipInput15:
+lloop:
+       LEAQ                 PSHUFFLE_BYTE_FLIP_MASK<>(SB), DX
+       LONG                 $0x487e7162; WORD $0x1a6f
+       MOVQ                 table+16(FP), DX
+       QUAD                 $0xd162226f487e7162; QUAD $0x7ed16224047f487e; QUAD $0x7ed16201244c7f48; QUAD $0x7ed1620224547f48; QUAD $0x7ed16203245c7f48; QUAD $0x7ed1620424647f48; QUAD $0x7ed16205246c7f48; QUAD $0x7ed1620624747f48; QUAD $0xc1834807247c7f48; QUAD $0x44c9c6407c316240; QUAD $0x62eec1c6407ca162; QUAD $0xa16244d3c6406c31; QUAD $0x34c162eed3c6406c; QUAD $0x407ca162dddac648; QUAD $0xc6407ca16288cac6; QUAD $0xcac648345162ddc2; QUAD $0x44d5c6405ca16288; QUAD $0x62eee5c6405ca162; QUAD $0xa16244d7c6404c31; QUAD $0x6cc162eef7c6404c; QUAD $0x405ca162ddfac640; QUAD $0xc6405ca16288eec6; QUAD $0xd2c6406cc162dde6; QUAD $0x44f1c6403c816288; QUAD $0x62eec1c6403c0162; QUAD $0x016244d3c6402c11; QUAD $0x4c4162eed3c6402c; QUAD $0x403c0162dddac640; QUAD $0xc6403c016288cac6; QUAD $0xf2c6404cc162ddc2; QUAD $0x44d5c6401c016288; QUAD $0x62eee5c6401c0162; QUAD $0x016244d7c6400c11; QUAD $0x2c4162eef7c6400c; QUAD $0x401c0162ddfac640; QUAD $0xc6401c016288eec6; QUAD $0xd2c6402c4162dde6; BYTE $0x88
+       LEAQ                 PSHUFFLE_TRANSPOSE16_MASK1<>(SB), BX
+       LEAQ                 PSHUFFLE_TRANSPOSE16_MASK2<>(SB), R8
+       QUAD                 $0x2262336f487e6162; QUAD $0x487e5162f27648b5; QUAD $0xd27648b53262106f; QUAD $0xa262136f487ee162; QUAD $0x487e5162d77640e5; QUAD $0xcf7640e53262086f; QUAD $0xa2621b6f487ee162; QUAD $0x487ec162dd7640f5; QUAD $0xfd7640f5a262386f; QUAD $0xa2620b6f487ee162; QUAD $0x487ec162cc7640fd; QUAD $0xec7640fda262286f; QUAD $0x8262036f487ee162; QUAD $0x487ec162c27640cd; QUAD $0xe27640cd8262206f; QUAD $0x8262336f487ee162; QUAD $0x487e4162f77640a5; QUAD $0xd77640a50262106f; QUAD $0x02621b6f487e6162; QUAD $0x487e4162dd7640b5; QUAD $0xfd7640b50262386f; QUAD $0x02620b6f487e6162; QUAD $0x487e4162cc7640bd; QUAD $0xec7640bd0262286f; QUAD $0x62eec023408d2362; QUAD $0x236244c023408da3; QUAD $0xada362eee42348ad; QUAD $0x40c5036244e42348; QUAD $0x2340c51362eef723; QUAD $0xfd2340d5036244d7; QUAD $0x44fd2340d58362ee; QUAD $0x62eeea2348b50362; QUAD $0x036244ea2348b583; QUAD $0xe51362eed32340e5; QUAD $0x40f5036244cb2340; QUAD $0x2340f58362eed923; QUAD $0xce2340ed236244d9; QUAD $0x44ce2340eda362ee; QUAD $0xc162d16f487ec162; QUAD $0x407dc262f26f487e; QUAD $0xcb004075c262c300; QUAD $0xc262d300406dc262; QUAD $0x405dc262db004065; QUAD $0xeb004055c262e300; QUAD $0xc262f300404dc262; QUAD $0x403d4262fb004045; QUAD $0xcb0040354262c300; QUAD $0x4262d300402d4262; QUAD $0x401d4262db004025; QUAD $0xeb0040154262e300; QUAD $0x4262f300400d4262; QUAD $0x48455162fb004005; QUAD $0xcc6f487e7162c4fe; QUAD $0x6206c472482df162; QUAD $0xf1620bc4724825f1; QUAD $0x55736219c472481d; QUAD $0x483d3162cace2548; QUAD $0xd42548255362c0fe; QUAD $0x62c1fe483d516296; QUAD $0x65d162c2fe483d51; QUAD $0x724845f162d8fe48; QUAD $0xc0724825f16202c0; QUAD $0x16c072481df1620d; QUAD $0x7362c86f487e7162; QUAD $0x25d362e8ca254875; QUAD $0x4845d16296fc2548; QUAD $0xf8fe4845d162f9fe; QUAD $0x6201626f487e7162; QUAD $0x916211c672481591; QUAD $0x05916213c672480d; QUAD $0x480d53620ad67248; QUAD $0xfe407dc16296ef25; QUAD $0x62c1fe407d8162c5; QUAD $0xb16207c1724815b1; QUAD $0x05b16212c172480d; QUAD $0x480d536203d17248; QUAD $0xfe407dc16296ef25; QUAD $0x62c4fe484d5162c5; QUAD $0x2df162cb6f487e71; QUAD $0x4825f16206c37248; QUAD $0x72481df1620bc372; QUAD $0xcd25485d736219c3; QUAD $0x62c1fe483d3162ca; QUAD $0x516296d425482553; QUAD $0x483d5162c1fe483d; QUAD $0xd0fe486dd162c2fe; QUAD $0x6202c772484df162; QUAD $0xf1620dc7724825f1; QUAD $0x7e716216c772481d; QUAD $0x25487d7362cf6f48; QUAD $0xf4254825d362e8c9; QUAD $0x62f1fe484dd16296; QUAD $0x7e7162f0fe484dd1; QUAD $0x4815916202626f48; QUAD $0x72480d916211c772; QUAD $0xd7724805916213c7; QUAD $0x96ef25480d53620a; QUAD $0x8162cdfe4075c162; QUAD $0x4815b162cafe4075; QUAD $0x72480db16207c272; QUAD $0xd2724805b16212c2; QUAD $0x96ef25480d536203; QUAD $0x5162cdfe4075c162; QUAD $0x487e7162c4fe4855; QUAD $0xc272482df162ca6f; QUAD $0x0bc2724825f16206; QUAD $0x6219c272481df162; QUAD $0x3162cacc25486573; QUAD $0x48255362c2fe483d; QUAD $0xfe483d516296d425; QUAD $0x62c2fe483d5162c1; QUAD $0x55f162c8fe4875d1; QUAD $0x4825f16202c67248; QUAD $0x72481df1620dc672; QUAD $0xce6f487e716216c6; QUAD $0x62e8c82548457362; QUAD $0xd16296ec254825d3; QUAD $0x4855d162e9fe4855; QUAD $0x626f487e7162e8fe; QUAD $0x11c0724815b16203; QUAD $0x6213c072480db162; QUAD $0x53620ad0724805b1; QUAD $0x6dc16296ef25480d; QUAD $0xfe406d8162d5fe40; QUAD $0x07c3724815b162d3; QUAD $0x6212c372480db162; QUAD $0x536203d3724805b1; QUAD $0x6dc16296ef25480d; QUAD $0xfe485d5162d5fe40; QUAD $0x62c96f487e7162c4; QUAD $0xf16206c172482df1; QUAD $0x1df1620bc1724825; QUAD $0x486d736219c17248; QUAD $0xfe483d3162cacb25; QUAD $0x96d42548255362c3; QUAD $0x5162c1fe483d5162; QUAD $0x487dd162c2fe483d; QUAD $0xc572485df162c0fe; QUAD $0x0dc5724825f16202; QUAD $0x6216c572481df162; QUAD $0x4d7362cd6f487e71; QUAD $0x4825d362e8cf2548; QUAD $0xfe485dd16296e425; QUAD $0x62e0fe485dd162e1; QUAD $0xb16204626f487e71; QUAD $0x0db16211c1724815; QUAD $0x4805b16213c17248; QUAD $0x25480d53620ad172; QUAD $0xddfe4065c16296ef; QUAD $0xb162dcfe40658162; QUAD $0x0db16207c4724815; QUAD $0x4805b16212c47248; QUAD $0x25480d536203d472; QUAD $0xddfe4065c16296ef; QUAD $0x7162c4fe48655162; QUAD $0x482df162c86f487e; QUAD $0x724825f16206c072; QUAD $0xc072481df1620bc0; QUAD $0xcaca254875736219; QUAD $0x5362c4fe483d3162; QUAD $0x3d516296d4254825; QUAD $0xfe483d5162c1fe48; QUAD $0x62f8fe4845d162c2; QUAD $0xf16202c4724865f1; QUAD $0x1df1620dc4724825; QUAD $0x487e716216c47248; QUAD $0xce2548557362cc6f; QUAD $0x96dc254825d362e8; QUAD $0xd162d9fe4865d162; QUAD $0x487e7162d8fe4865; QUAD $0x724815b16205626f; QUAD $0xc272480db16211c2; QUAD $0x0ad2724805b16213; QUAD $0x6296ef25480d5362; QUAD $0x5d8162e5fe405dc1; QUAD $0x724815b162e5fe40; QUAD $0xc572480db16207c5; QUAD $0x03d5724805b16212; QUAD $0x6296ef25480d5362; QUAD $0x6d5162e5fe405dc1; QUAD $0x6f487e7162c4fe48; QUAD $0x06c772482df162cf; QUAD $0x620bc7724825f162; QUAD $0x736219c772481df1; QUAD $0x3d3162cac925487d; QUAD $0x2548255362c5fe48; QUAD $0xc1fe483d516296d4; QUAD $0xd162c2fe483d5162; QUAD $0x486df162f0fe484d; QUAD $0x724825f16202c372; QUAD $0xc372481df1620dc3; QUAD $0x62cb6f487e716216; QUAD $0xd362e8cd25485d73; QUAD $0x6dd16296d4254825; QUAD $0xfe486dd162d1fe48; QUAD $0x06626f487e7162d0; QUAD $0x6211c3724815b162; QUAD $0xb16213c372480db1; QUAD $0x0d53620ad3724805; QUAD $0x4055c16296ef2548; QUAD $0xeefe40558162edfe; QUAD $0x6207c6724815b162; QUAD $0xb16212c672480db1; QUAD $0x0d536203d6724805; QUAD $0x4055c16296ef2548; QUAD $0xc4fe48755162edfe; QUAD $0xf162ce6f487e7162; QUAD $0x25f16206c672482d; QUAD $0x481df1620bc67248; QUAD $0x254845736219c672; QUAD $0xc6fe483d3162cac8; QUAD $0x6296d42548255362; QUAD $0x3d5162c1fe483d51; QUAD $0xfe4855d162c2fe48; QUAD $0x02c2724875f162e8; QUAD $0x620dc2724825f162; QUAD $0x716216c272481df1; QUAD $0x48657362ca6f487e; QUAD $0x254825d362e8cc25; QUAD $0xc9fe4875d16296cc; QUAD $0x7162c8fe4875d162; QUAD $0x15b16207626f487e; QUAD $0x480db16211c47248; QUAD $0x724805b16213c472; QUAD $0xef25480d53620ad4; QUAD $0x62f5fe404dc16296; QUAD $0x15b162f7fe404d81; QUAD $0x480db16207c77248; QUAD $0x724805b16212c772; QUAD $0xef25480d536203d7; QUAD $0x62f5fe404dc16296; QUAD $0x7e7162c4fe487d51; QUAD $0x72482df162cd6f48; QUAD $0xc5724825f16206c5; QUAD $0x19c572481df1620b; QUAD $0x62cacf25484d7362; QUAD $0x255362c7fe483d31; QUAD $0x483d516296d42548; QUAD $0xc2fe483d5162c1fe; QUAD $0xf162e0fe485dd162; QUAD $0x25f16202c172487d; QUAD $0x481df1620dc17248; QUAD $0x6f487e716216c172; QUAD $0xe8cb25486d7362c9; QUAD $0x6296c4254825d362; QUAD $0x7dd162c1fe487dd1; QUAD $0x6f487e7162c0fe48; QUAD $0xc5724815b1620862; QUAD $0x13c572480db16211; QUAD $0x620ad5724805b162; QUAD $0xc16296ef25480d53; QUAD $0x4045a162fdfe4045; QUAD $0xc07248159162f8fe; QUAD $0x12c072480d916207; QUAD $0x6203d07248059162; QUAD $0xc16296ef25480d53; QUAD $0x48455162fdfe4045; QUAD $0xcc6f487e7162c4fe; QUAD $0x6206c472482df162; QUAD $0xf1620bc4724825f1; QUAD $0x55736219c472481d; QUAD $0x483d1162cace2548; QUAD $0xd42548255362c0fe; QUAD $0x62c1fe483d516296; QUAD $0x65d162c2fe483d51; QUAD $0x724845f162d8fe48; QUAD $0xc0724825f16202c0; QUAD $0x16c072481df1620d; QUAD $0x7362c86f487e7162; QUAD $0x25d362e8ca254875; QUAD $0x4845d16296fc2548; QUAD $0xf8fe4845d162f9fe; QUAD $0x6209626f487e7162; QUAD $0xb16211c6724815b1; QUAD $0x05b16213c672480d; QUAD $0x480d53620ad67248; QUAD $0xfe403d416296ef25; QUAD $0x62c1fe403d2162c5; QUAD $0x916207c172481591; QUAD $0x05916212c172480d; QUAD $0x480d536203d17248; QUAD $0xfe403d416296ef25; QUAD $0x62c4fe484d5162c5; QUAD $0x2df162cb6f487e71; QUAD $0x4825f16206c37248; QUAD $0x72481df1620bc372; QUAD $0xcd25485d736219c3; QUAD $0x62c1fe483d1162ca; QUAD $0x516296d425482553; QUAD $0x483d5162c1fe483d; QUAD $0xd0fe486dd162c2fe; QUAD $0x6202c772484df162; QUAD $0xf1620dc7724825f1; QUAD $0x7e716216c772481d; QUAD $0x25487d7362cf6f48; QUAD $0xf4254825d362e8c9; QUAD $0x62f1fe484dd16296; QUAD $0x7e7162f0fe484dd1; QUAD $0x4815b1620a626f48; QUAD $0x72480db16211c772; QUAD $0xd7724805b16213c7; QUAD $0x96ef25480d53620a; QUAD $0x2162cdfe40354162; QUAD $0x48159162cafe4035; QUAD $0x72480d916207c272; QUAD $0xd2724805916212c2; QUAD $0x96ef25480d536203; QUAD $0x5162cdfe40354162; QUAD $0x487e7162c4fe4855; QUAD $0xc272482df162ca6f; QUAD $0x0bc2724825f16206; QUAD $0x6219c272481df162; QUAD $0x1162cacc25486573; QUAD $0x48255362c2fe483d; QUAD $0xfe483d516296d425; QUAD $0x62c2fe483d5162c1; QUAD $0x55f162c8fe4875d1; QUAD $0x4825f16202c67248; QUAD $0x72481df1620dc672; QUAD $0xce6f487e716216c6; QUAD $0x62e8c82548457362; QUAD $0xd16296ec254825d3; QUAD $0x4855d162e9fe4855; QUAD $0x626f487e7162e8fe; QUAD $0x11c072481591620b; QUAD $0x6213c072480d9162; QUAD $0x53620ad072480591; QUAD $0x2d416296ef25480d; QUAD $0xfe402d2162d5fe40; QUAD $0x07c37248159162d3; QUAD $0x6212c372480d9162; QUAD $0x536203d372480591; QUAD $0x2d416296ef25480d; QUAD $0xfe485d5162d5fe40; QUAD $0x62c96f487e7162c4; QUAD $0xf16206c172482df1; QUAD $0x1df1620bc1724825; QUAD $0x486d736219c17248; QUAD $0xfe483d1162cacb25; QUAD $0x96d42548255362c3; QUAD $0x5162c1fe483d5162; QUAD $0x487dd162c2fe483d; QUAD $0xc572485df162c0fe; QUAD $0x0dc5724825f16202; QUAD $0x6216c572481df162; QUAD $0x4d7362cd6f487e71; QUAD $0x4825d362e8cf2548; QUAD $0xfe485dd16296e425; QUAD $0x62e0fe485dd162e1; QUAD $0x91620c626f487e71; QUAD $0x0d916211c1724815; QUAD $0x4805916213c17248; QUAD $0x25480d53620ad172; QUAD $0xddfe4025416296ef; QUAD $0x9162dcfe40252162; QUAD $0x0d916207c4724815; QUAD $0x4805916212c47248; QUAD $0x25480d536203d472; QUAD $0xddfe4025416296ef; QUAD $0x7162c4fe48655162; QUAD $0x482df162c86f487e; QUAD $0x724825f16206c072; QUAD $0xc072481df1620bc0; QUAD $0xcaca254875736219; QUAD $0x5362c4fe483d1162; QUAD $0x3d516296d4254825; QUAD $0xfe483d5162c1fe48; QUAD $0x62f8fe4845d162c2; QUAD $0xf16202c4724865f1; QUAD $0x1df1620dc4724825; QUAD $0x487e716216c47248; QUAD $0xce2548557362cc6f; QUAD $0x96dc254825d362e8; QUAD $0xd162d9fe4865d162; QUAD $0x487e7162d8fe4865; QUAD $0x72481591620d626f; QUAD $0xc272480d916211c2; QUAD $0x0ad2724805916213; QUAD $0x6296ef25480d5362; QUAD $0x1d2162e5fe401d41; QUAD $0x7248159162e5fe40; QUAD $0xc572480d916207c5; QUAD $0x03d5724805916212; QUAD $0x6296ef25480d5362; QUAD $0x6d5162e5fe401d41; QUAD $0x6f487e7162c4fe48; QUAD $0x06c772482df162cf; QUAD $0x620bc7724825f162; QUAD $0x736219c772481df1; QUAD $0x3d1162cac925487d; QUAD $0x2548255362c5fe48; QUAD $0xc1fe483d516296d4; QUAD $0xd162c2fe483d5162; QUAD $0x486df162f0fe484d; QUAD $0x724825f16202c372; QUAD $0xc372481df1620dc3; QUAD $0x62cb6f487e716216; QUAD $0xd362e8cd25485d73; QUAD $0x6dd16296d4254825; QUAD $0xfe486dd162d1fe48; QUAD $0x0e626f487e7162d0; QUAD $0x6211c37248159162; QUAD $0x916213c372480d91; QUAD $0x0d53620ad3724805; QUAD $0x4015416296ef2548; QUAD $0xeefe40152162edfe; QUAD $0x6207c67248159162; QUAD $0x916212c672480d91; QUAD $0x0d536203d6724805; QUAD $0x4015416296ef2548; QUAD $0xc4fe48755162edfe; QUAD $0xf162ce6f487e7162; QUAD $0x25f16206c672482d; QUAD $0x481df1620bc67248; QUAD $0x254845736219c672; QUAD $0xc6fe483d1162cac8; QUAD $0x6296d42548255362; QUAD $0x3d5162c1fe483d51; QUAD $0xfe4855d162c2fe48; QUAD $0x02c2724875f162e8; QUAD $0x620dc2724825f162; QUAD $0x716216c272481df1; QUAD $0x48657362ca6f487e; QUAD $0x254825d362e8cc25; QUAD $0xc9fe4875d16296cc; QUAD $0x7162c8fe4875d162; QUAD $0x1591620f626f487e; QUAD $0x480d916211c47248; QUAD $0x724805916213c472; QUAD $0xef25480d53620ad4; QUAD $0x62f5fe400d416296; QUAD $0x159162f7fe400d21; QUAD $0x480d916207c77248; QUAD $0x724805916212c772; QUAD $0xef25480d536203d7; QUAD $0x62f5fe400d416296; QUAD $0x7e7162c4fe487d51; QUAD $0x72482df162cd6f48; QUAD $0xc5724825f16206c5; QUAD $0x19c572481df1620b; QUAD $0x62cacf25484d7362; QUAD $0x255362c7fe483d11; QUAD $0x483d516296d42548; QUAD $0xc2fe483d5162c1fe; QUAD $0xf162e0fe485dd162; QUAD $0x25f16202c172487d; QUAD $0x481df1620dc17248; QUAD $0x6f487e716216c172; QUAD $0xe8cb25486d7362c9; QUAD $0x6296c4254825d362; QUAD $0x7dd162c1fe487dd1; QUAD $0x6f487e7162c0fe48; QUAD $0xc572481591621062; QUAD $0x13c572480d916211; QUAD $0x620ad57248059162; QUAD $0x416296ef25480d53; QUAD $0x40050162fdfe4005; QUAD $0xc0724815b162f8fe; QUAD $0x12c072480db16207; QUAD $0x6203d0724805b162; QUAD $0x416296ef25480d53; QUAD $0x48455162fdfe4005; QUAD $0xcc6f487e7162c4fe; QUAD $0x6206c472482df162; QUAD $0xf1620bc4724825f1; QUAD $0x55736219c472481d; QUAD $0x483d3162cace2548; QUAD $0xd42548255362c0fe; QUAD $0x62c1fe483d516296; QUAD $0x65d162c2fe483d51; QUAD $0x724845f162d8fe48; QUAD $0xc0724825f16202c0; QUAD $0x16c072481df1620d; QUAD $0x7362c86f487e7162; QUAD $0x25d362e8ca254875; QUAD $0x4845d16296fc2548; QUAD $0xf8fe4845d162f9fe; QUAD $0x6211626f487e7162; QUAD $0x916211c672481591; QUAD $0x05916213c672480d; QUAD $0x480d53620ad67248; QUAD $0xfe407dc16296ef25; QUAD $0x62c1fe407d8162c5; QUAD $0xb16207c1724815b1; QUAD $0x05b16212c172480d; QUAD $0x480d536203d17248; QUAD $0xfe407dc16296ef25; QUAD $0x62c4fe484d5162c5; QUAD $0x2df162cb6f487e71; QUAD $0x4825f16206c37248; QUAD $0x72481df1620bc372; QUAD $0xcd25485d736219c3; QUAD $0x62c1fe483d3162ca; QUAD $0x516296d425482553; QUAD $0x483d5162c1fe483d; QUAD $0xd0fe486dd162c2fe; QUAD $0x6202c772484df162; QUAD $0xf1620dc7724825f1; QUAD $0x7e716216c772481d; QUAD $0x25487d7362cf6f48; QUAD $0xf4254825d362e8c9; QUAD $0x62f1fe484dd16296; QUAD $0x7e7162f0fe484dd1; QUAD $0x4815916212626f48; QUAD $0x72480d916211c772; QUAD $0xd7724805916213c7; QUAD $0x96ef25480d53620a; QUAD $0x8162cdfe4075c162; QUAD $0x4815b162cafe4075; QUAD $0x72480db16207c272; QUAD $0xd2724805b16212c2; QUAD $0x96ef25480d536203; QUAD $0x5162cdfe4075c162; QUAD $0x487e7162c4fe4855; QUAD $0xc272482df162ca6f; QUAD $0x0bc2724825f16206; QUAD $0x6219c272481df162; QUAD $0x3162cacc25486573; QUAD $0x48255362c2fe483d; QUAD $0xfe483d516296d425; QUAD $0x62c2fe483d5162c1; QUAD $0x55f162c8fe4875d1; QUAD $0x4825f16202c67248; QUAD $0x72481df1620dc672; QUAD $0xce6f487e716216c6; QUAD $0x62e8c82548457362; QUAD $0xd16296ec254825d3; QUAD $0x4855d162e9fe4855; QUAD $0x626f487e7162e8fe; QUAD $0x11c0724815b16213; QUAD $0x6213c072480db162; QUAD $0x53620ad0724805b1; QUAD $0x6dc16296ef25480d; QUAD $0xfe406d8162d5fe40; QUAD $0x07c3724815b162d3; QUAD $0x6212c372480db162; QUAD $0x536203d3724805b1; QUAD $0x6dc16296ef25480d; QUAD $0xfe485d5162d5fe40; QUAD $0x62c96f487e7162c4; QUAD $0xf16206c172482df1; QUAD $0x1df1620bc1724825; QUAD $0x486d736219c17248; QUAD $0xfe483d3162cacb25; QUAD $0x96d42548255362c3; QUAD $0x5162c1fe483d5162; QUAD $0x487dd162c2fe483d; QUAD $0xc572485df162c0fe; QUAD $0x0dc5724825f16202; QUAD $0x6216c572481df162; QUAD $0x4d7362cd6f487e71; QUAD $0x4825d362e8cf2548; QUAD $0xfe485dd16296e425; QUAD $0x62e0fe485dd162e1; QUAD $0xb16214626f487e71; QUAD $0x0db16211c1724815; QUAD $0x4805b16213c17248; QUAD $0x25480d53620ad172; QUAD $0xddfe4065c16296ef; QUAD $0xb162dcfe40658162; QUAD $0x0db16207c4724815; QUAD $0x4805b16212c47248; QUAD $0x25480d536203d472; QUAD $0xddfe4065c16296ef; QUAD $0x7162c4fe48655162; QUAD $0x482df162c86f487e; QUAD $0x724825f16206c072; QUAD $0xc072481df1620bc0; QUAD $0xcaca254875736219; QUAD $0x5362c4fe483d3162; QUAD $0x3d516296d4254825; QUAD $0xfe483d5162c1fe48; QUAD $0x62f8fe4845d162c2; QUAD $0xf16202c4724865f1; QUAD $0x1df1620dc4724825; QUAD $0x487e716216c47248; QUAD $0xce2548557362cc6f; QUAD $0x96dc254825d362e8; QUAD $0xd162d9fe4865d162; QUAD $0x487e7162d8fe4865; QUAD $0x724815b16215626f; QUAD $0xc272480db16211c2; QUAD $0x0ad2724805b16213; QUAD $0x6296ef25480d5362; QUAD $0x5d8162e5fe405dc1; QUAD $0x724815b162e5fe40; QUAD $0xc572480db16207c5; QUAD $0x03d5724805b16212; QUAD $0x6296ef25480d5362; QUAD $0x6d5162e5fe405dc1; QUAD $0x6f487e7162c4fe48; QUAD $0x06c772482df162cf; QUAD $0x620bc7724825f162; QUAD $0x736219c772481df1; QUAD $0x3d3162cac925487d; QUAD $0x2548255362c5fe48; QUAD $0xc1fe483d516296d4; QUAD $0xd162c2fe483d5162; QUAD $0x486df162f0fe484d; QUAD $0x724825f16202c372; QUAD $0xc372481df1620dc3; QUAD $0x62cb6f487e716216; QUAD $0xd362e8cd25485d73; QUAD $0x6dd16296d4254825; QUAD $0xfe486dd162d1fe48; QUAD $0x16626f487e7162d0; QUAD $0x6211c3724815b162; QUAD $0xb16213c372480db1; QUAD $0x0d53620ad3724805; QUAD $0x4055c16296ef2548; QUAD $0xeefe40558162edfe; QUAD $0x6207c6724815b162; QUAD $0xb16212c672480db1; QUAD $0x0d536203d6724805; QUAD $0x4055c16296ef2548; QUAD $0xc4fe48755162edfe; QUAD $0xf162ce6f487e7162; QUAD $0x25f16206c672482d; QUAD $0x481df1620bc67248; QUAD $0x254845736219c672; QUAD $0xc6fe483d3162cac8; QUAD $0x6296d42548255362; QUAD $0x3d5162c1fe483d51; QUAD $0xfe4855d162c2fe48; QUAD $0x02c2724875f162e8; QUAD $0x620dc2724825f162; QUAD $0x716216c272481df1; QUAD $0x48657362ca6f487e; QUAD $0x254825d362e8cc25; QUAD $0xc9fe4875d16296cc; QUAD $0x7162c8fe4875d162; QUAD $0x15b16217626f487e; QUAD $0x480db16211c47248; QUAD $0x724805b16213c472; QUAD $0xef25480d53620ad4; QUAD $0x62f5fe404dc16296; QUAD $0x15b162f7fe404d81; QUAD $0x480db16207c77248; QUAD $0x724805b16212c772; QUAD $0xef25480d536203d7; QUAD $0x62f5fe404dc16296; QUAD $0x7e7162c4fe487d51; QUAD $0x72482df162cd6f48; QUAD $0xc5724825f16206c5; QUAD $0x19c572481df1620b; QUAD $0x62cacf25484d7362; QUAD $0x255362c7fe483d31; QUAD $0x483d516296d42548; QUAD $0xc2fe483d5162c1fe; QUAD $0xf162e0fe485dd162; QUAD $0x25f16202c172487d; QUAD $0x481df1620dc17248; QUAD $0x6f487e716216c172; QUAD $0xe8cb25486d7362c9; QUAD $0x6296c4254825d362; QUAD $0x7dd162c1fe487dd1; QUAD $0x6f487e7162c0fe48; QUAD $0xc5724815b1621862; QUAD $0x13c572480db16211; QUAD $0x620ad5724805b162; QUAD $0xc16296ef25480d53; QUAD $0x4045a162fdfe4045; QUAD $0xc07248159162f8fe; QUAD $0x12c072480d916207; QUAD $0x6203d07248059162; QUAD $0xc16296ef25480d53; QUAD $0x48455162fdfe4045; QUAD $0xcc6f487e7162c4fe; QUAD $0x6206c472482df162; QUAD $0xf1620bc4724825f1; QUAD $0x55736219c472481d; QUAD $0x483d1162cace2548; QUAD $0xd42548255362c0fe; QUAD $0x62c1fe483d516296; QUAD $0x65d162c2fe483d51; QUAD $0x724845f162d8fe48; QUAD $0xc0724825f16202c0; QUAD $0x16c072481df1620d; QUAD $0x7362c86f487e7162; QUAD $0x25d362e8ca254875; QUAD $0x4845d16296fc2548; QUAD $0xf8fe4845d162f9fe; QUAD $0x6219626f487e7162; QUAD $0xb16211c6724815b1; QUAD $0x05b16213c672480d; QUAD $0x480d53620ad67248; QUAD $0xfe403d416296ef25; QUAD $0x62c1fe403d2162c5; QUAD $0x916207c172481591; QUAD $0x05916212c172480d; QUAD $0x480d536203d17248; QUAD $0xfe403d416296ef25; QUAD $0x62c4fe484d5162c5; QUAD $0x2df162cb6f487e71; QUAD $0x4825f16206c37248; QUAD $0x72481df1620bc372; QUAD $0xcd25485d736219c3; QUAD $0x62c1fe483d1162ca; QUAD $0x516296d425482553; QUAD $0x483d5162c1fe483d; QUAD $0xd0fe486dd162c2fe; QUAD $0x6202c772484df162; QUAD $0xf1620dc7724825f1; QUAD $0x7e716216c772481d; QUAD $0x25487d7362cf6f48; QUAD $0xf4254825d362e8c9; QUAD $0x62f1fe484dd16296; QUAD $0x7e7162f0fe484dd1; QUAD $0x4815b1621a626f48; QUAD $0x72480db16211c772; QUAD $0xd7724805b16213c7; QUAD $0x96ef25480d53620a; QUAD $0x2162cdfe40354162; QUAD $0x48159162cafe4035; QUAD $0x72480d916207c272; QUAD $0xd2724805916212c2; QUAD $0x96ef25480d536203; QUAD $0x5162cdfe40354162; QUAD $0x487e7162c4fe4855; QUAD $0xc272482df162ca6f; QUAD $0x0bc2724825f16206; QUAD $0x6219c272481df162; QUAD $0x1162cacc25486573; QUAD $0x48255362c2fe483d; QUAD $0xfe483d516296d425; QUAD $0x62c2fe483d5162c1; QUAD $0x55f162c8fe4875d1; QUAD $0x4825f16202c67248; QUAD $0x72481df1620dc672; QUAD $0xce6f487e716216c6; QUAD $0x62e8c82548457362; QUAD $0xd16296ec254825d3; QUAD $0x4855d162e9fe4855; QUAD $0x626f487e7162e8fe; QUAD $0x11c072481591621b; QUAD $0x6213c072480d9162; QUAD $0x53620ad072480591; QUAD $0x2d416296ef25480d; QUAD $0xfe402d2162d5fe40; QUAD $0x07c37248159162d3; QUAD $0x6212c372480d9162; QUAD $0x536203d372480591; QUAD $0x2d416296ef25480d; QUAD $0xfe485d5162d5fe40; QUAD $0x62c96f487e7162c4; QUAD $0xf16206c172482df1; QUAD $0x1df1620bc1724825; QUAD $0x486d736219c17248; QUAD $0xfe483d1162cacb25; QUAD $0x96d42548255362c3; QUAD $0x5162c1fe483d5162; QUAD $0x487dd162c2fe483d; QUAD $0xc572485df162c0fe; QUAD $0x0dc5724825f16202; QUAD $0x6216c572481df162; QUAD $0x4d7362cd6f487e71; QUAD $0x4825d362e8cf2548; QUAD $0xfe485dd16296e425; QUAD $0x62e0fe485dd162e1; QUAD $0x91621c626f487e71; QUAD $0x0d916211c1724815; QUAD $0x4805916213c17248; QUAD $0x25480d53620ad172; QUAD $0xddfe4025416296ef; QUAD $0x9162dcfe40252162; QUAD $0x0d916207c4724815; QUAD $0x4805916212c47248; QUAD $0x25480d536203d472; QUAD $0xddfe4025416296ef; QUAD $0x7162c4fe48655162; QUAD $0x482df162c86f487e; QUAD $0x724825f16206c072; QUAD $0xc072481df1620bc0; QUAD $0xcaca254875736219; QUAD $0x5362c4fe483d1162; QUAD $0x3d516296d4254825; QUAD $0xfe483d5162c1fe48; QUAD $0x62f8fe4845d162c2; QUAD $0xf16202c4724865f1; QUAD $0x1df1620dc4724825; QUAD $0x487e716216c47248; QUAD $0xce2548557362cc6f; QUAD $0x96dc254825d362e8; QUAD $0xd162d9fe4865d162; QUAD $0x487e7162d8fe4865; QUAD $0x72481591621d626f; QUAD $0xc272480d916211c2; QUAD $0x0ad2724805916213; QUAD $0x6296ef25480d5362; QUAD $0x1d2162e5fe401d41; QUAD $0x7248159162e5fe40; QUAD $0xc572480d916207c5; QUAD $0x03d5724805916212; QUAD $0x6296ef25480d5362; QUAD $0x6d5162e5fe401d41; QUAD $0x6f487e7162c4fe48; QUAD $0x06c772482df162cf; QUAD $0x620bc7724825f162; QUAD $0x736219c772481df1; QUAD $0x3d1162cac925487d; QUAD $0x2548255362c5fe48; QUAD $0xc1fe483d516296d4; QUAD $0xd162c2fe483d5162; QUAD $0x486df162f0fe484d; QUAD $0x724825f16202c372; QUAD $0xc372481df1620dc3; QUAD $0x62cb6f487e716216; QUAD $0xd362e8cd25485d73; QUAD $0x6dd16296d4254825; QUAD $0xfe486dd162d1fe48; QUAD $0x1e626f487e7162d0; QUAD $0x6211c37248159162; QUAD $0x916213c372480d91; QUAD $0x0d53620ad3724805; QUAD $0x4015416296ef2548; QUAD $0xeefe40152162edfe; QUAD $0x6207c67248159162; QUAD $0x916212c672480d91; QUAD $0x0d536203d6724805; QUAD $0x4015416296ef2548; QUAD $0xc4fe48755162edfe; QUAD $0xf162ce6f487e7162; QUAD $0x25f16206c672482d; QUAD $0x481df1620bc67248; QUAD $0x254845736219c672; QUAD $0xc6fe483d1162cac8; QUAD $0x6296d42548255362; QUAD $0x3d5162c1fe483d51; QUAD $0xfe4855d162c2fe48; QUAD $0x02c2724875f162e8; QUAD $0x620dc2724825f162; QUAD $0x716216c272481df1; QUAD $0x48657362ca6f487e; QUAD $0x254825d362e8cc25; QUAD $0xc9fe4875d16296cc; QUAD $0x7162c8fe4875d162; QUAD $0x1591621f626f487e; QUAD $0x480d916211c47248; QUAD $0x724805916213c472; QUAD $0xef25480d53620ad4; QUAD $0x62f5fe400d416296; QUAD $0x159162f7fe400d21; QUAD $0x480d916207c77248; QUAD $0x724805916212c772; QUAD $0xef25480d536203d7; QUAD $0x62f5fe400d416296; QUAD $0x7e7162c4fe487d51; QUAD $0x72482df162cd6f48; QUAD $0xc5724825f16206c5; QUAD $0x19c572481df1620b; QUAD $0x62cacf25484d7362; QUAD $0x255362c7fe483d11; QUAD $0x483d516296d42548; QUAD $0xc2fe483d5162c1fe; QUAD $0xf162e0fe485dd162; QUAD $0x25f16202c172487d; QUAD $0x481df1620dc17248; QUAD $0x6f487e716216c172; QUAD $0xe8cb25486d7362c9; QUAD $0x6296c4254825d362; QUAD $0x7dd162c1fe487dd1; QUAD $0x6f487e7162c0fe48; QUAD $0xc572481591622062; QUAD $0x13c572480d916211; QUAD $0x620ad57248059162; QUAD $0x416296ef25480d53; QUAD $0x40050162fdfe4005; QUAD $0xc0724815b162f8fe; QUAD $0x12c072480db16207; QUAD $0x6203d0724805b162; QUAD $0x416296ef25480d53; QUAD $0x48455162fdfe4005; QUAD $0xcc6f487e7162c4fe; QUAD $0x6206c472482df162; QUAD $0xf1620bc4724825f1; QUAD $0x55736219c472481d; QUAD $0x483d3162cace2548; QUAD $0xd42548255362c0fe; QUAD $0x62c1fe483d516296; QUAD $0x65d162c2fe483d51; QUAD $0x724845f162d8fe48; QUAD $0xc0724825f16202c0; QUAD $0x16c072481df1620d; QUAD $0x7362c86f487e7162; QUAD $0x25d362e8ca254875; QUAD $0x4845d16296fc2548; QUAD $0xf8fe4845d162f9fe; QUAD $0x6221626f487e7162; QUAD $0x916211c672481591; QUAD $0x05916213c672480d; QUAD $0x480d53620ad67248; QUAD $0xfe407dc16296ef25; QUAD $0x62c1fe407d8162c5; QUAD $0xb16207c1724815b1; QUAD $0x05b16212c172480d; QUAD $0x480d536203d17248; QUAD $0xfe407dc16296ef25; QUAD $0x62c4fe484d5162c5; QUAD $0x2df162cb6f487e71; QUAD $0x4825f16206c37248; QUAD $0x72481df1620bc372; QUAD $0xcd25485d736219c3; QUAD $0x62c1fe483d3162ca; QUAD $0x516296d425482553; QUAD $0x483d5162c1fe483d; QUAD $0xd0fe486dd162c2fe; QUAD $0x6202c772484df162; QUAD $0xf1620dc7724825f1; QUAD $0x7e716216c772481d; QUAD $0x25487d7362cf6f48; QUAD $0xf4254825d362e8c9; QUAD $0x62f1fe484dd16296; QUAD $0x7e7162f0fe484dd1; QUAD $0x4815916222626f48; QUAD $0x72480d916211c772; QUAD $0xd7724805916213c7; QUAD $0x96ef25480d53620a; QUAD $0x8162cdfe4075c162; QUAD $0x4815b162cafe4075; QUAD $0x72480db16207c272; QUAD $0xd2724805b16212c2; QUAD $0x96ef25480d536203; QUAD $0x5162cdfe4075c162; QUAD $0x487e7162c4fe4855; QUAD $0xc272482df162ca6f; QUAD $0x0bc2724825f16206; QUAD $0x6219c272481df162; QUAD $0x3162cacc25486573; QUAD $0x48255362c2fe483d; QUAD $0xfe483d516296d425; QUAD $0x62c2fe483d5162c1; QUAD $0x55f162c8fe4875d1; QUAD $0x4825f16202c67248; QUAD $0x72481df1620dc672; QUAD $0xce6f487e716216c6; QUAD $0x62e8c82548457362; QUAD $0xd16296ec254825d3; QUAD $0x4855d162e9fe4855; QUAD $0x626f487e7162e8fe; QUAD $0x11c0724815b16223; QUAD $0x6213c072480db162; QUAD $0x53620ad0724805b1; QUAD $0x6dc16296ef25480d; QUAD $0xfe406d8162d5fe40; QUAD $0x07c3724815b162d3; QUAD $0x6212c372480db162; QUAD $0x536203d3724805b1; QUAD $0x6dc16296ef25480d; QUAD $0xfe485d5162d5fe40; QUAD $0x62c96f487e7162c4; QUAD $0xf16206c172482df1; QUAD $0x1df1620bc1724825; QUAD $0x486d736219c17248; QUAD $0xfe483d3162cacb25; QUAD $0x96d42548255362c3; QUAD $0x5162c1fe483d5162; QUAD $0x487dd162c2fe483d; QUAD $0xc572485df162c0fe; QUAD $0x0dc5724825f16202; QUAD $0x6216c572481df162; QUAD $0x4d7362cd6f487e71; QUAD $0x4825d362e8cf2548; QUAD $0xfe485dd16296e425; QUAD $0x62e0fe485dd162e1; QUAD $0xb16224626f487e71; QUAD $0x0db16211c1724815; QUAD $0x4805b16213c17248; QUAD $0x25480d53620ad172; QUAD $0xddfe4065c16296ef; QUAD $0xb162dcfe40658162; QUAD $0x0db16207c4724815; QUAD $0x4805b16212c47248; QUAD $0x25480d536203d472; QUAD $0xddfe4065c16296ef; QUAD $0x7162c4fe48655162; QUAD $0x482df162c86f487e; QUAD $0x724825f16206c072; QUAD $0xc072481df1620bc0; QUAD $0xcaca254875736219; QUAD $0x5362c4fe483d3162; QUAD $0x3d516296d4254825; QUAD $0xfe483d5162c1fe48; QUAD $0x62f8fe4845d162c2; QUAD $0xf16202c4724865f1; QUAD $0x1df1620dc4724825; QUAD $0x487e716216c47248; QUAD $0xce2548557362cc6f; QUAD $0x96dc254825d362e8; QUAD $0xd162d9fe4865d162; QUAD $0x487e7162d8fe4865; QUAD $0x724815b16225626f; QUAD $0xc272480db16211c2; QUAD $0x0ad2724805b16213; QUAD $0x6296ef25480d5362; QUAD $0x5d8162e5fe405dc1; QUAD $0x724815b162e5fe40; QUAD $0xc572480db16207c5; QUAD $0x03d5724805b16212; QUAD $0x6296ef25480d5362; QUAD $0x6d5162e5fe405dc1; QUAD $0x6f487e7162c4fe48; QUAD $0x06c772482df162cf; QUAD $0x620bc7724825f162; QUAD $0x736219c772481df1; QUAD $0x3d3162cac925487d; QUAD $0x2548255362c5fe48; QUAD $0xc1fe483d516296d4; QUAD $0xd162c2fe483d5162; QUAD $0x486df162f0fe484d; QUAD $0x724825f16202c372; QUAD $0xc372481df1620dc3; QUAD $0x62cb6f487e716216; QUAD $0xd362e8cd25485d73; QUAD $0x6dd16296d4254825; QUAD $0xfe486dd162d1fe48; QUAD $0x26626f487e7162d0; QUAD $0x6211c3724815b162; QUAD $0xb16213c372480db1; QUAD $0x0d53620ad3724805; QUAD $0x4055c16296ef2548; QUAD $0xeefe40558162edfe; QUAD $0x6207c6724815b162; QUAD $0xb16212c672480db1; QUAD $0x0d536203d6724805; QUAD $0x4055c16296ef2548; QUAD $0xc4fe48755162edfe; QUAD $0xf162ce6f487e7162; QUAD $0x25f16206c672482d; QUAD $0x481df1620bc67248; QUAD $0x254845736219c672; QUAD $0xc6fe483d3162cac8; QUAD $0x6296d42548255362; QUAD $0x3d5162c1fe483d51; QUAD $0xfe4855d162c2fe48; QUAD $0x02c2724875f162e8; QUAD $0x620dc2724825f162; QUAD $0x716216c272481df1; QUAD $0x48657362ca6f487e; QUAD $0x254825d362e8cc25; QUAD $0xc9fe4875d16296cc; QUAD $0x7162c8fe4875d162; QUAD $0x15b16227626f487e; QUAD $0x480db16211c47248; QUAD $0x724805b16213c472; QUAD $0xef25480d53620ad4; QUAD $0x62f5fe404dc16296; QUAD $0x15b162f7fe404d81; QUAD $0x480db16207c77248; QUAD $0x724805b16212c772; QUAD $0xef25480d536203d7; QUAD $0x62f5fe404dc16296; QUAD $0x7e7162c4fe487d51; QUAD $0x72482df162cd6f48; QUAD $0xc5724825f16206c5; QUAD $0x19c572481df1620b; QUAD $0x62cacf25484d7362; QUAD $0x255362c7fe483d31; QUAD $0x483d516296d42548; QUAD $0xc2fe483d5162c1fe; QUAD $0xf162e0fe485dd162; QUAD $0x25f16202c172487d; QUAD $0x481df1620dc17248; QUAD $0x6f487e716216c172; QUAD $0xe8cb25486d7362c9; QUAD $0x6296c4254825d362; QUAD $0x7dd162c1fe487dd1; QUAD $0x6f487e7162c0fe48; QUAD $0xc5724815b1622862; QUAD $0x13c572480db16211; QUAD $0x620ad5724805b162; QUAD $0xc16296ef25480d53; QUAD $0x4045a162fdfe4045; QUAD $0xc07248159162f8fe; QUAD $0x12c072480d916207; QUAD $0x6203d07248059162; QUAD $0xc16296ef25480d53; QUAD $0x48455162fdfe4045; QUAD $0xcc6f487e7162c4fe; QUAD $0x6206c472482df162; QUAD $0xf1620bc4724825f1; QUAD $0x55736219c472481d; QUAD $0x483d1162cace2548; QUAD $0xd42548255362c0fe; QUAD $0x62c1fe483d516296; QUAD $0x65d162c2fe483d51; QUAD $0x724845f162d8fe48; QUAD $0xc0724825f16202c0; QUAD $0x16c072481df1620d; QUAD $0x7362c86f487e7162; QUAD $0x25d362e8ca254875; QUAD $0x4845d16296fc2548; QUAD $0xf8fe4845d162f9fe; QUAD $0x6229626f487e7162; QUAD $0xb16211c6724815b1; QUAD $0x05b16213c672480d; QUAD $0x480d53620ad67248; QUAD $0xfe403d416296ef25; QUAD $0x62c1fe403d2162c5; QUAD $0x916207c172481591; QUAD $0x05916212c172480d; QUAD $0x480d536203d17248; QUAD $0xfe403d416296ef25; QUAD $0x62c4fe484d5162c5; QUAD $0x2df162cb6f487e71; QUAD $0x4825f16206c37248; QUAD $0x72481df1620bc372; QUAD $0xcd25485d736219c3; QUAD $0x62c1fe483d1162ca; QUAD $0x516296d425482553; QUAD $0x483d5162c1fe483d; QUAD $0xd0fe486dd162c2fe; QUAD $0x6202c772484df162; QUAD $0xf1620dc7724825f1; QUAD $0x7e716216c772481d; QUAD $0x25487d7362cf6f48; QUAD $0xf4254825d362e8c9; QUAD $0x62f1fe484dd16296; QUAD $0x7e7162f0fe484dd1; QUAD $0x4815b1622a626f48; QUAD $0x72480db16211c772; QUAD $0xd7724805b16213c7; QUAD $0x96ef25480d53620a; QUAD $0x2162cdfe40354162; QUAD $0x48159162cafe4035; QUAD $0x72480d916207c272; QUAD $0xd2724805916212c2; QUAD $0x96ef25480d536203; QUAD $0x5162cdfe40354162; QUAD $0x487e7162c4fe4855; QUAD $0xc272482df162ca6f; QUAD $0x0bc2724825f16206; QUAD $0x6219c272481df162; QUAD $0x1162cacc25486573; QUAD $0x48255362c2fe483d; QUAD $0xfe483d516296d425; QUAD $0x62c2fe483d5162c1; QUAD $0x55f162c8fe4875d1; QUAD $0x4825f16202c67248; QUAD $0x72481df1620dc672; QUAD $0xce6f487e716216c6; QUAD $0x62e8c82548457362; QUAD $0xd16296ec254825d3; QUAD $0x4855d162e9fe4855; QUAD $0x626f487e7162e8fe; QUAD $0x11c072481591622b; QUAD $0x6213c072480d9162; QUAD $0x53620ad072480591; QUAD $0x2d416296ef25480d; QUAD $0xfe402d2162d5fe40; QUAD $0x07c37248159162d3; QUAD $0x6212c372480d9162; QUAD $0x536203d372480591; QUAD $0x2d416296ef25480d; QUAD $0xfe485d5162d5fe40; QUAD $0x62c96f487e7162c4; QUAD $0xf16206c172482df1; QUAD $0x1df1620bc1724825; QUAD $0x486d736219c17248; QUAD $0xfe483d1162cacb25; QUAD $0x96d42548255362c3; QUAD $0x5162c1fe483d5162; QUAD $0x487dd162c2fe483d; QUAD $0xc572485df162c0fe; QUAD $0x0dc5724825f16202; QUAD $0x6216c572481df162; QUAD $0x4d7362cd6f487e71; QUAD $0x4825d362e8cf2548; QUAD $0xfe485dd16296e425; QUAD $0x62e0fe485dd162e1; QUAD $0x91622c626f487e71; QUAD $0x0d916211c1724815; QUAD $0x4805916213c17248; QUAD $0x25480d53620ad172; QUAD $0xddfe4025416296ef; QUAD $0x9162dcfe40252162; QUAD $0x0d916207c4724815; QUAD $0x4805916212c47248; QUAD $0x25480d536203d472; QUAD $0xddfe4025416296ef; QUAD $0x7162c4fe48655162; QUAD $0x482df162c86f487e; QUAD $0x724825f16206c072; QUAD $0xc072481df1620bc0; QUAD $0xcaca254875736219; QUAD $0x5362c4fe483d1162; QUAD $0x3d516296d4254825; QUAD $0xfe483d5162c1fe48; QUAD $0x62f8fe4845d162c2; QUAD $0xf16202c4724865f1; QUAD $0x1df1620dc4724825; QUAD $0x487e716216c47248; QUAD $0xce2548557362cc6f; QUAD $0x96dc254825d362e8; QUAD $0xd162d9fe4865d162; QUAD $0x487e7162d8fe4865; QUAD $0x72481591622d626f; QUAD $0xc272480d916211c2; QUAD $0x0ad2724805916213; QUAD $0x6296ef25480d5362; QUAD $0x1d2162e5fe401d41; QUAD $0x7248159162e5fe40; QUAD $0xc572480d916207c5; QUAD $0x03d5724805916212; QUAD $0x6296ef25480d5362; QUAD $0x6d5162e5fe401d41; QUAD $0x6f487e7162c4fe48; QUAD $0x06c772482df162cf; QUAD $0x620bc7724825f162; QUAD $0x736219c772481df1; QUAD $0x3d1162cac925487d; QUAD $0x2548255362c5fe48; QUAD $0xc1fe483d516296d4; QUAD $0xd162c2fe483d5162; QUAD $0x486df162f0fe484d; QUAD $0x724825f16202c372; QUAD $0xc372481df1620dc3; QUAD $0x62cb6f487e716216; QUAD $0xd362e8cd25485d73; QUAD $0x6dd16296d4254825; QUAD $0xfe486dd162d1fe48; QUAD $0x2e626f487e7162d0; QUAD $0x6211c37248159162; QUAD $0x916213c372480d91; QUAD $0x0d53620ad3724805; QUAD $0x4015416296ef2548; QUAD $0xeefe40152162edfe; QUAD $0x6207c67248159162; QUAD $0x916212c672480d91; QUAD $0x0d536203d6724805; QUAD $0x4015416296ef2548; QUAD $0xc4fe48755162edfe; QUAD $0xf162ce6f487e7162; QUAD $0x25f16206c672482d; QUAD $0x481df1620bc67248; QUAD $0x254845736219c672; QUAD $0xc6fe483d1162cac8; QUAD $0x6296d42548255362; QUAD $0x3d5162c1fe483d51; QUAD $0xfe4855d162c2fe48; QUAD $0x02c2724875f162e8; QUAD $0x620dc2724825f162; QUAD $0x716216c272481df1; QUAD $0x48657362ca6f487e; QUAD $0x254825d362e8cc25; QUAD $0xc9fe4875d16296cc; QUAD $0x7162c8fe4875d162; QUAD $0x1591622f626f487e; QUAD $0x480d916211c47248; QUAD $0x724805916213c472; QUAD $0xef25480d53620ad4; QUAD $0x62f5fe400d416296; QUAD $0x159162f7fe400d21; QUAD $0x480d916207c77248; QUAD $0x724805916212c772; QUAD $0xef25480d536203d7; QUAD $0x62f5fe400d416296; QUAD $0x7e7162c4fe487d51; QUAD $0x72482df162cd6f48; QUAD $0xc5724825f16206c5; QUAD $0x19c572481df1620b; QUAD $0x62cacf25484d7362; QUAD $0x255362c7fe483d11; QUAD $0x483d516296d42548; QUAD $0xc2fe483d5162c1fe; QUAD $0xf162e0fe485dd162; QUAD $0x25f16202c172487d; QUAD $0x481df1620dc17248; QUAD $0x6f487e716216c172; QUAD $0xe8cb25486d7362c9; QUAD $0x6296c4254825d362; QUAD $0x7dd162c1fe487dd1; QUAD $0x6f487e7162c0fe48; QUAD $0xc572481591623062; QUAD $0x13c572480d916211; QUAD $0x620ad57248059162; QUAD $0x416296ef25480d53; QUAD $0x40050162fdfe4005; QUAD $0xc0724815b162f8fe; QUAD $0x12c072480db16207; QUAD $0x6203d0724805b162; QUAD $0x416296ef25480d53; QUAD $0x01ee8348fdfe4005
+       JE                   lastLoop
+       ADDQ                 $8, R13
+       MOVQ                 (R13), R14
+       QUAD                 $0x7162c4fe48455162; QUAD $0x482df162cc6f487e; QUAD $0x724825f16206c472; QUAD $0xc472481df1620bc4; QUAD $0xcace254855736219; QUAD $0x5362c0fe483d3162; QUAD $0x3d516296d4254825; QUAD $0xfe483d5162c1fe48; QUAD $0x62d8fe4865d162c2; QUAD $0xf16202c0724845f1; QUAD $0x1df1620dc0724825; QUAD $0x487e716216c07248; QUAD $0xca2548757362c86f; QUAD $0x96fc254825d362e8; QUAD $0xd162f9fe4845d162; QUAD $0x487e7162f8fe4845; WORD $0x626f; BYTE $0x31
+       TESTQ                $(1<<0), R14
+       JE                   skipNext0
+       MOVQ                 0*24(AX), R9
+       LONG                 $0x487cc162; WORD $0x0410; BYTE $0x09
+
+skipNext0:
+       QUAD  $0x7162c4fe484d5162; QUAD $0x482df162cb6f487e; QUAD $0x724825f16206c372; QUAD $0xc372481df1620bc3; QUAD $0xcacd25485d736219; QUAD $0x5362c1fe483d3162; QUAD $0x3d516296d4254825; QUAD $0xfe483d5162c1fe48; QUAD $0x62d0fe486dd162c2; QUAD $0xf16202c772484df1; QUAD $0x1df1620dc7724825; QUAD $0x487e716216c77248; QUAD $0xc925487d7362cf6f; QUAD $0x96f4254825d362e8; QUAD $0xd162f1fe484dd162; QUAD $0x487e7162f0fe484d; WORD $0x626f; BYTE $0x32
+       TESTQ $(1<<1), R14
+       JE    skipNext1
+       MOVQ  1*24(AX), R9
+       LONG  $0x487cc162; WORD $0x0c10; BYTE $0x09
+
+skipNext1:
+       QUAD  $0x7162c4fe48555162; QUAD $0x482df162ca6f487e; QUAD $0x724825f16206c272; QUAD $0xc272481df1620bc2; QUAD $0xcacc254865736219; QUAD $0x5362c2fe483d3162; QUAD $0x3d516296d4254825; QUAD $0xfe483d5162c1fe48; QUAD $0x62c8fe4875d162c2; QUAD $0xf16202c6724855f1; QUAD $0x1df1620dc6724825; QUAD $0x487e716216c67248; QUAD $0xc82548457362ce6f; QUAD $0x96ec254825d362e8; QUAD $0xd162e9fe4855d162; QUAD $0x487e7162e8fe4855; WORD $0x626f; BYTE $0x33
+       TESTQ $(1<<2), R14
+       JE    skipNext2
+       MOVQ  2*24(AX), R9
+       LONG  $0x487cc162; WORD $0x1410; BYTE $0x09
+
+skipNext2:
+       QUAD  $0x7162c4fe485d5162; QUAD $0x482df162c96f487e; QUAD $0x724825f16206c172; QUAD $0xc172481df1620bc1; QUAD $0xcacb25486d736219; QUAD $0x5362c3fe483d3162; QUAD $0x3d516296d4254825; QUAD $0xfe483d5162c1fe48; QUAD $0x62c0fe487dd162c2; QUAD $0xf16202c572485df1; QUAD $0x1df1620dc5724825; QUAD $0x487e716216c57248; QUAD $0xcf25484d7362cd6f; QUAD $0x96e4254825d362e8; QUAD $0xd162e1fe485dd162; QUAD $0x487e7162e0fe485d; WORD $0x626f; BYTE $0x34
+       TESTQ $(1<<3), R14
+       JE    skipNext3
+       MOVQ  3*24(AX), R9
+       LONG  $0x487cc162; WORD $0x1c10; BYTE $0x09
+
+skipNext3:
+       QUAD  $0x7162c4fe48655162; QUAD $0x482df162c86f487e; QUAD $0x724825f16206c072; QUAD $0xc072481df1620bc0; QUAD $0xcaca254875736219; QUAD $0x5362c4fe483d3162; QUAD $0x3d516296d4254825; QUAD $0xfe483d5162c1fe48; QUAD $0x62f8fe4845d162c2; QUAD $0xf16202c4724865f1; QUAD $0x1df1620dc4724825; QUAD $0x487e716216c47248; QUAD $0xce2548557362cc6f; QUAD $0x96dc254825d362e8; QUAD $0xd162d9fe4865d162; QUAD $0x487e7162d8fe4865; WORD $0x626f; BYTE $0x35
+       TESTQ $(1<<4), R14
+       JE    skipNext4
+       MOVQ  4*24(AX), R9
+       LONG  $0x487cc162; WORD $0x2410; BYTE $0x09
+
+skipNext4:
+       QUAD  $0x7162c4fe486d5162; QUAD $0x482df162cf6f487e; QUAD $0x724825f16206c772; QUAD $0xc772481df1620bc7; QUAD $0xcac925487d736219; QUAD $0x5362c5fe483d3162; QUAD $0x3d516296d4254825; QUAD $0xfe483d5162c1fe48; QUAD $0x62f0fe484dd162c2; QUAD $0xf16202c372486df1; QUAD $0x1df1620dc3724825; QUAD $0x487e716216c37248; QUAD $0xcd25485d7362cb6f; QUAD $0x96d4254825d362e8; QUAD $0xd162d1fe486dd162; QUAD $0x487e7162d0fe486d; WORD $0x626f; BYTE $0x36
+       TESTQ $(1<<5), R14
+       JE    skipNext5
+       MOVQ  5*24(AX), R9
+       LONG  $0x487cc162; WORD $0x2c10; BYTE $0x09
+
+skipNext5:
+       QUAD  $0x7162c4fe48755162; QUAD $0x482df162ce6f487e; QUAD $0x724825f16206c672; QUAD $0xc672481df1620bc6; QUAD $0xcac8254845736219; QUAD $0x5362c6fe483d3162; QUAD $0x3d516296d4254825; QUAD $0xfe483d5162c1fe48; QUAD $0x62e8fe4855d162c2; QUAD $0xf16202c2724875f1; QUAD $0x1df1620dc2724825; QUAD $0x487e716216c27248; QUAD $0xcc2548657362ca6f; QUAD $0x96cc254825d362e8; QUAD $0xd162c9fe4875d162; QUAD $0x487e7162c8fe4875; WORD $0x626f; BYTE $0x37
+       TESTQ $(1<<6), R14
+       JE    skipNext6
+       MOVQ  6*24(AX), R9
+       LONG  $0x487cc162; WORD $0x3410; BYTE $0x09
+
+skipNext6:
+       QUAD  $0x7162c4fe487d5162; QUAD $0x482df162cd6f487e; QUAD $0x724825f16206c572; QUAD $0xc572481df1620bc5; QUAD $0xcacf25484d736219; QUAD $0x5362c7fe483d3162; QUAD $0x3d516296d4254825; QUAD $0xfe483d5162c1fe48; QUAD $0x62e0fe485dd162c2; QUAD $0xf16202c172487df1; QUAD $0x1df1620dc1724825; QUAD $0x487e716216c17248; QUAD $0xcb25486d7362c96f; QUAD $0x96c4254825d362e8; QUAD $0xd162c1fe487dd162; QUAD $0x487e7162c0fe487d; WORD $0x626f; BYTE $0x38
+       TESTQ $(1<<7), R14
+       JE    skipNext7
+       MOVQ  7*24(AX), R9
+       LONG  $0x487cc162; WORD $0x3c10; BYTE $0x09
+
+skipNext7:
+       QUAD  $0x7162c4fe48455162; QUAD $0x482df162cc6f487e; QUAD $0x724825f16206c472; QUAD $0xc472481df1620bc4; QUAD $0xcace254855736219; QUAD $0x5362c0fe483d1162; QUAD $0x3d516296d4254825; QUAD $0xfe483d5162c1fe48; QUAD $0x62d8fe4865d162c2; QUAD $0xf16202c0724845f1; QUAD $0x1df1620dc0724825; QUAD $0x487e716216c07248; QUAD $0xca2548757362c86f; QUAD $0x96fc254825d362e8; QUAD $0xd162f9fe4845d162; QUAD $0x487e7162f8fe4845; WORD $0x626f; BYTE $0x39
+       TESTQ $(1<<8), R14
+       JE    skipNext8
+       MOVQ  8*24(AX), R9
+       LONG  $0x487c4162; WORD $0x0410; BYTE $0x09
+
+skipNext8:
+       QUAD  $0x7162c4fe484d5162; QUAD $0x482df162cb6f487e; QUAD $0x724825f16206c372; QUAD $0xc372481df1620bc3; QUAD $0xcacd25485d736219; QUAD $0x5362c1fe483d1162; QUAD $0x3d516296d4254825; QUAD $0xfe483d5162c1fe48; QUAD $0x62d0fe486dd162c2; QUAD $0xf16202c772484df1; QUAD $0x1df1620dc7724825; QUAD $0x487e716216c77248; QUAD $0xc925487d7362cf6f; QUAD $0x96f4254825d362e8; QUAD $0xd162f1fe484dd162; QUAD $0x487e7162f0fe484d; WORD $0x626f; BYTE $0x3a
+       TESTQ $(1<<9), R14
+       JE    skipNext9
+       MOVQ  9*24(AX), R9
+       LONG  $0x487c4162; WORD $0x0c10; BYTE $0x09
+
+skipNext9:
+       QUAD  $0x7162c4fe48555162; QUAD $0x482df162ca6f487e; QUAD $0x724825f16206c272; QUAD $0xc272481df1620bc2; QUAD $0xcacc254865736219; QUAD $0x5362c2fe483d1162; QUAD $0x3d516296d4254825; QUAD $0xfe483d5162c1fe48; QUAD $0x62c8fe4875d162c2; QUAD $0xf16202c6724855f1; QUAD $0x1df1620dc6724825; QUAD $0x487e716216c67248; QUAD $0xc82548457362ce6f; QUAD $0x96ec254825d362e8; QUAD $0xd162e9fe4855d162; QUAD $0x487e7162e8fe4855; WORD $0x626f; BYTE $0x3b
+       TESTQ $(1<<10), R14
+       JE    skipNext10
+       MOVQ  10*24(AX), R9
+       LONG  $0x487c4162; WORD $0x1410; BYTE $0x09
+
+skipNext10:
+       QUAD  $0x7162c4fe485d5162; QUAD $0x482df162c96f487e; QUAD $0x724825f16206c172; QUAD $0xc172481df1620bc1; QUAD $0xcacb25486d736219; QUAD $0x5362c3fe483d1162; QUAD $0x3d516296d4254825; QUAD $0xfe483d5162c1fe48; QUAD $0x62c0fe487dd162c2; QUAD $0xf16202c572485df1; QUAD $0x1df1620dc5724825; QUAD $0x487e716216c57248; QUAD $0xcf25484d7362cd6f; QUAD $0x96e4254825d362e8; QUAD $0xd162e1fe485dd162; QUAD $0x487e7162e0fe485d; WORD $0x626f; BYTE $0x3c
+       TESTQ $(1<<11), R14
+       JE    skipNext11
+       MOVQ  11*24(AX), R9
+       LONG  $0x487c4162; WORD $0x1c10; BYTE $0x09
+
+skipNext11:
+       QUAD  $0x7162c4fe48655162; QUAD $0x482df162c86f487e; QUAD $0x724825f16206c072; QUAD $0xc072481df1620bc0; QUAD $0xcaca254875736219; QUAD $0x5362c4fe483d1162; QUAD $0x3d516296d4254825; QUAD $0xfe483d5162c1fe48; QUAD $0x62f8fe4845d162c2; QUAD $0xf16202c4724865f1; QUAD $0x1df1620dc4724825; QUAD $0x487e716216c47248; QUAD $0xce2548557362cc6f; QUAD $0x96dc254825d362e8; QUAD $0xd162d9fe4865d162; QUAD $0x487e7162d8fe4865; WORD $0x626f; BYTE $0x3d
+       TESTQ $(1<<12), R14
+       JE    skipNext12
+       MOVQ  12*24(AX), R9
+       LONG  $0x487c4162; WORD $0x2410; BYTE $0x09
+
+skipNext12:
+       QUAD  $0x7162c4fe486d5162; QUAD $0x482df162cf6f487e; QUAD $0x724825f16206c772; QUAD $0xc772481df1620bc7; QUAD $0xcac925487d736219; QUAD $0x5362c5fe483d1162; QUAD $0x3d516296d4254825; QUAD $0xfe483d5162c1fe48; QUAD $0x62f0fe484dd162c2; QUAD $0xf16202c372486df1; QUAD $0x1df1620dc3724825; QUAD $0x487e716216c37248; QUAD $0xcd25485d7362cb6f; QUAD $0x96d4254825d362e8; QUAD $0xd162d1fe486dd162; QUAD $0x487e7162d0fe486d; WORD $0x626f; BYTE $0x3e
+       TESTQ $(1<<13), R14
+       JE    skipNext13
+       MOVQ  13*24(AX), R9
+       LONG  $0x487c4162; WORD $0x2c10; BYTE $0x09
+
+skipNext13:
+       QUAD  $0x7162c4fe48755162; QUAD $0x482df162ce6f487e; QUAD $0x724825f16206c672; QUAD $0xc672481df1620bc6; QUAD $0xcac8254845736219; QUAD $0x5362c6fe483d1162; QUAD $0x3d516296d4254825; QUAD $0xfe483d5162c1fe48; QUAD $0x62e8fe4855d162c2; QUAD $0xf16202c2724875f1; QUAD $0x1df1620dc2724825; QUAD $0x487e716216c27248; QUAD $0xcc2548657362ca6f; QUAD $0x96cc254825d362e8; QUAD $0xd162c9fe4875d162; QUAD $0x487e7162c8fe4875; WORD $0x626f; BYTE $0x3f
+       TESTQ $(1<<14), R14
+       JE    skipNext14
+       MOVQ  14*24(AX), R9
+       LONG  $0x487c4162; WORD $0x3410; BYTE $0x09
+
+skipNext14:
+       QUAD  $0x7162c4fe487d5162; QUAD $0x482df162cd6f487e; QUAD $0x724825f16206c572; QUAD $0xc572481df1620bc5; QUAD $0xcacf25484d736219; QUAD $0x5362c7fe483d1162; QUAD $0x3d516296d4254825; QUAD $0xfe483d5162c1fe48; QUAD $0x62e0fe485dd162c2; QUAD $0xf16202c172487df1; QUAD $0x1df1620dc1724825; QUAD $0x487e716216c17248; QUAD $0xcb25486d7362c96f; QUAD $0x96c4254825d362e8; QUAD $0xd162c1fe487dd162; QUAD $0x487e7162c0fe487d; WORD $0x626f; BYTE $0x40
+       TESTQ $(1<<15), R14
+       JE    skipNext15
+       MOVQ  15*24(AX), R9
+       LONG  $0x487c4162; WORD $0x3c10; BYTE $0x09
+
+skipNext15:
+       QUAD $0xd162d86f487e7162; QUAD $0x7dd16224046f487e; QUAD $0x6f487e7162c3fe49; QUAD $0x244c6f487ed162d9; QUAD $0x62cbfe4975d16201; QUAD $0x7ed162da6f487e71; QUAD $0x6dd1620224546f48; QUAD $0x6f487e7162d3fe49; QUAD $0x245c6f487ed162db; QUAD $0x62dbfe4965d16203; QUAD $0x7ed162dc6f487e71; QUAD $0x5dd1620424646f48; QUAD $0x6f487e7162e3fe49; QUAD $0x246c6f487ed162dd; QUAD $0x62ebfe4955d16205; QUAD $0x7ed162de6f487e71; QUAD $0x4dd1620624746f48; QUAD $0x6f487e7162f3fe49; QUAD $0x247c6f487ed162df; QUAD $0xc4fbfe4945d16207; LONG $0xce92fbc1
+       JMP  lloop
+
+lastLoop:
+       QUAD         $0x7162c4fe48455162; QUAD $0x482df162cc6f487e; QUAD $0x724825f16206c472; QUAD $0xc472481df1620bc4; QUAD $0xcace254855736219; QUAD $0x5362c0fe483d3162; QUAD $0x3d516296d4254825; QUAD $0xfe483d5162c1fe48; QUAD $0x62d8fe4865d162c2; QUAD $0xf16202c0724845f1; QUAD $0x1df1620dc0724825; QUAD $0x487e716216c07248; QUAD $0xca2548757362c86f; QUAD $0x96fc254825d362e8; QUAD $0xd162f9fe4845d162; QUAD $0x487e7162f8fe4845; QUAD $0xfe484d516231626f; QUAD $0x62cb6f487e7162c4; QUAD $0xf16206c372482df1; QUAD $0x1df1620bc3724825; QUAD $0x485d736219c37248; QUAD $0xfe483d3162cacd25; QUAD $0x96d42548255362c1; QUAD $0x5162c1fe483d5162; QUAD $0x486dd162c2fe483d; QUAD $0xc772484df162d0fe; QUAD $0x0dc7724825f16202; QUAD $0x6216c772481df162; QUAD $0x7d7362cf6f487e71; QUAD $0x4825d362e8c92548; QUAD $0xfe484dd16296f425; QUAD $0x62f0fe484dd162f1; QUAD $0x516232626f487e71; QUAD $0x487e7162c4fe4855; QUAD $0xc272482df162ca6f; QUAD $0x0bc2724825f16206; QUAD $0x6219c272481df162; QUAD $0x3162cacc25486573; QUAD $0x48255362c2fe483d; QUAD $0xfe483d516296d425; QUAD $0x62c2fe483d5162c1; QUAD $0x55f162c8fe4875d1; QUAD $0x4825f16202c67248; QUAD $0x72481df1620dc672; QUAD $0xce6f487e716216c6; QUAD $0x62e8c82548457362; QUAD $0xd16296ec254825d3; QUAD $0x4855d162e9fe4855; QUAD $0x626f487e7162e8fe; QUAD $0x62c4fe485d516233; QUAD $0x2df162c96f487e71; QUAD $0x4825f16206c17248; QUAD $0x72481df1620bc172; QUAD $0xcb25486d736219c1; QUAD $0x62c3fe483d3162ca; QUAD $0x516296d425482553; QUAD $0x483d5162c1fe483d; QUAD $0xc0fe487dd162c2fe; QUAD $0x6202c572485df162; QUAD $0xf1620dc5724825f1; QUAD $0x7e716216c572481d; QUAD $0x25484d7362cd6f48; QUAD $0xe4254825d362e8cf; QUAD $0x62e1fe485dd16296; QUAD $0x7e7162e0fe485dd1; QUAD $0x4865516234626f48; QUAD $0xc86f487e7162c4fe; QUAD $0x6206c072482df162; QUAD $0xf1620bc0724825f1; QUAD $0x75736219c072481d; QUAD $0x483d3162caca2548; QUAD $0xd42548255362c4fe; QUAD $0x62c1fe483d516296; QUAD $0x45d162c2fe483d51; QUAD $0x724865f162f8fe48; QUAD $0xc4724825f16202c4; QUAD $0x16c472481df1620d; QUAD $0x7362cc6f487e7162; QUAD $0x25d362e8ce254855; QUAD $0x4865d16296dc2548; QUAD $0xd8fe4865d162d9fe; QUAD $0x6235626f487e7162; QUAD $0x7e7162c4fe486d51; QUAD $0x72482df162cf6f48; QUAD $0xc7724825f16206c7; QUAD $0x19c772481df1620b; QUAD $0x62cac925487d7362; QUAD $0x255362c5fe483d31; QUAD $0x483d516296d42548; QUAD $0xc2fe483d5162c1fe; QUAD $0xf162f0fe484dd162; QUAD $0x25f16202c372486d; QUAD $0x481df1620dc37248; QUAD $0x6f487e716216c372; QUAD $0xe8cd25485d7362cb; QUAD $0x6296d4254825d362; QUAD $0x6dd162d1fe486dd1; QUAD $0x6f487e7162d0fe48; QUAD $0xc4fe487551623662; QUAD $0xf162ce6f487e7162; QUAD $0x25f16206c672482d; QUAD $0x481df1620bc67248; QUAD $0x254845736219c672; QUAD $0xc6fe483d3162cac8; QUAD $0x6296d42548255362; QUAD $0x3d5162c1fe483d51; QUAD $0xfe4855d162c2fe48; QUAD $0x02c2724875f162e8; QUAD $0x620dc2724825f162; QUAD $0x716216c272481df1; QUAD $0x48657362ca6f487e; QUAD $0x254825d362e8cc25; QUAD $0xc9fe4875d16296cc; QUAD $0x7162c8fe4875d162; QUAD $0x7d516237626f487e; QUAD $0x6f487e7162c4fe48; QUAD $0x06c572482df162cd; QUAD $0x620bc5724825f162; QUAD $0x736219c572481df1; QUAD $0x3d3162cacf25484d; QUAD $0x2548255362c7fe48; QUAD $0xc1fe483d516296d4; QUAD $0xd162c2fe483d5162; QUAD $0x487df162e0fe485d; QUAD $0x724825f16202c172; QUAD $0xc172481df1620dc1; QUAD $0x62c96f487e716216; QUAD $0xd362e8cb25486d73; QUAD $0x7dd16296c4254825; QUAD $0xfe487dd162c1fe48; QUAD $0x38626f487e7162c0; QUAD $0x7162c4fe48455162; QUAD $0x482df162cc6f487e; QUAD $0x724825f16206c472; QUAD $0xc472481df1620bc4; QUAD $0xcace254855736219; QUAD $0x5362c0fe483d1162; QUAD $0x3d516296d4254825; QUAD $0xfe483d5162c1fe48; QUAD $0x62d8fe4865d162c2; QUAD $0xf16202c0724845f1; QUAD $0x1df1620dc0724825; QUAD $0x487e716216c07248; QUAD $0xca2548757362c86f; QUAD $0x96fc254825d362e8; QUAD $0xd162f9fe4845d162; QUAD $0x487e7162f8fe4845; QUAD $0xfe484d516239626f; QUAD $0x62cb6f487e7162c4; QUAD $0xf16206c372482df1; QUAD $0x1df1620bc3724825; QUAD $0x485d736219c37248; QUAD $0xfe483d1162cacd25; QUAD $0x96d42548255362c1; QUAD $0x5162c1fe483d5162; QUAD $0x486dd162c2fe483d; QUAD $0xc772484df162d0fe; QUAD $0x0dc7724825f16202; QUAD $0x6216c772481df162; QUAD $0x7d7362cf6f487e71; QUAD $0x4825d362e8c92548; QUAD $0xfe484dd16296f425; QUAD $0x62f0fe484dd162f1; QUAD $0x51623a626f487e71; QUAD $0x487e7162c4fe4855; QUAD $0xc272482df162ca6f; QUAD $0x0bc2724825f16206; QUAD $0x6219c272481df162; QUAD $0x1162cacc25486573; QUAD $0x48255362c2fe483d; QUAD $0xfe483d516296d425; QUAD $0x62c2fe483d5162c1; QUAD $0x55f162c8fe4875d1; QUAD $0x4825f16202c67248; QUAD $0x72481df1620dc672; QUAD $0xce6f487e716216c6; QUAD $0x62e8c82548457362; QUAD $0xd16296ec254825d3; QUAD $0x4855d162e9fe4855; QUAD $0x626f487e7162e8fe; QUAD $0x62c4fe485d51623b; QUAD $0x2df162c96f487e71; QUAD $0x4825f16206c17248; QUAD $0x72481df1620bc172; QUAD $0xcb25486d736219c1; QUAD $0x62c3fe483d1162ca; QUAD $0x516296d425482553; QUAD $0x483d5162c1fe483d; QUAD $0xc0fe487dd162c2fe; QUAD $0x6202c572485df162; QUAD $0xf1620dc5724825f1; QUAD $0x7e716216c572481d; QUAD $0x25484d7362cd6f48; QUAD $0xe4254825d362e8cf; QUAD $0x62e1fe485dd16296; QUAD $0x7e7162e0fe485dd1; QUAD $0x486551623c626f48; QUAD $0xc86f487e7162c4fe; QUAD $0x6206c072482df162; QUAD $0xf1620bc0724825f1; QUAD $0x75736219c072481d; QUAD $0x483d1162caca2548; QUAD $0xd42548255362c4fe; QUAD $0x62c1fe483d516296; QUAD $0x45d162c2fe483d51; QUAD $0x724865f162f8fe48; QUAD $0xc4724825f16202c4; QUAD $0x16c472481df1620d; QUAD $0x7362cc6f487e7162; QUAD $0x25d362e8ce254855; QUAD $0x4865d16296dc2548; QUAD $0xd8fe4865d162d9fe; QUAD $0x623d626f487e7162; QUAD $0x7e7162c4fe486d51; QUAD $0x72482df162cf6f48; QUAD $0xc7724825f16206c7; QUAD $0x19c772481df1620b; QUAD $0x62cac925487d7362; QUAD $0x255362c5fe483d11; QUAD $0x483d516296d42548; QUAD $0xc2fe483d5162c1fe; QUAD $0xf162f0fe484dd162; QUAD $0x25f16202c372486d; QUAD $0x481df1620dc37248; QUAD $0x6f487e716216c372; QUAD $0xe8cd25485d7362cb; QUAD $0x6296d4254825d362; QUAD $0x6dd162d1fe486dd1; QUAD $0x6f487e7162d0fe48; QUAD $0xc4fe487551623e62; QUAD $0xf162ce6f487e7162; QUAD $0x25f16206c672482d; QUAD $0x481df1620bc67248; QUAD $0x254845736219c672; QUAD $0xc6fe483d1162cac8; QUAD $0x6296d42548255362; QUAD $0x3d5162c1fe483d51; QUAD $0xfe4855d162c2fe48; QUAD $0x02c2724875f162e8; QUAD $0x620dc2724825f162; QUAD $0x716216c272481df1; QUAD $0x48657362ca6f487e; QUAD $0x254825d362e8cc25; QUAD $0xc9fe4875d16296cc; QUAD $0x7162c8fe4875d162; QUAD $0x7d51623f626f487e; QUAD $0x6f487e7162c4fe48; QUAD $0x06c572482df162cd; QUAD $0x620bc5724825f162; QUAD $0x736219c572481df1; QUAD $0x3d1162cacf25484d; QUAD $0x2548255362c7fe48; QUAD $0xc1fe483d516296d4; QUAD $0xd162c2fe483d5162; QUAD $0x487df162e0fe485d; QUAD $0x724825f16202c172; QUAD $0xc172481df1620dc1; QUAD $0x62c96f487e716216; QUAD $0xd362e8cb25486d73; QUAD $0x7dd16296c4254825; QUAD $0xfe487dd162c1fe48; QUAD $0x40626f487e7162c0; QUAD $0xd162d86f487e7162; QUAD $0x7dd16224046f487e; QUAD $0x6f487e7162c3fe49; QUAD $0x244c6f487ed162d9; QUAD $0x62cbfe4975d16201; QUAD $0x7ed162da6f487e71; QUAD $0x6dd1620224546f48; QUAD $0x6f487e7162d3fe49; QUAD $0x245c6f487ed162db; QUAD $0x62dbfe4965d16203; QUAD $0x7ed162dc6f487e71; QUAD $0x5dd1620424646f48; QUAD $0x6f487e7162e3fe49; QUAD $0x246c6f487ed162dd; QUAD $0x62ebfe4955d16205; QUAD $0x7ed162de6f487e71; QUAD $0x4dd1620624746f48; QUAD $0x6f487e7162f3fe49; QUAD $0x247c6f487ed162df; QUAD $0x62fbfe4945d16207; QUAD $0x7ef162077f487ef1; QUAD $0x487ef162014f7f48; QUAD $0x7f487ef16202577f; QUAD $0x677f487ef162035f; QUAD $0x056f7f487ef16204; QUAD $0x6206777f487ef162; LONG $0x7f487ef1; WORD $0x077f
+       VZEROUPPER
+       RET
+
+DATA PSHUFFLE_BYTE_FLIP_MASK<>+0x000(SB)/8, $0x0405060700010203
+DATA PSHUFFLE_BYTE_FLIP_MASK<>+0x008(SB)/8, $0x0c0d0e0f08090a0b
+DATA PSHUFFLE_BYTE_FLIP_MASK<>+0x010(SB)/8, $0x0405060700010203
+DATA PSHUFFLE_BYTE_FLIP_MASK<>+0x018(SB)/8, $0x0c0d0e0f08090a0b
+DATA PSHUFFLE_BYTE_FLIP_MASK<>+0x020(SB)/8, $0x0405060700010203
+DATA PSHUFFLE_BYTE_FLIP_MASK<>+0x028(SB)/8, $0x0c0d0e0f08090a0b
+DATA PSHUFFLE_BYTE_FLIP_MASK<>+0x030(SB)/8, $0x0405060700010203
+DATA PSHUFFLE_BYTE_FLIP_MASK<>+0x038(SB)/8, $0x0c0d0e0f08090a0b
+GLOBL PSHUFFLE_BYTE_FLIP_MASK<>(SB), 8, $64
+DATA PSHUFFLE_TRANSPOSE16_MASK1<>+0x000(SB)/8, $0x0000000000000000
+DATA PSHUFFLE_TRANSPOSE16_MASK1<>+0x008(SB)/8, $0x0000000000000001
+DATA PSHUFFLE_TRANSPOSE16_MASK1<>+0x010(SB)/8, $0x0000000000000008
+DATA PSHUFFLE_TRANSPOSE16_MASK1<>+0x018(SB)/8, $0x0000000000000009
+DATA PSHUFFLE_TRANSPOSE16_MASK1<>+0x020(SB)/8, $0x0000000000000004
+DATA PSHUFFLE_TRANSPOSE16_MASK1<>+0x028(SB)/8, $0x0000000000000005
+DATA PSHUFFLE_TRANSPOSE16_MASK1<>+0x030(SB)/8, $0x000000000000000C
+DATA PSHUFFLE_TRANSPOSE16_MASK1<>+0x038(SB)/8, $0x000000000000000D
+GLOBL PSHUFFLE_TRANSPOSE16_MASK1<>(SB), 8, $64
+DATA PSHUFFLE_TRANSPOSE16_MASK2<>+0x000(SB)/8, $0x0000000000000002
+DATA PSHUFFLE_TRANSPOSE16_MASK2<>+0x008(SB)/8, $0x0000000000000003
+DATA PSHUFFLE_TRANSPOSE16_MASK2<>+0x010(SB)/8, $0x000000000000000A
+DATA PSHUFFLE_TRANSPOSE16_MASK2<>+0x018(SB)/8, $0x000000000000000B
+DATA PSHUFFLE_TRANSPOSE16_MASK2<>+0x020(SB)/8, $0x0000000000000006
+DATA PSHUFFLE_TRANSPOSE16_MASK2<>+0x028(SB)/8, $0x0000000000000007
+DATA PSHUFFLE_TRANSPOSE16_MASK2<>+0x030(SB)/8, $0x000000000000000E
+DATA PSHUFFLE_TRANSPOSE16_MASK2<>+0x038(SB)/8, $0x000000000000000F
+GLOBL PSHUFFLE_TRANSPOSE16_MASK2<>(SB), 8, $64

diff --git a/vendor/github.com/minio/sha256-simd/sha256blockAvx512_amd64_test.go b/vendor/github.com/minio/sha256-simd/sha256blockAvx512_amd64_test.go
new file mode 100644 (file)
index 0000000..87bc81f
--- /dev/null
+++ b/vendor/github.com/minio/sha256-simd/sha256blockAvx512_amd64_test.go
@@ -0,0 +1,409 @@
+/*
+ * Minio Cloud Storage, (C) 2017 Minio, Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package sha256
+
+import (
+       "bytes"
+       "encoding/binary"
+       "encoding/hex"
+       "fmt"
+       "hash"
+       "reflect"
+       "sync"
+       "testing"
+)
+
+func TestGoldenAVX512(t *testing.T) {
+
+       if !avx512 {
+               t.SkipNow()
+               return
+       }
+
+       server := NewAvx512Server()
+       h512 := NewAvx512(server)
+
+       for _, g := range golden {
+               h512.Reset()
+               h512.Write([]byte(g.in))
+               digest := h512.Sum([]byte{})
+               s := fmt.Sprintf("%x", digest)
+               if !reflect.DeepEqual(digest, g.out[:]) {
+                       t.Fatalf("Sum256 function: sha256(%s) = %s want %s", g.in, s, hex.EncodeToString(g.out[:]))
+               }
+       }
+}
+
+func createInputs(size int) [16][]byte {
+       input := [16][]byte{}
+       for i := 0; i < 16; i++ {
+               input[i] = make([]byte, size)
+       }
+       return input
+}
+
+func initDigests() *[512]byte {
+       digests := [512]byte{}
+       for i := 0; i < 16; i++ {
+               binary.LittleEndian.PutUint32(digests[(i+0*16)*4:], init0)
+               binary.LittleEndian.PutUint32(digests[(i+1*16)*4:], init1)
+               binary.LittleEndian.PutUint32(digests[(i+2*16)*4:], init2)
+               binary.LittleEndian.PutUint32(digests[(i+3*16)*4:], init3)
+               binary.LittleEndian.PutUint32(digests[(i+4*16)*4:], init4)
+               binary.LittleEndian.PutUint32(digests[(i+5*16)*4:], init5)
+               binary.LittleEndian.PutUint32(digests[(i+6*16)*4:], init6)
+               binary.LittleEndian.PutUint32(digests[(i+7*16)*4:], init7)
+       }
+       return &digests
+}
+
+func testSha256Avx512(t *testing.T, offset, padding int) [16][]byte {
+
+       if !avx512 {
+               t.SkipNow()
+               return [16][]byte{}
+       }
+
+       l := uint(len(golden[offset].in))
+       extraBlock := uint(0)
+       if padding == 0 {
+               extraBlock += 9
+       } else {
+               extraBlock += 64
+       }
+       input := createInputs(int(l + extraBlock))
+       for i := 0; i < 16; i++ {
+               copy(input[i], golden[offset+i].in)
+               input[i][l] = 0x80
+               copy(input[i][l+1:], bytes.Repeat([]byte{0}, padding))
+
+               // Length in bits.
+               len := uint64(l)
+               len <<= 3
+               for ii := uint(0); ii < 8; ii++ {
+                       input[i][l+1+uint(padding)+ii] = byte(len >> (56 - 8*ii))
+               }
+       }
+       mask := make([]uint64, len(input[0])>>6)
+       for m := range mask {
+               mask[m] = 0xffff
+       }
+       output := blockAvx512(initDigests(), input, mask)
+       for i := 0; i < 16; i++ {
+               if bytes.Compare(output[i][:], golden[offset+i].out[:]) != 0 {
+                       t.Fatalf("Sum256 function: sha256(%s) = %s want %s", golden[offset+i].in, hex.EncodeToString(output[i][:]), hex.EncodeToString(golden[offset+i].out[:]))
+               }
+       }
+       return input
+}
+
+func TestAvx512_1Block(t *testing.T)  { testSha256Avx512(t, 31, 0) }
+func TestAvx512_3Blocks(t *testing.T) { testSha256Avx512(t, 47, 55) }
+
+func TestAvx512_MixedBlocks(t *testing.T) {
+
+       if !avx512 {
+               t.SkipNow()
+               return
+       }
+
+       inputSingleBlock := testSha256Avx512(t, 31, 0)
+       inputMultiBlock := testSha256Avx512(t, 47, 55)
+
+       input := [16][]byte{}
+
+       for i := range input {
+               if i%2 == 0 {
+                       input[i] = inputMultiBlock[i]
+               } else {
+                       input[i] = inputSingleBlock[i]
+               }
+       }
+
+       mask := [3]uint64{0xffff, 0x5555, 0x5555}
+       output := blockAvx512(initDigests(), input, mask[:])
+       var offset int
+       for i := 0; i < len(output); i++ {
+               if i%2 == 0 {
+                       offset = 47
+               } else {
+                       offset = 31
+               }
+               if bytes.Compare(output[i][:], golden[offset+i].out[:]) != 0 {
+                       t.Fatalf("Sum256 function: sha256(%s) = %s want %s", golden[offset+i].in, hex.EncodeToString(output[i][:]), hex.EncodeToString(golden[offset+i].out[:]))
+               }
+       }
+}
+
+func TestAvx512_MixedWithNilBlocks(t *testing.T) {
+
+       if !avx512 {
+               t.SkipNow()
+               return
+       }
+
+       inputSingleBlock := testSha256Avx512(t, 31, 0)
+       inputMultiBlock := testSha256Avx512(t, 47, 55)
+
+       input := [16][]byte{}
+
+       for i := range input {
+               if i%3 == 0 {
+                       input[i] = inputMultiBlock[i]
+               } else if i%3 == 1 {
+                       input[i] = inputSingleBlock[i]
+               } else {
+                       input[i] = nil
+               }
+       }
+
+       mask := [3]uint64{0xb6db, 0x9249, 0x9249}
+       output := blockAvx512(initDigests(), input, mask[:])
+       var offset int
+       for i := 0; i < len(output); i++ {
+               if i%3 == 2 { // for nil inputs
+                       initvec := [32]byte{0x6a, 0x09, 0xe6, 0x67, 0xbb, 0x67, 0xae, 0x85,
+                               0x3c, 0x6e, 0xf3, 0x72, 0xa5, 0x4f, 0xf5, 0x3a,
+                               0x51, 0x0e, 0x52, 0x7f, 0x9b, 0x05, 0x68, 0x8c,
+                               0x1f, 0x83, 0xd9, 0xab, 0x5b, 0xe0, 0xcd, 0x19}
+                       if bytes.Compare(output[i][:], initvec[:]) != 0 {
+                               t.Fatalf("Sum256 function: sha256 for nil vector = %s want %s", hex.EncodeToString(output[i][:]), hex.EncodeToString(initvec[:]))
+                       }
+                       continue
+               }
+               if i%3 == 0 {
+                       offset = 47
+               } else {
+                       offset = 31
+               }
+               if bytes.Compare(output[i][:], golden[offset+i].out[:]) != 0 {
+                       t.Fatalf("Sum256 function: sha256(%s) = %s want %s", golden[offset+i].in, hex.EncodeToString(output[i][:]), hex.EncodeToString(golden[offset+i].out[:]))
+               }
+       }
+}
+
+func TestAvx512Server(t *testing.T) {
+
+       if !avx512 {
+               t.SkipNow()
+               return
+       }
+
+       const offset = 31 + 16
+       server := NewAvx512Server()
+
+       // First block of 64 bytes
+       for i := 0; i < 16; i++ {
+               input := make([]byte, 64)
+               copy(input, golden[offset+i].in)
+               server.Write(uint64(Avx512ServerUID+i), input)
+       }
+
+       // Second block of 64 bytes
+       for i := 0; i < 16; i++ {
+               input := make([]byte, 64)
+               copy(input, golden[offset+i].in[64:])
+               server.Write(uint64(Avx512ServerUID+i), input)
+       }
+
+       wg := sync.WaitGroup{}
+       wg.Add(16)
+
+       // Third and final block
+       for i := 0; i < 16; i++ {
+               input := make([]byte, 64)
+               input[0] = 0x80
+               copy(input[1:], bytes.Repeat([]byte{0}, 63-8))
+
+               // Length in bits.
+               len := uint64(128)
+               len <<= 3
+               for ii := uint(0); ii < 8; ii++ {
+                       input[63-8+1+ii] = byte(len >> (56 - 8*ii))
+               }
+               go func(i int, uid uint64, input []byte) {
+                       output := server.Sum(uid, input)
+                       if bytes.Compare(output[:], golden[offset+i].out[:]) != 0 {
+                               t.Fatalf("Sum256 function: sha256(%s) = %s want %s", golden[offset+i].in, hex.EncodeToString(output[:]), hex.EncodeToString(golden[offset+i].out[:]))
+                       }
+                       wg.Done()
+               }(i, uint64(Avx512ServerUID+i), input)
+       }
+
+       wg.Wait()
+}
+
+func TestAvx512Digest(t *testing.T) {
+
+       if !avx512 {
+               t.SkipNow()
+               return
+       }
+
+       server := NewAvx512Server()
+
+       const tests = 16
+       h512 := [16]hash.Hash{}
+       for i := 0; i < tests; i++ {
+               h512[i] = NewAvx512(server)
+       }
+
+       const offset = 31 + 16
+       for i := 0; i < tests; i++ {
+               input := make([]byte, 64)
+               copy(input, golden[offset+i].in)
+               h512[i].Write(input)
+       }
+       for i := 0; i < tests; i++ {
+               input := make([]byte, 64)
+               copy(input, golden[offset+i].in[64:])
+               h512[i].Write(input)
+       }
+       for i := 0; i < tests; i++ {
+               output := h512[i].Sum([]byte{})
+               if bytes.Compare(output[:], golden[offset+i].out[:]) != 0 {
+                       t.Fatalf("Sum256 function: sha256(%s) = %s want %s", golden[offset+i].in, hex.EncodeToString(output[:]), hex.EncodeToString(golden[offset+i].out[:]))
+               }
+       }
+}
+
+func benchmarkAvx512SingleCore(h512 []hash.Hash, body []byte) {
+
+       for i := 0; i < len(h512); i++ {
+               h512[i].Write(body)
+       }
+       for i := 0; i < len(h512); i++ {
+               _ = h512[i].Sum([]byte{})
+       }
+}
+
+func benchmarkAvx512(b *testing.B, size int) {
+
+       if !avx512 {
+               b.SkipNow()
+               return
+       }
+
+       server := NewAvx512Server()
+
+       const tests = 16
+       body := make([]byte, size)
+
+       b.SetBytes(int64(len(body) * tests))
+       b.ResetTimer()
+
+       for i := 0; i < b.N; i++ {
+               h512 := make([]hash.Hash, tests)
+               for i := 0; i < tests; i++ {
+                       h512[i] = NewAvx512(server)
+               }
+
+               benchmarkAvx512SingleCore(h512, body)
+       }
+}
+
+func BenchmarkAvx512_05M(b *testing.B) { benchmarkAvx512(b, 512*1024) }
+func BenchmarkAvx512_1M(b *testing.B)  { benchmarkAvx512(b, 1*1024*1024) }
+func BenchmarkAvx512_5M(b *testing.B)  { benchmarkAvx512(b, 5*1024*1024) }
+func BenchmarkAvx512_10M(b *testing.B) { benchmarkAvx512(b, 10*1024*1024) }
+
+func benchmarkAvx512MultiCore(b *testing.B, size, cores int) {
+
+       if !avx512 {
+               b.SkipNow()
+               return
+       }
+
+       servers := make([]*Avx512Server, cores)
+       for c := 0; c < cores; c++ {
+               servers[c] = NewAvx512Server()
+       }
+
+       const tests = 16
+
+       body := make([]byte, size)
+
+       h512 := make([]hash.Hash, tests*cores)
+       for i := 0; i < tests*cores; i++ {
+               h512[i] = NewAvx512(servers[i>>4])
+       }
+
+       b.SetBytes(int64(size * 16 * cores))
+       b.ResetTimer()
+
+       var wg sync.WaitGroup
+
+       for i := 0; i < b.N; i++ {
+               wg.Add(cores)
+               for c := 0; c < cores; c++ {
+                       go func(c int) { benchmarkAvx512SingleCore(h512[c*tests:(c+1)*tests], body); wg.Done() }(c)
+               }
+               wg.Wait()
+       }
+}
+
+func BenchmarkAvx512_5M_2Cores(b *testing.B) { benchmarkAvx512MultiCore(b, 5*1024*1024, 2) }
+func BenchmarkAvx512_5M_4Cores(b *testing.B) { benchmarkAvx512MultiCore(b, 5*1024*1024, 4) }
+func BenchmarkAvx512_5M_6Cores(b *testing.B) { benchmarkAvx512MultiCore(b, 5*1024*1024, 6) }
+
+type maskTest struct {
+       in  [16]int
+       out [16]maskRounds
+}
+
+var goldenMask = []maskTest{
+       {[16]int{0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}, [16]maskRounds{}},
+       {[16]int{64, 0, 64, 0, 64, 0, 64, 0, 64, 0, 64, 0, 64, 0, 64, 0}, [16]maskRounds{{0x5555, 1}}},
+       {[16]int{0, 64, 0, 64, 0, 64, 0, 64, 0, 64, 0, 64, 0, 64, 0, 64}, [16]maskRounds{{0xaaaa, 1}}},
+       {[16]int{64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64}, [16]maskRounds{{0xffff, 1}}},
+       {[16]int{128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128}, [16]maskRounds{{0xffff, 2}}},
+       {[16]int{64, 128, 64, 128, 64, 128, 64, 128, 64, 128, 64, 128, 64, 128, 64, 128}, [16]maskRounds{{0xffff, 1}, {0xaaaa, 1}}},
+       {[16]int{128, 64, 128, 64, 128, 64, 128, 64, 128, 64, 128, 64, 128, 64, 128, 64}, [16]maskRounds{{0xffff, 1}, {0x5555, 1}}},
+       {[16]int{64, 192, 64, 192, 64, 192, 64, 192, 64, 192, 64, 192, 64, 192, 64, 192}, [16]maskRounds{{0xffff, 1}, {0xaaaa, 2}}},
+       //
+       //  >= 64   0110=6          1011=b          1101=d           0110=6
+       //  >=128   0100=4          0010=2          1001=9           0100=4
+       {[16]int{0, 64, 128, 0, 64, 128, 0, 64, 128, 0, 64, 128, 0, 64, 128, 0}, [16]maskRounds{{0x6db6, 1}, {0x4924, 1}}},
+       {[16]int{1 * 64, 2 * 64, 3 * 64, 4 * 64, 5 * 64, 6 * 64, 7 * 64, 8 * 64, 9 * 64, 10 * 64, 11 * 64, 12 * 64, 13 * 64, 14 * 64, 15 * 64, 16 * 64},
+               [16]maskRounds{{0xffff, 1}, {0xfffe, 1}, {0xfffc, 1}, {0xfff8, 1}, {0xfff0, 1}, {0xffe0, 1}, {0xffc0, 1}, {0xff80, 1},
+                       {0xff00, 1}, {0xfe00, 1}, {0xfc00, 1}, {0xf800, 1}, {0xf000, 1}, {0xe000, 1}, {0xc000, 1}, {0x8000, 1}}},
+       {[16]int{2 * 64, 1 * 64, 3 * 64, 4 * 64, 5 * 64, 6 * 64, 7 * 64, 8 * 64, 9 * 64, 10 * 64, 11 * 64, 12 * 64, 13 * 64, 14 * 64, 15 * 64, 16 * 64},
+               [16]maskRounds{{0xffff, 1}, {0xfffd, 1}, {0xfffc, 1}, {0xfff8, 1}, {0xfff0, 1}, {0xffe0, 1}, {0xffc0, 1}, {0xff80, 1},
+                       {0xff00, 1}, {0xfe00, 1}, {0xfc00, 1}, {0xf800, 1}, {0xf000, 1}, {0xe000, 1}, {0xc000, 1}, {0x8000, 1}}},
+       {[16]int{10 * 64, 20 * 64, 30 * 64, 40 * 64, 50 * 64, 60 * 64, 70 * 64, 80 * 64, 90 * 64, 100 * 64, 110 * 64, 120 * 64, 130 * 64, 140 * 64, 150 * 64, 160 * 64},
+               [16]maskRounds{{0xffff, 10}, {0xfffe, 10}, {0xfffc, 10}, {0xfff8, 10}, {0xfff0, 10}, {0xffe0, 10}, {0xffc0, 10}, {0xff80, 10},
+                       {0xff00, 10}, {0xfe00, 10}, {0xfc00, 10}, {0xf800, 10}, {0xf000, 10}, {0xe000, 10}, {0xc000, 10}, {0x8000, 10}}},
+       {[16]int{10 * 64, 19 * 64, 27 * 64, 34 * 64, 40 * 64, 45 * 64, 49 * 64, 52 * 64, 54 * 64, 55 * 64, 57 * 64, 60 * 64, 64 * 64, 69 * 64, 75 * 64, 82 * 64},
+               [16]maskRounds{{0xffff, 10}, {0xfffe, 9}, {0xfffc, 8}, {0xfff8, 7}, {0xfff0, 6}, {0xffe0, 5}, {0xffc0, 4}, {0xff80, 3},
+                       {0xff00, 2}, {0xfe00, 1}, {0xfc00, 2}, {0xf800, 3}, {0xf000, 4}, {0xe000, 5}, {0xc000, 6}, {0x8000, 7}}},
+}
+
+func TestMaskGen(t *testing.T) {
+       input := [16][]byte{}
+       for gcase, g := range goldenMask {
+               for i, l := range g.in {
+                       buf := make([]byte, l)
+                       input[i] = buf[:]
+               }
+
+               mr := genMask(input)
+
+               if !reflect.DeepEqual(mr, g.out) {
+                       t.Fatalf("case %d: got %04x\n                    want %04x", gcase, mr, g.out)
+               }
+       }
+}

diff --git a/vendor/github.com/minio/sha256-simd/sha256blockAvx_amd64.go b/vendor/github.com/minio/sha256-simd/sha256blockAvx_amd64.go
new file mode 100644 (file)
index 0000000..eb8a0ff
--- /dev/null
+++ b/vendor/github.com/minio/sha256-simd/sha256blockAvx_amd64.go
@@ -0,0 +1,22 @@
+//+build !noasm
+
+/*
+ * Minio Cloud Storage, (C) 2016 Minio, Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package sha256
+
+//go:noescape
+func blockAvx(h []uint32, message []uint8, reserved0, reserved1, reserved2, reserved3 uint64)

diff --git a/vendor/github.com/minio/sha256-simd/sha256blockAvx_amd64.s b/vendor/github.com/minio/sha256-simd/sha256blockAvx_amd64.s
new file mode 100644 (file)
index 0000000..4a6b28d
--- /dev/null
+++ b/vendor/github.com/minio/sha256-simd/sha256blockAvx_amd64.s
@@ -0,0 +1,408 @@
+//+build !noasm !appengine
+
+// SHA256 implementation for AVX
+
+//
+// Minio Cloud Storage, (C) 2016 Minio, Inc.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+
+//
+// This code is based on an Intel White-Paper:
+// "Fast SHA-256 Implementations on Intel Architecture Processors"
+//
+// together with the reference implementation from the following authors:
+//    James Guilford <james.guilford@intel.com>
+//    Kirk Yap <kirk.s.yap@intel.com>
+//    Tim Chen <tim.c.chen@linux.intel.com>
+//
+// For Golang it has been converted to Plan 9 assembly with the help of
+// github.com/minio/asm2plan9s to assemble Intel instructions to their Plan9
+// equivalents
+//
+
+#include "textflag.h"
+
+#define ROTATE_XS \
+       MOVOU X4, X15 \
+       MOVOU X5, X4  \
+       MOVOU X6, X5  \
+       MOVOU X7, X6  \
+       MOVOU X15, X7
+
+// compute s0 four at a time and s1 two at a time
+// compute W[-16] + W[-7] 4 at a time
+#define FOUR_ROUNDS_AND_SCHED(a, b, c, d, e, f, g, h) \
+       MOVL e, R13                    \ // y0 = e
+       ROLL $18, R13                  \ // y0 = e >> (25-11)
+       MOVL a, R14                    \ // y1 = a
+       LONG $0x0f41e3c4; WORD $0x04c6 \ // VPALIGNR XMM0,XMM7,XMM6,0x4      /* XTMP0 = W[-7]                           */
+       ROLL $23, R14                  \ // y1 = a >> (22-13)
+       XORL e, R13                    \ // y0 = e ^ (e >> (25-11))
+       MOVL f, R15                    \ // y2 = f
+       ROLL $27, R13                  \ // y0 = (e >> (11-6)) ^ (e >> (25-6))
+       XORL a, R14                    \ // y1 = a ^ (a >> (22-13)
+       XORL g, R15                    \ // y2 = f^g
+       LONG $0xc4fef9c5               \ // VPADDD XMM0,XMM0,XMM4            /* XTMP0 = W[-7] + W[-16]                  */
+       XORL e, R13                    \ // y0 = e ^ (e >> (11-6)) ^ (e >> (25-6) )
+       ANDL e, R15                    \ // y2 = (f^g)&e
+       ROLL $21, R14                  \ // y1 = (a >> (13-2)) ^ (a >> (22-2))
+                                      \
+       \ // compute s0
+                                      \
+       LONG $0x0f51e3c4; WORD $0x04cc \ // VPALIGNR XMM1,XMM5,XMM4,0x4      /* XTMP1 = W[-15]                          */
+       XORL a, R14                    \ // y1 = a ^ (a >> (13-2)) ^ (a >> (22-2))
+       ROLL $26, R13                  \ // y0 = S1 = (e>>6) & (e>>11) ^ (e>>25)
+       XORL g, R15                    \ // y2 = CH = ((f^g)&e)^g
+       ROLL $30, R14                  \ // y1 = S0 = (a>>2) ^ (a>>13) ^ (a>>22)
+       ADDL R13, R15                  \ // y2 = S1 + CH
+       ADDL _xfer+48(FP), R15         \ // y2 = k + w + S1 + CH
+       MOVL a, R13                    \ // y0 = a
+       ADDL R15, h                    \ // h = h + S1 + CH + k + w
+       \ // ROTATE_ARGS
+       MOVL a, R15                    \ // y2 = a
+       LONG $0xd172e9c5; BYTE $0x07   \ // VPSRLD XMM2,XMM1,0x7             /*                                         */
+       ORL  c, R13                    \ // y0 = a|c
+       ADDL h, d                      \ // d = d + h + S1 + CH + k + w
+       ANDL c, R15                    \ // y2 = a&c
+       LONG $0xf172e1c5; BYTE $0x19   \ // VPSLLD XMM3,XMM1,0x19            /*                                         */
+       ANDL b, R13                    \ // y0 = (a|c)&b
+       ADDL R14, h                    \ // h = h + S1 + CH + k + w + S0
+       LONG $0xdaebe1c5               \ // VPOR   XMM3,XMM3,XMM2            /* XTMP1 = W[-15] MY_ROR 7                 */
+       ORL  R15, R13                  \ // y0 = MAJ = (a|c)&b)|(a&c)
+       ADDL R13, h                    \ // h = h + S1 + CH + k + w + S0 + MAJ
+       \ // ROTATE_ARGS
+       MOVL d, R13                    \ // y0 = e
+       MOVL h, R14                    \ // y1 = a
+       ROLL $18, R13                  \ // y0 = e >> (25-11)
+       XORL d, R13                    \ // y0 = e ^ (e >> (25-11))
+       MOVL e, R15                    \ // y2 = f
+       ROLL $23, R14                  \ // y1 = a >> (22-13)
+       LONG $0xd172e9c5; BYTE $0x12   \ // VPSRLD XMM2,XMM1,0x12            /*                                         */
+       XORL h, R14                    \ // y1 = a ^ (a >> (22-13)
+       ROLL $27, R13                  \ // y0 = (e >> (11-6)) ^ (e >> (25-6))
+       XORL f, R15                    \ // y2 = f^g
+       LONG $0xd172b9c5; BYTE $0x03   \ // VPSRLD XMM8,XMM1,0x3             /* XTMP4 = W[-15] >> 3                     */
+       ROLL $21, R14                  \ // y1 = (a >> (13-2)) ^ (a >> (22-2))
+       XORL d, R13                    \ // y0 = e ^ (e >> (11-6)) ^ (e >> (25-6))
+       ANDL d, R15                    \ // y2 = (f^g)&e
+       ROLL $26, R13                  \ // y0 = S1 = (e>>6) & (e>>11) ^ (e>>25)
+       LONG $0xf172f1c5; BYTE $0x0e   \ // VPSLLD XMM1,XMM1,0xe             /*                                         */
+       XORL h, R14                    \ // y1 = a ^ (a >> (13-2)) ^ (a >> (22-2))
+       XORL f, R15                    \ // y2 = CH = ((f^g)&e)^g
+       LONG $0xd9efe1c5               \ // VPXOR  XMM3,XMM3,XMM1            /*                                         */
+       ADDL R13, R15                  \ // y2 = S1 + CH
+       ADDL _xfer+52(FP), R15         \ // y2 = k + w + S1 + CH
+       ROLL $30, R14                  \ // y1 = S0 = (a>>2) ^ (a>>13) ^ (a>>22)
+       LONG $0xdaefe1c5               \ // VPXOR  XMM3,XMM3,XMM2            /* XTMP1 = W[-15] MY_ROR 7 ^ W[-15] MY_ROR */
+       MOVL h, R13                    \ // y0 = a
+       ADDL R15, g                    \ // h = h + S1 + CH + k + w
+       MOVL h, R15                    \ // y2 = a
+       LONG $0xef61c1c4; BYTE $0xc8   \ // VPXOR  XMM1,XMM3,XMM8            /* XTMP1 = s0                              */
+       ORL  b, R13                    \ // y0 = a|c
+       ADDL g, c                      \ // d = d + h + S1 + CH + k + w
+       ANDL b, R15                    \ // y2 = a&c
+                                      \
+       \ // compute low s1
+                                      \
+       LONG $0xd770f9c5; BYTE $0xfa   \ // VPSHUFD XMM2,XMM7,0xfa           /* XTMP2 = W[-2] {BBAA}                    */
+       ANDL a, R13                    \ // y0 = (a|c)&b
+       ADDL R14, g                    \ // h = h + S1 + CH + k + w + S0
+       LONG $0xc1fef9c5               \ // VPADDD XMM0,XMM0,XMM1            /* XTMP0 = W[-16] + W[-7] + s0             */
+       ORL  R15, R13                  \ // y0 = MAJ = (a|c)&b)|(a&c)
+       ADDL R13, g                    \ // h = h + S1 + CH + k + w + S0 + MAJ
+       \ // ROTATE_ARGS
+       MOVL c, R13                    \ // y0 = e
+       MOVL g, R14                    \ // y1 = a
+       ROLL $18, R13                  \ // y0 = e >> (25-11)
+       XORL c, R13                    \ // y0 = e ^ (e >> (25-11))
+       ROLL $23, R14                  \ // y1 = a >> (22-13)
+       MOVL d, R15                    \ // y2 = f
+       XORL g, R14                    \ // y1 = a ^ (a >> (22-13)
+       ROLL $27, R13                  \ // y0 = (e >> (11-6)) ^ (e >> (25-6))
+       LONG $0xd272b9c5; BYTE $0x0a   \ // VPSRLD XMM8,XMM2,0xa             /* XTMP4 = W[-2] >> 10 {BBAA}              */
+       XORL e, R15                    \ // y2 = f^g
+       LONG $0xd273e1c5; BYTE $0x13   \ // VPSRLQ XMM3,XMM2,0x13            /* XTMP3 = W[-2] MY_ROR 19 {xBxA}          */
+       XORL c, R13                    \ // y0 = e ^ (e >> (11-6)) ^ (e >> (25-6))
+       ANDL c, R15                    \ // y2 = (f^g)&e
+       LONG $0xd273e9c5; BYTE $0x11   \ // VPSRLQ XMM2,XMM2,0x11            /* XTMP2 = W[-2] MY_ROR 17 {xBxA}          */
+       ROLL $21, R14                  \ // y1 = (a >> (13-2)) ^ (a >> (22-2))
+       XORL g, R14                    \ // y1 = a ^ (a >> (13-2)) ^ (a >> (22-2))
+       XORL e, R15                    \ // y2 = CH = ((f^g)&e)^g
+       ROLL $26, R13                  \ // y0 = S1 = (e>>6) & (e>>11) ^ (e>>25)
+       LONG $0xd3efe9c5               \ // VPXOR  XMM2,XMM2,XMM3            /*                                         */
+       ADDL R13, R15                  \ // y2 = S1 + CH
+       ROLL $30, R14                  \ // y1 = S0 = (a>>2) ^ (a>>13) ^ (a>>22)
+       ADDL _xfer+56(FP), R15         \ // y2 = k + w + S1 + CH
+       LONG $0xc2ef39c5               \ // VPXOR  XMM8,XMM8,XMM2            /* XTMP4 = s1 {xBxA}                       */
+       MOVL g, R13                    \ // y0 = a
+       ADDL R15, f                    \ // h = h + S1 + CH + k + w
+       MOVL g, R15                    \ // y2 = a
+       LONG $0x003942c4; BYTE $0xc2   \ // VPSHUFB XMM8,XMM8,XMM10          /* XTMP4 = s1 {00BA}                       */
+       ORL  a, R13                    \ // y0 = a|c
+       ADDL f, b                      \ // d = d + h + S1 + CH + k + w
+       ANDL a, R15                    \ // y2 = a&c
+       LONG $0xfe79c1c4; BYTE $0xc0   \ // VPADDD XMM0,XMM0,XMM8            /* XTMP0 = {..., ..., W[1], W[0]}          */
+       ANDL h, R13                    \ // y0 = (a|c)&b
+       ADDL R14, f                    \ // h = h + S1 + CH + k + w + S0
+                                      \
+       \ // compute high s1
+                                      \
+       LONG $0xd070f9c5; BYTE $0x50   \ // VPSHUFD XMM2,XMM0,0x50           /* XTMP2 = W[-2] {DDCC}                    */
+       ORL  R15, R13                  \ // y0 = MAJ = (a|c)&b)|(a&c)
+       ADDL R13, f                    \ // h = h + S1 + CH + k + w + S0 + MAJ
+       \ // ROTATE_ARGS
+       MOVL b, R13                    \ // y0 = e
+       ROLL $18, R13                  \ // y0 = e >> (25-11)
+       MOVL f, R14                    \ // y1 = a
+       ROLL $23, R14                  \ // y1 = a >> (22-13)
+       XORL b, R13                    \ // y0 = e ^ (e >> (25-11))
+       MOVL c, R15                    \ // y2 = f
+       ROLL $27, R13                  \ // y0 = (e >> (11-6)) ^ (e >> (25-6))
+       LONG $0xd272a1c5; BYTE $0x0a   \ // VPSRLD XMM11,XMM2,0xa            /* XTMP5 = W[-2] >> 10 {DDCC}              */
+       XORL f, R14                    \ // y1 = a ^ (a >> (22-13)
+       XORL d, R15                    \ // y2 = f^g
+       LONG $0xd273e1c5; BYTE $0x13   \ // VPSRLQ XMM3,XMM2,0x13            /* XTMP3 = W[-2] MY_ROR 19 {xDxC}          */
+       XORL b, R13                    \ // y0 = e ^ (e >> (11-6)) ^ (e >> (25-6))
+       ANDL b, R15                    \ // y2 = (f^g)&e
+       ROLL $21, R14                  \ // y1 = (a >> (13-2)) ^ (a >> (22-2))
+       LONG $0xd273e9c5; BYTE $0x11   \ // VPSRLQ XMM2,XMM2,0x11            /* XTMP2 = W[-2] MY_ROR 17 {xDxC}          */
+       XORL f, R14                    \ // y1 = a ^ (a >> (13-2)) ^ (a >> (22-2))
+       ROLL $26, R13                  \ // y0 = S1 = (e>>6) & (e>>11) ^ (e>>25)
+       XORL d, R15                    \ // y2 = CH = ((f^g)&e)^g
+       LONG $0xd3efe9c5               \ // VPXOR  XMM2,XMM2,XMM3            /*                                         */
+       ROLL $30, R14                  \ // y1 = S0 = (a>>2) ^ (a>>13) ^ (a>>22)
+       ADDL R13, R15                  \ // y2 = S1 + CH
+       ADDL _xfer+60(FP), R15         \ // y2 = k + w + S1 + CH
+       LONG $0xdaef21c5               \ // VPXOR  XMM11,XMM11,XMM2          /* XTMP5 = s1 {xDxC}                       */
+       MOVL f, R13                    \ // y0 = a
+       ADDL R15, e                    \ // h = h + S1 + CH + k + w
+       MOVL f, R15                    \ // y2 = a
+       LONG $0x002142c4; BYTE $0xdc   \ // VPSHUFB XMM11,XMM11,XMM12        /* XTMP5 = s1 {DC00}                       */
+       ORL  h, R13                    \ // y0 = a|c
+       ADDL e, a                      \ // d = d + h + S1 + CH + k + w
+       ANDL h, R15                    \ // y2 = a&c
+       LONG $0xe0fea1c5               \ // VPADDD XMM4,XMM11,XMM0           /* X0 = {W[3], W[2], W[1], W[0]}           */
+       ANDL g, R13                    \ // y0 = (a|c)&b
+       ADDL R14, e                    \ // h = h + S1 + CH + k + w + S0
+       ORL  R15, R13                  \ // y0 = MAJ = (a|c)&b)|(a&c)
+       ADDL R13, e                    \ // h = h + S1 + CH + k + w + S0 + MAJ
+       \ // ROTATE_ARGS
+       ROTATE_XS
+
+#define DO_ROUND(a, b, c, d, e, f, g, h, offset) \
+       MOVL e, R13                \ // y0 = e
+       ROLL $18, R13              \ // y0 = e >> (25-11)
+       MOVL a, R14                \ // y1 = a
+       XORL e, R13                \ // y0 = e ^ (e >> (25-11))
+       ROLL $23, R14              \ // y1 = a >> (22-13)
+       MOVL f, R15                \ // y2 = f
+       XORL a, R14                \ // y1 = a ^ (a >> (22-13)
+       ROLL $27, R13              \ // y0 = (e >> (11-6)) ^ (e >> (25-6))
+       XORL g, R15                \ // y2 = f^g
+       XORL e, R13                \ // y0 = e ^ (e >> (11-6)) ^ (e >> (25-6))
+       ROLL $21, R14              \ // y1 = (a >> (13-2)) ^ (a >> (22-2))
+       ANDL e, R15                \ // y2 = (f^g)&e
+       XORL a, R14                \ // y1 = a ^ (a >> (13-2)) ^ (a >> (22-2))
+       ROLL $26, R13              \ // y0 = S1 = (e>>6) & (e>>11) ^ (e>>25)
+       XORL g, R15                \ // y2 = CH = ((f^g)&e)^g
+       ADDL R13, R15              \ // y2 = S1 + CH
+       ROLL $30, R14              \ // y1 = S0 = (a>>2) ^ (a>>13) ^ (a>>22)
+       ADDL _xfer+offset(FP), R15 \ // y2 = k + w + S1 + CH
+       MOVL a, R13                \ // y0 = a
+       ADDL R15, h                \ // h = h + S1 + CH + k + w
+       MOVL a, R15                \ // y2 = a
+       ORL  c, R13                \ // y0 = a|c
+       ADDL h, d                  \ // d = d + h + S1 + CH + k + w
+       ANDL c, R15                \ // y2 = a&c
+       ANDL b, R13                \ // y0 = (a|c)&b
+       ADDL R14, h                \ // h = h + S1 + CH + k + w + S0
+       ORL  R15, R13              \ // y0 = MAJ = (a|c)&b)|(a&c)
+       ADDL R13, h                // h = h + S1 + CH + k + w + S0 + MAJ
+
+// func blockAvx(h []uint32, message []uint8, reserved0, reserved1, reserved2, reserved3 uint64)
+TEXT ·blockAvx(SB), 7, $0-80
+
+       MOVQ h+0(FP), SI             // SI: &h
+       MOVQ message_base+24(FP), R8 // &message
+       MOVQ message_len+32(FP), R9  // length of message
+       CMPQ R9, $0
+       JEQ  done_hash
+       ADDQ R8, R9
+       MOVQ R9, reserved2+64(FP)    // store end of message
+
+       // Register definition
+       //  a -->  eax
+       //  b -->  ebx
+       //  c -->  ecx
+       //  d -->  r8d
+       //  e -->  edx
+       //  f -->  r9d
+       //  g --> r10d
+       //  h --> r11d
+       //
+       // y0 --> r13d
+       // y1 --> r14d
+       // y2 --> r15d
+
+       MOVL (0*4)(SI), AX  // a = H0
+       MOVL (1*4)(SI), BX  // b = H1
+       MOVL (2*4)(SI), CX  // c = H2
+       MOVL (3*4)(SI), R8  // d = H3
+       MOVL (4*4)(SI), DX  // e = H4
+       MOVL (5*4)(SI), R9  // f = H5
+       MOVL (6*4)(SI), R10 // g = H6
+       MOVL (7*4)(SI), R11 // h = H7
+
+       MOVOU bflipMask<>(SB), X13
+       MOVOU shuf00BA<>(SB), X10  // shuffle xBxA -> 00BA
+       MOVOU shufDC00<>(SB), X12  // shuffle xDxC -> DC00
+
+       MOVQ message_base+24(FP), SI // SI: &message
+
+loop0:
+       LEAQ constants<>(SB), BP
+
+       // byte swap first 16 dwords
+       MOVOU 0*16(SI), X4
+       LONG  $0x0059c2c4; BYTE $0xe5 // VPSHUFB XMM4, XMM4, XMM13
+       MOVOU 1*16(SI), X5
+       LONG  $0x0051c2c4; BYTE $0xed // VPSHUFB XMM5, XMM5, XMM13
+       MOVOU 2*16(SI), X6
+       LONG  $0x0049c2c4; BYTE $0xf5 // VPSHUFB XMM6, XMM6, XMM13
+       MOVOU 3*16(SI), X7
+       LONG  $0x0041c2c4; BYTE $0xfd // VPSHUFB XMM7, XMM7, XMM13
+
+       MOVQ SI, reserved3+72(FP)
+       MOVD $0x3, DI
+
+       // schedule 48 input dwords, by doing 3 rounds of 16 each
+loop1:
+       LONG  $0x4dfe59c5; BYTE $0x00 // VPADDD XMM9, XMM4, 0[RBP]   /* Add 1st constant to first part of message */
+       MOVOU X9, reserved0+48(FP)
+       FOUR_ROUNDS_AND_SCHED(AX, BX,  CX,  R8, DX, R9, R10, R11)
+
+       LONG  $0x4dfe59c5; BYTE $0x10 // VPADDD XMM9, XMM4, 16[RBP]   /* Add 2nd constant to message */
+       MOVOU X9, reserved0+48(FP)
+       FOUR_ROUNDS_AND_SCHED(DX, R9, R10, R11, AX, BX,  CX,  R8)
+
+       LONG  $0x4dfe59c5; BYTE $0x20 // VPADDD XMM9, XMM4, 32[RBP]   /* Add 3rd constant to message */
+       MOVOU X9, reserved0+48(FP)
+       FOUR_ROUNDS_AND_SCHED(AX, BX,  CX,  R8, DX, R9, R10, R11)
+
+       LONG  $0x4dfe59c5; BYTE $0x30 // VPADDD XMM9, XMM4, 48[RBP]   /* Add 4th constant to message */
+       MOVOU X9, reserved0+48(FP)
+       ADDQ  $64, BP
+       FOUR_ROUNDS_AND_SCHED(DX, R9, R10, R11, AX, BX,  CX,  R8)
+
+       SUBQ $1, DI
+       JNE  loop1
+
+       MOVD $0x2, DI
+
+loop2:
+       LONG  $0x4dfe59c5; BYTE $0x00 // VPADDD XMM9, XMM4, 0[RBP]   /* Add 1st constant to first part of message */
+       MOVOU X9, reserved0+48(FP)
+       DO_ROUND( AX,  BX,  CX,  R8,  DX,  R9, R10, R11, 48)
+       DO_ROUND(R11,  AX,  BX,  CX,  R8,  DX,  R9, R10, 52)
+       DO_ROUND(R10, R11,  AX,  BX,  CX,  R8,  DX,  R9, 56)
+       DO_ROUND( R9, R10, R11,  AX,  BX,  CX,  R8,  DX, 60)
+
+       LONG  $0x4dfe51c5; BYTE $0x10 // VPADDD XMM9, XMM5, 16[RBP]   /* Add 2nd constant to message */
+       MOVOU X9, reserved0+48(FP)
+       ADDQ  $32, BP
+       DO_ROUND( DX,  R9, R10, R11,  AX,  BX,  CX,  R8, 48)
+       DO_ROUND( R8,  DX,  R9, R10, R11,  AX,  BX,  CX, 52)
+       DO_ROUND( CX,  R8,  DX,  R9, R10, R11,  AX,  BX, 56)
+       DO_ROUND( BX,  CX,  R8,  DX,  R9, R10, R11,  AX, 60)
+
+       MOVOU X6, X4
+       MOVOU X7, X5
+
+       SUBQ $1, DI
+       JNE  loop2
+
+       MOVQ h+0(FP), SI    // SI: &h
+       ADDL (0*4)(SI), AX  // H0 = a + H0
+       MOVL AX, (0*4)(SI)
+       ADDL (1*4)(SI), BX  // H1 = b + H1
+       MOVL BX, (1*4)(SI)
+       ADDL (2*4)(SI), CX  // H2 = c + H2
+       MOVL CX, (2*4)(SI)
+       ADDL (3*4)(SI), R8  // H3 = d + H3
+       MOVL R8, (3*4)(SI)
+       ADDL (4*4)(SI), DX  // H4 = e + H4
+       MOVL DX, (4*4)(SI)
+       ADDL (5*4)(SI), R9  // H5 = f + H5
+       MOVL R9, (5*4)(SI)
+       ADDL (6*4)(SI), R10 // H6 = g + H6
+       MOVL R10, (6*4)(SI)
+       ADDL (7*4)(SI), R11 // H7 = h + H7
+       MOVL R11, (7*4)(SI)
+
+       MOVQ reserved3+72(FP), SI
+       ADDQ $64, SI
+       CMPQ reserved2+64(FP), SI
+       JNE  loop0
+
+done_hash:
+       RET
+
+// Constants table
+DATA constants<>+0x0(SB)/8, $0x71374491428a2f98
+DATA constants<>+0x8(SB)/8, $0xe9b5dba5b5c0fbcf
+DATA constants<>+0x10(SB)/8, $0x59f111f13956c25b
+DATA constants<>+0x18(SB)/8, $0xab1c5ed5923f82a4
+DATA constants<>+0x20(SB)/8, $0x12835b01d807aa98
+DATA constants<>+0x28(SB)/8, $0x550c7dc3243185be
+DATA constants<>+0x30(SB)/8, $0x80deb1fe72be5d74
+DATA constants<>+0x38(SB)/8, $0xc19bf1749bdc06a7
+DATA constants<>+0x40(SB)/8, $0xefbe4786e49b69c1
+DATA constants<>+0x48(SB)/8, $0x240ca1cc0fc19dc6
+DATA constants<>+0x50(SB)/8, $0x4a7484aa2de92c6f
+DATA constants<>+0x58(SB)/8, $0x76f988da5cb0a9dc
+DATA constants<>+0x60(SB)/8, $0xa831c66d983e5152
+DATA constants<>+0x68(SB)/8, $0xbf597fc7b00327c8
+DATA constants<>+0x70(SB)/8, $0xd5a79147c6e00bf3
+DATA constants<>+0x78(SB)/8, $0x1429296706ca6351
+DATA constants<>+0x80(SB)/8, $0x2e1b213827b70a85
+DATA constants<>+0x88(SB)/8, $0x53380d134d2c6dfc
+DATA constants<>+0x90(SB)/8, $0x766a0abb650a7354
+DATA constants<>+0x98(SB)/8, $0x92722c8581c2c92e
+DATA constants<>+0xa0(SB)/8, $0xa81a664ba2bfe8a1
+DATA constants<>+0xa8(SB)/8, $0xc76c51a3c24b8b70
+DATA constants<>+0xb0(SB)/8, $0xd6990624d192e819
+DATA constants<>+0xb8(SB)/8, $0x106aa070f40e3585
+DATA constants<>+0xc0(SB)/8, $0x1e376c0819a4c116
+DATA constants<>+0xc8(SB)/8, $0x34b0bcb52748774c
+DATA constants<>+0xd0(SB)/8, $0x4ed8aa4a391c0cb3
+DATA constants<>+0xd8(SB)/8, $0x682e6ff35b9cca4f
+DATA constants<>+0xe0(SB)/8, $0x78a5636f748f82ee
+DATA constants<>+0xe8(SB)/8, $0x8cc7020884c87814
+DATA constants<>+0xf0(SB)/8, $0xa4506ceb90befffa
+DATA constants<>+0xf8(SB)/8, $0xc67178f2bef9a3f7
+
+DATA bflipMask<>+0x00(SB)/8, $0x0405060700010203
+DATA bflipMask<>+0x08(SB)/8, $0x0c0d0e0f08090a0b
+
+DATA shuf00BA<>+0x00(SB)/8, $0x0b0a090803020100
+DATA shuf00BA<>+0x08(SB)/8, $0xFFFFFFFFFFFFFFFF
+
+DATA shufDC00<>+0x00(SB)/8, $0xFFFFFFFFFFFFFFFF
+DATA shufDC00<>+0x08(SB)/8, $0x0b0a090803020100
+
+GLOBL constants<>(SB), 8, $256
+GLOBL bflipMask<>(SB), (NOPTR+RODATA), $16
+GLOBL shuf00BA<>(SB), (NOPTR+RODATA), $16
+GLOBL shufDC00<>(SB), (NOPTR+RODATA), $16

diff --git a/vendor/github.com/minio/sha256-simd/sha256blockSha_amd64.go b/vendor/github.com/minio/sha256-simd/sha256blockSha_amd64.go
new file mode 100644 (file)
index 0000000..383189c
--- /dev/null
+++ b/vendor/github.com/minio/sha256-simd/sha256blockSha_amd64.go
@@ -0,0 +1,6 @@
+//+build !noasm
+
+package sha256
+
+//go:noescape
+func blockSha(h *[8]uint32, message []uint8)

diff --git a/vendor/github.com/minio/sha256-simd/sha256blockSha_amd64.s b/vendor/github.com/minio/sha256-simd/sha256blockSha_amd64.s
new file mode 100644 (file)
index 0000000..a107586
--- /dev/null
+++ b/vendor/github.com/minio/sha256-simd/sha256blockSha_amd64.s
@@ -0,0 +1,266 @@
+//+build !noasm !appengine
+
+// SHA intrinsic version of SHA256
+
+// Kristofer Peterson, (C) 2018.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+
+#include "textflag.h"
+
+DATA K<>+0x00(SB)/4, $0x428a2f98
+DATA K<>+0x04(SB)/4, $0x71374491
+DATA K<>+0x08(SB)/4, $0xb5c0fbcf
+DATA K<>+0x0c(SB)/4, $0xe9b5dba5
+DATA K<>+0x10(SB)/4, $0x3956c25b
+DATA K<>+0x14(SB)/4, $0x59f111f1
+DATA K<>+0x18(SB)/4, $0x923f82a4
+DATA K<>+0x1c(SB)/4, $0xab1c5ed5
+DATA K<>+0x20(SB)/4, $0xd807aa98
+DATA K<>+0x24(SB)/4, $0x12835b01
+DATA K<>+0x28(SB)/4, $0x243185be
+DATA K<>+0x2c(SB)/4, $0x550c7dc3
+DATA K<>+0x30(SB)/4, $0x72be5d74
+DATA K<>+0x34(SB)/4, $0x80deb1fe
+DATA K<>+0x38(SB)/4, $0x9bdc06a7
+DATA K<>+0x3c(SB)/4, $0xc19bf174
+DATA K<>+0x40(SB)/4, $0xe49b69c1
+DATA K<>+0x44(SB)/4, $0xefbe4786
+DATA K<>+0x48(SB)/4, $0x0fc19dc6
+DATA K<>+0x4c(SB)/4, $0x240ca1cc
+DATA K<>+0x50(SB)/4, $0x2de92c6f
+DATA K<>+0x54(SB)/4, $0x4a7484aa
+DATA K<>+0x58(SB)/4, $0x5cb0a9dc
+DATA K<>+0x5c(SB)/4, $0x76f988da
+DATA K<>+0x60(SB)/4, $0x983e5152
+DATA K<>+0x64(SB)/4, $0xa831c66d
+DATA K<>+0x68(SB)/4, $0xb00327c8
+DATA K<>+0x6c(SB)/4, $0xbf597fc7
+DATA K<>+0x70(SB)/4, $0xc6e00bf3
+DATA K<>+0x74(SB)/4, $0xd5a79147
+DATA K<>+0x78(SB)/4, $0x06ca6351
+DATA K<>+0x7c(SB)/4, $0x14292967
+DATA K<>+0x80(SB)/4, $0x27b70a85
+DATA K<>+0x84(SB)/4, $0x2e1b2138
+DATA K<>+0x88(SB)/4, $0x4d2c6dfc
+DATA K<>+0x8c(SB)/4, $0x53380d13
+DATA K<>+0x90(SB)/4, $0x650a7354
+DATA K<>+0x94(SB)/4, $0x766a0abb
+DATA K<>+0x98(SB)/4, $0x81c2c92e
+DATA K<>+0x9c(SB)/4, $0x92722c85
+DATA K<>+0xa0(SB)/4, $0xa2bfe8a1
+DATA K<>+0xa4(SB)/4, $0xa81a664b
+DATA K<>+0xa8(SB)/4, $0xc24b8b70
+DATA K<>+0xac(SB)/4, $0xc76c51a3
+DATA K<>+0xb0(SB)/4, $0xd192e819
+DATA K<>+0xb4(SB)/4, $0xd6990624
+DATA K<>+0xb8(SB)/4, $0xf40e3585
+DATA K<>+0xbc(SB)/4, $0x106aa070
+DATA K<>+0xc0(SB)/4, $0x19a4c116
+DATA K<>+0xc4(SB)/4, $0x1e376c08
+DATA K<>+0xc8(SB)/4, $0x2748774c
+DATA K<>+0xcc(SB)/4, $0x34b0bcb5
+DATA K<>+0xd0(SB)/4, $0x391c0cb3
+DATA K<>+0xd4(SB)/4, $0x4ed8aa4a
+DATA K<>+0xd8(SB)/4, $0x5b9cca4f
+DATA K<>+0xdc(SB)/4, $0x682e6ff3
+DATA K<>+0xe0(SB)/4, $0x748f82ee
+DATA K<>+0xe4(SB)/4, $0x78a5636f
+DATA K<>+0xe8(SB)/4, $0x84c87814
+DATA K<>+0xec(SB)/4, $0x8cc70208
+DATA K<>+0xf0(SB)/4, $0x90befffa
+DATA K<>+0xf4(SB)/4, $0xa4506ceb
+DATA K<>+0xf8(SB)/4, $0xbef9a3f7
+DATA K<>+0xfc(SB)/4, $0xc67178f2
+GLOBL K<>(SB), RODATA|NOPTR, $256
+
+DATA SHUF_MASK<>+0x00(SB)/8, $0x0405060700010203
+DATA SHUF_MASK<>+0x08(SB)/8, $0x0c0d0e0f08090a0b
+GLOBL SHUF_MASK<>(SB), RODATA|NOPTR, $16
+
+// Register Usage
+// BX  base address of constant table (constant)
+// DX  hash_state (constant)
+// SI  hash_data.data
+// DI  hash_data.data + hash_data.length - 64 (constant)
+// X0  scratch
+// X1  scratch
+// X2  working hash state // ABEF
+// X3  working hash state // CDGH
+// X4  first 16 bytes of block
+// X5  second 16 bytes of block
+// X6  third 16 bytes of block
+// X7  fourth 16 bytes of block
+// X12 saved hash state // ABEF
+// X13 saved hash state // CDGH
+// X15 data shuffle mask (constant)
+
+TEXT ·blockSha(SB), NOSPLIT, $0-32
+       MOVQ      h+0(FP), DX
+       MOVQ      message_base+8(FP), SI
+       MOVQ      message_len+16(FP), DI
+       LEAQ      -64(SI)(DI*1), DI
+       MOVOU     (DX), X2
+       MOVOU     16(DX), X1
+       MOVO      X2, X3
+       PUNPCKLLQ X1, X2
+       PUNPCKHLQ X1, X3
+       PSHUFD    $0x27, X2, X2
+       PSHUFD    $0x27, X3, X3
+       MOVO      SHUF_MASK<>(SB), X15
+       LEAQ      K<>(SB), BX
+
+       JMP TEST
+
+LOOP:
+       MOVO X2, X12
+       MOVO X3, X13
+
+       // load block and shuffle
+       MOVOU  (SI), X4
+       MOVOU  16(SI), X5
+       MOVOU  32(SI), X6
+       MOVOU  48(SI), X7
+       PSHUFB X15, X4
+       PSHUFB X15, X5
+       PSHUFB X15, X6
+       PSHUFB X15, X7
+
+#define ROUND456 \
+       PADDL  X5, X0                    \
+       LONG   $0xdacb380f               \ // SHA256RNDS2 XMM3, XMM2
+       MOVO   X5, X1                    \
+       LONG   $0x0f3a0f66; WORD $0x04cc \ // PALIGNR XMM1, XMM4, 4
+       PADDL  X1, X6                    \
+       LONG   $0xf5cd380f               \ // SHA256MSG2 XMM6, XMM5
+       PSHUFD $0x4e, X0, X0             \
+       LONG   $0xd3cb380f               \ // SHA256RNDS2 XMM2, XMM3
+       LONG   $0xe5cc380f               // SHA256MSG1 XMM4, XMM5
+
+#define ROUND567 \
+       PADDL  X6, X0                    \
+       LONG   $0xdacb380f               \ // SHA256RNDS2 XMM3, XMM2
+       MOVO   X6, X1                    \
+       LONG   $0x0f3a0f66; WORD $0x04cd \ // PALIGNR XMM1, XMM5, 4
+       PADDL  X1, X7                    \
+       LONG   $0xfecd380f               \ // SHA256MSG2 XMM7, XMM6
+       PSHUFD $0x4e, X0, X0             \
+       LONG   $0xd3cb380f               \ // SHA256RNDS2 XMM2, XMM3
+       LONG   $0xeecc380f               // SHA256MSG1 XMM5, XMM6
+
+#define ROUND674 \
+       PADDL  X7, X0                    \
+       LONG   $0xdacb380f               \ // SHA256RNDS2 XMM3, XMM2
+       MOVO   X7, X1                    \
+       LONG   $0x0f3a0f66; WORD $0x04ce \ // PALIGNR XMM1, XMM6, 4
+       PADDL  X1, X4                    \
+       LONG   $0xe7cd380f               \ // SHA256MSG2 XMM4, XMM7
+       PSHUFD $0x4e, X0, X0             \
+       LONG   $0xd3cb380f               \ // SHA256RNDS2 XMM2, XMM3
+       LONG   $0xf7cc380f               // SHA256MSG1 XMM6, XMM7
+
+#define ROUND745 \
+       PADDL  X4, X0                    \
+       LONG   $0xdacb380f               \ // SHA256RNDS2 XMM3, XMM2
+       MOVO   X4, X1                    \
+       LONG   $0x0f3a0f66; WORD $0x04cf \ // PALIGNR XMM1, XMM7, 4
+       PADDL  X1, X5                    \
+       LONG   $0xeccd380f               \ // SHA256MSG2 XMM5, XMM4
+       PSHUFD $0x4e, X0, X0             \
+       LONG   $0xd3cb380f               \ // SHA256RNDS2 XMM2, XMM3
+       LONG   $0xfccc380f               // SHA256MSG1 XMM7, XMM4
+
+       // rounds 0-3
+       MOVO   (BX), X0
+       PADDL  X4, X0
+       LONG   $0xdacb380f   // SHA256RNDS2 XMM3, XMM2
+       PSHUFD $0x4e, X0, X0
+       LONG   $0xd3cb380f   // SHA256RNDS2 XMM2, XMM3
+
+       // rounds 4-7
+       MOVO   1*16(BX), X0
+       PADDL  X5, X0
+       LONG   $0xdacb380f   // SHA256RNDS2 XMM3, XMM2
+       PSHUFD $0x4e, X0, X0
+       LONG   $0xd3cb380f   // SHA256RNDS2 XMM2, XMM3
+       LONG   $0xe5cc380f   // SHA256MSG1 XMM4, XMM5
+
+       // rounds 8-11
+       MOVO   2*16(BX), X0
+       PADDL  X6, X0
+       LONG   $0xdacb380f   // SHA256RNDS2 XMM3, XMM2
+       PSHUFD $0x4e, X0, X0
+       LONG   $0xd3cb380f   // SHA256RNDS2 XMM2, XMM3
+       LONG   $0xeecc380f   // SHA256MSG1 XMM5, XMM6
+
+       MOVO 3*16(BX), X0; ROUND674  // rounds 12-15
+       MOVO 4*16(BX), X0; ROUND745  // rounds 16-19
+       MOVO 5*16(BX), X0; ROUND456  // rounds 20-23
+       MOVO 6*16(BX), X0; ROUND567  // rounds 24-27
+       MOVO 7*16(BX), X0; ROUND674  // rounds 28-31
+       MOVO 8*16(BX), X0; ROUND745  // rounds 32-35
+       MOVO 9*16(BX), X0; ROUND456  // rounds 36-39
+       MOVO 10*16(BX), X0; ROUND567 // rounds 40-43
+       MOVO 11*16(BX), X0; ROUND674 // rounds 44-47
+       MOVO 12*16(BX), X0; ROUND745 // rounds 48-51
+
+       // rounds 52-55
+       MOVO   13*16(BX), X0
+       PADDL  X5, X0
+       LONG   $0xdacb380f               // SHA256RNDS2 XMM3, XMM2
+       MOVO   X5, X1
+       LONG   $0x0f3a0f66; WORD $0x04cc // PALIGNR XMM1, XMM4, 4
+       PADDL  X1, X6
+       LONG   $0xf5cd380f               // SHA256MSG2 XMM6, XMM5
+       PSHUFD $0x4e, X0, X0
+       LONG   $0xd3cb380f               // SHA256RNDS2 XMM2, XMM3
+
+       // rounds 56-59
+       MOVO   14*16(BX), X0
+       PADDL  X6, X0
+       LONG   $0xdacb380f               // SHA256RNDS2 XMM3, XMM2
+       MOVO   X6, X1
+       LONG   $0x0f3a0f66; WORD $0x04cd // PALIGNR XMM1, XMM5, 4
+       PADDL  X1, X7
+       LONG   $0xfecd380f               // SHA256MSG2 XMM7, XMM6
+       PSHUFD $0x4e, X0, X0
+       LONG   $0xd3cb380f               // SHA256RNDS2 XMM2, XMM3
+
+       // rounds 60-63
+       MOVO   15*16(BX), X0
+       PADDL  X7, X0
+       LONG   $0xdacb380f   // SHA256RNDS2 XMM3, XMM2
+       PSHUFD $0x4e, X0, X0
+       LONG   $0xd3cb380f   // SHA256RNDS2 XMM2, XMM3
+
+       PADDL X12, X2
+       PADDL X13, X3
+
+       ADDQ $64, SI
+
+TEST:
+       CMPQ SI, DI
+       JBE  LOOP
+
+       PSHUFD $0x4e, X3, X0
+       LONG   $0x0e3a0f66; WORD $0xf0c2 // PBLENDW XMM0, XMM2, 0xf0
+       PSHUFD $0x4e, X2, X1
+       LONG   $0x0e3a0f66; WORD $0x0fcb // PBLENDW XMM1, XMM3, 0x0f
+       PSHUFD $0x1b, X0, X0
+       PSHUFD $0x1b, X1, X1
+
+       MOVOU X0, (DX)
+       MOVOU X1, 16(DX)
+
+       RET

diff --git a/vendor/github.com/minio/sha256-simd/sha256blockSha_amd64_test.go b/vendor/github.com/minio/sha256-simd/sha256blockSha_amd64_test.go
new file mode 100644 (file)
index 0000000..ca30c97
--- /dev/null
+++ b/vendor/github.com/minio/sha256-simd/sha256blockSha_amd64_test.go
@@ -0,0 +1,77 @@
+//+build !noasm
+
+package sha256
+
+import (
+       "crypto/sha256"
+       "encoding/binary"
+       "testing"
+)
+
+func sha256hash(m []byte) (r [32]byte) {
+       var h [8]uint32
+
+       h[0] = 0x6a09e667
+       h[1] = 0xbb67ae85
+       h[2] = 0x3c6ef372
+       h[3] = 0xa54ff53a
+       h[4] = 0x510e527f
+       h[5] = 0x9b05688c
+       h[6] = 0x1f83d9ab
+       h[7] = 0x5be0cd19
+
+       blockSha(&h, m)
+       l0 := len(m)
+       l := l0 & (BlockSize - 1)
+       m = m[l0-l:]
+
+       var k [64]byte
+       copy(k[:], m)
+
+       k[l] = 0x80
+
+       if l >= 56 {
+               blockSha(&h, k[:])
+               binary.LittleEndian.PutUint64(k[0:8], 0)
+               binary.LittleEndian.PutUint64(k[8:16], 0)
+               binary.LittleEndian.PutUint64(k[16:24], 0)
+               binary.LittleEndian.PutUint64(k[24:32], 0)
+               binary.LittleEndian.PutUint64(k[32:40], 0)
+               binary.LittleEndian.PutUint64(k[40:48], 0)
+               binary.LittleEndian.PutUint64(k[48:56], 0)
+       }
+       binary.BigEndian.PutUint64(k[56:64], uint64(l0)<<3)
+       blockSha(&h, k[:])
+
+       binary.BigEndian.PutUint32(r[0:4], h[0])
+       binary.BigEndian.PutUint32(r[4:8], h[1])
+       binary.BigEndian.PutUint32(r[8:12], h[2])
+       binary.BigEndian.PutUint32(r[12:16], h[3])
+       binary.BigEndian.PutUint32(r[16:20], h[4])
+       binary.BigEndian.PutUint32(r[20:24], h[5])
+       binary.BigEndian.PutUint32(r[24:28], h[6])
+       binary.BigEndian.PutUint32(r[28:32], h[7])
+
+       return
+}
+
+func runTestSha(hashfunc func([]byte) [32]byte) bool {
+       var m = []byte("This is a message. This is a message. This is a message. This is a message.")
+
+       ar := hashfunc(m)
+       br := sha256.Sum256(m)
+
+       return ar == br
+}
+
+func TestSha0(t *testing.T) {
+       if !runTestSha(Sum256) {
+               t.Errorf("FAILED")
+       }
+}
+
+func TestSha1(t *testing.T) {
+       if sha && ssse3 && sse41 && !runTestSha(sha256hash) {
+               t.Errorf("FAILED")
+       }
+}

diff --git a/vendor/github.com/minio/sha256-simd/sha256blockSsse_amd64.go b/vendor/github.com/minio/sha256-simd/sha256blockSsse_amd64.go
new file mode 100644 (file)
index 0000000..54abbb0
--- /dev/null
+++ b/vendor/github.com/minio/sha256-simd/sha256blockSsse_amd64.go
@@ -0,0 +1,22 @@
+//+build !noasm
+
+/*
+ * Minio Cloud Storage, (C) 2016 Minio, Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package sha256
+
+//go:noescape
+func blockSsse(h []uint32, message []uint8, reserved0, reserved1, reserved2, reserved3 uint64)

diff --git a/vendor/github.com/minio/sha256-simd/sha256blockSsse_amd64.s b/vendor/github.com/minio/sha256-simd/sha256blockSsse_amd64.s
new file mode 100644 (file)
index 0000000..71666fc
--- /dev/null
+++ b/vendor/github.com/minio/sha256-simd/sha256blockSsse_amd64.s
@@ -0,0 +1,429 @@
+//+build !noasm !appengine
+
+// SHA256 implementation for SSSE3
+
+//
+// Minio Cloud Storage, (C) 2016 Minio, Inc.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+
+//
+// This code is based on an Intel White-Paper:
+// "Fast SHA-256 Implementations on Intel Architecture Processors"
+//
+// together with the reference implementation from the following authors:
+//    James Guilford <james.guilford@intel.com>
+//    Kirk Yap <kirk.s.yap@intel.com>
+//    Tim Chen <tim.c.chen@linux.intel.com>
+//
+// For Golang it has been converted to Plan 9 assembly with the help of
+// github.com/minio/asm2plan9s to assemble Intel instructions to their Plan9
+// equivalents
+//
+
+#include "textflag.h"
+
+#define ROTATE_XS \
+       MOVOU X4, X15 \
+       MOVOU X5, X4  \
+       MOVOU X6, X5  \
+       MOVOU X7, X6  \
+       MOVOU X15, X7
+
+// compute s0 four at a time and s1 two at a time
+// compute W[-16] + W[-7] 4 at a time
+#define FOUR_ROUNDS_AND_SCHED(a, b, c, d, e, f, g, h) \
+       MOVL  e, R13                    \ // y0 = e
+       ROLL  $18, R13                  \ // y0 = e >> (25-11)
+       MOVL  a, R14                    \ // y1 = a
+       MOVOU X7, X0                    \
+       LONG  $0x0f3a0f66; WORD $0x04c6 \ // PALIGNR XMM0,XMM6,0x4            /* XTMP0 = W[-7]                           */
+       ROLL  $23, R14                  \ // y1 = a >> (22-13)
+       XORL  e, R13                    \ // y0 = e ^ (e >> (25-11))
+       MOVL  f, R15                    \ // y2 = f
+       ROLL  $27, R13                  \ // y0 = (e >> (11-6)) ^ (e >> (25-6))
+       XORL  a, R14                    \ // y1 = a ^ (a >> (22-13)
+       XORL  g, R15                    \ // y2 = f^g
+       LONG  $0xc4fe0f66               \ // PADDD XMM0,XMM4                  /* XTMP0 = W[-7] + W[-16]                  */
+       XORL  e, R13                    \ // y0 = e ^ (e >> (11-6)) ^ (e >> (25-6) )
+       ANDL  e, R15                    \ // y2 = (f^g)&e
+       ROLL  $21, R14                  \ // y1 = (a >> (13-2)) ^ (a >> (22-2))
+                                       \
+       \ // compute s0
+                                       \
+       MOVOU X5, X1                    \
+       LONG  $0x0f3a0f66; WORD $0x04cc \ // PALIGNR XMM1,XMM4,0x4            /* XTMP1 = W[-15]                          */
+       XORL  a, R14                    \ // y1 = a ^ (a >> (13-2)) ^ (a >> (22-2))
+       ROLL  $26, R13                  \ // y0 = S1 = (e>>6) & (e>>11) ^ (e>>25)
+       XORL  g, R15                    \ // y2 = CH = ((f^g)&e)^g
+       ROLL  $30, R14                  \ // y1 = S0 = (a>>2) ^ (a>>13) ^ (a>>22)
+       ADDL  R13, R15                  \ // y2 = S1 + CH
+       ADDL  _xfer+48(FP), R15         \ // y2 = k + w + S1 + CH
+       MOVL  a, R13                    \ // y0 = a
+       ADDL  R15, h                    \ // h = h + S1 + CH + k + w
+       \ // ROTATE_ARGS
+       MOVL  a, R15                    \ // y2 = a
+       MOVOU X1, X2                    \
+       LONG  $0xd2720f66; BYTE $0x07   \ // PSRLD XMM2,0x7                   /*                                         */
+       ORL   c, R13                    \ // y0 = a|c
+       ADDL  h, d                      \ // d = d + h + S1 + CH + k + w
+       ANDL  c, R15                    \ // y2 = a&c
+       MOVOU X1, X3                    \
+       LONG  $0xf3720f66; BYTE $0x19   \ // PSLLD XMM3,0x19                  /*                                         */
+       ANDL  b, R13                    \ // y0 = (a|c)&b
+       ADDL  R14, h                    \ // h = h + S1 + CH + k + w + S0
+       LONG  $0xdaeb0f66               \ // POR   XMM3,XMM2                  /* XTMP1 = W[-15] MY_ROR 7                 */
+       ORL   R15, R13                  \ // y0 = MAJ = (a|c)&b)|(a&c)
+       ADDL  R13, h                    \ // h = h + S1 + CH + k + w + S0 + MAJ
+       \ // ROTATE_ARGS
+       MOVL  d, R13                    \ // y0 = e
+       MOVL  h, R14                    \ // y1 = a
+       ROLL  $18, R13                  \ // y0 = e >> (25-11)
+       XORL  d, R13                    \ // y0 = e ^ (e >> (25-11))
+       MOVL  e, R15                    \ // y2 = f
+       ROLL  $23, R14                  \ // y1 = a >> (22-13)
+       MOVOU X1, X2                    \
+       LONG  $0xd2720f66; BYTE $0x12   \ // PSRLD XMM2,0x12                  /*                                         */
+       XORL  h, R14                    \ // y1 = a ^ (a >> (22-13)
+       ROLL  $27, R13                  \ // y0 = (e >> (11-6)) ^ (e >> (25-6))
+       XORL  f, R15                    \ // y2 = f^g
+       MOVOU X1, X8                    \
+       LONG  $0x720f4166; WORD $0x03d0 \ // PSRLD XMM8,0x3                   /* XTMP4 = W[-15] >> 3                     */
+       ROLL  $21, R14                  \ // y1 = (a >> (13-2)) ^ (a >> (22-2))
+       XORL  d, R13                    \ // y0 = e ^ (e >> (11-6)) ^ (e >> (25-6))
+       ANDL  d, R15                    \ // y2 = (f^g)&e
+       ROLL  $26, R13                  \ // y0 = S1 = (e>>6) & (e>>11) ^ (e>>25)
+       LONG  $0xf1720f66; BYTE $0x0e   \ // PSLLD XMM1,0xe                   /*                                         */
+       XORL  h, R14                    \ // y1 = a ^ (a >> (13-2)) ^ (a >> (22-2))
+       XORL  f, R15                    \ // y2 = CH = ((f^g)&e)^g
+       LONG  $0xd9ef0f66               \ // PXOR  XMM3,XMM1                  /*                                         */
+       ADDL  R13, R15                  \ // y2 = S1 + CH
+       ADDL  _xfer+52(FP), R15         \ // y2 = k + w + S1 + CH
+       ROLL  $30, R14                  \ // y1 = S0 = (a>>2) ^ (a>>13) ^ (a>>22)
+       LONG  $0xdaef0f66               \ // PXOR  XMM3,XMM2                  /* XTMP1 = W[-15] MY_ROR 7 ^ W[-15] MY_ROR */
+       MOVL  h, R13                    \ // y0 = a
+       ADDL  R15, g                    \ // h = h + S1 + CH + k + w
+       MOVL  h, R15                    \ // y2 = a
+       MOVOU X3, X1                    \
+       LONG  $0xef0f4166; BYTE $0xc8   \ // PXOR  XMM1,XMM8                  /* XTMP1 = s0                              */
+       ORL   b, R13                    \ // y0 = a|c
+       ADDL  g, c                      \ // d = d + h + S1 + CH + k + w
+       ANDL  b, R15                    \ // y2 = a&c
+                                       \
+       \ // compute low s1
+                                       \
+       LONG  $0xd7700f66; BYTE $0xfa   \ // PSHUFD XMM2,XMM7,0xfa            /* XTMP2 = W[-2] {BBAA}                    */
+       ANDL  a, R13                    \ // y0 = (a|c)&b
+       ADDL  R14, g                    \ // h = h + S1 + CH + k + w + S0
+       LONG  $0xc1fe0f66               \ // PADDD XMM0,XMM1                  /* XTMP0 = W[-16] + W[-7] + s0             */
+       ORL   R15, R13                  \ // y0 = MAJ = (a|c)&b)|(a&c)
+       ADDL  R13, g                    \ // h = h + S1 + CH + k + w + S0 + MAJ
+       \ // ROTATE_ARGS
+       MOVL  c, R13                    \ // y0 = e
+       MOVL  g, R14                    \ // y1 = a
+       ROLL  $18, R13                  \ // y0 = e >> (25-11)
+       XORL  c, R13                    \ // y0 = e ^ (e >> (25-11))
+       ROLL  $23, R14                  \ // y1 = a >> (22-13)
+       MOVL  d, R15                    \ // y2 = f
+       XORL  g, R14                    \ // y1 = a ^ (a >> (22-13)
+       ROLL  $27, R13                  \ // y0 = (e >> (11-6)) ^ (e >> (25-6))
+       MOVOU X2, X8                    \
+       LONG  $0x720f4166; WORD $0x0ad0 \ // PSRLD XMM8,0xa                   /* XTMP4 = W[-2] >> 10 {BBAA}              */
+       XORL  e, R15                    \ // y2 = f^g
+       MOVOU X2, X3                    \
+       LONG  $0xd3730f66; BYTE $0x13   \ // PSRLQ XMM3,0x13                  /* XTMP3 = W[-2] MY_ROR 19 {xBxA}          */
+       XORL  c, R13                    \ // y0 = e ^ (e >> (11-6)) ^ (e >> (25-6))
+       ANDL  c, R15                    \ // y2 = (f^g)&e
+       LONG  $0xd2730f66; BYTE $0x11   \ // PSRLQ XMM2,0x11                  /* XTMP2 = W[-2] MY_ROR 17 {xBxA}          */
+       ROLL  $21, R14                  \ // y1 = (a >> (13-2)) ^ (a >> (22-2))
+       XORL  g, R14                    \ // y1 = a ^ (a >> (13-2)) ^ (a >> (22-2))
+       XORL  e, R15                    \ // y2 = CH = ((f^g)&e)^g
+       ROLL  $26, R13                  \ // y0 = S1 = (e>>6) & (e>>11) ^ (e>>25)
+       LONG  $0xd3ef0f66               \ // PXOR  XMM2,XMM3                  /*                                         */
+       ADDL  R13, R15                  \ // y2 = S1 + CH
+       ROLL  $30, R14                  \ // y1 = S0 = (a>>2) ^ (a>>13) ^ (a>>22)
+       ADDL  _xfer+56(FP), R15         \ // y2 = k + w + S1 + CH
+       LONG  $0xef0f4466; BYTE $0xc2   \ // PXOR  XMM8,XMM2                  /* XTMP4 = s1 {xBxA}                       */
+       MOVL  g, R13                    \ // y0 = a
+       ADDL  R15, f                    \ // h = h + S1 + CH + k + w
+       MOVL  g, R15                    \ // y2 = a
+       LONG  $0x380f4566; WORD $0xc200 \ // PSHUFB XMM8,XMM10                /* XTMP4 = s1 {00BA}                       */
+       ORL   a, R13                    \ // y0 = a|c
+       ADDL  f, b                      \ // d = d + h + S1 + CH + k + w
+       ANDL  a, R15                    \ // y2 = a&c
+       LONG  $0xfe0f4166; BYTE $0xc0   \ // PADDD XMM0,XMM8                  /* XTMP0 = {..., ..., W[1], W[0]}          */
+       ANDL  h, R13                    \ // y0 = (a|c)&b
+       ADDL  R14, f                    \ // h = h + S1 + CH + k + w + S0
+                                       \
+       \ // compute high s1
+                                       \
+       LONG  $0xd0700f66; BYTE $0x50   \ // PSHUFD XMM2,XMM0,0x50            /* XTMP2 = W[-2] {DDCC}                    */
+       ORL   R15, R13                  \ // y0 = MAJ = (a|c)&b)|(a&c)
+       ADDL  R13, f                    \ // h = h + S1 + CH + k + w + S0 + MAJ
+       \ // ROTATE_ARGS
+       MOVL  b, R13                    \ // y0 = e
+       ROLL  $18, R13                  \ // y0 = e >> (25-11)
+       MOVL  f, R14                    \ // y1 = a
+       ROLL  $23, R14                  \ // y1 = a >> (22-13)
+       XORL  b, R13                    \ // y0 = e ^ (e >> (25-11))
+       MOVL  c, R15                    \ // y2 = f
+       ROLL  $27, R13                  \ // y0 = (e >> (11-6)) ^ (e >> (25-6))
+       MOVOU X2, X11                   \
+       LONG  $0x720f4166; WORD $0x0ad3 \ // PSRLD XMM11,0xa                  /* XTMP5 = W[-2] >> 10 {DDCC}              */
+       XORL  f, R14                    \ // y1 = a ^ (a >> (22-13)
+       XORL  d, R15                    \ // y2 = f^g
+       MOVOU X2, X3                    \
+       LONG  $0xd3730f66; BYTE $0x13   \ // PSRLQ XMM3,0x13                  /* XTMP3 = W[-2] MY_ROR 19 {xDxC}          */
+       XORL  b, R13                    \ // y0 = e ^ (e >> (11-6)) ^ (e >> (25-6))
+       ANDL  b, R15                    \ // y2 = (f^g)&e
+       ROLL  $21, R14                  \ // y1 = (a >> (13-2)) ^ (a >> (22-2))
+       LONG  $0xd2730f66; BYTE $0x11   \ // PSRLQ XMM2,0x11                  /* XTMP2 = W[-2] MY_ROR 17 {xDxC}          */
+       XORL  f, R14                    \ // y1 = a ^ (a >> (13-2)) ^ (a >> (22-2))
+       ROLL  $26, R13                  \ // y0 = S1 = (e>>6) & (e>>11) ^ (e>>25)
+       XORL  d, R15                    \ // y2 = CH = ((f^g)&e)^g
+       LONG  $0xd3ef0f66               \ // PXOR  XMM2,XMM3                  /*                                         */
+       ROLL  $30, R14                  \ // y1 = S0 = (a>>2) ^ (a>>13) ^ (a>>22)
+       ADDL  R13, R15                  \ // y2 = S1 + CH
+       ADDL  _xfer+60(FP), R15         \ // y2 = k + w + S1 + CH
+       LONG  $0xef0f4466; BYTE $0xda   \ // PXOR  XMM11,XMM2                 /* XTMP5 = s1 {xDxC}                       */
+       MOVL  f, R13                    \ // y0 = a
+       ADDL  R15, e                    \ // h = h + S1 + CH + k + w
+       MOVL  f, R15                    \ // y2 = a
+       LONG  $0x380f4566; WORD $0xdc00 \ // PSHUFB XMM11,XMM12               /* XTMP5 = s1 {DC00}                       */
+       ORL   h, R13                    \ // y0 = a|c
+       ADDL  e, a                      \ // d = d + h + S1 + CH + k + w
+       ANDL  h, R15                    \ // y2 = a&c
+       MOVOU X11, X4                   \
+       LONG  $0xe0fe0f66               \ // PADDD XMM4,XMM0                  /* X0 = {W[3], W[2], W[1], W[0]}           */
+       ANDL  g, R13                    \ // y0 = (a|c)&b
+       ADDL  R14, e                    \ // h = h + S1 + CH + k + w + S0
+       ORL   R15, R13                  \ // y0 = MAJ = (a|c)&b)|(a&c)
+       ADDL  R13, e                    \ // h = h + S1 + CH + k + w + S0 + MAJ
+       \ // ROTATE_ARGS
+       ROTATE_XS
+
+#define DO_ROUND(a, b, c, d, e, f, g, h, offset) \
+       MOVL e, R13                \ // y0 = e
+       ROLL $18, R13              \ // y0 = e >> (25-11)
+       MOVL a, R14                \ // y1 = a
+       XORL e, R13                \ // y0 = e ^ (e >> (25-11))
+       ROLL $23, R14              \ // y1 = a >> (22-13)
+       MOVL f, R15                \ // y2 = f
+       XORL a, R14                \ // y1 = a ^ (a >> (22-13)
+       ROLL $27, R13              \ // y0 = (e >> (11-6)) ^ (e >> (25-6))
+       XORL g, R15                \ // y2 = f^g
+       XORL e, R13                \ // y0 = e ^ (e >> (11-6)) ^ (e >> (25-6))
+       ROLL $21, R14              \ // y1 = (a >> (13-2)) ^ (a >> (22-2))
+       ANDL e, R15                \ // y2 = (f^g)&e
+       XORL a, R14                \ // y1 = a ^ (a >> (13-2)) ^ (a >> (22-2))
+       ROLL $26, R13              \ // y0 = S1 = (e>>6) & (e>>11) ^ (e>>25)
+       XORL g, R15                \ // y2 = CH = ((f^g)&e)^g
+       ADDL R13, R15              \ // y2 = S1 + CH
+       ROLL $30, R14              \ // y1 = S0 = (a>>2) ^ (a>>13) ^ (a>>22)
+       ADDL _xfer+offset(FP), R15 \ // y2 = k + w + S1 + CH
+       MOVL a, R13                \ // y0 = a
+       ADDL R15, h                \ // h = h + S1 + CH + k + w
+       MOVL a, R15                \ // y2 = a
+       ORL  c, R13                \ // y0 = a|c
+       ADDL h, d                  \ // d = d + h + S1 + CH + k + w
+       ANDL c, R15                \ // y2 = a&c
+       ANDL b, R13                \ // y0 = (a|c)&b
+       ADDL R14, h                \ // h = h + S1 + CH + k + w + S0
+       ORL  R15, R13              \ // y0 = MAJ = (a|c)&b)|(a&c)
+       ADDL R13, h                // h = h + S1 + CH + k + w + S0 + MAJ
+
+// func blockSsse(h []uint32, message []uint8, reserved0, reserved1, reserved2, reserved3 uint64)
+TEXT ·blockSsse(SB), 7, $0-80
+
+       MOVQ h+0(FP), SI             // SI: &h
+       MOVQ message_base+24(FP), R8 // &message
+       MOVQ message_len+32(FP), R9  // length of message
+       CMPQ R9, $0
+       JEQ  done_hash
+       ADDQ R8, R9
+       MOVQ R9, reserved2+64(FP)    // store end of message
+
+       // Register definition
+       //  a -->  eax
+       //  b -->  ebx
+       //  c -->  ecx
+       //  d -->  r8d
+       //  e -->  edx
+       //  f -->  r9d
+       //  g --> r10d
+       //  h --> r11d
+       //
+       // y0 --> r13d
+       // y1 --> r14d
+       // y2 --> r15d
+
+       MOVL (0*4)(SI), AX  // a = H0
+       MOVL (1*4)(SI), BX  // b = H1
+       MOVL (2*4)(SI), CX  // c = H2
+       MOVL (3*4)(SI), R8  // d = H3
+       MOVL (4*4)(SI), DX  // e = H4
+       MOVL (5*4)(SI), R9  // f = H5
+       MOVL (6*4)(SI), R10 // g = H6
+       MOVL (7*4)(SI), R11 // h = H7
+
+       MOVOU bflipMask<>(SB), X13
+       MOVOU shuf00BA<>(SB), X10  // shuffle xBxA -> 00BA
+       MOVOU shufDC00<>(SB), X12  // shuffle xDxC -> DC00
+
+       MOVQ message_base+24(FP), SI // SI: &message
+
+loop0:
+       LEAQ constants<>(SB), BP
+
+       // byte swap first 16 dwords
+       MOVOU 0*16(SI), X4
+       LONG  $0x380f4166; WORD $0xe500 // PSHUFB XMM4, XMM13
+       MOVOU 1*16(SI), X5
+       LONG  $0x380f4166; WORD $0xed00 // PSHUFB XMM5, XMM13
+       MOVOU 2*16(SI), X6
+       LONG  $0x380f4166; WORD $0xf500 // PSHUFB XMM6, XMM13
+       MOVOU 3*16(SI), X7
+       LONG  $0x380f4166; WORD $0xfd00 // PSHUFB XMM7, XMM13
+
+       MOVQ SI, reserved3+72(FP)
+       MOVD $0x3, DI
+
+       // Align
+       //  nop    WORD PTR [rax+rax*1+0x0]
+
+       // schedule 48 input dwords, by doing 3 rounds of 16 each
+loop1:
+       MOVOU X4, X9
+       LONG  $0xfe0f4466; WORD $0x004d // PADDD XMM9, 0[RBP]   /* Add 1st constant to first part of message */
+       MOVOU X9, reserved0+48(FP)
+       FOUR_ROUNDS_AND_SCHED(AX, BX,  CX,  R8, DX, R9, R10, R11)
+
+       MOVOU X4, X9
+       LONG  $0xfe0f4466; WORD $0x104d // PADDD XMM9, 16[RBP]   /* Add 2nd constant to message */
+       MOVOU X9, reserved0+48(FP)
+       FOUR_ROUNDS_AND_SCHED(DX, R9, R10, R11, AX, BX,  CX,  R8)
+
+       MOVOU X4, X9
+       LONG  $0xfe0f4466; WORD $0x204d // PADDD XMM9, 32[RBP]   /* Add 3rd constant to message */
+       MOVOU X9, reserved0+48(FP)
+       FOUR_ROUNDS_AND_SCHED(AX, BX,  CX,  R8, DX, R9, R10, R11)
+
+       MOVOU X4, X9
+       LONG  $0xfe0f4466; WORD $0x304d // PADDD XMM9, 48[RBP]   /* Add 4th constant to message */
+       MOVOU X9, reserved0+48(FP)
+       ADDQ  $64, BP
+       FOUR_ROUNDS_AND_SCHED(DX, R9, R10, R11, AX, BX,  CX,  R8)
+
+       SUBQ $1, DI
+       JNE  loop1
+
+       MOVD $0x2, DI
+
+loop2:
+       MOVOU X4, X9
+       LONG  $0xfe0f4466; WORD $0x004d // PADDD XMM9, 0[RBP]   /* Add 1st constant to first part of message */
+       MOVOU X9, reserved0+48(FP)
+       DO_ROUND( AX,  BX,  CX,  R8,  DX,  R9, R10, R11, 48)
+       DO_ROUND(R11,  AX,  BX,  CX,  R8,  DX,  R9, R10, 52)
+       DO_ROUND(R10, R11,  AX,  BX,  CX,  R8,  DX,  R9, 56)
+       DO_ROUND( R9, R10, R11,  AX,  BX,  CX,  R8,  DX, 60)
+
+       MOVOU X5, X9
+       LONG  $0xfe0f4466; WORD $0x104d // PADDD XMM9, 16[RBP]   /* Add 2nd constant to message */
+       MOVOU X9, reserved0+48(FP)
+       ADDQ  $32, BP
+       DO_ROUND( DX,  R9, R10, R11,  AX,  BX,  CX,  R8, 48)
+       DO_ROUND( R8,  DX,  R9, R10, R11,  AX,  BX,  CX, 52)
+       DO_ROUND( CX,  R8,  DX,  R9, R10, R11,  AX,  BX, 56)
+       DO_ROUND( BX,  CX,  R8,  DX,  R9, R10, R11,  AX, 60)
+
+       MOVOU X6, X4
+       MOVOU X7, X5
+
+       SUBQ $1, DI
+       JNE  loop2
+
+       MOVQ h+0(FP), SI    // SI: &h
+       ADDL (0*4)(SI), AX  // H0 = a + H0
+       MOVL AX, (0*4)(SI)
+       ADDL (1*4)(SI), BX  // H1 = b + H1
+       MOVL BX, (1*4)(SI)
+       ADDL (2*4)(SI), CX  // H2 = c + H2
+       MOVL CX, (2*4)(SI)
+       ADDL (3*4)(SI), R8  // H3 = d + H3
+       MOVL R8, (3*4)(SI)
+       ADDL (4*4)(SI), DX  // H4 = e + H4
+       MOVL DX, (4*4)(SI)
+       ADDL (5*4)(SI), R9  // H5 = f + H5
+       MOVL R9, (5*4)(SI)
+       ADDL (6*4)(SI), R10 // H6 = g + H6
+       MOVL R10, (6*4)(SI)
+       ADDL (7*4)(SI), R11 // H7 = h + H7
+       MOVL R11, (7*4)(SI)
+
+       MOVQ reserved3+72(FP), SI
+       ADDQ $64, SI
+       CMPQ reserved2+64(FP), SI
+       JNE  loop0
+
+done_hash:
+       RET
+
+// Constants table
+DATA constants<>+0x0(SB)/8, $0x71374491428a2f98
+DATA constants<>+0x8(SB)/8, $0xe9b5dba5b5c0fbcf
+DATA constants<>+0x10(SB)/8, $0x59f111f13956c25b
+DATA constants<>+0x18(SB)/8, $0xab1c5ed5923f82a4
+DATA constants<>+0x20(SB)/8, $0x12835b01d807aa98
+DATA constants<>+0x28(SB)/8, $0x550c7dc3243185be
+DATA constants<>+0x30(SB)/8, $0x80deb1fe72be5d74
+DATA constants<>+0x38(SB)/8, $0xc19bf1749bdc06a7
+DATA constants<>+0x40(SB)/8, $0xefbe4786e49b69c1
+DATA constants<>+0x48(SB)/8, $0x240ca1cc0fc19dc6
+DATA constants<>+0x50(SB)/8, $0x4a7484aa2de92c6f
+DATA constants<>+0x58(SB)/8, $0x76f988da5cb0a9dc
+DATA constants<>+0x60(SB)/8, $0xa831c66d983e5152
+DATA constants<>+0x68(SB)/8, $0xbf597fc7b00327c8
+DATA constants<>+0x70(SB)/8, $0xd5a79147c6e00bf3
+DATA constants<>+0x78(SB)/8, $0x1429296706ca6351
+DATA constants<>+0x80(SB)/8, $0x2e1b213827b70a85
+DATA constants<>+0x88(SB)/8, $0x53380d134d2c6dfc
+DATA constants<>+0x90(SB)/8, $0x766a0abb650a7354
+DATA constants<>+0x98(SB)/8, $0x92722c8581c2c92e
+DATA constants<>+0xa0(SB)/8, $0xa81a664ba2bfe8a1
+DATA constants<>+0xa8(SB)/8, $0xc76c51a3c24b8b70
+DATA constants<>+0xb0(SB)/8, $0xd6990624d192e819
+DATA constants<>+0xb8(SB)/8, $0x106aa070f40e3585
+DATA constants<>+0xc0(SB)/8, $0x1e376c0819a4c116
+DATA constants<>+0xc8(SB)/8, $0x34b0bcb52748774c
+DATA constants<>+0xd0(SB)/8, $0x4ed8aa4a391c0cb3
+DATA constants<>+0xd8(SB)/8, $0x682e6ff35b9cca4f
+DATA constants<>+0xe0(SB)/8, $0x78a5636f748f82ee
+DATA constants<>+0xe8(SB)/8, $0x8cc7020884c87814
+DATA constants<>+0xf0(SB)/8, $0xa4506ceb90befffa
+DATA constants<>+0xf8(SB)/8, $0xc67178f2bef9a3f7
+
+DATA bflipMask<>+0x00(SB)/8, $0x0405060700010203
+DATA bflipMask<>+0x08(SB)/8, $0x0c0d0e0f08090a0b
+
+DATA shuf00BA<>+0x00(SB)/8, $0x0b0a090803020100
+DATA shuf00BA<>+0x08(SB)/8, $0xFFFFFFFFFFFFFFFF
+
+DATA shufDC00<>+0x00(SB)/8, $0xFFFFFFFFFFFFFFFF
+DATA shufDC00<>+0x08(SB)/8, $0x0b0a090803020100
+
+GLOBL constants<>(SB), 8, $256
+GLOBL bflipMask<>(SB), (NOPTR+RODATA), $16
+GLOBL shuf00BA<>(SB), (NOPTR+RODATA), $16
+GLOBL shufDC00<>(SB), (NOPTR+RODATA), $16

diff --git a/vendor/github.com/minio/sha256-simd/sha256block_386.go b/vendor/github.com/minio/sha256-simd/sha256block_386.go
new file mode 100644 (file)
index 0000000..a4153b9
--- /dev/null
+++ b/vendor/github.com/minio/sha256-simd/sha256block_386.go
@@ -0,0 +1,25 @@
+//+build !noasm
+
+/*
+ * Minio Cloud Storage, (C) 2016 Minio, Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package sha256
+
+func blockArmGo(dig *digest, p []byte)  {}
+func blockAvx2Go(dig *digest, p []byte) {}
+func blockAvxGo(dig *digest, p []byte)  {}
+func blockSsseGo(dig *digest, p []byte) {}
+func blockShaGo(dig *digest, p []byte)  {}

diff --git a/vendor/github.com/minio/sha256-simd/sha256block_amd64.go b/vendor/github.com/minio/sha256-simd/sha256block_amd64.go
new file mode 100644 (file)
index 0000000..8d341fc
--- /dev/null
+++ b/vendor/github.com/minio/sha256-simd/sha256block_amd64.go
@@ -0,0 +1,53 @@
+//+build !noasm
+
+/*
+ * Minio Cloud Storage, (C) 2016 Minio, Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package sha256
+
+func blockArmGo(dig *digest, p []byte) {}
+
+func blockAvxGo(dig *digest, p []byte) {
+
+       h := []uint32{dig.h[0], dig.h[1], dig.h[2], dig.h[3], dig.h[4], dig.h[5], dig.h[6], dig.h[7]}
+
+       blockAvx(h[:], p[:], 0, 0, 0, 0)
+
+       dig.h[0], dig.h[1], dig.h[2], dig.h[3], dig.h[4], dig.h[5], dig.h[6], dig.h[7] = h[0], h[1], h[2], h[3], h[4], h[5], h[6], h[7]
+}
+
+func blockAvx2Go(dig *digest, p []byte) {
+
+       h := []uint32{dig.h[0], dig.h[1], dig.h[2], dig.h[3], dig.h[4], dig.h[5], dig.h[6], dig.h[7]}
+
+       blockAvx2(h[:], p[:])
+
+       dig.h[0], dig.h[1], dig.h[2], dig.h[3], dig.h[4], dig.h[5], dig.h[6], dig.h[7] = h[0], h[1], h[2], h[3], h[4], h[5], h[6], h[7]
+}
+
+func blockSsseGo(dig *digest, p []byte) {
+
+       h := []uint32{dig.h[0], dig.h[1], dig.h[2], dig.h[3], dig.h[4], dig.h[5], dig.h[6], dig.h[7]}
+
+       blockSsse(h[:], p[:], 0, 0, 0, 0)
+
+       dig.h[0], dig.h[1], dig.h[2], dig.h[3], dig.h[4], dig.h[5], dig.h[6], dig.h[7] = h[0], h[1], h[2], h[3], h[4], h[5], h[6], h[7]
+}
+
+func blockShaGo(dig *digest, p []byte) {
+
+       blockSha(&dig.h, p)
+}

diff --git a/vendor/github.com/minio/sha256-simd/sha256block_arm.go b/vendor/github.com/minio/sha256-simd/sha256block_arm.go
new file mode 100644 (file)
index 0000000..1191c08
--- /dev/null
+++ b/vendor/github.com/minio/sha256-simd/sha256block_arm.go
@@ -0,0 +1,25 @@
+//+build !noasm
+
+/*
+ * Minio Cloud Storage, (C) 2016 Minio, Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package sha256
+
+func blockAvx2Go(dig *digest, p []byte) {}
+func blockAvxGo(dig *digest, p []byte)  {}
+func blockSsseGo(dig *digest, p []byte) {}
+func blockShaGo(dig *digest, p []byte)  {}
+func blockArmGo(dig *digest, p []byte)  {}

diff --git a/vendor/github.com/minio/sha256-simd/sha256block_arm64.go b/vendor/github.com/minio/sha256-simd/sha256block_arm64.go
new file mode 100644 (file)
index 0000000..4441b0c
--- /dev/null
+++ b/vendor/github.com/minio/sha256-simd/sha256block_arm64.go
@@ -0,0 +1,37 @@
+//+build !noasm
+
+/*
+ * Minio Cloud Storage, (C) 2016 Minio, Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package sha256
+
+func blockAvx2Go(dig *digest, p []byte) {}
+func blockAvxGo(dig *digest, p []byte)  {}
+func blockSsseGo(dig *digest, p []byte) {}
+func blockShaGo(dig *digest, p []byte)  {}
+
+//go:noescape
+func blockArm(h []uint32, message []uint8)
+
+func blockArmGo(dig *digest, p []byte) {
+
+       h := []uint32{dig.h[0], dig.h[1], dig.h[2], dig.h[3], dig.h[4], dig.h[5], dig.h[6], dig.h[7]}
+
+       blockArm(h[:], p[:])
+
+       dig.h[0], dig.h[1], dig.h[2], dig.h[3], dig.h[4], dig.h[5], dig.h[6], dig.h[7] = h[0], h[1], h[2], h[3], h[4],
+               h[5], h[6], h[7]
+}

diff --git a/vendor/github.com/minio/sha256-simd/sha256block_arm64.s b/vendor/github.com/minio/sha256-simd/sha256block_arm64.s
new file mode 100644 (file)
index 0000000..db816ac
--- /dev/null
+++ b/vendor/github.com/minio/sha256-simd/sha256block_arm64.s
@@ -0,0 +1,192 @@
+//+build !noasm !appengine
+
+// ARM64 version of SHA256
+
+//
+// Minio Cloud Storage, (C) 2016 Minio, Inc.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+
+//
+// Based on implementation as found in https://github.com/jocover/sha256-armv8
+//
+// Use github.com/minio/asm2plan9s on this file to assemble ARM instructions to
+// their Plan9 equivalents
+//
+
+TEXT ·blockArm(SB), 7, $0
+       MOVD h+0(FP), R0
+       MOVD message+24(FP), R1
+       MOVD lenmessage+32(FP), R2 // length of message
+       SUBS $64, R2
+       BMI  complete
+
+       // Load constants table pointer
+       MOVD $·constants(SB), R3
+
+       // Cache constants table in registers v16 - v31
+       WORD $0x4cdf2870 // ld1 {v16.4s-v19.4s}, [x3], #64
+       WORD $0x4cdf7800 // ld1 {v0.4s}, [x0], #16
+       WORD $0x4cdf2874 // ld1 {v20.4s-v23.4s}, [x3], #64
+
+       WORD $0x4c407801 // ld1 {v1.4s}, [x0]
+       WORD $0x4cdf2878 // ld1 {v24.4s-v27.4s}, [x3], #64
+       WORD $0xd1004000 // sub x0, x0, #0x10
+       WORD $0x4cdf287c // ld1 {v28.4s-v31.4s}, [x3], #64
+
+loop:
+       // Main loop
+       WORD $0x4cdf2025 // ld1 {v5.16b-v8.16b}, [x1], #64
+       WORD $0x4ea01c02 // mov v2.16b, v0.16b
+       WORD $0x4ea11c23 // mov v3.16b, v1.16b
+       WORD $0x6e2008a5 // rev32       v5.16b, v5.16b
+       WORD $0x6e2008c6 // rev32       v6.16b, v6.16b
+       WORD $0x4eb084a9 // add v9.4s, v5.4s, v16.4s
+       WORD $0x6e2008e7 // rev32       v7.16b, v7.16b
+       WORD $0x4eb184ca // add v10.4s, v6.4s, v17.4s
+       WORD $0x4ea21c44 // mov v4.16b, v2.16b
+       WORD $0x5e094062 // sha256h     q2, q3, v9.4s
+       WORD $0x5e095083 // sha256h2    q3, q4, v9.4s
+       WORD $0x5e2828c5 // sha256su0   v5.4s, v6.4s
+       WORD $0x6e200908 // rev32       v8.16b, v8.16b
+       WORD $0x4eb284e9 // add v9.4s, v7.4s, v18.4s
+       WORD $0x4ea21c44 // mov v4.16b, v2.16b
+       WORD $0x5e0a4062 // sha256h     q2, q3, v10.4s
+       WORD $0x5e0a5083 // sha256h2    q3, q4, v10.4s
+       WORD $0x5e2828e6 // sha256su0   v6.4s, v7.4s
+       WORD $0x5e0860e5 // sha256su1   v5.4s, v7.4s, v8.4s
+       WORD $0x4eb3850a // add v10.4s, v8.4s, v19.4s
+       WORD $0x4ea21c44 // mov v4.16b, v2.16b
+       WORD $0x5e094062 // sha256h     q2, q3, v9.4s
+       WORD $0x5e095083 // sha256h2    q3, q4, v9.4s
+       WORD $0x5e282907 // sha256su0   v7.4s, v8.4s
+       WORD $0x5e056106 // sha256su1   v6.4s, v8.4s, v5.4s
+       WORD $0x4eb484a9 // add v9.4s, v5.4s, v20.4s
+       WORD $0x4ea21c44 // mov v4.16b, v2.16b
+       WORD $0x5e0a4062 // sha256h     q2, q3, v10.4s
+       WORD $0x5e0a5083 // sha256h2    q3, q4, v10.4s
+       WORD $0x5e2828a8 // sha256su0   v8.4s, v5.4s
+       WORD $0x5e0660a7 // sha256su1   v7.4s, v5.4s, v6.4s
+       WORD $0x4eb584ca // add v10.4s, v6.4s, v21.4s
+       WORD $0x4ea21c44 // mov v4.16b, v2.16b
+       WORD $0x5e094062 // sha256h     q2, q3, v9.4s
+       WORD $0x5e095083 // sha256h2    q3, q4, v9.4s
+       WORD $0x5e2828c5 // sha256su0   v5.4s, v6.4s
+       WORD $0x5e0760c8 // sha256su1   v8.4s, v6.4s, v7.4s
+       WORD $0x4eb684e9 // add v9.4s, v7.4s, v22.4s
+       WORD $0x4ea21c44 // mov v4.16b, v2.16b
+       WORD $0x5e0a4062 // sha256h     q2, q3, v10.4s
+       WORD $0x5e0a5083 // sha256h2    q3, q4, v10.4s
+       WORD $0x5e2828e6 // sha256su0   v6.4s, v7.4s
+       WORD $0x5e0860e5 // sha256su1   v5.4s, v7.4s, v8.4s
+       WORD $0x4eb7850a // add v10.4s, v8.4s, v23.4s
+       WORD $0x4ea21c44 // mov v4.16b, v2.16b
+       WORD $0x5e094062 // sha256h     q2, q3, v9.4s
+       WORD $0x5e095083 // sha256h2    q3, q4, v9.4s
+       WORD $0x5e282907 // sha256su0   v7.4s, v8.4s
+       WORD $0x5e056106 // sha256su1   v6.4s, v8.4s, v5.4s
+       WORD $0x4eb884a9 // add v9.4s, v5.4s, v24.4s
+       WORD $0x4ea21c44 // mov v4.16b, v2.16b
+       WORD $0x5e0a4062 // sha256h     q2, q3, v10.4s
+       WORD $0x5e0a5083 // sha256h2    q3, q4, v10.4s
+       WORD $0x5e2828a8 // sha256su0   v8.4s, v5.4s
+       WORD $0x5e0660a7 // sha256su1   v7.4s, v5.4s, v6.4s
+       WORD $0x4eb984ca // add v10.4s, v6.4s, v25.4s
+       WORD $0x4ea21c44 // mov v4.16b, v2.16b
+       WORD $0x5e094062 // sha256h     q2, q3, v9.4s
+       WORD $0x5e095083 // sha256h2    q3, q4, v9.4s
+       WORD $0x5e2828c5 // sha256su0   v5.4s, v6.4s
+       WORD $0x5e0760c8 // sha256su1   v8.4s, v6.4s, v7.4s
+       WORD $0x4eba84e9 // add v9.4s, v7.4s, v26.4s
+       WORD $0x4ea21c44 // mov v4.16b, v2.16b
+       WORD $0x5e0a4062 // sha256h     q2, q3, v10.4s
+       WORD $0x5e0a5083 // sha256h2    q3, q4, v10.4s
+       WORD $0x5e2828e6 // sha256su0   v6.4s, v7.4s
+       WORD $0x5e0860e5 // sha256su1   v5.4s, v7.4s, v8.4s
+       WORD $0x4ebb850a // add v10.4s, v8.4s, v27.4s
+       WORD $0x4ea21c44 // mov v4.16b, v2.16b
+       WORD $0x5e094062 // sha256h     q2, q3, v9.4s
+       WORD $0x5e095083 // sha256h2    q3, q4, v9.4s
+       WORD $0x5e282907 // sha256su0   v7.4s, v8.4s
+       WORD $0x5e056106 // sha256su1   v6.4s, v8.4s, v5.4s
+       WORD $0x4ebc84a9 // add v9.4s, v5.4s, v28.4s
+       WORD $0x4ea21c44 // mov v4.16b, v2.16b
+       WORD $0x5e0a4062 // sha256h     q2, q3, v10.4s
+       WORD $0x5e0a5083 // sha256h2    q3, q4, v10.4s
+       WORD $0x5e2828a8 // sha256su0   v8.4s, v5.4s
+       WORD $0x5e0660a7 // sha256su1   v7.4s, v5.4s, v6.4s
+       WORD $0x4ebd84ca // add v10.4s, v6.4s, v29.4s
+       WORD $0x4ea21c44 // mov v4.16b, v2.16b
+       WORD $0x5e094062 // sha256h     q2, q3, v9.4s
+       WORD $0x5e095083 // sha256h2    q3, q4, v9.4s
+       WORD $0x5e0760c8 // sha256su1   v8.4s, v6.4s, v7.4s
+       WORD $0x4ebe84e9 // add v9.4s, v7.4s, v30.4s
+       WORD $0x4ea21c44 // mov v4.16b, v2.16b
+       WORD $0x5e0a4062 // sha256h     q2, q3, v10.4s
+       WORD $0x5e0a5083 // sha256h2    q3, q4, v10.4s
+       WORD $0x4ebf850a // add v10.4s, v8.4s, v31.4s
+       WORD $0x4ea21c44 // mov v4.16b, v2.16b
+       WORD $0x5e094062 // sha256h     q2, q3, v9.4s
+       WORD $0x5e095083 // sha256h2    q3, q4, v9.4s
+       WORD $0x4ea21c44 // mov v4.16b, v2.16b
+       WORD $0x5e0a4062 // sha256h     q2, q3, v10.4s
+       WORD $0x5e0a5083 // sha256h2    q3, q4, v10.4s
+       WORD $0x4ea38421 // add v1.4s, v1.4s, v3.4s
+       WORD $0x4ea28400 // add v0.4s, v0.4s, v2.4s
+
+       SUBS $64, R2
+       BPL  loop
+
+       // Store result
+       WORD $0x4c00a800 // st1 {v0.4s, v1.4s}, [x0]
+
+complete:
+       RET
+
+// Constants table
+DATA ·constants+0x0(SB)/8, $0x71374491428a2f98
+DATA ·constants+0x8(SB)/8, $0xe9b5dba5b5c0fbcf
+DATA ·constants+0x10(SB)/8, $0x59f111f13956c25b
+DATA ·constants+0x18(SB)/8, $0xab1c5ed5923f82a4
+DATA ·constants+0x20(SB)/8, $0x12835b01d807aa98
+DATA ·constants+0x28(SB)/8, $0x550c7dc3243185be
+DATA ·constants+0x30(SB)/8, $0x80deb1fe72be5d74
+DATA ·constants+0x38(SB)/8, $0xc19bf1749bdc06a7
+DATA ·constants+0x40(SB)/8, $0xefbe4786e49b69c1
+DATA ·constants+0x48(SB)/8, $0x240ca1cc0fc19dc6
+DATA ·constants+0x50(SB)/8, $0x4a7484aa2de92c6f
+DATA ·constants+0x58(SB)/8, $0x76f988da5cb0a9dc
+DATA ·constants+0x60(SB)/8, $0xa831c66d983e5152
+DATA ·constants+0x68(SB)/8, $0xbf597fc7b00327c8
+DATA ·constants+0x70(SB)/8, $0xd5a79147c6e00bf3
+DATA ·constants+0x78(SB)/8, $0x1429296706ca6351
+DATA ·constants+0x80(SB)/8, $0x2e1b213827b70a85
+DATA ·constants+0x88(SB)/8, $0x53380d134d2c6dfc
+DATA ·constants+0x90(SB)/8, $0x766a0abb650a7354
+DATA ·constants+0x98(SB)/8, $0x92722c8581c2c92e
+DATA ·constants+0xa0(SB)/8, $0xa81a664ba2bfe8a1
+DATA ·constants+0xa8(SB)/8, $0xc76c51a3c24b8b70
+DATA ·constants+0xb0(SB)/8, $0xd6990624d192e819
+DATA ·constants+0xb8(SB)/8, $0x106aa070f40e3585
+DATA ·constants+0xc0(SB)/8, $0x1e376c0819a4c116
+DATA ·constants+0xc8(SB)/8, $0x34b0bcb52748774c
+DATA ·constants+0xd0(SB)/8, $0x4ed8aa4a391c0cb3
+DATA ·constants+0xd8(SB)/8, $0x682e6ff35b9cca4f
+DATA ·constants+0xe0(SB)/8, $0x78a5636f748f82ee
+DATA ·constants+0xe8(SB)/8, $0x8cc7020884c87814
+DATA ·constants+0xf0(SB)/8, $0xa4506ceb90befffa
+DATA ·constants+0xf8(SB)/8, $0xc67178f2bef9a3f7
+
+GLOBL ·constants(SB), 8, $256
+

diff --git a/vendor/github.com/minio/sha256-simd/sha256block_noasm.go b/vendor/github.com/minio/sha256-simd/sha256block_noasm.go
new file mode 100644 (file)
index 0000000..356ca53
--- /dev/null
+++ b/vendor/github.com/minio/sha256-simd/sha256block_noasm.go
@@ -0,0 +1,136 @@
+//+build !arm64 !amd64 noasm appengine
+
+/*
+ * Minio Cloud Storage, (C) 2016 Minio, Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package sha256
+
+func blockGeneric(dig *digest, p []byte) {
+       var w [64]uint32
+       h0, h1, h2, h3, h4, h5, h6, h7 := dig.h[0], dig.h[1], dig.h[2], dig.h[3], dig.h[4], dig.h[5], dig.h[6], dig.h[7]
+       for len(p) >= chunk {
+               // Can interlace the computation of w with the
+               // rounds below if needed for speed.
+               for i := 0; i < 16; i++ {
+                       j := i * 4
+                       w[i] = uint32(p[j])<<24 | uint32(p[j+1])<<16 | uint32(p[j+2])<<8 | uint32(p[j+3])
+               }
+               for i := 16; i < 64; i++ {
+                       v1 := w[i-2]
+                       t1 := (v1>>17 | v1<<(32-17)) ^ (v1>>19 | v1<<(32-19)) ^ (v1 >> 10)
+                       v2 := w[i-15]
+                       t2 := (v2>>7 | v2<<(32-7)) ^ (v2>>18 | v2<<(32-18)) ^ (v2 >> 3)
+                       w[i] = t1 + w[i-7] + t2 + w[i-16]
+               }
+
+               a, b, c, d, e, f, g, h := h0, h1, h2, h3, h4, h5, h6, h7
+
+               for i := 0; i < 64; i++ {
+                       t1 := h + ((e>>6 | e<<(32-6)) ^ (e>>11 | e<<(32-11)) ^ (e>>25 | e<<(32-25))) + ((e & f) ^ (^e & g)) + _K[i] + w[i]
+
+                       t2 := ((a>>2 | a<<(32-2)) ^ (a>>13 | a<<(32-13)) ^ (a>>22 | a<<(32-22))) + ((a & b) ^ (a & c) ^ (b & c))
+
+                       h = g
+                       g = f
+                       f = e
+                       e = d + t1
+                       d = c
+                       c = b
+                       b = a
+                       a = t1 + t2
+               }
+
+               h0 += a
+               h1 += b
+               h2 += c
+               h3 += d
+               h4 += e
+               h5 += f
+               h6 += g
+               h7 += h
+
+               p = p[chunk:]
+       }
+
+       dig.h[0], dig.h[1], dig.h[2], dig.h[3], dig.h[4], dig.h[5], dig.h[6], dig.h[7] = h0, h1, h2, h3, h4, h5, h6, h7
+}
+
+var _K = []uint32{
+       0x428a2f98,
+       0x71374491,
+       0xb5c0fbcf,
+       0xe9b5dba5,
+       0x3956c25b,
+       0x59f111f1,
+       0x923f82a4,
+       0xab1c5ed5,
+       0xd807aa98,
+       0x12835b01,
+       0x243185be,
+       0x550c7dc3,
+       0x72be5d74,
+       0x80deb1fe,
+       0x9bdc06a7,
+       0xc19bf174,
+       0xe49b69c1,
+       0xefbe4786,
+       0x0fc19dc6,
+       0x240ca1cc,
+       0x2de92c6f,
+       0x4a7484aa,
+       0x5cb0a9dc,
+       0x76f988da,
+       0x983e5152,
+       0xa831c66d,
+       0xb00327c8,
+       0xbf597fc7,
+       0xc6e00bf3,
+       0xd5a79147,
+       0x06ca6351,
+       0x14292967,
+       0x27b70a85,
+       0x2e1b2138,
+       0x4d2c6dfc,
+       0x53380d13,
+       0x650a7354,
+       0x766a0abb,
+       0x81c2c92e,
+       0x92722c85,
+       0xa2bfe8a1,
+       0xa81a664b,
+       0xc24b8b70,
+       0xc76c51a3,
+       0xd192e819,
+       0xd6990624,
+       0xf40e3585,
+       0x106aa070,
+       0x19a4c116,
+       0x1e376c08,
+       0x2748774c,
+       0x34b0bcb5,
+       0x391c0cb3,
+       0x4ed8aa4a,
+       0x5b9cca4f,
+       0x682e6ff3,
+       0x748f82ee,
+       0x78a5636f,
+       0x84c87814,
+       0x8cc70208,
+       0x90befffa,
+       0xa4506ceb,
+       0xbef9a3f7,
+       0xc67178f2,
+}

diff --git a/vendor/github.com/minio/sha256-simd/sha256block_other.go b/vendor/github.com/minio/sha256-simd/sha256block_other.go
new file mode 100644 (file)
index 0000000..d1893dd
--- /dev/null
+++ b/vendor/github.com/minio/sha256-simd/sha256block_other.go
@@ -0,0 +1,24 @@
+// Minio Cloud Storage, (C) 2016 Minio, Inc.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+
+// +build ppc64 ppc64le mips mipsle mips64 mips64le s390x wasm
+
+package sha256
+
+func blockAvx2Go(dig *digest, p []byte) {}
+func blockAvxGo(dig *digest, p []byte)  {}
+func blockSsseGo(dig *digest, p []byte) {}
+func blockShaGo(dig *digest, p []byte)  {}
+func blockArmGo(dig *digest, p []byte)  {}

diff --git a/vendor/github.com/mitchellh/go-homedir/LICENSE b/vendor/github.com/mitchellh/go-homedir/LICENSE
new file mode 100644 (file)
index 0000000..f9c841a
--- /dev/null
+++ b/vendor/github.com/mitchellh/go-homedir/LICENSE
@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2013 Mitchell Hashimoto
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

diff --git a/vendor/github.com/mitchellh/go-homedir/README.md b/vendor/github.com/mitchellh/go-homedir/README.md
new file mode 100644 (file)
index 0000000..d70706d
--- /dev/null
+++ b/vendor/github.com/mitchellh/go-homedir/README.md
@@ -0,0 +1,14 @@
+# go-homedir
+
+This is a Go library for detecting the user's home directory without
+the use of cgo, so the library can be used in cross-compilation environments.
+
+Usage is incredibly simple, just call `homedir.Dir()` to get the home directory
+for a user, and `homedir.Expand()` to expand the `~` in a path to the home
+directory.
+
+**Why not just use `os/user`?** The built-in `os/user` package requires
+cgo on Darwin systems. This means that any Go code that uses that package
+cannot cross compile. But 99% of the time the use for `os/user` is just to
+retrieve the home directory, which we can do for the current user without
+cgo. This library does that, enabling cross-compilation.

diff --git a/vendor/github.com/mitchellh/go-homedir/go.mod b/vendor/github.com/mitchellh/go-homedir/go.mod
new file mode 100644 (file)
index 0000000..7efa09a
--- /dev/null
+++ b/vendor/github.com/mitchellh/go-homedir/go.mod
@@ -0,0 +1 @@
+module github.com/mitchellh/go-homedir

diff --git a/vendor/github.com/mitchellh/go-homedir/homedir.go b/vendor/github.com/mitchellh/go-homedir/homedir.go
new file mode 100644 (file)
index 0000000..2537853
--- /dev/null
+++ b/vendor/github.com/mitchellh/go-homedir/homedir.go
@@ -0,0 +1,167 @@
+package homedir
+
+import (
+       "bytes"
+       "errors"
+       "os"
+       "os/exec"
+       "path/filepath"
+       "runtime"
+       "strconv"
+       "strings"
+       "sync"
+)
+
+// DisableCache will disable caching of the home directory. Caching is enabled
+// by default.
+var DisableCache bool
+
+var homedirCache string
+var cacheLock sync.RWMutex
+
+// Dir returns the home directory for the executing user.
+//
+// This uses an OS-specific method for discovering the home directory.
+// An error is returned if a home directory cannot be detected.
+func Dir() (string, error) {
+       if !DisableCache {
+               cacheLock.RLock()
+               cached := homedirCache
+               cacheLock.RUnlock()
+               if cached != "" {
+                       return cached, nil
+               }
+       }
+
+       cacheLock.Lock()
+       defer cacheLock.Unlock()
+
+       var result string
+       var err error
+       if runtime.GOOS == "windows" {
+               result, err = dirWindows()
+       } else {
+               // Unix-like system, so just assume Unix
+               result, err = dirUnix()
+       }
+
+       if err != nil {
+               return "", err
+       }
+       homedirCache = result
+       return result, nil
+}
+
+// Expand expands the path to include the home directory if the path
+// is prefixed with `~`. If it isn't prefixed with `~`, the path is
+// returned as-is.
+func Expand(path string) (string, error) {
+       if len(path) == 0 {
+               return path, nil
+       }
+
+       if path[0] != '~' {
+               return path, nil
+       }
+
+       if len(path) > 1 && path[1] != '/' && path[1] != '\\' {
+               return "", errors.New("cannot expand user-specific home dir")
+       }
+
+       dir, err := Dir()
+       if err != nil {
+               return "", err
+       }
+
+       return filepath.Join(dir, path[1:]), nil
+}
+
+// Reset clears the cache, forcing the next call to Dir to re-detect
+// the home directory. This generally never has to be called, but can be
+// useful in tests if you're modifying the home directory via the HOME
+// env var or something.
+func Reset() {
+       cacheLock.Lock()
+       defer cacheLock.Unlock()
+       homedirCache = ""
+}
+
+func dirUnix() (string, error) {
+       homeEnv := "HOME"
+       if runtime.GOOS == "plan9" {
+               // On plan9, env vars are lowercase.
+               homeEnv = "home"
+       }
+
+       // First prefer the HOME environmental variable
+       if home := os.Getenv(homeEnv); home != "" {
+               return home, nil
+       }
+
+       var stdout bytes.Buffer
+
+       // If that fails, try OS specific commands
+       if runtime.GOOS == "darwin" {
+               cmd := exec.Command("sh", "-c", `dscl -q . -read /Users/"$(whoami)" NFSHomeDirectory | sed 's/^[^ ]*: //'`)
+               cmd.Stdout = &stdout
+               if err := cmd.Run(); err == nil {
+                       result := strings.TrimSpace(stdout.String())
+                       if result != "" {
+                               return result, nil
+                       }
+               }
+       } else {
+               cmd := exec.Command("getent", "passwd", strconv.Itoa(os.Getuid()))
+               cmd.Stdout = &stdout
+               if err := cmd.Run(); err != nil {
+                       // If the error is ErrNotFound, we ignore it. Otherwise, return it.
+                       if err != exec.ErrNotFound {
+                               return "", err
+                       }
+               } else {
+                       if passwd := strings.TrimSpace(stdout.String()); passwd != "" {
+                               // username:password:uid:gid:gecos:home:shell
+                               passwdParts := strings.SplitN(passwd, ":", 7)
+                               if len(passwdParts) > 5 {
+                                       return passwdParts[5], nil
+                               }
+                       }
+               }
+       }
+
+       // If all else fails, try the shell
+       stdout.Reset()
+       cmd := exec.Command("sh", "-c", "cd && pwd")
+       cmd.Stdout = &stdout
+       if err := cmd.Run(); err != nil {
+               return "", err
+       }
+
+       result := strings.TrimSpace(stdout.String())
+       if result == "" {
+               return "", errors.New("blank output when reading home directory")
+       }
+
+       return result, nil
+}
+
+func dirWindows() (string, error) {
+       // First prefer the HOME environmental variable
+       if home := os.Getenv("HOME"); home != "" {
+               return home, nil
+       }
+
+       // Prefer standard environment variable USERPROFILE
+       if home := os.Getenv("USERPROFILE"); home != "" {
+               return home, nil
+       }
+
+       drive := os.Getenv("HOMEDRIVE")
+       path := os.Getenv("HOMEPATH")
+       home := drive + path
+       if drive == "" || path == "" {
+               return "", errors.New("HOMEDRIVE, HOMEPATH, or USERPROFILE are blank")
+       }
+
+       return home, nil
+}

diff --git a/vendor/github.com/mitchellh/go-homedir/homedir_test.go b/vendor/github.com/mitchellh/go-homedir/homedir_test.go
new file mode 100644 (file)
index 0000000..cd52127
--- /dev/null
+++ b/vendor/github.com/mitchellh/go-homedir/homedir_test.go
@@ -0,0 +1,129 @@
+package homedir
+
+import (
+       "os"
+       "os/user"
+       "path/filepath"
+       "testing"
+)
+
+func patchEnv(key, value string) func() {
+       bck := os.Getenv(key)
+       deferFunc := func() {
+               os.Setenv(key, bck)
+       }
+
+       if value != "" {
+               os.Setenv(key, value)
+       } else {
+               os.Unsetenv(key)
+       }
+
+       return deferFunc
+}
+
+func BenchmarkDir(b *testing.B) {
+       // We do this for any "warmups"
+       for i := 0; i < 10; i++ {
+               Dir()
+       }
+
+       b.ResetTimer()
+       for i := 0; i < b.N; i++ {
+               Dir()
+       }
+}
+
+func TestDir(t *testing.T) {
+       u, err := user.Current()
+       if err != nil {
+               t.Fatalf("err: %s", err)
+       }
+
+       dir, err := Dir()
+       if err != nil {
+               t.Fatalf("err: %s", err)
+       }
+
+       if u.HomeDir != dir {
+               t.Fatalf("%#v != %#v", u.HomeDir, dir)
+       }
+
+       DisableCache = true
+       defer func() { DisableCache = false }()
+       defer patchEnv("HOME", "")()
+       dir, err = Dir()
+       if err != nil {
+               t.Fatalf("err: %s", err)
+       }
+
+       if u.HomeDir != dir {
+               t.Fatalf("%#v != %#v", u.HomeDir, dir)
+       }
+}
+
+func TestExpand(t *testing.T) {
+       u, err := user.Current()
+       if err != nil {
+               t.Fatalf("err: %s", err)
+       }
+
+       cases := []struct {
+               Input  string
+               Output string
+               Err    bool
+       }{
+               {
+                       "/foo",
+                       "/foo",
+                       false,
+               },
+
+               {
+                       "~/foo",
+                       filepath.Join(u.HomeDir, "foo"),
+                       false,
+               },
+
+               {
+                       "",
+                       "",
+                       false,
+               },
+
+               {
+                       "~",
+                       u.HomeDir,
+                       false,
+               },
+
+               {
+                       "~foo/foo",
+                       "",
+                       true,
+               },
+       }
+
+       for _, tc := range cases {
+               actual, err := Expand(tc.Input)
+               if (err != nil) != tc.Err {
+                       t.Fatalf("Input: %#v\n\nErr: %s", tc.Input, err)
+               }
+
+               if actual != tc.Output {
+                       t.Fatalf("Input: %#v\n\nOutput: %#v", tc.Input, actual)
+               }
+       }
+
+       DisableCache = true
+       defer func() { DisableCache = false }()
+       defer patchEnv("HOME", "/custom/path/")()
+       expected := filepath.Join("/", "custom", "path", "foo/bar")
+       actual, err := Expand("~/foo/bar")
+
+       if err != nil {
+               t.Errorf("No error is expected, got: %v", err)
+       } else if actual != expected {
+               t.Errorf("Expected: %v; actual: %v", expected, actual)
+       }
+}

diff --git a/vendor/github.com/mr-tron/base58/.gitignore b/vendor/github.com/mr-tron/base58/.gitignore
new file mode 100644 (file)
index 0000000..9f11b75
--- /dev/null
+++ b/vendor/github.com/mr-tron/base58/.gitignore
@@ -0,0 +1 @@
+.idea/

diff --git a/vendor/github.com/mr-tron/base58/LICENSE b/vendor/github.com/mr-tron/base58/LICENSE
new file mode 100644 (file)
index 0000000..cb7829a
--- /dev/null
+++ b/vendor/github.com/mr-tron/base58/LICENSE
@@ -0,0 +1,23 @@
+MIT License
+
+Copyright (c) 2017 Denis Subbotin
+Copyright (c) 2017 Nika Jones
+Copyright (c) 2017 Philip Schlump
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

diff --git a/vendor/github.com/mr-tron/base58/README.md b/vendor/github.com/mr-tron/base58/README.md
new file mode 100644 (file)
index 0000000..98b2fa2
--- /dev/null
+++ b/vendor/github.com/mr-tron/base58/README.md
@@ -0,0 +1,47 @@
+# Fast Implementation of Base58 encoding
+[![GoDoc](https://godoc.org/github.com/mr-tron/base58?status.svg)](https://godoc.org/github.com/mr-tron/base58)  [![Go Report Card](https://goreportcard.com/badge/github.com/mr-tron/base58)](https://goreportcard.com/report/github.com/mr-tron/base58)
+[![Used By](https://sourcegraph.com/github.com/mr-tron/base58/base58/-/badge.svg)](https://sourcegraph.com/github.com/mr-tron/base58?badge)
+
+Fast implementation of base58 encoding in Go. 
+
+Base algorithm is copied from https://github.com/trezor/trezor-crypto/blob/master/base58.c
+
+## Benchmark
+Trivial - encoding via big.Int (over libraries use this implemenation)
+Fast - optimized algorythm from trezor
+
+```
+BenchmarkTrivialBase58Encoding-4         200000             10602 ns/op  
+BenchmarkFastBase58Encoding-4           1000000              1637 ns/op
+BenchmarkTrivialBase58Decoding-4         200000              8316 ns/op
+BenchmarkFastBase58Decoding-4           1000000              1045 ns/op
+```
+Encoding - **faster by 6 times**
+
+Decoding - **faster by 8 times**
+
+## Usage example
+
+```go
+
+package main
+
+import (
+       "fmt"
+       "github.com/mr-tron/base58"
+)
+
+func main() {
+
+       encoded := "1QCaxc8hutpdZ62iKZsn1TCG3nh7uPZojq"
+       num, err := base58.Decode(encoded)
+       if err != nil {
+               fmt.Printf("Demo %v, got error %s\n", encoded, err)     
+       }
+       chk := base58.Encode(num)
+       if encoded == string(chk) {
+               fmt.Printf ( "Successfully decoded then re-encoded %s\n", encoded )
+       } 
+}
+
+```

diff --git a/vendor/github.com/mr-tron/base58/alphabet.go b/vendor/github.com/mr-tron/base58/alphabet.go
new file mode 100644 (file)
index 0000000..a0f8878
--- /dev/null
+++ b/vendor/github.com/mr-tron/base58/alphabet.go
@@ -0,0 +1,31 @@
+package base58
+
+// Alphabet is a a b58 alphabet.
+type Alphabet struct {
+       decode [128]int8
+       encode [58]byte
+}
+
+// NewAlphabet creates a new alphabet from the passed string.
+//
+// It panics if the passed string is not 58 bytes long or isn't valid ASCII.
+func NewAlphabet(s string) *Alphabet {
+       if len(s) != 58 {
+               panic("base58 alphabets must be 58 bytes long")
+       }
+       ret := new(Alphabet)
+       copy(ret.encode[:], s)
+       for i := range ret.decode {
+               ret.decode[i] = -1
+       }
+       for i, b := range ret.encode {
+               ret.decode[b] = int8(i)
+       }
+       return ret
+}
+
+// BTCAlphabet is the bitcoin base58 alphabet.
+var BTCAlphabet = NewAlphabet("123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz")
+
+// FlickrAlphabet is the flickr base58 alphabet.
+var FlickrAlphabet = NewAlphabet("123456789abcdefghijkmnopqrstuvwxyzABCDEFGHJKLMNPQRSTUVWXYZ")

diff --git a/vendor/github.com/mr-tron/base58/base58.go b/vendor/github.com/mr-tron/base58/base58.go
new file mode 100644 (file)
index 0000000..6835d58
--- /dev/null
+++ b/vendor/github.com/mr-tron/base58/base58.go
@@ -0,0 +1,163 @@
+package base58
+
+import (
+       "fmt"
+)
+
+// Encode encodes the passed bytes into a base58 encoded string.
+func Encode(bin []byte) string {
+       return FastBase58EncodingAlphabet(bin, BTCAlphabet)
+}
+
+// EncodeAlphabet encodes the passed bytes into a base58 encoded string with the
+// passed alphabet.
+func EncodeAlphabet(bin []byte, alphabet *Alphabet) string {
+       return FastBase58EncodingAlphabet(bin, alphabet)
+}
+
+// FastBase58Encoding encodes the passed bytes into a base58 encoded string.
+func FastBase58Encoding(bin []byte) string {
+       return FastBase58EncodingAlphabet(bin, BTCAlphabet)
+}
+
+// FastBase58EncodingAlphabet encodes the passed bytes into a base58 encoded
+// string with the passed alphabet.
+func FastBase58EncodingAlphabet(bin []byte, alphabet *Alphabet) string {
+       zero := alphabet.encode[0]
+
+       binsz := len(bin)
+       var i, j, zcount, high int
+       var carry uint32
+
+       for zcount < binsz && bin[zcount] == 0 {
+               zcount++
+       }
+
+       size := (binsz-zcount)*138/100 + 1
+       var buf = make([]uint32, size)
+
+       high = size - 1
+       for i = zcount; i < binsz; i++ {
+               j = size - 1
+               for carry = uint32(bin[i]); j > high || carry != 0; j-- {
+                       carry += buf[j] << 8
+                       buf[j] = carry % 58
+                       carry /= 58
+               }
+               high = j
+       }
+
+       for j = 0; j < size && buf[j] == 0; j++ {
+       }
+
+       var b58 = make([]byte, size-j+zcount)
+
+       if zcount != 0 {
+               for i = 0; i < zcount; i++ {
+                       b58[i] = zero
+               }
+       }
+
+       for i = zcount; j < size; i++ {
+               b58[i] = alphabet.encode[buf[j]]
+               j++
+       }
+
+       return string(b58)
+}
+
+// Decode decodes the base58 encoded bytes.
+func Decode(str string) ([]byte, error) {
+       return FastBase58DecodingAlphabet(str, BTCAlphabet)
+}
+
+// DecodeAlphabet decodes the base58 encoded bytes using the given b58 alphabet.
+func DecodeAlphabet(str string, alphabet *Alphabet) ([]byte, error) {
+       return FastBase58DecodingAlphabet(str, alphabet)
+}
+
+// FastBase58Decoding decodes the base58 encoded bytes.
+func FastBase58Decoding(str string) ([]byte, error) {
+       return FastBase58DecodingAlphabet(str, BTCAlphabet)
+}
+
+// FastBase58DecodingAlphabet decodes the base58 encoded bytes using the given
+// b58 alphabet.
+func FastBase58DecodingAlphabet(str string, alphabet *Alphabet) ([]byte, error) {
+       if len(str) == 0 {
+               return nil, fmt.Errorf("zero length string")
+       }
+
+       var (
+               t, c   uint64
+               zmask  uint32
+               zcount int
+
+               b58u  = []rune(str)
+               b58sz = len(b58u)
+
+               outisz    = (b58sz + 3) >> 2
+               binu      = make([]byte, (b58sz+3)*3)
+               bytesleft = b58sz & 3
+
+               zero = rune(alphabet.encode[0])
+       )
+
+       if bytesleft > 0 {
+               zmask = 0xffffffff << uint32(bytesleft*8)
+       } else {
+               bytesleft = 4
+       }
+
+       var outi = make([]uint32, outisz)
+
+       for i := 0; i < b58sz && b58u[i] == zero; i++ {
+               zcount++
+       }
+
+       for _, r := range b58u {
+               if r > 127 {
+                       return nil, fmt.Errorf("high-bit set on invalid digit")
+               }
+               if alphabet.decode[r] == -1 {
+                       return nil, fmt.Errorf("invalid base58 digit (%q)", r)
+               }
+
+               c = uint64(alphabet.decode[r])
+
+               for j := outisz - 1; j >= 0; j-- {
+                       t = uint64(outi[j])*58 + c
+                       c = (t >> 32) & 0x3f
+                       outi[j] = uint32(t & 0xffffffff)
+               }
+
+               if c > 0 {
+                       return nil, fmt.Errorf("output number too big (carry to the next int32)")
+               }
+
+               if outi[0]&zmask != 0 {
+                       return nil, fmt.Errorf("output number too big (last int32 filled too far)")
+               }
+       }
+
+       var j, cnt int
+       for j, cnt = 0, 0; j < outisz; j++ {
+               for mask := byte(bytesleft-1) * 8; mask <= 0x18; mask, cnt = mask-8, cnt+1 {
+                       binu[cnt] = byte(outi[j] >> mask)
+               }
+               if j == 0 {
+                       bytesleft = 4 // because it could be less than 4 the first time through
+               }
+       }
+
+       for n, v := range binu {
+               if v > 0 {
+                       start := n - zcount
+                       if start < 0 {
+                               start = 0
+                       }
+                       return binu[start:cnt], nil
+               }
+       }
+       return binu[:cnt], nil
+}

diff --git a/vendor/github.com/mr-tron/base58/base58/DEPRECATED.md b/vendor/github.com/mr-tron/base58/base58/DEPRECATED.md
new file mode 100644 (file)
index 0000000..0cc7ec7
--- /dev/null
+++ b/vendor/github.com/mr-tron/base58/base58/DEPRECATED.md
@@ -0,0 +1,4 @@
+Files from this directory was copied to level up directory 
+==========================================================
+
+Now all development will be on top level
\ No newline at end of file

diff --git a/vendor/github.com/mr-tron/base58/base58/alphabet.go b/vendor/github.com/mr-tron/base58/base58/alphabet.go
new file mode 100644 (file)
index 0000000..a0f8878
--- /dev/null
+++ b/vendor/github.com/mr-tron/base58/base58/alphabet.go
@@ -0,0 +1,31 @@
+package base58
+
+// Alphabet is a a b58 alphabet.
+type Alphabet struct {
+       decode [128]int8
+       encode [58]byte
+}
+
+// NewAlphabet creates a new alphabet from the passed string.
+//
+// It panics if the passed string is not 58 bytes long or isn't valid ASCII.
+func NewAlphabet(s string) *Alphabet {
+       if len(s) != 58 {
+               panic("base58 alphabets must be 58 bytes long")
+       }
+       ret := new(Alphabet)
+       copy(ret.encode[:], s)
+       for i := range ret.decode {
+               ret.decode[i] = -1
+       }
+       for i, b := range ret.encode {
+               ret.decode[b] = int8(i)
+       }
+       return ret
+}
+
+// BTCAlphabet is the bitcoin base58 alphabet.
+var BTCAlphabet = NewAlphabet("123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz")
+
+// FlickrAlphabet is the flickr base58 alphabet.
+var FlickrAlphabet = NewAlphabet("123456789abcdefghijkmnopqrstuvwxyzABCDEFGHJKLMNPQRSTUVWXYZ")

diff --git a/vendor/github.com/mr-tron/base58/base58/base58.go b/vendor/github.com/mr-tron/base58/base58/base58.go
new file mode 100644 (file)
index 0000000..b8810b7
--- /dev/null
+++ b/vendor/github.com/mr-tron/base58/base58/base58.go
@@ -0,0 +1,255 @@
+package base58
+
+import (
+       "fmt"
+       "math/big"
+)
+
+var (
+       bn0  = big.NewInt(0)
+       bn58 = big.NewInt(58)
+)
+
+// Encode encodes the passed bytes into a base58 encoded string.
+func Encode(bin []byte) string {
+       return FastBase58Encoding(bin)
+}
+
+// EncodeAlphabet encodes the passed bytes into a base58 encoded string with the
+// passed alphabet.
+func EncodeAlphabet(bin []byte, alphabet *Alphabet) string {
+       return FastBase58EncodingAlphabet(bin, alphabet)
+}
+
+// FastBase58Encoding encodes the passed bytes into a base58 encoded string.
+func FastBase58Encoding(bin []byte) string {
+       return FastBase58EncodingAlphabet(bin, BTCAlphabet)
+}
+
+// FastBase58EncodingAlphabet encodes the passed bytes into a base58 encoded
+// string with the passed alphabet.
+func FastBase58EncodingAlphabet(bin []byte, alphabet *Alphabet) string {
+       zero := alphabet.encode[0]
+
+       binsz := len(bin)
+       var i, j, zcount, high int
+       var carry uint32
+
+       for zcount < binsz && bin[zcount] == 0 {
+               zcount++
+       }
+
+       size := (binsz-zcount)*138/100 + 1
+       var buf = make([]byte, size)
+
+       high = size - 1
+       for i = zcount; i < binsz; i++ {
+               j = size - 1
+               for carry = uint32(bin[i]); j > high || carry != 0; j-- {
+                       carry = carry + 256*uint32(buf[j])
+                       buf[j] = byte(carry % 58)
+                       carry /= 58
+               }
+               high = j
+       }
+
+       for j = 0; j < size && buf[j] == 0; j++ {
+       }
+
+       var b58 = make([]byte, size-j+zcount)
+
+       if zcount != 0 {
+               for i = 0; i < zcount; i++ {
+                       b58[i] = zero
+               }
+       }
+
+       for i = zcount; j < size; i++ {
+               b58[i] = alphabet.encode[buf[j]]
+               j++
+       }
+
+       return string(b58)
+}
+
+// TrivialBase58Encoding encodes the passed bytes into a base58 encoded string
+// (inefficiently).
+func TrivialBase58Encoding(a []byte) string {
+       return TrivialBase58EncodingAlphabet(a, BTCAlphabet)
+}
+
+// TrivialBase58EncodingAlphabet encodes the passed bytes into a base58 encoded
+// string (inefficiently) with the passed alphabet.
+func TrivialBase58EncodingAlphabet(a []byte, alphabet *Alphabet) string {
+       zero := alphabet.encode[0]
+       idx := len(a)*138/100 + 1
+       buf := make([]byte, idx)
+       bn := new(big.Int).SetBytes(a)
+       var mo *big.Int
+       for bn.Cmp(bn0) != 0 {
+               bn, mo = bn.DivMod(bn, bn58, new(big.Int))
+               idx--
+               buf[idx] = alphabet.encode[mo.Int64()]
+       }
+       for i := range a {
+               if a[i] != 0 {
+                       break
+               }
+               idx--
+               buf[idx] = zero
+       }
+       return string(buf[idx:])
+}
+
+// Decode decodes the base58 encoded bytes.
+func Decode(str string) ([]byte, error) {
+       return FastBase58Decoding(str)
+}
+
+// DecodeAlphabet decodes the base58 encoded bytes using the given b58 alphabet.
+func DecodeAlphabet(str string, alphabet *Alphabet) ([]byte, error) {
+       return FastBase58DecodingAlphabet(str, alphabet)
+}
+
+// FastBase58Decoding decodes the base58 encoded bytes.
+func FastBase58Decoding(str string) ([]byte, error) {
+       return FastBase58DecodingAlphabet(str, BTCAlphabet)
+}
+
+// FastBase58DecodingAlphabet decodes the base58 encoded bytes using the given
+// b58 alphabet.
+func FastBase58DecodingAlphabet(str string, alphabet *Alphabet) ([]byte, error) {
+       if len(str) == 0 {
+               return nil, fmt.Errorf("zero length string")
+       }
+
+       var (
+               t        uint64
+               zmask, c uint32
+               zcount   int
+
+               b58u  = []rune(str)
+               b58sz = len(b58u)
+
+               outisz    = (b58sz + 3) / 4 // check to see if we need to change this buffer size to optimize
+               binu      = make([]byte, (b58sz+3)*3)
+               bytesleft = b58sz % 4
+
+               zero = rune(alphabet.encode[0])
+       )
+
+       if bytesleft > 0 {
+               zmask = (0xffffffff << uint32(bytesleft*8))
+       } else {
+               bytesleft = 4
+       }
+
+       var outi = make([]uint32, outisz)
+
+       for i := 0; i < b58sz && b58u[i] == zero; i++ {
+               zcount++
+       }
+
+       for _, r := range b58u {
+               if r > 127 {
+                       return nil, fmt.Errorf("High-bit set on invalid digit")
+               }
+               if alphabet.decode[r] == -1 {
+                       return nil, fmt.Errorf("Invalid base58 digit (%q)", r)
+               }
+
+               c = uint32(alphabet.decode[r])
+
+               for j := (outisz - 1); j >= 0; j-- {
+                       t = uint64(outi[j])*58 + uint64(c)
+                       c = uint32(t>>32) & 0x3f
+                       outi[j] = uint32(t & 0xffffffff)
+               }
+
+               if c > 0 {
+                       return nil, fmt.Errorf("Output number too big (carry to the next int32)")
+               }
+
+               if outi[0]&zmask != 0 {
+                       return nil, fmt.Errorf("Output number too big (last int32 filled too far)")
+               }
+       }
+
+       // the nested for-loop below is the same as the original code:
+       // switch (bytesleft) {
+       //      case 3:
+       //              *(binu++) = (outi[0] & 0xff0000) >> 16;
+       //              //-fallthrough
+       //      case 2:
+       //              *(binu++) = (outi[0] & 0xff00) >>  8;
+       //              //-fallthrough
+       //      case 1:
+       //              *(binu++) = (outi[0] & 0xff);
+       //              ++j;
+       //              //-fallthrough
+       //      default:
+       //              break;
+       // }
+       //
+       // for (; j < outisz; ++j)
+       // {
+       //      *(binu++) = (outi[j] >> 0x18) & 0xff;
+       //      *(binu++) = (outi[j] >> 0x10) & 0xff;
+       //      *(binu++) = (outi[j] >>    8) & 0xff;
+       //      *(binu++) = (outi[j] >>    0) & 0xff;
+       // }
+       var j, cnt int
+       for j, cnt = 0, 0; j < outisz; j++ {
+               for mask := byte(bytesleft-1) * 8; mask <= 0x18; mask, cnt = mask-8, cnt+1 {
+                       binu[cnt] = byte(outi[j] >> mask)
+               }
+               if j == 0 {
+                       bytesleft = 4 // because it could be less than 4 the first time through
+               }
+       }
+
+       for n, v := range binu {
+               if v > 0 {
+                       start := n - zcount
+                       if start < 0 {
+                               start = 0
+                       }
+                       return binu[start:cnt], nil
+               }
+       }
+       return binu[:cnt], nil
+}
+
+// TrivialBase58Decoding decodes the base58 encoded bytes (inefficiently).
+func TrivialBase58Decoding(str string) ([]byte, error) {
+       return TrivialBase58DecodingAlphabet(str, BTCAlphabet)
+}
+
+// TrivialBase58DecodingAlphabet decodes the base58 encoded bytes
+// (inefficiently) using the given b58 alphabet.
+func TrivialBase58DecodingAlphabet(str string, alphabet *Alphabet) ([]byte, error) {
+       zero := alphabet.encode[0]
+
+       var zcount int
+       for i := 0; i < len(str) && str[i] == zero; i++ {
+               zcount++
+       }
+       leading := make([]byte, zcount)
+
+       var padChar rune = -1
+       src := []byte(str)
+       j := 0
+       for ; j < len(src) && src[j] == byte(padChar); j++ {
+       }
+
+       n := new(big.Int)
+       for i := range src[j:] {
+               c := alphabet.decode[src[i]]
+               if c == -1 {
+                       return nil, fmt.Errorf("illegal base58 data at input index: %d", i)
+               }
+               n.Mul(n, bn58)
+               n.Add(n, big.NewInt(int64(c)))
+       }
+       return append(leading, n.Bytes()...), nil
+}

diff --git a/vendor/github.com/mr-tron/base58/base58/base58_2_test.go b/vendor/github.com/mr-tron/base58/base58/base58_2_test.go
new file mode 100644 (file)
index 0000000..ac7f7b0
--- /dev/null
+++ b/vendor/github.com/mr-tron/base58/base58/base58_2_test.go
@@ -0,0 +1,26 @@
+package base58
+
+import "testing"
+
+func TestBase58_test2(t *testing.T) {
+
+       testAddr := []string{
+               "1QCaxc8hutpdZ62iKZsn1TCG3nh7uPZojq",
+               "1DhRmSGnhPjUaVPAj48zgPV9e2oRhAQFUb",
+               "17LN2oPYRYsXS9TdYdXCCDvF2FegshLDU2",
+               "14h2bDLZSuvRFhUL45VjPHJcW667mmRAAn",
+       }
+
+       for ii, vv := range testAddr {
+               // num := Base58Decode([]byte(vv))
+               // chk := Base58Encode(num)
+               num, err := FastBase58Decoding(vv)
+               if err != nil {
+                       t.Errorf("Test %d, expected success, got error %s\n", ii, err)
+               }
+               chk := FastBase58Encoding(num)
+               if vv != string(chk) {
+                       t.Errorf("Test %d, expected=%s got=%s Address did base58 encode/decode correctly.", ii, vv, chk)
+               }
+       }
+}

diff --git a/vendor/github.com/mr-tron/base58/base58/base58_test.go b/vendor/github.com/mr-tron/base58/base58/base58_test.go
new file mode 100644 (file)
index 0000000..b87c6f0
--- /dev/null
+++ b/vendor/github.com/mr-tron/base58/base58/base58_test.go
@@ -0,0 +1,117 @@
+package base58
+
+import (
+       "crypto/rand"
+       "encoding/hex"
+       "testing"
+)
+
+type testValues struct {
+       dec []byte
+       enc string
+}
+
+var n = 5000000
+var testPairs = make([]testValues, 0, n)
+
+func initTestPairs() {
+       if len(testPairs) > 0 {
+               return
+       }
+       // pre-make the test pairs, so it doesn't take up benchmark time...
+       for i := 0; i < n; i++ {
+               data := make([]byte, 32)
+               rand.Read(data)
+               testPairs = append(testPairs, testValues{dec: data, enc: FastBase58Encoding(data)})
+       }
+}
+
+func randAlphabet() *Alphabet {
+       // Permutes [0, 127] and returns the first 58 elements.
+       // Like (math/rand).Perm but using crypto/rand.
+       var randomness [128]byte
+       rand.Read(randomness[:])
+
+       var bts [128]byte
+       for i, r := range randomness {
+               j := int(r) % (i + 1)
+               bts[i] = bts[j]
+               bts[j] = byte(i)
+       }
+       return NewAlphabet(string(bts[:58]))
+}
+
+func TestFastEqTrivialEncodingAndDecoding(t *testing.T) {
+       for k := 0; k < 10; k++ {
+               testEncDecLoop(t, randAlphabet())
+       }
+       testEncDecLoop(t, BTCAlphabet)
+       testEncDecLoop(t, FlickrAlphabet)
+}
+
+func testEncDecLoop(t *testing.T, alph *Alphabet) {
+       for j := 1; j < 256; j++ {
+               var b = make([]byte, j)
+               for i := 0; i < 100; i++ {
+                       rand.Read(b)
+                       fe := FastBase58EncodingAlphabet(b, alph)
+                       te := TrivialBase58EncodingAlphabet(b, alph)
+
+                       if fe != te {
+                               t.Errorf("encoding err: %#v", hex.EncodeToString(b))
+                       }
+
+                       fd, ferr := FastBase58DecodingAlphabet(fe, alph)
+                       if ferr != nil {
+                               t.Errorf("fast error: %v", ferr)
+                       }
+                       td, terr := TrivialBase58DecodingAlphabet(te, alph)
+                       if terr != nil {
+                               t.Errorf("trivial error: %v", terr)
+                       }
+
+                       if hex.EncodeToString(b) != hex.EncodeToString(td) {
+                               t.Errorf("decoding err: %s != %s", hex.EncodeToString(b), hex.EncodeToString(td))
+                       }
+                       if hex.EncodeToString(b) != hex.EncodeToString(fd) {
+                               t.Errorf("decoding err: %s != %s", hex.EncodeToString(b), hex.EncodeToString(fd))
+                       }
+               }
+       }
+}
+
+func BenchmarkTrivialBase58Encoding(b *testing.B) {
+       initTestPairs()
+       b.ResetTimer()
+
+       for i := 0; i < b.N; i++ {
+               TrivialBase58Encoding([]byte(testPairs[i].dec))
+       }
+}
+
+func BenchmarkFastBase58Encoding(b *testing.B) {
+       initTestPairs()
+       b.ResetTimer()
+
+       for i := 0; i < b.N; i++ {
+               FastBase58Encoding(testPairs[i].dec)
+       }
+}
+
+func BenchmarkTrivialBase58Decoding(b *testing.B) {
+       initTestPairs()
+       b.ResetTimer()
+
+       for i := 0; i < b.N; i++ {
+               TrivialBase58Decoding(testPairs[i].enc)
+       }
+}
+
+func BenchmarkFastBase58Decoding(b *testing.B) {
+       initTestPairs()
+       b.ResetTimer()
+
+       for i := 0; i < b.N; i++ {
+               FastBase58Decoding(testPairs[i].enc)
+       }
+}

diff --git a/vendor/github.com/mr-tron/base58/base58_2_test.go b/vendor/github.com/mr-tron/base58/base58_2_test.go
new file mode 100644 (file)
index 0000000..ac7f7b0
--- /dev/null
+++ b/vendor/github.com/mr-tron/base58/base58_2_test.go
@@ -0,0 +1,26 @@
+package base58
+
+import "testing"
+
+func TestBase58_test2(t *testing.T) {
+
+       testAddr := []string{
+               "1QCaxc8hutpdZ62iKZsn1TCG3nh7uPZojq",
+               "1DhRmSGnhPjUaVPAj48zgPV9e2oRhAQFUb",
+               "17LN2oPYRYsXS9TdYdXCCDvF2FegshLDU2",
+               "14h2bDLZSuvRFhUL45VjPHJcW667mmRAAn",
+       }
+
+       for ii, vv := range testAddr {
+               // num := Base58Decode([]byte(vv))
+               // chk := Base58Encode(num)
+               num, err := FastBase58Decoding(vv)
+               if err != nil {
+                       t.Errorf("Test %d, expected success, got error %s\n", ii, err)
+               }
+               chk := FastBase58Encoding(num)
+               if vv != string(chk) {
+                       t.Errorf("Test %d, expected=%s got=%s Address did base58 encode/decode correctly.", ii, vv, chk)
+               }
+       }
+}

diff --git a/vendor/github.com/mr-tron/base58/base58_test.go b/vendor/github.com/mr-tron/base58/base58_test.go
new file mode 100644 (file)
index 0000000..b87c6f0
--- /dev/null
+++ b/vendor/github.com/mr-tron/base58/base58_test.go
@@ -0,0 +1,117 @@
+package base58
+
+import (
+       "crypto/rand"
+       "encoding/hex"
+       "testing"
+)
+
+type testValues struct {
+       dec []byte
+       enc string
+}
+
+var n = 5000000
+var testPairs = make([]testValues, 0, n)
+
+func initTestPairs() {
+       if len(testPairs) > 0 {
+               return
+       }
+       // pre-make the test pairs, so it doesn't take up benchmark time...
+       for i := 0; i < n; i++ {
+               data := make([]byte, 32)
+               rand.Read(data)
+               testPairs = append(testPairs, testValues{dec: data, enc: FastBase58Encoding(data)})
+       }
+}
+
+func randAlphabet() *Alphabet {
+       // Permutes [0, 127] and returns the first 58 elements.
+       // Like (math/rand).Perm but using crypto/rand.
+       var randomness [128]byte
+       rand.Read(randomness[:])
+
+       var bts [128]byte
+       for i, r := range randomness {
+               j := int(r) % (i + 1)
+               bts[i] = bts[j]
+               bts[j] = byte(i)
+       }
+       return NewAlphabet(string(bts[:58]))
+}
+
+func TestFastEqTrivialEncodingAndDecoding(t *testing.T) {
+       for k := 0; k < 10; k++ {
+               testEncDecLoop(t, randAlphabet())
+       }
+       testEncDecLoop(t, BTCAlphabet)
+       testEncDecLoop(t, FlickrAlphabet)
+}
+
+func testEncDecLoop(t *testing.T, alph *Alphabet) {
+       for j := 1; j < 256; j++ {
+               var b = make([]byte, j)
+               for i := 0; i < 100; i++ {
+                       rand.Read(b)
+                       fe := FastBase58EncodingAlphabet(b, alph)
+                       te := TrivialBase58EncodingAlphabet(b, alph)
+
+                       if fe != te {
+                               t.Errorf("encoding err: %#v", hex.EncodeToString(b))
+                       }
+
+                       fd, ferr := FastBase58DecodingAlphabet(fe, alph)
+                       if ferr != nil {
+                               t.Errorf("fast error: %v", ferr)
+                       }
+                       td, terr := TrivialBase58DecodingAlphabet(te, alph)
+                       if terr != nil {
+                               t.Errorf("trivial error: %v", terr)
+                       }
+
+                       if hex.EncodeToString(b) != hex.EncodeToString(td) {
+                               t.Errorf("decoding err: %s != %s", hex.EncodeToString(b), hex.EncodeToString(td))
+                       }
+                       if hex.EncodeToString(b) != hex.EncodeToString(fd) {
+                               t.Errorf("decoding err: %s != %s", hex.EncodeToString(b), hex.EncodeToString(fd))
+                       }
+               }
+       }
+}
+
+func BenchmarkTrivialBase58Encoding(b *testing.B) {
+       initTestPairs()
+       b.ResetTimer()
+
+       for i := 0; i < b.N; i++ {
+               TrivialBase58Encoding([]byte(testPairs[i].dec))
+       }
+}
+
+func BenchmarkFastBase58Encoding(b *testing.B) {
+       initTestPairs()
+       b.ResetTimer()
+
+       for i := 0; i < b.N; i++ {
+               FastBase58Encoding(testPairs[i].dec)
+       }
+}
+
+func BenchmarkTrivialBase58Decoding(b *testing.B) {
+       initTestPairs()
+       b.ResetTimer()
+
+       for i := 0; i < b.N; i++ {
+               TrivialBase58Decoding(testPairs[i].enc)
+       }
+}
+
+func BenchmarkFastBase58Decoding(b *testing.B) {
+       initTestPairs()
+       b.ResetTimer()
+
+       for i := 0; i < b.N; i++ {
+               FastBase58Decoding(testPairs[i].enc)
+       }
+}

diff --git a/vendor/github.com/mr-tron/base58/examples/cli/cli.go b/vendor/github.com/mr-tron/base58/examples/cli/cli.go
new file mode 100644 (file)
index 0000000..be54f16
--- /dev/null
+++ b/vendor/github.com/mr-tron/base58/examples/cli/cli.go
@@ -0,0 +1,37 @@
+package main
+
+import (
+       "fmt"
+       "os"
+
+       "github.com/mr-tron/base58"
+)
+
+func main() {
+
+       exampleBase58Encoded := []string{
+               "1QCaxc8hutpdZ62iKZsn1TCG3nh7uPZojq",
+               "1DhRmSGnhPjUaVPAj48zgPV9e2oRhAQFUb",
+               "17LN2oPYRYsXS9TdYdXCCDvF2FegshLDU2",
+               "14h2bDLZSuvRFhUL45VjPHJcW667mmRAAn",
+       }
+
+       // If a base58 string is on the command line, then use that instead of the 4 exampels above.
+       if len(os.Args) > 1 {
+               exampleBase58Encoded = os.Args[1:]
+       }
+
+       for _, vv := range exampleBase58Encoded {
+               num, err := base58.Decode(vv)
+               if err != nil {
+                       fmt.Printf("Demo %s, got error %s\n", vv, err)
+                       continue
+               }
+               chk := base58.Encode(num)
+               if vv == string(chk) {
+                       fmt.Printf("Successfully decoded then re-encoded %s\n", vv)
+               } else {
+                       fmt.Printf("Failed on %s\n", vv)
+               }
+       }
+}

diff --git a/vendor/github.com/mr-tron/base58/examples/wif/main.go b/vendor/github.com/mr-tron/base58/examples/wif/main.go
new file mode 100644 (file)
index 0000000..5e8fc6d
--- /dev/null
+++ b/vendor/github.com/mr-tron/base58/examples/wif/main.go
@@ -0,0 +1,116 @@
+package main
+
+import (
+       "bytes"
+       "crypto/sha256"
+       "encoding/hex"
+       "flag"
+       "fmt"
+       "io"
+       "io/ioutil"
+       "os"
+
+       "github.com/mr-tron/base58"
+)
+
+func checkSum(b []byte) []byte {
+       sh1, sh2 := sha256.New(), sha256.New()
+       sh1.Write(b)
+       sh2.Write(sh1.Sum(nil))
+       return sh2.Sum(nil)
+}
+
+func main() {
+       var (
+               err error
+               bin []byte
+
+               help     = flag.Bool("h", false, "display this message")
+               lnBreak  = flag.Int("b", 76, "break encoded string into num character lines. Use 0 to disable line wrapping")
+               input    = flag.String("i", "-", `input file (use: "-" for stdin)`)
+               output   = flag.String("o", "-", `output file (use: "-" for stdout)`)
+               decode   = flag.Bool("d", false, `decode input`)
+               check    = flag.Bool("k", false, `use sha256 check`)
+               useError = flag.Bool("e", false, `write error to stderr`)
+       )
+
+       flag.Parse()
+
+       if *help {
+               flag.Usage()
+               os.Exit(0)
+       }
+
+       fin, fout := os.Stdin, os.Stdout
+       if *input != "-" {
+               if fin, err = os.Open(*input); err != nil {
+                       fmt.Fprintln(os.Stderr, "input file err:", err)
+                       os.Exit(1)
+               }
+       }
+
+       if *output != "-" {
+               if fout, err = os.Create(*output); err != nil {
+                       fmt.Fprintln(os.Stderr, "output file err:", err)
+                       os.Exit(1)
+               }
+       }
+
+       if bin, err = ioutil.ReadAll(fin); err != nil {
+               fmt.Fprintln(os.Stderr, "read input err:", err)
+               os.Exit(1)
+       }
+
+       if *decode {
+               decoded, err := base58.Decode(string(bin))
+               if err != nil {
+                       fmt.Fprintln(os.Stderr, "decode input err:", err)
+                       os.Exit(1)
+               }
+
+               var checkResult bool
+               if *check {
+                       chk := len(decoded) - 4
+                       decodedCk := decoded[chk:]
+                       decoded = decoded[:chk]
+                       sum := checkSum(decoded)
+                       checkResult = hex.EncodeToString(sum[:4]) == hex.EncodeToString(decodedCk)
+               }
+
+               _, err = io.Copy(fout, bytes.NewReader(decoded))
+               if err != nil {
+                       fmt.Fprintln(os.Stderr, err)
+                       os.Exit(1)
+               }
+
+               if *check && !checkResult {
+                       if *useError {
+                               fmt.Fprintf(os.Stderr, "%t\n", false)
+                       }
+                       os.Exit(3)
+               }
+
+               os.Exit(0)
+       }
+
+       if *check {
+               sum := checkSum(bin)
+               bin = append(bin, sum[:4]...)
+       }
+
+       encoded := base58.Encode(bin)
+
+       if *lnBreak > 0 {
+               lines := (len(encoded) / *lnBreak) + 1
+               for i := 0; i < lines; i++ {
+                       start := i * *lnBreak
+                       end := start + *lnBreak
+                       if i == lines-1 {
+                               fmt.Fprintln(fout, encoded[start:])
+                               return
+                       }
+                       fmt.Fprintln(fout, encoded[start:end])
+               }
+       }
+       fmt.Fprintln(fout, encoded)
+}

diff --git a/vendor/github.com/mr-tron/base58/go.mod b/vendor/github.com/mr-tron/base58/go.mod
new file mode 100644 (file)
index 0000000..c55c06c
--- /dev/null
+++ b/vendor/github.com/mr-tron/base58/go.mod
@@ -0,0 +1 @@
+module github.com/mr-tron/base58

diff --git a/vendor/github.com/mr-tron/base58/trivial.go b/vendor/github.com/mr-tron/base58/trivial.go
new file mode 100644 (file)
index 0000000..eff54f4
--- /dev/null
+++ b/vendor/github.com/mr-tron/base58/trivial.go
@@ -0,0 +1,74 @@
+package base58
+
+import (
+       "fmt"
+       "math/big"
+)
+
+var (
+       bn0  = big.NewInt(0)
+       bn58 = big.NewInt(58)
+)
+
+// TrivialBase58Encoding encodes the passed bytes into a base58 encoded string
+// (inefficiently).
+func TrivialBase58Encoding(a []byte) string {
+       return TrivialBase58EncodingAlphabet(a, BTCAlphabet)
+}
+
+// TrivialBase58EncodingAlphabet encodes the passed bytes into a base58 encoded
+// string (inefficiently) with the passed alphabet.
+func TrivialBase58EncodingAlphabet(a []byte, alphabet *Alphabet) string {
+       zero := alphabet.encode[0]
+       idx := len(a)*138/100 + 1
+       buf := make([]byte, idx)
+       bn := new(big.Int).SetBytes(a)
+       var mo *big.Int
+       for bn.Cmp(bn0) != 0 {
+               bn, mo = bn.DivMod(bn, bn58, new(big.Int))
+               idx--
+               buf[idx] = alphabet.encode[mo.Int64()]
+       }
+       for i := range a {
+               if a[i] != 0 {
+                       break
+               }
+               idx--
+               buf[idx] = zero
+       }
+       return string(buf[idx:])
+}
+
+// TrivialBase58Decoding decodes the base58 encoded bytes (inefficiently).
+func TrivialBase58Decoding(str string) ([]byte, error) {
+       return TrivialBase58DecodingAlphabet(str, BTCAlphabet)
+}
+
+// TrivialBase58DecodingAlphabet decodes the base58 encoded bytes
+// (inefficiently) using the given b58 alphabet.
+func TrivialBase58DecodingAlphabet(str string, alphabet *Alphabet) ([]byte, error) {
+       zero := alphabet.encode[0]
+
+       var zcount int
+       for i := 0; i < len(str) && str[i] == zero; i++ {
+               zcount++
+       }
+       leading := make([]byte, zcount)
+
+       var padChar rune = -1
+       src := []byte(str)
+       j := 0
+       for ; j < len(src) && src[j] == byte(padChar); j++ {
+       }
+
+       n := new(big.Int)
+       for i := range src[j:] {
+               c := alphabet.decode[src[i]]
+               if c == -1 {
+                       return nil, fmt.Errorf("illegal base58 data at input index: %d", i)
+               }
+               n.Mul(n, bn58)
+               n.Add(n, big.NewInt(int64(c)))
+       }
+       return append(leading, n.Bytes()...), nil
+}

diff --git a/vendor/github.com/multiformats/go-multiaddr-dns/.gitignore b/vendor/github.com/multiformats/go-multiaddr-dns/.gitignore
new file mode 100644 (file)
index 0000000..4621ab7
--- /dev/null
+++ b/vendor/github.com/multiformats/go-multiaddr-dns/.gitignore
@@ -0,0 +1 @@
+/madns/madns

diff --git a/vendor/github.com/multiformats/go-multiaddr-dns/.gx/lastpubver b/vendor/github.com/multiformats/go-multiaddr-dns/.gx/lastpubver
new file mode 100644 (file)
index 0000000..55d4f51
--- /dev/null
+++ b/vendor/github.com/multiformats/go-multiaddr-dns/.gx/lastpubver
@@ -0,0 +1 @@
+0.3.0: QmQc7jbDUsxUJZyFJzxVrnrWeECCct6fErEpMqtjyWvCX8

diff --git a/vendor/github.com/multiformats/go-multiaddr-dns/LICENSE b/vendor/github.com/multiformats/go-multiaddr-dns/LICENSE
new file mode 100644 (file)
index 0000000..c7386b3
--- /dev/null
+++ b/vendor/github.com/multiformats/go-multiaddr-dns/LICENSE
@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2014 Juan Batiz-Benet
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

diff --git a/vendor/github.com/multiformats/go-multiaddr-dns/README.md b/vendor/github.com/multiformats/go-multiaddr-dns/README.md
new file mode 100644 (file)
index 0000000..a1ac544
--- /dev/null
+++ b/vendor/github.com/multiformats/go-multiaddr-dns/README.md
@@ -0,0 +1,57 @@
+# go-multiaddr-dns
+
+> Resolve /dns4, /dns6, and /dnsaddr multiaddrs.
+
+```sh
+> madns /dnsaddr/ipfs.io/ipfs/QmSoLju6m7xTh3DuokvT3886QRYqxAzb1kShaanJgW36yx
+/ip4/104.236.151.122/tcp/4001/ipfs/QmSoLju6m7xTh3DuokvT3886QRYqxAzb1kShaanJgW36yx
+/ip6/2604:a880:1:20::1d9:6001/tcp/4001/ipfs/QmSoLju6m7xTh3DuokvT3886QRYqxAzb1kShaanJgW36yx
+/ip6/fc3d:9a4e:3c96:2fd2:1afa:18fe:8dd2:b602/tcp/4001/ipfs/QmSoLju6m7xTh3DuokvT3886QRYqxAzb1kShaanJgW36yx
+/dns4/jupiter.i.ipfs.io/tcp/4001/ipfs/QmSoLju6m7xTh3DuokvT3886QRYqxAzb1kShaanJgW36yx
+/dns6/jupiter.i.ipfs.io/tcp/4001/ipfs/QmSoLju6m7xTh3DuokvT3886QRYqxAzb1kShaanJgW36yx
+```
+
+
+In more detail:
+
+```sh
+> madns /dns6/example.net
+/ip6/2001:db8::a3
+/ip6/2001:db8::a4
+...
+
+> madns /dns4/example.net/tcp/443/wss
+/ip4/192.0.2.1/tcp/443/wss
+/ip4/192.0.2.2/tcp/443/wss
+
+# No-op if it's not a dns-ish address.
+
+> madns /ip4/127.0.0.1/tcp/8080
+/ip4/127.0.0.1/tcp/8080
+
+# /dnsaddr resolves by looking up TXT records.
+
+> dig +short TXT _dnsaddr.example.net
+"dnsaddr=/ip6/2001:db8::a3/tcp/443/wss/ipfs/Qmfoo"
+"dnsaddr=/ip6/2001:db8::a4/tcp/443/wss/ipfs/Qmbar"
+"dnsaddr=/ip4/192.0.2.1/tcp/443/wss/ipfs/Qmfoo"
+"dnsaddr=/ip4/192.0.2.2/tcp/443/wss/ipfs/Qmbar"
+...
+
+# /dnsaddr returns addrs which encapsulate whatever /dnsaddr encapsulates too.
+
+> madns example.net/ipfs/Qmfoo
+info: changing query to /dnsaddr/example.net/ipfs/Qmfoo
+/ip6/2001:db8::a3/tcp/443/wss/ipfs/Qmfoo
+/ip4/192.0.2.1/tcp/443/wss/ipfs/Qmfoo
+
+# TODO -p filters by protocol stacks.
+
+> madns -p /ip6/tcp/wss /dnsaddr/example.net
+/ip6/2001:db8::a3/tcp/443/wss/ipfs/Qmfoo
+/ip6/2001:db8::a4/tcp/443/wss/ipfs/Qmbar
+
+# TOOD -c filters by CIDR
+> madns -c /ip4/104.236.76.0/ipcidr/24 /dnsaddr/example.net
+/ip4/192.0.2.2/tcp/443/wss/ipfs/Qmbar
+```

diff --git a/vendor/github.com/multiformats/go-multiaddr-dns/ci/Jenkinsfile b/vendor/github.com/multiformats/go-multiaddr-dns/ci/Jenkinsfile
new file mode 100644 (file)
index 0000000..b2067e6
--- /dev/null
+++ b/vendor/github.com/multiformats/go-multiaddr-dns/ci/Jenkinsfile
@@ -0,0 +1 @@
+golang()

diff --git a/vendor/github.com/multiformats/go-multiaddr-dns/dns.go b/vendor/github.com/multiformats/go-multiaddr-dns/dns.go
new file mode 100644 (file)
index 0000000..52b9645
--- /dev/null
+++ b/vendor/github.com/multiformats/go-multiaddr-dns/dns.go
@@ -0,0 +1,62 @@
+package madns
+
+import (
+       "bytes"
+       "fmt"
+
+       ma "github.com/multiformats/go-multiaddr"
+)
+
+var Dns4Protocol = ma.Protocol{
+       Code:       54,
+       Size:       ma.LengthPrefixedVarSize,
+       Name:       "dns4",
+       VCode:      ma.CodeToVarint(54),
+       Transcoder: DnsTranscoder,
+}
+var Dns6Protocol = ma.Protocol{
+       Code:       55,
+       Size:       ma.LengthPrefixedVarSize,
+       Name:       "dns6",
+       VCode:      ma.CodeToVarint(55),
+       Transcoder: DnsTranscoder,
+}
+var DnsaddrProtocol = ma.Protocol{
+       Code:       56,
+       Size:       ma.LengthPrefixedVarSize,
+       Name:       "dnsaddr",
+       VCode:      ma.CodeToVarint(56),
+       Transcoder: DnsTranscoder,
+}
+
+func init() {
+       err := ma.AddProtocol(Dns4Protocol)
+       if err != nil {
+               panic(fmt.Errorf("error registering dns4 protocol: %s", err))
+       }
+       err = ma.AddProtocol(Dns6Protocol)
+       if err != nil {
+               panic(fmt.Errorf("error registering dns6 protocol: %s", err))
+       }
+       err = ma.AddProtocol(DnsaddrProtocol)
+       if err != nil {
+               panic(fmt.Errorf("error registering dnsaddr protocol: %s", err))
+       }
+}
+
+var DnsTranscoder = ma.NewTranscoderFromFunctions(dnsStB, dnsBtS, dnsVal)
+
+func dnsVal(b []byte) error {
+       if bytes.IndexByte(b, '/') >= 0 {
+               return fmt.Errorf("domain name %q contains a slash", string(b))
+       }
+       return nil
+}
+
+func dnsStB(s string) ([]byte, error) {
+       return []byte(s), nil
+}
+
+func dnsBtS(b []byte) (string, error) {
+       return string(b), nil
+}

diff --git a/vendor/github.com/multiformats/go-multiaddr-dns/madns/main.go b/vendor/github.com/multiformats/go-multiaddr-dns/madns/main.go
new file mode 100644 (file)
index 0000000..e9c65a8
--- /dev/null
+++ b/vendor/github.com/multiformats/go-multiaddr-dns/madns/main.go
@@ -0,0 +1,44 @@
+package main
+
+import (
+       "context"
+       "fmt"
+       "os"
+       "strings"
+
+       ma "github.com/multiformats/go-multiaddr"
+       madns "github.com/multiformats/go-multiaddr-dns"
+)
+
+func main() {
+       if len(os.Args) != 2 {
+               fmt.Print("usage: madns /dnsaddr/example.com\n" +
+                       "       madns /dnsaddr/example.com/ipfs/Qmfoobar\n" +
+                       "       madns /dns6/example.com\n" +
+                       "       madns /dns6/example.com/tcp/443/wss\n" +
+                       "       madns /dns4/example.com\n")
+               os.Exit(1)
+       }
+
+       query := os.Args[1]
+       if !strings.HasPrefix(query, "/") {
+               query = "/dnsaddr/" + query
+               fmt.Fprintf(os.Stderr, "madns: changing query to %s\n", query)
+       }
+
+       maddr, err := ma.NewMultiaddr(query)
+       if err != nil {
+               fmt.Printf("error: %s\n", err)
+               os.Exit(1)
+       }
+
+       rmaddrs, err := madns.Resolve(context.Background(), maddr)
+       if err != nil {
+               fmt.Printf("error: %s (result=%+v)\n", err, rmaddrs)
+               os.Exit(1)
+       }
+
+       for _, r := range rmaddrs {
+               fmt.Println(r.String())
+       }
+}

diff --git a/vendor/github.com/multiformats/go-multiaddr-dns/package.json b/vendor/github.com/multiformats/go-multiaddr-dns/package.json
new file mode 100644 (file)
index 0000000..49edbaa
--- /dev/null
+++ b/vendor/github.com/multiformats/go-multiaddr-dns/package.json
@@ -0,0 +1,24 @@
+{
+  "author": "lgierth",
+  "bugs": {
+    "url": "https://github.com/multiformats/go-multiaddr-dns/issues"
+  },
+  "gx": {
+    "dvcsimport": "github.com/multiformats/go-multiaddr-dns"
+  },
+  "gxDependencies": [
+    {
+      "author": "multiformats",
+      "hash": "QmNTCey11oxhb1AxDnQBRHtdhap6Ctud872NjAYPYYXPuc",
+      "name": "go-multiaddr",
+      "version": "1.4.0"
+    }
+  ],
+  "gxVersion": "0.10.0",
+  "language": "go",
+  "license": "MIT",
+  "name": "go-multiaddr-dns",
+  "releaseCmd": "git commit -a -m \"gx publish $VERSION\"",
+  "version": "0.3.0"
+}
+

diff --git a/vendor/github.com/multiformats/go-multiaddr-dns/resolve.go b/vendor/github.com/multiformats/go-multiaddr-dns/resolve.go
new file mode 100644 (file)
index 0000000..9c81c2f
--- /dev/null
+++ b/vendor/github.com/multiformats/go-multiaddr-dns/resolve.go
@@ -0,0 +1,181 @@
+package madns
+
+import (
+       "context"
+       "fmt"
+       "net"
+       "strings"
+
+       ma "github.com/multiformats/go-multiaddr"
+)
+
+var ResolvableProtocols = []ma.Protocol{DnsaddrProtocol, Dns4Protocol, Dns6Protocol}
+var DefaultResolver = &Resolver{Backend: net.DefaultResolver}
+
+type backend interface {
+       LookupIPAddr(context.Context, string) ([]net.IPAddr, error)
+       LookupTXT(context.Context, string) ([]string, error)
+}
+
+type Resolver struct {
+       Backend backend
+}
+
+type MockBackend struct {
+       IP  map[string][]net.IPAddr
+       TXT map[string][]string
+}
+
+func (r *MockBackend) LookupIPAddr(ctx context.Context, name string) ([]net.IPAddr, error) {
+       results, ok := r.IP[name]
+       if ok {
+               return results, nil
+       } else {
+               return []net.IPAddr{}, nil
+       }
+}
+
+func (r *MockBackend) LookupTXT(ctx context.Context, name string) ([]string, error) {
+       results, ok := r.TXT[name]
+       if ok {
+               return results, nil
+       } else {
+               return []string{}, nil
+       }
+}
+
+func Matches(maddr ma.Multiaddr) bool {
+       protos := maddr.Protocols()
+       if len(protos) == 0 {
+               return false
+       }
+
+       for _, p := range ResolvableProtocols {
+               if protos[0].Code == p.Code {
+                       return true
+               }
+       }
+
+       return false
+}
+
+func Resolve(ctx context.Context, maddr ma.Multiaddr) ([]ma.Multiaddr, error) {
+       return DefaultResolver.Resolve(ctx, maddr)
+}
+
+func (r *Resolver) Resolve(ctx context.Context, maddr ma.Multiaddr) ([]ma.Multiaddr, error) {
+       if !Matches(maddr) {
+               return []ma.Multiaddr{maddr}, nil
+       }
+
+       protos := maddr.Protocols()
+       if protos[0].Code == Dns4Protocol.Code {
+               return r.resolveDns4(ctx, maddr)
+       }
+       if protos[0].Code == Dns6Protocol.Code {
+               return r.resolveDns6(ctx, maddr)
+       }
+       if protos[0].Code == DnsaddrProtocol.Code {
+               return r.resolveDnsaddr(ctx, maddr)
+       }
+
+       panic("unreachable")
+}
+
+func (r *Resolver) resolveDns4(ctx context.Context, maddr ma.Multiaddr) ([]ma.Multiaddr, error) {
+       value, err := maddr.ValueForProtocol(Dns4Protocol.Code)
+       if err != nil {
+               return nil, fmt.Errorf("error resolving %s: %s", maddr.String(), err)
+       }
+
+       encap := ma.Split(maddr)[1:]
+
+       result := []ma.Multiaddr{}
+       records, err := r.Backend.LookupIPAddr(ctx, value)
+       if err != nil {
+               return result, err
+       }
+
+       for _, r := range records {
+               ip4 := r.IP.To4()
+               if ip4 == nil {
+                       continue
+               }
+               ip4maddr, err := ma.NewMultiaddr("/ip4/" + ip4.String())
+               if err != nil {
+                       return result, err
+               }
+               parts := append([]ma.Multiaddr{ip4maddr}, encap...)
+               result = append(result, ma.Join(parts...))
+       }
+       return result, nil
+}
+
+func (r *Resolver) resolveDns6(ctx context.Context, maddr ma.Multiaddr) ([]ma.Multiaddr, error) {
+       value, err := maddr.ValueForProtocol(Dns6Protocol.Code)
+       if err != nil {
+               return nil, fmt.Errorf("error resolving %s: %s", maddr.String(), err)
+       }
+
+       encap := ma.Split(maddr)[1:]
+
+       result := []ma.Multiaddr{}
+       records, err := r.Backend.LookupIPAddr(ctx, value)
+       if err != nil {
+               return result, err
+       }
+
+       for _, r := range records {
+               if r.IP.To4() != nil {
+                       continue
+               }
+               ip6maddr, err := ma.NewMultiaddr("/ip6/" + r.IP.To16().String())
+               if err != nil {
+                       return result, err
+               }
+               parts := append([]ma.Multiaddr{ip6maddr}, encap...)
+               result = append(result, ma.Join(parts...))
+       }
+       return result, nil
+}
+
+func (r *Resolver) resolveDnsaddr(ctx context.Context, maddr ma.Multiaddr) ([]ma.Multiaddr, error) {
+       value, err := maddr.ValueForProtocol(DnsaddrProtocol.Code)
+       if err != nil {
+               return nil, fmt.Errorf("error resolving %s: %s", maddr.String(), err)
+       }
+
+       trailer := ma.Split(maddr)[1:]
+
+       result := []ma.Multiaddr{}
+       records, err := r.Backend.LookupTXT(ctx, "_dnsaddr."+value)
+       if err != nil {
+               return result, err
+       }
+
+       for _, r := range records {
+               rv := strings.Split(r, "dnsaddr=")
+               if len(rv) != 2 {
+                       continue
+               }
+
+               rmaddr, err := ma.NewMultiaddr(rv[1])
+               if err != nil {
+                       return result, err
+               }
+
+               if matchDnsaddr(rmaddr, trailer) {
+                       result = append(result, rmaddr)
+               }
+       }
+       return result, nil
+}
+
+// XXX probably insecure
+func matchDnsaddr(maddr ma.Multiaddr, trailer []ma.Multiaddr) bool {
+       parts := ma.Split(maddr)
+       if ma.Join(parts[len(parts)-len(trailer):]...).Equal(ma.Join(trailer...)) {
+               return true
+       }
+       return false
+}

diff --git a/vendor/github.com/multiformats/go-multiaddr-dns/resolve_test.go b/vendor/github.com/multiformats/go-multiaddr-dns/resolve_test.go
new file mode 100644 (file)
index 0000000..2df9379
--- /dev/null
+++ b/vendor/github.com/multiformats/go-multiaddr-dns/resolve_test.go
@@ -0,0 +1,148 @@
+package madns
+
+import (
+       "context"
+       "net"
+       "testing"
+
+       ma "github.com/multiformats/go-multiaddr"
+)
+
+var ip4a = net.IPAddr{IP: net.ParseIP("192.0.2.1")}
+var ip4b = net.IPAddr{IP: net.ParseIP("192.0.2.2")}
+var ip6a = net.IPAddr{IP: net.ParseIP("2001:db8::a3")}
+var ip6b = net.IPAddr{IP: net.ParseIP("2001:db8::a4")}
+
+var ip4ma = ma.StringCast("/ip4/" + ip4a.IP.String())
+var ip4mb = ma.StringCast("/ip4/" + ip4b.IP.String())
+var ip6ma = ma.StringCast("/ip6/" + ip6a.IP.String())
+var ip6mb = ma.StringCast("/ip6/" + ip6b.IP.String())
+
+var txtmc = ma.Join(ip4ma, ma.StringCast("/tcp/123/http"))
+var txtmd = ma.Join(ip4ma, ma.StringCast("/tcp/123"))
+var txtme = ma.Join(ip4ma, ma.StringCast("/tcp/789/http"))
+
+var txta = "dnsaddr=" + ip4ma.String()
+var txtb = "dnsaddr=" + ip6ma.String()
+var txtc = "dnsaddr=" + txtmc.String()
+var txtd = "dnsaddr=" + txtmd.String()
+var txte = "dnsaddr=" + txtme.String()
+
+func makeResolver() *Resolver {
+       mock := &MockBackend{
+               IP: map[string][]net.IPAddr{
+                       "example.com": []net.IPAddr{ip4a, ip4b, ip6a, ip6b},
+               },
+               TXT: map[string][]string{
+                       "_dnsaddr.example.com":  []string{txta, txtb},
+                       "_dnsaddr.matching.com": []string{txtc, txtd, txte},
+               },
+       }
+       resolver := &Resolver{Backend: mock}
+       return resolver
+}
+
+func TestMatches(t *testing.T) {
+       if !Matches(ma.StringCast("/dns4/example.com")) {
+               t.Fatalf("expected match, didn't: /dns4/example.com")
+       }
+       if !Matches(ma.StringCast("/dns6/example.com")) {
+               t.Fatalf("expected match, didn't: /dns6/example.com")
+       }
+       if !Matches(ma.StringCast("/dnsaddr/example.com")) {
+               t.Fatalf("expected match, didn't: /dnsaddr/example.com")
+       }
+       if Matches(ip4ma) {
+               t.Fatalf("expected no-match, but did: %s", ip4ma.String())
+       }
+}
+
+func TestSimpleIPResolve(t *testing.T) {
+       ctx := context.Background()
+       resolver := makeResolver()
+
+       addrs4, err := resolver.Resolve(ctx, ma.StringCast("/dns4/example.com"))
+       if err != nil {
+               t.Error(err)
+       }
+       if len(addrs4) != 2 || !addrs4[0].Equal(ip4ma) || addrs4[0].Equal(ip4mb) {
+               t.Fatalf("expected [%s %s], got %+v", ip4ma, ip4mb, addrs4)
+       }
+
+       addrs6, err := resolver.Resolve(ctx, ma.StringCast("/dns6/example.com"))
+       if err != nil {
+               t.Error(err)
+       }
+       if len(addrs6) != 2 || !addrs6[0].Equal(ip6ma) || addrs6[0].Equal(ip6mb) {
+               t.Fatalf("expected [%s %s], got %+v", ip6ma, ip6mb, addrs6)
+       }
+}
+
+func TestSimpleTXTResolve(t *testing.T) {
+       ctx := context.Background()
+       resolver := makeResolver()
+
+       addrs, err := resolver.Resolve(ctx, ma.StringCast("/dnsaddr/example.com"))
+       if err != nil {
+               t.Error(err)
+       }
+       if len(addrs) != 2 || !addrs[0].Equal(ip4ma) || addrs[0].Equal(ip6ma) {
+               t.Fatalf("expected [%s %s], got %+v", ip4ma, ip6ma, addrs)
+       }
+}
+
+func TestNonResolvable(t *testing.T) {
+       ctx := context.Background()
+       resolver := makeResolver()
+
+       addrs, err := resolver.Resolve(ctx, ip4ma)
+       if err != nil {
+               t.Error(err)
+       }
+       if len(addrs) != 1 || !addrs[0].Equal(ip4ma) {
+               t.Fatalf("expected [%s], got %+v", ip4ma, addrs)
+       }
+}
+
+func TestEmptyResult(t *testing.T) {
+       ctx := context.Background()
+       resolver := makeResolver()
+
+       addrs, err := resolver.Resolve(ctx, ma.StringCast("/dnsaddr/none.com"))
+       if err != nil {
+               t.Error(err)
+       }
+       if len(addrs) > 0 {
+               t.Fatalf("expected [], got %+v", addrs)
+       }
+}
+
+func TestDnsaddrMatching(t *testing.T) {
+       ctx := context.Background()
+       resolver := makeResolver()
+
+       addrs, err := resolver.Resolve(ctx, ma.StringCast("/dnsaddr/matching.com/tcp/123/http"))
+       if err != nil {
+               t.Error(err)
+       }
+       if len(addrs) != 1 || !addrs[0].Equal(txtmc) {
+               t.Fatalf("expected [%s], got %+v", txtmc, addrs)
+       }
+
+       addrs, err = resolver.Resolve(ctx, ma.StringCast("/dnsaddr/matching.com/tcp/123"))
+       if err != nil {
+               t.Error(err)
+       }
+       if len(addrs) != 1 || !addrs[0].Equal(txtmd) {
+               t.Fatalf("expected [%s], got %+v", txtmd, addrs)
+       }
+}
+
+func TestBadDomain(t *testing.T) {
+       bts := ma.StringCast("/dns4/example.com").Bytes()
+       bts[len(bts)-5] = '/'
+       _, err := ma.NewMultiaddrBytes(bts)
+       if err == nil {
+               t.Error("expected malformed address to fail to parse")
+       }
+}

diff --git a/vendor/github.com/multiformats/go-multiaddr-net/.gitignore b/vendor/github.com/multiformats/go-multiaddr-net/.gitignore
new file mode 100644 (file)
index 0000000..a186a0e
--- /dev/null
+++ b/vendor/github.com/multiformats/go-multiaddr-net/.gitignore
@@ -0,0 +1,2 @@
+bin/gx*
+*.swp

diff --git a/vendor/github.com/multiformats/go-multiaddr-net/.gx/lastpubver b/vendor/github.com/multiformats/go-multiaddr-net/.gx/lastpubver
new file mode 100644 (file)
index 0000000..def8ce7
--- /dev/null
+++ b/vendor/github.com/multiformats/go-multiaddr-net/.gx/lastpubver
@@ -0,0 +1 @@
+1.7.1: QmZcLBXKaFe8ND5YHPkJRAwmhJGrVsi1JqDZNyJ4nRK5Mj

diff --git a/vendor/github.com/multiformats/go-multiaddr-net/.travis.yml b/vendor/github.com/multiformats/go-multiaddr-net/.travis.yml
new file mode 100644 (file)
index 0000000..c0c4fb2
--- /dev/null
+++ b/vendor/github.com/multiformats/go-multiaddr-net/.travis.yml
@@ -0,0 +1,24 @@
+os:
+  - linux
+
+sudo: true
+
+language: go
+
+go:
+    - 1.11
+
+install:
+  - make deps
+
+script:
+  - bash <(curl -s https://raw.githubusercontent.com/ipfs/ci-helpers/master/travis-ci/run-standard-tests.sh)
+
+cache:
+    directories:
+        - $GOPATH/src/gx
+
+notifications:
+  email: false
+
+env: GOTFLAGS="-race"

diff --git a/vendor/github.com/multiformats/go-multiaddr-net/LICENSE b/vendor/github.com/multiformats/go-multiaddr-net/LICENSE
new file mode 100644 (file)
index 0000000..c7386b3
--- /dev/null
+++ b/vendor/github.com/multiformats/go-multiaddr-net/LICENSE
@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2014 Juan Batiz-Benet
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

diff --git a/vendor/github.com/multiformats/go-multiaddr-net/Makefile b/vendor/github.com/multiformats/go-multiaddr-net/Makefile
new file mode 100644 (file)
index 0000000..5415256
--- /dev/null
+++ b/vendor/github.com/multiformats/go-multiaddr-net/Makefile
@@ -0,0 +1,9 @@
+export IPFS_API ?= v04x.ipfs.io
+
+gx:
+       go get -u github.com/whyrusleeping/gx
+       go get -u github.com/whyrusleeping/gx-go
+
+deps: gx
+       gx --verbose install --global
+       gx-go rewrite

diff --git a/vendor/github.com/multiformats/go-multiaddr-net/README.md b/vendor/github.com/multiformats/go-multiaddr-net/README.md
new file mode 100644 (file)
index 0000000..15a8a99
--- /dev/null
+++ b/vendor/github.com/multiformats/go-multiaddr-net/README.md
@@ -0,0 +1,71 @@
+# go-multiaddr-net
+
+[![](https://img.shields.io/badge/made%20by-Protocol%20Labs-blue.svg?style=flat-square)](http://ipn.io)
+[![](https://img.shields.io/badge/project-multiformats-blue.svg?style=flat-square)](https://github.com/multiformats/multiformats)
+[![](https://img.shields.io/badge/freenode-%23ipfs-blue.svg?style=flat-square)](https://webchat.freenode.net/?channels=%23ipfs)
+[![](https://img.shields.io/badge/readme%20style-standard-brightgreen.svg?style=flat-square)](https://github.com/RichardLitt/standard-readme)
+[![GoDoc](https://godoc.org/github.com/multiformats/go-multiaddr-net?status.svg)](https://godoc.org/github.com/multiformats/go-multiaddr-net)
+[![Travis CI](https://img.shields.io/travis/multiformats/go-multiaddr-net.svg?style=flat-square&branch=master)](https://travis-ci.org/multiformats/go-multiaddr-net)
+
+<!---[![codecov.io](https://img.shields.io/codecov/c/github/multiformats/go-multiaddr-net.svg?style=flat-square&branch=master)](https://codecov.io/github/multiformats/go-multiaddr-net?branch=master)--->
+
+> Multiaddress net tools
+
+This package provides [Multiaddr](https://github.com/multiformats/go-multiaddr) specific versions of common functions in [stdlib](https://github.com/golang/go/tree/master/src)'s `net` package. This means wrappers of standard net symbols like `net.Dial` and `net.Listen`, as well
+as conversion to and from `net.Addr`.
+
+## Table of Contents
+
+- [Install](#install)
+- [Usage](#usage)
+- [Maintainers](#maintainers)
+- [Contribute](#contribute)
+- [License](#license)
+
+## Install
+
+`go-multiaddr-net` is a standard Go module which can be installed with:
+
+```sh
+go get github.com/multiformats/go-multiaddr-net
+```
+
+Note that `go-multiaddr-net` is packaged with Gx, so it is recommended to use Gx to install and use it (see Usage section).
+
+
+## Usage
+
+This module is packaged with [Gx](https://github.com/whyrusleeping/gx). In order to use it in your own project do:
+
+```sh
+go get -u github.com/whyrusleeping/gx
+go get -u github.com/whyrusleeping/gx-go
+cd <your-project-repository>
+gx init
+gx import github.com/multiformats/go-multiaddr-net
+gx install --global
+gx-go --rewrite
+```
+
+Please check [Gx](https://github.com/whyrusleeping/gx) and [Gx-go](https://github.com/whyrusleeping/gx-go) documentation for more information.
+
+For further usage, see the docs:
+
+- `multiaddr/net`: https://godoc.org/github.com/multiformats/go-multiaddr-net
+- `multiaddr`: https://godoc.org/github.com/multiformats/go-multiaddr
+
+## Maintainers
+
+Captain: [@whyrusleeping](https://github.com/whyrusleeping).
+
+## Contribute
+
+Contributions welcome. Please check out [the issues](https://github.com/multiformats/go-multiaddr-net/issues).
+
+Check out our [contributing document](https://github.com/multiformats/multiformats/blob/master/contributing.md) for more information on how we work, and about contributing in general. Please be aware that all interactions related to multiformats are subject to the IPFS [Code of Conduct](https://github.com/ipfs/community/blob/master/code-of-conduct.md).
+
+Small note: If editing the README, please conform to the [standard-readme](https://github.com/RichardLitt/standard-readme) specification.
+
+## License
+
+[MIT](LICENSE) © 2014 Juan Batiz-Benet

diff --git a/vendor/github.com/multiformats/go-multiaddr-net/bin/dist_get b/vendor/github.com/multiformats/go-multiaddr-net/bin/dist_get
new file mode 100644 (file)
index 0000000..d6bdd12
--- /dev/null
+++ b/vendor/github.com/multiformats/go-multiaddr-net/bin/dist_get
@@ -0,0 +1,146 @@
+#!/bin/bash
+
+die() {
+       echo "$@" >&2
+       exit 1
+}
+
+have_binary() {
+       type "$1" > /dev/null 2> /dev/null
+}
+
+check_writeable() {
+       printf "" > "$1" && rm "$1"
+}
+
+download() {
+       local url="$1"
+       local output="$2"
+
+       if [ -z "$url" ] || [ -z "$output" ]; then
+               die "download takes exactly two arguments. was given '$@'"
+       fi
+
+       if ! check_writeable "$output"; then
+               die "download error: cannot write to $output"
+       fi
+
+       if have_binary wget; then
+               printf 'Using wget to download "%s" to "%s"\n' "$url" "$output"
+               wget "$url" -O "$output"
+       elif have_binary curl; then
+               printf 'Using curl to download "%s" to "%s"\n' "$url" "$output"
+               curl --silent "$url" > "$output"
+       elif have_binary fetch; then
+               printf 'Using fetch to download "%s" to "%s"\n' "$url" "$output"
+               fetch "$url" -o "$output"
+       else
+               die "no binary found to download $url. exiting."
+       fi
+}
+
+unarchive() {
+       local archivetype="$1"
+       local infile="$2"
+       local outfile="$3"
+       local distname="$4"
+
+       if ! check_writeable "$outfile"; then
+               die "unarchive error: cannot write to $outfile"
+       fi
+
+       case $archivetype in
+               tar.gz)
+                       if have_binary tar; then
+                               echo "==> using 'tar' to extract binary from archive"
+                               cat "$infile" | tar -O -z -x "$distname/$distname" > "$outfile"
+                       else
+                               die "no binary on system for extracting tar files"
+                       fi
+                       ;;
+               zip)
+                       if have_binary unzip; then
+                               echo "==> using 'unzip' to extract binary from archive"
+                               unzip -p "$infile" "$distname/$distname" > "$outfile"
+                       else
+                               die "no installed method for extracting .zip archives"
+                       fi
+                       ;;
+               *)
+                       die "unrecognized archive type '$archivetype'"
+       esac
+
+       chmod +x "$outfile"
+}
+
+get_go_vars() {
+       if [ ! -z "$GOOS" ] && [ ! -z "$GOARCH" ]; then
+               printf "%s-%s" "$GOOS" "$GOARCH"
+       fi
+
+       if have_binary go; then
+               printf "%s-%s" "$(go env GOOS)" "$(go env GOARCH)"
+       else
+               die "no way of determining system GOOS and GOARCH\nPlease manually set GOOS and GOARCH then retry."
+       fi
+}
+
+mkurl() {
+       local name="$1"
+       local vers="$2"
+       local archive="$3"
+
+       local govars=$(get_go_vars)
+
+       echo "http://dist.ipfs.io/$name/$vers/${name}_${vers}_$govars.$archive"
+}
+
+distname="$1"
+outpath="$2"
+version="$3"
+
+if [ -z "$distname" ] || [ -z "$outpath" ] || [ -z "$version" ]; then
+       die "usage: dist_get <distname> <outpath> <version>"
+fi
+
+if [ ${version:0:1} != "v" ]; then
+       echo "invalid version '$version'" >&2
+       die "versions must begin with 'v', for example: v0.4.0"
+fi
+
+# TODO: don't depend on the go tool being installed to detect this
+goenv=$(get_go_vars)
+
+case $goenv in
+       linux-*)
+               archive="tar.gz"
+               ;;
+       darwin-*)
+               archive="tar.gz"
+               ;;
+       windows-*)
+               archive="zip"
+               ;;
+       freebsd-*)
+               archive="tar.gz"
+               ;;
+       *)
+               echo "unrecognized system environment: $goenv" >&2
+               die "currently only linux, darwin, windows and freebsd are supported by this script"
+esac
+
+
+mkdir -p bin/tmp
+
+url=$(mkurl "$distname" "$version" "$archive")
+tmpfi="bin/tmp/$distname.$archive"
+
+download "$url" "$tmpfi"
+if [ $? -ne 0 ]; then
+       die "failed to download $url to $tmpfi"
+fi
+
+unarchive "$archive" "$tmpfi" "$outpath" "$distname"
+if [ $? -ne 0 ]; then
+       die "failed to exract archive $tmpfi"
+fi

diff --git a/vendor/github.com/multiformats/go-multiaddr-net/convert.go b/vendor/github.com/multiformats/go-multiaddr-net/convert.go
new file mode 100644 (file)
index 0000000..061f1c4
--- /dev/null
+++ b/vendor/github.com/multiformats/go-multiaddr-net/convert.go
@@ -0,0 +1,269 @@
+package manet
+
+import (
+       "fmt"
+       "net"
+       "path/filepath"
+
+       ma "github.com/multiformats/go-multiaddr"
+       madns "github.com/multiformats/go-multiaddr-dns"
+)
+
+var errIncorrectNetAddr = fmt.Errorf("incorrect network addr conversion")
+
+// FromNetAddr converts a net.Addr type to a Multiaddr.
+func FromNetAddr(a net.Addr) (ma.Multiaddr, error) {
+       return defaultCodecs.FromNetAddr(a)
+}
+
+// FromNetAddr converts a net.Addr to Multiaddress.
+func (cm *CodecMap) FromNetAddr(a net.Addr) (ma.Multiaddr, error) {
+       if a == nil {
+               return nil, fmt.Errorf("nil multiaddr")
+       }
+       p, err := cm.getAddrParser(a.Network())
+       if err != nil {
+               return nil, err
+       }
+
+       return p(a)
+}
+
+// ToNetAddr converts a Multiaddr to a net.Addr
+// Must be ThinWaist. acceptable protocol stacks are:
+// /ip{4,6}/{tcp, udp}
+func ToNetAddr(maddr ma.Multiaddr) (net.Addr, error) {
+       return defaultCodecs.ToNetAddr(maddr)
+}
+
+// ToNetAddr converts a Multiaddress to a standard net.Addr.
+func (cm *CodecMap) ToNetAddr(maddr ma.Multiaddr) (net.Addr, error) {
+       protos := maddr.Protocols()
+       final := protos[len(protos)-1]
+
+       p, err := cm.getMaddrParser(final.Name)
+       if err != nil {
+               return nil, err
+       }
+
+       return p(maddr)
+}
+
+func parseBasicNetMaddr(maddr ma.Multiaddr) (net.Addr, error) {
+       network, host, err := DialArgs(maddr)
+       if err != nil {
+               return nil, err
+       }
+
+       switch network {
+       case "tcp", "tcp4", "tcp6":
+               return net.ResolveTCPAddr(network, host)
+       case "udp", "udp4", "udp6":
+               return net.ResolveUDPAddr(network, host)
+       case "ip", "ip4", "ip6":
+               return net.ResolveIPAddr(network, host)
+       case "unix":
+               return net.ResolveUnixAddr(network, host)
+       }
+
+       return nil, fmt.Errorf("network not supported: %s", network)
+}
+
+func FromIPAndZone(ip net.IP, zone string) (ma.Multiaddr, error) {
+       switch {
+       case ip.To4() != nil:
+               return ma.NewComponent("ip4", ip.String())
+       case ip.To16() != nil:
+               ip6, err := ma.NewComponent("ip6", ip.String())
+               if err != nil {
+                       return nil, err
+               }
+               if zone == "" {
+                       return ip6, nil
+               } else {
+                       zone, err := ma.NewComponent("ip6zone", zone)
+                       if err != nil {
+                               return nil, err
+                       }
+                       return zone.Encapsulate(ip6), nil
+               }
+       default:
+               return nil, errIncorrectNetAddr
+       }
+}
+
+// FromIP converts a net.IP type to a Multiaddr.
+func FromIP(ip net.IP) (ma.Multiaddr, error) {
+       return FromIPAndZone(ip, "")
+}
+
+// DialArgs is a convenience function that returns network and address as
+// expected by net.Dial. See https://godoc.org/net#Dial for an overview of
+// possible return values (we do not support the unixpacket ones yet). Unix
+// addresses do not, at present, compose.
+func DialArgs(m ma.Multiaddr) (string, string, error) {
+       var (
+               zone, network, ip, port string
+               err                     error
+               hostname                bool
+       )
+
+       ma.ForEach(m, func(c ma.Component) bool {
+               switch network {
+               case "":
+                       switch c.Protocol().Code {
+                       case ma.P_IP6ZONE:
+                               if zone != "" {
+                                       err = fmt.Errorf("%s has multiple zones", m)
+                                       return false
+                               }
+                               zone = c.Value()
+                               return true
+                       case ma.P_IP6:
+                               network = "ip6"
+                               ip = c.Value()
+                               return true
+                       case ma.P_IP4:
+                               if zone != "" {
+                                       err = fmt.Errorf("%s has ip4 with zone", m)
+                                       return false
+                               }
+                               network = "ip4"
+                               ip = c.Value()
+                               return true
+                       case madns.Dns4Protocol.Code:
+                               network = "ip4"
+                               hostname = true
+                               ip = c.Value()
+                               return true
+                       case madns.Dns6Protocol.Code:
+                               network = "ip6"
+                               hostname = true
+                               ip = c.Value()
+                               return true
+                       case ma.P_UNIX:
+                               network = "unix"
+                               ip = c.Value()
+                               return false
+                       }
+               case "ip4":
+                       switch c.Protocol().Code {
+                       case ma.P_UDP:
+                               network = "udp4"
+                       case ma.P_TCP:
+                               network = "tcp4"
+                       default:
+                               return false
+                       }
+                       port = c.Value()
+               case "ip6":
+                       switch c.Protocol().Code {
+                       case ma.P_UDP:
+                               network = "udp6"
+                       case ma.P_TCP:
+                               network = "tcp6"
+                       default:
+                               return false
+                       }
+                       port = c.Value()
+               }
+               // Done.
+               return false
+       })
+       if err != nil {
+               return "", "", err
+       }
+
+       switch network {
+       case "ip6":
+               if zone != "" {
+                       ip += "%" + zone
+               }
+               fallthrough
+       case "ip4":
+               return network, ip, nil
+       case "tcp4", "udp4":
+               return network, ip + ":" + port, nil
+       case "tcp6", "udp6":
+               if zone != "" {
+                       ip += "%" + zone
+               }
+               if hostname {
+                       return network, ip + ":" + port, nil
+               }
+               return network, "[" + ip + "]" + ":" + port, nil
+       case "unix":
+               return network, ip, nil
+       default:
+               return "", "", fmt.Errorf("%s is not a 'thin waist' address", m)
+       }
+}
+
+func parseTCPNetAddr(a net.Addr) (ma.Multiaddr, error) {
+       ac, ok := a.(*net.TCPAddr)
+       if !ok {
+               return nil, errIncorrectNetAddr
+       }
+
+       // Get IP Addr
+       ipm, err := FromIPAndZone(ac.IP, ac.Zone)
+       if err != nil {
+               return nil, errIncorrectNetAddr
+       }
+
+       // Get TCP Addr
+       tcpm, err := ma.NewMultiaddr(fmt.Sprintf("/tcp/%d", ac.Port))
+       if err != nil {
+               return nil, errIncorrectNetAddr
+       }
+
+       // Encapsulate
+       return ipm.Encapsulate(tcpm), nil
+}
+
+func parseUDPNetAddr(a net.Addr) (ma.Multiaddr, error) {
+       ac, ok := a.(*net.UDPAddr)
+       if !ok {
+               return nil, errIncorrectNetAddr
+       }
+
+       // Get IP Addr
+       ipm, err := FromIPAndZone(ac.IP, ac.Zone)
+       if err != nil {
+               return nil, errIncorrectNetAddr
+       }
+
+       // Get UDP Addr
+       udpm, err := ma.NewMultiaddr(fmt.Sprintf("/udp/%d", ac.Port))
+       if err != nil {
+               return nil, errIncorrectNetAddr
+       }
+
+       // Encapsulate
+       return ipm.Encapsulate(udpm), nil
+}
+
+func parseIPNetAddr(a net.Addr) (ma.Multiaddr, error) {
+       ac, ok := a.(*net.IPAddr)
+       if !ok {
+               return nil, errIncorrectNetAddr
+       }
+       return FromIPAndZone(ac.IP, ac.Zone)
+}
+
+func parseIPPlusNetAddr(a net.Addr) (ma.Multiaddr, error) {
+       ac, ok := a.(*net.IPNet)
+       if !ok {
+               return nil, errIncorrectNetAddr
+       }
+       return FromIP(ac.IP)
+}
+
+func parseUnixNetAddr(a net.Addr) (ma.Multiaddr, error) {
+       ac, ok := a.(*net.UnixAddr)
+       if !ok {
+               return nil, errIncorrectNetAddr
+       }
+       cleaned := filepath.Clean(ac.Name)
+       return ma.NewComponent("unix", cleaned)
+}

diff --git a/vendor/github.com/multiformats/go-multiaddr-net/convert_test.go b/vendor/github.com/multiformats/go-multiaddr-net/convert_test.go
new file mode 100644 (file)
index 0000000..33250a0
--- /dev/null
+++ b/vendor/github.com/multiformats/go-multiaddr-net/convert_test.go
@@ -0,0 +1,175 @@
+package manet
+
+import (
+       "net"
+       "testing"
+
+       ma "github.com/multiformats/go-multiaddr"
+)
+
+type GenFunc func() (ma.Multiaddr, error)
+
+func testConvert(t *testing.T, s string, gen GenFunc) {
+       m, err := gen()
+       if err != nil {
+               t.Fatal("failed to generate.")
+       }
+
+       if s2 := m.String(); err != nil || s2 != s {
+               t.Fatal("failed to convert: " + s + " != " + s2)
+       }
+}
+
+func testToNetAddr(t *testing.T, maddr, ntwk, addr string) {
+       m, err := ma.NewMultiaddr(maddr)
+       if err != nil {
+               t.Fatal("failed to generate.")
+       }
+
+       naddr, err := ToNetAddr(m)
+       if addr == "" { // should fail
+               if err == nil {
+                       t.Fatalf("failed to error: %s", m)
+               }
+               return
+       }
+
+       // shouldn't fail
+       if err != nil {
+               t.Fatalf("failed to convert to net addr: %s", m)
+       }
+
+       if naddr.String() != addr {
+               t.Fatalf("naddr.Address() == %s != %s", naddr, addr)
+       }
+
+       if naddr.Network() != ntwk {
+               t.Fatalf("naddr.Network() == %s != %s", naddr.Network(), ntwk)
+       }
+
+       // should convert properly
+       switch ntwk {
+       case "tcp":
+               _ = naddr.(*net.TCPAddr)
+       case "udp":
+               _ = naddr.(*net.UDPAddr)
+       case "ip":
+               _ = naddr.(*net.IPAddr)
+       }
+}
+
+func TestFromIP4(t *testing.T) {
+       testConvert(t, "/ip4/10.20.30.40", func() (ma.Multiaddr, error) {
+               return FromNetAddr(&net.IPAddr{IP: net.ParseIP("10.20.30.40")})
+       })
+}
+
+func TestFromIP6(t *testing.T) {
+       testConvert(t, "/ip6/2001:4860:0:2001::68", func() (ma.Multiaddr, error) {
+               return FromNetAddr(&net.IPAddr{IP: net.ParseIP("2001:4860:0:2001::68")})
+       })
+}
+
+func TestFromTCP(t *testing.T) {
+       testConvert(t, "/ip4/10.20.30.40/tcp/1234", func() (ma.Multiaddr, error) {
+               return FromNetAddr(&net.TCPAddr{
+                       IP:   net.ParseIP("10.20.30.40"),
+                       Port: 1234,
+               })
+       })
+}
+
+func TestFromUDP(t *testing.T) {
+       testConvert(t, "/ip4/10.20.30.40/udp/1234", func() (ma.Multiaddr, error) {
+               return FromNetAddr(&net.UDPAddr{
+                       IP:   net.ParseIP("10.20.30.40"),
+                       Port: 1234,
+               })
+       })
+}
+
+func TestThinWaist(t *testing.T) {
+       addrs := map[string]bool{
+               "/ip4/127.0.0.1/udp/1234":                true,
+               "/ip4/127.0.0.1/tcp/1234":                true,
+               "/ip4/127.0.0.1/udp/1234/tcp/1234":       true,
+               "/ip4/127.0.0.1/tcp/12345/ip4/1.2.3.4":   true,
+               "/ip6/::1/tcp/80":                        true,
+               "/ip6/::1/udp/80":                        true,
+               "/ip6/::1":                               true,
+               "/ip6zone/hello/ip6/fe80::1/tcp/80":      true,
+               "/ip6zone/hello/ip6/fe80::1":             true,
+               "/tcp/1234/ip4/1.2.3.4":                  false,
+               "/tcp/1234":                              false,
+               "/tcp/1234/udp/1234":                     false,
+               "/ip4/1.2.3.4/ip4/2.3.4.5":               true,
+               "/ip6/fe80::1/ip4/2.3.4.5":               true,
+               "/ip6zone/hello/ip6/fe80::1/ip4/2.3.4.5": true,
+
+               // Invalid ip6zone usage:
+               "/ip6zone/hello":             false,
+               "/ip6zone/hello/ip4/1.1.1.1": false,
+       }
+
+       for a, res := range addrs {
+               m, err := ma.NewMultiaddr(a)
+               if err != nil {
+                       t.Fatalf("failed to construct Multiaddr: %s", a)
+               }
+
+               if IsThinWaist(m) != res {
+                       t.Fatalf("IsThinWaist(%s) != %v", a, res)
+               }
+       }
+}
+
+func TestDialArgs(t *testing.T) {
+       test := func(e_maddr, e_nw, e_host string) {
+               m, err := ma.NewMultiaddr(e_maddr)
+               if err != nil {
+                       t.Fatal("failed to construct", e_maddr)
+               }
+
+               nw, host, err := DialArgs(m)
+               if err != nil {
+                       t.Fatal("failed to get dial args", e_maddr, m, err)
+               }
+
+               if nw != e_nw {
+                       t.Error("failed to get udp network Dial Arg", e_nw, nw)
+               }
+
+               if host != e_host {
+                       t.Error("failed to get host:port Dial Arg", e_host, host)
+               }
+       }
+
+       test_error := func(e_maddr string) {
+               m, err := ma.NewMultiaddr(e_maddr)
+               if err != nil {
+                       t.Fatal("failed to construct", e_maddr)
+               }
+
+               _, _, err = DialArgs(m)
+               if err == nil {
+                       t.Fatal("expected DialArgs to fail on", e_maddr)
+               }
+       }
+
+       test("/ip4/127.0.0.1/udp/1234", "udp4", "127.0.0.1:1234")
+       test("/ip4/127.0.0.1/tcp/4321", "tcp4", "127.0.0.1:4321")
+       test("/ip6/::1/udp/1234", "udp6", "[::1]:1234")
+       test("/ip6/::1/tcp/4321", "tcp6", "[::1]:4321")
+       test("/ip6/::1", "ip6", "::1")                                  // Just an IP
+       test("/ip4/1.2.3.4", "ip4", "1.2.3.4")                          // Just an IP
+       test("/ip6zone/foo/ip6/::1/tcp/4321", "tcp6", "[::1%foo]:4321") // zone
+       test("/ip6zone/foo/ip6/::1/udp/4321", "udp6", "[::1%foo]:4321") // zone
+       test("/ip6zone/foo/ip6/::1", "ip6", "::1%foo")                  // no TCP
+       test_error("/ip6zone/foo/ip4/127.0.0.1")                        // IP4 doesn't take zone
+       test("/ip6zone/foo/ip6/::1/ip6zone/bar", "ip6", "::1%foo")      // IP over IP
+       test_error("/ip6zone/foo/ip6zone/bar/ip6/::1")                  // Only one zone per IP6
+       test("/dns4/abc.com/tcp/1234", "tcp4", "abc.com:1234")          // DNS4:port
+       test("/dns4/abc.com", "ip4", "abc.com")                         // Just DNS4
+       test("/dns6/abc.com/udp/1234", "udp6", "abc.com:1234")          // DNS6:port
+       test("/dns6/abc.com", "ip6", "abc.com")                         // Just DNS6
+}

diff --git a/vendor/github.com/multiformats/go-multiaddr-net/doc.go b/vendor/github.com/multiformats/go-multiaddr-net/doc.go
new file mode 100644 (file)
index 0000000..040ad3f
--- /dev/null
+++ b/vendor/github.com/multiformats/go-multiaddr-net/doc.go
@@ -0,0 +1,5 @@
+// Package manet provides Multiaddr specific versions of common
+// functions in stdlib's net package. This means wrappers of
+// standard net symbols like net.Dial and net.Listen, as well
+// as conversion to/from net.Addr.
+package manet

diff --git a/vendor/github.com/multiformats/go-multiaddr-net/ip.go b/vendor/github.com/multiformats/go-multiaddr-net/ip.go
new file mode 100644 (file)
index 0000000..1cf9a77
--- /dev/null
+++ b/vendor/github.com/multiformats/go-multiaddr-net/ip.go
@@ -0,0 +1,118 @@
+package manet
+
+import (
+       "net"
+
+       ma "github.com/multiformats/go-multiaddr"
+)
+
+// Loopback Addresses
+var (
+       // IP4Loopback is the ip4 loopback multiaddr
+       IP4Loopback = ma.StringCast("/ip4/127.0.0.1")
+
+       // IP6Loopback is the ip6 loopback multiaddr
+       IP6Loopback = ma.StringCast("/ip6/::1")
+
+       // IP4MappedIP6Loopback is the IPv4 Mapped IPv6 loopback address.
+       IP4MappedIP6Loopback = ma.StringCast("/ip6/::ffff:127.0.0.1")
+)
+
+// Unspecified Addresses (used for )
+var (
+       IP4Unspecified = ma.StringCast("/ip4/0.0.0.0")
+       IP6Unspecified = ma.StringCast("/ip6/::")
+)
+
+// IsThinWaist returns whether a Multiaddr starts with "Thin Waist" Protocols.
+// This means: /{IP4, IP6}[/{TCP, UDP}]
+func IsThinWaist(m ma.Multiaddr) bool {
+       m = zoneless(m)
+       if m == nil {
+               return false
+       }
+       p := m.Protocols()
+
+       // nothing? not even a waist.
+       if len(p) == 0 {
+               return false
+       }
+
+       if p[0].Code != ma.P_IP4 && p[0].Code != ma.P_IP6 {
+               return false
+       }
+
+       // only IP? still counts.
+       if len(p) == 1 {
+               return true
+       }
+
+       switch p[1].Code {
+       case ma.P_TCP, ma.P_UDP, ma.P_IP4, ma.P_IP6:
+               return true
+       default:
+               return false
+       }
+}
+
+// IsIPLoopback returns whether a Multiaddr starts with a "Loopback" IP address
+// This means either /ip4/127.*.*.*/*, /ip6/::1/*, or /ip6/::ffff:127.*.*.*.*/*,
+// or /ip6zone/<any value>/ip6/<one of the preceding ip6 values>/*
+func IsIPLoopback(m ma.Multiaddr) bool {
+       m = zoneless(m)
+       c, _ := ma.SplitFirst(m)
+       if c == nil {
+               return false
+       }
+       switch c.Protocol().Code {
+       case ma.P_IP4, ma.P_IP6:
+               return net.IP(c.RawValue()).IsLoopback()
+       }
+       return false
+}
+
+// IsIP6LinkLocal returns whether a Multiaddr starts with an IPv6 link-local
+// multiaddress (with zero or one leading zone). These addresses are non
+// routable.
+func IsIP6LinkLocal(m ma.Multiaddr) bool {
+       m = zoneless(m)
+       c, _ := ma.SplitFirst(m)
+       if c == nil || c.Protocol().Code != ma.P_IP6 {
+               return false
+       }
+       ip := net.IP(c.RawValue())
+       return ip.IsLinkLocalMulticast() || ip.IsLinkLocalUnicast()
+}
+
+// IsIPUnspecified returns whether a Multiaddr starts with an Unspecified IP address
+// This means either /ip4/0.0.0.0/* or /ip6/::/*
+func IsIPUnspecified(m ma.Multiaddr) bool {
+       m = zoneless(m)
+       if m == nil {
+               return false
+       }
+       c, _ := ma.SplitFirst(m)
+       return net.IP(c.RawValue()).IsUnspecified()
+}
+
+// If m matches [zone,ip6,...], return [ip6,...]
+// else if m matches [], [zone], or [zone,...], return nil
+// else return m
+func zoneless(m ma.Multiaddr) ma.Multiaddr {
+       head, tail := ma.SplitFirst(m)
+       if head == nil {
+               return nil
+       }
+       if head.Protocol().Code == ma.P_IP6ZONE {
+               if tail == nil {
+                       return nil
+               }
+               tailhead, _ := ma.SplitFirst(tail)
+               if tailhead.Protocol().Code != ma.P_IP6 {
+                       return nil
+               }
+               return tail
+       } else {
+               return m
+       }
+}

diff --git a/vendor/github.com/multiformats/go-multiaddr-net/multiaddr/.gitignore b/vendor/github.com/multiformats/go-multiaddr-net/multiaddr/.gitignore
new file mode 100644 (file)
index 0000000..e4dcb09
--- /dev/null
+++ b/vendor/github.com/multiformats/go-multiaddr-net/multiaddr/.gitignore
@@ -0,0 +1 @@
+multiaddr

diff --git a/vendor/github.com/multiformats/go-multiaddr-net/multiaddr/multiaddr.go b/vendor/github.com/multiformats/go-multiaddr-net/multiaddr/multiaddr.go
new file mode 100644 (file)
index 0000000..5faf35f
--- /dev/null
+++ b/vendor/github.com/multiformats/go-multiaddr-net/multiaddr/multiaddr.go
@@ -0,0 +1,96 @@
+package main
+
+import (
+       "encoding/hex"
+       "flag"
+       "fmt"
+       "os"
+
+       ma "github.com/multiformats/go-multiaddr"
+       manet "github.com/multiformats/go-multiaddr-net"
+)
+
+// flags
+var formats = []string{"string", "bytes", "hex", "slice"}
+var format string
+var hideLoopback bool
+
+func init() {
+       flag.Usage = func() {
+               fmt.Fprintf(os.Stderr, "usage: %s [<multiaddr>]\n\nFlags:\n", os.Args[0])
+               flag.PrintDefaults()
+       }
+
+       usage := fmt.Sprintf("output format, one of: %v", formats)
+       flag.StringVar(&format, "format", "string", usage)
+       flag.StringVar(&format, "f", "string", usage+" (shorthand)")
+       flag.BoolVar(&hideLoopback, "hide-loopback", false, "do not display loopback addresses")
+}
+
+func main() {
+       flag.Parse()
+       args := flag.Args()
+       if len(args) == 0 {
+               output(localAddresses()...)
+       } else {
+               output(address(args[0]))
+       }
+}
+
+func localAddresses() []ma.Multiaddr {
+       maddrs, err := manet.InterfaceMultiaddrs()
+       if err != nil {
+               die(err)
+       }
+
+       if !hideLoopback {
+               return maddrs
+       }
+
+       var maddrs2 []ma.Multiaddr
+       for _, a := range maddrs {
+               if !manet.IsIPLoopback(a) {
+                       maddrs2 = append(maddrs2, a)
+               }
+       }
+
+       return maddrs2
+}
+
+func address(addr string) ma.Multiaddr {
+       m, err := ma.NewMultiaddr(addr)
+       if err != nil {
+               die(err)
+       }
+
+       return m
+}
+
+func output(ms ...ma.Multiaddr) {
+       for _, m := range ms {
+               fmt.Println(outfmt(m))
+       }
+}
+
+func outfmt(m ma.Multiaddr) string {
+       switch format {
+       case "string":
+               return m.String()
+       case "slice":
+               return fmt.Sprintf("%v", m.Bytes())
+       case "bytes":
+               return string(m.Bytes())
+       case "hex":
+               return "0x" + hex.EncodeToString(m.Bytes())
+       }
+
+       die("error: invalid format", format)
+       return ""
+}
+
+func die(v ...interface{}) {
+       fmt.Fprint(os.Stderr, v...)
+       fmt.Fprint(os.Stderr, "\n")
+       flag.Usage()
+       os.Exit(-1)
+}

diff --git a/vendor/github.com/multiformats/go-multiaddr-net/net.go b/vendor/github.com/multiformats/go-multiaddr-net/net.go
new file mode 100644 (file)
index 0000000..ac35530
--- /dev/null
+++ b/vendor/github.com/multiformats/go-multiaddr-net/net.go
@@ -0,0 +1,427 @@
+// Package manet provides Multiaddr
+// (https://github.com/multiformats/go-multiaddr) specific versions of common
+// functions in Go's standard `net` package. This means wrappers of standard
+// net symbols like `net.Dial` and `net.Listen`, as well as conversion to
+// and from `net.Addr`.
+package manet
+
+import (
+       "context"
+       "fmt"
+       "net"
+
+       ma "github.com/multiformats/go-multiaddr"
+)
+
+// Conn is the equivalent of a net.Conn object. It is the
+// result of calling the Dial or Listen functions in this
+// package, with associated local and remote Multiaddrs.
+type Conn interface {
+       net.Conn
+
+       // LocalMultiaddr returns the local Multiaddr associated
+       // with this connection
+       LocalMultiaddr() ma.Multiaddr
+
+       // RemoteMultiaddr returns the remote Multiaddr associated
+       // with this connection
+       RemoteMultiaddr() ma.Multiaddr
+}
+
+type halfOpen interface {
+       net.Conn
+       CloseRead() error
+       CloseWrite() error
+}
+
+func wrap(nconn net.Conn, laddr, raddr ma.Multiaddr) Conn {
+       endpts := maEndpoints{
+               laddr: laddr,
+               raddr: raddr,
+       }
+       // This sucks. However, it's the only way to reliably expose the
+       // underlying methods. This way, users that need access to, e.g.,
+       // CloseRead and CloseWrite, can do so via type assertions.
+       switch nconn := nconn.(type) {
+       case *net.TCPConn:
+               return &struct {
+                       *net.TCPConn
+                       maEndpoints
+               }{nconn, endpts}
+       case *net.UDPConn:
+               return &struct {
+                       *net.UDPConn
+                       maEndpoints
+               }{nconn, endpts}
+       case *net.IPConn:
+               return &struct {
+                       *net.IPConn
+                       maEndpoints
+               }{nconn, endpts}
+       case *net.UnixConn:
+               return &struct {
+                       *net.UnixConn
+                       maEndpoints
+               }{nconn, endpts}
+       case halfOpen:
+               return &struct {
+                       halfOpen
+                       maEndpoints
+               }{nconn, endpts}
+       default:
+               return &struct {
+                       net.Conn
+                       maEndpoints
+               }{nconn, endpts}
+       }
+}
+
+// WrapNetConn wraps a net.Conn object with a Multiaddr friendly Conn.
+//
+// This function does it's best to avoid "hiding" methods exposed by the wrapped
+// type. Guarantees:
+//
+// * If the wrapped connection exposes the "half-open" closer methods
+//   (CloseWrite, CloseRead), these will be available on the wrapped connection
+//   via type assertions.
+// * If the wrapped connection is a UnixConn, IPConn, TCPConn, or UDPConn, all
+//   methods on these wrapped connections will be available via type assertions.
+func WrapNetConn(nconn net.Conn) (Conn, error) {
+       if nconn == nil {
+               return nil, fmt.Errorf("failed to convert nconn.LocalAddr: nil")
+       }
+
+       laddr, err := FromNetAddr(nconn.LocalAddr())
+       if err != nil {
+               return nil, fmt.Errorf("failed to convert nconn.LocalAddr: %s", err)
+       }
+
+       raddr, err := FromNetAddr(nconn.RemoteAddr())
+       if err != nil {
+               return nil, fmt.Errorf("failed to convert nconn.RemoteAddr: %s", err)
+       }
+
+       return wrap(nconn, laddr, raddr), nil
+}
+
+type maEndpoints struct {
+       laddr ma.Multiaddr
+       raddr ma.Multiaddr
+}
+
+// LocalMultiaddr returns the local address associated with
+// this connection
+func (c *maEndpoints) LocalMultiaddr() ma.Multiaddr {
+       return c.laddr
+}
+
+// RemoteMultiaddr returns the remote address associated with
+// this connection
+func (c *maEndpoints) RemoteMultiaddr() ma.Multiaddr {
+       return c.raddr
+}
+
+// Dialer contains options for connecting to an address. It
+// is effectively the same as net.Dialer, but its LocalAddr
+// and RemoteAddr options are Multiaddrs, instead of net.Addrs.
+type Dialer struct {
+
+       // Dialer is just an embedded net.Dialer, with all its options.
+       net.Dialer
+
+       // LocalAddr is the local address to use when dialing an
+       // address. The address must be of a compatible type for the
+       // network being dialed.
+       // If nil, a local address is automatically chosen.
+       LocalAddr ma.Multiaddr
+}
+
+// Dial connects to a remote address, using the options of the
+// Dialer. Dialer uses an underlying net.Dialer to Dial a
+// net.Conn, then wraps that in a Conn object (with local and
+// remote Multiaddrs).
+func (d *Dialer) Dial(remote ma.Multiaddr) (Conn, error) {
+       return d.DialContext(context.Background(), remote)
+}
+
+// DialContext allows to provide a custom context to Dial().
+func (d *Dialer) DialContext(ctx context.Context, remote ma.Multiaddr) (Conn, error) {
+       // if a LocalAddr is specified, use it on the embedded dialer.
+       if d.LocalAddr != nil {
+               // convert our multiaddr to net.Addr friendly
+               naddr, err := ToNetAddr(d.LocalAddr)
+               if err != nil {
+                       return nil, err
+               }
+
+               // set the dialer's LocalAddr as naddr
+               d.Dialer.LocalAddr = naddr
+       }
+
+       // get the net.Dial friendly arguments from the remote addr
+       rnet, rnaddr, err := DialArgs(remote)
+       if err != nil {
+               return nil, err
+       }
+
+       // ok, Dial!
+       var nconn net.Conn
+       switch rnet {
+       case "tcp", "tcp4", "tcp6", "udp", "udp4", "udp6", "unix":
+               nconn, err = d.Dialer.DialContext(ctx, rnet, rnaddr)
+               if err != nil {
+                       return nil, err
+               }
+       default:
+               return nil, fmt.Errorf("unrecognized network: %s", rnet)
+       }
+
+       // get local address (pre-specified or assigned within net.Conn)
+       local := d.LocalAddr
+       // This block helps us avoid parsing addresses in transports (such as unix
+       // sockets) that don't have local addresses when dialing out.
+       if local == nil && nconn.LocalAddr().String() != "" {
+               local, err = FromNetAddr(nconn.LocalAddr())
+               if err != nil {
+                       return nil, err
+               }
+       }
+       return wrap(nconn, local, remote), nil
+}
+
+// Dial connects to a remote address. It uses an underlying net.Conn,
+// then wraps it in a Conn object (with local and remote Multiaddrs).
+func Dial(remote ma.Multiaddr) (Conn, error) {
+       return (&Dialer{}).Dial(remote)
+}
+
+// A Listener is a generic network listener for stream-oriented protocols.
+// it uses an embedded net.Listener, overriding net.Listener.Accept to
+// return a Conn and providing Multiaddr.
+type Listener interface {
+       // Accept waits for and returns the next connection to the listener.
+       // Returns a Multiaddr friendly Conn
+       Accept() (Conn, error)
+
+       // Close closes the listener.
+       // Any blocked Accept operations will be unblocked and return errors.
+       Close() error
+
+       // Multiaddr returns the listener's (local) Multiaddr.
+       Multiaddr() ma.Multiaddr
+
+       // Addr returns the net.Listener's network address.
+       Addr() net.Addr
+}
+
+type netListenerAdapter struct {
+       Listener
+}
+
+func (nla *netListenerAdapter) Accept() (net.Conn, error) {
+       return nla.Listener.Accept()
+}
+
+// NetListener turns this Listener into a net.Listener.
+//
+// * Connections returned from Accept implement multiaddr-net Conn.
+// * Calling WrapNetListener on the net.Listener returned by this function will
+//   return the original (underlying) multiaddr-net Listener.
+func NetListener(l Listener) net.Listener {
+       return &netListenerAdapter{l}
+}
+
+// maListener implements Listener
+type maListener struct {
+       net.Listener
+       laddr ma.Multiaddr
+}
+
+// Accept waits for and returns the next connection to the listener.
+// Returns a Multiaddr friendly Conn
+func (l *maListener) Accept() (Conn, error) {
+       nconn, err := l.Listener.Accept()
+       if err != nil {
+               return nil, err
+       }
+
+       var raddr ma.Multiaddr
+       // This block protects us in transports (i.e. unix sockets) that don't have
+       // remote addresses for inbound connections.
+       if nconn.RemoteAddr().String() != "" {
+               raddr, err = FromNetAddr(nconn.RemoteAddr())
+               if err != nil {
+                       return nil, fmt.Errorf("failed to convert conn.RemoteAddr: %s", err)
+               }
+       }
+
+       return wrap(nconn, l.laddr, raddr), nil
+}
+
+// Multiaddr returns the listener's (local) Multiaddr.
+func (l *maListener) Multiaddr() ma.Multiaddr {
+       return l.laddr
+}
+
+// Addr returns the listener's network address.
+func (l *maListener) Addr() net.Addr {
+       return l.Listener.Addr()
+}
+
+// Listen announces on the local network address laddr.
+// The Multiaddr must be a "ThinWaist" stream-oriented network:
+// ip4/tcp, ip6/tcp, (TODO: unix, unixpacket)
+// See Dial for the syntax of laddr.
+func Listen(laddr ma.Multiaddr) (Listener, error) {
+
+       // get the net.Listen friendly arguments from the remote addr
+       lnet, lnaddr, err := DialArgs(laddr)
+       if err != nil {
+               return nil, err
+       }
+
+       nl, err := net.Listen(lnet, lnaddr)
+       if err != nil {
+               return nil, err
+       }
+
+       // we want to fetch the new multiaddr from the listener, as it may
+       // have resolved to some other value. WrapNetListener does it for us.
+       return WrapNetListener(nl)
+}
+
+// WrapNetListener wraps a net.Listener with a manet.Listener.
+func WrapNetListener(nl net.Listener) (Listener, error) {
+       if nla, ok := nl.(*netListenerAdapter); ok {
+               return nla.Listener, nil
+       }
+
+       laddr, err := FromNetAddr(nl.Addr())
+       if err != nil {
+               return nil, err
+       }
+
+       return &maListener{
+               Listener: nl,
+               laddr:    laddr,
+       }, nil
+}
+
+// A PacketConn is a generic packet oriented network connection which uses an
+// underlying net.PacketConn, wrapped with the locally bound Multiaddr.
+type PacketConn interface {
+       Connection() net.PacketConn
+
+       Multiaddr() ma.Multiaddr
+
+       ReadFrom(b []byte) (int, ma.Multiaddr, error)
+       WriteTo(b []byte, maddr ma.Multiaddr) (int, error)
+
+       Close() error
+}
+
+// maPacketConn implements PacketConn
+type maPacketConn struct {
+       net.PacketConn
+       laddr ma.Multiaddr
+}
+
+// Connection returns the embedded net.PacketConn.
+func (l *maPacketConn) Connection() net.PacketConn {
+       return l.PacketConn
+}
+
+// Multiaddr returns the bound local Multiaddr.
+func (l *maPacketConn) Multiaddr() ma.Multiaddr {
+       return l.laddr
+}
+
+func (l *maPacketConn) ReadFrom(b []byte) (int, ma.Multiaddr, error) {
+       n, addr, err := l.PacketConn.ReadFrom(b)
+       maddr, _ := FromNetAddr(addr)
+       return n, maddr, err
+}
+
+func (l *maPacketConn) WriteTo(b []byte, maddr ma.Multiaddr) (int, error) {
+       addr, err := ToNetAddr(maddr)
+       if err != nil {
+               return 0, err
+       }
+       return l.PacketConn.WriteTo(b, addr)
+}
+
+// ListenPacket announces on the local network address laddr.
+// The Multiaddr must be a packet driven network, like udp4 or udp6.
+// See Dial for the syntax of laddr.
+func ListenPacket(laddr ma.Multiaddr) (PacketConn, error) {
+       lnet, lnaddr, err := DialArgs(laddr)
+       if err != nil {
+               return nil, err
+       }
+
+       pc, err := net.ListenPacket(lnet, lnaddr)
+       if err != nil {
+               return nil, err
+       }
+
+       // We want to fetch the new multiaddr from the listener, as it may
+       // have resolved to some other value. WrapPacketConn does this.
+       return WrapPacketConn(pc)
+}
+
+// WrapPacketConn wraps a net.PacketConn with a manet.PacketConn.
+func WrapPacketConn(pc net.PacketConn) (PacketConn, error) {
+       laddr, err := FromNetAddr(pc.LocalAddr())
+       if err != nil {
+               return nil, err
+       }
+
+       return &maPacketConn{
+               PacketConn: pc,
+               laddr:      laddr,
+       }, nil
+}
+
+// InterfaceMultiaddrs will return the addresses matching net.InterfaceAddrs
+func InterfaceMultiaddrs() ([]ma.Multiaddr, error) {
+       addrs, err := net.InterfaceAddrs()
+       if err != nil {
+               return nil, err
+       }
+
+       maddrs := make([]ma.Multiaddr, len(addrs))
+       for i, a := range addrs {
+               maddrs[i], err = FromNetAddr(a)
+               if err != nil {
+                       return nil, err
+               }
+       }
+       return maddrs, nil
+}
+
+// AddrMatch returns the Multiaddrs that match the protocol stack on addr
+func AddrMatch(match ma.Multiaddr, addrs []ma.Multiaddr) []ma.Multiaddr {
+
+       // we should match transports entirely.
+       p1s := match.Protocols()
+
+       out := make([]ma.Multiaddr, 0, len(addrs))
+       for _, a := range addrs {
+               p2s := a.Protocols()
+               if len(p1s) != len(p2s) {
+                       continue
+               }
+
+               match := true
+               for i, p2 := range p2s {
+                       if p1s[i].Code != p2.Code {
+                               match = false
+                               break
+                       }
+               }
+               if match {
+                       out = append(out, a)
+               }
+       }
+       return out
+}

diff --git a/vendor/github.com/multiformats/go-multiaddr-net/net_test.go b/vendor/github.com/multiformats/go-multiaddr-net/net_test.go
new file mode 100644 (file)
index 0000000..0a070e8
--- /dev/null
+++ b/vendor/github.com/multiformats/go-multiaddr-net/net_test.go
@@ -0,0 +1,666 @@
+package manet
+
+import (
+       "bytes"
+       "fmt"
+       "io/ioutil"
+       "net"
+       "os"
+       "path/filepath"
+       "sync"
+       "testing"
+       "time"
+
+       ma "github.com/multiformats/go-multiaddr"
+)
+
+func newMultiaddr(t *testing.T, m string) ma.Multiaddr {
+       maddr, err := ma.NewMultiaddr(m)
+       if err != nil {
+               t.Fatal("failed to construct multiaddr:", m, err)
+       }
+       return maddr
+}
+
+func TestDial(t *testing.T) {
+
+       listener, err := net.Listen("tcp", "127.0.0.1:4321")
+       if err != nil {
+               t.Fatal("failed to listen")
+       }
+
+       var wg sync.WaitGroup
+       wg.Add(1)
+       go func() {
+
+               cB, err := listener.Accept()
+               if err != nil {
+                       t.Fatal("failed to accept")
+               }
+
+               // echo out
+               buf := make([]byte, 1024)
+               for {
+                       _, err := cB.Read(buf)
+                       if err != nil {
+                               break
+                       }
+                       cB.Write(buf)
+               }
+
+               wg.Done()
+       }()
+
+       maddr := newMultiaddr(t, "/ip4/127.0.0.1/tcp/4321")
+       cA, err := Dial(maddr)
+       if err != nil {
+               t.Fatal("failed to dial")
+       }
+
+       buf := make([]byte, 1024)
+       if _, err := cA.Write([]byte("beep boop")); err != nil {
+               t.Fatal("failed to write:", err)
+       }
+
+       if _, err := cA.Read(buf); err != nil {
+               t.Fatal("failed to read:", buf, err)
+       }
+
+       if !bytes.Equal(buf[:9], []byte("beep boop")) {
+               t.Fatal("failed to echo:", buf)
+       }
+
+       maddr2 := cA.RemoteMultiaddr()
+       if !maddr2.Equal(maddr) {
+               t.Fatal("remote multiaddr not equal:", maddr, maddr2)
+       }
+
+       cA.Close()
+       wg.Wait()
+}
+
+func TestUnixSockets(t *testing.T) {
+       dir, err := ioutil.TempDir(os.TempDir(), "manettest")
+       if err != nil {
+               t.Fatal(err)
+       }
+       path := filepath.Join(dir, "listen.sock")
+       maddr := newMultiaddr(t, "/unix/"+path)
+
+       listener, err := Listen(maddr)
+       if err != nil {
+               t.Fatal(err)
+       }
+
+       payload := []byte("hello")
+
+       // listen
+       done := make(chan struct{}, 1)
+       go func() {
+               conn, err := listener.Accept()
+               if err != nil {
+                       t.Fatal(err)
+               }
+               defer conn.Close()
+               buf := make([]byte, 1024)
+               n, err := conn.Read(buf)
+               if err != nil {
+                       t.Fatal(err)
+               }
+               if n != len(payload) {
+                       t.Fatal("failed to read appropriate number of bytes")
+               }
+               if !bytes.Equal(buf[0:n], payload) {
+                       t.Fatal("payload did not match")
+               }
+               done <- struct{}{}
+       }()
+
+       // dial
+       conn, err := Dial(maddr)
+       if err != nil {
+               t.Fatal(err)
+       }
+       n, err := conn.Write(payload)
+       if err != nil {
+               t.Fatal(err)
+       }
+       if n != len(payload) {
+               t.Fatal("failed to write appropriate number of bytes")
+       }
+       select {
+       case <-done:
+       case <-time.After(1 * time.Second):
+               t.Fatal("timed out waiting for read")
+       }
+}
+
+func TestListen(t *testing.T) {
+
+       maddr := newMultiaddr(t, "/ip4/127.0.0.1/tcp/4322")
+       listener, err := Listen(maddr)
+       if err != nil {
+               t.Fatal("failed to listen")
+       }
+
+       var wg sync.WaitGroup
+       wg.Add(1)
+       go func() {
+
+               cB, err := listener.Accept()
+               if err != nil {
+                       t.Fatal("failed to accept")
+               }
+
+               if !cB.LocalMultiaddr().Equal(maddr) {
+                       t.Fatal("local multiaddr not equal:", maddr, cB.LocalMultiaddr())
+               }
+
+               // echo out
+               buf := make([]byte, 1024)
+               for {
+                       _, err := cB.Read(buf)
+                       if err != nil {
+                               break
+                       }
+                       cB.Write(buf)
+               }
+
+               wg.Done()
+       }()
+
+       cA, err := net.Dial("tcp", "127.0.0.1:4322")
+       if err != nil {
+               t.Fatal("failed to dial")
+       }
+
+       buf := make([]byte, 1024)
+       if _, err := cA.Write([]byte("beep boop")); err != nil {
+               t.Fatal("failed to write:", err)
+       }
+
+       if _, err := cA.Read(buf); err != nil {
+               t.Fatal("failed to read:", buf, err)
+       }
+
+       if !bytes.Equal(buf[:9], []byte("beep boop")) {
+               t.Fatal("failed to echo:", buf)
+       }
+
+       maddr2, err := FromNetAddr(cA.RemoteAddr())
+       if err != nil {
+               t.Fatal("failed to convert", err)
+       }
+       if !maddr2.Equal(maddr) {
+               t.Fatal("remote multiaddr not equal:", maddr, maddr2)
+       }
+
+       cA.Close()
+       wg.Wait()
+}
+
+func TestListenAddrs(t *testing.T) {
+
+       test := func(addr, resaddr string, succeed bool) {
+               if resaddr == "" {
+                       resaddr = addr
+               }
+
+               maddr := newMultiaddr(t, addr)
+               l, err := Listen(maddr)
+               if !succeed {
+                       if err == nil {
+                               t.Fatal("succeeded in listening", addr)
+                       }
+                       return
+               }
+               if succeed && err != nil {
+                       t.Error("failed to listen", addr, err)
+               }
+               if l == nil {
+                       t.Error("failed to listen", addr, succeed, err)
+               }
+               if l.Multiaddr().String() != resaddr {
+                       t.Error("listen addr did not resolve properly", l.Multiaddr().String(), resaddr, succeed, err)
+               }
+
+               if err = l.Close(); err != nil {
+                       t.Fatal("failed to close listener", addr, err)
+               }
+       }
+
+       test("/ip4/127.0.0.1/tcp/4324", "", true)
+       test("/ip4/127.0.0.1/udp/4325", "", false)
+       test("/ip4/127.0.0.1/udp/4326/udt", "", false)
+       test("/ip4/0.0.0.0/tcp/4324", "", true)
+       test("/ip4/0.0.0.0/udp/4325", "", false)
+       test("/ip4/0.0.0.0/udp/4326/udt", "", false)
+
+       test("/ip6/::1/tcp/4324", "", true)
+       test("/ip6/::1/udp/4325", "", false)
+       test("/ip6/::1/udp/4326/udt", "", false)
+       test("/ip6/::/tcp/4324", "", true)
+       test("/ip6/::/udp/4325", "", false)
+       test("/ip6/::/udp/4326/udt", "", false)
+
+       /* "An implementation should also support the concept of a "default"
+        * zone for each scope.  And, when supported, the index value zero
+        * at each scope SHOULD be reserved to mean "use the default zone"."
+        * -- rfc4007. So, this _should_ work everywhere(?). */
+       test("/ip6zone/0/ip6/::1/tcp/4324", "/ip6/::1/tcp/4324", true)
+       test("/ip6zone/0/ip6/::1/udp/4324", "", false)
+}
+
+func TestListenAndDial(t *testing.T) {
+
+       maddr := newMultiaddr(t, "/ip4/127.0.0.1/tcp/4323")
+       listener, err := Listen(maddr)
+       if err != nil {
+               t.Fatal("failed to listen")
+       }
+
+       var wg sync.WaitGroup
+       wg.Add(1)
+       go func() {
+
+               cB, err := listener.Accept()
+               if err != nil {
+                       t.Fatal("failed to accept")
+               }
+
+               if !cB.LocalMultiaddr().Equal(maddr) {
+                       t.Fatal("local multiaddr not equal:", maddr, cB.LocalMultiaddr())
+               }
+
+               // echo out
+               buf := make([]byte, 1024)
+               for {
+                       _, err := cB.Read(buf)
+                       if err != nil {
+                               break
+                       }
+                       cB.Write(buf)
+               }
+
+               wg.Done()
+       }()
+
+       cA, err := Dial(newMultiaddr(t, "/ip4/127.0.0.1/tcp/4323"))
+       if err != nil {
+               t.Fatal("failed to dial")
+       }
+
+       buf := make([]byte, 1024)
+       if _, err := cA.Write([]byte("beep boop")); err != nil {
+               t.Fatal("failed to write:", err)
+       }
+
+       if _, err := cA.Read(buf); err != nil {
+               t.Fatal("failed to read:", buf, err)
+       }
+
+       if !bytes.Equal(buf[:9], []byte("beep boop")) {
+               t.Fatal("failed to echo:", buf)
+       }
+
+       maddr2 := cA.RemoteMultiaddr()
+       if !maddr2.Equal(maddr) {
+               t.Fatal("remote multiaddr not equal:", maddr, maddr2)
+       }
+
+       cA.Close()
+       wg.Wait()
+}
+
+func TestListenPacketAndDial(t *testing.T) {
+       maddr := newMultiaddr(t, "/ip4/127.0.0.1/udp/4324")
+       pc, err := ListenPacket(maddr)
+       if err != nil {
+               t.Fatal("failed to listen", err)
+       }
+
+       var wg sync.WaitGroup
+       wg.Add(1)
+
+       go func() {
+               if !pc.Multiaddr().Equal(maddr) {
+                       t.Fatal("connection multiaddr not equal:", maddr, pc.Multiaddr())
+               }
+
+               buffer := make([]byte, 1024)
+               _, addr, err := pc.ReadFrom(buffer)
+               if err != nil {
+                       t.Fatal("failed to read into buffer", err)
+               }
+               pc.WriteTo(buffer, addr)
+
+               wg.Done()
+       }()
+
+       cn, err := Dial(maddr)
+       if err != nil {
+               t.Fatal("failed to dial", err)
+       }
+
+       buf := make([]byte, 1024)
+       if _, err := cn.Write([]byte("beep boop")); err != nil {
+               t.Fatal("failed to write", err)
+       }
+
+       if _, err := cn.Read(buf); err != nil {
+               t.Fatal("failed to read:", buf, err)
+       }
+
+       if !bytes.Equal(buf[:9], []byte("beep boop")) {
+               t.Fatal("failed to echk:", buf)
+       }
+
+       maddr2 := cn.RemoteMultiaddr()
+       if !maddr2.Equal(maddr) {
+               t.Fatal("remote multiaddr not equal:", maddr, maddr2)
+       }
+
+       cn.Close()
+       pc.Close()
+       wg.Wait()
+}
+
+func TestIPLoopback(t *testing.T) {
+       if IP4Loopback.String() != "/ip4/127.0.0.1" {
+               t.Error("IP4Loopback incorrect:", IP4Loopback)
+       }
+
+       if IP6Loopback.String() != "/ip6/::1" {
+               t.Error("IP6Loopback incorrect:", IP6Loopback)
+       }
+
+       if IP4MappedIP6Loopback.String() != "/ip6/::ffff:127.0.0.1" {
+               t.Error("IP4MappedIP6Loopback incorrect:", IP4MappedIP6Loopback)
+       }
+
+       if !IsIPLoopback(IP4Loopback) {
+               t.Error("IsIPLoopback failed (IP4Loopback)")
+       }
+
+       if !IsIPLoopback(newMultiaddr(t, "/ip4/127.1.80.9")) {
+               t.Error("IsIPLoopback failed (/ip4/127.1.80.9)")
+       }
+
+       if IsIPLoopback(newMultiaddr(t, "/ip4/112.123.11.1")) {
+               t.Error("IsIPLoopback false positive (/ip4/112.123.11.1)")
+       }
+
+       if IsIPLoopback(newMultiaddr(t, "/ip4/192.168.0.1/ip6/::1")) {
+               t.Error("IsIPLoopback false positive (/ip4/192.168.0.1/ip6/::1)")
+       }
+
+       if !IsIPLoopback(IP6Loopback) {
+               t.Error("IsIPLoopback failed (IP6Loopback)")
+       }
+
+       if !IsIPLoopback(newMultiaddr(t, "/ip6/127.0.0.1")) {
+               t.Error("IsIPLoopback failed (/ip6/127.0.0.1)")
+       }
+
+       if !IsIPLoopback(newMultiaddr(t, "/ip6/127.99.3.2")) {
+               t.Error("IsIPLoopback failed (/ip6/127.99.3.2)")
+       }
+
+       if IsIPLoopback(newMultiaddr(t, "/ip6/::fffa:127.99.3.2")) {
+               t.Error("IsIPLoopback false positive (/ip6/::fffa:127.99.3.2)")
+       }
+
+       if !IsIPLoopback(newMultiaddr(t, "/ip6zone/0/ip6/::1")) {
+               t.Error("IsIPLoopback failed (/ip6zone/0/ip6/::1)")
+       }
+
+       if !IsIPLoopback(newMultiaddr(t, "/ip6zone/xxx/ip6/::1")) {
+               t.Error("IsIPLoopback failed (/ip6zone/xxx/ip6/::1)")
+       }
+
+       if IsIPLoopback(newMultiaddr(t, "/ip6zone/0/ip6/1::1")) {
+               t.Errorf("IsIPLoopback false positive (/ip6zone/0/ip6/1::1)")
+       }
+}
+
+func TestIPUnspecified(t *testing.T) {
+       if IP4Unspecified.String() != "/ip4/0.0.0.0" {
+               t.Error("IP4Unspecified incorrect:", IP4Unspecified)
+       }
+
+       if IP6Unspecified.String() != "/ip6/::" {
+               t.Error("IP6Unspecified incorrect:", IP6Unspecified)
+       }
+
+       if !IsIPUnspecified(IP4Unspecified) {
+               t.Error("IsIPUnspecified failed (IP4Unspecified)")
+       }
+
+       if !IsIPUnspecified(IP6Unspecified) {
+               t.Error("IsIPUnspecified failed (IP6Unspecified)")
+       }
+
+       if !IsIPUnspecified(newMultiaddr(t, "/ip6zone/xxx/ip6/::")) {
+               t.Error("IsIPUnspecified failed (/ip6zone/xxx/ip6/::)")
+       }
+}
+
+func TestIP6LinkLocal(t *testing.T) {
+       for a := 0; a < 65536; a++ {
+               isLinkLocal := (a&0xffc0 == 0xfe80 || a&0xff0f == 0xff02)
+               m := newMultiaddr(t, fmt.Sprintf("/ip6/%x::1", a))
+               if IsIP6LinkLocal(m) != isLinkLocal {
+                       t.Errorf("IsIP6LinkLocal failed (%s != %v)", m, isLinkLocal)
+               }
+       }
+
+       if !IsIP6LinkLocal(newMultiaddr(t, "/ip6zone/hello/ip6/fe80::9999")) {
+               t.Error("IsIP6LinkLocal failed (/ip6/fe80::9999)")
+       }
+}
+
+func TestConvertNetAddr(t *testing.T) {
+       m1 := newMultiaddr(t, "/ip4/1.2.3.4/tcp/4001")
+
+       n1, err := ToNetAddr(m1)
+       if err != nil {
+               t.Fatal(err)
+       }
+
+       m2, err := FromNetAddr(n1)
+       if err != nil {
+               t.Fatal(err)
+       }
+
+       if m1.String() != m2.String() {
+               t.Fatal("ToNetAddr + FromNetAddr did not work")
+       }
+}
+
+func TestWrapNetConn(t *testing.T) {
+       // test WrapNetConn nil
+       if _, err := WrapNetConn(nil); err == nil {
+               t.Error("WrapNetConn(nil) should return an error")
+       }
+
+       checkErr := func(err error, s string) {
+               if err != nil {
+                       t.Fatal(s, err)
+               }
+       }
+
+       listener, err := net.Listen("tcp", "127.0.0.1:0")
+       checkErr(err, "failed to listen")
+
+       var wg sync.WaitGroup
+       defer wg.Wait()
+       wg.Add(1)
+       go func() {
+               defer wg.Done()
+               cB, err := listener.Accept()
+               checkErr(err, "failed to accept")
+               _ = cB.(halfOpen)
+               cB.Close()
+       }()
+
+       cA, err := net.Dial("tcp", listener.Addr().String())
+       checkErr(err, "failed to dial")
+       defer cA.Close()
+       _ = cA.(halfOpen)
+
+       lmaddr, err := FromNetAddr(cA.LocalAddr())
+       checkErr(err, "failed to get local addr")
+       rmaddr, err := FromNetAddr(cA.RemoteAddr())
+       checkErr(err, "failed to get remote addr")
+
+       mcA, err := WrapNetConn(cA)
+       checkErr(err, "failed to wrap conn")
+
+       _ = mcA.(halfOpen)
+
+       if mcA.LocalAddr().String() != cA.LocalAddr().String() {
+               t.Error("wrapped conn local addr differs")
+       }
+       if mcA.RemoteAddr().String() != cA.RemoteAddr().String() {
+               t.Error("wrapped conn remote addr differs")
+       }
+       if mcA.LocalMultiaddr().String() != lmaddr.String() {
+               t.Error("wrapped conn local maddr differs")
+       }
+       if mcA.RemoteMultiaddr().String() != rmaddr.String() {
+               t.Error("wrapped conn remote maddr differs")
+       }
+}
+
+func TestAddrMatch(t *testing.T) {
+
+       test := func(m ma.Multiaddr, input, expect []ma.Multiaddr) {
+               actual := AddrMatch(m, input)
+               testSliceEqual(t, expect, actual)
+       }
+
+       a := []ma.Multiaddr{
+               newMultiaddr(t, "/ip4/1.2.3.4/tcp/1234"),
+               newMultiaddr(t, "/ip4/1.2.3.4/tcp/2345"),
+               newMultiaddr(t, "/ip4/1.2.3.4/tcp/1234/tcp/2345"),
+               newMultiaddr(t, "/ip4/1.2.3.4/tcp/1234/tcp/2345"),
+               newMultiaddr(t, "/ip4/1.2.3.4/tcp/1234/udp/1234"),
+               newMultiaddr(t, "/ip4/1.2.3.4/tcp/1234/udp/1234"),
+               newMultiaddr(t, "/ip4/1.2.3.4/tcp/1234/ip6/::1"),
+               newMultiaddr(t, "/ip4/1.2.3.4/tcp/1234/ip6/::1"),
+               newMultiaddr(t, "/ip6/::1/tcp/1234"),
+               newMultiaddr(t, "/ip6/::1/tcp/2345"),
+               newMultiaddr(t, "/ip6/::1/tcp/1234/tcp/2345"),
+               newMultiaddr(t, "/ip6/::1/tcp/1234/tcp/2345"),
+               newMultiaddr(t, "/ip6/::1/tcp/1234/udp/1234"),
+               newMultiaddr(t, "/ip6/::1/tcp/1234/udp/1234"),
+               newMultiaddr(t, "/ip6/::1/tcp/1234/ip6/::1"),
+               newMultiaddr(t, "/ip6/::1/tcp/1234/ip6/::1"),
+       }
+
+       test(a[0], a, []ma.Multiaddr{
+               newMultiaddr(t, "/ip4/1.2.3.4/tcp/1234"),
+               newMultiaddr(t, "/ip4/1.2.3.4/tcp/2345"),
+       })
+       test(a[2], a, []ma.Multiaddr{
+               newMultiaddr(t, "/ip4/1.2.3.4/tcp/1234/tcp/2345"),
+               newMultiaddr(t, "/ip4/1.2.3.4/tcp/1234/tcp/2345"),
+       })
+       test(a[4], a, []ma.Multiaddr{
+               newMultiaddr(t, "/ip4/1.2.3.4/tcp/1234/udp/1234"),
+               newMultiaddr(t, "/ip4/1.2.3.4/tcp/1234/udp/1234"),
+       })
+       test(a[6], a, []ma.Multiaddr{
+               newMultiaddr(t, "/ip4/1.2.3.4/tcp/1234/ip6/::1"),
+               newMultiaddr(t, "/ip4/1.2.3.4/tcp/1234/ip6/::1"),
+       })
+       test(a[8], a, []ma.Multiaddr{
+               newMultiaddr(t, "/ip6/::1/tcp/1234"),
+               newMultiaddr(t, "/ip6/::1/tcp/2345"),
+       })
+       test(a[10], a, []ma.Multiaddr{
+               newMultiaddr(t, "/ip6/::1/tcp/1234/tcp/2345"),
+               newMultiaddr(t, "/ip6/::1/tcp/1234/tcp/2345"),
+       })
+       test(a[12], a, []ma.Multiaddr{
+               newMultiaddr(t, "/ip6/::1/tcp/1234/udp/1234"),
+               newMultiaddr(t, "/ip6/::1/tcp/1234/udp/1234"),
+       })
+       test(a[14], a, []ma.Multiaddr{
+               newMultiaddr(t, "/ip6/::1/tcp/1234/ip6/::1"),
+               newMultiaddr(t, "/ip6/::1/tcp/1234/ip6/::1"),
+       })
+
+}
+
+func testSliceEqual(t *testing.T, a, b []ma.Multiaddr) {
+       if len(a) != len(b) {
+               t.Error("differ", a, b)
+       }
+       for i, addrA := range a {
+               if !addrA.Equal(b[i]) {
+                       t.Error("differ", a, b)
+               }
+       }
+}
+
+func TestInterfaceAddressesWorks(t *testing.T) {
+       _, err := InterfaceMultiaddrs()
+       if err != nil {
+               t.Fatal(err)
+       }
+}
+
+func TestNetListener(t *testing.T) {
+       listener, err := net.Listen("tcp", "127.0.0.1:1234")
+       if err != nil {
+               t.Fatal(err)
+       }
+       defer listener.Close()
+       malist, err := WrapNetListener(listener)
+       if err != nil {
+               t.Fatal(err)
+       }
+       if !malist.Multiaddr().Equal(newMultiaddr(t, "/ip4/127.0.0.1/tcp/1234")) {
+               t.Fatal("unexpected multiaddr")
+       }
+
+       go func() {
+               c, err := Dial(malist.Multiaddr())
+               if err != nil {
+                       t.Fatal("failed to dial")
+               }
+               if !c.RemoteMultiaddr().Equal(malist.Multiaddr()) {
+                       t.Fatal("dialed wrong target")
+               }
+               c.Close()
+
+               c, err = Dial(malist.Multiaddr())
+               if err != nil {
+                       t.Fatal("failed to dial")
+               }
+               c.Close()
+       }()
+
+       c, err := malist.Accept()
+       if err != nil {
+               t.Fatal(err)
+       }
+       c.Close()
+       netList := NetListener(malist)
+       malist2, err := WrapNetListener(netList)
+       if err != nil {
+               t.Fatal(err)
+       }
+       if malist2 != malist {
+               t.Fatal("expected WrapNetListener(NetListener(malist)) == malist")
+       }
+       nc, err := netList.Accept()
+       if err != nil {
+               t.Fatal(err)
+       }
+       if !nc.(Conn).LocalMultiaddr().Equal(malist.Multiaddr()) {
+               t.Fatal("wrong multiaddr on conn")
+       }
+       nc.Close()
+}

diff --git a/vendor/github.com/multiformats/go-multiaddr-net/package.json b/vendor/github.com/multiformats/go-multiaddr-net/package.json
new file mode 100644 (file)
index 0000000..1854187
--- /dev/null
+++ b/vendor/github.com/multiformats/go-multiaddr-net/package.json
@@ -0,0 +1,30 @@
+{
+  "author": "multiformats",
+  "bugs": {
+    "url": "https://github.com/multiformats/go-multiaddr-net"
+  },
+  "gx": {
+    "dvcsimport": "github.com/multiformats/go-multiaddr-net"
+  },
+  "gxDependencies": [
+    {
+      "author": "multiformats",
+      "hash": "QmNTCey11oxhb1AxDnQBRHtdhap6Ctud872NjAYPYYXPuc",
+      "name": "go-multiaddr",
+      "version": "1.4.0"
+    },
+    {
+      "author": "lgierth",
+      "hash": "QmQc7jbDUsxUJZyFJzxVrnrWeECCct6fErEpMqtjyWvCX8",
+      "name": "go-multiaddr-dns",
+      "version": "0.3.0"
+    }
+  ],
+  "gxVersion": "0.6.0",
+  "language": "go",
+  "license": "",
+  "name": "go-multiaddr-net",
+  "releaseCmd": "git commit -a -m \"gx publish $VERSION\"",
+  "version": "1.7.1"
+}
+

diff --git a/vendor/github.com/multiformats/go-multiaddr-net/private.go b/vendor/github.com/multiformats/go-multiaddr-net/private.go
new file mode 100644 (file)
index 0000000..26e547c
--- /dev/null
+++ b/vendor/github.com/multiformats/go-multiaddr-net/private.go
@@ -0,0 +1,116 @@
+package manet
+
+import (
+       "net"
+
+       ma "github.com/multiformats/go-multiaddr"
+)
+
+// Private4 and Private6 are well-known private networks
+var Private4, Private6 []*net.IPNet
+var privateCIDR4 = []string{
+       // localhost
+       "127.0.0.0/8",
+       // private networks
+       "10.0.0.0/8",
+       "100.64.0.0/10",
+       "172.16.0.0/12",
+       "192.168.0.0/16",
+       // link local
+       "169.254.0.0/16",
+}
+var privateCIDR6 = []string{
+       // localhost
+       "::1/128",
+       // ULA reserved
+       "fc00::/7",
+       // link local
+       "fe80::/10",
+}
+
+// Unroutable4 and Unroutable6 are well known unroutable address ranges
+var Unroutable4, Unroutable6 []*net.IPNet
+var unroutableCIDR4 = []string{
+       "0.0.0.0/8",
+       "192.0.0.0/26",
+       "192.0.2.0/24",
+       "192.88.99.0/24",
+       "198.18.0.0/15",
+       "198.51.100.0/24",
+       "203.0.113.0/24",
+       "224.0.0.0/4",
+       "240.0.0.0/4",
+       "255.255.255.255/32",
+}
+var unroutableCIDR6 = []string{
+       "ff00::/8",
+}
+
+func init() {
+       Private4 = parseCIDR(privateCIDR4)
+       Private6 = parseCIDR(privateCIDR6)
+       Unroutable4 = parseCIDR(unroutableCIDR4)
+       Unroutable6 = parseCIDR(unroutableCIDR6)
+}
+
+func parseCIDR(cidrs []string) []*net.IPNet {
+       ipnets := make([]*net.IPNet, len(cidrs))
+       for i, cidr := range cidrs {
+               _, ipnet, err := net.ParseCIDR(cidr)
+               if err != nil {
+                       panic(err)
+               }
+               ipnets[i] = ipnet
+       }
+       return ipnets
+}
+
+// IsPublicAddr retruns true if the IP part of the multiaddr is a publicly routable address
+func IsPublicAddr(a ma.Multiaddr) bool {
+       isPublic := false
+       ma.ForEach(a, func(c ma.Component) bool {
+               switch c.Protocol().Code {
+               case ma.P_IP6ZONE:
+                       return true
+               default:
+                       return false
+               case ma.P_IP4:
+                       ip := net.IP(c.RawValue())
+                       isPublic = !inAddrRange(ip, Private4) && !inAddrRange(ip, Unroutable4)
+               case ma.P_IP6:
+                       ip := net.IP(c.RawValue())
+                       isPublic = !inAddrRange(ip, Private6) && !inAddrRange(ip, Unroutable6)
+               }
+               return false
+       })
+       return isPublic
+}
+
+// IsPrivateAddr returns true if the IP part of the mutiaddr is in a private network
+func IsPrivateAddr(a ma.Multiaddr) bool {
+       isPrivate := false
+       ma.ForEach(a, func(c ma.Component) bool {
+               switch c.Protocol().Code {
+               case ma.P_IP6ZONE:
+                       return true
+               default:
+                       return false
+               case ma.P_IP4:
+                       isPrivate = inAddrRange(net.IP(c.RawValue()), Private4)
+               case ma.P_IP6:
+                       isPrivate = inAddrRange(net.IP(c.RawValue()), Private6)
+               }
+               return false
+       })
+       return isPrivate
+}
+
+func inAddrRange(ip net.IP, ipnets []*net.IPNet) bool {
+       for _, ipnet := range ipnets {
+               if ipnet.Contains(ip) {
+                       return true
+               }
+       }
+
+       return false
+}

diff --git a/vendor/github.com/multiformats/go-multiaddr-net/private_test.go b/vendor/github.com/multiformats/go-multiaddr-net/private_test.go
new file mode 100644 (file)
index 0000000..a4380a5
--- /dev/null
+++ b/vendor/github.com/multiformats/go-multiaddr-net/private_test.go
@@ -0,0 +1,48 @@
+package manet
+
+import (
+       "testing"
+
+       ma "github.com/multiformats/go-multiaddr"
+)
+
+func TestIsPublicAddr(t *testing.T) {
+       a, err := ma.NewMultiaddr("/ip4/192.168.1.1/tcp/80")
+       if err != nil {
+               t.Fatal(err)
+       }
+
+       if IsPublicAddr(a) {
+               t.Fatal("192.168.1.1 is not a public address!")
+       }
+
+       if !IsPrivateAddr(a) {
+               t.Fatal("192.168.1.1 is a private address!")
+       }
+
+       a, err = ma.NewMultiaddr("/ip4/1.1.1.1/tcp/80")
+       if err != nil {
+               t.Fatal(err)
+       }
+
+       if !IsPublicAddr(a) {
+               t.Fatal("1.1.1.1 is a public address!")
+       }
+
+       if IsPrivateAddr(a) {
+               t.Fatal("1.1.1.1 is not a private address!")
+       }
+
+       a, err = ma.NewMultiaddr("/tcp/80/ip4/1.1.1.1")
+       if err != nil {
+               t.Fatal(err)
+       }
+
+       if IsPublicAddr(a) {
+               t.Fatal("shouldn't consider an address that starts with /tcp/ as *public*")
+       }
+
+       if IsPrivateAddr(a) {
+               t.Fatal("shouldn't consider an address that starts with /tcp/ as *private*")
+       }
+}

diff --git a/vendor/github.com/multiformats/go-multiaddr-net/registry.go b/vendor/github.com/multiformats/go-multiaddr-net/registry.go
new file mode 100644 (file)
index 0000000..fc6561c
--- /dev/null
+++ b/vendor/github.com/multiformats/go-multiaddr-net/registry.go
@@ -0,0 +1,133 @@
+package manet
+
+import (
+       "fmt"
+       "net"
+       "sync"
+
+       ma "github.com/multiformats/go-multiaddr"
+)
+
+// FromNetAddrFunc is a generic function which converts a net.Addr to Multiaddress
+type FromNetAddrFunc func(a net.Addr) (ma.Multiaddr, error)
+
+// ToNetAddrFunc is a generic function which converts a Multiaddress to net.Addr
+type ToNetAddrFunc func(ma ma.Multiaddr) (net.Addr, error)
+
+var defaultCodecs = NewCodecMap()
+
+func init() {
+       defaultCodecs.RegisterFromNetAddr(parseTCPNetAddr, "tcp", "tcp4", "tcp6")
+       defaultCodecs.RegisterFromNetAddr(parseUDPNetAddr, "udp", "udp4", "udp6")
+       defaultCodecs.RegisterFromNetAddr(parseIPNetAddr, "ip", "ip4", "ip6")
+       defaultCodecs.RegisterFromNetAddr(parseIPPlusNetAddr, "ip+net")
+       defaultCodecs.RegisterFromNetAddr(parseUnixNetAddr, "unix")
+
+       defaultCodecs.RegisterToNetAddr(parseBasicNetMaddr, "tcp", "udp", "ip6", "ip4", "unix")
+}
+
+// CodecMap holds a map of NetCodecs indexed by their Protocol ID
+// along with parsers for the addresses they use.
+// It is used to keep a list of supported network address codecs (protocols
+// which addresses can be converted to and from multiaddresses).
+type CodecMap struct {
+       codecs       map[string]*NetCodec
+       addrParsers  map[string]FromNetAddrFunc
+       maddrParsers map[string]ToNetAddrFunc
+       lk           sync.Mutex
+}
+
+// NewCodecMap initializes and returns a CodecMap object.
+func NewCodecMap() *CodecMap {
+       return &CodecMap{
+               addrParsers:  make(map[string]FromNetAddrFunc),
+               maddrParsers: make(map[string]ToNetAddrFunc),
+       }
+}
+
+// NetCodec is used to identify a network codec, that is, a network type for
+// which we are able to translate multiaddresses into standard Go net.Addr
+// and back.
+//
+// Deprecated: Unfortunately, these mappings aren't one to one. This abstraction
+// assumes that multiple "networks" can map to a single multiaddr protocol but
+// not the reverse. For example, this abstraction supports `tcp6, tcp4, tcp ->
+// /tcp/` really well but doesn't support `ip -> {/ip4/, /ip6/}`.
+//
+// Please use `RegisterFromNetAddr` and `RegisterToNetAddr` directly.
+type NetCodec struct {
+       // NetAddrNetworks is an array of strings that may be returned
+       // by net.Addr.Network() calls on addresses belonging to this type
+       NetAddrNetworks []string
+
+       // ProtocolName is the string value for Multiaddr address keys
+       ProtocolName string
+
+       // ParseNetAddr parses a net.Addr belonging to this type into a multiaddr
+       ParseNetAddr FromNetAddrFunc
+
+       // ConvertMultiaddr converts a multiaddr of this type back into a net.Addr
+       ConvertMultiaddr ToNetAddrFunc
+
+       // Protocol returns the multiaddr protocol struct for this type
+       Protocol ma.Protocol
+}
+
+// RegisterNetCodec adds a new NetCodec to the default codecs.
+func RegisterNetCodec(a *NetCodec) {
+       defaultCodecs.RegisterNetCodec(a)
+}
+
+// RegisterNetCodec adds a new NetCodec to the CodecMap. This function is
+// thread safe.
+func (cm *CodecMap) RegisterNetCodec(a *NetCodec) {
+       cm.lk.Lock()
+       defer cm.lk.Unlock()
+       for _, n := range a.NetAddrNetworks {
+               cm.addrParsers[n] = a.ParseNetAddr
+       }
+
+       cm.maddrParsers[a.ProtocolName] = a.ConvertMultiaddr
+}
+
+// RegisterFromNetAddr registers a conversion from net.Addr instances to multiaddrs
+func (cm *CodecMap) RegisterFromNetAddr(from FromNetAddrFunc, networks ...string) {
+       cm.lk.Lock()
+       defer cm.lk.Unlock()
+
+       for _, n := range networks {
+               cm.addrParsers[n] = from
+       }
+}
+
+// RegisterToNetAddr registers a conversion from multiaddrs to net.Addr instances
+func (cm *CodecMap) RegisterToNetAddr(to ToNetAddrFunc, protocols ...string) {
+       cm.lk.Lock()
+       defer cm.lk.Unlock()
+
+       for _, p := range protocols {
+               cm.maddrParsers[p] = to
+       }
+}
+
+func (cm *CodecMap) getAddrParser(net string) (FromNetAddrFunc, error) {
+       cm.lk.Lock()
+       defer cm.lk.Unlock()
+
+       parser, ok := cm.addrParsers[net]
+       if !ok {
+               return nil, fmt.Errorf("unknown network %v", net)
+       }
+       return parser, nil
+}
+
+func (cm *CodecMap) getMaddrParser(name string) (ToNetAddrFunc, error) {
+       cm.lk.Lock()
+       defer cm.lk.Unlock()
+       p, ok := cm.maddrParsers[name]
+       if !ok {
+               return nil, fmt.Errorf("network not supported: %s", name)
+       }
+
+       return p, nil
+}

diff --git a/vendor/github.com/multiformats/go-multiaddr-net/registry_test.go b/vendor/github.com/multiformats/go-multiaddr-net/registry_test.go
new file mode 100644 (file)
index 0000000..b3777ca
--- /dev/null
+++ b/vendor/github.com/multiformats/go-multiaddr-net/registry_test.go
@@ -0,0 +1,50 @@
+package manet
+
+import (
+       "net"
+       "testing"
+
+       ma "github.com/multiformats/go-multiaddr"
+)
+
+func TestRegisterSpec(t *testing.T) {
+       cm := NewCodecMap()
+       myproto := &NetCodec{
+               ProtocolName:     "test",
+               NetAddrNetworks:  []string{"test", "iptest", "blahtest"},
+               ConvertMultiaddr: func(a ma.Multiaddr) (net.Addr, error) { return nil, nil },
+               ParseNetAddr:     func(a net.Addr) (ma.Multiaddr, error) { return nil, nil },
+       }
+
+       cm.RegisterNetCodec(myproto)
+
+       _, ok := cm.addrParsers["test"]
+       if !ok {
+               t.Fatal("myproto not properly registered")
+       }
+
+       _, ok = cm.addrParsers["iptest"]
+       if !ok {
+               t.Fatal("myproto not properly registered")
+       }
+
+       _, ok = cm.addrParsers["blahtest"]
+       if !ok {
+               t.Fatal("myproto not properly registered")
+       }
+
+       _, ok = cm.maddrParsers["test"]
+       if !ok {
+               t.Fatal("myproto not properly registered")
+       }
+
+       _, ok = cm.maddrParsers["iptest"]
+       if ok {
+               t.Fatal("myproto not properly registered")
+       }
+
+       _, ok = cm.maddrParsers["blahtest"]
+       if ok {
+               t.Fatal("myproto not properly registered")
+       }
+}

diff --git a/vendor/github.com/multiformats/go-multiaddr/.gitignore b/vendor/github.com/multiformats/go-multiaddr/.gitignore
new file mode 100644 (file)
index 0000000..1d74e21
--- /dev/null
+++ b/vendor/github.com/multiformats/go-multiaddr/.gitignore
@@ -0,0 +1 @@
+.vscode/

diff --git a/vendor/github.com/multiformats/go-multiaddr/.gx/lastpubver b/vendor/github.com/multiformats/go-multiaddr/.gx/lastpubver
new file mode 100644 (file)
index 0000000..e94067e
--- /dev/null
+++ b/vendor/github.com/multiformats/go-multiaddr/.gx/lastpubver
@@ -0,0 +1 @@
+1.4.0: QmNTCey11oxhb1AxDnQBRHtdhap6Ctud872NjAYPYYXPuc

diff --git a/vendor/github.com/multiformats/go-multiaddr/.travis.yml b/vendor/github.com/multiformats/go-multiaddr/.travis.yml
new file mode 100644 (file)
index 0000000..8f187a8
--- /dev/null
+++ b/vendor/github.com/multiformats/go-multiaddr/.travis.yml
@@ -0,0 +1,27 @@
+os:
+  - linux
+  - osx
+
+language: go
+
+go:
+    - 1.10.x
+
+install: true
+
+before_install:
+  - make deps
+
+script:
+  - go vet
+  - go test -race -coverprofile=coverage.txt -covermode=atomic
+
+after_success:
+    - bash <(curl -s https://codecov.io/bash)
+
+cache:
+    directories:
+        - $GOPATH/src/gx
+
+notifications:
+  email: false

diff --git a/vendor/github.com/multiformats/go-multiaddr/LICENSE b/vendor/github.com/multiformats/go-multiaddr/LICENSE
new file mode 100644 (file)
index 0000000..c7386b3
--- /dev/null
+++ b/vendor/github.com/multiformats/go-multiaddr/LICENSE
@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2014 Juan Batiz-Benet
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

diff --git a/vendor/github.com/multiformats/go-multiaddr/Makefile b/vendor/github.com/multiformats/go-multiaddr/Makefile
new file mode 100644 (file)
index 0000000..9eb5c44
--- /dev/null
+++ b/vendor/github.com/multiformats/go-multiaddr/Makefile
@@ -0,0 +1,14 @@
+gx:
+       go get github.com/whyrusleeping/gx
+       go get github.com/whyrusleeping/gx-go
+
+covertools:
+       go get golang.org/x/tools/cmd/cover
+
+deps: gx covertools
+       gx --verbose install --global
+       gx-go rewrite
+
+publish:
+       gx-go rewrite --undo
+

diff --git a/vendor/github.com/multiformats/go-multiaddr/README.md b/vendor/github.com/multiformats/go-multiaddr/README.md
new file mode 100644 (file)
index 0000000..df2766a
--- /dev/null
+++ b/vendor/github.com/multiformats/go-multiaddr/README.md
@@ -0,0 +1,117 @@
+# go-multiaddr
+
+[![](https://img.shields.io/badge/made%20by-Protocol%20Labs-blue.svg?style=flat-square)](http://ipn.io)
+[![](https://img.shields.io/badge/project-multiformats-blue.svg?style=flat-square)](https://github.com/multiformats/multiformats)
+[![](https://img.shields.io/badge/freenode-%23ipfs-blue.svg?style=flat-square)](https://webchat.freenode.net/?channels=%23ipfs)
+[![](https://img.shields.io/badge/readme%20style-standard-brightgreen.svg?style=flat-square)](https://github.com/RichardLitt/standard-readme)
+[![GoDoc](https://godoc.org/github.com/multiformats/go-multiaddr?status.svg)](https://godoc.org/github.com/multiformats/go-multiaddr)
+[![Travis CI](https://img.shields.io/travis/multiformats/go-multiaddr.svg?style=flat-square&branch=master)](https://travis-ci.org/multiformats/go-multiaddr)
+[![codecov.io](https://img.shields.io/codecov/c/github/multiformats/go-multiaddr.svg?style=flat-square&branch=master)](https://codecov.io/github/multiformats/go-multiaddr?branch=master)
+
+> [multiaddr](https://github.com/multiformats/multiaddr) implementation in go
+
+Multiaddr is a standard way to represent addresses that:
+
+- Support any standard network protocols.
+- Self-describe (include protocols).
+- Have a binary packed format.
+- Have a nice string representation.
+- Encapsulate well.
+
+## Table of Contents
+
+- [Install](#install)
+- [Usage](#usage)
+  - [Example](#example)
+    - [Simple](#simple)
+    - [Protocols](#protocols)
+    - [En/decapsulate](#endecapsulate)
+    - [Tunneling](#tunneling)
+- [Maintainers](#maintainers)
+- [Contribute](#contribute)
+- [License](#license)
+
+## Install
+
+```sh
+go get github.com/multiformats/go-multiaddr
+```
+
+## Usage
+
+### Example
+
+#### Simple
+
+```go
+import ma "github.com/multiformats/go-multiaddr"
+
+// construct from a string (err signals parse failure)
+m1, err := ma.NewMultiaddr("/ip4/127.0.0.1/udp/1234")
+
+// construct from bytes (err signals parse failure)
+m2, err := ma.NewMultiaddrBytes(m1.Bytes())
+
+// true
+strings.Equal(m1.String(), "/ip4/127.0.0.1/udp/1234")
+strings.Equal(m1.String(), m2.String())
+bytes.Equal(m1.Bytes(), m2.Bytes())
+m1.Equal(m2)
+m2.Equal(m1)
+```
+
+#### Protocols
+
+```go
+// get the multiaddr protocol description objects
+m1.Protocols()
+// []Protocol{
+//   Protocol{ Code: 4, Name: 'ip4', Size: 32},
+//   Protocol{ Code: 17, Name: 'udp', Size: 16},
+// }
+```
+
+#### En/decapsulate
+
+```go
+import ma "github.com/multiformats/go-multiaddr"
+
+m, err := ma.NewMultiaddr("/ip4/127.0.0.1/udp/1234")
+// <Multiaddr /ip4/127.0.0.1/udp/1234>
+
+sctpMA, err := ma.NewMultiaddr("/sctp/5678")
+
+m.Encapsulate(sctpMA)
+// <Multiaddr /ip4/127.0.0.1/udp/1234/sctp/5678>
+
+udpMA, err := ma.NewMultiaddr("/udp/1234")
+
+m.Decapsulate(udpMA) // up to + inc last occurrence of subaddr
+// <Multiaddr /ip4/127.0.0.1>
+```
+
+#### Tunneling
+
+Multiaddr allows expressing tunnels very nicely.
+
+```js
+printer, _ := ma.NewMultiaddr("/ip4/192.168.0.13/tcp/80")
+proxy, _ := ma.NewMultiaddr("/ip4/10.20.30.40/tcp/443")
+printerOverProxy := proxy.Encapsulate(printer)
+// /ip4/10.20.30.40/tcp/443/ip4/192.168.0.13/tcp/80
+
+proxyAgain := printerOverProxy.Decapsulate(printer)
+// /ip4/10.20.30.40/tcp/443
+```
+
+## Contribute
+
+Contributions welcome. Please check out [the issues](https://github.com/multiformats/go-multiaddr/issues).
+
+Check out our [contributing document](https://github.com/multiformats/multiformats/blob/master/contributing.md) for more information on how we work, and about contributing in general. Please be aware that all interactions related to multiformats are subject to the IPFS [Code of Conduct](https://github.com/ipfs/community/blob/master/code-of-conduct.md).
+
+Small note: If editing the README, please conform to the [standard-readme](https://github.com/RichardLitt/standard-readme) specification.
+
+## License
+
+[MIT](LICENSE) © 2014 Juan Batiz-Benet

diff --git a/vendor/github.com/multiformats/go-multiaddr/codec.go b/vendor/github.com/multiformats/go-multiaddr/codec.go
new file mode 100644 (file)
index 0000000..ae58b53
--- /dev/null
+++ b/vendor/github.com/multiformats/go-multiaddr/codec.go
@@ -0,0 +1,193 @@
+package multiaddr
+
+import (
+       "bytes"
+       "fmt"
+       "strings"
+)
+
+func stringToBytes(s string) ([]byte, error) {
+
+       // consume trailing slashes
+       s = strings.TrimRight(s, "/")
+
+       var b bytes.Buffer
+       sp := strings.Split(s, "/")
+
+       if sp[0] != "" {
+               return nil, fmt.Errorf("invalid multiaddr, must begin with /")
+       }
+
+       // consume first empty elem
+       sp = sp[1:]
+
+       for len(sp) > 0 {
+               name := sp[0]
+               p := ProtocolWithName(name)
+               if p.Code == 0 {
+                       return nil, fmt.Errorf("no protocol with name %s", sp[0])
+               }
+               _, _ = b.Write(CodeToVarint(p.Code))
+               sp = sp[1:]
+
+               if p.Size == 0 { // no length.
+                       continue
+               }
+
+               if len(sp) < 1 {
+                       return nil, fmt.Errorf("protocol requires address, none given: %s", name)
+               }
+
+               if p.Path {
+                       // it's a path protocol (terminal).
+                       // consume the rest of the address as the next component.
+                       sp = []string{"/" + strings.Join(sp, "/")}
+               }
+
+               a, err := p.Transcoder.StringToBytes(sp[0])
+               if err != nil {
+                       return nil, fmt.Errorf("failed to parse %s: %s %s", p.Name, sp[0], err)
+               }
+               if p.Size < 0 { // varint size.
+                       _, _ = b.Write(CodeToVarint(len(a)))
+               }
+               b.Write(a)
+               sp = sp[1:]
+       }
+
+       return b.Bytes(), nil
+}
+
+func validateBytes(b []byte) (err error) {
+       for len(b) > 0 {
+               code, n, err := ReadVarintCode(b)
+               if err != nil {
+                       return err
+               }
+
+               b = b[n:]
+               p := ProtocolWithCode(code)
+               if p.Code == 0 {
+                       return fmt.Errorf("no protocol with code %d", code)
+               }
+
+               if p.Size == 0 {
+                       continue
+               }
+
+               n, size, err := sizeForAddr(p, b)
+               if err != nil {
+                       return err
+               }
+
+               b = b[n:]
+
+               if len(b) < size || size < 0 {
+                       return fmt.Errorf("invalid value for size %d", len(b))
+               }
+
+               err = p.Transcoder.ValidateBytes(b[:size])
+               if err != nil {
+                       return err
+               }
+
+               b = b[size:]
+       }
+
+       return nil
+}
+
+func readComponent(b []byte) (int, Component, error) {
+       var offset int
+       code, n, err := ReadVarintCode(b)
+       if err != nil {
+               return 0, Component{}, err
+       }
+       offset += n
+
+       p := ProtocolWithCode(code)
+       if p.Code == 0 {
+               return 0, Component{}, fmt.Errorf("no protocol with code %d", code)
+       }
+
+       if p.Size == 0 {
+               return offset, Component{
+                       bytes:    b[:offset],
+                       offset:   offset,
+                       protocol: p,
+               }, nil
+       }
+
+       n, size, err := sizeForAddr(p, b[offset:])
+       if err != nil {
+               return 0, Component{}, err
+       }
+
+       offset += n
+
+       if len(b[offset:]) < size || size < 0 {
+               return 0, Component{}, fmt.Errorf("invalid value for size %d", len(b[offset:]))
+       }
+
+       return offset + size, Component{
+               bytes:    b[:offset+size],
+               protocol: p,
+               offset:   offset,
+       }, nil
+}
+
+func bytesToString(b []byte) (ret string, err error) {
+       var buf strings.Builder
+
+       for len(b) > 0 {
+               n, c, err := readComponent(b)
+               if err != nil {
+                       return "", err
+               }
+               b = b[n:]
+               c.writeTo(&buf)
+       }
+
+       return buf.String(), nil
+}
+
+func sizeForAddr(p Protocol, b []byte) (skip, size int, err error) {
+       switch {
+       case p.Size > 0:
+               return 0, (p.Size / 8), nil
+       case p.Size == 0:
+               return 0, 0, nil
+       default:
+               size, n, err := ReadVarintCode(b)
+               if err != nil {
+                       return 0, 0, err
+               }
+               return n, size, nil
+       }
+}
+
+func bytesSplit(b []byte) ([][]byte, error) {
+       var ret [][]byte
+       for len(b) > 0 {
+               code, n, err := ReadVarintCode(b)
+               if err != nil {
+                       return nil, err
+               }
+
+               p := ProtocolWithCode(code)
+               if p.Code == 0 {
+                       return nil, fmt.Errorf("no protocol with code %d", b[0])
+               }
+
+               n2, size, err := sizeForAddr(p, b[n:])
+               if err != nil {
+                       return nil, err
+               }
+
+               length := n + n2 + size
+               ret = append(ret, b[:length])
+               b = b[length:]
+       }
+
+       return ret, nil
+}

diff --git a/vendor/github.com/multiformats/go-multiaddr/component.go b/vendor/github.com/multiformats/go-multiaddr/component.go
new file mode 100644 (file)
index 0000000..e31fe5d
--- /dev/null
+++ b/vendor/github.com/multiformats/go-multiaddr/component.go
@@ -0,0 +1,132 @@
+package multiaddr
+
+import (
+       "bytes"
+       "encoding/binary"
+       "fmt"
+       "strings"
+)
+
+// Component is a single multiaddr Component.
+type Component struct {
+       bytes    []byte
+       protocol Protocol
+       offset   int
+}
+
+func (c *Component) Bytes() []byte {
+       return c.bytes
+}
+
+func (c *Component) Equal(o Multiaddr) bool {
+       return bytes.Equal(c.bytes, o.Bytes())
+}
+
+func (c *Component) Protocols() []Protocol {
+       return []Protocol{c.protocol}
+}
+
+func (c *Component) Decapsulate(o Multiaddr) Multiaddr {
+       if c.Equal(o) {
+               return nil
+       }
+       return c
+}
+
+func (c *Component) Encapsulate(o Multiaddr) Multiaddr {
+       m := multiaddr{bytes: c.bytes}
+       return m.Encapsulate(o)
+}
+
+func (c *Component) ValueForProtocol(code int) (string, error) {
+       if c.protocol.Code != code {
+               return "", ErrProtocolNotFound
+       }
+       return c.Value(), nil
+}
+
+func (c *Component) Protocol() Protocol {
+       return c.protocol
+}
+
+func (c *Component) RawValue() []byte {
+       return c.bytes[c.offset:]
+}
+
+func (c *Component) Value() string {
+       if c.protocol.Transcoder == nil {
+               return ""
+       }
+       value, err := c.protocol.Transcoder.BytesToString(c.bytes[c.offset:])
+       if err != nil {
+               // This Component must have been checked.
+               panic(err)
+       }
+       return value
+}
+
+func (c *Component) String() string {
+       var b strings.Builder
+       c.writeTo(&b)
+       return b.String()
+}
+
+// writeTo is an efficient, private function for string-formatting a multiaddr.
+// Trust me, we tend to allocate a lot when doing this.
+func (c *Component) writeTo(b *strings.Builder) {
+       b.WriteByte('/')
+       b.WriteString(c.protocol.Name)
+       value := c.Value()
+       if len(value) == 0 {
+               return
+       }
+       if !(c.protocol.Path && value[0] == '/') {
+               b.WriteByte('/')
+       }
+       b.WriteString(value)
+}
+
+// NewComponent constructs a new multiaddr component
+func NewComponent(protocol, value string) (*Component, error) {
+       p := ProtocolWithName(protocol)
+       if p.Code == 0 {
+               return nil, fmt.Errorf("unsupported protocol: %s", protocol)
+       }
+       if p.Transcoder != nil {
+               bts, err := p.Transcoder.StringToBytes(value)
+               if err != nil {
+                       return nil, err
+               }
+               return newComponent(p, bts), nil
+       } else if value != "" {
+               return nil, fmt.Errorf("protocol %s doesn't take a value", p.Name)
+       }
+       return newComponent(p, nil), nil
+       // TODO: handle path /?
+}
+
+func newComponent(protocol Protocol, bvalue []byte) *Component {
+       size := len(bvalue)
+       size += len(protocol.VCode)
+       if protocol.Size < 0 {
+               size += VarintSize(len(bvalue))
+       }
+       maddr := make([]byte, size)
+       var offset int
+       offset += copy(maddr[offset:], protocol.VCode)
+       if protocol.Size < 0 {
+               offset += binary.PutUvarint(maddr[offset:], uint64(len(bvalue)))
+       }
+       copy(maddr[offset:], bvalue)
+
+       // For debugging
+       if len(maddr) != offset+len(bvalue) {
+               panic("incorrect length")
+       }
+
+       return &Component{
+               bytes:    maddr,
+               protocol: protocol,
+               offset:   offset,
+       }
+}

diff --git a/vendor/github.com/multiformats/go-multiaddr/doc.go b/vendor/github.com/multiformats/go-multiaddr/doc.go
new file mode 100644 (file)
index 0000000..d8c37b2
--- /dev/null
+++ b/vendor/github.com/multiformats/go-multiaddr/doc.go
@@ -0,0 +1,36 @@
+/*
+Package multiaddr provides an implementation of the Multiaddr network
+address format. Multiaddr emphasizes explicitness, self-description, and
+portability. It allows applications to treat addresses as opaque tokens,
+and to avoid making assumptions about the address representation (e.g. length).
+Learn more at https://github.com/multiformats/multiaddr
+
+Basic Use:
+
+  import (
+    "bytes"
+    "strings"
+    ma "github.com/multiformats/go-multiaddr"
+  )
+
+  // construct from a string (err signals parse failure)
+  m1, err := ma.NewMultiaddr("/ip4/127.0.0.1/udp/1234")
+
+  // construct from bytes (err signals parse failure)
+  m2, err := ma.NewMultiaddrBytes(m1.Bytes())
+
+  // true
+  strings.Equal(m1.String(), "/ip4/127.0.0.1/udp/1234")
+  strings.Equal(m1.String(), m2.String())
+  bytes.Equal(m1.Bytes(), m2.Bytes())
+  m1.Equal(m2)
+  m2.Equal(m1)
+
+  // tunneling (en/decap)
+  printer, _ := ma.NewMultiaddr("/ip4/192.168.0.13/tcp/80")
+  proxy, _ := ma.NewMultiaddr("/ip4/10.20.30.40/tcp/443")
+  printerOverProxy := proxy.Encapsulate(printer)
+  proxyAgain := printerOverProxy.Decapsulate(printer)
+
+*/
+package multiaddr

diff --git a/vendor/github.com/multiformats/go-multiaddr/interface.go b/vendor/github.com/multiformats/go-multiaddr/interface.go
new file mode 100644 (file)
index 0000000..34bffd9
--- /dev/null
+++ b/vendor/github.com/multiformats/go-multiaddr/interface.go
@@ -0,0 +1,50 @@
+package multiaddr
+
+/*
+Multiaddr is a cross-protocol, cross-platform format for representing
+internet addresses. It emphasizes explicitness and self-description.
+Learn more here: https://github.com/multiformats/multiaddr
+
+Multiaddrs have both a binary and string representation.
+
+    import ma "github.com/multiformats/go-multiaddr"
+
+    addr, err := ma.NewMultiaddr("/ip4/1.2.3.4/tcp/80")
+    // err non-nil when parsing failed.
+
+*/
+type Multiaddr interface {
+       // Equal returns whether two Multiaddrs are exactly equal
+       Equal(Multiaddr) bool
+
+       // Bytes returns the []byte representation of this Multiaddr
+       //
+       // This function may expose immutable, internal state. Do not modify.
+       Bytes() []byte
+
+       // String returns the string representation of this Multiaddr
+       // (may panic if internal state is corrupted)
+       String() string
+
+       // Protocols returns the list of Protocols this Multiaddr includes
+       // will panic if protocol code incorrect (and bytes accessed incorrectly)
+       Protocols() []Protocol
+
+       // Encapsulate wraps this Multiaddr around another. For example:
+       //
+       //      /ip4/1.2.3.4 encapsulate /tcp/80 = /ip4/1.2.3.4/tcp/80
+       //
+       Encapsulate(Multiaddr) Multiaddr
+
+       // Decapsultate removes a Multiaddr wrapping. For example:
+       //
+       //      /ip4/1.2.3.4/tcp/80 decapsulate /ip4/1.2.3.4 = /tcp/80
+       //
+       Decapsulate(Multiaddr) Multiaddr
+
+       // ValueForProtocol returns the value (if any) following the specified protocol
+       //
+       // Note: protocols can appear multiple times in a single multiaddr.
+       // Consider using `ForEach` to walk over the addr manually.
+       ValueForProtocol(code int) (string, error)
+}

diff --git a/vendor/github.com/multiformats/go-multiaddr/multiaddr.go b/vendor/github.com/multiformats/go-multiaddr/multiaddr.go
new file mode 100644 (file)
index 0000000..2c07dd3
--- /dev/null
+++ b/vendor/github.com/multiformats/go-multiaddr/multiaddr.go
@@ -0,0 +1,141 @@
+package multiaddr
+
+import (
+       "bytes"
+       "fmt"
+       "log"
+       "strings"
+)
+
+// multiaddr is the data structure representing a Multiaddr
+type multiaddr struct {
+       bytes []byte
+}
+
+// NewMultiaddr parses and validates an input string, returning a *Multiaddr
+func NewMultiaddr(s string) (a Multiaddr, err error) {
+       defer func() {
+               if e := recover(); e != nil {
+                       log.Printf("Panic in NewMultiaddr on input %q: %s", s, e)
+                       err = fmt.Errorf("%v", e)
+               }
+       }()
+       b, err := stringToBytes(s)
+       if err != nil {
+               return nil, err
+       }
+       return multiaddr{bytes: b}, nil
+}
+
+// NewMultiaddrBytes initializes a Multiaddr from a byte representation.
+// It validates it as an input string.
+func NewMultiaddrBytes(b []byte) (a Multiaddr, err error) {
+       defer func() {
+               if e := recover(); e != nil {
+                       log.Printf("Panic in NewMultiaddrBytes on input %q: %s", b, e)
+                       err = fmt.Errorf("%v", e)
+               }
+       }()
+
+       if err := validateBytes(b); err != nil {
+               return nil, err
+       }
+
+       return multiaddr{bytes: b}, nil
+}
+
+// Equal tests whether two multiaddrs are equal
+func (m multiaddr) Equal(m2 Multiaddr) bool {
+       return bytes.Equal(m.bytes, m2.Bytes())
+}
+
+// Bytes returns the []byte representation of this Multiaddr
+//
+// Do not modify the returned buffer, it may be shared.
+func (m multiaddr) Bytes() []byte {
+       return m.bytes
+}
+
+// String returns the string representation of a Multiaddr
+func (m multiaddr) String() string {
+       s, err := bytesToString(m.bytes)
+       if err != nil {
+               panic(fmt.Errorf("multiaddr failed to convert back to string. corrupted? %s", err))
+       }
+       return s
+}
+
+// Protocols returns the list of protocols this Multiaddr has.
+// will panic in case we access bytes incorrectly.
+func (m multiaddr) Protocols() []Protocol {
+       ps := make([]Protocol, 0, 8)
+       b := m.bytes
+       for len(b) > 0 {
+               code, n, err := ReadVarintCode(b)
+               if err != nil {
+                       panic(err)
+               }
+
+               p := ProtocolWithCode(code)
+               if p.Code == 0 {
+                       // this is a panic (and not returning err) because this should've been
+                       // caught on constructing the Multiaddr
+                       panic(fmt.Errorf("no protocol with code %d", b[0]))
+               }
+               ps = append(ps, p)
+               b = b[n:]
+
+               n, size, err := sizeForAddr(p, b)
+               if err != nil {
+                       panic(err)
+               }
+
+               b = b[n+size:]
+       }
+       return ps
+}
+
+// Encapsulate wraps a given Multiaddr, returning the resulting joined Multiaddr
+func (m multiaddr) Encapsulate(o Multiaddr) Multiaddr {
+       mb := m.bytes
+       ob := o.Bytes()
+
+       b := make([]byte, len(mb)+len(ob))
+       copy(b, mb)
+       copy(b[len(mb):], ob)
+       return multiaddr{bytes: b}
+}
+
+// Decapsulate unwraps Multiaddr up until the given Multiaddr is found.
+func (m multiaddr) Decapsulate(o Multiaddr) Multiaddr {
+       s1 := m.String()
+       s2 := o.String()
+       i := strings.LastIndex(s1, s2)
+       if i < 0 {
+               // if multiaddr not contained, returns a copy.
+               cpy := make([]byte, len(m.bytes))
+               copy(cpy, m.bytes)
+               return multiaddr{bytes: cpy}
+       }
+
+       ma, err := NewMultiaddr(s1[:i])
+       if err != nil {
+               panic("Multiaddr.Decapsulate incorrect byte boundaries.")
+       }
+       return ma
+}
+
+var ErrProtocolNotFound = fmt.Errorf("protocol not found in multiaddr")
+
+func (m multiaddr) ValueForProtocol(code int) (value string, err error) {
+       err = ErrProtocolNotFound
+       ForEach(m, func(c Component) bool {
+               if c.Protocol().Code == code {
+                       value = c.Value()
+                       err = nil
+                       return false
+               }
+               return true
+       })
+       return
+}

diff --git a/vendor/github.com/multiformats/go-multiaddr/multiaddr_test.go b/vendor/github.com/multiformats/go-multiaddr/multiaddr_test.go
new file mode 100644 (file)
index 0000000..138fcd7
--- /dev/null
+++ b/vendor/github.com/multiformats/go-multiaddr/multiaddr_test.go
@@ -0,0 +1,557 @@
+package multiaddr
+
+import (
+       "bytes"
+       "encoding/hex"
+       "math/rand"
+       "strings"
+       "testing"
+       "time"
+)
+
+func newMultiaddr(t *testing.T, a string) Multiaddr {
+       m, err := NewMultiaddr(a)
+       if err != nil {
+               t.Error(err)
+       }
+       return m
+}
+
+func TestConstructFails(t *testing.T) {
+       cases := []string{
+               "/ip4",
+               "/ip4/::1",
+               "/ip4/fdpsofodsajfdoisa",
+               "/ip6",
+               "/ip6zone",
+               "/ip6zone/",
+               "/ip6zone//ip6/fe80::1",
+               "/udp",
+               "/tcp",
+               "/sctp",
+               "/udp/65536",
+               "/tcp/65536",
+               "/quic/65536",
+               "/onion/9imaq4ygg2iegci7:80",
+               "/onion/aaimaq4ygg2iegci7:80",
+               "/onion/timaq4ygg2iegci7:0",
+               "/onion/timaq4ygg2iegci7:-1",
+               "/onion/timaq4ygg2iegci7",
+               "/onion/timaq4ygg2iegci@:666",
+               "/onion3/9ww6ybal4bd7szmgncyruucpgfkqahzddi37ktceo3ah7ngmcopnpyyd:80",
+               "/onion3/vww6ybal4bd7szmgncyruucpgfkqahzddi37ktceo3ah7ngmcopnpyyd7:80",
+               "/onion3/vww6ybal4bd7szmgncyruucpgfkqahzddi37ktceo3ah7ngmcopnpyyd:0",
+               "/onion3/vww6ybal4bd7szmgncyruucpgfkqahzddi37ktceo3ah7ngmcopnpyyd:-1",
+               "/onion3/vww6ybal4bd7szmgncyruucpgfkqahzddi37ktceo3ah7ngmcopnpyyd",
+               "/onion3/vww6ybal4bd7szmgncyruucpgfkqahzddi37ktceo3ah7ngmcopnpyy@:666",
+               "/garlic64/jT~IyXaoauTni6N4517EG8mrFUKpy0IlgZh-EY9csMAk82Odatmzr~YTZy8Hv7u~wvkg75EFNOyqb~nAPg-khyp2TS~ObUz8WlqYAM2VlEzJ7wJB91P-cUlKF18zSzVoJFmsrcQHZCirSbWoOknS6iNmsGRh5KVZsBEfp1Dg3gwTipTRIx7Vl5Vy~1OSKQVjYiGZS9q8RL0MF~7xFiKxZDLbPxk0AK9TzGGqm~wMTI2HS0Gm4Ycy8LYPVmLvGonIBYndg2bJC7WLuF6tVjVquiokSVDKFwq70BCUU5AU-EvdOD5KEOAM7mPfw-gJUG4tm1TtvcobrObqoRnmhXPTBTN5H7qDD12AvlwFGnfAlBXjuP4xOUAISL5SRLiulrsMSiT4GcugSI80mF6sdB0zWRgL1yyvoVWeTBn1TqjO27alr95DGTluuSqrNAxgpQzCKEWAyzrQkBfo2avGAmmz2NaHaAvYbOg0QSJz1PLjv2jdPW~ofiQmrGWM1cd~1cCqAAAA7:80",
+               "/garlic64/jT~IyXaoauTni6N4517EG8mrFUKpy0IlgZh-EY9csMAk82Odatmzr~YTZy8Hv7u~wvkg75EFNOyqb~nAPg-khyp2TS~ObUz8WlqYAM2VlEzJ7wJB91P-cUlKF18zSzVoJFmsrcQHZCirSbWoOknS6iNmsGRh5KVZsBEfp1Dg3gwTipTRIx7Vl5Vy~1OSKQVjYiGZS9q8RL0MF~7xFiKxZDLbPxk0AK9TzGGqm~wMTI2HS0Gm4Ycy8LYPVmLvGonIBYndg2bJC7WLuF6tVjVquiokSVDKFwq70BCUU5AU-EvdOD5KEOAM7mPfw-gJUG4tm1TtvcobrObqoRnmhXPTBTN5H7qDD12AvlwFGnfAlBXjuP4xOUAISL5SRLiulrsMSiT4GcugSI80mF6sdB0zWRgL1yyvoVWeTBn1TqjO27alr95DGTluuSqrNAxgpQzCKEWAyzrQkBfo2avGAmmz2NaHaAvYbOg0QSJz1PLjv2jdPW~ofiQmrGWM1cd~1cCqAAAA:0",
+               "/garlic64/jT~IyXaoauTni6N4517EG8mrFUKpy0IlgZh-EY9csMAk82Odatmzr~YTZy8Hv7u~wvkg75EFNOyqb~nAPg-khyp2TS~ObUz8WlqYAM2VlEzJ7wJB91P-cUlKF18zSzVoJFmsrcQHZCirSbWoOknS6iNmsGRh5KVZsBEfp1Dg3gwTipTRIx7Vl5Vy~1OSKQVjYiGZS9q8RL0MF~7xFiKxZDLbPxk0AK9TzGGqm~wMTI2HS0Gm4Ycy8LYPVmLvGonIBYndg2bJC7WLuF6tVjVquiokSVDKFwq70BCUU5AU-EvdOD5KEOAM7mPfw-gJUG4tm1TtvcobrObqoRnmhXPTBTN5H7qDD12AvlwFGnfAlBXjuP4xOUAISL5SRLiulrsMSiT4GcugSI80mF6sdB0zWRgL1yyvoVWeTBn1TqjO27alr95DGTluuSqrNAxgpQzCKEWAyzrQkBfo2avGAmmz2NaHaAvYbOg0QSJz1PLjv2jdPW~ofiQmrGWM1cd~1cCqAAAA:0",
+               "/garlic64/jT~IyXaoauTni6N4517EG8mrFUKpy0IlgZh-EY9csMAk82Odatmzr~YTZy8Hv7u~wvkg75EFNOyqb~nAPg-khyp2TS~ObUz8WlqYAM2VlEzJ7wJB91P-cUlKF18zSzVoJFmsrcQHZCirSbWoOknS6iNmsGRh5KVZsBEfp1Dg3gwTipTRIx7Vl5Vy~1OSKQVjYiGZS9q8RL0MF~7xFiKxZDLbPxk0AK9TzGGqm~wMTI2HS0Gm4Ycy8LYPVmLvGonIBYndg2bJC7WLuF6tVjVquiokSVDKFwq70BCUU5AU-EvdOD5KEOAM7mPfw-gJUG4tm1TtvcobrObqoRnmhXPTBTN5H7qDD12AvlwFGnfAlBXjuP4xOUAISL5SRLiulrsMSiT4GcugSI80mF6sdB0zWRgL1yyvoVWeTBn1TqjO27alr95DGTluuSqrNAxgpQzCKEWAyzrQkBfo2avGAmmz2NaHaAvYbOg0QSJz1PLjv2jdPW~ofiQmrGWM1cd~1cCqAAAA:-1",
+               "/garlic64/jT~IyXaoauTni6N4517EG8mrFUKpy0IlgZh-EY9csMAk82Odatmzr~YTZy8Hv7u~wvkg75EFNOyqb~nAPg-khyp2TS~ObUz8WlqYAM2VlEzJ7wJB91P-cUlKF18zSzVoJFmsrcQHZCirSbWoOknS6iNmsGRh5KVZsBEfp1Dg3gwTipTRIx7Vl5Vy~1OSKQVjYiGZS9q8RL0MF~7xFiKxZDLbPxk0AK9TzGGqm~wMTI2HS0Gm4Ycy8LYPVmLvGonIBYndg2bJC7WLuF6tVjVquiokSVDKFwq70BCUU5AU-EvdOD5KEOAM7mPfw-gJUG4tm1TtvcobrObqoRnmhXPTBTN5H7qDD12AvlwFGnfAlBXjuP4xOUAISL5SRLiulrsMSiT4GcugSI80mF6sdB0zWRgL1yyvoVWeTBn1TqjO27alr95DGTluuSqrNAxgpQzCKEWAyzrQkBfo2avGAmmz2NaHaAvYbOg0QSJz1PLjv2jdPW~ofiQmrGWM1cd~1cCqAAAA@:666",
+               "/garlic64/jT~IyXaoauTni6N4517EG8mrFUKpy0IlgZh-EY9csMAk82Odatmzr~YTZy8Hv7u~wvkg75EFNOyqb~nAPg-khyp2TS~ObUz8WlqYAM2VlEzJ7wJB91P-cUlKF18zSzVoJFmsrcQHZCirSbWoOknS6iNmsGRh5KVZsBEfp1Dg3gwTipTRIx7Vl5Vy~1OSKQVjYiGZS9q8RL0MF~7xFiKxZDLbPxk0AK9TzGGqm~wMTI2HS0Gm4Ycy8LYPVmLvGonIBYndg2bJC7WLuF6tVjVquiokSVDKFwq70BCUU5AU-EvdOD5KEOAM7mPfw-gJUG4tm1TtvcobrObqoRnmhXPTBTN5H7qDD12AvlwFGnfAlBXjuP4xOUAISL5SRLiulrsMSiT4GcugSI80mF6sdB0zWRgL1yyvoVWeTBn1TqjO27alr95DGTluuSqrNAxgpQzCKEWAyzrQkBfo2avGAmmz2NaHaAvYbOg0QSJz1PLjv2jdPW~ofiQmrGWM1cd~1cCqAAAA7:80",
+               "/garlic64/jT~IyXaoauTni6N4517EG8mrFUKpy0IlgZh-EY9csMAk82Odatmzr~YTZy8Hv7u~wvkg75EFNOyqb~nAPg-khyp2TS~ObUz8WlqYAM2VlEzJ7wJB91P-cUlKF18zSzVoJFmsrcQHZCirSbWoOknS6iNmsGRh5KVZsBEfp1Dg3gwTipTRIx7Vl5Vy~1OSKQVjYiGZS9q8RL0MF~7xFiKxZDLbPxk0AK9TzGGqm~wMTI2HS0Gm4Ycy8LYPVmLvGonIBYndg2bJC7WLuF6tVjVquiokSVDKFwq70BCUU5AU-EvdOD5KEOAM7mPfw-gJUG4tm1TtvcobrObqoRnmhXPTBTN5H7qDD12AvlwFGnfAlBXjuP4xOUAISL5SRLiulrsMSiT4GcugSI80mF6sdB0zWRgL1yyvoVWeTBn1TqjO27alr95DGTluuSqrNAxgpQzCKEWAyzrQkBfo2avGAmmz2NaHaAvYbOg0QSJz1PLjv2jdPW~ofiQmrGWM1cd~1cCqAAAA:0",
+               "/garlic64/jT~IyXaoauTni6N4517EG8mrFUKpy0IlgZh-EY9csMAk82Odatmzr~YTZy8Hv7u~wvkg75EFNOyqb~nAPg-khyp2TS~ObUz8WlqYAM2VlEzJ7wJB91P-cUlKF18zSzVoJFmsrcQHZCirSbWoOknS6iNmsGRh5KVZsBEfp1Dg3gwTipTRIx7Vl5Vy~1OSKQVjYiGZS9q8RL0MF~7xFiKxZDLbPxk0AK9TzGGqm~wMTI2HS0Gm4Ycy8LYPVmLvGonIBYndg2bJC7WLuF6tVjVquiokSVDKFwq70BCUU5AU-EvdOD5KEOAM7mPfw-gJUG4tm1TtvcobrObqoRnmhXPTBTN5H7qDD12AvlwFGnfAlBXjuP4xOUAISL5SRLiulrsMSiT4GcugSI80mF6sdB0zWRgL1yyvoVWeTBn1TqjO27alr95DGTluuSqrNAxgpQzCKEWAyzrQkBfo2avGAmmz2NaHaAvYbOg0QSJz1PLjv2jdPW~ofiQmrGWM1cd~1cCqAAAA:0",
+               "/garlic64/jT~IyXaoauTni6N4517EG8mrFUKpy0IlgZh-EY9csMAk82Odatmzr~YTZy8Hv7u~wvkg75EFNOyqb~nAPg-khyp2TS~ObUz8WlqYAM2VlEzJ7wJB91P-cUlKF18zSzVoJFmsrcQHZCirSbWoOknS6iNmsGRh5KVZsBEfp1Dg3gwTipTRIx7Vl5Vy~1OSKQVjYiGZS9q8RL0MF~7xFiKxZDLbPxk0AK9TzGGqm~wMTI2HS0Gm4Ycy8LYPVmLvGonIBYndg2bJC7WLuF6tVjVquiokSVDKFwq70BCUU5AU-EvdOD5KEOAM7mPfw-gJUG4tm1TtvcobrObqoRnmhXPTBTN5H7qDD12AvlwFGnfAlBXjuP4xOUAISL5SRLiulrsMSiT4GcugSI80mF6sdB0zWRgL1yyvoVWeTBn1TqjO27alr95DGTluuSqrNAxgpQzCKEWAyzrQkBfo2avGAmmz2NaHaAvYbOg0QSJz1PLjv2jdPW~ofiQmrGWM1cd~1cCqAAAA:-1",
+               "/garlic64/jT~IyXaoauTni6N4517EG8mrFUKpy0IlgZh-EY9csMAk82Odatmzr~YTZy8Hv7u~wvkg75EFNOyqb~nAPg-khyp2TS~ObUz8WlqYAM2VlEzJ7wJB91P-cUlKF18zSzVoJFmsrcQHZCirSbWoOknS6iNmsGRh5KVZsBEfp1Dg3gwTipTRIx7Vl5Vy~1OSKQVjYiGZS9q8RL0MF~7xFiKxZDLbPxk0AK9TzGGqm~wMTI2HS0Gm4Ycy8LYPVmLvGonIBYndg2bJC7WLuF6tVjVquiokSVDKFwq70BCUU5AU-EvdOD5KEOAM7mPfw-gJUG4tm1TtvcobrObqoRnmhXPTBTN5H7qDD12AvlwFGnfAlBXjuP4xOUAISL5SRLiulrsMSiT4GcugSI80mF6sdB0zWRgL1yyvoVWeTBn1TqjO27alr95DGTluuSqrNAxgpQzCKEWAyzrQkBfo2avGAmmz2NaHaAvYbOg0QSJz1PLjv2jdPW~ofiQmrGWM1cd~1cCqAAAA@:666",
+               "/udp/1234/sctp",
+               "/udp/1234/udt/1234",
+               "/udp/1234/utp/1234",
+               "/ip4/127.0.0.1/udp/jfodsajfidosajfoidsa",
+               "/ip4/127.0.0.1/udp",
+               "/ip4/127.0.0.1/tcp/jfodsajfidosajfoidsa",
+               "/ip4/127.0.0.1/tcp",
+               "/ip4/127.0.0.1/quic/1234",
+               "/ip4/127.0.0.1/ipfs",
+               "/ip4/127.0.0.1/ipfs/tcp",
+               "/ip4/127.0.0.1/p2p",
+               "/ip4/127.0.0.1/p2p/tcp",
+               "/unix",
+               "/ip4/1.2.3.4/tcp/80/unix",
+               "/ip4/127.0.0.1/tcp/9090/http/p2p-webcrt-direct",
+       }
+
+       for _, a := range cases {
+               if _, err := NewMultiaddr(a); err == nil {
+                       t.Errorf("should have failed: %s - %s", a, err)
+               }
+       }
+}
+
+func TestConstructSucceeds(t *testing.T) {
+       cases := []string{
+               "/ip4/1.2.3.4",
+               "/ip4/0.0.0.0",
+               "/ip6/::1",
+               "/ip6/2601:9:4f81:9700:803e:ca65:66e8:c21",
+               "/ip6/2601:9:4f81:9700:803e:ca65:66e8:c21/udp/1234/quic",
+               "/ip6zone/x/ip6/fe80::1",
+               "/ip6zone/x%y/ip6/fe80::1",
+               "/ip6zone/x%y/ip6/::",
+               "/ip6zone/x/ip6/fe80::1/udp/1234/quic",
+               "/onion/timaq4ygg2iegci7:1234",
+               "/onion/timaq4ygg2iegci7:80/http",
+               "/onion3/vww6ybal4bd7szmgncyruucpgfkqahzddi37ktceo3ah7ngmcopnpyyd:1234",
+               "/onion3/vww6ybal4bd7szmgncyruucpgfkqahzddi37ktceo3ah7ngmcopnpyyd:80/http",
+               "/garlic64/jT~IyXaoauTni6N4517EG8mrFUKpy0IlgZh-EY9csMAk82Odatmzr~YTZy8Hv7u~wvkg75EFNOyqb~nAPg-khyp2TS~ObUz8WlqYAM2VlEzJ7wJB91P-cUlKF18zSzVoJFmsrcQHZCirSbWoOknS6iNmsGRh5KVZsBEfp1Dg3gwTipTRIx7Vl5Vy~1OSKQVjYiGZS9q8RL0MF~7xFiKxZDLbPxk0AK9TzGGqm~wMTI2HS0Gm4Ycy8LYPVmLvGonIBYndg2bJC7WLuF6tVjVquiokSVDKFwq70BCUU5AU-EvdOD5KEOAM7mPfw-gJUG4tm1TtvcobrObqoRnmhXPTBTN5H7qDD12AvlwFGnfAlBXjuP4xOUAISL5SRLiulrsMSiT4GcugSI80mF6sdB0zWRgL1yyvoVWeTBn1TqjO27alr95DGTluuSqrNAxgpQzCKEWAyzrQkBfo2avGAmmz2NaHaAvYbOg0QSJz1PLjv2jdPW~ofiQmrGWM1cd~1cCqAAAA",
+               "/garlic64/jT~IyXaoauTni6N4517EG8mrFUKpy0IlgZh-EY9csMAk82Odatmzr~YTZy8Hv7u~wvkg75EFNOyqb~nAPg-khyp2TS~ObUz8WlqYAM2VlEzJ7wJB91P-cUlKF18zSzVoJFmsrcQHZCirSbWoOknS6iNmsGRh5KVZsBEfp1Dg3gwTipTRIx7Vl5Vy~1OSKQVjYiGZS9q8RL0MF~7xFiKxZDLbPxk0AK9TzGGqm~wMTI2HS0Gm4Ycy8LYPVmLvGonIBYndg2bJC7WLuF6tVjVquiokSVDKFwq70BCUU5AU-EvdOD5KEOAM7mPfw-gJUG4tm1TtvcobrObqoRnmhXPTBTN5H7qDD12AvlwFGnfAlBXjuP4xOUAISL5SRLiulrsMSiT4GcugSI80mF6sdB0zWRgL1yyvoVWeTBn1TqjO27alr95DGTluuSqrNAxgpQzCKEWAyzrQkBfo2avGAmmz2NaHaAvYbOg0QSJz1PLjv2jdPW~ofiQmrGWM1cd~1cCqAAAA/http",
+               "/garlic64/jT~IyXaoauTni6N4517EG8mrFUKpy0IlgZh-EY9csMAk82Odatmzr~YTZy8Hv7u~wvkg75EFNOyqb~nAPg-khyp2TS~ObUz8WlqYAM2VlEzJ7wJB91P-cUlKF18zSzVoJFmsrcQHZCirSbWoOknS6iNmsGRh5KVZsBEfp1Dg3gwTipTRIx7Vl5Vy~1OSKQVjYiGZS9q8RL0MF~7xFiKxZDLbPxk0AK9TzGGqm~wMTI2HS0Gm4Ycy8LYPVmLvGonIBYndg2bJC7WLuF6tVjVquiokSVDKFwq70BCUU5AU-EvdOD5KEOAM7mPfw-gJUG4tm1TtvcobrObqoRnmhXPTBTN5H7qDD12AvlwFGnfAlBXjuP4xOUAISL5SRLiulrsMSiT4GcugSI80mF6sdB0zWRgL1yyvoVWeTBn1TqjO27alr95DGTluuSqrNAxgpQzCKEWAyzrQkBfo2avGAmmz2NaHaAvYbOg0QSJz1PLjv2jdPW~ofiQmrGWM1cd~1cCqAAAA/udp/8080",
+               "/garlic64/jT~IyXaoauTni6N4517EG8mrFUKpy0IlgZh-EY9csMAk82Odatmzr~YTZy8Hv7u~wvkg75EFNOyqb~nAPg-khyp2TS~ObUz8WlqYAM2VlEzJ7wJB91P-cUlKF18zSzVoJFmsrcQHZCirSbWoOknS6iNmsGRh5KVZsBEfp1Dg3gwTipTRIx7Vl5Vy~1OSKQVjYiGZS9q8RL0MF~7xFiKxZDLbPxk0AK9TzGGqm~wMTI2HS0Gm4Ycy8LYPVmLvGonIBYndg2bJC7WLuF6tVjVquiokSVDKFwq70BCUU5AU-EvdOD5KEOAM7mPfw-gJUG4tm1TtvcobrObqoRnmhXPTBTN5H7qDD12AvlwFGnfAlBXjuP4xOUAISL5SRLiulrsMSiT4GcugSI80mF6sdB0zWRgL1yyvoVWeTBn1TqjO27alr95DGTluuSqrNAxgpQzCKEWAyzrQkBfo2avGAmmz2NaHaAvYbOg0QSJz1PLjv2jdPW~ofiQmrGWM1cd~1cCqAAAA/tcp/8080",
+               "/udp/0",
+               "/tcp/0",
+               "/sctp/0",
+               "/udp/1234",
+               "/tcp/1234",
+               "/sctp/1234",
+               "/udp/65535",
+               "/tcp/65535",
+               "/ipfs/QmcgpsyWgH8Y8ajJz1Cu72KnS5uo2Aa2LpzU7kinSupNKC",
+               "/p2p/QmcgpsyWgH8Y8ajJz1Cu72KnS5uo2Aa2LpzU7kinSupNKC",
+               "/udp/1234/sctp/1234",
+               "/udp/1234/udt",
+               "/udp/1234/utp",
+               "/tcp/1234/http",
+               "/tcp/1234/https",
+               "/ipfs/QmcgpsyWgH8Y8ajJz1Cu72KnS5uo2Aa2LpzU7kinSupNKC/tcp/1234",
+               "/p2p/QmcgpsyWgH8Y8ajJz1Cu72KnS5uo2Aa2LpzU7kinSupNKC/tcp/1234",
+               "/ip4/127.0.0.1/udp/1234",
+               "/ip4/127.0.0.1/udp/0",
+               "/ip4/127.0.0.1/tcp/1234",
+               "/ip4/127.0.0.1/tcp/1234/",
+               "/ip4/127.0.0.1/udp/1234/quic",
+               "/ip4/127.0.0.1/ipfs/QmcgpsyWgH8Y8ajJz1Cu72KnS5uo2Aa2LpzU7kinSupNKC",
+               "/ip4/127.0.0.1/ipfs/QmcgpsyWgH8Y8ajJz1Cu72KnS5uo2Aa2LpzU7kinSupNKC/tcp/1234",
+               "/ip4/127.0.0.1/p2p/QmcgpsyWgH8Y8ajJz1Cu72KnS5uo2Aa2LpzU7kinSupNKC",
+               "/ip4/127.0.0.1/p2p/QmcgpsyWgH8Y8ajJz1Cu72KnS5uo2Aa2LpzU7kinSupNKC/tcp/1234",
+               "/unix/a/b/c/d/e",
+               "/unix/stdio",
+               "/ip4/1.2.3.4/tcp/80/unix/a/b/c/d/e/f",
+               "/ip4/127.0.0.1/ipfs/QmcgpsyWgH8Y8ajJz1Cu72KnS5uo2Aa2LpzU7kinSupNKC/tcp/1234/unix/stdio",
+               "/ip4/127.0.0.1/p2p/QmcgpsyWgH8Y8ajJz1Cu72KnS5uo2Aa2LpzU7kinSupNKC/tcp/1234/unix/stdio",
+               "/ip4/127.0.0.1/tcp/9090/http/p2p-webrtc-direct",
+       }
+
+       for _, a := range cases {
+               if _, err := NewMultiaddr(a); err != nil {
+                       t.Errorf("should have succeeded: %s -- %s", a, err)
+               }
+       }
+}
+
+func TestEqual(t *testing.T) {
+       m1 := newMultiaddr(t, "/ip4/127.0.0.1/udp/1234")
+       m2 := newMultiaddr(t, "/ip4/127.0.0.1/tcp/1234")
+       m3 := newMultiaddr(t, "/ip4/127.0.0.1/tcp/1234")
+       m4 := newMultiaddr(t, "/ip4/127.0.0.1/tcp/1234/")
+
+       if m1.Equal(m2) {
+               t.Error("should not be equal")
+       }
+
+       if m2.Equal(m1) {
+               t.Error("should not be equal")
+       }
+
+       if !m2.Equal(m3) {
+               t.Error("should be equal")
+       }
+
+       if !m3.Equal(m2) {
+               t.Error("should be equal")
+       }
+
+       if !m1.Equal(m1) {
+               t.Error("should be equal")
+       }
+
+       if !m2.Equal(m4) {
+               t.Error("should be equal")
+       }
+
+       if !m4.Equal(m3) {
+               t.Error("should be equal")
+       }
+}
+
+func TestStringToBytes(t *testing.T) {
+
+       testString := func(s string, h string) {
+               b1, err := hex.DecodeString(h)
+               if err != nil {
+                       t.Error("failed to decode hex", h)
+               }
+
+               b2, err := stringToBytes(s)
+               if err != nil {
+                       t.Error("failed to convert", s, err)
+               }
+
+               if !bytes.Equal(b1, b2) {
+                       t.Error("failed to convert \n", s, "to\n", b1, "got\n", b2)
+               }
+
+               if err := validateBytes(b2); err != nil {
+                       t.Error(err, "len:", len(b2))
+               }
+       }
+
+       testString("/ip4/127.0.0.1/udp/1234", "047f000001910204d2")
+       testString("/ip4/127.0.0.1/tcp/4321", "047f0000010610e1")
+       testString("/ip4/127.0.0.1/udp/1234/ip4/127.0.0.1/tcp/4321", "047f000001910204d2047f0000010610e1")
+       testString("/onion/aaimaq4ygg2iegci:80", "bc030010c0439831b48218480050")
+       testString("/onion3/vww6ybal4bd7szmgncyruucpgfkqahzddi37ktceo3ah7ngmcopnpyyd:1234", "bd03adadec040be047f9658668b11a504f3155001f231a37f54c4476c07fb4cc139ed7e30304d2")
+       testString("/garlic64/jT~IyXaoauTni6N4517EG8mrFUKpy0IlgZh-EY9csMAk82Odatmzr~YTZy8Hv7u~wvkg75EFNOyqb~nAPg-khyp2TS~ObUz8WlqYAM2VlEzJ7wJB91P-cUlKF18zSzVoJFmsrcQHZCirSbWoOknS6iNmsGRh5KVZsBEfp1Dg3gwTipTRIx7Vl5Vy~1OSKQVjYiGZS9q8RL0MF~7xFiKxZDLbPxk0AK9TzGGqm~wMTI2HS0Gm4Ycy8LYPVmLvGonIBYndg2bJC7WLuF6tVjVquiokSVDKFwq70BCUU5AU-EvdOD5KEOAM7mPfw-gJUG4tm1TtvcobrObqoRnmhXPTBTN5H7qDD12AvlwFGnfAlBXjuP4xOUAISL5SRLiulrsMSiT4GcugSI80mF6sdB0zWRgL1yyvoVWeTBn1TqjO27alr95DGTluuSqrNAxgpQzCKEWAyzrQkBfo2avGAmmz2NaHaAvYbOg0QSJz1PLjv2jdPW~ofiQmrGWM1cd~1cCqAAAA",
+               "ca0383038d3fc8c976a86ae4e78ba378e75ec41bc9ab1542a9cb422581987e118f5cb0c024f3639d6ad9b3aff613672f07bfbbbfc2f920ef910534ecaa6ff9c03e0fa4872a764d2fce6d4cfc5a5a9800cd95944cc9ef0241f753fe71494a175f334b35682459acadc4076428ab49b5a83a49d2ea2366b06461e4a559b0111fa750e0de0c138a94d1231ed5979572ff53922905636221994bdabc44bd0c17fef11622b16432db3f193400af53cc61aa9bfc0c4c8d874b41a6e18732f0b60f5662ef1a89c80589dd8366c90bb58bb85ead56356aba2a244950ca170abbd01094539014f84bdd383e4a10e00cee63dfc3e809506e2d9b54edbdca1bace6eaa119e68573d30533791fba830f5d80be5c051a77c09415e3b8fe3139400848be5244b8ae96bb0c4a24f819cba0488f34985eac741d3359180bd72cafa1559e4c19f54ea8cedbb6a5afde4319396eb92aab340c60a50cc2284580cb3ad09017e8d9abc60269b3d8d687680bd86ce834412273d4f2e3bf68dd3d6fe87e2426ac658cd5c77fd5c0aa000000")
+}
+
+func TestBytesToString(t *testing.T) {
+
+       testString := func(s1 string, h string) {
+               t.Helper()
+               b, err := hex.DecodeString(h)
+               if err != nil {
+                       t.Error("failed to decode hex", h)
+               }
+
+               if err := validateBytes(b); err != nil {
+                       t.Error(err)
+               }
+
+               s2, err := bytesToString(b)
+               if err != nil {
+                       t.Error("failed to convert", b, err)
+               }
+
+               if s1 != s2 {
+                       t.Error("failed to convert", b, "to", s1, "got", s2)
+               }
+       }
+
+       testString("/ip4/127.0.0.1/udp/1234", "047f000001910204d2")
+       testString("/ip4/127.0.0.1/tcp/4321", "047f0000010610e1")
+       testString("/ip4/127.0.0.1/udp/1234/ip4/127.0.0.1/tcp/4321", "047f000001910204d2047f0000010610e1")
+       testString("/onion/aaimaq4ygg2iegci:80", "bc030010c0439831b48218480050")
+       testString("/onion3/vww6ybal4bd7szmgncyruucpgfkqahzddi37ktceo3ah7ngmcopnpyyd:1234", "bd03adadec040be047f9658668b11a504f3155001f231a37f54c4476c07fb4cc139ed7e30304d2")
+       testString("/garlic64/jT~IyXaoauTni6N4517EG8mrFUKpy0IlgZh-EY9csMAk82Odatmzr~YTZy8Hv7u~wvkg75EFNOyqb~nAPg-khyp2TS~ObUz8WlqYAM2VlEzJ7wJB91P-cUlKF18zSzVoJFmsrcQHZCirSbWoOknS6iNmsGRh5KVZsBEfp1Dg3gwTipTRIx7Vl5Vy~1OSKQVjYiGZS9q8RL0MF~7xFiKxZDLbPxk0AK9TzGGqm~wMTI2HS0Gm4Ycy8LYPVmLvGonIBYndg2bJC7WLuF6tVjVquiokSVDKFwq70BCUU5AU-EvdOD5KEOAM7mPfw-gJUG4tm1TtvcobrObqoRnmhXPTBTN5H7qDD12AvlwFGnfAlBXjuP4xOUAISL5SRLiulrsMSiT4GcugSI80mF6sdB0zWRgL1yyvoVWeTBn1TqjO27alr95DGTluuSqrNAxgpQzCKEWAyzrQkBfo2avGAmmz2NaHaAvYbOg0QSJz1PLjv2jdPW~ofiQmrGWM1cd~1cCqAAAA",
+               "ca0383038d3fc8c976a86ae4e78ba378e75ec41bc9ab1542a9cb422581987e118f5cb0c024f3639d6ad9b3aff613672f07bfbbbfc2f920ef910534ecaa6ff9c03e0fa4872a764d2fce6d4cfc5a5a9800cd95944cc9ef0241f753fe71494a175f334b35682459acadc4076428ab49b5a83a49d2ea2366b06461e4a559b0111fa750e0de0c138a94d1231ed5979572ff53922905636221994bdabc44bd0c17fef11622b16432db3f193400af53cc61aa9bfc0c4c8d874b41a6e18732f0b60f5662ef1a89c80589dd8366c90bb58bb85ead56356aba2a244950ca170abbd01094539014f84bdd383e4a10e00cee63dfc3e809506e2d9b54edbdca1bace6eaa119e68573d30533791fba830f5d80be5c051a77c09415e3b8fe3139400848be5244b8ae96bb0c4a24f819cba0488f34985eac741d3359180bd72cafa1559e4c19f54ea8cedbb6a5afde4319396eb92aab340c60a50cc2284580cb3ad09017e8d9abc60269b3d8d687680bd86ce834412273d4f2e3bf68dd3d6fe87e2426ac658cd5c77fd5c0aa000000")
+}
+
+func TestBytesSplitAndJoin(t *testing.T) {
+
+       testString := func(s string, res []string) {
+               m, err := NewMultiaddr(s)
+               if err != nil {
+                       t.Fatal("failed to convert", s, err)
+               }
+
+               split := Split(m)
+               if len(split) != len(res) {
+                       t.Error("not enough split components", split)
+                       return
+               }
+
+               for i, a := range split {
+                       if a.String() != res[i] {
+                               t.Errorf("split component failed: %s != %s", a, res[i])
+                       }
+               }
+
+               joined := Join(split...)
+               if !m.Equal(joined) {
+                       t.Errorf("joined components failed: %s != %s", m, joined)
+               }
+
+               for i, a := range split {
+                       if a.String() != res[i] {
+                               t.Errorf("split component failed: %s != %s", a, res[i])
+                       }
+               }
+       }
+
+       testString("/ip4/1.2.3.4/udp/1234", []string{"/ip4/1.2.3.4", "/udp/1234"})
+       testString("/ip4/1.2.3.4/tcp/1/ip4/2.3.4.5/udp/2",
+               []string{"/ip4/1.2.3.4", "/tcp/1", "/ip4/2.3.4.5", "/udp/2"})
+       testString("/ip4/1.2.3.4/utp/ip4/2.3.4.5/udp/2/udt",
+               []string{"/ip4/1.2.3.4", "/utp", "/ip4/2.3.4.5", "/udp/2", "/udt"})
+}
+
+func TestProtocols(t *testing.T) {
+       m, err := NewMultiaddr("/ip4/127.0.0.1/udp/1234")
+       if err != nil {
+               t.Error("failed to construct", "/ip4/127.0.0.1/udp/1234")
+       }
+
+       ps := m.Protocols()
+       if ps[0].Code != ProtocolWithName("ip4").Code {
+               t.Error(ps[0], ProtocolWithName("ip4"))
+               t.Error("failed to get ip4 protocol")
+       }
+
+       if ps[1].Code != ProtocolWithName("udp").Code {
+               t.Error(ps[1], ProtocolWithName("udp"))
+               t.Error("failed to get udp protocol")
+       }
+
+}
+
+func TestProtocolsWithString(t *testing.T) {
+       pwn := ProtocolWithName
+       good := map[string][]Protocol{
+               "/ip4":                    []Protocol{pwn("ip4")},
+               "/ip4/tcp":                []Protocol{pwn("ip4"), pwn("tcp")},
+               "ip4/tcp/udp/ip6":         []Protocol{pwn("ip4"), pwn("tcp"), pwn("udp"), pwn("ip6")},
+               "////////ip4/tcp":         []Protocol{pwn("ip4"), pwn("tcp")},
+               "ip4/udp/////////":        []Protocol{pwn("ip4"), pwn("udp")},
+               "////////ip4/tcp////////": []Protocol{pwn("ip4"), pwn("tcp")},
+       }
+
+       for s, ps1 := range good {
+               ps2, err := ProtocolsWithString(s)
+               if err != nil {
+                       t.Errorf("ProtocolsWithString(%s) should have succeeded", s)
+               }
+
+               for i, ps1p := range ps1 {
+                       ps2p := ps2[i]
+                       if ps1p.Code != ps2p.Code {
+                               t.Errorf("mismatch: %s != %s, %s", ps1p.Name, ps2p.Name, s)
+                       }
+               }
+       }
+
+       bad := []string{
+               "dsijafd",                           // bogus proto
+               "/ip4/tcp/fidosafoidsa",             // bogus proto
+               "////////ip4/tcp/21432141/////////", // bogus proto
+               "////////ip4///////tcp/////////",    // empty protos in between
+       }
+
+       for _, s := range bad {
+               if _, err := ProtocolsWithString(s); err == nil {
+                       t.Errorf("ProtocolsWithString(%s) should have failed", s)
+               }
+       }
+
+}
+
+func TestEncapsulate(t *testing.T) {
+       m, err := NewMultiaddr("/ip4/127.0.0.1/udp/1234")
+       if err != nil {
+               t.Error(err)
+       }
+
+       m2, err := NewMultiaddr("/udp/5678")
+       if err != nil {
+               t.Error(err)
+       }
+
+       b := m.Encapsulate(m2)
+       if s := b.String(); s != "/ip4/127.0.0.1/udp/1234/udp/5678" {
+               t.Error("encapsulate /ip4/127.0.0.1/udp/1234/udp/5678 failed.", s)
+       }
+
+       m3, _ := NewMultiaddr("/udp/5678")
+       c := b.Decapsulate(m3)
+       if s := c.String(); s != "/ip4/127.0.0.1/udp/1234" {
+               t.Error("decapsulate /udp failed.", "/ip4/127.0.0.1/udp/1234", s)
+       }
+
+       m4, _ := NewMultiaddr("/ip4/127.0.0.1")
+       d := c.Decapsulate(m4)
+       if s := d.String(); s != "" {
+               t.Error("decapsulate /ip4 failed.", "/", s)
+       }
+}
+
+func assertValueForProto(t *testing.T, a Multiaddr, p int, exp string) {
+       t.Logf("checking for %s in %s", ProtocolWithCode(p).Name, a)
+       fv, err := a.ValueForProtocol(p)
+       if err != nil {
+               t.Fatal(err)
+       }
+
+       if fv != exp {
+               t.Fatalf("expected %q for %d in %s, but got %q instead", exp, p, a, fv)
+       }
+}
+
+func TestGetValue(t *testing.T) {
+       a := newMultiaddr(t, "/ip4/127.0.0.1/utp/tcp/5555/udp/1234/utp/ipfs/QmbHVEEepCi7rn7VL7Exxpd2Ci9NNB6ifvqwhsrbRMgQFP")
+       assertValueForProto(t, a, P_IP4, "127.0.0.1")
+       assertValueForProto(t, a, P_UTP, "")
+       assertValueForProto(t, a, P_TCP, "5555")
+       assertValueForProto(t, a, P_UDP, "1234")
+       assertValueForProto(t, a, P_IPFS, "QmbHVEEepCi7rn7VL7Exxpd2Ci9NNB6ifvqwhsrbRMgQFP")
+       assertValueForProto(t, a, P_P2P, "QmbHVEEepCi7rn7VL7Exxpd2Ci9NNB6ifvqwhsrbRMgQFP")
+
+       _, err := a.ValueForProtocol(P_IP6)
+       switch err {
+       case ErrProtocolNotFound:
+               break
+       case nil:
+               t.Fatal("expected value lookup to fail")
+       default:
+               t.Fatalf("expected ErrProtocolNotFound but got: %s", err)
+       }
+
+       a = newMultiaddr(t, "/ip4/0.0.0.0") // only one addr
+       assertValueForProto(t, a, P_IP4, "0.0.0.0")
+
+       a = newMultiaddr(t, "/ip4/0.0.0.0/ip4/0.0.0.0/ip4/0.0.0.0") // same sub-addr
+       assertValueForProto(t, a, P_IP4, "0.0.0.0")
+
+       a = newMultiaddr(t, "/ip4/0.0.0.0/udp/12345/utp") // ending in a no-value one.
+       assertValueForProto(t, a, P_IP4, "0.0.0.0")
+       assertValueForProto(t, a, P_UDP, "12345")
+       assertValueForProto(t, a, P_UTP, "")
+
+       a = newMultiaddr(t, "/ip4/0.0.0.0/unix/a/b/c/d") // ending in a path one.
+       assertValueForProto(t, a, P_IP4, "0.0.0.0")
+       assertValueForProto(t, a, P_UNIX, "/a/b/c/d")
+}
+
+func TestFuzzBytes(t *testing.T) {
+       rand.Seed(time.Now().UnixNano())
+       // Bump up these numbers if you want to stress this
+       buf := make([]byte, 256)
+       for i := 0; i < 2000; i++ {
+               l := rand.Intn(len(buf))
+               rand.Read(buf[:l])
+
+               // just checking that it doesnt panic
+               ma, err := NewMultiaddrBytes(buf[:l])
+               if err == nil {
+                       // for any valid multiaddrs, make sure these calls don't panic
+                       _ = ma.String()
+                       ma.Protocols()
+               }
+       }
+}
+
+func randMaddrString() string {
+       good_corpus := []string{"tcp", "ip", "udp", "ipfs", "0.0.0.0", "127.0.0.1", "12345", "QmbHVEEepCi7rn7VL7Exxpd2Ci9NNB6ifvqwhsrbRMgQFP"}
+
+       size := rand.Intn(256)
+       parts := make([]string, 0, size)
+       for i := 0; i < size; i++ {
+               switch rand.Intn(5) {
+               case 0, 1, 2:
+                       parts = append(parts, good_corpus[rand.Intn(len(good_corpus))])
+               default:
+                       badbuf := make([]byte, rand.Intn(256))
+                       rand.Read(badbuf)
+                       parts = append(parts, string(badbuf))
+               }
+       }
+
+       return "/" + strings.Join(parts, "/")
+}
+
+func TestFuzzString(t *testing.T) {
+       rand.Seed(time.Now().UnixNano())
+       // Bump up these numbers if you want to stress this
+       for i := 0; i < 2000; i++ {
+
+               // just checking that it doesnt panic
+               ma, err := NewMultiaddr(randMaddrString())
+               if err == nil {
+                       // for any valid multiaddrs, make sure these calls don't panic
+                       _ = ma.String()
+                       ma.Protocols()
+               }
+       }
+}
+
+func TestBinaryRepresentation(t *testing.T) {
+       expected := []byte{0x4, 0x7f, 0x0, 0x0, 0x1, 0x91, 0x2, 0x4, 0xd2}
+       ma, err := NewMultiaddr("/ip4/127.0.0.1/udp/1234")
+       if err != nil {
+               t.Error(err)
+       }
+
+       if !bytes.Equal(ma.Bytes(), expected) {
+               t.Errorf("expected %x, got %x", expected, ma.Bytes())
+       }
+}
+
+func TestRoundTrip(t *testing.T) {
+       for _, s := range []string{
+               "/unix/a/b/c/d",
+               "/ip6/::ffff:127.0.0.1/tcp/111",
+               "/ip4/127.0.0.1/tcp/123",
+               "/ip4/127.0.0.1/udp/123",
+               "/ip4/127.0.0.1/udp/123/ip6/::",
+               "/ipfs/QmbHVEEepCi7rn7VL7Exxpd2Ci9NNB6ifvqwhsrbRMgQFP",
+               "/ipfs/QmbHVEEepCi7rn7VL7Exxpd2Ci9NNB6ifvqwhsrbRMgQFP/unix/a/b/c",
+       } {
+               ma, err := NewMultiaddr(s)
+               if err != nil {
+                       t.Errorf("error when parsing %q: %s", s, err)
+                       continue
+               }
+               if ma.String() != s {
+                       t.Errorf("failed to round trip %q", s)
+               }
+       }
+}
+
+// XXX: Change this test when we switch to /p2p by default.
+func TestIPFSvP2P(t *testing.T) {
+       var (
+               p2pAddr  = "/p2p/QmbHVEEepCi7rn7VL7Exxpd2Ci9NNB6ifvqwhsrbRMgQFP"
+               ipfsAddr = "/ipfs/QmbHVEEepCi7rn7VL7Exxpd2Ci9NNB6ifvqwhsrbRMgQFP"
+       )
+
+       for _, s := range []string{p2pAddr, ipfsAddr} {
+               ma, err := NewMultiaddr(s)
+               if err != nil {
+                       t.Errorf("error when parsing %q: %s", s, err)
+               }
+               if ma.String() != ipfsAddr {
+                       t.Errorf("expected %q, got %q", ipfsAddr, ma.String())
+               }
+       }
+}
+
+func TestInvalidP2PAddr(t *testing.T) {
+       badAddr := "a503221221c05877cbae039d70a5e600ea02c6f9f2942439285c9e344e26f8d280c850fad6"
+       bts, err := hex.DecodeString(badAddr)
+       if err != nil {
+               t.Fatal(err)
+       }
+       ma, err := NewMultiaddrBytes(bts)
+       if err == nil {
+               t.Error("should have failed")
+               // Check for panic
+               _ = ma.String()
+       }
+}
+
+func TestZone(t *testing.T) {
+       ip6String := "/ip6zone/eth0/ip6/::1"
+       ip6Bytes := []byte{
+               0x2a, 4,
+               'e', 't', 'h', '0',
+               0x29,
+               0, 0, 0, 0,
+               0, 0, 0, 0,
+               0, 0, 0, 0,
+               0, 0, 0, 1,
+       }
+
+       ma, err := NewMultiaddr(ip6String)
+       if err != nil {
+               t.Error(err)
+       }
+       if !bytes.Equal(ma.Bytes(), ip6Bytes) {
+               t.Errorf("expected %x, got %x", ip6Bytes, ma.Bytes())
+       }
+
+       ma2, err2 := NewMultiaddrBytes(ip6Bytes)
+       if err2 != nil {
+               t.Error(err)
+       }
+       if ma2.String() != ip6String {
+               t.Errorf("expected %s, got %s", ip6String, ma2.String())
+       }
+}

diff --git a/vendor/github.com/multiformats/go-multiaddr/package.json b/vendor/github.com/multiformats/go-multiaddr/package.json
new file mode 100644 (file)
index 0000000..3d89c1d
--- /dev/null
+++ b/vendor/github.com/multiformats/go-multiaddr/package.json
@@ -0,0 +1,23 @@
+{
+  "author": "multiformats",
+  "bugs": {
+    "url": "https://github.com/multiformats/go-multiaddr/issues"
+  },
+  "gx": {
+    "dvcsimport": "github.com/multiformats/go-multiaddr"
+  },
+  "gxDependencies": [
+    {
+      "hash": "QmerPMzPk1mJVowm8KgmoknWa4yCYvvugMPsgWmDNUvDLW",
+      "name": "go-multihash",
+      "version": "1.0.9"
+    }
+  ],
+  "gxVersion": "0.9.0",
+  "language": "go",
+  "license": "MIT",
+  "name": "go-multiaddr",
+  "releaseCmd": "git commit -a -m \"gx publish $VERSION\"",
+  "version": "1.4.0"
+}
+

diff --git a/vendor/github.com/multiformats/go-multiaddr/protocol.go b/vendor/github.com/multiformats/go-multiaddr/protocol.go
new file mode 100644 (file)
index 0000000..f9d7036
--- /dev/null
+++ b/vendor/github.com/multiformats/go-multiaddr/protocol.go
@@ -0,0 +1,129 @@
+package multiaddr
+
+import (
+       "fmt"
+       "strings"
+)
+
+// These are special sizes
+const (
+       LengthPrefixedVarSize = -1
+)
+
+// Protocol is a Multiaddr protocol description structure.
+type Protocol struct {
+       // Name is the string representation of the protocol code. E.g., ip4,
+       // ip6, tcp, udp, etc.
+       Name string
+
+       // Code is the protocol's multicodec (a normal, non-varint number).
+       Code int
+
+       // VCode is a precomputed varint encoded version of Code.
+       VCode []byte
+
+       // Size is the size of the argument to this protocol.
+       //
+       // * Size == 0 means this protocol takes no argument.
+       // * Size >  0 means this protocol takes a constant sized argument.
+       // * Size <  0 means this protocol takes a variable length, varint
+       //             prefixed argument.
+       Size int // a size of -1 indicates a length-prefixed variable size
+
+       // Path indicates a path protocol (e.g., unix). When parsing multiaddr
+       // strings, path protocols consume the remainder of the address instead
+       // of stopping at the next forward slash.
+       //
+       // Size must be LengthPrefixedVarSize.
+       Path bool
+
+       // Transcoder converts between the byte representation and the string
+       // representation of this protocol's argument (if any).
+       //
+       // This should only be non-nil if Size != 0
+       Transcoder Transcoder
+}
+
+var protocolsByName = map[string]Protocol{}
+var protocolsByCode = map[int]Protocol{}
+
+// Protocols is the list of multiaddr protocols supported by this module.
+var Protocols = []Protocol{}
+
+// SwapToP2pMultiaddrs is a function to make the transition from /ipfs/...
+// multiaddrs to /p2p/... multiaddrs easier
+// The first stage of the rollout is to ship this package to all users so
+// that all users of multiaddr can parse both /ipfs/ and /p2p/ multiaddrs
+// as the same code (P_P2P). During this stage of the rollout, all addresses
+// with P_P2P will continue printing as /ipfs/, so that older clients without
+// the new parsing code won't break.
+// Once the network has adopted the new parsing code broadly enough, users of
+// multiaddr can add a call to this method to an init function in their codebase.
+// This will cause any P_P2P multiaddr to print out as /p2p/ instead of /ipfs/.
+// Note that the binary serialization of this multiaddr does not change at any
+// point. This means that this code is not a breaking network change at any point
+func SwapToP2pMultiaddrs() {
+       for i := range Protocols {
+               if Protocols[i].Code == P_P2P {
+                       Protocols[i].Name = "p2p"
+                       break
+               }
+       }
+
+       protoP2P.Name = "p2p"
+
+       protocolsByName["ipfs"] = protoP2P
+       protocolsByName["p2p"] = protoP2P
+       protocolsByCode[protoP2P.Code] = protoP2P
+}
+
+func AddProtocol(p Protocol) error {
+       if _, ok := protocolsByName[p.Name]; ok {
+               return fmt.Errorf("protocol by the name %q already exists", p.Name)
+       }
+
+       if _, ok := protocolsByCode[p.Code]; ok {
+               return fmt.Errorf("protocol code %d already taken by %q", p.Code, p.Code)
+       }
+
+       if p.Size != 0 && p.Transcoder == nil {
+               return fmt.Errorf("protocols with arguments must define transcoders")
+       }
+       if p.Path && p.Size >= 0 {
+               return fmt.Errorf("path protocols must have variable-length sizes")
+       }
+
+       Protocols = append(Protocols, p)
+       protocolsByName[p.Name] = p
+       protocolsByCode[p.Code] = p
+       return nil
+}
+
+// ProtocolWithName returns the Protocol description with given string name.
+func ProtocolWithName(s string) Protocol {
+       return protocolsByName[s]
+}
+
+// ProtocolWithCode returns the Protocol description with given protocol code.
+func ProtocolWithCode(c int) Protocol {
+       return protocolsByCode[c]
+}
+
+// ProtocolsWithString returns a slice of protocols matching given string.
+func ProtocolsWithString(s string) ([]Protocol, error) {
+       s = strings.Trim(s, "/")
+       sp := strings.Split(s, "/")
+       if len(sp) == 0 {
+               return nil, nil
+       }
+
+       t := make([]Protocol, len(sp))
+       for i, name := range sp {
+               p := ProtocolWithName(name)
+               if p.Code == 0 {
+                       return nil, fmt.Errorf("no protocol with name: %s", name)
+               }
+               t[i] = p
+       }
+       return t, nil
+}

diff --git a/vendor/github.com/multiformats/go-multiaddr/protocols.go b/vendor/github.com/multiformats/go-multiaddr/protocols.go
new file mode 100644 (file)
index 0000000..c822030
--- /dev/null
+++ b/vendor/github.com/multiformats/go-multiaddr/protocols.go
@@ -0,0 +1,183 @@
+package multiaddr
+
+// You **MUST** register your multicodecs with
+// https://github.com/multiformats/multicodec before adding them here.
+//
+// TODO: Use a single source of truth for all multicodecs instead of
+// distributing them like this...
+const (
+       P_IP4               = 0x0004
+       P_TCP               = 0x0006
+       P_UDP               = 0x0111
+       P_DCCP              = 0x0021
+       P_IP6               = 0x0029
+       P_IP6ZONE           = 0x002A
+       P_QUIC              = 0x01CC
+       P_SCTP              = 0x0084
+       P_UDT               = 0x012D
+       P_UTP               = 0x012E
+       P_UNIX              = 0x0190
+       P_P2P               = 0x01A5
+       P_IPFS              = 0x01A5 // alias for backwards compatability
+       P_HTTP              = 0x01E0
+       P_HTTPS             = 0x01BB
+       P_ONION             = 0x01BC // also for backwards compatibility
+       P_ONION3            = 0x01BD
+       P_GARLIC64          = 0x01CA
+       P_P2P_WEBRTC_DIRECT = 0x0114
+)
+
+var (
+       protoIP4 = Protocol{
+               Name:       "ip4",
+               Code:       P_IP4,
+               VCode:      CodeToVarint(P_IP4),
+               Size:       32,
+               Path:       false,
+               Transcoder: TranscoderIP4,
+       }
+       protoTCP = Protocol{
+               Name:       "tcp",
+               Code:       P_TCP,
+               VCode:      CodeToVarint(P_TCP),
+               Size:       16,
+               Path:       false,
+               Transcoder: TranscoderPort,
+       }
+       protoUDP = Protocol{
+               Name:       "udp",
+               Code:       P_UDP,
+               VCode:      CodeToVarint(P_UDP),
+               Size:       16,
+               Path:       false,
+               Transcoder: TranscoderPort,
+       }
+       protoDCCP = Protocol{
+               Name:       "dccp",
+               Code:       P_DCCP,
+               VCode:      CodeToVarint(P_DCCP),
+               Size:       16,
+               Path:       false,
+               Transcoder: TranscoderPort,
+       }
+       protoIP6 = Protocol{
+               Name:       "ip6",
+               Code:       P_IP6,
+               VCode:      CodeToVarint(P_IP6),
+               Size:       128,
+               Transcoder: TranscoderIP6,
+       }
+       // these require varint
+       protoIP6ZONE = Protocol{
+               Name:       "ip6zone",
+               Code:       P_IP6ZONE,
+               VCode:      CodeToVarint(P_IP6ZONE),
+               Size:       LengthPrefixedVarSize,
+               Path:       false,
+               Transcoder: TranscoderIP6Zone,
+       }
+       protoSCTP = Protocol{
+               Name:       "sctp",
+               Code:       P_SCTP,
+               VCode:      CodeToVarint(P_SCTP),
+               Size:       16,
+               Transcoder: TranscoderPort,
+       }
+       protoONION2 = Protocol{
+               Name:       "onion",
+               Code:       P_ONION,
+               VCode:      CodeToVarint(P_ONION),
+               Size:       96,
+               Transcoder: TranscoderOnion,
+       }
+       protoONION3 = Protocol{
+               Name:       "onion3",
+               Code:       P_ONION3,
+               VCode:      CodeToVarint(P_ONION3),
+               Size:       296,
+               Transcoder: TranscoderOnion3,
+       }
+       protoGARLIC64 = Protocol{
+               Name:       "garlic64",
+               Code:       P_GARLIC64,
+               VCode:      CodeToVarint(P_GARLIC64),
+               Size:       LengthPrefixedVarSize,
+               Transcoder: TranscoderGarlic64,
+       }
+       protoUTP = Protocol{
+               Name:  "utp",
+               Code:  P_UTP,
+               VCode: CodeToVarint(P_UTP),
+       }
+       protoUDT = Protocol{
+               Name:  "udt",
+               Code:  P_UDT,
+               VCode: CodeToVarint(P_UDT),
+       }
+       protoQUIC = Protocol{
+               Name:  "quic",
+               Code:  P_QUIC,
+               VCode: CodeToVarint(P_QUIC),
+       }
+       protoHTTP = Protocol{
+               Name:  "http",
+               Code:  P_HTTP,
+               VCode: CodeToVarint(P_HTTP),
+       }
+       protoHTTPS = Protocol{
+               Name:  "https",
+               Code:  P_HTTPS,
+               VCode: CodeToVarint(P_HTTPS),
+       }
+       protoP2P = Protocol{
+               Name:       "ipfs",
+               Code:       P_P2P,
+               VCode:      CodeToVarint(P_P2P),
+               Size:       LengthPrefixedVarSize,
+               Transcoder: TranscoderP2P,
+       }
+       protoUNIX = Protocol{
+               Name:       "unix",
+               Code:       P_UNIX,
+               VCode:      CodeToVarint(P_UNIX),
+               Size:       LengthPrefixedVarSize,
+               Path:       true,
+               Transcoder: TranscoderUnix,
+       }
+       protoP2P_WEBRTC_DIRECT = Protocol{
+               Name:  "p2p-webrtc-direct",
+               Code:  P_P2P_WEBRTC_DIRECT,
+               VCode: CodeToVarint(P_P2P_WEBRTC_DIRECT),
+       }
+)
+
+func init() {
+       for _, p := range []Protocol{
+               protoIP4,
+               protoTCP,
+               protoUDP,
+               protoDCCP,
+               protoIP6,
+               protoIP6ZONE,
+               protoSCTP,
+               protoONION2,
+               protoONION3,
+               protoGARLIC64,
+               protoUTP,
+               protoUDT,
+               protoQUIC,
+               protoHTTP,
+               protoHTTPS,
+               protoP2P,
+               protoUNIX,
+               protoP2P_WEBRTC_DIRECT,
+       } {
+               if err := AddProtocol(p); err != nil {
+                       panic(err)
+               }
+       }
+
+       // explicitly set both of these
+       protocolsByName["p2p"] = protoP2P
+       protocolsByName["ipfs"] = protoP2P
+}

diff --git a/vendor/github.com/multiformats/go-multiaddr/transcoders.go b/vendor/github.com/multiformats/go-multiaddr/transcoders.go
new file mode 100644 (file)
index 0000000..cca2514
--- /dev/null
+++ b/vendor/github.com/multiformats/go-multiaddr/transcoders.go
@@ -0,0 +1,280 @@
+package multiaddr
+
+import (
+       "bytes"
+       "encoding/base32"
+       "encoding/base64"
+       "encoding/binary"
+       "fmt"
+       "net"
+       "strconv"
+       "strings"
+
+       mh "github.com/multiformats/go-multihash"
+)
+
+type Transcoder interface {
+       StringToBytes(string) ([]byte, error)
+       BytesToString([]byte) (string, error)
+       ValidateBytes([]byte) error
+}
+
+func NewTranscoderFromFunctions(
+       s2b func(string) ([]byte, error),
+       b2s func([]byte) (string, error),
+       val func([]byte) error,
+) Transcoder {
+       return twrp{s2b, b2s, val}
+}
+
+type twrp struct {
+       strtobyte func(string) ([]byte, error)
+       bytetostr func([]byte) (string, error)
+       validbyte func([]byte) error
+}
+
+func (t twrp) StringToBytes(s string) ([]byte, error) {
+       return t.strtobyte(s)
+}
+func (t twrp) BytesToString(b []byte) (string, error) {
+       return t.bytetostr(b)
+}
+
+func (t twrp) ValidateBytes(b []byte) error {
+       if t.validbyte == nil {
+               return nil
+       }
+       return t.validbyte(b)
+}
+
+var TranscoderIP4 = NewTranscoderFromFunctions(ip4StB, ip4BtS, nil)
+var TranscoderIP6 = NewTranscoderFromFunctions(ip6StB, ip6BtS, nil)
+var TranscoderIP6Zone = NewTranscoderFromFunctions(ip6zoneStB, ip6zoneBtS, ip6zoneVal)
+
+func ip4StB(s string) ([]byte, error) {
+       i := net.ParseIP(s).To4()
+       if i == nil {
+               return nil, fmt.Errorf("failed to parse ip4 addr: %s", s)
+       }
+       return i, nil
+}
+
+func ip6zoneStB(s string) ([]byte, error) {
+       if len(s) == 0 {
+               return nil, fmt.Errorf("empty ip6zone")
+       }
+       return []byte(s), nil
+}
+
+func ip6zoneBtS(b []byte) (string, error) {
+       if len(b) == 0 {
+               return "", fmt.Errorf("invalid length (should be > 0)")
+       }
+       return string(b), nil
+}
+
+func ip6zoneVal(b []byte) error {
+       if len(b) == 0 {
+               return fmt.Errorf("invalid length (should be > 0)")
+       }
+       // Not supported as this would break multiaddrs.
+       if bytes.IndexByte(b, '/') >= 0 {
+               return fmt.Errorf("IPv6 zone ID contains '/': %s", string(b))
+       }
+       return nil
+}
+
+func ip6StB(s string) ([]byte, error) {
+       i := net.ParseIP(s).To16()
+       if i == nil {
+               return nil, fmt.Errorf("failed to parse ip6 addr: %s", s)
+       }
+       return i, nil
+}
+
+func ip6BtS(b []byte) (string, error) {
+       ip := net.IP(b)
+       if ip4 := ip.To4(); ip4 != nil {
+               // Go fails to prepend the `::ffff:` part.
+               return "::ffff:" + ip4.String(), nil
+       }
+       return ip.String(), nil
+}
+
+func ip4BtS(b []byte) (string, error) {
+       return net.IP(b).String(), nil
+}
+
+var TranscoderPort = NewTranscoderFromFunctions(portStB, portBtS, nil)
+
+func portStB(s string) ([]byte, error) {
+       i, err := strconv.Atoi(s)
+       if err != nil {
+               return nil, fmt.Errorf("failed to parse port addr: %s", err)
+       }
+       if i >= 65536 {
+               return nil, fmt.Errorf("failed to parse port addr: %s", "greater than 65536")
+       }
+       b := make([]byte, 2)
+       binary.BigEndian.PutUint16(b, uint16(i))
+       return b, nil
+}
+
+func portBtS(b []byte) (string, error) {
+       i := binary.BigEndian.Uint16(b)
+       return strconv.Itoa(int(i)), nil
+}
+
+var TranscoderOnion = NewTranscoderFromFunctions(onionStB, onionBtS, nil)
+
+func onionStB(s string) ([]byte, error) {
+       addr := strings.Split(s, ":")
+       if len(addr) != 2 {
+               return nil, fmt.Errorf("failed to parse onion addr: %s does not contain a port number.", s)
+       }
+
+       // onion address without the ".onion" substring
+       if len(addr[0]) != 16 {
+               return nil, fmt.Errorf("failed to parse onion addr: %s not a Tor onion address.", s)
+       }
+       onionHostBytes, err := base32.StdEncoding.DecodeString(strings.ToUpper(addr[0]))
+       if err != nil {
+               return nil, fmt.Errorf("failed to decode base32 onion addr: %s %s", s, err)
+       }
+
+       // onion port number
+       i, err := strconv.Atoi(addr[1])
+       if err != nil {
+               return nil, fmt.Errorf("failed to parse onion addr: %s", err)
+       }
+       if i >= 65536 {
+               return nil, fmt.Errorf("failed to parse onion addr: %s", "port greater than 65536")
+       }
+       if i < 1 {
+               return nil, fmt.Errorf("failed to parse onion addr: %s", "port less than 1")
+       }
+
+       onionPortBytes := make([]byte, 2)
+       binary.BigEndian.PutUint16(onionPortBytes, uint16(i))
+       bytes := []byte{}
+       bytes = append(bytes, onionHostBytes...)
+       bytes = append(bytes, onionPortBytes...)
+       return bytes, nil
+}
+
+func onionBtS(b []byte) (string, error) {
+       addr := strings.ToLower(base32.StdEncoding.EncodeToString(b[0:10]))
+       port := binary.BigEndian.Uint16(b[10:12])
+       return addr + ":" + strconv.Itoa(int(port)), nil
+}
+
+var TranscoderOnion3 = NewTranscoderFromFunctions(onion3StB, onion3BtS, nil)
+
+func onion3StB(s string) ([]byte, error) {
+       addr := strings.Split(s, ":")
+       if len(addr) != 2 {
+               return nil, fmt.Errorf("failed to parse onion addr: %s does not contain a port number.", s)
+       }
+
+       // onion address without the ".onion" substring
+       if len(addr[0]) != 56 {
+               return nil, fmt.Errorf("failed to parse onion addr: %s not a Tor onionv3 address. len == %d", s, len(addr[0]))
+       }
+       onionHostBytes, err := base32.StdEncoding.DecodeString(strings.ToUpper(addr[0]))
+       if err != nil {
+               return nil, fmt.Errorf("failed to decode base32 onion addr: %s %s", s, err)
+       }
+
+       // onion port number
+       i, err := strconv.Atoi(addr[1])
+       if err != nil {
+               return nil, fmt.Errorf("failed to parse onion addr: %s", err)
+       }
+       if i >= 65536 {
+               return nil, fmt.Errorf("failed to parse onion addr: %s", "port greater than 65536")
+       }
+       if i < 1 {
+               return nil, fmt.Errorf("failed to parse onion addr: %s", "port less than 1")
+       }
+
+       onionPortBytes := make([]byte, 2)
+       binary.BigEndian.PutUint16(onionPortBytes, uint16(i))
+       bytes := []byte{}
+       bytes = append(bytes, onionHostBytes[0:35]...)
+       bytes = append(bytes, onionPortBytes...)
+       return bytes, nil
+}
+
+func onion3BtS(b []byte) (string, error) {
+       addr := strings.ToLower(base32.StdEncoding.EncodeToString(b[0:35]))
+       port := binary.BigEndian.Uint16(b[35:37])
+       str := addr + ":" + strconv.Itoa(int(port))
+       return str, nil
+}
+
+var TranscoderGarlic64 = NewTranscoderFromFunctions(garlic64StB, garlic64BtS, garlicValidate)
+
+// i2p uses an alternate character set for base64 addresses. This returns an appropriate encoder.
+var garlicBase64Encoding = base64.NewEncoding("ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789-~")
+
+func garlic64StB(s string) ([]byte, error) {
+       // i2p base64 address
+       if len(s) < 516 || len(s) > 616 {
+               return nil, fmt.Errorf("failed to parse garlic addr: %s not an i2p base64 address. len: %d\n", s, len(s))
+       }
+       garlicHostBytes, err := garlicBase64Encoding.DecodeString(s)
+       if err != nil {
+               return nil, fmt.Errorf("failed to decode base64 i2p addr: %s %s", s, err)
+       }
+
+       return garlicHostBytes, nil
+}
+
+func garlic64BtS(b []byte) (string, error) {
+       if len(b) < 386 {
+               return "", fmt.Errorf("failed to validate garlic addr: %s not an i2p base64 address. len: %d\n", b, len(b))
+       }
+       addr := garlicBase64Encoding.EncodeToString(b)
+       return addr, nil
+}
+
+func garlicValidate(b []byte) error {
+       if len(b) < 386 {
+               return fmt.Errorf("failed to validate garlic addr: %s not an i2p base64 address. len: %d\n", b, len(b))
+       }
+       return nil
+}
+
+var TranscoderP2P = NewTranscoderFromFunctions(p2pStB, p2pBtS, p2pVal)
+
+func p2pStB(s string) ([]byte, error) {
+       // the address is a varint prefixed multihash string representation
+       m, err := mh.FromB58String(s)
+       if err != nil {
+               return nil, fmt.Errorf("failed to parse p2p addr: %s %s", s, err)
+       }
+       return m, nil
+}
+
+func p2pVal(b []byte) error {
+       _, err := mh.Cast(b)
+       return err
+}
+
+func p2pBtS(b []byte) (string, error) {
+       m, err := mh.Cast(b)
+       if err != nil {
+               return "", err
+       }
+       return m.B58String(), nil
+}
+
+var TranscoderUnix = NewTranscoderFromFunctions(unixStB, unixBtS, nil)
+
+func unixStB(s string) ([]byte, error) {
+       return []byte(s), nil
+}
+
+func unixBtS(b []byte) (string, error) {
+       return string(b), nil
+}

diff --git a/vendor/github.com/multiformats/go-multiaddr/util.go b/vendor/github.com/multiformats/go-multiaddr/util.go
new file mode 100644 (file)
index 0000000..d1044da
--- /dev/null
+++ b/vendor/github.com/multiformats/go-multiaddr/util.go
@@ -0,0 +1,180 @@
+package multiaddr
+
+import "fmt"
+
+// Split returns the sub-address portions of a multiaddr.
+func Split(m Multiaddr) []Multiaddr {
+       if _, ok := m.(*Component); ok {
+               return []Multiaddr{m}
+       }
+       var addrs []Multiaddr
+       ForEach(m, func(c Component) bool {
+               addrs = append(addrs, &c)
+               return true
+       })
+       return addrs
+}
+
+// Join returns a combination of addresses.
+func Join(ms ...Multiaddr) Multiaddr {
+       switch len(ms) {
+       case 0:
+               // empty multiaddr, unfortunately, we have callers that rely on
+               // this contract.
+               return multiaddr{}
+       case 1:
+               return ms[0]
+       }
+
+       length := 0
+       bs := make([][]byte, len(ms))
+       for i, m := range ms {
+               bs[i] = m.Bytes()
+               length += len(bs[i])
+       }
+
+       bidx := 0
+       b := make([]byte, length)
+       for _, mb := range bs {
+               bidx += copy(b[bidx:], mb)
+       }
+       return multiaddr{bytes: b}
+}
+
+// Cast re-casts a byte slice as a multiaddr. will panic if it fails to parse.
+func Cast(b []byte) Multiaddr {
+       m, err := NewMultiaddrBytes(b)
+       if err != nil {
+               panic(fmt.Errorf("multiaddr failed to parse: %s", err))
+       }
+       return m
+}
+
+// StringCast like Cast, but parses a string. Will also panic if it fails to parse.
+func StringCast(s string) Multiaddr {
+       m, err := NewMultiaddr(s)
+       if err != nil {
+               panic(fmt.Errorf("multiaddr failed to parse: %s", err))
+       }
+       return m
+}
+
+// SplitFirst returns the first component and the rest of the multiaddr.
+func SplitFirst(m Multiaddr) (*Component, Multiaddr) {
+       // Shortcut if we already have a component
+       if c, ok := m.(*Component); ok {
+               return c, nil
+       }
+
+       b := m.Bytes()
+       if len(b) == 0 {
+               return nil, nil
+       }
+       n, c, err := readComponent(b)
+       if err != nil {
+               panic(err)
+       }
+       if len(b) == n {
+               return &c, nil
+       }
+       return &c, multiaddr{b[n:]}
+}
+
+// SplitLast returns the rest of the multiaddr and the last component.
+func SplitLast(m Multiaddr) (Multiaddr, *Component) {
+       // Shortcut if we already have a component
+       if c, ok := m.(*Component); ok {
+               return nil, c
+       }
+
+       b := m.Bytes()
+       if len(b) == 0 {
+               return nil, nil
+       }
+
+       var (
+               c      Component
+               err    error
+               offset int
+       )
+       for {
+               var n int
+               n, c, err = readComponent(b[offset:])
+               if err != nil {
+                       panic(err)
+               }
+               if len(b) == n+offset {
+                       // Reached end
+                       if offset == 0 {
+                               // Only one component
+                               return nil, &c
+                       }
+                       return multiaddr{b[:offset]}, &c
+               }
+               offset += n
+       }
+}
+
+// SplitFunc splits the multiaddr when the callback first returns true. The
+// component on which the callback first returns will be included in the
+// *second* multiaddr.
+func SplitFunc(m Multiaddr, cb func(Component) bool) (Multiaddr, Multiaddr) {
+       // Shortcut if we already have a component
+       if c, ok := m.(*Component); ok {
+               if cb(*c) {
+                       return nil, m
+               }
+               return m, nil
+       }
+       b := m.Bytes()
+       if len(b) == 0 {
+               return nil, nil
+       }
+       var (
+               c      Component
+               err    error
+               offset int
+       )
+       for offset < len(b) {
+               var n int
+               n, c, err = readComponent(b[offset:])
+               if err != nil {
+                       panic(err)
+               }
+               if cb(c) {
+                       break
+               }
+               offset += n
+       }
+       switch offset {
+       case 0:
+               return nil, m
+       case len(b):
+               return m, nil
+       default:
+               return multiaddr{b[:offset]}, multiaddr{b[offset:]}
+       }
+}
+
+// ForEach walks over the multiaddr, component by component.
+//
+// This function iterates over components *by value* to avoid allocating.
+func ForEach(m Multiaddr, cb func(c Component) bool) {
+       // Shortcut if we already have a component
+       if c, ok := m.(*Component); ok {
+               cb(*c)
+               return
+       }
+
+       b := m.Bytes()
+       for len(b) > 0 {
+               n, c, err := readComponent(b)
+               if err != nil {
+                       panic(err)
+               }
+               if !cb(c) {
+                       return
+               }
+               b = b[n:]
+       }
+}

diff --git a/vendor/github.com/multiformats/go-multiaddr/util_test.go b/vendor/github.com/multiformats/go-multiaddr/util_test.go
new file mode 100644 (file)
index 0000000..a0ee55c
--- /dev/null
+++ b/vendor/github.com/multiformats/go-multiaddr/util_test.go
@@ -0,0 +1,143 @@
+package multiaddr
+
+import (
+       "strings"
+       "testing"
+)
+
+func TestSplitFirstLast(t *testing.T) {
+       ipStr := "/ip4/0.0.0.0"
+       tcpStr := "/tcp/123"
+       quicStr := "/quic"
+       ipfsStr := "/ipfs/QmPSQnBKM9g7BaUcZCvswUJVscQ1ipjmwxN5PXCjkp9EQ7"
+
+       for _, x := range [][]string{
+               []string{ipStr, tcpStr, quicStr, ipfsStr},
+               []string{ipStr, tcpStr, ipfsStr},
+               []string{ipStr, tcpStr},
+               []string{ipStr},
+               []string{},
+       } {
+               addr := StringCast(strings.Join(x, ""))
+               head, tail := SplitFirst(addr)
+               rest, last := SplitLast(addr)
+               if len(x) == 0 {
+                       if head != nil {
+                               t.Error("expected head to be nil")
+                       }
+                       if tail != nil {
+                               t.Error("expected tail to be nil")
+                       }
+                       if rest != nil {
+                               t.Error("expected rest to be nil")
+                       }
+                       if last != nil {
+                               t.Error("expected last to be nil")
+                       }
+                       continue
+               }
+               if !head.Equal(StringCast(x[0])) {
+                       t.Errorf("expected %s to be %s", head, x[0])
+               }
+               if !last.Equal(StringCast(x[len(x)-1])) {
+                       t.Errorf("expected %s to be %s", head, x[len(x)-1])
+               }
+               if len(x) == 1 {
+                       if tail != nil {
+                               t.Error("expected tail to be nil")
+                       }
+                       if rest != nil {
+                               t.Error("expected rest to be nil")
+                       }
+                       continue
+               }
+               tailExp := strings.Join(x[1:], "")
+               if !tail.Equal(StringCast(tailExp)) {
+                       t.Errorf("expected %s to be %s", tail, tailExp)
+               }
+               restExp := strings.Join(x[:len(x)-1], "")
+               if !rest.Equal(StringCast(restExp)) {
+                       t.Errorf("expected %s to be %s", rest, restExp)
+               }
+       }
+
+       c, err := NewComponent("ip4", "127.0.0.1")
+       if err != nil {
+               t.Fatal(err)
+       }
+
+       ci, m := SplitFirst(c)
+       if !ci.Equal(c) || m != nil {
+               t.Error("split first on component failed")
+       }
+       m, ci = SplitLast(c)
+       if !ci.Equal(c) || m != nil {
+               t.Error("split last on component failed")
+       }
+       cis := Split(c)
+       if len(cis) != 1 || !cis[0].Equal(c) {
+               t.Error("split on component failed")
+       }
+       m1, m2 := SplitFunc(c, func(c Component) bool {
+               return true
+       })
+       if m1 != nil || !m2.Equal(c) {
+               t.Error("split func(true) on component failed")
+       }
+       m1, m2 = SplitFunc(c, func(c Component) bool {
+               return false
+       })
+       if !m1.Equal(c) || m2 != nil {
+               t.Error("split func(false) on component failed")
+       }
+
+       i := 0
+       ForEach(c, func(ci Component) bool {
+               if i != 0 {
+                       t.Error("expected exactly one component")
+               }
+               i++
+               if !ci.Equal(c) {
+                       t.Error("foreach on component failed")
+               }
+               return true
+       })
+}
+
+func TestSplitFunc(t *testing.T) {
+       ipStr := "/ip4/0.0.0.0"
+       tcpStr := "/tcp/123"
+       quicStr := "/quic"
+       ipfsStr := "/ipfs/QmPSQnBKM9g7BaUcZCvswUJVscQ1ipjmwxN5PXCjkp9EQ7"
+
+       for _, x := range [][]string{
+               []string{ipStr, tcpStr, quicStr, ipfsStr},
+               []string{ipStr, tcpStr, ipfsStr},
+               []string{ipStr, tcpStr},
+               []string{ipStr},
+       } {
+               addr := StringCast(strings.Join(x, ""))
+               for i, cs := range x {
+                       target := StringCast(cs)
+                       a, b := SplitFunc(addr, func(c Component) bool {
+                               return c.Equal(target)
+                       })
+                       if i == 0 {
+                               if a != nil {
+                                       t.Error("expected nil addr")
+                               }
+                       } else {
+                               if !a.Equal(StringCast(strings.Join(x[:i], ""))) {
+                                       t.Error("split failed")
+                               }
+                               if !b.Equal(StringCast(strings.Join(x[i:], ""))) {
+                                       t.Error("split failed")
+                               }
+                       }
+               }
+               a, b := SplitFunc(addr, func(_ Component) bool { return false })
+               if !a.Equal(addr) || b != nil {
+                       t.Error("should not have split")
+               }
+       }
+}

diff --git a/vendor/github.com/multiformats/go-multiaddr/varint.go b/vendor/github.com/multiformats/go-multiaddr/varint.go
new file mode 100644 (file)
index 0000000..b8b1507
--- /dev/null
+++ b/vendor/github.com/multiformats/go-multiaddr/varint.go
@@ -0,0 +1,44 @@
+package multiaddr
+
+import (
+       "encoding/binary"
+       "fmt"
+       "math/bits"
+)
+
+// VarintSize returns the size (in bytes) of `num` encoded as a varint.
+func VarintSize(num int) int {
+       bits := bits.Len(uint(num))
+       q, r := bits/7, bits%7
+       size := q
+       if r > 0 || size == 0 {
+               size++
+       }
+       return size
+}
+
+// CodeToVarint converts an integer to a varint-encoded []byte
+func CodeToVarint(num int) []byte {
+       buf := make([]byte, VarintSize(num))
+       n := binary.PutUvarint(buf, uint64(num))
+       return buf[:n]
+}
+
+// VarintToCode converts a varint-encoded []byte to an integer protocol code
+func VarintToCode(buf []byte) int {
+       num, _, err := ReadVarintCode(buf)
+       if err != nil {
+               panic(err)
+       }
+       return num
+}
+
+// ReadVarintCode reads a varint code from the beginning of buf.
+// returns the code, and the number of bytes read.
+func ReadVarintCode(buf []byte) (int, int, error) {
+       num, n := binary.Uvarint(buf)
+       if n < 0 {
+               return 0, 0, fmt.Errorf("varints larger than uint64 not yet supported")
+       }
+       return int(num), n, nil
+}

diff --git a/vendor/github.com/multiformats/go-multiaddr/varint_test.go b/vendor/github.com/multiformats/go-multiaddr/varint_test.go
new file mode 100644 (file)
index 0000000..817b3dd
--- /dev/null
+++ b/vendor/github.com/multiformats/go-multiaddr/varint_test.go
@@ -0,0 +1,23 @@
+package multiaddr
+
+import (
+       "encoding/binary"
+       "testing"
+)
+
+func checkVarint(t *testing.T, x int) {
+       buf := make([]byte, binary.MaxVarintLen64)
+       expected := binary.PutUvarint(buf, uint64(x))
+
+       size := VarintSize(x)
+       if size != expected {
+               t.Fatalf("expected varintsize of %d to be %d, got %d", x, expected, size)
+       }
+}
+
+func TestVarintSize(t *testing.T) {
+       max := 1 << 16
+       for x := 0; x < max; x++ {
+               checkVarint(t, x)
+       }
+}

diff --git a/vendor/github.com/multiformats/go-multihash/.gitignore b/vendor/github.com/multiformats/go-multihash/.gitignore
new file mode 100644 (file)
index 0000000..1d74e21
--- /dev/null
+++ b/vendor/github.com/multiformats/go-multihash/.gitignore
@@ -0,0 +1 @@
+.vscode/

diff --git a/vendor/github.com/multiformats/go-multihash/.gx/lastpubver b/vendor/github.com/multiformats/go-multihash/.gx/lastpubver
new file mode 100644 (file)
index 0000000..90a29f4
--- /dev/null
+++ b/vendor/github.com/multiformats/go-multihash/.gx/lastpubver
@@ -0,0 +1 @@
+1.0.10: QmaENCY6u1328TiL3BozJLgZJxCh7oNJpMnUpgcDyX8TWp

diff --git a/vendor/github.com/multiformats/go-multihash/.travis.yml b/vendor/github.com/multiformats/go-multihash/.travis.yml
new file mode 100644 (file)
index 0000000..9f10ab5
--- /dev/null
+++ b/vendor/github.com/multiformats/go-multihash/.travis.yml
@@ -0,0 +1,21 @@
+os:
+  - linux
+
+language: go
+
+go:
+  - 1.11.x
+
+install:
+  - make deps
+
+script:
+  - bash <(curl -s https://raw.githubusercontent.com/ipfs/ci-helpers/master/travis-ci/run-standard-tests.sh)
+  - cd test && make test
+
+cache:
+    directories:
+        - $GOPATH/src/gx
+
+notifications:
+  email: false

diff --git a/vendor/github.com/multiformats/go-multihash/LICENSE b/vendor/github.com/multiformats/go-multihash/LICENSE
new file mode 100644 (file)
index 0000000..c7386b3
--- /dev/null
+++ b/vendor/github.com/multiformats/go-multihash/LICENSE
@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2014 Juan Batiz-Benet
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

diff --git a/vendor/github.com/multiformats/go-multihash/Makefile b/vendor/github.com/multiformats/go-multihash/Makefile
new file mode 100644 (file)
index 0000000..2061941
--- /dev/null
+++ b/vendor/github.com/multiformats/go-multihash/Makefile
@@ -0,0 +1,11 @@
+gx:
+       go get github.com/whyrusleeping/gx
+       go get github.com/whyrusleeping/gx-go
+
+deps: gx
+       gx --verbose install --global
+       gx-go rewrite
+
+publish:
+       gx-go rewrite --undo
+

diff --git a/vendor/github.com/multiformats/go-multihash/README.md b/vendor/github.com/multiformats/go-multihash/README.md
new file mode 100644 (file)
index 0000000..dd7f238
--- /dev/null
+++ b/vendor/github.com/multiformats/go-multihash/README.md
@@ -0,0 +1,90 @@
+# go-multihash
+
+[![](https://img.shields.io/badge/made%20by-Protocol%20Labs-blue.svg?style=flat-square)](http://ipn.io)
+[![](https://img.shields.io/badge/project-multiformats-blue.svg?style=flat-square)](https://github.com/multiformats/multiformats)
+[![](https://img.shields.io/badge/freenode-%23ipfs-blue.svg?style=flat-square)](https://webchat.freenode.net/?channels=%23ipfs)
+[![](https://img.shields.io/badge/readme%20style-standard-brightgreen.svg?style=flat-square)](https://github.com/RichardLitt/standard-readme)
+[![GoDoc](https://godoc.org/github.com/multiformats/go-multihash?status.svg)](https://godoc.org/github.com/multiformats/go-multihash)
+[![Travis CI](https://img.shields.io/travis/multiformats/go-multihash.svg?style=flat-square&branch=master)](https://travis-ci.org/multiformats/go-multihash)
+[![codecov.io](https://img.shields.io/codecov/c/github/multiformats/go-multihash.svg?style=flat-square&branch=master)](https://codecov.io/github/multiformats/go-multihash?branch=master)
+
+> [multihash](https://github.com/multiformats/multihash) implementation in Go
+
+## Table of Contents
+
+- [Install](#install)
+- [Usage](#usage)
+- [Maintainers](#maintainers)
+- [Contribute](#contribute)
+- [License](#license)
+
+## Install
+
+`go-multihash` is a standard Go module which can be installed with:
+
+```sh
+go get github.com/multiformats/go-multihash
+```
+
+## Usage
+
+
+### Example
+
+This example takes a standard hex-encoded data and uses `EncodeName` to calculate the SHA1 multihash value for the buffer.
+
+The resulting hex-encoded data corresponds to: `<hash function code><digest size><hash function output>`, which could be re-parsed
+with `Multihash.FromHexString()`.
+
+
+```go
+package main
+
+import (
+       "encoding/hex"
+       "fmt"
+
+       "github.com/multiformats/go-multihash"
+)
+
+func main() {
+       // ignores errors for simplicity.
+       // don't do that at home.
+       // Decode a SHA1 hash to a binary buffer
+       buf, _ := hex.DecodeString("0beec7b5ea3f0fdbc95d0dd47f3c5bc275da8a33")
+
+       // Create a new multihash with it.
+       mHashBuf, _ := multihash.EncodeName(buf, "sha1")
+       // Print the multihash as hex string
+       fmt.Printf("hex: %s\n", hex.EncodeToString(mHashBuf))
+
+       // Parse the binary multihash to a DecodedMultihash
+       mHash, _ := multihash.Decode(mHashBuf)
+       // Convert the sha1 value to hex string
+       sha1hex := hex.EncodeToString(mHash.Digest)
+       // Print all the information in the multihash
+       fmt.Printf("obj: %v 0x%x %d %s\n", mHash.Name, mHash.Code, mHash.Length, sha1hex)
+}
+```
+
+To run, copy to [example/foo.go](example/foo.go) and:
+
+```
+> cd example/
+> go build
+> ./example
+hex: 11140beec7b5ea3f0fdbc95d0dd47f3c5bc275da8a33
+obj: sha1 0x11 20 0beec7b5ea3f0fdbc95d0dd47f3c5bc275da8a33
+```
+
+## Contribute
+
+Contributions welcome. Please check out [the issues](https://github.com/multiformats/go-multihash/issues).
+
+Check out our [contributing document](https://github.com/multiformats/multiformats/blob/master/contributing.md) for more information on how we work, and about contributing in general. Please be aware that all interactions related to multiformats are subject to the IPFS [Code of Conduct](https://github.com/ipfs/community/blob/master/code-of-conduct.md).
+
+Small note: If editing the README, please conform to the [standard-readme](https://github.com/RichardLitt/standard-readme) specification.
+
+## License
+
+[MIT](LICENSE) © 2014 Juan Batiz-Benet

diff --git a/vendor/github.com/multiformats/go-multihash/codecov.yml b/vendor/github.com/multiformats/go-multihash/codecov.yml
new file mode 100644 (file)
index 0000000..5f88a9e
--- /dev/null
+++ b/vendor/github.com/multiformats/go-multihash/codecov.yml
@@ -0,0 +1,3 @@
+coverage:
+  range: "50...100"
+comment: off

diff --git a/vendor/github.com/multiformats/go-multihash/go.mod b/vendor/github.com/multiformats/go-multihash/go.mod
new file mode 100644 (file)
index 0000000..79a1dfc
--- /dev/null
+++ b/vendor/github.com/multiformats/go-multihash/go.mod
@@ -0,0 +1,11 @@
+module github.com/multiformats/go-multihash
+
+require (
+       github.com/gxed/hashland/keccakpg v0.0.1
+       github.com/gxed/hashland/murmur3 v0.0.1
+       github.com/minio/blake2b-simd v0.0.0-20160723061019-3f5f724cb5b1
+       github.com/minio/sha256-simd v0.0.0-20190131020904-2d45a736cd16
+       github.com/mr-tron/base58 v1.1.0
+       golang.org/x/crypto v0.0.0-20190211182817-74369b46fc67
+       golang.org/x/sys v0.0.0-20190219092855-153ac476189d // indirect
+)

diff --git a/vendor/github.com/multiformats/go-multihash/go.sum b/vendor/github.com/multiformats/go-multihash/go.sum
new file mode 100644 (file)
index 0000000..ecd77b6
--- /dev/null
+++ b/vendor/github.com/multiformats/go-multihash/go.sum
@@ -0,0 +1,14 @@
+github.com/gxed/hashland/keccakpg v0.0.1 h1:wrk3uMNaMxbXiHibbPO4S0ymqJMm41WiudyFSs7UnsU=
+github.com/gxed/hashland/keccakpg v0.0.1/go.mod h1:kRzw3HkwxFU1mpmPP8v1WyQzwdGfmKFJ6tItnhQ67kU=
+github.com/gxed/hashland/murmur3 v0.0.1 h1:SheiaIt0sda5K+8FLz952/1iWS9zrnKsEJaOJu4ZbSc=
+github.com/gxed/hashland/murmur3 v0.0.1/go.mod h1:KjXop02n4/ckmZSnY2+HKcLud/tcmvhST0bie/0lS48=
+github.com/minio/blake2b-simd v0.0.0-20160723061019-3f5f724cb5b1 h1:lYpkrQH5ajf0OXOcUbGjvZxxijuBwbbmlSxLiuofa+g=
+github.com/minio/blake2b-simd v0.0.0-20160723061019-3f5f724cb5b1/go.mod h1:pD8RvIylQ358TN4wwqatJ8rNavkEINozVn9DtGI3dfQ=
+github.com/minio/sha256-simd v0.0.0-20190131020904-2d45a736cd16 h1:5W7KhL8HVF3XCFOweFD3BNESdnO8ewyYTFT2R+/b8FQ=
+github.com/minio/sha256-simd v0.0.0-20190131020904-2d45a736cd16/go.mod h1:2FMWW+8GMoPweT6+pI63m9YE3Lmw4J71hV56Chs1E/U=
+github.com/mr-tron/base58 v1.1.0 h1:Y51FGVJ91WBqCEabAi5OPUz38eAx8DakuAm5svLcsfQ=
+github.com/mr-tron/base58 v1.1.0/go.mod h1:xcD2VGqlgYjBdcBLw+TuYLr8afG+Hj8g2eTVqeSzSU8=
+golang.org/x/crypto v0.0.0-20190211182817-74369b46fc67 h1:ng3VDlRp5/DHpSWl02R4rM9I+8M2rhmsuLwAMmkLQWE=
+golang.org/x/crypto v0.0.0-20190211182817-74369b46fc67/go.mod h1:6SG95UA2DQfeDnfUPMdvaQW0Q7yPrPDi9nlGo2tz2b4=
+golang.org/x/sys v0.0.0-20190219092855-153ac476189d h1:Z0Ahzd7HltpJtjAHHxX8QFP3j1yYgiuvjbjRzDj/KH0=
+golang.org/x/sys v0.0.0-20190219092855-153ac476189d/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY=

diff --git a/vendor/github.com/multiformats/go-multihash/io.go b/vendor/github.com/multiformats/go-multihash/io.go
new file mode 100644 (file)
index 0000000..4629016
--- /dev/null
+++ b/vendor/github.com/multiformats/go-multihash/io.go
@@ -0,0 +1,103 @@
+package multihash
+
+import (
+       "encoding/binary"
+       "errors"
+       "io"
+       "math"
+)
+
+// Reader is an io.Reader wrapper that exposes a function
+// to read a whole multihash, parse it, and return it.
+type Reader interface {
+       io.Reader
+
+       ReadMultihash() (Multihash, error)
+}
+
+// Writer is an io.Writer wrapper that exposes a function
+// to write a whole multihash.
+type Writer interface {
+       io.Writer
+
+       WriteMultihash(Multihash) error
+}
+
+// NewReader wraps an io.Reader with a multihash.Reader
+func NewReader(r io.Reader) Reader {
+       return &mhReader{r}
+}
+
+// NewWriter wraps an io.Writer with a multihash.Writer
+func NewWriter(w io.Writer) Writer {
+       return &mhWriter{w}
+}
+
+type mhReader struct {
+       r io.Reader
+}
+
+func (r *mhReader) Read(buf []byte) (n int, err error) {
+       return r.r.Read(buf)
+}
+
+func (r *mhReader) ReadByte() (byte, error) {
+       if br, ok := r.r.(io.ByteReader); ok {
+               return br.ReadByte()
+       }
+       var b [1]byte
+       n, err := r.r.Read(b[:])
+       if n == 1 {
+               return b[0], nil
+       }
+       if err == nil {
+               if n != 0 {
+                       panic("reader returned an invalid length")
+               }
+               err = io.ErrNoProgress
+       }
+       return 0, err
+}
+
+func (r *mhReader) ReadMultihash() (Multihash, error) {
+       code, err := binary.ReadUvarint(r)
+       if err != nil {
+               return nil, err
+       }
+
+       length, err := binary.ReadUvarint(r)
+       if err != nil {
+               return nil, err
+       }
+       if length > math.MaxInt32 {
+               return nil, errors.New("digest too long, supporting only <= 2^31-1")
+       }
+
+       pre := make([]byte, 2*binary.MaxVarintLen64)
+       spot := pre
+       n := binary.PutUvarint(spot, code)
+       spot = pre[n:]
+       n += binary.PutUvarint(spot, length)
+
+       buf := make([]byte, int(length)+n)
+       copy(buf, pre[:n])
+
+       if _, err := io.ReadFull(r.r, buf[n:]); err != nil {
+               return nil, err
+       }
+
+       return Cast(buf)
+}
+
+type mhWriter struct {
+       w io.Writer
+}
+
+func (w *mhWriter) Write(buf []byte) (n int, err error) {
+       return w.w.Write(buf)
+}
+
+func (w *mhWriter) WriteMultihash(m Multihash) error {
+       _, err := w.w.Write([]byte(m))
+       return err
+}

diff --git a/vendor/github.com/multiformats/go-multihash/io_test.go b/vendor/github.com/multiformats/go-multihash/io_test.go
new file mode 100644 (file)
index 0000000..d9ac4e5
--- /dev/null
+++ b/vendor/github.com/multiformats/go-multihash/io_test.go
@@ -0,0 +1,102 @@
+package multihash
+
+import (
+       "bytes"
+       "io"
+       "testing"
+)
+
+type evilReader struct {
+       buffer []byte
+}
+
+func (er *evilReader) Read(buf []byte) (int, error) {
+       n := copy(buf, er.buffer)
+       er.buffer = er.buffer[n:]
+       var err error
+       if len(er.buffer) == 0 {
+               err = io.EOF
+       }
+       return n, err
+}
+
+func TestEvilReader(t *testing.T) {
+       emptyHash, err := Sum(nil, ID, 0)
+       if err != nil {
+               t.Fatal(err)
+       }
+       r := NewReader(&evilReader{emptyHash})
+       h, err := r.ReadMultihash()
+       if err != nil {
+               t.Fatal(err)
+       }
+       if !bytes.Equal(h, []byte(emptyHash)) {
+               t.Fatal(err)
+       }
+       h, err = r.ReadMultihash()
+       if len([]byte(h)) > 0 || err != io.EOF {
+               t.Fatal("expected end of file")
+       }
+}
+
+func TestReader(t *testing.T) {
+
+       var buf bytes.Buffer
+
+       for _, tc := range testCases {
+               m, err := tc.Multihash()
+               if err != nil {
+                       t.Fatal(err)
+               }
+
+               buf.Write([]byte(m))
+       }
+
+       r := NewReader(&buf)
+
+       for _, tc := range testCases {
+               h, err := tc.Multihash()
+               if err != nil {
+                       t.Fatal(err)
+               }
+
+               h2, err := r.ReadMultihash()
+               if err != nil {
+                       t.Error(err)
+                       continue
+               }
+
+               if !bytes.Equal(h, h2) {
+                       t.Error("h and h2 should be equal")
+               }
+       }
+}
+
+func TestWriter(t *testing.T) {
+
+       var buf bytes.Buffer
+       w := NewWriter(&buf)
+
+       for _, tc := range testCases {
+               m, err := tc.Multihash()
+               if err != nil {
+                       t.Error(err)
+                       continue
+               }
+
+               if err := w.WriteMultihash(m); err != nil {
+                       t.Error(err)
+                       continue
+               }
+
+               buf2 := make([]byte, len(m))
+               if _, err := io.ReadFull(&buf, buf2); err != nil {
+                       t.Error(err)
+                       continue
+               }
+
+               if !bytes.Equal(m, buf2) {
+                       t.Error("m and buf2 should be equal")
+               }
+       }
+}

diff --git a/vendor/github.com/multiformats/go-multihash/multihash.go b/vendor/github.com/multiformats/go-multihash/multihash.go
new file mode 100644 (file)
index 0000000..8c5efbf
--- /dev/null
+++ b/vendor/github.com/multiformats/go-multihash/multihash.go
@@ -0,0 +1,293 @@
+// Package multihash is the Go implementation of
+// https://github.com/multiformats/multihash, or self-describing
+// hashes.
+package multihash
+
+import (
+       "encoding/binary"
+       "encoding/hex"
+       "errors"
+       "fmt"
+       "math"
+
+       b58 "github.com/mr-tron/base58/base58"
+)
+
+// errors
+var (
+       ErrUnknownCode      = errors.New("unknown multihash code")
+       ErrTooShort         = errors.New("multihash too short. must be >= 2 bytes")
+       ErrTooLong          = errors.New("multihash too long. must be < 129 bytes")
+       ErrLenNotSupported  = errors.New("multihash does not yet support digests longer than 127 bytes")
+       ErrInvalidMultihash = errors.New("input isn't valid multihash")
+
+       ErrVarintBufferShort = errors.New("uvarint: buffer too small")
+       ErrVarintTooLong     = errors.New("uvarint: varint too big (max 64bit)")
+)
+
+// ErrInconsistentLen is returned when a decoded multihash has an inconsistent length
+type ErrInconsistentLen struct {
+       dm *DecodedMultihash
+}
+
+func (e ErrInconsistentLen) Error() string {
+       return fmt.Sprintf("multihash length inconsistent: %v", e.dm)
+}
+
+// constants
+const (
+       ID         = 0x00
+       SHA1       = 0x11
+       SHA2_256   = 0x12
+       SHA2_512   = 0x13
+       SHA3_224   = 0x17
+       SHA3_256   = 0x16
+       SHA3_384   = 0x15
+       SHA3_512   = 0x14
+       SHA3       = SHA3_512
+       KECCAK_224 = 0x1A
+       KECCAK_256 = 0x1B
+       KECCAK_384 = 0x1C
+       KECCAK_512 = 0x1D
+
+       SHAKE_128 = 0x18
+       SHAKE_256 = 0x19
+
+       BLAKE2B_MIN = 0xb201
+       BLAKE2B_MAX = 0xb240
+       BLAKE2S_MIN = 0xb241
+       BLAKE2S_MAX = 0xb260
+
+       DBL_SHA2_256 = 0x56
+
+       MURMUR3 = 0x22
+
+       X11 = 0x1100
+)
+
+func init() {
+       // Add blake2b (64 codes)
+       for c := uint64(BLAKE2B_MIN); c <= BLAKE2B_MAX; c++ {
+               n := c - BLAKE2B_MIN + 1
+               name := fmt.Sprintf("blake2b-%d", n*8)
+               Names[name] = c
+               Codes[c] = name
+               DefaultLengths[c] = int(n)
+       }
+
+       // Add blake2s (32 codes)
+       for c := uint64(BLAKE2S_MIN); c <= BLAKE2S_MAX; c++ {
+               n := c - BLAKE2S_MIN + 1
+               name := fmt.Sprintf("blake2s-%d", n*8)
+               Names[name] = c
+               Codes[c] = name
+               DefaultLengths[c] = int(n)
+       }
+}
+
+// Names maps the name of a hash to the code
+var Names = map[string]uint64{
+       "id":           ID,
+       "sha1":         SHA1,
+       "sha2-256":     SHA2_256,
+       "sha2-512":     SHA2_512,
+       "sha3":         SHA3_512,
+       "sha3-224":     SHA3_224,
+       "sha3-256":     SHA3_256,
+       "sha3-384":     SHA3_384,
+       "sha3-512":     SHA3_512,
+       "dbl-sha2-256": DBL_SHA2_256,
+       "murmur3":      MURMUR3,
+       "keccak-224":   KECCAK_224,
+       "keccak-256":   KECCAK_256,
+       "keccak-384":   KECCAK_384,
+       "keccak-512":   KECCAK_512,
+       "shake-128":    SHAKE_128,
+       "shake-256":    SHAKE_256,
+       "x11":          X11,
+}
+
+// Codes maps a hash code to it's name
+var Codes = map[uint64]string{
+       ID:           "id",
+       SHA1:         "sha1",
+       SHA2_256:     "sha2-256",
+       SHA2_512:     "sha2-512",
+       SHA3_224:     "sha3-224",
+       SHA3_256:     "sha3-256",
+       SHA3_384:     "sha3-384",
+       SHA3_512:     "sha3-512",
+       DBL_SHA2_256: "dbl-sha2-256",
+       MURMUR3:      "murmur3",
+       KECCAK_224:   "keccak-224",
+       KECCAK_256:   "keccak-256",
+       KECCAK_384:   "keccak-384",
+       KECCAK_512:   "keccak-512",
+       SHAKE_128:    "shake-128",
+       SHAKE_256:    "shake-256",
+       X11:          "x11",
+}
+
+// DefaultLengths maps a hash code to it's default length
+var DefaultLengths = map[uint64]int{
+       ID:           -1,
+       SHA1:         20,
+       SHA2_256:     32,
+       SHA2_512:     64,
+       SHA3_224:     28,
+       SHA3_256:     32,
+       SHA3_384:     48,
+       SHA3_512:     64,
+       DBL_SHA2_256: 32,
+       KECCAK_224:   28,
+       KECCAK_256:   32,
+       MURMUR3:      4,
+       KECCAK_384:   48,
+       KECCAK_512:   64,
+       SHAKE_128:    32,
+       SHAKE_256:    64,
+       X11:          64,
+}
+
+func uvarint(buf []byte) (uint64, []byte, error) {
+       n, c := binary.Uvarint(buf)
+
+       if c == 0 {
+               return n, buf, ErrVarintBufferShort
+       } else if c < 0 {
+               return n, buf[-c:], ErrVarintTooLong
+       } else {
+               return n, buf[c:], nil
+       }
+}
+
+// DecodedMultihash represents a parsed multihash and allows
+// easy access to the different parts of a multihash.
+type DecodedMultihash struct {
+       Code   uint64
+       Name   string
+       Length int    // Length is just int as it is type of len() opearator
+       Digest []byte // Digest holds the raw multihash bytes
+}
+
+// Multihash is byte slice with the following form:
+// <hash function code><digest size><hash function output>.
+// See the spec for more information.
+type Multihash []byte
+
+// HexString returns the hex-encoded representation of a multihash.
+func (m *Multihash) HexString() string {
+       return hex.EncodeToString([]byte(*m))
+}
+
+// String is an alias to HexString().
+func (m *Multihash) String() string {
+       return m.HexString()
+}
+
+// FromHexString parses a hex-encoded multihash.
+func FromHexString(s string) (Multihash, error) {
+       b, err := hex.DecodeString(s)
+       if err != nil {
+               return Multihash{}, err
+       }
+
+       return Cast(b)
+}
+
+// B58String returns the B58-encoded representation of a multihash.
+func (m Multihash) B58String() string {
+       return b58.Encode([]byte(m))
+}
+
+// FromB58String parses a B58-encoded multihash.
+func FromB58String(s string) (m Multihash, err error) {
+       b, err := b58.Decode(s)
+       if err != nil {
+               return Multihash{}, ErrInvalidMultihash
+       }
+
+       return Cast(b)
+}
+
+// Cast casts a buffer onto a multihash, and returns an error
+// if it does not work.
+func Cast(buf []byte) (Multihash, error) {
+       dm, err := Decode(buf)
+       if err != nil {
+               return Multihash{}, err
+       }
+
+       if !ValidCode(dm.Code) {
+               return Multihash{}, ErrUnknownCode
+       }
+
+       return Multihash(buf), nil
+}
+
+// Decode parses multihash bytes into a DecodedMultihash.
+func Decode(buf []byte) (*DecodedMultihash, error) {
+
+       if len(buf) < 2 {
+               return nil, ErrTooShort
+       }
+
+       var err error
+       var code, length uint64
+
+       code, buf, err = uvarint(buf)
+       if err != nil {
+               return nil, err
+       }
+
+       length, buf, err = uvarint(buf)
+       if err != nil {
+               return nil, err
+       }
+
+       if length > math.MaxInt32 {
+               return nil, errors.New("digest too long, supporting only <= 2^31-1")
+       }
+
+       dm := &DecodedMultihash{
+               Code:   code,
+               Name:   Codes[code],
+               Length: int(length),
+               Digest: buf,
+       }
+
+       if len(dm.Digest) != dm.Length {
+               return nil, ErrInconsistentLen{dm}
+       }
+
+       return dm, nil
+}
+
+// Encode a hash digest along with the specified function code.
+// Note: the length is derived from the length of the digest itself.
+func Encode(buf []byte, code uint64) ([]byte, error) {
+
+       if !ValidCode(code) {
+               return nil, ErrUnknownCode
+       }
+
+       start := make([]byte, 2*binary.MaxVarintLen64, 2*binary.MaxVarintLen64+len(buf))
+       spot := start
+       n := binary.PutUvarint(spot, code)
+       spot = start[n:]
+       n += binary.PutUvarint(spot, uint64(len(buf)))
+
+       return append(start[:n], buf...), nil
+}
+
+// EncodeName is like Encode() but providing a string name
+// instead of a numeric code. See Names for allowed values.
+func EncodeName(buf []byte, name string) ([]byte, error) {
+       return Encode(buf, Names[name])
+}
+
+// ValidCode checks whether a multihash code is valid.
+func ValidCode(code uint64) bool {
+       _, ok := Codes[code]
+       return ok
+}

diff --git a/vendor/github.com/multiformats/go-multihash/multihash/.gitignore b/vendor/github.com/multiformats/go-multihash/multihash/.gitignore
new file mode 100644 (file)
index 0000000..2826f17
--- /dev/null
+++ b/vendor/github.com/multiformats/go-multihash/multihash/.gitignore
@@ -0,0 +1 @@
+multihash

diff --git a/vendor/github.com/multiformats/go-multihash/multihash/.gobuilder.yml b/vendor/github.com/multiformats/go-multihash/multihash/.gobuilder.yml
new file mode 100644 (file)
index 0000000..d775798
--- /dev/null
+++ b/vendor/github.com/multiformats/go-multihash/multihash/.gobuilder.yml
@@ -0,0 +1,5 @@
+---
+artifacts:
+  - LICENSE
+  - README.md
+  - install.dist.sh

diff --git a/vendor/github.com/multiformats/go-multihash/multihash/LICENSE b/vendor/github.com/multiformats/go-multihash/multihash/LICENSE
new file mode 100644 (file)
index 0000000..c7386b3
--- /dev/null
+++ b/vendor/github.com/multiformats/go-multihash/multihash/LICENSE
@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2014 Juan Batiz-Benet
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

diff --git a/vendor/github.com/multiformats/go-multihash/multihash/README.md b/vendor/github.com/multiformats/go-multihash/multihash/README.md
new file mode 100644 (file)
index 0000000..674eba1
--- /dev/null
+++ b/vendor/github.com/multiformats/go-multihash/multihash/README.md
@@ -0,0 +1,118 @@
+# multihash tool
+
+The `multihash` tool uses `go-multihash` to hash things much like `shasum`.
+
+Warning: this is a **multihash** tool! Its digests follow the [multihash](https://github.com/multiformats/multihash) format.
+
+### Install
+
+- From Source:
+    ```
+    go get github.com/multiformats/go-multihash/multihash
+    ```
+- Precompiled Binaries: https://gobuilder.me/github.com/multiformats/go-multihash/multihash
+
+### Usage
+
+```sh
+> multihash -h
+usage: ./multihash [options] [FILE]
+Print or check multihash checksums.
+With no FILE, or when FILE is -, read standard input.
+
+Options:
+  -a="sha2-256": one of: sha1, sha2-256, sha2-512, sha3 (shorthand)
+  -algorithm="sha2-256": one of: sha1, sha2-256, sha2-512, sha3
+  -c="": check checksum matches (shorthand)
+  -check="": check checksum matches
+  -e="base58": one of: raw, hex, base58, base64 (shorthand)
+  -encoding="base58": one of: raw, hex, base58, base64
+  -l=-1: checksums length in bits (truncate). -1 is default (shorthand)
+  -length=-1: checksums length in bits (truncate). -1 is default
+```
+
+### Examples
+
+#### Input
+
+```sh
+# from stdin
+> multihash < main.go
+QmRZxt2b1FVZPNqd8hsiykDL3TdBDeTSPX9Kv46HmX4Gx8
+
+# from file
+> ./multihash main.go
+QmRZxt2b1FVZPNqd8hsiykDL3TdBDeTSPX9Kv46HmX4Gx8
+
+# from stdin "filename"
+> multihash - < main.go
+QmRZxt2b1FVZPNqd8hsiykDL3TdBDeTSPX9Kv46HmX4Gx8
+```
+
+#### Algorithms
+
+```sh
+> multihash -a ?
+error: algorithm '?' not one of: sha1, sha2-256, sha2-512, sha3
+
+> multihash -a sha1 < main.go
+5drkbcqJUo6fZVvcZJeVEVWAgndvLm
+
+> multihash -a sha2-256 < main.go
+QmcK3s36goo9v2HYcfTrDKKwxaxmJJ59etodQQFYsL5T5N
+
+> multihash -a sha2-512 < main.go
+8VuDcW4CooyPQA8Cc4eYpwjhyDJZqu5m5ZMDFzWULYsVS8d119JaGeNWsZbZ2ZG2kPtbrMx31MidokCigaD65yUPAs
+
+> multihash -a sha3 < main.go
+8tWDCTfAX24DYmzNixTj2ARJkqwRG736VHx5aJppmqRjhW9QT1EuTgKUmu9Pmunzq292jzPKxb2VxSsTXmjFY1HD3B
+```
+
+#### Encodings
+
+```sh
+> multihash -e raw < main.go
+ Ϛ�����I�5  S��WG>���_��]g�����u
+
+> multihash -e hex < main.go
+1220cf9aa2b8a38b9b49d135095390059a57473e97aceb5fcae25d67a8b6feb58275
+
+> multihash -e base64 < main.go
+EiDPmqK4o4ubSdE1CVOQBZpXRz6XrOtfyuJdZ6i2/rWCdQ==
+
+> multihash -e base58 < main.go
+Qmf1QjEXDmqBm7RqHKqFGNUyhzUjnX7cmgKMrGzzPceZDQ
+```
+
+#### Digest Length
+
+```sh
+# we're outputing hex (good byte alignment) to show the codes changing
+# notice the multihash code (first 2 chars) differs!
+> multihash -e hex -a sha2-256 -l 256 < main.go
+1220cf9aa2b8a38b9b49d135095390059a57473e97aceb5fcae25d67a8b6feb58275
+> multihash -e hex -a sha2-512 -l 256 < main.go
+132047a4b6c629f5545f529b0ff461dc09119969f3593186277a1cc7a8ea3560a6f1
+> multihash -e hex -a sha3 -l 256 < main.go
+14206b9222a1a47939e665261bd2b5573e55e7988675223adde73c1011066ad66335
+
+# notice the multihash length (next 2 chars) differs!
+> multihash -e hex -a sha2-256 -l 256 < main.go
+1220cf9aa2b8a38b9b49d135095390059a57473e97aceb5fcae25d67a8b6feb58275
+> multihash -e hex -a sha2-256 -l 200 < main.go
+1219cf9aa2b8a38b9b49d135095390059a57473e97aceb5fcae25d
+```
+
+#### Verify Checksum
+
+```sh
+> multihash -c QmRZxt2b1FVZPNqd8hsiykDL3TdBDeTSPX9Kv46HmX4Gx8 < main.go
+OK checksums match (-q for no output)
+
+> multihash -c QmcKaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa < main.go
+error: computed checksum did not match (-q for no output)
+
+# works with other arguments too
+> multihash -e hex -l 128 -c "12102ffc284a1e82bf51e567c75b2ae6edb9" < main.go
+OK checksums match (-q for no output)
+```

diff --git a/vendor/github.com/multiformats/go-multihash/multihash/install.dist.sh b/vendor/github.com/multiformats/go-multihash/multihash/install.dist.sh
new file mode 100644 (file)
index 0000000..f90274f
--- /dev/null
+++ b/vendor/github.com/multiformats/go-multihash/multihash/install.dist.sh
@@ -0,0 +1,21 @@
+#!/bin/sh
+
+bin=multihash
+
+# this script is currently brain dead.
+# it merely tries two locations.
+# in the future maybe use value of $PATH.
+
+binpath=/usr/local/bin
+if [ -d "$binpath" ]; then
+  mv "$bin" "$binpath/$bin"
+  echo "installed $binpath/$bin"
+  exit 0
+fi
+
+binpath=/usr/bin
+if [ -d "$binpath" ]; then
+  mv "$bin" "$binpath/$bin"
+  echo "installed $binpath/$bin"
+  exit 0
+fi

diff --git a/vendor/github.com/multiformats/go-multihash/multihash/main.go b/vendor/github.com/multiformats/go-multihash/multihash/main.go
new file mode 100644 (file)
index 0000000..3f874c3
--- /dev/null
+++ b/vendor/github.com/multiformats/go-multihash/multihash/main.go
@@ -0,0 +1,142 @@
+package main
+
+import (
+       "flag"
+       "fmt"
+       "io"
+       "os"
+
+       mh "github.com/multiformats/go-multihash"
+       mhopts "github.com/multiformats/go-multihash/opts"
+)
+
+var usage = `usage: %s [options] [FILE]
+Print or check multihash checksums.
+With no FILE, or when FILE is -, read standard input.
+
+Options:
+`
+
+// flags
+var opts *mhopts.Options
+var checkRaw string
+var checkMh mh.Multihash
+var inputFilename string
+var quiet bool
+var help bool
+
+func init() {
+       flag.Usage = func() {
+               fmt.Fprintf(os.Stderr, usage, os.Args[0])
+               flag.PrintDefaults()
+       }
+
+       opts = mhopts.SetupFlags(flag.CommandLine)
+
+       checkStr := "check checksum matches"
+       flag.StringVar(&checkRaw, "check", "", checkStr)
+       flag.StringVar(&checkRaw, "c", "", checkStr+" (shorthand)")
+
+       helpStr := "display help message"
+       flag.BoolVar(&help, "help", false, helpStr)
+       flag.BoolVar(&help, "h", false, helpStr+" (shorthand)")
+
+       quietStr := "quiet output (no newline on checksum, no error text)"
+       flag.BoolVar(&quiet, "quiet", false, quietStr)
+       flag.BoolVar(&quiet, "q", false, quietStr+" (shorthand)")
+}
+
+func parseFlags(o *mhopts.Options) error {
+       flag.Parse()
+       if err := o.ParseError(); err != nil {
+               return err
+       }
+
+       if checkRaw != "" {
+               var err error
+               checkMh, err = mhopts.Decode(o.Encoding, checkRaw)
+               if err != nil {
+                       return fmt.Errorf("fail to decode check '%s': %s", checkRaw, err)
+               }
+       }
+
+       return nil
+}
+
+func getInput() (io.ReadCloser, error) {
+       args := flag.Args()
+
+       switch {
+       case len(args) < 1:
+               inputFilename = "-"
+               return os.Stdin, nil
+       case args[0] == "-":
+               inputFilename = "-"
+               return os.Stdin, nil
+       default:
+               inputFilename = args[0]
+               f, err := os.Open(args[0])
+               if err != nil {
+                       return nil, fmt.Errorf("failed to open '%s': %s", args[0], err)
+               }
+               return f, nil
+       }
+}
+func printHash(o *mhopts.Options, r io.Reader) error {
+       h, err := o.Multihash(r)
+       if err != nil {
+               return err
+       }
+
+       s, err := mhopts.Encode(o.Encoding, h)
+       if err != nil {
+               return err
+       }
+
+       if quiet {
+               fmt.Print(s)
+       } else {
+               fmt.Println(s)
+       }
+       return nil
+}
+
+func main() {
+       checkErr := func(err error) {
+               if err != nil {
+                       die("error: ", err)
+               }
+       }
+
+       err := parseFlags(opts)
+       checkErr(err)
+
+       if help {
+               flag.Usage()
+               os.Exit(0)
+       }
+
+       inp, err := getInput()
+       checkErr(err)
+
+       if checkMh != nil {
+               err = opts.Check(inp, checkMh)
+               checkErr(err)
+               if !quiet {
+                       fmt.Println("OK checksums match (-q for no output)")
+               }
+       } else {
+               err = printHash(opts, inp)
+               checkErr(err)
+       }
+       inp.Close()
+}
+
+func die(v ...interface{}) {
+       if !quiet {
+               fmt.Fprint(os.Stderr, v...)
+               fmt.Fprint(os.Stderr, "\n")
+       }
+       // flag.Usage()
+       os.Exit(1)
+}

diff --git a/vendor/github.com/multiformats/go-multihash/multihash_test.go b/vendor/github.com/multiformats/go-multihash/multihash_test.go
new file mode 100644 (file)
index 0000000..d1c3987
--- /dev/null
+++ b/vendor/github.com/multiformats/go-multihash/multihash_test.go
@@ -0,0 +1,311 @@
+package multihash
+
+import (
+       "bytes"
+       "encoding/binary"
+       "encoding/hex"
+       "fmt"
+       "testing"
+)
+
+// maybe silly, but makes it so changing
+// the table accidentally has to happen twice.
+var tCodes = map[uint64]string{
+       0x00:   "id",
+       0x11:   "sha1",
+       0x12:   "sha2-256",
+       0x13:   "sha2-512",
+       0x14:   "sha3-512",
+       0x15:   "sha3-384",
+       0x16:   "sha3-256",
+       0x17:   "sha3-224",
+       0x56:   "dbl-sha2-256",
+       0x22:   "murmur3",
+       0x1A:   "keccak-224",
+       0x1B:   "keccak-256",
+       0x1C:   "keccak-384",
+       0x1D:   "keccak-512",
+       0x18:   "shake-128",
+       0x19:   "shake-256",
+       0x1100: "x11",
+}
+
+type TestCase struct {
+       hex  string
+       code uint64
+       name string
+}
+
+var testCases = []TestCase{
+       {"2c26b46b68ffc68ff99b453c1d30413413422d706483bfa0f98a5e886266e7ae", 0x00, "id"},
+       {"", 0x00, "id"},
+       {"0beec7b5ea3f0fdbc95d0dd47f3c5bc275da8a33", 0x11, "sha1"},
+       {"0beec7b5", 0x11, "sha1"},
+       {"2c26b46b68ffc68ff99b453c1d30413413422d706483bfa0f98a5e886266e7ae", 0x12, "sha2-256"},
+       {"2c26b46b", 0x12, "sha2-256"},
+       {"2c26b46b68ffc68ff99b453c1d30413413", 0xb240, "blake2b-512"},
+       {"243ddb9e", 0x22, "murmur3"},
+       {"f00ba4", 0x1b, "keccak-256"},
+       {"f84e95cb5fbd2038863ab27d3cdeac295ad2d4ab96ad1f4b070c0bf36078ef08", 0x18, "shake-128"},
+       {"1af97f7818a28edfdfce5ec66dbdc7e871813816d7d585fe1f12475ded5b6502b7723b74e2ee36f2651a10a8eaca72aa9148c3c761aaceac8f6d6cc64381ed39", 0x19, "shake-256"},
+       {"4bca2b137edc580fe50a88983ef860ebaca36c857b1f492839d6d7392452a63c82cbebc68e3b70a2a1480b4bb5d437a7cba6ecf9d89f9ff3ccd14cd6146ea7e7", 0x14, "sha3-512"},
+}
+
+func (tc TestCase) Multihash() (Multihash, error) {
+       ob, err := hex.DecodeString(tc.hex)
+       if err != nil {
+               return nil, err
+       }
+
+       pre := make([]byte, 2*binary.MaxVarintLen64)
+       spot := pre
+       n := binary.PutUvarint(spot, tc.code)
+       spot = pre[n:]
+       n += binary.PutUvarint(spot, uint64(len(ob)))
+
+       nb := append(pre[:n], ob...)
+       return Cast(nb)
+}
+
+func TestEncode(t *testing.T) {
+       for _, tc := range testCases {
+               ob, err := hex.DecodeString(tc.hex)
+               if err != nil {
+                       t.Error(err)
+                       continue
+               }
+
+               pre := make([]byte, 2*binary.MaxVarintLen64)
+               spot := pre
+               n := binary.PutUvarint(spot, tc.code)
+               spot = pre[n:]
+               n += binary.PutUvarint(spot, uint64(len(ob)))
+
+               nb := append(pre[:n], ob...)
+
+               encC, err := Encode(ob, tc.code)
+               if err != nil {
+                       t.Error(err)
+                       continue
+               }
+
+               if !bytes.Equal(encC, nb) {
+                       t.Error("encoded byte mismatch: ", encC, nb)
+                       t.Error(hex.Dump(nb))
+               }
+
+               encN, err := EncodeName(ob, tc.name)
+               if err != nil {
+                       t.Error(err)
+                       continue
+               }
+
+               if !bytes.Equal(encN, nb) {
+                       t.Error("encoded byte mismatch: ", encN, nb)
+               }
+
+               h, err := tc.Multihash()
+               if err != nil {
+                       t.Error(err)
+               }
+               if !bytes.Equal(h, nb) {
+                       t.Error("Multihash func mismatch.")
+               }
+       }
+}
+
+func ExampleEncodeName() {
+       // ignores errors for simplicity - don't do that at home.
+       buf, _ := hex.DecodeString("0beec7b5ea3f0fdbc95d0dd47f3c5bc275da8a33")
+       mhbuf, _ := EncodeName(buf, "sha1")
+       mhhex := hex.EncodeToString(mhbuf)
+       fmt.Printf("hex: %v\n", mhhex)
+
+       // Output:
+       // hex: 11140beec7b5ea3f0fdbc95d0dd47f3c5bc275da8a33
+}
+
+func TestDecode(t *testing.T) {
+       for _, tc := range testCases {
+               ob, err := hex.DecodeString(tc.hex)
+               if err != nil {
+                       t.Error(err)
+                       continue
+               }
+               pre := make([]byte, 2*binary.MaxVarintLen64)
+               spot := pre
+               n := binary.PutUvarint(spot, tc.code)
+               spot = pre[n:]
+               n += binary.PutUvarint(spot, uint64(len(ob)))
+
+               nb := append(pre[:n], ob...)
+
+               dec, err := Decode(nb)
+               if err != nil {
+                       t.Error(err)
+                       continue
+               }
+
+               if dec.Code != tc.code {
+                       t.Error("decoded code mismatch: ", dec.Code, tc.code)
+               }
+
+               if dec.Name != tc.name {
+                       t.Error("decoded name mismatch: ", dec.Name, tc.name)
+               }
+
+               if dec.Length != len(ob) {
+                       t.Error("decoded length mismatch: ", dec.Length, len(ob))
+               }
+
+               if !bytes.Equal(dec.Digest, ob) {
+                       t.Error("decoded byte mismatch: ", dec.Digest, ob)
+               }
+       }
+}
+
+func TestTable(t *testing.T) {
+       for k, v := range tCodes {
+               if Codes[k] != v {
+                       t.Error("Table mismatch: ", Codes[k], v)
+               }
+               if Names[v] != k {
+                       t.Error("Table mismatch: ", Names[v], k)
+               }
+       }
+}
+
+func ExampleDecode() {
+       // ignores errors for simplicity - don't do that at home.
+       buf, _ := hex.DecodeString("0beec7b5ea3f0fdbc95d0dd47f3c5bc275da8a33")
+       mhbuf, _ := EncodeName(buf, "sha1")
+       o, _ := Decode(mhbuf)
+       mhhex := hex.EncodeToString(o.Digest)
+       fmt.Printf("obj: %v 0x%x %d %s\n", o.Name, o.Code, o.Length, mhhex)
+
+       // Output:
+       // obj: sha1 0x11 20 0beec7b5ea3f0fdbc95d0dd47f3c5bc275da8a33
+}
+
+func TestValidCode(t *testing.T) {
+       for i := uint64(0); i < 0xff; i++ {
+               _, ok := tCodes[i]
+
+               if ValidCode(i) != ok {
+                       t.Error("ValidCode incorrect for: ", i)
+               }
+       }
+}
+
+func TestCast(t *testing.T) {
+       for _, tc := range testCases {
+               ob, err := hex.DecodeString(tc.hex)
+               if err != nil {
+                       t.Error(err)
+                       continue
+               }
+
+               pre := make([]byte, 2*binary.MaxVarintLen64)
+               spot := pre
+               n := binary.PutUvarint(spot, tc.code)
+               spot = pre[n:]
+               n += binary.PutUvarint(spot, uint64(len(ob)))
+
+               nb := append(pre[:n], ob...)
+
+               if _, err := Cast(nb); err != nil {
+                       t.Error(err)
+                       continue
+               }
+
+               if _, err = Cast(ob); err == nil {
+                       t.Error("cast failed to detect non-multihash")
+                       continue
+               }
+       }
+}
+
+func TestHex(t *testing.T) {
+       for _, tc := range testCases {
+               ob, err := hex.DecodeString(tc.hex)
+               if err != nil {
+                       t.Error(err)
+                       continue
+               }
+
+               pre := make([]byte, 2*binary.MaxVarintLen64)
+               spot := pre
+               n := binary.PutUvarint(spot, tc.code)
+               spot = pre[n:]
+               n += binary.PutUvarint(spot, uint64(len(ob)))
+
+               nb := append(pre[:n], ob...)
+
+               hs := hex.EncodeToString(nb)
+               mh, err := FromHexString(hs)
+               if err != nil {
+                       t.Error(err)
+                       continue
+               }
+
+               if !bytes.Equal(mh, nb) {
+                       t.Error("FromHexString failed", nb, mh)
+                       continue
+               }
+
+               if mh.HexString() != hs {
+                       t.Error("Multihash.HexString failed", hs, mh.HexString())
+                       continue
+               }
+       }
+}
+func TestDecodeErrorInvalid(t *testing.T) {
+       _, err := FromB58String("/ipfs/QmQTw94j68Dgakgtfd45bG3TZG6CAfc427UVRH4mugg4q4")
+       if err != ErrInvalidMultihash {
+               t.Fatalf("expected: %s, got %s\n", ErrInvalidMultihash, err)
+       }
+}
+
+func TestBadVarint(t *testing.T) {
+       _, err := Cast([]byte{129, 128, 128, 128, 128, 128, 128, 128, 128, 128, 129, 1})
+       if err != ErrVarintTooLong {
+               t.Error("expected error from varint longer than 64bits, got: ", err)
+       }
+       _, err = Cast([]byte{128, 128, 128})
+       if err != ErrVarintBufferShort {
+               t.Error("expected error from cut-off varint, got: ", err)
+       }
+}
+
+func BenchmarkEncode(b *testing.B) {
+       tc := testCases[0]
+       ob, err := hex.DecodeString(tc.hex)
+       if err != nil {
+               b.Error(err)
+               return
+       }
+
+       b.ResetTimer()
+       for i := 0; i < b.N; i++ {
+               Encode(ob, tc.code)
+       }
+}
+
+func BenchmarkDecode(b *testing.B) {
+       tc := testCases[0]
+       ob, err := hex.DecodeString(tc.hex)
+       if err != nil {
+               b.Error(err)
+               return
+       }
+
+       pre := make([]byte, 2)
+       pre[0] = byte(uint8(tc.code))
+       pre[1] = byte(uint8(len(ob)))
+       nb := append(pre, ob...)
+
+       b.ResetTimer()
+       for i := 0; i < b.N; i++ {
+               Decode(nb)
+       }
+}

diff --git a/vendor/github.com/multiformats/go-multihash/opts/README.md b/vendor/github.com/multiformats/go-multihash/opts/README.md
new file mode 100644 (file)
index 0000000..ada8023
--- /dev/null
+++ b/vendor/github.com/multiformats/go-multihash/opts/README.md
@@ -0,0 +1,9 @@
+# mhopts - multihash options for writing commands
+
+`mhopts` is a small package that helps to write commands which
+may take multihash options. Check it out in action:
+
+- [multihash](../multihash)
+- [hashpipe](https://github.com/jbenet/go-hashpipe)
+
+Godoc: [https://godoc.org/github.com/multiformats/go-multihash/opts](https://godoc.org/github.com/multiformats/go-multihash/opts)

diff --git a/vendor/github.com/multiformats/go-multihash/opts/coding.go b/vendor/github.com/multiformats/go-multihash/opts/coding.go
new file mode 100644 (file)
index 0000000..0696102
--- /dev/null
+++ b/vendor/github.com/multiformats/go-multihash/opts/coding.go
@@ -0,0 +1,40 @@
+package opts
+
+import (
+       "encoding/base64"
+       "encoding/hex"
+       "fmt"
+
+       base58 "github.com/mr-tron/base58/base58"
+       mh "github.com/multiformats/go-multihash"
+)
+
+func Decode(encoding, digest string) (mh.Multihash, error) {
+       switch encoding {
+       case "raw":
+               return mh.Cast([]byte(digest))
+       case "hex":
+               return hex.DecodeString(digest)
+       case "base58":
+               return base58.Decode(digest)
+       case "base64":
+               return base64.StdEncoding.DecodeString(digest)
+       default:
+               return nil, fmt.Errorf("unknown encoding: %s", encoding)
+       }
+}
+
+func Encode(encoding string, hash mh.Multihash) (string, error) {
+       switch encoding {
+       case "raw":
+               return string(hash), nil
+       case "hex":
+               return hex.EncodeToString(hash), nil
+       case "base58":
+               return base58.Encode(hash), nil
+       case "base64":
+               return base64.StdEncoding.EncodeToString(hash), nil
+       default:
+               return "", fmt.Errorf("unknown encoding: %s", encoding)
+       }
+}

diff --git a/vendor/github.com/multiformats/go-multihash/opts/opts.go b/vendor/github.com/multiformats/go-multihash/opts/opts.go
new file mode 100644 (file)
index 0000000..745c83f
--- /dev/null
+++ b/vendor/github.com/multiformats/go-multihash/opts/opts.go
@@ -0,0 +1,153 @@
+// Package opts helps to write commands which may take multihash
+// options.
+package opts
+
+import (
+       "bytes"
+       "errors"
+       "flag"
+       "fmt"
+       "io"
+       "io/ioutil"
+       "sort"
+       "strings"
+
+       mh "github.com/multiformats/go-multihash"
+)
+
+// package errors
+var (
+       ErrMatch = errors.New("multihash checksums did not match")
+)
+
+// Options is a struct used to parse cli flags.
+type Options struct {
+       Encoding      string
+       Algorithm     string
+       AlgorithmCode uint64
+       Length        int
+
+       fs *flag.FlagSet
+}
+
+// FlagValues are the values the various option flags can take.
+var FlagValues = struct {
+       Encodings  []string
+       Algorithms []string
+}{
+       Encodings: []string{"raw", "hex", "base58", "base64"},
+       Algorithms: func() []string {
+               names := make([]string, 0, len(mh.Names))
+               for n := range mh.Names {
+                       // There are too many of these for now.
+                       // We can figure something better out later.
+                       if strings.HasPrefix(n, "blake2") {
+                               switch n {
+                               case "blake2s-256":
+                               case "blake2b-128":
+                               case "blake2b-224":
+                               case "blake2b-256":
+                               case "blake2b-384":
+                               case "blake2b-512":
+                               default:
+                                       continue
+                               }
+                       }
+                       names = append(names, n)
+               }
+               sort.Strings(names)
+               return names
+       }(),
+}
+
+// SetupFlags adds multihash related options to given flagset.
+func SetupFlags(f *flag.FlagSet) *Options {
+       // TODO: add arg for adding opt prefix and/or overriding opts
+
+       o := new(Options)
+       algoStr := "one of: " + strings.Join(FlagValues.Algorithms, ", ")
+       f.StringVar(&o.Algorithm, "algorithm", "sha2-256", algoStr)
+       f.StringVar(&o.Algorithm, "a", "sha2-256", algoStr+" (shorthand)")
+
+       encStr := "one of: " + strings.Join(FlagValues.Encodings, ", ")
+       f.StringVar(&o.Encoding, "encoding", "base58", encStr)
+       f.StringVar(&o.Encoding, "e", "base58", encStr+" (shorthand)")
+
+       lengthStr := "checksums length in bits (truncate). -1 is default"
+       f.IntVar(&o.Length, "length", -1, lengthStr)
+       f.IntVar(&o.Length, "l", -1, lengthStr+" (shorthand)")
+       return o
+}
+
+// Parse parses the values of flags from given argument slice.
+// It is equivalent to flags.Parse(args)
+func (o *Options) Parse(args []string) error {
+       if err := o.fs.Parse(args); err != nil {
+               return err
+       }
+       return o.ParseError()
+}
+
+// ParseError checks the parsed options for errors.
+func (o *Options) ParseError() error {
+       if !strIn(o.Encoding, FlagValues.Encodings) {
+               return fmt.Errorf("encoding '%s' not %s", o.Encoding, FlagValues.Encodings)
+       }
+
+       if !strIn(o.Algorithm, FlagValues.Algorithms) {
+               return fmt.Errorf("algorithm '%s' not %s", o.Algorithm, FlagValues.Algorithms)
+       }
+
+       var found bool
+       o.AlgorithmCode, found = mh.Names[o.Algorithm]
+       if !found {
+               return fmt.Errorf("algorithm '%s' not found (lib error, pls report).", o.Algorithm)
+       }
+
+       if o.Length >= 0 {
+               if o.Length%8 != 0 {
+                       return fmt.Errorf("length must be multiple of 8")
+               }
+               o.Length = o.Length / 8
+
+               if o.Length > mh.DefaultLengths[o.AlgorithmCode] {
+                       o.Length = mh.DefaultLengths[o.AlgorithmCode]
+               }
+       }
+       return nil
+}
+
+// strIn checks wither string a is in set.
+func strIn(a string, set []string) bool {
+       for _, s := range set {
+               if s == a {
+                       return true
+               }
+       }
+       return false
+}
+
+// Check reads all the data in r, calculates its multihash,
+// and checks it matches h1
+func (o *Options) Check(r io.Reader, h1 mh.Multihash) error {
+       h2, err := o.Multihash(r)
+       if err != nil {
+               return err
+       }
+
+       if !bytes.Equal(h1, h2) {
+               return fmt.Errorf("computed checksum did not match")
+       }
+
+       return nil
+}
+
+// Multihash reads all the data in r and calculates its multihash.
+func (o *Options) Multihash(r io.Reader) (mh.Multihash, error) {
+       b, err := ioutil.ReadAll(r)
+       if err != nil {
+               return nil, err
+       }
+
+       return mh.Sum(b, o.AlgorithmCode, o.Length)
+}

diff --git a/vendor/github.com/multiformats/go-multihash/package.json b/vendor/github.com/multiformats/go-multihash/package.json
new file mode 100644 (file)
index 0000000..af15ff5
--- /dev/null
+++ b/vendor/github.com/multiformats/go-multihash/package.json
@@ -0,0 +1,54 @@
+{
+  "author": "multiformats",
+  "bugs": {
+    "url": "https://github.com/multiformats/go-multihash/issues"
+  },
+  "gx": {
+    "dvcsimport": "github.com/multiformats/go-multihash"
+  },
+  "gxDependencies": [
+    {
+      "author": "whyrusleeping",
+      "hash": "QmW7VUmSvhvSGbYbdsh7uRjhGmsYkc9fL8aJ5CorxxrU5N",
+      "name": "go-crypto",
+      "version": "0.2.1"
+    },
+    {
+      "author": "mr-tron",
+      "hash": "QmWFAMPqsEyUX7gDUsRVmMWz59FxSpJ1b2v6bJ1yYzo7jY",
+      "name": "go-base58-fast",
+      "version": "0.1.1"
+    },
+    {
+      "author": "whyrusleeping",
+      "hash": "QmZtJMfZZvoD3EKpQaf8xsFi83HMtX5acQekY8exMbcWEi",
+      "name": "keccakpg",
+      "version": "0.0.1"
+    },
+    {
+      "author": "minio",
+      "hash": "QmcTzQXRcU2vf8yX5EEboz1BSvWC7wWmeYAKVQmhp8WZYU",
+      "name": "sha256-simd",
+      "version": "0.1.2"
+    },
+    {
+      "author": "minio",
+      "hash": "QmZp3eKdYQHHAneECmeK6HhiMwTPufmjC8DuuaGKv3unvx",
+      "name": "blake2b-simd",
+      "version": "0.1.1"
+    },
+    {
+      "author": "whyrusleeping",
+      "hash": "QmWAXZgFyppTRshtnVHJ8LnA1yoHjUr41ZnsWPoA8wnSgF",
+      "name": "hashland-murmur3",
+      "version": "0.0.1"
+    }
+  ],
+  "gxVersion": "0.9.0",
+  "language": "go",
+  "license": "MIT",
+  "name": "go-multihash",
+  "releaseCmd": "git commit -a -m \"gx release $VERSION\"",
+  "version": "1.0.10"
+}
+

diff --git a/vendor/github.com/multiformats/go-multihash/sum.go b/vendor/github.com/multiformats/go-multihash/sum.go
new file mode 100644 (file)
index 0000000..5301e0d
--- /dev/null
+++ b/vendor/github.com/multiformats/go-multihash/sum.go
@@ -0,0 +1,239 @@
+package multihash
+
+import (
+       "crypto/sha1"
+       "crypto/sha512"
+       "errors"
+       "fmt"
+
+       keccak "github.com/gxed/hashland/keccakpg"
+       murmur3 "github.com/gxed/hashland/murmur3"
+       blake2b "github.com/minio/blake2b-simd"
+       sha256 "github.com/minio/sha256-simd"
+       blake2s "golang.org/x/crypto/blake2s"
+       sha3 "golang.org/x/crypto/sha3"
+)
+
+// ErrSumNotSupported is returned when the Sum function code is not implemented
+var ErrSumNotSupported = errors.New("Function not implemented. Complain to lib maintainer.")
+
+// HashFunc is a hash function that hashes data into digest.
+//
+// The length is the size the digest will be truncated to. While the hash
+// function isn't responsible for truncating the digest, it may want to error if
+// the length is invalid for the hash function (e.g., truncation would make the
+// hash useless).
+type HashFunc func(data []byte, length int) (digest []byte, err error)
+
+// funcTable maps multicodec values to hash functions.
+var funcTable = make(map[uint64]HashFunc)
+
+// Sum obtains the cryptographic sum of a given buffer. The length parameter
+// indicates the length of the resulting digest and passing a negative value
+// use default length values for the selected hash function.
+func Sum(data []byte, code uint64, length int) (Multihash, error) {
+       if !ValidCode(code) {
+               return nil, fmt.Errorf("invalid multihash code %d", code)
+       }
+
+       if length < 0 {
+               var ok bool
+               length, ok = DefaultLengths[code]
+               if !ok {
+                       return nil, fmt.Errorf("no default length for code %d", code)
+               }
+       }
+
+       hashFunc, ok := funcTable[code]
+       if !ok {
+               return nil, ErrSumNotSupported
+       }
+
+       d, err := hashFunc(data, length)
+       if err != nil {
+               return nil, err
+       }
+       if length >= 0 {
+               d = d[:length]
+       }
+       return Encode(d, code)
+}
+
+func sumBlake2s(data []byte, size int) ([]byte, error) {
+       if size != 32 {
+               return nil, fmt.Errorf("unsupported length for blake2s: %d", size)
+       }
+       d := blake2s.Sum256(data)
+       return d[:], nil
+}
+func sumBlake2b(data []byte, size int) ([]byte, error) {
+       hasher, err := blake2b.New(&blake2b.Config{Size: uint8(size)})
+       if err != nil {
+               return nil, err
+       }
+
+       if _, err := hasher.Write(data); err != nil {
+               return nil, err
+       }
+
+       return hasher.Sum(nil)[:], nil
+}
+
+func sumID(data []byte, length int) ([]byte, error) {
+       if length >= 0 && length != len(data) {
+               return nil, fmt.Errorf("the length of the identity hash (%d) must be equal to the length of the data (%d)",
+                       length, len(data))
+
+       }
+       return data, nil
+}
+
+func sumSHA1(data []byte, length int) ([]byte, error) {
+       a := sha1.Sum(data)
+       return a[0:20], nil
+}
+
+func sumSHA256(data []byte, length int) ([]byte, error) {
+       a := sha256.Sum256(data)
+       return a[0:32], nil
+}
+
+func sumDoubleSHA256(data []byte, length int) ([]byte, error) {
+       val, _ := sumSHA256(data, len(data))
+       return sumSHA256(val, len(val))
+}
+
+func sumSHA512(data []byte, length int) ([]byte, error) {
+       a := sha512.Sum512(data)
+       return a[0:64], nil
+}
+
+func sumKeccak224(data []byte, length int) ([]byte, error) {
+       h := keccak.New224()
+       h.Write(data)
+       return h.Sum(nil), nil
+}
+
+func sumKeccak256(data []byte, length int) ([]byte, error) {
+       h := keccak.New256()
+       h.Write(data)
+       return h.Sum(nil), nil
+}
+
+func sumKeccak384(data []byte, length int) ([]byte, error) {
+       h := keccak.New384()
+       h.Write(data)
+       return h.Sum(nil), nil
+}
+
+func sumKeccak512(data []byte, length int) ([]byte, error) {
+       h := keccak.New512()
+       h.Write(data)
+       return h.Sum(nil), nil
+}
+
+func sumSHA3_512(data []byte, length int) ([]byte, error) {
+       a := sha3.Sum512(data)
+       return a[:], nil
+}
+
+func sumMURMUR3(data []byte, length int) ([]byte, error) {
+       number := murmur3.Sum32(data)
+       bytes := make([]byte, 4)
+       for i := range bytes {
+               bytes[i] = byte(number & 0xff)
+               number >>= 8
+       }
+       return bytes, nil
+}
+
+func sumSHAKE128(data []byte, length int) ([]byte, error) {
+       bytes := make([]byte, 32)
+       sha3.ShakeSum128(bytes, data)
+       return bytes, nil
+}
+
+func sumSHAKE256(data []byte, length int) ([]byte, error) {
+       bytes := make([]byte, 64)
+       sha3.ShakeSum256(bytes, data)
+       return bytes, nil
+}
+
+func sumSHA3_384(data []byte, length int) ([]byte, error) {
+       a := sha3.Sum384(data)
+       return a[:], nil
+}
+
+func sumSHA3_256(data []byte, length int) ([]byte, error) {
+       a := sha3.Sum256(data)
+       return a[:], nil
+}
+
+func sumSHA3_224(data []byte, length int) ([]byte, error) {
+       a := sha3.Sum224(data)
+       return a[:], nil
+}
+
+func registerStdlibHashFuncs() {
+       RegisterHashFunc(ID, sumID)
+       RegisterHashFunc(SHA1, sumSHA1)
+       RegisterHashFunc(SHA2_512, sumSHA512)
+}
+
+func registerNonStdlibHashFuncs() {
+       RegisterHashFunc(SHA2_256, sumSHA256)
+       RegisterHashFunc(DBL_SHA2_256, sumDoubleSHA256)
+
+       RegisterHashFunc(KECCAK_224, sumKeccak224)
+       RegisterHashFunc(KECCAK_256, sumKeccak256)
+       RegisterHashFunc(KECCAK_384, sumKeccak384)
+       RegisterHashFunc(KECCAK_512, sumKeccak512)
+
+       RegisterHashFunc(SHA3_224, sumSHA3_224)
+       RegisterHashFunc(SHA3_256, sumSHA3_256)
+       RegisterHashFunc(SHA3_384, sumSHA3_384)
+       RegisterHashFunc(SHA3_512, sumSHA3_512)
+
+       RegisterHashFunc(MURMUR3, sumMURMUR3)
+
+       RegisterHashFunc(SHAKE_128, sumSHAKE128)
+       RegisterHashFunc(SHAKE_256, sumSHAKE256)
+
+       // Blake family of hash functions
+       // BLAKE2S
+       for c := uint64(BLAKE2S_MIN); c <= BLAKE2S_MAX; c++ {
+               size := int(c - BLAKE2S_MIN + 1)
+               RegisterHashFunc(c, func(buf []byte, _ int) ([]byte, error) {
+                       return sumBlake2s(buf, size)
+               })
+       }
+       // BLAKE2B
+       for c := uint64(BLAKE2B_MIN); c <= BLAKE2B_MAX; c++ {
+               size := int(c - BLAKE2B_MIN + 1)
+               RegisterHashFunc(c, func(buf []byte, _ int) ([]byte, error) {
+                       return sumBlake2b(buf, size)
+               })
+       }
+}
+
+func init() {
+       registerStdlibHashFuncs()
+       registerNonStdlibHashFuncs()
+}
+
+// RegisterHashFunc adds an entry to the package-level code -> hash func map.
+// The hash function must return at least the requested number of bytes. If it
+// returns more, the hash will be truncated.
+func RegisterHashFunc(code uint64, hashFunc HashFunc) error {
+       if !ValidCode(code) {
+               return fmt.Errorf("code %v not valid", code)
+       }
+
+       _, ok := funcTable[code]
+       if ok {
+               return fmt.Errorf("hash func for code %v already registered", code)
+       }
+
+       funcTable[code] = hashFunc
+       return nil
+}

diff --git a/vendor/github.com/multiformats/go-multihash/sum_test.go b/vendor/github.com/multiformats/go-multihash/sum_test.go
new file mode 100644 (file)
index 0000000..3eb4050
--- /dev/null
+++ b/vendor/github.com/multiformats/go-multihash/sum_test.go
@@ -0,0 +1,175 @@
+package multihash
+
+import (
+       "bytes"
+       "encoding/hex"
+       "fmt"
+       "runtime"
+       "testing"
+)
+
+type SumTestCase struct {
+       code   uint64
+       length int
+       input  string
+       hex    string
+}
+
+var sumTestCases = []SumTestCase{
+       {ID, 3, "foo", "0003666f6f"},
+       {ID, -1, "foofoofoofoofoofoofoofoofoofoofoofoofoofoofoofoo", "0030666f6f666f6f666f6f666f6f666f6f666f6f666f6f666f6f666f6f666f6f666f6f666f6f666f6f666f6f666f6f666f6f"},
+       {SHA1, -1, "foo", "11140beec7b5ea3f0fdbc95d0dd47f3c5bc275da8a33"},
+       {SHA1, 10, "foo", "110a0beec7b5ea3f0fdbc95d"},
+       {SHA2_256, -1, "foo", "12202c26b46b68ffc68ff99b453c1d30413413422d706483bfa0f98a5e886266e7ae"},
+       {SHA2_256, 16, "foo", "12102c26b46b68ffc68ff99b453c1d304134"},
+       {SHA2_512, -1, "foo", "1340f7fbba6e0636f890e56fbbf3283e524c6fa3204ae298382d624741d0dc6638326e282c41be5e4254d8820772c5518a2c5a8c0c7f7eda19594a7eb539453e1ed7"},
+       {SHA2_512, 32, "foo", "1320f7fbba6e0636f890e56fbbf3283e524c6fa3204ae298382d624741d0dc663832"},
+       {SHA3, 32, "foo", "14204bca2b137edc580fe50a88983ef860ebaca36c857b1f492839d6d7392452a63c"},
+       {SHA3_512, 16, "foo", "14104bca2b137edc580fe50a88983ef860eb"},
+       {SHA3_512, -1, "foo", "14404bca2b137edc580fe50a88983ef860ebaca36c857b1f492839d6d7392452a63c82cbebc68e3b70a2a1480b4bb5d437a7cba6ecf9d89f9ff3ccd14cd6146ea7e7"},
+       {SHA3_224, -1, "beep boop", "171c0da73a89549018df311c0a63250e008f7be357f93ba4e582aaea32b8"},
+       {SHA3_224, 16, "beep boop", "17100da73a89549018df311c0a63250e008f"},
+       {SHA3_256, -1, "beep boop", "1620828705da60284b39de02e3599d1f39e6c1df001f5dbf63c9ec2d2c91a95a427f"},
+       {SHA3_256, 16, "beep boop", "1610828705da60284b39de02e3599d1f39e6"},
+       {SHA3_384, -1, "beep boop", "153075a9cff1bcfbe8a7025aa225dd558fb002769d4bf3b67d2aaf180459172208bea989804aefccf060b583e629e5f41e8d"},
+       {SHA3_384, 16, "beep boop", "151075a9cff1bcfbe8a7025aa225dd558fb0"},
+       {DBL_SHA2_256, 32, "foo", "5620c7ade88fc7a21498a6a5e5c385e1f68bed822b72aa63c4a9a48a02c2466ee29e"},
+       {BLAKE2B_MAX, -1, "foo", "c0e40240ca002330e69d3e6b84a46a56a6533fd79d51d97a3bb7cad6c2ff43b354185d6dc1e723fb3db4ae0737e120378424c714bb982d9dc5bbd7a0ab318240ddd18f8d"},
+       {BLAKE2B_MAX, 64, "foo", "c0e40240ca002330e69d3e6b84a46a56a6533fd79d51d97a3bb7cad6c2ff43b354185d6dc1e723fb3db4ae0737e120378424c714bb982d9dc5bbd7a0ab318240ddd18f8d"},
+       {BLAKE2B_MAX - 32, -1, "foo", "a0e40220b8fe9f7f6255a6fa08f668ab632a8d081ad87983c77cd274e48ce450f0b349fd"},
+       {BLAKE2B_MAX - 32, 32, "foo", "a0e40220b8fe9f7f6255a6fa08f668ab632a8d081ad87983c77cd274e48ce450f0b349fd"},
+       {BLAKE2B_MAX - 19, -1, "foo", "ade4022dca82ab956d5885e3f5db10cca94182f01a6ca2c47f9f4228497dcc9f4a0121c725468b852a71ec21fcbeb725df"},
+       {BLAKE2B_MAX - 19, 45, "foo", "ade4022dca82ab956d5885e3f5db10cca94182f01a6ca2c47f9f4228497dcc9f4a0121c725468b852a71ec21fcbeb725df"},
+       {BLAKE2B_MAX - 16, -1, "foo", "b0e40230e629ee880953d32c8877e479e3b4cb0a4c9d5805e2b34c675b5a5863c4ad7d64bb2a9b8257fac9d82d289b3d39eb9cc2"},
+       {BLAKE2B_MAX - 16, 48, "foo", "b0e40230e629ee880953d32c8877e479e3b4cb0a4c9d5805e2b34c675b5a5863c4ad7d64bb2a9b8257fac9d82d289b3d39eb9cc2"},
+       {BLAKE2B_MIN + 19, -1, "foo", "94e40214983ceba2afea8694cc933336b27b907f90c53a88"},
+       {BLAKE2B_MIN + 19, 20, "foo", "94e40214983ceba2afea8694cc933336b27b907f90c53a88"},
+       {BLAKE2B_MIN, -1, "foo", "81e4020152"},
+       {BLAKE2B_MIN, 1, "foo", "81e4020152"},
+       {BLAKE2S_MAX, 32, "foo", "e0e4022008d6cad88075de8f192db097573d0e829411cd91eb6ec65e8fc16c017edfdb74"},
+       {MURMUR3, 4, "beep boop", "2204243ddb9e"},
+       {KECCAK_224, -1, "beep boop", "1a1c2bd72cde2f75e523512999eb7639f17b699efe29bec342f5a0270896"},
+       {KECCAK_256, 32, "foo", "1b2041b1a0649752af1b28b3dc29a1556eee781e4a4c3a1f7f53f90fa834de098c4d"},
+       {KECCAK_384, -1, "beep boop", "1c300e2fcca40e861fc425a2503a65f4a4befab7be7f193e57654ca3713e85262b035e54d5ade93f9632b810ab88b04f7d84"},
+       {KECCAK_512, -1, "beep boop", "1d40e161c54798f78eba3404ac5e7e12d27555b7b810e7fd0db3f25ffa0c785c438331b0fbb6156215f69edf403c642e5280f4521da9bd767296ec81f05100852e78"},
+       {SHAKE_128, 32, "foo", "1820f84e95cb5fbd2038863ab27d3cdeac295ad2d4ab96ad1f4b070c0bf36078ef08"},
+       {SHAKE_256, 64, "foo", "19401af97f7818a28edfdfce5ec66dbdc7e871813816d7d585fe1f12475ded5b6502b7723b74e2ee36f2651a10a8eaca72aa9148c3c761aaceac8f6d6cc64381ed39"},
+}
+
+func TestSum(t *testing.T) {
+
+       for _, tc := range sumTestCases {
+
+               m1, err := FromHexString(tc.hex)
+               if err != nil {
+                       t.Error(err)
+                       continue
+               }
+
+               m2, err := Sum([]byte(tc.input), tc.code, tc.length)
+               if err != nil {
+                       t.Error(tc.code, "sum failed.", err)
+                       continue
+               }
+
+               if !bytes.Equal(m1, m2) {
+                       t.Error(tc.code, Codes[tc.code], "sum failed.", m1, m2)
+                       t.Error(hex.EncodeToString(m2))
+               }
+
+               s1 := m1.HexString()
+               if s1 != tc.hex {
+                       t.Error("hex strings not the same")
+               }
+
+               s2 := m1.B58String()
+               m3, err := FromB58String(s2)
+               if err != nil {
+                       t.Error("failed to decode b58")
+               } else if !bytes.Equal(m3, m1) {
+                       t.Error("b58 failing bytes")
+               } else if s2 != m3.B58String() {
+                       t.Error("b58 failing string")
+               }
+       }
+}
+
+func BenchmarkSum(b *testing.B) {
+       tc := sumTestCases[0]
+       for i := 0; i < b.N; i++ {
+               Sum([]byte(tc.input), tc.code, tc.length)
+       }
+}
+
+func BenchmarkBlake2B(b *testing.B) {
+       sizes := []uint64{128, 129, 130, 255, 256, 257, 386, 512}
+       for _, s := range sizes {
+               func(si uint64) {
+                       b.Run(fmt.Sprintf("blake2b-%d", s), func(b *testing.B) {
+                               arr := []byte("test data for some hashing, this is broken")
+                               b.ResetTimer()
+                               b.ReportAllocs()
+                               for i := 0; i < b.N; i++ {
+                                       m, err := Sum(arr, BLAKE2B_MIN+si/8-1, -1)
+                                       if err != nil {
+                                               b.Fatal(err)
+                                       }
+                                       runtime.KeepAlive(m)
+                               }
+                       })
+               }(s)
+       }
+}
+
+// Test that the identity hash function checks
+// its `length` arguemnt for values that are
+// different to its `data` length.
+func TestSmallerLengthHashID(t *testing.T) {
+
+       data := []byte("Identity hash input data.")
+       dataLength := len(data)
+
+       // Normal case: `length == len(data)`.
+       _, err := sumID(data, dataLength)
+       if err != nil {
+               t.Fatal(err)
+       }
+
+       // Unconstrained length (-1): also allowed.
+       _, err = sumID(data, -1)
+       if err != nil {
+               t.Fatal(err)
+       }
+
+       // Any other variation of those two scenarios should fail.
+       for l := (dataLength - 1); l >= 0; l-- {
+               _, err = sumID(data, l)
+               if err == nil {
+                       t.Fatal(fmt.Sprintf("identity hash of length %d smaller than data length %d didn't fail",
+                               l, dataLength))
+               }
+       }
+}
+
+// Ensure that invalid codecs can't be registered, and existing hash funcs
+// won't be overwritten.
+func TestRegisterHashFunc(t *testing.T) {
+       tests := []struct {
+               code      uint64
+               shouldErr bool
+       }{
+               {9999, true},
+               {SHA1, true},
+       }
+
+       doesNothing := func(data []byte, length int) ([]byte, error) {
+               return []byte{}, nil
+       }
+
+       for _, tt := range tests {
+               err := RegisterHashFunc(tt.code, doesNothing)
+               if err != nil && !tt.shouldErr {
+                       t.Error(err)
+               }
+       }
+}

diff --git a/vendor/github.com/multiformats/go-multihash/test/.gitignore b/vendor/github.com/multiformats/go-multihash/test/.gitignore
new file mode 100644 (file)
index 0000000..27f75ed
--- /dev/null
+++ b/vendor/github.com/multiformats/go-multihash/test/.gitignore
@@ -0,0 +1 @@
+bin/multihash

diff --git a/vendor/github.com/multiformats/go-multihash/test/Makefile b/vendor/github.com/multiformats/go-multihash/test/Makefile
new file mode 100644 (file)
index 0000000..97ec5b6
--- /dev/null
+++ b/vendor/github.com/multiformats/go-multihash/test/Makefile
@@ -0,0 +1,17 @@
+all: deps
+
+deps:
+       cd sharness && make deps
+
+clean:
+       cd sharness && make clean
+
+test: test_expensive
+
+test_expensive:
+       cd sharness && make TEST_EXPENSIVE=1
+
+test_cheap:
+       cd sharness && make
+
+.PHONY: all clean

diff --git a/vendor/github.com/multiformats/go-multihash/test/sharness/.gitignore b/vendor/github.com/multiformats/go-multihash/test/sharness/.gitignore
new file mode 100644 (file)
index 0000000..5e59048
--- /dev/null
+++ b/vendor/github.com/multiformats/go-multihash/test/sharness/.gitignore
@@ -0,0 +1,3 @@
+lib/sharness/
+test-results/
+trash directory.*.sh/

diff --git a/vendor/github.com/multiformats/go-multihash/test/sharness/Makefile b/vendor/github.com/multiformats/go-multihash/test/sharness/Makefile
new file mode 100644 (file)
index 0000000..9d19490
--- /dev/null
+++ b/vendor/github.com/multiformats/go-multihash/test/sharness/Makefile
@@ -0,0 +1,41 @@
+# Run tests
+#
+# Copyright (c) 2014 Christian Couder
+# MIT Licensed; see the LICENSE file in this repository.
+#
+
+# NOTE: run with TEST_VERBOSE=1 for verbose sharness tests.
+
+T = $(sort $(wildcard t[0-9][0-9][0-9][0-9]-*.sh))
+BINS = bin/multihash
+SHARNESS = lib/sharness/sharness.sh
+MULTIHASH_CMD = ../../multihash
+MULTIHASH_ROOT = ../../
+
+all: clean deps $(T) aggregate
+
+clean:
+       @echo "*** $@ ***"
+       -rm -rf test-results
+       -rm -rf $(BINS)
+
+$(T):
+       @echo "*** $@ ***"
+       ./$@
+
+aggregate:
+       @echo "*** $@ ***"
+       lib/test-aggregate-results.sh
+
+deps: $(SHARNESS) $(BINS)
+
+$(SHARNESS):
+       @echo "*** installing $@ ***"
+       lib/install-sharness.sh
+
+bin/multihash: $(MULTIHASH_ROOT)/**/*.go
+       go build -o bin/multihash $(MULTIHASH_CMD)
+
+bins: $(BINS)
+
+.PHONY: all clean $(T) aggregate

diff --git a/vendor/github.com/multiformats/go-multihash/test/sharness/lib/install-sharness.sh b/vendor/github.com/multiformats/go-multihash/test/sharness/lib/install-sharness.sh
new file mode 100644 (file)
index 0000000..d573c40
--- /dev/null
+++ b/vendor/github.com/multiformats/go-multihash/test/sharness/lib/install-sharness.sh
@@ -0,0 +1,26 @@
+#!/bin/sh
+# install sharness.sh
+#
+# Copyright (c) 2014 Juan Batiz-Benet
+# MIT Licensed; see the LICENSE file in this repository.
+#
+
+# settings
+version=50229a79ba22b2f13ccd82451d86570fecbd194c
+urlprefix=https://github.com/mlafeldt/sharness.git
+clonedir=lib
+sharnessdir=sharness
+
+die() {
+  echo >&2 "$@"
+  exit 1
+}
+
+mkdir -p "$clonedir" || die "Could not create '$clonedir' directory"
+cd "$clonedir" || die "Could not cd into '$clonedir' directory"
+
+git clone "$urlprefix" || die "Could not clone '$urlprefix'"
+cd "$sharnessdir" || die "Could not cd into '$sharnessdir' directory"
+git checkout "$version" || die "Could not checkout '$version'"
+
+exit 0

diff --git a/vendor/github.com/multiformats/go-multihash/test/sharness/lib/test-aggregate-results.sh b/vendor/github.com/multiformats/go-multihash/test/sharness/lib/test-aggregate-results.sh
new file mode 100644 (file)
index 0000000..c2ff76c
--- /dev/null
+++ b/vendor/github.com/multiformats/go-multihash/test/sharness/lib/test-aggregate-results.sh
@@ -0,0 +1,17 @@
+#!/bin/sh
+#
+# Script to aggregate results using Sharness
+#
+# Copyright (c) 2014 Christian Couder
+# MIT Licensed; see the LICENSE file in this repository.
+#
+
+SHARNESS_AGGREGATE="lib/sharness/aggregate-results.sh"
+
+test -f "$SHARNESS_AGGREGATE" || {
+       echo >&2 "Cannot find: $SHARNESS_AGGREGATE"
+       echo >&2 "Please check Sharness installation."
+       exit 1
+}
+
+ls test-results/t*-*.sh.*.counts | "$SHARNESS_AGGREGATE"

diff --git a/vendor/github.com/multiformats/go-multihash/test/sharness/lib/test-lib.sh b/vendor/github.com/multiformats/go-multihash/test/sharness/lib/test-lib.sh
new file mode 100644 (file)
index 0000000..988164a
--- /dev/null
+++ b/vendor/github.com/multiformats/go-multihash/test/sharness/lib/test-lib.sh
@@ -0,0 +1,43 @@
+# Test framework for go-ipfs
+#
+# Copyright (c) 2014 Christian Couder
+# MIT Licensed; see the LICENSE file in this repository.
+#
+# We are using sharness (https://github.com/mlafeldt/sharness)
+# which was extracted from the Git test framework.
+
+# Use the multihash tool to test against
+
+# Add current directory to path, for multihash tool.
+PATH=$(pwd)/bin:${PATH}
+
+# Set sharness verbosity. we set the env var directly as
+# it's too late to pass in --verbose, and --verbose is harder
+# to pass through in some cases.
+test "$TEST_VERBOSE" = 1 && verbose=t
+
+# assert the `multihash` we're using is the right one.
+if test `which multihash` != $(pwd)/bin/multihash; then
+       echo >&2 "Cannot find the tests' local multihash tool."
+       echo >&2 "Please check test and multihash tool installation."
+       exit 1
+fi
+
+SHARNESS_LIB="lib/sharness/sharness.sh"
+
+. "$SHARNESS_LIB" || {
+       echo >&2 "Cannot source: $SHARNESS_LIB"
+       echo >&2 "Please check Sharness installation."
+       exit 1
+}
+
+# Please put go-multihash specific shell functions below
+
+for hashbin in sha1sum shasum; do
+       if type "$hashbin"; then
+               export SHASUMBIN="$hashbin" &&
+               test_set_prereq SHASUM &&
+               break
+       fi
+done
+

diff --git a/vendor/github.com/multiformats/go-multihash/test/sharness/t0010-basics.sh b/vendor/github.com/multiformats/go-multihash/test/sharness/t0010-basics.sh
new file mode 100644 (file)
index 0000000..7fc4681
--- /dev/null
+++ b/vendor/github.com/multiformats/go-multihash/test/sharness/t0010-basics.sh
@@ -0,0 +1,25 @@
+#!/bin/sh
+#
+# Copyright (c) 2015 Christian Couder
+# MIT Licensed; see the LICENSE file in this repository.
+#
+
+test_description="Basic tests"
+
+. lib/test-lib.sh
+
+test_expect_success "current dir is writable" '
+       echo "It works!" >test.txt
+'
+
+test_expect_success "multihash is available" '
+       type multihash
+'
+
+test_expect_success "multihash help output looks good" '
+       multihash -h 2>help.txt &&
+       egrep -i "^usage:" help.txt >/dev/null &&
+       egrep -i "multihash .*options.*file" help.txt >/dev/null
+'
+
+test_done

diff --git a/vendor/github.com/multiformats/go-multihash/test/sharness/t0020-sha1.sh b/vendor/github.com/multiformats/go-multihash/test/sharness/t0020-sha1.sh
new file mode 100644 (file)
index 0000000..a5be58b
--- /dev/null
+++ b/vendor/github.com/multiformats/go-multihash/test/sharness/t0020-sha1.sh
@@ -0,0 +1,31 @@
+#!/bin/sh
+#
+# Copyright (c) 2015 Christian Couder
+# MIT Licensed; see the LICENSE file in this repository.
+#
+
+test_description="sha1 tests"
+
+. lib/test-lib.sh
+
+test_expect_success "setup sha1 tests" '
+       echo "Hash me!" >hash_me.txt &&
+       SHA1=bc6f2c3cd945bc754789e50b2f68deee2f421810 &&
+       echo "1114$SHA1" >actual
+'
+
+test_expect_success "'multihash -a=sha1 -e=hex' works" '
+       multihash -a=sha1 -e=hex hash_me.txt >expected
+'
+
+test_expect_success "'multihash -a=sha1 -e=hex' output looks good" '
+       test_cmp expected actual
+'
+
+test_expect_success SHASUM "check hash using shasum" '
+       echo "$SHA1  hash_me.txt" >actual &&
+       $SHASUMBIN hash_me.txt >expected &&
+       test_cmp expected actual
+'
+
+test_done

diff --git a/vendor/github.com/whyrusleeping/tar-utils/.gx/lastpubver b/vendor/github.com/whyrusleeping/tar-utils/.gx/lastpubver
new file mode 100644 (file)
index 0000000..28a2cbd
--- /dev/null
+++ b/vendor/github.com/whyrusleeping/tar-utils/.gx/lastpubver
@@ -0,0 +1 @@
+0.1.0: QmTkC7aeyDyjfdMTCVcG9P485TMJd6foLaLbf11DZ5WrnV

diff --git a/vendor/github.com/whyrusleeping/tar-utils/LICENSE b/vendor/github.com/whyrusleeping/tar-utils/LICENSE
new file mode 100644 (file)
index 0000000..2610033
--- /dev/null
+++ b/vendor/github.com/whyrusleeping/tar-utils/LICENSE
@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2016 Jeromy Johnson
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

diff --git a/vendor/github.com/whyrusleeping/tar-utils/extractor.go b/vendor/github.com/whyrusleeping/tar-utils/extractor.go
new file mode 100644 (file)
index 0000000..0088c71
--- /dev/null
+++ b/vendor/github.com/whyrusleeping/tar-utils/extractor.go
@@ -0,0 +1,217 @@
+package tar
+
+import (
+       "archive/tar"
+       "fmt"
+       "io"
+       "os"
+       gopath "path"
+       fp "path/filepath"
+       "strings"
+)
+
+type Extractor struct {
+       Path     string
+       Progress func(int64) int64
+
+       // SanitizePathFunc can be provided if you wish to inspect and/or modify the source path
+       // returning an error from this function will abort extraction
+       SanitizePathFunc func(path string) (saferPath string, userDefined error)
+
+       // LinkFunc can be provided for user specified handling of filesystem links
+       // returning an error from this function aborts extraction
+       LinkFunc func(Link) error
+}
+
+// Link represents a filesystem link where Name is the link's destination path,
+// Target is what the link actually points to,
+// and Root is the extraction root
+type Link struct {
+       Root, Name, Target string
+}
+
+func (te *Extractor) Extract(reader io.Reader) error {
+       if isNullDevice(te.Path) {
+               return nil
+       }
+
+       tarReader := tar.NewReader(reader)
+
+       // Check if the output path already exists, so we know whether we should
+       // create our output with that name, or if we should put the output inside
+       // a preexisting directory
+       rootExists := true
+       rootIsDir := false
+       if stat, err := os.Stat(te.Path); err != nil && os.IsNotExist(err) {
+               rootExists = false
+       } else if err != nil {
+               return err
+       } else if stat.IsDir() {
+               rootIsDir = true
+       }
+
+       // files come recursively in order (i == 0 is root directory)
+       for i := 0; ; i++ {
+               header, err := tarReader.Next()
+               if err != nil && err != io.EOF {
+                       return err
+               }
+               if header == nil || err == io.EOF {
+                       break
+               }
+
+               switch header.Typeflag {
+               case tar.TypeDir:
+                       if err := te.extractDir(header, i); err != nil {
+                               return err
+                       }
+               case tar.TypeReg:
+                       if err := te.extractFile(header, tarReader, i, rootExists, rootIsDir); err != nil {
+                               return err
+                       }
+               case tar.TypeSymlink:
+                       if err := te.extractSymlink(header); err != nil {
+                               return err
+                       }
+               default:
+                       return fmt.Errorf("unrecognized tar header type: %d", header.Typeflag)
+               }
+       }
+       return nil
+}
+
+// Sanitize sets up the extractor to use built in sanitation functions
+// (Modify paths to be platform legal, symlinks may not escape extraction root)
+// or unsets any previously set sanitation functions on the extractor
+// (no special rules are applied when extracting)
+func (te *Extractor) Sanitize(toggle bool) {
+       if toggle {
+               te.SanitizePathFunc = sanitizePath
+               te.LinkFunc = func(inLink Link) error {
+                       if err := childrenOnly(inLink); err != nil {
+                               return err
+                       }
+                       if err := platformLink(inLink); err != nil {
+                               return err
+                       }
+                       return os.Symlink(inLink.Target, inLink.Name)
+               }
+       } else {
+               te.SanitizePathFunc = nil
+               te.LinkFunc = nil
+       }
+}
+
+// outputPath returns the path at which to place tarPath
+func (te *Extractor) outputPath(tarPath string) (outPath string, err error) {
+       elems := strings.Split(tarPath, "/")    // break into elems
+       elems = elems[1:]                       // remove original root
+       outPath = strings.Join(elems, "/")      // join elems
+       outPath = gopath.Join(te.Path, outPath) // rebase on to extraction target root
+       // sanitize path to be platform legal
+       if te.SanitizePathFunc != nil {
+               outPath, err = te.SanitizePathFunc(outPath)
+       } else {
+               outPath = fp.FromSlash(outPath)
+       }
+       return
+}
+
+func (te *Extractor) extractDir(h *tar.Header, depth int) error {
+       path, err := te.outputPath(h.Name)
+       if err != nil {
+               return err
+       }
+
+       if depth == 0 {
+               // if this is the root directory, use it as the output path for remaining files
+               te.Path = path
+       }
+
+       return os.MkdirAll(path, 0755)
+}
+
+func (te *Extractor) extractSymlink(h *tar.Header) error {
+       path, err := te.outputPath(h.Name)
+       if err != nil {
+               return err
+       }
+
+       if te.LinkFunc != nil {
+               return te.LinkFunc(Link{Root: te.Path, Name: h.Name, Target: h.Linkname})
+       }
+
+       return os.Symlink(h.Linkname, path)
+}
+
+func (te *Extractor) extractFile(h *tar.Header, r *tar.Reader, depth int, rootExists bool, rootIsDir bool) error {
+       path, err := te.outputPath(h.Name)
+       if err != nil {
+               return err
+       }
+
+       if depth == 0 { // if depth is 0, this is the only file (we aren't extracting a directory)
+               if rootExists && rootIsDir {
+                       // putting file inside of a root dir.
+                       fnameo := gopath.Base(h.Name)
+                       fnamen := fp.Base(path)
+                       // add back original name if lost.
+                       if fnameo != fnamen {
+                               path = fp.Join(path, fnameo)
+                       }
+               } // else if old file exists, just overwrite it.
+       }
+
+       file, err := os.Create(path)
+       if err != nil {
+               return err
+       }
+       defer file.Close()
+
+       return copyWithProgress(file, r, te.Progress)
+}
+
+func copyWithProgress(to io.Writer, from io.Reader, cb func(int64) int64) error {
+       buf := make([]byte, 4096)
+       for {
+               n, err := from.Read(buf)
+               if n != 0 {
+                       if cb != nil {
+                               cb(int64(n))
+                       }
+                       _, err2 := to.Write(buf[:n])
+                       if err2 != nil {
+                               return err2
+                       }
+               }
+               if err != nil {
+                       if err == io.EOF {
+                               return nil
+                       }
+                       return err
+               }
+       }
+}
+
+// childrenOnly will return an error if link targets escape their root
+func childrenOnly(inLink Link) error {
+       if fp.IsAbs(inLink.Target) {
+               return fmt.Errorf("Link target %q is an absolute path (forbidden)", inLink.Target)
+       }
+
+       resolvedTarget := fp.Join(inLink.Name, inLink.Target)
+       rel, err := fp.Rel(inLink.Root, resolvedTarget)
+       if err != nil {
+               return err
+       }
+       //disallow symlinks from climbing out of the target root
+       if strings.HasPrefix(rel, "..") {
+               return fmt.Errorf("Symlink target %q escapes root %q", inLink.Target, inLink.Root)
+       }
+       //disallow pointing to your own root from above as well
+       if strings.HasPrefix(resolvedTarget, inLink.Root) {
+               return fmt.Errorf("Symlink target %q escapes and re-enters its own root %q (forbidden)", inLink.Target, inLink.Root)
+       }
+
+       return nil
+}

diff --git a/vendor/github.com/whyrusleeping/tar-utils/package.json b/vendor/github.com/whyrusleeping/tar-utils/package.json
new file mode 100644 (file)
index 0000000..2379cbc
--- /dev/null
+++ b/vendor/github.com/whyrusleeping/tar-utils/package.json
@@ -0,0 +1,16 @@
+{
+  "author": "whyrusleeping",
+  "bugs": {
+    "url": "https://github.com/whyrusleeping/tar-utils"
+  },
+  "gx": {
+    "dvcsimport": "github.com/whyrusleeping/tar-utils"
+  },
+  "gxVersion": "0.12.1",
+  "language": "go",
+  "license": "MIT",
+  "name": "tar-utils",
+  "releaseCmd": "git commit -a -m \"gx publish $VERSION\"",
+  "version": "0.1.0"
+}
+

diff --git a/vendor/github.com/whyrusleeping/tar-utils/sanitize.go b/vendor/github.com/whyrusleeping/tar-utils/sanitize.go
new file mode 100644 (file)
index 0000000..c54c7f3
--- /dev/null
+++ b/vendor/github.com/whyrusleeping/tar-utils/sanitize.go
@@ -0,0 +1,19 @@
+// +build !windows
+
+package tar
+
+import (
+       "os"
+)
+
+func isNullDevice(path string) bool {
+       return path == os.DevNull
+}
+
+func sanitizePath(path string) (string, error) {
+       return path, nil
+}
+
+func platformLink(inLink Link) error {
+       return nil
+}

diff --git a/vendor/github.com/whyrusleeping/tar-utils/sanitize_windows.go b/vendor/github.com/whyrusleeping/tar-utils/sanitize_windows.go
new file mode 100644 (file)
index 0000000..36fbe52
--- /dev/null
+++ b/vendor/github.com/whyrusleeping/tar-utils/sanitize_windows.go
@@ -0,0 +1,83 @@
+package tar
+
+import (
+       "fmt"
+       "net/url"
+       "os"
+       "path/filepath"
+       "regexp"
+       "strings"
+)
+
+//https://msdn.microsoft.com/en-us/library/windows/desktop/aa365247(v=vs.85).aspx
+var reservedNames = [...]string{"CON", "PRN", "AUX", "NUL", "COM1", "COM2", "COM3", "COM4", "COM5", "COM6", "COM7", "COM8", "COM9", "LPT1", "LPT2", "LPT3", "LPT4", "LPT5", "LPT6", "LPT7", "LPT8", "LPT9"}
+var reservedCharsRegex *regexp.Regexp
+
+const reservedCharsStr = `[<>:"\\|?*]`                    //NOTE: `/` is not included as it is our standard path separator
+const reservedNamesRegexFmt = `(?i)^(%s)(?: *%s*)?[^\w ]` // $reservedName, $reservedCharsStr
+
+func init() {
+       reservedCharsRegex = regexp.MustCompile(reservedCharsStr)
+}
+
+func isNullDevice(path string) bool {
+       if len(path) != 3 {
+               return false
+       }
+       if path[0]|0x20 != 'n' {
+               return false
+       }
+       if path[1]|0x20 != 'u' {
+               return false
+       }
+       if path[2]|0x20 != 'l' {
+               return false
+       }
+       return true
+}
+
+func sanitizePath(path string) (string, error) {
+       pathElements := strings.Split(path, "/")
+
+       //first pass: strip illegal tail & prefix reserved names `CON .` -> `_CON`
+       for pi := range pathElements {
+               pathElements[pi] = strings.TrimRight(pathElements[pi], ". ") //MSDN: Do not end a file or directory name with a space or a period
+
+               for _, rn := range reservedNames {
+                       re, _ := regexp.Compile(fmt.Sprintf(reservedNamesRegexFmt, rn, reservedCharsStr)) //no err, regex is a constant with guaranteed constant arguments
+                       if matched := re.MatchString(pathElements[pi]); matched {
+                               pathElements[pi] = "_" + pathElements[pi]
+                               break
+                       }
+               }
+       }
+
+       //second pass: scan and encode reserved characters ? -> %3F
+       res := strings.Join(pathElements, `/`) //intentionally avoiding [file]path.Clean() being called with Join(); we do our own filtering first
+       illegalIndices := reservedCharsRegex.FindAllStringIndex(res, -1)
+
+       if illegalIndices != nil {
+               var lastIndex int
+               var builder strings.Builder
+               allocAssist := (len(res) - len(illegalIndices)) + (len(illegalIndices) * 3) //3 = encoded length
+               builder.Grow(allocAssist)
+
+               for _, si := range illegalIndices {
+                       builder.WriteString(res[lastIndex:si[0]])              //append up to problem char
+                       builder.WriteString(url.QueryEscape(res[si[0]:si[1]])) //escape and append problem char
+                       lastIndex = si[1]
+               }
+               builder.WriteString(res[lastIndex:]) //append remainder
+               res = builder.String()
+       }
+
+       return filepath.FromSlash(res), nil
+}
+
+func platformLink(inLink Link) error {
+       if strings.HasPrefix(inLink.Target, string(os.PathSeparator)) || strings.HasPrefix(inLink.Target, "/") {
+               return fmt.Errorf("Link target %q is relative to drive root (forbidden)", inLink.Target)
+       }
+
+       return nil
+}