Quelle  main_enc.go   Sprache: unbekannt

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

package main

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

// begin of gob_test_data.go
func init() {
 TestStructGobRegId = gobtools.RegisterType(func() gobtools.CustomDec { return new(TestStruct) })
 TestEchoGobRegId = gobtools.RegisterType(func() gobtools.CustomDec { return new(TestEcho) })
 testEchosGobRegId = gobtools.RegisterType(func() gobtools.CustomDec { return new(testEchos) })
 testStringMapGobRegId = gobtools.RegisterType(func() gobtools.CustomDec { return new(testStringMap) })
 testEchoMapGobRegId = gobtools.RegisterType(func() gobtools.CustomDec { return new(testEchoMap) })
 TestEmbedPtrGobRegId = gobtools.RegisterType(func() gobtools.CustomDec { return new(TestEmbedPtr) })
 TestPtrsGobRegId = gobtools.RegisterType(func() gobtools.CustomDec { return new(TestPtrs) })
 HashStructGobRegId = gobtools.RegisterType(func() gobtools.CustomDec { return new(HashStruct) })
 PointersGobRegId = gobtools.RegisterType(func() gobtools.CustomDec { return new(Pointers) })
 SlicesGobRegId = gobtools.RegisterType(func() gobtools.CustomDec { return new(Slices) })
 MapsGobRegId = gobtools.RegisterType(func() gobtools.CustomDec { return new(Maps) })
 InnerGobRegId = gobtools.RegisterType(func() gobtools.CustomDec { return new(Inner) })
 EmbeddedGobRegId = gobtools.RegisterType(func() gobtools.CustomDec { return new(Embedded) })
 NestedGobRegId = gobtools.RegisterType(func() gobtools.CustomDec { return new(Nested) })
 InterfaceImpl1GobRegId = gobtools.RegisterType(func() gobtools.CustomDec { return new(InterfaceImpl1) })
 InterfaceImpl2GobRegId = gobtools.RegisterType(func() gobtools.CustomDec { return new(InterfaceImpl2) })
 InterfaceHolderGobRegId = gobtools.RegisterType(func() gobtools.CustomDec { return new(InterfaceHolder) })
 UnexportedGobRegId = gobtools.RegisterType(func() gobtools.CustomDec { return new(Unexported) })
 ComplexGobRegId = gobtools.RegisterType(func() gobtools.CustomDec { return new(Complex) })
 PointerDuplicationGobRegId = gobtools.RegisterType(func() gobtools.CustomDec { return new(PointerDuplication) })
 Type1GobRegId = gobtools.RegisterType(func() gobtools.CustomDec { return new(Type1) })
 Type2GobRegId = gobtools.RegisterType(func() gobtools.CustomDec { return new(Type2) })
 InterfaceWrapperGobRegId = gobtools.RegisterType(func() gobtools.CustomDec { return new(InterfaceWrapper) })
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

 val9 := r.f20.Len() == 0
 if err = gobtools.EncodeBool(buf, val9); err != nil {
  return err
 }
 if !val9 {
  if err = gobtools.EncodeReference(ctx, r.f20, buf, func(v uniquelist.UniqueList[TestEcho], buf *bytes.Buffer) error {
   val10 := v.ToSlice()
   if val10 == nil {
    if err = gobtools.EncodeInt(buf, -1); err != nil {
     return err
    }
   } else {
    if err = gobtools.EncodeInt(buf, len(val10)); err != nil {
     return err
    }
    for val11 := 0; val11 < len(val10); val11++ {
     if err = val10[val11].Encode(ctx, buf); err != nil {
      return err
     }
    }
   }
   return nil
  }); err != nil {
   return err
  }
 }

 val12 := r.f21.Len() == 0
 if err = gobtools.EncodeBool(buf, val12); err != nil {
  return err
 }
 if !val12 {
  if err = gobtools.EncodeReference(ctx, r.f21, buf, func(v uniquelist.UniqueList[TestEchoInterface], buf *bytes.Buffer) error {
   val13 := v.ToSlice()
   if val13 == nil {
    if err = gobtools.EncodeInt(buf, -1); err != nil {
     return err
    }
   } else {
    if err = gobtools.EncodeInt(buf, len(val13)); err != nil {
     return err
    }
    for val14 := 0; val14 < len(val13); val14++ {
     if err = gobtools.EncodeInterface(ctx, buf, val13[val14]); err != nil {
      return err
     }
    }
   }
   return nil
  }); err != nil {
   return err
  }
 }

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

 for val25 := 0; val25 < len(r.f39); val25++ {
  if err = gobtools.EncodeUint64(buf, r.f39[val25]); err != nil {
   return err
  }
 }

 if r.f40 == nil {
  if err = gobtools.EncodeInt(buf, -1); err != nil {
   return err
  }
 } else {
  if err = gobtools.EncodeInt(buf, len(r.f40)); err != nil {
   return err
  }
  for val26, val27 := range r.f40 {
   if err = gobtools.EncodeString(buf, val26); err != nil {
    return err
   }
   if val27 == nil {
    if err = gobtools.EncodeInt(buf, -1); err != nil {
     return err
    }
   } else {
    if err = gobtools.EncodeInt(buf, len(val27)); err != nil {
     return err
    }
    for val28, val29 := range val27 {
     if err = gobtools.EncodeInt(buf, val28); err != nil {
      return err
     }
     if val29 == nil {
      if err = gobtools.EncodeInt(buf, -1); err != nil {
       return err
      }
     } else {
      if err = gobtools.EncodeInt(buf, len(val29)); err != nil {
       return err
      }
      for val30 := 0; val30 < len(val29); val30++ {
       val31 := val29[val30] == nil
       if err = gobtools.EncodeBool(buf, val31); err != nil {
        return err
       }
       if !val31 {
        if err = gobtools.EncodeBool(buf, (*val29[val30])); err != nil {
         return err
        }
       }
      }
     }
    }
   }
  }
 }

 val32 := r.f41 == unique.Handle[TestEcho]{}
 if err = gobtools.EncodeBool(buf, val32); err != nil {
  return err
 }
 if !val32 {
  if err = gobtools.EncodeReference(ctx, r.f41, buf, func(v unique.Handle[TestEcho], buf *bytes.Buffer) error {
   return v.Value().Encode(ctx, buf)
  }); err != nil {
   return err
  }
 }

 val33 := r.f42 == unique.Handle[TestEcho]{}
 if err = gobtools.EncodeBool(buf, val33); err != nil {
  return err
 }
 if !val33 {
  if err = gobtools.EncodeReference(ctx, r.f42, buf, func(v unique.Handle[TestEcho], buf *bytes.Buffer) error {
   return v.Value().Encode(ctx, buf)
  }); err != nil {
   return err
  }
 }
 return err
}

