diff --git a/groot/gen.rtree.go b/groot/gen.rtree.go
index 33b50731..a3b0b2dc 100644
--- a/groot/gen.rtree.go
+++ b/groot/gen.rtree.go
@@ -812,20 +812,16 @@ func (leaf *rleaf{{.Kind}}{{.Name}}) ivalue() int { return int(*leaf.v) }
 func unsafeDecayArray{{.Name}}(ptr interface{}) interface{} {
 	rv := reflect.ValueOf(ptr).Elem()
 	sz := rv.Type().Size() / {{.Size}}
-	arr := (*[0]{{.Type}})(unsafe.Pointer(rv.UnsafeAddr()))
-	sli := (*arr)[:]
-	hdr := (*reflect.SliceHeader)(unsafe.Pointer(&sli))
-	hdr.Len = int(sz)
-	hdr.Cap = int(sz)
+	sli := unsafe.Slice((*{{.Type}})(unsafe.Pointer(rv.UnsafeAddr())), sz)
 	return &sli
 }
 
 func unsafeDecaySliceArray{{.Name}}(ptr *[]{{.Type}}, size int) interface{} {
-	var sli []{{.Type}}
-	hdr := (*reflect.SliceHeader)(unsafe.Pointer(&sli))
-	hdr.Len = int(size)
-	hdr.Cap = int(size)
-	hdr.Data = (*reflect.SliceHeader)(unsafe.Pointer(ptr)).Data
+	if *ptr == nil {
+		var sli []{{.Type}}
+		return &sli
+	}
+	sli := unsafe.Slice(unsafe.SliceData(*ptr), size)
 	return &sli
 }
 {{- end}}
