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

package cc

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

// begin of binary_sdk_member.go
func init() {
 binarySdkMemberTypeGobRegId = gobtools.RegisterType(func() gobtools.CustomDec { return new(binarySdkMemberType) })
}

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

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

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

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

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

 return err
}

var binarySdkMemberTypeGobRegId int16

func (r binarySdkMemberType) GetTypeId() int16 {
 return binarySdkMemberTypeGobRegId
}

// end of binary_sdk_member.go

// begin of builder.go
func init() {
 ObjectsGobRegId = gobtools.RegisterType(func() gobtools.CustomDec { return new(Objects) })
 KytheFilePairGobRegId = gobtools.RegisterType(func() gobtools.CustomDec { return new(KytheFilePair) })
}

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

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

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

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

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

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

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

func (r Objects) CustomHash(hasher *proptools.Hasher) error {
 hasher.WriteString(":cc.Objects")
 hasher.WriteInt(6)
 hasher.WriteString(":cc.android.Paths")
 hasher.WriteString(":.[]Path")
 hasher.WriteInt(len(r.objFiles))
 for val1 := 0; val1 < len(r.objFiles); val1++ {
  hasher.WriteString("android/soong/android:android.Path")
  val2 := r.objFiles[val1] == nil
  if val2 {
   hasher.WriteByte(0)
  } else {
   if v := reflect.ValueOf(r.objFiles[val1]); v.Kind() == reflect.Ptr {
    if v.IsNil() {
     panic(fmt.Errorf("nil pointer is not supported in interface"))
    } else {
     val3 := r.objFiles[val1] == nil
     if val3 {
      hasher.WriteByte(0)
     } else {
      val4 := func(hasher *proptools.Hasher) error {
       return r.objFiles[val1].(proptools.CustomHash).CustomHash(hasher)
      }
      if err := proptools.HashReference(hasher, uintptr(v.Pointer()), val4); err != nil {
       return err
      }
     }
    }
   } else {
    r.objFiles[val1].(proptools.CustomHash).CustomHash(hasher)
   }
  }
 }
 hasher.WriteString(":cc.android.Paths")
 hasher.WriteString(":.[]Path")
 hasher.WriteInt(len(r.tidyFiles))
 for val5 := 0; val5 < len(r.tidyFiles); val5++ {
  hasher.WriteString("android/soong/android:android.Path")
  val6 := r.tidyFiles[val5] == nil
  if val6 {
   hasher.WriteByte(0)
  } else {
   if v := reflect.ValueOf(r.tidyFiles[val5]); v.Kind() == reflect.Ptr {
    if v.IsNil() {
     panic(fmt.Errorf("nil pointer is not supported in interface"))
    } else {
     val7 := r.tidyFiles[val5] == nil
     if val7 {
      hasher.WriteByte(0)
     } else {
      val8 := func(hasher *proptools.Hasher) error {
       return r.tidyFiles[val5].(proptools.CustomHash).CustomHash(hasher)
      }
      if err := proptools.HashReference(hasher, uintptr(v.Pointer()), val8); err != nil {
       return err
      }
     }
    }
   } else {
    r.tidyFiles[val5].(proptools.CustomHash).CustomHash(hasher)
   }
  }
 }
 hasher.WriteString(":cc.android.Paths")
 hasher.WriteString(":.[]Path")
 hasher.WriteInt(len(r.tidyDepFiles))
 for val9 := 0; val9 < len(r.tidyDepFiles); val9++ {
  hasher.WriteString("android/soong/android:android.Path")
  val10 := r.tidyDepFiles[val9] == nil
  if val10 {
   hasher.WriteByte(0)
  } else {
   if v := reflect.ValueOf(r.tidyDepFiles[val9]); v.Kind() == reflect.Ptr {
    if v.IsNil() {
     panic(fmt.Errorf("nil pointer is not supported in interface"))
    } else {
     val11 := r.tidyDepFiles[val9] == nil
     if val11 {
      hasher.WriteByte(0)
     } else {
      val12 := func(hasher *proptools.Hasher) error {
       return r.tidyDepFiles[val9].(proptools.CustomHash).CustomHash(hasher)
      }
      if err := proptools.HashReference(hasher, uintptr(v.Pointer()), val12); err != nil {
       return err
      }
     }
    }
   } else {
    r.tidyDepFiles[val9].(proptools.CustomHash).CustomHash(hasher)
   }
  }
 }
 hasher.WriteString(":cc.android.Paths")
 hasher.WriteString(":.[]Path")
 hasher.WriteInt(len(r.coverageFiles))
 for val13 := 0; val13 < len(r.coverageFiles); val13++ {
  hasher.WriteString("android/soong/android:android.Path")
  val14 := r.coverageFiles[val13] == nil
  if val14 {
   hasher.WriteByte(0)
  } else {
   if v := reflect.ValueOf(r.coverageFiles[val13]); v.Kind() == reflect.Ptr {
    if v.IsNil() {
     panic(fmt.Errorf("nil pointer is not supported in interface"))
    } else {
     val15 := r.coverageFiles[val13] == nil
     if val15 {
      hasher.WriteByte(0)
     } else {
      val16 := func(hasher *proptools.Hasher) error {
       return r.coverageFiles[val13].(proptools.CustomHash).CustomHash(hasher)
      }
      if err := proptools.HashReference(hasher, uintptr(v.Pointer()), val16); err != nil {
       return err
      }
     }
    }
   } else {
    r.coverageFiles[val13].(proptools.CustomHash).CustomHash(hasher)
   }
  }
 }
 hasher.WriteString(":cc.android.Paths")
 hasher.WriteString(":.[]Path")
 hasher.WriteInt(len(r.sAbiDumpFiles))
 for val17 := 0; val17 < len(r.sAbiDumpFiles); val17++ {
  hasher.WriteString("android/soong/android:android.Path")
  val18 := r.sAbiDumpFiles[val17] == nil
  if val18 {
   hasher.WriteByte(0)
  } else {
   if v := reflect.ValueOf(r.sAbiDumpFiles[val17]); v.Kind() == reflect.Ptr {
    if v.IsNil() {
     panic(fmt.Errorf("nil pointer is not supported in interface"))
    } else {
     val19 := r.sAbiDumpFiles[val17] == nil
     if val19 {
      hasher.WriteByte(0)
     } else {
      val20 := func(hasher *proptools.Hasher) error {
       return r.sAbiDumpFiles[val17].(proptools.CustomHash).CustomHash(hasher)
      }
      if err := proptools.HashReference(hasher, uintptr(v.Pointer()), val20); err != nil {
       return err
      }
     }
    }
   } else {
    r.sAbiDumpFiles[val17].(proptools.CustomHash).CustomHash(hasher)
   }
  }
 }
 hasher.WriteString(":cc.KytheFilePairs")
 hasher.WriteString(":.[]KytheFilePair")
 hasher.WriteInt(len(r.kytheFiles))
 for val21 := 0; val21 < len(r.kytheFiles); val21++ {
  if err := r.kytheFiles[val21].CustomHash(hasher); err != nil {
   return err
  }
 }
 return nil
}

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

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

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

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

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

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

 return err
}

var ObjectsGobRegId int16

func (r Objects) GetTypeId() int16 {
 return ObjectsGobRegId
}

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

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

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

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

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

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

 return err
}

var KytheFilePairGobRegId int16

func (r KytheFilePair) GetTypeId() int16 {
 return KytheFilePairGobRegId
}

// end of builder.go

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

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

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

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

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

func (r CcMakeVarsInfo) CustomHash(hasher *proptools.Hasher) error {
 hasher.WriteString(":cc.CcMakeVarsInfo")
 hasher.WriteInt(3)
 hasher.WriteString(":.string")
 hasher.WriteString(r.WarningsAllowed)
 hasher.WriteString(":.string")
 hasher.WriteString(r.UsingWnoError)
 hasher.WriteString(":.string")
 hasher.WriteString(r.MissingProfile)
 return nil
}

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

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

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

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

 return err
}

var CcMakeVarsInfoGobRegId int16

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

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

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

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

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

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

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

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

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

 return err
}

var CcObjectInfoGobRegId int16

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

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

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

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

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

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

func (r AidlInterfaceInfo) CustomHash(hasher *proptools.Hasher) error {
 hasher.WriteString(":cc.AidlInterfaceInfo")
 hasher.WriteInt(4)
 hasher.WriteString(":.[]string")
 hasher.WriteInt(len(r.Sources))
 for val1 := 0; val1 < len(r.Sources); val1++ {
  hasher.WriteString(":.string")
  hasher.WriteString(r.Sources[val1])
 }
 hasher.WriteString(":.string")
 hasher.WriteString(r.AidlRoot)
 hasher.WriteString(":.string")
 hasher.WriteString(r.Lang)
 hasher.WriteString(":.[]string")
 hasher.WriteInt(len(r.Flags))
 for val2 := 0; val2 < len(r.Flags); val2++ {
  hasher.WriteString(":.string")
  hasher.WriteString(r.Flags[val2])
 }
 return nil
}

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

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

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

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

 return err
}

var AidlInterfaceInfoGobRegId int16

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

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

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

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

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

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

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

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

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

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

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

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

 return err
}

var CompilerInfoGobRegId int16

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

