// 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