android/android_enc.go

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

package android

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

// begin of aconfig_providers.go
func init() {
	AconfigDeclarationsProviderDataGobRegId = gobtools.RegisterType(func() gobtools.CustomDec { return new(AconfigDeclarationsProviderData) })
	AconfigReleaseDeclarationsProviderDataGobRegId = gobtools.RegisterType(func() gobtools.CustomDec { return new(AconfigReleaseDeclarationsProviderData) })
	ModeInfoGobRegId = gobtools.RegisterType(func() gobtools.CustomDec { return new(ModeInfo) })
	CodegenInfoGobRegId = gobtools.RegisterType(func() gobtools.CustomDec { return new(CodegenInfo) })
	aconfigPropagatingDeclarationsInfoGobRegId = gobtools.RegisterType(func() gobtools.CustomDec { return new(aconfigPropagatingDeclarationsInfo) })
}

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

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

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

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

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

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

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

func (r AconfigDeclarationsProviderData) CustomHash(hasher *proptools.Hasher) error {
	hasher.WriteString(":android.AconfigDeclarationsProviderData")
	hasher.WriteInt(6)
	hasher.WriteString(":.string")
	hasher.WriteString(r.Package)
	hasher.WriteString(":.string")
	hasher.WriteString(r.Container)
	hasher.WriteString(":.bool")
	if r.Exportable {
		hasher.WriteByte(1)
	} else {
		hasher.WriteByte(0)
	}
	hasher.WriteString(":android.WritablePath")
	val1 := r.IntermediateCacheOutputPath == nil
	if val1 {
		hasher.WriteByte(0)
	} else {
		if v := reflect.ValueOf(r.IntermediateCacheOutputPath); v.Kind() == reflect.Ptr {
			if v.IsNil() {
				panic(fmt.Errorf("nil pointer is not supported in interface"))
			} else {
				val2 := r.IntermediateCacheOutputPath == nil
				if val2 {
					hasher.WriteByte(0)
				} else {
					val3 := func(hasher *proptools.Hasher) error {
						return r.IntermediateCacheOutputPath.(proptools.CustomHash).CustomHash(hasher)
					}
					if err := proptools.HashReference(hasher, uintptr(v.Pointer()), val3); err != nil {
						return err
					}
				}
			}
		} else {
			r.IntermediateCacheOutputPath.(proptools.CustomHash).CustomHash(hasher)
		}
	}
	hasher.WriteString(":android.WritablePath")
	val4 := r.IntermediateDumpOutputPath == nil
	if val4 {
		hasher.WriteByte(0)
	} else {
		if v := reflect.ValueOf(r.IntermediateDumpOutputPath); v.Kind() == reflect.Ptr {
			if v.IsNil() {
				panic(fmt.Errorf("nil pointer is not supported in interface"))
			} else {
				val5 := r.IntermediateDumpOutputPath == nil
				if val5 {
					hasher.WriteByte(0)
				} else {
					val6 := func(hasher *proptools.Hasher) error {
						return r.IntermediateDumpOutputPath.(proptools.CustomHash).CustomHash(hasher)
					}
					if err := proptools.HashReference(hasher, uintptr(v.Pointer()), val6); err != nil {
						return err
					}
				}
			}
		} else {
			r.IntermediateDumpOutputPath.(proptools.CustomHash).CustomHash(hasher)
		}
	}
	hasher.WriteString(":android.Paths")
	hasher.WriteString(":.[]Path")
	hasher.WriteInt(len(r.Srcs))
	for val7 := 0; val7 < len(r.Srcs); val7++ {
		hasher.WriteString(":android.Path")
		val8 := r.Srcs[val7] == nil
		if val8 {
			hasher.WriteByte(0)
		} else {
			if v := reflect.ValueOf(r.Srcs[val7]); v.Kind() == reflect.Ptr {
				if v.IsNil() {
					panic(fmt.Errorf("nil pointer is not supported in interface"))
				} else {
					val9 := r.Srcs[val7] == nil
					if val9 {
						hasher.WriteByte(0)
					} else {
						val10 := func(hasher *proptools.Hasher) error { return r.Srcs[val7].(proptools.CustomHash).CustomHash(hasher) }
						if err := proptools.HashReference(hasher, uintptr(v.Pointer()), val10); err != nil {
							return err
						}
					}
				}
			} else {
				r.Srcs[val7].(proptools.CustomHash).CustomHash(hasher)
			}
		}
	}
	return nil
}

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

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

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

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

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

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

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

	return err
}

var AconfigDeclarationsProviderDataGobRegId int16

func (r AconfigDeclarationsProviderData) GetTypeId() int16 {
	return AconfigDeclarationsProviderDataGobRegId
}

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

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

func (r AconfigReleaseDeclarationsProviderData) CustomHash(hasher *proptools.Hasher) error {
	hasher.WriteString(":android.AconfigReleaseDeclarationsProviderData")
	hasher.WriteInt(1)
	hasher.WriteString(":.map[string]AconfigDeclarationsProviderData")
	hasher.WriteInt(len(r.Data))
	val1 := make([]string, 0, len(r.Data))
	for val3 := range r.Data {
		val1 = append(val1, val3)
	}
	proptools.SortOrdered(val1)
	for _, val2 := range val1 {
		hasher.WriteString(":.string")
		hasher.WriteString(val2)
		if err := r.Data[val2].CustomHash(hasher); err != nil {
			return err
		}
	}
	return nil
}

func (r *AconfigReleaseDeclarationsProviderData) 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.Data = make(map[string]AconfigDeclarationsProviderData, val1)
		for val2 := 0; val2 < int(val1); val2++ {
			var val3 string
			var val4 AconfigDeclarationsProviderData
			err = gobtools.DecodeString(buf, &val3)
			if err != nil {
				return err
			}
			if err = val4.Decode(ctx, buf); err != nil {
				return err
			}
			r.Data[val3] = val4
		}
	}

	return err
}

var AconfigReleaseDeclarationsProviderDataGobRegId int16

func (r AconfigReleaseDeclarationsProviderData) GetTypeId() int16 {
	return AconfigReleaseDeclarationsProviderDataGobRegId
}

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

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

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

func (r ModeInfo) CustomHash(hasher *proptools.Hasher) error {
	hasher.WriteString(":android.ModeInfo")
	hasher.WriteInt(2)
	hasher.WriteString(":.string")
	hasher.WriteString(r.Container)
	hasher.WriteString(":.string")
	hasher.WriteString(r.Mode)
	return nil
}

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

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

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

	return err
}

var ModeInfoGobRegId int16

func (r ModeInfo) GetTypeId() int16 {
	return ModeInfoGobRegId
}

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

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

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

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

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

func (r CodegenInfo) CustomHash(hasher *proptools.Hasher) error {
	hasher.WriteString(":android.CodegenInfo")
	hasher.WriteInt(4)
	hasher.WriteString(":.[]string")
	hasher.WriteInt(len(r.AconfigDeclarations))
	for val1 := 0; val1 < len(r.AconfigDeclarations); val1++ {
		hasher.WriteString(":.string")
		hasher.WriteString(r.AconfigDeclarations[val1])
	}
	hasher.WriteString(":android.Paths")
	hasher.WriteString(":.[]Path")
	hasher.WriteInt(len(r.IntermediateCacheOutputPaths))
	for val2 := 0; val2 < len(r.IntermediateCacheOutputPaths); val2++ {
		hasher.WriteString(":android.Path")
		val3 := r.IntermediateCacheOutputPaths[val2] == nil
		if val3 {
			hasher.WriteByte(0)
		} else {
			if v := reflect.ValueOf(r.IntermediateCacheOutputPaths[val2]); v.Kind() == reflect.Ptr {
				if v.IsNil() {
					panic(fmt.Errorf("nil pointer is not supported in interface"))
				} else {
					val4 := r.IntermediateCacheOutputPaths[val2] == nil
					if val4 {
						hasher.WriteByte(0)
					} else {
						val5 := func(hasher *proptools.Hasher) error {
							return r.IntermediateCacheOutputPaths[val2].(proptools.CustomHash).CustomHash(hasher)
						}
						if err := proptools.HashReference(hasher, uintptr(v.Pointer()), val5); err != nil {
							return err
						}
					}
				}
			} else {
				r.IntermediateCacheOutputPaths[val2].(proptools.CustomHash).CustomHash(hasher)
			}
		}
	}
	hasher.WriteString(":android.Paths")
	hasher.WriteString(":.[]Path")
	hasher.WriteInt(len(r.Srcjars))
	for val6 := 0; val6 < len(r.Srcjars); val6++ {
		hasher.WriteString(":android.Path")
		val7 := r.Srcjars[val6] == nil
		if val7 {
			hasher.WriteByte(0)
		} else {
			if v := reflect.ValueOf(r.Srcjars[val6]); v.Kind() == reflect.Ptr {
				if v.IsNil() {
					panic(fmt.Errorf("nil pointer is not supported in interface"))
				} else {
					val8 := r.Srcjars[val6] == nil
					if val8 {
						hasher.WriteByte(0)
					} else {
						val9 := func(hasher *proptools.Hasher) error { return r.Srcjars[val6].(proptools.CustomHash).CustomHash(hasher) }
						if err := proptools.HashReference(hasher, uintptr(v.Pointer()), val9); err != nil {
							return err
						}
					}
				}
			} else {
				r.Srcjars[val6].(proptools.CustomHash).CustomHash(hasher)
			}
		}
	}
	hasher.WriteString(":.map[string]ModeInfo")
	hasher.WriteInt(len(r.ModeInfos))
	val10 := make([]string, 0, len(r.ModeInfos))
	for val12 := range r.ModeInfos {
		val10 = append(val10, val12)
	}
	proptools.SortOrdered(val10)
	for _, val11 := range val10 {
		hasher.WriteString(":.string")
		hasher.WriteString(val11)
		if err := r.ModeInfos[val11].CustomHash(hasher); err != nil {
			return err
		}
	}
	return nil
}

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

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

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

	var val17 int
	err = gobtools.DecodeInt(buf, &val17)
	if err != nil {
		return err
	}
	if val17 != -1 {
		r.ModeInfos = make(map[string]ModeInfo, val17)
		for val18 := 0; val18 < int(val17); val18++ {
			var val19 string
			var val20 ModeInfo
			err = gobtools.DecodeString(buf, &val19)
			if err != nil {
				return err
			}
			if err = val20.Decode(ctx, buf); err != nil {
				return err
			}
			r.ModeInfos[val19] = val20
		}
	}

	return err
}

var CodegenInfoGobRegId int16

func (r CodegenInfo) GetTypeId() int16 {
	return CodegenInfoGobRegId
}

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

	if r.AconfigFiles == nil {
		if err = gobtools.EncodeInt(buf, -1); err != nil {
			return err
		}
	} else {
		if err = gobtools.EncodeInt(buf, len(r.AconfigFiles)); err != nil {
			return err
		}
		for val1, val2 := range r.AconfigFiles {
			if err = gobtools.EncodeString(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++ {
					if err = gobtools.EncodeInterface(ctx, buf, val2[val3]); err != nil {
						return err
					}
				}
			}
		}
	}

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

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

func (r *aconfigPropagatingDeclarationsInfo) 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.AconfigFiles = make(map[string]Paths, val1)
		for val2 := 0; val2 < int(val1); val2++ {
			var val3 string
			var val4 Paths
			err = gobtools.DecodeString(buf, &val3)
			if err != nil {
				return err
			}
			var val8 int
			err = gobtools.DecodeInt(buf, &val8)
			if err != nil {
				return err
			}
			if val8 != -1 {
				val4 = make([]Path, val8)
				for val9 := 0; val9 < int(val8); val9++ {
					if val11, err := gobtools.DecodeInterface(ctx, buf); err != nil {
						return err
					} else if val11 == nil {
						val4[val9] = nil
					} else {
						val4[val9] = val11.(Path)
					}
				}
			}
			r.AconfigFiles[val3] = val4
		}
	}

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

	return err
}

var aconfigPropagatingDeclarationsInfoGobRegId int16

func (r aconfigPropagatingDeclarationsInfo) GetTypeId() int16 {
	return aconfigPropagatingDeclarationsInfoGobRegId
}

// end of aconfig_providers.go

// begin of android_info.go
func init() {
	AndroidInfoGobRegId = gobtools.RegisterType(func() gobtools.CustomDec { return new(AndroidInfo) })
}

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

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

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

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

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

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

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

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

	return err
}

var AndroidInfoGobRegId int16

func (r AndroidInfo) GetTypeId() int16 {
	return AndroidInfoGobRegId
}

// end of android_info.go

// begin of androidmk.go
func init() {
	AndroidMkDataInfoGobRegId = gobtools.RegisterType(func() gobtools.CustomDec { return new(AndroidMkDataInfo) })
	AndroidMkProviderInfoGobRegId = gobtools.RegisterType(func() gobtools.CustomDec { return new(AndroidMkProviderInfo) })
	AndroidMkInfoGobRegId = gobtools.RegisterType(func() gobtools.CustomDec { return new(AndroidMkInfo) })
}

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

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

func (r AndroidMkDataInfo) CustomHash(hasher *proptools.Hasher) error {
	hasher.WriteString(":android.AndroidMkDataInfo")
	hasher.WriteInt(1)
	hasher.WriteString(":.string")
	hasher.WriteString(r.Class)
	return nil
}

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

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

	return err
}

var AndroidMkDataInfoGobRegId int16

func (r AndroidMkDataInfo) GetTypeId() int16 {
	return AndroidMkDataInfoGobRegId
}

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

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

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

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

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

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

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

	return err
}

var AndroidMkProviderInfoGobRegId int16

func (r AndroidMkProviderInfo) GetTypeId() int16 {
	return AndroidMkProviderInfoGobRegId
}

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

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

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

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

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

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

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

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

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

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

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

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

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

func (r AndroidMkInfo) CustomHash(hasher *proptools.Hasher) error {
	hasher.WriteString(":android.AndroidMkInfo")
	hasher.WriteInt(12)
	hasher.WriteString(":.string")
	hasher.WriteString(r.Class)
	hasher.WriteString(":.string")
	hasher.WriteString(r.SubName)
	hasher.WriteString(":.string")
	hasher.WriteString(r.OverrideName)
	if err := r.OutputFile.CustomHash(hasher); err != nil {
		return err
	}
	hasher.WriteString(":.string")
	hasher.WriteString(r.Include)
	hasher.WriteString(":.[]string")
	hasher.WriteInt(len(r.Required))
	for val1 := 0; val1 < len(r.Required); val1++ {
		hasher.WriteString(":.string")
		hasher.WriteString(r.Required[val1])
	}
	hasher.WriteString(":.[]string")
	hasher.WriteInt(len(r.Host_required))
	for val2 := 0; val2 < len(r.Host_required); val2++ {
		hasher.WriteString(":.string")
		hasher.WriteString(r.Host_required[val2])
	}
	hasher.WriteString(":.[]string")
	hasher.WriteInt(len(r.Target_required))
	for val3 := 0; val3 < len(r.Target_required); val3++ {
		hasher.WriteString(":.string")
		hasher.WriteString(r.Target_required[val3])
	}
	hasher.WriteString(":.[]string")
	hasher.WriteInt(len(r.HeaderStrings))
	for val4 := 0; val4 < len(r.HeaderStrings); val4++ {
		hasher.WriteString(":.string")
		hasher.WriteString(r.HeaderStrings[val4])
	}
	hasher.WriteString(":.[]string")
	hasher.WriteInt(len(r.FooterStrings))
	for val5 := 0; val5 < len(r.FooterStrings); val5++ {
		hasher.WriteString(":.string")
		hasher.WriteString(r.FooterStrings[val5])
	}
	hasher.WriteString(":.map[string][]string")
	hasher.WriteInt(len(r.EntryMap))
	val6 := make([]string, 0, len(r.EntryMap))
	for val8 := range r.EntryMap {
		val6 = append(val6, val8)
	}
	proptools.SortOrdered(val6)
	for _, val7 := range val6 {
		hasher.WriteString(":.string")
		hasher.WriteString(val7)
		hasher.WriteString(":.[]string")
		hasher.WriteInt(len(r.EntryMap[val7]))
		for val9 := 0; val9 < len(r.EntryMap[val7]); val9++ {
			hasher.WriteString(":.string")
			hasher.WriteString(r.EntryMap[val7][val9])
		}
	}
	hasher.WriteString(":.[]string")
	hasher.WriteInt(len(r.EntryOrder))
	for val10 := 0; val10 < len(r.EntryOrder); val10++ {
		hasher.WriteString(":.string")
		hasher.WriteString(r.EntryOrder[val10])
	}
	return nil
}

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

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

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

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

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

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

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

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

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

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

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

	var val26 int
	err = gobtools.DecodeInt(buf, &val26)
	if err != nil {
		return err
	}
	if val26 != -1 {
		r.EntryMap = make(map[string][]string, val26)
		for val27 := 0; val27 < int(val26); val27++ {
			var val28 string
			var val29 []string
			err = gobtools.DecodeString(buf, &val28)
			if err != nil {
				return err
			}
			var val32 int
			err = gobtools.DecodeInt(buf, &val32)
			if err != nil {
				return err
			}
			if val32 != -1 {
				val29 = make([]string, val32)
				for val33 := 0; val33 < int(val32); val33++ {
					err = gobtools.DecodeString(buf, &val29[val33])
					if err != nil {
						return err
					}
				}
			}
			r.EntryMap[val28] = val29
		}
	}

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

	return err
}

var AndroidMkInfoGobRegId int16

func (r AndroidMkInfo) GetTypeId() int16 {
	return AndroidMkInfoGobRegId
}

// end of androidmk.go

// begin of apex.go
func init() {
	ApexInfoGobRegId = gobtools.RegisterType(func() gobtools.CustomDec { return new(ApexInfo) })
	ApexAvailableInfoGobRegId = gobtools.RegisterType(func() gobtools.CustomDec { return new(ApexAvailableInfo) })
	ApexBundleInfoGobRegId = gobtools.RegisterType(func() gobtools.CustomDec { return new(ApexBundleInfo) })
	PlatformAvailabilityInfoGobRegId = gobtools.RegisterType(func() gobtools.CustomDec { return new(PlatformAvailabilityInfo) })
	DepInSameApexInfoGobRegId = gobtools.RegisterType(func() gobtools.CustomDec { return new(DepInSameApexInfo) })
	BaseDepInSameApexCheckerGobRegId = gobtools.RegisterType(func() gobtools.CustomDec { return new(BaseDepInSameApexChecker) })
	ApexBundleDepsInfoGobRegId = gobtools.RegisterType(func() gobtools.CustomDec { return new(ApexBundleDepsInfo) })
	ApexBundleTypeInfoGobRegId = gobtools.RegisterType(func() gobtools.CustomDec { return new(ApexBundleTypeInfo) })
	ApexExportsInfoGobRegId = gobtools.RegisterType(func() gobtools.CustomDec { return new(ApexExportsInfo) })
	PrebuiltJsonInfoGobRegId = gobtools.RegisterType(func() gobtools.CustomDec { return new(PrebuiltJsonInfo) })
}

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

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

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

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

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

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

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

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

func (r ApexInfo) CustomHash(hasher *proptools.Hasher) error {
	hasher.WriteString(":android.ApexInfo")
	hasher.WriteInt(7)
	hasher.WriteString(":.string")
	hasher.WriteString(r.ApexVariationName)
	if err := r.MinSdkVersion.CustomHash(hasher); err != nil {
		return err
	}
	hasher.WriteString(":.bool")
	if r.Updatable {
		hasher.WriteByte(1)
	} else {
		hasher.WriteByte(0)
	}
	hasher.WriteString(":.bool")
	if r.UsePlatformApis {
		hasher.WriteByte(1)
	} else {
		hasher.WriteByte(0)
	}
	hasher.WriteString(":.bool")
	if r.ForPrebuiltApex {
		hasher.WriteByte(1)
	} else {
		hasher.WriteByte(0)
	}
	hasher.WriteString(":.string")
	hasher.WriteString(r.BaseApexName)
	hasher.WriteString(":.string")
	hasher.WriteString(r.ApexAvailableName)
	return nil
}

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

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

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

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

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

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

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

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

	return err
}

var ApexInfoGobRegId int16

func (r ApexInfo) GetTypeId() int16 {
	return ApexInfoGobRegId
}

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

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

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

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

	return err
}

var ApexAvailableInfoGobRegId int16

func (r ApexAvailableInfo) GetTypeId() int16 {
	return ApexAvailableInfoGobRegId
}

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

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

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

	return err
}

var ApexBundleInfoGobRegId int16

func (r ApexBundleInfo) GetTypeId() int16 {
	return ApexBundleInfoGobRegId
}

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

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

func (r PlatformAvailabilityInfo) CustomHash(hasher *proptools.Hasher) error {
	hasher.WriteString(":android.PlatformAvailabilityInfo")
	hasher.WriteInt(1)
	hasher.WriteString(":.bool")
	if r.NotAvailableToPlatform {
		hasher.WriteByte(1)
	} else {
		hasher.WriteByte(0)
	}
	return nil
}

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

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

	return err
}

var PlatformAvailabilityInfoGobRegId int16

func (r PlatformAvailabilityInfo) GetTypeId() int16 {
	return PlatformAvailabilityInfoGobRegId
}

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

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

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

func (r *DepInSameApexInfo) 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.Checker = nil
	} else {
		r.Checker = val2.(DepInSameApexChecker)
	}

	return err
}

var DepInSameApexInfoGobRegId int16

func (r DepInSameApexInfo) GetTypeId() int16 {
	return DepInSameApexInfoGobRegId
}

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

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

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

	return err
}

var BaseDepInSameApexCheckerGobRegId int16

func (r BaseDepInSameApexChecker) GetTypeId() int16 {
	return BaseDepInSameApexCheckerGobRegId
}

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

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

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

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

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

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

	return err
}

var ApexBundleDepsInfoGobRegId int16

func (r ApexBundleDepsInfo) GetTypeId() int16 {
	return ApexBundleDepsInfoGobRegId
}

func (r ApexBundleTypeInfo) 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
	}
	return err
}

func (r ApexBundleTypeInfo) CustomHash(hasher *proptools.Hasher) error {
	hasher.WriteString(":android.ApexBundleTypeInfo")
	hasher.WriteInt(2)
	hasher.WriteString(":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(":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)
		}
	}
	return nil
}

func (r *ApexBundleTypeInfo) 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.(Path)
	}

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

	return err
}

var ApexBundleTypeInfoGobRegId int16

func (r ApexBundleTypeInfo) GetTypeId() int16 {
	return ApexBundleTypeInfoGobRegId
}

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

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

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

	if r.LibraryNameToDexJarPathOnHost == nil {
		if err = gobtools.EncodeInt(buf, -1); err != nil {
			return err
		}
	} else {
		if err = gobtools.EncodeInt(buf, len(r.LibraryNameToDexJarPathOnHost)); err != nil {
			return err
		}
		for val1, val2 := range r.LibraryNameToDexJarPathOnHost {
			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 ApexExportsInfo) CustomHash(hasher *proptools.Hasher) error {
	hasher.WriteString(":android.ApexExportsInfo")
	hasher.WriteInt(3)
	hasher.WriteString(":.string")
	hasher.WriteString(r.ApexName)
	hasher.WriteString(":android.Path")
	val1 := r.ProfilePathOnHost == nil
	if val1 {
		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 {
				val2 := r.ProfilePathOnHost == nil
				if val2 {
					hasher.WriteByte(0)
				} else {
					val3 := func(hasher *proptools.Hasher) error {
						return r.ProfilePathOnHost.(proptools.CustomHash).CustomHash(hasher)
					}
					if err := proptools.HashReference(hasher, uintptr(v.Pointer()), val3); err != nil {
						return err
					}
				}
			}
		} else {
			r.ProfilePathOnHost.(proptools.CustomHash).CustomHash(hasher)
		}
	}
	hasher.WriteString(":.map[string]Path")
	hasher.WriteInt(len(r.LibraryNameToDexJarPathOnHost))
	val4 := make([]string, 0, len(r.LibraryNameToDexJarPathOnHost))
	for val6 := range r.LibraryNameToDexJarPathOnHost {
		val4 = append(val4, val6)
	}
	proptools.SortOrdered(val4)
	for _, val5 := range val4 {
		hasher.WriteString(":.string")
		hasher.WriteString(val5)
		hasher.WriteString(":android.Path")
		val7 := r.LibraryNameToDexJarPathOnHost[val5] == nil
		if val7 {
			hasher.WriteByte(0)
		} else {
			if v := reflect.ValueOf(r.LibraryNameToDexJarPathOnHost[val5]); v.Kind() == reflect.Ptr {
				if v.IsNil() {
					panic(fmt.Errorf("nil pointer is not supported in interface"))
				} else {
					val8 := r.LibraryNameToDexJarPathOnHost[val5] == nil
					if val8 {
						hasher.WriteByte(0)
					} else {
						val9 := func(hasher *proptools.Hasher) error {
							return r.LibraryNameToDexJarPathOnHost[val5].(proptools.CustomHash).CustomHash(hasher)
						}
						if err := proptools.HashReference(hasher, uintptr(v.Pointer()), val9); err != nil {
							return err
						}
					}
				}
			} else {
				r.LibraryNameToDexJarPathOnHost[val5].(proptools.CustomHash).CustomHash(hasher)
			}
		}
	}
	return nil
}

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

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

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

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

	return err
}

var ApexExportsInfoGobRegId int16

func (r ApexExportsInfo) GetTypeId() int16 {
	return ApexExportsInfoGobRegId
}

func (r PrebuiltJsonInfo) 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.EncodeBool(buf, r.Is_prebuilt); err != nil {
		return err
	}

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

func (r PrebuiltJsonInfo) CustomHash(hasher *proptools.Hasher) error {
	hasher.WriteString(":android.PrebuiltJsonInfo")
	hasher.WriteInt(3)
	hasher.WriteString(":.string")
	hasher.WriteString(r.Name)
	hasher.WriteString(":.bool")
	if r.Is_prebuilt {
		hasher.WriteByte(1)
	} else {
		hasher.WriteByte(0)
	}
	hasher.WriteString(":.string")
	hasher.WriteString(r.Prebuilt_info_file_path)
	return nil
}

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

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

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

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

	return err
}

var PrebuiltJsonInfoGobRegId int16

func (r PrebuiltJsonInfo) GetTypeId() int16 {
	return PrebuiltJsonInfoGobRegId
}

// end of apex.go

// begin of apex_contributions.go
func init() {
	apexContributionsInfoGobRegId = gobtools.RegisterType(func() gobtools.CustomDec { return new(apexContributionsInfo) })
	PrebuiltSelectionInfoMapGobRegId = gobtools.RegisterType(func() gobtools.CustomDec { return new(PrebuiltSelectionInfoMap) })
	PrebuiltSelectionInfoGobRegId = gobtools.RegisterType(func() gobtools.CustomDec { return new(PrebuiltSelectionInfo) })
}

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

	if err = gobtools.EncodeString(buf, r.Name); 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 val1 := 0; val1 < len(r.Contents); val1++ {
			if err = gobtools.EncodeString(buf, r.Contents[val1]); err != nil {
				return err
			}
		}
	}

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

func (r apexContributionsInfo) CustomHash(hasher *proptools.Hasher) error {
	hasher.WriteString(":android.apexContributionsInfo")
	hasher.WriteInt(3)
	hasher.WriteString(":.string")
	hasher.WriteString(r.Name)
	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.WriteString(r.ApiDomain)
	return nil
}

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

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

	return err
}

var apexContributionsInfoGobRegId int16

func (r apexContributionsInfo) GetTypeId() int16 {
	return apexContributionsInfoGobRegId
}

func (r PrebuiltSelectionInfoMap) 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 = val2.Encode(ctx, buf); err != nil {
				return err
			}
		}
	}
	return err
}

func (r PrebuiltSelectionInfoMap) CustomHash(hasher *proptools.Hasher) error {
	hasher.WriteString(":.map[string]PrebuiltSelectionInfo")
	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)
		if err := r[val2].CustomHash(hasher); err != nil {
			return err
		}
	}
	return nil
}

func (r *PrebuiltSelectionInfoMap) 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]PrebuiltSelectionInfo, val1)
		for val2 := 0; val2 < int(val1); val2++ {
			var val3 string
			var val4 PrebuiltSelectionInfo
			err = gobtools.DecodeString(buf, &val3)
			if err != nil {
				return err
			}
			if err = val4.Decode(ctx, buf); err != nil {
				return err
			}
			(*r)[val3] = val4
		}
	}

	return err
}

var PrebuiltSelectionInfoMapGobRegId int16

func (r PrebuiltSelectionInfoMap) GetTypeId() int16 {
	return PrebuiltSelectionInfoMapGobRegId
}

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

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

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

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

func (r PrebuiltSelectionInfo) CustomHash(hasher *proptools.Hasher) error {
	hasher.WriteString(":android.PrebuiltSelectionInfo")
	hasher.WriteInt(3)
	hasher.WriteString(":.string")
	hasher.WriteString(r.selectedModuleName)
	hasher.WriteString(":.string")
	hasher.WriteString(r.metadataModuleName)
	hasher.WriteString(":.string")
	hasher.WriteString(r.apiDomain)
	return nil
}

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

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

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

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

	return err
}

var PrebuiltSelectionInfoGobRegId int16

func (r PrebuiltSelectionInfo) GetTypeId() int16 {
	return PrebuiltSelectionInfoGobRegId
}

// end of apex_contributions.go