func (r LinkerInfo) CustomHash(hasher *proptools.Hasher) error {
 hasher.WriteString(":cc.LinkerInfo")
 hasher.WriteInt(13)
 hasher.WriteString(":.[]string")
 hasher.WriteInt(len(r.WholeStaticLibs))
 for val1 := 0; val1 < len(r.WholeStaticLibs); val1++ {
  hasher.WriteString(":.string")
  hasher.WriteString(r.WholeStaticLibs[val1])
 }
 hasher.WriteString(":.[]string")
 hasher.WriteInt(len(r.StaticLibs))
 for val2 := 0; val2 < len(r.StaticLibs); val2++ {
  hasher.WriteString(":.string")
  hasher.WriteString(r.StaticLibs[val2])
 }
 hasher.WriteString(":.[]string")
 hasher.WriteInt(len(r.SharedLibs))
 for val3 := 0; val3 < len(r.SharedLibs); val3++ {
  hasher.WriteString(":.string")
  hasher.WriteString(r.SharedLibs[val3])
 }
 hasher.WriteString(":.[]string")
 hasher.WriteInt(len(r.HeaderLibs))
 for val4 := 0; val4 < len(r.HeaderLibs); val4++ {
  hasher.WriteString(":.string")
  hasher.WriteString(r.HeaderLibs[val4])
 }
 hasher.WriteString(":.[]string")
 hasher.WriteInt(len(r.SystemSharedLibs))
 for val5 := 0; val5 < len(r.SystemSharedLibs); val5++ {
  hasher.WriteString(":.string")
  hasher.WriteString(r.SystemSharedLibs[val5])
 }
 hasher.WriteString(":.*string")
 val6 := r.ImplementationModuleName == nil
 if val6 {
  hasher.WriteByte(0)
 } else {
  val7 := func(hasher *proptools.Hasher) error {
   hasher.WriteString(":.string")
   hasher.WriteString((*r.ImplementationModuleName))
   return nil
  }
  if err := proptools.HashReference(hasher, uintptr(unsafe.Pointer(r.ImplementationModuleName)), val7); err != nil {
   return err
  }
 }
 hasher.WriteString(":.*BinaryDecoratorInfo")
 val8 := r.BinaryDecoratorInfo == nil
 if val8 {
  hasher.WriteByte(0)
 } else {
  val9 := func(hasher *proptools.Hasher) error {
   if err := (*r.BinaryDecoratorInfo).CustomHash(hasher); err != nil {
    return err
   }
   return nil
  }
  if err := proptools.HashReference(hasher, uintptr(unsafe.Pointer(r.BinaryDecoratorInfo)), val9); err != nil {
   return err
  }
 }
 hasher.WriteString(":.*LibraryDecoratorInfo")
 val10 := r.LibraryDecoratorInfo == nil
 if val10 {
  hasher.WriteByte(0)
 } else {
  val11 := func(hasher *proptools.Hasher) error {
   if err := (*r.LibraryDecoratorInfo).CustomHash(hasher); err != nil {
    return err
   }
   return nil
  }
  if err := proptools.HashReference(hasher, uintptr(unsafe.Pointer(r.LibraryDecoratorInfo)), val11); err != nil {
   return err
  }
 }
 hasher.WriteString(":.*TestBinaryInfo")
 val12 := r.TestBinaryInfo == nil
 if val12 {
  hasher.WriteByte(0)
 } else {
  val13 := func(hasher *proptools.Hasher) error {
   if err := (*r.TestBinaryInfo).CustomHash(hasher); err != nil {
    return err
   }
   return nil
  }
  if err := proptools.HashReference(hasher, uintptr(unsafe.Pointer(r.TestBinaryInfo)), val13); err != nil {
   return err
  }
 }
 hasher.WriteString(":.*BenchmarkDecoratorInfo")
 val14 := r.BenchmarkDecoratorInfo == nil
 if val14 {
  hasher.WriteByte(0)
 } else {
  val15 := func(hasher *proptools.Hasher) error {
   if err := (*r.BenchmarkDecoratorInfo).CustomHash(hasher); err != nil {
    return err
   }
   return nil
  }
  if err := proptools.HashReference(hasher, uintptr(unsafe.Pointer(r.BenchmarkDecoratorInfo)), val15); err != nil {
   return err
  }
 }
 hasher.WriteString(":.*ObjectLinkerInfo")
 val16 := r.ObjectLinkerInfo == nil
 if val16 {
  hasher.WriteByte(0)
 } else {
  val17 := func(hasher *proptools.Hasher) error {
   if err := (*r.ObjectLinkerInfo).CustomHash(hasher); err != nil {
    return err
   }
   return nil
  }
  if err := proptools.HashReference(hasher, uintptr(unsafe.Pointer(r.ObjectLinkerInfo)), val17); err != nil {
   return err
  }
 }
 hasher.WriteString(":.*StubDecoratorInfo")
 val18 := r.StubDecoratorInfo == nil
 if val18 {
  hasher.WriteByte(0)
 } else {
  val19 := func(hasher *proptools.Hasher) error {
   if err := (*r.StubDecoratorInfo).CustomHash(hasher); err != nil {
    return err
   }
   return nil
  }
  if err := proptools.HashReference(hasher, uintptr(unsafe.Pointer(r.StubDecoratorInfo)), val19); err != nil {
   return err
  }
 }
 hasher.WriteString(":.*PrebuiltLibraryLinkerInfo")
 val20 := r.PrebuiltLibraryLinkerInfo == nil
 if val20 {
  hasher.WriteByte(0)
 } else {
  val21 := func(hasher *proptools.Hasher) error {
   if err := (*r.PrebuiltLibraryLinkerInfo).CustomHash(hasher); err != nil {
    return err
   }
   return nil
  }
  if err := proptools.HashReference(hasher, uintptr(unsafe.Pointer(r.PrebuiltLibraryLinkerInfo)), val21); err != nil {
   return err
  }
 }
 return nil
}

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

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

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

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

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

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

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

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

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

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

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

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

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

 return err
}

var LinkerInfoGobRegId int16

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

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

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

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

func (r BinaryDecoratorInfo) CustomHash(hasher *proptools.Hasher) error {
 hasher.WriteString(":cc.BinaryDecoratorInfo")
 hasher.WriteInt(2)
 hasher.WriteString(":.bool")
 if r.StaticExecutable {
  hasher.WriteByte(1)
 } else {
  hasher.WriteByte(0)
 }
 hasher.WriteString(":.bool")
 if r.Nocrt {
  hasher.WriteByte(1)
 } else {
  hasher.WriteByte(0)
 }
 return nil
}

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

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

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

 return err
}

var BinaryDecoratorInfoGobRegId int16

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

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

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

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

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

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

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

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

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

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

func (r LibraryDecoratorInfo) CustomHash(hasher *proptools.Hasher) error {
 hasher.WriteString(":cc.LibraryDecoratorInfo")
 hasher.WriteInt(8)
 hasher.WriteString(":.[]string")
 hasher.WriteInt(len(r.ExportIncludeDirs))
 for val1 := 0; val1 < len(r.ExportIncludeDirs); val1++ {
  hasher.WriteString(":.string")
  hasher.WriteString(r.ExportIncludeDirs[val1])
 }
 hasher.WriteString(":.bool")
 if r.InjectBsslHash {
  hasher.WriteByte(1)
 } else {
  hasher.WriteByte(0)
 }
 hasher.WriteString(":cc.android.Path")
 val2 := r.NdkSysrootPath == nil
 if val2 {
  hasher.WriteByte(0)
 } else {
  if v := reflect.ValueOf(r.NdkSysrootPath); v.Kind() == reflect.Ptr {
   if v.IsNil() {
    panic(fmt.Errorf("nil pointer is not supported in interface"))
   } else {
    val3 := r.NdkSysrootPath == nil
    if val3 {
     hasher.WriteByte(0)
    } else {
     val4 := func(hasher *proptools.Hasher) error {
      return r.NdkSysrootPath.(proptools.CustomHash).CustomHash(hasher)
     }
     if err := proptools.HashReference(hasher, uintptr(v.Pointer()), val4); err != nil {
      return err
     }
    }
   }
  } else {
   r.NdkSysrootPath.(proptools.CustomHash).CustomHash(hasher)
  }
 }
 hasher.WriteString(":.string")
 hasher.WriteString(r.VndkFileName)
 hasher.WriteString(":.*bool")
 val5 := r.UniqueHostSoname == nil
 if val5 {
  hasher.WriteByte(0)
 } else {
  val6 := func(hasher *proptools.Hasher) error {
   hasher.WriteString(":.bool")
   if *r.UniqueHostSoname {
    hasher.WriteByte(1)
   } else {
    hasher.WriteByte(0)
   }
   return nil
  }
  if err := proptools.HashReference(hasher, uintptr(unsafe.Pointer(r.UniqueHostSoname)), val6); err != nil {
   return err
  }
 }
 hasher.WriteString(":.[]string")
 hasher.WriteInt(len(r.SharedLibs))
 for val7 := 0; val7 < len(r.SharedLibs); val7++ {
  hasher.WriteString(":.string")
  hasher.WriteString(r.SharedLibs[val7])
 }
 hasher.WriteString(":.[]string")
 hasher.WriteInt(len(r.SystemSharedLibs))
 for val8 := 0; val8 < len(r.SystemSharedLibs); val8++ {
  hasher.WriteString(":.string")
  hasher.WriteString(r.SystemSharedLibs[val8])
 }
 hasher.WriteString(":cc.android.Path")
 val9 := r.StubsSymbolFilePath == nil
 if val9 {
  hasher.WriteByte(0)
 } else {
  if v := reflect.ValueOf(r.StubsSymbolFilePath); v.Kind() == reflect.Ptr {
   if v.IsNil() {
    panic(fmt.Errorf("nil pointer is not supported in interface"))
   } else {
    val10 := r.StubsSymbolFilePath == nil
    if val10 {
     hasher.WriteByte(0)
    } else {
     val11 := func(hasher *proptools.Hasher) error {
      return r.StubsSymbolFilePath.(proptools.CustomHash).CustomHash(hasher)
     }
     if err := proptools.HashReference(hasher, uintptr(v.Pointer()), val11); err != nil {
      return err
     }
    }
   }
  } else {
   r.StubsSymbolFilePath.(proptools.CustomHash).CustomHash(hasher)
  }
 }
 return nil
}

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

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

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

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

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

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

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

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

 return err
}

var LibraryDecoratorInfoGobRegId int16

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

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

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

func (r SnapshotInfo) CustomHash(hasher *proptools.Hasher) error {
 hasher.WriteString(":cc.SnapshotInfo")
 hasher.WriteInt(1)
 hasher.WriteString(":.string")
 hasher.WriteString(r.SnapshotAndroidMkSuffix)
 return nil
}

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

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

 return err
}

var SnapshotInfoGobRegId int16

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

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

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

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

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

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

 return err
}

var TestBinaryInfoGobRegId int16

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

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

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

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

 return err
}

var BenchmarkDecoratorInfoGobRegId int16

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

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

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

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

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

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

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

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

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

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

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

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

 return err
}

var StubDecoratorInfoGobRegId int16

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

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

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

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

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

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

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

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

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

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

 return err
}

var ObjectLinkerInfoGobRegId int16

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

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

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

func (r PrebuiltLibraryLinkerInfo) CustomHash(hasher *proptools.Hasher) error {
 hasher.WriteString(":cc.PrebuiltLibraryLinkerInfo")
 hasher.WriteInt(1)
 hasher.WriteString(":.string")
 hasher.WriteString(r.VndkFileName)
 return nil
}

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

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

 return err
}

var PrebuiltLibraryLinkerInfoGobRegId int16

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

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

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

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

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

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

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

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

 return err
}

var LibraryInfoGobRegId int16

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

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

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

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

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

 return err
}

var InstallerInfoGobRegId int16

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

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

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

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

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

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

func (r LocalOrGlobalFlagsInfo) CustomHash(hasher *proptools.Hasher) error {
 hasher.WriteString(":cc.LocalOrGlobalFlagsInfo")
 hasher.WriteInt(4)
 hasher.WriteString(":.[]string")
 hasher.WriteInt(len(r.CommonFlags))
 for val1 := 0; val1 < len(r.CommonFlags); val1++ {
  hasher.WriteString(":.string")
  hasher.WriteString(r.CommonFlags[val1])
 }
 hasher.WriteString(":.[]string")
 hasher.WriteInt(len(r.CFlags))
 for val2 := 0; val2 < len(r.CFlags); val2++ {
  hasher.WriteString(":.string")
  hasher.WriteString(r.CFlags[val2])
 }
 hasher.WriteString(":.[]string")
 hasher.WriteInt(len(r.ConlyFlags))
 for val3 := 0; val3 < len(r.ConlyFlags); val3++ {
  hasher.WriteString(":.string")
  hasher.WriteString(r.ConlyFlags[val3])
 }
 hasher.WriteString(":.[]string")
 hasher.WriteInt(len(r.CppFlags))
 for val4 := 0; val4 < len(r.CppFlags); val4++ {
  hasher.WriteString(":.string")
  hasher.WriteString(r.CppFlags[val4])
 }
 return nil
}

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

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

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

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

 return err
}

var LocalOrGlobalFlagsInfoGobRegId int16

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

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

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

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

func (r SanitizeInfo) CustomHash(hasher *proptools.Hasher) error {
 hasher.WriteString(":cc.SanitizeInfo")
 hasher.WriteInt(2)
 hasher.WriteString(":.bool")
 if r.IsUnsanitizedVariant {
  hasher.WriteByte(1)
 } else {
  hasher.WriteByte(0)
 }
 if err := r.Sanitize.CustomHash(hasher); err != nil {
  return err
 }
 return nil
}

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

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

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

 return err
}

var SanitizeInfoGobRegId int16

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

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

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

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

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

 return err
}

var StlInfoGobRegId int16

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

