rvt.pb.go

// Code generated by protoc-gen-gogo. DO NOT EDIT.
// source: rvt.proto

package rvt

import (
	context "context"
	fmt "fmt"
	proto "github.com/gogo/protobuf/proto"
	grpc "google.golang.org/grpc"
	codes "google.golang.org/grpc/codes"
	status "google.golang.org/grpc/status"
	io "io"
	math "math"
	math_bits "math/bits"
	reflect "reflect"
	strings "strings"
)

// 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.GoGoProtoPackageIsVersion3 // please upgrade the proto package

type ShareMessage struct {
	Id string `protobuf:"bytes,1,opt,name=id,proto3" json:"id,omitempty"`
	// Types that are valid to be assigned to Message:
	//	*ShareMessage_Init
	//	*ShareMessage_Render
	//	*ShareMessage_Event
	Message isShareMessage_Message `protobuf_oneof:"Message"`
}

func (m *ShareMessage) Reset()      { *m = ShareMessage{} }
func (*ShareMessage) ProtoMessage() {}
func (*ShareMessage) Descriptor() ([]byte, []int) {
	return fileDescriptor_ce9e79630956d2f5, []int{0}
}
func (m *ShareMessage) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *ShareMessage) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_ShareMessage.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *ShareMessage) XXX_Merge(src proto.Message) {
	xxx_messageInfo_ShareMessage.Merge(m, src)
}
func (m *ShareMessage) XXX_Size() int {
	return m.Size()
}
func (m *ShareMessage) XXX_DiscardUnknown() {
	xxx_messageInfo_ShareMessage.DiscardUnknown(m)
}

var xxx_messageInfo_ShareMessage proto.InternalMessageInfo

type isShareMessage_Message interface {
	isShareMessage_Message()
	Equal(interface{}) bool
	MarshalTo([]byte) (int, error)
	Size() int
}

type ShareMessage_Init struct {
	Init *InitMessage `protobuf:"bytes,2,opt,name=Init,proto3,oneof" json:"Init,omitempty"`
}
type ShareMessage_Render struct {
	Render *RenderMessage `protobuf:"bytes,3,opt,name=Render,proto3,oneof" json:"Render,omitempty"`
}
type ShareMessage_Event struct {
	Event *EventMessage `protobuf:"bytes,4,opt,name=Event,proto3,oneof" json:"Event,omitempty"`
}

func (*ShareMessage_Init) isShareMessage_Message()   {}
func (*ShareMessage_Render) isShareMessage_Message() {}
func (*ShareMessage_Event) isShareMessage_Message()  {}

func (m *ShareMessage) GetMessage() isShareMessage_Message {
	if m != nil {
		return m.Message
	}
	return nil
}

func (m *ShareMessage) GetId() string {
	if m != nil {
		return m.Id
	}
	return ""
}

func (m *ShareMessage) GetInit() *InitMessage {
	if x, ok := m.GetMessage().(*ShareMessage_Init); ok {
		return x.Init
	}
	return nil
}

func (m *ShareMessage) GetRender() *RenderMessage {
	if x, ok := m.GetMessage().(*ShareMessage_Render); ok {
		return x.Render
	}
	return nil
}

func (m *ShareMessage) GetEvent() *EventMessage {
	if x, ok := m.GetMessage().(*ShareMessage_Event); ok {
		return x.Event
	}
	return nil
}

// XXX_OneofWrappers is for the internal use of the proto package.
func (*ShareMessage) XXX_OneofWrappers() []interface{} {
	return []interface{}{
		(*ShareMessage_Init)(nil),
		(*ShareMessage_Render)(nil),
		(*ShareMessage_Event)(nil),
	}
}

type InitMessage struct {
}

func (m *InitMessage) Reset()      { *m = InitMessage{} }
func (*InitMessage) ProtoMessage() {}
func (*InitMessage) Descriptor() ([]byte, []int) {
	return fileDescriptor_ce9e79630956d2f5, []int{1}
}
func (m *InitMessage) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *InitMessage) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_InitMessage.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *InitMessage) XXX_Merge(src proto.Message) {
	xxx_messageInfo_InitMessage.Merge(m, src)
}
func (m *InitMessage) XXX_Size() int {
	return m.Size()
}
func (m *InitMessage) XXX_DiscardUnknown() {
	xxx_messageInfo_InitMessage.DiscardUnknown(m)
}

var xxx_messageInfo_InitMessage proto.InternalMessageInfo

type RenderMessage struct {
	Cols   int32    `protobuf:"varint,1,opt,name=cols,proto3" json:"cols,omitempty"`
	Rows   int32    `protobuf:"varint,2,opt,name=rows,proto3" json:"rows,omitempty"`
	Glyphs []*Glyph `protobuf:"bytes,3,rep,name=glyphs,proto3" json:"glyphs,omitempty"`
}

func (m *RenderMessage) Reset()      { *m = RenderMessage{} }
func (*RenderMessage) ProtoMessage() {}
func (*RenderMessage) Descriptor() ([]byte, []int) {
	return fileDescriptor_ce9e79630956d2f5, []int{2}
}
func (m *RenderMessage) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *RenderMessage) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_RenderMessage.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *RenderMessage) XXX_Merge(src proto.Message) {
	xxx_messageInfo_RenderMessage.Merge(m, src)
}
func (m *RenderMessage) XXX_Size() int {
	return m.Size()
}
func (m *RenderMessage) XXX_DiscardUnknown() {
	xxx_messageInfo_RenderMessage.DiscardUnknown(m)
}

var xxx_messageInfo_RenderMessage proto.InternalMessageInfo

func (m *RenderMessage) GetCols() int32 {
	if m != nil {
		return m.Cols
	}
	return 0
}

func (m *RenderMessage) GetRows() int32 {
	if m != nil {
		return m.Rows
	}
	return 0
}

func (m *RenderMessage) GetGlyphs() []*Glyph {
	if m != nil {
		return m.Glyphs
	}
	return nil
}

type Glyph struct {
	X        int32   `protobuf:"varint,1,opt,name=x,proto3" json:"x,omitempty"`
	Y        int32   `protobuf:"varint,2,opt,name=y,proto3" json:"y,omitempty"`
	Mainc    int32   `protobuf:"varint,3,opt,name=mainc,proto3" json:"mainc,omitempty"`
	Combc    []int32 `protobuf:"varint,4,rep,packed,name=combc,proto3" json:"combc,omitempty"`
	Fg       uint64  `protobuf:"varint,5,opt,name=fg,proto3" json:"fg,omitempty"`
	Bg       uint64  `protobuf:"varint,6,opt,name=bg,proto3" json:"bg,omitempty"`
	AttrMask int32   `protobuf:"varint,7,opt,name=attr_mask,json=attrMask,proto3" json:"attr_mask,omitempty"`
	Width    int32   `protobuf:"varint,8,opt,name=width,proto3" json:"width,omitempty"`
}

func (m *Glyph) Reset()      { *m = Glyph{} }
func (*Glyph) ProtoMessage() {}
func (*Glyph) Descriptor() ([]byte, []int) {
	return fileDescriptor_ce9e79630956d2f5, []int{3}
}
func (m *Glyph) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *Glyph) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_Glyph.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *Glyph) XXX_Merge(src proto.Message) {
	xxx_messageInfo_Glyph.Merge(m, src)
}
func (m *Glyph) XXX_Size() int {
	return m.Size()
}
func (m *Glyph) XXX_DiscardUnknown() {
	xxx_messageInfo_Glyph.DiscardUnknown(m)
}

var xxx_messageInfo_Glyph proto.InternalMessageInfo

func (m *Glyph) GetX() int32 {
	if m != nil {
		return m.X
	}
	return 0
}

func (m *Glyph) GetY() int32 {
	if m != nil {
		return m.Y
	}
	return 0
}

func (m *Glyph) GetMainc() int32 {
	if m != nil {
		return m.Mainc
	}
	return 0
}

func (m *Glyph) GetCombc() []int32 {
	if m != nil {
		return m.Combc
	}
	return nil
}

func (m *Glyph) GetFg() uint64 {
	if m != nil {
		return m.Fg
	}
	return 0
}

func (m *Glyph) GetBg() uint64 {
	if m != nil {
		return m.Bg
	}
	return 0
}

func (m *Glyph) GetAttrMask() int32 {
	if m != nil {
		return m.AttrMask
	}
	return 0
}

func (m *Glyph) GetWidth() int32 {
	if m != nil {
		return m.Width
	}
	return 0
}

