java/java_enc.go

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

package java

import (
	"android/soong/android"
	"android/soong/dexpreopt"
	"bytes"
	"fmt"
	"github.com/google/blueprint/gobtools"
	"github.com/google/blueprint/proptools"
	"github.com/google/blueprint/uniquelist"
	"reflect"
	"unsafe"
)

// begin of aar.go
func init() {
	resourcesNodeGobRegId = gobtools.RegisterType(func() gobtools.CustomDec { return new(resourcesNode) })
	AndroidLibraryInfoGobRegId = gobtools.RegisterType(func() gobtools.CustomDec { return new(AndroidLibraryInfo) })
	AARImportInfoGobRegId = gobtools.RegisterType(func() gobtools.CustomDec { return new(AARImportInfo) })
	JniPackageInfoGobRegId = gobtools.RegisterType(func() gobtools.CustomDec { return new(JniPackageInfo) })
	AARImportDepInSameApexCheckerGobRegId = gobtools.RegisterType(func() gobtools.CustomDec { return new(AARImportDepInSameApexChecker) })
	AARInfoGobRegId = gobtools.RegisterType(func() gobtools.CustomDec { return new(AARInfo) })
}

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

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

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

	val1 := r.additionalManifests.Len() == 0
	if err = gobtools.EncodeBool(buf, val1); err != nil {
		return err
	}
	if !val1 {
		if err = gobtools.EncodeReference(ctx, r.additionalManifests, buf, func(v uniquelist.UniqueList[android.Path], buf *bytes.Buffer) error {
			val2 := v.ToSlice()
			if val2 == nil {
				if err = gobtools.EncodeInt(buf, -1); err != nil {
					return err
				}
			} else {
				if err = gobtools.EncodeInt(buf, len(val2)); err != nil {
					return err
				}
				for val3 := 0; val3 < len(val2); val3++ {
					if err = gobtools.EncodeInterface(ctx, buf, val2[val3]); err != nil {
						return err
					}
				}
			}
			return nil
		}); err != nil {
			return err
		}
	}

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

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

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

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

func (r resourcesNode) CustomHash(hasher *proptools.Hasher) error {
	hasher.WriteString(":java.resourcesNode")
	hasher.WriteInt(7)
	hasher.WriteString(":java.android.Path")
	val1 := r.resPackage == nil
	if val1 {
		hasher.WriteByte(0)
	} else {
		if v := reflect.ValueOf(r.resPackage); v.Kind() == reflect.Ptr {
			if v.IsNil() {
				panic(fmt.Errorf("nil pointer is not supported in interface"))
			} else {
				val2 := r.resPackage == nil
				if val2 {
					hasher.WriteByte(0)
				} else {
					val3 := func(hasher *proptools.Hasher) error { return r.resPackage.(proptools.CustomHash).CustomHash(hasher) }
					if err := proptools.HashReference(hasher, uintptr(v.Pointer()), val3); err != nil {
						return err
					}
				}
			}
		} else {
			r.resPackage.(proptools.CustomHash).CustomHash(hasher)
		}
	}
	hasher.WriteString(":java.android.Path")
	val4 := r.manifest == nil
	if val4 {
		hasher.WriteByte(0)
	} else {
		if v := reflect.ValueOf(r.manifest); v.Kind() == reflect.Ptr {
			if v.IsNil() {
				panic(fmt.Errorf("nil pointer is not supported in interface"))
			} else {
				val5 := r.manifest == nil
				if val5 {
					hasher.WriteByte(0)
				} else {
					val6 := func(hasher *proptools.Hasher) error { return r.manifest.(proptools.CustomHash).CustomHash(hasher) }
					if err := proptools.HashReference(hasher, uintptr(v.Pointer()), val6); err != nil {
						return err
					}
				}
			}
		} else {
			r.manifest.(proptools.CustomHash).CustomHash(hasher)
		}
	}
	hasher.WriteString(":.uniquelist.UniqueList[android.Path]")
	val11 := func(hasher *proptools.Hasher, val7 android.Path) error {
		hasher.WriteString(":java.android.Path")
		val8 := val7 == nil
		if val8 {
			hasher.WriteByte(0)
		} else {
			if v := reflect.ValueOf(val7); v.Kind() == reflect.Ptr {
				if v.IsNil() {
					panic(fmt.Errorf("nil pointer is not supported in interface"))
				} else {
					val9 := val7 == nil
					if val9 {
						hasher.WriteByte(0)
					} else {
						val10 := func(hasher *proptools.Hasher) error { return val7.(proptools.CustomHash).CustomHash(hasher) }
						if err := proptools.HashReference(hasher, uintptr(v.Pointer()), val10); err != nil {
							return err
						}
					}
				}
			} else {
				val7.(proptools.CustomHash).CustomHash(hasher)
			}
		}
		return nil
	}
	if err := r.additionalManifests.Hash(hasher, "android.Path", val11); err != nil {
		return err
	}
	hasher.WriteString(":java.android.Path")
	val12 := r.rTxt == nil
	if val12 {
		hasher.WriteByte(0)
	} else {
		if v := reflect.ValueOf(r.rTxt); v.Kind() == reflect.Ptr {
			if v.IsNil() {
				panic(fmt.Errorf("nil pointer is not supported in interface"))
			} else {
				val13 := r.rTxt == nil
				if val13 {
					hasher.WriteByte(0)
				} else {
					val14 := func(hasher *proptools.Hasher) error { return r.rTxt.(proptools.CustomHash).CustomHash(hasher) }
					if err := proptools.HashReference(hasher, uintptr(v.Pointer()), val14); err != nil {
						return err
					}
				}
			}
		} else {
			r.rTxt.(proptools.CustomHash).CustomHash(hasher)
		}
	}
	hasher.WriteString(":java.android.Path")
	val15 := r.rJar == nil
	if val15 {
		hasher.WriteByte(0)
	} else {
		if v := reflect.ValueOf(r.rJar); v.Kind() == reflect.Ptr {
			if v.IsNil() {
				panic(fmt.Errorf("nil pointer is not supported in interface"))
			} else {
				val16 := r.rJar == nil
				if val16 {
					hasher.WriteByte(0)
				} else {
					val17 := func(hasher *proptools.Hasher) error { return r.rJar.(proptools.CustomHash).CustomHash(hasher) }
					if err := proptools.HashReference(hasher, uintptr(v.Pointer()), val17); err != nil {
						return err
					}
				}
			}
		} else {
			r.rJar.(proptools.CustomHash).CustomHash(hasher)
		}
	}
	if err := r.assets.CustomHash(hasher); err != nil {
		return err
	}
	hasher.WriteString(":.bool")
	if r.usedResourceProcessor {
		hasher.WriteByte(1)
	} else {
		hasher.WriteByte(0)
	}
	return nil
}

func (r *resourcesNode) 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.resPackage = nil
	} else {
		r.resPackage = val2.(android.Path)
	}

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

	var val6 bool
	if err = gobtools.DecodeBool(buf, &val6); err != nil {
		return err
	}
	if !val6 {
		tmp, err := gobtools.DecodeReference(ctx, &r.additionalManifests, buf, func(value *uniquelist.UniqueList[android.Path], buf *bytes.Reader) error {
			var val7 []android.Path
			var val8 int
			err = gobtools.DecodeInt(buf, &val8)
			if err != nil {
				return err
			}
			if val8 != -1 {
				val7 = make([]android.Path, val8)
				for val9 := 0; val9 < int(val8); val9++ {
					if val11, err := gobtools.DecodeInterface(ctx, buf); err != nil {
						return err
					} else if val11 == nil {
						val7[val9] = nil
					} else {
						val7[val9] = val11.(android.Path)
					}
				}
			}
			*value = uniquelist.Make(val7)
			return nil
		})
		if err != nil {
			return err
		}
		r.additionalManifests = *tmp
	}

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

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

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

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

	return err
}

var resourcesNodeGobRegId int16

func (r resourcesNode) GetTypeId() int16 {
	return resourcesNodeGobRegId
}

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

func (r AndroidLibraryInfo) CustomHash(hasher *proptools.Hasher) error {
	hasher.WriteString(":java.AndroidLibraryInfo")
	hasher.WriteInt(0)
	return nil
}

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

	return err
}

var AndroidLibraryInfoGobRegId int16

func (r AndroidLibraryInfo) GetTypeId() int16 {
	return AndroidLibraryInfoGobRegId
}

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

func (r AARImportInfo) CustomHash(hasher *proptools.Hasher) error {
	hasher.WriteString(":java.AARImportInfo")
	hasher.WriteInt(0)
	return nil
}

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

	return err
}

var AARImportInfoGobRegId int16

func (r AARImportInfo) GetTypeId() int16 {
	return AARImportInfoGobRegId
}

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

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

func (r JniPackageInfo) CustomHash(hasher *proptools.Hasher) error {
	hasher.WriteString(":java.JniPackageInfo")
	hasher.WriteInt(1)
	hasher.WriteString(":java.android.Paths")
	hasher.WriteString(":.[]Path")
	hasher.WriteInt(len(r.JniPackages))
	for val1 := 0; val1 < len(r.JniPackages); val1++ {
		hasher.WriteString("android/soong/android:android.Path")
		val2 := r.JniPackages[val1] == nil
		if val2 {
			hasher.WriteByte(0)
		} else {
			if v := reflect.ValueOf(r.JniPackages[val1]); v.Kind() == reflect.Ptr {
				if v.IsNil() {
					panic(fmt.Errorf("nil pointer is not supported in interface"))
				} else {
					val3 := r.JniPackages[val1] == nil
					if val3 {
						hasher.WriteByte(0)
					} else {
						val4 := func(hasher *proptools.Hasher) error {
							return r.JniPackages[val1].(proptools.CustomHash).CustomHash(hasher)
						}
						if err := proptools.HashReference(hasher, uintptr(v.Pointer()), val4); err != nil {
							return err
						}
					}
				}
			} else {
				r.JniPackages[val1].(proptools.CustomHash).CustomHash(hasher)
			}
		}
	}
	return nil
}

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

	var val3 int
	err = gobtools.DecodeInt(buf, &val3)
	if err != nil {
		return err
	}
	if val3 != -1 {
		r.JniPackages = 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.JniPackages[val4] = nil
			} else {
				r.JniPackages[val4] = val6.(android.Path)
			}
		}
	}

	return err
}

var JniPackageInfoGobRegId int16

func (r JniPackageInfo) GetTypeId() int16 {
	return JniPackageInfoGobRegId
}

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

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

func (r AARImportDepInSameApexChecker) CustomHash(hasher *proptools.Hasher) error {
	hasher.WriteString(":java.AARImportDepInSameApexChecker")
	hasher.WriteInt(1)
	if err := r.BaseDepInSameApexChecker.CustomHash(hasher); err != nil {
		return err
	}
	return nil
}

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

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

	return err
}

var AARImportDepInSameApexCheckerGobRegId int16

func (r AARImportDepInSameApexChecker) GetTypeId() int16 {
	return AARImportDepInSameApexCheckerGobRegId
}

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

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

func (r AARInfo) CustomHash(hasher *proptools.Hasher) error {
	hasher.WriteString(":java.AARInfo")
	hasher.WriteInt(1)
	hasher.WriteString(":java.android.Path")
	val1 := r.Aar == nil
	if val1 {
		hasher.WriteByte(0)
	} else {
		if v := reflect.ValueOf(r.Aar); v.Kind() == reflect.Ptr {
			if v.IsNil() {
				panic(fmt.Errorf("nil pointer is not supported in interface"))
			} else {
				val2 := r.Aar == nil
				if val2 {
					hasher.WriteByte(0)
				} else {
					val3 := func(hasher *proptools.Hasher) error { return r.Aar.(proptools.CustomHash).CustomHash(hasher) }
					if err := proptools.HashReference(hasher, uintptr(v.Pointer()), val3); err != nil {
						return err
					}
				}
			}
		} else {
			r.Aar.(proptools.CustomHash).CustomHash(hasher)
		}
	}
	return nil
}

func (r *AARInfo) 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.Aar = nil
	} else {
		r.Aar = val2.(android.Path)
	}

	return err
}

var AARInfoGobRegId int16

func (r AARInfo) GetTypeId() int16 {
	return AARInfoGobRegId
}

// end of aar.go

// begin of android_resources.go
func init() {
	rroDirGobRegId = gobtools.RegisterType(func() gobtools.CustomDec { return new(rroDir) })
}

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

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

	if err = gobtools.EncodeInt(buf, int(r.overlayType)); err != nil {
		return err
	}
	return err
}

func (r rroDir) CustomHash(hasher *proptools.Hasher) error {
	hasher.WriteString(":java.rroDir")
	hasher.WriteInt(2)
	hasher.WriteString(":java.android.Path")
	val1 := r.path == nil
	if val1 {
		hasher.WriteByte(0)
	} else {
		if v := reflect.ValueOf(r.path); v.Kind() == reflect.Ptr {
			if v.IsNil() {
				panic(fmt.Errorf("nil pointer is not supported in interface"))
			} else {
				val2 := r.path == nil
				if val2 {
					hasher.WriteByte(0)
				} else {
					val3 := func(hasher *proptools.Hasher) error { return r.path.(proptools.CustomHash).CustomHash(hasher) }
					if err := proptools.HashReference(hasher, uintptr(v.Pointer()), val3); err != nil {
						return err
					}
				}
			}
		} else {
			r.path.(proptools.CustomHash).CustomHash(hasher)
		}
	}
	hasher.WriteString(":java.overlayType")
	hasher.WriteString(":.int")
	hasher.WriteUint64(uint64(int(r.overlayType)))
	return nil
}

func (r *rroDir) 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.path = nil
	} else {
		r.path = val2.(android.Path)
	}

	var val4 int
	err = gobtools.DecodeInt(buf, &val4)
	if err != nil {
		return err
	}
	r.overlayType = overlayType(val4)

	return err
}

var rroDirGobRegId int16

func (r rroDir) GetTypeId() int16 {
	return rroDirGobRegId
}

// end of android_resources.go

// begin of apkcerts.go
func init() {
	ApkCertInfoGobRegId = gobtools.RegisterType(func() gobtools.CustomDec { return new(ApkCertInfo) })
	ApkCertsInfoGobRegId = gobtools.RegisterType(func() gobtools.CustomDec { return new(ApkCertsInfo) })
}

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

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

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

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

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

func (r ApkCertInfo) CustomHash(hasher *proptools.Hasher) error {
	hasher.WriteString(":java.ApkCertInfo")
	hasher.WriteInt(4)
	hasher.WriteString(":java.android.Path")
	val1 := r.ApkCertsFile == nil
	if val1 {
		hasher.WriteByte(0)
	} else {
		if v := reflect.ValueOf(r.ApkCertsFile); v.Kind() == reflect.Ptr {
			if v.IsNil() {
				panic(fmt.Errorf("nil pointer is not supported in interface"))
			} else {
				val2 := r.ApkCertsFile == nil
				if val2 {
					hasher.WriteByte(0)
				} else {
					val3 := func(hasher *proptools.Hasher) error { return r.ApkCertsFile.(proptools.CustomHash).CustomHash(hasher) }
					if err := proptools.HashReference(hasher, uintptr(v.Pointer()), val3); err != nil {
						return err
					}
				}
			}
		} else {
			r.ApkCertsFile.(proptools.CustomHash).CustomHash(hasher)
		}
	}
	if err := r.Certificate.CustomHash(hasher); err != nil {
		return err
	}
	hasher.WriteString(":.string")
	hasher.WriteString(r.Name)
	hasher.WriteString(":.bool")
	if r.Test {
		hasher.WriteByte(1)
	} else {
		hasher.WriteByte(0)
	}
	return nil
}

func (r *ApkCertInfo) 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.ApkCertsFile = nil
	} else {
		r.ApkCertsFile = val2.(android.Path)
	}

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

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

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

	return err
}

var ApkCertInfoGobRegId int16

func (r ApkCertInfo) GetTypeId() int16 {
	return ApkCertInfoGobRegId
}

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

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

func (r ApkCertsInfo) CustomHash(hasher *proptools.Hasher) error {
	hasher.WriteString(":.[]ApkCertInfo")
	hasher.WriteInt(len(r))
	for val1 := 0; val1 < len(r); val1++ {
		if err := r[val1].CustomHash(hasher); err != nil {
			return err
		}
	}
	return nil
}

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

	var val2 int
	err = gobtools.DecodeInt(buf, &val2)
	if err != nil {
		return err
	}
	if val2 != -1 {
		(*r) = make([]ApkCertInfo, val2)
		for val3 := 0; val3 < int(val2); val3++ {
			if err = (*r)[val3].Decode(ctx, buf); err != nil {
				return err
			}
		}
	}

	return err
}

var ApkCertsInfoGobRegId int16

func (r ApkCertsInfo) GetTypeId() int16 {
	return ApkCertsInfoGobRegId
}

// end of apkcerts.go

// begin of app.go
func init() {
	FlagsPackagesGobRegId = gobtools.RegisterType(func() gobtools.CustomDec { return new(FlagsPackages) })
	AppInfoGobRegId = gobtools.RegisterType(func() gobtools.CustomDec { return new(AppInfo) })
	CertificateGobRegId = gobtools.RegisterType(func() gobtools.CustomDec { return new(Certificate) })
	AppDepInSameApexCheckerGobRegId = gobtools.RegisterType(func() gobtools.CustomDec { return new(AppDepInSameApexChecker) })
	AndroidAppCertificateInfoGobRegId = gobtools.RegisterType(func() gobtools.CustomDec { return new(AndroidAppCertificateInfo) })
	BundleInfoGobRegId = gobtools.RegisterType(func() gobtools.CustomDec { return new(BundleInfo) })
}

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

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

func (r FlagsPackages) CustomHash(hasher *proptools.Hasher) error {
	hasher.WriteString(":java.FlagsPackages")
	hasher.WriteInt(1)
	hasher.WriteString(":java.android.Paths")
	hasher.WriteString(":.[]Path")
	hasher.WriteInt(len(r.AconfigTextFiles))
	for val1 := 0; val1 < len(r.AconfigTextFiles); val1++ {
		hasher.WriteString("android/soong/android:android.Path")
		val2 := r.AconfigTextFiles[val1] == nil
		if val2 {
			hasher.WriteByte(0)
		} else {
			if v := reflect.ValueOf(r.AconfigTextFiles[val1]); v.Kind() == reflect.Ptr {
				if v.IsNil() {
					panic(fmt.Errorf("nil pointer is not supported in interface"))
				} else {
					val3 := r.AconfigTextFiles[val1] == nil
					if val3 {
						hasher.WriteByte(0)
					} else {
						val4 := func(hasher *proptools.Hasher) error {
							return r.AconfigTextFiles[val1].(proptools.CustomHash).CustomHash(hasher)
						}
						if err := proptools.HashReference(hasher, uintptr(v.Pointer()), val4); err != nil {
							return err
						}
					}
				}
			} else {
				r.AconfigTextFiles[val1].(proptools.CustomHash).CustomHash(hasher)
			}
		}
	}
	return nil
}

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

	var val3 int
	err = gobtools.DecodeInt(buf, &val3)
	if err != nil {
		return err
	}
	if val3 != -1 {
		r.AconfigTextFiles = 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.AconfigTextFiles[val4] = nil
			} else {
				r.AconfigTextFiles[val4] = val6.(android.Path)
			}
		}
	}

	return err
}

var FlagsPackagesGobRegId int16

func (r FlagsPackages) GetTypeId() int16 {
	return FlagsPackagesGobRegId
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

func (r AppInfo) CustomHash(hasher *proptools.Hasher) error {
	hasher.WriteString(":java.AppInfo")
	hasher.WriteInt(18)
	hasher.WriteString(":.bool")
	if r.Updatable {
		hasher.WriteByte(1)
	} else {
		hasher.WriteByte(0)
	}
	hasher.WriteString(":.bool")
	if r.TestHelperApp {
		hasher.WriteByte(1)
	} else {
		hasher.WriteByte(0)
	}
	hasher.WriteString(":java.android.Paths")
	hasher.WriteString(":.[]Path")
	hasher.WriteInt(len(r.EmbeddedJNILibs))
	for val1 := 0; val1 < len(r.EmbeddedJNILibs); val1++ {
		hasher.WriteString("android/soong/android:android.Path")
		val2 := r.EmbeddedJNILibs[val1] == nil
		if val2 {
			hasher.WriteByte(0)
		} else {
			if v := reflect.ValueOf(r.EmbeddedJNILibs[val1]); v.Kind() == reflect.Ptr {
				if v.IsNil() {
					panic(fmt.Errorf("nil pointer is not supported in interface"))
				} else {
					val3 := r.EmbeddedJNILibs[val1] == nil
					if val3 {
						hasher.WriteByte(0)
					} else {
						val4 := func(hasher *proptools.Hasher) error {
							return r.EmbeddedJNILibs[val1].(proptools.CustomHash).CustomHash(hasher)
						}
						if err := proptools.HashReference(hasher, uintptr(v.Pointer()), val4); err != nil {
							return err
						}
					}
				}
			} else {
				r.EmbeddedJNILibs[val1].(proptools.CustomHash).CustomHash(hasher)
			}
		}
	}
	hasher.WriteString(":java.android.Path")
	val5 := r.MergedManifestFile == nil
	if val5 {
		hasher.WriteByte(0)
	} else {
		if v := reflect.ValueOf(r.MergedManifestFile); v.Kind() == reflect.Ptr {
			if v.IsNil() {
				panic(fmt.Errorf("nil pointer is not supported in interface"))
			} else {
				val6 := r.MergedManifestFile == nil
				if val6 {
					hasher.WriteByte(0)
				} else {
					val7 := func(hasher *proptools.Hasher) error {
						return r.MergedManifestFile.(proptools.CustomHash).CustomHash(hasher)
					}
					if err := proptools.HashReference(hasher, uintptr(v.Pointer()), val7); err != nil {
						return err
					}
				}
			}
		} else {
			r.MergedManifestFile.(proptools.CustomHash).CustomHash(hasher)
		}
	}
	hasher.WriteString(":.bool")
	if r.Prebuilt {
		hasher.WriteByte(1)
	} else {
		hasher.WriteByte(0)
	}
	hasher.WriteString(":.bool")
	if r.AppSet {
		hasher.WriteByte(1)
	} else {
		hasher.WriteByte(0)
	}
	hasher.WriteString(":.bool")
	if r.Privileged {
		hasher.WriteByte(1)
	} else {
		hasher.WriteByte(0)
	}
	hasher.WriteString(":java.android.Path")
	val8 := r.OutputFile == nil
	if val8 {
		hasher.WriteByte(0)
	} else {
		if v := reflect.ValueOf(r.OutputFile); v.Kind() == reflect.Ptr {
			if v.IsNil() {
				panic(fmt.Errorf("nil pointer is not supported in interface"))
			} else {
				val9 := r.OutputFile == nil
				if val9 {
					hasher.WriteByte(0)
				} else {
					val10 := func(hasher *proptools.Hasher) error { return r.OutputFile.(proptools.CustomHash).CustomHash(hasher) }
					if err := proptools.HashReference(hasher, uintptr(v.Pointer()), val10); err != nil {
						return err
					}
				}
			}
		} else {
			r.OutputFile.(proptools.CustomHash).CustomHash(hasher)
		}
	}
	hasher.WriteString(":.string")
	hasher.WriteString(r.InstallApkName)
	if err := r.JacocoInfo.CustomHash(hasher); err != nil {
		return err
	}
	if err := r.Certificate.CustomHash(hasher); err != nil {
		return err
	}
	if err := r.PrivAppAllowlist.CustomHash(hasher); err != nil {
		return err
	}
	if err := r.PreinstallAllowlist.CustomHash(hasher); err != nil {
		return err
	}
	hasher.WriteString(":.*string")
	val11 := r.OverriddenManifestPackageName == nil
	if val11 {
		hasher.WriteByte(0)
	} else {
		val12 := func(hasher *proptools.Hasher) error {
			hasher.WriteString(":.string")
			hasher.WriteString((*r.OverriddenManifestPackageName))
			return nil
		}
		if err := proptools.HashReference(hasher, uintptr(unsafe.Pointer(r.OverriddenManifestPackageName)), val12); err != nil {
			return err
		}
	}
	hasher.WriteString(":java.android.Path")
	val13 := r.ApkCertsFile == nil
	if val13 {
		hasher.WriteByte(0)
	} else {
		if v := reflect.ValueOf(r.ApkCertsFile); v.Kind() == reflect.Ptr {
			if v.IsNil() {
				panic(fmt.Errorf("nil pointer is not supported in interface"))
			} else {
				val14 := r.ApkCertsFile == nil
				if val14 {
					hasher.WriteByte(0)
				} else {
					val15 := func(hasher *proptools.Hasher) error { return r.ApkCertsFile.(proptools.CustomHash).CustomHash(hasher) }
					if err := proptools.HashReference(hasher, uintptr(v.Pointer()), val15); err != nil {
						return err
					}
				}
			}
		} else {
			r.ApkCertsFile.(proptools.CustomHash).CustomHash(hasher)
		}
	}
	hasher.WriteString(":.[]jniLib")
	hasher.WriteInt(len(r.JniLibs))
	for val16 := 0; val16 < len(r.JniLibs); val16++ {
		if err := r.JniLibs[val16].CustomHash(hasher); err != nil {
			return err
		}
	}
	hasher.WriteString(":java.android.Paths")
	hasher.WriteString(":.[]Path")
	hasher.WriteInt(len(r.JniCoverageOutputs))
	for val17 := 0; val17 < len(r.JniCoverageOutputs); val17++ {
		hasher.WriteString("android/soong/android:android.Path")
		val18 := r.JniCoverageOutputs[val17] == nil
		if val18 {
			hasher.WriteByte(0)
		} else {
			if v := reflect.ValueOf(r.JniCoverageOutputs[val17]); v.Kind() == reflect.Ptr {
				if v.IsNil() {
					panic(fmt.Errorf("nil pointer is not supported in interface"))
				} else {
					val19 := r.JniCoverageOutputs[val17] == nil
					if val19 {
						hasher.WriteByte(0)
					} else {
						val20 := func(hasher *proptools.Hasher) error {
							return r.JniCoverageOutputs[val17].(proptools.CustomHash).CustomHash(hasher)
						}
						if err := proptools.HashReference(hasher, uintptr(v.Pointer()), val20); err != nil {
							return err
						}
					}
				}
			} else {
				r.JniCoverageOutputs[val17].(proptools.CustomHash).CustomHash(hasher)
			}
		}
	}
	hasher.WriteString(":java.android.Path")
	val21 := r.PackedAdditionalOutputs == nil
	if val21 {
		hasher.WriteByte(0)
	} else {
		if v := reflect.ValueOf(r.PackedAdditionalOutputs); v.Kind() == reflect.Ptr {
			if v.IsNil() {
				panic(fmt.Errorf("nil pointer is not supported in interface"))
			} else {
				val22 := r.PackedAdditionalOutputs == nil
				if val22 {
					hasher.WriteByte(0)
				} else {
					val23 := func(hasher *proptools.Hasher) error {
						return r.PackedAdditionalOutputs.(proptools.CustomHash).CustomHash(hasher)
					}
					if err := proptools.HashReference(hasher, uintptr(v.Pointer()), val23); err != nil {
						return err
					}
				}
			}
		} else {
			r.PackedAdditionalOutputs.(proptools.CustomHash).CustomHash(hasher)
		}
	}
	return nil
}

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

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

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

	var val5 int
	err = gobtools.DecodeInt(buf, &val5)
	if err != nil {
		return err
	}
	if val5 != -1 {
		r.EmbeddedJNILibs = 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.EmbeddedJNILibs[val6] = nil
			} else {
				r.EmbeddedJNILibs[val6] = val8.(android.Path)
			}
		}
	}

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

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

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

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

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

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

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

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

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

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

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

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

	var val27 int
	err = gobtools.DecodeInt(buf, &val27)
	if err != nil {
		return err
	}
	if val27 != -1 {
		r.JniLibs = make([]jniLib, val27)
		for val28 := 0; val28 < int(val27); val28++ {
			if err = r.JniLibs[val28].Decode(ctx, buf); err != nil {
				return err
			}
		}
	}

	var val32 int
	err = gobtools.DecodeInt(buf, &val32)
	if err != nil {
		return err
	}
	if val32 != -1 {
		r.JniCoverageOutputs = make([]android.Path, val32)
		for val33 := 0; val33 < int(val32); val33++ {
			if val35, err := gobtools.DecodeInterface(ctx, buf); err != nil {
				return err
			} else if val35 == nil {
				r.JniCoverageOutputs[val33] = nil
			} else {
				r.JniCoverageOutputs[val33] = val35.(android.Path)
			}
		}
	}

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

	return err
}

var AppInfoGobRegId int16

func (r AppInfo) GetTypeId() int16 {
	return AppInfoGobRegId
}

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

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

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

func (r Certificate) CustomHash(hasher *proptools.Hasher) error {
	hasher.WriteString(":java.Certificate")
	hasher.WriteInt(3)
	hasher.WriteString(":java.android.Path")
	val1 := r.Pem == nil
	if val1 {
		hasher.WriteByte(0)
	} else {
		if v := reflect.ValueOf(r.Pem); v.Kind() == reflect.Ptr {
			if v.IsNil() {
				panic(fmt.Errorf("nil pointer is not supported in interface"))
			} else {
				val2 := r.Pem == nil
				if val2 {
					hasher.WriteByte(0)
				} else {
					val3 := func(hasher *proptools.Hasher) error { return r.Pem.(proptools.CustomHash).CustomHash(hasher) }
					if err := proptools.HashReference(hasher, uintptr(v.Pointer()), val3); err != nil {
						return err
					}
				}
			}
		} else {
			r.Pem.(proptools.CustomHash).CustomHash(hasher)
		}
	}
	hasher.WriteString(":java.android.Path")
	val4 := r.Key == nil
	if val4 {
		hasher.WriteByte(0)
	} else {
		if v := reflect.ValueOf(r.Key); v.Kind() == reflect.Ptr {
			if v.IsNil() {
				panic(fmt.Errorf("nil pointer is not supported in interface"))
			} else {
				val5 := r.Key == nil
				if val5 {
					hasher.WriteByte(0)
				} else {
					val6 := func(hasher *proptools.Hasher) error { return r.Key.(proptools.CustomHash).CustomHash(hasher) }
					if err := proptools.HashReference(hasher, uintptr(v.Pointer()), val6); err != nil {
						return err
					}
				}
			}
		} else {
			r.Key.(proptools.CustomHash).CustomHash(hasher)
		}
	}
	hasher.WriteString(":.bool")
	if r.presigned {
		hasher.WriteByte(1)
	} else {
		hasher.WriteByte(0)
	}
	return nil
}

func (r *Certificate) 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.Pem = nil
	} else {
		r.Pem = val2.(android.Path)
	}
	if val4, err := gobtools.DecodeInterface(ctx, buf); err != nil {
		return err
	} else if val4 == nil {
		r.Key = nil
	} else {
		r.Key = val4.(android.Path)
	}

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

	return err
}

var CertificateGobRegId int16

func (r Certificate) GetTypeId() int16 {
	return CertificateGobRegId
}

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

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

func (r AppDepInSameApexChecker) CustomHash(hasher *proptools.Hasher) error {
	hasher.WriteString(":java.AppDepInSameApexChecker")
	hasher.WriteInt(1)
	if err := r.BaseDepInSameApexChecker.CustomHash(hasher); err != nil {
		return err
	}
	return nil
}

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

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

	return err
}

var AppDepInSameApexCheckerGobRegId int16

func (r AppDepInSameApexChecker) GetTypeId() int16 {
	return AppDepInSameApexCheckerGobRegId
}

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

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

func (r AndroidAppCertificateInfo) CustomHash(hasher *proptools.Hasher) error {
	hasher.WriteString(":java.AndroidAppCertificateInfo")
	hasher.WriteInt(1)
	if err := r.Certificate.CustomHash(hasher); err != nil {
		return err
	}
	return nil
}

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

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

	return err
}

var AndroidAppCertificateInfoGobRegId int16

func (r AndroidAppCertificateInfo) GetTypeId() int16 {
	return AndroidAppCertificateInfoGobRegId
}

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

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

func (r BundleInfo) CustomHash(hasher *proptools.Hasher) error {
	hasher.WriteString(":java.BundleInfo")
	hasher.WriteInt(1)
	hasher.WriteString(":java.android.Path")
	val1 := r.Bundle == nil
	if val1 {
		hasher.WriteByte(0)
	} else {
		if v := reflect.ValueOf(r.Bundle); v.Kind() == reflect.Ptr {
			if v.IsNil() {
				panic(fmt.Errorf("nil pointer is not supported in interface"))
			} else {
				val2 := r.Bundle == nil
				if val2 {
					hasher.WriteByte(0)
				} else {
					val3 := func(hasher *proptools.Hasher) error { return r.Bundle.(proptools.CustomHash).CustomHash(hasher) }
					if err := proptools.HashReference(hasher, uintptr(v.Pointer()), val3); err != nil {
						return err
					}
				}
			}
		} else {
			r.Bundle.(proptools.CustomHash).CustomHash(hasher)
		}
	}
	return nil
}

func (r *BundleInfo) 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.Bundle = nil
	} else {
		r.Bundle = val2.(android.Path)
	}

	return err
}

var BundleInfoGobRegId int16

func (r BundleInfo) GetTypeId() int16 {
	return BundleInfoGobRegId
}

// end of app.go

// begin of app_import.go
func init() {
	AppImportDepInSameApexCheckerGobRegId = gobtools.RegisterType(func() gobtools.CustomDec { return new(AppImportDepInSameApexChecker) })
}

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

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

func (r AppImportDepInSameApexChecker) CustomHash(hasher *proptools.Hasher) error {
	hasher.WriteString(":java.AppImportDepInSameApexChecker")
	hasher.WriteInt(1)
	if err := r.BaseDepInSameApexChecker.CustomHash(hasher); err != nil {
		return err
	}
	return nil
}

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

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

	return err
}

var AppImportDepInSameApexCheckerGobRegId int16

func (r AppImportDepInSameApexChecker) GetTypeId() int16 {
	return AppImportDepInSameApexCheckerGobRegId
}

