// Code generated by go run gob_gen.go; DO NOT EDIT.

package main

import (
	"bytes"
	"github.com/google/blueprint/gobtools"
	"github.com/google/blueprint/gobtools/test"
	"github.com/google/blueprint/uniquelist"
)

func init() {
	TestStructGobRegId = gobtools.RegisterType(func() gobtools.CustomDec { return new(TestStruct) })
	TestEchoGobRegId = gobtools.RegisterType(func() gobtools.CustomDec { return new(TestEcho) })
	testEchosGobRegId = gobtools.RegisterType(func() gobtools.CustomDec { return new(testEchos) })
	testStringMapGobRegId = gobtools.RegisterType(func() gobtools.CustomDec { return new(testStringMap) })
	testEchoMapGobRegId = gobtools.RegisterType(func() gobtools.CustomDec { return new(testEchoMap) })
	TestEmbedPtrGobRegId = gobtools.RegisterType(func() gobtools.CustomDec { return new(TestEmbedPtr) })
}

func (r TestStruct) Encode(ctx gobtools.EncContext, buf *bytes.Buffer) error {
	var err error

	if err = r.TestEcho.Encode(ctx, buf); err != nil {
		return err
	}

	if err = gobtools.EncodeString(buf, r.f1); err != nil {
		return err
	}

	if err = gobtools.EncodeSimple(buf, r.f2); err != nil {
		return err
	}

	if err = gobtools.EncodeSimple(buf, r.f3); err != nil {
		return err
	}

	if err = gobtools.EncodeSimple(buf, r.f4); err != nil {
		return err
	}

	if err = gobtools.EncodeSimple(buf, r.f5); err != nil {
		return err
	}

	if err = gobtools.EncodeString(buf, r.f6); err != nil {
		return err
	}

	if err = r.f7.Encode(ctx, buf); err != nil {
		return err
	}

	if err = gobtools.EncodeSimple(buf, r.f8); err != nil {
		return err
	}

	if err = gobtools.EncodeSimple(buf, r.f9); err != nil {
		return err
	}

	if err = gobtools.EncodeSimple(buf, r.f10); err != nil {
		return err
	}

	if r.f11 == nil {
		if err = gobtools.EncodeSimple(buf, int32(-1)); err != nil {
			return err
		}
	} else {
		if err = gobtools.EncodeSimple(buf, int32(len(r.f11))); err != nil {
			return err
		}
		for val1 := 0; val1 < len(r.f11); val1++ {
			if err = gobtools.EncodeString(buf, r.f11[val1]); err != nil {
				return err
			}
		}
	}

	if r.f12 == nil {
		if err = gobtools.EncodeSimple(buf, int32(-1)); err != nil {
			return err
		}
	} else {
		if err = gobtools.EncodeSimple(buf, int32(len(r.f12))); err != nil {
			return err
		}
		for k, v := range r.f12 {
			if err = gobtools.EncodeString(buf, k); err != nil {
				return err
			}
			if err = gobtools.EncodeSimple(buf, int64(v)); err != nil {
				return err
			}
		}
	}

	val2 := r.f13 == nil
	if err = gobtools.EncodeSimple(buf, val2); err != nil {
		return err
	}
	if !val2 {
		if err = gobtools.EncodeString(buf, (*r.f13)); err != nil {
			return err
		}
	}

	if err = gobtools.EncodeSimple(buf, int64(r.f14)); err != nil {
		return err
	}

	if r.f15 == nil {
		if err = gobtools.EncodeSimple(buf, int32(-1)); err != nil {
			return err
		}
	} else {
		if err = gobtools.EncodeSimple(buf, int32(len(r.f15))); err != nil {
			return err
		}
		for val3 := 0; val3 < len(r.f15); val3++ {
			if err = gobtools.EncodeSimple(buf, int64(r.f15[val3])); err != nil {
				return err
			}
		}
	}

	if r.f16 == nil {
		if err = gobtools.EncodeSimple(buf, int32(-1)); err != nil {
			return err
		}
	} else {
		if err = gobtools.EncodeSimple(buf, int32(len(r.f16))); err != nil {
			return err
		}
		for val4 := 0; val4 < len(r.f16); val4++ {
			if err = r.f16[val4].Encode(ctx, buf); err != nil {
				return err
			}
		}
	}

	val5 := r.f17 == nil
	if err = gobtools.EncodeSimple(buf, val5); err != nil {
		return err
	}
	if !val5 {
		if err = (*r.f17).Encode(ctx, buf); err != nil {
			return err
		}
	}

	if err = gobtools.EncodeInterface(ctx, buf, r.f18); err != nil {
		return err
	}

	if r.f19 == nil {
		if err = gobtools.EncodeSimple(buf, int32(-1)); err != nil {
			return err
		}
	} else {
		if err = gobtools.EncodeSimple(buf, int32(len(r.f19))); err != nil {
			return err
		}
		for val6 := 0; val6 < len(r.f19); val6++ {
			if err = gobtools.EncodeString(buf, r.f19[val6]); err != nil {
				return err
			}
		}
	}

	val7 := r.f20.ToSlice()
	if val7 == nil {
		if err = gobtools.EncodeSimple(buf, int32(-1)); err != nil {
			return err
		}
	} else {
		if err = gobtools.EncodeSimple(buf, int32(len(val7))); err != nil {
			return err
		}
		for val8 := 0; val8 < len(val7); val8++ {
			if err = val7[val8].Encode(ctx, buf); err != nil {
				return err
			}
		}
	}

	val9 := r.f21.ToSlice()
	if val9 == nil {
		if err = gobtools.EncodeSimple(buf, int32(-1)); err != nil {
			return err
		}
	} else {
		if err = gobtools.EncodeSimple(buf, int32(len(val9))); err != nil {
			return err
		}
		for val10 := 0; val10 < len(val9); val10++ {
			if err = gobtools.EncodeInterface(ctx, buf, val9[val10]); err != nil {
				return err
			}
		}
	}

	if err = r.f22.Encode(ctx, buf); err != nil {
		return err
	}

	if r.f23 == nil {
		if err = gobtools.EncodeSimple(buf, int32(-1)); err != nil {
			return err
		}
	} else {
		if err = gobtools.EncodeSimple(buf, int32(len(r.f23))); err != nil {
			return err
		}
		for val11 := 0; val11 < len(r.f23); val11++ {
			if r.f23[val11] == nil {
				if err = gobtools.EncodeSimple(buf, int32(-1)); err != nil {
					return err
				}
			} else {
				if err = gobtools.EncodeSimple(buf, int32(len(r.f23[val11]))); err != nil {
					return err
				}
				for val12 := 0; val12 < len(r.f23[val11]); val12++ {
					if err = r.f23[val11][val12].Encode(ctx, buf); err != nil {
						return err
					}
				}
			}
		}
	}

	if err = gobtools.EncodeInterface(ctx, buf, r.f24); err != nil {
		return err
	}

	if err = test.TypeStruct(r.f25).Encode(ctx, buf); err != nil {
		return err
	}

	if err = r.f26.Encode(ctx, buf); err != nil {
		return err
	}

	if err = r.f27.EncodeInterface(ctx, buf); err != nil {
		return err
	}

	if r.f28 == nil {
		if err = gobtools.EncodeSimple(buf, int32(-1)); err != nil {
			return err
		}
	} else {
		if err = gobtools.EncodeSimple(buf, int32(len(r.f28))); err != nil {
			return err
		}
		for k, v := range r.f28 {
			if err = gobtools.EncodeSimple(buf, int64(k)); err != nil {
				return err
			}
			if v == nil {
				if err = gobtools.EncodeSimple(buf, int32(-1)); err != nil {
					return err
				}
			} else {
				if err = gobtools.EncodeSimple(buf, int32(len(v))); err != nil {
					return err
				}
				for val13 := 0; val13 < len(v); val13++ {
					if err = gobtools.EncodeString(buf, v[val13]); err != nil {
						return err
					}
				}
			}
		}
	}

	if r.f29 == nil {
		if err = gobtools.EncodeSimple(buf, int32(-1)); err != nil {
			return err
		}
	} else {
		if err = gobtools.EncodeSimple(buf, int32(len(r.f29))); err != nil {
			return err
		}
		for val14 := 0; val14 < len(r.f29); val14++ {
			if r.f29[val14] == nil {
				if err = gobtools.EncodeSimple(buf, int32(-1)); err != nil {
					return err
				}
			} else {
				if err = gobtools.EncodeSimple(buf, int32(len(r.f29[val14]))); err != nil {
					return err
				}
				for val15 := 0; val15 < len(r.f29[val14]); val15++ {
					if err = gobtools.EncodeString(buf, r.f29[val14][val15]); err != nil {
						return err
					}
				}
			}
		}
	}

	if err = r.f30.EncodeString(ctx, buf); err != nil {
		return err
	}

	if err = gobtools.EncodeInterface(ctx, buf, r.f31); err != nil {
		return err
	}

	if r.f32 == nil {
		if err = gobtools.EncodeSimple(buf, int32(-1)); err != nil {
			return err
		}
	} else {
		if err = gobtools.EncodeSimple(buf, int32(len(r.f32))); err != nil {
			return err
		}
		for val16 := 0; val16 < len(r.f32); val16++ {
			val17 := r.f32[val16] == nil
			if err = gobtools.EncodeSimple(buf, val17); err != nil {
				return err
			}
			if !val17 {
				if err = (*r.f32[val16]).Encode(ctx, buf); err != nil {
					return err
				}
			}
		}
	}

	if err = gobtools.EncodeString(buf, r.f33); err != nil {
		return err
	}
	if err = gobtools.EncodeString(buf, r.f34); err != nil {
		return err
	}

	if err = gobtools.EncodeString(buf, r.f35.s); err != nil {
		return err
	}

	if err = r.f36.Encode(ctx, buf); err != nil {
		return err
	}

	val18 := r.TestEmbedPtr == nil
	if err = gobtools.EncodeSimple(buf, val18); err != nil {
		return err
	}
	if !val18 {
		if err = (*r.TestEmbedPtr).Encode(ctx, buf); err != nil {
			return err
		}
	}

	if err = gobtools.EncodeSimple(buf, int64(int(r.f38))); err != nil {
		return err
	}
	return err
}