type EventMessage struct {
	// Types that are valid to be assigned to Event:
	//	*EventMessage_Mouse
	//	*EventMessage_Key
	//	*EventMessage_Resize
	//	*EventMessage_Paste
	Event isEventMessage_Event `protobuf_oneof:"Event"`
}

func (m *EventMessage) Reset()      { *m = EventMessage{} }
func (*EventMessage) ProtoMessage() {}
func (*EventMessage) Descriptor() ([]byte, []int) {
	return fileDescriptor_ce9e79630956d2f5, []int{4}
}
func (m *EventMessage) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *EventMessage) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_EventMessage.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *EventMessage) XXX_Merge(src proto.Message) {
	xxx_messageInfo_EventMessage.Merge(m, src)
}
func (m *EventMessage) XXX_Size() int {
	return m.Size()
}
func (m *EventMessage) XXX_DiscardUnknown() {
	xxx_messageInfo_EventMessage.DiscardUnknown(m)
}

var xxx_messageInfo_EventMessage proto.InternalMessageInfo

type isEventMessage_Event interface {
	isEventMessage_Event()
	Equal(interface{}) bool
	MarshalTo([]byte) (int, error)
	Size() int
}

type EventMessage_Mouse struct {
	Mouse *EventMouse `protobuf:"bytes,1,opt,name=Mouse,proto3,oneof" json:"Mouse,omitempty"`
}
type EventMessage_Key struct {
	Key *EventKey `protobuf:"bytes,2,opt,name=Key,proto3,oneof" json:"Key,omitempty"`
}
type EventMessage_Resize struct {
	Resize *EventResize `protobuf:"bytes,3,opt,name=Resize,proto3,oneof" json:"Resize,omitempty"`
}
type EventMessage_Paste struct {
	Paste *EventPaste `protobuf:"bytes,4,opt,name=Paste,proto3,oneof" json:"Paste,omitempty"`
}

func (*EventMessage_Mouse) isEventMessage_Event()  {}
func (*EventMessage_Key) isEventMessage_Event()    {}
func (*EventMessage_Resize) isEventMessage_Event() {}
func (*EventMessage_Paste) isEventMessage_Event()  {}

func (m *EventMessage) GetEvent() isEventMessage_Event {
	if m != nil {
		return m.Event
	}
	return nil
}

func (m *EventMessage) GetMouse() *EventMouse {
	if x, ok := m.GetEvent().(*EventMessage_Mouse); ok {
		return x.Mouse
	}
	return nil
}

func (m *EventMessage) GetKey() *EventKey {
	if x, ok := m.GetEvent().(*EventMessage_Key); ok {
		return x.Key
	}
	return nil
}

func (m *EventMessage) GetResize() *EventResize {
	if x, ok := m.GetEvent().(*EventMessage_Resize); ok {
		return x.Resize
	}
	return nil
}

func (m *EventMessage) GetPaste() *EventPaste {
	if x, ok := m.GetEvent().(*EventMessage_Paste); ok {
		return x.Paste
	}
	return nil
}

// XXX_OneofWrappers is for the internal use of the proto package.
func (*EventMessage) XXX_OneofWrappers() []interface{} {
	return []interface{}{
		(*EventMessage_Mouse)(nil),
		(*EventMessage_Key)(nil),
		(*EventMessage_Resize)(nil),
		(*EventMessage_Paste)(nil),
	}
}

type EventMouse struct {
	X          int32 `protobuf:"varint,1,opt,name=x,proto3" json:"x,omitempty"`
	Y          int32 `protobuf:"varint,2,opt,name=y,proto3" json:"y,omitempty"`
	ButtonMask int32 `protobuf:"varint,3,opt,name=button_mask,json=buttonMask,proto3" json:"button_mask,omitempty"`
	ModMask    int32 `protobuf:"varint,4,opt,name=mod_mask,json=modMask,proto3" json:"mod_mask,omitempty"`
}

func (m *EventMouse) Reset()      { *m = EventMouse{} }
func (*EventMouse) ProtoMessage() {}
func (*EventMouse) Descriptor() ([]byte, []int) {
	return fileDescriptor_ce9e79630956d2f5, []int{5}
}
func (m *EventMouse) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *EventMouse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_EventMouse.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *EventMouse) XXX_Merge(src proto.Message) {
	xxx_messageInfo_EventMouse.Merge(m, src)
}
func (m *EventMouse) XXX_Size() int {
	return m.Size()
}
func (m *EventMouse) XXX_DiscardUnknown() {
	xxx_messageInfo_EventMouse.DiscardUnknown(m)
}

var xxx_messageInfo_EventMouse proto.InternalMessageInfo

func (m *EventMouse) GetX() int32 {
	if m != nil {
		return m.X
	}
	return 0
}

func (m *EventMouse) GetY() int32 {
	if m != nil {
		return m.Y
	}
	return 0
}

func (m *EventMouse) GetButtonMask() int32 {
	if m != nil {
		return m.ButtonMask
	}
	return 0
}

func (m *EventMouse) GetModMask() int32 {
	if m != nil {
		return m.ModMask
	}
	return 0
}

type EventKey struct {
	Key     int32 `protobuf:"varint,1,opt,name=key,proto3" json:"key,omitempty"`
	Rune    int32 `protobuf:"varint,2,opt,name=rune,proto3" json:"rune,omitempty"`
	ModMask int32 `protobuf:"varint,3,opt,name=mod_mask,json=modMask,proto3" json:"mod_mask,omitempty"`
}

func (m *EventKey) Reset()      { *m = EventKey{} }
func (*EventKey) ProtoMessage() {}
func (*EventKey) Descriptor() ([]byte, []int) {
	return fileDescriptor_ce9e79630956d2f5, []int{6}
}
func (m *EventKey) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *EventKey) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_EventKey.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *EventKey) XXX_Merge(src proto.Message) {
	xxx_messageInfo_EventKey.Merge(m, src)
}
func (m *EventKey) XXX_Size() int {
	return m.Size()
}
func (m *EventKey) XXX_DiscardUnknown() {
	xxx_messageInfo_EventKey.DiscardUnknown(m)
}

var xxx_messageInfo_EventKey proto.InternalMessageInfo

func (m *EventKey) GetKey() int32 {
	if m != nil {
		return m.Key
	}
	return 0
}

func (m *EventKey) GetRune() int32 {
	if m != nil {
		return m.Rune
	}
	return 0
}

func (m *EventKey) GetModMask() int32 {
	if m != nil {
		return m.ModMask
	}
	return 0
}

type EventResize struct {
	Width  int32 `protobuf:"varint,1,opt,name=width,proto3" json:"width,omitempty"`
	Height int32 `protobuf:"varint,2,opt,name=height,proto3" json:"height,omitempty"`
}

func (m *EventResize) Reset()      { *m = EventResize{} }
func (*EventResize) ProtoMessage() {}
func (*EventResize) Descriptor() ([]byte, []int) {
	return fileDescriptor_ce9e79630956d2f5, []int{7}
}
func (m *EventResize) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *EventResize) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_EventResize.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *EventResize) XXX_Merge(src proto.Message) {
	xxx_messageInfo_EventResize.Merge(m, src)
}
func (m *EventResize) XXX_Size() int {
	return m.Size()
}
func (m *EventResize) XXX_DiscardUnknown() {
	xxx_messageInfo_EventResize.DiscardUnknown(m)
}

var xxx_messageInfo_EventResize proto.InternalMessageInfo

func (m *EventResize) GetWidth() int32 {
	if m != nil {
		return m.Width
	}
	return 0
}

func (m *EventResize) GetHeight() int32 {
	if m != nil {
		return m.Height
	}
	return 0
}

type EventPaste struct {
	Start bool `protobuf:"varint,1,opt,name=start,proto3" json:"start,omitempty"`
}

func (m *EventPaste) Reset()      { *m = EventPaste{} }
func (*EventPaste) ProtoMessage() {}
func (*EventPaste) Descriptor() ([]byte, []int) {
	return fileDescriptor_ce9e79630956d2f5, []int{8}
}
func (m *EventPaste) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *EventPaste) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_EventPaste.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *EventPaste) XXX_Merge(src proto.Message) {
	xxx_messageInfo_EventPaste.Merge(m, src)
}
func (m *EventPaste) XXX_Size() int {
	return m.Size()
}
func (m *EventPaste) XXX_DiscardUnknown() {
	xxx_messageInfo_EventPaste.DiscardUnknown(m)
}

var xxx_messageInfo_EventPaste proto.InternalMessageInfo

func (m *EventPaste) GetStart() bool {
	if m != nil {
		return m.Start
	}
	return false
}