func (r CcInfo) CustomHash(hasher *proptools.Hasher) error {
 hasher.WriteString(":cc.CcInfo")
 hasher.WriteInt(21)
 hasher.WriteString(":.bool")
 if r.IsPrebuilt {
  hasher.WriteByte(1)
 } else {
  hasher.WriteByte(0)
 }
 hasher.WriteString(":.bool")
 if r.CmakeSnapshotSupported {
  hasher.WriteByte(1)
 } else {
  hasher.WriteByte(0)
 }
 hasher.WriteString(":.bool")
 if r.HasLlndkStubs {
  hasher.WriteByte(1)
 } else {
  hasher.WriteByte(0)
 }
 hasher.WriteString(":.[]android.DataPath")
 hasher.WriteInt(len(r.DataPaths))
 for val1 := 0; val1 < len(r.DataPaths); val1++ {
  if err := r.DataPaths[val1].CustomHash(hasher); err != nil {
   return err
  }
 }
 hasher.WriteString(":.bool")
 if r.VendorAvailable {
  hasher.WriteByte(1)
 } else {
  hasher.WriteByte(0)
 }
 hasher.WriteString(":.bool")
 if r.OdmAvailable {
  hasher.WriteByte(1)
 } else {
  hasher.WriteByte(0)
 }
 hasher.WriteString(":.bool")
 if r.ProductAvailable {
  hasher.WriteByte(1)
 } else {
  hasher.WriteByte(0)
 }
 hasher.WriteString(":.bool")
 if r.IsVendorPublicLibrary {
  hasher.WriteByte(1)
 } else {
  hasher.WriteByte(0)
 }
 hasher.WriteString(":.string")
 hasher.WriteString(r.NotDoubleLoadableReason)
 hasher.WriteString(":.[]android.SdkMemberType")
 hasher.WriteInt(len(r.SdkMemberTypes))
 for val2 := 0; val2 < len(r.SdkMemberTypes); val2++ {
  hasher.WriteString(":cc.android.SdkMemberType")
  val3 := r.SdkMemberTypes[val2] == nil
  if val3 {
   hasher.WriteByte(0)
  } else {
   if v := reflect.ValueOf(r.SdkMemberTypes[val2]); v.Kind() == reflect.Ptr {
    if v.IsNil() {
     panic(fmt.Errorf("nil pointer is not supported in interface"))
    } else {
     val4 := r.SdkMemberTypes[val2] == nil
     if val4 {
      hasher.WriteByte(0)
     } else {
      val5 := func(hasher *proptools.Hasher) error {
       return r.SdkMemberTypes[val2].(proptools.CustomHash).CustomHash(hasher)
      }
      if err := proptools.HashReference(hasher, uintptr(v.Pointer()), val5); err != nil {
       return err
      }
     }
    }
   } else {
    r.SdkMemberTypes[val2].(proptools.CustomHash).CustomHash(hasher)
   }
  }
 }
 if err := r.LocalFlags.CustomHash(hasher); err != nil {
  return err
 }
 if err := r.GlobalFlags.CustomHash(hasher); err != nil {
  return err
 }
 hasher.WriteString(":.[]string")
 hasher.WriteInt(len(r.SystemIncludeFlags))
 for val6 := 0; val6 < len(r.SystemIncludeFlags); val6++ {
  hasher.WriteString(":.string")
  hasher.WriteString(r.SystemIncludeFlags[val6])
 }
 hasher.WriteString(":.[]string")
 hasher.WriteInt(len(r.NoOverrideFlags))
 for val7 := 0; val7 < len(r.NoOverrideFlags); val7++ {
  hasher.WriteString(":.string")
  hasher.WriteString(r.NoOverrideFlags[val7])
 }
 hasher.WriteString(":.*CompilerInfo")
 val8 := r.CompilerInfo == nil
 if val8 {
  hasher.WriteByte(0)
 } else {
  val9 := func(hasher *proptools.Hasher) error {
   if err := (*r.CompilerInfo).CustomHash(hasher); err != nil {
    return err
   }
   return nil
  }
  if err := proptools.HashReference(hasher, uintptr(unsafe.Pointer(r.CompilerInfo)), val9); err != nil {
   return err
  }
 }
 hasher.WriteString(":.*LinkerInfo")
 val10 := r.LinkerInfo == nil
 if val10 {
  hasher.WriteByte(0)
 } else {
  val11 := func(hasher *proptools.Hasher) error {
   if err := (*r.LinkerInfo).CustomHash(hasher); err != nil {
    return err
   }
   return nil
  }
  if err := proptools.HashReference(hasher, uintptr(unsafe.Pointer(r.LinkerInfo)), val11); err != nil {
   return err
  }
 }
 hasher.WriteString(":.*SnapshotInfo")
 val12 := r.SnapshotInfo == nil
 if val12 {
  hasher.WriteByte(0)
 } else {
  val13 := func(hasher *proptools.Hasher) error {
   if err := (*r.SnapshotInfo).CustomHash(hasher); err != nil {
    return err
   }
   return nil
  }
  if err := proptools.HashReference(hasher, uintptr(unsafe.Pointer(r.SnapshotInfo)), val13); err != nil {
   return err
  }
 }
 hasher.WriteString(":.*LibraryInfo")
 val14 := r.LibraryInfo == nil
 if val14 {
  hasher.WriteByte(0)
 } else {
  val15 := func(hasher *proptools.Hasher) error {
   if err := (*r.LibraryInfo).CustomHash(hasher); err != nil {
    return err
   }
   return nil
  }
  if err := proptools.HashReference(hasher, uintptr(unsafe.Pointer(r.LibraryInfo)), val15); err != nil {
   return err
  }
 }
 hasher.WriteString(":.*InstallerInfo")
 val16 := r.InstallerInfo == nil
 if val16 {
  hasher.WriteByte(0)
 } else {
  val17 := func(hasher *proptools.Hasher) error {
   if err := (*r.InstallerInfo).CustomHash(hasher); err != nil {
    return err
   }
   return nil
  }
  if err := proptools.HashReference(hasher, uintptr(unsafe.Pointer(r.InstallerInfo)), val17); err != nil {
   return err
  }
 }
 hasher.WriteString(":.*StlInfo")
 val18 := r.StlInfo == nil
 if val18 {
  hasher.WriteByte(0)
 } else {
  val19 := func(hasher *proptools.Hasher) error {
   if err := (*r.StlInfo).CustomHash(hasher); err != nil {
    return err
   }
   return nil
  }
  if err := proptools.HashReference(hasher, uintptr(unsafe.Pointer(r.StlInfo)), val19); err != nil {
   return err
  }
 }
 hasher.WriteString(":.*SanitizeInfo")
 val20 := r.SanitizeInfo == nil
 if val20 {
  hasher.WriteByte(0)
 } else {
  val21 := func(hasher *proptools.Hasher) error {
   if err := (*r.SanitizeInfo).CustomHash(hasher); err != nil {
    return err
   }
   return nil
  }
  if err := proptools.HashReference(hasher, uintptr(unsafe.Pointer(r.SanitizeInfo)), val21); err != nil {
   return err
  }
 }
 return nil
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

 return err
}

var CcInfoGobRegId int16

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

