1// Code generated by the FlatBuffers compiler. DO NOT EDIT.
2
3package Example
4
5import (
6	flatbuffers "github.com/google/flatbuffers/go"
7
8	MyGame "MyGame"
9)
10
11/// an example documentation comment: monster object
12type Monster struct {
13	_tab flatbuffers.Table
14}
15
16func GetRootAsMonster(buf []byte, offset flatbuffers.UOffsetT) *Monster {
17	n := flatbuffers.GetUOffsetT(buf[offset:])
18	x := &Monster{}
19	x.Init(buf, n+offset)
20	return x
21}
22
23func (rcv *Monster) Init(buf []byte, i flatbuffers.UOffsetT) {
24	rcv._tab.Bytes = buf
25	rcv._tab.Pos = i
26}
27
28func (rcv *Monster) Table() flatbuffers.Table {
29	return rcv._tab
30}
31
32func (rcv *Monster) Pos(obj *Vec3) *Vec3 {
33	o := flatbuffers.UOffsetT(rcv._tab.Offset(4))
34	if o != 0 {
35		x := o + rcv._tab.Pos
36		if obj == nil {
37			obj = new(Vec3)
38		}
39		obj.Init(rcv._tab.Bytes, x)
40		return obj
41	}
42	return nil
43}
44
45func (rcv *Monster) Mana() int16 {
46	o := flatbuffers.UOffsetT(rcv._tab.Offset(6))
47	if o != 0 {
48		return rcv._tab.GetInt16(o + rcv._tab.Pos)
49	}
50	return 150
51}
52
53func (rcv *Monster) MutateMana(n int16) bool {
54	return rcv._tab.MutateInt16Slot(6, n)
55}
56
57func (rcv *Monster) Hp() int16 {
58	o := flatbuffers.UOffsetT(rcv._tab.Offset(8))
59	if o != 0 {
60		return rcv._tab.GetInt16(o + rcv._tab.Pos)
61	}
62	return 100
63}
64
65func (rcv *Monster) MutateHp(n int16) bool {
66	return rcv._tab.MutateInt16Slot(8, n)
67}
68
69func (rcv *Monster) Name() []byte {
70	o := flatbuffers.UOffsetT(rcv._tab.Offset(10))
71	if o != 0 {
72		return rcv._tab.ByteVector(o + rcv._tab.Pos)
73	}
74	return nil
75}
76
77func (rcv *Monster) Inventory(j int) byte {
78	o := flatbuffers.UOffsetT(rcv._tab.Offset(14))
79	if o != 0 {
80		a := rcv._tab.Vector(o)
81		return rcv._tab.GetByte(a + flatbuffers.UOffsetT(j*1))
82	}
83	return 0
84}
85
86func (rcv *Monster) InventoryLength() int {
87	o := flatbuffers.UOffsetT(rcv._tab.Offset(14))
88	if o != 0 {
89		return rcv._tab.VectorLen(o)
90	}
91	return 0
92}
93
94func (rcv *Monster) InventoryBytes() []byte {
95	o := flatbuffers.UOffsetT(rcv._tab.Offset(14))
96	if o != 0 {
97		return rcv._tab.ByteVector(o + rcv._tab.Pos)
98	}
99	return nil
100}
101
102func (rcv *Monster) MutateInventory(j int, n byte) bool {
103	o := flatbuffers.UOffsetT(rcv._tab.Offset(14))
104	if o != 0 {
105		a := rcv._tab.Vector(o)
106		return rcv._tab.MutateByte(a+flatbuffers.UOffsetT(j*1), n)
107	}
108	return false
109}
110
111func (rcv *Monster) Color() Color {
112	o := flatbuffers.UOffsetT(rcv._tab.Offset(16))
113	if o != 0 {
114		return rcv._tab.GetInt8(o + rcv._tab.Pos)
115	}
116	return 8
117}
118
119func (rcv *Monster) MutateColor(n Color) bool {
120	return rcv._tab.MutateInt8Slot(16, n)
121}
122
123func (rcv *Monster) TestType() byte {
124	o := flatbuffers.UOffsetT(rcv._tab.Offset(18))
125	if o != 0 {
126		return rcv._tab.GetByte(o + rcv._tab.Pos)
127	}
128	return 0
129}
130
131func (rcv *Monster) MutateTestType(n byte) bool {
132	return rcv._tab.MutateByteSlot(18, n)
133}
134
135func (rcv *Monster) Test(obj *flatbuffers.Table) bool {
136	o := flatbuffers.UOffsetT(rcv._tab.Offset(20))
137	if o != 0 {
138		rcv._tab.Union(obj, o)
139		return true
140	}
141	return false
142}
143
144func (rcv *Monster) Test4(obj *Test, j int) bool {
145	o := flatbuffers.UOffsetT(rcv._tab.Offset(22))
146	if o != 0 {
147		x := rcv._tab.Vector(o)
148		x += flatbuffers.UOffsetT(j) * 4
149		obj.Init(rcv._tab.Bytes, x)
150		return true
151	}
152	return false
153}
154
155func (rcv *Monster) Test4Length() int {
156	o := flatbuffers.UOffsetT(rcv._tab.Offset(22))
157	if o != 0 {
158		return rcv._tab.VectorLen(o)
159	}
160	return 0
161}
162
163func (rcv *Monster) Testarrayofstring(j int) []byte {
164	o := flatbuffers.UOffsetT(rcv._tab.Offset(24))
165	if o != 0 {
166		a := rcv._tab.Vector(o)
167		return rcv._tab.ByteVector(a + flatbuffers.UOffsetT(j*4))
168	}
169	return nil
170}
171
172func (rcv *Monster) TestarrayofstringLength() int {
173	o := flatbuffers.UOffsetT(rcv._tab.Offset(24))
174	if o != 0 {
175		return rcv._tab.VectorLen(o)
176	}
177	return 0
178}
179
180/// an example documentation comment: this will end up in the generated code
181/// multiline too
182func (rcv *Monster) Testarrayoftables(obj *Monster, j int) bool {
183	o := flatbuffers.UOffsetT(rcv._tab.Offset(26))
184	if o != 0 {
185		x := rcv._tab.Vector(o)
186		x += flatbuffers.UOffsetT(j) * 4
187		x = rcv._tab.Indirect(x)
188		obj.Init(rcv._tab.Bytes, x)
189		return true
190	}
191	return false
192}
193
194func (rcv *Monster) TestarrayoftablesLength() int {
195	o := flatbuffers.UOffsetT(rcv._tab.Offset(26))
196	if o != 0 {
197		return rcv._tab.VectorLen(o)
198	}
199	return 0
200}
201
202/// an example documentation comment: this will end up in the generated code
203/// multiline too
204func (rcv *Monster) Enemy(obj *Monster) *Monster {
205	o := flatbuffers.UOffsetT(rcv._tab.Offset(28))
206	if o != 0 {
207		x := rcv._tab.Indirect(o + rcv._tab.Pos)
208		if obj == nil {
209			obj = new(Monster)
210		}
211		obj.Init(rcv._tab.Bytes, x)
212		return obj
213	}
214	return nil
215}
216
217func (rcv *Monster) Testnestedflatbuffer(j int) byte {
218	o := flatbuffers.UOffsetT(rcv._tab.Offset(30))
219	if o != 0 {
220		a := rcv._tab.Vector(o)
221		return rcv._tab.GetByte(a + flatbuffers.UOffsetT(j*1))
222	}
223	return 0
224}
225
226func (rcv *Monster) TestnestedflatbufferLength() int {
227	o := flatbuffers.UOffsetT(rcv._tab.Offset(30))
228	if o != 0 {
229		return rcv._tab.VectorLen(o)
230	}
231	return 0
232}
233
234func (rcv *Monster) TestnestedflatbufferBytes() []byte {
235	o := flatbuffers.UOffsetT(rcv._tab.Offset(30))
236	if o != 0 {
237		return rcv._tab.ByteVector(o + rcv._tab.Pos)
238	}
239	return nil
240}
241
242func (rcv *Monster) MutateTestnestedflatbuffer(j int, n byte) bool {
243	o := flatbuffers.UOffsetT(rcv._tab.Offset(30))
244	if o != 0 {
245		a := rcv._tab.Vector(o)
246		return rcv._tab.MutateByte(a+flatbuffers.UOffsetT(j*1), n)
247	}
248	return false
249}
250
251func (rcv *Monster) Testempty(obj *Stat) *Stat {
252	o := flatbuffers.UOffsetT(rcv._tab.Offset(32))
253	if o != 0 {
254		x := rcv._tab.Indirect(o + rcv._tab.Pos)
255		if obj == nil {
256			obj = new(Stat)
257		}
258		obj.Init(rcv._tab.Bytes, x)
259		return obj
260	}
261	return nil
262}
263
264func (rcv *Monster) Testbool() bool {
265	o := flatbuffers.UOffsetT(rcv._tab.Offset(34))
266	if o != 0 {
267		return rcv._tab.GetBool(o + rcv._tab.Pos)
268	}
269	return false
270}
271
272func (rcv *Monster) MutateTestbool(n bool) bool {
273	return rcv._tab.MutateBoolSlot(34, n)
274}
275
276func (rcv *Monster) Testhashs32Fnv1() int32 {
277	o := flatbuffers.UOffsetT(rcv._tab.Offset(36))
278	if o != 0 {
279		return rcv._tab.GetInt32(o + rcv._tab.Pos)
280	}
281	return 0
282}
283
284func (rcv *Monster) MutateTesthashs32Fnv1(n int32) bool {
285	return rcv._tab.MutateInt32Slot(36, n)
286}
287
288func (rcv *Monster) Testhashu32Fnv1() uint32 {
289	o := flatbuffers.UOffsetT(rcv._tab.Offset(38))
290	if o != 0 {
291		return rcv._tab.GetUint32(o + rcv._tab.Pos)
292	}
293	return 0
294}
295
296func (rcv *Monster) MutateTesthashu32Fnv1(n uint32) bool {
297	return rcv._tab.MutateUint32Slot(38, n)
298}
299
300func (rcv *Monster) Testhashs64Fnv1() int64 {
301	o := flatbuffers.UOffsetT(rcv._tab.Offset(40))
302	if o != 0 {
303		return rcv._tab.GetInt64(o + rcv._tab.Pos)
304	}
305	return 0
306}
307
308func (rcv *Monster) MutateTesthashs64Fnv1(n int64) bool {
309	return rcv._tab.MutateInt64Slot(40, n)
310}
311
312func (rcv *Monster) Testhashu64Fnv1() uint64 {
313	o := flatbuffers.UOffsetT(rcv._tab.Offset(42))
314	if o != 0 {
315		return rcv._tab.GetUint64(o + rcv._tab.Pos)
316	}
317	return 0
318}
319
320func (rcv *Monster) MutateTesthashu64Fnv1(n uint64) bool {
321	return rcv._tab.MutateUint64Slot(42, n)
322}
323
324func (rcv *Monster) Testhashs32Fnv1a() int32 {
325	o := flatbuffers.UOffsetT(rcv._tab.Offset(44))
326	if o != 0 {
327		return rcv._tab.GetInt32(o + rcv._tab.Pos)
328	}
329	return 0
330}
331
332func (rcv *Monster) MutateTesthashs32Fnv1a(n int32) bool {
333	return rcv._tab.MutateInt32Slot(44, n)
334}
335
336func (rcv *Monster) Testhashu32Fnv1a() uint32 {
337	o := flatbuffers.UOffsetT(rcv._tab.Offset(46))
338	if o != 0 {
339		return rcv._tab.GetUint32(o + rcv._tab.Pos)
340	}
341	return 0
342}
343
344func (rcv *Monster) MutateTesthashu32Fnv1a(n uint32) bool {
345	return rcv._tab.MutateUint32Slot(46, n)
346}
347
348func (rcv *Monster) Testhashs64Fnv1a() int64 {
349	o := flatbuffers.UOffsetT(rcv._tab.Offset(48))
350	if o != 0 {
351		return rcv._tab.GetInt64(o + rcv._tab.Pos)
352	}
353	return 0
354}
355
356func (rcv *Monster) MutateTesthashs64Fnv1a(n int64) bool {
357	return rcv._tab.MutateInt64Slot(48, n)
358}
359
360func (rcv *Monster) Testhashu64Fnv1a() uint64 {
361	o := flatbuffers.UOffsetT(rcv._tab.Offset(50))
362	if o != 0 {
363		return rcv._tab.GetUint64(o + rcv._tab.Pos)
364	}
365	return 0
366}
367
368func (rcv *Monster) MutateTesthashu64Fnv1a(n uint64) bool {
369	return rcv._tab.MutateUint64Slot(50, n)
370}
371
372func (rcv *Monster) Testarrayofbools(j int) bool {
373	o := flatbuffers.UOffsetT(rcv._tab.Offset(52))
374	if o != 0 {
375		a := rcv._tab.Vector(o)
376		return rcv._tab.GetBool(a + flatbuffers.UOffsetT(j*1))
377	}
378	return false
379}
380
381func (rcv *Monster) TestarrayofboolsLength() int {
382	o := flatbuffers.UOffsetT(rcv._tab.Offset(52))
383	if o != 0 {
384		return rcv._tab.VectorLen(o)
385	}
386	return 0
387}
388
389func (rcv *Monster) MutateTestarrayofbools(j int, n bool) bool {
390	o := flatbuffers.UOffsetT(rcv._tab.Offset(52))
391	if o != 0 {
392		a := rcv._tab.Vector(o)
393		return rcv._tab.MutateBool(a+flatbuffers.UOffsetT(j*1), n)
394	}
395	return false
396}
397
398func (rcv *Monster) Testf() float32 {
399	o := flatbuffers.UOffsetT(rcv._tab.Offset(54))
400	if o != 0 {
401		return rcv._tab.GetFloat32(o + rcv._tab.Pos)
402	}
403	return 3.14159
404}
405
406func (rcv *Monster) MutateTestf(n float32) bool {
407	return rcv._tab.MutateFloat32Slot(54, n)
408}
409
410func (rcv *Monster) Testf2() float32 {
411	o := flatbuffers.UOffsetT(rcv._tab.Offset(56))
412	if o != 0 {
413		return rcv._tab.GetFloat32(o + rcv._tab.Pos)
414	}
415	return 3.0
416}
417
418func (rcv *Monster) MutateTestf2(n float32) bool {
419	return rcv._tab.MutateFloat32Slot(56, n)
420}
421
422func (rcv *Monster) Testf3() float32 {
423	o := flatbuffers.UOffsetT(rcv._tab.Offset(58))
424	if o != 0 {
425		return rcv._tab.GetFloat32(o + rcv._tab.Pos)
426	}
427	return 0.0
428}
429
430func (rcv *Monster) MutateTestf3(n float32) bool {
431	return rcv._tab.MutateFloat32Slot(58, n)
432}
433
434func (rcv *Monster) Testarrayofstring2(j int) []byte {
435	o := flatbuffers.UOffsetT(rcv._tab.Offset(60))
436	if o != 0 {
437		a := rcv._tab.Vector(o)
438		return rcv._tab.ByteVector(a + flatbuffers.UOffsetT(j*4))
439	}
440	return nil
441}
442
443func (rcv *Monster) Testarrayofstring2Length() int {
444	o := flatbuffers.UOffsetT(rcv._tab.Offset(60))
445	if o != 0 {
446		return rcv._tab.VectorLen(o)
447	}
448	return 0
449}
450
451func (rcv *Monster) Testarrayofsortedstruct(obj *Ability, j int) bool {
452	o := flatbuffers.UOffsetT(rcv._tab.Offset(62))
453	if o != 0 {
454		x := rcv._tab.Vector(o)
455		x += flatbuffers.UOffsetT(j) * 8
456		obj.Init(rcv._tab.Bytes, x)
457		return true
458	}
459	return false
460}
461
462func (rcv *Monster) TestarrayofsortedstructLength() int {
463	o := flatbuffers.UOffsetT(rcv._tab.Offset(62))
464	if o != 0 {
465		return rcv._tab.VectorLen(o)
466	}
467	return 0
468}
469
470func (rcv *Monster) Flex(j int) byte {
471	o := flatbuffers.UOffsetT(rcv._tab.Offset(64))
472	if o != 0 {
473		a := rcv._tab.Vector(o)
474		return rcv._tab.GetByte(a + flatbuffers.UOffsetT(j*1))
475	}
476	return 0
477}
478
479func (rcv *Monster) FlexLength() int {
480	o := flatbuffers.UOffsetT(rcv._tab.Offset(64))
481	if o != 0 {
482		return rcv._tab.VectorLen(o)
483	}
484	return 0
485}
486
487func (rcv *Monster) FlexBytes() []byte {
488	o := flatbuffers.UOffsetT(rcv._tab.Offset(64))
489	if o != 0 {
490		return rcv._tab.ByteVector(o + rcv._tab.Pos)
491	}
492	return nil
493}
494
495func (rcv *Monster) MutateFlex(j int, n byte) bool {
496	o := flatbuffers.UOffsetT(rcv._tab.Offset(64))
497	if o != 0 {
498		a := rcv._tab.Vector(o)
499		return rcv._tab.MutateByte(a+flatbuffers.UOffsetT(j*1), n)
500	}
501	return false
502}
503
504func (rcv *Monster) Test5(obj *Test, j int) bool {
505	o := flatbuffers.UOffsetT(rcv._tab.Offset(66))
506	if o != 0 {
507		x := rcv._tab.Vector(o)
508		x += flatbuffers.UOffsetT(j) * 4
509		obj.Init(rcv._tab.Bytes, x)
510		return true
511	}
512	return false
513}
514
515func (rcv *Monster) Test5Length() int {
516	o := flatbuffers.UOffsetT(rcv._tab.Offset(66))
517	if o != 0 {
518		return rcv._tab.VectorLen(o)
519	}
520	return 0
521}
522
523func (rcv *Monster) VectorOfLongs(j int) int64 {
524	o := flatbuffers.UOffsetT(rcv._tab.Offset(68))
525	if o != 0 {
526		a := rcv._tab.Vector(o)
527		return rcv._tab.GetInt64(a + flatbuffers.UOffsetT(j*8))
528	}
529	return 0
530}
531
532func (rcv *Monster) VectorOfLongsLength() int {
533	o := flatbuffers.UOffsetT(rcv._tab.Offset(68))
534	if o != 0 {
535		return rcv._tab.VectorLen(o)
536	}
537	return 0
538}
539
540func (rcv *Monster) MutateVectorOfLongs(j int, n int64) bool {
541	o := flatbuffers.UOffsetT(rcv._tab.Offset(68))
542	if o != 0 {
543		a := rcv._tab.Vector(o)
544		return rcv._tab.MutateInt64(a+flatbuffers.UOffsetT(j*8), n)
545	}
546	return false
547}
548
549func (rcv *Monster) VectorOfDoubles(j int) float64 {
550	o := flatbuffers.UOffsetT(rcv._tab.Offset(70))
551	if o != 0 {
552		a := rcv._tab.Vector(o)
553		return rcv._tab.GetFloat64(a + flatbuffers.UOffsetT(j*8))
554	}
555	return 0
556}
557
558func (rcv *Monster) VectorOfDoublesLength() int {
559	o := flatbuffers.UOffsetT(rcv._tab.Offset(70))
560	if o != 0 {
561		return rcv._tab.VectorLen(o)
562	}
563	return 0
564}
565
566func (rcv *Monster) MutateVectorOfDoubles(j int, n float64) bool {
567	o := flatbuffers.UOffsetT(rcv._tab.Offset(70))
568	if o != 0 {
569		a := rcv._tab.Vector(o)
570		return rcv._tab.MutateFloat64(a+flatbuffers.UOffsetT(j*8), n)
571	}
572	return false
573}
574
575func (rcv *Monster) ParentNamespaceTest(obj *MyGame.InParentNamespace) *MyGame.InParentNamespace {
576	o := flatbuffers.UOffsetT(rcv._tab.Offset(72))
577	if o != 0 {
578		x := rcv._tab.Indirect(o + rcv._tab.Pos)
579		if obj == nil {
580			obj = new(MyGame.InParentNamespace)
581		}
582		obj.Init(rcv._tab.Bytes, x)
583		return obj
584	}
585	return nil
586}
587
588func (rcv *Monster) VectorOfReferrables(obj *Referrable, j int) bool {
589	o := flatbuffers.UOffsetT(rcv._tab.Offset(74))
590	if o != 0 {
591		x := rcv._tab.Vector(o)
592		x += flatbuffers.UOffsetT(j) * 4
593		x = rcv._tab.Indirect(x)
594		obj.Init(rcv._tab.Bytes, x)
595		return true
596	}
597	return false
598}
599
600func (rcv *Monster) VectorOfReferrablesLength() int {
601	o := flatbuffers.UOffsetT(rcv._tab.Offset(74))
602	if o != 0 {
603		return rcv._tab.VectorLen(o)
604	}
605	return 0
606}
607
608func (rcv *Monster) SingleWeakReference() uint64 {
609	o := flatbuffers.UOffsetT(rcv._tab.Offset(76))
610	if o != 0 {
611		return rcv._tab.GetUint64(o + rcv._tab.Pos)
612	}
613	return 0
614}
615
616func (rcv *Monster) MutateSingleWeakReference(n uint64) bool {
617	return rcv._tab.MutateUint64Slot(76, n)
618}
619
620func (rcv *Monster) VectorOfWeakReferences(j int) uint64 {
621	o := flatbuffers.UOffsetT(rcv._tab.Offset(78))
622	if o != 0 {
623		a := rcv._tab.Vector(o)
624		return rcv._tab.GetUint64(a + flatbuffers.UOffsetT(j*8))
625	}
626	return 0
627}
628
629func (rcv *Monster) VectorOfWeakReferencesLength() int {
630	o := flatbuffers.UOffsetT(rcv._tab.Offset(78))
631	if o != 0 {
632		return rcv._tab.VectorLen(o)
633	}
634	return 0
635}
636
637func (rcv *Monster) MutateVectorOfWeakReferences(j int, n uint64) bool {
638	o := flatbuffers.UOffsetT(rcv._tab.Offset(78))
639	if o != 0 {
640		a := rcv._tab.Vector(o)
641		return rcv._tab.MutateUint64(a+flatbuffers.UOffsetT(j*8), n)
642	}
643	return false
644}
645
646func (rcv *Monster) VectorOfStrongReferrables(obj *Referrable, j int) bool {
647	o := flatbuffers.UOffsetT(rcv._tab.Offset(80))
648	if o != 0 {
649		x := rcv._tab.Vector(o)
650		x += flatbuffers.UOffsetT(j) * 4
651		x = rcv._tab.Indirect(x)
652		obj.Init(rcv._tab.Bytes, x)
653		return true
654	}
655	return false
656}
657
658func (rcv *Monster) VectorOfStrongReferrablesLength() int {
659	o := flatbuffers.UOffsetT(rcv._tab.Offset(80))
660	if o != 0 {
661		return rcv._tab.VectorLen(o)
662	}
663	return 0
664}
665
666func (rcv *Monster) CoOwningReference() uint64 {
667	o := flatbuffers.UOffsetT(rcv._tab.Offset(82))
668	if o != 0 {
669		return rcv._tab.GetUint64(o + rcv._tab.Pos)
670	}
671	return 0
672}
673
674func (rcv *Monster) MutateCoOwningReference(n uint64) bool {
675	return rcv._tab.MutateUint64Slot(82, n)
676}
677
678func (rcv *Monster) VectorOfCoOwningReferences(j int) uint64 {
679	o := flatbuffers.UOffsetT(rcv._tab.Offset(84))
680	if o != 0 {
681		a := rcv._tab.Vector(o)
682		return rcv._tab.GetUint64(a + flatbuffers.UOffsetT(j*8))
683	}
684	return 0
685}
686
687func (rcv *Monster) VectorOfCoOwningReferencesLength() int {
688	o := flatbuffers.UOffsetT(rcv._tab.Offset(84))
689	if o != 0 {
690		return rcv._tab.VectorLen(o)
691	}
692	return 0
693}
694
695func (rcv *Monster) MutateVectorOfCoOwningReferences(j int, n uint64) bool {
696	o := flatbuffers.UOffsetT(rcv._tab.Offset(84))
697	if o != 0 {
698		a := rcv._tab.Vector(o)
699		return rcv._tab.MutateUint64(a+flatbuffers.UOffsetT(j*8), n)
700	}
701	return false
702}
703
704func (rcv *Monster) NonOwningReference() uint64 {
705	o := flatbuffers.UOffsetT(rcv._tab.Offset(86))
706	if o != 0 {
707		return rcv._tab.GetUint64(o + rcv._tab.Pos)
708	}
709	return 0
710}
711
712func (rcv *Monster) MutateNonOwningReference(n uint64) bool {
713	return rcv._tab.MutateUint64Slot(86, n)
714}
715
716func (rcv *Monster) VectorOfNonOwningReferences(j int) uint64 {
717	o := flatbuffers.UOffsetT(rcv._tab.Offset(88))
718	if o != 0 {
719		a := rcv._tab.Vector(o)
720		return rcv._tab.GetUint64(a + flatbuffers.UOffsetT(j*8))
721	}
722	return 0
723}
724
725func (rcv *Monster) VectorOfNonOwningReferencesLength() int {
726	o := flatbuffers.UOffsetT(rcv._tab.Offset(88))
727	if o != 0 {
728		return rcv._tab.VectorLen(o)
729	}
730	return 0
731}
732
733func (rcv *Monster) MutateVectorOfNonOwningReferences(j int, n uint64) bool {
734	o := flatbuffers.UOffsetT(rcv._tab.Offset(88))
735	if o != 0 {
736		a := rcv._tab.Vector(o)
737		return rcv._tab.MutateUint64(a+flatbuffers.UOffsetT(j*8), n)
738	}
739	return false
740}
741
742func (rcv *Monster) AnyUniqueType() byte {
743	o := flatbuffers.UOffsetT(rcv._tab.Offset(90))
744	if o != 0 {
745		return rcv._tab.GetByte(o + rcv._tab.Pos)
746	}
747	return 0
748}
749
750func (rcv *Monster) MutateAnyUniqueType(n byte) bool {
751	return rcv._tab.MutateByteSlot(90, n)
752}
753
754func (rcv *Monster) AnyUnique(obj *flatbuffers.Table) bool {
755	o := flatbuffers.UOffsetT(rcv._tab.Offset(92))
756	if o != 0 {
757		rcv._tab.Union(obj, o)
758		return true
759	}
760	return false
761}
762
763func (rcv *Monster) AnyAmbiguousType() byte {
764	o := flatbuffers.UOffsetT(rcv._tab.Offset(94))
765	if o != 0 {
766		return rcv._tab.GetByte(o + rcv._tab.Pos)
767	}
768	return 0
769}
770
771func (rcv *Monster) MutateAnyAmbiguousType(n byte) bool {
772	return rcv._tab.MutateByteSlot(94, n)
773}
774
775func (rcv *Monster) AnyAmbiguous(obj *flatbuffers.Table) bool {
776	o := flatbuffers.UOffsetT(rcv._tab.Offset(96))
777	if o != 0 {
778		rcv._tab.Union(obj, o)
779		return true
780	}
781	return false
782}
783
784func (rcv *Monster) VectorOfEnums(j int) Color {
785	o := flatbuffers.UOffsetT(rcv._tab.Offset(98))
786	if o != 0 {
787		a := rcv._tab.Vector(o)
788		return rcv._tab.GetInt8(a + flatbuffers.UOffsetT(j*1))
789	}
790	return 0
791}
792
793func (rcv *Monster) VectorOfEnumsLength() int {
794	o := flatbuffers.UOffsetT(rcv._tab.Offset(98))
795	if o != 0 {
796		return rcv._tab.VectorLen(o)
797	}
798	return 0
799}
800
801func (rcv *Monster) MutateVectorOfEnums(j int, n Color) bool {
802	o := flatbuffers.UOffsetT(rcv._tab.Offset(98))
803	if o != 0 {
804		a := rcv._tab.Vector(o)
805		return rcv._tab.MutateInt8(a+flatbuffers.UOffsetT(j*1), n)
806	}
807	return false
808}
809
810func MonsterStart(builder *flatbuffers.Builder) {
811	builder.StartObject(48)
812}
813func MonsterAddPos(builder *flatbuffers.Builder, pos flatbuffers.UOffsetT) {
814	builder.PrependStructSlot(0, flatbuffers.UOffsetT(pos), 0)
815}
816func MonsterAddMana(builder *flatbuffers.Builder, mana int16) {
817	builder.PrependInt16Slot(1, mana, 150)
818}
819func MonsterAddHp(builder *flatbuffers.Builder, hp int16) {
820	builder.PrependInt16Slot(2, hp, 100)
821}
822func MonsterAddName(builder *flatbuffers.Builder, name flatbuffers.UOffsetT) {
823	builder.PrependUOffsetTSlot(3, flatbuffers.UOffsetT(name), 0)
824}
825func MonsterAddInventory(builder *flatbuffers.Builder, inventory flatbuffers.UOffsetT) {
826	builder.PrependUOffsetTSlot(5, flatbuffers.UOffsetT(inventory), 0)
827}
828func MonsterStartInventoryVector(builder *flatbuffers.Builder, numElems int) flatbuffers.UOffsetT {
829	return builder.StartVector(1, numElems, 1)
830}
831func MonsterAddColor(builder *flatbuffers.Builder, color int8) {
832	builder.PrependInt8Slot(6, color, 8)
833}
834func MonsterAddTestType(builder *flatbuffers.Builder, testType byte) {
835	builder.PrependByteSlot(7, testType, 0)
836}
837func MonsterAddTest(builder *flatbuffers.Builder, test flatbuffers.UOffsetT) {
838	builder.PrependUOffsetTSlot(8, flatbuffers.UOffsetT(test), 0)
839}
840func MonsterAddTest4(builder *flatbuffers.Builder, test4 flatbuffers.UOffsetT) {
841	builder.PrependUOffsetTSlot(9, flatbuffers.UOffsetT(test4), 0)
842}
843func MonsterStartTest4Vector(builder *flatbuffers.Builder, numElems int) flatbuffers.UOffsetT {
844	return builder.StartVector(4, numElems, 2)
845}
846func MonsterAddTestarrayofstring(builder *flatbuffers.Builder, testarrayofstring flatbuffers.UOffsetT) {
847	builder.PrependUOffsetTSlot(10, flatbuffers.UOffsetT(testarrayofstring), 0)
848}
849func MonsterStartTestarrayofstringVector(builder *flatbuffers.Builder, numElems int) flatbuffers.UOffsetT {
850	return builder.StartVector(4, numElems, 4)
851}
852func MonsterAddTestarrayoftables(builder *flatbuffers.Builder, testarrayoftables flatbuffers.UOffsetT) {
853	builder.PrependUOffsetTSlot(11, flatbuffers.UOffsetT(testarrayoftables), 0)
854}
855func MonsterStartTestarrayoftablesVector(builder *flatbuffers.Builder, numElems int) flatbuffers.UOffsetT {
856	return builder.StartVector(4, numElems, 4)
857}
858func MonsterAddEnemy(builder *flatbuffers.Builder, enemy flatbuffers.UOffsetT) {
859	builder.PrependUOffsetTSlot(12, flatbuffers.UOffsetT(enemy), 0)
860}
861func MonsterAddTestnestedflatbuffer(builder *flatbuffers.Builder, testnestedflatbuffer flatbuffers.UOffsetT) {
862	builder.PrependUOffsetTSlot(13, flatbuffers.UOffsetT(testnestedflatbuffer), 0)
863}
864func MonsterStartTestnestedflatbufferVector(builder *flatbuffers.Builder, numElems int) flatbuffers.UOffsetT {
865	return builder.StartVector(1, numElems, 1)
866}
867func MonsterAddTestempty(builder *flatbuffers.Builder, testempty flatbuffers.UOffsetT) {
868	builder.PrependUOffsetTSlot(14, flatbuffers.UOffsetT(testempty), 0)
869}
870func MonsterAddTestbool(builder *flatbuffers.Builder, testbool bool) {
871	builder.PrependBoolSlot(15, testbool, false)
872}
873func MonsterAddTesthashs32Fnv1(builder *flatbuffers.Builder, testhashs32Fnv1 int32) {
874	builder.PrependInt32Slot(16, testhashs32Fnv1, 0)
875}
876func MonsterAddTesthashu32Fnv1(builder *flatbuffers.Builder, testhashu32Fnv1 uint32) {
877	builder.PrependUint32Slot(17, testhashu32Fnv1, 0)
878}
879func MonsterAddTesthashs64Fnv1(builder *flatbuffers.Builder, testhashs64Fnv1 int64) {
880	builder.PrependInt64Slot(18, testhashs64Fnv1, 0)
881}
882func MonsterAddTesthashu64Fnv1(builder *flatbuffers.Builder, testhashu64Fnv1 uint64) {
883	builder.PrependUint64Slot(19, testhashu64Fnv1, 0)
884}
885func MonsterAddTesthashs32Fnv1a(builder *flatbuffers.Builder, testhashs32Fnv1a int32) {
886	builder.PrependInt32Slot(20, testhashs32Fnv1a, 0)
887}
888func MonsterAddTesthashu32Fnv1a(builder *flatbuffers.Builder, testhashu32Fnv1a uint32) {
889	builder.PrependUint32Slot(21, testhashu32Fnv1a, 0)
890}
891func MonsterAddTesthashs64Fnv1a(builder *flatbuffers.Builder, testhashs64Fnv1a int64) {
892	builder.PrependInt64Slot(22, testhashs64Fnv1a, 0)
893}
894func MonsterAddTesthashu64Fnv1a(builder *flatbuffers.Builder, testhashu64Fnv1a uint64) {
895	builder.PrependUint64Slot(23, testhashu64Fnv1a, 0)
896}
897func MonsterAddTestarrayofbools(builder *flatbuffers.Builder, testarrayofbools flatbuffers.UOffsetT) {
898	builder.PrependUOffsetTSlot(24, flatbuffers.UOffsetT(testarrayofbools), 0)
899}
900func MonsterStartTestarrayofboolsVector(builder *flatbuffers.Builder, numElems int) flatbuffers.UOffsetT {
901	return builder.StartVector(1, numElems, 1)
902}
903func MonsterAddTestf(builder *flatbuffers.Builder, testf float32) {
904	builder.PrependFloat32Slot(25, testf, 3.14159)
905}
906func MonsterAddTestf2(builder *flatbuffers.Builder, testf2 float32) {
907	builder.PrependFloat32Slot(26, testf2, 3.0)
908}
909func MonsterAddTestf3(builder *flatbuffers.Builder, testf3 float32) {
910	builder.PrependFloat32Slot(27, testf3, 0.0)
911}
912func MonsterAddTestarrayofstring2(builder *flatbuffers.Builder, testarrayofstring2 flatbuffers.UOffsetT) {
913	builder.PrependUOffsetTSlot(28, flatbuffers.UOffsetT(testarrayofstring2), 0)
914}
915func MonsterStartTestarrayofstring2Vector(builder *flatbuffers.Builder, numElems int) flatbuffers.UOffsetT {
916	return builder.StartVector(4, numElems, 4)
917}
918func MonsterAddTestarrayofsortedstruct(builder *flatbuffers.Builder, testarrayofsortedstruct flatbuffers.UOffsetT) {
919	builder.PrependUOffsetTSlot(29, flatbuffers.UOffsetT(testarrayofsortedstruct), 0)
920}
921func MonsterStartTestarrayofsortedstructVector(builder *flatbuffers.Builder, numElems int) flatbuffers.UOffsetT {
922	return builder.StartVector(8, numElems, 4)
923}
924func MonsterAddFlex(builder *flatbuffers.Builder, flex flatbuffers.UOffsetT) {
925	builder.PrependUOffsetTSlot(30, flatbuffers.UOffsetT(flex), 0)
926}
927func MonsterStartFlexVector(builder *flatbuffers.Builder, numElems int) flatbuffers.UOffsetT {
928	return builder.StartVector(1, numElems, 1)
929}
930func MonsterAddTest5(builder *flatbuffers.Builder, test5 flatbuffers.UOffsetT) {
931	builder.PrependUOffsetTSlot(31, flatbuffers.UOffsetT(test5), 0)
932}
933func MonsterStartTest5Vector(builder *flatbuffers.Builder, numElems int) flatbuffers.UOffsetT {
934	return builder.StartVector(4, numElems, 2)
935}
936func MonsterAddVectorOfLongs(builder *flatbuffers.Builder, vectorOfLongs flatbuffers.UOffsetT) {
937	builder.PrependUOffsetTSlot(32, flatbuffers.UOffsetT(vectorOfLongs), 0)
938}
939func MonsterStartVectorOfLongsVector(builder *flatbuffers.Builder, numElems int) flatbuffers.UOffsetT {
940	return builder.StartVector(8, numElems, 8)
941}
942func MonsterAddVectorOfDoubles(builder *flatbuffers.Builder, vectorOfDoubles flatbuffers.UOffsetT) {
943	builder.PrependUOffsetTSlot(33, flatbuffers.UOffsetT(vectorOfDoubles), 0)
944}
945func MonsterStartVectorOfDoublesVector(builder *flatbuffers.Builder, numElems int) flatbuffers.UOffsetT {
946	return builder.StartVector(8, numElems, 8)
947}
948func MonsterAddParentNamespaceTest(builder *flatbuffers.Builder, parentNamespaceTest flatbuffers.UOffsetT) {
949	builder.PrependUOffsetTSlot(34, flatbuffers.UOffsetT(parentNamespaceTest), 0)
950}
951func MonsterAddVectorOfReferrables(builder *flatbuffers.Builder, vectorOfReferrables flatbuffers.UOffsetT) {
952	builder.PrependUOffsetTSlot(35, flatbuffers.UOffsetT(vectorOfReferrables), 0)
953}
954func MonsterStartVectorOfReferrablesVector(builder *flatbuffers.Builder, numElems int) flatbuffers.UOffsetT {
955	return builder.StartVector(4, numElems, 4)
956}
957func MonsterAddSingleWeakReference(builder *flatbuffers.Builder, singleWeakReference uint64) {
958	builder.PrependUint64Slot(36, singleWeakReference, 0)
959}
960func MonsterAddVectorOfWeakReferences(builder *flatbuffers.Builder, vectorOfWeakReferences flatbuffers.UOffsetT) {
961	builder.PrependUOffsetTSlot(37, flatbuffers.UOffsetT(vectorOfWeakReferences), 0)
962}
963func MonsterStartVectorOfWeakReferencesVector(builder *flatbuffers.Builder, numElems int) flatbuffers.UOffsetT {
964	return builder.StartVector(8, numElems, 8)
965}
966func MonsterAddVectorOfStrongReferrables(builder *flatbuffers.Builder, vectorOfStrongReferrables flatbuffers.UOffsetT) {
967	builder.PrependUOffsetTSlot(38, flatbuffers.UOffsetT(vectorOfStrongReferrables), 0)
968}
969func MonsterStartVectorOfStrongReferrablesVector(builder *flatbuffers.Builder, numElems int) flatbuffers.UOffsetT {
970	return builder.StartVector(4, numElems, 4)
971}
972func MonsterAddCoOwningReference(builder *flatbuffers.Builder, coOwningReference uint64) {
973	builder.PrependUint64Slot(39, coOwningReference, 0)
974}
975func MonsterAddVectorOfCoOwningReferences(builder *flatbuffers.Builder, vectorOfCoOwningReferences flatbuffers.UOffsetT) {
976	builder.PrependUOffsetTSlot(40, flatbuffers.UOffsetT(vectorOfCoOwningReferences), 0)
977}
978func MonsterStartVectorOfCoOwningReferencesVector(builder *flatbuffers.Builder, numElems int) flatbuffers.UOffsetT {
979	return builder.StartVector(8, numElems, 8)
980}
981func MonsterAddNonOwningReference(builder *flatbuffers.Builder, nonOwningReference uint64) {
982	builder.PrependUint64Slot(41, nonOwningReference, 0)
983}
984func MonsterAddVectorOfNonOwningReferences(builder *flatbuffers.Builder, vectorOfNonOwningReferences flatbuffers.UOffsetT) {
985	builder.PrependUOffsetTSlot(42, flatbuffers.UOffsetT(vectorOfNonOwningReferences), 0)
986}
987func MonsterStartVectorOfNonOwningReferencesVector(builder *flatbuffers.Builder, numElems int) flatbuffers.UOffsetT {
988	return builder.StartVector(8, numElems, 8)
989}
990func MonsterAddAnyUniqueType(builder *flatbuffers.Builder, anyUniqueType byte) {
991	builder.PrependByteSlot(43, anyUniqueType, 0)
992}
993func MonsterAddAnyUnique(builder *flatbuffers.Builder, anyUnique flatbuffers.UOffsetT) {
994	builder.PrependUOffsetTSlot(44, flatbuffers.UOffsetT(anyUnique), 0)
995}
996func MonsterAddAnyAmbiguousType(builder *flatbuffers.Builder, anyAmbiguousType byte) {
997	builder.PrependByteSlot(45, anyAmbiguousType, 0)
998}
999func MonsterAddAnyAmbiguous(builder *flatbuffers.Builder, anyAmbiguous flatbuffers.UOffsetT) {
1000	builder.PrependUOffsetTSlot(46, flatbuffers.UOffsetT(anyAmbiguous), 0)
1001}
1002func MonsterAddVectorOfEnums(builder *flatbuffers.Builder, vectorOfEnums flatbuffers.UOffsetT) {
1003	builder.PrependUOffsetTSlot(47, flatbuffers.UOffsetT(vectorOfEnums), 0)
1004}
1005func MonsterStartVectorOfEnumsVector(builder *flatbuffers.Builder, numElems int) flatbuffers.UOffsetT {
1006	return builder.StartVector(1, numElems, 1)
1007}
1008func MonsterEnd(builder *flatbuffers.Builder) flatbuffers.UOffsetT {
1009	return builder.EndObject()
1010}
1011