// begin of api_levels.go
func init() {
	ApiLevelGobRegId = gobtools.RegisterType(func() gobtools.CustomDec { return new(ApiLevel) })
}

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

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

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

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

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

func (r ApiLevel) CustomHash(hasher *proptools.Hasher) error {
	hasher.WriteString(":android.ApiLevel")
	hasher.WriteInt(4)
	hasher.WriteString(":.string")
	hasher.WriteString(r.value)
	hasher.WriteString(":.int")
	hasher.WriteUint64(uint64(r.major))
	hasher.WriteString(":.int")
	hasher.WriteUint64(uint64(r.minor))
	hasher.WriteString(":.bool")
	if r.isPreview {
		hasher.WriteByte(1)
	} else {
		hasher.WriteByte(0)
	}
	return nil
}

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

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

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

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

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

	return err
}

var ApiLevelGobRegId int16

func (r ApiLevel) GetTypeId() int16 {
	return ApiLevelGobRegId
}

// end of api_levels.go

// begin of arch.go
func init() {
	ArchGobRegId = gobtools.RegisterType(func() gobtools.CustomDec { return new(Arch) })
	ArchTypeGobRegId = gobtools.RegisterType(func() gobtools.CustomDec { return new(ArchType) })
	OsTypeGobRegId = gobtools.RegisterType(func() gobtools.CustomDec { return new(OsType) })
	TargetGobRegId = gobtools.RegisterType(func() gobtools.CustomDec { return new(Target) })
	allOsInfoGobRegId = gobtools.RegisterType(func() gobtools.CustomDec { return new(allOsInfo) })
	allArchInfoGobRegId = gobtools.RegisterType(func() gobtools.CustomDec { return new(allArchInfo) })
}

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

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

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

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

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

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

func (r Arch) CustomHash(hasher *proptools.Hasher) error {
	hasher.WriteString(":android.Arch")
	hasher.WriteInt(5)
	if err := r.ArchType.CustomHash(hasher); err != nil {
		return err
	}
	hasher.WriteString(":.string")
	hasher.WriteString(r.ArchVariant)
	hasher.WriteString(":.string")
	hasher.WriteString(r.CpuVariant)
	hasher.WriteString(":.[]string")
	hasher.WriteInt(len(r.Abi))
	for val1 := 0; val1 < len(r.Abi); val1++ {
		hasher.WriteString(":.string")
		hasher.WriteString(r.Abi[val1])
	}
	hasher.WriteString(":.[]string")
	hasher.WriteInt(len(r.ArchFeatures))
	for val2 := 0; val2 < len(r.ArchFeatures); val2++ {
		hasher.WriteString(":.string")
		hasher.WriteString(r.ArchFeatures[val2])
	}
	return nil
}

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

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

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

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

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

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

	return err
}

var ArchGobRegId int16

func (r Arch) GetTypeId() int16 {
	return ArchGobRegId
}

func (r ArchType) 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.EncodeString(buf, r.Field); err != nil {
		return err
	}

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

func (r ArchType) CustomHash(hasher *proptools.Hasher) error {
	hasher.WriteString(":android.ArchType")
	hasher.WriteInt(3)
	hasher.WriteString(":.string")
	hasher.WriteString(r.Name)
	hasher.WriteString(":.string")
	hasher.WriteString(r.Field)
	hasher.WriteString(":.string")
	hasher.WriteString(r.Multilib)
	return nil
}

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

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

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

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

	return err
}

var ArchTypeGobRegId int16

func (r ArchType) GetTypeId() int16 {
	return ArchTypeGobRegId
}

func (r OsType) 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.EncodeString(buf, r.Field); err != nil {
		return err
	}

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

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

func (r OsType) CustomHash(hasher *proptools.Hasher) error {
	hasher.WriteString(":android.OsType")
	hasher.WriteInt(4)
	hasher.WriteString(":.string")
	hasher.WriteString(r.Name)
	hasher.WriteString(":.string")
	hasher.WriteString(r.Field)
	hasher.WriteString(":android.OsClass")
	hasher.WriteString(":.int")
	hasher.WriteUint64(uint64(int(r.Class)))
	hasher.WriteString(":.bool")
	if r.DefaultDisabled {
		hasher.WriteByte(1)
	} else {
		hasher.WriteByte(0)
	}
	return nil
}

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

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

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

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

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

	return err
}

var OsTypeGobRegId int16

func (r OsType) GetTypeId() int16 {
	return OsTypeGobRegId
}

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

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

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

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

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

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

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

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

func (r Target) CustomHash(hasher *proptools.Hasher) error {
	hasher.WriteString(":android.Target")
	hasher.WriteInt(7)
	if err := r.Os.CustomHash(hasher); err != nil {
		return err
	}
	if err := r.Arch.CustomHash(hasher); err != nil {
		return err
	}
	hasher.WriteString(":android.NativeBridgeSupport")
	hasher.WriteString(":.bool")
	if bool(r.NativeBridge) {
		hasher.WriteByte(1)
	} else {
		hasher.WriteByte(0)
	}
	hasher.WriteString(":.string")
	hasher.WriteString(r.NativeBridgeHostArchName)
	hasher.WriteString(":.string")
	hasher.WriteString(r.NativeBridgeRelativePath)
	hasher.WriteString(":.bool")
	if r.LFI {
		hasher.WriteByte(1)
	} else {
		hasher.WriteByte(0)
	}
	hasher.WriteString(":.bool")
	if r.HostCross {
		hasher.WriteByte(1)
	} else {
		hasher.WriteByte(0)
	}
	return nil
}

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

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

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

	var val4 bool
	err = gobtools.DecodeBool(buf, &val4)
	if err != nil {
		return err
	}
	r.NativeBridge = NativeBridgeSupport(val4)

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

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

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

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

	return err
}

var TargetGobRegId int16

func (r Target) GetTypeId() int16 {
	return TargetGobRegId
}

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

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

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

func (r allOsInfo) CustomHash(hasher *proptools.Hasher) error {
	hasher.WriteString(":android.allOsInfo")
	hasher.WriteInt(2)
	hasher.WriteString(":.map[string]OsType")
	hasher.WriteInt(len(r.Os))
	val1 := make([]string, 0, len(r.Os))
	for val3 := range r.Os {
		val1 = append(val1, val3)
	}
	proptools.SortOrdered(val1)
	for _, val2 := range val1 {
		hasher.WriteString(":.string")
		hasher.WriteString(val2)
		if err := r.Os[val2].CustomHash(hasher); err != nil {
			return err
		}
	}
	hasher.WriteString(":.[]string")
	hasher.WriteInt(len(r.Variations))
	for val4 := 0; val4 < len(r.Variations); val4++ {
		hasher.WriteString(":.string")
		hasher.WriteString(r.Variations[val4])
	}
	return nil
}

func (r *allOsInfo) 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.Os = make(map[string]OsType, val1)
		for val2 := 0; val2 < int(val1); val2++ {
			var val3 string
			var val4 OsType
			err = gobtools.DecodeString(buf, &val3)
			if err != nil {
				return err
			}
			if err = val4.Decode(ctx, buf); err != nil {
				return err
			}
			r.Os[val3] = val4
		}
	}

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

	return err
}

var allOsInfoGobRegId int16

func (r allOsInfo) GetTypeId() int16 {
	return allOsInfoGobRegId
}

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

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

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

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

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

func (r allArchInfo) CustomHash(hasher *proptools.Hasher) error {
	hasher.WriteString(":android.allArchInfo")
	hasher.WriteInt(4)
	hasher.WriteString(":.map[string]Target")
	hasher.WriteInt(len(r.Targets))
	val1 := make([]string, 0, len(r.Targets))
	for val3 := range r.Targets {
		val1 = append(val1, val3)
	}
	proptools.SortOrdered(val1)
	for _, val2 := range val1 {
		hasher.WriteString(":.string")
		hasher.WriteString(val2)
		if err := r.Targets[val2].CustomHash(hasher); err != nil {
			return err
		}
	}
	hasher.WriteString(":.[]Target")
	hasher.WriteInt(len(r.MultiTargets))
	for val4 := 0; val4 < len(r.MultiTargets); val4++ {
		if err := r.MultiTargets[val4].CustomHash(hasher); err != nil {
			return err
		}
	}
	hasher.WriteString(":.string")
	hasher.WriteString(r.Primary)
	hasher.WriteString(":.string")
	hasher.WriteString(r.Multilib)
	return nil
}

func (r *allArchInfo) 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.Targets = make(map[string]Target, val1)
		for val2 := 0; val2 < int(val1); val2++ {
			var val3 string
			var val4 Target
			err = gobtools.DecodeString(buf, &val3)
			if err != nil {
				return err
			}
			if err = val4.Decode(ctx, buf); err != nil {
				return err
			}
			r.Targets[val3] = val4
		}
	}

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

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

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

	return err
}

var allArchInfoGobRegId int16

func (r allArchInfo) GetTypeId() int16 {
	return allArchInfoGobRegId
}

// end of arch.go

// begin of compliance_metadata.go
func init() {
	ComplianceMetadataInfoGobRegId = gobtools.RegisterType(func() gobtools.CustomDec { return new(ComplianceMetadataInfo) })
}

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

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

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

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

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

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

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

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

func (r ComplianceMetadataInfo) CustomHash(hasher *proptools.Hasher) error {
	hasher.WriteString(":android.ComplianceMetadataInfo")
	hasher.WriteInt(7)
	hasher.WriteString(":.map[string]string")
	hasher.WriteInt(len(r.properties))
	val1 := make([]string, 0, len(r.properties))
	for val3 := range r.properties {
		val1 = append(val1, val3)
	}
	proptools.SortOrdered(val1)
	for _, val2 := range val1 {
		hasher.WriteString(":.string")
		hasher.WriteString(val2)
		hasher.WriteString(":.string")
		hasher.WriteString(r.properties[val2])
	}
	hasher.WriteString(":.[]string")
	hasher.WriteInt(len(r.filesContained))
	for val4 := 0; val4 < len(r.filesContained); val4++ {
		hasher.WriteString(":.string")
		hasher.WriteString(r.filesContained[val4])
	}
	hasher.WriteString(":.[]string")
	hasher.WriteInt(len(r.buildOutputPathsOfFilesContained))
	for val5 := 0; val5 < len(r.buildOutputPathsOfFilesContained); val5++ {
		hasher.WriteString(":.string")
		hasher.WriteString(r.buildOutputPathsOfFilesContained[val5])
	}
	hasher.WriteString(":.[]string")
	hasher.WriteInt(len(r.prebuiltFilesCopied))
	for val6 := 0; val6 < len(r.prebuiltFilesCopied); val6++ {
		hasher.WriteString(":.string")
		hasher.WriteString(r.prebuiltFilesCopied[val6])
	}
	hasher.WriteString(":.[]string")
	hasher.WriteInt(len(r.platformGeneratedFiles))
	for val7 := 0; val7 < len(r.platformGeneratedFiles); val7++ {
		hasher.WriteString(":.string")
		hasher.WriteString(r.platformGeneratedFiles[val7])
	}
	hasher.WriteString(":.[]string")
	hasher.WriteInt(len(r.productCopyFiles))
	for val8 := 0; val8 < len(r.productCopyFiles); val8++ {
		hasher.WriteString(":.string")
		hasher.WriteString(r.productCopyFiles[val8])
	}
	hasher.WriteString(":.[]string")
	hasher.WriteInt(len(r.kernelModuleCopyFiles))
	for val9 := 0; val9 < len(r.kernelModuleCopyFiles); val9++ {
		hasher.WriteString(":.string")
		hasher.WriteString(r.kernelModuleCopyFiles[val9])
	}
	return nil
}

func (r *ComplianceMetadataInfo) 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.properties = 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.properties[val3] = val4
		}
	}

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

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

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

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

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

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

	return err
}

var ComplianceMetadataInfoGobRegId int16

func (r ComplianceMetadataInfo) GetTypeId() int16 {
	return ComplianceMetadataInfoGobRegId
}

// end of compliance_metadata.go

// begin of configured_jars.go
func init() {
	ConfiguredJarListGobRegId = gobtools.RegisterType(func() gobtools.CustomDec { return new(ConfiguredJarList) })
}

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

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

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

func (r ConfiguredJarList) CustomHash(hasher *proptools.Hasher) error {
	hasher.WriteString(":android.ConfiguredJarList")
	hasher.WriteInt(2)
	hasher.WriteString(":.[]string")
	hasher.WriteInt(len(r.apexes))
	for val1 := 0; val1 < len(r.apexes); val1++ {
		hasher.WriteString(":.string")
		hasher.WriteString(r.apexes[val1])
	}
	hasher.WriteString(":.[]string")
	hasher.WriteInt(len(r.jars))
	for val2 := 0; val2 < len(r.jars); val2++ {
		hasher.WriteString(":.string")
		hasher.WriteString(r.jars[val2])
	}
	return nil
}

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

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

	return err
}

var ConfiguredJarListGobRegId int16

func (r ConfiguredJarList) GetTypeId() int16 {
	return ConfiguredJarListGobRegId
}

// end of configured_jars.go

// begin of container.go
func init() {
	unstableInfoGobRegId = gobtools.RegisterType(func() gobtools.CustomDec { return new(unstableInfo) })
	restrictionGobRegId = gobtools.RegisterType(func() gobtools.CustomDec { return new(restriction) })
	containerGobRegId = gobtools.RegisterType(func() gobtools.CustomDec { return new(container) })
	ContainersInfoGobRegId = gobtools.RegisterType(func() gobtools.CustomDec { return new(ContainersInfo) })
}

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

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

func (r unstableInfo) CustomHash(hasher *proptools.Hasher) error {
	hasher.WriteString(":android.unstableInfo")
	hasher.WriteInt(1)
	hasher.WriteString(":.bool")
	if r.ContainsPlatformPrivateApis {
		hasher.WriteByte(1)
	} else {
		hasher.WriteByte(0)
	}
	return nil
}

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

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

	return err
}

var unstableInfoGobRegId int16

func (r unstableInfo) GetTypeId() int16 {
	return unstableInfoGobRegId
}

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

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

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

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

func (r restriction) CustomHash(hasher *proptools.Hasher) error {
	hasher.WriteString(":android.restriction")
	hasher.WriteInt(3)
	hasher.WriteString(":.*container")
	val1 := r.dependency == nil
	if val1 {
		hasher.WriteByte(0)
	} else {
		val2 := func(hasher *proptools.Hasher) error {
			if err := (*r.dependency).CustomHash(hasher); err != nil {
				return err
			}
			return nil
		}
		if err := proptools.HashReference(hasher, uintptr(unsafe.Pointer(r.dependency)), val2); err != nil {
			return err
		}
	}
	hasher.WriteString(":.string")
	hasher.WriteString(r.errorMessage)
	hasher.WriteString(":.[]exceptionHandleFuncLabel")
	hasher.WriteInt(len(r.allowedExceptions))
	for val3 := 0; val3 < len(r.allowedExceptions); val3++ {
		hasher.WriteString(":android.exceptionHandleFuncLabel")
		hasher.WriteString(":.int")
		hasher.WriteUint64(uint64(int(r.allowedExceptions[val3])))
	}
	return nil
}

func (r *restriction) 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 container
		if err = val1.Decode(ctx, buf); err != nil {
			return err
		}
		r.dependency = &val1
	}

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

	var val6 int
	err = gobtools.DecodeInt(buf, &val6)
	if err != nil {
		return err
	}
	if val6 != -1 {
		r.allowedExceptions = make([]exceptionHandleFuncLabel, val6)
		for val7 := 0; val7 < int(val6); val7++ {
			var val9 int
			err = gobtools.DecodeInt(buf, &val9)
			if err != nil {
				return err
			}
			r.allowedExceptions[val7] = exceptionHandleFuncLabel(val9)
		}
	}

	return err
}

var restrictionGobRegId int16

func (r restriction) GetTypeId() int16 {
	return restrictionGobRegId
}

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

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

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

func (r container) CustomHash(hasher *proptools.Hasher) error {
	hasher.WriteString(":android.container")
	hasher.WriteInt(2)
	hasher.WriteString(":.string")
	hasher.WriteString(r.name)
	hasher.WriteString(":.[]restriction")
	hasher.WriteInt(len(r.restricted))
	for val1 := 0; val1 < len(r.restricted); val1++ {
		if err := r.restricted[val1].CustomHash(hasher); err != nil {
			return err
		}
	}
	return nil
}

func (r *container) 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
	}
	if val3 != -1 {
		r.restricted = make([]restriction, val3)
		for val4 := 0; val4 < int(val3); val4++ {
			if err = r.restricted[val4].Decode(ctx, buf); err != nil {
				return err
			}
		}
	}

	return err
}

var containerGobRegId int16

func (r container) GetTypeId() int16 {
	return containerGobRegId
}

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

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

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

func (r ContainersInfo) CustomHash(hasher *proptools.Hasher) error {
	hasher.WriteString(":android.ContainersInfo")
	hasher.WriteInt(2)
	hasher.WriteString(":.[]*container")
	hasher.WriteInt(len(r.belongingContainers))
	for val1 := 0; val1 < len(r.belongingContainers); val1++ {
		hasher.WriteString(":.*container")
		val2 := r.belongingContainers[val1] == nil
		if val2 {
			hasher.WriteByte(0)
		} else {
			val3 := func(hasher *proptools.Hasher) error {
				if err := (*r.belongingContainers[val1]).CustomHash(hasher); err != nil {
					return err
				}
				return nil
			}
			if err := proptools.HashReference(hasher, uintptr(unsafe.Pointer(r.belongingContainers[val1])), val3); err != nil {
				return err
			}
		}
	}
	hasher.WriteString(":.[]ApexInfo")
	hasher.WriteInt(len(r.belongingApexes))
	for val4 := 0; val4 < len(r.belongingApexes); val4++ {
		if err := r.belongingApexes[val4].CustomHash(hasher); err != nil {
			return err
		}
	}
	return nil
}

func (r *ContainersInfo) 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.belongingContainers = make([]*container, val2)
		for val3 := 0; val3 < int(val2); val3++ {
			var val5 bool
			if err = gobtools.DecodeBool(buf, &val5); err != nil {
				return err
			}
			if !val5 {
				var val4 container
				if err = val4.Decode(ctx, buf); err != nil {
					return err
				}
				r.belongingContainers[val3] = &val4
			}
		}
	}

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

	return err
}

var ContainersInfoGobRegId int16

func (r ContainersInfo) GetTypeId() int16 {
	return ContainersInfoGobRegId
}

// end of container.go

// begin of deapexer.go
func init() {
	RequiredFilesFromPrebuiltApexInfoGobRegId = gobtools.RegisterType(func() gobtools.CustomDec { return new(RequiredFilesFromPrebuiltApexInfo) })
}

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

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

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

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

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

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

	return err
}

var RequiredFilesFromPrebuiltApexInfoGobRegId int16

func (r RequiredFilesFromPrebuiltApexInfo) GetTypeId() int16 {
	return RequiredFilesFromPrebuiltApexInfoGobRegId
}

// end of deapexer.go

// begin of dirgroup.go
func init() {
	DirInfoGobRegId = gobtools.RegisterType(func() gobtools.CustomDec { return new(DirInfo) })
}

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

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

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

func (r *DirInfo) 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.Dirs = make([]DirectoryPath, val3)
		for val4 := 0; val4 < int(val3); val4++ {
			if val6, err := gobtools.DecodeInterface(ctx, buf); err != nil {
				return err
			} else if val6 == nil {
				r.Dirs[val4] = nil
			} else {
				r.Dirs[val4] = val6.(DirectoryPath)
			}
		}
	}

	return err
}

var DirInfoGobRegId int16

func (r DirInfo) GetTypeId() int16 {
	return DirInfoGobRegId
}

// end of dirgroup.go

// begin of dist.go
func init() {
	distCopyGobRegId = gobtools.RegisterType(func() gobtools.CustomDec { return new(distCopy) })
}

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

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

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

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

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

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

	return err
}

var distCopyGobRegId int16

func (r distCopy) GetTypeId() int16 {
	return distCopyGobRegId
}

// end of dist.go

// begin of gen_notice.go
func init() {
	GenNoticeInfoGobRegId = gobtools.RegisterType(func() gobtools.CustomDec { return new(GenNoticeInfo) })
}

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

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

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

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

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

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

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

func (r GenNoticeInfo) CustomHash(hasher *proptools.Hasher) error {
	hasher.WriteString(":android.GenNoticeInfo")
	hasher.WriteInt(6)
	hasher.WriteString(":.[]string")
	hasher.WriteInt(len(r.For))
	for val1 := 0; val1 < len(r.For); val1++ {
		hasher.WriteString(":.string")
		hasher.WriteString(r.For[val1])
	}
	hasher.WriteString(":.*string")
	val2 := r.ArtifactName == nil
	if val2 {
		hasher.WriteByte(0)
	} else {
		val3 := func(hasher *proptools.Hasher) error {
			hasher.WriteString(":.string")
			hasher.WriteString((*r.ArtifactName))
			return nil
		}
		if err := proptools.HashReference(hasher, uintptr(unsafe.Pointer(r.ArtifactName)), val3); err != nil {
			return err
		}
	}
	hasher.WriteString(":.bool")
	if r.Html {
		hasher.WriteByte(1)
	} else {
		hasher.WriteByte(0)
	}
	hasher.WriteString(":.bool")
	if r.Xml {
		hasher.WriteByte(1)
	} else {
		hasher.WriteByte(0)
	}
	if err := r.Output.CustomHash(hasher); err != nil {
		return err
	}
	hasher.WriteString(":.[]string")
	hasher.WriteInt(len(r.Missing))
	for val4 := 0; val4 < len(r.Missing); val4++ {
		hasher.WriteString(":.string")
		hasher.WriteString(r.Missing[val4])
	}
	return nil
}

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

	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.ArtifactName = &val5
	}

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

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

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

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

	return err
}

var GenNoticeInfoGobRegId int16

func (r GenNoticeInfo) GetTypeId() int16 {
	return GenNoticeInfoGobRegId
}

// end of gen_notice.go

// begin of license.go
func init() {
	LicenseInfoGobRegId = gobtools.RegisterType(func() gobtools.CustomDec { return new(LicenseInfo) })
}

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

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

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

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

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

func (r LicenseInfo) CustomHash(hasher *proptools.Hasher) error {
	hasher.WriteString(":android.LicenseInfo")
	hasher.WriteInt(4)
	hasher.WriteString(":.*string")
	val1 := r.PackageName == nil
	if val1 {
		hasher.WriteByte(0)
	} else {
		val2 := func(hasher *proptools.Hasher) error {
			hasher.WriteString(":.string")
			hasher.WriteString((*r.PackageName))
			return nil
		}
		if err := proptools.HashReference(hasher, uintptr(unsafe.Pointer(r.PackageName)), val2); err != nil {
			return err
		}
	}
	hasher.WriteString(":android.NamedPaths")
	hasher.WriteString(":.[]NamedPath")
	hasher.WriteInt(len(r.EffectiveLicenseText))
	for val3 := 0; val3 < len(r.EffectiveLicenseText); val3++ {
		if err := r.EffectiveLicenseText[val3].CustomHash(hasher); err != nil {
			return err
		}
	}
	hasher.WriteString(":.[]string")
	hasher.WriteInt(len(r.EffectiveLicenseKinds))
	for val4 := 0; val4 < len(r.EffectiveLicenseKinds); val4++ {
		hasher.WriteString(":.string")
		hasher.WriteString(r.EffectiveLicenseKinds[val4])
	}
	hasher.WriteString(":.[]string")
	hasher.WriteInt(len(r.EffectiveLicenseConditions))
	for val5 := 0; val5 < len(r.EffectiveLicenseConditions); val5++ {
		hasher.WriteString(":.string")
		hasher.WriteString(r.EffectiveLicenseConditions[val5])
	}
	return nil
}

func (r *LicenseInfo) 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.PackageName = &val1
	}

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

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

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

	return err
}

var LicenseInfoGobRegId int16

func (r LicenseInfo) GetTypeId() int16 {
	return LicenseInfoGobRegId
}

// end of license.go

// begin of license_kind.go
func init() {
	LicenseKindInfoGobRegId = gobtools.RegisterType(func() gobtools.CustomDec { return new(LicenseKindInfo) })
}

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

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

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

func (r LicenseKindInfo) CustomHash(hasher *proptools.Hasher) error {
	hasher.WriteString(":android.LicenseKindInfo")
	hasher.WriteInt(2)
	hasher.WriteString(":.[]string")
	hasher.WriteInt(len(r.Conditions))
	for val1 := 0; val1 < len(r.Conditions); val1++ {
		hasher.WriteString(":.string")
		hasher.WriteString(r.Conditions[val1])
	}
	hasher.WriteString(":.string")
	hasher.WriteString(r.Url)
	return nil
}

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

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

	return err
}

var LicenseKindInfoGobRegId int16

func (r LicenseKindInfo) GetTypeId() int16 {
	return LicenseKindInfoGobRegId
}

// end of license_kind.go

// begin of license_metadata.go
func init() {
	LicenseMetadataInfoGobRegId = gobtools.RegisterType(func() gobtools.CustomDec { return new(LicenseMetadataInfo) })
}

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

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

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

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

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

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

	return err
}

var LicenseMetadataInfoGobRegId int16

func (r LicenseMetadataInfo) GetTypeId() int16 {
	return LicenseMetadataInfoGobRegId
}

// end of license_metadata.go

// begin of license_sdk_member.go
func init() {
	licenseSdkMemberTypeGobRegId = gobtools.RegisterType(func() gobtools.CustomDec { return new(licenseSdkMemberType) })
}

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

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

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

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

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

	return err
}

var licenseSdkMemberTypeGobRegId int16

func (r licenseSdkMemberType) GetTypeId() int16 {
	return licenseSdkMemberTypeGobRegId
}

// end of license_sdk_member.go

// begin of licenses.go
func init() {
	applicableLicensesPropertyGobRegId = gobtools.RegisterType(func() gobtools.CustomDec { return new(applicableLicensesProperty) })
	LicensesInfoGobRegId = gobtools.RegisterType(func() gobtools.CustomDec { return new(LicensesInfo) })
}

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

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

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

func (r applicableLicensesProperty) CustomHash(hasher *proptools.Hasher) error {
	hasher.WriteString(":android.applicableLicensesProperty")
	hasher.WriteInt(2)
	hasher.WriteString(":.string")
	hasher.WriteString(r.name)
	hasher.WriteString(":.*[]string")
	val1 := r.licensesProperty == nil
	if val1 {
		hasher.WriteByte(0)
	} else {
		val3 := func(hasher *proptools.Hasher) error {
			hasher.WriteString(":.[]string")
			hasher.WriteInt(len((*r.licensesProperty)))
			for val2 := 0; val2 < len((*r.licensesProperty)); val2++ {
				hasher.WriteString(":.string")
				hasher.WriteString((*r.licensesProperty)[val2])
			}
			return nil
		}
		if err := proptools.HashReference(hasher, uintptr(unsafe.Pointer(r.licensesProperty)), val3); err != nil {
			return err
		}
	}
	return nil
}

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

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

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

	return err
}

var applicableLicensesPropertyGobRegId int16

func (r applicableLicensesProperty) GetTypeId() int16 {
	return applicableLicensesPropertyGobRegId
}

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

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

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

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

	return err
}

var LicensesInfoGobRegId int16

func (r LicensesInfo) GetTypeId() int16 {
	return LicensesInfoGobRegId
}

// end of licenses.go

// begin of logtags.go
func init() {
	LogtagsInfoGobRegId = gobtools.RegisterType(func() gobtools.CustomDec { return new(LogtagsInfo) })
}

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

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

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

func (r *LogtagsInfo) 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.Logtags = make([]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.Logtags[val4] = nil
			} else {
				r.Logtags[val4] = val6.(Path)
			}
		}
	}

	return err
}

var LogtagsInfoGobRegId int16

func (r LogtagsInfo) GetTypeId() int16 {
	return LogtagsInfoGobRegId
}

// end of logtags.go

// begin of makevars.go
func init() {
	ModuleMakeVarsInfoGobRegId = gobtools.RegisterType(func() gobtools.CustomDec { return new(ModuleMakeVarsInfo) })
	ModuleMakeVarsValueGobRegId = gobtools.RegisterType(func() gobtools.CustomDec { return new(ModuleMakeVarsValue) })
	distGobRegId = gobtools.RegisterType(func() gobtools.CustomDec { return new(dist) })
}

func (r ModuleMakeVarsInfo) 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 ModuleMakeVarsInfo) CustomHash(hasher *proptools.Hasher) error {
	hasher.WriteString(":.[]ModuleMakeVarsValue")
	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 *ModuleMakeVarsInfo) 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([]ModuleMakeVarsValue, val2)
		for val3 := 0; val3 < int(val2); val3++ {
			if err = (*r)[val3].Decode(ctx, buf); err != nil {
				return err
			}
		}
	}

	return err
}

var ModuleMakeVarsInfoGobRegId int16

func (r ModuleMakeVarsInfo) GetTypeId() int16 {
	return ModuleMakeVarsInfoGobRegId
}

func (r ModuleMakeVarsValue) 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.EncodeString(buf, r.Value); err != nil {
		return err
	}
	return err
}

func (r ModuleMakeVarsValue) CustomHash(hasher *proptools.Hasher) error {
	hasher.WriteString(":android.ModuleMakeVarsValue")
	hasher.WriteInt(2)
	hasher.WriteString(":.string")
	hasher.WriteString(r.Name)
	hasher.WriteString(":.string")
	hasher.WriteString(r.Value)
	return nil
}

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

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

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

	return err
}