func (r LinkableInfo) CustomHash(hasher *proptools.Hasher) error {
 hasher.WriteString(":cc.LinkableInfo")
 hasher.WriteInt(52)
 hasher.WriteString(":.bool")
 if r.StaticExecutable {
  hasher.WriteByte(1)
 } else {
  hasher.WriteByte(0)
 }
 hasher.WriteString(":.bool")
 if r.Static {
  hasher.WriteByte(1)
 } else {
  hasher.WriteByte(0)
 }
 hasher.WriteString(":.bool")
 if r.Shared {
  hasher.WriteByte(1)
 } else {
  hasher.WriteByte(0)
 }
 hasher.WriteString(":.bool")
 if r.Rlib {
  hasher.WriteByte(1)
 } else {
  hasher.WriteByte(0)
 }
 hasher.WriteString(":.bool")
 if r.Header {
  hasher.WriteByte(1)
 } else {
  hasher.WriteByte(0)
 }
 hasher.WriteString(":.bool")
 if r.HasStubsVariants {
  hasher.WriteByte(1)
 } else {
  hasher.WriteByte(0)
 }
 hasher.WriteString(":.string")
 hasher.WriteString(r.StubsVersion)
 hasher.WriteString(":.bool")
 if r.IsStubs {
  hasher.WriteByte(1)
 } else {
  hasher.WriteByte(0)
 }
 hasher.WriteString(":cc.android.Path")
 val1 := r.UnstrippedOutputFile == nil
 if val1 {
  hasher.WriteByte(0)
 } else {
  if v := reflect.ValueOf(r.UnstrippedOutputFile); v.Kind() == reflect.Ptr {
   if v.IsNil() {
    panic(fmt.Errorf("nil pointer is not supported in interface"))
   } else {
    val2 := r.UnstrippedOutputFile == nil
    if val2 {
     hasher.WriteByte(0)
    } else {
     val3 := func(hasher *proptools.Hasher) error {
      return r.UnstrippedOutputFile.(proptools.CustomHash).CustomHash(hasher)
     }
     if err := proptools.HashReference(hasher, uintptr(v.Pointer()), val3); err != nil {
      return err
     }
    }
   }
  } else {
   r.UnstrippedOutputFile.(proptools.CustomHash).CustomHash(hasher)
  }
 }
 if err := r.OutputFile.CustomHash(hasher); err != nil {
  return err
 }
 hasher.WriteString(":cc.android.Paths")
 hasher.WriteString(":.[]Path")
 hasher.WriteInt(len(r.CoverageFiles))
 for val4 := 0; val4 < len(r.CoverageFiles); val4++ {
  hasher.WriteString("android/soong/android:android.Path")
  val5 := r.CoverageFiles[val4] == nil
  if val5 {
   hasher.WriteByte(0)
  } else {
   if v := reflect.ValueOf(r.CoverageFiles[val4]); v.Kind() == reflect.Ptr {
    if v.IsNil() {
     panic(fmt.Errorf("nil pointer is not supported in interface"))
    } else {
     val6 := r.CoverageFiles[val4] == nil
     if val6 {
      hasher.WriteByte(0)
     } else {
      val7 := func(hasher *proptools.Hasher) error {
       return r.CoverageFiles[val4].(proptools.CustomHash).CustomHash(hasher)
      }
      if err := proptools.HashReference(hasher, uintptr(v.Pointer()), val7); err != nil {
       return err
      }
     }
    }
   } else {
    r.CoverageFiles[val4].(proptools.CustomHash).CustomHash(hasher)
   }
  }
 }
 if err := r.CoverageOutputFile.CustomHash(hasher); err != nil {
  return err
 }
 hasher.WriteString(":.bool")
 if r.LinkCoverage {
  hasher.WriteByte(1)
 } else {
  hasher.WriteByte(0)
 }
 hasher.WriteString(":cc.android.Paths")
 hasher.WriteString(":.[]Path")
 hasher.WriteInt(len(r.SAbiDumpFiles))
 for val8 := 0; val8 < len(r.SAbiDumpFiles); val8++ {
  hasher.WriteString("android/soong/android:android.Path")
  val9 := r.SAbiDumpFiles[val8] == nil
  if val9 {
   hasher.WriteByte(0)
  } else {
   if v := reflect.ValueOf(r.SAbiDumpFiles[val8]); v.Kind() == reflect.Ptr {
    if v.IsNil() {
     panic(fmt.Errorf("nil pointer is not supported in interface"))
    } else {
     val10 := r.SAbiDumpFiles[val8] == nil
     if val10 {
      hasher.WriteByte(0)
     } else {
      val11 := func(hasher *proptools.Hasher) error {
       return r.SAbiDumpFiles[val8].(proptools.CustomHash).CustomHash(hasher)
      }
      if err := proptools.HashReference(hasher, uintptr(v.Pointer()), val11); err != nil {
       return err
      }
     }
    }
   } else {
    r.SAbiDumpFiles[val8].(proptools.CustomHash).CustomHash(hasher)
   }
  }
 }
 hasher.WriteString(":.string")
 hasher.WriteString(r.Partition)
 hasher.WriteString(":.bool")
 if r.CcLibrary {
  hasher.WriteByte(1)
 } else {
  hasher.WriteByte(0)
 }
 hasher.WriteString(":.bool")
 if r.CcLibraryInterface {
  hasher.WriteByte(1)
 } else {
  hasher.WriteByte(0)
 }
 hasher.WriteString(":.bool")
 if r.RustLibraryInterface {
  hasher.WriteByte(1)
 } else {
  hasher.WriteByte(0)
 }
 hasher.WriteString(":.string")
 hasher.WriteString(r.CrateName)
 hasher.WriteString(":.[]string")
 hasher.WriteInt(len(r.ExportedCrateLinkDirs))
 for val12 := 0; val12 < len(r.ExportedCrateLinkDirs); val12++ {
  hasher.WriteString(":.string")
  hasher.WriteString(r.ExportedCrateLinkDirs[val12])
 }
 hasher.WriteString(":.[]android.Path")
 hasher.WriteInt(len(r.ExportedCrateLinkDirsDeps))
 for val13 := 0; val13 < len(r.ExportedCrateLinkDirsDeps); val13++ {
  hasher.WriteString(":cc.android.Path")
  val14 := r.ExportedCrateLinkDirsDeps[val13] == nil
  if val14 {
   hasher.WriteByte(0)
  } else {
   if v := reflect.ValueOf(r.ExportedCrateLinkDirsDeps[val13]); v.Kind() == reflect.Ptr {
    if v.IsNil() {
     panic(fmt.Errorf("nil pointer is not supported in interface"))
    } else {
     val15 := r.ExportedCrateLinkDirsDeps[val13] == nil
     if val15 {
      hasher.WriteByte(0)
     } else {
      val16 := func(hasher *proptools.Hasher) error {
       return r.ExportedCrateLinkDirsDeps[val13].(proptools.CustomHash).CustomHash(hasher)
      }
      if err := proptools.HashReference(hasher, uintptr(v.Pointer()), val16); err != nil {
       return err
      }
     }
    }
   } else {
    r.ExportedCrateLinkDirsDeps[val13].(proptools.CustomHash).CustomHash(hasher)
   }
  }
 }
 hasher.WriteString(":.bool")
 if r.HasNonSystemVariants {
  hasher.WriteByte(1)
 } else {
  hasher.WriteByte(0)
 }
 hasher.WriteString(":.bool")
 if r.IsLlndk {
  hasher.WriteByte(1)
 } else {
  hasher.WriteByte(0)
 }
 hasher.WriteString(":.bool")
 if r.IsNdk {
  hasher.WriteByte(1)
 } else {
  hasher.WriteByte(0)
 }
 hasher.WriteString(":.bool")
 if r.InVendorOrProduct {
  hasher.WriteByte(1)
 } else {
  hasher.WriteByte(0)
 }
 hasher.WriteString(":.string")
 hasher.WriteString(r.SubName)
 hasher.WriteString(":.bool")
 if r.IsHwasan {
  hasher.WriteByte(1)
 } else {
  hasher.WriteByte(0)
 }
 hasher.WriteString(":.bool")
 if r.InRamdisk {
  hasher.WriteByte(1)
 } else {
  hasher.WriteByte(0)
 }
 hasher.WriteString(":.bool")
 if r.OnlyInRamdisk {
  hasher.WriteByte(1)
 } else {
  hasher.WriteByte(0)
 }
 hasher.WriteString(":.bool")
 if r.InVendorRamdisk {
  hasher.WriteByte(1)
 } else {
  hasher.WriteByte(0)
 }
 hasher.WriteString(":.bool")
 if r.OnlyInVendorRamdisk {
  hasher.WriteByte(1)
 } else {
  hasher.WriteByte(0)
 }
 hasher.WriteString(":.bool")
 if r.InRecovery {
  hasher.WriteByte(1)
 } else {
  hasher.WriteByte(0)
 }
 hasher.WriteString(":.bool")
 if r.OnlyInRecovery {
  hasher.WriteByte(1)
 } else {
  hasher.WriteByte(0)
 }
 hasher.WriteString(":.bool")
 if r.InVendor {
  hasher.WriteByte(1)
 } else {
  hasher.WriteByte(0)
 }
 hasher.WriteString(":.*bool")
 val17 := r.Installable == nil
 if val17 {
  hasher.WriteByte(0)
 } else {
  val18 := func(hasher *proptools.Hasher) error {
   hasher.WriteString(":.bool")
   if *r.Installable {
    hasher.WriteByte(1)
   } else {
    hasher.WriteByte(0)
   }
   return nil
  }
  if err := proptools.HashReference(hasher, uintptr(unsafe.Pointer(r.Installable)), val18); err != nil {
   return err
  }
 }
 hasher.WriteString(":.string")
 hasher.WriteString(r.RelativeInstallPath)
 hasher.WriteString(":.bool")
 if r.RustApexExclude {
  hasher.WriteByte(1)
 } else {
  hasher.WriteByte(0)
 }
 hasher.WriteString(":.bool")
 if r.Bootstrap {
  hasher.WriteByte(1)
 } else {
  hasher.WriteByte(0)
 }
 hasher.WriteString(":.string")
 hasher.WriteString(r.Multilib)
 hasher.WriteString(":.string")
 hasher.WriteString(r.ImplementationModuleNameForMake)
 hasher.WriteString(":.bool")
 if r.IsStubsImplementationRequired {
  hasher.WriteByte(1)
 } else {
  hasher.WriteByte(0)
 }
 hasher.WriteString(":.[]string")
 hasher.WriteInt(len(r.Symlinks))
 for val19 := 0; val19 < len(r.Symlinks); val19++ {
  hasher.WriteString(":.string")
  hasher.WriteString(r.Symlinks[val19])
 }
 if err := r.APIListCoverageXMLPath.CustomHash(hasher); err != nil {
  return err
 }
 hasher.WriteString(":cc.InstallPairs")
 hasher.WriteString(":.[]InstallPair")
 hasher.WriteInt(len(r.FuzzSharedLibraries))
 for val20 := 0; val20 < len(r.FuzzSharedLibraries); val20++ {
  if err := r.FuzzSharedLibraries[val20].CustomHash(hasher); err != nil {
   return err
  }
 }
 val22 := func(hasher *proptools.Hasher, val21 FuzzLibraryInstall) error {
  if err := val21.CustomHash(hasher); err != nil {
   return err
  }
  return nil
 }
 if err := r.FuzzDependencies.Hash(hasher, "FuzzLibraryInstall", val22); err != nil {
  return err
 }
 hasher.WriteString(":.bool")
 if r.IsVndkPrebuiltLibrary {
  hasher.WriteByte(1)
 } else {
  hasher.WriteByte(0)
 }
 hasher.WriteString(":.bool")
 if r.HasLLNDKStubs {
  hasher.WriteByte(1)
 } else {
  hasher.WriteByte(0)
 }
 hasher.WriteString(":.bool")
 if r.IsLLNDKMovedToApex {
  hasher.WriteByte(1)
 } else {
  hasher.WriteByte(0)
 }
 hasher.WriteString(":.string")
 hasher.WriteString(r.ImplementationModuleName)
 hasher.WriteString(":.string")
 hasher.WriteString(r.SelectedStl)
 hasher.WriteString(":.*bool")
 val23 := r.Xom == nil
 if val23 {
  hasher.WriteByte(0)
 } else {
  val24 := func(hasher *proptools.Hasher) error {
   hasher.WriteString(":.bool")
   if *r.Xom {
    hasher.WriteByte(1)
   } else {
    hasher.WriteByte(0)
   }
   return nil
  }
  if err := proptools.HashReference(hasher, uintptr(unsafe.Pointer(r.Xom)), val24); err != nil {
   return err
  }
 }
 hasher.WriteString(":.bool")
 if r.XomDisabledByPath {
  hasher.WriteByte(1)
 } else {
  hasher.WriteByte(0)
 }
 return nil
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

 var val54 bool
 if err = gobtools.DecodeBool(buf, &val54); err != nil {
  return err
 }
 if !val54 {
  var val53 bool
  err = gobtools.DecodeBool(buf, &val53)
  if err != nil {
   return err
  }
  r.Installable = &val53
 }

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

 return err
}

var LinkableInfoGobRegId int16

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

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

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

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

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

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

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

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

 return err
}

var InstallPairGobRegId int16

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

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

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

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

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

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

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

func (r RustRlibDep) CustomHash(hasher *proptools.Hasher) error {
 hasher.WriteString(":cc.RustRlibDep")
 hasher.WriteInt(5)
 hasher.WriteString(":cc.android.Path")
 val1 := r.LibPath == nil
 if val1 {
  hasher.WriteByte(0)
 } else {
  if v := reflect.ValueOf(r.LibPath); v.Kind() == reflect.Ptr {
   if v.IsNil() {
    panic(fmt.Errorf("nil pointer is not supported in interface"))
   } else {
    val2 := r.LibPath == nil
    if val2 {
     hasher.WriteByte(0)
    } else {
     val3 := func(hasher *proptools.Hasher) error { return r.LibPath.(proptools.CustomHash).CustomHash(hasher) }
     if err := proptools.HashReference(hasher, uintptr(v.Pointer()), val3); err != nil {
      return err
     }
    }
   }
  } else {
   r.LibPath.(proptools.CustomHash).CustomHash(hasher)
  }
 }
 hasher.WriteString(":.[]string")
 hasher.WriteInt(len(r.LinkDirs))
 for val4 := 0; val4 < len(r.LinkDirs); val4++ {
  hasher.WriteString(":.string")
  hasher.WriteString(r.LinkDirs[val4])
 }
 hasher.WriteString(":.[]android.Path")
 hasher.WriteInt(len(r.LinkDirsDeps))
 for val5 := 0; val5 < len(r.LinkDirsDeps); val5++ {
  hasher.WriteString(":cc.android.Path")
  val6 := r.LinkDirsDeps[val5] == nil
  if val6 {
   hasher.WriteByte(0)
  } else {
   if v := reflect.ValueOf(r.LinkDirsDeps[val5]); v.Kind() == reflect.Ptr {
    if v.IsNil() {
     panic(fmt.Errorf("nil pointer is not supported in interface"))
    } else {
     val7 := r.LinkDirsDeps[val5] == nil
     if val7 {
      hasher.WriteByte(0)
     } else {
      val8 := func(hasher *proptools.Hasher) error {
       return r.LinkDirsDeps[val5].(proptools.CustomHash).CustomHash(hasher)
      }
      if err := proptools.HashReference(hasher, uintptr(v.Pointer()), val8); err != nil {
       return err
      }
     }
    }
   } else {
    r.LinkDirsDeps[val5].(proptools.CustomHash).CustomHash(hasher)
   }
  }
 }
 hasher.WriteString(":.string")
 hasher.WriteString(r.CrateName)
 hasher.WriteString(":.bool")
 if r.IsHwasan {
  hasher.WriteByte(1)
 } else {
  hasher.WriteByte(0)
 }
 return nil
}

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

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

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

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

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

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

 return err
}

