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

package cc

import (
	"android/soong/android"
	"bytes"
	"github.com/google/blueprint/gobtools"
)

func init() {
	CcMakeVarsInfoGobRegId = gobtools.RegisterType(func() gobtools.CustomDec { return new(CcMakeVarsInfo) })
	CcObjectInfoGobRegId = gobtools.RegisterType(func() gobtools.CustomDec { return new(CcObjectInfo) })
	AidlInterfaceInfoGobRegId = gobtools.RegisterType(func() gobtools.CustomDec { return new(AidlInterfaceInfo) })
	CompilerInfoGobRegId = gobtools.RegisterType(func() gobtools.CustomDec { return new(CompilerInfo) })
	LinkerInfoGobRegId = gobtools.RegisterType(func() gobtools.CustomDec { return new(LinkerInfo) })
	BinaryDecoratorInfoGobRegId = gobtools.RegisterType(func() gobtools.CustomDec { return new(BinaryDecoratorInfo) })
	LibraryDecoratorInfoGobRegId = gobtools.RegisterType(func() gobtools.CustomDec { return new(LibraryDecoratorInfo) })
	SnapshotInfoGobRegId = gobtools.RegisterType(func() gobtools.CustomDec { return new(SnapshotInfo) })
	TestBinaryInfoGobRegId = gobtools.RegisterType(func() gobtools.CustomDec { return new(TestBinaryInfo) })
	BenchmarkDecoratorInfoGobRegId = gobtools.RegisterType(func() gobtools.CustomDec { return new(BenchmarkDecoratorInfo) })
	StubDecoratorInfoGobRegId = gobtools.RegisterType(func() gobtools.CustomDec { return new(StubDecoratorInfo) })
	ObjectLinkerInfoGobRegId = gobtools.RegisterType(func() gobtools.CustomDec { return new(ObjectLinkerInfo) })
	PrebuiltLibraryLinkerInfoGobRegId = gobtools.RegisterType(func() gobtools.CustomDec { return new(PrebuiltLibraryLinkerInfo) })
	LibraryInfoGobRegId = gobtools.RegisterType(func() gobtools.CustomDec { return new(LibraryInfo) })
	InstallerInfoGobRegId = gobtools.RegisterType(func() gobtools.CustomDec { return new(InstallerInfo) })
	LocalOrGlobalFlagsInfoGobRegId = gobtools.RegisterType(func() gobtools.CustomDec { return new(LocalOrGlobalFlagsInfo) })
	SanitizeInfoGobRegId = gobtools.RegisterType(func() gobtools.CustomDec { return new(SanitizeInfo) })
	StlInfoGobRegId = gobtools.RegisterType(func() gobtools.CustomDec { return new(StlInfo) })
	CcInfoGobRegId = gobtools.RegisterType(func() gobtools.CustomDec { return new(CcInfo) })
	LinkableInfoGobRegId = gobtools.RegisterType(func() gobtools.CustomDec { return new(LinkableInfo) })
	InstallPairGobRegId = gobtools.RegisterType(func() gobtools.CustomDec { return new(InstallPair) })
	RustRlibDepGobRegId = gobtools.RegisterType(func() gobtools.CustomDec { return new(RustRlibDep) })
}

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

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

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

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

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

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

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

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

	return err
}

var CcMakeVarsInfoGobRegId int16

func (r CcMakeVarsInfo) GetTypeId() int16 {
	return CcMakeVarsInfoGobRegId
}

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

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

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

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

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

	var val3 int32
	err = gobtools.DecodeSimple[int32](buf, &val3)
	if err != nil {
		return err
	}
	if val3 != -1 {
		r.ObjFiles = make([]android.Path, val3)
		for val4 := 0; val4 < int(val3); val4++ {
			if val6, err := gobtools.DecodeInterface(ctx, buf); err != nil {
				return err
			} else if val6 == nil {
				r.ObjFiles[val4] = nil
			} else {
				r.ObjFiles[val4] = val6.(android.Path)
			}
		}
	}

	var val9 int32
	err = gobtools.DecodeSimple[int32](buf, &val9)
	if err != nil {
		return err
	}
	if val9 != -1 {
		r.TidyFiles = make([]android.Path, val9)
		for val10 := 0; val10 < int(val9); val10++ {
			if val12, err := gobtools.DecodeInterface(ctx, buf); err != nil {
				return err
			} else if val12 == nil {
				r.TidyFiles[val10] = nil
			} else {
				r.TidyFiles[val10] = val12.(android.Path)
			}
		}
	}

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

	return err
}

