text: // Code generated by protoc-gen-gogo.
  // source: empty.proto
  // DO NOT EDIT!
  
  /*
  Package types is a generated protocol buffer package.
  
  It is generated from these files:
  	empty.proto
  
  It has these top-level messages:
  	Empty
  */
  package types
  
  import proto "github.com/gogo/protobuf/proto"
  import fmt "fmt"
  import math "math"
  
  import strings "strings"
  import github_com_gogo_protobuf_proto "github.com/gogo/protobuf/proto"
  import sort "sort"
  import strconv "strconv"
  import reflect "reflect"
  
  import io "io"
  
  // Reference imports to suppress errors if they are not otherwise used.
  var _ = proto.Marshal
  var _ = fmt.Errorf
  var _ = math.Inf
  
  // This is a compile-time assertion to ensure that this generated file
  // is compatible with the proto package it is being compiled against.
  // A compilation error at this line likely means your copy of the
  // proto package needs to be updated.
  const _ = proto.GoGoProtoPackageIsVersion2 // please upgrade the proto package
  
  // A generic empty message that you can re-use to avoid defining duplicated
  // empty messages in your APIs. A typical example is to use it as the request
  // or the response type of an API method. For instance:
  //
  //     service Foo {
  //       rpc Bar(google.protobuf.Empty) returns (google.protobuf.Empty);
  //     }
  //
  // The JSON representation for `Empty` is empty JSON object `{}`.
  type Empty struct {
  }
  
  func (m *Empty) Reset()                    { *m = Empty{} }
  func (*Empty) ProtoMessage()               {}
  func (*Empty) Descriptor() ([]byte, []int) { return fileDescriptorEmpty, []int{0} }
  func (*Empty) XXX_WellKnownType() string   { return "Empty" }
  
  func init() {
  	proto.RegisterType((*Empty)(nil), "google.protobuf.Empty")
  }
  func (this *Empty) Equal(that interface{}) bool {
  	if that == nil {
  		if this == nil {
  			return true
  		}
  		return false
  	}
  
  	that1, ok := that.(*Empty)
  	if !ok {
  		that2, ok := that.(Empty)
  		if ok {
  			that1 = &that2
  		} else {
  			return false
  		}
  	}
  	if that1 == nil {
  		if this == nil {
  			return true
  		}
  		return false
  	} else if this == nil {
  		return false
  	}
  	return true
  }
  func (this *Empty) GoString() string {
  	if this == nil {
  		return "nil"
  	}
  	s := make([]string, 0, 4)
  	s = append(s, "&types.Empty{")
  	s = append(s, "}")
  	return strings.Join(s, "")
  }
  func valueToGoStringEmpty(v interface{}, typ string) string {
  	rv := reflect.ValueOf(v)
  	if rv.IsNil() {
  		return "nil"
  	}
  	pv := reflect.Indirect(rv).Interface()
  	return fmt.Sprintf("func(v %v) *%v { return &v } ( %#v )", typ, typ, pv)
  }
  func extensionToGoStringEmpty(m github_com_gogo_protobuf_proto.Message) string {
  	e := github_com_gogo_protobuf_proto.GetUnsafeExtensionsMap(m)
  	if e == nil {
  		return "nil"
  	}
  	s := "proto.NewUnsafeXXX_InternalExtensions(map[int32]proto.Extension{"
  	keys := make([]int, 0, len(e))
  	for k := range e {
  		keys = append(keys, int(k))
  	}
  	sort.Ints(keys)
  	ss := []string{}
  	for _, k := range keys {
  		ss = append(ss, strconv.Itoa(k)+": "+e[int32(k)].GoString())
  	}
  	s += strings.Join(ss, ",") + "})"
  	return s
  }
  func (m *Empty) Marshal() (dAtA []byte, err error) {
  	size := m.Size()
  	dAtA = make([]byte, size)
  	n, err := m.MarshalTo(dAtA)
  	if err != nil {
  		return nil, err
  	}
  	return dAtA[:n], nil
  }
  
  func (m *Empty) MarshalTo(dAtA []byte) (int, error) {
  	var i int
  	_ = i
  	var l int
  	_ = l
  	return i, nil
  }
  
  func encodeFixed64Empty(dAtA []byte, offset int, v uint64) int {
  	dAtA[offset] = uint8(v)
  	dAtA[offset+1] = uint8(v >> 8)
  	dAtA[offset+2] = uint8(v >> 16)
  	dAtA[offset+3] = uint8(v >> 24)
  	dAtA[offset+4] = uint8(v >> 32)
  	dAtA[offset+5] = uint8(v >> 40)
  	dAtA[offset+6] = uint8(v >> 48)
  	dAtA[offset+7] = uint8(v >> 56)
  	return offset + 8
  }
  func encodeFixed32Empty(dAtA []byte, offset int, v uint32) int {
  	dAtA[offset] = uint8(v)
  	dAtA[offset+1] = uint8(v >> 8)
  	dAtA[offset+2] = uint8(v >> 16)
  	dAtA[offset+3] = uint8(v >> 24)
  	return offset + 4
  }
  func encodeVarintEmpty(dAtA []byte, offset int, v uint64) int {
  	for v >= 1<<7 {
  		dAtA[offset] = uint8(v&0x7f | 0x80)
  		v >>= 7
  		offset++
  	}
  	dAtA[offset] = uint8(v)
  	return offset + 1
  }
  func NewPopulatedEmpty(r randyEmpty, easy bool) *Empty {
  	this := &Empty{}
  	if !easy && r.Intn(10) != 0 {
  	}
  	return this
  }
  
  type randyEmpty interface {
  	Float32() float32
  	Float64() float64
  	Int63() int64
  	Int31() int32
  	Uint32() uint32
  	Intn(n int) int
  }
  
  func randUTF8RuneEmpty(r randyEmpty) rune {
  	ru := r.Intn(62)
  	if ru < 10 {
  		return rune(ru + 48)
  	} else if ru < 36 {
  		return rune(ru + 55)
  	}
  	return rune(ru + 61)
  }
  func randStringEmpty(r randyEmpty) string {
  	v1 := r.Intn(100)
  	tmps := make([]rune, v1)
  	for i := 0; i < v1; i++ {
  		tmps[i] = randUTF8RuneEmpty(r)
  	}
  	return string(tmps)
  }
  func randUnrecognizedEmpty(r randyEmpty, maxFieldNumber int) (dAtA []byte) {
  	l := r.Intn(5)
  	for i := 0; i < l; i++ {
  		wire := r.Intn(4)
  		if wire == 3 {
  			wire = 5
  		}
  		fieldNumber := maxFieldNumber + r.Intn(100)
  		dAtA = randFieldEmpty(dAtA, r, fieldNumber, wire)
  	}
  	return dAtA
  }
  func randFieldEmpty(dAtA []byte, r randyEmpty, fieldNumber int, wire int) []byte {
  	key := uint32(fieldNumber)<<3 | uint32(wire)
  	switch wire {
  	case 0:
  		dAtA = encodeVarintPopulateEmpty(dAtA, uint64(key))
  		v2 := r.Int63()
  		if r.Intn(2) == 0 {
  			v2 *= -1
  		}
  		dAtA = encodeVarintPopulateEmpty(dAtA, uint64(v2))
  	case 1:
  		dAtA = encodeVarintPopulateEmpty(dAtA, uint64(key))
  		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)))
  	case 2:
  		dAtA = encodeVarintPopulateEmpty(dAtA, uint64(key))
  		ll := r.Intn(100)
  		dAtA = encodeVarintPopulateEmpty(dAtA, uint64(ll))
  		for j := 0; j < ll; j++ {
  			dAtA = append(dAtA, byte(r.Intn(256)))
  		}
  	default:
  		dAtA = encodeVarintPopulateEmpty(dAtA, uint64(key))
  		dAtA = append(dAtA, byte(r.Intn(256)), byte(r.Intn(256)), byte(r.Intn(256)), byte(r.Intn(256)))
  	}
  	return dAtA
  }
  func encodeVarintPopulateEmpty(dAtA []byte, v uint64) []byte {
  	for v >= 1<<7 {
  		dAtA = append(dAtA, uint8(uint64(v)&0x7f|0x80))
  		v >>= 7
  	}
  	dAtA = append(dAtA, uint8(v))
  	return dAtA
  }
  func (m *Empty) Size() (n int) {
  	var l int
  	_ = l
  	return n
  }
  
  func sovEmpty(x uint64) (n int) {
  	for {
  		n++
  		x >>= 7
  		if x == 0 {
  			break
  		}
  	}
  	return n
  }
  func sozEmpty(x uint64) (n int) {
  	return sovEmpty(uint64((x << 1) ^ uint64((int64(x) >> 63))))
  }
  func (this *Empty) String() string {
  	if this == nil {
  		return "nil"
  	}
  	s := strings.Join([]string{`&Empty{`,
  		`}`,
  	}, "")
  	return s
  }
  func valueToStringEmpty(v interface{}) string {
  	rv := reflect.ValueOf(v)
  	if rv.IsNil() {
  		return "nil"
  	}
  	pv := reflect.Indirect(rv).Interface()
  	return fmt.Sprintf("*%v", pv)
  }
  func (m *Empty) Unmarshal(dAtA []byte) error {
  	l := len(dAtA)
  	iNdEx := 0
  	for iNdEx < l {
  		preIndex := iNdEx
  		var wire uint64
  		for shift := uint(0); ; shift += 7 {
  			if shift >= 64 {
  				return ErrIntOverflowEmpty
  			}
  			if iNdEx >= l {
  				return io.ErrUnexpectedEOF
  			}
  			b := dAtA[iNdEx]
  			iNdEx++
  			wire |= (uint64(b) & 0x7F) << shift
  			if b < 0x80 {
  				break
  			}
  		}
  		fieldNum := int32(wire >> 3)
  		wireType := int(wire & 0x7)
  		if wireType == 4 {
  			return fmt.Errorf("proto: Empty: wiretype end group for non-group")
  		}
  		if fieldNum <= 0 {
  			return fmt.Errorf("proto: Empty: illegal tag %d (wire type %d)", fieldNum, wire)
  		}
  		switch fieldNum {
  		default:
  			iNdEx = preIndex
  			skippy, err := skipEmpty(dAtA[iNdEx:])
  			if err != nil {
  				return err
  			}
  			if skippy < 0 {
  				return ErrInvalidLengthEmpty
  			}
  			if (iNdEx + skippy) > l {
  				return io.ErrUnexpectedEOF
  			}
  			iNdEx += skippy
  		}
  	}
  
  	if iNdEx > l {
  		return io.ErrUnexpectedEOF
  	}
  	return nil
  }
  func skipEmpty(dAtA []byte) (n int, err error) {
  	l := len(dAtA)
  	iNdEx := 0
  	for iNdEx < l {
  		var wire uint64
  		for shift := uint(0); ; shift += 7 {
  			if shift >= 64 {
  				return 0, ErrIntOverflowEmpty
  			}
  			if iNdEx >= l {
  				return 0, io.ErrUnexpectedEOF
  			}
  			b := dAtA[iNdEx]
  			iNdEx++
  			wire |= (uint64(b) & 0x7F) << shift
  			if b < 0x80 {
  				break
  			}
  		}
  		wireType := int(wire & 0x7)
  		switch wireType {
  		case 0:
  			for shift := uint(0); ; shift += 7 {
  				if shift >= 64 {
  					return 0, ErrIntOverflowEmpty
  				}
  				if iNdEx >= l {
  					return 0, io.ErrUnexpectedEOF
  				}
  				iNdEx++
  				if dAtA[iNdEx-1] < 0x80 {
  					break
  				}
  			}
  			return iNdEx, nil
  		case 1:
  			iNdEx += 8
  			return iNdEx, nil
  		case 2:
  			var length int
  			for shift := uint(0); ; shift += 7 {
  				if shift >= 64 {
  					return 0, ErrIntOverflowEmpty
  				}
  				if iNdEx >= l {
  					return 0, io.ErrUnexpectedEOF
  				}
  				b := dAtA[iNdEx]
  				iNdEx++
  				length |= (int(b) & 0x7F) << shift
  				if b < 0x80 {
  					break
  				}
  			}
  			iNdEx += length
  			if length < 0 {
  				return 0, ErrInvalidLengthEmpty
  			}
  			return iNdEx, nil
  		case 3:
  			for {
  				var innerWire uint64
  				var start int = iNdEx
  				for shift := uint(0); ; shift += 7 {
  					if shift >= 64 {
  						return 0, ErrIntOverflowEmpty
  					}
  					if iNdEx >= l {
  						return 0, io.ErrUnexpectedEOF
  					}
  					b := dAtA[iNdEx]
  					iNdEx++
  					innerWire |= (uint64(b) & 0x7F) << shift
  					if b < 0x80 {
  						break
  					}
  				}
  				innerWireType := int(innerWire & 0x7)
  				if innerWireType == 4 {
  					break
  				}
  				next, err := skipEmpty(dAtA[start:])
  				if err != nil {
  					return 0, err
  				}
  				iNdEx = start + next
  			}
  			return iNdEx, nil
  		case 4:
  			return iNdEx, nil
  		case 5:
  			iNdEx += 4
  			return iNdEx, nil
  		default:
  			return 0, fmt.Errorf("proto: illegal wireType %d", wireType)
  		}
  	}
  	panic("unreachable")
  }
  
  var (
  	ErrInvalidLengthEmpty = fmt.Errorf("proto: negative length found during unmarshaling")
  	ErrIntOverflowEmpty   = fmt.Errorf("proto: integer overflow")
  )
  
  func init() { proto.RegisterFile("empty.proto", fileDescriptorEmpty) }
  
  var fileDescriptorEmpty = []byte{
  	// 170 bytes of a gzipped FileDescriptorProto
  	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x09, 0x6e, 0x88, 0x02, 0xff, 0xe2, 0xe2, 0x4e, 0xcd, 0x2d, 0x28,
  	0xa9, 0xd4, 0x2b, 0x28, 0xca, 0x2f, 0xc9, 0x17, 0xe2, 0x4f, 0xcf, 0xcf, 0x4f, 0xcf, 0x49, 0x85,
  	0xf0, 0x92, 0x4a, 0xd3, 0x94, 0xd8, 0xb9, 0x58, 0x5d, 0x41, 0xf2, 0x4e, 0xcd, 0x8c, 0x17, 0x1e,
  	0xca, 0x31, 0xdc, 0x78, 0x28, 0xc7, 0xf0, 0xe1, 0xa1, 0x1c, 0xe3, 0x8f, 0x87, 0x72, 0x8c, 0x0d,
  	0x8f, 0xe4, 0x18, 0x57, 0x3c, 0x92, 0x63, 0x3c, 0xf1, 0x48, 0x8e, 0xf1, 0xc2, 0x23, 0x39, 0xc6,
  	0x07, 0x8f, 0xe4, 0x18, 0x5f, 0x3c, 0x92, 0x63, 0xf8, 0xf0, 0x48, 0x8e, 0x91, 0x4b, 0x38, 0x39,
  	0x3f, 0x57, 0x0f, 0xcd, 0x30, 0x27, 0x2e, 0xb0, 0x51, 0x01, 0x20, 0x6e, 0x00, 0x63, 0x14, 0x6b,
  	0x49, 0x65, 0x41, 0x6a, 0xf1, 0x02, 0x46, 0xc6, 0x1f, 0x8c, 0x8c, 0x8b, 0x98, 0x98, 0xdd, 0x03,
  	0x9c, 0x56, 0x31, 0xc9, 0xb9, 0x43, 0xb4, 0x04, 0x40, 0xb5, 0xe8, 0x85, 0xa7, 0xe6, 0xe4, 0x78,
  	0xe7, 0xe5, 0x97, 0xe7, 0x85, 0x80, 0x14, 0x27, 0xb1, 0x81, 0xcd, 0x32, 0x06, 0x04, 0x00, 0x00,
  	0xff, 0xff, 0xb6, 0x8f, 0x29, 0x84, 0xb5, 0x00, 0x00, 0x00,
  }
  