// end of app_import.go

// begin of base.go
func init() {
	OptionalDexJarPathGobRegId = gobtools.RegisterType(func() gobtools.CustomDec { return new(OptionalDexJarPath) })
	JavaDepInSameApexCheckerGobRegId = gobtools.RegisterType(func() gobtools.CustomDec { return new(JavaDepInSameApexChecker) })
	JarJarProviderDataGobRegId = gobtools.RegisterType(func() gobtools.CustomDec { return new(JarJarProviderData) })
}

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

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

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

func (r OptionalDexJarPath) CustomHash(hasher *proptools.Hasher) error {
	hasher.WriteString(":java.OptionalDexJarPath")
	hasher.WriteInt(2)
	hasher.WriteString(":.bool")
	if r.isSet {
		hasher.WriteByte(1)
	} else {
		hasher.WriteByte(0)
	}
	if err := r.path.CustomHash(hasher); err != nil {
		return err
	}
	return nil
}

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

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

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

	return err
}

var OptionalDexJarPathGobRegId int16

func (r OptionalDexJarPath) GetTypeId() int16 {
	return OptionalDexJarPathGobRegId
}

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

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

func (r JavaDepInSameApexChecker) CustomHash(hasher *proptools.Hasher) error {
	hasher.WriteString(":java.JavaDepInSameApexChecker")
	hasher.WriteInt(1)
	if err := r.BaseDepInSameApexChecker.CustomHash(hasher); err != nil {
		return err
	}
	return nil
}

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

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

	return err
}

var JavaDepInSameApexCheckerGobRegId int16

func (r JavaDepInSameApexChecker) GetTypeId() int16 {
	return JavaDepInSameApexCheckerGobRegId
}

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

	if r.Rename == nil {
		if err = gobtools.EncodeInt(buf, -1); err != nil {
			return err
		}
	} else {
		if err = gobtools.EncodeInt(buf, len(r.Rename)); err != nil {
			return err
		}
		for val1, val2 := range r.Rename {
			if err = gobtools.EncodeString(buf, val1); err != nil {
				return err
			}
			if err = gobtools.EncodeString(buf, val2); err != nil {
				return err
			}
		}
	}
	return err
}

func (r JarJarProviderData) CustomHash(hasher *proptools.Hasher) error {
	hasher.WriteString(":java.JarJarProviderData")
	hasher.WriteInt(1)
	hasher.WriteString(":java.android.JarJarRename")
	hasher.WriteString(":.map[string]string")
	hasher.WriteInt(len(r.Rename))
	val1 := make([]string, 0, len(r.Rename))
	for val3 := range r.Rename {
		val1 = append(val1, val3)
	}
	proptools.SortOrdered(val1)
	for _, val2 := range val1 {
		hasher.WriteString(":.string")
		hasher.WriteString(val2)
		hasher.WriteString(":.string")
		hasher.WriteString(r.Rename[val2])
	}
	return nil
}

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

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

	return err
}

var JarJarProviderDataGobRegId int16

func (r JarJarProviderData) GetTypeId() int16 {
	return JarJarProviderDataGobRegId
}

// end of base.go

// begin of bootclasspath.go
func init() {
	ApexVariantReferenceGobRegId = gobtools.RegisterType(func() gobtools.CustomDec { return new(ApexVariantReference) })
}

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

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

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

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

func (r ApexVariantReference) CustomHash(hasher *proptools.Hasher) error {
	hasher.WriteString(":java.ApexVariantReference")
	hasher.WriteInt(3)
	if err := r.BpPrintableBase.CustomHash(hasher); err != nil {
		return err
	}
	hasher.WriteString(":.*string")
	val1 := r.Apex == nil
	if val1 {
		hasher.WriteByte(0)
	} else {
		val2 := func(hasher *proptools.Hasher) error {
			hasher.WriteString(":.string")
			hasher.WriteString((*r.Apex))
			return nil
		}
		if err := proptools.HashReference(hasher, uintptr(unsafe.Pointer(r.Apex)), val2); err != nil {
			return err
		}
	}
	hasher.WriteString(":.*string")
	val3 := r.Module == nil
	if val3 {
		hasher.WriteByte(0)
	} else {
		val4 := func(hasher *proptools.Hasher) error {
			hasher.WriteString(":.string")
			hasher.WriteString((*r.Module))
			return nil
		}
		if err := proptools.HashReference(hasher, uintptr(unsafe.Pointer(r.Module)), val4); err != nil {
			return err
		}
	}
	return nil
}

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

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

	var val3 bool
	if err = gobtools.DecodeBool(buf, &val3); err != nil {
		return err
	}
	if !val3 {
		var val2 string
		err = gobtools.DecodeString(buf, &val2)
		if err != nil {
			return err
		}
		r.Apex = &val2
	}

	var val6 bool
	if err = gobtools.DecodeBool(buf, &val6); err != nil {
		return err
	}
	if !val6 {
		var val5 string
		err = gobtools.DecodeString(buf, &val5)
		if err != nil {
			return err
		}
		r.Module = &val5
	}

	return err
}

var ApexVariantReferenceGobRegId int16

func (r ApexVariantReference) GetTypeId() int16 {
	return ApexVariantReferenceGobRegId
}

// end of bootclasspath.go

// begin of bootclasspath_fragment.go
func init() {
	BootclasspathFragmentInfoGobRegId = gobtools.RegisterType(func() gobtools.CustomDec { return new(BootclasspathFragmentInfo) })
	BootclasspathFragmentApexContentInfoGobRegId = gobtools.RegisterType(func() gobtools.CustomDec { return new(BootclasspathFragmentApexContentInfo) })
	BootclasspathFragmentDepInSameApexCheckerGobRegId = gobtools.RegisterType(func() gobtools.CustomDec { return new(BootclasspathFragmentDepInSameApexChecker) })
	ClasspathFragmentValidationInfoGobRegId = gobtools.RegisterType(func() gobtools.CustomDec { return new(ClasspathFragmentValidationInfo) })
}

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

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

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

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

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

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

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

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

func (r BootclasspathFragmentInfo) CustomHash(hasher *proptools.Hasher) error {
	hasher.WriteString(":java.BootclasspathFragmentInfo")
	hasher.WriteInt(7)
	hasher.WriteString(":.*string")
	val1 := r.ImageName == nil
	if val1 {
		hasher.WriteByte(0)
	} else {
		val2 := func(hasher *proptools.Hasher) error {
			hasher.WriteString(":.string")
			hasher.WriteString((*r.ImageName))
			return nil
		}
		if err := proptools.HashReference(hasher, uintptr(unsafe.Pointer(r.ImageName)), val2); err != nil {
			return err
		}
	}
	hasher.WriteString(":.[]string")
	hasher.WriteInt(len(r.Contents))
	for val3 := 0; val3 < len(r.Contents); val3++ {
		hasher.WriteString(":.string")
		hasher.WriteString(r.Contents[val3])
	}
	hasher.WriteString(":.[]string")
	hasher.WriteInt(len(r.ApiStubLibs))
	for val4 := 0; val4 < len(r.ApiStubLibs); val4++ {
		hasher.WriteString(":.string")
		hasher.WriteString(r.ApiStubLibs[val4])
	}
	hasher.WriteString(":.[]string")
	hasher.WriteInt(len(r.CorePlatformApiStubLibs))
	for val5 := 0; val5 < len(r.CorePlatformApiStubLibs); val5++ {
		hasher.WriteString(":.string")
		hasher.WriteString(r.CorePlatformApiStubLibs[val5])
	}
	hasher.WriteString(":.[]ApexVariantReference")
	hasher.WriteInt(len(r.Fragments))
	for val6 := 0; val6 < len(r.Fragments); val6++ {
		if err := r.Fragments[val6].CustomHash(hasher); err != nil {
			return err
		}
	}
	hasher.WriteString(":java.android.Path")
	val7 := r.ProfilePathOnHost == nil
	if val7 {
		hasher.WriteByte(0)
	} else {
		if v := reflect.ValueOf(r.ProfilePathOnHost); v.Kind() == reflect.Ptr {
			if v.IsNil() {
				panic(fmt.Errorf("nil pointer is not supported in interface"))
			} else {
				val8 := r.ProfilePathOnHost == nil
				if val8 {
					hasher.WriteByte(0)
				} else {
					val9 := func(hasher *proptools.Hasher) error {
						return r.ProfilePathOnHost.(proptools.CustomHash).CustomHash(hasher)
					}
					if err := proptools.HashReference(hasher, uintptr(v.Pointer()), val9); err != nil {
						return err
					}
				}
			}
		} else {
			r.ProfilePathOnHost.(proptools.CustomHash).CustomHash(hasher)
		}
	}
	hasher.WriteString(":.bool")
	if r.DexPreoptProfileGuided {
		hasher.WriteByte(1)
	} else {
		hasher.WriteByte(0)
	}
	return nil
}

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

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

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

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

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

	var val17 int
	err = gobtools.DecodeInt(buf, &val17)
	if err != nil {
		return err
	}
	if val17 != -1 {
		r.Fragments = make([]ApexVariantReference, val17)
		for val18 := 0; val18 < int(val17); val18++ {
			if err = r.Fragments[val18].Decode(ctx, buf); err != nil {
				return err
			}
		}
	}

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

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

	return err
}

var BootclasspathFragmentInfoGobRegId int16

func (r BootclasspathFragmentInfo) GetTypeId() int16 {
	return BootclasspathFragmentInfoGobRegId
}

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

	if r.contentModuleDexJarPaths == nil {
		if err = gobtools.EncodeInt(buf, -1); err != nil {
			return err
		}
	} else {
		if err = gobtools.EncodeInt(buf, len(r.contentModuleDexJarPaths)); err != nil {
			return err
		}
		for val1, val2 := range r.contentModuleDexJarPaths {
			if err = gobtools.EncodeString(buf, val1); err != nil {
				return err
			}
			if err = gobtools.EncodeInterface(ctx, buf, val2); err != nil {
				return err
			}
		}
	}

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

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

func (r BootclasspathFragmentApexContentInfo) CustomHash(hasher *proptools.Hasher) error {
	hasher.WriteString(":java.BootclasspathFragmentApexContentInfo")
	hasher.WriteInt(3)
	hasher.WriteString(":java.bootDexJarByModule")
	hasher.WriteString(":.map[string]android.Path")
	hasher.WriteInt(len(r.contentModuleDexJarPaths))
	val1 := make([]string, 0, len(r.contentModuleDexJarPaths))
	for val3 := range r.contentModuleDexJarPaths {
		val1 = append(val1, val3)
	}
	proptools.SortOrdered(val1)
	for _, val2 := range val1 {
		hasher.WriteString(":.string")
		hasher.WriteString(val2)
		hasher.WriteString(":java.android.Path")
		val4 := r.contentModuleDexJarPaths[val2] == nil
		if val4 {
			hasher.WriteByte(0)
		} else {
			if v := reflect.ValueOf(r.contentModuleDexJarPaths[val2]); v.Kind() == reflect.Ptr {
				if v.IsNil() {
					panic(fmt.Errorf("nil pointer is not supported in interface"))
				} else {
					val5 := r.contentModuleDexJarPaths[val2] == nil
					if val5 {
						hasher.WriteByte(0)
					} else {
						val6 := func(hasher *proptools.Hasher) error {
							return r.contentModuleDexJarPaths[val2].(proptools.CustomHash).CustomHash(hasher)
						}
						if err := proptools.HashReference(hasher, uintptr(v.Pointer()), val6); err != nil {
							return err
						}
					}
				}
			} else {
				r.contentModuleDexJarPaths[val2].(proptools.CustomHash).CustomHash(hasher)
			}
		}
	}
	hasher.WriteString(":java.android.Path")
	val7 := r.profilePathOnHost == nil
	if val7 {
		hasher.WriteByte(0)
	} else {
		if v := reflect.ValueOf(r.profilePathOnHost); v.Kind() == reflect.Ptr {
			if v.IsNil() {
				panic(fmt.Errorf("nil pointer is not supported in interface"))
			} else {
				val8 := r.profilePathOnHost == nil
				if val8 {
					hasher.WriteByte(0)
				} else {
					val9 := func(hasher *proptools.Hasher) error {
						return r.profilePathOnHost.(proptools.CustomHash).CustomHash(hasher)
					}
					if err := proptools.HashReference(hasher, uintptr(v.Pointer()), val9); err != nil {
						return err
					}
				}
			}
		} else {
			r.profilePathOnHost.(proptools.CustomHash).CustomHash(hasher)
		}
	}
	hasher.WriteString(":.string")
	hasher.WriteString(r.profileInstallPathInApex)
	return nil
}

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

	var val2 int
	err = gobtools.DecodeInt(buf, &val2)
	if err != nil {
		return err
	}
	if val2 != -1 {
		r.contentModuleDexJarPaths = make(map[string]android.Path, val2)
		for val3 := 0; val3 < int(val2); val3++ {
			var val4 string
			var val5 android.Path
			err = gobtools.DecodeString(buf, &val4)
			if err != nil {
				return err
			}
			if val8, err := gobtools.DecodeInterface(ctx, buf); err != nil {
				return err
			} else if val8 == nil {
				val5 = nil
			} else {
				val5 = val8.(android.Path)
			}
			r.contentModuleDexJarPaths[val4] = val5
		}
	}

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

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

	return err
}

var BootclasspathFragmentApexContentInfoGobRegId int16

func (r BootclasspathFragmentApexContentInfo) GetTypeId() int16 {
	return BootclasspathFragmentApexContentInfoGobRegId
}

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

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

func (r BootclasspathFragmentDepInSameApexChecker) CustomHash(hasher *proptools.Hasher) error {
	hasher.WriteString(":java.BootclasspathFragmentDepInSameApexChecker")
	hasher.WriteInt(1)
	if err := r.BaseDepInSameApexChecker.CustomHash(hasher); err != nil {
		return err
	}
	return nil
}

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

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

	return err
}

var BootclasspathFragmentDepInSameApexCheckerGobRegId int16

func (r BootclasspathFragmentDepInSameApexChecker) GetTypeId() int16 {
	return BootclasspathFragmentDepInSameApexCheckerGobRegId
}

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

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

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

func (r ClasspathFragmentValidationInfo) CustomHash(hasher *proptools.Hasher) error {
	hasher.WriteString(":java.ClasspathFragmentValidationInfo")
	hasher.WriteInt(2)
	hasher.WriteString(":.string")
	hasher.WriteString(r.ClasspathFragmentModuleName)
	hasher.WriteString(":.[]string")
	hasher.WriteInt(len(r.UnknownJars))
	for val1 := 0; val1 < len(r.UnknownJars); val1++ {
		hasher.WriteString(":.string")
		hasher.WriteString(r.UnknownJars[val1])
	}
	return nil
}

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

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

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

	return err
}

var ClasspathFragmentValidationInfoGobRegId int16

func (r ClasspathFragmentValidationInfo) GetTypeId() int16 {
	return ClasspathFragmentValidationInfoGobRegId
}

// end of bootclasspath_fragment.go

// begin of classpath_fragment.go
func init() {
	ClasspathFragmentProtoContentInfoGobRegId = gobtools.RegisterType(func() gobtools.CustomDec { return new(ClasspathFragmentProtoContentInfo) })
}

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

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

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

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

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

func (r ClasspathFragmentProtoContentInfo) CustomHash(hasher *proptools.Hasher) error {
	hasher.WriteString(":java.ClasspathFragmentProtoContentInfo")
	hasher.WriteInt(4)
	hasher.WriteString(":.bool")
	if r.ClasspathFragmentProtoGenerated {
		hasher.WriteByte(1)
	} else {
		hasher.WriteByte(0)
	}
	if err := r.ClasspathFragmentProtoContents.CustomHash(hasher); err != nil {
		return err
	}
	if err := r.ClasspathFragmentProtoOutput.CustomHash(hasher); err != nil {
		return err
	}
	if err := r.ClasspathFragmentProtoInstallDir.CustomHash(hasher); err != nil {
		return err
	}
	return nil
}

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

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

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

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

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

	return err
}

var ClasspathFragmentProtoContentInfoGobRegId int16

func (r ClasspathFragmentProtoContentInfo) GetTypeId() int16 {
	return ClasspathFragmentProtoContentInfoGobRegId
}

// end of classpath_fragment.go

// begin of dex.go
func init() {
	ProguardInfoGobRegId = gobtools.RegisterType(func() gobtools.CustomDec { return new(ProguardInfo) })
	ProguardInfosGobRegId = gobtools.RegisterType(func() gobtools.CustomDec { return new(ProguardInfos) })
}

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

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

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

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

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

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

func (r ProguardInfo) CustomHash(hasher *proptools.Hasher) error {
	hasher.WriteString(":java.ProguardInfo")
	hasher.WriteInt(5)
	hasher.WriteString(":.string")
	hasher.WriteString(r.ModuleName)
	hasher.WriteString(":.string")
	hasher.WriteString(r.Class)
	hasher.WriteString(":java.android.Path")
	val1 := r.ProguardDictionary == nil
	if val1 {
		hasher.WriteByte(0)
	} else {
		if v := reflect.ValueOf(r.ProguardDictionary); v.Kind() == reflect.Ptr {
			if v.IsNil() {
				panic(fmt.Errorf("nil pointer is not supported in interface"))
			} else {
				val2 := r.ProguardDictionary == nil
				if val2 {
					hasher.WriteByte(0)
				} else {
					val3 := func(hasher *proptools.Hasher) error {
						return r.ProguardDictionary.(proptools.CustomHash).CustomHash(hasher)
					}
					if err := proptools.HashReference(hasher, uintptr(v.Pointer()), val3); err != nil {
						return err
					}
				}
			}
		} else {
			r.ProguardDictionary.(proptools.CustomHash).CustomHash(hasher)
		}
	}
	hasher.WriteString(":java.android.Path")
	val4 := r.ProguardUsageZip == nil
	if val4 {
		hasher.WriteByte(0)
	} else {
		if v := reflect.ValueOf(r.ProguardUsageZip); v.Kind() == reflect.Ptr {
			if v.IsNil() {
				panic(fmt.Errorf("nil pointer is not supported in interface"))
			} else {
				val5 := r.ProguardUsageZip == nil
				if val5 {
					hasher.WriteByte(0)
				} else {
					val6 := func(hasher *proptools.Hasher) error {
						return r.ProguardUsageZip.(proptools.CustomHash).CustomHash(hasher)
					}
					if err := proptools.HashReference(hasher, uintptr(v.Pointer()), val6); err != nil {
						return err
					}
				}
			}
		} else {
			r.ProguardUsageZip.(proptools.CustomHash).CustomHash(hasher)
		}
	}
	hasher.WriteString(":java.android.Path")
	val7 := r.ClassesJar == nil
	if val7 {
		hasher.WriteByte(0)
	} else {
		if v := reflect.ValueOf(r.ClassesJar); v.Kind() == reflect.Ptr {
			if v.IsNil() {
				panic(fmt.Errorf("nil pointer is not supported in interface"))
			} else {
				val8 := r.ClassesJar == nil
				if val8 {
					hasher.WriteByte(0)
				} else {
					val9 := func(hasher *proptools.Hasher) error { return r.ClassesJar.(proptools.CustomHash).CustomHash(hasher) }
					if err := proptools.HashReference(hasher, uintptr(v.Pointer()), val9); err != nil {
						return err
					}
				}
			}
		} else {
			r.ClassesJar.(proptools.CustomHash).CustomHash(hasher)
		}
	}
	return nil
}

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

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

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

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

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

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

	return err
}

var ProguardInfoGobRegId int16

func (r ProguardInfo) GetTypeId() int16 {
	return ProguardInfoGobRegId
}

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

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

func (r ProguardInfos) CustomHash(hasher *proptools.Hasher) error {
	hasher.WriteString(":.[]ProguardInfo")
	hasher.WriteInt(len(r))
	for val1 := 0; val1 < len(r); val1++ {
		if err := r[val1].CustomHash(hasher); err != nil {
			return err
		}
	}
	return nil
}

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

	var val2 int
	err = gobtools.DecodeInt(buf, &val2)
	if err != nil {
		return err
	}
	if val2 != -1 {
		(*r) = make([]ProguardInfo, val2)
		for val3 := 0; val3 < int(val2); val3++ {
			if err = (*r)[val3].Decode(ctx, buf); err != nil {
				return err
			}
		}
	}

	return err
}

var ProguardInfosGobRegId int16

func (r ProguardInfos) GetTypeId() int16 {
	return ProguardInfosGobRegId
}

// end of dex.go

// begin of dexpreopt.go
func init() {
	DexpreopterInstallGobRegId = gobtools.RegisterType(func() gobtools.CustomDec { return new(DexpreopterInstall) })
}

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

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

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

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

func (r DexpreopterInstall) CustomHash(hasher *proptools.Hasher) error {
	hasher.WriteString(":java.DexpreopterInstall")
	hasher.WriteInt(3)
	hasher.WriteString(":java.android.Path")
	val1 := r.OutputPathOnHost == nil
	if val1 {
		hasher.WriteByte(0)
	} else {
		if v := reflect.ValueOf(r.OutputPathOnHost); v.Kind() == reflect.Ptr {
			if v.IsNil() {
				panic(fmt.Errorf("nil pointer is not supported in interface"))
			} else {
				val2 := r.OutputPathOnHost == nil
				if val2 {
					hasher.WriteByte(0)
				} else {
					val3 := func(hasher *proptools.Hasher) error {
						return r.OutputPathOnHost.(proptools.CustomHash).CustomHash(hasher)
					}
					if err := proptools.HashReference(hasher, uintptr(v.Pointer()), val3); err != nil {
						return err
					}
				}
			}
		} else {
			r.OutputPathOnHost.(proptools.CustomHash).CustomHash(hasher)
		}
	}
	if err := r.InstallDirOnDevice.CustomHash(hasher); err != nil {
		return err
	}
	hasher.WriteString(":.string")
	hasher.WriteString(r.InstallFileOnDevice)
	return nil
}

func (r *DexpreopterInstall) 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.OutputPathOnHost = nil
	} else {
		r.OutputPathOnHost = val2.(android.Path)
	}

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

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

	return err
}

var DexpreopterInstallGobRegId int16

func (r DexpreopterInstall) GetTypeId() int16 {
	return DexpreopterInstallGobRegId
}

// end of dexpreopt.go

// begin of dexpreopt_bootjars.go
func init() {
	artBootImageHostInfoGobRegId = gobtools.RegisterType(func() gobtools.CustomDec { return new(artBootImageHostInfo) })
	profileInstallInfoGobRegId = gobtools.RegisterType(func() gobtools.CustomDec { return new(profileInstallInfo) })
}

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

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

func (r artBootImageHostInfo) CustomHash(hasher *proptools.Hasher) error {
	hasher.WriteString(":java.artBootImageHostInfo")
	hasher.WriteInt(1)
	hasher.WriteString(":java.android.RuleBuilderInstalls")
	hasher.WriteString(":.[]RuleBuilderInstall")
	hasher.WriteInt(len(r.installs))
	for val1 := 0; val1 < len(r.installs); val1++ {
		if err := r.installs[val1].CustomHash(hasher); err != nil {
			return err
		}
	}
	return nil
}

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

	var val3 int
	err = gobtools.DecodeInt(buf, &val3)
	if err != nil {
		return err
	}
	if val3 != -1 {
		r.installs = make([]android.RuleBuilderInstall, val3)
		for val4 := 0; val4 < int(val3); val4++ {
			if err = r.installs[val4].Decode(ctx, buf); err != nil {
				return err
			}
		}
	}

	return err
}

var artBootImageHostInfoGobRegId int16

func (r artBootImageHostInfo) GetTypeId() int16 {
	return artBootImageHostInfoGobRegId
}

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

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

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

func (r profileInstallInfo) CustomHash(hasher *proptools.Hasher) error {
	hasher.WriteString(":java.profileInstallInfo")
	hasher.WriteInt(2)
	hasher.WriteString(":java.android.RuleBuilderInstalls")
	hasher.WriteString(":.[]RuleBuilderInstall")
	hasher.WriteInt(len(r.profileInstalls))
	for val1 := 0; val1 < len(r.profileInstalls); val1++ {
		if err := r.profileInstalls[val1].CustomHash(hasher); err != nil {
			return err
		}
	}
	if err := r.profileLicenseMetadataFile.CustomHash(hasher); err != nil {
		return err
	}
	return nil
}

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

	var val3 int
	err = gobtools.DecodeInt(buf, &val3)
	if err != nil {
		return err
	}
	if val3 != -1 {
		r.profileInstalls = make([]android.RuleBuilderInstall, val3)
		for val4 := 0; val4 < int(val3); val4++ {
			if err = r.profileInstalls[val4].Decode(ctx, buf); err != nil {
				return err
			}
		}
	}

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

	return err
}

var profileInstallInfoGobRegId int16

func (r profileInstallInfo) GetTypeId() int16 {
	return profileInstallInfoGobRegId
}

// end of dexpreopt_bootjars.go

// begin of droiddoc.go
func init() {
	ExportedDroiddocDirInfoGobRegId = gobtools.RegisterType(func() gobtools.CustomDec { return new(ExportedDroiddocDirInfo) })
}

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

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

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

func (r ExportedDroiddocDirInfo) CustomHash(hasher *proptools.Hasher) error {
	hasher.WriteString(":java.ExportedDroiddocDirInfo")
	hasher.WriteInt(2)
	hasher.WriteString(":java.android.Paths")
	hasher.WriteString(":.[]Path")
	hasher.WriteInt(len(r.Deps))
	for val1 := 0; val1 < len(r.Deps); val1++ {
		hasher.WriteString("android/soong/android:android.Path")
		val2 := r.Deps[val1] == nil
		if val2 {
			hasher.WriteByte(0)
		} else {
			if v := reflect.ValueOf(r.Deps[val1]); v.Kind() == reflect.Ptr {
				if v.IsNil() {
					panic(fmt.Errorf("nil pointer is not supported in interface"))
				} else {
					val3 := r.Deps[val1] == nil
					if val3 {
						hasher.WriteByte(0)
					} else {
						val4 := func(hasher *proptools.Hasher) error { return r.Deps[val1].(proptools.CustomHash).CustomHash(hasher) }
						if err := proptools.HashReference(hasher, uintptr(v.Pointer()), val4); err != nil {
							return err
						}
					}
				}
			} else {
				r.Deps[val1].(proptools.CustomHash).CustomHash(hasher)
			}
		}
	}
	hasher.WriteString(":java.android.Path")
	val5 := r.Dir == nil
	if val5 {
		hasher.WriteByte(0)
	} else {
		if v := reflect.ValueOf(r.Dir); v.Kind() == reflect.Ptr {
			if v.IsNil() {
				panic(fmt.Errorf("nil pointer is not supported in interface"))
			} else {
				val6 := r.Dir == nil
				if val6 {
					hasher.WriteByte(0)
				} else {
					val7 := func(hasher *proptools.Hasher) error { return r.Dir.(proptools.CustomHash).CustomHash(hasher) }
					if err := proptools.HashReference(hasher, uintptr(v.Pointer()), val7); err != nil {
						return err
					}
				}
			}
		} else {
			r.Dir.(proptools.CustomHash).CustomHash(hasher)
		}
	}
	return nil
}

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

	var val3 int
	err = gobtools.DecodeInt(buf, &val3)
	if err != nil {
		return err
	}
	if val3 != -1 {
		r.Deps = 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.Deps[val4] = nil
			} else {
				r.Deps[val4] = val6.(android.Path)
			}
		}
	}

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

	return err
}

var ExportedDroiddocDirInfoGobRegId int16

func (r ExportedDroiddocDirInfo) GetTypeId() int16 {
	return ExportedDroiddocDirInfoGobRegId
}

// end of droiddoc.go

// begin of droidstubs.go
func init() {
	StubsInfoGobRegId = gobtools.RegisterType(func() gobtools.CustomDec { return new(StubsInfo) })
	DroidStubsInfoGobRegId = gobtools.RegisterType(func() gobtools.CustomDec { return new(DroidStubsInfo) })
	StubsSrcInfoGobRegId = gobtools.RegisterType(func() gobtools.CustomDec { return new(StubsSrcInfo) })
	UpdateApiInfoGobRegId = gobtools.RegisterType(func() gobtools.CustomDec { return new(UpdateApiInfo) })
}

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

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

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

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

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

func (r StubsInfo) CustomHash(hasher *proptools.Hasher) error {
	hasher.WriteString(":java.StubsInfo")
	hasher.WriteInt(4)
	hasher.WriteString(":java.android.Path")
	val1 := r.ApiVersionsXml == nil
	if val1 {
		hasher.WriteByte(0)
	} else {
		if v := reflect.ValueOf(r.ApiVersionsXml); v.Kind() == reflect.Ptr {
			if v.IsNil() {
				panic(fmt.Errorf("nil pointer is not supported in interface"))
			} else {
				val2 := r.ApiVersionsXml == nil
				if val2 {
					hasher.WriteByte(0)
				} else {
					val3 := func(hasher *proptools.Hasher) error {
						return r.ApiVersionsXml.(proptools.CustomHash).CustomHash(hasher)
					}
					if err := proptools.HashReference(hasher, uintptr(v.Pointer()), val3); err != nil {
						return err
					}
				}
			}
		} else {
			r.ApiVersionsXml.(proptools.CustomHash).CustomHash(hasher)
		}
	}
	hasher.WriteString(":java.android.Path")
	val4 := r.AnnotationsZip == nil
	if val4 {
		hasher.WriteByte(0)
	} else {
		if v := reflect.ValueOf(r.AnnotationsZip); v.Kind() == reflect.Ptr {
			if v.IsNil() {
				panic(fmt.Errorf("nil pointer is not supported in interface"))
			} else {
				val5 := r.AnnotationsZip == nil
				if val5 {
					hasher.WriteByte(0)
				} else {
					val6 := func(hasher *proptools.Hasher) error {
						return r.AnnotationsZip.(proptools.CustomHash).CustomHash(hasher)
					}
					if err := proptools.HashReference(hasher, uintptr(v.Pointer()), val6); err != nil {
						return err
					}
				}
			}
		} else {
			r.AnnotationsZip.(proptools.CustomHash).CustomHash(hasher)
		}
	}
	hasher.WriteString(":java.android.Path")
	val7 := r.ApiFile == nil
	if val7 {
		hasher.WriteByte(0)
	} else {
		if v := reflect.ValueOf(r.ApiFile); v.Kind() == reflect.Ptr {
			if v.IsNil() {
				panic(fmt.Errorf("nil pointer is not supported in interface"))
			} else {
				val8 := r.ApiFile == nil
				if val8 {
					hasher.WriteByte(0)
				} else {
					val9 := func(hasher *proptools.Hasher) error { return r.ApiFile.(proptools.CustomHash).CustomHash(hasher) }
					if err := proptools.HashReference(hasher, uintptr(v.Pointer()), val9); err != nil {
						return err
					}
				}
			}
		} else {
			r.ApiFile.(proptools.CustomHash).CustomHash(hasher)
		}
	}
	hasher.WriteString(":java.android.Path")
	val10 := r.RemovedApiFile == nil
	if val10 {
		hasher.WriteByte(0)
	} else {
		if v := reflect.ValueOf(r.RemovedApiFile); v.Kind() == reflect.Ptr {
			if v.IsNil() {
				panic(fmt.Errorf("nil pointer is not supported in interface"))
			} else {
				val11 := r.RemovedApiFile == nil
				if val11 {
					hasher.WriteByte(0)
				} else {
					val12 := func(hasher *proptools.Hasher) error {
						return r.RemovedApiFile.(proptools.CustomHash).CustomHash(hasher)
					}
					if err := proptools.HashReference(hasher, uintptr(v.Pointer()), val12); err != nil {
						return err
					}
				}
			}
		} else {
			r.RemovedApiFile.(proptools.CustomHash).CustomHash(hasher)
		}
	}
	return nil
}

func (r *StubsInfo) 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.ApiVersionsXml = nil
	} else {
		r.ApiVersionsXml = val2.(android.Path)
	}

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

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

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

	return err
}

var StubsInfoGobRegId int16

func (r StubsInfo) GetTypeId() int16 {
	return StubsInfoGobRegId
}

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

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

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

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

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

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

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

