Quellcode-Bibliothek java_enc.go   Sprache: unbekannt

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

package java

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

 return err
}

var resourcesNodeGobRegId int16

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

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

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

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

 return err
}

var AndroidLibraryInfoGobRegId int16

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

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

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

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

 return err
}

var AARImportInfoGobRegId int16

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

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

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

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

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

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

 return err
}

var JniPackageInfoGobRegId int16

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

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

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

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

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

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

 return err
}

var AARImportDepInSameApexCheckerGobRegId int16

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

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

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

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

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

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

 return err
}

var AARInfoGobRegId int16

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

// end of aar.go

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

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

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

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

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

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

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

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

 return err
}

var rroDirGobRegId int16

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

// end of android_resources.go

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

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

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

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

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

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

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

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

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

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

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

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

 return err
}

var ApkCertInfoGobRegId int16

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

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

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

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

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

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

 return err
}

var ApkCertsInfoGobRegId int16

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

// end of apkcerts.go

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

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

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

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

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

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

 return err
}

var FlagsPackagesGobRegId int16

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

 return err
}

var AppInfoGobRegId int16

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

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

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

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

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

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

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

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

 return err
}

var CertificateGobRegId int16

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

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

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

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

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

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

 return err
}

var AppDepInSameApexCheckerGobRegId int16

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

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

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

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

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

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

 return err
}

var AndroidAppCertificateInfoGobRegId int16

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

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

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

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

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

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

 return err
}

var BundleInfoGobRegId int16

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

// end of app.go

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

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

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

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

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

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

 return err
}

var AppImportDepInSameApexCheckerGobRegId int16

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

// end of app_import.go

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

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

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

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

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

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

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

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

 return err
}

var OptionalDexJarPathGobRegId int16

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

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

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

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

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

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

 return err
}

var JavaDepInSameApexCheckerGobRegId int16

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

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

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

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

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

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

 return err
}

var JarJarProviderDataGobRegId int16

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

// end of base.go

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

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

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

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

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

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

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

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

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

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

 return err
}

var ApexVariantReferenceGobRegId int16

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

// end of bootclasspath.go

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

 return err
}

var BootclasspathFragmentInfoGobRegId int16

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

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

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

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

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

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

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

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

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

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

 return err
}

var BootclasspathFragmentApexContentInfoGobRegId int16

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

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

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

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

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

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

 return err
}

var BootclasspathFragmentDepInSameApexCheckerGobRegId int16

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

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

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

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

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

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

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

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

 return err
}

var ClasspathFragmentValidationInfoGobRegId int16

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

// end of bootclasspath_fragment.go

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

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

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

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

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

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

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

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

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

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

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

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

 return err
}

var ClasspathFragmentProtoContentInfoGobRegId int16

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

// end of classpath_fragment.go

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

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

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

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

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

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

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

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

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

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

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

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

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

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

 return err
}

var ProguardInfoGobRegId int16

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

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

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

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

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

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

 return err
}

var ProguardInfosGobRegId int16

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

// end of dex.go

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

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

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

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

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

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

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

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

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

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

 return err
}

var DexpreopterInstallGobRegId int16

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

// end of dexpreopt.go

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

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

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

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

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

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

 return err
}

var artBootImageHostInfoGobRegId int16

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

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

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

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

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

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

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

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

 return err
}

var profileInstallInfoGobRegId int16

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

// end of dexpreopt_bootjars.go

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

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

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

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

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

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

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

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

 return err
}

var ExportedDroiddocDirInfoGobRegId int16

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

// end of droiddoc.go

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

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

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

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

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

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

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

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

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

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

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

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

 return err
}

var StubsInfoGobRegId int16

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

 return err
}

var DroidStubsInfoGobRegId int16

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

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

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

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

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

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

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

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

 return err
}

var StubsSrcInfoGobRegId int16

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

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

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

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

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

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

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

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

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

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

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

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

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

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

 return err
}

var UpdateApiInfoGobRegId int16

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

// end of droidstubs.go

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

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

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

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

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

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

 return err
}

var JavaFuzzTestInfoGobRegId int16

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

// end of fuzz.go

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

 return err
}

var HiddenAPIScopeGobRegId int16

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

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

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

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

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

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

 return err
}

var FlagFilesByCategoryGobRegId int16

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

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

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

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

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

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

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

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

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

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

 return err
}

var HiddenAPIInfoGobRegId int16

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

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

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

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

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

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

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

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

 return err
}

var HiddenAPIInfoForSdkGobRegId int16

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

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

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

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

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

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

 return err
}

var ModuleStubDexJarsGobRegId int16

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

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

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

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

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

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

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

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

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

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

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

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

 return err
}

var HiddenAPIPropertyInfoGobRegId int16

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

 return err
}

var HiddenAPIFlagOutputGobRegId int16

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

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

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

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

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

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

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

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

 return err
}

var SignatureCsvSubsetGobRegId int16

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

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

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

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

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

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

 return err
}

var SignatureCsvSubsetsGobRegId int16

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

// end of hiddenapi_modular.go

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

 return err
}

var MonolithicHiddenAPIInfoGobRegId int16

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

// end of hiddenapi_monolithic.go

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

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

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

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

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

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

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

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

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

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

 return err
}

var JacocoInfoGobRegId int16

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

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

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

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

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

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

 return err
}

var JacocoInfosGobRegId int16

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

// end of jacoco.go

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

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

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

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

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

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

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

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

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

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

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

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

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

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

 return err
}

var ProguardSpecInfoGobRegId int16

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

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

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

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

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

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

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

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

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

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

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

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

 return err
}

var AndroidLibraryDependencyInfoGobRegId int16

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

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

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

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

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

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

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

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

 return err
}

var UsesLibraryDependencyInfoGobRegId int16

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

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

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

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

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

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

 return err
}

var ProvidesUsesLibInfoGobRegId int16

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

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

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

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

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

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

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

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

 return err
}

var ModuleWithSdkDepInfoGobRegId int16

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

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

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

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

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

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

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

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

 return err
}

var ApexDependencyInfoGobRegId int16

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

 return err
}

var JavaInfoGobRegId int16

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

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

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

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

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

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

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

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

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

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

 return err
}

var DexpreopterInfoGobRegId int16

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

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

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

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

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

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

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

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

 return err
}

var JavaLibraryInfoGobRegId int16

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

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

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

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

 return err
}

var JavaDexImportInfoGobRegId int16

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

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

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

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

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

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

 return err
}

var SyspropPublicStubInfoGobRegId int16

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

 return err
}

var jniLibGobRegId int16

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

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

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

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

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

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

 return err
}

var JavaTestInfoGobRegId int16

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

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

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

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

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

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

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

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

 return err
}

var JavaApiImportInfoGobRegId int16

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

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

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

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

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

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

 return err
}

var JavaImportDepInSameApexCheckerGobRegId int16

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

// end of java.go

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

 return err
}

var LintInfoGobRegId int16

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

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

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

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

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

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

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

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

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

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

 return err
}

var ModuleLintReportZipsInfoGobRegId int16

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

// end of lint.go

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

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

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

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

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

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

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

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

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

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

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

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

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

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

 return err
}

var PlatformCompatConfigInfoGobRegId int16

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

// end of platform_compat_config.go

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

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

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

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

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

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

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

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

 return err
}