var ModuleMakeVarsValueGobRegId int16

func (r ModuleMakeVarsValue) GetTypeId() int16 {
	return ModuleMakeVarsValueGobRegId
}

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

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

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

func (r dist) CustomHash(hasher *proptools.Hasher) error {
	hasher.WriteString(":android.dist")
	hasher.WriteInt(2)
	hasher.WriteString(":.[]string")
	hasher.WriteInt(len(r.goals))
	for val1 := 0; val1 < len(r.goals); val1++ {
		hasher.WriteString(":.string")
		hasher.WriteString(r.goals[val1])
	}
	hasher.WriteString(":android.distCopies")
	hasher.WriteString(":.[]distCopy")
	hasher.WriteInt(len(r.paths))
	for val2 := 0; val2 < len(r.paths); val2++ {
		if err := r.paths[val2].CustomHash(hasher); err != nil {
			return err
		}
	}
	return nil
}

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

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

	return err
}

var distGobRegId int16

func (r dist) GetTypeId() int16 {
	return distGobRegId
}

// end of makevars.go

// begin of module.go
func init() {
	DistGobRegId = gobtools.RegisterType(func() gobtools.CustomDec { return new(Dist) })
	NamedPathGobRegId = gobtools.RegisterType(func() gobtools.CustomDec { return new(NamedPath) })
	NamedPathsGobRegId = gobtools.RegisterType(func() gobtools.CustomDec { return new(NamedPaths) })
	InstallFilesInfoGobRegId = gobtools.RegisterType(func() gobtools.CustomDec { return new(InstallFilesInfo) })
	SourceFilesInfoGobRegId = gobtools.RegisterType(func() gobtools.CustomDec { return new(SourceFilesInfo) })
	ModuleBuildTargetsInfoGobRegId = gobtools.RegisterType(func() gobtools.CustomDec { return new(ModuleBuildTargetsInfo) })
	JarJarRenameGobRegId = gobtools.RegisterType(func() gobtools.CustomDec { return new(JarJarRename) })
	BaseJarJarProviderDataGobRegId = gobtools.RegisterType(func() gobtools.CustomDec { return new(BaseJarJarProviderData) })
	CommonModuleInfoGobRegId = gobtools.RegisterType(func() gobtools.CustomDec { return new(CommonModuleInfo) })
	NinjaPhoniesGlobsInfoGobRegId = gobtools.RegisterType(func() gobtools.CustomDec { return new(NinjaPhoniesGlobsInfo) })
	ApiLevelOrPlatformGobRegId = gobtools.RegisterType(func() gobtools.CustomDec { return new(ApiLevelOrPlatform) })
	HostToolInfoGobRegId = gobtools.RegisterType(func() gobtools.CustomDec { return new(HostToolInfo) })
	DistInfoGobRegId = gobtools.RegisterType(func() gobtools.CustomDec { return new(DistInfo) })
	GeneratedSourceInfoGobRegId = gobtools.RegisterType(func() gobtools.CustomDec { return new(GeneratedSourceInfo) })
	katiInstallGobRegId = gobtools.RegisterType(func() gobtools.CustomDec { return new(katiInstall) })
	extraFilesZipGobRegId = gobtools.RegisterType(func() gobtools.CustomDec { return new(extraFilesZip) })
	OutputFilesInfoGobRegId = gobtools.RegisterType(func() gobtools.CustomDec { return new(OutputFilesInfo) })
	IdeInfoGobRegId = gobtools.RegisterType(func() gobtools.CustomDec { return new(IdeInfo) })
	AconfigIdeInfoGobRegId = gobtools.RegisterType(func() gobtools.CustomDec { return new(AconfigIdeInfo) })
	ProtoIdeInfoGobRegId = gobtools.RegisterType(func() gobtools.CustomDec { return new(ProtoIdeInfo) })
	AidlIdeInfoGobRegId = gobtools.RegisterType(func() gobtools.CustomDec { return new(AidlIdeInfo) })
}

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

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

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

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

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

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

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

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

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

func (r Dist) CustomHash(hasher *proptools.Hasher) error {
	hasher.WriteString(":android.Dist")
	hasher.WriteInt(8)
	hasher.WriteString(":.[]string")
	hasher.WriteInt(len(r.Targets))
	for val1 := 0; val1 < len(r.Targets); val1++ {
		hasher.WriteString(":.string")
		hasher.WriteString(r.Targets[val1])
	}
	hasher.WriteString(":.*string")
	val2 := r.Dest == nil
	if val2 {
		hasher.WriteByte(0)
	} else {
		val3 := func(hasher *proptools.Hasher) error {
			hasher.WriteString(":.string")
			hasher.WriteString((*r.Dest))
			return nil
		}
		if err := proptools.HashReference(hasher, uintptr(unsafe.Pointer(r.Dest)), val3); err != nil {
			return err
		}
	}
	hasher.WriteString(":.*string")
	val4 := r.Dir == nil
	if val4 {
		hasher.WriteByte(0)
	} else {
		val5 := func(hasher *proptools.Hasher) error {
			hasher.WriteString(":.string")
			hasher.WriteString((*r.Dir))
			return nil
		}
		if err := proptools.HashReference(hasher, uintptr(unsafe.Pointer(r.Dir)), val5); err != nil {
			return err
		}
	}
	hasher.WriteString(":.*string")
	val6 := r.Suffix == nil
	if val6 {
		hasher.WriteByte(0)
	} else {
		val7 := func(hasher *proptools.Hasher) error {
			hasher.WriteString(":.string")
			hasher.WriteString((*r.Suffix))
			return nil
		}
		if err := proptools.HashReference(hasher, uintptr(unsafe.Pointer(r.Suffix)), val7); err != nil {
			return err
		}
	}
	hasher.WriteString(":.*bool")
	val8 := r.Append_artifact_with_product == nil
	if val8 {
		hasher.WriteByte(0)
	} else {
		val9 := func(hasher *proptools.Hasher) error {
			hasher.WriteString(":.bool")
			if *r.Append_artifact_with_product {
				hasher.WriteByte(1)
			} else {
				hasher.WriteByte(0)
			}
			return nil
		}
		if err := proptools.HashReference(hasher, uintptr(unsafe.Pointer(r.Append_artifact_with_product)), val9); err != nil {
			return err
		}
	}
	hasher.WriteString(":.*bool")
	val10 := r.Prepend_artifact_with_product == nil
	if val10 {
		hasher.WriteByte(0)
	} else {
		val11 := func(hasher *proptools.Hasher) error {
			hasher.WriteString(":.bool")
			if *r.Prepend_artifact_with_product {
				hasher.WriteByte(1)
			} else {
				hasher.WriteByte(0)
			}
			return nil
		}
		if err := proptools.HashReference(hasher, uintptr(unsafe.Pointer(r.Prepend_artifact_with_product)), val11); err != nil {
			return err
		}
	}
	hasher.WriteString(":.*string")
	val12 := r.Tag == nil
	if val12 {
		hasher.WriteByte(0)
	} else {
		val13 := func(hasher *proptools.Hasher) error {
			hasher.WriteString(":.string")
			hasher.WriteString((*r.Tag))
			return nil
		}
		if err := proptools.HashReference(hasher, uintptr(unsafe.Pointer(r.Tag)), val13); err != nil {
			return err
		}
	}
	hasher.WriteString(":.*bool")
	val14 := r.Only_on_java_coverage_builds == nil
	if val14 {
		hasher.WriteByte(0)
	} else {
		val15 := func(hasher *proptools.Hasher) error {
			hasher.WriteString(":.bool")
			if *r.Only_on_java_coverage_builds {
				hasher.WriteByte(1)
			} else {
				hasher.WriteByte(0)
			}
			return nil
		}
		if err := proptools.HashReference(hasher, uintptr(unsafe.Pointer(r.Only_on_java_coverage_builds)), val15); err != nil {
			return err
		}
	}
	return nil
}

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

	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.Dest = &val5
	}

	var val9 bool
	if err = gobtools.DecodeBool(buf, &val9); err != nil {
		return err
	}
	if !val9 {
		var val8 string
		err = gobtools.DecodeString(buf, &val8)
		if err != nil {
			return err
		}
		r.Dir = &val8
	}

	var val12 bool
	if err = gobtools.DecodeBool(buf, &val12); err != nil {
		return err
	}
	if !val12 {
		var val11 string
		err = gobtools.DecodeString(buf, &val11)
		if err != nil {
			return err
		}
		r.Suffix = &val11
	}

	var val15 bool
	if err = gobtools.DecodeBool(buf, &val15); err != nil {
		return err
	}
	if !val15 {
		var val14 bool
		err = gobtools.DecodeBool(buf, &val14)
		if err != nil {
			return err
		}
		r.Append_artifact_with_product = &val14
	}

	var val18 bool
	if err = gobtools.DecodeBool(buf, &val18); err != nil {
		return err
	}
	if !val18 {
		var val17 bool
		err = gobtools.DecodeBool(buf, &val17)
		if err != nil {
			return err
		}
		r.Prepend_artifact_with_product = &val17
	}

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

	var val24 bool
	if err = gobtools.DecodeBool(buf, &val24); err != nil {
		return err
	}
	if !val24 {
		var val23 bool
		err = gobtools.DecodeBool(buf, &val23)
		if err != nil {
			return err
		}
		r.Only_on_java_coverage_builds = &val23
	}

	return err
}

var DistGobRegId int16

func (r Dist) GetTypeId() int16 {
	return DistGobRegId
}

func (r NamedPath) 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.EncodeString(buf, r.Name); err != nil {
		return err
	}
	return err
}

func (r NamedPath) CustomHash(hasher *proptools.Hasher) error {
	hasher.WriteString(":android.NamedPath")
	hasher.WriteInt(2)
	hasher.WriteString(":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(":.string")
	hasher.WriteString(r.Name)
	return nil
}

func (r *NamedPath) 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.(Path)
	}

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

	return err
}

var NamedPathGobRegId int16

func (r NamedPath) GetTypeId() int16 {
	return NamedPathGobRegId
}

func (r NamedPaths) 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 NamedPaths) CustomHash(hasher *proptools.Hasher) error {
	hasher.WriteString(":.[]NamedPath")
	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 *NamedPaths) 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([]NamedPath, val2)
		for val3 := 0; val3 < int(val2); val3++ {
			if err = (*r)[val3].Decode(ctx, buf); err != nil {
				return err
			}
		}
	}

	return err
}

var NamedPathsGobRegId int16

func (r NamedPaths) GetTypeId() int16 {
	return NamedPathsGobRegId
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

func (r InstallFilesInfo) CustomHash(hasher *proptools.Hasher) error {
	hasher.WriteString(":android.InstallFilesInfo")
	hasher.WriteInt(17)
	hasher.WriteString(":android.InstallPaths")
	hasher.WriteString(":.[]InstallPath")
	hasher.WriteInt(len(r.InstallFiles))
	for val1 := 0; val1 < len(r.InstallFiles); val1++ {
		if err := r.InstallFiles[val1].CustomHash(hasher); err != nil {
			return err
		}
	}
	hasher.WriteString(":android.Paths")
	hasher.WriteString(":.[]Path")
	hasher.WriteInt(len(r.CheckbuildFiles))
	for val2 := 0; val2 < len(r.CheckbuildFiles); val2++ {
		hasher.WriteString(":android.Path")
		val3 := r.CheckbuildFiles[val2] == nil
		if val3 {
			hasher.WriteByte(0)
		} else {
			if v := reflect.ValueOf(r.CheckbuildFiles[val2]); v.Kind() == reflect.Ptr {
				if v.IsNil() {
					panic(fmt.Errorf("nil pointer is not supported in interface"))
				} else {
					val4 := r.CheckbuildFiles[val2] == nil
					if val4 {
						hasher.WriteByte(0)
					} else {
						val5 := func(hasher *proptools.Hasher) error {
							return r.CheckbuildFiles[val2].(proptools.CustomHash).CustomHash(hasher)
						}
						if err := proptools.HashReference(hasher, uintptr(v.Pointer()), val5); err != nil {
							return err
						}
					}
				}
			} else {
				r.CheckbuildFiles[val2].(proptools.CustomHash).CustomHash(hasher)
			}
		}
	}
	hasher.WriteString(":.bool")
	if r.UncheckedModule {
		hasher.WriteByte(1)
	} else {
		hasher.WriteByte(0)
	}
	hasher.WriteString(":.[]PackagingSpec")
	hasher.WriteInt(len(r.PackagingSpecs))
	for val6 := 0; val6 < len(r.PackagingSpecs); val6++ {
		if err := r.PackagingSpecs[val6].CustomHash(hasher); err != nil {
			return err
		}
	}
	hasher.WriteString(":android.katiInstalls")
	hasher.WriteString(":.[]katiInstall")
	hasher.WriteInt(len(r.KatiInstalls))
	for val7 := 0; val7 < len(r.KatiInstalls); val7++ {
		if err := r.KatiInstalls[val7].CustomHash(hasher); err != nil {
			return err
		}
	}
	hasher.WriteString(":android.katiInstalls")
	hasher.WriteString(":.[]katiInstall")
	hasher.WriteInt(len(r.KatiSymlinks))
	for val8 := 0; val8 < len(r.KatiSymlinks); val8++ {
		if err := r.KatiSymlinks[val8].CustomHash(hasher); err != nil {
			return err
		}
	}
	hasher.WriteString(":.[]DataPath")
	hasher.WriteInt(len(r.TestData))
	for val9 := 0; val9 < len(r.TestData); val9++ {
		if err := r.TestData[val9].CustomHash(hasher); err != nil {
			return err
		}
	}
	val11 := func(hasher *proptools.Hasher, val10 PackagingSpec) error {
		if err := val10.CustomHash(hasher); err != nil {
			return err
		}
		return nil
	}
	if err := r.TransitivePackagingSpecs.Hash(hasher, "PackagingSpec", val11); err != nil {
		return err
	}
	hasher.WriteString(":android.WritablePath")
	val12 := r.LicenseMetadataFile == nil
	if val12 {
		hasher.WriteByte(0)
	} else {
		if v := reflect.ValueOf(r.LicenseMetadataFile); v.Kind() == reflect.Ptr {
			if v.IsNil() {
				panic(fmt.Errorf("nil pointer is not supported in interface"))
			} else {
				val13 := r.LicenseMetadataFile == nil
				if val13 {
					hasher.WriteByte(0)
				} else {
					val14 := func(hasher *proptools.Hasher) error {
						return r.LicenseMetadataFile.(proptools.CustomHash).CustomHash(hasher)
					}
					if err := proptools.HashReference(hasher, uintptr(v.Pointer()), val14); err != nil {
						return err
					}
				}
			}
		} else {
			r.LicenseMetadataFile.(proptools.CustomHash).CustomHash(hasher)
		}
	}
	val16 := func(hasher *proptools.Hasher, val15 InstallPath) error {
		if err := val15.CustomHash(hasher); err != nil {
			return err
		}
		return nil
	}
	if err := r.TransitiveInstallFiles.Hash(hasher, "InstallPath", val16); err != nil {
		return err
	}
	hasher.WriteString(":android.katiInstalls")
	hasher.WriteString(":.[]katiInstall")
	hasher.WriteInt(len(r.KatiInitRcInstalls))
	for val17 := 0; val17 < len(r.KatiInitRcInstalls); val17++ {
		if err := r.KatiInitRcInstalls[val17].CustomHash(hasher); err != nil {
			return err
		}
	}
	hasher.WriteString(":android.katiInstalls")
	hasher.WriteString(":.[]katiInstall")
	hasher.WriteInt(len(r.KatiVintfInstalls))
	for val18 := 0; val18 < len(r.KatiVintfInstalls); val18++ {
		if err := r.KatiVintfInstalls[val18].CustomHash(hasher); err != nil {
			return err
		}
	}
	hasher.WriteString(":android.Paths")
	hasher.WriteString(":.[]Path")
	hasher.WriteInt(len(r.InitRcPaths))
	for val19 := 0; val19 < len(r.InitRcPaths); val19++ {
		hasher.WriteString(":android.Path")
		val20 := r.InitRcPaths[val19] == nil
		if val20 {
			hasher.WriteByte(0)
		} else {
			if v := reflect.ValueOf(r.InitRcPaths[val19]); v.Kind() == reflect.Ptr {
				if v.IsNil() {
					panic(fmt.Errorf("nil pointer is not supported in interface"))
				} else {
					val21 := r.InitRcPaths[val19] == nil
					if val21 {
						hasher.WriteByte(0)
					} else {
						val22 := func(hasher *proptools.Hasher) error {
							return r.InitRcPaths[val19].(proptools.CustomHash).CustomHash(hasher)
						}
						if err := proptools.HashReference(hasher, uintptr(v.Pointer()), val22); err != nil {
							return err
						}
					}
				}
			} else {
				r.InitRcPaths[val19].(proptools.CustomHash).CustomHash(hasher)
			}
		}
	}
	hasher.WriteString(":android.Paths")
	hasher.WriteString(":.[]Path")
	hasher.WriteInt(len(r.VintfFragmentsPaths))
	for val23 := 0; val23 < len(r.VintfFragmentsPaths); val23++ {
		hasher.WriteString(":android.Path")
		val24 := r.VintfFragmentsPaths[val23] == nil
		if val24 {
			hasher.WriteByte(0)
		} else {
			if v := reflect.ValueOf(r.VintfFragmentsPaths[val23]); v.Kind() == reflect.Ptr {
				if v.IsNil() {
					panic(fmt.Errorf("nil pointer is not supported in interface"))
				} else {
					val25 := r.VintfFragmentsPaths[val23] == nil
					if val25 {
						hasher.WriteByte(0)
					} else {
						val26 := func(hasher *proptools.Hasher) error {
							return r.VintfFragmentsPaths[val23].(proptools.CustomHash).CustomHash(hasher)
						}
						if err := proptools.HashReference(hasher, uintptr(v.Pointer()), val26); err != nil {
							return err
						}
					}
				}
			} else {
				r.VintfFragmentsPaths[val23].(proptools.CustomHash).CustomHash(hasher)
			}
		}
	}
	hasher.WriteString(":android.InstallPaths")
	hasher.WriteString(":.[]InstallPath")
	hasher.WriteInt(len(r.InstalledInitRcPaths))
	for val27 := 0; val27 < len(r.InstalledInitRcPaths); val27++ {
		if err := r.InstalledInitRcPaths[val27].CustomHash(hasher); err != nil {
			return err
		}
	}
	hasher.WriteString(":android.InstallPaths")
	hasher.WriteString(":.[]InstallPath")
	hasher.WriteInt(len(r.InstalledVintfFragmentsPaths))
	for val28 := 0; val28 < len(r.InstalledVintfFragmentsPaths); val28++ {
		if err := r.InstalledVintfFragmentsPaths[val28].CustomHash(hasher); err != nil {
			return err
		}
	}
	hasher.WriteString(":android.TaggedDistFiles")
	hasher.WriteString(":.map[string]Paths")
	hasher.WriteInt(len(r.DistFiles))
	val29 := make([]string, 0, len(r.DistFiles))
	for val31 := range r.DistFiles {
		val29 = append(val29, val31)
	}
	proptools.SortOrdered(val29)
	for _, val30 := range val29 {
		hasher.WriteString(":.string")
		hasher.WriteString(val30)
		hasher.WriteString(":android.Paths")
		hasher.WriteString(":.[]Path")
		hasher.WriteInt(len(r.DistFiles[val30]))
		for val32 := 0; val32 < len(r.DistFiles[val30]); val32++ {
			hasher.WriteString(":android.Path")
			val33 := r.DistFiles[val30][val32] == nil
			if val33 {
				hasher.WriteByte(0)
			} else {
				if v := reflect.ValueOf(r.DistFiles[val30][val32]); v.Kind() == reflect.Ptr {
					if v.IsNil() {
						panic(fmt.Errorf("nil pointer is not supported in interface"))
					} else {
						val34 := r.DistFiles[val30][val32] == nil
						if val34 {
							hasher.WriteByte(0)
						} else {
							val35 := func(hasher *proptools.Hasher) error {
								return r.DistFiles[val30][val32].(proptools.CustomHash).CustomHash(hasher)
							}
							if err := proptools.HashReference(hasher, uintptr(v.Pointer()), val35); err != nil {
								return err
							}
						}
					}
				} else {
					r.DistFiles[val30][val32].(proptools.CustomHash).CustomHash(hasher)
				}
			}
		}
	}
	return nil
}

func (r *InstallFilesInfo) 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.InstallFiles = make([]InstallPath, val3)
		for val4 := 0; val4 < int(val3); val4++ {
			if err = r.InstallFiles[val4].Decode(ctx, buf); err != nil {
				return err
			}
		}
	}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

	return err
}

var InstallFilesInfoGobRegId int16

func (r InstallFilesInfo) GetTypeId() int16 {
	return InstallFilesInfoGobRegId
}

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

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

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

func (r *SourceFilesInfo) 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.Srcs = make([]Path, val3)
		for val4 := 0; val4 < int(val3); val4++ {
			if val6, err := gobtools.DecodeInterface(ctx, buf); err != nil {
				return err
			} else if val6 == nil {
				r.Srcs[val4] = nil
			} else {
				r.Srcs[val4] = val6.(Path)
			}
		}
	}

	return err
}

var SourceFilesInfoGobRegId int16

func (r SourceFilesInfo) GetTypeId() int16 {
	return SourceFilesInfoGobRegId
}

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

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

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

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

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

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

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

func (r ModuleBuildTargetsInfo) CustomHash(hasher *proptools.Hasher) error {
	hasher.WriteString(":android.ModuleBuildTargetsInfo")
	hasher.WriteInt(6)
	hasher.WriteString(":android.Path")
	val1 := r.InstallTarget == nil
	if val1 {
		hasher.WriteByte(0)
	} else {
		if v := reflect.ValueOf(r.InstallTarget); v.Kind() == reflect.Ptr {
			if v.IsNil() {
				panic(fmt.Errorf("nil pointer is not supported in interface"))
			} else {
				val2 := r.InstallTarget == nil
				if val2 {
					hasher.WriteByte(0)
				} else {
					val3 := func(hasher *proptools.Hasher) error { return r.InstallTarget.(proptools.CustomHash).CustomHash(hasher) }
					if err := proptools.HashReference(hasher, uintptr(v.Pointer()), val3); err != nil {
						return err
					}
				}
			}
		} else {
			r.InstallTarget.(proptools.CustomHash).CustomHash(hasher)
		}
	}
	hasher.WriteString(":android.Path")
	val4 := r.OutputsTarget == nil
	if val4 {
		hasher.WriteByte(0)
	} else {
		if v := reflect.ValueOf(r.OutputsTarget); v.Kind() == reflect.Ptr {
			if v.IsNil() {
				panic(fmt.Errorf("nil pointer is not supported in interface"))
			} else {
				val5 := r.OutputsTarget == nil
				if val5 {
					hasher.WriteByte(0)
				} else {
					val6 := func(hasher *proptools.Hasher) error { return r.OutputsTarget.(proptools.CustomHash).CustomHash(hasher) }
					if err := proptools.HashReference(hasher, uintptr(v.Pointer()), val6); err != nil {
						return err
					}
				}
			}
		} else {
			r.OutputsTarget.(proptools.CustomHash).CustomHash(hasher)
		}
	}
	hasher.WriteString(":android.Path")
	val7 := r.CheckbuildTarget == nil
	if val7 {
		hasher.WriteByte(0)
	} else {
		if v := reflect.ValueOf(r.CheckbuildTarget); v.Kind() == reflect.Ptr {
			if v.IsNil() {
				panic(fmt.Errorf("nil pointer is not supported in interface"))
			} else {
				val8 := r.CheckbuildTarget == nil
				if val8 {
					hasher.WriteByte(0)
				} else {
					val9 := func(hasher *proptools.Hasher) error {
						return r.CheckbuildTarget.(proptools.CustomHash).CustomHash(hasher)
					}
					if err := proptools.HashReference(hasher, uintptr(v.Pointer()), val9); err != nil {
						return err
					}
				}
			}
		} else {
			r.CheckbuildTarget.(proptools.CustomHash).CustomHash(hasher)
		}
	}
	hasher.WriteString(":android.Path")
	val10 := r.ModulePhonyTarget == nil
	if val10 {
		hasher.WriteByte(0)
	} else {
		if v := reflect.ValueOf(r.ModulePhonyTarget); v.Kind() == reflect.Ptr {
			if v.IsNil() {
				panic(fmt.Errorf("nil pointer is not supported in interface"))
			} else {
				val11 := r.ModulePhonyTarget == nil
				if val11 {
					hasher.WriteByte(0)
				} else {
					val12 := func(hasher *proptools.Hasher) error {
						return r.ModulePhonyTarget.(proptools.CustomHash).CustomHash(hasher)
					}
					if err := proptools.HashReference(hasher, uintptr(v.Pointer()), val12); err != nil {
						return err
					}
				}
			}
		} else {
			r.ModulePhonyTarget.(proptools.CustomHash).CustomHash(hasher)
		}
	}
	hasher.WriteString(":.bool")
	if r.NamespaceExportedToMake {
		hasher.WriteByte(1)
	} else {
		hasher.WriteByte(0)
	}
	hasher.WriteString(":.string")
	hasher.WriteString(r.BlueprintDir)
	return nil
}

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

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

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

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

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

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

	return err
}

var ModuleBuildTargetsInfoGobRegId int16

func (r ModuleBuildTargetsInfo) GetTypeId() int16 {
	return ModuleBuildTargetsInfoGobRegId
}

func (r JarJarRename) 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.EncodeString(buf, val2); err != nil {
				return err
			}
		}
	}
	return err
}

func (r JarJarRename) CustomHash(hasher *proptools.Hasher) error {
	hasher.WriteString(":.map[string]string")
	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(":.string")
		hasher.WriteString(r[val2])
	}
	return nil
}

func (r *JarJarRename) 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]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)[val3] = val4
		}
	}

	return err
}

var JarJarRenameGobRegId int16

func (r JarJarRename) GetTypeId() int16 {
	return JarJarRenameGobRegId
}