func (r DroidStubsInfo) CustomHash(hasher *proptools.Hasher) error {
	hasher.WriteString(":java.DroidStubsInfo")
	hasher.WriteInt(6)
	hasher.WriteString(":java.android.Path")
	val1 := r.CheckedInApiFile == nil
	if val1 {
		hasher.WriteByte(0)
	} else {
		if v := reflect.ValueOf(r.CheckedInApiFile); v.Kind() == reflect.Ptr {
			if v.IsNil() {
				panic(fmt.Errorf("nil pointer is not supported in interface"))
			} else {
				val2 := r.CheckedInApiFile == nil
				if val2 {
					hasher.WriteByte(0)
				} else {
					val3 := func(hasher *proptools.Hasher) error {
						return r.CheckedInApiFile.(proptools.CustomHash).CustomHash(hasher)
					}
					if err := proptools.HashReference(hasher, uintptr(v.Pointer()), val3); err != nil {
						return err
					}
				}
			}
		} else {
			r.CheckedInApiFile.(proptools.CustomHash).CustomHash(hasher)
		}
	}
	hasher.WriteString(":java.android.Path")
	val4 := r.CheckedInRemovedApiFile == nil
	if val4 {
		hasher.WriteByte(0)
	} else {
		if v := reflect.ValueOf(r.CheckedInRemovedApiFile); v.Kind() == reflect.Ptr {
			if v.IsNil() {
				panic(fmt.Errorf("nil pointer is not supported in interface"))
			} else {
				val5 := r.CheckedInRemovedApiFile == nil
				if val5 {
					hasher.WriteByte(0)
				} else {
					val6 := func(hasher *proptools.Hasher) error {
						return r.CheckedInRemovedApiFile.(proptools.CustomHash).CustomHash(hasher)
					}
					if err := proptools.HashReference(hasher, uintptr(v.Pointer()), val6); err != nil {
						return err
					}
				}
			}
		} else {
			r.CheckedInRemovedApiFile.(proptools.CustomHash).CustomHash(hasher)
		}
	}
	hasher.WriteString(":java.android.Paths")
	hasher.WriteString(":.[]Path")
	hasher.WriteInt(len(r.AconfigProtoFiles))
	for val7 := 0; val7 < len(r.AconfigProtoFiles); val7++ {
		hasher.WriteString("android/soong/android:android.Path")
		val8 := r.AconfigProtoFiles[val7] == nil
		if val8 {
			hasher.WriteByte(0)
		} else {
			if v := reflect.ValueOf(r.AconfigProtoFiles[val7]); v.Kind() == reflect.Ptr {
				if v.IsNil() {
					panic(fmt.Errorf("nil pointer is not supported in interface"))
				} else {
					val9 := r.AconfigProtoFiles[val7] == nil
					if val9 {
						hasher.WriteByte(0)
					} else {
						val10 := func(hasher *proptools.Hasher) error {
							return r.AconfigProtoFiles[val7].(proptools.CustomHash).CustomHash(hasher)
						}
						if err := proptools.HashReference(hasher, uintptr(v.Pointer()), val10); err != nil {
							return err
						}
					}
				}
			} else {
				r.AconfigProtoFiles[val7].(proptools.CustomHash).CustomHash(hasher)
			}
		}
	}
	hasher.WriteString(":java.android.Path")
	val11 := r.CurrentApiTimestamp == nil
	if val11 {
		hasher.WriteByte(0)
	} else {
		if v := reflect.ValueOf(r.CurrentApiTimestamp); v.Kind() == reflect.Ptr {
			if v.IsNil() {
				panic(fmt.Errorf("nil pointer is not supported in interface"))
			} else {
				val12 := r.CurrentApiTimestamp == nil
				if val12 {
					hasher.WriteByte(0)
				} else {
					val13 := func(hasher *proptools.Hasher) error {
						return r.CurrentApiTimestamp.(proptools.CustomHash).CustomHash(hasher)
					}
					if err := proptools.HashReference(hasher, uintptr(v.Pointer()), val13); err != nil {
						return err
					}
				}
			}
		} else {
			r.CurrentApiTimestamp.(proptools.CustomHash).CustomHash(hasher)
		}
	}
	if err := r.EverythingStubsInfo.CustomHash(hasher); err != nil {
		return err
	}
	if err := r.ExportableStubsInfo.CustomHash(hasher); err != nil {
		return err
	}
	return nil
}

func (r *DroidStubsInfo) 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.CheckedInApiFile = nil
	} else {
		r.CheckedInApiFile = val2.(android.Path)
	}

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

	var val7 int
	err = gobtools.DecodeInt(buf, &val7)
	if err != nil {
		return err
	}
	if val7 != -1 {
		r.AconfigProtoFiles = make([]android.Path, val7)
		for val8 := 0; val8 < int(val7); val8++ {
			if val10, err := gobtools.DecodeInterface(ctx, buf); err != nil {
				return err
			} else if val10 == nil {
				r.AconfigProtoFiles[val8] = nil
			} else {
				r.AconfigProtoFiles[val8] = val10.(android.Path)
			}
		}
	}

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

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

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

	return err
}

var DroidStubsInfoGobRegId int16

func (r DroidStubsInfo) GetTypeId() int16 {
	return DroidStubsInfoGobRegId
}

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

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

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

func (r StubsSrcInfo) CustomHash(hasher *proptools.Hasher) error {
	hasher.WriteString(":java.StubsSrcInfo")
	hasher.WriteInt(2)
	hasher.WriteString(":java.android.Path")
	val1 := r.EverythingStubsSrcJar == nil
	if val1 {
		hasher.WriteByte(0)
	} else {
		if v := reflect.ValueOf(r.EverythingStubsSrcJar); v.Kind() == reflect.Ptr {
			if v.IsNil() {
				panic(fmt.Errorf("nil pointer is not supported in interface"))
			} else {
				val2 := r.EverythingStubsSrcJar == nil
				if val2 {
					hasher.WriteByte(0)
				} else {
					val3 := func(hasher *proptools.Hasher) error {
						return r.EverythingStubsSrcJar.(proptools.CustomHash).CustomHash(hasher)
					}
					if err := proptools.HashReference(hasher, uintptr(v.Pointer()), val3); err != nil {
						return err
					}
				}
			}
		} else {
			r.EverythingStubsSrcJar.(proptools.CustomHash).CustomHash(hasher)
		}
	}
	hasher.WriteString(":java.android.Path")
	val4 := r.ExportableStubsSrcJar == nil
	if val4 {
		hasher.WriteByte(0)
	} else {
		if v := reflect.ValueOf(r.ExportableStubsSrcJar); v.Kind() == reflect.Ptr {
			if v.IsNil() {
				panic(fmt.Errorf("nil pointer is not supported in interface"))
			} else {
				val5 := r.ExportableStubsSrcJar == nil
				if val5 {
					hasher.WriteByte(0)
				} else {
					val6 := func(hasher *proptools.Hasher) error {
						return r.ExportableStubsSrcJar.(proptools.CustomHash).CustomHash(hasher)
					}
					if err := proptools.HashReference(hasher, uintptr(v.Pointer()), val6); err != nil {
						return err
					}
				}
			}
		} else {
			r.ExportableStubsSrcJar.(proptools.CustomHash).CustomHash(hasher)
		}
	}
	return nil
}

func (r *StubsSrcInfo) 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.EverythingStubsSrcJar = nil
	} else {
		r.EverythingStubsSrcJar = val2.(android.Path)
	}

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

	return err
}

var StubsSrcInfoGobRegId int16

func (r StubsSrcInfo) GetTypeId() int16 {
	return StubsSrcInfoGobRegId
}

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

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

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

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

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

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

func (r UpdateApiInfo) CustomHash(hasher *proptools.Hasher) error {
	hasher.WriteString(":java.UpdateApiInfo")
	hasher.WriteInt(5)
	hasher.WriteString(":.string")
	hasher.WriteString(r.Name)
	hasher.WriteString(":java.android.Path")
	val1 := r.SourceApiFile == nil
	if val1 {
		hasher.WriteByte(0)
	} else {
		if v := reflect.ValueOf(r.SourceApiFile); v.Kind() == reflect.Ptr {
			if v.IsNil() {
				panic(fmt.Errorf("nil pointer is not supported in interface"))
			} else {
				val2 := r.SourceApiFile == nil
				if val2 {
					hasher.WriteByte(0)
				} else {
					val3 := func(hasher *proptools.Hasher) error { return r.SourceApiFile.(proptools.CustomHash).CustomHash(hasher) }
					if err := proptools.HashReference(hasher, uintptr(v.Pointer()), val3); err != nil {
						return err
					}
				}
			}
		} else {
			r.SourceApiFile.(proptools.CustomHash).CustomHash(hasher)
		}
	}
	hasher.WriteString(":java.android.Path")
	val4 := r.GeneratedApiFile == nil
	if val4 {
		hasher.WriteByte(0)
	} else {
		if v := reflect.ValueOf(r.GeneratedApiFile); v.Kind() == reflect.Ptr {
			if v.IsNil() {
				panic(fmt.Errorf("nil pointer is not supported in interface"))
			} else {
				val5 := r.GeneratedApiFile == nil
				if val5 {
					hasher.WriteByte(0)
				} else {
					val6 := func(hasher *proptools.Hasher) error {
						return r.GeneratedApiFile.(proptools.CustomHash).CustomHash(hasher)
					}
					if err := proptools.HashReference(hasher, uintptr(v.Pointer()), val6); err != nil {
						return err
					}
				}
			}
		} else {
			r.GeneratedApiFile.(proptools.CustomHash).CustomHash(hasher)
		}
	}
	hasher.WriteString(":java.android.Path")
	val7 := r.SourceRemovedFile == nil
	if val7 {
		hasher.WriteByte(0)
	} else {
		if v := reflect.ValueOf(r.SourceRemovedFile); v.Kind() == reflect.Ptr {
			if v.IsNil() {
				panic(fmt.Errorf("nil pointer is not supported in interface"))
			} else {
				val8 := r.SourceRemovedFile == nil
				if val8 {
					hasher.WriteByte(0)
				} else {
					val9 := func(hasher *proptools.Hasher) error {
						return r.SourceRemovedFile.(proptools.CustomHash).CustomHash(hasher)
					}
					if err := proptools.HashReference(hasher, uintptr(v.Pointer()), val9); err != nil {
						return err
					}
				}
			}
		} else {
			r.SourceRemovedFile.(proptools.CustomHash).CustomHash(hasher)
		}
	}
	hasher.WriteString(":java.android.Path")
	val10 := r.GeneratedRemovedFile == nil
	if val10 {
		hasher.WriteByte(0)
	} else {
		if v := reflect.ValueOf(r.GeneratedRemovedFile); v.Kind() == reflect.Ptr {
			if v.IsNil() {
				panic(fmt.Errorf("nil pointer is not supported in interface"))
			} else {
				val11 := r.GeneratedRemovedFile == nil
				if val11 {
					hasher.WriteByte(0)
				} else {
					val12 := func(hasher *proptools.Hasher) error {
						return r.GeneratedRemovedFile.(proptools.CustomHash).CustomHash(hasher)
					}
					if err := proptools.HashReference(hasher, uintptr(v.Pointer()), val12); err != nil {
						return err
					}
				}
			}
		} else {
			r.GeneratedRemovedFile.(proptools.CustomHash).CustomHash(hasher)
		}
	}
	return nil
}

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

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

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

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

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

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

	return err
}

var UpdateApiInfoGobRegId int16

func (r UpdateApiInfo) GetTypeId() int16 {
	return UpdateApiInfoGobRegId
}

// end of droidstubs.go

// begin of fuzz.go
func init() {
	JavaFuzzTestInfoGobRegId = gobtools.RegisterType(func() gobtools.CustomDec { return new(JavaFuzzTestInfo) })
}

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

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

func (r JavaFuzzTestInfo) CustomHash(hasher *proptools.Hasher) error {
	hasher.WriteString(":java.JavaFuzzTestInfo")
	hasher.WriteInt(1)
	hasher.WriteString(":java.android.Paths")
	hasher.WriteString(":.[]Path")
	hasher.WriteInt(len(r.JniFilePaths))
	for val1 := 0; val1 < len(r.JniFilePaths); val1++ {
		hasher.WriteString("android/soong/android:android.Path")
		val2 := r.JniFilePaths[val1] == nil
		if val2 {
			hasher.WriteByte(0)
		} else {
			if v := reflect.ValueOf(r.JniFilePaths[val1]); v.Kind() == reflect.Ptr {
				if v.IsNil() {
					panic(fmt.Errorf("nil pointer is not supported in interface"))
				} else {
					val3 := r.JniFilePaths[val1] == nil
					if val3 {
						hasher.WriteByte(0)
					} else {
						val4 := func(hasher *proptools.Hasher) error {
							return r.JniFilePaths[val1].(proptools.CustomHash).CustomHash(hasher)
						}
						if err := proptools.HashReference(hasher, uintptr(v.Pointer()), val4); err != nil {
							return err
						}
					}
				}
			} else {
				r.JniFilePaths[val1].(proptools.CustomHash).CustomHash(hasher)
			}
		}
	}
	return nil
}

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

	var val3 int
	err = gobtools.DecodeInt(buf, &val3)
	if err != nil {
		return err
	}
	if val3 != -1 {
		r.JniFilePaths = 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.JniFilePaths[val4] = nil
			} else {
				r.JniFilePaths[val4] = val6.(android.Path)
			}
		}
	}

	return err
}

var JavaFuzzTestInfoGobRegId int16

func (r JavaFuzzTestInfo) GetTypeId() int16 {
	return JavaFuzzTestInfoGobRegId
}

// end of fuzz.go

// begin of hiddenapi_modular.go
func init() {
	HiddenAPIScopeGobRegId = gobtools.RegisterType(func() gobtools.CustomDec { return new(HiddenAPIScope) })
	FlagFilesByCategoryGobRegId = gobtools.RegisterType(func() gobtools.CustomDec { return new(FlagFilesByCategory) })
	HiddenAPIInfoGobRegId = gobtools.RegisterType(func() gobtools.CustomDec { return new(HiddenAPIInfo) })
	HiddenAPIInfoForSdkGobRegId = gobtools.RegisterType(func() gobtools.CustomDec { return new(HiddenAPIInfoForSdk) })
	ModuleStubDexJarsGobRegId = gobtools.RegisterType(func() gobtools.CustomDec { return new(ModuleStubDexJars) })
	HiddenAPIPropertyInfoGobRegId = gobtools.RegisterType(func() gobtools.CustomDec { return new(HiddenAPIPropertyInfo) })
	HiddenAPIFlagOutputGobRegId = gobtools.RegisterType(func() gobtools.CustomDec { return new(HiddenAPIFlagOutput) })
	SignatureCsvSubsetGobRegId = gobtools.RegisterType(func() gobtools.CustomDec { return new(SignatureCsvSubset) })
	SignatureCsvSubsetsGobRegId = gobtools.RegisterType(func() gobtools.CustomDec { return new(SignatureCsvSubsets) })
}

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

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

	if err = gobtools.EncodeInt(buf, int(r.sdkKind)); err != nil {
		return err
	}

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

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

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

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

func (r HiddenAPIScope) CustomHash(hasher *proptools.Hasher) error {
	hasher.WriteString(":java.HiddenAPIScope")
	hasher.WriteInt(6)
	hasher.WriteString(":.string")
	hasher.WriteString(r.name)
	hasher.WriteString(":java.android.SdkKind")
	hasher.WriteString(":.int")
	hasher.WriteUint64(uint64(int(r.sdkKind)))
	hasher.WriteString(":.string")
	hasher.WriteString(r.hiddenAPIListOption)
	hasher.WriteString(":.string")
	hasher.WriteString(r.nonUpdatableSourceModule)
	hasher.WriteString(":.string")
	hasher.WriteString(r.nonUpdatableFromTextModule)
	hasher.WriteString(":.string")
	hasher.WriteString(r.nonUpdatablePrebuiltModule)
	return nil
}

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

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

	var val3 int
	err = gobtools.DecodeInt(buf, &val3)
	if err != nil {
		return err
	}
	r.sdkKind = android.SdkKind(val3)

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

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

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

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

	return err
}

var HiddenAPIScopeGobRegId int16

func (r HiddenAPIScope) GetTypeId() int16 {
	return HiddenAPIScopeGobRegId
}

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

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

func (r FlagFilesByCategory) CustomHash(hasher *proptools.Hasher) error {
	hasher.WriteString(":.map[hiddenAPIFlagFileCategory]android.Paths")
	hasher.WriteInt(len(r))
	val1 := make([]hiddenAPIFlagFileCategory, 0, len(r))
	for val3 := range r {
		val1 = append(val1, val3)
	}
	proptools.SortOrdered(val1)
	for _, val2 := range val1 {
		hasher.WriteString(":java.hiddenAPIFlagFileCategory")
		hasher.WriteString(":.int")
		hasher.WriteUint64(uint64(int(val2)))
		hasher.WriteString(":java.android.Paths")
		hasher.WriteString(":.[]Path")
		hasher.WriteInt(len(r[val2]))
		for val4 := 0; val4 < len(r[val2]); val4++ {
			hasher.WriteString("android/soong/android:android.Path")
			val5 := r[val2][val4] == nil
			if val5 {
				hasher.WriteByte(0)
			} else {
				if v := reflect.ValueOf(r[val2][val4]); v.Kind() == reflect.Ptr {
					if v.IsNil() {
						panic(fmt.Errorf("nil pointer is not supported in interface"))
					} else {
						val6 := r[val2][val4] == nil
						if val6 {
							hasher.WriteByte(0)
						} else {
							val7 := func(hasher *proptools.Hasher) error { return r[val2][val4].(proptools.CustomHash).CustomHash(hasher) }
							if err := proptools.HashReference(hasher, uintptr(v.Pointer()), val7); err != nil {
								return err
							}
						}
					}
				} else {
					r[val2][val4].(proptools.CustomHash).CustomHash(hasher)
				}
			}
		}
	}
	return nil
}

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

	var val1 int
	err = gobtools.DecodeInt(buf, &val1)
	if err != nil {
		return err
	}
	if val1 != -1 {
		(*r) = make(map[hiddenAPIFlagFileCategory]android.Paths, val1)
		for val2 := 0; val2 < int(val1); val2++ {
			var val3 hiddenAPIFlagFileCategory
			var val4 android.Paths
			var val6 int
			err = gobtools.DecodeInt(buf, &val6)
			if err != nil {
				return err
			}
			val3 = hiddenAPIFlagFileCategory(val6)
			var val10 int
			err = gobtools.DecodeInt(buf, &val10)
			if err != nil {
				return err
			}
			if val10 != -1 {
				val4 = make([]android.Path, val10)
				for val11 := 0; val11 < int(val10); val11++ {
					if val13, err := gobtools.DecodeInterface(ctx, buf); err != nil {
						return err
					} else if val13 == nil {
						val4[val11] = nil
					} else {
						val4[val11] = val13.(android.Path)
					}
				}
			}
			(*r)[val3] = val4
		}
	}

	return err
}

var FlagFilesByCategoryGobRegId int16

func (r FlagFilesByCategory) GetTypeId() int16 {
	return FlagFilesByCategoryGobRegId
}

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

	if r.FlagFilesByCategory == nil {
		if err = gobtools.EncodeInt(buf, -1); err != nil {
			return err
		}
	} else {
		if err = gobtools.EncodeInt(buf, len(r.FlagFilesByCategory)); err != nil {
			return err
		}
		for val1, val2 := range r.FlagFilesByCategory {
			if err = gobtools.EncodeInt(buf, int(val1)); err != nil {
				return err
			}
			if val2 == nil {
				if err = gobtools.EncodeInt(buf, -1); err != nil {
					return err
				}
			} else {
				if err = gobtools.EncodeInt(buf, len(val2)); err != nil {
					return err
				}
				for val3 := 0; val3 < len(val2); val3++ {
					if err = gobtools.EncodeInterface(ctx, buf, val2[val3]); err != nil {
						return err
					}
				}
			}
		}
	}

	if r.TransitiveStubDexJarsByScope == nil {
		if err = gobtools.EncodeInt(buf, -1); err != nil {
			return err
		}
	} else {
		if err = gobtools.EncodeInt(buf, len(r.TransitiveStubDexJarsByScope)); err != nil {
			return err
		}
		for val4, val5 := range r.TransitiveStubDexJarsByScope {
			if err = gobtools.EncodeString(buf, val4); err != nil {
				return err
			}
			if val5 == nil {
				if err = gobtools.EncodeInt(buf, -1); err != nil {
					return err
				}
			} else {
				if err = gobtools.EncodeInt(buf, len(val5)); err != nil {
					return err
				}
				for val6, val7 := range val5 {
					if err = gobtools.EncodeString(buf, val6); err != nil {
						return err
					}
					if err = gobtools.EncodeInterface(ctx, buf, val7); err != nil {
						return err
					}
				}
			}
		}
	}

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

func (r HiddenAPIInfo) CustomHash(hasher *proptools.Hasher) error {
	hasher.WriteString(":java.HiddenAPIInfo")
	hasher.WriteInt(3)
	hasher.WriteString(":java.FlagFilesByCategory")
	hasher.WriteString(":.map[hiddenAPIFlagFileCategory]android.Paths")
	hasher.WriteInt(len(r.FlagFilesByCategory))
	val1 := make([]hiddenAPIFlagFileCategory, 0, len(r.FlagFilesByCategory))
	for val3 := range r.FlagFilesByCategory {
		val1 = append(val1, val3)
	}
	proptools.SortOrdered(val1)
	for _, val2 := range val1 {
		hasher.WriteString(":java.hiddenAPIFlagFileCategory")
		hasher.WriteString(":.int")
		hasher.WriteUint64(uint64(int(val2)))
		hasher.WriteString(":java.android.Paths")
		hasher.WriteString(":.[]Path")
		hasher.WriteInt(len(r.FlagFilesByCategory[val2]))
		for val4 := 0; val4 < len(r.FlagFilesByCategory[val2]); val4++ {
			hasher.WriteString("android/soong/android:android.Path")
			val5 := r.FlagFilesByCategory[val2][val4] == nil
			if val5 {
				hasher.WriteByte(0)
			} else {
				if v := reflect.ValueOf(r.FlagFilesByCategory[val2][val4]); v.Kind() == reflect.Ptr {
					if v.IsNil() {
						panic(fmt.Errorf("nil pointer is not supported in interface"))
					} else {
						val6 := r.FlagFilesByCategory[val2][val4] == nil
						if val6 {
							hasher.WriteByte(0)
						} else {
							val7 := func(hasher *proptools.Hasher) error {
								return r.FlagFilesByCategory[val2][val4].(proptools.CustomHash).CustomHash(hasher)
							}
							if err := proptools.HashReference(hasher, uintptr(v.Pointer()), val7); err != nil {
								return err
							}
						}
					}
				} else {
					r.FlagFilesByCategory[val2][val4].(proptools.CustomHash).CustomHash(hasher)
				}
			}
		}
	}
	hasher.WriteString(":java.StubDexJarsByModule")
	hasher.WriteString(":.map[string]ModuleStubDexJars")
	hasher.WriteInt(len(r.TransitiveStubDexJarsByScope))
	val8 := make([]string, 0, len(r.TransitiveStubDexJarsByScope))
	for val10 := range r.TransitiveStubDexJarsByScope {
		val8 = append(val8, val10)
	}
	proptools.SortOrdered(val8)
	for _, val9 := range val8 {
		hasher.WriteString(":.string")
		hasher.WriteString(val9)
		hasher.WriteString(":java.ModuleStubDexJars")
		hasher.WriteString(":.map[string]android.Path")
		hasher.WriteInt(len(r.TransitiveStubDexJarsByScope[val9]))
		val11 := make([]string, 0, len(r.TransitiveStubDexJarsByScope[val9]))
		for val13 := range r.TransitiveStubDexJarsByScope[val9] {
			val11 = append(val11, val13)
		}
		proptools.SortOrdered(val11)
		for _, val12 := range val11 {
			hasher.WriteString(":.string")
			hasher.WriteString(val12)
			hasher.WriteString(":java.android.Path")
			val14 := r.TransitiveStubDexJarsByScope[val9][val12] == nil
			if val14 {
				hasher.WriteByte(0)
			} else {
				if v := reflect.ValueOf(r.TransitiveStubDexJarsByScope[val9][val12]); v.Kind() == reflect.Ptr {
					if v.IsNil() {
						panic(fmt.Errorf("nil pointer is not supported in interface"))
					} else {
						val15 := r.TransitiveStubDexJarsByScope[val9][val12] == nil
						if val15 {
							hasher.WriteByte(0)
						} else {
							val16 := func(hasher *proptools.Hasher) error {
								return r.TransitiveStubDexJarsByScope[val9][val12].(proptools.CustomHash).CustomHash(hasher)
							}
							if err := proptools.HashReference(hasher, uintptr(v.Pointer()), val16); err != nil {
								return err
							}
						}
					}
				} else {
					r.TransitiveStubDexJarsByScope[val9][val12].(proptools.CustomHash).CustomHash(hasher)
				}
			}
		}
	}
	if err := r.HiddenAPIFlagOutput.CustomHash(hasher); err != nil {
		return err
	}
	return nil
}

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

	var val2 int
	err = gobtools.DecodeInt(buf, &val2)
	if err != nil {
		return err
	}
	if val2 != -1 {
		r.FlagFilesByCategory = make(map[hiddenAPIFlagFileCategory]android.Paths, val2)
		for val3 := 0; val3 < int(val2); val3++ {
			var val4 hiddenAPIFlagFileCategory
			var val5 android.Paths
			var val7 int
			err = gobtools.DecodeInt(buf, &val7)
			if err != nil {
				return err
			}
			val4 = hiddenAPIFlagFileCategory(val7)
			var val11 int
			err = gobtools.DecodeInt(buf, &val11)
			if err != nil {
				return err
			}
			if val11 != -1 {
				val5 = make([]android.Path, val11)
				for val12 := 0; val12 < int(val11); val12++ {
					if val14, err := gobtools.DecodeInterface(ctx, buf); err != nil {
						return err
					} else if val14 == nil {
						val5[val12] = nil
					} else {
						val5[val12] = val14.(android.Path)
					}
				}
			}
			r.FlagFilesByCategory[val4] = val5
		}
	}

	var val16 int
	err = gobtools.DecodeInt(buf, &val16)
	if err != nil {
		return err
	}
	if val16 != -1 {
		r.TransitiveStubDexJarsByScope = make(map[string]ModuleStubDexJars, val16)
		for val17 := 0; val17 < int(val16); val17++ {
			var val18 string
			var val19 ModuleStubDexJars
			err = gobtools.DecodeString(buf, &val18)
			if err != nil {
				return err
			}
			var val22 int
			err = gobtools.DecodeInt(buf, &val22)
			if err != nil {
				return err
			}
			if val22 != -1 {
				val19 = make(map[string]android.Path, val22)
				for val23 := 0; val23 < int(val22); val23++ {
					var val24 string
					var val25 android.Path
					err = gobtools.DecodeString(buf, &val24)
					if err != nil {
						return err
					}
					if val28, err := gobtools.DecodeInterface(ctx, buf); err != nil {
						return err
					} else if val28 == nil {
						val25 = nil
					} else {
						val25 = val28.(android.Path)
					}
					val19[val24] = val25
				}
			}
			r.TransitiveStubDexJarsByScope[val18] = val19
		}
	}

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

	return err
}

var HiddenAPIInfoGobRegId int16

func (r HiddenAPIInfo) GetTypeId() int16 {
	return HiddenAPIInfoGobRegId
}

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

	if r.FlagFilesByCategory == nil {
		if err = gobtools.EncodeInt(buf, -1); err != nil {
			return err
		}
	} else {
		if err = gobtools.EncodeInt(buf, len(r.FlagFilesByCategory)); err != nil {
			return err
		}
		for val1, val2 := range r.FlagFilesByCategory {
			if err = gobtools.EncodeInt(buf, int(val1)); err != nil {
				return err
			}
			if val2 == nil {
				if err = gobtools.EncodeInt(buf, -1); err != nil {
					return err
				}
			} else {
				if err = gobtools.EncodeInt(buf, len(val2)); err != nil {
					return err
				}
				for val3 := 0; val3 < len(val2); val3++ {
					if err = gobtools.EncodeInterface(ctx, buf, val2[val3]); err != nil {
						return err
					}
				}
			}
		}
	}

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

func (r HiddenAPIInfoForSdk) CustomHash(hasher *proptools.Hasher) error {
	hasher.WriteString(":java.HiddenAPIInfoForSdk")
	hasher.WriteInt(2)
	hasher.WriteString(":java.FlagFilesByCategory")
	hasher.WriteString(":.map[hiddenAPIFlagFileCategory]android.Paths")
	hasher.WriteInt(len(r.FlagFilesByCategory))
	val1 := make([]hiddenAPIFlagFileCategory, 0, len(r.FlagFilesByCategory))
	for val3 := range r.FlagFilesByCategory {
		val1 = append(val1, val3)
	}
	proptools.SortOrdered(val1)
	for _, val2 := range val1 {
		hasher.WriteString(":java.hiddenAPIFlagFileCategory")
		hasher.WriteString(":.int")
		hasher.WriteUint64(uint64(int(val2)))
		hasher.WriteString(":java.android.Paths")
		hasher.WriteString(":.[]Path")
		hasher.WriteInt(len(r.FlagFilesByCategory[val2]))
		for val4 := 0; val4 < len(r.FlagFilesByCategory[val2]); val4++ {
			hasher.WriteString("android/soong/android:android.Path")
			val5 := r.FlagFilesByCategory[val2][val4] == nil
			if val5 {
				hasher.WriteByte(0)
			} else {
				if v := reflect.ValueOf(r.FlagFilesByCategory[val2][val4]); v.Kind() == reflect.Ptr {
					if v.IsNil() {
						panic(fmt.Errorf("nil pointer is not supported in interface"))
					} else {
						val6 := r.FlagFilesByCategory[val2][val4] == nil
						if val6 {
							hasher.WriteByte(0)
						} else {
							val7 := func(hasher *proptools.Hasher) error {
								return r.FlagFilesByCategory[val2][val4].(proptools.CustomHash).CustomHash(hasher)
							}
							if err := proptools.HashReference(hasher, uintptr(v.Pointer()), val7); err != nil {
								return err
							}
						}
					}
				} else {
					r.FlagFilesByCategory[val2][val4].(proptools.CustomHash).CustomHash(hasher)
				}
			}
		}
	}
	if err := r.HiddenAPIFlagOutput.CustomHash(hasher); err != nil {
		return err
	}
	return nil
}

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

	var val2 int
	err = gobtools.DecodeInt(buf, &val2)
	if err != nil {
		return err
	}
	if val2 != -1 {
		r.FlagFilesByCategory = make(map[hiddenAPIFlagFileCategory]android.Paths, val2)
		for val3 := 0; val3 < int(val2); val3++ {
			var val4 hiddenAPIFlagFileCategory
			var val5 android.Paths
			var val7 int
			err = gobtools.DecodeInt(buf, &val7)
			if err != nil {
				return err
			}
			val4 = hiddenAPIFlagFileCategory(val7)
			var val11 int
			err = gobtools.DecodeInt(buf, &val11)
			if err != nil {
				return err
			}
			if val11 != -1 {
				val5 = make([]android.Path, val11)
				for val12 := 0; val12 < int(val11); val12++ {
					if val14, err := gobtools.DecodeInterface(ctx, buf); err != nil {
						return err
					} else if val14 == nil {
						val5[val12] = nil
					} else {
						val5[val12] = val14.(android.Path)
					}
				}
			}
			r.FlagFilesByCategory[val4] = val5
		}
	}

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

	return err
}

var HiddenAPIInfoForSdkGobRegId int16

func (r HiddenAPIInfoForSdk) GetTypeId() int16 {
	return HiddenAPIInfoForSdkGobRegId
}

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

	if r == nil {
		if err = gobtools.EncodeInt(buf, -1); err != nil {
			return err
		}
	} else {
		if err = gobtools.EncodeInt(buf, len(r)); err != nil {
			return err
		}
		for val1, val2 := range r {
			if err = gobtools.EncodeString(buf, val1); err != nil {
				return err
			}
			if err = gobtools.EncodeInterface(ctx, buf, val2); err != nil {
				return err
			}
		}
	}
	return err
}

func (r ModuleStubDexJars) CustomHash(hasher *proptools.Hasher) error {
	hasher.WriteString(":.map[string]android.Path")
	hasher.WriteInt(len(r))
	val1 := make([]string, 0, len(r))
	for val3 := range r {
		val1 = append(val1, val3)
	}
	proptools.SortOrdered(val1)
	for _, val2 := range val1 {
		hasher.WriteString(":.string")
		hasher.WriteString(val2)
		hasher.WriteString(":java.android.Path")
		val4 := r[val2] == nil
		if val4 {
			hasher.WriteByte(0)
		} else {
			if v := reflect.ValueOf(r[val2]); v.Kind() == reflect.Ptr {
				if v.IsNil() {
					panic(fmt.Errorf("nil pointer is not supported in interface"))
				} else {
					val5 := r[val2] == nil
					if val5 {
						hasher.WriteByte(0)
					} else {
						val6 := func(hasher *proptools.Hasher) error { return r[val2].(proptools.CustomHash).CustomHash(hasher) }
						if err := proptools.HashReference(hasher, uintptr(v.Pointer()), val6); err != nil {
							return err
						}
					}
				}
			} else {
				r[val2].(proptools.CustomHash).CustomHash(hasher)
			}
		}
	}
	return nil
}

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

	var val1 int
	err = gobtools.DecodeInt(buf, &val1)
	if err != nil {
		return err
	}
	if val1 != -1 {
		(*r) = make(map[string]android.Path, val1)
		for val2 := 0; val2 < int(val1); val2++ {
			var val3 string
			var val4 android.Path
			err = gobtools.DecodeString(buf, &val3)
			if err != nil {
				return err
			}
			if val7, err := gobtools.DecodeInterface(ctx, buf); err != nil {
				return err
			} else if val7 == nil {
				val4 = nil
			} else {
				val4 = val7.(android.Path)
			}
			(*r)[val3] = val4
		}
	}

	return err
}

var ModuleStubDexJarsGobRegId int16

func (r ModuleStubDexJars) GetTypeId() int16 {
	return ModuleStubDexJarsGobRegId
}

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

	if r.FlagFilesByCategory == nil {
		if err = gobtools.EncodeInt(buf, -1); err != nil {
			return err
		}
	} else {
		if err = gobtools.EncodeInt(buf, len(r.FlagFilesByCategory)); err != nil {
			return err
		}
		for val1, val2 := range r.FlagFilesByCategory {
			if err = gobtools.EncodeInt(buf, int(val1)); err != nil {
				return err
			}
			if val2 == nil {
				if err = gobtools.EncodeInt(buf, -1); err != nil {
					return err
				}
			} else {
				if err = gobtools.EncodeInt(buf, len(val2)); err != nil {
					return err
				}
				for val3 := 0; val3 < len(val2); val3++ {
					if err = gobtools.EncodeInterface(ctx, buf, val2[val3]); err != nil {
						return err
					}
				}
			}
		}
	}

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

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

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