var JavaPluginInfoGobRegId int16

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

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

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

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

 return err
}

var KotlinPluginInfoGobRegId int16

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

// end of plugin.go

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

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

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

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

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

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

 return err
}

var ravenwoodLibgroupJniDepProviderInfoGobRegId int16

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

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

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

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

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

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

 return err
}

var ravenwoodLibgroupInfoGobRegId int16

func (r ravenwoodLibgroupInfo) GetTypeId() int16 {
 return ravenwoodLibgroupInfoGobRegId
}

// end of ravenwood.go

// begin of robolectric.go
func init() {
 RobolectricRuntimesInfoGobRegId = gobtools.RegisterType(func() gobtools.CustomDec { return new(RobolectricRuntimesInfo) })
}

func (r RobolectricRuntimesInfo) Encode(ctx gobtools.EncContext, buf *bytes.Buffer) error {
 var err error

 if r.Runtimes == nil {
  if err = gobtools.EncodeInt(buf, -1); err != nil {
   return err
  }
 } else {
  if err = gobtools.EncodeInt(buf, len(r.Runtimes)); err != nil {
   return err
  }
  for val1 := 0; val1 < len(r.Runtimes); val1++ {
   if err = r.Runtimes[val1].Encode(ctx, buf); err != nil {
    return err
   }
  }
 }
 return err
}

func (r RobolectricRuntimesInfo) CustomHash(hasher *proptools.Hasher) error {
 hasher.WriteString(":java.RobolectricRuntimesInfo")
 hasher.WriteInt(1)
 hasher.WriteString(":.[]android.InstallPath")
 hasher.WriteInt(len(r.Runtimes))
 for val1 := 0; val1 < len(r.Runtimes); val1++ {
  if err := r.Runtimes[val1].CustomHash(hasher); err != nil {
   return err
  }
 }
 return nil
}

func (r *RobolectricRuntimesInfo) Decode(ctx gobtools.EncContext, buf *bytes.Reader) error {
 var err error

 var val2 int
 err = gobtools.DecodeInt(buf, &val2)
 if err != nil {
  return err
 }
 if val2 != -1 {
  r.Runtimes = make([]android.InstallPath, val2)
  for val3 := 0; val3 < int(val2); val3++ {
   if err = r.Runtimes[val3].Decode(ctx, buf); err != nil {
    return err
   }
  }
 }

 return err
}

var RobolectricRuntimesInfoGobRegId int16

func (r RobolectricRuntimesInfo) GetTypeId() int16 {
 return RobolectricRuntimesInfoGobRegId
}

// end of robolectric.go

// begin of rro.go
func init() {
 RuntimeResourceOverlayInfoGobRegId = gobtools.RegisterType(func() gobtools.CustomDec { return new(RuntimeResourceOverlayInfo) })
}

func (r RuntimeResourceOverlayInfo) Encode(ctx gobtools.EncContext, buf *bytes.Buffer) error {
 var err error

 if err = gobtools.EncodeInterface(ctx, buf, r.OutputFile); err != nil {
  return err
 }

 if err = r.Certificate.Encode(ctx, buf); err != nil {
  return err
 }

 if err = gobtools.EncodeString(buf, r.Theme); err != nil {
  return err
 }

 if err = gobtools.EncodeString(buf, r.OverriddenManifestPackageName); err != nil {
  return err
 }
 return err
}

func (r RuntimeResourceOverlayInfo) CustomHash(hasher *proptools.Hasher) error {
 hasher.WriteString(":java.RuntimeResourceOverlayInfo")
 hasher.WriteInt(4)
 hasher.WriteString(":java.android.Path")
 val1 := r.OutputFile == nil
 if val1 {
  hasher.WriteByte(0)
 } else {
  if v := reflect.ValueOf(r.OutputFile); v.Kind() == reflect.Ptr {
   if v.IsNil() {
    panic(fmt.Errorf("nil pointer is not supported in interface"))
   } else {
    val2 := r.OutputFile == nil
    if val2 {
     hasher.WriteByte(0)
    } else {
     val3 := func(hasher *proptools.Hasher) error { return r.OutputFile.(proptools.CustomHash).CustomHash(hasher) }
     if err := proptools.HashReference(hasher, uintptr(v.Pointer()), val3); err != nil {
      return err
     }
    }
   }
  } else {
   r.OutputFile.(proptools.CustomHash).CustomHash(hasher)
  }
 }
 if err := r.Certificate.CustomHash(hasher); err != nil {
  return err
 }
 hasher.WriteString(":.string")
 hasher.WriteString(r.Theme)
 hasher.WriteString(":.string")
 hasher.WriteString(r.OverriddenManifestPackageName)
 return nil
}

func (r *RuntimeResourceOverlayInfo) Decode(ctx gobtools.EncContext, buf *bytes.Reader) error {
 var err error

 if val2, err := gobtools.DecodeInterface(ctx, buf); err != nil {
  return err
 } else if val2 == nil {
  r.OutputFile = nil
 } else {
  r.OutputFile = val2.(android.Path)
 }

 if err = r.Certificate.Decode(ctx, buf); err != nil {
  return err
 }

 err = gobtools.DecodeString(buf, &r.Theme)
 if err != nil {
  return err
 }

 err = gobtools.DecodeString(buf, &r.OverriddenManifestPackageName)
 if err != nil {
  return err
 }

 return err
}

var RuntimeResourceOverlayInfoGobRegId int16

func (r RuntimeResourceOverlayInfo) GetTypeId() int16 {
 return RuntimeResourceOverlayInfoGobRegId
}

// end of rro.go

// begin of sdk_library.go
func init() {
 SdkLibraryComponentDependencyInfoGobRegId = gobtools.RegisterType(func() gobtools.CustomDec { return new(SdkLibraryComponentDependencyInfo) })
 ApiScopePathsInfoGobRegId = gobtools.RegisterType(func() gobtools.CustomDec { return new(ApiScopePathsInfo) })
 ApiScopePropsInfoGobRegId = gobtools.RegisterType(func() gobtools.CustomDec { return new(ApiScopePropsInfo) })
 SdkLibraryInfoGobRegId = gobtools.RegisterType(func() gobtools.CustomDec { return new(SdkLibraryInfo) })
 SdkLibraryDepInSameApexCheckerGobRegId = gobtools.RegisterType(func() gobtools.CustomDec { return new(SdkLibraryDepInSameApexChecker) })
 SdkLibraryImportDepIsInSameApexCheckerGobRegId = gobtools.RegisterType(func() gobtools.CustomDec { return new(SdkLibraryImportDepIsInSameApexChecker) })
}

func (r SdkLibraryComponentDependencyInfo) Encode(ctx gobtools.EncContext, buf *bytes.Buffer) error {
 var err error

 val1 := r.OptionalSdkLibraryImplementation == nil
 if err = gobtools.EncodeBool(buf, val1); err != nil {
  return err
 }
 if !val1 {
  if err = gobtools.EncodeString(buf, (*r.OptionalSdkLibraryImplementation)); err != nil {
   return err
  }
 }

 val2 := r.SdkLibraryName == nil
 if err = gobtools.EncodeBool(buf, val2); err != nil {
  return err
 }
 if !val2 {
  if err = gobtools.EncodeString(buf, (*r.SdkLibraryName)); err != nil {
   return err
  }
 }
 return err
}

