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

package filesystem

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

// begin of android_device.go
func init() {
 ApexKeyPathInfoGobRegId = gobtools.RegisterType(func() gobtools.CustomDec { return new(ApexKeyPathInfo) })
}

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

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

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

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

 return err
}

var ApexKeyPathInfoGobRegId int16

func (r ApexKeyPathInfo) GetTypeId() int16 {
 return ApexKeyPathInfoGobRegId
}

// end of android_device.go

// begin of bootimg.go
func init() {
 BootimgInfoGobRegId = gobtools.RegisterType(func() gobtools.CustomDec { return new(BootimgInfo) })
 ramdiskFragmentInfoGobRegId = gobtools.RegisterType(func() gobtools.CustomDec { return new(ramdiskFragmentInfo) })
 ramdiskFragmentsInfoGobRegId = gobtools.RegisterType(func() gobtools.CustomDec { return new(ramdiskFragmentsInfo) })
}

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

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

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

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

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

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

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

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

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

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

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

func (r BootimgInfo) CustomHash(hasher *proptools.Hasher) error {
 hasher.WriteString(":filesystem.BootimgInfo")
 hasher.WriteInt(10)
 hasher.WriteString(":filesystem.bootImageType")
 hasher.WriteString(":.int")
 hasher.WriteUint64(uint64(int(r.Type)))
 hasher.WriteString(":.[]string")
 hasher.WriteInt(len(r.Cmdline))
 for val1 := 0; val1 < len(r.Cmdline); val1++ {
  hasher.WriteString(":.string")
  hasher.WriteString(r.Cmdline[val1])
 }
 hasher.WriteString(":filesystem.android.Path")
 val2 := r.Kernel == nil
 if val2 {
  hasher.WriteByte(0)
 } else {
  if v := reflect.ValueOf(r.Kernel); v.Kind() == reflect.Ptr {
   if v.IsNil() {
    panic(fmt.Errorf("nil pointer is not supported in interface"))
   } else {
    val3 := r.Kernel == nil
    if val3 {
     hasher.WriteByte(0)
    } else {
     val4 := func(hasher *proptools.Hasher) error { return r.Kernel.(proptools.CustomHash).CustomHash(hasher) }
     if err := proptools.HashReference(hasher, uintptr(v.Pointer()), val4); err != nil {
      return err
     }
    }
   }
  } else {
   r.Kernel.(proptools.CustomHash).CustomHash(hasher)
  }
 }
 hasher.WriteString(":filesystem.android.Path")
 val5 := r.Dtb == nil
 if val5 {
  hasher.WriteByte(0)
 } else {
  if v := reflect.ValueOf(r.Dtb); v.Kind() == reflect.Ptr {
   if v.IsNil() {
    panic(fmt.Errorf("nil pointer is not supported in interface"))
   } else {
    val6 := r.Dtb == nil
    if val6 {
     hasher.WriteByte(0)
    } else {
     val7 := func(hasher *proptools.Hasher) error { return r.Dtb.(proptools.CustomHash).CustomHash(hasher) }
     if err := proptools.HashReference(hasher, uintptr(v.Pointer()), val7); err != nil {
      return err
     }
    }
   }
  } else {
   r.Dtb.(proptools.CustomHash).CustomHash(hasher)
  }
 }
 hasher.WriteString(":filesystem.android.Path")
 val8 := r.Bootconfig == nil
 if val8 {
  hasher.WriteByte(0)
 } else {
  if v := reflect.ValueOf(r.Bootconfig); v.Kind() == reflect.Ptr {
   if v.IsNil() {
    panic(fmt.Errorf("nil pointer is not supported in interface"))
   } else {
    val9 := r.Bootconfig == nil
    if val9 {
     hasher.WriteByte(0)
    } else {
     val10 := func(hasher *proptools.Hasher) error { return r.Bootconfig.(proptools.CustomHash).CustomHash(hasher) }
     if err := proptools.HashReference(hasher, uintptr(v.Pointer()), val10); err != nil {
      return err
     }
    }
   }
  } else {
   r.Bootconfig.(proptools.CustomHash).CustomHash(hasher)
  }
 }
 hasher.WriteString(":filesystem.android.Path")
 val11 := r.Output == nil
 if val11 {
  hasher.WriteByte(0)
 } else {
  if v := reflect.ValueOf(r.Output); v.Kind() == reflect.Ptr {
   if v.IsNil() {
    panic(fmt.Errorf("nil pointer is not supported in interface"))
   } else {
    val12 := r.Output == nil
    if val12 {
     hasher.WriteByte(0)
    } else {
     val13 := func(hasher *proptools.Hasher) error { return r.Output.(proptools.CustomHash).CustomHash(hasher) }
     if err := proptools.HashReference(hasher, uintptr(v.Pointer()), val13); err != nil {
      return err
     }
    }
   }
  } else {
   r.Output.(proptools.CustomHash).CustomHash(hasher)
  }
 }
 hasher.WriteString(":filesystem.android.Path")
 val14 := r.SignedOutput == nil
 if val14 {
  hasher.WriteByte(0)
 } else {
  if v := reflect.ValueOf(r.SignedOutput); v.Kind() == reflect.Ptr {
   if v.IsNil() {
    panic(fmt.Errorf("nil pointer is not supported in interface"))
   } else {
    val15 := r.SignedOutput == nil
    if val15 {
     hasher.WriteByte(0)
    } else {
     val16 := func(hasher *proptools.Hasher) error { return r.SignedOutput.(proptools.CustomHash).CustomHash(hasher) }
     if err := proptools.HashReference(hasher, uintptr(v.Pointer()), val16); err != nil {
      return err
     }
    }
   }
  } else {
   r.SignedOutput.(proptools.CustomHash).CustomHash(hasher)
  }
 }
 hasher.WriteString(":filesystem.android.Path")
 val17 := r.PropFileForMiscInfo == nil
 if val17 {
  hasher.WriteByte(0)
 } else {
  if v := reflect.ValueOf(r.PropFileForMiscInfo); v.Kind() == reflect.Ptr {
   if v.IsNil() {
    panic(fmt.Errorf("nil pointer is not supported in interface"))
   } else {
    val18 := r.PropFileForMiscInfo == nil
    if val18 {
     hasher.WriteByte(0)
    } else {
     val19 := func(hasher *proptools.Hasher) error {
      return r.PropFileForMiscInfo.(proptools.CustomHash).CustomHash(hasher)
     }
     if err := proptools.HashReference(hasher, uintptr(v.Pointer()), val19); err != nil {
      return err
     }
    }
   }
  } else {
   r.PropFileForMiscInfo.(proptools.CustomHash).CustomHash(hasher)
  }
 }
 hasher.WriteString(":.string")
 hasher.WriteString(r.HeaderVersion)
 hasher.WriteString(":.bool")
 if r.IsPrebuilt {
  hasher.WriteByte(1)
 } else {
  hasher.WriteByte(0)
 }
 return nil
}

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

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

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

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

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

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

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

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

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

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

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

 return err
}

