cmd/bpa-operator/vendor/google.golang.org/appengine/internal/datastore/datastore_v3.pb.go

   1 // Code generated by protoc-gen-go. DO NOT EDIT.
   2 // source: google.golang.org/appengine/internal/datastore/datastore_v3.proto
   3
   4 package datastore
   5
   6 import proto "github.com/golang/protobuf/proto"
   7 import fmt "fmt"
   8 import math "math"
   9
  10 // Reference imports to suppress errors if they are not otherwise used.
  11 var _ = proto.Marshal
  12 var _ = fmt.Errorf
  13 var _ = math.Inf
  14
  15 // This is a compile-time assertion to ensure that this generated file
  16 // is compatible with the proto package it is being compiled against.
  17 // A compilation error at this line likely means your copy of the
  18 // proto package needs to be updated.
  19 const _ = proto.ProtoPackageIsVersion2 // please upgrade the proto package
  20
  21 type Property_Meaning int32
  22
  23 const (
  24         Property_NO_MEANING       Property_Meaning = 0
  25         Property_BLOB             Property_Meaning = 14
  26         Property_TEXT             Property_Meaning = 15
  27         Property_BYTESTRING       Property_Meaning = 16
  28         Property_ATOM_CATEGORY    Property_Meaning = 1
  29         Property_ATOM_LINK        Property_Meaning = 2
  30         Property_ATOM_TITLE       Property_Meaning = 3
  31         Property_ATOM_CONTENT     Property_Meaning = 4
  32         Property_ATOM_SUMMARY     Property_Meaning = 5
  33         Property_ATOM_AUTHOR      Property_Meaning = 6
  34         Property_GD_WHEN          Property_Meaning = 7
  35         Property_GD_EMAIL         Property_Meaning = 8
  36         Property_GEORSS_POINT     Property_Meaning = 9
  37         Property_GD_IM            Property_Meaning = 10
  38         Property_GD_PHONENUMBER   Property_Meaning = 11
  39         Property_GD_POSTALADDRESS Property_Meaning = 12
  40         Property_GD_RATING        Property_Meaning = 13
  41         Property_BLOBKEY          Property_Meaning = 17
  42         Property_ENTITY_PROTO     Property_Meaning = 19
  43         Property_INDEX_VALUE      Property_Meaning = 18
  44 )
  45
  46 var Property_Meaning_name = map[int32]string{
  47         0:  "NO_MEANING",
  48         14: "BLOB",
  49         15: "TEXT",
  50         16: "BYTESTRING",
  51         1:  "ATOM_CATEGORY",
  52         2:  "ATOM_LINK",
  53         3:  "ATOM_TITLE",
  54         4:  "ATOM_CONTENT",
  55         5:  "ATOM_SUMMARY",
  56         6:  "ATOM_AUTHOR",
  57         7:  "GD_WHEN",
  58         8:  "GD_EMAIL",
  59         9:  "GEORSS_POINT",
  60         10: "GD_IM",
  61         11: "GD_PHONENUMBER",
  62         12: "GD_POSTALADDRESS",
  63         13: "GD_RATING",
  64         17: "BLOBKEY",
  65         19: "ENTITY_PROTO",
  66         18: "INDEX_VALUE",
  67 }
  68 var Property_Meaning_value = map[string]int32{
  69         "NO_MEANING":       0,
  70         "BLOB":             14,
  71         "TEXT":             15,
  72         "BYTESTRING":       16,
  73         "ATOM_CATEGORY":    1,
  74         "ATOM_LINK":        2,
  75         "ATOM_TITLE":       3,
  76         "ATOM_CONTENT":     4,
  77         "ATOM_SUMMARY":     5,
  78         "ATOM_AUTHOR":      6,
  79         "GD_WHEN":          7,
  80         "GD_EMAIL":         8,
  81         "GEORSS_POINT":     9,
  82         "GD_IM":            10,
  83         "GD_PHONENUMBER":   11,
  84         "GD_POSTALADDRESS": 12,
  85         "GD_RATING":        13,
  86         "BLOBKEY":          17,
  87         "ENTITY_PROTO":     19,
  88         "INDEX_VALUE":      18,
  89 }
  90
  91 func (x Property_Meaning) Enum() *Property_Meaning {
  92         p := new(Property_Meaning)
  93         *p = x
  94         return p
  95 }
  96 func (x Property_Meaning) String() string {
  97         return proto.EnumName(Property_Meaning_name, int32(x))
  98 }
  99 func (x *Property_Meaning) UnmarshalJSON(data []byte) error {
 100         value, err := proto.UnmarshalJSONEnum(Property_Meaning_value, data, "Property_Meaning")
 101         if err != nil {
 102                 return err
 103         }
 104         *x = Property_Meaning(value)
 105         return nil
 106 }
 107 func (Property_Meaning) EnumDescriptor() ([]byte, []int) {
 108         return fileDescriptor_datastore_v3_83b17b80c34f6179, []int{2, 0}
 109 }
 110
 111 type Property_FtsTokenizationOption int32
 112
 113 const (
 114         Property_HTML Property_FtsTokenizationOption = 1
 115         Property_ATOM Property_FtsTokenizationOption = 2
 116 )
 117
 118 var Property_FtsTokenizationOption_name = map[int32]string{
 119         1: "HTML",
 120         2: "ATOM",
 121 }
 122 var Property_FtsTokenizationOption_value = map[string]int32{
 123         "HTML": 1,
 124         "ATOM": 2,
 125 }
 126
 127 func (x Property_FtsTokenizationOption) Enum() *Property_FtsTokenizationOption {
 128         p := new(Property_FtsTokenizationOption)
 129         *p = x
 130         return p
 131 }
 132 func (x Property_FtsTokenizationOption) String() string {
 133         return proto.EnumName(Property_FtsTokenizationOption_name, int32(x))
 134 }
 135 func (x *Property_FtsTokenizationOption) UnmarshalJSON(data []byte) error {
 136         value, err := proto.UnmarshalJSONEnum(Property_FtsTokenizationOption_value, data, "Property_FtsTokenizationOption")
 137         if err != nil {
 138                 return err
 139         }
 140         *x = Property_FtsTokenizationOption(value)
 141         return nil
 142 }
 143 func (Property_FtsTokenizationOption) EnumDescriptor() ([]byte, []int) {
 144         return fileDescriptor_datastore_v3_83b17b80c34f6179, []int{2, 1}
 145 }
 146
 147 type EntityProto_Kind int32
 148
 149 const (
 150         EntityProto_GD_CONTACT EntityProto_Kind = 1
 151         EntityProto_GD_EVENT   EntityProto_Kind = 2
 152         EntityProto_GD_MESSAGE EntityProto_Kind = 3
 153 )
 154
 155 var EntityProto_Kind_name = map[int32]string{
 156         1: "GD_CONTACT",
 157         2: "GD_EVENT",
 158         3: "GD_MESSAGE",
 159 }
 160 var EntityProto_Kind_value = map[string]int32{
 161         "GD_CONTACT": 1,
 162         "GD_EVENT":   2,
 163         "GD_MESSAGE": 3,
 164 }
 165
 166 func (x EntityProto_Kind) Enum() *EntityProto_Kind {
 167         p := new(EntityProto_Kind)
 168         *p = x
 169         return p
 170 }
 171 func (x EntityProto_Kind) String() string {
 172         return proto.EnumName(EntityProto_Kind_name, int32(x))
 173 }
 174 func (x *EntityProto_Kind) UnmarshalJSON(data []byte) error {
 175         value, err := proto.UnmarshalJSONEnum(EntityProto_Kind_value, data, "EntityProto_Kind")
 176         if err != nil {
 177                 return err
 178         }
 179         *x = EntityProto_Kind(value)
 180         return nil
 181 }
 182 func (EntityProto_Kind) EnumDescriptor() ([]byte, []int) {
 183         return fileDescriptor_datastore_v3_83b17b80c34f6179, []int{6, 0}
 184 }
 185
 186 type Index_Property_Direction int32
 187
 188 const (
 189         Index_Property_ASCENDING  Index_Property_Direction = 1
 190         Index_Property_DESCENDING Index_Property_Direction = 2
 191 )
 192
 193 var Index_Property_Direction_name = map[int32]string{
 194         1: "ASCENDING",
 195         2: "DESCENDING",
 196 }
 197 var Index_Property_Direction_value = map[string]int32{
 198         "ASCENDING":  1,
 199         "DESCENDING": 2,
 200 }
 201
 202 func (x Index_Property_Direction) Enum() *Index_Property_Direction {
 203         p := new(Index_Property_Direction)
 204         *p = x
 205         return p
 206 }
 207 func (x Index_Property_Direction) String() string {
 208         return proto.EnumName(Index_Property_Direction_name, int32(x))
 209 }
 210 func (x *Index_Property_Direction) UnmarshalJSON(data []byte) error {
 211         value, err := proto.UnmarshalJSONEnum(Index_Property_Direction_value, data, "Index_Property_Direction")
 212         if err != nil {
 213                 return err
 214         }
 215         *x = Index_Property_Direction(value)
 216         return nil
 217 }
 218 func (Index_Property_Direction) EnumDescriptor() ([]byte, []int) {
 219         return fileDescriptor_datastore_v3_83b17b80c34f6179, []int{8, 0, 0}
 220 }
 221
 222 type CompositeIndex_State int32
 223
 224 const (
 225         CompositeIndex_WRITE_ONLY CompositeIndex_State = 1
 226         CompositeIndex_READ_WRITE CompositeIndex_State = 2
 227         CompositeIndex_DELETED    CompositeIndex_State = 3
 228         CompositeIndex_ERROR      CompositeIndex_State = 4
 229 )
 230
 231 var CompositeIndex_State_name = map[int32]string{
 232         1: "WRITE_ONLY",
 233         2: "READ_WRITE",
 234         3: "DELETED",
 235         4: "ERROR",
 236 }
 237 var CompositeIndex_State_value = map[string]int32{
 238         "WRITE_ONLY": 1,
 239         "READ_WRITE": 2,
 240         "DELETED":    3,
 241         "ERROR":      4,
 242 }
 243
 244 func (x CompositeIndex_State) Enum() *CompositeIndex_State {
 245         p := new(CompositeIndex_State)
 246         *p = x
 247         return p
 248 }
 249 func (x CompositeIndex_State) String() string {
 250         return proto.EnumName(CompositeIndex_State_name, int32(x))
 251 }
 252 func (x *CompositeIndex_State) UnmarshalJSON(data []byte) error {
 253         value, err := proto.UnmarshalJSONEnum(CompositeIndex_State_value, data, "CompositeIndex_State")
 254         if err != nil {
 255                 return err
 256         }
 257         *x = CompositeIndex_State(value)
 258         return nil
 259 }
 260 func (CompositeIndex_State) EnumDescriptor() ([]byte, []int) {
 261         return fileDescriptor_datastore_v3_83b17b80c34f6179, []int{9, 0}
 262 }
 263
 264 type Snapshot_Status int32
 265
 266 const (
 267         Snapshot_INACTIVE Snapshot_Status = 0
 268         Snapshot_ACTIVE   Snapshot_Status = 1
 269 )
 270
 271 var Snapshot_Status_name = map[int32]string{
 272         0: "INACTIVE",
 273         1: "ACTIVE",
 274 }
 275 var Snapshot_Status_value = map[string]int32{
 276         "INACTIVE": 0,
 277         "ACTIVE":   1,
 278 }
 279
 280 func (x Snapshot_Status) Enum() *Snapshot_Status {
 281         p := new(Snapshot_Status)
 282         *p = x
 283         return p
 284 }
 285 func (x Snapshot_Status) String() string {
 286         return proto.EnumName(Snapshot_Status_name, int32(x))
 287 }
 288 func (x *Snapshot_Status) UnmarshalJSON(data []byte) error {
 289         value, err := proto.UnmarshalJSONEnum(Snapshot_Status_value, data, "Snapshot_Status")
 290         if err != nil {
 291                 return err
 292         }
 293         *x = Snapshot_Status(value)
 294         return nil
 295 }
 296 func (Snapshot_Status) EnumDescriptor() ([]byte, []int) {
 297         return fileDescriptor_datastore_v3_83b17b80c34f6179, []int{12, 0}
 298 }
 299
 300 type Query_Hint int32
 301
 302 const (
 303         Query_ORDER_FIRST    Query_Hint = 1
 304         Query_ANCESTOR_FIRST Query_Hint = 2
 305         Query_FILTER_FIRST   Query_Hint = 3
 306 )
 307
 308 var Query_Hint_name = map[int32]string{
 309         1: "ORDER_FIRST",
 310         2: "ANCESTOR_FIRST",
 311         3: "FILTER_FIRST",
 312 }
 313 var Query_Hint_value = map[string]int32{
 314         "ORDER_FIRST":    1,
 315         "ANCESTOR_FIRST": 2,
 316         "FILTER_FIRST":   3,
 317 }
 318
 319 func (x Query_Hint) Enum() *Query_Hint {
 320         p := new(Query_Hint)
 321         *p = x
 322         return p
 323 }
 324 func (x Query_Hint) String() string {
 325         return proto.EnumName(Query_Hint_name, int32(x))
 326 }
 327 func (x *Query_Hint) UnmarshalJSON(data []byte) error {
 328         value, err := proto.UnmarshalJSONEnum(Query_Hint_value, data, "Query_Hint")
 329         if err != nil {
 330                 return err
 331         }
 332         *x = Query_Hint(value)
 333         return nil
 334 }
 335 func (Query_Hint) EnumDescriptor() ([]byte, []int) {
 336         return fileDescriptor_datastore_v3_83b17b80c34f6179, []int{15, 0}
 337 }
 338
 339 type Query_Filter_Operator int32
 340
 341 const (
 342         Query_Filter_LESS_THAN             Query_Filter_Operator = 1
 343         Query_Filter_LESS_THAN_OR_EQUAL    Query_Filter_Operator = 2
 344         Query_Filter_GREATER_THAN          Query_Filter_Operator = 3
 345         Query_Filter_GREATER_THAN_OR_EQUAL Query_Filter_Operator = 4
 346         Query_Filter_EQUAL                 Query_Filter_Operator = 5
 347         Query_Filter_IN                    Query_Filter_Operator = 6
 348         Query_Filter_EXISTS                Query_Filter_Operator = 7
 349 )
 350
 351 var Query_Filter_Operator_name = map[int32]string{
 352         1: "LESS_THAN",
 353         2: "LESS_THAN_OR_EQUAL",
 354         3: "GREATER_THAN",
 355         4: "GREATER_THAN_OR_EQUAL",
 356         5: "EQUAL",
 357         6: "IN",
 358         7: "EXISTS",
 359 }
 360 var Query_Filter_Operator_value = map[string]int32{
 361         "LESS_THAN":             1,
 362         "LESS_THAN_OR_EQUAL":    2,
 363         "GREATER_THAN":          3,
 364         "GREATER_THAN_OR_EQUAL": 4,
 365         "EQUAL":                 5,
 366         "IN":                    6,
 367         "EXISTS":                7,
 368 }
 369
 370 func (x Query_Filter_Operator) Enum() *Query_Filter_Operator {
 371         p := new(Query_Filter_Operator)
 372         *p = x
 373         return p
 374 }
 375 func (x Query_Filter_Operator) String() string {
 376         return proto.EnumName(Query_Filter_Operator_name, int32(x))
 377 }
 378 func (x *Query_Filter_Operator) UnmarshalJSON(data []byte) error {
 379         value, err := proto.UnmarshalJSONEnum(Query_Filter_Operator_value, data, "Query_Filter_Operator")
 380         if err != nil {
 381                 return err
 382         }
 383         *x = Query_Filter_Operator(value)
 384         return nil
 385 }
 386 func (Query_Filter_Operator) EnumDescriptor() ([]byte, []int) {
 387         return fileDescriptor_datastore_v3_83b17b80c34f6179, []int{15, 0, 0}
 388 }
 389
 390 type Query_Order_Direction int32
 391
 392 const (
 393         Query_Order_ASCENDING  Query_Order_Direction = 1
 394         Query_Order_DESCENDING Query_Order_Direction = 2
 395 )
 396
 397 var Query_Order_Direction_name = map[int32]string{
 398         1: "ASCENDING",
 399         2: "DESCENDING",
 400 }
 401 var Query_Order_Direction_value = map[string]int32{
 402         "ASCENDING":  1,
 403         "DESCENDING": 2,
 404 }
 405
 406 func (x Query_Order_Direction) Enum() *Query_Order_Direction {
 407         p := new(Query_Order_Direction)
 408         *p = x
 409         return p
 410 }
 411 func (x Query_Order_Direction) String() string {
 412         return proto.EnumName(Query_Order_Direction_name, int32(x))
 413 }
 414 func (x *Query_Order_Direction) UnmarshalJSON(data []byte) error {
 415         value, err := proto.UnmarshalJSONEnum(Query_Order_Direction_value, data, "Query_Order_Direction")
 416         if err != nil {
 417                 return err
 418         }
 419         *x = Query_Order_Direction(value)
 420         return nil
 421 }
 422 func (Query_Order_Direction) EnumDescriptor() ([]byte, []int) {
 423         return fileDescriptor_datastore_v3_83b17b80c34f6179, []int{15, 1, 0}
 424 }
 425
 426 type Error_ErrorCode int32
 427
 428 const (
 429         Error_BAD_REQUEST                  Error_ErrorCode = 1
 430         Error_CONCURRENT_TRANSACTION       Error_ErrorCode = 2
 431         Error_INTERNAL_ERROR               Error_ErrorCode = 3
 432         Error_NEED_INDEX                   Error_ErrorCode = 4
 433         Error_TIMEOUT                      Error_ErrorCode = 5
 434         Error_PERMISSION_DENIED            Error_ErrorCode = 6
 435         Error_BIGTABLE_ERROR               Error_ErrorCode = 7
 436         Error_COMMITTED_BUT_STILL_APPLYING Error_ErrorCode = 8
 437         Error_CAPABILITY_DISABLED          Error_ErrorCode = 9
 438         Error_TRY_ALTERNATE_BACKEND        Error_ErrorCode = 10
 439         Error_SAFE_TIME_TOO_OLD            Error_ErrorCode = 11
 440 )
 441
 442 var Error_ErrorCode_name = map[int32]string{
 443         1:  "BAD_REQUEST",
 444         2:  "CONCURRENT_TRANSACTION",
 445         3:  "INTERNAL_ERROR",
 446         4:  "NEED_INDEX",
 447         5:  "TIMEOUT",
 448         6:  "PERMISSION_DENIED",
 449         7:  "BIGTABLE_ERROR",
 450         8:  "COMMITTED_BUT_STILL_APPLYING",
 451         9:  "CAPABILITY_DISABLED",
 452         10: "TRY_ALTERNATE_BACKEND",
 453         11: "SAFE_TIME_TOO_OLD",
 454 }
 455 var Error_ErrorCode_value = map[string]int32{
 456         "BAD_REQUEST":                  1,
 457         "CONCURRENT_TRANSACTION":       2,
 458         "INTERNAL_ERROR":               3,
 459         "NEED_INDEX":                   4,
 460         "TIMEOUT":                      5,
 461         "PERMISSION_DENIED":            6,
 462         "BIGTABLE_ERROR":               7,
 463         "COMMITTED_BUT_STILL_APPLYING": 8,
 464         "CAPABILITY_DISABLED":          9,
 465         "TRY_ALTERNATE_BACKEND":        10,
 466         "SAFE_TIME_TOO_OLD":            11,
 467 }
 468
 469 func (x Error_ErrorCode) Enum() *Error_ErrorCode {
 470         p := new(Error_ErrorCode)
 471         *p = x
 472         return p
 473 }
 474 func (x Error_ErrorCode) String() string {
 475         return proto.EnumName(Error_ErrorCode_name, int32(x))
 476 }
 477 func (x *Error_ErrorCode) UnmarshalJSON(data []byte) error {
 478         value, err := proto.UnmarshalJSONEnum(Error_ErrorCode_value, data, "Error_ErrorCode")
 479         if err != nil {
 480                 return err
 481         }
 482         *x = Error_ErrorCode(value)
 483         return nil
 484 }
 485 func (Error_ErrorCode) EnumDescriptor() ([]byte, []int) {
 486         return fileDescriptor_datastore_v3_83b17b80c34f6179, []int{19, 0}
 487 }
 488
 489 type PutRequest_AutoIdPolicy int32
 490
 491 const (
 492         PutRequest_CURRENT    PutRequest_AutoIdPolicy = 0
 493         PutRequest_SEQUENTIAL PutRequest_AutoIdPolicy = 1
 494 )
 495
 496 var PutRequest_AutoIdPolicy_name = map[int32]string{
 497         0: "CURRENT",
 498         1: "SEQUENTIAL",
 499 }
 500 var PutRequest_AutoIdPolicy_value = map[string]int32{
 501         "CURRENT":    0,
 502         "SEQUENTIAL": 1,
 503 }
 504
 505 func (x PutRequest_AutoIdPolicy) Enum() *PutRequest_AutoIdPolicy {
 506         p := new(PutRequest_AutoIdPolicy)
 507         *p = x
 508         return p
 509 }
 510 func (x PutRequest_AutoIdPolicy) String() string {
 511         return proto.EnumName(PutRequest_AutoIdPolicy_name, int32(x))
 512 }
 513 func (x *PutRequest_AutoIdPolicy) UnmarshalJSON(data []byte) error {
 514         value, err := proto.UnmarshalJSONEnum(PutRequest_AutoIdPolicy_value, data, "PutRequest_AutoIdPolicy")
 515         if err != nil {
 516                 return err
 517         }
 518         *x = PutRequest_AutoIdPolicy(value)
 519         return nil
 520 }
 521 func (PutRequest_AutoIdPolicy) EnumDescriptor() ([]byte, []int) {
 522         return fileDescriptor_datastore_v3_83b17b80c34f6179, []int{23, 0}
 523 }
 524
 525 type BeginTransactionRequest_TransactionMode int32
 526
 527 const (
 528         BeginTransactionRequest_UNKNOWN    BeginTransactionRequest_TransactionMode = 0
 529         BeginTransactionRequest_READ_ONLY  BeginTransactionRequest_TransactionMode = 1
 530         BeginTransactionRequest_READ_WRITE BeginTransactionRequest_TransactionMode = 2
 531 )
 532
 533 var BeginTransactionRequest_TransactionMode_name = map[int32]string{
 534         0: "UNKNOWN",
 535         1: "READ_ONLY",
 536         2: "READ_WRITE",
 537 }
 538 var BeginTransactionRequest_TransactionMode_value = map[string]int32{
 539         "UNKNOWN":    0,
 540         "READ_ONLY":  1,
 541         "READ_WRITE": 2,
 542 }
 543
 544 func (x BeginTransactionRequest_TransactionMode) Enum() *BeginTransactionRequest_TransactionMode {
 545         p := new(BeginTransactionRequest_TransactionMode)
 546         *p = x
 547         return p
 548 }
 549 func (x BeginTransactionRequest_TransactionMode) String() string {
 550         return proto.EnumName(BeginTransactionRequest_TransactionMode_name, int32(x))
 551 }
 552 func (x *BeginTransactionRequest_TransactionMode) UnmarshalJSON(data []byte) error {
 553         value, err := proto.UnmarshalJSONEnum(BeginTransactionRequest_TransactionMode_value, data, "BeginTransactionRequest_TransactionMode")
 554         if err != nil {
 555                 return err
 556         }
 557         *x = BeginTransactionRequest_TransactionMode(value)
 558         return nil
 559 }
 560 func (BeginTransactionRequest_TransactionMode) EnumDescriptor() ([]byte, []int) {
 561         return fileDescriptor_datastore_v3_83b17b80c34f6179, []int{36, 0}
 562 }
 563
 564 type Action struct {
 565         XXX_NoUnkeyedLiteral struct{} `json:"-"`
 566         XXX_unrecognized     []byte   `json:"-"`
 567         XXX_sizecache        int32    `json:"-"`
 568 }
 569
 570 func (m *Action) Reset()         { *m = Action{} }
 571 func (m *Action) String() string { return proto.CompactTextString(m) }
 572 func (*Action) ProtoMessage()    {}
 573 func (*Action) Descriptor() ([]byte, []int) {
 574         return fileDescriptor_datastore_v3_83b17b80c34f6179, []int{0}
 575 }
 576 func (m *Action) XXX_Unmarshal(b []byte) error {
 577         return xxx_messageInfo_Action.Unmarshal(m, b)
 578 }
 579 func (m *Action) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
 580         return xxx_messageInfo_Action.Marshal(b, m, deterministic)
 581 }
 582 func (dst *Action) XXX_Merge(src proto.Message) {
 583         xxx_messageInfo_Action.Merge(dst, src)
 584 }
 585 func (m *Action) XXX_Size() int {
 586         return xxx_messageInfo_Action.Size(m)
 587 }
 588 func (m *Action) XXX_DiscardUnknown() {
 589         xxx_messageInfo_Action.DiscardUnknown(m)
 590 }
 591
 592 var xxx_messageInfo_Action proto.InternalMessageInfo
 593
 594 type PropertyValue struct {
 595         Int64Value           *int64                        `protobuf:"varint,1,opt,name=int64Value" json:"int64Value,omitempty"`
 596         BooleanValue         *bool                         `protobuf:"varint,2,opt,name=booleanValue" json:"booleanValue,omitempty"`
 597         StringValue          *string                       `protobuf:"bytes,3,opt,name=stringValue" json:"stringValue,omitempty"`
 598         DoubleValue          *float64                      `protobuf:"fixed64,4,opt,name=doubleValue" json:"doubleValue,omitempty"`
 599         Pointvalue           *PropertyValue_PointValue     `protobuf:"group,5,opt,name=PointValue,json=pointvalue" json:"pointvalue,omitempty"`
 600         Uservalue            *PropertyValue_UserValue      `protobuf:"group,8,opt,name=UserValue,json=uservalue" json:"uservalue,omitempty"`
 601         Referencevalue       *PropertyValue_ReferenceValue `protobuf:"group,12,opt,name=ReferenceValue,json=referencevalue" json:"referencevalue,omitempty"`
 602         XXX_NoUnkeyedLiteral struct{}                      `json:"-"`
 603         XXX_unrecognized     []byte                        `json:"-"`
 604         XXX_sizecache        int32                         `json:"-"`
 605 }
 606
 607 func (m *PropertyValue) Reset()         { *m = PropertyValue{} }
 608 func (m *PropertyValue) String() string { return proto.CompactTextString(m) }
 609 func (*PropertyValue) ProtoMessage()    {}
 610 func (*PropertyValue) Descriptor() ([]byte, []int) {
 611         return fileDescriptor_datastore_v3_83b17b80c34f6179, []int{1}
 612 }
 613 func (m *PropertyValue) XXX_Unmarshal(b []byte) error {
 614         return xxx_messageInfo_PropertyValue.Unmarshal(m, b)
 615 }
 616 func (m *PropertyValue) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
 617         return xxx_messageInfo_PropertyValue.Marshal(b, m, deterministic)
 618 }
 619 func (dst *PropertyValue) XXX_Merge(src proto.Message) {
 620         xxx_messageInfo_PropertyValue.Merge(dst, src)
 621 }
 622 func (m *PropertyValue) XXX_Size() int {
 623         return xxx_messageInfo_PropertyValue.Size(m)
 624 }
 625 func (m *PropertyValue) XXX_DiscardUnknown() {
 626         xxx_messageInfo_PropertyValue.DiscardUnknown(m)
 627 }
 628
 629 var xxx_messageInfo_PropertyValue proto.InternalMessageInfo
 630
 631 func (m *PropertyValue) GetInt64Value() int64 {
 632         if m != nil && m.Int64Value != nil {
 633                 return *m.Int64Value
 634         }
 635         return 0
 636 }
 637
 638 func (m *PropertyValue) GetBooleanValue() bool {
 639         if m != nil && m.BooleanValue != nil {
 640                 return *m.BooleanValue
 641         }
 642         return false
 643 }
 644
 645 func (m *PropertyValue) GetStringValue() string {
 646         if m != nil && m.StringValue != nil {
 647                 return *m.StringValue
 648         }
 649         return ""
 650 }
 651
 652 func (m *PropertyValue) GetDoubleValue() float64 {
 653         if m != nil && m.DoubleValue != nil {
 654                 return *m.DoubleValue
 655         }
 656         return 0
 657 }
 658
 659 func (m *PropertyValue) GetPointvalue() *PropertyValue_PointValue {
 660         if m != nil {
 661                 return m.Pointvalue
 662         }
 663         return nil
 664 }
 665
 666 func (m *PropertyValue) GetUservalue() *PropertyValue_UserValue {
 667         if m != nil {
 668                 return m.Uservalue
 669         }
 670         return nil
 671 }
 672
 673 func (m *PropertyValue) GetReferencevalue() *PropertyValue_ReferenceValue {
 674         if m != nil {
 675                 return m.Referencevalue
 676         }
 677         return nil
 678 }
 679
 680 type PropertyValue_PointValue struct {
 681         X                    *float64 `protobuf:"fixed64,6,req,name=x" json:"x,omitempty"`
 682         Y                    *float64 `protobuf:"fixed64,7,req,name=y" json:"y,omitempty"`
 683         XXX_NoUnkeyedLiteral struct{} `json:"-"`
 684         XXX_unrecognized     []byte   `json:"-"`
 685         XXX_sizecache        int32    `json:"-"`
 686 }
 687
 688 func (m *PropertyValue_PointValue) Reset()         { *m = PropertyValue_PointValue{} }
 689 func (m *PropertyValue_PointValue) String() string { return proto.CompactTextString(m) }
 690 func (*PropertyValue_PointValue) ProtoMessage()    {}
 691 func (*PropertyValue_PointValue) Descriptor() ([]byte, []int) {
 692         return fileDescriptor_datastore_v3_83b17b80c34f6179, []int{1, 0}
 693 }
 694 func (m *PropertyValue_PointValue) XXX_Unmarshal(b []byte) error {
 695         return xxx_messageInfo_PropertyValue_PointValue.Unmarshal(m, b)
 696 }
 697 func (m *PropertyValue_PointValue) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
 698         return xxx_messageInfo_PropertyValue_PointValue.Marshal(b, m, deterministic)
 699 }
 700 func (dst *PropertyValue_PointValue) XXX_Merge(src proto.Message) {
 701         xxx_messageInfo_PropertyValue_PointValue.Merge(dst, src)
 702 }
 703 func (m *PropertyValue_PointValue) XXX_Size() int {
 704         return xxx_messageInfo_PropertyValue_PointValue.Size(m)
 705 }
 706 func (m *PropertyValue_PointValue) XXX_DiscardUnknown() {
 707         xxx_messageInfo_PropertyValue_PointValue.DiscardUnknown(m)
 708 }
 709
 710 var xxx_messageInfo_PropertyValue_PointValue proto.InternalMessageInfo
 711
 712 func (m *PropertyValue_PointValue) GetX() float64 {
 713         if m != nil && m.X != nil {
 714                 return *m.X
 715         }
 716         return 0
 717 }
 718
 719 func (m *PropertyValue_PointValue) GetY() float64 {
 720         if m != nil && m.Y != nil {
 721                 return *m.Y
 722         }
 723         return 0
 724 }
 725
 726 type PropertyValue_UserValue struct {
 727         Email                *string  `protobuf:"bytes,9,req,name=email" json:"email,omitempty"`
 728         AuthDomain           *string  `protobuf:"bytes,10,req,name=auth_domain,json=authDomain" json:"auth_domain,omitempty"`
 729         Nickname             *string  `protobuf:"bytes,11,opt,name=nickname" json:"nickname,omitempty"`
 730         FederatedIdentity    *string  `protobuf:"bytes,21,opt,name=federated_identity,json=federatedIdentity" json:"federated_identity,omitempty"`
 731         FederatedProvider    *string  `protobuf:"bytes,22,opt,name=federated_provider,json=federatedProvider" json:"federated_provider,omitempty"`
 732         XXX_NoUnkeyedLiteral struct{} `json:"-"`
 733         XXX_unrecognized     []byte   `json:"-"`
 734         XXX_sizecache        int32    `json:"-"`
 735 }
 736
 737 func (m *PropertyValue_UserValue) Reset()         { *m = PropertyValue_UserValue{} }
 738 func (m *PropertyValue_UserValue) String() string { return proto.CompactTextString(m) }
 739 func (*PropertyValue_UserValue) ProtoMessage()    {}
 740 func (*PropertyValue_UserValue) Descriptor() ([]byte, []int) {
 741         return fileDescriptor_datastore_v3_83b17b80c34f6179, []int{1, 1}
 742 }
 743 func (m *PropertyValue_UserValue) XXX_Unmarshal(b []byte) error {
 744         return xxx_messageInfo_PropertyValue_UserValue.Unmarshal(m, b)
 745 }
 746 func (m *PropertyValue_UserValue) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
 747         return xxx_messageInfo_PropertyValue_UserValue.Marshal(b, m, deterministic)
 748 }
 749 func (dst *PropertyValue_UserValue) XXX_Merge(src proto.Message) {
 750         xxx_messageInfo_PropertyValue_UserValue.Merge(dst, src)
 751 }
 752 func (m *PropertyValue_UserValue) XXX_Size() int {
 753         return xxx_messageInfo_PropertyValue_UserValue.Size(m)
 754 }
 755 func (m *PropertyValue_UserValue) XXX_DiscardUnknown() {
 756         xxx_messageInfo_PropertyValue_UserValue.DiscardUnknown(m)
 757 }
 758
 759 var xxx_messageInfo_PropertyValue_UserValue proto.InternalMessageInfo
 760
 761 func (m *PropertyValue_UserValue) GetEmail() string {
 762         if m != nil && m.Email != nil {
 763                 return *m.Email
 764         }
 765         return ""
 766 }
 767
 768 func (m *PropertyValue_UserValue) GetAuthDomain() string {
 769         if m != nil && m.AuthDomain != nil {
 770                 return *m.AuthDomain
 771         }
 772         return ""
 773 }
 774
 775 func (m *PropertyValue_UserValue) GetNickname() string {
 776         if m != nil && m.Nickname != nil {
 777                 return *m.Nickname
 778         }
 779         return ""
 780 }
 781
 782 func (m *PropertyValue_UserValue) GetFederatedIdentity() string {
 783         if m != nil && m.FederatedIdentity != nil {
 784                 return *m.FederatedIdentity
 785         }
 786         return ""
 787 }
 788
 789 func (m *PropertyValue_UserValue) GetFederatedProvider() string {
 790         if m != nil && m.FederatedProvider != nil {
 791                 return *m.FederatedProvider
 792         }
 793         return ""
 794 }
 795
 796 type PropertyValue_ReferenceValue struct {
 797         App                  *string                                     `protobuf:"bytes,13,req,name=app" json:"app,omitempty"`
 798         NameSpace            *string                                     `protobuf:"bytes,20,opt,name=name_space,json=nameSpace" json:"name_space,omitempty"`
 799         Pathelement          []*PropertyValue_ReferenceValue_PathElement `protobuf:"group,14,rep,name=PathElement,json=pathelement" json:"pathelement,omitempty"`
 800         XXX_NoUnkeyedLiteral struct{}                                    `json:"-"`
 801         XXX_unrecognized     []byte                                      `json:"-"`
 802         XXX_sizecache        int32                                       `json:"-"`
 803 }
 804
 805 func (m *PropertyValue_ReferenceValue) Reset()         { *m = PropertyValue_ReferenceValue{} }
 806 func (m *PropertyValue_ReferenceValue) String() string { return proto.CompactTextString(m) }
 807 func (*PropertyValue_ReferenceValue) ProtoMessage()    {}
 808 func (*PropertyValue_ReferenceValue) Descriptor() ([]byte, []int) {
 809         return fileDescriptor_datastore_v3_83b17b80c34f6179, []int{1, 2}
 810 }
 811 func (m *PropertyValue_ReferenceValue) XXX_Unmarshal(b []byte) error {
 812         return xxx_messageInfo_PropertyValue_ReferenceValue.Unmarshal(m, b)
 813 }
 814 func (m *PropertyValue_ReferenceValue) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
 815         return xxx_messageInfo_PropertyValue_ReferenceValue.Marshal(b, m, deterministic)
 816 }
 817 func (dst *PropertyValue_ReferenceValue) XXX_Merge(src proto.Message) {
 818         xxx_messageInfo_PropertyValue_ReferenceValue.Merge(dst, src)
 819 }
 820 func (m *PropertyValue_ReferenceValue) XXX_Size() int {
 821         return xxx_messageInfo_PropertyValue_ReferenceValue.Size(m)
 822 }
 823 func (m *PropertyValue_ReferenceValue) XXX_DiscardUnknown() {
 824         xxx_messageInfo_PropertyValue_ReferenceValue.DiscardUnknown(m)
 825 }
 826
 827 var xxx_messageInfo_PropertyValue_ReferenceValue proto.InternalMessageInfo
 828
 829 func (m *PropertyValue_ReferenceValue) GetApp() string {
 830         if m != nil && m.App != nil {
 831                 return *m.App
 832         }
 833         return ""
 834 }
 835
 836 func (m *PropertyValue_ReferenceValue) GetNameSpace() string {
 837         if m != nil && m.NameSpace != nil {
 838                 return *m.NameSpace
 839         }
 840         return ""
 841 }
 842
 843 func (m *PropertyValue_ReferenceValue) GetPathelement() []*PropertyValue_ReferenceValue_PathElement {
 844         if m != nil {
 845                 return m.Pathelement
 846         }
 847         return nil
 848 }
 849
 850 type PropertyValue_ReferenceValue_PathElement struct {
 851         Type                 *string  `protobuf:"bytes,15,req,name=type" json:"type,omitempty"`
 852         Id                   *int64   `protobuf:"varint,16,opt,name=id" json:"id,omitempty"`
 853         Name                 *string  `protobuf:"bytes,17,opt,name=name" json:"name,omitempty"`
 854         XXX_NoUnkeyedLiteral struct{} `json:"-"`
 855         XXX_unrecognized     []byte   `json:"-"`
 856         XXX_sizecache        int32    `json:"-"`
 857 }
 858
 859 func (m *PropertyValue_ReferenceValue_PathElement) Reset() {
 860         *m = PropertyValue_ReferenceValue_PathElement{}
 861 }
 862 func (m *PropertyValue_ReferenceValue_PathElement) String() string { return proto.CompactTextString(m) }
 863 func (*PropertyValue_ReferenceValue_PathElement) ProtoMessage()    {}
 864 func (*PropertyValue_ReferenceValue_PathElement) Descriptor() ([]byte, []int) {
 865         return fileDescriptor_datastore_v3_83b17b80c34f6179, []int{1, 2, 0}
 866 }
 867 func (m *PropertyValue_ReferenceValue_PathElement) XXX_Unmarshal(b []byte) error {
 868         return xxx_messageInfo_PropertyValue_ReferenceValue_PathElement.Unmarshal(m, b)
 869 }
 870 func (m *PropertyValue_ReferenceValue_PathElement) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
 871         return xxx_messageInfo_PropertyValue_ReferenceValue_PathElement.Marshal(b, m, deterministic)
 872 }
 873 func (dst *PropertyValue_ReferenceValue_PathElement) XXX_Merge(src proto.Message) {
 874         xxx_messageInfo_PropertyValue_ReferenceValue_PathElement.Merge(dst, src)
 875 }
 876 func (m *PropertyValue_ReferenceValue_PathElement) XXX_Size() int {
 877         return xxx_messageInfo_PropertyValue_ReferenceValue_PathElement.Size(m)
 878 }
 879 func (m *PropertyValue_ReferenceValue_PathElement) XXX_DiscardUnknown() {
 880         xxx_messageInfo_PropertyValue_ReferenceValue_PathElement.DiscardUnknown(m)
 881 }
 882
 883 var xxx_messageInfo_PropertyValue_ReferenceValue_PathElement proto.InternalMessageInfo
 884
 885 func (m *PropertyValue_ReferenceValue_PathElement) GetType() string {
 886         if m != nil && m.Type != nil {
 887                 return *m.Type
 888         }
 889         return ""
 890 }
 891
 892 func (m *PropertyValue_ReferenceValue_PathElement) GetId() int64 {
 893         if m != nil && m.Id != nil {
 894                 return *m.Id
 895         }
 896         return 0
 897 }
 898
 899 func (m *PropertyValue_ReferenceValue_PathElement) GetName() string {
 900         if m != nil && m.Name != nil {
 901                 return *m.Name
 902         }
 903         return ""
 904 }
 905
 906 type Property struct {
 907         Meaning               *Property_Meaning               `protobuf:"varint,1,opt,name=meaning,enum=appengine.Property_Meaning,def=0" json:"meaning,omitempty"`
 908         MeaningUri            *string                         `protobuf:"bytes,2,opt,name=meaning_uri,json=meaningUri" json:"meaning_uri,omitempty"`
 909         Name                  *string                         `protobuf:"bytes,3,req,name=name" json:"name,omitempty"`
 910         Value                 *PropertyValue                  `protobuf:"bytes,5,req,name=value" json:"value,omitempty"`
 911         Multiple              *bool                           `protobuf:"varint,4,req,name=multiple" json:"multiple,omitempty"`
 912         Searchable            *bool                           `protobuf:"varint,6,opt,name=searchable,def=0" json:"searchable,omitempty"`
 913         FtsTokenizationOption *Property_FtsTokenizationOption `protobuf:"varint,8,opt,name=fts_tokenization_option,json=ftsTokenizationOption,enum=appengine.Property_FtsTokenizationOption" json:"fts_tokenization_option,omitempty"`
 914         Locale                *string                         `protobuf:"bytes,9,opt,name=locale,def=en" json:"locale,omitempty"`
 915         XXX_NoUnkeyedLiteral  struct{}                        `json:"-"`
 916         XXX_unrecognized      []byte                          `json:"-"`
 917         XXX_sizecache         int32                           `json:"-"`
 918 }
 919
 920 func (m *Property) Reset()         { *m = Property{} }
 921 func (m *Property) String() string { return proto.CompactTextString(m) }
 922 func (*Property) ProtoMessage()    {}
 923 func (*Property) Descriptor() ([]byte, []int) {
 924         return fileDescriptor_datastore_v3_83b17b80c34f6179, []int{2}
 925 }
 926 func (m *Property) XXX_Unmarshal(b []byte) error {
 927         return xxx_messageInfo_Property.Unmarshal(m, b)
 928 }
 929 func (m *Property) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
 930         return xxx_messageInfo_Property.Marshal(b, m, deterministic)
 931 }
 932 func (dst *Property) XXX_Merge(src proto.Message) {
 933         xxx_messageInfo_Property.Merge(dst, src)
 934 }
 935 func (m *Property) XXX_Size() int {
 936         return xxx_messageInfo_Property.Size(m)
 937 }
 938 func (m *Property) XXX_DiscardUnknown() {
 939         xxx_messageInfo_Property.DiscardUnknown(m)
 940 }
 941
 942 var xxx_messageInfo_Property proto.InternalMessageInfo
 943
 944 const Default_Property_Meaning Property_Meaning = Property_NO_MEANING
 945 const Default_Property_Searchable bool = false
 946 const Default_Property_Locale string = "en"
 947
 948 func (m *Property) GetMeaning() Property_Meaning {
 949         if m != nil && m.Meaning != nil {
 950                 return *m.Meaning
 951         }
 952         return Default_Property_Meaning
 953 }
 954
 955 func (m *Property) GetMeaningUri() string {
 956         if m != nil && m.MeaningUri != nil {
 957                 return *m.MeaningUri
 958         }
 959         return ""
 960 }
 961
 962 func (m *Property) GetName() string {
 963         if m != nil && m.Name != nil {
 964                 return *m.Name
 965         }
 966         return ""
 967 }
 968
 969 func (m *Property) GetValue() *PropertyValue {
 970         if m != nil {
 971                 return m.Value
 972         }
 973         return nil
 974 }
 975
 976 func (m *Property) GetMultiple() bool {
 977         if m != nil && m.Multiple != nil {
 978                 return *m.Multiple
 979         }
 980         return false
 981 }
 982
 983 func (m *Property) GetSearchable() bool {
 984         if m != nil && m.Searchable != nil {
 985                 return *m.Searchable
 986         }
 987         return Default_Property_Searchable
 988 }
 989
 990 func (m *Property) GetFtsTokenizationOption() Property_FtsTokenizationOption {
 991         if m != nil && m.FtsTokenizationOption != nil {
 992                 return *m.FtsTokenizationOption
 993         }
 994         return Property_HTML
 995 }
 996
 997 func (m *Property) GetLocale() string {
 998         if m != nil && m.Locale != nil {
 999                 return *m.Locale
1000         }
1001         return Default_Property_Locale
1002 }
1003
1004 type Path struct {
1005         Element              []*Path_Element `protobuf:"group,1,rep,name=Element,json=element" json:"element,omitempty"`
1006         XXX_NoUnkeyedLiteral struct{}        `json:"-"`
1007         XXX_unrecognized     []byte          `json:"-"`
1008         XXX_sizecache        int32           `json:"-"`
1009 }
1010
1011 func (m *Path) Reset()         { *m = Path{} }
1012 func (m *Path) String() string { return proto.CompactTextString(m) }
1013 func (*Path) ProtoMessage()    {}
1014 func (*Path) Descriptor() ([]byte, []int) {
1015         return fileDescriptor_datastore_v3_83b17b80c34f6179, []int{3}
1016 }
1017 func (m *Path) XXX_Unmarshal(b []byte) error {
1018         return xxx_messageInfo_Path.Unmarshal(m, b)
1019 }
1020 func (m *Path) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
1021         return xxx_messageInfo_Path.Marshal(b, m, deterministic)
1022 }
1023 func (dst *Path) XXX_Merge(src proto.Message) {
1024         xxx_messageInfo_Path.Merge(dst, src)
1025 }
1026 func (m *Path) XXX_Size() int {
1027         return xxx_messageInfo_Path.Size(m)
1028 }
1029 func (m *Path) XXX_DiscardUnknown() {
1030         xxx_messageInfo_Path.DiscardUnknown(m)
1031 }
1032
1033 var xxx_messageInfo_Path proto.InternalMessageInfo
1034
1035 func (m *Path) GetElement() []*Path_Element {
1036         if m != nil {
1037                 return m.Element
1038         }
1039         return nil
1040 }
1041
1042 type Path_Element struct {
1043         Type                 *string  `protobuf:"bytes,2,req,name=type" json:"type,omitempty"`
1044         Id                   *int64   `protobuf:"varint,3,opt,name=id" json:"id,omitempty"`
1045         Name                 *string  `protobuf:"bytes,4,opt,name=name" json:"name,omitempty"`
1046         XXX_NoUnkeyedLiteral struct{} `json:"-"`
1047         XXX_unrecognized     []byte   `json:"-"`
1048         XXX_sizecache        int32    `json:"-"`
1049 }
1050
1051 func (m *Path_Element) Reset()         { *m = Path_Element{} }
1052 func (m *Path_Element) String() string { return proto.CompactTextString(m) }
1053 func (*Path_Element) ProtoMessage()    {}
1054 func (*Path_Element) Descriptor() ([]byte, []int) {
1055         return fileDescriptor_datastore_v3_83b17b80c34f6179, []int{3, 0}
1056 }
1057 func (m *Path_Element) XXX_Unmarshal(b []byte) error {
1058         return xxx_messageInfo_Path_Element.Unmarshal(m, b)
1059 }
1060 func (m *Path_Element) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
1061         return xxx_messageInfo_Path_Element.Marshal(b, m, deterministic)
1062 }
1063 func (dst *Path_Element) XXX_Merge(src proto.Message) {
1064         xxx_messageInfo_Path_Element.Merge(dst, src)
1065 }
1066 func (m *Path_Element) XXX_Size() int {
1067         return xxx_messageInfo_Path_Element.Size(m)
1068 }
1069 func (m *Path_Element) XXX_DiscardUnknown() {
1070         xxx_messageInfo_Path_Element.DiscardUnknown(m)
1071 }
1072
1073 var xxx_messageInfo_Path_Element proto.InternalMessageInfo
1074
1075 func (m *Path_Element) GetType() string {
1076         if m != nil && m.Type != nil {
1077                 return *m.Type
1078         }
1079         return ""
1080 }
1081
1082 func (m *Path_Element) GetId() int64 {
1083         if m != nil && m.Id != nil {
1084                 return *m.Id
1085         }
1086         return 0
1087 }
1088
1089 func (m *Path_Element) GetName() string {
1090         if m != nil && m.Name != nil {
1091                 return *m.Name
1092         }
1093         return ""
1094 }
1095
1096 type Reference struct {
1097         App                  *string  `protobuf:"bytes,13,req,name=app" json:"app,omitempty"`
1098         NameSpace            *string  `protobuf:"bytes,20,opt,name=name_space,json=nameSpace" json:"name_space,omitempty"`
1099         Path                 *Path    `protobuf:"bytes,14,req,name=path" json:"path,omitempty"`
1100         XXX_NoUnkeyedLiteral struct{} `json:"-"`
1101         XXX_unrecognized     []byte   `json:"-"`
1102         XXX_sizecache        int32    `json:"-"`
1103 }
1104
1105 func (m *Reference) Reset()         { *m = Reference{} }
1106 func (m *Reference) String() string { return proto.CompactTextString(m) }
1107 func (*Reference) ProtoMessage()    {}
1108 func (*Reference) Descriptor() ([]byte, []int) {
1109         return fileDescriptor_datastore_v3_83b17b80c34f6179, []int{4}
1110 }
1111 func (m *Reference) XXX_Unmarshal(b []byte) error {
1112         return xxx_messageInfo_Reference.Unmarshal(m, b)
1113 }
1114 func (m *Reference) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
1115         return xxx_messageInfo_Reference.Marshal(b, m, deterministic)
1116 }
1117 func (dst *Reference) XXX_Merge(src proto.Message) {
1118         xxx_messageInfo_Reference.Merge(dst, src)
1119 }
1120 func (m *Reference) XXX_Size() int {
1121         return xxx_messageInfo_Reference.Size(m)
1122 }
1123 func (m *Reference) XXX_DiscardUnknown() {
1124         xxx_messageInfo_Reference.DiscardUnknown(m)
1125 }
1126
1127 var xxx_messageInfo_Reference proto.InternalMessageInfo
1128
1129 func (m *Reference) GetApp() string {
1130         if m != nil && m.App != nil {
1131                 return *m.App
1132         }
1133         return ""
1134 }
1135
1136 func (m *Reference) GetNameSpace() string {
1137         if m != nil && m.NameSpace != nil {
1138                 return *m.NameSpace
1139         }
1140         return ""
1141 }
1142
1143 func (m *Reference) GetPath() *Path {
1144         if m != nil {
1145                 return m.Path
1146         }
1147         return nil
1148 }
1149
1150 type User struct {
1151         Email                *string  `protobuf:"bytes,1,req,name=email" json:"email,omitempty"`
1152         AuthDomain           *string  `protobuf:"bytes,2,req,name=auth_domain,json=authDomain" json:"auth_domain,omitempty"`
1153         Nickname             *string  `protobuf:"bytes,3,opt,name=nickname" json:"nickname,omitempty"`
1154         FederatedIdentity    *string  `protobuf:"bytes,6,opt,name=federated_identity,json=federatedIdentity" json:"federated_identity,omitempty"`
1155         FederatedProvider    *string  `protobuf:"bytes,7,opt,name=federated_provider,json=federatedProvider" json:"federated_provider,omitempty"`
1156         XXX_NoUnkeyedLiteral struct{} `json:"-"`
1157         XXX_unrecognized     []byte   `json:"-"`
1158         XXX_sizecache        int32    `json:"-"`
1159 }
1160
1161 func (m *User) Reset()         { *m = User{} }
1162 func (m *User) String() string { return proto.CompactTextString(m) }
1163 func (*User) ProtoMessage()    {}
1164 func (*User) Descriptor() ([]byte, []int) {
1165         return fileDescriptor_datastore_v3_83b17b80c34f6179, []int{5}
1166 }
1167 func (m *User) XXX_Unmarshal(b []byte) error {
1168         return xxx_messageInfo_User.Unmarshal(m, b)
1169 }
1170 func (m *User) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
1171         return xxx_messageInfo_User.Marshal(b, m, deterministic)
1172 }
1173 func (dst *User) XXX_Merge(src proto.Message) {
1174         xxx_messageInfo_User.Merge(dst, src)
1175 }
1176 func (m *User) XXX_Size() int {
1177         return xxx_messageInfo_User.Size(m)
1178 }
1179 func (m *User) XXX_DiscardUnknown() {
1180         xxx_messageInfo_User.DiscardUnknown(m)
1181 }
1182
1183 var xxx_messageInfo_User proto.InternalMessageInfo
1184
1185 func (m *User) GetEmail() string {
1186         if m != nil && m.Email != nil {
1187                 return *m.Email
1188         }
1189         return ""
1190 }
1191
1192 func (m *User) GetAuthDomain() string {
1193         if m != nil && m.AuthDomain != nil {
1194                 return *m.AuthDomain
1195         }
1196         return ""
1197 }
1198
1199 func (m *User) GetNickname() string {
1200         if m != nil && m.Nickname != nil {
1201                 return *m.Nickname
1202         }
1203         return ""
1204 }
1205
1206 func (m *User) GetFederatedIdentity() string {
1207         if m != nil && m.FederatedIdentity != nil {
1208                 return *m.FederatedIdentity
1209         }
1210         return ""
1211 }
1212
1213 func (m *User) GetFederatedProvider() string {
1214         if m != nil && m.FederatedProvider != nil {
1215                 return *m.FederatedProvider
1216         }
1217         return ""
1218 }
1219
1220 type EntityProto struct {
1221         Key                  *Reference        `protobuf:"bytes,13,req,name=key" json:"key,omitempty"`
1222         EntityGroup          *Path             `protobuf:"bytes,16,req,name=entity_group,json=entityGroup" json:"entity_group,omitempty"`
1223         Owner                *User             `protobuf:"bytes,17,opt,name=owner" json:"owner,omitempty"`
1224         Kind                 *EntityProto_Kind `protobuf:"varint,4,opt,name=kind,enum=appengine.EntityProto_Kind" json:"kind,omitempty"`
1225         KindUri              *string           `protobuf:"bytes,5,opt,name=kind_uri,json=kindUri" json:"kind_uri,omitempty"`
1226         Property             []*Property       `protobuf:"bytes,14,rep,name=property" json:"property,omitempty"`
1227         RawProperty          []*Property       `protobuf:"bytes,15,rep,name=raw_property,json=rawProperty" json:"raw_property,omitempty"`
1228         Rank                 *int32            `protobuf:"varint,18,opt,name=rank" json:"rank,omitempty"`
1229         XXX_NoUnkeyedLiteral struct{}          `json:"-"`
1230         XXX_unrecognized     []byte            `json:"-"`
1231         XXX_sizecache        int32             `json:"-"`
1232 }
1233
1234 func (m *EntityProto) Reset()         { *m = EntityProto{} }
1235 func (m *EntityProto) String() string { return proto.CompactTextString(m) }
1236 func (*EntityProto) ProtoMessage()    {}
1237 func (*EntityProto) Descriptor() ([]byte, []int) {
1238         return fileDescriptor_datastore_v3_83b17b80c34f6179, []int{6}
1239 }
1240 func (m *EntityProto) XXX_Unmarshal(b []byte) error {
1241         return xxx_messageInfo_EntityProto.Unmarshal(m, b)
1242 }
1243 func (m *EntityProto) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
1244         return xxx_messageInfo_EntityProto.Marshal(b, m, deterministic)
1245 }
1246 func (dst *EntityProto) XXX_Merge(src proto.Message) {
1247         xxx_messageInfo_EntityProto.Merge(dst, src)
1248 }
1249 func (m *EntityProto) XXX_Size() int {
1250         return xxx_messageInfo_EntityProto.Size(m)
1251 }
1252 func (m *EntityProto) XXX_DiscardUnknown() {
1253         xxx_messageInfo_EntityProto.DiscardUnknown(m)
1254 }
1255
1256 var xxx_messageInfo_EntityProto proto.InternalMessageInfo
1257
1258 func (m *EntityProto) GetKey() *Reference {
1259         if m != nil {
1260                 return m.Key
1261         }
1262         return nil
1263 }
1264
1265 func (m *EntityProto) GetEntityGroup() *Path {
1266         if m != nil {
1267                 return m.EntityGroup
1268         }
1269         return nil
1270 }
1271
1272 func (m *EntityProto) GetOwner() *User {
1273         if m != nil {
1274                 return m.Owner
1275         }
1276         return nil
1277 }
1278
1279 func (m *EntityProto) GetKind() EntityProto_Kind {
1280         if m != nil && m.Kind != nil {
1281                 return *m.Kind
1282         }
1283         return EntityProto_GD_CONTACT
1284 }
1285
1286 func (m *EntityProto) GetKindUri() string {
1287         if m != nil && m.KindUri != nil {
1288                 return *m.KindUri
1289         }
1290         return ""
1291 }
1292
1293 func (m *EntityProto) GetProperty() []*Property {
1294         if m != nil {
1295                 return m.Property
1296         }
1297         return nil
1298 }
1299
1300 func (m *EntityProto) GetRawProperty() []*Property {
1301         if m != nil {
1302                 return m.RawProperty
1303         }
1304         return nil
1305 }
1306
1307 func (m *EntityProto) GetRank() int32 {
1308         if m != nil && m.Rank != nil {
1309                 return *m.Rank
1310         }
1311         return 0
1312 }
1313
1314 type CompositeProperty struct {
1315         IndexId              *int64   `protobuf:"varint,1,req,name=index_id,json=indexId" json:"index_id,omitempty"`
1316         Value                []string `protobuf:"bytes,2,rep,name=value" json:"value,omitempty"`
1317         XXX_NoUnkeyedLiteral struct{} `json:"-"`
1318         XXX_unrecognized     []byte   `json:"-"`
1319         XXX_sizecache        int32    `json:"-"`
1320 }
1321
1322 func (m *CompositeProperty) Reset()         { *m = CompositeProperty{} }
1323 func (m *CompositeProperty) String() string { return proto.CompactTextString(m) }
1324 func (*CompositeProperty) ProtoMessage()    {}
1325 func (*CompositeProperty) Descriptor() ([]byte, []int) {
1326         return fileDescriptor_datastore_v3_83b17b80c34f6179, []int{7}
1327 }
1328 func (m *CompositeProperty) XXX_Unmarshal(b []byte) error {
1329         return xxx_messageInfo_CompositeProperty.Unmarshal(m, b)
1330 }
1331 func (m *CompositeProperty) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
1332         return xxx_messageInfo_CompositeProperty.Marshal(b, m, deterministic)
1333 }
1334 func (dst *CompositeProperty) XXX_Merge(src proto.Message) {
1335         xxx_messageInfo_CompositeProperty.Merge(dst, src)
1336 }
1337 func (m *CompositeProperty) XXX_Size() int {
1338         return xxx_messageInfo_CompositeProperty.Size(m)
1339 }
1340 func (m *CompositeProperty) XXX_DiscardUnknown() {
1341         xxx_messageInfo_CompositeProperty.DiscardUnknown(m)
1342 }
1343
1344 var xxx_messageInfo_CompositeProperty proto.InternalMessageInfo
1345
1346 func (m *CompositeProperty) GetIndexId() int64 {
1347         if m != nil && m.IndexId != nil {
1348                 return *m.IndexId
1349         }
1350         return 0
1351 }
1352
1353 func (m *CompositeProperty) GetValue() []string {
1354         if m != nil {
1355                 return m.Value
1356         }
1357         return nil
1358 }
1359
1360 type Index struct {
1361         EntityType           *string           `protobuf:"bytes,1,req,name=entity_type,json=entityType" json:"entity_type,omitempty"`
1362         Ancestor             *bool             `protobuf:"varint,5,req,name=ancestor" json:"ancestor,omitempty"`
1363         Property             []*Index_Property `protobuf:"group,2,rep,name=Property,json=property" json:"property,omitempty"`
1364         XXX_NoUnkeyedLiteral struct{}          `json:"-"`
1365         XXX_unrecognized     []byte            `json:"-"`
1366         XXX_sizecache        int32             `json:"-"`
1367 }
1368
1369 func (m *Index) Reset()         { *m = Index{} }
1370 func (m *Index) String() string { return proto.CompactTextString(m) }
1371 func (*Index) ProtoMessage()    {}
1372 func (*Index) Descriptor() ([]byte, []int) {
1373         return fileDescriptor_datastore_v3_83b17b80c34f6179, []int{8}
1374 }
1375 func (m *Index) XXX_Unmarshal(b []byte) error {
1376         return xxx_messageInfo_Index.Unmarshal(m, b)
1377 }
1378 func (m *Index) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
1379         return xxx_messageInfo_Index.Marshal(b, m, deterministic)
1380 }
1381 func (dst *Index) XXX_Merge(src proto.Message) {
1382         xxx_messageInfo_Index.Merge(dst, src)
1383 }
1384 func (m *Index) XXX_Size() int {
1385         return xxx_messageInfo_Index.Size(m)
1386 }
1387 func (m *Index) XXX_DiscardUnknown() {
1388         xxx_messageInfo_Index.DiscardUnknown(m)
1389 }
1390
1391 var xxx_messageInfo_Index proto.InternalMessageInfo
1392
1393 func (m *Index) GetEntityType() string {
1394         if m != nil && m.EntityType != nil {
1395                 return *m.EntityType
1396         }
1397         return ""
1398 }
1399
1400 func (m *Index) GetAncestor() bool {
1401         if m != nil && m.Ancestor != nil {
1402                 return *m.Ancestor
1403         }
1404         return false
1405 }
1406
1407 func (m *Index) GetProperty() []*Index_Property {
1408         if m != nil {
1409                 return m.Property
1410         }
1411         return nil
1412 }
1413
1414 type Index_Property struct {
1415         Name                 *string                   `protobuf:"bytes,3,req,name=name" json:"name,omitempty"`
1416         Direction            *Index_Property_Direction `protobuf:"varint,4,opt,name=direction,enum=appengine.Index_Property_Direction,def=1" json:"direction,omitempty"`
1417         XXX_NoUnkeyedLiteral struct{}                  `json:"-"`
1418         XXX_unrecognized     []byte                    `json:"-"`
1419         XXX_sizecache        int32                     `json:"-"`
1420 }
1421
1422 func (m *Index_Property) Reset()         { *m = Index_Property{} }
1423 func (m *Index_Property) String() string { return proto.CompactTextString(m) }
1424 func (*Index_Property) ProtoMessage()    {}
1425 func (*Index_Property) Descriptor() ([]byte, []int) {
1426         return fileDescriptor_datastore_v3_83b17b80c34f6179, []int{8, 0}
1427 }
1428 func (m *Index_Property) XXX_Unmarshal(b []byte) error {
1429         return xxx_messageInfo_Index_Property.Unmarshal(m, b)
1430 }
1431 func (m *Index_Property) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
1432         return xxx_messageInfo_Index_Property.Marshal(b, m, deterministic)
1433 }
1434 func (dst *Index_Property) XXX_Merge(src proto.Message) {
1435         xxx_messageInfo_Index_Property.Merge(dst, src)
1436 }
1437 func (m *Index_Property) XXX_Size() int {
1438         return xxx_messageInfo_Index_Property.Size(m)
1439 }
1440 func (m *Index_Property) XXX_DiscardUnknown() {
1441         xxx_messageInfo_Index_Property.DiscardUnknown(m)
1442 }
1443
1444 var xxx_messageInfo_Index_Property proto.InternalMessageInfo
1445
1446 const Default_Index_Property_Direction Index_Property_Direction = Index_Property_ASCENDING
1447
1448 func (m *Index_Property) GetName() string {
1449         if m != nil && m.Name != nil {
1450                 return *m.Name
1451         }
1452         return ""
1453 }
1454
1455 func (m *Index_Property) GetDirection() Index_Property_Direction {
1456         if m != nil && m.Direction != nil {
1457                 return *m.Direction
1458         }
1459         return Default_Index_Property_Direction
1460 }
1461
1462 type CompositeIndex struct {
1463         AppId                *string               `protobuf:"bytes,1,req,name=app_id,json=appId" json:"app_id,omitempty"`
1464         Id                   *int64                `protobuf:"varint,2,req,name=id" json:"id,omitempty"`
1465         Definition           *Index                `protobuf:"bytes,3,req,name=definition" json:"definition,omitempty"`
1466         State                *CompositeIndex_State `protobuf:"varint,4,req,name=state,enum=appengine.CompositeIndex_State" json:"state,omitempty"`
1467         OnlyUseIfRequired    *bool                 `protobuf:"varint,6,opt,name=only_use_if_required,json=onlyUseIfRequired,def=0" json:"only_use_if_required,omitempty"`
1468         XXX_NoUnkeyedLiteral struct{}              `json:"-"`
1469         XXX_unrecognized     []byte                `json:"-"`
1470         XXX_sizecache        int32                 `json:"-"`
1471 }
1472
1473 func (m *CompositeIndex) Reset()         { *m = CompositeIndex{} }
1474 func (m *CompositeIndex) String() string { return proto.CompactTextString(m) }
1475 func (*CompositeIndex) ProtoMessage()    {}
1476 func (*CompositeIndex) Descriptor() ([]byte, []int) {
1477         return fileDescriptor_datastore_v3_83b17b80c34f6179, []int{9}
1478 }
1479 func (m *CompositeIndex) XXX_Unmarshal(b []byte) error {
1480         return xxx_messageInfo_CompositeIndex.Unmarshal(m, b)
1481 }
1482 func (m *CompositeIndex) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
1483         return xxx_messageInfo_CompositeIndex.Marshal(b, m, deterministic)
1484 }
1485 func (dst *CompositeIndex) XXX_Merge(src proto.Message) {
1486         xxx_messageInfo_CompositeIndex.Merge(dst, src)
1487 }
1488 func (m *CompositeIndex) XXX_Size() int {
1489         return xxx_messageInfo_CompositeIndex.Size(m)
1490 }
1491 func (m *CompositeIndex) XXX_DiscardUnknown() {
1492         xxx_messageInfo_CompositeIndex.DiscardUnknown(m)
1493 }
1494
1495 var xxx_messageInfo_CompositeIndex proto.InternalMessageInfo
1496
1497 const Default_CompositeIndex_OnlyUseIfRequired bool = false
1498
1499 func (m *CompositeIndex) GetAppId() string {
1500         if m != nil && m.AppId != nil {
1501                 return *m.AppId
1502         }
1503         return ""
1504 }
1505
1506 func (m *CompositeIndex) GetId() int64 {
1507         if m != nil && m.Id != nil {
1508                 return *m.Id
1509         }
1510         return 0
1511 }
1512
1513 func (m *CompositeIndex) GetDefinition() *Index {
1514         if m != nil {
1515                 return m.Definition
1516         }
1517         return nil
1518 }
1519
1520 func (m *CompositeIndex) GetState() CompositeIndex_State {
1521         if m != nil && m.State != nil {
1522                 return *m.State
1523         }
1524         return CompositeIndex_WRITE_ONLY
1525 }
1526
1527 func (m *CompositeIndex) GetOnlyUseIfRequired() bool {
1528         if m != nil && m.OnlyUseIfRequired != nil {
1529                 return *m.OnlyUseIfRequired
1530         }
1531         return Default_CompositeIndex_OnlyUseIfRequired
1532 }
1533
1534 type IndexPostfix struct {
1535         IndexValue           []*IndexPostfix_IndexValue `protobuf:"bytes,1,rep,name=index_value,json=indexValue" json:"index_value,omitempty"`
1536         Key                  *Reference                 `protobuf:"bytes,2,opt,name=key" json:"key,omitempty"`
1537         Before               *bool                      `protobuf:"varint,3,opt,name=before,def=1" json:"before,omitempty"`
1538         XXX_NoUnkeyedLiteral struct{}                   `json:"-"`
1539         XXX_unrecognized     []byte                     `json:"-"`
1540         XXX_sizecache        int32                      `json:"-"`
1541 }
1542
1543 func (m *IndexPostfix) Reset()         { *m = IndexPostfix{} }
1544 func (m *IndexPostfix) String() string { return proto.CompactTextString(m) }
1545 func (*IndexPostfix) ProtoMessage()    {}
1546 func (*IndexPostfix) Descriptor() ([]byte, []int) {
1547         return fileDescriptor_datastore_v3_83b17b80c34f6179, []int{10}
1548 }
1549 func (m *IndexPostfix) XXX_Unmarshal(b []byte) error {
1550         return xxx_messageInfo_IndexPostfix.Unmarshal(m, b)
1551 }
1552 func (m *IndexPostfix) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
1553         return xxx_messageInfo_IndexPostfix.Marshal(b, m, deterministic)
1554 }
1555 func (dst *IndexPostfix) XXX_Merge(src proto.Message) {
1556         xxx_messageInfo_IndexPostfix.Merge(dst, src)
1557 }
1558 func (m *IndexPostfix) XXX_Size() int {
1559         return xxx_messageInfo_IndexPostfix.Size(m)
1560 }
1561 func (m *IndexPostfix) XXX_DiscardUnknown() {
1562         xxx_messageInfo_IndexPostfix.DiscardUnknown(m)
1563 }
1564
1565 var xxx_messageInfo_IndexPostfix proto.InternalMessageInfo
1566
1567 const Default_IndexPostfix_Before bool = true
1568
1569 func (m *IndexPostfix) GetIndexValue() []*IndexPostfix_IndexValue {
1570         if m != nil {
1571                 return m.IndexValue
1572         }
1573         return nil
1574 }
1575
1576 func (m *IndexPostfix) GetKey() *Reference {
1577         if m != nil {
1578                 return m.Key
1579         }
1580         return nil
1581 }
1582
1583 func (m *IndexPostfix) GetBefore() bool {
1584         if m != nil && m.Before != nil {
1585                 return *m.Before
1586         }
1587         return Default_IndexPostfix_Before
1588 }
1589
1590 type IndexPostfix_IndexValue struct {
1591         PropertyName         *string        `protobuf:"bytes,1,req,name=property_name,json=propertyName" json:"property_name,omitempty"`
1592         Value                *PropertyValue `protobuf:"bytes,2,req,name=value" json:"value,omitempty"`
1593         XXX_NoUnkeyedLiteral struct{}       `json:"-"`
1594         XXX_unrecognized     []byte         `json:"-"`
1595         XXX_sizecache        int32          `json:"-"`
1596 }
1597
1598 func (m *IndexPostfix_IndexValue) Reset()         { *m = IndexPostfix_IndexValue{} }
1599 func (m *IndexPostfix_IndexValue) String() string { return proto.CompactTextString(m) }
1600 func (*IndexPostfix_IndexValue) ProtoMessage()    {}
1601 func (*IndexPostfix_IndexValue) Descriptor() ([]byte, []int) {
1602         return fileDescriptor_datastore_v3_83b17b80c34f6179, []int{10, 0}
1603 }
1604 func (m *IndexPostfix_IndexValue) XXX_Unmarshal(b []byte) error {
1605         return xxx_messageInfo_IndexPostfix_IndexValue.Unmarshal(m, b)
1606 }
1607 func (m *IndexPostfix_IndexValue) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
1608         return xxx_messageInfo_IndexPostfix_IndexValue.Marshal(b, m, deterministic)
1609 }
1610 func (dst *IndexPostfix_IndexValue) XXX_Merge(src proto.Message) {
1611         xxx_messageInfo_IndexPostfix_IndexValue.Merge(dst, src)
1612 }
1613 func (m *IndexPostfix_IndexValue) XXX_Size() int {
1614         return xxx_messageInfo_IndexPostfix_IndexValue.Size(m)
1615 }
1616 func (m *IndexPostfix_IndexValue) XXX_DiscardUnknown() {
1617         xxx_messageInfo_IndexPostfix_IndexValue.DiscardUnknown(m)
1618 }
1619
1620 var xxx_messageInfo_IndexPostfix_IndexValue proto.InternalMessageInfo
1621
1622 func (m *IndexPostfix_IndexValue) GetPropertyName() string {
1623         if m != nil && m.PropertyName != nil {
1624                 return *m.PropertyName
1625         }
1626         return ""
1627 }
1628
1629 func (m *IndexPostfix_IndexValue) GetValue() *PropertyValue {
1630         if m != nil {
1631                 return m.Value
1632         }
1633         return nil
1634 }
1635
1636 type IndexPosition struct {
1637         Key                  *string  `protobuf:"bytes,1,opt,name=key" json:"key,omitempty"`
1638         Before               *bool    `protobuf:"varint,2,opt,name=before,def=1" json:"before,omitempty"`
1639         XXX_NoUnkeyedLiteral struct{} `json:"-"`
1640         XXX_unrecognized     []byte   `json:"-"`
1641         XXX_sizecache        int32    `json:"-"`
1642 }
1643
1644 func (m *IndexPosition) Reset()         { *m = IndexPosition{} }
1645 func (m *IndexPosition) String() string { return proto.CompactTextString(m) }
1646 func (*IndexPosition) ProtoMessage()    {}
1647 func (*IndexPosition) Descriptor() ([]byte, []int) {
1648         return fileDescriptor_datastore_v3_83b17b80c34f6179, []int{11}
1649 }
1650 func (m *IndexPosition) XXX_Unmarshal(b []byte) error {
1651         return xxx_messageInfo_IndexPosition.Unmarshal(m, b)
1652 }
1653 func (m *IndexPosition) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
1654         return xxx_messageInfo_IndexPosition.Marshal(b, m, deterministic)
1655 }
1656 func (dst *IndexPosition) XXX_Merge(src proto.Message) {
1657         xxx_messageInfo_IndexPosition.Merge(dst, src)
1658 }
1659 func (m *IndexPosition) XXX_Size() int {
1660         return xxx_messageInfo_IndexPosition.Size(m)
1661 }
1662 func (m *IndexPosition) XXX_DiscardUnknown() {
1663         xxx_messageInfo_IndexPosition.DiscardUnknown(m)
1664 }
1665
1666 var xxx_messageInfo_IndexPosition proto.InternalMessageInfo
1667
1668 const Default_IndexPosition_Before bool = true
1669
1670 func (m *IndexPosition) GetKey() string {
1671         if m != nil && m.Key != nil {
1672                 return *m.Key
1673         }
1674         return ""
1675 }
1676
1677 func (m *IndexPosition) GetBefore() bool {
1678         if m != nil && m.Before != nil {
1679                 return *m.Before
1680         }
1681         return Default_IndexPosition_Before
1682 }
1683
1684 type Snapshot struct {
1685         Ts                   *int64   `protobuf:"varint,1,req,name=ts" json:"ts,omitempty"`
1686         XXX_NoUnkeyedLiteral struct{} `json:"-"`
1687         XXX_unrecognized     []byte   `json:"-"`
1688         XXX_sizecache        int32    `json:"-"`
1689 }
1690
1691 func (m *Snapshot) Reset()         { *m = Snapshot{} }
1692 func (m *Snapshot) String() string { return proto.CompactTextString(m) }
1693 func (*Snapshot) ProtoMessage()    {}
1694 func (*Snapshot) Descriptor() ([]byte, []int) {
1695         return fileDescriptor_datastore_v3_83b17b80c34f6179, []int{12}
1696 }
1697 func (m *Snapshot) XXX_Unmarshal(b []byte) error {
1698         return xxx_messageInfo_Snapshot.Unmarshal(m, b)
1699 }
1700 func (m *Snapshot) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
1701         return xxx_messageInfo_Snapshot.Marshal(b, m, deterministic)
1702 }
1703 func (dst *Snapshot) XXX_Merge(src proto.Message) {
1704         xxx_messageInfo_Snapshot.Merge(dst, src)
1705 }
1706 func (m *Snapshot) XXX_Size() int {
1707         return xxx_messageInfo_Snapshot.Size(m)
1708 }
1709 func (m *Snapshot) XXX_DiscardUnknown() {
1710         xxx_messageInfo_Snapshot.DiscardUnknown(m)
1711 }
1712
1713 var xxx_messageInfo_Snapshot proto.InternalMessageInfo
1714
1715 func (m *Snapshot) GetTs() int64 {
1716         if m != nil && m.Ts != nil {
1717                 return *m.Ts
1718         }
1719         return 0
1720 }
1721
1722 type InternalHeader struct {
1723         Qos                  *string  `protobuf:"bytes,1,opt,name=qos" json:"qos,omitempty"`
1724         XXX_NoUnkeyedLiteral struct{} `json:"-"`
1725         XXX_unrecognized     []byte   `json:"-"`
1726         XXX_sizecache        int32    `json:"-"`
1727 }
1728
1729 func (m *InternalHeader) Reset()         { *m = InternalHeader{} }
1730 func (m *InternalHeader) String() string { return proto.CompactTextString(m) }
1731 func (*InternalHeader) ProtoMessage()    {}
1732 func (*InternalHeader) Descriptor() ([]byte, []int) {
1733         return fileDescriptor_datastore_v3_83b17b80c34f6179, []int{13}
1734 }
1735 func (m *InternalHeader) XXX_Unmarshal(b []byte) error {
1736         return xxx_messageInfo_InternalHeader.Unmarshal(m, b)
1737 }
1738 func (m *InternalHeader) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
1739         return xxx_messageInfo_InternalHeader.Marshal(b, m, deterministic)
1740 }
1741 func (dst *InternalHeader) XXX_Merge(src proto.Message) {
1742         xxx_messageInfo_InternalHeader.Merge(dst, src)
1743 }
1744 func (m *InternalHeader) XXX_Size() int {
1745         return xxx_messageInfo_InternalHeader.Size(m)
1746 }
1747 func (m *InternalHeader) XXX_DiscardUnknown() {
1748         xxx_messageInfo_InternalHeader.DiscardUnknown(m)
1749 }
1750
1751 var xxx_messageInfo_InternalHeader proto.InternalMessageInfo
1752
1753 func (m *InternalHeader) GetQos() string {
1754         if m != nil && m.Qos != nil {
1755                 return *m.Qos
1756         }
1757         return ""
1758 }
1759
1760 type Transaction struct {
1761         Header               *InternalHeader `protobuf:"bytes,4,opt,name=header" json:"header,omitempty"`
1762         Handle               *uint64         `protobuf:"fixed64,1,req,name=handle" json:"handle,omitempty"`
1763         App                  *string         `protobuf:"bytes,2,req,name=app" json:"app,omitempty"`
1764         MarkChanges          *bool           `protobuf:"varint,3,opt,name=mark_changes,json=markChanges,def=0" json:"mark_changes,omitempty"`
1765         XXX_NoUnkeyedLiteral struct{}        `json:"-"`
1766         XXX_unrecognized     []byte          `json:"-"`
1767         XXX_sizecache        int32           `json:"-"`
1768 }
1769
1770 func (m *Transaction) Reset()         { *m = Transaction{} }
1771 func (m *Transaction) String() string { return proto.CompactTextString(m) }
1772 func (*Transaction) ProtoMessage()    {}
1773 func (*Transaction) Descriptor() ([]byte, []int) {
1774         return fileDescriptor_datastore_v3_83b17b80c34f6179, []int{14}
1775 }
1776 func (m *Transaction) XXX_Unmarshal(b []byte) error {
1777         return xxx_messageInfo_Transaction.Unmarshal(m, b)
1778 }
1779 func (m *Transaction) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
1780         return xxx_messageInfo_Transaction.Marshal(b, m, deterministic)
1781 }
1782 func (dst *Transaction) XXX_Merge(src proto.Message) {
1783         xxx_messageInfo_Transaction.Merge(dst, src)
1784 }
1785 func (m *Transaction) XXX_Size() int {
1786         return xxx_messageInfo_Transaction.Size(m)
1787 }
1788 func (m *Transaction) XXX_DiscardUnknown() {
1789         xxx_messageInfo_Transaction.DiscardUnknown(m)
1790 }
1791
1792 var xxx_messageInfo_Transaction proto.InternalMessageInfo
1793
1794 const Default_Transaction_MarkChanges bool = false
1795
1796 func (m *Transaction) GetHeader() *InternalHeader {
1797         if m != nil {
1798                 return m.Header
1799         }
1800         return nil
1801 }
1802
1803 func (m *Transaction) GetHandle() uint64 {
1804         if m != nil && m.Handle != nil {
1805                 return *m.Handle
1806         }
1807         return 0
1808 }
1809
1810 func (m *Transaction) GetApp() string {
1811         if m != nil && m.App != nil {
1812                 return *m.App
1813         }
1814         return ""
1815 }
1816
1817 func (m *Transaction) GetMarkChanges() bool {
1818         if m != nil && m.MarkChanges != nil {
1819                 return *m.MarkChanges
1820         }
1821         return Default_Transaction_MarkChanges
1822 }
1823
1824 type Query struct {
1825         Header               *InternalHeader   `protobuf:"bytes,39,opt,name=header" json:"header,omitempty"`
1826         App                  *string           `protobuf:"bytes,1,req,name=app" json:"app,omitempty"`
1827         NameSpace            *string           `protobuf:"bytes,29,opt,name=name_space,json=nameSpace" json:"name_space,omitempty"`
1828         Kind                 *string           `protobuf:"bytes,3,opt,name=kind" json:"kind,omitempty"`
1829         Ancestor             *Reference        `protobuf:"bytes,17,opt,name=ancestor" json:"ancestor,omitempty"`
1830         Filter               []*Query_Filter   `protobuf:"group,4,rep,name=Filter,json=filter" json:"filter,omitempty"`
1831         SearchQuery          *string           `protobuf:"bytes,8,opt,name=search_query,json=searchQuery" json:"search_query,omitempty"`
1832         Order                []*Query_Order    `protobuf:"group,9,rep,name=Order,json=order" json:"order,omitempty"`
1833         Hint                 *Query_Hint       `protobuf:"varint,18,opt,name=hint,enum=appengine.Query_Hint" json:"hint,omitempty"`
1834         Count                *int32            `protobuf:"varint,23,opt,name=count" json:"count,omitempty"`
1835         Offset               *int32            `protobuf:"varint,12,opt,name=offset,def=0" json:"offset,omitempty"`
1836         Limit                *int32            `protobuf:"varint,16,opt,name=limit" json:"limit,omitempty"`
1837         CompiledCursor       *CompiledCursor   `protobuf:"bytes,30,opt,name=compiled_cursor,json=compiledCursor" json:"compiled_cursor,omitempty"`
1838         EndCompiledCursor    *CompiledCursor   `protobuf:"bytes,31,opt,name=end_compiled_cursor,json=endCompiledCursor" json:"end_compiled_cursor,omitempty"`
1839         CompositeIndex       []*CompositeIndex `protobuf:"bytes,19,rep,name=composite_index,json=compositeIndex" json:"composite_index,omitempty"`
1840         RequirePerfectPlan   *bool             `protobuf:"varint,20,opt,name=require_perfect_plan,json=requirePerfectPlan,def=0" json:"require_perfect_plan,omitempty"`
1841         KeysOnly             *bool             `protobuf:"varint,21,opt,name=keys_only,json=keysOnly,def=0" json:"keys_only,omitempty"`
1842         Transaction          *Transaction      `protobuf:"bytes,22,opt,name=transaction" json:"transaction,omitempty"`
1843         Compile              *bool             `protobuf:"varint,25,opt,name=compile,def=0" json:"compile,omitempty"`
1844         FailoverMs           *int64            `protobuf:"varint,26,opt,name=failover_ms,json=failoverMs" json:"failover_ms,omitempty"`
1845         Strong               *bool             `protobuf:"varint,32,opt,name=strong" json:"strong,omitempty"`
1846         PropertyName         []string          `protobuf:"bytes,33,rep,name=property_name,json=propertyName" json:"property_name,omitempty"`
1847         GroupByPropertyName  []string          `protobuf:"bytes,34,rep,name=group_by_property_name,json=groupByPropertyName" json:"group_by_property_name,omitempty"`
1848         Distinct             *bool             `protobuf:"varint,24,opt,name=distinct" json:"distinct,omitempty"`
1849         MinSafeTimeSeconds   *int64            `protobuf:"varint,35,opt,name=min_safe_time_seconds,json=minSafeTimeSeconds" json:"min_safe_time_seconds,omitempty"`
1850         SafeReplicaName      []string          `protobuf:"bytes,36,rep,name=safe_replica_name,json=safeReplicaName" json:"safe_replica_name,omitempty"`
1851         PersistOffset        *bool             `protobuf:"varint,37,opt,name=persist_offset,json=persistOffset,def=0" json:"persist_offset,omitempty"`
1852         XXX_NoUnkeyedLiteral struct{}          `json:"-"`
1853         XXX_unrecognized     []byte            `json:"-"`
1854         XXX_sizecache        int32             `json:"-"`
1855 }
1856
1857 func (m *Query) Reset()         { *m = Query{} }
1858 func (m *Query) String() string { return proto.CompactTextString(m) }
1859 func (*Query) ProtoMessage()    {}
1860 func (*Query) Descriptor() ([]byte, []int) {
1861         return fileDescriptor_datastore_v3_83b17b80c34f6179, []int{15}
1862 }
1863 func (m *Query) XXX_Unmarshal(b []byte) error {
1864         return xxx_messageInfo_Query.Unmarshal(m, b)
1865 }
1866 func (m *Query) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
1867         return xxx_messageInfo_Query.Marshal(b, m, deterministic)
1868 }
1869 func (dst *Query) XXX_Merge(src proto.Message) {
1870         xxx_messageInfo_Query.Merge(dst, src)
1871 }
1872 func (m *Query) XXX_Size() int {
1873         return xxx_messageInfo_Query.Size(m)
1874 }
1875 func (m *Query) XXX_DiscardUnknown() {
1876         xxx_messageInfo_Query.DiscardUnknown(m)
1877 }
1878
1879 var xxx_messageInfo_Query proto.InternalMessageInfo
1880
1881 const Default_Query_Offset int32 = 0
1882 const Default_Query_RequirePerfectPlan bool = false
1883 const Default_Query_KeysOnly bool = false
1884 const Default_Query_Compile bool = false
1885 const Default_Query_PersistOffset bool = false
1886
1887 func (m *Query) GetHeader() *InternalHeader {
1888         if m != nil {
1889                 return m.Header
1890         }
1891         return nil
1892 }
1893
1894 func (m *Query) GetApp() string {
1895         if m != nil && m.App != nil {
1896                 return *m.App
1897         }
1898         return ""
1899 }
1900
1901 func (m *Query) GetNameSpace() string {
1902         if m != nil && m.NameSpace != nil {
1903                 return *m.NameSpace
1904         }
1905         return ""
1906 }
1907
1908 func (m *Query) GetKind() string {
1909         if m != nil && m.Kind != nil {
1910                 return *m.Kind
1911         }
1912         return ""
1913 }
1914
1915 func (m *Query) GetAncestor() *Reference {
1916         if m != nil {
1917                 return m.Ancestor
1918         }
1919         return nil
1920 }
1921
1922 func (m *Query) GetFilter() []*Query_Filter {
1923         if m != nil {
1924                 return m.Filter
1925         }
1926         return nil
1927 }
1928
1929 func (m *Query) GetSearchQuery() string {
1930         if m != nil && m.SearchQuery != nil {
1931                 return *m.SearchQuery
1932         }
1933         return ""
1934 }
1935
1936 func (m *Query) GetOrder() []*Query_Order {
1937         if m != nil {
1938                 return m.Order
1939         }
1940         return nil
1941 }
1942
1943 func (m *Query) GetHint() Query_Hint {
1944         if m != nil && m.Hint != nil {
1945                 return *m.Hint
1946         }
1947         return Query_ORDER_FIRST
1948 }
1949
1950 func (m *Query) GetCount() int32 {
1951         if m != nil && m.Count != nil {
1952                 return *m.Count
1953         }
1954         return 0
1955 }
1956
1957 func (m *Query) GetOffset() int32 {
1958         if m != nil && m.Offset != nil {
1959                 return *m.Offset
1960         }
1961         return Default_Query_Offset
1962 }
1963
1964 func (m *Query) GetLimit() int32 {
1965         if m != nil && m.Limit != nil {
1966                 return *m.Limit
1967         }
1968         return 0
1969 }
1970
1971 func (m *Query) GetCompiledCursor() *CompiledCursor {
1972         if m != nil {
1973                 return m.CompiledCursor
1974         }
1975         return nil
1976 }
1977
1978 func (m *Query) GetEndCompiledCursor() *CompiledCursor {
1979         if m != nil {
1980                 return m.EndCompiledCursor
1981         }
1982         return nil
1983 }
1984
1985 func (m *Query) GetCompositeIndex() []*CompositeIndex {
1986         if m != nil {
1987                 return m.CompositeIndex
1988         }
1989         return nil
1990 }
1991
1992 func (m *Query) GetRequirePerfectPlan() bool {
1993         if m != nil && m.RequirePerfectPlan != nil {
1994                 return *m.RequirePerfectPlan
1995         }
1996         return Default_Query_RequirePerfectPlan
1997 }
1998
1999 func (m *Query) GetKeysOnly() bool {
2000         if m != nil && m.KeysOnly != nil {
2001                 return *m.KeysOnly
2002         }
2003         return Default_Query_KeysOnly
2004 }
2005
2006 func (m *Query) GetTransaction() *Transaction {
2007         if m != nil {
2008                 return m.Transaction
2009         }
2010         return nil
2011 }
2012
2013 func (m *Query) GetCompile() bool {
2014         if m != nil && m.Compile != nil {
2015                 return *m.Compile
2016         }
2017         return Default_Query_Compile
2018 }
2019
2020 func (m *Query) GetFailoverMs() int64 {
2021         if m != nil && m.FailoverMs != nil {
2022                 return *m.FailoverMs
2023         }
2024         return 0
2025 }
2026
2027 func (m *Query) GetStrong() bool {
2028         if m != nil && m.Strong != nil {
2029                 return *m.Strong
2030         }
2031         return false
2032 }
2033
2034 func (m *Query) GetPropertyName() []string {
2035         if m != nil {
2036                 return m.PropertyName
2037         }
2038         return nil
2039 }
2040
2041 func (m *Query) GetGroupByPropertyName() []string {
2042         if m != nil {
2043                 return m.GroupByPropertyName
2044         }
2045         return nil
2046 }
2047
2048 func (m *Query) GetDistinct() bool {
2049         if m != nil && m.Distinct != nil {
2050                 return *m.Distinct
2051         }
2052         return false
2053 }
2054
2055 func (m *Query) GetMinSafeTimeSeconds() int64 {
2056         if m != nil && m.MinSafeTimeSeconds != nil {
2057                 return *m.MinSafeTimeSeconds
2058         }
2059         return 0
2060 }
2061
2062 func (m *Query) GetSafeReplicaName() []string {
2063         if m != nil {
2064                 return m.SafeReplicaName
2065         }
2066         return nil
2067 }
2068
2069 func (m *Query) GetPersistOffset() bool {
2070         if m != nil && m.PersistOffset != nil {
2071                 return *m.PersistOffset
2072         }
2073         return Default_Query_PersistOffset
2074 }
2075
2076 type Query_Filter struct {
2077         Op                   *Query_Filter_Operator `protobuf:"varint,6,req,name=op,enum=appengine.Query_Filter_Operator" json:"op,omitempty"`
2078         Property             []*Property            `protobuf:"bytes,14,rep,name=property" json:"property,omitempty"`
2079         XXX_NoUnkeyedLiteral struct{}               `json:"-"`
2080         XXX_unrecognized     []byte                 `json:"-"`
2081         XXX_sizecache        int32                  `json:"-"`
2082 }
2083
2084 func (m *Query_Filter) Reset()         { *m = Query_Filter{} }
2085 func (m *Query_Filter) String() string { return proto.CompactTextString(m) }
2086 func (*Query_Filter) ProtoMessage()    {}
2087 func (*Query_Filter) Descriptor() ([]byte, []int) {
2088         return fileDescriptor_datastore_v3_83b17b80c34f6179, []int{15, 0}
2089 }
2090 func (m *Query_Filter) XXX_Unmarshal(b []byte) error {
2091         return xxx_messageInfo_Query_Filter.Unmarshal(m, b)
2092 }
2093 func (m *Query_Filter) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
2094         return xxx_messageInfo_Query_Filter.Marshal(b, m, deterministic)
2095 }
2096 func (dst *Query_Filter) XXX_Merge(src proto.Message) {
2097         xxx_messageInfo_Query_Filter.Merge(dst, src)
2098 }
2099 func (m *Query_Filter) XXX_Size() int {
2100         return xxx_messageInfo_Query_Filter.Size(m)
2101 }
2102 func (m *Query_Filter) XXX_DiscardUnknown() {
2103         xxx_messageInfo_Query_Filter.DiscardUnknown(m)
2104 }
2105
2106 var xxx_messageInfo_Query_Filter proto.InternalMessageInfo
2107
2108 func (m *Query_Filter) GetOp() Query_Filter_Operator {
2109         if m != nil && m.Op != nil {
2110                 return *m.Op
2111         }
2112         return Query_Filter_LESS_THAN
2113 }
2114
2115 func (m *Query_Filter) GetProperty() []*Property {
2116         if m != nil {
2117                 return m.Property
2118         }
2119         return nil
2120 }
2121
2122 type Query_Order struct {
2123         Property             *string                `protobuf:"bytes,10,req,name=property" json:"property,omitempty"`
2124         Direction            *Query_Order_Direction `protobuf:"varint,11,opt,name=direction,enum=appengine.Query_Order_Direction,def=1" json:"direction,omitempty"`
2125         XXX_NoUnkeyedLiteral struct{}               `json:"-"`
2126         XXX_unrecognized     []byte                 `json:"-"`
2127         XXX_sizecache        int32                  `json:"-"`
2128 }
2129
2130 func (m *Query_Order) Reset()         { *m = Query_Order{} }
2131 func (m *Query_Order) String() string { return proto.CompactTextString(m) }
2132 func (*Query_Order) ProtoMessage()    {}
2133 func (*Query_Order) Descriptor() ([]byte, []int) {
2134         return fileDescriptor_datastore_v3_83b17b80c34f6179, []int{15, 1}
2135 }
2136 func (m *Query_Order) XXX_Unmarshal(b []byte) error {
2137         return xxx_messageInfo_Query_Order.Unmarshal(m, b)
2138 }
2139 func (m *Query_Order) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
2140         return xxx_messageInfo_Query_Order.Marshal(b, m, deterministic)
2141 }
2142 func (dst *Query_Order) XXX_Merge(src proto.Message) {
2143         xxx_messageInfo_Query_Order.Merge(dst, src)
2144 }
2145 func (m *Query_Order) XXX_Size() int {
2146         return xxx_messageInfo_Query_Order.Size(m)
2147 }
2148 func (m *Query_Order) XXX_DiscardUnknown() {
2149         xxx_messageInfo_Query_Order.DiscardUnknown(m)
2150 }
2151
2152 var xxx_messageInfo_Query_Order proto.InternalMessageInfo
2153
2154 const Default_Query_Order_Direction Query_Order_Direction = Query_Order_ASCENDING
2155
2156 func (m *Query_Order) GetProperty() string {
2157         if m != nil && m.Property != nil {
2158                 return *m.Property
2159         }
2160         return ""
2161 }
2162
2163 func (m *Query_Order) GetDirection() Query_Order_Direction {
2164         if m != nil && m.Direction != nil {
2165                 return *m.Direction
2166         }
2167         return Default_Query_Order_Direction
2168 }
2169
2170 type CompiledQuery struct {
2171         Primaryscan          *CompiledQuery_PrimaryScan     `protobuf:"group,1,req,name=PrimaryScan,json=primaryscan" json:"primaryscan,omitempty"`
2172         Mergejoinscan        []*CompiledQuery_MergeJoinScan `protobuf:"group,7,rep,name=MergeJoinScan,json=mergejoinscan" json:"mergejoinscan,omitempty"`
2173         IndexDef             *Index                         `protobuf:"bytes,21,opt,name=index_def,json=indexDef" json:"index_def,omitempty"`
2174         Offset               *int32                         `protobuf:"varint,10,opt,name=offset,def=0" json:"offset,omitempty"`
2175         Limit                *int32                         `protobuf:"varint,11,opt,name=limit" json:"limit,omitempty"`
2176         KeysOnly             *bool                          `protobuf:"varint,12,req,name=keys_only,json=keysOnly" json:"keys_only,omitempty"`
2177         PropertyName         []string                       `protobuf:"bytes,24,rep,name=property_name,json=propertyName" json:"property_name,omitempty"`
2178         DistinctInfixSize    *int32                         `protobuf:"varint,25,opt,name=distinct_infix_size,json=distinctInfixSize" json:"distinct_infix_size,omitempty"`
2179         Entityfilter         *CompiledQuery_EntityFilter    `protobuf:"group,13,opt,name=EntityFilter,json=entityfilter" json:"entityfilter,omitempty"`
2180         XXX_NoUnkeyedLiteral struct{}                       `json:"-"`
2181         XXX_unrecognized     []byte                         `json:"-"`
2182         XXX_sizecache        int32                          `json:"-"`
2183 }
2184
2185 func (m *CompiledQuery) Reset()         { *m = CompiledQuery{} }
2186 func (m *CompiledQuery) String() string { return proto.CompactTextString(m) }
2187 func (*CompiledQuery) ProtoMessage()    {}
2188 func (*CompiledQuery) Descriptor() ([]byte, []int) {
2189         return fileDescriptor_datastore_v3_83b17b80c34f6179, []int{16}
2190 }
2191 func (m *CompiledQuery) XXX_Unmarshal(b []byte) error {
2192         return xxx_messageInfo_CompiledQuery.Unmarshal(m, b)
2193 }
2194 func (m *CompiledQuery) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
2195         return xxx_messageInfo_CompiledQuery.Marshal(b, m, deterministic)
2196 }
2197 func (dst *CompiledQuery) XXX_Merge(src proto.Message) {
2198         xxx_messageInfo_CompiledQuery.Merge(dst, src)
2199 }
2200 func (m *CompiledQuery) XXX_Size() int {
2201         return xxx_messageInfo_CompiledQuery.Size(m)
2202 }
2203 func (m *CompiledQuery) XXX_DiscardUnknown() {
2204         xxx_messageInfo_CompiledQuery.DiscardUnknown(m)
2205 }
2206
2207 var xxx_messageInfo_CompiledQuery proto.InternalMessageInfo
2208
2209 const Default_CompiledQuery_Offset int32 = 0
2210
2211 func (m *CompiledQuery) GetPrimaryscan() *CompiledQuery_PrimaryScan {
2212         if m != nil {
2213                 return m.Primaryscan
2214         }
2215         return nil
2216 }
2217
2218 func (m *CompiledQuery) GetMergejoinscan() []*CompiledQuery_MergeJoinScan {
2219         if m != nil {
2220                 return m.Mergejoinscan
2221         }
2222         return nil
2223 }
2224
2225 func (m *CompiledQuery) GetIndexDef() *Index {
2226         if m != nil {
2227                 return m.IndexDef
2228         }
2229         return nil
2230 }
2231
2232 func (m *CompiledQuery) GetOffset() int32 {
2233         if m != nil && m.Offset != nil {
2234                 return *m.Offset
2235         }
2236         return Default_CompiledQuery_Offset
2237 }
2238
2239 func (m *CompiledQuery) GetLimit() int32 {
2240         if m != nil && m.Limit != nil {
2241                 return *m.Limit
2242         }
2243         return 0
2244 }
2245
2246 func (m *CompiledQuery) GetKeysOnly() bool {
2247         if m != nil && m.KeysOnly != nil {
2248                 return *m.KeysOnly
2249         }
2250         return false
2251 }
2252
2253 func (m *CompiledQuery) GetPropertyName() []string {
2254         if m != nil {
2255                 return m.PropertyName
2256         }
2257         return nil
2258 }
2259
2260 func (m *CompiledQuery) GetDistinctInfixSize() int32 {
2261         if m != nil && m.DistinctInfixSize != nil {
2262                 return *m.DistinctInfixSize
2263         }
2264         return 0
2265 }
2266
2267 func (m *CompiledQuery) GetEntityfilter() *CompiledQuery_EntityFilter {
2268         if m != nil {
2269                 return m.Entityfilter
2270         }
2271         return nil
2272 }
2273
2274 type CompiledQuery_PrimaryScan struct {
2275         IndexName                  *string  `protobuf:"bytes,2,opt,name=index_name,json=indexName" json:"index_name,omitempty"`
2276         StartKey                   *string  `protobuf:"bytes,3,opt,name=start_key,json=startKey" json:"start_key,omitempty"`
2277         StartInclusive             *bool    `protobuf:"varint,4,opt,name=start_inclusive,json=startInclusive" json:"start_inclusive,omitempty"`
2278         EndKey                     *string  `protobuf:"bytes,5,opt,name=end_key,json=endKey" json:"end_key,omitempty"`
2279         EndInclusive               *bool    `protobuf:"varint,6,opt,name=end_inclusive,json=endInclusive" json:"end_inclusive,omitempty"`
2280         StartPostfixValue          []string `protobuf:"bytes,22,rep,name=start_postfix_value,json=startPostfixValue" json:"start_postfix_value,omitempty"`
2281         EndPostfixValue            []string `protobuf:"bytes,23,rep,name=end_postfix_value,json=endPostfixValue" json:"end_postfix_value,omitempty"`
2282         EndUnappliedLogTimestampUs *int64   `protobuf:"varint,19,opt,name=end_unapplied_log_timestamp_us,json=endUnappliedLogTimestampUs" json:"end_unapplied_log_timestamp_us,omitempty"`
2283         XXX_NoUnkeyedLiteral       struct{} `json:"-"`
2284         XXX_unrecognized           []byte   `json:"-"`
2285         XXX_sizecache              int32    `json:"-"`
2286 }
2287
2288 func (m *CompiledQuery_PrimaryScan) Reset()         { *m = CompiledQuery_PrimaryScan{} }
2289 func (m *CompiledQuery_PrimaryScan) String() string { return proto.CompactTextString(m) }
2290 func (*CompiledQuery_PrimaryScan) ProtoMessage()    {}
2291 func (*CompiledQuery_PrimaryScan) Descriptor() ([]byte, []int) {
2292         return fileDescriptor_datastore_v3_83b17b80c34f6179, []int{16, 0}
2293 }
2294 func (m *CompiledQuery_PrimaryScan) XXX_Unmarshal(b []byte) error {
2295         return xxx_messageInfo_CompiledQuery_PrimaryScan.Unmarshal(m, b)
2296 }
2297 func (m *CompiledQuery_PrimaryScan) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
2298         return xxx_messageInfo_CompiledQuery_PrimaryScan.Marshal(b, m, deterministic)
2299 }
2300 func (dst *CompiledQuery_PrimaryScan) XXX_Merge(src proto.Message) {
2301         xxx_messageInfo_CompiledQuery_PrimaryScan.Merge(dst, src)
2302 }
2303 func (m *CompiledQuery_PrimaryScan) XXX_Size() int {
2304         return xxx_messageInfo_CompiledQuery_PrimaryScan.Size(m)
2305 }
2306 func (m *CompiledQuery_PrimaryScan) XXX_DiscardUnknown() {
2307         xxx_messageInfo_CompiledQuery_PrimaryScan.DiscardUnknown(m)
2308 }
2309
2310 var xxx_messageInfo_CompiledQuery_PrimaryScan proto.InternalMessageInfo
2311
2312 func (m *CompiledQuery_PrimaryScan) GetIndexName() string {
2313         if m != nil && m.IndexName != nil {
2314                 return *m.IndexName
2315         }
2316         return ""
2317 }
2318
2319 func (m *CompiledQuery_PrimaryScan) GetStartKey() string {
2320         if m != nil && m.StartKey != nil {
2321                 return *m.StartKey
2322         }
2323         return ""
2324 }
2325
2326 func (m *CompiledQuery_PrimaryScan) GetStartInclusive() bool {
2327         if m != nil && m.StartInclusive != nil {
2328                 return *m.StartInclusive
2329         }
2330         return false
2331 }
2332
2333 func (m *CompiledQuery_PrimaryScan) GetEndKey() string {
2334         if m != nil && m.EndKey != nil {
2335                 return *m.EndKey
2336         }
2337         return ""
2338 }
2339
2340 func (m *CompiledQuery_PrimaryScan) GetEndInclusive() bool {
2341         if m != nil && m.EndInclusive != nil {
2342                 return *m.EndInclusive
2343         }
2344         return false
2345 }
2346
2347 func (m *CompiledQuery_PrimaryScan) GetStartPostfixValue() []string {
2348         if m != nil {
2349                 return m.StartPostfixValue
2350         }
2351         return nil
2352 }
2353
2354 func (m *CompiledQuery_PrimaryScan) GetEndPostfixValue() []string {
2355         if m != nil {
2356                 return m.EndPostfixValue
2357         }
2358         return nil
2359 }
2360
2361 func (m *CompiledQuery_PrimaryScan) GetEndUnappliedLogTimestampUs() int64 {
2362         if m != nil && m.EndUnappliedLogTimestampUs != nil {
2363                 return *m.EndUnappliedLogTimestampUs
2364         }
2365         return 0
2366 }
2367
2368 type CompiledQuery_MergeJoinScan struct {
2369         IndexName            *string  `protobuf:"bytes,8,req,name=index_name,json=indexName" json:"index_name,omitempty"`
2370         PrefixValue          []string `protobuf:"bytes,9,rep,name=prefix_value,json=prefixValue" json:"prefix_value,omitempty"`
2371         ValuePrefix          *bool    `protobuf:"varint,20,opt,name=value_prefix,json=valuePrefix,def=0" json:"value_prefix,omitempty"`
2372         XXX_NoUnkeyedLiteral struct{} `json:"-"`
2373         XXX_unrecognized     []byte   `json:"-"`
2374         XXX_sizecache        int32    `json:"-"`
2375 }
2376
2377 func (m *CompiledQuery_MergeJoinScan) Reset()         { *m = CompiledQuery_MergeJoinScan{} }
2378 func (m *CompiledQuery_MergeJoinScan) String() string { return proto.CompactTextString(m) }
2379 func (*CompiledQuery_MergeJoinScan) ProtoMessage()    {}
2380 func (*CompiledQuery_MergeJoinScan) Descriptor() ([]byte, []int) {
2381         return fileDescriptor_datastore_v3_83b17b80c34f6179, []int{16, 1}
2382 }
2383 func (m *CompiledQuery_MergeJoinScan) XXX_Unmarshal(b []byte) error {
2384         return xxx_messageInfo_CompiledQuery_MergeJoinScan.Unmarshal(m, b)
2385 }
2386 func (m *CompiledQuery_MergeJoinScan) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
2387         return xxx_messageInfo_CompiledQuery_MergeJoinScan.Marshal(b, m, deterministic)
2388 }
2389 func (dst *CompiledQuery_MergeJoinScan) XXX_Merge(src proto.Message) {
2390         xxx_messageInfo_CompiledQuery_MergeJoinScan.Merge(dst, src)
2391 }
2392 func (m *CompiledQuery_MergeJoinScan) XXX_Size() int {
2393         return xxx_messageInfo_CompiledQuery_MergeJoinScan.Size(m)
2394 }
2395 func (m *CompiledQuery_MergeJoinScan) XXX_DiscardUnknown() {
2396         xxx_messageInfo_CompiledQuery_MergeJoinScan.DiscardUnknown(m)
2397 }
2398
2399 var xxx_messageInfo_CompiledQuery_MergeJoinScan proto.InternalMessageInfo
2400
2401 const Default_CompiledQuery_MergeJoinScan_ValuePrefix bool = false
2402
2403 func (m *CompiledQuery_MergeJoinScan) GetIndexName() string {
2404         if m != nil && m.IndexName != nil {
2405                 return *m.IndexName
2406         }
2407         return ""
2408 }
2409
2410 func (m *CompiledQuery_MergeJoinScan) GetPrefixValue() []string {
2411         if m != nil {
2412                 return m.PrefixValue
2413         }
2414         return nil
2415 }
2416
2417 func (m *CompiledQuery_MergeJoinScan) GetValuePrefix() bool {
2418         if m != nil && m.ValuePrefix != nil {
2419                 return *m.ValuePrefix
2420         }
2421         return Default_CompiledQuery_MergeJoinScan_ValuePrefix
2422 }
2423
2424 type CompiledQuery_EntityFilter struct {
2425         Distinct             *bool      `protobuf:"varint,14,opt,name=distinct,def=0" json:"distinct,omitempty"`
2426         Kind                 *string    `protobuf:"bytes,17,opt,name=kind" json:"kind,omitempty"`
2427         Ancestor             *Reference `protobuf:"bytes,18,opt,name=ancestor" json:"ancestor,omitempty"`
2428         XXX_NoUnkeyedLiteral struct{}   `json:"-"`
2429         XXX_unrecognized     []byte     `json:"-"`
2430         XXX_sizecache        int32      `json:"-"`
2431 }
2432
2433 func (m *CompiledQuery_EntityFilter) Reset()         { *m = CompiledQuery_EntityFilter{} }
2434 func (m *CompiledQuery_EntityFilter) String() string { return proto.CompactTextString(m) }
2435 func (*CompiledQuery_EntityFilter) ProtoMessage()    {}
2436 func (*CompiledQuery_EntityFilter) Descriptor() ([]byte, []int) {
2437         return fileDescriptor_datastore_v3_83b17b80c34f6179, []int{16, 2}
2438 }
2439 func (m *CompiledQuery_EntityFilter) XXX_Unmarshal(b []byte) error {
2440         return xxx_messageInfo_CompiledQuery_EntityFilter.Unmarshal(m, b)
2441 }
2442 func (m *CompiledQuery_EntityFilter) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
2443         return xxx_messageInfo_CompiledQuery_EntityFilter.Marshal(b, m, deterministic)
2444 }
2445 func (dst *CompiledQuery_EntityFilter) XXX_Merge(src proto.Message) {
2446         xxx_messageInfo_CompiledQuery_EntityFilter.Merge(dst, src)
2447 }
2448 func (m *CompiledQuery_EntityFilter) XXX_Size() int {
2449         return xxx_messageInfo_CompiledQuery_EntityFilter.Size(m)
2450 }
2451 func (m *CompiledQuery_EntityFilter) XXX_DiscardUnknown() {
2452         xxx_messageInfo_CompiledQuery_EntityFilter.DiscardUnknown(m)
2453 }
2454
2455 var xxx_messageInfo_CompiledQuery_EntityFilter proto.InternalMessageInfo
2456
2457 const Default_CompiledQuery_EntityFilter_Distinct bool = false
2458
2459 func (m *CompiledQuery_EntityFilter) GetDistinct() bool {
2460         if m != nil && m.Distinct != nil {
2461                 return *m.Distinct
2462         }
2463         return Default_CompiledQuery_EntityFilter_Distinct
2464 }
2465
2466 func (m *CompiledQuery_EntityFilter) GetKind() string {
2467         if m != nil && m.Kind != nil {
2468                 return *m.Kind
2469         }
2470         return ""
2471 }
2472
2473 func (m *CompiledQuery_EntityFilter) GetAncestor() *Reference {
2474         if m != nil {
2475                 return m.Ancestor
2476         }
2477         return nil
2478 }
2479
2480 type CompiledCursor struct {
2481         Position             *CompiledCursor_Position `protobuf:"group,2,opt,name=Position,json=position" json:"position,omitempty"`
2482         XXX_NoUnkeyedLiteral struct{}                 `json:"-"`
2483         XXX_unrecognized     []byte                   `json:"-"`
2484         XXX_sizecache        int32                    `json:"-"`
2485 }
2486
2487 func (m *CompiledCursor) Reset()         { *m = CompiledCursor{} }
2488 func (m *CompiledCursor) String() string { return proto.CompactTextString(m) }
2489 func (*CompiledCursor) ProtoMessage()    {}
2490 func (*CompiledCursor) Descriptor() ([]byte, []int) {
2491         return fileDescriptor_datastore_v3_83b17b80c34f6179, []int{17}
2492 }
2493 func (m *CompiledCursor) XXX_Unmarshal(b []byte) error {
2494         return xxx_messageInfo_CompiledCursor.Unmarshal(m, b)
2495 }
2496 func (m *CompiledCursor) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
2497         return xxx_messageInfo_CompiledCursor.Marshal(b, m, deterministic)
2498 }
2499 func (dst *CompiledCursor) XXX_Merge(src proto.Message) {
2500         xxx_messageInfo_CompiledCursor.Merge(dst, src)
2501 }
2502 func (m *CompiledCursor) XXX_Size() int {
2503         return xxx_messageInfo_CompiledCursor.Size(m)
2504 }
2505 func (m *CompiledCursor) XXX_DiscardUnknown() {
2506         xxx_messageInfo_CompiledCursor.DiscardUnknown(m)
2507 }
2508
2509 var xxx_messageInfo_CompiledCursor proto.InternalMessageInfo
2510
2511 func (m *CompiledCursor) GetPosition() *CompiledCursor_Position {
2512         if m != nil {
2513                 return m.Position
2514         }
2515         return nil
2516 }
2517
2518 type CompiledCursor_Position struct {
2519         StartKey             *string                               `protobuf:"bytes,27,opt,name=start_key,json=startKey" json:"start_key,omitempty"`
2520         Indexvalue           []*CompiledCursor_Position_IndexValue `protobuf:"group,29,rep,name=IndexValue,json=indexvalue" json:"indexvalue,omitempty"`
2521         Key                  *Reference                            `protobuf:"bytes,32,opt,name=key" json:"key,omitempty"`
2522         StartInclusive       *bool                                 `protobuf:"varint,28,opt,name=start_inclusive,json=startInclusive,def=1" json:"start_inclusive,omitempty"`
2523         XXX_NoUnkeyedLiteral struct{}                              `json:"-"`
2524         XXX_unrecognized     []byte                                `json:"-"`
2525         XXX_sizecache        int32                                 `json:"-"`
2526 }
2527
2528 func (m *CompiledCursor_Position) Reset()         { *m = CompiledCursor_Position{} }
2529 func (m *CompiledCursor_Position) String() string { return proto.CompactTextString(m) }
2530 func (*CompiledCursor_Position) ProtoMessage()    {}
2531 func (*CompiledCursor_Position) Descriptor() ([]byte, []int) {
2532         return fileDescriptor_datastore_v3_83b17b80c34f6179, []int{17, 0}
2533 }
2534 func (m *CompiledCursor_Position) XXX_Unmarshal(b []byte) error {
2535         return xxx_messageInfo_CompiledCursor_Position.Unmarshal(m, b)
2536 }
2537 func (m *CompiledCursor_Position) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
2538         return xxx_messageInfo_CompiledCursor_Position.Marshal(b, m, deterministic)
2539 }
2540 func (dst *CompiledCursor_Position) XXX_Merge(src proto.Message) {
2541         xxx_messageInfo_CompiledCursor_Position.Merge(dst, src)
2542 }
2543 func (m *CompiledCursor_Position) XXX_Size() int {
2544         return xxx_messageInfo_CompiledCursor_Position.Size(m)
2545 }
2546 func (m *CompiledCursor_Position) XXX_DiscardUnknown() {
2547         xxx_messageInfo_CompiledCursor_Position.DiscardUnknown(m)
2548 }
2549
2550 var xxx_messageInfo_CompiledCursor_Position proto.InternalMessageInfo
2551
2552 const Default_CompiledCursor_Position_StartInclusive bool = true
2553
2554 func (m *CompiledCursor_Position) GetStartKey() string {
2555         if m != nil && m.StartKey != nil {
2556                 return *m.StartKey
2557         }
2558         return ""
2559 }
2560
2561 func (m *CompiledCursor_Position) GetIndexvalue() []*CompiledCursor_Position_IndexValue {
2562         if m != nil {
2563                 return m.Indexvalue
2564         }
2565         return nil
2566 }
2567
2568 func (m *CompiledCursor_Position) GetKey() *Reference {
2569         if m != nil {
2570                 return m.Key
2571         }
2572         return nil
2573 }
2574
2575 func (m *CompiledCursor_Position) GetStartInclusive() bool {
2576         if m != nil && m.StartInclusive != nil {
2577                 return *m.StartInclusive
2578         }
2579         return Default_CompiledCursor_Position_StartInclusive
2580 }
2581
2582 type CompiledCursor_Position_IndexValue struct {
2583         Property             *string        `protobuf:"bytes,30,opt,name=property" json:"property,omitempty"`
2584         Value                *PropertyValue `protobuf:"bytes,31,req,name=value" json:"value,omitempty"`
2585         XXX_NoUnkeyedLiteral struct{}       `json:"-"`
2586         XXX_unrecognized     []byte         `json:"-"`
2587         XXX_sizecache        int32          `json:"-"`
2588 }
2589
2590 func (m *CompiledCursor_Position_IndexValue) Reset()         { *m = CompiledCursor_Position_IndexValue{} }
2591 func (m *CompiledCursor_Position_IndexValue) String() string { return proto.CompactTextString(m) }
2592 func (*CompiledCursor_Position_IndexValue) ProtoMessage()    {}
2593 func (*CompiledCursor_Position_IndexValue) Descriptor() ([]byte, []int) {
2594         return fileDescriptor_datastore_v3_83b17b80c34f6179, []int{17, 0, 0}
2595 }
2596 func (m *CompiledCursor_Position_IndexValue) XXX_Unmarshal(b []byte) error {
2597         return xxx_messageInfo_CompiledCursor_Position_IndexValue.Unmarshal(m, b)
2598 }
2599 func (m *CompiledCursor_Position_IndexValue) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
2600         return xxx_messageInfo_CompiledCursor_Position_IndexValue.Marshal(b, m, deterministic)
2601 }
2602 func (dst *CompiledCursor_Position_IndexValue) XXX_Merge(src proto.Message) {
2603         xxx_messageInfo_CompiledCursor_Position_IndexValue.Merge(dst, src)
2604 }
2605 func (m *CompiledCursor_Position_IndexValue) XXX_Size() int {
2606         return xxx_messageInfo_CompiledCursor_Position_IndexValue.Size(m)
2607 }
2608 func (m *CompiledCursor_Position_IndexValue) XXX_DiscardUnknown() {
2609         xxx_messageInfo_CompiledCursor_Position_IndexValue.DiscardUnknown(m)
2610 }
2611
2612 var xxx_messageInfo_CompiledCursor_Position_IndexValue proto.InternalMessageInfo
2613
2614 func (m *CompiledCursor_Position_IndexValue) GetProperty() string {
2615         if m != nil && m.Property != nil {
2616                 return *m.Property
2617         }
2618         return ""
2619 }
2620
2621 func (m *CompiledCursor_Position_IndexValue) GetValue() *PropertyValue {
2622         if m != nil {
2623                 return m.Value
2624         }
2625         return nil
2626 }
2627
2628 type Cursor struct {
2629         Cursor               *uint64  `protobuf:"fixed64,1,req,name=cursor" json:"cursor,omitempty"`
2630         App                  *string  `protobuf:"bytes,2,opt,name=app" json:"app,omitempty"`
2631         XXX_NoUnkeyedLiteral struct{} `json:"-"`
2632         XXX_unrecognized     []byte   `json:"-"`
2633         XXX_sizecache        int32    `json:"-"`
2634 }
2635
2636 func (m *Cursor) Reset()         { *m = Cursor{} }
2637 func (m *Cursor) String() string { return proto.CompactTextString(m) }
2638 func (*Cursor) ProtoMessage()    {}
2639 func (*Cursor) Descriptor() ([]byte, []int) {
2640         return fileDescriptor_datastore_v3_83b17b80c34f6179, []int{18}
2641 }
2642 func (m *Cursor) XXX_Unmarshal(b []byte) error {
2643         return xxx_messageInfo_Cursor.Unmarshal(m, b)
2644 }
2645 func (m *Cursor) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
2646         return xxx_messageInfo_Cursor.Marshal(b, m, deterministic)
2647 }
2648 func (dst *Cursor) XXX_Merge(src proto.Message) {
2649         xxx_messageInfo_Cursor.Merge(dst, src)
2650 }
2651 func (m *Cursor) XXX_Size() int {
2652         return xxx_messageInfo_Cursor.Size(m)
2653 }
2654 func (m *Cursor) XXX_DiscardUnknown() {
2655         xxx_messageInfo_Cursor.DiscardUnknown(m)
2656 }
2657
2658 var xxx_messageInfo_Cursor proto.InternalMessageInfo
2659
2660 func (m *Cursor) GetCursor() uint64 {
2661         if m != nil && m.Cursor != nil {
2662                 return *m.Cursor
2663         }
2664         return 0
2665 }
2666
2667 func (m *Cursor) GetApp() string {
2668         if m != nil && m.App != nil {
2669                 return *m.App
2670         }
2671         return ""
2672 }
2673
2674 type Error struct {
2675         XXX_NoUnkeyedLiteral struct{} `json:"-"`
2676         XXX_unrecognized     []byte   `json:"-"`
2677         XXX_sizecache        int32    `json:"-"`
2678 }
2679
2680 func (m *Error) Reset()         { *m = Error{} }
2681 func (m *Error) String() string { return proto.CompactTextString(m) }
2682 func (*Error) ProtoMessage()    {}
2683 func (*Error) Descriptor() ([]byte, []int) {
2684         return fileDescriptor_datastore_v3_83b17b80c34f6179, []int{19}
2685 }
2686 func (m *Error) XXX_Unmarshal(b []byte) error {
2687         return xxx_messageInfo_Error.Unmarshal(m, b)
2688 }
2689 func (m *Error) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
2690         return xxx_messageInfo_Error.Marshal(b, m, deterministic)
2691 }
2692 func (dst *Error) XXX_Merge(src proto.Message) {
2693         xxx_messageInfo_Error.Merge(dst, src)
2694 }
2695 func (m *Error) XXX_Size() int {
2696         return xxx_messageInfo_Error.Size(m)
2697 }
2698 func (m *Error) XXX_DiscardUnknown() {
2699         xxx_messageInfo_Error.DiscardUnknown(m)
2700 }
2701
2702 var xxx_messageInfo_Error proto.InternalMessageInfo
2703
2704 type Cost struct {
2705         IndexWrites             *int32           `protobuf:"varint,1,opt,name=index_writes,json=indexWrites" json:"index_writes,omitempty"`
2706         IndexWriteBytes         *int32           `protobuf:"varint,2,opt,name=index_write_bytes,json=indexWriteBytes" json:"index_write_bytes,omitempty"`
2707         EntityWrites            *int32           `protobuf:"varint,3,opt,name=entity_writes,json=entityWrites" json:"entity_writes,omitempty"`
2708         EntityWriteBytes        *int32           `protobuf:"varint,4,opt,name=entity_write_bytes,json=entityWriteBytes" json:"entity_write_bytes,omitempty"`
2709         Commitcost              *Cost_CommitCost `protobuf:"group,5,opt,name=CommitCost,json=commitcost" json:"commitcost,omitempty"`
2710         ApproximateStorageDelta *int32           `protobuf:"varint,8,opt,name=approximate_storage_delta,json=approximateStorageDelta" json:"approximate_storage_delta,omitempty"`
2711         IdSequenceUpdates       *int32           `protobuf:"varint,9,opt,name=id_sequence_updates,json=idSequenceUpdates" json:"id_sequence_updates,omitempty"`
2712         XXX_NoUnkeyedLiteral    struct{}         `json:"-"`
2713         XXX_unrecognized        []byte           `json:"-"`
2714         XXX_sizecache           int32            `json:"-"`
2715 }
2716
2717 func (m *Cost) Reset()         { *m = Cost{} }
2718 func (m *Cost) String() string { return proto.CompactTextString(m) }
2719 func (*Cost) ProtoMessage()    {}
2720 func (*Cost) Descriptor() ([]byte, []int) {
2721         return fileDescriptor_datastore_v3_83b17b80c34f6179, []int{20}
2722 }
2723 func (m *Cost) XXX_Unmarshal(b []byte) error {
2724         return xxx_messageInfo_Cost.Unmarshal(m, b)
2725 }
2726 func (m *Cost) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
2727         return xxx_messageInfo_Cost.Marshal(b, m, deterministic)
2728 }
2729 func (dst *Cost) XXX_Merge(src proto.Message) {
2730         xxx_messageInfo_Cost.Merge(dst, src)
2731 }
2732 func (m *Cost) XXX_Size() int {
2733         return xxx_messageInfo_Cost.Size(m)
2734 }
2735 func (m *Cost) XXX_DiscardUnknown() {
2736         xxx_messageInfo_Cost.DiscardUnknown(m)
2737 }
2738
2739 var xxx_messageInfo_Cost proto.InternalMessageInfo
2740
2741 func (m *Cost) GetIndexWrites() int32 {
2742         if m != nil && m.IndexWrites != nil {
2743                 return *m.IndexWrites
2744         }
2745         return 0
2746 }
2747
2748 func (m *Cost) GetIndexWriteBytes() int32 {
2749         if m != nil && m.IndexWriteBytes != nil {
2750                 return *m.IndexWriteBytes
2751         }
2752         return 0
2753 }
2754
2755 func (m *Cost) GetEntityWrites() int32 {
2756         if m != nil && m.EntityWrites != nil {
2757                 return *m.EntityWrites
2758         }
2759         return 0
2760 }
2761
2762 func (m *Cost) GetEntityWriteBytes() int32 {
2763         if m != nil && m.EntityWriteBytes != nil {
2764                 return *m.EntityWriteBytes
2765         }
2766         return 0
2767 }
2768
2769 func (m *Cost) GetCommitcost() *Cost_CommitCost {
2770         if m != nil {
2771                 return m.Commitcost
2772         }
2773         return nil
2774 }
2775
2776 func (m *Cost) GetApproximateStorageDelta() int32 {
2777         if m != nil && m.ApproximateStorageDelta != nil {
2778                 return *m.ApproximateStorageDelta
2779         }
2780         return 0
2781 }
2782
2783 func (m *Cost) GetIdSequenceUpdates() int32 {
2784         if m != nil && m.IdSequenceUpdates != nil {
2785                 return *m.IdSequenceUpdates
2786         }
2787         return 0
2788 }
2789
2790 type Cost_CommitCost struct {
2791         RequestedEntityPuts    *int32   `protobuf:"varint,6,opt,name=requested_entity_puts,json=requestedEntityPuts" json:"requested_entity_puts,omitempty"`
2792         RequestedEntityDeletes *int32   `protobuf:"varint,7,opt,name=requested_entity_deletes,json=requestedEntityDeletes" json:"requested_entity_deletes,omitempty"`
2793         XXX_NoUnkeyedLiteral   struct{} `json:"-"`
2794         XXX_unrecognized       []byte   `json:"-"`
2795         XXX_sizecache          int32    `json:"-"`
2796 }
2797
2798 func (m *Cost_CommitCost) Reset()         { *m = Cost_CommitCost{} }
2799 func (m *Cost_CommitCost) String() string { return proto.CompactTextString(m) }
2800 func (*Cost_CommitCost) ProtoMessage()    {}
2801 func (*Cost_CommitCost) Descriptor() ([]byte, []int) {
2802         return fileDescriptor_datastore_v3_83b17b80c34f6179, []int{20, 0}
2803 }
2804 func (m *Cost_CommitCost) XXX_Unmarshal(b []byte) error {
2805         return xxx_messageInfo_Cost_CommitCost.Unmarshal(m, b)
2806 }
2807 func (m *Cost_CommitCost) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
2808         return xxx_messageInfo_Cost_CommitCost.Marshal(b, m, deterministic)
2809 }
2810 func (dst *Cost_CommitCost) XXX_Merge(src proto.Message) {
2811         xxx_messageInfo_Cost_CommitCost.Merge(dst, src)
2812 }
2813 func (m *Cost_CommitCost) XXX_Size() int {
2814         return xxx_messageInfo_Cost_CommitCost.Size(m)
2815 }
2816 func (m *Cost_CommitCost) XXX_DiscardUnknown() {
2817         xxx_messageInfo_Cost_CommitCost.DiscardUnknown(m)
2818 }
2819
2820 var xxx_messageInfo_Cost_CommitCost proto.InternalMessageInfo
2821
2822 func (m *Cost_CommitCost) GetRequestedEntityPuts() int32 {
2823         if m != nil && m.RequestedEntityPuts != nil {
2824                 return *m.RequestedEntityPuts
2825         }
2826         return 0
2827 }
2828
2829 func (m *Cost_CommitCost) GetRequestedEntityDeletes() int32 {
2830         if m != nil && m.RequestedEntityDeletes != nil {
2831                 return *m.RequestedEntityDeletes
2832         }
2833         return 0
2834 }
2835
2836 type GetRequest struct {
2837         Header               *InternalHeader `protobuf:"bytes,6,opt,name=header" json:"header,omitempty"`
2838         Key                  []*Reference    `protobuf:"bytes,1,rep,name=key" json:"key,omitempty"`
2839         Transaction          *Transaction    `protobuf:"bytes,2,opt,name=transaction" json:"transaction,omitempty"`
2840         FailoverMs           *int64          `protobuf:"varint,3,opt,name=failover_ms,json=failoverMs" json:"failover_ms,omitempty"`
2841         Strong               *bool           `protobuf:"varint,4,opt,name=strong" json:"strong,omitempty"`
2842         AllowDeferred        *bool           `protobuf:"varint,5,opt,name=allow_deferred,json=allowDeferred,def=0" json:"allow_deferred,omitempty"`
2843         XXX_NoUnkeyedLiteral struct{}        `json:"-"`
2844         XXX_unrecognized     []byte          `json:"-"`
2845         XXX_sizecache        int32           `json:"-"`
2846 }
2847
2848 func (m *GetRequest) Reset()         { *m = GetRequest{} }
2849 func (m *GetRequest) String() string { return proto.CompactTextString(m) }
2850 func (*GetRequest) ProtoMessage()    {}
2851 func (*GetRequest) Descriptor() ([]byte, []int) {
2852         return fileDescriptor_datastore_v3_83b17b80c34f6179, []int{21}
2853 }
2854 func (m *GetRequest) XXX_Unmarshal(b []byte) error {
2855         return xxx_messageInfo_GetRequest.Unmarshal(m, b)
2856 }
2857 func (m *GetRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
2858         return xxx_messageInfo_GetRequest.Marshal(b, m, deterministic)
2859 }
2860 func (dst *GetRequest) XXX_Merge(src proto.Message) {
2861         xxx_messageInfo_GetRequest.Merge(dst, src)
2862 }
2863 func (m *GetRequest) XXX_Size() int {
2864         return xxx_messageInfo_GetRequest.Size(m)
2865 }
2866 func (m *GetRequest) XXX_DiscardUnknown() {
2867         xxx_messageInfo_GetRequest.DiscardUnknown(m)
2868 }
2869
2870 var xxx_messageInfo_GetRequest proto.InternalMessageInfo
2871
2872 const Default_GetRequest_AllowDeferred bool = false
2873
2874 func (m *GetRequest) GetHeader() *InternalHeader {
2875         if m != nil {
2876                 return m.Header
2877         }
2878         return nil
2879 }
2880
2881 func (m *GetRequest) GetKey() []*Reference {
2882         if m != nil {
2883                 return m.Key
2884         }
2885         return nil
2886 }
2887
2888 func (m *GetRequest) GetTransaction() *Transaction {
2889         if m != nil {
2890                 return m.Transaction
2891         }
2892         return nil
2893 }
2894
2895 func (m *GetRequest) GetFailoverMs() int64 {
2896         if m != nil && m.FailoverMs != nil {
2897                 return *m.FailoverMs
2898         }
2899         return 0
2900 }
2901
2902 func (m *GetRequest) GetStrong() bool {
2903         if m != nil && m.Strong != nil {
2904                 return *m.Strong
2905         }
2906         return false
2907 }
2908
2909 func (m *GetRequest) GetAllowDeferred() bool {
2910         if m != nil && m.AllowDeferred != nil {
2911                 return *m.AllowDeferred
2912         }
2913         return Default_GetRequest_AllowDeferred
2914 }
2915
2916 type GetResponse struct {
2917         Entity               []*GetResponse_Entity `protobuf:"group,1,rep,name=Entity,json=entity" json:"entity,omitempty"`
2918         Deferred             []*Reference          `protobuf:"bytes,5,rep,name=deferred" json:"deferred,omitempty"`
2919         InOrder              *bool                 `protobuf:"varint,6,opt,name=in_order,json=inOrder,def=1" json:"in_order,omitempty"`
2920         XXX_NoUnkeyedLiteral struct{}              `json:"-"`
2921         XXX_unrecognized     []byte                `json:"-"`
2922         XXX_sizecache        int32                 `json:"-"`
2923 }
2924
2925 func (m *GetResponse) Reset()         { *m = GetResponse{} }
2926 func (m *GetResponse) String() string { return proto.CompactTextString(m) }
2927 func (*GetResponse) ProtoMessage()    {}
2928 func (*GetResponse) Descriptor() ([]byte, []int) {
2929         return fileDescriptor_datastore_v3_83b17b80c34f6179, []int{22}
2930 }
2931 func (m *GetResponse) XXX_Unmarshal(b []byte) error {
2932         return xxx_messageInfo_GetResponse.Unmarshal(m, b)
2933 }
2934 func (m *GetResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
2935         return xxx_messageInfo_GetResponse.Marshal(b, m, deterministic)
2936 }
2937 func (dst *GetResponse) XXX_Merge(src proto.Message) {
2938         xxx_messageInfo_GetResponse.Merge(dst, src)
2939 }
2940 func (m *GetResponse) XXX_Size() int {
2941         return xxx_messageInfo_GetResponse.Size(m)
2942 }
2943 func (m *GetResponse) XXX_DiscardUnknown() {
2944         xxx_messageInfo_GetResponse.DiscardUnknown(m)
2945 }
2946
2947 var xxx_messageInfo_GetResponse proto.InternalMessageInfo
2948
2949 const Default_GetResponse_InOrder bool = true
2950
2951 func (m *GetResponse) GetEntity() []*GetResponse_Entity {
2952         if m != nil {
2953                 return m.Entity
2954         }
2955         return nil
2956 }
2957
2958 func (m *GetResponse) GetDeferred() []*Reference {
2959         if m != nil {
2960                 return m.Deferred
2961         }
2962         return nil
2963 }
2964
2965 func (m *GetResponse) GetInOrder() bool {
2966         if m != nil && m.InOrder != nil {
2967                 return *m.InOrder
2968         }
2969         return Default_GetResponse_InOrder
2970 }
2971
2972 type GetResponse_Entity struct {
2973         Entity               *EntityProto `protobuf:"bytes,2,opt,name=entity" json:"entity,omitempty"`
2974         Key                  *Reference   `protobuf:"bytes,4,opt,name=key" json:"key,omitempty"`
2975         Version              *int64       `protobuf:"varint,3,opt,name=version" json:"version,omitempty"`
2976         XXX_NoUnkeyedLiteral struct{}     `json:"-"`
2977         XXX_unrecognized     []byte       `json:"-"`
2978         XXX_sizecache        int32        `json:"-"`
2979 }
2980
2981 func (m *GetResponse_Entity) Reset()         { *m = GetResponse_Entity{} }
2982 func (m *GetResponse_Entity) String() string { return proto.CompactTextString(m) }
2983 func (*GetResponse_Entity) ProtoMessage()    {}
2984 func (*GetResponse_Entity) Descriptor() ([]byte, []int) {
2985         return fileDescriptor_datastore_v3_83b17b80c34f6179, []int{22, 0}
2986 }
2987 func (m *GetResponse_Entity) XXX_Unmarshal(b []byte) error {
2988         return xxx_messageInfo_GetResponse_Entity.Unmarshal(m, b)
2989 }
2990 func (m *GetResponse_Entity) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
2991         return xxx_messageInfo_GetResponse_Entity.Marshal(b, m, deterministic)
2992 }
2993 func (dst *GetResponse_Entity) XXX_Merge(src proto.Message) {
2994         xxx_messageInfo_GetResponse_Entity.Merge(dst, src)
2995 }
2996 func (m *GetResponse_Entity) XXX_Size() int {
2997         return xxx_messageInfo_GetResponse_Entity.Size(m)
2998 }
2999 func (m *GetResponse_Entity) XXX_DiscardUnknown() {
3000         xxx_messageInfo_GetResponse_Entity.DiscardUnknown(m)
3001 }
3002
3003 var xxx_messageInfo_GetResponse_Entity proto.InternalMessageInfo
3004
3005 func (m *GetResponse_Entity) GetEntity() *EntityProto {
3006         if m != nil {
3007                 return m.Entity
3008         }
3009         return nil
3010 }
3011
3012 func (m *GetResponse_Entity) GetKey() *Reference {
3013         if m != nil {
3014                 return m.Key
3015         }
3016         return nil
3017 }
3018
3019 func (m *GetResponse_Entity) GetVersion() int64 {
3020         if m != nil && m.Version != nil {
3021                 return *m.Version
3022         }
3023         return 0
3024 }
3025
3026 type PutRequest struct {
3027         Header               *InternalHeader          `protobuf:"bytes,11,opt,name=header" json:"header,omitempty"`
3028         Entity               []*EntityProto           `protobuf:"bytes,1,rep,name=entity" json:"entity,omitempty"`
3029         Transaction          *Transaction             `protobuf:"bytes,2,opt,name=transaction" json:"transaction,omitempty"`
3030         CompositeIndex       []*CompositeIndex        `protobuf:"bytes,3,rep,name=composite_index,json=compositeIndex" json:"composite_index,omitempty"`
3031         Trusted              *bool                    `protobuf:"varint,4,opt,name=trusted,def=0" json:"trusted,omitempty"`
3032         Force                *bool                    `protobuf:"varint,7,opt,name=force,def=0" json:"force,omitempty"`
3033         MarkChanges          *bool                    `protobuf:"varint,8,opt,name=mark_changes,json=markChanges,def=0" json:"mark_changes,omitempty"`
3034         Snapshot             []*Snapshot              `protobuf:"bytes,9,rep,name=snapshot" json:"snapshot,omitempty"`
3035         AutoIdPolicy         *PutRequest_AutoIdPolicy `protobuf:"varint,10,opt,name=auto_id_policy,json=autoIdPolicy,enum=appengine.PutRequest_AutoIdPolicy,def=0" json:"auto_id_policy,omitempty"`
3036         XXX_NoUnkeyedLiteral struct{}                 `json:"-"`
3037         XXX_unrecognized     []byte                   `json:"-"`
3038         XXX_sizecache        int32                    `json:"-"`
3039 }
3040
3041 func (m *PutRequest) Reset()         { *m = PutRequest{} }
3042 func (m *PutRequest) String() string { return proto.CompactTextString(m) }
3043 func (*PutRequest) ProtoMessage()    {}
3044 func (*PutRequest) Descriptor() ([]byte, []int) {
3045         return fileDescriptor_datastore_v3_83b17b80c34f6179, []int{23}
3046 }
3047 func (m *PutRequest) XXX_Unmarshal(b []byte) error {
3048         return xxx_messageInfo_PutRequest.Unmarshal(m, b)
3049 }
3050 func (m *PutRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
3051         return xxx_messageInfo_PutRequest.Marshal(b, m, deterministic)
3052 }
3053 func (dst *PutRequest) XXX_Merge(src proto.Message) {
3054         xxx_messageInfo_PutRequest.Merge(dst, src)
3055 }
3056 func (m *PutRequest) XXX_Size() int {
3057         return xxx_messageInfo_PutRequest.Size(m)
3058 }
3059 func (m *PutRequest) XXX_DiscardUnknown() {
3060         xxx_messageInfo_PutRequest.DiscardUnknown(m)
3061 }
3062
3063 var xxx_messageInfo_PutRequest proto.InternalMessageInfo
3064
3065 const Default_PutRequest_Trusted bool = false
3066 const Default_PutRequest_Force bool = false
3067 const Default_PutRequest_MarkChanges bool = false
3068 const Default_PutRequest_AutoIdPolicy PutRequest_AutoIdPolicy = PutRequest_CURRENT
3069
3070 func (m *PutRequest) GetHeader() *InternalHeader {
3071         if m != nil {
3072                 return m.Header
3073         }
3074         return nil
3075 }
3076
3077 func (m *PutRequest) GetEntity() []*EntityProto {
3078         if m != nil {
3079                 return m.Entity
3080         }
3081         return nil
3082 }
3083
3084 func (m *PutRequest) GetTransaction() *Transaction {
3085         if m != nil {
3086                 return m.Transaction
3087         }
3088         return nil
3089 }
3090
3091 func (m *PutRequest) GetCompositeIndex() []*CompositeIndex {
3092         if m != nil {
3093                 return m.CompositeIndex
3094         }
3095         return nil
3096 }
3097
3098 func (m *PutRequest) GetTrusted() bool {
3099         if m != nil && m.Trusted != nil {
3100                 return *m.Trusted
3101         }
3102         return Default_PutRequest_Trusted
3103 }
3104
3105 func (m *PutRequest) GetForce() bool {
3106         if m != nil && m.Force != nil {
3107                 return *m.Force
3108         }
3109         return Default_PutRequest_Force
3110 }
3111
3112 func (m *PutRequest) GetMarkChanges() bool {
3113         if m != nil && m.MarkChanges != nil {
3114                 return *m.MarkChanges
3115         }
3116         return Default_PutRequest_MarkChanges
3117 }
3118
3119 func (m *PutRequest) GetSnapshot() []*Snapshot {
3120         if m != nil {
3121                 return m.Snapshot
3122         }
3123         return nil
3124 }
3125
3126 func (m *PutRequest) GetAutoIdPolicy() PutRequest_AutoIdPolicy {
3127         if m != nil && m.AutoIdPolicy != nil {
3128                 return *m.AutoIdPolicy
3129         }
3130         return Default_PutRequest_AutoIdPolicy
3131 }
3132
3133 type PutResponse struct {
3134         Key                  []*Reference `protobuf:"bytes,1,rep,name=key" json:"key,omitempty"`
3135         Cost                 *Cost        `protobuf:"bytes,2,opt,name=cost" json:"cost,omitempty"`
3136         Version              []int64      `protobuf:"varint,3,rep,name=version" json:"version,omitempty"`
3137         XXX_NoUnkeyedLiteral struct{}     `json:"-"`
3138         XXX_unrecognized     []byte       `json:"-"`
3139         XXX_sizecache        int32        `json:"-"`
3140 }
3141
3142 func (m *PutResponse) Reset()         { *m = PutResponse{} }
3143 func (m *PutResponse) String() string { return proto.CompactTextString(m) }
3144 func (*PutResponse) ProtoMessage()    {}
3145 func (*PutResponse) Descriptor() ([]byte, []int) {
3146         return fileDescriptor_datastore_v3_83b17b80c34f6179, []int{24}
3147 }
3148 func (m *PutResponse) XXX_Unmarshal(b []byte) error {
3149         return xxx_messageInfo_PutResponse.Unmarshal(m, b)
3150 }
3151 func (m *PutResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
3152         return xxx_messageInfo_PutResponse.Marshal(b, m, deterministic)
3153 }
3154 func (dst *PutResponse) XXX_Merge(src proto.Message) {
3155         xxx_messageInfo_PutResponse.Merge(dst, src)
3156 }
3157 func (m *PutResponse) XXX_Size() int {
3158         return xxx_messageInfo_PutResponse.Size(m)
3159 }
3160 func (m *PutResponse) XXX_DiscardUnknown() {
3161         xxx_messageInfo_PutResponse.DiscardUnknown(m)
3162 }
3163
3164 var xxx_messageInfo_PutResponse proto.InternalMessageInfo
3165
3166 func (m *PutResponse) GetKey() []*Reference {
3167         if m != nil {
3168                 return m.Key
3169         }
3170         return nil
3171 }
3172
3173 func (m *PutResponse) GetCost() *Cost {
3174         if m != nil {
3175                 return m.Cost
3176         }
3177         return nil
3178 }
3179
3180 func (m *PutResponse) GetVersion() []int64 {
3181         if m != nil {
3182                 return m.Version
3183         }
3184         return nil
3185 }
3186
3187 type TouchRequest struct {
3188         Header               *InternalHeader   `protobuf:"bytes,10,opt,name=header" json:"header,omitempty"`
3189         Key                  []*Reference      `protobuf:"bytes,1,rep,name=key" json:"key,omitempty"`
3190         CompositeIndex       []*CompositeIndex `protobuf:"bytes,2,rep,name=composite_index,json=compositeIndex" json:"composite_index,omitempty"`
3191         Force                *bool             `protobuf:"varint,3,opt,name=force,def=0" json:"force,omitempty"`
3192         Snapshot             []*Snapshot       `protobuf:"bytes,9,rep,name=snapshot" json:"snapshot,omitempty"`
3193         XXX_NoUnkeyedLiteral struct{}          `json:"-"`
3194         XXX_unrecognized     []byte            `json:"-"`
3195         XXX_sizecache        int32             `json:"-"`
3196 }
3197
3198 func (m *TouchRequest) Reset()         { *m = TouchRequest{} }
3199 func (m *TouchRequest) String() string { return proto.CompactTextString(m) }
3200 func (*TouchRequest) ProtoMessage()    {}
3201 func (*TouchRequest) Descriptor() ([]byte, []int) {
3202         return fileDescriptor_datastore_v3_83b17b80c34f6179, []int{25}
3203 }
3204 func (m *TouchRequest) XXX_Unmarshal(b []byte) error {
3205         return xxx_messageInfo_TouchRequest.Unmarshal(m, b)
3206 }
3207 func (m *TouchRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
3208         return xxx_messageInfo_TouchRequest.Marshal(b, m, deterministic)
3209 }
3210 func (dst *TouchRequest) XXX_Merge(src proto.Message) {
3211         xxx_messageInfo_TouchRequest.Merge(dst, src)
3212 }
3213 func (m *TouchRequest) XXX_Size() int {
3214         return xxx_messageInfo_TouchRequest.Size(m)
3215 }
3216 func (m *TouchRequest) XXX_DiscardUnknown() {
3217         xxx_messageInfo_TouchRequest.DiscardUnknown(m)
3218 }
3219
3220 var xxx_messageInfo_TouchRequest proto.InternalMessageInfo
3221
3222 const Default_TouchRequest_Force bool = false
3223
3224 func (m *TouchRequest) GetHeader() *InternalHeader {
3225         if m != nil {
3226                 return m.Header
3227         }
3228         return nil
3229 }
3230
3231 func (m *TouchRequest) GetKey() []*Reference {
3232         if m != nil {
3233                 return m.Key
3234         }
3235         return nil
3236 }
3237
3238 func (m *TouchRequest) GetCompositeIndex() []*CompositeIndex {
3239         if m != nil {
3240                 return m.CompositeIndex
3241         }
3242         return nil
3243 }
3244
3245 func (m *TouchRequest) GetForce() bool {
3246         if m != nil && m.Force != nil {
3247                 return *m.Force
3248         }
3249         return Default_TouchRequest_Force
3250 }
3251
3252 func (m *TouchRequest) GetSnapshot() []*Snapshot {
3253         if m != nil {
3254                 return m.Snapshot
3255         }
3256         return nil
3257 }
3258
3259 type TouchResponse struct {
3260         Cost                 *Cost    `protobuf:"bytes,1,opt,name=cost" json:"cost,omitempty"`
3261         XXX_NoUnkeyedLiteral struct{} `json:"-"`
3262         XXX_unrecognized     []byte   `json:"-"`
3263         XXX_sizecache        int32    `json:"-"`
3264 }
3265
3266 func (m *TouchResponse) Reset()         { *m = TouchResponse{} }
3267 func (m *TouchResponse) String() string { return proto.CompactTextString(m) }
3268 func (*TouchResponse) ProtoMessage()    {}
3269 func (*TouchResponse) Descriptor() ([]byte, []int) {
3270         return fileDescriptor_datastore_v3_83b17b80c34f6179, []int{26}
3271 }
3272 func (m *TouchResponse) XXX_Unmarshal(b []byte) error {
3273         return xxx_messageInfo_TouchResponse.Unmarshal(m, b)
3274 }
3275 func (m *TouchResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
3276         return xxx_messageInfo_TouchResponse.Marshal(b, m, deterministic)
3277 }
3278 func (dst *TouchResponse) XXX_Merge(src proto.Message) {
3279         xxx_messageInfo_TouchResponse.Merge(dst, src)
3280 }
3281 func (m *TouchResponse) XXX_Size() int {
3282         return xxx_messageInfo_TouchResponse.Size(m)
3283 }
3284 func (m *TouchResponse) XXX_DiscardUnknown() {
3285         xxx_messageInfo_TouchResponse.DiscardUnknown(m)
3286 }
3287
3288 var xxx_messageInfo_TouchResponse proto.InternalMessageInfo
3289
3290 func (m *TouchResponse) GetCost() *Cost {
3291         if m != nil {
3292                 return m.Cost
3293         }
3294         return nil
3295 }
3296
3297 type DeleteRequest struct {
3298         Header               *InternalHeader `protobuf:"bytes,10,opt,name=header" json:"header,omitempty"`
3299         Key                  []*Reference    `protobuf:"bytes,6,rep,name=key" json:"key,omitempty"`
3300         Transaction          *Transaction    `protobuf:"bytes,5,opt,name=transaction" json:"transaction,omitempty"`
3301         Trusted              *bool           `protobuf:"varint,4,opt,name=trusted,def=0" json:"trusted,omitempty"`
3302         Force                *bool           `protobuf:"varint,7,opt,name=force,def=0" json:"force,omitempty"`
3303         MarkChanges          *bool           `protobuf:"varint,8,opt,name=mark_changes,json=markChanges,def=0" json:"mark_changes,omitempty"`
3304         Snapshot             []*Snapshot     `protobuf:"bytes,9,rep,name=snapshot" json:"snapshot,omitempty"`
3305         XXX_NoUnkeyedLiteral struct{}        `json:"-"`
3306         XXX_unrecognized     []byte          `json:"-"`
3307         XXX_sizecache        int32           `json:"-"`
3308 }
3309
3310 func (m *DeleteRequest) Reset()         { *m = DeleteRequest{} }
3311 func (m *DeleteRequest) String() string { return proto.CompactTextString(m) }
3312 func (*DeleteRequest) ProtoMessage()    {}
3313 func (*DeleteRequest) Descriptor() ([]byte, []int) {
3314         return fileDescriptor_datastore_v3_83b17b80c34f6179, []int{27}
3315 }
3316 func (m *DeleteRequest) XXX_Unmarshal(b []byte) error {
3317         return xxx_messageInfo_DeleteRequest.Unmarshal(m, b)
3318 }
3319 func (m *DeleteRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
3320         return xxx_messageInfo_DeleteRequest.Marshal(b, m, deterministic)
3321 }
3322 func (dst *DeleteRequest) XXX_Merge(src proto.Message) {
3323         xxx_messageInfo_DeleteRequest.Merge(dst, src)
3324 }
3325 func (m *DeleteRequest) XXX_Size() int {
3326         return xxx_messageInfo_DeleteRequest.Size(m)
3327 }
3328 func (m *DeleteRequest) XXX_DiscardUnknown() {
3329         xxx_messageInfo_DeleteRequest.DiscardUnknown(m)
3330 }
3331
3332 var xxx_messageInfo_DeleteRequest proto.InternalMessageInfo
3333
3334 const Default_DeleteRequest_Trusted bool = false
3335 const Default_DeleteRequest_Force bool = false
3336 const Default_DeleteRequest_MarkChanges bool = false
3337
3338 func (m *DeleteRequest) GetHeader() *InternalHeader {
3339         if m != nil {
3340                 return m.Header
3341         }
3342         return nil
3343 }
3344
3345 func (m *DeleteRequest) GetKey() []*Reference {
3346         if m != nil {
3347                 return m.Key
3348         }
3349         return nil
3350 }
3351
3352 func (m *DeleteRequest) GetTransaction() *Transaction {
3353         if m != nil {
3354                 return m.Transaction
3355         }
3356         return nil
3357 }
3358
3359 func (m *DeleteRequest) GetTrusted() bool {
3360         if m != nil && m.Trusted != nil {
3361                 return *m.Trusted
3362         }
3363         return Default_DeleteRequest_Trusted
3364 }
3365
3366 func (m *DeleteRequest) GetForce() bool {
3367         if m != nil && m.Force != nil {
3368                 return *m.Force
3369         }
3370         return Default_DeleteRequest_Force
3371 }
3372
3373 func (m *DeleteRequest) GetMarkChanges() bool {
3374         if m != nil && m.MarkChanges != nil {
3375                 return *m.MarkChanges
3376         }
3377         return Default_DeleteRequest_MarkChanges
3378 }
3379
3380 func (m *DeleteRequest) GetSnapshot() []*Snapshot {
3381         if m != nil {
3382                 return m.Snapshot
3383         }
3384         return nil
3385 }
3386
3387 type DeleteResponse struct {
3388         Cost                 *Cost    `protobuf:"bytes,1,opt,name=cost" json:"cost,omitempty"`
3389         Version              []int64  `protobuf:"varint,3,rep,name=version" json:"version,omitempty"`
3390         XXX_NoUnkeyedLiteral struct{} `json:"-"`
3391         XXX_unrecognized     []byte   `json:"-"`
3392         XXX_sizecache        int32    `json:"-"`
3393 }
3394
3395 func (m *DeleteResponse) Reset()         { *m = DeleteResponse{} }
3396 func (m *DeleteResponse) String() string { return proto.CompactTextString(m) }
3397 func (*DeleteResponse) ProtoMessage()    {}
3398 func (*DeleteResponse) Descriptor() ([]byte, []int) {
3399         return fileDescriptor_datastore_v3_83b17b80c34f6179, []int{28}
3400 }
3401 func (m *DeleteResponse) XXX_Unmarshal(b []byte) error {
3402         return xxx_messageInfo_DeleteResponse.Unmarshal(m, b)
3403 }
3404 func (m *DeleteResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
3405         return xxx_messageInfo_DeleteResponse.Marshal(b, m, deterministic)
3406 }
3407 func (dst *DeleteResponse) XXX_Merge(src proto.Message) {
3408         xxx_messageInfo_DeleteResponse.Merge(dst, src)
3409 }
3410 func (m *DeleteResponse) XXX_Size() int {
3411         return xxx_messageInfo_DeleteResponse.Size(m)
3412 }
3413 func (m *DeleteResponse) XXX_DiscardUnknown() {
3414         xxx_messageInfo_DeleteResponse.DiscardUnknown(m)
3415 }
3416
3417 var xxx_messageInfo_DeleteResponse proto.InternalMessageInfo
3418
3419 func (m *DeleteResponse) GetCost() *Cost {
3420         if m != nil {
3421                 return m.Cost
3422         }
3423         return nil
3424 }
3425
3426 func (m *DeleteResponse) GetVersion() []int64 {
3427         if m != nil {
3428                 return m.Version
3429         }
3430         return nil
3431 }
3432
3433 type NextRequest struct {
3434         Header               *InternalHeader `protobuf:"bytes,5,opt,name=header" json:"header,omitempty"`
3435         Cursor               *Cursor         `protobuf:"bytes,1,req,name=cursor" json:"cursor,omitempty"`
3436         Count                *int32          `protobuf:"varint,2,opt,name=count" json:"count,omitempty"`
3437         Offset               *int32          `protobuf:"varint,4,opt,name=offset,def=0" json:"offset,omitempty"`
3438         Compile              *bool           `protobuf:"varint,3,opt,name=compile,def=0" json:"compile,omitempty"`
3439         XXX_NoUnkeyedLiteral struct{}        `json:"-"`
3440         XXX_unrecognized     []byte          `json:"-"`
3441         XXX_sizecache        int32           `json:"-"`
3442 }
3443
3444 func (m *NextRequest) Reset()         { *m = NextRequest{} }
3445 func (m *NextRequest) String() string { return proto.CompactTextString(m) }
3446 func (*NextRequest) ProtoMessage()    {}
3447 func (*NextRequest) Descriptor() ([]byte, []int) {
3448         return fileDescriptor_datastore_v3_83b17b80c34f6179, []int{29}
3449 }
3450 func (m *NextRequest) XXX_Unmarshal(b []byte) error {
3451         return xxx_messageInfo_NextRequest.Unmarshal(m, b)
3452 }
3453 func (m *NextRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
3454         return xxx_messageInfo_NextRequest.Marshal(b, m, deterministic)
3455 }
3456 func (dst *NextRequest) XXX_Merge(src proto.Message) {
3457         xxx_messageInfo_NextRequest.Merge(dst, src)
3458 }
3459 func (m *NextRequest) XXX_Size() int {
3460         return xxx_messageInfo_NextRequest.Size(m)
3461 }
3462 func (m *NextRequest) XXX_DiscardUnknown() {
3463         xxx_messageInfo_NextRequest.DiscardUnknown(m)
3464 }
3465
3466 var xxx_messageInfo_NextRequest proto.InternalMessageInfo
3467
3468 const Default_NextRequest_Offset int32 = 0
3469 const Default_NextRequest_Compile bool = false
3470
3471 func (m *NextRequest) GetHeader() *InternalHeader {
3472         if m != nil {
3473                 return m.Header
3474         }
3475         return nil
3476 }
3477
3478 func (m *NextRequest) GetCursor() *Cursor {
3479         if m != nil {
3480                 return m.Cursor
3481         }
3482         return nil
3483 }
3484
3485 func (m *NextRequest) GetCount() int32 {
3486         if m != nil && m.Count != nil {
3487                 return *m.Count
3488         }
3489         return 0
3490 }
3491
3492 func (m *NextRequest) GetOffset() int32 {
3493         if m != nil && m.Offset != nil {
3494                 return *m.Offset
3495         }
3496         return Default_NextRequest_Offset
3497 }
3498
3499 func (m *NextRequest) GetCompile() bool {
3500         if m != nil && m.Compile != nil {
3501                 return *m.Compile
3502         }
3503         return Default_NextRequest_Compile
3504 }
3505
3506 type QueryResult struct {
3507         Cursor               *Cursor           `protobuf:"bytes,1,opt,name=cursor" json:"cursor,omitempty"`
3508         Result               []*EntityProto    `protobuf:"bytes,2,rep,name=result" json:"result,omitempty"`
3509         SkippedResults       *int32            `protobuf:"varint,7,opt,name=skipped_results,json=skippedResults" json:"skipped_results,omitempty"`
3510         MoreResults          *bool             `protobuf:"varint,3,req,name=more_results,json=moreResults" json:"more_results,omitempty"`
3511         KeysOnly             *bool             `protobuf:"varint,4,opt,name=keys_only,json=keysOnly" json:"keys_only,omitempty"`
3512         IndexOnly            *bool             `protobuf:"varint,9,opt,name=index_only,json=indexOnly" json:"index_only,omitempty"`
3513         SmallOps             *bool             `protobuf:"varint,10,opt,name=small_ops,json=smallOps" json:"small_ops,omitempty"`
3514         CompiledQuery        *CompiledQuery    `protobuf:"bytes,5,opt,name=compiled_query,json=compiledQuery" json:"compiled_query,omitempty"`
3515         CompiledCursor       *CompiledCursor   `protobuf:"bytes,6,opt,name=compiled_cursor,json=compiledCursor" json:"compiled_cursor,omitempty"`
3516         Index                []*CompositeIndex `protobuf:"bytes,8,rep,name=index" json:"index,omitempty"`
3517         Version              []int64           `protobuf:"varint,11,rep,name=version" json:"version,omitempty"`
3518         XXX_NoUnkeyedLiteral struct{}          `json:"-"`
3519         XXX_unrecognized     []byte            `json:"-"`
3520         XXX_sizecache        int32             `json:"-"`
3521 }
3522
3523 func (m *QueryResult) Reset()         { *m = QueryResult{} }
3524 func (m *QueryResult) String() string { return proto.CompactTextString(m) }
3525 func (*QueryResult) ProtoMessage()    {}
3526 func (*QueryResult) Descriptor() ([]byte, []int) {
3527         return fileDescriptor_datastore_v3_83b17b80c34f6179, []int{30}
3528 }
3529 func (m *QueryResult) XXX_Unmarshal(b []byte) error {
3530         return xxx_messageInfo_QueryResult.Unmarshal(m, b)
3531 }
3532 func (m *QueryResult) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
3533         return xxx_messageInfo_QueryResult.Marshal(b, m, deterministic)
3534 }
3535 func (dst *QueryResult) XXX_Merge(src proto.Message) {
3536         xxx_messageInfo_QueryResult.Merge(dst, src)
3537 }
3538 func (m *QueryResult) XXX_Size() int {
3539         return xxx_messageInfo_QueryResult.Size(m)
3540 }
3541 func (m *QueryResult) XXX_DiscardUnknown() {
3542         xxx_messageInfo_QueryResult.DiscardUnknown(m)
3543 }
3544
3545 var xxx_messageInfo_QueryResult proto.InternalMessageInfo
3546
3547 func (m *QueryResult) GetCursor() *Cursor {
3548         if m != nil {
3549                 return m.Cursor
3550         }
3551         return nil
3552 }
3553
3554 func (m *QueryResult) GetResult() []*EntityProto {
3555         if m != nil {
3556                 return m.Result
3557         }
3558         return nil
3559 }
3560
3561 func (m *QueryResult) GetSkippedResults() int32 {
3562         if m != nil && m.SkippedResults != nil {
3563                 return *m.SkippedResults
3564         }
3565         return 0
3566 }
3567
3568 func (m *QueryResult) GetMoreResults() bool {
3569         if m != nil && m.MoreResults != nil {
3570                 return *m.MoreResults
3571         }
3572         return false
3573 }
3574
3575 func (m *QueryResult) GetKeysOnly() bool {
3576         if m != nil && m.KeysOnly != nil {
3577                 return *m.KeysOnly
3578         }
3579         return false
3580 }
3581
3582 func (m *QueryResult) GetIndexOnly() bool {
3583         if m != nil && m.IndexOnly != nil {
3584                 return *m.IndexOnly
3585         }
3586         return false
3587 }
3588
3589 func (m *QueryResult) GetSmallOps() bool {
3590         if m != nil && m.SmallOps != nil {
3591                 return *m.SmallOps
3592         }
3593         return false
3594 }
3595
3596 func (m *QueryResult) GetCompiledQuery() *CompiledQuery {
3597         if m != nil {
3598                 return m.CompiledQuery
3599         }
3600         return nil
3601 }
3602
3603 func (m *QueryResult) GetCompiledCursor() *CompiledCursor {
3604         if m != nil {
3605                 return m.CompiledCursor
3606         }
3607         return nil
3608 }
3609
3610 func (m *QueryResult) GetIndex() []*CompositeIndex {
3611         if m != nil {
3612                 return m.Index
3613         }
3614         return nil
3615 }
3616
3617 func (m *QueryResult) GetVersion() []int64 {
3618         if m != nil {
3619                 return m.Version
3620         }
3621         return nil
3622 }
3623
3624 type AllocateIdsRequest struct {
3625         Header               *InternalHeader `protobuf:"bytes,4,opt,name=header" json:"header,omitempty"`
3626         ModelKey             *Reference      `protobuf:"bytes,1,opt,name=model_key,json=modelKey" json:"model_key,omitempty"`
3627         Size                 *int64          `protobuf:"varint,2,opt,name=size" json:"size,omitempty"`
3628         Max                  *int64          `protobuf:"varint,3,opt,name=max" json:"max,omitempty"`
3629         Reserve              []*Reference    `protobuf:"bytes,5,rep,name=reserve" json:"reserve,omitempty"`
3630         XXX_NoUnkeyedLiteral struct{}        `json:"-"`
3631         XXX_unrecognized     []byte          `json:"-"`
3632         XXX_sizecache        int32           `json:"-"`
3633 }
3634
3635 func (m *AllocateIdsRequest) Reset()         { *m = AllocateIdsRequest{} }
3636 func (m *AllocateIdsRequest) String() string { return proto.CompactTextString(m) }
3637 func (*AllocateIdsRequest) ProtoMessage()    {}
3638 func (*AllocateIdsRequest) Descriptor() ([]byte, []int) {
3639         return fileDescriptor_datastore_v3_83b17b80c34f6179, []int{31}
3640 }
3641 func (m *AllocateIdsRequest) XXX_Unmarshal(b []byte) error {
3642         return xxx_messageInfo_AllocateIdsRequest.Unmarshal(m, b)
3643 }
3644 func (m *AllocateIdsRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
3645         return xxx_messageInfo_AllocateIdsRequest.Marshal(b, m, deterministic)
3646 }
3647 func (dst *AllocateIdsRequest) XXX_Merge(src proto.Message) {
3648         xxx_messageInfo_AllocateIdsRequest.Merge(dst, src)
3649 }
3650 func (m *AllocateIdsRequest) XXX_Size() int {
3651         return xxx_messageInfo_AllocateIdsRequest.Size(m)
3652 }
3653 func (m *AllocateIdsRequest) XXX_DiscardUnknown() {
3654         xxx_messageInfo_AllocateIdsRequest.DiscardUnknown(m)
3655 }
3656
3657 var xxx_messageInfo_AllocateIdsRequest proto.InternalMessageInfo
3658
3659 func (m *AllocateIdsRequest) GetHeader() *InternalHeader {
3660         if m != nil {
3661                 return m.Header
3662         }
3663         return nil
3664 }
3665
3666 func (m *AllocateIdsRequest) GetModelKey() *Reference {
3667         if m != nil {
3668                 return m.ModelKey
3669         }
3670         return nil
3671 }
3672
3673 func (m *AllocateIdsRequest) GetSize() int64 {
3674         if m != nil && m.Size != nil {
3675                 return *m.Size
3676         }
3677         return 0
3678 }
3679
3680 func (m *AllocateIdsRequest) GetMax() int64 {
3681         if m != nil && m.Max != nil {
3682                 return *m.Max
3683         }
3684         return 0
3685 }
3686
3687 func (m *AllocateIdsRequest) GetReserve() []*Reference {
3688         if m != nil {
3689                 return m.Reserve
3690         }
3691         return nil
3692 }
3693
3694 type AllocateIdsResponse struct {
3695         Start                *int64   `protobuf:"varint,1,req,name=start" json:"start,omitempty"`
3696         End                  *int64   `protobuf:"varint,2,req,name=end" json:"end,omitempty"`
3697         Cost                 *Cost    `protobuf:"bytes,3,opt,name=cost" json:"cost,omitempty"`
3698         XXX_NoUnkeyedLiteral struct{} `json:"-"`
3699         XXX_unrecognized     []byte   `json:"-"`
3700         XXX_sizecache        int32    `json:"-"`
3701 }
3702
3703 func (m *AllocateIdsResponse) Reset()         { *m = AllocateIdsResponse{} }
3704 func (m *AllocateIdsResponse) String() string { return proto.CompactTextString(m) }
3705 func (*AllocateIdsResponse) ProtoMessage()    {}
3706 func (*AllocateIdsResponse) Descriptor() ([]byte, []int) {
3707         return fileDescriptor_datastore_v3_83b17b80c34f6179, []int{32}
3708 }
3709 func (m *AllocateIdsResponse) XXX_Unmarshal(b []byte) error {
3710         return xxx_messageInfo_AllocateIdsResponse.Unmarshal(m, b)
3711 }
3712 func (m *AllocateIdsResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
3713         return xxx_messageInfo_AllocateIdsResponse.Marshal(b, m, deterministic)
3714 }
3715 func (dst *AllocateIdsResponse) XXX_Merge(src proto.Message) {
3716         xxx_messageInfo_AllocateIdsResponse.Merge(dst, src)
3717 }
3718 func (m *AllocateIdsResponse) XXX_Size() int {
3719         return xxx_messageInfo_AllocateIdsResponse.Size(m)
3720 }
3721 func (m *AllocateIdsResponse) XXX_DiscardUnknown() {
3722         xxx_messageInfo_AllocateIdsResponse.DiscardUnknown(m)
3723 }
3724
3725 var xxx_messageInfo_AllocateIdsResponse proto.InternalMessageInfo
3726
3727 func (m *AllocateIdsResponse) GetStart() int64 {
3728         if m != nil && m.Start != nil {
3729                 return *m.Start
3730         }
3731         return 0
3732 }
3733
3734 func (m *AllocateIdsResponse) GetEnd() int64 {
3735         if m != nil && m.End != nil {
3736                 return *m.End
3737         }
3738         return 0
3739 }
3740
3741 func (m *AllocateIdsResponse) GetCost() *Cost {
3742         if m != nil {
3743                 return m.Cost
3744         }
3745         return nil
3746 }
3747
3748 type CompositeIndices struct {
3749         Index                []*CompositeIndex `protobuf:"bytes,1,rep,name=index" json:"index,omitempty"`
3750         XXX_NoUnkeyedLiteral struct{}          `json:"-"`
3751         XXX_unrecognized     []byte            `json:"-"`
3752         XXX_sizecache        int32             `json:"-"`
3753 }
3754
3755 func (m *CompositeIndices) Reset()         { *m = CompositeIndices{} }
3756 func (m *CompositeIndices) String() string { return proto.CompactTextString(m) }
3757 func (*CompositeIndices) ProtoMessage()    {}
3758 func (*CompositeIndices) Descriptor() ([]byte, []int) {
3759         return fileDescriptor_datastore_v3_83b17b80c34f6179, []int{33}
3760 }
3761 func (m *CompositeIndices) XXX_Unmarshal(b []byte) error {
3762         return xxx_messageInfo_CompositeIndices.Unmarshal(m, b)
3763 }
3764 func (m *CompositeIndices) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
3765         return xxx_messageInfo_CompositeIndices.Marshal(b, m, deterministic)
3766 }
3767 func (dst *CompositeIndices) XXX_Merge(src proto.Message) {
3768         xxx_messageInfo_CompositeIndices.Merge(dst, src)
3769 }
3770 func (m *CompositeIndices) XXX_Size() int {
3771         return xxx_messageInfo_CompositeIndices.Size(m)
3772 }
3773 func (m *CompositeIndices) XXX_DiscardUnknown() {
3774         xxx_messageInfo_CompositeIndices.DiscardUnknown(m)
3775 }
3776
3777 var xxx_messageInfo_CompositeIndices proto.InternalMessageInfo
3778
3779 func (m *CompositeIndices) GetIndex() []*CompositeIndex {
3780         if m != nil {
3781                 return m.Index
3782         }
3783         return nil
3784 }
3785
3786 type AddActionsRequest struct {
3787         Header               *InternalHeader `protobuf:"bytes,3,opt,name=header" json:"header,omitempty"`
3788         Transaction          *Transaction    `protobuf:"bytes,1,req,name=transaction" json:"transaction,omitempty"`
3789         Action               []*Action       `protobuf:"bytes,2,rep,name=action" json:"action,omitempty"`
3790         XXX_NoUnkeyedLiteral struct{}        `json:"-"`
3791         XXX_unrecognized     []byte          `json:"-"`
3792         XXX_sizecache        int32           `json:"-"`
3793 }
3794
3795 func (m *AddActionsRequest) Reset()         { *m = AddActionsRequest{} }
3796 func (m *AddActionsRequest) String() string { return proto.CompactTextString(m) }
3797 func (*AddActionsRequest) ProtoMessage()    {}
3798 func (*AddActionsRequest) Descriptor() ([]byte, []int) {
3799         return fileDescriptor_datastore_v3_83b17b80c34f6179, []int{34}
3800 }
3801 func (m *AddActionsRequest) XXX_Unmarshal(b []byte) error {
3802         return xxx_messageInfo_AddActionsRequest.Unmarshal(m, b)
3803 }
3804 func (m *AddActionsRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
3805         return xxx_messageInfo_AddActionsRequest.Marshal(b, m, deterministic)
3806 }
3807 func (dst *AddActionsRequest) XXX_Merge(src proto.Message) {
3808         xxx_messageInfo_AddActionsRequest.Merge(dst, src)
3809 }
3810 func (m *AddActionsRequest) XXX_Size() int {
3811         return xxx_messageInfo_AddActionsRequest.Size(m)
3812 }
3813 func (m *AddActionsRequest) XXX_DiscardUnknown() {
3814         xxx_messageInfo_AddActionsRequest.DiscardUnknown(m)
3815 }
3816
3817 var xxx_messageInfo_AddActionsRequest proto.InternalMessageInfo
3818
3819 func (m *AddActionsRequest) GetHeader() *InternalHeader {
3820         if m != nil {
3821                 return m.Header
3822         }
3823         return nil
3824 }
3825
3826 func (m *AddActionsRequest) GetTransaction() *Transaction {
3827         if m != nil {
3828                 return m.Transaction
3829         }
3830         return nil
3831 }
3832
3833 func (m *AddActionsRequest) GetAction() []*Action {
3834         if m != nil {
3835                 return m.Action
3836         }
3837         return nil
3838 }
3839
3840 type AddActionsResponse struct {
3841         XXX_NoUnkeyedLiteral struct{} `json:"-"`
3842         XXX_unrecognized     []byte   `json:"-"`
3843         XXX_sizecache        int32    `json:"-"`
3844 }
3845
3846 func (m *AddActionsResponse) Reset()         { *m = AddActionsResponse{} }
3847 func (m *AddActionsResponse) String() string { return proto.CompactTextString(m) }
3848 func (*AddActionsResponse) ProtoMessage()    {}
3849 func (*AddActionsResponse) Descriptor() ([]byte, []int) {
3850         return fileDescriptor_datastore_v3_83b17b80c34f6179, []int{35}
3851 }
3852 func (m *AddActionsResponse) XXX_Unmarshal(b []byte) error {
3853         return xxx_messageInfo_AddActionsResponse.Unmarshal(m, b)
3854 }
3855 func (m *AddActionsResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
3856         return xxx_messageInfo_AddActionsResponse.Marshal(b, m, deterministic)
3857 }
3858 func (dst *AddActionsResponse) XXX_Merge(src proto.Message) {
3859         xxx_messageInfo_AddActionsResponse.Merge(dst, src)
3860 }
3861 func (m *AddActionsResponse) XXX_Size() int {
3862         return xxx_messageInfo_AddActionsResponse.Size(m)
3863 }
3864 func (m *AddActionsResponse) XXX_DiscardUnknown() {
3865         xxx_messageInfo_AddActionsResponse.DiscardUnknown(m)
3866 }
3867
3868 var xxx_messageInfo_AddActionsResponse proto.InternalMessageInfo
3869
3870 type BeginTransactionRequest struct {
3871         Header               *InternalHeader                          `protobuf:"bytes,3,opt,name=header" json:"header,omitempty"`
3872         App                  *string                                  `protobuf:"bytes,1,req,name=app" json:"app,omitempty"`
3873         AllowMultipleEg      *bool                                    `protobuf:"varint,2,opt,name=allow_multiple_eg,json=allowMultipleEg,def=0" json:"allow_multiple_eg,omitempty"`
3874         DatabaseId           *string                                  `protobuf:"bytes,4,opt,name=database_id,json=databaseId" json:"database_id,omitempty"`
3875         Mode                 *BeginTransactionRequest_TransactionMode `protobuf:"varint,5,opt,name=mode,enum=appengine.BeginTransactionRequest_TransactionMode,def=0" json:"mode,omitempty"`
3876         PreviousTransaction  *Transaction                             `protobuf:"bytes,7,opt,name=previous_transaction,json=previousTransaction" json:"previous_transaction,omitempty"`
3877         XXX_NoUnkeyedLiteral struct{}                                 `json:"-"`
3878         XXX_unrecognized     []byte                                   `json:"-"`
3879         XXX_sizecache        int32                                    `json:"-"`
3880 }
3881
3882 func (m *BeginTransactionRequest) Reset()         { *m = BeginTransactionRequest{} }
3883 func (m *BeginTransactionRequest) String() string { return proto.CompactTextString(m) }
3884 func (*BeginTransactionRequest) ProtoMessage()    {}
3885 func (*BeginTransactionRequest) Descriptor() ([]byte, []int) {
3886         return fileDescriptor_datastore_v3_83b17b80c34f6179, []int{36}
3887 }
3888 func (m *BeginTransactionRequest) XXX_Unmarshal(b []byte) error {
3889         return xxx_messageInfo_BeginTransactionRequest.Unmarshal(m, b)
3890 }
3891 func (m *BeginTransactionRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
3892         return xxx_messageInfo_BeginTransactionRequest.Marshal(b, m, deterministic)
3893 }
3894 func (dst *BeginTransactionRequest) XXX_Merge(src proto.Message) {
3895         xxx_messageInfo_BeginTransactionRequest.Merge(dst, src)
3896 }
3897 func (m *BeginTransactionRequest) XXX_Size() int {
3898         return xxx_messageInfo_BeginTransactionRequest.Size(m)
3899 }
3900 func (m *BeginTransactionRequest) XXX_DiscardUnknown() {
3901         xxx_messageInfo_BeginTransactionRequest.DiscardUnknown(m)
3902 }
3903
3904 var xxx_messageInfo_BeginTransactionRequest proto.InternalMessageInfo
3905
3906 const Default_BeginTransactionRequest_AllowMultipleEg bool = false
3907 const Default_BeginTransactionRequest_Mode BeginTransactionRequest_TransactionMode = BeginTransactionRequest_UNKNOWN
3908
3909 func (m *BeginTransactionRequest) GetHeader() *InternalHeader {
3910         if m != nil {
3911                 return m.Header
3912         }
3913         return nil
3914 }
3915
3916 func (m *BeginTransactionRequest) GetApp() string {
3917         if m != nil && m.App != nil {
3918                 return *m.App
3919         }
3920         return ""
3921 }
3922
3923 func (m *BeginTransactionRequest) GetAllowMultipleEg() bool {
3924         if m != nil && m.AllowMultipleEg != nil {
3925                 return *m.AllowMultipleEg
3926         }
3927         return Default_BeginTransactionRequest_AllowMultipleEg
3928 }
3929
3930 func (m *BeginTransactionRequest) GetDatabaseId() string {
3931         if m != nil && m.DatabaseId != nil {
3932                 return *m.DatabaseId
3933         }
3934         return ""
3935 }
3936
3937 func (m *BeginTransactionRequest) GetMode() BeginTransactionRequest_TransactionMode {
3938         if m != nil && m.Mode != nil {
3939                 return *m.Mode
3940         }
3941         return Default_BeginTransactionRequest_Mode
3942 }
3943
3944 func (m *BeginTransactionRequest) GetPreviousTransaction() *Transaction {
3945         if m != nil {
3946                 return m.PreviousTransaction
3947         }
3948         return nil
3949 }
3950
3951 type CommitResponse struct {
3952         Cost                 *Cost                     `protobuf:"bytes,1,opt,name=cost" json:"cost,omitempty"`
3953         Version              []*CommitResponse_Version `protobuf:"group,3,rep,name=Version,json=version" json:"version,omitempty"`
3954         XXX_NoUnkeyedLiteral struct{}                  `json:"-"`
3955         XXX_unrecognized     []byte                    `json:"-"`
3956         XXX_sizecache        int32                     `json:"-"`
3957 }
3958
3959 func (m *CommitResponse) Reset()         { *m = CommitResponse{} }
3960 func (m *CommitResponse) String() string { return proto.CompactTextString(m) }
3961 func (*CommitResponse) ProtoMessage()    {}
3962 func (*CommitResponse) Descriptor() ([]byte, []int) {
3963         return fileDescriptor_datastore_v3_83b17b80c34f6179, []int{37}
3964 }
3965 func (m *CommitResponse) XXX_Unmarshal(b []byte) error {
3966         return xxx_messageInfo_CommitResponse.Unmarshal(m, b)
3967 }
3968 func (m *CommitResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
3969         return xxx_messageInfo_CommitResponse.Marshal(b, m, deterministic)
3970 }
3971 func (dst *CommitResponse) XXX_Merge(src proto.Message) {
3972         xxx_messageInfo_CommitResponse.Merge(dst, src)
3973 }
3974 func (m *CommitResponse) XXX_Size() int {
3975         return xxx_messageInfo_CommitResponse.Size(m)
3976 }
3977 func (m *CommitResponse) XXX_DiscardUnknown() {
3978         xxx_messageInfo_CommitResponse.DiscardUnknown(m)
3979 }
3980
3981 var xxx_messageInfo_CommitResponse proto.InternalMessageInfo
3982
3983 func (m *CommitResponse) GetCost() *Cost {
3984         if m != nil {
3985                 return m.Cost
3986         }
3987         return nil
3988 }
3989
3990 func (m *CommitResponse) GetVersion() []*CommitResponse_Version {
3991         if m != nil {
3992                 return m.Version
3993         }
3994         return nil
3995 }
3996
3997 type CommitResponse_Version struct {
3998         RootEntityKey        *Reference `protobuf:"bytes,4,req,name=root_entity_key,json=rootEntityKey" json:"root_entity_key,omitempty"`
3999         Version              *int64     `protobuf:"varint,5,req,name=version" json:"version,omitempty"`
4000         XXX_NoUnkeyedLiteral struct{}   `json:"-"`
4001         XXX_unrecognized     []byte     `json:"-"`
4002         XXX_sizecache        int32      `json:"-"`
4003 }
4004
4005 func (m *CommitResponse_Version) Reset()         { *m = CommitResponse_Version{} }
4006 func (m *CommitResponse_Version) String() string { return proto.CompactTextString(m) }
4007 func (*CommitResponse_Version) ProtoMessage()    {}
4008 func (*CommitResponse_Version) Descriptor() ([]byte, []int) {
4009         return fileDescriptor_datastore_v3_83b17b80c34f6179, []int{37, 0}
4010 }
4011 func (m *CommitResponse_Version) XXX_Unmarshal(b []byte) error {
4012         return xxx_messageInfo_CommitResponse_Version.Unmarshal(m, b)
4013 }
4014 func (m *CommitResponse_Version) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
4015         return xxx_messageInfo_CommitResponse_Version.Marshal(b, m, deterministic)
4016 }
4017 func (dst *CommitResponse_Version) XXX_Merge(src proto.Message) {
4018         xxx_messageInfo_CommitResponse_Version.Merge(dst, src)
4019 }
4020 func (m *CommitResponse_Version) XXX_Size() int {
4021         return xxx_messageInfo_CommitResponse_Version.Size(m)
4022 }
4023 func (m *CommitResponse_Version) XXX_DiscardUnknown() {
4024         xxx_messageInfo_CommitResponse_Version.DiscardUnknown(m)
4025 }
4026
4027 var xxx_messageInfo_CommitResponse_Version proto.InternalMessageInfo
4028
4029 func (m *CommitResponse_Version) GetRootEntityKey() *Reference {
4030         if m != nil {
4031                 return m.RootEntityKey
4032         }
4033         return nil
4034 }
4035
4036 func (m *CommitResponse_Version) GetVersion() int64 {
4037         if m != nil && m.Version != nil {
4038                 return *m.Version
4039         }
4040         return 0
4041 }
4042
4043 func init() {
4044         proto.RegisterType((*Action)(nil), "appengine.Action")
4045         proto.RegisterType((*PropertyValue)(nil), "appengine.PropertyValue")
4046         proto.RegisterType((*PropertyValue_PointValue)(nil), "appengine.PropertyValue.PointValue")
4047         proto.RegisterType((*PropertyValue_UserValue)(nil), "appengine.PropertyValue.UserValue")
4048         proto.RegisterType((*PropertyValue_ReferenceValue)(nil), "appengine.PropertyValue.ReferenceValue")
4049         proto.RegisterType((*PropertyValue_ReferenceValue_PathElement)(nil), "appengine.PropertyValue.ReferenceValue.PathElement")
4050         proto.RegisterType((*Property)(nil), "appengine.Property")
4051         proto.RegisterType((*Path)(nil), "appengine.Path")
4052         proto.RegisterType((*Path_Element)(nil), "appengine.Path.Element")
4053         proto.RegisterType((*Reference)(nil), "appengine.Reference")
4054         proto.RegisterType((*User)(nil), "appengine.User")
4055         proto.RegisterType((*EntityProto)(nil), "appengine.EntityProto")
4056         proto.RegisterType((*CompositeProperty)(nil), "appengine.CompositeProperty")
4057         proto.RegisterType((*Index)(nil), "appengine.Index")
4058         proto.RegisterType((*Index_Property)(nil), "appengine.Index.Property")
4059         proto.RegisterType((*CompositeIndex)(nil), "appengine.CompositeIndex")
4060         proto.RegisterType((*IndexPostfix)(nil), "appengine.IndexPostfix")
4061         proto.RegisterType((*IndexPostfix_IndexValue)(nil), "appengine.IndexPostfix.IndexValue")
4062         proto.RegisterType((*IndexPosition)(nil), "appengine.IndexPosition")
4063         proto.RegisterType((*Snapshot)(nil), "appengine.Snapshot")
4064         proto.RegisterType((*InternalHeader)(nil), "appengine.InternalHeader")
4065         proto.RegisterType((*Transaction)(nil), "appengine.Transaction")
4066         proto.RegisterType((*Query)(nil), "appengine.Query")
4067         proto.RegisterType((*Query_Filter)(nil), "appengine.Query.Filter")
4068         proto.RegisterType((*Query_Order)(nil), "appengine.Query.Order")
4069         proto.RegisterType((*CompiledQuery)(nil), "appengine.CompiledQuery")
4070         proto.RegisterType((*CompiledQuery_PrimaryScan)(nil), "appengine.CompiledQuery.PrimaryScan")
4071         proto.RegisterType((*CompiledQuery_MergeJoinScan)(nil), "appengine.CompiledQuery.MergeJoinScan")
4072         proto.RegisterType((*CompiledQuery_EntityFilter)(nil), "appengine.CompiledQuery.EntityFilter")
4073         proto.RegisterType((*CompiledCursor)(nil), "appengine.CompiledCursor")
4074         proto.RegisterType((*CompiledCursor_Position)(nil), "appengine.CompiledCursor.Position")
4075         proto.RegisterType((*CompiledCursor_Position_IndexValue)(nil), "appengine.CompiledCursor.Position.IndexValue")
4076         proto.RegisterType((*Cursor)(nil), "appengine.Cursor")
4077         proto.RegisterType((*Error)(nil), "appengine.Error")
4078         proto.RegisterType((*Cost)(nil), "appengine.Cost")
4079         proto.RegisterType((*Cost_CommitCost)(nil), "appengine.Cost.CommitCost")
4080         proto.RegisterType((*GetRequest)(nil), "appengine.GetRequest")
4081         proto.RegisterType((*GetResponse)(nil), "appengine.GetResponse")
4082         proto.RegisterType((*GetResponse_Entity)(nil), "appengine.GetResponse.Entity")
4083         proto.RegisterType((*PutRequest)(nil), "appengine.PutRequest")
4084         proto.RegisterType((*PutResponse)(nil), "appengine.PutResponse")
4085         proto.RegisterType((*TouchRequest)(nil), "appengine.TouchRequest")
4086         proto.RegisterType((*TouchResponse)(nil), "appengine.TouchResponse")
4087         proto.RegisterType((*DeleteRequest)(nil), "appengine.DeleteRequest")
4088         proto.RegisterType((*DeleteResponse)(nil), "appengine.DeleteResponse")
4089         proto.RegisterType((*NextRequest)(nil), "appengine.NextRequest")
4090         proto.RegisterType((*QueryResult)(nil), "appengine.QueryResult")
4091         proto.RegisterType((*AllocateIdsRequest)(nil), "appengine.AllocateIdsRequest")
4092         proto.RegisterType((*AllocateIdsResponse)(nil), "appengine.AllocateIdsResponse")
4093         proto.RegisterType((*CompositeIndices)(nil), "appengine.CompositeIndices")
4094         proto.RegisterType((*AddActionsRequest)(nil), "appengine.AddActionsRequest")
4095         proto.RegisterType((*AddActionsResponse)(nil), "appengine.AddActionsResponse")
4096         proto.RegisterType((*BeginTransactionRequest)(nil), "appengine.BeginTransactionRequest")
4097         proto.RegisterType((*CommitResponse)(nil), "appengine.CommitResponse")
4098         proto.RegisterType((*CommitResponse_Version)(nil), "appengine.CommitResponse.Version")
4099 }
4100
4101 func init() {
4102         proto.RegisterFile("google.golang.org/appengine/internal/datastore/datastore_v3.proto", fileDescriptor_datastore_v3_83b17b80c34f6179)
4103 }
4104
4105 var fileDescriptor_datastore_v3_83b17b80c34f6179 = []byte{
4106         // 4156 bytes of a gzipped FileDescriptorProto
4107         0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xcc, 0x5a, 0xcd, 0x73, 0xe3, 0x46,
4108         0x76, 0x37, 0xc1, 0xef, 0x47, 0x89, 0x82, 0x5a, 0xf3, 0xc1, 0xa1, 0x3f, 0x46, 0xc6, 0xac, 0x6d,
4109         0xd9, 0x6b, 0x73, 0x6c, 0xf9, 0x23, 0x5b, 0x4a, 0x76, 0x1d, 0x4a, 0xc4, 0x68, 0x90, 0xa1, 0x48,
4110         0xb9, 0x09, 0xd9, 0x9e, 0x5c, 0x50, 0x18, 0xa2, 0x29, 0x21, 0x43, 0x02, 0x30, 0x00, 0x6a, 0x46,
4111         0x93, 0xe4, 0x90, 0x4b, 0x2a, 0x55, 0x5b, 0xa9, 0x1c, 0x92, 0x4a, 0x25, 0xf9, 0x07, 0x72, 0xc8,
4112         0x39, 0x95, 0xaa, 0x54, 0xf6, 0x98, 0x5b, 0x0e, 0x7b, 0xc9, 0x31, 0x95, 0x73, 0xf2, 0x27, 0x24,
4113         0x39, 0xa4, 0xfa, 0x75, 0x03, 0x02, 0x28, 0x4a, 0x23, 0x6d, 0xf6, 0x90, 0x13, 0xd1, 0xef, 0xfd,
4114         0xba, 0xf1, 0xfa, 0xf5, 0xfb, 0x6c, 0x10, 0xba, 0xc7, 0xbe, 0x7f, 0x3c, 0x65, 0x9d, 0x63, 0x7f,
4115         0x6a, 0x7b, 0xc7, 0x1d, 0x3f, 0x3c, 0x7e, 0x68, 0x07, 0x01, 0xf3, 0x8e, 0x5d, 0x8f, 0x3d, 0x74,
4116         0xbd, 0x98, 0x85, 0x9e, 0x3d, 0x7d, 0xe8, 0xd8, 0xb1, 0x1d, 0xc5, 0x7e, 0xc8, 0xce, 0x9f, 0xac,
4117         0xd3, 0xcf, 0x3b, 0x41, 0xe8, 0xc7, 0x3e, 0xa9, 0xa7, 0x13, 0xb4, 0x1a, 0x54, 0xba, 0xe3, 0xd8,
4118         0xf5, 0x3d, 0xed, 0x1f, 0x2b, 0xb0, 0x7a, 0x18, 0xfa, 0x01, 0x0b, 0xe3, 0xb3, 0x6f, 0xed, 0xe9,
4119         0x9c, 0x91, 0x77, 0x00, 0x5c, 0x2f, 0xfe, 0xea, 0x0b, 0x1c, 0xb5, 0x0a, 0x9b, 0x85, 0xad, 0x22,
4120         0xcd, 0x50, 0x88, 0x06, 0x2b, 0xcf, 0x7c, 0x7f, 0xca, 0x6c, 0x4f, 0x20, 0x94, 0xcd, 0xc2, 0x56,
4121         0x8d, 0xe6, 0x68, 0x64, 0x13, 0x1a, 0x51, 0x1c, 0xba, 0xde, 0xb1, 0x80, 0x14, 0x37, 0x0b, 0x5b,
4122         0x75, 0x9a, 0x25, 0x71, 0x84, 0xe3, 0xcf, 0x9f, 0x4d, 0x99, 0x40, 0x94, 0x36, 0x0b, 0x5b, 0x05,
4123         0x9a, 0x25, 0x91, 0x3d, 0x80, 0xc0, 0x77, 0xbd, 0xf8, 0x14, 0x01, 0xe5, 0xcd, 0xc2, 0x16, 0x6c,
4124         0x3f, 0xe8, 0xa4, 0x7b, 0xe8, 0xe4, 0xa4, 0xee, 0x1c, 0x72, 0x28, 0x3e, 0xd2, 0xcc, 0x34, 0xf2,
4125         0xdb, 0x50, 0x9f, 0x47, 0x2c, 0x14, 0x6b, 0xd4, 0x70, 0x0d, 0xed, 0xd2, 0x35, 0x8e, 0x22, 0x16,
4126         0x8a, 0x25, 0xce, 0x27, 0x91, 0x21, 0x34, 0x43, 0x36, 0x61, 0x21, 0xf3, 0xc6, 0x4c, 0x2c, 0xb3,
4127         0x82, 0xcb, 0x7c, 0x70, 0xe9, 0x32, 0x34, 0x81, 0x8b, 0xb5, 0x16, 0xa6, 0xb7, 0xb7, 0x00, 0xce,
4128         0x85, 0x25, 0x2b, 0x50, 0x78, 0xd9, 0xaa, 0x6c, 0x2a, 0x5b, 0x05, 0x5a, 0x78, 0xc9, 0x47, 0x67,
4129         0xad, 0xaa, 0x18, 0x9d, 0xb5, 0xff, 0xa9, 0x00, 0xf5, 0x54, 0x26, 0x72, 0x0b, 0xca, 0x6c, 0x66,
4130         0xbb, 0xd3, 0x56, 0x7d, 0x53, 0xd9, 0xaa, 0x53, 0x31, 0x20, 0xf7, 0xa1, 0x61, 0xcf, 0xe3, 0x13,
4131         0xcb, 0xf1, 0x67, 0xb6, 0xeb, 0xb5, 0x00, 0x79, 0xc0, 0x49, 0x3d, 0xa4, 0x90, 0x36, 0xd4, 0x3c,
4132         0x77, 0xfc, 0xdc, 0xb3, 0x67, 0xac, 0xd5, 0xc0, 0x73, 0x48, 0xc7, 0xe4, 0x13, 0x20, 0x13, 0xe6,
4133         0xb0, 0xd0, 0x8e, 0x99, 0x63, 0xb9, 0x0e, 0xf3, 0x62, 0x37, 0x3e, 0x6b, 0xdd, 0x46, 0xd4, 0x7a,
4134         0xca, 0x31, 0x24, 0x23, 0x0f, 0x0f, 0x42, 0xff, 0xd4, 0x75, 0x58, 0xd8, 0xba, 0xb3, 0x00, 0x3f,
4135         0x94, 0x8c, 0xf6, 0xbf, 0x17, 0xa0, 0x99, 0xd7, 0x05, 0x51, 0xa1, 0x68, 0x07, 0x41, 0x6b, 0x15,
4136         0xa5, 0xe4, 0x8f, 0xe4, 0x6d, 0x00, 0x2e, 0x8a, 0x15, 0x05, 0xf6, 0x98, 0xb5, 0x6e, 0xe1, 0x5a,
4137         0x75, 0x4e, 0x19, 0x71, 0x02, 0x39, 0x82, 0x46, 0x60, 0xc7, 0x27, 0x6c, 0xca, 0x66, 0xcc, 0x8b,
4138         0x5b, 0xcd, 0xcd, 0xe2, 0x16, 0x6c, 0x7f, 0x7e, 0x4d, 0xd5, 0x77, 0x0e, 0xed, 0xf8, 0x44, 0x17,
4139         0x53, 0x69, 0x76, 0x9d, 0xb6, 0x0e, 0x8d, 0x0c, 0x8f, 0x10, 0x28, 0xc5, 0x67, 0x01, 0x6b, 0xad,
4140         0xa1, 0x5c, 0xf8, 0x4c, 0x9a, 0xa0, 0xb8, 0x4e, 0x4b, 0x45, 0xf3, 0x57, 0x5c, 0x87, 0x63, 0x50,
4141         0x87, 0xeb, 0x28, 0x22, 0x3e, 0x6b, 0xff, 0x51, 0x86, 0x5a, 0x22, 0x00, 0xe9, 0x42, 0x75, 0xc6,
4142         0x6c, 0xcf, 0xf5, 0x8e, 0xd1, 0x69, 0x9a, 0xdb, 0x6f, 0x2e, 0x11, 0xb3, 0x73, 0x20, 0x20, 0x3b,
4143         0x30, 0x18, 0x5a, 0x07, 0x7a, 0x77, 0x60, 0x0c, 0xf6, 0x69, 0x32, 0x8f, 0x1f, 0xa6, 0x7c, 0xb4,
4144         0xe6, 0xa1, 0x8b, 0x9e, 0x55, 0xa7, 0x20, 0x49, 0x47, 0xa1, 0x9b, 0x0a, 0x51, 0x14, 0x82, 0xe2,
4145         0x21, 0x76, 0xa0, 0x9c, 0xb8, 0x88, 0xb2, 0xd5, 0xd8, 0x6e, 0x5d, 0xa6, 0x1c, 0x2a, 0x60, 0xdc,
4146         0x20, 0x66, 0xf3, 0x69, 0xec, 0x06, 0x53, 0xee, 0x76, 0xca, 0x56, 0x8d, 0xa6, 0x63, 0xf2, 0x1e,
4147         0x40, 0xc4, 0xec, 0x70, 0x7c, 0x62, 0x3f, 0x9b, 0xb2, 0x56, 0x85, 0x7b, 0xf6, 0x4e, 0x79, 0x62,
4148         0x4f, 0x23, 0x46, 0x33, 0x0c, 0x62, 0xc3, 0xdd, 0x49, 0x1c, 0x59, 0xb1, 0xff, 0x9c, 0x79, 0xee,
4149         0x2b, 0x9b, 0x07, 0x12, 0xcb, 0x0f, 0xf8, 0x0f, 0xfa, 0x58, 0x73, 0xfb, 0xc3, 0x65, 0x5b, 0x7f,
4150         0x14, 0x47, 0x66, 0x66, 0xc6, 0x10, 0x27, 0xd0, 0xdb, 0x93, 0x65, 0x64, 0xd2, 0x86, 0xca, 0xd4,
4151         0x1f, 0xdb, 0x53, 0xd6, 0xaa, 0x73, 0x2d, 0xec, 0x28, 0xcc, 0xa3, 0x92, 0xa2, 0xfd, 0xb3, 0x02,
4152         0x55, 0xa9, 0x47, 0xd2, 0x84, 0x8c, 0x26, 0xd5, 0x37, 0x48, 0x0d, 0x4a, 0xbb, 0xfd, 0xe1, 0xae,
4153         0xda, 0xe4, 0x4f, 0xa6, 0xfe, 0xbd, 0xa9, 0xae, 0x71, 0xcc, 0xee, 0x53, 0x53, 0x1f, 0x99, 0x94,
4154         0x63, 0x54, 0xb2, 0x0e, 0xab, 0x5d, 0x73, 0x78, 0x60, 0xed, 0x75, 0x4d, 0x7d, 0x7f, 0x48, 0x9f,
4155         0xaa, 0x05, 0xb2, 0x0a, 0x75, 0x24, 0xf5, 0x8d, 0xc1, 0x13, 0x55, 0xe1, 0x33, 0x70, 0x68, 0x1a,
4156         0x66, 0x5f, 0x57, 0x8b, 0x44, 0x85, 0x15, 0x31, 0x63, 0x38, 0x30, 0xf5, 0x81, 0xa9, 0x96, 0x52,
4157         0xca, 0xe8, 0xe8, 0xe0, 0xa0, 0x4b, 0x9f, 0xaa, 0x65, 0xb2, 0x06, 0x0d, 0xa4, 0x74, 0x8f, 0xcc,
4158         0xc7, 0x43, 0xaa, 0x56, 0x48, 0x03, 0xaa, 0xfb, 0x3d, 0xeb, 0xbb, 0xc7, 0xfa, 0x40, 0xad, 0x92,
4159         0x15, 0xa8, 0xed, 0xf7, 0x2c, 0xfd, 0xa0, 0x6b, 0xf4, 0xd5, 0x1a, 0x9f, 0xbd, 0xaf, 0x0f, 0xe9,
4160         0x68, 0x64, 0x1d, 0x0e, 0x8d, 0x81, 0xa9, 0xd6, 0x49, 0x1d, 0xca, 0xfb, 0x3d, 0xcb, 0x38, 0x50,
4161         0x81, 0x10, 0x68, 0xee, 0xf7, 0xac, 0xc3, 0xc7, 0xc3, 0x81, 0x3e, 0x38, 0x3a, 0xd8, 0xd5, 0xa9,
4162         0xda, 0x20, 0xb7, 0x40, 0xe5, 0xb4, 0xe1, 0xc8, 0xec, 0xf6, 0xbb, 0xbd, 0x1e, 0xd5, 0x47, 0x23,
4163         0x75, 0x85, 0x4b, 0xbd, 0xdf, 0xb3, 0x68, 0xd7, 0xe4, 0xfb, 0x5a, 0xe5, 0x2f, 0xe4, 0x7b, 0x7f,
4164         0xa2, 0x3f, 0x55, 0xd7, 0xf9, 0x2b, 0xf4, 0x81, 0x69, 0x98, 0x4f, 0xad, 0x43, 0x3a, 0x34, 0x87,
4165         0xea, 0x06, 0x17, 0xd0, 0x18, 0xf4, 0xf4, 0xef, 0xad, 0x6f, 0xbb, 0xfd, 0x23, 0x5d, 0x25, 0xda,
4166         0x8f, 0xe1, 0xf6, 0xd2, 0x33, 0xe1, 0xaa, 0x7b, 0x6c, 0x1e, 0xf4, 0xd5, 0x02, 0x7f, 0xe2, 0x9b,
4167         0x52, 0x15, 0xed, 0x0f, 0xa0, 0xc4, 0x5d, 0x86, 0x7c, 0x06, 0xd5, 0xc4, 0x1b, 0x0b, 0xe8, 0x8d,
4168         0x77, 0xb3, 0x67, 0x6d, 0xc7, 0x27, 0x9d, 0xc4, 0xe3, 0x12, 0x5c, 0xbb, 0x0b, 0xd5, 0x45, 0x4f,
4169         0x53, 0x2e, 0x78, 0x5a, 0xf1, 0x82, 0xa7, 0x95, 0x32, 0x9e, 0x66, 0x43, 0x3d, 0xf5, 0xed, 0x9b,
4170         0x47, 0x91, 0x07, 0x50, 0xe2, 0xde, 0xdf, 0x6a, 0xa2, 0x87, 0xac, 0x2d, 0x08, 0x4c, 0x91, 0xa9,
4171         0xfd, 0x43, 0x01, 0x4a, 0x3c, 0xda, 0x9e, 0x07, 0xda, 0xc2, 0x15, 0x81, 0x56, 0xb9, 0x32, 0xd0,
4172         0x16, 0xaf, 0x15, 0x68, 0x2b, 0x37, 0x0b, 0xb4, 0xd5, 0x4b, 0x02, 0xad, 0xf6, 0x67, 0x45, 0x68,
4173         0xe8, 0x38, 0xf3, 0x10, 0x13, 0xfd, 0xfb, 0x50, 0x7c, 0xce, 0xce, 0x50, 0x3f, 0x8d, 0xed, 0x5b,
4174         0x99, 0xdd, 0xa6, 0x2a, 0xa4, 0x1c, 0x40, 0xb6, 0x61, 0x45, 0xbc, 0xd0, 0x3a, 0x0e, 0xfd, 0x79,
4175         0xd0, 0x52, 0x97, 0xab, 0xa7, 0x21, 0x40, 0xfb, 0x1c, 0x43, 0xde, 0x83, 0xb2, 0xff, 0xc2, 0x63,
4176         0x21, 0xc6, 0xc1, 0x3c, 0x98, 0x2b, 0x8f, 0x0a, 0x2e, 0x79, 0x08, 0xa5, 0xe7, 0xae, 0xe7, 0xe0,
4177         0x19, 0xe6, 0x23, 0x61, 0x46, 0xd0, 0xce, 0x13, 0xd7, 0x73, 0x28, 0x02, 0xc9, 0x3d, 0xa8, 0xf1,
4178         0x5f, 0x8c, 0x7b, 0x65, 0xdc, 0x68, 0x95, 0x8f, 0x79, 0xd0, 0x7b, 0x08, 0xb5, 0x40, 0xc6, 0x10,
4179         0x4c, 0x00, 0x8d, 0xed, 0x8d, 0x25, 0xe1, 0x85, 0xa6, 0x20, 0xf2, 0x15, 0xac, 0x84, 0xf6, 0x0b,
4180         0x2b, 0x9d, 0xb4, 0x76, 0xf9, 0xa4, 0x46, 0x68, 0xbf, 0x48, 0x23, 0x38, 0x81, 0x52, 0x68, 0x7b,
4181         0xcf, 0x5b, 0x64, 0xb3, 0xb0, 0x55, 0xa6, 0xf8, 0xac, 0x7d, 0x01, 0x25, 0x2e, 0x25, 0x8f, 0x08,
4182         0xfb, 0x3d, 0xf4, 0xff, 0xee, 0x9e, 0xa9, 0x16, 0x12, 0x7f, 0xfe, 0x96, 0x47, 0x03, 0x45, 0x72,
4183         0x0f, 0xf4, 0xd1, 0xa8, 0xbb, 0xaf, 0xab, 0x45, 0xad, 0x07, 0xeb, 0x7b, 0xfe, 0x2c, 0xf0, 0x23,
4184         0x37, 0x66, 0xe9, 0xf2, 0xf7, 0xa0, 0xe6, 0x7a, 0x0e, 0x7b, 0x69, 0xb9, 0x0e, 0x9a, 0x56, 0x91,
4185         0x56, 0x71, 0x6c, 0x38, 0xdc, 0xe4, 0x4e, 0x65, 0x31, 0x55, 0xe4, 0x26, 0x87, 0x03, 0xed, 0x2f,
4186         0x15, 0x28, 0x1b, 0x1c, 0xc1, 0x8d, 0x4f, 0x9e, 0x14, 0x7a, 0x8f, 0x30, 0x4c, 0x10, 0x24, 0x93,
4187         0xfb, 0x50, 0x1b, 0x6a, 0xb6, 0x37, 0x66, 0xbc, 0xe2, 0xc3, 0x3c, 0x50, 0xa3, 0xe9, 0x98, 0x7c,
4188         0x99, 0xd1, 0x9f, 0x82, 0x2e, 0x7b, 0x2f, 0xa3, 0x0a, 0x7c, 0xc1, 0x12, 0x2d, 0xb6, 0xff, 0xaa,
4189         0x90, 0x49, 0x6e, 0xcb, 0x12, 0x4f, 0x1f, 0xea, 0x8e, 0x1b, 0x32, 0xac, 0x23, 0xe5, 0x41, 0x3f,
4190         0xb8, 0x74, 0xe1, 0x4e, 0x2f, 0x81, 0xee, 0xd4, 0xbb, 0xa3, 0x3d, 0x7d, 0xd0, 0xe3, 0x99, 0xef,
4191         0x7c, 0x01, 0xed, 0x23, 0xa8, 0xa7, 0x10, 0x0c, 0xc7, 0x09, 0x48, 0x2d, 0x70, 0xf5, 0xf6, 0xf4,
4192         0x74, 0xac, 0x68, 0x7f, 0xad, 0x40, 0x33, 0xd5, 0xaf, 0xd0, 0xd0, 0x6d, 0xa8, 0xd8, 0x41, 0x90,
4193         0xa8, 0xb6, 0x4e, 0xcb, 0x76, 0x10, 0x18, 0x8e, 0x8c, 0x2d, 0x0a, 0x6a, 0x9b, 0xc7, 0x96, 0x4f,
4194         0x01, 0x1c, 0x36, 0x71, 0x3d, 0x17, 0x85, 0x2e, 0xa2, 0xc1, 0xab, 0x8b, 0x42, 0xd3, 0x0c, 0x86,
4195         0x7c, 0x09, 0xe5, 0x28, 0xb6, 0x63, 0x91, 0x2b, 0x9b, 0xdb, 0xf7, 0x33, 0xe0, 0xbc, 0x08, 0x9d,
4196         0x11, 0x87, 0x51, 0x81, 0x26, 0x5f, 0xc1, 0x2d, 0xdf, 0x9b, 0x9e, 0x59, 0xf3, 0x88, 0x59, 0xee,
4197         0xc4, 0x0a, 0xd9, 0x0f, 0x73, 0x37, 0x64, 0x4e, 0x3e, 0xa7, 0xae, 0x73, 0xc8, 0x51, 0xc4, 0x8c,
4198         0x09, 0x95, 0x7c, 0xed, 0x6b, 0x28, 0xe3, 0x3a, 0x7c, 0xcf, 0xdf, 0x51, 0xc3, 0xd4, 0xad, 0xe1,
4199         0xa0, 0xff, 0x54, 0xe8, 0x80, 0xea, 0xdd, 0x9e, 0x85, 0x44, 0x55, 0xe1, 0xc1, 0xbe, 0xa7, 0xf7,
4200         0x75, 0x53, 0xef, 0xa9, 0x45, 0x9e, 0x3d, 0x74, 0x4a, 0x87, 0x54, 0x2d, 0x69, 0xff, 0x53, 0x80,
4201         0x15, 0x94, 0xe7, 0xd0, 0x8f, 0xe2, 0x89, 0xfb, 0x92, 0xec, 0x41, 0x43, 0x98, 0xdd, 0xa9, 0x2c,
4202         0xe8, 0xb9, 0x33, 0x68, 0x8b, 0x7b, 0x96, 0x68, 0x31, 0x90, 0x75, 0xb4, 0x9b, 0x3e, 0x27, 0x21,
4203         0x45, 0x41, 0xa7, 0xbf, 0x22, 0xa4, 0xbc, 0x05, 0x95, 0x67, 0x6c, 0xe2, 0x87, 0x22, 0x04, 0xd6,
4204         0x76, 0x4a, 0x71, 0x38, 0x67, 0x54, 0xd2, 0xda, 0x36, 0xc0, 0xf9, 0xfa, 0xe4, 0x01, 0xac, 0x26,
4205         0xc6, 0x66, 0xa1, 0x71, 0x89, 0x93, 0x5b, 0x49, 0x88, 0x83, 0x5c, 0x75, 0xa3, 0x5c, 0xab, 0xba,
4206         0xd1, 0xbe, 0x86, 0xd5, 0x64, 0x3f, 0xe2, 0xfc, 0x54, 0x21, 0x79, 0x01, 0x63, 0xca, 0x82, 0x8c,
4207         0xca, 0x45, 0x19, 0xb5, 0x9f, 0x41, 0x6d, 0xe4, 0xd9, 0x41, 0x74, 0xe2, 0xc7, 0xdc, 0x7a, 0xe2,
4208         0x48, 0xfa, 0xaa, 0x12, 0x47, 0x9a, 0x06, 0x15, 0x7e, 0x38, 0xf3, 0x88, 0xbb, 0xbf, 0x31, 0xe8,
4209         0xee, 0x99, 0xc6, 0xb7, 0xba, 0xfa, 0x06, 0x01, 0xa8, 0xc8, 0xe7, 0x82, 0xa6, 0x41, 0xd3, 0x90,
4210         0xed, 0xd8, 0x63, 0x66, 0x3b, 0x2c, 0xe4, 0x12, 0xfc, 0xe0, 0x47, 0x89, 0x04, 0x3f, 0xf8, 0x91,
4211         0xf6, 0x17, 0x05, 0x68, 0x98, 0xa1, 0xed, 0x45, 0xb6, 0x30, 0xf7, 0xcf, 0xa0, 0x72, 0x82, 0x58,
4212         0x74, 0xa3, 0xc6, 0x82, 0x7f, 0x66, 0x17, 0xa3, 0x12, 0x48, 0xee, 0x40, 0xe5, 0xc4, 0xf6, 0x9c,
4213         0xa9, 0xd0, 0x5a, 0x85, 0xca, 0x51, 0x92, 0x1b, 0x95, 0xf3, 0xdc, 0xb8, 0x05, 0x2b, 0x33, 0x3b,
4214         0x7c, 0x6e, 0x8d, 0x4f, 0x6c, 0xef, 0x98, 0x45, 0xf2, 0x60, 0xa4, 0x05, 0x36, 0x38, 0x6b, 0x4f,
4215         0x70, 0xb4, 0xbf, 0x5f, 0x81, 0xf2, 0x37, 0x73, 0x16, 0x9e, 0x65, 0x04, 0xfa, 0xe0, 0xba, 0x02,
4216         0xc9, 0x17, 0x17, 0x2e, 0x4b, 0xca, 0x6f, 0x2f, 0x26, 0x65, 0x22, 0x53, 0x84, 0xc8, 0x95, 0x22,
4217         0x0b, 0x7c, 0x9a, 0x09, 0x63, 0xeb, 0x57, 0xd8, 0xda, 0x79, 0x70, 0x7b, 0x08, 0x95, 0x89, 0x3b,
4218         0x8d, 0x51, 0x75, 0x8b, 0xd5, 0x08, 0xee, 0xa5, 0xf3, 0x08, 0xd9, 0x54, 0xc2, 0xc8, 0xbb, 0xb0,
4219         0x22, 0x2a, 0x59, 0xeb, 0x07, 0xce, 0xc6, 0x82, 0x95, 0xf7, 0xa6, 0x48, 0x13, 0xbb, 0xff, 0x18,
4220         0xca, 0x7e, 0xc8, 0x37, 0x5f, 0xc7, 0x25, 0xef, 0x5c, 0x58, 0x72, 0xc8, 0xb9, 0x54, 0x80, 0xc8,
4221         0x87, 0x50, 0x3a, 0x71, 0xbd, 0x18, 0xb3, 0x46, 0x73, 0xfb, 0xf6, 0x05, 0xf0, 0x63, 0xd7, 0x8b,
4222         0x29, 0x42, 0x78, 0x98, 0x1f, 0xfb, 0x73, 0x2f, 0x6e, 0xdd, 0xc5, 0x0c, 0x23, 0x06, 0xe4, 0x1e,
4223         0x54, 0xfc, 0xc9, 0x24, 0x62, 0x31, 0x76, 0x96, 0xe5, 0x9d, 0xc2, 0xa7, 0x54, 0x12, 0xf8, 0x84,
4224         0xa9, 0x3b, 0x73, 0x63, 0xec, 0x43, 0xca, 0x54, 0x0c, 0xc8, 0x2e, 0xac, 0x8d, 0xfd, 0x59, 0xe0,
4225         0x4e, 0x99, 0x63, 0x8d, 0xe7, 0x61, 0xe4, 0x87, 0xad, 0x77, 0x2e, 0x1c, 0xd3, 0x9e, 0x44, 0xec,
4226         0x21, 0x80, 0x36, 0xc7, 0xb9, 0x31, 0x31, 0x60, 0x83, 0x79, 0x8e, 0xb5, 0xb8, 0xce, 0xfd, 0xd7,
4227         0xad, 0xb3, 0xce, 0x3c, 0x27, 0x4f, 0x4a, 0xc4, 0xc1, 0x48, 0x68, 0x61, 0xcc, 0x68, 0x6d, 0x60,
4228         0x90, 0xb9, 0x77, 0x69, 0xac, 0x14, 0xe2, 0x64, 0xc2, 0xf7, 0x6f, 0xc0, 0x2d, 0x19, 0x22, 0xad,
4229         0x80, 0x85, 0x13, 0x36, 0x8e, 0xad, 0x60, 0x6a, 0x7b, 0x58, 0xca, 0xa5, 0xc6, 0x4a, 0x24, 0xe4,
4230         0x50, 0x20, 0x0e, 0xa7, 0xb6, 0x47, 0x34, 0xa8, 0x3f, 0x67, 0x67, 0x91, 0xc5, 0x23, 0x29, 0x76,
4231         0xae, 0x29, 0xba, 0xc6, 0xe9, 0x43, 0x6f, 0x7a, 0x46, 0x7e, 0x02, 0x8d, 0xf8, 0xdc, 0xdb, 0xb0,
4232         0x61, 0x6d, 0xe4, 0x4e, 0x35, 0xe3, 0x8b, 0x34, 0x0b, 0x25, 0xf7, 0xa1, 0x2a, 0x35, 0xd4, 0xba,
4233         0x97, 0x5d, 0x3b, 0xa1, 0xf2, 0xc4, 0x3c, 0xb1, 0xdd, 0xa9, 0x7f, 0xca, 0x42, 0x6b, 0x16, 0xb5,
4234         0xda, 0xe2, 0xb6, 0x24, 0x21, 0x1d, 0x44, 0xdc, 0x4f, 0xa3, 0x38, 0xf4, 0xbd, 0xe3, 0xd6, 0x26,
4235         0xde, 0x93, 0xc8, 0xd1, 0xc5, 0xe0, 0xf7, 0x2e, 0x66, 0xfe, 0x7c, 0xf0, 0xfb, 0x1c, 0xee, 0x60,
4236         0x65, 0x66, 0x3d, 0x3b, 0xb3, 0xf2, 0x68, 0x0d, 0xd1, 0x1b, 0xc8, 0xdd, 0x3d, 0x3b, 0xcc, 0x4e,
4237         0x6a, 0x43, 0xcd, 0x71, 0xa3, 0xd8, 0xf5, 0xc6, 0x71, 0xab, 0x85, 0xef, 0x4c, 0xc7, 0xe4, 0x33,
4238         0xb8, 0x3d, 0x73, 0x3d, 0x2b, 0xb2, 0x27, 0xcc, 0x8a, 0x5d, 0xee, 0x9b, 0x6c, 0xec, 0x7b, 0x4e,
4239         0xd4, 0x7a, 0x80, 0x82, 0x93, 0x99, 0xeb, 0x8d, 0xec, 0x09, 0x33, 0xdd, 0x19, 0x1b, 0x09, 0x0e,
4240         0xf9, 0x08, 0xd6, 0x11, 0x1e, 0xb2, 0x60, 0xea, 0x8e, 0x6d, 0xf1, 0xfa, 0x1f, 0xe1, 0xeb, 0xd7,
4241         0x38, 0x83, 0x0a, 0x3a, 0xbe, 0xfa, 0x63, 0x68, 0x06, 0x2c, 0x8c, 0xdc, 0x28, 0xb6, 0xa4, 0x45,
4242         0xbf, 0x97, 0xd5, 0xda, 0xaa, 0x64, 0x0e, 0x91, 0xd7, 0xfe, 0xcf, 0x02, 0x54, 0x84, 0x73, 0x92,
4243         0x4f, 0x41, 0xf1, 0x03, 0xbc, 0x06, 0x69, 0x6e, 0x6f, 0x5e, 0xe2, 0xc1, 0x9d, 0x61, 0xc0, 0xeb,
4244         0x5e, 0x3f, 0xa4, 0x8a, 0x1f, 0xdc, 0xb8, 0x28, 0xd4, 0xfe, 0x10, 0x6a, 0xc9, 0x02, 0xbc, 0xbc,
4245         0xe8, 0xeb, 0xa3, 0x91, 0x65, 0x3e, 0xee, 0x0e, 0xd4, 0x02, 0xb9, 0x03, 0x24, 0x1d, 0x5a, 0x43,
4246         0x6a, 0xe9, 0xdf, 0x1c, 0x75, 0xfb, 0xaa, 0x82, 0x5d, 0x1a, 0xd5, 0xbb, 0xa6, 0x4e, 0x05, 0xb2,
4247         0x48, 0xee, 0xc1, 0xed, 0x2c, 0xe5, 0x1c, 0x5c, 0xc2, 0x14, 0x8c, 0x8f, 0x65, 0x52, 0x01, 0xc5,
4248         0x18, 0xa8, 0x15, 0x9e, 0x16, 0xf4, 0xef, 0x8d, 0x91, 0x39, 0x52, 0xab, 0xed, 0xbf, 0x29, 0x40,
4249         0x19, 0xc3, 0x06, 0x3f, 0x9f, 0x54, 0x72, 0x71, 0x5d, 0x73, 0x5e, 0xb9, 0x1a, 0xd9, 0x92, 0xaa,
4250         0x81, 0x01, 0x65, 0x73, 0x79, 0xf4, 0xf9, 0xb5, 0xd6, 0x53, 0x3f, 0x85, 0x12, 0x8f, 0x52, 0xbc,
4251         0x43, 0x1c, 0xd2, 0x9e, 0x4e, 0xad, 0x47, 0x06, 0x1d, 0xf1, 0x2a, 0x97, 0x40, 0xb3, 0x3b, 0xd8,
4252         0xd3, 0x47, 0xe6, 0x30, 0xa1, 0xa1, 0x56, 0x1e, 0x19, 0x7d, 0x33, 0x45, 0x15, 0xb5, 0x9f, 0xd7,
4253         0x60, 0x35, 0x89, 0x09, 0x22, 0x82, 0x3e, 0x82, 0x46, 0x10, 0xba, 0x33, 0x3b, 0x3c, 0x8b, 0xc6,
4254         0xb6, 0x87, 0x49, 0x01, 0xb6, 0x7f, 0xb4, 0x24, 0xaa, 0x88, 0x1d, 0x1d, 0x0a, 0xec, 0x68, 0x6c,
4255         0x7b, 0x34, 0x3b, 0x91, 0xf4, 0x61, 0x75, 0xc6, 0xc2, 0x63, 0xf6, 0x7b, 0xbe, 0xeb, 0xe1, 0x4a,
4256         0x55, 0x8c, 0xc8, 0xef, 0x5f, 0xba, 0xd2, 0x01, 0x47, 0xff, 0x8e, 0xef, 0x7a, 0xb8, 0x56, 0x7e,
4257         0x32, 0xf9, 0x04, 0xea, 0xa2, 0x12, 0x72, 0xd8, 0x04, 0x63, 0xc5, 0xb2, 0xda, 0x4f, 0xd4, 0xe8,
4258         0x3d, 0x36, 0xc9, 0xc4, 0x65, 0xb8, 0x34, 0x2e, 0x37, 0xb2, 0x71, 0xf9, 0xcd, 0x6c, 0x2c, 0x5a,
4259         0x11, 0x55, 0x78, 0x1a, 0x84, 0x2e, 0x38, 0x7c, 0x6b, 0x89, 0xc3, 0x77, 0x60, 0x23, 0xf1, 0x55,
4260         0xcb, 0xf5, 0x26, 0xee, 0x4b, 0x2b, 0x72, 0x5f, 0x89, 0xd8, 0x53, 0xa6, 0xeb, 0x09, 0xcb, 0xe0,
4261         0x9c, 0x91, 0xfb, 0x8a, 0x11, 0x23, 0xe9, 0xe0, 0x64, 0x0e, 0x5c, 0xc5, 0xab, 0xc9, 0xf7, 0x2e,
4262         0x55, 0x8f, 0x68, 0xbe, 0x64, 0x46, 0xcc, 0x4d, 0x6d, 0xff, 0x52, 0x81, 0x46, 0xe6, 0x1c, 0x78,
4263         0xf6, 0x16, 0xca, 0x42, 0x61, 0xc5, 0x55, 0x94, 0x50, 0x1f, 0x4a, 0xfa, 0x26, 0xd4, 0xa3, 0xd8,
4264         0x0e, 0x63, 0x8b, 0x17, 0x57, 0xb2, 0xdd, 0x45, 0xc2, 0x13, 0x76, 0x46, 0x3e, 0x80, 0x35, 0xc1,
4265         0x74, 0xbd, 0xf1, 0x74, 0x1e, 0xb9, 0xa7, 0xa2, 0x99, 0xaf, 0xd1, 0x26, 0x92, 0x8d, 0x84, 0x4a,
4266         0xee, 0x42, 0x95, 0x67, 0x21, 0xbe, 0x86, 0x68, 0xfa, 0x2a, 0xcc, 0x73, 0xf8, 0x0a, 0x0f, 0x60,
4267         0x95, 0x33, 0xce, 0xe7, 0x57, 0xc4, 0x2d, 0x33, 0xf3, 0x9c, 0xf3, 0xd9, 0x1d, 0xd8, 0x10, 0xaf,
4268         0x09, 0x44, 0xf1, 0x2a, 0x2b, 0xdc, 0x3b, 0xa8, 0xd8, 0x75, 0x64, 0xc9, 0xb2, 0x56, 0x14, 0x9c,
4269         0x1f, 0x01, 0xcf, 0x5e, 0x0b, 0xe8, 0xbb, 0x22, 0x94, 0x31, 0xcf, 0xc9, 0x61, 0x77, 0xe1, 0x1d,
4270         0x8e, 0x9d, 0x7b, 0x76, 0x10, 0x4c, 0x5d, 0xe6, 0x58, 0x53, 0xff, 0x18, 0x43, 0x66, 0x14, 0xdb,
4271         0xb3, 0xc0, 0x9a, 0x47, 0xad, 0x0d, 0x0c, 0x99, 0x6d, 0xe6, 0x39, 0x47, 0x09, 0xa8, 0xef, 0x1f,
4272         0x9b, 0x09, 0xe4, 0x28, 0x6a, 0xff, 0x3e, 0xac, 0xe6, 0xec, 0x71, 0x41, 0xa7, 0x35, 0x74, 0xfe,
4273         0x8c, 0x4e, 0xdf, 0x85, 0x95, 0x20, 0x64, 0xe7, 0xa2, 0xd5, 0x51, 0xb4, 0x86, 0xa0, 0x09, 0xb1,
4274         0xb6, 0x60, 0x05, 0x79, 0x96, 0x20, 0xe6, 0xf3, 0x63, 0x03, 0x59, 0x87, 0xc8, 0x69, 0xbf, 0x80,
4275         0x95, 0xec, 0x69, 0x93, 0x77, 0x33, 0x69, 0xa1, 0x99, 0xcb, 0x93, 0x69, 0x76, 0x48, 0x2a, 0xb2,
4276         0xf5, 0x4b, 0x2a, 0x32, 0x72, 0x9d, 0x8a, 0x4c, 0xfb, 0x2f, 0xd9, 0x9c, 0x65, 0x2a, 0x84, 0x9f,
4277         0x41, 0x2d, 0x90, 0xf5, 0x38, 0x5a, 0x52, 0xfe, 0x12, 0x3e, 0x0f, 0xee, 0x24, 0x95, 0x3b, 0x4d,
4278         0xe7, 0xb4, 0xff, 0x56, 0x81, 0x5a, 0x5a, 0xd0, 0xe7, 0x2c, 0xef, 0xcd, 0x05, 0xcb, 0x3b, 0x90,
4279         0x1a, 0x16, 0x0a, 0x7c, 0x1b, 0xa3, 0xc5, 0x27, 0xaf, 0x7f, 0xd7, 0xc5, 0xb6, 0xe7, 0x34, 0xdb,
4280         0xf6, 0x6c, 0xbe, 0xae, 0xed, 0xf9, 0xe4, 0xa2, 0xc1, 0xbf, 0x95, 0xe9, 0x2d, 0x16, 0xcc, 0xbe,
4281         0xfd, 0x7d, 0xae, 0x0f, 0xca, 0x26, 0x84, 0x77, 0xc4, 0x7e, 0xd2, 0x84, 0x90, 0xb6, 0x3f, 0xf7,
4282         0xaf, 0xd7, 0xfe, 0x6c, 0x43, 0x45, 0xea, 0xfc, 0x0e, 0x54, 0x64, 0x4d, 0x27, 0x1b, 0x04, 0x31,
4283         0x3a, 0x6f, 0x10, 0x0a, 0xb2, 0x4e, 0xd7, 0x7e, 0xae, 0x40, 0x59, 0x0f, 0x43, 0x3f, 0xd4, 0xfe,
4284         0x48, 0x81, 0x3a, 0x3e, 0xed, 0xf9, 0x0e, 0xe3, 0xd9, 0x60, 0xb7, 0xdb, 0xb3, 0xa8, 0xfe, 0xcd,
4285         0x91, 0x8e, 0xd9, 0xa0, 0x0d, 0x77, 0xf6, 0x86, 0x83, 0xbd, 0x23, 0x4a, 0xf5, 0x81, 0x69, 0x99,
4286         0xb4, 0x3b, 0x18, 0xf1, 0xb6, 0x67, 0x38, 0x50, 0x15, 0x9e, 0x29, 0x8c, 0x81, 0xa9, 0xd3, 0x41,
4287         0xb7, 0x6f, 0x89, 0x56, 0xb4, 0x88, 0x77, 0xb3, 0xba, 0xde, 0xb3, 0xf0, 0xd6, 0x51, 0x2d, 0xf1,
4288         0x96, 0xd5, 0x34, 0x0e, 0xf4, 0xe1, 0x91, 0xa9, 0x96, 0xc9, 0x6d, 0x58, 0x3f, 0xd4, 0xe9, 0x81,
4289         0x31, 0x1a, 0x19, 0xc3, 0x81, 0xd5, 0xd3, 0x07, 0x86, 0xde, 0x53, 0x2b, 0x7c, 0x9d, 0x5d, 0x63,
4290         0xdf, 0xec, 0xee, 0xf6, 0x75, 0xb9, 0x4e, 0x95, 0x6c, 0xc2, 0x5b, 0x7b, 0xc3, 0x83, 0x03, 0xc3,
4291         0x34, 0xf5, 0x9e, 0xb5, 0x7b, 0x64, 0x5a, 0x23, 0xd3, 0xe8, 0xf7, 0xad, 0xee, 0xe1, 0x61, 0xff,
4292         0x29, 0x4f, 0x60, 0x35, 0x72, 0x17, 0x36, 0xf6, 0xba, 0x87, 0xdd, 0x5d, 0xa3, 0x6f, 0x98, 0x4f,
4293         0xad, 0x9e, 0x31, 0xe2, 0xf3, 0x7b, 0x6a, 0x9d, 0x27, 0x6c, 0x93, 0x3e, 0xb5, 0xba, 0x7d, 0x14,
4294         0xcd, 0xd4, 0xad, 0xdd, 0xee, 0xde, 0x13, 0x7d, 0xd0, 0x53, 0x81, 0x0b, 0x30, 0xea, 0x3e, 0xd2,
4295         0x2d, 0x2e, 0x92, 0x65, 0x0e, 0x87, 0xd6, 0xb0, 0xdf, 0x53, 0x1b, 0xda, 0xbf, 0x14, 0xa1, 0xb4,
4296         0xe7, 0x47, 0x31, 0xf7, 0x46, 0xe1, 0xac, 0x2f, 0x42, 0x37, 0x66, 0xa2, 0x7f, 0x2b, 0x53, 0xd1,
4297         0x4b, 0x7f, 0x87, 0x24, 0x1e, 0x50, 0x32, 0x10, 0xeb, 0xd9, 0x19, 0xc7, 0x29, 0x88, 0x5b, 0x3b,
4298         0xc7, 0xed, 0x72, 0xb2, 0x88, 0x68, 0x78, 0x85, 0x23, 0xd7, 0x2b, 0x22, 0x4e, 0x06, 0x61, 0xb9,
4299         0xe0, 0xc7, 0x40, 0xb2, 0x20, 0xb9, 0x62, 0x09, 0x91, 0x6a, 0x06, 0x29, 0x96, 0xdc, 0x01, 0x18,
4300         0xfb, 0xb3, 0x99, 0x1b, 0x8f, 0xfd, 0x28, 0x96, 0x5f, 0xc8, 0xda, 0x39, 0x63, 0x8f, 0x62, 0x6e,
4301         0xf1, 0x33, 0x37, 0xe6, 0x8f, 0x34, 0x83, 0x26, 0x3b, 0x70, 0xcf, 0x0e, 0x82, 0xd0, 0x7f, 0xe9,
4302         0xce, 0xec, 0x98, 0x59, 0xdc, 0x73, 0xed, 0x63, 0x66, 0x39, 0x6c, 0x1a, 0xdb, 0xd8, 0x13, 0x95,
4303         0xe9, 0xdd, 0x0c, 0x60, 0x24, 0xf8, 0x3d, 0xce, 0xe6, 0x71, 0xd7, 0x75, 0xac, 0x88, 0xfd, 0x30,
4304         0xe7, 0x1e, 0x60, 0xcd, 0x03, 0xc7, 0xe6, 0x62, 0xd6, 0x45, 0x96, 0x72, 0x9d, 0x91, 0xe4, 0x1c,
4305         0x09, 0x46, 0xfb, 0x15, 0xc0, 0xb9, 0x14, 0x64, 0x1b, 0x6e, 0xf3, 0x3a, 0x9e, 0x45, 0x31, 0x73,
4306         0x2c, 0xb9, 0xdb, 0x60, 0x1e, 0x47, 0x18, 0xe2, 0xcb, 0x74, 0x23, 0x65, 0xca, 0x9b, 0xc2, 0x79,
4307         0x1c, 0x91, 0x9f, 0x40, 0xeb, 0xc2, 0x1c, 0x87, 0x4d, 0x19, 0x7f, 0x6d, 0x15, 0xa7, 0xdd, 0x59,
4308         0x98, 0xd6, 0x13, 0x5c, 0xed, 0x4f, 0x14, 0x80, 0x7d, 0x16, 0x53, 0xc1, 0xcd, 0x34, 0xb6, 0x95,
4309         0xeb, 0x36, 0xb6, 0xef, 0x27, 0x17, 0x08, 0xc5, 0xab, 0x63, 0xc0, 0x42, 0x97, 0xa1, 0xdc, 0xa4,
4310         0xcb, 0xc8, 0x35, 0x11, 0xc5, 0x2b, 0x9a, 0x88, 0x52, 0xae, 0x89, 0xf8, 0x18, 0x9a, 0xf6, 0x74,
4311         0xea, 0xbf, 0xe0, 0x05, 0x0d, 0x0b, 0x43, 0xe6, 0xa0, 0x11, 0x9c, 0xd7, 0xdb, 0xc8, 0xec, 0x49,
4312         0x9e, 0xf6, 0xe7, 0x0a, 0x34, 0x50, 0x15, 0x51, 0xe0, 0x7b, 0x11, 0x23, 0x5f, 0x42, 0x45, 0x5e,
4313         0x44, 0x8b, 0x8b, 0xfc, 0xb7, 0x33, 0xb2, 0x66, 0x70, 0xb2, 0x68, 0xa0, 0x12, 0xcc, 0x33, 0x42,
4314         0xe6, 0x75, 0x97, 0x2b, 0x25, 0x45, 0x91, 0xfb, 0x50, 0x73, 0x3d, 0x4b, 0xb4, 0xd4, 0x95, 0x4c,
4315         0x58, 0xac, 0xba, 0x1e, 0xd6, 0xb2, 0xed, 0x57, 0x50, 0x11, 0x2f, 0x21, 0x9d, 0x54, 0xa6, 0x8b,
4316         0xfa, 0xcb, 0xdc, 0x1c, 0xa7, 0xc2, 0xc8, 0xc3, 0x29, 0xbd, 0x2e, 0x40, 0xb7, 0xa0, 0x7a, 0xca,
4317         0x9b, 0x0f, 0xbc, 0xf4, 0xe3, 0xea, 0x4d, 0x86, 0xda, 0x1f, 0x97, 0x00, 0x0e, 0xe7, 0x4b, 0x0c,
4318         0xa4, 0x71, 0x5d, 0x03, 0xe9, 0xe4, 0xf4, 0xf8, 0x7a, 0x99, 0x7f, 0x75, 0x43, 0x59, 0xd2, 0x69,
4319         0x17, 0x6f, 0xda, 0x69, 0xdf, 0x87, 0x6a, 0x1c, 0xce, 0xb9, 0xa3, 0x08, 0x63, 0x4a, 0x5b, 0x5a,
4320         0x49, 0x25, 0x6f, 0x42, 0x79, 0xe2, 0x87, 0x63, 0x86, 0x8e, 0x95, 0xb2, 0x05, 0xed, 0xc2, 0x65,
4321         0x52, 0xed, 0xb2, 0xcb, 0x24, 0xde, 0xa0, 0x45, 0xf2, 0x1e, 0x0d, 0x0b, 0x99, 0x7c, 0x83, 0x96,
4322         0x5c, 0xb1, 0xd1, 0x14, 0x44, 0xbe, 0x81, 0xa6, 0x3d, 0x8f, 0x7d, 0xcb, 0xe5, 0x15, 0xda, 0xd4,
4323         0x1d, 0x9f, 0x61, 0xd9, 0xdd, 0xcc, 0x7f, 0xaf, 0x4f, 0x0f, 0xaa, 0xd3, 0x9d, 0xc7, 0xbe, 0xe1,
4324         0x1c, 0x22, 0x72, 0xa7, 0x2a, 0x93, 0x12, 0x5d, 0xb1, 0x33, 0x64, 0xed, 0xc7, 0xb0, 0x92, 0x85,
4325         0xf1, 0x04, 0x24, 0x81, 0xea, 0x1b, 0x3c, 0x3b, 0x8d, 0x78, 0x6a, 0x1b, 0x98, 0x46, 0xb7, 0xaf,
4326         0x16, 0xb4, 0x18, 0x1a, 0xb8, 0xbc, 0xf4, 0x8e, 0xeb, 0xba, 0xfd, 0x03, 0x28, 0x61, 0xf8, 0x55,
4327         0x2e, 0x7c, 0x0f, 0xc1, 0x98, 0x8b, 0xcc, 0xbc, 0xf9, 0x15, 0xb3, 0xe6, 0xf7, 0xdf, 0x05, 0x58,
4328         0x31, 0xfd, 0xf9, 0xf8, 0xe4, 0xa2, 0x01, 0xc2, 0xaf, 0x3b, 0x42, 0x2d, 0x31, 0x1f, 0xe5, 0xa6,
4329         0xe6, 0x93, 0x5a, 0x47, 0x71, 0x89, 0x75, 0xdc, 0xf4, 0xcc, 0xb5, 0x2f, 0x60, 0x55, 0x6e, 0x5e,
4330         0x6a, 0x3d, 0xd1, 0x66, 0xe1, 0x0a, 0x6d, 0x6a, 0xbf, 0x50, 0x60, 0x55, 0xc4, 0xf7, 0xff, 0xbb,
4331         0xd2, 0x2a, 0x37, 0x0c, 0xeb, 0xe5, 0x1b, 0x5d, 0x1e, 0xfd, 0xbf, 0xf4, 0x34, 0x6d, 0x08, 0xcd,
4332         0x44, 0x7d, 0x37, 0x50, 0xfb, 0x15, 0x46, 0xfc, 0x8b, 0x02, 0x34, 0x06, 0xec, 0xe5, 0x92, 0x20,
4333         0x5a, 0xbe, 0xee, 0x71, 0x7c, 0x98, 0x2b, 0x57, 0x1b, 0xdb, 0xeb, 0x59, 0x19, 0xc4, 0xd5, 0x63,
4334         0x52, 0xc1, 0xa6, 0xb7, 0xa8, 0xca, 0xf2, 0x5b, 0xd4, 0xd2, 0x62, 0xb7, 0x9e, 0xb9, 0xc5, 0x2b,
4335         0x2e, 0xbb, 0xc5, 0xd3, 0xfe, 0xad, 0x08, 0x0d, 0x6c, 0x90, 0x29, 0x8b, 0xe6, 0xd3, 0x38, 0x27,
4336         0x4c, 0xe1, 0x6a, 0x61, 0x3a, 0x50, 0x09, 0x71, 0x92, 0x74, 0xa5, 0x4b, 0x83, 0xbf, 0x40, 0x61,
4337         0x6b, 0xfc, 0xdc, 0x0d, 0x02, 0xe6, 0x58, 0x82, 0x92, 0x14, 0x30, 0x4d, 0x49, 0x16, 0x22, 0x44,
4338         0xbc, 0xfc, 0x9c, 0xf9, 0x21, 0x4b, 0x51, 0x45, 0xbc, 0x4f, 0x68, 0x70, 0x5a, 0x02, 0xc9, 0xdd,
4339         0x37, 0x88, 0xca, 0xe0, 0xfc, 0xbe, 0x21, 0xed, 0x35, 0x91, 0x5b, 0x47, 0xae, 0xe8, 0x35, 0x91,
4340         0xcd, 0xbb, 0xa8, 0x99, 0x3d, 0x9d, 0x5a, 0x7e, 0x10, 0xa1, 0xd3, 0xd4, 0x68, 0x0d, 0x09, 0xc3,
4341         0x20, 0x22, 0x5f, 0x43, 0x7a, 0x5d, 0x2c, 0x6f, 0xc9, 0xc5, 0x39, 0xb6, 0x2e, 0xbb, 0x58, 0xa0,
4342         0xab, 0xe3, 0xdc, 0xfd, 0xcf, 0x92, 0x1b, 0xea, 0xca, 0x4d, 0x6f, 0xa8, 0x1f, 0x42, 0x59, 0xc4,
4343         0xa8, 0xda, 0xeb, 0x62, 0x94, 0xc0, 0x65, 0xed, 0xb3, 0x91, 0xb7, 0xcf, 0x5f, 0x16, 0x80, 0x74,
4344         0xa7, 0x53, 0x7f, 0x6c, 0xc7, 0xcc, 0x70, 0xa2, 0x8b, 0x66, 0x7a, 0xed, 0xcf, 0x2e, 0x9f, 0x41,
4345         0x7d, 0xe6, 0x3b, 0x6c, 0x6a, 0x25, 0xdf, 0x94, 0x2e, 0xad, 0x7e, 0x10, 0xc6, 0x5b, 0x52, 0x02,
4346         0x25, 0xbc, 0xc4, 0x51, 0xb0, 0xee, 0xc0, 0x67, 0xde, 0x84, 0xcd, 0xec, 0x97, 0xb2, 0x14, 0xe1,
4347         0x8f, 0xa4, 0x03, 0xd5, 0x90, 0x45, 0x2c, 0x3c, 0x65, 0x57, 0x16, 0x55, 0x09, 0x48, 0x7b, 0x06,
4348         0x1b, 0xb9, 0x1d, 0x49, 0x47, 0xbe, 0x85, 0x5f, 0x2b, 0xc3, 0x58, 0x7e, 0xb4, 0x12, 0x03, 0xfe,
4349         0x3a, 0xe6, 0x25, 0x9f, 0x41, 0xf9, 0x63, 0xea, 0xf0, 0xc5, 0xab, 0xe2, 0xec, 0x1e, 0xa8, 0x59,
4350         0x4d, 0xbb, 0x63, 0x0c, 0x36, 0xf2, 0x54, 0x0a, 0xd7, 0x3b, 0x15, 0xed, 0xef, 0x0a, 0xb0, 0xde,
4351         0x75, 0x1c, 0xf1, 0x77, 0xc3, 0x25, 0xaa, 0x2f, 0x5e, 0x57, 0xf5, 0x0b, 0x81, 0x58, 0x84, 0x89,
4352         0x6b, 0x05, 0xe2, 0x0f, 0xa1, 0x92, 0xd6, 0x5a, 0xc5, 0x05, 0x77, 0x16, 0x72, 0x51, 0x09, 0xd0,
4353         0x6e, 0x01, 0xc9, 0x0a, 0x2b, 0xb4, 0xaa, 0xfd, 0x69, 0x11, 0xee, 0xee, 0xb2, 0x63, 0xd7, 0xcb,
4354         0xbe, 0xe2, 0x57, 0xdf, 0xc9, 0xc5, 0x4f, 0x65, 0x9f, 0xc1, 0xba, 0x28, 0xe4, 0x93, 0x7f, 0x62,
4355         0x59, 0xec, 0x58, 0x7e, 0x9d, 0x94, 0xb1, 0x6a, 0x0d, 0xf9, 0x07, 0x92, 0xad, 0xe3, 0x7f, 0xc5,
4356         0x1c, 0x3b, 0xb6, 0x9f, 0xd9, 0x11, 0xb3, 0x5c, 0x47, 0xfe, 0x59, 0x06, 0x12, 0x92, 0xe1, 0x90,
4357         0x21, 0x94, 0xb8, 0x0d, 0xa2, 0xeb, 0x36, 0xb7, 0xb7, 0x33, 0x62, 0x5d, 0xb2, 0x95, 0xac, 0x02,
4358         0x0f, 0x7c, 0x87, 0xed, 0x54, 0x8f, 0x06, 0x4f, 0x06, 0xc3, 0xef, 0x06, 0x14, 0x17, 0x22, 0x06,
4359         0xdc, 0x0a, 0x42, 0x76, 0xea, 0xfa, 0xf3, 0xc8, 0xca, 0x9e, 0x44, 0xf5, 0xca, 0x94, 0xb8, 0x91,
4360         0xcc, 0xc9, 0x10, 0xb5, 0x9f, 0xc2, 0xda, 0xc2, 0xcb, 0x78, 0x6d, 0x26, 0x5f, 0xa7, 0xbe, 0x41,
4361         0x56, 0xa1, 0x8e, 0x1f, 0xbb, 0x97, 0x7f, 0xfb, 0xd6, 0xfe, 0xb5, 0x80, 0x57, 0x4c, 0x33, 0x37,
4362         0xbe, 0x59, 0x06, 0xfb, 0xcd, 0x7c, 0x06, 0x83, 0xed, 0x77, 0xf3, 0xe6, 0x9b, 0x59, 0xb0, 0xf3,
4363         0xad, 0x00, 0xa6, 0x41, 0xa4, 0x6d, 0x43, 0x55, 0xd2, 0xc8, 0x6f, 0xc1, 0x5a, 0xe8, 0xfb, 0x71,
4364         0xd2, 0x89, 0x8a, 0x0e, 0xe4, 0xf2, 0x3f, 0xdb, 0xac, 0x72, 0xb0, 0x48, 0x06, 0x4f, 0xf2, 0xbd,
4365         0x48, 0x59, 0xfc, 0x0d, 0x44, 0x0e, 0x77, 0x1b, 0xbf, 0x5b, 0x4f, 0xff, 0xb7, 0xfb, 0xbf, 0x01,
4366         0x00, 0x00, 0xff, 0xff, 0x35, 0x9f, 0x30, 0x98, 0xf2, 0x2b, 0x00, 0x00,
4367 }