var RustRlibDepGobRegId int16

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

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

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

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

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

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

func (r CcDepInSameApexChecker) CustomHash(hasher *proptools.Hasher) error {
 hasher.WriteString(":cc.CcDepInSameApexChecker")
 hasher.WriteInt(4)
 hasher.WriteString(":.bool")
 if r.Static {
  hasher.WriteByte(1)
 } else {
  hasher.WriteByte(0)
 }
 hasher.WriteString(":.bool")
 if r.HasStubsVariants {
  hasher.WriteByte(1)
 } else {
  hasher.WriteByte(0)
 }
 hasher.WriteString(":.bool")
 if r.IsLlndk {
  hasher.WriteByte(1)
 } else {
  hasher.WriteByte(0)
 }
 hasher.WriteString(":.bool")
 if r.Host {
  hasher.WriteByte(1)
 } else {
  hasher.WriteByte(0)
 }
 return nil
}

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

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

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

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

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

 return err
}

var CcDepInSameApexCheckerGobRegId int16

func (r CcDepInSameApexChecker) GetTypeId() int16 {
 return CcDepInSameApexCheckerGobRegId
}

// end of cc.go

// begin of fdo_profile.go
func init() {
 FdoProfileInfoGobRegId = gobtools.RegisterType(func() gobtools.CustomDec { return new(FdoProfileInfo) })
}

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

func (r FdoProfileInfo) CustomHash(hasher *proptools.Hasher) error {
 hasher.WriteString(":cc.FdoProfileInfo")
 hasher.WriteInt(2)
 hasher.WriteString(":cc.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(":.bool")
 if r.IncompleteCoverage {
  hasher.WriteByte(1)
 } else {
  hasher.WriteByte(0)
 }
 return nil
}

func (r *FdoProfileInfo) 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)
 }

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

 return err
}

var FdoProfileInfoGobRegId int16

func (r FdoProfileInfo) GetTypeId() int16 {
 return FdoProfileInfoGobRegId
}

// end of fdo_profile.go

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

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

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

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

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

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

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

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

func (r FuzzLibraryInstall) CustomHash(hasher *proptools.Hasher) error {
 hasher.WriteString(":cc.FuzzLibraryInstall")
 hasher.WriteInt(6)
 hasher.WriteString(":cc.android.Path")
 val1 := r.Src == nil
 if val1 {
  hasher.WriteByte(0)
 } else {
  if v := reflect.ValueOf(r.Src); v.Kind() == reflect.Ptr {
   if v.IsNil() {
    panic(fmt.Errorf("nil pointer is not supported in interface"))
   } else {
    val2 := r.Src == nil
    if val2 {
     hasher.WriteByte(0)
    } else {
     val3 := func(hasher *proptools.Hasher) error { return r.Src.(proptools.CustomHash).CustomHash(hasher) }
     if err := proptools.HashReference(hasher, uintptr(v.Pointer()), val3); err != nil {
      return err
     }
    }
   }
  } else {
   r.Src.(proptools.CustomHash).CustomHash(hasher)
  }
 }
 hasher.WriteString(":.bool")
 if r.IsFuzzer {
  hasher.WriteByte(1)
 } else {
  hasher.WriteByte(0)
 }
 hasher.WriteString(":.string")
 hasher.WriteString(r.JNIDst)
 if err := r.InstallDst.CustomHash(hasher); err != nil {
  return err
 }
 if err := r.SymbolsDst.CustomHash(hasher); err != nil {
  return err
 }
 hasher.WriteString(":.bool")
 if r.HasSymbolsDst {
  hasher.WriteByte(1)
 } else {
  hasher.WriteByte(0)
 }
 return nil
}

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

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

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

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

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

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

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

 return err
}

var FuzzLibraryInstallGobRegId int16

func (r FuzzLibraryInstall) GetTypeId() int16 {
 return FuzzLibraryInstallGobRegId
}

// end of fuzz.go

// begin of image_sdk_traits.go
func init() {
 imageSdkTraitStructGobRegId = gobtools.RegisterType(func() gobtools.CustomDec { return new(imageSdkTraitStruct) })
}

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

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

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

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

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

 return err
}

var imageSdkTraitStructGobRegId int16

func (r imageSdkTraitStruct) GetTypeId() int16 {
 return imageSdkTraitStructGobRegId
}

// end of image_sdk_traits.go

// begin of lfi.go
func init() {
 lfiInfoGobRegId = gobtools.RegisterType(func() gobtools.CustomDec { return new(lfiInfo) })
}

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

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

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

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

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

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

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

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

 return err
}

var lfiInfoGobRegId int16

func (r lfiInfo) GetTypeId() int16 {
 return lfiInfoGobRegId
}

// end of lfi.go

// begin of library_sdk_member.go
func init() {
 librarySdkMemberTypeGobRegId = gobtools.RegisterType(func() gobtools.CustomDec { return new(librarySdkMemberType) })
}

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

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

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

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

func (r librarySdkMemberType) CustomHash(hasher *proptools.Hasher) error {
 hasher.WriteString(":cc.librarySdkMemberType")
 hasher.WriteInt(3)
 if err := r.SdkMemberTypeBase.CustomHash(hasher); err != nil {
  return err
 }
 hasher.WriteString(":.string")
 hasher.WriteString(r.prebuiltModuleType)
 hasher.WriteString(":.bool")
 if r.noOutputFiles {
  hasher.WriteByte(1)
 } else {
  hasher.WriteByte(0)
 }
 return nil
}

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

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

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

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

 return err
}

var librarySdkMemberTypeGobRegId int16

func (r librarySdkMemberType) GetTypeId() int16 {
 return librarySdkMemberTypeGobRegId
}

// end of library_sdk_member.go

// begin of linkable.go
func init() {
 SharedLibraryInfoGobRegId = gobtools.RegisterType(func() gobtools.CustomDec { return new(SharedLibraryInfo) })
 SharedStubLibraryGobRegId = gobtools.RegisterType(func() gobtools.CustomDec { return new(SharedStubLibrary) })
 SharedLibraryStubsInfoGobRegId = gobtools.RegisterType(func() gobtools.CustomDec { return new(SharedLibraryStubsInfo) })
 StaticLibraryInfoGobRegId = gobtools.RegisterType(func() gobtools.CustomDec { return new(StaticLibraryInfo) })
 HeaderLibraryInfoGobRegId = gobtools.RegisterType(func() gobtools.CustomDec { return new(HeaderLibraryInfo) })
 FlagExporterInfoGobRegId = gobtools.RegisterType(func() gobtools.CustomDec { return new(FlagExporterInfo) })
 ImplementationDepInfoGobRegId = gobtools.RegisterType(func() gobtools.CustomDec { return new(ImplementationDepInfo) })
}

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

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

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

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

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

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

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

func (r SharedLibraryInfo) CustomHash(hasher *proptools.Hasher) error {
 hasher.WriteString(":cc.SharedLibraryInfo")
 hasher.WriteInt(6)
 hasher.WriteString(":cc.android.Path")
 val1 := r.SharedLibrary == nil
 if val1 {
  hasher.WriteByte(0)
 } else {
  if v := reflect.ValueOf(r.SharedLibrary); v.Kind() == reflect.Ptr {
   if v.IsNil() {
    panic(fmt.Errorf("nil pointer is not supported in interface"))
   } else {
    val2 := r.SharedLibrary == nil
    if val2 {
     hasher.WriteByte(0)
    } else {
     val3 := func(hasher *proptools.Hasher) error { return r.SharedLibrary.(proptools.CustomHash).CustomHash(hasher) }
     if err := proptools.HashReference(hasher, uintptr(v.Pointer()), val3); err != nil {
      return err
     }
    }
   }
  } else {
   r.SharedLibrary.(proptools.CustomHash).CustomHash(hasher)
  }
 }
 if err := r.Target.CustomHash(hasher); err != nil {
  return err
 }
 if err := r.TableOfContents.CustomHash(hasher); err != nil {
  return err
 }
 hasher.WriteString(":.bool")
 if r.IsStubs {
  hasher.WriteByte(1)
 } else {
  hasher.WriteByte(0)
 }
 val5 := func(hasher *proptools.Hasher, val4 string) error {
  hasher.WriteString(":.string")
  hasher.WriteString(val4)
  return nil
 }
 if err := r.ImplementationDeps.Hash(hasher, "string", val5); err != nil {
  return err
 }
 val10 := func(hasher *proptools.Hasher, val6 android.Path) error {
  hasher.WriteString(":cc.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.TransitiveStaticLibrariesForOrdering.Hash(hasher, "android.Path", val10); err != nil {
  return err
 }
 return nil
}

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

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

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

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

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

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

 return err
}

var SharedLibraryInfoGobRegId int16

func (r SharedLibraryInfo) GetTypeId() int16 {
 return SharedLibraryInfoGobRegId
}

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

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

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

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

func (r SharedStubLibrary) CustomHash(hasher *proptools.Hasher) error {
 hasher.WriteString(":cc.SharedStubLibrary")
 hasher.WriteInt(3)
 hasher.WriteString(":.string")
 hasher.WriteString(r.Version)
 if err := r.SharedLibraryInfo.CustomHash(hasher); err != nil {
  return err
 }
 if err := r.FlagExporterInfo.CustomHash(hasher); err != nil {
  return err
 }
 return nil
}

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

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

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

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

 return err
}

var SharedStubLibraryGobRegId int16

func (r SharedStubLibrary) GetTypeId() int16 {
 return SharedStubLibraryGobRegId
}

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

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

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

func (r SharedLibraryStubsInfo) CustomHash(hasher *proptools.Hasher) error {
 hasher.WriteString(":cc.SharedLibraryStubsInfo")
 hasher.WriteInt(2)
 hasher.WriteString(":.[]SharedStubLibrary")
 hasher.WriteInt(len(r.SharedStubLibraries))
 for val1 := 0; val1 < len(r.SharedStubLibraries); val1++ {
  if err := r.SharedStubLibraries[val1].CustomHash(hasher); err != nil {
   return err
  }
 }
 hasher.WriteString(":.bool")
 if r.IsLLNDK {
  hasher.WriteByte(1)
 } else {
  hasher.WriteByte(0)
 }
 return nil
}

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

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

 return err
}

var SharedLibraryStubsInfoGobRegId int16

func (r SharedLibraryStubsInfo) GetTypeId() int16 {
 return SharedLibraryStubsInfoGobRegId
}

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

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

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

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

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

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