func (r HiddenAPIPropertyInfo) CustomHash(hasher *proptools.Hasher) error {
	hasher.WriteString(":java.HiddenAPIPropertyInfo")
	hasher.WriteInt(4)
	hasher.WriteString(":java.FlagFilesByCategory")
	hasher.WriteString(":.map[hiddenAPIFlagFileCategory]android.Paths")
	hasher.WriteInt(len(r.FlagFilesByCategory))
	val1 := make([]hiddenAPIFlagFileCategory, 0, len(r.FlagFilesByCategory))
	for val3 := range r.FlagFilesByCategory {
		val1 = append(val1, val3)
	}
	proptools.SortOrdered(val1)
	for _, val2 := range val1 {
		hasher.WriteString(":java.hiddenAPIFlagFileCategory")
		hasher.WriteString(":.int")
		hasher.WriteUint64(uint64(int(val2)))
		hasher.WriteString(":java.android.Paths")
		hasher.WriteString(":.[]Path")
		hasher.WriteInt(len(r.FlagFilesByCategory[val2]))
		for val4 := 0; val4 < len(r.FlagFilesByCategory[val2]); val4++ {
			hasher.WriteString("android/soong/android:android.Path")
			val5 := r.FlagFilesByCategory[val2][val4] == nil
			if val5 {
				hasher.WriteByte(0)
			} else {
				if v := reflect.ValueOf(r.FlagFilesByCategory[val2][val4]); v.Kind() == reflect.Ptr {
					if v.IsNil() {
						panic(fmt.Errorf("nil pointer is not supported in interface"))
					} else {
						val6 := r.FlagFilesByCategory[val2][val4] == nil
						if val6 {
							hasher.WriteByte(0)
						} else {
							val7 := func(hasher *proptools.Hasher) error {
								return r.FlagFilesByCategory[val2][val4].(proptools.CustomHash).CustomHash(hasher)
							}
							if err := proptools.HashReference(hasher, uintptr(v.Pointer()), val7); err != nil {
								return err
							}
						}
					}
				} else {
					r.FlagFilesByCategory[val2][val4].(proptools.CustomHash).CustomHash(hasher)
				}
			}
		}
	}
	hasher.WriteString(":.[]string")
	hasher.WriteInt(len(r.PackagePrefixes))
	for val8 := 0; val8 < len(r.PackagePrefixes); val8++ {
		hasher.WriteString(":.string")
		hasher.WriteString(r.PackagePrefixes[val8])
	}
	hasher.WriteString(":.[]string")
	hasher.WriteInt(len(r.SinglePackages))
	for val9 := 0; val9 < len(r.SinglePackages); val9++ {
		hasher.WriteString(":.string")
		hasher.WriteString(r.SinglePackages[val9])
	}
	hasher.WriteString(":.[]string")
	hasher.WriteInt(len(r.SplitPackages))
	for val10 := 0; val10 < len(r.SplitPackages); val10++ {
		hasher.WriteString(":.string")
		hasher.WriteString(r.SplitPackages[val10])
	}
	return nil
}

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

	var val2 int
	err = gobtools.DecodeInt(buf, &val2)
	if err != nil {
		return err
	}
	if val2 != -1 {
		r.FlagFilesByCategory = make(map[hiddenAPIFlagFileCategory]android.Paths, val2)
		for val3 := 0; val3 < int(val2); val3++ {
			var val4 hiddenAPIFlagFileCategory
			var val5 android.Paths
			var val7 int
			err = gobtools.DecodeInt(buf, &val7)
			if err != nil {
				return err
			}
			val4 = hiddenAPIFlagFileCategory(val7)
			var val11 int
			err = gobtools.DecodeInt(buf, &val11)
			if err != nil {
				return err
			}
			if val11 != -1 {
				val5 = make([]android.Path, val11)
				for val12 := 0; val12 < int(val11); val12++ {
					if val14, err := gobtools.DecodeInterface(ctx, buf); err != nil {
						return err
					} else if val14 == nil {
						val5[val12] = nil
					} else {
						val5[val12] = val14.(android.Path)
					}
				}
			}
			r.FlagFilesByCategory[val4] = val5
		}
	}

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

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

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

	return err
}

var HiddenAPIPropertyInfoGobRegId int16

func (r HiddenAPIPropertyInfo) GetTypeId() int16 {
	return HiddenAPIPropertyInfoGobRegId
}

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

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

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

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

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

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

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

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

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

func (r HiddenAPIFlagOutput) CustomHash(hasher *proptools.Hasher) error {
	hasher.WriteString(":java.HiddenAPIFlagOutput")
	hasher.WriteInt(8)
	hasher.WriteString(":java.android.Path")
	val1 := r.AnnotationFlagsPath == nil
	if val1 {
		hasher.WriteByte(0)
	} else {
		if v := reflect.ValueOf(r.AnnotationFlagsPath); v.Kind() == reflect.Ptr {
			if v.IsNil() {
				panic(fmt.Errorf("nil pointer is not supported in interface"))
			} else {
				val2 := r.AnnotationFlagsPath == nil
				if val2 {
					hasher.WriteByte(0)
				} else {
					val3 := func(hasher *proptools.Hasher) error {
						return r.AnnotationFlagsPath.(proptools.CustomHash).CustomHash(hasher)
					}
					if err := proptools.HashReference(hasher, uintptr(v.Pointer()), val3); err != nil {
						return err
					}
				}
			}
		} else {
			r.AnnotationFlagsPath.(proptools.CustomHash).CustomHash(hasher)
		}
	}
	hasher.WriteString(":java.android.Path")
	val4 := r.MetadataPath == nil
	if val4 {
		hasher.WriteByte(0)
	} else {
		if v := reflect.ValueOf(r.MetadataPath); v.Kind() == reflect.Ptr {
			if v.IsNil() {
				panic(fmt.Errorf("nil pointer is not supported in interface"))
			} else {
				val5 := r.MetadataPath == nil
				if val5 {
					hasher.WriteByte(0)
				} else {
					val6 := func(hasher *proptools.Hasher) error { return r.MetadataPath.(proptools.CustomHash).CustomHash(hasher) }
					if err := proptools.HashReference(hasher, uintptr(v.Pointer()), val6); err != nil {
						return err
					}
				}
			}
		} else {
			r.MetadataPath.(proptools.CustomHash).CustomHash(hasher)
		}
	}
	hasher.WriteString(":java.android.Path")
	val7 := r.IndexPath == nil
	if val7 {
		hasher.WriteByte(0)
	} else {
		if v := reflect.ValueOf(r.IndexPath); v.Kind() == reflect.Ptr {
			if v.IsNil() {
				panic(fmt.Errorf("nil pointer is not supported in interface"))
			} else {
				val8 := r.IndexPath == nil
				if val8 {
					hasher.WriteByte(0)
				} else {
					val9 := func(hasher *proptools.Hasher) error { return r.IndexPath.(proptools.CustomHash).CustomHash(hasher) }
					if err := proptools.HashReference(hasher, uintptr(v.Pointer()), val9); err != nil {
						return err
					}
				}
			}
		} else {
			r.IndexPath.(proptools.CustomHash).CustomHash(hasher)
		}
	}
	hasher.WriteString(":java.android.Path")
	val10 := r.StubFlagsPath == nil
	if val10 {
		hasher.WriteByte(0)
	} else {
		if v := reflect.ValueOf(r.StubFlagsPath); v.Kind() == reflect.Ptr {
			if v.IsNil() {
				panic(fmt.Errorf("nil pointer is not supported in interface"))
			} else {
				val11 := r.StubFlagsPath == nil
				if val11 {
					hasher.WriteByte(0)
				} else {
					val12 := func(hasher *proptools.Hasher) error { return r.StubFlagsPath.(proptools.CustomHash).CustomHash(hasher) }
					if err := proptools.HashReference(hasher, uintptr(v.Pointer()), val12); err != nil {
						return err
					}
				}
			}
		} else {
			r.StubFlagsPath.(proptools.CustomHash).CustomHash(hasher)
		}
	}
	hasher.WriteString(":java.android.Path")
	val13 := r.AllFlagsPath == nil
	if val13 {
		hasher.WriteByte(0)
	} else {
		if v := reflect.ValueOf(r.AllFlagsPath); v.Kind() == reflect.Ptr {
			if v.IsNil() {
				panic(fmt.Errorf("nil pointer is not supported in interface"))
			} else {
				val14 := r.AllFlagsPath == nil
				if val14 {
					hasher.WriteByte(0)
				} else {
					val15 := func(hasher *proptools.Hasher) error { return r.AllFlagsPath.(proptools.CustomHash).CustomHash(hasher) }
					if err := proptools.HashReference(hasher, uintptr(v.Pointer()), val15); err != nil {
						return err
					}
				}
			}
		} else {
			r.AllFlagsPath.(proptools.CustomHash).CustomHash(hasher)
		}
	}
	hasher.WriteString(":java.android.Path")
	val16 := r.SignaturePatternsPath == nil
	if val16 {
		hasher.WriteByte(0)
	} else {
		if v := reflect.ValueOf(r.SignaturePatternsPath); v.Kind() == reflect.Ptr {
			if v.IsNil() {
				panic(fmt.Errorf("nil pointer is not supported in interface"))
			} else {
				val17 := r.SignaturePatternsPath == nil
				if val17 {
					hasher.WriteByte(0)
				} else {
					val18 := func(hasher *proptools.Hasher) error {
						return r.SignaturePatternsPath.(proptools.CustomHash).CustomHash(hasher)
					}
					if err := proptools.HashReference(hasher, uintptr(v.Pointer()), val18); err != nil {
						return err
					}
				}
			}
		} else {
			r.SignaturePatternsPath.(proptools.CustomHash).CustomHash(hasher)
		}
	}
	hasher.WriteString(":java.android.Path")
	val19 := r.FilteredStubFlagsPath == nil
	if val19 {
		hasher.WriteByte(0)
	} else {
		if v := reflect.ValueOf(r.FilteredStubFlagsPath); v.Kind() == reflect.Ptr {
			if v.IsNil() {
				panic(fmt.Errorf("nil pointer is not supported in interface"))
			} else {
				val20 := r.FilteredStubFlagsPath == nil
				if val20 {
					hasher.WriteByte(0)
				} else {
					val21 := func(hasher *proptools.Hasher) error {
						return r.FilteredStubFlagsPath.(proptools.CustomHash).CustomHash(hasher)
					}
					if err := proptools.HashReference(hasher, uintptr(v.Pointer()), val21); err != nil {
						return err
					}
				}
			}
		} else {
			r.FilteredStubFlagsPath.(proptools.CustomHash).CustomHash(hasher)
		}
	}
	hasher.WriteString(":java.android.Path")
	val22 := r.FilteredFlagsPath == nil
	if val22 {
		hasher.WriteByte(0)
	} else {
		if v := reflect.ValueOf(r.FilteredFlagsPath); v.Kind() == reflect.Ptr {
			if v.IsNil() {
				panic(fmt.Errorf("nil pointer is not supported in interface"))
			} else {
				val23 := r.FilteredFlagsPath == nil
				if val23 {
					hasher.WriteByte(0)
				} else {
					val24 := func(hasher *proptools.Hasher) error {
						return r.FilteredFlagsPath.(proptools.CustomHash).CustomHash(hasher)
					}
					if err := proptools.HashReference(hasher, uintptr(v.Pointer()), val24); err != nil {
						return err
					}
				}
			}
		} else {
			r.FilteredFlagsPath.(proptools.CustomHash).CustomHash(hasher)
		}
	}
	return nil
}

func (r *HiddenAPIFlagOutput) 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.AnnotationFlagsPath = nil
	} else {
		r.AnnotationFlagsPath = val2.(android.Path)
	}

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

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

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

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

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

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

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

	return err
}

var HiddenAPIFlagOutputGobRegId int16

func (r HiddenAPIFlagOutput) GetTypeId() int16 {
	return HiddenAPIFlagOutputGobRegId
}

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

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

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

func (r SignatureCsvSubset) CustomHash(hasher *proptools.Hasher) error {
	hasher.WriteString(":java.SignatureCsvSubset")
	hasher.WriteInt(2)
	hasher.WriteString(":java.android.Path")
	val1 := r.CsvFile == nil
	if val1 {
		hasher.WriteByte(0)
	} else {
		if v := reflect.ValueOf(r.CsvFile); v.Kind() == reflect.Ptr {
			if v.IsNil() {
				panic(fmt.Errorf("nil pointer is not supported in interface"))
			} else {
				val2 := r.CsvFile == nil
				if val2 {
					hasher.WriteByte(0)
				} else {
					val3 := func(hasher *proptools.Hasher) error { return r.CsvFile.(proptools.CustomHash).CustomHash(hasher) }
					if err := proptools.HashReference(hasher, uintptr(v.Pointer()), val3); err != nil {
						return err
					}
				}
			}
		} else {
			r.CsvFile.(proptools.CustomHash).CustomHash(hasher)
		}
	}
	hasher.WriteString(":java.android.Path")
	val4 := r.SignaturePatternsFile == nil
	if val4 {
		hasher.WriteByte(0)
	} else {
		if v := reflect.ValueOf(r.SignaturePatternsFile); v.Kind() == reflect.Ptr {
			if v.IsNil() {
				panic(fmt.Errorf("nil pointer is not supported in interface"))
			} else {
				val5 := r.SignaturePatternsFile == nil
				if val5 {
					hasher.WriteByte(0)
				} else {
					val6 := func(hasher *proptools.Hasher) error {
						return r.SignaturePatternsFile.(proptools.CustomHash).CustomHash(hasher)
					}
					if err := proptools.HashReference(hasher, uintptr(v.Pointer()), val6); err != nil {
						return err
					}
				}
			}
		} else {
			r.SignaturePatternsFile.(proptools.CustomHash).CustomHash(hasher)
		}
	}
	return nil
}

func (r *SignatureCsvSubset) 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.CsvFile = nil
	} else {
		r.CsvFile = val2.(android.Path)
	}

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

	return err
}

var SignatureCsvSubsetGobRegId int16

func (r SignatureCsvSubset) GetTypeId() int16 {
	return SignatureCsvSubsetGobRegId
}

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

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

func (r SignatureCsvSubsets) CustomHash(hasher *proptools.Hasher) error {
	hasher.WriteString(":.[]SignatureCsvSubset")
	hasher.WriteInt(len(r))
	for val1 := 0; val1 < len(r); val1++ {
		if err := r[val1].CustomHash(hasher); err != nil {
			return err
		}
	}
	return nil
}

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

	var val2 int
	err = gobtools.DecodeInt(buf, &val2)
	if err != nil {
		return err
	}
	if val2 != -1 {
		(*r) = make([]SignatureCsvSubset, val2)
		for val3 := 0; val3 < int(val2); val3++ {
			if err = (*r)[val3].Decode(ctx, buf); err != nil {
				return err
			}
		}
	}

	return err
}

var SignatureCsvSubsetsGobRegId int16

func (r SignatureCsvSubsets) GetTypeId() int16 {
	return SignatureCsvSubsetsGobRegId
}

// end of hiddenapi_modular.go

// begin of hiddenapi_monolithic.go
func init() {
	MonolithicHiddenAPIInfoGobRegId = gobtools.RegisterType(func() gobtools.CustomDec { return new(MonolithicHiddenAPIInfo) })
}

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

	if r.FlagsFilesByCategory == nil {
		if err = gobtools.EncodeInt(buf, -1); err != nil {
			return err
		}
	} else {
		if err = gobtools.EncodeInt(buf, len(r.FlagsFilesByCategory)); err != nil {
			return err
		}
		for val1, val2 := range r.FlagsFilesByCategory {
			if err = gobtools.EncodeInt(buf, int(val1)); err != nil {
				return err
			}
			if val2 == nil {
				if err = gobtools.EncodeInt(buf, -1); err != nil {
					return err
				}
			} else {
				if err = gobtools.EncodeInt(buf, len(val2)); err != nil {
					return err
				}
				for val3 := 0; val3 < len(val2); val3++ {
					if err = gobtools.EncodeInterface(ctx, buf, val2[val3]); err != nil {
						return err
					}
				}
			}
		}
	}

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

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

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

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

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

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

func (r MonolithicHiddenAPIInfo) CustomHash(hasher *proptools.Hasher) error {
	hasher.WriteString(":java.MonolithicHiddenAPIInfo")
	hasher.WriteInt(7)
	hasher.WriteString(":java.FlagFilesByCategory")
	hasher.WriteString(":.map[hiddenAPIFlagFileCategory]android.Paths")
	hasher.WriteInt(len(r.FlagsFilesByCategory))
	val1 := make([]hiddenAPIFlagFileCategory, 0, len(r.FlagsFilesByCategory))
	for val3 := range r.FlagsFilesByCategory {
		val1 = append(val1, val3)
	}
	proptools.SortOrdered(val1)
	for _, val2 := range val1 {
		hasher.WriteString(":java.hiddenAPIFlagFileCategory")
		hasher.WriteString(":.int")
		hasher.WriteUint64(uint64(int(val2)))
		hasher.WriteString(":java.android.Paths")
		hasher.WriteString(":.[]Path")
		hasher.WriteInt(len(r.FlagsFilesByCategory[val2]))
		for val4 := 0; val4 < len(r.FlagsFilesByCategory[val2]); val4++ {
			hasher.WriteString("android/soong/android:android.Path")
			val5 := r.FlagsFilesByCategory[val2][val4] == nil
			if val5 {
				hasher.WriteByte(0)
			} else {
				if v := reflect.ValueOf(r.FlagsFilesByCategory[val2][val4]); v.Kind() == reflect.Ptr {
					if v.IsNil() {
						panic(fmt.Errorf("nil pointer is not supported in interface"))
					} else {
						val6 := r.FlagsFilesByCategory[val2][val4] == nil
						if val6 {
							hasher.WriteByte(0)
						} else {
							val7 := func(hasher *proptools.Hasher) error {
								return r.FlagsFilesByCategory[val2][val4].(proptools.CustomHash).CustomHash(hasher)
							}
							if err := proptools.HashReference(hasher, uintptr(v.Pointer()), val7); err != nil {
								return err
							}
						}
					}
				} else {
					r.FlagsFilesByCategory[val2][val4].(proptools.CustomHash).CustomHash(hasher)
				}
			}
		}
	}
	hasher.WriteString(":java.android.Paths")
	hasher.WriteString(":.[]Path")
	hasher.WriteInt(len(r.AnnotationFlagsPaths))
	for val8 := 0; val8 < len(r.AnnotationFlagsPaths); val8++ {
		hasher.WriteString("android/soong/android:android.Path")
		val9 := r.AnnotationFlagsPaths[val8] == nil
		if val9 {
			hasher.WriteByte(0)
		} else {
			if v := reflect.ValueOf(r.AnnotationFlagsPaths[val8]); v.Kind() == reflect.Ptr {
				if v.IsNil() {
					panic(fmt.Errorf("nil pointer is not supported in interface"))
				} else {
					val10 := r.AnnotationFlagsPaths[val8] == nil
					if val10 {
						hasher.WriteByte(0)
					} else {
						val11 := func(hasher *proptools.Hasher) error {
							return r.AnnotationFlagsPaths[val8].(proptools.CustomHash).CustomHash(hasher)
						}
						if err := proptools.HashReference(hasher, uintptr(v.Pointer()), val11); err != nil {
							return err
						}
					}
				}
			} else {
				r.AnnotationFlagsPaths[val8].(proptools.CustomHash).CustomHash(hasher)
			}
		}
	}
	hasher.WriteString(":java.android.Paths")
	hasher.WriteString(":.[]Path")
	hasher.WriteInt(len(r.MetadataPaths))
	for val12 := 0; val12 < len(r.MetadataPaths); val12++ {
		hasher.WriteString("android/soong/android:android.Path")
		val13 := r.MetadataPaths[val12] == nil
		if val13 {
			hasher.WriteByte(0)
		} else {
			if v := reflect.ValueOf(r.MetadataPaths[val12]); v.Kind() == reflect.Ptr {
				if v.IsNil() {
					panic(fmt.Errorf("nil pointer is not supported in interface"))
				} else {
					val14 := r.MetadataPaths[val12] == nil
					if val14 {
						hasher.WriteByte(0)
					} else {
						val15 := func(hasher *proptools.Hasher) error {
							return r.MetadataPaths[val12].(proptools.CustomHash).CustomHash(hasher)
						}
						if err := proptools.HashReference(hasher, uintptr(v.Pointer()), val15); err != nil {
							return err
						}
					}
				}
			} else {
				r.MetadataPaths[val12].(proptools.CustomHash).CustomHash(hasher)
			}
		}
	}
	hasher.WriteString(":java.android.Paths")
	hasher.WriteString(":.[]Path")
	hasher.WriteInt(len(r.IndexPaths))
	for val16 := 0; val16 < len(r.IndexPaths); val16++ {
		hasher.WriteString("android/soong/android:android.Path")
		val17 := r.IndexPaths[val16] == nil
		if val17 {
			hasher.WriteByte(0)
		} else {
			if v := reflect.ValueOf(r.IndexPaths[val16]); v.Kind() == reflect.Ptr {
				if v.IsNil() {
					panic(fmt.Errorf("nil pointer is not supported in interface"))
				} else {
					val18 := r.IndexPaths[val16] == nil
					if val18 {
						hasher.WriteByte(0)
					} else {
						val19 := func(hasher *proptools.Hasher) error {
							return r.IndexPaths[val16].(proptools.CustomHash).CustomHash(hasher)
						}
						if err := proptools.HashReference(hasher, uintptr(v.Pointer()), val19); err != nil {
							return err
						}
					}
				}
			} else {
				r.IndexPaths[val16].(proptools.CustomHash).CustomHash(hasher)
			}
		}
	}
	hasher.WriteString(":java.SignatureCsvSubsets")
	hasher.WriteString(":.[]SignatureCsvSubset")
	hasher.WriteInt(len(r.StubFlagSubsets))
	for val20 := 0; val20 < len(r.StubFlagSubsets); val20++ {
		if err := r.StubFlagSubsets[val20].CustomHash(hasher); err != nil {
			return err
		}
	}
	hasher.WriteString(":java.SignatureCsvSubsets")
	hasher.WriteString(":.[]SignatureCsvSubset")
	hasher.WriteInt(len(r.FlagSubsets))
	for val21 := 0; val21 < len(r.FlagSubsets); val21++ {
		if err := r.FlagSubsets[val21].CustomHash(hasher); err != nil {
			return err
		}
	}
	hasher.WriteString(":java.android.Paths")
	hasher.WriteString(":.[]Path")
	hasher.WriteInt(len(r.ClassesJars))
	for val22 := 0; val22 < len(r.ClassesJars); val22++ {
		hasher.WriteString("android/soong/android:android.Path")
		val23 := r.ClassesJars[val22] == nil
		if val23 {
			hasher.WriteByte(0)
		} else {
			if v := reflect.ValueOf(r.ClassesJars[val22]); v.Kind() == reflect.Ptr {
				if v.IsNil() {
					panic(fmt.Errorf("nil pointer is not supported in interface"))
				} else {
					val24 := r.ClassesJars[val22] == nil
					if val24 {
						hasher.WriteByte(0)
					} else {
						val25 := func(hasher *proptools.Hasher) error {
							return r.ClassesJars[val22].(proptools.CustomHash).CustomHash(hasher)
						}
						if err := proptools.HashReference(hasher, uintptr(v.Pointer()), val25); err != nil {
							return err
						}
					}
				}
			} else {
				r.ClassesJars[val22].(proptools.CustomHash).CustomHash(hasher)
			}
		}
	}
	return nil
}

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

	var val2 int
	err = gobtools.DecodeInt(buf, &val2)
	if err != nil {
		return err
	}
	if val2 != -1 {
		r.FlagsFilesByCategory = make(map[hiddenAPIFlagFileCategory]android.Paths, val2)
		for val3 := 0; val3 < int(val2); val3++ {
			var val4 hiddenAPIFlagFileCategory
			var val5 android.Paths
			var val7 int
			err = gobtools.DecodeInt(buf, &val7)
			if err != nil {
				return err
			}
			val4 = hiddenAPIFlagFileCategory(val7)
			var val11 int
			err = gobtools.DecodeInt(buf, &val11)
			if err != nil {
				return err
			}
			if val11 != -1 {
				val5 = make([]android.Path, val11)
				for val12 := 0; val12 < int(val11); val12++ {
					if val14, err := gobtools.DecodeInterface(ctx, buf); err != nil {
						return err
					} else if val14 == nil {
						val5[val12] = nil
					} else {
						val5[val12] = val14.(android.Path)
					}
				}
			}
			r.FlagsFilesByCategory[val4] = val5
		}
	}

	var val17 int
	err = gobtools.DecodeInt(buf, &val17)
	if err != nil {
		return err
	}
	if val17 != -1 {
		r.AnnotationFlagsPaths = make([]android.Path, val17)
		for val18 := 0; val18 < int(val17); val18++ {
			if val20, err := gobtools.DecodeInterface(ctx, buf); err != nil {
				return err
			} else if val20 == nil {
				r.AnnotationFlagsPaths[val18] = nil
			} else {
				r.AnnotationFlagsPaths[val18] = val20.(android.Path)
			}
		}
	}

	var val23 int
	err = gobtools.DecodeInt(buf, &val23)
	if err != nil {
		return err
	}
	if val23 != -1 {
		r.MetadataPaths = make([]android.Path, val23)
		for val24 := 0; val24 < int(val23); val24++ {
			if val26, err := gobtools.DecodeInterface(ctx, buf); err != nil {
				return err
			} else if val26 == nil {
				r.MetadataPaths[val24] = nil
			} else {
				r.MetadataPaths[val24] = val26.(android.Path)
			}
		}
	}

	var val29 int
	err = gobtools.DecodeInt(buf, &val29)
	if err != nil {
		return err
	}
	if val29 != -1 {
		r.IndexPaths = make([]android.Path, val29)
		for val30 := 0; val30 < int(val29); val30++ {
			if val32, err := gobtools.DecodeInterface(ctx, buf); err != nil {
				return err
			} else if val32 == nil {
				r.IndexPaths[val30] = nil
			} else {
				r.IndexPaths[val30] = val32.(android.Path)
			}
		}
	}

	var val35 int
	err = gobtools.DecodeInt(buf, &val35)
	if err != nil {
		return err
	}
	if val35 != -1 {
		r.StubFlagSubsets = make([]SignatureCsvSubset, val35)
		for val36 := 0; val36 < int(val35); val36++ {
			if err = r.StubFlagSubsets[val36].Decode(ctx, buf); err != nil {
				return err
			}
		}
	}

	var val40 int
	err = gobtools.DecodeInt(buf, &val40)
	if err != nil {
		return err
	}
	if val40 != -1 {
		r.FlagSubsets = make([]SignatureCsvSubset, val40)
		for val41 := 0; val41 < int(val40); val41++ {
			if err = r.FlagSubsets[val41].Decode(ctx, buf); err != nil {
				return err
			}
		}
	}

	var val45 int
	err = gobtools.DecodeInt(buf, &val45)
	if err != nil {
		return err
	}
	if val45 != -1 {
		r.ClassesJars = make([]android.Path, val45)
		for val46 := 0; val46 < int(val45); val46++ {
			if val48, err := gobtools.DecodeInterface(ctx, buf); err != nil {
				return err
			} else if val48 == nil {
				r.ClassesJars[val46] = nil
			} else {
				r.ClassesJars[val46] = val48.(android.Path)
			}
		}
	}

	return err
}

var MonolithicHiddenAPIInfoGobRegId int16

func (r MonolithicHiddenAPIInfo) GetTypeId() int16 {
	return MonolithicHiddenAPIInfoGobRegId
}

// end of hiddenapi_monolithic.go

// begin of jacoco.go
func init() {
	JacocoInfoGobRegId = gobtools.RegisterType(func() gobtools.CustomDec { return new(JacocoInfo) })
	JacocoInfosGobRegId = gobtools.RegisterType(func() gobtools.CustomDec { return new(JacocoInfos) })
}

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

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

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

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

func (r JacocoInfo) CustomHash(hasher *proptools.Hasher) error {
	hasher.WriteString(":java.JacocoInfo")
	hasher.WriteInt(3)
	hasher.WriteString(":java.android.Path")
	val1 := r.ReportClassesFile == nil
	if val1 {
		hasher.WriteByte(0)
	} else {
		if v := reflect.ValueOf(r.ReportClassesFile); v.Kind() == reflect.Ptr {
			if v.IsNil() {
				panic(fmt.Errorf("nil pointer is not supported in interface"))
			} else {
				val2 := r.ReportClassesFile == nil
				if val2 {
					hasher.WriteByte(0)
				} else {
					val3 := func(hasher *proptools.Hasher) error {
						return r.ReportClassesFile.(proptools.CustomHash).CustomHash(hasher)
					}
					if err := proptools.HashReference(hasher, uintptr(v.Pointer()), val3); err != nil {
						return err
					}
				}
			}
		} else {
			r.ReportClassesFile.(proptools.CustomHash).CustomHash(hasher)
		}
	}
	hasher.WriteString(":.string")
	hasher.WriteString(r.Class)
	hasher.WriteString(":.string")
	hasher.WriteString(r.ModuleName)
	return nil
}

func (r *JacocoInfo) 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.ReportClassesFile = nil
	} else {
		r.ReportClassesFile = val2.(android.Path)
	}

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

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

	return err
}

var JacocoInfoGobRegId int16

func (r JacocoInfo) GetTypeId() int16 {
	return JacocoInfoGobRegId
}

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

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

func (r JacocoInfos) CustomHash(hasher *proptools.Hasher) error {
	hasher.WriteString(":.[]JacocoInfo")
	hasher.WriteInt(len(r))
	for val1 := 0; val1 < len(r); val1++ {
		if err := r[val1].CustomHash(hasher); err != nil {
			return err
		}
	}
	return nil
}

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

	var val2 int
	err = gobtools.DecodeInt(buf, &val2)
	if err != nil {
		return err
	}
	if val2 != -1 {
		(*r) = make([]JacocoInfo, val2)
		for val3 := 0; val3 < int(val2); val3++ {
			if err = (*r)[val3].Decode(ctx, buf); err != nil {
				return err
			}
		}
	}

	return err
}

var JacocoInfosGobRegId int16

func (r JacocoInfos) GetTypeId() int16 {
	return JacocoInfosGobRegId
}

// end of jacoco.go

// begin of java.go
func init() {
	ProguardSpecInfoGobRegId = gobtools.RegisterType(func() gobtools.CustomDec { return new(ProguardSpecInfo) })
	AndroidLibraryDependencyInfoGobRegId = gobtools.RegisterType(func() gobtools.CustomDec { return new(AndroidLibraryDependencyInfo) })
	UsesLibraryDependencyInfoGobRegId = gobtools.RegisterType(func() gobtools.CustomDec { return new(UsesLibraryDependencyInfo) })
	ProvidesUsesLibInfoGobRegId = gobtools.RegisterType(func() gobtools.CustomDec { return new(ProvidesUsesLibInfo) })
	ModuleWithSdkDepInfoGobRegId = gobtools.RegisterType(func() gobtools.CustomDec { return new(ModuleWithSdkDepInfo) })
	ApexDependencyInfoGobRegId = gobtools.RegisterType(func() gobtools.CustomDec { return new(ApexDependencyInfo) })
	JavaInfoGobRegId = gobtools.RegisterType(func() gobtools.CustomDec { return new(JavaInfo) })
	DexpreopterInfoGobRegId = gobtools.RegisterType(func() gobtools.CustomDec { return new(DexpreopterInfo) })
	JavaLibraryInfoGobRegId = gobtools.RegisterType(func() gobtools.CustomDec { return new(JavaLibraryInfo) })
	JavaDexImportInfoGobRegId = gobtools.RegisterType(func() gobtools.CustomDec { return new(JavaDexImportInfo) })
	SyspropPublicStubInfoGobRegId = gobtools.RegisterType(func() gobtools.CustomDec { return new(SyspropPublicStubInfo) })
	jniLibGobRegId = gobtools.RegisterType(func() gobtools.CustomDec { return new(jniLib) })
	JavaTestInfoGobRegId = gobtools.RegisterType(func() gobtools.CustomDec { return new(JavaTestInfo) })
	JavaApiImportInfoGobRegId = gobtools.RegisterType(func() gobtools.CustomDec { return new(JavaApiImportInfo) })
	JavaImportDepInSameApexCheckerGobRegId = gobtools.RegisterType(func() gobtools.CustomDec { return new(JavaImportDepInSameApexChecker) })
}

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

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

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

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

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

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

func (r ProguardSpecInfo) CustomHash(hasher *proptools.Hasher) error {
	hasher.WriteString(":java.ProguardSpecInfo")
	hasher.WriteInt(5)
	hasher.WriteString(":.bool")
	if r.Export_proguard_flags_files {
		hasher.WriteByte(1)
	} else {
		hasher.WriteByte(0)
	}
	val5 := func(hasher *proptools.Hasher, val1 android.Path) error {
		hasher.WriteString(":java.android.Path")
		val2 := val1 == nil
		if val2 {
			hasher.WriteByte(0)
		} else {
			if v := reflect.ValueOf(val1); v.Kind() == reflect.Ptr {
				if v.IsNil() {
					panic(fmt.Errorf("nil pointer is not supported in interface"))
				} else {
					val3 := val1 == nil
					if val3 {
						hasher.WriteByte(0)
					} else {
						val4 := func(hasher *proptools.Hasher) error { return val1.(proptools.CustomHash).CustomHash(hasher) }
						if err := proptools.HashReference(hasher, uintptr(v.Pointer()), val4); err != nil {
							return err
						}
					}
				}
			} else {
				val1.(proptools.CustomHash).CustomHash(hasher)
			}
		}
		return nil
	}
	if err := r.ProguardFlagsFiles.Hash(hasher, "android.Path", val5); err != nil {
		return err
	}
	val10 := func(hasher *proptools.Hasher, val6 android.Path) error {
		hasher.WriteString(":java.android.Path")
		val7 := val6 == nil
		if val7 {
			hasher.WriteByte(0)
		} else {
			if v := reflect.ValueOf(val6); v.Kind() == reflect.Ptr {
				if v.IsNil() {
					panic(fmt.Errorf("nil pointer is not supported in interface"))
				} else {
					val8 := val6 == nil
					if val8 {
						hasher.WriteByte(0)
					} else {
						val9 := func(hasher *proptools.Hasher) error { return val6.(proptools.CustomHash).CustomHash(hasher) }
						if err := proptools.HashReference(hasher, uintptr(v.Pointer()), val9); err != nil {
							return err
						}
					}
				}
			} else {
				val6.(proptools.CustomHash).CustomHash(hasher)
			}
		}
		return nil
	}
	if err := r.IncludedProguardFlagsFiles.Hash(hasher, "android.Path", val10); err != nil {
		return err
	}
	val15 := func(hasher *proptools.Hasher, val11 android.Path) error {
		hasher.WriteString(":java.android.Path")
		val12 := val11 == nil
		if val12 {
			hasher.WriteByte(0)
		} else {
			if v := reflect.ValueOf(val11); v.Kind() == reflect.Ptr {
				if v.IsNil() {
					panic(fmt.Errorf("nil pointer is not supported in interface"))
				} else {
					val13 := val11 == nil
					if val13 {
						hasher.WriteByte(0)
					} else {
						val14 := func(hasher *proptools.Hasher) error { return val11.(proptools.CustomHash).CustomHash(hasher) }
						if err := proptools.HashReference(hasher, uintptr(v.Pointer()), val14); err != nil {
							return err
						}
					}
				}
			} else {
				val11.(proptools.CustomHash).CustomHash(hasher)
			}
		}
		return nil
	}
	if err := r.UnconditionallyExportedProguardFlags.Hash(hasher, "android.Path", val15); err != nil {
		return err
	}
	val20 := func(hasher *proptools.Hasher, val16 android.Path) error {
		hasher.WriteString(":java.android.Path")
		val17 := val16 == nil
		if val17 {
			hasher.WriteByte(0)
		} else {
			if v := reflect.ValueOf(val16); v.Kind() == reflect.Ptr {
				if v.IsNil() {
					panic(fmt.Errorf("nil pointer is not supported in interface"))
				} else {
					val18 := val16 == nil
					if val18 {
						hasher.WriteByte(0)
					} else {
						val19 := func(hasher *proptools.Hasher) error { return val16.(proptools.CustomHash).CustomHash(hasher) }
						if err := proptools.HashReference(hasher, uintptr(v.Pointer()), val19); err != nil {
							return err
						}
					}
				}
			} else {
				val16.(proptools.CustomHash).CustomHash(hasher)
			}
		}
		return nil
	}
	if err := r.IncludedUnconditionallyExportedProguardFlags.Hash(hasher, "android.Path", val20); err != nil {
		return err
	}
	return nil
}

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

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

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

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

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

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

	return err
}