func (r SdkLibraryComponentDependencyInfo) CustomHash(hasher *proptools.Hasher) error {
 hasher.WriteString(":java.SdkLibraryComponentDependencyInfo")
 hasher.WriteInt(2)
 hasher.WriteString(":.*string")
 val1 := r.OptionalSdkLibraryImplementation == nil
 if val1 {
  hasher.WriteByte(0)
 } else {
  val2 := func(hasher *proptools.Hasher) error {
   hasher.WriteString(":.string")
   hasher.WriteString((*r.OptionalSdkLibraryImplementation))
   return nil
  }
  if err := proptools.HashReference(hasher, uintptr(unsafe.Pointer(r.OptionalSdkLibraryImplementation)), val2); err != nil {
   return err
  }
 }
 hasher.WriteString(":.*string")
 val3 := r.SdkLibraryName == nil
 if val3 {
  hasher.WriteByte(0)
 } else {
  val4 := func(hasher *proptools.Hasher) error {
   hasher.WriteString(":.string")
   hasher.WriteString((*r.SdkLibraryName))
   return nil
  }
  if err := proptools.HashReference(hasher, uintptr(unsafe.Pointer(r.SdkLibraryName)), val4); err != nil {
   return err
  }
 }
 return nil
}

func (r *SdkLibraryComponentDependencyInfo) Decode(ctx gobtools.EncContext, buf *bytes.Reader) error {
 var err error

 var val2 bool
 if err = gobtools.DecodeBool(buf, &val2); err != nil {
  return err
 }
 if !val2 {
  var val1 string
  err = gobtools.DecodeString(buf, &val1)
  if err != nil {
   return err
  }
  r.OptionalSdkLibraryImplementation = &val1
 }

 var val5 bool
 if err = gobtools.DecodeBool(buf, &val5); err != nil {
  return err
 }
 if !val5 {
  var val4 string
  err = gobtools.DecodeString(buf, &val4)
  if err != nil {
   return err
  }
  r.SdkLibraryName = &val4
 }

 return err
}

var SdkLibraryComponentDependencyInfoGobRegId int16

func (r SdkLibraryComponentDependencyInfo) GetTypeId() int16 {
 return SdkLibraryComponentDependencyInfoGobRegId
}

func (r ApiScopePathsInfo) Encode(ctx gobtools.EncContext, buf *bytes.Buffer) error {
 var err error

 if r.StubsImplPath == nil {
  if err = gobtools.EncodeInt(buf, -1); err != nil {
   return err
  }
 } else {
  if err = gobtools.EncodeInt(buf, len(r.StubsImplPath)); err != nil {
   return err
  }
  for val1 := 0; val1 < len(r.StubsImplPath); val1++ {
   if err = gobtools.EncodeInterface(ctx, buf, r.StubsImplPath[val1]); err != nil {
    return err
   }
  }
 }

 if err = r.CurrentApiFilePath.Encode(ctx, buf); err != nil {
  return err
 }

 if err = r.RemovedApiFilePath.Encode(ctx, buf); err != nil {
  return err
 }

 if err = r.StubsSrcJar.Encode(ctx, buf); err != nil {
  return err
 }

 if err = r.AnnotationsZip.Encode(ctx, buf); err != nil {
  return err
 }
 return err
}

func (r ApiScopePathsInfo) CustomHash(hasher *proptools.Hasher) error {
 hasher.WriteString(":java.ApiScopePathsInfo")
 hasher.WriteInt(5)
 hasher.WriteString(":java.android.Paths")
 hasher.WriteString(":.[]Path")
 hasher.WriteInt(len(r.StubsImplPath))
 for val1 := 0; val1 < len(r.StubsImplPath); val1++ {
  hasher.WriteString("android/soong/android:android.Path")
  val2 := r.StubsImplPath[val1] == nil
  if val2 {
   hasher.WriteByte(0)
  } else {
   if v := reflect.ValueOf(r.StubsImplPath[val1]); v.Kind() == reflect.Ptr {
    if v.IsNil() {
     panic(fmt.Errorf("nil pointer is not supported in interface"))
    } else {
     val3 := r.StubsImplPath[val1] == nil
     if val3 {
      hasher.WriteByte(0)
     } else {
      val4 := func(hasher *proptools.Hasher) error {
       return r.StubsImplPath[val1].(proptools.CustomHash).CustomHash(hasher)
      }
      if err := proptools.HashReference(hasher, uintptr(v.Pointer()), val4); err != nil {
       return err
      }
     }
    }
   } else {
    r.StubsImplPath[val1].(proptools.CustomHash).CustomHash(hasher)
   }
  }
 }
 if err := r.CurrentApiFilePath.CustomHash(hasher); err != nil {
  return err
 }
 if err := r.RemovedApiFilePath.CustomHash(hasher); err != nil {
  return err
 }
 if err := r.StubsSrcJar.CustomHash(hasher); err != nil {
  return err
 }
 if err := r.AnnotationsZip.CustomHash(hasher); err != nil {
  return err
 }
 return nil
}

func (r *ApiScopePathsInfo) Decode(ctx gobtools.EncContext, buf *bytes.Reader) error {
 var err error

 var val3 int
 err = gobtools.DecodeInt(buf, &val3)
 if err != nil {
  return err
 }
 if val3 != -1 {
  r.StubsImplPath = make([]android.Path, val3)
  for val4 := 0; val4 < int(val3); val4++ {
   if val6, err := gobtools.DecodeInterface(ctx, buf); err != nil {
    return err
   } else if val6 == nil {
    r.StubsImplPath[val4] = nil
   } else {
    r.StubsImplPath[val4] = val6.(android.Path)
   }
  }
 }

 if err = r.CurrentApiFilePath.Decode(ctx, buf); err != nil {
  return err
 }

 if err = r.RemovedApiFilePath.Decode(ctx, buf); err != nil {
  return err
 }

 if err = r.StubsSrcJar.Decode(ctx, buf); err != nil {
  return err
 }

 if err = r.AnnotationsZip.Decode(ctx, buf); err != nil {
  return err
 }

 return err
}

var ApiScopePathsInfoGobRegId int16

func (r ApiScopePathsInfo) GetTypeId() int16 {
 return ApiScopePathsInfoGobRegId
}

func (r ApiScopePropsInfo) Encode(ctx gobtools.EncContext, buf *bytes.Buffer) error {
 var err error

 val1 := r.SdkVersion == nil
 if err = gobtools.EncodeBool(buf, val1); err != nil {
  return err
 }
 if !val1 {
  if err = gobtools.EncodeString(buf, (*r.SdkVersion)); err != nil {
   return err
  }
 }
 return err
}

func (r ApiScopePropsInfo) CustomHash(hasher *proptools.Hasher) error {
 hasher.WriteString(":java.ApiScopePropsInfo")
 hasher.WriteInt(1)
 hasher.WriteString(":.*string")
 val1 := r.SdkVersion == nil
 if val1 {
  hasher.WriteByte(0)
 } else {
  val2 := func(hasher *proptools.Hasher) error {
   hasher.WriteString(":.string")
   hasher.WriteString((*r.SdkVersion))
   return nil
  }
  if err := proptools.HashReference(hasher, uintptr(unsafe.Pointer(r.SdkVersion)), val2); err != nil {
   return err
  }
 }
 return nil
}