func (r *TestStruct) Decode(ctx gobtools.EncContext, buf *bytes.Reader) error {
	var err error

	if err = r.TestEcho.Decode(ctx, buf); err != nil {
		return err
	}

	err = gobtools.DecodeString(buf, &r.f1)
	if err != nil {
		return err
	}

	err = gobtools.DecodeSimple[int16](buf, &r.f2)
	if err != nil {
		return err
	}

	err = gobtools.DecodeSimple[int32](buf, &r.f3)
	if err != nil {
		return err
	}

	err = gobtools.DecodeSimple[bool](buf, &r.f4)
	if err != nil {
		return err
	}

	err = gobtools.DecodeSimple[int64](buf, &r.f5)
	if err != nil {
		return err
	}

	err = gobtools.DecodeString(buf, &r.f6)
	if err != nil {
		return err
	}

	if err = r.f7.Decode(ctx, buf); err != nil {
		return err
	}

	err = gobtools.DecodeSimple[uint16](buf, &r.f8)
	if err != nil {
		return err
	}

	err = gobtools.DecodeSimple[uint32](buf, &r.f9)
	if err != nil {
		return err
	}

	err = gobtools.DecodeSimple[uint64](buf, &r.f10)
	if err != nil {
		return err
	}

	var val13 int32
	err = gobtools.DecodeSimple[int32](buf, &val13)
	if err != nil {
		return err
	}
	if val13 != -1 {
		r.f11 = make([]string, val13)
		for val14 := 0; val14 < int(val13); val14++ {
			err = gobtools.DecodeString(buf, &r.f11[val14])
			if err != nil {
				return err
			}
		}
	}

	var val16 int32
	err = gobtools.DecodeSimple[int32](buf, &val16)
	if err != nil {
		return err
	}
	if val16 != -1 {
		r.f12 = make(map[string]int, val16)
		for val17 := 0; val17 < int(val16); val17++ {
			var k string
			var v int
			err = gobtools.DecodeString(buf, &k)
			if err != nil {
				return err
			}
			var val19 int64
			err = gobtools.DecodeSimple[int64](buf, &val19)
			if err != nil {
				return err
			}
			v = int(val19)
			r.f12[k] = v
		}
	}

	var val21 bool
	if err = gobtools.DecodeSimple(buf, &val21); err != nil {
		return err
	}
	if !val21 {
		var val20 string
		err = gobtools.DecodeString(buf, &val20)
		if err != nil {
			return err
		}
		r.f13 = &val20
	}

	var val23 int64
	err = gobtools.DecodeSimple[int64](buf, &val23)
	if err != nil {
		return err
	}
	r.f14 = int(val23)

	var val25 int32
	err = gobtools.DecodeSimple[int32](buf, &val25)
	if err != nil {
		return err
	}
	if val25 != -1 {
		r.f15 = make([]int, val25)
		for val26 := 0; val26 < int(val25); val26++ {
			var val27 int64
			err = gobtools.DecodeSimple[int64](buf, &val27)
			if err != nil {
				return err
			}
			r.f15[val26] = int(val27)
		}
	}

	var val29 int32
	err = gobtools.DecodeSimple[int32](buf, &val29)
	if err != nil {
		return err
	}
	if val29 != -1 {
		r.f16 = make([]TestEcho, val29)
		for val30 := 0; val30 < int(val29); val30++ {
			if err = r.f16[val30].Decode(ctx, buf); err != nil {
				return err
			}
		}
	}

	var val33 bool
	if err = gobtools.DecodeSimple(buf, &val33); err != nil {
		return err
	}
	if !val33 {
		var val32 TestEcho
		if err = val32.Decode(ctx, buf); err != nil {
			return err
		}
		r.f17 = &val32
	}

	if val36, err := gobtools.DecodeInterface(ctx, buf); err != nil {
		return err
	} else if val36 == nil {
		r.f18 = nil
	} else {
		r.f18 = val36.(TestEchoInterface)
	}

	var val39 int32
	err = gobtools.DecodeSimple[int32](buf, &val39)
	if err != nil {
		return err
	}
	if val39 != -1 {
		r.f19 = make([]string, val39)
		for val40 := 0; val40 < int(val39); val40++ {
			err = gobtools.DecodeString(buf, &r.f19[val40])
			if err != nil {
				return err
			}
		}
	}

	var val43 []TestEcho
	var val44 int32
	err = gobtools.DecodeSimple[int32](buf, &val44)
	if err != nil {
		return err
	}
	if val44 != -1 {
		val43 = make([]TestEcho, val44)
		for val45 := 0; val45 < int(val44); val45++ {
			if err = val43[val45].Decode(ctx, buf); err != nil {
				return err
			}
		}
	}
	r.f20 = uniquelist.Make(val43)

	var val48 []TestEchoInterface
	var val49 int32
	err = gobtools.DecodeSimple[int32](buf, &val49)
	if err != nil {
		return err
	}
	if val49 != -1 {
		val48 = make([]TestEchoInterface, val49)
		for val50 := 0; val50 < int(val49); val50++ {
			if val52, err := gobtools.DecodeInterface(ctx, buf); err != nil {
				return err
			} else if val52 == nil {
				val48[val50] = nil
			} else {
				val48[val50] = val52.(TestEchoInterface)
			}
		}
	}
	r.f21 = uniquelist.Make(val48)

	if err = r.f22.Decode(ctx, buf); err != nil {
		return err
	}

	var val55 int32
	err = gobtools.DecodeSimple[int32](buf, &val55)
	if err != nil {
		return err
	}
	if val55 != -1 {
		r.f23 = make([]test.TypeAlias, val55)
		for val56 := 0; val56 < int(val55); val56++ {
			var val59 int32
			err = gobtools.DecodeSimple[int32](buf, &val59)
			if err != nil {
				return err
			}
			if val59 != -1 {
				r.f23[val56] = make([]test.TypeStruct, val59)
				for val60 := 0; val60 < int(val59); val60++ {
					if err = r.f23[val56][val60].Decode(ctx, buf); err != nil {
						return err
					}
				}
			}
		}
	}

	if val63, err := gobtools.DecodeInterface(ctx, buf); err != nil {
		return err
	} else if val63 == nil {
		r.f24 = nil
	} else {
		r.f24 = val63.(test.TypeInterface)
	}

	var val65 test.TypeStruct
	if err = val65.Decode(ctx, buf); err != nil {
		return err
	}
	r.f25 = test.TypeIdent(val65)

	if err = r.f26.Decode(ctx, buf); err != nil {
		return err
	}

	if err = r.f27.DecodeInterface(ctx, buf); err != nil {
		return err
	}

	var val69 int32
	err = gobtools.DecodeSimple[int32](buf, &val69)
	if err != nil {
		return err
	}
	if val69 != -1 {
		r.f28 = make(map[int][]string, val69)
		for val70 := 0; val70 < int(val69); val70++ {
			var k int
			var v []string
			var val71 int64
			err = gobtools.DecodeSimple[int64](buf, &val71)
			if err != nil {
				return err
			}
			k = int(val71)
			var val73 int32
			err = gobtools.DecodeSimple[int32](buf, &val73)
			if err != nil {
				return err
			}
			if val73 != -1 {
				v = make([]string, val73)
				for val74 := 0; val74 < int(val73); val74++ {
					err = gobtools.DecodeString(buf, &v[val74])
					if err != nil {
						return err
					}
				}
			}
			r.f28[k] = v
		}
	}

	var val77 int32
	err = gobtools.DecodeSimple[int32](buf, &val77)
	if err != nil {
		return err
	}
	if val77 != -1 {
		r.f29 = make([][]string, val77)
		for val78 := 0; val78 < int(val77); val78++ {
			var val80 int32
			err = gobtools.DecodeSimple[int32](buf, &val80)
			if err != nil {
				return err
			}
			if val80 != -1 {
				r.f29[val78] = make([]string, val80)
				for val81 := 0; val81 < int(val80); val81++ {
					err = gobtools.DecodeString(buf, &r.f29[val78][val81])
					if err != nil {
						return err
					}
				}
			}
		}
	}

	if err = r.f30.DecodeString(ctx, buf); err != nil {
		return err
	}

	if val85, err := gobtools.DecodeInterface(ctx, buf); err != nil {
		return err
	} else if val85 == nil {
		r.f31 = nil
	} else {
		r.f31 = val85
	}

	var val87 int32
	err = gobtools.DecodeSimple[int32](buf, &val87)
	if err != nil {
		return err
	}
	if val87 != -1 {
		r.f32 = make([]*test.TypeStruct, val87)
		for val88 := 0; val88 < int(val87); val88++ {
			var val90 bool
			if err = gobtools.DecodeSimple(buf, &val90); err != nil {
				return err
			}
			if !val90 {
				var val89 test.TypeStruct
				if err = val89.Decode(ctx, buf); err != nil {
					return err
				}
				r.f32[val88] = &val89
			}
		}
	}

	err = gobtools.DecodeString(buf, &r.f33)
	if err != nil {
		return err
	}
	err = gobtools.DecodeString(buf, &r.f34)
	if err != nil {
		return err
	}

	err = gobtools.DecodeString(buf, &r.f35.s)
	if err != nil {
		return err
	}

	if err = r.f36.Decode(ctx, buf); err != nil {
		return err
	}

	var val98 bool
	if err = gobtools.DecodeSimple(buf, &val98); err != nil {
		return err
	}
	if !val98 {
		var val97 TestEmbedPtr
		if err = val97.Decode(ctx, buf); err != nil {
			return err
		}
		r.TestEmbedPtr = &val97
	}

	var val101 int
	var val102 int64
	err = gobtools.DecodeSimple[int64](buf, &val102)
	if err != nil {
		return err
	}
	val101 = int(val102)
	r.f38 = test.TypeBasic(val101)

	return err
}