var ProguardSpecInfoGobRegId int16

func (r ProguardSpecInfo) GetTypeId() int16 {
	return ProguardSpecInfoGobRegId
}

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

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

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

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

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

func (r AndroidLibraryDependencyInfo) CustomHash(hasher *proptools.Hasher) error {
	hasher.WriteString(":java.AndroidLibraryDependencyInfo")
	hasher.WriteInt(4)
	hasher.WriteString(":java.android.Path")
	val1 := r.ExportPackage == nil
	if val1 {
		hasher.WriteByte(0)
	} else {
		if v := reflect.ValueOf(r.ExportPackage); v.Kind() == reflect.Ptr {
			if v.IsNil() {
				panic(fmt.Errorf("nil pointer is not supported in interface"))
			} else {
				val2 := r.ExportPackage == nil
				if val2 {
					hasher.WriteByte(0)
				} else {
					val3 := func(hasher *proptools.Hasher) error { return r.ExportPackage.(proptools.CustomHash).CustomHash(hasher) }
					if err := proptools.HashReference(hasher, uintptr(v.Pointer()), val3); err != nil {
						return err
					}
				}
			}
		} else {
			r.ExportPackage.(proptools.CustomHash).CustomHash(hasher)
		}
	}
	val5 := func(hasher *proptools.Hasher, val4 resourcesNode) error {
		if err := val4.CustomHash(hasher); err != nil {
			return err
		}
		return nil
	}
	if err := r.ResourcesNodeDepSet.Hash(hasher, "resourcesNode", val5); err != nil {
		return err
	}
	val7 := func(hasher *proptools.Hasher, val6 rroDir) error {
		if err := val6.CustomHash(hasher); err != nil {
			return err
		}
		return nil
	}
	if err := r.RRODirsDepSet.Hash(hasher, "rroDir", val7); err != nil {
		return err
	}
	val12 := func(hasher *proptools.Hasher, val8 android.Path) error {
		hasher.WriteString(":java.android.Path")
		val9 := val8 == nil
		if val9 {
			hasher.WriteByte(0)
		} else {
			if v := reflect.ValueOf(val8); v.Kind() == reflect.Ptr {
				if v.IsNil() {
					panic(fmt.Errorf("nil pointer is not supported in interface"))
				} else {
					val10 := val8 == nil
					if val10 {
						hasher.WriteByte(0)
					} else {
						val11 := func(hasher *proptools.Hasher) error { return val8.(proptools.CustomHash).CustomHash(hasher) }
						if err := proptools.HashReference(hasher, uintptr(v.Pointer()), val11); err != nil {
							return err
						}
					}
				}
			} else {
				val8.(proptools.CustomHash).CustomHash(hasher)
			}
		}
		return nil
	}
	if err := r.ManifestsDepSet.Hash(hasher, "android.Path", val12); err != nil {
		return err
	}
	return nil
}

func (r *AndroidLibraryDependencyInfo) 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.ExportPackage = nil
	} else {
		r.ExportPackage = val2.(android.Path)
	}

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

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

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

	return err
}

var AndroidLibraryDependencyInfoGobRegId int16

func (r AndroidLibraryDependencyInfo) GetTypeId() int16 {
	return AndroidLibraryDependencyInfoGobRegId
}

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

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

	if r.ClassLoaderContexts == nil {
		if err = gobtools.EncodeInt(buf, -1); err != nil {
			return err
		}
	} else {
		if err = gobtools.EncodeInt(buf, len(r.ClassLoaderContexts)); err != nil {
			return err
		}
		for val1, val2 := range r.ClassLoaderContexts {
			if err = gobtools.EncodeInt(buf, val1); err != nil {
				return err
			}
			if val2 == nil {
				if err = gobtools.EncodeInt(buf, -1); err != nil {
					return err
				}
			} else {
				if err = gobtools.EncodeInt(buf, len(val2)); err != nil {
					return err
				}
				for val3 := 0; val3 < len(val2); val3++ {
					val4 := val2[val3] == nil
					if err = gobtools.EncodeBool(buf, val4); err != nil {
						return err
					}
					if !val4 {
						if err = (*val2[val3]).Encode(ctx, buf); err != nil {
							return err
						}
					}
				}
			}
		}
	}
	return err
}

func (r UsesLibraryDependencyInfo) CustomHash(hasher *proptools.Hasher) error {
	hasher.WriteString(":java.UsesLibraryDependencyInfo")
	hasher.WriteInt(2)
	hasher.WriteString(":java.android.Path")
	val1 := r.DexJarInstallPath == nil
	if val1 {
		hasher.WriteByte(0)
	} else {
		if v := reflect.ValueOf(r.DexJarInstallPath); v.Kind() == reflect.Ptr {
			if v.IsNil() {
				panic(fmt.Errorf("nil pointer is not supported in interface"))
			} else {
				val2 := r.DexJarInstallPath == nil
				if val2 {
					hasher.WriteByte(0)
				} else {
					val3 := func(hasher *proptools.Hasher) error {
						return r.DexJarInstallPath.(proptools.CustomHash).CustomHash(hasher)
					}
					if err := proptools.HashReference(hasher, uintptr(v.Pointer()), val3); err != nil {
						return err
					}
				}
			}
		} else {
			r.DexJarInstallPath.(proptools.CustomHash).CustomHash(hasher)
		}
	}
	hasher.WriteString(":java.dexpreopt.ClassLoaderContextMap")
	hasher.WriteString(":.map[int][]*ClassLoaderContext")
	hasher.WriteInt(len(r.ClassLoaderContexts))
	val4 := make([]int, 0, len(r.ClassLoaderContexts))
	for val6 := range r.ClassLoaderContexts {
		val4 = append(val4, val6)
	}
	proptools.SortOrdered(val4)
	for _, val5 := range val4 {
		hasher.WriteString(":.int")
		hasher.WriteUint64(uint64(val5))
		hasher.WriteString(":.[]*ClassLoaderContext")
		hasher.WriteInt(len(r.ClassLoaderContexts[val5]))
		for val7 := 0; val7 < len(r.ClassLoaderContexts[val5]); val7++ {
			hasher.WriteString(":.*ClassLoaderContext")
			val8 := r.ClassLoaderContexts[val5][val7] == nil
			if val8 {
				hasher.WriteByte(0)
			} else {
				val9 := func(hasher *proptools.Hasher) error {
					if err := (*r.ClassLoaderContexts[val5][val7]).CustomHash(hasher); err != nil {
						return err
					}
					return nil
				}
				if err := proptools.HashReference(hasher, uintptr(unsafe.Pointer(r.ClassLoaderContexts[val5][val7])), val9); err != nil {
					return err
				}
			}
		}
	}
	return nil
}

func (r *UsesLibraryDependencyInfo) 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.DexJarInstallPath = nil
	} else {
		r.DexJarInstallPath = val2.(android.Path)
	}

	var val4 int
	err = gobtools.DecodeInt(buf, &val4)
	if err != nil {
		return err
	}
	if val4 != -1 {
		r.ClassLoaderContexts = make(map[int][]*dexpreopt.ClassLoaderContext, val4)
		for val5 := 0; val5 < int(val4); val5++ {
			var val6 int
			var val7 []*dexpreopt.ClassLoaderContext
			err = gobtools.DecodeInt(buf, &val6)
			if err != nil {
				return err
			}
			var val10 int
			err = gobtools.DecodeInt(buf, &val10)
			if err != nil {
				return err
			}
			if val10 != -1 {
				val7 = make([]*dexpreopt.ClassLoaderContext, val10)
				for val11 := 0; val11 < int(val10); val11++ {
					var val13 bool
					if err = gobtools.DecodeBool(buf, &val13); err != nil {
						return err
					}
					if !val13 {
						var val12 dexpreopt.ClassLoaderContext
						if err = val12.Decode(ctx, buf); err != nil {
							return err
						}
						val7[val11] = &val12
					}
				}
			}
			r.ClassLoaderContexts[val6] = val7
		}
	}

	return err
}

var UsesLibraryDependencyInfoGobRegId int16

func (r UsesLibraryDependencyInfo) GetTypeId() int16 {
	return UsesLibraryDependencyInfoGobRegId
}

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

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

func (r ProvidesUsesLibInfo) CustomHash(hasher *proptools.Hasher) error {
	hasher.WriteString(":java.ProvidesUsesLibInfo")
	hasher.WriteInt(1)
	hasher.WriteString(":.*string")
	val1 := r.ProvidesUsesLib == nil
	if val1 {
		hasher.WriteByte(0)
	} else {
		val2 := func(hasher *proptools.Hasher) error {
			hasher.WriteString(":.string")
			hasher.WriteString((*r.ProvidesUsesLib))
			return nil
		}
		if err := proptools.HashReference(hasher, uintptr(unsafe.Pointer(r.ProvidesUsesLib)), val2); err != nil {
			return err
		}
	}
	return nil
}

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

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

	return err
}

var ProvidesUsesLibInfoGobRegId int16

func (r ProvidesUsesLibInfo) GetTypeId() int16 {
	return ProvidesUsesLibInfoGobRegId
}

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

	if err = gobtools.EncodeInt(buf, int(r.SdkLinkType)); err != nil {
		return err
	}

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

func (r ModuleWithSdkDepInfo) CustomHash(hasher *proptools.Hasher) error {
	hasher.WriteString(":java.ModuleWithSdkDepInfo")
	hasher.WriteInt(2)
	hasher.WriteString(":java.sdkLinkType")
	hasher.WriteString(":.int")
	hasher.WriteUint64(uint64(int(r.SdkLinkType)))
	hasher.WriteString(":.bool")
	if r.Stubs {
		hasher.WriteByte(1)
	} else {
		hasher.WriteByte(0)
	}
	return nil
}

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

	var val2 int
	err = gobtools.DecodeInt(buf, &val2)
	if err != nil {
		return err
	}
	r.SdkLinkType = sdkLinkType(val2)

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

	return err
}

var ModuleWithSdkDepInfoGobRegId int16

func (r ModuleWithSdkDepInfo) GetTypeId() int16 {
	return ModuleWithSdkDepInfoGobRegId
}

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

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

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

func (r ApexDependencyInfo) CustomHash(hasher *proptools.Hasher) error {
	hasher.WriteString(":java.ApexDependencyInfo")
	hasher.WriteInt(2)
	hasher.WriteString(":java.android.Paths")
	hasher.WriteString(":.[]Path")
	hasher.WriteInt(len(r.HeaderJars))
	for val1 := 0; val1 < len(r.HeaderJars); val1++ {
		hasher.WriteString("android/soong/android:android.Path")
		val2 := r.HeaderJars[val1] == nil
		if val2 {
			hasher.WriteByte(0)
		} else {
			if v := reflect.ValueOf(r.HeaderJars[val1]); v.Kind() == reflect.Ptr {
				if v.IsNil() {
					panic(fmt.Errorf("nil pointer is not supported in interface"))
				} else {
					val3 := r.HeaderJars[val1] == nil
					if val3 {
						hasher.WriteByte(0)
					} else {
						val4 := func(hasher *proptools.Hasher) error {
							return r.HeaderJars[val1].(proptools.CustomHash).CustomHash(hasher)
						}
						if err := proptools.HashReference(hasher, uintptr(v.Pointer()), val4); err != nil {
							return err
						}
					}
				}
			} else {
				r.HeaderJars[val1].(proptools.CustomHash).CustomHash(hasher)
			}
		}
	}
	hasher.WriteString(":java.android.Paths")
	hasher.WriteString(":.[]Path")
	hasher.WriteInt(len(r.ImplementationAndResourcesJars))
	for val5 := 0; val5 < len(r.ImplementationAndResourcesJars); val5++ {
		hasher.WriteString("android/soong/android:android.Path")
		val6 := r.ImplementationAndResourcesJars[val5] == nil
		if val6 {
			hasher.WriteByte(0)
		} else {
			if v := reflect.ValueOf(r.ImplementationAndResourcesJars[val5]); v.Kind() == reflect.Ptr {
				if v.IsNil() {
					panic(fmt.Errorf("nil pointer is not supported in interface"))
				} else {
					val7 := r.ImplementationAndResourcesJars[val5] == nil
					if val7 {
						hasher.WriteByte(0)
					} else {
						val8 := func(hasher *proptools.Hasher) error {
							return r.ImplementationAndResourcesJars[val5].(proptools.CustomHash).CustomHash(hasher)
						}
						if err := proptools.HashReference(hasher, uintptr(v.Pointer()), val8); err != nil {
							return err
						}
					}
				}
			} else {
				r.ImplementationAndResourcesJars[val5].(proptools.CustomHash).CustomHash(hasher)
			}
		}
	}
	return nil
}

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

	var val3 int
	err = gobtools.DecodeInt(buf, &val3)
	if err != nil {
		return err
	}
	if val3 != -1 {
		r.HeaderJars = 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.HeaderJars[val4] = nil
			} else {
				r.HeaderJars[val4] = val6.(android.Path)
			}
		}
	}

	var val9 int
	err = gobtools.DecodeInt(buf, &val9)
	if err != nil {
		return err
	}
	if val9 != -1 {
		r.ImplementationAndResourcesJars = 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.ImplementationAndResourcesJars[val10] = nil
			} else {
				r.ImplementationAndResourcesJars[val10] = val12.(android.Path)
			}
		}
	}

	return err
}

var ApexDependencyInfoGobRegId int16