var BootimgInfoGobRegId int16

func (r BootimgInfo) GetTypeId() int16 {
 return BootimgInfoGobRegId
}

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

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

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

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

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

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

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

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

 return err
}

var ramdiskFragmentInfoGobRegId int16

func (r ramdiskFragmentInfo) GetTypeId() int16 {
 return ramdiskFragmentInfoGobRegId
}

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

 return err
}

var ramdiskFragmentsInfoGobRegId int16

func (r ramdiskFragmentsInfo) GetTypeId() int16 {
 return ramdiskFragmentsInfoGobRegId
}

// end of bootimg.go

// begin of bootloader.go
func init() {
 bootloaderInfoGobRegId = gobtools.RegisterType(func() gobtools.CustomDec { return new(bootloaderInfo) })
}

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

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

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

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

 return err
}

var bootloaderInfoGobRegId int16

func (r bootloaderInfo) GetTypeId() int16 {
 return bootloaderInfoGobRegId
}

// end of bootloader.go

// begin of dtboimg.go
func init() {
 DtboImgInfoGobRegId = gobtools.RegisterType(func() gobtools.CustomDec { return new(DtboImgInfo) })
}

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

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

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

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

 return err
}

var DtboImgInfoGobRegId int16

func (r DtboImgInfo) GetTypeId() int16 {
 return DtboImgInfoGobRegId
}

// end of dtboimg.go

// begin of filesystem.go
func init() {
 InstalledFilesStructGobRegId = gobtools.RegisterType(func() gobtools.CustomDec { return new(InstalledFilesStruct) })
 InstalledModuleInfoGobRegId = gobtools.RegisterType(func() gobtools.CustomDec { return new(InstalledModuleInfo) })
 FilesystemInfoGobRegId = gobtools.RegisterType(func() gobtools.CustomDec { return new(FilesystemInfo) })
 FullInstallPathInfoGobRegId = gobtools.RegisterType(func() gobtools.CustomDec { return new(FullInstallPathInfo) })
 FilesystemDefaultsInfoGobRegId = gobtools.RegisterType(func() gobtools.CustomDec { return new(FilesystemDefaultsInfo) })
}

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

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

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

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

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

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

 return err
}

