vendor/google.golang.org/genproto/googleapis/privacy/dlp/v2beta1/dlp.pb.go

   1 // Code generated by protoc-gen-go. DO NOT EDIT.
   2 // source: google/privacy/dlp/v2beta1/dlp.proto
   3
   4 /*
   5 Package dlp is a generated protocol buffer package.
   6
   7 It is generated from these files:
   8         google/privacy/dlp/v2beta1/dlp.proto
   9         google/privacy/dlp/v2beta1/storage.proto
  10
  11 It has these top-level messages:
  12         InspectConfig
  13         OperationConfig
  14         ContentItem
  15         Table
  16         InspectResult
  17         Finding
  18         Location
  19         TableLocation
  20         Range
  21         ImageLocation
  22         RedactContentRequest
  23         Color
  24         RedactContentResponse
  25         InspectContentRequest
  26         InspectContentResponse
  27         CreateInspectOperationRequest
  28         OutputStorageConfig
  29         InfoTypeStatistics
  30         InspectOperationMetadata
  31         InspectOperationResult
  32         ListInspectFindingsRequest
  33         ListInspectFindingsResponse
  34         InfoTypeDescription
  35         ListInfoTypesRequest
  36         ListInfoTypesResponse
  37         CategoryDescription
  38         ListRootCategoriesRequest
  39         ListRootCategoriesResponse
  40         Value
  41         InfoType
  42         FieldId
  43         PartitionId
  44         KindExpression
  45         PropertyReference
  46         Projection
  47         DatastoreOptions
  48         CloudStorageOptions
  49         CloudStoragePath
  50         BigQueryOptions
  51         StorageConfig
  52         CloudStorageKey
  53         DatastoreKey
  54         Key
  55         RecordKey
  56         BigQueryTable
  57 */
  58 package dlp
  59
  60 import proto "github.com/golang/protobuf/proto"
  61 import fmt "fmt"
  62 import math "math"
  63 import _ "google.golang.org/genproto/googleapis/api/annotations"
  64 import google_longrunning "google.golang.org/genproto/googleapis/longrunning"
  65 import _ "github.com/golang/protobuf/ptypes/empty"
  66 import google_protobuf3 "github.com/golang/protobuf/ptypes/timestamp"
  67 import google_type "google.golang.org/genproto/googleapis/type/date"
  68 import google_type1 "google.golang.org/genproto/googleapis/type/timeofday"
  69
  70 import (
  71         context "golang.org/x/net/context"
  72         grpc "google.golang.org/grpc"
  73 )
  74
  75 // Reference imports to suppress errors if they are not otherwise used.
  76 var _ = proto.Marshal
  77 var _ = fmt.Errorf
  78 var _ = math.Inf
  79
  80 // This is a compile-time assertion to ensure that this generated file
  81 // is compatible with the proto package it is being compiled against.
  82 // A compilation error at this line likely means your copy of the
  83 // proto package needs to be updated.
  84 const _ = proto.ProtoPackageIsVersion2 // please upgrade the proto package
  85
  86 // Categorization of results based on how likely they are to represent a match,
  87 // based on the number of elements they contain which imply a match.
  88 type Likelihood int32
  89
  90 const (
  91         // Default value; information with all likelihoods is included.
  92         Likelihood_LIKELIHOOD_UNSPECIFIED Likelihood = 0
  93         // Few matching elements.
  94         Likelihood_VERY_UNLIKELY Likelihood = 1
  95         Likelihood_UNLIKELY      Likelihood = 2
  96         // Some matching elements.
  97         Likelihood_POSSIBLE Likelihood = 3
  98         Likelihood_LIKELY   Likelihood = 4
  99         // Many matching elements.
 100         Likelihood_VERY_LIKELY Likelihood = 5
 101 )
 102
 103 var Likelihood_name = map[int32]string{
 104         0: "LIKELIHOOD_UNSPECIFIED",
 105         1: "VERY_UNLIKELY",
 106         2: "UNLIKELY",
 107         3: "POSSIBLE",
 108         4: "LIKELY",
 109         5: "VERY_LIKELY",
 110 }
 111 var Likelihood_value = map[string]int32{
 112         "LIKELIHOOD_UNSPECIFIED": 0,
 113         "VERY_UNLIKELY":          1,
 114         "UNLIKELY":               2,
 115         "POSSIBLE":               3,
 116         "LIKELY":                 4,
 117         "VERY_LIKELY":            5,
 118 }
 119
 120 func (x Likelihood) String() string {
 121         return proto.EnumName(Likelihood_name, int32(x))
 122 }
 123 func (Likelihood) EnumDescriptor() ([]byte, []int) { return fileDescriptor0, []int{0} }
 124
 125 // Configuration description of the scanning process.
 126 // When used with redactContent only info_types and min_likelihood are currently
 127 // used.
 128 type InspectConfig struct {
 129         // Restricts what info_types to look for. The values must correspond to
 130         // InfoType values returned by ListInfoTypes or found in documentation.
 131         // Empty info_types runs all enabled detectors.
 132         InfoTypes []*InfoType `protobuf:"bytes,1,rep,name=info_types,json=infoTypes" json:"info_types,omitempty"`
 133         // Only returns findings equal or above this threshold.
 134         MinLikelihood Likelihood `protobuf:"varint,2,opt,name=min_likelihood,json=minLikelihood,enum=google.privacy.dlp.v2beta1.Likelihood" json:"min_likelihood,omitempty"`
 135         // Limits the number of findings per content item or long running operation.
 136         MaxFindings int32 `protobuf:"varint,3,opt,name=max_findings,json=maxFindings" json:"max_findings,omitempty"`
 137         // When true, a contextual quote from the data that triggered a finding is
 138         // included in the response; see Finding.quote.
 139         IncludeQuote bool `protobuf:"varint,4,opt,name=include_quote,json=includeQuote" json:"include_quote,omitempty"`
 140         // When true, excludes type information of the findings.
 141         ExcludeTypes bool `protobuf:"varint,6,opt,name=exclude_types,json=excludeTypes" json:"exclude_types,omitempty"`
 142         // Configuration of findings limit given for specified info types.
 143         InfoTypeLimits []*InspectConfig_InfoTypeLimit `protobuf:"bytes,7,rep,name=info_type_limits,json=infoTypeLimits" json:"info_type_limits,omitempty"`
 144 }
 145
 146 func (m *InspectConfig) Reset()                    { *m = InspectConfig{} }
 147 func (m *InspectConfig) String() string            { return proto.CompactTextString(m) }
 148 func (*InspectConfig) ProtoMessage()               {}
 149 func (*InspectConfig) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{0} }
 150
 151 func (m *InspectConfig) GetInfoTypes() []*InfoType {
 152         if m != nil {
 153                 return m.InfoTypes
 154         }
 155         return nil
 156 }
 157
 158 func (m *InspectConfig) GetMinLikelihood() Likelihood {
 159         if m != nil {
 160                 return m.MinLikelihood
 161         }
 162         return Likelihood_LIKELIHOOD_UNSPECIFIED
 163 }
 164
 165 func (m *InspectConfig) GetMaxFindings() int32 {
 166         if m != nil {
 167                 return m.MaxFindings
 168         }
 169         return 0
 170 }
 171
 172 func (m *InspectConfig) GetIncludeQuote() bool {
 173         if m != nil {
 174                 return m.IncludeQuote
 175         }
 176         return false
 177 }
 178
 179 func (m *InspectConfig) GetExcludeTypes() bool {
 180         if m != nil {
 181                 return m.ExcludeTypes
 182         }
 183         return false
 184 }
 185
 186 func (m *InspectConfig) GetInfoTypeLimits() []*InspectConfig_InfoTypeLimit {
 187         if m != nil {
 188                 return m.InfoTypeLimits
 189         }
 190         return nil
 191 }
 192
 193 // Max findings configuration per info type, per content item or long running
 194 // operation.
 195 type InspectConfig_InfoTypeLimit struct {
 196         // Type of information the findings limit applies to. Only one limit per
 197         // info_type should be provided. If InfoTypeLimit does not have an
 198         // info_type, the DLP API applies the limit against all info_types that are
 199         // found but not specified in another InfoTypeLimit.
 200         InfoType *InfoType `protobuf:"bytes,1,opt,name=info_type,json=infoType" json:"info_type,omitempty"`
 201         // Max findings limit for the given infoType.
 202         MaxFindings int32 `protobuf:"varint,2,opt,name=max_findings,json=maxFindings" json:"max_findings,omitempty"`
 203 }
 204
 205 func (m *InspectConfig_InfoTypeLimit) Reset()                    { *m = InspectConfig_InfoTypeLimit{} }
 206 func (m *InspectConfig_InfoTypeLimit) String() string            { return proto.CompactTextString(m) }
 207 func (*InspectConfig_InfoTypeLimit) ProtoMessage()               {}
 208 func (*InspectConfig_InfoTypeLimit) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{0, 0} }
 209
 210 func (m *InspectConfig_InfoTypeLimit) GetInfoType() *InfoType {
 211         if m != nil {
 212                 return m.InfoType
 213         }
 214         return nil
 215 }
 216
 217 func (m *InspectConfig_InfoTypeLimit) GetMaxFindings() int32 {
 218         if m != nil {
 219                 return m.MaxFindings
 220         }
 221         return 0
 222 }
 223
 224 // Additional configuration for inspect long running operations.
 225 type OperationConfig struct {
 226         // Max number of findings per file, Datastore entity, or database row.
 227         MaxItemFindings int64 `protobuf:"varint,1,opt,name=max_item_findings,json=maxItemFindings" json:"max_item_findings,omitempty"`
 228 }
 229
 230 func (m *OperationConfig) Reset()                    { *m = OperationConfig{} }
 231 func (m *OperationConfig) String() string            { return proto.CompactTextString(m) }
 232 func (*OperationConfig) ProtoMessage()               {}
 233 func (*OperationConfig) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{1} }
 234
 235 func (m *OperationConfig) GetMaxItemFindings() int64 {
 236         if m != nil {
 237                 return m.MaxItemFindings
 238         }
 239         return 0
 240 }
 241
 242 // Container structure for the content to inspect.
 243 type ContentItem struct {
 244         // Type of the content, as defined in Content-Type HTTP header.
 245         // Supported types are: all "text" types, octet streams, PNG images,
 246         // JPEG images.
 247         Type string `protobuf:"bytes,1,opt,name=type" json:"type,omitempty"`
 248         // Data of the item either in the byte array or UTF-8 string form.
 249         //
 250         // Types that are valid to be assigned to DataItem:
 251         //      *ContentItem_Data
 252         //      *ContentItem_Value
 253         //      *ContentItem_Table
 254         DataItem isContentItem_DataItem `protobuf_oneof:"data_item"`
 255 }
 256
 257 func (m *ContentItem) Reset()                    { *m = ContentItem{} }
 258 func (m *ContentItem) String() string            { return proto.CompactTextString(m) }
 259 func (*ContentItem) ProtoMessage()               {}
 260 func (*ContentItem) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{2} }
 261
 262 type isContentItem_DataItem interface {
 263         isContentItem_DataItem()
 264 }
 265
 266 type ContentItem_Data struct {
 267         Data []byte `protobuf:"bytes,2,opt,name=data,proto3,oneof"`
 268 }
 269 type ContentItem_Value struct {
 270         Value string `protobuf:"bytes,3,opt,name=value,oneof"`
 271 }
 272 type ContentItem_Table struct {
 273         Table *Table `protobuf:"bytes,4,opt,name=table,oneof"`
 274 }
 275
 276 func (*ContentItem_Data) isContentItem_DataItem()  {}
 277 func (*ContentItem_Value) isContentItem_DataItem() {}
 278 func (*ContentItem_Table) isContentItem_DataItem() {}
 279
 280 func (m *ContentItem) GetDataItem() isContentItem_DataItem {
 281         if m != nil {
 282                 return m.DataItem
 283         }
 284         return nil
 285 }
 286
 287 func (m *ContentItem) GetType() string {
 288         if m != nil {
 289                 return m.Type
 290         }
 291         return ""
 292 }
 293
 294 func (m *ContentItem) GetData() []byte {
 295         if x, ok := m.GetDataItem().(*ContentItem_Data); ok {
 296                 return x.Data
 297         }
 298         return nil
 299 }
 300
 301 func (m *ContentItem) GetValue() string {
 302         if x, ok := m.GetDataItem().(*ContentItem_Value); ok {
 303                 return x.Value
 304         }
 305         return ""
 306 }
 307
 308 func (m *ContentItem) GetTable() *Table {
 309         if x, ok := m.GetDataItem().(*ContentItem_Table); ok {
 310                 return x.Table
 311         }
 312         return nil
 313 }
 314
 315 // XXX_OneofFuncs is for the internal use of the proto package.
 316 func (*ContentItem) 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{}) {
 317         return _ContentItem_OneofMarshaler, _ContentItem_OneofUnmarshaler, _ContentItem_OneofSizer, []interface{}{
 318                 (*ContentItem_Data)(nil),
 319                 (*ContentItem_Value)(nil),
 320                 (*ContentItem_Table)(nil),
 321         }
 322 }
 323
 324 func _ContentItem_OneofMarshaler(msg proto.Message, b *proto.Buffer) error {
 325         m := msg.(*ContentItem)
 326         // data_item
 327         switch x := m.DataItem.(type) {
 328         case *ContentItem_Data:
 329                 b.EncodeVarint(2<<3 | proto.WireBytes)
 330                 b.EncodeRawBytes(x.Data)
 331         case *ContentItem_Value:
 332                 b.EncodeVarint(3<<3 | proto.WireBytes)
 333                 b.EncodeStringBytes(x.Value)
 334         case *ContentItem_Table:
 335                 b.EncodeVarint(4<<3 | proto.WireBytes)
 336                 if err := b.EncodeMessage(x.Table); err != nil {
 337                         return err
 338                 }
 339         case nil:
 340         default:
 341                 return fmt.Errorf("ContentItem.DataItem has unexpected type %T", x)
 342         }
 343         return nil
 344 }
 345
 346 func _ContentItem_OneofUnmarshaler(msg proto.Message, tag, wire int, b *proto.Buffer) (bool, error) {
 347         m := msg.(*ContentItem)
 348         switch tag {
 349         case 2: // data_item.data
 350                 if wire != proto.WireBytes {
 351                         return true, proto.ErrInternalBadWireType
 352                 }
 353                 x, err := b.DecodeRawBytes(true)
 354                 m.DataItem = &ContentItem_Data{x}
 355                 return true, err
 356         case 3: // data_item.value
 357                 if wire != proto.WireBytes {
 358                         return true, proto.ErrInternalBadWireType
 359                 }
 360                 x, err := b.DecodeStringBytes()
 361                 m.DataItem = &ContentItem_Value{x}
 362                 return true, err
 363         case 4: // data_item.table
 364                 if wire != proto.WireBytes {
 365                         return true, proto.ErrInternalBadWireType
 366                 }
 367                 msg := new(Table)
 368                 err := b.DecodeMessage(msg)
 369                 m.DataItem = &ContentItem_Table{msg}
 370                 return true, err
 371         default:
 372                 return false, nil
 373         }
 374 }
 375
 376 func _ContentItem_OneofSizer(msg proto.Message) (n int) {
 377         m := msg.(*ContentItem)
 378         // data_item
 379         switch x := m.DataItem.(type) {
 380         case *ContentItem_Data:
 381                 n += proto.SizeVarint(2<<3 | proto.WireBytes)
 382                 n += proto.SizeVarint(uint64(len(x.Data)))
 383                 n += len(x.Data)
 384         case *ContentItem_Value:
 385                 n += proto.SizeVarint(3<<3 | proto.WireBytes)
 386                 n += proto.SizeVarint(uint64(len(x.Value)))
 387                 n += len(x.Value)
 388         case *ContentItem_Table:
 389                 s := proto.Size(x.Table)
 390                 n += proto.SizeVarint(4<<3 | proto.WireBytes)
 391                 n += proto.SizeVarint(uint64(s))
 392                 n += s
 393         case nil:
 394         default:
 395                 panic(fmt.Sprintf("proto: unexpected type %T in oneof", x))
 396         }
 397         return n
 398 }
 399
 400 // Structured content to inspect. Up to 50,000 `Value`s per request allowed.
 401 type Table struct {
 402         Headers []*FieldId   `protobuf:"bytes,1,rep,name=headers" json:"headers,omitempty"`
 403         Rows    []*Table_Row `protobuf:"bytes,2,rep,name=rows" json:"rows,omitempty"`
 404 }
 405
 406 func (m *Table) Reset()                    { *m = Table{} }
 407 func (m *Table) String() string            { return proto.CompactTextString(m) }
 408 func (*Table) ProtoMessage()               {}
 409 func (*Table) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{3} }
 410
 411 func (m *Table) GetHeaders() []*FieldId {
 412         if m != nil {
 413                 return m.Headers
 414         }
 415         return nil
 416 }
 417
 418 func (m *Table) GetRows() []*Table_Row {
 419         if m != nil {
 420                 return m.Rows
 421         }
 422         return nil
 423 }
 424
 425 type Table_Row struct {
 426         Values []*Value `protobuf:"bytes,1,rep,name=values" json:"values,omitempty"`
 427 }
 428
 429 func (m *Table_Row) Reset()                    { *m = Table_Row{} }
 430 func (m *Table_Row) String() string            { return proto.CompactTextString(m) }
 431 func (*Table_Row) ProtoMessage()               {}
 432 func (*Table_Row) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{3, 0} }
 433
 434 func (m *Table_Row) GetValues() []*Value {
 435         if m != nil {
 436                 return m.Values
 437         }
 438         return nil
 439 }
 440
 441 // All the findings for a single scanned item.
 442 type InspectResult struct {
 443         // List of findings for an item.
 444         Findings []*Finding `protobuf:"bytes,1,rep,name=findings" json:"findings,omitempty"`
 445         // If true, then this item might have more findings than were returned,
 446         // and the findings returned are an arbitrary subset of all findings.
 447         // The findings list might be truncated because the input items were too
 448         // large, or because the server reached the maximum amount of resources
 449         // allowed for a single API call. For best results, divide the input into
 450         // smaller batches.
 451         FindingsTruncated bool `protobuf:"varint,2,opt,name=findings_truncated,json=findingsTruncated" json:"findings_truncated,omitempty"`
 452 }
 453
 454 func (m *InspectResult) Reset()                    { *m = InspectResult{} }
 455 func (m *InspectResult) String() string            { return proto.CompactTextString(m) }
 456 func (*InspectResult) ProtoMessage()               {}
 457 func (*InspectResult) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{4} }
 458
 459 func (m *InspectResult) GetFindings() []*Finding {
 460         if m != nil {
 461                 return m.Findings
 462         }
 463         return nil
 464 }
 465
 466 func (m *InspectResult) GetFindingsTruncated() bool {
 467         if m != nil {
 468                 return m.FindingsTruncated
 469         }
 470         return false
 471 }
 472
 473 // Container structure describing a single finding within a string or image.
 474 type Finding struct {
 475         // The specific string that may be potentially sensitive info.
 476         Quote string `protobuf:"bytes,1,opt,name=quote" json:"quote,omitempty"`
 477         // The specific type of info the string might be.
 478         InfoType *InfoType `protobuf:"bytes,2,opt,name=info_type,json=infoType" json:"info_type,omitempty"`
 479         // Estimate of how likely it is that the info_type is correct.
 480         Likelihood Likelihood `protobuf:"varint,3,opt,name=likelihood,enum=google.privacy.dlp.v2beta1.Likelihood" json:"likelihood,omitempty"`
 481         // Location of the info found.
 482         Location *Location `protobuf:"bytes,4,opt,name=location" json:"location,omitempty"`
 483         // Timestamp when finding was detected.
 484         CreateTime *google_protobuf3.Timestamp `protobuf:"bytes,6,opt,name=create_time,json=createTime" json:"create_time,omitempty"`
 485 }
 486
 487 func (m *Finding) Reset()                    { *m = Finding{} }
 488 func (m *Finding) String() string            { return proto.CompactTextString(m) }
 489 func (*Finding) ProtoMessage()               {}
 490 func (*Finding) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{5} }
 491
 492 func (m *Finding) GetQuote() string {
 493         if m != nil {
 494                 return m.Quote
 495         }
 496         return ""
 497 }
 498
 499 func (m *Finding) GetInfoType() *InfoType {
 500         if m != nil {
 501                 return m.InfoType
 502         }
 503         return nil
 504 }
 505
 506 func (m *Finding) GetLikelihood() Likelihood {
 507         if m != nil {
 508                 return m.Likelihood
 509         }
 510         return Likelihood_LIKELIHOOD_UNSPECIFIED
 511 }
 512
 513 func (m *Finding) GetLocation() *Location {
 514         if m != nil {
 515                 return m.Location
 516         }
 517         return nil
 518 }
 519
 520 func (m *Finding) GetCreateTime() *google_protobuf3.Timestamp {
 521         if m != nil {
 522                 return m.CreateTime
 523         }
 524         return nil
 525 }
 526
 527 // Specifies the location of a finding within its source item.
 528 type Location struct {
 529         // Zero-based byte offsets within a content item.
 530         ByteRange *Range `protobuf:"bytes,1,opt,name=byte_range,json=byteRange" json:"byte_range,omitempty"`
 531         // Character offsets within a content item, included when content type
 532         // is a text. Default charset assumed to be UTF-8.
 533         CodepointRange *Range `protobuf:"bytes,2,opt,name=codepoint_range,json=codepointRange" json:"codepoint_range,omitempty"`
 534         // Location within an image's pixels.
 535         ImageBoxes []*ImageLocation `protobuf:"bytes,3,rep,name=image_boxes,json=imageBoxes" json:"image_boxes,omitempty"`
 536         // Key of the finding.
 537         RecordKey *RecordKey `protobuf:"bytes,4,opt,name=record_key,json=recordKey" json:"record_key,omitempty"`
 538         // Field id of the field containing the finding.
 539         FieldId *FieldId `protobuf:"bytes,5,opt,name=field_id,json=fieldId" json:"field_id,omitempty"`
 540         // Location within a `ContentItem.Table`.
 541         TableLocation *TableLocation `protobuf:"bytes,6,opt,name=table_location,json=tableLocation" json:"table_location,omitempty"`
 542 }
 543
 544 func (m *Location) Reset()                    { *m = Location{} }
 545 func (m *Location) String() string            { return proto.CompactTextString(m) }
 546 func (*Location) ProtoMessage()               {}
 547 func (*Location) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{6} }
 548
 549 func (m *Location) GetByteRange() *Range {
 550         if m != nil {
 551                 return m.ByteRange
 552         }
 553         return nil
 554 }
 555
 556 func (m *Location) GetCodepointRange() *Range {
 557         if m != nil {
 558                 return m.CodepointRange
 559         }
 560         return nil
 561 }
 562
 563 func (m *Location) GetImageBoxes() []*ImageLocation {
 564         if m != nil {
 565                 return m.ImageBoxes
 566         }
 567         return nil
 568 }
 569
 570 func (m *Location) GetRecordKey() *RecordKey {
 571         if m != nil {
 572                 return m.RecordKey
 573         }
 574         return nil
 575 }
 576
 577 func (m *Location) GetFieldId() *FieldId {
 578         if m != nil {
 579                 return m.FieldId
 580         }
 581         return nil
 582 }
 583
 584 func (m *Location) GetTableLocation() *TableLocation {
 585         if m != nil {
 586                 return m.TableLocation
 587         }
 588         return nil
 589 }
 590
 591 // Location of a finding within a `ContentItem.Table`.
 592 type TableLocation struct {
 593         // The zero-based index of the row where the finding is located.
 594         RowIndex int64 `protobuf:"varint,1,opt,name=row_index,json=rowIndex" json:"row_index,omitempty"`
 595 }
 596
 597 func (m *TableLocation) Reset()                    { *m = TableLocation{} }
 598 func (m *TableLocation) String() string            { return proto.CompactTextString(m) }
 599 func (*TableLocation) ProtoMessage()               {}
 600 func (*TableLocation) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{7} }
 601
 602 func (m *TableLocation) GetRowIndex() int64 {
 603         if m != nil {
 604                 return m.RowIndex
 605         }
 606         return 0
 607 }
 608
 609 // Generic half-open interval [start, end)
 610 type Range struct {
 611         // Index of the first character of the range (inclusive).
 612         Start int64 `protobuf:"varint,1,opt,name=start" json:"start,omitempty"`
 613         // Index of the last character of the range (exclusive).
 614         End int64 `protobuf:"varint,2,opt,name=end" json:"end,omitempty"`
 615 }
 616
 617 func (m *Range) Reset()                    { *m = Range{} }
 618 func (m *Range) String() string            { return proto.CompactTextString(m) }
 619 func (*Range) ProtoMessage()               {}
 620 func (*Range) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{8} }
 621
 622 func (m *Range) GetStart() int64 {
 623         if m != nil {
 624                 return m.Start
 625         }
 626         return 0
 627 }
 628
 629 func (m *Range) GetEnd() int64 {
 630         if m != nil {
 631                 return m.End
 632         }
 633         return 0
 634 }
 635
 636 // Bounding box encompassing detected text within an image.
 637 type ImageLocation struct {
 638         // Top coordinate of the bounding box. (0,0) is upper left.
 639         Top int32 `protobuf:"varint,1,opt,name=top" json:"top,omitempty"`
 640         // Left coordinate of the bounding box. (0,0) is upper left.
 641         Left int32 `protobuf:"varint,2,opt,name=left" json:"left,omitempty"`
 642         // Width of the bounding box in pixels.
 643         Width int32 `protobuf:"varint,3,opt,name=width" json:"width,omitempty"`
 644         // Height of the bounding box in pixels.
 645         Height int32 `protobuf:"varint,4,opt,name=height" json:"height,omitempty"`
 646 }
 647
 648 func (m *ImageLocation) Reset()                    { *m = ImageLocation{} }
 649 func (m *ImageLocation) String() string            { return proto.CompactTextString(m) }
 650 func (*ImageLocation) ProtoMessage()               {}
 651 func (*ImageLocation) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{9} }
 652
 653 func (m *ImageLocation) GetTop() int32 {
 654         if m != nil {
 655                 return m.Top
 656         }
 657         return 0
 658 }
 659
 660 func (m *ImageLocation) GetLeft() int32 {
 661         if m != nil {
 662                 return m.Left
 663         }
 664         return 0
 665 }
 666
 667 func (m *ImageLocation) GetWidth() int32 {
 668         if m != nil {
 669                 return m.Width
 670         }
 671         return 0
 672 }
 673
 674 func (m *ImageLocation) GetHeight() int32 {
 675         if m != nil {
 676                 return m.Height
 677         }
 678         return 0
 679 }
 680
 681 // Request to search for potentially sensitive info in a list of items
 682 // and replace it with a default or provided content.
 683 type RedactContentRequest struct {
 684         // Configuration for the inspector.
 685         InspectConfig *InspectConfig `protobuf:"bytes,1,opt,name=inspect_config,json=inspectConfig" json:"inspect_config,omitempty"`
 686         // The list of items to inspect. Up to 100 are allowed per request.
 687         Items []*ContentItem `protobuf:"bytes,2,rep,name=items" json:"items,omitempty"`
 688         // The strings to replace findings text findings with. Must specify at least
 689         // one of these or one ImageRedactionConfig if redacting images.
 690         ReplaceConfigs []*RedactContentRequest_ReplaceConfig `protobuf:"bytes,3,rep,name=replace_configs,json=replaceConfigs" json:"replace_configs,omitempty"`
 691         // The configuration for specifying what content to redact from images.
 692         ImageRedactionConfigs []*RedactContentRequest_ImageRedactionConfig `protobuf:"bytes,4,rep,name=image_redaction_configs,json=imageRedactionConfigs" json:"image_redaction_configs,omitempty"`
 693 }
 694
 695 func (m *RedactContentRequest) Reset()                    { *m = RedactContentRequest{} }
 696 func (m *RedactContentRequest) String() string            { return proto.CompactTextString(m) }
 697 func (*RedactContentRequest) ProtoMessage()               {}
 698 func (*RedactContentRequest) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{10} }
 699
 700 func (m *RedactContentRequest) GetInspectConfig() *InspectConfig {
 701         if m != nil {
 702                 return m.InspectConfig
 703         }
 704         return nil
 705 }
 706
 707 func (m *RedactContentRequest) GetItems() []*ContentItem {
 708         if m != nil {
 709                 return m.Items
 710         }
 711         return nil
 712 }
 713
 714 func (m *RedactContentRequest) GetReplaceConfigs() []*RedactContentRequest_ReplaceConfig {
 715         if m != nil {
 716                 return m.ReplaceConfigs
 717         }
 718         return nil
 719 }
 720
 721 func (m *RedactContentRequest) GetImageRedactionConfigs() []*RedactContentRequest_ImageRedactionConfig {
 722         if m != nil {
 723                 return m.ImageRedactionConfigs
 724         }
 725         return nil
 726 }
 727
 728 type RedactContentRequest_ReplaceConfig struct {
 729         // Type of information to replace. Only one ReplaceConfig per info_type
 730         // should be provided. If ReplaceConfig does not have an info_type, the DLP
 731         // API matches it against all info_types that are found but not specified in
 732         // another ReplaceConfig.
 733         InfoType *InfoType `protobuf:"bytes,1,opt,name=info_type,json=infoType" json:"info_type,omitempty"`
 734         // Content replacing sensitive information of given type. Max 256 chars.
 735         ReplaceWith string `protobuf:"bytes,2,opt,name=replace_with,json=replaceWith" json:"replace_with,omitempty"`
 736 }
 737
 738 func (m *RedactContentRequest_ReplaceConfig) Reset()         { *m = RedactContentRequest_ReplaceConfig{} }
 739 func (m *RedactContentRequest_ReplaceConfig) String() string { return proto.CompactTextString(m) }
 740 func (*RedactContentRequest_ReplaceConfig) ProtoMessage()    {}
 741 func (*RedactContentRequest_ReplaceConfig) Descriptor() ([]byte, []int) {
 742         return fileDescriptor0, []int{10, 0}
 743 }
 744
 745 func (m *RedactContentRequest_ReplaceConfig) GetInfoType() *InfoType {
 746         if m != nil {
 747                 return m.InfoType
 748         }
 749         return nil
 750 }
 751
 752 func (m *RedactContentRequest_ReplaceConfig) GetReplaceWith() string {
 753         if m != nil {
 754                 return m.ReplaceWith
 755         }
 756         return ""
 757 }
 758
 759 // Configuration for determing how redaction of images should occur.
 760 type RedactContentRequest_ImageRedactionConfig struct {
 761         // Type of information to redact from images.
 762         //
 763         // Types that are valid to be assigned to Target:
 764         //      *RedactContentRequest_ImageRedactionConfig_InfoType
 765         //      *RedactContentRequest_ImageRedactionConfig_RedactAllText
 766         Target isRedactContentRequest_ImageRedactionConfig_Target `protobuf_oneof:"target"`
 767         // The color to use when redacting content from an image. If not specified,
 768         // the default is black.
 769         RedactionColor *Color `protobuf:"bytes,3,opt,name=redaction_color,json=redactionColor" json:"redaction_color,omitempty"`
 770 }
 771
 772 func (m *RedactContentRequest_ImageRedactionConfig) Reset() {
 773         *m = RedactContentRequest_ImageRedactionConfig{}
 774 }
 775 func (m *RedactContentRequest_ImageRedactionConfig) String() string { return proto.CompactTextString(m) }
 776 func (*RedactContentRequest_ImageRedactionConfig) ProtoMessage()    {}
 777 func (*RedactContentRequest_ImageRedactionConfig) Descriptor() ([]byte, []int) {
 778         return fileDescriptor0, []int{10, 1}
 779 }
 780
 781 type isRedactContentRequest_ImageRedactionConfig_Target interface {
 782         isRedactContentRequest_ImageRedactionConfig_Target()
 783 }
 784
 785 type RedactContentRequest_ImageRedactionConfig_InfoType struct {
 786         InfoType *InfoType `protobuf:"bytes,1,opt,name=info_type,json=infoType,oneof"`
 787 }
 788 type RedactContentRequest_ImageRedactionConfig_RedactAllText struct {
 789         RedactAllText bool `protobuf:"varint,2,opt,name=redact_all_text,json=redactAllText,oneof"`
 790 }
 791
 792 func (*RedactContentRequest_ImageRedactionConfig_InfoType) isRedactContentRequest_ImageRedactionConfig_Target() {
 793 }
 794 func (*RedactContentRequest_ImageRedactionConfig_RedactAllText) isRedactContentRequest_ImageRedactionConfig_Target() {
 795 }
 796
 797 func (m *RedactContentRequest_ImageRedactionConfig) GetTarget() isRedactContentRequest_ImageRedactionConfig_Target {
 798         if m != nil {
 799                 return m.Target
 800         }
 801         return nil
 802 }
 803
 804 func (m *RedactContentRequest_ImageRedactionConfig) GetInfoType() *InfoType {
 805         if x, ok := m.GetTarget().(*RedactContentRequest_ImageRedactionConfig_InfoType); ok {
 806                 return x.InfoType
 807         }
 808         return nil
 809 }
 810
 811 func (m *RedactContentRequest_ImageRedactionConfig) GetRedactAllText() bool {
 812         if x, ok := m.GetTarget().(*RedactContentRequest_ImageRedactionConfig_RedactAllText); ok {
 813                 return x.RedactAllText
 814         }
 815         return false
 816 }
 817
 818 func (m *RedactContentRequest_ImageRedactionConfig) GetRedactionColor() *Color {
 819         if m != nil {
 820                 return m.RedactionColor
 821         }
 822         return nil
 823 }
 824
 825 // XXX_OneofFuncs is for the internal use of the proto package.
 826 func (*RedactContentRequest_ImageRedactionConfig) 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{}) {
 827         return _RedactContentRequest_ImageRedactionConfig_OneofMarshaler, _RedactContentRequest_ImageRedactionConfig_OneofUnmarshaler, _RedactContentRequest_ImageRedactionConfig_OneofSizer, []interface{}{
 828                 (*RedactContentRequest_ImageRedactionConfig_InfoType)(nil),
 829                 (*RedactContentRequest_ImageRedactionConfig_RedactAllText)(nil),
 830         }
 831 }
 832
 833 func _RedactContentRequest_ImageRedactionConfig_OneofMarshaler(msg proto.Message, b *proto.Buffer) error {
 834         m := msg.(*RedactContentRequest_ImageRedactionConfig)
 835         // target
 836         switch x := m.Target.(type) {
 837         case *RedactContentRequest_ImageRedactionConfig_InfoType:
 838                 b.EncodeVarint(1<<3 | proto.WireBytes)
 839                 if err := b.EncodeMessage(x.InfoType); err != nil {
 840                         return err
 841                 }
 842         case *RedactContentRequest_ImageRedactionConfig_RedactAllText:
 843                 t := uint64(0)
 844                 if x.RedactAllText {
 845                         t = 1
 846                 }
 847                 b.EncodeVarint(2<<3 | proto.WireVarint)
 848                 b.EncodeVarint(t)
 849         case nil:
 850         default:
 851                 return fmt.Errorf("RedactContentRequest_ImageRedactionConfig.Target has unexpected type %T", x)
 852         }
 853         return nil
 854 }
 855
 856 func _RedactContentRequest_ImageRedactionConfig_OneofUnmarshaler(msg proto.Message, tag, wire int, b *proto.Buffer) (bool, error) {
 857         m := msg.(*RedactContentRequest_ImageRedactionConfig)
 858         switch tag {
 859         case 1: // target.info_type
 860                 if wire != proto.WireBytes {
 861                         return true, proto.ErrInternalBadWireType
 862                 }
 863                 msg := new(InfoType)
 864                 err := b.DecodeMessage(msg)
 865                 m.Target = &RedactContentRequest_ImageRedactionConfig_InfoType{msg}
 866                 return true, err
 867         case 2: // target.redact_all_text
 868                 if wire != proto.WireVarint {
 869                         return true, proto.ErrInternalBadWireType
 870                 }
 871                 x, err := b.DecodeVarint()
 872                 m.Target = &RedactContentRequest_ImageRedactionConfig_RedactAllText{x != 0}
 873                 return true, err
 874         default:
 875                 return false, nil
 876         }
 877 }
 878
 879 func _RedactContentRequest_ImageRedactionConfig_OneofSizer(msg proto.Message) (n int) {
 880         m := msg.(*RedactContentRequest_ImageRedactionConfig)
 881         // target
 882         switch x := m.Target.(type) {
 883         case *RedactContentRequest_ImageRedactionConfig_InfoType:
 884                 s := proto.Size(x.InfoType)
 885                 n += proto.SizeVarint(1<<3 | proto.WireBytes)
 886                 n += proto.SizeVarint(uint64(s))
 887                 n += s
 888         case *RedactContentRequest_ImageRedactionConfig_RedactAllText:
 889                 n += proto.SizeVarint(2<<3 | proto.WireVarint)
 890                 n += 1
 891         case nil:
 892         default:
 893                 panic(fmt.Sprintf("proto: unexpected type %T in oneof", x))
 894         }
 895         return n
 896 }
 897
 898 // Represents a color in the RGB color space.
 899 type Color struct {
 900         // The amount of red in the color as a value in the interval [0, 1].
 901         Red float32 `protobuf:"fixed32,1,opt,name=red" json:"red,omitempty"`
 902         // The amount of green in the color as a value in the interval [0, 1].
 903         Green float32 `protobuf:"fixed32,2,opt,name=green" json:"green,omitempty"`
 904         // The amount of blue in the color as a value in the interval [0, 1].
 905         Blue float32 `protobuf:"fixed32,3,opt,name=blue" json:"blue,omitempty"`
 906 }
 907
 908 func (m *Color) Reset()                    { *m = Color{} }
 909 func (m *Color) String() string            { return proto.CompactTextString(m) }
 910 func (*Color) ProtoMessage()               {}
 911 func (*Color) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{11} }
 912
 913 func (m *Color) GetRed() float32 {
 914         if m != nil {
 915                 return m.Red
 916         }
 917         return 0
 918 }
 919
 920 func (m *Color) GetGreen() float32 {
 921         if m != nil {
 922                 return m.Green
 923         }
 924         return 0
 925 }
 926
 927 func (m *Color) GetBlue() float32 {
 928         if m != nil {
 929                 return m.Blue
 930         }
 931         return 0
 932 }
 933
 934 // Results of redacting a list of items.
 935 type RedactContentResponse struct {
 936         // The redacted content.
 937         Items []*ContentItem `protobuf:"bytes,1,rep,name=items" json:"items,omitempty"`
 938 }
 939
 940 func (m *RedactContentResponse) Reset()                    { *m = RedactContentResponse{} }
 941 func (m *RedactContentResponse) String() string            { return proto.CompactTextString(m) }
 942 func (*RedactContentResponse) ProtoMessage()               {}
 943 func (*RedactContentResponse) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{12} }
 944
 945 func (m *RedactContentResponse) GetItems() []*ContentItem {
 946         if m != nil {
 947                 return m.Items
 948         }
 949         return nil
 950 }
 951
 952 // Request to search for potentially sensitive info in a list of items.
 953 type InspectContentRequest struct {
 954         // Configuration for the inspector.
 955         InspectConfig *InspectConfig `protobuf:"bytes,1,opt,name=inspect_config,json=inspectConfig" json:"inspect_config,omitempty"`
 956         // The list of items to inspect. Items in a single request are
 957         // considered "related" unless inspect_config.independent_inputs is true.
 958         // Up to 100 are allowed per request.
 959         Items []*ContentItem `protobuf:"bytes,2,rep,name=items" json:"items,omitempty"`
 960 }
 961
 962 func (m *InspectContentRequest) Reset()                    { *m = InspectContentRequest{} }
 963 func (m *InspectContentRequest) String() string            { return proto.CompactTextString(m) }
 964 func (*InspectContentRequest) ProtoMessage()               {}
 965 func (*InspectContentRequest) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{13} }
 966
 967 func (m *InspectContentRequest) GetInspectConfig() *InspectConfig {
 968         if m != nil {
 969                 return m.InspectConfig
 970         }
 971         return nil
 972 }
 973
 974 func (m *InspectContentRequest) GetItems() []*ContentItem {
 975         if m != nil {
 976                 return m.Items
 977         }
 978         return nil
 979 }
 980
 981 // Results of inspecting a list of items.
 982 type InspectContentResponse struct {
 983         // Each content_item from the request has a result in this list, in the
 984         // same order as the request.
 985         Results []*InspectResult `protobuf:"bytes,1,rep,name=results" json:"results,omitempty"`
 986 }
 987
 988 func (m *InspectContentResponse) Reset()                    { *m = InspectContentResponse{} }
 989 func (m *InspectContentResponse) String() string            { return proto.CompactTextString(m) }
 990 func (*InspectContentResponse) ProtoMessage()               {}
 991 func (*InspectContentResponse) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{14} }
 992
 993 func (m *InspectContentResponse) GetResults() []*InspectResult {
 994         if m != nil {
 995                 return m.Results
 996         }
 997         return nil
 998 }
 999