func (r StaticLibraryInfo) CustomHash(hasher *proptools.Hasher) error {
 hasher.WriteString(":cc.StaticLibraryInfo")
 hasher.WriteInt(5)
 hasher.WriteString(":cc.android.Path")
 val1 := r.StaticLibrary == nil
 if val1 {
  hasher.WriteByte(0)
 } else {
  if v := reflect.ValueOf(r.StaticLibrary); v.Kind() == reflect.Ptr {
   if v.IsNil() {
    panic(fmt.Errorf("nil pointer is not supported in interface"))
   } else {
    val2 := r.StaticLibrary == nil
    if val2 {
     hasher.WriteByte(0)
    } else {
     val3 := func(hasher *proptools.Hasher) error { return r.StaticLibrary.(proptools.CustomHash).CustomHash(hasher) }
     if err := proptools.HashReference(hasher, uintptr(v.Pointer()), val3); err != nil {
      return err
     }
    }
   }
  } else {
   r.StaticLibrary.(proptools.CustomHash).CustomHash(hasher)
  }
 }
 if err := r.Objects.CustomHash(hasher); err != nil {
  return err
 }
 if err := r.ReuseObjects.CustomHash(hasher); err != nil {
  return err
 }
 hasher.WriteString(":cc.android.Paths")
 hasher.WriteString(":.[]Path")
 hasher.WriteInt(len(r.WholeStaticLibsFromPrebuilts))
 for val4 := 0; val4 < len(r.WholeStaticLibsFromPrebuilts); val4++ {
  hasher.WriteString("android/soong/android:android.Path")
  val5 := r.WholeStaticLibsFromPrebuilts[val4] == nil
  if val5 {
   hasher.WriteByte(0)
  } else {
   if v := reflect.ValueOf(r.WholeStaticLibsFromPrebuilts[val4]); v.Kind() == reflect.Ptr {
    if v.IsNil() {
     panic(fmt.Errorf("nil pointer is not supported in interface"))
    } else {
     val6 := r.WholeStaticLibsFromPrebuilts[val4] == nil
     if val6 {
      hasher.WriteByte(0)
     } else {
      val7 := func(hasher *proptools.Hasher) error {
       return r.WholeStaticLibsFromPrebuilts[val4].(proptools.CustomHash).CustomHash(hasher)
      }
      if err := proptools.HashReference(hasher, uintptr(v.Pointer()), val7); err != nil {
       return err
      }
     }
    }
   } else {
    r.WholeStaticLibsFromPrebuilts[val4].(proptools.CustomHash).CustomHash(hasher)
   }
  }
 }
 val12 := func(hasher *proptools.Hasher, val8 android.Path) error {
  hasher.WriteString(":cc.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.TransitiveStaticLibrariesForOrdering.Hash(hasher, "android.Path", val12); err != nil {
  return err
 }
 return nil
}

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

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

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

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

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

 return err
}

var StaticLibraryInfoGobRegId int16

func (r StaticLibraryInfo) GetTypeId() int16 {
 return StaticLibraryInfoGobRegId
}

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

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

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

 return err
}

var HeaderLibraryInfoGobRegId int16

func (r HeaderLibraryInfo) GetTypeId() int16 {
 return HeaderLibraryInfoGobRegId
}

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

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

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

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

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

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

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

func (r FlagExporterInfo) CustomHash(hasher *proptools.Hasher) error {
 hasher.WriteString(":cc.FlagExporterInfo")
 hasher.WriteInt(6)
 hasher.WriteString(":cc.android.Paths")
 hasher.WriteString(":.[]Path")
 hasher.WriteInt(len(r.IncludeDirs))
 for val1 := 0; val1 < len(r.IncludeDirs); val1++ {
  hasher.WriteString("android/soong/android:android.Path")
  val2 := r.IncludeDirs[val1] == nil
  if val2 {
   hasher.WriteByte(0)
  } else {
   if v := reflect.ValueOf(r.IncludeDirs[val1]); v.Kind() == reflect.Ptr {
    if v.IsNil() {
     panic(fmt.Errorf("nil pointer is not supported in interface"))
    } else {
     val3 := r.IncludeDirs[val1] == nil
     if val3 {
      hasher.WriteByte(0)
     } else {
      val4 := func(hasher *proptools.Hasher) error {
       return r.IncludeDirs[val1].(proptools.CustomHash).CustomHash(hasher)
      }
      if err := proptools.HashReference(hasher, uintptr(v.Pointer()), val4); err != nil {
       return err
      }
     }
    }
   } else {
    r.IncludeDirs[val1].(proptools.CustomHash).CustomHash(hasher)
   }
  }
 }
 hasher.WriteString(":cc.android.Paths")
 hasher.WriteString(":.[]Path")
 hasher.WriteInt(len(r.SystemIncludeDirs))
 for val5 := 0; val5 < len(r.SystemIncludeDirs); val5++ {
  hasher.WriteString("android/soong/android:android.Path")
  val6 := r.SystemIncludeDirs[val5] == nil
  if val6 {
   hasher.WriteByte(0)
  } else {
   if v := reflect.ValueOf(r.SystemIncludeDirs[val5]); v.Kind() == reflect.Ptr {
    if v.IsNil() {
     panic(fmt.Errorf("nil pointer is not supported in interface"))
    } else {
     val7 := r.SystemIncludeDirs[val5] == nil
     if val7 {
      hasher.WriteByte(0)
     } else {
      val8 := func(hasher *proptools.Hasher) error {
       return r.SystemIncludeDirs[val5].(proptools.CustomHash).CustomHash(hasher)
      }
      if err := proptools.HashReference(hasher, uintptr(v.Pointer()), val8); err != nil {
       return err
      }
     }
    }
   } else {
    r.SystemIncludeDirs[val5].(proptools.CustomHash).CustomHash(hasher)
   }
  }
 }
 hasher.WriteString(":.[]string")
 hasher.WriteInt(len(r.Flags))
 for val9 := 0; val9 < len(r.Flags); val9++ {
  hasher.WriteString(":.string")
  hasher.WriteString(r.Flags[val9])
 }
 hasher.WriteString(":cc.android.Paths")
 hasher.WriteString(":.[]Path")
 hasher.WriteInt(len(r.Deps))
 for val10 := 0; val10 < len(r.Deps); val10++ {
  hasher.WriteString("android/soong/android:android.Path")
  val11 := r.Deps[val10] == nil
  if val11 {
   hasher.WriteByte(0)
  } else {
   if v := reflect.ValueOf(r.Deps[val10]); v.Kind() == reflect.Ptr {
    if v.IsNil() {
     panic(fmt.Errorf("nil pointer is not supported in interface"))
    } else {
     val12 := r.Deps[val10] == nil
     if val12 {
      hasher.WriteByte(0)
     } else {
      val13 := func(hasher *proptools.Hasher) error { return r.Deps[val10].(proptools.CustomHash).CustomHash(hasher) }
      if err := proptools.HashReference(hasher, uintptr(v.Pointer()), val13); err != nil {
       return err
      }
     }
    }
   } else {
    r.Deps[val10].(proptools.CustomHash).CustomHash(hasher)
   }
  }
 }
 hasher.WriteString(":.[]RustRlibDep")
 hasher.WriteInt(len(r.RustRlibDeps))
 for val14 := 0; val14 < len(r.RustRlibDeps); val14++ {
  if err := r.RustRlibDeps[val14].CustomHash(hasher); err != nil {
   return err
  }
 }
 hasher.WriteString(":cc.android.Paths")
 hasher.WriteString(":.[]Path")
 hasher.WriteInt(len(r.GeneratedHeaders))
 for val15 := 0; val15 < len(r.GeneratedHeaders); val15++ {
  hasher.WriteString("android/soong/android:android.Path")
  val16 := r.GeneratedHeaders[val15] == nil
  if val16 {
   hasher.WriteByte(0)
  } else {
   if v := reflect.ValueOf(r.GeneratedHeaders[val15]); v.Kind() == reflect.Ptr {
    if v.IsNil() {
     panic(fmt.Errorf("nil pointer is not supported in interface"))
    } else {
     val17 := r.GeneratedHeaders[val15] == nil
     if val17 {
      hasher.WriteByte(0)
     } else {
      val18 := func(hasher *proptools.Hasher) error {
       return r.GeneratedHeaders[val15].(proptools.CustomHash).CustomHash(hasher)
      }
      if err := proptools.HashReference(hasher, uintptr(v.Pointer()), val18); err != nil {
       return err
      }
     }
    }
   } else {
    r.GeneratedHeaders[val15].(proptools.CustomHash).CustomHash(hasher)
   }
  }
 }
 return nil
}

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

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

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

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

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

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

 return err
}

var FlagExporterInfoGobRegId int16

func (r FlagExporterInfo) GetTypeId() int16 {
 return FlagExporterInfoGobRegId
}

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

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

func (r ImplementationDepInfo) CustomHash(hasher *proptools.Hasher) error {
 hasher.WriteString(":cc.ImplementationDepInfo")
 hasher.WriteInt(1)
 val5 := func(hasher *proptools.Hasher, val1 android.Path) error {
  hasher.WriteString(":cc.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.ImplementationDeps.Hash(hasher, "android.Path", val5); err != nil {
  return err
 }
 return nil
}

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

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

 return err
}

var ImplementationDepInfoGobRegId int16

func (r ImplementationDepInfo) GetTypeId() int16 {
 return ImplementationDepInfoGobRegId
}

// end of linkable.go

// begin of native_bridge_sdk_trait.go
func init() {
 nativeBridgeSdkTraitStructGobRegId = gobtools.RegisterType(func() gobtools.CustomDec { return new(nativeBridgeSdkTraitStruct) })
}

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

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

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

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

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

 return err
}

var nativeBridgeSdkTraitStructGobRegId int16

func (r nativeBridgeSdkTraitStruct) GetTypeId() int16 {
 return nativeBridgeSdkTraitStructGobRegId
}

// end of native_bridge_sdk_trait.go

// begin of ndk_headers.go
func init() {
 NdkHeaderInfoGobRegId = gobtools.RegisterType(func() gobtools.CustomDec { return new(NdkHeaderInfo) })
}

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

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

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

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

func (r NdkHeaderInfo) CustomHash(hasher *proptools.Hasher) error {
 hasher.WriteString(":cc.NdkHeaderInfo")
 hasher.WriteInt(4)
 hasher.WriteString(":cc.android.Paths")
 hasher.WriteString(":.[]Path")
 hasher.WriteInt(len(r.SrcPaths))
 for val1 := 0; val1 < len(r.SrcPaths); val1++ {
  hasher.WriteString("android/soong/android:android.Path")
  val2 := r.SrcPaths[val1] == nil
  if val2 {
   hasher.WriteByte(0)
  } else {
   if v := reflect.ValueOf(r.SrcPaths[val1]); v.Kind() == reflect.Ptr {
    if v.IsNil() {
     panic(fmt.Errorf("nil pointer is not supported in interface"))
    } else {
     val3 := r.SrcPaths[val1] == nil
     if val3 {
      hasher.WriteByte(0)
     } else {
      val4 := func(hasher *proptools.Hasher) error {
       return r.SrcPaths[val1].(proptools.CustomHash).CustomHash(hasher)
      }
      if err := proptools.HashReference(hasher, uintptr(v.Pointer()), val4); err != nil {
       return err
      }
     }
    }
   } else {
    r.SrcPaths[val1].(proptools.CustomHash).CustomHash(hasher)
   }
  }
 }
 hasher.WriteString(":cc.android.Paths")
 hasher.WriteString(":.[]Path")
 hasher.WriteInt(len(r.InstallPaths))
 for val5 := 0; val5 < len(r.InstallPaths); val5++ {
  hasher.WriteString("android/soong/android:android.Path")
  val6 := r.InstallPaths[val5] == nil
  if val6 {
   hasher.WriteByte(0)
  } else {
   if v := reflect.ValueOf(r.InstallPaths[val5]); v.Kind() == reflect.Ptr {
    if v.IsNil() {
     panic(fmt.Errorf("nil pointer is not supported in interface"))
    } else {
     val7 := r.InstallPaths[val5] == nil
     if val7 {
      hasher.WriteByte(0)
     } else {
      val8 := func(hasher *proptools.Hasher) error {
       return r.InstallPaths[val5].(proptools.CustomHash).CustomHash(hasher)
      }
      if err := proptools.HashReference(hasher, uintptr(v.Pointer()), val8); err != nil {
       return err
      }
     }
    }
   } else {
    r.InstallPaths[val5].(proptools.CustomHash).CustomHash(hasher)
   }
  }
 }
 hasher.WriteString(":cc.android.Path")
 val9 := r.LicensePath == nil
 if val9 {
  hasher.WriteByte(0)
 } else {
  if v := reflect.ValueOf(r.LicensePath); v.Kind() == reflect.Ptr {
   if v.IsNil() {
    panic(fmt.Errorf("nil pointer is not supported in interface"))
   } else {
    val10 := r.LicensePath == nil
    if val10 {
     hasher.WriteByte(0)
    } else {
     val11 := func(hasher *proptools.Hasher) error { return r.LicensePath.(proptools.CustomHash).CustomHash(hasher) }
     if err := proptools.HashReference(hasher, uintptr(v.Pointer()), val11); err != nil {
      return err
     }
    }
   }
  } else {
   r.LicensePath.(proptools.CustomHash).CustomHash(hasher)
  }
 }
 hasher.WriteString(":.bool")
 if r.SkipVerification {
  hasher.WriteByte(1)
 } else {
  hasher.WriteByte(0)
 }
 return nil
}

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

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

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

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

 return err
}