func (r TestStruct) CustomHash(hasher *proptools.Hasher) error {
 hasher.WriteString(":main.TestStruct")
 hasher.WriteInt(43)
 if err := r.TestEcho.CustomHash(hasher); err != nil {
  return err
 }
 hasher.WriteString(":.string")
 hasher.WriteString(r.f1)
 hasher.WriteString(":.int16")
 hasher.WriteUint64(uint64(r.f2))
 hasher.WriteString(":.int32")
 hasher.WriteUint64(uint64(r.f3))
 hasher.WriteString(":.bool")
 if r.f4 {
  hasher.WriteByte(1)
 } else {
  hasher.WriteByte(0)
 }
 hasher.WriteString(":.int64")
 hasher.WriteUint64(uint64(r.f5))
 hasher.WriteString(":.string")
 hasher.WriteString(r.f6)
 if err := r.f7.CustomHash(hasher); err != nil {
  return err
 }
 hasher.WriteString(":.uint16")
 hasher.WriteUint64(uint64(r.f8))
 hasher.WriteString(":.uint32")
 hasher.WriteUint64(uint64(r.f9))
 hasher.WriteString(":.uint64")
 hasher.WriteUint64(uint64(r.f10))
 hasher.WriteString(":.[]string")
 hasher.WriteInt(len(r.f11))
 for val1 := 0; val1 < len(r.f11); val1++ {
  hasher.WriteString(":.string")
  hasher.WriteString(r.f11[val1])
 }
 hasher.WriteString(":.map[string]int")
 hasher.WriteInt(len(r.f12))
 val2 := make([]string, 0, len(r.f12))
 for val4 := range r.f12 {
  val2 = append(val2, val4)
 }
 proptools.SortOrdered(val2)
 for _, val3 := range val2 {
  hasher.WriteString(":.string")
  hasher.WriteString(val3)
  hasher.WriteString(":.int")
  hasher.WriteUint64(uint64(r.f12[val3]))
 }
 hasher.WriteString(":.*string")
 val5 := r.f13 == nil
 if val5 {
  hasher.WriteByte(0)
 } else {
  val6 := func(hasher *proptools.Hasher) error {
   hasher.WriteString(":.string")
   hasher.WriteString((*r.f13))
   return nil
  }
  if err := proptools.HashReference(hasher, uintptr(unsafe.Pointer(r.f13)), val6); err != nil {
   return err
  }
 }
 hasher.WriteString(":.int")
 hasher.WriteUint64(uint64(r.f14))
 hasher.WriteString(":.[]int")
 hasher.WriteInt(len(r.f15))
 for val7 := 0; val7 < len(r.f15); val7++ {
  hasher.WriteString(":.int")
  hasher.WriteUint64(uint64(r.f15[val7]))
 }
 hasher.WriteString(":.[]TestEcho")
 hasher.WriteInt(len(r.f16))
 for val8 := 0; val8 < len(r.f16); val8++ {
  if err := r.f16[val8].CustomHash(hasher); err != nil {
   return err
  }
 }
 hasher.WriteString(":.*TestEcho")
 val9 := r.f17 == nil
 if val9 {
  hasher.WriteByte(0)
 } else {
  val10 := func(hasher *proptools.Hasher) error {
   if err := (*r.f17).CustomHash(hasher); err != nil {
    return err
   }
   return nil
  }
  if err := proptools.HashReference(hasher, uintptr(unsafe.Pointer(r.f17)), val10); err != nil {
   return err
  }
 }
 hasher.WriteString(":main.TestEchoInterface")
 val11 := r.f18 == nil
 if val11 {
  hasher.WriteByte(0)
 } else {
  if v := reflect.ValueOf(r.f18); v.Kind() == reflect.Ptr {
   if v.IsNil() {
    panic(fmt.Errorf("nil pointer is not supported in interface"))
   } else {
    val12 := r.f18 == nil
    if val12 {
     hasher.WriteByte(0)
    } else {
     val13 := func(hasher *proptools.Hasher) error { return r.f18.(proptools.CustomHash).CustomHash(hasher) }
     if err := proptools.HashReference(hasher, uintptr(v.Pointer()), val13); err != nil {
      return err
     }
    }
   }
  } else {
   r.f18.(proptools.CustomHash).CustomHash(hasher)
  }
 }
 hasher.WriteString(":main.testStrings")
 hasher.WriteString(":.[]string")
 hasher.WriteInt(len(r.f19))
 for val14 := 0; val14 < len(r.f19); val14++ {
  hasher.WriteString(":.string")
  hasher.WriteString(r.f19[val14])
 }
 hasher.WriteString(":.uniquelist.UniqueList[TestEcho]")
 val16 := func(hasher *proptools.Hasher, val15 TestEcho) error {
  if err := val15.CustomHash(hasher); err != nil {
   return err
  }
  return nil
 }
 if err := r.f20.Hash(hasher, "TestEcho", val16); err != nil {
  return err
 }
 hasher.WriteString(":.uniquelist.UniqueList[TestEchoInterface]")
 val21 := func(hasher *proptools.Hasher, val17 TestEchoInterface) error {
  hasher.WriteString(":main.TestEchoInterface")
  val18 := val17 == nil
  if val18 {
   hasher.WriteByte(0)
  } else {
   if v := reflect.ValueOf(val17); v.Kind() == reflect.Ptr {
    if v.IsNil() {
     panic(fmt.Errorf("nil pointer is not supported in interface"))
    } else {
     val19 := val17 == nil
     if val19 {
      hasher.WriteByte(0)
     } else {
      val20 := func(hasher *proptools.Hasher) error { return val17.(proptools.CustomHash).CustomHash(hasher) }
      if err := proptools.HashReference(hasher, uintptr(v.Pointer()), val20); err != nil {
       return err
      }
     }
    }
   } else {
    val17.(proptools.CustomHash).CustomHash(hasher)
   }
  }
  return nil
 }
 if err := r.f21.Hash(hasher, "TestEchoInterface", val21); err != nil {
  return err
 }
 if err := r.f22.CustomHash(hasher); err != nil {
  return err
 }
 hasher.WriteString(":.[]test.TypeAlias")
 hasher.WriteInt(len(r.f23))
 for val22 := 0; val22 < len(r.f23); val22++ {
  hasher.WriteString(":main.test.TypeAlias")
  hasher.WriteString(":.[]TypeStruct")
  hasher.WriteInt(len(r.f23[val22]))
  for val23 := 0; val23 < len(r.f23[val22]); val23++ {
   if err := r.f23[val22][val23].CustomHash(hasher); err != nil {
    return err
   }
  }
 }
 hasher.WriteString(":main.test.TypeInterface")
 val24 := r.f24 == nil
 if val24 {
  hasher.WriteByte(0)
 } else {
  if v := reflect.ValueOf(r.f24); v.Kind() == reflect.Ptr {
   if v.IsNil() {
    panic(fmt.Errorf("nil pointer is not supported in interface"))
   } else {
    val25 := r.f24 == nil
    if val25 {
     hasher.WriteByte(0)
    } else {
     val26 := func(hasher *proptools.Hasher) error { return r.f24.(proptools.CustomHash).CustomHash(hasher) }
     if err := proptools.HashReference(hasher, uintptr(v.Pointer()), val26); err != nil {
      return err
     }
    }
   }
  } else {
   r.f24.(proptools.CustomHash).CustomHash(hasher)
  }
 }
 hasher.WriteString(":main.test.TypeIdent")
 hasher.WriteString("github.com/google/blueprint/gobtools/test:test.TypeStruct")
 if err := test.TypeStruct(r.f25).CustomHash(hasher); err != nil {
  return err
 }
 val28 := func(hasher *proptools.Hasher, val27 TestEcho) error {
  if err := val27.CustomHash(hasher); err != nil {
   return err
  }
  return nil
 }
 if err := r.f26.Hash(hasher, "TestEcho", val28); err != nil {
  return err
 }
 val33 := func(hasher *proptools.Hasher, val29 TestEchoInterface) error {
  hasher.WriteString(":main.TestEchoInterface")
  val30 := val29 == nil
  if val30 {
   hasher.WriteByte(0)
  } else {
   if v := reflect.ValueOf(val29); v.Kind() == reflect.Ptr {
    if v.IsNil() {
     panic(fmt.Errorf("nil pointer is not supported in interface"))
    } else {
     val31 := val29 == nil
     if val31 {
      hasher.WriteByte(0)
     } else {
      val32 := func(hasher *proptools.Hasher) error { return val29.(proptools.CustomHash).CustomHash(hasher) }
      if err := proptools.HashReference(hasher, uintptr(v.Pointer()), val32); err != nil {
       return err
      }
     }
    }
   } else {
    val29.(proptools.CustomHash).CustomHash(hasher)
   }
  }
  return nil
 }
 if err := r.f27.Hash(hasher, "TestEchoInterface", val33); err != nil {
  return err
 }
 hasher.WriteString(":.map[int][]string")
 hasher.WriteInt(len(r.f28))
 val34 := make([]int, 0, len(r.f28))
 for val36 := range r.f28 {
  val34 = append(val34, val36)
 }
 proptools.SortOrdered(val34)
 for _, val35 := range val34 {
  hasher.WriteString(":.int")
  hasher.WriteUint64(uint64(val35))
  hasher.WriteString(":.[]string")
  hasher.WriteInt(len(r.f28[val35]))
  for val37 := 0; val37 < len(r.f28[val35]); val37++ {
   hasher.WriteString(":.string")
   hasher.WriteString(r.f28[val35][val37])
  }
 }
 hasher.WriteString(":.[][]string")
 hasher.WriteInt(len(r.f29))
 for val38 := 0; val38 < len(r.f29); val38++ {
  hasher.WriteString(":.[]string")
  hasher.WriteInt(len(r.f29[val38]))
  for val39 := 0; val39 < len(r.f29[val38]); val39++ {
   hasher.WriteString(":.string")
   hasher.WriteString(r.f29[val38][val39])
  }
 }
 val41 := func(hasher *proptools.Hasher, val40 string) error {
  hasher.WriteString(":.string")
  hasher.WriteString(val40)
  return nil
 }
 if err := r.f30.Hash(hasher, "string", val41); err != nil {
  return err
 }
 hasher.WriteString(":.any")
 val42 := r.f31 == nil
 if val42 {
  hasher.WriteByte(0)
 } else {
  if v := reflect.ValueOf(r.f31); v.Kind() == reflect.Ptr {
   if v.IsNil() {
    panic(fmt.Errorf("nil pointer is not supported in interface"))
   } else {
    val43 := r.f31 == nil
    if val43 {
     hasher.WriteByte(0)
    } else {
     val44 := func(hasher *proptools.Hasher) error { return r.f31.(proptools.CustomHash).CustomHash(hasher) }
     if err := proptools.HashReference(hasher, uintptr(v.Pointer()), val44); err != nil {
      return err
     }
    }
   }
  } else {
   r.f31.(proptools.CustomHash).CustomHash(hasher)
  }
 }
 hasher.WriteString(":.[]*test.TypeStruct")
 hasher.WriteInt(len(r.f32))
 for val45 := 0; val45 < len(r.f32); val45++ {
  hasher.WriteString(":.*test.TypeStruct")
  val46 := r.f32[val45] == nil
  if val46 {
   hasher.WriteByte(0)
  } else {
   val47 := func(hasher *proptools.Hasher) error {
    if err := (*r.f32[val45]).CustomHash(hasher); err != nil {
     return err
    }
    return nil
   }
   if err := proptools.HashReference(hasher, uintptr(unsafe.Pointer(r.f32[val45])), val47); err != nil {
    return err
   }
  }
 }
 hasher.WriteString(":.string")
 hasher.WriteString(r.f33)
 hasher.WriteString(":.string")
 hasher.WriteString(r.f34)
 hasher.WriteString(":main.r.f35")
 hasher.WriteInt(1)
 hasher.WriteString(":.string")
 hasher.WriteString(r.f35.s)
 if err := hasher.CalculateHashReflection(reflect.ValueOf(r.f36)); err != nil {
  return err
 }
 hasher.WriteString(":.*TestEmbedPtr")
 val48 := r.TestEmbedPtr == nil
 if val48 {
  hasher.WriteByte(0)
 } else {
  val49 := func(hasher *proptools.Hasher) error {
   if err := (*r.TestEmbedPtr).CustomHash(hasher); err != nil {
    return err
   }
   return nil
  }
  if err := proptools.HashReference(hasher, uintptr(unsafe.Pointer(r.TestEmbedPtr)), val49); err != nil {
   return err
  }
 }
 hasher.WriteString(":main.test.TypeBasic")
 hasher.WriteString(":.int")
 hasher.WriteUint64(uint64(int(r.f38)))
 hasher.WriteString(":.[2]uint64")
 hasher.WriteInt(len(r.f39))
 for val50 := 0; val50 < len(r.f39); val50++ {
  hasher.WriteString(":.uint64")
  hasher.WriteUint64(uint64(r.f39[val50]))
 }
 hasher.WriteString(":.map[string]map[int][]*bool")
 hasher.WriteInt(len(r.f40))
 val51 := make([]string, 0, len(r.f40))
 for val53 := range r.f40 {
  val51 = append(val51, val53)
 }
 proptools.SortOrdered(val51)
 for _, val52 := range val51 {
  hasher.WriteString(":.string")
  hasher.WriteString(val52)
  hasher.WriteString(":.map[int][]*bool")
  hasher.WriteInt(len(r.f40[val52]))
  val54 := make([]int, 0, len(r.f40[val52]))
  for val56 := range r.f40[val52] {
   val54 = append(val54, val56)
  }
  proptools.SortOrdered(val54)
  for _, val55 := range val54 {
   hasher.WriteString(":.int")
   hasher.WriteUint64(uint64(val55))
   hasher.WriteString(":.[]*bool")
   hasher.WriteInt(len(r.f40[val52][val55]))
   for val57 := 0; val57 < len(r.f40[val52][val55]); val57++ {
    hasher.WriteString(":.*bool")
    val58 := r.f40[val52][val55][val57] == nil
    if val58 {
     hasher.WriteByte(0)
    } else {
     val59 := func(hasher *proptools.Hasher) error {
      hasher.WriteString(":.bool")
      if *r.f40[val52][val55][val57] {
       hasher.WriteByte(1)
      } else {
       hasher.WriteByte(0)
      }
      return nil
     }
     if err := proptools.HashReference(hasher, uintptr(unsafe.Pointer(r.f40[val52][val55][val57])), val59); err != nil {
      return err
     }
    }
   }
  }
 }
 hasher.WriteString(":.unique.Handle[TestEcho]")
 val60 := r.f41 == unique.Handle[TestEcho]{}
 if val60 {
  hasher.WriteByte(0)
 } else {
  if err := proptools.HashReference(hasher, r.f41, func(*proptools.Hasher) error {
   return r.f41.Value().CustomHash(hasher)
  }); err != nil {
   return err
  }
 }
 hasher.WriteString(":main.testEchoHandle")
 hasher.WriteString(":.unique.Handle[TestEcho]")
 val61 := r.f42 == unique.Handle[TestEcho]{}
 if val61 {
  hasher.WriteByte(0)
 } else {
  if err := proptools.HashReference(hasher, r.f42, func(*proptools.Hasher) error {
   return r.f42.Value().CustomHash(hasher)
  }); err != nil {
   return err
  }
 }
 return nil
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

 var val45 bool
 if err = gobtools.DecodeBool(buf, &val45); err != nil {
  return err
 }
 if !val45 {
  tmp, err := gobtools.DecodeReference(ctx, &r.f20, buf, func(value *uniquelist.UniqueList[TestEcho], buf *bytes.Reader) error {
   var val46 []TestEcho
   var val47 int
   err = gobtools.DecodeInt(buf, &val47)
   if err != nil {
    return err
   }
   if val47 != -1 {
    val46 = make([]TestEcho, val47)
    for val48 := 0; val48 < int(val47); val48++ {
     if err = val46[val48].Decode(ctx, buf); err != nil {
      return err
     }
    }
   }
   *value = uniquelist.Make(val46)
   return nil
  })
  if err != nil {
   return err
  }
  r.f20 = *tmp
 }

 var val51 bool
 if err = gobtools.DecodeBool(buf, &val51); err != nil {
  return err
 }
 if !val51 {
  tmp, err := gobtools.DecodeReference(ctx, &r.f21, buf, func(value *uniquelist.UniqueList[TestEchoInterface], buf *bytes.Reader) error {
   var val52 []TestEchoInterface
   var val53 int
   err = gobtools.DecodeInt(buf, &val53)
   if err != nil {
    return err
   }
   if val53 != -1 {
    val52 = make([]TestEchoInterface, val53)
    for val54 := 0; val54 < int(val53); val54++ {
     if val56, err := gobtools.DecodeInterface(ctx, buf); err != nil {
      return err
     } else if val56 == nil {
      val52[val54] = nil
     } else {
      val52[val54] = val56.(TestEchoInterface)
     }
    }
   }
   *value = uniquelist.Make(val52)
   return nil
  })
  if err != nil {
   return err
  }
  r.f21 = *tmp
 }

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

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

 if val67, err := gobtools.DecodeInterface(ctx, buf); err != nil {
  return err
 } else if val67 == nil {
  r.f24 = nil
 } else {
  r.f24 = val67.(test.TypeInterface)
 }

 var val69 test.TypeStruct
 if err = val69.Decode(ctx, buf); err != nil {
  return err
 }
 r.f25 = test.TypeIdent(val69)

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

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

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

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

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

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

 var val93 int
 err = gobtools.DecodeInt(buf, &val93)
 if err != nil {
  return err
 }
 if val93 != -1 {
  r.f32 = make([]*test.TypeStruct, val93)
  for val94 := 0; val94 < int(val93); val94++ {
   var val96 bool
   if err = gobtools.DecodeBool(buf, &val96); err != nil {
    return err
   }
   if !val96 {
    var val95 test.TypeStruct
    if err = val95.Decode(ctx, buf); err != nil {
     return err
    }
    r.f32[val94] = &val95
   }
  }
 }

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

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

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

 var val104 bool
 if err = gobtools.DecodeBool(buf, &val104); err != nil {
  return err
 }
 if !val104 {
  var val103 TestEmbedPtr
  if err = val103.Decode(ctx, buf); err != nil {
   return err
  }
  r.TestEmbedPtr = &val103
 }

 var val107 int
 err = gobtools.DecodeInt(buf, &val107)
 if err != nil {
  return err
 }
 r.f38 = test.TypeBasic(val107)

 for val110 := 0; val110 < len(r.f39); val110++ {
  err = gobtools.DecodeUint64(buf, &r.f39[val110])
  if err != nil {
   return err
  }
 }

 var val112 int
 err = gobtools.DecodeInt(buf, &val112)
 if err != nil {
  return err
 }
 if val112 != -1 {
  r.f40 = make(map[string]map[int][]*bool, val112)
  for val113 := 0; val113 < int(val112); val113++ {
   var val114 string
   var val115 map[int][]*bool
   err = gobtools.DecodeString(buf, &val114)
   if err != nil {
    return err
   }
   var val117 int
   err = gobtools.DecodeInt(buf, &val117)
   if err != nil {
    return err
   }
   if val117 != -1 {
    val115 = make(map[int][]*bool, val117)
    for val118 := 0; val118 < int(val117); val118++ {
     var val119 int
     var val120 []*bool
     err = gobtools.DecodeInt(buf, &val119)
     if err != nil {
      return err
     }
     var val123 int
     err = gobtools.DecodeInt(buf, &val123)
     if err != nil {
      return err
     }
     if val123 != -1 {
      val120 = make([]*bool, val123)
      for val124 := 0; val124 < int(val123); val124++ {
       var val126 bool
       if err = gobtools.DecodeBool(buf, &val126); err != nil {
        return err
       }
       if !val126 {
        var val125 bool
        err = gobtools.DecodeBool(buf, &val125)
        if err != nil {
         return err
        }
        val120[val124] = &val125
       }
      }
     }
     val115[val119] = val120
    }
   }
   r.f40[val114] = val115
  }
 }

 var val129 bool
 if err = gobtools.DecodeBool(buf, &val129); err != nil {
  return err
 }
 if !val129 {
  tmp, err := gobtools.DecodeReference(ctx, &r.f41, buf, func(value *unique.Handle[TestEcho], buf *bytes.Reader) error {
   var val130 TestEcho
   if err = val130.Decode(ctx, buf); err != nil {
    return err
   }
   *value = unique.Make(val130)
   return nil
  })
  if err != nil {
   return err
  }
  r.f41 = *tmp
 }

 var val133 bool
 if err = gobtools.DecodeBool(buf, &val133); err != nil {
  return err
 }
 if !val133 {
  tmp, err := gobtools.DecodeReference(ctx, &r.f42, buf, func(value *unique.Handle[TestEcho], buf *bytes.Reader) error {
   var val134 TestEcho
   if err = val134.Decode(ctx, buf); err != nil {
    return err
   }
   *value = unique.Make(val134)
   return nil
  })
  if err != nil {
   return err
  }
  r.f42 = *tmp
 }

 return err
}