func (r ApexDependencyInfo) GetTypeId() int16 {
	return ApexDependencyInfoGobRegId
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

	if r.KSnapshotFiles == nil {
		if err = gobtools.EncodeInt(buf, -1); err != nil {
			return err
		}
	} else {
		if err = gobtools.EncodeInt(buf, len(r.KSnapshotFiles)); err != nil {
			return err
		}
		for val12, val13 := range r.KSnapshotFiles {
			if err = gobtools.EncodeString(buf, val12); err != nil {
				return err
			}
			if err = gobtools.EncodeInterface(ctx, buf, val13); err != nil {
				return err
			}
		}
	}

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

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

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

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

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

	if err = gobtools.EncodeInt(buf, int(r.StubsLinkType)); err != nil {
		return err
	}

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

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

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

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

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

	val19 := r.UsesLibraryDependencyInfo == nil
	if err = gobtools.EncodeBool(buf, val19); err != nil {
		return err
	}
	if !val19 {
		if err = (*r.UsesLibraryDependencyInfo).Encode(ctx, buf); err != nil {
			return err
		}
	}

	val20 := r.ProvidesUsesLibInfo == nil
	if err = gobtools.EncodeBool(buf, val20); err != nil {
		return err
	}
	if !val20 {
		if err = (*r.ProvidesUsesLibInfo).Encode(ctx, buf); err != nil {
			return err
		}
	}

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

	val22 := r.ModuleWithSdkDepInfo == nil
	if err = gobtools.EncodeBool(buf, val22); err != nil {
		return err
	}
	if !val22 {
		if err = (*r.ModuleWithSdkDepInfo).Encode(ctx, buf); err != nil {
			return err
		}
	}

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

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

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

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

	val24 := r.UncompressDexState == nil
	if err = gobtools.EncodeBool(buf, val24); err != nil {
		return err
	}
	if !val24 {
		if err = gobtools.EncodeBool(buf, (*r.UncompressDexState)); err != nil {
			return err
		}
	}

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

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

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

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

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

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

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

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

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

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

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

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

	val28 := r.DexpreopterInfo == nil
	if err = gobtools.EncodeBool(buf, val28); err != nil {
		return err
	}
	if !val28 {
		if err = (*r.DexpreopterInfo).Encode(ctx, buf); err != nil {
			return err
		}
	}

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

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

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

	val31 := r.CompileDex == nil
	if err = gobtools.EncodeBool(buf, val31); err != nil {
		return err
	}
	if !val31 {
		if err = gobtools.EncodeBool(buf, (*r.CompileDex)); err != nil {
			return err
		}
	}

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

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

	val32 := r.ApexDependencyInfo == nil
	if err = gobtools.EncodeBool(buf, val32); err != nil {
		return err
	}
	if !val32 {
		if err = (*r.ApexDependencyInfo).Encode(ctx, buf); err != nil {
			return err
		}
	}

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

func (r JavaInfo) CustomHash(hasher *proptools.Hasher) error {
	hasher.WriteString(":java.JavaInfo")
	hasher.WriteInt(58)
	hasher.WriteString(":java.android.Paths")
	hasher.WriteString(":.[]Path")
	hasher.WriteInt(len(r.HeaderJars))
	for val1 := 0; val1 < len(r.HeaderJars); val1++ {
		hasher.WriteString("android/soong/android:android.Path")
		val2 := r.HeaderJars[val1] == nil
		if val2 {
			hasher.WriteByte(0)
		} else {
			if v := reflect.ValueOf(r.HeaderJars[val1]); v.Kind() == reflect.Ptr {
				if v.IsNil() {
					panic(fmt.Errorf("nil pointer is not supported in interface"))
				} else {
					val3 := r.HeaderJars[val1] == nil
					if val3 {
						hasher.WriteByte(0)
					} else {
						val4 := func(hasher *proptools.Hasher) error {
							return r.HeaderJars[val1].(proptools.CustomHash).CustomHash(hasher)
						}
						if err := proptools.HashReference(hasher, uintptr(v.Pointer()), val4); err != nil {
							return err
						}
					}
				}
			} else {
				r.HeaderJars[val1].(proptools.CustomHash).CustomHash(hasher)
			}
		}
	}
	hasher.WriteString(":java.android.Paths")
	hasher.WriteString(":.[]Path")
	hasher.WriteInt(len(r.RepackagedHeaderJars))
	for val5 := 0; val5 < len(r.RepackagedHeaderJars); val5++ {
		hasher.WriteString("android/soong/android:android.Path")
		val6 := r.RepackagedHeaderJars[val5] == nil
		if val6 {
			hasher.WriteByte(0)
		} else {
			if v := reflect.ValueOf(r.RepackagedHeaderJars[val5]); v.Kind() == reflect.Ptr {
				if v.IsNil() {
					panic(fmt.Errorf("nil pointer is not supported in interface"))
				} else {
					val7 := r.RepackagedHeaderJars[val5] == nil
					if val7 {
						hasher.WriteByte(0)
					} else {
						val8 := func(hasher *proptools.Hasher) error {
							return r.RepackagedHeaderJars[val5].(proptools.CustomHash).CustomHash(hasher)
						}
						if err := proptools.HashReference(hasher, uintptr(v.Pointer()), val8); err != nil {
							return err
						}
					}
				}
			} else {
				r.RepackagedHeaderJars[val5].(proptools.CustomHash).CustomHash(hasher)
			}
		}
	}
	hasher.WriteString(":java.android.Paths")
	hasher.WriteString(":.[]Path")
	hasher.WriteInt(len(r.LocalHeaderJarsPreJarjar))
	for val9 := 0; val9 < len(r.LocalHeaderJarsPreJarjar); val9++ {
		hasher.WriteString("android/soong/android:android.Path")
		val10 := r.LocalHeaderJarsPreJarjar[val9] == nil
		if val10 {
			hasher.WriteByte(0)
		} else {
			if v := reflect.ValueOf(r.LocalHeaderJarsPreJarjar[val9]); v.Kind() == reflect.Ptr {
				if v.IsNil() {
					panic(fmt.Errorf("nil pointer is not supported in interface"))
				} else {
					val11 := r.LocalHeaderJarsPreJarjar[val9] == nil
					if val11 {
						hasher.WriteByte(0)
					} else {
						val12 := func(hasher *proptools.Hasher) error {
							return r.LocalHeaderJarsPreJarjar[val9].(proptools.CustomHash).CustomHash(hasher)
						}
						if err := proptools.HashReference(hasher, uintptr(v.Pointer()), val12); err != nil {
							return err
						}
					}
				}
			} else {
				r.LocalHeaderJarsPreJarjar[val9].(proptools.CustomHash).CustomHash(hasher)
			}
		}
	}
	val17 := func(hasher *proptools.Hasher, val13 android.Path) error {
		hasher.WriteString(":java.android.Path")
		val14 := val13 == nil
		if val14 {
			hasher.WriteByte(0)
		} else {
			if v := reflect.ValueOf(val13); v.Kind() == reflect.Ptr {
				if v.IsNil() {
					panic(fmt.Errorf("nil pointer is not supported in interface"))
				} else {
					val15 := val13 == nil
					if val15 {
						hasher.WriteByte(0)
					} else {
						val16 := func(hasher *proptools.Hasher) error { return val13.(proptools.CustomHash).CustomHash(hasher) }
						if err := proptools.HashReference(hasher, uintptr(v.Pointer()), val16); err != nil {
							return err
						}
					}
				}
			} else {
				val13.(proptools.CustomHash).CustomHash(hasher)
			}
		}
		return nil
	}
	if err := r.TransitiveLibsHeaderJarsForR8.Hash(hasher, "android.Path", val17); err != nil {
		return err
	}
	val22 := func(hasher *proptools.Hasher, val18 android.Path) error {
		hasher.WriteString(":java.android.Path")
		val19 := val18 == nil
		if val19 {
			hasher.WriteByte(0)
		} else {
			if v := reflect.ValueOf(val18); v.Kind() == reflect.Ptr {
				if v.IsNil() {
					panic(fmt.Errorf("nil pointer is not supported in interface"))
				} else {
					val20 := val18 == nil
					if val20 {
						hasher.WriteByte(0)
					} else {
						val21 := func(hasher *proptools.Hasher) error { return val18.(proptools.CustomHash).CustomHash(hasher) }
						if err := proptools.HashReference(hasher, uintptr(v.Pointer()), val21); err != nil {
							return err
						}
					}
				}
			} else {
				val18.(proptools.CustomHash).CustomHash(hasher)
			}
		}
		return nil
	}
	if err := r.TransitiveStaticLibsHeaderJarsForR8.Hash(hasher, "android.Path", val22); err != nil {
		return err
	}
	val27 := func(hasher *proptools.Hasher, val23 android.Path) error {
		hasher.WriteString(":java.android.Path")
		val24 := val23 == nil
		if val24 {
			hasher.WriteByte(0)
		} else {
			if v := reflect.ValueOf(val23); v.Kind() == reflect.Ptr {
				if v.IsNil() {
					panic(fmt.Errorf("nil pointer is not supported in interface"))
				} else {
					val25 := val23 == nil
					if val25 {
						hasher.WriteByte(0)
					} else {
						val26 := func(hasher *proptools.Hasher) error { return val23.(proptools.CustomHash).CustomHash(hasher) }
						if err := proptools.HashReference(hasher, uintptr(v.Pointer()), val26); err != nil {
							return err
						}
					}
				}
			} else {
				val23.(proptools.CustomHash).CustomHash(hasher)
			}
		}
		return nil
	}
	if err := r.TransitiveStaticLibsHeaderJars.Hash(hasher, "android.Path", val27); err != nil {
		return err
	}
	val32 := func(hasher *proptools.Hasher, val28 android.Path) error {
		hasher.WriteString(":java.android.Path")
		val29 := val28 == nil
		if val29 {
			hasher.WriteByte(0)
		} else {
			if v := reflect.ValueOf(val28); v.Kind() == reflect.Ptr {
				if v.IsNil() {
					panic(fmt.Errorf("nil pointer is not supported in interface"))
				} else {
					val30 := val28 == nil
					if val30 {
						hasher.WriteByte(0)
					} else {
						val31 := func(hasher *proptools.Hasher) error { return val28.(proptools.CustomHash).CustomHash(hasher) }
						if err := proptools.HashReference(hasher, uintptr(v.Pointer()), val31); err != nil {
							return err
						}
					}
				}
			} else {
				val28.(proptools.CustomHash).CustomHash(hasher)
			}
		}
		return nil
	}
	if err := r.TransitiveStaticLibsImplementationJars.Hash(hasher, "android.Path", val32); err != nil {
		return err
	}
	val37 := func(hasher *proptools.Hasher, val33 android.Path) error {
		hasher.WriteString(":java.android.Path")
		val34 := val33 == nil
		if val34 {
			hasher.WriteByte(0)
		} else {
			if v := reflect.ValueOf(val33); v.Kind() == reflect.Ptr {
				if v.IsNil() {
					panic(fmt.Errorf("nil pointer is not supported in interface"))
				} else {
					val35 := val33 == nil
					if val35 {
						hasher.WriteByte(0)
					} else {
						val36 := func(hasher *proptools.Hasher) error { return val33.(proptools.CustomHash).CustomHash(hasher) }
						if err := proptools.HashReference(hasher, uintptr(v.Pointer()), val36); err != nil {
							return err
						}
					}
				}
			} else {
				val33.(proptools.CustomHash).CustomHash(hasher)
			}
		}
		return nil
	}
	if err := r.TransitiveStaticLibsResourceJars.Hash(hasher, "android.Path", val37); err != nil {
		return err
	}
	hasher.WriteString(":java.android.Paths")
	hasher.WriteString(":.[]Path")
	hasher.WriteInt(len(r.ImplementationAndResourcesJars))
	for val38 := 0; val38 < len(r.ImplementationAndResourcesJars); val38++ {
		hasher.WriteString("android/soong/android:android.Path")
		val39 := r.ImplementationAndResourcesJars[val38] == nil
		if val39 {
			hasher.WriteByte(0)
		} else {
			if v := reflect.ValueOf(r.ImplementationAndResourcesJars[val38]); v.Kind() == reflect.Ptr {
				if v.IsNil() {
					panic(fmt.Errorf("nil pointer is not supported in interface"))
				} else {
					val40 := r.ImplementationAndResourcesJars[val38] == nil
					if val40 {
						hasher.WriteByte(0)
					} else {
						val41 := func(hasher *proptools.Hasher) error {
							return r.ImplementationAndResourcesJars[val38].(proptools.CustomHash).CustomHash(hasher)
						}
						if err := proptools.HashReference(hasher, uintptr(v.Pointer()), val41); err != nil {
							return err
						}
					}
				}
			} else {
				r.ImplementationAndResourcesJars[val38].(proptools.CustomHash).CustomHash(hasher)
			}
		}
	}
	hasher.WriteString(":java.android.Paths")
	hasher.WriteString(":.[]Path")
	hasher.WriteInt(len(r.ImplementationJars))
	for val42 := 0; val42 < len(r.ImplementationJars); val42++ {
		hasher.WriteString("android/soong/android:android.Path")
		val43 := r.ImplementationJars[val42] == nil
		if val43 {
			hasher.WriteByte(0)
		} else {
			if v := reflect.ValueOf(r.ImplementationJars[val42]); v.Kind() == reflect.Ptr {
				if v.IsNil() {
					panic(fmt.Errorf("nil pointer is not supported in interface"))
				} else {
					val44 := r.ImplementationJars[val42] == nil
					if val44 {
						hasher.WriteByte(0)
					} else {
						val45 := func(hasher *proptools.Hasher) error {
							return r.ImplementationJars[val42].(proptools.CustomHash).CustomHash(hasher)
						}
						if err := proptools.HashReference(hasher, uintptr(v.Pointer()), val45); err != nil {
							return err
						}
					}
				}
			} else {
				r.ImplementationJars[val42].(proptools.CustomHash).CustomHash(hasher)
			}
		}
	}
	hasher.WriteString(":java.android.Paths")
	hasher.WriteString(":.[]Path")
	hasher.WriteInt(len(r.ResourceJars))
	for val46 := 0; val46 < len(r.ResourceJars); val46++ {
		hasher.WriteString("android/soong/android:android.Path")
		val47 := r.ResourceJars[val46] == nil
		if val47 {
			hasher.WriteByte(0)
		} else {
			if v := reflect.ValueOf(r.ResourceJars[val46]); v.Kind() == reflect.Ptr {
				if v.IsNil() {
					panic(fmt.Errorf("nil pointer is not supported in interface"))
				} else {
					val48 := r.ResourceJars[val46] == nil
					if val48 {
						hasher.WriteByte(0)
					} else {
						val49 := func(hasher *proptools.Hasher) error {
							return r.ResourceJars[val46].(proptools.CustomHash).CustomHash(hasher)
						}
						if err := proptools.HashReference(hasher, uintptr(v.Pointer()), val49); err != nil {
							return err
						}
					}
				}
			} else {
				r.ResourceJars[val46].(proptools.CustomHash).CustomHash(hasher)
			}
		}
	}
	hasher.WriteString(":java.android.Paths")
	hasher.WriteString(":.[]Path")
	hasher.WriteInt(len(r.LocalHeaderJars))
	for val50 := 0; val50 < len(r.LocalHeaderJars); val50++ {
		hasher.WriteString("android/soong/android:android.Path")
		val51 := r.LocalHeaderJars[val50] == nil
		if val51 {
			hasher.WriteByte(0)
		} else {
			if v := reflect.ValueOf(r.LocalHeaderJars[val50]); v.Kind() == reflect.Ptr {
				if v.IsNil() {
					panic(fmt.Errorf("nil pointer is not supported in interface"))
				} else {
					val52 := r.LocalHeaderJars[val50] == nil
					if val52 {
						hasher.WriteByte(0)
					} else {
						val53 := func(hasher *proptools.Hasher) error {
							return r.LocalHeaderJars[val50].(proptools.CustomHash).CustomHash(hasher)
						}
						if err := proptools.HashReference(hasher, uintptr(v.Pointer()), val53); err != nil {
							return err
						}
					}
				}
			} else {
				r.LocalHeaderJars[val50].(proptools.CustomHash).CustomHash(hasher)
			}
		}
	}
	hasher.WriteString(":java.android.Paths")
	hasher.WriteString(":.[]Path")
	hasher.WriteInt(len(r.KotlinHeaderJars))
	for val54 := 0; val54 < len(r.KotlinHeaderJars); val54++ {
		hasher.WriteString("android/soong/android:android.Path")
		val55 := r.KotlinHeaderJars[val54] == nil
		if val55 {
			hasher.WriteByte(0)
		} else {
			if v := reflect.ValueOf(r.KotlinHeaderJars[val54]); v.Kind() == reflect.Ptr {
				if v.IsNil() {
					panic(fmt.Errorf("nil pointer is not supported in interface"))
				} else {
					val56 := r.KotlinHeaderJars[val54] == nil
					if val56 {
						hasher.WriteByte(0)
					} else {
						val57 := func(hasher *proptools.Hasher) error {
							return r.KotlinHeaderJars[val54].(proptools.CustomHash).CustomHash(hasher)
						}
						if err := proptools.HashReference(hasher, uintptr(v.Pointer()), val57); err != nil {
							return err
						}
					}
				}
			} else {
				r.KotlinHeaderJars[val54].(proptools.CustomHash).CustomHash(hasher)
			}
		}
	}
	hasher.WriteString(":java.android.Paths")
	hasher.WriteString(":.[]Path")
	hasher.WriteInt(len(r.AidlIncludeDirs))
	for val58 := 0; val58 < len(r.AidlIncludeDirs); val58++ {
		hasher.WriteString("android/soong/android:android.Path")
		val59 := r.AidlIncludeDirs[val58] == nil
		if val59 {
			hasher.WriteByte(0)
		} else {
			if v := reflect.ValueOf(r.AidlIncludeDirs[val58]); v.Kind() == reflect.Ptr {
				if v.IsNil() {
					panic(fmt.Errorf("nil pointer is not supported in interface"))
				} else {
					val60 := r.AidlIncludeDirs[val58] == nil
					if val60 {
						hasher.WriteByte(0)
					} else {
						val61 := func(hasher *proptools.Hasher) error {
							return r.AidlIncludeDirs[val58].(proptools.CustomHash).CustomHash(hasher)
						}
						if err := proptools.HashReference(hasher, uintptr(v.Pointer()), val61); err != nil {
							return err
						}
					}
				}
			} else {
				r.AidlIncludeDirs[val58].(proptools.CustomHash).CustomHash(hasher)
			}
		}
	}
	hasher.WriteString(":.[]string")
	hasher.WriteInt(len(r.SrcJarArgs))
	for val62 := 0; val62 < len(r.SrcJarArgs); val62++ {
		hasher.WriteString(":.string")
		hasher.WriteString(r.SrcJarArgs[val62])
	}
	hasher.WriteString(":java.android.Paths")
	hasher.WriteString(":.[]Path")
	hasher.WriteInt(len(r.SrcJarDeps))
	for val63 := 0; val63 < len(r.SrcJarDeps); val63++ {
		hasher.WriteString("android/soong/android:android.Path")
		val64 := r.SrcJarDeps[val63] == nil
		if val64 {
			hasher.WriteByte(0)
		} else {
			if v := reflect.ValueOf(r.SrcJarDeps[val63]); v.Kind() == reflect.Ptr {
				if v.IsNil() {
					panic(fmt.Errorf("nil pointer is not supported in interface"))
				} else {
					val65 := r.SrcJarDeps[val63] == nil
					if val65 {
						hasher.WriteByte(0)
					} else {
						val66 := func(hasher *proptools.Hasher) error {
							return r.SrcJarDeps[val63].(proptools.CustomHash).CustomHash(hasher)
						}
						if err := proptools.HashReference(hasher, uintptr(v.Pointer()), val66); err != nil {
							return err
						}
					}
				}
			} else {
				r.SrcJarDeps[val63].(proptools.CustomHash).CustomHash(hasher)
			}
		}
	}
	hasher.WriteString(":.map[string]android.Path")
	hasher.WriteInt(len(r.KSnapshotFiles))
	val67 := make([]string, 0, len(r.KSnapshotFiles))
	for val69 := range r.KSnapshotFiles {
		val67 = append(val67, val69)
	}
	proptools.SortOrdered(val67)
	for _, val68 := range val67 {
		hasher.WriteString(":.string")
		hasher.WriteString(val68)
		hasher.WriteString(":java.android.Path")
		val70 := r.KSnapshotFiles[val68] == nil
		if val70 {
			hasher.WriteByte(0)
		} else {
			if v := reflect.ValueOf(r.KSnapshotFiles[val68]); v.Kind() == reflect.Ptr {
				if v.IsNil() {
					panic(fmt.Errorf("nil pointer is not supported in interface"))
				} else {
					val71 := r.KSnapshotFiles[val68] == nil
					if val71 {
						hasher.WriteByte(0)
					} else {
						val72 := func(hasher *proptools.Hasher) error {
							return r.KSnapshotFiles[val68].(proptools.CustomHash).CustomHash(hasher)
						}
						if err := proptools.HashReference(hasher, uintptr(v.Pointer()), val72); err != nil {
							return err
						}
					}
				}
			} else {
				r.KSnapshotFiles[val68].(proptools.CustomHash).CustomHash(hasher)
			}
		}
	}
	val77 := func(hasher *proptools.Hasher, val73 android.Path) error {
		hasher.WriteString(":java.android.Path")
		val74 := val73 == nil
		if val74 {
			hasher.WriteByte(0)
		} else {
			if v := reflect.ValueOf(val73); v.Kind() == reflect.Ptr {
				if v.IsNil() {
					panic(fmt.Errorf("nil pointer is not supported in interface"))
				} else {
					val75 := val73 == nil
					if val75 {
						hasher.WriteByte(0)
					} else {
						val76 := func(hasher *proptools.Hasher) error { return val73.(proptools.CustomHash).CustomHash(hasher) }
						if err := proptools.HashReference(hasher, uintptr(v.Pointer()), val76); err != nil {
							return err
						}
					}
				}
			} else {
				val73.(proptools.CustomHash).CustomHash(hasher)
			}
		}
		return nil
	}
	if err := r.TransitiveSrcFiles.Hash(hasher, "android.Path", val77); err != nil {
		return err
	}
	hasher.WriteString(":java.android.Paths")
	hasher.WriteString(":.[]Path")
	hasher.WriteInt(len(r.ExportedPlugins))
	for val78 := 0; val78 < len(r.ExportedPlugins); val78++ {
		hasher.WriteString("android/soong/android:android.Path")
		val79 := r.ExportedPlugins[val78] == nil
		if val79 {
			hasher.WriteByte(0)
		} else {
			if v := reflect.ValueOf(r.ExportedPlugins[val78]); v.Kind() == reflect.Ptr {
				if v.IsNil() {
					panic(fmt.Errorf("nil pointer is not supported in interface"))
				} else {
					val80 := r.ExportedPlugins[val78] == nil
					if val80 {
						hasher.WriteByte(0)
					} else {
						val81 := func(hasher *proptools.Hasher) error {
							return r.ExportedPlugins[val78].(proptools.CustomHash).CustomHash(hasher)
						}
						if err := proptools.HashReference(hasher, uintptr(v.Pointer()), val81); err != nil {
							return err
						}
					}
				}
			} else {
				r.ExportedPlugins[val78].(proptools.CustomHash).CustomHash(hasher)
			}
		}
	}
	hasher.WriteString(":.[]string")
	hasher.WriteInt(len(r.ExportedPluginClasses))
	for val82 := 0; val82 < len(r.ExportedPluginClasses); val82++ {
		hasher.WriteString(":.string")
		hasher.WriteString(r.ExportedPluginClasses[val82])
	}
	hasher.WriteString(":.bool")
	if r.ExportedPluginDisableTurbine {
		hasher.WriteByte(1)
	} else {
		hasher.WriteByte(0)
	}
	if err := r.JacocoInfo.CustomHash(hasher); err != nil {
		return err
	}
	hasher.WriteString(":java.StubsLinkType")
	hasher.WriteString(":.int")
	hasher.WriteUint64(uint64(int(r.StubsLinkType)))
	hasher.WriteString(":java.android.Paths")
	hasher.WriteString(":.[]Path")
	hasher.WriteInt(len(r.AconfigIntermediateCacheOutputPaths))
	for val83 := 0; val83 < len(r.AconfigIntermediateCacheOutputPaths); val83++ {
		hasher.WriteString("android/soong/android:android.Path")
		val84 := r.AconfigIntermediateCacheOutputPaths[val83] == nil
		if val84 {
			hasher.WriteByte(0)
		} else {
			if v := reflect.ValueOf(r.AconfigIntermediateCacheOutputPaths[val83]); v.Kind() == reflect.Ptr {
				if v.IsNil() {
					panic(fmt.Errorf("nil pointer is not supported in interface"))
				} else {
					val85 := r.AconfigIntermediateCacheOutputPaths[val83] == nil
					if val85 {
						hasher.WriteByte(0)
					} else {
						val86 := func(hasher *proptools.Hasher) error {
							return r.AconfigIntermediateCacheOutputPaths[val83].(proptools.CustomHash).CustomHash(hasher)
						}
						if err := proptools.HashReference(hasher, uintptr(v.Pointer()), val86); err != nil {
							return err
						}
					}
				}
			} else {
				r.AconfigIntermediateCacheOutputPaths[val83].(proptools.CustomHash).CustomHash(hasher)
			}
		}
	}
	if err := r.SdkVersion.CustomHash(hasher); err != nil {
		return err
	}
	hasher.WriteString(":java.android.Path")
	val87 := r.OutputFile == nil
	if val87 {
		hasher.WriteByte(0)
	} else {
		if v := reflect.ValueOf(r.OutputFile); v.Kind() == reflect.Ptr {
			if v.IsNil() {
				panic(fmt.Errorf("nil pointer is not supported in interface"))
			} else {
				val88 := r.OutputFile == nil
				if val88 {
					hasher.WriteByte(0)
				} else {
					val89 := func(hasher *proptools.Hasher) error { return r.OutputFile.(proptools.CustomHash).CustomHash(hasher) }
					if err := proptools.HashReference(hasher, uintptr(v.Pointer()), val89); err != nil {
						return err
					}
				}
			}
		} else {
			r.OutputFile.(proptools.CustomHash).CustomHash(hasher)
		}
	}
	hasher.WriteString(":java.android.Paths")
	hasher.WriteString(":.[]Path")
	hasher.WriteInt(len(r.ExtraOutputFiles))
	for val90 := 0; val90 < len(r.ExtraOutputFiles); val90++ {
		hasher.WriteString("android/soong/android:android.Path")
		val91 := r.ExtraOutputFiles[val90] == nil
		if val91 {
			hasher.WriteByte(0)
		} else {
			if v := reflect.ValueOf(r.ExtraOutputFiles[val90]); v.Kind() == reflect.Ptr {
				if v.IsNil() {
					panic(fmt.Errorf("nil pointer is not supported in interface"))
				} else {
					val92 := r.ExtraOutputFiles[val90] == nil
					if val92 {
						hasher.WriteByte(0)
					} else {
						val93 := func(hasher *proptools.Hasher) error {
							return r.ExtraOutputFiles[val90].(proptools.CustomHash).CustomHash(hasher)
						}
						if err := proptools.HashReference(hasher, uintptr(v.Pointer()), val93); err != nil {
							return err
						}
					}
				}
			} else {
				r.ExtraOutputFiles[val90].(proptools.CustomHash).CustomHash(hasher)
			}
		}
	}
	hasher.WriteString(":.*AndroidLibraryDependencyInfo")
	val94 := r.AndroidLibraryDependencyInfo == nil
	if val94 {
		hasher.WriteByte(0)
	} else {
		val95 := func(hasher *proptools.Hasher) error {
			if err := (*r.AndroidLibraryDependencyInfo).CustomHash(hasher); err != nil {
				return err
			}
			return nil
		}
		if err := proptools.HashReference(hasher, uintptr(unsafe.Pointer(r.AndroidLibraryDependencyInfo)), val95); err != nil {
			return err
		}
	}
	hasher.WriteString(":.*UsesLibraryDependencyInfo")
	val96 := r.UsesLibraryDependencyInfo == nil
	if val96 {
		hasher.WriteByte(0)
	} else {
		val97 := func(hasher *proptools.Hasher) error {
			if err := (*r.UsesLibraryDependencyInfo).CustomHash(hasher); err != nil {
				return err
			}
			return nil
		}
		if err := proptools.HashReference(hasher, uintptr(unsafe.Pointer(r.UsesLibraryDependencyInfo)), val97); err != nil {
			return err
		}
	}
	hasher.WriteString(":.*ProvidesUsesLibInfo")
	val98 := r.ProvidesUsesLibInfo == nil
	if val98 {
		hasher.WriteByte(0)
	} else {
		val99 := func(hasher *proptools.Hasher) error {
			if err := (*r.ProvidesUsesLibInfo).CustomHash(hasher); err != nil {
				return err
			}
			return nil
		}
		if err := proptools.HashReference(hasher, uintptr(unsafe.Pointer(r.ProvidesUsesLibInfo)), val99); err != nil {
			return err
		}
	}
	hasher.WriteString(":.[]string")
	hasher.WriteInt(len(r.MissingOptionalUsesLibs))
	for val100 := 0; val100 < len(r.MissingOptionalUsesLibs); val100++ {
		hasher.WriteString(":.string")
		hasher.WriteString(r.MissingOptionalUsesLibs[val100])
	}
	hasher.WriteString(":.*ModuleWithSdkDepInfo")
	val101 := r.ModuleWithSdkDepInfo == nil
	if val101 {
		hasher.WriteByte(0)
	} else {
		val102 := func(hasher *proptools.Hasher) error {
			if err := (*r.ModuleWithSdkDepInfo).CustomHash(hasher); err != nil {
				return err
			}
			return nil
		}
		if err := proptools.HashReference(hasher, uintptr(unsafe.Pointer(r.ModuleWithSdkDepInfo)), val102); err != nil {
			return err
		}
	}
	if err := r.DexJarFile.CustomHash(hasher); err != nil {
		return err
	}
	hasher.WriteString(":java.android.Path")
	val103 := r.InstallFile == nil
	if val103 {
		hasher.WriteByte(0)
	} else {
		if v := reflect.ValueOf(r.InstallFile); v.Kind() == reflect.Ptr {
			if v.IsNil() {
				panic(fmt.Errorf("nil pointer is not supported in interface"))
			} else {
				val104 := r.InstallFile == nil
				if val104 {
					hasher.WriteByte(0)
				} else {
					val105 := func(hasher *proptools.Hasher) error { return r.InstallFile.(proptools.CustomHash).CustomHash(hasher) }
					if err := proptools.HashReference(hasher, uintptr(v.Pointer()), val105); err != nil {
						return err
					}
				}
			}
		} else {
			r.InstallFile.(proptools.CustomHash).CustomHash(hasher)
		}
	}
	if err := r.BootDexJarPath.CustomHash(hasher); err != nil {
		return err
	}
	hasher.WriteString(":java.android.Paths")
	hasher.WriteString(":.[]Path")
	hasher.WriteInt(len(r.HiddenapiClassesJarPaths))
	for val106 := 0; val106 < len(r.HiddenapiClassesJarPaths); val106++ {
		hasher.WriteString("android/soong/android:android.Path")
		val107 := r.HiddenapiClassesJarPaths[val106] == nil
		if val107 {
			hasher.WriteByte(0)
		} else {
			if v := reflect.ValueOf(r.HiddenapiClassesJarPaths[val106]); v.Kind() == reflect.Ptr {
				if v.IsNil() {
					panic(fmt.Errorf("nil pointer is not supported in interface"))
				} else {
					val108 := r.HiddenapiClassesJarPaths[val106] == nil
					if val108 {
						hasher.WriteByte(0)
					} else {
						val109 := func(hasher *proptools.Hasher) error {
							return r.HiddenapiClassesJarPaths[val106].(proptools.CustomHash).CustomHash(hasher)
						}
						if err := proptools.HashReference(hasher, uintptr(v.Pointer()), val109); err != nil {
							return err
						}
					}
				}
			} else {
				r.HiddenapiClassesJarPaths[val106].(proptools.CustomHash).CustomHash(hasher)
			}
		}
	}
	hasher.WriteString(":.*bool")
	val110 := r.UncompressDexState == nil
	if val110 {
		hasher.WriteByte(0)
	} else {
		val111 := func(hasher *proptools.Hasher) error {
			hasher.WriteString(":.bool")
			if *r.UncompressDexState {
				hasher.WriteByte(1)
			} else {
				hasher.WriteByte(0)
			}
			return nil
		}
		if err := proptools.HashReference(hasher, uintptr(unsafe.Pointer(r.UncompressDexState)), val111); err != nil {
			return err
		}
	}
	hasher.WriteString(":.bool")
	if r.Active {
		hasher.WriteByte(1)
	} else {
		hasher.WriteByte(0)
	}
	hasher.WriteString(":.string")
	hasher.WriteString(r.BuiltInstalled)
	hasher.WriteString(":java.android.WritablePath")
	val112 := r.ConfigPath == nil
	if val112 {
		hasher.WriteByte(0)
	} else {
		if v := reflect.ValueOf(r.ConfigPath); v.Kind() == reflect.Ptr {
			if v.IsNil() {
				panic(fmt.Errorf("nil pointer is not supported in interface"))
			} else {
				val113 := r.ConfigPath == nil
				if val113 {
					hasher.WriteByte(0)
				} else {
					val114 := func(hasher *proptools.Hasher) error { return r.ConfigPath.(proptools.CustomHash).CustomHash(hasher) }
					if err := proptools.HashReference(hasher, uintptr(v.Pointer()), val114); err != nil {
						return err
					}
				}
			}
		} else {
			r.ConfigPath.(proptools.CustomHash).CustomHash(hasher)
		}
	}
	hasher.WriteString(":java.android.Paths")
	hasher.WriteString(":.[]Path")
	hasher.WriteInt(len(r.LogtagsSrcs))
	for val115 := 0; val115 < len(r.LogtagsSrcs); val115++ {
		hasher.WriteString("android/soong/android:android.Path")
		val116 := r.LogtagsSrcs[val115] == nil
		if val116 {
			hasher.WriteByte(0)
		} else {
			if v := reflect.ValueOf(r.LogtagsSrcs[val115]); v.Kind() == reflect.Ptr {
				if v.IsNil() {
					panic(fmt.Errorf("nil pointer is not supported in interface"))
				} else {
					val117 := r.LogtagsSrcs[val115] == nil
					if val117 {
						hasher.WriteByte(0)
					} else {
						val118 := func(hasher *proptools.Hasher) error {
							return r.LogtagsSrcs[val115].(proptools.CustomHash).CustomHash(hasher)
						}
						if err := proptools.HashReference(hasher, uintptr(v.Pointer()), val118); err != nil {
							return err
						}
					}
				}
			} else {
				r.LogtagsSrcs[val115].(proptools.CustomHash).CustomHash(hasher)
			}
		}
	}
	if err := r.ProguardDictionary.CustomHash(hasher); err != nil {
		return err
	}
	if err := r.ProguardUsageZip.CustomHash(hasher); err != nil {
		return err
	}
	hasher.WriteString(":java.android.Paths")
	hasher.WriteString(":.[]Path")
	hasher.WriteInt(len(r.LinterReports))
	for val119 := 0; val119 < len(r.LinterReports); val119++ {
		hasher.WriteString("android/soong/android:android.Path")
		val120 := r.LinterReports[val119] == nil
		if val120 {
			hasher.WriteByte(0)
		} else {
			if v := reflect.ValueOf(r.LinterReports[val119]); v.Kind() == reflect.Ptr {
				if v.IsNil() {
					panic(fmt.Errorf("nil pointer is not supported in interface"))
				} else {
					val121 := r.LinterReports[val119] == nil
					if val121 {
						hasher.WriteByte(0)
					} else {
						val122 := func(hasher *proptools.Hasher) error {
							return r.LinterReports[val119].(proptools.CustomHash).CustomHash(hasher)
						}
						if err := proptools.HashReference(hasher, uintptr(v.Pointer()), val122); err != nil {
							return err
						}
					}
				}
			} else {
				r.LinterReports[val119].(proptools.CustomHash).CustomHash(hasher)
			}
		}
	}
	if err := r.HostdexInstallFile.CustomHash(hasher); err != nil {
		return err
	}
	hasher.WriteString(":.[]android.Path")
	hasher.WriteInt(len(r.GeneratedSrcjars))
	for val123 := 0; val123 < len(r.GeneratedSrcjars); val123++ {
		hasher.WriteString(":java.android.Path")
		val124 := r.GeneratedSrcjars[val123] == nil
		if val124 {
			hasher.WriteByte(0)
		} else {
			if v := reflect.ValueOf(r.GeneratedSrcjars[val123]); v.Kind() == reflect.Ptr {
				if v.IsNil() {
					panic(fmt.Errorf("nil pointer is not supported in interface"))
				} else {
					val125 := r.GeneratedSrcjars[val123] == nil
					if val125 {
						hasher.WriteByte(0)
					} else {
						val126 := func(hasher *proptools.Hasher) error {
							return r.GeneratedSrcjars[val123].(proptools.CustomHash).CustomHash(hasher)
						}
						if err := proptools.HashReference(hasher, uintptr(v.Pointer()), val126); err != nil {
							return err
						}
					}
				}
			} else {
				r.GeneratedSrcjars[val123].(proptools.CustomHash).CustomHash(hasher)
			}
		}
	}
	hasher.WriteString(":.bool")
	if r.ProfileGuided {
		hasher.WriteByte(1)
	} else {
		hasher.WriteByte(0)
	}
	hasher.WriteString(":.string")
	hasher.WriteString(r.Stem)
	if err := r.DexJarBuildPath.CustomHash(hasher); err != nil {
		return err
	}
	hasher.WriteString(":.*DexpreopterInfo")
	val127 := r.DexpreopterInfo == nil
	if val127 {
		hasher.WriteByte(0)
	} else {
		val128 := func(hasher *proptools.Hasher) error {
			if err := (*r.DexpreopterInfo).CustomHash(hasher); err != nil {
				return err
			}
			return nil
		}
		if err := proptools.HashReference(hasher, uintptr(unsafe.Pointer(r.DexpreopterInfo)), val128); err != nil {
			return err
		}
	}
	hasher.WriteString(":java.android.Paths")
	hasher.WriteString(":.[]Path")
	hasher.WriteInt(len(r.XrefJavaFiles))
	for val129 := 0; val129 < len(r.XrefJavaFiles); val129++ {
		hasher.WriteString("android/soong/android:android.Path")
		val130 := r.XrefJavaFiles[val129] == nil
		if val130 {
			hasher.WriteByte(0)
		} else {
			if v := reflect.ValueOf(r.XrefJavaFiles[val129]); v.Kind() == reflect.Ptr {
				if v.IsNil() {
					panic(fmt.Errorf("nil pointer is not supported in interface"))
				} else {
					val131 := r.XrefJavaFiles[val129] == nil
					if val131 {
						hasher.WriteByte(0)
					} else {
						val132 := func(hasher *proptools.Hasher) error {
							return r.XrefJavaFiles[val129].(proptools.CustomHash).CustomHash(hasher)
						}
						if err := proptools.HashReference(hasher, uintptr(v.Pointer()), val132); err != nil {
							return err
						}
					}
				}
			} else {
				r.XrefJavaFiles[val129].(proptools.CustomHash).CustomHash(hasher)
			}
		}
	}
	hasher.WriteString(":java.android.Paths")
	hasher.WriteString(":.[]Path")
	hasher.WriteInt(len(r.XrefKotlinFiles))
	for val133 := 0; val133 < len(r.XrefKotlinFiles); val133++ {
		hasher.WriteString("android/soong/android:android.Path")
		val134 := r.XrefKotlinFiles[val133] == nil
		if val134 {
			hasher.WriteByte(0)
		} else {
			if v := reflect.ValueOf(r.XrefKotlinFiles[val133]); v.Kind() == reflect.Ptr {
				if v.IsNil() {
					panic(fmt.Errorf("nil pointer is not supported in interface"))
				} else {
					val135 := r.XrefKotlinFiles[val133] == nil
					if val135 {
						hasher.WriteByte(0)
					} else {
						val136 := func(hasher *proptools.Hasher) error {
							return r.XrefKotlinFiles[val133].(proptools.CustomHash).CustomHash(hasher)
						}
						if err := proptools.HashReference(hasher, uintptr(v.Pointer()), val136); err != nil {
							return err
						}
					}
				}
			} else {
				r.XrefKotlinFiles[val133].(proptools.CustomHash).CustomHash(hasher)
			}
		}
	}
	hasher.WriteString(":.bool")
	if r.HasOverrideMinSdkVersion {
		hasher.WriteByte(1)
	} else {
		hasher.WriteByte(0)
	}
	hasher.WriteString(":.*bool")
	val137 := r.CompileDex == nil
	if val137 {
		hasher.WriteByte(0)
	} else {
		val138 := func(hasher *proptools.Hasher) error {
			hasher.WriteString(":.bool")
			if *r.CompileDex {
				hasher.WriteByte(1)
			} else {
				hasher.WriteByte(0)
			}
			return nil
		}
		if err := proptools.HashReference(hasher, uintptr(unsafe.Pointer(r.CompileDex)), val138); err != nil {
			return err
		}
	}
	hasher.WriteString(":.string")
	hasher.WriteString(r.SystemModules)
	hasher.WriteString(":.bool")
	if r.Installable {
		hasher.WriteByte(1)
	} else {
		hasher.WriteByte(0)
	}
	hasher.WriteString(":.*ApexDependencyInfo")
	val139 := r.ApexDependencyInfo == nil
	if val139 {
		hasher.WriteByte(0)
	} else {
		val140 := func(hasher *proptools.Hasher) error {
			if err := (*r.ApexDependencyInfo).CustomHash(hasher); err != nil {
				return err
			}
			return nil
		}
		if err := proptools.HashReference(hasher, uintptr(unsafe.Pointer(r.ApexDependencyInfo)), val140); err != nil {
			return err
		}
	}
	if err := r.MaxSdkVersion.CustomHash(hasher); err != nil {
		return err
	}
	return nil
}

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

	var val3 int
	err = gobtools.DecodeInt(buf, &val3)
	if err != nil {
		return err
	}
	if val3 != -1 {
		r.HeaderJars = 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.HeaderJars[val4] = nil
			} else {
				r.HeaderJars[val4] = val6.(android.Path)
			}
		}
	}

	var val9 int
	err = gobtools.DecodeInt(buf, &val9)
	if err != nil {
		return err
	}
	if val9 != -1 {
		r.RepackagedHeaderJars = 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.RepackagedHeaderJars[val10] = nil
			} else {
				r.RepackagedHeaderJars[val10] = val12.(android.Path)
			}
		}
	}

	var val15 int
	err = gobtools.DecodeInt(buf, &val15)
	if err != nil {
		return err
	}
	if val15 != -1 {
		r.LocalHeaderJarsPreJarjar = make([]android.Path, val15)
		for val16 := 0; val16 < int(val15); val16++ {
			if val18, err := gobtools.DecodeInterface(ctx, buf); err != nil {
				return err
			} else if val18 == nil {
				r.LocalHeaderJarsPreJarjar[val16] = nil
			} else {
				r.LocalHeaderJarsPreJarjar[val16] = val18.(android.Path)
			}
		}
	}

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

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

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

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

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

	var val26 int
	err = gobtools.DecodeInt(buf, &val26)
	if err != nil {
		return err
	}
	if val26 != -1 {
		r.ImplementationAndResourcesJars = make([]android.Path, val26)
		for val27 := 0; val27 < int(val26); val27++ {
			if val29, err := gobtools.DecodeInterface(ctx, buf); err != nil {
				return err
			} else if val29 == nil {
				r.ImplementationAndResourcesJars[val27] = nil
			} else {
				r.ImplementationAndResourcesJars[val27] = val29.(android.Path)
			}
		}
	}

	var val32 int
	err = gobtools.DecodeInt(buf, &val32)
	if err != nil {
		return err
	}
	if val32 != -1 {
		r.ImplementationJars = make([]android.Path, val32)
		for val33 := 0; val33 < int(val32); val33++ {
			if val35, err := gobtools.DecodeInterface(ctx, buf); err != nil {
				return err
			} else if val35 == nil {
				r.ImplementationJars[val33] = nil
			} else {
				r.ImplementationJars[val33] = val35.(android.Path)
			}
		}
	}

	var val38 int
	err = gobtools.DecodeInt(buf, &val38)
	if err != nil {
		return err
	}
	if val38 != -1 {
		r.ResourceJars = make([]android.Path, val38)
		for val39 := 0; val39 < int(val38); val39++ {
			if val41, err := gobtools.DecodeInterface(ctx, buf); err != nil {
				return err
			} else if val41 == nil {
				r.ResourceJars[val39] = nil
			} else {
				r.ResourceJars[val39] = val41.(android.Path)
			}
		}
	}

	var val44 int
	err = gobtools.DecodeInt(buf, &val44)
	if err != nil {
		return err
	}
	if val44 != -1 {
		r.LocalHeaderJars = make([]android.Path, val44)
		for val45 := 0; val45 < int(val44); val45++ {
			if val47, err := gobtools.DecodeInterface(ctx, buf); err != nil {
				return err
			} else if val47 == nil {
				r.LocalHeaderJars[val45] = nil
			} else {
				r.LocalHeaderJars[val45] = val47.(android.Path)
			}
		}
	}

	var val50 int
	err = gobtools.DecodeInt(buf, &val50)
	if err != nil {
		return err
	}
	if val50 != -1 {
		r.KotlinHeaderJars = make([]android.Path, val50)
		for val51 := 0; val51 < int(val50); val51++ {
			if val53, err := gobtools.DecodeInterface(ctx, buf); err != nil {
				return err
			} else if val53 == nil {
				r.KotlinHeaderJars[val51] = nil
			} else {
				r.KotlinHeaderJars[val51] = val53.(android.Path)
			}
		}
	}

	var val56 int
	err = gobtools.DecodeInt(buf, &val56)
	if err != nil {
		return err
	}
	if val56 != -1 {
		r.AidlIncludeDirs = make([]android.Path, val56)
		for val57 := 0; val57 < int(val56); val57++ {
			if val59, err := gobtools.DecodeInterface(ctx, buf); err != nil {
				return err
			} else if val59 == nil {
				r.AidlIncludeDirs[val57] = nil
			} else {
				r.AidlIncludeDirs[val57] = val59.(android.Path)
			}
		}
	}

	var val61 int
	err = gobtools.DecodeInt(buf, &val61)
	if err != nil {
		return err
	}
	if val61 != -1 {
		r.SrcJarArgs = make([]string, val61)
		for val62 := 0; val62 < int(val61); val62++ {
			err = gobtools.DecodeString(buf, &r.SrcJarArgs[val62])
			if err != nil {
				return err
			}
		}
	}

	var val66 int
	err = gobtools.DecodeInt(buf, &val66)
	if err != nil {
		return err
	}
	if val66 != -1 {
		r.SrcJarDeps = make([]android.Path, val66)
		for val67 := 0; val67 < int(val66); val67++ {
			if val69, err := gobtools.DecodeInterface(ctx, buf); err != nil {
				return err
			} else if val69 == nil {
				r.SrcJarDeps[val67] = nil
			} else {
				r.SrcJarDeps[val67] = val69.(android.Path)
			}
		}
	}

	var val70 int
	err = gobtools.DecodeInt(buf, &val70)
	if err != nil {
		return err
	}
	if val70 != -1 {
		r.KSnapshotFiles = make(map[string]android.Path, val70)
		for val71 := 0; val71 < int(val70); val71++ {
			var val72 string
			var val73 android.Path
			err = gobtools.DecodeString(buf, &val72)
			if err != nil {
				return err
			}
			if val76, err := gobtools.DecodeInterface(ctx, buf); err != nil {
				return err
			} else if val76 == nil {
				val73 = nil
			} else {
				val73 = val76.(android.Path)
			}
			r.KSnapshotFiles[val72] = val73
		}
	}

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

	var val80 int
	err = gobtools.DecodeInt(buf, &val80)
	if err != nil {
		return err
	}
	if val80 != -1 {
		r.ExportedPlugins = make([]android.Path, val80)
		for val81 := 0; val81 < int(val80); val81++ {
			if val83, err := gobtools.DecodeInterface(ctx, buf); err != nil {
				return err
			} else if val83 == nil {
				r.ExportedPlugins[val81] = nil
			} else {
				r.ExportedPlugins[val81] = val83.(android.Path)
			}
		}
	}

	var val85 int
	err = gobtools.DecodeInt(buf, &val85)
	if err != nil {
		return err
	}
	if val85 != -1 {
		r.ExportedPluginClasses = make([]string, val85)
		for val86 := 0; val86 < int(val85); val86++ {
			err = gobtools.DecodeString(buf, &r.ExportedPluginClasses[val86])
			if err != nil {
				return err
			}
		}
	}

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

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

	var val91 int
	err = gobtools.DecodeInt(buf, &val91)
	if err != nil {
		return err
	}
	r.StubsLinkType = StubsLinkType(val91)

	var val95 int
	err = gobtools.DecodeInt(buf, &val95)
	if err != nil {
		return err
	}
	if val95 != -1 {
		r.AconfigIntermediateCacheOutputPaths = make([]android.Path, val95)
		for val96 := 0; val96 < int(val95); val96++ {
			if val98, err := gobtools.DecodeInterface(ctx, buf); err != nil {
				return err
			} else if val98 == nil {
				r.AconfigIntermediateCacheOutputPaths[val96] = nil
			} else {
				r.AconfigIntermediateCacheOutputPaths[val96] = val98.(android.Path)
			}
		}
	}

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

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

	var val104 int
	err = gobtools.DecodeInt(buf, &val104)
	if err != nil {
		return err
	}
	if val104 != -1 {
		r.ExtraOutputFiles = make([]android.Path, val104)
		for val105 := 0; val105 < int(val104); val105++ {
			if val107, err := gobtools.DecodeInterface(ctx, buf); err != nil {
				return err
			} else if val107 == nil {
				r.ExtraOutputFiles[val105] = nil
			} else {
				r.ExtraOutputFiles[val105] = val107.(android.Path)
			}
		}
	}

	var val109 bool
	if err = gobtools.DecodeBool(buf, &val109); err != nil {
		return err
	}
	if !val109 {
		var val108 AndroidLibraryDependencyInfo
		if err = val108.Decode(ctx, buf); err != nil {
			return err
		}
		r.AndroidLibraryDependencyInfo = &val108
	}

	var val112 bool
	if err = gobtools.DecodeBool(buf, &val112); err != nil {
		return err
	}
	if !val112 {
		var val111 UsesLibraryDependencyInfo
		if err = val111.Decode(ctx, buf); err != nil {
			return err
		}
		r.UsesLibraryDependencyInfo = &val111
	}

	var val115 bool
	if err = gobtools.DecodeBool(buf, &val115); err != nil {
		return err
	}
	if !val115 {
		var val114 ProvidesUsesLibInfo
		if err = val114.Decode(ctx, buf); err != nil {
			return err
		}
		r.ProvidesUsesLibInfo = &val114
	}

	var val118 int
	err = gobtools.DecodeInt(buf, &val118)
	if err != nil {
		return err
	}
	if val118 != -1 {
		r.MissingOptionalUsesLibs = make([]string, val118)
		for val119 := 0; val119 < int(val118); val119++ {
			err = gobtools.DecodeString(buf, &r.MissingOptionalUsesLibs[val119])
			if err != nil {
				return err
			}
		}
	}

	var val122 bool
	if err = gobtools.DecodeBool(buf, &val122); err != nil {
		return err
	}
	if !val122 {
		var val121 ModuleWithSdkDepInfo
		if err = val121.Decode(ctx, buf); err != nil {
			return err
		}
		r.ModuleWithSdkDepInfo = &val121
	}

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

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

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

	var val130 int
	err = gobtools.DecodeInt(buf, &val130)
	if err != nil {
		return err
	}
	if val130 != -1 {
		r.HiddenapiClassesJarPaths = make([]android.Path, val130)
		for val131 := 0; val131 < int(val130); val131++ {
			if val133, err := gobtools.DecodeInterface(ctx, buf); err != nil {
				return err
			} else if val133 == nil {
				r.HiddenapiClassesJarPaths[val131] = nil
			} else {
				r.HiddenapiClassesJarPaths[val131] = val133.(android.Path)
			}
		}
	}

	var val135 bool
	if err = gobtools.DecodeBool(buf, &val135); err != nil {
		return err
	}
	if !val135 {
		var val134 bool
		err = gobtools.DecodeBool(buf, &val134)
		if err != nil {
			return err
		}
		r.UncompressDexState = &val134
	}

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

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

	if val140, err := gobtools.DecodeInterface(ctx, buf); err != nil {
		return err
	} else if val140 == nil {
		r.ConfigPath = nil
	} else {
		r.ConfigPath = val140.(android.WritablePath)
	}

	var val143 int
	err = gobtools.DecodeInt(buf, &val143)
	if err != nil {
		return err
	}
	if val143 != -1 {
		r.LogtagsSrcs = make([]android.Path, val143)
		for val144 := 0; val144 < int(val143); val144++ {
			if val146, err := gobtools.DecodeInterface(ctx, buf); err != nil {
				return err
			} else if val146 == nil {
				r.LogtagsSrcs[val144] = nil
			} else {
				r.LogtagsSrcs[val144] = val146.(android.Path)
			}
		}
	}

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

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

	var val151 int
	err = gobtools.DecodeInt(buf, &val151)
	if err != nil {
		return err
	}
	if val151 != -1 {
		r.LinterReports = make([]android.Path, val151)
		for val152 := 0; val152 < int(val151); val152++ {
			if val154, err := gobtools.DecodeInterface(ctx, buf); err != nil {
				return err
			} else if val154 == nil {
				r.LinterReports[val152] = nil
			} else {
				r.LinterReports[val152] = val154.(android.Path)
			}
		}
	}

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

	var val157 int
	err = gobtools.DecodeInt(buf, &val157)
	if err != nil {
		return err
	}
	if val157 != -1 {
		r.GeneratedSrcjars = make([]android.Path, val157)
		for val158 := 0; val158 < int(val157); val158++ {
			if val160, err := gobtools.DecodeInterface(ctx, buf); err != nil {
				return err
			} else if val160 == nil {
				r.GeneratedSrcjars[val158] = nil
			} else {
				r.GeneratedSrcjars[val158] = val160.(android.Path)
			}
		}
	}

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

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

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

	var val165 bool
	if err = gobtools.DecodeBool(buf, &val165); err != nil {
		return err
	}
	if !val165 {
		var val164 DexpreopterInfo
		if err = val164.Decode(ctx, buf); err != nil {
			return err
		}
		r.DexpreopterInfo = &val164
	}

	var val169 int
	err = gobtools.DecodeInt(buf, &val169)
	if err != nil {
		return err
	}
	if val169 != -1 {
		r.XrefJavaFiles = make([]android.Path, val169)
		for val170 := 0; val170 < int(val169); val170++ {
			if val172, err := gobtools.DecodeInterface(ctx, buf); err != nil {
				return err
			} else if val172 == nil {
				r.XrefJavaFiles[val170] = nil
			} else {
				r.XrefJavaFiles[val170] = val172.(android.Path)
			}
		}
	}

	var val175 int
	err = gobtools.DecodeInt(buf, &val175)
	if err != nil {
		return err
	}
	if val175 != -1 {
		r.XrefKotlinFiles = make([]android.Path, val175)
		for val176 := 0; val176 < int(val175); val176++ {
			if val178, err := gobtools.DecodeInterface(ctx, buf); err != nil {
				return err
			} else if val178 == nil {
				r.XrefKotlinFiles[val176] = nil
			} else {
				r.XrefKotlinFiles[val176] = val178.(android.Path)
			}
		}
	}

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

	var val181 bool
	if err = gobtools.DecodeBool(buf, &val181); err != nil {
		return err
	}
	if !val181 {
		var val180 bool
		err = gobtools.DecodeBool(buf, &val180)
		if err != nil {
			return err
		}
		r.CompileDex = &val180
	}

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

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

	var val186 bool
	if err = gobtools.DecodeBool(buf, &val186); err != nil {
		return err
	}
	if !val186 {
		var val185 ApexDependencyInfo
		if err = val185.Decode(ctx, buf); err != nil {
			return err
		}
		r.ApexDependencyInfo = &val185
	}

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

	return err
}