1000 // Request for scheduling a scan of a data subset from a Google Platform data
1001 // repository.
1002 type CreateInspectOperationRequest struct {
1003         // Configuration for the inspector.
1004         InspectConfig *InspectConfig `protobuf:"bytes,1,opt,name=inspect_config,json=inspectConfig" json:"inspect_config,omitempty"`
1005         // Specification of the data set to process.
1006         StorageConfig *StorageConfig `protobuf:"bytes,2,opt,name=storage_config,json=storageConfig" json:"storage_config,omitempty"`
1007         // Optional location to store findings. The bucket must already exist and
1008         // the Google APIs service account for DLP must have write permission to
1009         // write to the given bucket.
1010         // <p>Results are split over multiple csv files with each file name matching
1011         // the pattern "[operation_id]_[count].csv", for example
1012         // `3094877188788974909_1.csv`. The `operation_id` matches the
1013         // identifier for the Operation, and the `count` is a counter used for
1014         // tracking the number of files written. <p>The CSV file(s) contain the
1015         // following columns regardless of storage type scanned: <li>id <li>info_type
1016         // <li>likelihood <li>byte size of finding <li>quote <li>timestamp<br/>
1017         // <p>For Cloud Storage the next columns are: <li>file_path
1018         // <li>start_offset<br/>
1019         // <p>For Cloud Datastore the next columns are: <li>project_id
1020         // <li>namespace_id <li>path <li>column_name <li>offset<br/>
1021         // <p>For BigQuery the next columns are: <li>row_number <li>project_id
1022         // <li>dataset_id <li>table_id
1023         OutputConfig *OutputStorageConfig `protobuf:"bytes,3,opt,name=output_config,json=outputConfig" json:"output_config,omitempty"`
1024         // Additional configuration settings for long running operations.
1025         OperationConfig *OperationConfig `protobuf:"bytes,5,opt,name=operation_config,json=operationConfig" json:"operation_config,omitempty"`
1026 }
1027
1028 func (m *CreateInspectOperationRequest) Reset()                    { *m = CreateInspectOperationRequest{} }
1029 func (m *CreateInspectOperationRequest) String() string            { return proto.CompactTextString(m) }
1030 func (*CreateInspectOperationRequest) ProtoMessage()               {}
1031 func (*CreateInspectOperationRequest) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{15} }
1032
1033 func (m *CreateInspectOperationRequest) GetInspectConfig() *InspectConfig {
1034         if m != nil {
1035                 return m.InspectConfig
1036         }
1037         return nil
1038 }
1039
1040 func (m *CreateInspectOperationRequest) GetStorageConfig() *StorageConfig {
1041         if m != nil {
1042                 return m.StorageConfig
1043         }
1044         return nil
1045 }
1046
1047 func (m *CreateInspectOperationRequest) GetOutputConfig() *OutputStorageConfig {
1048         if m != nil {
1049                 return m.OutputConfig
1050         }
1051         return nil
1052 }
1053
1054 func (m *CreateInspectOperationRequest) GetOperationConfig() *OperationConfig {
1055         if m != nil {
1056                 return m.OperationConfig
1057         }
1058         return nil
1059 }
1060
1061 // Cloud repository for storing output.
1062 type OutputStorageConfig struct {
1063         // Types that are valid to be assigned to Type:
1064         //      *OutputStorageConfig_Table
1065         //      *OutputStorageConfig_StoragePath
1066         Type isOutputStorageConfig_Type `protobuf_oneof:"type"`
1067 }
1068
1069 func (m *OutputStorageConfig) Reset()                    { *m = OutputStorageConfig{} }
1070 func (m *OutputStorageConfig) String() string            { return proto.CompactTextString(m) }
1071 func (*OutputStorageConfig) ProtoMessage()               {}
1072 func (*OutputStorageConfig) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{16} }
1073
1074 type isOutputStorageConfig_Type interface {
1075         isOutputStorageConfig_Type()
1076 }
1077
1078 type OutputStorageConfig_Table struct {
1079         Table *BigQueryTable `protobuf:"bytes,1,opt,name=table,oneof"`
1080 }
1081 type OutputStorageConfig_StoragePath struct {
1082         StoragePath *CloudStoragePath `protobuf:"bytes,2,opt,name=storage_path,json=storagePath,oneof"`
1083 }
1084
1085 func (*OutputStorageConfig_Table) isOutputStorageConfig_Type()       {}
1086 func (*OutputStorageConfig_StoragePath) isOutputStorageConfig_Type() {}
1087
1088 func (m *OutputStorageConfig) GetType() isOutputStorageConfig_Type {
1089         if m != nil {
1090                 return m.Type
1091         }
1092         return nil
1093 }
1094
1095 func (m *OutputStorageConfig) GetTable() *BigQueryTable {
1096         if x, ok := m.GetType().(*OutputStorageConfig_Table); ok {
1097                 return x.Table
1098         }
1099         return nil
1100 }
1101
1102 func (m *OutputStorageConfig) GetStoragePath() *CloudStoragePath {
1103         if x, ok := m.GetType().(*OutputStorageConfig_StoragePath); ok {
1104                 return x.StoragePath
1105         }
1106         return nil
1107 }
1108
1109 // XXX_OneofFuncs is for the internal use of the proto package.
1110 func (*OutputStorageConfig) 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{}) {
1111         return _OutputStorageConfig_OneofMarshaler, _OutputStorageConfig_OneofUnmarshaler, _OutputStorageConfig_OneofSizer, []interface{}{
1112                 (*OutputStorageConfig_Table)(nil),
1113                 (*OutputStorageConfig_StoragePath)(nil),
1114         }
1115 }
1116
1117 func _OutputStorageConfig_OneofMarshaler(msg proto.Message, b *proto.Buffer) error {
1118         m := msg.(*OutputStorageConfig)
1119         // type
1120         switch x := m.Type.(type) {
1121         case *OutputStorageConfig_Table:
1122                 b.EncodeVarint(1<<3 | proto.WireBytes)
1123                 if err := b.EncodeMessage(x.Table); err != nil {
1124                         return err
1125                 }
1126         case *OutputStorageConfig_StoragePath:
1127                 b.EncodeVarint(2<<3 | proto.WireBytes)
1128                 if err := b.EncodeMessage(x.StoragePath); err != nil {
1129                         return err
1130                 }
1131         case nil:
1132         default:
1133                 return fmt.Errorf("OutputStorageConfig.Type has unexpected type %T", x)
1134         }
1135         return nil
1136 }
1137
1138 func _OutputStorageConfig_OneofUnmarshaler(msg proto.Message, tag, wire int, b *proto.Buffer) (bool, error) {
1139         m := msg.(*OutputStorageConfig)
1140         switch tag {
1141         case 1: // type.table
1142                 if wire != proto.WireBytes {
1143                         return true, proto.ErrInternalBadWireType
1144                 }
1145                 msg := new(BigQueryTable)
1146                 err := b.DecodeMessage(msg)
1147                 m.Type = &OutputStorageConfig_Table{msg}
1148                 return true, err
1149         case 2: // type.storage_path
1150                 if wire != proto.WireBytes {
1151                         return true, proto.ErrInternalBadWireType
1152                 }
1153                 msg := new(CloudStoragePath)
1154                 err := b.DecodeMessage(msg)
1155                 m.Type = &OutputStorageConfig_StoragePath{msg}
1156                 return true, err
1157         default:
1158                 return false, nil
1159         }
1160 }
1161
1162 func _OutputStorageConfig_OneofSizer(msg proto.Message) (n int) {
1163         m := msg.(*OutputStorageConfig)
1164         // type
1165         switch x := m.Type.(type) {
1166         case *OutputStorageConfig_Table:
1167                 s := proto.Size(x.Table)
1168                 n += proto.SizeVarint(1<<3 | proto.WireBytes)
1169                 n += proto.SizeVarint(uint64(s))
1170                 n += s
1171         case *OutputStorageConfig_StoragePath:
1172                 s := proto.Size(x.StoragePath)
1173                 n += proto.SizeVarint(2<<3 | proto.WireBytes)
1174                 n += proto.SizeVarint(uint64(s))
1175                 n += s
1176         case nil:
1177         default:
1178                 panic(fmt.Sprintf("proto: unexpected type %T in oneof", x))
1179         }
1180         return n
1181 }
1182
1183 // Statistics regarding a specific InfoType.
1184 type InfoTypeStatistics struct {
1185         // The type of finding this stat is for.
1186         InfoType *InfoType `protobuf:"bytes,1,opt,name=info_type,json=infoType" json:"info_type,omitempty"`
1187         // Number of findings for this info type.
1188         Count int64 `protobuf:"varint,2,opt,name=count" json:"count,omitempty"`
1189 }
1190
1191 func (m *InfoTypeStatistics) Reset()                    { *m = InfoTypeStatistics{} }
1192 func (m *InfoTypeStatistics) String() string            { return proto.CompactTextString(m) }
1193 func (*InfoTypeStatistics) ProtoMessage()               {}
1194 func (*InfoTypeStatistics) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{17} }
1195
1196 func (m *InfoTypeStatistics) GetInfoType() *InfoType {
1197         if m != nil {
1198                 return m.InfoType
1199         }
1200         return nil
1201 }
1202
1203 func (m *InfoTypeStatistics) GetCount() int64 {
1204         if m != nil {
1205                 return m.Count
1206         }
1207         return 0
1208 }
1209
1210 // Metadata returned within GetOperation for an inspect request.
1211 type InspectOperationMetadata struct {
1212         // Total size in bytes that were processed.
1213         ProcessedBytes int64 `protobuf:"varint,1,opt,name=processed_bytes,json=processedBytes" json:"processed_bytes,omitempty"`
1214         // Estimate of the number of bytes to process.
1215         TotalEstimatedBytes int64                 `protobuf:"varint,4,opt,name=total_estimated_bytes,json=totalEstimatedBytes" json:"total_estimated_bytes,omitempty"`
1216         InfoTypeStats       []*InfoTypeStatistics `protobuf:"bytes,2,rep,name=info_type_stats,json=infoTypeStats" json:"info_type_stats,omitempty"`
1217         // The time which this request was started.
1218         CreateTime *google_protobuf3.Timestamp `protobuf:"bytes,3,opt,name=create_time,json=createTime" json:"create_time,omitempty"`
1219         // The inspect config used to create the Operation.
1220         RequestInspectConfig *InspectConfig `protobuf:"bytes,5,opt,name=request_inspect_config,json=requestInspectConfig" json:"request_inspect_config,omitempty"`
1221         // The storage config used to create the Operation.
1222         RequestStorageConfig *StorageConfig `protobuf:"bytes,6,opt,name=request_storage_config,json=requestStorageConfig" json:"request_storage_config,omitempty"`
1223         // Optional location to store findings.
1224         RequestOutputConfig *OutputStorageConfig `protobuf:"bytes,7,opt,name=request_output_config,json=requestOutputConfig" json:"request_output_config,omitempty"`
1225 }
1226
1227 func (m *InspectOperationMetadata) Reset()                    { *m = InspectOperationMetadata{} }
1228 func (m *InspectOperationMetadata) String() string            { return proto.CompactTextString(m) }
1229 func (*InspectOperationMetadata) ProtoMessage()               {}
1230 func (*InspectOperationMetadata) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{18} }
1231
1232 func (m *InspectOperationMetadata) GetProcessedBytes() int64 {
1233         if m != nil {
1234                 return m.ProcessedBytes
1235         }
1236         return 0
1237 }
1238
1239 func (m *InspectOperationMetadata) GetTotalEstimatedBytes() int64 {
1240         if m != nil {
1241                 return m.TotalEstimatedBytes
1242         }
1243         return 0
1244 }
1245
1246 func (m *InspectOperationMetadata) GetInfoTypeStats() []*InfoTypeStatistics {
1247         if m != nil {
1248                 return m.InfoTypeStats
1249         }
1250         return nil
1251 }
1252
1253 func (m *InspectOperationMetadata) GetCreateTime() *google_protobuf3.Timestamp {
1254         if m != nil {
1255                 return m.CreateTime
1256         }
1257         return nil
1258 }
1259
1260 func (m *InspectOperationMetadata) GetRequestInspectConfig() *InspectConfig {
1261         if m != nil {
1262                 return m.RequestInspectConfig
1263         }
1264         return nil
1265 }
1266
1267 func (m *InspectOperationMetadata) GetRequestStorageConfig() *StorageConfig {
1268         if m != nil {
1269                 return m.RequestStorageConfig
1270         }
1271         return nil
1272 }
1273
1274 func (m *InspectOperationMetadata) GetRequestOutputConfig() *OutputStorageConfig {
1275         if m != nil {
1276                 return m.RequestOutputConfig
1277         }
1278         return nil
1279 }
1280
1281 // The operational data.
1282 type InspectOperationResult struct {
1283         // The server-assigned name, which is only unique within the same service that
1284         // originally returns it. If you use the default HTTP mapping, the
1285         // `name` should have the format of `inspect/results/{id}`.
1286         Name string `protobuf:"bytes,1,opt,name=name" json:"name,omitempty"`
1287 }
1288
1289 func (m *InspectOperationResult) Reset()                    { *m = InspectOperationResult{} }
1290 func (m *InspectOperationResult) String() string            { return proto.CompactTextString(m) }
1291 func (*InspectOperationResult) ProtoMessage()               {}
1292 func (*InspectOperationResult) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{19} }
1293
1294 func (m *InspectOperationResult) GetName() string {
1295         if m != nil {
1296                 return m.Name
1297         }
1298         return ""
1299 }
1300
1301 // Request for the list of results in a given inspect operation.
1302 type ListInspectFindingsRequest struct {
1303         // Identifier of the results set returned as metadata of
1304         // the longrunning operation created by a call to CreateInspectOperation.
1305         // Should be in the format of `inspect/results/{id}`.
1306         Name string `protobuf:"bytes,1,opt,name=name" json:"name,omitempty"`
1307         // Maximum number of results to return.
1308         // If 0, the implementation selects a reasonable value.
1309         PageSize int32 `protobuf:"varint,2,opt,name=page_size,json=pageSize" json:"page_size,omitempty"`
1310         // The value returned by the last `ListInspectFindingsResponse`; indicates
1311         // that this is a continuation of a prior `ListInspectFindings` call, and that
1312         // the system should return the next page of data.
1313         PageToken string `protobuf:"bytes,3,opt,name=page_token,json=pageToken" json:"page_token,omitempty"`
1314         // Restricts findings to items that match. Supports info_type and likelihood.
1315         // <p>Examples:<br/>
1316         // <li>info_type=EMAIL_ADDRESS
1317         // <li>info_type=PHONE_NUMBER,EMAIL_ADDRESS
1318         // <li>likelihood=VERY_LIKELY
1319         // <li>likelihood=VERY_LIKELY,LIKELY
1320         // <li>info_type=EMAIL_ADDRESS,likelihood=VERY_LIKELY,LIKELY
1321         Filter string `protobuf:"bytes,4,opt,name=filter" json:"filter,omitempty"`
1322 }
1323
1324 func (m *ListInspectFindingsRequest) Reset()                    { *m = ListInspectFindingsRequest{} }
1325 func (m *ListInspectFindingsRequest) String() string            { return proto.CompactTextString(m) }
1326 func (*ListInspectFindingsRequest) ProtoMessage()               {}
1327 func (*ListInspectFindingsRequest) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{20} }
1328
1329 func (m *ListInspectFindingsRequest) GetName() string {
1330         if m != nil {
1331                 return m.Name
1332         }
1333         return ""
1334 }
1335
1336 func (m *ListInspectFindingsRequest) GetPageSize() int32 {
1337         if m != nil {
1338                 return m.PageSize
1339         }
1340         return 0
1341 }
1342
1343 func (m *ListInspectFindingsRequest) GetPageToken() string {
1344         if m != nil {
1345                 return m.PageToken
1346         }
1347         return ""
1348 }
1349
1350 func (m *ListInspectFindingsRequest) GetFilter() string {
1351         if m != nil {
1352                 return m.Filter
1353         }
1354         return ""
1355 }
1356
1357 // Response to the ListInspectFindings request.
1358 type ListInspectFindingsResponse struct {
1359         // The results.
1360         Result *InspectResult `protobuf:"bytes,1,opt,name=result" json:"result,omitempty"`
1361         // If not empty, indicates that there may be more results that match the
1362         // request; this value should be passed in a new `ListInspectFindingsRequest`.
1363         NextPageToken string `protobuf:"bytes,2,opt,name=next_page_token,json=nextPageToken" json:"next_page_token,omitempty"`
1364 }
1365
1366 func (m *ListInspectFindingsResponse) Reset()                    { *m = ListInspectFindingsResponse{} }
1367 func (m *ListInspectFindingsResponse) String() string            { return proto.CompactTextString(m) }
1368 func (*ListInspectFindingsResponse) ProtoMessage()               {}
1369 func (*ListInspectFindingsResponse) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{21} }
1370
1371 func (m *ListInspectFindingsResponse) GetResult() *InspectResult {
1372         if m != nil {
1373                 return m.Result
1374         }
1375         return nil
1376 }
1377
1378 func (m *ListInspectFindingsResponse) GetNextPageToken() string {
1379         if m != nil {
1380                 return m.NextPageToken
1381         }
1382         return ""
1383 }
1384
1385 // Info type description.
1386 type InfoTypeDescription struct {
1387         // Internal name of the info type.
1388         Name string `protobuf:"bytes,1,opt,name=name" json:"name,omitempty"`
1389         // Human readable form of the info type name.
1390         DisplayName string `protobuf:"bytes,2,opt,name=display_name,json=displayName" json:"display_name,omitempty"`
1391         // List of categories this info type belongs to.
1392         Categories []*CategoryDescription `protobuf:"bytes,3,rep,name=categories" json:"categories,omitempty"`
1393 }
1394
1395 func (m *InfoTypeDescription) Reset()                    { *m = InfoTypeDescription{} }
1396 func (m *InfoTypeDescription) String() string            { return proto.CompactTextString(m) }
1397 func (*InfoTypeDescription) ProtoMessage()               {}
1398 func (*InfoTypeDescription) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{22} }
1399
1400 func (m *InfoTypeDescription) GetName() string {
1401         if m != nil {
1402                 return m.Name
1403         }
1404         return ""
1405 }
1406
1407 func (m *InfoTypeDescription) GetDisplayName() string {
1408         if m != nil {
1409                 return m.DisplayName
1410         }
1411         return ""
1412 }
1413
1414 func (m *InfoTypeDescription) GetCategories() []*CategoryDescription {
1415         if m != nil {
1416                 return m.Categories
1417         }
1418         return nil
1419 }
1420
1421 // Request for the list of info types belonging to a given category,
1422 // or all supported info types if no category is specified.
1423 type ListInfoTypesRequest struct {
1424         // Category name as returned by ListRootCategories.
1425         Category string `protobuf:"bytes,1,opt,name=category" json:"category,omitempty"`
1426         // Optional BCP-47 language code for localized info type friendly
1427         // names. If omitted, or if localized strings are not available,
1428         // en-US strings will be returned.
1429         LanguageCode string `protobuf:"bytes,2,opt,name=language_code,json=languageCode" json:"language_code,omitempty"`
1430 }
1431
1432 func (m *ListInfoTypesRequest) Reset()                    { *m = ListInfoTypesRequest{} }
1433 func (m *ListInfoTypesRequest) String() string            { return proto.CompactTextString(m) }
1434 func (*ListInfoTypesRequest) ProtoMessage()               {}
1435 func (*ListInfoTypesRequest) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{23} }
1436
1437 func (m *ListInfoTypesRequest) GetCategory() string {
1438         if m != nil {
1439                 return m.Category
1440         }
1441         return ""
1442 }
1443
1444 func (m *ListInfoTypesRequest) GetLanguageCode() string {
1445         if m != nil {
1446                 return m.LanguageCode
1447         }
1448         return ""
1449 }
1450
1451 // Response to the ListInfoTypes request.
1452 type ListInfoTypesResponse struct {
1453         // Set of sensitive info types belonging to a category.
1454         InfoTypes []*InfoTypeDescription `protobuf:"bytes,1,rep,name=info_types,json=infoTypes" json:"info_types,omitempty"`
1455 }
1456
1457 func (m *ListInfoTypesResponse) Reset()                    { *m = ListInfoTypesResponse{} }
1458 func (m *ListInfoTypesResponse) String() string            { return proto.CompactTextString(m) }
1459 func (*ListInfoTypesResponse) ProtoMessage()               {}
1460 func (*ListInfoTypesResponse) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{24} }
1461
1462 func (m *ListInfoTypesResponse) GetInfoTypes() []*InfoTypeDescription {
1463         if m != nil {
1464                 return m.InfoTypes
1465         }
1466         return nil
1467 }
1468
1469 // Info Type Category description.
1470 type CategoryDescription struct {
1471         // Internal name of the category.
1472         Name string `protobuf:"bytes,1,opt,name=name" json:"name,omitempty"`
1473         // Human readable form of the category name.
1474         DisplayName string `protobuf:"bytes,2,opt,name=display_name,json=displayName" json:"display_name,omitempty"`
1475 }
1476
1477 func (m *CategoryDescription) Reset()                    { *m = CategoryDescription{} }
1478 func (m *CategoryDescription) String() string            { return proto.CompactTextString(m) }
1479 func (*CategoryDescription) ProtoMessage()               {}
1480 func (*CategoryDescription) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{25} }
1481
1482 func (m *CategoryDescription) GetName() string {
1483         if m != nil {
1484                 return m.Name
1485         }
1486         return ""
1487 }
1488
1489 func (m *CategoryDescription) GetDisplayName() string {
1490         if m != nil {
1491                 return m.DisplayName
1492         }
1493         return ""
1494 }
1495
1496 // Request for root categories of Info Types supported by the API.
1497 // Example values might include "FINANCE", "HEALTH", "FAST", "DEFAULT".
1498 type ListRootCategoriesRequest struct {
1499         // Optional language code for localized friendly category names.
1500         // If omitted or if localized strings are not available,
1501         // en-US strings will be returned.
1502         LanguageCode string `protobuf:"bytes,1,opt,name=language_code,json=languageCode" json:"language_code,omitempty"`
1503 }
1504
1505 func (m *ListRootCategoriesRequest) Reset()                    { *m = ListRootCategoriesRequest{} }
1506 func (m *ListRootCategoriesRequest) String() string            { return proto.CompactTextString(m) }
1507 func (*ListRootCategoriesRequest) ProtoMessage()               {}
1508 func (*ListRootCategoriesRequest) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{26} }
1509
1510 func (m *ListRootCategoriesRequest) GetLanguageCode() string {
1511         if m != nil {
1512                 return m.LanguageCode
1513         }
1514         return ""
1515 }
1516
1517 // Response for ListRootCategories request.
1518 type ListRootCategoriesResponse struct {
1519         // List of all into type categories supported by the API.
1520         Categories []*CategoryDescription `protobuf:"bytes,1,rep,name=categories" json:"categories,omitempty"`
1521 }
1522
1523 func (m *ListRootCategoriesResponse) Reset()                    { *m = ListRootCategoriesResponse{} }
1524 func (m *ListRootCategoriesResponse) String() string            { return proto.CompactTextString(m) }
1525 func (*ListRootCategoriesResponse) ProtoMessage()               {}
1526 func (*ListRootCategoriesResponse) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{27} }
1527
1528 func (m *ListRootCategoriesResponse) GetCategories() []*CategoryDescription {
1529         if m != nil {
1530                 return m.Categories
1531         }
1532         return nil
1533 }
1534
1535 // Set of primitive values supported by the system.
1536 type Value struct {
1537         // Types that are valid to be assigned to Type:
1538         //      *Value_IntegerValue
1539         //      *Value_FloatValue
1540         //      *Value_StringValue
1541         //      *Value_BooleanValue
1542         //      *Value_TimestampValue
1543         //      *Value_TimeValue
1544         //      *Value_DateValue
1545         Type isValue_Type `protobuf_oneof:"type"`
1546 }
1547
1548 func (m *Value) Reset()                    { *m = Value{} }
1549 func (m *Value) String() string            { return proto.CompactTextString(m) }
1550 func (*Value) ProtoMessage()               {}
1551 func (*Value) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{28} }
1552
1553 type isValue_Type interface {
1554         isValue_Type()
1555 }
1556
1557 type Value_IntegerValue struct {
1558         IntegerValue int64 `protobuf:"varint,1,opt,name=integer_value,json=integerValue,oneof"`
1559 }
1560 type Value_FloatValue struct {
1561         FloatValue float64 `protobuf:"fixed64,2,opt,name=float_value,json=floatValue,oneof"`
1562 }
1563 type Value_StringValue struct {
1564         StringValue string `protobuf:"bytes,3,opt,name=string_value,json=stringValue,oneof"`
1565 }
1566 type Value_BooleanValue struct {
1567         BooleanValue bool `protobuf:"varint,4,opt,name=boolean_value,json=booleanValue,oneof"`
1568 }
1569 type Value_TimestampValue struct {
1570         TimestampValue *google_protobuf3.Timestamp `protobuf:"bytes,5,opt,name=timestamp_value,json=timestampValue,oneof"`
1571 }
1572 type Value_TimeValue struct {
1573         TimeValue *google_type1.TimeOfDay `protobuf:"bytes,6,opt,name=time_value,json=timeValue,oneof"`
1574 }
1575 type Value_DateValue struct {
1576         DateValue *google_type.Date `protobuf:"bytes,7,opt,name=date_value,json=dateValue,oneof"`
1577 }
1578
1579 func (*Value_IntegerValue) isValue_Type()   {}
1580 func (*Value_FloatValue) isValue_Type()     {}
1581 func (*Value_StringValue) isValue_Type()    {}
1582 func (*Value_BooleanValue) isValue_Type()   {}
1583 func (*Value_TimestampValue) isValue_Type() {}
1584 func (*Value_TimeValue) isValue_Type()      {}
1585 func (*Value_DateValue) isValue_Type()      {}
1586
1587 func (m *Value) GetType() isValue_Type {
1588         if m != nil {
1589                 return m.Type
1590         }
1591         return nil
1592 }
1593
1594 func (m *Value) GetIntegerValue() int64 {
1595         if x, ok := m.GetType().(*Value_IntegerValue); ok {
1596                 return x.IntegerValue
1597         }
1598         return 0
1599 }
1600
1601 func (m *Value) GetFloatValue() float64 {
1602         if x, ok := m.GetType().(*Value_FloatValue); ok {
1603                 return x.FloatValue
1604         }
1605         return 0
1606 }
1607
1608 func (m *Value) GetStringValue() string {
1609         if x, ok := m.GetType().(*Value_StringValue); ok {
1610                 return x.StringValue
1611         }
1612         return ""
1613 }
1614
1615 func (m *Value) GetBooleanValue() bool {
1616         if x, ok := m.GetType().(*Value_BooleanValue); ok {
1617                 return x.BooleanValue
1618         }
1619         return false
1620 }
1621
1622 func (m *Value) GetTimestampValue() *google_protobuf3.Timestamp {
1623         if x, ok := m.GetType().(*Value_TimestampValue); ok {
1624                 return x.TimestampValue
1625         }
1626         return nil
1627 }
1628
1629 func (m *Value) GetTimeValue() *google_type1.TimeOfDay {
1630         if x, ok := m.GetType().(*Value_TimeValue); ok {
1631                 return x.TimeValue
1632         }
1633         return nil
1634 }
1635
1636 func (m *Value) GetDateValue() *google_type.Date {
1637         if x, ok := m.GetType().(*Value_DateValue); ok {
1638                 return x.DateValue
1639         }
1640         return nil
1641 }
1642
1643 // XXX_OneofFuncs is for the internal use of the proto package.
1644 func (*Value) 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{}) {
1645         return _Value_OneofMarshaler, _Value_OneofUnmarshaler, _Value_OneofSizer, []interface{}{
1646                 (*Value_IntegerValue)(nil),
1647                 (*Value_FloatValue)(nil),
1648                 (*Value_StringValue)(nil),
1649                 (*Value_BooleanValue)(nil),
1650                 (*Value_TimestampValue)(nil),
1651                 (*Value_TimeValue)(nil),
1652                 (*Value_DateValue)(nil),
1653         }
1654 }
1655
1656 func _Value_OneofMarshaler(msg proto.Message, b *proto.Buffer) error {
1657         m := msg.(*Value)
1658         // type
1659         switch x := m.Type.(type) {
1660         case *Value_IntegerValue:
1661                 b.EncodeVarint(1<<3 | proto.WireVarint)
1662                 b.EncodeVarint(uint64(x.IntegerValue))
1663         case *Value_FloatValue:
1664                 b.EncodeVarint(2<<3 | proto.WireFixed64)
1665                 b.EncodeFixed64(math.Float64bits(x.FloatValue))
1666         case *Value_StringValue:
1667                 b.EncodeVarint(3<<3 | proto.WireBytes)
1668                 b.EncodeStringBytes(x.StringValue)
1669         case *Value_BooleanValue:
1670                 t := uint64(0)
1671                 if x.BooleanValue {
1672                         t = 1
1673                 }
1674                 b.EncodeVarint(4<<3 | proto.WireVarint)
1675                 b.EncodeVarint(t)
1676         case *Value_TimestampValue:
1677                 b.EncodeVarint(5<<3 | proto.WireBytes)
1678                 if err := b.EncodeMessage(x.TimestampValue); err != nil {
1679                         return err
1680                 }
1681         case *Value_TimeValue:
1682                 b.EncodeVarint(6<<3 | proto.WireBytes)
1683                 if err := b.EncodeMessage(x.TimeValue); err != nil {
1684                         return err
1685                 }
1686         case *Value_DateValue:
1687                 b.EncodeVarint(7<<3 | proto.WireBytes)
1688                 if err := b.EncodeMessage(x.DateValue); err != nil {
1689                         return err
1690                 }
1691         case nil:
1692         default:
1693                 return fmt.Errorf("Value.Type has unexpected type %T", x)
1694         }
1695         return nil
1696 }
1697
1698 func _Value_OneofUnmarshaler(msg proto.Message, tag, wire int, b *proto.Buffer) (bool, error) {
1699         m := msg.(*Value)
1700         switch tag {
1701         case 1: // type.integer_value
1702                 if wire != proto.WireVarint {
1703                         return true, proto.ErrInternalBadWireType
1704                 }
1705                 x, err := b.DecodeVarint()
1706                 m.Type = &Value_IntegerValue{int64(x)}
1707                 return true, err
1708         case 2: // type.float_value
1709                 if wire != proto.WireFixed64 {
1710                         return true, proto.ErrInternalBadWireType
1711                 }
1712                 x, err := b.DecodeFixed64()
1713                 m.Type = &Value_FloatValue{math.Float64frombits(x)}
1714                 return true, err
1715         case 3: // type.string_value
1716                 if wire != proto.WireBytes {
1717                         return true, proto.ErrInternalBadWireType
1718                 }
1719                 x, err := b.DecodeStringBytes()
1720                 m.Type = &Value_StringValue{x}
1721                 return true, err
1722         case 4: // type.boolean_value
1723                 if wire != proto.WireVarint {
1724                         return true, proto.ErrInternalBadWireType
1725                 }
1726                 x, err := b.DecodeVarint()
1727                 m.Type = &Value_BooleanValue{x != 0}
1728                 return true, err
1729         case 5: // type.timestamp_value
1730                 if wire != proto.WireBytes {
1731                         return true, proto.ErrInternalBadWireType
1732                 }
1733                 msg := new(google_protobuf3.Timestamp)
1734                 err := b.DecodeMessage(msg)
1735                 m.Type = &Value_TimestampValue{msg}
1736                 return true, err
1737         case 6: // type.time_value
1738                 if wire != proto.WireBytes {
1739                         return true, proto.ErrInternalBadWireType
1740                 }
1741                 msg := new(google_type1.TimeOfDay)
1742                 err := b.DecodeMessage(msg)
1743                 m.Type = &Value_TimeValue{msg}
1744                 return true, err
1745         case 7: // type.date_value
1746                 if wire != proto.WireBytes {
1747                         return true, proto.ErrInternalBadWireType
1748                 }
1749                 msg := new(google_type.Date)
1750                 err := b.DecodeMessage(msg)
1751                 m.Type = &Value_DateValue{msg}
1752                 return true, err
1753         default:
1754                 return false, nil
1755         }
1756 }
1757
1758 func _Value_OneofSizer(msg proto.Message) (n int) {
1759         m := msg.(*Value)
1760         // type
1761         switch x := m.Type.(type) {
1762         case *Value_IntegerValue:
1763                 n += proto.SizeVarint(1<<3 | proto.WireVarint)
1764                 n += proto.SizeVarint(uint64(x.IntegerValue))
1765         case *Value_FloatValue:
1766                 n += proto.SizeVarint(2<<3 | proto.WireFixed64)
1767                 n += 8
1768         case *Value_StringValue:
1769                 n += proto.SizeVarint(3<<3 | proto.WireBytes)
1770                 n += proto.SizeVarint(uint64(len(x.StringValue)))
1771                 n += len(x.StringValue)
1772         case *Value_BooleanValue:
1773                 n += proto.SizeVarint(4<<3 | proto.WireVarint)
1774                 n += 1
1775         case *Value_TimestampValue:
1776                 s := proto.Size(x.TimestampValue)
1777                 n += proto.SizeVarint(5<<3 | proto.WireBytes)
1778                 n += proto.SizeVarint(uint64(s))
1779                 n += s
1780         case *Value_TimeValue:
1781                 s := proto.Size(x.TimeValue)
1782                 n += proto.SizeVarint(6<<3 | proto.WireBytes)
1783                 n += proto.SizeVarint(uint64(s))
1784                 n += s
1785         case *Value_DateValue:
1786                 s := proto.Size(x.DateValue)
1787                 n += proto.SizeVarint(7<<3 | proto.WireBytes)
1788                 n += proto.SizeVarint(uint64(s))
1789                 n += s
1790         case nil:
1791         default:
1792                 panic(fmt.Sprintf("proto: unexpected type %T in oneof", x))
1793         }
1794         return n
1795 }
1796
1797 func init() {
1798         proto.RegisterType((*InspectConfig)(nil), "google.privacy.dlp.v2beta1.InspectConfig")
1799         proto.RegisterType((*InspectConfig_InfoTypeLimit)(nil), "google.privacy.dlp.v2beta1.InspectConfig.InfoTypeLimit")
1800         proto.RegisterType((*OperationConfig)(nil), "google.privacy.dlp.v2beta1.OperationConfig")
1801         proto.RegisterType((*ContentItem)(nil), "google.privacy.dlp.v2beta1.ContentItem")
1802         proto.RegisterType((*Table)(nil), "google.privacy.dlp.v2beta1.Table")
1803         proto.RegisterType((*Table_Row)(nil), "google.privacy.dlp.v2beta1.Table.Row")
1804         proto.RegisterType((*InspectResult)(nil), "google.privacy.dlp.v2beta1.InspectResult")
1805         proto.RegisterType((*Finding)(nil), "google.privacy.dlp.v2beta1.Finding")
1806         proto.RegisterType((*Location)(nil), "google.privacy.dlp.v2beta1.Location")
1807         proto.RegisterType((*TableLocation)(nil), "google.privacy.dlp.v2beta1.TableLocation")
1808         proto.RegisterType((*Range)(nil), "google.privacy.dlp.v2beta1.Range")
1809         proto.RegisterType((*ImageLocation)(nil), "google.privacy.dlp.v2beta1.ImageLocation")
1810         proto.RegisterType((*RedactContentRequest)(nil), "google.privacy.dlp.v2beta1.RedactContentRequest")
1811         proto.RegisterType((*RedactContentRequest_ReplaceConfig)(nil), "google.privacy.dlp.v2beta1.RedactContentRequest.ReplaceConfig")
1812         proto.RegisterType((*RedactContentRequest_ImageRedactionConfig)(nil), "google.privacy.dlp.v2beta1.RedactContentRequest.ImageRedactionConfig")
1813         proto.RegisterType((*Color)(nil), "google.privacy.dlp.v2beta1.Color")
1814         proto.RegisterType((*RedactContentResponse)(nil), "google.privacy.dlp.v2beta1.RedactContentResponse")
1815         proto.RegisterType((*InspectContentRequest)(nil), "google.privacy.dlp.v2beta1.InspectContentRequest")
1816         proto.RegisterType((*InspectContentResponse)(nil), "google.privacy.dlp.v2beta1.InspectContentResponse")
1817         proto.RegisterType((*CreateInspectOperationRequest)(nil), "google.privacy.dlp.v2beta1.CreateInspectOperationRequest")
1818         proto.RegisterType((*OutputStorageConfig)(nil), "google.privacy.dlp.v2beta1.OutputStorageConfig")
1819         proto.RegisterType((*InfoTypeStatistics)(nil), "google.privacy.dlp.v2beta1.InfoTypeStatistics")
1820         proto.RegisterType((*InspectOperationMetadata)(nil), "google.privacy.dlp.v2beta1.InspectOperationMetadata")
1821         proto.RegisterType((*InspectOperationResult)(nil), "google.privacy.dlp.v2beta1.InspectOperationResult")
1822         proto.RegisterType((*ListInspectFindingsRequest)(nil), "google.privacy.dlp.v2beta1.ListInspectFindingsRequest")
1823         proto.RegisterType((*ListInspectFindingsResponse)(nil), "google.privacy.dlp.v2beta1.ListInspectFindingsResponse")
1824         proto.RegisterType((*InfoTypeDescription)(nil), "google.privacy.dlp.v2beta1.InfoTypeDescription")
1825         proto.RegisterType((*ListInfoTypesRequest)(nil), "google.privacy.dlp.v2beta1.ListInfoTypesRequest")
1826         proto.RegisterType((*ListInfoTypesResponse)(nil), "google.privacy.dlp.v2beta1.ListInfoTypesResponse")
1827         proto.RegisterType((*CategoryDescription)(nil), "google.privacy.dlp.v2beta1.CategoryDescription")
1828         proto.RegisterType((*ListRootCategoriesRequest)(nil), "google.privacy.dlp.v2beta1.ListRootCategoriesRequest")
1829         proto.RegisterType((*ListRootCategoriesResponse)(nil), "google.privacy.dlp.v2beta1.ListRootCategoriesResponse")
1830         proto.RegisterType((*Value)(nil), "google.privacy.dlp.v2beta1.Value")
1831         proto.RegisterEnum("google.privacy.dlp.v2beta1.Likelihood", Likelihood_name, Likelihood_value)
1832 }
1833
1834 // Reference imports to suppress errors if they are not otherwise used.
1835 var _ context.Context
1836 var _ grpc.ClientConn
1837
1838 // This is a compile-time assertion to ensure that this generated file
1839 // is compatible with the grpc package it is being compiled against.
1840 const _ = grpc.SupportPackageIsVersion4
1841
1842 // Client API for DlpService service
1843
1844 type DlpServiceClient interface {
1845         // Finds potentially sensitive info in a list of strings.
1846         // This method has limits on input size, processing time, and output size.
1847         InspectContent(ctx context.Context, in *InspectContentRequest, opts ...grpc.CallOption) (*InspectContentResponse, error)
1848         // Redacts potentially sensitive info from a list of strings.
1849         // This method has limits on input size, processing time, and output size.
1850         RedactContent(ctx context.Context, in *RedactContentRequest, opts ...grpc.CallOption) (*RedactContentResponse, error)
1851         // Schedules a job scanning content in a Google Cloud Platform data
1852         // repository.
1853         CreateInspectOperation(ctx context.Context, in *CreateInspectOperationRequest, opts ...grpc.CallOption) (*google_longrunning.Operation, error)
1854         // Returns list of results for given inspect operation result set id.
1855         ListInspectFindings(ctx context.Context, in *ListInspectFindingsRequest, opts ...grpc.CallOption) (*ListInspectFindingsResponse, error)
1856         // Returns sensitive information types for given category.
1857         ListInfoTypes(ctx context.Context, in *ListInfoTypesRequest, opts ...grpc.CallOption) (*ListInfoTypesResponse, error)
1858         // Returns the list of root categories of sensitive information.
1859         ListRootCategories(ctx context.Context, in *ListRootCategoriesRequest, opts ...grpc.CallOption) (*ListRootCategoriesResponse, error)
1860 }
1861
1862 type dlpServiceClient struct {
1863         cc *grpc.ClientConn
1864 }
1865
1866 func NewDlpServiceClient(cc *grpc.ClientConn) DlpServiceClient {
1867         return &dlpServiceClient{cc}
1868 }
1869
1870 func (c *dlpServiceClient) InspectContent(ctx context.Context, in *InspectContentRequest, opts ...grpc.CallOption) (*InspectContentResponse, error) {
1871         out := new(InspectContentResponse)
1872         err := grpc.Invoke(ctx, "/google.privacy.dlp.v2beta1.DlpService/InspectContent", in, out, c.cc, opts...)
1873         if err != nil {
1874                 return nil, err
1875         }
1876         return out, nil
1877 }
1878
1879 func (c *dlpServiceClient) RedactContent(ctx context.Context, in *RedactContentRequest, opts ...grpc.CallOption) (*RedactContentResponse, error) {
1880         out := new(RedactContentResponse)
1881         err := grpc.Invoke(ctx, "/google.privacy.dlp.v2beta1.DlpService/RedactContent", in, out, c.cc, opts...)
1882         if err != nil {
1883                 return nil, err
1884         }
1885         return out, nil
1886 }
1887
1888 func (c *dlpServiceClient) CreateInspectOperation(ctx context.Context, in *CreateInspectOperationRequest, opts ...grpc.CallOption) (*google_longrunning.Operation, error) {
1889         out := new(google_longrunning.Operation)
1890         err := grpc.Invoke(ctx, "/google.privacy.dlp.v2beta1.DlpService/CreateInspectOperation", in, out, c.cc, opts...)
1891         if err != nil {
1892                 return nil, err
1893         }
1894         return out, nil
1895 }
1896
1897 func (c *dlpServiceClient) ListInspectFindings(ctx context.Context, in *ListInspectFindingsRequest, opts ...grpc.CallOption) (*ListInspectFindingsResponse, error) {
1898         out := new(ListInspectFindingsResponse)
1899         err := grpc.Invoke(ctx, "/google.privacy.dlp.v2beta1.DlpService/ListInspectFindings", in, out, c.cc, opts...)
1900         if err != nil {
1901                 return nil, err
1902         }
1903         return out, nil
1904 }
1905
1906 func (c *dlpServiceClient) ListInfoTypes(ctx context.Context, in *ListInfoTypesRequest, opts ...grpc.CallOption) (*ListInfoTypesResponse, error) {
1907         out := new(ListInfoTypesResponse)
1908         err := grpc.Invoke(ctx, "/google.privacy.dlp.v2beta1.DlpService/ListInfoTypes", in, out, c.cc, opts...)
1909         if err != nil {
1910                 return nil, err
1911         }
1912         return out, nil
1913 }
1914
1915 func (c *dlpServiceClient) ListRootCategories(ctx context.Context, in *ListRootCategoriesRequest, opts ...grpc.CallOption) (*ListRootCategoriesResponse, error) {
1916         out := new(ListRootCategoriesResponse)
1917         err := grpc.Invoke(ctx, "/google.privacy.dlp.v2beta1.DlpService/ListRootCategories", in, out, c.cc, opts...)
1918         if err != nil {
1919                 return nil, err
1920         }
1921         return out, nil
1922 }
1923
1924 // Server API for DlpService service
1925
1926 type DlpServiceServer interface {
1927         // Finds potentially sensitive info in a list of strings.
1928         // This method has limits on input size, processing time, and output size.
1929         InspectContent(context.Context, *InspectContentRequest) (*InspectContentResponse, error)
1930         // Redacts potentially sensitive info from a list of strings.
1931         // This method has limits on input size, processing time, and output size.
1932         RedactContent(context.Context, *RedactContentRequest) (*RedactContentResponse, error)
1933         // Schedules a job scanning content in a Google Cloud Platform data
1934         // repository.
1935         CreateInspectOperation(context.Context, *CreateInspectOperationRequest) (*google_longrunning.Operation, error)
1936         // Returns list of results for given inspect operation result set id.
1937         ListInspectFindings(context.Context, *ListInspectFindingsRequest) (*ListInspectFindingsResponse, error)
1938         // Returns sensitive information types for given category.
1939         ListInfoTypes(context.Context, *ListInfoTypesRequest) (*ListInfoTypesResponse, error)
1940         // Returns the list of root categories of sensitive information.
1941         ListRootCategories(context.Context, *ListRootCategoriesRequest) (*ListRootCategoriesResponse, error)
1942 }
1943
1944 func RegisterDlpServiceServer(s *grpc.Server, srv DlpServiceServer) {
1945         s.RegisterService(&_DlpService_serviceDesc, srv)
1946 }
1947
1948 func _DlpService_InspectContent_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
1949         in := new(InspectContentRequest)
1950         if err := dec(in); err != nil {
1951                 return nil, err
1952         }
1953         if interceptor == nil {
1954                 return srv.(DlpServiceServer).InspectContent(ctx, in)
1955         }
1956         info := &grpc.UnaryServerInfo{
1957                 Server:     srv,
1958                 FullMethod: "/google.privacy.dlp.v2beta1.DlpService/InspectContent",
1959         }
1960         handler := func(ctx context.Context, req interface{}) (interface{}, error) {
1961                 return srv.(DlpServiceServer).InspectContent(ctx, req.(*InspectContentRequest))
1962         }
1963         return interceptor(ctx, in, info, handler)
1964 }
1965
1966 func _DlpService_RedactContent_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
1967         in := new(RedactContentRequest)
1968         if err := dec(in); err != nil {
1969                 return nil, err
1970         }
1971         if interceptor == nil {
1972                 return srv.(DlpServiceServer).RedactContent(ctx, in)
1973         }
1974         info := &grpc.UnaryServerInfo{
1975                 Server:     srv,
1976                 FullMethod: "/google.privacy.dlp.v2beta1.DlpService/RedactContent",
1977         }
1978         handler := func(ctx context.Context, req interface{}) (interface{}, error) {
1979                 return srv.(DlpServiceServer).RedactContent(ctx, req.(*RedactContentRequest))
1980         }
1981         return interceptor(ctx, in, info, handler)
1982 }
1983
1984 func _DlpService_CreateInspectOperation_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
1985         in := new(CreateInspectOperationRequest)
1986         if err := dec(in); err != nil {
1987                 return nil, err
1988         }
1989         if interceptor == nil {
1990                 return srv.(DlpServiceServer).CreateInspectOperation(ctx, in)
1991         }
1992         info := &grpc.UnaryServerInfo{
1993                 Server:     srv,
1994                 FullMethod: "/google.privacy.dlp.v2beta1.DlpService/CreateInspectOperation",
1995         }
1996         handler := func(ctx context.Context, req interface{}) (interface{}, error) {
1997                 return srv.(DlpServiceServer).CreateInspectOperation(ctx, req.(*CreateInspectOperationRequest))
1998         }
1999         return interceptor(ctx, in, info, handler)
2000 }
2001
2002 func _DlpService_ListInspectFindings_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
2003         in := new(ListInspectFindingsRequest)
2004         if err := dec(in); err != nil {
2005                 return nil, err
2006         }
2007         if interceptor == nil {
2008                 return srv.(DlpServiceServer).ListInspectFindings(ctx, in)
2009         }
2010         info := &grpc.UnaryServerInfo{
2011                 Server:     srv,
2012                 FullMethod: "/google.privacy.dlp.v2beta1.DlpService/ListInspectFindings",
2013         }
2014         handler := func(ctx context.Context, req interface{}) (interface{}, error) {
2015                 return srv.(DlpServiceServer).ListInspectFindings(ctx, req.(*ListInspectFindingsRequest))
2016         }
2017         return interceptor(ctx, in, info, handler)
2018 }
2019
2020 func _DlpService_ListInfoTypes_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
2021         in := new(ListInfoTypesRequest)
2022         if err := dec(in); err != nil {
2023                 return nil, err
2024         }
2025         if interceptor == nil {
2026                 return srv.(DlpServiceServer).ListInfoTypes(ctx, in)
2027         }
2028         info := &grpc.UnaryServerInfo{
2029                 Server:     srv,
2030                 FullMethod: "/google.privacy.dlp.v2beta1.DlpService/ListInfoTypes",
2031         }
2032         handler := func(ctx context.Context, req interface{}) (interface{}, error) {
2033                 return srv.(DlpServiceServer).ListInfoTypes(ctx, req.(*ListInfoTypesRequest))
2034         }
2035         return interceptor(ctx, in, info, handler)
2036 }
2037
2038 func _DlpService_ListRootCategories_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
2039         in := new(ListRootCategoriesRequest)
2040         if err := dec(in); err != nil {
2041                 return nil, err
2042         }
2043         if interceptor == nil {
2044                 return srv.(DlpServiceServer).ListRootCategories(ctx, in)
2045         }
2046         info := &grpc.UnaryServerInfo{
2047                 Server:     srv,
2048                 FullMethod: "/google.privacy.dlp.v2beta1.DlpService/ListRootCategories",
2049         }
2050         handler := func(ctx context.Context, req interface{}) (interface{}, error) {
2051                 return srv.(DlpServiceServer).ListRootCategories(ctx, req.(*ListRootCategoriesRequest))
2052         }
2053         return interceptor(ctx, in, info, handler)
2054 }
2055
2056 var _DlpService_serviceDesc = grpc.ServiceDesc{
2057         ServiceName: "google.privacy.dlp.v2beta1.DlpService",
2058         HandlerType: (*DlpServiceServer)(nil),
2059         Methods: []grpc.MethodDesc{
2060                 {
2061                         MethodName: "InspectContent",
2062                         Handler:    _DlpService_InspectContent_Handler,
2063                 },
2064                 {
2065                         MethodName: "RedactContent",
2066                         Handler:    _DlpService_RedactContent_Handler,
2067                 },
2068                 {
2069                         MethodName: "CreateInspectOperation",
2070                         Handler:    _DlpService_CreateInspectOperation_Handler,
2071                 },
2072                 {
2073                         MethodName: "ListInspectFindings",
2074                         Handler:    _DlpService_ListInspectFindings_Handler,
2075                 },
2076                 {
2077                         MethodName: "ListInfoTypes",
2078                         Handler:    _DlpService_ListInfoTypes_Handler,
2079                 },
2080                 {
2081                         MethodName: "ListRootCategories",
2082                         Handler:    _DlpService_ListRootCategories_Handler,
2083                 },
2084         },
2085         Streams:  []grpc.StreamDesc{},
2086         Metadata: "google/privacy/dlp/v2beta1/dlp.proto",
2087 }
2088
2089 func init() { proto.RegisterFile("google/privacy/dlp/v2beta1/dlp.proto", fileDescriptor0) }
2090
2091 var fileDescriptor0 = []byte{
2092         // 2313 bytes of a gzipped FileDescriptorProto
2093         0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xcc, 0x59, 0xcf, 0x6f, 0x1b, 0xc7,
2094         0xf5, 0xd7, 0x52, 0xa2, 0x44, 0x3e, 0x8a, 0x92, 0x3c, 0xfa, 0x61, 0x85, 0x8e, 0xbf, 0x91, 0x57,
2095         0x89, 0x23, 0xeb, 0xeb, 0x92, 0x31, 0x8b, 0xda, 0x70, 0x02, 0xa5, 0xb6, 0x28, 0xb9, 0x52, 0xa3,
2096         0x58, 0xf2, 0x48, 0x51, 0x90, 0x02, 0xc5, 0x62, 0xc5, 0x1d, 0x51, 0x03, 0x2f, 0x77, 0x36, 0xbb,
2097         0x43, 0x4b, 0x4c, 0x60, 0x14, 0x28, 0x8a, 0xa2, 0xf7, 0x1e, 0x5a, 0x14, 0xed, 0xad, 0x87, 0xb6,
2098         0xe8, 0x2d, 0xb7, 0xa2, 0xb7, 0xfe, 0x09, 0x3d, 0x15, 0xbd, 0xe6, 0xd4, 0x5b, 0x2f, 0x3d, 0x17,
2099         0xf3, 0x6b, 0xb9, 0x94, 0xe8, 0x95, 0xe8, 0xa6, 0x40, 0x6f, 0x33, 0x6f, 0xde, 0xe7, 0xcd, 0x9b,
2100         0x37, 0xef, 0xd7, 0xec, 0xc2, 0xdb, 0x2d, 0xc6, 0x5a, 0x3e, 0xa9, 0x85, 0x11, 0x7d, 0xe1, 0x36,
2101         0xbb, 0x35, 0xcf, 0x0f, 0x6b, 0x2f, 0xea, 0x47, 0x84, 0xbb, 0xf7, 0xc4, 0xb8, 0x1a, 0x46, 0x8c,
2102         0x33, 0x54, 0x51, 0x5c, 0x55, 0xcd, 0x55, 0x15, 0x2b, 0x9a, 0xab, 0xf2, 0xa6, 0x96, 0xe0, 0x86,
2103         0xb4, 0xe6, 0x06, 0x01, 0xe3, 0x2e, 0xa7, 0x2c, 0x88, 0x15, 0xb2, 0xb2, 0xac, 0x57, 0x7d, 0x16,
2104         0xb4, 0xa2, 0x4e, 0x10, 0xd0, 0xa0, 0x55, 0x63, 0x21, 0x89, 0xfa, 0x98, 0x56, 0x32, 0x94, 0x88,
2105         0x39, 0x8b, 0xdc, 0x16, 0xd1, 0x9c, 0x37, 0x12, 0x4e, 0xc6, 0xd9, 0x51, 0xe7, 0xb8, 0x46, 0xda,
2106         0x21, 0xef, 0xea, 0xc5, 0xb7, 0xce, 0x2f, 0x72, 0xda, 0x26, 0x31, 0x77, 0xdb, 0xfa, 0x18, 0x95,
2107         0x05, 0xcd, 0xc0, 0xbb, 0x21, 0xa9, 0x79, 0x2e, 0x3f, 0x2f, 0x55, 0xd2, 0x05, 0x88, 0x1d, 0x7b,
2108         0xae, 0x96, 0x6a, 0xff, 0x63, 0x14, 0xca, 0xdb, 0x41, 0x1c, 0x92, 0x26, 0x6f, 0xb0, 0xe0, 0x98,
2109         0xb6, 0x50, 0x03, 0x80, 0x06, 0xc7, 0xcc, 0x11, 0xec, 0xf1, 0xa2, 0xb5, 0x34, 0xba, 0x52, 0xaa,
2110         0xbf, 0x5d, 0x7d, 0xb5, 0x89, 0xaa, 0xdb, 0xc1, 0x31, 0x3b, 0xe8, 0x86, 0x04, 0x17, 0xa9, 0x1e,
2111         0xc5, 0xe8, 0x63, 0x98, 0x6a, 0xd3, 0xc0, 0xf1, 0xe9, 0x73, 0xe2, 0xd3, 0x13, 0xc6, 0xbc, 0xc5,
2112         0xdc, 0x92, 0xb5, 0x32, 0x55, 0xbf, 0x9d, 0x25, 0x68, 0x27, 0xe1, 0xc6, 0xe5, 0x36, 0x0d, 0x7a,
2113         0x53, 0x74, 0x0b, 0x26, 0xdb, 0xee, 0x99, 0x73, 0x4c, 0x03, 0x8f, 0x06, 0xad, 0x78, 0x71, 0x74,
2114         0xc9, 0x5a, 0xc9, 0xe3, 0x52, 0xdb, 0x3d, 0x7b, 0xa2, 0x49, 0x68, 0x19, 0xca, 0x34, 0x68, 0xfa,
2115         0x1d, 0x8f, 0x38, 0x9f, 0x77, 0x18, 0x27, 0x8b, 0x63, 0x4b, 0xd6, 0x4a, 0x01, 0x4f, 0x6a, 0xe2,
2116         0x33, 0x41, 0x13, 0x4c, 0xe4, 0x4c, 0x31, 0xa9, 0xe3, 0x8d, 0x2b, 0x26, 0x4d, 0x54, 0xba, 0xbb,
2117         0x30, 0x93, 0x18, 0xc0, 0xf1, 0x69, 0x9b, 0xf2, 0x78, 0x71, 0x42, 0x9a, 0xe1, 0x41, 0xb6, 0x19,
2118         0x52, 0x56, 0x4c, 0x8c, 0xb2, 0x23, 0xf0, 0x78, 0x8a, 0xa6, 0xa7, 0x71, 0xa5, 0x23, 0x8c, 0x9e,
2119         0xa2, 0xa0, 0xc7, 0x50, 0x4c, 0xf6, 0x5c, 0xb4, 0x96, 0xac, 0x2b, 0xdb, 0xbc, 0x60, 0x24, 0x5f,
2120         0xb0, 0x51, 0xee, 0x82, 0x8d, 0xec, 0x35, 0x98, 0xde, 0x35, 0xde, 0xa9, 0x6f, 0x7b, 0x15, 0xae,
2121         0x09, 0x14, 0xe5, 0xa4, 0xdd, 0x83, 0x0a, 0x05, 0x46, 0xf1, 0x74, 0xdb, 0x3d, 0xdb, 0xe6, 0xa4,
2122         0x9d, 0xc0, 0x7f, 0x61, 0x41, 0xa9, 0xc1, 0x02, 0x4e, 0x02, 0x2e, 0xe8, 0x08, 0xc1, 0x58, 0xa2,
2123         0x6f, 0x11, 0xcb, 0x31, 0x9a, 0x83, 0x31, 0xcf, 0xe5, 0xae, 0xdc, 0x7d, 0x72, 0x6b, 0x04, 0xcb,
2124         0x19, 0x5a, 0x80, 0xfc, 0x0b, 0xd7, 0xef, 0x10, 0x79, 0x71, 0xc5, 0xad, 0x11, 0xac, 0xa6, 0xe8,
2125         0x21, 0xe4, 0xb9, 0x7b, 0xe4, 0xab, 0xcb, 0x2a, 0xd5, 0x6f, 0x65, 0x1d, 0xf9, 0x40, 0x30, 0x0a,
2126         0xa8, 0x44, 0xac, 0x97, 0xa0, 0x28, 0x44, 0x4b, 0xcd, 0xed, 0xbf, 0x58, 0x90, 0x97, 0xeb, 0x68,
2127         0x0d, 0x26, 0x4e, 0x88, 0xeb, 0x91, 0xc8, 0xb8, 0xee, 0x72, 0x96, 0xcc, 0x27, 0x94, 0xf8, 0xde,
2128         0xb6, 0x87, 0x0d, 0x06, 0x3d, 0x84, 0xb1, 0x88, 0x9d, 0x0a, 0xe3, 0x09, 0xec, 0x3b, 0x97, 0xea,
2129         0x53, 0xc5, 0xec, 0x14, 0x4b, 0x48, 0xe5, 0x11, 0x8c, 0x62, 0x76, 0x8a, 0x1e, 0xc2, 0xb8, 0x3c,
2130         0x9b, 0xd9, 0x3f, 0xf3, 0x4c, 0x87, 0x82, 0x13, 0x6b, 0x80, 0xfd, 0xa3, 0x24, 0x14, 0x31, 0x89,
2131         0x3b, 0x3e, 0x47, 0xdf, 0x85, 0x42, 0xea, 0x4e, 0xae, 0x70, 0x1a, 0xc9, 0x8b, 0x13, 0x10, 0xfa,
2132         0x16, 0x20, 0x33, 0x76, 0x78, 0xd4, 0x09, 0x9a, 0x2e, 0x27, 0x2a, 0x14, 0x0b, 0xf8, 0x9a, 0x59,
2133         0x39, 0x30, 0x0b, 0xf6, 0xef, 0x73, 0x30, 0xa1, 0x85, 0xa0, 0x39, 0xc8, 0xab, 0x38, 0x52, 0xb7,
2134         0xab, 0x26, 0xfd, 0x7e, 0x9a, 0x7b, 0x2d, 0x3f, 0x7d, 0x02, 0x90, 0x4a, 0x0b, 0xa3, 0x43, 0xa5,
2135         0x85, 0x14, 0x12, 0x3d, 0x82, 0x82, 0xcf, 0x9a, 0xd2, 0x97, 0xb5, 0xfb, 0x64, 0x6a, 0xb2, 0xa3,
2136         0x79, 0x71, 0x82, 0x42, 0x1f, 0x40, 0xa9, 0x19, 0x11, 0x97, 0x13, 0x47, 0x64, 0x45, 0x99, 0x0b,
2137         0x4a, 0xf5, 0x4a, 0x4f, 0x88, 0xca, 0xb3, 0xd5, 0x03, 0x93, 0x67, 0x31, 0x28, 0x76, 0x41, 0xb0,
2138         0xff, 0x3c, 0x0a, 0x05, 0x23, 0x13, 0x3d, 0x02, 0x38, 0xea, 0x72, 0xe2, 0x44, 0x6e, 0xd0, 0x32,
2139         0xf1, 0x9b, 0x79, 0xf1, 0x58, 0x30, 0xe2, 0xa2, 0x00, 0xc9, 0x21, 0xfa, 0x3e, 0x4c, 0x37, 0x99,
2140         0x47, 0x42, 0x46, 0x03, 0xae, 0xc5, 0xe4, 0xae, 0x2a, 0x66, 0x2a, 0x41, 0x1a, 0x59, 0x25, 0xda,
2141         0x76, 0x5b, 0xc4, 0x39, 0x62, 0x67, 0x44, 0x24, 0x4b, 0xe1, 0x39, 0x77, 0x32, 0xaf, 0x49, 0xb0,
2142         0x27, 0x16, 0x02, 0x89, 0x5e, 0x17, 0x60, 0xb4, 0x01, 0x10, 0x91, 0x26, 0x8b, 0x3c, 0xe7, 0x39,
2143         0xe9, 0x6a, 0x3b, 0x67, 0x86, 0x05, 0x96, 0xdc, 0x1f, 0x91, 0x2e, 0x2e, 0x46, 0x66, 0x88, 0x3e,
2144         0x14, 0x8e, 0x4c, 0x7c, 0xcf, 0xa1, 0xde, 0x62, 0x5e, 0xca, 0xb8, 0x5a, 0x58, 0x1e, 0xab, 0x01,
2145         0xda, 0x83, 0x29, 0x19, 0xf5, 0x4e, 0x72, 0xe3, 0xea, 0xb2, 0xee, 0x5c, 0x1a, 0xa0, 0xc9, 0xa1,
2146         0xca, 0x3c, 0x3d, 0xb5, 0xef, 0x42, 0xb9, 0x6f, 0x1d, 0xdd, 0x80, 0x62, 0xc4, 0x4e, 0x1d, 0x1a,
2147         0x78, 0xe4, 0x4c, 0x27, 0xc0, 0x42, 0xc4, 0x4e, 0xb7, 0xc5, 0xdc, 0xae, 0x41, 0x5e, 0x99, 0x76,
2148         0x0e, 0xf2, 0x31, 0x77, 0x23, 0xae, 0x39, 0xd4, 0x04, 0xcd, 0xc0, 0x28, 0x09, 0x54, 0x5c, 0x8d,
2149         0x62, 0x31, 0xb4, 0x9b, 0x50, 0xee, 0xb3, 0xa9, 0x60, 0xe1, 0x2c, 0x94, 0xb0, 0x3c, 0x16, 0x43,
2150         0x91, 0x3d, 0x7d, 0x72, 0xcc, 0x75, 0x9e, 0x96, 0x63, 0x21, 0xfe, 0x94, 0x7a, 0xfc, 0x44, 0x17,
2151         0x38, 0x35, 0x41, 0x0b, 0x30, 0x7e, 0x42, 0x68, 0xeb, 0x84, 0x4b, 0xfb, 0xe7, 0xb1, 0x9e, 0xd9,
2152         0x5f, 0xe7, 0x61, 0x0e, 0x13, 0xcf, 0x95, 0x45, 0x47, 0x64, 0x65, 0x4c, 0x3e, 0xef, 0x90, 0x98,
2153         0x0b, 0x73, 0x51, 0x95, 0x48, 0x9c, 0xa6, 0x4c, 0xf3, 0xda, 0x25, 0xef, 0x5c, 0xb9, 0x7e, 0xe1,
2154         0x32, 0xed, 0x6b, 0x0a, 0xd6, 0x20, 0x2f, 0x12, 0xad, 0x49, 0x8c, 0xef, 0x66, 0x09, 0x4a, 0x95,
2155         0x08, 0xac, 0x50, 0xa8, 0x05, 0xd3, 0x11, 0x09, 0x7d, 0xb7, 0x49, 0xb4, 0x42, 0xc6, 0x2b, 0x3f,
2156         0xcc, 0x76, 0xa5, 0x8b, 0x67, 0xab, 0x62, 0x25, 0x47, 0xab, 0x39, 0x15, 0xa5, 0xa7, 0x31, 0x7a,
2157         0x09, 0xd7, 0x95, 0xeb, 0x47, 0x12, 0x4b, 0x59, 0x90, 0x6c, 0x38, 0x26, 0x37, 0xdc, 0x1c, 0x7a,
2158         0x43, 0x79, 0x8f, 0xd8, 0x88, 0xd3, 0xfb, 0xce, 0xd3, 0x01, 0x54, 0x59, 0xd7, 0xfb, 0xf4, 0xfb,
2159         0x86, 0xea, 0xba, 0xb1, 0xdd, 0x29, 0xe5, 0x27, 0xd2, 0x5f, 0x8a, 0xb8, 0xa4, 0x69, 0x9f, 0x52,
2160         0x7e, 0x52, 0xf9, 0xbb, 0x05, 0x73, 0x83, 0xd4, 0x44, 0x8d, 0xd7, 0xdc, 0x7e, 0x6b, 0x24, 0xa5,
2161         0xc0, 0x8a, 0xb8, 0x3c, 0x21, 0xd7, 0x71, 0x7d, 0xdf, 0xe1, 0xe4, 0x4c, 0xf9, 0x6c, 0x61, 0x6b,
2162         0x04, 0x97, 0xd5, 0xc2, 0x63, 0xdf, 0x3f, 0x20, 0x67, 0x5c, 0x24, 0xb1, 0xb4, 0xdd, 0x7d, 0x16,
2163         0x49, 0x47, 0xbe, 0x24, 0x89, 0x35, 0x04, 0xa3, 0xb8, 0xc9, 0x44, 0x77, 0x9f, 0x45, 0xeb, 0x05,
2164         0x18, 0xe7, 0x6e, 0xd4, 0x22, 0xdc, 0x6e, 0x40, 0x5e, 0x92, 0x44, 0x0c, 0x45, 0xc4, 0x93, 0xe7,
2165         0xc8, 0x61, 0x31, 0x14, 0xf1, 0xd2, 0x8a, 0x08, 0x09, 0xa4, 0x42, 0x39, 0xac, 0x26, 0x22, 0xb2,
2166         0x8e, 0x4c, 0xb3, 0x91, 0xc3, 0x72, 0x6c, 0x1f, 0xc2, 0xfc, 0xb9, 0xdb, 0x8d, 0x43, 0x16, 0xc4,
2167         0xa4, 0xe7, 0xd9, 0xd6, 0xeb, 0x78, 0xb6, 0xfd, 0x3b, 0x0b, 0xe6, 0x7b, 0x91, 0xf3, 0xbf, 0x1c,
2168         0x84, 0xf6, 0x0f, 0x61, 0xe1, 0xbc, 0xa6, 0xda, 0x06, 0x0d, 0x98, 0x88, 0x64, 0xc7, 0x61, 0xac,
2169         0x70, 0x15, 0x1d, 0x55, 0x8f, 0x82, 0x0d, 0xd2, 0xfe, 0x67, 0x0e, 0x6e, 0x36, 0x64, 0x7d, 0xd4,
2170         0x0c, 0x49, 0xab, 0xf9, 0xdf, 0xb3, 0xc8, 0x1e, 0x4c, 0xe9, 0x17, 0x94, 0x91, 0x98, 0xbb, 0x5c,
2171         0xe2, 0xbe, 0x42, 0x18, 0x89, 0x71, 0x7a, 0x8a, 0x0e, 0xa0, 0xcc, 0x3a, 0x3c, 0xec, 0x24, 0x2a,
2172         0x2a, 0x07, 0xae, 0x65, 0x09, 0xdc, 0x95, 0x80, 0x7e, 0xb1, 0x93, 0x4a, 0x8a, 0x96, 0x7a, 0x08,
2173         0x33, 0xc9, 0xb3, 0xd0, 0x08, 0x56, 0x75, 0xf0, 0xff, 0x33, 0x05, 0xf7, 0x37, 0xeb, 0x78, 0x9a,
2174         0xf5, 0x13, 0xec, 0xaf, 0x2c, 0x98, 0x1d, 0xb0, 0x3b, 0x7a, 0x6c, 0xfa, 0xea, 0x2b, 0x18, 0x78,
2175         0x9d, 0xb6, 0x9e, 0x75, 0x48, 0xd4, 0xed, 0xef, 0xaf, 0xd1, 0x33, 0x98, 0x34, 0xa6, 0x0d, 0x5d,
2176         0x9d, 0x76, 0x4a, 0xf5, 0xbb, 0x99, 0x3e, 0xe7, 0xb3, 0x8e, 0xa7, 0x15, 0xd9, 0x73, 0xf9, 0xc9,
2177         0xd6, 0x08, 0x2e, 0xc5, 0xbd, 0xe9, 0xfa, 0xb8, 0x7a, 0x2f, 0xd8, 0x6d, 0x40, 0x26, 0xd1, 0xec,
2178         0x8b, 0xf7, 0x74, 0xcc, 0x69, 0x33, 0xfe, 0x26, 0x52, 0xe5, 0x1c, 0xe4, 0x9b, 0xac, 0x13, 0x70,
2179         0x5d, 0x89, 0xd5, 0xc4, 0xfe, 0x6a, 0x0c, 0x16, 0xcf, 0xbb, 0xe4, 0xc7, 0x84, 0xbb, 0xf2, 0x65,
2180         0xf2, 0x2e, 0x4c, 0x87, 0x11, 0x6b, 0x92, 0x38, 0x26, 0x9e, 0x23, 0xda, 0x31, 0xf3, 0xfa, 0x99,
2181         0x4a, 0xc8, 0xeb, 0x82, 0x8a, 0xea, 0x30, 0xcf, 0x19, 0x77, 0x7d, 0x87, 0xc4, 0x9c, 0xb6, 0x45,
2182         0xbb, 0xac, 0xd9, 0xc7, 0x24, 0xfb, 0xac, 0x5c, 0xdc, 0x34, 0x6b, 0x0a, 0x73, 0x08, 0xd3, 0xbd,
2183         0x97, 0x64, 0xcc, 0x5d, 0x6e, 0x42, 0xb7, 0x7a, 0x95, 0x83, 0xf5, 0x6c, 0x23, 0xdc, 0xbe, 0x47,
2184         0x8b, 0xcf, 0x37, 0xae, 0xa3, 0xc3, 0x34, 0xae, 0xc8, 0x81, 0x85, 0x48, 0x05, 0xa4, 0x73, 0x2e,
2185         0x1a, 0xf3, 0xc3, 0x46, 0xe3, 0x9c, 0x16, 0xd4, 0xff, 0x01, 0x21, 0xb5, 0xc1, 0xb9, 0xe0, 0x1c,
2186         0x1f, 0x36, 0x38, 0xcd, 0x06, 0xfd, 0xde, 0xdd, 0x84, 0x79, 0xb3, 0x41, 0x7f, 0xac, 0x4e, 0xbc,
2187         0x5e, 0xac, 0xce, 0x6a, 0x69, 0xbb, 0xa9, 0x90, 0xb5, 0xef, 0x26, 0xd9, 0x32, 0x95, 0xc7, 0xe4,
2188         0xab, 0x0c, 0xc1, 0x58, 0xe0, 0xb6, 0x93, 0x67, 0xaf, 0x18, 0xdb, 0x3f, 0xb1, 0xa0, 0xb2, 0x43,
2189         0x13, 0x4b, 0x98, 0x27, 0xb3, 0xc9, 0x7c, 0x03, 0x20, 0xa2, 0xe1, 0x0c, 0x85, 0x6d, 0x62, 0xfa,
2190         0x05, 0xd1, 0x4d, 0x60, 0x41, 0x10, 0xf6, 0xe9, 0x17, 0x04, 0xdd, 0x04, 0x90, 0x8b, 0x9c, 0x3d,
2191         0x27, 0x81, 0x7a, 0x35, 0x63, 0xc9, 0x7e, 0x20, 0x08, 0xa2, 0x23, 0x3c, 0xa6, 0x3e, 0x27, 0x91,
2192         0xf4, 0xbe, 0x22, 0xd6, 0x33, 0xfb, 0x67, 0x16, 0xdc, 0x18, 0xa8, 0x86, 0x4e, 0xf4, 0x8f, 0x61,
2193         0x5c, 0xa5, 0xeb, 0x21, 0x32, 0xaf, 0xce, 0xf3, 0x1a, 0x88, 0x6e, 0xc3, 0x74, 0x40, 0xce, 0xb8,
2194         0x93, 0x52, 0x4f, 0x75, 0x24, 0x65, 0x41, 0xde, 0x33, 0x2a, 0xda, 0xbf, 0xb1, 0x60, 0xd6, 0x78,
2195         0xf2, 0x06, 0x89, 0x9b, 0x11, 0x0d, 0x65, 0x23, 0x3c, 0xc8, 0x14, 0xb7, 0x60, 0xd2, 0xa3, 0x71,
2196         0xe8, 0xbb, 0x5d, 0x47, 0xae, 0xe9, 0x16, 0x47, 0xd3, 0x9e, 0x0a, 0x96, 0x5d, 0x00, 0xf1, 0x46,
2197         0x6d, 0xb1, 0x88, 0x26, 0x4f, 0x9a, 0xcc, 0x8b, 0x6e, 0x28, 0xee, 0x6e, 0x6a, 0x6f, 0x9c, 0x12,
2198         0x61, 0x7f, 0x0a, 0x73, 0xca, 0x52, 0xfa, 0x93, 0x95, 0xb9, 0xaa, 0x0a, 0x14, 0x34, 0x57, 0x57,
2199         0xeb, 0x98, 0xcc, 0xd1, 0x32, 0x94, 0x7d, 0x37, 0x68, 0x75, 0x94, 0x4b, 0x7b, 0x46, 0xd1, 0x49,
2200         0x43, 0x6c, 0x30, 0x8f, 0xd8, 0x2d, 0x98, 0x3f, 0x27, 0x58, 0x1b, 0xff, 0xe9, 0x80, 0x0f, 0x6b,
2201         0xb5, 0xab, 0x24, 0x82, 0xf4, 0x11, 0x7a, 0xdf, 0xd8, 0xec, 0x1d, 0x98, 0x1d, 0x70, 0xc8, 0xd7,
2202         0x34, 0xb0, 0xfd, 0x08, 0xde, 0x10, 0x6a, 0x63, 0xc6, 0x78, 0x23, 0xb1, 0x92, 0x31, 0xca, 0x85,
2203         0x83, 0x5b, 0x03, 0x0e, 0xde, 0x56, 0x21, 0x70, 0x5e, 0x82, 0x3e, 0x7d, 0xff, 0x05, 0x5a, 0xff,
2204         0xf9, 0x05, 0xfe, 0x2d, 0x07, 0x79, 0xf9, 0xfd, 0x04, 0xbd, 0x03, 0x65, 0x1a, 0x70, 0xd2, 0x22,
2205         0x91, 0xa3, 0xbe, 0x32, 0xc9, 0x0c, 0xbe, 0x35, 0x82, 0x27, 0x35, 0x59, 0xb1, 0xdd, 0x82, 0xd2,
2206         0xb1, 0xcf, 0x5c, 0xae, 0x99, 0x84, 0x0d, 0xac, 0xad, 0x11, 0x0c, 0x92, 0xa8, 0x58, 0x96, 0x45,
2207         0xd1, 0x8b, 0x68, 0xd0, 0x72, 0xfa, 0x3f, 0x57, 0x95, 0x14, 0x35, 0xd9, 0xee, 0x88, 0x31, 0x9f,
2208         0xb8, 0x81, 0xe6, 0x1a, 0xd3, 0xdd, 0xf0, 0xa4, 0x26, 0x2b, 0xb6, 0x4d, 0x98, 0x4e, 0xbe, 0xd0,
2209         0x6a, 0xc6, 0xfc, 0x65, 0x89, 0x7a, 0x6b, 0x04, 0x4f, 0x25, 0x20, 0x25, 0xe6, 0x01, 0x80, 0xa0,
2210         0x68, 0x09, 0x2a, 0x83, 0x2e, 0x18, 0x09, 0xc2, 0x95, 0x24, 0x7a, 0xf7, 0x78, 0xc3, 0xed, 0x6e,
2211         0x8d, 0xe0, 0xa2, 0xe0, 0x55, 0xc0, 0x3a, 0x80, 0x27, 0x4a, 0x84, 0x02, 0xaa, 0xd4, 0x78, 0xad,
2212         0x0f, 0xb8, 0xe1, 0x72, 0x51, 0xf0, 0x8b, 0x82, 0x4d, 0x62, 0x4c, 0x85, 0x5e, 0xe5, 0x00, 0xa9,
2213         0xaf, 0xaf, 0x15, 0x58, 0xd8, 0xd9, 0xfe, 0x68, 0x73, 0x67, 0x7b, 0x6b, 0x77, 0x77, 0xc3, 0xf9,
2214         0xe4, 0xe9, 0xfe, 0xde, 0x66, 0x63, 0xfb, 0xc9, 0xf6, 0xe6, 0xc6, 0xcc, 0x08, 0xba, 0x06, 0xe5,
2215         0xc3, 0x4d, 0xfc, 0x99, 0xf3, 0xc9, 0x53, 0xc9, 0xf2, 0xd9, 0x8c, 0x85, 0x26, 0xa1, 0x90, 0xcc,
2216         0x72, 0x62, 0xb6, 0xb7, 0xbb, 0xbf, 0xbf, 0xbd, 0xbe, 0xb3, 0x39, 0x33, 0x8a, 0x00, 0xc6, 0xf5,
2217         0xca, 0x18, 0x9a, 0x86, 0x92, 0x84, 0x6a, 0x42, 0xbe, 0xfe, 0xaf, 0x09, 0x80, 0x0d, 0x3f, 0xdc,
2218         0x27, 0xd1, 0x0b, 0xda, 0x24, 0xe8, 0xd7, 0x16, 0x4c, 0xf5, 0x37, 0xac, 0xe8, 0xde, 0xd5, 0x6a,
2219         0x53, 0xaa, 0x0d, 0xaf, 0xd4, 0x87, 0x81, 0x28, 0x5f, 0xb5, 0x97, 0x7f, 0xfc, 0xd7, 0xaf, 0x7f,
2220         0x9e, 0xbb, 0x69, 0x2f, 0x26, 0xdf, 0xe9, 0x9b, 0x8a, 0xe3, 0x7d, 0x5d, 0x31, 0xdf, 0xb7, 0x56,
2221         0xd1, 0x2f, 0x2d, 0xf1, 0xd8, 0x4b, 0x3d, 0x29, 0xd0, 0x7b, 0xc3, 0xbe, 0x2d, 0x2b, 0xf7, 0x86,
2222         0x40, 0x68, 0xdd, 0x6c, 0xa9, 0xdb, 0x9b, 0xf6, 0xf5, 0x0b, 0xba, 0xa9, 0x07, 0x94, 0x50, 0xed,
2223         0x57, 0x16, 0x2c, 0x0c, 0x6e, 0xc5, 0xd1, 0xc3, 0xcc, 0x90, 0xcb, 0x6a, 0xdf, 0x2b, 0x37, 0x0d,
2224         0x34, 0xf5, 0xb7, 0xa3, 0xd7, 0xa2, 0xda, 0xb7, 0xa5, 0x62, 0x4b, 0xf6, 0x8d, 0x44, 0x31, 0x6d,
2225         0xac, 0xd4, 0x1f, 0x11, 0xa1, 0xdc, 0x9f, 0x2c, 0x98, 0x1d, 0x50, 0xa3, 0xd0, 0xfd, 0xec, 0x6f,
2226         0x80, 0xaf, 0xaa, 0xad, 0x95, 0x07, 0x43, 0xe3, 0xb4, 0x25, 0xeb, 0x52, 0xe1, 0xbb, 0x68, 0x35,
2227         0x51, 0xf8, 0x4b, 0x91, 0x1c, 0xd7, 0x8c, 0xda, 0xfa, 0x61, 0x53, 0x5b, 0x7d, 0x59, 0x4b, 0x3e,
2228         0xa8, 0xfe, 0xd1, 0x82, 0x72, 0x5f, 0x76, 0xcf, 0xbe, 0xf4, 0x41, 0x15, 0x26, 0xfb, 0xd2, 0x07,
2229         0x96, 0x0e, 0xfb, 0xbe, 0x54, 0xf5, 0x3d, 0x54, 0x4d, 0x54, 0x8d, 0xfa, 0xb2, 0x6c, 0xed, 0x4b,
2230         0x53, 0xa3, 0xd6, 0x56, 0x5f, 0xd6, 0x7a, 0xbf, 0x61, 0x7e, 0x6b, 0x01, 0xba, 0x98, 0x93, 0xd1,
2231         0x77, 0x2e, 0xd3, 0x60, 0x60, 0x15, 0xa8, 0xdc, 0x1f, 0x16, 0xa6, 0xb5, 0x7f, 0x4b, 0x6a, 0xff,
2232         0x06, 0xba, 0xfe, 0x0a, 0xed, 0xd7, 0x7f, 0x6a, 0xc1, 0xff, 0x35, 0x59, 0x3b, 0x43, 0xfc, 0x7a,
2233         0x61, 0xc3, 0x0f, 0xf7, 0x44, 0xbe, 0xdc, 0xb3, 0x7e, 0xb0, 0xa6, 0xf9, 0x5a, 0x4c, 0xd4, 0x9f,
2234         0x2a, 0x8b, 0x5a, 0xb5, 0x16, 0x09, 0x64, 0x36, 0xad, 0xa9, 0x25, 0x37, 0xa4, 0xf1, 0xa0, 0xff,
2235         0x6d, 0x1f, 0x78, 0x7e, 0xf8, 0x87, 0xdc, 0xe2, 0xf7, 0x14, 0x5e, 0xbe, 0x57, 0xaa, 0x1b, 0x7e,
2236         0x58, 0x3d, 0xac, 0xaf, 0x8b, 0xe5, 0xa3, 0x71, 0x29, 0xe4, 0xdb, 0xff, 0x0e, 0x00, 0x00, 0xff,
2237         0xff, 0x01, 0xfb, 0x51, 0xc8, 0x38, 0x1c, 0x00, 0x00,
2238 }