func (r *ApiScopePropsInfo) Decode(ctx gobtools.EncContext, buf *bytes.Reader) error {
 var err error

 var val2 bool
 if err = gobtools.DecodeBool(buf, &val2); err != nil {
  return err
 }
 if !val2 {
  var val1 string
  err = gobtools.DecodeString(buf, &val1)
  if err != nil {
   return err
  }
  r.SdkVersion = &val1
 }

 return err
}

var ApiScopePropsInfoGobRegId int16

func (r ApiScopePropsInfo) GetTypeId() int16 {
 return ApiScopePropsInfoGobRegId
}

func (r SdkLibraryInfo) Encode(ctx gobtools.EncContext, buf *bytes.Buffer) error {
 var err error

 if r.GeneratingLibs == nil {
  if err = gobtools.EncodeInt(buf, -1); err != nil {
   return err
  }
 } else {
  if err = gobtools.EncodeInt(buf, len(r.GeneratingLibs)); err != nil {
   return err
  }
  for val1 := 0; val1 < len(r.GeneratingLibs); val1++ {
   if err = gobtools.EncodeString(buf, r.GeneratingLibs[val1]); err != nil {
    return err
   }
  }
 }

 if r.EverythingStubDexJarPaths == nil {
  if err = gobtools.EncodeInt(buf, -1); err != nil {
   return err
  }
 } else {
  if err = gobtools.EncodeInt(buf, len(r.EverythingStubDexJarPaths)); err != nil {
   return err
  }
  for val2, val3 := range r.EverythingStubDexJarPaths {
   if err = gobtools.EncodeInt(buf, int(val2)); err != nil {
    return err
   }
   if err = val3.Encode(ctx, buf); err != nil {
    return err
   }
  }
 }

 if r.ExportableStubDexJarPaths == nil {
  if err = gobtools.EncodeInt(buf, -1); err != nil {
   return err
  }
 } else {
  if err = gobtools.EncodeInt(buf, len(r.ExportableStubDexJarPaths)); err != nil {
   return err
  }
  for val4, val5 := range r.ExportableStubDexJarPaths {
   if err = gobtools.EncodeInt(buf, int(val4)); err != nil {
    return err
   }
   if err = val5.Encode(ctx, buf); err != nil {
    return err
   }
  }
 }

 if r.RemovedTxtFiles == nil {
  if err = gobtools.EncodeInt(buf, -1); err != nil {
   return err
  }
 } else {
  if err = gobtools.EncodeInt(buf, len(r.RemovedTxtFiles)); err != nil {
   return err
  }
  for val6, val7 := range r.RemovedTxtFiles {
   if err = gobtools.EncodeInt(buf, int(val6)); err != nil {
    return err
   }
   if err = val7.Encode(ctx, buf); err != nil {
    return err
   }
  }
 }

 if err = gobtools.EncodeBool(buf, r.SharedLibrary); err != nil {
  return err
 }

 if err = gobtools.EncodeBool(buf, r.Prebuilt); err != nil {
  return err
 }

 if err = gobtools.EncodeString(buf, r.DistStem); err != nil {
  return err
 }

 if r.DoctagPaths == nil {
  if err = gobtools.EncodeInt(buf, -1); err != nil {
   return err
  }
 } else {
  if err = gobtools.EncodeInt(buf, len(r.DoctagPaths)); err != nil {
   return err
  }
  for val8 := 0; val8 < len(r.DoctagPaths); val8++ {
   if err = gobtools.EncodeInterface(ctx, buf, r.DoctagPaths[val8]); err != nil {
    return err
   }
  }
 }

 val9 := r.OnBootclasspathSince == nil
 if err = gobtools.EncodeBool(buf, val9); err != nil {
  return err
 }
 if !val9 {
  if err = gobtools.EncodeString(buf, (*r.OnBootclasspathSince)); err != nil {
   return err
  }
 }

 val10 := r.OnBootclasspathBefore == nil
 if err = gobtools.EncodeBool(buf, val10); err != nil {
  return err
 }
 if !val10 {
  if err = gobtools.EncodeString(buf, (*r.OnBootclasspathBefore)); err != nil {
   return err
  }
 }

 val11 := r.MinDeviceSdk == nil
 if err = gobtools.EncodeBool(buf, val11); err != nil {
  return err
 }
 if !val11 {
  if err = gobtools.EncodeString(buf, (*r.MinDeviceSdk)); err != nil {
   return err
  }
 }

 val12 := r.MaxDeviceSdk == nil
 if err = gobtools.EncodeBool(buf, val12); err != nil {
  return err
 }
 if !val12 {
  if err = gobtools.EncodeString(buf, (*r.MaxDeviceSdk)); err != nil {
   return err
  }
 }

 if err = gobtools.EncodeBool(buf, r.ImplLibProfileGuided); err != nil {
  return err
 }

 if r.ApiScopePaths == nil {
  if err = gobtools.EncodeInt(buf, -1); err != nil {
   return err
  }
 } else {
  if err = gobtools.EncodeInt(buf, len(r.ApiScopePaths)); err != nil {
   return err
  }
  for val13, val14 := range r.ApiScopePaths {
   if err = gobtools.EncodeString(buf, val13); err != nil {
    return err
   }
   if err = val14.Encode(ctx, buf); err != nil {
    return err
   }
  }
 }

 if r.ApiScopeProps == nil {
  if err = gobtools.EncodeInt(buf, -1); err != nil {
   return err
  }
 } else {
  if err = gobtools.EncodeInt(buf, len(r.ApiScopeProps)); err != nil {
   return err
  }
  for val15, val16 := range r.ApiScopeProps {
   if err = gobtools.EncodeString(buf, val15); err != nil {
    return err
   }
   if err = val16.Encode(ctx, buf); err != nil {
    return err
   }
  }
 }
 return err
}