var NdkHeaderInfoGobRegId int16

func (r NdkHeaderInfo) GetTypeId() int16 {
 return NdkHeaderInfoGobRegId
}

// end of ndk_headers.go

// begin of sabi.go
func init() {
 taggedLsDumpGobRegId = gobtools.RegisterType(func() gobtools.CustomDec { return new(taggedLsDump) })
 TaggedLsDumpsInfoGobRegId = gobtools.RegisterType(func() gobtools.CustomDec { return new(TaggedLsDumpsInfo) })
}

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

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

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

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

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

 var val2 string
 err = gobtools.DecodeString(buf, &val2)
 if err != nil {
  return err
 }
 r.tag = lsdumpTag(val2)

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

 return err
}

var taggedLsDumpGobRegId int16

func (r taggedLsDump) GetTypeId() int16 {
 return taggedLsDumpGobRegId
}

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

 return err
}

var TaggedLsDumpsInfoGobRegId int16

func (r TaggedLsDumpsInfo) GetTypeId() int16 {
 return TaggedLsDumpsInfoGobRegId
}

// end of sabi.go

// begin of sanitize.go
func init() {
 SanitizeUserPropsGobRegId = gobtools.RegisterType(func() gobtools.CustomDec { return new(SanitizeUserProps) })
 PlatformSanitizeableInfoGobRegId = gobtools.RegisterType(func() gobtools.CustomDec { return new(PlatformSanitizeableInfo) })
 SanitizerRuntimeDepInfoGobRegId = gobtools.RegisterType(func() gobtools.CustomDec { return new(SanitizerRuntimeDepInfo) })
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

 val21 := r.Diag.Memtag_heap == nil
 if err = gobtools.EncodeBool(buf, val21); err != nil {
  return err
 }
 if !val21 {
  if err = gobtools.EncodeBool(buf, (*r.Diag.Memtag_heap)); err != nil {
   return err
  }
 }

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

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

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

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

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

func (r SanitizeUserProps) CustomHash(hasher *proptools.Hasher) error {
 hasher.WriteString(":cc.SanitizeUserProps")
 hasher.WriteInt(21)
 hasher.WriteString(":.*bool")
 val1 := r.Never == nil
 if val1 {
  hasher.WriteByte(0)
 } else {
  val2 := func(hasher *proptools.Hasher) error {
   hasher.WriteString(":.bool")
   if *r.Never {
    hasher.WriteByte(1)
   } else {
    hasher.WriteByte(0)
   }
   return nil
  }
  if err := proptools.HashReference(hasher, uintptr(unsafe.Pointer(r.Never)), val2); err != nil {
   return err
  }
 }
 hasher.WriteString(":.*bool")
 val3 := r.Address == nil
 if val3 {
  hasher.WriteByte(0)
 } else {
  val4 := func(hasher *proptools.Hasher) error {
   hasher.WriteString(":.bool")
   if *r.Address {
    hasher.WriteByte(1)
   } else {
    hasher.WriteByte(0)
   }
   return nil
  }
  if err := proptools.HashReference(hasher, uintptr(unsafe.Pointer(r.Address)), val4); err != nil {
   return err
  }
 }
 hasher.WriteString(":.*bool")
 val5 := r.Thread == nil
 if val5 {
  hasher.WriteByte(0)
 } else {
  val6 := func(hasher *proptools.Hasher) error {
   hasher.WriteString(":.bool")
   if *r.Thread {
    hasher.WriteByte(1)
   } else {
    hasher.WriteByte(0)
   }
   return nil
  }
  if err := proptools.HashReference(hasher, uintptr(unsafe.Pointer(r.Thread)), val6); err != nil {
   return err
  }
 }
 hasher.WriteString(":.*bool")
 val7 := r.Hwaddress == nil
 if val7 {
  hasher.WriteByte(0)
 } else {
  val8 := func(hasher *proptools.Hasher) error {
   hasher.WriteString(":.bool")
   if *r.Hwaddress {
    hasher.WriteByte(1)
   } else {
    hasher.WriteByte(0)
   }
   return nil
  }
  if err := proptools.HashReference(hasher, uintptr(unsafe.Pointer(r.Hwaddress)), val8); err != nil {
   return err
  }
 }
 hasher.WriteString(":.*bool")
 val9 := r.All_undefined == nil
 if val9 {
  hasher.WriteByte(0)
 } else {
  val10 := func(hasher *proptools.Hasher) error {
   hasher.WriteString(":.bool")
   if *r.All_undefined {
    hasher.WriteByte(1)
   } else {
    hasher.WriteByte(0)
   }
   return nil
  }
  if err := proptools.HashReference(hasher, uintptr(unsafe.Pointer(r.All_undefined)), val10); err != nil {
   return err
  }
 }
 hasher.WriteString(":.*bool")
 val11 := r.Undefined == nil
 if val11 {
  hasher.WriteByte(0)
 } else {
  val12 := func(hasher *proptools.Hasher) error {
   hasher.WriteString(":.bool")
   if *r.Undefined {
    hasher.WriteByte(1)
   } else {
    hasher.WriteByte(0)
   }
   return nil
  }
  if err := proptools.HashReference(hasher, uintptr(unsafe.Pointer(r.Undefined)), val12); err != nil {
   return err
  }
 }
 hasher.WriteString(":.[]string")
 hasher.WriteInt(len(r.Misc_undefined))
 for val13 := 0; val13 < len(r.Misc_undefined); val13++ {
  hasher.WriteString(":.string")
  hasher.WriteString(r.Misc_undefined[val13])
 }
 hasher.WriteString(":.*bool")
 val14 := r.Fuzzer == nil
 if val14 {
  hasher.WriteByte(0)
 } else {
  val15 := func(hasher *proptools.Hasher) error {
   hasher.WriteString(":.bool")
   if *r.Fuzzer {
    hasher.WriteByte(1)
   } else {
    hasher.WriteByte(0)
   }
   return nil
  }
  if err := proptools.HashReference(hasher, uintptr(unsafe.Pointer(r.Fuzzer)), val15); err != nil {
   return err
  }
 }
 hasher.WriteString(":.*bool")
 val16 := r.Safestack == nil
 if val16 {
  hasher.WriteByte(0)
 } else {
  val17 := func(hasher *proptools.Hasher) error {
   hasher.WriteString(":.bool")
   if *r.Safestack {
    hasher.WriteByte(1)
   } else {
    hasher.WriteByte(0)
   }
   return nil
  }
  if err := proptools.HashReference(hasher, uintptr(unsafe.Pointer(r.Safestack)), val17); err != nil {
   return err
  }
 }
 hasher.WriteString(":.*bool")
 val18 := r.Cfi == nil
 if val18 {
  hasher.WriteByte(0)
 } else {
  val19 := func(hasher *proptools.Hasher) error {
   hasher.WriteString(":.bool")
   if *r.Cfi {
    hasher.WriteByte(1)
   } else {
    hasher.WriteByte(0)
   }
   return nil
  }
  if err := proptools.HashReference(hasher, uintptr(unsafe.Pointer(r.Cfi)), val19); err != nil {
   return err
  }
 }
 hasher.WriteString(":.*bool")
 val20 := r.Integer_overflow == nil
 if val20 {
  hasher.WriteByte(0)
 } else {
  val21 := func(hasher *proptools.Hasher) error {
   hasher.WriteString(":.bool")
   if *r.Integer_overflow {
    hasher.WriteByte(1)
   } else {
    hasher.WriteByte(0)
   }
   return nil
  }
  if err := proptools.HashReference(hasher, uintptr(unsafe.Pointer(r.Integer_overflow)), val21); err != nil {
   return err
  }
 }
 hasher.WriteString(":.*bool")
 val22 := r.Scudo == nil
 if val22 {
  hasher.WriteByte(0)
 } else {
  val23 := func(hasher *proptools.Hasher) error {
   hasher.WriteString(":.bool")
   if *r.Scudo {
    hasher.WriteByte(1)
   } else {
    hasher.WriteByte(0)
   }
   return nil
  }
  if err := proptools.HashReference(hasher, uintptr(unsafe.Pointer(r.Scudo)), val23); err != nil {
   return err
  }
 }
 hasher.WriteString(":.*bool")
 val24 := r.Scs == nil
 if val24 {
  hasher.WriteByte(0)
 } else {
  val25 := func(hasher *proptools.Hasher) error {
   hasher.WriteString(":.bool")
   if *r.Scs {
    hasher.WriteByte(1)
   } else {
    hasher.WriteByte(0)
   }
   return nil
  }
  if err := proptools.HashReference(hasher, uintptr(unsafe.Pointer(r.Scs)), val25); err != nil {
   return err
  }
 }
 hasher.WriteString(":.*bool")
 val26 := r.Memtag_heap == nil
 if val26 {
  hasher.WriteByte(0)
 } else {
  val27 := func(hasher *proptools.Hasher) error {
   hasher.WriteString(":.bool")
   if *r.Memtag_heap {
    hasher.WriteByte(1)
   } else {
    hasher.WriteByte(0)
   }
   return nil
  }
  if err := proptools.HashReference(hasher, uintptr(unsafe.Pointer(r.Memtag_heap)), val27); err != nil {
   return err
  }
 }
 hasher.WriteString(":.*bool")
 val28 := r.Memtag_stack == nil
 if val28 {
  hasher.WriteByte(0)
 } else {
  val29 := func(hasher *proptools.Hasher) error {
   hasher.WriteString(":.bool")
   if *r.Memtag_stack {
    hasher.WriteByte(1)
   } else {
    hasher.WriteByte(0)
   }
   return nil
  }
  if err := proptools.HashReference(hasher, uintptr(unsafe.Pointer(r.Memtag_stack)), val29); err != nil {
   return err
  }
 }
 hasher.WriteString(":.*bool")
 val30 := r.Memtag_globals == nil
 if val30 {
  hasher.WriteByte(0)
 } else {
  val31 := func(hasher *proptools.Hasher) error {
   hasher.WriteString(":.bool")
   if *r.Memtag_globals {
    hasher.WriteByte(1)
   } else {
    hasher.WriteByte(0)
   }
   return nil
  }
  if err := proptools.HashReference(hasher, uintptr(unsafe.Pointer(r.Memtag_globals)), val31); err != nil {
   return err
  }
 }
 hasher.WriteString(":.*bool")
 val32 := r.Writeonly == nil
 if val32 {
  hasher.WriteByte(0)
 } else {
  val33 := func(hasher *proptools.Hasher) error {
   hasher.WriteString(":.bool")
   if *r.Writeonly {
    hasher.WriteByte(1)
   } else {
    hasher.WriteByte(0)
   }
   return nil
  }
  if err := proptools.HashReference(hasher, uintptr(unsafe.Pointer(r.Writeonly)), val33); err != nil {
   return err
  }
 }
 hasher.WriteString(":cc.r.Diag")
 hasher.WriteInt(6)
 hasher.WriteString(":.*bool")
 val34 := r.Diag.Undefined == nil
 if val34 {
  hasher.WriteByte(0)
 } else {
  val35 := func(hasher *proptools.Hasher) error {
   hasher.WriteString(":.bool")
   if *r.Diag.Undefined {
    hasher.WriteByte(1)
   } else {
    hasher.WriteByte(0)
   }
   return nil
  }
  if err := proptools.HashReference(hasher, uintptr(unsafe.Pointer(r.Diag.Undefined)), val35); err != nil {
   return err
  }
 }
 hasher.WriteString(":.*bool")
 val36 := r.Diag.Cfi == nil
 if val36 {
  hasher.WriteByte(0)
 } else {
  val37 := func(hasher *proptools.Hasher) error {
   hasher.WriteString(":.bool")
   if *r.Diag.Cfi {
    hasher.WriteByte(1)
   } else {
    hasher.WriteByte(0)
   }
   return nil
  }
  if err := proptools.HashReference(hasher, uintptr(unsafe.Pointer(r.Diag.Cfi)), val37); err != nil {
   return err
  }
 }
 hasher.WriteString(":.*bool")
 val38 := r.Diag.Integer_overflow == nil
 if val38 {
  hasher.WriteByte(0)
 } else {
  val39 := func(hasher *proptools.Hasher) error {
   hasher.WriteString(":.bool")
   if *r.Diag.Integer_overflow {
    hasher.WriteByte(1)
   } else {
    hasher.WriteByte(0)
   }
   return nil
  }
  if err := proptools.HashReference(hasher, uintptr(unsafe.Pointer(r.Diag.Integer_overflow)), val39); err != nil {
   return err
  }
 }
 hasher.WriteString(":.*bool")
 val40 := r.Diag.Memtag_heap == nil
 if val40 {
  hasher.WriteByte(0)
 } else {
  val41 := func(hasher *proptools.Hasher) error {
   hasher.WriteString(":.bool")
   if *r.Diag.Memtag_heap {
    hasher.WriteByte(1)
   } else {
    hasher.WriteByte(0)
   }
   return nil
  }
  if err := proptools.HashReference(hasher, uintptr(unsafe.Pointer(r.Diag.Memtag_heap)), val41); err != nil {
   return err
  }
 }
 hasher.WriteString(":.[]string")
 hasher.WriteInt(len(r.Diag.Misc_undefined))
 for val42 := 0; val42 < len(r.Diag.Misc_undefined); val42++ {
  hasher.WriteString(":.string")
  hasher.WriteString(r.Diag.Misc_undefined[val42])
 }
 hasher.WriteString(":.[]string")
 hasher.WriteInt(len(r.Diag.No_recover))
 for val43 := 0; val43 < len(r.Diag.No_recover); val43++ {
  hasher.WriteString(":.string")
  hasher.WriteString(r.Diag.No_recover[val43])
 }
 hasher.WriteString(":cc.r.Config")
 hasher.WriteInt(1)
 hasher.WriteString(":.*bool")
 val44 := r.Config.Cfi_assembly_support == nil
 if val44 {
  hasher.WriteByte(0)
 } else {
  val45 := func(hasher *proptools.Hasher) error {
   hasher.WriteString(":.bool")
   if *r.Config.Cfi_assembly_support {
    hasher.WriteByte(1)
   } else {
    hasher.WriteByte(0)
   }
   return nil
  }
  if err := proptools.HashReference(hasher, uintptr(unsafe.Pointer(r.Config.Cfi_assembly_support)), val45); err != nil {
   return err
  }
 }
 hasher.WriteString(":.[]string")
 hasher.WriteInt(len(r.Recover))
 for val46 := 0; val46 < len(r.Recover); val46++ {
  hasher.WriteString(":.string")
  hasher.WriteString(r.Recover[val46])
 }
 hasher.WriteString(":.*string")
 val47 := r.Blocklist == nil
 if val47 {
  hasher.WriteByte(0)
 } else {
  val48 := func(hasher *proptools.Hasher) error {
   hasher.WriteString(":.string")
   hasher.WriteString((*r.Blocklist))
   return nil
  }
  if err := proptools.HashReference(hasher, uintptr(unsafe.Pointer(r.Blocklist)), val48); err != nil {
   return err
  }
 }
 return nil
}

func (r *SanitizeUserProps) 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 bool
  err = gobtools.DecodeBool(buf, &val1)
  if err != nil {
   return err
  }
  r.Never = &val1
 }

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

 var val8 bool
 if err = gobtools.DecodeBool(buf, &val8); err != nil {
  return err
 }
 if !val8 {
  var val7 bool
  err = gobtools.DecodeBool(buf, &val7)
  if err != nil {
   return err
  }
  r.Thread = &val7
 }

 var val11 bool
 if err = gobtools.DecodeBool(buf, &val11); err != nil {
  return err
 }
 if !val11 {
  var val10 bool
  err = gobtools.DecodeBool(buf, &val10)
  if err != nil {
   return err
  }
  r.Hwaddress = &val10
 }

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

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

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

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

 var val27 bool
 if err = gobtools.DecodeBool(buf, &val27); err != nil {
  return err
 }
 if !val27 {
  var val26 bool
  err = gobtools.DecodeBool(buf, &val26)
  if err != nil {
   return err
  }
  r.Safestack = &val26
 }

 var val30 bool
 if err = gobtools.DecodeBool(buf, &val30); err != nil {
  return err
 }
 if !val30 {
  var val29 bool
  err = gobtools.DecodeBool(buf, &val29)
  if err != nil {
   return err
  }
  r.Cfi = &val29
 }

 var val33 bool
 if err = gobtools.DecodeBool(buf, &val33); err != nil {
  return err
 }
 if !val33 {
  var val32 bool
  err = gobtools.DecodeBool(buf, &val32)
  if err != nil {
   return err
  }
  r.Integer_overflow = &val32
 }

 var val36 bool
 if err = gobtools.DecodeBool(buf, &val36); err != nil {
  return err
 }
 if !val36 {
  var val35 bool
  err = gobtools.DecodeBool(buf, &val35)
  if err != nil {
   return err
  }
  r.Scudo = &val35
 }

 var val39 bool
 if err = gobtools.DecodeBool(buf, &val39); err != nil {
  return err
 }
 if !val39 {
  var val38 bool
  err = gobtools.DecodeBool(buf, &val38)
  if err != nil {
   return err
  }
  r.Scs = &val38
 }

 var val42 bool
 if err = gobtools.DecodeBool(buf, &val42); err != nil {
  return err
 }
 if !val42 {
  var val41 bool
  err = gobtools.DecodeBool(buf, &val41)
  if err != nil {
   return err
  }
  r.Memtag_heap = &val41
 }

 var val45 bool
 if err = gobtools.DecodeBool(buf, &val45); err != nil {
  return err
 }
 if !val45 {
  var val44 bool
  err = gobtools.DecodeBool(buf, &val44)
  if err != nil {
   return err
  }
  r.Memtag_stack = &val44
 }

 var val48 bool
 if err = gobtools.DecodeBool(buf, &val48); err != nil {
  return err
 }
 if !val48 {
  var val47 bool
  err = gobtools.DecodeBool(buf, &val47)
  if err != nil {
   return err
  }
  r.Memtag_globals = &val47
 }

 var val51 bool
 if err = gobtools.DecodeBool(buf, &val51); err != nil {
  return err
 }
 if !val51 {
  var val50 bool
  err = gobtools.DecodeBool(buf, &val50)
  if err != nil {
   return err
  }
  r.Writeonly = &val50
 }

 var val55 bool
 if err = gobtools.DecodeBool(buf, &val55); err != nil {
  return err
 }
 if !val55 {
  var val54 bool
  err = gobtools.DecodeBool(buf, &val54)
  if err != nil {
   return err
  }
  r.Diag.Undefined = &val54
 }

 var val58 bool
 if err = gobtools.DecodeBool(buf, &val58); err != nil {
  return err
 }
 if !val58 {
  var val57 bool
  err = gobtools.DecodeBool(buf, &val57)
  if err != nil {
   return err
  }
  r.Diag.Cfi = &val57
 }

 var val61 bool
 if err = gobtools.DecodeBool(buf, &val61); err != nil {
  return err
 }
 if !val61 {
  var val60 bool
  err = gobtools.DecodeBool(buf, &val60)
  if err != nil {
   return err
  }
  r.Diag.Integer_overflow = &val60
 }

 var val64 bool
 if err = gobtools.DecodeBool(buf, &val64); err != nil {
  return err
 }
 if !val64 {
  var val63 bool
  err = gobtools.DecodeBool(buf, &val63)
  if err != nil {
   return err
  }
  r.Diag.Memtag_heap = &val63
 }

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

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

 var val76 bool
 if err = gobtools.DecodeBool(buf, &val76); err != nil {
  return err
 }
 if !val76 {
  var val75 bool
  err = gobtools.DecodeBool(buf, &val75)
  if err != nil {
   return err
  }
  r.Config.Cfi_assembly_support = &val75
 }

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

 var val83 bool
 if err = gobtools.DecodeBool(buf, &val83); err != nil {
  return err
 }
 if !val83 {
  var val82 string
  err = gobtools.DecodeString(buf, &val82)
  if err != nil {
   return err
  }
  r.Blocklist = &val82
 }

 return err
}