var InstalledFilesStructGobRegId int16

func (r InstalledFilesStruct) GetTypeId() int16 {
 return InstalledFilesStructGobRegId
}

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

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

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

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

func (r InstalledModuleInfo) CustomHash(hasher *proptools.Hasher) error {
 hasher.WriteString(":filesystem.InstalledModuleInfo")
 hasher.WriteInt(3)
 hasher.WriteString(":.string")
 hasher.WriteString(r.Name)
 hasher.WriteString(":.string")
 hasher.WriteString(r.Variation)
 hasher.WriteString(":.bool")
 if r.Prebuilt {
  hasher.WriteByte(1)
 } else {
  hasher.WriteByte(0)
 }
 return nil
}

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

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

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

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

 return err
}

var InstalledModuleInfoGobRegId int16

func (r InstalledModuleInfo) GetTypeId() int16 {
 return InstalledModuleInfoGobRegId
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

func (r FilesystemInfo) CustomHash(hasher *proptools.Hasher) error {
 hasher.WriteString(":filesystem.FilesystemInfo")
 hasher.WriteInt(28)
 hasher.WriteString(":filesystem.android.Path")
 val1 := r.Output == nil
 if val1 {
  hasher.WriteByte(0)
 } else {
  if v := reflect.ValueOf(r.Output); v.Kind() == reflect.Ptr {
   if v.IsNil() {
    panic(fmt.Errorf("nil pointer is not supported in interface"))
   } else {
    val2 := r.Output == nil
    if val2 {
     hasher.WriteByte(0)
    } else {
     val3 := func(hasher *proptools.Hasher) error { return r.Output.(proptools.CustomHash).CustomHash(hasher) }
     if err := proptools.HashReference(hasher, uintptr(v.Pointer()), val3); err != nil {
      return err
     }
    }
   }
  } else {
   r.Output.(proptools.CustomHash).CustomHash(hasher)
  }
 }
 hasher.WriteString(":filesystem.android.Path")
 val4 := r.SignedOutputPath == nil
 if val4 {
  hasher.WriteByte(0)
 } else {
  if v := reflect.ValueOf(r.SignedOutputPath); v.Kind() == reflect.Ptr {
   if v.IsNil() {
    panic(fmt.Errorf("nil pointer is not supported in interface"))
   } else {
    val5 := r.SignedOutputPath == nil
    if val5 {
     hasher.WriteByte(0)
    } else {
     val6 := func(hasher *proptools.Hasher) error {
      return r.SignedOutputPath.(proptools.CustomHash).CustomHash(hasher)
     }
     if err := proptools.HashReference(hasher, uintptr(v.Pointer()), val6); err != nil {
      return err
     }
    }
   }
  } else {
   r.SignedOutputPath.(proptools.CustomHash).CustomHash(hasher)
  }
 }
 hasher.WriteString(":filesystem.android.Path")
 val7 := r.FileListFile == nil
 if val7 {
  hasher.WriteByte(0)
 } else {
  if v := reflect.ValueOf(r.FileListFile); v.Kind() == reflect.Ptr {
   if v.IsNil() {
    panic(fmt.Errorf("nil pointer is not supported in interface"))
   } else {
    val8 := r.FileListFile == nil
    if val8 {
     hasher.WriteByte(0)
    } else {
     val9 := func(hasher *proptools.Hasher) error { return r.FileListFile.(proptools.CustomHash).CustomHash(hasher) }
     if err := proptools.HashReference(hasher, uintptr(v.Pointer()), val9); err != nil {
      return err
     }
    }
   }
  } else {
   r.FileListFile.(proptools.CustomHash).CustomHash(hasher)
  }
 }
 if err := r.RootDir.CustomHash(hasher); err != nil {
  return err
 }
 hasher.WriteString(":filesystem.android.Paths")
 hasher.WriteString(":.[]Path")
 hasher.WriteInt(len(r.ExtraRootDirs))
 for val10 := 0; val10 < len(r.ExtraRootDirs); val10++ {
  hasher.WriteString("android/soong/android:android.Path")
  val11 := r.ExtraRootDirs[val10] == nil
  if val11 {
   hasher.WriteByte(0)
  } else {
   if v := reflect.ValueOf(r.ExtraRootDirs[val10]); v.Kind() == reflect.Ptr {
    if v.IsNil() {
     panic(fmt.Errorf("nil pointer is not supported in interface"))
    } else {
     val12 := r.ExtraRootDirs[val10] == nil
     if val12 {
      hasher.WriteByte(0)
     } else {
      val13 := func(hasher *proptools.Hasher) error {
       return r.ExtraRootDirs[val10].(proptools.CustomHash).CustomHash(hasher)
      }
      if err := proptools.HashReference(hasher, uintptr(v.Pointer()), val13); err != nil {
       return err
      }
     }
    }
   } else {
    r.ExtraRootDirs[val10].(proptools.CustomHash).CustomHash(hasher)
   }
  }
 }
 if err := r.RebasedDir.CustomHash(hasher); err != nil {
  return err
 }
 hasher.WriteString(":.string")
 hasher.WriteString(r.ModuleName)
 hasher.WriteString(":filesystem.android.Path")
 val14 := r.BuildImagePropFile == nil
 if val14 {
  hasher.WriteByte(0)
 } else {
  if v := reflect.ValueOf(r.BuildImagePropFile); v.Kind() == reflect.Ptr {
   if v.IsNil() {
    panic(fmt.Errorf("nil pointer is not supported in interface"))
   } else {
    val15 := r.BuildImagePropFile == nil
    if val15 {
     hasher.WriteByte(0)
    } else {
     val16 := func(hasher *proptools.Hasher) error {
      return r.BuildImagePropFile.(proptools.CustomHash).CustomHash(hasher)
     }
     if err := proptools.HashReference(hasher, uintptr(v.Pointer()), val16); err != nil {
      return err
     }
    }
   }
  } else {
   r.BuildImagePropFile.(proptools.CustomHash).CustomHash(hasher)
  }
 }
 hasher.WriteString(":filesystem.android.Paths")
 hasher.WriteString(":.[]Path")
 hasher.WriteInt(len(r.BuildImagePropFileDeps))
 for val17 := 0; val17 < len(r.BuildImagePropFileDeps); val17++ {
  hasher.WriteString("android/soong/android:android.Path")
  val18 := r.BuildImagePropFileDeps[val17] == nil
  if val18 {
   hasher.WriteByte(0)
  } else {
   if v := reflect.ValueOf(r.BuildImagePropFileDeps[val17]); v.Kind() == reflect.Ptr {
    if v.IsNil() {
     panic(fmt.Errorf("nil pointer is not supported in interface"))
    } else {
     val19 := r.BuildImagePropFileDeps[val17] == nil
     if val19 {
      hasher.WriteByte(0)
     } else {
      val20 := func(hasher *proptools.Hasher) error {
       return r.BuildImagePropFileDeps[val17].(proptools.CustomHash).CustomHash(hasher)
      }
      if err := proptools.HashReference(hasher, uintptr(v.Pointer()), val20); err != nil {
       return err
      }
     }
    }
   } else {
    r.BuildImagePropFileDeps[val17].(proptools.CustomHash).CustomHash(hasher)
   }
  }
 }
 hasher.WriteString(":.map[string]android.PackagingSpec")
 hasher.WriteInt(len(r.SpecsForSystemOther))
 val21 := make([]string, 0, len(r.SpecsForSystemOther))
 for val23 := range r.SpecsForSystemOther {
  val21 = append(val21, val23)
 }
 proptools.SortOrdered(val21)
 for _, val22 := range val21 {
  hasher.WriteString(":.string")
  hasher.WriteString(val22)
  if err := r.SpecsForSystemOther[val22].CustomHash(hasher); err != nil {
   return err
  }
 }
 hasher.WriteString(":.[]FullInstallPathInfo")
 hasher.WriteInt(len(r.FullInstallPaths))
 for val24 := 0; val24 < len(r.FullInstallPaths); val24++ {
  if err := r.FullInstallPaths[val24].CustomHash(hasher); err != nil {
   return err
  }
 }
 val26 := func(hasher *proptools.Hasher, val25 InstalledFilesStruct) error {
  if err := val25.CustomHash(hasher); err != nil {
   return err
  }
  return nil
 }
 if err := r.InstalledFilesDepSet.Hash(hasher, "InstalledFilesStruct", val26); err != nil {
  return err
 }
 hasher.WriteString(":filesystem.android.Path")
 val27 := r.ErofsCompressHints == nil
 if val27 {
  hasher.WriteByte(0)
 } else {
  if v := reflect.ValueOf(r.ErofsCompressHints); v.Kind() == reflect.Ptr {
   if v.IsNil() {
    panic(fmt.Errorf("nil pointer is not supported in interface"))
   } else {
    val28 := r.ErofsCompressHints == nil
    if val28 {
     hasher.WriteByte(0)
    } else {
     val29 := func(hasher *proptools.Hasher) error {
      return r.ErofsCompressHints.(proptools.CustomHash).CustomHash(hasher)
     }
     if err := proptools.HashReference(hasher, uintptr(v.Pointer()), val29); err != nil {
      return err
     }
    }
   }
  } else {
   r.ErofsCompressHints.(proptools.CustomHash).CustomHash(hasher)
  }
 }
 hasher.WriteString(":filesystem.android.Path")
 val30 := r.SelinuxFc == nil
 if val30 {
  hasher.WriteByte(0)
 } else {
  if v := reflect.ValueOf(r.SelinuxFc); v.Kind() == reflect.Ptr {
   if v.IsNil() {
    panic(fmt.Errorf("nil pointer is not supported in interface"))
   } else {
    val31 := r.SelinuxFc == nil
    if val31 {
     hasher.WriteByte(0)
    } else {
     val32 := func(hasher *proptools.Hasher) error { return r.SelinuxFc.(proptools.CustomHash).CustomHash(hasher) }
     if err := proptools.HashReference(hasher, uintptr(v.Pointer()), val32); err != nil {
      return err
     }
    }
   }
  } else {
   r.SelinuxFc.(proptools.CustomHash).CustomHash(hasher)
  }
 }
 hasher.WriteString(":filesystem.android.Path")
 val33 := r.FilesystemConfig == nil
 if val33 {
  hasher.WriteByte(0)
 } else {
  if v := reflect.ValueOf(r.FilesystemConfig); v.Kind() == reflect.Ptr {
   if v.IsNil() {
    panic(fmt.Errorf("nil pointer is not supported in interface"))
   } else {
    val34 := r.FilesystemConfig == nil
    if val34 {
     hasher.WriteByte(0)
    } else {
     val35 := func(hasher *proptools.Hasher) error {
      return r.FilesystemConfig.(proptools.CustomHash).CustomHash(hasher)
     }
     if err := proptools.HashReference(hasher, uintptr(v.Pointer()), val35); err != nil {
      return err
     }
    }
   }
  } else {
   r.FilesystemConfig.(proptools.CustomHash).CustomHash(hasher)
  }
 }
 val37 := func(hasher *proptools.Hasher, val36 InstalledModuleInfo) error {
  if err := val36.CustomHash(hasher); err != nil {
   return err
  }
  return nil
 }
 if err := r.Owners.Hash(hasher, "InstalledModuleInfo", val37); err != nil {
  return err
 }
 hasher.WriteString(":.bool")
 if r.HasFsverity {
  hasher.WriteByte(1)
 } else {
  hasher.WriteByte(0)
 }
 hasher.WriteString(":filesystem.android.Path")
 val38 := r.PropFileForMiscInfo == nil
 if val38 {
  hasher.WriteByte(0)
 } else {
  if v := reflect.ValueOf(r.PropFileForMiscInfo); v.Kind() == reflect.Ptr {
   if v.IsNil() {
    panic(fmt.Errorf("nil pointer is not supported in interface"))
   } else {
    val39 := r.PropFileForMiscInfo == nil
    if val39 {
     hasher.WriteByte(0)
    } else {
     val40 := func(hasher *proptools.Hasher) error {
      return r.PropFileForMiscInfo.(proptools.CustomHash).CustomHash(hasher)
     }
     if err := proptools.HashReference(hasher, uintptr(v.Pointer()), val40); err != nil {
      return err
     }
    }
   }
  } else {
   r.PropFileForMiscInfo.(proptools.CustomHash).CustomHash(hasher)
  }
 }
 hasher.WriteString(":.*int64")
 val41 := r.PartitionSize == nil
 if val41 {
  hasher.WriteByte(0)
 } else {
  val42 := func(hasher *proptools.Hasher) error {
   hasher.WriteString(":.int64")
   hasher.WriteUint64(uint64((*r.PartitionSize)))
   return nil
  }
  if err := proptools.HashReference(hasher, uintptr(unsafe.Pointer(r.PartitionSize)), val42); err != nil {
   return err
  }
 }
 hasher.WriteString(":.bool")
 if r.UseAvb {
  hasher.WriteByte(1)
 } else {
  hasher.WriteByte(0)
 }
 hasher.WriteString(":.string")
 hasher.WriteString(r.AvbAlgorithm)
 hasher.WriteString(":.string")
 hasher.WriteString(r.AvbHashAlgorithm)
 hasher.WriteString(":filesystem.android.Path")
 val43 := r.AvbKey == nil
 if val43 {
  hasher.WriteByte(0)
 } else {
  if v := reflect.ValueOf(r.AvbKey); v.Kind() == reflect.Ptr {
   if v.IsNil() {
    panic(fmt.Errorf("nil pointer is not supported in interface"))
   } else {
    val44 := r.AvbKey == nil
    if val44 {
     hasher.WriteByte(0)
    } else {
     val45 := func(hasher *proptools.Hasher) error { return r.AvbKey.(proptools.CustomHash).CustomHash(hasher) }
     if err := proptools.HashReference(hasher, uintptr(v.Pointer()), val45); err != nil {
      return err
     }
    }
   }
  } else {
   r.AvbKey.(proptools.CustomHash).CustomHash(hasher)
  }
 }
 hasher.WriteString(":.string")
 hasher.WriteString(r.PartitionName)
 hasher.WriteString(":.bool")
 if r.NoFlashall {
  hasher.WriteByte(1)
 } else {
  hasher.WriteByte(0)
 }
 hasher.WriteString(":.bool")
 if r.HasOrIsRecovery {
  hasher.WriteByte(1)
 } else {
  hasher.WriteByte(0)
 }
 hasher.WriteString(":filesystem.android.Path")
 val46 := r.checkVintfLog == nil
 if val46 {
  hasher.WriteByte(0)
 } else {
  if v := reflect.ValueOf(r.checkVintfLog); v.Kind() == reflect.Ptr {
   if v.IsNil() {
    panic(fmt.Errorf("nil pointer is not supported in interface"))
   } else {
    val47 := r.checkVintfLog == nil
    if val47 {
     hasher.WriteByte(0)
    } else {
     val48 := func(hasher *proptools.Hasher) error { return r.checkVintfLog.(proptools.CustomHash).CustomHash(hasher) }
     if err := proptools.HashReference(hasher, uintptr(v.Pointer()), val48); err != nil {
      return err
     }
    }
   }
  } else {
   r.checkVintfLog.(proptools.CustomHash).CustomHash(hasher)
  }
 }
 hasher.WriteString(":.bool")
 if r.Prebuilt {
  hasher.WriteByte(1)
 } else {
  hasher.WriteByte(0)
 }
 return nil
}

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

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

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

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

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

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

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

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

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

 var val24 int
 err = gobtools.DecodeInt(buf, &val24)
 if err != nil {
  return err
 }
 if val24 != -1 {
  r.SpecsForSystemOther = make(map[string]android.PackagingSpec, val24)
  for val25 := 0; val25 < int(val24); val25++ {
   var val26 string
   var val27 android.PackagingSpec
   err = gobtools.DecodeString(buf, &val26)
   if err != nil {
    return err
   }
   if err = val27.Decode(ctx, buf); err != nil {
    return err
   }
   r.SpecsForSystemOther[val26] = val27
  }
 }

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

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

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

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

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

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

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

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

 var val46 bool
 if err = gobtools.DecodeBool(buf, &val46); err != nil {
  return err
 }
 if !val46 {
  var val45 int64
  err = gobtools.DecodeInt64(buf, &val45)
  if err != nil {
   return err
  }
  r.PartitionSize = &val45
 }

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

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

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

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

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

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

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

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

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

 return err
}