var TestStructGobRegId int16

func (r TestStruct) GetTypeId() int16 {
 return TestStructGobRegId
}

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

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

func (r TestEcho) CustomHash(hasher *proptools.Hasher) error {
 hasher.WriteString(":main.TestEcho")
 hasher.WriteInt(1)
 hasher.WriteString(":.string")
 hasher.WriteString(r.EchoStr)
 return nil
}

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

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

 return err
}

var TestEchoGobRegId int16

func (r TestEcho) GetTypeId() int16 {
 return TestEchoGobRegId
}

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

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

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

func (r *testEchos) 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([]TestEchoInterface, val2)
  for val3 := 0; val3 < int(val2); val3++ {
   if val5, err := gobtools.DecodeInterface(ctx, buf); err != nil {
    return err
   } else if val5 == nil {
    (*r)[val3] = nil
   } else {
    (*r)[val3] = val5.(TestEchoInterface)
   }
  }
 }

 return err
}

var testEchosGobRegId int16

func (r testEchos) GetTypeId() int16 {
 return testEchosGobRegId
}

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

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

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

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

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

 return err
}

var testStringMapGobRegId int16

func (r testStringMap) GetTypeId() int16 {
 return testStringMapGobRegId
}

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

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

func (r testEchoMap) CustomHash(hasher *proptools.Hasher) error {
 hasher.WriteString(":.map[TestEcho]*TestEcho")
 hasher.WriteInt(len(r))
 val1 := make([]TestEcho, 0, len(r))
 for val3 := range r {
  val1 = append(val1, val3)
 }
 proptools.SortCustom(val1)
 for _, val2 := range val1 {
  if err := val2.CustomHash(hasher); err != nil {
   return err
  }
  hasher.WriteString(":.*TestEcho")
  val4 := r[val2] == nil
  if val4 {
   hasher.WriteByte(0)
  } else {
   val5 := func(hasher *proptools.Hasher) error {
    if err := (*r[val2]).CustomHash(hasher); err != nil {
     return err
    }
    return nil
   }
   if err := proptools.HashReference(hasher, uintptr(unsafe.Pointer(r[val2])), val5); err != nil {
    return err
   }
  }
 }
 return nil
}

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

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

 return err
}