var JavaInfoGobRegId int16

func (r JavaInfo) GetTypeId() int16 {
	return JavaInfoGobRegId
}

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

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

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

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

func (r DexpreopterInfo) CustomHash(hasher *proptools.Hasher) error {
	hasher.WriteString(":java.DexpreopterInfo")
	hasher.WriteInt(3)
	hasher.WriteString(":java.android.Path")
	val1 := r.OutputProfilePathOnHost == nil
	if val1 {
		hasher.WriteByte(0)
	} else {
		if v := reflect.ValueOf(r.OutputProfilePathOnHost); v.Kind() == reflect.Ptr {
			if v.IsNil() {
				panic(fmt.Errorf("nil pointer is not supported in interface"))
			} else {
				val2 := r.OutputProfilePathOnHost == nil
				if val2 {
					hasher.WriteByte(0)
				} else {
					val3 := func(hasher *proptools.Hasher) error {
						return r.OutputProfilePathOnHost.(proptools.CustomHash).CustomHash(hasher)
					}
					if err := proptools.HashReference(hasher, uintptr(v.Pointer()), val3); err != nil {
						return err
					}
				}
			}
		} else {
			r.OutputProfilePathOnHost.(proptools.CustomHash).CustomHash(hasher)
		}
	}
	hasher.WriteString(":.[]DexpreopterInstall")
	hasher.WriteInt(len(r.ApexSystemServerDexpreoptInstalls))
	for val4 := 0; val4 < len(r.ApexSystemServerDexpreoptInstalls); val4++ {
		if err := r.ApexSystemServerDexpreoptInstalls[val4].CustomHash(hasher); err != nil {
			return err
		}
	}
	hasher.WriteString(":java.android.Paths")
	hasher.WriteString(":.[]Path")
	hasher.WriteInt(len(r.ApexSystemServerDexJars))
	for val5 := 0; val5 < len(r.ApexSystemServerDexJars); val5++ {
		hasher.WriteString("android/soong/android:android.Path")
		val6 := r.ApexSystemServerDexJars[val5] == nil
		if val6 {
			hasher.WriteByte(0)
		} else {
			if v := reflect.ValueOf(r.ApexSystemServerDexJars[val5]); v.Kind() == reflect.Ptr {
				if v.IsNil() {
					panic(fmt.Errorf("nil pointer is not supported in interface"))
				} else {
					val7 := r.ApexSystemServerDexJars[val5] == nil
					if val7 {
						hasher.WriteByte(0)
					} else {
						val8 := func(hasher *proptools.Hasher) error {
							return r.ApexSystemServerDexJars[val5].(proptools.CustomHash).CustomHash(hasher)
						}
						if err := proptools.HashReference(hasher, uintptr(v.Pointer()), val8); err != nil {
							return err
						}
					}
				}
			} else {
				r.ApexSystemServerDexJars[val5].(proptools.CustomHash).CustomHash(hasher)
			}
		}
	}
	return nil
}

func (r *DexpreopterInfo) 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.OutputProfilePathOnHost = nil
	} else {
		r.OutputProfilePathOnHost = val2.(android.Path)
	}

	var val4 int
	err = gobtools.DecodeInt(buf, &val4)
	if err != nil {
		return err
	}
	if val4 != -1 {
		r.ApexSystemServerDexpreoptInstalls = make([]DexpreopterInstall, val4)
		for val5 := 0; val5 < int(val4); val5++ {
			if err = r.ApexSystemServerDexpreoptInstalls[val5].Decode(ctx, buf); err != nil {
				return err
			}
		}
	}

	var val9 int
	err = gobtools.DecodeInt(buf, &val9)
	if err != nil {
		return err
	}
	if val9 != -1 {
		r.ApexSystemServerDexJars = 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.ApexSystemServerDexJars[val10] = nil
			} else {
				r.ApexSystemServerDexJars[val10] = val12.(android.Path)
			}
		}
	}

	return err
}

var DexpreopterInfoGobRegId int16

func (r DexpreopterInfo) GetTypeId() int16 {
	return DexpreopterInfoGobRegId
}

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

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

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

func (r JavaLibraryInfo) CustomHash(hasher *proptools.Hasher) error {
	hasher.WriteString(":java.JavaLibraryInfo")
	hasher.WriteInt(2)
	hasher.WriteString(":.bool")
	if r.Prebuilt {
		hasher.WriteByte(1)
	} else {
		hasher.WriteByte(0)
	}
	hasher.WriteString(":.[]string")
	hasher.WriteInt(len(r.PermittedPackages))
	for val1 := 0; val1 < len(r.PermittedPackages); val1++ {
		hasher.WriteString(":.string")
		hasher.WriteString(r.PermittedPackages[val1])
	}
	return nil
}

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

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

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

	return err
}

var JavaLibraryInfoGobRegId int16

func (r JavaLibraryInfo) GetTypeId() int16 {
	return JavaLibraryInfoGobRegId
}

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

func (r JavaDexImportInfo) CustomHash(hasher *proptools.Hasher) error {
	hasher.WriteString(":java.JavaDexImportInfo")
	hasher.WriteInt(0)
	return nil
}

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

	return err
}

var JavaDexImportInfoGobRegId int16

func (r JavaDexImportInfo) GetTypeId() int16 {
	return JavaDexImportInfoGobRegId
}

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

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

func (r SyspropPublicStubInfo) CustomHash(hasher *proptools.Hasher) error {
	hasher.WriteString(":java.SyspropPublicStubInfo")
	hasher.WriteInt(1)
	hasher.WriteString(":.*JavaInfo")
	val1 := r.JavaInfo == nil
	if val1 {
		hasher.WriteByte(0)
	} else {
		val2 := func(hasher *proptools.Hasher) error {
			if err := (*r.JavaInfo).CustomHash(hasher); err != nil {
				return err
			}
			return nil
		}
		if err := proptools.HashReference(hasher, uintptr(unsafe.Pointer(r.JavaInfo)), val2); err != nil {
			return err
		}
	}
	return nil
}

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

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

	return err
}

var SyspropPublicStubInfoGobRegId int16

func (r SyspropPublicStubInfo) GetTypeId() int16 {
	return SyspropPublicStubInfoGobRegId
}

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

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

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

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

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

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

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

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

func (r jniLib) CustomHash(hasher *proptools.Hasher) error {
	hasher.WriteString(":java.jniLib")
	hasher.WriteInt(7)
	hasher.WriteString(":.string")
	hasher.WriteString(r.name)
	hasher.WriteString(":java.android.Path")
	val1 := r.path == nil
	if val1 {
		hasher.WriteByte(0)
	} else {
		if v := reflect.ValueOf(r.path); v.Kind() == reflect.Ptr {
			if v.IsNil() {
				panic(fmt.Errorf("nil pointer is not supported in interface"))
			} else {
				val2 := r.path == nil
				if val2 {
					hasher.WriteByte(0)
				} else {
					val3 := func(hasher *proptools.Hasher) error { return r.path.(proptools.CustomHash).CustomHash(hasher) }
					if err := proptools.HashReference(hasher, uintptr(v.Pointer()), val3); err != nil {
						return err
					}
				}
			}
		} else {
			r.path.(proptools.CustomHash).CustomHash(hasher)
		}
	}
	if err := r.target.CustomHash(hasher); err != nil {
		return err
	}
	if err := r.coverageFile.CustomHash(hasher); err != nil {
		return err
	}
	hasher.WriteString(":java.android.Path")
	val4 := r.unstrippedFile == nil
	if val4 {
		hasher.WriteByte(0)
	} else {
		if v := reflect.ValueOf(r.unstrippedFile); v.Kind() == reflect.Ptr {
			if v.IsNil() {
				panic(fmt.Errorf("nil pointer is not supported in interface"))
			} else {
				val5 := r.unstrippedFile == nil
				if val5 {
					hasher.WriteByte(0)
				} else {
					val6 := func(hasher *proptools.Hasher) error {
						return r.unstrippedFile.(proptools.CustomHash).CustomHash(hasher)
					}
					if err := proptools.HashReference(hasher, uintptr(v.Pointer()), val6); err != nil {
						return err
					}
				}
			}
		} else {
			r.unstrippedFile.(proptools.CustomHash).CustomHash(hasher)
		}
	}
	hasher.WriteString(":.string")
	hasher.WriteString(r.partition)
	hasher.WriteString(":java.android.InstallPaths")
	hasher.WriteString(":.[]InstallPath")
	hasher.WriteInt(len(r.installPaths))
	for val7 := 0; val7 < len(r.installPaths); val7++ {
		if err := r.installPaths[val7].CustomHash(hasher); err != nil {
			return err
		}
	}
	return nil
}

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

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

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

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

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

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

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

	var val11 int
	err = gobtools.DecodeInt(buf, &val11)
	if err != nil {
		return err
	}
	if val11 != -1 {
		r.installPaths = make([]android.InstallPath, val11)
		for val12 := 0; val12 < int(val11); val12++ {
			if err = r.installPaths[val12].Decode(ctx, buf); err != nil {
				return err
			}
		}
	}

	return err
}

var jniLibGobRegId int16

func (r jniLib) GetTypeId() int16 {
	return jniLibGobRegId
}

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

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

func (r JavaTestInfo) CustomHash(hasher *proptools.Hasher) error {
	hasher.WriteString(":java.JavaTestInfo")
	hasher.WriteInt(1)
	hasher.WriteString(":java.android.Path")
	val1 := r.TestConfig == nil
	if val1 {
		hasher.WriteByte(0)
	} else {
		if v := reflect.ValueOf(r.TestConfig); v.Kind() == reflect.Ptr {
			if v.IsNil() {
				panic(fmt.Errorf("nil pointer is not supported in interface"))
			} else {
				val2 := r.TestConfig == nil
				if val2 {
					hasher.WriteByte(0)
				} else {
					val3 := func(hasher *proptools.Hasher) error { return r.TestConfig.(proptools.CustomHash).CustomHash(hasher) }
					if err := proptools.HashReference(hasher, uintptr(v.Pointer()), val3); err != nil {
						return err
					}
				}
			}
		} else {
			r.TestConfig.(proptools.CustomHash).CustomHash(hasher)
		}
	}
	return nil
}

func (r *JavaTestInfo) 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.TestConfig = nil
	} else {
		r.TestConfig = val2.(android.Path)
	}

	return err
}

var JavaTestInfoGobRegId int16

func (r JavaTestInfo) GetTypeId() int16 {
	return JavaTestInfoGobRegId
}

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

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

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

func (r JavaApiImportInfo) CustomHash(hasher *proptools.Hasher) error {
	hasher.WriteString(":java.JavaApiImportInfo")
	hasher.WriteInt(2)
	hasher.WriteString(":java.android.Path")
	val1 := r.ApiFile == nil
	if val1 {
		hasher.WriteByte(0)
	} else {
		if v := reflect.ValueOf(r.ApiFile); v.Kind() == reflect.Ptr {
			if v.IsNil() {
				panic(fmt.Errorf("nil pointer is not supported in interface"))
			} else {
				val2 := r.ApiFile == nil
				if val2 {
					hasher.WriteByte(0)
				} else {
					val3 := func(hasher *proptools.Hasher) error { return r.ApiFile.(proptools.CustomHash).CustomHash(hasher) }
					if err := proptools.HashReference(hasher, uintptr(v.Pointer()), val3); err != nil {
						return err
					}
				}
			}
		} else {
			r.ApiFile.(proptools.CustomHash).CustomHash(hasher)
		}
	}
	hasher.WriteString(":.string")
	hasher.WriteString(r.ApiSurface)
	return nil
}

func (r *JavaApiImportInfo) 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.ApiFile = nil
	} else {
		r.ApiFile = val2.(android.Path)
	}

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

	return err
}

var JavaApiImportInfoGobRegId int16

func (r JavaApiImportInfo) GetTypeId() int16 {
	return JavaApiImportInfoGobRegId
}

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

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

func (r JavaImportDepInSameApexChecker) CustomHash(hasher *proptools.Hasher) error {
	hasher.WriteString(":java.JavaImportDepInSameApexChecker")
	hasher.WriteInt(1)
	if err := r.BaseDepInSameApexChecker.CustomHash(hasher); err != nil {
		return err
	}
	return nil
}

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

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

	return err
}

var JavaImportDepInSameApexCheckerGobRegId int16

func (r JavaImportDepInSameApexChecker) GetTypeId() int16 {
	return JavaImportDepInSameApexCheckerGobRegId
}

// end of java.go

// begin of lint.go
func init() {
	LintInfoGobRegId = gobtools.RegisterType(func() gobtools.CustomDec { return new(LintInfo) })
	ModuleLintReportZipsInfoGobRegId = gobtools.RegisterType(func() gobtools.CustomDec { return new(ModuleLintReportZipsInfo) })
}

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

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

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

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

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

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

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

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

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

func (r LintInfo) CustomHash(hasher *proptools.Hasher) error {
	hasher.WriteString(":java.LintInfo")
	hasher.WriteInt(8)
	hasher.WriteString(":java.android.Path")
	val1 := r.HTML == nil
	if val1 {
		hasher.WriteByte(0)
	} else {
		if v := reflect.ValueOf(r.HTML); v.Kind() == reflect.Ptr {
			if v.IsNil() {
				panic(fmt.Errorf("nil pointer is not supported in interface"))
			} else {
				val2 := r.HTML == nil
				if val2 {
					hasher.WriteByte(0)
				} else {
					val3 := func(hasher *proptools.Hasher) error { return r.HTML.(proptools.CustomHash).CustomHash(hasher) }
					if err := proptools.HashReference(hasher, uintptr(v.Pointer()), val3); err != nil {
						return err
					}
				}
			}
		} else {
			r.HTML.(proptools.CustomHash).CustomHash(hasher)
		}
	}
	hasher.WriteString(":java.android.Path")
	val4 := r.Text == nil
	if val4 {
		hasher.WriteByte(0)
	} else {
		if v := reflect.ValueOf(r.Text); v.Kind() == reflect.Ptr {
			if v.IsNil() {
				panic(fmt.Errorf("nil pointer is not supported in interface"))
			} else {
				val5 := r.Text == nil
				if val5 {
					hasher.WriteByte(0)
				} else {
					val6 := func(hasher *proptools.Hasher) error { return r.Text.(proptools.CustomHash).CustomHash(hasher) }
					if err := proptools.HashReference(hasher, uintptr(v.Pointer()), val6); err != nil {
						return err
					}
				}
			}
		} else {
			r.Text.(proptools.CustomHash).CustomHash(hasher)
		}
	}
	hasher.WriteString(":java.android.Path")
	val7 := r.XML == nil
	if val7 {
		hasher.WriteByte(0)
	} else {
		if v := reflect.ValueOf(r.XML); v.Kind() == reflect.Ptr {
			if v.IsNil() {
				panic(fmt.Errorf("nil pointer is not supported in interface"))
			} else {
				val8 := r.XML == nil
				if val8 {
					hasher.WriteByte(0)
				} else {
					val9 := func(hasher *proptools.Hasher) error { return r.XML.(proptools.CustomHash).CustomHash(hasher) }
					if err := proptools.HashReference(hasher, uintptr(v.Pointer()), val9); err != nil {
						return err
					}
				}
			}
		} else {
			r.XML.(proptools.CustomHash).CustomHash(hasher)
		}
	}
	hasher.WriteString(":java.android.Path")
	val10 := r.ReferenceBaseline == nil
	if val10 {
		hasher.WriteByte(0)
	} else {
		if v := reflect.ValueOf(r.ReferenceBaseline); v.Kind() == reflect.Ptr {
			if v.IsNil() {
				panic(fmt.Errorf("nil pointer is not supported in interface"))
			} else {
				val11 := r.ReferenceBaseline == nil
				if val11 {
					hasher.WriteByte(0)
				} else {
					val12 := func(hasher *proptools.Hasher) error {
						return r.ReferenceBaseline.(proptools.CustomHash).CustomHash(hasher)
					}
					if err := proptools.HashReference(hasher, uintptr(v.Pointer()), val12); err != nil {
						return err
					}
				}
			}
		} else {
			r.ReferenceBaseline.(proptools.CustomHash).CustomHash(hasher)
		}
	}
	val17 := func(hasher *proptools.Hasher, val13 android.Path) error {
		hasher.WriteString(":java.android.Path")
		val14 := val13 == nil
		if val14 {
			hasher.WriteByte(0)
		} else {
			if v := reflect.ValueOf(val13); v.Kind() == reflect.Ptr {
				if v.IsNil() {
					panic(fmt.Errorf("nil pointer is not supported in interface"))
				} else {
					val15 := val13 == nil
					if val15 {
						hasher.WriteByte(0)
					} else {
						val16 := func(hasher *proptools.Hasher) error { return val13.(proptools.CustomHash).CustomHash(hasher) }
						if err := proptools.HashReference(hasher, uintptr(v.Pointer()), val16); err != nil {
							return err
						}
					}
				}
			} else {
				val13.(proptools.CustomHash).CustomHash(hasher)
			}
		}
		return nil
	}
	if err := r.TransitiveHTML.Hash(hasher, "android.Path", val17); err != nil {
		return err
	}
	val22 := func(hasher *proptools.Hasher, val18 android.Path) error {
		hasher.WriteString(":java.android.Path")
		val19 := val18 == nil
		if val19 {
			hasher.WriteByte(0)
		} else {
			if v := reflect.ValueOf(val18); v.Kind() == reflect.Ptr {
				if v.IsNil() {
					panic(fmt.Errorf("nil pointer is not supported in interface"))
				} else {
					val20 := val18 == nil
					if val20 {
						hasher.WriteByte(0)
					} else {
						val21 := func(hasher *proptools.Hasher) error { return val18.(proptools.CustomHash).CustomHash(hasher) }
						if err := proptools.HashReference(hasher, uintptr(v.Pointer()), val21); err != nil {
							return err
						}
					}
				}
			} else {
				val18.(proptools.CustomHash).CustomHash(hasher)
			}
		}
		return nil
	}
	if err := r.TransitiveText.Hash(hasher, "android.Path", val22); err != nil {
		return err
	}
	val27 := func(hasher *proptools.Hasher, val23 android.Path) error {
		hasher.WriteString(":java.android.Path")
		val24 := val23 == nil
		if val24 {
			hasher.WriteByte(0)
		} else {
			if v := reflect.ValueOf(val23); v.Kind() == reflect.Ptr {
				if v.IsNil() {
					panic(fmt.Errorf("nil pointer is not supported in interface"))
				} else {
					val25 := val23 == nil
					if val25 {
						hasher.WriteByte(0)
					} else {
						val26 := func(hasher *proptools.Hasher) error { return val23.(proptools.CustomHash).CustomHash(hasher) }
						if err := proptools.HashReference(hasher, uintptr(v.Pointer()), val26); err != nil {
							return err
						}
					}
				}
			} else {
				val23.(proptools.CustomHash).CustomHash(hasher)
			}
		}
		return nil
	}
	if err := r.TransitiveXML.Hash(hasher, "android.Path", val27); err != nil {
		return err
	}
	val32 := func(hasher *proptools.Hasher, val28 android.Path) error {
		hasher.WriteString(":java.android.Path")
		val29 := val28 == nil
		if val29 {
			hasher.WriteByte(0)
		} else {
			if v := reflect.ValueOf(val28); v.Kind() == reflect.Ptr {
				if v.IsNil() {
					panic(fmt.Errorf("nil pointer is not supported in interface"))
				} else {
					val30 := val28 == nil
					if val30 {
						hasher.WriteByte(0)
					} else {
						val31 := func(hasher *proptools.Hasher) error { return val28.(proptools.CustomHash).CustomHash(hasher) }
						if err := proptools.HashReference(hasher, uintptr(v.Pointer()), val31); err != nil {
							return err
						}
					}
				}
			} else {
				val28.(proptools.CustomHash).CustomHash(hasher)
			}
		}
		return nil
	}
	if err := r.TransitiveBaseline.Hash(hasher, "android.Path", val32); err != nil {
		return err
	}
	return nil
}

func (r *LintInfo) 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.HTML = nil
	} else {
		r.HTML = val2.(android.Path)
	}

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

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

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

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

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

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

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

	return err
}

var LintInfoGobRegId int16

func (r LintInfo) GetTypeId() int16 {
	return LintInfoGobRegId
}

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

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

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

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

func (r ModuleLintReportZipsInfo) CustomHash(hasher *proptools.Hasher) error {
	hasher.WriteString(":java.ModuleLintReportZipsInfo")
	hasher.WriteInt(3)
	hasher.WriteString(":java.android.Path")
	val1 := r.HtmlZip == nil
	if val1 {
		hasher.WriteByte(0)
	} else {
		if v := reflect.ValueOf(r.HtmlZip); v.Kind() == reflect.Ptr {
			if v.IsNil() {
				panic(fmt.Errorf("nil pointer is not supported in interface"))
			} else {
				val2 := r.HtmlZip == nil
				if val2 {
					hasher.WriteByte(0)
				} else {
					val3 := func(hasher *proptools.Hasher) error { return r.HtmlZip.(proptools.CustomHash).CustomHash(hasher) }
					if err := proptools.HashReference(hasher, uintptr(v.Pointer()), val3); err != nil {
						return err
					}
				}
			}
		} else {
			r.HtmlZip.(proptools.CustomHash).CustomHash(hasher)
		}
	}
	hasher.WriteString(":java.android.Path")
	val4 := r.TextZip == nil
	if val4 {
		hasher.WriteByte(0)
	} else {
		if v := reflect.ValueOf(r.TextZip); v.Kind() == reflect.Ptr {
			if v.IsNil() {
				panic(fmt.Errorf("nil pointer is not supported in interface"))
			} else {
				val5 := r.TextZip == nil
				if val5 {
					hasher.WriteByte(0)
				} else {
					val6 := func(hasher *proptools.Hasher) error { return r.TextZip.(proptools.CustomHash).CustomHash(hasher) }
					if err := proptools.HashReference(hasher, uintptr(v.Pointer()), val6); err != nil {
						return err
					}
				}
			}
		} else {
			r.TextZip.(proptools.CustomHash).CustomHash(hasher)
		}
	}
	hasher.WriteString(":java.android.Path")
	val7 := r.XmlZip == nil
	if val7 {
		hasher.WriteByte(0)
	} else {
		if v := reflect.ValueOf(r.XmlZip); v.Kind() == reflect.Ptr {
			if v.IsNil() {
				panic(fmt.Errorf("nil pointer is not supported in interface"))
			} else {
				val8 := r.XmlZip == nil
				if val8 {
					hasher.WriteByte(0)
				} else {
					val9 := func(hasher *proptools.Hasher) error { return r.XmlZip.(proptools.CustomHash).CustomHash(hasher) }
					if err := proptools.HashReference(hasher, uintptr(v.Pointer()), val9); err != nil {
						return err
					}
				}
			}
		} else {
			r.XmlZip.(proptools.CustomHash).CustomHash(hasher)
		}
	}
	return nil
}

func (r *ModuleLintReportZipsInfo) 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.HtmlZip = nil
	} else {
		r.HtmlZip = val2.(android.Path)
	}

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

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

	return err
}

var ModuleLintReportZipsInfoGobRegId int16

func (r ModuleLintReportZipsInfo) GetTypeId() int16 {
	return ModuleLintReportZipsInfoGobRegId
}

// end of lint.go

// begin of platform_compat_config.go
func init() {
	PlatformCompatConfigInfoGobRegId = gobtools.RegisterType(func() gobtools.CustomDec { return new(PlatformCompatConfigInfo) })
}

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

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

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

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

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

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

func (r PlatformCompatConfigInfo) CustomHash(hasher *proptools.Hasher) error {
	hasher.WriteString(":java.PlatformCompatConfigInfo")
	hasher.WriteInt(5)
	if err := r.CompatConfig.CustomHash(hasher); err != nil {
		return err
	}
	hasher.WriteString(":.string")
	hasher.WriteString(r.SubDir)
	hasher.WriteString(":java.android.Path")
	val1 := r.CompatConfigMetadata == nil
	if val1 {
		hasher.WriteByte(0)
	} else {
		if v := reflect.ValueOf(r.CompatConfigMetadata); v.Kind() == reflect.Ptr {
			if v.IsNil() {
				panic(fmt.Errorf("nil pointer is not supported in interface"))
			} else {
				val2 := r.CompatConfigMetadata == nil
				if val2 {
					hasher.WriteByte(0)
				} else {
					val3 := func(hasher *proptools.Hasher) error {
						return r.CompatConfigMetadata.(proptools.CustomHash).CustomHash(hasher)
					}
					if err := proptools.HashReference(hasher, uintptr(v.Pointer()), val3); err != nil {
						return err
					}
				}
			}
		} else {
			r.CompatConfigMetadata.(proptools.CustomHash).CustomHash(hasher)
		}
	}
	hasher.WriteString(":.bool")
	if r.IncludeInMergedXml {
		hasher.WriteByte(1)
	} else {
		hasher.WriteByte(0)
	}
	hasher.WriteString(":.bool")
	if r.Prebuilt {
		hasher.WriteByte(1)
	} else {
		hasher.WriteByte(0)
	}
	return nil
}

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

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

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

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

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

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

	return err
}

var PlatformCompatConfigInfoGobRegId int16

func (r PlatformCompatConfigInfo) GetTypeId() int16 {
	return PlatformCompatConfigInfoGobRegId
}

// end of platform_compat_config.go

// begin of plugin.go
func init() {
	JavaPluginInfoGobRegId = gobtools.RegisterType(func() gobtools.CustomDec { return new(JavaPluginInfo) })
	KotlinPluginInfoGobRegId = gobtools.RegisterType(func() gobtools.CustomDec { return new(KotlinPluginInfo) })
}

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

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

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

func (r JavaPluginInfo) CustomHash(hasher *proptools.Hasher) error {
	hasher.WriteString(":java.JavaPluginInfo")
	hasher.WriteInt(2)
	hasher.WriteString(":.*string")
	val1 := r.ProcessorClass == nil
	if val1 {
		hasher.WriteByte(0)
	} else {
		val2 := func(hasher *proptools.Hasher) error {
			hasher.WriteString(":.string")
			hasher.WriteString((*r.ProcessorClass))
			return nil
		}
		if err := proptools.HashReference(hasher, uintptr(unsafe.Pointer(r.ProcessorClass)), val2); err != nil {
			return err
		}
	}
	hasher.WriteString(":.bool")
	if r.GeneratesApi {
		hasher.WriteByte(1)
	} else {
		hasher.WriteByte(0)
	}
	return nil
}

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

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

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

	return err
}

var JavaPluginInfoGobRegId int16

func (r JavaPluginInfo) GetTypeId() int16 {
	return JavaPluginInfoGobRegId
}

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

func (r KotlinPluginInfo) CustomHash(hasher *proptools.Hasher) error {
	hasher.WriteString(":java.KotlinPluginInfo")
	hasher.WriteInt(0)
	return nil
}

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

	return err
}

var KotlinPluginInfoGobRegId int16

func (r KotlinPluginInfo) GetTypeId() int16 {
	return KotlinPluginInfoGobRegId
}

// end of plugin.go

// begin of ravenwood.go
func init() {
	ravenwoodLibgroupJniDepProviderInfoGobRegId = gobtools.RegisterType(func() gobtools.CustomDec { return new(ravenwoodLibgroupJniDepProviderInfo) })
	ravenwoodLibgroupInfoGobRegId = gobtools.RegisterType(func() gobtools.CustomDec { return new(ravenwoodLibgroupInfo) })
}

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

	if r.names == nil {
		if err = gobtools.EncodeInt(buf, -1); err != nil {
			return err
		}
	} else {
		if err = gobtools.EncodeInt(buf, len(r.names)); err != nil {
			return err
		}
		for val1, val2 := range r.names {
			if err = gobtools.EncodeString(buf, val1); err != nil {
				return err
			}
			if err = gobtools.EncodeBool(buf, val2); err != nil {
				return err
			}
		}
	}
	return err
}

func (r ravenwoodLibgroupJniDepProviderInfo) CustomHash(hasher *proptools.Hasher) error {
	hasher.WriteString(":java.ravenwoodLibgroupJniDepProviderInfo")
	hasher.WriteInt(1)
	hasher.WriteString(":.map[string]bool")
	hasher.WriteInt(len(r.names))
	val1 := make([]string, 0, len(r.names))
	for val3 := range r.names {
		val1 = append(val1, val3)
	}
	proptools.SortOrdered(val1)
	for _, val2 := range val1 {
		hasher.WriteString(":.string")
		hasher.WriteString(val2)
		hasher.WriteString(":.bool")
		if r.names[val2] {
			hasher.WriteByte(1)
		} else {
			hasher.WriteByte(0)
		}
	}
	return nil
}

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

	var val1 int
	err = gobtools.DecodeInt(buf, &val1)
	if err != nil {
		return err
	}
	if val1 != -1 {
		r.names = make(map[string]bool, val1)
		for val2 := 0; val2 < int(val1); val2++ {
			var val3 string
			var val4 bool
			err = gobtools.DecodeString(buf, &val3)
			if err != nil {
				return err
			}
			err = gobtools.DecodeBool(buf, &val4)
			if err != nil {
				return err
			}
			r.names[val3] = val4
		}
	}

	return err
}

var ravenwoodLibgroupJniDepProviderInfoGobRegId int16

func (r ravenwoodLibgroupJniDepProviderInfo) GetTypeId() int16 {
	return ravenwoodLibgroupJniDepProviderInfoGobRegId
}

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

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

func (r ravenwoodLibgroupInfo) CustomHash(hasher *proptools.Hasher) error {
	hasher.WriteString(":java.ravenwoodLibgroupInfo")
	hasher.WriteInt(1)
	hasher.WriteString(":.[]string")
	hasher.WriteInt(len(r.libs))
	for val1 := 0; val1 < len(r.libs); val1++ {
		hasher.WriteString(":.string")
		hasher.WriteString(r.libs[val1])
	}
	return nil
}

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

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

	return err
}

var ravenwoodLibgroupInfoGobRegId int16

func (r ravenwoodLibgroupInfo) GetTypeId() int16 {
	return ravenwoodLibgroupInfoGobRegId
}

// end of ravenwood.go

// begin of robolectric.go
func init() {
	RobolectricRuntimesInfoGobRegId = gobtools.RegisterType(func() gobtools.CustomDec { return new(RobolectricRuntimesInfo) })
}

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

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

func (r RobolectricRuntimesInfo) CustomHash(hasher *proptools.Hasher) error {
	hasher.WriteString(":java.RobolectricRuntimesInfo")
	hasher.WriteInt(1)
	hasher.WriteString(":.[]android.InstallPath")
	hasher.WriteInt(len(r.Runtimes))
	for val1 := 0; val1 < len(r.Runtimes); val1++ {
		if err := r.Runtimes[val1].CustomHash(hasher); err != nil {
			return err
		}
	}
	return nil
}

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

	var val2 int
	err = gobtools.DecodeInt(buf, &val2)
	if err != nil {
		return err
	}
	if val2 != -1 {
		r.Runtimes = make([]android.InstallPath, val2)
		for val3 := 0; val3 < int(val2); val3++ {
			if err = r.Runtimes[val3].Decode(ctx, buf); err != nil {
				return err
			}
		}
	}

	return err
}