func (r SdkLibraryInfo) CustomHash(hasher *proptools.Hasher) error {
 hasher.WriteString(":java.SdkLibraryInfo")
 hasher.WriteInt(15)
 hasher.WriteString(":.[]string")
 hasher.WriteInt(len(r.GeneratingLibs))
 for val1 := 0; val1 < len(r.GeneratingLibs); val1++ {
  hasher.WriteString(":.string")
  hasher.WriteString(r.GeneratingLibs[val1])
 }
 hasher.WriteString(":.map[android.SdkKind]OptionalDexJarPath")
 hasher.WriteInt(len(r.EverythingStubDexJarPaths))
 val2 := make([]android.SdkKind, 0, len(r.EverythingStubDexJarPaths))
 for val4 := range r.EverythingStubDexJarPaths {
  val2 = append(val2, val4)
 }
 proptools.SortOrdered(val2)
 for _, val3 := range val2 {
  hasher.WriteString(":java.android.SdkKind")
  hasher.WriteString(":.int")
  hasher.WriteUint64(uint64(int(val3)))
  if err := r.EverythingStubDexJarPaths[val3].CustomHash(hasher); err != nil {
   return err
  }
 }
 hasher.WriteString(":.map[android.SdkKind]OptionalDexJarPath")
 hasher.WriteInt(len(r.ExportableStubDexJarPaths))
 val5 := make([]android.SdkKind, 0, len(r.ExportableStubDexJarPaths))
 for val7 := range r.ExportableStubDexJarPaths {
  val5 = append(val5, val7)
 }
 proptools.SortOrdered(val5)
 for _, val6 := range val5 {
  hasher.WriteString(":java.android.SdkKind")
  hasher.WriteString(":.int")
  hasher.WriteUint64(uint64(int(val6)))
  if err := r.ExportableStubDexJarPaths[val6].CustomHash(hasher); err != nil {
   return err
  }
 }
 hasher.WriteString(":.map[android.SdkKind]android.OptionalPath")
 hasher.WriteInt(len(r.RemovedTxtFiles))
 val8 := make([]android.SdkKind, 0, len(r.RemovedTxtFiles))
 for val10 := range r.RemovedTxtFiles {
  val8 = append(val8, val10)
 }
 proptools.SortOrdered(val8)
 for _, val9 := range val8 {
  hasher.WriteString(":java.android.SdkKind")
  hasher.WriteString(":.int")
  hasher.WriteUint64(uint64(int(val9)))
  if err := r.RemovedTxtFiles[val9].CustomHash(hasher); err != nil {
   return err
  }
 }
 hasher.WriteString(":.bool")
 if r.SharedLibrary {
  hasher.WriteByte(1)
 } else {
  hasher.WriteByte(0)
 }
 hasher.WriteString(":.bool")
 if r.Prebuilt {
  hasher.WriteByte(1)
 } else {
  hasher.WriteByte(0)
 }
 hasher.WriteString(":.string")
 hasher.WriteString(r.DistStem)
 hasher.WriteString(":java.android.Paths")
 hasher.WriteString(":.[]Path")
 hasher.WriteInt(len(r.DoctagPaths))
 for val11 := 0; val11 < len(r.DoctagPaths); val11++ {
  hasher.WriteString("android/soong/android:android.Path")
  val12 := r.DoctagPaths[val11] == nil
  if val12 {
   hasher.WriteByte(0)
  } else {
   if v := reflect.ValueOf(r.DoctagPaths[val11]); v.Kind() == reflect.Ptr {
    if v.IsNil() {
     panic(fmt.Errorf("nil pointer is not supported in interface"))
    } else {
     val13 := r.DoctagPaths[val11] == nil
     if val13 {
      hasher.WriteByte(0)
     } else {
      val14 := func(hasher *proptools.Hasher) error {
       return r.DoctagPaths[val11].(proptools.CustomHash).CustomHash(hasher)
      }
      if err := proptools.HashReference(hasher, uintptr(v.Pointer()), val14); err != nil {
       return err
      }
     }
    }
   } else {
    r.DoctagPaths[val11].(proptools.CustomHash).CustomHash(hasher)
   }
  }
 }
 hasher.WriteString(":.*string")
 val15 := r.OnBootclasspathSince == nil
 if val15 {
  hasher.WriteByte(0)
 } else {
  val16 := func(hasher *proptools.Hasher) error {
   hasher.WriteString(":.string")
   hasher.WriteString((*r.OnBootclasspathSince))
   return nil
  }
  if err := proptools.HashReference(hasher, uintptr(unsafe.Pointer(r.OnBootclasspathSince)), val16); err != nil {
   return err
  }
 }
 hasher.WriteString(":.*string")
 val17 := r.OnBootclasspathBefore == nil
 if val17 {
  hasher.WriteByte(0)
 } else {
  val18 := func(hasher *proptools.Hasher) error {
   hasher.WriteString(":.string")
   hasher.WriteString((*r.OnBootclasspathBefore))
   return nil
  }
  if err := proptools.HashReference(hasher, uintptr(unsafe.Pointer(r.OnBootclasspathBefore)), val18); err != nil {
   return err
  }
 }
 hasher.WriteString(":.*string")
 val19 := r.MinDeviceSdk == nil
 if val19 {
  hasher.WriteByte(0)
 } else {
  val20 := func(hasher *proptools.Hasher) error {
   hasher.WriteString(":.string")
   hasher.WriteString((*r.MinDeviceSdk))
   return nil
  }
  if err := proptools.HashReference(hasher, uintptr(unsafe.Pointer(r.MinDeviceSdk)), val20); err != nil {
   return err
  }
 }
 hasher.WriteString(":.*string")
 val21 := r.MaxDeviceSdk == nil
 if val21 {
  hasher.WriteByte(0)
 } else {
  val22 := func(hasher *proptools.Hasher) error {
   hasher.WriteString(":.string")
   hasher.WriteString((*r.MaxDeviceSdk))
   return nil
  }
  if err := proptools.HashReference(hasher, uintptr(unsafe.Pointer(r.MaxDeviceSdk)), val22); err != nil {
   return err
  }
 }
 hasher.WriteString(":.bool")
 if r.ImplLibProfileGuided {
  hasher.WriteByte(1)
 } else {
  hasher.WriteByte(0)
 }
 hasher.WriteString(":.map[string]ApiScopePathsInfo")
 hasher.WriteInt(len(r.ApiScopePaths))
 val23 := make([]string, 0, len(r.ApiScopePaths))
 for val25 := range r.ApiScopePaths {
  val23 = append(val23, val25)
 }
 proptools.SortOrdered(val23)
 for _, val24 := range val23 {
  hasher.WriteString(":.string")
  hasher.WriteString(val24)
  if err := r.ApiScopePaths[val24].CustomHash(hasher); err != nil {
   return err
  }
 }
 hasher.WriteString(":.map[string]ApiScopePropsInfo")
 hasher.WriteInt(len(r.ApiScopeProps))
 val26 := make([]string, 0, len(r.ApiScopeProps))
 for val28 := range r.ApiScopeProps {
  val26 = append(val26, val28)
 }
 proptools.SortOrdered(val26)
 for _, val27 := range val26 {
  hasher.WriteString(":.string")
  hasher.WriteString(val27)
  if err := r.ApiScopeProps[val27].CustomHash(hasher); err != nil {
   return err
  }
 }
 return nil
}