var testEchoMapGobRegId int16

func (r testEchoMap) GetTypeId() int16 {
 return testEchoMapGobRegId
}

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

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

func (r TestEmbedPtr) CustomHash(hasher *proptools.Hasher) error {
 hasher.WriteString(":main.TestEmbedPtr")
 hasher.WriteInt(1)
 hasher.WriteString(":.string")
 hasher.WriteString(r.f37)
 return nil
}

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

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

 return err
}

var TestEmbedPtrGobRegId int16

func (r TestEmbedPtr) GetTypeId() int16 {
 return TestEmbedPtrGobRegId
}

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

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

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

func (r TestPtrs) CustomHash(hasher *proptools.Hasher) error {
 hasher.WriteString(":main.TestPtrs")
 hasher.WriteInt(2)
 hasher.WriteString(":.*TestEcho")
 val1 := r.f1 == nil
 if val1 {
  hasher.WriteByte(0)
 } else {
  val2 := func(hasher *proptools.Hasher) error {
   if err := (*r.f1).CustomHash(hasher); err != nil {
    return err
   }
   return nil
  }
  if err := proptools.HashReference(hasher, uintptr(unsafe.Pointer(r.f1)), val2); err != nil {
   return err
  }
 }
 hasher.WriteString(":.*TestEcho")
 val3 := r.f2 == nil
 if val3 {
  hasher.WriteByte(0)
 } else {
  val4 := func(hasher *proptools.Hasher) error {
   if err := (*r.f2).CustomHash(hasher); err != nil {
    return err
   }
   return nil
  }
  if err := proptools.HashReference(hasher, uintptr(unsafe.Pointer(r.f2)), val4); err != nil {
   return err
  }
 }
 return nil
}

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

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

 return err
}