var CcObjectInfoGobRegId int16

func (r CcObjectInfo) GetTypeId() int16 {
	return CcObjectInfoGobRegId
}

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

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

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

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

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

func (r *AidlInterfaceInfo) 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.Sources = make([]string, val2)
		for val3 := 0; val3 < int(val2); val3++ {
			err = gobtools.DecodeString(buf, &r.Sources[val3])
			if err != nil {
				return err
			}
		}
	}

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

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

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

	return err
}

var AidlInterfaceInfoGobRegId int16

func (r AidlInterfaceInfo) GetTypeId() int16 {
	return AidlInterfaceInfoGobRegId
}

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

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

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

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

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

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

	var val3 int32
	err = gobtools.DecodeSimple[int32](buf, &val3)
	if err != nil {
		return err
	}
	if val3 != -1 {
		r.Srcs = make([]android.Path, val3)
		for val4 := 0; val4 < int(val3); val4++ {
			if val6, err := gobtools.DecodeInterface(ctx, buf); err != nil {
				return err
			} else if val6 == nil {
				r.Srcs[val4] = nil
			} else {
				r.Srcs[val4] = val6.(android.Path)
			}
		}
	}

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

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

	var val13 bool
	if err = gobtools.DecodeSimple(buf, &val13); err != nil {
		return err
	}
	if !val13 {
		var val12 LibraryDecoratorInfo
		if err = val12.Decode(ctx, buf); err != nil {
			return err
		}
		r.LibraryDecoratorInfo = &val12
	}

	return err
}

var CompilerInfoGobRegId int16

func (r CompilerInfo) GetTypeId() int16 {
	return CompilerInfoGobRegId
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

func (r *LinkerInfo) 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.WholeStaticLibs = make([]string, val2)
		for val3 := 0; val3 < int(val2); val3++ {
			err = gobtools.DecodeString(buf, &r.WholeStaticLibs[val3])
			if err != nil {
				return err
			}
		}
	}

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

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

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

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

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

	var val25 bool
	if err = gobtools.DecodeSimple(buf, &val25); err != nil {
		return err
	}
	if !val25 {
		var val24 BinaryDecoratorInfo
		if err = val24.Decode(ctx, buf); err != nil {
			return err
		}
		r.BinaryDecoratorInfo = &val24
	}

	var val28 bool
	if err = gobtools.DecodeSimple(buf, &val28); err != nil {
		return err
	}
	if !val28 {
		var val27 LibraryDecoratorInfo
		if err = val27.Decode(ctx, buf); err != nil {
			return err
		}
		r.LibraryDecoratorInfo = &val27
	}

	var val31 bool
	if err = gobtools.DecodeSimple(buf, &val31); err != nil {
		return err
	}
	if !val31 {
		var val30 TestBinaryInfo
		if err = val30.Decode(ctx, buf); err != nil {
			return err
		}
		r.TestBinaryInfo = &val30
	}

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

	var val37 bool
	if err = gobtools.DecodeSimple(buf, &val37); err != nil {
		return err
	}
	if !val37 {
		var val36 ObjectLinkerInfo
		if err = val36.Decode(ctx, buf); err != nil {
			return err
		}
		r.ObjectLinkerInfo = &val36
	}

	var val40 bool
	if err = gobtools.DecodeSimple(buf, &val40); err != nil {
		return err
	}
	if !val40 {
		var val39 StubDecoratorInfo
		if err = val39.Decode(ctx, buf); err != nil {
			return err
		}
		r.StubDecoratorInfo = &val39
	}

	var val43 bool
	if err = gobtools.DecodeSimple(buf, &val43); err != nil {
		return err
	}
	if !val43 {
		var val42 PrebuiltLibraryLinkerInfo
		if err = val42.Decode(ctx, buf); err != nil {
			return err
		}
		r.PrebuiltLibraryLinkerInfo = &val42
	}

	return err
}