func (r *SdkLibraryInfo) Decode(ctx gobtools.EncContext, buf *bytes.Reader) error {
 var err error

 var val2 int
 err = gobtools.DecodeInt(buf, &val2)
 if err != nil {
  return err
 }
 if val2 != -1 {
  r.GeneratingLibs = make([]string, val2)
  for val3 := 0; val3 < int(val2); val3++ {
   err = gobtools.DecodeString(buf, &r.GeneratingLibs[val3])
   if err != nil {
    return err
   }
  }
 }

 var val5 int
 err = gobtools.DecodeInt(buf, &val5)
 if err != nil {
  return err
 }
 if val5 != -1 {
  r.EverythingStubDexJarPaths = make(map[android.SdkKind]OptionalDexJarPath, val5)
  for val6 := 0; val6 < int(val5); val6++ {
   var val7 android.SdkKind
   var val8 OptionalDexJarPath
   var val10 int
   err = gobtools.DecodeInt(buf, &val10)
   if err != nil {
    return err
   }
   val7 = android.SdkKind(val10)
   if err = val8.Decode(ctx, buf); err != nil {
    return err
   }
   r.EverythingStubDexJarPaths[val7] = val8
  }
 }

 var val13 int
 err = gobtools.DecodeInt(buf, &val13)
 if err != nil {
  return err
 }
 if val13 != -1 {
  r.ExportableStubDexJarPaths = make(map[android.SdkKind]OptionalDexJarPath, val13)
  for val14 := 0; val14 < int(val13); val14++ {
   var val15 android.SdkKind
   var val16 OptionalDexJarPath
   var val18 int
   err = gobtools.DecodeInt(buf, &val18)
   if err != nil {
    return err
   }
   val15 = android.SdkKind(val18)
   if err = val16.Decode(ctx, buf); err != nil {
    return err
   }
   r.ExportableStubDexJarPaths[val15] = val16
  }
 }

 var val21 int
 err = gobtools.DecodeInt(buf, &val21)
 if err != nil {
  return err
 }
 if val21 != -1 {
  r.RemovedTxtFiles = make(map[android.SdkKind]android.OptionalPath, val21)
  for val22 := 0; val22 < int(val21); val22++ {
   var val23 android.SdkKind
   var val24 android.OptionalPath
   var val26 int
   err = gobtools.DecodeInt(buf, &val26)
   if err != nil {
    return err
   }
   val23 = android.SdkKind(val26)
   if err = val24.Decode(ctx, buf); err != nil {
    return err
   }
   r.RemovedTxtFiles[val23] = val24
  }
 }

 err = gobtools.DecodeBool(buf, &r.SharedLibrary)
 if err != nil {
  return err
 }

 err = gobtools.DecodeBool(buf, &r.Prebuilt)
 if err != nil {
  return err
 }

 err = gobtools.DecodeString(buf, &r.DistStem)
 if err != nil {
  return err
 }

 var val34 int
 err = gobtools.DecodeInt(buf, &val34)
 if err != nil {
  return err
 }
 if val34 != -1 {
  r.DoctagPaths = make([]android.Path, val34)
  for val35 := 0; val35 < int(val34); val35++ {
   if val37, err := gobtools.DecodeInterface(ctx, buf); err != nil {
    return err
   } else if val37 == nil {
    r.DoctagPaths[val35] = nil
   } else {
    r.DoctagPaths[val35] = val37.(android.Path)
   }
  }
 }

 var val39 bool
 if err = gobtools.DecodeBool(buf, &val39); err != nil {
  return err
 }
 if !val39 {
  var val38 string
  err = gobtools.DecodeString(buf, &val38)
  if err != nil {
   return err
  }
  r.OnBootclasspathSince = &val38
 }

 var val42 bool
 if err = gobtools.DecodeBool(buf, &val42); err != nil {
  return err
 }
 if !val42 {
  var val41 string
  err = gobtools.DecodeString(buf, &val41)
  if err != nil {
   return err
  }
  r.OnBootclasspathBefore = &val41
 }

 var val45 bool
 if err = gobtools.DecodeBool(buf, &val45); err != nil {
  return err
 }
 if !val45 {
  var val44 string
  err = gobtools.DecodeString(buf, &val44)
  if err != nil {
   return err
  }
  r.MinDeviceSdk = &val44
 }

 var val48 bool
 if err = gobtools.DecodeBool(buf, &val48); err != nil {
  return err
 }
 if !val48 {
  var val47 string
  err = gobtools.DecodeString(buf, &val47)
  if err != nil {
   return err
  }
  r.MaxDeviceSdk = &val47
 }

 err = gobtools.DecodeBool(buf, &r.ImplLibProfileGuided)
 if err != nil {
  return err
 }

 var val51 int
 err = gobtools.DecodeInt(buf, &val51)
 if err != nil {
  return err
 }
 if val51 != -1 {
  r.ApiScopePaths = make(map[string]ApiScopePathsInfo, val51)
  for val52 := 0; val52 < int(val51); val52++ {
   var val53 string
   var val54 ApiScopePathsInfo
   err = gobtools.DecodeString(buf, &val53)
   if err != nil {
    return err
   }
   if err = val54.Decode(ctx, buf); err != nil {
    return err
   }
   r.ApiScopePaths[val53] = val54
  }
 }

 var val57 int
 err = gobtools.DecodeInt(buf, &val57)
 if err != nil {
  return err
 }
 if val57 != -1 {
  r.ApiScopeProps = make(map[string]ApiScopePropsInfo, val57)
  for val58 := 0; val58 < int(val57); val58++ {
   var val59 string
   var val60 ApiScopePropsInfo
   err = gobtools.DecodeString(buf, &val59)
   if err != nil {
    return err
   }
   if err = val60.Decode(ctx, buf); err != nil {
    return err
   }
   r.ApiScopeProps[val59] = val60
  }
 }

 return err
}

var SdkLibraryInfoGobRegId int16

func (r SdkLibraryInfo) GetTypeId() int16 {
 return SdkLibraryInfoGobRegId
}

func (r SdkLibraryDepInSameApexChecker) Encode(ctx gobtools.EncContext, buf *bytes.Buffer) error {
 var err error

 if err = r.BaseDepInSameApexChecker.Encode(ctx, buf); err != nil {
  return err
 }
 return err
}

func (r SdkLibraryDepInSameApexChecker) CustomHash(hasher *proptools.Hasher) error {
 hasher.WriteString(":java.SdkLibraryDepInSameApexChecker")
 hasher.WriteInt(1)
 if err := r.BaseDepInSameApexChecker.CustomHash(hasher); err != nil {
  return err
 }
 return nil
}

func (r *SdkLibraryDepInSameApexChecker) Decode(ctx gobtools.EncContext, buf *bytes.Reader) error {
 var err error

 if err = r.BaseDepInSameApexChecker.Decode(ctx, buf); err != nil {
  return err
 }

 return err
}

var SdkLibraryDepInSameApexCheckerGobRegId int16

func (r SdkLibraryDepInSameApexChecker) GetTypeId() int16 {
 return SdkLibraryDepInSameApexCheckerGobRegId
}

func (r SdkLibraryImportDepIsInSameApexChecker) Encode(ctx gobtools.EncContext, buf *bytes.Buffer) error {
 var err error

 if err = r.BaseDepInSameApexChecker.Encode(ctx, buf); err != nil {
  return err
 }
 return err
}

func (r SdkLibraryImportDepIsInSameApexChecker) CustomHash(hasher *proptools.Hasher) error {
 hasher.WriteString(":java.SdkLibraryImportDepIsInSameApexChecker")
 hasher.WriteInt(1)
 if err := r.BaseDepInSameApexChecker.CustomHash(hasher); err != nil {
  return err
 }
 return nil
}

func (r *SdkLibraryImportDepIsInSameApexChecker) Decode(ctx gobtools.EncContext, buf *bytes.Reader) error {
 var err error

 if err = r.BaseDepInSameApexChecker.Decode(ctx, buf); err != nil {
  return err
 }

 return err
}

var SdkLibraryImportDepIsInSameApexCheckerGobRegId int16

func (r SdkLibraryImportDepIsInSameApexChecker) GetTypeId() int16 {
 return SdkLibraryImportDepIsInSameApexCheckerGobRegId
}

// end of sdk_library.go

// begin of system_modules.go
func init() {
 SystemModulesProviderInfoGobRegId = gobtools.RegisterType(func() gobtools.CustomDec { return new(SystemModulesProviderInfo) })
}