func (r BaseJarJarProviderData) 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 BaseJarJarProviderData) CustomHash(hasher *proptools.Hasher) error {
	hasher.WriteString(":android.BaseJarJarProviderData")
	hasher.WriteInt(1)
	hasher.WriteString(":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 *BaseJarJarProviderData) 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 BaseJarJarProviderDataGobRegId int16

func (r BaseJarJarProviderData) GetTypeId() int16 {
	return BaseJarJarProviderDataGobRegId
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

	if r.NinjaPhonies == nil {
		if err = gobtools.EncodeInt(buf, -1); err != nil {
			return err
		}
	} else {
		if err = gobtools.EncodeInt(buf, len(r.NinjaPhonies)); err != nil {
			return err
		}
		for val32, val33 := range r.NinjaPhonies {
			if err = gobtools.EncodeString(buf, val32); err != nil {
				return err
			}
			if err = val33.Encode(ctx, buf); err != nil {
				return err
			}
		}
	}

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

func (r CommonModuleInfo) CustomHash(hasher *proptools.Hasher) error {
	hasher.WriteString(":android.CommonModuleInfo")
	hasher.WriteInt(65)
	hasher.WriteString(":.bool")
	if r.Enabled {
		hasher.WriteByte(1)
	} else {
		hasher.WriteByte(0)
	}
	if err := r.Target.CustomHash(hasher); err != nil {
		return err
	}
	hasher.WriteString(":.bool")
	if r.SkipAndroidMkProcessing {
		hasher.WriteByte(1)
	} else {
		hasher.WriteByte(0)
	}
	hasher.WriteString(":.string")
	hasher.WriteString(r.BaseModuleName)
	hasher.WriteString(":.string")
	hasher.WriteString(r.BaseModuleType)
	hasher.WriteString(":.bool")
	if r.CanHaveApexVariants {
		hasher.WriteByte(1)
	} else {
		hasher.WriteByte(0)
	}
	if err := r.MinSdkVersion.CustomHash(hasher); err != nil {
		return err
	}
	hasher.WriteString(":.string")
	hasher.WriteString(r.SdkVersion)
	hasher.WriteString(":.bool")
	if r.NotInPlatform {
		hasher.WriteByte(1)
	} else {
		hasher.WriteByte(0)
	}
	hasher.WriteString(":.bool")
	if r.UninstallableApexPlatformVariant {
		hasher.WriteByte(1)
	} else {
		hasher.WriteByte(0)
	}
	if err := r.MinSdkVersionSupported.CustomHash(hasher); err != nil {
		return err
	}
	hasher.WriteString(":.bool")
	if r.ModuleWithMinSdkVersionCheck {
		hasher.WriteByte(1)
	} else {
		hasher.WriteByte(0)
	}
	hasher.WriteString(":.bool")
	if r.IsInstallableToApex {
		hasher.WriteByte(1)
	} else {
		hasher.WriteByte(0)
	}
	hasher.WriteString(":.bool")
	if r.HideFromMake {
		hasher.WriteByte(1)
	} else {
		hasher.WriteByte(0)
	}
	hasher.WriteString(":.bool")
	if r.SkipInstall {
		hasher.WriteByte(1)
	} else {
		hasher.WriteByte(0)
	}
	hasher.WriteString(":.bool")
	if r.IsStubsModule {
		hasher.WriteByte(1)
	} else {
		hasher.WriteByte(0)
	}
	hasher.WriteString(":.bool")
	if r.Host {
		hasher.WriteByte(1)
	} else {
		hasher.WriteByte(0)
	}
	hasher.WriteString(":.bool")
	if r.IsApexModule {
		hasher.WriteByte(1)
	} else {
		hasher.WriteByte(0)
	}
	hasher.WriteString(":.string")
	hasher.WriteString(r.Owner)
	hasher.WriteString(":.bool")
	if r.Vendor {
		hasher.WriteByte(1)
	} else {
		hasher.WriteByte(0)
	}
	hasher.WriteString(":.bool")
	if r.Proprietary {
		hasher.WriteByte(1)
	} else {
		hasher.WriteByte(0)
	}
	hasher.WriteString(":.bool")
	if r.SocSpecific {
		hasher.WriteByte(1)
	} else {
		hasher.WriteByte(0)
	}
	hasher.WriteString(":.bool")
	if r.ProductSpecific {
		hasher.WriteByte(1)
	} else {
		hasher.WriteByte(0)
	}
	hasher.WriteString(":.bool")
	if r.SystemExtSpecific {
		hasher.WriteByte(1)
	} else {
		hasher.WriteByte(0)
	}
	hasher.WriteString(":.bool")
	if r.DeviceSpecific {
		hasher.WriteByte(1)
	} else {
		hasher.WriteByte(0)
	}
	hasher.WriteString(":.bool")
	if r.UseGenericConfig {
		hasher.WriteByte(1)
	} else {
		hasher.WriteByte(0)
	}
	hasher.WriteString(":.bool")
	if r.NoFullInstall {
		hasher.WriteByte(1)
	} else {
		hasher.WriteByte(0)
	}
	hasher.WriteString(":.bool")
	if r.InVendorRamdisk {
		hasher.WriteByte(1)
	} else {
		hasher.WriteByte(0)
	}
	hasher.WriteString(":.bool")
	if r.ExemptFromRequiredApplicableLicensesProperty {
		hasher.WriteByte(1)
	} else {
		hasher.WriteByte(0)
	}
	hasher.WriteString(":.[]string")
	hasher.WriteInt(len(r.RequiredModuleNames))
	for val1 := 0; val1 < len(r.RequiredModuleNames); val1++ {
		hasher.WriteString(":.string")
		hasher.WriteString(r.RequiredModuleNames[val1])
	}
	hasher.WriteString(":.[]string")
	hasher.WriteInt(len(r.HostRequiredModuleNames))
	for val2 := 0; val2 < len(r.HostRequiredModuleNames); val2++ {
		hasher.WriteString(":.string")
		hasher.WriteString(r.HostRequiredModuleNames[val2])
	}
	hasher.WriteString(":.[]string")
	hasher.WriteInt(len(r.TargetRequiredModuleNames))
	for val3 := 0; val3 < len(r.TargetRequiredModuleNames); val3++ {
		hasher.WriteString(":.string")
		hasher.WriteString(r.TargetRequiredModuleNames[val3])
	}
	hasher.WriteString(":.[]string")
	hasher.WriteInt(len(r.VintfFragmentModuleNames))
	for val4 := 0; val4 < len(r.VintfFragmentModuleNames); val4++ {
		hasher.WriteString(":.string")
		hasher.WriteString(r.VintfFragmentModuleNames[val4])
	}
	hasher.WriteString(":.[]Dist")
	hasher.WriteInt(len(r.Dists))
	for val5 := 0; val5 < len(r.Dists); val5++ {
		if err := r.Dists[val5].CustomHash(hasher); err != nil {
			return err
		}
	}
	hasher.WriteString(":.bool")
	if r.ExportedToMake {
		hasher.WriteByte(1)
	} else {
		hasher.WriteByte(0)
	}
	hasher.WriteString(":.string")
	hasher.WriteString(r.Team)
	hasher.WriteString(":.string")
	hasher.WriteString(r.PartitionTag)
	hasher.WriteString(":.[]string")
	hasher.WriteInt(len(r.ApexAvailable))
	for val6 := 0; val6 < len(r.ApexAvailable); val6++ {
		hasher.WriteString(":.string")
		hasher.WriteString(r.ApexAvailable[val6])
	}
	hasher.WriteString(":.[]string")
	hasher.WriteInt(len(r.ApexAvailableFor))
	for val7 := 0; val7 < len(r.ApexAvailableFor); val7++ {
		hasher.WriteString(":.string")
		hasher.WriteString(r.ApexAvailableFor[val7])
	}
	if err := r.ImageVariation.CustomHash(hasher); err != nil {
		return err
	}
	hasher.WriteString(":.bool")
	if r.IsNonPrimaryImageVariation {
		hasher.WriteByte(1)
	} else {
		hasher.WriteByte(0)
	}
	hasher.WriteString(":.*ComplianceMetadataInfo")
	val8 := r.ComplianceMetadata == nil
	if val8 {
		hasher.WriteByte(0)
	} else {
		val9 := func(hasher *proptools.Hasher) error {
			if err := (*r.ComplianceMetadata).CustomHash(hasher); err != nil {
				return err
			}
			return nil
		}
		if err := proptools.HashReference(hasher, uintptr(unsafe.Pointer(r.ComplianceMetadata)), val9); err != nil {
			return err
		}
	}
	hasher.WriteString(":.*ModuleInfoJSONInfo")
	val10 := r.ModuleInfoJSON == nil
	if val10 {
		hasher.WriteByte(0)
	} else {
		val11 := func(hasher *proptools.Hasher) error {
			if err := (*r.ModuleInfoJSON).CustomHash(hasher); err != nil {
				return err
			}
			return nil
		}
		if err := proptools.HashReference(hasher, uintptr(unsafe.Pointer(r.ModuleInfoJSON)), val11); err != nil {
			return err
		}
	}
	hasher.WriteString(":.*unstableInfo")
	val12 := r.UnstableInfo == nil
	if val12 {
		hasher.WriteByte(0)
	} else {
		val13 := func(hasher *proptools.Hasher) error {
			if err := (*r.UnstableInfo).CustomHash(hasher); err != nil {
				return err
			}
			return nil
		}
		if err := proptools.HashReference(hasher, uintptr(unsafe.Pointer(r.UnstableInfo)), val13); err != nil {
			return err
		}
	}
	hasher.WriteString(":.*LicenseMetadataInfo")
	val14 := r.LicenseMetadata == nil
	if val14 {
		hasher.WriteByte(0)
	} else {
		val15 := func(hasher *proptools.Hasher) error {
			if err := (*r.LicenseMetadata).CustomHash(hasher); err != nil {
				return err
			}
			return nil
		}
		if err := proptools.HashReference(hasher, uintptr(unsafe.Pointer(r.LicenseMetadata)), val15); err != nil {
			return err
		}
	}
	hasher.WriteString(":.*LicensesInfo")
	val16 := r.Licenses == nil
	if val16 {
		hasher.WriteByte(0)
	} else {
		val17 := func(hasher *proptools.Hasher) error {
			if err := (*r.Licenses).CustomHash(hasher); err != nil {
				return err
			}
			return nil
		}
		if err := proptools.HashReference(hasher, uintptr(unsafe.Pointer(r.Licenses)), val17); err != nil {
			return err
		}
	}
	hasher.WriteString(":.*PhonyInfo")
	val18 := r.Phonies == nil
	if val18 {
		hasher.WriteByte(0)
	} else {
		val19 := func(hasher *proptools.Hasher) error {
			if err := (*r.Phonies).CustomHash(hasher); err != nil {
				return err
			}
			return nil
		}
		if err := proptools.HashReference(hasher, uintptr(unsafe.Pointer(r.Phonies)), val19); err != nil {
			return err
		}
	}
	hasher.WriteString(":.*OutputFilesInfo")
	val20 := r.OutputFiles == nil
	if val20 {
		hasher.WriteByte(0)
	} else {
		val21 := func(hasher *proptools.Hasher) error {
			if err := (*r.OutputFiles).CustomHash(hasher); err != nil {
				return err
			}
			return nil
		}
		if err := proptools.HashReference(hasher, uintptr(unsafe.Pointer(r.OutputFiles)), val21); err != nil {
			return err
		}
	}
	hasher.WriteString(":.*ModuleBuildTargetsInfo")
	val22 := r.ModuleBuildTargets == nil
	if val22 {
		hasher.WriteByte(0)
	} else {
		val23 := func(hasher *proptools.Hasher) error {
			if err := (*r.ModuleBuildTargets).CustomHash(hasher); err != nil {
				return err
			}
			return nil
		}
		if err := proptools.HashReference(hasher, uintptr(unsafe.Pointer(r.ModuleBuildTargets)), val23); err != nil {
			return err
		}
	}
	hasher.WriteString(":.*HostToolInfo")
	val24 := r.HostToolInfo == nil
	if val24 {
		hasher.WriteByte(0)
	} else {
		val25 := func(hasher *proptools.Hasher) error {
			if err := (*r.HostToolInfo).CustomHash(hasher); err != nil {
				return err
			}
			return nil
		}
		if err := proptools.HashReference(hasher, uintptr(unsafe.Pointer(r.HostToolInfo)), val25); err != nil {
			return err
		}
	}
	hasher.WriteString(":.*LogtagsInfo")
	val26 := r.Logtags == nil
	if val26 {
		hasher.WriteByte(0)
	} else {
		val27 := func(hasher *proptools.Hasher) error {
			if err := (*r.Logtags).CustomHash(hasher); err != nil {
				return err
			}
			return nil
		}
		if err := proptools.HashReference(hasher, uintptr(unsafe.Pointer(r.Logtags)), val27); err != nil {
			return err
		}
	}
	hasher.WriteString(":.*TestModuleInformation")
	val28 := r.TestModuleInfo == nil
	if val28 {
		hasher.WriteByte(0)
	} else {
		val29 := func(hasher *proptools.Hasher) error {
			if err := (*r.TestModuleInfo).CustomHash(hasher); err != nil {
				return err
			}
			return nil
		}
		if err := proptools.HashReference(hasher, uintptr(unsafe.Pointer(r.TestModuleInfo)), val29); err != nil {
			return err
		}
	}
	hasher.WriteString(":.*SymbolicOutputInfos")
	val30 := r.SymbolicOutput == nil
	if val30 {
		hasher.WriteByte(0)
	} else {
		val34 := func(hasher *proptools.Hasher) error {
			hasher.WriteString(":android.SymbolicOutputInfos")
			hasher.WriteString(":.[]*SymbolicOutputInfo")
			hasher.WriteInt(len((*r.SymbolicOutput)))
			for val31 := 0; val31 < len((*r.SymbolicOutput)); val31++ {
				hasher.WriteString(":.*SymbolicOutputInfo")
				val32 := (*r.SymbolicOutput)[val31] == nil
				if val32 {
					hasher.WriteByte(0)
				} else {
					val33 := func(hasher *proptools.Hasher) error {
						if err := (*(*r.SymbolicOutput)[val31]).CustomHash(hasher); err != nil {
							return err
						}
						return nil
					}
					if err := proptools.HashReference(hasher, uintptr(unsafe.Pointer((*r.SymbolicOutput)[val31])), val33); err != nil {
						return err
					}
				}
			}
			return nil
		}
		if err := proptools.HashReference(hasher, uintptr(unsafe.Pointer(r.SymbolicOutput)), val34); err != nil {
			return err
		}
	}
	hasher.WriteString(":.*IdeInfo")
	val35 := r.IdeInfo == nil
	if val35 {
		hasher.WriteByte(0)
	} else {
		val36 := func(hasher *proptools.Hasher) error {
			if err := (*r.IdeInfo).CustomHash(hasher); err != nil {
				return err
			}
			return nil
		}
		if err := proptools.HashReference(hasher, uintptr(unsafe.Pointer(r.IdeInfo)), val36); err != nil {
			return err
		}
	}
	hasher.WriteString(":.*aconfigPropagatingDeclarationsInfo")
	val37 := r.AconfigPropagatingDeclarations == nil
	if val37 {
		hasher.WriteByte(0)
	} else {
		val38 := func(hasher *proptools.Hasher) error {
			if err := (*r.AconfigPropagatingDeclarations).CustomHash(hasher); err != nil {
				return err
			}
			return nil
		}
		if err := proptools.HashReference(hasher, uintptr(unsafe.Pointer(r.AconfigPropagatingDeclarations)), val38); err != nil {
			return err
		}
	}
	hasher.WriteString(":.*MakeNamesInfo")
	val39 := r.MakeNames == nil
	if val39 {
		hasher.WriteByte(0)
	} else {
		val40 := func(hasher *proptools.Hasher) error {
			if err := (*r.MakeNames).CustomHash(hasher); err != nil {
				return err
			}
			return nil
		}
		if err := proptools.HashReference(hasher, uintptr(unsafe.Pointer(r.MakeNames)), val40); err != nil {
			return err
		}
	}
	hasher.WriteString(":.*SourceFilesInfo")
	val41 := r.SourceFiles == nil
	if val41 {
		hasher.WriteByte(0)
	} else {
		val42 := func(hasher *proptools.Hasher) error {
			if err := (*r.SourceFiles).CustomHash(hasher); err != nil {
				return err
			}
			return nil
		}
		if err := proptools.HashReference(hasher, uintptr(unsafe.Pointer(r.SourceFiles)), val42); err != nil {
			return err
		}
	}
	hasher.WriteString(":.*GeneratedSourceInfo")
	val43 := r.GeneratedSource == nil
	if val43 {
		hasher.WriteByte(0)
	} else {
		val44 := func(hasher *proptools.Hasher) error {
			if err := (*r.GeneratedSource).CustomHash(hasher); err != nil {
				return err
			}
			return nil
		}
		if err := proptools.HashReference(hasher, uintptr(unsafe.Pointer(r.GeneratedSource)), val44); err != nil {
			return err
		}
	}
	hasher.WriteString(":.*ContainersInfo")
	val45 := r.Containers == nil
	if val45 {
		hasher.WriteByte(0)
	} else {
		val46 := func(hasher *proptools.Hasher) error {
			if err := (*r.Containers).CustomHash(hasher); err != nil {
				return err
			}
			return nil
		}
		if err := proptools.HashReference(hasher, uintptr(unsafe.Pointer(r.Containers)), val46); err != nil {
			return err
		}
	}
	hasher.WriteString(":.*PackageInfo")
	val47 := r.PackageInfo == nil
	if val47 {
		hasher.WriteByte(0)
	} else {
		val48 := func(hasher *proptools.Hasher) error {
			if err := (*r.PackageInfo).CustomHash(hasher); err != nil {
				return err
			}
			return nil
		}
		if err := proptools.HashReference(hasher, uintptr(unsafe.Pointer(r.PackageInfo)), val48); err != nil {
			return err
		}
	}
	hasher.WriteString(":.*AndroidMkDataInfo")
	val49 := r.AndroidMkData == nil
	if val49 {
		hasher.WriteByte(0)
	} else {
		val50 := func(hasher *proptools.Hasher) error {
			if err := (*r.AndroidMkData).CustomHash(hasher); err != nil {
				return err
			}
			return nil
		}
		if err := proptools.HashReference(hasher, uintptr(unsafe.Pointer(r.AndroidMkData)), val50); err != nil {
			return err
		}
	}
	hasher.WriteString(":.*BaseJarJarProviderData")
	val51 := r.BaseJarJarProviderData == nil
	if val51 {
		hasher.WriteByte(0)
	} else {
		val52 := func(hasher *proptools.Hasher) error {
			if err := (*r.BaseJarJarProviderData).CustomHash(hasher); err != nil {
				return err
			}
			return nil
		}
		if err := proptools.HashReference(hasher, uintptr(unsafe.Pointer(r.BaseJarJarProviderData)), val52); err != nil {
			return err
		}
	}
	hasher.WriteString(":.*InstallFilesInfo")
	val53 := r.InstallFiles == nil
	if val53 {
		hasher.WriteByte(0)
	} else {
		val54 := func(hasher *proptools.Hasher) error {
			if err := (*r.InstallFiles).CustomHash(hasher); err != nil {
				return err
			}
			return nil
		}
		if err := proptools.HashReference(hasher, uintptr(unsafe.Pointer(r.InstallFiles)), val54); err != nil {
			return err
		}
	}
	hasher.WriteString(":.map[string]NinjaPhoniesGlobsInfo")
	hasher.WriteInt(len(r.NinjaPhonies))
	val55 := make([]string, 0, len(r.NinjaPhonies))
	for val57 := range r.NinjaPhonies {
		val55 = append(val55, val57)
	}
	proptools.SortOrdered(val55)
	for _, val56 := range val55 {
		hasher.WriteString(":.string")
		hasher.WriteString(val56)
		if err := r.NinjaPhonies[val56].CustomHash(hasher); err != nil {
			return err
		}
	}
	hasher.WriteString(":android.Paths")
	hasher.WriteString(":.[]Path")
	hasher.WriteInt(len(r.RuntimeHostToolDeps))
	for val58 := 0; val58 < len(r.RuntimeHostToolDeps); val58++ {
		hasher.WriteString(":android.Path")
		val59 := r.RuntimeHostToolDeps[val58] == nil
		if val59 {
			hasher.WriteByte(0)
		} else {
			if v := reflect.ValueOf(r.RuntimeHostToolDeps[val58]); v.Kind() == reflect.Ptr {
				if v.IsNil() {
					panic(fmt.Errorf("nil pointer is not supported in interface"))
				} else {
					val60 := r.RuntimeHostToolDeps[val58] == nil
					if val60 {
						hasher.WriteByte(0)
					} else {
						val61 := func(hasher *proptools.Hasher) error {
							return r.RuntimeHostToolDeps[val58].(proptools.CustomHash).CustomHash(hasher)
						}
						if err := proptools.HashReference(hasher, uintptr(v.Pointer()), val61); err != nil {
							return err
						}
					}
				}
			} else {
				r.RuntimeHostToolDeps[val58].(proptools.CustomHash).CustomHash(hasher)
			}
		}
	}
	return nil
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

	var val64 bool
	if err = gobtools.DecodeBool(buf, &val64); err != nil {
		return err
	}
	if !val64 {
		var val63 ComplianceMetadataInfo
		if err = val63.Decode(ctx, buf); err != nil {
			return err
		}
		r.ComplianceMetadata = &val63
	}

	var val67 bool
	if err = gobtools.DecodeBool(buf, &val67); err != nil {
		return err
	}
	if !val67 {
		var val66 ModuleInfoJSONInfo
		if err = val66.Decode(ctx, buf); err != nil {
			return err
		}
		r.ModuleInfoJSON = &val66
	}

	var val70 bool
	if err = gobtools.DecodeBool(buf, &val70); err != nil {
		return err
	}
	if !val70 {
		var val69 unstableInfo
		if err = val69.Decode(ctx, buf); err != nil {
			return err
		}
		r.UnstableInfo = &val69
	}

	var val73 bool
	if err = gobtools.DecodeBool(buf, &val73); err != nil {
		return err
	}
	if !val73 {
		var val72 LicenseMetadataInfo
		if err = val72.Decode(ctx, buf); err != nil {
			return err
		}
		r.LicenseMetadata = &val72
	}

	var val76 bool
	if err = gobtools.DecodeBool(buf, &val76); err != nil {
		return err
	}
	if !val76 {
		var val75 LicensesInfo
		if err = val75.Decode(ctx, buf); err != nil {
			return err
		}
		r.Licenses = &val75
	}

	var val79 bool
	if err = gobtools.DecodeBool(buf, &val79); err != nil {
		return err
	}
	if !val79 {
		var val78 PhonyInfo
		if err = val78.Decode(ctx, buf); err != nil {
			return err
		}
		r.Phonies = &val78
	}

	var val82 bool
	if err = gobtools.DecodeBool(buf, &val82); err != nil {
		return err
	}
	if !val82 {
		var val81 OutputFilesInfo
		if err = val81.Decode(ctx, buf); err != nil {
			return err
		}
		r.OutputFiles = &val81
	}

	var val85 bool
	if err = gobtools.DecodeBool(buf, &val85); err != nil {
		return err
	}
	if !val85 {
		var val84 ModuleBuildTargetsInfo
		if err = val84.Decode(ctx, buf); err != nil {
			return err
		}
		r.ModuleBuildTargets = &val84
	}

	var val88 bool
	if err = gobtools.DecodeBool(buf, &val88); err != nil {
		return err
	}
	if !val88 {
		var val87 HostToolInfo
		if err = val87.Decode(ctx, buf); err != nil {
			return err
		}
		r.HostToolInfo = &val87
	}

	var val91 bool
	if err = gobtools.DecodeBool(buf, &val91); err != nil {
		return err
	}
	if !val91 {
		var val90 LogtagsInfo
		if err = val90.Decode(ctx, buf); err != nil {
			return err
		}
		r.Logtags = &val90
	}

	var val94 bool
	if err = gobtools.DecodeBool(buf, &val94); err != nil {
		return err
	}
	if !val94 {
		var val93 TestModuleInformation
		if err = val93.Decode(ctx, buf); err != nil {
			return err
		}
		r.TestModuleInfo = &val93
	}

	var val97 bool
	if err = gobtools.DecodeBool(buf, &val97); err != nil {
		return err
	}
	if !val97 {
		var val96 SymbolicOutputInfos
		var val100 int
		err = gobtools.DecodeInt(buf, &val100)
		if err != nil {
			return err
		}
		if val100 != -1 {
			val96 = make([]*SymbolicOutputInfo, val100)
			for val101 := 0; val101 < int(val100); val101++ {
				var val103 bool
				if err = gobtools.DecodeBool(buf, &val103); err != nil {
					return err
				}
				if !val103 {
					var val102 SymbolicOutputInfo
					if err = val102.Decode(ctx, buf); err != nil {
						return err
					}
					val96[val101] = &val102
				}
			}
		}
		r.SymbolicOutput = &val96
	}

	var val106 bool
	if err = gobtools.DecodeBool(buf, &val106); err != nil {
		return err
	}
	if !val106 {
		var val105 IdeInfo
		if err = val105.Decode(ctx, buf); err != nil {
			return err
		}
		r.IdeInfo = &val105
	}

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

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

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

	var val118 bool
	if err = gobtools.DecodeBool(buf, &val118); err != nil {
		return err
	}
	if !val118 {
		var val117 GeneratedSourceInfo
		if err = val117.Decode(ctx, buf); err != nil {
			return err
		}
		r.GeneratedSource = &val117
	}

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

	var val124 bool
	if err = gobtools.DecodeBool(buf, &val124); err != nil {
		return err
	}
	if !val124 {
		var val123 PackageInfo
		if err = val123.Decode(ctx, buf); err != nil {
			return err
		}
		r.PackageInfo = &val123
	}

	var val127 bool
	if err = gobtools.DecodeBool(buf, &val127); err != nil {
		return err
	}
	if !val127 {
		var val126 AndroidMkDataInfo
		if err = val126.Decode(ctx, buf); err != nil {
			return err
		}
		r.AndroidMkData = &val126
	}

	var val130 bool
	if err = gobtools.DecodeBool(buf, &val130); err != nil {
		return err
	}
	if !val130 {
		var val129 BaseJarJarProviderData
		if err = val129.Decode(ctx, buf); err != nil {
			return err
		}
		r.BaseJarJarProviderData = &val129
	}

	var val133 bool
	if err = gobtools.DecodeBool(buf, &val133); err != nil {
		return err
	}
	if !val133 {
		var val132 InstallFilesInfo
		if err = val132.Decode(ctx, buf); err != nil {
			return err
		}
		r.InstallFiles = &val132
	}

	var val135 int
	err = gobtools.DecodeInt(buf, &val135)
	if err != nil {
		return err
	}
	if val135 != -1 {
		r.NinjaPhonies = make(map[string]NinjaPhoniesGlobsInfo, val135)
		for val136 := 0; val136 < int(val135); val136++ {
			var val137 string
			var val138 NinjaPhoniesGlobsInfo
			err = gobtools.DecodeString(buf, &val137)
			if err != nil {
				return err
			}
			if err = val138.Decode(ctx, buf); err != nil {
				return err
			}
			r.NinjaPhonies[val137] = val138
		}
	}

	var val143 int
	err = gobtools.DecodeInt(buf, &val143)
	if err != nil {
		return err
	}
	if val143 != -1 {
		r.RuntimeHostToolDeps = make([]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.RuntimeHostToolDeps[val144] = nil
			} else {
				r.RuntimeHostToolDeps[val144] = val146.(Path)
			}
		}
	}

	return err
}

var CommonModuleInfoGobRegId int16

func (r CommonModuleInfo) GetTypeId() int16 {
	return CommonModuleInfoGobRegId
}

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

	val1 := r.Globs.Len() == 0
	if err = gobtools.EncodeBool(buf, val1); err != nil {
		return err
	}
	if !val1 {
		if err = gobtools.EncodeReference(ctx, r.Globs, buf, func(v uniquelist.UniqueList[string], 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.EncodeString(buf, val2[val3]); err != nil {
						return err
					}
				}
			}
			return nil
		}); err != nil {
			return err
		}
	}
	return err
}

func (r NinjaPhoniesGlobsInfo) CustomHash(hasher *proptools.Hasher) error {
	hasher.WriteString(":android.NinjaPhoniesGlobsInfo")
	hasher.WriteInt(1)
	hasher.WriteString(":.uniquelist.UniqueList[string]")
	val2 := func(hasher *proptools.Hasher, val1 string) error {
		hasher.WriteString(":.string")
		hasher.WriteString(val1)
		return nil
	}
	if err := r.Globs.Hash(hasher, "string", val2); err != nil {
		return err
	}
	return nil
}

func (r *NinjaPhoniesGlobsInfo) 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 {
		tmp, err := gobtools.DecodeReference(ctx, &r.Globs, buf, func(value *uniquelist.UniqueList[string], buf *bytes.Reader) error {
			var val3 []string
			var val4 int
			err = gobtools.DecodeInt(buf, &val4)
			if err != nil {
				return err
			}
			if val4 != -1 {
				val3 = make([]string, val4)
				for val5 := 0; val5 < int(val4); val5++ {
					err = gobtools.DecodeString(buf, &val3[val5])
					if err != nil {
						return err
					}
				}
			}
			*value = uniquelist.Make(val3)
			return nil
		})
		if err != nil {
			return err
		}
		r.Globs = *tmp
	}

	return err
}

var NinjaPhoniesGlobsInfoGobRegId int16

func (r NinjaPhoniesGlobsInfo) GetTypeId() int16 {
	return NinjaPhoniesGlobsInfoGobRegId
}

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

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

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

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

func (r *ApiLevelOrPlatform) 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 ApiLevel
		if err = val1.Decode(ctx, buf); err != nil {
			return err
		}
		r.ApiLevel = &val1
	}

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

	return err
}

var ApiLevelOrPlatformGobRegId int16

func (r ApiLevelOrPlatform) GetTypeId() int16 {
	return ApiLevelOrPlatformGobRegId
}

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

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

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

func (r HostToolInfo) CustomHash(hasher *proptools.Hasher) error {
	hasher.WriteString(":android.HostToolInfo")
	hasher.WriteInt(2)
	if err := r.HostToolPath.CustomHash(hasher); err != nil {
		return err
	}
	val2 := func(hasher *proptools.Hasher, val1 PackagingSpec) error {
		if err := val1.CustomHash(hasher); err != nil {
			return err
		}
		return nil
	}
	if err := r.TransitivePackagingSpecs.Hash(hasher, "PackagingSpec", val2); err != nil {
		return err
	}
	return nil
}

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

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

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

	return err
}

var HostToolInfoGobRegId int16

func (r HostToolInfo) GetTypeId() int16 {
	return HostToolInfoGobRegId
}

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

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

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

func (r *DistInfo) 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.Dists = make([]dist, val2)
		for val3 := 0; val3 < int(val2); val3++ {
			if err = r.Dists[val3].Decode(ctx, buf); err != nil {
				return err
			}
		}
	}

	return err
}

var DistInfoGobRegId int16

func (r DistInfo) GetTypeId() int16 {
	return DistInfoGobRegId
}

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

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

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

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

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

func (r *GeneratedSourceInfo) 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.GeneratedSourceFiles = make([]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.GeneratedSourceFiles[val4] = nil
			} else {
				r.GeneratedSourceFiles[val4] = val6.(Path)
			}
		}
	}

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

	var val15 int
	err = gobtools.DecodeInt(buf, &val15)
	if err != nil {
		return err
	}
	if val15 != -1 {
		r.GeneratedDeps = make([]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.GeneratedDeps[val16] = nil
			} else {
				r.GeneratedDeps[val16] = val18.(Path)
			}
		}
	}

	return err
}

var GeneratedSourceInfoGobRegId int16

func (r GeneratedSourceInfo) GetTypeId() int16 {
	return GeneratedSourceInfoGobRegId
}

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

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

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

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

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

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

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

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