var LinkerInfoGobRegId int16

func (r LinkerInfo) GetTypeId() int16 {
	return LinkerInfoGobRegId
}

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

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

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

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

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

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

	return err
}

var BinaryDecoratorInfoGobRegId int16

func (r BinaryDecoratorInfo) GetTypeId() int16 {
	return BinaryDecoratorInfoGobRegId
}

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

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

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

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

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

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

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

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

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

func (r *LibraryDecoratorInfo) 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.ExportIncludeDirs = make([]string, val2)
		for val3 := 0; val3 < int(val2); val3++ {
			err = gobtools.DecodeString(buf, &r.ExportIncludeDirs[val3])
			if err != nil {
				return err
			}
		}
	}

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

	if val7, err := gobtools.DecodeInterface(ctx, buf); err != nil {
		return err
	} else if val7 == nil {
		r.NdkSysrootPath = nil
	} else {
		r.NdkSysrootPath = val7.(android.Path)
	}

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

	var val10 bool
	if err = gobtools.DecodeSimple(buf, &val10); err != nil {
		return err
	}
	if !val10 {
		var val9 bool
		err = gobtools.DecodeSimple[bool](buf, &val9)
		if err != nil {
			return err
		}
		r.UniqueHostSoname = &val9
	}

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

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

	if val21, err := gobtools.DecodeInterface(ctx, buf); err != nil {
		return err
	} else if val21 == nil {
		r.StubsSymbolFilePath = nil
	} else {
		r.StubsSymbolFilePath = val21.(android.Path)
	}

	return err
}

var LibraryDecoratorInfoGobRegId int16

func (r LibraryDecoratorInfo) GetTypeId() int16 {
	return LibraryDecoratorInfoGobRegId
}

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

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

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

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

	return err
}

var SnapshotInfoGobRegId int16

func (r SnapshotInfo) GetTypeId() int16 {
	return SnapshotInfoGobRegId
}

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

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

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

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

	return err
}

var TestBinaryInfoGobRegId int16

func (r TestBinaryInfo) GetTypeId() int16 {
	return TestBinaryInfoGobRegId
}

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

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

	return err
}

var BenchmarkDecoratorInfoGobRegId int16

func (r BenchmarkDecoratorInfo) GetTypeId() int16 {
	return BenchmarkDecoratorInfoGobRegId
}

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

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

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

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

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

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

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

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

	var val5 int32
	err = gobtools.DecodeSimple[int32](buf, &val5)
	if err != nil {
		return err
	}
	if val5 != -1 {
		r.AbiDiffPaths = make([]android.Path, val5)
		for val6 := 0; val6 < int(val5); val6++ {
			if val8, err := gobtools.DecodeInterface(ctx, buf); err != nil {
				return err
			} else if val8 == nil {
				r.AbiDiffPaths[val6] = nil
			} else {
				r.AbiDiffPaths[val6] = val8.(android.Path)
			}
		}
	}

	if val10, err := gobtools.DecodeInterface(ctx, buf); err != nil {
		return err
	} else if val10 == nil {
		r.InstallPath = nil
	} else {
		r.InstallPath = val10.(android.Path)
	}

	return err
}

var StubDecoratorInfoGobRegId int16

func (r StubDecoratorInfo) GetTypeId() int16 {
	return StubDecoratorInfoGobRegId
}

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

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

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

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

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

	if val2, err := gobtools.DecodeInterface(ctx, buf); err != nil {
		return err
	} else if val2 == nil {
		r.NdkSysrootPath = nil
	} else {
		r.NdkSysrootPath = val2.(android.Path)
	}

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

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

	return err
}