func (r SystemModulesProviderInfo) Encode(ctx gobtools.EncContext, buf *bytes.Buffer) error {
 var err error

 if r.HeaderJars == nil {
  if err = gobtools.EncodeInt(buf, -1); err != nil {
   return err
  }
 } else {
  if err = gobtools.EncodeInt(buf, len(r.HeaderJars)); err != nil {
   return err
  }
  for val1 := 0; val1 < len(r.HeaderJars); val1++ {
   if err = gobtools.EncodeInterface(ctx, buf, r.HeaderJars[val1]); err != nil {
    return err
   }
  }
 }

 if err = gobtools.EncodeInterface(ctx, buf, r.OutputDir); err != nil {
  return err
 }

 if r.OutputDirDeps == nil {
  if err = gobtools.EncodeInt(buf, -1); err != nil {
   return err
  }
 } else {
  if err = gobtools.EncodeInt(buf, len(r.OutputDirDeps)); err != nil {
   return err
  }
  for val2 := 0; val2 < len(r.OutputDirDeps); val2++ {
   if err = gobtools.EncodeInterface(ctx, buf, r.OutputDirDeps[val2]); err != nil {
    return err
   }
  }
 }

 if err = r.TransitiveStaticLibsHeaderJars.EncodeInterface(ctx, buf); err != nil {
  return err
 }

 if err = gobtools.EncodeBool(buf, r.Prebuilt); err != nil {
  return err
 }

 if r.Libs == nil {
  if err = gobtools.EncodeInt(buf, -1); err != nil {
   return err
  }
 } else {
  if err = gobtools.EncodeInt(buf, len(r.Libs)); err != nil {
   return err
  }
  for val3 := 0; val3 < len(r.Libs); val3++ {
   if err = gobtools.EncodeString(buf, r.Libs[val3]); err != nil {
    return err
   }
  }
 }
 return err
}

func (r SystemModulesProviderInfo) CustomHash(hasher *proptools.Hasher) error {
 hasher.WriteString(":java.SystemModulesProviderInfo")
 hasher.WriteInt(6)
 hasher.WriteString(":java.android.Paths")
 hasher.WriteString(":.[]Path")
 hasher.WriteInt(len(r.HeaderJars))
 for val1 := 0; val1 < len(r.HeaderJars); val1++ {
  hasher.WriteString("android/soong/android:android.Path")
  val2 := r.HeaderJars[val1] == nil
  if val2 {
   hasher.WriteByte(0)
  } else {
   if v := reflect.ValueOf(r.HeaderJars[val1]); v.Kind() == reflect.Ptr {
    if v.IsNil() {
     panic(fmt.Errorf("nil pointer is not supported in interface"))
    } else {
     val3 := r.HeaderJars[val1] == nil
     if val3 {
      hasher.WriteByte(0)
     } else {
      val4 := func(hasher *proptools.Hasher) error {
       return r.HeaderJars[val1].(proptools.CustomHash).CustomHash(hasher)
      }
      if err := proptools.HashReference(hasher, uintptr(v.Pointer()), val4); err != nil {
       return err
      }
     }
    }
   } else {
    r.HeaderJars[val1].(proptools.CustomHash).CustomHash(hasher)
   }
  }
 }
 hasher.WriteString(":java.android.Path")
 val5 := r.OutputDir == nil
 if val5 {
  hasher.WriteByte(0)
 } else {
  if v := reflect.ValueOf(r.OutputDir); v.Kind() == reflect.Ptr {
   if v.IsNil() {
    panic(fmt.Errorf("nil pointer is not supported in interface"))
   } else {
    val6 := r.OutputDir == nil
    if val6 {
     hasher.WriteByte(0)
    } else {
     val7 := func(hasher *proptools.Hasher) error { return r.OutputDir.(proptools.CustomHash).CustomHash(hasher) }
     if err := proptools.HashReference(hasher, uintptr(v.Pointer()), val7); err != nil {
      return err
     }
    }
   }
  } else {
   r.OutputDir.(proptools.CustomHash).CustomHash(hasher)
  }
 }
 hasher.WriteString(":java.android.Paths")
 hasher.WriteString(":.[]Path")
 hasher.WriteInt(len(r.OutputDirDeps))
 for val8 := 0; val8 < len(r.OutputDirDeps); val8++ {
  hasher.WriteString("android/soong/android:android.Path")
  val9 := r.OutputDirDeps[val8] == nil
  if val9 {
   hasher.WriteByte(0)
  } else {
   if v := reflect.ValueOf(r.OutputDirDeps[val8]); v.Kind() == reflect.Ptr {
    if v.IsNil() {
     panic(fmt.Errorf("nil pointer is not supported in interface"))
    } else {
     val10 := r.OutputDirDeps[val8] == nil
     if val10 {
      hasher.WriteByte(0)
     } else {
      val11 := func(hasher *proptools.Hasher) error {
       return r.OutputDirDeps[val8].(proptools.CustomHash).CustomHash(hasher)
      }
      if err := proptools.HashReference(hasher, uintptr(v.Pointer()), val11); err != nil {
       return err
      }
     }
    }
   } else {
    r.OutputDirDeps[val8].(proptools.CustomHash).CustomHash(hasher)
   }
  }
 }
 val16 := func(hasher *proptools.Hasher, val12 android.Path) error {
  hasher.WriteString(":java.android.Path")
  val13 := val12 == nil
  if val13 {
   hasher.WriteByte(0)
  } else {
   if v := reflect.ValueOf(val12); v.Kind() == reflect.Ptr {
    if v.IsNil() {
     panic(fmt.Errorf("nil pointer is not supported in interface"))
    } else {
     val14 := val12 == nil
     if val14 {
      hasher.WriteByte(0)
     } else {
      val15 := func(hasher *proptools.Hasher) error { return val12.(proptools.CustomHash).CustomHash(hasher) }
      if err := proptools.HashReference(hasher, uintptr(v.Pointer()), val15); err != nil {
       return err
      }
     }
    }
   } else {
    val12.(proptools.CustomHash).CustomHash(hasher)
   }
  }
  return nil
 }
 if err := r.TransitiveStaticLibsHeaderJars.Hash(hasher, "android.Path", val16); err != nil {
  return err
 }
 hasher.WriteString(":.bool")
 if r.Prebuilt {
  hasher.WriteByte(1)
 } else {
  hasher.WriteByte(0)
 }
 hasher.WriteString(":.[]string")
 hasher.WriteInt(len(r.Libs))
 for val17 := 0; val17 < len(r.Libs); val17++ {
  hasher.WriteString(":.string")
  hasher.WriteString(r.Libs[val17])
 }
 return nil
}