var TestPtrsGobRegId int16

func (r TestPtrs) GetTypeId() int16 {
 return TestPtrsGobRegId
}

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

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

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

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

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

func (r HashStruct) CustomHash(hasher *proptools.Hasher) error {
 hasher.WriteString(":main.HashStruct")
 hasher.WriteInt(4)
 hasher.WriteString(":.int")
 hasher.WriteUint64(uint64(r.I))
 hasher.WriteString(":.string")
 hasher.WriteString(r.S)
 hasher.WriteString(":.bool")
 if r.B {
  hasher.WriteByte(1)
 } else {
  hasher.WriteByte(0)
 }
 hasher.WriteString(":.int64")
 hasher.WriteUint64(uint64(r.F64))
 return nil
}

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

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

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

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

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

 return err
}

var HashStructGobRegId int16

func (r HashStruct) GetTypeId() int16 {
 return HashStructGobRegId
}

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

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

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

func (r Pointers) CustomHash(hasher *proptools.Hasher) error {
 hasher.WriteString(":main.Pointers")
 hasher.WriteInt(2)
 hasher.WriteString(":.*int")
 val1 := r.A == nil
 if val1 {
  hasher.WriteByte(0)
 } else {
  val2 := func(hasher *proptools.Hasher) error {
   hasher.WriteString(":.int")
   hasher.WriteUint64(uint64((*r.A)))
   return nil
  }
  if err := proptools.HashReference(hasher, uintptr(unsafe.Pointer(r.A)), val2); err != nil {
   return err
  }
 }
 hasher.WriteString(":.*string")
 val3 := r.S == nil
 if val3 {
  hasher.WriteByte(0)
 } else {
  val4 := func(hasher *proptools.Hasher) error {
   hasher.WriteString(":.string")
   hasher.WriteString((*r.S))
   return nil
  }
  if err := proptools.HashReference(hasher, uintptr(unsafe.Pointer(r.S)), val4); err != nil {
   return err
  }
 }
 return nil
}