func (r katiInstall) CustomHash(hasher *proptools.Hasher) error {
	hasher.WriteString(":android.katiInstall")
	hasher.WriteInt(7)
	hasher.WriteString(":android.Path")
	val1 := r.from == nil
	if val1 {
		hasher.WriteByte(0)
	} else {
		if v := reflect.ValueOf(r.from); v.Kind() == reflect.Ptr {
			if v.IsNil() {
				panic(fmt.Errorf("nil pointer is not supported in interface"))
			} else {
				val2 := r.from == nil
				if val2 {
					hasher.WriteByte(0)
				} else {
					val3 := func(hasher *proptools.Hasher) error { return r.from.(proptools.CustomHash).CustomHash(hasher) }
					if err := proptools.HashReference(hasher, uintptr(v.Pointer()), val3); err != nil {
						return err
					}
				}
			}
		} else {
			r.from.(proptools.CustomHash).CustomHash(hasher)
		}
	}
	if err := r.to.CustomHash(hasher); err != nil {
		return err
	}
	hasher.WriteString(":android.Paths")
	hasher.WriteString(":.[]Path")
	hasher.WriteInt(len(r.implicitDeps))
	for val4 := 0; val4 < len(r.implicitDeps); val4++ {
		hasher.WriteString(":android.Path")
		val5 := r.implicitDeps[val4] == nil
		if val5 {
			hasher.WriteByte(0)
		} else {
			if v := reflect.ValueOf(r.implicitDeps[val4]); v.Kind() == reflect.Ptr {
				if v.IsNil() {
					panic(fmt.Errorf("nil pointer is not supported in interface"))
				} else {
					val6 := r.implicitDeps[val4] == nil
					if val6 {
						hasher.WriteByte(0)
					} else {
						val7 := func(hasher *proptools.Hasher) error {
							return r.implicitDeps[val4].(proptools.CustomHash).CustomHash(hasher)
						}
						if err := proptools.HashReference(hasher, uintptr(v.Pointer()), val7); err != nil {
							return err
						}
					}
				}
			} else {
				r.implicitDeps[val4].(proptools.CustomHash).CustomHash(hasher)
			}
		}
	}
	hasher.WriteString(":android.Paths")
	hasher.WriteString(":.[]Path")
	hasher.WriteInt(len(r.orderOnlyDeps))
	for val8 := 0; val8 < len(r.orderOnlyDeps); val8++ {
		hasher.WriteString(":android.Path")
		val9 := r.orderOnlyDeps[val8] == nil
		if val9 {
			hasher.WriteByte(0)
		} else {
			if v := reflect.ValueOf(r.orderOnlyDeps[val8]); v.Kind() == reflect.Ptr {
				if v.IsNil() {
					panic(fmt.Errorf("nil pointer is not supported in interface"))
				} else {
					val10 := r.orderOnlyDeps[val8] == nil
					if val10 {
						hasher.WriteByte(0)
					} else {
						val11 := func(hasher *proptools.Hasher) error {
							return r.orderOnlyDeps[val8].(proptools.CustomHash).CustomHash(hasher)
						}
						if err := proptools.HashReference(hasher, uintptr(v.Pointer()), val11); err != nil {
							return err
						}
					}
				}
			} else {
				r.orderOnlyDeps[val8].(proptools.CustomHash).CustomHash(hasher)
			}
		}
	}
	hasher.WriteString(":.bool")
	if r.executable {
		hasher.WriteByte(1)
	} else {
		hasher.WriteByte(0)
	}
	hasher.WriteString(":.*extraFilesZip")
	val12 := r.extraFiles == nil
	if val12 {
		hasher.WriteByte(0)
	} else {
		val13 := func(hasher *proptools.Hasher) error {
			if err := (*r.extraFiles).CustomHash(hasher); err != nil {
				return err
			}
			return nil
		}
		if err := proptools.HashReference(hasher, uintptr(unsafe.Pointer(r.extraFiles)), val13); err != nil {
			return err
		}
	}
	hasher.WriteString(":.string")
	hasher.WriteString(r.absFrom)
	return nil
}

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

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

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

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

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

	var val18 bool
	if err = gobtools.DecodeBool(buf, &val18); err != nil {
		return err
	}
	if !val18 {
		var val17 extraFilesZip
		if err = val17.Decode(ctx, buf); err != nil {
			return err
		}
		r.extraFiles = &val17
	}

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

	return err
}

var katiInstallGobRegId int16

func (r katiInstall) GetTypeId() int16 {
	return katiInstallGobRegId
}

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

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

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

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

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

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

	return err
}

var extraFilesZipGobRegId int16

func (r extraFilesZip) GetTypeId() int16 {
	return extraFilesZipGobRegId
}

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

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

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

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

func (r *OutputFilesInfo) 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.DefaultOutputFiles = make([]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.DefaultOutputFiles[val4] = nil
			} else {
				r.DefaultOutputFiles[val4] = val6.(Path)
			}
		}
	}

	var val7 int
	err = gobtools.DecodeInt(buf, &val7)
	if err != nil {
		return err
	}
	if val7 != -1 {
		r.TaggedOutputFiles = make(map[string]Paths, val7)
		for val8 := 0; val8 < int(val7); val8++ {
			var val9 string
			var val10 Paths
			err = gobtools.DecodeString(buf, &val9)
			if err != nil {
				return err
			}
			var val14 int
			err = gobtools.DecodeInt(buf, &val14)
			if err != nil {
				return err
			}
			if val14 != -1 {
				val10 = make([]Path, val14)
				for val15 := 0; val15 < int(val14); val15++ {
					if val17, err := gobtools.DecodeInterface(ctx, buf); err != nil {
						return err
					} else if val17 == nil {
						val10[val15] = nil
					} else {
						val10[val15] = val17.(Path)
					}
				}
			}
			r.TaggedOutputFiles[val9] = val10
		}
	}

	return err
}

var OutputFilesInfoGobRegId int16

func (r OutputFilesInfo) GetTypeId() int16 {
	return OutputFilesInfoGobRegId
}

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

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

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

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

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

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

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

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

	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 val4 := 0; val4 < len(r.Deps); val4++ {
			if err = gobtools.EncodeString(buf, r.Deps[val4]); err != nil {
				return err
			}
		}
	}

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

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

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

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

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

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

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

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

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

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

	if r.Static_libs == nil {
		if err = gobtools.EncodeInt(buf, -1); err != nil {
			return err
		}
	} else {
		if err = gobtools.EncodeInt(buf, len(r.Static_libs)); err != nil {
			return err
		}
		for val15 := 0; val15 < len(r.Static_libs); val15++ {
			if err = gobtools.EncodeString(buf, r.Static_libs[val15]); 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 val16 := 0; val16 < len(r.Libs); val16++ {
			if err = gobtools.EncodeString(buf, r.Libs[val16]); err != nil {
				return err
			}
		}
	}

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

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

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

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

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

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

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

func (r IdeInfo) CustomHash(hasher *proptools.Hasher) error {
	hasher.WriteString(":android.IdeInfo")
	hasher.WriteInt(27)
	hasher.WriteString(":.string")
	hasher.WriteString(r.BaseModuleName)
	hasher.WriteString(":.string")
	hasher.WriteString(r.ModuleType)
	hasher.WriteString(":.string")
	hasher.WriteString(r.Manifest)
	hasher.WriteString(":.string")
	hasher.WriteString(r.PackageName)
	hasher.WriteString(":.*AconfigIdeInfo")
	val1 := r.Aconfig == nil
	if val1 {
		hasher.WriteByte(0)
	} else {
		val2 := func(hasher *proptools.Hasher) error {
			if err := (*r.Aconfig).CustomHash(hasher); err != nil {
				return err
			}
			return nil
		}
		if err := proptools.HashReference(hasher, uintptr(unsafe.Pointer(r.Aconfig)), val2); err != nil {
			return err
		}
	}
	hasher.WriteString(":.*ProtoIdeInfo")
	val3 := r.Proto == nil
	if val3 {
		hasher.WriteByte(0)
	} else {
		val4 := func(hasher *proptools.Hasher) error {
			if err := (*r.Proto).CustomHash(hasher); err != nil {
				return err
			}
			return nil
		}
		if err := proptools.HashReference(hasher, uintptr(unsafe.Pointer(r.Proto)), val4); err != nil {
			return err
		}
	}
	hasher.WriteString(":.*AidlIdeInfo")
	val5 := r.Aidl == nil
	if val5 {
		hasher.WriteByte(0)
	} else {
		val6 := func(hasher *proptools.Hasher) error {
			if err := (*r.Aidl).CustomHash(hasher); err != nil {
				return err
			}
			return nil
		}
		if err := proptools.HashReference(hasher, uintptr(unsafe.Pointer(r.Aidl)), val6); err != nil {
			return err
		}
	}
	hasher.WriteString(":.[]string")
	hasher.WriteInt(len(r.Deps))
	for val7 := 0; val7 < len(r.Deps); val7++ {
		hasher.WriteString(":.string")
		hasher.WriteString(r.Deps[val7])
	}
	hasher.WriteString(":.[]string")
	hasher.WriteInt(len(r.Srcs))
	for val8 := 0; val8 < len(r.Srcs); val8++ {
		hasher.WriteString(":.string")
		hasher.WriteString(r.Srcs[val8])
	}
	hasher.WriteString(":.[]string")
	hasher.WriteInt(len(r.Aidl_include_dirs))
	for val9 := 0; val9 < len(r.Aidl_include_dirs); val9++ {
		hasher.WriteString(":.string")
		hasher.WriteString(r.Aidl_include_dirs[val9])
	}
	hasher.WriteString(":.[]string")
	hasher.WriteInt(len(r.Jarjar_rules))
	for val10 := 0; val10 < len(r.Jarjar_rules); val10++ {
		hasher.WriteString(":.string")
		hasher.WriteString(r.Jarjar_rules[val10])
	}
	hasher.WriteString(":.[]string")
	hasher.WriteInt(len(r.Jars))
	for val11 := 0; val11 < len(r.Jars); val11++ {
		hasher.WriteString(":.string")
		hasher.WriteString(r.Jars[val11])
	}
	hasher.WriteString(":.[]string")
	hasher.WriteInt(len(r.Imported_jars))
	for val12 := 0; val12 < len(r.Imported_jars); val12++ {
		hasher.WriteString(":.string")
		hasher.WriteString(r.Imported_jars[val12])
	}
	hasher.WriteString(":.[]string")
	hasher.WriteInt(len(r.Imported_aars))
	for val13 := 0; val13 < len(r.Imported_aars); val13++ {
		hasher.WriteString(":.string")
		hasher.WriteString(r.Imported_aars[val13])
	}
	hasher.WriteString(":.[]string")
	hasher.WriteInt(len(r.Classes))
	for val14 := 0; val14 < len(r.Classes); val14++ {
		hasher.WriteString(":.string")
		hasher.WriteString(r.Classes[val14])
	}
	hasher.WriteString(":.[]string")
	hasher.WriteInt(len(r.Installed_paths))
	for val15 := 0; val15 < len(r.Installed_paths); val15++ {
		hasher.WriteString(":.string")
		hasher.WriteString(r.Installed_paths[val15])
	}
	hasher.WriteString(":.[]string")
	hasher.WriteInt(len(r.SrcJars))
	for val16 := 0; val16 < len(r.SrcJars); val16++ {
		hasher.WriteString(":.string")
		hasher.WriteString(r.SrcJars[val16])
	}
	hasher.WriteString(":.[]string")
	hasher.WriteInt(len(r.Paths))
	for val17 := 0; val17 < len(r.Paths); val17++ {
		hasher.WriteString(":.string")
		hasher.WriteString(r.Paths[val17])
	}
	hasher.WriteString(":.[]string")
	hasher.WriteInt(len(r.Static_libs))
	for val18 := 0; val18 < len(r.Static_libs); val18++ {
		hasher.WriteString(":.string")
		hasher.WriteString(r.Static_libs[val18])
	}
	hasher.WriteString(":.[]string")
	hasher.WriteInt(len(r.Libs))
	for val19 := 0; val19 < len(r.Libs); val19++ {
		hasher.WriteString(":.string")
		hasher.WriteString(r.Libs[val19])
	}
	hasher.WriteString(":.[]string")
	hasher.WriteInt(len(r.Asset_dirs))
	for val20 := 0; val20 < len(r.Asset_dirs); val20++ {
		hasher.WriteString(":.string")
		hasher.WriteString(r.Asset_dirs[val20])
	}
	hasher.WriteString(":.[]string")
	hasher.WriteInt(len(r.Resource_dirs))
	for val21 := 0; val21 < len(r.Resource_dirs); val21++ {
		hasher.WriteString(":.string")
		hasher.WriteString(r.Resource_dirs[val21])
	}
	hasher.WriteString(":.[]string")
	hasher.WriteInt(len(r.Associates))
	for val22 := 0; val22 < len(r.Associates); val22++ {
		hasher.WriteString(":.string")
		hasher.WriteString(r.Associates[val22])
	}
	hasher.WriteString(":.[]string")
	hasher.WriteInt(len(r.Kotlincflags))
	for val23 := 0; val23 < len(r.Kotlincflags); val23++ {
		hasher.WriteString(":.string")
		hasher.WriteString(r.Kotlincflags[val23])
	}
	hasher.WriteString(":.[]string")
	hasher.WriteInt(len(r.Javacflags))
	for val24 := 0; val24 < len(r.Javacflags); val24++ {
		hasher.WriteString(":.string")
		hasher.WriteString(r.Javacflags[val24])
	}
	hasher.WriteString(":.[]string")
	hasher.WriteInt(len(r.Annotation_processor_flags))
	for val25 := 0; val25 < len(r.Annotation_processor_flags); val25++ {
		hasher.WriteString(":.string")
		hasher.WriteString(r.Annotation_processor_flags[val25])
	}
	hasher.WriteString(":.[]string")
	hasher.WriteInt(len(r.Plugins))
	for val26 := 0; val26 < len(r.Plugins); val26++ {
		hasher.WriteString(":.string")
		hasher.WriteString(r.Plugins[val26])
	}
	return nil
}

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

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

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

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

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

	var val6 bool
	if err = gobtools.DecodeBool(buf, &val6); err != nil {
		return err
	}
	if !val6 {
		var val5 AconfigIdeInfo
		if err = val5.Decode(ctx, buf); err != nil {
			return err
		}
		r.Aconfig = &val5
	}

	var val9 bool
	if err = gobtools.DecodeBool(buf, &val9); err != nil {
		return err
	}
	if !val9 {
		var val8 ProtoIdeInfo
		if err = val8.Decode(ctx, buf); err != nil {
			return err
		}
		r.Proto = &val8
	}

	var val12 bool
	if err = gobtools.DecodeBool(buf, &val12); err != nil {
		return err
	}
	if !val12 {
		var val11 AidlIdeInfo
		if err = val11.Decode(ctx, buf); err != nil {
			return err
		}
		r.Aidl = &val11
	}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

	return err
}

var IdeInfoGobRegId int16

func (r IdeInfo) GetTypeId() int16 {
	return IdeInfoGobRegId
}

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

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

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

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

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

func (r AconfigIdeInfo) CustomHash(hasher *proptools.Hasher) error {
	hasher.WriteString(":android.AconfigIdeInfo")
	hasher.WriteInt(4)
	hasher.WriteString(":.[]string")
	hasher.WriteInt(len(r.Srcs))
	for val1 := 0; val1 < len(r.Srcs); val1++ {
		hasher.WriteString(":.string")
		hasher.WriteString(r.Srcs[val1])
	}
	hasher.WriteString(":.string")
	hasher.WriteString(r.Mode)
	hasher.WriteString(":.string")
	hasher.WriteString(r.Package)
	hasher.WriteString(":.string")
	hasher.WriteString(r.Container)
	return nil
}

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

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

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

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

	return err
}

var AconfigIdeInfoGobRegId int16

func (r AconfigIdeInfo) GetTypeId() int16 {
	return AconfigIdeInfoGobRegId
}

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

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

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

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

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

func (r ProtoIdeInfo) CustomHash(hasher *proptools.Hasher) error {
	hasher.WriteString(":android.ProtoIdeInfo")
	hasher.WriteInt(4)
	hasher.WriteString(":.[]string")
	hasher.WriteInt(len(r.Srcs))
	for val1 := 0; val1 < len(r.Srcs); val1++ {
		hasher.WriteString(":.string")
		hasher.WriteString(r.Srcs[val1])
	}
	hasher.WriteString(":.string")
	hasher.WriteString(r.Type)
	hasher.WriteString(":.*bool")
	val2 := r.CanonicalPathFromRoot == nil
	if val2 {
		hasher.WriteByte(0)
	} else {
		val3 := func(hasher *proptools.Hasher) error {
			hasher.WriteString(":.bool")
			if *r.CanonicalPathFromRoot {
				hasher.WriteByte(1)
			} else {
				hasher.WriteByte(0)
			}
			return nil
		}
		if err := proptools.HashReference(hasher, uintptr(unsafe.Pointer(r.CanonicalPathFromRoot)), val3); err != nil {
			return err
		}
	}
	hasher.WriteString(":.[]string")
	hasher.WriteInt(len(r.LocalIncludeDirs))
	for val4 := 0; val4 < len(r.LocalIncludeDirs); val4++ {
		hasher.WriteString(":.string")
		hasher.WriteString(r.LocalIncludeDirs[val4])
	}
	return nil
}

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

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

	var val7 bool
	if err = gobtools.DecodeBool(buf, &val7); err != nil {
		return err
	}
	if !val7 {
		var val6 bool
		err = gobtools.DecodeBool(buf, &val6)
		if err != nil {
			return err
		}
		r.CanonicalPathFromRoot = &val6
	}

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

	return err
}

var ProtoIdeInfoGobRegId int16

func (r ProtoIdeInfo) GetTypeId() int16 {
	return ProtoIdeInfoGobRegId
}

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

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

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

func (r AidlIdeInfo) CustomHash(hasher *proptools.Hasher) error {
	hasher.WriteString(":android.AidlIdeInfo")
	hasher.WriteInt(2)
	hasher.WriteString(":.[]string")
	hasher.WriteInt(len(r.Srcs))
	for val1 := 0; val1 < len(r.Srcs); val1++ {
		hasher.WriteString(":.string")
		hasher.WriteString(r.Srcs[val1])
	}
	hasher.WriteString(":.string")
	hasher.WriteString(r.Stability)
	return nil
}

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

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

	return err
}

var AidlIdeInfoGobRegId int16

func (r AidlIdeInfo) GetTypeId() int16 {
	return AidlIdeInfoGobRegId
}

// end of module.go

// begin of module_info_json.go
func init() {
	CoreModuleInfoJSONGobRegId = gobtools.RegisterType(func() gobtools.CustomDec { return new(CoreModuleInfoJSON) })
	ExtraModuleInfoJSONGobRegId = gobtools.RegisterType(func() gobtools.CustomDec { return new(ExtraModuleInfoJSON) })
	ModuleInfoJSONGobRegId = gobtools.RegisterType(func() gobtools.CustomDec { return new(ModuleInfoJSON) })
	ModuleInfoJSONInfoGobRegId = gobtools.RegisterType(func() gobtools.CustomDec { return new(ModuleInfoJSONInfo) })
}

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

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

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

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

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

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

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

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

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

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

func (r CoreModuleInfoJSON) CustomHash(hasher *proptools.Hasher) error {
	hasher.WriteString(":android.CoreModuleInfoJSON")
	hasher.WriteInt(9)
	hasher.WriteString(":.string")
	hasher.WriteString(r.RegisterName)
	hasher.WriteString(":.[]string")
	hasher.WriteInt(len(r.Path))
	for val1 := 0; val1 < len(r.Path); val1++ {
		hasher.WriteString(":.string")
		hasher.WriteString(r.Path[val1])
	}
	hasher.WriteString(":.[]string")
	hasher.WriteInt(len(r.Installed))
	for val2 := 0; val2 < len(r.Installed); val2++ {
		hasher.WriteString(":.string")
		hasher.WriteString(r.Installed[val2])
	}
	hasher.WriteString(":.string")
	hasher.WriteString(r.ModuleName)
	hasher.WriteString(":.[]string")
	hasher.WriteInt(len(r.SupportedVariants))
	for val3 := 0; val3 < len(r.SupportedVariants); val3++ {
		hasher.WriteString(":.string")
		hasher.WriteString(r.SupportedVariants[val3])
	}
	hasher.WriteString(":.[]string")
	hasher.WriteInt(len(r.HostDependencies))
	for val4 := 0; val4 < len(r.HostDependencies); val4++ {
		hasher.WriteString(":.string")
		hasher.WriteString(r.HostDependencies[val4])
	}
	hasher.WriteString(":.[]string")
	hasher.WriteInt(len(r.TargetDependencies))
	for val5 := 0; val5 < len(r.TargetDependencies); val5++ {
		hasher.WriteString(":.string")
		hasher.WriteString(r.TargetDependencies[val5])
	}
	hasher.WriteString(":.[]string")
	hasher.WriteInt(len(r.Data))
	for val6 := 0; val6 < len(r.Data); val6++ {
		hasher.WriteString(":.string")
		hasher.WriteString(r.Data[val6])
	}
	hasher.WriteString(":.[]string")
	hasher.WriteInt(len(r.Required))
	for val7 := 0; val7 < len(r.Required); val7++ {
		hasher.WriteString(":.string")
		hasher.WriteString(r.Required[val7])
	}
	return nil
}

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

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

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

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

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

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

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

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

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

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

	return err
}

var CoreModuleInfoJSONGobRegId int16

func (r CoreModuleInfoJSON) GetTypeId() int16 {
	return CoreModuleInfoJSONGobRegId
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

func (r ExtraModuleInfoJSON) CustomHash(hasher *proptools.Hasher) error {
	hasher.WriteString(":android.ExtraModuleInfoJSON")
	hasher.WriteInt(27)
	hasher.WriteString(":.string")
	hasher.WriteString(r.SubName)
	hasher.WriteString(":.bool")
	if r.Uninstallable {
		hasher.WriteByte(1)
	} else {
		hasher.WriteByte(0)
	}
	hasher.WriteString(":.[]string")
	hasher.WriteInt(len(r.Class))
	for val1 := 0; val1 < len(r.Class); val1++ {
		hasher.WriteString(":.string")
		hasher.WriteString(r.Class[val1])
	}
	hasher.WriteString(":.[]string")
	hasher.WriteInt(len(r.Tags))
	for val2 := 0; val2 < len(r.Tags); val2++ {
		hasher.WriteString(":.string")
		hasher.WriteString(r.Tags[val2])
	}
	hasher.WriteString(":.[]string")
	hasher.WriteInt(len(r.Dependencies))
	for val3 := 0; val3 < len(r.Dependencies); val3++ {
		hasher.WriteString(":.string")
		hasher.WriteString(r.Dependencies[val3])
	}
	hasher.WriteString(":.[]string")
	hasher.WriteInt(len(r.SharedLibs))
	for val4 := 0; val4 < len(r.SharedLibs); val4++ {
		hasher.WriteString(":.string")
		hasher.WriteString(r.SharedLibs[val4])
	}
	hasher.WriteString(":.[]string")
	hasher.WriteInt(len(r.StaticLibs))
	for val5 := 0; val5 < len(r.StaticLibs); val5++ {
		hasher.WriteString(":.string")
		hasher.WriteString(r.StaticLibs[val5])
	}
	hasher.WriteString(":.[]string")
	hasher.WriteInt(len(r.SystemSharedLibs))
	for val6 := 0; val6 < len(r.SystemSharedLibs); val6++ {
		hasher.WriteString(":.string")
		hasher.WriteString(r.SystemSharedLibs[val6])
	}
	hasher.WriteString(":.[]string")
	hasher.WriteInt(len(r.Srcs))
	for val7 := 0; val7 < len(r.Srcs); val7++ {
		hasher.WriteString(":.string")
		hasher.WriteString(r.Srcs[val7])
	}
	hasher.WriteString(":.[]string")
	hasher.WriteInt(len(r.SrcJars))
	for val8 := 0; val8 < len(r.SrcJars); val8++ {
		hasher.WriteString(":.string")
		hasher.WriteString(r.SrcJars[val8])
	}
	hasher.WriteString(":.[]string")
	hasher.WriteInt(len(r.ClassesJar))
	for val9 := 0; val9 < len(r.ClassesJar); val9++ {
		hasher.WriteString(":.string")
		hasher.WriteString(r.ClassesJar[val9])
	}
	hasher.WriteString(":.[]string")
	hasher.WriteInt(len(r.TestMainlineModules))
	for val10 := 0; val10 < len(r.TestMainlineModules); val10++ {
		hasher.WriteString(":.string")
		hasher.WriteString(r.TestMainlineModules[val10])
	}
	hasher.WriteString(":.string")
	hasher.WriteString(r.IsUnitTest)
	hasher.WriteString(":.[]string")
	hasher.WriteInt(len(r.TestOptionsTags))
	for val11 := 0; val11 < len(r.TestOptionsTags); val11++ {
		hasher.WriteString(":.string")
		hasher.WriteString(r.TestOptionsTags[val11])
	}
	hasher.WriteString(":.[]string")
	hasher.WriteInt(len(r.RuntimeDependencies))
	for val12 := 0; val12 < len(r.RuntimeDependencies); val12++ {
		hasher.WriteString(":.string")
		hasher.WriteString(r.RuntimeDependencies[val12])
	}
	hasher.WriteString(":.[]string")
	hasher.WriteInt(len(r.StaticDependencies))
	for val13 := 0; val13 < len(r.StaticDependencies); val13++ {
		hasher.WriteString(":.string")
		hasher.WriteString(r.StaticDependencies[val13])
	}
	hasher.WriteString(":.[]string")
	hasher.WriteInt(len(r.DataDependencies))
	for val14 := 0; val14 < len(r.DataDependencies); val14++ {
		hasher.WriteString(":.string")
		hasher.WriteString(r.DataDependencies[val14])
	}
	hasher.WriteString(":.[]string")
	hasher.WriteInt(len(r.CompatibilitySuites))
	for val15 := 0; val15 < len(r.CompatibilitySuites); val15++ {
		hasher.WriteString(":.string")
		hasher.WriteString(r.CompatibilitySuites[val15])
	}
	hasher.WriteString(":.[]string")
	hasher.WriteInt(len(r.AutoTestConfig))
	for val16 := 0; val16 < len(r.AutoTestConfig); val16++ {
		hasher.WriteString(":.string")
		hasher.WriteString(r.AutoTestConfig[val16])
	}
	hasher.WriteString(":.[]string")
	hasher.WriteInt(len(r.TestConfig))
	for val17 := 0; val17 < len(r.TestConfig); val17++ {
		hasher.WriteString(":.string")
		hasher.WriteString(r.TestConfig[val17])
	}
	hasher.WriteString(":.string")
	hasher.WriteString(r.TestModuleConfigBase)
	hasher.WriteString(":.[]string")
	hasher.WriteInt(len(r.ExtraRequired))
	for val18 := 0; val18 < len(r.ExtraRequired); val18++ {
		hasher.WriteString(":.string")
		hasher.WriteString(r.ExtraRequired[val18])
	}
	hasher.WriteString(":.[]string")
	hasher.WriteInt(len(r.ExtraHostRequired))
	for val19 := 0; val19 < len(r.ExtraHostRequired); val19++ {
		hasher.WriteString(":.string")
		hasher.WriteString(r.ExtraHostRequired[val19])
	}
	hasher.WriteString(":.[]string")
	hasher.WriteInt(len(r.SupportedVariantsOverride))
	for val20 := 0; val20 < len(r.SupportedVariantsOverride); val20++ {
		hasher.WriteString(":.string")
		hasher.WriteString(r.SupportedVariantsOverride[val20])
	}
	hasher.WriteString(":.bool")
	if r.Disabled {
		hasher.WriteByte(1)
	} else {
		hasher.WriteByte(0)
	}
	hasher.WriteString(":.string")
	hasher.WriteString(r.RegisterNameOverride)
	hasher.WriteString(":.string")
	hasher.WriteString(r.ModuleNameOverride)
	return nil
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

	return err
}

var ExtraModuleInfoJSONGobRegId int16

func (r ExtraModuleInfoJSON) GetTypeId() int16 {
	return ExtraModuleInfoJSONGobRegId
}

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

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

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

func (r ModuleInfoJSON) CustomHash(hasher *proptools.Hasher) error {
	hasher.WriteString(":android.ModuleInfoJSON")
	hasher.WriteInt(2)
	if err := r.core.CustomHash(hasher); err != nil {
		return err
	}
	if err := r.ExtraModuleInfoJSON.CustomHash(hasher); err != nil {
		return err
	}
	return nil
}

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

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

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

	return err
}

var ModuleInfoJSONGobRegId int16

func (r ModuleInfoJSON) GetTypeId() int16 {
	return ModuleInfoJSONGobRegId
}

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

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

func (r ModuleInfoJSONInfo) CustomHash(hasher *proptools.Hasher) error {
	hasher.WriteString(":android.ModuleInfoJSONInfo")
	hasher.WriteInt(1)
	hasher.WriteString(":.[]*ModuleInfoJSON")
	hasher.WriteInt(len(r.Data))
	for val1 := 0; val1 < len(r.Data); val1++ {
		hasher.WriteString(":.*ModuleInfoJSON")
		val2 := r.Data[val1] == nil
		if val2 {
			hasher.WriteByte(0)
		} else {
			val3 := func(hasher *proptools.Hasher) error {
				if err := (*r.Data[val1]).CustomHash(hasher); err != nil {
					return err
				}
				return nil
			}
			if err := proptools.HashReference(hasher, uintptr(unsafe.Pointer(r.Data[val1])), val3); err != nil {
				return err
			}
		}
	}
	return nil
}

func (r *ModuleInfoJSONInfo) 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.Data = make([]*ModuleInfoJSON, val2)
		for val3 := 0; val3 < int(val2); val3++ {
			var val5 bool
			if err = gobtools.DecodeBool(buf, &val5); err != nil {
				return err
			}
			if !val5 {
				var val4 ModuleInfoJSON
				if err = val4.Decode(ctx, buf); err != nil {
					return err
				}
				r.Data[val3] = &val4
			}
		}
	}

	return err
}

var ModuleInfoJSONInfoGobRegId int16

func (r ModuleInfoJSONInfo) GetTypeId() int16 {
	return ModuleInfoJSONInfoGobRegId
}

// end of module_info_json.go