func init() {
	proto.RegisterType((*ShareMessage)(nil), "ptmux.rvt.v1.ShareMessage")
	proto.RegisterType((*InitMessage)(nil), "ptmux.rvt.v1.InitMessage")
	proto.RegisterType((*RenderMessage)(nil), "ptmux.rvt.v1.RenderMessage")
	proto.RegisterType((*Glyph)(nil), "ptmux.rvt.v1.Glyph")
	proto.RegisterType((*EventMessage)(nil), "ptmux.rvt.v1.EventMessage")
	proto.RegisterType((*EventMouse)(nil), "ptmux.rvt.v1.EventMouse")
	proto.RegisterType((*EventKey)(nil), "ptmux.rvt.v1.EventKey")
	proto.RegisterType((*EventResize)(nil), "ptmux.rvt.v1.EventResize")
	proto.RegisterType((*EventPaste)(nil), "ptmux.rvt.v1.EventPaste")
}

func init() { proto.RegisterFile("rvt.proto", fileDescriptor_ce9e79630956d2f5) }

var fileDescriptor_ce9e79630956d2f5 = []byte{
	// 605 bytes of a gzipped FileDescriptorProto
	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x7c, 0x54, 0xc1, 0x6e, 0xd3, 0x4c,
	0x10, 0xf6, 0xc6, 0xb1, 0x93, 0x8c, 0xd3, 0x5f, 0xbf, 0x16, 0x54, 0xb9, 0xad, 0xb4, 0x44, 0x3e,
	0x45, 0x20, 0x85, 0x92, 0x8a, 0x03, 0xe2, 0x56, 0x84, 0x28, 0xaa, 0x22, 0x21, 0xf7, 0xc6, 0x05,
	0x39, 0xf1, 0xd6, 0xb1, 0x5a, 0xdb, 0x95, 0xbd, 0x49, 0x6b, 0x4e, 0x3c, 0x02, 0xcf, 0xc0, 0x89,
	0x17, 0x41, 0xe2, 0xd8, 0x63, 0x0f, 0x1c, 0xa8, 0x73, 0xe1, 0xd8, 0x47, 0x40, 0x3b, 0xbb, 0x10,
	0x1b, 0x45, 0xbd, 0xcd, 0xcc, 0x37, 0xdf, 0x78, 0xf6, 0xfb, 0x76, 0x0d, 0xbd, 0x7c, 0x29, 0x46,
	0x17, 0x79, 0x26, 0x32, 0xda, 0xbf, 0x10, 0xc9, 0xe2, 0x6a, 0x24, 0x0b, 0xcb, 0x67, 0xde, 0x37,
	0x02, 0xfd, 0x93, 0x79, 0x90, 0xf3, 0x09, 0x2f, 0x8a, 0x20, 0xe2, 0xf4, 0x3f, 0x68, 0xc5, 0xa1,
	0x4b, 0x06, 0x64, 0xd8, 0xf3, 0x5b, 0x71, 0x48, 0x9f, 0x42, 0xfb, 0x6d, 0x1a, 0x0b, 0xb7, 0x35,
	0x20, 0x43, 0x67, 0xbc, 0x33, 0xaa, 0xb3, 0x47, 0x12, 0xd1, 0xc4, 0x23, 0xc3, 0xc7, 0x46, 0xfa,
	0x1c, 0x6c, 0x9f, 0xa7, 0x21, 0xcf, 0x5d, 0x13, 0x29, 0x7b, 0x4d, 0x8a, 0xc2, 0xd6, 0x24, 0xdd,
	0x4c, 0xc7, 0x60, 0xbd, 0x5e, 0xf2, 0x54, 0xb8, 0x6d, 0x64, 0xed, 0x36, 0x59, 0x08, 0xad, 0x49,
	0xaa, 0xf5, 0xb0, 0x07, 0x1d, 0x5d, 0xf3, 0xb6, 0xc0, 0xa9, 0x2d, 0xe3, 0x85, 0xb0, 0xd5, 0xf8,
	0x10, 0xa5, 0xd0, 0x9e, 0x65, 0xe7, 0x05, 0x1e, 0xcc, 0xf2, 0x31, 0x96, 0xb5, 0x3c, 0xbb, 0x2c,
	0xf0, 0x68, 0x96, 0x8f, 0x31, 0x7d, 0x02, 0x76, 0x74, 0x5e, 0x5e, 0xcc, 0x0b, 0xd7, 0x1c, 0x98,
	0x43, 0x67, 0xfc, 0xa0, 0xb9, 0xc7, 0x1b, 0x89, 0xf9, 0xba, 0xc5, 0xfb, 0x42, 0xc0, 0xc2, 0x0a,
	0xed, 0x03, 0xb9, 0xd2, 0xb3, 0xc9, 0x95, 0xcc, 0x4a, 0x3d, 0x95, 0x94, 0xf4, 0x21, 0x58, 0x49,
	0x10, 0xa7, 0x33, 0xd4, 0xc3, 0xf2, 0x55, 0x22, 0xab, 0xb3, 0x2c, 0x99, 0xce, 0xdc, 0xf6, 0xc0,
	0x94, 0x55, 0x4c, 0xa4, 0xfa, 0xa7, 0x91, 0x6b, 0x0d, 0xc8, 0xb0, 0xed, 0xb7, 0x4e, 0x23, 0x99,
	0x4f, 0x23, 0xd7, 0x56, 0xf9, 0x34, 0xa2, 0x7b, 0xd0, 0x0b, 0x84, 0xc8, 0x3f, 0x24, 0x41, 0x71,
	0xe6, 0x76, 0x70, 0x5e, 0x57, 0x16, 0x26, 0x41, 0x71, 0x26, 0x47, 0x5e, 0xc6, 0xa1, 0x98, 0xbb,
	0x5d, 0xf5, 0x21, 0x4c, 0xbc, 0x1f, 0x04, 0xfa, 0x75, 0xf9, 0xe8, 0x3e, 0x58, 0x93, 0x6c, 0x51,
	0x70, 0xdc, 0xd7, 0x19, 0xbb, 0x9b, 0x94, 0x96, 0xb8, 0xd4, 0x19, 0x03, 0xfa, 0x18, 0xcc, 0x63,
	0x5e, 0xea, 0x2b, 0xb0, 0xbd, 0xa1, 0xff, 0x98, 0x97, 0x47, 0x86, 0x2f, 0x9b, 0xe8, 0x81, 0xb4,
	0xbf, 0x88, 0x3f, 0x72, 0x6d, 0xff, 0xce, 0x86, 0x76, 0xd5, 0xa0, 0xcc, 0x97, 0x91, 0x5c, 0xe9,
	0x5d, 0x50, 0x08, 0xae, 0xcd, 0xdf, 0xb4, 0x12, 0xe2, 0x72, 0x25, 0x0c, 0x0e, 0x3b, 0xfa, 0xba,
	0x78, 0x21, 0xc0, 0x7a, 0xe5, 0x7b, 0x7d, 0x78, 0x04, 0xce, 0x74, 0x21, 0x44, 0x96, 0x2a, 0xf5,
	0x94, 0x1b, 0xa0, 0x4a, 0xa8, 0xdf, 0x0e, 0x74, 0x93, 0x2c, 0x54, 0x68, 0x1b, 0xd1, 0x4e, 0x92,
	0x85, 0x12, 0xf2, 0x8e, 0xa1, 0xfb, 0xe7, 0xa0, 0xf4, 0x7f, 0x30, 0xcf, 0x78, 0xa9, 0xbf, 0x22,
	0x43, 0xbc, 0x48, 0x8b, 0x94, 0xff, 0xbd, 0x48, 0x8b, 0x94, 0x37, 0x86, 0x99, 0xcd, 0x61, 0x2f,
	0xc1, 0xa9, 0xc9, 0xb0, 0xb6, 0x8d, 0xd4, 0x6c, 0xa3, 0xdb, 0x60, 0xcf, 0x79, 0x1c, 0xcd, 0x85,
	0x9e, 0xaa, 0x33, 0xcf, 0xd3, 0xe7, 0x45, 0x19, 0x24, 0xb7, 0x10, 0x41, 0x2e, 0x90, 0xdb, 0xf5,
	0x55, 0x32, 0x9e, 0x80, 0x7d, 0x32, 0xcb, 0x39, 0x4f, 0xe9, 0x2b, 0xb0, 0xf0, 0x75, 0xd3, 0x7f,
	0xde, 0x53, 0xfd, 0xc9, 0xef, 0xde, 0x83, 0x0d, 0xc9, 0x3e, 0x39, 0x7c, 0x71, 0x7d, 0xcb, 0x8c,
	0x9b, 0x5b, 0x66, 0xdc, 0xdd, 0x32, 0xf2, 0xa9, 0x62, 0xe4, 0x6b, 0xc5, 0xc8, 0xf7, 0x8a, 0x91,
	0xeb, 0x8a, 0x91, 0x9f, 0x15, 0x23, 0xbf, 0x2a, 0x66, 0xdc, 0x55, 0x8c, 0x7c, 0x5e, 0x31, 0xe3,
	0x7a, 0xc5, 0x8c, 0x9b, 0x15, 0x33, 0xde, 0x9b, 0xf9, 0x52, 0x4c, 0x6d, 0xfc, 0xe7, 0x1c, 0xfc,
	0x0e, 0x00, 0x00, 0xff, 0xff, 0xcc, 0x76, 0x51, 0xd5, 0x80, 0x04, 0x00, 0x00,
}