var ObjectLinkerInfoGobRegId int16

func (r ObjectLinkerInfo) GetTypeId() int16 {
	return ObjectLinkerInfoGobRegId
}

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

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

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

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

	return err
}

var PrebuiltLibraryLinkerInfoGobRegId int16

func (r PrebuiltLibraryLinkerInfo) GetTypeId() int16 {
	return PrebuiltLibraryLinkerInfoGobRegId
}

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

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

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

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

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

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

	return err
}

var LibraryInfoGobRegId int16

func (r LibraryInfo) GetTypeId() int16 {
	return LibraryInfoGobRegId
}

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

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

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

	var val2 bool
	if err = gobtools.DecodeSimple(buf, &val2); err != nil {
		return err
	}
	if !val2 {
		var val1 StubDecoratorInfo
		if err = val1.Decode(ctx, buf); err != nil {
			return err
		}
		r.StubDecoratorInfo = &val1
	}

	return err
}

var InstallerInfoGobRegId int16

func (r InstallerInfo) GetTypeId() int16 {
	return InstallerInfoGobRegId
}

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

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

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

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

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

func (r *LocalOrGlobalFlagsInfo) 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.CommonFlags = make([]string, val2)
		for val3 := 0; val3 < int(val2); val3++ {
			err = gobtools.DecodeString(buf, &r.CommonFlags[val3])
			if err != nil {
				return err
			}
		}
	}

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

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

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

	return err
}

var LocalOrGlobalFlagsInfoGobRegId int16

func (r LocalOrGlobalFlagsInfo) GetTypeId() int16 {
	return LocalOrGlobalFlagsInfoGobRegId
}

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

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

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

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

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

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

	return err
}

var SanitizeInfoGobRegId int16

func (r SanitizeInfo) GetTypeId() int16 {
	return SanitizeInfoGobRegId
}

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

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

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

	var val2 bool
	if err = gobtools.DecodeSimple(buf, &val2); err != nil {
		return err
	}
	if !val2 {
		var val1 string
		err = gobtools.DecodeString(buf, &val1)
		if err != nil {
			return err
		}
		r.Stl = &val1
	}

	return err
}

var StlInfoGobRegId int16

func (r StlInfo) GetTypeId() int16 {
	return StlInfoGobRegId
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

	var val5 int32
	err = gobtools.DecodeSimple[int32](buf, &val5)
	if err != nil {
		return err
	}
	if val5 != -1 {
		r.DataPaths = make([]android.DataPath, val5)
		for val6 := 0; val6 < int(val5); val6++ {
			if err = r.DataPaths[val6].Decode(ctx, buf); err != nil {
				return err
			}
		}
	}

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

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

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

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

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

	var val14 int32
	err = gobtools.DecodeSimple[int32](buf, &val14)
	if err != nil {
		return err
	}
	if val14 != -1 {
		r.SdkMemberTypes = make([]android.SdkMemberType, val14)
		for val15 := 0; val15 < int(val14); val15++ {
			if val17, err := gobtools.DecodeInterface(ctx, buf); err != nil {
				return err
			} else if val17 == nil {
				r.SdkMemberTypes[val15] = nil
			} else {
				r.SdkMemberTypes[val15] = val17.(android.SdkMemberType)
			}
		}
	}

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

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

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

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

	var val29 bool
	if err = gobtools.DecodeSimple(buf, &val29); err != nil {
		return err
	}
	if !val29 {
		var val28 CompilerInfo
		if err = val28.Decode(ctx, buf); err != nil {
			return err
		}
		r.CompilerInfo = &val28
	}

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

	var val35 bool
	if err = gobtools.DecodeSimple(buf, &val35); err != nil {
		return err
	}
	if !val35 {
		var val34 SnapshotInfo
		if err = val34.Decode(ctx, buf); err != nil {
			return err
		}
		r.SnapshotInfo = &val34
	}

	var val38 bool
	if err = gobtools.DecodeSimple(buf, &val38); err != nil {
		return err
	}
	if !val38 {
		var val37 LibraryInfo
		if err = val37.Decode(ctx, buf); err != nil {
			return err
		}
		r.LibraryInfo = &val37
	}

	var val41 bool
	if err = gobtools.DecodeSimple(buf, &val41); err != nil {
		return err
	}
	if !val41 {
		var val40 InstallerInfo
		if err = val40.Decode(ctx, buf); err != nil {
			return err
		}
		r.InstallerInfo = &val40
	}

	var val44 bool
	if err = gobtools.DecodeSimple(buf, &val44); err != nil {
		return err
	}
	if !val44 {
		var val43 StlInfo
		if err = val43.Decode(ctx, buf); err != nil {
			return err
		}
		r.StlInfo = &val43
	}

	var val47 bool
	if err = gobtools.DecodeSimple(buf, &val47); err != nil {
		return err
	}
	if !val47 {
		var val46 SanitizeInfo
		if err = val46.Decode(ctx, buf); err != nil {
			return err
		}
		r.SanitizeInfo = &val46
	}

	return err
}