var FilesystemInfoGobRegId int16

func (r FilesystemInfo) GetTypeId() int16 {
 return FilesystemInfoGobRegId
}

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

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

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

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

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

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

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

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

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

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

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

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

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

 return err
}

var FullInstallPathInfoGobRegId int16

func (r FullInstallPathInfo) GetTypeId() int16 {
 return FullInstallPathInfoGobRegId
}

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

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

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

 return err
}

var FilesystemDefaultsInfoGobRegId int16

func (r FilesystemDefaultsInfo) GetTypeId() int16 {
 return FilesystemDefaultsInfoGobRegId
}

// end of filesystem.go

// begin of radio.go
func init() {
 radioInfoGobRegId = gobtools.RegisterType(func() gobtools.CustomDec { return new(radioInfo) })
}

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

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

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

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

 return err
}

var radioInfoGobRegId int16

func (r radioInfo) GetTypeId() int16 {
 return radioInfoGobRegId
}

// end of radio.go

// begin of raw_binary.go
func init() {
 RawBinaryInfoGobRegId = gobtools.RegisterType(func() gobtools.CustomDec { return new(RawBinaryInfo) })
}

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

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

func (r RawBinaryInfo) CustomHash(hasher *proptools.Hasher) error {
 hasher.WriteString(":filesystem.RawBinaryInfo")
 hasher.WriteInt(1)
 hasher.WriteString(":filesystem.android.SymbolicOutputInfos")
 hasher.WriteString(":.[]*SymbolicOutputInfo")
 hasher.WriteInt(len(r.SrcSymbolInfos))
 for val1 := 0; val1 < len(r.SrcSymbolInfos); val1++ {
  hasher.WriteString(":.*SymbolicOutputInfo")
  val2 := r.SrcSymbolInfos[val1] == nil
  if val2 {
   hasher.WriteByte(0)
  } else {
   val3 := func(hasher *proptools.Hasher) error {
    if err := (*r.SrcSymbolInfos[val1]).CustomHash(hasher); err != nil {
     return err
    }
    return nil
   }
   if err := proptools.HashReference(hasher, uintptr(unsafe.Pointer(r.SrcSymbolInfos[val1])), val3); err != nil {
    return err
   }
  }
 }
 return nil
}

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

 return err
}