func (r *Pointers) 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 int
  err = gobtools.DecodeInt(buf, &val1)
  if err != nil {
   return err
  }
  r.A = &val1
 }

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

 return err
}

var PointersGobRegId int16

func (r Pointers) GetTypeId() int16 {
 return PointersGobRegId
}

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

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

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

func (r Slices) CustomHash(hasher *proptools.Hasher) error {
 hasher.WriteString(":main.Slices")
 hasher.WriteInt(2)
 hasher.WriteString(":.[]int")
 hasher.WriteInt(len(r.A))
 for val1 := 0; val1 < len(r.A); val1++ {
  hasher.WriteString(":.int")
  hasher.WriteUint64(uint64(r.A[val1]))
 }
 hasher.WriteString(":.[]string")
 hasher.WriteInt(len(r.B))
 for val2 := 0; val2 < len(r.B); val2++ {
  hasher.WriteString(":.string")
  hasher.WriteString(r.B[val2])
 }
 return nil
}

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

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

 return err
}

var SlicesGobRegId int16

func (r Slices) GetTypeId() int16 {
 return SlicesGobRegId
}

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

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

func (r Maps) CustomHash(hasher *proptools.Hasher) error {
 hasher.WriteString(":main.Maps")
 hasher.WriteInt(1)
 hasher.WriteString(":.map[string]int")
 hasher.WriteInt(len(r.M))
 val1 := make([]string, 0, len(r.M))
 for val3 := range r.M {
  val1 = append(val1, val3)
 }
 proptools.SortOrdered(val1)
 for _, val2 := range val1 {
  hasher.WriteString(":.string")
  hasher.WriteString(val2)
  hasher.WriteString(":.int")
  hasher.WriteUint64(uint64(r.M[val2]))
 }
 return nil
}

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

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

 return err
}