var TestStructGobRegId int16

func (r TestStruct) GetTypeId() int16 {
	return TestStructGobRegId
}

func (r TestEcho) Encode(ctx gobtools.EncContext, buf *bytes.Buffer) error {
	var err error

	if err = gobtools.EncodeString(buf, r.EchoStr); err != nil {
		return err
	}
	return err
}

func (r *TestEcho) Decode(ctx gobtools.EncContext, buf *bytes.Reader) error {
	var err error

	err = gobtools.DecodeString(buf, &r.EchoStr)
	if err != nil {
		return err
	}

	return err
}

var TestEchoGobRegId int16

func (r TestEcho) GetTypeId() int16 {
	return TestEchoGobRegId
}

func (r testEchos) Encode(ctx gobtools.EncContext, buf *bytes.Buffer) error {
	var err error

	if r == nil {
		if err = gobtools.EncodeSimple(buf, int32(-1)); err != nil {
			return err
		}
	} else {
		if err = gobtools.EncodeSimple(buf, int32(len(r))); err != nil {
			return err
		}
		for val1 := 0; val1 < len(r); val1++ {
			if err = gobtools.EncodeInterface(ctx, buf, r[val1]); err != nil {
				return err
			}
		}
	}
	return err
}

func (r *testEchos) Decode(ctx gobtools.EncContext, buf *bytes.Reader) error {
	var err error

	var val2 int32
	err = gobtools.DecodeSimple[int32](buf, &val2)
	if err != nil {
		return err
	}
	if val2 != -1 {
		(*r) = make([]TestEchoInterface, val2)
		for val3 := 0; val3 < int(val2); val3++ {
			if val5, err := gobtools.DecodeInterface(ctx, buf); err != nil {
				return err
			} else if val5 == nil {
				(*r)[val3] = nil
			} else {
				(*r)[val3] = val5.(TestEchoInterface)
			}
		}
	}

	return err
}