// begin of notices.go
func init() {
	NoticeModuleInfoGobRegId = gobtools.RegisterType(func() gobtools.CustomDec { return new(NoticeModuleInfo) })
	NoticeModuleInfosGobRegId = gobtools.RegisterType(func() gobtools.CustomDec { return new(NoticeModuleInfos) })
}

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

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

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

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

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

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

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

	return err
}

var NoticeModuleInfoGobRegId int16

func (r NoticeModuleInfo) GetTypeId() int16 {
	return NoticeModuleInfoGobRegId
}

func (r NoticeModuleInfos) 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 NoticeModuleInfos) CustomHash(hasher *proptools.Hasher) error {
	hasher.WriteString(":.[]NoticeModuleInfo")
	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 *NoticeModuleInfos) 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([]NoticeModuleInfo, val2)
		for val3 := 0; val3 < int(val2); val3++ {
			if err = (*r)[val3].Decode(ctx, buf); err != nil {
				return err
			}
		}
	}

	return err
}

var NoticeModuleInfosGobRegId int16

func (r NoticeModuleInfos) GetTypeId() int16 {
	return NoticeModuleInfosGobRegId
}

// end of notices.go

// begin of override_module.go
func init() {
	OverrideInfoGobRegId = gobtools.RegisterType(func() gobtools.CustomDec { return new(OverrideInfo) })
}

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

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

func (r OverrideInfo) CustomHash(hasher *proptools.Hasher) error {
	hasher.WriteString(":android.OverrideInfo")
	hasher.WriteInt(1)
	hasher.WriteString(":.string")
	hasher.WriteString(r.OverriddenBy)
	return nil
}

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

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

	return err
}

var OverrideInfoGobRegId int16

func (r OverrideInfo) GetTypeId() int16 {
	return OverrideInfoGobRegId
}

// end of override_module.go

// begin of package.go
func init() {
	packagePropertiesGobRegId = gobtools.RegisterType(func() gobtools.CustomDec { return new(packageProperties) })
	PackageInfoGobRegId = gobtools.RegisterType(func() gobtools.CustomDec { return new(PackageInfo) })
}

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

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

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

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

func (r packageProperties) CustomHash(hasher *proptools.Hasher) error {
	hasher.WriteString(":android.packageProperties")
	hasher.WriteInt(3)
	hasher.WriteString(":.[]string")
	hasher.WriteInt(len(r.Default_visibility))
	for val1 := 0; val1 < len(r.Default_visibility); val1++ {
		hasher.WriteString(":.string")
		hasher.WriteString(r.Default_visibility[val1])
	}
	hasher.WriteString(":.[]string")
	hasher.WriteInt(len(r.Default_applicable_licenses))
	for val2 := 0; val2 < len(r.Default_applicable_licenses); val2++ {
		hasher.WriteString(":.string")
		hasher.WriteString(r.Default_applicable_licenses[val2])
	}
	hasher.WriteString(":.*string")
	val3 := r.Default_team == nil
	if val3 {
		hasher.WriteByte(0)
	} else {
		val4 := func(hasher *proptools.Hasher) error {
			hasher.WriteString(":.string")
			hasher.WriteString((*r.Default_team))
			return nil
		}
		if err := proptools.HashReference(hasher, uintptr(unsafe.Pointer(r.Default_team)), val4); err != nil {
			return err
		}
	}
	return nil
}

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

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

	var val10 bool
	if err = gobtools.DecodeBool(buf, &val10); err != nil {
		return err
	}
	if !val10 {
		var val9 string
		err = gobtools.DecodeString(buf, &val9)
		if err != nil {
			return err
		}
		r.Default_team = &val9
	}

	return err
}

var packagePropertiesGobRegId int16

func (r packageProperties) GetTypeId() int16 {
	return packagePropertiesGobRegId
}

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

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

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

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

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

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

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

	return err
}

var PackageInfoGobRegId int16

func (r PackageInfo) GetTypeId() int16 {
	return PackageInfoGobRegId
}

// end of package.go

// begin of packaging.go
func init() {
	PackagingSpecGobRegId = gobtools.RegisterType(func() gobtools.CustomDec { return new(PackagingSpec) })
	RROInfoGobRegId = gobtools.RegisterType(func() gobtools.CustomDec { return new(RROInfo) })
}

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

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

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

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

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

	val1 := r.effectiveLicenseFiles.Len() == 0
	if err = gobtools.EncodeBool(buf, val1); err != nil {
		return err
	}
	if !val1 {
		if err = gobtools.EncodeReference(ctx, r.effectiveLicenseFiles, buf, func(v uniquelist.UniqueList[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.EncodeString(buf, r.partition); err != nil {
		return err
	}

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

	val4 := r.aconfigPaths.Len() == 0
	if err = gobtools.EncodeBool(buf, val4); err != nil {
		return err
	}
	if !val4 {
		if err = gobtools.EncodeReference(ctx, r.aconfigPaths, buf, func(v uniquelist.UniqueList[Path], buf *bytes.Buffer) error {
			val5 := v.ToSlice()
			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 := 0; val6 < len(val5); val6++ {
					if err = gobtools.EncodeInterface(ctx, buf, val5[val6]); err != nil {
						return err
					}
				}
			}
			return nil
		}); err != nil {
			return err
		}
	}

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

	val7 := r.overrides.Len() == 0
	if err = gobtools.EncodeBool(buf, val7); err != nil {
		return err
	}
	if !val7 {
		if err = gobtools.EncodeReference(ctx, r.overrides, buf, func(v uniquelist.UniqueList[string], buf *bytes.Buffer) error {
			val8 := v.ToSlice()
			if val8 == nil {
				if err = gobtools.EncodeInt(buf, -1); err != nil {
					return err
				}
			} else {
				if err = gobtools.EncodeInt(buf, len(val8)); err != nil {
					return err
				}
				for val9 := 0; val9 < len(val8); val9++ {
					if err = gobtools.EncodeString(buf, val8[val9]); err != nil {
						return err
					}
				}
			}
			return nil
		}); err != nil {
			return err
		}
	}

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

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

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

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

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

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

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

func (r PackagingSpec) CustomHash(hasher *proptools.Hasher) error {
	hasher.WriteString(":android.PackagingSpec")
	hasher.WriteInt(17)
	hasher.WriteString(":.string")
	hasher.WriteString(r.relPathInPackage)
	hasher.WriteString(":android.Path")
	val1 := r.srcPath == nil
	if val1 {
		hasher.WriteByte(0)
	} else {
		if v := reflect.ValueOf(r.srcPath); v.Kind() == reflect.Ptr {
			if v.IsNil() {
				panic(fmt.Errorf("nil pointer is not supported in interface"))
			} else {
				val2 := r.srcPath == nil
				if val2 {
					hasher.WriteByte(0)
				} else {
					val3 := func(hasher *proptools.Hasher) error { return r.srcPath.(proptools.CustomHash).CustomHash(hasher) }
					if err := proptools.HashReference(hasher, uintptr(v.Pointer()), val3); err != nil {
						return err
					}
				}
			}
		} else {
			r.srcPath.(proptools.CustomHash).CustomHash(hasher)
		}
	}
	hasher.WriteString(":.string")
	hasher.WriteString(r.symlinkTarget)
	hasher.WriteString(":.bool")
	if r.executable {
		hasher.WriteByte(1)
	} else {
		hasher.WriteByte(0)
	}
	hasher.WriteString(":.uniquelist.UniqueList[Path]")
	val8 := func(hasher *proptools.Hasher, val4 Path) error {
		hasher.WriteString(":android.Path")
		val5 := val4 == nil
		if val5 {
			hasher.WriteByte(0)
		} else {
			if v := reflect.ValueOf(val4); v.Kind() == reflect.Ptr {
				if v.IsNil() {
					panic(fmt.Errorf("nil pointer is not supported in interface"))
				} else {
					val6 := val4 == nil
					if val6 {
						hasher.WriteByte(0)
					} else {
						val7 := func(hasher *proptools.Hasher) error { return val4.(proptools.CustomHash).CustomHash(hasher) }
						if err := proptools.HashReference(hasher, uintptr(v.Pointer()), val7); err != nil {
							return err
						}
					}
				}
			} else {
				val4.(proptools.CustomHash).CustomHash(hasher)
			}
		}
		return nil
	}
	if err := r.effectiveLicenseFiles.Hash(hasher, "Path", val8); err != nil {
		return err
	}
	hasher.WriteString(":.string")
	hasher.WriteString(r.partition)
	hasher.WriteString(":.bool")
	if r.skipInstall {
		hasher.WriteByte(1)
	} else {
		hasher.WriteByte(0)
	}
	hasher.WriteString(":.uniquelist.UniqueList[Path]")
	val13 := func(hasher *proptools.Hasher, val9 Path) error {
		hasher.WriteString(":android.Path")
		val10 := val9 == nil
		if val10 {
			hasher.WriteByte(0)
		} else {
			if v := reflect.ValueOf(val9); v.Kind() == reflect.Ptr {
				if v.IsNil() {
					panic(fmt.Errorf("nil pointer is not supported in interface"))
				} else {
					val11 := val9 == nil
					if val11 {
						hasher.WriteByte(0)
					} else {
						val12 := func(hasher *proptools.Hasher) error { return val9.(proptools.CustomHash).CustomHash(hasher) }
						if err := proptools.HashReference(hasher, uintptr(v.Pointer()), val12); err != nil {
							return err
						}
					}
				}
			} else {
				val9.(proptools.CustomHash).CustomHash(hasher)
			}
		}
		return nil
	}
	if err := r.aconfigPaths.Hash(hasher, "Path", val13); err != nil {
		return err
	}
	if err := r.archType.CustomHash(hasher); err != nil {
		return err
	}
	hasher.WriteString(":.uniquelist.UniqueList[string]")
	val15 := func(hasher *proptools.Hasher, val14 string) error {
		hasher.WriteString(":.string")
		hasher.WriteString(val14)
		return nil
	}
	if err := r.overrides.Hash(hasher, "string", val15); err != nil {
		return err
	}
	hasher.WriteString(":.string")
	hasher.WriteString(r.owner)
	hasher.WriteString(":.bool")
	if r.requiresFullInstall {
		hasher.WriteByte(1)
	} else {
		hasher.WriteByte(0)
	}
	if err := r.fullInstallPath.CustomHash(hasher); err != nil {
		return err
	}
	hasher.WriteString(":.bool")
	if r.installInSanitizerDir {
		hasher.WriteByte(1)
	} else {
		hasher.WriteByte(0)
	}
	hasher.WriteString(":.string")
	hasher.WriteString(r.variation)
	hasher.WriteString(":.bool")
	if r.prebuilt {
		hasher.WriteByte(1)
	} else {
		hasher.WriteByte(0)
	}
	if err := r.extraZip.CustomHash(hasher); err != nil {
		return err
	}
	return nil
}

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

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

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

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

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

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

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

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

	var val16 bool
	if err = gobtools.DecodeBool(buf, &val16); err != nil {
		return err
	}
	if !val16 {
		tmp, err := gobtools.DecodeReference(ctx, &r.aconfigPaths, buf, func(value *uniquelist.UniqueList[Path], buf *bytes.Reader) error {
			var val17 []Path
			var val18 int
			err = gobtools.DecodeInt(buf, &val18)
			if err != nil {
				return err
			}
			if val18 != -1 {
				val17 = make([]Path, val18)
				for val19 := 0; val19 < int(val18); val19++ {
					if val21, err := gobtools.DecodeInterface(ctx, buf); err != nil {
						return err
					} else if val21 == nil {
						val17[val19] = nil
					} else {
						val17[val19] = val21.(Path)
					}
				}
			}
			*value = uniquelist.Make(val17)
			return nil
		})
		if err != nil {
			return err
		}
		r.aconfigPaths = *tmp
	}

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

	var val24 bool
	if err = gobtools.DecodeBool(buf, &val24); err != nil {
		return err
	}
	if !val24 {
		tmp, err := gobtools.DecodeReference(ctx, &r.overrides, buf, func(value *uniquelist.UniqueList[string], buf *bytes.Reader) error {
			var val25 []string
			var val26 int
			err = gobtools.DecodeInt(buf, &val26)
			if err != nil {
				return err
			}
			if val26 != -1 {
				val25 = make([]string, val26)
				for val27 := 0; val27 < int(val26); val27++ {
					err = gobtools.DecodeString(buf, &val25[val27])
					if err != nil {
						return err
					}
				}
			}
			*value = uniquelist.Make(val25)
			return nil
		})
		if err != nil {
			return err
		}
		r.overrides = *tmp
	}

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

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

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

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

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

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

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

	return err
}

var PackagingSpecGobRegId int16

func (r PackagingSpec) GetTypeId() int16 {
	return PackagingSpecGobRegId
}

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

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

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

func (r *RROInfo) 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.Paths = make([]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.Paths[val4] = nil
			} else {
				r.Paths[val4] = val6.(Path)
			}
		}
	}

	return err
}

var RROInfoGobRegId int16

func (r RROInfo) GetTypeId() int16 {
	return RROInfoGobRegId
}

// end of packaging.go

// begin of paths.go
func init() {
	OptionalPathGobRegId = gobtools.RegisterType(func() gobtools.CustomDec { return new(OptionalPath) })
	PathsGobRegId = gobtools.RegisterType(func() gobtools.CustomDec { return new(Paths) })
	directoryPathGobRegId = gobtools.RegisterType(func() gobtools.CustomDec { return new(directoryPath) })
	DirectoryPathsGobRegId = gobtools.RegisterType(func() gobtools.CustomDec { return new(DirectoryPaths) })
	basePathGobRegId = gobtools.RegisterType(func() gobtools.CustomDec { return new(basePath) })
	SourcePathGobRegId = gobtools.RegisterType(func() gobtools.CustomDec { return new(SourcePath) })
	OutputPathGobRegId = gobtools.RegisterType(func() gobtools.CustomDec { return new(OutputPath) })
	toolDepPathGobRegId = gobtools.RegisterType(func() gobtools.CustomDec { return new(toolDepPath) })
	ModuleOutPathGobRegId = gobtools.RegisterType(func() gobtools.CustomDec { return new(ModuleOutPath) })
	ModuleGenPathGobRegId = gobtools.RegisterType(func() gobtools.CustomDec { return new(ModuleGenPath) })
	ModuleObjPathGobRegId = gobtools.RegisterType(func() gobtools.CustomDec { return new(ModuleObjPath) })
	ModuleResPathGobRegId = gobtools.RegisterType(func() gobtools.CustomDec { return new(ModuleResPath) })
	InstallPathGobRegId = gobtools.RegisterType(func() gobtools.CustomDec { return new(InstallPath) })
	PhonyPathGobRegId = gobtools.RegisterType(func() gobtools.CustomDec { return new(PhonyPath) })
	testPathGobRegId = gobtools.RegisterType(func() gobtools.CustomDec { return new(testPath) })
	DataPathGobRegId = gobtools.RegisterType(func() gobtools.CustomDec { return new(DataPath) })
}

func (r OptionalPath) 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.EncodeString(buf, r.invalidReason); err != nil {
		return err
	}
	return err
}

func (r OptionalPath) CustomHash(hasher *proptools.Hasher) error {
	hasher.WriteString(":android.OptionalPath")
	hasher.WriteInt(2)
	hasher.WriteString(":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(":.string")
	hasher.WriteString(r.invalidReason)
	return nil
}

func (r *OptionalPath) 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.(Path)
	}

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

	return err
}

var OptionalPathGobRegId int16

func (r OptionalPath) GetTypeId() int16 {
	return OptionalPathGobRegId
}

func (r Paths) 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 = gobtools.EncodeInterface(ctx, buf, r[val1]); err != nil {
				return err
			}
		}
	}
	return err
}

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

func (r *Paths) 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([]Path, val2)
		for val3 := 0; val3 < int(val2); val3++ {
			if val5, err := gobtools.DecodeInterface(ctx, buf); err != nil {
				return err
			} else if val5 == nil {
				(*r)[val3] = nil
			} else {
				(*r)[val3] = val5.(Path)
			}
		}
	}

	return err
}

var PathsGobRegId int16

func (r Paths) GetTypeId() int16 {
	return PathsGobRegId
}

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

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

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

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

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

	return err
}

var directoryPathGobRegId int16

func (r directoryPath) GetTypeId() int16 {
	return directoryPathGobRegId
}

func (r DirectoryPaths) 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 = gobtools.EncodeInterface(ctx, buf, r[val1]); err != nil {
				return err
			}
		}
	}
	return err
}

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

func (r *DirectoryPaths) 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([]DirectoryPath, val2)
		for val3 := 0; val3 < int(val2); val3++ {
			if val5, err := gobtools.DecodeInterface(ctx, buf); err != nil {
				return err
			} else if val5 == nil {
				(*r)[val3] = nil
			} else {
				(*r)[val3] = val5.(DirectoryPath)
			}
		}
	}

	return err
}

var DirectoryPathsGobRegId int16

func (r DirectoryPaths) GetTypeId() int16 {
	return DirectoryPathsGobRegId
}

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

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

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

func (r basePath) CustomHash(hasher *proptools.Hasher) error {
	hasher.WriteString(":android.basePath")
	hasher.WriteInt(2)
	hasher.WriteString(":.string")
	hasher.WriteString(r.path)
	hasher.WriteString(":.string")
	hasher.WriteString(r.rel)
	return nil
}

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

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

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

	return err
}

var basePathGobRegId int16

func (r basePath) GetTypeId() int16 {
	return basePathGobRegId
}

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

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

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

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

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

	return err
}

var SourcePathGobRegId int16

func (r SourcePath) GetTypeId() int16 {
	return SourcePathGobRegId
}

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

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

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

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

func (r OutputPath) CustomHash(hasher *proptools.Hasher) error {
	hasher.WriteString(":android.OutputPath")
	hasher.WriteInt(3)
	if err := r.basePath.CustomHash(hasher); err != nil {
		return err
	}
	hasher.WriteString(":.string")
	hasher.WriteString(r.outDir)
	hasher.WriteString(":.string")
	hasher.WriteString(r.fullPath)
	return nil
}

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

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

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

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

	return err
}

var OutputPathGobRegId int16

func (r OutputPath) GetTypeId() int16 {
	return OutputPathGobRegId
}

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

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

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

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

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

	return err
}

var toolDepPathGobRegId int16

func (r toolDepPath) GetTypeId() int16 {
	return toolDepPathGobRegId
}

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

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

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

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

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

	return err
}

var ModuleOutPathGobRegId int16

func (r ModuleOutPath) GetTypeId() int16 {
	return ModuleOutPathGobRegId
}

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

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

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

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

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

	return err
}

var ModuleGenPathGobRegId int16

func (r ModuleGenPath) GetTypeId() int16 {
	return ModuleGenPathGobRegId
}

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

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

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

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

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

	return err
}

var ModuleObjPathGobRegId int16

func (r ModuleObjPath) GetTypeId() int16 {
	return ModuleObjPathGobRegId
}

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

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

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

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

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

	return err
}

var ModuleResPathGobRegId int16

func (r ModuleResPath) GetTypeId() int16 {
	return ModuleResPathGobRegId
}

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

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

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

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

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

	if err = gobtools.EncodeBool(buf, r.makePath); err != nil {
		return err
	}

	if err = gobtools.EncodeString(buf, r.fullPath); err != nil {
		return err
	}
	return err
}

func (r InstallPath) CustomHash(hasher *proptools.Hasher) error {
	hasher.WriteString(":android.InstallPath")
	hasher.WriteInt(6)
	if err := r.basePath.CustomHash(hasher); err != nil {
		return err
	}
	hasher.WriteString(":.string")
	hasher.WriteString(r.soongOutDir)
	hasher.WriteString(":.string")
	hasher.WriteString(r.partitionDir)
	hasher.WriteString(":.string")
	hasher.WriteString(r.partition)
	hasher.WriteString(":.bool")
	if r.makePath {
		hasher.WriteByte(1)
	} else {
		hasher.WriteByte(0)
	}
	hasher.WriteString(":.string")
	hasher.WriteString(r.fullPath)
	return nil
}

func (r *InstallPath) Decode(ctx gobtools.EncContext, buf *bytes.Reader) error {
	var err error

	if err = r.basePath.Decode(ctx, buf); err != nil {
		return err
	}

	err = gobtools.DecodeString(buf, &r.soongOutDir)
	if err != nil {
		return err
	}

	err = gobtools.DecodeString(buf, &r.partitionDir)
	if err != nil {
		return err
	}

	err = gobtools.DecodeString(buf, &r.partition)
	if err != nil {
		return err
	}

	err = gobtools.DecodeBool(buf, &r.makePath)
	if err != nil {
		return err
	}

	err = gobtools.DecodeString(buf, &r.fullPath)
	if err != nil {
		return err
	}

	return err
}

var InstallPathGobRegId int16

func (r InstallPath) GetTypeId() int16 {
	return InstallPathGobRegId
}

func (r PhonyPath) Encode(ctx gobtools.EncContext, buf *bytes.Buffer) error {
	var err error

	if err = r.basePath.Encode(ctx, buf); err != nil {
		return err
	}
	return err
}

func (r PhonyPath) CustomHash(hasher *proptools.Hasher) error {
	hasher.WriteString(":android.PhonyPath")
	hasher.WriteInt(1)
	if err := r.basePath.CustomHash(hasher); err != nil {
		return err
	}
	return nil
}

func (r *PhonyPath) Decode(ctx gobtools.EncContext, buf *bytes.Reader) error {
	var err error

	if err = r.basePath.Decode(ctx, buf); err != nil {
		return err
	}

	return err
}

var PhonyPathGobRegId int16

func (r PhonyPath) GetTypeId() int16 {
	return PhonyPathGobRegId
}

func (r testPath) Encode(ctx gobtools.EncContext, buf *bytes.Buffer) error {
	var err error

	if err = r.basePath.Encode(ctx, buf); err != nil {
		return err
	}
	return err
}

func (r testPath) CustomHash(hasher *proptools.Hasher) error {
	hasher.WriteString(":android.testPath")
	hasher.WriteInt(1)
	if err := r.basePath.CustomHash(hasher); err != nil {
		return err
	}
	return nil
}

func (r *testPath) Decode(ctx gobtools.EncContext, buf *bytes.Reader) error {
	var err error

	if err = r.basePath.Decode(ctx, buf); err != nil {
		return err
	}

	return err
}

var testPathGobRegId int16

func (r testPath) GetTypeId() int16 {
	return testPathGobRegId
}

func (r DataPath) Encode(ctx gobtools.EncContext, buf *bytes.Buffer) error {
	var err error

	if err = gobtools.EncodeInterface(ctx, buf, r.SrcPath); err != nil {
		return err
	}

	if err = gobtools.EncodeString(buf, r.RelativeInstallPath); err != nil {
		return err
	}

	if err = gobtools.EncodeBool(buf, r.WithoutRel); err != nil {
		return err
	}
	return err
}

func (r DataPath) CustomHash(hasher *proptools.Hasher) error {
	hasher.WriteString(":android.DataPath")
	hasher.WriteInt(3)
	hasher.WriteString(":android.Path")
	val1 := r.SrcPath == nil
	if val1 {
		hasher.WriteByte(0)
	} else {
		if v := reflect.ValueOf(r.SrcPath); v.Kind() == reflect.Ptr {
			if v.IsNil() {
				panic(fmt.Errorf("nil pointer is not supported in interface"))
			} else {
				val2 := r.SrcPath == nil
				if val2 {
					hasher.WriteByte(0)
				} else {
					val3 := func(hasher *proptools.Hasher) error { return r.SrcPath.(proptools.CustomHash).CustomHash(hasher) }
					if err := proptools.HashReference(hasher, uintptr(v.Pointer()), val3); err != nil {
						return err
					}
				}
			}
		} else {
			r.SrcPath.(proptools.CustomHash).CustomHash(hasher)
		}
	}
	hasher.WriteString(":.string")
	hasher.WriteString(r.RelativeInstallPath)
	hasher.WriteString(":.bool")
	if r.WithoutRel {
		hasher.WriteByte(1)
	} else {
		hasher.WriteByte(0)
	}
	return nil
}

func (r *DataPath) 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.SrcPath = nil
	} else {
		r.SrcPath = val2.(Path)
	}

	err = gobtools.DecodeString(buf, &r.RelativeInstallPath)
	if err != nil {
		return err
	}

	err = gobtools.DecodeBool(buf, &r.WithoutRel)
	if err != nil {
		return err
	}

	return err
}

var DataPathGobRegId int16

func (r DataPath) GetTypeId() int16 {
	return DataPathGobRegId
}

// end of paths.go

// begin of phony.go
func init() {
	PhonyInfoGobRegId = gobtools.RegisterType(func() gobtools.CustomDec { return new(PhonyInfo) })
}

func (r PhonyInfo) Encode(ctx gobtools.EncContext, buf *bytes.Buffer) error {
	var err error

	if r.Phonies == nil {
		if err = gobtools.EncodeInt(buf, -1); err != nil {
			return err
		}
	} else {
		if err = gobtools.EncodeInt(buf, len(r.Phonies)); err != nil {
			return err
		}
		for val1, val2 := range r.Phonies {
			if err = gobtools.EncodeString(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++ {
					if err = gobtools.EncodeInterface(ctx, buf, val2[val3]); err != nil {
						return err
					}
				}
			}
		}
	}
	return err
}

func (r PhonyInfo) CustomHash(hasher *proptools.Hasher) error {
	hasher.WriteString(":android.PhonyInfo")
	hasher.WriteInt(1)
	hasher.WriteString(":android.phonyMap")
	hasher.WriteString(":.map[string]Paths")
	hasher.WriteInt(len(r.Phonies))
	val1 := make([]string, 0, len(r.Phonies))
	for val3 := range r.Phonies {
		val1 = append(val1, val3)
	}
	proptools.SortOrdered(val1)
	for _, val2 := range val1 {
		hasher.WriteString(":.string")
		hasher.WriteString(val2)
		hasher.WriteString(":android.Paths")
		hasher.WriteString(":.[]Path")
		hasher.WriteInt(len(r.Phonies[val2]))
		for val4 := 0; val4 < len(r.Phonies[val2]); val4++ {
			hasher.WriteString(":android.Path")
			val5 := r.Phonies[val2][val4] == nil
			if val5 {
				hasher.WriteByte(0)
			} else {
				if v := reflect.ValueOf(r.Phonies[val2][val4]); v.Kind() == reflect.Ptr {
					if v.IsNil() {
						panic(fmt.Errorf("nil pointer is not supported in interface"))
					} else {
						val6 := r.Phonies[val2][val4] == nil
						if val6 {
							hasher.WriteByte(0)
						} else {
							val7 := func(hasher *proptools.Hasher) error {
								return r.Phonies[val2][val4].(proptools.CustomHash).CustomHash(hasher)
							}
							if err := proptools.HashReference(hasher, uintptr(v.Pointer()), val7); err != nil {
								return err
							}
						}
					}
				} else {
					r.Phonies[val2][val4].(proptools.CustomHash).CustomHash(hasher)
				}
			}
		}
	}
	return nil
}

func (r *PhonyInfo) 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.Phonies = make(map[string]Paths, val2)
		for val3 := 0; val3 < int(val2); val3++ {
			var val4 string
			var val5 Paths
			err = gobtools.DecodeString(buf, &val4)
			if err != nil {
				return err
			}
			var val9 int
			err = gobtools.DecodeInt(buf, &val9)
			if err != nil {
				return err
			}
			if val9 != -1 {
				val5 = make([]Path, val9)
				for val10 := 0; val10 < int(val9); val10++ {
					if val12, err := gobtools.DecodeInterface(ctx, buf); err != nil {
						return err
					} else if val12 == nil {
						val5[val10] = nil
					} else {
						val5[val10] = val12.(Path)
					}
				}
			}
			r.Phonies[val4] = val5
		}
	}

	return err
}

var PhonyInfoGobRegId int16

func (r PhonyInfo) GetTypeId() int16 {
	return PhonyInfoGobRegId
}

// end of phony.go

// begin of prebuilt.go
func init() {
	PrebuiltInfoGobRegId = gobtools.RegisterType(func() gobtools.CustomDec { return new(PrebuiltInfo) })
}

func (r PrebuiltInfo) Encode(ctx gobtools.EncContext, buf *bytes.Buffer) error {
	var err error

	if err = gobtools.EncodeBool(buf, r.IsPrebuilt); err != nil {
		return err
	}

	if err = gobtools.EncodeBool(buf, r.PrebuiltSourceExists); err != nil {
		return err
	}

	if err = gobtools.EncodeBool(buf, r.UsePrebuilt); err != nil {
		return err
	}

	if err = gobtools.EncodeBool(buf, r.ReplacedByPrebuilt); err != nil {
		return err
	}

	if err = gobtools.EncodeString(buf, r.PartitionTag); err != nil {
		return err
	}
	return err
}

func (r PrebuiltInfo) CustomHash(hasher *proptools.Hasher) error {
	hasher.WriteString(":android.PrebuiltInfo")
	hasher.WriteInt(5)
	hasher.WriteString(":.bool")
	if r.IsPrebuilt {
		hasher.WriteByte(1)
	} else {
		hasher.WriteByte(0)
	}
	hasher.WriteString(":.bool")
	if r.PrebuiltSourceExists {
		hasher.WriteByte(1)
	} else {
		hasher.WriteByte(0)
	}
	hasher.WriteString(":.bool")
	if r.UsePrebuilt {
		hasher.WriteByte(1)
	} else {
		hasher.WriteByte(0)
	}
	hasher.WriteString(":.bool")
	if r.ReplacedByPrebuilt {
		hasher.WriteByte(1)
	} else {
		hasher.WriteByte(0)
	}
	hasher.WriteString(":.string")
	hasher.WriteString(r.PartitionTag)
	return nil
}