diff --git a/groot/rtree/rleaf_gen.go b/groot/rtree/rleaf_gen.go
index 342276f4..06b87734 100644
--- a/groot/rtree/rleaf_gen.go
+++ b/groot/rtree/rleaf_gen.go
@@ -110,20 +110,16 @@ func (leaf *rleafArrBool) Offset() int64 {
 func unsafeDecayArrayBool(ptr interface{}) interface{} {
 	rv := reflect.ValueOf(ptr).Elem()
 	sz := rv.Type().Size() / 1
-	arr := (*[0]bool)(unsafe.Pointer(rv.UnsafeAddr()))
-	sli := (*arr)[:]
-	hdr := (*reflect.SliceHeader)(unsafe.Pointer(&sli))
-	hdr.Len = int(sz)
-	hdr.Cap = int(sz)
+	sli := unsafe.Slice((*bool)(unsafe.Pointer(rv.UnsafeAddr())), sz)
 	return &sli
 }
 
 func unsafeDecaySliceArrayBool(ptr *[]bool, size int) interface{} {
-	var sli []bool
-	hdr := (*reflect.SliceHeader)(unsafe.Pointer(&sli))
-	hdr.Len = int(size)
-	hdr.Cap = int(size)
-	hdr.Data = (*reflect.SliceHeader)(unsafe.Pointer(ptr)).Data
+	if *ptr == nil {
+		var sli []bool
+		return &sli
+	}
+	sli := unsafe.Slice(unsafe.SliceData(*ptr), size)
 	return &sli
 }
 
@@ -261,20 +257,16 @@ func (leaf *rleafArrI8) Offset() int64 {
 func unsafeDecayArrayI8(ptr interface{}) interface{} {
 	rv := reflect.ValueOf(ptr).Elem()
 	sz := rv.Type().Size() / 1
-	arr := (*[0]int8)(unsafe.Pointer(rv.UnsafeAddr()))
-	sli := (*arr)[:]
-	hdr := (*reflect.SliceHeader)(unsafe.Pointer(&sli))
-	hdr.Len = int(sz)
-	hdr.Cap = int(sz)
+	sli := unsafe.Slice((*int8)(unsafe.Pointer(rv.UnsafeAddr())), sz)
 	return &sli
 }
 
 func unsafeDecaySliceArrayI8(ptr *[]int8, size int) interface{} {
-	var sli []int8
-	hdr := (*reflect.SliceHeader)(unsafe.Pointer(&sli))
-	hdr.Len = int(size)
-	hdr.Cap = int(size)
-	hdr.Data = (*reflect.SliceHeader)(unsafe.Pointer(ptr)).Data
+	if *ptr == nil {
+		var sli []int8
+		return &sli
+	}
+	sli := unsafe.Slice(unsafe.SliceData(*ptr), size)
 	return &sli
 }
 
@@ -412,20 +404,16 @@ func (leaf *rleafArrI16) Offset() int64 {
 func unsafeDecayArrayI16(ptr interface{}) interface{} {
 	rv := reflect.ValueOf(ptr).Elem()
 	sz := rv.Type().Size() / 2
-	arr := (*[0]int16)(unsafe.Pointer(rv.UnsafeAddr()))
-	sli := (*arr)[:]
-	hdr := (*reflect.SliceHeader)(unsafe.Pointer(&sli))
-	hdr.Len = int(sz)
-	hdr.Cap = int(sz)
+	sli := unsafe.Slice((*int16)(unsafe.Pointer(rv.UnsafeAddr())), sz)
 	return &sli
 }
 
 func unsafeDecaySliceArrayI16(ptr *[]int16, size int) interface{} {
-	var sli []int16
-	hdr := (*reflect.SliceHeader)(unsafe.Pointer(&sli))
-	hdr.Len = int(size)
-	hdr.Cap = int(size)
-	hdr.Data = (*reflect.SliceHeader)(unsafe.Pointer(ptr)).Data
+	if *ptr == nil {
+		var sli []int16
+		return &sli
+	}
+	sli := unsafe.Slice(unsafe.SliceData(*ptr), size)
 	return &sli
 }
 
@@ -563,20 +551,16 @@ func (leaf *rleafArrI32) Offset() int64 {
 func unsafeDecayArrayI32(ptr interface{}) interface{} {
 	rv := reflect.ValueOf(ptr).Elem()
 	sz := rv.Type().Size() / 4
-	arr := (*[0]int32)(unsafe.Pointer(rv.UnsafeAddr()))
-	sli := (*arr)[:]
-	hdr := (*reflect.SliceHeader)(unsafe.Pointer(&sli))
-	hdr.Len = int(sz)
-	hdr.Cap = int(sz)
+	sli := unsafe.Slice((*int32)(unsafe.Pointer(rv.UnsafeAddr())), sz)
 	return &sli
 }
 
 func unsafeDecaySliceArrayI32(ptr *[]int32, size int) interface{} {
-	var sli []int32
-	hdr := (*reflect.SliceHeader)(unsafe.Pointer(&sli))
-	hdr.Len = int(size)
-	hdr.Cap = int(size)
-	hdr.Data = (*reflect.SliceHeader)(unsafe.Pointer(ptr)).Data
+	if *ptr == nil {
+		var sli []int32
+		return &sli
+	}
+	sli := unsafe.Slice(unsafe.SliceData(*ptr), size)
 	return &sli
 }
 
@@ -714,20 +698,16 @@ func (leaf *rleafArrI64) Offset() int64 {
 func unsafeDecayArrayI64(ptr interface{}) interface{} {
 	rv := reflect.ValueOf(ptr).Elem()
 	sz := rv.Type().Size() / 8
-	arr := (*[0]int64)(unsafe.Pointer(rv.UnsafeAddr()))
-	sli := (*arr)[:]
-	hdr := (*reflect.SliceHeader)(unsafe.Pointer(&sli))
-	hdr.Len = int(sz)
-	hdr.Cap = int(sz)
+	sli := unsafe.Slice((*int64)(unsafe.Pointer(rv.UnsafeAddr())), sz)
 	return &sli
 }
 
 func unsafeDecaySliceArrayI64(ptr *[]int64, size int) interface{} {
-	var sli []int64
-	hdr := (*reflect.SliceHeader)(unsafe.Pointer(&sli))
-	hdr.Len = int(size)
-	hdr.Cap = int(size)
-	hdr.Data = (*reflect.SliceHeader)(unsafe.Pointer(ptr)).Data
+	if *ptr == nil {
+		var sli []int64
+		return &sli
+	}
+	sli := unsafe.Slice(unsafe.SliceData(*ptr), size)
 	return &sli
 }
 
@@ -865,20 +845,16 @@ func (leaf *rleafArrU8) Offset() int64 {
 func unsafeDecayArrayU8(ptr interface{}) interface{} {
 	rv := reflect.ValueOf(ptr).Elem()
 	sz := rv.Type().Size() / 1
-	arr := (*[0]uint8)(unsafe.Pointer(rv.UnsafeAddr()))
-	sli := (*arr)[:]
-	hdr := (*reflect.SliceHeader)(unsafe.Pointer(&sli))
-	hdr.Len = int(sz)
-	hdr.Cap = int(sz)
+	sli := unsafe.Slice((*uint8)(unsafe.Pointer(rv.UnsafeAddr())), sz)
 	return &sli
 }
 
 func unsafeDecaySliceArrayU8(ptr *[]uint8, size int) interface{} {
-	var sli []uint8
-	hdr := (*reflect.SliceHeader)(unsafe.Pointer(&sli))
-	hdr.Len = int(size)
-	hdr.Cap = int(size)
-	hdr.Data = (*reflect.SliceHeader)(unsafe.Pointer(ptr)).Data
+	if *ptr == nil {
+		var sli []uint8
+		return &sli
+	}
+	sli := unsafe.Slice(unsafe.SliceData(*ptr), size)
 	return &sli
 }
 
@@ -1016,20 +992,16 @@ func (leaf *rleafArrU16) Offset() int64 {
 func unsafeDecayArrayU16(ptr interface{}) interface{} {
 	rv := reflect.ValueOf(ptr).Elem()
 	sz := rv.Type().Size() / 2
-	arr := (*[0]uint16)(unsafe.Pointer(rv.UnsafeAddr()))
-	sli := (*arr)[:]
-	hdr := (*reflect.SliceHeader)(unsafe.Pointer(&sli))
-	hdr.Len = int(sz)
-	hdr.Cap = int(sz)
+	sli := unsafe.Slice((*uint16)(unsafe.Pointer(rv.UnsafeAddr())), sz)
 	return &sli
 }
 
 func unsafeDecaySliceArrayU16(ptr *[]uint16, size int) interface{} {
-	var sli []uint16
-	hdr := (*reflect.SliceHeader)(unsafe.Pointer(&sli))
-	hdr.Len = int(size)
-	hdr.Cap = int(size)
-	hdr.Data = (*reflect.SliceHeader)(unsafe.Pointer(ptr)).Data
+	if *ptr == nil {
+		var sli []uint16
+		return &sli
+	}
+	sli := unsafe.Slice(unsafe.SliceData(*ptr), size)
 	return &sli
 }
 
@@ -1167,20 +1139,16 @@ func (leaf *rleafArrU32) Offset() int64 {
 func unsafeDecayArrayU32(ptr interface{}) interface{} {
 	rv := reflect.ValueOf(ptr).Elem()
 	sz := rv.Type().Size() / 4
-	arr := (*[0]uint32)(unsafe.Pointer(rv.UnsafeAddr()))
-	sli := (*arr)[:]
-	hdr := (*reflect.SliceHeader)(unsafe.Pointer(&sli))
-	hdr.Len = int(sz)
-	hdr.Cap = int(sz)
+	sli := unsafe.Slice((*uint32)(unsafe.Pointer(rv.UnsafeAddr())), sz)
 	return &sli
 }
 
 func unsafeDecaySliceArrayU32(ptr *[]uint32, size int) interface{} {
-	var sli []uint32
-	hdr := (*reflect.SliceHeader)(unsafe.Pointer(&sli))
-	hdr.Len = int(size)
-	hdr.Cap = int(size)
-	hdr.Data = (*reflect.SliceHeader)(unsafe.Pointer(ptr)).Data
+	if *ptr == nil {
+		var sli []uint32
+		return &sli
+	}
+	sli := unsafe.Slice(unsafe.SliceData(*ptr), size)
 	return &sli
 }
 
@@ -1318,20 +1286,16 @@ func (leaf *rleafArrU64) Offset() int64 {
 func unsafeDecayArrayU64(ptr interface{}) interface{} {
 	rv := reflect.ValueOf(ptr).Elem()
 	sz := rv.Type().Size() / 8
-	arr := (*[0]uint64)(unsafe.Pointer(rv.UnsafeAddr()))
-	sli := (*arr)[:]
-	hdr := (*reflect.SliceHeader)(unsafe.Pointer(&sli))
-	hdr.Len = int(sz)
-	hdr.Cap = int(sz)
+	sli := unsafe.Slice((*uint64)(unsafe.Pointer(rv.UnsafeAddr())), sz)
 	return &sli
 }
 
 func unsafeDecaySliceArrayU64(ptr *[]uint64, size int) interface{} {
-	var sli []uint64
-	hdr := (*reflect.SliceHeader)(unsafe.Pointer(&sli))
-	hdr.Len = int(size)
-	hdr.Cap = int(size)
-	hdr.Data = (*reflect.SliceHeader)(unsafe.Pointer(ptr)).Data
+	if *ptr == nil {
+		var sli []uint64
+		return &sli
+	}
+	sli := unsafe.Slice(unsafe.SliceData(*ptr), size)
 	return &sli
 }
 
@@ -1467,20 +1431,16 @@ func (leaf *rleafArrF32) Offset() int64 {
 func unsafeDecayArrayF32(ptr interface{}) interface{} {
 	rv := reflect.ValueOf(ptr).Elem()
 	sz := rv.Type().Size() / 4
-	arr := (*[0]float32)(unsafe.Pointer(rv.UnsafeAddr()))
-	sli := (*arr)[:]
-	hdr := (*reflect.SliceHeader)(unsafe.Pointer(&sli))
-	hdr.Len = int(sz)
-	hdr.Cap = int(sz)
+	sli := unsafe.Slice((*float32)(unsafe.Pointer(rv.UnsafeAddr())), sz)
 	return &sli
 }
 
 func unsafeDecaySliceArrayF32(ptr *[]float32, size int) interface{} {
-	var sli []float32
-	hdr := (*reflect.SliceHeader)(unsafe.Pointer(&sli))
-	hdr.Len = int(size)
-	hdr.Cap = int(size)
-	hdr.Data = (*reflect.SliceHeader)(unsafe.Pointer(ptr)).Data
+	if *ptr == nil {
+		var sli []float32
+		return &sli
+	}
+	sli := unsafe.Slice(unsafe.SliceData(*ptr), size)
 	return &sli
 }
 
@@ -1616,20 +1576,16 @@ func (leaf *rleafArrF64) Offset() int64 {
 func unsafeDecayArrayF64(ptr interface{}) interface{} {
 	rv := reflect.ValueOf(ptr).Elem()
 	sz := rv.Type().Size() / 8
-	arr := (*[0]float64)(unsafe.Pointer(rv.UnsafeAddr()))
-	sli := (*arr)[:]
-	hdr := (*reflect.SliceHeader)(unsafe.Pointer(&sli))
-	hdr.Len = int(sz)
-	hdr.Cap = int(sz)
+	sli := unsafe.Slice((*float64)(unsafe.Pointer(rv.UnsafeAddr())), sz)
 	return &sli
 }
 
 func unsafeDecaySliceArrayF64(ptr *[]float64, size int) interface{} {
-	var sli []float64
-	hdr := (*reflect.SliceHeader)(unsafe.Pointer(&sli))
-	hdr.Len = int(size)
-	hdr.Cap = int(size)
-	hdr.Data = (*reflect.SliceHeader)(unsafe.Pointer(ptr)).Data
+	if *ptr == nil {
+		var sli []float64
+		return &sli
+	}
+	sli := unsafe.Slice(unsafe.SliceData(*ptr), size)
 	return &sli
 }
 
@@ -1767,20 +1723,16 @@ func (leaf *rleafArrD32) Offset() int64 {
 func unsafeDecayArrayD32(ptr interface{}) interface{} {
 	rv := reflect.ValueOf(ptr).Elem()
 	sz := rv.Type().Size() / 8
-	arr := (*[0]root.Double32)(unsafe.Pointer(rv.UnsafeAddr()))
-	sli := (*arr)[:]
-	hdr := (*reflect.SliceHeader)(unsafe.Pointer(&sli))
-	hdr.Len = int(sz)
-	hdr.Cap = int(sz)
+	sli := unsafe.Slice((*root.Double32)(unsafe.Pointer(rv.UnsafeAddr())), sz)
 	return &sli
 }
 
 func unsafeDecaySliceArrayD32(ptr *[]root.Double32, size int) interface{} {
-	var sli []root.Double32
-	hdr := (*reflect.SliceHeader)(unsafe.Pointer(&sli))
-	hdr.Len = int(size)
-	hdr.Cap = int(size)
-	hdr.Data = (*reflect.SliceHeader)(unsafe.Pointer(ptr)).Data
+	if *ptr == nil {
+		var sli []root.Double32
+		return &sli
+	}
+	sli := unsafe.Slice(unsafe.SliceData(*ptr), size)
 	return &sli
 }
 
@@ -1919,20 +1871,16 @@ func (leaf *rleafArrF16) Offset() int64 {
 func unsafeDecayArrayF16(ptr interface{}) interface{} {
 	rv := reflect.ValueOf(ptr).Elem()
 	sz := rv.Type().Size() / 4
-	arr := (*[0]root.Float16)(unsafe.Pointer(rv.UnsafeAddr()))
-	sli := (*arr)[:]
-	hdr := (*reflect.SliceHeader)(unsafe.Pointer(&sli))
-	hdr.Len = int(sz)
-	hdr.Cap = int(sz)
+	sli := unsafe.Slice((*root.Float16)(unsafe.Pointer(rv.UnsafeAddr())), sz)
 	return &sli
 }
 
 func unsafeDecaySliceArrayF16(ptr *[]root.Float16, size int) interface{} {
-	var sli []root.Float16
-	hdr := (*reflect.SliceHeader)(unsafe.Pointer(&sli))
-	hdr.Len = int(size)
-	hdr.Cap = int(size)
-	hdr.Data = (*reflect.SliceHeader)(unsafe.Pointer(ptr)).Data
+	if *ptr == nil {
+		var sli []root.Float16
+		return &sli
+	}
+	sli := unsafe.Slice(unsafe.SliceData(*ptr), size)
 	return &sli
 }
 
@@ -2069,20 +2017,16 @@ func (leaf *rleafArrStr) Offset() int64 {
 func unsafeDecayArrayStr(ptr interface{}) interface{} {
 	rv := reflect.ValueOf(ptr).Elem()
 	sz := rv.Type().Size() / 16
-	arr := (*[0]string)(unsafe.Pointer(rv.UnsafeAddr()))
-	sli := (*arr)[:]
-	hdr := (*reflect.SliceHeader)(unsafe.Pointer(&sli))
-	hdr.Len = int(sz)
-	hdr.Cap = int(sz)
+	sli := unsafe.Slice((*string)(unsafe.Pointer(rv.UnsafeAddr())), sz)
 	return &sli
 }
 
 func unsafeDecaySliceArrayStr(ptr *[]string, size int) interface{} {
-	var sli []string
-	hdr := (*reflect.SliceHeader)(unsafe.Pointer(&sli))
-	hdr.Len = int(size)
-	hdr.Cap = int(size)
-	hdr.Data = (*reflect.SliceHeader)(unsafe.Pointer(ptr)).Data
+	if *ptr == nil {
+		var sli []string
+		return &sli
+	}
+	sli := unsafe.Slice(unsafe.SliceData(*ptr), size)
 	return &sli
 }