github.com/cockroachdb/cockroach@v20.2.0-alpha.1+incompatible/pkg/kv/kvserver/kvserverpb/liveness.pb.go (about)

     1  // Code generated by protoc-gen-gogo. DO NOT EDIT.
     2  // source: kv/kvserver/kvserverpb/liveness.proto
     3  
     4  package kvserverpb
     5  
     6  import proto "github.com/gogo/protobuf/proto"
     7  import fmt "fmt"
     8  import math "math"
     9  import hlc "github.com/cockroachdb/cockroach/pkg/util/hlc"
    10  
    11  import github_com_cockroachdb_cockroach_pkg_roachpb "github.com/cockroachdb/cockroach/pkg/roachpb"
    12  
    13  import io "io"
    14  
    15  // Reference imports to suppress errors if they are not otherwise used.
    16  var _ = proto.Marshal
    17  var _ = fmt.Errorf
    18  var _ = math.Inf
    19  
    20  // This is a compile-time assertion to ensure that this generated file
    21  // is compatible with the proto package it is being compiled against.
    22  // A compilation error at this line likely means your copy of the
    23  // proto package needs to be updated.
    24  const _ = proto.GoGoProtoPackageIsVersion2 // please upgrade the proto package
    25  
    26  // NodeLivenessStatus describes the status of a node from the perspective of the
    27  // liveness system.
    28  //
    29  // See comment on LivenessStatus() for a description of the states.
    30  type NodeLivenessStatus int32
    31  
    32  const (
    33  	NodeLivenessStatus_UNKNOWN NodeLivenessStatus = 0
    34  	// DEAD indicates the node is considered dead.
    35  	NodeLivenessStatus_DEAD NodeLivenessStatus = 1
    36  	// UNAVAILABLE indicates that the node is unavailable - it has not updated its
    37  	// liveness record recently enough to be considered live, but has not been
    38  	// unavailable long enough to be considered dead.
    39  	NodeLivenessStatus_UNAVAILABLE NodeLivenessStatus = 2
    40  	// LIVE indicates a live node.
    41  	NodeLivenessStatus_LIVE NodeLivenessStatus = 3
    42  	// DECOMMISSIONING indicates a node that is in the decommissioning process.
    43  	NodeLivenessStatus_DECOMMISSIONING NodeLivenessStatus = 4
    44  	// DECOMMISSIONED indicates a node that has finished the decommissioning
    45  	// process.
    46  	NodeLivenessStatus_DECOMMISSIONED NodeLivenessStatus = 5
    47  )
    48  
    49  var NodeLivenessStatus_name = map[int32]string{
    50  	0: "UNKNOWN",
    51  	1: "DEAD",
    52  	2: "UNAVAILABLE",
    53  	3: "LIVE",
    54  	4: "DECOMMISSIONING",
    55  	5: "DECOMMISSIONED",
    56  }
    57  var NodeLivenessStatus_value = map[string]int32{
    58  	"UNKNOWN":         0,
    59  	"DEAD":            1,
    60  	"UNAVAILABLE":     2,
    61  	"LIVE":            3,
    62  	"DECOMMISSIONING": 4,
    63  	"DECOMMISSIONED":  5,
    64  }
    65  
    66  func (x NodeLivenessStatus) String() string {
    67  	return proto.EnumName(NodeLivenessStatus_name, int32(x))
    68  }
    69  func (NodeLivenessStatus) EnumDescriptor() ([]byte, []int) {
    70  	return fileDescriptor_liveness_46a42aaa6ca100bc, []int{0}
    71  }
    72  
    73  // Liveness holds information about a node's latest heartbeat and epoch.
    74  //
    75  // NOTE: Care must be taken when changing the encoding of this proto
    76  // because it is used as part of conditional put operations.
    77  type Liveness struct {
    78  	NodeID github_com_cockroachdb_cockroach_pkg_roachpb.NodeID `protobuf:"varint,1,opt,name=node_id,json=nodeId,proto3,casttype=github.com/cockroachdb/cockroach/pkg/roachpb.NodeID" json:"node_id,omitempty"`
    79  	// Epoch is a monotonically-increasing value for node liveness. It
    80  	// may be incremented if the liveness record expires (current time
    81  	// is later than the expiration timestamp).
    82  	Epoch int64 `protobuf:"varint,2,opt,name=epoch,proto3" json:"epoch,omitempty"`
    83  	// The timestamp at which this liveness record expires. The logical part of
    84  	// this timestamp is zero.
    85  	//
    86  	// Note that the clock max offset is not accounted for in any way when this
    87  	// expiration is set. If a checker wants to be extra-optimistic about another
    88  	// node being alive, it can adjust for the max offset. liveness.IsLive()
    89  	// doesn't do that, however. The expectation is that the expiration duration
    90  	// is large in comparison to the max offset, and that nodes heartbeat their
    91  	// liveness records well in advance of this expiration, so the optimism or
    92  	// pessimism of a checker does not matter very much.
    93  	Expiration      hlc.LegacyTimestamp `protobuf:"bytes,3,opt,name=expiration,proto3" json:"expiration"`
    94  	Draining        bool                `protobuf:"varint,4,opt,name=draining,proto3" json:"draining,omitempty"`
    95  	Decommissioning bool                `protobuf:"varint,5,opt,name=decommissioning,proto3" json:"decommissioning,omitempty"`
    96  }
    97  
    98  func (m *Liveness) Reset()         { *m = Liveness{} }
    99  func (m *Liveness) String() string { return proto.CompactTextString(m) }
   100  func (*Liveness) ProtoMessage()    {}
   101  func (*Liveness) Descriptor() ([]byte, []int) {
   102  	return fileDescriptor_liveness_46a42aaa6ca100bc, []int{0}
   103  }
   104  func (m *Liveness) XXX_Unmarshal(b []byte) error {
   105  	return m.Unmarshal(b)
   106  }
   107  func (m *Liveness) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
   108  	b = b[:cap(b)]
   109  	n, err := m.MarshalTo(b)
   110  	if err != nil {
   111  		return nil, err
   112  	}
   113  	return b[:n], nil
   114  }
   115  func (dst *Liveness) XXX_Merge(src proto.Message) {
   116  	xxx_messageInfo_Liveness.Merge(dst, src)
   117  }
   118  func (m *Liveness) XXX_Size() int {
   119  	return m.Size()
   120  }
   121  func (m *Liveness) XXX_DiscardUnknown() {
   122  	xxx_messageInfo_Liveness.DiscardUnknown(m)
   123  }
   124  
   125  var xxx_messageInfo_Liveness proto.InternalMessageInfo
   126  
   127  func init() {
   128  	proto.RegisterType((*Liveness)(nil), "cockroach.kv.kvserver.storagepb.Liveness")
   129  	proto.RegisterEnum("cockroach.kv.kvserver.storagepb.NodeLivenessStatus", NodeLivenessStatus_name, NodeLivenessStatus_value)
   130  }
   131  func (m *Liveness) Marshal() (dAtA []byte, err error) {
   132  	size := m.Size()
   133  	dAtA = make([]byte, size)
   134  	n, err := m.MarshalTo(dAtA)
   135  	if err != nil {
   136  		return nil, err
   137  	}
   138  	return dAtA[:n], nil
   139  }
   140  
   141  func (m *Liveness) MarshalTo(dAtA []byte) (int, error) {
   142  	var i int
   143  	_ = i
   144  	var l int
   145  	_ = l
   146  	if m.NodeID != 0 {
   147  		dAtA[i] = 0x8
   148  		i++
   149  		i = encodeVarintLiveness(dAtA, i, uint64(m.NodeID))
   150  	}
   151  	if m.Epoch != 0 {
   152  		dAtA[i] = 0x10
   153  		i++
   154  		i = encodeVarintLiveness(dAtA, i, uint64(m.Epoch))
   155  	}
   156  	dAtA[i] = 0x1a
   157  	i++
   158  	i = encodeVarintLiveness(dAtA, i, uint64(m.Expiration.Size()))
   159  	n1, err := m.Expiration.MarshalTo(dAtA[i:])
   160  	if err != nil {
   161  		return 0, err
   162  	}
   163  	i += n1
   164  	if m.Draining {
   165  		dAtA[i] = 0x20
   166  		i++
   167  		if m.Draining {
   168  			dAtA[i] = 1
   169  		} else {
   170  			dAtA[i] = 0
   171  		}
   172  		i++
   173  	}
   174  	if m.Decommissioning {
   175  		dAtA[i] = 0x28
   176  		i++
   177  		if m.Decommissioning {
   178  			dAtA[i] = 1
   179  		} else {
   180  			dAtA[i] = 0
   181  		}
   182  		i++
   183  	}
   184  	return i, nil
   185  }
   186  
   187  func encodeVarintLiveness(dAtA []byte, offset int, v uint64) int {
   188  	for v >= 1<<7 {
   189  		dAtA[offset] = uint8(v&0x7f | 0x80)
   190  		v >>= 7
   191  		offset++
   192  	}
   193  	dAtA[offset] = uint8(v)
   194  	return offset + 1
   195  }
   196  func NewPopulatedLiveness(r randyLiveness, easy bool) *Liveness {
   197  	this := &Liveness{}
   198  	this.NodeID = github_com_cockroachdb_cockroach_pkg_roachpb.NodeID(r.Int31())
   199  	if r.Intn(2) == 0 {
   200  		this.NodeID *= -1
   201  	}
   202  	this.Epoch = int64(r.Int63())
   203  	if r.Intn(2) == 0 {
   204  		this.Epoch *= -1
   205  	}
   206  	v1 := hlc.NewPopulatedLegacyTimestamp(r, easy)
   207  	this.Expiration = *v1
   208  	this.Draining = bool(bool(r.Intn(2) == 0))
   209  	this.Decommissioning = bool(bool(r.Intn(2) == 0))
   210  	if !easy && r.Intn(10) != 0 {
   211  	}
   212  	return this
   213  }
   214  
   215  type randyLiveness interface {
   216  	Float32() float32
   217  	Float64() float64
   218  	Int63() int64
   219  	Int31() int32
   220  	Uint32() uint32
   221  	Intn(n int) int
   222  }
   223  
   224  func randUTF8RuneLiveness(r randyLiveness) rune {
   225  	ru := r.Intn(62)
   226  	if ru < 10 {
   227  		return rune(ru + 48)
   228  	} else if ru < 36 {
   229  		return rune(ru + 55)
   230  	}
   231  	return rune(ru + 61)
   232  }
   233  func randStringLiveness(r randyLiveness) string {
   234  	v2 := r.Intn(100)
   235  	tmps := make([]rune, v2)
   236  	for i := 0; i < v2; i++ {
   237  		tmps[i] = randUTF8RuneLiveness(r)
   238  	}
   239  	return string(tmps)
   240  }
   241  func randUnrecognizedLiveness(r randyLiveness, maxFieldNumber int) (dAtA []byte) {
   242  	l := r.Intn(5)
   243  	for i := 0; i < l; i++ {
   244  		wire := r.Intn(4)
   245  		if wire == 3 {
   246  			wire = 5
   247  		}
   248  		fieldNumber := maxFieldNumber + r.Intn(100)
   249  		dAtA = randFieldLiveness(dAtA, r, fieldNumber, wire)
   250  	}
   251  	return dAtA
   252  }
   253  func randFieldLiveness(dAtA []byte, r randyLiveness, fieldNumber int, wire int) []byte {
   254  	key := uint32(fieldNumber)<<3 | uint32(wire)
   255  	switch wire {
   256  	case 0:
   257  		dAtA = encodeVarintPopulateLiveness(dAtA, uint64(key))
   258  		v3 := r.Int63()
   259  		if r.Intn(2) == 0 {
   260  			v3 *= -1
   261  		}
   262  		dAtA = encodeVarintPopulateLiveness(dAtA, uint64(v3))
   263  	case 1:
   264  		dAtA = encodeVarintPopulateLiveness(dAtA, uint64(key))
   265  		dAtA = append(dAtA, byte(r.Intn(256)), byte(r.Intn(256)), byte(r.Intn(256)), byte(r.Intn(256)), byte(r.Intn(256)), byte(r.Intn(256)), byte(r.Intn(256)), byte(r.Intn(256)))
   266  	case 2:
   267  		dAtA = encodeVarintPopulateLiveness(dAtA, uint64(key))
   268  		ll := r.Intn(100)
   269  		dAtA = encodeVarintPopulateLiveness(dAtA, uint64(ll))
   270  		for j := 0; j < ll; j++ {
   271  			dAtA = append(dAtA, byte(r.Intn(256)))
   272  		}
   273  	default:
   274  		dAtA = encodeVarintPopulateLiveness(dAtA, uint64(key))
   275  		dAtA = append(dAtA, byte(r.Intn(256)), byte(r.Intn(256)), byte(r.Intn(256)), byte(r.Intn(256)))
   276  	}
   277  	return dAtA
   278  }
   279  func encodeVarintPopulateLiveness(dAtA []byte, v uint64) []byte {
   280  	for v >= 1<<7 {
   281  		dAtA = append(dAtA, uint8(uint64(v)&0x7f|0x80))
   282  		v >>= 7
   283  	}
   284  	dAtA = append(dAtA, uint8(v))
   285  	return dAtA
   286  }
   287  func (m *Liveness) Size() (n int) {
   288  	if m == nil {
   289  		return 0
   290  	}
   291  	var l int
   292  	_ = l
   293  	if m.NodeID != 0 {
   294  		n += 1 + sovLiveness(uint64(m.NodeID))
   295  	}
   296  	if m.Epoch != 0 {
   297  		n += 1 + sovLiveness(uint64(m.Epoch))
   298  	}
   299  	l = m.Expiration.Size()
   300  	n += 1 + l + sovLiveness(uint64(l))
   301  	if m.Draining {
   302  		n += 2
   303  	}
   304  	if m.Decommissioning {
   305  		n += 2
   306  	}
   307  	return n
   308  }
   309  
   310  func sovLiveness(x uint64) (n int) {
   311  	for {
   312  		n++
   313  		x >>= 7
   314  		if x == 0 {
   315  			break
   316  		}
   317  	}
   318  	return n
   319  }
   320  func sozLiveness(x uint64) (n int) {
   321  	return sovLiveness(uint64((x << 1) ^ uint64((int64(x) >> 63))))
   322  }
   323  func (m *Liveness) Unmarshal(dAtA []byte) error {
   324  	l := len(dAtA)
   325  	iNdEx := 0
   326  	for iNdEx < l {
   327  		preIndex := iNdEx
   328  		var wire uint64
   329  		for shift := uint(0); ; shift += 7 {
   330  			if shift >= 64 {
   331  				return ErrIntOverflowLiveness
   332  			}
   333  			if iNdEx >= l {
   334  				return io.ErrUnexpectedEOF
   335  			}
   336  			b := dAtA[iNdEx]
   337  			iNdEx++
   338  			wire |= (uint64(b) & 0x7F) << shift
   339  			if b < 0x80 {
   340  				break
   341  			}
   342  		}
   343  		fieldNum := int32(wire >> 3)
   344  		wireType := int(wire & 0x7)
   345  		if wireType == 4 {
   346  			return fmt.Errorf("proto: Liveness: wiretype end group for non-group")
   347  		}
   348  		if fieldNum <= 0 {
   349  			return fmt.Errorf("proto: Liveness: illegal tag %d (wire type %d)", fieldNum, wire)
   350  		}
   351  		switch fieldNum {
   352  		case 1:
   353  			if wireType != 0 {
   354  				return fmt.Errorf("proto: wrong wireType = %d for field NodeID", wireType)
   355  			}
   356  			m.NodeID = 0
   357  			for shift := uint(0); ; shift += 7 {
   358  				if shift >= 64 {
   359  					return ErrIntOverflowLiveness
   360  				}
   361  				if iNdEx >= l {
   362  					return io.ErrUnexpectedEOF
   363  				}
   364  				b := dAtA[iNdEx]
   365  				iNdEx++
   366  				m.NodeID |= (github_com_cockroachdb_cockroach_pkg_roachpb.NodeID(b) & 0x7F) << shift
   367  				if b < 0x80 {
   368  					break
   369  				}
   370  			}
   371  		case 2:
   372  			if wireType != 0 {
   373  				return fmt.Errorf("proto: wrong wireType = %d for field Epoch", wireType)
   374  			}
   375  			m.Epoch = 0
   376  			for shift := uint(0); ; shift += 7 {
   377  				if shift >= 64 {
   378  					return ErrIntOverflowLiveness
   379  				}
   380  				if iNdEx >= l {
   381  					return io.ErrUnexpectedEOF
   382  				}
   383  				b := dAtA[iNdEx]
   384  				iNdEx++
   385  				m.Epoch |= (int64(b) & 0x7F) << shift
   386  				if b < 0x80 {
   387  					break
   388  				}
   389  			}
   390  		case 3:
   391  			if wireType != 2 {
   392  				return fmt.Errorf("proto: wrong wireType = %d for field Expiration", wireType)
   393  			}
   394  			var msglen int
   395  			for shift := uint(0); ; shift += 7 {
   396  				if shift >= 64 {
   397  					return ErrIntOverflowLiveness
   398  				}
   399  				if iNdEx >= l {
   400  					return io.ErrUnexpectedEOF
   401  				}
   402  				b := dAtA[iNdEx]
   403  				iNdEx++
   404  				msglen |= (int(b) & 0x7F) << shift
   405  				if b < 0x80 {
   406  					break
   407  				}
   408  			}
   409  			if msglen < 0 {
   410  				return ErrInvalidLengthLiveness
   411  			}
   412  			postIndex := iNdEx + msglen
   413  			if postIndex > l {
   414  				return io.ErrUnexpectedEOF
   415  			}
   416  			if err := m.Expiration.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
   417  				return err
   418  			}
   419  			iNdEx = postIndex
   420  		case 4:
   421  			if wireType != 0 {
   422  				return fmt.Errorf("proto: wrong wireType = %d for field Draining", wireType)
   423  			}
   424  			var v int
   425  			for shift := uint(0); ; shift += 7 {
   426  				if shift >= 64 {
   427  					return ErrIntOverflowLiveness
   428  				}
   429  				if iNdEx >= l {
   430  					return io.ErrUnexpectedEOF
   431  				}
   432  				b := dAtA[iNdEx]
   433  				iNdEx++
   434  				v |= (int(b) & 0x7F) << shift
   435  				if b < 0x80 {
   436  					break
   437  				}
   438  			}
   439  			m.Draining = bool(v != 0)
   440  		case 5:
   441  			if wireType != 0 {
   442  				return fmt.Errorf("proto: wrong wireType = %d for field Decommissioning", wireType)
   443  			}
   444  			var v int
   445  			for shift := uint(0); ; shift += 7 {
   446  				if shift >= 64 {
   447  					return ErrIntOverflowLiveness
   448  				}
   449  				if iNdEx >= l {
   450  					return io.ErrUnexpectedEOF
   451  				}
   452  				b := dAtA[iNdEx]
   453  				iNdEx++
   454  				v |= (int(b) & 0x7F) << shift
   455  				if b < 0x80 {
   456  					break
   457  				}
   458  			}
   459  			m.Decommissioning = bool(v != 0)
   460  		default:
   461  			iNdEx = preIndex
   462  			skippy, err := skipLiveness(dAtA[iNdEx:])
   463  			if err != nil {
   464  				return err
   465  			}
   466  			if skippy < 0 {
   467  				return ErrInvalidLengthLiveness
   468  			}
   469  			if (iNdEx + skippy) > l {
   470  				return io.ErrUnexpectedEOF
   471  			}
   472  			iNdEx += skippy
   473  		}
   474  	}
   475  
   476  	if iNdEx > l {
   477  		return io.ErrUnexpectedEOF
   478  	}
   479  	return nil
   480  }
   481  func skipLiveness(dAtA []byte) (n int, err error) {
   482  	l := len(dAtA)
   483  	iNdEx := 0
   484  	for iNdEx < l {
   485  		var wire uint64
   486  		for shift := uint(0); ; shift += 7 {
   487  			if shift >= 64 {
   488  				return 0, ErrIntOverflowLiveness
   489  			}
   490  			if iNdEx >= l {
   491  				return 0, io.ErrUnexpectedEOF
   492  			}
   493  			b := dAtA[iNdEx]
   494  			iNdEx++
   495  			wire |= (uint64(b) & 0x7F) << shift
   496  			if b < 0x80 {
   497  				break
   498  			}
   499  		}
   500  		wireType := int(wire & 0x7)
   501  		switch wireType {
   502  		case 0:
   503  			for shift := uint(0); ; shift += 7 {
   504  				if shift >= 64 {
   505  					return 0, ErrIntOverflowLiveness
   506  				}
   507  				if iNdEx >= l {
   508  					return 0, io.ErrUnexpectedEOF
   509  				}
   510  				iNdEx++
   511  				if dAtA[iNdEx-1] < 0x80 {
   512  					break
   513  				}
   514  			}
   515  			return iNdEx, nil
   516  		case 1:
   517  			iNdEx += 8
   518  			return iNdEx, nil
   519  		case 2:
   520  			var length int
   521  			for shift := uint(0); ; shift += 7 {
   522  				if shift >= 64 {
   523  					return 0, ErrIntOverflowLiveness
   524  				}
   525  				if iNdEx >= l {
   526  					return 0, io.ErrUnexpectedEOF
   527  				}
   528  				b := dAtA[iNdEx]
   529  				iNdEx++
   530  				length |= (int(b) & 0x7F) << shift
   531  				if b < 0x80 {
   532  					break
   533  				}
   534  			}
   535  			iNdEx += length
   536  			if length < 0 {
   537  				return 0, ErrInvalidLengthLiveness
   538  			}
   539  			return iNdEx, nil
   540  		case 3:
   541  			for {
   542  				var innerWire uint64
   543  				var start int = iNdEx
   544  				for shift := uint(0); ; shift += 7 {
   545  					if shift >= 64 {
   546  						return 0, ErrIntOverflowLiveness
   547  					}
   548  					if iNdEx >= l {
   549  						return 0, io.ErrUnexpectedEOF
   550  					}
   551  					b := dAtA[iNdEx]
   552  					iNdEx++
   553  					innerWire |= (uint64(b) & 0x7F) << shift
   554  					if b < 0x80 {
   555  						break
   556  					}
   557  				}
   558  				innerWireType := int(innerWire & 0x7)
   559  				if innerWireType == 4 {
   560  					break
   561  				}
   562  				next, err := skipLiveness(dAtA[start:])
   563  				if err != nil {
   564  					return 0, err
   565  				}
   566  				iNdEx = start + next
   567  			}
   568  			return iNdEx, nil
   569  		case 4:
   570  			return iNdEx, nil
   571  		case 5:
   572  			iNdEx += 4
   573  			return iNdEx, nil
   574  		default:
   575  			return 0, fmt.Errorf("proto: illegal wireType %d", wireType)
   576  		}
   577  	}
   578  	panic("unreachable")
   579  }
   580  
   581  var (
   582  	ErrInvalidLengthLiveness = fmt.Errorf("proto: negative length found during unmarshaling")
   583  	ErrIntOverflowLiveness   = fmt.Errorf("proto: integer overflow")
   584  )
   585  
   586  func init() {
   587  	proto.RegisterFile("kv/kvserver/kvserverpb/liveness.proto", fileDescriptor_liveness_46a42aaa6ca100bc)
   588  }
   589  
   590  var fileDescriptor_liveness_46a42aaa6ca100bc = []byte{
   591  	// 438 bytes of a gzipped FileDescriptorProto
   592  	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x5c, 0x92, 0x4f, 0x8b, 0x9b, 0x40,
   593  	0x18, 0xc6, 0x9d, 0xc4, 0x64, 0xc3, 0x04, 0x1a, 0x99, 0xee, 0x21, 0xe4, 0xa0, 0xa1, 0xa5, 0x20,
   594  	0xa5, 0x8c, 0xd0, 0xbd, 0xf5, 0x66, 0xaa, 0x14, 0xa9, 0x6b, 0x20, 0xe9, 0x6e, 0x61, 0x2f, 0x8b,
   595  	0x8e, 0x83, 0x0e, 0xfe, 0x19, 0xd1, 0x89, 0xb4, 0xdf, 0xa2, 0xd0, 0x2f, 0xd0, 0x8f, 0xd1, 0x8f,
   596  	0x90, 0xe3, 0x1e, 0xf7, 0x14, 0x5a, 0xf3, 0x2d, 0x7a, 0x2a, 0x9a, 0x26, 0x59, 0x7a, 0xfb, 0xbd,
   597  	0x8f, 0xcf, 0xfb, 0xfa, 0x3e, 0x33, 0x03, 0x5f, 0x25, 0xb5, 0x91, 0xd4, 0x15, 0x2d, 0x6b, 0x5a,
   598  	0x9e, 0xa0, 0x08, 0x8c, 0x94, 0xd5, 0x34, 0xa7, 0x55, 0x85, 0x8b, 0x92, 0x0b, 0x8e, 0x34, 0xc2,
   599  	0x49, 0x52, 0x72, 0x9f, 0xc4, 0x38, 0xa9, 0xf1, 0xd1, 0x87, 0x2b, 0xc1, 0x4b, 0x3f, 0xa2, 0x45,
   600  	0x30, 0xd3, 0x36, 0x82, 0xa5, 0x46, 0x9c, 0x12, 0x23, 0xa5, 0x91, 0x4f, 0xbe, 0xde, 0x0b, 0x96,
   601  	0xd1, 0x4a, 0xf8, 0x59, 0x71, 0x98, 0x30, 0xbb, 0x8c, 0x78, 0xc4, 0x3b, 0x34, 0x5a, 0x3a, 0xa8,
   602  	0x2f, 0xbe, 0xf7, 0xe0, 0xc8, 0xfd, 0xf7, 0x2b, 0x74, 0x07, 0x2f, 0x72, 0x1e, 0xd2, 0x7b, 0x16,
   603  	0x4e, 0xc1, 0x1c, 0xe8, 0x83, 0x85, 0xd9, 0xec, 0xb4, 0xa1, 0xc7, 0x43, 0xea, 0x58, 0x7f, 0x76,
   604  	0xda, 0x55, 0xc4, 0x44, 0xbc, 0x09, 0x30, 0xe1, 0x99, 0x71, 0x5a, 0x27, 0x0c, 0xce, 0x6c, 0x14,
   605  	0x49, 0x64, 0x74, 0x54, 0x04, 0xf8, 0xd0, 0xb6, 0x1a, 0xb6, 0x13, 0x9d, 0x10, 0x5d, 0xc2, 0x01,
   606  	0x2d, 0x38, 0x89, 0xa7, 0xbd, 0x39, 0xd0, 0xfb, 0xab, 0x43, 0x81, 0x1c, 0x08, 0xe9, 0x97, 0x82,
   607  	0x95, 0xbe, 0x60, 0x3c, 0x9f, 0xf6, 0xe7, 0x40, 0x1f, 0xbf, 0x7d, 0x89, 0xcf, 0x59, 0xdb, 0x50,
   608  	0x38, 0x4e, 0x09, 0x76, 0xbb, 0x50, 0x9f, 0x8e, 0x99, 0x16, 0xf2, 0x76, 0xa7, 0x49, 0xab, 0x27,
   609  	0xcd, 0x68, 0x06, 0x47, 0x61, 0xe9, 0xb3, 0x9c, 0xe5, 0xd1, 0x54, 0x9e, 0x03, 0x7d, 0xb4, 0x3a,
   610  	0xd5, 0x48, 0x87, 0x93, 0x90, 0x12, 0x9e, 0x65, 0xac, 0xaa, 0x18, 0xef, 0x2c, 0x83, 0xce, 0xf2,
   611  	0xbf, 0xfc, 0x4e, 0xfe, 0xf9, 0x43, 0x03, 0xaf, 0x39, 0x44, 0xed, 0xfa, 0xc7, 0x83, 0x59, 0x0b,
   612  	0x5f, 0x6c, 0x2a, 0x34, 0x86, 0x17, 0x37, 0xde, 0x47, 0x6f, 0xf9, 0xd9, 0x53, 0x24, 0x34, 0x82,
   613  	0xb2, 0x65, 0x9b, 0x96, 0x02, 0xd0, 0x04, 0x8e, 0x6f, 0x3c, 0xf3, 0xd6, 0x74, 0x5c, 0x73, 0xe1,
   614  	0xda, 0x4a, 0xaf, 0xfd, 0xe4, 0x3a, 0xb7, 0xb6, 0xd2, 0x47, 0xcf, 0xe1, 0xc4, 0xb2, 0xdf, 0x2f,
   615  	0xaf, 0xaf, 0x9d, 0xf5, 0xda, 0x59, 0x7a, 0x8e, 0xf7, 0x41, 0x91, 0x11, 0x82, 0xcf, 0x9e, 0x8a,
   616  	0xb6, 0xa5, 0x0c, 0x16, 0x6f, 0xb6, 0xbf, 0x55, 0x69, 0xdb, 0xa8, 0xe0, 0xa1, 0x51, 0xc1, 0x63,
   617  	0xa3, 0x82, 0x5f, 0x8d, 0x0a, 0xbe, 0xed, 0x55, 0xe9, 0x61, 0xaf, 0x4a, 0x8f, 0x7b, 0x55, 0xba,
   618  	0x83, 0xe7, 0xb7, 0x11, 0x0c, 0xbb, 0xbb, 0xbb, 0xfa, 0x1b, 0x00, 0x00, 0xff, 0xff, 0xdb, 0xac,
   619  	0x23, 0xc6, 0x3c, 0x02, 0x00, 0x00,
   620  }