func (this *ShareMessage) Equal(that interface{}) bool {
	if that == nil {
		return this == nil
	}

	that1, ok := that.(*ShareMessage)
	if !ok {
		that2, ok := that.(ShareMessage)
		if ok {
			that1 = &that2
		} else {
			return false
		}
	}
	if that1 == nil {
		return this == nil
	} else if this == nil {
		return false
	}
	if this.Id != that1.Id {
		return false
	}
	if that1.Message == nil {
		if this.Message != nil {
			return false
		}
	} else if this.Message == nil {
		return false
	} else if !this.Message.Equal(that1.Message) {
		return false
	}
	return true
}
func (this *ShareMessage_Init) Equal(that interface{}) bool {
	if that == nil {
		return this == nil
	}

	that1, ok := that.(*ShareMessage_Init)
	if !ok {
		that2, ok := that.(ShareMessage_Init)
		if ok {
			that1 = &that2
		} else {
			return false
		}
	}
	if that1 == nil {
		return this == nil
	} else if this == nil {
		return false
	}
	if !this.Init.Equal(that1.Init) {
		return false
	}
	return true
}
func (this *ShareMessage_Render) Equal(that interface{}) bool {
	if that == nil {
		return this == nil
	}

	that1, ok := that.(*ShareMessage_Render)
	if !ok {
		that2, ok := that.(ShareMessage_Render)
		if ok {
			that1 = &that2
		} else {
			return false
		}
	}
	if that1 == nil {
		return this == nil
	} else if this == nil {
		return false
	}
	if !this.Render.Equal(that1.Render) {
		return false
	}
	return true
}
func (this *ShareMessage_Event) Equal(that interface{}) bool {
	if that == nil {
		return this == nil
	}

	that1, ok := that.(*ShareMessage_Event)
	if !ok {
		that2, ok := that.(ShareMessage_Event)
		if ok {
			that1 = &that2
		} else {
			return false
		}
	}
	if that1 == nil {
		return this == nil
	} else if this == nil {
		return false
	}
	if !this.Event.Equal(that1.Event) {
		return false
	}
	return true
}
func (this *InitMessage) Equal(that interface{}) bool {
	if that == nil {
		return this == nil
	}

	that1, ok := that.(*InitMessage)
	if !ok {
		that2, ok := that.(InitMessage)
		if ok {
			that1 = &that2
		} else {
			return false
		}
	}
	if that1 == nil {
		return this == nil
	} else if this == nil {
		return false
	}
	return true
}
func (this *RenderMessage) Equal(that interface{}) bool {
	if that == nil {
		return this == nil
	}

	that1, ok := that.(*RenderMessage)
	if !ok {
		that2, ok := that.(RenderMessage)
		if ok {
			that1 = &that2
		} else {
			return false
		}
	}
	if that1 == nil {
		return this == nil
	} else if this == nil {
		return false
	}
	if this.Cols != that1.Cols {
		return false
	}
	if this.Rows != that1.Rows {
		return false
	}
	if len(this.Glyphs) != len(that1.Glyphs) {
		return false
	}
	for i := range this.Glyphs {
		if !this.Glyphs[i].Equal(that1.Glyphs[i]) {
			return false
		}
	}
	return true
}
func (this *Glyph) Equal(that interface{}) bool {
	if that == nil {
		return this == nil
	}

	that1, ok := that.(*Glyph)
	if !ok {
		that2, ok := that.(Glyph)
		if ok {
			that1 = &that2
		} else {
			return false
		}
	}
	if that1 == nil {
		return this == nil
	} else if this == nil {
		return false
	}
	if this.X != that1.X {
		return false
	}
	if this.Y != that1.Y {
		return false
	}
	if this.Mainc != that1.Mainc {
		return false
	}
	if len(this.Combc) != len(that1.Combc) {
		return false
	}
	for i := range this.Combc {
		if this.Combc[i] != that1.Combc[i] {
			return false
		}
	}
	if this.Fg != that1.Fg {
		return false
	}
	if this.Bg != that1.Bg {
		return false
	}
	if this.AttrMask != that1.AttrMask {
		return false
	}
	if this.Width != that1.Width {
		return false
	}
	return true
}
func (this *EventMessage) Equal(that interface{}) bool {
	if that == nil {
		return this == nil
	}

	that1, ok := that.(*EventMessage)
	if !ok {
		that2, ok := that.(EventMessage)
		if ok {
			that1 = &that2
		} else {
			return false
		}
	}
	if that1 == nil {
		return this == nil
	} else if this == nil {
		return false
	}
	if that1.Event == nil {
		if this.Event != nil {
			return false
		}
	} else if this.Event == nil {
		return false
	} else if !this.Event.Equal(that1.Event) {
		return false
	}
	return true
}
func (this *EventMessage_Mouse) Equal(that interface{}) bool {
	if that == nil {
		return this == nil
	}

	that1, ok := that.(*EventMessage_Mouse)
	if !ok {
		that2, ok := that.(EventMessage_Mouse)
		if ok {
			that1 = &that2
		} else {
			return false
		}
	}
	if that1 == nil {
		return this == nil
	} else if this == nil {
		return false
	}
	if !this.Mouse.Equal(that1.Mouse) {
		return false
	}
	return true
}
func (this *EventMessage_Key) Equal(that interface{}) bool {
	if that == nil {
		return this == nil
	}

	that1, ok := that.(*EventMessage_Key)
	if !ok {
		that2, ok := that.(EventMessage_Key)
		if ok {
			that1 = &that2
		} else {
			return false
		}
	}
	if that1 == nil {
		return this == nil
	} else if this == nil {
		return false
	}
	if !this.Key.Equal(that1.Key) {
		return false
	}
	return true
}
func (this *EventMessage_Resize) Equal(that interface{}) bool {
	if that == nil {
		return this == nil
	}

	that1, ok := that.(*EventMessage_Resize)
	if !ok {
		that2, ok := that.(EventMessage_Resize)
		if ok {
			that1 = &that2
		} else {
			return false
		}
	}
	if that1 == nil {
		return this == nil
	} else if this == nil {
		return false
	}
	if !this.Resize.Equal(that1.Resize) {
		return false
	}
	return true
}
func (this *EventMessage_Paste) Equal(that interface{}) bool {
	if that == nil {
		return this == nil
	}

	that1, ok := that.(*EventMessage_Paste)
	if !ok {
		that2, ok := that.(EventMessage_Paste)
		if ok {
			that1 = &that2
		} else {
			return false
		}
	}
	if that1 == nil {
		return this == nil
	} else if this == nil {
		return false
	}
	if !this.Paste.Equal(that1.Paste) {
		return false
	}
	return true
}
func (this *EventMouse) Equal(that interface{}) bool {
	if that == nil {
		return this == nil
	}

	that1, ok := that.(*EventMouse)
	if !ok {
		that2, ok := that.(EventMouse)
		if ok {
			that1 = &that2
		} else {
			return false
		}
	}
	if that1 == nil {
		return this == nil
	} else if this == nil {
		return false
	}
	if this.X != that1.X {
		return false
	}
	if this.Y != that1.Y {
		return false
	}
	if this.ButtonMask != that1.ButtonMask {
		return false
	}
	if this.ModMask != that1.ModMask {
		return false
	}
	return true
}
func (this *EventKey) Equal(that interface{}) bool {
	if that == nil {
		return this == nil
	}

	that1, ok := that.(*EventKey)
	if !ok {
		that2, ok := that.(EventKey)
		if ok {
			that1 = &that2
		} else {
			return false
		}
	}
	if that1 == nil {
		return this == nil
	} else if this == nil {
		return false
	}
	if this.Key != that1.Key {
		return false
	}
	if this.Rune != that1.Rune {
		return false
	}
	if this.ModMask != that1.ModMask {
		return false
	}
	return true
}
func (this *EventResize) Equal(that interface{}) bool {
	if that == nil {
		return this == nil
	}

	that1, ok := that.(*EventResize)
	if !ok {
		that2, ok := that.(EventResize)
		if ok {
			that1 = &that2
		} else {
			return false
		}
	}
	if that1 == nil {
		return this == nil
	} else if this == nil {
		return false
	}
	if this.Width != that1.Width {
		return false
	}
	if this.Height != that1.Height {
		return false
	}
	return true
}
func (this *EventPaste) Equal(that interface{}) bool {
	if that == nil {
		return this == nil
	}

	that1, ok := that.(*EventPaste)
	if !ok {
		that2, ok := that.(EventPaste)
		if ok {
			that1 = &that2
		} else {
			return false
		}
	}
	if that1 == nil {
		return this == nil
	} else if this == nil {
		return false
	}
	if this.Start != that1.Start {
		return false
	}
	return true
}
func (this *ShareMessage) GoString() string {
	if this == nil {
		return "nil"
	}
	s := make([]string, 0, 8)
	s = append(s, "&rvt.ShareMessage{")
	s = append(s, "Id: "+fmt.Sprintf("%#v", this.Id)+",\n")
	if this.Message != nil {
		s = append(s, "Message: "+fmt.Sprintf("%#v", this.Message)+",\n")
	}
	s = append(s, "}")
	return strings.Join(s, "")
}
func (this *ShareMessage_Init) GoString() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&rvt.ShareMessage_Init{` +
		`Init:` + fmt.Sprintf("%#v", this.Init) + `}`}, ", ")
	return s
}
func (this *ShareMessage_Render) GoString() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&rvt.ShareMessage_Render{` +
		`Render:` + fmt.Sprintf("%#v", this.Render) + `}`}, ", ")
	return s
}
func (this *ShareMessage_Event) GoString() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&rvt.ShareMessage_Event{` +
		`Event:` + fmt.Sprintf("%#v", this.Event) + `}`}, ", ")
	return s
}
func (this *InitMessage) GoString() string {
	if this == nil {
		return "nil"
	}
	s := make([]string, 0, 4)
	s = append(s, "&rvt.InitMessage{")
	s = append(s, "}")
	return strings.Join(s, "")
}
func (this *RenderMessage) GoString() string {
	if this == nil {
		return "nil"
	}
	s := make([]string, 0, 7)
	s = append(s, "&rvt.RenderMessage{")
	s = append(s, "Cols: "+fmt.Sprintf("%#v", this.Cols)+",\n")
	s = append(s, "Rows: "+fmt.Sprintf("%#v", this.Rows)+",\n")
	if this.Glyphs != nil {
		s = append(s, "Glyphs: "+fmt.Sprintf("%#v", this.Glyphs)+",\n")
	}
	s = append(s, "}")
	return strings.Join(s, "")
}
func (this *Glyph) GoString() string {
	if this == nil {
		return "nil"
	}
	s := make([]string, 0, 12)
	s = append(s, "&rvt.Glyph{")
	s = append(s, "X: "+fmt.Sprintf("%#v", this.X)+",\n")
	s = append(s, "Y: "+fmt.Sprintf("%#v", this.Y)+",\n")
	s = append(s, "Mainc: "+fmt.Sprintf("%#v", this.Mainc)+",\n")
	s = append(s, "Combc: "+fmt.Sprintf("%#v", this.Combc)+",\n")
	s = append(s, "Fg: "+fmt.Sprintf("%#v", this.Fg)+",\n")
	s = append(s, "Bg: "+fmt.Sprintf("%#v", this.Bg)+",\n")
	s = append(s, "AttrMask: "+fmt.Sprintf("%#v", this.AttrMask)+",\n")
	s = append(s, "Width: "+fmt.Sprintf("%#v", this.Width)+",\n")
	s = append(s, "}")
	return strings.Join(s, "")
}
func (this *EventMessage) GoString() string {
	if this == nil {
		return "nil"
	}
	s := make([]string, 0, 8)
	s = append(s, "&rvt.EventMessage{")
	if this.Event != nil {
		s = append(s, "Event: "+fmt.Sprintf("%#v", this.Event)+",\n")
	}
	s = append(s, "}")
	return strings.Join(s, "")
}
func (this *EventMessage_Mouse) GoString() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&rvt.EventMessage_Mouse{` +
		`Mouse:` + fmt.Sprintf("%#v", this.Mouse) + `}`}, ", ")
	return s
}
func (this *EventMessage_Key) GoString() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&rvt.EventMessage_Key{` +
		`Key:` + fmt.Sprintf("%#v", this.Key) + `}`}, ", ")
	return s
}
func (this *EventMessage_Resize) GoString() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&rvt.EventMessage_Resize{` +
		`Resize:` + fmt.Sprintf("%#v", this.Resize) + `}`}, ", ")
	return s
}
func (this *EventMessage_Paste) GoString() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&rvt.EventMessage_Paste{` +
		`Paste:` + fmt.Sprintf("%#v", this.Paste) + `}`}, ", ")
	return s
}
func (this *EventMouse) GoString() string {
	if this == nil {
		return "nil"
	}
	s := make([]string, 0, 8)
	s = append(s, "&rvt.EventMouse{")
	s = append(s, "X: "+fmt.Sprintf("%#v", this.X)+",\n")
	s = append(s, "Y: "+fmt.Sprintf("%#v", this.Y)+",\n")
	s = append(s, "ButtonMask: "+fmt.Sprintf("%#v", this.ButtonMask)+",\n")
	s = append(s, "ModMask: "+fmt.Sprintf("%#v", this.ModMask)+",\n")
	s = append(s, "}")
	return strings.Join(s, "")
}
func (this *EventKey) GoString() string {
	if this == nil {
		return "nil"
	}
	s := make([]string, 0, 7)
	s = append(s, "&rvt.EventKey{")
	s = append(s, "Key: "+fmt.Sprintf("%#v", this.Key)+",\n")
	s = append(s, "Rune: "+fmt.Sprintf("%#v", this.Rune)+",\n")
	s = append(s, "ModMask: "+fmt.Sprintf("%#v", this.ModMask)+",\n")
	s = append(s, "}")
	return strings.Join(s, "")
}
func (this *EventResize) GoString() string {
	if this == nil {
		return "nil"
	}
	s := make([]string, 0, 6)
	s = append(s, "&rvt.EventResize{")
	s = append(s, "Width: "+fmt.Sprintf("%#v", this.Width)+",\n")
	s = append(s, "Height: "+fmt.Sprintf("%#v", this.Height)+",\n")
	s = append(s, "}")
	return strings.Join(s, "")
}
func (this *EventPaste) GoString() string {
	if this == nil {
		return "nil"
	}
	s := make([]string, 0, 5)
	s = append(s, "&rvt.EventPaste{")
	s = append(s, "Start: "+fmt.Sprintf("%#v", this.Start)+",\n")
	s = append(s, "}")
	return strings.Join(s, "")
}
func valueToGoStringRvt(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)
}

// Reference imports to suppress errors if they are not otherwise used.
var _ context.Context
var _ grpc.ClientConn

// This is a compile-time assertion to ensure that this generated file
// is compatible with the grpc package it is being compiled against.
const _ = grpc.SupportPackageIsVersion4

// ScreenClient is the client API for Screen service.
//
// For semantics around ctx use and closing/ending streaming RPCs, please refer to https://godoc.org/google.golang.org/grpc#ClientConn.NewStream.
type ScreenClient interface {
	Share(ctx context.Context, opts ...grpc.CallOption) (Screen_ShareClient, error)
}

type screenClient struct {
	cc *grpc.ClientConn
}

func NewScreenClient(cc *grpc.ClientConn) ScreenClient {
	return &screenClient{cc}
}

func (c *screenClient) Share(ctx context.Context, opts ...grpc.CallOption) (Screen_ShareClient, error) {
	stream, err := c.cc.NewStream(ctx, &_Screen_serviceDesc.Streams[0], "/ptmux.rvt.v1.Screen/Share", opts...)
	if err != nil {
		return nil, err
	}
	x := &screenShareClient{stream}
	return x, nil
}

type Screen_ShareClient interface {
	Send(*ShareMessage) error
	Recv() (*ShareMessage, error)
	grpc.ClientStream
}

type screenShareClient struct {
	grpc.ClientStream
}

func (x *screenShareClient) Send(m *ShareMessage) error {
	return x.ClientStream.SendMsg(m)
}

func (x *screenShareClient) Recv() (*ShareMessage, error) {
	m := new(ShareMessage)
	if err := x.ClientStream.RecvMsg(m); err != nil {
		return nil, err
	}
	return m, nil
}

// ScreenServer is the server API for Screen service.
type ScreenServer interface {
	Share(Screen_ShareServer) error
}

// UnimplementedScreenServer can be embedded to have forward compatible implementations.
type UnimplementedScreenServer struct {
}

func (*UnimplementedScreenServer) Share(srv Screen_ShareServer) error {
	return status.Errorf(codes.Unimplemented, "method Share not implemented")
}

func RegisterScreenServer(s *grpc.Server, srv ScreenServer) {
	s.RegisterService(&_Screen_serviceDesc, srv)
}

func _Screen_Share_Handler(srv interface{}, stream grpc.ServerStream) error {
	return srv.(ScreenServer).Share(&screenShareServer{stream})
}

type Screen_ShareServer interface {
	Send(*ShareMessage) error
	Recv() (*ShareMessage, error)
	grpc.ServerStream
}

type screenShareServer struct {
	grpc.ServerStream
}

func (x *screenShareServer) Send(m *ShareMessage) error {
	return x.ServerStream.SendMsg(m)
}

func (x *screenShareServer) Recv() (*ShareMessage, error) {
	m := new(ShareMessage)
	if err := x.ServerStream.RecvMsg(m); err != nil {
		return nil, err
	}
	return m, nil
}

var _Screen_serviceDesc = grpc.ServiceDesc{
	ServiceName: "ptmux.rvt.v1.Screen",
	HandlerType: (*ScreenServer)(nil),
	Methods:     []grpc.MethodDesc{},
	Streams: []grpc.StreamDesc{
		{
			StreamName:    "Share",
			Handler:       _Screen_Share_Handler,
			ServerStreams: true,
			ClientStreams: true,
		},
	},
	Metadata: "rvt.proto",
}

func (m *ShareMessage) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *ShareMessage) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *ShareMessage) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.Message != nil {
		{
			size := m.Message.Size()
			i -= size
			if _, err := m.Message.MarshalTo(dAtA[i:]); err != nil {
				return 0, err
			}
		}
	}
	if len(m.Id) > 0 {
		i -= len(m.Id)
		copy(dAtA[i:], m.Id)
		i = encodeVarintRvt(dAtA, i, uint64(len(m.Id)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *ShareMessage_Init) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *ShareMessage_Init) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	if m.Init != nil {
		{
			size, err := m.Init.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintRvt(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x12
	}
	return len(dAtA) - i, nil
}
func (m *ShareMessage_Render) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *ShareMessage_Render) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	if m.Render != nil {
		{
			size, err := m.Render.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintRvt(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x1a
	}
	return len(dAtA) - i, nil
}
func (m *ShareMessage_Event) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *ShareMessage_Event) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	if m.Event != nil {
		{
			size, err := m.Event.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintRvt(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x22
	}
	return len(dAtA) - i, nil
}
func (m *InitMessage) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *InitMessage) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *InitMessage) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	return len(dAtA) - i, nil
}

func (m *RenderMessage) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RenderMessage) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RenderMessage) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.Glyphs) > 0 {
		for iNdEx := len(m.Glyphs) - 1; iNdEx >= 0; iNdEx-- {
			{
				size, err := m.Glyphs[iNdEx].MarshalToSizedBuffer(dAtA[:i])
				if err != nil {
					return 0, err
				}
				i -= size
				i = encodeVarintRvt(dAtA, i, uint64(size))
			}
			i--
			dAtA[i] = 0x1a
		}
	}
	if m.Rows != 0 {
		i = encodeVarintRvt(dAtA, i, uint64(m.Rows))
		i--
		dAtA[i] = 0x10
	}
	if m.Cols != 0 {
		i = encodeVarintRvt(dAtA, i, uint64(m.Cols))
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

func (m *Glyph) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *Glyph) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *Glyph) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.Width != 0 {
		i = encodeVarintRvt(dAtA, i, uint64(m.Width))
		i--
		dAtA[i] = 0x40
	}
	if m.AttrMask != 0 {
		i = encodeVarintRvt(dAtA, i, uint64(m.AttrMask))
		i--
		dAtA[i] = 0x38
	}
	if m.Bg != 0 {
		i = encodeVarintRvt(dAtA, i, uint64(m.Bg))
		i--
		dAtA[i] = 0x30
	}
	if m.Fg != 0 {
		i = encodeVarintRvt(dAtA, i, uint64(m.Fg))
		i--
		dAtA[i] = 0x28
	}
	if len(m.Combc) > 0 {
		dAtA5 := make([]byte, len(m.Combc)*10)
		var j4 int
		for _, num1 := range m.Combc {
			num := uint64(num1)
			for num >= 1<<7 {
				dAtA5[j4] = uint8(uint64(num)&0x7f | 0x80)
				num >>= 7
				j4++
			}
			dAtA5[j4] = uint8(num)
			j4++
		}
		i -= j4
		copy(dAtA[i:], dAtA5[:j4])
		i = encodeVarintRvt(dAtA, i, uint64(j4))
		i--
		dAtA[i] = 0x22
	}
	if m.Mainc != 0 {
		i = encodeVarintRvt(dAtA, i, uint64(m.Mainc))
		i--
		dAtA[i] = 0x18
	}
	if m.Y != 0 {
		i = encodeVarintRvt(dAtA, i, uint64(m.Y))
		i--
		dAtA[i] = 0x10
	}
	if m.X != 0 {
		i = encodeVarintRvt(dAtA, i, uint64(m.X))
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

func (m *EventMessage) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *EventMessage) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *EventMessage) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.Event != nil {
		{
			size := m.Event.Size()
			i -= size
			if _, err := m.Event.MarshalTo(dAtA[i:]); err != nil {
				return 0, err
			}
		}
	}
	return len(dAtA) - i, nil
}

func (m *EventMessage_Mouse) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *EventMessage_Mouse) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	if m.Mouse != nil {
		{
			size, err := m.Mouse.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintRvt(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}
func (m *EventMessage_Key) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *EventMessage_Key) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	if m.Key != nil {
		{
			size, err := m.Key.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintRvt(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x12
	}
	return len(dAtA) - i, nil
}
func (m *EventMessage_Resize) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *EventMessage_Resize) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	if m.Resize != nil {
		{
			size, err := m.Resize.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintRvt(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x1a
	}
	return len(dAtA) - i, nil
}
func (m *EventMessage_Paste) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *EventMessage_Paste) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	if m.Paste != nil {
		{
			size, err := m.Paste.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintRvt(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x22
	}
	return len(dAtA) - i, nil
}
func (m *EventMouse) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *EventMouse) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *EventMouse) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.ModMask != 0 {
		i = encodeVarintRvt(dAtA, i, uint64(m.ModMask))
		i--
		dAtA[i] = 0x20
	}
	if m.ButtonMask != 0 {
		i = encodeVarintRvt(dAtA, i, uint64(m.ButtonMask))
		i--
		dAtA[i] = 0x18
	}
	if m.Y != 0 {
		i = encodeVarintRvt(dAtA, i, uint64(m.Y))
		i--
		dAtA[i] = 0x10
	}
	if m.X != 0 {
		i = encodeVarintRvt(dAtA, i, uint64(m.X))
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

func (m *EventKey) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *EventKey) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *EventKey) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.ModMask != 0 {
		i = encodeVarintRvt(dAtA, i, uint64(m.ModMask))
		i--
		dAtA[i] = 0x18
	}
	if m.Rune != 0 {
		i = encodeVarintRvt(dAtA, i, uint64(m.Rune))
		i--
		dAtA[i] = 0x10
	}
	if m.Key != 0 {
		i = encodeVarintRvt(dAtA, i, uint64(m.Key))
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

func (m *EventResize) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *EventResize) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *EventResize) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.Height != 0 {
		i = encodeVarintRvt(dAtA, i, uint64(m.Height))
		i--
		dAtA[i] = 0x10
	}
	if m.Width != 0 {
		i = encodeVarintRvt(dAtA, i, uint64(m.Width))
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

func (m *EventPaste) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *EventPaste) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *EventPaste) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.Start {
		i--
		if m.Start {
			dAtA[i] = 1
		} else {
			dAtA[i] = 0
		}
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

func encodeVarintRvt(dAtA []byte, offset int, v uint64) int {
	offset -= sovRvt(v)
	base := offset
	for v >= 1<<7 {
		dAtA[offset] = uint8(v&0x7f | 0x80)
		v >>= 7
		offset++
	}
	dAtA[offset] = uint8(v)
	return base
}
func (m *ShareMessage) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.Id)
	if l > 0 {
		n += 1 + l + sovRvt(uint64(l))
	}
	if m.Message != nil {
		n += m.Message.Size()
	}
	return n
}

func (m *ShareMessage_Init) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Init != nil {
		l = m.Init.Size()
		n += 1 + l + sovRvt(uint64(l))
	}
	return n
}
func (m *ShareMessage_Render) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Render != nil {
		l = m.Render.Size()
		n += 1 + l + sovRvt(uint64(l))
	}
	return n
}
func (m *ShareMessage_Event) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Event != nil {
		l = m.Event.Size()
		n += 1 + l + sovRvt(uint64(l))
	}
	return n
}
func (m *InitMessage) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	return n
}

func (m *RenderMessage) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Cols != 0 {
		n += 1 + sovRvt(uint64(m.Cols))
	}
	if m.Rows != 0 {
		n += 1 + sovRvt(uint64(m.Rows))
	}
	if len(m.Glyphs) > 0 {
		for _, e := range m.Glyphs {
			l = e.Size()
			n += 1 + l + sovRvt(uint64(l))
		}
	}
	return n
}

func (m *Glyph) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.X != 0 {
		n += 1 + sovRvt(uint64(m.X))
	}
	if m.Y != 0 {
		n += 1 + sovRvt(uint64(m.Y))
	}
	if m.Mainc != 0 {
		n += 1 + sovRvt(uint64(m.Mainc))
	}
	if len(m.Combc) > 0 {
		l = 0
		for _, e := range m.Combc {
			l += sovRvt(uint64(e))
		}
		n += 1 + sovRvt(uint64(l)) + l
	}
	if m.Fg != 0 {
		n += 1 + sovRvt(uint64(m.Fg))
	}
	if m.Bg != 0 {
		n += 1 + sovRvt(uint64(m.Bg))
	}
	if m.AttrMask != 0 {
		n += 1 + sovRvt(uint64(m.AttrMask))
	}
	if m.Width != 0 {
		n += 1 + sovRvt(uint64(m.Width))
	}
	return n
}

func (m *EventMessage) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Event != nil {
		n += m.Event.Size()
	}
	return n
}

func (m *EventMessage_Mouse) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Mouse != nil {
		l = m.Mouse.Size()
		n += 1 + l + sovRvt(uint64(l))
	}
	return n
}
func (m *EventMessage_Key) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Key != nil {
		l = m.Key.Size()
		n += 1 + l + sovRvt(uint64(l))
	}
	return n
}
func (m *EventMessage_Resize) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Resize != nil {
		l = m.Resize.Size()
		n += 1 + l + sovRvt(uint64(l))
	}
	return n
}
func (m *EventMessage_Paste) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Paste != nil {
		l = m.Paste.Size()
		n += 1 + l + sovRvt(uint64(l))
	}
	return n
}
func (m *EventMouse) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.X != 0 {
		n += 1 + sovRvt(uint64(m.X))
	}
	if m.Y != 0 {
		n += 1 + sovRvt(uint64(m.Y))
	}
	if m.ButtonMask != 0 {
		n += 1 + sovRvt(uint64(m.ButtonMask))
	}
	if m.ModMask != 0 {
		n += 1 + sovRvt(uint64(m.ModMask))
	}
	return n
}

func (m *EventKey) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Key != 0 {
		n += 1 + sovRvt(uint64(m.Key))
	}
	if m.Rune != 0 {
		n += 1 + sovRvt(uint64(m.Rune))
	}
	if m.ModMask != 0 {
		n += 1 + sovRvt(uint64(m.ModMask))
	}
	return n
}

func (m *EventResize) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Width != 0 {
		n += 1 + sovRvt(uint64(m.Width))
	}
	if m.Height != 0 {
		n += 1 + sovRvt(uint64(m.Height))
	}
	return n
}

func (m *EventPaste) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Start {
		n += 2
	}
	return n
}

func sovRvt(x uint64) (n int) {
	return (math_bits.Len64(x|1) + 6) / 7
}
func sozRvt(x uint64) (n int) {
	return sovRvt(uint64((x << 1) ^ uint64((int64(x) >> 63))))
}
func (this *ShareMessage) String() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&ShareMessage{`,
		`Id:` + fmt.Sprintf("%v", this.Id) + `,`,
		`Message:` + fmt.Sprintf("%v", this.Message) + `,`,
		`}`,
	}, "")
	return s
}
func (this *ShareMessage_Init) String() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&ShareMessage_Init{`,
		`Init:` + strings.Replace(fmt.Sprintf("%v", this.Init), "InitMessage", "InitMessage", 1) + `,`,
		`}`,
	}, "")
	return s
}
func (this *ShareMessage_Render) String() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&ShareMessage_Render{`,
		`Render:` + strings.Replace(fmt.Sprintf("%v", this.Render), "RenderMessage", "RenderMessage", 1) + `,`,
		`}`,
	}, "")
	return s
}
func (this *ShareMessage_Event) String() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&ShareMessage_Event{`,
		`Event:` + strings.Replace(fmt.Sprintf("%v", this.Event), "EventMessage", "EventMessage", 1) + `,`,
		`}`,
	}, "")
	return s
}
func (this *InitMessage) String() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&InitMessage{`,
		`}`,
	}, "")
	return s
}
func (this *RenderMessage) String() string {
	if this == nil {
		return "nil"
	}
	repeatedStringForGlyphs := "[]*Glyph{"
	for _, f := range this.Glyphs {
		repeatedStringForGlyphs += strings.Replace(f.String(), "Glyph", "Glyph", 1) + ","
	}
	repeatedStringForGlyphs += "}"
	s := strings.Join([]string{`&RenderMessage{`,
		`Cols:` + fmt.Sprintf("%v", this.Cols) + `,`,
		`Rows:` + fmt.Sprintf("%v", this.Rows) + `,`,
		`Glyphs:` + repeatedStringForGlyphs + `,`,
		`}`,
	}, "")
	return s
}
func (this *Glyph) String() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&Glyph{`,
		`X:` + fmt.Sprintf("%v", this.X) + `,`,
		`Y:` + fmt.Sprintf("%v", this.Y) + `,`,
		`Mainc:` + fmt.Sprintf("%v", this.Mainc) + `,`,
		`Combc:` + fmt.Sprintf("%v", this.Combc) + `,`,
		`Fg:` + fmt.Sprintf("%v", this.Fg) + `,`,
		`Bg:` + fmt.Sprintf("%v", this.Bg) + `,`,
		`AttrMask:` + fmt.Sprintf("%v", this.AttrMask) + `,`,
		`Width:` + fmt.Sprintf("%v", this.Width) + `,`,
		`}`,
	}, "")
	return s
}
func (this *EventMessage) String() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&EventMessage{`,
		`Event:` + fmt.Sprintf("%v", this.Event) + `,`,
		`}`,
	}, "")
	return s
}
func (this *EventMessage_Mouse) String() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&EventMessage_Mouse{`,
		`Mouse:` + strings.Replace(fmt.Sprintf("%v", this.Mouse), "EventMouse", "EventMouse", 1) + `,`,
		`}`,
	}, "")
	return s
}
func (this *EventMessage_Key) String() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&EventMessage_Key{`,
		`Key:` + strings.Replace(fmt.Sprintf("%v", this.Key), "EventKey", "EventKey", 1) + `,`,
		`}`,
	}, "")
	return s
}
func (this *EventMessage_Resize) String() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&EventMessage_Resize{`,
		`Resize:` + strings.Replace(fmt.Sprintf("%v", this.Resize), "EventResize", "EventResize", 1) + `,`,
		`}`,
	}, "")
	return s
}
func (this *EventMessage_Paste) String() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&EventMessage_Paste{`,
		`Paste:` + strings.Replace(fmt.Sprintf("%v", this.Paste), "EventPaste", "EventPaste", 1) + `,`,
		`}`,
	}, "")
	return s
}
func (this *EventMouse) String() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&EventMouse{`,
		`X:` + fmt.Sprintf("%v", this.X) + `,`,
		`Y:` + fmt.Sprintf("%v", this.Y) + `,`,
		`ButtonMask:` + fmt.Sprintf("%v", this.ButtonMask) + `,`,
		`ModMask:` + fmt.Sprintf("%v", this.ModMask) + `,`,
		`}`,
	}, "")
	return s
}
func (this *EventKey) String() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&EventKey{`,
		`Key:` + fmt.Sprintf("%v", this.Key) + `,`,
		`Rune:` + fmt.Sprintf("%v", this.Rune) + `,`,
		`ModMask:` + fmt.Sprintf("%v", this.ModMask) + `,`,
		`}`,
	}, "")
	return s
}
func (this *EventResize) String() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&EventResize{`,
		`Width:` + fmt.Sprintf("%v", this.Width) + `,`,
		`Height:` + fmt.Sprintf("%v", this.Height) + `,`,
		`}`,
	}, "")
	return s
}
func (this *EventPaste) String() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&EventPaste{`,
		`Start:` + fmt.Sprintf("%v", this.Start) + `,`,
		`}`,
	}, "")
	return s
}
func valueToStringRvt(v interface{}) string {
	rv := reflect.ValueOf(v)
	if rv.IsNil() {
		return "nil"
	}
	pv := reflect.Indirect(rv).Interface()
	return fmt.Sprintf("*%v", pv)
}
func (m *ShareMessage) 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 ErrIntOverflowRvt
			}
			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: ShareMessage: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: ShareMessage: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Id", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowRvt
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthRvt
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthRvt
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Id = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Init", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowRvt
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthRvt
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthRvt
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			v := &InitMessage{}
			if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			m.Message = &ShareMessage_Init{v}
			iNdEx = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Render", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowRvt
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthRvt
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthRvt
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			v := &RenderMessage{}
			if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			m.Message = &ShareMessage_Render{v}
			iNdEx = postIndex
		case 4:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Event", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowRvt
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthRvt
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthRvt
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			v := &EventMessage{}
			if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			m.Message = &ShareMessage_Event{v}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipRvt(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthRvt
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *InitMessage) 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 ErrIntOverflowRvt
			}
			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: InitMessage: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: InitMessage: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		default:
			iNdEx = preIndex
			skippy, err := skipRvt(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthRvt
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *RenderMessage) 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 ErrIntOverflowRvt
			}
			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: RenderMessage: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: RenderMessage: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Cols", wireType)
			}
			m.Cols = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowRvt
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Cols |= int32(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 2:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Rows", wireType)
			}
			m.Rows = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowRvt
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Rows |= int32(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Glyphs", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowRvt
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthRvt
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthRvt
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Glyphs = append(m.Glyphs, &Glyph{})
			if err := m.Glyphs[len(m.Glyphs)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipRvt(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthRvt
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *Glyph) 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 ErrIntOverflowRvt
			}
			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: Glyph: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Glyph: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field X", wireType)
			}
			m.X = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowRvt
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.X |= int32(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 2:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Y", wireType)
			}
			m.Y = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowRvt
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Y |= int32(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 3:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Mainc", wireType)
			}
			m.Mainc = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowRvt
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Mainc |= int32(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 4:
			if wireType == 0 {
				var v int32
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return ErrIntOverflowRvt
					}
					if iNdEx >= l {
						return io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					v |= int32(b&0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				m.Combc = append(m.Combc, v)
			} else if wireType == 2 {
				var packedLen int
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return ErrIntOverflowRvt
					}
					if iNdEx >= l {
						return io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					packedLen |= int(b&0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				if packedLen < 0 {
					return ErrInvalidLengthRvt
				}
				postIndex := iNdEx + packedLen
				if postIndex < 0 {
					return ErrInvalidLengthRvt
				}
				if postIndex > l {
					return io.ErrUnexpectedEOF
				}
				var elementCount int
				var count int
				for _, integer := range dAtA[iNdEx:postIndex] {
					if integer < 128 {
						count++
					}
				}
				elementCount = count
				if elementCount != 0 && len(m.Combc) == 0 {
					m.Combc = make([]int32, 0, elementCount)
				}
				for iNdEx < postIndex {
					var v int32
					for shift := uint(0); ; shift += 7 {
						if shift >= 64 {
							return ErrIntOverflowRvt
						}
						if iNdEx >= l {
							return io.ErrUnexpectedEOF
						}
						b := dAtA[iNdEx]
						iNdEx++
						v |= int32(b&0x7F) << shift
						if b < 0x80 {
							break
						}
					}
					m.Combc = append(m.Combc, v)
				}
			} else {
				return fmt.Errorf("proto: wrong wireType = %d for field Combc", wireType)
			}
		case 5:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Fg", wireType)
			}
			m.Fg = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowRvt
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Fg |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 6:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Bg", wireType)
			}
			m.Bg = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowRvt
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Bg |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 7:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field AttrMask", wireType)
			}
			m.AttrMask = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowRvt
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.AttrMask |= int32(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 8:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Width", wireType)
			}
			m.Width = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowRvt
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Width |= int32(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		default:
			iNdEx = preIndex
			skippy, err := skipRvt(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthRvt
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *EventMessage) 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 ErrIntOverflowRvt
			}
			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: EventMessage: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: EventMessage: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Mouse", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowRvt
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthRvt
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthRvt
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			v := &EventMouse{}
			if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			m.Event = &EventMessage_Mouse{v}
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Key", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowRvt
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthRvt
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthRvt
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			v := &EventKey{}
			if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			m.Event = &EventMessage_Key{v}
			iNdEx = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Resize", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowRvt
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthRvt
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthRvt
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			v := &EventResize{}
			if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			m.Event = &EventMessage_Resize{v}
			iNdEx = postIndex
		case 4:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Paste", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowRvt
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthRvt
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthRvt
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			v := &EventPaste{}
			if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			m.Event = &EventMessage_Paste{v}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipRvt(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthRvt
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *EventMouse) 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 ErrIntOverflowRvt
			}
			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: EventMouse: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: EventMouse: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field X", wireType)
			}
			m.X = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowRvt
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.X |= int32(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 2:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Y", wireType)
			}
			m.Y = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowRvt
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Y |= int32(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 3:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field ButtonMask", wireType)
			}
			m.ButtonMask = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowRvt
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.ButtonMask |= int32(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 4:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field ModMask", wireType)
			}
			m.ModMask = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowRvt
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.ModMask |= int32(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		default:
			iNdEx = preIndex
			skippy, err := skipRvt(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthRvt
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *EventKey) 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 ErrIntOverflowRvt
			}
			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: EventKey: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: EventKey: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Key", wireType)
			}
			m.Key = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowRvt
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Key |= int32(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 2:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Rune", wireType)
			}
			m.Rune = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowRvt
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Rune |= int32(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 3:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field ModMask", wireType)
			}
			m.ModMask = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowRvt
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.ModMask |= int32(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		default:
			iNdEx = preIndex
			skippy, err := skipRvt(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthRvt
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *EventResize) 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 ErrIntOverflowRvt
			}
			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: EventResize: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: EventResize: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Width", wireType)
			}
			m.Width = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowRvt
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Width |= int32(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 2:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Height", wireType)
			}
			m.Height = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowRvt
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Height |= int32(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		default:
			iNdEx = preIndex
			skippy, err := skipRvt(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthRvt
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *EventPaste) 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 ErrIntOverflowRvt
			}
			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: EventPaste: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: EventPaste: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Start", wireType)
			}
			var v int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowRvt
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				v |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			m.Start = bool(v != 0)
		default:
			iNdEx = preIndex
			skippy, err := skipRvt(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthRvt
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func skipRvt(dAtA []byte) (n int, err error) {
	l := len(dAtA)
	iNdEx := 0
	depth := 0
	for iNdEx < l {
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return 0, ErrIntOverflowRvt
			}
			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, ErrIntOverflowRvt
				}
				if iNdEx >= l {
					return 0, io.ErrUnexpectedEOF
				}
				iNdEx++
				if dAtA[iNdEx-1] < 0x80 {
					break
				}
			}
		case 1:
			iNdEx += 8
		case 2:
			var length int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return 0, ErrIntOverflowRvt
				}
				if iNdEx >= l {
					return 0, io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				length |= (int(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if length < 0 {
				return 0, ErrInvalidLengthRvt
			}
			iNdEx += length
		case 3:
			depth++
		case 4:
			if depth == 0 {
				return 0, ErrUnexpectedEndOfGroupRvt
			}
			depth--
		case 5:
			iNdEx += 4
		default:
			return 0, fmt.Errorf("proto: illegal wireType %d", wireType)
		}
		if iNdEx < 0 {
			return 0, ErrInvalidLengthRvt
		}
		if depth == 0 {
			return iNdEx, nil
		}
	}
	return 0, io.ErrUnexpectedEOF
}

var (
	ErrInvalidLengthRvt        = fmt.Errorf("proto: negative length found during unmarshaling")
	ErrIntOverflowRvt          = fmt.Errorf("proto: integer overflow")
	ErrUnexpectedEndOfGroupRvt = fmt.Errorf("proto: unexpected end of group")
)