var MapsGobRegId int16

func (r Maps) GetTypeId() int16 {
 return MapsGobRegId
}

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

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

func (r Inner) CustomHash(hasher *proptools.Hasher) error {
 hasher.WriteString(":main.Inner")
 hasher.WriteInt(1)
 hasher.WriteString(":.string")
 hasher.WriteString(r.Val)
 return nil
}

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

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

 return err
}

var InnerGobRegId int16

func (r Inner) GetTypeId() int16 {
 return InnerGobRegId
}

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

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

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

func (r Embedded) CustomHash(hasher *proptools.Hasher) error {
 hasher.WriteString(":main.Embedded")
 hasher.WriteInt(2)
 if err := r.Inner.CustomHash(hasher); err != nil {
  return err
 }
 hasher.WriteString(":.int32")
 hasher.WriteUint64(uint64(r.F))
 return nil
}

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

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

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

 return err
}

var EmbeddedGobRegId int16

func (r Embedded) GetTypeId() int16 {
 return EmbeddedGobRegId
}

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

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

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

func (r Nested) CustomHash(hasher *proptools.Hasher) error {
 hasher.WriteString(":main.Nested")
 hasher.WriteInt(2)
 if err := r.A.CustomHash(hasher); err != nil {
  return err
 }
 hasher.WriteString(":.*Inner")
 val1 := r.B == nil
 if val1 {
  hasher.WriteByte(0)
 } else {
  val2 := func(hasher *proptools.Hasher) error {
   if err := (*r.B).CustomHash(hasher); err != nil {
    return err
   }
   return nil
  }
  if err := proptools.HashReference(hasher, uintptr(unsafe.Pointer(r.B)), val2); err != nil {
   return err
  }
 }
 return nil
}

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

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

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

 return err
}

var NestedGobRegId int16

func (r Nested) GetTypeId() int16 {
 return NestedGobRegId
}

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

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

func (r InterfaceImpl1) CustomHash(hasher *proptools.Hasher) error {
 hasher.WriteString(":main.InterfaceImpl1")
 hasher.WriteInt(1)
 hasher.WriteString(":.string")
 hasher.WriteString(r.V)
 return nil
}

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

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

 return err
}

var InterfaceImpl1GobRegId int16

func (r InterfaceImpl1) GetTypeId() int16 {
 return InterfaceImpl1GobRegId
}

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

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

func (r InterfaceImpl2) CustomHash(hasher *proptools.Hasher) error {
 hasher.WriteString(":main.InterfaceImpl2")
 hasher.WriteInt(1)
 hasher.WriteString(":.string")
 hasher.WriteString(r.V)
 return nil
}

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

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

 return err
}

var InterfaceImpl2GobRegId int16

func (r InterfaceImpl2) GetTypeId() int16 {
 return InterfaceImpl2GobRegId
}

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

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

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

func (r *InterfaceHolder) 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.I = nil
 } else {
  r.I = val2.(MyInterface)
 }

 return err
}

var InterfaceHolderGobRegId int16

func (r InterfaceHolder) GetTypeId() int16 {
 return InterfaceHolderGobRegId
}

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

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

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

func (r Unexported) CustomHash(hasher *proptools.Hasher) error {
 hasher.WriteString(":main.Unexported")
 hasher.WriteInt(2)
 hasher.WriteString(":.string")
 hasher.WriteString(r.Exported)
 hasher.WriteString(":.string")
 hasher.WriteString(r.unexported)
 return nil
}

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

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

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

 return err
}

