perso/syncthing-arm
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity

vendor: Update github.com/gogo/protobuf

Browse Source 
Also tweaks the proto definitions:

 - [packed=false] on the block_indexes field to retain compat with
   v0.14.16 and earlier.

 - Uses the vendored protobuf package in include paths.

And, "build.go setup" will install the vendored protoc-gen-gogofast.
This should ensure that a proto rebuild isn't so dependent on whatever
version of the compiler and package the developer has installed...

GitHub-Pull-Request: https://github.com/syncthing/syncthing/pull/3864
This commit is contained in:
Jakob Borg
2017-01-03 00:16:21 +00:00
committed by Audrius Butkevicius
parent 4fb9c143ac
commit 987718baf8
603 changed files with 340684 additions and 62506 deletions
Download Patch File Download Diff File Expand all files Collapse all files

40
vendor/github.com/gogo/protobuf/test/castvalue/Makefile generated vendored Normal file
View File

@@ -0,0 +1,40 @@
# 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.
regenerate:
rm -rf combos
go install github.com/gogo/protobuf/protoc-gen-combo
go install github.com/gogo/protobuf/protoc-gen-gogo
protoc-min-version --version="3.0.0" --gogo_out=. --proto_path=../../../../../:../../protobuf/:. castvalue.proto
protoc-gen-combo --default=false --version="3.0.0" --gogo_out=. --proto_path=../../../../../:../../protobuf/:. castvalue.proto
cp mytypes.go ./combos/both/ || true
cp mytypes.go ./combos/marshaler/ || true
cp mytypes.go ./combos/unmarshaler/ || true
cp mytypes.go ./combos/unsafeboth/ || true
cp mytypes.go ./combos/unsafemarshaler/ || true
cp mytypes.go ./combos/unsafeunmarshaler/ || true

539
vendor/github.com/gogo/protobuf/test/castvalue/castvalue.pb.go generated vendored
View File

@@ -38,11 +38,13 @@ 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.
const _ = proto.GoGoProtoPackageIsVersion1
// 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 Castaway struct {
CastMapValueMessage map[int32]MyWilson `protobuf:"bytes,1,rep,name=CastMapValueMessage,json=castMapValueMessage,castvalue=MyWilson,castvaluetype=castvalue.Wilson" json:"CastMapValueMessage" protobuf_key:"varint,1,opt,name=key" protobuf_val:"bytes,2,opt,name=value"`
CastMapValueMessageNullable map[int32]*MyWilson `protobuf:"bytes,2,rep,name=CastMapValueMessageNullable,json=castMapValueMessageNullable,castvalue=MyWilson,castvaluetype=castvalue.Wilson" json:"CastMapValueMessageNullable,omitempty" protobuf_key:"varint,1,opt,name=key" protobuf_val:"bytes,2,opt,name=value"`
CastMapValueMessage map[int32]MyWilson `protobuf:"bytes,1,rep,name=CastMapValueMessage,castvalue=MyWilson,castvaluetype=castvalue.Wilson" json:"CastMapValueMessage" protobuf_key:"varint,1,opt,name=key" protobuf_val:"bytes,2,opt,name=value"`
CastMapValueMessageNullable map[int32]*MyWilson `protobuf:"bytes,2,rep,name=CastMapValueMessageNullable,castvalue=MyWilson,castvaluetype=castvalue.Wilson" json:"CastMapValueMessageNullable,omitempty" protobuf_key:"varint,1,opt,name=key" protobuf_val:"bytes,2,opt,name=value"`
XXX_unrecognized []byte `json:"-"`
}
@@ -51,7 +53,7 @@ func (*Castaway) ProtoMessage() {}
func (*Castaway) Descriptor() ([]byte, []int) { return fileDescriptorCastvalue, []int{0} }
type Wilson struct {
Int64 *int64 `protobuf:"varint,1,opt,name=Int64,json=int64" json:"Int64,omitempty"`
Int64 *int64 `protobuf:"varint,1,opt,name=Int64" json:"Int64,omitempty"`
XXX_unrecognized []byte `json:"-"`
}
@@ -72,224 +74,232 @@ func (this *Wilson) Description() (desc *github_com_gogo_protobuf_protoc_gen_gog
func CastvalueDescription() (desc *github_com_gogo_protobuf_protoc_gen_gogo_descriptor.FileDescriptorSet) {
d := &github_com_gogo_protobuf_protoc_gen_gogo_descriptor.FileDescriptorSet{}
var gzipped = []byte{
// 3462 bytes of a gzipped FileDescriptorSet
0x1f, 0x8b, 0x08, 0x00, 0x00, 0x09, 0x6e, 0x88, 0x02, 0xff, 0xcc, 0x5a, 0x6b, 0x6c, 0x23, 0x57,
0xf5, 0x5f, 0xc7, 0x76, 0x62, 0x1f, 0x3b, 0x8e, 0x33, 0x49, 0x77, 0xbd, 0xd9, 0x76, 0x1f, 0xee,
0x63, 0xb7, 0xdb, 0x36, 0xdb, 0xff, 0xfe, 0xfb, 0xd8, 0xba, 0xff, 0x7f, 0xab, 0x3c, 0xbc, 0xa9,
0x57, 0x79, 0x31, 0x89, 0xdb, 0xdd, 0xf2, 0x61, 0x34, 0x19, 0xdf, 0x38, 0xde, 0x1d, 0xcf, 0x18,
0xcf, 0x78, 0x77, 0xd3, 0x4f, 0x45, 0x2d, 0xa0, 0x82, 0x78, 0x23, 0xd1, 0x37, 0xb4, 0x12, 0xb4,
0x94, 0x57, 0xcb, 0x4b, 0x88, 0x4f, 0x45, 0xa8, 0xd0, 0x4f, 0x08, 0xf8, 0xc4, 0x07, 0x04, 0x6d,
0xa9, 0x44, 0x81, 0x02, 0x45, 0x5a, 0x89, 0x4a, 0x15, 0x12, 0xe7, 0xbe, 0xc6, 0x33, 0xb6, 0x93,
0x71, 0x8a, 0x4a, 0x89, 0x34, 0xca, 0xcc, 0xb9, 0xe7, 0xf7, 0x9b, 0x7b, 0xcf, 0x3d, 0xf7, 0x9c,
0x73, 0xef, 0x18, 0x7e, 0xf2, 0x3f, 0x70, 0xb0, 0x6a, 0xdb, 0x55, 0x93, 0x1c, 0x6b, 0x34, 0x6d,
0xd7, 0x5e, 0x6b, 0xad, 0x1f, 0xab, 0x10, 0xc7, 0x68, 0xd6, 0x1a, 0xae, 0xdd, 0x9c, 0x64, 0x32,
0x65, 0x84, 0x6b, 0x4c, 0x4a, 0x8d, 0xfc, 0x02, 0x8c, 0x9e, 0xac, 0x99, 0x64, 0xd6, 0x53, 0x5c,
0x21, 0xae, 0x72, 0x02, 0x62, 0xeb, 0x28, 0xcc, 0x45, 0x0e, 0x46, 0x8f, 0xa4, 0x8e, 0x5f, 0x35,
0xd9, 0x01, 0x9a, 0x0c, 0x22, 0x96, 0xa9, 0x58, 0x65, 0x88, 0xfc, 0xeb, 0x31, 0x18, 0xeb, 0xd1,
0xaa, 0x28, 0x10, 0xb3, 0xf4, 0x3a, 0x65, 0x8c, 0x1c, 0x49, 0xaa, 0xec, 0x5e, 0xc9, 0xc1, 0x50,
0x43, 0x37, 0xce, 0xe9, 0x55, 0x92, 0x1b, 0x60, 0x62, 0xf9, 0xa8, 0xec, 0x07, 0xa8, 0x90, 0x06,
0xb1, 0x2a, 0xc4, 0x32, 0x36, 0x73, 0x51, 0xec, 0x45, 0x52, 0xf5, 0x49, 0x94, 0xeb, 0x60, 0xb4,
0xd1, 0x5a, 0x33, 0x6b, 0x86, 0xe6, 0x53, 0x03, 0x54, 0x8b, 0xab, 0x59, 0xde, 0x30, 0xdb, 0x56,
0x3e, 0x0c, 0x23, 0x17, 0x88, 0x7e, 0xce, 0xaf, 0x9a, 0x62, 0xaa, 0x19, 0x2a, 0xf6, 0x29, 0xce,
0x40, 0xba, 0x4e, 0x1c, 0x07, 0x3b, 0xa0, 0xb9, 0x9b, 0x0d, 0x92, 0x8b, 0xb1, 0xd1, 0x1f, 0xec,
0x1a, 0x7d, 0xe7, 0xc8, 0x53, 0x02, 0xb5, 0x8a, 0x20, 0x65, 0x0a, 0x92, 0xc4, 0x6a, 0xd5, 0x39,
0x43, 0x7c, 0x0b, 0xfb, 0x15, 0x51, 0xa3, 0x93, 0x25, 0x41, 0x61, 0x82, 0x62, 0xc8, 0x21, 0xcd,
0xf3, 0x35, 0x83, 0xe4, 0x06, 0x19, 0xc1, 0xe1, 0x2e, 0x82, 0x15, 0xde, 0xde, 0xc9, 0x21, 0x71,
0x38, 0x94, 0x24, 0xb9, 0xe8, 0x12, 0xcb, 0xa9, 0xd9, 0x56, 0x6e, 0x88, 0x91, 0x5c, 0xdd, 0x63,
0x16, 0x89, 0x59, 0xe9, 0xa4, 0x68, 0xe3, 0x94, 0x5b, 0x60, 0xc8, 0x6e, 0xb8, 0x78, 0xe7, 0xe4,
0x12, 0x38, 0x3f, 0xa9, 0xe3, 0x97, 0xf7, 0x74, 0x84, 0x25, 0xae, 0xa3, 0x4a, 0x65, 0xa5, 0x04,
0x59, 0xc7, 0x6e, 0x35, 0x0d, 0xa2, 0x19, 0x76, 0x85, 0x68, 0x35, 0x6b, 0xdd, 0xce, 0x25, 0x19,
0xc1, 0x81, 0xee, 0x81, 0x30, 0xc5, 0x19, 0xd4, 0x2b, 0xa1, 0x9a, 0x9a, 0x71, 0x02, 0xcf, 0xca,
0x6e, 0x18, 0x74, 0x36, 0x2d, 0x57, 0xbf, 0x98, 0x4b, 0x33, 0x0f, 0x11, 0x4f, 0xf9, 0x7f, 0xc4,
0x61, 0xa4, 0x1f, 0x17, 0xbb, 0x1d, 0xe2, 0xeb, 0x74, 0x94, 0xe8, 0x60, 0x3b, 0xb0, 0x01, 0xc7,
0x04, 0x8d, 0x38, 0xf8, 0x2e, 0x8d, 0x38, 0x05, 0x29, 0x8b, 0x38, 0x2e, 0xa9, 0x70, 0x8f, 0x88,
0xf6, 0xe9, 0x53, 0xc0, 0x41, 0xdd, 0x2e, 0x15, 0x7b, 0x57, 0x2e, 0x75, 0x1a, 0x46, 0xbc, 0x2e,
0x69, 0x4d, 0xdd, 0xaa, 0x4a, 0xdf, 0x3c, 0x16, 0xd6, 0x93, 0xc9, 0xa2, 0xc4, 0xa9, 0x14, 0xa6,
0x66, 0x48, 0xe0, 0x59, 0x99, 0x05, 0xb0, 0x2d, 0x62, 0xaf, 0xe3, 0xf2, 0x32, 0x4c, 0xf4, 0x93,
0xde, 0x56, 0x5a, 0xa2, 0x2a, 0x5d, 0x56, 0xb2, 0xb9, 0xd4, 0x30, 0x95, 0xdb, 0xda, 0xae, 0x36,
0xb4, 0x85, 0xa7, 0x2c, 0xf0, 0x45, 0xd6, 0xe5, 0x6d, 0x65, 0xc8, 0x34, 0x09, 0xf5, 0x7b, 0x34,
0x31, 0x1f, 0x59, 0x92, 0x75, 0x62, 0x32, 0x74, 0x64, 0xaa, 0x80, 0xf1, 0x81, 0x0d, 0x37, 0xfd,
0x8f, 0xca, 0x95, 0xe0, 0x09, 0x34, 0xe6, 0x56, 0xc0, 0xa2, 0x50, 0x5a, 0x0a, 0x17, 0x51, 0x36,
0x71, 0x02, 0x32, 0x41, 0xf3, 0x28, 0xe3, 0x10, 0x77, 0x5c, 0xbd, 0xe9, 0x32, 0x2f, 0x8c, 0xab,
0xfc, 0x41, 0xc9, 0x42, 0x14, 0x83, 0x0c, 0x8b, 0x72, 0x71, 0x95, 0xde, 0x4e, 0xdc, 0x0a, 0xc3,
0x81, 0xd7, 0xf7, 0x0b, 0xcc, 0x3f, 0x3c, 0x08, 0xe3, 0xbd, 0x7c, 0xae, 0xa7, 0xfb, 0xe3, 0xf2,
0x41, 0x0f, 0x58, 0x23, 0x4d, 0xf4, 0x3b, 0xca, 0x20, 0x9e, 0xd0, 0xa3, 0xe2, 0xa6, 0xbe, 0x46,
0x4c, 0xf4, 0xa6, 0xc8, 0x91, 0xcc, 0xf1, 0xeb, 0xfa, 0xf2, 0xea, 0xc9, 0x79, 0x0a, 0x51, 0x39,
0x52, 0xb9, 0x03, 0x62, 0x22, 0xc4, 0x51, 0x86, 0xa3, 0xfd, 0x31, 0x50, 0x5f, 0x54, 0x19, 0x4e,
0xd9, 0x07, 0x49, 0xfa, 0x9f, 0xdb, 0x76, 0x90, 0xf5, 0x39, 0x41, 0x05, 0xd4, 0xae, 0xca, 0x04,
0x24, 0x98, 0x9b, 0x55, 0x88, 0x4c, 0x0d, 0xde, 0x33, 0x9d, 0x98, 0x0a, 0x59, 0xd7, 0x5b, 0xa6,
0xab, 0x9d, 0xd7, 0xcd, 0x16, 0x61, 0x0e, 0x83, 0x13, 0x23, 0x84, 0x77, 0x53, 0x99, 0x72, 0x00,
0x52, 0xdc, 0x2b, 0x6b, 0x88, 0xb9, 0xc8, 0xa2, 0x4f, 0x5c, 0xe5, 0x8e, 0x5a, 0xa2, 0x12, 0xfa,
0xfa, 0xb3, 0x0e, 0xae, 0x05, 0x31, 0xb5, 0xec, 0x15, 0x54, 0xc0, 0x5e, 0x7f, 0x6b, 0x67, 0xe0,
0xbb, 0xa2, 0xf7, 0xf0, 0x3a, 0x7d, 0x31, 0xff, 0x83, 0x01, 0x88, 0xb1, 0xf5, 0x36, 0x02, 0xa9,
0xd5, 0x33, 0xcb, 0x45, 0x6d, 0x76, 0xa9, 0x3c, 0x3d, 0x5f, 0xcc, 0x46, 0x94, 0x0c, 0x00, 0x13,
0x9c, 0x9c, 0x5f, 0x9a, 0x5a, 0xcd, 0x0e, 0x78, 0xcf, 0xa5, 0xc5, 0xd5, 0x5b, 0x6e, 0xca, 0x46,
0x3d, 0x40, 0x99, 0x0b, 0x62, 0x7e, 0x85, 0xff, 0x3d, 0x9e, 0x8d, 0xa3, 0x27, 0xa4, 0x39, 0x41,
0xe9, 0x74, 0x71, 0x16, 0x35, 0x06, 0x83, 0x12, 0xd4, 0x19, 0x52, 0x86, 0x21, 0xc9, 0x24, 0xd3,
0x4b, 0x4b, 0xf3, 0xd9, 0x84, 0xc7, 0xb9, 0xb2, 0xaa, 0x96, 0x16, 0xe7, 0xb2, 0x49, 0x8f, 0x73,
0x4e, 0x5d, 0x2a, 0x2f, 0x67, 0xc1, 0x63, 0x58, 0x28, 0xae, 0xac, 0x4c, 0xcd, 0x15, 0xb3, 0x29,
0x4f, 0x63, 0xfa, 0xcc, 0x6a, 0x71, 0x25, 0x9b, 0x0e, 0x74, 0x0b, 0x5f, 0x31, 0xec, 0xbd, 0xa2,
0xb8, 0x58, 0x5e, 0xc8, 0x66, 0x94, 0x51, 0x18, 0xe6, 0xaf, 0x90, 0x9d, 0x18, 0xe9, 0x10, 0x61,
0x4f, 0xb3, 0xed, 0x8e, 0x70, 0x96, 0xd1, 0x80, 0x00, 0x35, 0x94, 0xfc, 0x0c, 0xc4, 0x99, 0x77,
0xa1, 0x17, 0x67, 0xe6, 0xa7, 0xa6, 0x8b, 0xf3, 0xda, 0xd2, 0xf2, 0x6a, 0x69, 0x69, 0x71, 0x6a,
0x1e, 0x6d, 0xe7, 0xc9, 0xd4, 0xe2, 0x07, 0xca, 0x25, 0xb5, 0x38, 0x8b, 0xf6, 0xf3, 0xc9, 0x96,
0x8b, 0x53, 0xab, 0x28, 0x8b, 0xe6, 0x8f, 0xc2, 0x78, 0xaf, 0x38, 0xd3, 0x6b, 0x65, 0xe4, 0x9f,
0x8e, 0xc0, 0x58, 0x8f, 0x90, 0xd9, 0x73, 0x15, 0xdd, 0x09, 0x71, 0xee, 0x69, 0x3c, 0x89, 0x5c,
0xdb, 0x33, 0xf6, 0x32, 0xbf, 0xeb, 0x4a, 0x24, 0x0c, 0xe7, 0x4f, 0xa4, 0xd1, 0x2d, 0x12, 0x29,
0xa5, 0xe8, 0x72, 0xa7, 0x07, 0x22, 0x90, 0xdb, 0x8a, 0x3b, 0x64, 0xbd, 0x0f, 0x04, 0xd6, 0xfb,
0xed, 0x9d, 0x1d, 0x38, 0xb4, 0xf5, 0x18, 0xba, 0x7a, 0xf1, 0x4c, 0x04, 0x76, 0xf7, 0xae, 0x37,
0x7a, 0xf6, 0xe1, 0x0e, 0x18, 0xac, 0x13, 0x77, 0xc3, 0x96, 0x39, 0xf7, 0x9a, 0x1e, 0x91, 0x9c,
0x36, 0x77, 0xda, 0x4a, 0xa0, 0xfc, 0xa9, 0x20, 0xba, 0x55, 0xd1, 0xc0, 0x7b, 0xd3, 0xd5, 0xd3,
0x87, 0x06, 0xe0, 0xb2, 0x9e, 0xe4, 0x3d, 0x3b, 0x7a, 0x05, 0x40, 0xcd, 0x6a, 0xb4, 0x5c, 0x9e,
0x57, 0x79, 0x98, 0x49, 0x32, 0x09, 0x5b, 0xc2, 0x34, 0x84, 0xb4, 0x5c, 0xaf, 0x3d, 0xca, 0xda,
0x81, 0x8b, 0x98, 0xc2, 0x89, 0x76, 0x47, 0x63, 0xac, 0xa3, 0xfb, 0xb7, 0x18, 0x69, 0x57, 0xca,
0xba, 0x11, 0xb2, 0x86, 0x59, 0x23, 0x96, 0xab, 0x39, 0x6e, 0x93, 0xe8, 0xf5, 0x9a, 0x55, 0x65,
0x71, 0x34, 0x51, 0x88, 0xaf, 0xeb, 0xa6, 0x43, 0xd4, 0x11, 0xde, 0xbc, 0x22, 0x5b, 0x29, 0x82,
0x25, 0x8b, 0xa6, 0x0f, 0x31, 0x18, 0x40, 0xf0, 0x66, 0x0f, 0x91, 0xff, 0xd5, 0x10, 0xa4, 0x7c,
0xd5, 0x99, 0x72, 0x08, 0xd2, 0x67, 0xf5, 0xf3, 0xba, 0x26, 0x2b, 0x6e, 0x6e, 0x89, 0x14, 0x95,
0x2d, 0x8b, 0xaa, 0xfb, 0x46, 0x18, 0x67, 0x2a, 0x38, 0x46, 0x7c, 0x91, 0x61, 0xea, 0x8e, 0xc3,
0x8c, 0x96, 0x60, 0xaa, 0x0a, 0x6d, 0x5b, 0xa2, 0x4d, 0x33, 0xb2, 0x45, 0xb9, 0x19, 0xc6, 0x18,
0xa2, 0x8e, 0x81, 0xb7, 0xd6, 0x30, 0x89, 0x46, 0xf7, 0x00, 0x0e, 0x8b, 0xa7, 0x5e, 0xcf, 0x46,
0xa9, 0xc6, 0x82, 0x50, 0xa0, 0x3d, 0x72, 0x94, 0x39, 0xb8, 0x82, 0xc1, 0xaa, 0xc4, 0x22, 0x4d,
0xdd, 0x25, 0x1a, 0xf9, 0x50, 0x0b, 0x75, 0x35, 0xdd, 0xaa, 0x68, 0x1b, 0xba, 0xb3, 0x91, 0x1b,
0xf7, 0x13, 0xec, 0xa5, 0xba, 0x73, 0x42, 0xb5, 0xc8, 0x34, 0xa7, 0xac, 0xca, 0x5d, 0xa8, 0xa7,
0x14, 0x60, 0x37, 0x23, 0x42, 0xa3, 0xe0, 0x98, 0x35, 0x63, 0x83, 0x18, 0xe7, 0xb4, 0x96, 0xbb,
0x7e, 0x22, 0xb7, 0xcf, 0xcf, 0xc0, 0x3a, 0xb9, 0xc2, 0x74, 0x66, 0xa8, 0x4a, 0x19, 0x35, 0x94,
0x15, 0x48, 0xd3, 0xf9, 0xa8, 0xd7, 0xee, 0xc3, 0x6e, 0xdb, 0x4d, 0x96, 0x23, 0x32, 0x3d, 0x16,
0xb7, 0xcf, 0x88, 0x93, 0x4b, 0x02, 0xb0, 0x80, 0xf5, 0x69, 0x21, 0xbe, 0xb2, 0x5c, 0x2c, 0xce,
0xaa, 0x29, 0xc9, 0x72, 0xd2, 0x6e, 0x52, 0x9f, 0xaa, 0xda, 0x9e, 0x8d, 0x53, 0xdc, 0xa7, 0xaa,
0xb6, 0xb4, 0x30, 0xda, 0xcb, 0x30, 0xf8, 0xb0, 0x71, 0xef, 0x22, 0x8a, 0x75, 0x27, 0x97, 0x0d,
0xd8, 0xcb, 0x30, 0xe6, 0xb8, 0x82, 0x70, 0x73, 0x07, 0x97, 0xc4, 0x65, 0x6d, 0x7b, 0xf9, 0x81,
0xa3, 0x5d, 0xa3, 0xec, 0x84, 0xe2, 0x1b, 0x1b, 0x9b, 0xdd, 0x40, 0x25, 0xf0, 0xc6, 0xc6, 0x66,
0x27, 0xec, 0x6a, 0xb6, 0x01, 0x6b, 0x12, 0x03, 0x4d, 0x5e, 0xc9, 0xed, 0xf1, 0x6b, 0xfb, 0x1a,
0x94, 0x63, 0xe8, 0xc8, 0x86, 0x46, 0x2c, 0x7d, 0x0d, 0xe7, 0x5e, 0x6f, 0xe2, 0x8d, 0x93, 0x3b,
0xe0, 0x57, 0xce, 0x18, 0x46, 0x91, 0xb5, 0x4e, 0xb1, 0x46, 0xe5, 0x28, 0x8c, 0xda, 0x6b, 0x67,
0x0d, 0xee, 0x5c, 0x1a, 0xf2, 0xac, 0xd7, 0x2e, 0xe6, 0xae, 0x62, 0x66, 0x1a, 0xa1, 0x0d, 0xcc,
0xb5, 0x96, 0x99, 0x58, 0xb9, 0x16, 0xc9, 0x9d, 0x0d, 0xbd, 0xd9, 0x60, 0x49, 0xda, 0x41, 0xa3,
0x92, 0xdc, 0xd5, 0x5c, 0x95, 0xcb, 0x17, 0xa5, 0x58, 0x29, 0xc2, 0x01, 0x3a, 0x78, 0x4b, 0xb7,
0x6c, 0xad, 0xe5, 0x10, 0xad, 0xdd, 0x45, 0x6f, 0x2e, 0xae, 0xa1, 0xdd, 0x52, 0x2f, 0x97, 0x6a,
0x65, 0x07, 0x83, 0x99, 0x54, 0x92, 0xd3, 0x73, 0x1a, 0xc6, 0x5b, 0x56, 0xcd, 0x42, 0x17, 0xc7,
0x16, 0x0a, 0xe6, 0x0b, 0x36, 0xf7, 0x87, 0xa1, 0x2d, 0x8a, 0xee, 0xb2, 0x5f, 0x9b, 0x3b, 0x89,
0x3a, 0xd6, 0xea, 0x16, 0xe6, 0x0b, 0x90, 0xf6, 0xfb, 0x8e, 0x92, 0x04, 0xee, 0x3d, 0x98, 0xdd,
0x30, 0xa3, 0xce, 0x2c, 0xcd, 0xd2, 0x5c, 0x78, 0x6f, 0x11, 0x13, 0x1b, 0xe6, 0xe4, 0xf9, 0xd2,
0x6a, 0x51, 0x53, 0xcb, 0x8b, 0xab, 0xa5, 0x85, 0x62, 0x36, 0x7a, 0x34, 0x99, 0x78, 0x63, 0x28,
0x7b, 0x3f, 0xfe, 0x0d, 0xe4, 0x5f, 0x1a, 0x80, 0x4c, 0xb0, 0x0e, 0x56, 0xfe, 0x0f, 0xf6, 0xc8,
0x4d, 0xab, 0x43, 0x5c, 0xed, 0x42, 0xad, 0xc9, 0xdc, 0xb9, 0xae, 0xf3, 0x4a, 0xd2, 0x9b, 0x89,
0x71, 0xa1, 0x85, 0xdb, 0xfb, 0x7b, 0x50, 0xe7, 0x24, 0x53, 0x51, 0xe6, 0xe1, 0x00, 0x9a, 0x0c,
0x6b, 0x4d, 0xab, 0xa2, 0x37, 0x2b, 0x5a, 0xfb, 0xb8, 0x40, 0xd3, 0x0d, 0xf4, 0x03, 0xc7, 0xe6,
0x99, 0xc4, 0x63, 0xb9, 0xdc, 0xb2, 0x57, 0x84, 0x72, 0x3b, 0xc4, 0x4e, 0x09, 0xd5, 0x0e, 0xaf,
0x89, 0x6e, 0xe5, 0x35, 0x58, 0x7b, 0xd5, 0xf5, 0x06, 0xba, 0x8d, 0xdb, 0xdc, 0x64, 0xd5, 0x5b,
0x42, 0x4d, 0xa0, 0xa0, 0x48, 0x9f, 0xdf, 0xbb, 0x39, 0xf0, 0xdb, 0xf1, 0x37, 0x51, 0x48, 0xfb,
0x2b, 0x38, 0x5a, 0x10, 0x1b, 0x2c, 0xcc, 0x47, 0x58, 0x14, 0xb8, 0x72, 0xdb, 0x7a, 0x6f, 0x72,
0x86, 0xc6, 0xff, 0xc2, 0x20, 0xaf, 0xab, 0x54, 0x8e, 0xa4, 0xb9, 0x97, 0xfa, 0x1a, 0xe1, 0xd5,
0x7a, 0x42, 0x15, 0x4f, 0x18, 0xec, 0x06, 0xcf, 0x3a, 0x8c, 0x7b, 0x90, 0x71, 0x5f, 0xb5, 0x3d,
0xf7, 0xa9, 0x15, 0x46, 0x9e, 0x3c, 0xb5, 0xa2, 0x2d, 0x2e, 0xa9, 0x0b, 0x53, 0xf3, 0xaa, 0x80,
0x2b, 0x7b, 0x21, 0x66, 0xea, 0xf7, 0x6d, 0x06, 0x33, 0x05, 0x13, 0xf5, 0x6b, 0x78, 0x64, 0xa0,
0x47, 0x1e, 0xc1, 0xf8, 0xcc, 0x44, 0xef, 0xa1, 0xeb, 0x1f, 0x83, 0x38, 0xb3, 0x97, 0x02, 0x20,
0x2c, 0x96, 0xdd, 0xa5, 0x24, 0x20, 0x36, 0xb3, 0xa4, 0x52, 0xf7, 0x47, 0x7f, 0xe7, 0x52, 0x6d,
0xb9, 0x54, 0x9c, 0xc1, 0x15, 0x90, 0xbf, 0x19, 0x06, 0xb9, 0x11, 0xe8, 0xd2, 0xf0, 0xcc, 0x80,
0x20, 0xfe, 0x28, 0x38, 0x22, 0xb2, 0xb5, 0xbc, 0x30, 0x5d, 0x54, 0xb3, 0x03, 0xfe, 0xe9, 0xfd,
0x51, 0x04, 0x52, 0xbe, 0x82, 0x8a, 0xa6, 0x72, 0xdd, 0x34, 0xed, 0x0b, 0x9a, 0x6e, 0xd6, 0x30,
0x42, 0xf1, 0xf9, 0x01, 0x26, 0x9a, 0xa2, 0x92, 0x7e, 0xed, 0xf7, 0x1f, 0xf1, 0xcd, 0x27, 0x23,
0x90, 0xed, 0x2c, 0xc6, 0x3a, 0x3a, 0x18, 0x79, 0x5f, 0x3b, 0xf8, 0x78, 0x04, 0x32, 0xc1, 0x0a,
0xac, 0xa3, 0x7b, 0x87, 0xde, 0xd7, 0xee, 0x3d, 0x16, 0x81, 0xe1, 0x40, 0xdd, 0xf5, 0x5f, 0xd5,
0xbb, 0x47, 0xa3, 0x30, 0xd6, 0x03, 0x87, 0x01, 0x88, 0x17, 0xa8, 0xbc, 0x66, 0xbe, 0xa1, 0x9f,
0x77, 0x4d, 0xd2, 0xfc, 0xb7, 0xac, 0x37, 0x5d, 0x51, 0xcf, 0x62, 0xbe, 0xac, 0x55, 0x30, 0xa8,
0xd6, 0xd6, 0x6b, 0x58, 0xbe, 0xf1, 0x1d, 0x0b, 0xaf, 0x5a, 0x47, 0xda, 0x72, 0xbe, 0x3d, 0xbe,
0x1e, 0x94, 0x86, 0xed, 0xd4, 0xdc, 0xda, 0x79, 0x7a, 0x3c, 0x27, 0x37, 0xd2, 0xb4, 0x8a, 0x8d,
0xa9, 0x59, 0xd9, 0x52, 0xb2, 0x5c, 0x4f, 0xdb, 0x22, 0x55, 0xbd, 0x43, 0x9b, 0x86, 0xa1, 0xa8,
0x9a, 0x95, 0x2d, 0x9e, 0x36, 0x16, 0x9a, 0x15, 0xbb, 0x45, 0x0b, 0x02, 0xae, 0x47, 0xa3, 0x5e,
0x44, 0x4d, 0x71, 0x99, 0xa7, 0x22, 0x2a, 0xb6, 0xf6, 0x0e, 0x3e, 0xad, 0xa6, 0xb8, 0x8c, 0xab,
0x1c, 0x86, 0x11, 0xbd, 0x5a, 0x6d, 0x52, 0x72, 0x49, 0xc4, 0xcb, 0xd0, 0x8c, 0x27, 0x66, 0x8a,
0x13, 0xa7, 0x20, 0x21, 0xed, 0x40, 0x13, 0x0b, 0xb5, 0x04, 0xe6, 0x7c, 0x76, 0x8e, 0x32, 0x40,
0x37, 0xf5, 0x96, 0x6c, 0xc4, 0x97, 0xd6, 0x1c, 0xad, 0x7d, 0xa0, 0x37, 0x80, 0xed, 0x09, 0x35,
0x55, 0x73, 0xbc, 0x13, 0x9c, 0xfc, 0x33, 0x98, 0x5e, 0x83, 0x07, 0x92, 0xca, 0x2c, 0x24, 0x4c,
0x1b, 0xfd, 0x83, 0x22, 0xf8, 0x69, 0xf8, 0x91, 0x90, 0x33, 0xcc, 0xc9, 0x79, 0xa1, 0xaf, 0x7a,
0xc8, 0x89, 0x9f, 0x47, 0x20, 0x21, 0xc5, 0x98, 0x28, 0x62, 0x0d, 0xdd, 0xdd, 0x60, 0x74, 0xf1,
0xe9, 0x81, 0x6c, 0x44, 0x65, 0xcf, 0x54, 0x8e, 0xd5, 0x8c, 0xc5, 0x5c, 0x40, 0xc8, 0xe9, 0x33,
0x9d, 0x57, 0x93, 0xe8, 0x15, 0x56, 0xe0, 0xda, 0xf5, 0x3a, 0xce, 0xa4, 0x23, 0xe7, 0x55, 0xc8,
0x67, 0x84, 0x98, 0x9e, 0x8b, 0xbb, 0x4d, 0xbd, 0x66, 0x06, 0x74, 0x63, 0x4c, 0x37, 0x2b, 0x1b,
0x3c, 0xe5, 0x02, 0xec, 0x95, 0xbc, 0x15, 0xe2, 0xea, 0x58, 0x3c, 0x57, 0xda, 0xa0, 0x41, 0x76,
0xda, 0xb5, 0x47, 0x28, 0xcc, 0x8a, 0x76, 0x89, 0x9d, 0x3e, 0x8d, 0x85, 0xac, 0x5d, 0xef, 0xb4,
0xc4, 0x74, 0xb6, 0x63, 0xdf, 0xe5, 0xdc, 0x15, 0xb9, 0x17, 0xda, 0x45, 0xc5, 0xd3, 0x03, 0xd1,
0xb9, 0xe5, 0xe9, 0xe7, 0x06, 0x26, 0xe6, 0x38, 0x6e, 0x59, 0x5a, 0x50, 0x25, 0xeb, 0x26, 0x31,
0xa8, 0x75, 0xe0, 0xa9, 0x2b, 0xe1, 0x86, 0x6a, 0xcd, 0xdd, 0x68, 0xad, 0x4d, 0xe2, 0x1b, 0x8e,
0x55, 0xed, 0xaa, 0xdd, 0xfe, 0x9c, 0x41, 0x9f, 0xd8, 0x03, 0xbb, 0x13, 0x9f, 0x34, 0x92, 0x9e,
0x74, 0x22, 0xf4, 0xfb, 0x47, 0x61, 0x11, 0xc6, 0x84, 0xb2, 0xc6, 0xce, 0x54, 0x79, 0x09, 0xaa,
0x6c, 0xbb, 0x21, 0xcf, 0xbd, 0xf0, 0x3a, 0x4b, 0x09, 0xea, 0xa8, 0x80, 0xd2, 0x36, 0x5e, 0xa4,
0x16, 0x54, 0xb8, 0x2c, 0xc0, 0xc7, 0x7d, 0x18, 0xb7, 0xdc, 0xdb, 0x33, 0xbe, 0x24, 0x18, 0xc7,
0x7c, 0x8c, 0x2b, 0x02, 0x5a, 0x98, 0x81, 0xe1, 0x9d, 0x70, 0xfd, 0x54, 0x70, 0xa5, 0x89, 0x9f,
0x64, 0x0e, 0x46, 0x18, 0x89, 0xd1, 0x72, 0x5c, 0xbb, 0xce, 0x02, 0xc4, 0xf6, 0x34, 0x3f, 0x7b,
0x9d, 0x3b, 0x55, 0x86, 0xc2, 0x66, 0x3c, 0x54, 0xe1, 0x6e, 0x18, 0xa7, 0x12, 0xb6, 0x06, 0xfd,
0x6c, 0xe1, 0x47, 0x08, 0xb9, 0x5f, 0x3e, 0xc0, 0x7d, 0x6f, 0xcc, 0x23, 0xf0, 0xf1, 0xfa, 0x66,
0xa2, 0x4a, 0x5c, 0x8c, 0x6d, 0xb8, 0xff, 0x33, 0x4d, 0x65, 0xdb, 0x6f, 0x0c, 0xb9, 0x47, 0xde,
0x0c, 0xce, 0xc4, 0x1c, 0x47, 0x4e, 0x99, 0x66, 0xa1, 0x0c, 0x7b, 0x7a, 0xcc, 0x6c, 0x1f, 0x9c,
0x8f, 0x0a, 0xce, 0xf1, 0xae, 0xd9, 0xa5, 0xb4, 0xcb, 0x20, 0xe5, 0xde, 0x7c, 0xf4, 0xc1, 0xf9,
0x98, 0xe0, 0x54, 0x04, 0x56, 0x4e, 0x0b, 0x65, 0x3c, 0x05, 0xa3, 0xb8, 0x53, 0x5f, 0xb3, 0x1d,
0xb1, 0xef, 0xed, 0x83, 0xee, 0x71, 0x41, 0x37, 0x22, 0x80, 0x6c, 0x17, 0x4c, 0xb9, 0x6e, 0x83,
0xc4, 0x3a, 0x6e, 0x80, 0xfa, 0xa0, 0x78, 0x42, 0x50, 0x0c, 0x51, 0x7d, 0x0a, 0x9d, 0x82, 0x74,
0xd5, 0x16, 0x61, 0x38, 0x1c, 0xfe, 0xa4, 0x80, 0xa7, 0x24, 0x46, 0x50, 0x34, 0xec, 0x46, 0xcb,
0xa4, 0x31, 0x3a, 0x9c, 0xe2, 0x4b, 0x92, 0x42, 0x62, 0x04, 0xc5, 0x0e, 0xcc, 0xfa, 0x65, 0x49,
0xe1, 0xf8, 0xec, 0x79, 0x27, 0x3d, 0xeb, 0x35, 0x37, 0x6d, 0xab, 0x9f, 0x4e, 0x3c, 0x25, 0x18,
0x40, 0x40, 0x28, 0xc1, 0xed, 0x90, 0xec, 0x77, 0x22, 0xbe, 0x22, 0xe0, 0x09, 0x22, 0x67, 0x00,
0xd7, 0x99, 0x0c, 0x32, 0xf4, 0xdb, 0x4a, 0x38, 0xc5, 0x57, 0x05, 0x45, 0xc6, 0x07, 0x13, 0xc3,
0x70, 0x89, 0xe3, 0xe2, 0x56, 0xbd, 0x0f, 0x92, 0x67, 0xe4, 0x30, 0x04, 0x44, 0x98, 0x72, 0x8d,
0x58, 0xc6, 0x46, 0x7f, 0x0c, 0xcf, 0x4a, 0x53, 0x4a, 0x0c, 0xa5, 0xc0, 0xc8, 0x53, 0xd7, 0x9b,
0xb8, 0xb9, 0x36, 0xfb, 0x9a, 0x8e, 0xaf, 0x09, 0x8e, 0xb4, 0x07, 0x12, 0x16, 0x69, 0x59, 0x3b,
0xa1, 0x79, 0x4e, 0x5a, 0xc4, 0x07, 0x13, 0x4b, 0x0f, 0x77, 0xa6, 0xb4, 0x92, 0xd8, 0x09, 0xdb,
0xd7, 0xe5, 0xd2, 0xe3, 0xd8, 0x05, 0x3f, 0x23, 0xce, 0xb4, 0x83, 0x5b, 0xf0, 0x7e, 0x68, 0xbe,
0x21, 0x67, 0x9a, 0x01, 0x28, 0xf8, 0x0c, 0xec, 0xed, 0x19, 0xea, 0xfb, 0x20, 0xfb, 0xa6, 0x20,
0xdb, 0xdd, 0x23, 0xdc, 0x8b, 0x90, 0xb0, 0x53, 0xca, 0x6f, 0xc9, 0x90, 0x40, 0x3a, 0xb8, 0x96,
0x69, 0x19, 0xeb, 0xe8, 0xeb, 0x3b, 0xb3, 0xda, 0xb7, 0xa5, 0xd5, 0x38, 0x36, 0x60, 0xb5, 0x55,
0xd8, 0x2d, 0x18, 0x77, 0x36, 0xaf, 0xcf, 0xcb, 0xc0, 0xca, 0xd1, 0xe5, 0xe0, 0xec, 0x7e, 0x10,
0x26, 0x3c, 0x73, 0xca, 0x0a, 0xcc, 0xd1, 0xe8, 0xc1, 0x40, 0x38, 0xf3, 0x0b, 0x82, 0x59, 0x46,
0x7c, 0xaf, 0x84, 0x73, 0x16, 0xf4, 0x06, 0x25, 0x3f, 0x0d, 0x39, 0x49, 0xde, 0xb2, 0xb0, 0xc0,
0xb7, 0xab, 0x16, 0x4e, 0x63, 0xa5, 0x0f, 0xea, 0xef, 0x74, 0x4c, 0x55, 0xd9, 0x07, 0xa7, 0xcc,
0x25, 0xc8, 0x7a, 0xf5, 0x86, 0x56, 0xab, 0x37, 0x6c, 0x2c, 0x2d, 0xb7, 0x67, 0xfc, 0xae, 0x9c,
0x29, 0x0f, 0x57, 0x62, 0xb0, 0x42, 0x11, 0x32, 0xec, 0xb1, 0x5f, 0x97, 0xfc, 0x9e, 0x20, 0x1a,
0x6e, 0xa3, 0x44, 0xe0, 0xc0, 0x4a, 0x09, 0x6b, 0xde, 0x7e, 0xe2, 0xdf, 0xf7, 0x65, 0xe0, 0x10,
0x10, 0xee, 0x7d, 0x23, 0x1d, 0x99, 0x58, 0x09, 0xfb, 0xfc, 0x9a, 0xfb, 0xf0, 0x25, 0xb1, 0x66,
0x83, 0x89, 0xb8, 0x30, 0x4f, 0xcd, 0x13, 0x4c, 0x97, 0xe1, 0x64, 0x0f, 0x5c, 0xf2, 0x2c, 0x14,
0xc8, 0x96, 0x85, 0x93, 0x30, 0x1c, 0x48, 0x95, 0xe1, 0x54, 0x0f, 0x0a, 0xaa, 0xb4, 0x3f, 0x53,
0x16, 0x6e, 0x86, 0x18, 0x4d, 0x7b, 0xe1, 0xf0, 0x8f, 0x08, 0x38, 0x53, 0x2f, 0xfc, 0x3f, 0x24,
0x64, 0xba, 0x0b, 0x87, 0x7e, 0x54, 0x40, 0x3d, 0x08, 0x85, 0xcb, 0x54, 0x17, 0x0e, 0xff, 0x98,
0x84, 0x4b, 0x08, 0x85, 0xf7, 0x6f, 0xc2, 0x17, 0x3f, 0x11, 0x13, 0xe1, 0x4a, 0xda, 0x8e, 0x7e,
0xf3, 0xe1, 0x39, 0x2e, 0x1c, 0xfd, 0x90, 0x78, 0xb9, 0x44, 0x14, 0x6e, 0x85, 0x78, 0x9f, 0x06,
0xff, 0xa4, 0x80, 0x72, 0x7d, 0xcc, 0x20, 0x29, 0x5f, 0x5e, 0x0b, 0x87, 0x7f, 0x4a, 0xc0, 0xfd,
0x28, 0xda, 0x75, 0x91, 0xd7, 0xc2, 0x09, 0x3e, 0x2d, 0xbb, 0x2e, 0x10, 0xd4, 0x6c, 0x32, 0xa5,
0x85, 0xa3, 0x3f, 0x23, 0xad, 0x2e, 0x21, 0xb8, 0x9a, 0x92, 0x5e, 0x98, 0x0a, 0xc7, 0x7f, 0x56,
0xe0, 0xdb, 0x18, 0x6a, 0x01, 0x5f, 0x98, 0x0c, 0xa7, 0xf8, 0x9c, 0xb4, 0x80, 0x0f, 0x45, 0x97,
0x51, 0x67, 0xea, 0x0b, 0x67, 0xfa, 0xbc, 0x5c, 0x46, 0x1d, 0x99, 0x8f, 0xce, 0x26, 0x8b, 0x16,
0xe1, 0x14, 0x5f, 0x90, 0xb3, 0xc9, 0xf4, 0x69, 0x37, 0x3a, 0x73, 0x49, 0x38, 0xc7, 0x17, 0x65,
0x37, 0x3a, 0x52, 0x09, 0x66, 0x26, 0xa5, 0x3b, 0x8f, 0x84, 0xf3, 0x3d, 0x2c, 0xf8, 0x46, 0xbb,
0xd2, 0x48, 0xe1, 0x1e, 0xd8, 0xdd, 0x3b, 0x87, 0x84, 0xb3, 0x3e, 0x72, 0xa9, 0xa3, 0xea, 0xf7,
0xa7, 0x10, 0x4c, 0x79, 0xe3, 0xbd, 0xf2, 0x47, 0x38, 0xed, 0xa3, 0x97, 0x82, 0x1b, 0x3b, 0x7f,
0xfa, 0xc0, 0x0a, 0x0d, 0xda, 0xa1, 0x3b, 0x9c, 0xeb, 0x71, 0xc1, 0xe5, 0x03, 0xd1, 0xa5, 0x21,
0x22, 0x77, 0x38, 0xfe, 0x09, 0xb9, 0x34, 0x04, 0x02, 0xc1, 0x09, 0xab, 0x65, 0x9a, 0xd4, 0x39,
0x94, 0xed, 0x7f, 0xd2, 0x90, 0xfb, 0xe3, 0x3b, 0x62, 0x61, 0x48, 0x00, 0xc6, 0xd0, 0x38, 0xa9,
0xaf, 0xa1, 0x0d, 0x42, 0x90, 0x7f, 0x7a, 0x47, 0x06, 0x04, 0xaa, 0x8d, 0xeb, 0x09, 0xf8, 0xa6,
0x91, 0x9d, 0x61, 0x87, 0x60, 0xff, 0xfc, 0x8e, 0xf8, 0xcc, 0xda, 0x86, 0xb4, 0x09, 0xf8, 0x47,
0xdb, 0xed, 0x09, 0xde, 0x0c, 0x12, 0xb0, 0x8d, 0xe6, 0x6d, 0x30, 0x44, 0x7f, 0xd9, 0xe1, 0xea,
0xd5, 0x30, 0xf4, 0x5f, 0x04, 0x5a, 0xea, 0x53, 0x83, 0xd5, 0xed, 0x26, 0xc1, 0x5b, 0x27, 0x0c,
0xfb, 0x57, 0x81, 0xf5, 0x00, 0x14, 0x6c, 0xe8, 0x8e, 0xdb, 0xcf, 0xb8, 0xff, 0x26, 0xc1, 0x12,
0x40, 0x3b, 0x4d, 0xef, 0xcf, 0x91, 0xcd, 0x30, 0xec, 0x5b, 0xb2, 0xd3, 0x42, 0x1f, 0x03, 0x60,
0x92, 0xde, 0xf2, 0x9f, 0x1e, 0x84, 0x80, 0xff, 0x2e, 0xc0, 0x6d, 0xc4, 0xf4, 0xa1, 0xde, 0x47,
0x3b, 0x30, 0x67, 0xcf, 0xd9, 0xfc, 0x50, 0x07, 0xfe, 0x19, 0x83, 0x11, 0x0f, 0x20, 0x4f, 0x61,
0x3c, 0xc1, 0xc4, 0xce, 0xce, 0x6f, 0xf2, 0x3f, 0x8e, 0x42, 0x62, 0x06, 0xc1, 0xfa, 0x05, 0x7d,
0x53, 0x69, 0xc0, 0x18, 0xbd, 0xc7, 0x35, 0xc8, 0x4e, 0x12, 0x84, 0x47, 0x8b, 0xa3, 0xb7, 0xeb,
0x27, 0xdb, 0x6f, 0x95, 0x88, 0xc9, 0x1e, 0xea, 0xec, 0x4b, 0xd2, 0x74, 0xf6, 0xe5, 0xdf, 0x1e,
0xd8, 0xf5, 0xf1, 0xdf, 0x1d, 0x48, 0x2c, 0x6c, 0xde, 0x53, 0x33, 0x1d, 0x7a, 0x38, 0x6b, 0x74,
0xeb, 0x2a, 0x0f, 0x46, 0x60, 0x5f, 0x0f, 0x8e, 0x45, 0xe1, 0xf7, 0xe2, 0x44, 0xf6, 0xa6, 0x3e,
0x5f, 0x2d, 0x61, 0xbc, 0x0b, 0xe9, 0xc0, 0xeb, 0xf7, 0x19, 0x5b, 0xeb, 0x4f, 0x9c, 0x81, 0xdc,
0x56, 0x23, 0xa1, 0xbf, 0x02, 0xc3, 0x89, 0x15, 0xbf, 0x0c, 0xa3, 0xb7, 0xca, 0xe1, 0xf6, 0x4f,
0x52, 0xe8, 0x2f, 0x0f, 0x46, 0x7d, 0xbd, 0x13, 0x2f, 0xe3, 0xed, 0x85, 0x81, 0x13, 0x91, 0x09,
0x1d, 0x0e, 0x86, 0xf5, 0xf4, 0xdf, 0x7c, 0x45, 0x7e, 0x3f, 0x0c, 0x72, 0x21, 0xfd, 0x1d, 0x5b,
0xc9, 0x72, 0x6f, 0xb9, 0x89, 0x51, 0x45, 0xd5, 0x78, 0x8d, 0x3e, 0x4c, 0xcf, 0xbf, 0xfc, 0xea,
0xfe, 0x5d, 0xbf, 0xc0, 0xeb, 0xd7, 0x78, 0xbd, 0xf2, 0xea, 0xfe, 0xc8, 0x1b, 0x78, 0xbd, 0x85,
0xd7, 0xdb, 0x78, 0xdd, 0xff, 0xda, 0xfe, 0xc8, 0xb3, 0x78, 0x3d, 0x8f, 0xd7, 0x0f, 0xf1, 0x7a,
0x11, 0xaf, 0x97, 0x5f, 0x43, 0x7d, 0xbc, 0x5e, 0xc1, 0xfb, 0x37, 0xf0, 0xff, 0x5b, 0xf8, 0xff,
0x6d, 0xfc, 0x7f, 0xff, 0xef, 0xf7, 0xef, 0xfa, 0x57, 0x00, 0x00, 0x00, 0xff, 0xff, 0xf8, 0x6d,
0x34, 0xdd, 0xea, 0x2c, 0x00, 0x00,
// 3595 bytes of a gzipped FileDescriptorSet
0x1f, 0x8b, 0x08, 0x00, 0x00, 0x09, 0x6e, 0x88, 0x02, 0xff, 0xcc, 0x5a, 0x5d, 0x6c, 0x1c, 0xd7,
0x75, 0xe6, 0xec, 0x0f, 0xb9, 0x7b, 0x76, 0xb9, 0x1c, 0x5e, 0xd2, 0xd4, 0x8a, 0x8a, 0x57, 0x14,
0x23, 0x57, 0xb4, 0x9d, 0x50, 0x81, 0x2c, 0xc9, 0xd2, 0xaa, 0x89, 0xb0, 0x5c, 0xae, 0x18, 0x0a,
0xfc, 0xeb, 0x90, 0x8c, 0xa5, 0xe4, 0x61, 0x70, 0x39, 0x7b, 0x77, 0x39, 0xd2, 0xec, 0xcc, 0x76,
0x66, 0x56, 0x12, 0xf5, 0xa4, 0xc0, 0x69, 0x8b, 0x34, 0xe8, 0x7f, 0x81, 0x26, 0x8e, 0xf3, 0xd3,
0x00, 0xad, 0xd3, 0xf4, 0x2f, 0xe9, 0x1f, 0x8a, 0x3e, 0xb9, 0x0f, 0x6e, 0xfd, 0x54, 0xd8, 0x6f,
0x7d, 0x28, 0x5a, 0x8b, 0x35, 0x50, 0xb7, 0x75, 0x5b, 0xb7, 0x15, 0x50, 0x03, 0x42, 0x81, 0xe2,
0xfe, 0xcd, 0xce, 0xfe, 0x90, 0xb3, 0x74, 0x61, 0x3b, 0x4f, 0xdc, 0x7b, 0xee, 0xf9, 0xbe, 0x39,
0xf7, 0xdc, 0x73, 0xcf, 0x39, 0x73, 0x87, 0xf0, 0xe5, 0xf3, 0x30, 0x53, 0x77, 0x9c, 0xba, 0x45,
0xce, 0x36, 0x5d, 0xc7, 0x77, 0x76, 0x5a, 0xb5, 0xb3, 0x55, 0xe2, 0x19, 0xae, 0xd9, 0xf4, 0x1d,
0x77, 0x9e, 0xc9, 0xd0, 0x18, 0xd7, 0x98, 0x97, 0x1a, 0xb3, 0xab, 0x30, 0x7e, 0xcd, 0xb4, 0xc8,
0x62, 0xa0, 0xb8, 0x49, 0x7c, 0x74, 0x09, 0x12, 0x35, 0xd3, 0x22, 0x79, 0x65, 0x26, 0x3e, 0x97,
0x39, 0x77, 0x7a, 0xbe, 0x0b, 0x34, 0xdf, 0x89, 0xd8, 0xa0, 0x62, 0x8d, 0x21, 0x66, 0xdf, 0x4e,
0xc0, 0x44, 0x9f, 0x59, 0x84, 0x20, 0x61, 0xe3, 0x06, 0x65, 0x54, 0xe6, 0xd2, 0x1a, 0xfb, 0x8d,
0xf2, 0x30, 0xd2, 0xc4, 0xc6, 0x6d, 0x5c, 0x27, 0xf9, 0x18, 0x13, 0xcb, 0x21, 0x2a, 0x00, 0x54,
0x49, 0x93, 0xd8, 0x55, 0x62, 0x1b, 0x7b, 0xf9, 0xf8, 0x4c, 0x7c, 0x2e, 0xad, 0x85, 0x24, 0xe8,
0x59, 0x18, 0x6f, 0xb6, 0x76, 0x2c, 0xd3, 0xd0, 0x43, 0x6a, 0x30, 0x13, 0x9f, 0x4b, 0x6a, 0x2a,
0x9f, 0x58, 0x6c, 0x2b, 0x9f, 0x81, 0xb1, 0xbb, 0x04, 0xdf, 0x0e, 0xab, 0x66, 0x98, 0x6a, 0x8e,
0x8a, 0x43, 0x8a, 0x65, 0xc8, 0x36, 0x88, 0xe7, 0xe1, 0x3a, 0xd1, 0xfd, 0xbd, 0x26, 0xc9, 0x27,
0xd8, 0xea, 0x67, 0x7a, 0x56, 0xdf, 0xbd, 0xf2, 0x8c, 0x40, 0x6d, 0xed, 0x35, 0x09, 0x2a, 0x41,
0x9a, 0xd8, 0xad, 0x06, 0x67, 0x48, 0x1e, 0xe0, 0xbf, 0x8a, 0xdd, 0x6a, 0x74, 0xb3, 0xa4, 0x28,
0x4c, 0x50, 0x8c, 0x78, 0xc4, 0xbd, 0x63, 0x1a, 0x24, 0x3f, 0xcc, 0x08, 0xce, 0xf4, 0x10, 0x6c,
0xf2, 0xf9, 0x6e, 0x0e, 0x89, 0x43, 0x65, 0x48, 0x93, 0x7b, 0x3e, 0xb1, 0x3d, 0xd3, 0xb1, 0xf3,
0x23, 0x8c, 0xe4, 0xa9, 0x3e, 0xbb, 0x48, 0xac, 0x6a, 0x37, 0x45, 0x1b, 0x87, 0x2e, 0xc2, 0x88,
0xd3, 0xf4, 0x4d, 0xc7, 0xf6, 0xf2, 0xa9, 0x19, 0x65, 0x2e, 0x73, 0xee, 0x13, 0x7d, 0x03, 0x61,
0x9d, 0xeb, 0x68, 0x52, 0x19, 0x2d, 0x83, 0xea, 0x39, 0x2d, 0xd7, 0x20, 0xba, 0xe1, 0x54, 0x89,
0x6e, 0xda, 0x35, 0x27, 0x9f, 0x66, 0x04, 0x27, 0x7b, 0x17, 0xc2, 0x14, 0xcb, 0x4e, 0x95, 0x2c,
0xdb, 0x35, 0x47, 0xcb, 0x79, 0x1d, 0x63, 0x34, 0x05, 0xc3, 0xde, 0x9e, 0xed, 0xe3, 0x7b, 0xf9,
0x2c, 0x8b, 0x10, 0x31, 0x9a, 0xfd, 0x9f, 0x24, 0x8c, 0x0d, 0x12, 0x62, 0x57, 0x20, 0x59, 0xa3,
0xab, 0xcc, 0xc7, 0x8e, 0xe2, 0x03, 0x8e, 0xe9, 0x74, 0xe2, 0xf0, 0x07, 0x74, 0x62, 0x09, 0x32,
0x36, 0xf1, 0x7c, 0x52, 0xe5, 0x11, 0x11, 0x1f, 0x30, 0xa6, 0x80, 0x83, 0x7a, 0x43, 0x2a, 0xf1,
0x81, 0x42, 0xea, 0x06, 0x8c, 0x05, 0x26, 0xe9, 0x2e, 0xb6, 0xeb, 0x32, 0x36, 0xcf, 0x46, 0x59,
0x32, 0x5f, 0x91, 0x38, 0x8d, 0xc2, 0xb4, 0x1c, 0xe9, 0x18, 0xa3, 0x45, 0x00, 0xc7, 0x26, 0x4e,
0x4d, 0xaf, 0x12, 0xc3, 0xca, 0xa7, 0x0e, 0xf0, 0xd2, 0x3a, 0x55, 0xe9, 0xf1, 0x92, 0xc3, 0xa5,
0x86, 0x85, 0x2e, 0xb7, 0x43, 0x6d, 0xe4, 0x80, 0x48, 0x59, 0xe5, 0x87, 0xac, 0x27, 0xda, 0xb6,
0x21, 0xe7, 0x12, 0x1a, 0xf7, 0xa4, 0x2a, 0x56, 0x96, 0x66, 0x46, 0xcc, 0x47, 0xae, 0x4c, 0x13,
0x30, 0xbe, 0xb0, 0x51, 0x37, 0x3c, 0x44, 0x9f, 0x84, 0x40, 0xa0, 0xb3, 0xb0, 0x02, 0x96, 0x85,
0xb2, 0x52, 0xb8, 0x86, 0x1b, 0x64, 0xfa, 0x12, 0xe4, 0x3a, 0xdd, 0x83, 0x26, 0x21, 0xe9, 0xf9,
0xd8, 0xf5, 0x59, 0x14, 0x26, 0x35, 0x3e, 0x40, 0x2a, 0xc4, 0x89, 0x5d, 0x65, 0x59, 0x2e, 0xa9,
0xd1, 0x9f, 0xd3, 0xcf, 0xc3, 0x68, 0xc7, 0xe3, 0x07, 0x05, 0xce, 0x7e, 0x7d, 0x18, 0x26, 0xfb,
0xc5, 0x5c, 0xdf, 0xf0, 0x9f, 0x82, 0x61, 0xbb, 0xd5, 0xd8, 0x21, 0x6e, 0x3e, 0xce, 0x18, 0xc4,
0x08, 0x95, 0x20, 0x69, 0xe1, 0x1d, 0x62, 0xe5, 0x13, 0x33, 0xca, 0x5c, 0xee, 0xdc, 0xb3, 0x03,
0x45, 0xf5, 0xfc, 0x0a, 0x85, 0x68, 0x1c, 0x89, 0x3e, 0x07, 0x09, 0x91, 0xe2, 0x28, 0xc3, 0x33,
0x83, 0x31, 0xd0, 0x58, 0xd4, 0x18, 0x0e, 0x9d, 0x80, 0x34, 0xfd, 0xcb, 0x7d, 0x3b, 0xcc, 0x6c,
0x4e, 0x51, 0x01, 0xf5, 0x2b, 0x9a, 0x86, 0x14, 0x0b, 0xb3, 0x2a, 0x91, 0xa5, 0x21, 0x18, 0xd3,
0x8d, 0xa9, 0x92, 0x1a, 0x6e, 0x59, 0xbe, 0x7e, 0x07, 0x5b, 0x2d, 0xc2, 0x02, 0x26, 0xad, 0x65,
0x85, 0xf0, 0x0b, 0x54, 0x86, 0x4e, 0x42, 0x86, 0x47, 0xa5, 0x69, 0x57, 0xc9, 0x3d, 0x96, 0x7d,
0x92, 0x1a, 0x0f, 0xd4, 0x65, 0x2a, 0xa1, 0x8f, 0xbf, 0xe5, 0x39, 0xb6, 0xdc, 0x5a, 0xf6, 0x08,
0x2a, 0x60, 0x8f, 0x7f, 0xbe, 0x3b, 0xf1, 0x3d, 0xd9, 0x7f, 0x79, 0xdd, 0xb1, 0x38, 0xfb, 0x67,
0x31, 0x48, 0xb0, 0xf3, 0x36, 0x06, 0x99, 0xad, 0x9b, 0x1b, 0x15, 0x7d, 0x71, 0x7d, 0x7b, 0x61,
0xa5, 0xa2, 0x2a, 0x28, 0x07, 0xc0, 0x04, 0xd7, 0x56, 0xd6, 0x4b, 0x5b, 0x6a, 0x2c, 0x18, 0x2f,
0xaf, 0x6d, 0x5d, 0x3c, 0xaf, 0xc6, 0x03, 0xc0, 0x36, 0x17, 0x24, 0xc2, 0x0a, 0xcf, 0x9d, 0x53,
0x93, 0x48, 0x85, 0x2c, 0x27, 0x58, 0xbe, 0x51, 0x59, 0xbc, 0x78, 0x5e, 0x1d, 0xee, 0x94, 0x3c,
0x77, 0x4e, 0x1d, 0x41, 0xa3, 0x90, 0x66, 0x92, 0x85, 0xf5, 0xf5, 0x15, 0x35, 0x15, 0x70, 0x6e,
0x6e, 0x69, 0xcb, 0x6b, 0x4b, 0x6a, 0x3a, 0xe0, 0x5c, 0xd2, 0xd6, 0xb7, 0x37, 0x54, 0x08, 0x18,
0x56, 0x2b, 0x9b, 0x9b, 0xa5, 0xa5, 0x8a, 0x9a, 0x09, 0x34, 0x16, 0x6e, 0x6e, 0x55, 0x36, 0xd5,
0x6c, 0x87, 0x59, 0xcf, 0x9d, 0x53, 0x47, 0x83, 0x47, 0x54, 0xd6, 0xb6, 0x57, 0xd5, 0x1c, 0x1a,
0x87, 0x51, 0xfe, 0x08, 0x69, 0xc4, 0x58, 0x97, 0xe8, 0xe2, 0x79, 0x55, 0x6d, 0x1b, 0xc2, 0x59,
0xc6, 0x3b, 0x04, 0x17, 0xcf, 0xab, 0x68, 0xb6, 0x0c, 0x49, 0x16, 0x5d, 0x08, 0x41, 0x6e, 0xa5,
0xb4, 0x50, 0x59, 0xd1, 0xd7, 0x37, 0xb6, 0x96, 0xd7, 0xd7, 0x4a, 0x2b, 0xaa, 0xd2, 0x96, 0x69,
0x95, 0x9f, 0xda, 0x5e, 0xd6, 0x2a, 0x8b, 0x6a, 0x2c, 0x2c, 0xdb, 0xa8, 0x94, 0xb6, 0x2a, 0x8b,
0x6a, 0x7c, 0xd6, 0x80, 0xc9, 0x7e, 0x79, 0xa6, 0xef, 0xc9, 0x08, 0x6d, 0x71, 0xec, 0x80, 0x2d,
0x66, 0x5c, 0x3d, 0x5b, 0xfc, 0x3d, 0x05, 0x26, 0xfa, 0xe4, 0xda, 0xbe, 0x0f, 0xb9, 0x0a, 0x49,
0x1e, 0xa2, 0xbc, 0xfa, 0x3c, 0xdd, 0x37, 0x69, 0xb3, 0x80, 0xed, 0xa9, 0x40, 0x0c, 0x17, 0xae,
0xc0, 0xf1, 0x03, 0x2a, 0x30, 0xa5, 0xe8, 0x31, 0xf2, 0x45, 0x05, 0xf2, 0x07, 0x71, 0x47, 0x24,
0x8a, 0x58, 0x47, 0xa2, 0xb8, 0xd2, 0x6d, 0xc0, 0xa9, 0x83, 0xd7, 0xd0, 0x63, 0xc5, 0x2b, 0x0a,
0x4c, 0xf5, 0x6f, 0x54, 0xfa, 0xda, 0xf0, 0x39, 0x18, 0x6e, 0x10, 0x7f, 0xd7, 0x91, 0xc5, 0xfa,
0x27, 0xfa, 0x94, 0x00, 0x3a, 0xdd, 0xed, 0x2b, 0x81, 0x0a, 0xd7, 0x90, 0xf8, 0x41, 0xdd, 0x06,
0xb7, 0xa6, 0xc7, 0xd2, 0xaf, 0xc6, 0xe0, 0x89, 0xbe, 0xe4, 0x7d, 0x0d, 0x7d, 0x12, 0xc0, 0xb4,
0x9b, 0x2d, 0x9f, 0x17, 0x64, 0x9e, 0x9f, 0xd2, 0x4c, 0xc2, 0xce, 0x3e, 0xcd, 0x3d, 0x2d, 0x3f,
0x98, 0x8f, 0xb3, 0x79, 0xe0, 0x22, 0xa6, 0x70, 0xa9, 0x6d, 0x68, 0x82, 0x19, 0x5a, 0x38, 0x60,
0xa5, 0x3d, 0xb5, 0xee, 0x33, 0xa0, 0x1a, 0x96, 0x49, 0x6c, 0x5f, 0xf7, 0x7c, 0x97, 0xe0, 0x86,
0x69, 0xd7, 0x59, 0x02, 0x4e, 0x15, 0x93, 0x35, 0x6c, 0x79, 0x44, 0x1b, 0xe3, 0xd3, 0x9b, 0x72,
0x96, 0x22, 0x58, 0x95, 0x71, 0x43, 0x88, 0xe1, 0x0e, 0x04, 0x9f, 0x0e, 0x10, 0xb3, 0x5f, 0x1b,
0x81, 0x4c, 0xa8, 0xad, 0x43, 0xa7, 0x20, 0x7b, 0x0b, 0xdf, 0xc1, 0xba, 0x6c, 0xd5, 0xb9, 0x27,
0x32, 0x54, 0xb6, 0x21, 0xda, 0xf5, 0xcf, 0xc0, 0x24, 0x53, 0x71, 0x5a, 0x3e, 0x71, 0x75, 0xc3,
0xc2, 0x9e, 0xc7, 0x9c, 0x96, 0x62, 0xaa, 0x88, 0xce, 0xad, 0xd3, 0xa9, 0xb2, 0x9c, 0x41, 0x17,
0x60, 0x82, 0x21, 0x1a, 0x2d, 0xcb, 0x37, 0x9b, 0x16, 0xd1, 0xe9, 0xcb, 0x83, 0xc7, 0x12, 0x71,
0x60, 0xd9, 0x38, 0xd5, 0x58, 0x15, 0x0a, 0xd4, 0x22, 0x0f, 0x2d, 0xc1, 0x93, 0x0c, 0x56, 0x27,
0x36, 0x71, 0xb1, 0x4f, 0x74, 0xf2, 0xd3, 0x2d, 0x6c, 0x79, 0x3a, 0xb6, 0xab, 0xfa, 0x2e, 0xf6,
0x76, 0xf3, 0x93, 0x61, 0x82, 0xe3, 0x54, 0x77, 0x49, 0xa8, 0x56, 0x98, 0x66, 0xc9, 0xae, 0x7e,
0x1e, 0x7b, 0xbb, 0xa8, 0x08, 0x53, 0x8c, 0xc8, 0xf3, 0x5d, 0xd3, 0xae, 0xeb, 0xc6, 0x2e, 0x31,
0x6e, 0xeb, 0x2d, 0xbf, 0x76, 0x29, 0x7f, 0x22, 0xcc, 0xc0, 0x8c, 0xdc, 0x64, 0x3a, 0x65, 0xaa,
0xb2, 0xed, 0xd7, 0x2e, 0xa1, 0x4d, 0xc8, 0xd2, 0xfd, 0x68, 0x98, 0xf7, 0x89, 0x5e, 0x73, 0x5c,
0x56, 0x5c, 0x72, 0x7d, 0x0e, 0x77, 0xc8, 0x89, 0xf3, 0xeb, 0x02, 0xb0, 0xea, 0x54, 0x49, 0x31,
0xb9, 0xb9, 0x51, 0xa9, 0x2c, 0x6a, 0x19, 0xc9, 0x72, 0xcd, 0x71, 0x69, 0x4c, 0xd5, 0x9d, 0xc0,
0xc7, 0x19, 0x1e, 0x53, 0x75, 0x47, 0x7a, 0xf8, 0x02, 0x4c, 0x18, 0x06, 0x5f, 0xb6, 0x69, 0xe8,
0xa2, 0xcb, 0xf7, 0xf2, 0x6a, 0x87, 0xbf, 0x0c, 0x63, 0x89, 0x2b, 0x88, 0x30, 0xf7, 0xd0, 0x65,
0x78, 0xa2, 0xed, 0xaf, 0x30, 0x70, 0xbc, 0x67, 0x95, 0xdd, 0xd0, 0x0b, 0x30, 0xd1, 0xdc, 0xeb,
0x05, 0xa2, 0x8e, 0x27, 0x36, 0xf7, 0xba, 0x61, 0x4f, 0xb1, 0x37, 0x37, 0x97, 0x18, 0xd8, 0x27,
0xd5, 0xfc, 0xb1, 0xb0, 0x76, 0x68, 0x02, 0x9d, 0x05, 0xd5, 0x30, 0x74, 0x62, 0xe3, 0x1d, 0x8b,
0xe8, 0xd8, 0x25, 0x36, 0xf6, 0xf2, 0x27, 0xc3, 0xca, 0x39, 0xc3, 0xa8, 0xb0, 0xd9, 0x12, 0x9b,
0x44, 0xcf, 0xc0, 0xb8, 0xb3, 0x73, 0xcb, 0xe0, 0xc1, 0xa5, 0x37, 0x5d, 0x52, 0x33, 0xef, 0xe5,
0x4f, 0x33, 0x37, 0x8d, 0xd1, 0x09, 0x16, 0x5a, 0x1b, 0x4c, 0x8c, 0x9e, 0x06, 0xd5, 0xf0, 0x76,
0xb1, 0xdb, 0x64, 0xd5, 0xdd, 0x6b, 0x62, 0x83, 0xe4, 0x9f, 0xe2, 0xaa, 0x5c, 0xbe, 0x26, 0xc5,
0xe8, 0x06, 0x4c, 0xb6, 0x6c, 0xd3, 0xf6, 0x89, 0xdb, 0x74, 0x09, 0x6d, 0xd2, 0xf9, 0x49, 0xcb,
0xff, 0xd3, 0xc8, 0x01, 0x6d, 0xf6, 0x76, 0x58, 0x9b, 0xef, 0xae, 0x36, 0xd1, 0xea, 0x15, 0xce,
0x16, 0x21, 0x1b, 0xde, 0x74, 0x94, 0x06, 0xbe, 0xed, 0xaa, 0x42, 0x6b, 0x68, 0x79, 0x7d, 0x91,
0x56, 0xbf, 0x2f, 0x56, 0xd4, 0x18, 0xad, 0xc2, 0x2b, 0xcb, 0x5b, 0x15, 0x5d, 0xdb, 0x5e, 0xdb,
0x5a, 0x5e, 0xad, 0xa8, 0xf1, 0x67, 0xd2, 0xa9, 0x77, 0x46, 0xd4, 0x07, 0x0f, 0x1e, 0x3c, 0x88,
0xcd, 0xbe, 0x16, 0x83, 0x5c, 0x67, 0xe7, 0x8b, 0x7e, 0x12, 0x8e, 0xc9, 0xd7, 0x54, 0x8f, 0xf8,
0xfa, 0x5d, 0xd3, 0x65, 0x71, 0xd8, 0xc0, 0xbc, 0x77, 0x0c, 0x5c, 0x38, 0x29, 0xb4, 0x36, 0x89,
0xff, 0x82, 0xe9, 0xd2, 0x28, 0x6b, 0x60, 0x1f, 0xad, 0xc0, 0x49, 0xdb, 0xd1, 0x3d, 0x1f, 0xdb,
0x55, 0xec, 0x56, 0xf5, 0xf6, 0x05, 0x81, 0x8e, 0x0d, 0x83, 0x78, 0x9e, 0xc3, 0x4b, 0x40, 0xc0,
0xf2, 0x09, 0xdb, 0xd9, 0x14, 0xca, 0xed, 0xdc, 0x58, 0x12, 0xaa, 0x5d, 0xdb, 0x1d, 0x3f, 0x68,
0xbb, 0x4f, 0x40, 0xba, 0x81, 0x9b, 0x3a, 0xb1, 0x7d, 0x77, 0x8f, 0xf5, 0x6b, 0x29, 0x2d, 0xd5,
0xc0, 0xcd, 0x0a, 0x1d, 0x7f, 0x78, 0x7b, 0x10, 0xf6, 0xe3, 0xdf, 0xc5, 0x21, 0x1b, 0xee, 0xd9,
0x68, 0x0b, 0x6c, 0xb0, 0xfc, 0xac, 0xb0, 0xe3, 0xfb, 0xc9, 0x43, 0x3b, 0xbc, 0xf9, 0x32, 0x4d,
0xdc, 0xc5, 0x61, 0xde, 0x49, 0x69, 0x1c, 0x49, 0x8b, 0x26, 0x3d, 0xb0, 0x84, 0xf7, 0xe7, 0x29,
0x4d, 0x8c, 0xd0, 0x12, 0x0c, 0xdf, 0xf2, 0x18, 0xf7, 0x30, 0xe3, 0x3e, 0x7d, 0x38, 0xf7, 0xf5,
0x4d, 0x46, 0x9e, 0xbe, 0xbe, 0xa9, 0xaf, 0xad, 0x6b, 0xab, 0xa5, 0x15, 0x4d, 0xc0, 0xd1, 0x71,
0x48, 0x58, 0xf8, 0xfe, 0x5e, 0x67, 0x8a, 0x67, 0xa2, 0x41, 0x1d, 0x7f, 0x1c, 0x12, 0x77, 0x09,
0xbe, 0xdd, 0x99, 0x58, 0x99, 0xe8, 0x43, 0x0c, 0xfd, 0xb3, 0x90, 0x64, 0xfe, 0x42, 0x00, 0xc2,
0x63, 0xea, 0x10, 0x4a, 0x41, 0xa2, 0xbc, 0xae, 0xd1, 0xf0, 0x57, 0x21, 0xcb, 0xa5, 0xfa, 0xc6,
0x72, 0xa5, 0x5c, 0x51, 0x63, 0xb3, 0x17, 0x60, 0x98, 0x3b, 0x81, 0x1e, 0x8d, 0xc0, 0x0d, 0xea,
0x90, 0x18, 0x0a, 0x0e, 0x45, 0xce, 0x6e, 0xaf, 0x2e, 0x54, 0x34, 0x35, 0x16, 0xde, 0x5e, 0x0f,
0xb2, 0xe1, 0x76, 0xed, 0xa3, 0x89, 0xa9, 0xbf, 0x50, 0x20, 0x13, 0x6a, 0xbf, 0x68, 0xe1, 0xc7,
0x96, 0xe5, 0xdc, 0xd5, 0xb1, 0x65, 0x62, 0x4f, 0x04, 0x05, 0x30, 0x51, 0x89, 0x4a, 0x06, 0xdd,
0xb4, 0x8f, 0xc4, 0xf8, 0x6f, 0x2b, 0xa0, 0x76, 0xb7, 0x6e, 0x5d, 0x06, 0x2a, 0x1f, 0xab, 0x81,
0x2f, 0x2b, 0x90, 0xeb, 0xec, 0xd7, 0xba, 0xcc, 0x3b, 0xf5, 0xb1, 0x9a, 0xf7, 0x4d, 0x05, 0x46,
0x3b, 0xba, 0xb4, 0x1f, 0x2b, 0xeb, 0x5e, 0x8a, 0xc3, 0x44, 0x1f, 0x1c, 0x2a, 0x89, 0x76, 0x96,
0x77, 0xd8, 0x9f, 0x1e, 0xe4, 0x59, 0xf3, 0xb4, 0x5a, 0x6e, 0x60, 0xd7, 0x17, 0xdd, 0xef, 0xd3,
0xa0, 0x9a, 0x55, 0x62, 0xfb, 0x66, 0xcd, 0x24, 0xae, 0x78, 0x05, 0xe7, 0x3d, 0xee, 0x58, 0x5b,
0xce, 0xdf, 0xc2, 0x3f, 0x05, 0xa8, 0xe9, 0x78, 0xa6, 0x6f, 0xde, 0x21, 0xba, 0x69, 0xcb, 0xf7,
0x75, 0xda, 0xf3, 0x26, 0x34, 0x55, 0xce, 0x2c, 0xdb, 0x7e, 0xa0, 0x6d, 0x93, 0x3a, 0xee, 0xd2,
0xa6, 0xb9, 0x2f, 0xae, 0xa9, 0x72, 0x26, 0xd0, 0x3e, 0x05, 0xd9, 0xaa, 0xd3, 0xa2, 0xed, 0x03,
0xd7, 0xa3, 0xa9, 0x56, 0xd1, 0x32, 0x5c, 0x16, 0xa8, 0x88, 0xfe, 0xae, 0x7d, 0x51, 0x90, 0xd5,
0x32, 0x5c, 0xc6, 0x55, 0xce, 0xc0, 0x18, 0xae, 0xd7, 0x5d, 0x4a, 0x2e, 0x89, 0x78, 0xd3, 0x9a,
0x0b, 0xc4, 0x4c, 0x71, 0xfa, 0x3a, 0xa4, 0xa4, 0x1f, 0x68, 0x35, 0xa3, 0x9e, 0xd0, 0x9b, 0xfc,
0xba, 0x26, 0x36, 0x97, 0xd6, 0x52, 0xb6, 0x9c, 0x3c, 0x05, 0x59, 0xd3, 0xd3, 0xdb, 0xf7, 0x86,
0xb1, 0x99, 0xd8, 0x5c, 0x4a, 0xcb, 0x98, 0x5e, 0x70, 0x51, 0x34, 0xfb, 0x4a, 0x0c, 0x72, 0x9d,
0xf7, 0x9e, 0x68, 0x11, 0x52, 0x96, 0x63, 0x60, 0x16, 0x08, 0xfc, 0xd2, 0x7d, 0x2e, 0xe2, 0xaa,
0x74, 0x7e, 0x45, 0xe8, 0x6b, 0x01, 0x72, 0xfa, 0x6f, 0x14, 0x48, 0x49, 0x31, 0x9a, 0x82, 0x44,
0x13, 0xfb, 0xbb, 0x8c, 0x2e, 0xb9, 0x10, 0x53, 0x15, 0x8d, 0x8d, 0xa9, 0xdc, 0x6b, 0x62, 0x9b,
0x85, 0x80, 0x90, 0xd3, 0x31, 0xdd, 0x57, 0x8b, 0xe0, 0x2a, 0x6b, 0x87, 0x9d, 0x46, 0x83, 0xd8,
0xbe, 0x27, 0xf7, 0x55, 0xc8, 0xcb, 0x42, 0x8c, 0x9e, 0x85, 0x71, 0xdf, 0xc5, 0xa6, 0xd5, 0xa1,
0x9b, 0x60, 0xba, 0xaa, 0x9c, 0x08, 0x94, 0x8b, 0x70, 0x5c, 0xf2, 0x56, 0x89, 0x8f, 0x8d, 0x5d,
0x52, 0x6d, 0x83, 0x86, 0xd9, 0xa5, 0xda, 0x31, 0xa1, 0xb0, 0x28, 0xe6, 0x25, 0x76, 0xf6, 0x4d,
0x05, 0xc6, 0x65, 0x03, 0x5f, 0x0d, 0x9c, 0xb5, 0x0a, 0x80, 0x6d, 0xdb, 0xf1, 0xc3, 0xee, 0xea,
0x0d, 0xe5, 0x1e, 0xdc, 0x7c, 0x29, 0x00, 0x69, 0x21, 0x82, 0xe9, 0x06, 0x40, 0x7b, 0xe6, 0x40,
0xb7, 0x9d, 0x84, 0x8c, 0xb8, 0xd4, 0x66, 0x5f, 0x46, 0xf8, 0x5b, 0x1f, 0x70, 0x11, 0xed, 0xf4,
0xd1, 0x24, 0x24, 0x77, 0x48, 0xdd, 0xb4, 0xc5, 0x55, 0x1b, 0x1f, 0xc8, 0x0b, 0xbc, 0x44, 0x70,
0x81, 0xb7, 0xf0, 0x25, 0x98, 0x30, 0x9c, 0x46, 0xb7, 0xb9, 0x0b, 0x6a, 0xd7, 0x9b, 0xa7, 0xf7,
0x79, 0xe5, 0x8b, 0xd0, 0xee, 0xce, 0xbe, 0xab, 0x28, 0xdf, 0x8b, 0xc5, 0x97, 0x36, 0x16, 0x7e,
0x10, 0x9b, 0x5e, 0xe2, 0xd0, 0x0d, 0xb9, 0x52, 0x8d, 0xd4, 0x2c, 0x62, 0x50, 0xeb, 0xe1, 0x3b,
0xa7, 0xe1, 0xd3, 0x75, 0xd3, 0xdf, 0x6d, 0xed, 0xcc, 0x1b, 0x4e, 0xe3, 0x6c, 0xdd, 0xa9, 0x3b,
0xed, 0x8f, 0x41, 0x74, 0xc4, 0x06, 0xec, 0x97, 0xf8, 0x20, 0x94, 0x0e, 0xa4, 0xd3, 0x91, 0x5f,
0x8f, 0x8a, 0x6b, 0x30, 0x21, 0x94, 0x75, 0x76, 0x23, 0xcd, 0xfb, 0x70, 0x74, 0xe8, 0xad, 0x44,
0xfe, 0x47, 0x6f, 0xb3, 0x4a, 0xa7, 0x8d, 0x0b, 0x28, 0x9d, 0xe3, 0x9d, 0x7a, 0x51, 0x83, 0x27,
0x3a, 0xf8, 0xf8, 0xd1, 0x24, 0x6e, 0x04, 0xe3, 0x6b, 0x82, 0x71, 0x22, 0xc4, 0xb8, 0x29, 0xa0,
0xc5, 0x32, 0x8c, 0x1e, 0x85, 0xeb, 0xaf, 0x04, 0x57, 0x96, 0x84, 0x49, 0x96, 0x60, 0x8c, 0x91,
0x18, 0x2d, 0xcf, 0x77, 0x1a, 0x2c, 0xef, 0x1d, 0x4e, 0xf3, 0xd7, 0x6f, 0xf3, 0xb3, 0x92, 0xa3,
0xb0, 0x72, 0x80, 0x2a, 0x7e, 0x01, 0x26, 0xa9, 0x84, 0xa5, 0x96, 0x30, 0x5b, 0xf4, 0x3d, 0x4a,
0xfe, 0xcd, 0x17, 0xf9, 0x91, 0x9a, 0x08, 0x08, 0x42, 0xbc, 0xa1, 0x9d, 0xa8, 0x13, 0xdf, 0x27,
0xae, 0xa7, 0x63, 0xcb, 0x42, 0x87, 0x7e, 0xa1, 0xc9, 0x7f, 0xe3, 0xdd, 0xce, 0x9d, 0x58, 0xe2,
0xc8, 0x92, 0x65, 0x15, 0xb7, 0xe1, 0x58, 0x9f, 0x9d, 0x1d, 0x80, 0xf3, 0x25, 0xc1, 0x39, 0xd9,
0xb3, 0xbb, 0x94, 0x76, 0x03, 0xa4, 0x3c, 0xd8, 0x8f, 0x01, 0x38, 0xbf, 0x29, 0x38, 0x91, 0xc0,
0xca, 0x6d, 0xa1, 0x8c, 0xd7, 0x61, 0xfc, 0x0e, 0x71, 0x77, 0x1c, 0x4f, 0xbc, 0xfc, 0x0f, 0x40,
0xf7, 0xb2, 0xa0, 0x1b, 0x13, 0x40, 0x76, 0x15, 0x40, 0xb9, 0x2e, 0x43, 0xaa, 0x86, 0x0d, 0x32,
0x00, 0xc5, 0xb7, 0x04, 0xc5, 0x08, 0xd5, 0xa7, 0xd0, 0x12, 0x64, 0xeb, 0x8e, 0xa8, 0x2e, 0xd1,
0xf0, 0x6f, 0x0b, 0x78, 0x46, 0x62, 0x04, 0x45, 0xd3, 0x69, 0xb6, 0x2c, 0x5a, 0x7a, 0xa2, 0x29,
0xbe, 0x23, 0x29, 0x24, 0x46, 0x50, 0x1c, 0xc1, 0xad, 0xdf, 0x95, 0x14, 0x5e, 0xc8, 0x9f, 0x57,
0x21, 0xe3, 0xd8, 0xd6, 0x9e, 0x63, 0x0f, 0x62, 0xc4, 0x6f, 0x0a, 0x06, 0x10, 0x10, 0x4a, 0x70,
0x05, 0xd2, 0x83, 0x6e, 0xc4, 0x6f, 0x09, 0x78, 0x8a, 0xc8, 0x1d, 0x58, 0x82, 0x31, 0x99, 0x64,
0x4c, 0xc7, 0x1e, 0x80, 0xe2, 0xb7, 0x05, 0x45, 0x2e, 0x04, 0x13, 0xcb, 0xf0, 0x89, 0xe7, 0xd7,
0xc9, 0x20, 0x24, 0xaf, 0xc8, 0x65, 0x08, 0x88, 0x70, 0xe5, 0x0e, 0xb1, 0x8d, 0xdd, 0xc1, 0x18,
0xbe, 0x2f, 0x5d, 0x29, 0x31, 0x94, 0xa2, 0x0c, 0xa3, 0x0d, 0xec, 0x7a, 0xbb, 0xd8, 0x1a, 0x68,
0x3b, 0x7e, 0x47, 0x70, 0x64, 0x03, 0x90, 0xf0, 0x48, 0xcb, 0x3e, 0x0a, 0xcd, 0x0f, 0xa4, 0x47,
0x42, 0x30, 0x71, 0xf4, 0x3c, 0x9f, 0xdd, 0xaf, 0x1c, 0x85, 0xed, 0x77, 0xe5, 0xd1, 0xe3, 0xd8,
0xd5, 0x30, 0xe3, 0x15, 0x48, 0x7b, 0xe6, 0xfd, 0x81, 0x68, 0x7e, 0x4f, 0xee, 0x34, 0x03, 0x50,
0xf0, 0x4d, 0x38, 0xde, 0x37, 0xd5, 0x0f, 0x40, 0xf6, 0xfb, 0x82, 0x6c, 0xaa, 0x4f, 0xba, 0x17,
0x29, 0xe1, 0xa8, 0x94, 0x7f, 0x20, 0x53, 0x02, 0xe9, 0xe2, 0xda, 0xa0, 0xdd, 0xb9, 0x87, 0x6b,
0x47, 0xf3, 0xda, 0x1f, 0x4a, 0xaf, 0x71, 0x6c, 0x87, 0xd7, 0xb6, 0x60, 0x4a, 0x30, 0x1e, 0x6d,
0x5f, 0x7f, 0x28, 0x13, 0x2b, 0x47, 0x6f, 0x77, 0xee, 0xee, 0x97, 0x60, 0x3a, 0x70, 0xa7, 0x6c,
0x2c, 0x3d, 0xbd, 0x81, 0x9b, 0x03, 0x30, 0xff, 0x48, 0x30, 0xcb, 0x8c, 0x1f, 0x74, 0xa6, 0xde,
0x2a, 0x6e, 0x52, 0xf2, 0x1b, 0x90, 0x97, 0xe4, 0x2d, 0xdb, 0x25, 0x86, 0x53, 0xb7, 0xcd, 0xfb,
0xa4, 0x3a, 0x00, 0xf5, 0x1f, 0x75, 0x6d, 0xd5, 0x76, 0x08, 0x4e, 0x99, 0x97, 0x41, 0x0d, 0xfa,
0x0d, 0xdd, 0x6c, 0x34, 0x1d, 0xd7, 0x8f, 0x60, 0xfc, 0x63, 0xb9, 0x53, 0x01, 0x6e, 0x99, 0xc1,
0x8a, 0x15, 0xc8, 0xb1, 0xe1, 0xa0, 0x21, 0xf9, 0x27, 0x82, 0x68, 0xb4, 0x8d, 0x12, 0x89, 0xc3,
0x70, 0x1a, 0x4d, 0xec, 0x0e, 0x92, 0xff, 0xfe, 0x54, 0x26, 0x0e, 0x01, 0xe1, 0xd1, 0x37, 0xd6,
0x55, 0x89, 0x51, 0xd4, 0xc7, 0xeb, 0xfc, 0x97, 0x1f, 0x89, 0x33, 0xdb, 0x59, 0x88, 0x8b, 0x2b,
0xd4, 0x3d, 0x9d, 0xe5, 0x32, 0x9a, 0xec, 0xc5, 0x47, 0x81, 0x87, 0x3a, 0xaa, 0x65, 0xf1, 0x1a,
0x8c, 0x76, 0x94, 0xca, 0x68, 0xaa, 0xaf, 0x08, 0xaa, 0x6c, 0xb8, 0x52, 0x16, 0x2f, 0x40, 0x82,
0x96, 0xbd, 0x68, 0xf8, 0xcf, 0x08, 0x38, 0x53, 0x2f, 0x7e, 0x16, 0x52, 0xb2, 0xdc, 0x45, 0x43,
0x7f, 0x56, 0x40, 0x03, 0x08, 0x85, 0xcb, 0x52, 0x17, 0x0d, 0xff, 0x39, 0x09, 0x97, 0x10, 0x0a,
0x1f, 0xdc, 0x85, 0xaf, 0x7e, 0x2d, 0x21, 0xd2, 0x95, 0xf4, 0xdd, 0x15, 0x18, 0x11, 0x35, 0x2e,
0x1a, 0xfd, 0x55, 0xf1, 0x70, 0x89, 0x28, 0x3e, 0x0f, 0xc9, 0x01, 0x1d, 0xfe, 0x0b, 0x02, 0xca,
0xf5, 0x8b, 0x65, 0xc8, 0x84, 0xea, 0x5a, 0x34, 0xfc, 0x17, 0x05, 0x3c, 0x8c, 0xa2, 0xa6, 0x8b,
0xba, 0x16, 0x4d, 0xf0, 0x4b, 0xd2, 0x74, 0x81, 0xa0, 0x6e, 0x93, 0x25, 0x2d, 0x1a, 0xfd, 0xcb,
0xd2, 0xeb, 0x12, 0x52, 0xbc, 0x0a, 0xe9, 0x20, 0x4d, 0x45, 0xe3, 0x7f, 0x45, 0xe0, 0xdb, 0x18,
0xea, 0x81, 0x50, 0x9a, 0x8c, 0xa6, 0xf8, 0x55, 0xe9, 0x81, 0x10, 0x8a, 0x1e, 0xa3, 0xee, 0xd2,
0x17, 0xcd, 0xf4, 0x6b, 0xf2, 0x18, 0x75, 0x55, 0x3e, 0xba, 0x9b, 0x2c, 0x5b, 0x44, 0x53, 0xfc,
0xba, 0xdc, 0x4d, 0xa6, 0x4f, 0xcd, 0xe8, 0xae, 0x25, 0xd1, 0x1c, 0xbf, 0x21, 0xcd, 0xe8, 0x2a,
0x25, 0xc5, 0x0d, 0x40, 0xbd, 0x75, 0x24, 0x9a, 0xef, 0xeb, 0x82, 0x6f, 0xbc, 0xa7, 0x8c, 0x14,
0x5f, 0x80, 0xa9, 0xfe, 0x35, 0x24, 0x9a, 0xf5, 0x1b, 0x8f, 0xba, 0xba, 0xfe, 0x70, 0x09, 0x29,
0x6e, 0xb5, 0xbb, 0xfe, 0x70, 0xfd, 0x88, 0xa6, 0x7d, 0xe9, 0x51, 0xe7, 0x8b, 0x5d, 0xb8, 0x7c,
0x14, 0x4b, 0x00, 0xed, 0xd4, 0x1d, 0xcd, 0xf5, 0xb2, 0xe0, 0x0a, 0x81, 0xe8, 0xd1, 0x10, 0x99,
0x3b, 0x1a, 0xff, 0x2d, 0x79, 0x34, 0x04, 0xa2, 0x78, 0x05, 0x52, 0x76, 0xcb, 0xb2, 0x68, 0x70,
0xa0, 0xc3, 0xff, 0x21, 0x24, 0xff, 0xcf, 0x8f, 0xc5, 0xc1, 0x90, 0x80, 0xe2, 0x05, 0x48, 0x92,
0xc6, 0x0e, 0xa9, 0x46, 0x21, 0xff, 0xe5, 0xb1, 0x4c, 0x08, 0x54, 0xbb, 0x78, 0x15, 0x80, 0xbf,
0x34, 0xb2, 0xef, 0x01, 0x11, 0xd8, 0x7f, 0x7d, 0x2c, 0xbe, 0x35, 0xb7, 0x21, 0x6d, 0x02, 0xfe,
0xe5, 0xfa, 0x70, 0x82, 0x77, 0x3b, 0x09, 0xd8, 0x8b, 0xe6, 0x65, 0x18, 0xb9, 0xe5, 0x39, 0xb6,
0x8f, 0xeb, 0x51, 0xe8, 0x7f, 0x13, 0x68, 0xa9, 0x4f, 0x1d, 0xd6, 0x70, 0x5c, 0xe2, 0xe3, 0xba,
0x17, 0x85, 0xfd, 0x77, 0x81, 0x0d, 0x00, 0x14, 0x6c, 0x60, 0xcf, 0x1f, 0x64, 0xdd, 0xff, 0x21,
0xc1, 0x12, 0x40, 0x8d, 0xa6, 0xbf, 0x6f, 0x93, 0xbd, 0x28, 0xec, 0x7b, 0xd2, 0x68, 0xa1, 0x5f,
0xfc, 0x2c, 0xa4, 0xe9, 0x4f, 0xfe, 0xff, 0x17, 0x11, 0xe0, 0xff, 0x14, 0xe0, 0x36, 0x82, 0x3e,
0xd9, 0xf3, 0xab, 0xbe, 0x19, 0xed, 0xec, 0xff, 0x12, 0x3b, 0x2d, 0xf5, 0x8b, 0x25, 0xc8, 0x78,
0x7e, 0xb5, 0xda, 0x72, 0xf9, 0x45, 0x54, 0x04, 0xfc, 0xbf, 0x1f, 0x07, 0x2f, 0x73, 0x01, 0x66,
0xe1, 0x54, 0xff, 0xbb, 0x25, 0x58, 0x72, 0x96, 0x1c, 0x7e, 0xab, 0x04, 0xff, 0x9b, 0x80, 0xb1,
0xc0, 0x5c, 0x79, 0x07, 0x14, 0x08, 0xa6, 0x8f, 0x76, 0x7b, 0x34, 0xfb, 0x97, 0x71, 0x48, 0x95,
0xb1, 0xe7, 0xe3, 0xbb, 0x78, 0x0f, 0x35, 0x61, 0x82, 0xfe, 0x5e, 0xc5, 0x4d, 0x76, 0x8f, 0x21,
0xce, 0x93, 0xb8, 0xa0, 0xfb, 0xd4, 0x7c, 0xfb, 0xa9, 0x12, 0x31, 0xdf, 0x47, 0x9d, 0x7d, 0x13,
0x5c, 0x50, 0x5f, 0xff, 0xfb, 0x93, 0x43, 0x3f, 0xff, 0x0f, 0x27, 0x53, 0xab, 0x7b, 0x2f, 0x98,
0x96, 0xe7, 0xd8, 0x5a, 0x3f, 0x6a, 0xf4, 0x15, 0x05, 0x4e, 0xf4, 0x91, 0xaf, 0x89, 0x53, 0x27,
0xae, 0xb9, 0xcf, 0x0f, 0xf8, 0x68, 0x09, 0xe3, 0x26, 0x64, 0x3b, 0x1e, 0x7f, 0xd8, 0x63, 0xa6,
0x6f, 0x42, 0xfe, 0xa0, 0x95, 0x20, 0x15, 0xe2, 0xb7, 0xc9, 0x9e, 0xf8, 0xaf, 0x3e, 0xfa, 0x13,
0x9d, 0x69, 0xff, 0x57, 0x90, 0x32, 0x97, 0x39, 0x37, 0x1e, 0xb2, 0x4e, 0x3c, 0x8c, 0xcf, 0x17,
0x63, 0x97, 0x94, 0x69, 0x0c, 0x33, 0x51, 0x96, 0xfe, 0x3f, 0x1f, 0x31, 0x5b, 0x80, 0x61, 0x2e,
0x44, 0x93, 0x90, 0x5c, 0xb6, 0xfd, 0x8b, 0xe7, 0x19, 0x55, 0x5c, 0xe3, 0x83, 0x85, 0x95, 0xd7,
0x1f, 0x16, 0x86, 0xde, 0x78, 0x58, 0x18, 0xfa, 0xdb, 0x87, 0x85, 0xa1, 0xb7, 0x1e, 0x16, 0x94,
0x77, 0x1e, 0x16, 0x94, 0xf7, 0x1e, 0x16, 0x94, 0xf7, 0x1f, 0x16, 0x94, 0x07, 0xfb, 0x05, 0xe5,
0xfb, 0xfb, 0x05, 0xe5, 0x87, 0xfb, 0x05, 0xe5, 0xcf, 0xf7, 0x0b, 0xca, 0xab, 0xfb, 0x05, 0xe5,
0xf5, 0xfd, 0xc2, 0xd0, 0x1b, 0xfb, 0x85, 0xa1, 0xb7, 0xf6, 0x0b, 0xca, 0x3b, 0xfb, 0x85, 0xa1,
0xf7, 0xf6, 0x0b, 0xca, 0xfb, 0xfb, 0x85, 0xa1, 0x07, 0xff, 0x58, 0x18, 0xfa, 0xbf, 0x00, 0x00,
0x00, 0xff, 0xff, 0x01, 0x64, 0xba, 0x9f, 0xa6, 0x2e, 0x00, 0x00,
}
r := bytes.NewReader(gzipped)
gzipr, err := compress_gzip.NewReader(r)
@@ -597,11 +607,12 @@ func valueToGoStringCastvalue(v interface{}, typ string) string {
pv := reflect.Indirect(rv).Interface()
return fmt.Sprintf("func(v %v) *%v { return &v } ( %#v )", typ, typ, pv)
}
func extensionToGoStringCastvalue(e map[int32]github_com_gogo_protobuf_proto.Extension) string {
func extensionToGoStringCastvalue(m github_com_gogo_protobuf_proto.Message) string {
e := github_com_gogo_protobuf_proto.GetUnsafeExtensionsMap(m)
if e == nil {
return "nil"
}
s := "map[int32]proto.Extension{"
s := "proto.NewUnsafeXXX_InternalExtensions(map[int32]proto.Extension{"
keys := make([]int, 0, len(e))
for k := range e {
keys = append(keys, int(k))
@@ -611,7 +622,7 @@ func extensionToGoStringCastvalue(e map[int32]github_com_gogo_protobuf_proto.Ext
for _, k := range keys {
ss = append(ss, strconv.Itoa(k)+": "+e[int32(k)].GoString())
}
s += strings.Join(ss, ",") + "}"
s += strings.Join(ss, ",") + "})"
return s
}
func NewPopulatedCastaway(r randyCastvalue, easy bool) *Castaway {
@@ -677,7 +688,7 @@ func randStringCastvalue(r randyCastvalue) string {
}
return string(tmps)
}
func randUnrecognizedCastvalue(r randyCastvalue, maxFieldNumber int) (data []byte) {
func randUnrecognizedCastvalue(r randyCastvalue, maxFieldNumber int) (dAtA []byte) {
l := r.Intn(5)
for i := 0; i < l; i++ {
wire := r.Intn(4)
@@ -685,43 +696,43 @@ func randUnrecognizedCastvalue(r randyCastvalue, maxFieldNumber int) (data []byt
wire = 5
}
fieldNumber := maxFieldNumber + r.Intn(100)
data = randFieldCastvalue(data, r, fieldNumber, wire)
dAtA = randFieldCastvalue(dAtA, r, fieldNumber, wire)
}
return data
return dAtA
}
func randFieldCastvalue(data []byte, r randyCastvalue, fieldNumber int, wire int) []byte {
func randFieldCastvalue(dAtA []byte, r randyCastvalue, fieldNumber int, wire int) []byte {
key := uint32(fieldNumber)<<3 | uint32(wire)
switch wire {
case 0:
data = encodeVarintPopulateCastvalue(data, uint64(key))
dAtA = encodeVarintPopulateCastvalue(dAtA, uint64(key))
v5 := r.Int63()
if r.Intn(2) == 0 {
v5 *= -1
}
data = encodeVarintPopulateCastvalue(data, uint64(v5))
dAtA = encodeVarintPopulateCastvalue(dAtA, uint64(v5))
case 1:
data = encodeVarintPopulateCastvalue(data, uint64(key))
data = append(data, byte(r.Intn(256)), byte(r.Intn(256)), byte(r.Intn(256)), byte(r.Intn(256)), byte(r.Intn(256)), byte(r.Intn(256)), byte(r.Intn(256)), byte(r.Intn(256)))
dAtA = encodeVarintPopulateCastvalue(dAtA, uint64(key))
dAtA = append(dAtA, byte(r.Intn(256)), byte(r.Intn(256)), byte(r.Intn(256)), byte(r.Intn(256)), byte(r.Intn(256)), byte(r.Intn(256)), byte(r.Intn(256)), byte(r.Intn(256)))
case 2:
data = encodeVarintPopulateCastvalue(data, uint64(key))
dAtA = encodeVarintPopulateCastvalue(dAtA, uint64(key))
ll := r.Intn(100)
data = encodeVarintPopulateCastvalue(data, uint64(ll))
dAtA = encodeVarintPopulateCastvalue(dAtA, uint64(ll))
for j := 0; j < ll; j++ {
data = append(data, byte(r.Intn(256)))
dAtA = append(dAtA, byte(r.Intn(256)))
}
default:
data = encodeVarintPopulateCastvalue(data, uint64(key))
data = append(data, byte(r.Intn(256)), byte(r.Intn(256)), byte(r.Intn(256)), byte(r.Intn(256)))
dAtA = encodeVarintPopulateCastvalue(dAtA, uint64(key))
dAtA = append(dAtA, byte(r.Intn(256)), byte(r.Intn(256)), byte(r.Intn(256)), byte(r.Intn(256)))
}
return data
return dAtA
}
func encodeVarintPopulateCastvalue(data []byte, v uint64) []byte {
func encodeVarintPopulateCastvalue(dAtA []byte, v uint64) []byte {
for v >= 1<<7 {
data = append(data, uint8(uint64(v)&0x7f|0x80))
dAtA = append(dAtA, uint8(uint64(v)&0x7f|0x80))
v >>= 7
}
data = append(data, uint8(v))
return data
dAtA = append(dAtA, uint8(v))
return dAtA
}
func (m *Castaway) Size() (n int) {
var l int
@@ -742,8 +753,9 @@ func (m *Castaway) Size() (n int) {
l = 0
if v != nil {
l = ((*Wilson)(v)).Size()
l += 1 + sovCastvalue(uint64(l))
}
mapEntrySize := 1 + sovCastvalue(uint64(k)) + 1 + l + sovCastvalue(uint64(l))
mapEntrySize := 1 + sovCastvalue(uint64(k)) + l
n += mapEntrySize + 1 + sovCastvalue(uint64(mapEntrySize))
}
}
@@ -830,27 +842,30 @@ func valueToStringCastvalue(v interface{}) string {
return fmt.Sprintf("*%v", pv)
}
func init() { proto.RegisterFile("castvalue.proto", fileDescriptorCastvalue) }
var fileDescriptorCastvalue = []byte{
// 322 bytes of a gzipped FileDescriptorProto
// 342 bytes of a gzipped FileDescriptorProto
0x1f, 0x8b, 0x08, 0x00, 0x00, 0x09, 0x6e, 0x88, 0x02, 0xff, 0xe2, 0xe2, 0x4f, 0x4e, 0x2c, 0x2e,
0x29, 0x4b, 0xcc, 0x29, 0x4d, 0xd5, 0x2b, 0x28, 0xca, 0x2f, 0xc9, 0x17, 0xe2, 0x84, 0x0b, 0x48,
0xe9, 0xa6, 0x67, 0x96, 0x64, 0x94, 0x26, 0xe9, 0x25, 0xe7, 0xe7, 0xea, 0xa7, 0xe7, 0xa7, 0xe7,
0xeb, 0x83, 0x55, 0x24, 0x95, 0xa6, 0x81, 0x79, 0x60, 0x0e, 0x98, 0x05, 0xd1, 0xa9, 0x74, 0x90,
0x99, 0x8b, 0xc3, 0x19, 0xa8, 0x39, 0xb1, 0x3c, 0xb1, 0x52, 0xa8, 0x80, 0x4b, 0x18, 0xc4, 0xf6,
0x4d, 0x2c, 0x08, 0x03, 0x99, 0xe5, 0x9b, 0x5a, 0x5c, 0x9c, 0x98, 0x9e, 0x2a, 0xc1, 0xa8, 0xc0,
0xac, 0xc1, 0x6d, 0xa4, 0xa3, 0x87, 0xb0, 0x15, 0xa6, 0x43, 0x0f, 0x8b, 0x72, 0xd7, 0xbc, 0x92,
0xa2, 0x4a, 0x27, 0x81, 0x13, 0xf7, 0xe4, 0x19, 0xba, 0xee, 0xcb, 0x73, 0xf8, 0x56, 0x86, 0x67,
0xe6, 0x14, 0xe7, 0xe7, 0x05, 0x09, 0x27, 0x63, 0xaa, 0x15, 0x6a, 0x61, 0xe4, 0x92, 0xc6, 0x62,
0x86, 0x5f, 0x69, 0x4e, 0x4e, 0x62, 0x52, 0x4e, 0xaa, 0x04, 0x13, 0xd8, 0x6a, 0x13, 0x22, 0xad,
0x86, 0x69, 0x83, 0x38, 0x81, 0x07, 0xc5, 0x7a, 0xe9, 0x64, 0xdc, 0xea, 0xa5, 0x22, 0xb9, 0x24,
0x70, 0xf9, 0x44, 0x48, 0x80, 0x8b, 0x39, 0x3b, 0xb5, 0x12, 0x18, 0x08, 0x8c, 0x1a, 0xac, 0x41,
0x20, 0xa6, 0x90, 0x3a, 0x17, 0x2b, 0xd8, 0x2d, 0x40, 0xd7, 0x31, 0x02, 0x5d, 0x27, 0x88, 0xe4,
0x3a, 0xa8, 0x65, 0x10, 0x79, 0x2b, 0x26, 0x0b, 0x46, 0xa9, 0x44, 0x2e, 0x05, 0x42, 0x2e, 0xa5,
0xd0, 0x0a, 0x25, 0x39, 0x2e, 0x36, 0x88, 0xa0, 0x90, 0x08, 0x17, 0xab, 0x67, 0x5e, 0x89, 0x99,
0x09, 0xd8, 0x28, 0xe6, 0x20, 0xd6, 0x4c, 0x10, 0xc7, 0xc9, 0xe7, 0xc4, 0x43, 0x39, 0x86, 0x0b,
0x40, 0x7c, 0x03, 0x88, 0x1f, 0x3c, 0x94, 0x63, 0x7c, 0x01, 0xc4, 0x1f, 0x80, 0xf8, 0x07, 0x10,
0x37, 0x3c, 0x92, 0x63, 0x5c, 0x01, 0xc4, 0x1b, 0x80, 0x78, 0x07, 0x10, 0x1f, 0x00, 0xe2, 0x13,
0x8f, 0x80, 0xea, 0x81, 0xf8, 0x01, 0x90, 0xfd, 0x02, 0x48, 0x7f, 0x00, 0xd2, 0x3f, 0x80, 0x74,
0xc3, 0x63, 0x39, 0x06, 0x40, 0x00, 0x00, 0x00, 0xff, 0xff, 0xad, 0x1f, 0x01, 0x78, 0x7d, 0x02,
0x00, 0x00,
0x99, 0x8b, 0xc3, 0x39, 0xb1, 0xb8, 0x24, 0xb1, 0x3c, 0xb1, 0x52, 0xa8, 0x80, 0x4b, 0x18, 0xc4,
0xf6, 0x4d, 0x2c, 0x08, 0x03, 0x99, 0xe5, 0x9b, 0x5a, 0x5c, 0x9c, 0x98, 0x9e, 0x2a, 0xc1, 0xa8,
0xc0, 0xac, 0xc1, 0x6d, 0xa4, 0xa3, 0x87, 0xb0, 0x15, 0xa6, 0x43, 0x0f, 0x8b, 0x72, 0xd7, 0xbc,
0x92, 0xa2, 0x4a, 0x27, 0x81, 0x13, 0xf7, 0xe4, 0x19, 0xba, 0xee, 0xcb, 0x73, 0xf8, 0x56, 0x86,
0x67, 0xe6, 0x14, 0xe7, 0xe7, 0x05, 0x61, 0x33, 0x5a, 0xa8, 0x85, 0x91, 0x4b, 0x1a, 0x8b, 0xb8,
0x5f, 0x69, 0x4e, 0x4e, 0x62, 0x52, 0x4e, 0xaa, 0x04, 0x13, 0xd8, 0x6a, 0x13, 0x22, 0xad, 0x86,
0x69, 0x83, 0x38, 0x81, 0x07, 0xc5, 0x7a, 0x7c, 0xd6, 0x48, 0x45, 0x72, 0x49, 0xe0, 0xf2, 0x89,
0x90, 0x00, 0x17, 0x73, 0x76, 0x6a, 0xa5, 0x04, 0xa3, 0x02, 0xa3, 0x06, 0x6b, 0x10, 0x88, 0x29,
0xa4, 0xce, 0xc5, 0x0a, 0x76, 0x8b, 0x04, 0x93, 0x02, 0xa3, 0x06, 0xb7, 0x91, 0x20, 0x92, 0xeb,
0xa0, 0x96, 0x41, 0xe4, 0xad, 0x98, 0x2c, 0x18, 0xa5, 0x12, 0xb9, 0x14, 0x08, 0xb9, 0x94, 0x42,
0x2b, 0x94, 0xe4, 0xb8, 0xd8, 0x20, 0x82, 0x42, 0x22, 0x5c, 0xac, 0x9e, 0x79, 0x25, 0x66, 0x26,
0x60, 0xa3, 0x98, 0x83, 0x20, 0x1c, 0x27, 0x9f, 0x13, 0x0f, 0xe5, 0x18, 0x2e, 0x3c, 0x94, 0x63,
0xb8, 0xf1, 0x50, 0x8e, 0xe1, 0xc1, 0x43, 0x39, 0xc6, 0x17, 0x0f, 0xe5, 0x18, 0x3f, 0x3c, 0x94,
0x63, 0xfc, 0xf1, 0x50, 0x8e, 0xb1, 0xe1, 0x91, 0x1c, 0xe3, 0x8a, 0x47, 0x72, 0x8c, 0x1b, 0x1e,
0xc9, 0x31, 0xee, 0x78, 0x24, 0xc7, 0x78, 0xe0, 0x91, 0x1c, 0xe3, 0x89, 0x47, 0x72, 0x0c, 0x17,
0x1e, 0xc9, 0x31, 0x3c, 0x78, 0x24, 0xc7, 0xf8, 0xe2, 0x91, 0x1c, 0xc3, 0x87, 0x47, 0x72, 0x8c,
0x3f, 0x1e, 0xc9, 0x31, 0x34, 0x3c, 0x96, 0x63, 0x00, 0x04, 0x00, 0x00, 0xff, 0xff, 0x7b, 0x8b,
0x19, 0x68, 0x7d, 0x02, 0x00, 0x00,
}

66
vendor/github.com/gogo/protobuf/test/castvalue/castvalue.proto generated vendored Normal file
View File

@@ -0,0 +1,66 @@
// Protocol Buffers for Go with Gadgets
//
// Copyright (c) 2015, 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.
syntax = "proto2";
package castvalue;
import "github.com/gogo/protobuf/gogoproto/gogo.proto";
option (gogoproto.goproto_stringer_all) = false;
option (gogoproto.goproto_enum_prefix_all) = false;
option (gogoproto.goproto_getters_all) = false;
option (gogoproto.equal_all) = true;
option (gogoproto.verbose_equal_all) = true;
option (gogoproto.stringer_all) = true;
option (gogoproto.gostring_all) = true;
option (gogoproto.face_all) = true;
option (gogoproto.description_all) = true;
option (gogoproto.testgen_all) = true;
option (gogoproto.populate_all) = true;
option (gogoproto.benchgen_all) = true;
option (gogoproto.unmarshaler_all) = false;
option (gogoproto.marshaler_all) = false;
option (gogoproto.sizer_all) = true;
option (gogoproto.goproto_enum_stringer_all) = false;
option (gogoproto.enum_stringer_all) = true;
option (gogoproto.unsafe_marshaler_all) = false;
option (gogoproto.unsafe_unmarshaler_all) = false;
message Castaway {
map<int32,Wilson> CastMapValueMessage = 1 [(gogoproto.castvalue) = "MyWilson", (gogoproto.nullable) = false];
map<int32,Wilson> CastMapValueMessageNullable = 2 [(gogoproto.castvalue) = "MyWilson"];
}
message Wilson {
optional int64 Int64 = 1;
}

457
vendor/github.com/gogo/protobuf/test/castvalue/castvaluepb_test.go generated vendored Normal file
View File

@@ -0,0 +1,457 @@
// Code generated by protoc-gen-gogo.
// source: castvalue.proto
// DO NOT EDIT!
/*
Package castvalue is a generated protocol buffer package.
It is generated from these files:
castvalue.proto
It has these top-level messages:
Castaway
Wilson
*/
package castvalue
import testing "testing"
import math_rand "math/rand"
import time "time"
import github_com_gogo_protobuf_proto "github.com/gogo/protobuf/proto"
import github_com_gogo_protobuf_jsonpb "github.com/gogo/protobuf/jsonpb"
import fmt "fmt"
import go_parser "go/parser"
import proto "github.com/gogo/protobuf/proto"
import math "math"
import _ "github.com/gogo/protobuf/gogoproto"
// Reference imports to suppress errors if they are not otherwise used.
var _ = proto.Marshal
var _ = fmt.Errorf
var _ = math.Inf
func TestCastawayProto(t *testing.T) {
seed := time.Now().UnixNano()
popr := math_rand.New(math_rand.NewSource(seed))
p := NewPopulatedCastaway(popr, false)
dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
if err != nil {
t.Fatalf("seed = %d, err = %v", seed, err)
}
msg := &Castaway{}
if err := github_com_gogo_protobuf_proto.Unmarshal(dAtA, msg); err != nil {
t.Fatalf("seed = %d, err = %v", seed, err)
}
littlefuzz := make([]byte, len(dAtA))
copy(littlefuzz, dAtA)
for i := range dAtA {
dAtA[i] = byte(popr.Intn(256))
}
if err := p.VerboseEqual(msg); err != nil {
t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
}
if !p.Equal(msg) {
t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p)
}
if len(littlefuzz) > 0 {
fuzzamount := 100
for i := 0; i < fuzzamount; i++ {
littlefuzz[popr.Intn(len(littlefuzz))] = byte(popr.Intn(256))
littlefuzz = append(littlefuzz, byte(popr.Intn(256)))
}
// shouldn't panic
_ = github_com_gogo_protobuf_proto.Unmarshal(littlefuzz, msg)
}
}
func BenchmarkCastawayProtoMarshal(b *testing.B) {
popr := math_rand.New(math_rand.NewSource(616))
total := 0
pops := make([]*Castaway, 10000)
for i := 0; i < 10000; i++ {
pops[i] = NewPopulatedCastaway(popr, false)
}
b.ResetTimer()
for i := 0; i < b.N; i++ {
dAtA, err := github_com_gogo_protobuf_proto.Marshal(pops[i%10000])
if err != nil {
panic(err)
}
total += len(dAtA)
}
b.SetBytes(int64(total / b.N))
}
func BenchmarkCastawayProtoUnmarshal(b *testing.B) {
popr := math_rand.New(math_rand.NewSource(616))
total := 0
datas := make([][]byte, 10000)
for i := 0; i < 10000; i++ {
dAtA, err := github_com_gogo_protobuf_proto.Marshal(NewPopulatedCastaway(popr, false))
if err != nil {
panic(err)
}
datas[i] = dAtA
}
msg := &Castaway{}
b.ResetTimer()
for i := 0; i < b.N; i++ {
total += len(datas[i%10000])
if err := github_com_gogo_protobuf_proto.Unmarshal(datas[i%10000], msg); err != nil {
panic(err)
}
}
b.SetBytes(int64(total / b.N))
}
func TestWilsonProto(t *testing.T) {
seed := time.Now().UnixNano()
popr := math_rand.New(math_rand.NewSource(seed))
p := NewPopulatedWilson(popr, false)
dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
if err != nil {
t.Fatalf("seed = %d, err = %v", seed, err)
}
msg := &Wilson{}
if err := github_com_gogo_protobuf_proto.Unmarshal(dAtA, msg); err != nil {
t.Fatalf("seed = %d, err = %v", seed, err)
}
littlefuzz := make([]byte, len(dAtA))
copy(littlefuzz, dAtA)
for i := range dAtA {
dAtA[i] = byte(popr.Intn(256))
}
if err := p.VerboseEqual(msg); err != nil {
t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
}
if !p.Equal(msg) {
t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p)
}
if len(littlefuzz) > 0 {
fuzzamount := 100
for i := 0; i < fuzzamount; i++ {
littlefuzz[popr.Intn(len(littlefuzz))] = byte(popr.Intn(256))
littlefuzz = append(littlefuzz, byte(popr.Intn(256)))
}
// shouldn't panic
_ = github_com_gogo_protobuf_proto.Unmarshal(littlefuzz, msg)
}
}
func BenchmarkWilsonProtoMarshal(b *testing.B) {
popr := math_rand.New(math_rand.NewSource(616))
total := 0
pops := make([]*Wilson, 10000)
for i := 0; i < 10000; i++ {
pops[i] = NewPopulatedWilson(popr, false)
}
b.ResetTimer()
for i := 0; i < b.N; i++ {
dAtA, err := github_com_gogo_protobuf_proto.Marshal(pops[i%10000])
if err != nil {
panic(err)
}
total += len(dAtA)
}
b.SetBytes(int64(total / b.N))
}
func BenchmarkWilsonProtoUnmarshal(b *testing.B) {
popr := math_rand.New(math_rand.NewSource(616))
total := 0
datas := make([][]byte, 10000)
for i := 0; i < 10000; i++ {
dAtA, err := github_com_gogo_protobuf_proto.Marshal(NewPopulatedWilson(popr, false))
if err != nil {
panic(err)
}
datas[i] = dAtA
}
msg := &Wilson{}
b.ResetTimer()
for i := 0; i < b.N; i++ {
total += len(datas[i%10000])
if err := github_com_gogo_protobuf_proto.Unmarshal(datas[i%10000], msg); err != nil {
panic(err)
}
}
b.SetBytes(int64(total / b.N))
}
func TestCastawayJSON(t *testing.T) {
seed := time.Now().UnixNano()
popr := math_rand.New(math_rand.NewSource(seed))
p := NewPopulatedCastaway(popr, true)
marshaler := github_com_gogo_protobuf_jsonpb.Marshaler{}
jsondata, err := marshaler.MarshalToString(p)
if err != nil {
t.Fatalf("seed = %d, err = %v", seed, err)
}
msg := &Castaway{}
err = github_com_gogo_protobuf_jsonpb.UnmarshalString(jsondata, msg)
if err != nil {
t.Fatalf("seed = %d, err = %v", seed, err)
}
if err := p.VerboseEqual(msg); err != nil {
t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
}
if !p.Equal(msg) {
t.Fatalf("seed = %d, %#v !Json Equal %#v", seed, msg, p)
}
}
func TestWilsonJSON(t *testing.T) {
seed := time.Now().UnixNano()
popr := math_rand.New(math_rand.NewSource(seed))
p := NewPopulatedWilson(popr, true)
marshaler := github_com_gogo_protobuf_jsonpb.Marshaler{}
jsondata, err := marshaler.MarshalToString(p)
if err != nil {
t.Fatalf("seed = %d, err = %v", seed, err)
}
msg := &Wilson{}
err = github_com_gogo_protobuf_jsonpb.UnmarshalString(jsondata, msg)
if err != nil {
t.Fatalf("seed = %d, err = %v", seed, err)
}
if err := p.VerboseEqual(msg); err != nil {
t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
}
if !p.Equal(msg) {
t.Fatalf("seed = %d, %#v !Json Equal %#v", seed, msg, p)
}
}
func TestCastawayProtoText(t *testing.T) {
seed := time.Now().UnixNano()
popr := math_rand.New(math_rand.NewSource(seed))
p := NewPopulatedCastaway(popr, true)
dAtA := github_com_gogo_protobuf_proto.MarshalTextString(p)
msg := &Castaway{}
if err := github_com_gogo_protobuf_proto.UnmarshalText(dAtA, msg); err != nil {
t.Fatalf("seed = %d, err = %v", seed, err)
}
if err := p.VerboseEqual(msg); err != nil {
t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
}
if !p.Equal(msg) {
t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p)
}
}
func TestCastawayProtoCompactText(t *testing.T) {
seed := time.Now().UnixNano()
popr := math_rand.New(math_rand.NewSource(seed))
p := NewPopulatedCastaway(popr, true)
dAtA := github_com_gogo_protobuf_proto.CompactTextString(p)
msg := &Castaway{}
if err := github_com_gogo_protobuf_proto.UnmarshalText(dAtA, msg); err != nil {
t.Fatalf("seed = %d, err = %v", seed, err)
}
if err := p.VerboseEqual(msg); err != nil {
t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
}
if !p.Equal(msg) {
t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p)
}
}
func TestWilsonProtoText(t *testing.T) {
seed := time.Now().UnixNano()
popr := math_rand.New(math_rand.NewSource(seed))
p := NewPopulatedWilson(popr, true)
dAtA := github_com_gogo_protobuf_proto.MarshalTextString(p)
msg := &Wilson{}
if err := github_com_gogo_protobuf_proto.UnmarshalText(dAtA, msg); err != nil {
t.Fatalf("seed = %d, err = %v", seed, err)
}
if err := p.VerboseEqual(msg); err != nil {
t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
}
if !p.Equal(msg) {
t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p)
}
}
func TestWilsonProtoCompactText(t *testing.T) {
seed := time.Now().UnixNano()
popr := math_rand.New(math_rand.NewSource(seed))
p := NewPopulatedWilson(popr, true)
dAtA := github_com_gogo_protobuf_proto.CompactTextString(p)
msg := &Wilson{}
if err := github_com_gogo_protobuf_proto.UnmarshalText(dAtA, msg); err != nil {
t.Fatalf("seed = %d, err = %v", seed, err)
}
if err := p.VerboseEqual(msg); err != nil {
t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
}
if !p.Equal(msg) {
t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p)
}
}
func TestCastvalueDescription(t *testing.T) {
CastvalueDescription()
}
func TestCastawayVerboseEqual(t *testing.T) {
popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
p := NewPopulatedCastaway(popr, false)
dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
if err != nil {
panic(err)
}
msg := &Castaway{}
if err := github_com_gogo_protobuf_proto.Unmarshal(dAtA, msg); err != nil {
panic(err)
}
if err := p.VerboseEqual(msg); err != nil {
t.Fatalf("%#v !VerboseEqual %#v, since %v", msg, p, err)
}
}
func TestWilsonVerboseEqual(t *testing.T) {
popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
p := NewPopulatedWilson(popr, false)
dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
if err != nil {
panic(err)
}
msg := &Wilson{}
if err := github_com_gogo_protobuf_proto.Unmarshal(dAtA, msg); err != nil {
panic(err)
}
if err := p.VerboseEqual(msg); err != nil {
t.Fatalf("%#v !VerboseEqual %#v, since %v", msg, p, err)
}
}
func TestCastawayFace(t *testing.T) {
popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
p := NewPopulatedCastaway(popr, true)
msg := p.TestProto()
if !p.Equal(msg) {
t.Fatalf("%#v !Face Equal %#v", msg, p)
}
}
func TestWilsonFace(t *testing.T) {
popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
p := NewPopulatedWilson(popr, true)
msg := p.TestProto()
if !p.Equal(msg) {
t.Fatalf("%#v !Face Equal %#v", msg, p)
}
}
func TestCastawayGoString(t *testing.T) {
popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
p := NewPopulatedCastaway(popr, false)
s1 := p.GoString()
s2 := fmt.Sprintf("%#v", p)
if s1 != s2 {
t.Fatalf("GoString want %v got %v", s1, s2)
}
_, err := go_parser.ParseExpr(s1)
if err != nil {
panic(err)
}
}
func TestWilsonGoString(t *testing.T) {
popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
p := NewPopulatedWilson(popr, false)
s1 := p.GoString()
s2 := fmt.Sprintf("%#v", p)
if s1 != s2 {
t.Fatalf("GoString want %v got %v", s1, s2)
}
_, err := go_parser.ParseExpr(s1)
if err != nil {
panic(err)
}
}
func TestCastawaySize(t *testing.T) {
seed := time.Now().UnixNano()
popr := math_rand.New(math_rand.NewSource(seed))
p := NewPopulatedCastaway(popr, true)
size2 := github_com_gogo_protobuf_proto.Size(p)
dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
if err != nil {
t.Fatalf("seed = %d, err = %v", seed, err)
}
size := p.Size()
if len(dAtA) != size {
t.Errorf("seed = %d, size %v != marshalled size %v", seed, size, len(dAtA))
}
if size2 != size {
t.Errorf("seed = %d, size %v != before marshal proto.Size %v", seed, size, size2)
}
size3 := github_com_gogo_protobuf_proto.Size(p)
if size3 != size {
t.Errorf("seed = %d, size %v != after marshal proto.Size %v", seed, size, size3)
}
}
func BenchmarkCastawaySize(b *testing.B) {
popr := math_rand.New(math_rand.NewSource(616))
total := 0
pops := make([]*Castaway, 1000)
for i := 0; i < 1000; i++ {
pops[i] = NewPopulatedCastaway(popr, false)
}
b.ResetTimer()
for i := 0; i < b.N; i++ {
total += pops[i%1000].Size()
}
b.SetBytes(int64(total / b.N))
}
func TestWilsonSize(t *testing.T) {
seed := time.Now().UnixNano()
popr := math_rand.New(math_rand.NewSource(seed))
p := NewPopulatedWilson(popr, true)
size2 := github_com_gogo_protobuf_proto.Size(p)
dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
if err != nil {
t.Fatalf("seed = %d, err = %v", seed, err)
}
size := p.Size()
if len(dAtA) != size {
t.Errorf("seed = %d, size %v != marshalled size %v", seed, size, len(dAtA))
}
if size2 != size {
t.Errorf("seed = %d, size %v != before marshal proto.Size %v", seed, size, size2)
}
size3 := github_com_gogo_protobuf_proto.Size(p)
if size3 != size {
t.Errorf("seed = %d, size %v != after marshal proto.Size %v", seed, size, size3)
}
}
func BenchmarkWilsonSize(b *testing.B) {
popr := math_rand.New(math_rand.NewSource(616))
total := 0
pops := make([]*Wilson, 1000)
for i := 0; i < 1000; i++ {
pops[i] = NewPopulatedWilson(popr, false)
}
b.ResetTimer()
for i := 0; i < b.N; i++ {
total += pops[i%1000].Size()
}
b.SetBytes(int64(total / b.N))
}
func TestCastawayStringer(t *testing.T) {
popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
p := NewPopulatedCastaway(popr, false)
s1 := p.String()
s2 := fmt.Sprintf("%v", p)
if s1 != s2 {
t.Fatalf("String want %v got %v", s1, s2)
}
}
func TestWilsonStringer(t *testing.T) {
popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
p := NewPopulatedWilson(popr, false)
s1 := p.String()
s2 := fmt.Sprintf("%v", p)
if s1 != s2 {
t.Fatalf("String want %v got %v", s1, s2)
}
}
//These tests are generated by github.com/gogo/protobuf/plugin/testgen

910
vendor/github.com/gogo/protobuf/test/castvalue/combos/both/castvalue.pb.go generated vendored
View File

File diff suppressed because it is too large Load Diff

66
vendor/github.com/gogo/protobuf/test/castvalue/combos/both/castvalue.proto generated vendored Normal file
View File

@@ -0,0 +1,66 @@
// Protocol Buffers for Go with Gadgets
//
// Copyright (c) 2015, 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.
syntax = "proto2";
package castvalue;
import "github.com/gogo/protobuf/gogoproto/gogo.proto";
option (gogoproto.goproto_stringer_all) = false;
option (gogoproto.goproto_enum_prefix_all) = false;
option (gogoproto.goproto_getters_all) = false;
option (gogoproto.equal_all) = true;
option (gogoproto.verbose_equal_all) = true;
option (gogoproto.stringer_all) = true;
option (gogoproto.gostring_all) = true;
option (gogoproto.face_all) = true;
option (gogoproto.description_all) = true;
option (gogoproto.testgen_all) = true;
option (gogoproto.populate_all) = true;
option (gogoproto.benchgen_all) = true;
option (gogoproto.unmarshaler_all) = true;
option (gogoproto.marshaler_all) = true;
option (gogoproto.sizer_all) = true;
option (gogoproto.goproto_enum_stringer_all) = false;
option (gogoproto.enum_stringer_all) = true;
option (gogoproto.unsafe_marshaler_all) = false;
option (gogoproto.unsafe_unmarshaler_all) = false;
message Castaway {
map<int32,Wilson> CastMapValueMessage = 1 [(gogoproto.castvalue) = "MyWilson", (gogoproto.nullable) = false];
map<int32,Wilson> CastMapValueMessageNullable = 2 [(gogoproto.castvalue) = "MyWilson"];
}
message Wilson {
optional int64 Int64 = 1;
}

513
vendor/github.com/gogo/protobuf/test/castvalue/combos/both/castvaluepb_test.go generated vendored Normal file
View File

@@ -0,0 +1,513 @@
// Code generated by protoc-gen-gogo.
// source: combos/both/castvalue.proto
// DO NOT EDIT!
/*
Package castvalue is a generated protocol buffer package.
It is generated from these files:
combos/both/castvalue.proto
It has these top-level messages:
Castaway
Wilson
*/
package castvalue
import testing "testing"
import math_rand "math/rand"
import time "time"
import github_com_gogo_protobuf_proto "github.com/gogo/protobuf/proto"
import github_com_gogo_protobuf_jsonpb "github.com/gogo/protobuf/jsonpb"
import fmt "fmt"
import go_parser "go/parser"
import proto "github.com/gogo/protobuf/proto"
import math "math"
import _ "github.com/gogo/protobuf/gogoproto"
// Reference imports to suppress errors if they are not otherwise used.
var _ = proto.Marshal
var _ = fmt.Errorf
var _ = math.Inf
func TestCastawayProto(t *testing.T) {
seed := time.Now().UnixNano()
popr := math_rand.New(math_rand.NewSource(seed))
p := NewPopulatedCastaway(popr, false)
dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
if err != nil {
t.Fatalf("seed = %d, err = %v", seed, err)
}
msg := &Castaway{}
if err := github_com_gogo_protobuf_proto.Unmarshal(dAtA, msg); err != nil {
t.Fatalf("seed = %d, err = %v", seed, err)
}
littlefuzz := make([]byte, len(dAtA))
copy(littlefuzz, dAtA)
for i := range dAtA {
dAtA[i] = byte(popr.Intn(256))
}
if err := p.VerboseEqual(msg); err != nil {
t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
}
if !p.Equal(msg) {
t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p)
}
if len(littlefuzz) > 0 {
fuzzamount := 100
for i := 0; i < fuzzamount; i++ {
littlefuzz[popr.Intn(len(littlefuzz))] = byte(popr.Intn(256))
littlefuzz = append(littlefuzz, byte(popr.Intn(256)))
}
// shouldn't panic
_ = github_com_gogo_protobuf_proto.Unmarshal(littlefuzz, msg)
}
}
func TestCastawayMarshalTo(t *testing.T) {
seed := time.Now().UnixNano()
popr := math_rand.New(math_rand.NewSource(seed))
p := NewPopulatedCastaway(popr, false)
size := p.Size()
dAtA := make([]byte, size)
for i := range dAtA {
dAtA[i] = byte(popr.Intn(256))
}
_, err := p.MarshalTo(dAtA)
if err != nil {
t.Fatalf("seed = %d, err = %v", seed, err)
}
msg := &Castaway{}
if err := github_com_gogo_protobuf_proto.Unmarshal(dAtA, msg); err != nil {
t.Fatalf("seed = %d, err = %v", seed, err)
}
for i := range dAtA {
dAtA[i] = byte(popr.Intn(256))
}
if err := p.VerboseEqual(msg); err != nil {
t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
}
if !p.Equal(msg) {
t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p)
}
}
func BenchmarkCastawayProtoMarshal(b *testing.B) {
popr := math_rand.New(math_rand.NewSource(616))
total := 0
pops := make([]*Castaway, 10000)
for i := 0; i < 10000; i++ {
pops[i] = NewPopulatedCastaway(popr, false)
}
b.ResetTimer()
for i := 0; i < b.N; i++ {
dAtA, err := github_com_gogo_protobuf_proto.Marshal(pops[i%10000])
if err != nil {
panic(err)
}
total += len(dAtA)
}
b.SetBytes(int64(total / b.N))
}
func BenchmarkCastawayProtoUnmarshal(b *testing.B) {
popr := math_rand.New(math_rand.NewSource(616))
total := 0
datas := make([][]byte, 10000)
for i := 0; i < 10000; i++ {
dAtA, err := github_com_gogo_protobuf_proto.Marshal(NewPopulatedCastaway(popr, false))
if err != nil {
panic(err)
}
datas[i] = dAtA
}
msg := &Castaway{}
b.ResetTimer()
for i := 0; i < b.N; i++ {
total += len(datas[i%10000])
if err := github_com_gogo_protobuf_proto.Unmarshal(datas[i%10000], msg); err != nil {
panic(err)
}
}
b.SetBytes(int64(total / b.N))
}
func TestWilsonProto(t *testing.T) {
seed := time.Now().UnixNano()
popr := math_rand.New(math_rand.NewSource(seed))
p := NewPopulatedWilson(popr, false)
dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
if err != nil {
t.Fatalf("seed = %d, err = %v", seed, err)
}
msg := &Wilson{}
if err := github_com_gogo_protobuf_proto.Unmarshal(dAtA, msg); err != nil {
t.Fatalf("seed = %d, err = %v", seed, err)
}
littlefuzz := make([]byte, len(dAtA))
copy(littlefuzz, dAtA)
for i := range dAtA {
dAtA[i] = byte(popr.Intn(256))
}
if err := p.VerboseEqual(msg); err != nil {
t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
}
if !p.Equal(msg) {
t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p)
}
if len(littlefuzz) > 0 {
fuzzamount := 100
for i := 0; i < fuzzamount; i++ {
littlefuzz[popr.Intn(len(littlefuzz))] = byte(popr.Intn(256))
littlefuzz = append(littlefuzz, byte(popr.Intn(256)))
}
// shouldn't panic
_ = github_com_gogo_protobuf_proto.Unmarshal(littlefuzz, msg)
}
}
func TestWilsonMarshalTo(t *testing.T) {
seed := time.Now().UnixNano()
popr := math_rand.New(math_rand.NewSource(seed))
p := NewPopulatedWilson(popr, false)
size := p.Size()
dAtA := make([]byte, size)
for i := range dAtA {
dAtA[i] = byte(popr.Intn(256))
}
_, err := p.MarshalTo(dAtA)
if err != nil {
t.Fatalf("seed = %d, err = %v", seed, err)
}
msg := &Wilson{}
if err := github_com_gogo_protobuf_proto.Unmarshal(dAtA, msg); err != nil {
t.Fatalf("seed = %d, err = %v", seed, err)
}
for i := range dAtA {
dAtA[i] = byte(popr.Intn(256))
}
if err := p.VerboseEqual(msg); err != nil {
t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
}
if !p.Equal(msg) {
t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p)
}
}
func BenchmarkWilsonProtoMarshal(b *testing.B) {
popr := math_rand.New(math_rand.NewSource(616))
total := 0
pops := make([]*Wilson, 10000)
for i := 0; i < 10000; i++ {
pops[i] = NewPopulatedWilson(popr, false)
}
b.ResetTimer()
for i := 0; i < b.N; i++ {
dAtA, err := github_com_gogo_protobuf_proto.Marshal(pops[i%10000])
if err != nil {
panic(err)
}
total += len(dAtA)
}
b.SetBytes(int64(total / b.N))
}
func BenchmarkWilsonProtoUnmarshal(b *testing.B) {
popr := math_rand.New(math_rand.NewSource(616))
total := 0
datas := make([][]byte, 10000)
for i := 0; i < 10000; i++ {
dAtA, err := github_com_gogo_protobuf_proto.Marshal(NewPopulatedWilson(popr, false))
if err != nil {
panic(err)
}
datas[i] = dAtA
}
msg := &Wilson{}
b.ResetTimer()
for i := 0; i < b.N; i++ {
total += len(datas[i%10000])
if err := github_com_gogo_protobuf_proto.Unmarshal(datas[i%10000], msg); err != nil {
panic(err)
}
}
b.SetBytes(int64(total / b.N))
}
func TestCastawayJSON(t *testing.T) {
seed := time.Now().UnixNano()
popr := math_rand.New(math_rand.NewSource(seed))
p := NewPopulatedCastaway(popr, true)
marshaler := github_com_gogo_protobuf_jsonpb.Marshaler{}
jsondata, err := marshaler.MarshalToString(p)
if err != nil {
t.Fatalf("seed = %d, err = %v", seed, err)
}
msg := &Castaway{}
err = github_com_gogo_protobuf_jsonpb.UnmarshalString(jsondata, msg)
if err != nil {
t.Fatalf("seed = %d, err = %v", seed, err)
}
if err := p.VerboseEqual(msg); err != nil {
t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
}
if !p.Equal(msg) {
t.Fatalf("seed = %d, %#v !Json Equal %#v", seed, msg, p)
}
}
func TestWilsonJSON(t *testing.T) {
seed := time.Now().UnixNano()
popr := math_rand.New(math_rand.NewSource(seed))
p := NewPopulatedWilson(popr, true)
marshaler := github_com_gogo_protobuf_jsonpb.Marshaler{}
jsondata, err := marshaler.MarshalToString(p)
if err != nil {
t.Fatalf("seed = %d, err = %v", seed, err)
}
msg := &Wilson{}
err = github_com_gogo_protobuf_jsonpb.UnmarshalString(jsondata, msg)
if err != nil {
t.Fatalf("seed = %d, err = %v", seed, err)
}
if err := p.VerboseEqual(msg); err != nil {
t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
}
if !p.Equal(msg) {
t.Fatalf("seed = %d, %#v !Json Equal %#v", seed, msg, p)
}
}
func TestCastawayProtoText(t *testing.T) {
seed := time.Now().UnixNano()
popr := math_rand.New(math_rand.NewSource(seed))
p := NewPopulatedCastaway(popr, true)
dAtA := github_com_gogo_protobuf_proto.MarshalTextString(p)
msg := &Castaway{}
if err := github_com_gogo_protobuf_proto.UnmarshalText(dAtA, msg); err != nil {
t.Fatalf("seed = %d, err = %v", seed, err)
}
if err := p.VerboseEqual(msg); err != nil {
t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
}
if !p.Equal(msg) {
t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p)
}
}
func TestCastawayProtoCompactText(t *testing.T) {
seed := time.Now().UnixNano()
popr := math_rand.New(math_rand.NewSource(seed))
p := NewPopulatedCastaway(popr, true)
dAtA := github_com_gogo_protobuf_proto.CompactTextString(p)
msg := &Castaway{}
if err := github_com_gogo_protobuf_proto.UnmarshalText(dAtA, msg); err != nil {
t.Fatalf("seed = %d, err = %v", seed, err)
}
if err := p.VerboseEqual(msg); err != nil {
t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
}
if !p.Equal(msg) {
t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p)
}
}
func TestWilsonProtoText(t *testing.T) {
seed := time.Now().UnixNano()
popr := math_rand.New(math_rand.NewSource(seed))
p := NewPopulatedWilson(popr, true)
dAtA := github_com_gogo_protobuf_proto.MarshalTextString(p)
msg := &Wilson{}
if err := github_com_gogo_protobuf_proto.UnmarshalText(dAtA, msg); err != nil {
t.Fatalf("seed = %d, err = %v", seed, err)
}
if err := p.VerboseEqual(msg); err != nil {
t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
}
if !p.Equal(msg) {
t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p)
}
}
func TestWilsonProtoCompactText(t *testing.T) {
seed := time.Now().UnixNano()
popr := math_rand.New(math_rand.NewSource(seed))
p := NewPopulatedWilson(popr, true)
dAtA := github_com_gogo_protobuf_proto.CompactTextString(p)
msg := &Wilson{}
if err := github_com_gogo_protobuf_proto.UnmarshalText(dAtA, msg); err != nil {
t.Fatalf("seed = %d, err = %v", seed, err)
}
if err := p.VerboseEqual(msg); err != nil {
t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
}
if !p.Equal(msg) {
t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p)
}
}
func TestCastvalueDescription(t *testing.T) {
CastvalueDescription()
}
func TestCastawayVerboseEqual(t *testing.T) {
popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
p := NewPopulatedCastaway(popr, false)
dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
if err != nil {
panic(err)
}
msg := &Castaway{}
if err := github_com_gogo_protobuf_proto.Unmarshal(dAtA, msg); err != nil {
panic(err)
}
if err := p.VerboseEqual(msg); err != nil {
t.Fatalf("%#v !VerboseEqual %#v, since %v", msg, p, err)
}
}
func TestWilsonVerboseEqual(t *testing.T) {
popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
p := NewPopulatedWilson(popr, false)
dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
if err != nil {
panic(err)
}
msg := &Wilson{}
if err := github_com_gogo_protobuf_proto.Unmarshal(dAtA, msg); err != nil {
panic(err)
}
if err := p.VerboseEqual(msg); err != nil {
t.Fatalf("%#v !VerboseEqual %#v, since %v", msg, p, err)
}
}
func TestCastawayFace(t *testing.T) {
popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
p := NewPopulatedCastaway(popr, true)
msg := p.TestProto()
if !p.Equal(msg) {
t.Fatalf("%#v !Face Equal %#v", msg, p)
}
}
func TestWilsonFace(t *testing.T) {
popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
p := NewPopulatedWilson(popr, true)
msg := p.TestProto()
if !p.Equal(msg) {
t.Fatalf("%#v !Face Equal %#v", msg, p)
}
}
func TestCastawayGoString(t *testing.T) {
popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
p := NewPopulatedCastaway(popr, false)
s1 := p.GoString()
s2 := fmt.Sprintf("%#v", p)
if s1 != s2 {
t.Fatalf("GoString want %v got %v", s1, s2)
}
_, err := go_parser.ParseExpr(s1)
if err != nil {
panic(err)
}
}
func TestWilsonGoString(t *testing.T) {
popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
p := NewPopulatedWilson(popr, false)
s1 := p.GoString()
s2 := fmt.Sprintf("%#v", p)
if s1 != s2 {
t.Fatalf("GoString want %v got %v", s1, s2)
}
_, err := go_parser.ParseExpr(s1)
if err != nil {
panic(err)
}
}
func TestCastawaySize(t *testing.T) {
seed := time.Now().UnixNano()
popr := math_rand.New(math_rand.NewSource(seed))
p := NewPopulatedCastaway(popr, true)
size2 := github_com_gogo_protobuf_proto.Size(p)
dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
if err != nil {
t.Fatalf("seed = %d, err = %v", seed, err)
}
size := p.Size()
if len(dAtA) != size {
t.Errorf("seed = %d, size %v != marshalled size %v", seed, size, len(dAtA))
}
if size2 != size {
t.Errorf("seed = %d, size %v != before marshal proto.Size %v", seed, size, size2)
}
size3 := github_com_gogo_protobuf_proto.Size(p)
if size3 != size {
t.Errorf("seed = %d, size %v != after marshal proto.Size %v", seed, size, size3)
}
}
func BenchmarkCastawaySize(b *testing.B) {
popr := math_rand.New(math_rand.NewSource(616))
total := 0
pops := make([]*Castaway, 1000)
for i := 0; i < 1000; i++ {
pops[i] = NewPopulatedCastaway(popr, false)
}
b.ResetTimer()
for i := 0; i < b.N; i++ {
total += pops[i%1000].Size()
}
b.SetBytes(int64(total / b.N))
}
func TestWilsonSize(t *testing.T) {
seed := time.Now().UnixNano()
popr := math_rand.New(math_rand.NewSource(seed))
p := NewPopulatedWilson(popr, true)
size2 := github_com_gogo_protobuf_proto.Size(p)
dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
if err != nil {
t.Fatalf("seed = %d, err = %v", seed, err)
}
size := p.Size()
if len(dAtA) != size {
t.Errorf("seed = %d, size %v != marshalled size %v", seed, size, len(dAtA))
}
if size2 != size {
t.Errorf("seed = %d, size %v != before marshal proto.Size %v", seed, size, size2)
}
size3 := github_com_gogo_protobuf_proto.Size(p)
if size3 != size {
t.Errorf("seed = %d, size %v != after marshal proto.Size %v", seed, size, size3)
}
}
func BenchmarkWilsonSize(b *testing.B) {
popr := math_rand.New(math_rand.NewSource(616))
total := 0
pops := make([]*Wilson, 1000)
for i := 0; i < 1000; i++ {
pops[i] = NewPopulatedWilson(popr, false)
}
b.ResetTimer()
for i := 0; i < b.N; i++ {
total += pops[i%1000].Size()
}
b.SetBytes(int64(total / b.N))
}
func TestCastawayStringer(t *testing.T) {
popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
p := NewPopulatedCastaway(popr, false)
s1 := p.String()
s2 := fmt.Sprintf("%v", p)
if s1 != s2 {
t.Fatalf("String want %v got %v", s1, s2)
}
}
func TestWilsonStringer(t *testing.T) {
popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
p := NewPopulatedWilson(popr, false)
s1 := p.String()
s2 := fmt.Sprintf("%v", p)
if s1 != s2 {
t.Fatalf("String want %v got %v", s1, s2)
}
}
//These tests are generated by github.com/gogo/protobuf/plugin/testgen

6
vendor/github.com/gogo/protobuf/test/castvalue/combos/both/mytypes.go generated vendored
View File

@@ -1,7 +1,7 @@
// Extensions for Protocol Buffers to create more go like structures.
// Protocol Buffers for Go with Gadgets
//
// Copyright (c) 2013, Vastech SA (PTY) LTD. All rights reserved.
// http://github.com/gogo/protobuf/gogoproto
// 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

669
vendor/github.com/gogo/protobuf/test/castvalue/combos/marshaler/castvalue.pb.go generated vendored
View File

@@ -31,8 +31,6 @@ import strconv "strconv"
import reflect "reflect"
import github_com_gogo_protobuf_sortkeys "github.com/gogo/protobuf/sortkeys"
import errors "errors"
// Reference imports to suppress errors if they are not otherwise used.
var _ = proto.Marshal
var _ = fmt.Errorf
@@ -40,11 +38,13 @@ 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.
const _ = proto.GoGoProtoPackageIsVersion1
// 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 Castaway struct {
CastMapValueMessage map[int32]MyWilson `protobuf:"bytes,1,rep,name=CastMapValueMessage,json=castMapValueMessage,castvalue=MyWilson,castvaluetype=castvalue.Wilson" json:"CastMapValueMessage" protobuf_key:"varint,1,opt,name=key" protobuf_val:"bytes,2,opt,name=value"`
CastMapValueMessageNullable map[int32]*MyWilson `protobuf:"bytes,2,rep,name=CastMapValueMessageNullable,json=castMapValueMessageNullable,castvalue=MyWilson,castvaluetype=castvalue.Wilson" json:"CastMapValueMessageNullable,omitempty" protobuf_key:"varint,1,opt,name=key" protobuf_val:"bytes,2,opt,name=value"`
CastMapValueMessage map[int32]MyWilson `protobuf:"bytes,1,rep,name=CastMapValueMessage,castvalue=MyWilson,castvaluetype=castvalue.Wilson" json:"CastMapValueMessage" protobuf_key:"varint,1,opt,name=key" protobuf_val:"bytes,2,opt,name=value"`
CastMapValueMessageNullable map[int32]*MyWilson `protobuf:"bytes,2,rep,name=CastMapValueMessageNullable,castvalue=MyWilson,castvaluetype=castvalue.Wilson" json:"CastMapValueMessageNullable,omitempty" protobuf_key:"varint,1,opt,name=key" protobuf_val:"bytes,2,opt,name=value"`
XXX_unrecognized []byte `json:"-"`
}
@@ -53,7 +53,7 @@ func (*Castaway) ProtoMessage() {}
func (*Castaway) Descriptor() ([]byte, []int) { return fileDescriptorCastvalue, []int{0} }
type Wilson struct {
Int64 *int64 `protobuf:"varint,1,opt,name=Int64,json=int64" json:"Int64,omitempty"`
Int64 *int64 `protobuf:"varint,1,opt,name=Int64" json:"Int64,omitempty"`
XXX_unrecognized []byte `json:"-"`
}
@@ -74,224 +74,233 @@ func (this *Wilson) Description() (desc *github_com_gogo_protobuf_protoc_gen_gog
func CastvalueDescription() (desc *github_com_gogo_protobuf_protoc_gen_gogo_descriptor.FileDescriptorSet) {
d := &github_com_gogo_protobuf_protoc_gen_gogo_descriptor.FileDescriptorSet{}
var gzipped = []byte{
// 3470 bytes of a gzipped FileDescriptorSet
0x1f, 0x8b, 0x08, 0x00, 0x00, 0x09, 0x6e, 0x88, 0x02, 0xff, 0xcc, 0x5a, 0x6b, 0x6c, 0x23, 0x57,
0xf5, 0x5f, 0xc7, 0x76, 0x62, 0x1f, 0x3b, 0x8e, 0x33, 0x49, 0x77, 0xbd, 0xd9, 0x76, 0xb3, 0xeb,
0x3e, 0x76, 0xbb, 0x6d, 0x93, 0xfe, 0xf7, 0xdf, 0xc7, 0xd6, 0xfd, 0xff, 0x5b, 0xe5, 0xe1, 0x4d,
0xbd, 0xca, 0x8b, 0x49, 0xd2, 0xee, 0x96, 0x0f, 0xa3, 0xc9, 0xf8, 0xc6, 0xf1, 0xee, 0x78, 0xc6,
0x78, 0xc6, 0xbb, 0x9b, 0x7e, 0x2a, 0x6a, 0x01, 0x15, 0x44, 0x79, 0x4a, 0xf4, 0x0d, 0xad, 0x04,
0x2d, 0xe5, 0xd5, 0xf2, 0x12, 0xe2, 0x53, 0x11, 0x2a, 0xf4, 0x13, 0x2a, 0x7c, 0xe2, 0x03, 0x02,
0x5a, 0x2a, 0x51, 0xa0, 0x40, 0x91, 0x56, 0xa2, 0x52, 0xbf, 0x70, 0xee, 0x6b, 0x3c, 0x63, 0x3b,
0x19, 0xa7, 0xa8, 0x94, 0x48, 0xa3, 0xcc, 0x9c, 0x7b, 0x7e, 0xbf, 0xb9, 0xf7, 0xdc, 0x73, 0xcf,
0x39, 0xf7, 0x8e, 0xe1, 0xa7, 0xff, 0x03, 0x87, 0x2a, 0xb6, 0x5d, 0x31, 0xc9, 0x64, 0xbd, 0x61,
0xbb, 0xf6, 0x7a, 0x73, 0x63, 0xb2, 0x4c, 0x1c, 0xa3, 0x51, 0xad, 0xbb, 0x76, 0x63, 0x82, 0xc9,
0x94, 0x21, 0xae, 0x31, 0x21, 0x35, 0xf2, 0x0b, 0x30, 0x7c, 0xb2, 0x6a, 0x92, 0x59, 0x4f, 0x71,
0x85, 0xb8, 0xca, 0x09, 0x88, 0x6d, 0xa0, 0x30, 0x17, 0x39, 0x14, 0x3d, 0x9a, 0x3a, 0x7e, 0xd5,
0x44, 0x1b, 0x68, 0x22, 0x88, 0x58, 0xa6, 0x62, 0x95, 0x21, 0xf2, 0x6f, 0xc4, 0x60, 0xa4, 0x4b,
0xab, 0xa2, 0x40, 0xcc, 0xd2, 0x6b, 0x94, 0x31, 0x72, 0x34, 0xa9, 0xb2, 0x7b, 0x25, 0x07, 0x03,
0x75, 0xdd, 0x38, 0xa7, 0x57, 0x48, 0xae, 0x8f, 0x89, 0xe5, 0xa3, 0x72, 0x10, 0xa0, 0x4c, 0xea,
0xc4, 0x2a, 0x13, 0xcb, 0xd8, 0xca, 0x45, 0xb1, 0x17, 0x49, 0xd5, 0x27, 0x51, 0xae, 0x83, 0xe1,
0x7a, 0x73, 0xdd, 0xac, 0x1a, 0x9a, 0x4f, 0x0d, 0x50, 0x2d, 0xae, 0x66, 0x79, 0xc3, 0x6c, 0x4b,
0xf9, 0x08, 0x0c, 0x5d, 0x20, 0xfa, 0x39, 0xbf, 0x6a, 0x8a, 0xa9, 0x66, 0xa8, 0xd8, 0xa7, 0x38,
0x03, 0xe9, 0x1a, 0x71, 0x1c, 0xec, 0x80, 0xe6, 0x6e, 0xd5, 0x49, 0x2e, 0xc6, 0x46, 0x7f, 0xa8,
0x63, 0xf4, 0xed, 0x23, 0x4f, 0x09, 0xd4, 0x2a, 0x82, 0x94, 0x29, 0x48, 0x12, 0xab, 0x59, 0xe3,
0x0c, 0xf1, 0x6d, 0xec, 0x57, 0x44, 0x8d, 0x76, 0x96, 0x04, 0x85, 0x09, 0x8a, 0x01, 0x87, 0x34,
0xce, 0x57, 0x0d, 0x92, 0xeb, 0x67, 0x04, 0x47, 0x3a, 0x08, 0x56, 0x78, 0x7b, 0x3b, 0x87, 0xc4,
0xe1, 0x50, 0x92, 0xe4, 0xa2, 0x4b, 0x2c, 0xa7, 0x6a, 0x5b, 0xb9, 0x01, 0x46, 0x72, 0x75, 0x97,
0x59, 0x24, 0x66, 0xb9, 0x9d, 0xa2, 0x85, 0x53, 0x6e, 0x81, 0x01, 0xbb, 0xee, 0xe2, 0x9d, 0x93,
0x4b, 0xe0, 0xfc, 0xa4, 0x8e, 0x5f, 0xde, 0xd5, 0x11, 0x96, 0xb8, 0x8e, 0x2a, 0x95, 0x95, 0x12,
0x64, 0x1d, 0xbb, 0xd9, 0x30, 0x88, 0x66, 0xd8, 0x65, 0xa2, 0x55, 0xad, 0x0d, 0x3b, 0x97, 0x64,
0x04, 0xe3, 0x9d, 0x03, 0x61, 0x8a, 0x33, 0xa8, 0x57, 0x42, 0x35, 0x35, 0xe3, 0x04, 0x9e, 0x95,
0xbd, 0xd0, 0xef, 0x6c, 0x59, 0xae, 0x7e, 0x31, 0x97, 0x66, 0x1e, 0x22, 0x9e, 0xf2, 0xff, 0x8c,
0xc3, 0x50, 0x2f, 0x2e, 0x76, 0x3b, 0xc4, 0x37, 0xe8, 0x28, 0xd1, 0xc1, 0x76, 0x61, 0x03, 0x8e,
0x09, 0x1a, 0xb1, 0xff, 0x3d, 0x1a, 0x71, 0x0a, 0x52, 0x16, 0x71, 0x5c, 0x52, 0xe6, 0x1e, 0x11,
0xed, 0xd1, 0xa7, 0x80, 0x83, 0x3a, 0x5d, 0x2a, 0xf6, 0x9e, 0x5c, 0xea, 0x34, 0x0c, 0x79, 0x5d,
0xd2, 0x1a, 0xba, 0x55, 0x91, 0xbe, 0x39, 0x19, 0xd6, 0x93, 0x89, 0xa2, 0xc4, 0xa9, 0x14, 0xa6,
0x66, 0x48, 0xe0, 0x59, 0x99, 0x05, 0xb0, 0x2d, 0x62, 0x6f, 0xe0, 0xf2, 0x32, 0x4c, 0xf4, 0x93,
0xee, 0x56, 0x5a, 0xa2, 0x2a, 0x1d, 0x56, 0xb2, 0xb9, 0xd4, 0x30, 0x95, 0xdb, 0x5a, 0xae, 0x36,
0xb0, 0x8d, 0xa7, 0x2c, 0xf0, 0x45, 0xd6, 0xe1, 0x6d, 0x6b, 0x90, 0x69, 0x10, 0xea, 0xf7, 0x68,
0x62, 0x3e, 0xb2, 0x24, 0xeb, 0xc4, 0x44, 0xe8, 0xc8, 0x54, 0x01, 0xe3, 0x03, 0x1b, 0x6c, 0xf8,
0x1f, 0x95, 0x2b, 0xc1, 0x13, 0x68, 0xcc, 0xad, 0x80, 0x45, 0xa1, 0xb4, 0x14, 0x2e, 0xa2, 0x6c,
0xec, 0x04, 0x64, 0x82, 0xe6, 0x51, 0x46, 0x21, 0xee, 0xb8, 0x7a, 0xc3, 0x65, 0x5e, 0x18, 0x57,
0xf9, 0x83, 0x92, 0x85, 0x28, 0x06, 0x19, 0x16, 0xe5, 0xe2, 0x2a, 0xbd, 0x1d, 0xbb, 0x15, 0x06,
0x03, 0xaf, 0xef, 0x15, 0x98, 0x7f, 0xa4, 0x1f, 0x46, 0xbb, 0xf9, 0x5c, 0x57, 0xf7, 0xc7, 0xe5,
0x83, 0x1e, 0xb0, 0x4e, 0x1a, 0xe8, 0x77, 0x94, 0x41, 0x3c, 0xa1, 0x47, 0xc5, 0x4d, 0x7d, 0x9d,
0x98, 0xe8, 0x4d, 0x91, 0xa3, 0x99, 0xe3, 0xd7, 0xf5, 0xe4, 0xd5, 0x13, 0xf3, 0x14, 0xa2, 0x72,
0xa4, 0x72, 0x07, 0xc4, 0x44, 0x88, 0xa3, 0x0c, 0xc7, 0x7a, 0x63, 0xa0, 0xbe, 0xa8, 0x32, 0x9c,
0x72, 0x00, 0x92, 0xf4, 0x3f, 0xb7, 0x6d, 0x3f, 0xeb, 0x73, 0x82, 0x0a, 0xa8, 0x5d, 0x95, 0x31,
0x48, 0x30, 0x37, 0x2b, 0x13, 0x99, 0x1a, 0xbc, 0x67, 0x3a, 0x31, 0x65, 0xb2, 0xa1, 0x37, 0x4d,
0x57, 0x3b, 0xaf, 0x9b, 0x4d, 0xc2, 0x1c, 0x06, 0x27, 0x46, 0x08, 0xef, 0xa6, 0x32, 0x65, 0x1c,
0x52, 0xdc, 0x2b, 0xab, 0x88, 0xb9, 0xc8, 0xa2, 0x4f, 0x5c, 0xe5, 0x8e, 0x5a, 0xa2, 0x12, 0xfa,
0xfa, 0xb3, 0x0e, 0xae, 0x05, 0x31, 0xb5, 0xec, 0x15, 0x54, 0xc0, 0x5e, 0x7f, 0x6b, 0x7b, 0xe0,
0xbb, 0xa2, 0xfb, 0xf0, 0xda, 0x7d, 0x31, 0xff, 0xc3, 0x3e, 0x88, 0xb1, 0xf5, 0x36, 0x04, 0xa9,
0xd5, 0x33, 0xcb, 0x45, 0x6d, 0x76, 0x69, 0x6d, 0x7a, 0xbe, 0x98, 0x8d, 0x28, 0x19, 0x00, 0x26,
0x38, 0x39, 0xbf, 0x34, 0xb5, 0x9a, 0xed, 0xf3, 0x9e, 0x4b, 0x8b, 0xab, 0xb7, 0xdc, 0x94, 0x8d,
0x7a, 0x80, 0x35, 0x2e, 0x88, 0xf9, 0x15, 0xfe, 0xf7, 0x78, 0x36, 0x8e, 0x9e, 0x90, 0xe6, 0x04,
0xa5, 0xd3, 0xc5, 0x59, 0xd4, 0xe8, 0x0f, 0x4a, 0x50, 0x67, 0x40, 0x19, 0x84, 0x24, 0x93, 0x4c,
0x2f, 0x2d, 0xcd, 0x67, 0x13, 0x1e, 0xe7, 0xca, 0xaa, 0x5a, 0x5a, 0x9c, 0xcb, 0x26, 0x3d, 0xce,
0x39, 0x75, 0x69, 0x6d, 0x39, 0x0b, 0x1e, 0xc3, 0x42, 0x71, 0x65, 0x65, 0x6a, 0xae, 0x98, 0x4d,
0x79, 0x1a, 0xd3, 0x67, 0x56, 0x8b, 0x2b, 0xd9, 0x74, 0xa0, 0x5b, 0xf8, 0x8a, 0x41, 0xef, 0x15,
0xc5, 0xc5, 0xb5, 0x85, 0x6c, 0x46, 0x19, 0x86, 0x41, 0xfe, 0x0a, 0xd9, 0x89, 0xa1, 0x36, 0x11,
0xf6, 0x34, 0xdb, 0xea, 0x08, 0x67, 0x19, 0x0e, 0x08, 0x50, 0x43, 0xc9, 0xcf, 0x40, 0x9c, 0x79,
0x17, 0x7a, 0x71, 0x66, 0x7e, 0x6a, 0xba, 0x38, 0xaf, 0x2d, 0x2d, 0xaf, 0x96, 0x96, 0x16, 0xa7,
0xe6, 0xd1, 0x76, 0x9e, 0x4c, 0x2d, 0x7e, 0x68, 0xad, 0xa4, 0x16, 0x67, 0xd1, 0x7e, 0x3e, 0xd9,
0x72, 0x71, 0x6a, 0x15, 0x65, 0xd1, 0xfc, 0x31, 0x18, 0xed, 0x16, 0x67, 0xba, 0xad, 0x8c, 0xfc,
0x33, 0x11, 0x18, 0xe9, 0x12, 0x32, 0xbb, 0xae, 0xa2, 0x3b, 0x21, 0xce, 0x3d, 0x8d, 0x27, 0x91,
0x6b, 0xbb, 0xc6, 0x5e, 0xe6, 0x77, 0x1d, 0x89, 0x84, 0xe1, 0xfc, 0x89, 0x34, 0xba, 0x4d, 0x22,
0xa5, 0x14, 0x1d, 0xee, 0xf4, 0x40, 0x04, 0x72, 0xdb, 0x71, 0x87, 0xac, 0xf7, 0xbe, 0xc0, 0x7a,
0xbf, 0xbd, 0xbd, 0x03, 0x87, 0xb7, 0x1f, 0x43, 0x47, 0x2f, 0x9e, 0x8d, 0xc0, 0xde, 0xee, 0xf5,
0x46, 0xd7, 0x3e, 0xdc, 0x01, 0xfd, 0x35, 0xe2, 0x6e, 0xda, 0x32, 0xe7, 0x5e, 0xd3, 0x25, 0x92,
0xd3, 0xe6, 0x76, 0x5b, 0x09, 0x94, 0x3f, 0x15, 0x44, 0xb7, 0x2b, 0x1a, 0x78, 0x6f, 0x3a, 0x7a,
0xfa, 0x50, 0x1f, 0x5c, 0xd6, 0x95, 0xbc, 0x6b, 0x47, 0xaf, 0x00, 0xa8, 0x5a, 0xf5, 0xa6, 0xcb,
0xf3, 0x2a, 0x0f, 0x33, 0x49, 0x26, 0x61, 0x4b, 0x98, 0x86, 0x90, 0xa6, 0xeb, 0xb5, 0x47, 0x59,
0x3b, 0x70, 0x11, 0x53, 0x38, 0xd1, 0xea, 0x68, 0x8c, 0x75, 0xf4, 0xe0, 0x36, 0x23, 0xed, 0x48,
0x59, 0x37, 0x42, 0xd6, 0x30, 0xab, 0xc4, 0x72, 0x35, 0xc7, 0x6d, 0x10, 0xbd, 0x56, 0xb5, 0x2a,
0x2c, 0x8e, 0x26, 0x0a, 0xf1, 0x0d, 0xdd, 0x74, 0x88, 0x3a, 0xc4, 0x9b, 0x57, 0x64, 0x2b, 0x45,
0xb0, 0x64, 0xd1, 0xf0, 0x21, 0xfa, 0x03, 0x08, 0xde, 0xec, 0x21, 0xf2, 0xbf, 0x1a, 0x80, 0x94,
0xaf, 0x3a, 0x53, 0x0e, 0x43, 0xfa, 0xac, 0x7e, 0x5e, 0xd7, 0x64, 0xc5, 0xcd, 0x2d, 0x91, 0xa2,
0xb2, 0x65, 0x51, 0x75, 0xdf, 0x08, 0xa3, 0x4c, 0x05, 0xc7, 0x88, 0x2f, 0x32, 0x4c, 0xdd, 0x71,
0x98, 0xd1, 0x12, 0x4c, 0x55, 0xa1, 0x6d, 0x4b, 0xb4, 0x69, 0x46, 0xb6, 0x28, 0x37, 0xc3, 0x08,
0x43, 0xd4, 0x30, 0xf0, 0x56, 0xeb, 0x26, 0xd1, 0xe8, 0x1e, 0xc0, 0x61, 0xf1, 0xd4, 0xeb, 0xd9,
0x30, 0xd5, 0x58, 0x10, 0x0a, 0xb4, 0x47, 0x8e, 0x32, 0x07, 0x57, 0x30, 0x58, 0x85, 0x58, 0xa4,
0xa1, 0xbb, 0x44, 0x23, 0x1f, 0x69, 0xa2, 0xae, 0xa6, 0x5b, 0x65, 0x6d, 0x53, 0x77, 0x36, 0x73,
0xa3, 0x7e, 0x82, 0xfd, 0x54, 0x77, 0x4e, 0xa8, 0x16, 0x99, 0xe6, 0x94, 0x55, 0xbe, 0x0b, 0xf5,
0x94, 0x02, 0xec, 0x65, 0x44, 0x68, 0x14, 0x1c, 0xb3, 0x66, 0x6c, 0x12, 0xe3, 0x9c, 0xd6, 0x74,
0x37, 0x4e, 0xe4, 0x0e, 0xf8, 0x19, 0x58, 0x27, 0x57, 0x98, 0xce, 0x0c, 0x55, 0x59, 0x43, 0x0d,
0x65, 0x05, 0xd2, 0x74, 0x3e, 0x6a, 0xd5, 0xfb, 0xb0, 0xdb, 0x76, 0x83, 0xe5, 0x88, 0x4c, 0x97,
0xc5, 0xed, 0x33, 0xe2, 0xc4, 0x92, 0x00, 0x2c, 0x60, 0x7d, 0x5a, 0x88, 0xaf, 0x2c, 0x17, 0x8b,
0xb3, 0x6a, 0x4a, 0xb2, 0x9c, 0xb4, 0x1b, 0xd4, 0xa7, 0x2a, 0xb6, 0x67, 0xe3, 0x14, 0xf7, 0xa9,
0x8a, 0x2d, 0x2d, 0x8c, 0xf6, 0x32, 0x0c, 0x3e, 0x6c, 0xdc, 0xbb, 0x88, 0x62, 0xdd, 0xc9, 0x65,
0x03, 0xf6, 0x32, 0x8c, 0x39, 0xae, 0x20, 0xdc, 0xdc, 0xc1, 0x25, 0x71, 0x59, 0xcb, 0x5e, 0x7e,
0xe0, 0x70, 0xc7, 0x28, 0xdb, 0xa1, 0xf8, 0xc6, 0xfa, 0x56, 0x27, 0x50, 0x09, 0xbc, 0xb1, 0xbe,
0xd5, 0x0e, 0xbb, 0x9a, 0x6d, 0xc0, 0x1a, 0xc4, 0x40, 0x93, 0x97, 0x73, 0xfb, 0xfc, 0xda, 0xbe,
0x06, 0x65, 0x12, 0x1d, 0xd9, 0xd0, 0x88, 0xa5, 0xaf, 0xe3, 0xdc, 0xeb, 0x0d, 0xbc, 0x71, 0x72,
0xe3, 0x7e, 0xe5, 0x8c, 0x61, 0x14, 0x59, 0xeb, 0x14, 0x6b, 0x54, 0x8e, 0xc1, 0xb0, 0xbd, 0x7e,
0xd6, 0xe0, 0xce, 0xa5, 0x21, 0xcf, 0x46, 0xf5, 0x62, 0xee, 0x2a, 0x66, 0xa6, 0x21, 0xda, 0xc0,
0x5c, 0x6b, 0x99, 0x89, 0x95, 0x6b, 0x91, 0xdc, 0xd9, 0xd4, 0x1b, 0x75, 0x96, 0xa4, 0x1d, 0x34,
0x2a, 0xc9, 0x5d, 0xcd, 0x55, 0xb9, 0x7c, 0x51, 0x8a, 0x95, 0x22, 0x8c, 0xd3, 0xc1, 0x5b, 0xba,
0x65, 0x6b, 0x4d, 0x87, 0x68, 0xad, 0x2e, 0x7a, 0x73, 0x71, 0x0d, 0xed, 0x96, 0x7a, 0xb9, 0x54,
0x5b, 0x73, 0x30, 0x98, 0x49, 0x25, 0x39, 0x3d, 0xa7, 0x61, 0xb4, 0x69, 0x55, 0x2d, 0x74, 0x71,
0x6c, 0xa1, 0x60, 0xbe, 0x60, 0x73, 0x7f, 0x1c, 0xd8, 0xa6, 0xe8, 0x5e, 0xf3, 0x6b, 0x73, 0x27,
0x51, 0x47, 0x9a, 0x9d, 0xc2, 0x7c, 0x01, 0xd2, 0x7e, 0xdf, 0x51, 0x92, 0xc0, 0xbd, 0x07, 0xb3,
0x1b, 0x66, 0xd4, 0x99, 0xa5, 0x59, 0x9a, 0x0b, 0xef, 0x2d, 0x62, 0x62, 0xc3, 0x9c, 0x3c, 0x5f,
0x5a, 0x2d, 0x6a, 0xea, 0xda, 0xe2, 0x6a, 0x69, 0xa1, 0x98, 0x8d, 0x1e, 0x4b, 0x26, 0xde, 0x1c,
0xc8, 0xde, 0x8f, 0x7f, 0x7d, 0xf9, 0x97, 0xfb, 0x20, 0x13, 0xac, 0x83, 0x95, 0xff, 0x83, 0x7d,
0x72, 0xd3, 0xea, 0x10, 0x57, 0xbb, 0x50, 0x6d, 0x30, 0x77, 0xae, 0xe9, 0xbc, 0x92, 0xf4, 0x66,
0x62, 0x54, 0x68, 0xe1, 0xf6, 0xfe, 0x1e, 0xd4, 0x39, 0xc9, 0x54, 0x94, 0x79, 0x18, 0x47, 0x93,
0x61, 0xad, 0x69, 0x95, 0xf5, 0x46, 0x59, 0x6b, 0x1d, 0x17, 0x68, 0xba, 0x81, 0x7e, 0xe0, 0xd8,
0x3c, 0x93, 0x78, 0x2c, 0x97, 0x5b, 0xf6, 0x8a, 0x50, 0x6e, 0x85, 0xd8, 0x29, 0xa1, 0xda, 0xe6,
0x35, 0xd1, 0xed, 0xbc, 0x06, 0x6b, 0xaf, 0x9a, 0x5e, 0x47, 0xb7, 0x71, 0x1b, 0x5b, 0xac, 0x7a,
0x4b, 0xa8, 0x09, 0x14, 0x14, 0xe9, 0xf3, 0xfb, 0x37, 0x07, 0x7e, 0x3b, 0xfe, 0x26, 0x0a, 0x69,
0x7f, 0x05, 0x47, 0x0b, 0x62, 0x83, 0x85, 0xf9, 0x08, 0x8b, 0x02, 0x57, 0xee, 0x58, 0xef, 0x4d,
0xcc, 0xd0, 0xf8, 0x5f, 0xe8, 0xe7, 0x75, 0x95, 0xca, 0x91, 0x34, 0xf7, 0x52, 0x5f, 0x23, 0xbc,
0x5a, 0x4f, 0xa8, 0xe2, 0x09, 0x83, 0x5d, 0xff, 0x59, 0x87, 0x71, 0xf7, 0x33, 0xee, 0xab, 0x76,
0xe6, 0x3e, 0xb5, 0xc2, 0xc8, 0x93, 0xa7, 0x56, 0xb4, 0xc5, 0x25, 0x75, 0x61, 0x6a, 0x5e, 0x15,
0x70, 0x65, 0x3f, 0xc4, 0x4c, 0xfd, 0xbe, 0xad, 0x60, 0xa6, 0x60, 0xa2, 0x5e, 0x0d, 0x8f, 0x0c,
0xf4, 0xc8, 0x23, 0x18, 0x9f, 0x99, 0xe8, 0x7d, 0x74, 0xfd, 0x49, 0x88, 0x33, 0x7b, 0x29, 0x00,
0xc2, 0x62, 0xd9, 0x3d, 0x4a, 0x02, 0x62, 0x33, 0x4b, 0x2a, 0x75, 0x7f, 0xf4, 0x77, 0x2e, 0xd5,
0x96, 0x4b, 0xc5, 0x19, 0x5c, 0x01, 0xf9, 0x9b, 0xa1, 0x9f, 0x1b, 0x81, 0x2e, 0x0d, 0xcf, 0x0c,
0x08, 0xe2, 0x8f, 0x82, 0x23, 0x22, 0x5b, 0xd7, 0x16, 0xa6, 0x8b, 0x6a, 0xb6, 0xcf, 0x3f, 0xbd,
0x3f, 0x8e, 0x40, 0xca, 0x57, 0x50, 0xd1, 0x54, 0xae, 0x9b, 0xa6, 0x7d, 0x41, 0xd3, 0xcd, 0x2a,
0x46, 0x28, 0x3e, 0x3f, 0xc0, 0x44, 0x53, 0x54, 0xd2, 0xab, 0xfd, 0xfe, 0x23, 0xbe, 0xf9, 0x54,
0x04, 0xb2, 0xed, 0xc5, 0x58, 0x5b, 0x07, 0x23, 0x1f, 0x68, 0x07, 0x9f, 0x88, 0x40, 0x26, 0x58,
0x81, 0xb5, 0x75, 0xef, 0xf0, 0x07, 0xda, 0xbd, 0xc7, 0x23, 0x30, 0x18, 0xa8, 0xbb, 0xfe, 0xab,
0x7a, 0xf7, 0x58, 0x14, 0x46, 0xba, 0xe0, 0x30, 0x00, 0xf1, 0x02, 0x95, 0xd7, 0xcc, 0x37, 0xf4,
0xf2, 0xae, 0x09, 0x9a, 0xff, 0x96, 0xf5, 0x86, 0x2b, 0xea, 0x59, 0xcc, 0x97, 0xd5, 0x32, 0x06,
0xd5, 0xea, 0x46, 0x15, 0xcb, 0x37, 0xbe, 0x63, 0xe1, 0x55, 0xeb, 0x50, 0x4b, 0xce, 0xb7, 0xc7,
0xd7, 0x83, 0x52, 0xb7, 0x9d, 0xaa, 0x5b, 0x3d, 0x4f, 0x8f, 0xe7, 0xe4, 0x46, 0x9a, 0x56, 0xb1,
0x31, 0x35, 0x2b, 0x5b, 0x4a, 0x96, 0xeb, 0x69, 0x5b, 0xa4, 0xa2, 0xb7, 0x69, 0xd3, 0x30, 0x14,
0x55, 0xb3, 0xb2, 0xc5, 0xd3, 0xc6, 0x42, 0xb3, 0x6c, 0x37, 0x69, 0x41, 0xc0, 0xf5, 0x68, 0xd4,
0x8b, 0xa8, 0x29, 0x2e, 0xf3, 0x54, 0x44, 0xc5, 0xd6, 0xda, 0xc1, 0xa7, 0xd5, 0x14, 0x97, 0x71,
0x95, 0x23, 0x30, 0xa4, 0x57, 0x2a, 0x0d, 0x4a, 0x2e, 0x89, 0x78, 0x19, 0x9a, 0xf1, 0xc4, 0x4c,
0x71, 0xec, 0x14, 0x24, 0xa4, 0x1d, 0x68, 0x62, 0xa1, 0x96, 0xc0, 0x9c, 0xcf, 0xce, 0x51, 0xfa,
0xe8, 0xa6, 0xde, 0x92, 0x8d, 0xf8, 0xd2, 0xaa, 0xa3, 0xb5, 0x0e, 0xf4, 0xfa, 0xb0, 0x3d, 0xa1,
0xa6, 0xaa, 0x8e, 0x77, 0x82, 0x93, 0x7f, 0x16, 0xd3, 0x6b, 0xf0, 0x40, 0x52, 0x99, 0x85, 0x84,
0x69, 0xa3, 0x7f, 0x50, 0x04, 0x3f, 0x0d, 0x3f, 0x1a, 0x72, 0x86, 0x39, 0x31, 0x2f, 0xf4, 0x55,
0x0f, 0x39, 0xf6, 0x8b, 0x08, 0x24, 0xa4, 0x18, 0x13, 0x45, 0xac, 0xae, 0xbb, 0x9b, 0x8c, 0x2e,
0x3e, 0xdd, 0x97, 0x8d, 0xa8, 0xec, 0x99, 0xca, 0xb1, 0x9a, 0xb1, 0x98, 0x0b, 0x08, 0x39, 0x7d,
0xa6, 0xf3, 0x6a, 0x12, 0xbd, 0xcc, 0x0a, 0x5c, 0xbb, 0x56, 0xc3, 0x99, 0x74, 0xe4, 0xbc, 0x0a,
0xf9, 0x8c, 0x10, 0xd3, 0x73, 0x71, 0xb7, 0xa1, 0x57, 0xcd, 0x80, 0x6e, 0x8c, 0xe9, 0x66, 0x65,
0x83, 0xa7, 0x5c, 0x80, 0xfd, 0x92, 0xb7, 0x4c, 0x5c, 0x1d, 0x8b, 0xe7, 0x72, 0x0b, 0xd4, 0xcf,
0x4e, 0xbb, 0xf6, 0x09, 0x85, 0x59, 0xd1, 0x2e, 0xb1, 0xd3, 0xa7, 0xb1, 0x90, 0xb5, 0x6b, 0xed,
0x96, 0x98, 0xce, 0xb6, 0xed, 0xbb, 0x9c, 0xbb, 0x22, 0xf7, 0x42, 0xab, 0xa8, 0x78, 0xa6, 0x2f,
0x3a, 0xb7, 0x3c, 0xfd, 0x7c, 0xdf, 0xd8, 0x1c, 0xc7, 0x2d, 0x4b, 0x0b, 0xaa, 0x64, 0xc3, 0x24,
0x06, 0xb5, 0x0e, 0x3c, 0x7d, 0x25, 0xdc, 0x50, 0xa9, 0xba, 0x9b, 0xcd, 0xf5, 0x09, 0x7c, 0xc3,
0x64, 0xc5, 0xae, 0xd8, 0xad, 0xcf, 0x19, 0xf4, 0x89, 0x3d, 0xb0, 0x3b, 0xf1, 0x49, 0x23, 0xe9,
0x49, 0xc7, 0x42, 0xbf, 0x7f, 0x14, 0x16, 0x61, 0x44, 0x28, 0x6b, 0xec, 0x4c, 0x95, 0x97, 0xa0,
0xca, 0x8e, 0x1b, 0xf2, 0xdc, 0x8b, 0x6f, 0xb0, 0x94, 0xa0, 0x0e, 0x0b, 0x28, 0x6d, 0xe3, 0x45,
0x6a, 0x41, 0x85, 0xcb, 0x02, 0x7c, 0xdc, 0x87, 0x71, 0xcb, 0xbd, 0x33, 0xe3, 0xcb, 0x82, 0x71,
0xc4, 0xc7, 0xb8, 0x22, 0xa0, 0x85, 0x19, 0x18, 0xdc, 0x0d, 0xd7, 0xcf, 0x04, 0x57, 0x9a, 0xf8,
0x49, 0xe6, 0x60, 0x88, 0x91, 0x18, 0x4d, 0xc7, 0xb5, 0x6b, 0x2c, 0x40, 0xec, 0x4c, 0xf3, 0xf3,
0x37, 0xb8, 0x53, 0x65, 0x28, 0x6c, 0xc6, 0x43, 0x15, 0xee, 0x86, 0x51, 0x2a, 0x61, 0x6b, 0xd0,
0xcf, 0x16, 0x7e, 0x84, 0x90, 0xfb, 0xe5, 0x03, 0xdc, 0xf7, 0x46, 0x3c, 0x02, 0x1f, 0xaf, 0x6f,
0x26, 0x2a, 0xc4, 0xc5, 0xd8, 0x86, 0xfb, 0x3f, 0xd3, 0x54, 0x76, 0xfc, 0xc6, 0x90, 0x7b, 0xf4,
0xad, 0xe0, 0x4c, 0xcc, 0x71, 0xe4, 0x94, 0x69, 0x16, 0xd6, 0x60, 0x5f, 0x97, 0x99, 0xed, 0x81,
0xf3, 0x31, 0xc1, 0x39, 0xda, 0x31, 0xbb, 0x94, 0x76, 0x19, 0xa4, 0xdc, 0x9b, 0x8f, 0x1e, 0x38,
0x1f, 0x17, 0x9c, 0x8a, 0xc0, 0xca, 0x69, 0xa1, 0x8c, 0xa7, 0x60, 0x18, 0x77, 0xea, 0xeb, 0xb6,
0x23, 0xf6, 0xbd, 0x3d, 0xd0, 0x3d, 0x21, 0xe8, 0x86, 0x04, 0x90, 0xed, 0x82, 0x29, 0xd7, 0x6d,
0x90, 0xd8, 0xc0, 0x0d, 0x50, 0x0f, 0x14, 0x4f, 0x0a, 0x8a, 0x01, 0xaa, 0x4f, 0xa1, 0x53, 0x90,
0xae, 0xd8, 0x22, 0x0c, 0x87, 0xc3, 0x9f, 0x12, 0xf0, 0x94, 0xc4, 0x08, 0x8a, 0xba, 0x5d, 0x6f,
0x9a, 0x34, 0x46, 0x87, 0x53, 0x7c, 0x59, 0x52, 0x48, 0x8c, 0xa0, 0xd8, 0x85, 0x59, 0xbf, 0x22,
0x29, 0x1c, 0x9f, 0x3d, 0xef, 0xa4, 0x67, 0xbd, 0xe6, 0x96, 0x6d, 0xf5, 0xd2, 0x89, 0xa7, 0x05,
0x03, 0x08, 0x08, 0x25, 0xb8, 0x1d, 0x92, 0xbd, 0x4e, 0xc4, 0x57, 0x05, 0x3c, 0x41, 0xe4, 0x0c,
0xe0, 0x3a, 0x93, 0x41, 0x86, 0x7e, 0x5b, 0x09, 0xa7, 0xf8, 0x9a, 0xa0, 0xc8, 0xf8, 0x60, 0x62,
0x18, 0x2e, 0x71, 0x5c, 0xdc, 0xaa, 0xf7, 0x40, 0xf2, 0xac, 0x1c, 0x86, 0x80, 0x08, 0x53, 0xae,
0x13, 0xcb, 0xd8, 0xec, 0x8d, 0xe1, 0x39, 0x69, 0x4a, 0x89, 0xa1, 0x14, 0x18, 0x79, 0x6a, 0x7a,
0x03, 0x37, 0xd7, 0x66, 0x4f, 0xd3, 0xf1, 0x75, 0xc1, 0x91, 0xf6, 0x40, 0xc2, 0x22, 0x4d, 0x6b,
0x37, 0x34, 0xcf, 0x4b, 0x8b, 0xf8, 0x60, 0x62, 0xe9, 0xe1, 0xce, 0x94, 0x56, 0x12, 0xbb, 0x61,
0xfb, 0x86, 0x5c, 0x7a, 0x1c, 0xbb, 0xe0, 0x67, 0xc4, 0x99, 0x76, 0x70, 0x0b, 0xde, 0x0b, 0xcd,
0x37, 0xe5, 0x4c, 0x33, 0x00, 0x05, 0x9f, 0x81, 0xfd, 0x5d, 0x43, 0x7d, 0x0f, 0x64, 0xdf, 0x12,
0x64, 0x7b, 0xbb, 0x84, 0x7b, 0x11, 0x12, 0x76, 0x4b, 0xf9, 0x6d, 0x19, 0x12, 0x48, 0x1b, 0xd7,
0x32, 0x2d, 0x63, 0x1d, 0x7d, 0x63, 0x77, 0x56, 0xfb, 0x8e, 0xb4, 0x1a, 0xc7, 0x06, 0xac, 0xb6,
0x0a, 0x7b, 0x05, 0xe3, 0xee, 0xe6, 0xf5, 0x05, 0x19, 0x58, 0x39, 0x7a, 0x2d, 0x38, 0xbb, 0x1f,
0x86, 0x31, 0xcf, 0x9c, 0xb2, 0x02, 0x73, 0x34, 0x7a, 0x30, 0x10, 0xce, 0xfc, 0xa2, 0x60, 0x96,
0x11, 0xdf, 0x2b, 0xe1, 0x9c, 0x05, 0xbd, 0x4e, 0xc9, 0x4f, 0x43, 0x4e, 0x92, 0x37, 0x2d, 0x2c,
0xf0, 0xed, 0x8a, 0x85, 0xd3, 0x58, 0xee, 0x81, 0xfa, 0xbb, 0x6d, 0x53, 0xb5, 0xe6, 0x83, 0x53,
0xe6, 0x12, 0x64, 0xbd, 0x7a, 0x43, 0xab, 0xd6, 0xea, 0x36, 0x96, 0x96, 0x3b, 0x33, 0x7e, 0x4f,
0xce, 0x94, 0x87, 0x2b, 0x31, 0x58, 0xa1, 0x08, 0x19, 0xf6, 0xd8, 0xab, 0x4b, 0x7e, 0x5f, 0x10,
0x0d, 0xb6, 0x50, 0x22, 0x70, 0x60, 0xa5, 0x84, 0x35, 0x6f, 0x2f, 0xf1, 0xef, 0x07, 0x32, 0x70,
0x08, 0x08, 0xf7, 0xbe, 0xa1, 0xb6, 0x4c, 0xac, 0x84, 0x7d, 0x7e, 0xcd, 0x7d, 0xf4, 0x92, 0x58,
0xb3, 0xc1, 0x44, 0x5c, 0x98, 0xa7, 0xe6, 0x09, 0xa6, 0xcb, 0x70, 0xb2, 0x07, 0x2e, 0x79, 0x16,
0x0a, 0x64, 0xcb, 0xc2, 0x49, 0x18, 0x0c, 0xa4, 0xca, 0x70, 0xaa, 0x07, 0x05, 0x55, 0xda, 0x9f,
0x29, 0x0b, 0x37, 0x43, 0x8c, 0xa6, 0xbd, 0x70, 0xf8, 0xc7, 0x04, 0x9c, 0xa9, 0x17, 0xfe, 0x1f,
0x12, 0x32, 0xdd, 0x85, 0x43, 0x3f, 0x2e, 0xa0, 0x1e, 0x84, 0xc2, 0x65, 0xaa, 0x0b, 0x87, 0x7f,
0x42, 0xc2, 0x25, 0x84, 0xc2, 0x7b, 0x37, 0xe1, 0x4b, 0x9f, 0x8a, 0x89, 0x70, 0x25, 0x6d, 0x47,
0xbf, 0xf9, 0xf0, 0x1c, 0x17, 0x8e, 0x7e, 0x48, 0xbc, 0x5c, 0x22, 0x0a, 0xb7, 0x42, 0xbc, 0x47,
0x83, 0x7f, 0x5a, 0x40, 0xb9, 0x3e, 0x66, 0x90, 0x94, 0x2f, 0xaf, 0x85, 0xc3, 0x1f, 0x16, 0x70,
0x3f, 0x8a, 0x76, 0x5d, 0xe4, 0xb5, 0x70, 0x82, 0xcf, 0xc8, 0xae, 0x0b, 0x04, 0x35, 0x9b, 0x4c,
0x69, 0xe1, 0xe8, 0xcf, 0x4a, 0xab, 0x4b, 0x08, 0xae, 0xa6, 0xa4, 0x17, 0xa6, 0xc2, 0xf1, 0x9f,
0x13, 0xf8, 0x16, 0x86, 0x5a, 0xc0, 0x17, 0x26, 0xc3, 0x29, 0x3e, 0x2f, 0x2d, 0xe0, 0x43, 0xd1,
0x65, 0xd4, 0x9e, 0xfa, 0xc2, 0x99, 0xbe, 0x20, 0x97, 0x51, 0x5b, 0xe6, 0xa3, 0xb3, 0xc9, 0xa2,
0x45, 0x38, 0xc5, 0x17, 0xe5, 0x6c, 0x32, 0x7d, 0xda, 0x8d, 0xf6, 0x5c, 0x12, 0xce, 0xf1, 0x25,
0xd9, 0x8d, 0xb6, 0x54, 0x82, 0x99, 0x49, 0xe9, 0xcc, 0x23, 0xe1, 0x7c, 0x8f, 0x08, 0xbe, 0xe1,
0x8e, 0x34, 0x52, 0xb8, 0x07, 0xf6, 0x76, 0xcf, 0x21, 0xe1, 0xac, 0x8f, 0x5e, 0x6a, 0xab, 0xfa,
0xfd, 0x29, 0x04, 0x53, 0xde, 0x68, 0xb7, 0xfc, 0x11, 0x4e, 0xfb, 0xd8, 0xa5, 0xe0, 0xc6, 0xce,
0x9f, 0x3e, 0xb0, 0x42, 0x83, 0x56, 0xe8, 0x0e, 0xe7, 0x7a, 0x42, 0x70, 0xf9, 0x40, 0x74, 0x69,
0x88, 0xc8, 0x1d, 0x8e, 0x7f, 0x52, 0x2e, 0x0d, 0x81, 0x40, 0x70, 0xc2, 0x6a, 0x9a, 0x26, 0x75,
0x0e, 0x65, 0xe7, 0x9f, 0x34, 0xe4, 0xfe, 0xf4, 0xae, 0x58, 0x18, 0x12, 0x80, 0x31, 0x34, 0x4e,
0x6a, 0xeb, 0x68, 0x83, 0x10, 0xe4, 0x9f, 0xdf, 0x95, 0x01, 0x81, 0x6a, 0xe3, 0x7a, 0x02, 0xbe,
0x69, 0x64, 0x67, 0xd8, 0x21, 0xd8, 0xbf, 0xbc, 0x2b, 0x3e, 0xb3, 0xb6, 0x20, 0x2d, 0x02, 0xfe,
0xd1, 0x76, 0x67, 0x82, 0xb7, 0x82, 0x04, 0x6c, 0xa3, 0x79, 0x1b, 0x0c, 0xd0, 0x5f, 0x76, 0xb8,
0x7a, 0x25, 0x0c, 0xfd, 0x57, 0x81, 0x96, 0xfa, 0xd4, 0x60, 0x35, 0xbb, 0x41, 0xf0, 0xd6, 0x09,
0xc3, 0xfe, 0x4d, 0x60, 0x3d, 0x00, 0x05, 0x1b, 0xba, 0xe3, 0xf6, 0x32, 0xee, 0xbf, 0x4b, 0xb0,
0x04, 0xd0, 0x4e, 0xd3, 0xfb, 0x73, 0x64, 0x2b, 0x0c, 0xfb, 0xb6, 0xec, 0xb4, 0xd0, 0xc7, 0x00,
0x98, 0xa4, 0xb7, 0xfc, 0xa7, 0x07, 0x21, 0xe0, 0x7f, 0x08, 0x70, 0x0b, 0x31, 0x7d, 0xb8, 0xfb,
0xd1, 0x0e, 0xcc, 0xd9, 0x73, 0x36, 0x3f, 0xd4, 0x81, 0x87, 0xe3, 0x70, 0x08, 0x75, 0x30, 0xbf,
0x4e, 0x7a, 0x6b, 0x71, 0xd2, 0x63, 0x90, 0xc7, 0x32, 0x9e, 0x60, 0x6c, 0x77, 0x07, 0x3a, 0xf9,
0x9f, 0x44, 0x21, 0x31, 0x83, 0x60, 0xfd, 0x82, 0xbe, 0xa5, 0xd4, 0x61, 0x84, 0xde, 0xe3, 0xa2,
0x64, 0x47, 0x0b, 0xc2, 0xc5, 0xc5, 0x59, 0xdc, 0xf5, 0x13, 0xad, 0xb7, 0x4a, 0xc4, 0x44, 0x17,
0x75, 0xf6, 0x69, 0x69, 0x3a, 0xfb, 0xca, 0x6f, 0xc7, 0xf7, 0x7c, 0xf2, 0x77, 0xe3, 0x89, 0x85,
0xad, 0x7b, 0xaa, 0xa6, 0x43, 0x4f, 0x6b, 0x8d, 0x4e, 0x5d, 0xe5, 0xc1, 0x08, 0x1c, 0xe8, 0xc2,
0xb1, 0x28, 0x16, 0x82, 0x38, 0xa2, 0xbd, 0xa9, 0xc7, 0x57, 0x4b, 0x18, 0xef, 0x42, 0x3a, 0xf0,
0xfa, 0x03, 0xc6, 0xf6, 0xfa, 0x63, 0x67, 0x20, 0xb7, 0xdd, 0x48, 0xe8, 0xcf, 0xc2, 0x70, 0xa6,
0xc5, 0x4f, 0xc5, 0xe8, 0xad, 0x72, 0xa4, 0xf5, 0x1b, 0x15, 0xfa, 0x53, 0x84, 0x61, 0x5f, 0xef,
0xc4, 0xcb, 0x78, 0x7b, 0xa1, 0xef, 0x44, 0x64, 0x4c, 0x87, 0x43, 0x61, 0x3d, 0xfd, 0x37, 0x5f,
0x91, 0x3f, 0x08, 0xfd, 0x5c, 0x48, 0x7f, 0xd8, 0x56, 0xb2, 0xdc, 0x5b, 0x6e, 0x62, 0x54, 0x51,
0x35, 0x5e, 0xa5, 0x0f, 0xd3, 0xf3, 0xaf, 0xbc, 0x76, 0x70, 0xcf, 0xab, 0x78, 0xfd, 0x1a, 0xaf,
0xdf, 0xbf, 0x76, 0x30, 0xf2, 0x26, 0x5e, 0x6f, 0xe3, 0xf5, 0x0e, 0x5e, 0xf7, 0xbf, 0x7e, 0x30,
0xf2, 0x1c, 0x5e, 0x2f, 0xe0, 0xf5, 0x23, 0xbc, 0x5e, 0xc2, 0xeb, 0x15, 0xbc, 0x5e, 0x7d, 0x1d,
0x75, 0xf1, 0xff, 0x9b, 0xf8, 0xff, 0x6d, 0xfc, 0xff, 0x0e, 0xfe, 0xbf, 0xff, 0x0f, 0x07, 0xf7,
0xfc, 0x2b, 0x00, 0x00, 0xff, 0xff, 0xda, 0x83, 0xc0, 0xc0, 0xfb, 0x2c, 0x00, 0x00,
// 3604 bytes of a gzipped FileDescriptorSet
0x1f, 0x8b, 0x08, 0x00, 0x00, 0x09, 0x6e, 0x88, 0x02, 0xff, 0xcc, 0x5a, 0x5d, 0x6c, 0x1c, 0xd7,
0x75, 0xe6, 0xec, 0x0f, 0xb9, 0x7b, 0x76, 0xb9, 0x1c, 0x5e, 0xd2, 0xd4, 0x8a, 0x8a, 0x57, 0x14,
0x23, 0x57, 0xb4, 0x9d, 0x90, 0x81, 0x2c, 0xc9, 0xd2, 0xaa, 0x89, 0xb0, 0x5c, 0xae, 0x18, 0x0a,
0xfc, 0xeb, 0x90, 0x8c, 0xa5, 0xe4, 0x61, 0x70, 0x39, 0x7b, 0x77, 0x39, 0xd2, 0xec, 0xcc, 0x76,
0x66, 0x56, 0x12, 0xf5, 0xa4, 0xc0, 0x69, 0x8b, 0x34, 0x68, 0xfa, 0x0b, 0x34, 0x71, 0x9c, 0x9f,
0x06, 0x68, 0x9d, 0xa6, 0x7f, 0x49, 0xff, 0x50, 0xf4, 0x29, 0x7d, 0x48, 0xeb, 0xa7, 0x22, 0x79,
0xeb, 0x43, 0xd1, 0x5a, 0xac, 0x81, 0xba, 0xad, 0xdb, 0xba, 0xad, 0x80, 0x1a, 0xd0, 0x4b, 0x71,
0xff, 0x66, 0x67, 0x7f, 0xc8, 0x59, 0xba, 0xb0, 0x9d, 0x27, 0xee, 0x3d, 0xf7, 0x7c, 0xdf, 0x9c,
0x7b, 0xee, 0xb9, 0xe7, 0x9c, 0xb9, 0x43, 0xf8, 0xfc, 0x05, 0x98, 0xa9, 0x3b, 0x4e, 0xdd, 0x22,
0x0b, 0x4d, 0xd7, 0xf1, 0x9d, 0xdd, 0x56, 0x6d, 0xa1, 0x4a, 0x3c, 0xc3, 0x35, 0x9b, 0xbe, 0xe3,
0xce, 0x33, 0x19, 0x1a, 0xe3, 0x1a, 0xf3, 0x52, 0x63, 0x76, 0x0d, 0xc6, 0xaf, 0x9b, 0x16, 0x59,
0x0a, 0x14, 0xb7, 0x88, 0x8f, 0x2e, 0x43, 0xa2, 0x66, 0x5a, 0x24, 0xaf, 0xcc, 0xc4, 0xe7, 0x32,
0xe7, 0xcf, 0xce, 0x77, 0x81, 0xe6, 0x3b, 0x11, 0x9b, 0x54, 0xac, 0x31, 0xc4, 0xec, 0x9b, 0x09,
0x98, 0xe8, 0x33, 0x8b, 0x10, 0x24, 0x6c, 0xdc, 0xa0, 0x8c, 0xca, 0x5c, 0x5a, 0x63, 0xbf, 0x51,
0x1e, 0x46, 0x9a, 0xd8, 0xb8, 0x83, 0xeb, 0x24, 0x1f, 0x63, 0x62, 0x39, 0x44, 0x05, 0x80, 0x2a,
0x69, 0x12, 0xbb, 0x4a, 0x6c, 0x63, 0x3f, 0x1f, 0x9f, 0x89, 0xcf, 0xa5, 0xb5, 0x90, 0x04, 0x3d,
0x0f, 0xe3, 0xcd, 0xd6, 0xae, 0x65, 0x1a, 0x7a, 0x48, 0x0d, 0x66, 0xe2, 0x73, 0x49, 0x4d, 0xe5,
0x13, 0x4b, 0x6d, 0xe5, 0x73, 0x30, 0x76, 0x8f, 0xe0, 0x3b, 0x61, 0xd5, 0x0c, 0x53, 0xcd, 0x51,
0x71, 0x48, 0xb1, 0x0c, 0xd9, 0x06, 0xf1, 0x3c, 0x5c, 0x27, 0xba, 0xbf, 0xdf, 0x24, 0xf9, 0x04,
0x5b, 0xfd, 0x4c, 0xcf, 0xea, 0xbb, 0x57, 0x9e, 0x11, 0xa8, 0xed, 0xfd, 0x26, 0x41, 0x25, 0x48,
0x13, 0xbb, 0xd5, 0xe0, 0x0c, 0xc9, 0x43, 0xfc, 0x57, 0xb1, 0x5b, 0x8d, 0x6e, 0x96, 0x14, 0x85,
0x09, 0x8a, 0x11, 0x8f, 0xb8, 0x77, 0x4d, 0x83, 0xe4, 0x87, 0x19, 0xc1, 0xb9, 0x1e, 0x82, 0x2d,
0x3e, 0xdf, 0xcd, 0x21, 0x71, 0xa8, 0x0c, 0x69, 0x72, 0xdf, 0x27, 0xb6, 0x67, 0x3a, 0x76, 0x7e,
0x84, 0x91, 0x3c, 0xd3, 0x67, 0x17, 0x89, 0x55, 0xed, 0xa6, 0x68, 0xe3, 0xd0, 0x25, 0x18, 0x71,
0x9a, 0xbe, 0xe9, 0xd8, 0x5e, 0x3e, 0x35, 0xa3, 0xcc, 0x65, 0xce, 0x7f, 0xa4, 0x6f, 0x20, 0x6c,
0x70, 0x1d, 0x4d, 0x2a, 0xa3, 0x15, 0x50, 0x3d, 0xa7, 0xe5, 0x1a, 0x44, 0x37, 0x9c, 0x2a, 0xd1,
0x4d, 0xbb, 0xe6, 0xe4, 0xd3, 0x8c, 0xe0, 0x74, 0xef, 0x42, 0x98, 0x62, 0xd9, 0xa9, 0x92, 0x15,
0xbb, 0xe6, 0x68, 0x39, 0xaf, 0x63, 0x8c, 0xa6, 0x60, 0xd8, 0xdb, 0xb7, 0x7d, 0x7c, 0x3f, 0x9f,
0x65, 0x11, 0x22, 0x46, 0xb3, 0xff, 0x9b, 0x84, 0xb1, 0x41, 0x42, 0xec, 0x2a, 0x24, 0x6b, 0x74,
0x95, 0xf9, 0xd8, 0x71, 0x7c, 0xc0, 0x31, 0x9d, 0x4e, 0x1c, 0x7e, 0x8f, 0x4e, 0x2c, 0x41, 0xc6,
0x26, 0x9e, 0x4f, 0xaa, 0x3c, 0x22, 0xe2, 0x03, 0xc6, 0x14, 0x70, 0x50, 0x6f, 0x48, 0x25, 0xde,
0x53, 0x48, 0xdd, 0x84, 0xb1, 0xc0, 0x24, 0xdd, 0xc5, 0x76, 0x5d, 0xc6, 0xe6, 0x42, 0x94, 0x25,
0xf3, 0x15, 0x89, 0xd3, 0x28, 0x4c, 0xcb, 0x91, 0x8e, 0x31, 0x5a, 0x02, 0x70, 0x6c, 0xe2, 0xd4,
0xf4, 0x2a, 0x31, 0xac, 0x7c, 0xea, 0x10, 0x2f, 0x6d, 0x50, 0x95, 0x1e, 0x2f, 0x39, 0x5c, 0x6a,
0x58, 0xe8, 0x4a, 0x3b, 0xd4, 0x46, 0x0e, 0x89, 0x94, 0x35, 0x7e, 0xc8, 0x7a, 0xa2, 0x6d, 0x07,
0x72, 0x2e, 0xa1, 0x71, 0x4f, 0xaa, 0x62, 0x65, 0x69, 0x66, 0xc4, 0x7c, 0xe4, 0xca, 0x34, 0x01,
0xe3, 0x0b, 0x1b, 0x75, 0xc3, 0x43, 0xf4, 0x51, 0x08, 0x04, 0x3a, 0x0b, 0x2b, 0x60, 0x59, 0x28,
0x2b, 0x85, 0xeb, 0xb8, 0x41, 0xa6, 0x2f, 0x43, 0xae, 0xd3, 0x3d, 0x68, 0x12, 0x92, 0x9e, 0x8f,
0x5d, 0x9f, 0x45, 0x61, 0x52, 0xe3, 0x03, 0xa4, 0x42, 0x9c, 0xd8, 0x55, 0x96, 0xe5, 0x92, 0x1a,
0xfd, 0x39, 0xfd, 0x22, 0x8c, 0x76, 0x3c, 0x7e, 0x50, 0xe0, 0xec, 0x57, 0x86, 0x61, 0xb2, 0x5f,
0xcc, 0xf5, 0x0d, 0xff, 0x29, 0x18, 0xb6, 0x5b, 0x8d, 0x5d, 0xe2, 0xe6, 0xe3, 0x8c, 0x41, 0x8c,
0x50, 0x09, 0x92, 0x16, 0xde, 0x25, 0x56, 0x3e, 0x31, 0xa3, 0xcc, 0xe5, 0xce, 0x3f, 0x3f, 0x50,
0x54, 0xcf, 0xaf, 0x52, 0x88, 0xc6, 0x91, 0xe8, 0x53, 0x90, 0x10, 0x29, 0x8e, 0x32, 0x3c, 0x37,
0x18, 0x03, 0x8d, 0x45, 0x8d, 0xe1, 0xd0, 0x29, 0x48, 0xd3, 0xbf, 0xdc, 0xb7, 0xc3, 0xcc, 0xe6,
0x14, 0x15, 0x50, 0xbf, 0xa2, 0x69, 0x48, 0xb1, 0x30, 0xab, 0x12, 0x59, 0x1a, 0x82, 0x31, 0xdd,
0x98, 0x2a, 0xa9, 0xe1, 0x96, 0xe5, 0xeb, 0x77, 0xb1, 0xd5, 0x22, 0x2c, 0x60, 0xd2, 0x5a, 0x56,
0x08, 0x3f, 0x43, 0x65, 0xe8, 0x34, 0x64, 0x78, 0x54, 0x9a, 0x76, 0x95, 0xdc, 0x67, 0xd9, 0x27,
0xa9, 0xf1, 0x40, 0x5d, 0xa1, 0x12, 0xfa, 0xf8, 0xdb, 0x9e, 0x63, 0xcb, 0xad, 0x65, 0x8f, 0xa0,
0x02, 0xf6, 0xf8, 0x17, 0xbb, 0x13, 0xdf, 0xd3, 0xfd, 0x97, 0xd7, 0x1d, 0x8b, 0xb3, 0x7f, 0x1e,
0x83, 0x04, 0x3b, 0x6f, 0x63, 0x90, 0xd9, 0xbe, 0xb5, 0x59, 0xd1, 0x97, 0x36, 0x76, 0x16, 0x57,
0x2b, 0xaa, 0x82, 0x72, 0x00, 0x4c, 0x70, 0x7d, 0x75, 0xa3, 0xb4, 0xad, 0xc6, 0x82, 0xf1, 0xca,
0xfa, 0xf6, 0xa5, 0x0b, 0x6a, 0x3c, 0x00, 0xec, 0x70, 0x41, 0x22, 0xac, 0xf0, 0xc2, 0x79, 0x35,
0x89, 0x54, 0xc8, 0x72, 0x82, 0x95, 0x9b, 0x95, 0xa5, 0x4b, 0x17, 0xd4, 0xe1, 0x4e, 0xc9, 0x0b,
0xe7, 0xd5, 0x11, 0x34, 0x0a, 0x69, 0x26, 0x59, 0xdc, 0xd8, 0x58, 0x55, 0x53, 0x01, 0xe7, 0xd6,
0xb6, 0xb6, 0xb2, 0xbe, 0xac, 0xa6, 0x03, 0xce, 0x65, 0x6d, 0x63, 0x67, 0x53, 0x85, 0x80, 0x61,
0xad, 0xb2, 0xb5, 0x55, 0x5a, 0xae, 0xa8, 0x99, 0x40, 0x63, 0xf1, 0xd6, 0x76, 0x65, 0x4b, 0xcd,
0x76, 0x98, 0xf5, 0xc2, 0x79, 0x75, 0x34, 0x78, 0x44, 0x65, 0x7d, 0x67, 0x4d, 0xcd, 0xa1, 0x71,
0x18, 0xe5, 0x8f, 0x90, 0x46, 0x8c, 0x75, 0x89, 0x2e, 0x5d, 0x50, 0xd5, 0xb6, 0x21, 0x9c, 0x65,
0xbc, 0x43, 0x70, 0xe9, 0x82, 0x8a, 0x66, 0xcb, 0x90, 0x64, 0xd1, 0x85, 0x10, 0xe4, 0x56, 0x4b,
0x8b, 0x95, 0x55, 0x7d, 0x63, 0x73, 0x7b, 0x65, 0x63, 0xbd, 0xb4, 0xaa, 0x2a, 0x6d, 0x99, 0x56,
0xf9, 0x99, 0x9d, 0x15, 0xad, 0xb2, 0xa4, 0xc6, 0xc2, 0xb2, 0xcd, 0x4a, 0x69, 0xbb, 0xb2, 0xa4,
0xc6, 0x67, 0x0d, 0x98, 0xec, 0x97, 0x67, 0xfa, 0x9e, 0x8c, 0xd0, 0x16, 0xc7, 0x0e, 0xd9, 0x62,
0xc6, 0xd5, 0xb3, 0xc5, 0xdf, 0x56, 0x60, 0xa2, 0x4f, 0xae, 0xed, 0xfb, 0x90, 0x6b, 0x90, 0xe4,
0x21, 0xca, 0xab, 0xcf, 0xb3, 0x7d, 0x93, 0x36, 0x0b, 0xd8, 0x9e, 0x0a, 0xc4, 0x70, 0xe1, 0x0a,
0x1c, 0x3f, 0xa4, 0x02, 0x53, 0x8a, 0x1e, 0x23, 0x5f, 0x56, 0x20, 0x7f, 0x18, 0x77, 0x44, 0xa2,
0x88, 0x75, 0x24, 0x8a, 0xab, 0xdd, 0x06, 0x9c, 0x39, 0x7c, 0x0d, 0x3d, 0x56, 0xbc, 0xa6, 0xc0,
0x54, 0xff, 0x46, 0xa5, 0xaf, 0x0d, 0x9f, 0x82, 0xe1, 0x06, 0xf1, 0xf7, 0x1c, 0x59, 0xac, 0x7f,
0xaa, 0x4f, 0x09, 0xa0, 0xd3, 0xdd, 0xbe, 0x12, 0xa8, 0x70, 0x0d, 0x89, 0x1f, 0xd6, 0x6d, 0x70,
0x6b, 0x7a, 0x2c, 0xfd, 0x62, 0x0c, 0x9e, 0xea, 0x4b, 0xde, 0xd7, 0xd0, 0xa7, 0x01, 0x4c, 0xbb,
0xd9, 0xf2, 0x79, 0x41, 0xe6, 0xf9, 0x29, 0xcd, 0x24, 0xec, 0xec, 0xd3, 0xdc, 0xd3, 0xf2, 0x83,
0xf9, 0x38, 0x9b, 0x07, 0x2e, 0x62, 0x0a, 0x97, 0xdb, 0x86, 0x26, 0x98, 0xa1, 0x85, 0x43, 0x56,
0xda, 0x53, 0xeb, 0x3e, 0x01, 0xaa, 0x61, 0x99, 0xc4, 0xf6, 0x75, 0xcf, 0x77, 0x09, 0x6e, 0x98,
0x76, 0x9d, 0x25, 0xe0, 0x54, 0x31, 0x59, 0xc3, 0x96, 0x47, 0xb4, 0x31, 0x3e, 0xbd, 0x25, 0x67,
0x29, 0x82, 0x55, 0x19, 0x37, 0x84, 0x18, 0xee, 0x40, 0xf0, 0xe9, 0x00, 0x31, 0xfb, 0xa5, 0x11,
0xc8, 0x84, 0xda, 0x3a, 0x74, 0x06, 0xb2, 0xb7, 0xf1, 0x5d, 0xac, 0xcb, 0x56, 0x9d, 0x7b, 0x22,
0x43, 0x65, 0x9b, 0xa2, 0x5d, 0xff, 0x04, 0x4c, 0x32, 0x15, 0xa7, 0xe5, 0x13, 0x57, 0x37, 0x2c,
0xec, 0x79, 0xcc, 0x69, 0x29, 0xa6, 0x8a, 0xe8, 0xdc, 0x06, 0x9d, 0x2a, 0xcb, 0x19, 0x74, 0x11,
0x26, 0x18, 0xa2, 0xd1, 0xb2, 0x7c, 0xb3, 0x69, 0x11, 0x9d, 0xbe, 0x3c, 0x78, 0x2c, 0x11, 0x07,
0x96, 0x8d, 0x53, 0x8d, 0x35, 0xa1, 0x40, 0x2d, 0xf2, 0xd0, 0x32, 0x3c, 0xcd, 0x60, 0x75, 0x62,
0x13, 0x17, 0xfb, 0x44, 0x27, 0x3f, 0xdb, 0xc2, 0x96, 0xa7, 0x63, 0xbb, 0xaa, 0xef, 0x61, 0x6f,
0x2f, 0x3f, 0x19, 0x26, 0x38, 0x49, 0x75, 0x97, 0x85, 0x6a, 0x85, 0x69, 0x96, 0xec, 0xea, 0xa7,
0xb1, 0xb7, 0x87, 0x8a, 0x30, 0xc5, 0x88, 0x3c, 0xdf, 0x35, 0xed, 0xba, 0x6e, 0xec, 0x11, 0xe3,
0x8e, 0xde, 0xf2, 0x6b, 0x97, 0xf3, 0xa7, 0xc2, 0x0c, 0xcc, 0xc8, 0x2d, 0xa6, 0x53, 0xa6, 0x2a,
0x3b, 0x7e, 0xed, 0x32, 0xda, 0x82, 0x2c, 0xdd, 0x8f, 0x86, 0xf9, 0x80, 0xe8, 0x35, 0xc7, 0x65,
0xc5, 0x25, 0xd7, 0xe7, 0x70, 0x87, 0x9c, 0x38, 0xbf, 0x21, 0x00, 0x6b, 0x4e, 0x95, 0x14, 0x93,
0x5b, 0x9b, 0x95, 0xca, 0x92, 0x96, 0x91, 0x2c, 0xd7, 0x1d, 0x97, 0xc6, 0x54, 0xdd, 0x09, 0x7c,
0x9c, 0xe1, 0x31, 0x55, 0x77, 0xa4, 0x87, 0x2f, 0xc2, 0x84, 0x61, 0xf0, 0x65, 0x9b, 0x86, 0x2e,
0xba, 0x7c, 0x2f, 0xaf, 0x76, 0xf8, 0xcb, 0x30, 0x96, 0xb9, 0x82, 0x08, 0x73, 0x0f, 0x5d, 0x81,
0xa7, 0xda, 0xfe, 0x0a, 0x03, 0xc7, 0x7b, 0x56, 0xd9, 0x0d, 0xbd, 0x08, 0x13, 0xcd, 0xfd, 0x5e,
0x20, 0xea, 0x78, 0x62, 0x73, 0xbf, 0x1b, 0xf6, 0x0c, 0x7b, 0x73, 0x73, 0x89, 0x81, 0x7d, 0x52,
0xcd, 0x9f, 0x08, 0x6b, 0x87, 0x26, 0xd0, 0x02, 0xa8, 0x86, 0xa1, 0x13, 0x1b, 0xef, 0x5a, 0x44,
0xc7, 0x2e, 0xb1, 0xb1, 0x97, 0x3f, 0x1d, 0x56, 0xce, 0x19, 0x46, 0x85, 0xcd, 0x96, 0xd8, 0x24,
0x7a, 0x0e, 0xc6, 0x9d, 0xdd, 0xdb, 0x06, 0x0f, 0x2e, 0xbd, 0xe9, 0x92, 0x9a, 0x79, 0x3f, 0x7f,
0x96, 0xb9, 0x69, 0x8c, 0x4e, 0xb0, 0xd0, 0xda, 0x64, 0x62, 0xf4, 0x2c, 0xa8, 0x86, 0xb7, 0x87,
0xdd, 0x26, 0xab, 0xee, 0x5e, 0x13, 0x1b, 0x24, 0xff, 0x0c, 0x57, 0xe5, 0xf2, 0x75, 0x29, 0x46,
0x37, 0x61, 0xb2, 0x65, 0x9b, 0xb6, 0x4f, 0xdc, 0xa6, 0x4b, 0x68, 0x93, 0xce, 0x4f, 0x5a, 0xfe,
0x9f, 0x47, 0x0e, 0x69, 0xb3, 0x77, 0xc2, 0xda, 0x7c, 0x77, 0xb5, 0x89, 0x56, 0xaf, 0x70, 0xb6,
0x08, 0xd9, 0xf0, 0xa6, 0xa3, 0x34, 0xf0, 0x6d, 0x57, 0x15, 0x5a, 0x43, 0xcb, 0x1b, 0x4b, 0xb4,
0xfa, 0x7d, 0xb6, 0xa2, 0xc6, 0x68, 0x15, 0x5e, 0x5d, 0xd9, 0xae, 0xe8, 0xda, 0xce, 0xfa, 0xf6,
0xca, 0x5a, 0x45, 0x8d, 0x3f, 0x97, 0x4e, 0xbd, 0x35, 0xa2, 0x3e, 0x7c, 0xf8, 0xf0, 0x61, 0x6c,
0xf6, 0x87, 0x31, 0xc8, 0x75, 0x76, 0xbe, 0xe8, 0xa7, 0xe1, 0x84, 0x7c, 0x4d, 0xf5, 0x88, 0xaf,
0xdf, 0x33, 0x5d, 0x16, 0x87, 0x0d, 0xcc, 0x7b, 0xc7, 0xc0, 0x85, 0x93, 0x42, 0x6b, 0x8b, 0xf8,
0x2f, 0x99, 0x2e, 0x8d, 0xb2, 0x06, 0xf6, 0xd1, 0x2a, 0x9c, 0xb6, 0x1d, 0xdd, 0xf3, 0xb1, 0x5d,
0xc5, 0x6e, 0x55, 0x6f, 0x5f, 0x10, 0xe8, 0xd8, 0x30, 0x88, 0xe7, 0x39, 0xbc, 0x04, 0x04, 0x2c,
0x1f, 0xb1, 0x9d, 0x2d, 0xa1, 0xdc, 0xce, 0x8d, 0x25, 0xa1, 0xda, 0xb5, 0xdd, 0xf1, 0xc3, 0xb6,
0xfb, 0x14, 0xa4, 0x1b, 0xb8, 0xa9, 0x13, 0xdb, 0x77, 0xf7, 0x59, 0xbf, 0x96, 0xd2, 0x52, 0x0d,
0xdc, 0xac, 0xd0, 0xf1, 0xfb, 0xb7, 0x07, 0x61, 0x3f, 0xfe, 0x7d, 0x1c, 0xb2, 0xe1, 0x9e, 0x8d,
0xb6, 0xc0, 0x06, 0xcb, 0xcf, 0x0a, 0x3b, 0xbe, 0x1f, 0x3d, 0xb2, 0xc3, 0x9b, 0x2f, 0xd3, 0xc4,
0x5d, 0x1c, 0xe6, 0x9d, 0x94, 0xc6, 0x91, 0xb4, 0x68, 0xd2, 0x03, 0x4b, 0x78, 0x7f, 0x9e, 0xd2,
0xc4, 0x08, 0x2d, 0xc3, 0xf0, 0x6d, 0x8f, 0x71, 0x0f, 0x33, 0xee, 0xb3, 0x47, 0x73, 0xdf, 0xd8,
0x62, 0xe4, 0xe9, 0x1b, 0x5b, 0xfa, 0xfa, 0x86, 0xb6, 0x56, 0x5a, 0xd5, 0x04, 0x1c, 0x9d, 0x84,
0x84, 0x85, 0x1f, 0xec, 0x77, 0xa6, 0x78, 0x26, 0x1a, 0xd4, 0xf1, 0x27, 0x21, 0x71, 0x8f, 0xe0,
0x3b, 0x9d, 0x89, 0x95, 0x89, 0xde, 0xc7, 0xd0, 0x5f, 0x80, 0x24, 0xf3, 0x17, 0x02, 0x10, 0x1e,
0x53, 0x87, 0x50, 0x0a, 0x12, 0xe5, 0x0d, 0x8d, 0x86, 0xbf, 0x0a, 0x59, 0x2e, 0xd5, 0x37, 0x57,
0x2a, 0xe5, 0x8a, 0x1a, 0x9b, 0xbd, 0x08, 0xc3, 0xdc, 0x09, 0xf4, 0x68, 0x04, 0x6e, 0x50, 0x87,
0xc4, 0x50, 0x70, 0x28, 0x72, 0x76, 0x67, 0x6d, 0xb1, 0xa2, 0xa9, 0xb1, 0xf0, 0xf6, 0x7a, 0x90,
0x0d, 0xb7, 0x6b, 0x1f, 0x4c, 0x4c, 0xfd, 0xa5, 0x02, 0x99, 0x50, 0xfb, 0x45, 0x0b, 0x3f, 0xb6,
0x2c, 0xe7, 0x9e, 0x8e, 0x2d, 0x13, 0x7b, 0x22, 0x28, 0x80, 0x89, 0x4a, 0x54, 0x32, 0xe8, 0xa6,
0x7d, 0x20, 0xc6, 0x7f, 0x43, 0x01, 0xb5, 0xbb, 0x75, 0xeb, 0x32, 0x50, 0xf9, 0x50, 0x0d, 0x7c,
0x55, 0x81, 0x5c, 0x67, 0xbf, 0xd6, 0x65, 0xde, 0x99, 0x0f, 0xd5, 0xbc, 0xaf, 0x29, 0x30, 0xda,
0xd1, 0xa5, 0xfd, 0x44, 0x59, 0xf7, 0x4a, 0x1c, 0x26, 0xfa, 0xe0, 0x50, 0x49, 0xb4, 0xb3, 0xbc,
0xc3, 0xfe, 0xf8, 0x20, 0xcf, 0x9a, 0xa7, 0xd5, 0x72, 0x13, 0xbb, 0xbe, 0xe8, 0x7e, 0x9f, 0x05,
0xd5, 0xac, 0x12, 0xdb, 0x37, 0x6b, 0x26, 0x71, 0xc5, 0x2b, 0x38, 0xef, 0x71, 0xc7, 0xda, 0x72,
0xfe, 0x16, 0xfe, 0x31, 0x40, 0x4d, 0xc7, 0x33, 0x7d, 0xf3, 0x2e, 0xd1, 0x4d, 0x5b, 0xbe, 0xaf,
0xd3, 0x9e, 0x37, 0xa1, 0xa9, 0x72, 0x66, 0xc5, 0xf6, 0x03, 0x6d, 0x9b, 0xd4, 0x71, 0x97, 0x36,
0xcd, 0x7d, 0x71, 0x4d, 0x95, 0x33, 0x81, 0xf6, 0x19, 0xc8, 0x56, 0x9d, 0x16, 0x6d, 0x1f, 0xb8,
0x1e, 0x4d, 0xb5, 0x8a, 0x96, 0xe1, 0xb2, 0x40, 0x45, 0xf4, 0x77, 0xed, 0x8b, 0x82, 0xac, 0x96,
0xe1, 0x32, 0xae, 0x72, 0x0e, 0xc6, 0x70, 0xbd, 0xee, 0x52, 0x72, 0x49, 0xc4, 0x9b, 0xd6, 0x5c,
0x20, 0x66, 0x8a, 0xd3, 0x37, 0x20, 0x25, 0xfd, 0x40, 0xab, 0x19, 0xf5, 0x84, 0xde, 0xe4, 0xd7,
0x35, 0xb1, 0xb9, 0xb4, 0x96, 0xb2, 0xe5, 0xe4, 0x19, 0xc8, 0x9a, 0x9e, 0xde, 0xbe, 0x37, 0x8c,
0xcd, 0xc4, 0xe6, 0x52, 0x5a, 0xc6, 0xf4, 0x82, 0x8b, 0xa2, 0xd9, 0xd7, 0x62, 0x90, 0xeb, 0xbc,
0xf7, 0x44, 0x4b, 0x90, 0xb2, 0x1c, 0x03, 0xb3, 0x40, 0xe0, 0x97, 0xee, 0x73, 0x11, 0x57, 0xa5,
0xf3, 0xab, 0x42, 0x5f, 0x0b, 0x90, 0xd3, 0x7f, 0xab, 0x40, 0x4a, 0x8a, 0xd1, 0x14, 0x24, 0x9a,
0xd8, 0xdf, 0x63, 0x74, 0xc9, 0xc5, 0x98, 0xaa, 0x68, 0x6c, 0x4c, 0xe5, 0x5e, 0x13, 0xdb, 0x2c,
0x04, 0x84, 0x9c, 0x8e, 0xe9, 0xbe, 0x5a, 0x04, 0x57, 0x59, 0x3b, 0xec, 0x34, 0x1a, 0xc4, 0xf6,
0x3d, 0xb9, 0xaf, 0x42, 0x5e, 0x16, 0x62, 0xf4, 0x3c, 0x8c, 0xfb, 0x2e, 0x36, 0xad, 0x0e, 0xdd,
0x04, 0xd3, 0x55, 0xe5, 0x44, 0xa0, 0x5c, 0x84, 0x93, 0x92, 0xb7, 0x4a, 0x7c, 0x6c, 0xec, 0x91,
0x6a, 0x1b, 0x34, 0xcc, 0x2e, 0xd5, 0x4e, 0x08, 0x85, 0x25, 0x31, 0x2f, 0xb1, 0xb3, 0x3f, 0x56,
0x60, 0x5c, 0x36, 0xf0, 0xd5, 0xc0, 0x59, 0x6b, 0x00, 0xd8, 0xb6, 0x1d, 0x3f, 0xec, 0xae, 0xde,
0x50, 0xee, 0xc1, 0xcd, 0x97, 0x02, 0x90, 0x16, 0x22, 0x98, 0x6e, 0x00, 0xb4, 0x67, 0x0e, 0x75,
0xdb, 0x69, 0xc8, 0x88, 0x4b, 0x6d, 0xf6, 0x65, 0x84, 0xbf, 0xf5, 0x01, 0x17, 0xd1, 0x4e, 0x1f,
0x4d, 0x42, 0x72, 0x97, 0xd4, 0x4d, 0x5b, 0x5c, 0xb5, 0xf1, 0x81, 0xbc, 0xc0, 0x4b, 0x04, 0x17,
0x78, 0x8b, 0x9f, 0x83, 0x09, 0xc3, 0x69, 0x74, 0x9b, 0xbb, 0xa8, 0x76, 0xbd, 0x79, 0x7a, 0x9f,
0x56, 0x3e, 0x0b, 0xed, 0xee, 0xec, 0x5b, 0x8a, 0xf2, 0xed, 0x58, 0x7c, 0x79, 0x73, 0xf1, 0xbb,
0xb1, 0xe9, 0x65, 0x0e, 0xdd, 0x94, 0x2b, 0xd5, 0x48, 0xcd, 0x22, 0x06, 0xb5, 0x1e, 0xbe, 0x79,
0x16, 0x3e, 0x5e, 0x37, 0xfd, 0xbd, 0xd6, 0xee, 0xbc, 0xe1, 0x34, 0x16, 0xea, 0x4e, 0xdd, 0x69,
0x7f, 0x0c, 0xa2, 0x23, 0x36, 0x60, 0xbf, 0xc4, 0x07, 0xa1, 0x74, 0x20, 0x9d, 0x8e, 0xfc, 0x7a,
0x54, 0x5c, 0x87, 0x09, 0xa1, 0xac, 0xb3, 0x1b, 0x69, 0xde, 0x87, 0xa3, 0x23, 0x6f, 0x25, 0xf2,
0xdf, 0x7f, 0x93, 0x55, 0x3a, 0x6d, 0x5c, 0x40, 0xe9, 0x1c, 0xef, 0xd4, 0x8b, 0x1a, 0x3c, 0xd5,
0xc1, 0xc7, 0x8f, 0x26, 0x71, 0x23, 0x18, 0x7f, 0x28, 0x18, 0x27, 0x42, 0x8c, 0x5b, 0x02, 0x5a,
0x2c, 0xc3, 0xe8, 0x71, 0xb8, 0xfe, 0x5a, 0x70, 0x65, 0x49, 0x98, 0x64, 0x19, 0xc6, 0x18, 0x89,
0xd1, 0xf2, 0x7c, 0xa7, 0xc1, 0xf2, 0xde, 0xd1, 0x34, 0x7f, 0xf3, 0x26, 0x3f, 0x2b, 0x39, 0x0a,
0x2b, 0x07, 0xa8, 0xe2, 0x67, 0x60, 0x92, 0x4a, 0x58, 0x6a, 0x09, 0xb3, 0x45, 0xdf, 0xa3, 0xe4,
0x7f, 0xfc, 0x32, 0x3f, 0x52, 0x13, 0x01, 0x41, 0x88, 0x37, 0xb4, 0x13, 0x75, 0xe2, 0xfb, 0xc4,
0xf5, 0x74, 0x6c, 0x59, 0xe8, 0xc8, 0x2f, 0x34, 0xf9, 0xaf, 0xbe, 0xdd, 0xb9, 0x13, 0xcb, 0x1c,
0x59, 0xb2, 0xac, 0xe2, 0x0e, 0x9c, 0xe8, 0xb3, 0xb3, 0x03, 0x70, 0xbe, 0x22, 0x38, 0x27, 0x7b,
0x76, 0x97, 0xd2, 0x6e, 0x82, 0x94, 0x07, 0xfb, 0x31, 0x00, 0xe7, 0xd7, 0x04, 0x27, 0x12, 0x58,
0xb9, 0x2d, 0x94, 0xf1, 0x06, 0x8c, 0xdf, 0x25, 0xee, 0xae, 0xe3, 0x89, 0x97, 0xff, 0x01, 0xe8,
0x5e, 0x15, 0x74, 0x63, 0x02, 0xc8, 0xae, 0x02, 0x28, 0xd7, 0x15, 0x48, 0xd5, 0xb0, 0x41, 0x06,
0xa0, 0xf8, 0xba, 0xa0, 0x18, 0xa1, 0xfa, 0x14, 0x5a, 0x82, 0x6c, 0xdd, 0x11, 0xd5, 0x25, 0x1a,
0xfe, 0x0d, 0x01, 0xcf, 0x48, 0x8c, 0xa0, 0x68, 0x3a, 0xcd, 0x96, 0x45, 0x4b, 0x4f, 0x34, 0xc5,
0x37, 0x25, 0x85, 0xc4, 0x08, 0x8a, 0x63, 0xb8, 0xf5, 0x5b, 0x92, 0xc2, 0x0b, 0xf9, 0xf3, 0x1a,
0x64, 0x1c, 0xdb, 0xda, 0x77, 0xec, 0x41, 0x8c, 0xf8, 0x2d, 0xc1, 0x00, 0x02, 0x42, 0x09, 0xae,
0x42, 0x7a, 0xd0, 0x8d, 0xf8, 0x6d, 0x01, 0x4f, 0x11, 0xb9, 0x03, 0xcb, 0x30, 0x26, 0x93, 0x8c,
0xe9, 0xd8, 0x03, 0x50, 0xfc, 0x8e, 0xa0, 0xc8, 0x85, 0x60, 0x62, 0x19, 0x3e, 0xf1, 0xfc, 0x3a,
0x19, 0x84, 0xe4, 0x35, 0xb9, 0x0c, 0x01, 0x11, 0xae, 0xdc, 0x25, 0xb6, 0xb1, 0x37, 0x18, 0xc3,
0x77, 0xa4, 0x2b, 0x25, 0x86, 0x52, 0x94, 0x61, 0xb4, 0x81, 0x5d, 0x6f, 0x0f, 0x5b, 0x03, 0x6d,
0xc7, 0xef, 0x0a, 0x8e, 0x6c, 0x00, 0x12, 0x1e, 0x69, 0xd9, 0xc7, 0xa1, 0xf9, 0xae, 0xf4, 0x48,
0x08, 0x26, 0x8e, 0x9e, 0xe7, 0xb3, 0xfb, 0x95, 0xe3, 0xb0, 0xfd, 0x9e, 0x3c, 0x7a, 0x1c, 0xbb,
0x16, 0x66, 0xbc, 0x0a, 0x69, 0xcf, 0x7c, 0x30, 0x10, 0xcd, 0xef, 0xcb, 0x9d, 0x66, 0x00, 0x0a,
0xbe, 0x05, 0x27, 0xfb, 0xa6, 0xfa, 0x01, 0xc8, 0xfe, 0x40, 0x90, 0x4d, 0xf5, 0x49, 0xf7, 0x22,
0x25, 0x1c, 0x97, 0xf2, 0x0f, 0x65, 0x4a, 0x20, 0x5d, 0x5c, 0x9b, 0xb4, 0x3b, 0xf7, 0x70, 0xed,
0x78, 0x5e, 0xfb, 0x23, 0xe9, 0x35, 0x8e, 0xed, 0xf0, 0xda, 0x36, 0x4c, 0x09, 0xc6, 0xe3, 0xed,
0xeb, 0xf7, 0x64, 0x62, 0xe5, 0xe8, 0x9d, 0xce, 0xdd, 0xfd, 0x1c, 0x4c, 0x07, 0xee, 0x94, 0x8d,
0xa5, 0xa7, 0x37, 0x70, 0x73, 0x00, 0xe6, 0xef, 0x0b, 0x66, 0x99, 0xf1, 0x83, 0xce, 0xd4, 0x5b,
0xc3, 0x4d, 0x4a, 0x7e, 0x13, 0xf2, 0x92, 0xbc, 0x65, 0xbb, 0xc4, 0x70, 0xea, 0xb6, 0xf9, 0x80,
0x54, 0x07, 0xa0, 0xfe, 0xe3, 0xae, 0xad, 0xda, 0x09, 0xc1, 0x29, 0xf3, 0x0a, 0xa8, 0x41, 0xbf,
0xa1, 0x9b, 0x8d, 0xa6, 0xe3, 0xfa, 0x11, 0x8c, 0x7f, 0x22, 0x77, 0x2a, 0xc0, 0xad, 0x30, 0x58,
0xb1, 0x02, 0x39, 0x36, 0x1c, 0x34, 0x24, 0xff, 0x54, 0x10, 0x8d, 0xb6, 0x51, 0x22, 0x71, 0x18,
0x4e, 0xa3, 0x89, 0xdd, 0x41, 0xf2, 0xdf, 0x9f, 0xc9, 0xc4, 0x21, 0x20, 0x3c, 0xfa, 0xc6, 0xba,
0x2a, 0x31, 0x8a, 0xfa, 0x78, 0x9d, 0xff, 0xfc, 0x63, 0x71, 0x66, 0x3b, 0x0b, 0x71, 0x71, 0x95,
0xba, 0xa7, 0xb3, 0x5c, 0x46, 0x93, 0xbd, 0xfc, 0x38, 0xf0, 0x50, 0x47, 0xb5, 0x2c, 0x5e, 0x87,
0xd1, 0x8e, 0x52, 0x19, 0x4d, 0xf5, 0x05, 0x41, 0x95, 0x0d, 0x57, 0xca, 0xe2, 0x45, 0x48, 0xd0,
0xb2, 0x17, 0x0d, 0xff, 0x39, 0x01, 0x67, 0xea, 0xc5, 0x4f, 0x42, 0x4a, 0x96, 0xbb, 0x68, 0xe8,
0xcf, 0x0b, 0x68, 0x00, 0xa1, 0x70, 0x59, 0xea, 0xa2, 0xe1, 0xbf, 0x20, 0xe1, 0x12, 0x42, 0xe1,
0x83, 0xbb, 0xf0, 0x07, 0x5f, 0x4a, 0x88, 0x74, 0x25, 0x7d, 0x77, 0x15, 0x46, 0x44, 0x8d, 0x8b,
0x46, 0x7f, 0x51, 0x3c, 0x5c, 0x22, 0x8a, 0x2f, 0x42, 0x72, 0x40, 0x87, 0xff, 0x92, 0x80, 0x72,
0xfd, 0x62, 0x19, 0x32, 0xa1, 0xba, 0x16, 0x0d, 0xff, 0xb2, 0x80, 0x87, 0x51, 0xd4, 0x74, 0x51,
0xd7, 0xa2, 0x09, 0x7e, 0x59, 0x9a, 0x2e, 0x10, 0xd4, 0x6d, 0xb2, 0xa4, 0x45, 0xa3, 0x7f, 0x45,
0x7a, 0x5d, 0x42, 0x8a, 0xd7, 0x20, 0x1d, 0xa4, 0xa9, 0x68, 0xfc, 0xaf, 0x0a, 0x7c, 0x1b, 0x43,
0x3d, 0x10, 0x4a, 0x93, 0xd1, 0x14, 0xbf, 0x26, 0x3d, 0x10, 0x42, 0xd1, 0x63, 0xd4, 0x5d, 0xfa,
0xa2, 0x99, 0x7e, 0x5d, 0x1e, 0xa3, 0xae, 0xca, 0x47, 0x77, 0x93, 0x65, 0x8b, 0x68, 0x8a, 0xdf,
0x90, 0xbb, 0xc9, 0xf4, 0xa9, 0x19, 0xdd, 0xb5, 0x24, 0x9a, 0xe3, 0x37, 0xa5, 0x19, 0x5d, 0xa5,
0xa4, 0xb8, 0x09, 0xa8, 0xb7, 0x8e, 0x44, 0xf3, 0x7d, 0x45, 0xf0, 0x8d, 0xf7, 0x94, 0x91, 0xe2,
0x4b, 0x30, 0xd5, 0xbf, 0x86, 0x44, 0xb3, 0x7e, 0xf5, 0x71, 0x57, 0xd7, 0x1f, 0x2e, 0x21, 0xc5,
0xed, 0x76, 0xd7, 0x1f, 0xae, 0x1f, 0xd1, 0xb4, 0xaf, 0x3c, 0xee, 0x7c, 0xb1, 0x0b, 0x97, 0x8f,
0x62, 0x09, 0xa0, 0x9d, 0xba, 0xa3, 0xb9, 0x5e, 0x15, 0x5c, 0x21, 0x10, 0x3d, 0x1a, 0x22, 0x73,
0x47, 0xe3, 0xbf, 0x2e, 0x8f, 0x86, 0x40, 0x14, 0xaf, 0x42, 0xca, 0x6e, 0x59, 0x16, 0x0d, 0x0e,
0x74, 0xf4, 0x3f, 0x84, 0xe4, 0xff, 0xe5, 0x89, 0x38, 0x18, 0x12, 0x50, 0xbc, 0x08, 0x49, 0xd2,
0xd8, 0x25, 0xd5, 0x28, 0xe4, 0xbf, 0x3e, 0x91, 0x09, 0x81, 0x6a, 0x17, 0xaf, 0x01, 0xf0, 0x97,
0x46, 0xf6, 0x3d, 0x20, 0x02, 0xfb, 0x6f, 0x4f, 0xc4, 0xb7, 0xe6, 0x36, 0xa4, 0x4d, 0xc0, 0xbf,
0x5c, 0x1f, 0x4d, 0xf0, 0x76, 0x27, 0x01, 0x7b, 0xd1, 0xbc, 0x02, 0x23, 0xb7, 0x3d, 0xc7, 0xf6,
0x71, 0x3d, 0x0a, 0xfd, 0xef, 0x02, 0x2d, 0xf5, 0xa9, 0xc3, 0x1a, 0x8e, 0x4b, 0x7c, 0x5c, 0xf7,
0xa2, 0xb0, 0xff, 0x21, 0xb0, 0x01, 0x80, 0x82, 0x0d, 0xec, 0xf9, 0x83, 0xac, 0xfb, 0x3f, 0x25,
0x58, 0x02, 0xa8, 0xd1, 0xf4, 0xf7, 0x1d, 0xb2, 0x1f, 0x85, 0x7d, 0x47, 0x1a, 0x2d, 0xf4, 0x8b,
0x9f, 0x84, 0x34, 0xfd, 0xc9, 0xff, 0xff, 0x22, 0x02, 0xfc, 0x5f, 0x02, 0xdc, 0x46, 0xd0, 0x27,
0x7b, 0x7e, 0xd5, 0x37, 0xa3, 0x9d, 0xfd, 0xdf, 0x62, 0xa7, 0xa5, 0x7e, 0xb1, 0x04, 0x19, 0xcf,
0xaf, 0x56, 0x5b, 0x2e, 0xbf, 0x88, 0x8a, 0x80, 0xff, 0xcf, 0x93, 0xe0, 0x65, 0x2e, 0xc0, 0x2c,
0x9e, 0xe9, 0x7f, 0xb7, 0x04, 0xcb, 0xce, 0xb2, 0xc3, 0x6f, 0x95, 0xe0, 0xcb, 0x49, 0x98, 0x31,
0x9c, 0xc6, 0xae, 0xe3, 0x2d, 0x04, 0x99, 0x60, 0x21, 0xb0, 0x5f, 0x5e, 0x0a, 0x05, 0x82, 0xe9,
0xe3, 0x5d, 0x27, 0xcd, 0xfe, 0x55, 0x1c, 0x52, 0x65, 0xec, 0xf9, 0xf8, 0x1e, 0xde, 0x47, 0x4d,
0x98, 0xa0, 0xbf, 0xd7, 0x70, 0x93, 0x5d, 0x6c, 0x88, 0x03, 0x26, 0x6e, 0xec, 0x3e, 0x36, 0xdf,
0x7e, 0xaa, 0x44, 0xcc, 0xf7, 0x51, 0x67, 0x1f, 0x09, 0x17, 0xd5, 0xd7, 0xff, 0xe1, 0xf4, 0xd0,
0x2f, 0xfe, 0xe3, 0xe9, 0xd4, 0xda, 0xfe, 0x4b, 0xa6, 0xe5, 0x39, 0xb6, 0xd6, 0x8f, 0x1a, 0x7d,
0x41, 0x81, 0x53, 0x7d, 0xe4, 0xeb, 0xe2, 0x18, 0x8a, 0x7b, 0xef, 0x0b, 0x03, 0x3e, 0x5a, 0xc2,
0xb8, 0x09, 0xd9, 0x8e, 0xc7, 0x1f, 0xf5, 0x98, 0xe9, 0x5b, 0x90, 0x3f, 0x6c, 0x25, 0x48, 0x85,
0xf8, 0x1d, 0xb2, 0x2f, 0xfe, 0xcd, 0x8f, 0xfe, 0x44, 0xe7, 0xda, 0xff, 0x26, 0xa4, 0xcc, 0x65,
0xce, 0x8f, 0x87, 0xac, 0x13, 0x0f, 0xe3, 0xf3, 0xc5, 0xd8, 0x65, 0x65, 0x1a, 0xc3, 0x4c, 0x94,
0xa5, 0xff, 0xcf, 0x47, 0xcc, 0x16, 0x60, 0x98, 0x0b, 0xd1, 0x24, 0x24, 0x57, 0x6c, 0xff, 0xd2,
0x05, 0x46, 0x15, 0xd7, 0xf8, 0x60, 0x71, 0xf5, 0xf5, 0x47, 0x85, 0xa1, 0x1f, 0x3d, 0x2a, 0x0c,
0xfd, 0xdd, 0xa3, 0xc2, 0xd0, 0x1b, 0x8f, 0x0a, 0xca, 0x5b, 0x8f, 0x0a, 0xca, 0x3b, 0x8f, 0x0a,
0xca, 0xbb, 0x8f, 0x0a, 0xca, 0xc3, 0x83, 0x82, 0xf2, 0x9d, 0x83, 0x82, 0xf2, 0xbd, 0x83, 0x82,
0xf2, 0x17, 0x07, 0x05, 0xe5, 0x07, 0x07, 0x05, 0xe5, 0xf5, 0x83, 0x82, 0xf2, 0xa3, 0x83, 0xc2,
0xd0, 0x1b, 0x07, 0x05, 0xe5, 0xad, 0x83, 0xc2, 0xd0, 0x3b, 0x07, 0x05, 0xe5, 0xdd, 0x83, 0xc2,
0xd0, 0xc3, 0x7f, 0x2a, 0x0c, 0xfd, 0x5f, 0x00, 0x00, 0x00, 0xff, 0xff, 0x26, 0x33, 0x13, 0x65,
0xb7, 0x2e, 0x00, 0x00,
}
r := bytes.NewReader(gzipped)
gzipr, err := compress_gzip.NewReader(r)
@@ -599,11 +608,12 @@ func valueToGoStringCastvalue(v interface{}, typ string) string {
pv := reflect.Indirect(rv).Interface()
return fmt.Sprintf("func(v %v) *%v { return &v } ( %#v )", typ, typ, pv)
}
func extensionToGoStringCastvalue(e map[int32]github_com_gogo_protobuf_proto.Extension) string {
func extensionToGoStringCastvalue(m github_com_gogo_protobuf_proto.Message) string {
e := github_com_gogo_protobuf_proto.GetUnsafeExtensionsMap(m)
if e == nil {
return "nil"
}
s := "map[int32]proto.Extension{"
s := "proto.NewUnsafeXXX_InternalExtensions(map[int32]proto.Extension{"
keys := make([]int, 0, len(e))
for k := range e {
keys = append(keys, int(k))
@@ -613,39 +623,43 @@ func extensionToGoStringCastvalue(e map[int32]github_com_gogo_protobuf_proto.Ext
for _, k := range keys {
ss = append(ss, strconv.Itoa(k)+": "+e[int32(k)].GoString())
}
s += strings.Join(ss, ",") + "}"
s += strings.Join(ss, ",") + "})"
return s
}
func (m *Castaway) Marshal() (data []byte, err error) {
func (m *Castaway) Marshal() (dAtA []byte, err error) {
size := m.Size()
data = make([]byte, size)
n, err := m.MarshalTo(data)
dAtA = make([]byte, size)
n, err := m.MarshalTo(dAtA)
if err != nil {
return nil, err
}
return data[:n], nil
return dAtA[:n], nil
}
func (m *Castaway) MarshalTo(data []byte) (int, error) {
func (m *Castaway) MarshalTo(dAtA []byte) (int, error) {
var i int
_ = i
var l int
_ = l
if len(m.CastMapValueMessage) > 0 {
for k := range m.CastMapValueMessage {
data[i] = 0xa
dAtA[i] = 0xa
i++
v := m.CastMapValueMessage[k]
msgSize := ((*Wilson)(&v)).Size()
mapSize := 1 + sovCastvalue(uint64(k)) + 1 + msgSize + sovCastvalue(uint64(msgSize))
i = encodeVarintCastvalue(data, i, uint64(mapSize))
data[i] = 0x8
msgSize := 0
if ((*Wilson)(&v)) != nil {
msgSize = ((*Wilson)(&v)).Size()
msgSize += 1 + sovCastvalue(uint64(msgSize))
}
mapSize := 1 + sovCastvalue(uint64(k)) + msgSize
i = encodeVarintCastvalue(dAtA, i, uint64(mapSize))
dAtA[i] = 0x8
i++
i = encodeVarintCastvalue(data, i, uint64(k))
data[i] = 0x12
i = encodeVarintCastvalue(dAtA, i, uint64(k))
dAtA[i] = 0x12
i++
i = encodeVarintCastvalue(data, i, uint64(((*Wilson)(&v)).Size()))
n1, err := ((*Wilson)(&v)).MarshalTo(data[i:])
i = encodeVarintCastvalue(dAtA, i, uint64(((*Wilson)(&v)).Size()))
n1, err := ((*Wilson)(&v)).MarshalTo(dAtA[i:])
if err != nil {
return 0, err
}
@@ -654,85 +668,88 @@ func (m *Castaway) MarshalTo(data []byte) (int, error) {
}
if len(m.CastMapValueMessageNullable) > 0 {
for k := range m.CastMapValueMessageNullable {
data[i] = 0x12
dAtA[i] = 0x12
i++
v := m.CastMapValueMessageNullable[k]
if v == nil {
return 0, errors.New("proto: map has nil element")
msgSize := 0
if ((*Wilson)(v)) != nil {
msgSize = ((*Wilson)(v)).Size()
msgSize += 1 + sovCastvalue(uint64(msgSize))
}
msgSize := ((*Wilson)(v)).Size()
mapSize := 1 + sovCastvalue(uint64(k)) + 1 + msgSize + sovCastvalue(uint64(msgSize))
i = encodeVarintCastvalue(data, i, uint64(mapSize))
data[i] = 0x8
mapSize := 1 + sovCastvalue(uint64(k)) + msgSize
i = encodeVarintCastvalue(dAtA, i, uint64(mapSize))
dAtA[i] = 0x8
i++
i = encodeVarintCastvalue(data, i, uint64(k))
data[i] = 0x12
i++
i = encodeVarintCastvalue(data, i, uint64(((*Wilson)(v)).Size()))
n2, err := ((*Wilson)(v)).MarshalTo(data[i:])
if err != nil {
return 0, err
i = encodeVarintCastvalue(dAtA, i, uint64(k))
if ((*Wilson)(v)) != nil {
dAtA[i] = 0x12
i++
i = encodeVarintCastvalue(dAtA, i, uint64(((*Wilson)(v)).Size()))
n2, err := ((*Wilson)(v)).MarshalTo(dAtA[i:])
if err != nil {
return 0, err
}
i += n2
}
i += n2
}
}
if m.XXX_unrecognized != nil {
i += copy(data[i:], m.XXX_unrecognized)
i += copy(dAtA[i:], m.XXX_unrecognized)
}
return i, nil
}
func (m *Wilson) Marshal() (data []byte, err error) {
func (m *Wilson) Marshal() (dAtA []byte, err error) {
size := m.Size()
data = make([]byte, size)
n, err := m.MarshalTo(data)
dAtA = make([]byte, size)
n, err := m.MarshalTo(dAtA)
if err != nil {
return nil, err
}
return data[:n], nil
return dAtA[:n], nil
}
func (m *Wilson) MarshalTo(data []byte) (int, error) {
func (m *Wilson) MarshalTo(dAtA []byte) (int, error) {
var i int
_ = i
var l int
_ = l
if m.Int64 != nil {
data[i] = 0x8
dAtA[i] = 0x8
i++
i = encodeVarintCastvalue(data, i, uint64(*m.Int64))
i = encodeVarintCastvalue(dAtA, i, uint64(*m.Int64))
}
if m.XXX_unrecognized != nil {
i += copy(data[i:], m.XXX_unrecognized)
i += copy(dAtA[i:], m.XXX_unrecognized)
}
return i, nil
}
func encodeFixed64Castvalue(data []byte, offset int, v uint64) int {
data[offset] = uint8(v)
data[offset+1] = uint8(v >> 8)
data[offset+2] = uint8(v >> 16)
data[offset+3] = uint8(v >> 24)
data[offset+4] = uint8(v >> 32)
data[offset+5] = uint8(v >> 40)
data[offset+6] = uint8(v >> 48)
data[offset+7] = uint8(v >> 56)
func encodeFixed64Castvalue(dAtA []byte, offset int, v uint64) int {
dAtA[offset] = uint8(v)
dAtA[offset+1] = uint8(v >> 8)
dAtA[offset+2] = uint8(v >> 16)
dAtA[offset+3] = uint8(v >> 24)
dAtA[offset+4] = uint8(v >> 32)
dAtA[offset+5] = uint8(v >> 40)
dAtA[offset+6] = uint8(v >> 48)
dAtA[offset+7] = uint8(v >> 56)
return offset + 8
}
func encodeFixed32Castvalue(data []byte, offset int, v uint32) int {
data[offset] = uint8(v)
data[offset+1] = uint8(v >> 8)
data[offset+2] = uint8(v >> 16)
data[offset+3] = uint8(v >> 24)
func encodeFixed32Castvalue(dAtA []byte, offset int, v uint32) int {
dAtA[offset] = uint8(v)
dAtA[offset+1] = uint8(v >> 8)
dAtA[offset+2] = uint8(v >> 16)
dAtA[offset+3] = uint8(v >> 24)
return offset + 4
}
func encodeVarintCastvalue(data []byte, offset int, v uint64) int {
func encodeVarintCastvalue(dAtA []byte, offset int, v uint64) int {
for v >= 1<<7 {
data[offset] = uint8(v&0x7f | 0x80)
dAtA[offset] = uint8(v&0x7f | 0x80)
v >>= 7
offset++
}
data[offset] = uint8(v)
dAtA[offset] = uint8(v)
return offset + 1
}
func NewPopulatedCastaway(r randyCastvalue, easy bool) *Castaway {
@@ -798,7 +815,7 @@ func randStringCastvalue(r randyCastvalue) string {
}
return string(tmps)
}
func randUnrecognizedCastvalue(r randyCastvalue, maxFieldNumber int) (data []byte) {
func randUnrecognizedCastvalue(r randyCastvalue, maxFieldNumber int) (dAtA []byte) {
l := r.Intn(5)
for i := 0; i < l; i++ {
wire := r.Intn(4)
@@ -806,43 +823,43 @@ func randUnrecognizedCastvalue(r randyCastvalue, maxFieldNumber int) (data []byt
wire = 5
}
fieldNumber := maxFieldNumber + r.Intn(100)
data = randFieldCastvalue(data, r, fieldNumber, wire)
dAtA = randFieldCastvalue(dAtA, r, fieldNumber, wire)
}
return data
return dAtA
}
func randFieldCastvalue(data []byte, r randyCastvalue, fieldNumber int, wire int) []byte {
func randFieldCastvalue(dAtA []byte, r randyCastvalue, fieldNumber int, wire int) []byte {
key := uint32(fieldNumber)<<3 | uint32(wire)
switch wire {
case 0:
data = encodeVarintPopulateCastvalue(data, uint64(key))
dAtA = encodeVarintPopulateCastvalue(dAtA, uint64(key))
v5 := r.Int63()
if r.Intn(2) == 0 {
v5 *= -1
}
data = encodeVarintPopulateCastvalue(data, uint64(v5))
dAtA = encodeVarintPopulateCastvalue(dAtA, uint64(v5))
case 1:
data = encodeVarintPopulateCastvalue(data, uint64(key))
data = append(data, byte(r.Intn(256)), byte(r.Intn(256)), byte(r.Intn(256)), byte(r.Intn(256)), byte(r.Intn(256)), byte(r.Intn(256)), byte(r.Intn(256)), byte(r.Intn(256)))
dAtA = encodeVarintPopulateCastvalue(dAtA, uint64(key))
dAtA = append(dAtA, byte(r.Intn(256)), byte(r.Intn(256)), byte(r.Intn(256)), byte(r.Intn(256)), byte(r.Intn(256)), byte(r.Intn(256)), byte(r.Intn(256)), byte(r.Intn(256)))
case 2:
data = encodeVarintPopulateCastvalue(data, uint64(key))
dAtA = encodeVarintPopulateCastvalue(dAtA, uint64(key))
ll := r.Intn(100)
data = encodeVarintPopulateCastvalue(data, uint64(ll))
dAtA = encodeVarintPopulateCastvalue(dAtA, uint64(ll))
for j := 0; j < ll; j++ {
data = append(data, byte(r.Intn(256)))
dAtA = append(dAtA, byte(r.Intn(256)))
}
default:
data = encodeVarintPopulateCastvalue(data, uint64(key))
data = append(data, byte(r.Intn(256)), byte(r.Intn(256)), byte(r.Intn(256)), byte(r.Intn(256)))
dAtA = encodeVarintPopulateCastvalue(dAtA, uint64(key))
dAtA = append(dAtA, byte(r.Intn(256)), byte(r.Intn(256)), byte(r.Intn(256)), byte(r.Intn(256)))
}
return data
return dAtA
}
func encodeVarintPopulateCastvalue(data []byte, v uint64) []byte {
func encodeVarintPopulateCastvalue(dAtA []byte, v uint64) []byte {
for v >= 1<<7 {
data = append(data, uint8(uint64(v)&0x7f|0x80))
dAtA = append(dAtA, uint8(uint64(v)&0x7f|0x80))
v >>= 7
}
data = append(data, uint8(v))
return data
dAtA = append(dAtA, uint8(v))
return dAtA
}
func (m *Castaway) Size() (n int) {
var l int
@@ -863,8 +880,9 @@ func (m *Castaway) Size() (n int) {
l = 0
if v != nil {
l = ((*Wilson)(v)).Size()
l += 1 + sovCastvalue(uint64(l))
}
mapEntrySize := 1 + sovCastvalue(uint64(k)) + 1 + l + sovCastvalue(uint64(l))
mapEntrySize := 1 + sovCastvalue(uint64(k)) + l
n += mapEntrySize + 1 + sovCastvalue(uint64(mapEntrySize))
}
}
@@ -951,28 +969,31 @@ func valueToStringCastvalue(v interface{}) string {
return fmt.Sprintf("*%v", pv)
}
func init() { proto.RegisterFile("combos/marshaler/castvalue.proto", fileDescriptorCastvalue) }
var fileDescriptorCastvalue = []byte{
// 337 bytes of a gzipped FileDescriptorProto
0x1f, 0x8b, 0x08, 0x00, 0x00, 0x09, 0x6e, 0x88, 0x02, 0xff, 0xe2, 0x52, 0x48, 0xce, 0xcf, 0x4d,
0xca, 0x2f, 0xd6, 0xcf, 0x4d, 0x2c, 0x2a, 0xce, 0x48, 0xcc, 0x49, 0x2d, 0xd2, 0x4f, 0x4e, 0x2c,
0x2e, 0x29, 0x4b, 0xcc, 0x29, 0x4d, 0xd5, 0x2b, 0x28, 0xca, 0x2f, 0xc9, 0x17, 0xe2, 0x84, 0x0b,
0x48, 0xe9, 0xa6, 0x67, 0x96, 0x64, 0x94, 0x26, 0xe9, 0x01, 0xf5, 0xe8, 0xa7, 0xe7, 0xa7, 0xe7,
0xeb, 0x83, 0x55, 0x24, 0x95, 0xa6, 0x81, 0x79, 0x60, 0x0e, 0x98, 0x05, 0xd1, 0xa9, 0x74, 0x90,
0x99, 0x8b, 0xc3, 0x19, 0xa8, 0x39, 0xb1, 0x3c, 0xb1, 0x52, 0xa8, 0x80, 0x4b, 0x18, 0xc4, 0xf6,
0x4d, 0x2c, 0x08, 0x03, 0x99, 0xe5, 0x9b, 0x5a, 0x5c, 0x9c, 0x98, 0x9e, 0x2a, 0xc1, 0xa8, 0xc0,
0xac, 0xc1, 0x6d, 0xa4, 0xa3, 0x87, 0xb0, 0x15, 0xa6, 0x43, 0x0f, 0x8b, 0x72, 0xd7, 0xbc, 0x92,
0xa2, 0x4a, 0x27, 0x81, 0x13, 0xf7, 0xe4, 0x19, 0xba, 0xee, 0xcb, 0x73, 0xf8, 0x56, 0x86, 0x67,
0xe6, 0x14, 0xe7, 0xe7, 0x05, 0x09, 0x27, 0x63, 0xaa, 0x15, 0x6a, 0x61, 0xe4, 0x92, 0xc6, 0x62,
0x86, 0x5f, 0x69, 0x4e, 0x4e, 0x62, 0x52, 0x4e, 0xaa, 0x04, 0x13, 0xd8, 0x6a, 0x13, 0x22, 0xad,
0x86, 0x69, 0x83, 0x38, 0x81, 0x07, 0xc5, 0x7a, 0xe9, 0x64, 0xdc, 0xea, 0xa5, 0x22, 0xb9, 0x24,
0x70, 0xf9, 0x44, 0x48, 0x80, 0x8b, 0x39, 0x3b, 0xb5, 0x12, 0x18, 0x08, 0x8c, 0x1a, 0xac, 0x41,
0x20, 0xa6, 0x90, 0x3a, 0x17, 0x2b, 0xd8, 0x2d, 0x40, 0xd7, 0x31, 0x02, 0x5d, 0x27, 0x88, 0xe4,
0x3a, 0xa8, 0x65, 0x10, 0x79, 0x2b, 0x26, 0x0b, 0x46, 0xa9, 0x44, 0x2e, 0x05, 0x42, 0x2e, 0xa5,
0xd0, 0x0a, 0x25, 0x39, 0x2e, 0x36, 0x88, 0xa0, 0x90, 0x08, 0x17, 0xab, 0x67, 0x5e, 0x89, 0x99,
0x09, 0xd8, 0x28, 0xe6, 0x20, 0xd6, 0x4c, 0x10, 0xc7, 0xc9, 0xe7, 0xc4, 0x43, 0x39, 0x86, 0x0b,
0x40, 0x7c, 0x03, 0x88, 0x1f, 0x3c, 0x94, 0x63, 0x7c, 0x01, 0xc4, 0x1f, 0x80, 0xf8, 0x07, 0x10,
0x37, 0x3c, 0x92, 0x63, 0x5c, 0x01, 0xc4, 0x1b, 0x80, 0x78, 0x07, 0x10, 0x1f, 0x00, 0xe2, 0x13,
0x40, 0x7c, 0xe1, 0x11, 0x50, 0x2d, 0x90, 0x7e, 0x01, 0xa4, 0x3f, 0x00, 0xe9, 0x1f, 0x40, 0xba,
0xe1, 0xb1, 0x1c, 0x03, 0x20, 0x00, 0x00, 0xff, 0xff, 0x15, 0xb6, 0x94, 0x56, 0x8e, 0x02, 0x00,
0x00,
// 358 bytes of a gzipped FileDescriptorProto
0x1f, 0x8b, 0x08, 0x00, 0x00, 0x09, 0x6e, 0x88, 0x02, 0xff, 0xa4, 0x8f, 0xbd, 0x4f, 0x2a, 0x41,
0x14, 0xc5, 0xe7, 0xb2, 0xe1, 0x85, 0x37, 0xbc, 0x82, 0xb7, 0xef, 0x15, 0x1b, 0x4c, 0x2e, 0x1b,
0x1a, 0x29, 0x74, 0x37, 0x21, 0xc4, 0x18, 0x4b, 0x8c, 0x85, 0x89, 0x58, 0x50, 0x68, 0x2c, 0x67,
0xc9, 0xba, 0x10, 0x17, 0x86, 0xec, 0x87, 0x66, 0x3b, 0x0a, 0x2b, 0xff, 0x12, 0x4b, 0x4b, 0x4b,
0xed, 0x28, 0x29, 0xad, 0x94, 0x19, 0x1b, 0x4a, 0x4a, 0x4a, 0xc3, 0xac, 0xf8, 0x91, 0xe0, 0x47,
0x62, 0x77, 0xef, 0x99, 0x7b, 0xce, 0xef, 0x0c, 0x35, 0x5b, 0xbc, 0xeb, 0xf0, 0xd0, 0xee, 0xb2,
0x20, 0x6c, 0x33, 0xdf, 0x0d, 0xec, 0x16, 0x0b, 0xa3, 0x53, 0xe6, 0xc7, 0xae, 0xd5, 0x0f, 0x78,
0xc4, 0xf5, 0xdf, 0x2f, 0x42, 0x71, 0xdd, 0xeb, 0x44, 0xed, 0xd8, 0xb1, 0x5a, 0xbc, 0x6b, 0x7b,
0xdc, 0xe3, 0xb6, 0xba, 0x70, 0xe2, 0x63, 0xb5, 0xa9, 0x45, 0x4d, 0xa9, 0xb3, 0x7c, 0xab, 0xd1,
0xdc, 0x36, 0x0b, 0x23, 0x76, 0xc6, 0x12, 0xbd, 0x4f, 0xff, 0xcd, 0xe7, 0x06, 0xeb, 0x1f, 0xcc,
0xb3, 0x1a, 0x6e, 0x18, 0x32, 0xcf, 0x35, 0xc0, 0xd4, 0x2a, 0xf9, 0xea, 0x9a, 0xf5, 0x4a, 0x5d,
0x38, 0xac, 0x25, 0xe7, 0x3b, 0xbd, 0x28, 0x48, 0xea, 0x85, 0xe1, 0x7d, 0x89, 0x5c, 0x3c, 0x94,
0x72, 0x8d, 0xe4, 0xb0, 0xe3, 0x87, 0xbc, 0xd7, 0x5c, 0x16, 0xad, 0x9f, 0x03, 0x5d, 0x59, 0xa2,
0xef, 0xc7, 0xbe, 0xcf, 0x1c, 0xdf, 0x35, 0x32, 0x0a, 0x5d, 0xfb, 0x26, 0x7a, 0x61, 0x4b, 0x2b,
0xfc, 0x79, 0x87, 0xff, 0x0c, 0x53, 0x3c, 0xa2, 0xc6, 0x47, 0x3f, 0xd1, 0x0b, 0x54, 0x3b, 0x71,
0x13, 0x03, 0x4c, 0xa8, 0x64, 0x9b, 0xf3, 0x51, 0x5f, 0xa5, 0x59, 0xd5, 0xc5, 0xc8, 0x98, 0x50,
0xc9, 0x57, 0xff, 0xbe, 0x69, 0xf7, 0x0c, 0x4b, 0xdf, 0xb7, 0x32, 0x9b, 0x50, 0x64, 0xd4, 0xfc,
0xaa, 0xe9, 0x0f, 0x11, 0x65, 0xa4, 0xbf, 0x52, 0x51, 0xff, 0x4f, 0xb3, 0xbb, 0xbd, 0x68, 0xa3,
0xa6, 0xa2, 0xb4, 0x66, 0xba, 0xd4, 0xf7, 0x86, 0x02, 0xc9, 0x48, 0x20, 0xb9, 0x13, 0x48, 0xc6,
0x02, 0x61, 0x22, 0x10, 0xa6, 0x02, 0x61, 0x26, 0x10, 0x06, 0x12, 0xe1, 0x52, 0x22, 0x5c, 0x49,
0x84, 0x6b, 0x89, 0x70, 0x23, 0x11, 0x86, 0x12, 0x61, 0x24, 0x91, 0x8c, 0x25, 0xc2, 0x44, 0x22,
0x99, 0x4a, 0x84, 0x99, 0x44, 0x32, 0x78, 0x44, 0xf2, 0x14, 0x00, 0x00, 0xff, 0xff, 0xc3, 0x22,
0x8c, 0x46, 0x8e, 0x02, 0x00, 0x00,
}

66
vendor/github.com/gogo/protobuf/test/castvalue/combos/marshaler/castvalue.proto generated vendored Normal file
View File

@@ -0,0 +1,66 @@
// Protocol Buffers for Go with Gadgets
//
// Copyright (c) 2015, 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.
syntax = "proto2";
package castvalue;
import "github.com/gogo/protobuf/gogoproto/gogo.proto";
option (gogoproto.goproto_stringer_all) = false;
option (gogoproto.goproto_enum_prefix_all) = false;
option (gogoproto.goproto_getters_all) = false;
option (gogoproto.equal_all) = true;
option (gogoproto.verbose_equal_all) = true;
option (gogoproto.stringer_all) = true;
option (gogoproto.gostring_all) = true;
option (gogoproto.face_all) = true;
option (gogoproto.description_all) = true;
option (gogoproto.testgen_all) = true;
option (gogoproto.populate_all) = true;
option (gogoproto.benchgen_all) = true;
option (gogoproto.unmarshaler_all) = false;
option (gogoproto.marshaler_all) = true;
option (gogoproto.sizer_all) = true;
option (gogoproto.goproto_enum_stringer_all) = false;
option (gogoproto.enum_stringer_all) = true;
option (gogoproto.unsafe_marshaler_all) = false;
option (gogoproto.unsafe_unmarshaler_all) = false;
message Castaway {
map<int32,Wilson> CastMapValueMessage = 1 [(gogoproto.castvalue) = "MyWilson", (gogoproto.nullable) = false];
map<int32,Wilson> CastMapValueMessageNullable = 2 [(gogoproto.castvalue) = "MyWilson"];
}
message Wilson {
optional int64 Int64 = 1;
}

513
vendor/github.com/gogo/protobuf/test/castvalue/combos/marshaler/castvaluepb_test.go generated vendored Normal file
View File

@@ -0,0 +1,513 @@
// Code generated by protoc-gen-gogo.
// source: combos/marshaler/castvalue.proto
// DO NOT EDIT!
/*
Package castvalue is a generated protocol buffer package.
It is generated from these files:
combos/marshaler/castvalue.proto
It has these top-level messages:
Castaway
Wilson
*/
package castvalue
import testing "testing"
import math_rand "math/rand"
import time "time"
import github_com_gogo_protobuf_proto "github.com/gogo/protobuf/proto"
import github_com_gogo_protobuf_jsonpb "github.com/gogo/protobuf/jsonpb"
import fmt "fmt"
import go_parser "go/parser"
import proto "github.com/gogo/protobuf/proto"
import math "math"
import _ "github.com/gogo/protobuf/gogoproto"
// Reference imports to suppress errors if they are not otherwise used.
var _ = proto.Marshal
var _ = fmt.Errorf
var _ = math.Inf
func TestCastawayProto(t *testing.T) {
seed := time.Now().UnixNano()
popr := math_rand.New(math_rand.NewSource(seed))
p := NewPopulatedCastaway(popr, false)
dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
if err != nil {
t.Fatalf("seed = %d, err = %v", seed, err)
}
msg := &Castaway{}
if err := github_com_gogo_protobuf_proto.Unmarshal(dAtA, msg); err != nil {
t.Fatalf("seed = %d, err = %v", seed, err)
}
littlefuzz := make([]byte, len(dAtA))
copy(littlefuzz, dAtA)
for i := range dAtA {
dAtA[i] = byte(popr.Intn(256))
}
if err := p.VerboseEqual(msg); err != nil {
t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
}
if !p.Equal(msg) {
t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p)
}
if len(littlefuzz) > 0 {
fuzzamount := 100
for i := 0; i < fuzzamount; i++ {
littlefuzz[popr.Intn(len(littlefuzz))] = byte(popr.Intn(256))
littlefuzz = append(littlefuzz, byte(popr.Intn(256)))
}
// shouldn't panic
_ = github_com_gogo_protobuf_proto.Unmarshal(littlefuzz, msg)
}
}
func TestCastawayMarshalTo(t *testing.T) {
seed := time.Now().UnixNano()
popr := math_rand.New(math_rand.NewSource(seed))
p := NewPopulatedCastaway(popr, false)
size := p.Size()
dAtA := make([]byte, size)
for i := range dAtA {
dAtA[i] = byte(popr.Intn(256))
}
_, err := p.MarshalTo(dAtA)
if err != nil {
t.Fatalf("seed = %d, err = %v", seed, err)
}
msg := &Castaway{}
if err := github_com_gogo_protobuf_proto.Unmarshal(dAtA, msg); err != nil {
t.Fatalf("seed = %d, err = %v", seed, err)
}
for i := range dAtA {
dAtA[i] = byte(popr.Intn(256))
}
if err := p.VerboseEqual(msg); err != nil {
t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
}
if !p.Equal(msg) {
t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p)
}
}
func BenchmarkCastawayProtoMarshal(b *testing.B) {
popr := math_rand.New(math_rand.NewSource(616))
total := 0
pops := make([]*Castaway, 10000)
for i := 0; i < 10000; i++ {
pops[i] = NewPopulatedCastaway(popr, false)
}
b.ResetTimer()
for i := 0; i < b.N; i++ {
dAtA, err := github_com_gogo_protobuf_proto.Marshal(pops[i%10000])
if err != nil {
panic(err)
}
total += len(dAtA)
}
b.SetBytes(int64(total / b.N))
}
func BenchmarkCastawayProtoUnmarshal(b *testing.B) {
popr := math_rand.New(math_rand.NewSource(616))
total := 0
datas := make([][]byte, 10000)
for i := 0; i < 10000; i++ {
dAtA, err := github_com_gogo_protobuf_proto.Marshal(NewPopulatedCastaway(popr, false))
if err != nil {
panic(err)
}
datas[i] = dAtA
}
msg := &Castaway{}
b.ResetTimer()
for i := 0; i < b.N; i++ {
total += len(datas[i%10000])
if err := github_com_gogo_protobuf_proto.Unmarshal(datas[i%10000], msg); err != nil {
panic(err)
}
}
b.SetBytes(int64(total / b.N))
}
func TestWilsonProto(t *testing.T) {
seed := time.Now().UnixNano()
popr := math_rand.New(math_rand.NewSource(seed))
p := NewPopulatedWilson(popr, false)
dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
if err != nil {
t.Fatalf("seed = %d, err = %v", seed, err)
}
msg := &Wilson{}
if err := github_com_gogo_protobuf_proto.Unmarshal(dAtA, msg); err != nil {
t.Fatalf("seed = %d, err = %v", seed, err)
}
littlefuzz := make([]byte, len(dAtA))
copy(littlefuzz, dAtA)
for i := range dAtA {
dAtA[i] = byte(popr.Intn(256))
}
if err := p.VerboseEqual(msg); err != nil {
t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
}
if !p.Equal(msg) {
t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p)
}
if len(littlefuzz) > 0 {
fuzzamount := 100
for i := 0; i < fuzzamount; i++ {
littlefuzz[popr.Intn(len(littlefuzz))] = byte(popr.Intn(256))
littlefuzz = append(littlefuzz, byte(popr.Intn(256)))
}
// shouldn't panic
_ = github_com_gogo_protobuf_proto.Unmarshal(littlefuzz, msg)
}
}
func TestWilsonMarshalTo(t *testing.T) {
seed := time.Now().UnixNano()
popr := math_rand.New(math_rand.NewSource(seed))
p := NewPopulatedWilson(popr, false)
size := p.Size()
dAtA := make([]byte, size)
for i := range dAtA {
dAtA[i] = byte(popr.Intn(256))
}
_, err := p.MarshalTo(dAtA)
if err != nil {
t.Fatalf("seed = %d, err = %v", seed, err)
}
msg := &Wilson{}
if err := github_com_gogo_protobuf_proto.Unmarshal(dAtA, msg); err != nil {
t.Fatalf("seed = %d, err = %v", seed, err)
}
for i := range dAtA {
dAtA[i] = byte(popr.Intn(256))
}
if err := p.VerboseEqual(msg); err != nil {
t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
}
if !p.Equal(msg) {
t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p)
}
}
func BenchmarkWilsonProtoMarshal(b *testing.B) {
popr := math_rand.New(math_rand.NewSource(616))
total := 0
pops := make([]*Wilson, 10000)
for i := 0; i < 10000; i++ {
pops[i] = NewPopulatedWilson(popr, false)
}
b.ResetTimer()
for i := 0; i < b.N; i++ {
dAtA, err := github_com_gogo_protobuf_proto.Marshal(pops[i%10000])
if err != nil {
panic(err)
}
total += len(dAtA)
}
b.SetBytes(int64(total / b.N))
}
func BenchmarkWilsonProtoUnmarshal(b *testing.B) {
popr := math_rand.New(math_rand.NewSource(616))
total := 0
datas := make([][]byte, 10000)
for i := 0; i < 10000; i++ {
dAtA, err := github_com_gogo_protobuf_proto.Marshal(NewPopulatedWilson(popr, false))
if err != nil {
panic(err)
}
datas[i] = dAtA
}
msg := &Wilson{}
b.ResetTimer()
for i := 0; i < b.N; i++ {
total += len(datas[i%10000])
if err := github_com_gogo_protobuf_proto.Unmarshal(datas[i%10000], msg); err != nil {
panic(err)
}
}
b.SetBytes(int64(total / b.N))
}
func TestCastawayJSON(t *testing.T) {
seed := time.Now().UnixNano()
popr := math_rand.New(math_rand.NewSource(seed))
p := NewPopulatedCastaway(popr, true)
marshaler := github_com_gogo_protobuf_jsonpb.Marshaler{}
jsondata, err := marshaler.MarshalToString(p)
if err != nil {
t.Fatalf("seed = %d, err = %v", seed, err)
}
msg := &Castaway{}
err = github_com_gogo_protobuf_jsonpb.UnmarshalString(jsondata, msg)
if err != nil {
t.Fatalf("seed = %d, err = %v", seed, err)
}
if err := p.VerboseEqual(msg); err != nil {
t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
}
if !p.Equal(msg) {
t.Fatalf("seed = %d, %#v !Json Equal %#v", seed, msg, p)
}
}
func TestWilsonJSON(t *testing.T) {
seed := time.Now().UnixNano()
popr := math_rand.New(math_rand.NewSource(seed))
p := NewPopulatedWilson(popr, true)
marshaler := github_com_gogo_protobuf_jsonpb.Marshaler{}
jsondata, err := marshaler.MarshalToString(p)
if err != nil {
t.Fatalf("seed = %d, err = %v", seed, err)
}
msg := &Wilson{}
err = github_com_gogo_protobuf_jsonpb.UnmarshalString(jsondata, msg)
if err != nil {
t.Fatalf("seed = %d, err = %v", seed, err)
}
if err := p.VerboseEqual(msg); err != nil {
t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
}
if !p.Equal(msg) {
t.Fatalf("seed = %d, %#v !Json Equal %#v", seed, msg, p)
}
}
func TestCastawayProtoText(t *testing.T) {
seed := time.Now().UnixNano()
popr := math_rand.New(math_rand.NewSource(seed))
p := NewPopulatedCastaway(popr, true)
dAtA := github_com_gogo_protobuf_proto.MarshalTextString(p)
msg := &Castaway{}
if err := github_com_gogo_protobuf_proto.UnmarshalText(dAtA, msg); err != nil {
t.Fatalf("seed = %d, err = %v", seed, err)
}
if err := p.VerboseEqual(msg); err != nil {
t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
}
if !p.Equal(msg) {
t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p)
}
}
func TestCastawayProtoCompactText(t *testing.T) {
seed := time.Now().UnixNano()
popr := math_rand.New(math_rand.NewSource(seed))
p := NewPopulatedCastaway(popr, true)
dAtA := github_com_gogo_protobuf_proto.CompactTextString(p)
msg := &Castaway{}
if err := github_com_gogo_protobuf_proto.UnmarshalText(dAtA, msg); err != nil {
t.Fatalf("seed = %d, err = %v", seed, err)
}
if err := p.VerboseEqual(msg); err != nil {
t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
}
if !p.Equal(msg) {
t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p)
}
}
func TestWilsonProtoText(t *testing.T) {
seed := time.Now().UnixNano()
popr := math_rand.New(math_rand.NewSource(seed))
p := NewPopulatedWilson(popr, true)
dAtA := github_com_gogo_protobuf_proto.MarshalTextString(p)
msg := &Wilson{}
if err := github_com_gogo_protobuf_proto.UnmarshalText(dAtA, msg); err != nil {
t.Fatalf("seed = %d, err = %v", seed, err)
}
if err := p.VerboseEqual(msg); err != nil {
t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
}
if !p.Equal(msg) {
t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p)
}
}
func TestWilsonProtoCompactText(t *testing.T) {
seed := time.Now().UnixNano()
popr := math_rand.New(math_rand.NewSource(seed))
p := NewPopulatedWilson(popr, true)
dAtA := github_com_gogo_protobuf_proto.CompactTextString(p)
msg := &Wilson{}
if err := github_com_gogo_protobuf_proto.UnmarshalText(dAtA, msg); err != nil {
t.Fatalf("seed = %d, err = %v", seed, err)
}
if err := p.VerboseEqual(msg); err != nil {
t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
}
if !p.Equal(msg) {
t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p)
}
}
func TestCastvalueDescription(t *testing.T) {
CastvalueDescription()
}
func TestCastawayVerboseEqual(t *testing.T) {
popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
p := NewPopulatedCastaway(popr, false)
dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
if err != nil {
panic(err)
}
msg := &Castaway{}
if err := github_com_gogo_protobuf_proto.Unmarshal(dAtA, msg); err != nil {
panic(err)
}
if err := p.VerboseEqual(msg); err != nil {
t.Fatalf("%#v !VerboseEqual %#v, since %v", msg, p, err)
}
}
func TestWilsonVerboseEqual(t *testing.T) {
popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
p := NewPopulatedWilson(popr, false)
dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
if err != nil {
panic(err)
}
msg := &Wilson{}
if err := github_com_gogo_protobuf_proto.Unmarshal(dAtA, msg); err != nil {
panic(err)
}
if err := p.VerboseEqual(msg); err != nil {
t.Fatalf("%#v !VerboseEqual %#v, since %v", msg, p, err)
}
}
func TestCastawayFace(t *testing.T) {
popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
p := NewPopulatedCastaway(popr, true)
msg := p.TestProto()
if !p.Equal(msg) {
t.Fatalf("%#v !Face Equal %#v", msg, p)
}
}
func TestWilsonFace(t *testing.T) {
popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
p := NewPopulatedWilson(popr, true)
msg := p.TestProto()
if !p.Equal(msg) {
t.Fatalf("%#v !Face Equal %#v", msg, p)
}
}
func TestCastawayGoString(t *testing.T) {
popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
p := NewPopulatedCastaway(popr, false)
s1 := p.GoString()
s2 := fmt.Sprintf("%#v", p)
if s1 != s2 {
t.Fatalf("GoString want %v got %v", s1, s2)
}
_, err := go_parser.ParseExpr(s1)
if err != nil {
panic(err)
}
}
func TestWilsonGoString(t *testing.T) {
popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
p := NewPopulatedWilson(popr, false)
s1 := p.GoString()
s2 := fmt.Sprintf("%#v", p)
if s1 != s2 {
t.Fatalf("GoString want %v got %v", s1, s2)
}
_, err := go_parser.ParseExpr(s1)
if err != nil {
panic(err)
}
}
func TestCastawaySize(t *testing.T) {
seed := time.Now().UnixNano()
popr := math_rand.New(math_rand.NewSource(seed))
p := NewPopulatedCastaway(popr, true)
size2 := github_com_gogo_protobuf_proto.Size(p)
dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
if err != nil {
t.Fatalf("seed = %d, err = %v", seed, err)
}
size := p.Size()
if len(dAtA) != size {
t.Errorf("seed = %d, size %v != marshalled size %v", seed, size, len(dAtA))
}
if size2 != size {
t.Errorf("seed = %d, size %v != before marshal proto.Size %v", seed, size, size2)
}
size3 := github_com_gogo_protobuf_proto.Size(p)
if size3 != size {
t.Errorf("seed = %d, size %v != after marshal proto.Size %v", seed, size, size3)
}
}
func BenchmarkCastawaySize(b *testing.B) {
popr := math_rand.New(math_rand.NewSource(616))
total := 0
pops := make([]*Castaway, 1000)
for i := 0; i < 1000; i++ {
pops[i] = NewPopulatedCastaway(popr, false)
}
b.ResetTimer()
for i := 0; i < b.N; i++ {
total += pops[i%1000].Size()
}
b.SetBytes(int64(total / b.N))
}
func TestWilsonSize(t *testing.T) {
seed := time.Now().UnixNano()
popr := math_rand.New(math_rand.NewSource(seed))
p := NewPopulatedWilson(popr, true)
size2 := github_com_gogo_protobuf_proto.Size(p)
dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
if err != nil {
t.Fatalf("seed = %d, err = %v", seed, err)
}
size := p.Size()
if len(dAtA) != size {
t.Errorf("seed = %d, size %v != marshalled size %v", seed, size, len(dAtA))
}
if size2 != size {
t.Errorf("seed = %d, size %v != before marshal proto.Size %v", seed, size, size2)
}
size3 := github_com_gogo_protobuf_proto.Size(p)
if size3 != size {
t.Errorf("seed = %d, size %v != after marshal proto.Size %v", seed, size, size3)
}
}
func BenchmarkWilsonSize(b *testing.B) {
popr := math_rand.New(math_rand.NewSource(616))
total := 0
pops := make([]*Wilson, 1000)
for i := 0; i < 1000; i++ {
pops[i] = NewPopulatedWilson(popr, false)
}
b.ResetTimer()
for i := 0; i < b.N; i++ {
total += pops[i%1000].Size()
}
b.SetBytes(int64(total / b.N))
}
func TestCastawayStringer(t *testing.T) {
popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
p := NewPopulatedCastaway(popr, false)
s1 := p.String()
s2 := fmt.Sprintf("%v", p)
if s1 != s2 {
t.Fatalf("String want %v got %v", s1, s2)
}
}
func TestWilsonStringer(t *testing.T) {
popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
p := NewPopulatedWilson(popr, false)
s1 := p.String()
s2 := fmt.Sprintf("%v", p)
if s1 != s2 {
t.Fatalf("String want %v got %v", s1, s2)
}
}
//These tests are generated by github.com/gogo/protobuf/plugin/testgen

6
vendor/github.com/gogo/protobuf/test/castvalue/combos/marshaler/mytypes.go generated vendored
View File

@@ -1,7 +1,7 @@
// Extensions for Protocol Buffers to create more go like structures.
// Protocol Buffers for Go with Gadgets
//
// Copyright (c) 2013, Vastech SA (PTY) LTD. All rights reserved.
// http://github.com/gogo/protobuf/gogoproto
// 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

792
vendor/github.com/gogo/protobuf/test/castvalue/combos/unmarshaler/castvalue.pb.go generated vendored
View File

File diff suppressed because it is too large Load Diff

66
vendor/github.com/gogo/protobuf/test/castvalue/combos/unmarshaler/castvalue.proto generated vendored Normal file
View File

@@ -0,0 +1,66 @@
// Protocol Buffers for Go with Gadgets
//
// Copyright (c) 2015, 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.
syntax = "proto2";
package castvalue;
import "github.com/gogo/protobuf/gogoproto/gogo.proto";
option (gogoproto.goproto_stringer_all) = false;
option (gogoproto.goproto_enum_prefix_all) = false;
option (gogoproto.goproto_getters_all) = false;
option (gogoproto.equal_all) = true;
option (gogoproto.verbose_equal_all) = true;
option (gogoproto.stringer_all) = true;
option (gogoproto.gostring_all) = true;
option (gogoproto.face_all) = true;
option (gogoproto.description_all) = true;
option (gogoproto.testgen_all) = true;
option (gogoproto.populate_all) = true;
option (gogoproto.benchgen_all) = true;
option (gogoproto.unmarshaler_all) = true;
option (gogoproto.marshaler_all) = false;
option (gogoproto.sizer_all) = true;
option (gogoproto.goproto_enum_stringer_all) = false;
option (gogoproto.enum_stringer_all) = true;
option (gogoproto.unsafe_marshaler_all) = false;
option (gogoproto.unsafe_unmarshaler_all) = false;
message Castaway {
map<int32,Wilson> CastMapValueMessage = 1 [(gogoproto.castvalue) = "MyWilson", (gogoproto.nullable) = false];
map<int32,Wilson> CastMapValueMessageNullable = 2 [(gogoproto.castvalue) = "MyWilson"];
}
message Wilson {
optional int64 Int64 = 1;
}

457
vendor/github.com/gogo/protobuf/test/castvalue/combos/unmarshaler/castvaluepb_test.go generated vendored Normal file
View File

@@ -0,0 +1,457 @@
// Code generated by protoc-gen-gogo.
// source: combos/unmarshaler/castvalue.proto
// DO NOT EDIT!
/*
Package castvalue is a generated protocol buffer package.
It is generated from these files:
combos/unmarshaler/castvalue.proto
It has these top-level messages:
Castaway
Wilson
*/
package castvalue
import testing "testing"
import math_rand "math/rand"
import time "time"
import github_com_gogo_protobuf_proto "github.com/gogo/protobuf/proto"
import github_com_gogo_protobuf_jsonpb "github.com/gogo/protobuf/jsonpb"
import fmt "fmt"
import go_parser "go/parser"
import proto "github.com/gogo/protobuf/proto"
import math "math"
import _ "github.com/gogo/protobuf/gogoproto"
// Reference imports to suppress errors if they are not otherwise used.
var _ = proto.Marshal
var _ = fmt.Errorf
var _ = math.Inf
func TestCastawayProto(t *testing.T) {
seed := time.Now().UnixNano()
popr := math_rand.New(math_rand.NewSource(seed))
p := NewPopulatedCastaway(popr, false)
dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
if err != nil {
t.Fatalf("seed = %d, err = %v", seed, err)
}
msg := &Castaway{}
if err := github_com_gogo_protobuf_proto.Unmarshal(dAtA, msg); err != nil {
t.Fatalf("seed = %d, err = %v", seed, err)
}
littlefuzz := make([]byte, len(dAtA))
copy(littlefuzz, dAtA)
for i := range dAtA {
dAtA[i] = byte(popr.Intn(256))
}
if err := p.VerboseEqual(msg); err != nil {
t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
}
if !p.Equal(msg) {
t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p)
}
if len(littlefuzz) > 0 {
fuzzamount := 100
for i := 0; i < fuzzamount; i++ {
littlefuzz[popr.Intn(len(littlefuzz))] = byte(popr.Intn(256))
littlefuzz = append(littlefuzz, byte(popr.Intn(256)))
}
// shouldn't panic
_ = github_com_gogo_protobuf_proto.Unmarshal(littlefuzz, msg)
}
}
func BenchmarkCastawayProtoMarshal(b *testing.B) {
popr := math_rand.New(math_rand.NewSource(616))
total := 0
pops := make([]*Castaway, 10000)
for i := 0; i < 10000; i++ {
pops[i] = NewPopulatedCastaway(popr, false)
}
b.ResetTimer()
for i := 0; i < b.N; i++ {
dAtA, err := github_com_gogo_protobuf_proto.Marshal(pops[i%10000])
if err != nil {
panic(err)
}
total += len(dAtA)
}
b.SetBytes(int64(total / b.N))
}
func BenchmarkCastawayProtoUnmarshal(b *testing.B) {
popr := math_rand.New(math_rand.NewSource(616))
total := 0
datas := make([][]byte, 10000)
for i := 0; i < 10000; i++ {
dAtA, err := github_com_gogo_protobuf_proto.Marshal(NewPopulatedCastaway(popr, false))
if err != nil {
panic(err)
}
datas[i] = dAtA
}
msg := &Castaway{}
b.ResetTimer()
for i := 0; i < b.N; i++ {
total += len(datas[i%10000])
if err := github_com_gogo_protobuf_proto.Unmarshal(datas[i%10000], msg); err != nil {
panic(err)
}
}
b.SetBytes(int64(total / b.N))
}
func TestWilsonProto(t *testing.T) {
seed := time.Now().UnixNano()
popr := math_rand.New(math_rand.NewSource(seed))
p := NewPopulatedWilson(popr, false)
dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
if err != nil {
t.Fatalf("seed = %d, err = %v", seed, err)
}
msg := &Wilson{}
if err := github_com_gogo_protobuf_proto.Unmarshal(dAtA, msg); err != nil {
t.Fatalf("seed = %d, err = %v", seed, err)
}
littlefuzz := make([]byte, len(dAtA))
copy(littlefuzz, dAtA)
for i := range dAtA {
dAtA[i] = byte(popr.Intn(256))
}
if err := p.VerboseEqual(msg); err != nil {
t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
}
if !p.Equal(msg) {
t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p)
}
if len(littlefuzz) > 0 {
fuzzamount := 100
for i := 0; i < fuzzamount; i++ {
littlefuzz[popr.Intn(len(littlefuzz))] = byte(popr.Intn(256))
littlefuzz = append(littlefuzz, byte(popr.Intn(256)))
}
// shouldn't panic
_ = github_com_gogo_protobuf_proto.Unmarshal(littlefuzz, msg)
}
}
func BenchmarkWilsonProtoMarshal(b *testing.B) {
popr := math_rand.New(math_rand.NewSource(616))
total := 0
pops := make([]*Wilson, 10000)
for i := 0; i < 10000; i++ {
pops[i] = NewPopulatedWilson(popr, false)
}
b.ResetTimer()
for i := 0; i < b.N; i++ {
dAtA, err := github_com_gogo_protobuf_proto.Marshal(pops[i%10000])
if err != nil {
panic(err)
}
total += len(dAtA)
}
b.SetBytes(int64(total / b.N))
}
func BenchmarkWilsonProtoUnmarshal(b *testing.B) {
popr := math_rand.New(math_rand.NewSource(616))
total := 0
datas := make([][]byte, 10000)
for i := 0; i < 10000; i++ {
dAtA, err := github_com_gogo_protobuf_proto.Marshal(NewPopulatedWilson(popr, false))
if err != nil {
panic(err)
}
datas[i] = dAtA
}
msg := &Wilson{}
b.ResetTimer()
for i := 0; i < b.N; i++ {
total += len(datas[i%10000])
if err := github_com_gogo_protobuf_proto.Unmarshal(datas[i%10000], msg); err != nil {
panic(err)
}
}
b.SetBytes(int64(total / b.N))
}
func TestCastawayJSON(t *testing.T) {
seed := time.Now().UnixNano()
popr := math_rand.New(math_rand.NewSource(seed))
p := NewPopulatedCastaway(popr, true)
marshaler := github_com_gogo_protobuf_jsonpb.Marshaler{}
jsondata, err := marshaler.MarshalToString(p)
if err != nil {
t.Fatalf("seed = %d, err = %v", seed, err)
}
msg := &Castaway{}
err = github_com_gogo_protobuf_jsonpb.UnmarshalString(jsondata, msg)
if err != nil {
t.Fatalf("seed = %d, err = %v", seed, err)
}
if err := p.VerboseEqual(msg); err != nil {
t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
}
if !p.Equal(msg) {
t.Fatalf("seed = %d, %#v !Json Equal %#v", seed, msg, p)
}
}
func TestWilsonJSON(t *testing.T) {
seed := time.Now().UnixNano()
popr := math_rand.New(math_rand.NewSource(seed))
p := NewPopulatedWilson(popr, true)
marshaler := github_com_gogo_protobuf_jsonpb.Marshaler{}
jsondata, err := marshaler.MarshalToString(p)
if err != nil {
t.Fatalf("seed = %d, err = %v", seed, err)
}
msg := &Wilson{}
err = github_com_gogo_protobuf_jsonpb.UnmarshalString(jsondata, msg)
if err != nil {
t.Fatalf("seed = %d, err = %v", seed, err)
}
if err := p.VerboseEqual(msg); err != nil {
t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
}
if !p.Equal(msg) {
t.Fatalf("seed = %d, %#v !Json Equal %#v", seed, msg, p)
}
}
func TestCastawayProtoText(t *testing.T) {
seed := time.Now().UnixNano()
popr := math_rand.New(math_rand.NewSource(seed))
p := NewPopulatedCastaway(popr, true)
dAtA := github_com_gogo_protobuf_proto.MarshalTextString(p)
msg := &Castaway{}
if err := github_com_gogo_protobuf_proto.UnmarshalText(dAtA, msg); err != nil {
t.Fatalf("seed = %d, err = %v", seed, err)
}
if err := p.VerboseEqual(msg); err != nil {
t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
}
if !p.Equal(msg) {
t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p)
}
}
func TestCastawayProtoCompactText(t *testing.T) {
seed := time.Now().UnixNano()
popr := math_rand.New(math_rand.NewSource(seed))
p := NewPopulatedCastaway(popr, true)
dAtA := github_com_gogo_protobuf_proto.CompactTextString(p)
msg := &Castaway{}
if err := github_com_gogo_protobuf_proto.UnmarshalText(dAtA, msg); err != nil {
t.Fatalf("seed = %d, err = %v", seed, err)
}
if err := p.VerboseEqual(msg); err != nil {
t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
}
if !p.Equal(msg) {
t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p)
}
}
func TestWilsonProtoText(t *testing.T) {
seed := time.Now().UnixNano()
popr := math_rand.New(math_rand.NewSource(seed))
p := NewPopulatedWilson(popr, true)
dAtA := github_com_gogo_protobuf_proto.MarshalTextString(p)
msg := &Wilson{}
if err := github_com_gogo_protobuf_proto.UnmarshalText(dAtA, msg); err != nil {
t.Fatalf("seed = %d, err = %v", seed, err)
}
if err := p.VerboseEqual(msg); err != nil {
t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
}
if !p.Equal(msg) {
t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p)
}
}
func TestWilsonProtoCompactText(t *testing.T) {
seed := time.Now().UnixNano()
popr := math_rand.New(math_rand.NewSource(seed))
p := NewPopulatedWilson(popr, true)
dAtA := github_com_gogo_protobuf_proto.CompactTextString(p)
msg := &Wilson{}
if err := github_com_gogo_protobuf_proto.UnmarshalText(dAtA, msg); err != nil {
t.Fatalf("seed = %d, err = %v", seed, err)
}
if err := p.VerboseEqual(msg); err != nil {
t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
}
if !p.Equal(msg) {
t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p)
}
}
func TestCastvalueDescription(t *testing.T) {
CastvalueDescription()
}
func TestCastawayVerboseEqual(t *testing.T) {
popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
p := NewPopulatedCastaway(popr, false)
dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
if err != nil {
panic(err)
}
msg := &Castaway{}
if err := github_com_gogo_protobuf_proto.Unmarshal(dAtA, msg); err != nil {
panic(err)
}
if err := p.VerboseEqual(msg); err != nil {
t.Fatalf("%#v !VerboseEqual %#v, since %v", msg, p, err)
}
}
func TestWilsonVerboseEqual(t *testing.T) {
popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
p := NewPopulatedWilson(popr, false)
dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
if err != nil {
panic(err)
}
msg := &Wilson{}
if err := github_com_gogo_protobuf_proto.Unmarshal(dAtA, msg); err != nil {
panic(err)
}
if err := p.VerboseEqual(msg); err != nil {
t.Fatalf("%#v !VerboseEqual %#v, since %v", msg, p, err)
}
}
func TestCastawayFace(t *testing.T) {
popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
p := NewPopulatedCastaway(popr, true)
msg := p.TestProto()
if !p.Equal(msg) {
t.Fatalf("%#v !Face Equal %#v", msg, p)
}
}
func TestWilsonFace(t *testing.T) {
popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
p := NewPopulatedWilson(popr, true)
msg := p.TestProto()
if !p.Equal(msg) {
t.Fatalf("%#v !Face Equal %#v", msg, p)
}
}
func TestCastawayGoString(t *testing.T) {
popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
p := NewPopulatedCastaway(popr, false)
s1 := p.GoString()
s2 := fmt.Sprintf("%#v", p)
if s1 != s2 {
t.Fatalf("GoString want %v got %v", s1, s2)
}
_, err := go_parser.ParseExpr(s1)
if err != nil {
panic(err)
}
}
func TestWilsonGoString(t *testing.T) {
popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
p := NewPopulatedWilson(popr, false)
s1 := p.GoString()
s2 := fmt.Sprintf("%#v", p)
if s1 != s2 {
t.Fatalf("GoString want %v got %v", s1, s2)
}
_, err := go_parser.ParseExpr(s1)
if err != nil {
panic(err)
}
}
func TestCastawaySize(t *testing.T) {
seed := time.Now().UnixNano()
popr := math_rand.New(math_rand.NewSource(seed))
p := NewPopulatedCastaway(popr, true)
size2 := github_com_gogo_protobuf_proto.Size(p)
dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
if err != nil {
t.Fatalf("seed = %d, err = %v", seed, err)
}
size := p.Size()
if len(dAtA) != size {
t.Errorf("seed = %d, size %v != marshalled size %v", seed, size, len(dAtA))
}
if size2 != size {
t.Errorf("seed = %d, size %v != before marshal proto.Size %v", seed, size, size2)
}
size3 := github_com_gogo_protobuf_proto.Size(p)
if size3 != size {
t.Errorf("seed = %d, size %v != after marshal proto.Size %v", seed, size, size3)
}
}
func BenchmarkCastawaySize(b *testing.B) {
popr := math_rand.New(math_rand.NewSource(616))
total := 0
pops := make([]*Castaway, 1000)
for i := 0; i < 1000; i++ {
pops[i] = NewPopulatedCastaway(popr, false)
}
b.ResetTimer()
for i := 0; i < b.N; i++ {
total += pops[i%1000].Size()
}
b.SetBytes(int64(total / b.N))
}
func TestWilsonSize(t *testing.T) {
seed := time.Now().UnixNano()
popr := math_rand.New(math_rand.NewSource(seed))
p := NewPopulatedWilson(popr, true)
size2 := github_com_gogo_protobuf_proto.Size(p)
dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
if err != nil {
t.Fatalf("seed = %d, err = %v", seed, err)
}
size := p.Size()
if len(dAtA) != size {
t.Errorf("seed = %d, size %v != marshalled size %v", seed, size, len(dAtA))
}
if size2 != size {
t.Errorf("seed = %d, size %v != before marshal proto.Size %v", seed, size, size2)
}
size3 := github_com_gogo_protobuf_proto.Size(p)
if size3 != size {
t.Errorf("seed = %d, size %v != after marshal proto.Size %v", seed, size, size3)
}
}
func BenchmarkWilsonSize(b *testing.B) {
popr := math_rand.New(math_rand.NewSource(616))
total := 0
pops := make([]*Wilson, 1000)
for i := 0; i < 1000; i++ {
pops[i] = NewPopulatedWilson(popr, false)
}
b.ResetTimer()
for i := 0; i < b.N; i++ {
total += pops[i%1000].Size()
}
b.SetBytes(int64(total / b.N))
}
func TestCastawayStringer(t *testing.T) {
popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
p := NewPopulatedCastaway(popr, false)
s1 := p.String()
s2 := fmt.Sprintf("%v", p)
if s1 != s2 {
t.Fatalf("String want %v got %v", s1, s2)
}
}
func TestWilsonStringer(t *testing.T) {
popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
p := NewPopulatedWilson(popr, false)
s1 := p.String()
s2 := fmt.Sprintf("%v", p)
if s1 != s2 {
t.Fatalf("String want %v got %v", s1, s2)
}
}
//These tests are generated by github.com/gogo/protobuf/plugin/testgen

6
vendor/github.com/gogo/protobuf/test/castvalue/combos/unmarshaler/mytypes.go generated vendored
View File

@@ -1,7 +1,7 @@
// Extensions for Protocol Buffers to create more go like structures.
// Protocol Buffers for Go with Gadgets
//
// Copyright (c) 2013, Vastech SA (PTY) LTD. All rights reserved.
// http://github.com/gogo/protobuf/gogoproto
// 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

911
vendor/github.com/gogo/protobuf/test/castvalue/combos/unsafeboth/castvalue.pb.go generated vendored
View File

File diff suppressed because it is too large Load Diff

66
vendor/github.com/gogo/protobuf/test/castvalue/combos/unsafeboth/castvalue.proto generated vendored Normal file
View File

@@ -0,0 +1,66 @@
// Protocol Buffers for Go with Gadgets
//
// Copyright (c) 2015, 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.
syntax = "proto2";
package castvalue;
import "github.com/gogo/protobuf/gogoproto/gogo.proto";
option (gogoproto.goproto_stringer_all) = false;
option (gogoproto.goproto_enum_prefix_all) = false;
option (gogoproto.goproto_getters_all) = false;
option (gogoproto.equal_all) = true;
option (gogoproto.verbose_equal_all) = true;
option (gogoproto.stringer_all) = true;
option (gogoproto.gostring_all) = true;
option (gogoproto.face_all) = true;
option (gogoproto.description_all) = true;
option (gogoproto.testgen_all) = true;
option (gogoproto.populate_all) = true;
option (gogoproto.benchgen_all) = true;
option (gogoproto.unmarshaler_all) = false;
option (gogoproto.marshaler_all) = false;
option (gogoproto.sizer_all) = true;
option (gogoproto.goproto_enum_stringer_all) = false;
option (gogoproto.enum_stringer_all) = true;
option (gogoproto.unsafe_marshaler_all) = true;
option (gogoproto.unsafe_unmarshaler_all) = true;
message Castaway {
map<int32,Wilson> CastMapValueMessage = 1 [(gogoproto.castvalue) = "MyWilson", (gogoproto.nullable) = false];
map<int32,Wilson> CastMapValueMessageNullable = 2 [(gogoproto.castvalue) = "MyWilson"];
}
message Wilson {
optional int64 Int64 = 1;
}

513
vendor/github.com/gogo/protobuf/test/castvalue/combos/unsafeboth/castvaluepb_test.go generated vendored Normal file
View File

@@ -0,0 +1,513 @@
// Code generated by protoc-gen-gogo.
// source: combos/unsafeboth/castvalue.proto
// DO NOT EDIT!
/*
Package castvalue is a generated protocol buffer package.
It is generated from these files:
combos/unsafeboth/castvalue.proto
It has these top-level messages:
Castaway
Wilson
*/
package castvalue
import testing "testing"
import math_rand "math/rand"
import time "time"
import github_com_gogo_protobuf_proto "github.com/gogo/protobuf/proto"
import github_com_gogo_protobuf_jsonpb "github.com/gogo/protobuf/jsonpb"
import fmt "fmt"
import go_parser "go/parser"
import proto "github.com/gogo/protobuf/proto"
import math "math"
import _ "github.com/gogo/protobuf/gogoproto"
// Reference imports to suppress errors if they are not otherwise used.
var _ = proto.Marshal
var _ = fmt.Errorf
var _ = math.Inf
func TestCastawayProto(t *testing.T) {
seed := time.Now().UnixNano()
popr := math_rand.New(math_rand.NewSource(seed))
p := NewPopulatedCastaway(popr, false)
dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
if err != nil {
t.Fatalf("seed = %d, err = %v", seed, err)
}
msg := &Castaway{}
if err := github_com_gogo_protobuf_proto.Unmarshal(dAtA, msg); err != nil {
t.Fatalf("seed = %d, err = %v", seed, err)
}
littlefuzz := make([]byte, len(dAtA))
copy(littlefuzz, dAtA)
for i := range dAtA {
dAtA[i] = byte(popr.Intn(256))
}
if err := p.VerboseEqual(msg); err != nil {
t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
}
if !p.Equal(msg) {
t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p)
}
if len(littlefuzz) > 0 {
fuzzamount := 100
for i := 0; i < fuzzamount; i++ {
littlefuzz[popr.Intn(len(littlefuzz))] = byte(popr.Intn(256))
littlefuzz = append(littlefuzz, byte(popr.Intn(256)))
}
// shouldn't panic
_ = github_com_gogo_protobuf_proto.Unmarshal(littlefuzz, msg)
}
}
func TestCastawayMarshalTo(t *testing.T) {
seed := time.Now().UnixNano()
popr := math_rand.New(math_rand.NewSource(seed))
p := NewPopulatedCastaway(popr, false)
size := p.Size()
dAtA := make([]byte, size)
for i := range dAtA {
dAtA[i] = byte(popr.Intn(256))
}
_, err := p.MarshalTo(dAtA)
if err != nil {
t.Fatalf("seed = %d, err = %v", seed, err)
}
msg := &Castaway{}
if err := github_com_gogo_protobuf_proto.Unmarshal(dAtA, msg); err != nil {
t.Fatalf("seed = %d, err = %v", seed, err)
}
for i := range dAtA {
dAtA[i] = byte(popr.Intn(256))
}
if err := p.VerboseEqual(msg); err != nil {
t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
}
if !p.Equal(msg) {
t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p)
}
}
func BenchmarkCastawayProtoMarshal(b *testing.B) {
popr := math_rand.New(math_rand.NewSource(616))
total := 0
pops := make([]*Castaway, 10000)
for i := 0; i < 10000; i++ {
pops[i] = NewPopulatedCastaway(popr, false)
}
b.ResetTimer()
for i := 0; i < b.N; i++ {
dAtA, err := github_com_gogo_protobuf_proto.Marshal(pops[i%10000])
if err != nil {
panic(err)
}
total += len(dAtA)
}
b.SetBytes(int64(total / b.N))
}
func BenchmarkCastawayProtoUnmarshal(b *testing.B) {
popr := math_rand.New(math_rand.NewSource(616))
total := 0
datas := make([][]byte, 10000)
for i := 0; i < 10000; i++ {
dAtA, err := github_com_gogo_protobuf_proto.Marshal(NewPopulatedCastaway(popr, false))
if err != nil {
panic(err)
}
datas[i] = dAtA
}
msg := &Castaway{}
b.ResetTimer()
for i := 0; i < b.N; i++ {
total += len(datas[i%10000])
if err := github_com_gogo_protobuf_proto.Unmarshal(datas[i%10000], msg); err != nil {
panic(err)
}
}
b.SetBytes(int64(total / b.N))
}
func TestWilsonProto(t *testing.T) {
seed := time.Now().UnixNano()
popr := math_rand.New(math_rand.NewSource(seed))
p := NewPopulatedWilson(popr, false)
dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
if err != nil {
t.Fatalf("seed = %d, err = %v", seed, err)
}
msg := &Wilson{}
if err := github_com_gogo_protobuf_proto.Unmarshal(dAtA, msg); err != nil {
t.Fatalf("seed = %d, err = %v", seed, err)
}
littlefuzz := make([]byte, len(dAtA))
copy(littlefuzz, dAtA)
for i := range dAtA {
dAtA[i] = byte(popr.Intn(256))
}
if err := p.VerboseEqual(msg); err != nil {
t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
}
if !p.Equal(msg) {
t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p)
}
if len(littlefuzz) > 0 {
fuzzamount := 100
for i := 0; i < fuzzamount; i++ {
littlefuzz[popr.Intn(len(littlefuzz))] = byte(popr.Intn(256))
littlefuzz = append(littlefuzz, byte(popr.Intn(256)))
}
// shouldn't panic
_ = github_com_gogo_protobuf_proto.Unmarshal(littlefuzz, msg)
}
}
func TestWilsonMarshalTo(t *testing.T) {
seed := time.Now().UnixNano()
popr := math_rand.New(math_rand.NewSource(seed))
p := NewPopulatedWilson(popr, false)
size := p.Size()
dAtA := make([]byte, size)
for i := range dAtA {
dAtA[i] = byte(popr.Intn(256))
}
_, err := p.MarshalTo(dAtA)
if err != nil {
t.Fatalf("seed = %d, err = %v", seed, err)
}
msg := &Wilson{}
if err := github_com_gogo_protobuf_proto.Unmarshal(dAtA, msg); err != nil {
t.Fatalf("seed = %d, err = %v", seed, err)
}
for i := range dAtA {
dAtA[i] = byte(popr.Intn(256))
}
if err := p.VerboseEqual(msg); err != nil {
t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
}
if !p.Equal(msg) {
t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p)
}
}
func BenchmarkWilsonProtoMarshal(b *testing.B) {
popr := math_rand.New(math_rand.NewSource(616))
total := 0
pops := make([]*Wilson, 10000)
for i := 0; i < 10000; i++ {
pops[i] = NewPopulatedWilson(popr, false)
}
b.ResetTimer()
for i := 0; i < b.N; i++ {
dAtA, err := github_com_gogo_protobuf_proto.Marshal(pops[i%10000])
if err != nil {
panic(err)
}
total += len(dAtA)
}
b.SetBytes(int64(total / b.N))
}
func BenchmarkWilsonProtoUnmarshal(b *testing.B) {
popr := math_rand.New(math_rand.NewSource(616))
total := 0
datas := make([][]byte, 10000)
for i := 0; i < 10000; i++ {
dAtA, err := github_com_gogo_protobuf_proto.Marshal(NewPopulatedWilson(popr, false))
if err != nil {
panic(err)
}
datas[i] = dAtA
}
msg := &Wilson{}
b.ResetTimer()
for i := 0; i < b.N; i++ {
total += len(datas[i%10000])
if err := github_com_gogo_protobuf_proto.Unmarshal(datas[i%10000], msg); err != nil {
panic(err)
}
}
b.SetBytes(int64(total / b.N))
}
func TestCastawayJSON(t *testing.T) {
seed := time.Now().UnixNano()
popr := math_rand.New(math_rand.NewSource(seed))
p := NewPopulatedCastaway(popr, true)
marshaler := github_com_gogo_protobuf_jsonpb.Marshaler{}
jsondata, err := marshaler.MarshalToString(p)
if err != nil {
t.Fatalf("seed = %d, err = %v", seed, err)
}
msg := &Castaway{}
err = github_com_gogo_protobuf_jsonpb.UnmarshalString(jsondata, msg)
if err != nil {
t.Fatalf("seed = %d, err = %v", seed, err)
}
if err := p.VerboseEqual(msg); err != nil {
t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
}
if !p.Equal(msg) {
t.Fatalf("seed = %d, %#v !Json Equal %#v", seed, msg, p)
}
}
func TestWilsonJSON(t *testing.T) {
seed := time.Now().UnixNano()
popr := math_rand.New(math_rand.NewSource(seed))
p := NewPopulatedWilson(popr, true)
marshaler := github_com_gogo_protobuf_jsonpb.Marshaler{}
jsondata, err := marshaler.MarshalToString(p)
if err != nil {
t.Fatalf("seed = %d, err = %v", seed, err)
}
msg := &Wilson{}
err = github_com_gogo_protobuf_jsonpb.UnmarshalString(jsondata, msg)
if err != nil {
t.Fatalf("seed = %d, err = %v", seed, err)
}
if err := p.VerboseEqual(msg); err != nil {
t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
}
if !p.Equal(msg) {
t.Fatalf("seed = %d, %#v !Json Equal %#v", seed, msg, p)
}
}
func TestCastawayProtoText(t *testing.T) {
seed := time.Now().UnixNano()
popr := math_rand.New(math_rand.NewSource(seed))
p := NewPopulatedCastaway(popr, true)
dAtA := github_com_gogo_protobuf_proto.MarshalTextString(p)
msg := &Castaway{}
if err := github_com_gogo_protobuf_proto.UnmarshalText(dAtA, msg); err != nil {
t.Fatalf("seed = %d, err = %v", seed, err)
}
if err := p.VerboseEqual(msg); err != nil {
t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
}
if !p.Equal(msg) {
t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p)
}
}
func TestCastawayProtoCompactText(t *testing.T) {
seed := time.Now().UnixNano()
popr := math_rand.New(math_rand.NewSource(seed))
p := NewPopulatedCastaway(popr, true)
dAtA := github_com_gogo_protobuf_proto.CompactTextString(p)
msg := &Castaway{}
if err := github_com_gogo_protobuf_proto.UnmarshalText(dAtA, msg); err != nil {
t.Fatalf("seed = %d, err = %v", seed, err)
}
if err := p.VerboseEqual(msg); err != nil {
t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
}
if !p.Equal(msg) {
t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p)
}
}
func TestWilsonProtoText(t *testing.T) {
seed := time.Now().UnixNano()
popr := math_rand.New(math_rand.NewSource(seed))
p := NewPopulatedWilson(popr, true)
dAtA := github_com_gogo_protobuf_proto.MarshalTextString(p)
msg := &Wilson{}
if err := github_com_gogo_protobuf_proto.UnmarshalText(dAtA, msg); err != nil {
t.Fatalf("seed = %d, err = %v", seed, err)
}
if err := p.VerboseEqual(msg); err != nil {
t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
}
if !p.Equal(msg) {
t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p)
}
}
func TestWilsonProtoCompactText(t *testing.T) {
seed := time.Now().UnixNano()
popr := math_rand.New(math_rand.NewSource(seed))
p := NewPopulatedWilson(popr, true)
dAtA := github_com_gogo_protobuf_proto.CompactTextString(p)
msg := &Wilson{}
if err := github_com_gogo_protobuf_proto.UnmarshalText(dAtA, msg); err != nil {
t.Fatalf("seed = %d, err = %v", seed, err)
}
if err := p.VerboseEqual(msg); err != nil {
t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
}
if !p.Equal(msg) {
t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p)
}
}
func TestCastvalueDescription(t *testing.T) {
CastvalueDescription()
}
func TestCastawayVerboseEqual(t *testing.T) {
popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
p := NewPopulatedCastaway(popr, false)
dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
if err != nil {
panic(err)
}
msg := &Castaway{}
if err := github_com_gogo_protobuf_proto.Unmarshal(dAtA, msg); err != nil {
panic(err)
}
if err := p.VerboseEqual(msg); err != nil {
t.Fatalf("%#v !VerboseEqual %#v, since %v", msg, p, err)
}
}
func TestWilsonVerboseEqual(t *testing.T) {
popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
p := NewPopulatedWilson(popr, false)
dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
if err != nil {
panic(err)
}
msg := &Wilson{}
if err := github_com_gogo_protobuf_proto.Unmarshal(dAtA, msg); err != nil {
panic(err)
}
if err := p.VerboseEqual(msg); err != nil {
t.Fatalf("%#v !VerboseEqual %#v, since %v", msg, p, err)
}
}
func TestCastawayFace(t *testing.T) {
popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
p := NewPopulatedCastaway(popr, true)
msg := p.TestProto()
if !p.Equal(msg) {
t.Fatalf("%#v !Face Equal %#v", msg, p)
}
}
func TestWilsonFace(t *testing.T) {
popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
p := NewPopulatedWilson(popr, true)
msg := p.TestProto()
if !p.Equal(msg) {
t.Fatalf("%#v !Face Equal %#v", msg, p)
}
}
func TestCastawayGoString(t *testing.T) {
popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
p := NewPopulatedCastaway(popr, false)
s1 := p.GoString()
s2 := fmt.Sprintf("%#v", p)
if s1 != s2 {
t.Fatalf("GoString want %v got %v", s1, s2)
}
_, err := go_parser.ParseExpr(s1)
if err != nil {
panic(err)
}
}
func TestWilsonGoString(t *testing.T) {
popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
p := NewPopulatedWilson(popr, false)
s1 := p.GoString()
s2 := fmt.Sprintf("%#v", p)
if s1 != s2 {
t.Fatalf("GoString want %v got %v", s1, s2)
}
_, err := go_parser.ParseExpr(s1)
if err != nil {
panic(err)
}
}
func TestCastawaySize(t *testing.T) {
seed := time.Now().UnixNano()
popr := math_rand.New(math_rand.NewSource(seed))
p := NewPopulatedCastaway(popr, true)
size2 := github_com_gogo_protobuf_proto.Size(p)
dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
if err != nil {
t.Fatalf("seed = %d, err = %v", seed, err)
}
size := p.Size()
if len(dAtA) != size {
t.Errorf("seed = %d, size %v != marshalled size %v", seed, size, len(dAtA))
}
if size2 != size {
t.Errorf("seed = %d, size %v != before marshal proto.Size %v", seed, size, size2)
}
size3 := github_com_gogo_protobuf_proto.Size(p)
if size3 != size {
t.Errorf("seed = %d, size %v != after marshal proto.Size %v", seed, size, size3)
}
}
func BenchmarkCastawaySize(b *testing.B) {
popr := math_rand.New(math_rand.NewSource(616))
total := 0
pops := make([]*Castaway, 1000)
for i := 0; i < 1000; i++ {
pops[i] = NewPopulatedCastaway(popr, false)
}
b.ResetTimer()
for i := 0; i < b.N; i++ {
total += pops[i%1000].Size()
}
b.SetBytes(int64(total / b.N))
}
func TestWilsonSize(t *testing.T) {
seed := time.Now().UnixNano()
popr := math_rand.New(math_rand.NewSource(seed))
p := NewPopulatedWilson(popr, true)
size2 := github_com_gogo_protobuf_proto.Size(p)
dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
if err != nil {
t.Fatalf("seed = %d, err = %v", seed, err)
}
size := p.Size()
if len(dAtA) != size {
t.Errorf("seed = %d, size %v != marshalled size %v", seed, size, len(dAtA))
}
if size2 != size {
t.Errorf("seed = %d, size %v != before marshal proto.Size %v", seed, size, size2)
}
size3 := github_com_gogo_protobuf_proto.Size(p)
if size3 != size {
t.Errorf("seed = %d, size %v != after marshal proto.Size %v", seed, size, size3)
}
}
func BenchmarkWilsonSize(b *testing.B) {
popr := math_rand.New(math_rand.NewSource(616))
total := 0
pops := make([]*Wilson, 1000)
for i := 0; i < 1000; i++ {
pops[i] = NewPopulatedWilson(popr, false)
}
b.ResetTimer()
for i := 0; i < b.N; i++ {
total += pops[i%1000].Size()
}
b.SetBytes(int64(total / b.N))
}
func TestCastawayStringer(t *testing.T) {
popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
p := NewPopulatedCastaway(popr, false)
s1 := p.String()
s2 := fmt.Sprintf("%v", p)
if s1 != s2 {
t.Fatalf("String want %v got %v", s1, s2)
}
}
func TestWilsonStringer(t *testing.T) {
popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
p := NewPopulatedWilson(popr, false)
s1 := p.String()
s2 := fmt.Sprintf("%v", p)
if s1 != s2 {
t.Fatalf("String want %v got %v", s1, s2)
}
}
//These tests are generated by github.com/gogo/protobuf/plugin/testgen

6
vendor/github.com/gogo/protobuf/test/castvalue/combos/unsafeboth/mytypes.go generated vendored
View File

@@ -1,7 +1,7 @@
// Extensions for Protocol Buffers to create more go like structures.
// Protocol Buffers for Go with Gadgets
//
// Copyright (c) 2013, Vastech SA (PTY) LTD. All rights reserved.
// http://github.com/gogo/protobuf/gogoproto
// 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

669
vendor/github.com/gogo/protobuf/test/castvalue/combos/unsafemarshaler/castvalue.pb.go generated vendored
View File

@@ -31,8 +31,6 @@ import strconv "strconv"
import reflect "reflect"
import github_com_gogo_protobuf_sortkeys "github.com/gogo/protobuf/sortkeys"
import errors "errors"
// Reference imports to suppress errors if they are not otherwise used.
var _ = proto.Marshal
var _ = fmt.Errorf
@@ -40,11 +38,13 @@ 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.
const _ = proto.GoGoProtoPackageIsVersion1
// 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 Castaway struct {
CastMapValueMessage map[int32]MyWilson `protobuf:"bytes,1,rep,name=CastMapValueMessage,json=castMapValueMessage,castvalue=MyWilson,castvaluetype=castvalue.Wilson" json:"CastMapValueMessage" protobuf_key:"varint,1,opt,name=key" protobuf_val:"bytes,2,opt,name=value"`
CastMapValueMessageNullable map[int32]*MyWilson `protobuf:"bytes,2,rep,name=CastMapValueMessageNullable,json=castMapValueMessageNullable,castvalue=MyWilson,castvaluetype=castvalue.Wilson" json:"CastMapValueMessageNullable,omitempty" protobuf_key:"varint,1,opt,name=key" protobuf_val:"bytes,2,opt,name=value"`
CastMapValueMessage map[int32]MyWilson `protobuf:"bytes,1,rep,name=CastMapValueMessage,castvalue=MyWilson,castvaluetype=castvalue.Wilson" json:"CastMapValueMessage" protobuf_key:"varint,1,opt,name=key" protobuf_val:"bytes,2,opt,name=value"`
CastMapValueMessageNullable map[int32]*MyWilson `protobuf:"bytes,2,rep,name=CastMapValueMessageNullable,castvalue=MyWilson,castvaluetype=castvalue.Wilson" json:"CastMapValueMessageNullable,omitempty" protobuf_key:"varint,1,opt,name=key" protobuf_val:"bytes,2,opt,name=value"`
XXX_unrecognized []byte `json:"-"`
}
@@ -53,7 +53,7 @@ func (*Castaway) ProtoMessage() {}
func (*Castaway) Descriptor() ([]byte, []int) { return fileDescriptorCastvalue, []int{0} }
type Wilson struct {
Int64 *int64 `protobuf:"varint,1,opt,name=Int64,json=int64" json:"Int64,omitempty"`
Int64 *int64 `protobuf:"varint,1,opt,name=Int64" json:"Int64,omitempty"`
XXX_unrecognized []byte `json:"-"`
}
@@ -74,224 +74,233 @@ func (this *Wilson) Description() (desc *github_com_gogo_protobuf_protoc_gen_gog
func CastvalueDescription() (desc *github_com_gogo_protobuf_protoc_gen_gogo_descriptor.FileDescriptorSet) {
d := &github_com_gogo_protobuf_protoc_gen_gogo_descriptor.FileDescriptorSet{}
var gzipped = []byte{
// 3472 bytes of a gzipped FileDescriptorSet
0x1f, 0x8b, 0x08, 0x00, 0x00, 0x09, 0x6e, 0x88, 0x02, 0xff, 0xcc, 0x5a, 0x6b, 0x6c, 0x23, 0xd5,
0xf5, 0x5f, 0xc7, 0x76, 0x62, 0x1f, 0x3b, 0x8e, 0x33, 0x09, 0xbb, 0xde, 0x2c, 0x6c, 0x76, 0xcd,
0x63, 0x97, 0x05, 0x12, 0xfe, 0xfb, 0xe7, 0xb1, 0x98, 0xff, 0x1f, 0x94, 0x87, 0x37, 0x78, 0x95,
0x57, 0x27, 0x09, 0xec, 0xd2, 0x0f, 0xa3, 0xc9, 0xf8, 0xc6, 0xf1, 0xee, 0x78, 0xc6, 0xf5, 0x8c,
0x77, 0x37, 0x7c, 0xa2, 0x82, 0xb6, 0xa2, 0x55, 0xdf, 0x48, 0xe5, 0xdd, 0x82, 0xd4, 0x42, 0xe9,
0x0b, 0xfa, 0x52, 0xd5, 0x4f, 0x54, 0x15, 0x2d, 0x9f, 0xaa, 0xb6, 0x9f, 0xfa, 0xa1, 0x6a, 0x81,
0x22, 0x95, 0xb6, 0xb4, 0xa5, 0xd2, 0x4a, 0x45, 0xe2, 0x4b, 0xcf, 0x7d, 0x8d, 0x67, 0x6c, 0x27,
0xe3, 0x50, 0x51, 0x1a, 0x69, 0x94, 0x99, 0x73, 0xcf, 0xef, 0x37, 0xf7, 0x9e, 0x7b, 0xee, 0x39,
0xe7, 0xde, 0x31, 0xfc, 0xf4, 0x7f, 0xe0, 0x50, 0xc5, 0xb6, 0x2b, 0x26, 0x99, 0xac, 0x37, 0x6c,
0xd7, 0x5e, 0x6f, 0x6e, 0x4c, 0x96, 0x89, 0x63, 0x34, 0xaa, 0x75, 0xd7, 0x6e, 0x4c, 0x30, 0x99,
0x32, 0xc4, 0x35, 0x26, 0xa4, 0x46, 0x7e, 0x01, 0x86, 0x4f, 0x56, 0x4d, 0x32, 0xeb, 0x29, 0xae,
0x10, 0x57, 0x39, 0x01, 0xb1, 0x0d, 0x14, 0xe6, 0x22, 0x87, 0xa2, 0x47, 0x53, 0xc7, 0xaf, 0x9a,
0x68, 0x03, 0x4d, 0x04, 0x11, 0xcb, 0x54, 0xac, 0x32, 0x44, 0xfe, 0x8d, 0x18, 0x8c, 0x74, 0x69,
0x55, 0x14, 0x88, 0x59, 0x7a, 0x8d, 0x32, 0x46, 0x8e, 0x26, 0x55, 0x76, 0xaf, 0xe4, 0x60, 0xa0,
0xae, 0x1b, 0xe7, 0xf4, 0x0a, 0xc9, 0xf5, 0x31, 0xb1, 0x7c, 0x54, 0x0e, 0x02, 0x94, 0x49, 0x9d,
0x58, 0x65, 0x62, 0x19, 0x5b, 0xb9, 0x28, 0xf6, 0x22, 0xa9, 0xfa, 0x24, 0xca, 0x75, 0x30, 0x5c,
0x6f, 0xae, 0x9b, 0x55, 0x43, 0xf3, 0xa9, 0x01, 0xaa, 0xc5, 0xd5, 0x2c, 0x6f, 0x98, 0x6d, 0x29,
0x1f, 0x81, 0xa1, 0x0b, 0x44, 0x3f, 0xe7, 0x57, 0x4d, 0x31, 0xd5, 0x0c, 0x15, 0xfb, 0x14, 0x67,
0x20, 0x5d, 0x23, 0x8e, 0x83, 0x1d, 0xd0, 0xdc, 0xad, 0x3a, 0xc9, 0xc5, 0xd8, 0xe8, 0x0f, 0x75,
0x8c, 0xbe, 0x7d, 0xe4, 0x29, 0x81, 0x5a, 0x45, 0x90, 0x32, 0x05, 0x49, 0x62, 0x35, 0x6b, 0x9c,
0x21, 0xbe, 0x8d, 0xfd, 0x8a, 0xa8, 0xd1, 0xce, 0x92, 0xa0, 0x30, 0x41, 0x31, 0xe0, 0x90, 0xc6,
0xf9, 0xaa, 0x41, 0x72, 0xfd, 0x8c, 0xe0, 0x48, 0x07, 0xc1, 0x0a, 0x6f, 0x6f, 0xe7, 0x90, 0x38,
0x1c, 0x4a, 0x92, 0x5c, 0x74, 0x89, 0xe5, 0x54, 0x6d, 0x2b, 0x37, 0xc0, 0x48, 0xae, 0xee, 0x32,
0x8b, 0xc4, 0x2c, 0xb7, 0x53, 0xb4, 0x70, 0xca, 0x2d, 0x30, 0x60, 0xd7, 0x5d, 0xbc, 0x73, 0x72,
0x09, 0x9c, 0x9f, 0xd4, 0xf1, 0xcb, 0xbb, 0x3a, 0xc2, 0x12, 0xd7, 0x51, 0xa5, 0xb2, 0x52, 0x82,
0xac, 0x63, 0x37, 0x1b, 0x06, 0xd1, 0x0c, 0xbb, 0x4c, 0xb4, 0xaa, 0xb5, 0x61, 0xe7, 0x92, 0x8c,
0x60, 0xbc, 0x73, 0x20, 0x4c, 0x71, 0x06, 0xf5, 0x4a, 0xa8, 0xa6, 0x66, 0x9c, 0xc0, 0xb3, 0xb2,
0x17, 0xfa, 0x9d, 0x2d, 0xcb, 0xd5, 0x2f, 0xe6, 0xd2, 0xcc, 0x43, 0xc4, 0x53, 0xfe, 0x9f, 0x71,
0x18, 0xea, 0xc5, 0xc5, 0x6e, 0x87, 0xf8, 0x06, 0x1d, 0x25, 0x3a, 0xd8, 0x2e, 0x6c, 0xc0, 0x31,
0x41, 0x23, 0xf6, 0xbf, 0x47, 0x23, 0x4e, 0x41, 0xca, 0x22, 0x8e, 0x4b, 0xca, 0xdc, 0x23, 0xa2,
0x3d, 0xfa, 0x14, 0x70, 0x50, 0xa7, 0x4b, 0xc5, 0xde, 0x93, 0x4b, 0x9d, 0x86, 0x21, 0xaf, 0x4b,
0x5a, 0x43, 0xb7, 0x2a, 0xd2, 0x37, 0x27, 0xc3, 0x7a, 0x32, 0x51, 0x94, 0x38, 0x95, 0xc2, 0xd4,
0x0c, 0x09, 0x3c, 0x2b, 0xb3, 0x00, 0xb6, 0x45, 0xec, 0x0d, 0x5c, 0x5e, 0x86, 0x89, 0x7e, 0xd2,
0xdd, 0x4a, 0x4b, 0x54, 0xa5, 0xc3, 0x4a, 0x36, 0x97, 0x1a, 0xa6, 0x72, 0x5b, 0xcb, 0xd5, 0x06,
0xb6, 0xf1, 0x94, 0x05, 0xbe, 0xc8, 0x3a, 0xbc, 0x6d, 0x0d, 0x32, 0x0d, 0x42, 0xfd, 0x1e, 0x4d,
0xcc, 0x47, 0x96, 0x64, 0x9d, 0x98, 0x08, 0x1d, 0x99, 0x2a, 0x60, 0x7c, 0x60, 0x83, 0x0d, 0xff,
0xa3, 0x72, 0x25, 0x78, 0x02, 0x8d, 0xb9, 0x15, 0xb0, 0x28, 0x94, 0x96, 0xc2, 0x45, 0x94, 0x8d,
0x9d, 0x80, 0x4c, 0xd0, 0x3c, 0xca, 0x28, 0xc4, 0x1d, 0x57, 0x6f, 0xb8, 0xcc, 0x0b, 0xe3, 0x2a,
0x7f, 0x50, 0xb2, 0x10, 0xc5, 0x20, 0xc3, 0xa2, 0x5c, 0x5c, 0xa5, 0xb7, 0x63, 0xb7, 0xc2, 0x60,
0xe0, 0xf5, 0xbd, 0x02, 0xf3, 0x8f, 0xf4, 0xc3, 0x68, 0x37, 0x9f, 0xeb, 0xea, 0xfe, 0xb8, 0x7c,
0xd0, 0x03, 0xd6, 0x49, 0x03, 0xfd, 0x8e, 0x32, 0x88, 0x27, 0xf4, 0xa8, 0xb8, 0xa9, 0xaf, 0x13,
0x13, 0xbd, 0x29, 0x72, 0x34, 0x73, 0xfc, 0xba, 0x9e, 0xbc, 0x7a, 0x62, 0x9e, 0x42, 0x54, 0x8e,
0x54, 0xee, 0x80, 0x98, 0x08, 0x71, 0x94, 0xe1, 0x58, 0x6f, 0x0c, 0xd4, 0x17, 0x55, 0x86, 0x53,
0x0e, 0x40, 0x92, 0xfe, 0xe7, 0xb6, 0xed, 0x67, 0x7d, 0x4e, 0x50, 0x01, 0xb5, 0xab, 0x32, 0x06,
0x09, 0xe6, 0x66, 0x65, 0x22, 0x53, 0x83, 0xf7, 0x4c, 0x27, 0xa6, 0x4c, 0x36, 0xf4, 0xa6, 0xe9,
0x6a, 0xe7, 0x75, 0xb3, 0x49, 0x98, 0xc3, 0xe0, 0xc4, 0x08, 0xe1, 0xdd, 0x54, 0xa6, 0x8c, 0x43,
0x8a, 0x7b, 0x65, 0x15, 0x31, 0x17, 0x59, 0xf4, 0x89, 0xab, 0xdc, 0x51, 0x4b, 0x54, 0x42, 0x5f,
0x7f, 0xd6, 0xc1, 0xb5, 0x20, 0xa6, 0x96, 0xbd, 0x82, 0x0a, 0xd8, 0xeb, 0x6f, 0x6d, 0x0f, 0x7c,
0x57, 0x74, 0x1f, 0x5e, 0xbb, 0x2f, 0xe6, 0x7f, 0xd8, 0x07, 0x31, 0xb6, 0xde, 0x86, 0x20, 0xb5,
0x7a, 0x66, 0xb9, 0xa8, 0xcd, 0x2e, 0xad, 0x4d, 0xcf, 0x17, 0xb3, 0x11, 0x25, 0x03, 0xc0, 0x04,
0x27, 0xe7, 0x97, 0xa6, 0x56, 0xb3, 0x7d, 0xde, 0x73, 0x69, 0x71, 0xf5, 0x96, 0x9b, 0xb2, 0x51,
0x0f, 0xb0, 0xc6, 0x05, 0x31, 0xbf, 0xc2, 0xff, 0x1e, 0xcf, 0xc6, 0xd1, 0x13, 0xd2, 0x9c, 0xa0,
0x74, 0xba, 0x38, 0x8b, 0x1a, 0xfd, 0x41, 0x09, 0xea, 0x0c, 0x28, 0x83, 0x90, 0x64, 0x92, 0xe9,
0xa5, 0xa5, 0xf9, 0x6c, 0xc2, 0xe3, 0x5c, 0x59, 0x55, 0x4b, 0x8b, 0x73, 0xd9, 0xa4, 0xc7, 0x39,
0xa7, 0x2e, 0xad, 0x2d, 0x67, 0xc1, 0x63, 0x58, 0x28, 0xae, 0xac, 0x4c, 0xcd, 0x15, 0xb3, 0x29,
0x4f, 0x63, 0xfa, 0xcc, 0x6a, 0x71, 0x25, 0x9b, 0x0e, 0x74, 0x0b, 0x5f, 0x31, 0xe8, 0xbd, 0xa2,
0xb8, 0xb8, 0xb6, 0x90, 0xcd, 0x28, 0xc3, 0x30, 0xc8, 0x5f, 0x21, 0x3b, 0x31, 0xd4, 0x26, 0xc2,
0x9e, 0x66, 0x5b, 0x1d, 0xe1, 0x2c, 0xc3, 0x01, 0x01, 0x6a, 0x28, 0xf9, 0x19, 0x88, 0x33, 0xef,
0x42, 0x2f, 0xce, 0xcc, 0x4f, 0x4d, 0x17, 0xe7, 0xb5, 0xa5, 0xe5, 0xd5, 0xd2, 0xd2, 0xe2, 0xd4,
0x3c, 0xda, 0xce, 0x93, 0xa9, 0xc5, 0x0f, 0xad, 0x95, 0xd4, 0xe2, 0x2c, 0xda, 0xcf, 0x27, 0x5b,
0x2e, 0x4e, 0xad, 0xa2, 0x2c, 0x9a, 0x3f, 0x06, 0xa3, 0xdd, 0xe2, 0x4c, 0xb7, 0x95, 0x91, 0x7f,
0x26, 0x02, 0x23, 0x5d, 0x42, 0x66, 0xd7, 0x55, 0x74, 0x27, 0xc4, 0xb9, 0xa7, 0xf1, 0x24, 0x72,
0x6d, 0xd7, 0xd8, 0xcb, 0xfc, 0xae, 0x23, 0x91, 0x30, 0x9c, 0x3f, 0x91, 0x46, 0xb7, 0x49, 0xa4,
0x94, 0xa2, 0xc3, 0x9d, 0x1e, 0x88, 0x40, 0x6e, 0x3b, 0xee, 0x90, 0xf5, 0xde, 0x17, 0x58, 0xef,
0xb7, 0xb7, 0x77, 0xe0, 0xf0, 0xf6, 0x63, 0xe8, 0xe8, 0xc5, 0xb3, 0x11, 0xd8, 0xdb, 0xbd, 0xde,
0xe8, 0xda, 0x87, 0x3b, 0xa0, 0xbf, 0x46, 0xdc, 0x4d, 0x5b, 0xe6, 0xdc, 0x6b, 0xba, 0x44, 0x72,
0xda, 0xdc, 0x6e, 0x2b, 0x81, 0xf2, 0xa7, 0x82, 0xe8, 0x76, 0x45, 0x03, 0xef, 0x4d, 0x47, 0x4f,
0x1f, 0xea, 0x83, 0xcb, 0xba, 0x92, 0x77, 0xed, 0xe8, 0x15, 0x00, 0x55, 0xab, 0xde, 0x74, 0x79,
0x5e, 0xe5, 0x61, 0x26, 0xc9, 0x24, 0x6c, 0x09, 0xd3, 0x10, 0xd2, 0x74, 0xbd, 0xf6, 0x28, 0x6b,
0x07, 0x2e, 0x62, 0x0a, 0x27, 0x5a, 0x1d, 0x8d, 0xb1, 0x8e, 0x1e, 0xdc, 0x66, 0xa4, 0x1d, 0x29,
0xeb, 0x46, 0xc8, 0x1a, 0x66, 0x95, 0x58, 0xae, 0xe6, 0xb8, 0x0d, 0xa2, 0xd7, 0xaa, 0x56, 0x85,
0xc5, 0xd1, 0x44, 0x21, 0xbe, 0xa1, 0x9b, 0x0e, 0x51, 0x87, 0x78, 0xf3, 0x8a, 0x6c, 0xa5, 0x08,
0x96, 0x2c, 0x1a, 0x3e, 0x44, 0x7f, 0x00, 0xc1, 0x9b, 0x3d, 0x44, 0xfe, 0xd7, 0x03, 0x90, 0xf2,
0x55, 0x67, 0xca, 0x61, 0x48, 0x9f, 0xd5, 0xcf, 0xeb, 0x9a, 0xac, 0xb8, 0xb9, 0x25, 0x52, 0x54,
0xb6, 0x2c, 0xaa, 0xee, 0x1b, 0x61, 0x94, 0xa9, 0xe0, 0x18, 0xf1, 0x45, 0x86, 0xa9, 0x3b, 0x0e,
0x33, 0x5a, 0x82, 0xa9, 0x2a, 0xb4, 0x6d, 0x89, 0x36, 0xcd, 0xc8, 0x16, 0xe5, 0x66, 0x18, 0x61,
0x88, 0x1a, 0x06, 0xde, 0x6a, 0xdd, 0x24, 0x1a, 0xdd, 0x03, 0x38, 0x2c, 0x9e, 0x7a, 0x3d, 0x1b,
0xa6, 0x1a, 0x0b, 0x42, 0x81, 0xf6, 0xc8, 0x51, 0xe6, 0xe0, 0x0a, 0x06, 0xab, 0x10, 0x8b, 0x34,
0x74, 0x97, 0x68, 0xe4, 0x23, 0x4d, 0xd4, 0xd5, 0x74, 0xab, 0xac, 0x6d, 0xea, 0xce, 0x66, 0x6e,
0xd4, 0x4f, 0xb0, 0x9f, 0xea, 0xce, 0x09, 0xd5, 0x22, 0xd3, 0x9c, 0xb2, 0xca, 0x77, 0xa1, 0x9e,
0x52, 0x80, 0xbd, 0x8c, 0x08, 0x8d, 0x82, 0x63, 0xd6, 0x8c, 0x4d, 0x62, 0x9c, 0xd3, 0x9a, 0xee,
0xc6, 0x89, 0xdc, 0x01, 0x3f, 0x03, 0xeb, 0xe4, 0x0a, 0xd3, 0x99, 0xa1, 0x2a, 0x6b, 0xa8, 0xa1,
0xac, 0x40, 0x9a, 0xce, 0x47, 0xad, 0x7a, 0x1f, 0x76, 0xdb, 0x6e, 0xb0, 0x1c, 0x91, 0xe9, 0xb2,
0xb8, 0x7d, 0x46, 0x9c, 0x58, 0x12, 0x80, 0x05, 0xac, 0x4f, 0x0b, 0xf1, 0x95, 0xe5, 0x62, 0x71,
0x56, 0x4d, 0x49, 0x96, 0x93, 0x76, 0x83, 0xfa, 0x54, 0xc5, 0xf6, 0x6c, 0x9c, 0xe2, 0x3e, 0x55,
0xb1, 0xa5, 0x85, 0xd1, 0x5e, 0x86, 0xc1, 0x87, 0x8d, 0x7b, 0x17, 0x51, 0xac, 0x3b, 0xb9, 0x6c,
0xc0, 0x5e, 0x86, 0x31, 0xc7, 0x15, 0x84, 0x9b, 0x3b, 0xb8, 0x24, 0x2e, 0x6b, 0xd9, 0xcb, 0x0f,
0x1c, 0xee, 0x18, 0x65, 0x3b, 0x14, 0xdf, 0x58, 0xdf, 0xea, 0x04, 0x2a, 0x81, 0x37, 0xd6, 0xb7,
0xda, 0x61, 0x57, 0xb3, 0x0d, 0x58, 0x83, 0x18, 0x68, 0xf2, 0x72, 0x6e, 0x9f, 0x5f, 0xdb, 0xd7,
0xa0, 0x4c, 0xa2, 0x23, 0x1b, 0x1a, 0xb1, 0xf4, 0x75, 0x9c, 0x7b, 0xbd, 0x81, 0x37, 0x4e, 0x6e,
0xdc, 0xaf, 0x9c, 0x31, 0x8c, 0x22, 0x6b, 0x9d, 0x62, 0x8d, 0xca, 0x31, 0x18, 0xb6, 0xd7, 0xcf,
0x1a, 0xdc, 0xb9, 0x34, 0xe4, 0xd9, 0xa8, 0x5e, 0xcc, 0x5d, 0xc5, 0xcc, 0x34, 0x44, 0x1b, 0x98,
0x6b, 0x2d, 0x33, 0xb1, 0x72, 0x2d, 0x92, 0x3b, 0x9b, 0x7a, 0xa3, 0xce, 0x92, 0xb4, 0x83, 0x46,
0x25, 0xb9, 0xab, 0xb9, 0x2a, 0x97, 0x2f, 0x4a, 0xb1, 0x52, 0x84, 0x71, 0x3a, 0x78, 0x4b, 0xb7,
0x6c, 0xad, 0xe9, 0x10, 0xad, 0xd5, 0x45, 0x6f, 0x2e, 0xae, 0xa1, 0xdd, 0x52, 0x2f, 0x97, 0x6a,
0x6b, 0x0e, 0x06, 0x33, 0xa9, 0x24, 0xa7, 0xe7, 0x34, 0x8c, 0x36, 0xad, 0xaa, 0x85, 0x2e, 0x8e,
0x2d, 0x14, 0xcc, 0x17, 0x6c, 0xee, 0x8f, 0x03, 0xdb, 0x14, 0xdd, 0x6b, 0x7e, 0x6d, 0xee, 0x24,
0xea, 0x48, 0xb3, 0x53, 0x98, 0x2f, 0x40, 0xda, 0xef, 0x3b, 0x4a, 0x12, 0xb8, 0xf7, 0x60, 0x76,
0xc3, 0x8c, 0x3a, 0xb3, 0x34, 0x4b, 0x73, 0xe1, 0xbd, 0x45, 0x4c, 0x6c, 0x98, 0x93, 0xe7, 0x4b,
0xab, 0x45, 0x4d, 0x5d, 0x5b, 0x5c, 0x2d, 0x2d, 0x14, 0xb3, 0xd1, 0x63, 0xc9, 0xc4, 0x9b, 0x03,
0xd9, 0xfb, 0xf1, 0xaf, 0x2f, 0xff, 0x72, 0x1f, 0x64, 0x82, 0x75, 0xb0, 0xf2, 0x7f, 0xb0, 0x4f,
0x6e, 0x5a, 0x1d, 0xe2, 0x6a, 0x17, 0xaa, 0x0d, 0xe6, 0xce, 0x35, 0x9d, 0x57, 0x92, 0xde, 0x4c,
0x8c, 0x0a, 0x2d, 0xdc, 0xde, 0xdf, 0x83, 0x3a, 0x27, 0x99, 0x8a, 0x32, 0x0f, 0xe3, 0x68, 0x32,
0xac, 0x35, 0xad, 0xb2, 0xde, 0x28, 0x6b, 0xad, 0xe3, 0x02, 0x4d, 0x37, 0xd0, 0x0f, 0x1c, 0x9b,
0x67, 0x12, 0x8f, 0xe5, 0x72, 0xcb, 0x5e, 0x11, 0xca, 0xad, 0x10, 0x3b, 0x25, 0x54, 0xdb, 0xbc,
0x26, 0xba, 0x9d, 0xd7, 0x60, 0xed, 0x55, 0xd3, 0xeb, 0xe8, 0x36, 0x6e, 0x63, 0x8b, 0x55, 0x6f,
0x09, 0x35, 0x81, 0x82, 0x22, 0x7d, 0x7e, 0xff, 0xe6, 0xc0, 0x6f, 0xc7, 0xdf, 0x46, 0x21, 0xed,
0xaf, 0xe0, 0x68, 0x41, 0x6c, 0xb0, 0x30, 0x1f, 0x61, 0x51, 0xe0, 0xca, 0x1d, 0xeb, 0xbd, 0x89,
0x19, 0x1a, 0xff, 0x0b, 0xfd, 0xbc, 0xae, 0x52, 0x39, 0x92, 0xe6, 0x5e, 0xea, 0x6b, 0x84, 0x57,
0xeb, 0x09, 0x55, 0x3c, 0x61, 0xb0, 0xeb, 0x3f, 0xeb, 0x30, 0xee, 0x7e, 0xc6, 0x7d, 0xd5, 0xce,
0xdc, 0xa7, 0x56, 0x18, 0x79, 0xf2, 0xd4, 0x8a, 0xb6, 0xb8, 0xa4, 0x2e, 0x4c, 0xcd, 0xab, 0x02,
0xae, 0xec, 0x87, 0x98, 0xa9, 0xdf, 0xb7, 0x15, 0xcc, 0x14, 0x4c, 0xd4, 0xab, 0xe1, 0x91, 0x81,
0x1e, 0x79, 0x04, 0xe3, 0x33, 0x13, 0xbd, 0x8f, 0xae, 0x3f, 0x09, 0x71, 0x66, 0x2f, 0x05, 0x40,
0x58, 0x2c, 0xbb, 0x47, 0x49, 0x40, 0x6c, 0x66, 0x49, 0xa5, 0xee, 0x8f, 0xfe, 0xce, 0xa5, 0xda,
0x72, 0xa9, 0x38, 0x83, 0x2b, 0x20, 0x7f, 0x33, 0xf4, 0x73, 0x23, 0xd0, 0xa5, 0xe1, 0x99, 0x01,
0x41, 0xfc, 0x51, 0x70, 0x44, 0x64, 0xeb, 0xda, 0xc2, 0x74, 0x51, 0xcd, 0xf6, 0xf9, 0xa7, 0xf7,
0xc7, 0x11, 0x48, 0xf9, 0x0a, 0x2a, 0x9a, 0xca, 0x75, 0xd3, 0xb4, 0x2f, 0x68, 0xba, 0x59, 0xc5,
0x08, 0xc5, 0xe7, 0x07, 0x98, 0x68, 0x8a, 0x4a, 0x7a, 0xb5, 0xdf, 0x7f, 0xc4, 0x37, 0x9f, 0x8a,
0x40, 0xb6, 0xbd, 0x18, 0x6b, 0xeb, 0x60, 0xe4, 0x03, 0xed, 0xe0, 0x13, 0x11, 0xc8, 0x04, 0x2b,
0xb0, 0xb6, 0xee, 0x1d, 0xfe, 0x40, 0xbb, 0xf7, 0x78, 0x04, 0x06, 0x03, 0x75, 0xd7, 0x7f, 0x55,
0xef, 0x1e, 0x8b, 0xc2, 0x48, 0x17, 0x1c, 0x06, 0x20, 0x5e, 0xa0, 0xf2, 0x9a, 0xf9, 0x86, 0x5e,
0xde, 0x35, 0x41, 0xf3, 0xdf, 0xb2, 0xde, 0x70, 0x45, 0x3d, 0x8b, 0xf9, 0xb2, 0x5a, 0xc6, 0xa0,
0x5a, 0xdd, 0xa8, 0x62, 0xf9, 0xc6, 0x77, 0x2c, 0xbc, 0x6a, 0x1d, 0x6a, 0xc9, 0xf9, 0xf6, 0xf8,
0x7a, 0x50, 0xea, 0xb6, 0x53, 0x75, 0xab, 0xe7, 0xe9, 0xf1, 0x9c, 0xdc, 0x48, 0xd3, 0x2a, 0x36,
0xa6, 0x66, 0x65, 0x4b, 0xc9, 0x72, 0x3d, 0x6d, 0x8b, 0x54, 0xf4, 0x36, 0x6d, 0x1a, 0x86, 0xa2,
0x6a, 0x56, 0xb6, 0x78, 0xda, 0x58, 0x68, 0x96, 0xed, 0x26, 0x2d, 0x08, 0xb8, 0x1e, 0x8d, 0x7a,
0x11, 0x35, 0xc5, 0x65, 0x9e, 0x8a, 0xa8, 0xd8, 0x5a, 0x3b, 0xf8, 0xb4, 0x9a, 0xe2, 0x32, 0xae,
0x72, 0x04, 0x86, 0xf4, 0x4a, 0xa5, 0x41, 0xc9, 0x25, 0x11, 0x2f, 0x43, 0x33, 0x9e, 0x98, 0x29,
0x8e, 0x9d, 0x82, 0x84, 0xb4, 0x03, 0x4d, 0x2c, 0xd4, 0x12, 0x98, 0xf3, 0xd9, 0x39, 0x4a, 0x1f,
0xdd, 0xd4, 0x5b, 0xb2, 0x11, 0x5f, 0x5a, 0x75, 0xb4, 0xd6, 0x81, 0x5e, 0x1f, 0xb6, 0x27, 0xd4,
0x54, 0xd5, 0xf1, 0x4e, 0x70, 0xf2, 0xcf, 0x62, 0x7a, 0x0d, 0x1e, 0x48, 0x2a, 0xb3, 0x90, 0x30,
0x6d, 0xf4, 0x0f, 0x8a, 0xe0, 0xa7, 0xe1, 0x47, 0x43, 0xce, 0x30, 0x27, 0xe6, 0x85, 0xbe, 0xea,
0x21, 0xc7, 0x7e, 0x11, 0x81, 0x84, 0x14, 0x63, 0xa2, 0x88, 0xd5, 0x75, 0x77, 0x93, 0xd1, 0xc5,
0xa7, 0xfb, 0xb2, 0x11, 0x95, 0x3d, 0x53, 0x39, 0x56, 0x33, 0x16, 0x73, 0x01, 0x21, 0xa7, 0xcf,
0x74, 0x5e, 0x4d, 0xa2, 0x97, 0x59, 0x81, 0x6b, 0xd7, 0x6a, 0x38, 0x93, 0x8e, 0x9c, 0x57, 0x21,
0x9f, 0x11, 0x62, 0x7a, 0x2e, 0xee, 0x36, 0xf4, 0xaa, 0x19, 0xd0, 0x8d, 0x31, 0xdd, 0xac, 0x6c,
0xf0, 0x94, 0x0b, 0xb0, 0x5f, 0xf2, 0x96, 0x89, 0xab, 0x63, 0xf1, 0x5c, 0x6e, 0x81, 0xfa, 0xd9,
0x69, 0xd7, 0x3e, 0xa1, 0x30, 0x2b, 0xda, 0x25, 0x76, 0xfa, 0x34, 0x16, 0xb2, 0x76, 0xad, 0xdd,
0x12, 0xd3, 0xd9, 0xb6, 0x7d, 0x97, 0x73, 0x57, 0xe4, 0x5e, 0x68, 0x15, 0x15, 0xcf, 0xf4, 0x45,
0xe7, 0x96, 0xa7, 0x9f, 0xef, 0x1b, 0x9b, 0xe3, 0xb8, 0x65, 0x69, 0x41, 0x95, 0x6c, 0x98, 0xc4,
0xa0, 0xd6, 0x81, 0xa7, 0xaf, 0x84, 0x1b, 0x2a, 0x55, 0x77, 0xb3, 0xb9, 0x3e, 0x81, 0x6f, 0x98,
0xac, 0xd8, 0x15, 0xbb, 0xf5, 0x39, 0x83, 0x3e, 0xb1, 0x07, 0x76, 0x27, 0x3e, 0x69, 0x24, 0x3d,
0xe9, 0x58, 0xe8, 0xf7, 0x8f, 0xc2, 0x22, 0x8c, 0x08, 0x65, 0x8d, 0x9d, 0xa9, 0xf2, 0x12, 0x54,
0xd9, 0x71, 0x43, 0x9e, 0x7b, 0xf1, 0x0d, 0x96, 0x12, 0xd4, 0x61, 0x01, 0xa5, 0x6d, 0xbc, 0x48,
0x2d, 0xa8, 0x70, 0x59, 0x80, 0x8f, 0xfb, 0x30, 0x6e, 0xb9, 0x77, 0x66, 0x7c, 0x59, 0x30, 0x8e,
0xf8, 0x18, 0x57, 0x04, 0xb4, 0x30, 0x03, 0x83, 0xbb, 0xe1, 0xfa, 0x99, 0xe0, 0x4a, 0x13, 0x3f,
0xc9, 0x1c, 0x0c, 0x31, 0x12, 0xa3, 0xe9, 0xb8, 0x76, 0x8d, 0x05, 0x88, 0x9d, 0x69, 0x7e, 0xfe,
0x06, 0x77, 0xaa, 0x0c, 0x85, 0xcd, 0x78, 0xa8, 0xc2, 0xdd, 0x30, 0x4a, 0x25, 0x6c, 0x0d, 0xfa,
0xd9, 0xc2, 0x8f, 0x10, 0x72, 0xbf, 0x7a, 0x80, 0xfb, 0xde, 0x88, 0x47, 0xe0, 0xe3, 0xf5, 0xcd,
0x44, 0x85, 0xb8, 0x18, 0xdb, 0x70, 0xff, 0x67, 0x9a, 0xca, 0x8e, 0xdf, 0x18, 0x72, 0x8f, 0xbe,
0x15, 0x9c, 0x89, 0x39, 0x8e, 0x9c, 0x32, 0xcd, 0xc2, 0x1a, 0xec, 0xeb, 0x32, 0xb3, 0x3d, 0x70,
0x3e, 0x26, 0x38, 0x47, 0x3b, 0x66, 0x97, 0xd2, 0x2e, 0x83, 0x94, 0x7b, 0xf3, 0xd1, 0x03, 0xe7,
0xe3, 0x82, 0x53, 0x11, 0x58, 0x39, 0x2d, 0x94, 0xf1, 0x14, 0x0c, 0xe3, 0x4e, 0x7d, 0xdd, 0x76,
0xc4, 0xbe, 0xb7, 0x07, 0xba, 0x27, 0x04, 0xdd, 0x90, 0x00, 0xb2, 0x5d, 0x30, 0xe5, 0xba, 0x0d,
0x12, 0x1b, 0xb8, 0x01, 0xea, 0x81, 0xe2, 0x49, 0x41, 0x31, 0x40, 0xf5, 0x29, 0x74, 0x0a, 0xd2,
0x15, 0x5b, 0x84, 0xe1, 0x70, 0xf8, 0x53, 0x02, 0x9e, 0x92, 0x18, 0x41, 0x51, 0xb7, 0xeb, 0x4d,
0x93, 0xc6, 0xe8, 0x70, 0x8a, 0x2f, 0x4b, 0x0a, 0x89, 0x11, 0x14, 0xbb, 0x30, 0xeb, 0x57, 0x24,
0x85, 0xe3, 0xb3, 0xe7, 0x9d, 0xf4, 0xac, 0xd7, 0xdc, 0xb2, 0xad, 0x5e, 0x3a, 0xf1, 0xb4, 0x60,
0x00, 0x01, 0xa1, 0x04, 0xb7, 0x43, 0xb2, 0xd7, 0x89, 0xf8, 0xaa, 0x80, 0x27, 0x88, 0x9c, 0x01,
0x5c, 0x67, 0x32, 0xc8, 0xd0, 0x6f, 0x2b, 0xe1, 0x14, 0x5f, 0x13, 0x14, 0x19, 0x1f, 0x4c, 0x0c,
0xc3, 0x25, 0x8e, 0x8b, 0x5b, 0xf5, 0x1e, 0x48, 0x9e, 0x95, 0xc3, 0x10, 0x10, 0x61, 0xca, 0x75,
0x62, 0x19, 0x9b, 0xbd, 0x31, 0x3c, 0x27, 0x4d, 0x29, 0x31, 0x94, 0x02, 0x23, 0x4f, 0x4d, 0x6f,
0xe0, 0xe6, 0xda, 0xec, 0x69, 0x3a, 0xbe, 0x2e, 0x38, 0xd2, 0x1e, 0x48, 0x58, 0xa4, 0x69, 0xed,
0x86, 0xe6, 0x79, 0x69, 0x11, 0x1f, 0x4c, 0x2c, 0x3d, 0xdc, 0x99, 0xd2, 0x4a, 0x62, 0x37, 0x6c,
0xdf, 0x90, 0x4b, 0x8f, 0x63, 0x17, 0xfc, 0x8c, 0x38, 0xd3, 0x0e, 0x6e, 0xc1, 0x7b, 0xa1, 0xf9,
0xa6, 0x9c, 0x69, 0x06, 0xa0, 0xe0, 0x33, 0xb0, 0xbf, 0x6b, 0xa8, 0xef, 0x81, 0xec, 0x5b, 0x82,
0x6c, 0x6f, 0x97, 0x70, 0x2f, 0x42, 0xc2, 0x6e, 0x29, 0xbf, 0x2d, 0x43, 0x02, 0x69, 0xe3, 0x5a,
0xa6, 0x65, 0xac, 0xa3, 0x6f, 0xec, 0xce, 0x6a, 0xdf, 0x91, 0x56, 0xe3, 0xd8, 0x80, 0xd5, 0x56,
0x61, 0xaf, 0x60, 0xdc, 0xdd, 0xbc, 0xbe, 0x20, 0x03, 0x2b, 0x47, 0xaf, 0x05, 0x67, 0xf7, 0xc3,
0x30, 0xe6, 0x99, 0x53, 0x56, 0x60, 0x8e, 0x46, 0x0f, 0x06, 0xc2, 0x99, 0x5f, 0x14, 0xcc, 0x32,
0xe2, 0x7b, 0x25, 0x9c, 0xb3, 0xa0, 0xd7, 0x29, 0xf9, 0x69, 0xc8, 0x49, 0xf2, 0xa6, 0x85, 0x05,
0xbe, 0x5d, 0xb1, 0x70, 0x1a, 0xcb, 0x3d, 0x50, 0x7f, 0xb7, 0x6d, 0xaa, 0xd6, 0x7c, 0x70, 0xca,
0x5c, 0x82, 0xac, 0x57, 0x6f, 0x68, 0xd5, 0x5a, 0xdd, 0xc6, 0xd2, 0x72, 0x67, 0xc6, 0xef, 0xc9,
0x99, 0xf2, 0x70, 0x25, 0x06, 0x2b, 0x14, 0x21, 0xc3, 0x1e, 0x7b, 0x75, 0xc9, 0xef, 0x0b, 0xa2,
0xc1, 0x16, 0x4a, 0x04, 0x0e, 0xac, 0x94, 0xb0, 0xe6, 0xed, 0x25, 0xfe, 0xfd, 0x40, 0x06, 0x0e,
0x01, 0xe1, 0xde, 0x37, 0xd4, 0x96, 0x89, 0x95, 0xb0, 0xcf, 0xaf, 0xb9, 0x8f, 0x5e, 0x12, 0x6b,
0x36, 0x98, 0x88, 0x0b, 0xf3, 0xd4, 0x3c, 0xc1, 0x74, 0x19, 0x4e, 0xf6, 0xc0, 0x25, 0xcf, 0x42,
0x81, 0x6c, 0x59, 0x38, 0x09, 0x83, 0x81, 0x54, 0x19, 0x4e, 0xf5, 0xa0, 0xa0, 0x4a, 0xfb, 0x33,
0x65, 0xe1, 0x66, 0x88, 0xd1, 0xb4, 0x17, 0x0e, 0xff, 0x98, 0x80, 0x33, 0xf5, 0xc2, 0xff, 0x43,
0x42, 0xa6, 0xbb, 0x70, 0xe8, 0xc7, 0x05, 0xd4, 0x83, 0x50, 0xb8, 0x4c, 0x75, 0xe1, 0xf0, 0x4f,
0x48, 0xb8, 0x84, 0x50, 0x78, 0xef, 0x26, 0x7c, 0xe9, 0x53, 0x31, 0x11, 0xae, 0xa4, 0xed, 0xe8,
0x37, 0x1f, 0x9e, 0xe3, 0xc2, 0xd1, 0x0f, 0x89, 0x97, 0x4b, 0x44, 0xe1, 0x56, 0x88, 0xf7, 0x68,
0xf0, 0x4f, 0x0b, 0x28, 0xd7, 0xc7, 0x0c, 0x92, 0xf2, 0xe5, 0xb5, 0x70, 0xf8, 0x67, 0x04, 0xdc,
0x8f, 0xa2, 0x5d, 0x17, 0x79, 0x2d, 0x9c, 0xe0, 0xb3, 0xb2, 0xeb, 0x02, 0x41, 0xcd, 0x26, 0x53,
0x5a, 0x38, 0xfa, 0x73, 0xd2, 0xea, 0x12, 0x82, 0xab, 0x29, 0xe9, 0x85, 0xa9, 0x70, 0xfc, 0xe7,
0x05, 0xbe, 0x85, 0xa1, 0x16, 0xf0, 0x85, 0xc9, 0x70, 0x8a, 0x2f, 0x48, 0x0b, 0xf8, 0x50, 0x74,
0x19, 0xb5, 0xa7, 0xbe, 0x70, 0xa6, 0x2f, 0xca, 0x65, 0xd4, 0x96, 0xf9, 0xe8, 0x6c, 0xb2, 0x68,
0x11, 0x4e, 0xf1, 0xb0, 0x9c, 0x4d, 0xa6, 0x4f, 0xbb, 0xd1, 0x9e, 0x4b, 0xc2, 0x39, 0xbe, 0x24,
0xbb, 0xd1, 0x96, 0x4a, 0x30, 0x33, 0x29, 0x9d, 0x79, 0x24, 0x9c, 0xef, 0x11, 0xc1, 0x37, 0xdc,
0x91, 0x46, 0x0a, 0xf7, 0xc0, 0xde, 0xee, 0x39, 0x24, 0x9c, 0xf5, 0xd1, 0x4b, 0x6d, 0x55, 0xbf,
0x3f, 0x85, 0x60, 0xca, 0x1b, 0xed, 0x96, 0x3f, 0xc2, 0x69, 0x1f, 0xbb, 0x14, 0xdc, 0xd8, 0xf9,
0xd3, 0x07, 0x56, 0x68, 0xd0, 0x0a, 0xdd, 0xe1, 0x5c, 0x4f, 0x08, 0x2e, 0x1f, 0x88, 0x2e, 0x0d,
0x11, 0xb9, 0xc3, 0xf1, 0x4f, 0xca, 0xa5, 0x21, 0x10, 0x08, 0x4e, 0x58, 0x4d, 0xd3, 0xa4, 0xce,
0xa1, 0xec, 0xfc, 0x93, 0x86, 0xdc, 0x9f, 0xde, 0x15, 0x0b, 0x43, 0x02, 0x30, 0x86, 0xc6, 0x49,
0x6d, 0x1d, 0x6d, 0x10, 0x82, 0xfc, 0xf3, 0xbb, 0x32, 0x20, 0x50, 0x6d, 0x5c, 0x4f, 0xc0, 0x37,
0x8d, 0xec, 0x0c, 0x3b, 0x04, 0xfb, 0x97, 0x77, 0xc5, 0x67, 0xd6, 0x16, 0xa4, 0x45, 0xc0, 0x3f,
0xda, 0xee, 0x4c, 0xf0, 0x56, 0x90, 0x80, 0x6d, 0x34, 0x6f, 0x83, 0x01, 0xfa, 0xcb, 0x0e, 0x57,
0xaf, 0x84, 0xa1, 0xff, 0x2a, 0xd0, 0x52, 0x9f, 0x1a, 0xac, 0x66, 0x37, 0x08, 0xde, 0x3a, 0x61,
0xd8, 0xbf, 0x09, 0xac, 0x07, 0xa0, 0x60, 0x43, 0x77, 0xdc, 0x5e, 0xc6, 0xfd, 0x77, 0x09, 0x96,
0x00, 0xda, 0x69, 0x7a, 0x7f, 0x8e, 0x6c, 0x85, 0x61, 0xdf, 0x96, 0x9d, 0x16, 0xfa, 0x18, 0x00,
0x93, 0xf4, 0x96, 0xff, 0xf4, 0x20, 0x04, 0xfc, 0x0f, 0x01, 0x6e, 0x21, 0xa6, 0x0f, 0x77, 0x3f,
0xda, 0x81, 0x39, 0x7b, 0xce, 0xe6, 0x87, 0x3a, 0xf0, 0x70, 0x1c, 0xae, 0x41, 0x1d, 0xcc, 0xaf,
0x93, 0x7c, 0x4d, 0x7a, 0x2b, 0x72, 0xd2, 0xe3, 0x91, 0x87, 0x33, 0x9e, 0x60, 0x6c, 0x77, 0xc7,
0x3a, 0xf9, 0x9f, 0x44, 0x21, 0x31, 0x83, 0x60, 0xfd, 0x82, 0xbe, 0xa5, 0xd4, 0x61, 0x84, 0xde,
0xe3, 0xd2, 0x64, 0x07, 0x0c, 0xc2, 0xd1, 0xc5, 0x89, 0xdc, 0xf5, 0x13, 0xad, 0xb7, 0x4a, 0xc4,
0x44, 0x17, 0x75, 0xf6, 0x81, 0x69, 0x3a, 0xfb, 0xca, 0xef, 0xc6, 0xf7, 0x7c, 0xf2, 0xf7, 0xe3,
0x89, 0x85, 0xad, 0x7b, 0xaa, 0xa6, 0x43, 0xcf, 0x6c, 0x8d, 0x4e, 0x5d, 0xe5, 0xc1, 0x08, 0x1c,
0xe8, 0xc2, 0xb1, 0x28, 0x96, 0x83, 0x38, 0xa8, 0xbd, 0xa9, 0xc7, 0x57, 0x4b, 0x18, 0xef, 0x42,
0x3a, 0xf0, 0xfa, 0x03, 0xc6, 0xf6, 0xfa, 0x63, 0x67, 0x20, 0xb7, 0xdd, 0x48, 0xe8, 0x8f, 0xc3,
0x70, 0xbe, 0xc5, 0x0f, 0xc6, 0xe8, 0xad, 0x72, 0xa4, 0xf5, 0x4b, 0x15, 0xfa, 0x83, 0x84, 0x61,
0x5f, 0xef, 0xc4, 0xcb, 0x78, 0x7b, 0xa1, 0xef, 0x44, 0x64, 0x4c, 0x87, 0x43, 0x61, 0x3d, 0xfd,
0x37, 0x5f, 0x91, 0x3f, 0x08, 0xfd, 0x5c, 0x48, 0x7f, 0xde, 0x56, 0xb2, 0xdc, 0x5b, 0x6e, 0x62,
0x54, 0x51, 0x35, 0x5e, 0xa5, 0x0f, 0xd3, 0xf3, 0xaf, 0xbc, 0x76, 0x70, 0xcf, 0x2f, 0xf1, 0xfa,
0x0d, 0x5e, 0xaf, 0xbe, 0x76, 0x30, 0xf2, 0x26, 0x5e, 0x6f, 0xe3, 0xf5, 0x0e, 0x5e, 0xf7, 0xbf,
0x7e, 0x30, 0xf2, 0x1c, 0x5e, 0x2f, 0xe0, 0xf5, 0x23, 0xbc, 0x5e, 0xc2, 0xeb, 0x95, 0xd7, 0x51,
0x1f, 0xaf, 0x57, 0xf1, 0xfe, 0x4d, 0xfc, 0xff, 0x36, 0xfe, 0x7f, 0x07, 0xaf, 0xfb, 0xff, 0x70,
0x70, 0xcf, 0xbf, 0x02, 0x00, 0x00, 0xff, 0xff, 0x76, 0x38, 0x95, 0x63, 0x01, 0x2d, 0x00, 0x00,
// 3606 bytes of a gzipped FileDescriptorSet
0x1f, 0x8b, 0x08, 0x00, 0x00, 0x09, 0x6e, 0x88, 0x02, 0xff, 0xcc, 0x5a, 0x5d, 0x6c, 0x1c, 0xd7,
0x75, 0xe6, 0xec, 0x0f, 0xb9, 0x7b, 0x76, 0xb9, 0x1c, 0x5e, 0xd2, 0xd4, 0x8a, 0x8a, 0x57, 0x14,
0x23, 0x47, 0xb4, 0x9d, 0x90, 0x81, 0x2c, 0xc9, 0xd2, 0xaa, 0x89, 0xb0, 0x5c, 0xae, 0x18, 0x0a,
0xfc, 0xeb, 0x90, 0x8c, 0xa5, 0xe4, 0x61, 0x70, 0x39, 0x7b, 0x77, 0x39, 0xd2, 0xec, 0xcc, 0x76,
0x66, 0x56, 0x12, 0xf5, 0xa4, 0xc0, 0x69, 0x8b, 0x34, 0xe8, 0x7f, 0x80, 0x26, 0x8e, 0xf3, 0xd3,
0x00, 0xad, 0xd3, 0xf4, 0x2f, 0xe9, 0x1f, 0x8a, 0x3e, 0xa5, 0x0f, 0x69, 0xfd, 0x54, 0x24, 0x6f,
0x7d, 0x28, 0x5a, 0x8b, 0x35, 0x50, 0xb7, 0x75, 0x5b, 0xb7, 0x15, 0x50, 0x03, 0x7a, 0x29, 0xee,
0xdf, 0xec, 0xec, 0x0f, 0x39, 0x4b, 0x17, 0xb6, 0xfb, 0xc4, 0xbd, 0xe7, 0x9e, 0xef, 0x9b, 0x73,
0xcf, 0x3d, 0xf7, 0x9c, 0x33, 0x77, 0x08, 0x5f, 0xb8, 0x00, 0x33, 0x75, 0xc7, 0xa9, 0x5b, 0x64,
0xa1, 0xe9, 0x3a, 0xbe, 0xb3, 0xdb, 0xaa, 0x2d, 0x54, 0x89, 0x67, 0xb8, 0x66, 0xd3, 0x77, 0xdc,
0x79, 0x26, 0x43, 0x63, 0x5c, 0x63, 0x5e, 0x6a, 0xcc, 0xae, 0xc1, 0xf8, 0x75, 0xd3, 0x22, 0x4b,
0x81, 0xe2, 0x16, 0xf1, 0xd1, 0x65, 0x48, 0xd4, 0x4c, 0x8b, 0xe4, 0x95, 0x99, 0xf8, 0x5c, 0xe6,
0xfc, 0xd9, 0xf9, 0x2e, 0xd0, 0x7c, 0x27, 0x62, 0x93, 0x8a, 0x35, 0x86, 0x98, 0x7d, 0x33, 0x01,
0x13, 0x7d, 0x66, 0x11, 0x82, 0x84, 0x8d, 0x1b, 0x94, 0x51, 0x99, 0x4b, 0x6b, 0xec, 0x37, 0xca,
0xc3, 0x48, 0x13, 0x1b, 0x77, 0x70, 0x9d, 0xe4, 0x63, 0x4c, 0x2c, 0x87, 0xa8, 0x00, 0x50, 0x25,
0x4d, 0x62, 0x57, 0x89, 0x6d, 0xec, 0xe7, 0xe3, 0x33, 0xf1, 0xb9, 0xb4, 0x16, 0x92, 0xa0, 0xe7,
0x61, 0xbc, 0xd9, 0xda, 0xb5, 0x4c, 0x43, 0x0f, 0xa9, 0xc1, 0x4c, 0x7c, 0x2e, 0xa9, 0xa9, 0x7c,
0x62, 0xa9, 0xad, 0x7c, 0x0e, 0xc6, 0xee, 0x11, 0x7c, 0x27, 0xac, 0x9a, 0x61, 0xaa, 0x39, 0x2a,
0x0e, 0x29, 0x96, 0x21, 0xdb, 0x20, 0x9e, 0x87, 0xeb, 0x44, 0xf7, 0xf7, 0x9b, 0x24, 0x9f, 0x60,
0xab, 0x9f, 0xe9, 0x59, 0x7d, 0xf7, 0xca, 0x33, 0x02, 0xb5, 0xbd, 0xdf, 0x24, 0xa8, 0x04, 0x69,
0x62, 0xb7, 0x1a, 0x9c, 0x21, 0x79, 0x88, 0xff, 0x2a, 0x76, 0xab, 0xd1, 0xcd, 0x92, 0xa2, 0x30,
0x41, 0x31, 0xe2, 0x11, 0xf7, 0xae, 0x69, 0x90, 0xfc, 0x30, 0x23, 0x38, 0xd7, 0x43, 0xb0, 0xc5,
0xe7, 0xbb, 0x39, 0x24, 0x0e, 0x95, 0x21, 0x4d, 0xee, 0xfb, 0xc4, 0xf6, 0x4c, 0xc7, 0xce, 0x8f,
0x30, 0x92, 0x67, 0xfa, 0xec, 0x22, 0xb1, 0xaa, 0xdd, 0x14, 0x6d, 0x1c, 0xba, 0x04, 0x23, 0x4e,
0xd3, 0x37, 0x1d, 0xdb, 0xcb, 0xa7, 0x66, 0x94, 0xb9, 0xcc, 0xf9, 0x8f, 0xf4, 0x0d, 0x84, 0x0d,
0xae, 0xa3, 0x49, 0x65, 0xb4, 0x02, 0xaa, 0xe7, 0xb4, 0x5c, 0x83, 0xe8, 0x86, 0x53, 0x25, 0xba,
0x69, 0xd7, 0x9c, 0x7c, 0x9a, 0x11, 0x9c, 0xee, 0x5d, 0x08, 0x53, 0x2c, 0x3b, 0x55, 0xb2, 0x62,
0xd7, 0x1c, 0x2d, 0xe7, 0x75, 0x8c, 0xd1, 0x14, 0x0c, 0x7b, 0xfb, 0xb6, 0x8f, 0xef, 0xe7, 0xb3,
0x2c, 0x42, 0xc4, 0x68, 0xf6, 0x7f, 0x92, 0x30, 0x36, 0x48, 0x88, 0x5d, 0x85, 0x64, 0x8d, 0xae,
0x32, 0x1f, 0x3b, 0x8e, 0x0f, 0x38, 0xa6, 0xd3, 0x89, 0xc3, 0xef, 0xd1, 0x89, 0x25, 0xc8, 0xd8,
0xc4, 0xf3, 0x49, 0x95, 0x47, 0x44, 0x7c, 0xc0, 0x98, 0x02, 0x0e, 0xea, 0x0d, 0xa9, 0xc4, 0x7b,
0x0a, 0xa9, 0x9b, 0x30, 0x16, 0x98, 0xa4, 0xbb, 0xd8, 0xae, 0xcb, 0xd8, 0x5c, 0x88, 0xb2, 0x64,
0xbe, 0x22, 0x71, 0x1a, 0x85, 0x69, 0x39, 0xd2, 0x31, 0x46, 0x4b, 0x00, 0x8e, 0x4d, 0x9c, 0x9a,
0x5e, 0x25, 0x86, 0x95, 0x4f, 0x1d, 0xe2, 0xa5, 0x0d, 0xaa, 0xd2, 0xe3, 0x25, 0x87, 0x4b, 0x0d,
0x0b, 0x5d, 0x69, 0x87, 0xda, 0xc8, 0x21, 0x91, 0xb2, 0xc6, 0x0f, 0x59, 0x4f, 0xb4, 0xed, 0x40,
0xce, 0x25, 0x34, 0xee, 0x49, 0x55, 0xac, 0x2c, 0xcd, 0x8c, 0x98, 0x8f, 0x5c, 0x99, 0x26, 0x60,
0x7c, 0x61, 0xa3, 0x6e, 0x78, 0x88, 0x3e, 0x0a, 0x81, 0x40, 0x67, 0x61, 0x05, 0x2c, 0x0b, 0x65,
0xa5, 0x70, 0x1d, 0x37, 0xc8, 0xf4, 0x65, 0xc8, 0x75, 0xba, 0x07, 0x4d, 0x42, 0xd2, 0xf3, 0xb1,
0xeb, 0xb3, 0x28, 0x4c, 0x6a, 0x7c, 0x80, 0x54, 0x88, 0x13, 0xbb, 0xca, 0xb2, 0x5c, 0x52, 0xa3,
0x3f, 0xa7, 0x5f, 0x84, 0xd1, 0x8e, 0xc7, 0x0f, 0x0a, 0x9c, 0xfd, 0xea, 0x30, 0x4c, 0xf6, 0x8b,
0xb9, 0xbe, 0xe1, 0x3f, 0x05, 0xc3, 0x76, 0xab, 0xb1, 0x4b, 0xdc, 0x7c, 0x9c, 0x31, 0x88, 0x11,
0x2a, 0x41, 0xd2, 0xc2, 0xbb, 0xc4, 0xca, 0x27, 0x66, 0x94, 0xb9, 0xdc, 0xf9, 0xe7, 0x07, 0x8a,
0xea, 0xf9, 0x55, 0x0a, 0xd1, 0x38, 0x12, 0x7d, 0x1a, 0x12, 0x22, 0xc5, 0x51, 0x86, 0xe7, 0x06,
0x63, 0xa0, 0xb1, 0xa8, 0x31, 0x1c, 0x3a, 0x05, 0x69, 0xfa, 0x97, 0xfb, 0x76, 0x98, 0xd9, 0x9c,
0xa2, 0x02, 0xea, 0x57, 0x34, 0x0d, 0x29, 0x16, 0x66, 0x55, 0x22, 0x4b, 0x43, 0x30, 0xa6, 0x1b,
0x53, 0x25, 0x35, 0xdc, 0xb2, 0x7c, 0xfd, 0x2e, 0xb6, 0x5a, 0x84, 0x05, 0x4c, 0x5a, 0xcb, 0x0a,
0xe1, 0x67, 0xa9, 0x0c, 0x9d, 0x86, 0x0c, 0x8f, 0x4a, 0xd3, 0xae, 0x92, 0xfb, 0x2c, 0xfb, 0x24,
0x35, 0x1e, 0xa8, 0x2b, 0x54, 0x42, 0x1f, 0x7f, 0xdb, 0x73, 0x6c, 0xb9, 0xb5, 0xec, 0x11, 0x54,
0xc0, 0x1e, 0xff, 0x62, 0x77, 0xe2, 0x7b, 0xba, 0xff, 0xf2, 0xba, 0x63, 0x71, 0xf6, 0xcf, 0x62,
0x90, 0x60, 0xe7, 0x6d, 0x0c, 0x32, 0xdb, 0xb7, 0x36, 0x2b, 0xfa, 0xd2, 0xc6, 0xce, 0xe2, 0x6a,
0x45, 0x55, 0x50, 0x0e, 0x80, 0x09, 0xae, 0xaf, 0x6e, 0x94, 0xb6, 0xd5, 0x58, 0x30, 0x5e, 0x59,
0xdf, 0xbe, 0x74, 0x41, 0x8d, 0x07, 0x80, 0x1d, 0x2e, 0x48, 0x84, 0x15, 0x5e, 0x38, 0xaf, 0x26,
0x91, 0x0a, 0x59, 0x4e, 0xb0, 0x72, 0xb3, 0xb2, 0x74, 0xe9, 0x82, 0x3a, 0xdc, 0x29, 0x79, 0xe1,
0xbc, 0x3a, 0x82, 0x46, 0x21, 0xcd, 0x24, 0x8b, 0x1b, 0x1b, 0xab, 0x6a, 0x2a, 0xe0, 0xdc, 0xda,
0xd6, 0x56, 0xd6, 0x97, 0xd5, 0x74, 0xc0, 0xb9, 0xac, 0x6d, 0xec, 0x6c, 0xaa, 0x10, 0x30, 0xac,
0x55, 0xb6, 0xb6, 0x4a, 0xcb, 0x15, 0x35, 0x13, 0x68, 0x2c, 0xde, 0xda, 0xae, 0x6c, 0xa9, 0xd9,
0x0e, 0xb3, 0x5e, 0x38, 0xaf, 0x8e, 0x06, 0x8f, 0xa8, 0xac, 0xef, 0xac, 0xa9, 0x39, 0x34, 0x0e,
0xa3, 0xfc, 0x11, 0xd2, 0x88, 0xb1, 0x2e, 0xd1, 0xa5, 0x0b, 0xaa, 0xda, 0x36, 0x84, 0xb3, 0x8c,
0x77, 0x08, 0x2e, 0x5d, 0x50, 0xd1, 0x6c, 0x19, 0x92, 0x2c, 0xba, 0x10, 0x82, 0xdc, 0x6a, 0x69,
0xb1, 0xb2, 0xaa, 0x6f, 0x6c, 0x6e, 0xaf, 0x6c, 0xac, 0x97, 0x56, 0x55, 0xa5, 0x2d, 0xd3, 0x2a,
0x3f, 0xbd, 0xb3, 0xa2, 0x55, 0x96, 0xd4, 0x58, 0x58, 0xb6, 0x59, 0x29, 0x6d, 0x57, 0x96, 0xd4,
0xf8, 0xac, 0x01, 0x93, 0xfd, 0xf2, 0x4c, 0xdf, 0x93, 0x11, 0xda, 0xe2, 0xd8, 0x21, 0x5b, 0xcc,
0xb8, 0x7a, 0xb6, 0xf8, 0x3b, 0x0a, 0x4c, 0xf4, 0xc9, 0xb5, 0x7d, 0x1f, 0x72, 0x0d, 0x92, 0x3c,
0x44, 0x79, 0xf5, 0x79, 0xb6, 0x6f, 0xd2, 0x66, 0x01, 0xdb, 0x53, 0x81, 0x18, 0x2e, 0x5c, 0x81,
0xe3, 0x87, 0x54, 0x60, 0x4a, 0xd1, 0x63, 0xe4, 0xcb, 0x0a, 0xe4, 0x0f, 0xe3, 0x8e, 0x48, 0x14,
0xb1, 0x8e, 0x44, 0x71, 0xb5, 0xdb, 0x80, 0x33, 0x87, 0xaf, 0xa1, 0xc7, 0x8a, 0xd7, 0x14, 0x98,
0xea, 0xdf, 0xa8, 0xf4, 0xb5, 0xe1, 0xd3, 0x30, 0xdc, 0x20, 0xfe, 0x9e, 0x23, 0x8b, 0xf5, 0xc7,
0xfa, 0x94, 0x00, 0x3a, 0xdd, 0xed, 0x2b, 0x81, 0x0a, 0xd7, 0x90, 0xf8, 0x61, 0xdd, 0x06, 0xb7,
0xa6, 0xc7, 0xd2, 0x2f, 0xc5, 0xe0, 0xa9, 0xbe, 0xe4, 0x7d, 0x0d, 0x7d, 0x1a, 0xc0, 0xb4, 0x9b,
0x2d, 0x9f, 0x17, 0x64, 0x9e, 0x9f, 0xd2, 0x4c, 0xc2, 0xce, 0x3e, 0xcd, 0x3d, 0x2d, 0x3f, 0x98,
0x8f, 0xb3, 0x79, 0xe0, 0x22, 0xa6, 0x70, 0xb9, 0x6d, 0x68, 0x82, 0x19, 0x5a, 0x38, 0x64, 0xa5,
0x3d, 0xb5, 0xee, 0x93, 0xa0, 0x1a, 0x96, 0x49, 0x6c, 0x5f, 0xf7, 0x7c, 0x97, 0xe0, 0x86, 0x69,
0xd7, 0x59, 0x02, 0x4e, 0x15, 0x93, 0x35, 0x6c, 0x79, 0x44, 0x1b, 0xe3, 0xd3, 0x5b, 0x72, 0x96,
0x22, 0x58, 0x95, 0x71, 0x43, 0x88, 0xe1, 0x0e, 0x04, 0x9f, 0x0e, 0x10, 0xb3, 0x5f, 0x1e, 0x81,
0x4c, 0xa8, 0xad, 0x43, 0x67, 0x20, 0x7b, 0x1b, 0xdf, 0xc5, 0xba, 0x6c, 0xd5, 0xb9, 0x27, 0x32,
0x54, 0xb6, 0x29, 0xda, 0xf5, 0x4f, 0xc2, 0x24, 0x53, 0x71, 0x5a, 0x3e, 0x71, 0x75, 0xc3, 0xc2,
0x9e, 0xc7, 0x9c, 0x96, 0x62, 0xaa, 0x88, 0xce, 0x6d, 0xd0, 0xa9, 0xb2, 0x9c, 0x41, 0x17, 0x61,
0x82, 0x21, 0x1a, 0x2d, 0xcb, 0x37, 0x9b, 0x16, 0xd1, 0xe9, 0xcb, 0x83, 0xc7, 0x12, 0x71, 0x60,
0xd9, 0x38, 0xd5, 0x58, 0x13, 0x0a, 0xd4, 0x22, 0x0f, 0x2d, 0xc3, 0xd3, 0x0c, 0x56, 0x27, 0x36,
0x71, 0xb1, 0x4f, 0x74, 0xf2, 0x33, 0x2d, 0x6c, 0x79, 0x3a, 0xb6, 0xab, 0xfa, 0x1e, 0xf6, 0xf6,
0xf2, 0x93, 0x61, 0x82, 0x93, 0x54, 0x77, 0x59, 0xa8, 0x56, 0x98, 0x66, 0xc9, 0xae, 0x7e, 0x06,
0x7b, 0x7b, 0xa8, 0x08, 0x53, 0x8c, 0xc8, 0xf3, 0x5d, 0xd3, 0xae, 0xeb, 0xc6, 0x1e, 0x31, 0xee,
0xe8, 0x2d, 0xbf, 0x76, 0x39, 0x7f, 0x2a, 0xcc, 0xc0, 0x8c, 0xdc, 0x62, 0x3a, 0x65, 0xaa, 0xb2,
0xe3, 0xd7, 0x2e, 0xa3, 0x2d, 0xc8, 0xd2, 0xfd, 0x68, 0x98, 0x0f, 0x88, 0x5e, 0x73, 0x5c, 0x56,
0x5c, 0x72, 0x7d, 0x0e, 0x77, 0xc8, 0x89, 0xf3, 0x1b, 0x02, 0xb0, 0xe6, 0x54, 0x49, 0x31, 0xb9,
0xb5, 0x59, 0xa9, 0x2c, 0x69, 0x19, 0xc9, 0x72, 0xdd, 0x71, 0x69, 0x4c, 0xd5, 0x9d, 0xc0, 0xc7,
0x19, 0x1e, 0x53, 0x75, 0x47, 0x7a, 0xf8, 0x22, 0x4c, 0x18, 0x06, 0x5f, 0xb6, 0x69, 0xe8, 0xa2,
0xcb, 0xf7, 0xf2, 0x6a, 0x87, 0xbf, 0x0c, 0x63, 0x99, 0x2b, 0x88, 0x30, 0xf7, 0xd0, 0x15, 0x78,
0xaa, 0xed, 0xaf, 0x30, 0x70, 0xbc, 0x67, 0x95, 0xdd, 0xd0, 0x8b, 0x30, 0xd1, 0xdc, 0xef, 0x05,
0xa2, 0x8e, 0x27, 0x36, 0xf7, 0xbb, 0x61, 0xcf, 0xb0, 0x37, 0x37, 0x97, 0x18, 0xd8, 0x27, 0xd5,
0xfc, 0x89, 0xb0, 0x76, 0x68, 0x02, 0x2d, 0x80, 0x6a, 0x18, 0x3a, 0xb1, 0xf1, 0xae, 0x45, 0x74,
0xec, 0x12, 0x1b, 0x7b, 0xf9, 0xd3, 0x61, 0xe5, 0x9c, 0x61, 0x54, 0xd8, 0x6c, 0x89, 0x4d, 0xa2,
0xe7, 0x60, 0xdc, 0xd9, 0xbd, 0x6d, 0xf0, 0xe0, 0xd2, 0x9b, 0x2e, 0xa9, 0x99, 0xf7, 0xf3, 0x67,
0x99, 0x9b, 0xc6, 0xe8, 0x04, 0x0b, 0xad, 0x4d, 0x26, 0x46, 0xcf, 0x82, 0x6a, 0x78, 0x7b, 0xd8,
0x6d, 0xb2, 0xea, 0xee, 0x35, 0xb1, 0x41, 0xf2, 0xcf, 0x70, 0x55, 0x2e, 0x5f, 0x97, 0x62, 0x74,
0x13, 0x26, 0x5b, 0xb6, 0x69, 0xfb, 0xc4, 0x6d, 0xba, 0x84, 0x36, 0xe9, 0xfc, 0xa4, 0xe5, 0xff,
0x69, 0xe4, 0x90, 0x36, 0x7b, 0x27, 0xac, 0xcd, 0x77, 0x57, 0x9b, 0x68, 0xf5, 0x0a, 0x67, 0x8b,
0x90, 0x0d, 0x6f, 0x3a, 0x4a, 0x03, 0xdf, 0x76, 0x55, 0xa1, 0x35, 0xb4, 0xbc, 0xb1, 0x44, 0xab,
0xdf, 0xe7, 0x2a, 0x6a, 0x8c, 0x56, 0xe1, 0xd5, 0x95, 0xed, 0x8a, 0xae, 0xed, 0xac, 0x6f, 0xaf,
0xac, 0x55, 0xd4, 0xf8, 0x73, 0xe9, 0xd4, 0x5b, 0x23, 0xea, 0xc3, 0x87, 0x0f, 0x1f, 0xc6, 0x66,
0x7f, 0x14, 0x83, 0x5c, 0x67, 0xe7, 0x8b, 0x7e, 0x0a, 0x4e, 0xc8, 0xd7, 0x54, 0x8f, 0xf8, 0xfa,
0x3d, 0xd3, 0x65, 0x71, 0xd8, 0xc0, 0xbc, 0x77, 0x0c, 0x5c, 0x38, 0x29, 0xb4, 0xb6, 0x88, 0xff,
0x92, 0xe9, 0xd2, 0x28, 0x6b, 0x60, 0x1f, 0xad, 0xc2, 0x69, 0xdb, 0xd1, 0x3d, 0x1f, 0xdb, 0x55,
0xec, 0x56, 0xf5, 0xf6, 0x05, 0x81, 0x8e, 0x0d, 0x83, 0x78, 0x9e, 0xc3, 0x4b, 0x40, 0xc0, 0xf2,
0x11, 0xdb, 0xd9, 0x12, 0xca, 0xed, 0xdc, 0x58, 0x12, 0xaa, 0x5d, 0xdb, 0x1d, 0x3f, 0x6c, 0xbb,
0x4f, 0x41, 0xba, 0x81, 0x9b, 0x3a, 0xb1, 0x7d, 0x77, 0x9f, 0xf5, 0x6b, 0x29, 0x2d, 0xd5, 0xc0,
0xcd, 0x0a, 0x1d, 0xbf, 0x7f, 0x7b, 0x10, 0xf6, 0xe3, 0xdf, 0xc5, 0x21, 0x1b, 0xee, 0xd9, 0x68,
0x0b, 0x6c, 0xb0, 0xfc, 0xac, 0xb0, 0xe3, 0xfb, 0xd1, 0x23, 0x3b, 0xbc, 0xf9, 0x32, 0x4d, 0xdc,
0xc5, 0x61, 0xde, 0x49, 0x69, 0x1c, 0x49, 0x8b, 0x26, 0x3d, 0xb0, 0x84, 0xf7, 0xe7, 0x29, 0x4d,
0x8c, 0xd0, 0x32, 0x0c, 0xdf, 0xf6, 0x18, 0xf7, 0x30, 0xe3, 0x3e, 0x7b, 0x34, 0xf7, 0x8d, 0x2d,
0x46, 0x9e, 0xbe, 0xb1, 0xa5, 0xaf, 0x6f, 0x68, 0x6b, 0xa5, 0x55, 0x4d, 0xc0, 0xd1, 0x49, 0x48,
0x58, 0xf8, 0xc1, 0x7e, 0x67, 0x8a, 0x67, 0xa2, 0x41, 0x1d, 0x7f, 0x12, 0x12, 0xf7, 0x08, 0xbe,
0xd3, 0x99, 0x58, 0x99, 0xe8, 0x7d, 0x0c, 0xfd, 0x05, 0x48, 0x32, 0x7f, 0x21, 0x00, 0xe1, 0x31,
0x75, 0x08, 0xa5, 0x20, 0x51, 0xde, 0xd0, 0x68, 0xf8, 0xab, 0x90, 0xe5, 0x52, 0x7d, 0x73, 0xa5,
0x52, 0xae, 0xa8, 0xb1, 0xd9, 0x8b, 0x30, 0xcc, 0x9d, 0x40, 0x8f, 0x46, 0xe0, 0x06, 0x75, 0x48,
0x0c, 0x05, 0x87, 0x22, 0x67, 0x77, 0xd6, 0x16, 0x2b, 0x9a, 0x1a, 0x0b, 0x6f, 0xaf, 0x07, 0xd9,
0x70, 0xbb, 0xf6, 0xc1, 0xc4, 0xd4, 0x5f, 0x28, 0x90, 0x09, 0xb5, 0x5f, 0xb4, 0xf0, 0x63, 0xcb,
0x72, 0xee, 0xe9, 0xd8, 0x32, 0xb1, 0x27, 0x82, 0x02, 0x98, 0xa8, 0x44, 0x25, 0x83, 0x6e, 0xda,
0x07, 0x62, 0xfc, 0x37, 0x15, 0x50, 0xbb, 0x5b, 0xb7, 0x2e, 0x03, 0x95, 0x0f, 0xd5, 0xc0, 0x57,
0x15, 0xc8, 0x75, 0xf6, 0x6b, 0x5d, 0xe6, 0x9d, 0xf9, 0x50, 0xcd, 0xfb, 0xba, 0x02, 0xa3, 0x1d,
0x5d, 0xda, 0xff, 0x2b, 0xeb, 0x5e, 0x89, 0xc3, 0x44, 0x1f, 0x1c, 0x2a, 0x89, 0x76, 0x96, 0x77,
0xd8, 0x9f, 0x18, 0xe4, 0x59, 0xf3, 0xb4, 0x5a, 0x6e, 0x62, 0xd7, 0x17, 0xdd, 0xef, 0xb3, 0xa0,
0x9a, 0x55, 0x62, 0xfb, 0x66, 0xcd, 0x24, 0xae, 0x78, 0x05, 0xe7, 0x3d, 0xee, 0x58, 0x5b, 0xce,
0xdf, 0xc2, 0x3f, 0x0e, 0xa8, 0xe9, 0x78, 0xa6, 0x6f, 0xde, 0x25, 0xba, 0x69, 0xcb, 0xf7, 0x75,
0xda, 0xf3, 0x26, 0x34, 0x55, 0xce, 0xac, 0xd8, 0x7e, 0xa0, 0x6d, 0x93, 0x3a, 0xee, 0xd2, 0xa6,
0xb9, 0x2f, 0xae, 0xa9, 0x72, 0x26, 0xd0, 0x3e, 0x03, 0xd9, 0xaa, 0xd3, 0xa2, 0xed, 0x03, 0xd7,
0xa3, 0xa9, 0x56, 0xd1, 0x32, 0x5c, 0x16, 0xa8, 0x88, 0xfe, 0xae, 0x7d, 0x51, 0x90, 0xd5, 0x32,
0x5c, 0xc6, 0x55, 0xce, 0xc1, 0x18, 0xae, 0xd7, 0x5d, 0x4a, 0x2e, 0x89, 0x78, 0xd3, 0x9a, 0x0b,
0xc4, 0x4c, 0x71, 0xfa, 0x06, 0xa4, 0xa4, 0x1f, 0x68, 0x35, 0xa3, 0x9e, 0xd0, 0x9b, 0xfc, 0xba,
0x26, 0x36, 0x97, 0xd6, 0x52, 0xb6, 0x9c, 0x3c, 0x03, 0x59, 0xd3, 0xd3, 0xdb, 0xf7, 0x86, 0xb1,
0x99, 0xd8, 0x5c, 0x4a, 0xcb, 0x98, 0x5e, 0x70, 0x51, 0x34, 0xfb, 0x5a, 0x0c, 0x72, 0x9d, 0xf7,
0x9e, 0x68, 0x09, 0x52, 0x96, 0x63, 0x60, 0x16, 0x08, 0xfc, 0xd2, 0x7d, 0x2e, 0xe2, 0xaa, 0x74,
0x7e, 0x55, 0xe8, 0x6b, 0x01, 0x72, 0xfa, 0x6f, 0x14, 0x48, 0x49, 0x31, 0x9a, 0x82, 0x44, 0x13,
0xfb, 0x7b, 0x8c, 0x2e, 0xb9, 0x18, 0x53, 0x15, 0x8d, 0x8d, 0xa9, 0xdc, 0x6b, 0x62, 0x9b, 0x85,
0x80, 0x90, 0xd3, 0x31, 0xdd, 0x57, 0x8b, 0xe0, 0x2a, 0x6b, 0x87, 0x9d, 0x46, 0x83, 0xd8, 0xbe,
0x27, 0xf7, 0x55, 0xc8, 0xcb, 0x42, 0x8c, 0x9e, 0x87, 0x71, 0xdf, 0xc5, 0xa6, 0xd5, 0xa1, 0x9b,
0x60, 0xba, 0xaa, 0x9c, 0x08, 0x94, 0x8b, 0x70, 0x52, 0xf2, 0x56, 0x89, 0x8f, 0x8d, 0x3d, 0x52,
0x6d, 0x83, 0x86, 0xd9, 0xa5, 0xda, 0x09, 0xa1, 0xb0, 0x24, 0xe6, 0x25, 0x76, 0xf6, 0x27, 0x0a,
0x8c, 0xcb, 0x06, 0xbe, 0x1a, 0x38, 0x6b, 0x0d, 0x00, 0xdb, 0xb6, 0xe3, 0x87, 0xdd, 0xd5, 0x1b,
0xca, 0x3d, 0xb8, 0xf9, 0x52, 0x00, 0xd2, 0x42, 0x04, 0xd3, 0x0d, 0x80, 0xf6, 0xcc, 0xa1, 0x6e,
0x3b, 0x0d, 0x19, 0x71, 0xa9, 0xcd, 0xbe, 0x8c, 0xf0, 0xb7, 0x3e, 0xe0, 0x22, 0xda, 0xe9, 0xa3,
0x49, 0x48, 0xee, 0x92, 0xba, 0x69, 0x8b, 0xab, 0x36, 0x3e, 0x90, 0x17, 0x78, 0x89, 0xe0, 0x02,
0x6f, 0xf1, 0xf3, 0x30, 0x61, 0x38, 0x8d, 0x6e, 0x73, 0x17, 0xd5, 0xae, 0x37, 0x4f, 0xef, 0x33,
0xca, 0xe7, 0xa0, 0xdd, 0x9d, 0x7d, 0x5b, 0x51, 0xbe, 0x13, 0x8b, 0x2f, 0x6f, 0x2e, 0x7e, 0x2f,
0x36, 0xbd, 0xcc, 0xa1, 0x9b, 0x72, 0xa5, 0x1a, 0xa9, 0x59, 0xc4, 0xa0, 0xd6, 0xc3, 0xb7, 0xce,
0xc2, 0x27, 0xea, 0xa6, 0xbf, 0xd7, 0xda, 0x9d, 0x37, 0x9c, 0xc6, 0x42, 0xdd, 0xa9, 0x3b, 0xed,
0x8f, 0x41, 0x74, 0xc4, 0x06, 0xec, 0x97, 0xf8, 0x20, 0x94, 0x0e, 0xa4, 0xd3, 0x91, 0x5f, 0x8f,
0x8a, 0xeb, 0x30, 0x21, 0x94, 0x75, 0x76, 0x23, 0xcd, 0xfb, 0x70, 0x74, 0xe4, 0xad, 0x44, 0xfe,
0x07, 0x6f, 0xb2, 0x4a, 0xa7, 0x8d, 0x0b, 0x28, 0x9d, 0xe3, 0x9d, 0x7a, 0x51, 0x83, 0xa7, 0x3a,
0xf8, 0xf8, 0xd1, 0x24, 0x6e, 0x04, 0xe3, 0x8f, 0x04, 0xe3, 0x44, 0x88, 0x71, 0x4b, 0x40, 0x8b,
0x65, 0x18, 0x3d, 0x0e, 0xd7, 0x5f, 0x09, 0xae, 0x2c, 0x09, 0x93, 0x2c, 0xc3, 0x18, 0x23, 0x31,
0x5a, 0x9e, 0xef, 0x34, 0x58, 0xde, 0x3b, 0x9a, 0xe6, 0xaf, 0xdf, 0xe4, 0x67, 0x25, 0x47, 0x61,
0xe5, 0x00, 0x55, 0xfc, 0x2c, 0x4c, 0x52, 0x09, 0x4b, 0x2d, 0x61, 0xb6, 0xe8, 0x7b, 0x94, 0xfc,
0x4f, 0x5e, 0xe6, 0x47, 0x6a, 0x22, 0x20, 0x08, 0xf1, 0x86, 0x76, 0xa2, 0x4e, 0x7c, 0x9f, 0xb8,
0x9e, 0x8e, 0x2d, 0x0b, 0x1d, 0xf9, 0x85, 0x26, 0xff, 0xb5, 0xb7, 0x3b, 0x77, 0x62, 0x99, 0x23,
0x4b, 0x96, 0x55, 0xdc, 0x81, 0x13, 0x7d, 0x76, 0x76, 0x00, 0xce, 0x57, 0x04, 0xe7, 0x64, 0xcf,
0xee, 0x52, 0xda, 0x4d, 0x90, 0xf2, 0x60, 0x3f, 0x06, 0xe0, 0xfc, 0xba, 0xe0, 0x44, 0x02, 0x2b,
0xb7, 0x85, 0x32, 0xde, 0x80, 0xf1, 0xbb, 0xc4, 0xdd, 0x75, 0x3c, 0xf1, 0xf2, 0x3f, 0x00, 0xdd,
0xab, 0x82, 0x6e, 0x4c, 0x00, 0xd9, 0x55, 0x00, 0xe5, 0xba, 0x02, 0xa9, 0x1a, 0x36, 0xc8, 0x00,
0x14, 0xdf, 0x10, 0x14, 0x23, 0x54, 0x9f, 0x42, 0x4b, 0x90, 0xad, 0x3b, 0xa2, 0xba, 0x44, 0xc3,
0xbf, 0x29, 0xe0, 0x19, 0x89, 0x11, 0x14, 0x4d, 0xa7, 0xd9, 0xb2, 0x68, 0xe9, 0x89, 0xa6, 0xf8,
0x96, 0xa4, 0x90, 0x18, 0x41, 0x71, 0x0c, 0xb7, 0x7e, 0x5b, 0x52, 0x78, 0x21, 0x7f, 0x5e, 0x83,
0x8c, 0x63, 0x5b, 0xfb, 0x8e, 0x3d, 0x88, 0x11, 0xbf, 0x29, 0x18, 0x40, 0x40, 0x28, 0xc1, 0x55,
0x48, 0x0f, 0xba, 0x11, 0xbf, 0x25, 0xe0, 0x29, 0x22, 0x77, 0x60, 0x19, 0xc6, 0x64, 0x92, 0x31,
0x1d, 0x7b, 0x00, 0x8a, 0xdf, 0x16, 0x14, 0xb9, 0x10, 0x4c, 0x2c, 0xc3, 0x27, 0x9e, 0x5f, 0x27,
0x83, 0x90, 0xbc, 0x26, 0x97, 0x21, 0x20, 0xc2, 0x95, 0xbb, 0xc4, 0x36, 0xf6, 0x06, 0x63, 0xf8,
0xae, 0x74, 0xa5, 0xc4, 0x50, 0x8a, 0x32, 0x8c, 0x36, 0xb0, 0xeb, 0xed, 0x61, 0x6b, 0xa0, 0xed,
0xf8, 0x1d, 0xc1, 0x91, 0x0d, 0x40, 0xc2, 0x23, 0x2d, 0xfb, 0x38, 0x34, 0xdf, 0x93, 0x1e, 0x09,
0xc1, 0xc4, 0xd1, 0xf3, 0x7c, 0x76, 0xbf, 0x72, 0x1c, 0xb6, 0xdf, 0x95, 0x47, 0x8f, 0x63, 0xd7,
0xc2, 0x8c, 0x57, 0x21, 0xed, 0x99, 0x0f, 0x06, 0xa2, 0xf9, 0x3d, 0xb9, 0xd3, 0x0c, 0x40, 0xc1,
0xb7, 0xe0, 0x64, 0xdf, 0x54, 0x3f, 0x00, 0xd9, 0xef, 0x0b, 0xb2, 0xa9, 0x3e, 0xe9, 0x5e, 0xa4,
0x84, 0xe3, 0x52, 0xfe, 0x81, 0x4c, 0x09, 0xa4, 0x8b, 0x6b, 0x93, 0x76, 0xe7, 0x1e, 0xae, 0x1d,
0xcf, 0x6b, 0x7f, 0x28, 0xbd, 0xc6, 0xb1, 0x1d, 0x5e, 0xdb, 0x86, 0x29, 0xc1, 0x78, 0xbc, 0x7d,
0xfd, 0xbe, 0x4c, 0xac, 0x1c, 0xbd, 0xd3, 0xb9, 0xbb, 0x9f, 0x87, 0xe9, 0xc0, 0x9d, 0xb2, 0xb1,
0xf4, 0xf4, 0x06, 0x6e, 0x0e, 0xc0, 0xfc, 0x03, 0xc1, 0x2c, 0x33, 0x7e, 0xd0, 0x99, 0x7a, 0x6b,
0xb8, 0x49, 0xc9, 0x6f, 0x42, 0x5e, 0x92, 0xb7, 0x6c, 0x97, 0x18, 0x4e, 0xdd, 0x36, 0x1f, 0x90,
0xea, 0x00, 0xd4, 0x7f, 0xd4, 0xb5, 0x55, 0x3b, 0x21, 0x38, 0x65, 0x5e, 0x01, 0x35, 0xe8, 0x37,
0x74, 0xb3, 0xd1, 0x74, 0x5c, 0x3f, 0x82, 0xf1, 0x8f, 0xe5, 0x4e, 0x05, 0xb8, 0x15, 0x06, 0x2b,
0x56, 0x20, 0xc7, 0x86, 0x83, 0x86, 0xe4, 0x9f, 0x08, 0xa2, 0xd1, 0x36, 0x4a, 0x24, 0x0e, 0xc3,
0x69, 0x34, 0xb1, 0x3b, 0x48, 0xfe, 0xfb, 0x53, 0x99, 0x38, 0x04, 0x84, 0x47, 0xdf, 0x58, 0x57,
0x25, 0x46, 0x51, 0x1f, 0xaf, 0xf3, 0x5f, 0x78, 0x2c, 0xce, 0x6c, 0x67, 0x21, 0x2e, 0xae, 0x52,
0xf7, 0x74, 0x96, 0xcb, 0x68, 0xb2, 0x97, 0x1f, 0x07, 0x1e, 0xea, 0xa8, 0x96, 0xc5, 0xeb, 0x30,
0xda, 0x51, 0x2a, 0xa3, 0xa9, 0xbe, 0x28, 0xa8, 0xb2, 0xe1, 0x4a, 0x59, 0xbc, 0x08, 0x09, 0x5a,
0xf6, 0xa2, 0xe1, 0x3f, 0x2b, 0xe0, 0x4c, 0xbd, 0xf8, 0x29, 0x48, 0xc9, 0x72, 0x17, 0x0d, 0xfd,
0x39, 0x01, 0x0d, 0x20, 0x14, 0x2e, 0x4b, 0x5d, 0x34, 0xfc, 0xe7, 0x25, 0x5c, 0x42, 0x28, 0x7c,
0x70, 0x17, 0xfe, 0xf0, 0xcb, 0x09, 0x91, 0xae, 0xa4, 0xef, 0xae, 0xc2, 0x88, 0xa8, 0x71, 0xd1,
0xe8, 0x2f, 0x89, 0x87, 0x4b, 0x44, 0xf1, 0x45, 0x48, 0x0e, 0xe8, 0xf0, 0x5f, 0x14, 0x50, 0xae,
0x5f, 0x2c, 0x43, 0x26, 0x54, 0xd7, 0xa2, 0xe1, 0xbf, 0x24, 0xe0, 0x61, 0x14, 0x35, 0x5d, 0xd4,
0xb5, 0x68, 0x82, 0x5f, 0x96, 0xa6, 0x0b, 0x04, 0x75, 0x9b, 0x2c, 0x69, 0xd1, 0xe8, 0x5f, 0x91,
0x5e, 0x97, 0x90, 0xe2, 0x35, 0x48, 0x07, 0x69, 0x2a, 0x1a, 0xff, 0xab, 0x02, 0xdf, 0xc6, 0x50,
0x0f, 0x84, 0xd2, 0x64, 0x34, 0xc5, 0xaf, 0x49, 0x0f, 0x84, 0x50, 0xf4, 0x18, 0x75, 0x97, 0xbe,
0x68, 0xa6, 0x5f, 0x97, 0xc7, 0xa8, 0xab, 0xf2, 0xd1, 0xdd, 0x64, 0xd9, 0x22, 0x9a, 0xe2, 0x2b,
0x72, 0x37, 0x99, 0x3e, 0x35, 0xa3, 0xbb, 0x96, 0x44, 0x73, 0xfc, 0x86, 0x34, 0xa3, 0xab, 0x94,
0x14, 0x37, 0x01, 0xf5, 0xd6, 0x91, 0x68, 0xbe, 0xaf, 0x0a, 0xbe, 0xf1, 0x9e, 0x32, 0x52, 0x7c,
0x09, 0xa6, 0xfa, 0xd7, 0x90, 0x68, 0xd6, 0xaf, 0x3d, 0xee, 0xea, 0xfa, 0xc3, 0x25, 0xa4, 0xb8,
0xdd, 0xee, 0xfa, 0xc3, 0xf5, 0x23, 0x9a, 0xf6, 0x95, 0xc7, 0x9d, 0x2f, 0x76, 0xe1, 0xf2, 0x51,
0x2c, 0x01, 0xb4, 0x53, 0x77, 0x34, 0xd7, 0xab, 0x82, 0x2b, 0x04, 0xa2, 0x47, 0x43, 0x64, 0xee,
0x68, 0xfc, 0x37, 0xe4, 0xd1, 0x10, 0x88, 0xe2, 0x55, 0x48, 0xd9, 0x2d, 0xcb, 0xa2, 0xc1, 0x81,
0x8e, 0xfe, 0x87, 0x90, 0xfc, 0x3f, 0x3f, 0x11, 0x07, 0x43, 0x02, 0x8a, 0x17, 0x21, 0x49, 0x1a,
0xbb, 0xa4, 0x1a, 0x85, 0xfc, 0x97, 0x27, 0x32, 0x21, 0x50, 0xed, 0xe2, 0x35, 0x00, 0xfe, 0xd2,
0xc8, 0xbe, 0x07, 0x44, 0x60, 0xff, 0xf5, 0x89, 0xf8, 0xd6, 0xdc, 0x86, 0xb4, 0x09, 0xf8, 0x97,
0xeb, 0xa3, 0x09, 0xde, 0xee, 0x24, 0x60, 0x2f, 0x9a, 0x57, 0x60, 0xe4, 0xb6, 0xe7, 0xd8, 0x3e,
0xae, 0x47, 0xa1, 0xff, 0x4d, 0xa0, 0xa5, 0x3e, 0x75, 0x58, 0xc3, 0x71, 0x89, 0x8f, 0xeb, 0x5e,
0x14, 0xf6, 0xdf, 0x05, 0x36, 0x00, 0x50, 0xb0, 0x81, 0x3d, 0x7f, 0x90, 0x75, 0xff, 0x87, 0x04,
0x4b, 0x00, 0x35, 0x9a, 0xfe, 0xbe, 0x43, 0xf6, 0xa3, 0xb0, 0xef, 0x48, 0xa3, 0x85, 0x7e, 0xf1,
0x53, 0x90, 0xa6, 0x3f, 0xf9, 0xff, 0x5f, 0x44, 0x80, 0xff, 0x53, 0x80, 0xdb, 0x08, 0xfa, 0x64,
0xcf, 0xaf, 0xfa, 0x66, 0xb4, 0xb3, 0xff, 0x4b, 0xec, 0xb4, 0xd4, 0x2f, 0x96, 0x20, 0xe3, 0xf9,
0xd5, 0x6a, 0xcb, 0xe5, 0x17, 0x51, 0x11, 0xf0, 0xff, 0x7e, 0x12, 0xbc, 0xcc, 0x05, 0x98, 0xc5,
0x33, 0xfd, 0xef, 0x96, 0x60, 0xd9, 0x59, 0x76, 0xf8, 0xad, 0x12, 0x7c, 0x25, 0x09, 0x1f, 0x33,
0x9c, 0xc6, 0xae, 0xe3, 0x2d, 0xf0, 0x8c, 0x10, 0xe4, 0x83, 0x85, 0x60, 0x15, 0xf2, 0x6a, 0x28,
0x10, 0x4c, 0x1f, 0xef, 0x52, 0x69, 0xf6, 0x2f, 0xe3, 0x90, 0x2a, 0x63, 0xcf, 0xc7, 0xf7, 0xf0,
0x3e, 0x6a, 0xc2, 0x04, 0xfd, 0xbd, 0x86, 0x9b, 0xec, 0x7a, 0x43, 0x1c, 0x33, 0x71, 0x6f, 0xf7,
0xf1, 0xf9, 0xf6, 0x53, 0x25, 0x62, 0xbe, 0x8f, 0x3a, 0xfb, 0x54, 0xb8, 0xa8, 0xbe, 0xfe, 0xf7,
0xa7, 0x87, 0x7e, 0xe1, 0x1f, 0x4e, 0xa7, 0xd6, 0xf6, 0x5f, 0x32, 0x2d, 0xcf, 0xb1, 0xb5, 0x7e,
0xd4, 0xe8, 0x8b, 0x0a, 0x9c, 0xea, 0x23, 0x5f, 0x17, 0x87, 0x51, 0xdc, 0x7e, 0x5f, 0x18, 0xf0,
0xd1, 0x12, 0xc6, 0x4d, 0xc8, 0x76, 0x3c, 0xfe, 0xa8, 0xc7, 0x4c, 0xdf, 0x82, 0xfc, 0x61, 0x2b,
0x41, 0x2a, 0xc4, 0xef, 0x90, 0x7d, 0xf1, 0xcf, 0x7e, 0xf4, 0x27, 0x3a, 0xd7, 0xfe, 0x67, 0x21,
0x65, 0x2e, 0x73, 0x7e, 0x3c, 0x64, 0x9d, 0x78, 0x18, 0x9f, 0x2f, 0xc6, 0x2e, 0x2b, 0xd3, 0x18,
0x66, 0xa2, 0x2c, 0xfd, 0x3f, 0x3e, 0x62, 0xb6, 0x00, 0xc3, 0x5c, 0x88, 0x26, 0x21, 0xb9, 0x62,
0xfb, 0x97, 0x2e, 0x30, 0xaa, 0xb8, 0xc6, 0x07, 0x8b, 0xab, 0xaf, 0x3f, 0x2a, 0x0c, 0xfd, 0xf8,
0x51, 0x61, 0xe8, 0x6f, 0x1f, 0x15, 0x86, 0xde, 0x78, 0x54, 0x50, 0xde, 0x7a, 0x54, 0x50, 0xde,
0x79, 0x54, 0x50, 0xde, 0x7d, 0x54, 0x50, 0x1e, 0x1e, 0x14, 0x94, 0xef, 0x1e, 0x14, 0x94, 0xef,
0x1f, 0x14, 0x94, 0x3f, 0x3f, 0x28, 0x28, 0x3f, 0x3c, 0x28, 0x28, 0xaf, 0x1f, 0x14, 0x86, 0x7e,
0x7c, 0x50, 0x18, 0x7a, 0xe3, 0xa0, 0xa0, 0xbc, 0x75, 0x50, 0x18, 0x7a, 0xe7, 0xa0, 0xa0, 0xbc,
0x7b, 0x50, 0x50, 0x1e, 0xfe, 0x63, 0x61, 0xe8, 0x7f, 0x03, 0x00, 0x00, 0xff, 0xff, 0xc8, 0x56,
0x22, 0x83, 0xbd, 0x2e, 0x00, 0x00,
}
r := bytes.NewReader(gzipped)
gzipr, err := compress_gzip.NewReader(r)
@@ -599,11 +608,12 @@ func valueToGoStringCastvalue(v interface{}, typ string) string {
pv := reflect.Indirect(rv).Interface()
return fmt.Sprintf("func(v %v) *%v { return &v } ( %#v )", typ, typ, pv)
}
func extensionToGoStringCastvalue(e map[int32]github_com_gogo_protobuf_proto.Extension) string {
func extensionToGoStringCastvalue(m github_com_gogo_protobuf_proto.Message) string {
e := github_com_gogo_protobuf_proto.GetUnsafeExtensionsMap(m)
if e == nil {
return "nil"
}
s := "map[int32]proto.Extension{"
s := "proto.NewUnsafeXXX_InternalExtensions(map[int32]proto.Extension{"
keys := make([]int, 0, len(e))
for k := range e {
keys = append(keys, int(k))
@@ -613,7 +623,7 @@ func extensionToGoStringCastvalue(e map[int32]github_com_gogo_protobuf_proto.Ext
for _, k := range keys {
ss = append(ss, strconv.Itoa(k)+": "+e[int32(k)].GoString())
}
s += strings.Join(ss, ",") + "}"
s += strings.Join(ss, ",") + "})"
return s
}
func NewPopulatedCastaway(r randyCastvalue, easy bool) *Castaway {
@@ -679,7 +689,7 @@ func randStringCastvalue(r randyCastvalue) string {
}
return string(tmps)
}
func randUnrecognizedCastvalue(r randyCastvalue, maxFieldNumber int) (data []byte) {
func randUnrecognizedCastvalue(r randyCastvalue, maxFieldNumber int) (dAtA []byte) {
l := r.Intn(5)
for i := 0; i < l; i++ {
wire := r.Intn(4)
@@ -687,43 +697,43 @@ func randUnrecognizedCastvalue(r randyCastvalue, maxFieldNumber int) (data []byt
wire = 5
}
fieldNumber := maxFieldNumber + r.Intn(100)
data = randFieldCastvalue(data, r, fieldNumber, wire)
dAtA = randFieldCastvalue(dAtA, r, fieldNumber, wire)
}
return data
return dAtA
}
func randFieldCastvalue(data []byte, r randyCastvalue, fieldNumber int, wire int) []byte {
func randFieldCastvalue(dAtA []byte, r randyCastvalue, fieldNumber int, wire int) []byte {
key := uint32(fieldNumber)<<3 | uint32(wire)
switch wire {
case 0:
data = encodeVarintPopulateCastvalue(data, uint64(key))
dAtA = encodeVarintPopulateCastvalue(dAtA, uint64(key))
v5 := r.Int63()
if r.Intn(2) == 0 {
v5 *= -1
}
data = encodeVarintPopulateCastvalue(data, uint64(v5))
dAtA = encodeVarintPopulateCastvalue(dAtA, uint64(v5))
case 1:
data = encodeVarintPopulateCastvalue(data, uint64(key))
data = append(data, byte(r.Intn(256)), byte(r.Intn(256)), byte(r.Intn(256)), byte(r.Intn(256)), byte(r.Intn(256)), byte(r.Intn(256)), byte(r.Intn(256)), byte(r.Intn(256)))
dAtA = encodeVarintPopulateCastvalue(dAtA, uint64(key))
dAtA = append(dAtA, byte(r.Intn(256)), byte(r.Intn(256)), byte(r.Intn(256)), byte(r.Intn(256)), byte(r.Intn(256)), byte(r.Intn(256)), byte(r.Intn(256)), byte(r.Intn(256)))
case 2:
data = encodeVarintPopulateCastvalue(data, uint64(key))
dAtA = encodeVarintPopulateCastvalue(dAtA, uint64(key))
ll := r.Intn(100)
data = encodeVarintPopulateCastvalue(data, uint64(ll))
dAtA = encodeVarintPopulateCastvalue(dAtA, uint64(ll))
for j := 0; j < ll; j++ {
data = append(data, byte(r.Intn(256)))
dAtA = append(dAtA, byte(r.Intn(256)))
}
default:
data = encodeVarintPopulateCastvalue(data, uint64(key))
data = append(data, byte(r.Intn(256)), byte(r.Intn(256)), byte(r.Intn(256)), byte(r.Intn(256)))
dAtA = encodeVarintPopulateCastvalue(dAtA, uint64(key))
dAtA = append(dAtA, byte(r.Intn(256)), byte(r.Intn(256)), byte(r.Intn(256)), byte(r.Intn(256)))
}
return data
return dAtA
}
func encodeVarintPopulateCastvalue(data []byte, v uint64) []byte {
func encodeVarintPopulateCastvalue(dAtA []byte, v uint64) []byte {
for v >= 1<<7 {
data = append(data, uint8(uint64(v)&0x7f|0x80))
dAtA = append(dAtA, uint8(uint64(v)&0x7f|0x80))
v >>= 7
}
data = append(data, uint8(v))
return data
dAtA = append(dAtA, uint8(v))
return dAtA
}
func (m *Castaway) Size() (n int) {
var l int
@@ -744,8 +754,9 @@ func (m *Castaway) Size() (n int) {
l = 0
if v != nil {
l = ((*Wilson)(v)).Size()
l += 1 + sovCastvalue(uint64(l))
}
mapEntrySize := 1 + sovCastvalue(uint64(k)) + 1 + l + sovCastvalue(uint64(l))
mapEntrySize := 1 + sovCastvalue(uint64(k)) + l
n += mapEntrySize + 1 + sovCastvalue(uint64(mapEntrySize))
}
}
@@ -831,36 +842,40 @@ func valueToStringCastvalue(v interface{}) string {
pv := reflect.Indirect(rv).Interface()
return fmt.Sprintf("*%v", pv)
}
func (m *Castaway) Marshal() (data []byte, err error) {
func (m *Castaway) Marshal() (dAtA []byte, err error) {
size := m.Size()
data = make([]byte, size)
n, err := m.MarshalTo(data)
dAtA = make([]byte, size)
n, err := m.MarshalTo(dAtA)
if err != nil {
return nil, err
}
return data[:n], nil
return dAtA[:n], nil
}
func (m *Castaway) MarshalTo(data []byte) (int, error) {
func (m *Castaway) MarshalTo(dAtA []byte) (int, error) {
var i int
_ = i
var l int
_ = l
if len(m.CastMapValueMessage) > 0 {
for k := range m.CastMapValueMessage {
data[i] = 0xa
dAtA[i] = 0xa
i++
v := m.CastMapValueMessage[k]
msgSize := ((*Wilson)(&v)).Size()
mapSize := 1 + sovCastvalue(uint64(k)) + 1 + msgSize + sovCastvalue(uint64(msgSize))
i = encodeVarintCastvalue(data, i, uint64(mapSize))
data[i] = 0x8
msgSize := 0
if ((*Wilson)(&v)) != nil {
msgSize = ((*Wilson)(&v)).Size()
msgSize += 1 + sovCastvalue(uint64(msgSize))
}
mapSize := 1 + sovCastvalue(uint64(k)) + msgSize
i = encodeVarintCastvalue(dAtA, i, uint64(mapSize))
dAtA[i] = 0x8
i++
i = encodeVarintCastvalue(data, i, uint64(k))
data[i] = 0x12
i = encodeVarintCastvalue(dAtA, i, uint64(k))
dAtA[i] = 0x12
i++
i = encodeVarintCastvalue(data, i, uint64(((*Wilson)(&v)).Size()))
n1, err := ((*Wilson)(&v)).MarshalTo(data[i:])
i = encodeVarintCastvalue(dAtA, i, uint64(((*Wilson)(&v)).Size()))
n1, err := ((*Wilson)(&v)).MarshalTo(dAtA[i:])
if err != nil {
return 0, err
}
@@ -869,110 +884,116 @@ func (m *Castaway) MarshalTo(data []byte) (int, error) {
}
if len(m.CastMapValueMessageNullable) > 0 {
for k := range m.CastMapValueMessageNullable {
data[i] = 0x12
dAtA[i] = 0x12
i++
v := m.CastMapValueMessageNullable[k]
if v == nil {
return 0, errors.New("proto: map has nil element")
msgSize := 0
if ((*Wilson)(v)) != nil {
msgSize = ((*Wilson)(v)).Size()
msgSize += 1 + sovCastvalue(uint64(msgSize))
}
msgSize := ((*Wilson)(v)).Size()
mapSize := 1 + sovCastvalue(uint64(k)) + 1 + msgSize + sovCastvalue(uint64(msgSize))
i = encodeVarintCastvalue(data, i, uint64(mapSize))
data[i] = 0x8
mapSize := 1 + sovCastvalue(uint64(k)) + msgSize
i = encodeVarintCastvalue(dAtA, i, uint64(mapSize))
dAtA[i] = 0x8
i++
i = encodeVarintCastvalue(data, i, uint64(k))
data[i] = 0x12
i++
i = encodeVarintCastvalue(data, i, uint64(((*Wilson)(v)).Size()))
n2, err := ((*Wilson)(v)).MarshalTo(data[i:])
if err != nil {
return 0, err
i = encodeVarintCastvalue(dAtA, i, uint64(k))
if ((*Wilson)(v)) != nil {
dAtA[i] = 0x12
i++
i = encodeVarintCastvalue(dAtA, i, uint64(((*Wilson)(v)).Size()))
n2, err := ((*Wilson)(v)).MarshalTo(dAtA[i:])
if err != nil {
return 0, err
}
i += n2
}
i += n2
}
}
if m.XXX_unrecognized != nil {
i += copy(data[i:], m.XXX_unrecognized)
i += copy(dAtA[i:], m.XXX_unrecognized)
}
return i, nil
}
func (m *Wilson) Marshal() (data []byte, err error) {
func (m *Wilson) Marshal() (dAtA []byte, err error) {
size := m.Size()
data = make([]byte, size)
n, err := m.MarshalTo(data)
dAtA = make([]byte, size)
n, err := m.MarshalTo(dAtA)
if err != nil {
return nil, err
}
return data[:n], nil
return dAtA[:n], nil
}
func (m *Wilson) MarshalTo(data []byte) (int, error) {
func (m *Wilson) MarshalTo(dAtA []byte) (int, error) {
var i int
_ = i
var l int
_ = l
if m.Int64 != nil {
data[i] = 0x8
dAtA[i] = 0x8
i++
i = encodeVarintCastvalue(data, i, uint64(*m.Int64))
i = encodeVarintCastvalue(dAtA, i, uint64(*m.Int64))
}
if m.XXX_unrecognized != nil {
i += copy(data[i:], m.XXX_unrecognized)
i += copy(dAtA[i:], m.XXX_unrecognized)
}
return i, nil
}
func encodeFixed64Castvalue(data []byte, offset int, v uint64) int {
data[offset] = uint8(v)
data[offset+1] = uint8(v >> 8)
data[offset+2] = uint8(v >> 16)
data[offset+3] = uint8(v >> 24)
data[offset+4] = uint8(v >> 32)
data[offset+5] = uint8(v >> 40)
data[offset+6] = uint8(v >> 48)
data[offset+7] = uint8(v >> 56)
func encodeFixed64Castvalue(dAtA []byte, offset int, v uint64) int {
dAtA[offset] = uint8(v)
dAtA[offset+1] = uint8(v >> 8)
dAtA[offset+2] = uint8(v >> 16)
dAtA[offset+3] = uint8(v >> 24)
dAtA[offset+4] = uint8(v >> 32)
dAtA[offset+5] = uint8(v >> 40)
dAtA[offset+6] = uint8(v >> 48)
dAtA[offset+7] = uint8(v >> 56)
return offset + 8
}
func encodeFixed32Castvalue(data []byte, offset int, v uint32) int {
data[offset] = uint8(v)
data[offset+1] = uint8(v >> 8)
data[offset+2] = uint8(v >> 16)
data[offset+3] = uint8(v >> 24)
func encodeFixed32Castvalue(dAtA []byte, offset int, v uint32) int {
dAtA[offset] = uint8(v)
dAtA[offset+1] = uint8(v >> 8)
dAtA[offset+2] = uint8(v >> 16)
dAtA[offset+3] = uint8(v >> 24)
return offset + 4
}
func encodeVarintCastvalue(data []byte, offset int, v uint64) int {
func encodeVarintCastvalue(dAtA []byte, offset int, v uint64) int {
for v >= 1<<7 {
data[offset] = uint8(v&0x7f | 0x80)
dAtA[offset] = uint8(v&0x7f | 0x80)
v >>= 7
offset++
}
data[offset] = uint8(v)
dAtA[offset] = uint8(v)
return offset + 1
}
func init() { proto.RegisterFile("combos/unsafemarshaler/castvalue.proto", fileDescriptorCastvalue) }
var fileDescriptorCastvalue = []byte{
// 343 bytes of a gzipped FileDescriptorProto
0x1f, 0x8b, 0x08, 0x00, 0x00, 0x09, 0x6e, 0x88, 0x02, 0xff, 0xe2, 0x52, 0x4b, 0xce, 0xcf, 0x4d,
0xca, 0x2f, 0xd6, 0x2f, 0xcd, 0x2b, 0x4e, 0x4c, 0x4b, 0xcd, 0x4d, 0x2c, 0x2a, 0xce, 0x48, 0xcc,
0x49, 0x2d, 0xd2, 0x4f, 0x4e, 0x2c, 0x2e, 0x29, 0x4b, 0xcc, 0x29, 0x4d, 0xd5, 0x2b, 0x28, 0xca,
0x2f, 0xc9, 0x17, 0xe2, 0x84, 0x0b, 0x48, 0xe9, 0xa6, 0x67, 0x96, 0x64, 0x94, 0x26, 0xe9, 0x01,
0x75, 0xea, 0xa7, 0xe7, 0xa7, 0xe7, 0xeb, 0x83, 0x55, 0x24, 0x95, 0xa6, 0x81, 0x79, 0x60, 0x0e,
0x98, 0x05, 0xd1, 0xa9, 0x74, 0x90, 0x99, 0x8b, 0xc3, 0x19, 0xa8, 0x39, 0xb1, 0x3c, 0xb1, 0x52,
0xa8, 0x80, 0x4b, 0x18, 0xc4, 0xf6, 0x4d, 0x2c, 0x08, 0x03, 0x99, 0xe5, 0x9b, 0x5a, 0x5c, 0x9c,
0x98, 0x9e, 0x2a, 0xc1, 0xa8, 0xc0, 0xac, 0xc1, 0x6d, 0xa4, 0xa3, 0x87, 0xb0, 0x15, 0xa6, 0x43,
0x0f, 0x8b, 0x72, 0xd7, 0xbc, 0x92, 0xa2, 0x4a, 0x27, 0x81, 0x13, 0xf7, 0xe4, 0x19, 0xba, 0xee,
0xcb, 0x73, 0xf8, 0x56, 0x86, 0x67, 0xe6, 0x14, 0xe7, 0xe7, 0x05, 0x09, 0x27, 0x63, 0xaa, 0x15,
0x6a, 0x61, 0xe4, 0x92, 0xc6, 0x62, 0x86, 0x5f, 0x69, 0x4e, 0x4e, 0x62, 0x52, 0x4e, 0xaa, 0x04,
0x13, 0xd8, 0x6a, 0x13, 0x22, 0xad, 0x86, 0x69, 0x83, 0x38, 0x81, 0x07, 0xc5, 0x7a, 0xe9, 0x64,
0xdc, 0xea, 0xa5, 0x22, 0xb9, 0x24, 0x70, 0xf9, 0x44, 0x48, 0x80, 0x8b, 0x39, 0x3b, 0xb5, 0x12,
0x18, 0x08, 0x8c, 0x1a, 0xac, 0x41, 0x20, 0xa6, 0x90, 0x3a, 0x17, 0x2b, 0xd8, 0x2d, 0x40, 0xd7,
0x31, 0x02, 0x5d, 0x27, 0x88, 0xe4, 0x3a, 0xa8, 0x65, 0x10, 0x79, 0x2b, 0x26, 0x0b, 0x46, 0xa9,
0x44, 0x2e, 0x05, 0x42, 0x2e, 0xa5, 0xd0, 0x0a, 0x25, 0x39, 0x2e, 0x36, 0x88, 0xa0, 0x90, 0x08,
0x17, 0xab, 0x67, 0x5e, 0x89, 0x99, 0x09, 0xd8, 0x28, 0xe6, 0x20, 0xd6, 0x4c, 0x10, 0xc7, 0xc9,
0xe7, 0xc4, 0x43, 0x39, 0x86, 0x0b, 0x40, 0x7c, 0x03, 0x88, 0x1f, 0x3c, 0x94, 0x63, 0x7c, 0x01,
0xc4, 0x1f, 0x80, 0xf8, 0x07, 0x10, 0x37, 0x3c, 0x92, 0x63, 0x5c, 0x01, 0xc4, 0x1b, 0x80, 0x78,
0x07, 0x10, 0x1f, 0x00, 0xe2, 0x13, 0x8f, 0x80, 0xea, 0x81, 0xf8, 0x01, 0x90, 0xfd, 0x02, 0x48,
0x7f, 0x00, 0xd2, 0x3f, 0x80, 0xb8, 0xe1, 0xb1, 0x1c, 0x03, 0x20, 0x00, 0x00, 0xff, 0xff, 0x29,
0x83, 0xc1, 0xb7, 0x94, 0x02, 0x00, 0x00,
// 364 bytes of a gzipped FileDescriptorProto
0x1f, 0x8b, 0x08, 0x00, 0x00, 0x09, 0x6e, 0x88, 0x02, 0xff, 0xa4, 0x8f, 0xbd, 0x4f, 0xea, 0x50,
0x18, 0xc6, 0xcf, 0x4b, 0xc3, 0x0d, 0xf7, 0x70, 0x07, 0x6e, 0xef, 0x1d, 0x1a, 0x4c, 0x5e, 0x1a,
0x06, 0x65, 0xd0, 0x36, 0x21, 0xc4, 0x18, 0x47, 0x8c, 0x83, 0x89, 0x38, 0x30, 0x68, 0x1c, 0x4f,
0x49, 0x29, 0xc4, 0xd2, 0x43, 0x7a, 0x5a, 0x4d, 0x37, 0x06, 0x27, 0xff, 0x12, 0x47, 0x47, 0x47,
0xdd, 0x18, 0x19, 0x9d, 0x94, 0x1e, 0x17, 0x46, 0x46, 0x46, 0x43, 0x2b, 0x7e, 0x24, 0xf8, 0x91,
0xb8, 0xbd, 0xef, 0x73, 0xde, 0xe7, 0xf9, 0x3d, 0x87, 0xae, 0xb6, 0x78, 0xcf, 0xe2, 0xc2, 0x0c,
0x3d, 0xc1, 0xda, 0x76, 0x8f, 0xf9, 0xa2, 0xc3, 0x5c, 0xdb, 0x37, 0x5b, 0x4c, 0x04, 0xa7, 0xcc,
0x0d, 0x6d, 0xa3, 0xef, 0xf3, 0x80, 0xab, 0xbf, 0x5f, 0x84, 0xe2, 0x86, 0xd3, 0x0d, 0x3a, 0xa1,
0x65, 0xb4, 0x78, 0xcf, 0x74, 0xb8, 0xc3, 0xcd, 0xe4, 0xc2, 0x0a, 0xdb, 0xc9, 0x96, 0x2c, 0xc9,
0x94, 0x3a, 0xcb, 0xb7, 0x0a, 0xcd, 0xed, 0x30, 0x11, 0xb0, 0x33, 0x16, 0xa9, 0x7d, 0xfa, 0x6f,
0x3e, 0x37, 0x58, 0xff, 0x70, 0x9e, 0xd5, 0xb0, 0x85, 0x60, 0x8e, 0xad, 0x81, 0xae, 0x54, 0xf2,
0xd5, 0x75, 0xe3, 0x95, 0xba, 0x70, 0x18, 0x4b, 0xce, 0x77, 0xbd, 0xc0, 0x8f, 0xea, 0x85, 0xe1,
0x7d, 0x89, 0x5c, 0x3c, 0x94, 0x72, 0x8d, 0xe8, 0xa8, 0xeb, 0x0a, 0xee, 0x35, 0x97, 0x45, 0xab,
0xe7, 0x40, 0x57, 0x96, 0xe8, 0x07, 0xa1, 0xeb, 0x32, 0xcb, 0xb5, 0xb5, 0x4c, 0x82, 0xae, 0x7d,
0x13, 0xbd, 0xb0, 0xa5, 0x15, 0xfe, 0xbc, 0xc3, 0x7f, 0x86, 0x29, 0x1e, 0x53, 0xed, 0xa3, 0x9f,
0xa8, 0x05, 0xaa, 0x9c, 0xd8, 0x91, 0x06, 0x3a, 0x54, 0xb2, 0xcd, 0xf9, 0xa8, 0xae, 0xd1, 0x6c,
0xd2, 0x45, 0xcb, 0xe8, 0x50, 0xc9, 0x57, 0xff, 0xbe, 0x69, 0xf7, 0x0c, 0x4b, 0xdf, 0xb7, 0x33,
0x5b, 0x50, 0x64, 0x54, 0xff, 0xaa, 0xe9, 0x0f, 0x11, 0x65, 0xa4, 0xbf, 0x52, 0x51, 0xfd, 0x4f,
0xb3, 0x7b, 0x5e, 0xb0, 0x59, 0x4b, 0xa2, 0x94, 0x66, 0xba, 0xd4, 0xf7, 0x87, 0x31, 0x92, 0x51,
0x8c, 0xe4, 0x2e, 0x46, 0x32, 0x8e, 0x11, 0x26, 0x31, 0xc2, 0x34, 0x46, 0x98, 0xc5, 0x08, 0x03,
0x89, 0x70, 0x29, 0x11, 0xae, 0x24, 0xc2, 0xb5, 0x44, 0xb8, 0x91, 0x08, 0x43, 0x89, 0x64, 0x24,
0x91, 0x8c, 0x25, 0xc2, 0x44, 0x22, 0x99, 0x4a, 0x84, 0x99, 0x44, 0x18, 0x3c, 0x22, 0x79, 0x0a,
0x00, 0x00, 0xff, 0xff, 0xff, 0x17, 0xd9, 0xa7, 0x94, 0x02, 0x00, 0x00,
}

66
vendor/github.com/gogo/protobuf/test/castvalue/combos/unsafemarshaler/castvalue.proto generated vendored Normal file
View File

@@ -0,0 +1,66 @@
// Protocol Buffers for Go with Gadgets
//
// Copyright (c) 2015, 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.
syntax = "proto2";
package castvalue;
import "github.com/gogo/protobuf/gogoproto/gogo.proto";
option (gogoproto.goproto_stringer_all) = false;
option (gogoproto.goproto_enum_prefix_all) = false;
option (gogoproto.goproto_getters_all) = false;
option (gogoproto.equal_all) = true;
option (gogoproto.verbose_equal_all) = true;
option (gogoproto.stringer_all) = true;
option (gogoproto.gostring_all) = true;
option (gogoproto.face_all) = true;
option (gogoproto.description_all) = true;
option (gogoproto.testgen_all) = true;
option (gogoproto.populate_all) = true;
option (gogoproto.benchgen_all) = true;
option (gogoproto.unmarshaler_all) = false;
option (gogoproto.marshaler_all) = false;
option (gogoproto.sizer_all) = true;
option (gogoproto.goproto_enum_stringer_all) = false;
option (gogoproto.enum_stringer_all) = true;
option (gogoproto.unsafe_marshaler_all) = true;
option (gogoproto.unsafe_unmarshaler_all) = false;
message Castaway {
map<int32,Wilson> CastMapValueMessage = 1 [(gogoproto.castvalue) = "MyWilson", (gogoproto.nullable) = false];
map<int32,Wilson> CastMapValueMessageNullable = 2 [(gogoproto.castvalue) = "MyWilson"];
}
message Wilson {
optional int64 Int64 = 1;
}

513
vendor/github.com/gogo/protobuf/test/castvalue/combos/unsafemarshaler/castvaluepb_test.go generated vendored Normal file
View File

@@ -0,0 +1,513 @@
// Code generated by protoc-gen-gogo.
// source: combos/unsafemarshaler/castvalue.proto
// DO NOT EDIT!
/*
Package castvalue is a generated protocol buffer package.
It is generated from these files:
combos/unsafemarshaler/castvalue.proto
It has these top-level messages:
Castaway
Wilson
*/
package castvalue
import testing "testing"
import math_rand "math/rand"
import time "time"
import github_com_gogo_protobuf_proto "github.com/gogo/protobuf/proto"
import github_com_gogo_protobuf_jsonpb "github.com/gogo/protobuf/jsonpb"
import fmt "fmt"
import go_parser "go/parser"
import proto "github.com/gogo/protobuf/proto"
import math "math"
import _ "github.com/gogo/protobuf/gogoproto"
// Reference imports to suppress errors if they are not otherwise used.
var _ = proto.Marshal
var _ = fmt.Errorf
var _ = math.Inf
func TestCastawayProto(t *testing.T) {
seed := time.Now().UnixNano()
popr := math_rand.New(math_rand.NewSource(seed))
p := NewPopulatedCastaway(popr, false)
dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
if err != nil {
t.Fatalf("seed = %d, err = %v", seed, err)
}
msg := &Castaway{}
if err := github_com_gogo_protobuf_proto.Unmarshal(dAtA, msg); err != nil {
t.Fatalf("seed = %d, err = %v", seed, err)
}
littlefuzz := make([]byte, len(dAtA))
copy(littlefuzz, dAtA)
for i := range dAtA {
dAtA[i] = byte(popr.Intn(256))
}
if err := p.VerboseEqual(msg); err != nil {
t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
}
if !p.Equal(msg) {
t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p)
}
if len(littlefuzz) > 0 {
fuzzamount := 100
for i := 0; i < fuzzamount; i++ {
littlefuzz[popr.Intn(len(littlefuzz))] = byte(popr.Intn(256))
littlefuzz = append(littlefuzz, byte(popr.Intn(256)))
}
// shouldn't panic
_ = github_com_gogo_protobuf_proto.Unmarshal(littlefuzz, msg)
}
}
func TestCastawayMarshalTo(t *testing.T) {
seed := time.Now().UnixNano()
popr := math_rand.New(math_rand.NewSource(seed))
p := NewPopulatedCastaway(popr, false)
size := p.Size()
dAtA := make([]byte, size)
for i := range dAtA {
dAtA[i] = byte(popr.Intn(256))
}
_, err := p.MarshalTo(dAtA)
if err != nil {
t.Fatalf("seed = %d, err = %v", seed, err)
}
msg := &Castaway{}
if err := github_com_gogo_protobuf_proto.Unmarshal(dAtA, msg); err != nil {
t.Fatalf("seed = %d, err = %v", seed, err)
}
for i := range dAtA {
dAtA[i] = byte(popr.Intn(256))
}
if err := p.VerboseEqual(msg); err != nil {
t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
}
if !p.Equal(msg) {
t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p)
}
}
func BenchmarkCastawayProtoMarshal(b *testing.B) {
popr := math_rand.New(math_rand.NewSource(616))
total := 0
pops := make([]*Castaway, 10000)
for i := 0; i < 10000; i++ {
pops[i] = NewPopulatedCastaway(popr, false)
}
b.ResetTimer()
for i := 0; i < b.N; i++ {
dAtA, err := github_com_gogo_protobuf_proto.Marshal(pops[i%10000])
if err != nil {
panic(err)
}
total += len(dAtA)
}
b.SetBytes(int64(total / b.N))
}
func BenchmarkCastawayProtoUnmarshal(b *testing.B) {
popr := math_rand.New(math_rand.NewSource(616))
total := 0
datas := make([][]byte, 10000)
for i := 0; i < 10000; i++ {
dAtA, err := github_com_gogo_protobuf_proto.Marshal(NewPopulatedCastaway(popr, false))
if err != nil {
panic(err)
}
datas[i] = dAtA
}
msg := &Castaway{}
b.ResetTimer()
for i := 0; i < b.N; i++ {
total += len(datas[i%10000])
if err := github_com_gogo_protobuf_proto.Unmarshal(datas[i%10000], msg); err != nil {
panic(err)
}
}
b.SetBytes(int64(total / b.N))
}
func TestWilsonProto(t *testing.T) {
seed := time.Now().UnixNano()
popr := math_rand.New(math_rand.NewSource(seed))
p := NewPopulatedWilson(popr, false)
dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
if err != nil {
t.Fatalf("seed = %d, err = %v", seed, err)
}
msg := &Wilson{}
if err := github_com_gogo_protobuf_proto.Unmarshal(dAtA, msg); err != nil {
t.Fatalf("seed = %d, err = %v", seed, err)
}
littlefuzz := make([]byte, len(dAtA))
copy(littlefuzz, dAtA)
for i := range dAtA {
dAtA[i] = byte(popr.Intn(256))
}
if err := p.VerboseEqual(msg); err != nil {
t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
}
if !p.Equal(msg) {
t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p)
}
if len(littlefuzz) > 0 {
fuzzamount := 100
for i := 0; i < fuzzamount; i++ {
littlefuzz[popr.Intn(len(littlefuzz))] = byte(popr.Intn(256))
littlefuzz = append(littlefuzz, byte(popr.Intn(256)))
}
// shouldn't panic
_ = github_com_gogo_protobuf_proto.Unmarshal(littlefuzz, msg)
}
}
func TestWilsonMarshalTo(t *testing.T) {
seed := time.Now().UnixNano()
popr := math_rand.New(math_rand.NewSource(seed))
p := NewPopulatedWilson(popr, false)
size := p.Size()
dAtA := make([]byte, size)
for i := range dAtA {
dAtA[i] = byte(popr.Intn(256))
}
_, err := p.MarshalTo(dAtA)
if err != nil {
t.Fatalf("seed = %d, err = %v", seed, err)
}
msg := &Wilson{}
if err := github_com_gogo_protobuf_proto.Unmarshal(dAtA, msg); err != nil {
t.Fatalf("seed = %d, err = %v", seed, err)
}
for i := range dAtA {
dAtA[i] = byte(popr.Intn(256))
}
if err := p.VerboseEqual(msg); err != nil {
t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
}
if !p.Equal(msg) {
t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p)
}
}
func BenchmarkWilsonProtoMarshal(b *testing.B) {
popr := math_rand.New(math_rand.NewSource(616))
total := 0
pops := make([]*Wilson, 10000)
for i := 0; i < 10000; i++ {
pops[i] = NewPopulatedWilson(popr, false)
}
b.ResetTimer()
for i := 0; i < b.N; i++ {
dAtA, err := github_com_gogo_protobuf_proto.Marshal(pops[i%10000])
if err != nil {
panic(err)
}
total += len(dAtA)
}
b.SetBytes(int64(total / b.N))
}
func BenchmarkWilsonProtoUnmarshal(b *testing.B) {
popr := math_rand.New(math_rand.NewSource(616))
total := 0
datas := make([][]byte, 10000)
for i := 0; i < 10000; i++ {
dAtA, err := github_com_gogo_protobuf_proto.Marshal(NewPopulatedWilson(popr, false))
if err != nil {
panic(err)
}
datas[i] = dAtA
}
msg := &Wilson{}
b.ResetTimer()
for i := 0; i < b.N; i++ {
total += len(datas[i%10000])
if err := github_com_gogo_protobuf_proto.Unmarshal(datas[i%10000], msg); err != nil {
panic(err)
}
}
b.SetBytes(int64(total / b.N))
}
func TestCastawayJSON(t *testing.T) {
seed := time.Now().UnixNano()
popr := math_rand.New(math_rand.NewSource(seed))
p := NewPopulatedCastaway(popr, true)
marshaler := github_com_gogo_protobuf_jsonpb.Marshaler{}
jsondata, err := marshaler.MarshalToString(p)
if err != nil {
t.Fatalf("seed = %d, err = %v", seed, err)
}
msg := &Castaway{}
err = github_com_gogo_protobuf_jsonpb.UnmarshalString(jsondata, msg)
if err != nil {
t.Fatalf("seed = %d, err = %v", seed, err)
}
if err := p.VerboseEqual(msg); err != nil {
t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
}
if !p.Equal(msg) {
t.Fatalf("seed = %d, %#v !Json Equal %#v", seed, msg, p)
}
}
func TestWilsonJSON(t *testing.T) {
seed := time.Now().UnixNano()
popr := math_rand.New(math_rand.NewSource(seed))
p := NewPopulatedWilson(popr, true)
marshaler := github_com_gogo_protobuf_jsonpb.Marshaler{}
jsondata, err := marshaler.MarshalToString(p)
if err != nil {
t.Fatalf("seed = %d, err = %v", seed, err)
}
msg := &Wilson{}
err = github_com_gogo_protobuf_jsonpb.UnmarshalString(jsondata, msg)
if err != nil {
t.Fatalf("seed = %d, err = %v", seed, err)
}
if err := p.VerboseEqual(msg); err != nil {
t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
}
if !p.Equal(msg) {
t.Fatalf("seed = %d, %#v !Json Equal %#v", seed, msg, p)
}
}
func TestCastawayProtoText(t *testing.T) {
seed := time.Now().UnixNano()
popr := math_rand.New(math_rand.NewSource(seed))
p := NewPopulatedCastaway(popr, true)
dAtA := github_com_gogo_protobuf_proto.MarshalTextString(p)
msg := &Castaway{}
if err := github_com_gogo_protobuf_proto.UnmarshalText(dAtA, msg); err != nil {
t.Fatalf("seed = %d, err = %v", seed, err)
}
if err := p.VerboseEqual(msg); err != nil {
t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
}
if !p.Equal(msg) {
t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p)
}
}
func TestCastawayProtoCompactText(t *testing.T) {
seed := time.Now().UnixNano()
popr := math_rand.New(math_rand.NewSource(seed))
p := NewPopulatedCastaway(popr, true)
dAtA := github_com_gogo_protobuf_proto.CompactTextString(p)
msg := &Castaway{}
if err := github_com_gogo_protobuf_proto.UnmarshalText(dAtA, msg); err != nil {
t.Fatalf("seed = %d, err = %v", seed, err)
}
if err := p.VerboseEqual(msg); err != nil {
t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
}
if !p.Equal(msg) {
t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p)
}
}
func TestWilsonProtoText(t *testing.T) {
seed := time.Now().UnixNano()
popr := math_rand.New(math_rand.NewSource(seed))
p := NewPopulatedWilson(popr, true)
dAtA := github_com_gogo_protobuf_proto.MarshalTextString(p)
msg := &Wilson{}
if err := github_com_gogo_protobuf_proto.UnmarshalText(dAtA, msg); err != nil {
t.Fatalf("seed = %d, err = %v", seed, err)
}
if err := p.VerboseEqual(msg); err != nil {
t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
}
if !p.Equal(msg) {
t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p)
}
}
func TestWilsonProtoCompactText(t *testing.T) {
seed := time.Now().UnixNano()
popr := math_rand.New(math_rand.NewSource(seed))
p := NewPopulatedWilson(popr, true)
dAtA := github_com_gogo_protobuf_proto.CompactTextString(p)
msg := &Wilson{}
if err := github_com_gogo_protobuf_proto.UnmarshalText(dAtA, msg); err != nil {
t.Fatalf("seed = %d, err = %v", seed, err)
}
if err := p.VerboseEqual(msg); err != nil {
t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
}
if !p.Equal(msg) {
t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p)
}
}
func TestCastvalueDescription(t *testing.T) {
CastvalueDescription()
}
func TestCastawayVerboseEqual(t *testing.T) {
popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
p := NewPopulatedCastaway(popr, false)
dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
if err != nil {
panic(err)
}
msg := &Castaway{}
if err := github_com_gogo_protobuf_proto.Unmarshal(dAtA, msg); err != nil {
panic(err)
}
if err := p.VerboseEqual(msg); err != nil {
t.Fatalf("%#v !VerboseEqual %#v, since %v", msg, p, err)
}
}
func TestWilsonVerboseEqual(t *testing.T) {
popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
p := NewPopulatedWilson(popr, false)
dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
if err != nil {
panic(err)
}
msg := &Wilson{}
if err := github_com_gogo_protobuf_proto.Unmarshal(dAtA, msg); err != nil {
panic(err)
}
if err := p.VerboseEqual(msg); err != nil {
t.Fatalf("%#v !VerboseEqual %#v, since %v", msg, p, err)
}
}
func TestCastawayFace(t *testing.T) {
popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
p := NewPopulatedCastaway(popr, true)
msg := p.TestProto()
if !p.Equal(msg) {
t.Fatalf("%#v !Face Equal %#v", msg, p)
}
}
func TestWilsonFace(t *testing.T) {
popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
p := NewPopulatedWilson(popr, true)
msg := p.TestProto()
if !p.Equal(msg) {
t.Fatalf("%#v !Face Equal %#v", msg, p)
}
}
func TestCastawayGoString(t *testing.T) {
popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
p := NewPopulatedCastaway(popr, false)
s1 := p.GoString()
s2 := fmt.Sprintf("%#v", p)
if s1 != s2 {
t.Fatalf("GoString want %v got %v", s1, s2)
}
_, err := go_parser.ParseExpr(s1)
if err != nil {
panic(err)
}
}
func TestWilsonGoString(t *testing.T) {
popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
p := NewPopulatedWilson(popr, false)
s1 := p.GoString()
s2 := fmt.Sprintf("%#v", p)
if s1 != s2 {
t.Fatalf("GoString want %v got %v", s1, s2)
}
_, err := go_parser.ParseExpr(s1)
if err != nil {
panic(err)
}
}
func TestCastawaySize(t *testing.T) {
seed := time.Now().UnixNano()
popr := math_rand.New(math_rand.NewSource(seed))
p := NewPopulatedCastaway(popr, true)
size2 := github_com_gogo_protobuf_proto.Size(p)
dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
if err != nil {
t.Fatalf("seed = %d, err = %v", seed, err)
}
size := p.Size()
if len(dAtA) != size {
t.Errorf("seed = %d, size %v != marshalled size %v", seed, size, len(dAtA))
}
if size2 != size {
t.Errorf("seed = %d, size %v != before marshal proto.Size %v", seed, size, size2)
}
size3 := github_com_gogo_protobuf_proto.Size(p)
if size3 != size {
t.Errorf("seed = %d, size %v != after marshal proto.Size %v", seed, size, size3)
}
}
func BenchmarkCastawaySize(b *testing.B) {
popr := math_rand.New(math_rand.NewSource(616))
total := 0
pops := make([]*Castaway, 1000)
for i := 0; i < 1000; i++ {
pops[i] = NewPopulatedCastaway(popr, false)
}
b.ResetTimer()
for i := 0; i < b.N; i++ {
total += pops[i%1000].Size()
}
b.SetBytes(int64(total / b.N))
}
func TestWilsonSize(t *testing.T) {
seed := time.Now().UnixNano()
popr := math_rand.New(math_rand.NewSource(seed))
p := NewPopulatedWilson(popr, true)
size2 := github_com_gogo_protobuf_proto.Size(p)
dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
if err != nil {
t.Fatalf("seed = %d, err = %v", seed, err)
}
size := p.Size()
if len(dAtA) != size {
t.Errorf("seed = %d, size %v != marshalled size %v", seed, size, len(dAtA))
}
if size2 != size {
t.Errorf("seed = %d, size %v != before marshal proto.Size %v", seed, size, size2)
}
size3 := github_com_gogo_protobuf_proto.Size(p)
if size3 != size {
t.Errorf("seed = %d, size %v != after marshal proto.Size %v", seed, size, size3)
}
}
func BenchmarkWilsonSize(b *testing.B) {
popr := math_rand.New(math_rand.NewSource(616))
total := 0
pops := make([]*Wilson, 1000)
for i := 0; i < 1000; i++ {
pops[i] = NewPopulatedWilson(popr, false)
}
b.ResetTimer()
for i := 0; i < b.N; i++ {
total += pops[i%1000].Size()
}
b.SetBytes(int64(total / b.N))
}
func TestCastawayStringer(t *testing.T) {
popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
p := NewPopulatedCastaway(popr, false)
s1 := p.String()
s2 := fmt.Sprintf("%v", p)
if s1 != s2 {
t.Fatalf("String want %v got %v", s1, s2)
}
}
func TestWilsonStringer(t *testing.T) {
popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
p := NewPopulatedWilson(popr, false)
s1 := p.String()
s2 := fmt.Sprintf("%v", p)
if s1 != s2 {
t.Fatalf("String want %v got %v", s1, s2)
}
}
//These tests are generated by github.com/gogo/protobuf/plugin/testgen

6
vendor/github.com/gogo/protobuf/test/castvalue/combos/unsafemarshaler/mytypes.go generated vendored
View File

@@ -1,7 +1,7 @@
// Extensions for Protocol Buffers to create more go like structures.
// Protocol Buffers for Go with Gadgets
//
// Copyright (c) 2013, Vastech SA (PTY) LTD. All rights reserved.
// http://github.com/gogo/protobuf/gogoproto
// 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

792
vendor/github.com/gogo/protobuf/test/castvalue/combos/unsafeunmarshaler/castvalue.pb.go generated vendored
View File

File diff suppressed because it is too large Load Diff

66
vendor/github.com/gogo/protobuf/test/castvalue/combos/unsafeunmarshaler/castvalue.proto generated vendored Normal file
View File

@@ -0,0 +1,66 @@
// Protocol Buffers for Go with Gadgets
//
// Copyright (c) 2015, 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.
syntax = "proto2";
package castvalue;
import "github.com/gogo/protobuf/gogoproto/gogo.proto";
option (gogoproto.goproto_stringer_all) = false;
option (gogoproto.goproto_enum_prefix_all) = false;
option (gogoproto.goproto_getters_all) = false;
option (gogoproto.equal_all) = true;
option (gogoproto.verbose_equal_all) = true;
option (gogoproto.stringer_all) = true;
option (gogoproto.gostring_all) = true;
option (gogoproto.face_all) = true;
option (gogoproto.description_all) = true;
option (gogoproto.testgen_all) = true;
option (gogoproto.populate_all) = true;
option (gogoproto.benchgen_all) = true;
option (gogoproto.unmarshaler_all) = false;
option (gogoproto.marshaler_all) = false;
option (gogoproto.sizer_all) = true;
option (gogoproto.goproto_enum_stringer_all) = false;
option (gogoproto.enum_stringer_all) = true;
option (gogoproto.unsafe_marshaler_all) = false;
option (gogoproto.unsafe_unmarshaler_all) = true;
message Castaway {
map<int32,Wilson> CastMapValueMessage = 1 [(gogoproto.castvalue) = "MyWilson", (gogoproto.nullable) = false];
map<int32,Wilson> CastMapValueMessageNullable = 2 [(gogoproto.castvalue) = "MyWilson"];
}
message Wilson {
optional int64 Int64 = 1;
}

457
vendor/github.com/gogo/protobuf/test/castvalue/combos/unsafeunmarshaler/castvaluepb_test.go generated vendored Normal file
View File

@@ -0,0 +1,457 @@
// Code generated by protoc-gen-gogo.
// source: combos/unsafeunmarshaler/castvalue.proto
// DO NOT EDIT!
/*
Package castvalue is a generated protocol buffer package.
It is generated from these files:
combos/unsafeunmarshaler/castvalue.proto
It has these top-level messages:
Castaway
Wilson
*/
package castvalue
import testing "testing"
import math_rand "math/rand"
import time "time"
import github_com_gogo_protobuf_proto "github.com/gogo/protobuf/proto"
import github_com_gogo_protobuf_jsonpb "github.com/gogo/protobuf/jsonpb"
import fmt "fmt"
import go_parser "go/parser"
import proto "github.com/gogo/protobuf/proto"
import math "math"
import _ "github.com/gogo/protobuf/gogoproto"
// Reference imports to suppress errors if they are not otherwise used.
var _ = proto.Marshal
var _ = fmt.Errorf
var _ = math.Inf
func TestCastawayProto(t *testing.T) {
seed := time.Now().UnixNano()
popr := math_rand.New(math_rand.NewSource(seed))
p := NewPopulatedCastaway(popr, false)
dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
if err != nil {
t.Fatalf("seed = %d, err = %v", seed, err)
}
msg := &Castaway{}
if err := github_com_gogo_protobuf_proto.Unmarshal(dAtA, msg); err != nil {
t.Fatalf("seed = %d, err = %v", seed, err)
}
littlefuzz := make([]byte, len(dAtA))
copy(littlefuzz, dAtA)
for i := range dAtA {
dAtA[i] = byte(popr.Intn(256))
}
if err := p.VerboseEqual(msg); err != nil {
t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
}
if !p.Equal(msg) {
t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p)
}
if len(littlefuzz) > 0 {
fuzzamount := 100
for i := 0; i < fuzzamount; i++ {
littlefuzz[popr.Intn(len(littlefuzz))] = byte(popr.Intn(256))
littlefuzz = append(littlefuzz, byte(popr.Intn(256)))
}
// shouldn't panic
_ = github_com_gogo_protobuf_proto.Unmarshal(littlefuzz, msg)
}
}
func BenchmarkCastawayProtoMarshal(b *testing.B) {
popr := math_rand.New(math_rand.NewSource(616))
total := 0
pops := make([]*Castaway, 10000)
for i := 0; i < 10000; i++ {
pops[i] = NewPopulatedCastaway(popr, false)
}
b.ResetTimer()
for i := 0; i < b.N; i++ {
dAtA, err := github_com_gogo_protobuf_proto.Marshal(pops[i%10000])
if err != nil {
panic(err)
}
total += len(dAtA)
}
b.SetBytes(int64(total / b.N))
}
func BenchmarkCastawayProtoUnmarshal(b *testing.B) {
popr := math_rand.New(math_rand.NewSource(616))
total := 0
datas := make([][]byte, 10000)
for i := 0; i < 10000; i++ {
dAtA, err := github_com_gogo_protobuf_proto.Marshal(NewPopulatedCastaway(popr, false))
if err != nil {
panic(err)
}
datas[i] = dAtA
}
msg := &Castaway{}
b.ResetTimer()
for i := 0; i < b.N; i++ {
total += len(datas[i%10000])
if err := github_com_gogo_protobuf_proto.Unmarshal(datas[i%10000], msg); err != nil {
panic(err)
}
}
b.SetBytes(int64(total / b.N))
}
func TestWilsonProto(t *testing.T) {
seed := time.Now().UnixNano()
popr := math_rand.New(math_rand.NewSource(seed))
p := NewPopulatedWilson(popr, false)
dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
if err != nil {
t.Fatalf("seed = %d, err = %v", seed, err)
}
msg := &Wilson{}
if err := github_com_gogo_protobuf_proto.Unmarshal(dAtA, msg); err != nil {
t.Fatalf("seed = %d, err = %v", seed, err)
}
littlefuzz := make([]byte, len(dAtA))
copy(littlefuzz, dAtA)
for i := range dAtA {
dAtA[i] = byte(popr.Intn(256))
}
if err := p.VerboseEqual(msg); err != nil {
t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
}
if !p.Equal(msg) {
t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p)
}
if len(littlefuzz) > 0 {
fuzzamount := 100
for i := 0; i < fuzzamount; i++ {
littlefuzz[popr.Intn(len(littlefuzz))] = byte(popr.Intn(256))
littlefuzz = append(littlefuzz, byte(popr.Intn(256)))
}
// shouldn't panic
_ = github_com_gogo_protobuf_proto.Unmarshal(littlefuzz, msg)
}
}
func BenchmarkWilsonProtoMarshal(b *testing.B) {
popr := math_rand.New(math_rand.NewSource(616))
total := 0
pops := make([]*Wilson, 10000)
for i := 0; i < 10000; i++ {
pops[i] = NewPopulatedWilson(popr, false)
}
b.ResetTimer()
for i := 0; i < b.N; i++ {
dAtA, err := github_com_gogo_protobuf_proto.Marshal(pops[i%10000])
if err != nil {
panic(err)
}
total += len(dAtA)
}
b.SetBytes(int64(total / b.N))
}
func BenchmarkWilsonProtoUnmarshal(b *testing.B) {
popr := math_rand.New(math_rand.NewSource(616))
total := 0
datas := make([][]byte, 10000)
for i := 0; i < 10000; i++ {
dAtA, err := github_com_gogo_protobuf_proto.Marshal(NewPopulatedWilson(popr, false))
if err != nil {
panic(err)
}
datas[i] = dAtA
}
msg := &Wilson{}
b.ResetTimer()
for i := 0; i < b.N; i++ {
total += len(datas[i%10000])
if err := github_com_gogo_protobuf_proto.Unmarshal(datas[i%10000], msg); err != nil {
panic(err)
}
}
b.SetBytes(int64(total / b.N))
}
func TestCastawayJSON(t *testing.T) {
seed := time.Now().UnixNano()
popr := math_rand.New(math_rand.NewSource(seed))
p := NewPopulatedCastaway(popr, true)
marshaler := github_com_gogo_protobuf_jsonpb.Marshaler{}
jsondata, err := marshaler.MarshalToString(p)
if err != nil {
t.Fatalf("seed = %d, err = %v", seed, err)
}
msg := &Castaway{}
err = github_com_gogo_protobuf_jsonpb.UnmarshalString(jsondata, msg)
if err != nil {
t.Fatalf("seed = %d, err = %v", seed, err)
}
if err := p.VerboseEqual(msg); err != nil {
t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
}
if !p.Equal(msg) {
t.Fatalf("seed = %d, %#v !Json Equal %#v", seed, msg, p)
}
}
func TestWilsonJSON(t *testing.T) {
seed := time.Now().UnixNano()
popr := math_rand.New(math_rand.NewSource(seed))
p := NewPopulatedWilson(popr, true)
marshaler := github_com_gogo_protobuf_jsonpb.Marshaler{}
jsondata, err := marshaler.MarshalToString(p)
if err != nil {
t.Fatalf("seed = %d, err = %v", seed, err)
}
msg := &Wilson{}
err = github_com_gogo_protobuf_jsonpb.UnmarshalString(jsondata, msg)
if err != nil {
t.Fatalf("seed = %d, err = %v", seed, err)
}
if err := p.VerboseEqual(msg); err != nil {
t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
}
if !p.Equal(msg) {
t.Fatalf("seed = %d, %#v !Json Equal %#v", seed, msg, p)
}
}
func TestCastawayProtoText(t *testing.T) {
seed := time.Now().UnixNano()
popr := math_rand.New(math_rand.NewSource(seed))
p := NewPopulatedCastaway(popr, true)
dAtA := github_com_gogo_protobuf_proto.MarshalTextString(p)
msg := &Castaway{}
if err := github_com_gogo_protobuf_proto.UnmarshalText(dAtA, msg); err != nil {
t.Fatalf("seed = %d, err = %v", seed, err)
}
if err := p.VerboseEqual(msg); err != nil {
t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
}
if !p.Equal(msg) {
t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p)
}
}
func TestCastawayProtoCompactText(t *testing.T) {
seed := time.Now().UnixNano()
popr := math_rand.New(math_rand.NewSource(seed))
p := NewPopulatedCastaway(popr, true)
dAtA := github_com_gogo_protobuf_proto.CompactTextString(p)
msg := &Castaway{}
if err := github_com_gogo_protobuf_proto.UnmarshalText(dAtA, msg); err != nil {
t.Fatalf("seed = %d, err = %v", seed, err)
}
if err := p.VerboseEqual(msg); err != nil {
t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
}
if !p.Equal(msg) {
t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p)
}
}
func TestWilsonProtoText(t *testing.T) {
seed := time.Now().UnixNano()
popr := math_rand.New(math_rand.NewSource(seed))
p := NewPopulatedWilson(popr, true)
dAtA := github_com_gogo_protobuf_proto.MarshalTextString(p)
msg := &Wilson{}
if err := github_com_gogo_protobuf_proto.UnmarshalText(dAtA, msg); err != nil {
t.Fatalf("seed = %d, err = %v", seed, err)
}
if err := p.VerboseEqual(msg); err != nil {
t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
}
if !p.Equal(msg) {
t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p)
}
}
func TestWilsonProtoCompactText(t *testing.T) {
seed := time.Now().UnixNano()
popr := math_rand.New(math_rand.NewSource(seed))
p := NewPopulatedWilson(popr, true)
dAtA := github_com_gogo_protobuf_proto.CompactTextString(p)
msg := &Wilson{}
if err := github_com_gogo_protobuf_proto.UnmarshalText(dAtA, msg); err != nil {
t.Fatalf("seed = %d, err = %v", seed, err)
}
if err := p.VerboseEqual(msg); err != nil {
t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
}
if !p.Equal(msg) {
t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p)
}
}
func TestCastvalueDescription(t *testing.T) {
CastvalueDescription()
}
func TestCastawayVerboseEqual(t *testing.T) {
popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
p := NewPopulatedCastaway(popr, false)
dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
if err != nil {
panic(err)
}
msg := &Castaway{}
if err := github_com_gogo_protobuf_proto.Unmarshal(dAtA, msg); err != nil {
panic(err)
}
if err := p.VerboseEqual(msg); err != nil {
t.Fatalf("%#v !VerboseEqual %#v, since %v", msg, p, err)
}
}
func TestWilsonVerboseEqual(t *testing.T) {
popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
p := NewPopulatedWilson(popr, false)
dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
if err != nil {
panic(err)
}
msg := &Wilson{}
if err := github_com_gogo_protobuf_proto.Unmarshal(dAtA, msg); err != nil {
panic(err)
}
if err := p.VerboseEqual(msg); err != nil {
t.Fatalf("%#v !VerboseEqual %#v, since %v", msg, p, err)
}
}
func TestCastawayFace(t *testing.T) {
popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
p := NewPopulatedCastaway(popr, true)
msg := p.TestProto()
if !p.Equal(msg) {
t.Fatalf("%#v !Face Equal %#v", msg, p)
}
}
func TestWilsonFace(t *testing.T) {
popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
p := NewPopulatedWilson(popr, true)
msg := p.TestProto()
if !p.Equal(msg) {
t.Fatalf("%#v !Face Equal %#v", msg, p)
}
}
func TestCastawayGoString(t *testing.T) {
popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
p := NewPopulatedCastaway(popr, false)
s1 := p.GoString()
s2 := fmt.Sprintf("%#v", p)
if s1 != s2 {
t.Fatalf("GoString want %v got %v", s1, s2)
}
_, err := go_parser.ParseExpr(s1)
if err != nil {
panic(err)
}
}
func TestWilsonGoString(t *testing.T) {
popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
p := NewPopulatedWilson(popr, false)
s1 := p.GoString()
s2 := fmt.Sprintf("%#v", p)
if s1 != s2 {
t.Fatalf("GoString want %v got %v", s1, s2)
}
_, err := go_parser.ParseExpr(s1)
if err != nil {
panic(err)
}
}
func TestCastawaySize(t *testing.T) {
seed := time.Now().UnixNano()
popr := math_rand.New(math_rand.NewSource(seed))
p := NewPopulatedCastaway(popr, true)
size2 := github_com_gogo_protobuf_proto.Size(p)
dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
if err != nil {
t.Fatalf("seed = %d, err = %v", seed, err)
}
size := p.Size()
if len(dAtA) != size {
t.Errorf("seed = %d, size %v != marshalled size %v", seed, size, len(dAtA))
}
if size2 != size {
t.Errorf("seed = %d, size %v != before marshal proto.Size %v", seed, size, size2)
}
size3 := github_com_gogo_protobuf_proto.Size(p)
if size3 != size {
t.Errorf("seed = %d, size %v != after marshal proto.Size %v", seed, size, size3)
}
}
func BenchmarkCastawaySize(b *testing.B) {
popr := math_rand.New(math_rand.NewSource(616))
total := 0
pops := make([]*Castaway, 1000)
for i := 0; i < 1000; i++ {
pops[i] = NewPopulatedCastaway(popr, false)
}
b.ResetTimer()
for i := 0; i < b.N; i++ {
total += pops[i%1000].Size()
}
b.SetBytes(int64(total / b.N))
}
func TestWilsonSize(t *testing.T) {
seed := time.Now().UnixNano()
popr := math_rand.New(math_rand.NewSource(seed))
p := NewPopulatedWilson(popr, true)
size2 := github_com_gogo_protobuf_proto.Size(p)
dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
if err != nil {
t.Fatalf("seed = %d, err = %v", seed, err)
}
size := p.Size()
if len(dAtA) != size {
t.Errorf("seed = %d, size %v != marshalled size %v", seed, size, len(dAtA))
}
if size2 != size {
t.Errorf("seed = %d, size %v != before marshal proto.Size %v", seed, size, size2)
}
size3 := github_com_gogo_protobuf_proto.Size(p)
if size3 != size {
t.Errorf("seed = %d, size %v != after marshal proto.Size %v", seed, size, size3)
}
}
func BenchmarkWilsonSize(b *testing.B) {
popr := math_rand.New(math_rand.NewSource(616))
total := 0
pops := make([]*Wilson, 1000)
for i := 0; i < 1000; i++ {
pops[i] = NewPopulatedWilson(popr, false)
}
b.ResetTimer()
for i := 0; i < b.N; i++ {
total += pops[i%1000].Size()
}
b.SetBytes(int64(total / b.N))
}
func TestCastawayStringer(t *testing.T) {
popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
p := NewPopulatedCastaway(popr, false)
s1 := p.String()
s2 := fmt.Sprintf("%v", p)
if s1 != s2 {
t.Fatalf("String want %v got %v", s1, s2)
}
}
func TestWilsonStringer(t *testing.T) {
popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
p := NewPopulatedWilson(popr, false)
s1 := p.String()
s2 := fmt.Sprintf("%v", p)
if s1 != s2 {
t.Fatalf("String want %v got %v", s1, s2)
}
}
//These tests are generated by github.com/gogo/protobuf/plugin/testgen

6
vendor/github.com/gogo/protobuf/test/castvalue/combos/unsafeunmarshaler/mytypes.go generated vendored
View File

@@ -1,7 +1,7 @@
// Extensions for Protocol Buffers to create more go like structures.
// Protocol Buffers for Go with Gadgets
//
// Copyright (c) 2013, Vastech SA (PTY) LTD. All rights reserved.
// http://github.com/gogo/protobuf/gogoproto
// 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

6
vendor/github.com/gogo/protobuf/test/castvalue/mytypes.go generated vendored
View File

@@ -1,7 +1,7 @@
// Extensions for Protocol Buffers to create more go like structures.
// Protocol Buffers for Go with Gadgets
//
// Copyright (c) 2013, Vastech SA (PTY) LTD. All rights reserved.
// http://github.com/gogo/protobuf/gogoproto
// 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