func (r *PrebuiltInfo) Decode(ctx gobtools.EncContext, buf *bytes.Reader) error {
	var err error

	err = gobtools.DecodeBool(buf, &r.IsPrebuilt)
	if err != nil {
		return err
	}

	err = gobtools.DecodeBool(buf, &r.PrebuiltSourceExists)
	if err != nil {
		return err
	}

	err = gobtools.DecodeBool(buf, &r.UsePrebuilt)
	if err != nil {
		return err
	}

	err = gobtools.DecodeBool(buf, &r.ReplacedByPrebuilt)
	if err != nil {
		return err
	}

	err = gobtools.DecodeString(buf, &r.PartitionTag)
	if err != nil {
		return err
	}

	return err
}

var PrebuiltInfoGobRegId int16

func (r PrebuiltInfo) GetTypeId() int16 {
	return PrebuiltInfoGobRegId
}

// end of prebuilt.go

// begin of provider_keys.go
func init() {
	AndroidDeviceInfoGobRegId = gobtools.RegisterType(func() gobtools.CustomDec { return new(AndroidDeviceInfo) })
	PrebuiltKernelModulesComplianceMetadataGobRegId = gobtools.RegisterType(func() gobtools.CustomDec { return new(PrebuiltKernelModulesComplianceMetadata) })
}

func (r AndroidDeviceInfo) Encode(ctx gobtools.EncContext, buf *bytes.Buffer) error {
	var err error

	if err = gobtools.EncodeBool(buf, r.Main_device); err != nil {
		return err
	}
	return err
}

func (r AndroidDeviceInfo) CustomHash(hasher *proptools.Hasher) error {
	hasher.WriteString(":android.AndroidDeviceInfo")
	hasher.WriteInt(1)
	hasher.WriteString(":.bool")
	if r.Main_device {
		hasher.WriteByte(1)
	} else {
		hasher.WriteByte(0)
	}
	return nil
}

func (r *AndroidDeviceInfo) Decode(ctx gobtools.EncContext, buf *bytes.Reader) error {
	var err error

	err = gobtools.DecodeBool(buf, &r.Main_device)
	if err != nil {
		return err
	}

	return err
}

var AndroidDeviceInfoGobRegId int16

func (r AndroidDeviceInfo) GetTypeId() int16 {
	return AndroidDeviceInfoGobRegId
}

func (r PrebuiltKernelModulesComplianceMetadata) Encode(ctx gobtools.EncContext, buf *bytes.Buffer) error {
	var err error

	if r.Srcs == nil {
		if err = gobtools.EncodeInt(buf, -1); err != nil {
			return err
		}
	} else {
		if err = gobtools.EncodeInt(buf, len(r.Srcs)); err != nil {
			return err
		}
		for val1 := 0; val1 < len(r.Srcs); val1++ {
			if err = gobtools.EncodeString(buf, r.Srcs[val1]); err != nil {
				return err
			}
		}
	}

	if r.Dests == nil {
		if err = gobtools.EncodeInt(buf, -1); err != nil {
			return err
		}
	} else {
		if err = gobtools.EncodeInt(buf, len(r.Dests)); err != nil {
			return err
		}
		for val2 := 0; val2 < len(r.Dests); val2++ {
			if err = gobtools.EncodeString(buf, r.Dests[val2]); err != nil {
				return err
			}
		}
	}
	return err
}

func (r PrebuiltKernelModulesComplianceMetadata) CustomHash(hasher *proptools.Hasher) error {
	hasher.WriteString(":android.PrebuiltKernelModulesComplianceMetadata")
	hasher.WriteInt(2)
	hasher.WriteString(":.[]string")
	hasher.WriteInt(len(r.Srcs))
	for val1 := 0; val1 < len(r.Srcs); val1++ {
		hasher.WriteString(":.string")
		hasher.WriteString(r.Srcs[val1])
	}
	hasher.WriteString(":.[]string")
	hasher.WriteInt(len(r.Dests))
	for val2 := 0; val2 < len(r.Dests); val2++ {
		hasher.WriteString(":.string")
		hasher.WriteString(r.Dests[val2])
	}
	return nil
}

func (r *PrebuiltKernelModulesComplianceMetadata) 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.Srcs = make([]string, val2)
		for val3 := 0; val3 < int(val2); val3++ {
			err = gobtools.DecodeString(buf, &r.Srcs[val3])
			if err != nil {
				return err
			}
		}
	}

	var val6 int
	err = gobtools.DecodeInt(buf, &val6)
	if err != nil {
		return err
	}
	if val6 != -1 {
		r.Dests = make([]string, val6)
		for val7 := 0; val7 < int(val6); val7++ {
			err = gobtools.DecodeString(buf, &r.Dests[val7])
			if err != nil {
				return err
			}
		}
	}

	return err
}

var PrebuiltKernelModulesComplianceMetadataGobRegId int16

func (r PrebuiltKernelModulesComplianceMetadata) GetTypeId() int16 {
	return PrebuiltKernelModulesComplianceMetadataGobRegId
}

// end of provider_keys.go

// begin of rule_builder.go
func init() {
	RuleBuilderInstallGobRegId = gobtools.RegisterType(func() gobtools.CustomDec { return new(RuleBuilderInstall) })
}

func (r RuleBuilderInstall) Encode(ctx gobtools.EncContext, buf *bytes.Buffer) error {
	var err error

	if err = gobtools.EncodeInterface(ctx, buf, r.From); err != nil {
		return err
	}

	if err = gobtools.EncodeString(buf, r.To); err != nil {
		return err
	}
	return err
}

func (r RuleBuilderInstall) CustomHash(hasher *proptools.Hasher) error {
	hasher.WriteString(":android.RuleBuilderInstall")
	hasher.WriteInt(2)
	hasher.WriteString(":android.Path")
	val1 := r.From == nil
	if val1 {
		hasher.WriteByte(0)
	} else {
		if v := reflect.ValueOf(r.From); v.Kind() == reflect.Ptr {
			if v.IsNil() {
				panic(fmt.Errorf("nil pointer is not supported in interface"))
			} else {
				val2 := r.From == nil
				if val2 {
					hasher.WriteByte(0)
				} else {
					val3 := func(hasher *proptools.Hasher) error { return r.From.(proptools.CustomHash).CustomHash(hasher) }
					if err := proptools.HashReference(hasher, uintptr(v.Pointer()), val3); err != nil {
						return err
					}
				}
			}
		} else {
			r.From.(proptools.CustomHash).CustomHash(hasher)
		}
	}
	hasher.WriteString(":.string")
	hasher.WriteString(r.To)
	return nil
}

func (r *RuleBuilderInstall) 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.From = nil
	} else {
		r.From = val2.(Path)
	}

	err = gobtools.DecodeString(buf, &r.To)
	if err != nil {
		return err
	}

	return err
}

var RuleBuilderInstallGobRegId int16

func (r RuleBuilderInstall) GetTypeId() int16 {
	return RuleBuilderInstallGobRegId
}

// end of rule_builder.go

// begin of sdk.go
func init() {
	BpPrintableBaseGobRegId = gobtools.RegisterType(func() gobtools.CustomDec { return new(BpPrintableBase) })
	SdkMemberTraitBaseGobRegId = gobtools.RegisterType(func() gobtools.CustomDec { return new(SdkMemberTraitBase) })
	SdkMemberTypeBaseGobRegId = gobtools.RegisterType(func() gobtools.CustomDec { return new(SdkMemberTypeBase) })
	ExportedComponentsInfoGobRegId = gobtools.RegisterType(func() gobtools.CustomDec { return new(ExportedComponentsInfo) })
	AdditionalSdkInfoGobRegId = gobtools.RegisterType(func() gobtools.CustomDec { return new(AdditionalSdkInfo) })
	AdditionalSdkInfoPropertiesGobRegId = gobtools.RegisterType(func() gobtools.CustomDec { return new(AdditionalSdkInfoProperties) })
}

func (r BpPrintableBase) Encode(ctx gobtools.EncContext, buf *bytes.Buffer) error {
	var err error
	return err
}

func (r BpPrintableBase) CustomHash(hasher *proptools.Hasher) error {
	hasher.WriteString(":android.BpPrintableBase")
	hasher.WriteInt(0)
	return nil
}

func (r *BpPrintableBase) Decode(ctx gobtools.EncContext, buf *bytes.Reader) error {
	var err error

	return err
}

var BpPrintableBaseGobRegId int16

func (r BpPrintableBase) GetTypeId() int16 {
	return BpPrintableBaseGobRegId
}

func (r SdkMemberTraitBase) Encode(ctx gobtools.EncContext, buf *bytes.Buffer) error {
	var err error

	if err = gobtools.EncodeString(buf, r.PropertyName); err != nil {
		return err
	}
	return err
}

func (r SdkMemberTraitBase) CustomHash(hasher *proptools.Hasher) error {
	hasher.WriteString(":android.SdkMemberTraitBase")
	hasher.WriteInt(1)
	hasher.WriteString(":.string")
	hasher.WriteString(r.PropertyName)
	return nil
}

func (r *SdkMemberTraitBase) Decode(ctx gobtools.EncContext, buf *bytes.Reader) error {
	var err error

	err = gobtools.DecodeString(buf, &r.PropertyName)
	if err != nil {
		return err
	}

	return err
}

var SdkMemberTraitBaseGobRegId int16

func (r SdkMemberTraitBase) GetTypeId() int16 {
	return SdkMemberTraitBaseGobRegId
}

func (r SdkMemberTypeBase) Encode(ctx gobtools.EncContext, buf *bytes.Buffer) error {
	var err error

	if err = gobtools.EncodeString(buf, r.PropertyName); err != nil {
		return err
	}

	if r.OverridesPropertyNames == nil {
		if err = gobtools.EncodeInt(buf, -1); err != nil {
			return err
		}
	} else {
		if err = gobtools.EncodeInt(buf, len(r.OverridesPropertyNames)); err != nil {
			return err
		}
		for val1, val2 := range r.OverridesPropertyNames {
			if err = gobtools.EncodeString(buf, val1); err != nil {
				return err
			}
			if err = gobtools.EncodeBool(buf, val2); err != nil {
				return err
			}
		}
	}

	if r.SupportedLinkageNames == nil {
		if err = gobtools.EncodeInt(buf, -1); err != nil {
			return err
		}
	} else {
		if err = gobtools.EncodeInt(buf, len(r.SupportedLinkageNames)); err != nil {
			return err
		}
		for val3 := 0; val3 < len(r.SupportedLinkageNames); val3++ {
			if err = gobtools.EncodeString(buf, r.SupportedLinkageNames[val3]); err != nil {
				return err
			}
		}
	}

	if err = gobtools.EncodeBool(buf, r.StripDisabled); err != nil {
		return err
	}

	if err = gobtools.EncodeBool(buf, r.BpPropertyNotRequired); err != nil {
		return err
	}

	if err = gobtools.EncodeString(buf, r.SupportedBuildReleaseSpecification); err != nil {
		return err
	}

	if err = gobtools.EncodeBool(buf, r.SupportsSdk); err != nil {
		return err
	}

	if err = gobtools.EncodeBool(buf, r.HostOsDependent); err != nil {
		return err
	}

	if err = gobtools.EncodeBool(buf, r.UseSourceModuleTypeInSnapshot); err != nil {
		return err
	}

	val4 := r.PrebuiltsRequired == nil
	if err = gobtools.EncodeBool(buf, val4); err != nil {
		return err
	}
	if !val4 {
		if err = gobtools.EncodeBool(buf, (*r.PrebuiltsRequired)); err != nil {
			return err
		}
	}

	if r.Traits == nil {
		if err = gobtools.EncodeInt(buf, -1); err != nil {
			return err
		}
	} else {
		if err = gobtools.EncodeInt(buf, len(r.Traits)); err != nil {
			return err
		}
		for val5 := 0; val5 < len(r.Traits); val5++ {
			if err = gobtools.EncodeInterface(ctx, buf, r.Traits[val5]); err != nil {
				return err
			}
		}
	}
	return err
}

func (r SdkMemberTypeBase) CustomHash(hasher *proptools.Hasher) error {
	hasher.WriteString(":android.SdkMemberTypeBase")
	hasher.WriteInt(11)
	hasher.WriteString(":.string")
	hasher.WriteString(r.PropertyName)
	hasher.WriteString(":.map[string]bool")
	hasher.WriteInt(len(r.OverridesPropertyNames))
	val1 := make([]string, 0, len(r.OverridesPropertyNames))
	for val3 := range r.OverridesPropertyNames {
		val1 = append(val1, val3)
	}
	proptools.SortOrdered(val1)
	for _, val2 := range val1 {
		hasher.WriteString(":.string")
		hasher.WriteString(val2)
		hasher.WriteString(":.bool")
		if r.OverridesPropertyNames[val2] {
			hasher.WriteByte(1)
		} else {
			hasher.WriteByte(0)
		}
	}
	hasher.WriteString(":.[]string")
	hasher.WriteInt(len(r.SupportedLinkageNames))
	for val4 := 0; val4 < len(r.SupportedLinkageNames); val4++ {
		hasher.WriteString(":.string")
		hasher.WriteString(r.SupportedLinkageNames[val4])
	}
	hasher.WriteString(":.bool")
	if r.StripDisabled {
		hasher.WriteByte(1)
	} else {
		hasher.WriteByte(0)
	}
	hasher.WriteString(":.bool")
	if r.BpPropertyNotRequired {
		hasher.WriteByte(1)
	} else {
		hasher.WriteByte(0)
	}
	hasher.WriteString(":.string")
	hasher.WriteString(r.SupportedBuildReleaseSpecification)
	hasher.WriteString(":.bool")
	if r.SupportsSdk {
		hasher.WriteByte(1)
	} else {
		hasher.WriteByte(0)
	}
	hasher.WriteString(":.bool")
	if r.HostOsDependent {
		hasher.WriteByte(1)
	} else {
		hasher.WriteByte(0)
	}
	hasher.WriteString(":.bool")
	if r.UseSourceModuleTypeInSnapshot {
		hasher.WriteByte(1)
	} else {
		hasher.WriteByte(0)
	}
	hasher.WriteString(":.*bool")
	val5 := r.PrebuiltsRequired == nil
	if val5 {
		hasher.WriteByte(0)
	} else {
		val6 := func(hasher *proptools.Hasher) error {
			hasher.WriteString(":.bool")
			if *r.PrebuiltsRequired {
				hasher.WriteByte(1)
			} else {
				hasher.WriteByte(0)
			}
			return nil
		}
		if err := proptools.HashReference(hasher, uintptr(unsafe.Pointer(r.PrebuiltsRequired)), val6); err != nil {
			return err
		}
	}
	hasher.WriteString(":.[]SdkMemberTrait")
	hasher.WriteInt(len(r.Traits))
	for val7 := 0; val7 < len(r.Traits); val7++ {
		hasher.WriteString(":android.SdkMemberTrait")
		val8 := r.Traits[val7] == nil
		if val8 {
			hasher.WriteByte(0)
		} else {
			if v := reflect.ValueOf(r.Traits[val7]); v.Kind() == reflect.Ptr {
				if v.IsNil() {
					panic(fmt.Errorf("nil pointer is not supported in interface"))
				} else {
					val9 := r.Traits[val7] == nil
					if val9 {
						hasher.WriteByte(0)
					} else {
						val10 := func(hasher *proptools.Hasher) error { return r.Traits[val7].(proptools.CustomHash).CustomHash(hasher) }
						if err := proptools.HashReference(hasher, uintptr(v.Pointer()), val10); err != nil {
							return err
						}
					}
				}
			} else {
				r.Traits[val7].(proptools.CustomHash).CustomHash(hasher)
			}
		}
	}
	return nil
}

func (r *SdkMemberTypeBase) Decode(ctx gobtools.EncContext, buf *bytes.Reader) error {
	var err error

	err = gobtools.DecodeString(buf, &r.PropertyName)
	if err != nil {
		return err
	}

	var val2 int
	err = gobtools.DecodeInt(buf, &val2)
	if err != nil {
		return err
	}
	if val2 != -1 {
		r.OverridesPropertyNames = make(map[string]bool, val2)
		for val3 := 0; val3 < int(val2); val3++ {
			var val4 string
			var val5 bool
			err = gobtools.DecodeString(buf, &val4)
			if err != nil {
				return err
			}
			err = gobtools.DecodeBool(buf, &val5)
			if err != nil {
				return err
			}
			r.OverridesPropertyNames[val4] = val5
		}
	}

	var val9 int
	err = gobtools.DecodeInt(buf, &val9)
	if err != nil {
		return err
	}
	if val9 != -1 {
		r.SupportedLinkageNames = make([]string, val9)
		for val10 := 0; val10 < int(val9); val10++ {
			err = gobtools.DecodeString(buf, &r.SupportedLinkageNames[val10])
			if err != nil {
				return err
			}
		}
	}

	err = gobtools.DecodeBool(buf, &r.StripDisabled)
	if err != nil {
		return err
	}

	err = gobtools.DecodeBool(buf, &r.BpPropertyNotRequired)
	if err != nil {
		return err
	}

	err = gobtools.DecodeString(buf, &r.SupportedBuildReleaseSpecification)
	if err != nil {
		return err
	}

	err = gobtools.DecodeBool(buf, &r.SupportsSdk)
	if err != nil {
		return err
	}

	err = gobtools.DecodeBool(buf, &r.HostOsDependent)
	if err != nil {
		return err
	}

	err = gobtools.DecodeBool(buf, &r.UseSourceModuleTypeInSnapshot)
	if err != nil {
		return err
	}

	var val19 bool
	if err = gobtools.DecodeBool(buf, &val19); err != nil {
		return err
	}
	if !val19 {
		var val18 bool
		err = gobtools.DecodeBool(buf, &val18)
		if err != nil {
			return err
		}
		r.PrebuiltsRequired = &val18
	}

	var val22 int
	err = gobtools.DecodeInt(buf, &val22)
	if err != nil {
		return err
	}
	if val22 != -1 {
		r.Traits = make([]SdkMemberTrait, val22)
		for val23 := 0; val23 < int(val22); val23++ {
			if val25, err := gobtools.DecodeInterface(ctx, buf); err != nil {
				return err
			} else if val25 == nil {
				r.Traits[val23] = nil
			} else {
				r.Traits[val23] = val25.(SdkMemberTrait)
			}
		}
	}

	return err
}

var SdkMemberTypeBaseGobRegId int16

func (r SdkMemberTypeBase) GetTypeId() int16 {
	return SdkMemberTypeBaseGobRegId
}

func (r ExportedComponentsInfo) Encode(ctx gobtools.EncContext, buf *bytes.Buffer) error {
	var err error

	if r.Components == nil {
		if err = gobtools.EncodeInt(buf, -1); err != nil {
			return err
		}
	} else {
		if err = gobtools.EncodeInt(buf, len(r.Components)); err != nil {
			return err
		}
		for val1 := 0; val1 < len(r.Components); val1++ {
			if err = gobtools.EncodeString(buf, r.Components[val1]); err != nil {
				return err
			}
		}
	}
	return err
}

func (r ExportedComponentsInfo) CustomHash(hasher *proptools.Hasher) error {
	hasher.WriteString(":android.ExportedComponentsInfo")
	hasher.WriteInt(1)
	hasher.WriteString(":.[]string")
	hasher.WriteInt(len(r.Components))
	for val1 := 0; val1 < len(r.Components); val1++ {
		hasher.WriteString(":.string")
		hasher.WriteString(r.Components[val1])
	}
	return nil
}

func (r *ExportedComponentsInfo) 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.Components = make([]string, val2)
		for val3 := 0; val3 < int(val2); val3++ {
			err = gobtools.DecodeString(buf, &r.Components[val3])
			if err != nil {
				return err
			}
		}
	}

	return err
}

var ExportedComponentsInfoGobRegId int16

func (r ExportedComponentsInfo) GetTypeId() int16 {
	return ExportedComponentsInfoGobRegId
}

func (r AdditionalSdkInfo) Encode(ctx gobtools.EncContext, buf *bytes.Buffer) error {
	var err error

	if err = r.Properties.Encode(ctx, buf); err != nil {
		return err
	}
	return err
}

func (r AdditionalSdkInfo) CustomHash(hasher *proptools.Hasher) error {
	hasher.WriteString(":android.AdditionalSdkInfo")
	hasher.WriteInt(1)
	if err := r.Properties.CustomHash(hasher); err != nil {
		return err
	}
	return nil
}

func (r *AdditionalSdkInfo) Decode(ctx gobtools.EncContext, buf *bytes.Reader) error {
	var err error

	if err = r.Properties.Decode(ctx, buf); err != nil {
		return err
	}

	return err
}

var AdditionalSdkInfoGobRegId int16

func (r AdditionalSdkInfo) GetTypeId() int16 {
	return AdditionalSdkInfoGobRegId
}

func (r AdditionalSdkInfoProperties) Encode(ctx gobtools.EncContext, buf *bytes.Buffer) error {
	var err error

	if r.Nested == nil {
		if err = gobtools.EncodeInt(buf, -1); err != nil {
			return err
		}
	} else {
		if err = gobtools.EncodeInt(buf, len(r.Nested)); err != nil {
			return err
		}
		for val1, val2 := range r.Nested {
			if err = gobtools.EncodeString(buf, val1); err != nil {
				return err
			}
			if err = val2.Encode(ctx, buf); err != nil {
				return err
			}
		}
	}

	if r.Properties == nil {
		if err = gobtools.EncodeInt(buf, -1); err != nil {
			return err
		}
	} else {
		if err = gobtools.EncodeInt(buf, len(r.Properties)); err != nil {
			return err
		}
		for val3, val4 := range r.Properties {
			if err = gobtools.EncodeString(buf, val3); err != nil {
				return err
			}
			if err = gobtools.EncodeString(buf, val4); err != nil {
				return err
			}
		}
	}
	return err
}

func (r AdditionalSdkInfoProperties) CustomHash(hasher *proptools.Hasher) error {
	hasher.WriteString(":android.AdditionalSdkInfoProperties")
	hasher.WriteInt(2)
	hasher.WriteString(":.map[string]AdditionalSdkInfoProperties")
	hasher.WriteInt(len(r.Nested))
	val1 := make([]string, 0, len(r.Nested))
	for val3 := range r.Nested {
		val1 = append(val1, val3)
	}
	proptools.SortOrdered(val1)
	for _, val2 := range val1 {
		hasher.WriteString(":.string")
		hasher.WriteString(val2)
		if err := r.Nested[val2].CustomHash(hasher); err != nil {
			return err
		}
	}
	hasher.WriteString(":.map[string]string")
	hasher.WriteInt(len(r.Properties))
	val4 := make([]string, 0, len(r.Properties))
	for val6 := range r.Properties {
		val4 = append(val4, val6)
	}
	proptools.SortOrdered(val4)
	for _, val5 := range val4 {
		hasher.WriteString(":.string")
		hasher.WriteString(val5)
		hasher.WriteString(":.string")
		hasher.WriteString(r.Properties[val5])
	}
	return nil
}

func (r *AdditionalSdkInfoProperties) 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.Nested = make(map[string]AdditionalSdkInfoProperties, val1)
		for val2 := 0; val2 < int(val1); val2++ {
			var val3 string
			var val4 AdditionalSdkInfoProperties
			err = gobtools.DecodeString(buf, &val3)
			if err != nil {
				return err
			}
			if err = val4.Decode(ctx, buf); err != nil {
				return err
			}
			r.Nested[val3] = val4
		}
	}

	var val7 int
	err = gobtools.DecodeInt(buf, &val7)
	if err != nil {
		return err
	}
	if val7 != -1 {
		r.Properties = make(map[string]string, val7)
		for val8 := 0; val8 < int(val7); val8++ {
			var val9 string
			var val10 string
			err = gobtools.DecodeString(buf, &val9)
			if err != nil {
				return err
			}
			err = gobtools.DecodeString(buf, &val10)
			if err != nil {
				return err
			}
			r.Properties[val9] = val10
		}
	}

	return err
}

var AdditionalSdkInfoPropertiesGobRegId int16

func (r AdditionalSdkInfoProperties) GetTypeId() int16 {
	return AdditionalSdkInfoPropertiesGobRegId
}

// end of sdk.go

// begin of sdk_version.go
func init() {
	SdkSpecGobRegId = gobtools.RegisterType(func() gobtools.CustomDec { return new(SdkSpec) })
}

func (r SdkSpec) Encode(ctx gobtools.EncContext, buf *bytes.Buffer) error {
	var err error

	if err = gobtools.EncodeInt(buf, int(r.Kind)); err != nil {
		return err
	}

	if err = r.ApiLevel.Encode(ctx, buf); err != nil {
		return err
	}

	if err = gobtools.EncodeString(buf, r.Raw); err != nil {
		return err
	}
	return err
}

func (r SdkSpec) CustomHash(hasher *proptools.Hasher) error {
	hasher.WriteString(":android.SdkSpec")
	hasher.WriteInt(3)
	hasher.WriteString(":android.SdkKind")
	hasher.WriteString(":.int")
	hasher.WriteUint64(uint64(int(r.Kind)))
	if err := r.ApiLevel.CustomHash(hasher); err != nil {
		return err
	}
	hasher.WriteString(":.string")
	hasher.WriteString(r.Raw)
	return nil
}

func (r *SdkSpec) 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.Kind = SdkKind(val2)

	if err = r.ApiLevel.Decode(ctx, buf); err != nil {
		return err
	}

	err = gobtools.DecodeString(buf, &r.Raw)
	if err != nil {
		return err
	}

	return err
}

var SdkSpecGobRegId int16

func (r SdkSpec) GetTypeId() int16 {
	return SdkSpecGobRegId
}

// end of sdk_version.go

// begin of symbols.go
func init() {
	SymbolicOutputInfoGobRegId = gobtools.RegisterType(func() gobtools.CustomDec { return new(SymbolicOutputInfo) })
	SymbolicOutputInfosGobRegId = gobtools.RegisterType(func() gobtools.CustomDec { return new(SymbolicOutputInfos) })
}

func (r SymbolicOutputInfo) Encode(ctx gobtools.EncContext, buf *bytes.Buffer) error {
	var err error

	if err = gobtools.EncodeInterface(ctx, buf, r.UnstrippedOutputFile); err != nil {
		return err
	}

	if err = r.SymbolicOutputPath.Encode(ctx, buf); err != nil {
		return err
	}

	if err = r.ElfMappingProtoPath.Encode(ctx, buf); err != nil {
		return err
	}
	return err
}

func (r SymbolicOutputInfo) CustomHash(hasher *proptools.Hasher) error {
	hasher.WriteString(":android.SymbolicOutputInfo")
	hasher.WriteInt(3)
	hasher.WriteString(":android.Path")
	val1 := r.UnstrippedOutputFile == nil
	if val1 {
		hasher.WriteByte(0)
	} else {
		if v := reflect.ValueOf(r.UnstrippedOutputFile); v.Kind() == reflect.Ptr {
			if v.IsNil() {
				panic(fmt.Errorf("nil pointer is not supported in interface"))
			} else {
				val2 := r.UnstrippedOutputFile == nil
				if val2 {
					hasher.WriteByte(0)
				} else {
					val3 := func(hasher *proptools.Hasher) error {
						return r.UnstrippedOutputFile.(proptools.CustomHash).CustomHash(hasher)
					}
					if err := proptools.HashReference(hasher, uintptr(v.Pointer()), val3); err != nil {
						return err
					}
				}
			}
		} else {
			r.UnstrippedOutputFile.(proptools.CustomHash).CustomHash(hasher)
		}
	}
	if err := r.SymbolicOutputPath.CustomHash(hasher); err != nil {
		return err
	}
	if err := r.ElfMappingProtoPath.CustomHash(hasher); err != nil {
		return err
	}
	return nil
}

func (r *SymbolicOutputInfo) 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.UnstrippedOutputFile = nil
	} else {
		r.UnstrippedOutputFile = val2.(Path)
	}

	if err = r.SymbolicOutputPath.Decode(ctx, buf); err != nil {
		return err
	}

	if err = r.ElfMappingProtoPath.Decode(ctx, buf); err != nil {
		return err
	}

	return err
}

var SymbolicOutputInfoGobRegId int16

func (r SymbolicOutputInfo) GetTypeId() int16 {
	return SymbolicOutputInfoGobRegId
}

func (r SymbolicOutputInfos) 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++ {
			val2 := r[val1] == nil
			if err = gobtools.EncodeBool(buf, val2); err != nil {
				return err
			}
			if !val2 {
				if err = (*r[val1]).Encode(ctx, buf); err != nil {
					return err
				}
			}
		}
	}
	return err
}

func (r SymbolicOutputInfos) CustomHash(hasher *proptools.Hasher) error {
	hasher.WriteString(":.[]*SymbolicOutputInfo")
	hasher.WriteInt(len(r))
	for val1 := 0; val1 < len(r); val1++ {
		hasher.WriteString(":.*SymbolicOutputInfo")
		val2 := r[val1] == nil
		if val2 {
			hasher.WriteByte(0)
		} else {
			val3 := func(hasher *proptools.Hasher) error {
				if err := (*r[val1]).CustomHash(hasher); err != nil {
					return err
				}
				return nil
			}
			if err := proptools.HashReference(hasher, uintptr(unsafe.Pointer(r[val1])), val3); err != nil {
				return err
			}
		}
	}
	return nil
}

