Skip to content
rachel/specter
File

Blob: spec/protocol/chord_vtproto.pb.go

go2354 lines
1// Code generated by protoc-gen-go-vtproto. DO NOT EDIT.
2// protoc-gen-go-vtproto version: v0.6.0
3// source: spec/proto/chord.proto
4 
5package protocol
6 
7import (
8	fmt "fmt"
9	protohelpers "github.com/planetscale/vtprotobuf/protohelpers"
10	protoimpl "google.golang.org/protobuf/runtime/protoimpl"
11	io "io"
12)
13 
14const (
15	// Verify that this generated code is sufficiently up-to-date.
16	_ = protoimpl.EnforceVersion(20 - protoimpl.MinVersion)
17	// Verify that runtime/protoimpl is sufficiently up-to-date.
18	_ = protoimpl.EnforceVersion(protoimpl.MaxVersion - 20)
19)
20 
21func (m *Empty) MarshalVT() (dAtA []byte, err error) {
22	if m == nil {
23		return nil, nil
24	}
25	size := m.SizeVT()
26	dAtA = make([]byte, size)
27	n, err := m.MarshalToSizedBufferVT(dAtA[:size])
28	if err != nil {
29		return nil, err
30	}
31	return dAtA[:n], nil
32}
33 
34func (m *Empty) MarshalToVT(dAtA []byte) (int, error) {
35	size := m.SizeVT()
36	return m.MarshalToSizedBufferVT(dAtA[:size])
37}
38 
39func (m *Empty) MarshalToSizedBufferVT(dAtA []byte) (int, error) {
40	if m == nil {
41		return 0, nil
42	}
43	i := len(dAtA)
44	_ = i
45	var l int
46	_ = l
47	if m.unknownFields != nil {
48		i -= len(m.unknownFields)
49		copy(dAtA[i:], m.unknownFields)
50	}
51	return len(dAtA) - i, nil
52}
53 
54func (m *IdentityRequest) MarshalVT() (dAtA []byte, err error) {
55	if m == nil {
56		return nil, nil
57	}
58	size := m.SizeVT()
59	dAtA = make([]byte, size)
60	n, err := m.MarshalToSizedBufferVT(dAtA[:size])
61	if err != nil {
62		return nil, err
63	}
64	return dAtA[:n], nil
65}
66 
67func (m *IdentityRequest) MarshalToVT(dAtA []byte) (int, error) {
68	size := m.SizeVT()
69	return m.MarshalToSizedBufferVT(dAtA[:size])
70}
71 
72func (m *IdentityRequest) MarshalToSizedBufferVT(dAtA []byte) (int, error) {
73	if m == nil {
74		return 0, nil
75	}
76	i := len(dAtA)
77	_ = i
78	var l int
79	_ = l
80	if m.unknownFields != nil {
81		i -= len(m.unknownFields)
82		copy(dAtA[i:], m.unknownFields)
83	}
84	return len(dAtA) - i, nil
85}
86 
87func (m *IdentityResponse) MarshalVT() (dAtA []byte, err error) {
88	if m == nil {
89		return nil, nil
90	}
91	size := m.SizeVT()
92	dAtA = make([]byte, size)
93	n, err := m.MarshalToSizedBufferVT(dAtA[:size])
94	if err != nil {
95		return nil, err
96	}
97	return dAtA[:n], nil
98}
99 
100func (m *IdentityResponse) MarshalToVT(dAtA []byte) (int, error) {
101	size := m.SizeVT()
102	return m.MarshalToSizedBufferVT(dAtA[:size])
103}
104 
105func (m *IdentityResponse) MarshalToSizedBufferVT(dAtA []byte) (int, error) {
106	if m == nil {
107		return 0, nil
108	}
109	i := len(dAtA)
110	_ = i
111	var l int
112	_ = l
113	if m.unknownFields != nil {
114		i -= len(m.unknownFields)
115		copy(dAtA[i:], m.unknownFields)
116	}
117	if m.Identity != nil {
118		size, err := m.Identity.MarshalToSizedBufferVT(dAtA[:i])
119		if err != nil {
120			return 0, err
121		}
122		i -= size
123		i = protohelpers.EncodeVarint(dAtA, i, uint64(size))
124		i--
125		dAtA[i] = 0xa
126	}
127	return len(dAtA) - i, nil
128}
129 
130func (m *PingRequest) MarshalVT() (dAtA []byte, err error) {
131	if m == nil {
132		return nil, nil
133	}
134	size := m.SizeVT()
135	dAtA = make([]byte, size)
136	n, err := m.MarshalToSizedBufferVT(dAtA[:size])
137	if err != nil {
138		return nil, err
139	}
140	return dAtA[:n], nil
141}
142 
143func (m *PingRequest) MarshalToVT(dAtA []byte) (int, error) {
144	size := m.SizeVT()
145	return m.MarshalToSizedBufferVT(dAtA[:size])
146}
147 
148func (m *PingRequest) MarshalToSizedBufferVT(dAtA []byte) (int, error) {
149	if m == nil {
150		return 0, nil
151	}
152	i := len(dAtA)
153	_ = i
154	var l int
155	_ = l
156	if m.unknownFields != nil {
157		i -= len(m.unknownFields)
158		copy(dAtA[i:], m.unknownFields)
159	}
160	return len(dAtA) - i, nil
161}
162 
163func (m *PingResponse) MarshalVT() (dAtA []byte, err error) {
164	if m == nil {
165		return nil, nil
166	}
167	size := m.SizeVT()
168	dAtA = make([]byte, size)
169	n, err := m.MarshalToSizedBufferVT(dAtA[:size])
170	if err != nil {
171		return nil, err
172	}
173	return dAtA[:n], nil
174}
175 
176func (m *PingResponse) MarshalToVT(dAtA []byte) (int, error) {
177	size := m.SizeVT()
178	return m.MarshalToSizedBufferVT(dAtA[:size])
179}
180 
181func (m *PingResponse) MarshalToSizedBufferVT(dAtA []byte) (int, error) {
182	if m == nil {
183		return 0, nil
184	}
185	i := len(dAtA)
186	_ = i
187	var l int
188	_ = l
189	if m.unknownFields != nil {
190		i -= len(m.unknownFields)
191		copy(dAtA[i:], m.unknownFields)
192	}
193	return len(dAtA) - i, nil
194}
195 
196func (m *NotifyRequest) MarshalVT() (dAtA []byte, err error) {
197	if m == nil {
198		return nil, nil
199	}
200	size := m.SizeVT()
201	dAtA = make([]byte, size)
202	n, err := m.MarshalToSizedBufferVT(dAtA[:size])
203	if err != nil {
204		return nil, err
205	}
206	return dAtA[:n], nil
207}
208 
209func (m *NotifyRequest) MarshalToVT(dAtA []byte) (int, error) {
210	size := m.SizeVT()
211	return m.MarshalToSizedBufferVT(dAtA[:size])
212}
213 
214func (m *NotifyRequest) MarshalToSizedBufferVT(dAtA []byte) (int, error) {
215	if m == nil {
216		return 0, nil
217	}
218	i := len(dAtA)
219	_ = i
220	var l int
221	_ = l
222	if m.unknownFields != nil {
223		i -= len(m.unknownFields)
224		copy(dAtA[i:], m.unknownFields)
225	}
226	if m.Predecessor != nil {
227		size, err := m.Predecessor.MarshalToSizedBufferVT(dAtA[:i])
228		if err != nil {
229			return 0, err
230		}
231		i -= size
232		i = protohelpers.EncodeVarint(dAtA, i, uint64(size))
233		i--
234		dAtA[i] = 0xa
235	}
236	return len(dAtA) - i, nil
237}
238 
239func (m *NotifyResponse) MarshalVT() (dAtA []byte, err error) {
240	if m == nil {
241		return nil, nil
242	}
243	size := m.SizeVT()
244	dAtA = make([]byte, size)
245	n, err := m.MarshalToSizedBufferVT(dAtA[:size])
246	if err != nil {
247		return nil, err
248	}
249	return dAtA[:n], nil
250}
251 
252func (m *NotifyResponse) MarshalToVT(dAtA []byte) (int, error) {
253	size := m.SizeVT()
254	return m.MarshalToSizedBufferVT(dAtA[:size])
255}
256 
257func (m *NotifyResponse) MarshalToSizedBufferVT(dAtA []byte) (int, error) {
258	if m == nil {
259		return 0, nil
260	}
261	i := len(dAtA)
262	_ = i
263	var l int
264	_ = l
265	if m.unknownFields != nil {
266		i -= len(m.unknownFields)
267		copy(dAtA[i:], m.unknownFields)
268	}
269	return len(dAtA) - i, nil
270}
271 
272func (m *FindSuccessorRequest) MarshalVT() (dAtA []byte, err error) {
273	if m == nil {
274		return nil, nil
275	}
276	size := m.SizeVT()
277	dAtA = make([]byte, size)
278	n, err := m.MarshalToSizedBufferVT(dAtA[:size])
279	if err != nil {
280		return nil, err
281	}
282	return dAtA[:n], nil
283}
284 
285func (m *FindSuccessorRequest) MarshalToVT(dAtA []byte) (int, error) {
286	size := m.SizeVT()
287	return m.MarshalToSizedBufferVT(dAtA[:size])
288}
289 
290func (m *FindSuccessorRequest) MarshalToSizedBufferVT(dAtA []byte) (int, error) {
291	if m == nil {
292		return 0, nil
293	}
294	i := len(dAtA)
295	_ = i
296	var l int
297	_ = l
298	if m.unknownFields != nil {
299		i -= len(m.unknownFields)
300		copy(dAtA[i:], m.unknownFields)
301	}
302	if m.Key != 0 {
303		i = protohelpers.EncodeVarint(dAtA, i, uint64(m.Key))
304		i--
305		dAtA[i] = 0x8
306	}
307	return len(dAtA) - i, nil
308}
309 
310func (m *FindSuccessorResponse) MarshalVT() (dAtA []byte, err error) {
311	if m == nil {
312		return nil, nil
313	}
314	size := m.SizeVT()
315	dAtA = make([]byte, size)
316	n, err := m.MarshalToSizedBufferVT(dAtA[:size])
317	if err != nil {
318		return nil, err
319	}
320	return dAtA[:n], nil
321}
322 
323func (m *FindSuccessorResponse) MarshalToVT(dAtA []byte) (int, error) {
324	size := m.SizeVT()
325	return m.MarshalToSizedBufferVT(dAtA[:size])
326}
327 
328func (m *FindSuccessorResponse) MarshalToSizedBufferVT(dAtA []byte) (int, error) {
329	if m == nil {
330		return 0, nil
331	}
332	i := len(dAtA)
333	_ = i
334	var l int
335	_ = l
336	if m.unknownFields != nil {
337		i -= len(m.unknownFields)
338		copy(dAtA[i:], m.unknownFields)
339	}
340	if m.Successor != nil {
341		size, err := m.Successor.MarshalToSizedBufferVT(dAtA[:i])
342		if err != nil {
343			return 0, err
344		}
345		i -= size
346		i = protohelpers.EncodeVarint(dAtA, i, uint64(size))
347		i--
348		dAtA[i] = 0xa
349	}
350	return len(dAtA) - i, nil
351}
352 
353func (m *GetPredecessorRequest) MarshalVT() (dAtA []byte, err error) {
354	if m == nil {
355		return nil, nil
356	}
357	size := m.SizeVT()
358	dAtA = make([]byte, size)
359	n, err := m.MarshalToSizedBufferVT(dAtA[:size])
360	if err != nil {
361		return nil, err
362	}
363	return dAtA[:n], nil
364}
365 
366func (m *GetPredecessorRequest) MarshalToVT(dAtA []byte) (int, error) {
367	size := m.SizeVT()
368	return m.MarshalToSizedBufferVT(dAtA[:size])
369}
370 
371func (m *GetPredecessorRequest) MarshalToSizedBufferVT(dAtA []byte) (int, error) {
372	if m == nil {
373		return 0, nil
374	}
375	i := len(dAtA)
376	_ = i
377	var l int
378	_ = l
379	if m.unknownFields != nil {
380		i -= len(m.unknownFields)
381		copy(dAtA[i:], m.unknownFields)
382	}
383	return len(dAtA) - i, nil
384}
385 
386func (m *GetPredecessorResponse) MarshalVT() (dAtA []byte, err error) {
387	if m == nil {
388		return nil, nil
389	}
390	size := m.SizeVT()
391	dAtA = make([]byte, size)
392	n, err := m.MarshalToSizedBufferVT(dAtA[:size])
393	if err != nil {
394		return nil, err
395	}
396	return dAtA[:n], nil
397}
398 
399func (m *GetPredecessorResponse) MarshalToVT(dAtA []byte) (int, error) {
400	size := m.SizeVT()
401	return m.MarshalToSizedBufferVT(dAtA[:size])
402}
403 
404func (m *GetPredecessorResponse) MarshalToSizedBufferVT(dAtA []byte) (int, error) {
405	if m == nil {
406		return 0, nil
407	}
408	i := len(dAtA)
409	_ = i
410	var l int
411	_ = l
412	if m.unknownFields != nil {
413		i -= len(m.unknownFields)
414		copy(dAtA[i:], m.unknownFields)
415	}
416	if m.Predecessor != nil {
417		size, err := m.Predecessor.MarshalToSizedBufferVT(dAtA[:i])
418		if err != nil {
419			return 0, err
420		}
421		i -= size
422		i = protohelpers.EncodeVarint(dAtA, i, uint64(size))
423		i--
424		dAtA[i] = 0xa
425	}
426	return len(dAtA) - i, nil
427}
428 
429func (m *GetSuccessorsRequest) MarshalVT() (dAtA []byte, err error) {
430	if m == nil {
431		return nil, nil
432	}
433	size := m.SizeVT()
434	dAtA = make([]byte, size)
435	n, err := m.MarshalToSizedBufferVT(dAtA[:size])
436	if err != nil {
437		return nil, err
438	}
439	return dAtA[:n], nil
440}
441 
442func (m *GetSuccessorsRequest) MarshalToVT(dAtA []byte) (int, error) {
443	size := m.SizeVT()
444	return m.MarshalToSizedBufferVT(dAtA[:size])
445}
446 
447func (m *GetSuccessorsRequest) MarshalToSizedBufferVT(dAtA []byte) (int, error) {
448	if m == nil {
449		return 0, nil
450	}
451	i := len(dAtA)
452	_ = i
453	var l int
454	_ = l
455	if m.unknownFields != nil {
456		i -= len(m.unknownFields)
457		copy(dAtA[i:], m.unknownFields)
458	}
459	return len(dAtA) - i, nil
460}
461 
462func (m *GetSuccessorsResponse) MarshalVT() (dAtA []byte, err error) {
463	if m == nil {
464		return nil, nil
465	}
466	size := m.SizeVT()
467	dAtA = make([]byte, size)
468	n, err := m.MarshalToSizedBufferVT(dAtA[:size])
469	if err != nil {
470		return nil, err
471	}
472	return dAtA[:n], nil
473}
474 
475func (m *GetSuccessorsResponse) MarshalToVT(dAtA []byte) (int, error) {
476	size := m.SizeVT()
477	return m.MarshalToSizedBufferVT(dAtA[:size])
478}
479 
480func (m *GetSuccessorsResponse) MarshalToSizedBufferVT(dAtA []byte) (int, error) {
481	if m == nil {
482		return 0, nil
483	}
484	i := len(dAtA)
485	_ = i
486	var l int
487	_ = l
488	if m.unknownFields != nil {
489		i -= len(m.unknownFields)
490		copy(dAtA[i:], m.unknownFields)
491	}
492	if len(m.Successors) > 0 {
493		for iNdEx := len(m.Successors) - 1; iNdEx >= 0; iNdEx-- {
494			size, err := m.Successors[iNdEx].MarshalToSizedBufferVT(dAtA[:i])
495			if err != nil {
496				return 0, err
497			}
498			i -= size
499			i = protohelpers.EncodeVarint(dAtA, i, uint64(size))
500			i--
501			dAtA[i] = 0xa
502		}
503	}
504	return len(dAtA) - i, nil
505}
506 
507func (m *RequestToJoinRequest) MarshalVT() (dAtA []byte, err error) {
508	if m == nil {
509		return nil, nil
510	}
511	size := m.SizeVT()
512	dAtA = make([]byte, size)
513	n, err := m.MarshalToSizedBufferVT(dAtA[:size])
514	if err != nil {
515		return nil, err
516	}
517	return dAtA[:n], nil
518}
519 
520func (m *RequestToJoinRequest) MarshalToVT(dAtA []byte) (int, error) {
521	size := m.SizeVT()
522	return m.MarshalToSizedBufferVT(dAtA[:size])
523}
524 
525func (m *RequestToJoinRequest) MarshalToSizedBufferVT(dAtA []byte) (int, error) {
526	if m == nil {
527		return 0, nil
528	}
529	i := len(dAtA)
530	_ = i
531	var l int
532	_ = l
533	if m.unknownFields != nil {
534		i -= len(m.unknownFields)
535		copy(dAtA[i:], m.unknownFields)
536	}
537	if m.Joiner != nil {
538		size, err := m.Joiner.MarshalToSizedBufferVT(dAtA[:i])
539		if err != nil {
540			return 0, err
541		}
542		i -= size
543		i = protohelpers.EncodeVarint(dAtA, i, uint64(size))
544		i--
545		dAtA[i] = 0xa
546	}
547	return len(dAtA) - i, nil
548}
549 
550func (m *RequestToJoinResponse) MarshalVT() (dAtA []byte, err error) {
551	if m == nil {
552		return nil, nil
553	}
554	size := m.SizeVT()
555	dAtA = make([]byte, size)
556	n, err := m.MarshalToSizedBufferVT(dAtA[:size])
557	if err != nil {
558		return nil, err
559	}
560	return dAtA[:n], nil
561}
562 
563func (m *RequestToJoinResponse) MarshalToVT(dAtA []byte) (int, error) {
564	size := m.SizeVT()
565	return m.MarshalToSizedBufferVT(dAtA[:size])
566}
567 
568func (m *RequestToJoinResponse) MarshalToSizedBufferVT(dAtA []byte) (int, error) {
569	if m == nil {
570		return 0, nil
571	}
572	i := len(dAtA)
573	_ = i
574	var l int
575	_ = l
576	if m.unknownFields != nil {
577		i -= len(m.unknownFields)
578		copy(dAtA[i:], m.unknownFields)
579	}
580	if len(m.Successors) > 0 {
581		for iNdEx := len(m.Successors) - 1; iNdEx >= 0; iNdEx-- {
582			size, err := m.Successors[iNdEx].MarshalToSizedBufferVT(dAtA[:i])
583			if err != nil {
584				return 0, err
585			}
586			i -= size
587			i = protohelpers.EncodeVarint(dAtA, i, uint64(size))
588			i--
589			dAtA[i] = 0x12
590		}
591	}
592	if m.Predecessor != nil {
593		size, err := m.Predecessor.MarshalToSizedBufferVT(dAtA[:i])
594		if err != nil {
595			return 0, err
596		}
597		i -= size
598		i = protohelpers.EncodeVarint(dAtA, i, uint64(size))
599		i--
600		dAtA[i] = 0xa
601	}
602	return len(dAtA) - i, nil
603}
604 
605func (m *RequestToLeaveRequest) MarshalVT() (dAtA []byte, err error) {
606	if m == nil {
607		return nil, nil
608	}
609	size := m.SizeVT()
610	dAtA = make([]byte, size)
611	n, err := m.MarshalToSizedBufferVT(dAtA[:size])
612	if err != nil {
613		return nil, err
614	}
615	return dAtA[:n], nil
616}
617 
618func (m *RequestToLeaveRequest) MarshalToVT(dAtA []byte) (int, error) {
619	size := m.SizeVT()
620	return m.MarshalToSizedBufferVT(dAtA[:size])
621}
622 
623func (m *RequestToLeaveRequest) MarshalToSizedBufferVT(dAtA []byte) (int, error) {
624	if m == nil {
625		return 0, nil
626	}
627	i := len(dAtA)
628	_ = i
629	var l int
630	_ = l
631	if m.unknownFields != nil {
632		i -= len(m.unknownFields)
633		copy(dAtA[i:], m.unknownFields)
634	}
635	if m.Leaver != nil {
636		size, err := m.Leaver.MarshalToSizedBufferVT(dAtA[:i])
637		if err != nil {
638			return 0, err
639		}
640		i -= size
641		i = protohelpers.EncodeVarint(dAtA, i, uint64(size))
642		i--
643		dAtA[i] = 0xa
644	}
645	return len(dAtA) - i, nil
646}
647 
648func (m *RequestToLeaveResponse) MarshalVT() (dAtA []byte, err error) {
649	if m == nil {
650		return nil, nil
651	}
652	size := m.SizeVT()
653	dAtA = make([]byte, size)
654	n, err := m.MarshalToSizedBufferVT(dAtA[:size])
655	if err != nil {
656		return nil, err
657	}
658	return dAtA[:n], nil
659}
660 
661func (m *RequestToLeaveResponse) MarshalToVT(dAtA []byte) (int, error) {
662	size := m.SizeVT()
663	return m.MarshalToSizedBufferVT(dAtA[:size])
664}
665 
666func (m *RequestToLeaveResponse) MarshalToSizedBufferVT(dAtA []byte) (int, error) {
667	if m == nil {
668		return 0, nil
669	}
670	i := len(dAtA)
671	_ = i
672	var l int
673	_ = l
674	if m.unknownFields != nil {
675		i -= len(m.unknownFields)
676		copy(dAtA[i:], m.unknownFields)
677	}
678	return len(dAtA) - i, nil
679}
680 
681func (m *MembershipConclusionRequest) MarshalVT() (dAtA []byte, err error) {
682	if m == nil {
683		return nil, nil
684	}
685	size := m.SizeVT()
686	dAtA = make([]byte, size)
687	n, err := m.MarshalToSizedBufferVT(dAtA[:size])
688	if err != nil {
689		return nil, err
690	}
691	return dAtA[:n], nil
692}
693 
694func (m *MembershipConclusionRequest) MarshalToVT(dAtA []byte) (int, error) {
695	size := m.SizeVT()
696	return m.MarshalToSizedBufferVT(dAtA[:size])
697}
698 
699func (m *MembershipConclusionRequest) MarshalToSizedBufferVT(dAtA []byte) (int, error) {
700	if m == nil {
701		return 0, nil
702	}
703	i := len(dAtA)
704	_ = i
705	var l int
706	_ = l
707	if m.unknownFields != nil {
708		i -= len(m.unknownFields)
709		copy(dAtA[i:], m.unknownFields)
710	}
711	if m.Release {
712		i--
713		if m.Release {
714			dAtA[i] = 1
715		} else {
716			dAtA[i] = 0
717		}
718		i--
719		dAtA[i] = 0x10
720	}
721	if m.Stabilize {
722		i--
723		if m.Stabilize {
724			dAtA[i] = 1
725		} else {
726			dAtA[i] = 0
727		}
728		i--
729		dAtA[i] = 0x8
730	}
731	return len(dAtA) - i, nil
732}
733 
734func (m *MembershipConclusionResponse) MarshalVT() (dAtA []byte, err error) {
735	if m == nil {
736		return nil, nil
737	}
738	size := m.SizeVT()
739	dAtA = make([]byte, size)
740	n, err := m.MarshalToSizedBufferVT(dAtA[:size])
741	if err != nil {
742		return nil, err
743	}
744	return dAtA[:n], nil
745}
746 
747func (m *MembershipConclusionResponse) MarshalToVT(dAtA []byte) (int, error) {
748	size := m.SizeVT()
749	return m.MarshalToSizedBufferVT(dAtA[:size])
750}
751 
752func (m *MembershipConclusionResponse) MarshalToSizedBufferVT(dAtA []byte) (int, error) {
753	if m == nil {
754		return 0, nil
755	}
756	i := len(dAtA)
757	_ = i
758	var l int
759	_ = l
760	if m.unknownFields != nil {
761		i -= len(m.unknownFields)
762		copy(dAtA[i:], m.unknownFields)
763	}
764	return len(dAtA) - i, nil
765}
766 
767func (m *Empty) SizeVT() (n int) {
768	if m == nil {
769		return 0
770	}
771	var l int
772	_ = l
773	n += len(m.unknownFields)
774	return n
775}
776 
777func (m *IdentityRequest) SizeVT() (n int) {
778	if m == nil {
779		return 0
780	}
781	var l int
782	_ = l
783	n += len(m.unknownFields)
784	return n
785}
786 
787func (m *IdentityResponse) SizeVT() (n int) {
788	if m == nil {
789		return 0
790	}
791	var l int
792	_ = l
793	if m.Identity != nil {
794		l = m.Identity.SizeVT()
795		n += 1 + l + protohelpers.SizeOfVarint(uint64(l))
796	}
797	n += len(m.unknownFields)
798	return n
799}
800 
801func (m *PingRequest) SizeVT() (n int) {
802	if m == nil {
803		return 0
804	}
805	var l int
806	_ = l
807	n += len(m.unknownFields)
808	return n
809}
810 
811func (m *PingResponse) SizeVT() (n int) {
812	if m == nil {
813		return 0
814	}
815	var l int
816	_ = l
817	n += len(m.unknownFields)
818	return n
819}
820 
821func (m *NotifyRequest) SizeVT() (n int) {
822	if m == nil {
823		return 0
824	}
825	var l int
826	_ = l
827	if m.Predecessor != nil {
828		l = m.Predecessor.SizeVT()
829		n += 1 + l + protohelpers.SizeOfVarint(uint64(l))
830	}
831	n += len(m.unknownFields)
832	return n
833}
834 
835func (m *NotifyResponse) SizeVT() (n int) {
836	if m == nil {
837		return 0
838	}
839	var l int
840	_ = l
841	n += len(m.unknownFields)
842	return n
843}
844 
845func (m *FindSuccessorRequest) SizeVT() (n int) {
846	if m == nil {
847		return 0
848	}
849	var l int
850	_ = l
851	if m.Key != 0 {
852		n += 1 + protohelpers.SizeOfVarint(uint64(m.Key))
853	}
854	n += len(m.unknownFields)
855	return n
856}
857 
858func (m *FindSuccessorResponse) SizeVT() (n int) {
859	if m == nil {
860		return 0
861	}
862	var l int
863	_ = l
864	if m.Successor != nil {
865		l = m.Successor.SizeVT()
866		n += 1 + l + protohelpers.SizeOfVarint(uint64(l))
867	}
868	n += len(m.unknownFields)
869	return n
870}
871 
872func (m *GetPredecessorRequest) SizeVT() (n int) {
873	if m == nil {
874		return 0
875	}
876	var l int
877	_ = l
878	n += len(m.unknownFields)
879	return n
880}
881 
882func (m *GetPredecessorResponse) SizeVT() (n int) {
883	if m == nil {
884		return 0
885	}
886	var l int
887	_ = l
888	if m.Predecessor != nil {
889		l = m.Predecessor.SizeVT()
890		n += 1 + l + protohelpers.SizeOfVarint(uint64(l))
891	}
892	n += len(m.unknownFields)
893	return n
894}
895 
896func (m *GetSuccessorsRequest) SizeVT() (n int) {
897	if m == nil {
898		return 0
899	}
900	var l int
901	_ = l
902	n += len(m.unknownFields)
903	return n
904}
905 
906func (m *GetSuccessorsResponse) SizeVT() (n int) {
907	if m == nil {
908		return 0
909	}
910	var l int
911	_ = l
912	if len(m.Successors) > 0 {
913		for _, e := range m.Successors {
914			l = e.SizeVT()
915			n += 1 + l + protohelpers.SizeOfVarint(uint64(l))
916		}
917	}
918	n += len(m.unknownFields)
919	return n
920}
921 
922func (m *RequestToJoinRequest) SizeVT() (n int) {
923	if m == nil {
924		return 0
925	}
926	var l int
927	_ = l
928	if m.Joiner != nil {
929		l = m.Joiner.SizeVT()
930		n += 1 + l + protohelpers.SizeOfVarint(uint64(l))
931	}
932	n += len(m.unknownFields)
933	return n
934}
935 
936func (m *RequestToJoinResponse) SizeVT() (n int) {
937	if m == nil {
938		return 0
939	}
940	var l int
941	_ = l
942	if m.Predecessor != nil {
943		l = m.Predecessor.SizeVT()
944		n += 1 + l + protohelpers.SizeOfVarint(uint64(l))
945	}
946	if len(m.Successors) > 0 {
947		for _, e := range m.Successors {
948			l = e.SizeVT()
949			n += 1 + l + protohelpers.SizeOfVarint(uint64(l))
950		}
951	}
952	n += len(m.unknownFields)
953	return n
954}
955 
956func (m *RequestToLeaveRequest) SizeVT() (n int) {
957	if m == nil {
958		return 0
959	}
960	var l int
961	_ = l
962	if m.Leaver != nil {
963		l = m.Leaver.SizeVT()
964		n += 1 + l + protohelpers.SizeOfVarint(uint64(l))
965	}
966	n += len(m.unknownFields)
967	return n
968}
969 
970func (m *RequestToLeaveResponse) SizeVT() (n int) {
971	if m == nil {
972		return 0
973	}
974	var l int
975	_ = l
976	n += len(m.unknownFields)
977	return n
978}
979 
980func (m *MembershipConclusionRequest) SizeVT() (n int) {
981	if m == nil {
982		return 0
983	}
984	var l int
985	_ = l
986	if m.Stabilize {
987		n += 2
988	}
989	if m.Release {
990		n += 2
991	}
992	n += len(m.unknownFields)
993	return n
994}
995 
996func (m *MembershipConclusionResponse) SizeVT() (n int) {
997	if m == nil {
998		return 0
999	}
1000	var l int
1001	_ = l
1002	n += len(m.unknownFields)
1003	return n
1004}
1005 
1006func (m *Empty) UnmarshalVT(dAtA []byte) error {
1007	l := len(dAtA)
1008	iNdEx := 0
1009	for iNdEx < l {
1010		preIndex := iNdEx
1011		var wire uint64
1012		for shift := uint(0); ; shift += 7 {
1013			if shift >= 64 {
1014				return protohelpers.ErrIntOverflow
1015			}
1016			if iNdEx >= l {
1017				return io.ErrUnexpectedEOF
1018			}
1019			b := dAtA[iNdEx]
1020			iNdEx++
1021			wire |= uint64(b&0x7F) << shift
1022			if b < 0x80 {
1023				break
1024			}
1025		}
1026		fieldNum := int32(wire >> 3)
1027		wireType := int(wire & 0x7)
1028		if wireType == 4 {
1029			return fmt.Errorf("proto: Empty: wiretype end group for non-group")
1030		}
1031		if fieldNum <= 0 {
1032			return fmt.Errorf("proto: Empty: illegal tag %d (wire type %d)", fieldNum, wire)
1033		}
1034		switch fieldNum {
1035		default:
1036			iNdEx = preIndex
1037			skippy, err := protohelpers.Skip(dAtA[iNdEx:])
1038			if err != nil {
1039				return err
1040			}
1041			if (skippy < 0) || (iNdEx+skippy) < 0 {
1042				return protohelpers.ErrInvalidLength
1043			}
1044			if (iNdEx + skippy) > l {
1045				return io.ErrUnexpectedEOF
1046			}
1047			m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...)
1048			iNdEx += skippy
1049		}
1050	}
1051 
1052	if iNdEx > l {
1053		return io.ErrUnexpectedEOF
1054	}
1055	return nil
1056}
1057func (m *IdentityRequest) UnmarshalVT(dAtA []byte) error {
1058	l := len(dAtA)
1059	iNdEx := 0
1060	for iNdEx < l {
1061		preIndex := iNdEx
1062		var wire uint64
1063		for shift := uint(0); ; shift += 7 {
1064			if shift >= 64 {
1065				return protohelpers.ErrIntOverflow
1066			}
1067			if iNdEx >= l {
1068				return io.ErrUnexpectedEOF
1069			}
1070			b := dAtA[iNdEx]
1071			iNdEx++
1072			wire |= uint64(b&0x7F) << shift
1073			if b < 0x80 {
1074				break
1075			}
1076		}
1077		fieldNum := int32(wire >> 3)
1078		wireType := int(wire & 0x7)
1079		if wireType == 4 {
1080			return fmt.Errorf("proto: IdentityRequest: wiretype end group for non-group")
1081		}
1082		if fieldNum <= 0 {
1083			return fmt.Errorf("proto: IdentityRequest: illegal tag %d (wire type %d)", fieldNum, wire)
1084		}
1085		switch fieldNum {
1086		default:
1087			iNdEx = preIndex
1088			skippy, err := protohelpers.Skip(dAtA[iNdEx:])
1089			if err != nil {
1090				return err
1091			}
1092			if (skippy < 0) || (iNdEx+skippy) < 0 {
1093				return protohelpers.ErrInvalidLength
1094			}
1095			if (iNdEx + skippy) > l {
1096				return io.ErrUnexpectedEOF
1097			}
1098			m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...)
1099			iNdEx += skippy
1100		}
1101	}
1102 
1103	if iNdEx > l {
1104		return io.ErrUnexpectedEOF
1105	}
1106	return nil
1107}
1108func (m *IdentityResponse) UnmarshalVT(dAtA []byte) error {
1109	l := len(dAtA)
1110	iNdEx := 0
1111	for iNdEx < l {
1112		preIndex := iNdEx
1113		var wire uint64
1114		for shift := uint(0); ; shift += 7 {
1115			if shift >= 64 {
1116				return protohelpers.ErrIntOverflow
1117			}
1118			if iNdEx >= l {
1119				return io.ErrUnexpectedEOF
1120			}
1121			b := dAtA[iNdEx]
1122			iNdEx++
1123			wire |= uint64(b&0x7F) << shift
1124			if b < 0x80 {
1125				break
1126			}
1127		}
1128		fieldNum := int32(wire >> 3)
1129		wireType := int(wire & 0x7)
1130		if wireType == 4 {
1131			return fmt.Errorf("proto: IdentityResponse: wiretype end group for non-group")
1132		}
1133		if fieldNum <= 0 {
1134			return fmt.Errorf("proto: IdentityResponse: illegal tag %d (wire type %d)", fieldNum, wire)
1135		}
1136		switch fieldNum {
1137		case 1:
1138			if wireType != 2 {
1139				return fmt.Errorf("proto: wrong wireType = %d for field Identity", wireType)
1140			}
1141			var msglen int
1142			for shift := uint(0); ; shift += 7 {
1143				if shift >= 64 {
1144					return protohelpers.ErrIntOverflow
1145				}
1146				if iNdEx >= l {
1147					return io.ErrUnexpectedEOF
1148				}
1149				b := dAtA[iNdEx]
1150				iNdEx++
1151				msglen |= int(b&0x7F) << shift
1152				if b < 0x80 {
1153					break
1154				}
1155			}
1156			if msglen < 0 {
1157				return protohelpers.ErrInvalidLength
1158			}
1159			postIndex := iNdEx + msglen
1160			if postIndex < 0 {
1161				return protohelpers.ErrInvalidLength
1162			}
1163			if postIndex > l {
1164				return io.ErrUnexpectedEOF
1165			}
1166			if m.Identity == nil {
1167				m.Identity = &Node{}
1168			}
1169			if err := m.Identity.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil {
1170				return err
1171			}
1172			iNdEx = postIndex
1173		default:
1174			iNdEx = preIndex
1175			skippy, err := protohelpers.Skip(dAtA[iNdEx:])
1176			if err != nil {
1177				return err
1178			}
1179			if (skippy < 0) || (iNdEx+skippy) < 0 {
1180				return protohelpers.ErrInvalidLength
1181			}
1182			if (iNdEx + skippy) > l {
1183				return io.ErrUnexpectedEOF
1184			}
1185			m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...)
1186			iNdEx += skippy
1187		}
1188	}
1189 
1190	if iNdEx > l {
1191		return io.ErrUnexpectedEOF
1192	}
1193	return nil
1194}
1195func (m *PingRequest) UnmarshalVT(dAtA []byte) error {
1196	l := len(dAtA)
1197	iNdEx := 0
1198	for iNdEx < l {
1199		preIndex := iNdEx
1200		var wire uint64
1201		for shift := uint(0); ; shift += 7 {
1202			if shift >= 64 {
1203				return protohelpers.ErrIntOverflow
1204			}
1205			if iNdEx >= l {
1206				return io.ErrUnexpectedEOF
1207			}
1208			b := dAtA[iNdEx]
1209			iNdEx++
1210			wire |= uint64(b&0x7F) << shift
1211			if b < 0x80 {
1212				break
1213			}
1214		}
1215		fieldNum := int32(wire >> 3)
1216		wireType := int(wire & 0x7)
1217		if wireType == 4 {
1218			return fmt.Errorf("proto: PingRequest: wiretype end group for non-group")
1219		}
1220		if fieldNum <= 0 {
1221			return fmt.Errorf("proto: PingRequest: illegal tag %d (wire type %d)", fieldNum, wire)
1222		}
1223		switch fieldNum {
1224		default:
1225			iNdEx = preIndex
1226			skippy, err := protohelpers.Skip(dAtA[iNdEx:])
1227			if err != nil {
1228				return err
1229			}
1230			if (skippy < 0) || (iNdEx+skippy) < 0 {
1231				return protohelpers.ErrInvalidLength
1232			}
1233			if (iNdEx + skippy) > l {
1234				return io.ErrUnexpectedEOF
1235			}
1236			m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...)
1237			iNdEx += skippy
1238		}
1239	}
1240 
1241	if iNdEx > l {
1242		return io.ErrUnexpectedEOF
1243	}
1244	return nil
1245}
1246func (m *PingResponse) UnmarshalVT(dAtA []byte) error {
1247	l := len(dAtA)
1248	iNdEx := 0
1249	for iNdEx < l {
1250		preIndex := iNdEx
1251		var wire uint64
1252		for shift := uint(0); ; shift += 7 {
1253			if shift >= 64 {
1254				return protohelpers.ErrIntOverflow
1255			}
1256			if iNdEx >= l {
1257				return io.ErrUnexpectedEOF
1258			}
1259			b := dAtA[iNdEx]
1260			iNdEx++
1261			wire |= uint64(b&0x7F) << shift
1262			if b < 0x80 {
1263				break
1264			}
1265		}
1266		fieldNum := int32(wire >> 3)
1267		wireType := int(wire & 0x7)
1268		if wireType == 4 {
1269			return fmt.Errorf("proto: PingResponse: wiretype end group for non-group")
1270		}
1271		if fieldNum <= 0 {
1272			return fmt.Errorf("proto: PingResponse: illegal tag %d (wire type %d)", fieldNum, wire)
1273		}
1274		switch fieldNum {
1275		default:
1276			iNdEx = preIndex
1277			skippy, err := protohelpers.Skip(dAtA[iNdEx:])
1278			if err != nil {
1279				return err
1280			}
1281			if (skippy < 0) || (iNdEx+skippy) < 0 {
1282				return protohelpers.ErrInvalidLength
1283			}
1284			if (iNdEx + skippy) > l {
1285				return io.ErrUnexpectedEOF
1286			}
1287			m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...)
1288			iNdEx += skippy
1289		}
1290	}
1291 
1292	if iNdEx > l {
1293		return io.ErrUnexpectedEOF
1294	}
1295	return nil
1296}
1297func (m *NotifyRequest) UnmarshalVT(dAtA []byte) error {
1298	l := len(dAtA)
1299	iNdEx := 0
1300	for iNdEx < l {
1301		preIndex := iNdEx
1302		var wire uint64
1303		for shift := uint(0); ; shift += 7 {
1304			if shift >= 64 {
1305				return protohelpers.ErrIntOverflow
1306			}
1307			if iNdEx >= l {
1308				return io.ErrUnexpectedEOF
1309			}
1310			b := dAtA[iNdEx]
1311			iNdEx++
1312			wire |= uint64(b&0x7F) << shift
1313			if b < 0x80 {
1314				break
1315			}
1316		}
1317		fieldNum := int32(wire >> 3)
1318		wireType := int(wire & 0x7)
1319		if wireType == 4 {
1320			return fmt.Errorf("proto: NotifyRequest: wiretype end group for non-group")
1321		}
1322		if fieldNum <= 0 {
1323			return fmt.Errorf("proto: NotifyRequest: illegal tag %d (wire type %d)", fieldNum, wire)
1324		}
1325		switch fieldNum {
1326		case 1:
1327			if wireType != 2 {
1328				return fmt.Errorf("proto: wrong wireType = %d for field Predecessor", wireType)
1329			}
1330			var msglen int
1331			for shift := uint(0); ; shift += 7 {
1332				if shift >= 64 {
1333					return protohelpers.ErrIntOverflow
1334				}
1335				if iNdEx >= l {
1336					return io.ErrUnexpectedEOF
1337				}
1338				b := dAtA[iNdEx]
1339				iNdEx++
1340				msglen |= int(b&0x7F) << shift
1341				if b < 0x80 {
1342					break
1343				}
1344			}
1345			if msglen < 0 {
1346				return protohelpers.ErrInvalidLength
1347			}
1348			postIndex := iNdEx + msglen
1349			if postIndex < 0 {
1350				return protohelpers.ErrInvalidLength
1351			}
1352			if postIndex > l {
1353				return io.ErrUnexpectedEOF
1354			}
1355			if m.Predecessor == nil {
1356				m.Predecessor = &Node{}
1357			}
1358			if err := m.Predecessor.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil {
1359				return err
1360			}
1361			iNdEx = postIndex
1362		default:
1363			iNdEx = preIndex
1364			skippy, err := protohelpers.Skip(dAtA[iNdEx:])
1365			if err != nil {
1366				return err
1367			}
1368			if (skippy < 0) || (iNdEx+skippy) < 0 {
1369				return protohelpers.ErrInvalidLength
1370			}
1371			if (iNdEx + skippy) > l {
1372				return io.ErrUnexpectedEOF
1373			}
1374			m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...)
1375			iNdEx += skippy
1376		}
1377	}
1378 
1379	if iNdEx > l {
1380		return io.ErrUnexpectedEOF
1381	}
1382	return nil
1383}
1384func (m *NotifyResponse) UnmarshalVT(dAtA []byte) error {
1385	l := len(dAtA)
1386	iNdEx := 0
1387	for iNdEx < l {
1388		preIndex := iNdEx
1389		var wire uint64
1390		for shift := uint(0); ; shift += 7 {
1391			if shift >= 64 {
1392				return protohelpers.ErrIntOverflow
1393			}
1394			if iNdEx >= l {
1395				return io.ErrUnexpectedEOF
1396			}
1397			b := dAtA[iNdEx]
1398			iNdEx++
1399			wire |= uint64(b&0x7F) << shift
1400			if b < 0x80 {
1401				break
1402			}
1403		}
1404		fieldNum := int32(wire >> 3)
1405		wireType := int(wire & 0x7)
1406		if wireType == 4 {
1407			return fmt.Errorf("proto: NotifyResponse: wiretype end group for non-group")
1408		}
1409		if fieldNum <= 0 {
1410			return fmt.Errorf("proto: NotifyResponse: illegal tag %d (wire type %d)", fieldNum, wire)
1411		}
1412		switch fieldNum {
1413		default:
1414			iNdEx = preIndex
1415			skippy, err := protohelpers.Skip(dAtA[iNdEx:])
1416			if err != nil {
1417				return err
1418			}
1419			if (skippy < 0) || (iNdEx+skippy) < 0 {
1420				return protohelpers.ErrInvalidLength
1421			}
1422			if (iNdEx + skippy) > l {
1423				return io.ErrUnexpectedEOF
1424			}
1425			m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...)
1426			iNdEx += skippy
1427		}
1428	}
1429 
1430	if iNdEx > l {
1431		return io.ErrUnexpectedEOF
1432	}
1433	return nil
1434}
1435func (m *FindSuccessorRequest) UnmarshalVT(dAtA []byte) error {
1436	l := len(dAtA)
1437	iNdEx := 0
1438	for iNdEx < l {
1439		preIndex := iNdEx
1440		var wire uint64
1441		for shift := uint(0); ; shift += 7 {
1442			if shift >= 64 {
1443				return protohelpers.ErrIntOverflow
1444			}
1445			if iNdEx >= l {
1446				return io.ErrUnexpectedEOF
1447			}
1448			b := dAtA[iNdEx]
1449			iNdEx++
1450			wire |= uint64(b&0x7F) << shift
1451			if b < 0x80 {
1452				break
1453			}
1454		}
1455		fieldNum := int32(wire >> 3)
1456		wireType := int(wire & 0x7)
1457		if wireType == 4 {
1458			return fmt.Errorf("proto: FindSuccessorRequest: wiretype end group for non-group")
1459		}
1460		if fieldNum <= 0 {
1461			return fmt.Errorf("proto: FindSuccessorRequest: illegal tag %d (wire type %d)", fieldNum, wire)
1462		}
1463		switch fieldNum {
1464		case 1:
1465			if wireType != 0 {
1466				return fmt.Errorf("proto: wrong wireType = %d for field Key", wireType)
1467			}
1468			m.Key = 0
1469			for shift := uint(0); ; shift += 7 {
1470				if shift >= 64 {
1471					return protohelpers.ErrIntOverflow
1472				}
1473				if iNdEx >= l {
1474					return io.ErrUnexpectedEOF
1475				}
1476				b := dAtA[iNdEx]
1477				iNdEx++
1478				m.Key |= uint64(b&0x7F) << shift
1479				if b < 0x80 {
1480					break
1481				}
1482			}
1483		default:
1484			iNdEx = preIndex
1485			skippy, err := protohelpers.Skip(dAtA[iNdEx:])
1486			if err != nil {
1487				return err
1488			}
1489			if (skippy < 0) || (iNdEx+skippy) < 0 {
1490				return protohelpers.ErrInvalidLength
1491			}
1492			if (iNdEx + skippy) > l {
1493				return io.ErrUnexpectedEOF
1494			}
1495			m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...)
1496			iNdEx += skippy
1497		}
1498	}
1499 
1500	if iNdEx > l {
1501		return io.ErrUnexpectedEOF
1502	}
1503	return nil
1504}
1505func (m *FindSuccessorResponse) UnmarshalVT(dAtA []byte) error {
1506	l := len(dAtA)
1507	iNdEx := 0
1508	for iNdEx < l {
1509		preIndex := iNdEx
1510		var wire uint64
1511		for shift := uint(0); ; shift += 7 {
1512			if shift >= 64 {
1513				return protohelpers.ErrIntOverflow
1514			}
1515			if iNdEx >= l {
1516				return io.ErrUnexpectedEOF
1517			}
1518			b := dAtA[iNdEx]
1519			iNdEx++
1520			wire |= uint64(b&0x7F) << shift
1521			if b < 0x80 {
1522				break
1523			}
1524		}
1525		fieldNum := int32(wire >> 3)
1526		wireType := int(wire & 0x7)
1527		if wireType == 4 {
1528			return fmt.Errorf("proto: FindSuccessorResponse: wiretype end group for non-group")
1529		}
1530		if fieldNum <= 0 {
1531			return fmt.Errorf("proto: FindSuccessorResponse: illegal tag %d (wire type %d)", fieldNum, wire)
1532		}
1533		switch fieldNum {
1534		case 1:
1535			if wireType != 2 {
1536				return fmt.Errorf("proto: wrong wireType = %d for field Successor", wireType)
1537			}
1538			var msglen int
1539			for shift := uint(0); ; shift += 7 {
1540				if shift >= 64 {
1541					return protohelpers.ErrIntOverflow
1542				}
1543				if iNdEx >= l {
1544					return io.ErrUnexpectedEOF
1545				}
1546				b := dAtA[iNdEx]
1547				iNdEx++
1548				msglen |= int(b&0x7F) << shift
1549				if b < 0x80 {
1550					break
1551				}
1552			}
1553			if msglen < 0 {
1554				return protohelpers.ErrInvalidLength
1555			}
1556			postIndex := iNdEx + msglen
1557			if postIndex < 0 {
1558				return protohelpers.ErrInvalidLength
1559			}
1560			if postIndex > l {
1561				return io.ErrUnexpectedEOF
1562			}
1563			if m.Successor == nil {
1564				m.Successor = &Node{}
1565			}
1566			if err := m.Successor.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil {
1567				return err
1568			}
1569			iNdEx = postIndex
1570		default:
1571			iNdEx = preIndex
1572			skippy, err := protohelpers.Skip(dAtA[iNdEx:])
1573			if err != nil {
1574				return err
1575			}
1576			if (skippy < 0) || (iNdEx+skippy) < 0 {
1577				return protohelpers.ErrInvalidLength
1578			}
1579			if (iNdEx + skippy) > l {
1580				return io.ErrUnexpectedEOF
1581			}
1582			m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...)
1583			iNdEx += skippy
1584		}
1585	}
1586 
1587	if iNdEx > l {
1588		return io.ErrUnexpectedEOF
1589	}
1590	return nil
1591}
1592func (m *GetPredecessorRequest) UnmarshalVT(dAtA []byte) error {
1593	l := len(dAtA)
1594	iNdEx := 0
1595	for iNdEx < l {
1596		preIndex := iNdEx
1597		var wire uint64
1598		for shift := uint(0); ; shift += 7 {
1599			if shift >= 64 {
1600				return protohelpers.ErrIntOverflow
1601			}
1602			if iNdEx >= l {
1603				return io.ErrUnexpectedEOF
1604			}
1605			b := dAtA[iNdEx]
1606			iNdEx++
1607			wire |= uint64(b&0x7F) << shift
1608			if b < 0x80 {
1609				break
1610			}
1611		}
1612		fieldNum := int32(wire >> 3)
1613		wireType := int(wire & 0x7)
1614		if wireType == 4 {
1615			return fmt.Errorf("proto: GetPredecessorRequest: wiretype end group for non-group")
1616		}
1617		if fieldNum <= 0 {
1618			return fmt.Errorf("proto: GetPredecessorRequest: illegal tag %d (wire type %d)", fieldNum, wire)
1619		}
1620		switch fieldNum {
1621		default:
1622			iNdEx = preIndex
1623			skippy, err := protohelpers.Skip(dAtA[iNdEx:])
1624			if err != nil {
1625				return err
1626			}
1627			if (skippy < 0) || (iNdEx+skippy) < 0 {
1628				return protohelpers.ErrInvalidLength
1629			}
1630			if (iNdEx + skippy) > l {
1631				return io.ErrUnexpectedEOF
1632			}
1633			m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...)
1634			iNdEx += skippy
1635		}
1636	}
1637 
1638	if iNdEx > l {
1639		return io.ErrUnexpectedEOF
1640	}
1641	return nil
1642}
1643func (m *GetPredecessorResponse) UnmarshalVT(dAtA []byte) error {
1644	l := len(dAtA)
1645	iNdEx := 0
1646	for iNdEx < l {
1647		preIndex := iNdEx
1648		var wire uint64
1649		for shift := uint(0); ; shift += 7 {
1650			if shift >= 64 {
1651				return protohelpers.ErrIntOverflow
1652			}
1653			if iNdEx >= l {
1654				return io.ErrUnexpectedEOF
1655			}
1656			b := dAtA[iNdEx]
1657			iNdEx++
1658			wire |= uint64(b&0x7F) << shift
1659			if b < 0x80 {
1660				break
1661			}
1662		}
1663		fieldNum := int32(wire >> 3)
1664		wireType := int(wire & 0x7)
1665		if wireType == 4 {
1666			return fmt.Errorf("proto: GetPredecessorResponse: wiretype end group for non-group")
1667		}
1668		if fieldNum <= 0 {
1669			return fmt.Errorf("proto: GetPredecessorResponse: illegal tag %d (wire type %d)", fieldNum, wire)
1670		}
1671		switch fieldNum {
1672		case 1:
1673			if wireType != 2 {
1674				return fmt.Errorf("proto: wrong wireType = %d for field Predecessor", wireType)
1675			}
1676			var msglen int
1677			for shift := uint(0); ; shift += 7 {
1678				if shift >= 64 {
1679					return protohelpers.ErrIntOverflow
1680				}
1681				if iNdEx >= l {
1682					return io.ErrUnexpectedEOF
1683				}
1684				b := dAtA[iNdEx]
1685				iNdEx++
1686				msglen |= int(b&0x7F) << shift
1687				if b < 0x80 {
1688					break
1689				}
1690			}
1691			if msglen < 0 {
1692				return protohelpers.ErrInvalidLength
1693			}
1694			postIndex := iNdEx + msglen
1695			if postIndex < 0 {
1696				return protohelpers.ErrInvalidLength
1697			}
1698			if postIndex > l {
1699				return io.ErrUnexpectedEOF
1700			}
1701			if m.Predecessor == nil {
1702				m.Predecessor = &Node{}
1703			}
1704			if err := m.Predecessor.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil {
1705				return err
1706			}
1707			iNdEx = postIndex
1708		default:
1709			iNdEx = preIndex
1710			skippy, err := protohelpers.Skip(dAtA[iNdEx:])
1711			if err != nil {
1712				return err
1713			}
1714			if (skippy < 0) || (iNdEx+skippy) < 0 {
1715				return protohelpers.ErrInvalidLength
1716			}
1717			if (iNdEx + skippy) > l {
1718				return io.ErrUnexpectedEOF
1719			}
1720			m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...)
1721			iNdEx += skippy
1722		}
1723	}
1724 
1725	if iNdEx > l {
1726		return io.ErrUnexpectedEOF
1727	}
1728	return nil
1729}
1730func (m *GetSuccessorsRequest) UnmarshalVT(dAtA []byte) error {
1731	l := len(dAtA)
1732	iNdEx := 0
1733	for iNdEx < l {
1734		preIndex := iNdEx
1735		var wire uint64
1736		for shift := uint(0); ; shift += 7 {
1737			if shift >= 64 {
1738				return protohelpers.ErrIntOverflow
1739			}
1740			if iNdEx >= l {
1741				return io.ErrUnexpectedEOF
1742			}
1743			b := dAtA[iNdEx]
1744			iNdEx++
1745			wire |= uint64(b&0x7F) << shift
1746			if b < 0x80 {
1747				break
1748			}
1749		}
1750		fieldNum := int32(wire >> 3)
1751		wireType := int(wire & 0x7)
1752		if wireType == 4 {
1753			return fmt.Errorf("proto: GetSuccessorsRequest: wiretype end group for non-group")
1754		}
1755		if fieldNum <= 0 {
1756			return fmt.Errorf("proto: GetSuccessorsRequest: illegal tag %d (wire type %d)", fieldNum, wire)
1757		}
1758		switch fieldNum {
1759		default:
1760			iNdEx = preIndex
1761			skippy, err := protohelpers.Skip(dAtA[iNdEx:])
1762			if err != nil {
1763				return err
1764			}
1765			if (skippy < 0) || (iNdEx+skippy) < 0 {
1766				return protohelpers.ErrInvalidLength
1767			}
1768			if (iNdEx + skippy) > l {
1769				return io.ErrUnexpectedEOF
1770			}
1771			m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...)
1772			iNdEx += skippy
1773		}
1774	}
1775 
1776	if iNdEx > l {
1777		return io.ErrUnexpectedEOF
1778	}
1779	return nil
1780}
1781func (m *GetSuccessorsResponse) UnmarshalVT(dAtA []byte) error {
1782	l := len(dAtA)
1783	iNdEx := 0
1784	for iNdEx < l {
1785		preIndex := iNdEx
1786		var wire uint64
1787		for shift := uint(0); ; shift += 7 {
1788			if shift >= 64 {
1789				return protohelpers.ErrIntOverflow
1790			}
1791			if iNdEx >= l {
1792				return io.ErrUnexpectedEOF
1793			}
1794			b := dAtA[iNdEx]
1795			iNdEx++
1796			wire |= uint64(b&0x7F) << shift
1797			if b < 0x80 {
1798				break
1799			}
1800		}
1801		fieldNum := int32(wire >> 3)
1802		wireType := int(wire & 0x7)
1803		if wireType == 4 {
1804			return fmt.Errorf("proto: GetSuccessorsResponse: wiretype end group for non-group")
1805		}
1806		if fieldNum <= 0 {
1807			return fmt.Errorf("proto: GetSuccessorsResponse: illegal tag %d (wire type %d)", fieldNum, wire)
1808		}
1809		switch fieldNum {
1810		case 1:
1811			if wireType != 2 {
1812				return fmt.Errorf("proto: wrong wireType = %d for field Successors", wireType)
1813			}
1814			var msglen int
1815			for shift := uint(0); ; shift += 7 {
1816				if shift >= 64 {
1817					return protohelpers.ErrIntOverflow
1818				}
1819				if iNdEx >= l {
1820					return io.ErrUnexpectedEOF
1821				}
1822				b := dAtA[iNdEx]
1823				iNdEx++
1824				msglen |= int(b&0x7F) << shift
1825				if b < 0x80 {
1826					break
1827				}
1828			}
1829			if msglen < 0 {
1830				return protohelpers.ErrInvalidLength
1831			}
1832			postIndex := iNdEx + msglen
1833			if postIndex < 0 {
1834				return protohelpers.ErrInvalidLength
1835			}
1836			if postIndex > l {
1837				return io.ErrUnexpectedEOF
1838			}
1839			m.Successors = append(m.Successors, &Node{})
1840			if err := m.Successors[len(m.Successors)-1].UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil {
1841				return err
1842			}
1843			iNdEx = postIndex
1844		default:
1845			iNdEx = preIndex
1846			skippy, err := protohelpers.Skip(dAtA[iNdEx:])
1847			if err != nil {
1848				return err
1849			}
1850			if (skippy < 0) || (iNdEx+skippy) < 0 {
1851				return protohelpers.ErrInvalidLength
1852			}
1853			if (iNdEx + skippy) > l {
1854				return io.ErrUnexpectedEOF
1855			}
1856			m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...)
1857			iNdEx += skippy
1858		}
1859	}
1860 
1861	if iNdEx > l {
1862		return io.ErrUnexpectedEOF
1863	}
1864	return nil
1865}
1866func (m *RequestToJoinRequest) UnmarshalVT(dAtA []byte) error {
1867	l := len(dAtA)
1868	iNdEx := 0
1869	for iNdEx < l {
1870		preIndex := iNdEx
1871		var wire uint64
1872		for shift := uint(0); ; shift += 7 {
1873			if shift >= 64 {
1874				return protohelpers.ErrIntOverflow
1875			}
1876			if iNdEx >= l {
1877				return io.ErrUnexpectedEOF
1878			}
1879			b := dAtA[iNdEx]
1880			iNdEx++
1881			wire |= uint64(b&0x7F) << shift
1882			if b < 0x80 {
1883				break
1884			}
1885		}
1886		fieldNum := int32(wire >> 3)
1887		wireType := int(wire & 0x7)
1888		if wireType == 4 {
1889			return fmt.Errorf("proto: RequestToJoinRequest: wiretype end group for non-group")
1890		}
1891		if fieldNum <= 0 {
1892			return fmt.Errorf("proto: RequestToJoinRequest: illegal tag %d (wire type %d)", fieldNum, wire)
1893		}
1894		switch fieldNum {
1895		case 1:
1896			if wireType != 2 {
1897				return fmt.Errorf("proto: wrong wireType = %d for field Joiner", wireType)
1898			}
1899			var msglen int
1900			for shift := uint(0); ; shift += 7 {
1901				if shift >= 64 {
1902					return protohelpers.ErrIntOverflow
1903				}
1904				if iNdEx >= l {
1905					return io.ErrUnexpectedEOF
1906				}
1907				b := dAtA[iNdEx]
1908				iNdEx++
1909				msglen |= int(b&0x7F) << shift
1910				if b < 0x80 {
1911					break
1912				}
1913			}
1914			if msglen < 0 {
1915				return protohelpers.ErrInvalidLength
1916			}
1917			postIndex := iNdEx + msglen
1918			if postIndex < 0 {
1919				return protohelpers.ErrInvalidLength
1920			}
1921			if postIndex > l {
1922				return io.ErrUnexpectedEOF
1923			}
1924			if m.Joiner == nil {
1925				m.Joiner = &Node{}
1926			}
1927			if err := m.Joiner.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil {
1928				return err
1929			}
1930			iNdEx = postIndex
1931		default:
1932			iNdEx = preIndex
1933			skippy, err := protohelpers.Skip(dAtA[iNdEx:])
1934			if err != nil {
1935				return err
1936			}
1937			if (skippy < 0) || (iNdEx+skippy) < 0 {
1938				return protohelpers.ErrInvalidLength
1939			}
1940			if (iNdEx + skippy) > l {
1941				return io.ErrUnexpectedEOF
1942			}
1943			m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...)
1944			iNdEx += skippy
1945		}
1946	}
1947 
1948	if iNdEx > l {
1949		return io.ErrUnexpectedEOF
1950	}
1951	return nil
1952}
1953func (m *RequestToJoinResponse) UnmarshalVT(dAtA []byte) error {
1954	l := len(dAtA)
1955	iNdEx := 0
1956	for iNdEx < l {
1957		preIndex := iNdEx
1958		var wire uint64
1959		for shift := uint(0); ; shift += 7 {
1960			if shift >= 64 {
1961				return protohelpers.ErrIntOverflow
1962			}
1963			if iNdEx >= l {
1964				return io.ErrUnexpectedEOF
1965			}
1966			b := dAtA[iNdEx]
1967			iNdEx++
1968			wire |= uint64(b&0x7F) << shift
1969			if b < 0x80 {
1970				break
1971			}
1972		}
1973		fieldNum := int32(wire >> 3)
1974		wireType := int(wire & 0x7)
1975		if wireType == 4 {
1976			return fmt.Errorf("proto: RequestToJoinResponse: wiretype end group for non-group")
1977		}
1978		if fieldNum <= 0 {
1979			return fmt.Errorf("proto: RequestToJoinResponse: illegal tag %d (wire type %d)", fieldNum, wire)
1980		}
1981		switch fieldNum {
1982		case 1:
1983			if wireType != 2 {
1984				return fmt.Errorf("proto: wrong wireType = %d for field Predecessor", wireType)
1985			}
1986			var msglen int
1987			for shift := uint(0); ; shift += 7 {
1988				if shift >= 64 {
1989					return protohelpers.ErrIntOverflow
1990				}
1991				if iNdEx >= l {
1992					return io.ErrUnexpectedEOF
1993				}
1994				b := dAtA[iNdEx]
1995				iNdEx++
1996				msglen |= int(b&0x7F) << shift
1997				if b < 0x80 {
1998					break
1999				}
2000			}
2001			if msglen < 0 {
2002				return protohelpers.ErrInvalidLength
2003			}
2004			postIndex := iNdEx + msglen
2005			if postIndex < 0 {
2006				return protohelpers.ErrInvalidLength
2007			}
2008			if postIndex > l {
2009				return io.ErrUnexpectedEOF
2010			}
2011			if m.Predecessor == nil {
2012				m.Predecessor = &Node{}
2013			}
2014			if err := m.Predecessor.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil {
2015				return err
2016			}
2017			iNdEx = postIndex
2018		case 2:
2019			if wireType != 2 {
2020				return fmt.Errorf("proto: wrong wireType = %d for field Successors", wireType)
2021			}
2022			var msglen int
2023			for shift := uint(0); ; shift += 7 {
2024				if shift >= 64 {
2025					return protohelpers.ErrIntOverflow
2026				}
2027				if iNdEx >= l {
2028					return io.ErrUnexpectedEOF
2029				}
2030				b := dAtA[iNdEx]
2031				iNdEx++
2032				msglen |= int(b&0x7F) << shift
2033				if b < 0x80 {
2034					break
2035				}
2036			}
2037			if msglen < 0 {
2038				return protohelpers.ErrInvalidLength
2039			}
2040			postIndex := iNdEx + msglen
2041			if postIndex < 0 {
2042				return protohelpers.ErrInvalidLength
2043			}
2044			if postIndex > l {
2045				return io.ErrUnexpectedEOF
2046			}
2047			m.Successors = append(m.Successors, &Node{})
2048			if err := m.Successors[len(m.Successors)-1].UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil {
2049				return err
2050			}
2051			iNdEx = postIndex
2052		default:
2053			iNdEx = preIndex
2054			skippy, err := protohelpers.Skip(dAtA[iNdEx:])
2055			if err != nil {
2056				return err
2057			}
2058			if (skippy < 0) || (iNdEx+skippy) < 0 {
2059				return protohelpers.ErrInvalidLength
2060			}
2061			if (iNdEx + skippy) > l {
2062				return io.ErrUnexpectedEOF
2063			}
2064			m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...)
2065			iNdEx += skippy
2066		}
2067	}
2068 
2069	if iNdEx > l {
2070		return io.ErrUnexpectedEOF
2071	}
2072	return nil
2073}
2074func (m *RequestToLeaveRequest) UnmarshalVT(dAtA []byte) error {
2075	l := len(dAtA)
2076	iNdEx := 0
2077	for iNdEx < l {
2078		preIndex := iNdEx
2079		var wire uint64
2080		for shift := uint(0); ; shift += 7 {
2081			if shift >= 64 {
2082				return protohelpers.ErrIntOverflow
2083			}
2084			if iNdEx >= l {
2085				return io.ErrUnexpectedEOF
2086			}
2087			b := dAtA[iNdEx]
2088			iNdEx++
2089			wire |= uint64(b&0x7F) << shift
2090			if b < 0x80 {
2091				break
2092			}
2093		}
2094		fieldNum := int32(wire >> 3)
2095		wireType := int(wire & 0x7)
2096		if wireType == 4 {
2097			return fmt.Errorf("proto: RequestToLeaveRequest: wiretype end group for non-group")
2098		}
2099		if fieldNum <= 0 {
2100			return fmt.Errorf("proto: RequestToLeaveRequest: illegal tag %d (wire type %d)", fieldNum, wire)
2101		}
2102		switch fieldNum {
2103		case 1:
2104			if wireType != 2 {
2105				return fmt.Errorf("proto: wrong wireType = %d for field Leaver", wireType)
2106			}
2107			var msglen int
2108			for shift := uint(0); ; shift += 7 {
2109				if shift >= 64 {
2110					return protohelpers.ErrIntOverflow
2111				}
2112				if iNdEx >= l {
2113					return io.ErrUnexpectedEOF
2114				}
2115				b := dAtA[iNdEx]
2116				iNdEx++
2117				msglen |= int(b&0x7F) << shift
2118				if b < 0x80 {
2119					break
2120				}
2121			}
2122			if msglen < 0 {
2123				return protohelpers.ErrInvalidLength
2124			}
2125			postIndex := iNdEx + msglen
2126			if postIndex < 0 {
2127				return protohelpers.ErrInvalidLength
2128			}
2129			if postIndex > l {
2130				return io.ErrUnexpectedEOF
2131			}
2132			if m.Leaver == nil {
2133				m.Leaver = &Node{}
2134			}
2135			if err := m.Leaver.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil {
2136				return err
2137			}
2138			iNdEx = postIndex
2139		default:
2140			iNdEx = preIndex
2141			skippy, err := protohelpers.Skip(dAtA[iNdEx:])
2142			if err != nil {
2143				return err
2144			}
2145			if (skippy < 0) || (iNdEx+skippy) < 0 {
2146				return protohelpers.ErrInvalidLength
2147			}
2148			if (iNdEx + skippy) > l {
2149				return io.ErrUnexpectedEOF
2150			}
2151			m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...)
2152			iNdEx += skippy
2153		}
2154	}
2155 
2156	if iNdEx > l {
2157		return io.ErrUnexpectedEOF
2158	}
2159	return nil
2160}
2161func (m *RequestToLeaveResponse) UnmarshalVT(dAtA []byte) error {
2162	l := len(dAtA)
2163	iNdEx := 0
2164	for iNdEx < l {
2165		preIndex := iNdEx
2166		var wire uint64
2167		for shift := uint(0); ; shift += 7 {
2168			if shift >= 64 {
2169				return protohelpers.ErrIntOverflow
2170			}
2171			if iNdEx >= l {
2172				return io.ErrUnexpectedEOF
2173			}
2174			b := dAtA[iNdEx]
2175			iNdEx++
2176			wire |= uint64(b&0x7F) << shift
2177			if b < 0x80 {
2178				break
2179			}
2180		}
2181		fieldNum := int32(wire >> 3)
2182		wireType := int(wire & 0x7)
2183		if wireType == 4 {
2184			return fmt.Errorf("proto: RequestToLeaveResponse: wiretype end group for non-group")
2185		}
2186		if fieldNum <= 0 {
2187			return fmt.Errorf("proto: RequestToLeaveResponse: illegal tag %d (wire type %d)", fieldNum, wire)
2188		}
2189		switch fieldNum {
2190		default:
2191			iNdEx = preIndex
2192			skippy, err := protohelpers.Skip(dAtA[iNdEx:])
2193			if err != nil {
2194				return err
2195			}
2196			if (skippy < 0) || (iNdEx+skippy) < 0 {
2197				return protohelpers.ErrInvalidLength
2198			}
2199			if (iNdEx + skippy) > l {
2200				return io.ErrUnexpectedEOF
2201			}
2202			m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...)
2203			iNdEx += skippy
2204		}
2205	}
2206 
2207	if iNdEx > l {
2208		return io.ErrUnexpectedEOF
2209	}
2210	return nil
2211}
2212func (m *MembershipConclusionRequest) UnmarshalVT(dAtA []byte) error {
2213	l := len(dAtA)
2214	iNdEx := 0
2215	for iNdEx < l {
2216		preIndex := iNdEx
2217		var wire uint64
2218		for shift := uint(0); ; shift += 7 {
2219			if shift >= 64 {
2220				return protohelpers.ErrIntOverflow
2221			}
2222			if iNdEx >= l {
2223				return io.ErrUnexpectedEOF
2224			}
2225			b := dAtA[iNdEx]
2226			iNdEx++
2227			wire |= uint64(b&0x7F) << shift
2228			if b < 0x80 {
2229				break
2230			}
2231		}
2232		fieldNum := int32(wire >> 3)
2233		wireType := int(wire & 0x7)
2234		if wireType == 4 {
2235			return fmt.Errorf("proto: MembershipConclusionRequest: wiretype end group for non-group")
2236		}
2237		if fieldNum <= 0 {
2238			return fmt.Errorf("proto: MembershipConclusionRequest: illegal tag %d (wire type %d)", fieldNum, wire)
2239		}
2240		switch fieldNum {
2241		case 1:
2242			if wireType != 0 {
2243				return fmt.Errorf("proto: wrong wireType = %d for field Stabilize", wireType)
2244			}
2245			var v int
2246			for shift := uint(0); ; shift += 7 {
2247				if shift >= 64 {
2248					return protohelpers.ErrIntOverflow
2249				}
2250				if iNdEx >= l {
2251					return io.ErrUnexpectedEOF
2252				}
2253				b := dAtA[iNdEx]
2254				iNdEx++
2255				v |= int(b&0x7F) << shift
2256				if b < 0x80 {
2257					break
2258				}
2259			}
2260			m.Stabilize = bool(v != 0)
2261		case 2:
2262			if wireType != 0 {
2263				return fmt.Errorf("proto: wrong wireType = %d for field Release", wireType)
2264			}
2265			var v int
2266			for shift := uint(0); ; shift += 7 {
2267				if shift >= 64 {
2268					return protohelpers.ErrIntOverflow
2269				}
2270				if iNdEx >= l {
2271					return io.ErrUnexpectedEOF
2272				}
2273				b := dAtA[iNdEx]
2274				iNdEx++
2275				v |= int(b&0x7F) << shift
2276				if b < 0x80 {
2277					break
2278				}
2279			}
2280			m.Release = bool(v != 0)
2281		default:
2282			iNdEx = preIndex
2283			skippy, err := protohelpers.Skip(dAtA[iNdEx:])
2284			if err != nil {
2285				return err
2286			}
2287			if (skippy < 0) || (iNdEx+skippy) < 0 {
2288				return protohelpers.ErrInvalidLength
2289			}
2290			if (iNdEx + skippy) > l {
2291				return io.ErrUnexpectedEOF
2292			}
2293			m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...)
2294			iNdEx += skippy
2295		}
2296	}
2297 
2298	if iNdEx > l {
2299		return io.ErrUnexpectedEOF
2300	}
2301	return nil
2302}
2303func (m *MembershipConclusionResponse) UnmarshalVT(dAtA []byte) error {
2304	l := len(dAtA)
2305	iNdEx := 0
2306	for iNdEx < l {
2307		preIndex := iNdEx
2308		var wire uint64
2309		for shift := uint(0); ; shift += 7 {
2310			if shift >= 64 {
2311				return protohelpers.ErrIntOverflow
2312			}
2313			if iNdEx >= l {
2314				return io.ErrUnexpectedEOF
2315			}
2316			b := dAtA[iNdEx]
2317			iNdEx++
2318			wire |= uint64(b&0x7F) << shift
2319			if b < 0x80 {
2320				break
2321			}
2322		}
2323		fieldNum := int32(wire >> 3)
2324		wireType := int(wire & 0x7)
2325		if wireType == 4 {
2326			return fmt.Errorf("proto: MembershipConclusionResponse: wiretype end group for non-group")
2327		}
2328		if fieldNum <= 0 {
2329			return fmt.Errorf("proto: MembershipConclusionResponse: illegal tag %d (wire type %d)", fieldNum, wire)
2330		}
2331		switch fieldNum {
2332		default:
2333			iNdEx = preIndex
2334			skippy, err := protohelpers.Skip(dAtA[iNdEx:])
2335			if err != nil {
2336				return err
2337			}
2338			if (skippy < 0) || (iNdEx+skippy) < 0 {
2339				return protohelpers.ErrInvalidLength
2340			}
2341			if (iNdEx + skippy) > l {
2342				return io.ErrUnexpectedEOF
2343			}
2344			m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...)
2345			iNdEx += skippy
2346		}
2347	}
2348 
2349	if iNdEx > l {
2350		return io.ErrUnexpectedEOF
2351	}
2352	return nil
2353}