var RawBinaryInfoGobRegId int16

func (r RawBinaryInfo) GetTypeId() int16 {
 return RawBinaryInfoGobRegId
}

// end of raw_binary.go

// begin of super_image.go
func init() {
 SuperImageInfoGobRegId = gobtools.RegisterType(func() gobtools.CustomDec { return new(SuperImageInfo) })
}

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

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

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

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

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

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

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

func (r SuperImageInfo) CustomHash(hasher *proptools.Hasher) error {
 hasher.WriteString(":filesystem.SuperImageInfo")
 hasher.WriteInt(6)
 hasher.WriteString(":filesystem.android.Path")
 val1 := r.SuperImage == nil
 if val1 {
  hasher.WriteByte(0)
 } else {
  if v := reflect.ValueOf(r.SuperImage); v.Kind() == reflect.Ptr {
   if v.IsNil() {
    panic(fmt.Errorf("nil pointer is not supported in interface"))
   } else {
    val2 := r.SuperImage == nil
    if val2 {
     hasher.WriteByte(0)
    } else {
     val3 := func(hasher *proptools.Hasher) error { return r.SuperImage.(proptools.CustomHash).CustomHash(hasher) }
     if err := proptools.HashReference(hasher, uintptr(v.Pointer()), val3); err != nil {
      return err
     }
    }
   }
  } else {
   r.SuperImage.(proptools.CustomHash).CustomHash(hasher)
  }
 }
 hasher.WriteString(":.map[string]FilesystemInfo")
 hasher.WriteInt(len(r.SubImageInfo))
 val4 := make([]string, 0, len(r.SubImageInfo))
 for val6 := range r.SubImageInfo {
  val4 = append(val4, val6)
 }
 proptools.SortOrdered(val4)
 for _, val5 := range val4 {
  hasher.WriteString(":.string")
  hasher.WriteString(val5)
  if err := r.SubImageInfo[val5].CustomHash(hasher); err != nil {
   return err
  }
 }
 hasher.WriteString(":filesystem.android.Path")
 val7 := r.DynamicPartitionsInfo == nil
 if val7 {
  hasher.WriteByte(0)
 } else {
  if v := reflect.ValueOf(r.DynamicPartitionsInfo); v.Kind() == reflect.Ptr {
   if v.IsNil() {
    panic(fmt.Errorf("nil pointer is not supported in interface"))
   } else {
    val8 := r.DynamicPartitionsInfo == nil
    if val8 {
     hasher.WriteByte(0)
    } else {
     val9 := func(hasher *proptools.Hasher) error {
      return r.DynamicPartitionsInfo.(proptools.CustomHash).CustomHash(hasher)
     }
     if err := proptools.HashReference(hasher, uintptr(v.Pointer()), val9); err != nil {
      return err
     }
    }
   }
  } else {
   r.DynamicPartitionsInfo.(proptools.CustomHash).CustomHash(hasher)
  }
 }
 hasher.WriteString(":filesystem.android.Path")
 val10 := r.SuperEmptyImage == nil
 if val10 {
  hasher.WriteByte(0)
 } else {
  if v := reflect.ValueOf(r.SuperEmptyImage); v.Kind() == reflect.Ptr {
   if v.IsNil() {
    panic(fmt.Errorf("nil pointer is not supported in interface"))
   } else {
    val11 := r.SuperEmptyImage == nil
    if val11 {
     hasher.WriteByte(0)
    } else {
     val12 := func(hasher *proptools.Hasher) error {
      return r.SuperEmptyImage.(proptools.CustomHash).CustomHash(hasher)
     }
     if err := proptools.HashReference(hasher, uintptr(v.Pointer()), val12); err != nil {
      return err
     }
    }
   }
  } else {
   r.SuperEmptyImage.(proptools.CustomHash).CustomHash(hasher)
  }
 }
 hasher.WriteString(":.bool")
 if r.AbUpdate {
  hasher.WriteByte(1)
 } else {
  hasher.WriteByte(0)
 }
 hasher.WriteString(":.bool")
 if r.SuperImageInUpdatePackage {
  hasher.WriteByte(1)
 } else {
  hasher.WriteByte(0)
 }
 return nil
}

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

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

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

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

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

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

 return err
}