func (r *SymbolicOutputInfos) 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([]*SymbolicOutputInfo, val2)
		for val3 := 0; val3 < int(val2); val3++ {
			var val5 bool
			if err = gobtools.DecodeBool(buf, &val5); err != nil {
				return err
			}
			if !val5 {
				var val4 SymbolicOutputInfo
				if err = val4.Decode(ctx, buf); err != nil {
					return err
				}
				(*r)[val3] = &val4
			}
		}
	}

	return err
}

var SymbolicOutputInfosGobRegId int16

func (r SymbolicOutputInfos) GetTypeId() int16 {
	return SymbolicOutputInfosGobRegId
}

// end of symbols.go

// begin of team.go
func init() {
	teamPropertiesGobRegId = gobtools.RegisterType(func() gobtools.CustomDec { return new(teamProperties) })
	TeamInfoGobRegId = gobtools.RegisterType(func() gobtools.CustomDec { return new(TeamInfo) })
	TestModuleInformationGobRegId = gobtools.RegisterType(func() gobtools.CustomDec { return new(TestModuleInformation) })
}

func (r teamProperties) Encode(ctx gobtools.EncContext, buf *bytes.Buffer) error {
	var err error

	val1 := r.Trendy_team_id == nil
	if err = gobtools.EncodeBool(buf, val1); err != nil {
		return err
	}
	if !val1 {
		if err = gobtools.EncodeString(buf, (*r.Trendy_team_id)); err != nil {
			return err
		}
	}
	return err
}

func (r teamProperties) CustomHash(hasher *proptools.Hasher) error {
	hasher.WriteString(":android.teamProperties")
	hasher.WriteInt(1)
	hasher.WriteString(":.*string")
	val1 := r.Trendy_team_id == nil
	if val1 {
		hasher.WriteByte(0)
	} else {
		val2 := func(hasher *proptools.Hasher) error {
			hasher.WriteString(":.string")
			hasher.WriteString((*r.Trendy_team_id))
			return nil
		}
		if err := proptools.HashReference(hasher, uintptr(unsafe.Pointer(r.Trendy_team_id)), val2); err != nil {
			return err
		}
	}
	return nil
}

func (r *teamProperties) 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.Trendy_team_id = &val1
	}

	return err
}

var teamPropertiesGobRegId int16

func (r teamProperties) GetTypeId() int16 {
	return teamPropertiesGobRegId
}

func (r TeamInfo) Encode(ctx gobtools.EncContext, buf *bytes.Buffer) error {
	var err error

	if err = r.Properties.Encode(ctx, buf); err != nil {
		return err
	}
	return err
}

func (r TeamInfo) CustomHash(hasher *proptools.Hasher) error {
	hasher.WriteString(":android.TeamInfo")
	hasher.WriteInt(1)
	if err := r.Properties.CustomHash(hasher); err != nil {
		return err
	}
	return nil
}

func (r *TeamInfo) Decode(ctx gobtools.EncContext, buf *bytes.Reader) error {
	var err error

	if err = r.Properties.Decode(ctx, buf); err != nil {
		return err
	}

	return err
}

var TeamInfoGobRegId int16

func (r TeamInfo) GetTypeId() int16 {
	return TeamInfoGobRegId
}

func (r TestModuleInformation) Encode(ctx gobtools.EncContext, buf *bytes.Buffer) error {
	var err error

	if err = gobtools.EncodeBool(buf, r.TestOnly); err != nil {
		return err
	}

	if err = gobtools.EncodeBool(buf, r.TopLevelTarget); err != nil {
		return err
	}
	return err
}

func (r TestModuleInformation) CustomHash(hasher *proptools.Hasher) error {
	hasher.WriteString(":android.TestModuleInformation")
	hasher.WriteInt(2)
	hasher.WriteString(":.bool")
	if r.TestOnly {
		hasher.WriteByte(1)
	} else {
		hasher.WriteByte(0)
	}
	hasher.WriteString(":.bool")
	if r.TopLevelTarget {
		hasher.WriteByte(1)
	} else {
		hasher.WriteByte(0)
	}
	return nil
}

func (r *TestModuleInformation) Decode(ctx gobtools.EncContext, buf *bytes.Reader) error {
	var err error

	err = gobtools.DecodeBool(buf, &r.TestOnly)
	if err != nil {
		return err
	}

	err = gobtools.DecodeBool(buf, &r.TopLevelTarget)
	if err != nil {
		return err
	}

	return err
}

var TestModuleInformationGobRegId int16

func (r TestModuleInformation) GetTypeId() int16 {
	return TestModuleInformationGobRegId
}

// end of team.go

// begin of test_suites.go
func init() {
	TestSuiteInfoGobRegId = gobtools.RegisterType(func() gobtools.CustomDec { return new(TestSuiteInfo) })
	MakeNamesInfoGobRegId = gobtools.RegisterType(func() gobtools.CustomDec { return new(MakeNamesInfo) })
	FilePairGobRegId = gobtools.RegisterType(func() gobtools.CustomDec { return new(FilePair) })
	TestSuiteInstallsInfoGobRegId = gobtools.RegisterType(func() gobtools.CustomDec { return new(TestSuiteInstallsInfo) })
}

func (r TestSuiteInfo) Encode(ctx gobtools.EncContext, buf *bytes.Buffer) error {
	var err error

	if err = gobtools.EncodeString(buf, r.NameSuffix); err != nil {
		return err
	}

	if r.TestSuites == nil {
		if err = gobtools.EncodeInt(buf, -1); err != nil {
			return err
		}
	} else {
		if err = gobtools.EncodeInt(buf, len(r.TestSuites)); err != nil {
			return err
		}
		for val1 := 0; val1 < len(r.TestSuites); val1++ {
			if err = gobtools.EncodeString(buf, r.TestSuites[val1]); err != nil {
				return err
			}
		}
	}

	if err = gobtools.EncodeBool(buf, r.NeedsArchFolder); err != nil {
		return err
	}

	if err = gobtools.EncodeInterface(ctx, buf, r.MainFile); err != nil {
		return err
	}

	if err = gobtools.EncodeString(buf, r.MainFileStem); err != nil {
		return err
	}

	if err = gobtools.EncodeString(buf, r.MainFileExt); err != nil {
		return err
	}

	if err = gobtools.EncodeInterface(ctx, buf, r.ConfigFile); err != nil {
		return err
	}

	if err = gobtools.EncodeString(buf, r.ConfigFileSuffix); err != nil {
		return err
	}

	if r.ExtraConfigs == nil {
		if err = gobtools.EncodeInt(buf, -1); err != nil {
			return err
		}
	} else {
		if err = gobtools.EncodeInt(buf, len(r.ExtraConfigs)); err != nil {
			return err
		}
		for val2 := 0; val2 < len(r.ExtraConfigs); val2++ {
			if err = gobtools.EncodeInterface(ctx, buf, r.ExtraConfigs[val2]); err != nil {
				return err
			}
		}
	}

	if err = gobtools.EncodeBool(buf, r.PerTestcaseDirectory); err != nil {
		return err
	}

	if r.Data == nil {
		if err = gobtools.EncodeInt(buf, -1); err != nil {
			return err
		}
	} else {
		if err = gobtools.EncodeInt(buf, len(r.Data)); err != nil {
			return err
		}
		for val3 := 0; val3 < len(r.Data); val3++ {
			if err = r.Data[val3].Encode(ctx, buf); err != nil {
				return err
			}
		}
	}

	if r.NonArchData == nil {
		if err = gobtools.EncodeInt(buf, -1); err != nil {
			return err
		}
	} else {
		if err = gobtools.EncodeInt(buf, len(r.NonArchData)); err != nil {
			return err
		}
		for val4 := 0; val4 < len(r.NonArchData); val4++ {
			if err = r.NonArchData[val4].Encode(ctx, buf); err != nil {
				return err
			}
		}
	}

	if r.CompatibilitySupportFiles == nil {
		if err = gobtools.EncodeInt(buf, -1); err != nil {
			return err
		}
	} else {
		if err = gobtools.EncodeInt(buf, len(r.CompatibilitySupportFiles)); err != nil {
			return err
		}
		for val5 := 0; val5 < len(r.CompatibilitySupportFiles); val5++ {
			if err = gobtools.EncodeInterface(ctx, buf, r.CompatibilitySupportFiles[val5]); err != nil {
				return err
			}
		}
	}

	if err = gobtools.EncodeBool(buf, r.DisableTestConfig); err != nil {
		return err
	}

	if err = gobtools.EncodeBool(buf, r.IsUnitTest); err != nil {
		return err
	}

	val6 := r.TestSuiteInstalls == nil
	if err = gobtools.EncodeBool(buf, val6); err != nil {
		return err
	}
	if !val6 {
		if err = (*r.TestSuiteInstalls).Encode(ctx, buf); err != nil {
			return err
		}
	}
	return err
}

func (r TestSuiteInfo) CustomHash(hasher *proptools.Hasher) error {
	hasher.WriteString(":android.TestSuiteInfo")
	hasher.WriteInt(16)
	hasher.WriteString(":.string")
	hasher.WriteString(r.NameSuffix)
	hasher.WriteString(":.[]string")
	hasher.WriteInt(len(r.TestSuites))
	for val1 := 0; val1 < len(r.TestSuites); val1++ {
		hasher.WriteString(":.string")
		hasher.WriteString(r.TestSuites[val1])
	}
	hasher.WriteString(":.bool")
	if r.NeedsArchFolder {
		hasher.WriteByte(1)
	} else {
		hasher.WriteByte(0)
	}
	hasher.WriteString(":android.Path")
	val2 := r.MainFile == nil
	if val2 {
		hasher.WriteByte(0)
	} else {
		if v := reflect.ValueOf(r.MainFile); v.Kind() == reflect.Ptr {
			if v.IsNil() {
				panic(fmt.Errorf("nil pointer is not supported in interface"))
			} else {
				val3 := r.MainFile == nil
				if val3 {
					hasher.WriteByte(0)
				} else {
					val4 := func(hasher *proptools.Hasher) error { return r.MainFile.(proptools.CustomHash).CustomHash(hasher) }
					if err := proptools.HashReference(hasher, uintptr(v.Pointer()), val4); err != nil {
						return err
					}
				}
			}
		} else {
			r.MainFile.(proptools.CustomHash).CustomHash(hasher)
		}
	}
	hasher.WriteString(":.string")
	hasher.WriteString(r.MainFileStem)
	hasher.WriteString(":.string")
	hasher.WriteString(r.MainFileExt)
	hasher.WriteString(":android.Path")
	val5 := r.ConfigFile == nil
	if val5 {
		hasher.WriteByte(0)
	} else {
		if v := reflect.ValueOf(r.ConfigFile); v.Kind() == reflect.Ptr {
			if v.IsNil() {
				panic(fmt.Errorf("nil pointer is not supported in interface"))
			} else {
				val6 := r.ConfigFile == nil
				if val6 {
					hasher.WriteByte(0)
				} else {
					val7 := func(hasher *proptools.Hasher) error { return r.ConfigFile.(proptools.CustomHash).CustomHash(hasher) }
					if err := proptools.HashReference(hasher, uintptr(v.Pointer()), val7); err != nil {
						return err
					}
				}
			}
		} else {
			r.ConfigFile.(proptools.CustomHash).CustomHash(hasher)
		}
	}
	hasher.WriteString(":.string")
	hasher.WriteString(r.ConfigFileSuffix)
	hasher.WriteString(":android.Paths")
	hasher.WriteString(":.[]Path")
	hasher.WriteInt(len(r.ExtraConfigs))
	for val8 := 0; val8 < len(r.ExtraConfigs); val8++ {
		hasher.WriteString(":android.Path")
		val9 := r.ExtraConfigs[val8] == nil
		if val9 {
			hasher.WriteByte(0)
		} else {
			if v := reflect.ValueOf(r.ExtraConfigs[val8]); v.Kind() == reflect.Ptr {
				if v.IsNil() {
					panic(fmt.Errorf("nil pointer is not supported in interface"))
				} else {
					val10 := r.ExtraConfigs[val8] == nil
					if val10 {
						hasher.WriteByte(0)
					} else {
						val11 := func(hasher *proptools.Hasher) error {
							return r.ExtraConfigs[val8].(proptools.CustomHash).CustomHash(hasher)
						}
						if err := proptools.HashReference(hasher, uintptr(v.Pointer()), val11); err != nil {
							return err
						}
					}
				}
			} else {
				r.ExtraConfigs[val8].(proptools.CustomHash).CustomHash(hasher)
			}
		}
	}
	hasher.WriteString(":.bool")
	if r.PerTestcaseDirectory {
		hasher.WriteByte(1)
	} else {
		hasher.WriteByte(0)
	}
	hasher.WriteString(":.[]DataPath")
	hasher.WriteInt(len(r.Data))
	for val12 := 0; val12 < len(r.Data); val12++ {
		if err := r.Data[val12].CustomHash(hasher); err != nil {
			return err
		}
	}
	hasher.WriteString(":.[]DataPath")
	hasher.WriteInt(len(r.NonArchData))
	for val13 := 0; val13 < len(r.NonArchData); val13++ {
		if err := r.NonArchData[val13].CustomHash(hasher); err != nil {
			return err
		}
	}
	hasher.WriteString(":.[]Path")
	hasher.WriteInt(len(r.CompatibilitySupportFiles))
	for val14 := 0; val14 < len(r.CompatibilitySupportFiles); val14++ {
		hasher.WriteString(":android.Path")
		val15 := r.CompatibilitySupportFiles[val14] == nil
		if val15 {
			hasher.WriteByte(0)
		} else {
			if v := reflect.ValueOf(r.CompatibilitySupportFiles[val14]); v.Kind() == reflect.Ptr {
				if v.IsNil() {
					panic(fmt.Errorf("nil pointer is not supported in interface"))
				} else {
					val16 := r.CompatibilitySupportFiles[val14] == nil
					if val16 {
						hasher.WriteByte(0)
					} else {
						val17 := func(hasher *proptools.Hasher) error {
							return r.CompatibilitySupportFiles[val14].(proptools.CustomHash).CustomHash(hasher)
						}
						if err := proptools.HashReference(hasher, uintptr(v.Pointer()), val17); err != nil {
							return err
						}
					}
				}
			} else {
				r.CompatibilitySupportFiles[val14].(proptools.CustomHash).CustomHash(hasher)
			}
		}
	}
	hasher.WriteString(":.bool")
	if r.DisableTestConfig {
		hasher.WriteByte(1)
	} else {
		hasher.WriteByte(0)
	}
	hasher.WriteString(":.bool")
	if r.IsUnitTest {
		hasher.WriteByte(1)
	} else {
		hasher.WriteByte(0)
	}
	hasher.WriteString(":.*TestSuiteInstallsInfo")
	val18 := r.TestSuiteInstalls == nil
	if val18 {
		hasher.WriteByte(0)
	} else {
		val19 := func(hasher *proptools.Hasher) error {
			if err := (*r.TestSuiteInstalls).CustomHash(hasher); err != nil {
				return err
			}
			return nil
		}
		if err := proptools.HashReference(hasher, uintptr(unsafe.Pointer(r.TestSuiteInstalls)), val19); err != nil {
			return err
		}
	}
	return nil
}

func (r *TestSuiteInfo) Decode(ctx gobtools.EncContext, buf *bytes.Reader) error {
	var err error

	err = gobtools.DecodeString(buf, &r.NameSuffix)
	if err != nil {
		return err
	}

	var val3 int
	err = gobtools.DecodeInt(buf, &val3)
	if err != nil {
		return err
	}
	if val3 != -1 {
		r.TestSuites = make([]string, val3)
		for val4 := 0; val4 < int(val3); val4++ {
			err = gobtools.DecodeString(buf, &r.TestSuites[val4])
			if err != nil {
				return err
			}
		}
	}

	err = gobtools.DecodeBool(buf, &r.NeedsArchFolder)
	if err != nil {
		return err
	}

	if val8, err := gobtools.DecodeInterface(ctx, buf); err != nil {
		return err
	} else if val8 == nil {
		r.MainFile = nil
	} else {
		r.MainFile = val8.(Path)
	}

	err = gobtools.DecodeString(buf, &r.MainFileStem)
	if err != nil {
		return err
	}

	err = gobtools.DecodeString(buf, &r.MainFileExt)
	if err != nil {
		return err
	}

	if val12, err := gobtools.DecodeInterface(ctx, buf); err != nil {
		return err
	} else if val12 == nil {
		r.ConfigFile = nil
	} else {
		r.ConfigFile = val12.(Path)
	}

	err = gobtools.DecodeString(buf, &r.ConfigFileSuffix)
	if err != nil {
		return err
	}

	var val16 int
	err = gobtools.DecodeInt(buf, &val16)
	if err != nil {
		return err
	}
	if val16 != -1 {
		r.ExtraConfigs = make([]Path, val16)
		for val17 := 0; val17 < int(val16); val17++ {
			if val19, err := gobtools.DecodeInterface(ctx, buf); err != nil {
				return err
			} else if val19 == nil {
				r.ExtraConfigs[val17] = nil
			} else {
				r.ExtraConfigs[val17] = val19.(Path)
			}
		}
	}

	err = gobtools.DecodeBool(buf, &r.PerTestcaseDirectory)
	if err != nil {
		return err
	}

	var val22 int
	err = gobtools.DecodeInt(buf, &val22)
	if err != nil {
		return err
	}
	if val22 != -1 {
		r.Data = make([]DataPath, val22)
		for val23 := 0; val23 < int(val22); val23++ {
			if err = r.Data[val23].Decode(ctx, buf); err != nil {
				return err
			}
		}
	}

	var val26 int
	err = gobtools.DecodeInt(buf, &val26)
	if err != nil {
		return err
	}
	if val26 != -1 {
		r.NonArchData = make([]DataPath, val26)
		for val27 := 0; val27 < int(val26); val27++ {
			if err = r.NonArchData[val27].Decode(ctx, buf); err != nil {
				return err
			}
		}
	}

	var val30 int
	err = gobtools.DecodeInt(buf, &val30)
	if err != nil {
		return err
	}
	if val30 != -1 {
		r.CompatibilitySupportFiles = make([]Path, val30)
		for val31 := 0; val31 < int(val30); val31++ {
			if val33, err := gobtools.DecodeInterface(ctx, buf); err != nil {
				return err
			} else if val33 == nil {
				r.CompatibilitySupportFiles[val31] = nil
			} else {
				r.CompatibilitySupportFiles[val31] = val33.(Path)
			}
		}
	}

	err = gobtools.DecodeBool(buf, &r.DisableTestConfig)
	if err != nil {
		return err
	}

	err = gobtools.DecodeBool(buf, &r.IsUnitTest)
	if err != nil {
		return err
	}

	var val37 bool
	if err = gobtools.DecodeBool(buf, &val37); err != nil {
		return err
	}
	if !val37 {
		var val36 TestSuiteInstallsInfo
		if err = val36.Decode(ctx, buf); err != nil {
			return err
		}
		r.TestSuiteInstalls = &val36
	}

	return err
}

var TestSuiteInfoGobRegId int16

func (r TestSuiteInfo) GetTypeId() int16 {
	return TestSuiteInfoGobRegId
}

func (r MakeNamesInfo) Encode(ctx gobtools.EncContext, buf *bytes.Buffer) error {
	var err error

	if err = gobtools.EncodeString(buf, r.MakeName); err != nil {
		return err
	}

	if r.SharedLibsMakeNames == nil {
		if err = gobtools.EncodeInt(buf, -1); err != nil {
			return err
		}
	} else {
		if err = gobtools.EncodeInt(buf, len(r.SharedLibsMakeNames)); err != nil {
			return err
		}
		for val1 := 0; val1 < len(r.SharedLibsMakeNames); val1++ {
			if err = gobtools.EncodeString(buf, r.SharedLibsMakeNames[val1]); err != nil {
				return err
			}
		}
	}
	return err
}

func (r MakeNamesInfo) CustomHash(hasher *proptools.Hasher) error {
	hasher.WriteString(":android.MakeNamesInfo")
	hasher.WriteInt(2)
	hasher.WriteString(":.string")
	hasher.WriteString(r.MakeName)
	hasher.WriteString(":.[]string")
	hasher.WriteInt(len(r.SharedLibsMakeNames))
	for val1 := 0; val1 < len(r.SharedLibsMakeNames); val1++ {
		hasher.WriteString(":.string")
		hasher.WriteString(r.SharedLibsMakeNames[val1])
	}
	return nil
}

func (r *MakeNamesInfo) Decode(ctx gobtools.EncContext, buf *bytes.Reader) error {
	var err error

	err = gobtools.DecodeString(buf, &r.MakeName)
	if err != nil {
		return err
	}

	var val3 int
	err = gobtools.DecodeInt(buf, &val3)
	if err != nil {
		return err
	}
	if val3 != -1 {
		r.SharedLibsMakeNames = make([]string, val3)
		for val4 := 0; val4 < int(val3); val4++ {
			err = gobtools.DecodeString(buf, &r.SharedLibsMakeNames[val4])
			if err != nil {
				return err
			}
		}
	}

	return err
}

var MakeNamesInfoGobRegId int16

func (r MakeNamesInfo) GetTypeId() int16 {
	return MakeNamesInfoGobRegId
}

func (r FilePair) Encode(ctx gobtools.EncContext, buf *bytes.Buffer) error {
	var err error

	if err = gobtools.EncodeInterface(ctx, buf, r.Src); err != nil {
		return err
	}

	if err = gobtools.EncodeInterface(ctx, buf, r.Dst); err != nil {
		return err
	}
	return err
}

func (r FilePair) CustomHash(hasher *proptools.Hasher) error {
	hasher.WriteString(":android.FilePair")
	hasher.WriteInt(2)
	hasher.WriteString(":android.Path")
	val1 := r.Src == nil
	if val1 {
		hasher.WriteByte(0)
	} else {
		if v := reflect.ValueOf(r.Src); v.Kind() == reflect.Ptr {
			if v.IsNil() {
				panic(fmt.Errorf("nil pointer is not supported in interface"))
			} else {
				val2 := r.Src == nil
				if val2 {
					hasher.WriteByte(0)
				} else {
					val3 := func(hasher *proptools.Hasher) error { return r.Src.(proptools.CustomHash).CustomHash(hasher) }
					if err := proptools.HashReference(hasher, uintptr(v.Pointer()), val3); err != nil {
						return err
					}
				}
			}
		} else {
			r.Src.(proptools.CustomHash).CustomHash(hasher)
		}
	}
	hasher.WriteString(":android.WritablePath")
	val4 := r.Dst == nil
	if val4 {
		hasher.WriteByte(0)
	} else {
		if v := reflect.ValueOf(r.Dst); v.Kind() == reflect.Ptr {
			if v.IsNil() {
				panic(fmt.Errorf("nil pointer is not supported in interface"))
			} else {
				val5 := r.Dst == nil
				if val5 {
					hasher.WriteByte(0)
				} else {
					val6 := func(hasher *proptools.Hasher) error { return r.Dst.(proptools.CustomHash).CustomHash(hasher) }
					if err := proptools.HashReference(hasher, uintptr(v.Pointer()), val6); err != nil {
						return err
					}
				}
			}
		} else {
			r.Dst.(proptools.CustomHash).CustomHash(hasher)
		}
	}
	return nil
}

func (r *FilePair) Decode(ctx gobtools.EncContext, buf *bytes.Reader) error {
	var err error

	if val2, err := gobtools.DecodeInterface(ctx, buf); err != nil {
		return err
	} else if val2 == nil {
		r.Src = nil
	} else {
		r.Src = val2.(Path)
	}

	if val4, err := gobtools.DecodeInterface(ctx, buf); err != nil {
		return err
	} else if val4 == nil {
		r.Dst = nil
	} else {
		r.Dst = val4.(WritablePath)
	}

	return err
}

var FilePairGobRegId int16

func (r FilePair) GetTypeId() int16 {
	return FilePairGobRegId
}

func (r TestSuiteInstallsInfo) Encode(ctx gobtools.EncContext, buf *bytes.Buffer) error {
	var err error

	if r.Files == nil {
		if err = gobtools.EncodeInt(buf, -1); err != nil {
			return err
		}
	} else {
		if err = gobtools.EncodeInt(buf, len(r.Files)); err != nil {
			return err
		}
		for val1 := 0; val1 < len(r.Files); val1++ {
			if err = r.Files[val1].Encode(ctx, buf); err != nil {
				return err
			}
		}
	}

	if r.OneVariantInstalls == nil {
		if err = gobtools.EncodeInt(buf, -1); err != nil {
			return err
		}
	} else {
		if err = gobtools.EncodeInt(buf, len(r.OneVariantInstalls)); err != nil {
			return err
		}
		for val2 := 0; val2 < len(r.OneVariantInstalls); val2++ {
			if err = r.OneVariantInstalls[val2].Encode(ctx, buf); err != nil {
				return err
			}
		}
	}
	return err
}

func (r TestSuiteInstallsInfo) CustomHash(hasher *proptools.Hasher) error {
	hasher.WriteString(":android.TestSuiteInstallsInfo")
	hasher.WriteInt(2)
	hasher.WriteString(":.[]FilePair")
	hasher.WriteInt(len(r.Files))
	for val1 := 0; val1 < len(r.Files); val1++ {
		if err := r.Files[val1].CustomHash(hasher); err != nil {
			return err
		}
	}
	hasher.WriteString(":.[]FilePair")
	hasher.WriteInt(len(r.OneVariantInstalls))
	for val2 := 0; val2 < len(r.OneVariantInstalls); val2++ {
		if err := r.OneVariantInstalls[val2].CustomHash(hasher); err != nil {
			return err
		}
	}
	return nil
}

func (r *TestSuiteInstallsInfo) 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.Files = make([]FilePair, val2)
		for val3 := 0; val3 < int(val2); val3++ {
			if err = r.Files[val3].Decode(ctx, buf); err != nil {
				return err
			}
		}
	}

	var val6 int
	err = gobtools.DecodeInt(buf, &val6)
	if err != nil {
		return err
	}
	if val6 != -1 {
		r.OneVariantInstalls = make([]FilePair, val6)
		for val7 := 0; val7 < int(val6); val7++ {
			if err = r.OneVariantInstalls[val7].Decode(ctx, buf); err != nil {
				return err
			}
		}
	}

	return err
}

var TestSuiteInstallsInfoGobRegId int16

func (r TestSuiteInstallsInfo) GetTypeId() int16 {
	return TestSuiteInstallsInfoGobRegId
}

// end of test_suites.go

// begin of transition.go
func init() {
	variationTransitionInfoGobRegId = gobtools.RegisterType(func() gobtools.CustomDec { return new(variationTransitionInfo) })
}

func (r variationTransitionInfo) Encode(ctx gobtools.EncContext, buf *bytes.Buffer) error {
	var err error

	if err = gobtools.EncodeString(buf, r.variation); err != nil {
		return err
	}
	return err
}

func (r variationTransitionInfo) CustomHash(hasher *proptools.Hasher) error {
	hasher.WriteString(":android.variationTransitionInfo")
	hasher.WriteInt(1)
	hasher.WriteString(":.string")
	hasher.WriteString(r.variation)
	return nil
}

func (r *variationTransitionInfo) Decode(ctx gobtools.EncContext, buf *bytes.Reader) error {
	var err error

	err = gobtools.DecodeString(buf, &r.variation)
	if err != nil {
		return err
	}

	return err
}

var variationTransitionInfoGobRegId int16

func (r variationTransitionInfo) GetTypeId() int16 {
	return variationTransitionInfoGobRegId
}

// end of transition.go

// begin of vintf_fragment.go
func init() {
	VintfFragmentInfoGobRegId = gobtools.RegisterType(func() gobtools.CustomDec { return new(VintfFragmentInfo) })
}

func (r VintfFragmentInfo) Encode(ctx gobtools.EncContext, buf *bytes.Buffer) error {
	var err error

	if err = gobtools.EncodeInterface(ctx, buf, r.OutputFile); err != nil {
		return err
	}
	return err
}

func (r VintfFragmentInfo) CustomHash(hasher *proptools.Hasher) error {
	hasher.WriteString(":android.VintfFragmentInfo")
	hasher.WriteInt(1)
	hasher.WriteString(":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)
		}
	}
	return nil
}

func (r *VintfFragmentInfo) 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.(Path)
	}

	return err
}

var VintfFragmentInfoGobRegId int16

func (r VintfFragmentInfo) GetTypeId() int16 {
	return VintfFragmentInfoGobRegId
}

// end of vintf_fragment.go

// begin of visibility.go
func init() {
	PartitionTypeInfoGobRegId = gobtools.RegisterType(func() gobtools.CustomDec { return new(PartitionTypeInfo) })
}

func (r PartitionTypeInfo) Encode(ctx gobtools.EncContext, buf *bytes.Buffer) error {
	var err error

	if err = gobtools.EncodeString(buf, r.PartitionType); err != nil {
		return err
	}
	return err
}

func (r PartitionTypeInfo) CustomHash(hasher *proptools.Hasher) error {
	hasher.WriteString(":android.PartitionTypeInfo")
	hasher.WriteInt(1)
	hasher.WriteString(":.string")
	hasher.WriteString(r.PartitionType)
	return nil
}

func (r *PartitionTypeInfo) Decode(ctx gobtools.EncContext, buf *bytes.Reader) error {
	var err error

	err = gobtools.DecodeString(buf, &r.PartitionType)
	if err != nil {
		return err
	}

	return err
}

var PartitionTypeInfoGobRegId int16

func (r PartitionTypeInfo) GetTypeId() int16 {
	return PartitionTypeInfoGobRegId
}

// end of visibility.go