var testEchosGobRegId int16

func (r testEchos) GetTypeId() int16 {
	return testEchosGobRegId
}

func (r testStringMap) Encode(ctx gobtools.EncContext, buf *bytes.Buffer) error {
	var err error

	if r == nil {
		if err = gobtools.EncodeSimple(buf, int32(-1)); err != nil {
			return err
		}
	} else {
		if err = gobtools.EncodeSimple(buf, int32(len(r))); err != nil {
			return err
		}
		for k, v := range r {
			if err = gobtools.EncodeString(buf, k); err != nil {
				return err
			}
			if v == nil {
				if err = gobtools.EncodeSimple(buf, int32(-1)); err != nil {
					return err
				}
			} else {
				if err = gobtools.EncodeSimple(buf, int32(len(v))); err != nil {
					return err
				}
				for val1 := 0; val1 < len(v); val1++ {
					if err = gobtools.EncodeString(buf, v[val1]); err != nil {
						return err
					}
				}
			}
		}
	}
	return err
}

func (r *testStringMap) Decode(ctx gobtools.EncContext, buf *bytes.Reader) error {
	var err error

	var val1 int32
	err = gobtools.DecodeSimple[int32](buf, &val1)
	if err != nil {
		return err
	}
	if val1 != -1 {
		(*r) = make(map[string][]string, val1)
		for val2 := 0; val2 < int(val1); val2++ {
			var k string
			var v []string
			err = gobtools.DecodeString(buf, &k)
			if err != nil {
				return err
			}
			var val5 int32
			err = gobtools.DecodeSimple[int32](buf, &val5)
			if err != nil {
				return err
			}
			if val5 != -1 {
				v = make([]string, val5)
				for val6 := 0; val6 < int(val5); val6++ {
					err = gobtools.DecodeString(buf, &v[val6])
					if err != nil {
						return err
					}
				}
			}
			(*r)[k] = v
		}
	}

	return err
}