func (r *SystemModulesProviderInfo) Decode(ctx gobtools.EncContext, buf *bytes.Reader) error {
 var err error

 var val3 int
 err = gobtools.DecodeInt(buf, &val3)
 if err != nil {
  return err
 }
 if val3 != -1 {
  r.HeaderJars = make([]android.Path, val3)
  for val4 := 0; val4 < int(val3); val4++ {
   if val6, err := gobtools.DecodeInterface(ctx, buf); err != nil {
    return err
   } else if val6 == nil {
    r.HeaderJars[val4] = nil
   } else {
    r.HeaderJars[val4] = val6.(android.Path)
   }
  }
 }

 if val8, err := gobtools.DecodeInterface(ctx, buf); err != nil {
  return err
 } else if val8 == nil {
  r.OutputDir = nil
 } else {
  r.OutputDir = val8.(android.Path)
 }

 var val11 int
 err = gobtools.DecodeInt(buf, &val11)
 if err != nil {
  return err
 }
 if val11 != -1 {
  r.OutputDirDeps = make([]android.Path, val11)
  for val12 := 0; val12 < int(val11); val12++ {
   if val14, err := gobtools.DecodeInterface(ctx, buf); err != nil {
    return err
   } else if val14 == nil {
    r.OutputDirDeps[val12] = nil
   } else {
    r.OutputDirDeps[val12] = val14.(android.Path)
   }
  }
 }

 if err = r.TransitiveStaticLibsHeaderJars.DecodeInterface(ctx, buf); err != nil {
  return err
 }

 err = gobtools.DecodeBool(buf, &r.Prebuilt)
 if err != nil {
  return err
 }

 var val18 int
 err = gobtools.DecodeInt(buf, &val18)
 if err != nil {
  return err
 }
 if val18 != -1 {
  r.Libs = make([]string, val18)
  for val19 := 0; val19 < int(val18); val19++ {
   err = gobtools.DecodeString(buf, &r.Libs[val19])
   if err != nil {
    return err
   }
  }
 }

 return err
}

var SystemModulesProviderInfoGobRegId int16

func (r SystemModulesProviderInfo) GetTypeId() int16 {
 return SystemModulesProviderInfoGobRegId
}

// end of system_modules.go

// begin of systemserver_classpath_fragment.go
func init() {
 SystemServerClasspathInfoGobRegId = gobtools.RegisterType(func() gobtools.CustomDec { return new(SystemServerClasspathInfo) })
 LibraryNameToPartitionInfoGobRegId = gobtools.RegisterType(func() gobtools.CustomDec { return new(LibraryNameToPartitionInfo) })
}

func (r SystemServerClasspathInfo) Encode(ctx gobtools.EncContext, buf *bytes.Buffer) error {
 var err error

 if r.Contents == nil {
  if err = gobtools.EncodeInt(buf, -1); err != nil {
   return err
  }
 } else {
  if err = gobtools.EncodeInt(buf, len(r.Contents)); err != nil {
   return err
  }
  for val1 := 0; val1 < len(r.Contents); val1++ {
   if err = gobtools.EncodeString(buf, r.Contents[val1]); err != nil {
    return err
   }
  }
 }

 if r.StandaloneContents == nil {
  if err = gobtools.EncodeInt(buf, -1); err != nil {
   return err
  }
 } else {
  if err = gobtools.EncodeInt(buf, len(r.StandaloneContents)); err != nil {
   return err
  }
  for val2 := 0; val2 < len(r.StandaloneContents); val2++ {
   if err = gobtools.EncodeString(buf, r.StandaloneContents[val2]); err != nil {
    return err
   }
  }
 }
 return err
}

func (r SystemServerClasspathInfo) CustomHash(hasher *proptools.Hasher) error {
 hasher.WriteString(":java.SystemServerClasspathInfo")
 hasher.WriteInt(2)
 hasher.WriteString(":.[]string")
 hasher.WriteInt(len(r.Contents))
 for val1 := 0; val1 < len(r.Contents); val1++ {
  hasher.WriteString(":.string")
  hasher.WriteString(r.Contents[val1])
 }
 hasher.WriteString(":.[]string")
 hasher.WriteInt(len(r.StandaloneContents))
 for val2 := 0; val2 < len(r.StandaloneContents); val2++ {
  hasher.WriteString(":.string")
  hasher.WriteString(r.StandaloneContents[val2])
 }
 return nil
}

func (r *SystemServerClasspathInfo) Decode(ctx gobtools.EncContext, buf *bytes.Reader) error {
 var err error

 var val2 int
 err = gobtools.DecodeInt(buf, &val2)
 if err != nil {
  return err
 }
 if val2 != -1 {
  r.Contents = make([]string, val2)
  for val3 := 0; val3 < int(val2); val3++ {
   err = gobtools.DecodeString(buf, &r.Contents[val3])
   if err != nil {
    return err
   }
  }
 }

 var val6 int
 err = gobtools.DecodeInt(buf, &val6)
 if err != nil {
  return err
 }
 if val6 != -1 {
  r.StandaloneContents = make([]string, val6)
  for val7 := 0; val7 < int(val6); val7++ {
   err = gobtools.DecodeString(buf, &r.StandaloneContents[val7])
   if err != nil {
    return err
   }
  }
 }

 return err
}

var SystemServerClasspathInfoGobRegId int16

func (r SystemServerClasspathInfo) GetTypeId() int16 {
 return SystemServerClasspathInfoGobRegId
}

func (r LibraryNameToPartitionInfo) Encode(ctx gobtools.EncContext, buf *bytes.Buffer) error {
 var err error

 if r.LibraryNameToPartition == nil {
  if err = gobtools.EncodeInt(buf, -1); err != nil {
   return err
  }
 } else {
  if err = gobtools.EncodeInt(buf, len(r.LibraryNameToPartition)); err != nil {
   return err
  }
  for val1, val2 := range r.LibraryNameToPartition {
   if err = gobtools.EncodeString(buf, val1); err != nil {
    return err
   }
   if err = gobtools.EncodeString(buf, val2); err != nil {
    return err
   }
  }
 }
 return err
}

func (r LibraryNameToPartitionInfo) CustomHash(hasher *proptools.Hasher) error {
 hasher.WriteString(":java.LibraryNameToPartitionInfo")
 hasher.WriteInt(1)
 hasher.WriteString(":.map[string]string")
 hasher.WriteInt(len(r.LibraryNameToPartition))
 val1 := make([]string, 0, len(r.LibraryNameToPartition))
 for val3 := range r.LibraryNameToPartition {
  val1 = append(val1, val3)
 }
 proptools.SortOrdered(val1)
 for _, val2 := range val1 {
  hasher.WriteString(":.string")
  hasher.WriteString(val2)
  hasher.WriteString(":.string")
  hasher.WriteString(r.LibraryNameToPartition[val2])
 }
 return nil
}

func (r *LibraryNameToPartitionInfo) Decode(ctx gobtools.EncContext, buf *bytes.Reader) error {
 var err error

 var val1 int
 err = gobtools.DecodeInt(buf, &val1)
 if err != nil {
  return err
 }
 if val1 != -1 {
  r.LibraryNameToPartition = make(map[string]string, val1)
  for val2 := 0; val2 < int(val1); val2++ {
   var val3 string
   var val4 string
   err = gobtools.DecodeString(buf, &val3)
   if err != nil {
    return err
   }
   err = gobtools.DecodeString(buf, &val4)
   if err != nil {
    return err
   }
   r.LibraryNameToPartition[val3] = val4
  }
 }

 return err
}

var LibraryNameToPartitionInfoGobRegId int16

func (r LibraryNameToPartitionInfo) GetTypeId() int16 {
 return LibraryNameToPartitionInfoGobRegId
}

// end of systemserver_classpath_fragment.go