var SuperImageInfoGobRegId int16

func (r SuperImageInfo) GetTypeId() int16 {
 return SuperImageInfoGobRegId
}

// end of super_image.go

// begin of vbmeta.go
func init() {
 vbmetaPartitionInfoGobRegId = gobtools.RegisterType(func() gobtools.CustomDec { return new(vbmetaPartitionInfo) })
 vbmetaPartitionInfosGobRegId = gobtools.RegisterType(func() gobtools.CustomDec { return new(vbmetaPartitionInfos) })
}

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

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

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

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

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

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

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

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

func (r vbmetaPartitionInfo) CustomHash(hasher *proptools.Hasher) error {
 hasher.WriteString(":filesystem.vbmetaPartitionInfo")
 hasher.WriteInt(7)
 hasher.WriteString(":.string")
 hasher.WriteString(r.Name)
 hasher.WriteString(":.string")
 hasher.WriteString(r.FilesystemPartitionType)
 hasher.WriteString(":.int")
 hasher.WriteUint64(uint64(r.RollbackIndexLocation))
 hasher.WriteString(":filesystem.android.Path")
 val1 := r.PublicKey == nil
 if val1 {
  hasher.WriteByte(0)
 } else {
  if v := reflect.ValueOf(r.PublicKey); v.Kind() == reflect.Ptr {
   if v.IsNil() {
    panic(fmt.Errorf("nil pointer is not supported in interface"))
   } else {
    val2 := r.PublicKey == nil
    if val2 {
     hasher.WriteByte(0)
    } else {
     val3 := func(hasher *proptools.Hasher) error { return r.PublicKey.(proptools.CustomHash).CustomHash(hasher) }
     if err := proptools.HashReference(hasher, uintptr(v.Pointer()), val3); err != nil {
      return err
     }
    }
   }
  } else {
   r.PublicKey.(proptools.CustomHash).CustomHash(hasher)
  }
 }
 hasher.WriteString(":filesystem.android.Path")
 val4 := r.Output == nil
 if val4 {
  hasher.WriteByte(0)
 } else {
  if v := reflect.ValueOf(r.Output); v.Kind() == reflect.Ptr {
   if v.IsNil() {
    panic(fmt.Errorf("nil pointer is not supported in interface"))
   } else {
    val5 := r.Output == nil
    if val5 {
     hasher.WriteByte(0)
    } else {
     val6 := func(hasher *proptools.Hasher) error { return r.Output.(proptools.CustomHash).CustomHash(hasher) }
     if err := proptools.HashReference(hasher, uintptr(v.Pointer()), val6); err != nil {
      return err
     }
    }
   }
  } else {
   r.Output.(proptools.CustomHash).CustomHash(hasher)
  }
 }
 hasher.WriteString(":filesystem.android.Path")
 val7 := r.PropFileForMiscInfo == nil
 if val7 {
  hasher.WriteByte(0)
 } else {
  if v := reflect.ValueOf(r.PropFileForMiscInfo); v.Kind() == reflect.Ptr {
   if v.IsNil() {
    panic(fmt.Errorf("nil pointer is not supported in interface"))
   } else {
    val8 := r.PropFileForMiscInfo == nil
    if val8 {
     hasher.WriteByte(0)
    } else {
     val9 := func(hasher *proptools.Hasher) error {
      return r.PropFileForMiscInfo.(proptools.CustomHash).CustomHash(hasher)
     }
     if err := proptools.HashReference(hasher, uintptr(v.Pointer()), val9); err != nil {
      return err
     }
    }
   }
  } else {
   r.PropFileForMiscInfo.(proptools.CustomHash).CustomHash(hasher)
  }
 }
 hasher.WriteString(":.bool")
 if r.AbOtaBootloaderPartition {
  hasher.WriteByte(1)
 } else {
  hasher.WriteByte(0)
 }
 return nil
}

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

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

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

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

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

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

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

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

 return err
}

var vbmetaPartitionInfoGobRegId int16

func (r vbmetaPartitionInfo) GetTypeId() int16 {
 return vbmetaPartitionInfoGobRegId
}

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

 return err
}

var vbmetaPartitionInfosGobRegId int16

func (r vbmetaPartitionInfos) GetTypeId() int16 {
 return vbmetaPartitionInfosGobRegId
}

// end of vbmeta.go