vendor/google.golang.org/genproto/googleapis/cloud/vision/v1/text_annotation.pb.go

   1 // Code generated by protoc-gen-go. DO NOT EDIT.
   2 // source: google/cloud/vision/v1/text_annotation.proto
   3
   4 package vision
   5
   6 import proto "github.com/golang/protobuf/proto"
   7 import fmt "fmt"
   8 import math "math"
   9 import _ "google.golang.org/genproto/googleapis/api/annotations"
  10
  11 // Reference imports to suppress errors if they are not otherwise used.
  12 var _ = proto.Marshal
  13 var _ = fmt.Errorf
  14 var _ = math.Inf
  15
  16 // Enum to denote the type of break found. New line, space etc.
  17 type TextAnnotation_DetectedBreak_BreakType int32
  18
  19 const (
  20         // Unknown break label type.
  21         TextAnnotation_DetectedBreak_UNKNOWN TextAnnotation_DetectedBreak_BreakType = 0
  22         // Regular space.
  23         TextAnnotation_DetectedBreak_SPACE TextAnnotation_DetectedBreak_BreakType = 1
  24         // Sure space (very wide).
  25         TextAnnotation_DetectedBreak_SURE_SPACE TextAnnotation_DetectedBreak_BreakType = 2
  26         // Line-wrapping break.
  27         TextAnnotation_DetectedBreak_EOL_SURE_SPACE TextAnnotation_DetectedBreak_BreakType = 3
  28         // End-line hyphen that is not present in text; does
  29         TextAnnotation_DetectedBreak_HYPHEN TextAnnotation_DetectedBreak_BreakType = 4
  30         // not co-occur with SPACE, LEADER_SPACE, or
  31         // LINE_BREAK.
  32         // Line break that ends a paragraph.
  33         TextAnnotation_DetectedBreak_LINE_BREAK TextAnnotation_DetectedBreak_BreakType = 5
  34 )
  35
  36 var TextAnnotation_DetectedBreak_BreakType_name = map[int32]string{
  37         0: "UNKNOWN",
  38         1: "SPACE",
  39         2: "SURE_SPACE",
  40         3: "EOL_SURE_SPACE",
  41         4: "HYPHEN",
  42         5: "LINE_BREAK",
  43 }
  44 var TextAnnotation_DetectedBreak_BreakType_value = map[string]int32{
  45         "UNKNOWN":        0,
  46         "SPACE":          1,
  47         "SURE_SPACE":     2,
  48         "EOL_SURE_SPACE": 3,
  49         "HYPHEN":         4,
  50         "LINE_BREAK":     5,
  51 }
  52
  53 func (x TextAnnotation_DetectedBreak_BreakType) String() string {
  54         return proto.EnumName(TextAnnotation_DetectedBreak_BreakType_name, int32(x))
  55 }
  56 func (TextAnnotation_DetectedBreak_BreakType) EnumDescriptor() ([]byte, []int) {
  57         return fileDescriptor2, []int{0, 1, 0}
  58 }
  59
  60 // Type of a block (text, image etc) as identified by OCR.
  61 type Block_BlockType int32
  62
  63 const (
  64         // Unknown block type.
  65         Block_UNKNOWN Block_BlockType = 0
  66         // Regular text block.
  67         Block_TEXT Block_BlockType = 1
  68         // Table block.
  69         Block_TABLE Block_BlockType = 2
  70         // Image block.
  71         Block_PICTURE Block_BlockType = 3
  72         // Horizontal/vertical line box.
  73         Block_RULER Block_BlockType = 4
  74         // Barcode block.
  75         Block_BARCODE Block_BlockType = 5
  76 )
  77
  78 var Block_BlockType_name = map[int32]string{
  79         0: "UNKNOWN",
  80         1: "TEXT",
  81         2: "TABLE",
  82         3: "PICTURE",
  83         4: "RULER",
  84         5: "BARCODE",
  85 }
  86 var Block_BlockType_value = map[string]int32{
  87         "UNKNOWN": 0,
  88         "TEXT":    1,
  89         "TABLE":   2,
  90         "PICTURE": 3,
  91         "RULER":   4,
  92         "BARCODE": 5,
  93 }
  94
  95 func (x Block_BlockType) String() string {
  96         return proto.EnumName(Block_BlockType_name, int32(x))
  97 }
  98 func (Block_BlockType) EnumDescriptor() ([]byte, []int) { return fileDescriptor2, []int{2, 0} }
  99
 100 // TextAnnotation contains a structured representation of OCR extracted text.
 101 // The hierarchy of an OCR extracted text structure is like this:
 102 //     TextAnnotation -> Page -> Block -> Paragraph -> Word -> Symbol
 103 // Each structural component, starting from Page, may further have their own
 104 // properties. Properties describe detected languages, breaks etc.. Please
 105 // refer to the [google.cloud.vision.v1.TextAnnotation.TextProperty][google.cloud.vision.v1.TextAnnotation.TextProperty] message
 106 // definition below for more detail.
 107 type TextAnnotation struct {
 108         // List of pages detected by OCR.
 109         Pages []*Page `protobuf:"bytes,1,rep,name=pages" json:"pages,omitempty"`
 110         // UTF-8 text detected on the pages.
 111         Text string `protobuf:"bytes,2,opt,name=text" json:"text,omitempty"`
 112 }
 113
 114 func (m *TextAnnotation) Reset()                    { *m = TextAnnotation{} }
 115 func (m *TextAnnotation) String() string            { return proto.CompactTextString(m) }
 116 func (*TextAnnotation) ProtoMessage()               {}
 117 func (*TextAnnotation) Descriptor() ([]byte, []int) { return fileDescriptor2, []int{0} }
 118
 119 func (m *TextAnnotation) GetPages() []*Page {
 120         if m != nil {
 121                 return m.Pages
 122         }
 123         return nil
 124 }
 125
 126 func (m *TextAnnotation) GetText() string {
 127         if m != nil {
 128                 return m.Text
 129         }
 130         return ""
 131 }
 132
 133 // Detected language for a structural component.
 134 type TextAnnotation_DetectedLanguage struct {
 135         // The BCP-47 language code, such as "en-US" or "sr-Latn". For more
 136         // information, see
 137         // http://www.unicode.org/reports/tr35/#Unicode_locale_identifier.
 138         LanguageCode string `protobuf:"bytes,1,opt,name=language_code,json=languageCode" json:"language_code,omitempty"`
 139         // Confidence of detected language. Range [0, 1].
 140         Confidence float32 `protobuf:"fixed32,2,opt,name=confidence" json:"confidence,omitempty"`
 141 }
 142
 143 func (m *TextAnnotation_DetectedLanguage) Reset()         { *m = TextAnnotation_DetectedLanguage{} }
 144 func (m *TextAnnotation_DetectedLanguage) String() string { return proto.CompactTextString(m) }
 145 func (*TextAnnotation_DetectedLanguage) ProtoMessage()    {}
 146 func (*TextAnnotation_DetectedLanguage) Descriptor() ([]byte, []int) {
 147         return fileDescriptor2, []int{0, 0}
 148 }
 149
 150 func (m *TextAnnotation_DetectedLanguage) GetLanguageCode() string {
 151         if m != nil {
 152                 return m.LanguageCode
 153         }
 154         return ""
 155 }
 156
 157 func (m *TextAnnotation_DetectedLanguage) GetConfidence() float32 {
 158         if m != nil {
 159                 return m.Confidence
 160         }
 161         return 0
 162 }
 163
 164 // Detected start or end of a structural component.
 165 type TextAnnotation_DetectedBreak struct {
 166         Type TextAnnotation_DetectedBreak_BreakType `protobuf:"varint,1,opt,name=type,enum=google.cloud.vision.v1.TextAnnotation_DetectedBreak_BreakType" json:"type,omitempty"`
 167         // True if break prepends the element.
 168         IsPrefix bool `protobuf:"varint,2,opt,name=is_prefix,json=isPrefix" json:"is_prefix,omitempty"`
 169 }
 170
 171 func (m *TextAnnotation_DetectedBreak) Reset()                    { *m = TextAnnotation_DetectedBreak{} }
 172 func (m *TextAnnotation_DetectedBreak) String() string            { return proto.CompactTextString(m) }
 173 func (*TextAnnotation_DetectedBreak) ProtoMessage()               {}
 174 func (*TextAnnotation_DetectedBreak) Descriptor() ([]byte, []int) { return fileDescriptor2, []int{0, 1} }
 175
 176 func (m *TextAnnotation_DetectedBreak) GetType() TextAnnotation_DetectedBreak_BreakType {
 177         if m != nil {
 178                 return m.Type
 179         }
 180         return TextAnnotation_DetectedBreak_UNKNOWN
 181 }
 182
 183 func (m *TextAnnotation_DetectedBreak) GetIsPrefix() bool {
 184         if m != nil {
 185                 return m.IsPrefix
 186         }
 187         return false
 188 }
 189
 190 // Additional information detected on the structural component.
 191 type TextAnnotation_TextProperty struct {
 192         // A list of detected languages together with confidence.
 193         DetectedLanguages []*TextAnnotation_DetectedLanguage `protobuf:"bytes,1,rep,name=detected_languages,json=detectedLanguages" json:"detected_languages,omitempty"`
 194         // Detected start or end of a text segment.
 195         DetectedBreak *TextAnnotation_DetectedBreak `protobuf:"bytes,2,opt,name=detected_break,json=detectedBreak" json:"detected_break,omitempty"`
 196 }
 197
 198 func (m *TextAnnotation_TextProperty) Reset()                    { *m = TextAnnotation_TextProperty{} }
 199 func (m *TextAnnotation_TextProperty) String() string            { return proto.CompactTextString(m) }
 200 func (*TextAnnotation_TextProperty) ProtoMessage()               {}
 201 func (*TextAnnotation_TextProperty) Descriptor() ([]byte, []int) { return fileDescriptor2, []int{0, 2} }
 202
 203 func (m *TextAnnotation_TextProperty) GetDetectedLanguages() []*TextAnnotation_DetectedLanguage {
 204         if m != nil {
 205                 return m.DetectedLanguages
 206         }
 207         return nil
 208 }
 209
 210 func (m *TextAnnotation_TextProperty) GetDetectedBreak() *TextAnnotation_DetectedBreak {
 211         if m != nil {
 212                 return m.DetectedBreak
 213         }
 214         return nil
 215 }
 216
 217 // Detected page from OCR.
 218 type Page struct {
 219         // Additional information detected on the page.
 220         Property *TextAnnotation_TextProperty `protobuf:"bytes,1,opt,name=property" json:"property,omitempty"`
 221         // Page width in pixels.
 222         Width int32 `protobuf:"varint,2,opt,name=width" json:"width,omitempty"`
 223         // Page height in pixels.
 224         Height int32 `protobuf:"varint,3,opt,name=height" json:"height,omitempty"`
 225         // List of blocks of text, images etc on this page.
 226         Blocks []*Block `protobuf:"bytes,4,rep,name=blocks" json:"blocks,omitempty"`
 227 }
 228
 229 func (m *Page) Reset()                    { *m = Page{} }
 230 func (m *Page) String() string            { return proto.CompactTextString(m) }
 231 func (*Page) ProtoMessage()               {}
 232 func (*Page) Descriptor() ([]byte, []int) { return fileDescriptor2, []int{1} }
 233
 234 func (m *Page) GetProperty() *TextAnnotation_TextProperty {
 235         if m != nil {
 236                 return m.Property
 237         }
 238         return nil
 239 }
 240
 241 func (m *Page) GetWidth() int32 {
 242         if m != nil {
 243                 return m.Width
 244         }
 245         return 0
 246 }
 247
 248 func (m *Page) GetHeight() int32 {
 249         if m != nil {
 250                 return m.Height
 251         }
 252         return 0
 253 }
 254
 255 func (m *Page) GetBlocks() []*Block {
 256         if m != nil {
 257                 return m.Blocks
 258         }
 259         return nil
 260 }
 261
 262 // Logical element on the page.
 263 type Block struct {
 264         // Additional information detected for the block.
 265         Property *TextAnnotation_TextProperty `protobuf:"bytes,1,opt,name=property" json:"property,omitempty"`
 266         // The bounding box for the block.
 267         // The vertices are in the order of top-left, top-right, bottom-right,
 268         // bottom-left. When a rotation of the bounding box is detected the rotation
 269         // is represented as around the top-left corner as defined when the text is
 270         // read in the 'natural' orientation.
 271         // For example:
 272         //   * when the text is horizontal it might look like:
 273         //      0----1
 274         //      |    |
 275         //      3----2
 276         //   * when it's rotated 180 degrees around the top-left corner it becomes:
 277         //      2----3
 278         //      |    |
 279         //      1----0
 280         //   and the vertice order will still be (0, 1, 2, 3).
 281         BoundingBox *BoundingPoly `protobuf:"bytes,2,opt,name=bounding_box,json=boundingBox" json:"bounding_box,omitempty"`
 282         // List of paragraphs in this block (if this blocks is of type text).
 283         Paragraphs []*Paragraph `protobuf:"bytes,3,rep,name=paragraphs" json:"paragraphs,omitempty"`
 284         // Detected block type (text, image etc) for this block.
 285         BlockType Block_BlockType `protobuf:"varint,4,opt,name=block_type,json=blockType,enum=google.cloud.vision.v1.Block_BlockType" json:"block_type,omitempty"`
 286 }
 287
 288 func (m *Block) Reset()                    { *m = Block{} }
 289 func (m *Block) String() string            { return proto.CompactTextString(m) }
 290 func (*Block) ProtoMessage()               {}
 291 func (*Block) Descriptor() ([]byte, []int) { return fileDescriptor2, []int{2} }
 292
 293 func (m *Block) GetProperty() *TextAnnotation_TextProperty {
 294         if m != nil {
 295                 return m.Property
 296         }
 297         return nil
 298 }
 299
 300 func (m *Block) GetBoundingBox() *BoundingPoly {
 301         if m != nil {
 302                 return m.BoundingBox
 303         }
 304         return nil
 305 }
 306
 307 func (m *Block) GetParagraphs() []*Paragraph {
 308         if m != nil {
 309                 return m.Paragraphs
 310         }
 311         return nil
 312 }
 313
 314 func (m *Block) GetBlockType() Block_BlockType {
 315         if m != nil {
 316                 return m.BlockType
 317         }
 318         return Block_UNKNOWN
 319 }
 320
 321 // Structural unit of text representing a number of words in certain order.
 322 type Paragraph struct {
 323         // Additional information detected for the paragraph.
 324         Property *TextAnnotation_TextProperty `protobuf:"bytes,1,opt,name=property" json:"property,omitempty"`
 325         // The bounding box for the paragraph.
 326         // The vertices are in the order of top-left, top-right, bottom-right,
 327         // bottom-left. When a rotation of the bounding box is detected the rotation
 328         // is represented as around the top-left corner as defined when the text is
 329         // read in the 'natural' orientation.
 330         // For example:
 331         //   * when the text is horizontal it might look like:
 332         //      0----1
 333         //      |    |
 334         //      3----2
 335         //   * when it's rotated 180 degrees around the top-left corner it becomes:
 336         //      2----3
 337         //      |    |
 338         //      1----0
 339         //   and the vertice order will still be (0, 1, 2, 3).
 340         BoundingBox *BoundingPoly `protobuf:"bytes,2,opt,name=bounding_box,json=boundingBox" json:"bounding_box,omitempty"`
 341         // List of words in this paragraph.
 342         Words []*Word `protobuf:"bytes,3,rep,name=words" json:"words,omitempty"`
 343 }
 344
 345 func (m *Paragraph) Reset()                    { *m = Paragraph{} }
 346 func (m *Paragraph) String() string            { return proto.CompactTextString(m) }
 347 func (*Paragraph) ProtoMessage()               {}
 348 func (*Paragraph) Descriptor() ([]byte, []int) { return fileDescriptor2, []int{3} }
 349
 350 func (m *Paragraph) GetProperty() *TextAnnotation_TextProperty {
 351         if m != nil {
 352                 return m.Property
 353         }
 354         return nil
 355 }
 356
 357 func (m *Paragraph) GetBoundingBox() *BoundingPoly {
 358         if m != nil {
 359                 return m.BoundingBox
 360         }
 361         return nil
 362 }
 363
 364 func (m *Paragraph) GetWords() []*Word {
 365         if m != nil {
 366                 return m.Words
 367         }
 368         return nil
 369 }
 370
 371 // A word representation.
 372 type Word struct {
 373         // Additional information detected for the word.
 374         Property *TextAnnotation_TextProperty `protobuf:"bytes,1,opt,name=property" json:"property,omitempty"`
 375         // The bounding box for the word.
 376         // The vertices are in the order of top-left, top-right, bottom-right,
 377         // bottom-left. When a rotation of the bounding box is detected the rotation
 378         // is represented as around the top-left corner as defined when the text is
 379         // read in the 'natural' orientation.
 380         // For example:
 381         //   * when the text is horizontal it might look like:
 382         //      0----1
 383         //      |    |
 384         //      3----2
 385         //   * when it's rotated 180 degrees around the top-left corner it becomes:
 386         //      2----3
 387         //      |    |
 388         //      1----0
 389         //   and the vertice order will still be (0, 1, 2, 3).
 390         BoundingBox *BoundingPoly `protobuf:"bytes,2,opt,name=bounding_box,json=boundingBox" json:"bounding_box,omitempty"`
 391         // List of symbols in the word.
 392         // The order of the symbols follows the natural reading order.
 393         Symbols []*Symbol `protobuf:"bytes,3,rep,name=symbols" json:"symbols,omitempty"`
 394 }
 395
 396 func (m *Word) Reset()                    { *m = Word{} }
 397 func (m *Word) String() string            { return proto.CompactTextString(m) }
 398 func (*Word) ProtoMessage()               {}
 399 func (*Word) Descriptor() ([]byte, []int) { return fileDescriptor2, []int{4} }
 400
 401 func (m *Word) GetProperty() *TextAnnotation_TextProperty {
 402         if m != nil {
 403                 return m.Property
 404         }
 405         return nil
 406 }
 407
 408 func (m *Word) GetBoundingBox() *BoundingPoly {
 409         if m != nil {
 410                 return m.BoundingBox
 411         }
 412         return nil
 413 }
 414
 415 func (m *Word) GetSymbols() []*Symbol {
 416         if m != nil {
 417                 return m.Symbols
 418         }
 419         return nil
 420 }
 421
 422 // A single symbol representation.
 423 type Symbol struct {
 424         // Additional information detected for the symbol.
 425         Property *TextAnnotation_TextProperty `protobuf:"bytes,1,opt,name=property" json:"property,omitempty"`
 426         // The bounding box for the symbol.
 427         // The vertices are in the order of top-left, top-right, bottom-right,
 428         // bottom-left. When a rotation of the bounding box is detected the rotation
 429         // is represented as around the top-left corner as defined when the text is
 430         // read in the 'natural' orientation.
 431         // For example:
 432         //   * when the text is horizontal it might look like:
 433         //      0----1
 434         //      |    |
 435         //      3----2
 436         //   * when it's rotated 180 degrees around the top-left corner it becomes:
 437         //      2----3
 438         //      |    |
 439         //      1----0
 440         //   and the vertice order will still be (0, 1, 2, 3).
 441         BoundingBox *BoundingPoly `protobuf:"bytes,2,opt,name=bounding_box,json=boundingBox" json:"bounding_box,omitempty"`
 442         // The actual UTF-8 representation of the symbol.
 443         Text string `protobuf:"bytes,3,opt,name=text" json:"text,omitempty"`
 444 }
 445
 446 func (m *Symbol) Reset()                    { *m = Symbol{} }
 447 func (m *Symbol) String() string            { return proto.CompactTextString(m) }
 448 func (*Symbol) ProtoMessage()               {}
 449 func (*Symbol) Descriptor() ([]byte, []int) { return fileDescriptor2, []int{5} }
 450
 451 func (m *Symbol) GetProperty() *TextAnnotation_TextProperty {
 452         if m != nil {
 453                 return m.Property
 454         }
 455         return nil
 456 }
 457
 458 func (m *Symbol) GetBoundingBox() *BoundingPoly {
 459         if m != nil {
 460                 return m.BoundingBox
 461         }
 462         return nil
 463 }
 464
 465 func (m *Symbol) GetText() string {
 466         if m != nil {
 467                 return m.Text
 468         }
 469         return ""
 470 }
 471
 472 func init() {
 473         proto.RegisterType((*TextAnnotation)(nil), "google.cloud.vision.v1.TextAnnotation")
 474         proto.RegisterType((*TextAnnotation_DetectedLanguage)(nil), "google.cloud.vision.v1.TextAnnotation.DetectedLanguage")
 475         proto.RegisterType((*TextAnnotation_DetectedBreak)(nil), "google.cloud.vision.v1.TextAnnotation.DetectedBreak")
 476         proto.RegisterType((*TextAnnotation_TextProperty)(nil), "google.cloud.vision.v1.TextAnnotation.TextProperty")
 477         proto.RegisterType((*Page)(nil), "google.cloud.vision.v1.Page")
 478         proto.RegisterType((*Block)(nil), "google.cloud.vision.v1.Block")
 479         proto.RegisterType((*Paragraph)(nil), "google.cloud.vision.v1.Paragraph")
 480         proto.RegisterType((*Word)(nil), "google.cloud.vision.v1.Word")
 481         proto.RegisterType((*Symbol)(nil), "google.cloud.vision.v1.Symbol")
 482         proto.RegisterEnum("google.cloud.vision.v1.TextAnnotation_DetectedBreak_BreakType", TextAnnotation_DetectedBreak_BreakType_name, TextAnnotation_DetectedBreak_BreakType_value)
 483         proto.RegisterEnum("google.cloud.vision.v1.Block_BlockType", Block_BlockType_name, Block_BlockType_value)
 484 }
 485
 486 func init() { proto.RegisterFile("google/cloud/vision/v1/text_annotation.proto", fileDescriptor2) }
 487
 488 var fileDescriptor2 = []byte{
 489         // 744 bytes of a gzipped FileDescriptorProto
 490         0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xcc, 0x55, 0x4f, 0x6f, 0xd3, 0x4e,
 491         0x10, 0xfd, 0xb9, 0xb1, 0xd3, 0x78, 0xd2, 0x46, 0xfe, 0x2d, 0xa8, 0x8a, 0x42, 0xa9, 0x8a, 0x01,
 492         0xd1, 0x03, 0x72, 0xd4, 0x14, 0x04, 0x12, 0x08, 0x29, 0x4e, 0x0d, 0xad, 0x1a, 0x25, 0xd6, 0x36,
 493         0x51, 0xf9, 0x73, 0xb0, 0xfc, 0x67, 0xeb, 0x58, 0x4d, 0xbd, 0x96, 0xed, 0xb6, 0xc9, 0x8d, 0x4f,
 494         0xc5, 0x89, 0x6f, 0xc1, 0x09, 0xee, 0x9c, 0xb9, 0x72, 0x44, 0x5e, 0xdb, 0x69, 0x52, 0x61, 0x04,
 495         0x88, 0x43, 0x2f, 0xd6, 0xce, 0xe4, 0xed, 0xdb, 0xf7, 0x66, 0x33, 0x3b, 0xf0, 0xd0, 0xa5, 0xd4,
 496         0x1d, 0x93, 0xa6, 0x3d, 0xa6, 0x67, 0x4e, 0xf3, 0xdc, 0x8b, 0x3c, 0xea, 0x37, 0xcf, 0xb7, 0x9b,
 497         0x31, 0x99, 0xc4, 0x86, 0xe9, 0xfb, 0x34, 0x36, 0x63, 0x8f, 0xfa, 0x4a, 0x10, 0xd2, 0x98, 0xa2,
 498         0xb5, 0x14, 0xad, 0x30, 0xb4, 0x92, 0xa2, 0x95, 0xf3, 0xed, 0xc6, 0x7a, 0xc6, 0x62, 0x06, 0x5e,
 499         0xf3, 0x72, 0x53, 0x94, 0xee, 0x6a, 0xdc, 0x2f, 0x38, 0xc3, 0x25, 0xf4, 0x94, 0xc4, 0xe1, 0x34,
 500         0x85, 0xc9, 0xdf, 0x78, 0xa8, 0x0d, 0xc8, 0x24, 0x6e, 0xcf, 0x08, 0x50, 0x0b, 0x84, 0xc0, 0x74,
 501         0x49, 0x54, 0xe7, 0x36, 0x4b, 0x5b, 0xd5, 0xd6, 0xba, 0xf2, 0xf3, 0xf3, 0x15, 0xdd, 0x74, 0x09,
 502         0x4e, 0xa1, 0x08, 0x01, 0x9f, 0x88, 0xaf, 0x2f, 0x6d, 0x72, 0x5b, 0x22, 0x66, 0xeb, 0xc6, 0x11,
 503         0x48, 0xbb, 0x24, 0x26, 0x76, 0x4c, 0x9c, 0xae, 0xe9, 0xbb, 0x67, 0xa6, 0x4b, 0xd0, 0x5d, 0x58,
 504         0x1d, 0x67, 0x6b, 0xc3, 0xa6, 0x0e, 0xa9, 0x73, 0x6c, 0xc3, 0x4a, 0x9e, 0xec, 0x50, 0x87, 0xa0,
 505         0x0d, 0x00, 0x9b, 0xfa, 0xc7, 0x9e, 0x43, 0x7c, 0x9b, 0x30, 0xca, 0x25, 0x3c, 0x97, 0x69, 0x7c,
 506         0xe5, 0x60, 0x35, 0x67, 0x56, 0x43, 0x62, 0x9e, 0x20, 0x0c, 0x7c, 0x3c, 0x0d, 0x52, 0xb6, 0x5a,
 507         0xeb, 0x45, 0x91, 0xe2, 0x45, 0xa3, 0xca, 0x02, 0x87, 0xc2, 0xbe, 0x83, 0x69, 0x40, 0x30, 0xe3,
 508         0x42, 0xb7, 0x40, 0xf4, 0x22, 0x23, 0x08, 0xc9, 0xb1, 0x37, 0x61, 0x22, 0x2a, 0xb8, 0xe2, 0x45,
 509         0x3a, 0x8b, 0x65, 0x1b, 0xc4, 0x19, 0x1e, 0x55, 0x61, 0x79, 0xd8, 0x3b, 0xe8, 0xf5, 0x8f, 0x7a,
 510         0xd2, 0x7f, 0x48, 0x04, 0xe1, 0x50, 0x6f, 0x77, 0x34, 0x89, 0x43, 0x35, 0x80, 0xc3, 0x21, 0xd6,
 511         0x8c, 0x34, 0x5e, 0x42, 0x08, 0x6a, 0x5a, 0xbf, 0x6b, 0xcc, 0xe5, 0x4a, 0x08, 0xa0, 0xbc, 0xf7,
 512         0x46, 0xdf, 0xd3, 0x7a, 0x12, 0x9f, 0xe0, 0xbb, 0xfb, 0x3d, 0xcd, 0x50, 0xb1, 0xd6, 0x3e, 0x90,
 513         0x84, 0xc6, 0x27, 0x0e, 0x56, 0x12, 0xc9, 0x7a, 0x48, 0x03, 0x12, 0xc6, 0x53, 0x74, 0x0c, 0xc8,
 514         0xc9, 0x34, 0x1b, 0x79, 0xc5, 0xf2, 0x6b, 0x7a, 0xf2, 0x87, 0xa6, 0xf3, 0x2b, 0xc1, 0xff, 0x3b,
 515         0x57, 0x32, 0x11, 0x7a, 0x07, 0xb5, 0xd9, 0x39, 0x56, 0x62, 0x93, 0xf9, 0xaf, 0xb6, 0x1e, 0xfd,
 516         0x4d, 0x61, 0xf1, 0xaa, 0x33, 0x1f, 0xca, 0x1f, 0x39, 0xe0, 0x93, 0xbf, 0x0e, 0xea, 0x43, 0x25,
 517         0xc8, 0x9c, 0xb1, 0x8b, 0xab, 0xb6, 0x76, 0x7e, 0x93, 0x7f, 0xbe, 0x28, 0x78, 0x46, 0x82, 0x6e,
 518         0x82, 0x70, 0xe1, 0x39, 0xf1, 0x88, 0xa9, 0x15, 0x70, 0x1a, 0xa0, 0x35, 0x28, 0x8f, 0x88, 0xe7,
 519         0x8e, 0xe2, 0x7a, 0x89, 0xa5, 0xb3, 0x08, 0x3d, 0x86, 0xb2, 0x35, 0xa6, 0xf6, 0x49, 0x54, 0xe7,
 520         0x59, 0x01, 0x6f, 0x17, 0x1d, 0xae, 0x26, 0x28, 0x9c, 0x81, 0xe5, 0xf7, 0x25, 0x10, 0x58, 0xe6,
 521         0xdf, 0xeb, 0x7f, 0x05, 0x2b, 0x16, 0x3d, 0xf3, 0x1d, 0xcf, 0x77, 0x0d, 0x8b, 0x4e, 0xb2, 0xa2,
 522         0xdf, 0x2b, 0xd4, 0x95, 0x61, 0x75, 0x3a, 0x9e, 0xe2, 0x6a, 0xbe, 0x53, 0xa5, 0x13, 0xd4, 0x06,
 523         0x08, 0xcc, 0xd0, 0x74, 0x43, 0x33, 0x18, 0x45, 0xf5, 0x12, 0xb3, 0x77, 0xa7, 0xb8, 0x8d, 0x33,
 524         0x24, 0x9e, 0xdb, 0x84, 0x5e, 0x02, 0x30, 0xc3, 0x06, 0xeb, 0x2b, 0x9e, 0xf5, 0xd5, 0x83, 0x5f,
 525         0x56, 0x28, 0xfd, 0xb2, 0x06, 0x12, 0xad, 0x7c, 0x29, 0x63, 0x10, 0x67, 0xf9, 0xc5, 0x46, 0xa9,
 526         0x00, 0x3f, 0xd0, 0x5e, 0x0f, 0x24, 0x2e, 0x69, 0x99, 0x41, 0x5b, 0xed, 0x26, 0x2d, 0x52, 0x85,
 527         0x65, 0x7d, 0xbf, 0x33, 0x18, 0xe2, 0xa4, 0x37, 0x44, 0x10, 0xf0, 0xb0, 0xab, 0x61, 0x89, 0x4f,
 528         0xf2, 0x6a, 0x1b, 0x77, 0xfa, 0xbb, 0x9a, 0x24, 0xc8, 0x9f, 0x39, 0x10, 0x67, 0xaa, 0xaf, 0xf1,
 529         0x35, 0xb4, 0x40, 0xb8, 0xa0, 0xa1, 0x93, 0xdf, 0x40, 0xe1, 0x43, 0x7a, 0x44, 0x43, 0x07, 0xa7,
 530         0x50, 0xf9, 0x0b, 0x07, 0x7c, 0x12, 0x5f, 0x63, 0x5b, 0x4f, 0x61, 0x39, 0x9a, 0x9e, 0x5a, 0x74,
 531         0x9c, 0x1b, 0xdb, 0x28, 0xe2, 0x38, 0x64, 0x30, 0x9c, 0xc3, 0xe5, 0x0f, 0x1c, 0x94, 0xd3, 0xdc,
 532         0x35, 0xb6, 0x97, 0x8f, 0xb2, 0xd2, 0xe5, 0x28, 0x53, 0x63, 0x68, 0xd8, 0xf4, 0xb4, 0x80, 0x4b,
 533         0xbd, 0xb1, 0xa8, 0x50, 0x4f, 0x06, 0xab, 0xce, 0xbd, 0x7d, 0x9e, 0xc1, 0x5d, 0x9a, 0xbc, 0xd5,
 534         0x0a, 0x0d, 0xdd, 0xa6, 0x4b, 0x7c, 0x36, 0x76, 0x9b, 0xe9, 0x4f, 0x66, 0xe0, 0x45, 0x57, 0x07,
 535         0xf4, 0xb3, 0x74, 0xf5, 0x9d, 0xe3, 0xac, 0x32, 0xc3, 0xee, 0xfc, 0x08, 0x00, 0x00, 0xff, 0xff,
 536         0x80, 0x29, 0x2a, 0x3b, 0x2f, 0x08, 0x00, 0x00,
 537 }