var UnexportedGobRegId int16

func (r Unexported) GetTypeId() int16 {
 return UnexportedGobRegId
}

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

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

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

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

func (r Complex) CustomHash(hasher *proptools.Hasher) error {
 hasher.WriteString(":main.Complex")
 hasher.WriteInt(3)
 hasher.WriteString(":.map[string][]int")
 hasher.WriteInt(len(r.MapOfSlices))
 val1 := make([]string, 0, len(r.MapOfSlices))
 for val3 := range r.MapOfSlices {
  val1 = append(val1, val3)
 }
 proptools.SortOrdered(val1)
 for _, val2 := range val1 {
  hasher.WriteString(":.string")
  hasher.WriteString(val2)
  hasher.WriteString(":.[]int")
  hasher.WriteInt(len(r.MapOfSlices[val2]))
  for val4 := 0; val4 < len(r.MapOfSlices[val2]); val4++ {
   hasher.WriteString(":.int")
   hasher.WriteUint64(uint64(r.MapOfSlices[val2][val4]))
  }
 }
 hasher.WriteString(":.[]*Inner")
 hasher.WriteInt(len(r.SliceOfPtrs))
 for val5 := 0; val5 < len(r.SliceOfPtrs); val5++ {
  hasher.WriteString(":.*Inner")
  val6 := r.SliceOfPtrs[val5] == nil
  if val6 {
   hasher.WriteByte(0)
  } else {
   val7 := func(hasher *proptools.Hasher) error {
    if err := (*r.SliceOfPtrs[val5]).CustomHash(hasher); err != nil {
     return err
    }
    return nil
   }
   if err := proptools.HashReference(hasher, uintptr(unsafe.Pointer(r.SliceOfPtrs[val5])), val7); err != nil {
    return err
   }
  }
 }
 hasher.WriteString(":main.MyInterface")
 val8 := r.InterfaceField == nil
 if val8 {
  hasher.WriteByte(0)
 } else {
  if v := reflect.ValueOf(r.InterfaceField); v.Kind() == reflect.Ptr {
   if v.IsNil() {
    panic(fmt.Errorf("nil pointer is not supported in interface"))
   } else {
    val9 := r.InterfaceField == nil
    if val9 {
     hasher.WriteByte(0)
    } else {
     val10 := func(hasher *proptools.Hasher) error {
      return r.InterfaceField.(proptools.CustomHash).CustomHash(hasher)
     }
     if err := proptools.HashReference(hasher, uintptr(v.Pointer()), val10); err != nil {
      return err
     }
    }
   }
  } else {
   r.InterfaceField.(proptools.CustomHash).CustomHash(hasher)
  }
 }
 return nil
}

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

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

 var val11 int
 err = gobtools.DecodeInt(buf, &val11)
 if err != nil {
  return err
 }
 if val11 != -1 {
  r.SliceOfPtrs = make([]*Inner, val11)
  for val12 := 0; val12 < int(val11); val12++ {
   var val14 bool
   if err = gobtools.DecodeBool(buf, &val14); err != nil {
    return err
   }
   if !val14 {
    var val13 Inner
    if err = val13.Decode(ctx, buf); err != nil {
     return err
    }
    r.SliceOfPtrs[val12] = &val13
   }
  }
 }

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

 return err
}

var ComplexGobRegId int16

func (r Complex) GetTypeId() int16 {
 return ComplexGobRegId
}

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

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

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

func (r PointerDuplication) CustomHash(hasher *proptools.Hasher) error {
 hasher.WriteString(":main.PointerDuplication")
 hasher.WriteInt(2)
 hasher.WriteString(":.*string")
 val1 := r.F1 == nil
 if val1 {
  hasher.WriteByte(0)
 } else {
  val2 := func(hasher *proptools.Hasher) error {
   hasher.WriteString(":.string")
   hasher.WriteString((*r.F1))
   return nil
  }
  if err := proptools.HashReference(hasher, uintptr(unsafe.Pointer(r.F1)), val2); err != nil {
   return err
  }
 }
 hasher.WriteString(":.*string")
 val3 := r.F2 == nil
 if val3 {
  hasher.WriteByte(0)
 } else {
  val4 := func(hasher *proptools.Hasher) error {
   hasher.WriteString(":.string")
   hasher.WriteString((*r.F2))
   return nil
  }
  if err := proptools.HashReference(hasher, uintptr(unsafe.Pointer(r.F2)), val4); err != nil {
   return err
  }
 }
 return nil
}

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

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

 return err
}

var PointerDuplicationGobRegId int16

func (r PointerDuplication) GetTypeId() int16 {
 return PointerDuplicationGobRegId
}

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

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

func (r Type1) CustomHash(hasher *proptools.Hasher) error {
 hasher.WriteString(":main.Type1")
 hasher.WriteInt(1)
 hasher.WriteString(":.string")
 hasher.WriteString(r.S)
 return nil
}

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

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

 return err
}

var Type1GobRegId int16

func (r Type1) GetTypeId() int16 {
 return Type1GobRegId
}

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

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

func (r Type2) CustomHash(hasher *proptools.Hasher) error {
 hasher.WriteString(":main.Type2")
 hasher.WriteInt(1)
 hasher.WriteString(":.string")
 hasher.WriteString(r.S)
 return nil
}

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

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

 return err
}

var Type2GobRegId int16

func (r Type2) GetTypeId() int16 {
 return Type2GobRegId
}

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

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

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

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

 return err
}

var InterfaceWrapperGobRegId int16

func (r InterfaceWrapper) GetTypeId() int16 {
 return InterfaceWrapperGobRegId
}

// end of gob_test_data.go