var RobolectricRuntimesInfoGobRegId int16

func (r RobolectricRuntimesInfo) GetTypeId() int16 {
	return RobolectricRuntimesInfoGobRegId
}

// end of robolectric.go

// begin of rro.go
func init() {
	RuntimeResourceOverlayInfoGobRegId = gobtools.RegisterType(func() gobtools.CustomDec { return new(RuntimeResourceOverlayInfo) })
}

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

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

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

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

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

func (r RuntimeResourceOverlayInfo) CustomHash(hasher *proptools.Hasher) error {
	hasher.WriteString(":java.RuntimeResourceOverlayInfo")
	hasher.WriteInt(4)
	hasher.WriteString(":java.android.Path")
	val1 := r.OutputFile == nil
	if val1 {
		hasher.WriteByte(0)
	} else {
		if v := reflect.ValueOf(r.OutputFile); v.Kind() == reflect.Ptr {
			if v.IsNil() {
				panic(fmt.Errorf("nil pointer is not supported in interface"))
			} else {
				val2 := r.OutputFile == nil
				if val2 {
					hasher.WriteByte(0)
				} else {
					val3 := func(hasher *proptools.Hasher) error { return r.OutputFile.(proptools.CustomHash).CustomHash(hasher) }
					if err := proptools.HashReference(hasher, uintptr(v.Pointer()), val3); err != nil {
						return err
					}
				}
			}
		} else {
			r.OutputFile.(proptools.CustomHash).CustomHash(hasher)
		}
	}
	if err := r.Certificate.CustomHash(hasher); err != nil {
		return err
	}
	hasher.WriteString(":.string")
	hasher.WriteString(r.Theme)
	hasher.WriteString(":.string")
	hasher.WriteString(r.OverriddenManifestPackageName)
	return nil
}

func (r *RuntimeResourceOverlayInfo) 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.OutputFile = nil
	} else {
		r.OutputFile = val2.(android.Path)
	}

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

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

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

	return err
}

var RuntimeResourceOverlayInfoGobRegId int16

func (r RuntimeResourceOverlayInfo) GetTypeId() int16 {
	return RuntimeResourceOverlayInfoGobRegId
}

// end of rro.go

// begin of sdk_library.go
func init() {
	SdkLibraryComponentDependencyInfoGobRegId = gobtools.RegisterType(func() gobtools.CustomDec { return new(SdkLibraryComponentDependencyInfo) })
	ApiScopePathsInfoGobRegId = gobtools.RegisterType(func() gobtools.CustomDec { return new(ApiScopePathsInfo) })
	ApiScopePropsInfoGobRegId = gobtools.RegisterType(func() gobtools.CustomDec { return new(ApiScopePropsInfo) })
	SdkLibraryInfoGobRegId = gobtools.RegisterType(func() gobtools.CustomDec { return new(SdkLibraryInfo) })
	SdkLibraryDepInSameApexCheckerGobRegId = gobtools.RegisterType(func() gobtools.CustomDec { return new(SdkLibraryDepInSameApexChecker) })
	SdkLibraryImportDepIsInSameApexCheckerGobRegId = gobtools.RegisterType(func() gobtools.CustomDec { return new(SdkLibraryImportDepIsInSameApexChecker) })
}

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

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

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

func (r SdkLibraryComponentDependencyInfo) CustomHash(hasher *proptools.Hasher) error {
	hasher.WriteString(":java.SdkLibraryComponentDependencyInfo")
	hasher.WriteInt(2)
	hasher.WriteString(":.*string")
	val1 := r.OptionalSdkLibraryImplementation == nil
	if val1 {
		hasher.WriteByte(0)
	} else {
		val2 := func(hasher *proptools.Hasher) error {
			hasher.WriteString(":.string")
			hasher.WriteString((*r.OptionalSdkLibraryImplementation))
			return nil
		}
		if err := proptools.HashReference(hasher, uintptr(unsafe.Pointer(r.OptionalSdkLibraryImplementation)), val2); err != nil {
			return err
		}
	}
	hasher.WriteString(":.*string")
	val3 := r.SdkLibraryName == nil
	if val3 {
		hasher.WriteByte(0)
	} else {
		val4 := func(hasher *proptools.Hasher) error {
			hasher.WriteString(":.string")
			hasher.WriteString((*r.SdkLibraryName))
			return nil
		}
		if err := proptools.HashReference(hasher, uintptr(unsafe.Pointer(r.SdkLibraryName)), val4); err != nil {
			return err
		}
	}
	return nil
}

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

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

	var val5 bool
	if err = gobtools.DecodeBool(buf, &val5); err != nil {
		return err
	}
	if !val5 {
		var val4 string
		err = gobtools.DecodeString(buf, &val4)
		if err != nil {
			return err
		}
		r.SdkLibraryName = &val4
	}

	return err
}

var SdkLibraryComponentDependencyInfoGobRegId int16

func (r SdkLibraryComponentDependencyInfo) GetTypeId() int16 {
	return SdkLibraryComponentDependencyInfoGobRegId
}

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

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

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

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

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

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

func (r ApiScopePathsInfo) CustomHash(hasher *proptools.Hasher) error {
	hasher.WriteString(":java.ApiScopePathsInfo")
	hasher.WriteInt(5)
	hasher.WriteString(":java.android.Paths")
	hasher.WriteString(":.[]Path")
	hasher.WriteInt(len(r.StubsImplPath))
	for val1 := 0; val1 < len(r.StubsImplPath); val1++ {
		hasher.WriteString("android/soong/android:android.Path")
		val2 := r.StubsImplPath[val1] == nil
		if val2 {
			hasher.WriteByte(0)
		} else {
			if v := reflect.ValueOf(r.StubsImplPath[val1]); v.Kind() == reflect.Ptr {
				if v.IsNil() {
					panic(fmt.Errorf("nil pointer is not supported in interface"))
				} else {
					val3 := r.StubsImplPath[val1] == nil
					if val3 {
						hasher.WriteByte(0)
					} else {
						val4 := func(hasher *proptools.Hasher) error {
							return r.StubsImplPath[val1].(proptools.CustomHash).CustomHash(hasher)
						}
						if err := proptools.HashReference(hasher, uintptr(v.Pointer()), val4); err != nil {
							return err
						}
					}
				}
			} else {
				r.StubsImplPath[val1].(proptools.CustomHash).CustomHash(hasher)
			}
		}
	}
	if err := r.CurrentApiFilePath.CustomHash(hasher); err != nil {
		return err
	}
	if err := r.RemovedApiFilePath.CustomHash(hasher); err != nil {
		return err
	}
	if err := r.StubsSrcJar.CustomHash(hasher); err != nil {
		return err
	}
	if err := r.AnnotationsZip.CustomHash(hasher); err != nil {
		return err
	}
	return nil
}

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

	var val3 int
	err = gobtools.DecodeInt(buf, &val3)
	if err != nil {
		return err
	}
	if val3 != -1 {
		r.StubsImplPath = 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.StubsImplPath[val4] = nil
			} else {
				r.StubsImplPath[val4] = val6.(android.Path)
			}
		}
	}

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

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

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

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

	return err
}

var ApiScopePathsInfoGobRegId int16

func (r ApiScopePathsInfo) GetTypeId() int16 {
	return ApiScopePathsInfoGobRegId
}

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

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

func (r ApiScopePropsInfo) CustomHash(hasher *proptools.Hasher) error {
	hasher.WriteString(":java.ApiScopePropsInfo")
	hasher.WriteInt(1)
	hasher.WriteString(":.*string")
	val1 := r.SdkVersion == nil
	if val1 {
		hasher.WriteByte(0)
	} else {
		val2 := func(hasher *proptools.Hasher) error {
			hasher.WriteString(":.string")
			hasher.WriteString((*r.SdkVersion))
			return nil
		}
		if err := proptools.HashReference(hasher, uintptr(unsafe.Pointer(r.SdkVersion)), val2); err != nil {
			return err
		}
	}
	return nil
}

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

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

	return err
}

var ApiScopePropsInfoGobRegId int16

func (r ApiScopePropsInfo) GetTypeId() int16 {
	return ApiScopePropsInfoGobRegId
}

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

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

	if r.EverythingStubDexJarPaths == nil {
		if err = gobtools.EncodeInt(buf, -1); err != nil {
			return err
		}
	} else {
		if err = gobtools.EncodeInt(buf, len(r.EverythingStubDexJarPaths)); err != nil {
			return err
		}
		for val2, val3 := range r.EverythingStubDexJarPaths {
			if err = gobtools.EncodeInt(buf, int(val2)); err != nil {
				return err
			}
			if err = val3.Encode(ctx, buf); err != nil {
				return err
			}
		}
	}

	if r.ExportableStubDexJarPaths == nil {
		if err = gobtools.EncodeInt(buf, -1); err != nil {
			return err
		}
	} else {
		if err = gobtools.EncodeInt(buf, len(r.ExportableStubDexJarPaths)); err != nil {
			return err
		}
		for val4, val5 := range r.ExportableStubDexJarPaths {
			if err = gobtools.EncodeInt(buf, int(val4)); err != nil {
				return err
			}
			if err = val5.Encode(ctx, buf); err != nil {
				return err
			}
		}
	}

	if r.RemovedTxtFiles == nil {
		if err = gobtools.EncodeInt(buf, -1); err != nil {
			return err
		}
	} else {
		if err = gobtools.EncodeInt(buf, len(r.RemovedTxtFiles)); err != nil {
			return err
		}
		for val6, val7 := range r.RemovedTxtFiles {
			if err = gobtools.EncodeInt(buf, int(val6)); err != nil {
				return err
			}
			if err = val7.Encode(ctx, buf); err != nil {
				return err
			}
		}
	}

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

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

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

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

	val9 := r.OnBootclasspathSince == nil
	if err = gobtools.EncodeBool(buf, val9); err != nil {
		return err
	}
	if !val9 {
		if err = gobtools.EncodeString(buf, (*r.OnBootclasspathSince)); err != nil {
			return err
		}
	}

	val10 := r.OnBootclasspathBefore == nil
	if err = gobtools.EncodeBool(buf, val10); err != nil {
		return err
	}
	if !val10 {
		if err = gobtools.EncodeString(buf, (*r.OnBootclasspathBefore)); err != nil {
			return err
		}
	}

	val11 := r.MinDeviceSdk == nil
	if err = gobtools.EncodeBool(buf, val11); err != nil {
		return err
	}
	if !val11 {
		if err = gobtools.EncodeString(buf, (*r.MinDeviceSdk)); err != nil {
			return err
		}
	}

	val12 := r.MaxDeviceSdk == nil
	if err = gobtools.EncodeBool(buf, val12); err != nil {
		return err
	}
	if !val12 {
		if err = gobtools.EncodeString(buf, (*r.MaxDeviceSdk)); err != nil {
			return err
		}
	}

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

	if r.ApiScopePaths == nil {
		if err = gobtools.EncodeInt(buf, -1); err != nil {
			return err
		}
	} else {
		if err = gobtools.EncodeInt(buf, len(r.ApiScopePaths)); err != nil {
			return err
		}
		for val13, val14 := range r.ApiScopePaths {
			if err = gobtools.EncodeString(buf, val13); err != nil {
				return err
			}
			if err = val14.Encode(ctx, buf); err != nil {
				return err
			}
		}
	}

	if r.ApiScopeProps == nil {
		if err = gobtools.EncodeInt(buf, -1); err != nil {
			return err
		}
	} else {
		if err = gobtools.EncodeInt(buf, len(r.ApiScopeProps)); err != nil {
			return err
		}
		for val15, val16 := range r.ApiScopeProps {
			if err = gobtools.EncodeString(buf, val15); err != nil {
				return err
			}
			if err = val16.Encode(ctx, buf); err != nil {
				return err
			}
		}
	}
	return err
}

func (r SdkLibraryInfo) CustomHash(hasher *proptools.Hasher) error {
	hasher.WriteString(":java.SdkLibraryInfo")
	hasher.WriteInt(15)
	hasher.WriteString(":.[]string")
	hasher.WriteInt(len(r.GeneratingLibs))
	for val1 := 0; val1 < len(r.GeneratingLibs); val1++ {
		hasher.WriteString(":.string")
		hasher.WriteString(r.GeneratingLibs[val1])
	}
	hasher.WriteString(":.map[android.SdkKind]OptionalDexJarPath")
	hasher.WriteInt(len(r.EverythingStubDexJarPaths))
	val2 := make([]android.SdkKind, 0, len(r.EverythingStubDexJarPaths))
	for val4 := range r.EverythingStubDexJarPaths {
		val2 = append(val2, val4)
	}
	proptools.SortOrdered(val2)
	for _, val3 := range val2 {
		hasher.WriteString(":java.android.SdkKind")
		hasher.WriteString(":.int")
		hasher.WriteUint64(uint64(int(val3)))
		if err := r.EverythingStubDexJarPaths[val3].CustomHash(hasher); err != nil {
			return err
		}
	}
	hasher.WriteString(":.map[android.SdkKind]OptionalDexJarPath")
	hasher.WriteInt(len(r.ExportableStubDexJarPaths))
	val5 := make([]android.SdkKind, 0, len(r.ExportableStubDexJarPaths))
	for val7 := range r.ExportableStubDexJarPaths {
		val5 = append(val5, val7)
	}
	proptools.SortOrdered(val5)
	for _, val6 := range val5 {
		hasher.WriteString(":java.android.SdkKind")
		hasher.WriteString(":.int")
		hasher.WriteUint64(uint64(int(val6)))
		if err := r.ExportableStubDexJarPaths[val6].CustomHash(hasher); err != nil {
			return err
		}
	}
	hasher.WriteString(":.map[android.SdkKind]android.OptionalPath")
	hasher.WriteInt(len(r.RemovedTxtFiles))
	val8 := make([]android.SdkKind, 0, len(r.RemovedTxtFiles))
	for val10 := range r.RemovedTxtFiles {
		val8 = append(val8, val10)
	}
	proptools.SortOrdered(val8)
	for _, val9 := range val8 {
		hasher.WriteString(":java.android.SdkKind")
		hasher.WriteString(":.int")
		hasher.WriteUint64(uint64(int(val9)))
		if err := r.RemovedTxtFiles[val9].CustomHash(hasher); err != nil {
			return err
		}
	}
	hasher.WriteString(":.bool")
	if r.SharedLibrary {
		hasher.WriteByte(1)
	} else {
		hasher.WriteByte(0)
	}
	hasher.WriteString(":.bool")
	if r.Prebuilt {
		hasher.WriteByte(1)
	} else {
		hasher.WriteByte(0)
	}
	hasher.WriteString(":.string")
	hasher.WriteString(r.DistStem)
	hasher.WriteString(":java.android.Paths")
	hasher.WriteString(":.[]Path")
	hasher.WriteInt(len(r.DoctagPaths))
	for val11 := 0; val11 < len(r.DoctagPaths); val11++ {
		hasher.WriteString("android/soong/android:android.Path")
		val12 := r.DoctagPaths[val11] == nil
		if val12 {
			hasher.WriteByte(0)
		} else {
			if v := reflect.ValueOf(r.DoctagPaths[val11]); v.Kind() == reflect.Ptr {
				if v.IsNil() {
					panic(fmt.Errorf("nil pointer is not supported in interface"))
				} else {
					val13 := r.DoctagPaths[val11] == nil
					if val13 {
						hasher.WriteByte(0)
					} else {
						val14 := func(hasher *proptools.Hasher) error {
							return r.DoctagPaths[val11].(proptools.CustomHash).CustomHash(hasher)
						}
						if err := proptools.HashReference(hasher, uintptr(v.Pointer()), val14); err != nil {
							return err
						}
					}
				}
			} else {
				r.DoctagPaths[val11].(proptools.CustomHash).CustomHash(hasher)
			}
		}
	}
	hasher.WriteString(":.*string")
	val15 := r.OnBootclasspathSince == nil
	if val15 {
		hasher.WriteByte(0)
	} else {
		val16 := func(hasher *proptools.Hasher) error {
			hasher.WriteString(":.string")
			hasher.WriteString((*r.OnBootclasspathSince))
			return nil
		}
		if err := proptools.HashReference(hasher, uintptr(unsafe.Pointer(r.OnBootclasspathSince)), val16); err != nil {
			return err
		}
	}
	hasher.WriteString(":.*string")
	val17 := r.OnBootclasspathBefore == nil
	if val17 {
		hasher.WriteByte(0)
	} else {
		val18 := func(hasher *proptools.Hasher) error {
			hasher.WriteString(":.string")
			hasher.WriteString((*r.OnBootclasspathBefore))
			return nil
		}
		if err := proptools.HashReference(hasher, uintptr(unsafe.Pointer(r.OnBootclasspathBefore)), val18); err != nil {
			return err
		}
	}
	hasher.WriteString(":.*string")
	val19 := r.MinDeviceSdk == nil
	if val19 {
		hasher.WriteByte(0)
	} else {
		val20 := func(hasher *proptools.Hasher) error {
			hasher.WriteString(":.string")
			hasher.WriteString((*r.MinDeviceSdk))
			return nil
		}
		if err := proptools.HashReference(hasher, uintptr(unsafe.Pointer(r.MinDeviceSdk)), val20); err != nil {
			return err
		}
	}
	hasher.WriteString(":.*string")
	val21 := r.MaxDeviceSdk == nil
	if val21 {
		hasher.WriteByte(0)
	} else {
		val22 := func(hasher *proptools.Hasher) error {
			hasher.WriteString(":.string")
			hasher.WriteString((*r.MaxDeviceSdk))
			return nil
		}
		if err := proptools.HashReference(hasher, uintptr(unsafe.Pointer(r.MaxDeviceSdk)), val22); err != nil {
			return err
		}
	}
	hasher.WriteString(":.bool")
	if r.ImplLibProfileGuided {
		hasher.WriteByte(1)
	} else {
		hasher.WriteByte(0)
	}
	hasher.WriteString(":.map[string]ApiScopePathsInfo")
	hasher.WriteInt(len(r.ApiScopePaths))
	val23 := make([]string, 0, len(r.ApiScopePaths))
	for val25 := range r.ApiScopePaths {
		val23 = append(val23, val25)
	}
	proptools.SortOrdered(val23)
	for _, val24 := range val23 {
		hasher.WriteString(":.string")
		hasher.WriteString(val24)
		if err := r.ApiScopePaths[val24].CustomHash(hasher); err != nil {
			return err
		}
	}
	hasher.WriteString(":.map[string]ApiScopePropsInfo")
	hasher.WriteInt(len(r.ApiScopeProps))
	val26 := make([]string, 0, len(r.ApiScopeProps))
	for val28 := range r.ApiScopeProps {
		val26 = append(val26, val28)
	}
	proptools.SortOrdered(val26)
	for _, val27 := range val26 {
		hasher.WriteString(":.string")
		hasher.WriteString(val27)
		if err := r.ApiScopeProps[val27].CustomHash(hasher); err != nil {
			return err
		}
	}
	return nil
}

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

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

	var val5 int
	err = gobtools.DecodeInt(buf, &val5)
	if err != nil {
		return err
	}
	if val5 != -1 {
		r.EverythingStubDexJarPaths = make(map[android.SdkKind]OptionalDexJarPath, val5)
		for val6 := 0; val6 < int(val5); val6++ {
			var val7 android.SdkKind
			var val8 OptionalDexJarPath
			var val10 int
			err = gobtools.DecodeInt(buf, &val10)
			if err != nil {
				return err
			}
			val7 = android.SdkKind(val10)
			if err = val8.Decode(ctx, buf); err != nil {
				return err
			}
			r.EverythingStubDexJarPaths[val7] = val8
		}
	}

	var val13 int
	err = gobtools.DecodeInt(buf, &val13)
	if err != nil {
		return err
	}
	if val13 != -1 {
		r.ExportableStubDexJarPaths = make(map[android.SdkKind]OptionalDexJarPath, val13)
		for val14 := 0; val14 < int(val13); val14++ {
			var val15 android.SdkKind
			var val16 OptionalDexJarPath
			var val18 int
			err = gobtools.DecodeInt(buf, &val18)
			if err != nil {
				return err
			}
			val15 = android.SdkKind(val18)
			if err = val16.Decode(ctx, buf); err != nil {
				return err
			}
			r.ExportableStubDexJarPaths[val15] = val16
		}
	}

	var val21 int
	err = gobtools.DecodeInt(buf, &val21)
	if err != nil {
		return err
	}
	if val21 != -1 {
		r.RemovedTxtFiles = make(map[android.SdkKind]android.OptionalPath, val21)
		for val22 := 0; val22 < int(val21); val22++ {
			var val23 android.SdkKind
			var val24 android.OptionalPath
			var val26 int
			err = gobtools.DecodeInt(buf, &val26)
			if err != nil {
				return err
			}
			val23 = android.SdkKind(val26)
			if err = val24.Decode(ctx, buf); err != nil {
				return err
			}
			r.RemovedTxtFiles[val23] = val24
		}
	}

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

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

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

	var val34 int
	err = gobtools.DecodeInt(buf, &val34)
	if err != nil {
		return err
	}
	if val34 != -1 {
		r.DoctagPaths = make([]android.Path, val34)
		for val35 := 0; val35 < int(val34); val35++ {
			if val37, err := gobtools.DecodeInterface(ctx, buf); err != nil {
				return err
			} else if val37 == nil {
				r.DoctagPaths[val35] = nil
			} else {
				r.DoctagPaths[val35] = val37.(android.Path)
			}
		}
	}

	var val39 bool
	if err = gobtools.DecodeBool(buf, &val39); err != nil {
		return err
	}
	if !val39 {
		var val38 string
		err = gobtools.DecodeString(buf, &val38)
		if err != nil {
			return err
		}
		r.OnBootclasspathSince = &val38
	}

	var val42 bool
	if err = gobtools.DecodeBool(buf, &val42); err != nil {
		return err
	}
	if !val42 {
		var val41 string
		err = gobtools.DecodeString(buf, &val41)
		if err != nil {
			return err
		}
		r.OnBootclasspathBefore = &val41
	}

	var val45 bool
	if err = gobtools.DecodeBool(buf, &val45); err != nil {
		return err
	}
	if !val45 {
		var val44 string
		err = gobtools.DecodeString(buf, &val44)
		if err != nil {
			return err
		}
		r.MinDeviceSdk = &val44
	}

	var val48 bool
	if err = gobtools.DecodeBool(buf, &val48); err != nil {
		return err
	}
	if !val48 {
		var val47 string
		err = gobtools.DecodeString(buf, &val47)
		if err != nil {
			return err
		}
		r.MaxDeviceSdk = &val47
	}

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

	var val51 int
	err = gobtools.DecodeInt(buf, &val51)
	if err != nil {
		return err
	}
	if val51 != -1 {
		r.ApiScopePaths = make(map[string]ApiScopePathsInfo, val51)
		for val52 := 0; val52 < int(val51); val52++ {
			var val53 string
			var val54 ApiScopePathsInfo
			err = gobtools.DecodeString(buf, &val53)
			if err != nil {
				return err
			}
			if err = val54.Decode(ctx, buf); err != nil {
				return err
			}
			r.ApiScopePaths[val53] = val54
		}
	}

	var val57 int
	err = gobtools.DecodeInt(buf, &val57)
	if err != nil {
		return err
	}
	if val57 != -1 {
		r.ApiScopeProps = make(map[string]ApiScopePropsInfo, val57)
		for val58 := 0; val58 < int(val57); val58++ {
			var val59 string
			var val60 ApiScopePropsInfo
			err = gobtools.DecodeString(buf, &val59)
			if err != nil {
				return err
			}
			if err = val60.Decode(ctx, buf); err != nil {
				return err
			}
			r.ApiScopeProps[val59] = val60
		}
	}

	return err
}

var SdkLibraryInfoGobRegId int16

func (r SdkLibraryInfo) GetTypeId() int16 {
	return SdkLibraryInfoGobRegId
}

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

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

func (r SdkLibraryDepInSameApexChecker) CustomHash(hasher *proptools.Hasher) error {
	hasher.WriteString(":java.SdkLibraryDepInSameApexChecker")
	hasher.WriteInt(1)
	if err := r.BaseDepInSameApexChecker.CustomHash(hasher); err != nil {
		return err
	}
	return nil
}

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

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

	return err
}

var SdkLibraryDepInSameApexCheckerGobRegId int16

func (r SdkLibraryDepInSameApexChecker) GetTypeId() int16 {
	return SdkLibraryDepInSameApexCheckerGobRegId
}

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

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

func (r SdkLibraryImportDepIsInSameApexChecker) CustomHash(hasher *proptools.Hasher) error {
	hasher.WriteString(":java.SdkLibraryImportDepIsInSameApexChecker")
	hasher.WriteInt(1)
	if err := r.BaseDepInSameApexChecker.CustomHash(hasher); err != nil {
		return err
	}
	return nil
}

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

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

	return err
}

var SdkLibraryImportDepIsInSameApexCheckerGobRegId int16

func (r SdkLibraryImportDepIsInSameApexChecker) GetTypeId() int16 {
	return SdkLibraryImportDepIsInSameApexCheckerGobRegId
}

// end of sdk_library.go

// begin of system_modules.go
func init() {
	SystemModulesProviderInfoGobRegId = gobtools.RegisterType(func() gobtools.CustomDec { return new(SystemModulesProviderInfo) })
}

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

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

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

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

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

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

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

func (r SystemModulesProviderInfo) CustomHash(hasher *proptools.Hasher) error {
	hasher.WriteString(":java.SystemModulesProviderInfo")
	hasher.WriteInt(6)
	hasher.WriteString(":java.android.Paths")
	hasher.WriteString(":.[]Path")
	hasher.WriteInt(len(r.HeaderJars))
	for val1 := 0; val1 < len(r.HeaderJars); val1++ {
		hasher.WriteString("android/soong/android:android.Path")
		val2 := r.HeaderJars[val1] == nil
		if val2 {
			hasher.WriteByte(0)
		} else {
			if v := reflect.ValueOf(r.HeaderJars[val1]); v.Kind() == reflect.Ptr {
				if v.IsNil() {
					panic(fmt.Errorf("nil pointer is not supported in interface"))
				} else {
					val3 := r.HeaderJars[val1] == nil
					if val3 {
						hasher.WriteByte(0)
					} else {
						val4 := func(hasher *proptools.Hasher) error {
							return r.HeaderJars[val1].(proptools.CustomHash).CustomHash(hasher)
						}
						if err := proptools.HashReference(hasher, uintptr(v.Pointer()), val4); err != nil {
							return err
						}
					}
				}
			} else {
				r.HeaderJars[val1].(proptools.CustomHash).CustomHash(hasher)
			}
		}
	}
	hasher.WriteString(":java.android.Path")
	val5 := r.OutputDir == nil
	if val5 {
		hasher.WriteByte(0)
	} else {
		if v := reflect.ValueOf(r.OutputDir); v.Kind() == reflect.Ptr {
			if v.IsNil() {
				panic(fmt.Errorf("nil pointer is not supported in interface"))
			} else {
				val6 := r.OutputDir == nil
				if val6 {
					hasher.WriteByte(0)
				} else {
					val7 := func(hasher *proptools.Hasher) error { return r.OutputDir.(proptools.CustomHash).CustomHash(hasher) }
					if err := proptools.HashReference(hasher, uintptr(v.Pointer()), val7); err != nil {
						return err
					}
				}
			}
		} else {
			r.OutputDir.(proptools.CustomHash).CustomHash(hasher)
		}
	}
	hasher.WriteString(":java.android.Paths")
	hasher.WriteString(":.[]Path")
	hasher.WriteInt(len(r.OutputDirDeps))
	for val8 := 0; val8 < len(r.OutputDirDeps); val8++ {
		hasher.WriteString("android/soong/android:android.Path")
		val9 := r.OutputDirDeps[val8] == nil
		if val9 {
			hasher.WriteByte(0)
		} else {
			if v := reflect.ValueOf(r.OutputDirDeps[val8]); v.Kind() == reflect.Ptr {
				if v.IsNil() {
					panic(fmt.Errorf("nil pointer is not supported in interface"))
				} else {
					val10 := r.OutputDirDeps[val8] == nil
					if val10 {
						hasher.WriteByte(0)
					} else {
						val11 := func(hasher *proptools.Hasher) error {
							return r.OutputDirDeps[val8].(proptools.CustomHash).CustomHash(hasher)
						}
						if err := proptools.HashReference(hasher, uintptr(v.Pointer()), val11); err != nil {
							return err
						}
					}
				}
			} else {
				r.OutputDirDeps[val8].(proptools.CustomHash).CustomHash(hasher)
			}
		}
	}
	val16 := func(hasher *proptools.Hasher, val12 android.Path) error {
		hasher.WriteString(":java.android.Path")
		val13 := val12 == nil
		if val13 {
			hasher.WriteByte(0)
		} else {
			if v := reflect.ValueOf(val12); v.Kind() == reflect.Ptr {
				if v.IsNil() {
					panic(fmt.Errorf("nil pointer is not supported in interface"))
				} else {
					val14 := val12 == nil
					if val14 {
						hasher.WriteByte(0)
					} else {
						val15 := func(hasher *proptools.Hasher) error { return val12.(proptools.CustomHash).CustomHash(hasher) }
						if err := proptools.HashReference(hasher, uintptr(v.Pointer()), val15); err != nil {
							return err
						}
					}
				}
			} else {
				val12.(proptools.CustomHash).CustomHash(hasher)
			}
		}
		return nil
	}
	if err := r.TransitiveStaticLibsHeaderJars.Hash(hasher, "android.Path", val16); err != nil {
		return err
	}
	hasher.WriteString(":.bool")
	if r.Prebuilt {
		hasher.WriteByte(1)
	} else {
		hasher.WriteByte(0)
	}
	hasher.WriteString(":.[]string")
	hasher.WriteInt(len(r.Libs))
	for val17 := 0; val17 < len(r.Libs); val17++ {
		hasher.WriteString(":.string")
		hasher.WriteString(r.Libs[val17])
	}
	return nil
}

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

	var val3 int
	err = gobtools.DecodeInt(buf, &val3)
	if err != nil {
		return err
	}
	if val3 != -1 {
		r.HeaderJars = 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.HeaderJars[val4] = nil
			} else {
				r.HeaderJars[val4] = val6.(android.Path)
			}
		}
	}

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

	var val11 int
	err = gobtools.DecodeInt(buf, &val11)
	if err != nil {
		return err
	}
	if val11 != -1 {
		r.OutputDirDeps = make([]android.Path, val11)
		for val12 := 0; val12 < int(val11); val12++ {
			if val14, err := gobtools.DecodeInterface(ctx, buf); err != nil {
				return err
			} else if val14 == nil {
				r.OutputDirDeps[val12] = nil
			} else {
				r.OutputDirDeps[val12] = val14.(android.Path)
			}
		}
	}

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

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

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

	return err
}

var SystemModulesProviderInfoGobRegId int16

func (r SystemModulesProviderInfo) GetTypeId() int16 {
	return SystemModulesProviderInfoGobRegId
}

// end of system_modules.go

// begin of systemserver_classpath_fragment.go
func init() {
	SystemServerClasspathInfoGobRegId = gobtools.RegisterType(func() gobtools.CustomDec { return new(SystemServerClasspathInfo) })
	LibraryNameToPartitionInfoGobRegId = gobtools.RegisterType(func() gobtools.CustomDec { return new(LibraryNameToPartitionInfo) })
}

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

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

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

func (r SystemServerClasspathInfo) CustomHash(hasher *proptools.Hasher) error {
	hasher.WriteString(":java.SystemServerClasspathInfo")
	hasher.WriteInt(2)
	hasher.WriteString(":.[]string")
	hasher.WriteInt(len(r.Contents))
	for val1 := 0; val1 < len(r.Contents); val1++ {
		hasher.WriteString(":.string")
		hasher.WriteString(r.Contents[val1])
	}
	hasher.WriteString(":.[]string")
	hasher.WriteInt(len(r.StandaloneContents))
	for val2 := 0; val2 < len(r.StandaloneContents); val2++ {
		hasher.WriteString(":.string")
		hasher.WriteString(r.StandaloneContents[val2])
	}
	return nil
}

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

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

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

	return err
}

var SystemServerClasspathInfoGobRegId int16

func (r SystemServerClasspathInfo) GetTypeId() int16 {
	return SystemServerClasspathInfoGobRegId
}

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

	if r.LibraryNameToPartition == nil {
		if err = gobtools.EncodeInt(buf, -1); err != nil {
			return err
		}
	} else {
		if err = gobtools.EncodeInt(buf, len(r.LibraryNameToPartition)); err != nil {
			return err
		}
		for val1, val2 := range r.LibraryNameToPartition {
			if err = gobtools.EncodeString(buf, val1); err != nil {
				return err
			}
			if err = gobtools.EncodeString(buf, val2); err != nil {
				return err
			}
		}
	}
	return err
}

func (r LibraryNameToPartitionInfo) CustomHash(hasher *proptools.Hasher) error {
	hasher.WriteString(":java.LibraryNameToPartitionInfo")
	hasher.WriteInt(1)
	hasher.WriteString(":.map[string]string")
	hasher.WriteInt(len(r.LibraryNameToPartition))
	val1 := make([]string, 0, len(r.LibraryNameToPartition))
	for val3 := range r.LibraryNameToPartition {
		val1 = append(val1, val3)
	}
	proptools.SortOrdered(val1)
	for _, val2 := range val1 {
		hasher.WriteString(":.string")
		hasher.WriteString(val2)
		hasher.WriteString(":.string")
		hasher.WriteString(r.LibraryNameToPartition[val2])
	}
	return nil
}

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

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

	return err
}

var LibraryNameToPartitionInfoGobRegId int16

func (r LibraryNameToPartitionInfo) GetTypeId() int16 {
	return LibraryNameToPartitionInfoGobRegId
}

// end of systemserver_classpath_fragment.go