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

   1 // Code generated by protoc-gen-go. DO NOT EDIT.
   2 // source: google/bigtable/admin/table/v1/bigtable_table_data.proto
   3
   4 /*
   5 Package table is a generated protocol buffer package.
   6
   7 It is generated from these files:
   8         google/bigtable/admin/table/v1/bigtable_table_data.proto
   9         google/bigtable/admin/table/v1/bigtable_table_service.proto
  10         google/bigtable/admin/table/v1/bigtable_table_service_messages.proto
  11
  12 It has these top-level messages:
  13         Table
  14         ColumnFamily
  15         GcRule
  16         CreateTableRequest
  17         ListTablesRequest
  18         ListTablesResponse
  19         GetTableRequest
  20         DeleteTableRequest
  21         RenameTableRequest
  22         CreateColumnFamilyRequest
  23         DeleteColumnFamilyRequest
  24         BulkDeleteRowsRequest
  25 */
  26 package table
  27
  28 import proto "github.com/golang/protobuf/proto"
  29 import fmt "fmt"
  30 import math "math"
  31 import google_longrunning "google.golang.org/genproto/googleapis/longrunning"
  32 import google_protobuf3 "github.com/golang/protobuf/ptypes/duration"
  33
  34 // Reference imports to suppress errors if they are not otherwise used.
  35 var _ = proto.Marshal
  36 var _ = fmt.Errorf
  37 var _ = math.Inf
  38
  39 // This is a compile-time assertion to ensure that this generated file
  40 // is compatible with the proto package it is being compiled against.
  41 // A compilation error at this line likely means your copy of the
  42 // proto package needs to be updated.
  43 const _ = proto.ProtoPackageIsVersion2 // please upgrade the proto package
  44
  45 type Table_TimestampGranularity int32
  46
  47 const (
  48         Table_MILLIS Table_TimestampGranularity = 0
  49 )
  50
  51 var Table_TimestampGranularity_name = map[int32]string{
  52         0: "MILLIS",
  53 }
  54 var Table_TimestampGranularity_value = map[string]int32{
  55         "MILLIS": 0,
  56 }
  57
  58 func (x Table_TimestampGranularity) String() string {
  59         return proto.EnumName(Table_TimestampGranularity_name, int32(x))
  60 }
  61 func (Table_TimestampGranularity) EnumDescriptor() ([]byte, []int) {
  62         return fileDescriptor0, []int{0, 0}
  63 }
  64
  65 // A collection of user data indexed by row, column, and timestamp.
  66 // Each table is served using the resources of its parent cluster.
  67 type Table struct {
  68         // A unique identifier of the form
  69         // <cluster_name>/tables/[_a-zA-Z0-9][-_.a-zA-Z0-9]*
  70         Name string `protobuf:"bytes,1,opt,name=name" json:"name,omitempty"`
  71         // If this Table is in the process of being created, the Operation used to
  72         // track its progress. As long as this operation is present, the Table will
  73         // not accept any Table Admin or Read/Write requests.
  74         CurrentOperation *google_longrunning.Operation `protobuf:"bytes,2,opt,name=current_operation,json=currentOperation" json:"current_operation,omitempty"`
  75         // The column families configured for this table, mapped by column family id.
  76         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"`
  77         // The granularity (e.g. MILLIS, MICROS) at which timestamps are stored in
  78         // this table. Timestamps not matching the granularity will be rejected.
  79         // Cannot be changed once the table is created.
  80         Granularity Table_TimestampGranularity `protobuf:"varint,4,opt,name=granularity,enum=google.bigtable.admin.table.v1.Table_TimestampGranularity" json:"granularity,omitempty"`
  81 }
  82
  83 func (m *Table) Reset()                    { *m = Table{} }
  84 func (m *Table) String() string            { return proto.CompactTextString(m) }
  85 func (*Table) ProtoMessage()               {}
  86 func (*Table) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{0} }
  87
  88 func (m *Table) GetName() string {
  89         if m != nil {
  90                 return m.Name
  91         }
  92         return ""
  93 }
  94
  95 func (m *Table) GetCurrentOperation() *google_longrunning.Operation {
  96         if m != nil {
  97                 return m.CurrentOperation
  98         }
  99         return nil
 100 }
 101
 102 func (m *Table) GetColumnFamilies() map[string]*ColumnFamily {
 103         if m != nil {
 104                 return m.ColumnFamilies
 105         }
 106         return nil
 107 }
 108
 109 func (m *Table) GetGranularity() Table_TimestampGranularity {
 110         if m != nil {
 111                 return m.Granularity
 112         }
 113         return Table_MILLIS
 114 }
 115
 116 // A set of columns within a table which share a common configuration.
 117 type ColumnFamily struct {
 118         // A unique identifier of the form <table_name>/columnFamilies/[-_.a-zA-Z0-9]+
 119         // The last segment is the same as the "name" field in
 120         // google.bigtable.v1.Family.
 121         Name string `protobuf:"bytes,1,opt,name=name" json:"name,omitempty"`
 122         // Garbage collection expression specified by the following grammar:
 123         //   GC = EXPR
 124         //      | "" ;
 125         //   EXPR = EXPR, "||", EXPR              (* lowest precedence *)
 126         //        | EXPR, "&&", EXPR
 127         //        | "(", EXPR, ")"                (* highest precedence *)
 128         //        | PROP ;
 129         //   PROP = "version() >", NUM32
 130         //        | "age() >", NUM64, [ UNIT ] ;
 131         //   NUM32 = non-zero-digit { digit } ;    (* # NUM32 <= 2^32 - 1 *)
 132         //   NUM64 = non-zero-digit { digit } ;    (* # NUM64 <= 2^63 - 1 *)
 133         //   UNIT =  "d" | "h" | "m"  (* d=days, h=hours, m=minutes, else micros *)
 134         // GC expressions can be up to 500 characters in length
 135         //
 136         // The different types of PROP are defined as follows:
 137         //   version() - cell index, counting from most recent and starting at 1
 138         //   age() - age of the cell (current time minus cell timestamp)
 139         //
 140         // Example: "version() > 3 || (age() > 3d && version() > 1)"
 141         //   drop cells beyond the most recent three, and drop cells older than three
 142         //   days unless they're the most recent cell in the row/column
 143         //
 144         // Garbage collection executes opportunistically in the background, and so
 145         // it's possible for reads to return a cell even if it matches the active GC
 146         // expression for its family.
 147         GcExpression string `protobuf:"bytes,2,opt,name=gc_expression,json=gcExpression" json:"gc_expression,omitempty"`
 148         // Garbage collection rule specified as a protobuf.
 149         // Supersedes `gc_expression`.
 150         // Must serialize to at most 500 bytes.
 151         //
 152         // NOTE: Garbage collection executes opportunistically in the background, and
 153         // so it's possible for reads to return a cell even if it matches the active
 154         // GC expression for its family.
 155         GcRule *GcRule `protobuf:"bytes,3,opt,name=gc_rule,json=gcRule" json:"gc_rule,omitempty"`
 156 }
 157
 158 func (m *ColumnFamily) Reset()                    { *m = ColumnFamily{} }
 159 func (m *ColumnFamily) String() string            { return proto.CompactTextString(m) }
 160 func (*ColumnFamily) ProtoMessage()               {}
 161 func (*ColumnFamily) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{1} }
 162
 163 func (m *ColumnFamily) GetName() string {
 164         if m != nil {
 165                 return m.Name
 166         }
 167         return ""
 168 }
 169
 170 func (m *ColumnFamily) GetGcExpression() string {
 171         if m != nil {
 172                 return m.GcExpression
 173         }
 174         return ""
 175 }
 176
 177 func (m *ColumnFamily) GetGcRule() *GcRule {
 178         if m != nil {
 179                 return m.GcRule
 180         }
 181         return nil
 182 }
 183
 184 // Rule for determining which cells to delete during garbage collection.
 185 type GcRule struct {
 186         // Types that are valid to be assigned to Rule:
 187         //      *GcRule_MaxNumVersions
 188         //      *GcRule_MaxAge
 189         //      *GcRule_Intersection_
 190         //      *GcRule_Union_
 191         Rule isGcRule_Rule `protobuf_oneof:"rule"`
 192 }
 193
 194 func (m *GcRule) Reset()                    { *m = GcRule{} }
 195 func (m *GcRule) String() string            { return proto.CompactTextString(m) }
 196 func (*GcRule) ProtoMessage()               {}
 197 func (*GcRule) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{2} }
 198
 199 type isGcRule_Rule interface {
 200         isGcRule_Rule()
 201 }
 202
 203 type GcRule_MaxNumVersions struct {
 204         MaxNumVersions int32 `protobuf:"varint,1,opt,name=max_num_versions,json=maxNumVersions,oneof"`
 205 }
 206 type GcRule_MaxAge struct {
 207         MaxAge *google_protobuf3.Duration `protobuf:"bytes,2,opt,name=max_age,json=maxAge,oneof"`
 208 }
 209 type GcRule_Intersection_ struct {
 210         Intersection *GcRule_Intersection `protobuf:"bytes,3,opt,name=intersection,oneof"`
 211 }
 212 type GcRule_Union_ struct {
 213         Union *GcRule_Union `protobuf:"bytes,4,opt,name=union,oneof"`
 214 }
 215
 216 func (*GcRule_MaxNumVersions) isGcRule_Rule() {}
 217 func (*GcRule_MaxAge) isGcRule_Rule()         {}
 218 func (*GcRule_Intersection_) isGcRule_Rule()  {}
 219 func (*GcRule_Union_) isGcRule_Rule()         {}
 220
 221 func (m *GcRule) GetRule() isGcRule_Rule {
 222         if m != nil {
 223                 return m.Rule
 224         }
 225         return nil
 226 }
 227
 228 func (m *GcRule) GetMaxNumVersions() int32 {
 229         if x, ok := m.GetRule().(*GcRule_MaxNumVersions); ok {
 230                 return x.MaxNumVersions
 231         }
 232         return 0
 233 }
 234
 235 func (m *GcRule) GetMaxAge() *google_protobuf3.Duration {
 236         if x, ok := m.GetRule().(*GcRule_MaxAge); ok {
 237                 return x.MaxAge
 238         }
 239         return nil
 240 }
 241
 242 func (m *GcRule) GetIntersection() *GcRule_Intersection {
 243         if x, ok := m.GetRule().(*GcRule_Intersection_); ok {
 244                 return x.Intersection
 245         }
 246         return nil
 247 }
 248
 249 func (m *GcRule) GetUnion() *GcRule_Union {
 250         if x, ok := m.GetRule().(*GcRule_Union_); ok {
 251                 return x.Union
 252         }
 253         return nil
 254 }
 255
 256 // XXX_OneofFuncs is for the internal use of the proto package.
 257 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{}) {
 258         return _GcRule_OneofMarshaler, _GcRule_OneofUnmarshaler, _GcRule_OneofSizer, []interface{}{
 259                 (*GcRule_MaxNumVersions)(nil),
 260                 (*GcRule_MaxAge)(nil),
 261                 (*GcRule_Intersection_)(nil),
 262                 (*GcRule_Union_)(nil),
 263         }
 264 }
 265
 266 func _GcRule_OneofMarshaler(msg proto.Message, b *proto.Buffer) error {
 267         m := msg.(*GcRule)
 268         // rule
 269         switch x := m.Rule.(type) {
 270         case *GcRule_MaxNumVersions:
 271                 b.EncodeVarint(1<<3 | proto.WireVarint)
 272                 b.EncodeVarint(uint64(x.MaxNumVersions))
 273         case *GcRule_MaxAge:
 274                 b.EncodeVarint(2<<3 | proto.WireBytes)
 275                 if err := b.EncodeMessage(x.MaxAge); err != nil {
 276                         return err
 277                 }
 278         case *GcRule_Intersection_:
 279                 b.EncodeVarint(3<<3 | proto.WireBytes)
 280                 if err := b.EncodeMessage(x.Intersection); err != nil {
 281                         return err
 282                 }
 283         case *GcRule_Union_:
 284                 b.EncodeVarint(4<<3 | proto.WireBytes)
 285                 if err := b.EncodeMessage(x.Union); err != nil {
 286                         return err
 287                 }
 288         case nil:
 289         default:
 290                 return fmt.Errorf("GcRule.Rule has unexpected type %T", x)
 291         }
 292         return nil
 293 }
 294
 295 func _GcRule_OneofUnmarshaler(msg proto.Message, tag, wire int, b *proto.Buffer) (bool, error) {
 296         m := msg.(*GcRule)
 297         switch tag {
 298         case 1: // rule.max_num_versions
 299                 if wire != proto.WireVarint {
 300                         return true, proto.ErrInternalBadWireType
 301                 }
 302                 x, err := b.DecodeVarint()
 303                 m.Rule = &GcRule_MaxNumVersions{int32(x)}
 304                 return true, err
 305         case 2: // rule.max_age
 306                 if wire != proto.WireBytes {
 307                         return true, proto.ErrInternalBadWireType
 308                 }
 309                 msg := new(google_protobuf3.Duration)
 310                 err := b.DecodeMessage(msg)
 311                 m.Rule = &GcRule_MaxAge{msg}
 312                 return true, err
 313         case 3: // rule.intersection
 314                 if wire != proto.WireBytes {
 315                         return true, proto.ErrInternalBadWireType
 316                 }
 317                 msg := new(GcRule_Intersection)
 318                 err := b.DecodeMessage(msg)
 319                 m.Rule = &GcRule_Intersection_{msg}
 320                 return true, err
 321         case 4: // rule.union
 322                 if wire != proto.WireBytes {
 323                         return true, proto.ErrInternalBadWireType
 324                 }
 325                 msg := new(GcRule_Union)
 326                 err := b.DecodeMessage(msg)
 327                 m.Rule = &GcRule_Union_{msg}
 328                 return true, err
 329         default:
 330                 return false, nil
 331         }
 332 }
 333
 334 func _GcRule_OneofSizer(msg proto.Message) (n int) {
 335         m := msg.(*GcRule)
 336         // rule
 337         switch x := m.Rule.(type) {
 338         case *GcRule_MaxNumVersions:
 339                 n += proto.SizeVarint(1<<3 | proto.WireVarint)
 340                 n += proto.SizeVarint(uint64(x.MaxNumVersions))
 341         case *GcRule_MaxAge:
 342                 s := proto.Size(x.MaxAge)
 343                 n += proto.SizeVarint(2<<3 | proto.WireBytes)
 344                 n += proto.SizeVarint(uint64(s))
 345                 n += s
 346         case *GcRule_Intersection_:
 347                 s := proto.Size(x.Intersection)
 348                 n += proto.SizeVarint(3<<3 | proto.WireBytes)
 349                 n += proto.SizeVarint(uint64(s))
 350                 n += s
 351         case *GcRule_Union_:
 352                 s := proto.Size(x.Union)
 353                 n += proto.SizeVarint(4<<3 | proto.WireBytes)
 354                 n += proto.SizeVarint(uint64(s))
 355                 n += s
 356         case nil:
 357         default:
 358                 panic(fmt.Sprintf("proto: unexpected type %T in oneof", x))
 359         }
 360         return n
 361 }
 362
 363 // A GcRule which deletes cells matching all of the given rules.
 364 type GcRule_Intersection struct {
 365         // Only delete cells which would be deleted by every element of `rules`.
 366         Rules []*GcRule `protobuf:"bytes,1,rep,name=rules" json:"rules,omitempty"`
 367 }
 368
 369 func (m *GcRule_Intersection) Reset()                    { *m = GcRule_Intersection{} }
 370 func (m *GcRule_Intersection) String() string            { return proto.CompactTextString(m) }
 371 func (*GcRule_Intersection) ProtoMessage()               {}
 372 func (*GcRule_Intersection) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{2, 0} }
 373
 374 func (m *GcRule_Intersection) GetRules() []*GcRule {
 375         if m != nil {
 376                 return m.Rules
 377         }
 378         return nil
 379 }
 380
 381 // A GcRule which deletes cells matching any of the given rules.
 382 type GcRule_Union struct {
 383         // Delete cells which would be deleted by any element of `rules`.
 384         Rules []*GcRule `protobuf:"bytes,1,rep,name=rules" json:"rules,omitempty"`
 385 }
 386
 387 func (m *GcRule_Union) Reset()                    { *m = GcRule_Union{} }
 388 func (m *GcRule_Union) String() string            { return proto.CompactTextString(m) }
 389 func (*GcRule_Union) ProtoMessage()               {}
 390 func (*GcRule_Union) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{2, 1} }
 391
 392 func (m *GcRule_Union) GetRules() []*GcRule {
 393         if m != nil {
 394                 return m.Rules
 395         }
 396         return nil
 397 }
 398
 399 func init() {
 400         proto.RegisterType((*Table)(nil), "google.bigtable.admin.table.v1.Table")
 401         proto.RegisterType((*ColumnFamily)(nil), "google.bigtable.admin.table.v1.ColumnFamily")
 402         proto.RegisterType((*GcRule)(nil), "google.bigtable.admin.table.v1.GcRule")
 403         proto.RegisterType((*GcRule_Intersection)(nil), "google.bigtable.admin.table.v1.GcRule.Intersection")
 404         proto.RegisterType((*GcRule_Union)(nil), "google.bigtable.admin.table.v1.GcRule.Union")
 405         proto.RegisterEnum("google.bigtable.admin.table.v1.Table_TimestampGranularity", Table_TimestampGranularity_name, Table_TimestampGranularity_value)
 406 }
 407
 408 func init() {
 409         proto.RegisterFile("google/bigtable/admin/table/v1/bigtable_table_data.proto", fileDescriptor0)
 410 }
 411
 412 var fileDescriptor0 = []byte{
 413         // 579 bytes of a gzipped FileDescriptorProto
 414         0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xa4, 0x94, 0x61, 0x6b, 0xd3, 0x40,
 415         0x18, 0xc7, 0x9b, 0xa5, 0xed, 0xd8, 0xb3, 0x3a, 0xeb, 0x29, 0x52, 0x0b, 0x4a, 0xc9, 0x40, 0x8a,
 416         0xc8, 0x85, 0x6d, 0xbe, 0x98, 0x53, 0x10, 0xbb, 0xcd, 0x6d, 0x32, 0x75, 0xc4, 0x29, 0x28, 0x42,
 417         0xb8, 0x66, 0xb7, 0x23, 0x98, 0xbb, 0x2b, 0x97, 0x5c, 0x69, 0x5f, 0xfb, 0xc6, 0x8f, 0xe2, 0xa7,
 418         0xf0, 0xb3, 0x49, 0xee, 0x2e, 0x35, 0x83, 0xe9, 0x26, 0xbe, 0x49, 0x9e, 0x3c, 0xf7, 0xfc, 0x7f,
 419         0xf7, 0xcf, 0xf3, 0x5c, 0x02, 0xdb, 0x4c, 0x4a, 0x96, 0xd1, 0x70, 0x9c, 0xb2, 0x82, 0x8c, 0x33,
 420         0x1a, 0x92, 0x33, 0x9e, 0x8a, 0xd0, 0xc6, 0xd3, 0x8d, 0x45, 0x3e, 0xb6, 0xd7, 0x33, 0x52, 0x10,
 421         0x3c, 0x51, 0xb2, 0x90, 0xe8, 0x81, 0x55, 0xe2, 0xaa, 0x02, 0x1b, 0x25, 0xb6, 0xf1, 0x74, 0xa3,
 422         0xbf, 0xee, 0xc8, 0x99, 0x14, 0x4c, 0x69, 0x21, 0x52, 0xc1, 0x42, 0x39, 0xa1, 0x8a, 0x14, 0xa9,
 423         0x14, 0xb9, 0x85, 0xf4, 0x1d, 0x24, 0x34, 0x4f, 0x63, 0x7d, 0x1e, 0x9e, 0x69, 0x5b, 0x60, 0xd7,
 424         0x83, 0x9f, 0x3e, 0xb4, 0x4e, 0x4b, 0x22, 0x42, 0xd0, 0x14, 0x84, 0xd3, 0x9e, 0x37, 0xf0, 0x86,
 425         0x2b, 0x91, 0x89, 0xd1, 0x6b, 0xb8, 0x95, 0x68, 0xa5, 0xa8, 0x28, 0xe2, 0x05, 0xb9, 0xb7, 0x34,
 426         0xf0, 0x86, 0xab, 0x9b, 0xf7, 0xb1, 0xb3, 0x57, 0xdb, 0x1e, 0xbf, 0xab, 0x8a, 0xa2, 0xae, 0xd3,
 427         0x2d, 0x32, 0x68, 0x0c, 0x37, 0x13, 0x99, 0x69, 0x2e, 0xe2, 0x73, 0xc2, 0xd3, 0x2c, 0xa5, 0x79,
 428         0xcf, 0x1f, 0xf8, 0xc3, 0xd5, 0xcd, 0xa7, 0xf8, 0xef, 0x2f, 0x8a, 0x8d, 0x3f, 0xbc, 0x6b, 0xc4,
 429         0xaf, 0x9c, 0x76, 0x5f, 0x14, 0x6a, 0x1e, 0xad, 0x25, 0x17, 0x92, 0xe8, 0x0b, 0xac, 0x32, 0x45,
 430         0x84, 0xce, 0x88, 0x4a, 0x8b, 0x79, 0xaf, 0x39, 0xf0, 0x86, 0x6b, 0x9b, 0x3b, 0xd7, 0xe3, 0x9f,
 431         0xa6, 0x9c, 0xe6, 0x05, 0xe1, 0x93, 0x83, 0xdf, 0x84, 0xa8, 0x8e, 0xeb, 0x4b, 0xb8, 0x7d, 0x89,
 432         0x09, 0xd4, 0x05, 0xff, 0x2b, 0x9d, 0xbb, 0xbe, 0x95, 0x21, 0x1a, 0x41, 0x6b, 0x4a, 0x32, 0x4d,
 433         0x5d, 0xab, 0x1e, 0x5f, 0x65, 0xa0, 0x46, 0x9d, 0x47, 0x56, 0xba, 0xb3, 0xb4, 0xed, 0x05, 0x01,
 434         0xdc, 0xb9, 0xcc, 0x15, 0x02, 0x68, 0xbf, 0x39, 0x3a, 0x3e, 0x3e, 0x7a, 0xdf, 0x6d, 0x04, 0xdf,
 435         0x3d, 0xe8, 0xd4, 0xf5, 0x97, 0xce, 0x71, 0x1d, 0x6e, 0xb0, 0x24, 0xa6, 0xb3, 0x89, 0xa2, 0x79,
 436         0x5e, 0xcd, 0x70, 0x25, 0xea, 0xb0, 0x64, 0x7f, 0x91, 0x43, 0x2f, 0x60, 0x99, 0x25, 0xb1, 0xd2,
 437         0x19, 0xed, 0xf9, 0xc6, 0xf7, 0xc3, 0xab, 0x7c, 0x1f, 0x24, 0x91, 0xce, 0x68, 0xd4, 0x66, 0xe6,
 438         0x1e, 0xfc, 0xf0, 0xa1, 0x6d, 0x53, 0xe8, 0x11, 0x74, 0x39, 0x99, 0xc5, 0x42, 0xf3, 0x78, 0x4a,
 439         0x55, 0x89, 0xcf, 0x8d, 0xa1, 0xd6, 0x61, 0x23, 0x5a, 0xe3, 0x64, 0xf6, 0x56, 0xf3, 0x8f, 0x2e,
 440         0x8f, 0x9e, 0xc0, 0x72, 0x59, 0x4b, 0x58, 0xd5, 0xaf, 0x7b, 0xd5, 0xbe, 0xd5, 0xa1, 0xc5, 0x7b,
 441         0xee, 0xd0, 0x1e, 0x36, 0xa2, 0x36, 0x27, 0xb3, 0x97, 0x8c, 0xa2, 0x4f, 0xd0, 0x49, 0x45, 0x41,
 442         0x55, 0x4e, 0x13, 0x73, 0x2a, 0xad, 0xe5, 0xad, 0xeb, 0x59, 0xc6, 0x47, 0x35, 0xe9, 0x61, 0x23,
 443         0xba, 0x80, 0x42, 0x7b, 0xd0, 0xd2, 0xa2, 0x64, 0x36, 0xaf, 0x37, 0x3e, 0xc7, 0xfc, 0x20, 0x2c,
 444         0xcc, 0x8a, 0xfb, 0xc7, 0xd0, 0xa9, 0xef, 0x82, 0x9e, 0x43, 0xab, 0xec, 0x6d, 0xd9, 0x07, 0xff,
 445         0x1f, 0x9a, 0x6b, 0x45, 0xfd, 0x7d, 0x68, 0x19, 0xfe, 0xff, 0x61, 0x46, 0x6d, 0x68, 0x96, 0xc1,
 446         0xe8, 0x9b, 0x07, 0x41, 0x22, 0xf9, 0x15, 0xe2, 0xd1, 0xdd, 0x91, 0x5b, 0x30, 0x9f, 0xc8, 0x1e,
 447         0x29, 0xc8, 0x49, 0x39, 0x92, 0x13, 0xef, 0xf3, 0xae, 0x53, 0x32, 0x99, 0x11, 0xc1, 0xb0, 0x54,
 448         0x2c, 0x64, 0x54, 0x98, 0x81, 0x85, 0x76, 0x89, 0x4c, 0xd2, 0xfc, 0x4f, 0x7f, 0xbd, 0x67, 0x26,
 449         0x18, 0xb7, 0x4d, 0xfd, 0xd6, 0xaf, 0x00, 0x00, 0x00, 0xff, 0xff, 0xd7, 0x80, 0x76, 0xdc, 0x24,
 450         0x05, 0x00, 0x00,
 451 }