vendor/google.golang.org/genproto/googleapis/bigtable/admin/v2/table.pb.go

   1 // Code generated by protoc-gen-go. DO NOT EDIT.
   2 // source: google/bigtable/admin/v2/table.proto
   3
   4 package admin
   5
   6 import proto "github.com/golang/protobuf/proto"
   7 import fmt "fmt"
   8 import math "math"
   9 import _ "google.golang.org/genproto/googleapis/api/annotations"
  10 import google_protobuf4 "github.com/golang/protobuf/ptypes/duration"
  11 import _ "github.com/golang/protobuf/ptypes/timestamp"
  12
  13 // Reference imports to suppress errors if they are not otherwise used.
  14 var _ = proto.Marshal
  15 var _ = fmt.Errorf
  16 var _ = math.Inf
  17
  18 // Possible timestamp granularities to use when keeping multiple versions
  19 // of data in a table.
  20 type Table_TimestampGranularity int32
  21
  22 const (
  23         // The user did not specify a granularity. Should not be returned.
  24         // When specified during table creation, MILLIS will be used.
  25         Table_TIMESTAMP_GRANULARITY_UNSPECIFIED Table_TimestampGranularity = 0
  26         // The table keeps data versioned at a granularity of 1ms.
  27         Table_MILLIS Table_TimestampGranularity = 1
  28 )
  29
  30 var Table_TimestampGranularity_name = map[int32]string{
  31         0: "TIMESTAMP_GRANULARITY_UNSPECIFIED",
  32         1: "MILLIS",
  33 }
  34 var Table_TimestampGranularity_value = map[string]int32{
  35         "TIMESTAMP_GRANULARITY_UNSPECIFIED": 0,
  36         "MILLIS": 1,
  37 }
  38
  39 func (x Table_TimestampGranularity) String() string {
  40         return proto.EnumName(Table_TimestampGranularity_name, int32(x))
  41 }
  42 func (Table_TimestampGranularity) EnumDescriptor() ([]byte, []int) {
  43         return fileDescriptor4, []int{0, 0}
  44 }
  45
  46 // Defines a view over a table's fields.
  47 type Table_View int32
  48
  49 const (
  50         // Uses the default view for each method as documented in its request.
  51         Table_VIEW_UNSPECIFIED Table_View = 0
  52         // Only populates `name`.
  53         Table_NAME_ONLY Table_View = 1
  54         // Only populates `name` and fields related to the table's schema.
  55         Table_SCHEMA_VIEW Table_View = 2
  56         // Populates all fields.
  57         Table_FULL Table_View = 4
  58 )
  59
  60 var Table_View_name = map[int32]string{
  61         0: "VIEW_UNSPECIFIED",
  62         1: "NAME_ONLY",
  63         2: "SCHEMA_VIEW",
  64         4: "FULL",
  65 }
  66 var Table_View_value = map[string]int32{
  67         "VIEW_UNSPECIFIED": 0,
  68         "NAME_ONLY":        1,
  69         "SCHEMA_VIEW":      2,
  70         "FULL":             4,
  71 }
  72
  73 func (x Table_View) String() string {
  74         return proto.EnumName(Table_View_name, int32(x))
  75 }
  76 func (Table_View) EnumDescriptor() ([]byte, []int) { return fileDescriptor4, []int{0, 1} }
  77
  78 // A collection of user data indexed by row, column, and timestamp.
  79 // Each table is served using the resources of its parent cluster.
  80 type Table struct {
  81         // (`OutputOnly`)
  82         // The unique name of the table. Values are of the form
  83         // `projects/<project>/instances/<instance>/tables/[_a-zA-Z0-9][-_.a-zA-Z0-9]*`.
  84         // Views: `NAME_ONLY`, `SCHEMA_VIEW`, `FULL`
  85         Name string `protobuf:"bytes,1,opt,name=name" json:"name,omitempty"`
  86         // (`CreationOnly`)
  87         // The column families configured for this table, mapped by column family ID.
  88         // Views: `SCHEMA_VIEW`, `FULL`
  89         ColumnFamilies map[string]*ColumnFamily `protobuf:"bytes,3,rep,name=column_families,json=columnFamilies" json:"column_families,omitempty" protobuf_key:"bytes,1,opt,name=key" protobuf_val:"bytes,2,opt,name=value"`
  90         // (`CreationOnly`)
  91         // The granularity (e.g. `MILLIS`, `MICROS`) at which timestamps are stored in
  92         // this table. Timestamps not matching the granularity will be rejected.
  93         // If unspecified at creation time, the value will be set to `MILLIS`.
  94         // Views: `SCHEMA_VIEW`, `FULL`
  95         Granularity Table_TimestampGranularity `protobuf:"varint,4,opt,name=granularity,enum=google.bigtable.admin.v2.Table_TimestampGranularity" json:"granularity,omitempty"`
  96 }
  97
  98 func (m *Table) Reset()                    { *m = Table{} }
  99 func (m *Table) String() string            { return proto.CompactTextString(m) }
 100 func (*Table) ProtoMessage()               {}
 101 func (*Table) Descriptor() ([]byte, []int) { return fileDescriptor4, []int{0} }
 102
 103 func (m *Table) GetName() string {
 104         if m != nil {
 105                 return m.Name
 106         }
 107         return ""
 108 }
 109
 110 func (m *Table) GetColumnFamilies() map[string]*ColumnFamily {
 111         if m != nil {
 112                 return m.ColumnFamilies
 113         }
 114         return nil
 115 }
 116
 117 func (m *Table) GetGranularity() Table_TimestampGranularity {
 118         if m != nil {
 119                 return m.Granularity
 120         }
 121         return Table_TIMESTAMP_GRANULARITY_UNSPECIFIED
 122 }
 123
 124 // A set of columns within a table which share a common configuration.
 125 type ColumnFamily struct {
 126         // Garbage collection rule specified as a protobuf.
 127         // Must serialize to at most 500 bytes.
 128         //
 129         // NOTE: Garbage collection executes opportunistically in the background, and
 130         // so it's possible for reads to return a cell even if it matches the active
 131         // GC expression for its family.
 132         GcRule *GcRule `protobuf:"bytes,1,opt,name=gc_rule,json=gcRule" json:"gc_rule,omitempty"`
 133 }
 134
 135 func (m *ColumnFamily) Reset()                    { *m = ColumnFamily{} }
 136 func (m *ColumnFamily) String() string            { return proto.CompactTextString(m) }
 137 func (*ColumnFamily) ProtoMessage()               {}
 138 func (*ColumnFamily) Descriptor() ([]byte, []int) { return fileDescriptor4, []int{1} }
 139
 140 func (m *ColumnFamily) GetGcRule() *GcRule {
 141         if m != nil {
 142                 return m.GcRule
 143         }
 144         return nil
 145 }
 146
 147 // Rule for determining which cells to delete during garbage collection.
 148 type GcRule struct {
 149         // Garbage collection rules.
 150         //
 151         // Types that are valid to be assigned to Rule:
 152         //      *GcRule_MaxNumVersions
 153         //      *GcRule_MaxAge
 154         //      *GcRule_Intersection_
 155         //      *GcRule_Union_
 156         Rule isGcRule_Rule `protobuf_oneof:"rule"`
 157 }
 158
 159 func (m *GcRule) Reset()                    { *m = GcRule{} }
 160 func (m *GcRule) String() string            { return proto.CompactTextString(m) }
 161 func (*GcRule) ProtoMessage()               {}
 162 func (*GcRule) Descriptor() ([]byte, []int) { return fileDescriptor4, []int{2} }
 163
 164 type isGcRule_Rule interface {
 165         isGcRule_Rule()
 166 }
 167
 168 type GcRule_MaxNumVersions struct {
 169         MaxNumVersions int32 `protobuf:"varint,1,opt,name=max_num_versions,json=maxNumVersions,oneof"`
 170 }
 171 type GcRule_MaxAge struct {
 172         MaxAge *google_protobuf4.Duration `protobuf:"bytes,2,opt,name=max_age,json=maxAge,oneof"`
 173 }
 174 type GcRule_Intersection_ struct {
 175         Intersection *GcRule_Intersection `protobuf:"bytes,3,opt,name=intersection,oneof"`
 176 }
 177 type GcRule_Union_ struct {
 178         Union *GcRule_Union `protobuf:"bytes,4,opt,name=union,oneof"`
 179 }
 180
 181 func (*GcRule_MaxNumVersions) isGcRule_Rule() {}
 182 func (*GcRule_MaxAge) isGcRule_Rule()         {}
 183 func (*GcRule_Intersection_) isGcRule_Rule()  {}
 184 func (*GcRule_Union_) isGcRule_Rule()         {}
 185
 186 func (m *GcRule) GetRule() isGcRule_Rule {
 187         if m != nil {
 188                 return m.Rule
 189         }
 190         return nil
 191 }
 192
 193 func (m *GcRule) GetMaxNumVersions() int32 {
 194         if x, ok := m.GetRule().(*GcRule_MaxNumVersions); ok {
 195                 return x.MaxNumVersions
 196         }
 197         return 0
 198 }
 199
 200 func (m *GcRule) GetMaxAge() *google_protobuf4.Duration {
 201         if x, ok := m.GetRule().(*GcRule_MaxAge); ok {
 202                 return x.MaxAge
 203         }
 204         return nil
 205 }
 206
 207 func (m *GcRule) GetIntersection() *GcRule_Intersection {
 208         if x, ok := m.GetRule().(*GcRule_Intersection_); ok {
 209                 return x.Intersection
 210         }
 211         return nil
 212 }
 213
 214 func (m *GcRule) GetUnion() *GcRule_Union {
 215         if x, ok := m.GetRule().(*GcRule_Union_); ok {
 216                 return x.Union
 217         }
 218         return nil
 219 }
 220
 221 // XXX_OneofFuncs is for the internal use of the proto package.
 222 func (*GcRule) XXX_OneofFuncs() (func(msg proto.Message, b *proto.Buffer) error, func(msg proto.Message, tag, wire int, b *proto.Buffer) (bool, error), func(msg proto.Message) (n int), []interface{}) {
 223         return _GcRule_OneofMarshaler, _GcRule_OneofUnmarshaler, _GcRule_OneofSizer, []interface{}{
 224                 (*GcRule_MaxNumVersions)(nil),
 225                 (*GcRule_MaxAge)(nil),
 226                 (*GcRule_Intersection_)(nil),
 227                 (*GcRule_Union_)(nil),
 228         }
 229 }
 230
 231 func _GcRule_OneofMarshaler(msg proto.Message, b *proto.Buffer) error {
 232         m := msg.(*GcRule)
 233         // rule
 234         switch x := m.Rule.(type) {
 235         case *GcRule_MaxNumVersions:
 236                 b.EncodeVarint(1<<3 | proto.WireVarint)
 237                 b.EncodeVarint(uint64(x.MaxNumVersions))
 238         case *GcRule_MaxAge:
 239                 b.EncodeVarint(2<<3 | proto.WireBytes)
 240                 if err := b.EncodeMessage(x.MaxAge); err != nil {
 241                         return err
 242                 }
 243         case *GcRule_Intersection_:
 244                 b.EncodeVarint(3<<3 | proto.WireBytes)
 245                 if err := b.EncodeMessage(x.Intersection); err != nil {
 246                         return err
 247                 }
 248         case *GcRule_Union_:
 249                 b.EncodeVarint(4<<3 | proto.WireBytes)
 250                 if err := b.EncodeMessage(x.Union); err != nil {
 251                         return err
 252                 }
 253         case nil:
 254         default:
 255                 return fmt.Errorf("GcRule.Rule has unexpected type %T", x)
 256         }
 257         return nil
 258 }
 259
 260 func _GcRule_OneofUnmarshaler(msg proto.Message, tag, wire int, b *proto.Buffer) (bool, error) {
 261         m := msg.(*GcRule)
 262         switch tag {
 263         case 1: // rule.max_num_versions
 264                 if wire != proto.WireVarint {
 265                         return true, proto.ErrInternalBadWireType
 266                 }
 267                 x, err := b.DecodeVarint()
 268                 m.Rule = &GcRule_MaxNumVersions{int32(x)}
 269                 return true, err
 270         case 2: // rule.max_age
 271                 if wire != proto.WireBytes {
 272                         return true, proto.ErrInternalBadWireType
 273                 }
 274                 msg := new(google_protobuf4.Duration)
 275                 err := b.DecodeMessage(msg)
 276                 m.Rule = &GcRule_MaxAge{msg}
 277                 return true, err
 278         case 3: // rule.intersection
 279                 if wire != proto.WireBytes {
 280                         return true, proto.ErrInternalBadWireType
 281                 }
 282                 msg := new(GcRule_Intersection)
 283                 err := b.DecodeMessage(msg)
 284                 m.Rule = &GcRule_Intersection_{msg}
 285                 return true, err
 286         case 4: // rule.union
 287                 if wire != proto.WireBytes {
 288                         return true, proto.ErrInternalBadWireType
 289                 }
 290                 msg := new(GcRule_Union)
 291                 err := b.DecodeMessage(msg)
 292                 m.Rule = &GcRule_Union_{msg}
 293                 return true, err
 294         default:
 295                 return false, nil
 296         }
 297 }
 298
 299 func _GcRule_OneofSizer(msg proto.Message) (n int) {
 300         m := msg.(*GcRule)
 301         // rule
 302         switch x := m.Rule.(type) {
 303         case *GcRule_MaxNumVersions:
 304                 n += proto.SizeVarint(1<<3 | proto.WireVarint)
 305                 n += proto.SizeVarint(uint64(x.MaxNumVersions))
 306         case *GcRule_MaxAge:
 307                 s := proto.Size(x.MaxAge)
 308                 n += proto.SizeVarint(2<<3 | proto.WireBytes)
 309                 n += proto.SizeVarint(uint64(s))
 310                 n += s
 311         case *GcRule_Intersection_:
 312                 s := proto.Size(x.Intersection)
 313                 n += proto.SizeVarint(3<<3 | proto.WireBytes)
 314                 n += proto.SizeVarint(uint64(s))
 315                 n += s
 316         case *GcRule_Union_:
 317                 s := proto.Size(x.Union)
 318                 n += proto.SizeVarint(4<<3 | proto.WireBytes)
 319                 n += proto.SizeVarint(uint64(s))
 320                 n += s
 321         case nil:
 322         default:
 323                 panic(fmt.Sprintf("proto: unexpected type %T in oneof", x))
 324         }
 325         return n
 326 }
 327
 328 // A GcRule which deletes cells matching all of the given rules.
 329 type GcRule_Intersection struct {
 330         // Only delete cells which would be deleted by every element of `rules`.
 331         Rules []*GcRule `protobuf:"bytes,1,rep,name=rules" json:"rules,omitempty"`
 332 }
 333
 334 func (m *GcRule_Intersection) Reset()                    { *m = GcRule_Intersection{} }
 335 func (m *GcRule_Intersection) String() string            { return proto.CompactTextString(m) }
 336 func (*GcRule_Intersection) ProtoMessage()               {}
 337 func (*GcRule_Intersection) Descriptor() ([]byte, []int) { return fileDescriptor4, []int{2, 0} }
 338
 339 func (m *GcRule_Intersection) GetRules() []*GcRule {
 340         if m != nil {
 341                 return m.Rules
 342         }
 343         return nil
 344 }
 345
 346 // A GcRule which deletes cells matching any of the given rules.
 347 type GcRule_Union struct {
 348         // Delete cells which would be deleted by any element of `rules`.
 349         Rules []*GcRule `protobuf:"bytes,1,rep,name=rules" json:"rules,omitempty"`
 350 }
 351
 352 func (m *GcRule_Union) Reset()                    { *m = GcRule_Union{} }
 353 func (m *GcRule_Union) String() string            { return proto.CompactTextString(m) }
 354 func (*GcRule_Union) ProtoMessage()               {}
 355 func (*GcRule_Union) Descriptor() ([]byte, []int) { return fileDescriptor4, []int{2, 1} }
 356
 357 func (m *GcRule_Union) GetRules() []*GcRule {
 358         if m != nil {
 359                 return m.Rules
 360         }
 361         return nil
 362 }
 363
 364 func init() {
 365         proto.RegisterType((*Table)(nil), "google.bigtable.admin.v2.Table")
 366         proto.RegisterType((*ColumnFamily)(nil), "google.bigtable.admin.v2.ColumnFamily")
 367         proto.RegisterType((*GcRule)(nil), "google.bigtable.admin.v2.GcRule")
 368         proto.RegisterType((*GcRule_Intersection)(nil), "google.bigtable.admin.v2.GcRule.Intersection")
 369         proto.RegisterType((*GcRule_Union)(nil), "google.bigtable.admin.v2.GcRule.Union")
 370         proto.RegisterEnum("google.bigtable.admin.v2.Table_TimestampGranularity", Table_TimestampGranularity_name, Table_TimestampGranularity_value)
 371         proto.RegisterEnum("google.bigtable.admin.v2.Table_View", Table_View_name, Table_View_value)
 372 }
 373
 374 func init() { proto.RegisterFile("google/bigtable/admin/v2/table.proto", fileDescriptor4) }
 375
 376 var fileDescriptor4 = []byte{
 377         // 598 bytes of a gzipped FileDescriptorProto
 378         0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x9c, 0x54, 0x7d, 0x6b, 0xda, 0x5e,
 379         0x14, 0x36, 0x4d, 0xb4, 0xbf, 0x1e, 0xfb, 0x6b, 0xc3, 0x5d, 0xff, 0x70, 0x52, 0x36, 0x27, 0xdb,
 380         0x90, 0xc1, 0x12, 0xb0, 0x65, 0xec, 0x7d, 0xd8, 0x36, 0xd6, 0x80, 0x3a, 0x89, 0x2f, 0xa3, 0x63,
 381         0x10, 0xae, 0xe9, 0xed, 0xe5, 0xd2, 0xdc, 0x1b, 0xc9, 0x8b, 0xab, 0xdf, 0x62, 0xdf, 0x6c, 0x5f,
 382         0x69, 0xe4, 0x26, 0x32, 0xdb, 0x55, 0x1c, 0xfb, 0xcb, 0x73, 0xcf, 0x79, 0x9e, 0xe7, 0xbc, 0x1a,
 383         0x78, 0x4a, 0x83, 0x80, 0xfa, 0xc4, 0x9c, 0x32, 0x1a, 0xe3, 0xa9, 0x4f, 0x4c, 0x7c, 0xc9, 0x99,
 384         0x30, 0xe7, 0x4d, 0x53, 0x3e, 0x8d, 0x59, 0x18, 0xc4, 0x01, 0xaa, 0x64, 0x28, 0x63, 0x89, 0x32,
 385         0x24, 0xca, 0x98, 0x37, 0xab, 0x87, 0x39, 0x1f, 0xcf, 0x98, 0x89, 0x85, 0x08, 0x62, 0x1c, 0xb3,
 386         0x40, 0x44, 0x19, 0xaf, 0xfa, 0x28, 0x8f, 0xca, 0xd7, 0x34, 0xb9, 0x32, 0x2f, 0x93, 0x50, 0x02,
 387         0xf2, 0xf8, 0xe3, 0xbb, 0xf1, 0x98, 0x71, 0x12, 0xc5, 0x98, 0xcf, 0x32, 0x40, 0xfd, 0xa7, 0x0a,
 388         0xc5, 0x51, 0x9a, 0x11, 0x21, 0xd0, 0x04, 0xe6, 0xa4, 0xa2, 0xd4, 0x94, 0xc6, 0x8e, 0x23, 0x6d,
 389         0xf4, 0x0d, 0xf6, 0xbd, 0xc0, 0x4f, 0xb8, 0x70, 0xaf, 0x30, 0x67, 0x3e, 0x23, 0x51, 0x45, 0xad,
 390         0xa9, 0x8d, 0x72, 0xf3, 0xc8, 0x58, 0x57, 0xb0, 0x21, 0xd5, 0x8c, 0x53, 0x49, 0x6b, 0xe7, 0x2c,
 391         0x4b, 0xc4, 0xe1, 0xc2, 0xd9, 0xf3, 0x6e, 0x39, 0xd1, 0x04, 0xca, 0x34, 0xc4, 0x22, 0xf1, 0x71,
 392         0xc8, 0xe2, 0x45, 0x45, 0xab, 0x29, 0x8d, 0xbd, 0xe6, 0xf1, 0x26, 0xe5, 0xd1, 0xb2, 0x83, 0xf3,
 393         0xdf, 0x5c, 0x67, 0x55, 0xa8, 0xca, 0xe0, 0xc1, 0x3d, 0xe9, 0x91, 0x0e, 0xea, 0x35, 0x59, 0xe4,
 394         0xfd, 0xa5, 0x26, 0x7a, 0x0f, 0xc5, 0x39, 0xf6, 0x13, 0x52, 0xd9, 0xaa, 0x29, 0x8d, 0x72, 0xf3,
 395         0xf9, 0xfa, 0xd4, 0x2b, 0x7a, 0x0b, 0x27, 0x23, 0xbd, 0xdd, 0x7a, 0xad, 0xd4, 0x6d, 0x38, 0xb8,
 396         0xaf, 0x1e, 0xf4, 0x0c, 0x9e, 0x8c, 0xec, 0x9e, 0x35, 0x1c, 0xb5, 0x7a, 0x03, 0xf7, 0xdc, 0x69,
 397         0xf5, 0xc7, 0xdd, 0x96, 0x63, 0x8f, 0x2e, 0xdc, 0x71, 0x7f, 0x38, 0xb0, 0x4e, 0xed, 0xb6, 0x6d,
 398         0x9d, 0xe9, 0x05, 0x04, 0x50, 0xea, 0xd9, 0xdd, 0xae, 0x3d, 0xd4, 0x95, 0x7a, 0x1b, 0xb4, 0x09,
 399         0x23, 0xdf, 0xd1, 0x01, 0xe8, 0x13, 0xdb, 0xfa, 0x72, 0x07, 0xf9, 0x3f, 0xec, 0xf4, 0x5b, 0x3d,
 400         0xcb, 0xfd, 0xdc, 0xef, 0x5e, 0xe8, 0x0a, 0xda, 0x87, 0xf2, 0xf0, 0xb4, 0x63, 0xf5, 0x5a, 0x6e,
 401         0x8a, 0xd5, 0xb7, 0xd0, 0x7f, 0xa0, 0xb5, 0xc7, 0xdd, 0xae, 0xae, 0xd5, 0x6d, 0xd8, 0x5d, 0xad,
 402         0x16, 0xbd, 0x81, 0x6d, 0xea, 0xb9, 0x61, 0xe2, 0x67, 0xab, 0x2d, 0x37, 0x6b, 0xeb, 0xdb, 0x3c,
 403         0xf7, 0x9c, 0xc4, 0x27, 0x4e, 0x89, 0xca, 0xdf, 0xfa, 0x0f, 0x15, 0x4a, 0x99, 0x0b, 0xbd, 0x00,
 404         0x9d, 0xe3, 0x1b, 0x57, 0x24, 0xdc, 0x9d, 0x93, 0x30, 0x4a, 0x4f, 0x50, 0xca, 0x15, 0x3b, 0x05,
 405         0x67, 0x8f, 0xe3, 0x9b, 0x7e, 0xc2, 0x27, 0xb9, 0x1f, 0x1d, 0xc3, 0x76, 0x8a, 0xc5, 0x74, 0x39,
 406         0xd8, 0x87, 0xcb, 0x8c, 0xcb, 0x33, 0x34, 0xce, 0xf2, 0x33, 0xed, 0x14, 0x9c, 0x12, 0xc7, 0x37,
 407         0x2d, 0x4a, 0xd0, 0x10, 0x76, 0x99, 0x88, 0x49, 0x18, 0x11, 0x2f, 0x8d, 0x54, 0x54, 0x49, 0x7d,
 408         0xb9, 0xa9, 0x58, 0xc3, 0x5e, 0x21, 0x75, 0x0a, 0xce, 0x2d, 0x11, 0xf4, 0x11, 0x8a, 0x89, 0x48,
 409         0xd5, 0xb4, 0x4d, 0x1b, 0xce, 0xd5, 0xc6, 0x22, 0x93, 0xc9, 0x68, 0xd5, 0x36, 0xec, 0xae, 0xea,
 410         0xa3, 0x57, 0x50, 0x4c, 0x27, 0x99, 0xf6, 0xae, 0xfe, 0xd5, 0x28, 0x33, 0x78, 0xf5, 0x13, 0x14,
 411         0xa5, 0xf2, 0xbf, 0x0a, 0x9c, 0x94, 0x40, 0x4b, 0x8d, 0x93, 0x6b, 0x38, 0xf4, 0x02, 0xbe, 0x96,
 412         0x75, 0x02, 0xf2, 0x4f, 0x32, 0x48, 0xe7, 0x3c, 0x50, 0xbe, 0x7e, 0xc8, 0x71, 0x34, 0xf0, 0xb1,
 413         0xa0, 0x46, 0x10, 0x52, 0x93, 0x12, 0x21, 0xb7, 0x60, 0x66, 0x21, 0x3c, 0x63, 0xd1, 0x9f, 0xdf,
 414         0xa6, 0x77, 0xd2, 0x98, 0x96, 0x24, 0xf2, 0xe8, 0x57, 0x00, 0x00, 0x00, 0xff, 0xff, 0x68, 0xe3,
 415         0x1b, 0xd9, 0xc4, 0x04, 0x00, 0x00,
 416 }