var testStringMapGobRegId int16

func (r testStringMap) GetTypeId() int16 {
	return testStringMapGobRegId
}

func (r testEchoMap) Encode(ctx gobtools.EncContext, buf *bytes.Buffer) error {
	var err error

	if r == nil {
		if err = gobtools.EncodeSimple(buf, int32(-1)); err != nil {
			return err
		}
	} else {
		if err = gobtools.EncodeSimple(buf, int32(len(r))); err != nil {
			return err
		}
		for k, v := range r {
			if err = k.Encode(ctx, buf); err != nil {
				return err
			}
			val1 := v == nil
			if err = gobtools.EncodeSimple(buf, val1); err != nil {
				return err
			}
			if !val1 {
				if err = (*v).Encode(ctx, buf); err != nil {
					return err
				}
			}
		}
	}
	return err
}

func (r *testEchoMap) Decode(ctx gobtools.EncContext, buf *bytes.Reader) error {
	var err error

	var val1 int32
	err = gobtools.DecodeSimple[int32](buf, &val1)
	if err != nil {
		return err
	}
	if val1 != -1 {
		(*r) = make(map[TestEcho]*TestEcho, val1)
		for val2 := 0; val2 < int(val1); val2++ {
			var k TestEcho
			var v *TestEcho
			if err = k.Decode(ctx, buf); err != nil {
				return err
			}
			var val5 bool
			if err = gobtools.DecodeSimple(buf, &val5); err != nil {
				return err
			}
			if !val5 {
				var val4 TestEcho
				if err = val4.Decode(ctx, buf); err != nil {
					return err
				}
				v = &val4
			}
			(*r)[k] = v
		}
	}

	return err
}

var testEchoMapGobRegId int16

func (r testEchoMap) GetTypeId() int16 {
	return testEchoMapGobRegId
}

func (r TestEmbedPtr) Encode(ctx gobtools.EncContext, buf *bytes.Buffer) error {
	var err error

	if err = gobtools.EncodeString(buf, r.f37); err != nil {
		return err
	}
	return err
}

func (r *TestEmbedPtr) Decode(ctx gobtools.EncContext, buf *bytes.Reader) error {
	var err error

	err = gobtools.DecodeString(buf, &r.f37)
	if err != nil {
		return err
	}

	return err
}

var TestEmbedPtrGobRegId int16

func (r TestEmbedPtr) GetTypeId() int16 {
	return TestEmbedPtrGobRegId
}