var SanitizeUserPropsGobRegId int16

func (r SanitizeUserProps) GetTypeId() int16 {
 return SanitizeUserPropsGobRegId
}

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

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

func (r PlatformSanitizeableInfo) CustomHash(hasher *proptools.Hasher) error {
 hasher.WriteString(":cc.PlatformSanitizeableInfo")
 hasher.WriteInt(1)
 hasher.WriteString(":.[]bool")
 hasher.WriteInt(len(r.IsSanitizerEnabled))
 for val1 := 0; val1 < len(r.IsSanitizerEnabled); val1++ {
  hasher.WriteString(":.bool")
  if r.IsSanitizerEnabled[val1] {
   hasher.WriteByte(1)
  } else {
   hasher.WriteByte(0)
  }
 }
 return nil
}

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

 return err
}

var PlatformSanitizeableInfoGobRegId int16

func (r PlatformSanitizeableInfo) GetTypeId() int16 {
 return PlatformSanitizeableInfoGobRegId
}

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

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

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

func (r SanitizerRuntimeDepInfo) CustomHash(hasher *proptools.Hasher) error {
 hasher.WriteString(":cc.SanitizerRuntimeDepInfo")
 hasher.WriteInt(2)
 hasher.WriteString(":.bool")
 if r.MinimalRuntimeNeeded {
  hasher.WriteByte(1)
 } else {
  hasher.WriteByte(0)
 }
 hasher.WriteString(":.bool")
 if r.UbsanRuntimeNeeded {
  hasher.WriteByte(1)
 } else {
  hasher.WriteByte(0)
 }
 return nil
}

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

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

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

 return err
}

var SanitizerRuntimeDepInfoGobRegId int16

func (r SanitizerRuntimeDepInfo) GetTypeId() int16 {
 return SanitizerRuntimeDepInfoGobRegId
}

// end of sanitize.go