var CcInfoGobRegId int16

func (r CcInfo) GetTypeId() int16 {
	return CcInfoGobRegId
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

	val4 := r.Installable == nil
	if err = gobtools.EncodeSimple(buf, val4); err != nil {
		return err
	}
	if !val4 {
		if err = gobtools.EncodeSimple(buf, (*r.Installable)); err != nil {
			return err
		}
	}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

	if val9, err := gobtools.DecodeInterface(ctx, buf); err != nil {
		return err
	} else if val9 == nil {
		r.UnstrippedOutputFile = nil
	} else {
		r.UnstrippedOutputFile = val9.(android.Path)
	}

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

	var val13 int32
	err = gobtools.DecodeSimple[int32](buf, &val13)
	if err != nil {
		return err
	}
	if val13 != -1 {
		r.CoverageFiles = make([]android.Path, val13)
		for val14 := 0; val14 < int(val13); val14++ {
			if val16, err := gobtools.DecodeInterface(ctx, buf); err != nil {
				return err
			} else if val16 == nil {
				r.CoverageFiles[val14] = nil
			} else {
				r.CoverageFiles[val14] = val16.(android.Path)
			}
		}
	}

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

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

	var val21 int32
	err = gobtools.DecodeSimple[int32](buf, &val21)
	if err != nil {
		return err
	}
	if val21 != -1 {
		r.SAbiDumpFiles = make([]android.Path, val21)
		for val22 := 0; val22 < int(val21); val22++ {
			if val24, err := gobtools.DecodeInterface(ctx, buf); err != nil {
				return err
			} else if val24 == nil {
				r.SAbiDumpFiles[val22] = nil
			} else {
				r.SAbiDumpFiles[val22] = val24.(android.Path)
			}
		}
	}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

	var val47 bool
	if err = gobtools.DecodeSimple(buf, &val47); err != nil {
		return err
	}
	if !val47 {
		var val46 bool
		err = gobtools.DecodeSimple[bool](buf, &val46)
		if err != nil {
			return err
		}
		r.Installable = &val46
	}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

	return err
}

var LinkableInfoGobRegId int16

func (r LinkableInfo) GetTypeId() int16 {
	return LinkableInfoGobRegId
}

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

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

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

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

	if val2, err := gobtools.DecodeInterface(ctx, buf); err != nil {
		return err
	} else if val2 == nil {
		r.Src = nil
	} else {
		r.Src = val2.(android.Path)
	}

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

	return err
}

var InstallPairGobRegId int16

func (r InstallPair) GetTypeId() int16 {
	return InstallPairGobRegId
}

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

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

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

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

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

	if val2, err := gobtools.DecodeInterface(ctx, buf); err != nil {
		return err
	} else if val2 == nil {
		r.LibPath = nil
	} else {
		r.LibPath = val2.(android.Path)
	}

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

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

	return err
}

var RustRlibDepGobRegId int16

func (r RustRlibDep) GetTypeId() int16 {
	return RustRlibDepGobRegId
}