beam-commits mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From "ASF GitHub Bot (JIRA)" <j...@apache.org>
Subject [jira] [Commented] (BEAM-3388) Reduce Go runtime reflective overhead
Date Tue, 09 Jan 2018 17:48:07 GMT

    [ https://issues.apache.org/jira/browse/BEAM-3388?page=com.atlassian.jira.plugin.system.issuetabpanels:comment-tabpanel&focusedCommentId=16318806#comment-16318806 ] 

ASF GitHub Bot commented on BEAM-3388:
--------------------------------------

robertwb closed pull request #4336: [BEAM-3388] Avoid various reflection and re-processing in the Go SDK runtime
URL: https://github.com/apache/beam/pull/4336
 
 
   

This is a PR merged from a forked repository.
As GitHub hides the original diff on merge, it is displayed below for
the sake of provenance:

As this is a foreign pull request (from a fork), the diff is supplied
below (as it won't show otherwise due to GitHub magic):

diff --git a/sdks/go/pkg/beam/core/runtime/exec/coder.go b/sdks/go/pkg/beam/core/runtime/exec/coder.go
index 2253c363016..8c4e6a596af 100644
--- a/sdks/go/pkg/beam/core/runtime/exec/coder.go
+++ b/sdks/go/pkg/beam/core/runtime/exec/coder.go
@@ -22,7 +22,6 @@ import (
 	"reflect"
 	"time"
 
-	"github.com/apache/beam/sdks/go/pkg/beam/core/funcx"
 	"github.com/apache/beam/sdks/go/pkg/beam/core/graph"
 	"github.com/apache/beam/sdks/go/pkg/beam/core/graph/coder"
 	"github.com/apache/beam/sdks/go/pkg/beam/core/typex"
@@ -63,139 +62,202 @@ type DataManager interface {
 // work, because each "element" can be too large to fit into memory. Instead,
 // we handle the top GBK/CoGBK layer in the processing node directly.
 
-// EncodeElement uses the supplied coder to write the data in val to the supplied io.Writer.
-func EncodeElement(c *coder.Coder, val FullValue, w io.Writer) error {
+// ElementEncoder handles FullValue serialization to a byte stream. The encoder
+// can be reused, even if an error is encountered.
+type ElementEncoder interface {
+	// Encode serializes the given value to the writer.
+	Encode(FullValue, io.Writer) error
+}
+
+// ElementDecoder handles FullValue deserialization from a byte stream. The decoder
+// can be reused, even if an error is encountered.
+type ElementDecoder interface {
+	// Decode deserializes a value from the given reader.
+	Decode(io.Reader) (FullValue, error)
+}
+
+// MakeElementEncoder returns a ElementCoder for the given coder. It panics
+// if given a coder with stream types, such as GBK.
+func MakeElementEncoder(c *coder.Coder) ElementEncoder {
 	switch c.Kind {
 	case coder.Bytes:
-		// Encoding: size (varint) + raw data
+		return &bytesEncoder{}
 
-		data := reflectx.UnderlyingType(val.Elm).Convert(reflectx.ByteSlice).Interface().([]byte)
-		size := len(data)
+	case coder.VarInt:
+		return &varIntEncoder{}
 
-		if err := coder.EncodeVarInt((int32)(size), w); err != nil {
-			return err
+	case coder.Custom:
+		return &customEncoder{
+			t:   c.Custom.Type,
+			enc: makeEncoder(c.Custom.Enc),
 		}
-		_, err := w.Write(data)
-		return err
 
-	case coder.VarInt:
-		// Encoding: beam varint
+	case coder.KV:
+		return &kvEncoder{
+			fst: MakeElementEncoder(c.Components[0]),
+			snd: MakeElementEncoder(c.Components[1]),
+		}
 
-		n := reflectx.UnderlyingType(val.Elm).Convert(reflectx.Int32).Interface().(int32)
-		return coder.EncodeVarInt(n, w)
+	default:
+		panic(fmt.Sprintf("Unexpected coder: %v", c))
+	}
+}
 
-	case coder.Custom:
-		enc := c.Custom.Enc
+// MakeElementDecoder returns a ElementDecoder for the given coder. It panics
+// if given a coder with stream types, such as GBK.
+func MakeElementDecoder(c *coder.Coder) ElementDecoder {
+	switch c.Kind {
+	case coder.Bytes:
+		return &bytesDecoder{}
 
-		// (1) Call encode
+	case coder.VarInt:
+		return &varIntDecoder{}
 
-		args := make([]reflect.Value, len(enc.Param))
-		if index, ok := enc.Type(); ok {
-			args[index] = reflect.ValueOf(c.Custom.Type)
+	case coder.Custom:
+		return &customDecoder{
+			t:   c.Custom.Type,
+			dec: makeDecoder(c.Custom.Dec),
 		}
-		params := enc.Params(funcx.FnValue)
-		args[params[0]] = val.Elm
 
-		ret, err := reflectCallNoPanic(enc.Fn, args)
-		if err != nil {
-			return err
-		}
-		if index, ok := enc.Error(); ok && !ret[index].IsNil() {
-			return fmt.Errorf("encode error: %v", ret[index].Interface())
+	case coder.KV:
+		return &kvDecoder{
+			fst: MakeElementDecoder(c.Components[0]),
+			snd: MakeElementDecoder(c.Components[1]),
 		}
-		data := ret[enc.Returns(funcx.RetValue)[0]].Interface().([]byte)
 
-		// (2) Add length prefix
+	default:
+		panic(fmt.Sprintf("Unexpected coder: %v", c))
+	}
+}
+
+type bytesEncoder struct{}
 
-		size := len(data)
-		if err := coder.EncodeVarInt((int32)(size), w); err != nil {
-			return err
-		}
-		_, err = w.Write(data)
+func (*bytesEncoder) Encode(val FullValue, w io.Writer) error {
+	// Encoding: size (varint) + raw data
+
+	data := reflectx.UnderlyingType(val.Elm).Convert(reflectx.ByteSlice).Interface().([]byte)
+	size := len(data)
+
+	if err := coder.EncodeVarInt((int32)(size), w); err != nil {
 		return err
+	}
+	_, err := w.Write(data)
+	return err
+}
 
-	case coder.KV:
-		if err := EncodeElement(c.Components[0], FullValue{Elm: val.Elm}, w); err != nil {
-			return err
-		}
-		return EncodeElement(c.Components[1], FullValue{Elm: val.Elm2}, w)
+type bytesDecoder struct{}
 
-	default:
-		return fmt.Errorf("unexpected coder: %v", c)
+func (*bytesDecoder) Decode(r io.Reader) (FullValue, error) {
+	// Encoding: size (varint) + raw data
+
+	size, err := coder.DecodeVarInt(r)
+	if err != nil {
+		return FullValue{}, err
 	}
+	data, err := ioutilx.ReadN(r, (int)(size))
+	if err != nil {
+		return FullValue{}, err
+	}
+	return FullValue{Elm: reflect.ValueOf(data)}, nil
 }
 
-// DecodeElement uses the supplied coder to read data from the supplied Reader and return a data element.
-func DecodeElement(c *coder.Coder, r io.Reader) (FullValue, error) {
-	switch c.Kind {
-	case coder.Bytes:
-		// Encoding: size (varint) + raw data
+type varIntEncoder struct{}
 
-		size, err := coder.DecodeVarInt(r)
-		if err != nil {
-			return FullValue{}, err
-		}
-		data, err := ioutilx.ReadN(r, (int)(size))
-		if err != nil {
-			return FullValue{}, err
-		}
-		return FullValue{Elm: reflect.ValueOf(data)}, nil
+func (*varIntEncoder) Encode(val FullValue, w io.Writer) error {
+	// Encoding: beam varint
 
-	case coder.VarInt:
-		// Encoding: beam varint
+	n := reflectx.UnderlyingType(val.Elm).Convert(reflectx.Int32).Interface().(int32)
+	return coder.EncodeVarInt(n, w)
+}
 
-		n, err := coder.DecodeVarInt(r)
-		if err != nil {
-			return FullValue{}, err
-		}
-		return FullValue{Elm: reflect.ValueOf(n)}, nil
+type varIntDecoder struct{}
 
-	case coder.Custom:
-		dec := c.Custom.Dec
+func (*varIntDecoder) Decode(r io.Reader) (FullValue, error) {
+	// Encoding: beam varint
 
-		// (1) Read length-prefixed encoded data
+	n, err := coder.DecodeVarInt(r)
+	if err != nil {
+		return FullValue{}, err
+	}
+	return FullValue{Elm: reflect.ValueOf(n)}, nil
+}
 
-		size, err := coder.DecodeVarInt(r)
-		if err != nil {
-			return FullValue{}, err
-		}
-		data, err := ioutilx.ReadN(r, (int)(size))
-		if err != nil {
-			return FullValue{}, err
-		}
+type customEncoder struct {
+	t   reflect.Type
+	enc Encoder
+}
 
-		// (2) Call decode
+func (c *customEncoder) Encode(val FullValue, w io.Writer) error {
+	// (1) Call encode
 
-		args := make([]reflect.Value, len(dec.Param))
-		if index, ok := dec.Type(); ok {
-			args[index] = reflect.ValueOf(c.Custom.Type)
-		}
-		params := dec.Params(funcx.FnValue)
-		args[params[0]] = reflect.ValueOf(data)
+	data, err := c.enc.Encode(c.t, val.Elm)
+	if err != nil {
+		return err
+	}
 
-		ret, err := reflectCallNoPanic(dec.Fn, args)
-		if err != nil {
-			return FullValue{}, err
-		}
-		if index, ok := dec.Error(); ok && !ret[index].IsNil() {
-			return FullValue{}, fmt.Errorf("decode error: %v", ret[index].Interface())
-		}
-		return FullValue{Elm: ret[dec.Returns(funcx.RetValue)[0]]}, err
+	// (2) Add length prefix
 
-	case coder.KV:
-		key, err := DecodeElement(c.Components[0], r)
-		if err != nil {
-			return FullValue{}, err
-		}
-		value, err := DecodeElement(c.Components[1], r)
-		if err != nil {
-			return FullValue{}, err
-		}
-		return FullValue{Elm: key.Elm, Elm2: value.Elm}, nil
+	size := len(data)
+	if err := coder.EncodeVarInt((int32)(size), w); err != nil {
+		return err
+	}
+	_, err = w.Write(data)
+	return err
+}
 
-	default:
-		return FullValue{}, fmt.Errorf("unexpected coder: %v", c)
+type customDecoder struct {
+	t   reflect.Type
+	dec Decoder
+}
+
+func (c *customDecoder) Decode(r io.Reader) (FullValue, error) {
+	// (1) Read length-prefixed encoded data
+
+	size, err := coder.DecodeVarInt(r)
+	if err != nil {
+		return FullValue{}, err
 	}
+	data, err := ioutilx.ReadN(r, (int)(size))
+	if err != nil {
+		return FullValue{}, err
+	}
+
+	// (2) Call decode
+
+	val, err := c.dec.Decode(c.t, data)
+	if err != nil {
+		return FullValue{}, err
+	}
+	return FullValue{Elm: val}, err
+}
+
+type kvEncoder struct {
+	fst, snd ElementEncoder
+}
+
+func (c *kvEncoder) Encode(val FullValue, w io.Writer) error {
+	if err := c.fst.Encode(FullValue{Elm: val.Elm}, w); err != nil {
+		return err
+	}
+	return c.snd.Encode(FullValue{Elm: val.Elm2}, w)
+
+}
+
+type kvDecoder struct {
+	fst, snd ElementDecoder
+}
+
+func (c *kvDecoder) Decode(r io.Reader) (FullValue, error) {
+	key, err := c.fst.Decode(r)
+	if err != nil {
+		return FullValue{}, err
+	}
+	value, err := c.snd.Decode(r)
+	if err != nil {
+		return FullValue{}, err
+	}
+	return FullValue{Elm: key.Elm, Elm2: value.Elm}, nil
+
 }
 
 // TODO(herohde) 4/7/2017: actually handle windows.
diff --git a/sdks/go/pkg/beam/core/runtime/exec/datasink.go b/sdks/go/pkg/beam/core/runtime/exec/datasink.go
index f993aaac14b..7ef74de2af4 100644
--- a/sdks/go/pkg/beam/core/runtime/exec/datasink.go
+++ b/sdks/go/pkg/beam/core/runtime/exec/datasink.go
@@ -30,7 +30,8 @@ type DataSink struct {
 	UID  UnitID
 	Edge *graph.MultiEdge
 
-	w io.WriteCloser
+	enc ElementEncoder
+	w   io.WriteCloser
 }
 
 func (n *DataSink) ID() UnitID {
@@ -38,6 +39,8 @@ func (n *DataSink) ID() UnitID {
 }
 
 func (n *DataSink) Up(ctx context.Context) error {
+	c := coder.SkipW(n.Edge.Input[0].From.Coder)
+	n.enc = MakeElementEncoder(c)
 	return nil
 }
 
@@ -61,7 +64,7 @@ func (n *DataSink) ProcessElement(ctx context.Context, value FullValue, values .
 	if err := EncodeWindowedValueHeader(c, value.Timestamp, &b); err != nil {
 		return err
 	}
-	if err := EncodeElement(coder.SkipW(c), value, &b); err != nil {
+	if err := n.enc.Encode(value, &b); err != nil {
 		return err
 	}
 
diff --git a/sdks/go/pkg/beam/core/runtime/exec/datasource.go b/sdks/go/pkg/beam/core/runtime/exec/datasource.go
index a0cc349007a..e29239b989e 100644
--- a/sdks/go/pkg/beam/core/runtime/exec/datasource.go
+++ b/sdks/go/pkg/beam/core/runtime/exec/datasource.go
@@ -56,24 +56,23 @@ func (n *DataSource) Process(ctx context.Context) error {
 	defer r.Close()
 
 	c := n.Edge.Output[0].To.Coder
-	for {
-		t, err := DecodeWindowedValueHeader(c, r)
-		if err != nil {
-			if err == io.EOF {
-				// log.Printf("EOF")
-				break
-			}
-			return fmt.Errorf("source failed: %v", err)
-		}
+	switch {
+	case coder.IsWGBK(c):
+		ck := MakeElementDecoder(coder.SkipW(c).Components[0])
+		cv := MakeElementDecoder(coder.SkipW(c).Components[1])
 
-		switch {
-		case coder.IsWGBK(c):
-			ck := coder.SkipW(c).Components[0]
-			cv := coder.SkipW(c).Components[1]
+		for {
+			t, err := DecodeWindowedValueHeader(c, r)
+			if err != nil {
+				if err == io.EOF {
+					return nil
+				}
+				return fmt.Errorf("source failed: %v", err)
+			}
 
 			// Decode key
 
-			key, err := DecodeElement(ck, r)
+			key, err := ck.Decode(r)
 			if err != nil {
 				return fmt.Errorf("source decode failed: %v", err)
 			}
@@ -96,7 +95,7 @@ func (n *DataSource) Process(ctx context.Context) error {
 				// log.Printf("Fixed size=%v", size)
 
 				for i := int32(0); i < size; i++ {
-					value, err := DecodeElement(cv, r)
+					value, err := cv.Decode(r)
 					if err != nil {
 						return fmt.Errorf("stream value decode failed: %v", err)
 					}
@@ -118,7 +117,7 @@ func (n *DataSource) Process(ctx context.Context) error {
 					}
 
 					for i := uint64(0); i < chunk; i++ {
-						value, err := DecodeElement(cv, r)
+						value, err := cv.Decode(r)
 						if err != nil {
 							return fmt.Errorf("stream value decode failed: %v", err)
 						}
@@ -131,12 +130,24 @@ func (n *DataSource) Process(ctx context.Context) error {
 			if err := n.Out.ProcessElement(ctx, key, values); err != nil {
 				return err
 			}
+		}
 
-		case coder.IsWCoGBK(c):
-			panic("NYI")
+	case coder.IsWCoGBK(c):
+		panic("NYI")
 
-		default:
-			elm, err := DecodeElement(coder.SkipW(c), r)
+	default:
+		ec := MakeElementDecoder(coder.SkipW(c))
+
+		for {
+			t, err := DecodeWindowedValueHeader(c, r)
+			if err != nil {
+				if err == io.EOF {
+					return nil
+				}
+				return fmt.Errorf("source failed: %v", err)
+			}
+
+			elm, err := ec.Decode(r)
 			if err != nil {
 				return fmt.Errorf("source decode failed: %v", err)
 			}
@@ -149,7 +160,6 @@ func (n *DataSource) Process(ctx context.Context) error {
 			}
 		}
 	}
-	return nil
 }
 
 func (n *DataSource) FinishBundle(ctx context.Context) error {
diff --git a/sdks/go/pkg/beam/core/runtime/exec/decode.go b/sdks/go/pkg/beam/core/runtime/exec/decode.go
new file mode 100644
index 00000000000..248eee7278b
--- /dev/null
+++ b/sdks/go/pkg/beam/core/runtime/exec/decode.go
@@ -0,0 +1,90 @@
+// Licensed to the Apache Software Foundation (ASF) under one or more
+// contributor license agreements.  See the NOTICE file distributed with
+// this work for additional information regarding copyright ownership.
+// The ASF licenses this file to You under the Apache License, Version 2.0
+// (the "License"); you may not use this file except in compliance with
+// the License.  You may obtain a copy of the License at
+//
+//    http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package exec
+
+import (
+	"context"
+	"fmt"
+	"reflect"
+	"sync"
+
+	"github.com/apache/beam/sdks/go/pkg/beam/core/funcx"
+	"github.com/apache/beam/sdks/go/pkg/beam/log"
+)
+
+//go:generate specialize --input=decoders.tmpl --x=data,universals
+
+// Decoder is a uniform custom encoder interface.
+type Decoder interface {
+	// Decode decodes the []byte in to a value of the given type.
+	Decode(reflect.Type, []byte) (reflect.Value, error)
+}
+
+var (
+	decoders   = make(map[string]func(reflect.Value) Decoder)
+	decodersMu sync.Mutex
+)
+
+// RegisterDecoder registers an custom decoder invoker for the given type,
+// such as "func(int)[]byte". If multiple decoder invokers are registered
+// for the same type, the last registration wins.
+func RegisterDecoder(t reflect.Type, maker func(reflect.Value) Decoder) {
+	decodersMu.Lock()
+	defer decodersMu.Unlock()
+
+	key := t.String()
+	if _, exists := decoders[key]; exists {
+		log.Warnf(context.Background(), "Decoder for %v already registered. Overwriting.", key)
+	}
+	decoders[key] = maker
+}
+
+func makeDecoder(fn *funcx.Fn) Decoder {
+	decodersMu.Lock()
+	maker, exists := decoders[fn.Fn.Type().String()]
+	decodersMu.Unlock()
+
+	if exists {
+		return maker(fn.Fn)
+	}
+
+	// If no specialized implementation is available, we use the (slower)
+	// reflection-based one.
+
+	return &decoder{fn: fn}
+}
+
+type decoder struct {
+	fn *funcx.Fn
+}
+
+func (d *decoder) Decode(t reflect.Type, data []byte) (reflect.Value, error) {
+	args := make([]reflect.Value, len(d.fn.Param))
+	if index, ok := d.fn.Type(); ok {
+		args[index] = reflect.ValueOf(t)
+	}
+	params := d.fn.Params(funcx.FnValue)
+	args[params[0]] = reflect.ValueOf(data)
+
+	ret, err := reflectCallNoPanic(d.fn.Fn, args)
+	if err != nil {
+		return reflect.Value{}, err
+	}
+	if index, ok := d.fn.Error(); ok && !ret[index].IsNil() {
+		return reflect.Value{}, fmt.Errorf("decode error: %v", ret[index].Interface())
+	}
+	return ret[d.fn.Returns(funcx.RetValue)[0]], nil
+}
diff --git a/sdks/go/pkg/beam/core/runtime/exec/decoders.go b/sdks/go/pkg/beam/core/runtime/exec/decoders.go
new file mode 100644
index 00000000000..6f191c73ae1
--- /dev/null
+++ b/sdks/go/pkg/beam/core/runtime/exec/decoders.go
@@ -0,0 +1,1347 @@
+// File generated by specialize. Do not edit.
+
+// Licensed to the Apache Software Foundation (ASF) under one or more
+// contributor license agreements.  See the NOTICE file distributed with
+// this work for additional information regarding copyright ownership.
+// The ASF licenses this file to You under the Apache License, Version 2.0
+// (the "License"); you may not use this file except in compliance with
+// the License.  You may obtain a copy of the License at
+//
+//    http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package exec
+
+import (
+	"reflect"
+
+	"github.com/apache/beam/sdks/go/pkg/beam/core/typex"
+)
+
+func init() {
+	RegisterDecoder(reflect.TypeOf((*func([]byte) []byte)(nil)).Elem(), decoderMakerByteSlice)
+	RegisterDecoder(reflect.TypeOf((*func([]byte) ([]byte, error))(nil)).Elem(), decoderMakerByteSliceE)
+	RegisterDecoder(reflect.TypeOf((*func(reflect.Type, []byte) []byte)(nil)).Elem(), decoderMakerTByteSlice)
+	RegisterDecoder(reflect.TypeOf((*func(reflect.Type, []byte) ([]byte, error))(nil)).Elem(), decoderMakerTByteSliceE)
+	RegisterDecoder(reflect.TypeOf((*func([]byte) bool)(nil)).Elem(), decoderMakerBool)
+	RegisterDecoder(reflect.TypeOf((*func([]byte) (bool, error))(nil)).Elem(), decoderMakerBoolE)
+	RegisterDecoder(reflect.TypeOf((*func(reflect.Type, []byte) bool)(nil)).Elem(), decoderMakerTBool)
+	RegisterDecoder(reflect.TypeOf((*func(reflect.Type, []byte) (bool, error))(nil)).Elem(), decoderMakerTBoolE)
+	RegisterDecoder(reflect.TypeOf((*func([]byte) string)(nil)).Elem(), decoderMakerString)
+	RegisterDecoder(reflect.TypeOf((*func([]byte) (string, error))(nil)).Elem(), decoderMakerStringE)
+	RegisterDecoder(reflect.TypeOf((*func(reflect.Type, []byte) string)(nil)).Elem(), decoderMakerTString)
+	RegisterDecoder(reflect.TypeOf((*func(reflect.Type, []byte) (string, error))(nil)).Elem(), decoderMakerTStringE)
+	RegisterDecoder(reflect.TypeOf((*func([]byte) int)(nil)).Elem(), decoderMakerInt)
+	RegisterDecoder(reflect.TypeOf((*func([]byte) (int, error))(nil)).Elem(), decoderMakerIntE)
+	RegisterDecoder(reflect.TypeOf((*func(reflect.Type, []byte) int)(nil)).Elem(), decoderMakerTInt)
+	RegisterDecoder(reflect.TypeOf((*func(reflect.Type, []byte) (int, error))(nil)).Elem(), decoderMakerTIntE)
+	RegisterDecoder(reflect.TypeOf((*func([]byte) int8)(nil)).Elem(), decoderMakerInt8)
+	RegisterDecoder(reflect.TypeOf((*func([]byte) (int8, error))(nil)).Elem(), decoderMakerInt8E)
+	RegisterDecoder(reflect.TypeOf((*func(reflect.Type, []byte) int8)(nil)).Elem(), decoderMakerTInt8)
+	RegisterDecoder(reflect.TypeOf((*func(reflect.Type, []byte) (int8, error))(nil)).Elem(), decoderMakerTInt8E)
+	RegisterDecoder(reflect.TypeOf((*func([]byte) int16)(nil)).Elem(), decoderMakerInt16)
+	RegisterDecoder(reflect.TypeOf((*func([]byte) (int16, error))(nil)).Elem(), decoderMakerInt16E)
+	RegisterDecoder(reflect.TypeOf((*func(reflect.Type, []byte) int16)(nil)).Elem(), decoderMakerTInt16)
+	RegisterDecoder(reflect.TypeOf((*func(reflect.Type, []byte) (int16, error))(nil)).Elem(), decoderMakerTInt16E)
+	RegisterDecoder(reflect.TypeOf((*func([]byte) int32)(nil)).Elem(), decoderMakerInt32)
+	RegisterDecoder(reflect.TypeOf((*func([]byte) (int32, error))(nil)).Elem(), decoderMakerInt32E)
+	RegisterDecoder(reflect.TypeOf((*func(reflect.Type, []byte) int32)(nil)).Elem(), decoderMakerTInt32)
+	RegisterDecoder(reflect.TypeOf((*func(reflect.Type, []byte) (int32, error))(nil)).Elem(), decoderMakerTInt32E)
+	RegisterDecoder(reflect.TypeOf((*func([]byte) int64)(nil)).Elem(), decoderMakerInt64)
+	RegisterDecoder(reflect.TypeOf((*func([]byte) (int64, error))(nil)).Elem(), decoderMakerInt64E)
+	RegisterDecoder(reflect.TypeOf((*func(reflect.Type, []byte) int64)(nil)).Elem(), decoderMakerTInt64)
+	RegisterDecoder(reflect.TypeOf((*func(reflect.Type, []byte) (int64, error))(nil)).Elem(), decoderMakerTInt64E)
+	RegisterDecoder(reflect.TypeOf((*func([]byte) uint)(nil)).Elem(), decoderMakerUint)
+	RegisterDecoder(reflect.TypeOf((*func([]byte) (uint, error))(nil)).Elem(), decoderMakerUintE)
+	RegisterDecoder(reflect.TypeOf((*func(reflect.Type, []byte) uint)(nil)).Elem(), decoderMakerTUint)
+	RegisterDecoder(reflect.TypeOf((*func(reflect.Type, []byte) (uint, error))(nil)).Elem(), decoderMakerTUintE)
+	RegisterDecoder(reflect.TypeOf((*func([]byte) uint8)(nil)).Elem(), decoderMakerUint8)
+	RegisterDecoder(reflect.TypeOf((*func([]byte) (uint8, error))(nil)).Elem(), decoderMakerUint8E)
+	RegisterDecoder(reflect.TypeOf((*func(reflect.Type, []byte) uint8)(nil)).Elem(), decoderMakerTUint8)
+	RegisterDecoder(reflect.TypeOf((*func(reflect.Type, []byte) (uint8, error))(nil)).Elem(), decoderMakerTUint8E)
+	RegisterDecoder(reflect.TypeOf((*func([]byte) uint16)(nil)).Elem(), decoderMakerUint16)
+	RegisterDecoder(reflect.TypeOf((*func([]byte) (uint16, error))(nil)).Elem(), decoderMakerUint16E)
+	RegisterDecoder(reflect.TypeOf((*func(reflect.Type, []byte) uint16)(nil)).Elem(), decoderMakerTUint16)
+	RegisterDecoder(reflect.TypeOf((*func(reflect.Type, []byte) (uint16, error))(nil)).Elem(), decoderMakerTUint16E)
+	RegisterDecoder(reflect.TypeOf((*func([]byte) uint32)(nil)).Elem(), decoderMakerUint32)
+	RegisterDecoder(reflect.TypeOf((*func([]byte) (uint32, error))(nil)).Elem(), decoderMakerUint32E)
+	RegisterDecoder(reflect.TypeOf((*func(reflect.Type, []byte) uint32)(nil)).Elem(), decoderMakerTUint32)
+	RegisterDecoder(reflect.TypeOf((*func(reflect.Type, []byte) (uint32, error))(nil)).Elem(), decoderMakerTUint32E)
+	RegisterDecoder(reflect.TypeOf((*func([]byte) uint64)(nil)).Elem(), decoderMakerUint64)
+	RegisterDecoder(reflect.TypeOf((*func([]byte) (uint64, error))(nil)).Elem(), decoderMakerUint64E)
+	RegisterDecoder(reflect.TypeOf((*func(reflect.Type, []byte) uint64)(nil)).Elem(), decoderMakerTUint64)
+	RegisterDecoder(reflect.TypeOf((*func(reflect.Type, []byte) (uint64, error))(nil)).Elem(), decoderMakerTUint64E)
+	RegisterDecoder(reflect.TypeOf((*func([]byte) float32)(nil)).Elem(), decoderMakerFloat32)
+	RegisterDecoder(reflect.TypeOf((*func([]byte) (float32, error))(nil)).Elem(), decoderMakerFloat32E)
+	RegisterDecoder(reflect.TypeOf((*func(reflect.Type, []byte) float32)(nil)).Elem(), decoderMakerTFloat32)
+	RegisterDecoder(reflect.TypeOf((*func(reflect.Type, []byte) (float32, error))(nil)).Elem(), decoderMakerTFloat32E)
+	RegisterDecoder(reflect.TypeOf((*func([]byte) float64)(nil)).Elem(), decoderMakerFloat64)
+	RegisterDecoder(reflect.TypeOf((*func([]byte) (float64, error))(nil)).Elem(), decoderMakerFloat64E)
+	RegisterDecoder(reflect.TypeOf((*func(reflect.Type, []byte) float64)(nil)).Elem(), decoderMakerTFloat64)
+	RegisterDecoder(reflect.TypeOf((*func(reflect.Type, []byte) (float64, error))(nil)).Elem(), decoderMakerTFloat64E)
+	RegisterDecoder(reflect.TypeOf((*func([]byte) typex.T)(nil)).Elem(), decoderMakerTypex_T)
+	RegisterDecoder(reflect.TypeOf((*func([]byte) (typex.T, error))(nil)).Elem(), decoderMakerTypex_TE)
+	RegisterDecoder(reflect.TypeOf((*func(reflect.Type, []byte) typex.T)(nil)).Elem(), decoderMakerTTypex_T)
+	RegisterDecoder(reflect.TypeOf((*func(reflect.Type, []byte) (typex.T, error))(nil)).Elem(), decoderMakerTTypex_TE)
+	RegisterDecoder(reflect.TypeOf((*func([]byte) typex.U)(nil)).Elem(), decoderMakerTypex_U)
+	RegisterDecoder(reflect.TypeOf((*func([]byte) (typex.U, error))(nil)).Elem(), decoderMakerTypex_UE)
+	RegisterDecoder(reflect.TypeOf((*func(reflect.Type, []byte) typex.U)(nil)).Elem(), decoderMakerTTypex_U)
+	RegisterDecoder(reflect.TypeOf((*func(reflect.Type, []byte) (typex.U, error))(nil)).Elem(), decoderMakerTTypex_UE)
+	RegisterDecoder(reflect.TypeOf((*func([]byte) typex.V)(nil)).Elem(), decoderMakerTypex_V)
+	RegisterDecoder(reflect.TypeOf((*func([]byte) (typex.V, error))(nil)).Elem(), decoderMakerTypex_VE)
+	RegisterDecoder(reflect.TypeOf((*func(reflect.Type, []byte) typex.V)(nil)).Elem(), decoderMakerTTypex_V)
+	RegisterDecoder(reflect.TypeOf((*func(reflect.Type, []byte) (typex.V, error))(nil)).Elem(), decoderMakerTTypex_VE)
+	RegisterDecoder(reflect.TypeOf((*func([]byte) typex.W)(nil)).Elem(), decoderMakerTypex_W)
+	RegisterDecoder(reflect.TypeOf((*func([]byte) (typex.W, error))(nil)).Elem(), decoderMakerTypex_WE)
+	RegisterDecoder(reflect.TypeOf((*func(reflect.Type, []byte) typex.W)(nil)).Elem(), decoderMakerTTypex_W)
+	RegisterDecoder(reflect.TypeOf((*func(reflect.Type, []byte) (typex.W, error))(nil)).Elem(), decoderMakerTTypex_WE)
+	RegisterDecoder(reflect.TypeOf((*func([]byte) typex.X)(nil)).Elem(), decoderMakerTypex_X)
+	RegisterDecoder(reflect.TypeOf((*func([]byte) (typex.X, error))(nil)).Elem(), decoderMakerTypex_XE)
+	RegisterDecoder(reflect.TypeOf((*func(reflect.Type, []byte) typex.X)(nil)).Elem(), decoderMakerTTypex_X)
+	RegisterDecoder(reflect.TypeOf((*func(reflect.Type, []byte) (typex.X, error))(nil)).Elem(), decoderMakerTTypex_XE)
+	RegisterDecoder(reflect.TypeOf((*func([]byte) typex.Y)(nil)).Elem(), decoderMakerTypex_Y)
+	RegisterDecoder(reflect.TypeOf((*func([]byte) (typex.Y, error))(nil)).Elem(), decoderMakerTypex_YE)
+	RegisterDecoder(reflect.TypeOf((*func(reflect.Type, []byte) typex.Y)(nil)).Elem(), decoderMakerTTypex_Y)
+	RegisterDecoder(reflect.TypeOf((*func(reflect.Type, []byte) (typex.Y, error))(nil)).Elem(), decoderMakerTTypex_YE)
+	RegisterDecoder(reflect.TypeOf((*func([]byte) typex.Z)(nil)).Elem(), decoderMakerTypex_Z)
+	RegisterDecoder(reflect.TypeOf((*func([]byte) (typex.Z, error))(nil)).Elem(), decoderMakerTypex_ZE)
+	RegisterDecoder(reflect.TypeOf((*func(reflect.Type, []byte) typex.Z)(nil)).Elem(), decoderMakerTTypex_Z)
+	RegisterDecoder(reflect.TypeOf((*func(reflect.Type, []byte) (typex.Z, error))(nil)).Elem(), decoderMakerTTypex_ZE)
+}
+
+type decoderByteSlice struct {
+	fn func([]byte) []byte
+}
+
+func (e *decoderByteSlice) Decode(t reflect.Type, data []byte) (reflect.Value, error) {
+	return reflect.ValueOf(e.fn(data)), nil
+}
+
+func decoderMakerByteSlice(fn reflect.Value) Decoder {
+	return &decoderByteSlice{fn: fn.Interface().(func([]byte) []byte)}
+}
+
+type decoderByteSliceE struct {
+	fn func([]byte) ([]byte, error)
+}
+
+func (e *decoderByteSliceE) Decode(t reflect.Type, data []byte) (reflect.Value, error) {
+	val, err := e.fn(data)
+	if err != nil {
+		return reflect.Value{}, nil
+	}
+	return reflect.ValueOf(val), nil
+}
+
+func decoderMakerByteSliceE(fn reflect.Value) Decoder {
+	return &decoderByteSliceE{fn: fn.Interface().(func([]byte) ([]byte, error))}
+}
+
+type decoderTByteSlice struct {
+	fn func(reflect.Type, []byte) []byte
+}
+
+func (e *decoderTByteSlice) Decode(t reflect.Type, data []byte) (reflect.Value, error) {
+	return reflect.ValueOf(e.fn(t, data)), nil
+}
+
+func decoderMakerTByteSlice(fn reflect.Value) Decoder {
+	return &decoderTByteSlice{fn: fn.Interface().(func(reflect.Type, []byte) []byte)}
+}
+
+type decoderTByteSliceE struct {
+	fn func(reflect.Type, []byte) ([]byte, error)
+}
+
+func (e *decoderTByteSliceE) Decode(t reflect.Type, data []byte) (reflect.Value, error) {
+	val, err := e.fn(t, data)
+	if err != nil {
+		return reflect.Value{}, nil
+	}
+	return reflect.ValueOf(val), nil
+}
+
+func decoderMakerTByteSliceE(fn reflect.Value) Decoder {
+	return &decoderTByteSliceE{fn: fn.Interface().(func(reflect.Type, []byte) ([]byte, error))}
+}
+
+type decoderBool struct {
+	fn func([]byte) bool
+}
+
+func (e *decoderBool) Decode(t reflect.Type, data []byte) (reflect.Value, error) {
+	return reflect.ValueOf(e.fn(data)), nil
+}
+
+func decoderMakerBool(fn reflect.Value) Decoder {
+	return &decoderBool{fn: fn.Interface().(func([]byte) bool)}
+}
+
+type decoderBoolE struct {
+	fn func([]byte) (bool, error)
+}
+
+func (e *decoderBoolE) Decode(t reflect.Type, data []byte) (reflect.Value, error) {
+	val, err := e.fn(data)
+	if err != nil {
+		return reflect.Value{}, nil
+	}
+	return reflect.ValueOf(val), nil
+}
+
+func decoderMakerBoolE(fn reflect.Value) Decoder {
+	return &decoderBoolE{fn: fn.Interface().(func([]byte) (bool, error))}
+}
+
+type decoderTBool struct {
+	fn func(reflect.Type, []byte) bool
+}
+
+func (e *decoderTBool) Decode(t reflect.Type, data []byte) (reflect.Value, error) {
+	return reflect.ValueOf(e.fn(t, data)), nil
+}
+
+func decoderMakerTBool(fn reflect.Value) Decoder {
+	return &decoderTBool{fn: fn.Interface().(func(reflect.Type, []byte) bool)}
+}
+
+type decoderTBoolE struct {
+	fn func(reflect.Type, []byte) (bool, error)
+}
+
+func (e *decoderTBoolE) Decode(t reflect.Type, data []byte) (reflect.Value, error) {
+	val, err := e.fn(t, data)
+	if err != nil {
+		return reflect.Value{}, nil
+	}
+	return reflect.ValueOf(val), nil
+}
+
+func decoderMakerTBoolE(fn reflect.Value) Decoder {
+	return &decoderTBoolE{fn: fn.Interface().(func(reflect.Type, []byte) (bool, error))}
+}
+
+type decoderString struct {
+	fn func([]byte) string
+}
+
+func (e *decoderString) Decode(t reflect.Type, data []byte) (reflect.Value, error) {
+	return reflect.ValueOf(e.fn(data)), nil
+}
+
+func decoderMakerString(fn reflect.Value) Decoder {
+	return &decoderString{fn: fn.Interface().(func([]byte) string)}
+}
+
+type decoderStringE struct {
+	fn func([]byte) (string, error)
+}
+
+func (e *decoderStringE) Decode(t reflect.Type, data []byte) (reflect.Value, error) {
+	val, err := e.fn(data)
+	if err != nil {
+		return reflect.Value{}, nil
+	}
+	return reflect.ValueOf(val), nil
+}
+
+func decoderMakerStringE(fn reflect.Value) Decoder {
+	return &decoderStringE{fn: fn.Interface().(func([]byte) (string, error))}
+}
+
+type decoderTString struct {
+	fn func(reflect.Type, []byte) string
+}
+
+func (e *decoderTString) Decode(t reflect.Type, data []byte) (reflect.Value, error) {
+	return reflect.ValueOf(e.fn(t, data)), nil
+}
+
+func decoderMakerTString(fn reflect.Value) Decoder {
+	return &decoderTString{fn: fn.Interface().(func(reflect.Type, []byte) string)}
+}
+
+type decoderTStringE struct {
+	fn func(reflect.Type, []byte) (string, error)
+}
+
+func (e *decoderTStringE) Decode(t reflect.Type, data []byte) (reflect.Value, error) {
+	val, err := e.fn(t, data)
+	if err != nil {
+		return reflect.Value{}, nil
+	}
+	return reflect.ValueOf(val), nil
+}
+
+func decoderMakerTStringE(fn reflect.Value) Decoder {
+	return &decoderTStringE{fn: fn.Interface().(func(reflect.Type, []byte) (string, error))}
+}
+
+type decoderInt struct {
+	fn func([]byte) int
+}
+
+func (e *decoderInt) Decode(t reflect.Type, data []byte) (reflect.Value, error) {
+	return reflect.ValueOf(e.fn(data)), nil
+}
+
+func decoderMakerInt(fn reflect.Value) Decoder {
+	return &decoderInt{fn: fn.Interface().(func([]byte) int)}
+}
+
+type decoderIntE struct {
+	fn func([]byte) (int, error)
+}
+
+func (e *decoderIntE) Decode(t reflect.Type, data []byte) (reflect.Value, error) {
+	val, err := e.fn(data)
+	if err != nil {
+		return reflect.Value{}, nil
+	}
+	return reflect.ValueOf(val), nil
+}
+
+func decoderMakerIntE(fn reflect.Value) Decoder {
+	return &decoderIntE{fn: fn.Interface().(func([]byte) (int, error))}
+}
+
+type decoderTInt struct {
+	fn func(reflect.Type, []byte) int
+}
+
+func (e *decoderTInt) Decode(t reflect.Type, data []byte) (reflect.Value, error) {
+	return reflect.ValueOf(e.fn(t, data)), nil
+}
+
+func decoderMakerTInt(fn reflect.Value) Decoder {
+	return &decoderTInt{fn: fn.Interface().(func(reflect.Type, []byte) int)}
+}
+
+type decoderTIntE struct {
+	fn func(reflect.Type, []byte) (int, error)
+}
+
+func (e *decoderTIntE) Decode(t reflect.Type, data []byte) (reflect.Value, error) {
+	val, err := e.fn(t, data)
+	if err != nil {
+		return reflect.Value{}, nil
+	}
+	return reflect.ValueOf(val), nil
+}
+
+func decoderMakerTIntE(fn reflect.Value) Decoder {
+	return &decoderTIntE{fn: fn.Interface().(func(reflect.Type, []byte) (int, error))}
+}
+
+type decoderInt8 struct {
+	fn func([]byte) int8
+}
+
+func (e *decoderInt8) Decode(t reflect.Type, data []byte) (reflect.Value, error) {
+	return reflect.ValueOf(e.fn(data)), nil
+}
+
+func decoderMakerInt8(fn reflect.Value) Decoder {
+	return &decoderInt8{fn: fn.Interface().(func([]byte) int8)}
+}
+
+type decoderInt8E struct {
+	fn func([]byte) (int8, error)
+}
+
+func (e *decoderInt8E) Decode(t reflect.Type, data []byte) (reflect.Value, error) {
+	val, err := e.fn(data)
+	if err != nil {
+		return reflect.Value{}, nil
+	}
+	return reflect.ValueOf(val), nil
+}
+
+func decoderMakerInt8E(fn reflect.Value) Decoder {
+	return &decoderInt8E{fn: fn.Interface().(func([]byte) (int8, error))}
+}
+
+type decoderTInt8 struct {
+	fn func(reflect.Type, []byte) int8
+}
+
+func (e *decoderTInt8) Decode(t reflect.Type, data []byte) (reflect.Value, error) {
+	return reflect.ValueOf(e.fn(t, data)), nil
+}
+
+func decoderMakerTInt8(fn reflect.Value) Decoder {
+	return &decoderTInt8{fn: fn.Interface().(func(reflect.Type, []byte) int8)}
+}
+
+type decoderTInt8E struct {
+	fn func(reflect.Type, []byte) (int8, error)
+}
+
+func (e *decoderTInt8E) Decode(t reflect.Type, data []byte) (reflect.Value, error) {
+	val, err := e.fn(t, data)
+	if err != nil {
+		return reflect.Value{}, nil
+	}
+	return reflect.ValueOf(val), nil
+}
+
+func decoderMakerTInt8E(fn reflect.Value) Decoder {
+	return &decoderTInt8E{fn: fn.Interface().(func(reflect.Type, []byte) (int8, error))}
+}
+
+type decoderInt16 struct {
+	fn func([]byte) int16
+}
+
+func (e *decoderInt16) Decode(t reflect.Type, data []byte) (reflect.Value, error) {
+	return reflect.ValueOf(e.fn(data)), nil
+}
+
+func decoderMakerInt16(fn reflect.Value) Decoder {
+	return &decoderInt16{fn: fn.Interface().(func([]byte) int16)}
+}
+
+type decoderInt16E struct {
+	fn func([]byte) (int16, error)
+}
+
+func (e *decoderInt16E) Decode(t reflect.Type, data []byte) (reflect.Value, error) {
+	val, err := e.fn(data)
+	if err != nil {
+		return reflect.Value{}, nil
+	}
+	return reflect.ValueOf(val), nil
+}
+
+func decoderMakerInt16E(fn reflect.Value) Decoder {
+	return &decoderInt16E{fn: fn.Interface().(func([]byte) (int16, error))}
+}
+
+type decoderTInt16 struct {
+	fn func(reflect.Type, []byte) int16
+}
+
+func (e *decoderTInt16) Decode(t reflect.Type, data []byte) (reflect.Value, error) {
+	return reflect.ValueOf(e.fn(t, data)), nil
+}
+
+func decoderMakerTInt16(fn reflect.Value) Decoder {
+	return &decoderTInt16{fn: fn.Interface().(func(reflect.Type, []byte) int16)}
+}
+
+type decoderTInt16E struct {
+	fn func(reflect.Type, []byte) (int16, error)
+}
+
+func (e *decoderTInt16E) Decode(t reflect.Type, data []byte) (reflect.Value, error) {
+	val, err := e.fn(t, data)
+	if err != nil {
+		return reflect.Value{}, nil
+	}
+	return reflect.ValueOf(val), nil
+}
+
+func decoderMakerTInt16E(fn reflect.Value) Decoder {
+	return &decoderTInt16E{fn: fn.Interface().(func(reflect.Type, []byte) (int16, error))}
+}
+
+type decoderInt32 struct {
+	fn func([]byte) int32
+}
+
+func (e *decoderInt32) Decode(t reflect.Type, data []byte) (reflect.Value, error) {
+	return reflect.ValueOf(e.fn(data)), nil
+}
+
+func decoderMakerInt32(fn reflect.Value) Decoder {
+	return &decoderInt32{fn: fn.Interface().(func([]byte) int32)}
+}
+
+type decoderInt32E struct {
+	fn func([]byte) (int32, error)
+}
+
+func (e *decoderInt32E) Decode(t reflect.Type, data []byte) (reflect.Value, error) {
+	val, err := e.fn(data)
+	if err != nil {
+		return reflect.Value{}, nil
+	}
+	return reflect.ValueOf(val), nil
+}
+
+func decoderMakerInt32E(fn reflect.Value) Decoder {
+	return &decoderInt32E{fn: fn.Interface().(func([]byte) (int32, error))}
+}
+
+type decoderTInt32 struct {
+	fn func(reflect.Type, []byte) int32
+}
+
+func (e *decoderTInt32) Decode(t reflect.Type, data []byte) (reflect.Value, error) {
+	return reflect.ValueOf(e.fn(t, data)), nil
+}
+
+func decoderMakerTInt32(fn reflect.Value) Decoder {
+	return &decoderTInt32{fn: fn.Interface().(func(reflect.Type, []byte) int32)}
+}
+
+type decoderTInt32E struct {
+	fn func(reflect.Type, []byte) (int32, error)
+}
+
+func (e *decoderTInt32E) Decode(t reflect.Type, data []byte) (reflect.Value, error) {
+	val, err := e.fn(t, data)
+	if err != nil {
+		return reflect.Value{}, nil
+	}
+	return reflect.ValueOf(val), nil
+}
+
+func decoderMakerTInt32E(fn reflect.Value) Decoder {
+	return &decoderTInt32E{fn: fn.Interface().(func(reflect.Type, []byte) (int32, error))}
+}
+
+type decoderInt64 struct {
+	fn func([]byte) int64
+}
+
+func (e *decoderInt64) Decode(t reflect.Type, data []byte) (reflect.Value, error) {
+	return reflect.ValueOf(e.fn(data)), nil
+}
+
+func decoderMakerInt64(fn reflect.Value) Decoder {
+	return &decoderInt64{fn: fn.Interface().(func([]byte) int64)}
+}
+
+type decoderInt64E struct {
+	fn func([]byte) (int64, error)
+}
+
+func (e *decoderInt64E) Decode(t reflect.Type, data []byte) (reflect.Value, error) {
+	val, err := e.fn(data)
+	if err != nil {
+		return reflect.Value{}, nil
+	}
+	return reflect.ValueOf(val), nil
+}
+
+func decoderMakerInt64E(fn reflect.Value) Decoder {
+	return &decoderInt64E{fn: fn.Interface().(func([]byte) (int64, error))}
+}
+
+type decoderTInt64 struct {
+	fn func(reflect.Type, []byte) int64
+}
+
+func (e *decoderTInt64) Decode(t reflect.Type, data []byte) (reflect.Value, error) {
+	return reflect.ValueOf(e.fn(t, data)), nil
+}
+
+func decoderMakerTInt64(fn reflect.Value) Decoder {
+	return &decoderTInt64{fn: fn.Interface().(func(reflect.Type, []byte) int64)}
+}
+
+type decoderTInt64E struct {
+	fn func(reflect.Type, []byte) (int64, error)
+}
+
+func (e *decoderTInt64E) Decode(t reflect.Type, data []byte) (reflect.Value, error) {
+	val, err := e.fn(t, data)
+	if err != nil {
+		return reflect.Value{}, nil
+	}
+	return reflect.ValueOf(val), nil
+}
+
+func decoderMakerTInt64E(fn reflect.Value) Decoder {
+	return &decoderTInt64E{fn: fn.Interface().(func(reflect.Type, []byte) (int64, error))}
+}
+
+type decoderUint struct {
+	fn func([]byte) uint
+}
+
+func (e *decoderUint) Decode(t reflect.Type, data []byte) (reflect.Value, error) {
+	return reflect.ValueOf(e.fn(data)), nil
+}
+
+func decoderMakerUint(fn reflect.Value) Decoder {
+	return &decoderUint{fn: fn.Interface().(func([]byte) uint)}
+}
+
+type decoderUintE struct {
+	fn func([]byte) (uint, error)
+}
+
+func (e *decoderUintE) Decode(t reflect.Type, data []byte) (reflect.Value, error) {
+	val, err := e.fn(data)
+	if err != nil {
+		return reflect.Value{}, nil
+	}
+	return reflect.ValueOf(val), nil
+}
+
+func decoderMakerUintE(fn reflect.Value) Decoder {
+	return &decoderUintE{fn: fn.Interface().(func([]byte) (uint, error))}
+}
+
+type decoderTUint struct {
+	fn func(reflect.Type, []byte) uint
+}
+
+func (e *decoderTUint) Decode(t reflect.Type, data []byte) (reflect.Value, error) {
+	return reflect.ValueOf(e.fn(t, data)), nil
+}
+
+func decoderMakerTUint(fn reflect.Value) Decoder {
+	return &decoderTUint{fn: fn.Interface().(func(reflect.Type, []byte) uint)}
+}
+
+type decoderTUintE struct {
+	fn func(reflect.Type, []byte) (uint, error)
+}
+
+func (e *decoderTUintE) Decode(t reflect.Type, data []byte) (reflect.Value, error) {
+	val, err := e.fn(t, data)
+	if err != nil {
+		return reflect.Value{}, nil
+	}
+	return reflect.ValueOf(val), nil
+}
+
+func decoderMakerTUintE(fn reflect.Value) Decoder {
+	return &decoderTUintE{fn: fn.Interface().(func(reflect.Type, []byte) (uint, error))}
+}
+
+type decoderUint8 struct {
+	fn func([]byte) uint8
+}
+
+func (e *decoderUint8) Decode(t reflect.Type, data []byte) (reflect.Value, error) {
+	return reflect.ValueOf(e.fn(data)), nil
+}
+
+func decoderMakerUint8(fn reflect.Value) Decoder {
+	return &decoderUint8{fn: fn.Interface().(func([]byte) uint8)}
+}
+
+type decoderUint8E struct {
+	fn func([]byte) (uint8, error)
+}
+
+func (e *decoderUint8E) Decode(t reflect.Type, data []byte) (reflect.Value, error) {
+	val, err := e.fn(data)
+	if err != nil {
+		return reflect.Value{}, nil
+	}
+	return reflect.ValueOf(val), nil
+}
+
+func decoderMakerUint8E(fn reflect.Value) Decoder {
+	return &decoderUint8E{fn: fn.Interface().(func([]byte) (uint8, error))}
+}
+
+type decoderTUint8 struct {
+	fn func(reflect.Type, []byte) uint8
+}
+
+func (e *decoderTUint8) Decode(t reflect.Type, data []byte) (reflect.Value, error) {
+	return reflect.ValueOf(e.fn(t, data)), nil
+}
+
+func decoderMakerTUint8(fn reflect.Value) Decoder {
+	return &decoderTUint8{fn: fn.Interface().(func(reflect.Type, []byte) uint8)}
+}
+
+type decoderTUint8E struct {
+	fn func(reflect.Type, []byte) (uint8, error)
+}
+
+func (e *decoderTUint8E) Decode(t reflect.Type, data []byte) (reflect.Value, error) {
+	val, err := e.fn(t, data)
+	if err != nil {
+		return reflect.Value{}, nil
+	}
+	return reflect.ValueOf(val), nil
+}
+
+func decoderMakerTUint8E(fn reflect.Value) Decoder {
+	return &decoderTUint8E{fn: fn.Interface().(func(reflect.Type, []byte) (uint8, error))}
+}
+
+type decoderUint16 struct {
+	fn func([]byte) uint16
+}
+
+func (e *decoderUint16) Decode(t reflect.Type, data []byte) (reflect.Value, error) {
+	return reflect.ValueOf(e.fn(data)), nil
+}
+
+func decoderMakerUint16(fn reflect.Value) Decoder {
+	return &decoderUint16{fn: fn.Interface().(func([]byte) uint16)}
+}
+
+type decoderUint16E struct {
+	fn func([]byte) (uint16, error)
+}
+
+func (e *decoderUint16E) Decode(t reflect.Type, data []byte) (reflect.Value, error) {
+	val, err := e.fn(data)
+	if err != nil {
+		return reflect.Value{}, nil
+	}
+	return reflect.ValueOf(val), nil
+}
+
+func decoderMakerUint16E(fn reflect.Value) Decoder {
+	return &decoderUint16E{fn: fn.Interface().(func([]byte) (uint16, error))}
+}
+
+type decoderTUint16 struct {
+	fn func(reflect.Type, []byte) uint16
+}
+
+func (e *decoderTUint16) Decode(t reflect.Type, data []byte) (reflect.Value, error) {
+	return reflect.ValueOf(e.fn(t, data)), nil
+}
+
+func decoderMakerTUint16(fn reflect.Value) Decoder {
+	return &decoderTUint16{fn: fn.Interface().(func(reflect.Type, []byte) uint16)}
+}
+
+type decoderTUint16E struct {
+	fn func(reflect.Type, []byte) (uint16, error)
+}
+
+func (e *decoderTUint16E) Decode(t reflect.Type, data []byte) (reflect.Value, error) {
+	val, err := e.fn(t, data)
+	if err != nil {
+		return reflect.Value{}, nil
+	}
+	return reflect.ValueOf(val), nil
+}
+
+func decoderMakerTUint16E(fn reflect.Value) Decoder {
+	return &decoderTUint16E{fn: fn.Interface().(func(reflect.Type, []byte) (uint16, error))}
+}
+
+type decoderUint32 struct {
+	fn func([]byte) uint32
+}
+
+func (e *decoderUint32) Decode(t reflect.Type, data []byte) (reflect.Value, error) {
+	return reflect.ValueOf(e.fn(data)), nil
+}
+
+func decoderMakerUint32(fn reflect.Value) Decoder {
+	return &decoderUint32{fn: fn.Interface().(func([]byte) uint32)}
+}
+
+type decoderUint32E struct {
+	fn func([]byte) (uint32, error)
+}
+
+func (e *decoderUint32E) Decode(t reflect.Type, data []byte) (reflect.Value, error) {
+	val, err := e.fn(data)
+	if err != nil {
+		return reflect.Value{}, nil
+	}
+	return reflect.ValueOf(val), nil
+}
+
+func decoderMakerUint32E(fn reflect.Value) Decoder {
+	return &decoderUint32E{fn: fn.Interface().(func([]byte) (uint32, error))}
+}
+
+type decoderTUint32 struct {
+	fn func(reflect.Type, []byte) uint32
+}
+
+func (e *decoderTUint32) Decode(t reflect.Type, data []byte) (reflect.Value, error) {
+	return reflect.ValueOf(e.fn(t, data)), nil
+}
+
+func decoderMakerTUint32(fn reflect.Value) Decoder {
+	return &decoderTUint32{fn: fn.Interface().(func(reflect.Type, []byte) uint32)}
+}
+
+type decoderTUint32E struct {
+	fn func(reflect.Type, []byte) (uint32, error)
+}
+
+func (e *decoderTUint32E) Decode(t reflect.Type, data []byte) (reflect.Value, error) {
+	val, err := e.fn(t, data)
+	if err != nil {
+		return reflect.Value{}, nil
+	}
+	return reflect.ValueOf(val), nil
+}
+
+func decoderMakerTUint32E(fn reflect.Value) Decoder {
+	return &decoderTUint32E{fn: fn.Interface().(func(reflect.Type, []byte) (uint32, error))}
+}
+
+type decoderUint64 struct {
+	fn func([]byte) uint64
+}
+
+func (e *decoderUint64) Decode(t reflect.Type, data []byte) (reflect.Value, error) {
+	return reflect.ValueOf(e.fn(data)), nil
+}
+
+func decoderMakerUint64(fn reflect.Value) Decoder {
+	return &decoderUint64{fn: fn.Interface().(func([]byte) uint64)}
+}
+
+type decoderUint64E struct {
+	fn func([]byte) (uint64, error)
+}
+
+func (e *decoderUint64E) Decode(t reflect.Type, data []byte) (reflect.Value, error) {
+	val, err := e.fn(data)
+	if err != nil {
+		return reflect.Value{}, nil
+	}
+	return reflect.ValueOf(val), nil
+}
+
+func decoderMakerUint64E(fn reflect.Value) Decoder {
+	return &decoderUint64E{fn: fn.Interface().(func([]byte) (uint64, error))}
+}
+
+type decoderTUint64 struct {
+	fn func(reflect.Type, []byte) uint64
+}
+
+func (e *decoderTUint64) Decode(t reflect.Type, data []byte) (reflect.Value, error) {
+	return reflect.ValueOf(e.fn(t, data)), nil
+}
+
+func decoderMakerTUint64(fn reflect.Value) Decoder {
+	return &decoderTUint64{fn: fn.Interface().(func(reflect.Type, []byte) uint64)}
+}
+
+type decoderTUint64E struct {
+	fn func(reflect.Type, []byte) (uint64, error)
+}
+
+func (e *decoderTUint64E) Decode(t reflect.Type, data []byte) (reflect.Value, error) {
+	val, err := e.fn(t, data)
+	if err != nil {
+		return reflect.Value{}, nil
+	}
+	return reflect.ValueOf(val), nil
+}
+
+func decoderMakerTUint64E(fn reflect.Value) Decoder {
+	return &decoderTUint64E{fn: fn.Interface().(func(reflect.Type, []byte) (uint64, error))}
+}
+
+type decoderFloat32 struct {
+	fn func([]byte) float32
+}
+
+func (e *decoderFloat32) Decode(t reflect.Type, data []byte) (reflect.Value, error) {
+	return reflect.ValueOf(e.fn(data)), nil
+}
+
+func decoderMakerFloat32(fn reflect.Value) Decoder {
+	return &decoderFloat32{fn: fn.Interface().(func([]byte) float32)}
+}
+
+type decoderFloat32E struct {
+	fn func([]byte) (float32, error)
+}
+
+func (e *decoderFloat32E) Decode(t reflect.Type, data []byte) (reflect.Value, error) {
+	val, err := e.fn(data)
+	if err != nil {
+		return reflect.Value{}, nil
+	}
+	return reflect.ValueOf(val), nil
+}
+
+func decoderMakerFloat32E(fn reflect.Value) Decoder {
+	return &decoderFloat32E{fn: fn.Interface().(func([]byte) (float32, error))}
+}
+
+type decoderTFloat32 struct {
+	fn func(reflect.Type, []byte) float32
+}
+
+func (e *decoderTFloat32) Decode(t reflect.Type, data []byte) (reflect.Value, error) {
+	return reflect.ValueOf(e.fn(t, data)), nil
+}
+
+func decoderMakerTFloat32(fn reflect.Value) Decoder {
+	return &decoderTFloat32{fn: fn.Interface().(func(reflect.Type, []byte) float32)}
+}
+
+type decoderTFloat32E struct {
+	fn func(reflect.Type, []byte) (float32, error)
+}
+
+func (e *decoderTFloat32E) Decode(t reflect.Type, data []byte) (reflect.Value, error) {
+	val, err := e.fn(t, data)
+	if err != nil {
+		return reflect.Value{}, nil
+	}
+	return reflect.ValueOf(val), nil
+}
+
+func decoderMakerTFloat32E(fn reflect.Value) Decoder {
+	return &decoderTFloat32E{fn: fn.Interface().(func(reflect.Type, []byte) (float32, error))}
+}
+
+type decoderFloat64 struct {
+	fn func([]byte) float64
+}
+
+func (e *decoderFloat64) Decode(t reflect.Type, data []byte) (reflect.Value, error) {
+	return reflect.ValueOf(e.fn(data)), nil
+}
+
+func decoderMakerFloat64(fn reflect.Value) Decoder {
+	return &decoderFloat64{fn: fn.Interface().(func([]byte) float64)}
+}
+
+type decoderFloat64E struct {
+	fn func([]byte) (float64, error)
+}
+
+func (e *decoderFloat64E) Decode(t reflect.Type, data []byte) (reflect.Value, error) {
+	val, err := e.fn(data)
+	if err != nil {
+		return reflect.Value{}, nil
+	}
+	return reflect.ValueOf(val), nil
+}
+
+func decoderMakerFloat64E(fn reflect.Value) Decoder {
+	return &decoderFloat64E{fn: fn.Interface().(func([]byte) (float64, error))}
+}
+
+type decoderTFloat64 struct {
+	fn func(reflect.Type, []byte) float64
+}
+
+func (e *decoderTFloat64) Decode(t reflect.Type, data []byte) (reflect.Value, error) {
+	return reflect.ValueOf(e.fn(t, data)), nil
+}
+
+func decoderMakerTFloat64(fn reflect.Value) Decoder {
+	return &decoderTFloat64{fn: fn.Interface().(func(reflect.Type, []byte) float64)}
+}
+
+type decoderTFloat64E struct {
+	fn func(reflect.Type, []byte) (float64, error)
+}
+
+func (e *decoderTFloat64E) Decode(t reflect.Type, data []byte) (reflect.Value, error) {
+	val, err := e.fn(t, data)
+	if err != nil {
+		return reflect.Value{}, nil
+	}
+	return reflect.ValueOf(val), nil
+}
+
+func decoderMakerTFloat64E(fn reflect.Value) Decoder {
+	return &decoderTFloat64E{fn: fn.Interface().(func(reflect.Type, []byte) (float64, error))}
+}
+
+type decoderTypex_T struct {
+	fn func([]byte) typex.T
+}
+
+func (e *decoderTypex_T) Decode(t reflect.Type, data []byte) (reflect.Value, error) {
+	return reflect.ValueOf(e.fn(data)), nil
+}
+
+func decoderMakerTypex_T(fn reflect.Value) Decoder {
+	return &decoderTypex_T{fn: fn.Interface().(func([]byte) typex.T)}
+}
+
+type decoderTypex_TE struct {
+	fn func([]byte) (typex.T, error)
+}
+
+func (e *decoderTypex_TE) Decode(t reflect.Type, data []byte) (reflect.Value, error) {
+	val, err := e.fn(data)
+	if err != nil {
+		return reflect.Value{}, nil
+	}
+	return reflect.ValueOf(val), nil
+}
+
+func decoderMakerTypex_TE(fn reflect.Value) Decoder {
+	return &decoderTypex_TE{fn: fn.Interface().(func([]byte) (typex.T, error))}
+}
+
+type decoderTTypex_T struct {
+	fn func(reflect.Type, []byte) typex.T
+}
+
+func (e *decoderTTypex_T) Decode(t reflect.Type, data []byte) (reflect.Value, error) {
+	return reflect.ValueOf(e.fn(t, data)), nil
+}
+
+func decoderMakerTTypex_T(fn reflect.Value) Decoder {
+	return &decoderTTypex_T{fn: fn.Interface().(func(reflect.Type, []byte) typex.T)}
+}
+
+type decoderTTypex_TE struct {
+	fn func(reflect.Type, []byte) (typex.T, error)
+}
+
+func (e *decoderTTypex_TE) Decode(t reflect.Type, data []byte) (reflect.Value, error) {
+	val, err := e.fn(t, data)
+	if err != nil {
+		return reflect.Value{}, nil
+	}
+	return reflect.ValueOf(val), nil
+}
+
+func decoderMakerTTypex_TE(fn reflect.Value) Decoder {
+	return &decoderTTypex_TE{fn: fn.Interface().(func(reflect.Type, []byte) (typex.T, error))}
+}
+
+type decoderTypex_U struct {
+	fn func([]byte) typex.U
+}
+
+func (e *decoderTypex_U) Decode(t reflect.Type, data []byte) (reflect.Value, error) {
+	return reflect.ValueOf(e.fn(data)), nil
+}
+
+func decoderMakerTypex_U(fn reflect.Value) Decoder {
+	return &decoderTypex_U{fn: fn.Interface().(func([]byte) typex.U)}
+}
+
+type decoderTypex_UE struct {
+	fn func([]byte) (typex.U, error)
+}
+
+func (e *decoderTypex_UE) Decode(t reflect.Type, data []byte) (reflect.Value, error) {
+	val, err := e.fn(data)
+	if err != nil {
+		return reflect.Value{}, nil
+	}
+	return reflect.ValueOf(val), nil
+}
+
+func decoderMakerTypex_UE(fn reflect.Value) Decoder {
+	return &decoderTypex_UE{fn: fn.Interface().(func([]byte) (typex.U, error))}
+}
+
+type decoderTTypex_U struct {
+	fn func(reflect.Type, []byte) typex.U
+}
+
+func (e *decoderTTypex_U) Decode(t reflect.Type, data []byte) (reflect.Value, error) {
+	return reflect.ValueOf(e.fn(t, data)), nil
+}
+
+func decoderMakerTTypex_U(fn reflect.Value) Decoder {
+	return &decoderTTypex_U{fn: fn.Interface().(func(reflect.Type, []byte) typex.U)}
+}
+
+type decoderTTypex_UE struct {
+	fn func(reflect.Type, []byte) (typex.U, error)
+}
+
+func (e *decoderTTypex_UE) Decode(t reflect.Type, data []byte) (reflect.Value, error) {
+	val, err := e.fn(t, data)
+	if err != nil {
+		return reflect.Value{}, nil
+	}
+	return reflect.ValueOf(val), nil
+}
+
+func decoderMakerTTypex_UE(fn reflect.Value) Decoder {
+	return &decoderTTypex_UE{fn: fn.Interface().(func(reflect.Type, []byte) (typex.U, error))}
+}
+
+type decoderTypex_V struct {
+	fn func([]byte) typex.V
+}
+
+func (e *decoderTypex_V) Decode(t reflect.Type, data []byte) (reflect.Value, error) {
+	return reflect.ValueOf(e.fn(data)), nil
+}
+
+func decoderMakerTypex_V(fn reflect.Value) Decoder {
+	return &decoderTypex_V{fn: fn.Interface().(func([]byte) typex.V)}
+}
+
+type decoderTypex_VE struct {
+	fn func([]byte) (typex.V, error)
+}
+
+func (e *decoderTypex_VE) Decode(t reflect.Type, data []byte) (reflect.Value, error) {
+	val, err := e.fn(data)
+	if err != nil {
+		return reflect.Value{}, nil
+	}
+	return reflect.ValueOf(val), nil
+}
+
+func decoderMakerTypex_VE(fn reflect.Value) Decoder {
+	return &decoderTypex_VE{fn: fn.Interface().(func([]byte) (typex.V, error))}
+}
+
+type decoderTTypex_V struct {
+	fn func(reflect.Type, []byte) typex.V
+}
+
+func (e *decoderTTypex_V) Decode(t reflect.Type, data []byte) (reflect.Value, error) {
+	return reflect.ValueOf(e.fn(t, data)), nil
+}
+
+func decoderMakerTTypex_V(fn reflect.Value) Decoder {
+	return &decoderTTypex_V{fn: fn.Interface().(func(reflect.Type, []byte) typex.V)}
+}
+
+type decoderTTypex_VE struct {
+	fn func(reflect.Type, []byte) (typex.V, error)
+}
+
+func (e *decoderTTypex_VE) Decode(t reflect.Type, data []byte) (reflect.Value, error) {
+	val, err := e.fn(t, data)
+	if err != nil {
+		return reflect.Value{}, nil
+	}
+	return reflect.ValueOf(val), nil
+}
+
+func decoderMakerTTypex_VE(fn reflect.Value) Decoder {
+	return &decoderTTypex_VE{fn: fn.Interface().(func(reflect.Type, []byte) (typex.V, error))}
+}
+
+type decoderTypex_W struct {
+	fn func([]byte) typex.W
+}
+
+func (e *decoderTypex_W) Decode(t reflect.Type, data []byte) (reflect.Value, error) {
+	return reflect.ValueOf(e.fn(data)), nil
+}
+
+func decoderMakerTypex_W(fn reflect.Value) Decoder {
+	return &decoderTypex_W{fn: fn.Interface().(func([]byte) typex.W)}
+}
+
+type decoderTypex_WE struct {
+	fn func([]byte) (typex.W, error)
+}
+
+func (e *decoderTypex_WE) Decode(t reflect.Type, data []byte) (reflect.Value, error) {
+	val, err := e.fn(data)
+	if err != nil {
+		return reflect.Value{}, nil
+	}
+	return reflect.ValueOf(val), nil
+}
+
+func decoderMakerTypex_WE(fn reflect.Value) Decoder {
+	return &decoderTypex_WE{fn: fn.Interface().(func([]byte) (typex.W, error))}
+}
+
+type decoderTTypex_W struct {
+	fn func(reflect.Type, []byte) typex.W
+}
+
+func (e *decoderTTypex_W) Decode(t reflect.Type, data []byte) (reflect.Value, error) {
+	return reflect.ValueOf(e.fn(t, data)), nil
+}
+
+func decoderMakerTTypex_W(fn reflect.Value) Decoder {
+	return &decoderTTypex_W{fn: fn.Interface().(func(reflect.Type, []byte) typex.W)}
+}
+
+type decoderTTypex_WE struct {
+	fn func(reflect.Type, []byte) (typex.W, error)
+}
+
+func (e *decoderTTypex_WE) Decode(t reflect.Type, data []byte) (reflect.Value, error) {
+	val, err := e.fn(t, data)
+	if err != nil {
+		return reflect.Value{}, nil
+	}
+	return reflect.ValueOf(val), nil
+}
+
+func decoderMakerTTypex_WE(fn reflect.Value) Decoder {
+	return &decoderTTypex_WE{fn: fn.Interface().(func(reflect.Type, []byte) (typex.W, error))}
+}
+
+type decoderTypex_X struct {
+	fn func([]byte) typex.X
+}
+
+func (e *decoderTypex_X) Decode(t reflect.Type, data []byte) (reflect.Value, error) {
+	return reflect.ValueOf(e.fn(data)), nil
+}
+
+func decoderMakerTypex_X(fn reflect.Value) Decoder {
+	return &decoderTypex_X{fn: fn.Interface().(func([]byte) typex.X)}
+}
+
+type decoderTypex_XE struct {
+	fn func([]byte) (typex.X, error)
+}
+
+func (e *decoderTypex_XE) Decode(t reflect.Type, data []byte) (reflect.Value, error) {
+	val, err := e.fn(data)
+	if err != nil {
+		return reflect.Value{}, nil
+	}
+	return reflect.ValueOf(val), nil
+}
+
+func decoderMakerTypex_XE(fn reflect.Value) Decoder {
+	return &decoderTypex_XE{fn: fn.Interface().(func([]byte) (typex.X, error))}
+}
+
+type decoderTTypex_X struct {
+	fn func(reflect.Type, []byte) typex.X
+}
+
+func (e *decoderTTypex_X) Decode(t reflect.Type, data []byte) (reflect.Value, error) {
+	return reflect.ValueOf(e.fn(t, data)), nil
+}
+
+func decoderMakerTTypex_X(fn reflect.Value) Decoder {
+	return &decoderTTypex_X{fn: fn.Interface().(func(reflect.Type, []byte) typex.X)}
+}
+
+type decoderTTypex_XE struct {
+	fn func(reflect.Type, []byte) (typex.X, error)
+}
+
+func (e *decoderTTypex_XE) Decode(t reflect.Type, data []byte) (reflect.Value, error) {
+	val, err := e.fn(t, data)
+	if err != nil {
+		return reflect.Value{}, nil
+	}
+	return reflect.ValueOf(val), nil
+}
+
+func decoderMakerTTypex_XE(fn reflect.Value) Decoder {
+	return &decoderTTypex_XE{fn: fn.Interface().(func(reflect.Type, []byte) (typex.X, error))}
+}
+
+type decoderTypex_Y struct {
+	fn func([]byte) typex.Y
+}
+
+func (e *decoderTypex_Y) Decode(t reflect.Type, data []byte) (reflect.Value, error) {
+	return reflect.ValueOf(e.fn(data)), nil
+}
+
+func decoderMakerTypex_Y(fn reflect.Value) Decoder {
+	return &decoderTypex_Y{fn: fn.Interface().(func([]byte) typex.Y)}
+}
+
+type decoderTypex_YE struct {
+	fn func([]byte) (typex.Y, error)
+}
+
+func (e *decoderTypex_YE) Decode(t reflect.Type, data []byte) (reflect.Value, error) {
+	val, err := e.fn(data)
+	if err != nil {
+		return reflect.Value{}, nil
+	}
+	return reflect.ValueOf(val), nil
+}
+
+func decoderMakerTypex_YE(fn reflect.Value) Decoder {
+	return &decoderTypex_YE{fn: fn.Interface().(func([]byte) (typex.Y, error))}
+}
+
+type decoderTTypex_Y struct {
+	fn func(reflect.Type, []byte) typex.Y
+}
+
+func (e *decoderTTypex_Y) Decode(t reflect.Type, data []byte) (reflect.Value, error) {
+	return reflect.ValueOf(e.fn(t, data)), nil
+}
+
+func decoderMakerTTypex_Y(fn reflect.Value) Decoder {
+	return &decoderTTypex_Y{fn: fn.Interface().(func(reflect.Type, []byte) typex.Y)}
+}
+
+type decoderTTypex_YE struct {
+	fn func(reflect.Type, []byte) (typex.Y, error)
+}
+
+func (e *decoderTTypex_YE) Decode(t reflect.Type, data []byte) (reflect.Value, error) {
+	val, err := e.fn(t, data)
+	if err != nil {
+		return reflect.Value{}, nil
+	}
+	return reflect.ValueOf(val), nil
+}
+
+func decoderMakerTTypex_YE(fn reflect.Value) Decoder {
+	return &decoderTTypex_YE{fn: fn.Interface().(func(reflect.Type, []byte) (typex.Y, error))}
+}
+
+type decoderTypex_Z struct {
+	fn func([]byte) typex.Z
+}
+
+func (e *decoderTypex_Z) Decode(t reflect.Type, data []byte) (reflect.Value, error) {
+	return reflect.ValueOf(e.fn(data)), nil
+}
+
+func decoderMakerTypex_Z(fn reflect.Value) Decoder {
+	return &decoderTypex_Z{fn: fn.Interface().(func([]byte) typex.Z)}
+}
+
+type decoderTypex_ZE struct {
+	fn func([]byte) (typex.Z, error)
+}
+
+func (e *decoderTypex_ZE) Decode(t reflect.Type, data []byte) (reflect.Value, error) {
+	val, err := e.fn(data)
+	if err != nil {
+		return reflect.Value{}, nil
+	}
+	return reflect.ValueOf(val), nil
+}
+
+func decoderMakerTypex_ZE(fn reflect.Value) Decoder {
+	return &decoderTypex_ZE{fn: fn.Interface().(func([]byte) (typex.Z, error))}
+}
+
+type decoderTTypex_Z struct {
+	fn func(reflect.Type, []byte) typex.Z
+}
+
+func (e *decoderTTypex_Z) Decode(t reflect.Type, data []byte) (reflect.Value, error) {
+	return reflect.ValueOf(e.fn(t, data)), nil
+}
+
+func decoderMakerTTypex_Z(fn reflect.Value) Decoder {
+	return &decoderTTypex_Z{fn: fn.Interface().(func(reflect.Type, []byte) typex.Z)}
+}
+
+type decoderTTypex_ZE struct {
+	fn func(reflect.Type, []byte) (typex.Z, error)
+}
+
+func (e *decoderTTypex_ZE) Decode(t reflect.Type, data []byte) (reflect.Value, error) {
+	val, err := e.fn(t, data)
+	if err != nil {
+		return reflect.Value{}, nil
+	}
+	return reflect.ValueOf(val), nil
+}
+
+func decoderMakerTTypex_ZE(fn reflect.Value) Decoder {
+	return &decoderTTypex_ZE{fn: fn.Interface().(func(reflect.Type, []byte) (typex.Z, error))}
+}
diff --git a/sdks/go/pkg/beam/core/runtime/exec/decoders.tmpl b/sdks/go/pkg/beam/core/runtime/exec/decoders.tmpl
new file mode 100644
index 00000000000..1df00c76879
--- /dev/null
+++ b/sdks/go/pkg/beam/core/runtime/exec/decoders.tmpl
@@ -0,0 +1,89 @@
+// Licensed to the Apache Software Foundation (ASF) under one or more
+// contributor license agreements.  See the NOTICE file distributed with
+// this work for additional information regarding copyright ownership.
+// The ASF licenses this file to You under the Apache License, Version 2.0
+// (the "License"); you may not use this file except in compliance with
+// the License.  You may obtain a copy of the License at
+//
+//    http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package exec
+
+import (
+    "reflect"
+
+  	"github.com/apache/beam/sdks/go/pkg/beam/core/typex"
+)
+
+func init() {
+{{- range $x := .X}}
+    RegisterDecoder(reflect.TypeOf((*func ([]byte) {{$x.Type}})(nil)).Elem(), decoderMaker{{$x.Name}})
+    RegisterDecoder(reflect.TypeOf((*func ([]byte) ({{$x.Type}}, error))(nil)).Elem(), decoderMaker{{$x.Name}}E)
+    RegisterDecoder(reflect.TypeOf((*func (reflect.Type, []byte) {{$x.Type}})(nil)).Elem(), decoderMakerT{{$x.Name}})
+    RegisterDecoder(reflect.TypeOf((*func (reflect.Type, []byte) ({{$x.Type}}, error))(nil)).Elem(), decoderMakerT{{$x.Name}}E)
+{{- end}}
+}
+
+{{range $x := .X}}
+type decoder{{$x.Name}} struct {
+    fn func ([]byte) {{$x.Type}}
+}
+
+func (e *decoder{{$x.Name}}) Decode(t reflect.Type, data []byte) (reflect.Value, error) {
+    return reflect.ValueOf(e.fn(data)), nil
+}
+
+func decoderMaker{{$x.Name}}(fn reflect.Value) Decoder {
+    return &decoder{{$x.Name}}{fn: fn.Interface().(func ([]byte) {{$x.Type}})}
+}
+
+type decoder{{$x.Name}}E struct {
+    fn func ([]byte) ({{$x.Type}}, error)
+}
+
+func (e *decoder{{$x.Name}}E) Decode(t reflect.Type, data []byte) (reflect.Value, error) {
+    val, err := e.fn(data)
+    if err != nil {
+        return reflect.Value{}, nil
+    }
+    return reflect.ValueOf(val), nil
+}
+
+func decoderMaker{{$x.Name}}E(fn reflect.Value) Decoder {
+    return &decoder{{$x.Name}}E{fn: fn.Interface().(func ([]byte) ({{$x.Type}}, error))}
+}
+
+type decoderT{{$x.Name}} struct {
+    fn func (reflect.Type, []byte) {{$x.Type}}
+}
+
+func (e *decoderT{{$x.Name}}) Decode(t reflect.Type, data []byte) (reflect.Value, error) {
+    return reflect.ValueOf(e.fn(t, data)), nil
+}
+
+func decoderMakerT{{$x.Name}}(fn reflect.Value) Decoder {
+    return &decoderT{{$x.Name}}{fn: fn.Interface().(func (reflect.Type, []byte) {{$x.Type}})}
+}
+
+type decoderT{{$x.Name}}E struct {
+    fn func (reflect.Type, []byte) ({{$x.Type}}, error)
+}
+
+func (e *decoderT{{$x.Name}}E) Decode(t reflect.Type, data []byte) (reflect.Value, error) {
+    val, err := e.fn(t, data)
+    if err != nil {
+        return reflect.Value{}, nil
+    }
+    return reflect.ValueOf(val), nil
+}
+
+func decoderMakerT{{$x.Name}}E(fn reflect.Value) Decoder {
+    return &decoderT{{$x.Name}}E{fn: fn.Interface().(func (reflect.Type, []byte) ({{$x.Type}}, error))}
+}
+{{end}}
diff --git a/sdks/go/pkg/beam/core/runtime/exec/emit.go b/sdks/go/pkg/beam/core/runtime/exec/emit.go
index fb259072e5f..6336b702148 100644
--- a/sdks/go/pkg/beam/core/runtime/exec/emit.go
+++ b/sdks/go/pkg/beam/core/runtime/exec/emit.go
@@ -23,6 +23,7 @@ import (
 
 	"github.com/apache/beam/sdks/go/pkg/beam/core/funcx"
 	"github.com/apache/beam/sdks/go/pkg/beam/core/typex"
+	"github.com/apache/beam/sdks/go/pkg/beam/log"
 )
 
 //go:generate specialize --input=emitters.tmpl --x=data,universals --y=data,universals
@@ -47,7 +48,11 @@ func RegisterEmitter(t reflect.Type, maker func(ElementProcessor) ReusableEmitte
 	emittersMu.Lock()
 	defer emittersMu.Unlock()
 
-	emitters[t.String()] = maker
+	key := t.String()
+	if _, exists := emitters[key]; exists {
+		log.Warnf(context.Background(), "Emitter for %v already registered. Overwriting.", key)
+	}
+	emitters[key] = maker
 }
 
 func makeEmit(t reflect.Type, n ElementProcessor) ReusableEmitter {
diff --git a/sdks/go/pkg/beam/core/runtime/exec/encode.go b/sdks/go/pkg/beam/core/runtime/exec/encode.go
new file mode 100644
index 00000000000..18adbb58d04
--- /dev/null
+++ b/sdks/go/pkg/beam/core/runtime/exec/encode.go
@@ -0,0 +1,91 @@
+// Licensed to the Apache Software Foundation (ASF) under one or more
+// contributor license agreements.  See the NOTICE file distributed with
+// this work for additional information regarding copyright ownership.
+// The ASF licenses this file to You under the Apache License, Version 2.0
+// (the "License"); you may not use this file except in compliance with
+// the License.  You may obtain a copy of the License at
+//
+//    http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package exec
+
+import (
+	"context"
+	"fmt"
+	"reflect"
+	"sync"
+
+	"github.com/apache/beam/sdks/go/pkg/beam/core/funcx"
+	"github.com/apache/beam/sdks/go/pkg/beam/log"
+)
+
+//go:generate specialize --input=encoders.tmpl --x=data,universals
+
+// Encoder is a uniform custom encoder interface.
+type Encoder interface {
+	// Encode encodes the given value (of the given type).
+	Encode(reflect.Type, reflect.Value) ([]byte, error)
+}
+
+var (
+	encoders   = make(map[string]func(reflect.Value) Encoder)
+	encodersMu sync.Mutex
+)
+
+// RegisterEncoder registers an custom encoder invoker for the given type,
+// such as "func(int)[]byte". If multiple encoder invokers are registered
+// for the same type, the last registration wins.
+func RegisterEncoder(t reflect.Type, maker func(reflect.Value) Encoder) {
+	encodersMu.Lock()
+	defer encodersMu.Unlock()
+
+	key := t.String()
+	if _, exists := encoders[key]; exists {
+		log.Warnf(context.Background(), "Encoder for %v already registered. Overwriting.", key)
+	}
+	encoders[key] = maker
+}
+
+func makeEncoder(fn *funcx.Fn) Encoder {
+	encodersMu.Lock()
+	maker, exists := encoders[fn.Fn.Type().String()]
+	encodersMu.Unlock()
+
+	if exists {
+		return maker(fn.Fn)
+	}
+
+	// If no specialized implementation is available, we use the (slower)
+	// reflection-based one.
+
+	return &encoder{fn: fn}
+}
+
+type encoder struct {
+	fn *funcx.Fn
+}
+
+func (e *encoder) Encode(t reflect.Type, elm reflect.Value) ([]byte, error) {
+	args := make([]reflect.Value, len(e.fn.Param))
+	if index, ok := e.fn.Type(); ok {
+		args[index] = reflect.ValueOf(t)
+	}
+	params := e.fn.Params(funcx.FnValue)
+	args[params[0]] = elm
+
+	ret, err := reflectCallNoPanic(e.fn.Fn, args)
+	if err != nil {
+		return nil, err
+	}
+	if index, ok := e.fn.Error(); ok && !ret[index].IsNil() {
+		return nil, fmt.Errorf("encode error: %v", ret[index].Interface())
+	}
+	data := ret[e.fn.Returns(funcx.RetValue)[0]].Interface().([]byte)
+	return data, nil
+}
diff --git a/sdks/go/pkg/beam/core/runtime/exec/encoders.go b/sdks/go/pkg/beam/core/runtime/exec/encoders.go
new file mode 100644
index 00000000000..7cdff48d9ed
--- /dev/null
+++ b/sdks/go/pkg/beam/core/runtime/exec/encoders.go
@@ -0,0 +1,1171 @@
+// File generated by specialize. Do not edit.
+
+// Licensed to the Apache Software Foundation (ASF) under one or more
+// contributor license agreements.  See the NOTICE file distributed with
+// this work for additional information regarding copyright ownership.
+// The ASF licenses this file to You under the Apache License, Version 2.0
+// (the "License"); you may not use this file except in compliance with
+// the License.  You may obtain a copy of the License at
+//
+//    http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package exec
+
+import (
+	"reflect"
+
+	"github.com/apache/beam/sdks/go/pkg/beam/core/typex"
+)
+
+func init() {
+	RegisterEncoder(reflect.TypeOf((*func([]byte) []byte)(nil)).Elem(), encoderMakerByteSlice)
+	RegisterEncoder(reflect.TypeOf((*func([]byte) ([]byte, error))(nil)).Elem(), encoderMakerByteSliceE)
+	RegisterEncoder(reflect.TypeOf((*func(reflect.Type, []byte) []byte)(nil)).Elem(), encoderMakerTByteSlice)
+	RegisterEncoder(reflect.TypeOf((*func(reflect.Type, []byte) ([]byte, error))(nil)).Elem(), encoderMakerTByteSliceE)
+	RegisterEncoder(reflect.TypeOf((*func(bool) []byte)(nil)).Elem(), encoderMakerBool)
+	RegisterEncoder(reflect.TypeOf((*func(bool) ([]byte, error))(nil)).Elem(), encoderMakerBoolE)
+	RegisterEncoder(reflect.TypeOf((*func(reflect.Type, bool) []byte)(nil)).Elem(), encoderMakerTBool)
+	RegisterEncoder(reflect.TypeOf((*func(reflect.Type, bool) ([]byte, error))(nil)).Elem(), encoderMakerTBoolE)
+	RegisterEncoder(reflect.TypeOf((*func(string) []byte)(nil)).Elem(), encoderMakerString)
+	RegisterEncoder(reflect.TypeOf((*func(string) ([]byte, error))(nil)).Elem(), encoderMakerStringE)
+	RegisterEncoder(reflect.TypeOf((*func(reflect.Type, string) []byte)(nil)).Elem(), encoderMakerTString)
+	RegisterEncoder(reflect.TypeOf((*func(reflect.Type, string) ([]byte, error))(nil)).Elem(), encoderMakerTStringE)
+	RegisterEncoder(reflect.TypeOf((*func(int) []byte)(nil)).Elem(), encoderMakerInt)
+	RegisterEncoder(reflect.TypeOf((*func(int) ([]byte, error))(nil)).Elem(), encoderMakerIntE)
+	RegisterEncoder(reflect.TypeOf((*func(reflect.Type, int) []byte)(nil)).Elem(), encoderMakerTInt)
+	RegisterEncoder(reflect.TypeOf((*func(reflect.Type, int) ([]byte, error))(nil)).Elem(), encoderMakerTIntE)
+	RegisterEncoder(reflect.TypeOf((*func(int8) []byte)(nil)).Elem(), encoderMakerInt8)
+	RegisterEncoder(reflect.TypeOf((*func(int8) ([]byte, error))(nil)).Elem(), encoderMakerInt8E)
+	RegisterEncoder(reflect.TypeOf((*func(reflect.Type, int8) []byte)(nil)).Elem(), encoderMakerTInt8)
+	RegisterEncoder(reflect.TypeOf((*func(reflect.Type, int8) ([]byte, error))(nil)).Elem(), encoderMakerTInt8E)
+	RegisterEncoder(reflect.TypeOf((*func(int16) []byte)(nil)).Elem(), encoderMakerInt16)
+	RegisterEncoder(reflect.TypeOf((*func(int16) ([]byte, error))(nil)).Elem(), encoderMakerInt16E)
+	RegisterEncoder(reflect.TypeOf((*func(reflect.Type, int16) []byte)(nil)).Elem(), encoderMakerTInt16)
+	RegisterEncoder(reflect.TypeOf((*func(reflect.Type, int16) ([]byte, error))(nil)).Elem(), encoderMakerTInt16E)
+	RegisterEncoder(reflect.TypeOf((*func(int32) []byte)(nil)).Elem(), encoderMakerInt32)
+	RegisterEncoder(reflect.TypeOf((*func(int32) ([]byte, error))(nil)).Elem(), encoderMakerInt32E)
+	RegisterEncoder(reflect.TypeOf((*func(reflect.Type, int32) []byte)(nil)).Elem(), encoderMakerTInt32)
+	RegisterEncoder(reflect.TypeOf((*func(reflect.Type, int32) ([]byte, error))(nil)).Elem(), encoderMakerTInt32E)
+	RegisterEncoder(reflect.TypeOf((*func(int64) []byte)(nil)).Elem(), encoderMakerInt64)
+	RegisterEncoder(reflect.TypeOf((*func(int64) ([]byte, error))(nil)).Elem(), encoderMakerInt64E)
+	RegisterEncoder(reflect.TypeOf((*func(reflect.Type, int64) []byte)(nil)).Elem(), encoderMakerTInt64)
+	RegisterEncoder(reflect.TypeOf((*func(reflect.Type, int64) ([]byte, error))(nil)).Elem(), encoderMakerTInt64E)
+	RegisterEncoder(reflect.TypeOf((*func(uint) []byte)(nil)).Elem(), encoderMakerUint)
+	RegisterEncoder(reflect.TypeOf((*func(uint) ([]byte, error))(nil)).Elem(), encoderMakerUintE)
+	RegisterEncoder(reflect.TypeOf((*func(reflect.Type, uint) []byte)(nil)).Elem(), encoderMakerTUint)
+	RegisterEncoder(reflect.TypeOf((*func(reflect.Type, uint) ([]byte, error))(nil)).Elem(), encoderMakerTUintE)
+	RegisterEncoder(reflect.TypeOf((*func(uint8) []byte)(nil)).Elem(), encoderMakerUint8)
+	RegisterEncoder(reflect.TypeOf((*func(uint8) ([]byte, error))(nil)).Elem(), encoderMakerUint8E)
+	RegisterEncoder(reflect.TypeOf((*func(reflect.Type, uint8) []byte)(nil)).Elem(), encoderMakerTUint8)
+	RegisterEncoder(reflect.TypeOf((*func(reflect.Type, uint8) ([]byte, error))(nil)).Elem(), encoderMakerTUint8E)
+	RegisterEncoder(reflect.TypeOf((*func(uint16) []byte)(nil)).Elem(), encoderMakerUint16)
+	RegisterEncoder(reflect.TypeOf((*func(uint16) ([]byte, error))(nil)).Elem(), encoderMakerUint16E)
+	RegisterEncoder(reflect.TypeOf((*func(reflect.Type, uint16) []byte)(nil)).Elem(), encoderMakerTUint16)
+	RegisterEncoder(reflect.TypeOf((*func(reflect.Type, uint16) ([]byte, error))(nil)).Elem(), encoderMakerTUint16E)
+	RegisterEncoder(reflect.TypeOf((*func(uint32) []byte)(nil)).Elem(), encoderMakerUint32)
+	RegisterEncoder(reflect.TypeOf((*func(uint32) ([]byte, error))(nil)).Elem(), encoderMakerUint32E)
+	RegisterEncoder(reflect.TypeOf((*func(reflect.Type, uint32) []byte)(nil)).Elem(), encoderMakerTUint32)
+	RegisterEncoder(reflect.TypeOf((*func(reflect.Type, uint32) ([]byte, error))(nil)).Elem(), encoderMakerTUint32E)
+	RegisterEncoder(reflect.TypeOf((*func(uint64) []byte)(nil)).Elem(), encoderMakerUint64)
+	RegisterEncoder(reflect.TypeOf((*func(uint64) ([]byte, error))(nil)).Elem(), encoderMakerUint64E)
+	RegisterEncoder(reflect.TypeOf((*func(reflect.Type, uint64) []byte)(nil)).Elem(), encoderMakerTUint64)
+	RegisterEncoder(reflect.TypeOf((*func(reflect.Type, uint64) ([]byte, error))(nil)).Elem(), encoderMakerTUint64E)
+	RegisterEncoder(reflect.TypeOf((*func(float32) []byte)(nil)).Elem(), encoderMakerFloat32)
+	RegisterEncoder(reflect.TypeOf((*func(float32) ([]byte, error))(nil)).Elem(), encoderMakerFloat32E)
+	RegisterEncoder(reflect.TypeOf((*func(reflect.Type, float32) []byte)(nil)).Elem(), encoderMakerTFloat32)
+	RegisterEncoder(reflect.TypeOf((*func(reflect.Type, float32) ([]byte, error))(nil)).Elem(), encoderMakerTFloat32E)
+	RegisterEncoder(reflect.TypeOf((*func(float64) []byte)(nil)).Elem(), encoderMakerFloat64)
+	RegisterEncoder(reflect.TypeOf((*func(float64) ([]byte, error))(nil)).Elem(), encoderMakerFloat64E)
+	RegisterEncoder(reflect.TypeOf((*func(reflect.Type, float64) []byte)(nil)).Elem(), encoderMakerTFloat64)
+	RegisterEncoder(reflect.TypeOf((*func(reflect.Type, float64) ([]byte, error))(nil)).Elem(), encoderMakerTFloat64E)
+	RegisterEncoder(reflect.TypeOf((*func(typex.T) []byte)(nil)).Elem(), encoderMakerTypex_T)
+	RegisterEncoder(reflect.TypeOf((*func(typex.T) ([]byte, error))(nil)).Elem(), encoderMakerTypex_TE)
+	RegisterEncoder(reflect.TypeOf((*func(reflect.Type, typex.T) []byte)(nil)).Elem(), encoderMakerTTypex_T)
+	RegisterEncoder(reflect.TypeOf((*func(reflect.Type, typex.T) ([]byte, error))(nil)).Elem(), encoderMakerTTypex_TE)
+	RegisterEncoder(reflect.TypeOf((*func(typex.U) []byte)(nil)).Elem(), encoderMakerTypex_U)
+	RegisterEncoder(reflect.TypeOf((*func(typex.U) ([]byte, error))(nil)).Elem(), encoderMakerTypex_UE)
+	RegisterEncoder(reflect.TypeOf((*func(reflect.Type, typex.U) []byte)(nil)).Elem(), encoderMakerTTypex_U)
+	RegisterEncoder(reflect.TypeOf((*func(reflect.Type, typex.U) ([]byte, error))(nil)).Elem(), encoderMakerTTypex_UE)
+	RegisterEncoder(reflect.TypeOf((*func(typex.V) []byte)(nil)).Elem(), encoderMakerTypex_V)
+	RegisterEncoder(reflect.TypeOf((*func(typex.V) ([]byte, error))(nil)).Elem(), encoderMakerTypex_VE)
+	RegisterEncoder(reflect.TypeOf((*func(reflect.Type, typex.V) []byte)(nil)).Elem(), encoderMakerTTypex_V)
+	RegisterEncoder(reflect.TypeOf((*func(reflect.Type, typex.V) ([]byte, error))(nil)).Elem(), encoderMakerTTypex_VE)
+	RegisterEncoder(reflect.TypeOf((*func(typex.W) []byte)(nil)).Elem(), encoderMakerTypex_W)
+	RegisterEncoder(reflect.TypeOf((*func(typex.W) ([]byte, error))(nil)).Elem(), encoderMakerTypex_WE)
+	RegisterEncoder(reflect.TypeOf((*func(reflect.Type, typex.W) []byte)(nil)).Elem(), encoderMakerTTypex_W)
+	RegisterEncoder(reflect.TypeOf((*func(reflect.Type, typex.W) ([]byte, error))(nil)).Elem(), encoderMakerTTypex_WE)
+	RegisterEncoder(reflect.TypeOf((*func(typex.X) []byte)(nil)).Elem(), encoderMakerTypex_X)
+	RegisterEncoder(reflect.TypeOf((*func(typex.X) ([]byte, error))(nil)).Elem(), encoderMakerTypex_XE)
+	RegisterEncoder(reflect.TypeOf((*func(reflect.Type, typex.X) []byte)(nil)).Elem(), encoderMakerTTypex_X)
+	RegisterEncoder(reflect.TypeOf((*func(reflect.Type, typex.X) ([]byte, error))(nil)).Elem(), encoderMakerTTypex_XE)
+	RegisterEncoder(reflect.TypeOf((*func(typex.Y) []byte)(nil)).Elem(), encoderMakerTypex_Y)
+	RegisterEncoder(reflect.TypeOf((*func(typex.Y) ([]byte, error))(nil)).Elem(), encoderMakerTypex_YE)
+	RegisterEncoder(reflect.TypeOf((*func(reflect.Type, typex.Y) []byte)(nil)).Elem(), encoderMakerTTypex_Y)
+	RegisterEncoder(reflect.TypeOf((*func(reflect.Type, typex.Y) ([]byte, error))(nil)).Elem(), encoderMakerTTypex_YE)
+	RegisterEncoder(reflect.TypeOf((*func(typex.Z) []byte)(nil)).Elem(), encoderMakerTypex_Z)
+	RegisterEncoder(reflect.TypeOf((*func(typex.Z) ([]byte, error))(nil)).Elem(), encoderMakerTypex_ZE)
+	RegisterEncoder(reflect.TypeOf((*func(reflect.Type, typex.Z) []byte)(nil)).Elem(), encoderMakerTTypex_Z)
+	RegisterEncoder(reflect.TypeOf((*func(reflect.Type, typex.Z) ([]byte, error))(nil)).Elem(), encoderMakerTTypex_ZE)
+}
+
+type encoderByteSlice struct {
+	fn func([]byte) []byte
+}
+
+func (e *encoderByteSlice) Encode(t reflect.Type, val reflect.Value) ([]byte, error) {
+	return e.fn(val.Interface().([]byte)), nil
+}
+
+func encoderMakerByteSlice(fn reflect.Value) Encoder {
+	return &encoderByteSlice{fn: fn.Interface().(func([]byte) []byte)}
+}
+
+type encoderByteSliceE struct {
+	fn func([]byte) ([]byte, error)
+}
+
+func (e *encoderByteSliceE) Encode(t reflect.Type, val reflect.Value) ([]byte, error) {
+	return e.fn(val.Interface().([]byte))
+}
+
+func encoderMakerByteSliceE(fn reflect.Value) Encoder {
+	return &encoderByteSliceE{fn: fn.Interface().(func([]byte) ([]byte, error))}
+}
+
+type encoderTByteSlice struct {
+	fn func(reflect.Type, []byte) []byte
+}
+
+func (e *encoderTByteSlice) Encode(t reflect.Type, val reflect.Value) ([]byte, error) {
+	return e.fn(t, val.Interface().([]byte)), nil
+}
+
+func encoderMakerTByteSlice(fn reflect.Value) Encoder {
+	return &encoderTByteSlice{fn: fn.Interface().(func(reflect.Type, []byte) []byte)}
+}
+
+type encoderTByteSliceE struct {
+	fn func(reflect.Type, []byte) ([]byte, error)
+}
+
+func (e *encoderTByteSliceE) Encode(t reflect.Type, val reflect.Value) ([]byte, error) {
+	return e.fn(t, val.Interface().([]byte))
+}
+
+func encoderMakerTByteSliceE(fn reflect.Value) Encoder {
+	return &encoderTByteSliceE{fn: fn.Interface().(func(reflect.Type, []byte) ([]byte, error))}
+}
+
+type encoderBool struct {
+	fn func(bool) []byte
+}
+
+func (e *encoderBool) Encode(t reflect.Type, val reflect.Value) ([]byte, error) {
+	return e.fn(val.Interface().(bool)), nil
+}
+
+func encoderMakerBool(fn reflect.Value) Encoder {
+	return &encoderBool{fn: fn.Interface().(func(bool) []byte)}
+}
+
+type encoderBoolE struct {
+	fn func(bool) ([]byte, error)
+}
+
+func (e *encoderBoolE) Encode(t reflect.Type, val reflect.Value) ([]byte, error) {
+	return e.fn(val.Interface().(bool))
+}
+
+func encoderMakerBoolE(fn reflect.Value) Encoder {
+	return &encoderBoolE{fn: fn.Interface().(func(bool) ([]byte, error))}
+}
+
+type encoderTBool struct {
+	fn func(reflect.Type, bool) []byte
+}
+
+func (e *encoderTBool) Encode(t reflect.Type, val reflect.Value) ([]byte, error) {
+	return e.fn(t, val.Interface().(bool)), nil
+}
+
+func encoderMakerTBool(fn reflect.Value) Encoder {
+	return &encoderTBool{fn: fn.Interface().(func(reflect.Type, bool) []byte)}
+}
+
+type encoderTBoolE struct {
+	fn func(reflect.Type, bool) ([]byte, error)
+}
+
+func (e *encoderTBoolE) Encode(t reflect.Type, val reflect.Value) ([]byte, error) {
+	return e.fn(t, val.Interface().(bool))
+}
+
+func encoderMakerTBoolE(fn reflect.Value) Encoder {
+	return &encoderTBoolE{fn: fn.Interface().(func(reflect.Type, bool) ([]byte, error))}
+}
+
+type encoderString struct {
+	fn func(string) []byte
+}
+
+func (e *encoderString) Encode(t reflect.Type, val reflect.Value) ([]byte, error) {
+	return e.fn(val.Interface().(string)), nil
+}
+
+func encoderMakerString(fn reflect.Value) Encoder {
+	return &encoderString{fn: fn.Interface().(func(string) []byte)}
+}
+
+type encoderStringE struct {
+	fn func(string) ([]byte, error)
+}
+
+func (e *encoderStringE) Encode(t reflect.Type, val reflect.Value) ([]byte, error) {
+	return e.fn(val.Interface().(string))
+}
+
+func encoderMakerStringE(fn reflect.Value) Encoder {
+	return &encoderStringE{fn: fn.Interface().(func(string) ([]byte, error))}
+}
+
+type encoderTString struct {
+	fn func(reflect.Type, string) []byte
+}
+
+func (e *encoderTString) Encode(t reflect.Type, val reflect.Value) ([]byte, error) {
+	return e.fn(t, val.Interface().(string)), nil
+}
+
+func encoderMakerTString(fn reflect.Value) Encoder {
+	return &encoderTString{fn: fn.Interface().(func(reflect.Type, string) []byte)}
+}
+
+type encoderTStringE struct {
+	fn func(reflect.Type, string) ([]byte, error)
+}
+
+func (e *encoderTStringE) Encode(t reflect.Type, val reflect.Value) ([]byte, error) {
+	return e.fn(t, val.Interface().(string))
+}
+
+func encoderMakerTStringE(fn reflect.Value) Encoder {
+	return &encoderTStringE{fn: fn.Interface().(func(reflect.Type, string) ([]byte, error))}
+}
+
+type encoderInt struct {
+	fn func(int) []byte
+}
+
+func (e *encoderInt) Encode(t reflect.Type, val reflect.Value) ([]byte, error) {
+	return e.fn(val.Interface().(int)), nil
+}
+
+func encoderMakerInt(fn reflect.Value) Encoder {
+	return &encoderInt{fn: fn.Interface().(func(int) []byte)}
+}
+
+type encoderIntE struct {
+	fn func(int) ([]byte, error)
+}
+
+func (e *encoderIntE) Encode(t reflect.Type, val reflect.Value) ([]byte, error) {
+	return e.fn(val.Interface().(int))
+}
+
+func encoderMakerIntE(fn reflect.Value) Encoder {
+	return &encoderIntE{fn: fn.Interface().(func(int) ([]byte, error))}
+}
+
+type encoderTInt struct {
+	fn func(reflect.Type, int) []byte
+}
+
+func (e *encoderTInt) Encode(t reflect.Type, val reflect.Value) ([]byte, error) {
+	return e.fn(t, val.Interface().(int)), nil
+}
+
+func encoderMakerTInt(fn reflect.Value) Encoder {
+	return &encoderTInt{fn: fn.Interface().(func(reflect.Type, int) []byte)}
+}
+
+type encoderTIntE struct {
+	fn func(reflect.Type, int) ([]byte, error)
+}
+
+func (e *encoderTIntE) Encode(t reflect.Type, val reflect.Value) ([]byte, error) {
+	return e.fn(t, val.Interface().(int))
+}
+
+func encoderMakerTIntE(fn reflect.Value) Encoder {
+	return &encoderTIntE{fn: fn.Interface().(func(reflect.Type, int) ([]byte, error))}
+}
+
+type encoderInt8 struct {
+	fn func(int8) []byte
+}
+
+func (e *encoderInt8) Encode(t reflect.Type, val reflect.Value) ([]byte, error) {
+	return e.fn(val.Interface().(int8)), nil
+}
+
+func encoderMakerInt8(fn reflect.Value) Encoder {
+	return &encoderInt8{fn: fn.Interface().(func(int8) []byte)}
+}
+
+type encoderInt8E struct {
+	fn func(int8) ([]byte, error)
+}
+
+func (e *encoderInt8E) Encode(t reflect.Type, val reflect.Value) ([]byte, error) {
+	return e.fn(val.Interface().(int8))
+}
+
+func encoderMakerInt8E(fn reflect.Value) Encoder {
+	return &encoderInt8E{fn: fn.Interface().(func(int8) ([]byte, error))}
+}
+
+type encoderTInt8 struct {
+	fn func(reflect.Type, int8) []byte
+}
+
+func (e *encoderTInt8) Encode(t reflect.Type, val reflect.Value) ([]byte, error) {
+	return e.fn(t, val.Interface().(int8)), nil
+}
+
+func encoderMakerTInt8(fn reflect.Value) Encoder {
+	return &encoderTInt8{fn: fn.Interface().(func(reflect.Type, int8) []byte)}
+}
+
+type encoderTInt8E struct {
+	fn func(reflect.Type, int8) ([]byte, error)
+}
+
+func (e *encoderTInt8E) Encode(t reflect.Type, val reflect.Value) ([]byte, error) {
+	return e.fn(t, val.Interface().(int8))
+}
+
+func encoderMakerTInt8E(fn reflect.Value) Encoder {
+	return &encoderTInt8E{fn: fn.Interface().(func(reflect.Type, int8) ([]byte, error))}
+}
+
+type encoderInt16 struct {
+	fn func(int16) []byte
+}
+
+func (e *encoderInt16) Encode(t reflect.Type, val reflect.Value) ([]byte, error) {
+	return e.fn(val.Interface().(int16)), nil
+}
+
+func encoderMakerInt16(fn reflect.Value) Encoder {
+	return &encoderInt16{fn: fn.Interface().(func(int16) []byte)}
+}
+
+type encoderInt16E struct {
+	fn func(int16) ([]byte, error)
+}
+
+func (e *encoderInt16E) Encode(t reflect.Type, val reflect.Value) ([]byte, error) {
+	return e.fn(val.Interface().(int16))
+}
+
+func encoderMakerInt16E(fn reflect.Value) Encoder {
+	return &encoderInt16E{fn: fn.Interface().(func(int16) ([]byte, error))}
+}
+
+type encoderTInt16 struct {
+	fn func(reflect.Type, int16) []byte
+}
+
+func (e *encoderTInt16) Encode(t reflect.Type, val reflect.Value) ([]byte, error) {
+	return e.fn(t, val.Interface().(int16)), nil
+}
+
+func encoderMakerTInt16(fn reflect.Value) Encoder {
+	return &encoderTInt16{fn: fn.Interface().(func(reflect.Type, int16) []byte)}
+}
+
+type encoderTInt16E struct {
+	fn func(reflect.Type, int16) ([]byte, error)
+}
+
+func (e *encoderTInt16E) Encode(t reflect.Type, val reflect.Value) ([]byte, error) {
+	return e.fn(t, val.Interface().(int16))
+}
+
+func encoderMakerTInt16E(fn reflect.Value) Encoder {
+	return &encoderTInt16E{fn: fn.Interface().(func(reflect.Type, int16) ([]byte, error))}
+}
+
+type encoderInt32 struct {
+	fn func(int32) []byte
+}
+
+func (e *encoderInt32) Encode(t reflect.Type, val reflect.Value) ([]byte, error) {
+	return e.fn(val.Interface().(int32)), nil
+}
+
+func encoderMakerInt32(fn reflect.Value) Encoder {
+	return &encoderInt32{fn: fn.Interface().(func(int32) []byte)}
+}
+
+type encoderInt32E struct {
+	fn func(int32) ([]byte, error)
+}
+
+func (e *encoderInt32E) Encode(t reflect.Type, val reflect.Value) ([]byte, error) {
+	return e.fn(val.Interface().(int32))
+}
+
+func encoderMakerInt32E(fn reflect.Value) Encoder {
+	return &encoderInt32E{fn: fn.Interface().(func(int32) ([]byte, error))}
+}
+
+type encoderTInt32 struct {
+	fn func(reflect.Type, int32) []byte
+}
+
+func (e *encoderTInt32) Encode(t reflect.Type, val reflect.Value) ([]byte, error) {
+	return e.fn(t, val.Interface().(int32)), nil
+}
+
+func encoderMakerTInt32(fn reflect.Value) Encoder {
+	return &encoderTInt32{fn: fn.Interface().(func(reflect.Type, int32) []byte)}
+}
+
+type encoderTInt32E struct {
+	fn func(reflect.Type, int32) ([]byte, error)
+}
+
+func (e *encoderTInt32E) Encode(t reflect.Type, val reflect.Value) ([]byte, error) {
+	return e.fn(t, val.Interface().(int32))
+}
+
+func encoderMakerTInt32E(fn reflect.Value) Encoder {
+	return &encoderTInt32E{fn: fn.Interface().(func(reflect.Type, int32) ([]byte, error))}
+}
+
+type encoderInt64 struct {
+	fn func(int64) []byte
+}
+
+func (e *encoderInt64) Encode(t reflect.Type, val reflect.Value) ([]byte, error) {
+	return e.fn(val.Interface().(int64)), nil
+}
+
+func encoderMakerInt64(fn reflect.Value) Encoder {
+	return &encoderInt64{fn: fn.Interface().(func(int64) []byte)}
+}
+
+type encoderInt64E struct {
+	fn func(int64) ([]byte, error)
+}
+
+func (e *encoderInt64E) Encode(t reflect.Type, val reflect.Value) ([]byte, error) {
+	return e.fn(val.Interface().(int64))
+}
+
+func encoderMakerInt64E(fn reflect.Value) Encoder {
+	return &encoderInt64E{fn: fn.Interface().(func(int64) ([]byte, error))}
+}
+
+type encoderTInt64 struct {
+	fn func(reflect.Type, int64) []byte
+}
+
+func (e *encoderTInt64) Encode(t reflect.Type, val reflect.Value) ([]byte, error) {
+	return e.fn(t, val.Interface().(int64)), nil
+}
+
+func encoderMakerTInt64(fn reflect.Value) Encoder {
+	return &encoderTInt64{fn: fn.Interface().(func(reflect.Type, int64) []byte)}
+}
+
+type encoderTInt64E struct {
+	fn func(reflect.Type, int64) ([]byte, error)
+}
+
+func (e *encoderTInt64E) Encode(t reflect.Type, val reflect.Value) ([]byte, error) {
+	return e.fn(t, val.Interface().(int64))
+}
+
+func encoderMakerTInt64E(fn reflect.Value) Encoder {
+	return &encoderTInt64E{fn: fn.Interface().(func(reflect.Type, int64) ([]byte, error))}
+}
+
+type encoderUint struct {
+	fn func(uint) []byte
+}
+
+func (e *encoderUint) Encode(t reflect.Type, val reflect.Value) ([]byte, error) {
+	return e.fn(val.Interface().(uint)), nil
+}
+
+func encoderMakerUint(fn reflect.Value) Encoder {
+	return &encoderUint{fn: fn.Interface().(func(uint) []byte)}
+}
+
+type encoderUintE struct {
+	fn func(uint) ([]byte, error)
+}
+
+func (e *encoderUintE) Encode(t reflect.Type, val reflect.Value) ([]byte, error) {
+	return e.fn(val.Interface().(uint))
+}
+
+func encoderMakerUintE(fn reflect.Value) Encoder {
+	return &encoderUintE{fn: fn.Interface().(func(uint) ([]byte, error))}
+}
+
+type encoderTUint struct {
+	fn func(reflect.Type, uint) []byte
+}
+
+func (e *encoderTUint) Encode(t reflect.Type, val reflect.Value) ([]byte, error) {
+	return e.fn(t, val.Interface().(uint)), nil
+}
+
+func encoderMakerTUint(fn reflect.Value) Encoder {
+	return &encoderTUint{fn: fn.Interface().(func(reflect.Type, uint) []byte)}
+}
+
+type encoderTUintE struct {
+	fn func(reflect.Type, uint) ([]byte, error)
+}
+
+func (e *encoderTUintE) Encode(t reflect.Type, val reflect.Value) ([]byte, error) {
+	return e.fn(t, val.Interface().(uint))
+}
+
+func encoderMakerTUintE(fn reflect.Value) Encoder {
+	return &encoderTUintE{fn: fn.Interface().(func(reflect.Type, uint) ([]byte, error))}
+}
+
+type encoderUint8 struct {
+	fn func(uint8) []byte
+}
+
+func (e *encoderUint8) Encode(t reflect.Type, val reflect.Value) ([]byte, error) {
+	return e.fn(val.Interface().(uint8)), nil
+}
+
+func encoderMakerUint8(fn reflect.Value) Encoder {
+	return &encoderUint8{fn: fn.Interface().(func(uint8) []byte)}
+}
+
+type encoderUint8E struct {
+	fn func(uint8) ([]byte, error)
+}
+
+func (e *encoderUint8E) Encode(t reflect.Type, val reflect.Value) ([]byte, error) {
+	return e.fn(val.Interface().(uint8))
+}
+
+func encoderMakerUint8E(fn reflect.Value) Encoder {
+	return &encoderUint8E{fn: fn.Interface().(func(uint8) ([]byte, error))}
+}
+
+type encoderTUint8 struct {
+	fn func(reflect.Type, uint8) []byte
+}
+
+func (e *encoderTUint8) Encode(t reflect.Type, val reflect.Value) ([]byte, error) {
+	return e.fn(t, val.Interface().(uint8)), nil
+}
+
+func encoderMakerTUint8(fn reflect.Value) Encoder {
+	return &encoderTUint8{fn: fn.Interface().(func(reflect.Type, uint8) []byte)}
+}
+
+type encoderTUint8E struct {
+	fn func(reflect.Type, uint8) ([]byte, error)
+}
+
+func (e *encoderTUint8E) Encode(t reflect.Type, val reflect.Value) ([]byte, error) {
+	return e.fn(t, val.Interface().(uint8))
+}
+
+func encoderMakerTUint8E(fn reflect.Value) Encoder {
+	return &encoderTUint8E{fn: fn.Interface().(func(reflect.Type, uint8) ([]byte, error))}
+}
+
+type encoderUint16 struct {
+	fn func(uint16) []byte
+}
+
+func (e *encoderUint16) Encode(t reflect.Type, val reflect.Value) ([]byte, error) {
+	return e.fn(val.Interface().(uint16)), nil
+}
+
+func encoderMakerUint16(fn reflect.Value) Encoder {
+	return &encoderUint16{fn: fn.Interface().(func(uint16) []byte)}
+}
+
+type encoderUint16E struct {
+	fn func(uint16) ([]byte, error)
+}
+
+func (e *encoderUint16E) Encode(t reflect.Type, val reflect.Value) ([]byte, error) {
+	return e.fn(val.Interface().(uint16))
+}
+
+func encoderMakerUint16E(fn reflect.Value) Encoder {
+	return &encoderUint16E{fn: fn.Interface().(func(uint16) ([]byte, error))}
+}
+
+type encoderTUint16 struct {
+	fn func(reflect.Type, uint16) []byte
+}
+
+func (e *encoderTUint16) Encode(t reflect.Type, val reflect.Value) ([]byte, error) {
+	return e.fn(t, val.Interface().(uint16)), nil
+}
+
+func encoderMakerTUint16(fn reflect.Value) Encoder {
+	return &encoderTUint16{fn: fn.Interface().(func(reflect.Type, uint16) []byte)}
+}
+
+type encoderTUint16E struct {
+	fn func(reflect.Type, uint16) ([]byte, error)
+}
+
+func (e *encoderTUint16E) Encode(t reflect.Type, val reflect.Value) ([]byte, error) {
+	return e.fn(t, val.Interface().(uint16))
+}
+
+func encoderMakerTUint16E(fn reflect.Value) Encoder {
+	return &encoderTUint16E{fn: fn.Interface().(func(reflect.Type, uint16) ([]byte, error))}
+}
+
+type encoderUint32 struct {
+	fn func(uint32) []byte
+}
+
+func (e *encoderUint32) Encode(t reflect.Type, val reflect.Value) ([]byte, error) {
+	return e.fn(val.Interface().(uint32)), nil
+}
+
+func encoderMakerUint32(fn reflect.Value) Encoder {
+	return &encoderUint32{fn: fn.Interface().(func(uint32) []byte)}
+}
+
+type encoderUint32E struct {
+	fn func(uint32) ([]byte, error)
+}
+
+func (e *encoderUint32E) Encode(t reflect.Type, val reflect.Value) ([]byte, error) {
+	return e.fn(val.Interface().(uint32))
+}
+
+func encoderMakerUint32E(fn reflect.Value) Encoder {
+	return &encoderUint32E{fn: fn.Interface().(func(uint32) ([]byte, error))}
+}
+
+type encoderTUint32 struct {
+	fn func(reflect.Type, uint32) []byte
+}
+
+func (e *encoderTUint32) Encode(t reflect.Type, val reflect.Value) ([]byte, error) {
+	return e.fn(t, val.Interface().(uint32)), nil
+}
+
+func encoderMakerTUint32(fn reflect.Value) Encoder {
+	return &encoderTUint32{fn: fn.Interface().(func(reflect.Type, uint32) []byte)}
+}
+
+type encoderTUint32E struct {
+	fn func(reflect.Type, uint32) ([]byte, error)
+}
+
+func (e *encoderTUint32E) Encode(t reflect.Type, val reflect.Value) ([]byte, error) {
+	return e.fn(t, val.Interface().(uint32))
+}
+
+func encoderMakerTUint32E(fn reflect.Value) Encoder {
+	return &encoderTUint32E{fn: fn.Interface().(func(reflect.Type, uint32) ([]byte, error))}
+}
+
+type encoderUint64 struct {
+	fn func(uint64) []byte
+}
+
+func (e *encoderUint64) Encode(t reflect.Type, val reflect.Value) ([]byte, error) {
+	return e.fn(val.Interface().(uint64)), nil
+}
+
+func encoderMakerUint64(fn reflect.Value) Encoder {
+	return &encoderUint64{fn: fn.Interface().(func(uint64) []byte)}
+}
+
+type encoderUint64E struct {
+	fn func(uint64) ([]byte, error)
+}
+
+func (e *encoderUint64E) Encode(t reflect.Type, val reflect.Value) ([]byte, error) {
+	return e.fn(val.Interface().(uint64))
+}
+
+func encoderMakerUint64E(fn reflect.Value) Encoder {
+	return &encoderUint64E{fn: fn.Interface().(func(uint64) ([]byte, error))}
+}
+
+type encoderTUint64 struct {
+	fn func(reflect.Type, uint64) []byte
+}
+
+func (e *encoderTUint64) Encode(t reflect.Type, val reflect.Value) ([]byte, error) {
+	return e.fn(t, val.Interface().(uint64)), nil
+}
+
+func encoderMakerTUint64(fn reflect.Value) Encoder {
+	return &encoderTUint64{fn: fn.Interface().(func(reflect.Type, uint64) []byte)}
+}
+
+type encoderTUint64E struct {
+	fn func(reflect.Type, uint64) ([]byte, error)
+}
+
+func (e *encoderTUint64E) Encode(t reflect.Type, val reflect.Value) ([]byte, error) {
+	return e.fn(t, val.Interface().(uint64))
+}
+
+func encoderMakerTUint64E(fn reflect.Value) Encoder {
+	return &encoderTUint64E{fn: fn.Interface().(func(reflect.Type, uint64) ([]byte, error))}
+}
+
+type encoderFloat32 struct {
+	fn func(float32) []byte
+}
+
+func (e *encoderFloat32) Encode(t reflect.Type, val reflect.Value) ([]byte, error) {
+	return e.fn(val.Interface().(float32)), nil
+}
+
+func encoderMakerFloat32(fn reflect.Value) Encoder {
+	return &encoderFloat32{fn: fn.Interface().(func(float32) []byte)}
+}
+
+type encoderFloat32E struct {
+	fn func(float32) ([]byte, error)
+}
+
+func (e *encoderFloat32E) Encode(t reflect.Type, val reflect.Value) ([]byte, error) {
+	return e.fn(val.Interface().(float32))
+}
+
+func encoderMakerFloat32E(fn reflect.Value) Encoder {
+	return &encoderFloat32E{fn: fn.Interface().(func(float32) ([]byte, error))}
+}
+
+type encoderTFloat32 struct {
+	fn func(reflect.Type, float32) []byte
+}
+
+func (e *encoderTFloat32) Encode(t reflect.Type, val reflect.Value) ([]byte, error) {
+	return e.fn(t, val.Interface().(float32)), nil
+}
+
+func encoderMakerTFloat32(fn reflect.Value) Encoder {
+	return &encoderTFloat32{fn: fn.Interface().(func(reflect.Type, float32) []byte)}
+}
+
+type encoderTFloat32E struct {
+	fn func(reflect.Type, float32) ([]byte, error)
+}
+
+func (e *encoderTFloat32E) Encode(t reflect.Type, val reflect.Value) ([]byte, error) {
+	return e.fn(t, val.Interface().(float32))
+}
+
+func encoderMakerTFloat32E(fn reflect.Value) Encoder {
+	return &encoderTFloat32E{fn: fn.Interface().(func(reflect.Type, float32) ([]byte, error))}
+}
+
+type encoderFloat64 struct {
+	fn func(float64) []byte
+}
+
+func (e *encoderFloat64) Encode(t reflect.Type, val reflect.Value) ([]byte, error) {
+	return e.fn(val.Interface().(float64)), nil
+}
+
+func encoderMakerFloat64(fn reflect.Value) Encoder {
+	return &encoderFloat64{fn: fn.Interface().(func(float64) []byte)}
+}
+
+type encoderFloat64E struct {
+	fn func(float64) ([]byte, error)
+}
+
+func (e *encoderFloat64E) Encode(t reflect.Type, val reflect.Value) ([]byte, error) {
+	return e.fn(val.Interface().(float64))
+}
+
+func encoderMakerFloat64E(fn reflect.Value) Encoder {
+	return &encoderFloat64E{fn: fn.Interface().(func(float64) ([]byte, error))}
+}
+
+type encoderTFloat64 struct {
+	fn func(reflect.Type, float64) []byte
+}
+
+func (e *encoderTFloat64) Encode(t reflect.Type, val reflect.Value) ([]byte, error) {
+	return e.fn(t, val.Interface().(float64)), nil
+}
+
+func encoderMakerTFloat64(fn reflect.Value) Encoder {
+	return &encoderTFloat64{fn: fn.Interface().(func(reflect.Type, float64) []byte)}
+}
+
+type encoderTFloat64E struct {
+	fn func(reflect.Type, float64) ([]byte, error)
+}
+
+func (e *encoderTFloat64E) Encode(t reflect.Type, val reflect.Value) ([]byte, error) {
+	return e.fn(t, val.Interface().(float64))
+}
+
+func encoderMakerTFloat64E(fn reflect.Value) Encoder {
+	return &encoderTFloat64E{fn: fn.Interface().(func(reflect.Type, float64) ([]byte, error))}
+}
+
+type encoderTypex_T struct {
+	fn func(typex.T) []byte
+}
+
+func (e *encoderTypex_T) Encode(t reflect.Type, val reflect.Value) ([]byte, error) {
+	return e.fn(val.Interface().(typex.T)), nil
+}
+
+func encoderMakerTypex_T(fn reflect.Value) Encoder {
+	return &encoderTypex_T{fn: fn.Interface().(func(typex.T) []byte)}
+}
+
+type encoderTypex_TE struct {
+	fn func(typex.T) ([]byte, error)
+}
+
+func (e *encoderTypex_TE) Encode(t reflect.Type, val reflect.Value) ([]byte, error) {
+	return e.fn(val.Interface().(typex.T))
+}
+
+func encoderMakerTypex_TE(fn reflect.Value) Encoder {
+	return &encoderTypex_TE{fn: fn.Interface().(func(typex.T) ([]byte, error))}
+}
+
+type encoderTTypex_T struct {
+	fn func(reflect.Type, typex.T) []byte
+}
+
+func (e *encoderTTypex_T) Encode(t reflect.Type, val reflect.Value) ([]byte, error) {
+	return e.fn(t, val.Interface().(typex.T)), nil
+}
+
+func encoderMakerTTypex_T(fn reflect.Value) Encoder {
+	return &encoderTTypex_T{fn: fn.Interface().(func(reflect.Type, typex.T) []byte)}
+}
+
+type encoderTTypex_TE struct {
+	fn func(reflect.Type, typex.T) ([]byte, error)
+}
+
+func (e *encoderTTypex_TE) Encode(t reflect.Type, val reflect.Value) ([]byte, error) {
+	return e.fn(t, val.Interface().(typex.T))
+}
+
+func encoderMakerTTypex_TE(fn reflect.Value) Encoder {
+	return &encoderTTypex_TE{fn: fn.Interface().(func(reflect.Type, typex.T) ([]byte, error))}
+}
+
+type encoderTypex_U struct {
+	fn func(typex.U) []byte
+}
+
+func (e *encoderTypex_U) Encode(t reflect.Type, val reflect.Value) ([]byte, error) {
+	return e.fn(val.Interface().(typex.U)), nil
+}
+
+func encoderMakerTypex_U(fn reflect.Value) Encoder {
+	return &encoderTypex_U{fn: fn.Interface().(func(typex.U) []byte)}
+}
+
+type encoderTypex_UE struct {
+	fn func(typex.U) ([]byte, error)
+}
+
+func (e *encoderTypex_UE) Encode(t reflect.Type, val reflect.Value) ([]byte, error) {
+	return e.fn(val.Interface().(typex.U))
+}
+
+func encoderMakerTypex_UE(fn reflect.Value) Encoder {
+	return &encoderTypex_UE{fn: fn.Interface().(func(typex.U) ([]byte, error))}
+}
+
+type encoderTTypex_U struct {
+	fn func(reflect.Type, typex.U) []byte
+}
+
+func (e *encoderTTypex_U) Encode(t reflect.Type, val reflect.Value) ([]byte, error) {
+	return e.fn(t, val.Interface().(typex.U)), nil
+}
+
+func encoderMakerTTypex_U(fn reflect.Value) Encoder {
+	return &encoderTTypex_U{fn: fn.Interface().(func(reflect.Type, typex.U) []byte)}
+}
+
+type encoderTTypex_UE struct {
+	fn func(reflect.Type, typex.U) ([]byte, error)
+}
+
+func (e *encoderTTypex_UE) Encode(t reflect.Type, val reflect.Value) ([]byte, error) {
+	return e.fn(t, val.Interface().(typex.U))
+}
+
+func encoderMakerTTypex_UE(fn reflect.Value) Encoder {
+	return &encoderTTypex_UE{fn: fn.Interface().(func(reflect.Type, typex.U) ([]byte, error))}
+}
+
+type encoderTypex_V struct {
+	fn func(typex.V) []byte
+}
+
+func (e *encoderTypex_V) Encode(t reflect.Type, val reflect.Value) ([]byte, error) {
+	return e.fn(val.Interface().(typex.V)), nil
+}
+
+func encoderMakerTypex_V(fn reflect.Value) Encoder {
+	return &encoderTypex_V{fn: fn.Interface().(func(typex.V) []byte)}
+}
+
+type encoderTypex_VE struct {
+	fn func(typex.V) ([]byte, error)
+}
+
+func (e *encoderTypex_VE) Encode(t reflect.Type, val reflect.Value) ([]byte, error) {
+	return e.fn(val.Interface().(typex.V))
+}
+
+func encoderMakerTypex_VE(fn reflect.Value) Encoder {
+	return &encoderTypex_VE{fn: fn.Interface().(func(typex.V) ([]byte, error))}
+}
+
+type encoderTTypex_V struct {
+	fn func(reflect.Type, typex.V) []byte
+}
+
+func (e *encoderTTypex_V) Encode(t reflect.Type, val reflect.Value) ([]byte, error) {
+	return e.fn(t, val.Interface().(typex.V)), nil
+}
+
+func encoderMakerTTypex_V(fn reflect.Value) Encoder {
+	return &encoderTTypex_V{fn: fn.Interface().(func(reflect.Type, typex.V) []byte)}
+}
+
+type encoderTTypex_VE struct {
+	fn func(reflect.Type, typex.V) ([]byte, error)
+}
+
+func (e *encoderTTypex_VE) Encode(t reflect.Type, val reflect.Value) ([]byte, error) {
+	return e.fn(t, val.Interface().(typex.V))
+}
+
+func encoderMakerTTypex_VE(fn reflect.Value) Encoder {
+	return &encoderTTypex_VE{fn: fn.Interface().(func(reflect.Type, typex.V) ([]byte, error))}
+}
+
+type encoderTypex_W struct {
+	fn func(typex.W) []byte
+}
+
+func (e *encoderTypex_W) Encode(t reflect.Type, val reflect.Value) ([]byte, error) {
+	return e.fn(val.Interface().(typex.W)), nil
+}
+
+func encoderMakerTypex_W(fn reflect.Value) Encoder {
+	return &encoderTypex_W{fn: fn.Interface().(func(typex.W) []byte)}
+}
+
+type encoderTypex_WE struct {
+	fn func(typex.W) ([]byte, error)
+}
+
+func (e *encoderTypex_WE) Encode(t reflect.Type, val reflect.Value) ([]byte, error) {
+	return e.fn(val.Interface().(typex.W))
+}
+
+func encoderMakerTypex_WE(fn reflect.Value) Encoder {
+	return &encoderTypex_WE{fn: fn.Interface().(func(typex.W) ([]byte, error))}
+}
+
+type encoderTTypex_W struct {
+	fn func(reflect.Type, typex.W) []byte
+}
+
+func (e *encoderTTypex_W) Encode(t reflect.Type, val reflect.Value) ([]byte, error) {
+	return e.fn(t, val.Interface().(typex.W)), nil
+}
+
+func encoderMakerTTypex_W(fn reflect.Value) Encoder {
+	return &encoderTTypex_W{fn: fn.Interface().(func(reflect.Type, typex.W) []byte)}
+}
+
+type encoderTTypex_WE struct {
+	fn func(reflect.Type, typex.W) ([]byte, error)
+}
+
+func (e *encoderTTypex_WE) Encode(t reflect.Type, val reflect.Value) ([]byte, error) {
+	return e.fn(t, val.Interface().(typex.W))
+}
+
+func encoderMakerTTypex_WE(fn reflect.Value) Encoder {
+	return &encoderTTypex_WE{fn: fn.Interface().(func(reflect.Type, typex.W) ([]byte, error))}
+}
+
+type encoderTypex_X struct {
+	fn func(typex.X) []byte
+}
+
+func (e *encoderTypex_X) Encode(t reflect.Type, val reflect.Value) ([]byte, error) {
+	return e.fn(val.Interface().(typex.X)), nil
+}
+
+func encoderMakerTypex_X(fn reflect.Value) Encoder {
+	return &encoderTypex_X{fn: fn.Interface().(func(typex.X) []byte)}
+}
+
+type encoderTypex_XE struct {
+	fn func(typex.X) ([]byte, error)
+}
+
+func (e *encoderTypex_XE) Encode(t reflect.Type, val reflect.Value) ([]byte, error) {
+	return e.fn(val.Interface().(typex.X))
+}
+
+func encoderMakerTypex_XE(fn reflect.Value) Encoder {
+	return &encoderTypex_XE{fn: fn.Interface().(func(typex.X) ([]byte, error))}
+}
+
+type encoderTTypex_X struct {
+	fn func(reflect.Type, typex.X) []byte
+}
+
+func (e *encoderTTypex_X) Encode(t reflect.Type, val reflect.Value) ([]byte, error) {
+	return e.fn(t, val.Interface().(typex.X)), nil
+}
+
+func encoderMakerTTypex_X(fn reflect.Value) Encoder {
+	return &encoderTTypex_X{fn: fn.Interface().(func(reflect.Type, typex.X) []byte)}
+}
+
+type encoderTTypex_XE struct {
+	fn func(reflect.Type, typex.X) ([]byte, error)
+}
+
+func (e *encoderTTypex_XE) Encode(t reflect.Type, val reflect.Value) ([]byte, error) {
+	return e.fn(t, val.Interface().(typex.X))
+}
+
+func encoderMakerTTypex_XE(fn reflect.Value) Encoder {
+	return &encoderTTypex_XE{fn: fn.Interface().(func(reflect.Type, typex.X) ([]byte, error))}
+}
+
+type encoderTypex_Y struct {
+	fn func(typex.Y) []byte
+}
+
+func (e *encoderTypex_Y) Encode(t reflect.Type, val reflect.Value) ([]byte, error) {
+	return e.fn(val.Interface().(typex.Y)), nil
+}
+
+func encoderMakerTypex_Y(fn reflect.Value) Encoder {
+	return &encoderTypex_Y{fn: fn.Interface().(func(typex.Y) []byte)}
+}
+
+type encoderTypex_YE struct {
+	fn func(typex.Y) ([]byte, error)
+}
+
+func (e *encoderTypex_YE) Encode(t reflect.Type, val reflect.Value) ([]byte, error) {
+	return e.fn(val.Interface().(typex.Y))
+}
+
+func encoderMakerTypex_YE(fn reflect.Value) Encoder {
+	return &encoderTypex_YE{fn: fn.Interface().(func(typex.Y) ([]byte, error))}
+}
+
+type encoderTTypex_Y struct {
+	fn func(reflect.Type, typex.Y) []byte
+}
+
+func (e *encoderTTypex_Y) Encode(t reflect.Type, val reflect.Value) ([]byte, error) {
+	return e.fn(t, val.Interface().(typex.Y)), nil
+}
+
+func encoderMakerTTypex_Y(fn reflect.Value) Encoder {
+	return &encoderTTypex_Y{fn: fn.Interface().(func(reflect.Type, typex.Y) []byte)}
+}
+
+type encoderTTypex_YE struct {
+	fn func(reflect.Type, typex.Y) ([]byte, error)
+}
+
+func (e *encoderTTypex_YE) Encode(t reflect.Type, val reflect.Value) ([]byte, error) {
+	return e.fn(t, val.Interface().(typex.Y))
+}
+
+func encoderMakerTTypex_YE(fn reflect.Value) Encoder {
+	return &encoderTTypex_YE{fn: fn.Interface().(func(reflect.Type, typex.Y) ([]byte, error))}
+}
+
+type encoderTypex_Z struct {
+	fn func(typex.Z) []byte
+}
+
+func (e *encoderTypex_Z) Encode(t reflect.Type, val reflect.Value) ([]byte, error) {
+	return e.fn(val.Interface().(typex.Z)), nil
+}
+
+func encoderMakerTypex_Z(fn reflect.Value) Encoder {
+	return &encoderTypex_Z{fn: fn.Interface().(func(typex.Z) []byte)}
+}
+
+type encoderTypex_ZE struct {
+	fn func(typex.Z) ([]byte, error)
+}
+
+func (e *encoderTypex_ZE) Encode(t reflect.Type, val reflect.Value) ([]byte, error) {
+	return e.fn(val.Interface().(typex.Z))
+}
+
+func encoderMakerTypex_ZE(fn reflect.Value) Encoder {
+	return &encoderTypex_ZE{fn: fn.Interface().(func(typex.Z) ([]byte, error))}
+}
+
+type encoderTTypex_Z struct {
+	fn func(reflect.Type, typex.Z) []byte
+}
+
+func (e *encoderTTypex_Z) Encode(t reflect.Type, val reflect.Value) ([]byte, error) {
+	return e.fn(t, val.Interface().(typex.Z)), nil
+}
+
+func encoderMakerTTypex_Z(fn reflect.Value) Encoder {
+	return &encoderTTypex_Z{fn: fn.Interface().(func(reflect.Type, typex.Z) []byte)}
+}
+
+type encoderTTypex_ZE struct {
+	fn func(reflect.Type, typex.Z) ([]byte, error)
+}
+
+func (e *encoderTTypex_ZE) Encode(t reflect.Type, val reflect.Value) ([]byte, error) {
+	return e.fn(t, val.Interface().(typex.Z))
+}
+
+func encoderMakerTTypex_ZE(fn reflect.Value) Encoder {
+	return &encoderTTypex_ZE{fn: fn.Interface().(func(reflect.Type, typex.Z) ([]byte, error))}
+}
diff --git a/sdks/go/pkg/beam/core/runtime/exec/encoders.tmpl b/sdks/go/pkg/beam/core/runtime/exec/encoders.tmpl
new file mode 100644
index 00000000000..2796667d742
--- /dev/null
+++ b/sdks/go/pkg/beam/core/runtime/exec/encoders.tmpl
@@ -0,0 +1,81 @@
+// Licensed to the Apache Software Foundation (ASF) under one or more
+// contributor license agreements.  See the NOTICE file distributed with
+// this work for additional information regarding copyright ownership.
+// The ASF licenses this file to You under the Apache License, Version 2.0
+// (the "License"); you may not use this file except in compliance with
+// the License.  You may obtain a copy of the License at
+//
+//    http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package exec
+
+import (
+    "reflect"
+
+  	"github.com/apache/beam/sdks/go/pkg/beam/core/typex"
+)
+
+func init() {
+{{- range $x := .X}}
+    RegisterEncoder(reflect.TypeOf((*func ({{$x.Type}}) []byte)(nil)).Elem(), encoderMaker{{$x.Name}})
+    RegisterEncoder(reflect.TypeOf((*func ({{$x.Type}}) ([]byte, error))(nil)).Elem(), encoderMaker{{$x.Name}}E)
+    RegisterEncoder(reflect.TypeOf((*func (reflect.Type, {{$x.Type}}) []byte)(nil)).Elem(), encoderMakerT{{$x.Name}})
+    RegisterEncoder(reflect.TypeOf((*func (reflect.Type, {{$x.Type}}) ([]byte, error))(nil)).Elem(), encoderMakerT{{$x.Name}}E)
+{{- end}}
+}
+
+{{range $x := .X}}
+type encoder{{$x.Name}} struct {
+    fn func ({{$x.Type}}) []byte
+}
+
+func (e *encoder{{$x.Name}}) Encode(t reflect.Type, val reflect.Value) ([]byte, error) {
+    return e.fn(val.Interface().({{$x.Type}})), nil
+}
+
+func encoderMaker{{$x.Name}}(fn reflect.Value) Encoder {
+    return &encoder{{$x.Name}}{fn: fn.Interface().(func ({{$x.Type}}) []byte)}
+}
+
+type encoder{{$x.Name}}E struct {
+    fn func ({{$x.Type}}) ([]byte, error)
+}
+
+func (e *encoder{{$x.Name}}E) Encode(t reflect.Type, val reflect.Value) ([]byte, error) {
+    return e.fn(val.Interface().({{$x.Type}}))
+}
+
+func encoderMaker{{$x.Name}}E(fn reflect.Value) Encoder {
+    return &encoder{{$x.Name}}E{fn: fn.Interface().(func ({{$x.Type}}) ([]byte, error))}
+}
+
+type encoderT{{$x.Name}} struct {
+    fn func (reflect.Type, {{$x.Type}}) []byte
+}
+
+func (e *encoderT{{$x.Name}}) Encode(t reflect.Type, val reflect.Value) ([]byte, error) {
+    return e.fn(t, val.Interface().({{$x.Type}})), nil
+}
+
+func encoderMakerT{{$x.Name}}(fn reflect.Value) Encoder {
+    return &encoderT{{$x.Name}}{fn: fn.Interface().(func (reflect.Type, {{$x.Type}}) []byte)}
+}
+
+type encoderT{{$x.Name}}E struct {
+    fn func (reflect.Type, {{$x.Type}}) ([]byte, error)
+}
+
+func (e *encoderT{{$x.Name}}E) Encode(t reflect.Type, val reflect.Value) ([]byte, error) {
+    return e.fn(t, val.Interface().({{$x.Type}}))
+}
+
+func encoderMakerT{{$x.Name}}E(fn reflect.Value) Encoder {
+    return &encoderT{{$x.Name}}E{fn: fn.Interface().(func (reflect.Type, {{$x.Type}}) ([]byte, error))}
+}
+{{end}}
diff --git a/sdks/go/pkg/beam/core/runtime/exec/fn.go b/sdks/go/pkg/beam/core/runtime/exec/fn.go
index 1e5ce6b3f4e..15c0e287707 100644
--- a/sdks/go/pkg/beam/core/runtime/exec/fn.go
+++ b/sdks/go/pkg/beam/core/runtime/exec/fn.go
@@ -18,7 +18,6 @@ package exec
 import (
 	"context"
 	"fmt"
-	"io"
 	"reflect"
 
 	"github.com/apache/beam/sdks/go/pkg/beam/core/funcx"
@@ -118,7 +117,7 @@ func Invoke(ctx context.Context, fn *funcx.Fn, opt *MainInput, extra ...reflect.
 	return nil, nil
 }
 
-func makeSideInputs(fn *funcx.Fn, in []*graph.Inbound, side []ReStream) ([]ReusableSideInput, error) {
+func makeSideInputs(fn *funcx.Fn, in []*graph.Inbound, side []ReStream) ([]ReusableInput, error) {
 	if len(side) == 0 {
 		return nil, nil // ok: no side input
 	}
@@ -134,7 +133,7 @@ func makeSideInputs(fn *funcx.Fn, in []*graph.Inbound, side []ReStream) ([]Reusa
 	// The side input are last of the above params, so we can compute the offset easily.
 	offset := len(param) - len(side)
 
-	var ret []ReusableSideInput
+	var ret []ReusableInput
 	for i := 0; i < len(side); i++ {
 		s, err := makeSideInput(in[i+1].Kind, fn.Param[i+offset].T, side[i])
 		if err != nil {
@@ -168,7 +167,7 @@ func makeEmitters(fn *funcx.Fn, nodes []Node) ([]ReusableEmitter, error) {
 }
 
 // makeSideInput returns a reusable side input of the given kind and type.
-func makeSideInput(kind graph.InputKind, t reflect.Type, values ReStream) (ReusableSideInput, error) {
+func makeSideInput(kind graph.InputKind, t reflect.Type, values ReStream) (ReusableInput, error) {
 	switch kind {
 	case graph.Singleton:
 		elms, err := ReadAll(values.Open())
@@ -201,134 +200,3 @@ func makeSideInput(kind graph.InputKind, t reflect.Type, values ReStream) (Reusa
 		panic(fmt.Sprintf("Unexpected side input kind: %v", kind))
 	}
 }
-
-// TODO(herohde) 4/26/2017: SideInput representation? We want it to be amenable
-// to the State API. For now, just use Stream.
-
-// TODO(BEAM-3303): need to include windowing as well when resetting values.
-
-// ReusableSideInput is a resettable value, notably used to unwind iterators cheaply
-// and cache materialized side input across invocations.
-type ReusableSideInput interface {
-	// Init initializes the value before use.
-	Init() error
-	// Value returns the side input value.
-	Value() reflect.Value
-	// Reset resets the value after use.
-	Reset() error
-}
-
-type reIterValue struct {
-	t  reflect.Type
-	s  ReStream
-	fn reflect.Value
-}
-
-func makeReIter(t reflect.Type, s ReStream) ReusableSideInput {
-	if !funcx.IsReIter(t) {
-		panic(fmt.Sprintf("illegal re-iter type: %v", t))
-	}
-
-	ret := &reIterValue{t: t, s: s}
-	ret.fn = reflect.MakeFunc(t, ret.invoke)
-	return ret
-}
-
-func (v *reIterValue) Init() error {
-	return nil
-}
-
-func (v *reIterValue) Value() reflect.Value {
-	return v.fn
-}
-
-func (v *reIterValue) Reset() error {
-	return nil
-}
-
-func (v *reIterValue) invoke(args []reflect.Value) []reflect.Value {
-	iter := makeIter(v.t.Out(0), v.s)
-	iter.Init()
-	return []reflect.Value{iter.Value()}
-}
-
-type iterValue struct {
-	s     ReStream
-	fn    reflect.Value
-	types []reflect.Type
-
-	// cur is the "current" stream, if any.
-	cur Stream
-}
-
-func makeIter(t reflect.Type, s ReStream) ReusableSideInput {
-	types, ok := funcx.UnfoldIter(t)
-	if !ok {
-		panic(fmt.Sprintf("illegal iter type: %v", t))
-	}
-
-	ret := &iterValue{types: types, s: s}
-	ret.fn = reflect.MakeFunc(t, ret.invoke)
-	return ret
-}
-
-func (v *iterValue) Init() error {
-	v.cur = v.s.Open()
-	return nil
-}
-
-func (v *iterValue) Value() reflect.Value {
-	return v.fn
-}
-
-func (v *iterValue) Reset() error {
-	if err := v.cur.Close(); err != nil {
-		return err
-	}
-	v.cur = nil
-	return nil
-}
-
-func (v *iterValue) invoke(args []reflect.Value) []reflect.Value {
-	elm, err := v.cur.Read()
-	if err != nil {
-		if err == io.EOF {
-			return []reflect.Value{reflect.ValueOf(false)}
-		}
-		panic(fmt.Sprintf("broken stream: %v", err))
-	}
-
-	// We expect 1-3 out parameters: func (*int, *string) bool.
-
-	isKey := true
-	for i, t := range v.types {
-		var v reflect.Value
-		switch {
-		case t == typex.EventTimeType:
-			v = reflect.ValueOf(elm.Timestamp)
-		case isKey:
-			v = Convert(elm.Elm, t)
-			isKey = false
-		default:
-			v = Convert(elm.Elm2, t)
-		}
-		args[i].Elem().Set(v)
-	}
-	return []reflect.Value{reflect.ValueOf(true)}
-}
-
-type fixedValue struct {
-	val reflect.Value
-}
-
-func (v *fixedValue) Init() error {
-	return nil
-}
-
-func (v *fixedValue) Value() reflect.Value {
-	return v.val
-}
-
-func (v *fixedValue) Reset() error {
-	return nil
-}
diff --git a/sdks/go/pkg/beam/core/runtime/exec/fullvalue_test.go b/sdks/go/pkg/beam/core/runtime/exec/fullvalue_test.go
index b82656a97c2..f93557cec57 100644
--- a/sdks/go/pkg/beam/core/runtime/exec/fullvalue_test.go
+++ b/sdks/go/pkg/beam/core/runtime/exec/fullvalue_test.go
@@ -15,7 +15,9 @@
 
 package exec
 
-import "reflect"
+import (
+	"reflect"
+)
 
 func makeValue(v interface{}) FullValue {
 	return FullValue{Elm: reflect.ValueOf(v)}
diff --git a/sdks/go/pkg/beam/core/runtime/exec/input.go b/sdks/go/pkg/beam/core/runtime/exec/input.go
new file mode 100644
index 00000000000..b18db6a0ba6
--- /dev/null
+++ b/sdks/go/pkg/beam/core/runtime/exec/input.go
@@ -0,0 +1,190 @@
+// Licensed to the Apache Software Foundation (ASF) under one or more
+// contributor license agreements.  See the NOTICE file distributed with
+// this work for additional information regarding copyright ownership.
+// The ASF licenses this file to You under the Apache License, Version 2.0
+// (the "License"); you may not use this file except in compliance with
+// the License.  You may obtain a copy of the License at
+//
+//    http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package exec
+
+import (
+	"context"
+	"fmt"
+	"io"
+	"reflect"
+	"sync"
+
+	"github.com/apache/beam/sdks/go/pkg/beam/core/funcx"
+	"github.com/apache/beam/sdks/go/pkg/beam/core/typex"
+	"github.com/apache/beam/sdks/go/pkg/beam/log"
+)
+
+//go:generate specialize --input=inputs.tmpl --x=data,universals --y=data,universals
+
+// TODO(herohde) 4/26/2017: SideInput representation? We want it to be amenable
+// to the State API. For now, just use Stream.
+
+// TODO(BEAM-3303): need to include windowing as well when resetting values.
+
+// ReusableInput is a resettable value, notably used to unwind iterators cheaply
+// and cache materialized side input across invocations.
+type ReusableInput interface {
+	// Init initializes the value before use.
+	Init() error
+	// Value returns the side input value.
+	Value() reflect.Value
+	// Reset resets the value after use.
+	Reset() error
+}
+
+var (
+	inputs   = make(map[string]func(ReStream) ReusableInput)
+	inputsMu sync.Mutex
+)
+
+// RegisterInput registers an input handler for the given type, such as "func(*int)bool". If
+// multiple input handlers are registered for the same type, the last registration wins.
+func RegisterInput(t reflect.Type, maker func(ReStream) ReusableInput) {
+	inputsMu.Lock()
+	defer inputsMu.Unlock()
+
+	key := t.String()
+	if _, exists := inputs[key]; exists {
+		log.Warnf(context.Background(), "Input for %v already registered. Overwriting.", key)
+	}
+	inputs[key] = maker
+}
+
+type reIterValue struct {
+	t  reflect.Type
+	s  ReStream
+	fn reflect.Value
+}
+
+func makeReIter(t reflect.Type, s ReStream) ReusableInput {
+	if !funcx.IsReIter(t) {
+		panic(fmt.Sprintf("illegal re-iter type: %v", t))
+	}
+
+	ret := &reIterValue{t: t, s: s}
+	ret.fn = reflect.MakeFunc(t, ret.invoke)
+	return ret
+}
+
+func (v *reIterValue) Init() error {
+	return nil
+}
+
+func (v *reIterValue) Value() reflect.Value {
+	return v.fn
+}
+
+func (v *reIterValue) Reset() error {
+	return nil
+}
+
+func (v *reIterValue) invoke(args []reflect.Value) []reflect.Value {
+	iter := makeIter(v.t.Out(0), v.s)
+	iter.Init()
+	return []reflect.Value{iter.Value()}
+}
+
+type iterValue struct {
+	s     ReStream
+	fn    reflect.Value
+	types []reflect.Type
+
+	// cur is the "current" stream, if any.
+	cur Stream
+}
+
+func makeIter(t reflect.Type, s ReStream) ReusableInput {
+	inputsMu.Lock()
+	maker, exists := inputs[t.String()]
+	inputsMu.Unlock()
+
+	if exists {
+		return maker(s)
+	}
+
+	// If no specialized implementation is available, we use the (slower)
+	// reflection-based one.
+
+	types, ok := funcx.UnfoldIter(t)
+	if !ok {
+		panic(fmt.Sprintf("illegal iter type: %v", t))
+	}
+
+	ret := &iterValue{types: types, s: s}
+	ret.fn = reflect.MakeFunc(t, ret.invoke)
+	return ret
+}
+
+func (v *iterValue) Init() error {
+	v.cur = v.s.Open()
+	return nil
+}
+
+func (v *iterValue) Value() reflect.Value {
+	return v.fn
+}
+
+func (v *iterValue) Reset() error {
+	if err := v.cur.Close(); err != nil {
+		return err
+	}
+	v.cur = nil
+	return nil
+}
+
+func (v *iterValue) invoke(args []reflect.Value) []reflect.Value {
+	elm, err := v.cur.Read()
+	if err != nil {
+		if err == io.EOF {
+			return []reflect.Value{reflect.ValueOf(false)}
+		}
+		panic(fmt.Sprintf("broken stream: %v", err))
+	}
+
+	// We expect 1-3 out parameters: func (*int, *string) bool.
+
+	isKey := true
+	for i, t := range v.types {
+		var v reflect.Value
+		switch {
+		case t == typex.EventTimeType:
+			v = reflect.ValueOf(elm.Timestamp)
+		case isKey:
+			v = Convert(elm.Elm, t)
+			isKey = false
+		default:
+			v = Convert(elm.Elm2, t)
+		}
+		args[i].Elem().Set(v)
+	}
+	return []reflect.Value{reflect.ValueOf(true)}
+}
+
+type fixedValue struct {
+	val reflect.Value
+}
+
+func (v *fixedValue) Init() error {
+	return nil
+}
+
+func (v *fixedValue) Value() reflect.Value {
+	return v.val
+}
+
+func (v *fixedValue) Reset() error {
+	return nil
+}
diff --git a/sdks/go/pkg/beam/core/runtime/exec/inputs.go b/sdks/go/pkg/beam/core/runtime/exec/inputs.go
new file mode 100644
index 00000000000..c9759e0c42d
--- /dev/null
+++ b/sdks/go/pkg/beam/core/runtime/exec/inputs.go
@@ -0,0 +1,21768 @@
+// File generated by specialize. Do not edit.
+
+// Licensed to the Apache Software Foundation (ASF) under one or more
+// contributor license agreements.  See the NOTICE file distributed with
+// this work for additional information regarding copyright ownership.
+// The ASF licenses this file to You under the Apache License, Version 2.0
+// (the "License"); you may not use this file except in compliance with
+// the License.  You may obtain a copy of the License at
+//
+//    http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package exec
+
+import (
+	"fmt"
+	"io"
+	"reflect"
+
+	"github.com/apache/beam/sdks/go/pkg/beam/core/typex"
+)
+
+func init() {
+	RegisterInput(reflect.TypeOf((*func(*[]byte) bool)(nil)).Elem(), iterMakerByteSlice)
+	RegisterInput(reflect.TypeOf((*func(*typex.EventTime, *[]byte) bool)(nil)).Elem(), iterMakerETByteSlice)
+	RegisterInput(reflect.TypeOf((*func(*[]byte, *[]byte) bool)(nil)).Elem(), iterMakerByteSliceByteSlice)
+	RegisterInput(reflect.TypeOf((*func(*typex.EventTime, *[]byte, *[]byte) bool)(nil)).Elem(), iterMakerETByteSliceByteSlice)
+	RegisterInput(reflect.TypeOf((*func(*[]byte, *bool) bool)(nil)).Elem(), iterMakerByteSliceBool)
+	RegisterInput(reflect.TypeOf((*func(*typex.EventTime, *[]byte, *bool) bool)(nil)).Elem(), iterMakerETByteSliceBool)
+	RegisterInput(reflect.TypeOf((*func(*[]byte, *string) bool)(nil)).Elem(), iterMakerByteSliceString)
+	RegisterInput(reflect.TypeOf((*func(*typex.EventTime, *[]byte, *string) bool)(nil)).Elem(), iterMakerETByteSliceString)
+	RegisterInput(reflect.TypeOf((*func(*[]byte, *int) bool)(nil)).Elem(), iterMakerByteSliceInt)
+	RegisterInput(reflect.TypeOf((*func(*typex.EventTime, *[]byte, *int) bool)(nil)).Elem(), iterMakerETByteSliceInt)
+	RegisterInput(reflect.TypeOf((*func(*[]byte, *int8) bool)(nil)).Elem(), iterMakerByteSliceInt8)
+	RegisterInput(reflect.TypeOf((*func(*typex.EventTime, *[]byte, *int8) bool)(nil)).Elem(), iterMakerETByteSliceInt8)
+	RegisterInput(reflect.TypeOf((*func(*[]byte, *int16) bool)(nil)).Elem(), iterMakerByteSliceInt16)
+	RegisterInput(reflect.TypeOf((*func(*typex.EventTime, *[]byte, *int16) bool)(nil)).Elem(), iterMakerETByteSliceInt16)
+	RegisterInput(reflect.TypeOf((*func(*[]byte, *int32) bool)(nil)).Elem(), iterMakerByteSliceInt32)
+	RegisterInput(reflect.TypeOf((*func(*typex.EventTime, *[]byte, *int32) bool)(nil)).Elem(), iterMakerETByteSliceInt32)
+	RegisterInput(reflect.TypeOf((*func(*[]byte, *int64) bool)(nil)).Elem(), iterMakerByteSliceInt64)
+	RegisterInput(reflect.TypeOf((*func(*typex.EventTime, *[]byte, *int64) bool)(nil)).Elem(), iterMakerETByteSliceInt64)
+	RegisterInput(reflect.TypeOf((*func(*[]byte, *uint) bool)(nil)).Elem(), iterMakerByteSliceUint)
+	RegisterInput(reflect.TypeOf((*func(*typex.EventTime, *[]byte, *uint) bool)(nil)).Elem(), iterMakerETByteSliceUint)
+	RegisterInput(reflect.TypeOf((*func(*[]byte, *uint8) bool)(nil)).Elem(), iterMakerByteSliceUint8)
+	RegisterInput(reflect.TypeOf((*func(*typex.EventTime, *[]byte, *uint8) bool)(nil)).Elem(), iterMakerETByteSliceUint8)
+	RegisterInput(reflect.TypeOf((*func(*[]byte, *uint16) bool)(nil)).Elem(), iterMakerByteSliceUint16)
+	RegisterInput(reflect.TypeOf((*func(*typex.EventTime, *[]byte, *uint16) bool)(nil)).Elem(), iterMakerETByteSliceUint16)
+	RegisterInput(reflect.TypeOf((*func(*[]byte, *uint32) bool)(nil)).Elem(), iterMakerByteSliceUint32)
+	RegisterInput(reflect.TypeOf((*func(*typex.EventTime, *[]byte, *uint32) bool)(nil)).Elem(), iterMakerETByteSliceUint32)
+	RegisterInput(reflect.TypeOf((*func(*[]byte, *uint64) bool)(nil)).Elem(), iterMakerByteSliceUint64)
+	RegisterInput(reflect.TypeOf((*func(*typex.EventTime, *[]byte, *uint64) bool)(nil)).Elem(), iterMakerETByteSliceUint64)
+	RegisterInput(reflect.TypeOf((*func(*[]byte, *float32) bool)(nil)).Elem(), iterMakerByteSliceFloat32)
+	RegisterInput(reflect.TypeOf((*func(*typex.EventTime, *[]byte, *float32) bool)(nil)).Elem(), iterMakerETByteSliceFloat32)
+	RegisterInput(reflect.TypeOf((*func(*[]byte, *float64) bool)(nil)).Elem(), iterMakerByteSliceFloat64)
+	RegisterInput(reflect.TypeOf((*func(*typex.EventTime, *[]byte, *float64) bool)(nil)).Elem(), iterMakerETByteSliceFloat64)
+	RegisterInput(reflect.TypeOf((*func(*[]byte, *typex.T) bool)(nil)).Elem(), iterMakerByteSliceTypex_T)
+	RegisterInput(reflect.TypeOf((*func(*typex.EventTime, *[]byte, *typex.T) bool)(nil)).Elem(), iterMakerETByteSliceTypex_T)
+	RegisterInput(reflect.TypeOf((*func(*[]byte, *typex.U) bool)(nil)).Elem(), iterMakerByteSliceTypex_U)
+	RegisterInput(reflect.TypeOf((*func(*typex.EventTime, *[]byte, *typex.U) bool)(nil)).Elem(), iterMakerETByteSliceTypex_U)
+	RegisterInput(reflect.TypeOf((*func(*[]byte, *typex.V) bool)(nil)).Elem(), iterMakerByteSliceTypex_V)
+	RegisterInput(reflect.TypeOf((*func(*typex.EventTime, *[]byte, *typex.V) bool)(nil)).Elem(), iterMakerETByteSliceTypex_V)
+	RegisterInput(reflect.TypeOf((*func(*[]byte, *typex.W) bool)(nil)).Elem(), iterMakerByteSliceTypex_W)
+	RegisterInput(reflect.TypeOf((*func(*typex.EventTime, *[]byte, *typex.W) bool)(nil)).Elem(), iterMakerETByteSliceTypex_W)
+	RegisterInput(reflect.TypeOf((*func(*[]byte, *typex.X) bool)(nil)).Elem(), iterMakerByteSliceTypex_X)
+	RegisterInput(reflect.TypeOf((*func(*typex.EventTime, *[]byte, *typex.X) bool)(nil)).Elem(), iterMakerETByteSliceTypex_X)
+	RegisterInput(reflect.TypeOf((*func(*[]byte, *typex.Y) bool)(nil)).Elem(), iterMakerByteSliceTypex_Y)
+	RegisterInput(reflect.TypeOf((*func(*typex.EventTime, *[]byte, *typex.Y) bool)(nil)).Elem(), iterMakerETByteSliceTypex_Y)
+	RegisterInput(reflect.TypeOf((*func(*[]byte, *typex.Z) bool)(nil)).Elem(), iterMakerByteSliceTypex_Z)
+	RegisterInput(reflect.TypeOf((*func(*typex.EventTime, *[]byte, *typex.Z) bool)(nil)).Elem(), iterMakerETByteSliceTypex_Z)
+	RegisterInput(reflect.TypeOf((*func(*bool) bool)(nil)).Elem(), iterMakerBool)
+	RegisterInput(reflect.TypeOf((*func(*typex.EventTime, *bool) bool)(nil)).Elem(), iterMakerETBool)
+	RegisterInput(reflect.TypeOf((*func(*bool, *[]byte) bool)(nil)).Elem(), iterMakerBoolByteSlice)
+	RegisterInput(reflect.TypeOf((*func(*typex.EventTime, *bool, *[]byte) bool)(nil)).Elem(), iterMakerETBoolByteSlice)
+	RegisterInput(reflect.TypeOf((*func(*bool, *bool) bool)(nil)).Elem(), iterMakerBoolBool)
+	RegisterInput(reflect.TypeOf((*func(*typex.EventTime, *bool, *bool) bool)(nil)).Elem(), iterMakerETBoolBool)
+	RegisterInput(reflect.TypeOf((*func(*bool, *string) bool)(nil)).Elem(), iterMakerBoolString)
+	RegisterInput(reflect.TypeOf((*func(*typex.EventTime, *bool, *string) bool)(nil)).Elem(), iterMakerETBoolString)
+	RegisterInput(reflect.TypeOf((*func(*bool, *int) bool)(nil)).Elem(), iterMakerBoolInt)
+	RegisterInput(reflect.TypeOf((*func(*typex.EventTime, *bool, *int) bool)(nil)).Elem(), iterMakerETBoolInt)
+	RegisterInput(reflect.TypeOf((*func(*bool, *int8) bool)(nil)).Elem(), iterMakerBoolInt8)
+	RegisterInput(reflect.TypeOf((*func(*typex.EventTime, *bool, *int8) bool)(nil)).Elem(), iterMakerETBoolInt8)
+	RegisterInput(reflect.TypeOf((*func(*bool, *int16) bool)(nil)).Elem(), iterMakerBoolInt16)
+	RegisterInput(reflect.TypeOf((*func(*typex.EventTime, *bool, *int16) bool)(nil)).Elem(), iterMakerETBoolInt16)
+	RegisterInput(reflect.TypeOf((*func(*bool, *int32) bool)(nil)).Elem(), iterMakerBoolInt32)
+	RegisterInput(reflect.TypeOf((*func(*typex.EventTime, *bool, *int32) bool)(nil)).Elem(), iterMakerETBoolInt32)
+	RegisterInput(reflect.TypeOf((*func(*bool, *int64) bool)(nil)).Elem(), iterMakerBoolInt64)
+	RegisterInput(reflect.TypeOf((*func(*typex.EventTime, *bool, *int64) bool)(nil)).Elem(), iterMakerETBoolInt64)
+	RegisterInput(reflect.TypeOf((*func(*bool, *uint) bool)(nil)).Elem(), iterMakerBoolUint)
+	RegisterInput(reflect.TypeOf((*func(*typex.EventTime, *bool, *uint) bool)(nil)).Elem(), iterMakerETBoolUint)
+	RegisterInput(reflect.TypeOf((*func(*bool, *uint8) bool)(nil)).Elem(), iterMakerBoolUint8)
+	RegisterInput(reflect.TypeOf((*func(*typex.EventTime, *bool, *uint8) bool)(nil)).Elem(), iterMakerETBoolUint8)
+	RegisterInput(reflect.TypeOf((*func(*bool, *uint16) bool)(nil)).Elem(), iterMakerBoolUint16)
+	RegisterInput(reflect.TypeOf((*func(*typex.EventTime, *bool, *uint16) bool)(nil)).Elem(), iterMakerETBoolUint16)
+	RegisterInput(reflect.TypeOf((*func(*bool, *uint32) bool)(nil)).Elem(), iterMakerBoolUint32)
+	RegisterInput(reflect.TypeOf((*func(*typex.EventTime, *bool, *uint32) bool)(nil)).Elem(), iterMakerETBoolUint32)
+	RegisterInput(reflect.TypeOf((*func(*bool, *uint64) bool)(nil)).Elem(), iterMakerBoolUint64)
+	RegisterInput(reflect.TypeOf((*func(*typex.EventTime, *bool, *uint64) bool)(nil)).Elem(), iterMakerETBoolUint64)
+	RegisterInput(reflect.TypeOf((*func(*bool, *float32) bool)(nil)).Elem(), iterMakerBoolFloat32)
+	RegisterInput(reflect.TypeOf((*func(*typex.EventTime, *bool, *float32) bool)(nil)).Elem(), iterMakerETBoolFloat32)
+	RegisterInput(reflect.TypeOf((*func(*bool, *float64) bool)(nil)).Elem(), iterMakerBoolFloat64)
+	RegisterInput(reflect.TypeOf((*func(*typex.EventTime, *bool, *float64) bool)(nil)).Elem(), iterMakerETBoolFloat64)
+	RegisterInput(reflect.TypeOf((*func(*bool, *typex.T) bool)(nil)).Elem(), iterMakerBoolTypex_T)
+	RegisterInput(reflect.TypeOf((*func(*typex.EventTime, *bool, *typex.T) bool)(nil)).Elem(), iterMakerETBoolTypex_T)
+	RegisterInput(reflect.TypeOf((*func(*bool, *typex.U) bool)(nil)).Elem(), iterMakerBoolTypex_U)
+	RegisterInput(reflect.TypeOf((*func(*typex.EventTime, *bool, *typex.U) bool)(nil)).Elem(), iterMakerETBoolTypex_U)
+	RegisterInput(reflect.TypeOf((*func(*bool, *typex.V) bool)(nil)).Elem(), iterMakerBoolTypex_V)
+	RegisterInput(reflect.TypeOf((*func(*typex.EventTime, *bool, *typex.V) bool)(nil)).Elem(), iterMakerETBoolTypex_V)
+	RegisterInput(reflect.TypeOf((*func(*bool, *typex.W) bool)(nil)).Elem(), iterMakerBoolTypex_W)
+	RegisterInput(reflect.TypeOf((*func(*typex.EventTime, *bool, *typex.W) bool)(nil)).Elem(), iterMakerETBoolTypex_W)
+	RegisterInput(reflect.TypeOf((*func(*bool, *typex.X) bool)(nil)).Elem(), iterMakerBoolTypex_X)
+	RegisterInput(reflect.TypeOf((*func(*typex.EventTime, *bool, *typex.X) bool)(nil)).Elem(), iterMakerETBoolTypex_X)
+	RegisterInput(reflect.TypeOf((*func(*bool, *typex.Y) bool)(nil)).Elem(), iterMakerBoolTypex_Y)
+	RegisterInput(reflect.TypeOf((*func(*typex.EventTime, *bool, *typex.Y) bool)(nil)).Elem(), iterMakerETBoolTypex_Y)
+	RegisterInput(reflect.TypeOf((*func(*bool, *typex.Z) bool)(nil)).Elem(), iterMakerBoolTypex_Z)
+	RegisterInput(reflect.TypeOf((*func(*typex.EventTime, *bool, *typex.Z) bool)(nil)).Elem(), iterMakerETBoolTypex_Z)
+	RegisterInput(reflect.TypeOf((*func(*string) bool)(nil)).Elem(), iterMakerString)
+	RegisterInput(reflect.TypeOf((*func(*typex.EventTime, *string) bool)(nil)).Elem(), iterMakerETString)
+	RegisterInput(reflect.TypeOf((*func(*string, *[]byte) bool)(nil)).Elem(), iterMakerStringByteSlice)
+	RegisterInput(reflect.TypeOf((*func(*typex.EventTime, *string, *[]byte) bool)(nil)).Elem(), iterMakerETStringByteSlice)
+	RegisterInput(reflect.TypeOf((*func(*string, *bool) bool)(nil)).Elem(), iterMakerStringBool)
+	RegisterInput(reflect.TypeOf((*func(*typex.EventTime, *string, *bool) bool)(nil)).Elem(), iterMakerETStringBool)
+	RegisterInput(reflect.TypeOf((*func(*string, *string) bool)(nil)).Elem(), iterMakerStringString)
+	RegisterInput(reflect.TypeOf((*func(*typex.EventTime, *string, *string) bool)(nil)).Elem(), iterMakerETStringString)
+	RegisterInput(reflect.TypeOf((*func(*string, *int) bool)(nil)).Elem(), iterMakerStringInt)
+	RegisterInput(reflect.TypeOf((*func(*typex.EventTime, *string, *int) bool)(nil)).Elem(), iterMakerETStringInt)
+	RegisterInput(reflect.TypeOf((*func(*string, *int8) bool)(nil)).Elem(), iterMakerStringInt8)
+	RegisterInput(reflect.TypeOf((*func(*typex.EventTime, *string, *int8) bool)(nil)).Elem(), iterMakerETStringInt8)
+	RegisterInput(reflect.TypeOf((*func(*string, *int16) bool)(nil)).Elem(), iterMakerStringInt16)
+	RegisterInput(reflect.TypeOf((*func(*typex.EventTime, *string, *int16) bool)(nil)).Elem(), iterMakerETStringInt16)
+	RegisterInput(reflect.TypeOf((*func(*string, *int32) bool)(nil)).Elem(), iterMakerStringInt32)
+	RegisterInput(reflect.TypeOf((*func(*typex.EventTime, *string, *int32) bool)(nil)).Elem(), iterMakerETStringInt32)
+	RegisterInput(reflect.TypeOf((*func(*string, *int64) bool)(nil)).Elem(), iterMakerStringInt64)
+	RegisterInput(reflect.TypeOf((*func(*typex.EventTime, *string, *int64) bool)(nil)).Elem(), iterMakerETStringInt64)
+	RegisterInput(reflect.TypeOf((*func(*string, *uint) bool)(nil)).Elem(), iterMakerStringUint)
+	RegisterInput(reflect.TypeOf((*func(*typex.EventTime, *string, *uint) bool)(nil)).Elem(), iterMakerETStringUint)
+	RegisterInput(reflect.TypeOf((*func(*string, *uint8) bool)(nil)).Elem(), iterMakerStringUint8)
+	RegisterInput(reflect.TypeOf((*func(*typex.EventTime, *string, *uint8) bool)(nil)).Elem(), iterMakerETStringUint8)
+	RegisterInput(reflect.TypeOf((*func(*string, *uint16) bool)(nil)).Elem(), iterMakerStringUint16)
+	RegisterInput(reflect.TypeOf((*func(*typex.EventTime, *string, *uint16) bool)(nil)).Elem(), iterMakerETStringUint16)
+	RegisterInput(reflect.TypeOf((*func(*string, *uint32) bool)(nil)).Elem(), iterMakerStringUint32)
+	RegisterInput(reflect.TypeOf((*func(*typex.EventTime, *string, *uint32) bool)(nil)).Elem(), iterMakerETStringUint32)
+	RegisterInput(reflect.TypeOf((*func(*string, *uint64) bool)(nil)).Elem(), iterMakerStringUint64)
+	RegisterInput(reflect.TypeOf((*func(*typex.EventTime, *string, *uint64) bool)(nil)).Elem(), iterMakerETStringUint64)
+	RegisterInput(reflect.TypeOf((*func(*string, *float32) bool)(nil)).Elem(), iterMakerStringFloat32)
+	RegisterInput(reflect.TypeOf((*func(*typex.EventTime, *string, *float32) bool)(nil)).Elem(), iterMakerETStringFloat32)
+	RegisterInput(reflect.TypeOf((*func(*string, *float64) bool)(nil)).Elem(), iterMakerStringFloat64)
+	RegisterInput(reflect.TypeOf((*func(*typex.EventTime, *string, *float64) bool)(nil)).Elem(), iterMakerETStringFloat64)
+	RegisterInput(reflect.TypeOf((*func(*string, *typex.T) bool)(nil)).Elem(), iterMakerStringTypex_T)
+	RegisterInput(reflect.TypeOf((*func(*typex.EventTime, *string, *typex.T) bool)(nil)).Elem(), iterMakerETStringTypex_T)
+	RegisterInput(reflect.TypeOf((*func(*string, *typex.U) bool)(nil)).Elem(), iterMakerStringTypex_U)
+	RegisterInput(reflect.TypeOf((*func(*typex.EventTime, *string, *typex.U) bool)(nil)).Elem(), iterMakerETStringTypex_U)
+	RegisterInput(reflect.TypeOf((*func(*string, *typex.V) bool)(nil)).Elem(), iterMakerStringTypex_V)
+	RegisterInput(reflect.TypeOf((*func(*typex.EventTime, *string, *typex.V) bool)(nil)).Elem(), iterMakerETStringTypex_V)
+	RegisterInput(reflect.TypeOf((*func(*string, *typex.W) bool)(nil)).Elem(), iterMakerStringTypex_W)
+	RegisterInput(reflect.TypeOf((*func(*typex.EventTime, *string, *typex.W) bool)(nil)).Elem(), iterMakerETStringTypex_W)
+	RegisterInput(reflect.TypeOf((*func(*string, *typex.X) bool)(nil)).Elem(), iterMakerStringTypex_X)
+	RegisterInput(reflect.TypeOf((*func(*typex.EventTime, *string, *typex.X) bool)(nil)).Elem(), iterMakerETStringTypex_X)
+	RegisterInput(reflect.TypeOf((*func(*string, *typex.Y) bool)(nil)).Elem(), iterMakerStringTypex_Y)
+	RegisterInput(reflect.TypeOf((*func(*typex.EventTime, *string, *typex.Y) bool)(nil)).Elem(), iterMakerETStringTypex_Y)
+	RegisterInput(reflect.TypeOf((*func(*string, *typex.Z) bool)(nil)).Elem(), iterMakerStringTypex_Z)
+	RegisterInput(reflect.TypeOf((*func(*typex.EventTime, *string, *typex.Z) bool)(nil)).Elem(), iterMakerETStringTypex_Z)
+	RegisterInput(reflect.TypeOf((*func(*int) bool)(nil)).Elem(), iterMakerInt)
+	RegisterInput(reflect.TypeOf((*func(*typex.EventTime, *int) bool)(nil)).Elem(), iterMakerETInt)
+	RegisterInput(reflect.TypeOf((*func(*int, *[]byte) bool)(nil)).Elem(), iterMakerIntByteSlice)
+	RegisterInput(reflect.TypeOf((*func(*typex.EventTime, *int, *[]byte) bool)(nil)).Elem(), iterMakerETIntByteSlice)
+	RegisterInput(reflect.TypeOf((*func(*int, *bool) bool)(nil)).Elem(), iterMakerIntBool)
+	RegisterInput(reflect.TypeOf((*func(*typex.EventTime, *int, *bool) bool)(nil)).Elem(), iterMakerETIntBool)
+	RegisterInput(reflect.TypeOf((*func(*int, *string) bool)(nil)).Elem(), iterMakerIntString)
+	RegisterInput(reflect.TypeOf((*func(*typex.EventTime, *int, *string) bool)(nil)).Elem(), iterMakerETIntString)
+	RegisterInput(reflect.TypeOf((*func(*int, *int) bool)(nil)).Elem(), iterMakerIntInt)
+	RegisterInput(reflect.TypeOf((*func(*typex.EventTime, *int, *int) bool)(nil)).Elem(), iterMakerETIntInt)
+	RegisterInput(reflect.TypeOf((*func(*int, *int8) bool)(nil)).Elem(), iterMakerIntInt8)
+	RegisterInput(reflect.TypeOf((*func(*typex.EventTime, *int, *int8) bool)(nil)).Elem(), iterMakerETIntInt8)
+	RegisterInput(reflect.TypeOf((*func(*int, *int16) bool)(nil)).Elem(), iterMakerIntInt16)
+	RegisterInput(reflect.TypeOf((*func(*typex.EventTime, *int, *int16) bool)(nil)).Elem(), iterMakerETIntInt16)
+	RegisterInput(reflect.TypeOf((*func(*int, *int32) bool)(nil)).Elem(), iterMakerIntInt32)
+	RegisterInput(reflect.TypeOf((*func(*typex.EventTime, *int, *int32) bool)(nil)).Elem(), iterMakerETIntInt32)
+	RegisterInput(reflect.TypeOf((*func(*int, *int64) bool)(nil)).Elem(), iterMakerIntInt64)
+	RegisterInput(reflect.TypeOf((*func(*typex.EventTime, *int, *int64) bool)(nil)).Elem(), iterMakerETIntInt64)
+	RegisterInput(reflect.TypeOf((*func(*int, *uint) bool)(nil)).Elem(), iterMakerIntUint)
+	RegisterInput(reflect.TypeOf((*func(*typex.EventTime, *int, *uint) bool)(nil)).Elem(), iterMakerETIntUint)
+	RegisterInput(reflect.TypeOf((*func(*int, *uint8) bool)(nil)).Elem(), iterMakerIntUint8)
+	RegisterInput(reflect.TypeOf((*func(*typex.EventTime, *int, *uint8) bool)(nil)).Elem(), iterMakerETIntUint8)
+	RegisterInput(reflect.TypeOf((*func(*int, *uint16) bool)(nil)).Elem(), iterMakerIntUint16)
+	RegisterInput(reflect.TypeOf((*func(*typex.EventTime, *int, *uint16) bool)(nil)).Elem(), iterMakerETIntUint16)
+	RegisterInput(reflect.TypeOf((*func(*int, *uint32) bool)(nil)).Elem(), iterMakerIntUint32)
+	RegisterInput(reflect.TypeOf((*func(*typex.EventTime, *int, *uint32) bool)(nil)).Elem(), iterMakerETIntUint32)
+	RegisterInput(reflect.TypeOf((*func(*int, *uint64) bool)(nil)).Elem(), iterMakerIntUint64)
+	RegisterInput(reflect.TypeOf((*func(*typex.EventTime, *int, *uint64) bool)(nil)).Elem(), iterMakerETIntUint64)
+	RegisterInput(reflect.TypeOf((*func(*int, *float32) bool)(nil)).Elem(), iterMakerIntFloat32)
+	RegisterInput(reflect.TypeOf((*func(*typex.EventTime, *int, *float32) bool)(nil)).Elem(), iterMakerETIntFloat32)
+	RegisterInput(reflect.TypeOf((*func(*int, *float64) bool)(nil)).Elem(), iterMakerIntFloat64)
+	RegisterInput(reflect.TypeOf((*func(*typex.EventTime, *int, *float64) bool)(nil)).Elem(), iterMakerETIntFloat64)
+	RegisterInput(reflect.TypeOf((*func(*int, *typex.T) bool)(nil)).Elem(), iterMakerIntTypex_T)
+	RegisterInput(reflect.TypeOf((*func(*typex.EventTime, *int, *typex.T) bool)(nil)).Elem(), iterMakerETIntTypex_T)
+	RegisterInput(reflect.TypeOf((*func(*int, *typex.U) bool)(nil)).Elem(), iterMakerIntTypex_U)
+	RegisterInput(reflect.TypeOf((*func(*typex.EventTime, *int, *typex.U) bool)(nil)).Elem(), iterMakerETIntTypex_U)
+	RegisterInput(reflect.TypeOf((*func(*int, *typex.V) bool)(nil)).Elem(), iterMakerIntTypex_V)
+	RegisterInput(reflect.TypeOf((*func(*typex.EventTime, *int, *typex.V) bool)(nil)).Elem(), iterMakerETIntTypex_V)
+	RegisterInput(reflect.TypeOf((*func(*int, *typex.W) bool)(nil)).Elem(), iterMakerIntTypex_W)
+	RegisterInput(reflect.TypeOf((*func(*typex.EventTime, *int, *typex.W) bool)(nil)).Elem(), iterMakerETIntTypex_W)
+	RegisterInput(reflect.TypeOf((*func(*int, *typex.X) bool)(nil)).Elem(), iterMakerIntTypex_X)
+	RegisterInput(reflect.TypeOf((*func(*typex.EventTime, *int, *typex.X) bool)(nil)).Elem(), iterMakerETIntTypex_X)
+	RegisterInput(reflect.TypeOf((*func(*int, *typex.Y) bool)(nil)).Elem(), iterMakerIntTypex_Y)
+	RegisterInput(reflect.TypeOf((*func(*typex.EventTime, *int, *typex.Y) bool)(nil)).Elem(), iterMakerETIntTypex_Y)
+	RegisterInput(reflect.TypeOf((*func(*int, *typex.Z) bool)(nil)).Elem(), iterMakerIntTypex_Z)
+	RegisterInput(reflect.TypeOf((*func(*typex.EventTime, *int, *typex.Z) bool)(nil)).Elem(), iterMakerETIntTypex_Z)
+	RegisterInput(reflect.TypeOf((*func(*int8) bool)(nil)).Elem(), iterMakerInt8)
+	RegisterInput(reflect.TypeOf((*func(*typex.EventTime, *int8) bool)(nil)).Elem(), iterMakerETInt8)
+	RegisterInput(reflect.TypeOf((*func(*int8, *[]byte) bool)(nil)).Elem(), iterMakerInt8ByteSlice)
+	RegisterInput(reflect.TypeOf((*func(*typex.EventTime, *int8, *[]byte) bool)(nil)).Elem(), iterMakerETInt8ByteSlice)
+	RegisterInput(reflect.TypeOf((*func(*int8, *bool) bool)(nil)).Elem(), iterMakerInt8Bool)
+	RegisterInput(reflect.TypeOf((*func(*typex.EventTime, *int8, *bool) bool)(nil)).Elem(), iterMakerETInt8Bool)
+	RegisterInput(reflect.TypeOf((*func(*int8, *string) bool)(nil)).Elem(), iterMakerInt8String)
+	RegisterInput(reflect.TypeOf((*func(*typex.EventTime, *int8, *string) bool)(nil)).Elem(), iterMakerETInt8String)
+	RegisterInput(reflect.TypeOf((*func(*int8, *int) bool)(nil)).Elem(), iterMakerInt8Int)
+	RegisterInput(reflect.TypeOf((*func(*typex.EventTime, *int8, *int) bool)(nil)).Elem(), iterMakerETInt8Int)
+	RegisterInput(reflect.TypeOf((*func(*int8, *int8) bool)(nil)).Elem(), iterMakerInt8Int8)
+	RegisterInput(reflect.TypeOf((*func(*typex.EventTime, *int8, *int8) bool)(nil)).Elem(), iterMakerETInt8Int8)
+	RegisterInput(reflect.TypeOf((*func(*int8, *int16) bool)(nil)).Elem(), iterMakerInt8Int16)
+	RegisterInput(reflect.TypeOf((*func(*typex.EventTime, *int8, *int16) bool)(nil)).Elem(), iterMakerETInt8Int16)
+	RegisterInput(reflect.TypeOf((*func(*int8, *int32) bool)(nil)).Elem(), iterMakerInt8Int32)
+	RegisterInput(reflect.TypeOf((*func(*typex.EventTime, *int8, *int32) bool)(nil)).Elem(), iterMakerETInt8Int32)
+	RegisterInput(reflect.TypeOf((*func(*int8, *int64) bool)(nil)).Elem(), iterMakerInt8Int64)
+	RegisterInput(reflect.TypeOf((*func(*typex.EventTime, *int8, *int64) bool)(nil)).Elem(), iterMakerETInt8Int64)
+	RegisterInput(reflect.TypeOf((*func(*int8, *uint) bool)(nil)).Elem(), iterMakerInt8Uint)
+	RegisterInput(reflect.TypeOf((*func(*typex.EventTime, *int8, *uint) bool)(nil)).Elem(), iterMakerETInt8Uint)
+	RegisterInput(reflect.TypeOf((*func(*int8, *uint8) bool)(nil)).Elem(), iterMakerInt8Uint8)
+	RegisterInput(reflect.TypeOf((*func(*typex.EventTime, *int8, *uint8) bool)(nil)).Elem(), iterMakerETInt8Uint8)
+	RegisterInput(reflect.TypeOf((*func(*int8, *uint16) bool)(nil)).Elem(), iterMakerInt8Uint16)
+	RegisterInput(reflect.TypeOf((*func(*typex.EventTime, *int8, *uint16) bool)(nil)).Elem(), iterMakerETInt8Uint16)
+	RegisterInput(reflect.TypeOf((*func(*int8, *uint32) bool)(nil)).Elem(), iterMakerInt8Uint32)
+	RegisterInput(reflect.TypeOf((*func(*typex.EventTime, *int8, *uint32) bool)(nil)).Elem(), iterMakerETInt8Uint32)
+	RegisterInput(reflect.TypeOf((*func(*int8, *uint64) bool)(nil)).Elem(), iterMakerInt8Uint64)
+	RegisterInput(reflect.TypeOf((*func(*typex.EventTime, *int8, *uint64) bool)(nil)).Elem(), iterMakerETInt8Uint64)
+	RegisterInput(reflect.TypeOf((*func(*int8, *float32) bool)(nil)).Elem(), iterMakerInt8Float32)
+	RegisterInput(reflect.TypeOf((*func(*typex.EventTime, *int8, *float32) bool)(nil)).Elem(), iterMakerETInt8Float32)
+	RegisterInput(reflect.TypeOf((*func(*int8, *float64) bool)(nil)).Elem(), iterMakerInt8Float64)
+	RegisterInput(reflect.TypeOf((*func(*typex.EventTime, *int8, *float64) bool)(nil)).Elem(), iterMakerETInt8Float64)
+	RegisterInput(reflect.TypeOf((*func(*int8, *typex.T) bool)(nil)).Elem(), iterMakerInt8Typex_T)
+	RegisterInput(reflect.TypeOf((*func(*typex.EventTime, *int8, *typex.T) bool)(nil)).Elem(), iterMakerETInt8Typex_T)
+	RegisterInput(reflect.TypeOf((*func(*int8, *typex.U) bool)(nil)).Elem(), iterMakerInt8Typex_U)
+	RegisterInput(reflect.TypeOf((*func(*typex.EventTime, *int8, *typex.U) bool)(nil)).Elem(), iterMakerETInt8Typex_U)
+	RegisterInput(reflect.TypeOf((*func(*int8, *typex.V) bool)(nil)).Elem(), iterMakerInt8Typex_V)
+	RegisterInput(reflect.TypeOf((*func(*typex.EventTime, *int8, *typex.V) bool)(nil)).Elem(), iterMakerETInt8Typex_V)
+	RegisterInput(reflect.TypeOf((*func(*int8, *typex.W) bool)(nil)).Elem(), iterMakerInt8Typex_W)
+	RegisterInput(reflect.TypeOf((*func(*typex.EventTime, *int8, *typex.W) bool)(nil)).Elem(), iterMakerETInt8Typex_W)
+	RegisterInput(reflect.TypeOf((*func(*int8, *typex.X) bool)(nil)).Elem(), iterMakerInt8Typex_X)
+	RegisterInput(reflect.TypeOf((*func(*typex.EventTime, *int8, *typex.X) bool)(nil)).Elem(), iterMakerETInt8Typex_X)
+	RegisterInput(reflect.TypeOf((*func(*int8, *typex.Y) bool)(nil)).Elem(), iterMakerInt8Typex_Y)
+	RegisterInput(reflect.TypeOf((*func(*typex.EventTime, *int8, *typex.Y) bool)(nil)).Elem(), iterMakerETInt8Typex_Y)
+	RegisterInput(reflect.TypeOf((*func(*int8, *typex.Z) bool)(nil)).Elem(), iterMakerInt8Typex_Z)
+	RegisterInput(reflect.TypeOf((*func(*typex.EventTime, *int8, *typex.Z) bool)(nil)).Elem(), iterMakerETInt8Typex_Z)
+	RegisterInput(reflect.TypeOf((*func(*int16) bool)(nil)).Elem(), iterMakerInt16)
+	RegisterInput(reflect.TypeOf((*func(*typex.EventTime, *int16) bool)(nil)).Elem(), iterMakerETInt16)
+	RegisterInput(reflect.TypeOf((*func(*int16, *[]byte) bool)(nil)).Elem(), iterMakerInt16ByteSlice)
+	RegisterInput(reflect.TypeOf((*func(*typex.EventTime, *int16, *[]byte) bool)(nil)).Elem(), iterMakerETInt16ByteSlice)
+	RegisterInput(reflect.TypeOf((*func(*int16, *bool) bool)(nil)).Elem(), iterMakerInt16Bool)
+	RegisterInput(reflect.TypeOf((*func(*typex.EventTime, *int16, *bool) bool)(nil)).Elem(), iterMakerETInt16Bool)
+	RegisterInput(reflect.TypeOf((*func(*int16, *string) bool)(nil)).Elem(), iterMakerInt16String)
+	RegisterInput(reflect.TypeOf((*func(*typex.EventTime, *int16, *string) bool)(nil)).Elem(), iterMakerETInt16String)
+	RegisterInput(reflect.TypeOf((*func(*int16, *int) bool)(nil)).Elem(), iterMakerInt16Int)
+	RegisterInput(reflect.TypeOf((*func(*typex.EventTime, *int16, *int) bool)(nil)).Elem(), iterMakerETInt16Int)
+	RegisterInput(reflect.TypeOf((*func(*int16, *int8) bool)(nil)).Elem(), iterMakerInt16Int8)
+	RegisterInput(reflect.TypeOf((*func(*typex.EventTime, *int16, *int8) bool)(nil)).Elem(), iterMakerETInt16Int8)
+	RegisterInput(reflect.TypeOf((*func(*int16, *int16) bool)(nil)).Elem(), iterMakerInt16Int16)
+	RegisterInput(reflect.TypeOf((*func(*typex.EventTime, *int16, *int16) bool)(nil)).Elem(), iterMakerETInt16Int16)
+	RegisterInput(reflect.TypeOf((*func(*int16, *int32) bool)(nil)).Elem(), iterMakerInt16Int32)
+	RegisterInput(reflect.TypeOf((*func(*typex.EventTime, *int16, *int32) bool)(nil)).Elem(), iterMakerETInt16Int32)
+	RegisterInput(reflect.TypeOf((*func(*int16, *int64) bool)(nil)).Elem(), iterMakerInt16Int64)
+	RegisterInput(reflect.TypeOf((*func(*typex.EventTime, *int16, *int64) bool)(nil)).Elem(), iterMakerETInt16Int64)
+	RegisterInput(reflect.TypeOf((*func(*int16, *uint) bool)(nil)).Elem(), iterMakerInt16Uint)
+	RegisterInput(reflect.TypeOf((*func(*typex.EventTime, *int16, *uint) bool)(nil)).Elem(), iterMakerETInt16Uint)
+	RegisterInput(reflect.TypeOf((*func(*int16, *uint8) bool)(nil)).Elem(), iterMakerInt16Uint8)
+	RegisterInput(reflect.TypeOf((*func(*typex.EventTime, *int16, *uint8) bool)(nil)).Elem(), iterMakerETInt16Uint8)
+	RegisterInput(reflect.TypeOf((*func(*int16, *uint16) bool)(nil)).Elem(), iterMakerInt16Uint16)
+	RegisterInput(reflect.TypeOf((*func(*typex.EventTime, *int16, *uint16) bool)(nil)).Elem(), iterMakerETInt16Uint16)
+	RegisterInput(reflect.TypeOf((*func(*int16, *uint32) bool)(nil)).Elem(), iterMakerInt16Uint32)
+	RegisterInput(reflect.TypeOf((*func(*typex.EventTime, *int16, *uint32) bool)(nil)).Elem(), iterMakerETInt16Uint32)
+	RegisterInput(reflect.TypeOf((*func(*int16, *uint64) bool)(nil)).Elem(), iterMakerInt16Uint64)
+	RegisterInput(reflect.TypeOf((*func(*typex.EventTime, *int16, *uint64) bool)(nil)).Elem(), iterMakerETInt16Uint64)
+	RegisterInput(reflect.TypeOf((*func(*int16, *float32) bool)(nil)).Elem(), iterMakerInt16Float32)
+	RegisterInput(reflect.TypeOf((*func(*typex.EventTime, *int16, *float32) bool)(nil)).Elem(), iterMakerETInt16Float32)
+	RegisterInput(reflect.TypeOf((*func(*int16, *float64) bool)(nil)).Elem(), iterMakerInt16Float64)
+	RegisterInput(reflect.TypeOf((*func(*typex.EventTime, *int16, *float64) bool)(nil)).Elem(), iterMakerETInt16Float64)
+	RegisterInput(reflect.TypeOf((*func(*int16, *typex.T) bool)(nil)).Elem(), iterMakerInt16Typex_T)
+	RegisterInput(reflect.TypeOf((*func(*typex.EventTime, *int16, *typex.T) bool)(nil)).Elem(), iterMakerETInt16Typex_T)
+	RegisterInput(reflect.TypeOf((*func(*int16, *typex.U) bool)(nil)).Elem(), iterMakerInt16Typex_U)
+	RegisterInput(reflect.TypeOf((*func(*typex.EventTime, *int16, *typex.U) bool)(nil)).Elem(), iterMakerETInt16Typex_U)
+	RegisterInput(reflect.TypeOf((*func(*int16, *typex.V) bool)(nil)).Elem(), iterMakerInt16Typex_V)
+	RegisterInput(reflect.TypeOf((*func(*typex.EventTime, *int16, *typex.V) bool)(nil)).Elem(), iterMakerETInt16Typex_V)
+	RegisterInput(reflect.TypeOf((*func(*int16, *typex.W) bool)(nil)).Elem(), iterMakerInt16Typex_W)
+	RegisterInput(reflect.TypeOf((*func(*typex.EventTime, *int16, *typex.W) bool)(nil)).Elem(), iterMakerETInt16Typex_W)
+	RegisterInput(reflect.TypeOf((*func(*int16, *typex.X) bool)(nil)).Elem(), iterMakerInt16Typex_X)
+	RegisterInput(reflect.TypeOf((*func(*typex.EventTime, *int16, *typex.X) bool)(nil)).Elem(), iterMakerETInt16Typex_X)
+	RegisterInput(reflect.TypeOf((*func(*int16, *typex.Y) bool)(nil)).Elem(), iterMakerInt16Typex_Y)
+	RegisterInput(reflect.TypeOf((*func(*typex.EventTime, *int16, *typex.Y) bool)(nil)).Elem(), iterMakerETInt16Typex_Y)
+	RegisterInput(reflect.TypeOf((*func(*int16, *typex.Z) bool)(nil)).Elem(), iterMakerInt16Typex_Z)
+	RegisterInput(reflect.TypeOf((*func(*typex.EventTime, *int16, *typex.Z) bool)(nil)).Elem(), iterMakerETInt16Typex_Z)
+	RegisterInput(reflect.TypeOf((*func(*int32) bool)(nil)).Elem(), iterMakerInt32)
+	RegisterInput(reflect.TypeOf((*func(*typex.EventTime, *int32) bool)(nil)).Elem(), iterMakerETInt32)
+	RegisterInput(reflect.TypeOf((*func(*int32, *[]byte) bool)(nil)).Elem(), iterMakerInt32ByteSlice)
+	RegisterInput(reflect.TypeOf((*func(*typex.EventTime, *int32, *[]byte) bool)(nil)).Elem(), iterMakerETInt32ByteSlice)
+	RegisterInput(reflect.TypeOf((*func(*int32, *bool) bool)(nil)).Elem(), iterMakerInt32Bool)
+	RegisterInput(reflect.TypeOf((*func(*typex.EventTime, *int32, *bool) bool)(nil)).Elem(), iterMakerETInt32Bool)
+	RegisterInput(reflect.TypeOf((*func(*int32, *string) bool)(nil)).Elem(), iterMakerInt32String)
+	RegisterInput(reflect.TypeOf((*func(*typex.EventTime, *int32, *string) bool)(nil)).Elem(), iterMakerETInt32String)
+	RegisterInput(reflect.TypeOf((*func(*int32, *int) bool)(nil)).Elem(), iterMakerInt32Int)
+	RegisterInput(reflect.TypeOf((*func(*typex.EventTime, *int32, *int) bool)(nil)).Elem(), iterMakerETInt32Int)
+	RegisterInput(reflect.TypeOf((*func(*int32, *int8) bool)(nil)).Elem(), iterMakerInt32Int8)
+	RegisterInput(reflect.TypeOf((*func(*typex.EventTime, *int32, *int8) bool)(nil)).Elem(), iterMakerETInt32Int8)
+	RegisterInput(reflect.TypeOf((*func(*int32, *int16) bool)(nil)).Elem(), iterMakerInt32Int16)
+	RegisterInput(reflect.TypeOf((*func(*typex.EventTime, *int32, *int16) bool)(nil)).Elem(), iterMakerETInt32Int16)
+	RegisterInput(reflect.TypeOf((*func(*int32, *int32) bool)(nil)).Elem(), iterMakerInt32Int32)
+	RegisterInput(reflect.TypeOf((*func(*typex.EventTime, *int32, *int32) bool)(nil)).Elem(), iterMakerETInt32Int32)
+	RegisterInput(reflect.TypeOf((*func(*int32, *int64) bool)(nil)).Elem(), iterMakerInt32Int64)
+	RegisterInput(reflect.TypeOf((*func(*typex.EventTime, *int32, *int64) bool)(nil)).Elem(), iterMakerETInt32Int64)
+	RegisterInput(reflect.TypeOf((*func(*int32, *uint) bool)(nil)).Elem(), iterMakerInt32Uint)
+	RegisterInput(reflect.TypeOf((*func(*typex.EventTime, *int32, *uint) bool)(nil)).Elem(), iterMakerETInt32Uint)
+	RegisterInput(reflect.TypeOf((*func(*int32, *uint8) bool)(nil)).Elem(), iterMakerInt32Uint8)
+	RegisterInput(reflect.TypeOf((*func(*typex.EventTime, *int32, *uint8) bool)(nil)).Elem(), iterMakerETInt32Uint8)
+	RegisterInput(reflect.TypeOf((*func(*int32, *uint16) bool)(nil)).Elem(), iterMakerInt32Uint16)
+	RegisterInput(reflect.TypeOf((*func(*typex.EventTime, *int32, *uint16) bool)(nil)).Elem(), iterMakerETInt32Uint16)
+	RegisterInput(reflect.TypeOf((*func(*int32, *uint32) bool)(nil)).Elem(), iterMakerInt32Uint32)
+	RegisterInput(reflect.TypeOf((*func(*typex.EventTime, *int32, *uint32) bool)(nil)).Elem(), iterMakerETInt32Uint32)
+	RegisterInput(reflect.TypeOf((*func(*int32, *uint64) bool)(nil)).Elem(), iterMakerInt32Uint64)
+	RegisterInput(reflect.TypeOf((*func(*typex.EventTime, *int32, *uint64) bool)(nil)).Elem(), iterMakerETInt32Uint64)
+	RegisterInput(reflect.TypeOf((*func(*int32, *float32) bool)(nil)).Elem(), iterMakerInt32Float32)
+	RegisterInput(reflect.TypeOf((*func(*typex.EventTime, *int32, *float32) bool)(nil)).Elem(), iterMakerETInt32Float32)
+	RegisterInput(reflect.TypeOf((*func(*int32, *float64) bool)(nil)).Elem(), iterMakerInt32Float64)
+	RegisterInput(reflect.TypeOf((*func(*typex.EventTime, *int32, *float64) bool)(nil)).Elem(), iterMakerETInt32Float64)
+	RegisterInput(reflect.TypeOf((*func(*int32, *typex.T) bool)(nil)).Elem(), iterMakerInt32Typex_T)
+	RegisterInput(reflect.TypeOf((*func(*typex.EventTime, *int32, *typex.T) bool)(nil)).Elem(), iterMakerETInt32Typex_T)
+	RegisterInput(reflect.TypeOf((*func(*int32, *typex.U) bool)(nil)).Elem(), iterMakerInt32Typex_U)
+	RegisterInput(reflect.TypeOf((*func(*typex.EventTime, *int32, *typex.U) bool)(nil)).Elem(), iterMakerETInt32Typex_U)
+	RegisterInput(reflect.TypeOf((*func(*int32, *typex.V) bool)(nil)).Elem(), iterMakerInt32Typex_V)
+	RegisterInput(reflect.TypeOf((*func(*typex.EventTime, *int32, *typex.V) bool)(nil)).Elem(), iterMakerETInt32Typex_V)
+	RegisterInput(reflect.TypeOf((*func(*int32, *typex.W) bool)(nil)).Elem(), iterMakerInt32Typex_W)
+	RegisterInput(reflect.TypeOf((*func(*typex.EventTime, *int32, *typex.W) bool)(nil)).Elem(), iterMakerETInt32Typex_W)
+	RegisterInput(reflect.TypeOf((*func(*int32, *typex.X) bool)(nil)).Elem(), iterMakerInt32Typex_X)
+	RegisterInput(reflect.TypeOf((*func(*typex.EventTime, *int32, *typex.X) bool)(nil)).Elem(), iterMakerETInt32Typex_X)
+	RegisterInput(reflect.TypeOf((*func(*int32, *typex.Y) bool)(nil)).Elem(), iterMakerInt32Typex_Y)
+	RegisterInput(reflect.TypeOf((*func(*typex.EventTime, *int32, *typex.Y) bool)(nil)).Elem(), iterMakerETInt32Typex_Y)
+	RegisterInput(reflect.TypeOf((*func(*int32, *typex.Z) bool)(nil)).Elem(), iterMakerInt32Typex_Z)
+	RegisterInput(reflect.TypeOf((*func(*typex.EventTime, *int32, *typex.Z) bool)(nil)).Elem(), iterMakerETInt32Typex_Z)
+	RegisterInput(reflect.TypeOf((*func(*int64) bool)(nil)).Elem(), iterMakerInt64)
+	RegisterInput(reflect.TypeOf((*func(*typex.EventTime, *int64) bool)(nil)).Elem(), iterMakerETInt64)
+	RegisterInput(reflect.TypeOf((*func(*int64, *[]byte) bool)(nil)).Elem(), iterMakerInt64ByteSlice)
+	RegisterInput(reflect.TypeOf((*func(*typex.EventTime, *int64, *[]byte) bool)(nil)).Elem(), iterMakerETInt64ByteSlice)
+	RegisterInput(reflect.TypeOf((*func(*int64, *bool) bool)(nil)).Elem(), iterMakerInt64Bool)
+	RegisterInput(reflect.TypeOf((*func(*typex.EventTime, *int64, *bool) bool)(nil)).Elem(), iterMakerETInt64Bool)
+	RegisterInput(reflect.TypeOf((*func(*int64, *string) bool)(nil)).Elem(), iterMakerInt64String)
+	RegisterInput(reflect.TypeOf((*func(*typex.EventTime, *int64, *string) bool)(nil)).Elem(), iterMakerETInt64String)
+	RegisterInput(reflect.TypeOf((*func(*int64, *int) bool)(nil)).Elem(), iterMakerInt64Int)
+	RegisterInput(reflect.TypeOf((*func(*typex.EventTime, *int64, *int) bool)(nil)).Elem(), iterMakerETInt64Int)
+	RegisterInput(reflect.TypeOf((*func(*int64, *int8) bool)(nil)).Elem(), iterMakerInt64Int8)
+	RegisterInput(reflect.TypeOf((*func(*typex.EventTime, *int64, *int8) bool)(nil)).Elem(), iterMakerETInt64Int8)
+	RegisterInput(reflect.TypeOf((*func(*int64, *int16) bool)(nil)).Elem(), iterMakerInt64Int16)
+	RegisterInput(reflect.TypeOf((*func(*typex.EventTime, *int64, *int16) bool)(nil)).Elem(), iterMakerETInt64Int16)
+	RegisterInput(reflect.TypeOf((*func(*int64, *int32) bool)(nil)).Elem(), iterMakerInt64Int32)
+	RegisterInput(reflect.TypeOf((*func(*typex.EventTime, *int64, *int32) bool)(nil)).Elem(), iterMakerETInt64Int32)
+	RegisterInput(reflect.TypeOf((*func(*int64, *int64) bool)(nil)).Elem(), iterMakerInt64Int64)
+	RegisterInput(reflect.TypeOf((*func(*typex.EventTime, *int64, *int64) bool)(nil)).Elem(), iterMakerETInt64Int64)
+	RegisterInput(reflect.TypeOf((*func(*int64, *uint) bool)(nil)).Elem(), iterMakerInt64Uint)
+	RegisterInput(reflect.TypeOf((*func(*typex.EventTime, *int64, *uint) bool)(nil)).Elem(), iterMakerETInt64Uint)
+	RegisterInput(reflect.TypeOf((*func(*int64, *uint8) bool)(nil)).Elem(), iterMakerInt64Uint8)
+	RegisterInput(reflect.TypeOf((*func(*typex.EventTime, *int64, *uint8) bool)(nil)).Elem(), iterMakerETInt64Uint8)
+	RegisterInput(reflect.TypeOf((*func(*int64, *uint16) bool)(nil)).Elem(), iterMakerInt64Uint16)
+	RegisterInput(reflect.TypeOf((*func(*typex.EventTime, *int64, *uint16) bool)(nil)).Elem(), iterMakerETInt64Uint16)
+	RegisterInput(reflect.TypeOf((*func(*int64, *uint32) bool)(nil)).Elem(), iterMakerInt64Uint32)
+	RegisterInput(reflect.TypeOf((*func(*typex.EventTime, *int64, *uint32) bool)(nil)).Elem(), iterMakerETInt64Uint32)
+	RegisterInput(reflect.TypeOf((*func(*int64, *uint64) bool)(nil)).Elem(), iterMakerInt64Uint64)
+	RegisterInput(reflect.TypeOf((*func(*typex.EventTime, *int64, *uint64) bool)(nil)).Elem(), iterMakerETInt64Uint64)
+	RegisterInput(reflect.TypeOf((*func(*int64, *float32) bool)(nil)).Elem(), iterMakerInt64Float32)
+	RegisterInput(reflect.TypeOf((*func(*typex.EventTime, *int64, *float32) bool)(nil)).Elem(), iterMakerETInt64Float32)
+	RegisterInput(reflect.TypeOf((*func(*int64, *float64) bool)(nil)).Elem(), iterMakerInt64Float64)
+	RegisterInput(reflect.TypeOf((*func(*typex.EventTime, *int64, *float64) bool)(nil)).Elem(), iterMakerETInt64Float64)
+	RegisterInput(reflect.TypeOf((*func(*int64, *typex.T) bool)(nil)).Elem(), iterMakerInt64Typex_T)
+	RegisterInput(reflect.TypeOf((*func(*typex.EventTime, *int64, *typex.T) bool)(nil)).Elem(), iterMakerETInt64Typex_T)
+	RegisterInput(reflect.TypeOf((*func(*int64, *typex.U) bool)(nil)).Elem(), iterMakerInt64Typex_U)
+	RegisterInput(reflect.TypeOf((*func(*typex.EventTime, *int64, *typex.U) bool)(nil)).Elem(), iterMakerETInt64Typex_U)
+	RegisterInput(reflect.TypeOf((*func(*int64, *typex.V) bool)(nil)).Elem(), iterMakerInt64Typex_V)
+	RegisterInput(reflect.TypeOf((*func(*typex.EventTime, *int64, *typex.V) bool)(nil)).Elem(), iterMakerETInt64Typex_V)
+	RegisterInput(reflect.TypeOf((*func(*int64, *typex.W) bool)(nil)).Elem(), iterMakerInt64Typex_W)
+	RegisterInput(reflect.TypeOf((*func(*typex.EventTime, *int64, *typex.W) bool)(nil)).Elem(), iterMakerETInt64Typex_W)
+	RegisterInput(reflect.TypeOf((*func(*int64, *typex.X) bool)(nil)).Elem(), iterMakerInt64Typex_X)
+	RegisterInput(reflect.TypeOf((*func(*typex.EventTime, *int64, *typex.X) bool)(nil)).Elem(), iterMakerETInt64Typex_X)
+	RegisterInput(reflect.TypeOf((*func(*int64, *typex.Y) bool)(nil)).Elem(), iterMakerInt64Typex_Y)
+	RegisterInput(reflect.TypeOf((*func(*typex.EventTime, *int64, *typex.Y) bool)(nil)).Elem(), iterMakerETInt64Typex_Y)
+	RegisterInput(reflect.TypeOf((*func(*int64, *typex.Z) bool)(nil)).Elem(), iterMakerInt64Typex_Z)
+	RegisterInput(reflect.TypeOf((*func(*typex.EventTime, *int64, *typex.Z) bool)(nil)).Elem(), iterMakerETInt64Typex_Z)
+	RegisterInput(reflect.TypeOf((*func(*uint) bool)(nil)).Elem(), iterMakerUint)
+	RegisterInput(reflect.TypeOf((*func(*typex.EventTime, *uint) bool)(nil)).Elem(), iterMakerETUint)
+	RegisterInput(reflect.TypeOf((*func(*uint, *[]byte) bool)(nil)).Elem(), iterMakerUintByteSlice)
+	RegisterInput(reflect.TypeOf((*func(*typex.EventTime, *uint, *[]byte) bool)(nil)).Elem(), iterMakerETUintByteSlice)
+	RegisterInput(reflect.TypeOf((*func(*uint, *bool) bool)(nil)).Elem(), iterMakerUintBool)
+	RegisterInput(reflect.TypeOf((*func(*typex.EventTime, *uint, *bool) bool)(nil)).Elem(), iterMakerETUintBool)
+	RegisterInput(reflect.TypeOf((*func(*uint, *string) bool)(nil)).Elem(), iterMakerUintString)
+	RegisterInput(reflect.TypeOf((*func(*typex.EventTime, *uint, *string) bool)(nil)).Elem(), iterMakerETUintString)
+	RegisterInput(reflect.TypeOf((*func(*uint, *int) bool)(nil)).Elem(), iterMakerUintInt)
+	RegisterInput(reflect.TypeOf((*func(*typex.EventTime, *uint, *int) bool)(nil)).Elem(), iterMakerETUintInt)
+	RegisterInput(reflect.TypeOf((*func(*uint, *int8) bool)(nil)).Elem(), iterMakerUintInt8)
+	RegisterInput(reflect.TypeOf((*func(*typex.EventTime, *uint, *int8) bool)(nil)).Elem(), iterMakerETUintInt8)
+	RegisterInput(reflect.TypeOf((*func(*uint, *int16) bool)(nil)).Elem(), iterMakerUintInt16)
+	RegisterInput(reflect.TypeOf((*func(*typex.EventTime, *uint, *int16) bool)(nil)).Elem(), iterMakerETUintInt16)
+	RegisterInput(reflect.TypeOf((*func(*uint, *int32) bool)(nil)).Elem(), iterMakerUintInt32)
+	RegisterInput(reflect.TypeOf((*func(*typex.EventTime, *uint, *int32) bool)(nil)).Elem(), iterMakerETUintInt32)
+	RegisterInput(reflect.TypeOf((*func(*uint, *int64) bool)(nil)).Elem(), iterMakerUintInt64)
+	RegisterInput(reflect.TypeOf((*func(*typex.EventTime, *uint, *int64) bool)(nil)).Elem(), iterMakerETUintInt64)
+	RegisterInput(reflect.TypeOf((*func(*uint, *uint) bool)(nil)).Elem(), iterMakerUintUint)
+	RegisterInput(reflect.TypeOf((*func(*typex.EventTime, *uint, *uint) bool)(nil)).Elem(), iterMakerETUintUint)
+	RegisterInput(reflect.TypeOf((*func(*uint, *uint8) bool)(nil)).Elem(), iterMakerUintUint8)
+	RegisterInput(reflect.TypeOf((*func(*typex.EventTime, *uint, *uint8) bool)(nil)).Elem(), iterMakerETUintUint8)
+	RegisterInput(reflect.TypeOf((*func(*uint, *uint16) bool)(nil)).Elem(), iterMakerUintUint16)
+	RegisterInput(reflect.TypeOf((*func(*typex.EventTime, *uint, *uint16) bool)(nil)).Elem(), iterMakerETUintUint16)
+	RegisterInput(reflect.TypeOf((*func(*uint, *uint32) bool)(nil)).Elem(), iterMakerUintUint32)
+	RegisterInput(reflect.TypeOf((*func(*typex.EventTime, *uint, *uint32) bool)(nil)).Elem(), iterMakerETUintUint32)
+	RegisterInput(reflect.TypeOf((*func(*uint, *uint64) bool)(nil)).Elem(), iterMakerUintUint64)
+	RegisterInput(reflect.TypeOf((*func(*typex.EventTime, *uint, *uint64) bool)(nil)).Elem(), iterMakerETUintUint64)
+	RegisterInput(reflect.TypeOf((*func(*uint, *float32) bool)(nil)).Elem(), iterMakerUintFloat32)
+	RegisterInput(reflect.TypeOf((*func(*typex.EventTime, *uint, *float32) bool)(nil)).Elem(), iterMakerETUintFloat32)
+	RegisterInput(reflect.TypeOf((*func(*uint, *float64) bool)(nil)).Elem(), iterMakerUintFloat64)
+	RegisterInput(reflect.TypeOf((*func(*typex.EventTime, *uint, *float64) bool)(nil)).Elem(), iterMakerETUintFloat64)
+	RegisterInput(reflect.TypeOf((*func(*uint, *typex.T) bool)(nil)).Elem(), iterMakerUintTypex_T)
+	RegisterInput(reflect.TypeOf((*func(*typex.EventTime, *uint, *typex.T) bool)(nil)).Elem(), iterMakerETUintTypex_T)
+	RegisterInput(reflect.TypeOf((*func(*uint, *typex.U) bool)(nil)).Elem(), iterMakerUintTypex_U)
+	RegisterInput(reflect.TypeOf((*func(*typex.EventTime, *uint, *typex.U) bool)(nil)).Elem(), iterMakerETUintTypex_U)
+	RegisterInput(reflect.TypeOf((*func(*uint, *typex.V) bool)(nil)).Elem(), iterMakerUintTypex_V)
+	RegisterInput(reflect.TypeOf((*func(*typex.EventTime, *uint, *typex.V) bool)(nil)).Elem(), iterMakerETUintTypex_V)
+	RegisterInput(reflect.TypeOf((*func(*uint, *typex.W) bool)(nil)).Elem(), iterMakerUintTypex_W)
+	RegisterInput(reflect.TypeOf((*func(*typex.EventTime, *uint, *typex.W) bool)(nil)).Elem(), iterMakerETUintTypex_W)
+	RegisterInput(reflect.TypeOf((*func(*uint, *typex.X) bool)(nil)).Elem(), iterMakerUintTypex_X)
+	RegisterInput(reflect.TypeOf((*func(*typex.EventTime, *uint, *typex.X) bool)(nil)).Elem(), iterMakerETUintTypex_X)
+	RegisterInput(reflect.TypeOf((*func(*uint, *typex.Y) bool)(nil)).Elem(), iterMakerUintTypex_Y)
+	RegisterInput(reflect.TypeOf((*func(*typex.EventTime, *uint, *typex.Y) bool)(nil)).Elem(), iterMakerETUintTypex_Y)
+	RegisterInput(reflect.TypeOf((*func(*uint, *typex.Z) bool)(nil)).Elem(), iterMakerUintTypex_Z)
+	RegisterInput(reflect.TypeOf((*func(*typex.EventTime, *uint, *typex.Z) bool)(nil)).Elem(), iterMakerETUintTypex_Z)
+	RegisterInput(reflect.TypeOf((*func(*uint8) bool)(nil)).Elem(), iterMakerUint8)
+	RegisterInput(reflect.TypeOf((*func(*typex.EventTime, *uint8) bool)(nil)).Elem(), iterMakerETUint8)
+	RegisterInput(reflect.TypeOf((*func(*uint8, *[]byte) bool)(nil)).Elem(), iterMakerUint8ByteSlice)
+	RegisterInput(reflect.TypeOf((*func(*typex.EventTime, *uint8, *[]byte) bool)(nil)).Elem(), iterMakerETUint8ByteSlice)
+	RegisterInput(reflect.TypeOf((*func(*uint8, *bool) bool)(nil)).Elem(), iterMakerUint8Bool)
+	RegisterInput(reflect.TypeOf((*func(*typex.EventTime, *uint8, *bool) bool)(nil)).Elem(), iterMakerETUint8Bool)
+	RegisterInput(reflect.TypeOf((*func(*uint8, *string) bool)(nil)).Elem(), iterMakerUint8String)
+	RegisterInput(reflect.TypeOf((*func(*typex.EventTime, *uint8, *string) bool)(nil)).Elem(), iterMakerETUint8String)
+	RegisterInput(reflect.TypeOf((*func(*uint8, *int) bool)(nil)).Elem(), iterMakerUint8Int)
+	RegisterInput(reflect.TypeOf((*func(*typex.EventTime, *uint8, *int) bool)(nil)).Elem(), iterMakerETUint8Int)
+	RegisterInput(reflect.TypeOf((*func(*uint8, *int8) bool)(nil)).Elem(), iterMakerUint8Int8)
+	RegisterInput(reflect.TypeOf((*func(*typex.EventTime, *uint8, *int8) bool)(nil)).Elem(), iterMakerETUint8Int8)
+	RegisterInput(reflect.TypeOf((*func(*uint8, *int16) bool)(nil)).Elem(), iterMakerUint8Int16)
+	RegisterInput(reflect.TypeOf((*func(*typex.EventTime, *uint8, *int16) bool)(nil)).Elem(), iterMakerETUint8Int16)
+	RegisterInput(reflect.TypeOf((*func(*uint8, *int32) bool)(nil)).Elem(), iterMakerUint8Int32)
+	RegisterInput(reflect.TypeOf((*func(*typex.EventTime, *uint8, *int32) bool)(nil)).Elem(), iterMakerETUint8Int32)
+	RegisterInput(reflect.TypeOf((*func(*uint8, *int64) bool)(nil)).Elem(), iterMakerUint8Int64)
+	RegisterInput(reflect.TypeOf((*func(*typex.EventTime, *uint8, *int64) bool)(nil)).Elem(), iterMakerETUint8Int64)
+	RegisterInput(reflect.TypeOf((*func(*uint8, *uint) bool)(nil)).Elem(), iterMakerUint8Uint)
+	RegisterInput(reflect.TypeOf((*func(*typex.EventTime, *uint8, *uint) bool)(nil)).Elem(), iterMakerETUint8Uint)
+	RegisterInput(reflect.TypeOf((*func(*uint8, *uint8) bool)(nil)).Elem(), iterMakerUint8Uint8)
+	RegisterInput(reflect.TypeOf((*func(*typex.EventTime, *uint8, *uint8) bool)(nil)).Elem(), iterMakerETUint8Uint8)
+	RegisterInput(reflect.TypeOf((*func(*uint8, *uint16) bool)(nil)).Elem(), iterMakerUint8Uint16)
+	RegisterInput(reflect.TypeOf((*func(*typex.EventTime, *uint8, *uint16) bool)(nil)).Elem(), iterMakerETUint8Uint16)
+	RegisterInput(reflect.TypeOf((*func(*uint8, *uint32) bool)(nil)).Elem(), iterMakerUint8Uint32)
+	RegisterInput(reflect.TypeOf((*func(*typex.EventTime, *uint8, *uint32) bool)(nil)).Elem(), iterMakerETUint8Uint32)
+	RegisterInput(reflect.TypeOf((*func(*uint8, *uint64) bool)(nil)).Elem(), iterMakerUint8Uint64)
+	RegisterInput(reflect.TypeOf((*func(*typex.EventTime, *uint8, *uint64) bool)(nil)).Elem(), iterMakerETUint8Uint64)
+	RegisterInput(reflect.TypeOf((*func(*uint8, *float32) bool)(nil)).Elem(), iterMakerUint8Float32)
+	RegisterInput(reflect.TypeOf((*func(*typex.EventTime, *uint8, *float32) bool)(nil)).Elem(), iterMakerETUint8Float32)
+	RegisterInput(reflect.TypeOf((*func(*uint8, *float64) bool)(nil)).Elem(), iterMakerUint8Float64)
+	RegisterInput(reflect.TypeOf((*func(*typex.EventTime, *uint8, *float64) bool)(nil)).Elem(), iterMakerETUint8Float64)
+	RegisterInput(reflect.TypeOf((*func(*uint8, *typex.T) bool)(nil)).Elem(), iterMakerUint8Typex_T)
+	RegisterInput(reflect.TypeOf((*func(*typex.EventTime, *uint8, *typex.T) bool)(nil)).Elem(), iterMakerETUint8Typex_T)
+	RegisterInput(reflect.TypeOf((*func(*uint8, *typex.U) bool)(nil)).Elem(), iterMakerUint8Typex_U)
+	RegisterInput(reflect.TypeOf((*func(*typex.EventTime, *uint8, *typex.U) bool)(nil)).Elem(), iterMakerETUint8Typex_U)
+	RegisterInput(reflect.TypeOf((*func(*uint8, *typex.V) bool)(nil)).Elem(), iterMakerUint8Typex_V)
+	RegisterInput(reflect.TypeOf((*func(*typex.EventTime, *uint8, *typex.V) bool)(nil)).Elem(), iterMakerETUint8Typex_V)
+	RegisterInput(reflect.TypeOf((*func(*uint8, *typex.W) bool)(nil)).Elem(), iterMakerUint8Typex_W)
+	RegisterInput(reflect.TypeOf((*func(*typex.EventTime, *uint8, *typex.W) bool)(nil)).Elem(), iterMakerETUint8Typex_W)
+	RegisterInput(reflect.TypeOf((*func(*uint8, *typex.X) bool)(nil)).Elem(), iterMakerUint8Typex_X)
+	RegisterInput(reflect.TypeOf((*func(*typex.EventTime, *uint8, *typex.X) bool)(nil)).Elem(), iterMakerETUint8Typex_X)
+	RegisterInput(reflect.TypeOf((*func(*uint8, *typex.Y) bool)(nil)).Elem(), iterMakerUint8Typex_Y)
+	RegisterInput(reflect.TypeOf((*func(*typex.EventTime, *uint8, *typex.Y) bool)(nil)).Elem(), iterMakerETUint8Typex_Y)
+	RegisterInput(reflect.TypeOf((*func(*uint8, *typex.Z) bool)(nil)).Elem(), iterMakerUint8Typex_Z)
+	RegisterInput(reflect.TypeOf((*func(*typex.EventTime, *uint8, *typex.Z) bool)(nil)).Elem(), iterMakerETUint8Typex_Z)
+	RegisterInput(reflect.TypeOf((*func(*uint16) bool)(nil)).Elem(), iterMakerUint16)
+	RegisterInput(reflect.TypeOf((*func(*typex.EventTime, *uint16) bool)(nil)).Elem(), iterMakerETUint16)
+	RegisterInput(reflect.TypeOf((*func(*uint16, *[]byte) bool)(nil)).Elem(), iterMakerUint16ByteSlice)
+	RegisterInput(reflect.TypeOf((*func(*typex.EventTime, *uint16, *[]byte) bool)(nil)).Elem(), iterMakerETUint16ByteSlice)
+	RegisterInput(reflect.TypeOf((*func(*uint16, *bool) bool)(nil)).Elem(), iterMakerUint16Bool)
+	RegisterInput(reflect.TypeOf((*func(*typex.EventTime, *uint16, *bool) bool)(nil)).Elem(), iterMakerETUint16Bool)
+	RegisterInput(reflect.TypeOf((*func(*uint16, *string) bool)(nil)).Elem(), iterMakerUint16String)
+	RegisterInput(reflect.TypeOf((*func(*typex.EventTime, *uint16, *string) bool)(nil)).Elem(), iterMakerETUint16String)
+	RegisterInput(reflect.TypeOf((*func(*uint16, *int) bool)(nil)).Elem(), iterMakerUint16Int)
+	RegisterInput(reflect.TypeOf((*func(*typex.EventTime, *uint16, *int) bool)(nil)).Elem(), iterMakerETUint16Int)
+	RegisterInput(reflect.TypeOf((*func(*uint16, *int8) bool)(nil)).Elem(), iterMakerUint16Int8)
+	RegisterInput(reflect.TypeOf((*func(*typex.EventTime, *uint16, *int8) bool)(nil)).Elem(), iterMakerETUint16Int8)
+	RegisterInput(reflect.TypeOf((*func(*uint16, *int16) bool)(nil)).Elem(), iterMakerUint16Int16)
+	RegisterInput(reflect.TypeOf((*func(*typex.EventTime, *uint16, *int16) bool)(nil)).Elem(), iterMakerETUint16Int16)
+	RegisterInput(reflect.TypeOf((*func(*uint16, *int32) bool)(nil)).Elem(), iterMakerUint16Int32)
+	RegisterInput(reflect.TypeOf((*func(*typex.EventTime, *uint16, *int32) bool)(nil)).Elem(), iterMakerETUint16Int32)
+	RegisterInput(reflect.TypeOf((*func(*uint16, *int64) bool)(nil)).Elem(), iterMakerUint16Int64)
+	RegisterInput(reflect.TypeOf((*func(*typex.EventTime, *uint16, *int64) bool)(nil)).Elem(), iterMakerETUint16Int64)
+	RegisterInput(reflect.TypeOf((*func(*uint16, *uint) bool)(nil)).Elem(), iterMakerUint16Uint)
+	RegisterInput(reflect.TypeOf((*func(*typex.EventTime, *uint16, *uint) bool)(nil)).Elem(), iterMakerETUint16Uint)
+	RegisterInput(reflect.TypeOf((*func(*uint16, *uint8) bool)(nil)).Elem(), iterMakerUint16Uint8)
+	RegisterInput(reflect.TypeOf((*func(*typex.EventTime, *uint16, *uint8) bool)(nil)).Elem(), iterMakerETUint16Uint8)
+	RegisterInput(reflect.TypeOf((*func(*uint16, *uint16) bool)(nil)).Elem(), iterMakerUint16Uint16)
+	RegisterInput(reflect.TypeOf((*func(*typex.EventTime, *uint16, *uint16) bool)(nil)).Elem(), iterMakerETUint16Uint16)
+	RegisterInput(reflect.TypeOf((*func(*uint16, *uint32) bool)(nil)).Elem(), iterMakerUint16Uint32)
+	RegisterInput(reflect.TypeOf((*func(*typex.EventTime, *uint16, *uint32) bool)(nil)).Elem(), iterMakerETUint16Uint32)
+	RegisterInput(reflect.TypeOf((*func(*uint16, *uint64) bool)(nil)).Elem(), iterMakerUint16Uint64)
+	RegisterInput(reflect.TypeOf((*func(*typex.EventTime, *uint16, *uint64) bool)(nil)).Elem(), iterMakerETUint16Uint64)
+	RegisterInput(reflect.TypeOf((*func(*uint16, *float32) bool)(nil)).Elem(), iterMakerUint16Float32)
+	RegisterInput(reflect.TypeOf((*func(*typex.EventTime, *uint16, *float32) bool)(nil)).Elem(), iterMakerETUint16Float32)
+	RegisterInput(reflect.TypeOf((*func(*uint16, *float64) bool)(nil)).Elem(), iterMakerUint16Float64)
+	RegisterInput(reflect.TypeOf((*func(*typex.EventTime, *uint16, *float64) bool)(nil)).Elem(), iterMakerETUint16Float64)
+	RegisterInput(reflect.TypeOf((*func(*uint16, *typex.T) bool)(nil)).Elem(), iterMakerUint16Typex_T)
+	RegisterInput(reflect.TypeOf((*func(*typex.EventTime, *uint16, *typex.T) bool)(nil)).Elem(), iterMakerETUint16Typex_T)
+	RegisterInput(reflect.TypeOf((*func(*uint16, *typex.U) bool)(nil)).Elem(), iterMakerUint16Typex_U)
+	RegisterInput(reflect.TypeOf((*func(*typex.EventTime, *uint16, *typex.U) bool)(nil)).Elem(), iterMakerETUint16Typex_U)
+	RegisterInput(reflect.TypeOf((*func(*uint16, *typex.V) bool)(nil)).Elem(), iterMakerUint16Typex_V)
+	RegisterInput(reflect.TypeOf((*func(*typex.EventTime, *uint16, *typex.V) bool)(nil)).Elem(), iterMakerETUint16Typex_V)
+	RegisterInput(reflect.TypeOf((*func(*uint16, *typex.W) bool)(nil)).Elem(), iterMakerUint16Typex_W)
+	RegisterInput(reflect.TypeOf((*func(*typex.EventTime, *uint16, *typex.W) bool)(nil)).Elem(), iterMakerETUint16Typex_W)
+	RegisterInput(reflect.TypeOf((*func(*uint16, *typex.X) bool)(nil)).Elem(), iterMakerUint16Typex_X)
+	RegisterInput(reflect.TypeOf((*func(*typex.EventTime, *uint16, *typex.X) bool)(nil)).Elem(), iterMakerETUint16Typex_X)
+	RegisterInput(reflect.TypeOf((*func(*uint16, *typex.Y) bool)(nil)).Elem(), iterMakerUint16Typex_Y)
+	RegisterInput(reflect.TypeOf((*func(*typex.EventTime, *uint16, *typex.Y) bool)(nil)).Elem(), iterMakerETUint16Typex_Y)
+	RegisterInput(reflect.TypeOf((*func(*uint16, *typex.Z) bool)(nil)).Elem(), iterMakerUint16Typex_Z)
+	RegisterInput(reflect.TypeOf((*func(*typex.EventTime, *uint16, *typex.Z) bool)(nil)).Elem(), iterMakerETUint16Typex_Z)
+	RegisterInput(reflect.TypeOf((*func(*uint32) bool)(nil)).Elem(), iterMakerUint32)
+	RegisterInput(reflect.TypeOf((*func(*typex.EventTime, *uint32) bool)(nil)).Elem(), iterMakerETUint32)
+	RegisterInput(reflect.TypeOf((*func(*uint32, *[]byte) bool)(nil)).Elem(), iterMakerUint32ByteSlice)
+	RegisterInput(reflect.TypeOf((*func(*typex.EventTime, *uint32, *[]byte) bool)(nil)).Elem(), iterMakerETUint32ByteSlice)
+	RegisterInput(reflect.TypeOf((*func(*uint32, *bool) bool)(nil)).Elem(), iterMakerUint32Bool)
+	RegisterInput(reflect.TypeOf((*func(*typex.EventTime, *uint32, *bool) bool)(nil)).Elem(), iterMakerETUint32Bool)
+	RegisterInput(reflect.TypeOf((*func(*uint32, *string) bool)(nil)).Elem(), iterMakerUint32String)
+	RegisterInput(reflect.TypeOf((*func(*typex.EventTime, *uint32, *string) bool)(nil)).Elem(), iterMakerETUint32String)
+	RegisterInput(reflect.TypeOf((*func(*uint32, *int) bool)(nil)).Elem(), iterMakerUint32Int)
+	RegisterInput(reflect.TypeOf((*func(*typex.EventTime, *uint32, *int) bool)(nil)).Elem(), iterMakerETUint32Int)
+	RegisterInput(reflect.TypeOf((*func(*uint32, *int8) bool)(nil)).Elem(), iterMakerUint32Int8)
+	RegisterInput(reflect.TypeOf((*func(*typex.EventTime, *uint32, *int8) bool)(nil)).Elem(), iterMakerETUint32Int8)
+	RegisterInput(reflect.TypeOf((*func(*uint32, *int16) bool)(nil)).Elem(), iterMakerUint32Int16)
+	RegisterInput(reflect.TypeOf((*func(*typex.EventTime, *uint32, *int16) bool)(nil)).Elem(), iterMakerETUint32Int16)
+	RegisterInput(reflect.TypeOf((*func(*uint32, *int32) bool)(nil)).Elem(), iterMakerUint32Int32)
+	RegisterInput(reflect.TypeOf((*func(*typex.EventTime, *uint32, *int32) bool)(nil)).Elem(), iterMakerETUint32Int32)
+	RegisterInput(reflect.TypeOf((*func(*uint32, *int64) bool)(nil)).Elem(), iterMakerUint32Int64)
+	RegisterInput(reflect.TypeOf((*func(*typex.EventTime, *uint32, *int64) bool)(nil)).Elem(), iterMakerETUint32Int64)
+	RegisterInput(reflect.TypeOf((*func(*uint32, *uint) bool)(nil)).Elem(), iterMakerUint32Uint)
+	RegisterInput(reflect.TypeOf((*func(*typex.EventTime, *uint32, *uint) bool)(nil)).Elem(), iterMakerETUint32Uint)
+	RegisterInput(reflect.TypeOf((*func(*uint32, *uint8) bool)(nil)).Elem(), iterMakerUint32Uint8)
+	RegisterInput(reflect.TypeOf((*func(*typex.EventTime, *uint32, *uint8) bool)(nil)).Elem(), iterMakerETUint32Uint8)
+	RegisterInput(reflect.TypeOf((*func(*uint32, *uint16) bool)(nil)).Elem(), iterMakerUint32Uint16)
+	RegisterInput(reflect.TypeOf((*func(*typex.EventTime, *uint32, *uint16) bool)(nil)).Elem(), iterMakerETUint32Uint16)
+	RegisterInput(reflect.TypeOf((*func(*uint32, *uint32) bool)(nil)).Elem(), iterMakerUint32Uint32)
+	RegisterInput(reflect.TypeOf((*func(*typex.EventTime, *uint32, *uint32) bool)(nil)).Elem(), iterMakerETUint32Uint32)
+	RegisterInput(reflect.TypeOf((*func(*uint32, *uint64) bool)(nil)).Elem(), iterMakerUint32Uint64)
+	RegisterInput(reflect.TypeOf((*func(*typex.EventTime, *uint32, *uint64) bool)(nil)).Elem(), iterMakerETUint32Uint64)
+	RegisterInput(reflect.TypeOf((*func(*uint32, *float32) bool)(nil)).Elem(), iterMakerUint32Float32)
+	RegisterInput(reflect.TypeOf((*func(*typex.EventTime, *uint32, *float32) bool)(nil)).Elem(), iterMakerETUint32Float32)
+	RegisterInput(reflect.TypeOf((*func(*uint32, *float64) bool)(nil)).Elem(), iterMakerUint32Float64)
+	RegisterInput(reflect.TypeOf((*func(*typex.EventTime, *uint32, *float64) bool)(nil)).Elem(), iterMakerETUint32Float64)
+	RegisterInput(reflect.TypeOf((*func(*uint32, *typex.T) bool)(nil)).Elem(), iterMakerUint32Typex_T)
+	RegisterInput(reflect.TypeOf((*func(*typex.EventTime, *uint32, *typex.T) bool)(nil)).Elem(), iterMakerETUint32Typex_T)
+	RegisterInput(reflect.TypeOf((*func(*uint32, *typex.U) bool)(nil)).Elem(), iterMakerUint32Typex_U)
+	RegisterInput(reflect.TypeOf((*func(*typex.EventTime, *uint32, *typex.U) bool)(nil)).Elem(), iterMakerETUint32Typex_U)
+	RegisterInput(reflect.TypeOf((*func(*uint32, *typex.V) bool)(nil)).Elem(), iterMakerUint32Typex_V)
+	RegisterInput(reflect.TypeOf((*func(*typex.EventTime, *uint32, *typex.V) bool)(nil)).Elem(), iterMakerETUint32Typex_V)
+	RegisterInput(reflect.TypeOf((*func(*uint32, *typex.W) bool)(nil)).Elem(), iterMakerUint32Typex_W)
+	RegisterInput(reflect.TypeOf((*func(*typex.EventTime, *uint32, *typex.W) bool)(nil)).Elem(), iterMakerETUint32Typex_W)
+	RegisterInput(reflect.TypeOf((*func(*uint32, *typex.X) bool)(nil)).Elem(), iterMakerUint32Typex_X)
+	RegisterInput(reflect.TypeOf((*func(*typex.EventTime, *uint32, *typex.X) bool)(nil)).Elem(), iterMakerETUint32Typex_X)
+	RegisterInput(reflect.TypeOf((*func(*uint32, *typex.Y) bool)(nil)).Elem(), iterMakerUint32Typex_Y)
+	RegisterInput(reflect.TypeOf((*func(*typex.EventTime, *uint32, *typex.Y) bool)(nil)).Elem(), iterMakerETUint32Typex_Y)
+	RegisterInput(reflect.TypeOf((*func(*uint32, *typex.Z) bool)(nil)).Elem(), iterMakerUint32Typex_Z)
+	RegisterInput(reflect.TypeOf((*func(*typex.EventTime, *uint32, *typex.Z) bool)(nil)).Elem(), iterMakerETUint32Typex_Z)
+	RegisterInput(reflect.TypeOf((*func(*uint64) bool)(nil)).Elem(), iterMakerUint64)
+	RegisterInput(reflect.TypeOf((*func(*typex.EventTime, *uint64) bool)(nil)).Elem(), iterMakerETUint64)
+	RegisterInput(reflect.TypeOf((*func(*uint64, *[]byte) bool)(nil)).Elem(), iterMakerUint64ByteSlice)
+	RegisterInput(reflect.TypeOf((*func(*typex.EventTime, *uint64, *[]byte) bool)(nil)).Elem(), iterMakerETUint64ByteSlice)
+	RegisterInput(reflect.TypeOf((*func(*uint64, *bool) bool)(nil)).Elem(), iterMakerUint64Bool)
+	RegisterInput(reflect.TypeOf((*func(*typex.EventTime, *uint64, *bool) bool)(nil)).Elem(), iterMakerETUint64Bool)
+	RegisterInput(reflect.TypeOf((*func(*uint64, *string) bool)(nil)).Elem(), iterMakerUint64String)
+	RegisterInput(reflect.TypeOf((*func(*typex.EventTime, *uint64, *string) bool)(nil)).Elem(), iterMakerETUint64String)
+	RegisterInput(reflect.TypeOf((*func(*uint64, *int) bool)(nil)).Elem(), iterMakerUint64Int)
+	RegisterInput(reflect.TypeOf((*func(*typex.EventTime, *uint64, *int) bool)(nil)).Elem(), iterMakerETUint64Int)
+	RegisterInput(reflect.TypeOf((*func(*uint64, *int8) bool)(nil)).Elem(), iterMakerUint64Int8)
+	RegisterInput(reflect.TypeOf((*func(*typex.EventTime, *uint64, *int8) bool)(nil)).Elem(), iterMakerETUint64Int8)
+	RegisterInput(reflect.TypeOf((*func(*uint64, *int16) bool)(nil)).Elem(), iterMakerUint64Int16)
+	RegisterInput(reflect.TypeOf((*func(*typex.EventTime, *uint64, *int16) bool)(nil)).Elem(), iterMakerETUint64Int16)
+	RegisterInput(reflect.TypeOf((*func(*uint64, *int32) bool)(nil)).Elem(), iterMakerUint64Int32)
+	RegisterInput(reflect.TypeOf((*func(*typex.EventTime, *uint64, *int32) bool)(nil)).Elem(), iterMakerETUint64Int32)
+	RegisterInput(reflect.TypeOf((*func(*uint64, *int64) bool)(nil)).Elem(), iterMakerUint64Int64)
+	RegisterInput(reflect.TypeOf((*func(*typex.EventTime, *uint64, *int64) bool)(nil)).Elem(), iterMakerETUint64Int64)
+	RegisterInput(reflect.TypeOf((*func(*uint64, *uint) bool)(nil)).Elem(), iterMakerUint64Uint)
+	RegisterInput(reflect.TypeOf((*func(*typex.EventTime, *uint64, *uint) bool)(nil)).Elem(), iterMakerETUint64Uint)
+	RegisterInput(reflect.TypeOf((*func(*uint64, *uint8) bool)(nil)).Elem(), iterMakerUint64Uint8)
+	RegisterInput(reflect.TypeOf((*func(*typex.EventTime, *uint64, *uint8) bool)(nil)).Elem(), iterMakerETUint64Uint8)
+	RegisterInput(reflect.TypeOf((*func(*uint64, *uint16) bool)(nil)).Elem(), iterMakerUint64Uint16)
+	RegisterInput(reflect.TypeOf((*func(*typex.EventTime, *uint64, *uint16) bool)(nil)).Elem(), iterMakerETUint64Uint16)
+	RegisterInput(reflect.TypeOf((*func(*uint64, *uint32) bool)(nil)).Elem(), iterMakerUint64Uint32)
+	RegisterInput(reflect.TypeOf((*func(*typex.EventTime, *uint64, *uint32) bool)(nil)).Elem(), iterMakerETUint64Uint32)
+	RegisterInput(reflect.TypeOf((*func(*uint64, *uint64) bool)(nil)).Elem(), iterMakerUint64Uint64)
+	RegisterInput(reflect.TypeOf((*func(*typex.EventTime, *uint64, *uint64) bool)(nil)).Elem(), iterMakerETUint64Uint64)
+	RegisterInput(reflect.TypeOf((*func(*uint64, *float32) bool)(nil)).Elem(), iterMakerUint64Float32)
+	RegisterInput(reflect.TypeOf((*func(*typex.EventTime, *uint64, *float32) bool)(nil)).Elem(), iterMakerETUint64Float32)
+	RegisterInput(reflect.TypeOf((*func(*uint64, *float64) bool)(nil)).Elem(), iterMakerUint64Float64)
+	RegisterInput(reflect.TypeOf((*func(*typex.EventTime, *uint64, *float64) bool)(nil)).Elem(), iterMakerETUint64Float64)
+	RegisterInput(reflect.TypeOf((*func(*uint64, *typex.T) bool)(nil)).Elem(), iterMakerUint64Typex_T)
+	RegisterInput(reflect.TypeOf((*func(*typex.EventTime, *uint64, *typex.T) bool)(nil)).Elem(), iterMakerETUint64Typex_T)
+	RegisterInput(reflect.TypeOf((*func(*uint64, *typex.U) bool)(nil)).Elem(), iterMakerUint64Typex_U)
+	RegisterInput(reflect.TypeOf((*func(*typex.EventTime, *uint64, *typex.U) bool)(nil)).Elem(), iterMakerETUint64Typex_U)
+	RegisterInput(reflect.TypeOf((*func(*uint64, *typex.V) bool)(nil)).Elem(), iterMakerUint64Typex_V)
+	RegisterInput(reflect.TypeOf((*func(*typex.EventTime, *uint64, *typex.V) bool)(nil)).Elem(), iterMakerETUint64Typex_V)
+	RegisterInput(reflect.TypeOf((*func(*uint64, *typex.W) bool)(nil)).Elem(), iterMakerUint64Typex_W)
+	RegisterInput(reflect.TypeOf((*func(*typex.EventTime, *uint64, *typex.W) bool)(nil)).Elem(), iterMakerETUint64Typex_W)
+	RegisterInput(reflect.TypeOf((*func(*uint64, *typex.X) bool)(nil)).Elem(), iterMakerUint64Typex_X)
+	RegisterInput(reflect.TypeOf((*func(*typex.EventTime, *uint64, *typex.X) bool)(nil)).Elem(), iterMakerETUint64Typex_X)
+	RegisterInput(reflect.TypeOf((*func(*uint64, *typex.Y) bool)(nil)).Elem(), iterMakerUint64Typex_Y)
+	RegisterInput(reflect.TypeOf((*func(*typex.EventTime, *uint64, *typex.Y) bool)(nil)).Elem(), iterMakerETUint64Typex_Y)
+	RegisterInput(reflect.TypeOf((*func(*uint64, *typex.Z) bool)(nil)).Elem(), iterMakerUint64Typex_Z)
+	RegisterInput(reflect.TypeOf((*func(*typex.EventTime, *uint64, *typex.Z) bool)(nil)).Elem(), iterMakerETUint64Typex_Z)
+	RegisterInput(reflect.TypeOf((*func(*float32) bool)(nil)).Elem(), iterMakerFloat32)
+	RegisterInput(reflect.TypeOf((*func(*typex.EventTime, *float32) bool)(nil)).Elem(), iterMakerETFloat32)
+	RegisterInput(reflect.TypeOf((*func(*float32, *[]byte) bool)(nil)).Elem(), iterMakerFloat32ByteSlice)
+	RegisterInput(reflect.TypeOf((*func(*typex.EventTime, *float32, *[]byte) bool)(nil)).Elem(), iterMakerETFloat32ByteSlice)
+	RegisterInput(reflect.TypeOf((*func(*float32, *bool) bool)(nil)).Elem(), iterMakerFloat32Bool)
+	RegisterInput(reflect.TypeOf((*func(*typex.EventTime, *float32, *bool) bool)(nil)).Elem(), iterMakerETFloat32Bool)
+	RegisterInput(reflect.TypeOf((*func(*float32, *string) bool)(nil)).Elem(), iterMakerFloat32String)
+	RegisterInput(reflect.TypeOf((*func(*typex.EventTime, *float32, *string) bool)(nil)).Elem(), iterMakerETFloat32String)
+	RegisterInput(reflect.TypeOf((*func(*float32, *int) bool)(nil)).Elem(), iterMakerFloat32Int)
+	RegisterInput(reflect.TypeOf((*func(*typex.EventTime, *float32, *int) bool)(nil)).Elem(), iterMakerETFloat32Int)
+	RegisterInput(reflect.TypeOf((*func(*float32, *int8) bool)(nil)).Elem(), iterMakerFloat32Int8)
+	RegisterInput(reflect.TypeOf((*func(*typex.EventTime, *float32, *int8) bool)(nil)).Elem(), iterMakerETFloat32Int8)
+	RegisterInput(reflect.TypeOf((*func(*float32, *int16) bool)(nil)).Elem(), iterMakerFloat32Int16)
+	RegisterInput(reflect.TypeOf((*func(*typex.EventTime, *float32, *int16) bool)(nil)).Elem(), iterMakerETFloat32Int16)
+	RegisterInput(reflect.TypeOf((*func(*float32, *int32) bool)(nil)).Elem(), iterMakerFloat32Int32)
+	RegisterInput(reflect.TypeOf((*func(*typex.EventTime, *float32, *int32) bool)(nil)).Elem(), iterMakerETFloat32Int32)
+	RegisterInput(reflect.TypeOf((*func(*float32, *int64) bool)(nil)).Elem(), iterMakerFloat32Int64)
+	RegisterInput(reflect.TypeOf((*func(*typex.EventTime, *float32, *int64) bool)(nil)).Elem(), iterMakerETFloat32Int64)
+	RegisterInput(reflect.TypeOf((*func(*float32, *uint) bool)(nil)).Elem(), iterMakerFloat32Uint)
+	RegisterInput(reflect.TypeOf((*func(*typex.EventTime, *float32, *uint) bool)(nil)).Elem(), iterMakerETFloat32Uint)
+	RegisterInput(reflect.TypeOf((*func(*float32, *uint8) bool)(nil)).Elem(), iterMakerFloat32Uint8)
+	RegisterInput(reflect.TypeOf((*func(*typex.EventTime, *float32, *uint8) bool)(nil)).Elem(), iterMakerETFloat32Uint8)
+	RegisterInput(reflect.TypeOf((*func(*float32, *uint16) bool)(nil)).Elem(), iterMakerFloat32Uint16)
+	RegisterInput(reflect.TypeOf((*func(*typex.EventTime, *float32, *uint16) bool)(nil)).Elem(), iterMakerETFloat32Uint16)
+	RegisterInput(reflect.TypeOf((*func(*float32, *uint32) bool)(nil)).Elem(), iterMakerFloat32Uint32)
+	RegisterInput(reflect.TypeOf((*func(*typex.EventTime, *float32, *uint32) bool)(nil)).Elem(), iterMakerETFloat32Uint32)
+	RegisterInput(reflect.TypeOf((*func(*float32, *uint64) bool)(nil)).Elem(), iterMakerFloat32Uint64)
+	RegisterInput(reflect.TypeOf((*func(*typex.EventTime, *float32, *uint64) bool)(nil)).Elem(), iterMakerETFloat32Uint64)
+	RegisterInput(reflect.TypeOf((*func(*float32, *float32) bool)(nil)).Elem(), iterMakerFloat32Float32)
+	RegisterInput(reflect.TypeOf((*func(*typex.EventTime, *float32, *float32) bool)(nil)).Elem(), iterMakerETFloat32Float32)
+	RegisterInput(reflect.TypeOf((*func(*float32, *float64) bool)(nil)).Elem(), iterMakerFloat32Float64)
+	RegisterInput(reflect.TypeOf((*func(*typex.EventTime, *float32, *float64) bool)(nil)).Elem(), iterMakerETFloat32Float64)
+	RegisterInput(reflect.TypeOf((*func(*float32, *typex.T) bool)(nil)).Elem(), iterMakerFloat32Typex_T)
+	RegisterInput(reflect.TypeOf((*func(*typex.EventTime, *float32, *typex.T) bool)(nil)).Elem(), iterMakerETFloat32Typex_T)
+	RegisterInput(reflect.TypeOf((*func(*float32, *typex.U) bool)(nil)).Elem(), iterMakerFloat32Typex_U)
+	RegisterInput(reflect.TypeOf((*func(*typex.EventTime, *float32, *typex.U) bool)(nil)).Elem(), iterMakerETFloat32Typex_U)
+	RegisterInput(reflect.TypeOf((*func(*float32, *typex.V) bool)(nil)).Elem(), iterMakerFloat32Typex_V)
+	RegisterInput(reflect.TypeOf((*func(*typex.EventTime, *float32, *typex.V) bool)(nil)).Elem(), iterMakerETFloat32Typex_V)
+	RegisterInput(reflect.TypeOf((*func(*float32, *typex.W) bool)(nil)).Elem(), iterMakerFloat32Typex_W)
+	RegisterInput(reflect.TypeOf((*func(*typex.EventTime, *float32, *typex.W) bool)(nil)).Elem(), iterMakerETFloat32Typex_W)
+	RegisterInput(reflect.TypeOf((*func(*float32, *typex.X) bool)(nil)).Elem(), iterMakerFloat32Typex_X)
+	RegisterInput(reflect.TypeOf((*func(*typex.EventTime, *float32, *typex.X) bool)(nil)).Elem(), iterMakerETFloat32Typex_X)
+	RegisterInput(reflect.TypeOf((*func(*float32, *typex.Y) bool)(nil)).Elem(), iterMakerFloat32Typex_Y)
+	RegisterInput(reflect.TypeOf((*func(*typex.EventTime, *float32, *typex.Y) bool)(nil)).Elem(), iterMakerETFloat32Typex_Y)
+	RegisterInput(reflect.TypeOf((*func(*float32, *typex.Z) bool)(nil)).Elem(), iterMakerFloat32Typex_Z)
+	RegisterInput(reflect.TypeOf((*func(*typex.EventTime, *float32, *typex.Z) bool)(nil)).Elem(), iterMakerETFloat32Typex_Z)
+	RegisterInput(reflect.TypeOf((*func(*float64) bool)(nil)).Elem(), iterMakerFloat64)
+	RegisterInput(reflect.TypeOf((*func(*typex.EventTime, *float64) bool)(nil)).Elem(), iterMakerETFloat64)
+	RegisterInput(reflect.TypeOf((*func(*float64, *[]byte) bool)(nil)).Elem(), iterMakerFloat64ByteSlice)
+	RegisterInput(reflect.TypeOf((*func(*typex.EventTime, *float64, *[]byte) bool)(nil)).Elem(), iterMakerETFloat64ByteSlice)
+	RegisterInput(reflect.TypeOf((*func(*float64, *bool) bool)(nil)).Elem(), iterMakerFloat64Bool)
+	RegisterInput(reflect.TypeOf((*func(*typex.EventTime, *float64, *bool) bool)(nil)).Elem(), iterMakerETFloat64Bool)
+	RegisterInput(reflect.TypeOf((*func(*float64, *string) bool)(nil)).Elem(), iterMakerFloat64String)
+	RegisterInput(reflect.TypeOf((*func(*typex.EventTime, *float64, *string) bool)(nil)).Elem(), iterMakerETFloat64String)
+	RegisterInput(reflect.TypeOf((*func(*float64, *int) bool)(nil)).Elem(), iterMakerFloat64Int)
+	RegisterInput(reflect.TypeOf((*func(*typex.EventTime, *float64, *int) bool)(nil)).Elem(), iterMakerETFloat64Int)
+	RegisterInput(reflect.TypeOf((*func(*float64, *int8) bool)(nil)).Elem(), iterMakerFloat64Int8)
+	RegisterInput(reflect.TypeOf((*func(*typex.EventTime, *float64, *int8) bool)(nil)).Elem(), iterMakerETFloat64Int8)
+	RegisterInput(reflect.TypeOf((*func(*float64, *int16) bool)(nil)).Elem(), iterMakerFloat64Int16)
+	RegisterInput(reflect.TypeOf((*func(*typex.EventTime, *float64, *int16) bool)(nil)).Elem(), iterMakerETFloat64Int16)
+	RegisterInput(reflect.TypeOf((*func(*float64, *int32) bool)(nil)).Elem(), iterMakerFloat64Int32)
+	RegisterInput(reflect.TypeOf((*func(*typex.EventTime, *float64, *int32) bool)(nil)).Elem(), iterMakerETFloat64Int32)
+	RegisterInput(reflect.TypeOf((*func(*float64, *int64) bool)(nil)).Elem(), iterMakerFloat64Int64)
+	RegisterInput(reflect.TypeOf((*func(*typex.EventTime, *float64, *int64) bool)(nil)).Elem(), iterMakerETFloat64Int64)
+	RegisterInput(reflect.TypeOf((*func(*float64, *uint) bool)(nil)).Elem(), iterMakerFloat64Uint)
+	RegisterInput(reflect.TypeOf((*func(*typex.EventTime, *float64, *uint) bool)(nil)).Elem(), iterMakerETFloat64Uint)
+	RegisterInput(reflect.TypeOf((*func(*float64, *uint8) bool)(nil)).Elem(), iterMakerFloat64Uint8)
+	RegisterInput(reflect.TypeOf((*func(*typex.EventTime, *float64, *uint8) bool)(nil)).Elem(), iterMakerETFloat64Uint8)
+	RegisterInput(reflect.TypeOf((*func(*float64, *uint16) bool)(nil)).Elem(), iterMakerFloat64Uint16)
+	RegisterInput(reflect.TypeOf((*func(*typex.EventTime, *float64, *uint16) bool)(nil)).Elem(), iterMakerETFloat64Uint16)
+	RegisterInput(reflect.TypeOf((*func(*float64, *uint32) bool)(nil)).Elem(), iterMakerFloat64Uint32)
+	RegisterInput(reflect.TypeOf((*func(*typex.EventTime, *float64, *uint32) bool)(nil)).Elem(), iterMakerETFloat64Uint32)
+	RegisterInput(reflect.TypeOf((*func(*float64, *uint64) bool)(nil)).Elem(), iterMakerFloat64Uint64)
+	RegisterInput(reflect.TypeOf((*func(*typex.EventTime, *float64, *uint64) bool)(nil)).Elem(), iterMakerETFloat64Uint64)
+	RegisterInput(reflect.TypeOf((*func(*float64, *float32) bool)(nil)).Elem(), iterMakerFloat64Float32)
+	RegisterInput(reflect.TypeOf((*func(*typex.EventTime, *float64, *float32) bool)(nil)).Elem(), iterMakerETFloat64Float32)
+	RegisterInput(reflect.TypeOf((*func(*float64, *float64) bool)(nil)).Elem(), iterMakerFloat64Float64)
+	RegisterInput(reflect.TypeOf((*func(*typex.EventTime, *float64, *float64) bool)(nil)).Elem(), iterMakerETFloat64Float64)
+	RegisterInput(reflect.TypeOf((*func(*float64, *typex.T) bool)(nil)).Elem(), iterMakerFloat64Typex_T)
+	RegisterInput(reflect.TypeOf((*func(*typex.EventTime, *float64, *typex.T) bool)(nil)).Elem(), iterMakerETFloat64Typex_T)
+	RegisterInput(reflect.TypeOf((*func(*float64, *typex.U) bool)(nil)).Elem(), iterMakerFloat64Typex_U)
+	RegisterInput(reflect.TypeOf((*func(*typex.EventTime, *float64, *typex.U) bool)(nil)).Elem(), iterMakerETFloat64Typex_U)
+	RegisterInput(reflect.TypeOf((*func(*float64, *typex.V) bool)(nil)).Elem(), iterMakerFloat64Typex_V)
+	RegisterInput(reflect.TypeOf((*func(*typex.EventTime, *float64, *typex.V) bool)(nil)).Elem(), iterMakerETFloat64Typex_V)
+	RegisterInput(reflect.TypeOf((*func(*float64, *typex.W) bool)(nil)).Elem(), iterMakerFloat64Typex_W)
+	RegisterInput(reflect.TypeOf((*func(*typex.EventTime, *float64, *typex.W) bool)(nil)).Elem(), iterMakerETFloat64Typex_W)
+	RegisterInput(reflect.TypeOf((*func(*float64, *typex.X) bool)(nil)).Elem(), iterMakerFloat64Typex_X)
+	RegisterInput(reflect.TypeOf((*func(*typex.EventTime, *float64, *typex.X) bool)(nil)).Elem(), iterMakerETFloat64Typex_X)
+	RegisterInput(reflect.TypeOf((*func(*float64, *typex.Y) bool)(nil)).Elem(), iterMakerFloat64Typex_Y)
+	RegisterInput(reflect.TypeOf((*func(*typex.EventTime, *float64, *typex.Y) bool)(nil)).Elem(), iterMakerETFloat64Typex_Y)
+	RegisterInput(reflect.TypeOf((*func(*float64, *typex.Z) bool)(nil)).Elem(), iterMakerFloat64Typex_Z)
+	RegisterInput(reflect.TypeOf((*func(*typex.EventTime, *float64, *typex.Z) bool)(nil)).Elem(), iterMakerETFloat64Typex_Z)
+	RegisterInput(reflect.TypeOf((*func(*typex.T) bool)(nil)).Elem(), iterMakerTypex_T)
+	RegisterInput(reflect.TypeOf((*func(*typex.EventTime, *typex.T) bool)(nil)).Elem(), iterMakerETTypex_T)
+	RegisterInput(reflect.TypeOf((*func(*typex.T, *[]byte) bool)(nil)).Elem(), iterMakerTypex_TByteSlice)
+	RegisterInput(reflect.TypeOf((*func(*typex.EventTime, *typex.T, *[]byte) bool)(nil)).Elem(), iterMakerETTypex_TByteSlice)
+	RegisterInput(reflect.TypeOf((*func(*typex.T, *bool) bool)(nil)).Elem(), iterMakerTypex_TBool)
+	RegisterInput(reflect.TypeOf((*func(*typex.EventTime, *typex.T, *bool) bool)(nil)).Elem(), iterMakerETTypex_TBool)
+	RegisterInput(reflect.TypeOf((*func(*typex.T, *string) bool)(nil)).Elem(), iterMakerTypex_TString)
+	RegisterInput(reflect.TypeOf((*func(*typex.EventTime, *typex.T, *string) bool)(nil)).Elem(), iterMakerETTypex_TString)
+	RegisterInput(reflect.TypeOf((*func(*typex.T, *int) bool)(nil)).Elem(), iterMakerTypex_TInt)
+	RegisterInput(reflect.TypeOf((*func(*typex.EventTime, *typex.T, *int) bool)(nil)).Elem(), iterMakerETTypex_TInt)
+	RegisterInput(reflect.TypeOf((*func(*typex.T, *int8) bool)(nil)).Elem(), iterMakerTypex_TInt8)
+	RegisterInput(reflect.TypeOf((*func(*typex.EventTime, *typex.T, *int8) bool)(nil)).Elem(), iterMakerETTypex_TInt8)
+	RegisterInput(reflect.TypeOf((*func(*typex.T, *int16) bool)(nil)).Elem(), iterMakerTypex_TInt16)
+	RegisterInput(reflect.TypeOf((*func(*typex.EventTime, *typex.T, *int16) bool)(nil)).Elem(), iterMakerETTypex_TInt16)
+	RegisterInput(reflect.TypeOf((*func(*typex.T, *int32) bool)(nil)).Elem(), iterMakerTypex_TInt32)
+	RegisterInput(reflect.TypeOf((*func(*typex.EventTime, *typex.T, *int32) bool)(nil)).Elem(), iterMakerETTypex_TInt32)
+	RegisterInput(reflect.TypeOf((*func(*typex.T, *int64) bool)(nil)).Elem(), iterMakerTypex_TInt64)
+	RegisterInput(reflect.TypeOf((*func(*typex.EventTime, *typex.T, *int64) bool)(nil)).Elem(), iterMakerETTypex_TInt64)
+	RegisterInput(reflect.TypeOf((*func(*typex.T, *uint) bool)(nil)).Elem(), iterMakerTypex_TUint)
+	RegisterInput(reflect.TypeOf((*func(*typex.EventTime, *typex.T, *uint) bool)(nil)).Elem(), iterMakerETTypex_TUint)
+	RegisterInput(reflect.TypeOf((*func(*typex.T, *uint8) bool)(nil)).Elem(), iterMakerTypex_TUint8)
+	RegisterInput(reflect.TypeOf((*func(*typex.EventTime, *typex.T, *uint8) bool)(nil)).Elem(), iterMakerETTypex_TUint8)
+	RegisterInput(reflect.TypeOf((*func(*typex.T, *uint16) bool)(nil)).Elem(), iterMakerTypex_TUint16)
+	RegisterInput(reflect.TypeOf((*func(*typex.EventTime, *typex.T, *uint16) bool)(nil)).Elem(), iterMakerETTypex_TUint16)
+	RegisterInput(reflect.TypeOf((*func(*typex.T, *uint32) bool)(nil)).Elem(), iterMakerTypex_TUint32)
+	RegisterInput(reflect.TypeOf((*func(*typex.EventTime, *typex.T, *uint32) bool)(nil)).Elem(), iterMakerETTypex_TUint32)
+	RegisterInput(reflect.TypeOf((*func(*typex.T, *uint64) bool)(nil)).Elem(), iterMakerTypex_TUint64)
+	RegisterInput(reflect.TypeOf((*func(*typex.EventTime, *typex.T, *uint64) bool)(nil)).Elem(), iterMakerETTypex_TUint64)
+	RegisterInput(reflect.TypeOf((*func(*typex.T, *float32) bool)(nil)).Elem(), iterMakerTypex_TFloat32)
+	RegisterInput(reflect.TypeOf((*func(*typex.EventTime, *typex.T, *float32) bool)(nil)).Elem(), iterMakerETTypex_TFloat32)
+	RegisterInput(reflect.TypeOf((*func(*typex.T, *float64) bool)(nil)).Elem(), iterMakerTypex_TFloat64)
+	RegisterInput(reflect.TypeOf((*func(*typex.EventTime, *typex.T, *float64) bool)(nil)).Elem(), iterMakerETTypex_TFloat64)
+	RegisterInput(reflect.TypeOf((*func(*typex.T, *typex.T) bool)(nil)).Elem(), iterMakerTypex_TTypex_T)
+	RegisterInput(reflect.TypeOf((*func(*typex.EventTime, *typex.T, *typex.T) bool)(nil)).Elem(), iterMakerETTypex_TTypex_T)
+	RegisterInput(reflect.TypeOf((*func(*typex.T, *typex.U) bool)(nil)).Elem(), iterMakerTypex_TTypex_U)
+	RegisterInput(reflect.TypeOf((*func(*typex.EventTime, *typex.T, *typex.U) bool)(nil)).Elem(), iterMakerETTypex_TTypex_U)
+	RegisterInput(reflect.TypeOf((*func(*typex.T, *typex.V) bool)(nil)).Elem(), iterMakerTypex_TTypex_V)
+	RegisterInput(reflect.TypeOf((*func(*typex.EventTime, *typex.T, *typex.V) bool)(nil)).Elem(), iterMakerETTypex_TTypex_V)
+	RegisterInput(reflect.TypeOf((*func(*typex.T, *typex.W) bool)(nil)).Elem(), iterMakerTypex_TTypex_W)
+	RegisterInput(reflect.TypeOf((*func(*typex.EventTime, *typex.T, *typex.W) bool)(nil)).Elem(), iterMakerETTypex_TTypex_W)
+	RegisterInput(reflect.TypeOf((*func(*typex.T, *typex.X) bool)(nil)).Elem(), iterMakerTypex_TTypex_X)
+	RegisterInput(reflect.TypeOf((*func(*typex.EventTime, *typex.T, *typex.X) bool)(nil)).Elem(), iterMakerETTypex_TTypex_X)
+	RegisterInput(reflect.TypeOf((*func(*typex.T, *typex.Y) bool)(nil)).Elem(), iterMakerTypex_TTypex_Y)
+	RegisterInput(reflect.TypeOf((*func(*typex.EventTime, *typex.T, *typex.Y) bool)(nil)).Elem(), iterMakerETTypex_TTypex_Y)
+	RegisterInput(reflect.TypeOf((*func(*typex.T, *typex.Z) bool)(nil)).Elem(), iterMakerTypex_TTypex_Z)
+	RegisterInput(reflect.TypeOf((*func(*typex.EventTime, *typex.T, *typex.Z) bool)(nil)).Elem(), iterMakerETTypex_TTypex_Z)
+	RegisterInput(reflect.TypeOf((*func(*typex.U) bool)(nil)).Elem(), iterMakerTypex_U)
+	RegisterInput(reflect.TypeOf((*func(*typex.EventTime, *typex.U) bool)(nil)).Elem(), iterMakerETTypex_U)
+	RegisterInput(reflect.TypeOf((*func(*typex.U, *[]byte) bool)(nil)).Elem(), iterMakerTypex_UByteSlice)
+	RegisterInput(reflect.TypeOf((*func(*typex.EventTime, *typex.U, *[]byte) bool)(nil)).Elem(), iterMakerETTypex_UByteSlice)
+	RegisterInput(reflect.TypeOf((*func(*typex.U, *bool) bool)(nil)).Elem(), iterMakerTypex_UBool)
+	RegisterInput(reflect.TypeOf((*func(*typex.EventTime, *typex.U, *bool) bool)(nil)).Elem(), iterMakerETTypex_UBool)
+	RegisterInput(reflect.TypeOf((*func(*typex.U, *string) bool)(nil)).Elem(), iterMakerTypex_UString)
+	RegisterInput(reflect.TypeOf((*func(*typex.EventTime, *typex.U, *string) bool)(nil)).Elem(), iterMakerETTypex_UString)
+	RegisterInput(reflect.TypeOf((*func(*typex.U, *int) bool)(nil)).Elem(), iterMakerTypex_UInt)
+	RegisterInput(reflect.TypeOf((*func(*typex.EventTime, *typex.U, *int) bool)(nil)).Elem(), iterMakerETTypex_UInt)
+	RegisterInput(reflect.TypeOf((*func(*typex.U, *int8) bool)(nil)).Elem(), iterMakerTypex_UInt8)
+	RegisterInput(reflect.TypeOf((*func(*typex.EventTime, *typex.U, *int8) bool)(nil)).Elem(), iterMakerETTypex_UInt8)
+	RegisterInput(reflect.TypeOf((*func(*typex.U, *int16) bool)(nil)).Elem(), iterMakerTypex_UInt16)
+	RegisterInput(reflect.TypeOf((*func(*typex.EventTime, *typex.U, *int16) bool)(nil)).Elem(), iterMakerETTypex_UInt16)
+	RegisterInput(reflect.TypeOf((*func(*typex.U, *int32) bool)(nil)).Elem(), iterMakerTypex_UInt32)
+	RegisterInput(reflect.TypeOf((*func(*typex.EventTime, *typex.U, *int32) bool)(nil)).Elem(), iterMakerETTypex_UInt32)
+	RegisterInput(reflect.TypeOf((*func(*typex.U, *int64) bool)(nil)).Elem(), iterMakerTypex_UInt64)
+	RegisterInput(reflect.TypeOf((*func(*typex.EventTime, *typex.U, *int64) bool)(nil)).Elem(), iterMakerETTypex_UInt64)
+	RegisterInput(reflect.TypeOf((*func(*typex.U, *uint) bool)(nil)).Elem(), iterMakerTypex_UUint)
+	RegisterInput(reflect.TypeOf((*func(*typex.EventTime, *typex.U, *uint) bool)(nil)).Elem(), iterMakerETTypex_UUint)
+	RegisterInput(reflect.TypeOf((*func(*typex.U, *uint8) bool)(nil)).Elem(), iterMakerTypex_UUint8)
+	RegisterInput(reflect.TypeOf((*func(*typex.EventTime, *typex.U, *uint8) bool)(nil)).Elem(), iterMakerETTypex_UUint8)
+	RegisterInput(reflect.TypeOf((*func(*typex.U, *uint16) bool)(nil)).Elem(), iterMakerTypex_UUint16)
+	RegisterInput(reflect.TypeOf((*func(*typex.EventTime, *typex.U, *uint16) bool)(nil)).Elem(), iterMakerETTypex_UUint16)
+	RegisterInput(reflect.TypeOf((*func(*typex.U, *uint32) bool)(nil)).Elem(), iterMakerTypex_UUint32)
+	RegisterInput(reflect.TypeOf((*func(*typex.EventTime, *typex.U, *uint32) bool)(nil)).Elem(), iterMakerETTypex_UUint32)
+	RegisterInput(reflect.TypeOf((*func(*typex.U, *uint64) bool)(nil)).Elem(), iterMakerTypex_UUint64)
+	RegisterInput(reflect.TypeOf((*func(*typex.EventTime, *typex.U, *uint64) bool)(nil)).Elem(), iterMakerETTypex_UUint64)
+	RegisterInput(reflect.TypeOf((*func(*typex.U, *float32) bool)(nil)).Elem(), iterMakerTypex_UFloat32)
+	RegisterInput(reflect.TypeOf((*func(*typex.EventTime, *typex.U, *float32) bool)(nil)).Elem(), iterMakerETTypex_UFloat32)
+	RegisterInput(reflect.TypeOf((*func(*typex.U, *float64) bool)(nil)).Elem(), iterMakerTypex_UFloat64)
+	RegisterInput(reflect.TypeOf((*func(*typex.EventTime, *typex.U, *float64) bool)(nil)).Elem(), iterMakerETTypex_UFloat64)
+	RegisterInput(reflect.TypeOf((*func(*typex.U, *typex.T) bool)(nil)).Elem(), iterMakerTypex_UTypex_T)
+	RegisterInput(reflect.TypeOf((*func(*typex.EventTime, *typex.U, *typex.T) bool)(nil)).Elem(), iterMakerETTypex_UTypex_T)
+	RegisterInput(reflect.TypeOf((*func(*typex.U, *typex.U) bool)(nil)).Elem(), iterMakerTypex_UTypex_U)
+	RegisterInput(reflect.TypeOf((*func(*typex.EventTime, *typex.U, *typex.U) bool)(nil)).Elem(), iterMakerETTypex_UTypex_U)
+	RegisterInput(reflect.TypeOf((*func(*typex.U, *typex.V) bool)(nil)).Elem(), iterMakerTypex_UTypex_V)
+	RegisterInput(reflect.TypeOf((*func(*typex.EventTime, *typex.U, *typex.V) bool)(nil)).Elem(), iterMakerETTypex_UTypex_V)
+	RegisterInput(reflect.TypeOf((*func(*typex.U, *typex.W) bool)(nil)).Elem(), iterMakerTypex_UTypex_W)
+	RegisterInput(reflect.TypeOf((*func(*typex.EventTime, *typex.U, *typex.W) bool)(nil)).Elem(), iterMakerETTypex_UTypex_W)
+	RegisterInput(reflect.TypeOf((*func(*typex.U, *typex.X) bool)(nil)).Elem(), iterMakerTypex_UTypex_X)
+	RegisterInput(reflect.TypeOf((*func(*typex.EventTime, *typex.U, *typex.X) bool)(nil)).Elem(), iterMakerETTypex_UTypex_X)
+	RegisterInput(reflect.TypeOf((*func(*typex.U, *typex.Y) bool)(nil)).Elem(), iterMakerTypex_UTypex_Y)
+	RegisterInput(reflect.TypeOf((*func(*typex.EventTime, *typex.U, *typex.Y) bool)(nil)).Elem(), iterMakerETTypex_UTypex_Y)
+	RegisterInput(reflect.TypeOf((*func(*typex.U, *typex.Z) bool)(nil)).Elem(), iterMakerTypex_UTypex_Z)
+	RegisterInput(reflect.TypeOf((*func(*typex.EventTime, *typex.U, *typex.Z) bool)(nil)).Elem(), iterMakerETTypex_UTypex_Z)
+	RegisterInput(reflect.TypeOf((*func(*typex.V) bool)(nil)).Elem(), iterMakerTypex_V)
+	RegisterInput(reflect.TypeOf((*func(*typex.EventTime, *typex.V) bool)(nil)).Elem(), iterMakerETTypex_V)
+	RegisterInput(reflect.TypeOf((*func(*typex.V, *[]byte) bool)(nil)).Elem(), iterMakerTypex_VByteSlice)
+	RegisterInput(reflect.TypeOf((*func(*typex.EventTime, *typex.V, *[]byte) bool)(nil)).Elem(), iterMakerETTypex_VByteSlice)
+	RegisterInput(reflect.TypeOf((*func(*typex.V, *bool) bool)(nil)).Elem(), iterMakerTypex_VBool)
+	RegisterInput(reflect.TypeOf((*func(*typex.EventTime, *typex.V, *bool) bool)(nil)).Elem(), iterMakerETTypex_VBool)
+	RegisterInput(reflect.TypeOf((*func(*typex.V, *string) bool)(nil)).Elem(), iterMakerTypex_VString)
+	RegisterInput(reflect.TypeOf((*func(*typex.EventTime, *typex.V, *string) bool)(nil)).Elem(), iterMakerETTypex_VString)
+	RegisterInput(reflect.TypeOf((*func(*typex.V, *int) bool)(nil)).Elem(), iterMakerTypex_VInt)
+	RegisterInput(reflect.TypeOf((*func(*typex.EventTime, *typex.V, *int) bool)(nil)).Elem(), iterMakerETTypex_VInt)
+	RegisterInput(reflect.TypeOf((*func(*typex.V, *int8) bool)(nil)).Elem(), iterMakerTypex_VInt8)
+	RegisterInput(reflect.TypeOf((*func(*typex.EventTime, *typex.V, *int8) bool)(nil)).Elem(), iterMakerETTypex_VInt8)
+	RegisterInput(reflect.TypeOf((*func(*typex.V, *int16) bool)(nil)).Elem(), iterMakerTypex_VInt16)
+	RegisterInput(reflect.TypeOf((*func(*typex.EventTime, *typex.V, *int16) bool)(nil)).Elem(), iterMakerETTypex_VInt16)
+	RegisterInput(reflect.TypeOf((*func(*typex.V, *int32) bool)(nil)).Elem(), iterMakerTypex_VInt32)
+	RegisterInput(reflect.TypeOf((*func(*typex.EventTime, *typex.V, *int32) bool)(nil)).Elem(), iterMakerETTypex_VInt32)
+	RegisterInput(reflect.TypeOf((*func(*typex.V, *int64) bool)(nil)).Elem(), iterMakerTypex_VInt64)
+	RegisterInput(reflect.TypeOf((*func(*typex.EventTime, *typex.V, *int64) bool)(nil)).Elem(), iterMakerETTypex_VInt64)
+	RegisterInput(reflect.TypeOf((*func(*typex.V, *uint) bool)(nil)).Elem(), iterMakerTypex_VUint)
+	RegisterInput(reflect.TypeOf((*func(*typex.EventTime, *typex.V, *uint) bool)(nil)).Elem(), iterMakerETTypex_VUint)
+	RegisterInput(reflect.TypeOf((*func(*typex.V, *uint8) bool)(nil)).Elem(), iterMakerTypex_VUint8)
+	RegisterInput(reflect.TypeOf((*func(*typex.EventTime, *typex.V, *uint8) bool)(nil)).Elem(), iterMakerETTypex_VUint8)
+	RegisterInput(reflect.TypeOf((*func(*typex.V, *uint16) bool)(nil)).Elem(), iterMakerTypex_VUint16)
+	RegisterInput(reflect.TypeOf((*func(*typex.EventTime, *typex.V, *uint16) bool)(nil)).Elem(), iterMakerETTypex_VUint16)
+	RegisterInput(reflect.TypeOf((*func(*typex.V, *uint32) bool)(nil)).Elem(), iterMakerTypex_VUint32)
+	RegisterInput(reflect.TypeOf((*func(*typex.EventTime, *typex.V, *uint32) bool)(nil)).Elem(), iterMakerETTypex_VUint32)
+	RegisterInput(reflect.TypeOf((*func(*typex.V, *uint64) bool)(nil)).Elem(), iterMakerTypex_VUint64)
+	RegisterInput(reflect.TypeOf((*func(*typex.EventTime, *typex.V, *uint64) bool)(nil)).Elem(), iterMakerETTypex_VUint64)
+	RegisterInput(reflect.TypeOf((*func(*typex.V, *float32) bool)(nil)).Elem(), iterMakerTypex_VFloat32)
+	RegisterInput(reflect.TypeOf((*func(*typex.EventTime, *typex.V, *float32) bool)(nil)).Elem(), iterMakerETTypex_VFloat32)
+	RegisterInput(reflect.TypeOf((*func(*typex.V, *float64) bool)(nil)).Elem(), iterMakerTypex_VFloat64)
+	RegisterInput(reflect.TypeOf((*func(*typex.EventTime, *typex.V, *float64) bool)(nil)).Elem(), iterMakerETTypex_VFloat64)
+	RegisterInput(reflect.TypeOf((*func(*typex.V, *typex.T) bool)(nil)).Elem(), iterMakerTypex_VTypex_T)
+	RegisterInput(reflect.TypeOf((*func(*typex.EventTime, *typex.V, *typex.T) bool)(nil)).Elem(), iterMakerETTypex_VTypex_T)
+	RegisterInput(reflect.TypeOf((*func(*typex.V, *typex.U) bool)(nil)).Elem(), iterMakerTypex_VTypex_U)
+	RegisterInput(reflect.TypeOf((*func(*typex.EventTime, *typex.V, *typex.U) bool)(nil)).Elem(), iterMakerETTypex_VTypex_U)
+	RegisterInput(reflect.TypeOf((*func(*typex.V, *typex.V) bool)(nil)).Elem(), iterMakerTypex_VTypex_V)
+	RegisterInput(reflect.TypeOf((*func(*typex.EventTime, *typex.V, *typex.V) bool)(nil)).Elem(), iterMakerETTypex_VTypex_V)
+	RegisterInput(reflect.TypeOf((*func(*typex.V, *typex.W) bool)(nil)).Elem(), iterMakerTypex_VTypex_W)
+	RegisterInput(reflect.TypeOf((*func(*typex.EventTime, *typex.V, *typex.W) bool)(nil)).Elem(), iterMakerETTypex_VTypex_W)
+	RegisterInput(reflect.TypeOf((*func(*typex.V, *typex.X) bool)(nil)).Elem(), iterMakerTypex_VTypex_X)
+	RegisterInput(reflect.TypeOf((*func(*typex.EventTime, *typex.V, *typex.X) bool)(nil)).Elem(), iterMakerETTypex_VTypex_X)
+	RegisterInput(reflect.TypeOf((*func(*typex.V, *typex.Y) bool)(nil)).Elem(), iterMakerTypex_VTypex_Y)
+	RegisterInput(reflect.TypeOf((*func(*typex.EventTime, *typex.V, *typex.Y) bool)(nil)).Elem(), iterMakerETTypex_VTypex_Y)
+	RegisterInput(reflect.TypeOf((*func(*typex.V, *typex.Z) bool)(nil)).Elem(), iterMakerTypex_VTypex_Z)
+	RegisterInput(reflect.TypeOf((*func(*typex.EventTime, *typex.V, *typex.Z) bool)(nil)).Elem(), iterMakerETTypex_VTypex_Z)
+	RegisterInput(reflect.TypeOf((*func(*typex.W) bool)(nil)).Elem(), iterMakerTypex_W)
+	RegisterInput(reflect.TypeOf((*func(*typex.EventTime, *typex.W) bool)(nil)).Elem(), iterMakerETTypex_W)
+	RegisterInput(reflect.TypeOf((*func(*typex.W, *[]byte) bool)(nil)).Elem(), iterMakerTypex_WByteSlice)
+	RegisterInput(reflect.TypeOf((*func(*typex.EventTime, *typex.W, *[]byte) bool)(nil)).Elem(), iterMakerETTypex_WByteSlice)
+	RegisterInput(reflect.TypeOf((*func(*typex.W, *bool) bool)(nil)).Elem(), iterMakerTypex_WBool)
+	RegisterInput(reflect.TypeOf((*func(*typex.EventTime, *typex.W, *bool) bool)(nil)).Elem(), iterMakerETTypex_WBool)
+	RegisterInput(reflect.TypeOf((*func(*typex.W, *string) bool)(nil)).Elem(), iterMakerTypex_WString)
+	RegisterInput(reflect.TypeOf((*func(*typex.EventTime, *typex.W, *string) bool)(nil)).Elem(), iterMakerETTypex_WString)
+	RegisterInput(reflect.TypeOf((*func(*typex.W, *int) bool)(nil)).Elem(), iterMakerTypex_WInt)
+	RegisterInput(reflect.TypeOf((*func(*typex.EventTime, *typex.W, *int) bool)(nil)).Elem(), iterMakerETTypex_WInt)
+	RegisterInput(reflect.TypeOf((*func(*typex.W, *int8) bool)(nil)).Elem(), iterMakerTypex_WInt8)
+	RegisterInput(reflect.TypeOf((*func(*typex.EventTime, *typex.W, *int8) bool)(nil)).Elem(), iterMakerETTypex_WInt8)
+	RegisterInput(reflect.TypeOf((*func(*typex.W, *int16) bool)(nil)).Elem(), iterMakerTypex_WInt16)
+	RegisterInput(reflect.TypeOf((*func(*typex.EventTime, *typex.W, *int16) bool)(nil)).Elem(), iterMakerETTypex_WInt16)
+	RegisterInput(reflect.TypeOf((*func(*typex.W, *int32) bool)(nil)).Elem(), iterMakerTypex_WInt32)
+	RegisterInput(reflect.TypeOf((*func(*typex.EventTime, *typex.W, *int32) bool)(nil)).Elem(), iterMakerETTypex_WInt32)
+	RegisterInput(reflect.TypeOf((*func(*typex.W, *int64) bool)(nil)).Elem(), iterMakerTypex_WInt64)
+	RegisterInput(reflect.TypeOf((*func(*typex.EventTime, *typex.W, *int64) bool)(nil)).Elem(), iterMakerETTypex_WInt64)
+	RegisterInput(reflect.TypeOf((*func(*typex.W, *uint) bool)(nil)).Elem(), iterMakerTypex_WUint)
+	RegisterInput(reflect.TypeOf((*func(*typex.EventTime, *typex.W, *uint) bool)(nil)).Elem(), iterMakerETTypex_WUint)
+	RegisterInput(reflect.TypeOf((*func(*typex.W, *uint8) bool)(nil)).Elem(), iterMakerTypex_WUint8)
+	RegisterInput(reflect.TypeOf((*func(*typex.EventTime, *typex.W, *uint8) bool)(nil)).Elem(), iterMakerETTypex_WUint8)
+	RegisterInput(reflect.TypeOf((*func(*typex.W, *uint16) bool)(nil)).Elem(), iterMakerTypex_WUint16)
+	RegisterInput(reflect.TypeOf((*func(*typex.EventTime, *typex.W, *uint16) bool)(nil)).Elem(), iterMakerETTypex_WUint16)
+	RegisterInput(reflect.TypeOf((*func(*typex.W, *uint32) bool)(nil)).Elem(), iterMakerTypex_WUint32)
+	RegisterInput(reflect.TypeOf((*func(*typex.EventTime, *typex.W, *uint32) bool)(nil)).Elem(), iterMakerETTypex_WUint32)
+	RegisterInput(reflect.TypeOf((*func(*typex.W, *uint64) bool)(nil)).Elem(), iterMakerTypex_WUint64)
+	RegisterInput(reflect.TypeOf((*func(*typex.EventTime, *typex.W, *uint64) bool)(nil)).Elem(), iterMakerETTypex_WUint64)
+	RegisterInput(reflect.TypeOf((*func(*typex.W, *float32) bool)(nil)).Elem(), iterMakerTypex_WFloat32)
+	RegisterInput(reflect.TypeOf((*func(*typex.EventTime, *typex.W, *float32) bool)(nil)).Elem(), iterMakerETTypex_WFloat32)
+	RegisterInput(reflect.TypeOf((*func(*typex.W, *float64) bool)(nil)).Elem(), iterMakerTypex_WFloat64)
+	RegisterInput(reflect.TypeOf((*func(*typex.EventTime, *typex.W, *float64) bool)(nil)).Elem(), iterMakerETTypex_WFloat64)
+	RegisterInput(reflect.TypeOf((*func(*typex.W, *typex.T) bool)(nil)).Elem(), iterMakerTypex_WTypex_T)
+	RegisterInput(reflect.TypeOf((*func(*typex.EventTime, *typex.W, *typex.T) bool)(nil)).Elem(), iterMakerETTypex_WTypex_T)
+	RegisterInput(reflect.TypeOf((*func(*typex.W, *typex.U) bool)(nil)).Elem(), iterMakerTypex_WTypex_U)
+	RegisterInput(reflect.TypeOf((*func(*typex.EventTime, *typex.W, *typex.U) bool)(nil)).Elem(), iterMakerETTypex_WTypex_U)
+	RegisterInput(reflect.TypeOf((*func(*typex.W, *typex.V) bool)(nil)).Elem(), iterMakerTypex_WTypex_V)
+	RegisterInput(reflect.TypeOf((*func(*typex.EventTime, *typex.W, *typex.V) bool)(nil)).Elem(), iterMakerETTypex_WTypex_V)
+	RegisterInput(reflect.TypeOf((*func(*typex.W, *typex.W) bool)(nil)).Elem(), iterMakerTypex_WTypex_W)
+	RegisterInput(reflect.TypeOf((*func(*typex.EventTime, *typex.W, *typex.W) bool)(nil)).Elem(), iterMakerETTypex_WTypex_W)
+	RegisterInput(reflect.TypeOf((*func(*typex.W, *typex.X) bool)(nil)).Elem(), iterMakerTypex_WTypex_X)
+	RegisterInput(reflect.TypeOf((*func(*typex.EventTime, *typex.W, *typex.X) bool)(nil)).Elem(), iterMakerETTypex_WTypex_X)
+	RegisterInput(reflect.TypeOf((*func(*typex.W, *typex.Y) bool)(nil)).Elem(), iterMakerTypex_WTypex_Y)
+	RegisterInput(reflect.TypeOf((*func(*typex.EventTime, *typex.W, *typex.Y) bool)(nil)).Elem(), iterMakerETTypex_WTypex_Y)
+	RegisterInput(reflect.TypeOf((*func(*typex.W, *typex.Z) bool)(nil)).Elem(), iterMakerTypex_WTypex_Z)
+	RegisterInput(reflect.TypeOf((*func(*typex.EventTime, *typex.W, *typex.Z) bool)(nil)).Elem(), iterMakerETTypex_WTypex_Z)
+	RegisterInput(reflect.TypeOf((*func(*typex.X) bool)(nil)).Elem(), iterMakerTypex_X)
+	RegisterInput(reflect.TypeOf((*func(*typex.EventTime, *typex.X) bool)(nil)).Elem(), iterMakerETTypex_X)
+	RegisterInput(reflect.TypeOf((*func(*typex.X, *[]byte) bool)(nil)).Elem(), iterMakerTypex_XByteSlice)
+	RegisterInput(reflect.TypeOf((*func(*typex.EventTime, *typex.X, *[]byte) bool)(nil)).Elem(), iterMakerETTypex_XByteSlice)
+	RegisterInput(reflect.TypeOf((*func(*typex.X, *bool) bool)(nil)).Elem(), iterMakerTypex_XBool)
+	RegisterInput(reflect.TypeOf((*func(*typex.EventTime, *typex.X, *bool) bool)(nil)).Elem(), iterMakerETTypex_XBool)
+	RegisterInput(reflect.TypeOf((*func(*typex.X, *string) bool)(nil)).Elem(), iterMakerTypex_XString)
+	RegisterInput(reflect.TypeOf((*func(*typex.EventTime, *typex.X, *string) bool)(nil)).Elem(), iterMakerETTypex_XString)
+	RegisterInput(reflect.TypeOf((*func(*typex.X, *int) bool)(nil)).Elem(), iterMakerTypex_XInt)
+	RegisterInput(reflect.TypeOf((*func(*typex.EventTime, *typex.X, *int) bool)(nil)).Elem(), iterMakerETTypex_XInt)
+	RegisterInput(reflect.TypeOf((*func(*typex.X, *int8) bool)(nil)).Elem(), iterMakerTypex_XInt8)
+	RegisterInput(reflect.TypeOf((*func(*typex.EventTime, *typex.X, *int8) bool)(nil)).Elem(), iterMakerETTypex_XInt8)
+	RegisterInput(reflect.TypeOf((*func(*typex.X, *int16) bool)(nil)).Elem(), iterMakerTypex_XInt16)
+	RegisterInput(reflect.TypeOf((*func(*typex.EventTime, *typex.X, *int16) bool)(nil)).Elem(), iterMakerETTypex_XInt16)
+	RegisterInput(reflect.TypeOf((*func(*typex.X, *int32) bool)(nil)).Elem(), iterMakerTypex_XInt32)
+	RegisterInput(reflect.TypeOf((*func(*typex.EventTime, *typex.X, *int32) bool)(nil)).Elem(), iterMakerETTypex_XInt32)
+	RegisterInput(reflect.TypeOf((*func(*typex.X, *int64) bool)(nil)).Elem(), iterMakerTypex_XInt64)
+	RegisterInput(reflect.TypeOf((*func(*typex.EventTime, *typex.X, *int64) bool)(nil)).Elem(), iterMakerETTypex_XInt64)
+	RegisterInput(reflect.TypeOf((*func(*typex.X, *uint) bool)(nil)).Elem(), iterMakerTypex_XUint)
+	RegisterInput(reflect.TypeOf((*func(*typex.EventTime, *typex.X, *uint) bool)(nil)).Elem(), iterMakerETTypex_XUint)
+	RegisterInput(reflect.TypeOf((*func(*typex.X, *uint8) bool)(nil)).Elem(), iterMakerTypex_XUint8)
+	RegisterInput(reflect.TypeOf((*func(*typex.EventTime, *typex.X, *uint8) bool)(nil)).Elem(), iterMakerETTypex_XUint8)
+	RegisterInput(reflect.TypeOf((*func(*typex.X, *uint16) bool)(nil)).Elem(), iterMakerTypex_XUint16)
+	RegisterInput(reflect.TypeOf((*func(*typex.EventTime, *typex.X, *uint16) bool)(nil)).Elem(), iterMakerETTypex_XUint16)
+	RegisterInput(reflect.TypeOf((*func(*typex.X, *uint32) bool)(nil)).Elem(), iterMakerTypex_XUint32)
+	RegisterInput(reflect.TypeOf((*func(*typex.EventTime, *typex.X, *uint32) bool)(nil)).Elem(), iterMakerETTypex_XUint32)
+	RegisterInput(reflect.TypeOf((*func(*typex.X, *uint64) bool)(nil)).Elem(), iterMakerTypex_XUint64)
+	RegisterInput(reflect.TypeOf((*func(*typex.EventTime, *typex.X, *uint64) bool)(nil)).Elem(), iterMakerETTypex_XUint64)
+	RegisterInput(reflect.TypeOf((*func(*typex.X, *float32) bool)(nil)).Elem(), iterMakerTypex_XFloat32)
+	RegisterInput(reflect.TypeOf((*func(*typex.EventTime, *typex.X, *float32) bool)(nil)).Elem(), iterMakerETTypex_XFloat32)
+	RegisterInput(reflect.TypeOf((*func(*typex.X, *float64) bool)(nil)).Elem(), iterMakerTypex_XFloat64)
+	RegisterInput(reflect.TypeOf((*func(*typex.EventTime, *typex.X, *float64) bool)(nil)).Elem(), iterMakerETTypex_XFloat64)
+	RegisterInput(reflect.TypeOf((*func(*typex.X, *typex.T) bool)(nil)).Elem(), iterMakerTypex_XTypex_T)
+	RegisterInput(reflect.TypeOf((*func(*typex.EventTime, *typex.X, *typex.T) bool)(nil)).Elem(), iterMakerETTypex_XTypex_T)
+	RegisterInput(reflect.TypeOf((*func(*typex.X, *typex.U) bool)(nil)).Elem(), iterMakerTypex_XTypex_U)
+	RegisterInput(reflect.TypeOf((*func(*typex.EventTime, *typex.X, *typex.U) bool)(nil)).Elem(), iterMakerETTypex_XTypex_U)
+	RegisterInput(reflect.TypeOf((*func(*typex.X, *typex.V) bool)(nil)).Elem(), iterMakerTypex_XTypex_V)
+	RegisterInput(reflect.TypeOf((*func(*typex.EventTime, *typex.X, *typex.V) bool)(nil)).Elem(), iterMakerETTypex_XTypex_V)
+	RegisterInput(reflect.TypeOf((*func(*typex.X, *typex.W) bool)(nil)).Elem(), iterMakerTypex_XTypex_W)
+	RegisterInput(reflect.TypeOf((*func(*typex.EventTime, *typex.X, *typex.W) bool)(nil)).Elem(), iterMakerETTypex_XTypex_W)
+	RegisterInput(reflect.TypeOf((*func(*typex.X, *typex.X) bool)(nil)).Elem(), iterMakerTypex_XTypex_X)
+	RegisterInput(reflect.TypeOf((*func(*typex.EventTime, *typex.X, *typex.X) bool)(nil)).Elem(), iterMakerETTypex_XTypex_X)
+	RegisterInput(reflect.TypeOf((*func(*typex.X, *typex.Y) bool)(nil)).Elem(), iterMakerTypex_XTypex_Y)
+	RegisterInput(reflect.TypeOf((*func(*typex.EventTime, *typex.X, *typex.Y) bool)(nil)).Elem(), iterMakerETTypex_XTypex_Y)
+	RegisterInput(reflect.TypeOf((*func(*typex.X, *typex.Z) bool)(nil)).Elem(), iterMakerTypex_XTypex_Z)
+	RegisterInput(reflect.TypeOf((*func(*typex.EventTime, *typex.X, *typex.Z) bool)(nil)).Elem(), iterMakerETTypex_XTypex_Z)
+	RegisterInput(reflect.TypeOf((*func(*typex.Y) bool)(nil)).Elem(), iterMakerTypex_Y)
+	RegisterInput(reflect.TypeOf((*func(*typex.EventTime, *typex.Y) bool)(nil)).Elem(), iterMakerETTypex_Y)
+	RegisterInput(reflect.TypeOf((*func(*typex.Y, *[]byte) bool)(nil)).Elem(), iterMakerTypex_YByteSlice)
+	RegisterInput(reflect.TypeOf((*func(*typex.EventTime, *typex.Y, *[]byte) bool)(nil)).Elem(), iterMakerETTypex_YByteSlice)
+	RegisterInput(reflect.TypeOf((*func(*typex.Y, *bool) bool)(nil)).Elem(), iterMakerTypex_YBool)
+	RegisterInput(reflect.TypeOf((*func(*typex.EventTime, *typex.Y, *bool) bool)(nil)).Elem(), iterMakerETTypex_YBool)
+	RegisterInput(reflect.TypeOf((*func(*typex.Y, *string) bool)(nil)).Elem(), iterMakerTypex_YString)
+	RegisterInput(reflect.TypeOf((*func(*typex.EventTime, *typex.Y, *string) bool)(nil)).Elem(), iterMakerETTypex_YString)
+	RegisterInput(reflect.TypeOf((*func(*typex.Y, *int) bool)(nil)).Elem(), iterMakerTypex_YInt)
+	RegisterInput(reflect.TypeOf((*func(*typex.EventTime, *typex.Y, *int) bool)(nil)).Elem(), iterMakerETTypex_YInt)
+	RegisterInput(reflect.TypeOf((*func(*typex.Y, *int8) bool)(nil)).Elem(), iterMakerTypex_YInt8)
+	RegisterInput(reflect.TypeOf((*func(*typex.EventTime, *typex.Y, *int8) bool)(nil)).Elem(), iterMakerETTypex_YInt8)
+	RegisterInput(reflect.TypeOf((*func(*typex.Y, *int16) bool)(nil)).Elem(), iterMakerTypex_YInt16)
+	RegisterInput(reflect.TypeOf((*func(*typex.EventTime, *typex.Y, *int16) bool)(nil)).Elem(), iterMakerETTypex_YInt16)
+	RegisterInput(reflect.TypeOf((*func(*typex.Y, *int32) bool)(nil)).Elem(), iterMakerTypex_YInt32)
+	RegisterInput(reflect.TypeOf((*func(*typex.EventTime, *typex.Y, *int32) bool)(nil)).Elem(), iterMakerETTypex_YInt32)
+	RegisterInput(reflect.TypeOf((*func(*typex.Y, *int64) bool)(nil)).Elem(), iterMakerTypex_YInt64)
+	RegisterInput(reflect.TypeOf((*func(*typex.EventTime, *typex.Y, *int64) bool)(nil)).Elem(), iterMakerETTypex_YInt64)
+	RegisterInput(reflect.TypeOf((*func(*typex.Y, *uint) bool)(nil)).Elem(), iterMakerTypex_YUint)
+	RegisterInput(reflect.TypeOf((*func(*typex.EventTime, *typex.Y, *uint) bool)(nil)).Elem(), iterMakerETTypex_YUint)
+	RegisterInput(reflect.TypeOf((*func(*typex.Y, *uint8) bool)(nil)).Elem(), iterMakerTypex_YUint8)
+	RegisterInput(reflect.TypeOf((*func(*typex.EventTime, *typex.Y, *uint8) bool)(nil)).Elem(), iterMakerETTypex_YUint8)
+	RegisterInput(reflect.TypeOf((*func(*typex.Y, *uint16) bool)(nil)).Elem(), iterMakerTypex_YUint16)
+	RegisterInput(reflect.TypeOf((*func(*typex.EventTime, *typex.Y, *uint16) bool)(nil)).Elem(), iterMakerETTypex_YUint16)
+	RegisterInput(reflect.TypeOf((*func(*typex.Y, *uint32) bool)(nil)).Elem(), iterMakerTypex_YUint32)
+	RegisterInput(reflect.TypeOf((*func(*typex.EventTime, *typex.Y, *uint32) bool)(nil)).Elem(), iterMakerETTypex_YUint32)
+	RegisterInput(reflect.TypeOf((*func(*typex.Y, *uint64) bool)(nil)).Elem(), iterMakerTypex_YUint64)
+	RegisterInput(reflect.TypeOf((*func(*typex.EventTime, *typex.Y, *uint64) bool)(nil)).Elem(), iterMakerETTypex_YUint64)
+	RegisterInput(reflect.TypeOf((*func(*typex.Y, *float32) bool)(nil)).Elem(), iterMakerTypex_YFloat32)
+	RegisterInput(reflect.TypeOf((*func(*typex.EventTime, *typex.Y, *float32) bool)(nil)).Elem(), iterMakerETTypex_YFloat32)
+	RegisterInput(reflect.TypeOf((*func(*typex.Y, *float64) bool)(nil)).Elem(), iterMakerTypex_YFloat64)
+	RegisterInput(reflect.TypeOf((*func(*typex.EventTime, *typex.Y, *float64) bool)(nil)).Elem(), iterMakerETTypex_YFloat64)
+	RegisterInput(reflect.TypeOf((*func(*typex.Y, *typex.T) bool)(nil)).Elem(), iterMakerTypex_YTypex_T)
+	RegisterInput(reflect.TypeOf((*func(*typex.EventTime, *typex.Y, *typex.T) bool)(nil)).Elem(), iterMakerETTypex_YTypex_T)
+	RegisterInput(reflect.TypeOf((*func(*typex.Y, *typex.U) bool)(nil)).Elem(), iterMakerTypex_YTypex_U)
+	RegisterInput(reflect.TypeOf((*func(*typex.EventTime, *typex.Y, *typex.U) bool)(nil)).Elem(), iterMakerETTypex_YTypex_U)
+	RegisterInput(reflect.TypeOf((*func(*typex.Y, *typex.V) bool)(nil)).Elem(), iterMakerTypex_YTypex_V)
+	RegisterInput(reflect.TypeOf((*func(*typex.EventTime, *typex.Y, *typex.V) bool)(nil)).Elem(), iterMakerETTypex_YTypex_V)
+	RegisterInput(reflect.TypeOf((*func(*typex.Y, *typex.W) bool)(nil)).Elem(), iterMakerTypex_YTypex_W)
+	RegisterInput(reflect.TypeOf((*func(*typex.EventTime, *typex.Y, *typex.W) bool)(nil)).Elem(), iterMakerETTypex_YTypex_W)
+	RegisterInput(reflect.TypeOf((*func(*typex.Y, *typex.X) bool)(nil)).Elem(), iterMakerTypex_YTypex_X)
+	RegisterInput(reflect.TypeOf((*func(*typex.EventTime, *typex.Y, *typex.X) bool)(nil)).Elem(), iterMakerETTypex_YTypex_X)
+	RegisterInput(reflect.TypeOf((*func(*typex.Y, *typex.Y) bool)(nil)).Elem(), iterMakerTypex_YTypex_Y)
+	RegisterInput(reflect.TypeOf((*func(*typex.EventTime, *typex.Y, *typex.Y) bool)(nil)).Elem(), iterMakerETTypex_YTypex_Y)
+	RegisterInput(reflect.TypeOf((*func(*typex.Y, *typex.Z) bool)(nil)).Elem(), iterMakerTypex_YTypex_Z)
+	RegisterInput(reflect.TypeOf((*func(*typex.EventTime, *typex.Y, *typex.Z) bool)(nil)).Elem(), iterMakerETTypex_YTypex_Z)
+	RegisterInput(reflect.TypeOf((*func(*typex.Z) bool)(nil)).Elem(), iterMakerTypex_Z)
+	RegisterInput(reflect.TypeOf((*func(*typex.EventTime, *typex.Z) bool)(nil)).Elem(), iterMakerETTypex_Z)
+	RegisterInput(reflect.TypeOf((*func(*typex.Z, *[]byte) bool)(nil)).Elem(), iterMakerTypex_ZByteSlice)
+	RegisterInput(reflect.TypeOf((*func(*typex.EventTime, *typex.Z, *[]byte) bool)(nil)).Elem(), iterMakerETTypex_ZByteSlice)
+	RegisterInput(reflect.TypeOf((*func(*typex.Z, *bool) bool)(nil)).Elem(), iterMakerTypex_ZBool)
+	RegisterInput(reflect.TypeOf((*func(*typex.EventTime, *typex.Z, *bool) bool)(nil)).Elem(), iterMakerETTypex_ZBool)
+	RegisterInput(reflect.TypeOf((*func(*typex.Z, *string) bool)(nil)).Elem(), iterMakerTypex_ZString)
+	RegisterInput(reflect.TypeOf((*func(*typex.EventTime, *typex.Z, *string) bool)(nil)).Elem(), iterMakerETTypex_ZString)
+	RegisterInput(reflect.TypeOf((*func(*typex.Z, *int) bool)(nil)).Elem(), iterMakerTypex_ZInt)
+	RegisterInput(reflect.TypeOf((*func(*typex.EventTime, *typex.Z, *int) bool)(nil)).Elem(), iterMakerETTypex_ZInt)
+	RegisterInput(reflect.TypeOf((*func(*typex.Z, *int8) bool)(nil)).Elem(), iterMakerTypex_ZInt8)
+	RegisterInput(reflect.TypeOf((*func(*typex.EventTime, *typex.Z, *int8) bool)(nil)).Elem(), iterMakerETTypex_ZInt8)
+	RegisterInput(reflect.TypeOf((*func(*typex.Z, *int16) bool)(nil)).Elem(), iterMakerTypex_ZInt16)
+	RegisterInput(reflect.TypeOf((*func(*typex.EventTime, *typex.Z, *int16) bool)(nil)).Elem(), iterMakerETTypex_ZInt16)
+	RegisterInput(reflect.TypeOf((*func(*typex.Z, *int32) bool)(nil)).Elem(), iterMakerTypex_ZInt32)
+	RegisterInput(reflect.TypeOf((*func(*typex.EventTime, *typex.Z, *int32) bool)(nil)).Elem(), iterMakerETTypex_ZInt32)
+	RegisterInput(reflect.TypeOf((*func(*typex.Z, *int64) bool)(nil)).Elem(), iterMakerTypex_ZInt64)
+	RegisterInput(reflect.TypeOf((*func(*typex.EventTime, *typex.Z, *int64) bool)(nil)).Elem(), iterMakerETTypex_ZInt64)
+	RegisterInput(reflect.TypeOf((*func(*typex.Z, *uint) bool)(nil)).Elem(), iterMakerTypex_ZUint)
+	RegisterInput(reflect.TypeOf((*func(*typex.EventTime, *typex.Z, *uint) bool)(nil)).Elem(), iterMakerETTypex_ZUint)
+	RegisterInput(reflect.TypeOf((*func(*typex.Z, *uint8) bool)(nil)).Elem(), iterMakerTypex_ZUint8)
+	RegisterInput(reflect.TypeOf((*func(*typex.EventTime, *typex.Z, *uint8) bool)(nil)).Elem(), iterMakerETTypex_ZUint8)
+	RegisterInput(reflect.TypeOf((*func(*typex.Z, *uint16) bool)(nil)).Elem(), iterMakerTypex_ZUint16)
+	RegisterInput(reflect.TypeOf((*func(*typex.EventTime, *typex.Z, *uint16) bool)(nil)).Elem(), iterMakerETTypex_ZUint16)
+	RegisterInput(reflect.TypeOf((*func(*typex.Z, *uint32) bool)(nil)).Elem(), iterMakerTypex_ZUint32)
+	RegisterInput(reflect.TypeOf((*func(*typex.EventTime, *typex.Z, *uint32) bool)(nil)).Elem(), iterMakerETTypex_ZUint32)
+	RegisterInput(reflect.TypeOf((*func(*typex.Z, *uint64) bool)(nil)).Elem(), iterMakerTypex_ZUint64)
+	RegisterInput(reflect.TypeOf((*func(*typex.EventTime, *typex.Z, *uint64) bool)(nil)).Elem(), iterMakerETTypex_ZUint64)
+	RegisterInput(reflect.TypeOf((*func(*typex.Z, *float32) bool)(nil)).Elem(), iterMakerTypex_ZFloat32)
+	RegisterInput(reflect.TypeOf((*func(*typex.EventTime, *typex.Z, *float32) bool)(nil)).Elem(), iterMakerETTypex_ZFloat32)
+	RegisterInput(reflect.TypeOf((*func(*typex.Z, *float64) bool)(nil)).Elem(), iterMakerTypex_ZFloat64)
+	RegisterInput(reflect.TypeOf((*func(*typex.EventTime, *typex.Z, *float64) bool)(nil)).Elem(), iterMakerETTypex_ZFloat64)
+	RegisterInput(reflect.TypeOf((*func(*typex.Z, *typex.T) bool)(nil)).Elem(), iterMakerTypex_ZTypex_T)
+	RegisterInput(reflect.TypeOf((*func(*typex.EventTime, *typex.Z, *typex.T) bool)(nil)).Elem(), iterMakerETTypex_ZTypex_T)
+	RegisterInput(reflect.TypeOf((*func(*typex.Z, *typex.U) bool)(nil)).Elem(), iterMakerTypex_ZTypex_U)
+	RegisterInput(reflect.TypeOf((*func(*typex.EventTime, *typex.Z, *typex.U) bool)(nil)).Elem(), iterMakerETTypex_ZTypex_U)
+	RegisterInput(reflect.TypeOf((*func(*typex.Z, *typex.V) bool)(nil)).Elem(), iterMakerTypex_ZTypex_V)
+	RegisterInput(reflect.TypeOf((*func(*typex.EventTime, *typex.Z, *typex.V) bool)(nil)).Elem(), iterMakerETTypex_ZTypex_V)
+	RegisterInput(reflect.TypeOf((*func(*typex.Z, *typex.W) bool)(nil)).Elem(), iterMakerTypex_ZTypex_W)
+	RegisterInput(reflect.TypeOf((*func(*typex.EventTime, *typex.Z, *typex.W) bool)(nil)).Elem(), iterMakerETTypex_ZTypex_W)
+	RegisterInput(reflect.TypeOf((*func(*typex.Z, *typex.X) bool)(nil)).Elem(), iterMakerTypex_ZTypex_X)
+	RegisterInput(reflect.TypeOf((*func(*typex.EventTime, *typex.Z, *typex.X) bool)(nil)).Elem(), iterMakerETTypex_ZTypex_X)
+	RegisterInput(reflect.TypeOf((*func(*typex.Z, *typex.Y) bool)(nil)).Elem(), iterMakerTypex_ZTypex_Y)
+	RegisterInput(reflect.TypeOf((*func(*typex.EventTime, *typex.Z, *typex.Y) bool)(nil)).Elem(), iterMakerETTypex_ZTypex_Y)
+	RegisterInput(reflect.TypeOf((*func(*typex.Z, *typex.Z) bool)(nil)).Elem(), iterMakerTypex_ZTypex_Z)
+	RegisterInput(reflect.TypeOf((*func(*typex.EventTime, *typex.Z, *typex.Z) bool)(nil)).Elem(), iterMakerETTypex_ZTypex_Z)
+}
+
+type iterNative struct {
+	s  ReStream
+	fn reflect.Value
+
+	// cur is the "current" stream, if any.
+	cur Stream
+}
+
+func (v *iterNative) Init() error {
+	v.cur = v.s.Open()
+	return nil
+}
+
+func (v *iterNative) Value() reflect.Value {
+	return v.fn
+}
+
+func (v *iterNative) Reset() error {
+	if err := v.cur.Close(); err != nil {
+		return err
+	}
+	v.cur = nil
+	return nil
+}
+
+func (v *iterNative) readByteSlice(val *[]byte) bool {
+	elm, err := v.cur.Read()
+	if err != nil {
+		if err == io.EOF {
+			return false
+		}
+		panic(fmt.Sprintf("broken stream: %v", err))
+	}
+
+	*val = elm.Elm.Interface().([]byte)
+	return true
+}
+
+func iterMakerByteSlice(s ReStream) ReusableInput {
+	ret := &iterNative{s: s}
+	ret.fn = reflect.ValueOf(ret.readByteSlice)
+	return ret
+}
+
+func (v *iterNative) readETByteSlice(et *typex.EventTime, val *[]byte) bool {
+	elm, err := v.cur.Read()
+	if err != nil {
+		if err == io.EOF {
+			return false
+		}
+		panic(fmt.Sprintf("broken stream: %v", err))
+	}
+
+	*et = elm.Timestamp
+	*val = elm.Elm.Interface().([]byte)
+	return true
+}
+
+func iterMakerETByteSlice(s ReStream) ReusableInput {
+	ret := &iterNative{s: s}
+	ret.fn = reflect.ValueOf(ret.readETByteSlice)
+	return ret
+}
+
+func (v *iterNative) readByteSliceByteSlice(key *[]byte, value *[]byte) bool {
+	elm, err := v.cur.Read()
+	if err != nil {
+		if err == io.EOF {
+			return false
+		}
+		panic(fmt.Sprintf("broken stream: %v", err))
+	}
+
+	*key = elm.Elm.Interface().([]byte)
+	*value = elm.Elm2.Interface().([]byte)
+	return true
+}
+
+func iterMakerByteSliceByteSlice(s ReStream) ReusableInput {
+	ret := &iterNative{s: s}
+	ret.fn = reflect.ValueOf(ret.readByteSliceByteSlice)
+	return ret
+}
+
+func (v *iterNative) readETByteSliceByteSlice(et *typex.EventTime, key *[]byte, value *[]byte) bool {
+	elm, err := v.cur.Read()
+	if err != nil {
+		if err == io.EOF {
+			return false
+		}
+		panic(fmt.Sprintf("broken stream: %v", err))
+	}
+
+	*et = elm.Timestamp
+	*key = elm.Elm.Interface().([]byte)
+	*value = elm.Elm2.Interface().([]byte)
+	return true
+}
+
+func iterMakerETByteSliceByteSlice(s ReStream) ReusableInput {
+	ret := &iterNative{s: s}
+	ret.fn = reflect.ValueOf(ret.readETByteSliceByteSlice)
+	return ret
+}
+
+func (v *iterNative) readByteSliceBool(key *[]byte, value *bool) bool {
+	elm, err := v.cur.Read()
+	if err != nil {
+		if err == io.EOF {
+			return false
+		}
+		panic(fmt.Sprintf("broken stream: %v", err))
+	}
+
+	*key = elm.Elm.Interface().([]byte)
+	*value = elm.Elm2.Interface().(bool)
+	return true
+}
+
+func iterMakerByteSliceBool(s ReStream) ReusableInput {
+	ret := &iterNative{s: s}
+	ret.fn = reflect.ValueOf(ret.readByteSliceBool)
+	return ret
+}
+
+func (v *iterNative) readETByteSliceBool(et *typex.EventTime, key *[]byte, value *bool) bool {
+	elm, err := v.cur.Read()
+	if err != nil {
+		if err == io.EOF {
+			return false
+		}
+		panic(fmt.Sprintf("broken stream: %v", err))
+	}
+
+	*et = elm.Timestamp
+	*key = elm.Elm.Interface().([]byte)
+	*value = elm.Elm2.Interface().(bool)
+	return true
+}
+
+func iterMakerETByteSliceBool(s ReStream) ReusableInput {
+	ret := &iterNative{s: s}
+	ret.fn = reflect.ValueOf(ret.readETByteSliceBool)
+	return ret
+}
+
+func (v *iterNative) readByteSliceString(key *[]byte, value *string) bool {
+	elm, err := v.cur.Read()
+	if err != nil {
+		if err == io.EOF {
+			return false
+		}
+		panic(fmt.Sprintf("broken stream: %v", err))
+	}
+
+	*key = elm.Elm.Interface().([]byte)
+	*value = elm.Elm2.Interface().(string)
+	return true
+}
+
+func iterMakerByteSliceString(s ReStream) ReusableInput {
+	ret := &iterNative{s: s}
+	ret.fn = reflect.ValueOf(ret.readByteSliceString)
+	return ret
+}
+
+func (v *iterNative) readETByteSliceString(et *typex.EventTime, key *[]byte, value *string) bool {
+	elm, err := v.cur.Read()
+	if err != nil {
+		if err == io.EOF {
+			return false
+		}
+		panic(fmt.Sprintf("broken stream: %v", err))
+	}
+
+	*et = elm.Timestamp
+	*key = elm.Elm.Interface().([]byte)
+	*value = elm.Elm2.Interface().(string)
+	return true
+}
+
+func iterMakerETByteSliceString(s ReStream) ReusableInput {
+	ret := &iterNative{s: s}
+	ret.fn = reflect.ValueOf(ret.readETByteSliceString)
+	return ret
+}
+
+func (v *iterNative) readByteSliceInt(key *[]byte, value *int) bool {
+	elm, err := v.cur.Read()
+	if err != nil {
+		if err == io.EOF {
+			return false
+		}
+		panic(fmt.Sprintf("broken stream: %v", err))
+	}
+
+	*key = elm.Elm.Interface().([]byte)
+	*value = elm.Elm2.Interface().(int)
+	return true
+}
+
+func iterMakerByteSliceInt(s ReStream) ReusableInput {
+	ret := &iterNative{s: s}
+	ret.fn = reflect.ValueOf(ret.readByteSliceInt)
+	return ret
+}
+
+func (v *iterNative) readETByteSliceInt(et *typex.EventTime, key *[]byte, value *int) bool {
+	elm, err := v.cur.Read()
+	if err != nil {
+		if err == io.EOF {
+			return false
+		}
+		panic(fmt.Sprintf("broken stream: %v", err))
+	}
+
+	*et = elm.Timestamp
+	*key = elm.Elm.Interface().([]byte)
+	*value = elm.Elm2.Interface().(int)
+	return true
+}
+
+func iterMakerETByteSliceInt(s ReStream) ReusableInput {
+	ret := &iterNative{s: s}
+	ret.fn = reflect.ValueOf(ret.readETByteSliceInt)
+	return ret
+}
+
+func (v *iterNative) readByteSliceInt8(key *[]byte, value *int8) bool {
+	elm, err := v.cur.Read()
+	if err != nil {
+		if err == io.EOF {
+			return false
+		}
+		panic(fmt.Sprintf("broken stream: %v", err))
+	}
+
+	*key = elm.Elm.Interface().([]byte)
+	*value = elm.Elm2.Interface().(int8)
+	return true
+}
+
+func iterMakerByteSliceInt8(s ReStream) ReusableInput {
+	ret := &iterNative{s: s}
+	ret.fn = reflect.ValueOf(ret.readByteSliceInt8)
+	return ret
+}
+
+func (v *iterNative) readETByteSliceInt8(et *typex.EventTime, key *[]byte, value *int8) bool {
+	elm, err := v.cur.Read()
+	if err != nil {
+		if err == io.EOF {
+			return false
+		}
+		panic(fmt.Sprintf("broken stream: %v", err))
+	}
+
+	*et = elm.Timestamp
+	*key = elm.Elm.Interface().([]byte)
+	*value = elm.Elm2.Interface().(int8)
+	return true
+}
+
+func iterMakerETByteSliceInt8(s ReStream) ReusableInput {
+	ret := &iterNative{s: s}
+	ret.fn = reflect.ValueOf(ret.readETByteSliceInt8)
+	return ret
+}
+
+func (v *iterNative) readByteSliceInt16(key *[]byte, value *int16) bool {
+	elm, err := v.cur.Read()
+	if err != nil {
+		if err == io.EOF {
+			return false
+		}
+		panic(fmt.Sprintf("broken stream: %v", err))
+	}
+
+	*key = elm.Elm.Interface().([]byte)
+	*value = elm.Elm2.Interface().(int16)
+	return true
+}
+
+func iterMakerByteSliceInt16(s ReStream) ReusableInput {
+	ret := &iterNative{s: s}
+	ret.fn = reflect.ValueOf(ret.readByteSliceInt16)
+	return ret
+}
+
+func (v *iterNative) readETByteSliceInt16(et *typex.EventTime, key *[]byte, value *int16) bool {
+	elm, err := v.cur.Read()
+	if err != nil {
+		if err == io.EOF {
+			return false
+		}
+		panic(fmt.Sprintf("broken stream: %v", err))
+	}
+
+	*et = elm.Timestamp
+	*key = elm.Elm.Interface().([]byte)
+	*value = elm.Elm2.Interface().(int16)
+	return true
+}
+
+func iterMakerETByteSliceInt16(s ReStream) ReusableInput {
+	ret := &iterNative{s: s}
+	ret.fn = reflect.ValueOf(ret.readETByteSliceInt16)
+	return ret
+}
+
+func (v *iterNative) readByteSliceInt32(key *[]byte, value *int32) bool {
+	elm, err := v.cur.Read()
+	if err != nil {
+		if err == io.EOF {
+			return false
+		}
+		panic(fmt.Sprintf("broken stream: %v", err))
+	}
+
+	*key = elm.Elm.Interface().([]byte)
+	*value = elm.Elm2.Interface().(int32)
+	return true
+}
+
+func iterMakerByteSliceInt32(s ReStream) ReusableInput {
+	ret := &iterNative{s: s}
+	ret.fn = reflect.ValueOf(ret.readByteSliceInt32)
+	return ret
+}
+
+func (v *iterNative) readETByteSliceInt32(et *typex.EventTime, key *[]byte, value *int32) bool {
+	elm, err := v.cur.Read()
+	if err != nil {
+		if err == io.EOF {
+			return false
+		}
+		panic(fmt.Sprintf("broken stream: %v", err))
+	}
+
+	*et = elm.Timestamp
+	*key = elm.Elm.Interface().([]byte)
+	*value = elm.Elm2.Interface().(int32)
+	return true
+}
+
+func iterMakerETByteSliceInt32(s ReStream) ReusableInput {
+	ret := &iterNative{s: s}
+	ret.fn = reflect.ValueOf(ret.readETByteSliceInt32)
+	return ret
+}
+
+func (v *iterNative) readByteSliceInt64(key *[]byte, value *int64) bool {
+	elm, err := v.cur.Read()
+	if err != nil {
+		if err == io.EOF {
+			return false
+		}
+		panic(fmt.Sprintf("broken stream: %v", err))
+	}
+
+	*key = elm.Elm.Interface().([]byte)
+	*value = elm.Elm2.Interface().(int64)
+	return true
+}
+
+func iterMakerByteSliceInt64(s ReStream) ReusableInput {
+	ret := &iterNative{s: s}
+	ret.fn = reflect.ValueOf(ret.readByteSliceInt64)
+	return ret
+}
+
+func (v *iterNative) readETByteSliceInt64(et *typex.EventTime, key *[]byte, value *int64) bool {
+	elm, err := v.cur.Read()
+	if err != nil {
+		if err == io.EOF {
+			return false
+		}
+		panic(fmt.Sprintf("broken stream: %v", err))
+	}
+
+	*et = elm.Timestamp
+	*key = elm.Elm.Interface().([]byte)
+	*value = elm.Elm2.Interface().(int64)
+	return true
+}
+
+func iterMakerETByteSliceInt64(s ReStream) ReusableInput {
+	ret := &iterNative{s: s}
+	ret.fn = reflect.ValueOf(ret.readETByteSliceInt64)
+	return ret
+}
+
+func (v *iterNative) readByteSliceUint(key *[]byte, value *uint) bool {
+	elm, err := v.cur.Read()
+	if err != nil {
+		if err == io.EOF {
+			return false
+		}
+		panic(fmt.Sprintf("broken stream: %v", err))
+	}
+
+	*key = elm.Elm.Interface().([]byte)
+	*value = elm.Elm2.Interface().(uint)
+	return true
+}
+
+func iterMakerByteSliceUint(s ReStream) ReusableInput {
+	ret := &iterNative{s: s}
+	ret.fn = reflect.ValueOf(ret.readByteSliceUint)
+	return ret
+}
+
+func (v *iterNative) readETByteSliceUint(et *typex.EventTime, key *[]byte, value *uint) bool {
+	elm, err := v.cur.Read()
+	if err != nil {
+		if err == io.EOF {
+			return false
+		}
+		panic(fmt.Sprintf("broken stream: %v", err))
+	}
+
+	*et = elm.Timestamp
+	*key = elm.Elm.Interface().([]byte)
+	*value = elm.Elm2.Interface().(uint)
+	return true
+}
+
+func iterMakerETByteSliceUint(s ReStream) ReusableInput {
+	ret := &iterNative{s: s}
+	ret.fn = reflect.ValueOf(ret.readETByteSliceUint)
+	return ret
+}
+
+func (v *iterNative) readByteSliceUint8(key *[]byte, value *uint8) bool {
+	elm, err := v.cur.Read()
+	if err != nil {
+		if err == io.EOF {
+			return false
+		}
+		panic(fmt.Sprintf("broken stream: %v", err))
+	}
+
+	*key = elm.Elm.Interface().([]byte)
+	*value = elm.Elm2.Interface().(uint8)
+	return true
+}
+
+func iterMakerByteSliceUint8(s ReStream) ReusableInput {
+	ret := &iterNative{s: s}
+	ret.fn = reflect.ValueOf(ret.readByteSliceUint8)
+	return ret
+}
+
+func (v *iterNative) readETByteSliceUint8(et *typex.EventTime, key *[]byte, value *uint8) bool {
+	elm, err := v.cur.Read()
+	if err != nil {
+		if err == io.EOF {
+			return false
+		}
+		panic(fmt.Sprintf("broken stream: %v", err))
+	}
+
+	*et = elm.Timestamp
+	*key = elm.Elm.Interface().([]byte)
+	*value = elm.Elm2.Interface().(uint8)
+	return true
+}
+
+func iterMakerETByteSliceUint8(s ReStream) ReusableInput {
+	ret := &iterNative{s: s}
+	ret.fn = reflect.ValueOf(ret.readETByteSliceUint8)
+	return ret
+}
+
+func (v *iterNative) readByteSliceUint16(key *[]byte, value *uint16) bool {
+	elm, err := v.cur.Read()
+	if err != nil {
+		if err == io.EOF {
+			return false
+		}
+		panic(fmt.Sprintf("broken stream: %v", err))
+	}
+
+	*key = elm.Elm.Interface().([]byte)
+	*value = elm.Elm2.Interface().(uint16)
+	return true
+}
+
+func iterMakerByteSliceUint16(s ReStream) ReusableInput {
+	ret := &iterNative{s: s}
+	ret.fn = reflect.ValueOf(ret.readByteSliceUint16)
+	return ret
+}
+
+func (v *iterNative) readETByteSliceUint16(et *typex.EventTime, key *[]byte, value *uint16) bool {
+	elm, err := v.cur.Read()
+	if err != nil {
+		if err == io.EOF {
+			return false
+		}
+		panic(fmt.Sprintf("broken stream: %v", err))
+	}
+
+	*et = elm.Timestamp
+	*key = elm.Elm.Interface().([]byte)
+	*value = elm.Elm2.Interface().(uint16)
+	return true
+}
+
+func iterMakerETByteSliceUint16(s ReStream) ReusableInput {
+	ret := &iterNative{s: s}
+	ret.fn = reflect.ValueOf(ret.readETByteSliceUint16)
+	return ret
+}
+
+func (v *iterNative) readByteSliceUint32(key *[]byte, value *uint32) bool {
+	elm, err := v.cur.Read()
+	if err != nil {
+		if err == io.EOF {
+			return false
+		}
+		panic(fmt.Sprintf("broken stream: %v", err))
+	}
+
+	*key = elm.Elm.Interface().([]byte)
+	*value = elm.Elm2.Interface().(uint32)
+	return true
+}
+
+func iterMakerByteSliceUint32(s ReStream) ReusableInput {
+	ret := &iterNative{s: s}
+	ret.fn = reflect.ValueOf(ret.readByteSliceUint32)
+	return ret
+}
+
+func (v *iterNative) readETByteSliceUint32(et *typex.EventTime, key *[]byte, value *uint32) bool {
+	elm, err := v.cur.Read()
+	if err != nil {
+		if err == io.EOF {
+			return false
+		}
+		panic(fmt.Sprintf("broken stream: %v", err))
+	}
+
+	*et = elm.Timestamp
+	*key = elm.Elm.Interface().([]byte)
+	*value = elm.Elm2.Interface().(uint32)
+	return true
+}
+
+func iterMakerETByteSliceUint32(s ReStream) ReusableInput {
+	ret := &iterNative{s: s}
+	ret.fn = reflect.ValueOf(ret.readETByteSliceUint32)
+	return ret
+}
+
+func (v *iterNative) readByteSliceUint64(key *[]byte, value *uint64) bool {
+	elm, err := v.cur.Read()
+	if err != nil {
+		if err == io.EOF {
+			return false
+		}
+		panic(fmt.Sprintf("broken stream: %v", err))
+	}
+
+	*key = elm.Elm.Interface().([]byte)
+	*value = elm.Elm2.Interface().(uint64)
+	return true
+}
+
+func iterMakerByteSliceUint64(s ReStream) ReusableInput {
+	ret := &iterNative{s: s}
+	ret.fn = reflect.ValueOf(ret.readByteSliceUint64)
+	return ret
+}
+
+func (v *iterNative) readETByteSliceUint64(et *typex.EventTime, key *[]byte, value *uint64) bool {
+	elm, err := v.cur.Read()
+	if err != nil {
+		if err == io.EOF {
+			return false
+		}
+		panic(fmt.Sprintf("broken stream: %v", err))
+	}
+
+	*et = elm.Timestamp
+	*key = elm.Elm.Interface().([]byte)
+	*value = elm.Elm2.Interface().(uint64)
+	return true
+}
+
+func iterMakerETByteSliceUint64(s ReStream) ReusableInput {
+	ret := &iterNative{s: s}
+	ret.fn = reflect.ValueOf(ret.readETByteSliceUint64)
+	return ret
+}
+
+func (v *iterNative) readByteSliceFloat32(key *[]byte, value *float32) bool {
+	elm, err := v.cur.Read()
+	if err != nil {
+		if err == io.EOF {
+			return false
+		}
+		panic(fmt.Sprintf("broken stream: %v", err))
+	}
+
+	*key = elm.Elm.Interface().([]byte)
+	*value = elm.Elm2.Interface().(float32)
+	return true
+}
+
+func iterMakerByteSliceFloat32(s ReStream) ReusableInput {
+	ret := &iterNative{s: s}
+	ret.fn = reflect.ValueOf(ret.readByteSliceFloat32)
+	return ret
+}
+
+func (v *iterNative) readETByteSliceFloat32(et *typex.EventTime, key *[]byte, value *float32) bool {
+	elm, err := v.cur.Read()
+	if err != nil {
+		if err == io.EOF {
+			return false
+		}
+		panic(fmt.Sprintf("broken stream: %v", err))
+	}
+
+	*et = elm.Timestamp
+	*key = elm.Elm.Interface().([]byte)
+	*value = elm.Elm2.Interface().(float32)
+	return true
+}
+
+func iterMakerETByteSliceFloat32(s ReStream) ReusableInput {
+	ret := &iterNative{s: s}
+	ret.fn = reflect.ValueOf(ret.readETByteSliceFloat32)
+	return ret
+}
+
+func (v *iterNative) readByteSliceFloat64(key *[]byte, value *float64) bool {
+	elm, err := v.cur.Read()
+	if err != nil {
+		if err == io.EOF {
+			return false
+		}
+		panic(fmt.Sprintf("broken stream: %v", err))
+	}
+
+	*key = elm.Elm.Interface().([]byte)
+	*value = elm.Elm2.Interface().(float64)
+	return true
+}
+
+func iterMakerByteSliceFloat64(s ReStream) ReusableInput {
+	ret := &iterNative{s: s}
+	ret.fn = reflect.ValueOf(ret.readByteSliceFloat64)
+	return ret
+}
+
+func (v *iterNative) readETByteSliceFloat64(et *typex.EventTime, key *[]byte, value *float64) bool {
+	elm, err := v.cur.Read()
+	if err != nil {
+		if err == io.EOF {
+			return false
+		}
+		panic(fmt.Sprintf("broken stream: %v", err))
+	}
+
+	*et = elm.Timestamp
+	*key = elm.Elm.Interface().([]byte)
+	*value = elm.Elm2.Interface().(float64)
+	return true
+}
+
+func iterMakerETByteSliceFloat64(s ReStream) ReusableInput {
+	ret := &iterNative{s: s}
+	ret.fn = reflect.ValueOf(ret.readETByteSliceFloat64)
+	return ret
+}
+
+func (v *iterNative) readByteSliceTypex_T(key *[]byte, value *typex.T) bool {
+	elm, err := v.cur.Read()
+	if err != nil {
+		if err == io.EOF {
+			return false
+		}
+		panic(fmt.Sprintf("broken stream: %v", err))
+	}
+
+	*key = elm.Elm.Interface().([]byte)
+	*value = elm.Elm2.Interface().(typex.T)
+	return true
+}
+
+func iterMakerByteSliceTypex_T(s ReStream) ReusableInput {
+	ret := &iterNative{s: s}
+	ret.fn = reflect.ValueOf(ret.readByteSliceTypex_T)
+	return ret
+}
+
+func (v *iterNative) readETByteSliceTypex_T(et *typex.EventTime, key *[]byte, value *typex.T) bool {
+	elm, err := v.cur.Read()
+	if err != nil {
+		if err == io.EOF {
+			return false
+		}
+		panic(fmt.Sprintf("broken stream: %v", err))
+	}
+
+	*et = elm.Timestamp
+	*key = elm.Elm.Interface().([]byte)
+	*value = elm.Elm2.Interface().(typex.T)
+	return true
+}
+
+func iterMakerETByteSliceTypex_T(s ReStream) ReusableInput {
+	ret := &iterNative{s: s}
+	ret.fn = reflect.ValueOf(ret.readETByteSliceTypex_T)
+	return ret
+}
+
+func (v *iterNative) readByteSliceTypex_U(key *[]byte, value *typex.U) bool {
+	elm, err := v.cur.Read()
+	if err != nil {
+		if err == io.EOF {
+			return false
+		}
+		panic(fmt.Sprintf("broken stream: %v", err))
+	}
+
+	*key = elm.Elm.Interface().([]byte)
+	*value = elm.Elm2.Interface().(typex.U)
+	return true
+}
+
+func iterMakerByteSliceTypex_U(s ReStream) ReusableInput {
+	ret := &iterNative{s: s}
+	ret.fn = reflect.ValueOf(ret.readByteSliceTypex_U)
+	return ret
+}
+
+func (v *iterNative) readETByteSliceTypex_U(et *typex.EventTime, key *[]byte, value *typex.U) bool {
+	elm, err := v.cur.Read()
+	if err != nil {
+		if err == io.EOF {
+			return false
+		}
+		panic(fmt.Sprintf("broken stream: %v", err))
+	}
+
+	*et = elm.Timestamp
+	*key = elm.Elm.Interface().([]byte)
+	*value = elm.Elm2.Interface().(typex.U)
+	return true
+}
+
+func iterMakerETByteSliceTypex_U(s ReStream) ReusableInput {
+	ret := &iterNative{s: s}
+	ret.fn = reflect.ValueOf(ret.readETByteSliceTypex_U)
+	return ret
+}
+
+func (v *iterNative) readByteSliceTypex_V(key *[]byte, value *typex.V) bool {
+	elm, err := v.cur.Read()
+	if err != nil {
+		if err == io.EOF {
+			return false
+		}
+		panic(fmt.Sprintf("broken stream: %v", err))
+	}
+
+	*key = elm.Elm.Interface().([]byte)
+	*value = elm.Elm2.Interface().(typex.V)
+	return true
+}
+
+func iterMakerByteSliceTypex_V(s ReStream) ReusableInput {
+	ret := &iterNative{s: s}
+	ret.fn = reflect.ValueOf(ret.readByteSliceTypex_V)
+	return ret
+}
+
+func (v *iterNative) readETByteSliceTypex_V(et *typex.EventTime, key *[]byte, value *typex.V) bool {
+	elm, err := v.cur.Read()
+	if err != nil {
+		if err == io.EOF {
+			return false
+		}
+		panic(fmt.Sprintf("broken stream: %v", err))
+	}
+
+	*et = elm.Timestamp
+	*key = elm.Elm.Interface().([]byte)
+	*value = elm.Elm2.Interface().(typex.V)
+	return true
+}
+
+func iterMakerETByteSliceTypex_V(s ReStream) ReusableInput {
+	ret := &iterNative{s: s}
+	ret.fn = reflect.ValueOf(ret.readETByteSliceTypex_V)
+	return ret
+}
+
+func (v *iterNative) readByteSliceTypex_W(key *[]byte, value *typex.W) bool {
+	elm, err := v.cur.Read()
+	if err != nil {
+		if err == io.EOF {
+			return false
+		}
+		panic(fmt.Sprintf("broken stream: %v", err))
+	}
+
+	*key = elm.Elm.Interface().([]byte)
+	*value = elm.Elm2.Interface().(typex.W)
+	return true
+}
+
+func iterMakerByteSliceTypex_W(s ReStream) ReusableInput {
+	ret := &iterNative{s: s}
+	ret.fn = reflect.ValueOf(ret.readByteSliceTypex_W)
+	return ret
+}
+
+func (v *iterNative) readETByteSliceTypex_W(et *typex.EventTime, key *[]byte, value *typex.W) bool {
+	elm, err := v.cur.Read()
+	if err != nil {
+		if err == io.EOF {
+			return false
+		}
+		panic(fmt.Sprintf("broken stream: %v", err))
+	}
+
+	*et = elm.Timestamp
+	*key = elm.Elm.Interface().([]byte)
+	*value = elm.Elm2.Interface().(typex.W)
+	return true
+}
+
+func iterMakerETByteSliceTypex_W(s ReStream) ReusableInput {
+	ret := &iterNative{s: s}
+	ret.fn = reflect.ValueOf(ret.readETByteSliceTypex_W)
+	return ret
+}
+
+func (v *iterNative) readByteSliceTypex_X(key *[]byte, value *typex.X) bool {
+	elm, err := v.cur.Read()
+	if err != nil {
+		if err == io.EOF {
+			return false
+		}
+		panic(fmt.Sprintf("broken stream: %v", err))
+	}
+
+	*key = elm.Elm.Interface().([]byte)
+	*value = elm.Elm2.Interface().(typex.X)
+	return true
+}
+
+func iterMakerByteSliceTypex_X(s ReStream) ReusableInput {
+	ret := &iterNative{s: s}
+	ret.fn = reflect.ValueOf(ret.readByteSliceTypex_X)
+	return ret
+}
+
+func (v *iterNative) readETByteSliceTypex_X(et *typex.EventTime, key *[]byte, value *typex.X) bool {
+	elm, err := v.cur.Read()
+	if err != nil {
+		if err == io.EOF {
+			return false
+		}
+		panic(fmt.Sprintf("broken stream: %v", err))
+	}
+
+	*et = elm.Timestamp
+	*key = elm.Elm.Interface().([]byte)
+	*value = elm.Elm2.Interface().(typex.X)
+	return true
+}
+
+func iterMakerETByteSliceTypex_X(s ReStream) ReusableInput {
+	ret := &iterNative{s: s}
+	ret.fn = reflect.ValueOf(ret.readETByteSliceTypex_X)
+	return ret
+}
+
+func (v *iterNative) readByteSliceTypex_Y(key *[]byte, value *typex.Y) bool {
+	elm, err := v.cur.Read()
+	if err != nil {
+		if err == io.EOF {
+			return false
+		}
+		panic(fmt.Sprintf("broken stream: %v", err))
+	}
+
+	*key = elm.Elm.Interface().([]byte)
+	*value = elm.Elm2.Interface().(typex.Y)
+	return true
+}
+
+func iterMakerByteSliceTypex_Y(s ReStream) ReusableInput {
+	ret := &iterNative{s: s}
+	ret.fn = reflect.ValueOf(ret.readByteSliceTypex_Y)
+	return ret
+}
+
+func (v *iterNative) readETByteSliceTypex_Y(et *typex.EventTime, key *[]byte, value *typex.Y) bool {
+	elm, err := v.cur.Read()
+	if err != nil {
+		if err == io.EOF {
+			return false
+		}
+		panic(fmt.Sprintf("broken stream: %v", err))
+	}
+
+	*et = elm.Timestamp
+	*key = elm.Elm.Interface().([]byte)
+	*value = elm.Elm2.Interface().(typex.Y)
+	return true
+}
+
+func iterMakerETByteSliceTypex_Y(s ReStream) ReusableInput {
+	ret := &iterNative{s: s}
+	ret.fn = reflect.ValueOf(ret.readETByteSliceTypex_Y)
+	return ret
+}
+
+func (v *iterNative) readByteSliceTypex_Z(key *[]byte, value *typex.Z) bool {
+	elm, err := v.cur.Read()
+	if err != nil {
+		if err == io.EOF {
+			return false
+		}
+		panic(fmt.Sprintf("broken stream: %v", err))
+	}
+
+	*key = elm.Elm.Interface().([]byte)
+	*value = elm.Elm2.Interface().(typex.Z)
+	return true
+}
+
+func iterMakerByteSliceTypex_Z(s ReStream) ReusableInput {
+	ret := &iterNative{s: s}
+	ret.fn = reflect.ValueOf(ret.readByteSliceTypex_Z)
+	return ret
+}
+
+func (v *iterNative) readETByteSliceTypex_Z(et *typex.EventTime, key *[]byte, value *typex.Z) bool {
+	elm, err := v.cur.Read()
+	if err != nil {
+		if err == io.EOF {
+			return false
+		}
+		panic(fmt.Sprintf("broken stream: %v", err))
+	}
+
+	*et = elm.Timestamp
+	*key = elm.Elm.Interface().([]byte)
+	*value = elm.Elm2.Interface().(typex.Z)
+	return true
+}
+
+func iterMakerETByteSliceTypex_Z(s ReStream) ReusableInput {
+	ret := &iterNative{s: s}
+	ret.fn = reflect.ValueOf(ret.readETByteSliceTypex_Z)
+	return ret
+}
+
+func (v *iterNative) readBool(val *bool) bool {
+	elm, err := v.cur.Read()
+	if err != nil {
+		if err == io.EOF {
+			return false
+		}
+		panic(fmt.Sprintf("broken stream: %v", err))
+	}
+
+	*val = elm.Elm.Interface().(bool)
+	return true
+}
+
+func iterMakerBool(s ReStream) ReusableInput {
+	ret := &iterNative{s: s}
+	ret.fn = reflect.ValueOf(ret.readBool)
+	return ret
+}
+
+func (v *iterNative) readETBool(et *typex.EventTime, val *bool) bool {
+	elm, err := v.cur.Read()
+	if err != nil {
+		if err == io.EOF {
+			return false
+		}
+		panic(fmt.Sprintf("broken stream: %v", err))
+	}
+
+	*et = elm.Timestamp
+	*val = elm.Elm.Interface().(bool)
+	return true
+}
+
+func iterMakerETBool(s ReStream) ReusableInput {
+	ret := &iterNative{s: s}
+	ret.fn = reflect.ValueOf(ret.readETBool)
+	return ret
+}
+
+func (v *iterNative) readBoolByteSlice(key *bool, value *[]byte) bool {
+	elm, err := v.cur.Read()
+	if err != nil {
+		if err == io.EOF {
+			return false
+		}
+		panic(fmt.Sprintf("broken stream: %v", err))
+	}
+
+	*key = elm.Elm.Interface().(bool)
+	*value = elm.Elm2.Interface().([]byte)
+	return true
+}
+
+func iterMakerBoolByteSlice(s ReStream) ReusableInput {
+	ret := &iterNative{s: s}
+	ret.fn = reflect.ValueOf(ret.readBoolByteSlice)
+	return ret
+}
+
+func (v *iterNative) readETBoolByteSlice(et *typex.EventTime, key *bool, value *[]byte) bool {
+	elm, err := v.cur.Read()
+	if err != nil {
+		if err == io.EOF {
+			return false
+		}
+		panic(fmt.Sprintf("broken stream: %v", err))
+	}
+
+	*et = elm.Timestamp
+	*key = elm.Elm.Interface().(bool)
+	*value = elm.Elm2.Interface().([]byte)
+	return true
+}
+
+func iterMakerETBoolByteSlice(s ReStream) ReusableInput {
+	ret := &iterNative{s: s}
+	ret.fn = reflect.ValueOf(ret.readETBoolByteSlice)
+	return ret
+}
+
+func (v *iterNative) readBoolBool(key *bool, value *bool) bool {
+	elm, err := v.cur.Read()
+	if err != nil {
+		if err == io.EOF {
+			return false
+		}
+		panic(fmt.Sprintf("broken stream: %v", err))
+	}
+
+	*key = elm.Elm.Interface().(bool)
+	*value = elm.Elm2.Interface().(bool)
+	return true
+}
+
+func iterMakerBoolBool(s ReStream) ReusableInput {
+	ret := &iterNative{s: s}
+	ret.fn = reflect.ValueOf(ret.readBoolBool)
+	return ret
+}
+
+func (v *iterNative) readETBoolBool(et *typex.EventTime, key *bool, value *bool) bool {
+	elm, err := v.cur.Read()
+	if err != nil {
+		if err == io.EOF {
+			return false
+		}
+		panic(fmt.Sprintf("broken stream: %v", err))
+	}
+
+	*et = elm.Timestamp
+	*key = elm.Elm.Interface().(bool)
+	*value = elm.Elm2.Interface().(bool)
+	return true
+}
+
+func iterMakerETBoolBool(s ReStream) ReusableInput {
+	ret := &iterNative{s: s}
+	ret.fn = reflect.ValueOf(ret.readETBoolBool)
+	return ret
+}
+
+func (v *iterNative) readBoolString(key *bool, value *string) bool {
+	elm, err := v.cur.Read()
+	if err != nil {
+		if err == io.EOF {
+			return false
+		}
+		panic(fmt.Sprintf("broken stream: %v", err))
+	}
+
+	*key = elm.Elm.Interface().(bool)
+	*value = elm.Elm2.Interface().(string)
+	return true
+}
+
+func iterMakerBoolString(s ReStream) ReusableInput {
+	ret := &iterNative{s: s}
+	ret.fn = reflect.ValueOf(ret.readBoolString)
+	return ret
+}
+
+func (v *iterNative) readETBoolString(et *typex.EventTime, key *bool, value *string) bool {
+	elm, err := v.cur.Read()
+	if err != nil {
+		if err == io.EOF {
+			return false
+		}
+		panic(fmt.Sprintf("broken stream: %v", err))
+	}
+
+	*et = elm.Timestamp
+	*key = elm.Elm.Interface().(bool)
+	*value = elm.Elm2.Interface().(string)
+	return true
+}
+
+func iterMakerETBoolString(s ReStream) ReusableInput {
+	ret := &iterNative{s: s}
+	ret.fn = reflect.ValueOf(ret.readETBoolString)
+	return ret
+}
+
+func (v *iterNative) readBoolInt(key *bool, value *int) bool {
+	elm, err := v.cur.Read()
+	if err != nil {
+		if err == io.EOF {
+			return false
+		}
+		panic(fmt.Sprintf("broken stream: %v", err))
+	}
+
+	*key = elm.Elm.Interface().(bool)
+	*value = elm.Elm2.Interface().(int)
+	return true
+}
+
+func iterMakerBoolInt(s ReStream) ReusableInput {
+	ret := &iterNative{s: s}
+	ret.fn = reflect.ValueOf(ret.readBoolInt)
+	return ret
+}
+
+func (v *iterNative) readETBoolInt(et *typex.EventTime, key *bool, value *int) bool {
+	elm, err := v.cur.Read()
+	if err != nil {
+		if err == io.EOF {
+			return false
+		}
+		panic(fmt.Sprintf("broken stream: %v", err))
+	}
+
+	*et = elm.Timestamp
+	*key = elm.Elm.Interface().(bool)
+	*value = elm.Elm2.Interface().(int)
+	return true
+}
+
+func iterMakerETBoolInt(s ReStream) ReusableInput {
+	ret := &iterNative{s: s}
+	ret.fn = reflect.ValueOf(ret.readETBoolInt)
+	return ret
+}
+
+func (v *iterNative) readBoolInt8(key *bool, value *int8) bool {
+	elm, err := v.cur.Read()
+	if err != nil {
+		if err == io.EOF {
+			return false
+		}
+		panic(fmt.Sprintf("broken stream: %v", err))
+	}
+
+	*key = elm.Elm.Interface().(bool)
+	*value = elm.Elm2.Interface().(int8)
+	return true
+}
+
+func iterMakerBoolInt8(s ReStream) ReusableInput {
+	ret := &iterNative{s: s}
+	ret.fn = reflect.ValueOf(ret.readBoolInt8)
+	return ret
+}
+
+func (v *iterNative) readETBoolInt8(et *typex.EventTime, key *bool, value *int8) bool {
+	elm, err := v.cur.Read()
+	if err != nil {
+		if err == io.EOF {
+			return false
+		}
+		panic(fmt.Sprintf("broken stream: %v", err))
+	}
+
+	*et = elm.Timestamp
+	*key = elm.Elm.Interface().(bool)
+	*value = elm.Elm2.Interface().(int8)
+	return true
+}
+
+func iterMakerETBoolInt8(s ReStream) ReusableInput {
+	ret := &iterNative{s: s}
+	ret.fn = reflect.ValueOf(ret.readETBoolInt8)
+	return ret
+}
+
+func (v *iterNative) readBoolInt16(key *bool, value *int16) bool {
+	elm, err := v.cur.Read()
+	if err != nil {
+		if err == io.EOF {
+			return false
+		}
+		panic(fmt.Sprintf("broken stream: %v", err))
+	}
+
+	*key = elm.Elm.Interface().(bool)
+	*value = elm.Elm2.Interface().(int16)
+	return true
+}
+
+func iterMakerBoolInt16(s ReStream) ReusableInput {
+	ret := &iterNative{s: s}
+	ret.fn = reflect.ValueOf(ret.readBoolInt16)
+	return ret
+}
+
+func (v *iterNative) readETBoolInt16(et *typex.EventTime, key *bool, value *int16) bool {
+	elm, err := v.cur.Read()
+	if err != nil {
+		if err == io.EOF {
+			return false
+		}
+		panic(fmt.Sprintf("broken stream: %v", err))
+	}
+
+	*et = elm.Timestamp
+	*key = elm.Elm.Interface().(bool)
+	*value = elm.Elm2.Interface().(int16)
+	return true
+}
+
+func iterMakerETBoolInt16(s ReStream) ReusableInput {
+	ret := &iterNative{s: s}
+	ret.fn = reflect.ValueOf(ret.readETBoolInt16)
+	return ret
+}
+
+func (v *iterNative) readBoolInt32(key *bool, value *int32) bool {
+	elm, err := v.cur.Read()
+	if err != nil {
+		if err == io.EOF {
+			return false
+		}
+		panic(fmt.Sprintf("broken stream: %v", err))
+	}
+
+	*key = elm.Elm.Interface().(bool)
+	*value = elm.Elm2.Interface().(int32)
+	return true
+}
+
+func iterMakerBoolInt32(s ReStream) ReusableInput {
+	ret := &iterNative{s: s}
+	ret.fn = reflect.ValueOf(ret.readBoolInt32)
+	return ret
+}
+
+func (v *iterNative) readETBoolInt32(et *typex.EventTime, key *bool, value *int32) bool {
+	elm, err := v.cur.Read()
+	if err != nil {
+		if err == io.EOF {
+			return false
+		}
+		panic(fmt.Sprintf("broken stream: %v", err))
+	}
+
+	*et = elm.Timestamp
+	*key = elm.Elm.Interface().(bool)
+	*value = elm.Elm2.Interface().(int32)
+	return true
+}
+
+func iterMakerETBoolInt32(s ReStream) ReusableInput {
+	ret := &iterNative{s: s}
+	ret.fn = reflect.ValueOf(ret.readETBoolInt32)
+	return ret
+}
+
+func (v *iterNative) readBoolInt64(key *bool, value *int64) bool {
+	elm, err := v.cur.Read()
+	if err != nil {
+		if err == io.EOF {
+			return false
+		}
+		panic(fmt.Sprintf("broken stream: %v", err))
+	}
+
+	*key = elm.Elm.Interface().(bool)
+	*value = elm.Elm2.Interface().(int64)
+	return true
+}
+
+func iterMakerBoolInt64(s ReStream) ReusableInput {
+	ret := &iterNative{s: s}
+	ret.fn = reflect.ValueOf(ret.readBoolInt64)
+	return ret
+}
+
+func (v *iterNative) readETBoolInt64(et *typex.EventTime, key *bool, value *int64) bool {
+	elm, err := v.cur.Read()
+	if err != nil {
+		if err == io.EOF {
+			return false
+		}
+		panic(fmt.Sprintf("broken stream: %v", err))
+	}
+
+	*et = elm.Timestamp
+	*key = elm.Elm.Interface().(bool)
+	*value = elm.Elm2.Interface().(int64)
+	return true
+}
+
+func iterMakerETBoolInt64(s ReStream) ReusableInput {
+	ret := &iterNative{s: s}
+	ret.fn = reflect.ValueOf(ret.readETBoolInt64)
+	return ret
+}
+
+func (v *iterNative) readBoolUint(key *bool, value *uint) bool {
+	elm, err := v.cur.Read()
+	if err != nil {
+		if err == io.EOF {
+			return false
+		}
+		panic(fmt.Sprintf("broken stream: %v", err))
+	}
+
+	*key = elm.Elm.Interface().(bool)
+	*value = elm.Elm2.Interface().(uint)
+	return true
+}
+
+func iterMakerBoolUint(s ReStream) ReusableInput {
+	ret := &iterNative{s: s}
+	ret.fn = reflect.ValueOf(ret.readBoolUint)
+	return ret
+}
+
+func (v *iterNative) readETBoolUint(et *typex.EventTime, key *bool, value *uint) bool {
+	elm, err := v.cur.Read()
+	if err != nil {
+		if err == io.EOF {
+			return false
+		}
+		panic(fmt.Sprintf("broken stream: %v", err))
+	}
+
+	*et = elm.Timestamp
+	*key = elm.Elm.Interface().(bool)
+	*value = elm.Elm2.Interface().(uint)
+	return true
+}
+
+func iterMakerETBoolUint(s ReStream) ReusableInput {
+	ret := &iterNative{s: s}
+	ret.fn = reflect.ValueOf(ret.readETBoolUint)
+	return ret
+}
+
+func (v *iterNative) readBoolUint8(key *bool, value *uint8) bool {
+	elm, err := v.cur.Read()
+	if err != nil {
+		if err == io.EOF {
+			return false
+		}
+		panic(fmt.Sprintf("broken stream: %v", err))
+	}
+
+	*key = elm.Elm.Interface().(bool)
+	*value = elm.Elm2.Interface().(uint8)
+	return true
+}
+
+func iterMakerBoolUint8(s ReStream) ReusableInput {
+	ret := &iterNative{s: s}
+	ret.fn = reflect.ValueOf(ret.readBoolUint8)
+	return ret
+}
+
+func (v *iterNative) readETBoolUint8(et *typex.EventTime, key *bool, value *uint8) bool {
+	elm, err := v.cur.Read()
+	if err != nil {
+		if err == io.EOF {
+			return false
+		}
+		panic(fmt.Sprintf("broken stream: %v", err))
+	}
+
+	*et = elm.Timestamp
+	*key = elm.Elm.Interface().(bool)
+	*value = elm.Elm2.Interface().(uint8)
+	return true
+}
+
+func iterMakerETBoolUint8(s ReStream) ReusableInput {
+	ret := &iterNative{s: s}
+	ret.fn = reflect.ValueOf(ret.readETBoolUint8)
+	return ret
+}
+
+func (v *iterNative) readBoolUint16(key *bool, value *uint16) bool {
+	elm, err := v.cur.Read()
+	if err != nil {
+		if err == io.EOF {
+			return false
+		}
+		panic(fmt.Sprintf("broken stream: %v", err))
+	}
+
+	*key = elm.Elm.Interface().(bool)
+	*value = elm.Elm2.Interface().(uint16)
+	return true
+}
+
+func iterMakerBoolUint16(s ReStream) ReusableInput {
+	ret := &iterNative{s: s}
+	ret.fn = reflect.ValueOf(ret.readBoolUint16)
+	return ret
+}
+
+func (v *iterNative) readETBoolUint16(et *typex.EventTime, key *bool, value *uint16) bool {
+	elm, err := v.cur.Read()
+	if err != nil {
+		if err == io.EOF {
+			return false
+		}
+		panic(fmt.Sprintf("broken stream: %v", err))
+	}
+
+	*et = elm.Timestamp
+	*key = elm.Elm.Interface().(bool)
+	*value = elm.Elm2.Interface().(uint16)
+	return true
+}
+
+func iterMakerETBoolUint16(s ReStream) ReusableInput {
+	ret := &iterNative{s: s}
+	ret.fn = reflect.ValueOf(ret.readETBoolUint16)
+	return ret
+}
+
+func (v *iterNative) readBoolUint32(key *bool, value *uint32) bool {
+	elm, err := v.cur.Read()
+	if err != nil {
+		if err == io.EOF {
+			return false
+		}
+		panic(fmt.Sprintf("broken stream: %v", err))
+	}
+
+	*key = elm.Elm.Interface().(bool)
+	*value = elm.Elm2.Interface().(uint32)
+	return true
+}
+
+func iterMakerBoolUint32(s ReStream) ReusableInput {
+	ret := &iterNative{s: s}
+	ret.fn = reflect.ValueOf(ret.readBoolUint32)
+	return ret
+}
+
+func (v *iterNative) readETBoolUint32(et *typex.EventTime, key *bool, value *uint32) bool {
+	elm, err := v.cur.Read()
+	if err != nil {
+		if err == io.EOF {
+			return false
+		}
+		panic(fmt.Sprintf("broken stream: %v", err))
+	}
+
+	*et = elm.Timestamp
+	*key = elm.Elm.Interface().(bool)
+	*value = elm.Elm2.Interface().(uint32)
+	return true
+}
+
+func iterMakerETBoolUint32(s ReStream) ReusableInput {
+	ret := &iterNative{s: s}
+	ret.fn = reflect.ValueOf(ret.readETBoolUint32)
+	return ret
+}
+
+func (v *iterNative) readBoolUint64(key *bool, value *uint64) bool {
+	elm, err := v.cur.Read()
+	if err != nil {
+		if err == io.EOF {
+			return false
+		}
+		panic(fmt.Sprintf("broken stream: %v", err))
+	}
+
+	*key = elm.Elm.Interface().(bool)
+	*value = elm.Elm2.Interface().(uint64)
+	return true
+}
+
+func iterMakerBoolUint64(s ReStream) ReusableInput {
+	ret := &iterNative{s: s}
+	ret.fn = reflect.ValueOf(ret.readBoolUint64)
+	return ret
+}
+
+func (v *iterNative) readETBoolUint64(et *typex.EventTime, key *bool, value *uint64) bool {
+	elm, err := v.cur.Read()
+	if err != nil {
+		if err == io.EOF {
+			return false
+		}
+		panic(fmt.Sprintf("broken stream: %v", err))
+	}
+
+	*et = elm.Timestamp
+	*key = elm.Elm.Interface().(bool)
+	*value = elm.Elm2.Interface().(uint64)
+	return true
+}
+
+func iterMakerETBoolUint64(s ReStream) ReusableInput {
+	ret := &iterNative{s: s}
+	ret.fn = reflect.ValueOf(ret.readETBoolUint64)
+	return ret
+}
+
+func (v *iterNative) readBoolFloat32(key *bool, value *float32) bool {
+	elm, err := v.cur.Read()
+	if err != nil {
+		if err == io.EOF {
+			return false
+		}
+		panic(fmt.Sprintf("broken stream: %v", err))
+	}
+
+	*key = elm.Elm.Interface().(bool)
+	*value = elm.Elm2.Interface().(float32)
+	return true
+}
+
+func iterMakerBoolFloat32(s ReStream) ReusableInput {
+	ret := &iterNative{s: s}
+	ret.fn = reflect.ValueOf(ret.readBoolFloat32)
+	return ret
+}
+
+func (v *iterNative) readETBoolFloat32(et *typex.EventTime, key *bool, value *float32) bool {
+	elm, err := v.cur.Read()
+	if err != nil {
+		if err == io.EOF {
+			return false
+		}
+		panic(fmt.Sprintf("broken stream: %v", err))
+	}
+
+	*et = elm.Timestamp
+	*key = elm.Elm.Interface().(bool)
+	*value = elm.Elm2.Interface().(float32)
+	return true
+}
+
+func iterMakerETBoolFloat32(s ReStream) ReusableInput {
+	ret := &iterNative{s: s}
+	ret.fn = reflect.ValueOf(ret.readETBoolFloat32)
+	return ret
+}
+
+func (v *iterNative) readBoolFloat64(key *bool, value *float64) bool {
+	elm, err := v.cur.Read()
+	if err != nil {
+		if err == io.EOF {
+			return false
+		}
+		panic(fmt.Sprintf("broken stream: %v", err))
+	}
+
+	*key = elm.Elm.Interface().(bool)
+	*value = elm.Elm2.Interface().(float64)
+	return true
+}
+
+func iterMakerBoolFloat64(s ReStream) ReusableInput {
+	ret := &iterNative{s: s}
+	ret.fn = reflect.ValueOf(ret.readBoolFloat64)
+	return ret
+}
+
+func (v *iterNative) readETBoolFloat64(et *typex.EventTime, key *bool, value *float64) bool {
+	elm, err := v.cur.Read()
+	if err != nil {
+		if err == io.EOF {
+			return false
+		}
+		panic(fmt.Sprintf("broken stream: %v", err))
+	}
+
+	*et = elm.Timestamp
+	*key = elm.Elm.Interface().(bool)
+	*value = elm.Elm2.Interface().(float64)
+	return true
+}
+
+func iterMakerETBoolFloat64(s ReStream) ReusableInput {
+	ret := &iterNative{s: s}
+	ret.fn = reflect.ValueOf(ret.readETBoolFloat64)
+	return ret
+}
+
+func (v *iterNative) readBoolTypex_T(key *bool, value *typex.T) bool {
+	elm, err := v.cur.Read()
+	if err != nil {
+		if err == io.EOF {
+			return false
+		}
+		panic(fmt.Sprintf("broken stream: %v", err))
+	}
+
+	*key = elm.Elm.Interface().(bool)
+	*value = elm.Elm2.Interface().(typex.T)
+	return true
+}
+
+func iterMakerBoolTypex_T(s ReStream) ReusableInput {
+	ret := &iterNative{s: s}
+	ret.fn = reflect.ValueOf(ret.readBoolTypex_T)
+	return ret
+}
+
+func (v *iterNative) readETBoolTypex_T(et *typex.EventTime, key *bool, value *typex.T) bool {
+	elm, err := v.cur.Read()
+	if err != nil {
+		if err == io.EOF {
+			return false
+		}
+		panic(fmt.Sprintf("broken stream: %v", err))
+	}
+
+	*et = elm.Timestamp
+	*key = elm.Elm.Interface().(bool)
+	*value = elm.Elm2.Interface().(typex.T)
+	return true
+}
+
+func iterMakerETBoolTypex_T(s ReStream) ReusableInput {
+	ret := &iterNative{s: s}
+	ret.fn = reflect.ValueOf(ret.readETBoolTypex_T)
+	return ret
+}
+
+func (v *iterNative) readBoolTypex_U(key *bool, value *typex.U) bool {
+	elm, err := v.cur.Read()
+	if err != nil {
+		if err == io.EOF {
+			return false
+		}
+		panic(fmt.Sprintf("broken stream: %v", err))
+	}
+
+	*key = elm.Elm.Interface().(bool)
+	*value = elm.Elm2.Interface().(typex.U)
+	return true
+}
+
+func iterMakerBoolTypex_U(s ReStream) ReusableInput {
+	ret := &iterNative{s: s}
+	ret.fn = reflect.ValueOf(ret.readBoolTypex_U)
+	return ret
+}
+
+func (v *iterNative) readETBoolTypex_U(et *typex.EventTime, key *bool, value *typex.U) bool {
+	elm, err := v.cur.Read()
+	if err != nil {
+		if err == io.EOF {
+			return false
+		}
+		panic(fmt.Sprintf("broken stream: %v", err))
+	}
+
+	*et = elm.Timestamp
+	*key = elm.Elm.Interface().(bool)
+	*value = elm.Elm2.Interface().(typex.U)
+	return true
+}
+
+func iterMakerETBoolTypex_U(s ReStream) ReusableInput {
+	ret := &iterNative{s: s}
+	ret.fn = reflect.ValueOf(ret.readETBoolTypex_U)
+	return ret
+}
+
+func (v *iterNative) readBoolTypex_V(key *bool, value *typex.V) bool {
+	elm, err := v.cur.Read()
+	if err != nil {
+		if err == io.EOF {
+			return false
+		}
+		panic(fmt.Sprintf("broken stream: %v", err))
+	}
+
+	*key = elm.Elm.Interface().(bool)
+	*value = elm.Elm2.Interface().(typex.V)
+	return true
+}
+
+func iterMakerBoolTypex_V(s ReStream) ReusableInput {
+	ret := &iterNative{s: s}
+	ret.fn = reflect.ValueOf(ret.readBoolTypex_V)
+	return ret
+}
+
+func (v *iterNative) readETBoolTypex_V(et *typex.EventTime, key *bool, value *typex.V) bool {
+	elm, err := v.cur.Read()
+	if err != nil {
+		if err == io.EOF {
+			return false
+		}
+		panic(fmt.Sprintf("broken stream: %v", err))
+	}
+
+	*et = elm.Timestamp
+	*key = elm.Elm.Interface().(bool)
+	*value = elm.Elm2.Interface().(typex.V)
+	return true
+}
+
+func iterMakerETBoolTypex_V(s ReStream) ReusableInput {
+	ret := &iterNative{s: s}
+	ret.fn = reflect.ValueOf(ret.readETBoolTypex_V)
+	return ret
+}
+
+func (v *iterNative) readBoolTypex_W(key *bool, value *typex.W) bool {
+	elm, err := v.cur.Read()
+	if err != nil {
+		if err == io.EOF {
+			return false
+		}
+		panic(fmt.Sprintf("broken stream: %v", err))
+	}
+
+	*key = elm.Elm.Interface().(bool)
+	*value = elm.Elm2.Interface().(typex.W)
+	return true
+}
+
+func iterMakerBoolTypex_W(s ReStream) ReusableInput {
+	ret := &iterNative{s: s}
+	ret.fn = reflect.ValueOf(ret.readBoolTypex_W)
+	return ret
+}
+
+func (v *iterNative) readETBoolTypex_W(et *typex.EventTime, key *bool, value *typex.W) bool {
+	elm, err := v.cur.Read()
+	if err != nil {
+		if err == io.EOF {
+			return false
+		}
+		panic(fmt.Sprintf("broken stream: %v", err))
+	}
+
+	*et = elm.Timestamp
+	*key = elm.Elm.Interface().(bool)
+	*value = elm.Elm2.Interface().(typex.W)
+	return true
+}
+
+func iterMakerETBoolTypex_W(s ReStream) ReusableInput {
+	ret := &iterNative{s: s}
+	ret.fn = reflect.ValueOf(ret.readETBoolTypex_W)
+	return ret
+}
+
+func (v *iterNative) readBoolTypex_X(key *bool, value *typex.X) bool {
+	elm, err := v.cur.Read()
+	if err != nil {
+		if err == io.EOF {
+			return false
+		}
+		panic(fmt.Sprintf("broken stream: %v", err))
+	}
+
+	*key = elm.Elm.Interface().(bool)
+	*value = elm.Elm2.Interface().(typex.X)
+	return true
+}
+
+func iterMakerBoolTypex_X(s ReStream) ReusableInput {
+	ret := &iterNative{s: s}
+	ret.fn = reflect.ValueOf(ret.readBoolTypex_X)
+	return ret
+}
+
+func (v *iterNative) readETBoolTypex_X(et *typex.EventTime, key *bool, value *typex.X) bool {
+	elm, err := v.cur.Read()
+	if err != nil {
+		if err == io.EOF {
+			return false
+		}
+		panic(fmt.Sprintf("broken stream: %v", err))
+	}
+
+	*et = elm.Timestamp
+	*key = elm.Elm.Interface().(bool)
+	*value = elm.Elm2.Interface().(typex.X)
+	return true
+}
+
+func iterMakerETBoolTypex_X(s ReStream) ReusableInput {
+	ret := &iterNative{s: s}
+	ret.fn = reflect.ValueOf(ret.readETBoolTypex_X)
+	return ret
+}
+
+func (v *iterNative) readBoolTypex_Y(key *bool, value *typex.Y) bool {
+	elm, err := v.cur.Read()
+	if err != nil {
+		if err == io.EOF {
+			return false
+		}
+		panic(fmt.Sprintf("broken stream: %v", err))
+	}
+
+	*key = elm.Elm.Interface().(bool)
+	*value = elm.Elm2.Interface().(typex.Y)
+	return true
+}
+
+func iterMakerBoolTypex_Y(s ReStream) ReusableInput {
+	ret := &iterNative{s: s}
+	ret.fn = reflect.ValueOf(ret.readBoolTypex_Y)
+	return ret
+}
+
+func (v *iterNative) readETBoolTypex_Y(et *typex.EventTime, key *bool, value *typex.Y) bool {
+	elm, err := v.cur.Read()
+	if err != nil {
+		if err == io.EOF {
+			return false
+		}
+		panic(fmt.Sprintf("broken stream: %v", err))
+	}
+
+	*et = elm.Timestamp
+	*key = elm.Elm.Interface().(bool)
+	*value = elm.Elm2.Interface().(typex.Y)
+	return true
+}
+
+func iterMakerETBoolTypex_Y(s ReStream) ReusableInput {
+	ret := &iterNative{s: s}
+	ret.fn = reflect.ValueOf(ret.readETBoolTypex_Y)
+	return ret
+}
+
+func (v *iterNative) readBoolTypex_Z(key *bool, value *typex.Z) bool {
+	elm, err := v.cur.Read()
+	if err != nil {
+		if err == io.EOF {
+			return false
+		}
+		panic(fmt.Sprintf("broken stream: %v", err))
+	}
+
+	*key = elm.Elm.Interface().(bool)
+	*value = elm.Elm2.Interface().(typex.Z)
+	return true
+}
+
+func iterMakerBoolTypex_Z(s ReStream) ReusableInput {
+	ret := &iterNative{s: s}
+	ret.fn = reflect.ValueOf(ret.readBoolTypex_Z)
+	return ret
+}
+
+func (v *iterNative) readETBoolTypex_Z(et *typex.EventTime, key *bool, value *typex.Z) bool {
+	elm, err := v.cur.Read()
+	if err != nil {
+		if err == io.EOF {
+			return false
+		}
+		panic(fmt.Sprintf("broken stream: %v", err))
+	}
+
+	*et = elm.Timestamp
+	*key = elm.Elm.Interface().(bool)
+	*value = elm.Elm2.Interface().(typex.Z)
+	return true
+}
+
+func iterMakerETBoolTypex_Z(s ReStream) ReusableInput {
+	ret := &iterNative{s: s}
+	ret.fn = reflect.ValueOf(ret.readETBoolTypex_Z)
+	return ret
+}
+
+func (v *iterNative) readString(val *string) bool {
+	elm, err := v.cur.Read()
+	if err != nil {
+		if err == io.EOF {
+			return false
+		}
+		panic(fmt.Sprintf("broken stream: %v", err))
+	}
+
+	*val = elm.Elm.Interface().(string)
+	return true
+}
+
+func iterMakerString(s ReStream) ReusableInput {
+	ret := &iterNative{s: s}
+	ret.fn = reflect.ValueOf(ret.readString)
+	return ret
+}
+
+func (v *iterNative) readETString(et *typex.EventTime, val *string) bool {
+	elm, err := v.cur.Read()
+	if err != nil {
+		if err == io.EOF {
+			return false
+		}
+		panic(fmt.Sprintf("broken stream: %v", err))
+	}
+
+	*et = elm.Timestamp
+	*val = elm.Elm.Interface().(string)
+	return true
+}
+
+func iterMakerETString(s ReStream) ReusableInput {
+	ret := &iterNative{s: s}
+	ret.fn = reflect.ValueOf(ret.readETString)
+	return ret
+}
+
+func (v *iterNative) readStringByteSlice(key *string, value *[]byte) bool {
+	elm, err := v.cur.Read()
+	if err != nil {
+		if err == io.EOF {
+			return false
+		}
+		panic(fmt.Sprintf("broken stream: %v", err))
+	}
+
+	*key = elm.Elm.Interface().(string)
+	*value = elm.Elm2.Interface().([]byte)
+	return true
+}
+
+func iterMakerStringByteSlice(s ReStream) ReusableInput {
+	ret := &iterNative{s: s}
+	ret.fn = reflect.ValueOf(ret.readStringByteSlice)
+	return ret
+}
+
+func (v *iterNative) readETStringByteSlice(et *typex.EventTime, key *string, value *[]byte) bool {
+	elm, err := v.cur.Read()
+	if err != nil {
+		if err == io.EOF {
+			return false
+		}
+		panic(fmt.Sprintf("broken stream: %v", err))
+	}
+
+	*et = elm.Timestamp
+	*key = elm.Elm.Interface().(string)
+	*value = elm.Elm2.Interface().([]byte)
+	return true
+}
+
+func iterMakerETStringByteSlice(s ReStream) ReusableInput {
+	ret := &iterNative{s: s}
+	ret.fn = reflect.ValueOf(ret.readETStringByteSlice)
+	return ret
+}
+
+func (v *iterNative) readStringBool(key *string, value *bool) bool {
+	elm, err := v.cur.Read()
+	if err != nil {
+		if err == io.EOF {
+			return false
+		}
+		panic(fmt.Sprintf("broken stream: %v", err))
+	}
+
+	*key = elm.Elm.Interface().(string)
+	*value = elm.Elm2.Interface().(bool)
+	return true
+}
+
+func iterMakerStringBool(s ReStream) ReusableInput {
+	ret := &iterNative{s: s}
+	ret.fn = reflect.ValueOf(ret.readStringBool)
+	return ret
+}
+
+func (v *iterNative) readETStringBool(et *typex.EventTime, key *string, value *bool) bool {
+	elm, err := v.cur.Read()
+	if err != nil {
+		if err == io.EOF {
+			return false
+		}
+		panic(fmt.Sprintf("broken stream: %v", err))
+	}
+
+	*et = elm.Timestamp
+	*key = elm.Elm.Interface().(string)
+	*value = elm.Elm2.Interface().(bool)
+	return true
+}
+
+func iterMakerETStringBool(s ReStream) ReusableInput {
+	ret := &iterNative{s: s}
+	ret.fn = reflect.ValueOf(ret.readETStringBool)
+	return ret
+}
+
+func (v *iterNative) readStringString(key *string, value *string) bool {
+	elm, err := v.cur.Read()
+	if err != nil {
+		if err == io.EOF {
+			return false
+		}
+		panic(fmt.Sprintf("broken stream: %v", err))
+	}
+
+	*key = elm.Elm.Interface().(string)
+	*value = elm.Elm2.Interface().(string)
+	return true
+}
+
+func iterMakerStringString(s ReStream) ReusableInput {
+	ret := &iterNative{s: s}
+	ret.fn = reflect.ValueOf(ret.readStringString)
+	return ret
+}
+
+func (v *iterNative) readETStringString(et *typex.EventTime, key *string, value *string) bool {
+	elm, err := v.cur.Read()
+	if err != nil {
+		if err == io.EOF {
+			return false
+		}
+		panic(fmt.Sprintf("broken stream: %v", err))
+	}
+
+	*et = elm.Timestamp
+	*key = elm.Elm.Interface().(string)
+	*value = elm.Elm2.Interface().(string)
+	return true
+}
+
+func iterMakerETStringString(s ReStream) ReusableInput {
+	ret := &iterNative{s: s}
+	ret.fn = reflect.ValueOf(ret.readETStringString)
+	return ret
+}
+
+func (v *iterNative) readStringInt(key *string, value *int) bool {
+	elm, err := v.cur.Read()
+	if err != nil {
+		if err == io.EOF {
+			return false
+		}
+		panic(fmt.Sprintf("broken stream: %v", err))
+	}
+
+	*key = elm.Elm.Interface().(string)
+	*value = elm.Elm2.Interface().(int)
+	return true
+}
+
+func iterMakerStringInt(s ReStream) ReusableInput {
+	ret := &iterNative{s: s}
+	ret.fn = reflect.ValueOf(ret.readStringInt)
+	return ret
+}
+
+func (v *iterNative) readETStringInt(et *typex.EventTime, key *string, value *int) bool {
+	elm, err := v.cur.Read()
+	if err != nil {
+		if err == io.EOF {
+			return false
+		}
+		panic(fmt.Sprintf("broken stream: %v", err))
+	}
+
+	*et = elm.Timestamp
+	*key = elm.Elm.Interface().(string)
+	*value = elm.Elm2.Interface().(int)
+	return true
+}
+
+func iterMakerETStringInt(s ReStream) ReusableInput {
+	ret := &iterNative{s: s}
+	ret.fn = reflect.ValueOf(ret.readETStringInt)
+	return ret
+}
+
+func (v *iterNative) readStringInt8(key *string, value *int8) bool {
+	elm, err := v.cur.Read()
+	if err != nil {
+		if err == io.EOF {
+			return false
+		}
+		panic(fmt.Sprintf("broken stream: %v", err))
+	}
+
+	*key = elm.Elm.Interface().(string)
+	*value = elm.Elm2.Interface().(int8)
+	return true
+}
+
+func iterMakerStringInt8(s ReStream) ReusableInput {
+	ret := &iterNative{s: s}
+	ret.fn = reflect.ValueOf(ret.readStringInt8)
+	return ret
+}
+
+func (v *iterNative) readETStringInt8(et *typex.EventTime, key *string, value *int8) bool {
+	elm, err := v.cur.Read()
+	if err != nil {
+		if err == io.EOF {
+			return false
+		}
+		panic(fmt.Sprintf("broken stream: %v", err))
+	}
+
+	*et = elm.Timestamp
+	*key = elm.Elm.Interface().(string)
+	*value = elm.Elm2.Interface().(int8)
+	return true
+}
+
+func iterMakerETStringInt8(s ReStream) ReusableInput {
+	ret := &iterNative{s: s}
+	ret.fn = reflect.ValueOf(ret.readETStringInt8)
+	return ret
+}
+
+func (v *iterNative) readStringInt16(key *string, value *int16) bool {
+	elm, err := v.cur.Read()
+	if err != nil {
+		if err == io.EOF {
+			return false
+		}
+		panic(fmt.Sprintf("broken stream: %v", err))
+	}
+
+	*key = elm.Elm.Interface().(string)
+	*value = elm.Elm2.Interface().(int16)
+	return true
+}
+
+func iterMakerStringInt16(s ReStream) ReusableInput {
+	ret := &iterNative{s: s}
+	ret.fn = reflect.ValueOf(ret.readStringInt16)
+	return ret
+}
+
+func (v *iterNative) readETStringInt16(et *typex.EventTime, key *string, value *int16) bool {
+	elm, err := v.cur.Read()
+	if err != nil {
+		if err == io.EOF {
+			return false
+		}
+		panic(fmt.Sprintf("broken stream: %v", err))
+	}
+
+	*et = elm.Timestamp
+	*key = elm.Elm.Interface().(string)
+	*value = elm.Elm2.Interface().(int16)
+	return true
+}
+
+func iterMakerETStringInt16(s ReStream) ReusableInput {
+	ret := &iterNative{s: s}
+	ret.fn = reflect.ValueOf(ret.readETStringInt16)
+	return ret
+}
+
+func (v *iterNative) readStringInt32(key *string, value *int32) bool {
+	elm, err := v.cur.Read()
+	if err != nil {
+		if err == io.EOF {
+			return false
+		}
+		panic(fmt.Sprintf("broken stream: %v", err))
+	}
+
+	*key = elm.Elm.Interface().(string)
+	*value = elm.Elm2.Interface().(int32)
+	return true
+}
+
+func iterMakerStringInt32(s ReStream) ReusableInput {
+	ret := &iterNative{s: s}
+	ret.fn = reflect.ValueOf(ret.readStringInt32)
+	return ret
+}
+
+func (v *iterNative) readETStringInt32(et *typex.EventTime, key *string, value *int32) bool {
+	elm, err := v.cur.Read()
+	if err != nil {
+		if err == io.EOF {
+			return false
+		}
+		panic(fmt.Sprintf("broken stream: %v", err))
+	}
+
+	*et = elm.Timestamp
+	*key = elm.Elm.Interface().(string)
+	*value = elm.Elm2.Interface().(int32)
+	return true
+}
+
+func iterMakerETStringInt32(s ReStream) ReusableInput {
+	ret := &iterNative{s: s}
+	ret.fn = reflect.ValueOf(ret.readETStringInt32)
+	return ret
+}
+
+func (v *iterNative) readStringInt64(key *string, value *int64) bool {
+	elm, err := v.cur.Read()
+	if err != nil {
+		if err == io.EOF {
+			return false
+		}
+		panic(fmt.Sprintf("broken stream: %v", err))
+	}
+
+	*key = elm.Elm.Interface().(string)
+	*value = elm.Elm2.Interface().(int64)
+	return true
+}
+
+func iterMakerStringInt64(s ReStream) ReusableInput {
+	ret := &iterNative{s: s}
+	ret.fn = reflect.ValueOf(ret.readStringInt64)
+	return ret
+}
+
+func (v *iterNative) readETStringInt64(et *typex.EventTime, key *string, value *int64) bool {
+	elm, err := v.cur.Read()
+	if err != nil {
+		if err == io.EOF {
+			return false
+		}
+		panic(fmt.Sprintf("broken stream: %v", err))
+	}
+
+	*et = elm.Timestamp
+	*key = elm.Elm.Interface().(string)
+	*value = elm.Elm2.Interface().(int64)
+	return true
+}
+
+func iterMakerETStringInt64(s ReStream) ReusableInput {
+	ret := &iterNative{s: s}
+	ret.fn = reflect.ValueOf(ret.readETStringInt64)
+	return ret
+}
+
+func (v *iterNative) readStringUint(key *string, value *uint) bool {
+	elm, err := v.cur.Read()
+	if err != nil {
+		if err == io.EOF {
+			return false
+		}
+		panic(fmt.Sprintf("broken stream: %v", err))
+	}
+
+	*key = elm.Elm.Interface().(string)
+	*value = elm.Elm2.Interface().(uint)
+	return true
+}
+
+func iterMakerStringUint(s ReStream) ReusableInput {
+	ret := &iterNative{s: s}
+	ret.fn = reflect.ValueOf(ret.readStringUint)
+	return ret
+}
+
+func (v *iterNative) readETStringUint(et *typex.EventTime, key *string, value *uint) bool {
+	elm, err := v.cur.Read()
+	if err != nil {
+		if err == io.EOF {
+			return false
+		}
+		panic(fmt.Sprintf("broken stream: %v", err))
+	}
+
+	*et = elm.Timestamp
+	*key = elm.Elm.Interface().(string)
+	*value = elm.Elm2.Interface().(uint)
+	return true
+}
+
+func iterMakerETStringUint(s ReStream) ReusableInput {
+	ret := &iterNative{s: s}
+	ret.fn = reflect.ValueOf(ret.readETStringUint)
+	return ret
+}
+
+func (v *iterNative) readStringUint8(key *string, value *uint8) bool {
+	elm, err := v.cur.Read()
+	if err != nil {
+		if err == io.EOF {
+			return false
+		}
+		panic(fmt.Sprintf("broken stream: %v", err))
+	}
+
+	*key = elm.Elm.Interface().(string)
+	*value = elm.Elm2.Interface().(uint8)
+	return true
+}
+
+func iterMakerStringUint8(s ReStream) ReusableInput {
+	ret := &iterNative{s: s}
+	ret.fn = reflect.ValueOf(ret.readStringUint8)
+	return ret
+}
+
+func (v *iterNative) readETStringUint8(et *typex.EventTime, key *string, value *uint8) bool {
+	elm, err := v.cur.Read()
+	if err != nil {
+		if err == io.EOF {
+			return false
+		}
+		panic(fmt.Sprintf("broken stream: %v", err))
+	}
+
+	*et = elm.Timestamp
+	*key = elm.Elm.Interface().(string)
+	*value = elm.Elm2.Interface().(uint8)
+	return true
+}
+
+func iterMakerETStringUint8(s ReStream) ReusableInput {
+	ret := &iterNative{s: s}
+	ret.fn = reflect.ValueOf(ret.readETStringUint8)
+	return ret
+}
+
+func (v *iterNative) readStringUint16(key *string, value *uint16) bool {
+	elm, err := v.cur.Read()
+	if err != nil {
+		if err == io.EOF {
+			return false
+		}
+		panic(fmt.Sprintf("broken stream: %v", err))
+	}
+
+	*key = elm.Elm.Interface().(string)
+	*value = elm.Elm2.Interface().(uint16)
+	return true
+}
+
+func iterMakerStringUint16(s ReStream) ReusableInput {
+	ret := &iterNative{s: s}
+	ret.fn = reflect.ValueOf(ret.readStringUint16)
+	return ret
+}
+
+func (v *iterNative) readETStringUint16(et *typex.EventTime, key *string, value *uint16) bool {
+	elm, err := v.cur.Read()
+	if err != nil {
+		if err == io.EOF {
+			return false
+		}
+		panic(fmt.Sprintf("broken stream: %v", err))
+	}
+
+	*et = elm.Timestamp
+	*key = elm.Elm.Interface().(string)
+	*value = elm.Elm2.Interface().(uint16)
+	return true
+}
+
+func iterMakerETStringUint16(s ReStream) ReusableInput {
+	ret := &iterNative{s: s}
+	ret.fn = reflect.ValueOf(ret.readETStringUint16)
+	return ret
+}
+
+func (v *iterNative) readStringUint32(key *string, value *uint32) bool {
+	elm, err := v.cur.Read()
+	if err != nil {
+		if err == io.EOF {
+			return false
+		}
+		panic(fmt.Sprintf("broken stream: %v", err))
+	}
+
+	*key = elm.Elm.Interface().(string)
+	*value = elm.Elm2.Interface().(uint32)
+	return true
+}
+
+func iterMakerStringUint32(s ReStream) ReusableInput {
+	ret := &iterNative{s: s}
+	ret.fn = reflect.ValueOf(ret.readStringUint32)
+	return ret
+}
+
+func (v *iterNative) readETStringUint32(et *typex.EventTime, key *string, value *uint32) bool {
+	elm, err := v.cur.Read()
+	if err != nil {
+		if err == io.EOF {
+			return false
+		}
+		panic(fmt.Sprintf("broken stream: %v", err))
+	}
+
+	*et = elm.Timestamp
+	*key = elm.Elm.Interface().(string)
+	*value = elm.Elm2.Interface().(uint32)
+	return true
+}
+
+func iterMakerETStringUint32(s ReStream) ReusableInput {
+	ret := &iterNative{s: s}
+	ret.fn = reflect.ValueOf(ret.readETStringUint32)
+	return ret
+}
+
+func (v *iterNative) readStringUint64(key *string, value *uint64) bool {
+	elm, err := v.cur.Read()
+	if err != nil {
+		if err == io.EOF {
+			return false
+		}
+		panic(fmt.Sprintf("broken stream: %v", err))
+	}
+
+	*key = elm.Elm.Interface().(string)
+	*value = elm.Elm2.Interface().(uint64)
+	return true
+}
+
+func iterMakerStringUint64(s ReStream) ReusableInput {
+	ret := &iterNative{s: s}
+	ret.fn = reflect.ValueOf(ret.readStringUint64)
+	return ret
+}
+
+func (v *iterNative) readETStringUint64(et *typex.EventTime, key *string, value *uint64) bool {
+	elm, err := v.cur.Read()
+	if err != nil {
+		if err == io.EOF {
+			return false
+		}
+		panic(fmt.Sprintf("broken stream: %v", err))
+	}
+
+	*et = elm.Timestamp
+	*key = elm.Elm.Interface().(string)
+	*value = elm.Elm2.Interface().(uint64)
+	return true
+}
+
+func iterMakerETStringUint64(s ReStream) ReusableInput {
+	ret := &iterNative{s: s}
+	ret.fn = reflect.ValueOf(ret.readETStringUint64)
+	return ret
+}
+
+func (v *iterNative) readStringFloat32(key *string, value *float32) bool {
+	elm, err := v.cur.Read()
+	if err != nil {
+		if err == io.EOF {
+			return false
+		}
+		panic(fmt.Sprintf("broken stream: %v", err))
+	}
+
+	*key = elm.Elm.Interface().(string)
+	*value = elm.Elm2.Interface().(float32)
+	return true
+}
+
+func iterMakerStringFloat32(s ReStream) ReusableInput {
+	ret := &iterNative{s: s}
+	ret.fn = reflect.ValueOf(ret.readStringFloat32)
+	return ret
+}
+
+func (v *iterNative) readETStringFloat32(et *typex.EventTime, key *string, value *float32) bool {
+	elm, err := v.cur.Read()
+	if err != nil {
+		if err == io.EOF {
+			return false
+		}
+		panic(fmt.Sprintf("broken stream: %v", err))
+	}
+
+	*et = elm.Timestamp
+	*key = elm.Elm.Interface().(string)
+	*value = elm.Elm2.Interface().(float32)
+	return true
+}
+
+func iterMakerETStringFloat32(s ReStream) ReusableInput {
+	ret := &iterNative{s: s}
+	ret.fn = reflect.ValueOf(ret.readETStringFloat32)
+	return ret
+}
+
+func (v *iterNative) readStringFloat64(key *string, value *float64) bool {
+	elm, err := v.cur.Read()
+	if err != nil {
+		if err == io.EOF {
+			return false
+		}
+		panic(fmt.Sprintf("broken stream: %v", err))
+	}
+
+	*key = elm.Elm.Interface().(string)
+	*value = elm.Elm2.Interface().(float64)
+	return true
+}
+
+func iterMakerStringFloat64(s ReStream) ReusableInput {
+	ret := &iterNative{s: s}
+	ret.fn = reflect.ValueOf(ret.readStringFloat64)
+	return ret
+}
+
+func (v *iterNative) readETStringFloat64(et *typex.EventTime, key *string, value *float64) bool {
+	elm, err := v.cur.Read()
+	if err != nil {
+		if err == io.EOF {
+			return false
+		}
+		panic(fmt.Sprintf("broken stream: %v", err))
+	}
+
+	*et = elm.Timestamp
+	*key = elm.Elm.Interface().(string)
+	*value = elm.Elm2.Interface().(float64)
+	return true
+}
+
+func iterMakerETStringFloat64(s ReStream) ReusableInput {
+	ret := &iterNative{s: s}
+	ret.fn = reflect.ValueOf(ret.readETStringFloat64)
+	return ret
+}
+
+func (v *iterNative) readStringTypex_T(key *string, value *typex.T) bool {
+	elm, err := v.cur.Read()
+	if err != nil {
+		if err == io.EOF {
+			return false
+		}
+		panic(fmt.Sprintf("broken stream: %v", err))
+	}
+
+	*key = elm.Elm.Interface().(string)
+	*value = elm.Elm2.Interface().(typex.T)
+	return true
+}
+
+func iterMakerStringTypex_T(s ReStream) ReusableInput {
+	ret := &iterNative{s: s}
+	ret.fn = reflect.ValueOf(ret.readStringTypex_T)
+	return ret
+}
+
+func (v *iterNative) readETStringTypex_T(et *typex.EventTime, key *string, value *typex.T) bool {
+	elm, err := v.cur.Read()
+	if err != nil {
+		if err == io.EOF {
+			return false
+		}
+		panic(fmt.Sprintf("broken stream: %v", err))
+	}
+
+	*et = elm.Timestamp
+	*key = elm.Elm.Interface().(string)
+	*value = elm.Elm2.Interface().(typex.T)
+	return true
+}
+
+func iterMakerETStringTypex_T(s ReStream) ReusableInput {
+	ret := &iterNative{s: s}
+	ret.fn = reflect.ValueOf(ret.readETStringTypex_T)
+	return ret
+}
+
+func (v *iterNative) readStringTypex_U(key *string, value *typex.U) bool {
+	elm, err := v.cur.Read()
+	if err != nil {
+		if err == io.EOF {
+			return false
+		}
+		panic(fmt.Sprintf("broken stream: %v", err))
+	}
+
+	*key = elm.Elm.Interface().(string)
+	*value = elm.Elm2.Interface().(typex.U)
+	return true
+}
+
+func iterMakerStringTypex_U(s ReStream) ReusableInput {
+	ret := &iterNative{s: s}
+	ret.fn = reflect.ValueOf(ret.readStringTypex_U)
+	return ret
+}
+
+func (v *iterNative) readETStringTypex_U(et *typex.EventTime, key *string, value *typex.U) bool {
+	elm, err := v.cur.Read()
+	if err != nil {
+		if err == io.EOF {
+			return false
+		}
+		panic(fmt.Sprintf("broken stream: %v", err))
+	}
+
+	*et = elm.Timestamp
+	*key = elm.Elm.Interface().(string)
+	*value = elm.Elm2.Interface().(typex.U)
+	return true
+}
+
+func iterMakerETStringTypex_U(s ReStream) ReusableInput {
+	ret := &iterNative{s: s}
+	ret.fn = reflect.ValueOf(ret.readETStringTypex_U)
+	return ret
+}
+
+func (v *iterNative) readStringTypex_V(key *string, value *typex.V) bool {
+	elm, err := v.cur.Read()
+	if err != nil {
+		if err == io.EOF {
+			return false
+		}
+		panic(fmt.Sprintf("broken stream: %v", err))
+	}
+
+	*key = elm.Elm.Interface().(string)
+	*value = elm.Elm2.Interface().(typex.V)
+	return true
+}
+
+func iterMakerStringTypex_V(s ReStream) ReusableInput {
+	ret := &iterNative{s: s}
+	ret.fn = reflect.ValueOf(ret.readStringTypex_V)
+	return ret
+}
+
+func (v *iterNative) readETStringTypex_V(et *typex.EventTime, key *string, value *typex.V) bool {
+	elm, err := v.cur.Read()
+	if err != nil {
+		if err == io.EOF {
+			return false
+		}
+		panic(fmt.Sprintf("broken stream: %v", err))
+	}
+
+	*et = elm.Timestamp
+	*key = elm.Elm.Interface().(string)
+	*value = elm.Elm2.Interface().(typex.V)
+	return true
+}
+
+func iterMakerETStringTypex_V(s ReStream) ReusableInput {
+	ret := &iterNative{s: s}
+	ret.fn = reflect.ValueOf(ret.readETStringTypex_V)
+	return ret
+}
+
+func (v *iterNative) readStringTypex_W(key *string, value *typex.W) bool {
+	elm, err := v.cur.Read()
+	if err != nil {
+		if err == io.EOF {
+			return false
+		}
+		panic(fmt.Sprintf("broken stream: %v", err))
+	}
+
+	*key = elm.Elm.Interface().(string)
+	*value = elm.Elm2.Interface().(typex.W)
+	return true
+}
+
+func iterMakerStringTypex_W(s ReStream) ReusableInput {
+	ret := &iterNative{s: s}
+	ret.fn = reflect.ValueOf(ret.readStringTypex_W)
+	return ret
+}
+
+func (v *iterNative) readETStringTypex_W(et *typex.EventTime, key *string, value *typex.W) bool {
+	elm, err := v.cur.Read()
+	if err != nil {
+		if err == io.EOF {
+			return false
+		}
+		panic(fmt.Sprintf("broken stream: %v", err))
+	}
+
+	*et = elm.Timestamp
+	*key = elm.Elm.Interface().(string)
+	*value = elm.Elm2.Interface().(typex.W)
+	return true
+}
+
+func iterMakerETStringTypex_W(s ReStream) ReusableInput {
+	ret := &iterNative{s: s}
+	ret.fn = reflect.ValueOf(ret.readETStringTypex_W)
+	return ret
+}
+
+func (v *iterNative) readStringTypex_X(key *string, value *typex.X) bool {
+	elm, err := v.cur.Read()
+	if err != nil {
+		if err == io.EOF {
+			return false
+		}
+		panic(fmt.Sprintf("broken stream: %v", err))
+	}
+
+	*key = elm.Elm.Interface().(string)
+	*value = elm.Elm2.Interface().(typex.X)
+	return true
+}
+
+func iterMakerStringTypex_X(s ReStream) ReusableInput {
+	ret := &iterNative{s: s}
+	ret.fn = reflect.ValueOf(ret.readStringTypex_X)
+	return ret
+}
+
+func (v *iterNative) readETStringTypex_X(et *typex.EventTime, key *string, value *typex.X) bool {
+	elm, err := v.cur.Read()
+	if err != nil {
+		if err == io.EOF {
+			return false
+		}
+		panic(fmt.Sprintf("broken stream: %v", err))
+	}
+
+	*et = elm.Timestamp
+	*key = elm.Elm.Interface().(string)
+	*value = elm.Elm2.Interface().(typex.X)
+	return true
+}
+
+func iterMakerETStringTypex_X(s ReStream) ReusableInput {
+	ret := &iterNative{s: s}
+	ret.fn = reflect.ValueOf(ret.readETStringTypex_X)
+	return ret
+}
+
+func (v *iterNative) readStringTypex_Y(key *string, value *typex.Y) bool {
+	elm, err := v.cur.Read()
+	if err != nil {
+		if err == io.EOF {
+			return false
+		}
+		panic(fmt.Sprintf("broken stream: %v", err))
+	}
+
+	*key = elm.Elm.Interface().(string)
+	*value = elm.Elm2.Interface().(typex.Y)
+	return true
+}
+
+func iterMakerStringTypex_Y(s ReStream) ReusableInput {
+	ret := &iterNative{s: s}
+	ret.fn = reflect.ValueOf(ret.readStringTypex_Y)
+	return ret
+}
+
+func (v *iterNative) readETStringTypex_Y(et *typex.EventTime, key *string, value *typex.Y) bool {
+	elm, err := v.cur.Read()
+	if err != nil {
+		if err == io.EOF {
+			return false
+		}
+		panic(fmt.Sprintf("broken stream: %v", err))
+	}
+
+	*et = elm.Timestamp
+	*key = elm.Elm.Interface().(string)
+	*value = elm.Elm2.Interface().(typex.Y)
+	return true
+}
+
+func iterMakerETStringTypex_Y(s ReStream) ReusableInput {
+	ret := &iterNative{s: s}
+	ret.fn = reflect.ValueOf(ret.readETStringTypex_Y)
+	return ret
+}
+
+func (v *iterNative) readStringTypex_Z(key *string, value *typex.Z) bool {
+	elm, err := v.cur.Read()
+	if err != nil {
+		if err == io.EOF {
+			return false
+		}
+		panic(fmt.Sprintf("broken stream: %v", err))
+	}
+
+	*key = elm.Elm.Interface().(string)
+	*value = elm.Elm2.Interface().(typex.Z)
+	return true
+}
+
+func iterMakerStringTypex_Z(s ReStream) ReusableInput {
+	ret := &iterNative{s: s}
+	ret.fn = reflect.ValueOf(ret.readStringTypex_Z)
+	return ret
+}
+
+func (v *iterNative) readETStringTypex_Z(et *typex.EventTime, key *string, value *typex.Z) bool {
+	elm, err := v.cur.Read()
+	if err != nil {
+		if err == io.EOF {
+			return false
+		}
+		panic(fmt.Sprintf("broken stream: %v", err))
+	}
+
+	*et = elm.Timestamp
+	*key = elm.Elm.Interface().(string)
+	*value = elm.Elm2.Interface().(typex.Z)
+	return true
+}
+
+func iterMakerETStringTypex_Z(s ReStream) ReusableInput {
+	ret := &iterNative{s: s}
+	ret.fn = reflect.ValueOf(ret.readETStringTypex_Z)
+	return ret
+}
+
+func (v *iterNative) readInt(val *int) bool {
+	elm, err := v.cur.Read()
+	if err != nil {
+		if err == io.EOF {
+			return false
+		}
+		panic(fmt.Sprintf("broken stream: %v", err))
+	}
+
+	*val = elm.Elm.Interface().(int)
+	return true
+}
+
+func iterMakerInt(s ReStream) ReusableInput {
+	ret := &iterNative{s: s}
+	ret.fn = reflect.ValueOf(ret.readInt)
+	return ret
+}
+
+func (v *iterNative) readETInt(et *typex.EventTime, val *int) bool {
+	elm, err := v.cur.Read()
+	if err != nil {
+		if err == io.EOF {
+			return false
+		}
+		panic(fmt.Sprintf("broken stream: %v", err))
+	}
+
+	*et = elm.Timestamp
+	*val = elm.Elm.Interface().(int)
+	return true
+}
+
+func iterMakerETInt(s ReStream) ReusableInput {
+	ret := &iterNative{s: s}
+	ret.fn = reflect.ValueOf(ret.readETInt)
+	return ret
+}
+
+func (v *iterNative) readIntByteSlice(key *int, value *[]byte) bool {
+	elm, err := v.cur.Read()
+	if err != nil {
+		if err == io.EOF {
+			return false
+		}
+		panic(fmt.Sprintf("broken stream: %v", err))
+	}
+
+	*key = elm.Elm.Interface().(int)
+	*value = elm.Elm2.Interface().([]byte)
+	return true
+}
+
+func iterMakerIntByteSlice(s ReStream) ReusableInput {
+	ret := &iterNative{s: s}
+	ret.fn = reflect.ValueOf(ret.readIntByteSlice)
+	return ret
+}
+
+func (v *iterNative) readETIntByteSlice(et *typex.EventTime, key *int, value *[]byte) bool {
+	elm, err := v.cur.Read()
+	if err != nil {
+		if err == io.EOF {
+			return false
+		}
+		panic(fmt.Sprintf("broken stream: %v", err))
+	}
+
+	*et = elm.Timestamp
+	*key = elm.Elm.Interface().(int)
+	*value = elm.Elm2.Interface().([]byte)
+	return true
+}
+
+func iterMakerETIntByteSlice(s ReStream) ReusableInput {
+	ret := &iterNative{s: s}
+	ret.fn = reflect.ValueOf(ret.readETIntByteSlice)
+	return ret
+}
+
+func (v *iterNative) readIntBool(key *int, value *bool) bool {
+	elm, err := v.cur.Read()
+	if err != nil {
+		if err == io.EOF {
+			return false
+		}
+		panic(fmt.Sprintf("broken stream: %v", err))
+	}
+
+	*key = elm.Elm.Interface().(int)
+	*value = elm.Elm2.Interface().(bool)
+	return true
+}
+
+func iterMakerIntBool(s ReStream) ReusableInput {
+	ret := &iterNative{s: s}
+	ret.fn = reflect.ValueOf(ret.readIntBool)
+	return ret
+}
+
+func (v *iterNative) readETIntBool(et *typex.EventTime, key *int, value *bool) bool {
+	elm, err := v.cur.Read()
+	if err != nil {
+		if err == io.EOF {
+			return false
+		}
+		panic(fmt.Sprintf("broken stream: %v", err))
+	}
+
+	*et = elm.Timestamp
+	*key = elm.Elm.Interface().(int)
+	*value = elm.Elm2.Interface().(bool)
+	return true
+}
+
+func iterMakerETIntBool(s ReStream) ReusableInput {
+	ret := &iterNative{s: s}
+	ret.fn = reflect.ValueOf(ret.readETIntBool)
+	return ret
+}
+
+func (v *iterNative) readIntString(key *int, value *string) bool {
+	elm, err := v.cur.Read()
+	if err != nil {
+		if err == io.EOF {
+			return false
+		}
+		panic(fmt.Sprintf("broken stream: %v", err))
+	}
+
+	*key = elm.Elm.Interface().(int)
+	*value = elm.Elm2.Interface().(string)
+	return true
+}
+
+func iterMakerIntString(s ReStream) ReusableInput {
+	ret := &iterNative{s: s}
+	ret.fn = reflect.ValueOf(ret.readIntString)
+	return ret
+}
+
+func (v *iterNative) readETIntString(et *typex.EventTime, key *int, value *string) bool {
+	elm, err := v.cur.Read()
+	if err != nil {
+		if err == io.EOF {
+			return false
+		}
+		panic(fmt.Sprintf("broken stream: %v", err))
+	}
+
+	*et = elm.Timestamp
+	*key = elm.Elm.Interface().(int)
+	*value = elm.Elm2.Interface().(string)
+	return true
+}
+
+func iterMakerETIntString(s ReStream) ReusableInput {
+	ret := &iterNative{s: s}
+	ret.fn = reflect.ValueOf(ret.readETIntString)
+	return ret
+}
+
+func (v *iterNative) readIntInt(key *int, value *int) bool {
+	elm, err := v.cur.Read()
+	if err != nil {
+		if err == io.EOF {
+			return false
+		}
+		panic(fmt.Sprintf("broken stream: %v", err))
+	}
+
+	*key = elm.Elm.Interface().(int)
+	*value = elm.Elm2.Interface().(int)
+	return true
+}
+
+func iterMakerIntInt(s ReStream) ReusableInput {
+	ret := &iterNative{s: s}
+	ret.fn = reflect.ValueOf(ret.readIntInt)
+	return ret
+}
+
+func (v *iterNative) readETIntInt(et *typex.EventTime, key *int, value *int) bool {
+	elm, err := v.cur.Read()
+	if err != nil {
+		if err == io.EOF {
+			return false
+		}
+		panic(fmt.Sprintf("broken stream: %v", err))
+	}
+
+	*et = elm.Timestamp
+	*key = elm.Elm.Interface().(int)
+	*value = elm.Elm2.Interface().(int)
+	return true
+}
+
+func iterMakerETIntInt(s ReStream) ReusableInput {
+	ret := &iterNative{s: s}
+	ret.fn = reflect.ValueOf(ret.readETIntInt)
+	return ret
+}
+
+func (v *iterNative) readIntInt8(key *int, value *int8) bool {
+	elm, err := v.cur.Read()
+	if err != nil {
+		if err == io.EOF {
+			return false
+		}
+		panic(fmt.Sprintf("broken stream: %v", err))
+	}
+
+	*key = elm.Elm.Interface().(int)
+	*value = elm.Elm2.Interface().(int8)
+	return true
+}
+
+func iterMakerIntInt8(s ReStream) ReusableInput {
+	ret := &iterNative{s: s}
+	ret.fn = reflect.ValueOf(ret.readIntInt8)
+	return ret
+}
+
+func (v *iterNative) readETIntInt8(et *typex.EventTime, key *int, value *int8) bool {
+	elm, err := v.cur.Read()
+	if err != nil {
+		if err == io.EOF {
+			return false
+		}
+		panic(fmt.Sprintf("broken stream: %v", err))
+	}
+
+	*et = elm.Timestamp
+	*key = elm.Elm.Interface().(int)
+	*value = elm.Elm2.Interface().(int8)
+	return true
+}
+
+func iterMakerETIntInt8(s ReStream) ReusableInput {
+	ret := &iterNative{s: s}
+	ret.fn = reflect.ValueOf(ret.readETIntInt8)
+	return ret
+}
+
+func (v *iterNative) readIntInt16(key *int, value *int16) bool {
+	elm, err := v.cur.Read()
+	if err != nil {
+		if err == io.EOF {
+			return false
+		}
+		panic(fmt.Sprintf("broken stream: %v", err))
+	}
+
+	*key = elm.Elm.Interface().(int)
+	*value = elm.Elm2.Interface().(int16)
+	return true
+}
+
+func iterMakerIntInt16(s ReStream) ReusableInput {
+	ret := &iterNative{s: s}
+	ret.fn = reflect.ValueOf(ret.readIntInt16)
+	return ret
+}
+
+func (v *iterNative) readETIntInt16(et *typex.EventTime, key *int, value *int16) bool {
+	elm, err := v.cur.Read()
+	if err != nil {
+		if err == io.EOF {
+			return false
+		}
+		panic(fmt.Sprintf("broken stream: %v", err))
+	}
+
+	*et = elm.Timestamp
+	*key = elm.Elm.Interface().(int)
+	*value = elm.Elm2.Interface().(int16)
+	return true
+}
+
+func iterMakerETIntInt16(s ReStream) ReusableInput {
+	ret := &iterNative{s: s}
+	ret.fn = reflect.ValueOf(ret.readETIntInt16)
+	return ret
+}
+
+func (v *iterNative) readIntInt32(key *int, value *int32) bool {
+	elm, err := v.cur.Read()
+	if err != nil {
+		if err == io.EOF {
+			return false
+		}
+		panic(fmt.Sprintf("broken stream: %v", err))
+	}
+
+	*key = elm.Elm.Interface().(int)
+	*value = elm.Elm2.Interface().(int32)
+	return true
+}
+
+func iterMakerIntInt32(s ReStream) ReusableInput {
+	ret := &iterNative{s: s}
+	ret.fn = reflect.ValueOf(ret.readIntInt32)
+	return ret
+}
+
+func (v *iterNative) readETIntInt32(et *typex.EventTime, key *int, value *int32) bool {
+	elm, err := v.cur.Read()
+	if err != nil {
+		if err == io.EOF {
+			return false
+		}
+		panic(fmt.Sprintf("broken stream: %v", err))
+	}
+
+	*et = elm.Timestamp
+	*key = elm.Elm.Interface().(int)
+	*value = elm.Elm2.Interface().(int32)
+	return true
+}
+
+func iterMakerETIntInt32(s ReStream) ReusableInput {
+	ret := &iterNative{s: s}
+	ret.fn = reflect.ValueOf(ret.readETIntInt32)
+	return ret
+}
+
+func (v *iterNative) readIntInt64(key *int, value *int64) bool {
+	elm, err := v.cur.Read()
+	if err != nil {
+		if err == io.EOF {
+			return false
+		}
+		panic(fmt.Sprintf("broken stream: %v", err))
+	}
+
+	*key = elm.Elm.Interface().(int)
+	*value = elm.Elm2.Interface().(int64)
+	return true
+}
+
+func iterMakerIntInt64(s ReStream) ReusableInput {
+	ret := &iterNative{s: s}
+	ret.fn = reflect.ValueOf(ret.readIntInt64)
+	return ret
+}
+
+func (v *iterNative) readETIntInt64(et *typex.EventTime, key *int, value *int64) bool {
+	elm, err := v.cur.Read()
+	if err != nil {
+		if err == io.EOF {
+			return false
+		}
+		panic(fmt.Sprintf("broken stream: %v", err))
+	}
+
+	*et = elm.Timestamp
+	*key = elm.Elm.Interface().(int)
+	*value = elm.Elm2.Interface().(int64)
+	return true
+}
+
+func iterMakerETIntInt64(s ReStream) ReusableInput {
+	ret := &iterNative{s: s}
+	ret.fn = reflect.ValueOf(ret.readETIntInt64)
+	return ret
+}
+
+func (v *iterNative) readIntUint(key *int, value *uint) bool {
+	elm, err := v.cur.Read()
+	if err != nil {
+		if err == io.EOF {
+			return false
+		}
+		panic(fmt.Sprintf("broken stream: %v", err))
+	}
+
+	*key = elm.Elm.Interface().(int)
+	*value = elm.Elm2.Interface().(uint)
+	return true
+}
+
+func iterMakerIntUint(s ReStream) ReusableInput {
+	ret := &iterNative{s: s}
+	ret.fn = reflect.ValueOf(ret.readIntUint)
+	return ret
+}
+
+func (v *iterNative) readETIntUint(et *typex.EventTime, key *int, value *uint) bool {
+	elm, err := v.cur.Read()
+	if err != nil {
+		if err == io.EOF {
+			return false
+		}
+		panic(fmt.Sprintf("broken stream: %v", err))
+	}
+
+	*et = elm.Timestamp
+	*key = elm.Elm.Interface().(int)
+	*value = elm.Elm2.Interface().(uint)
+	return true
+}
+
+func iterMakerETIntUint(s ReStream) ReusableInput {
+	ret := &iterNative{s: s}
+	ret.fn = reflect.ValueOf(ret.readETIntUint)
+	return ret
+}
+
+func (v *iterNative) readIntUint8(key *int, value *uint8) bool {
+	elm, err := v.cur.Read()
+	if err != nil {
+		if err == io.EOF {
+			return false
+		}
+		panic(fmt.Sprintf("broken stream: %v", err))
+	}
+
+	*key = elm.Elm.Interface().(int)
+	*value = elm.Elm2.Interface().(uint8)
+	return true
+}
+
+func iterMakerIntUint8(s ReStream) ReusableInput {
+	ret := &iterNative{s: s}
+	ret.fn = reflect.ValueOf(ret.readIntUint8)
+	return ret
+}
+
+func (v *iterNative) readETIntUint8(et *typex.EventTime, key *int, value *uint8) bool {
+	elm, err := v.cur.Read()
+	if err != nil {
+		if err == io.EOF {
+			return false
+		}
+		panic(fmt.Sprintf("broken stream: %v", err))
+	}
+
+	*et = elm.Timestamp
+	*key = elm.Elm.Interface().(int)
+	*value = elm.Elm2.Interface().(uint8)
+	return true
+}
+
+func iterMakerETIntUint8(s ReStream) ReusableInput {
+	ret := &iterNative{s: s}
+	ret.fn = reflect.ValueOf(ret.readETIntUint8)
+	return ret
+}
+
+func (v *iterNative) readIntUint16(key *int, value *uint16) bool {
+	elm, err := v.cur.Read()
+	if err != nil {
+		if err == io.EOF {
+			return false
+		}
+		panic(fmt.Sprintf("broken stream: %v", err))
+	}
+
+	*key = elm.Elm.Interface().(int)
+	*value = elm.Elm2.Interface().(uint16)
+	return true
+}
+
+func iterMakerIntUint16(s ReStream) ReusableInput {
+	ret := &iterNative{s: s}
+	ret.fn = reflect.ValueOf(ret.readIntUint16)
+	return ret
+}
+
+func (v *iterNative) readETIntUint16(et *typex.EventTime, key *int, value *uint16) bool {
+	elm, err := v.cur.Read()
+	if err != nil {
+		if err == io.EOF {
+			return false
+		}
+		panic(fmt.Sprintf("broken stream: %v", err))
+	}
+
+	*et = elm.Timestamp
+	*key = elm.Elm.Interface().(int)
+	*value = elm.Elm2.Interface().(uint16)
+	return true
+}
+
+func iterMakerETIntUint16(s ReStream) ReusableInput {
+	ret := &iterNative{s: s}
+	ret.fn = reflect.ValueOf(ret.readETIntUint16)
+	return ret
+}
+
+func (v *iterNative) readIntUint32(key *int, value *uint32) bool {
+	elm, err := v.cur.Read()
+	if err != nil {
+		if err == io.EOF {
+			return false
+		}
+		panic(fmt.Sprintf("broken stream: %v", err))
+	}
+
+	*key = elm.Elm.Interface().(int)
+	*value = elm.Elm2.Interface().(uint32)
+	return true
+}
+
+func iterMakerIntUint32(s ReStream) ReusableInput {
+	ret := &iterNative{s: s}
+	ret.fn = reflect.ValueOf(ret.readIntUint32)
+	return ret
+}
+
+func (v *iterNative) readETIntUint32(et *typex.EventTime, key *int, value *uint32) bool {
+	elm, err := v.cur.Read()
+	if err != nil {
+		if err == io.EOF {
+			return false
+		}
+		panic(fmt.Sprintf("broken stream: %v", err))
+	}
+
+	*et = elm.Timestamp
+	*key = elm.Elm.Interface().(int)
+	*value = elm.Elm2.Interface().(uint32)
+	return true
+}
+
+func iterMakerETIntUint32(s ReStream) ReusableInput {
+	ret := &iterNative{s: s}
+	ret.fn = reflect.ValueOf(ret.readETIntUint32)
+	return ret
+}
+
+func (v *iterNative) readIntUint64(key *int, value *uint64) bool {
+	elm, err := v.cur.Read()
+	if err != nil {
+		if err == io.EOF {
+			return false
+		}
+		panic(fmt.Sprintf("broken stream: %v", err))
+	}
+
+	*key = elm.Elm.Interface().(int)
+	*value = elm.Elm2.Interface().(uint64)
+	return true
+}
+
+func iterMakerIntUint64(s ReStream) ReusableInput {
+	ret := &iterNative{s: s}
+	ret.fn = reflect.ValueOf(ret.readIntUint64)
+	return ret
+}
+
+func (v *iterNative) readETIntUint64(et *typex.EventTime, key *int, value *uint64) bool {
+	elm, err := v.cur.Read()
+	if err != nil {
+		if err == io.EOF {
+			return false
+		}
+		panic(fmt.Sprintf("broken stream: %v", err))
+	}
+
+	*et = elm.Timestamp
+	*key = elm.Elm.Interface().(int)
+	*value = elm.Elm2.Interface().(uint64)
+	return true
+}
+
+func iterMakerETIntUint64(s ReStream) ReusableInput {
+	ret := &iterNative{s: s}
+	ret.fn = reflect.ValueOf(ret.readETIntUint64)
+	return ret
+}
+
+func (v *iterNative) readIntFloat32(key *int, value *float32) bool {
+	elm, err := v.cur.Read()
+	if err != nil {
+		if err == io.EOF {
+			return false
+		}
+		panic(fmt.Sprintf("broken stream: %v", err))
+	}
+
+	*key = elm.Elm.Interface().(int)
+	*value = elm.Elm2.Interface().(float32)
+	return true
+}
+
+func iterMakerIntFloat32(s ReStream) ReusableInput {
+	ret := &iterNative{s: s}
+	ret.fn = reflect.ValueOf(ret.readIntFloat32)
+	return ret
+}
+
+func (v *iterNative) readETIntFloat32(et *typex.EventTime, key *int, value *float32) bool {
+	elm, err := v.cur.Read()
+	if err != nil {
+		if err == io.EOF {
+			return false
+		}
+		panic(fmt.Sprintf("broken stream: %v", err))
+	}
+
+	*et = elm.Timestamp
+	*key = elm.Elm.Interface().(int)
+	*value = elm.Elm2.Interface().(float32)
+	return true
+}
+
+func iterMakerETIntFloat32(s ReStream) ReusableInput {
+	ret := &iterNative{s: s}
+	ret.fn = reflect.ValueOf(ret.readETIntFloat32)
+	return ret
+}
+
+func (v *iterNative) readIntFloat64(key *int, value *float64) bool {
+	elm, err := v.cur.Read()
+	if err != nil {
+		if err == io.EOF {
+			return false
+		}
+		panic(fmt.Sprintf("broken stream: %v", err))
+	}
+
+	*key = elm.Elm.Interface().(int)
+	*value = elm.Elm2.Interface().(float64)
+	return true
+}
+
+func iterMakerIntFloat64(s ReStream) ReusableInput {
+	ret := &iterNative{s: s}
+	ret.fn = reflect.ValueOf(ret.readIntFloat64)
+	return ret
+}
+
+func (v *iterNative) readETIntFloat64(et *typex.EventTime, key *int, value *float64) bool {
+	elm, err := v.cur.Read()
+	if err != nil {
+		if err == io.EOF {
+			return false
+		}
+		panic(fmt.Sprintf("broken stream: %v", err))
+	}
+
+	*et = elm.Timestamp
+	*key = elm.Elm.Interface().(int)
+	*value = elm.Elm2.Interface().(float64)
+	return true
+}
+
+func iterMakerETIntFloat64(s ReStream) ReusableInput {
+	ret := &iterNative{s: s}
+	ret.fn = reflect.ValueOf(ret.readETIntFloat64)
+	return ret
+}
+
+func (v *iterNative) readIntTypex_T(key *int, value *typex.T) bool {
+	elm, err := v.cur.Read()
+	if err != nil {
+		if err == io.EOF {
+			return false
+		}
+		panic(fmt.Sprintf("broken stream: %v", err))
+	}
+
+	*key = elm.Elm.Interface().(int)
+	*value = elm.Elm2.Interface().(typex.T)
+	return true
+}
+
+func iterMakerIntTypex_T(s ReStream) ReusableInput {
+	ret := &iterNative{s: s}
+	ret.fn = reflect.ValueOf(ret.readIntTypex_T)
+	return ret
+}
+
+func (v *iterNative) readETIntTypex_T(et *typex.EventTime, key *int, value *typex.T) bool {
+	elm, err := v.cur.Read()
+	if err != nil {
+		if err == io.EOF {
+			return false
+		}
+		panic(fmt.Sprintf("broken stream: %v", err))
+	}
+
+	*et = elm.Timestamp
+	*key = elm.Elm.Interface().(int)
+	*value = elm.Elm2.Interface().(typex.T)
+	return true
+}
+
+func iterMakerETIntTypex_T(s ReStream) ReusableInput {
+	ret := &iterNative{s: s}
+	ret.fn = reflect.ValueOf(ret.readETIntTypex_T)
+	return ret
+}
+
+func (v *iterNative) readIntTypex_U(key *int, value *typex.U) bool {
+	elm, err := v.cur.Read()
+	if err != nil {
+		if err == io.EOF {
+			return false
+		}
+		panic(fmt.Sprintf("broken stream: %v", err))
+	}
+
+	*key = elm.Elm.Interface().(int)
+	*value = elm.Elm2.Interface().(typex.U)
+	return true
+}
+
+func iterMakerIntTypex_U(s ReStream) ReusableInput {
+	ret := &iterNative{s: s}
+	ret.fn = reflect.ValueOf(ret.readIntTypex_U)
+	return ret
+}
+
+func (v *iterNative) readETIntTypex_U(et *typex.EventTime, key *int, value *typex.U) bool {
+	elm, err := v.cur.Read()
+	if err != nil {
+		if err == io.EOF {
+			return false
+		}
+		panic(fmt.Sprintf("broken stream: %v", err))
+	}
+
+	*et = elm.Timestamp
+	*key = elm.Elm.Interface().(int)
+	*value = elm.Elm2.Interface().(typex.U)
+	return true
+}
+
+func iterMakerETIntTypex_U(s ReStream) ReusableInput {
+	ret := &iterNative{s: s}
+	ret.fn = reflect.ValueOf(ret.readETIntTypex_U)
+	return ret
+}
+
+func (v *iterNative) readIntTypex_V(key *int, value *typex.V) bool {
+	elm, err := v.cur.Read()
+	if err != nil {
+		if err == io.EOF {
+			return false
+		}
+		panic(fmt.Sprintf("broken stream: %v", err))
+	}
+
+	*key = elm.Elm.Interface().(int)
+	*value = elm.Elm2.Interface().(typex.V)
+	return true
+}
+
+func iterMakerIntTypex_V(s ReStream) ReusableInput {
+	ret := &iterNative{s: s}
+	ret.fn = reflect.ValueOf(ret.readIntTypex_V)
+	return ret
+}
+
+func (v *iterNative) readETIntTypex_V(et *typex.EventTime, key *int, value *typex.V) bool {
+	elm, err := v.cur.Read()
+	if err != nil {
+		if err == io.EOF {
+			return false
+		}
+		panic(fmt.Sprintf("broken stream: %v", err))
+	}
+
+	*et = elm.Timestamp
+	*key = elm.Elm.Interface().(int)
+	*value = elm.Elm2.Interface().(typex.V)
+	return true
+}
+
+func iterMakerETIntTypex_V(s ReStream) ReusableInput {
+	ret := &iterNative{s: s}
+	ret.fn = reflect.ValueOf(ret.readETIntTypex_V)
+	return ret
+}
+
+func (v *iterNative) readIntTypex_W(key *int, value *typex.W) bool {
+	elm, err := v.cur.Read()
+	if err != nil {
+		if err == io.EOF {
+			return false
+		}
+		panic(fmt.Sprintf("broken stream: %v", err))
+	}
+
+	*key = elm.Elm.Interface().(int)
+	*value = elm.Elm2.Interface().(typex.W)
+	return true
+}
+
+func iterMakerIntTypex_W(s ReStream) ReusableInput {
+	ret := &iterNative{s: s}
+	ret.fn = reflect.ValueOf(ret.readIntTypex_W)
+	return ret
+}
+
+func (v *iterNative) readETIntTypex_W(et *typex.EventTime, key *int, value *typex.W) bool {
+	elm, err := v.cur.Read()
+	if err != nil {
+		if err == io.EOF {
+			return false
+		}
+		panic(fmt.Sprintf("broken stream: %v", err))
+	}
+
+	*et = elm.Timestamp
+	*key = elm.Elm.Interface().(int)
+	*value = elm.Elm2.Interface().(typex.W)
+	return true
+}
+
+func iterMakerETIntTypex_W(s ReStream) ReusableInput {
+	ret := &iterNative{s: s}
+	ret.fn = reflect.ValueOf(ret.readETIntTypex_W)
+	return ret
+}
+
+func (v *iterNative) readIntTypex_X(key *int, value *typex.X) bool {
+	elm, err := v.cur.Read()
+	if err != nil {
+		if err == io.EOF {
+			return false
+		}
+		panic(fmt.Sprintf("broken stream: %v", err))
+	}
+
+	*key = elm.Elm.Interface().(int)
+	*value = elm.Elm2.Interface().(typex.X)
+	return true
+}
+
+func iterMakerIntTypex_X(s ReStream) ReusableInput {
+	ret := &iterNative{s: s}
+	ret.fn = reflect.ValueOf(ret.readIntTypex_X)
+	return ret
+}
+
+func (v *iterNative) readETIntTypex_X(et *typex.EventTime, key *int, value *typex.X) bool {
+	elm, err := v.cur.Read()
+	if err != nil {
+		if err == io.EOF {
+			return false
+		}
+		panic(fmt.Sprintf("broken stream: %v", err))
+	}
+
+	*et = elm.Timestamp
+	*key = elm.Elm.Interface().(int)
+	*value = elm.Elm2.Interface().(typex.X)
+	return true
+}
+
+func iterMakerETIntTypex_X(s ReStream) ReusableInput {
+	ret := &iterNative{s: s}
+	ret.fn = reflect.ValueOf(ret.readETIntTypex_X)
+	return ret
+}
+
+func (v *iterNative) readIntTypex_Y(key *int, value *typex.Y) bool {
+	elm, err := v.cur.Read()
+	if err != nil {
+		if err == io.EOF {
+			return false
+		}
+		panic(fmt.Sprintf("broken stream: %v", err))
+	}
+
+	*key = elm.Elm.Interface().(int)
+	*value = elm.Elm2.Interface().(typex.Y)
+	return true
+}
+
+func iterMakerIntTypex_Y(s ReStream) ReusableInput {
+	ret := &iterNative{s: s}
+	ret.fn = reflect.ValueOf(ret.readIntTypex_Y)
+	return ret
+}
+
+func (v *iterNative) readETIntTypex_Y(et *typex.EventTime, key *int, value *typex.Y) bool {
+	elm, err := v.cur.Read()
+	if err != nil {
+		if err == io.EOF {
+			return false
+		}
+		panic(fmt.Sprintf("broken stream: %v", err))
+	}
+
+	*et = elm.Timestamp
+	*key = elm.Elm.Interface().(int)
+	*value = elm.Elm2.Interface().(typex.Y)
+	return true
+}
+
+func iterMakerETIntTypex_Y(s ReStream) ReusableInput {
+	ret := &iterNative{s: s}
+	ret.fn = reflect.ValueOf(ret.readETIntTypex_Y)
+	return ret
+}
+
+func (v *iterNative) readIntTypex_Z(key *int, value *typex.Z) bool {
+	elm, err := v.cur.Read()
+	if err != nil {
+		if err == io.EOF {
+			return false
+		}
+		panic(fmt.Sprintf("broken stream: %v", err))
+	}
+
+	*key = elm.Elm.Interface().(int)
+	*value = elm.Elm2.Interface().(typex.Z)
+	return true
+}
+
+func iterMakerIntTypex_Z(s ReStream) ReusableInput {
+	ret := &iterNative{s: s}
+	ret.fn = reflect.ValueOf(ret.readIntTypex_Z)
+	return ret
+}
+
+func (v *iterNative) readETIntTypex_Z(et *typex.EventTime, key *int, value *typex.Z) bool {
+	elm, err := v.cur.Read()
+	if err != nil {
+		if err == io.EOF {
+			return false
+		}
+		panic(fmt.Sprintf("broken stream: %v", err))
+	}
+
+	*et = elm.Timestamp
+	*key = elm.Elm.Interface().(int)
+	*value = elm.Elm2.Interface().(typex.Z)
+	return true
+}
+
+func iterMakerETIntTypex_Z(s ReStream) ReusableInput {
+	ret := &iterNative{s: s}
+	ret.fn = reflect.ValueOf(ret.readETIntTypex_Z)
+	return ret
+}
+
+func (v *iterNative) readInt8(val *int8) bool {
+	elm, err := v.cur.Read()
+	if err != nil {
+		if err == io.EOF {
+			return false
+		}
+		panic(fmt.Sprintf("broken stream: %v", err))
+	}
+
+	*val = elm.Elm.Interface().(int8)
+	return true
+}
+
+func iterMakerInt8(s ReStream) ReusableInput {
+	ret := &iterNative{s: s}
+	ret.fn = reflect.ValueOf(ret.readInt8)
+	return ret
+}
+
+func (v *iterNative) readETInt8(et *typex.EventTime, val *int8) bool {
+	elm, err := v.cur.Read()
+	if err != nil {
+		if err == io.EOF {
+			return false
+		}
+		panic(fmt.Sprintf("broken stream: %v", err))
+	}
+
+	*et = elm.Timestamp
+	*val = elm.Elm.Interface().(int8)
+	return true
+}
+
+func iterMakerETInt8(s ReStream) ReusableInput {
+	ret := &iterNative{s: s}
+	ret.fn = reflect.ValueOf(ret.readETInt8)
+	return ret
+}
+
+func (v *iterNative) readInt8ByteSlice(key *int8, value *[]byte) bool {
+	elm, err := v.cur.Read()
+	if err != nil {
+		if err == io.EOF {
+			return false
+		}
+		panic(fmt.Sprintf("broken stream: %v", err))
+	}
+
+	*key = elm.Elm.Interface().(int8)
+	*value = elm.Elm2.Interface().([]byte)
+	return true
+}
+
+func iterMakerInt8ByteSlice(s ReStream) ReusableInput {
+	ret := &iterNative{s: s}
+	ret.fn = reflect.ValueOf(ret.readInt8ByteSlice)
+	return ret
+}
+
+func (v *iterNative) readETInt8ByteSlice(et *typex.EventTime, key *int8, value *[]byte) bool {
+	elm, err := v.cur.Read()
+	if err != nil {
+		if err == io.EOF {
+			return false
+		}
+		panic(fmt.Sprintf("broken stream: %v", err))
+	}
+
+	*et = elm.Timestamp
+	*key = elm.Elm.Interface().(int8)
+	*value = elm.Elm2.Interface().([]byte)
+	return true
+}
+
+func iterMakerETInt8ByteSlice(s ReStream) ReusableInput {
+	ret := &iterNative{s: s}
+	ret.fn = reflect.ValueOf(ret.readETInt8ByteSlice)
+	return ret
+}
+
+func (v *iterNative) readInt8Bool(key *int8, value *bool) bool {
+	elm, err := v.cur.Read()
+	if err != nil {
+		if err == io.EOF {
+			return false
+		}
+		panic(fmt.Sprintf("broken stream: %v", err))
+	}
+
+	*key = elm.Elm.Interface().(int8)
+	*value = elm.Elm2.Interface().(bool)
+	return true
+}
+
+func iterMakerInt8Bool(s ReStream) ReusableInput {
+	ret := &iterNative{s: s}
+	ret.fn = reflect.ValueOf(ret.readInt8Bool)
+	return ret
+}
+
+func (v *iterNative) readETInt8Bool(et *typex.EventTime, key *int8, value *bool) bool {
+	elm, err := v.cur.Read()
+	if err != nil {
+		if err == io.EOF {
+			return false
+		}
+		panic(fmt.Sprintf("broken stream: %v", err))
+	}
+
+	*et = elm.Timestamp
+	*key = elm.Elm.Interface().(int8)
+	*value = elm.Elm2.Interface().(bool)
+	return true
+}
+
+func iterMakerETInt8Bool(s ReStream) ReusableInput {
+	ret := &iterNative{s: s}
+	ret.fn = reflect.ValueOf(ret.readETInt8Bool)
+	return ret
+}
+
+func (v *iterNative) readInt8String(key *int8, value *string) bool {
+	elm, err := v.cur.Read()
+	if err != nil {
+		if err == io.EOF {
+			return false
+		}
+		panic(fmt.Sprintf("broken stream: %v", err))
+	}
+
+	*key = elm.Elm.Interface().(int8)
+	*value = elm.Elm2.Interface().(string)
+	return true
+}
+
+func iterMakerInt8String(s ReStream) ReusableInput {
+	ret := &iterNative{s: s}
+	ret.fn = reflect.ValueOf(ret.readInt8String)
+	return ret
+}
+
+func (v *iterNative) readETInt8String(et *typex.EventTime, key *int8, value *string) bool {
+	elm, err := v.cur.Read()
+	if err != nil {
+		if err == io.EOF {
+			return false
+		}
+		panic(fmt.Sprintf("broken stream: %v", err))
+	}
+
+	*et = elm.Timestamp
+	*key = elm.Elm.Interface().(int8)
+	*value = elm.Elm2.Interface().(string)
+	return true
+}
+
+func iterMakerETInt8String(s ReStream) ReusableInput {
+	ret := &iterNative{s: s}
+	ret.fn = reflect.ValueOf(ret.readETInt8String)
+	return ret
+}
+
+func (v *iterNative) readInt8Int(key *int8, value *int) bool {
+	elm, err := v.cur.Read()
+	if err != nil {
+		if err == io.EOF {
+			return false
+		}
+		panic(fmt.Sprintf("broken stream: %v", err))
+	}
+
+	*key = elm.Elm.Interface().(int8)
+	*value = elm.Elm2.Interface().(int)
+	return true
+}
+
+func iterMakerInt8Int(s ReStream) ReusableInput {
+	ret := &iterNative{s: s}
+	ret.fn = reflect.ValueOf(ret.readInt8Int)
+	return ret
+}
+
+func (v *iterNative) readETInt8Int(et *typex.EventTime, key *int8, value *int) bool {
+	elm, err := v.cur.Read()
+	if err != nil {
+		if err == io.EOF {
+			return false
+		}
+		panic(fmt.Sprintf("broken stream: %v", err))
+	}
+
+	*et = elm.Timestamp
+	*key = elm.Elm.Interface().(int8)
+	*value = elm.Elm2.Interface().(int)
+	return true
+}
+
+func iterMakerETInt8Int(s ReStream) ReusableInput {
+	ret := &iterNative{s: s}
+	ret.fn = reflect.ValueOf(ret.readETInt8Int)
+	return ret
+}
+
+func (v *iterNative) readInt8Int8(key *int8, value *int8) bool {
+	elm, err := v.cur.Read()
+	if err != nil {
+		if err == io.EOF {
+			return false
+		}
+		panic(fmt.Sprintf("broken stream: %v", err))
+	}
+
+	*key = elm.Elm.Interface().(int8)
+	*value = elm.Elm2.Interface().(int8)
+	return true
+}
+
+func iterMakerInt8Int8(s ReStream) ReusableInput {
+	ret := &iterNative{s: s}
+	ret.fn = reflect.ValueOf(ret.readInt8Int8)
+	return ret
+}
+
+func (v *iterNative) readETInt8Int8(et *typex.EventTime, key *int8, value *int8) bool {
+	elm, err := v.cur.Read()
+	if err != nil {
+		if err == io.EOF {
+			return false
+		}
+		panic(fmt.Sprintf("broken stream: %v", err))
+	}
+
+	*et = elm.Timestamp
+	*key = elm.Elm.Interface().(int8)
+	*value = elm.Elm2.Interface().(int8)
+	return true
+}
+
+func iterMakerETInt8Int8(s ReStream) ReusableInput {
+	ret := &iterNative{s: s}
+	ret.fn = reflect.ValueOf(ret.readETInt8Int8)
+	return ret
+}
+
+func (v *iterNative) readInt8Int16(key *int8, value *int16) bool {
+	elm, err := v.cur.Read()
+	if err != nil {
+		if err == io.EOF {
+			return false
+		}
+		panic(fmt.Sprintf("broken stream: %v", err))
+	}
+
+	*key = elm.Elm.Interface().(int8)
+	*value = elm.Elm2.Interface().(int16)
+	return true
+}
+
+func iterMakerInt8Int16(s ReStream) ReusableInput {
+	ret := &iterNative{s: s}
+	ret.fn = reflect.ValueOf(ret.readInt8Int16)
+	return ret
+}
+
+func (v *iterNative) readETInt8Int16(et *typex.EventTime, key *int8, value *int16) bool {
+	elm, err := v.cur.Read()
+	if err != nil {
+		if err == io.EOF {
+			return false
+		}
+		panic(fmt.Sprintf("broken stream: %v", err))
+	}
+
+	*et = elm.Timestamp
+	*key = elm.Elm.Interface().(int8)
+	*value = elm.Elm2.Interface().(int16)
+	return true
+}
+
+func iterMakerETInt8Int16(s ReStream) ReusableInput {
+	ret := &iterNative{s: s}
+	ret.fn = reflect.ValueOf(ret.readETInt8Int16)
+	return ret
+}
+
+func (v *iterNative) readInt8Int32(key *int8, value *int32) bool {
+	elm, err := v.cur.Read()
+	if err != nil {
+		if err == io.EOF {
+			return false
+		}
+		panic(fmt.Sprintf("broken stream: %v", err))
+	}
+
+	*key = elm.Elm.Interface().(int8)
+	*value = elm.Elm2.Interface().(int32)
+	return true
+}
+
+func iterMakerInt8Int32(s ReStream) ReusableInput {
+	ret := &iterNative{s: s}
+	ret.fn = reflect.ValueOf(ret.readInt8Int32)
+	return ret
+}
+
+func (v *iterNative) readETInt8Int32(et *typex.EventTime, key *int8, value *int32) bool {
+	elm, err := v.cur.Read()
+	if err != nil {
+		if err == io.EOF {
+			return false
+		}
+		panic(fmt.Sprintf("broken stream: %v", err))
+	}
+
+	*et = elm.Timestamp
+	*key = elm.Elm.Interface().(int8)
+	*value = elm.Elm2.Interface().(int32)
+	return true
+}
+
+func iterMakerETInt8Int32(s ReStream) ReusableInput {
+	ret := &iterNative{s: s}
+	ret.fn = reflect.ValueOf(ret.readETInt8Int32)
+	return ret
+}
+
+func (v *iterNative) readInt8Int64(key *int8, value *int64) bool {
+	elm, err := v.cur.Read()
+	if err != nil {
+		if err == io.EOF {
+			return false
+		}
+		panic(fmt.Sprintf("broken stream: %v", err))
+	}
+
+	*key = elm.Elm.Interface().(int8)
+	*value = elm.Elm2.Interface().(int64)
+	return true
+}
+
+func iterMakerInt8Int64(s ReStream) ReusableInput {
+	ret := &iterNative{s: s}
+	ret.fn = reflect.ValueOf(ret.readInt8Int64)
+	return ret
+}
+
+func (v *iterNative) readETInt8Int64(et *typex.EventTime, key *int8, value *int64) bool {
+	elm, err := v.cur.Read()
+	if err != nil {
+		if err == io.EOF {
+			return false
+		}
+		panic(fmt.Sprintf("broken stream: %v", err))
+	}
+
+	*et = elm.Timestamp
+	*key = elm.Elm.Interface().(int8)
+	*value = elm.Elm2.Interface().(int64)
+	return true
+}
+
+func iterMakerETInt8Int64(s ReStream) ReusableInput {
+	ret := &iterNative{s: s}
+	ret.fn = reflect.ValueOf(ret.readETInt8Int64)
+	return ret
+}
+
+func (v *iterNative) readInt8Uint(key *int8, value *uint) bool {
+	elm, err := v.cur.Read()
+	if err != nil {
+		if err == io.EOF {
+			return false
+		}
+		panic(fmt.Sprintf("broken stream: %v", err))
+	}
+
+	*key = elm.Elm.Interface().(int8)
+	*value = elm.Elm2.Interface().(uint)
+	return true
+}
+
+func iterMakerInt8Uint(s ReStream) ReusableInput {
+	ret := &iterNative{s: s}
+	ret.fn = reflect.ValueOf(ret.readInt8Uint)
+	return ret
+}
+
+func (v *iterNative) readETInt8Uint(et *typex.EventTime, key *int8, value *uint) bool {
+	elm, err := v.cur.Read()
+	if err != nil {
+		if err == io.EOF {
+			return false
+		}
+		panic(fmt.Sprintf("broken stream: %v", err))
+	}
+
+	*et = elm.Timestamp
+	*key = elm.Elm.Interface().(int8)
+	*value = elm.Elm2.Interface().(uint)
+	return true
+}
+
+func iterMakerETInt8Uint(s ReStream) ReusableInput {
+	ret := &iterNative{s: s}
+	ret.fn = reflect.ValueOf(ret.readETInt8Uint)
+	return ret
+}
+
+func (v *iterNative) readInt8Uint8(key *int8, value *uint8) bool {
+	elm, err := v.cur.Read()
+	if err != nil {
+		if err == io.EOF {
+			return false
+		}
+		panic(fmt.Sprintf("broken stream: %v", err))
+	}
+
+	*key = elm.Elm.Interface().(int8)
+	*value = elm.Elm2.Interface().(uint8)
+	return true
+}
+
+func iterMakerInt8Uint8(s ReStream) ReusableInput {
+	ret := &iterNative{s: s}
+	ret.fn = reflect.ValueOf(ret.readInt8Uint8)
+	return ret
+}
+
+func (v *iterNative) readETInt8Uint8(et *typex.EventTime, key *int8, value *uint8) bool {
+	elm, err := v.cur.Read()
+	if err != nil {
+		if err == io.EOF {
+			return false
+		}
+		panic(fmt.Sprintf("broken stream: %v", err))
+	}
+
+	*et = elm.Timestamp
+	*key = elm.Elm.Interface().(int8)
+	*value = elm.Elm2.Interface().(uint8)
+	return true
+}
+
+func iterMakerETInt8Uint8(s ReStream) ReusableInput {
+	ret := &iterNative{s: s}
+	ret.fn = reflect.ValueOf(ret.readETInt8Uint8)
+	return ret
+}
+
+func (v *iterNative) readInt8Uint16(key *int8, value *uint16) bool {
+	elm, err := v.cur.Read()
+	if err != nil {
+		if err == io.EOF {
+			return false
+		}
+		panic(fmt.Sprintf("broken stream: %v", err))
+	}
+
+	*key = elm.Elm.Interface().(int8)
+	*value = elm.Elm2.Interface().(uint16)
+	return true
+}
+
+func iterMakerInt8Uint16(s ReStream) ReusableInput {
+	ret := &iterNative{s: s}
+	ret.fn = reflect.ValueOf(ret.readInt8Uint16)
+	return ret
+}
+
+func (v *iterNative) readETInt8Uint16(et *typex.EventTime, key *int8, value *uint16) bool {
+	elm, err := v.cur.Read()
+	if err != nil {
+		if err == io.EOF {
+			return false
+		}
+		panic(fmt.Sprintf("broken stream: %v", err))
+	}
+
+	*et = elm.Timestamp
+	*key = elm.Elm.Interface().(int8)
+	*value = elm.Elm2.Interface().(uint16)
+	return true
+}
+
+func iterMakerETInt8Uint16(s ReStream) ReusableInput {
+	ret := &iterNative{s: s}
+	ret.fn = reflect.ValueOf(ret.readETInt8Uint16)
+	return ret
+}
+
+func (v *iterNative) readInt8Uint32(key *int8, value *uint32) bool {
+	elm, err := v.cur.Read()
+	if err != nil {
+		if err == io.EOF {
+			return false
+		}
+		panic(fmt.Sprintf("broken stream: %v", err))
+	}
+
+	*key = elm.Elm.Interface().(int8)
+	*value = elm.Elm2.Interface().(uint32)
+	return true
+}
+
+func iterMakerInt8Uint32(s ReStream) ReusableInput {
+	ret := &iterNative{s: s}
+	ret.fn = reflect.ValueOf(ret.readInt8Uint32)
+	return ret
+}
+
+func (v *iterNative) readETInt8Uint32(et *typex.EventTime, key *int8, value *uint32) bool {
+	elm, err := v.cur.Read()
+	if err != nil {
+		if err == io.EOF {
+			return false
+		}
+		panic(fmt.Sprintf("broken stream: %v", err))
+	}
+
+	*et = elm.Timestamp
+	*key = elm.Elm.Interface().(int8)
+	*value = elm.Elm2.Interface().(uint32)
+	return true
+}
+
+func iterMakerETInt8Uint32(s ReStream) ReusableInput {
+	ret := &iterNative{s: s}
+	ret.fn = reflect.ValueOf(ret.readETInt8Uint32)
+	return ret
+}
+
+func (v *iterNative) readInt8Uint64(key *int8, value *uint64) bool {
+	elm, err := v.cur.Read()
+	if err != nil {
+		if err == io.EOF {
+			return false
+		}
+		panic(fmt.Sprintf("broken stream: %v", err))
+	}
+
+	*key = elm.Elm.Interface().(int8)
+	*value = elm.Elm2.Interface().(uint64)
+	return true
+}
+
+func iterMakerInt8Uint64(s ReStream) ReusableInput {
+	ret := &iterNative{s: s}
+	ret.fn = reflect.ValueOf(ret.readInt8Uint64)
+	return ret
+}
+
+func (v *iterNative) readETInt8Uint64(et *typex.EventTime, key *int8, value *uint64) bool {
+	elm, err := v.cur.Read()
+	if err != nil {
+		if err == io.EOF {
+			return false
+		}
+		panic(fmt.Sprintf("broken stream: %v", err))
+	}
+
+	*et = elm.Timestamp
+	*key = elm.Elm.Interface().(int8)
+	*value = elm.Elm2.Interface().(uint64)
+	return true
+}
+
+func iterMakerETInt8Uint64(s ReStream) ReusableInput {
+	ret := &iterNative{s: s}
+	ret.fn = reflect.ValueOf(ret.readETInt8Uint64)
+	return ret
+}
+
+func (v *iterNative) readInt8Float32(key *int8, value *float32) bool {
+	elm, err := v.cur.Read()
+	if err != nil {
+		if err == io.EOF {
+			return false
+		}
+		panic(fmt.Sprintf("broken stream: %v", err))
+	}
+
+	*key = elm.Elm.Interface().(int8)
+	*value = elm.Elm2.Interface().(float32)
+	return true
+}
+
+func iterMakerInt8Float32(s ReStream) ReusableInput {
+	ret := &iterNative{s: s}
+	ret.fn = reflect.ValueOf(ret.readInt8Float32)
+	return ret
+}
+
+func (v *iterNative) readETInt8Float32(et *typex.EventTime, key *int8, value *float32) bool {
+	elm, err := v.cur.Read()
+	if err != nil {
+		if err == io.EOF {
+			return false
+		}
+		panic(fmt.Sprintf("broken stream: %v", err))
+	}
+
+	*et = elm.Timestamp
+	*key = elm.Elm.Interface().(int8)
+	*value = elm.Elm2.Interface().(float32)
+	return true
+}
+
+func iterMakerETInt8Float32(s ReStream) ReusableInput {
+	ret := &iterNative{s: s}
+	ret.fn = reflect.ValueOf(ret.readETInt8Float32)
+	return ret
+}
+
+func (v *iterNative) readInt8Float64(key *int8, value *float64) bool {
+	elm, err := v.cur.Read()
+	if err != nil {
+		if err == io.EOF {
+			return false
+		}
+		panic(fmt.Sprintf("broken stream: %v", err))
+	}
+
+	*key = elm.Elm.Interface().(int8)
+	*value = elm.Elm2.Interface().(float64)
+	return true
+}
+
+func iterMakerInt8Float64(s ReStream) ReusableInput {
+	ret := &iterNative{s: s}
+	ret.fn = reflect.ValueOf(ret.readInt8Float64)
+	return ret
+}
+
+func (v *iterNative) readETInt8Float64(et *typex.EventTime, key *int8, value *float64) bool {
+	elm, err := v.cur.Read()
+	if err != nil {
+		if err == io.EOF {
+			return false
+		}
+		panic(fmt.Sprintf("broken stream: %v", err))
+	}
+
+	*et = elm.Timestamp
+	*key = elm.Elm.Interface().(int8)
+	*value = elm.Elm2.Interface().(float64)
+	return true
+}
+
+func iterMakerETInt8Float64(s ReStream) ReusableInput {
+	ret := &iterNative{s: s}
+	ret.fn = reflect.ValueOf(ret.readETInt8Float64)
+	return ret
+}
+
+func (v *iterNative) readInt8Typex_T(key *int8, value *typex.T) bool {
+	elm, err := v.cur.Read()
+	if err != nil {
+		if err == io.EOF {
+			return false
+		}
+		panic(fmt.Sprintf("broken stream: %v", err))
+	}
+
+	*key = elm.Elm.Interface().(int8)
+	*value = elm.Elm2.Interface().(typex.T)
+	return true
+}
+
+func iterMakerInt8Typex_T(s ReStream) ReusableInput {
+	ret := &iterNative{s: s}
+	ret.fn = reflect.ValueOf(ret.readInt8Typex_T)
+	return ret
+}
+
+func (v *iterNative) readETInt8Typex_T(et *typex.EventTime, key *int8, value *typex.T) bool {
+	elm, err := v.cur.Read()
+	if err != nil {
+		if err == io.EOF {
+			return false
+		}
+		panic(fmt.Sprintf("broken stream: %v", err))
+	}
+
+	*et = elm.Timestamp
+	*key = elm.Elm.Interface().(int8)
+	*value = elm.Elm2.Interface().(typex.T)
+	return true
+}
+
+func iterMakerETInt8Typex_T(s ReStream) ReusableInput {
+	ret := &iterNative{s: s}
+	ret.fn = reflect.ValueOf(ret.readETInt8Typex_T)
+	return ret
+}
+
+func (v *iterNative) readInt8Typex_U(key *int8, value *typex.U) bool {
+	elm, err := v.cur.Read()
+	if err != nil {
+		if err == io.EOF {
+			return false
+		}
+		panic(fmt.Sprintf("broken stream: %v", err))
+	}
+
+	*key = elm.Elm.Interface().(int8)
+	*value = elm.Elm2.Interface().(typex.U)
+	return true
+}
+
+func iterMakerInt8Typex_U(s ReStream) ReusableInput {
+	ret := &iterNative{s: s}
+	ret.fn = reflect.ValueOf(ret.readInt8Typex_U)
+	return ret
+}
+
+func (v *iterNative) readETInt8Typex_U(et *typex.EventTime, key *int8, value *typex.U) bool {
+	elm, err := v.cur.Read()
+	if err != nil {
+		if err == io.EOF {
+			return false
+		}
+		panic(fmt.Sprintf("broken stream: %v", err))
+	}
+
+	*et = elm.Timestamp
+	*key = elm.Elm.Interface().(int8)
+	*value = elm.Elm2.Interface().(typex.U)
+	return true
+}
+
+func iterMakerETInt8Typex_U(s ReStream) ReusableInput {
+	ret := &iterNative{s: s}
+	ret.fn = reflect.ValueOf(ret.readETInt8Typex_U)
+	return ret
+}
+
+func (v *iterNative) readInt8Typex_V(key *int8, value *typex.V) bool {
+	elm, err := v.cur.Read()
+	if err != nil {
+		if err == io.EOF {
+			return false
+		}
+		panic(fmt.Sprintf("broken stream: %v", err))
+	}
+
+	*key = elm.Elm.Interface().(int8)
+	*value = elm.Elm2.Interface().(typex.V)
+	return true
+}
+
+func iterMakerInt8Typex_V(s ReStream) ReusableInput {
+	ret := &iterNative{s: s}
+	ret.fn = reflect.ValueOf(ret.readInt8Typex_V)
+	return ret
+}
+
+func (v *iterNative) readETInt8Typex_V(et *typex.EventTime, key *int8, value *typex.V) bool {
+	elm, err := v.cur.Read()
+	if err != nil {
+		if err == io.EOF {
+			return false
+		}
+		panic(fmt.Sprintf("broken stream: %v", err))
+	}
+
+	*et = elm.Timestamp
+	*key = elm.Elm.Interface().(int8)
+	*value = elm.Elm2.Interface().(typex.V)
+	return true
+}
+
+func iterMakerETInt8Typex_V(s ReStream) ReusableInput {
+	ret := &iterNative{s: s}
+	ret.fn = reflect.ValueOf(ret.readETInt8Typex_V)
+	return ret
+}
+
+func (v *iterNative) readInt8Typex_W(key *int8, value *typex.W) bool {
+	elm, err := v.cur.Read()
+	if err != nil {
+		if err == io.EOF {
+			return false
+		}
+		panic(fmt.Sprintf("broken stream: %v", err))
+	}
+
+	*key = elm.Elm.Interface().(int8)
+	*value = elm.Elm2.Interface().(typex.W)
+	return true
+}
+
+func iterMakerInt8Typex_W(s ReStream) ReusableInput {
+	ret := &iterNative{s: s}
+	ret.fn = reflect.ValueOf(ret.readInt8Typex_W)
+	return ret
+}
+
+func (v *iterNative) readETInt8Typex_W(et *typex.EventTime, key *int8, value *typex.W) bool {
+	elm, err := v.cur.Read()
+	if err != nil {
+		if err == io.EOF {
+			return false
+		}
+		panic(fmt.Sprintf("broken stream: %v", err))
+	}
+
+	*et = elm.Timestamp
+	*key = elm.Elm.Interface().(int8)
+	*value = elm.Elm2.Interface().(typex.W)
+	return true
+}
+
+func iterMakerETInt8Typex_W(s ReStream) ReusableInput {
+	ret := &iterNative{s: s}
+	ret.fn = reflect.ValueOf(ret.readETInt8Typex_W)
+	return ret
+}
+
+func (v *iterNative) readInt8Typex_X(key *int8, value *typex.X) bool {
+	elm, err := v.cur.Read()
+	if err != nil {
+		if err == io.EOF {
+			return false
+		}
+		panic(fmt.Sprintf("broken stream: %v", err))
+	}
+
+	*key = elm.Elm.Interface().(int8)
+	*value = elm.Elm2.Interface().(typex.X)
+	return true
+}
+
+func iterMakerInt8Typex_X(s ReStream) ReusableInput {
+	ret := &iterNative{s: s}
+	ret.fn = reflect.ValueOf(ret.readInt8Typex_X)
+	return ret
+}
+
+func (v *iterNative) readETInt8Typex_X(et *typex.EventTime, key *int8, value *typex.X) bool {
+	elm, err := v.cur.Read()
+	if err != nil {
+		if err == io.EOF {
+			return false
+		}
+		panic(fmt.Sprintf("broken stream: %v", err))
+	}
+
+	*et = elm.Timestamp
+	*key = elm.Elm.Interface().(int8)
+	*value = elm.Elm2.Interface().(typex.X)
+	return true
+}
+
+func iterMakerETInt8Typex_X(s ReStream) ReusableInput {
+	ret := &iterNative{s: s}
+	ret.fn = reflect.ValueOf(ret.readETInt8Typex_X)
+	return ret
+}
+
+func (v *iterNative) readInt8Typex_Y(key *int8, value *typex.Y) bool {
+	elm, err := v.cur.Read()
+	if err != nil {
+		if err == io.EOF {
+			return false
+		}
+		panic(fmt.Sprintf("broken stream: %v", err))
+	}
+
+	*key = elm.Elm.Interface().(int8)
+	*value = elm.Elm2.Interface().(typex.Y)
+	return true
+}
+
+func iterMakerInt8Typex_Y(s ReStream) ReusableInput {
+	ret := &iterNative{s: s}
+	ret.fn = reflect.ValueOf(ret.readInt8Typex_Y)
+	return ret
+}
+
+func (v *iterNative) readETInt8Typex_Y(et *typex.EventTime, key *int8, value *typex.Y) bool {
+	elm, err := v.cur.Read()
+	if err != nil {
+		if err == io.EOF {
+			return false
+		}
+		panic(fmt.Sprintf("broken stream: %v", err))
+	}
+
+	*et = elm.Timestamp
+	*key = elm.Elm.Interface().(int8)
+	*value = elm.Elm2.Interface().(typex.Y)
+	return true
+}
+
+func iterMakerETInt8Typex_Y(s ReStream) ReusableInput {
+	ret := &iterNative{s: s}
+	ret.fn = reflect.ValueOf(ret.readETInt8Typex_Y)
+	return ret
+}
+
+func (v *iterNative) readInt8Typex_Z(key *int8, value *typex.Z) bool {
+	elm, err := v.cur.Read()
+	if err != nil {
+		if err == io.EOF {
+			return false
+		}
+		panic(fmt.Sprintf("broken stream: %v", err))
+	}
+
+	*key = elm.Elm.Interface().(int8)
+	*value = elm.Elm2.Interface().(typex.Z)
+	return true
+}
+
+func iterMakerInt8Typex_Z(s ReStream) ReusableInput {
+	ret := &iterNative{s: s}
+	ret.fn = reflect.ValueOf(ret.readInt8Typex_Z)
+	return ret
+}
+
+func (v *iterNative) readETInt8Typex_Z(et *typex.EventTime, key *int8, value *typex.Z) bool {
+	elm, err := v.cur.Read()
+	if err != nil {
+		if err == io.EOF {
+			return false
+		}
+		panic(fmt.Sprintf("broken stream: %v", err))
+	}
+
+	*et = elm.Timestamp
+	*key = elm.Elm.Interface().(int8)
+	*value = elm.Elm2.Interface().(typex.Z)
+	return true
+}
+
+func iterMakerETInt8Typex_Z(s ReStream) ReusableInput {
+	ret := &iterNative{s: s}
+	ret.fn = reflect.ValueOf(ret.readETInt8Typex_Z)
+	return ret
+}
+
+func (v *iterNative) readInt16(val *int16) bool {
+	elm, err := v.cur.Read()
+	if err != nil {
+		if err == io.EOF {
+			return false
+		}
+		panic(fmt.Sprintf("broken stream: %v", err))
+	}
+
+	*val = elm.Elm.Interface().(int16)
+	return true
+}
+
+func iterMakerInt16(s ReStream) ReusableInput {
+	ret := &iterNative{s: s}
+	ret.fn = reflect.ValueOf(ret.readInt16)
+	return ret
+}
+
+func (v *iterNative) readETInt16(et *typex.EventTime, val *int16) bool {
+	elm, err := v.cur.Read()
+	if err != nil {
+		if err == io.EOF {
+			return false
+		}
+		panic(fmt.Sprintf("broken stream: %v", err))
+	}
+
+	*et = elm.Timestamp
+	*val = elm.Elm.Interface().(int16)
+	return true
+}
+
+func iterMakerETInt16(s ReStream) ReusableInput {
+	ret := &iterNative{s: s}
+	ret.fn = reflect.ValueOf(ret.readETInt16)
+	return ret
+}
+
+func (v *iterNative) readInt16ByteSlice(key *int16, value *[]byte) bool {
+	elm, err := v.cur.Read()
+	if err != nil {
+		if err == io.EOF {
+			return false
+		}
+		panic(fmt.Sprintf("broken stream: %v", err))
+	}
+
+	*key = elm.Elm.Interface().(int16)
+	*value = elm.Elm2.Interface().([]byte)
+	return true
+}
+
+func iterMakerInt16ByteSlice(s ReStream) ReusableInput {
+	ret := &iterNative{s: s}
+	ret.fn = reflect.ValueOf(ret.readInt16ByteSlice)
+	return ret
+}
+
+func (v *iterNative) readETInt16ByteSlice(et *typex.EventTime, key *int16, value *[]byte) bool {
+	elm, err := v.cur.Read()
+	if err != nil {
+		if err == io.EOF {
+			return false
+		}
+		panic(fmt.Sprintf("broken stream: %v", err))
+	}
+
+	*et = elm.Timestamp
+	*key = elm.Elm.Interface().(int16)
+	*value = elm.Elm2.Interface().([]byte)
+	return true
+}
+
+func iterMakerETInt16ByteSlice(s ReStream) ReusableInput {
+	ret := &iterNative{s: s}
+	ret.fn = reflect.ValueOf(ret.readETInt16ByteSlice)
+	return ret
+}
+
+func (v *iterNative) readInt16Bool(key *int16, value *bool) bool {
+	elm, err := v.cur.Read()
+	if err != nil {
+		if err == io.EOF {
+			return false
+		}
+		panic(fmt.Sprintf("broken stream: %v", err))
+	}
+
+	*key = elm.Elm.Interface().(int16)
+	*value = elm.Elm2.Interface().(bool)
+	return true
+}
+
+func iterMakerInt16Bool(s ReStream) ReusableInput {
+	ret := &iterNative{s: s}
+	ret.fn = reflect.ValueOf(ret.readInt16Bool)
+	return ret
+}
+
+func (v *iterNative) readETInt16Bool(et *typex.EventTime, key *int16, value *bool) bool {
+	elm, err := v.cur.Read()
+	if err != nil {
+		if err == io.EOF {
+			return false
+		}
+		panic(fmt.Sprintf("broken stream: %v", err))
+	}
+
+	*et = elm.Timestamp
+	*key = elm.Elm.Interface().(int16)
+	*value = elm.Elm2.Interface().(bool)
+	return true
+}
+
+func iterMakerETInt16Bool(s ReStream) ReusableInput {
+	ret := &iterNative{s: s}
+	ret.fn = reflect.ValueOf(ret.readETInt16Bool)
+	return ret
+}
+
+func (v *iterNative) readInt16String(key *int16, value *string) bool {
+	elm, err := v.cur.Read()
+	if err != nil {
+		if err == io.EOF {
+			return false
+		}
+		panic(fmt.Sprintf("broken stream: %v", err))
+	}
+
+	*key = elm.Elm.Interface().(int16)
+	*value = elm.Elm2.Interface().(string)
+	return true
+}
+
+func iterMakerInt16String(s ReStream) ReusableInput {
+	ret := &iterNative{s: s}
+	ret.fn = reflect.ValueOf(ret.readInt16String)
+	return ret
+}
+
+func (v *iterNative) readETInt16String(et *typex.EventTime, key *int16, value *string) bool {
+	elm, err := v.cur.Read()
+	if err != nil {
+		if err == io.EOF {
+			return false
+		}
+		panic(fmt.Sprintf("broken stream: %v", err))
+	}
+
+	*et = elm.Timestamp
+	*key = elm.Elm.Interface().(int16)
+	*value = elm.Elm2.Interface().(string)
+	return true
+}
+
+func iterMakerETInt16String(s ReStream) ReusableInput {
+	ret := &iterNative{s: s}
+	ret.fn = reflect.ValueOf(ret.readETInt16String)
+	return ret
+}
+
+func (v *iterNative) readInt16Int(key *int16, value *int) bool {
+	elm, err := v.cur.Read()
+	if err != nil {
+		if err == io.EOF {
+			return false
+		}
+		panic(fmt.Sprintf("broken stream: %v", err))
+	}
+
+	*key = elm.Elm.Interface().(int16)
+	*value = elm.Elm2.Interface().(int)
+	return true
+}
+
+func iterMakerInt16Int(s ReStream) ReusableInput {
+	ret := &iterNative{s: s}
+	ret.fn = reflect.ValueOf(ret.readInt16Int)
+	return ret
+}
+
+func (v *iterNative) readETInt16Int(et *typex.EventTime, key *int16, value *int) bool {
+	elm, err := v.cur.Read()
+	if err != nil {
+		if err == io.EOF {
+			return false
+		}
+		panic(fmt.Sprintf("broken stream: %v", err))
+	}
+
+	*et = elm.Timestamp
+	*key = elm.Elm.Interface().(int16)
+	*value = elm.Elm2.Interface().(int)
+	return true
+}
+
+func iterMakerETInt16Int(s ReStream) ReusableInput {
+	ret := &iterNative{s: s}
+	ret.fn = reflect.ValueOf(ret.readETInt16Int)
+	return ret
+}
+
+func (v *iterNative) readInt16Int8(key *int16, value *int8) bool {
+	elm, err := v.cur.Read()
+	if err != nil {
+		if err == io.EOF {
+			return false
+		}
+		panic(fmt.Sprintf("broken stream: %v", err))
+	}
+
+	*key = elm.Elm.Interface().(int16)
+	*value = elm.Elm2.Interface().(int8)
+	return true
+}
+
+func iterMakerInt16Int8(s ReStream) ReusableInput {
+	ret := &iterNative{s: s}
+	ret.fn = reflect.ValueOf(ret.readInt16Int8)
+	return ret
+}
+
+func (v *iterNative) readETInt16Int8(et *typex.EventTime, key *int16, value *int8) bool {
+	elm, err := v.cur.Read()
+	if err != nil {
+		if err == io.EOF {
+			return false
+		}
+		panic(fmt.Sprintf("broken stream: %v", err))
+	}
+
+	*et = elm.Timestamp
+	*key = elm.Elm.Interface().(int16)
+	*value = elm.Elm2.Interface().(int8)
+	return true
+}
+
+func iterMakerETInt16Int8(s ReStream) ReusableInput {
+	ret := &iterNative{s: s}
+	ret.fn = reflect.ValueOf(ret.readETInt16Int8)
+	return ret
+}
+
+func (v *iterNative) readInt16Int16(key *int16, value *int16) bool {
+	elm, err := v.cur.Read()
+	if err != nil {
+		if err == io.EOF {
+			return false
+		}
+		panic(fmt.Sprintf("broken stream: %v", err))
+	}
+
+	*key = elm.Elm.Interface().(int16)
+	*value = elm.Elm2.Interface().(int16)
+	return true
+}
+
+func iterMakerInt16Int16(s ReStream) ReusableInput {
+	ret := &iterNative{s: s}
+	ret.fn = reflect.ValueOf(ret.readInt16Int16)
+	return ret
+}
+
+func (v *iterNative) readETInt16Int16(et *typex.EventTime, key *int16, value *int16) bool {
+	elm, err := v.cur.Read()
+	if err != nil {
+		if err == io.EOF {
+			return false
+		}
+		panic(fmt.Sprintf("broken stream: %v", err))
+	}
+
+	*et = elm.Timestamp
+	*key = elm.Elm.Interface().(int16)
+	*value = elm.Elm2.Interface().(int16)
+	return true
+}
+
+func iterMakerETInt16Int16(s ReStream) ReusableInput {
+	ret := &iterNative{s: s}
+	ret.fn = reflect.ValueOf(ret.readETInt16Int16)
+	return ret
+}
+
+func (v *iterNative) readInt16Int32(key *int16, value *int32) bool {
+	elm, err := v.cur.Read()
+	if err != nil {
+		if err == io.EOF {
+			return false
+		}
+		panic(fmt.Sprintf("broken stream: %v", err))
+	}
+
+	*key = elm.Elm.Interface().(int16)
+	*value = elm.Elm2.Interface().(int32)
+	return true
+}
+
+func iterMakerInt16Int32(s ReStream) ReusableInput {
+	ret := &iterNative{s: s}
+	ret.fn = reflect.ValueOf(ret.readInt16Int32)
+	return ret
+}
+
+func (v *iterNative) readETInt16Int32(et *typex.EventTime, key *int16, value *int32) bool {
+	elm, err := v.cur.Read()
+	if err != nil {
+		if err == io.EOF {
+			return false
+		}
+		panic(fmt.Sprintf("broken stream: %v", err))
+	}
+
+	*et = elm.Timestamp
+	*key = elm.Elm.Interface().(int16)
+	*value = elm.Elm2.Interface().(int32)
+	return true
+}
+
+func iterMakerETInt16Int32(s ReStream) ReusableInput {
+	ret := &iterNative{s: s}
+	ret.fn = reflect.ValueOf(ret.readETInt16Int32)
+	return ret
+}
+
+func (v *iterNative) readInt16Int64(key *int16, value *int64) bool {
+	elm, err := v.cur.Read()
+	if err != nil {
+		if err == io.EOF {
+			return false
+		}
+		panic(fmt.Sprintf("broken stream: %v", err))
+	}
+
+	*key = elm.Elm.Interface().(int16)
+	*value = elm.Elm2.Interface().(int64)
+	return true
+}
+
+func iterMakerInt16Int64(s ReStream) ReusableInput {
+	ret := &iterNative{s: s}
+	ret.fn = reflect.ValueOf(ret.readInt16Int64)
+	return ret
+}
+
+func (v *iterNative) readETInt16Int64(et *typex.EventTime, key *int16, value *int64) bool {
+	elm, err := v.cur.Read()
+	if err != nil {
+		if err == io.EOF {
+			return false
+		}
+		panic(fmt.Sprintf("broken stream: %v", err))
+	}
+
+	*et = elm.Timestamp
+	*key = elm.Elm.Interface().(int16)
+	*value = elm.Elm2.Interface().(int64)
+	return true
+}
+
+func iterMakerETInt16Int64(s ReStream) ReusableInput {
+	ret := &iterNative{s: s}
+	ret.fn = reflect.ValueOf(ret.readETInt16Int64)
+	return ret
+}
+
+func (v *iterNative) readInt16Uint(key *int16, value *uint) bool {
+	elm, err := v.cur.Read()
+	if err != nil {
+		if err == io.EOF {
+			return false
+		}
+		panic(fmt.Sprintf("broken stream: %v", err))
+	}
+
+	*key = elm.Elm.Interface().(int16)
+	*value = elm.Elm2.Interface().(uint)
+	return true
+}
+
+func iterMakerInt16Uint(s ReStream) ReusableInput {
+	ret := &iterNative{s: s}
+	ret.fn = reflect.ValueOf(ret.readInt16Uint)
+	return ret
+}
+
+func (v *iterNative) readETInt16Uint(et *typex.EventTime, key *int16, value *uint) bool {
+	elm, err := v.cur.Read()
+	if err != nil {
+		if err == io.EOF {
+			return false
+		}
+		panic(fmt.Sprintf("broken stream: %v", err))
+	}
+
+	*et = elm.Timestamp
+	*key = elm.Elm.Interface().(int16)
+	*value = elm.Elm2.Interface().(uint)
+	return true
+}
+
+func iterMakerETInt16Uint(s ReStream) ReusableInput {
+	ret := &iterNative{s: s}
+	ret.fn = reflect.ValueOf(ret.readETInt16Uint)
+	return ret
+}
+
+func (v *iterNative) readInt16Uint8(key *int16, value *uint8) bool {
+	elm, err := v.cur.Read()
+	if err != nil {
+		if err == io.EOF {
+			return false
+		}
+		panic(fmt.Sprintf("broken stream: %v", err))
+	}
+
+	*key = elm.Elm.Interface().(int16)
+	*value = elm.Elm2.Interface().(uint8)
+	return true
+}
+
+func iterMakerInt16Uint8(s ReStream) ReusableInput {
+	ret := &iterNative{s: s}
+	ret.fn = reflect.ValueOf(ret.readInt16Uint8)
+	return ret
+}
+
+func (v *iterNative) readETInt16Uint8(et *typex.EventTime, key *int16, value *uint8) bool {
+	elm, err := v.cur.Read()
+	if err != nil {
+		if err == io.EOF {
+			return false
+		}
+		panic(fmt.Sprintf("broken stream: %v", err))
+	}
+
+	*et = elm.Timestamp
+	*key = elm.Elm.Interface().(int16)
+	*value = elm.Elm2.Interface().(uint8)
+	return true
+}
+
+func iterMakerETInt16Uint8(s ReStream) ReusableInput {
+	ret := &iterNative{s: s}
+	ret.fn = reflect.ValueOf(ret.readETInt16Uint8)
+	return ret
+}
+
+func (v *iterNative) readInt16Uint16(key *int16, value *uint16) bool {
+	elm, err := v.cur.Read()
+	if err != nil {
+		if err == io.EOF {
+			return false
+		}
+		panic(fmt.Sprintf("broken stream: %v", err))
+	}
+
+	*key = elm.Elm.Interface().(int16)
+	*value = elm.Elm2.Interface().(uint16)
+	return true
+}
+
+func iterMakerInt16Uint16(s ReStream) ReusableInput {
+	ret := &iterNative{s: s}
+	ret.fn = reflect.ValueOf(ret.readInt16Uint16)
+	return ret
+}
+
+func (v *iterNative) readETInt16Uint16(et *typex.EventTime, key *int16, value *uint16) bool {
+	elm, err := v.cur.Read()
+	if err != nil {
+		if err == io.EOF {
+			return false
+		}
+		panic(fmt.Sprintf("broken stream: %v", err))
+	}
+
+	*et = elm.Timestamp
+	*key = elm.Elm.Interface().(int16)
+	*value = elm.Elm2.Interface().(uint16)
+	return true
+}
+
+func iterMakerETInt16Uint16(s ReStream) ReusableInput {
+	ret := &iterNative{s: s}
+	ret.fn = reflect.ValueOf(ret.readETInt16Uint16)
+	return ret
+}
+
+func (v *iterNative) readInt16Uint32(key *int16, value *uint32) bool {
+	elm, err := v.cur.Read()
+	if err != nil {
+		if err == io.EOF {
+			return false
+		}
+		panic(fmt.Sprintf("broken stream: %v", err))
+	}
+
+	*key = elm.Elm.Interface().(int16)
+	*value = elm.Elm2.Interface().(uint32)
+	return true
+}
+
+func iterMakerInt16Uint32(s ReStream) ReusableInput {
+	ret := &iterNative{s: s}
+	ret.fn = reflect.ValueOf(ret.readInt16Uint32)
+	return ret
+}
+
+func (v *iterNative) readETInt16Uint32(et *typex.EventTime, key *int16, value *uint32) bool {
+	elm, err := v.cur.Read()
+	if err != nil {
+		if err == io.EOF {
+			return false
+		}
+		panic(fmt.Sprintf("broken stream: %v", err))
+	}
+
+	*et = elm.Timestamp
+	*key = elm.Elm.Interface().(int16)
+	*value = elm.Elm2.Interface().(uint32)
+	return true
+}
+
+func iterMakerETInt16Uint32(s ReStream) ReusableInput {
+	ret := &iterNative{s: s}
+	ret.fn = reflect.ValueOf(ret.readETInt16Uint32)
+	return ret
+}
+
+func (v *iterNative) readInt16Uint64(key *int16, value *uint64) bool {
+	elm, err := v.cur.Read()
+	if err != nil {
+		if err == io.EOF {
+			return false
+		}
+		panic(fmt.Sprintf("broken stream: %v", err))
+	}
+
+	*key = elm.Elm.Interface().(int16)
+	*value = elm.Elm2.Interface().(uint64)
+	return true
+}
+
+func iterMakerInt16Uint64(s ReStream) ReusableInput {
+	ret := &iterNative{s: s}
+	ret.fn = reflect.ValueOf(ret.readInt16Uint64)
+	return ret
+}
+
+func (v *iterNative) readETInt16Uint64(et *typex.EventTime, key *int16, value *uint64) bool {
+	elm, err := v.cur.Read()
+	if err != nil {
+		if err == io.EOF {
+			return false
+		}
+		panic(fmt.Sprintf("broken stream: %v", err))
+	}
+
+	*et = elm.Timestamp
+	*key = elm.Elm.Interface().(int16)
+	*value = elm.Elm2.Interface().(uint64)
+	return true
+}
+
+func iterMakerETInt16Uint64(s ReStream) ReusableInput {
+	ret := &iterNative{s: s}
+	ret.fn = reflect.ValueOf(ret.readETInt16Uint64)
+	return ret
+}
+
+func (v *iterNative) readInt16Float32(key *int16, value *float32) bool {
+	elm, err := v.cur.Read()
+	if err != nil {
+		if err == io.EOF {
+			return false
+		}
+		panic(fmt.Sprintf("broken stream: %v", err))
+	}
+
+	*key = elm.Elm.Interface().(int16)
+	*value = elm.Elm2.Interface().(float32)
+	return true
+}
+
+func iterMakerInt16Float32(s ReStream) ReusableInput {
+	ret := &iterNative{s: s}
+	ret.fn = reflect.ValueOf(ret.readInt16Float32)
+	return ret
+}
+
+func (v *iterNative) readETInt16Float32(et *typex.EventTime, key *int16, value *float32) bool {
+	elm, err := v.cur.Read()
+	if err != nil {
+		if err == io.EOF {
+			return false
+		}
+		panic(fmt.Sprintf("broken stream: %v", err))
+	}
+
+	*et = elm.Timestamp
+	*key = elm.Elm.Interface().(int16)
+	*value = elm.Elm2.Interface().(float32)
+	return true
+}
+
+func iterMakerETInt16Float32(s ReStream) ReusableInput {
+	ret := &iterNative{s: s}
+	ret.fn = reflect.ValueOf(ret.readETInt16Float32)
+	return ret
+}
+
+func (v *iterNative) readInt16Float64(key *int16, value *float64) bool {
+	elm, err := v.cur.Read()
+	if err != nil {
+		if err == io.EOF {
+			return false
+		}
+		panic(fmt.Sprintf("broken stream: %v", err))
+	}
+
+	*key = elm.Elm.Interface().(int16)
+	*value = elm.Elm2.Interface().(float64)
+	return true
+}
+
+func iterMakerInt16Float64(s ReStream) ReusableInput {
+	ret := &iterNative{s: s}
+	ret.fn = reflect.ValueOf(ret.readInt16Float64)
+	return ret
+}
+
+func (v *iterNative) readETInt16Float64(et *typex.EventTime, key *int16, value *float64) bool {
+	elm, err := v.cur.Read()
+	if err != nil {
+		if err == io.EOF {
+			return false
+		}
+		panic(fmt.Sprintf("broken stream: %v", err))
+	}
+
+	*et = elm.Timestamp
+	*key = elm.Elm.Interface().(int16)
+	*value = elm.Elm2.Interface().(float64)
+	return true
+}
+
+func iterMakerETInt16Float64(s ReStream) ReusableInput {
+	ret := &iterNative{s: s}
+	ret.fn = reflect.ValueOf(ret.readETInt16Float64)
+	return ret
+}
+
+func (v *iterNative) readInt16Typex_T(key *int16, value *typex.T) bool {
+	elm, err := v.cur.Read()
+	if err != nil {
+		if err == io.EOF {
+			return false
+		}
+		panic(fmt.Sprintf("broken stream: %v", err))
+	}
+
+	*key = elm.Elm.Interface().(int16)
+	*value = elm.Elm2.Interface().(typex.T)
+	return true
+}
+
+func iterMakerInt16Typex_T(s ReStream) ReusableInput {
+	ret := &iterNative{s: s}
+	ret.fn = reflect.ValueOf(ret.readInt16Typex_T)
+	return ret
+}
+
+func (v *iterNative) readETInt16Typex_T(et *typex.EventTime, key *int16, value *typex.T) bool {
+	elm, err := v.cur.Read()
+	if err != nil {
+		if err == io.EOF {
+			return false
+		}
+		panic(fmt.Sprintf("broken stream: %v", err))
+	}
+
+	*et = elm.Timestamp
+	*key = elm.Elm.Interface().(int16)
+	*value = elm.Elm2.Interface().(typex.T)
+	return true
+}
+
+func iterMakerETInt16Typex_T(s ReStream) ReusableInput {
+	ret := &iterNative{s: s}
+	ret.fn = reflect.ValueOf(ret.readETInt16Typex_T)
+	return ret
+}
+
+func (v *iterNative) readInt16Typex_U(key *int16, value *typex.U) bool {
+	elm, err := v.cur.Read()
+	if err != nil {
+		if err == io.EOF {
+			return false
+		}
+		panic(fmt.Sprintf("broken stream: %v", err))
+	}
+
+	*key = elm.Elm.Interface().(int16)
+	*value = elm.Elm2.Interface().(typex.U)
+	return true
+}
+
+func iterMakerInt16Typex_U(s ReStream) ReusableInput {
+	ret := &iterNative{s: s}
+	ret.fn = reflect.ValueOf(ret.readInt16Typex_U)
+	return ret
+}
+
+func (v *iterNative) readETInt16Typex_U(et *typex.EventTime, key *int16, value *typex.U) bool {
+	elm, err := v.cur.Read()
+	if err != nil {
+		if err == io.EOF {
+			return false
+		}
+		panic(fmt.Sprintf("broken stream: %v", err))
+	}
+
+	*et = elm.Timestamp
+	*key = elm.Elm.Interface().(int16)
+	*value = elm.Elm2.Interface().(typex.U)
+	return true
+}
+
+func iterMakerETInt16Typex_U(s ReStream) ReusableInput {
+	ret := &iterNative{s: s}
+	ret.fn = reflect.ValueOf(ret.readETInt16Typex_U)
+	return ret
+}
+
+func (v *iterNative) readInt16Typex_V(key *int16, value *typex.V) bool {
+	elm, err := v.cur.Read()
+	if err != nil {
+		if err == io.EOF {
+			return false
+		}
+		panic(fmt.Sprintf("broken stream: %v", err))
+	}
+
+	*key = elm.Elm.Interface().(int16)
+	*value = elm.Elm2.Interface().(typex.V)
+	return true
+}
+
+func iterMakerInt16Typex_V(s ReStream) ReusableInput {
+	ret := &iterNative{s: s}
+	ret.fn = reflect.ValueOf(ret.readInt16Typex_V)
+	return ret
+}
+
+func (v *iterNative) readETInt16Typex_V(et *typex.EventTime, key *int16, value *typex.V) bool {
+	elm, err := v.cur.Read()
+	if err != nil {
+		if err == io.EOF {
+			return false
+		}
+		panic(fmt.Sprintf("broken stream: %v", err))
+	}
+
+	*et = elm.Timestamp
+	*key = elm.Elm.Interface().(int16)
+	*value = elm.Elm2.Interface().(typex.V)
+	return true
+}
+
+func iterMakerETInt16Typex_V(s ReStream) ReusableInput {
+	ret := &iterNative{s: s}
+	ret.fn = reflect.ValueOf(ret.readETInt16Typex_V)
+	return ret
+}
+
+func (v *iterNative) readInt16Typex_W(key *int16, value *typex.W) bool {
+	elm, err := v.cur.Read()
+	if err != nil {
+		if err == io.EOF {
+			return false
+		}
+		panic(fmt.Sprintf("broken stream: %v", err))
+	}
+
+	*key = elm.Elm.Interface().(int16)
+	*value = elm.Elm2.Interface().(typex.W)
+	return true
+}
+
+func iterMakerInt16Typex_W(s ReStream) ReusableInput {
+	ret := &iterNative{s: s}
+	ret.fn = reflect.ValueOf(ret.readInt16Typex_W)
+	return ret
+}
+
+func (v *iterNative) readETInt16Typex_W(et *typex.EventTime, key *int16, value *typex.W) bool {
+	elm, err := v.cur.Read()
+	if err != nil {
+		if err == io.EOF {
+			return false
+		}
+		panic(fmt.Sprintf("broken stream: %v", err))
+	}
+
+	*et = elm.Timestamp
+	*key = elm.Elm.Interface().(int16)
+	*value = elm.Elm2.Interface().(typex.W)
+	return true
+}
+
+func iterMakerETInt16Typex_W(s ReStream) ReusableInput {
+	ret := &iterNative{s: s}
+	ret.fn = reflect.ValueOf(ret.readETInt16Typex_W)
+	return ret
+}
+
+func (v *iterNative) readInt16Typex_X(key *int16, value *typex.X) bool {
+	elm, err := v.cur.Read()
+	if err != nil {
+		if err == io.EOF {
+			return false
+		}
+		panic(fmt.Sprintf("broken stream: %v", err))
+	}
+
+	*key = elm.Elm.Interface().(int16)
+	*value = elm.Elm2.Interface().(typex.X)
+	return true
+}
+
+func iterMakerInt16Typex_X(s ReStream) ReusableInput {
+	ret := &iterNative{s: s}
+	ret.fn = reflect.ValueOf(ret.readInt16Typex_X)
+	return ret
+}
+
+func (v *iterNative) readETInt16Typex_X(et *typex.EventTime, key *int16, value *typex.X) bool {
+	elm, err := v.cur.Read()
+	if err != nil {
+		if err == io.EOF {
+			return false
+		}
+		panic(fmt.Sprintf("broken stream: %v", err))
+	}
+
+	*et = elm.Timestamp
+	*key = elm.Elm.Interface().(int16)
+	*value = elm.Elm2.Interface().(typex.X)
+	return true
+}
+
+func iterMakerETInt16Typex_X(s ReStream) ReusableInput {
+	ret := &iterNative{s: s}
+	ret.fn = reflect.ValueOf(ret.readETInt16Typex_X)
+	return ret
+}
+
+func (v *iterNative) readInt16Typex_Y(key *int16, value *typex.Y) bool {
+	elm, err := v.cur.Read()
+	if err != nil {
+		if err == io.EOF {
+			return false
+		}
+		panic(fmt.Sprintf("broken stream: %v", err))
+	}
+
+	*key = elm.Elm.Interface().(int16)
+	*value = elm.Elm2.Interface().(typex.Y)
+	return true
+}
+
+func iterMakerInt16Typex_Y(s ReStream) ReusableInput {
+	ret := &iterNative{s: s}
+	ret.fn = reflect.ValueOf(ret.readInt16Typex_Y)
+	return ret
+}
+
+func (v *iterNative) readETInt16Typex_Y(et *typex.EventTime, key *int16, value *typex.Y) bool {
+	elm, err := v.cur.Read()
+	if err != nil {
+		if err == io.EOF {
+			return false
+		}
+		panic(fmt.Sprintf("broken stream: %v", err))
+	}
+
+	*et = elm.Timestamp
+	*key = elm.Elm.Interface().(int16)
+	*value = elm.Elm2.Interface().(typex.Y)
+	return true
+}
+
+func iterMakerETInt16Typex_Y(s ReStream) ReusableInput {
+	ret := &iterNative{s: s}
+	ret.fn = reflect.ValueOf(ret.readETInt16Typex_Y)
+	return ret
+}
+
+func (v *iterNative) readInt16Typex_Z(key *int16, value *typex.Z) bool {
+	elm, err := v.cur.Read()
+	if err != nil {
+		if err == io.EOF {
+			return false
+		}
+		panic(fmt.Sprintf("broken stream: %v", err))
+	}
+
+	*key = elm.Elm.Interface().(int16)
+	*value = elm.Elm2.Interface().(typex.Z)
+	return true
+}
+
+func iterMakerInt16Typex_Z(s ReStream) ReusableInput {
+	ret := &iterNative{s: s}
+	ret.fn = reflect.ValueOf(ret.readInt16Typex_Z)
+	return ret
+}
+
+func (v *iterNative) readETInt16Typex_Z(et *typex.EventTime, key *int16, value *typex.Z) bool {
+	elm, err := v.cur.Read()
+	if err != nil {
+		if err == io.EOF {
+			return false
+		}
+		panic(fmt.Sprintf("broken stream: %v", err))
+	}
+
+	*et = elm.Timestamp
+	*key = elm.Elm.Interface().(int16)
+	*value = elm.Elm2.Interface().(typex.Z)
+	return true
+}
+
+func iterMakerETInt16Typex_Z(s ReStream) ReusableInput {
+	ret := &iterNative{s: s}
+	ret.fn = reflect.ValueOf(ret.readETInt16Typex_Z)
+	return ret
+}
+
+func (v *iterNative) readInt32(val *int32) bool {
+	elm, err := v.cur.Read()
+	if err != nil {
+		if err == io.EOF {
+			return false
+		}
+		panic(fmt.Sprintf("broken stream: %v", err))
+	}
+
+	*val = elm.Elm.Interface().(int32)
+	return true
+}
+
+func iterMakerInt32(s ReStream) ReusableInput {
+	ret := &iterNative{s: s}
+	ret.fn = reflect.ValueOf(ret.readInt32)
+	return ret
+}
+
+func (v *iterNative) readETInt32(et *typex.EventTime, val *int32) bool {
+	elm, err := v.cur.Read()
+	if err != nil {
+		if err == io.EOF {
+			return false
+		}
+		panic(fmt.Sprintf("broken stream: %v", err))
+	}
+
+	*et = elm.Timestamp
+	*val = elm.Elm.Interface().(int32)
+	return true
+}
+
+func iterMakerETInt32(s ReStream) ReusableInput {
+	ret := &iterNative{s: s}
+	ret.fn = reflect.ValueOf(ret.readETInt32)
+	return ret
+}
+
+func (v *iterNative) readInt32ByteSlice(key *int32, value *[]byte) bool {
+	elm, err := v.cur.Read()
+	if err != nil {
+		if err == io.EOF {
+			return false
+		}
+		panic(fmt.Sprintf("broken stream: %v", err))
+	}
+
+	*key = elm.Elm.Interface().(int32)
+	*value = elm.Elm2.Interface().([]byte)
+	return true
+}
+
+func iterMakerInt32ByteSlice(s ReStream) ReusableInput {
+	ret := &iterNative{s: s}
+	ret.fn = reflect.ValueOf(ret.readInt32ByteSlice)
+	return ret
+}
+
+func (v *iterNative) readETInt32ByteSlice(et *typex.EventTime, key *int32, value *[]byte) bool {
+	elm, err := v.cur.Read()
+	if err != nil {
+		if err == io.EOF {
+			return false
+		}
+		panic(fmt.Sprintf("broken stream: %v", err))
+	}
+
+	*et = elm.Timestamp
+	*key = elm.Elm.Interface().(int32)
+	*value = elm.Elm2.Interface().([]byte)
+	return true
+}
+
+func iterMakerETInt32ByteSlice(s ReStream) ReusableInput {
+	ret := &iterNative{s: s}
+	ret.fn = reflect.ValueOf(ret.readETInt32ByteSlice)
+	return ret
+}
+
+func (v *iterNative) readInt32Bool(key *int32, value *bool) bool {
+	elm, err := v.cur.Read()
+	if err != nil {
+		if err == io.EOF {
+			return false
+		}
+		panic(fmt.Sprintf("broken stream: %v", err))
+	}
+
+	*key = elm.Elm.Interface().(int32)
+	*value = elm.Elm2.Interface().(bool)
+	return true
+}
+
+func iterMakerInt32Bool(s ReStream) ReusableInput {
+	ret := &iterNative{s: s}
+	ret.fn = reflect.ValueOf(ret.readInt32Bool)
+	return ret
+}
+
+func (v *iterNative) readETInt32Bool(et *typex.EventTime, key *int32, value *bool) bool {
+	elm, err := v.cur.Read()
+	if err != nil {
+		if err == io.EOF {
+			return false
+		}
+		panic(fmt.Sprintf("broken stream: %v", err))
+	}
+
+	*et = elm.Timestamp
+	*key = elm.Elm.Interface().(int32)
+	*value = elm.Elm2.Interface().(bool)
+	return true
+}
+
+func iterMakerETInt32Bool(s ReStream) ReusableInput {
+	ret := &iterNative{s: s}
+	ret.fn = reflect.ValueOf(ret.readETInt32Bool)
+	return ret
+}
+
+func (v *iterNative) readInt32String(key *int32, value *string) bool {
+	elm, err := v.cur.Read()
+	if err != nil {
+		if err == io.EOF {
+			return false
+		}
+		panic(fmt.Sprintf("broken stream: %v", err))
+	}
+
+	*key = elm.Elm.Interface().(int32)
+	*value = elm.Elm2.Interface().(string)
+	return true
+}
+
+func iterMakerInt32String(s ReStream) ReusableInput {
+	ret := &iterNative{s: s}
+	ret.fn = reflect.ValueOf(ret.readInt32String)
+	return ret
+}
+
+func (v *iterNative) readETInt32String(et *typex.EventTime, key *int32, value *string) bool {
+	elm, err := v.cur.Read()
+	if err != nil {
+		if err == io.EOF {
+			return false
+		}
+		panic(fmt.Sprintf("broken stream: %v", err))
+	}
+
+	*et = elm.Timestamp
+	*key = elm.Elm.Interface().(int32)
+	*value = elm.Elm2.Interface().(string)
+	return true
+}
+
+func iterMakerETInt32String(s ReStream) ReusableInput {
+	ret := &iterNative{s: s}
+	ret.fn = reflect.ValueOf(ret.readETInt32String)
+	return ret
+}
+
+func (v *iterNative) readInt32Int(key *int32, value *int) bool {
+	elm, err := v.cur.Read()
+	if err != nil {
+		if err == io.EOF {
+			return false
+		}
+		panic(fmt.Sprintf("broken stream: %v", err))
+	}
+
+	*key = elm.Elm.Interface().(int32)
+	*value = elm.Elm2.Interface().(int)
+	return true
+}
+
+func iterMakerInt32Int(s ReStream) ReusableInput {
+	ret := &iterNative{s: s}
+	ret.fn = reflect.ValueOf(ret.readInt32Int)
+	return ret
+}
+
+func (v *iterNative) readETInt32Int(et *typex.EventTime, key *int32, value *int) bool {
+	elm, err := v.cur.Read()
+	if err != nil {
+		if err == io.EOF {
+			return false
+		}
+		panic(fmt.Sprintf("broken stream: %v", err))
+	}
+
+	*et = elm.Timestamp
+	*key = elm.Elm.Interface().(int32)
+	*value = elm.Elm2.Interface().(int)
+	return true
+}
+
+func iterMakerETInt32Int(s ReStream) ReusableInput {
+	ret := &iterNative{s: s}
+	ret.fn = reflect.ValueOf(ret.readETInt32Int)
+	return ret
+}
+
+func (v *iterNative) readInt32Int8(key *int32, value *int8) bool {
+	elm, err := v.cur.Read()
+	if err != nil {
+		if err == io.EOF {
+			return false
+		}
+		panic(fmt.Sprintf("broken stream: %v", err))
+	}
+
+	*key = elm.Elm.Interface().(int32)
+	*value = elm.Elm2.Interface().(int8)
+	return true
+}
+
+func iterMakerInt32Int8(s ReStream) ReusableInput {
+	ret := &iterNative{s: s}
+	ret.fn = reflect.ValueOf(ret.readInt32Int8)
+	return ret
+}
+
+func (v *iterNative) readETInt32Int8(et *typex.EventTime, key *int32, value *int8) bool {
+	elm, err := v.cur.Read()
+	if err != nil {
+		if err == io.EOF {
+			return false
+		}
+		panic(fmt.Sprintf("broken stream: %v", err))
+	}
+
+	*et = elm.Timestamp
+	*key = elm.Elm.Interface().(int32)
+	*value = elm.Elm2.Interface().(int8)
+	return true
+}
+
+func iterMakerETInt32Int8(s ReStream) ReusableInput {
+	ret := &iterNative{s: s}
+	ret.fn = reflect.ValueOf(ret.readETInt32Int8)
+	return ret
+}
+
+func (v *iterNative) readInt32Int16(key *int32, value *int16) bool {
+	elm, err := v.cur.Read()
+	if err != nil {
+		if err == io.EOF {
+			return false
+		}
+		panic(fmt.Sprintf("broken stream: %v", err))
+	}
+
+	*key = elm.Elm.Interface().(int32)
+	*value = elm.Elm2.Interface().(int16)
+	return true
+}
+
+func iterMakerInt32Int16(s ReStream) ReusableInput {
+	ret := &iterNative{s: s}
+	ret.fn = reflect.ValueOf(ret.readInt32Int16)
+	return ret
+}
+
+func (v *iterNative) readETInt32Int16(et *typex.EventTime, key *int32, value *int16) bool {
+	elm, err := v.cur.Read()
+	if err != nil {
+		if err == io.EOF {
+			return false
+		}
+		panic(fmt.Sprintf("broken stream: %v", err))
+	}
+
+	*et = elm.Timestamp
+	*key = elm.Elm.Interface().(int32)
+	*value = elm.Elm2.Interface().(int16)
+	return true
+}
+
+func iterMakerETInt32Int16(s ReStream) ReusableInput {
+	ret := &iterNative{s: s}
+	ret.fn = reflect.ValueOf(ret.readETInt32Int16)
+	return ret
+}
+
+func (v *iterNative) readInt32Int32(key *int32, value *int32) bool {
+	elm, err := v.cur.Read()
+	if err != nil {
+		if err == io.EOF {
+			return false
+		}
+		panic(fmt.Sprintf("broken stream: %v", err))
+	}
+
+	*key = elm.Elm.Interface().(int32)
+	*value = elm.Elm2.Interface().(int32)
+	return true
+}
+
+func iterMakerInt32Int32(s ReStream) ReusableInput {
+	ret := &iterNative{s: s}
+	ret.fn = reflect.ValueOf(ret.readInt32Int32)
+	return ret
+}
+
+func (v *iterNative) readETInt32Int32(et *typex.EventTime, key *int32, value *int32) bool {
+	elm, err := v.cur.Read()
+	if err != nil {
+		if err == io.EOF {
+			return false
+		}
+		panic(fmt.Sprintf("broken stream: %v", err))
+	}
+
+	*et = elm.Timestamp
+	*key = elm.Elm.Interface().(int32)
+	*value = elm.Elm2.Interface().(int32)
+	return true
+}
+
+func iterMakerETInt32Int32(s ReStream) ReusableInput {
+	ret := &iterNative{s: s}
+	ret.fn = reflect.ValueOf(ret.readETInt32Int32)
+	return ret
+}
+
+func (v *iterNative) readInt32Int64(key *int32, value *int64) bool {
+	elm, err := v.cur.Read()
+	if err != nil {
+		if err == io.EOF {
+			return false
+		}
+		panic(fmt.Sprintf("broken stream: %v", err))
+	}
+
+	*key = elm.Elm.Interface().(int32)
+	*value = elm.Elm2.Interface().(int64)
+	return true
+}
+
+func iterMakerInt32Int64(s ReStream) ReusableInput {
+	ret := &iterNative{s: s}
+	ret.fn = reflect.ValueOf(ret.readInt32Int64)
+	return ret
+}
+
+func (v *iterNative) readETInt32Int64(et *typex.EventTime, key *int32, value *int64) bool {
+	elm, err := v.cur.Read()
+	if err != nil {
+		if err == io.EOF {
+			return false
+		}
+		panic(fmt.Sprintf("broken stream: %v", err))
+	}
+
+	*et = elm.Timestamp
+	*key = elm.Elm.Interface().(int32)
+	*value = elm.Elm2.Interface().(int64)
+	return true
+}
+
+func iterMakerETInt32Int64(s ReStream) ReusableInput {
+	ret := &iterNative{s: s}
+	ret.fn = reflect.ValueOf(ret.readETInt32Int64)
+	return ret
+}
+
+func (v *iterNative) readInt32Uint(key *int32, value *uint) bool {
+	elm, err := v.cur.Read()
+	if err != nil {
+		if err == io.EOF {
+			return false
+		}
+		panic(fmt.Sprintf("broken stream: %v", err))
+	}
+
+	*key = elm.Elm.Interface().(int32)
+	*value = elm.Elm2.Interface().(uint)
+	return true
+}
+
+func iterMakerInt32Uint(s ReStream) ReusableInput {
+	ret := &iterNative{s: s}
+	ret.fn = reflect.ValueOf(ret.readInt32Uint)
+	return ret
+}
+
+func (v *iterNative) readETInt32Uint(et *typex.EventTime, key *int32, value *uint) bool {
+	elm, err := v.cur.Read()
+	if err != nil {
+		if err == io.EOF {
+			return false
+		}
+		panic(fmt.Sprintf("broken stream: %v", err))
+	}
+
+	*et = elm.Timestamp
+	*key = elm.Elm.Interface().(int32)
+	*value = elm.Elm2.Interface().(uint)
+	return true
+}
+
+func iterMakerETInt32Uint(s ReStream) ReusableInput {
+	ret := &iterNative{s: s}
+	ret.fn = reflect.ValueOf(ret.readETInt32Uint)
+	return ret
+}
+
+func (v *iterNative) readInt32Uint8(key *int32, value *uint8) bool {
+	elm, err := v.cur.Read()
+	if err != nil {
+		if err == io.EOF {
+			return false
+		}
+		panic(fmt.Sprintf("broken stream: %v", err))
+	}
+
+	*key = elm.Elm.Interface().(int32)
+	*value = elm.Elm2.Interface().(uint8)
+	return true
+}
+
+func iterMakerInt32Uint8(s ReStream) ReusableInput {
+	ret := &iterNative{s: s}
+	ret.fn = reflect.ValueOf(ret.readInt32Uint8)
+	return ret
+}
+
+func (v *iterNative) readETInt32Uint8(et *typex.EventTime, key *int32, value *uint8) bool {
+	elm, err := v.cur.Read()
+	if err != nil {
+		if err == io.EOF {
+			return false
+		}
+		panic(fmt.Sprintf("broken stream: %v", err))
+	}
+
+	*et = elm.Timestamp
+	*key = elm.Elm.Interface().(int32)
+	*value = elm.Elm2.Interface().(uint8)
+	return true
+}
+
+func iterMakerETInt32Uint8(s ReStream) ReusableInput {
+	ret := &iterNative{s: s}
+	ret.fn = reflect.ValueOf(ret.readETInt32Uint8)
+	return ret
+}
+
+func (v *iterNative) readInt32Uint16(key *int32, value *uint16) bool {
+	elm, err := v.cur.Read()
+	if err != nil {
+		if err == io.EOF {
+			return false
+		}
+		panic(fmt.Sprintf("broken stream: %v", err))
+	}
+
+	*key = elm.Elm.Interface().(int32)
+	*value = elm.Elm2.Interface().(uint16)
+	return true
+}
+
+func iterMakerInt32Uint16(s ReStream) ReusableInput {
+	ret := &iterNative{s: s}
+	ret.fn = reflect.ValueOf(ret.readInt32Uint16)
+	return ret
+}
+
+func (v *iterNative) readETInt32Uint16(et *typex.EventTime, key *int32, value *uint16) bool {
+	elm, err := v.cur.Read()
+	if err != nil {
+		if err == io.EOF {
+			return false
+		}
+		panic(fmt.Sprintf("broken stream: %v", err))
+	}
+
+	*et = elm.Timestamp
+	*key = elm.Elm.Interface().(int32)
+	*value = elm.Elm2.Interface().(uint16)
+	return true
+}
+
+func iterMakerETInt32Uint16(s ReStream) ReusableInput {
+	ret := &iterNative{s: s}
+	ret.fn = reflect.ValueOf(ret.readETInt32Uint16)
+	return ret
+}
+
+func (v *iterNative) readInt32Uint32(key *int32, value *uint32) bool {
+	elm, err := v.cur.Read()
+	if err != nil {
+		if err == io.EOF {
+			return false
+		}
+		panic(fmt.Sprintf("broken stream: %v", err))
+	}
+
+	*key = elm.Elm.Interface().(int32)
+	*value = elm.Elm2.Interface().(uint32)
+	return true
+}
+
+func iterMakerInt32Uint32(s ReStream) ReusableInput {
+	ret := &iterNative{s: s}
+	ret.fn = reflect.ValueOf(ret.readInt32Uint32)
+	return ret
+}
+
+func (v *iterNative) readETInt32Uint32(et *typex.EventTime, key *int32, value *uint32) bool {
+	elm, err := v.cur.Read()
+	if err != nil {
+		if err == io.EOF {
+			return false
+		}
+		panic(fmt.Sprintf("broken stream: %v", err))
+	}
+
+	*et = elm.Timestamp
+	*key = elm.Elm.Interface().(int32)
+	*value = elm.Elm2.Interface().(uint32)
+	return true
+}
+
+func iterMakerETInt32Uint32(s ReStream) ReusableInput {
+	ret := &iterNative{s: s}
+	ret.fn = reflect.ValueOf(ret.readETInt32Uint32)
+	return ret
+}
+
+func (v *iterNative) readInt32Uint64(key *int32, value *uint64) bool {
+	elm, err := v.cur.Read()
+	if err != nil {
+		if err == io.EOF {
+			return false
+		}
+		panic(fmt.Sprintf("broken stream: %v", err))
+	}
+
+	*key = elm.Elm.Interface().(int32)
+	*value = elm.Elm2.Interface().(uint64)
+	return true
+}
+
+func iterMakerInt32Uint64(s ReStream) ReusableInput {
+	ret := &iterNative{s: s}
+	ret.fn = reflect.ValueOf(ret.readInt32Uint64)
+	return ret
+}
+
+func (v *iterNative) readETInt32Uint64(et *typex.EventTime, key *int32, value *uint64) bool {
+	elm, err := v.cur.Read()
+	if err != nil {
+		if err == io.EOF {
+			return false
+		}
+		panic(fmt.Sprintf("broken stream: %v", err))
+	}
+
+	*et = elm.Timestamp
+	*key = elm.Elm.Interface().(int32)
+	*value = elm.Elm2.Interface().(uint64)
+	return true
+}
+
+func iterMakerETInt32Uint64(s ReStream) ReusableInput {
+	ret := &iterNative{s: s}
+	ret.fn = reflect.ValueOf(ret.readETInt32Uint64)
+	return ret
+}
+
+func (v *iterNative) readInt32Float32(key *int32, value *float32) bool {
+	elm, err := v.cur.Read()
+	if err != nil {
+		if err == io.EOF {
+			return false
+		}
+		panic(fmt.Sprintf("broken stream: %v", err))
+	}
+
+	*key = elm.Elm.Interface().(int32)
+	*value = elm.Elm2.Interface().(float32)
+	return true
+}
+
+func iterMakerInt32Float32(s ReStream) ReusableInput {
+	ret := &iterNative{s: s}
+	ret.fn = reflect.ValueOf(ret.readInt32Float32)
+	return ret
+}
+
+func (v *iterNative) readETInt32Float32(et *typex.EventTime, key *int32, value *float32) bool {
+	elm, err := v.cur.Read()
+	if err != nil {
+		if err == io.EOF {
+			return false
+		}
+		panic(fmt.Sprintf("broken stream: %v", err))
+	}
+
+	*et = elm.Timestamp
+	*key = elm.Elm.Interface().(int32)
+	*value = elm.Elm2.Interface().(float32)
+	return true
+}
+
+func iterMakerETInt32Float32(s ReStream) ReusableInput {
+	ret := &iterNative{s: s}
+	ret.fn = reflect.ValueOf(ret.readETInt32Float32)
+	return ret
+}
+
+func (v *iterNative) readInt32Float64(key *int32, value *float64) bool {
+	elm, err := v.cur.Read()
+	if err != nil {
+		if err == io.EOF {
+			return false
+		}
+		panic(fmt.Sprintf("broken stream: %v", err))
+	}
+
+	*key = elm.Elm.Interface().(int32)
+	*value = elm.Elm2.Interface().(float64)
+	return true
+}
+
+func iterMakerInt32Float64(s ReStream) ReusableInput {
+	ret := &iterNative{s: s}
+	ret.fn = reflect.ValueOf(ret.readInt32Float64)
+	return ret
+}
+
+func (v *iterNative) readETInt32Float64(et *typex.EventTime, key *int32, value *float64) bool {
+	elm, err := v.cur.Read()
+	if err != nil {
+		if err == io.EOF {
+			return false
+		}
+		panic(fmt.Sprintf("broken stream: %v", err))
+	}
+
+	*et = elm.Timestamp
+	*key = elm.Elm.Interface().(int32)
+	*value = elm.Elm2.Interface().(float64)
+	return true
+}
+
+func iterMakerETInt32Float64(s ReStream) ReusableInput {
+	ret := &iterNative{s: s}
+	ret.fn = reflect.ValueOf(ret.readETInt32Float64)
+	return ret
+}
+
+func (v *iterNative) readInt32Typex_T(key *int32, value *typex.T) bool {
+	elm, err := v.cur.Read()
+	if err != nil {
+		if err == io.EOF {
+			return false
+		}
+		panic(fmt.Sprintf("broken stream: %v", err))
+	}
+
+	*key = elm.Elm.Interface().(int32)
+	*value = elm.Elm2.Interface().(typex.T)
+	return true
+}
+
+func iterMakerInt32Typex_T(s ReStream) ReusableInput {
+	ret := &iterNative{s: s}
+	ret.fn = reflect.ValueOf(ret.readInt32Typex_T)
+	return ret
+}
+
+func (v *iterNative) readETInt32Typex_T(et *typex.EventTime, key *int32, value *typex.T) bool {
+	elm, err := v.cur.Read()
+	if err != nil {
+		if err == io.EOF {
+			return false
+		}
+		panic(fmt.Sprintf("broken stream: %v", err))
+	}
+
+	*et = elm.Timestamp
+	*key = elm.Elm.Interface().(int32)
+	*value = elm.Elm2.Interface().(typex.T)
+	return true
+}
+
+func iterMakerETInt32Typex_T(s ReStream) ReusableInput {
+	ret := &iterNative{s: s}
+	ret.fn = reflect.ValueOf(ret.readETInt32Typex_T)
+	return ret
+}
+
+func (v *iterNative) readInt32Typex_U(key *int32, value *typex.U) bool {
+	elm, err := v.cur.Read()
+	if err != nil {
+		if err == io.EOF {
+			return false
+		}
+		panic(fmt.Sprintf("broken stream: %v", err))
+	}
+
+	*key = elm.Elm.Interface().(int32)
+	*value = elm.Elm2.Interface().(typex.U)
+	return true
+}
+
+func iterMakerInt32Typex_U(s ReStream) ReusableInput {
+	ret := &iterNative{s: s}
+	ret.fn = reflect.ValueOf(ret.readInt32Typex_U)
+	return ret
+}
+
+func (v *iterNative) readETInt32Typex_U(et *typex.EventTime, key *int32, value *typex.U) bool {
+	elm, err := v.cur.Read()
+	if err != nil {
+		if err == io.EOF {
+			return false
+		}
+		panic(fmt.Sprintf("broken stream: %v", err))
+	}
+
+	*et = elm.Timestamp
+	*key = elm.Elm.Interface().(int32)
+	*value = elm.Elm2.Interface().(typex.U)
+	return true
+}
+
+func iterMakerETInt32Typex_U(s ReStream) ReusableInput {
+	ret := &iterNative{s: s}
+	ret.fn = reflect.ValueOf(ret.readETInt32Typex_U)
+	return ret
+}
+
+func (v *iterNative) readInt32Typex_V(key *int32, value *typex.V) bool {
+	elm, err := v.cur.Read()
+	if err != nil {
+		if err == io.EOF {
+			return false
+		}
+		panic(fmt.Sprintf("broken stream: %v", err))
+	}
+
+	*key = elm.Elm.Interface().(int32)
+	*value = elm.Elm2.Interface().(typex.V)
+	return true
+}
+
+func iterMakerInt32Typex_V(s ReStream) ReusableInput {
+	ret := &iterNative{s: s}
+	ret.fn = reflect.ValueOf(ret.readInt32Typex_V)
+	return ret
+}
+
+func (v *iterNative) readETInt32Typex_V(et *typex.EventTime, key *int32, value *typex.V) bool {
+	elm, err := v.cur.Read()
+	if err != nil {
+		if err == io.EOF {
+			return false
+		}
+		panic(fmt.Sprintf("broken stream: %v", err))
+	}
+
+	*et = elm.Timestamp
+	*key = elm.Elm.Interface().(int32)
+	*value = elm.Elm2.Interface().(typex.V)
+	return true
+}
+
+func iterMakerETInt32Typex_V(s ReStream) ReusableInput {
+	ret := &iterNative{s: s}
+	ret.fn = reflect.ValueOf(ret.readETInt32Typex_V)
+	return ret
+}
+
+func (v *iterNative) readInt32Typex_W(key *int32, value *typex.W) bool {
+	elm, err := v.cur.Read()
+	if err != nil {
+		if err == io.EOF {
+			return false
+		}
+		panic(fmt.Sprintf("broken stream: %v", err))
+	}
+
+	*key = elm.Elm.Interface().(int32)
+	*value = elm.Elm2.Interface().(typex.W)
+	return true
+}
+
+func iterMakerInt32Typex_W(s ReStream) ReusableInput {
+	ret := &iterNative{s: s}
+	ret.fn = reflect.ValueOf(ret.readInt32Typex_W)
+	return ret
+}
+
+func (v *iterNative) readETInt32Typex_W(et *typex.EventTime, key *int32, value *typex.W) bool {
+	elm, err := v.cur.Read()
+	if err != nil {
+		if err == io.EOF {
+			return false
+		}
+		panic(fmt.Sprintf("broken stream: %v", err))
+	}
+
+	*et = elm.Timestamp
+	*key = elm.Elm.Interface().(int32)
+	*value = elm.Elm2.Interface().(typex.W)
+	return true
+}
+
+func iterMakerETInt32Typex_W(s ReStream) ReusableInput {
+	ret := &iterNative{s: s}
+	ret.fn = reflect.ValueOf(ret.readETInt32Typex_W)
+	return ret
+}
+
+func (v *iterNative) readInt32Typex_X(key *int32, value *typex.X) bool {
+	elm, err := v.cur.Read()
+	if err != nil {
+		if err == io.EOF {
+			return false
+		}
+		panic(fmt.Sprintf("broken stream: %v", err))
+	}
+
+	*key = elm.Elm.Interface().(int32)
+	*value = elm.Elm2.Interface().(typex.X)
+	return true
+}
+
+func iterMakerInt32Typex_X(s ReStream) ReusableInput {
+	ret := &iterNative{s: s}
+	ret.fn = reflect.ValueOf(ret.readInt32Typex_X)
+	return ret
+}
+
+func (v *iterNative) readETInt32Typex_X(et *typex.EventTime, key *int32, value *typex.X) bool {
+	elm, err := v.cur.Read()
+	if err != nil {
+		if err == io.EOF {
+			return false
+		}
+		panic(fmt.Sprintf("broken stream: %v", err))
+	}
+
+	*et = elm.Timestamp
+	*key = elm.Elm.Interface().(int32)
+	*value = elm.Elm2.Interface().(typex.X)
+	return true
+}
+
+func iterMakerETInt32Typex_X(s ReStream) ReusableInput {
+	ret := &iterNative{s: s}
+	ret.fn = reflect.ValueOf(ret.readETInt32Typex_X)
+	return ret
+}
+
+func (v *iterNative) readInt32Typex_Y(key *int32, value *typex.Y) bool {
+	elm, err := v.cur.Read()
+	if err != nil {
+		if err == io.EOF {
+			return false
+		}
+		panic(fmt.Sprintf("broken stream: %v", err))
+	}
+
+	*key = elm.Elm.Interface().(int32)
+	*value = elm.Elm2.Interface().(typex.Y)
+	return true
+}
+
+func iterMakerInt32Typex_Y(s ReStream) ReusableInput {
+	ret := &iterNative{s: s}
+	ret.fn = reflect.ValueOf(ret.readInt32Typex_Y)
+	return ret
+}
+
+func (v *iterNative) readETInt32Typex_Y(et *typex.EventTime, key *int32, value *typex.Y) bool {
+	elm, err := v.cur.Read()
+	if err != nil {
+		if err == io.EOF {
+			return false
+		}
+		panic(fmt.Sprintf("broken stream: %v", err))
+	}
+
+	*et = elm.Timestamp
+	*key = elm.Elm.Interface().(int32)
+	*value = elm.Elm2.Interface().(typex.Y)
+	return true
+}
+
+func iterMakerETInt32Typex_Y(s ReStream) ReusableInput {
+	ret := &iterNative{s: s}
+	ret.fn = reflect.ValueOf(ret.readETInt32Typex_Y)
+	return ret
+}
+
+func (v *iterNative) readInt32Typex_Z(key *int32, value *typex.Z) bool {
+	elm, err := v.cur.Read()
+	if err != nil {
+		if err == io.EOF {
+			return false
+		}
+		panic(fmt.Sprintf("broken stream: %v", err))
+	}
+
+	*key = elm.Elm.Interface().(int32)
+	*value = elm.Elm2.Interface().(typex.Z)
+	return true
+}
+
+func iterMakerInt32Typex_Z(s ReStream) ReusableInput {
+	ret := &iterNative{s: s}
+	ret.fn = reflect.ValueOf(ret.readInt32Typex_Z)
+	return ret
+}
+
+func (v *iterNative) readETInt32Typex_Z(et *typex.EventTime, key *int32, value *typex.Z) bool {
+	elm, err := v.cur.Read()
+	if err != nil {
+		if err == io.EOF {
+			return false
+		}
+		panic(fmt.Sprintf("broken stream: %v", err))
+	}
+
+	*et = elm.Timestamp
+	*key = elm.Elm.Interface().(int32)
+	*value = elm.Elm2.Interface().(typex.Z)
+	return true
+}
+
+func iterMakerETInt32Typex_Z(s ReStream) ReusableInput {
+	ret := &iterNative{s: s}
+	ret.fn = reflect.ValueOf(ret.readETInt32Typex_Z)
+	return ret
+}
+
+func (v *iterNative) readInt64(val *int64) bool {
+	elm, err := v.cur.Read()
+	if err != nil {
+		if err == io.EOF {
+			return false
+		}
+		panic(fmt.Sprintf("broken stream: %v", err))
+	}
+
+	*val = elm.Elm.Interface().(int64)
+	return true
+}
+
+func iterMakerInt64(s ReStream) ReusableInput {
+	ret := &iterNative{s: s}
+	ret.fn = reflect.ValueOf(ret.readInt64)
+	return ret
+}
+
+func (v *iterNative) readETInt64(et *typex.EventTime, val *int64) bool {
+	elm, err := v.cur.Read()
+	if err != nil {
+		if err == io.EOF {
+			return false
+		}
+		panic(fmt.Sprintf("broken stream: %v", err))
+	}
+
+	*et = elm.Timestamp
+	*val = elm.Elm.Interface().(int64)
+	return true
+}
+
+func iterMakerETInt64(s ReStream) ReusableInput {
+	ret := &iterNative{s: s}
+	ret.fn = reflect.ValueOf(ret.readETInt64)
+	return ret
+}
+
+func (v *iterNative) readInt64ByteSlice(key *int64, value *[]byte) bool {
+	elm, err := v.cur.Read()
+	if err != nil {
+		if err == io.EOF {
+			return false
+		}
+		panic(fmt.Sprintf("broken stream: %v", err))
+	}
+
+	*key = elm.Elm.Interface().(int64)
+	*value = elm.Elm2.Interface().([]byte)
+	return true
+}
+
+func iterMakerInt64ByteSlice(s ReStream) ReusableInput {
+	ret := &iterNative{s: s}
+	ret.fn = reflect.ValueOf(ret.readInt64ByteSlice)
+	return ret
+}
+
+func (v *iterNative) readETInt64ByteSlice(et *typex.EventTime, key *int64, value *[]byte) bool {
+	elm, err := v.cur.Read()
+	if err != nil {
+		if err == io.EOF {
+			return false
+		}
+		panic(fmt.Sprintf("broken stream: %v", err))
+	}
+
+	*et = elm.Timestamp
+	*key = elm.Elm.Interface().(int64)
+	*value = elm.Elm2.Interface().([]byte)
+	return true
+}
+
+func iterMakerETInt64ByteSlice(s ReStream) ReusableInput {
+	ret := &iterNative{s: s}
+	ret.fn = reflect.ValueOf(ret.readETInt64ByteSlice)
+	return ret
+}
+
+func (v *iterNative) readInt64Bool(key *int64, value *bool) bool {
+	elm, err := v.cur.Read()
+	if err != nil {
+		if err == io.EOF {
+			return false
+		}
+		panic(fmt.Sprintf("broken stream: %v", err))
+	}
+
+	*key = elm.Elm.Interface().(int64)
+	*value = elm.Elm2.Interface().(bool)
+	return true
+}
+
+func iterMakerInt64Bool(s ReStream) ReusableInput {
+	ret := &iterNative{s: s}
+	ret.fn = reflect.ValueOf(ret.readInt64Bool)
+	return ret
+}
+
+func (v *iterNative) readETInt64Bool(et *typex.EventTime, key *int64, value *bool) bool {
+	elm, err := v.cur.Read()
+	if err != nil {
+		if err == io.EOF {
+			return false
+		}
+		panic(fmt.Sprintf("broken stream: %v", err))
+	}
+
+	*et = elm.Timestamp
+	*key = elm.Elm.Interface().(int64)
+	*value = elm.Elm2.Interface().(bool)
+	return true
+}
+
+func iterMakerETInt64Bool(s ReStream) ReusableInput {
+	ret := &iterNative{s: s}
+	ret.fn = reflect.ValueOf(ret.readETInt64Bool)
+	return ret
+}
+
+func (v *iterNative) readInt64String(key *int64, value *string) bool {
+	elm, err := v.cur.Read()
+	if err != nil {
+		if err == io.EOF {
+			return false
+		}
+		panic(fmt.Sprintf("broken stream: %v", err))
+	}
+
+	*key = elm.Elm.Interface().(int64)
+	*value = elm.Elm2.Interface().(string)
+	return true
+}
+
+func iterMakerInt64String(s ReStream) ReusableInput {
+	ret := &iterNative{s: s}
+	ret.fn = reflect.ValueOf(ret.readInt64String)
+	return ret
+}
+
+func (v *iterNative) readETInt64String(et *typex.EventTime, key *int64, value *string) bool {
+	elm, err := v.cur.Read()
+	if err != nil {
+		if err == io.EOF {
+			return false
+		}
+		panic(fmt.Sprintf("broken stream: %v", err))
+	}
+
+	*et = elm.Timestamp
+	*key = elm.Elm.Interface().(int64)
+	*value = elm.Elm2.Interface().(string)
+	return true
+}
+
+func iterMakerETInt64String(s ReStream) ReusableInput {
+	ret := &iterNative{s: s}
+	ret.fn = reflect.ValueOf(ret.readETInt64String)
+	return ret
+}
+
+func (v *iterNative) readInt64Int(key *int64, value *int) bool {
+	elm, err := v.cur.Read()
+	if err != nil {
+		if err == io.EOF {
+			return false
+		}
+		panic(fmt.Sprintf("broken stream: %v", err))
+	}
+
+	*key = elm.Elm.Interface().(int64)
+	*value = elm.Elm2.Interface().(int)
+	return true
+}
+
+func iterMakerInt64Int(s ReStream) ReusableInput {
+	ret := &iterNative{s: s}
+	ret.fn = reflect.ValueOf(ret.readInt64Int)
+	return ret
+}
+
+func (v *iterNative) readETInt64Int(et *typex.EventTime, key *int64, value *int) bool {
+	elm, err := v.cur.Read()
+	if err != nil {
+		if err == io.EOF {
+			return false
+		}
+		panic(fmt.Sprintf("broken stream: %v", err))
+	}
+
+	*et = elm.Timestamp
+	*key = elm.Elm.Interface().(int64)
+	*value = elm.Elm2.Interface().(int)
+	return true
+}
+
+func iterMakerETInt64Int(s ReStream) ReusableInput {
+	ret := &iterNative{s: s}
+	ret.fn = reflect.ValueOf(ret.readETInt64Int)
+	return ret
+}
+
+func (v *iterNative) readInt64Int8(key *int64, value *int8) bool {
+	elm, err := v.cur.Read()
+	if err != nil {
+		if err == io.EOF {
+			return false
+		}
+		panic(fmt.Sprintf("broken stream: %v", err))
+	}
+
+	*key = elm.Elm.Interface().(int64)
+	*value = elm.Elm2.Interface().(int8)
+	return true
+}
+
+func iterMakerInt64Int8(s ReStream) ReusableInput {
+	ret := &iterNative{s: s}
+	ret.fn = reflect.ValueOf(ret.readInt64Int8)
+	return ret
+}
+
+func (v *iterNative) readETInt64Int8(et *typex.EventTime, key *int64, value *int8) bool {
+	elm, err := v.cur.Read()
+	if err != nil {
+		if err == io.EOF {
+			return false
+		}
+		panic(fmt.Sprintf("broken stream: %v", err))
+	}
+
+	*et = elm.Timestamp
+	*key = elm.Elm.Interface().(int64)
+	*value = elm.Elm2.Interface().(int8)
+	return true
+}
+
+func iterMakerETInt64Int8(s ReStream) ReusableInput {
+	ret := &iterNative{s: s}
+	ret.fn = reflect.ValueOf(ret.readETInt64Int8)
+	return ret
+}
+
+func (v *iterNative) readInt64Int16(key *int64, value *int16) bool {
+	elm, err := v.cur.Read()
+	if err != nil {
+		if err == io.EOF {
+			return false
+		}
+		panic(fmt.Sprintf("broken stream: %v", err))
+	}
+
+	*key = elm.Elm.Interface().(int64)
+	*value = elm.Elm2.Interface().(int16)
+	return true
+}
+
+func iterMakerInt64Int16(s ReStream) ReusableInput {
+	ret := &iterNative{s: s}
+	ret.fn = reflect.ValueOf(ret.readInt64Int16)
+	return ret
+}
+
+func (v *iterNative) readETInt64Int16(et *typex.EventTime, key *int64, value *int16) bool {
+	elm, err := v.cur.Read()
+	if err != nil {
+		if err == io.EOF {
+			return false
+		}
+		panic(fmt.Sprintf("broken stream: %v", err))
+	}
+
+	*et = elm.Timestamp
+	*key = elm.Elm.Interface().(int64)
+	*value = elm.Elm2.Interface().(int16)
+	return true
+}
+
+func iterMakerETInt64Int16(s ReStream) ReusableInput {
+	ret := &iterNative{s: s}
+	ret.fn = reflect.ValueOf(ret.readETInt64Int16)
+	return ret
+}
+
+func (v *iterNative) readInt64Int32(key *int64, value *int32) bool {
+	elm, err := v.cur.Read()
+	if err != nil {
+		if err == io.EOF {
+			return false
+		}
+		panic(fmt.Sprintf("broken stream: %v", err))
+	}
+
+	*key = elm.Elm.Interface().(int64)
+	*value = elm.Elm2.Interface().(int32)
+	return true
+}
+
+func iterMakerInt64Int32(s ReStream) ReusableInput {
+	ret := &iterNative{s: s}
+	ret.fn = reflect.ValueOf(ret.readInt64Int32)
+	return ret
+}
+
+func (v *iterNative) readETInt64Int32(et *typex.EventTime, key *int64, value *int32) bool {
+	elm, err := v.cur.Read()
+	if err != nil {
+		if err == io.EOF {
+			return false
+		}
+		panic(fmt.Sprintf("broken stream: %v", err))
+	}
+
+	*et = elm.Timestamp
+	*key = elm.Elm.Interface().(int64)
+	*value = elm.Elm2.Interface().(int32)
+	return true
+}
+
+func iterMakerETInt64Int32(s ReStream) ReusableInput {
+	ret := &iterNative{s: s}
+	ret.fn = reflect.ValueOf(ret.readETInt64Int32)
+	return ret
+}
+
+func (v *iterNative) readInt64Int64(key *int64, value *int64) bool {
+	elm, err := v.cur.Read()
+	if err != nil {
+		if err == io.EOF {
+			return false
+		}
+		panic(fmt.Sprintf("broken stream: %v", err))
+	}
+
+	*key = elm.Elm.Interface().(int64)
+	*value = elm.Elm2.Interface().(int64)
+	return true
+}
+
+func iterMakerInt64Int64(s ReStream) ReusableInput {
+	ret := &iterNative{s: s}
+	ret.fn = reflect.ValueOf(ret.readInt64Int64)
+	return ret
+}
+
+func (v *iterNative) readETInt64Int64(et *typex.EventTime, key *int64, value *int64) bool {
+	elm, err := v.cur.Read()
+	if err != nil {
+		if err == io.EOF {
+			return false
+		}
+		panic(fmt.Sprintf("broken stream: %v", err))
+	}
+
+	*et = elm.Timestamp
+	*key = elm.Elm.Interface().(int64)
+	*value = elm.Elm2.Interface().(int64)
+	return true
+}
+
+func iterMakerETInt64Int64(s ReStream) ReusableInput {
+	ret := &iterNative{s: s}
+	ret.fn = reflect.ValueOf(ret.readETInt64Int64)
+	return ret
+}
+
+func (v *iterNative) readInt64Uint(key *int64, value *uint) bool {
+	elm, err := v.cur.Read()
+	if err != nil {
+		if err == io.EOF {
+			return false
+		}
+		panic(fmt.Sprintf("broken stream: %v", err))
+	}
+
+	*key = elm.Elm.Interface().(int64)
+	*value = elm.Elm2.Interface().(uint)
+	return true
+}
+
+func iterMakerInt64Uint(s ReStream) ReusableInput {
+	ret := &iterNative{s: s}
+	ret.fn = reflect.ValueOf(ret.readInt64Uint)
+	return ret
+}
+
+func (v *iterNative) readETInt64Uint(et *typex.EventTime, key *int64, value *uint) bool {
+	elm, err := v.cur.Read()
+	if err != nil {
+		if err == io.EOF {
+			return false
+		}
+		panic(fmt.Sprintf("broken stream: %v", err))
+	}
+
+	*et = elm.Timestamp
+	*key = elm.Elm.Interface().(int64)
+	*value = elm.Elm2.Interface().(uint)
+	return true
+}
+
+func iterMakerETInt64Uint(s ReStream) ReusableInput {
+	ret := &iterNative{s: s}
+	ret.fn = reflect.ValueOf(ret.readETInt64Uint)
+	return ret
+}
+
+func (v *iterNative) readInt64Uint8(key *int64, value *uint8) bool {
+	elm, err := v.cur.Read()
+	if err != nil {
+		if err == io.EOF {
+			return false
+		}
+		panic(fmt.Sprintf("broken stream: %v", err))
+	}
+
+	*key = elm.Elm.Interface().(int64)
+	*value = elm.Elm2.Interface().(uint8)
+	return true
+}
+
+func iterMakerInt64Uint8(s ReStream) ReusableInput {
+	ret := &iterNative{s: s}
+	ret.fn = reflect.ValueOf(ret.readInt64Uint8)
+	return ret
+}
+
+func (v *iterNative) readETInt64Uint8(et *typex.EventTime, key *int64, value *uint8) bool {
+	elm, err := v.cur.Read()
+	if err != nil {
+		if err == io.EOF {
+			return false
+		}
+		panic(fmt.Sprintf("broken stream: %v", err))
+	}
+
+	*et = elm.Timestamp
+	*key = elm.Elm.Interface().(int64)
+	*value = elm.Elm2.Interface().(uint8)
+	return true
+}
+
+func iterMakerETInt64Uint8(s ReStream) ReusableInput {
+	ret := &iterNative{s: s}
+	ret.fn = reflect.ValueOf(ret.readETInt64Uint8)
+	return ret
+}
+
+func (v *iterNative) readInt64Uint16(key *int64, value *uint16) bool {
+	elm, err := v.cur.Read()
+	if err != nil {
+		if err == io.EOF {
+			return false
+		}
+		panic(fmt.Sprintf("broken stream: %v", err))
+	}
+
+	*key = elm.Elm.Interface().(int64)
+	*value = elm.Elm2.Interface().(uint16)
+	return true
+}
+
+func iterMakerInt64Uint16(s ReStream) ReusableInput {
+	ret := &iterNative{s: s}
+	ret.fn = reflect.ValueOf(ret.readInt64Uint16)
+	return ret
+}
+
+func (v *iterNative) readETInt64Uint16(et *typex.EventTime, key *int64, value *uint16) bool {
+	elm, err := v.cur.Read()
+	if err != nil {
+		if err == io.EOF {
+			return false
+		}
+		panic(fmt.Sprintf("broken stream: %v", err))
+	}
+
+	*et = elm.Timestamp
+	*key = elm.Elm.Interface().(int64)
+	*value = elm.Elm2.Interface().(uint16)
+	return true
+}
+
+func iterMakerETInt64Uint16(s ReStream) ReusableInput {
+	ret := &iterNative{s: s}
+	ret.fn = reflect.ValueOf(ret.readETInt64Uint16)
+	return ret
+}
+
+func (v *iterNative) readInt64Uint32(key *int64, value *uint32) bool {
+	elm, err := v.cur.Read()
+	if err != nil {
+		if err == io.EOF {
+			return false
+		}
+		panic(fmt.Sprintf("broken stream: %v", err))
+	}
+
+	*key = elm.Elm.Interface().(int64)
+	*value = elm.Elm2.Interface().(uint32)
+	return true
+}
+
+func iterMakerInt64Uint32(s ReStream) ReusableInput {
+	ret := &iterNative{s: s}
+	ret.fn = reflect.ValueOf(ret.readInt64Uint32)
+	return ret
+}
+
+func (v *iterNative) readETInt64Uint32(et *typex.EventTime, key *int64, value *uint32) bool {
+	elm, err := v.cur.Read()
+	if err != nil {
+		if err == io.EOF {
+			return false
+		}
+		panic(fmt.Sprintf("broken stream: %v", err))
+	}
+
+	*et = elm.Timestamp
+	*key = elm.Elm.Interface().(int64)
+	*value = elm.Elm2.Interface().(uint32)
+	return true
+}
+
+func iterMakerETInt64Uint32(s ReStream) ReusableInput {
+	ret := &iterNative{s: s}
+	ret.fn = reflect.ValueOf(ret.readETInt64Uint32)
+	return ret
+}
+
+func (v *iterNative) readInt64Uint64(key *int64, value *uint64) bool {
+	elm, err := v.cur.Read()
+	if err != nil {
+		if err == io.EOF {
+			return false
+		}
+		panic(fmt.Sprintf("broken stream: %v", err))
+	}
+
+	*key = elm.Elm.Interface().(int64)
+	*value = elm.Elm2.Interface().(uint64)
+	return true
+}
+
+func iterMakerInt64Uint64(s ReStream) ReusableInput {
+	ret := &iterNative{s: s}
+	ret.fn = reflect.ValueOf(ret.readInt64Uint64)
+	return ret
+}
+
+func (v *iterNative) readETInt64Uint64(et *typex.EventTime, key *int64, value *uint64) bool {
+	elm, err := v.cur.Read()
+	if err != nil {
+		if err == io.EOF {
+			return false
+		}
+		panic(fmt.Sprintf("broken stream: %v", err))
+	}
+
+	*et = elm.Timestamp
+	*key = elm.Elm.Interface().(int64)
+	*value = elm.Elm2.Interface().(uint64)
+	return true
+}
+
+func iterMakerETInt64Uint64(s ReStream) ReusableInput {
+	ret := &iterNative{s: s}
+	ret.fn = reflect.ValueOf(ret.readETInt64Uint64)
+	return ret
+}
+
+func (v *iterNative) readInt64Float32(key *int64, value *float32) bool {
+	elm, err := v.cur.Read()
+	if err != nil {
+		if err == io.EOF {
+			return false
+		}
+		panic(fmt.Sprintf("broken stream: %v", err))
+	}
+
+	*key = elm.Elm.Interface().(int64)
+	*value = elm.Elm2.Interface().(float32)
+	return true
+}
+
+func iterMakerInt64Float32(s ReStream) ReusableInput {
+	ret := &iterNative{s: s}
+	ret.fn = reflect.ValueOf(ret.readInt64Float32)
+	return ret
+}
+
+func (v *iterNative) readETInt64Float32(et *typex.EventTime, key *int64, value *float32) bool {
+	elm, err := v.cur.Read()
+	if err != nil {
+		if err == io.EOF {
+			return false
+		}
+		panic(fmt.Sprintf("broken stream: %v", err))
+	}
+
+	*et = elm.Timestamp
+	*key = elm.Elm.Interface().(int64)
+	*value = elm.Elm2.Interface().(float32)
+	return true
+}
+
+func iterMakerETInt64Float32(s ReStream) ReusableInput {
+	ret := &iterNative{s: s}
+	ret.fn = reflect.ValueOf(ret.readETInt64Float32)
+	return ret
+}
+
+func (v *iterNative) readInt64Float64(key *int64, value *float64) bool {
+	elm, err := v.cur.Read()
+	if err != nil {
+		if err == io.EOF {
+			return false
+		}
+		panic(fmt.Sprintf("broken stream: %v", err))
+	}
+
+	*key = elm.Elm.Interface().(int64)
+	*value = elm.Elm2.Interface().(float64)
+	return true
+}
+
+func iterMakerInt64Float64(s ReStream) ReusableInput {
+	ret := &iterNative{s: s}
+	ret.fn = reflect.ValueOf(ret.readInt64Float64)
+	return ret
+}
+
+func (v *iterNative) readETInt64Float64(et *typex.EventTime, key *int64, value *float64) bool {
+	elm, err := v.cur.Read()
+	if err != nil {
+		if err == io.EOF {
+			return false
+		}
+		panic(fmt.Sprintf("broken stream: %v", err))
+	}
+
+	*et = elm.Timestamp
+	*key = elm.Elm.Interface().(int64)
+	*value = elm.Elm2.Interface().(float64)
+	return true
+}
+
+func iterMakerETInt64Float64(s ReStream) ReusableInput {
+	ret := &iterNative{s: s}
+	ret.fn = reflect.ValueOf(ret.readETInt64Float64)
+	return ret
+}
+
+func (v *iterNative) readInt64Typex_T(key *int64, value *typex.T) bool {
+	elm, err := v.cur.Read()
+	if err != nil {
+		if err == io.EOF {
+			return false
+		}
+		panic(fmt.Sprintf("broken stream: %v", err))
+	}
+
+	*key = elm.Elm.Interface().(int64)
+	*value = elm.Elm2.Interface().(typex.T)
+	return true
+}
+
+func iterMakerInt64Typex_T(s ReStream) ReusableInput {
+	ret := &iterNative{s: s}
+	ret.fn = reflect.ValueOf(ret.readInt64Typex_T)
+	return ret
+}
+
+func (v *iterNative) readETInt64Typex_T(et *typex.EventTime, key *int64, value *typex.T) bool {
+	elm, err := v.cur.Read()
+	if err != nil {
+		if err == io.EOF {
+			return false
+		}
+		panic(fmt.Sprintf("broken stream: %v", err))
+	}
+
+	*et = elm.Timestamp
+	*key = elm.Elm.Interface().(int64)
+	*value = elm.Elm2.Interface().(typex.T)
+	return true
+}
+
+func iterMakerETInt64Typex_T(s ReStream) ReusableInput {
+	ret := &iterNative{s: s}
+	ret.fn = reflect.ValueOf(ret.readETInt64Typex_T)
+	return ret
+}
+
+func (v *iterNative) readInt64Typex_U(key *int64, value *typex.U) bool {
+	elm, err := v.cur.Read()
+	if err != nil {
+		if err == io.EOF {
+			return false
+		}
+		panic(fmt.Sprintf("broken stream: %v", err))
+	}
+
+	*key = elm.Elm.Interface().(int64)
+	*value = elm.Elm2.Interface().(typex.U)
+	return true
+}
+
+func iterMakerInt64Typex_U(s ReStream) ReusableInput {
+	ret := &iterNative{s: s}
+	ret.fn = reflect.ValueOf(ret.readInt64Typex_U)
+	return ret
+}
+
+func (v *iterNative) readETInt64Typex_U(et *typex.EventTime, key *int64, value *typex.U) bool {
+	elm, err := v.cur.Read()
+	if err != nil {
+		if err == io.EOF {
+			return false
+		}
+		panic(fmt.Sprintf("broken stream: %v", err))
+	}
+
+	*et = elm.Timestamp
+	*key = elm.Elm.Interface().(int64)
+	*value = elm.Elm2.Interface().(typex.U)
+	return true
+}
+
+func iterMakerETInt64Typex_U(s ReStream) ReusableInput {
+	ret := &iterNative{s: s}
+	ret.fn = reflect.ValueOf(ret.readETInt64Typex_U)
+	return ret
+}
+
+func (v *iterNative) readInt64Typex_V(key *int64, value *typex.V) bool {
+	elm, err := v.cur.Read()
+	if err != nil {
+		if err == io.EOF {
+			return false
+		}
+		panic(fmt.Sprintf("broken stream: %v", err))
+	}
+
+	*key = elm.Elm.Interface().(int64)
+	*value = elm.Elm2.Interface().(typex.V)
+	return true
+}
+
+func iterMakerInt64Typex_V(s ReStream) ReusableInput {
+	ret := &iterNative{s: s}
+	ret.fn = reflect.ValueOf(ret.readInt64Typex_V)
+	return ret
+}
+
+func (v *iterNative) readETInt64Typex_V(et *typex.EventTime, key *int64, value *typex.V) bool {
+	elm, err := v.cur.Read()
+	if err != nil {
+		if err == io.EOF {
+			return false
+		}
+		panic(fmt.Sprintf("broken stream: %v", err))
+	}
+
+	*et = elm.Timestamp
+	*key = elm.Elm.Interface().(int64)
+	*value = elm.Elm2.Interface().(typex.V)
+	return true
+}
+
+func iterMakerETInt64Typex_V(s ReStream) ReusableInput {
+	ret := &iterNative{s: s}
+	ret.fn = reflect.ValueOf(ret.readETInt64Typex_V)
+	return ret
+}
+
+func (v *iterNative) readInt64Typex_W(key *int64, value *typex.W) bool {
+	elm, err := v.cur.Read()
+	if err != nil {
+		if err == io.EOF {
+			return false
+		}
+		panic(fmt.Sprintf("broken stream: %v", err))
+	}
+
+	*key = elm.Elm.Interface().(int64)
+	*value = elm.Elm2.Interface().(typex.W)
+	return true
+}
+
+func iterMakerInt64Typex_W(s ReStream) ReusableInput {
+	ret := &iterNative{s: s}
+	ret.fn = reflect.ValueOf(ret.readInt64Typex_W)
+	return ret
+}
+
+func (v *iterNative) readETInt64Typex_W(et *typex.EventTime, key *int64, value *typex.W) bool {
+	elm, err := v.cur.Read()
+	if err != nil {
+		if err == io.EOF {
+			return false
+		}
+		panic(fmt.Sprintf("broken stream: %v", err))
+	}
+
+	*et = elm.Timestamp
+	*key = elm.Elm.Interface().(int64)
+	*value = elm.Elm2.Interface().(typex.W)
+	return true
+}
+
+func iterMakerETInt64Typex_W(s ReStream) ReusableInput {
+	ret := &iterNative{s: s}
+	ret.fn = reflect.ValueOf(ret.readETInt64Typex_W)
+	return ret
+}
+
+func (v *iterNative) readInt64Typex_X(key *int64, value *typex.X) bool {
+	elm, err := v.cur.Read()
+	if err != nil {
+		if err == io.EOF {
+			return false
+		}
+		panic(fmt.Sprintf("broken stream: %v", err))
+	}
+
+	*key = elm.Elm.Interface().(int64)
+	*value = elm.Elm2.Interface().(typex.X)
+	return true
+}
+
+func iterMakerInt64Typex_X(s ReStream) ReusableInput {
+	ret := &iterNative{s: s}
+	ret.fn = reflect.ValueOf(ret.readInt64Typex_X)
+	return ret
+}
+
+func (v *iterNative) readETInt64Typex_X(et *typex.EventTime, key *int64, value *typex.X) bool {
+	elm, err := v.cur.Read()
+	if err != nil {
+		if err == io.EOF {
+			return false
+		}
+		panic(fmt.Sprintf("broken stream: %v", err))
+	}
+
+	*et = elm.Timestamp
+	*key = elm.Elm.Interface().(int64)
+	*value = elm.Elm2.Interface().(typex.X)
+	return true
+}
+
+func iterMakerETInt64Typex_X(s ReStream) ReusableInput {
+	ret := &iterNative{s: s}
+	ret.fn = reflect.ValueOf(ret.readETInt64Typex_X)
+	return ret
+}
+
+func (v *iterNative) readInt64Typex_Y(key *int64, value *typex.Y) bool {
+	elm, err := v.cur.Read()
+	if err != nil {
+		if err == io.EOF {
+			return false
+		}
+		panic(fmt.Sprintf("broken stream: %v", err))
+	}
+
+	*key = elm.Elm.Interface().(int64)
+	*value = elm.Elm2.Interface().(typex.Y)
+	return true
+}
+
+func iterMakerInt64Typex_Y(s ReStream) ReusableInput {
+	ret := &iterNative{s: s}
+	ret.fn = reflect.ValueOf(ret.readInt64Typex_Y)
+	return ret
+}
+
+func (v *iterNative) readETInt64Typex_Y(et *typex.EventTime, key *int64, value *typex.Y) bool {
+	elm, err := v.cur.Read()
+	if err != nil {
+		if err == io.EOF {
+			return false
+		}
+		panic(fmt.Sprintf("broken stream: %v", err))
+	}
+
+	*et = elm.Timestamp
+	*key = elm.Elm.Interface().(int64)
+	*value = elm.Elm2.Interface().(typex.Y)
+	return true
+}
+
+func iterMakerETInt64Typex_Y(s ReStream) ReusableInput {
+	ret := &iterNative{s: s}
+	ret.fn = reflect.ValueOf(ret.readETInt64Typex_Y)
+	return ret
+}
+
+func (v *iterNative) readInt64Typex_Z(key *int64, value *typex.Z) bool {
+	elm, err := v.cur.Read()
+	if err != nil {
+		if err == io.EOF {
+			return false
+		}
+		panic(fmt.Sprintf("broken stream: %v", err))
+	}
+
+	*key = elm.Elm.Interface().(int64)
+	*value = elm.Elm2.Interface().(typex.Z)
+	return true
+}
+
+func iterMakerInt64Typex_Z(s ReStream) ReusableInput {
+	ret := &iterNative{s: s}
+	ret.fn = reflect.ValueOf(ret.readInt64Typex_Z)
+	return ret
+}
+
+func (v *iterNative) readETInt64Typex_Z(et *typex.EventTime, key *int64, value *typex.Z) bool {
+	elm, err := v.cur.Read()
+	if err != nil {
+		if err == io.EOF {
+			return false
+		}
+		panic(fmt.Sprintf("broken stream: %v", err))
+	}
+
+	*et = elm.Timestamp
+	*key = elm.Elm.Interface().(int64)
+	*value = elm.Elm2.Interface().(typex.Z)
+	return true
+}
+
+func iterMakerETInt64Typex_Z(s ReStream) ReusableInput {
+	ret := &iterNative{s: s}
+	ret.fn = reflect.ValueOf(ret.readETInt64Typex_Z)
+	return ret
+}
+
+func (v *iterNative) readUint(val *uint) bool {
+	elm, err := v.cur.Read()
+	if err != nil {
+		if err == io.EOF {
+			return false
+		}
+		panic(fmt.Sprintf("broken stream: %v", err))
+	}
+
+	*val = elm.Elm.Interface().(uint)
+	return true
+}
+
+func iterMakerUint(s ReStream) ReusableInput {
+	ret := &iterNative{s: s}
+	ret.fn = reflect.ValueOf(ret.readUint)
+	return ret
+}
+
+func (v *iterNative) readETUint(et *typex.EventTime, val *uint) bool {
+	elm, err := v.cur.Read()
+	if err != nil {
+		if err == io.EOF {
+			return false
+		}
+		panic(fmt.Sprintf("broken stream: %v", err))
+	}
+
+	*et = elm.Timestamp
+	*val = elm.Elm.Interface().(uint)
+	return true
+}
+
+func iterMakerETUint(s ReStream) ReusableInput {
+	ret := &iterNative{s: s}
+	ret.fn = reflect.ValueOf(ret.readETUint)
+	return ret
+}
+
+func (v *iterNative) readUintByteSlice(key *uint, value *[]byte) bool {
+	elm, err := v.cur.Read()
+	if err != nil {
+		if err == io.EOF {
+			return false
+		}
+		panic(fmt.Sprintf("broken stream: %v", err))
+	}
+
+	*key = elm.Elm.Interface().(uint)
+	*value = elm.Elm2.Interface().([]byte)
+	return true
+}
+
+func iterMakerUintByteSlice(s ReStream) ReusableInput {
+	ret := &iterNative{s: s}
+	ret.fn = reflect.ValueOf(ret.readUintByteSlice)
+	return ret
+}
+
+func (v *iterNative) readETUintByteSlice(et *typex.EventTime, key *uint, value *[]byte) bool {
+	elm, err := v.cur.Read()
+	if err != nil {
+		if err == io.EOF {
+			return false
+		}
+		panic(fmt.Sprintf("broken stream: %v", err))
+	}
+
+	*et = elm.Timestamp
+	*key = elm.Elm.Interface().(uint)
+	*value = elm.Elm2.Interface().([]byte)
+	return true
+}
+
+func iterMakerETUintByteSlice(s ReStream) ReusableInput {
+	ret := &iterNative{s: s}
+	ret.fn = reflect.ValueOf(ret.readETUintByteSlice)
+	return ret
+}
+
+func (v *iterNative) readUintBool(key *uint, value *bool) bool {
+	elm, err := v.cur.Read()
+	if err != nil {
+		if err == io.EOF {
+			return false
+		}
+		panic(fmt.Sprintf("broken stream: %v", err))
+	}
+
+	*key = elm.Elm.Interface().(uint)
+	*value = elm.Elm2.Interface().(bool)
+	return true
+}
+
+func iterMakerUintBool(s ReStream) ReusableInput {
+	ret := &iterNative{s: s}
+	ret.fn = reflect.ValueOf(ret.readUintBool)
+	return ret
+}
+
+func (v *iterNative) readETUintBool(et *typex.EventTime, key *uint, value *bool) bool {
+	elm, err := v.cur.Read()
+	if err != nil {
+		if err == io.EOF {
+			return false
+		}
+		panic(fmt.Sprintf("broken stream: %v", err))
+	}
+
+	*et = elm.Timestamp
+	*key = elm.Elm.Interface().(uint)
+	*value = elm.Elm2.Interface().(bool)
+	return true
+}
+
+func iterMakerETUintBool(s ReStream) ReusableInput {
+	ret := &iterNative{s: s}
+	ret.fn = reflect.ValueOf(ret.readETUintBool)
+	return ret
+}
+
+func (v *iterNative) readUintString(key *uint, value *string) bool {
+	elm, err := v.cur.Read()
+	if err != nil {
+		if err == io.EOF {
+			return false
+		}
+		panic(fmt.Sprintf("broken stream: %v", err))
+	}
+
+	*key = elm.Elm.Interface().(uint)
+	*value = elm.Elm2.Interface().(string)
+	return true
+}
+
+func iterMakerUintString(s ReStream) ReusableInput {
+	ret := &iterNative{s: s}
+	ret.fn = reflect.ValueOf(ret.readUintString)
+	return ret
+}
+
+func (v *iterNative) readETUintString(et *typex.EventTime, key *uint, value *string) bool {
+	elm, err := v.cur.Read()
+	if err != nil {
+		if err == io.EOF {
+			return false
+		}
+		panic(fmt.Sprintf("broken stream: %v", err))
+	}
+
+	*et = elm.Timestamp
+	*key = elm.Elm.Interface().(uint)
+	*value = elm.Elm2.Interface().(string)
+	return true
+}
+
+func iterMakerETUintString(s ReStream) ReusableInput {
+	ret := &iterNative{s: s}
+	ret.fn = reflect.ValueOf(ret.readETUintString)
+	return ret
+}
+
+func (v *iterNative) readUintInt(key *uint, value *int) bool {
+	elm, err := v.cur.Read()
+	if err != nil {
+		if err == io.EOF {
+			return false
+		}
+		panic(fmt.Sprintf("broken stream: %v", err))
+	}
+
+	*key = elm.Elm.Interface().(uint)
+	*value = elm.Elm2.Interface().(int)
+	return true
+}
+
+func iterMakerUintInt(s ReStream) ReusableInput {
+	ret := &iterNative{s: s}
+	ret.fn = reflect.ValueOf(ret.readUintInt)
+	return ret
+}
+
+func (v *iterNative) readETUintInt(et *typex.EventTime, key *uint, value *int) bool {
+	elm, err := v.cur.Read()
+	if err != nil {
+		if err == io.EOF {
+			return false
+		}
+		panic(fmt.Sprintf("broken stream: %v", err))
+	}
+
+	*et = elm.Timestamp
+	*key = elm.Elm.Interface().(uint)
+	*value = elm.Elm2.Interface().(int)
+	return true
+}
+
+func iterMakerETUintInt(s ReStream) ReusableInput {
+	ret := &iterNative{s: s}
+	ret.fn = reflect.ValueOf(ret.readETUintInt)
+	return ret
+}
+
+func (v *iterNative) readUintInt8(key *uint, value *int8) bool {
+	elm, err := v.cur.Read()
+	if err != nil {
+		if err == io.EOF {
+			return false
+		}
+		panic(fmt.Sprintf("broken stream: %v", err))
+	}
+
+	*key = elm.Elm.Interface().(uint)
+	*value = elm.Elm2.Interface().(int8)
+	return true
+}
+
+func iterMakerUintInt8(s ReStream) ReusableInput {
+	ret := &iterNative{s: s}
+	ret.fn = reflect.ValueOf(ret.readUintInt8)
+	return ret
+}
+
+func (v *iterNative) readETUintInt8(et *typex.EventTime, key *uint, value *int8) bool {
+	elm, err := v.cur.Read()
+	if err != nil {
+		if err == io.EOF {
+			return false
+		}
+		panic(fmt.Sprintf("broken stream: %v", err))
+	}
+
+	*et = elm.Timestamp
+	*key = elm.Elm.Interface().(uint)
+	*value = elm.Elm2.Interface().(int8)
+	return true
+}
+
+func iterMakerETUintInt8(s ReStream) ReusableInput {
+	ret := &iterNative{s: s}
+	ret.fn = reflect.ValueOf(ret.readETUintInt8)
+	return ret
+}
+
+func (v *iterNative) readUintInt16(key *uint, value *int16) bool {
+	elm, err := v.cur.Read()
+	if err != nil {
+		if err == io.EOF {
+			return false
+		}
+		panic(fmt.Sprintf("broken stream: %v", err))
+	}
+
+	*key = elm.Elm.Interface().(uint)
+	*value = elm.Elm2.Interface().(int16)
+	return true
+}
+
+func iterMakerUintInt16(s ReStream) ReusableInput {
+	ret := &iterNative{s: s}
+	ret.fn = reflect.ValueOf(ret.readUintInt16)
+	return ret
+}
+
+func (v *iterNative) readETUintInt16(et *typex.EventTime, key *uint, value *int16) bool {
+	elm, err := v.cur.Read()
+	if err != nil {
+		if err == io.EOF {
+			return false
+		}
+		panic(fmt.Sprintf("broken stream: %v", err))
+	}
+
+	*et = elm.Timestamp
+	*key = elm.Elm.Interface().(uint)
+	*value = elm.Elm2.Interface().(int16)
+	return true
+}
+
+func iterMakerETUintInt16(s ReStream) ReusableInput {
+	ret := &iterNative{s: s}
+	ret.fn = reflect.ValueOf(ret.readETUintInt16)
+	return ret
+}
+
+func (v *iterNative) readUintInt32(key *uint, value *int32) bool {
+	elm, err := v.cur.Read()
+	if err != nil {
+		if err == io.EOF {
+			return false
+		}
+		panic(fmt.Sprintf("broken stream: %v", err))
+	}
+
+	*key = elm.Elm.Interface().(uint)
+	*value = elm.Elm2.Interface().(int32)
+	return true
+}
+
+func iterMakerUintInt32(s ReStream) ReusableInput {
+	ret := &iterNative{s: s}
+	ret.fn = reflect.ValueOf(ret.readUintInt32)
+	return ret
+}
+
+func (v *iterNative) readETUintInt32(et *typex.EventTime, key *uint, value *int32) bool {
+	elm, err := v.cur.Read()
+	if err != nil {
+		if err == io.EOF {
+			return false
+		}
+		panic(fmt.Sprintf("broken stream: %v", err))
+	}
+
+	*et = elm.Timestamp
+	*key = elm.Elm.Interface().(uint)
+	*value = elm.Elm2.Interface().(int32)
+	return true
+}
+
+func iterMakerETUintInt32(s ReStream) ReusableInput {
+	ret := &iterNative{s: s}
+	ret.fn = reflect.ValueOf(ret.readETUintInt32)
+	return ret
+}
+
+func (v *iterNative) readUintInt64(key *uint, value *int64) bool {
+	elm, err := v.cur.Read()
+	if err != nil {
+		if err == io.EOF {
+			return false
+		}
+		panic(fmt.Sprintf("broken stream: %v", err))
+	}
+
+	*key = elm.Elm.Interface().(uint)
+	*value = elm.Elm2.Interface().(int64)
+	return true
+}
+
+func iterMakerUintInt64(s ReStream) ReusableInput {
+	ret := &iterNative{s: s}
+	ret.fn = reflect.ValueOf(ret.readUintInt64)
+	return ret
+}
+
+func (v *iterNative) readETUintInt64(et *typex.EventTime, key *uint, value *int64) bool {
+	elm, err := v.cur.Read()
+	if err != nil {
+		if err == io.EOF {
+			return false
+		}
+		panic(fmt.Sprintf("broken stream: %v", err))
+	}
+
+	*et = elm.Timestamp
+	*key = elm.Elm.Interface().(uint)
+	*value = elm.Elm2.Interface().(int64)
+	return true
+}
+
+func iterMakerETUintInt64(s ReStream) ReusableInput {
+	ret := &iterNative{s: s}
+	ret.fn = reflect.ValueOf(ret.readETUintInt64)
+	return ret
+}
+
+func (v *iterNative) readUintUint(key *uint, value *uint) bool {
+	elm, err := v.cur.Read()
+	if err != nil {
+		if err == io.EOF {
+			return false
+		}
+		panic(fmt.Sprintf("broken stream: %v", err))
+	}
+
+	*key = elm.Elm.Interface().(uint)
+	*value = elm.Elm2.Interface().(uint)
+	return true
+}
+
+func iterMakerUintUint(s ReStream) ReusableInput {
+	ret := &iterNative{s: s}
+	ret.fn = reflect.ValueOf(ret.readUintUint)
+	return ret
+}
+
+func (v *iterNative) readETUintUint(et *typex.EventTime, key *uint, value *uint) bool {
+	elm, err := v.cur.Read()
+	if err != nil {
+		if err == io.EOF {
+			return false
+		}
+		panic(fmt.Sprintf("broken stream: %v", err))
+	}
+
+	*et = elm.Timestamp
+	*key = elm.Elm.Interface().(uint)
+	*value = elm.Elm2.Interface().(uint)
+	return true
+}
+
+func iterMakerETUintUint(s ReStream) ReusableInput {
+	ret := &iterNative{s: s}
+	ret.fn = reflect.ValueOf(ret.readETUintUint)
+	return ret
+}
+
+func (v *iterNative) readUintUint8(key *uint, value *uint8) bool {
+	elm, err := v.cur.Read()
+	if err != nil {
+		if err == io.EOF {
+			return false
+		}
+		panic(fmt.Sprintf("broken stream: %v", err))
+	}
+
+	*key = elm.Elm.Interface().(uint)
+	*value = elm.Elm2.Interface().(uint8)
+	return true
+}
+
+func iterMakerUintUint8(s ReStream) ReusableInput {
+	ret := &iterNative{s: s}
+	ret.fn = reflect.ValueOf(ret.readUintUint8)
+	return ret
+}
+
+func (v *iterNative) readETUintUint8(et *typex.EventTime, key *uint, value *uint8) bool {
+	elm, err := v.cur.Read()
+	if err != nil {
+		if err == io.EOF {
+			return false
+		}
+		panic(fmt.Sprintf("broken stream: %v", err))
+	}
+
+	*et = elm.Timestamp
+	*key = elm.Elm.Interface().(uint)
+	*value = elm.Elm2.Interface().(uint8)
+	return true
+}
+
+func iterMakerETUintUint8(s ReStream) ReusableInput {
+	ret := &iterNative{s: s}
+	ret.fn = reflect.ValueOf(ret.readETUintUint8)
+	return ret
+}
+
+func (v *iterNative) readUintUint16(key *uint, value *uint16) bool {
+	elm, err := v.cur.Read()
+	if err != nil {
+		if err == io.EOF {
+			return false
+		}
+		panic(fmt.Sprintf("broken stream: %v", err))
+	}
+
+	*key = elm.Elm.Interface().(uint)
+	*value = elm.Elm2.Interface().(uint16)
+	return true
+}
+
+func iterMakerUintUint16(s ReStream) ReusableInput {
+	ret := &iterNative{s: s}
+	ret.fn = reflect.ValueOf(ret.readUintUint16)
+	return ret
+}
+
+func (v *iterNative) readETUintUint16(et *typex.EventTime, key *uint, value *uint16) bool {
+	elm, err := v.cur.Read()
+	if err != nil {
+		if err == io.EOF {
+			return false
+		}
+		panic(fmt.Sprintf("broken stream: %v", err))
+	}
+
+	*et = elm.Timestamp
+	*key = elm.Elm.Interface().(uint)
+	*value = elm.Elm2.Interface().(uint16)
+	return true
+}
+
+func iterMakerETUintUint16(s ReStream) ReusableInput {
+	ret := &iterNative{s: s}
+	ret.fn = reflect.ValueOf(ret.readETUintUint16)
+	return ret
+}
+
+func (v *iterNative) readUintUint32(key *uint, value *uint32) bool {
+	elm, err := v.cur.Read()
+	if err != nil {
+		if err == io.EOF {
+			return false
+		}
+		panic(fmt.Sprintf("broken stream: %v", err))
+	}
+
+	*key = elm.Elm.Interface().(uint)
+	*value = elm.Elm2.Interface().(uint32)
+	return true
+}
+
+func iterMakerUintUint32(s ReStream) ReusableInput {
+	ret := &iterNative{s: s}
+	ret.fn = reflect.ValueOf(ret.readUintUint32)
+	return ret
+}
+
+func (v *iterNative) readETUintUint32(et *typex.EventTime, key *uint, value *uint32) bool {
+	elm, err := v.cur.Read()
+	if err != nil {
+		if err == io.EOF {
+			return false
+		}
+		panic(fmt.Sprintf("broken stream: %v", err))
+	}
+
+	*et = elm.Timestamp
+	*key = elm.Elm.Interface().(uint)
+	*value = elm.Elm2.Interface().(uint32)
+	return true
+}
+
+func iterMakerETUintUint32(s ReStream) ReusableInput {
+	ret := &iterNative{s: s}
+	ret.fn = reflect.ValueOf(ret.readETUintUint32)
+	return ret
+}
+
+func (v *iterNative) readUintUint64(key *uint, value *uint64) bool {
+	elm, err := v.cur.Read()
+	if err != nil {
+		if err == io.EOF {
+			return false
+		}
+		panic(fmt.Sprintf("broken stream: %v", err))
+	}
+
+	*key = elm.Elm.Interface().(uint)
+	*value = elm.Elm2.Interface().(uint64)
+	return true
+}
+
+func iterMakerUintUint64(s ReStream) ReusableInput {
+	ret := &iterNative{s: s}
+	ret.fn = reflect.ValueOf(ret.readUintUint64)
+	return ret
+}
+
+func (v *iterNative) readETUintUint64(et *typex.EventTime, key *uint, value *uint64) bool {
+	elm, err := v.cur.Read()
+	if err != nil {
+		if err == io.EOF {
+			return false
+		}
+		panic(fmt.Sprintf("broken stream: %v", err))
+	}
+
+	*et = elm.Timestamp
+	*key = elm.Elm.Interface().(uint)
+	*value = elm.Elm2.Interface().(uint64)
+	return true
+}
+
+func iterMakerETUintUint64(s ReStream) ReusableInput {
+	ret := &iterNative{s: s}
+	ret.fn = reflect.ValueOf(ret.readETUintUint64)
+	return ret
+}
+
+func (v *iterNative) readUintFloat32(key *uint, value *float32) bool {
+	elm, err := v.cur.Read()
+	if err != nil {
+		if err == io.EOF {
+			return false
+		}
+		panic(fmt.Sprintf("broken stream: %v", err))
+	}
+
+	*key = elm.Elm.Interface().(uint)
+	*value = elm.Elm2.Interface().(float32)
+	return true
+}
+
+func iterMakerUintFloat32(s ReStream) ReusableInput {
+	ret := &iterNative{s: s}
+	ret.fn = reflect.ValueOf(ret.readUintFloat32)
+	return ret
+}
+
+func (v *iterNative) readETUintFloat32(et *typex.EventTime, key *uint, value *float32) bool {
+	elm, err := v.cur.Read()
+	if err != nil {
+		if err == io.EOF {
+			return false
+		}
+		panic(fmt.Sprintf("broken stream: %v", err))
+	}
+
+	*et = elm.Timestamp
+	*key = elm.Elm.Interface().(uint)
+	*value = elm.Elm2.Interface().(float32)
+	return true
+}
+
+func iterMakerETUintFloat32(s ReStream) ReusableInput {
+	ret := &iterNative{s: s}
+	ret.fn = reflect.ValueOf(ret.readETUintFloat32)
+	return ret
+}
+
+func (v *iterNative) readUintFloat64(key *uint, value *float64) bool {
+	elm, err := v.cur.Read()
+	if err != nil {
+		if err == io.EOF {
+			return false
+		}
+		panic(fmt.Sprintf("broken stream: %v", err))
+	}
+
+	*key = elm.Elm.Interface().(uint)
+	*value = elm.Elm2.Interface().(float64)
+	return true
+}
+
+func iterMakerUintFloat64(s ReStream) ReusableInput {
+	ret := &iterNative{s: s}
+	ret.fn = reflect.ValueOf(ret.readUintFloat64)
+	return ret
+}
+
+func (v *iterNative) readETUintFloat64(et *typex.EventTime, key *uint, value *float64) bool {
+	elm, err := v.cur.Read()
+	if err != nil {
+		if err == io.EOF {
+			return false
+		}
+		panic(fmt.Sprintf("broken stream: %v", err))
+	}
+
+	*et = elm.Timestamp
+	*key = elm.Elm.Interface().(uint)
+	*value = elm.Elm2.Interface().(float64)
+	return true
+}
+
+func iterMakerETUintFloat64(s ReStream) ReusableInput {
+	ret := &iterNative{s: s}
+	ret.fn = reflect.ValueOf(ret.readETUintFloat64)
+	return ret
+}
+
+func (v *iterNative) readUintTypex_T(key *uint, value *typex.T) bool {
+	elm, err := v.cur.Read()
+	if err != nil {
+		if err == io.EOF {
+			return false
+		}
+		panic(fmt.Sprintf("broken stream: %v", err))
+	}
+
+	*key = elm.Elm.Interface().(uint)
+	*value = elm.Elm2.Interface().(typex.T)
+	return true
+}
+
+func iterMakerUintTypex_T(s ReStream) ReusableInput {
+	ret := &iterNative{s: s}
+	ret.fn = reflect.ValueOf(ret.readUintTypex_T)
+	return ret
+}
+
+func (v *iterNative) readETUintTypex_T(et *typex.EventTime, key *uint, value *typex.T) bool {
+	elm, err := v.cur.Read()
+	if err != nil {
+		if err == io.EOF {
+			return false
+		}
+		panic(fmt.Sprintf("broken stream: %v", err))
+	}
+
+	*et = elm.Timestamp
+	*key = elm.Elm.Interface().(uint)
+	*value = elm.Elm2.Interface().(typex.T)
+	return true
+}
+
+func iterMakerETUintTypex_T(s ReStream) ReusableInput {
+	ret := &iterNative{s: s}
+	ret.fn = reflect.ValueOf(ret.readETUintTypex_T)
+	return ret
+}
+
+func (v *iterNative) readUintTypex_U(key *uint, value *typex.U) bool {
+	elm, err := v.cur.Read()
+	if err != nil {
+		if err == io.EOF {
+			return false
+		}
+		panic(fmt.Sprintf("broken stream: %v", err))
+	}
+
+	*key = elm.Elm.Interface().(uint)
+	*value = elm.Elm2.Interface().(typex.U)
+	return true
+}
+
+func iterMakerUintTypex_U(s ReStream) ReusableInput {
+	ret := &iterNative{s: s}
+	ret.fn = reflect.ValueOf(ret.readUintTypex_U)
+	return ret
+}
+
+func (v *iterNative) readETUintTypex_U(et *typex.EventTime, key *uint, value *typex.U) bool {
+	elm, err := v.cur.Read()
+	if err != nil {
+		if err == io.EOF {
+			return false
+		}
+		panic(fmt.Sprintf("broken stream: %v", err))
+	}
+
+	*et = elm.Timestamp
+	*key = elm.Elm.Interface().(uint)
+	*value = elm.Elm2.Interface().(typex.U)
+	return true
+}
+
+func iterMakerETUintTypex_U(s ReStream) ReusableInput {
+	ret := &iterNative{s: s}
+	ret.fn = reflect.ValueOf(ret.readETUintTypex_U)
+	return ret
+}
+
+func (v *iterNative) readUintTypex_V(key *uint, value *typex.V) bool {
+	elm, err := v.cur.Read()
+	if err != nil {
+		if err == io.EOF {
+			return false
+		}
+		panic(fmt.Sprintf("broken stream: %v", err))
+	}
+
+	*key = elm.Elm.Interface().(uint)
+	*value = elm.Elm2.Interface().(typex.V)
+	return true
+}
+
+func iterMakerUintTypex_V(s ReStream) ReusableInput {
+	ret := &iterNative{s: s}
+	ret.fn = reflect.ValueOf(ret.readUintTypex_V)
+	return ret
+}
+
+func (v *iterNative) readETUintTypex_V(et *typex.EventTime, key *uint, value *typex.V) bool {
+	elm, err := v.cur.Read()
+	if err != nil {
+		if err == io.EOF {
+			return false
+		}
+		panic(fmt.Sprintf("broken stream: %v", err))
+	}
+
+	*et = elm.Timestamp
+	*key = elm.Elm.Interface().(uint)
+	*value = elm.Elm2.Interface().(typex.V)
+	return true
+}
+
+func iterMakerETUintTypex_V(s ReStream) ReusableInput {
+	ret := &iterNative{s: s}
+	ret.fn = reflect.ValueOf(ret.readETUintTypex_V)
+	return ret
+}
+
+func (v *iterNative) readUintTypex_W(key *uint, value *typex.W) bool {
+	elm, err := v.cur.Read()
+	if err != nil {
+		if err == io.EOF {
+			return false
+		}
+		panic(fmt.Sprintf("broken stream: %v", err))
+	}
+
+	*key = elm.Elm.Interface().(uint)
+	*value = elm.Elm2.Interface().(typex.W)
+	return true
+}
+
+func iterMakerUintTypex_W(s ReStream) ReusableInput {
+	ret := &iterNative{s: s}
+	ret.fn = reflect.ValueOf(ret.readUintTypex_W)
+	return ret
+}
+
+func (v *iterNative) readETUintTypex_W(et *typex.EventTime, key *uint, value *typex.W) bool {
+	elm, err := v.cur.Read()
+	if err != nil {
+		if err == io.EOF {
+			return false
+		}
+		panic(fmt.Sprintf("broken stream: %v", err))
+	}
+
+	*et = elm.Timestamp
+	*key = elm.Elm.Interface().(uint)
+	*value = elm.Elm2.Interface().(typex.W)
+	return true
+}
+
+func iterMakerETUintTypex_W(s ReStream) ReusableInput {
+	ret := &iterNative{s: s}
+	ret.fn = reflect.ValueOf(ret.readETUintTypex_W)
+	return ret
+}
+
+func (v *iterNative) readUintTypex_X(key *uint, value *typex.X) bool {
+	elm, err := v.cur.Read()
+	if err != nil {
+		if err == io.EOF {
+			return false
+		}
+		panic(fmt.Sprintf("broken stream: %v", err))
+	}
+
+	*key = elm.Elm.Interface().(uint)
+	*value = elm.Elm2.Interface().(typex.X)
+	return true
+}
+
+func iterMakerUintTypex_X(s ReStream) ReusableInput {
+	ret := &iterNative{s: s}
+	ret.fn = reflect.ValueOf(ret.readUintTypex_X)
+	return ret
+}
+
+func (v *iterNative) readETUintTypex_X(et *typex.EventTime, key *uint, value *typex.X) bool {
+	elm, err := v.cur.Read()
+	if err != nil {
+		if err == io.EOF {
+			return false
+		}
+		panic(fmt.Sprintf("broken stream: %v", err))
+	}
+
+	*et = elm.Timestamp
+	*key = elm.Elm.Interface().(uint)
+	*value = elm.Elm2.Interface().(typex.X)
+	return true
+}
+
+func iterMakerETUintTypex_X(s ReStream) ReusableInput {
+	ret := &iterNative{s: s}
+	ret.fn = reflect.ValueOf(ret.readETUintTypex_X)
+	return ret
+}
+
+func (v *iterNative) readUintTypex_Y(key *uint, value *typex.Y) bool {
+	elm, err := v.cur.Read()
+	if err != nil {
+		if err == io.EOF {
+			return false
+		}
+		panic(fmt.Sprintf("broken stream: %v", err))
+	}
+
+	*key = elm.Elm.Interface().(uint)
+	*value = elm.Elm2.Interface().(typex.Y)
+	return true
+}
+
+func iterMakerUintTypex_Y(s ReStream) ReusableInput {
+	ret := &iterNative{s: s}
+	ret.fn = reflect.ValueOf(ret.readUintTypex_Y)
+	return ret
+}
+
+func (v *iterNative) readETUintTypex_Y(et *typex.EventTime, key *uint, value *typex.Y) bool {
+	elm, err := v.cur.Read()
+	if err != nil {
+		if err == io.EOF {
+			return false
+		}
+		panic(fmt.Sprintf("broken stream: %v", err))
+	}
+
+	*et = elm.Timestamp
+	*key = elm.Elm.Interface().(uint)
+	*value = elm.Elm2.Interface().(typex.Y)
+	return true
+}
+
+func iterMakerETUintTypex_Y(s ReStream) ReusableInput {
+	ret := &iterNative{s: s}
+	ret.fn = reflect.ValueOf(ret.readETUintTypex_Y)
+	return ret
+}
+
+func (v *iterNative) readUintTypex_Z(key *uint, value *typex.Z) bool {
+	elm, err := v.cur.Read()
+	if err != nil {
+		if err == io.EOF {
+			return false
+		}
+		panic(fmt.Sprintf("broken stream: %v", err))
+	}
+
+	*key = elm.Elm.Interface().(uint)
+	*value = elm.Elm2.Interface().(typex.Z)
+	return true
+}
+
+func iterMakerUintTypex_Z(s ReStream) ReusableInput {
+	ret := &iterNative{s: s}
+	ret.fn = reflect.ValueOf(ret.readUintTypex_Z)
+	return ret
+}
+
+func (v *iterNative) readETUintTypex_Z(et *typex.EventTime, key *uint, value *typex.Z) bool {
+	elm, err := v.cur.Read()
+	if err != nil {
+		if err == io.EOF {
+			return false
+		}
+		panic(fmt.Sprintf("broken stream: %v", err))
+	}
+
+	*et = elm.Timestamp
+	*key = elm.Elm.Interface().(uint)
+	*value = elm.Elm2.Interface().(typex.Z)
+	return true
+}
+
+func iterMakerETUintTypex_Z(s ReStream) ReusableInput {
+	ret := &iterNative{s: s}
+	ret.fn = reflect.ValueOf(ret.readETUintTypex_Z)
+	return ret
+}
+
+func (v *iterNative) readUint8(val *uint8) bool {
+	elm, err := v.cur.Read()
+	if err != nil {
+		if err == io.EOF {
+			return false
+		}
+		panic(fmt.Sprintf("broken stream: %v", err))
+	}
+
+	*val = elm.Elm.Interface().(uint8)
+	return true
+}
+
+func iterMakerUint8(s ReStream) ReusableInput {
+	ret := &iterNative{s: s}
+	ret.fn = reflect.ValueOf(ret.readUint8)
+	return ret
+}
+
+func (v *iterNative) readETUint8(et *typex.EventTime, val *uint8) bool {
+	elm, err := v.cur.Read()
+	if err != nil {
+		if err == io.EOF {
+			return false
+		}
+		panic(fmt.Sprintf("broken stream: %v", err))
+	}
+
+	*et = elm.Timestamp
+	*val = elm.Elm.Interface().(uint8)
+	return true
+}
+
+func iterMakerETUint8(s ReStream) ReusableInput {
+	ret := &iterNative{s: s}
+	ret.fn = reflect.ValueOf(ret.readETUint8)
+	return ret
+}
+
+func (v *iterNative) readUint8ByteSlice(key *uint8, value *[]byte) bool {
+	elm, err := v.cur.Read()
+	if err != nil {
+		if err == io.EOF {
+			return false
+		}
+		panic(fmt.Sprintf("broken stream: %v", err))
+	}
+
+	*key = elm.Elm.Interface().(uint8)
+	*value = elm.Elm2.Interface().([]byte)
+	return true
+}
+
+func iterMakerUint8ByteSlice(s ReStream) ReusableInput {
+	ret := &iterNative{s: s}
+	ret.fn = reflect.ValueOf(ret.readUint8ByteSlice)
+	return ret
+}
+
+func (v *iterNative) readETUint8ByteSlice(et *typex.EventTime, key *uint8, value *[]byte) bool {
+	elm, err := v.cur.Read()
+	if err != nil {
+		if err == io.EOF {
+			return false
+		}
+		panic(fmt.Sprintf("broken stream: %v", err))
+	}
+
+	*et = elm.Timestamp
+	*key = elm.Elm.Interface().(uint8)
+	*value = elm.Elm2.Interface().([]byte)
+	return true
+}
+
+func iterMakerETUint8ByteSlice(s ReStream) ReusableInput {
+	ret := &iterNative{s: s}
+	ret.fn = reflect.ValueOf(ret.readETUint8ByteSlice)
+	return ret
+}
+
+func (v *iterNative) readUint8Bool(key *uint8, value *bool) bool {
+	elm, err := v.cur.Read()
+	if err != nil {
+		if err == io.EOF {
+			return false
+		}
+		panic(fmt.Sprintf("broken stream: %v", err))
+	}
+
+	*key = elm.Elm.Interface().(uint8)
+	*value = elm.Elm2.Interface().(bool)
+	return true
+}
+
+func iterMakerUint8Bool(s ReStream) ReusableInput {
+	ret := &iterNative{s: s}
+	ret.fn = reflect.ValueOf(ret.readUint8Bool)
+	return ret
+}
+
+func (v *iterNative) readETUint8Bool(et *typex.EventTime, key *uint8, value *bool) bool {
+	elm, err := v.cur.Read()
+	if err != nil {
+		if err == io.EOF {
+			return false
+		}
+		panic(fmt.Sprintf("broken stream: %v", err))
+	}
+
+	*et = elm.Timestamp
+	*key = elm.Elm.Interface().(uint8)
+	*value = elm.Elm2.Interface().(bool)
+	return true
+}
+
+func iterMakerETUint8Bool(s ReStream) ReusableInput {
+	ret := &iterNative{s: s}
+	ret.fn = reflect.ValueOf(ret.readETUint8Bool)
+	return ret
+}
+
+func (v *iterNative) readUint8String(key *uint8, value *string) bool {
+	elm, err := v.cur.Read()
+	if err != nil {
+		if err == io.EOF {
+			return false
+		}
+		panic(fmt.Sprintf("broken stream: %v", err))
+	}
+
+	*key = elm.Elm.Interface().(uint8)
+	*value = elm.Elm2.Interface().(string)
+	return true
+}
+
+func iterMakerUint8String(s ReStream) ReusableInput {
+	ret := &iterNative{s: s}
+	ret.fn = reflect.ValueOf(ret.readUint8String)
+	return ret
+}
+
+func (v *iterNative) readETUint8String(et *typex.EventTime, key *uint8, value *string) bool {
+	elm, err := v.cur.Read()
+	if err != nil {
+		if err == io.EOF {
+			return false
+		}
+		panic(fmt.Sprintf("broken stream: %v", err))
+	}
+
+	*et = elm.Timestamp
+	*key = elm.Elm.Interface().(uint8)
+	*value = elm.Elm2.Interface().(string)
+	return true
+}
+
+func iterMakerETUint8String(s ReStream) ReusableInput {
+	ret := &iterNative{s: s}
+	ret.fn = reflect.ValueOf(ret.readETUint8String)
+	return ret
+}
+
+func (v *iterNative) readUint8Int(key *uint8, value *int) bool {
+	elm, err := v.cur.Read()
+	if err != nil {
+		if err == io.EOF {
+			return false
+		}
+		panic(fmt.Sprintf("broken stream: %v", err))
+	}
+
+	*key = elm.Elm.Interface().(uint8)
+	*value = elm.Elm2.Interface().(int)
+	return true
+}
+
+func iterMakerUint8Int(s ReStream) ReusableInput {
+	ret := &iterNative{s: s}
+	ret.fn = reflect.ValueOf(ret.readUint8Int)
+	return ret
+}
+
+func (v *iterNative) readETUint8Int(et *typex.EventTime, key *uint8, value *int) bool {
+	elm, err := v.cur.Read()
+	if err != nil {
+		if err == io.EOF {
+			return false
+		}
+		panic(fmt.Sprintf("broken stream: %v", err))
+	}
+
+	*et = elm.Timestamp
+	*key = elm.Elm.Interface().(uint8)
+	*value = elm.Elm2.Interface().(int)
+	return true
+}
+
+func iterMakerETUint8Int(s ReStream) ReusableInput {
+	ret := &iterNative{s: s}
+	ret.fn = reflect.ValueOf(ret.readETUint8Int)
+	return ret
+}
+
+func (v *iterNative) readUint8Int8(key *uint8, value *int8) bool {
+	elm, err := v.cur.Read()
+	if err != nil {
+		if err == io.EOF {
+			return false
+		}
+		panic(fmt.Sprintf("broken stream: %v", err))
+	}
+
+	*key = elm.Elm.Interface().(uint8)
+	*value = elm.Elm2.Interface().(int8)
+	return true
+}
+
+func iterMakerUint8Int8(s ReStream) ReusableInput {
+	ret := &iterNative{s: s}
+	ret.fn = reflect.ValueOf(ret.readUint8Int8)
+	return ret
+}
+
+func (v *iterNative) readETUint8Int8(et *typex.EventTime, key *uint8, value *int8) bool {
+	elm, err := v.cur.Read()
+	if err != nil {
+		if err == io.EOF {
+			return false
+		}
+		panic(fmt.Sprintf("broken stream: %v", err))
+	}
+
+	*et = elm.Timestamp
+	*key = elm.Elm.Interface().(uint8)
+	*value = elm.Elm2.Interface().(int8)
+	return true
+}
+
+func iterMakerETUint8Int8(s ReStream) ReusableInput {
+	ret := &iterNative{s: s}
+	ret.fn = reflect.ValueOf(ret.readETUint8Int8)
+	return ret
+}
+
+func (v *iterNative) readUint8Int16(key *uint8, value *int16) bool {
+	elm, err := v.cur.Read()
+	if err != nil {
+		if err == io.EOF {
+			return false
+		}
+		panic(fmt.Sprintf("broken stream: %v", err))
+	}
+
+	*key = elm.Elm.Interface().(uint8)
+	*value = elm.Elm2.Interface().(int16)
+	return true
+}
+
+func iterMakerUint8Int16(s ReStream) ReusableInput {
+	ret := &iterNative{s: s}
+	ret.fn = reflect.ValueOf(ret.readUint8Int16)
+	return ret
+}
+
+func (v *iterNative) readETUint8Int16(et *typex.EventTime, key *uint8, value *int16) bool {
+	elm, err := v.cur.Read()
+	if err != nil {
+		if err == io.EOF {
+			return false
+		}
+		panic(fmt.Sprintf("broken stream: %v", err))
+	}
+
+	*et = elm.Timestamp
+	*key = elm.Elm.Interface().(uint8)
+	*value = elm.Elm2.Interface().(int16)
+	return true
+}
+
+func iterMakerETUint8Int16(s ReStream) ReusableInput {
+	ret := &iterNative{s: s}
+	ret.fn = reflect.ValueOf(ret.readETUint8Int16)
+	return ret
+}
+
+func (v *iterNative) readUint8Int32(key *uint8, value *int32) bool {
+	elm, err := v.cur.Read()
+	if err != nil {
+		if err == io.EOF {
+			return false
+		}
+		panic(fmt.Sprintf("broken stream: %v", err))
+	}
+
+	*key = elm.Elm.Interface().(uint8)
+	*value = elm.Elm2.Interface().(int32)
+	return true
+}
+
+func iterMakerUint8Int32(s ReStream) ReusableInput {
+	ret := &iterNative{s: s}
+	ret.fn = reflect.ValueOf(ret.readUint8Int32)
+	return ret
+}
+
+func (v *iterNative) readETUint8Int32(et *typex.EventTime, key *uint8, value *int32) bool {
+	elm, err := v.cur.Read()
+	if err != nil {
+		if err == io.EOF {
+			return false
+		}
+		panic(fmt.Sprintf("broken stream: %v", err))
+	}
+
+	*et = elm.Timestamp
+	*key = elm.Elm.Interface().(uint8)
+	*value = elm.Elm2.Interface().(int32)
+	return true
+}
+
+func iterMakerETUint8Int32(s ReStream) ReusableInput {
+	ret := &iterNative{s: s}
+	ret.fn = reflect.ValueOf(ret.readETUint8Int32)
+	return ret
+}
+
+func (v *iterNative) readUint8Int64(key *uint8, value *int64) bool {
+	elm, err := v.cur.Read()
+	if err != nil {
+		if err == io.EOF {
+			return false
+		}
+		panic(fmt.Sprintf("broken stream: %v", err))
+	}
+
+	*key = elm.Elm.Interface().(uint8)
+	*value = elm.Elm2.Interface().(int64)
+	return true
+}
+
+func iterMakerUint8Int64(s ReStream) ReusableInput {
+	ret := &iterNative{s: s}
+	ret.fn = reflect.ValueOf(ret.readUint8Int64)
+	return ret
+}
+
+func (v *iterNative) readETUint8Int64(et *typex.EventTime, key *uint8, value *int64) bool {
+	elm, err := v.cur.Read()
+	if err != nil {
+		if err == io.EOF {
+			return false
+		}
+		panic(fmt.Sprintf("broken stream: %v", err))
+	}
+
+	*et = elm.Timestamp
+	*key = elm.Elm.Interface().(uint8)
+	*value = elm.Elm2.Interface().(int64)
+	return true
+}
+
+func iterMakerETUint8Int64(s ReStream) ReusableInput {
+	ret := &iterNative{s: s}
+	ret.fn = reflect.ValueOf(ret.readETUint8Int64)
+	return ret
+}
+
+func (v *iterNative) readUint8Uint(key *uint8, value *uint) bool {
+	elm, err := v.cur.Read()
+	if err != nil {
+		if err == io.EOF {
+			return false
+		}
+		panic(fmt.Sprintf("broken stream: %v", err))
+	}
+
+	*key = elm.Elm.Interface().(uint8)
+	*value = elm.Elm2.Interface().(uint)
+	return true
+}
+
+func iterMakerUint8Uint(s ReStream) ReusableInput {
+	ret := &iterNative{s: s}
+	ret.fn = reflect.ValueOf(ret.readUint8Uint)
+	return ret
+}
+
+func (v *iterNative) readETUint8Uint(et *typex.EventTime, key *uint8, value *uint) bool {
+	elm, err := v.cur.Read()
+	if err != nil {
+		if err == io.EOF {
+			return false
+		}
+		panic(fmt.Sprintf("broken stream: %v", err))
+	}
+
+	*et = elm.Timestamp
+	*key = elm.Elm.Interface().(uint8)
+	*value = elm.Elm2.Interface().(uint)
+	return true
+}
+
+func iterMakerETUint8Uint(s ReStream) ReusableInput {
+	ret := &iterNative{s: s}
+	ret.fn = reflect.ValueOf(ret.readETUint8Uint)
+	return ret
+}
+
+func (v *iterNative) readUint8Uint8(key *uint8, value *uint8) bool {
+	elm, err := v.cur.Read()
+	if err != nil {
+		if err == io.EOF {
+			return false
+		}
+		panic(fmt.Sprintf("broken stream: %v", err))
+	}
+
+	*key = elm.Elm.Interface().(uint8)
+	*value = elm.Elm2.Interface().(uint8)
+	return true
+}
+
+func iterMakerUint8Uint8(s ReStream) ReusableInput {
+	ret := &iterNative{s: s}
+	ret.fn = reflect.ValueOf(ret.readUint8Uint8)
+	return ret
+}
+
+func (v *iterNative) readETUint8Uint8(et *typex.EventTime, key *uint8, value *uint8) bool {
+	elm, err := v.cur.Read()
+	if err != nil {
+		if err == io.EOF {
+			return false
+		}
+		panic(fmt.Sprintf("broken stream: %v", err))
+	}
+
+	*et = elm.Timestamp
+	*key = elm.Elm.Interface().(uint8)
+	*value = elm.Elm2.Interface().(uint8)
+	return true
+}
+
+func iterMakerETUint8Uint8(s ReStream) ReusableInput {
+	ret := &iterNative{s: s}
+	ret.fn = reflect.ValueOf(ret.readETUint8Uint8)
+	return ret
+}
+
+func (v *iterNative) readUint8Uint16(key *uint8, value *uint16) bool {
+	elm, err := v.cur.Read()
+	if err != nil {
+		if err == io.EOF {
+			return false
+		}
+		panic(fmt.Sprintf("broken stream: %v", err))
+	}
+
+	*key = elm.Elm.Interface().(uint8)
+	*value = elm.Elm2.Interface().(uint16)
+	return true
+}
+
+func iterMakerUint8Uint16(s ReStream) ReusableInput {
+	ret := &iterNative{s: s}
+	ret.fn = reflect.ValueOf(ret.readUint8Uint16)
+	return ret
+}
+
+func (v *iterNative) readETUint8Uint16(et *typex.EventTime, key *uint8, value *uint16) bool {
+	elm, err := v.cur.Read()
+	if err != nil {
+		if err == io.EOF {
+			return false
+		}
+		panic(fmt.Sprintf("broken stream: %v", err))
+	}
+
+	*et = elm.Timestamp
+	*key = elm.Elm.Interface().(uint8)
+	*value = elm.Elm2.Interface().(uint16)
+	return true
+}
+
+func iterMakerETUint8Uint16(s ReStream) ReusableInput {
+	ret := &iterNative{s: s}
+	ret.fn = reflect.ValueOf(ret.readETUint8Uint16)
+	return ret
+}
+
+func (v *iterNative) readUint8Uint32(key *uint8, value *uint32) bool {
+	elm, err := v.cur.Read()
+	if err != nil {
+		if err == io.EOF {
+			return false
+		}
+		panic(fmt.Sprintf("broken stream: %v", err))
+	}
+
+	*key = elm.Elm.Interface().(uint8)
+	*value = elm.Elm2.Interface().(uint32)
+	return true
+}
+
+func iterMakerUint8Uint32(s ReStream) ReusableInput {
+	ret := &iterNative{s: s}
+	ret.fn = reflect.ValueOf(ret.readUint8Uint32)
+	return ret
+}
+
+func (v *iterNative) readETUint8Uint32(et *typex.EventTime, key *uint8, value *uint32) bool {
+	elm, err := v.cur.Read()
+	if err != nil {
+		if err == io.EOF {
+			return false
+		}
+		panic(fmt.Sprintf("broken stream: %v", err))
+	}
+
+	*et = elm.Timestamp
+	*key = elm.Elm.Interface().(uint8)
+	*value = elm.Elm2.Interface().(uint32)
+	return true
+}
+
+func iterMakerETUint8Uint32(s ReStream) ReusableInput {
+	ret := &iterNative{s: s}
+	ret.fn = reflect.ValueOf(ret.readETUint8Uint32)
+	return ret
+}
+
+func (v *iterNative) readUint8Uint64(key *uint8, value *uint64) bool {
+	elm, err := v.cur.Read()
+	if err != nil {
+		if err == io.EOF {
+			return false
+		}
+		panic(fmt.Sprintf("broken stream: %v", err))
+	}
+
+	*key = elm.Elm.Interface().(uint8)
+	*value = elm.Elm2.Interface().(uint64)
+	return true
+}
+
+func iterMakerUint8Uint64(s ReStream) ReusableInput {
+	ret := &iterNative{s: s}
+	ret.fn = reflect.ValueOf(ret.readUint8Uint64)
+	return ret
+}
+
+func (v *iterNative) readETUint8Uint64(et *typex.EventTime, key *uint8, value *uint64) bool {
+	elm, err := v.cur.Read()
+	if err != nil {
+		if err == io.EOF {
+			return false
+		}
+		panic(fmt.Sprintf("broken stream: %v", err))
+	}
+
+	*et = elm.Timestamp
+	*key = elm.Elm.Interface().(uint8)
+	*value = elm.Elm2.Interface().(uint64)
+	return true
+}
+
+func iterMakerETUint8Uint64(s ReStream) ReusableInput {
+	ret := &iterNative{s: s}
+	ret.fn = reflect.ValueOf(ret.readETUint8Uint64)
+	return ret
+}
+
+func (v *iterNative) readUint8Float32(key *uint8, value *float32) bool {
+	elm, err := v.cur.Read()
+	if err != nil {
+		if err == io.EOF {
+			return false
+		}
+		panic(fmt.Sprintf("broken stream: %v", err))
+	}
+
+	*key = elm.Elm.Interface().(uint8)
+	*value = elm.Elm2.Interface().(float32)
+	return true
+}
+
+func iterMakerUint8Float32(s ReStream) ReusableInput {
+	ret := &iterNative{s: s}
+	ret.fn = reflect.ValueOf(ret.readUint8Float32)
+	return ret
+}
+
+func (v *iterNative) readETUint8Float32(et *typex.EventTime, key *uint8, value *float32) bool {
+	elm, err := v.cur.Read()
+	if err != nil {
+		if err == io.EOF {
+			return false
+		}
+		panic(fmt.Sprintf("broken stream: %v", err))
+	}
+
+	*et = elm.Timestamp
+	*key = elm.Elm.Interface().(uint8)
+	*value = elm.Elm2.Interface().(float32)
+	return true
+}
+
+func iterMakerETUint8Float32(s ReStream) ReusableInput {
+	ret := &iterNative{s: s}
+	ret.fn = reflect.ValueOf(ret.readETUint8Float32)
+	return ret
+}
+
+func (v *iterNative) readUint8Float64(key *uint8, value *float64) bool {
+	elm, err := v.cur.Read()
+	if err != nil {
+		if err == io.EOF {
+			return false
+		}
+		panic(fmt.Sprintf("broken stream: %v", err))
+	}
+
+	*key = elm.Elm.Interface().(uint8)
+	*value = elm.Elm2.Interface().(float64)
+	return true
+}
+
+func iterMakerUint8Float64(s ReStream) ReusableInput {
+	ret := &iterNative{s: s}
+	ret.fn = reflect.ValueOf(ret.readUint8Float64)
+	return ret
+}
+
+func (v *iterNative) readETUint8Float64(et *typex.EventTime, key *uint8, value *float64) bool {
+	elm, err := v.cur.Read()
+	if err != nil {
+		if err == io.EOF {
+			return false
+		}
+		panic(fmt.Sprintf("broken stream: %v", err))
+	}
+
+	*et = elm.Timestamp
+	*key = elm.Elm.Interface().(uint8)
+	*value = elm.Elm2.Interface().(float64)
+	return true
+}
+
+func iterMakerETUint8Float64(s ReStream) ReusableInput {
+	ret := &iterNative{s: s}
+	ret.fn = reflect.ValueOf(ret.readETUint8Float64)
+	return ret
+}
+
+func (v *iterNative) readUint8Typex_T(key *uint8, value *typex.T) bool {
+	elm, err := v.cur.Read()
+	if err != nil {
+		if err == io.EOF {
+			return false
+		}
+		panic(fmt.Sprintf("broken stream: %v", err))
+	}
+
+	*key = elm.Elm.Interface().(uint8)
+	*value = elm.Elm2.Interface().(typex.T)
+	return true
+}
+
+func iterMakerUint8Typex_T(s ReStream) ReusableInput {
+	ret := &iterNative{s: s}
+	ret.fn = reflect.ValueOf(ret.readUint8Typex_T)
+	return ret
+}
+
+func (v *iterNative) readETUint8Typex_T(et *typex.EventTime, key *uint8, value *typex.T) bool {
+	elm, err := v.cur.Read()
+	if err != nil {
+		if err == io.EOF {
+			return false
+		}
+		panic(fmt.Sprintf("broken stream: %v", err))
+	}
+
+	*et = elm.Timestamp
+	*key = elm.Elm.Interface().(uint8)
+	*value = elm.Elm2.Interface().(typex.T)
+	return true
+}
+
+func iterMakerETUint8Typex_T(s ReStream) ReusableInput {
+	ret := &iterNative{s: s}
+	ret.fn = reflect.ValueOf(ret.readETUint8Typex_T)
+	return ret
+}
+
+func (v *iterNative) readUint8Typex_U(key *uint8, value *typex.U) bool {
+	elm, err := v.cur.Read()
+	if err != nil {
+		if err == io.EOF {
+			return false
+		}
+		panic(fmt.Sprintf("broken stream: %v", err))
+	}
+
+	*key = elm.Elm.Interface().(uint8)
+	*value = elm.Elm2.Interface().(typex.U)
+	return true
+}
+
+func iterMakerUint8Typex_U(s ReStream) ReusableInput {
+	ret := &iterNative{s: s}
+	ret.fn = reflect.ValueOf(ret.readUint8Typex_U)
+	return ret
+}
+
+func (v *iterNative) readETUint8Typex_U(et *typex.EventTime, key *uint8, value *typex.U) bool {
+	elm, err := v.cur.Read()
+	if err != nil {
+		if err == io.EOF {
+			return false
+		}
+		panic(fmt.Sprintf("broken stream: %v", err))
+	}
+
+	*et = elm.Timestamp
+	*key = elm.Elm.Interface().(uint8)
+	*value = elm.Elm2.Interface().(typex.U)
+	return true
+}
+
+func iterMakerETUint8Typex_U(s ReStream) ReusableInput {
+	ret := &iterNative{s: s}
+	ret.fn = reflect.ValueOf(ret.readETUint8Typex_U)
+	return ret
+}
+
+func (v *iterNative) readUint8Typex_V(key *uint8, value *typex.V) bool {
+	elm, err := v.cur.Read()
+	if err != nil {
+		if err == io.EOF {
+			return false
+		}
+		panic(fmt.Sprintf("broken stream: %v", err))
+	}
+
+	*key = elm.Elm.Interface().(uint8)
+	*value = elm.Elm2.Interface().(typex.V)
+	return true
+}
+
+func iterMakerUint8Typex_V(s ReStream) ReusableInput {
+	ret := &iterNative{s: s}
+	ret.fn = reflect.ValueOf(ret.readUint8Typex_V)
+	return ret
+}
+
+func (v *iterNative) readETUint8Typex_V(et *typex.EventTime, key *uint8, value *typex.V) bool {
+	elm, err := v.cur.Read()
+	if err != nil {
+		if err == io.EOF {
+			return false
+		}
+		panic(fmt.Sprintf("broken stream: %v", err))
+	}
+
+	*et = elm.Timestamp
+	*key = elm.Elm.Interface().(uint8)
+	*value = elm.Elm2.Interface().(typex.V)
+	return true
+}
+
+func iterMakerETUint8Typex_V(s ReStream) ReusableInput {
+	ret := &iterNative{s: s}
+	ret.fn = reflect.ValueOf(ret.readETUint8Typex_V)
+	return ret
+}
+
+func (v *iterNative) readUint8Typex_W(key *uint8, value *typex.W) bool {
+	elm, err := v.cur.Read()
+	if err != nil {
+		if err == io.EOF {
+			return false
+		}
+		panic(fmt.Sprintf("broken stream: %v", err))
+	}
+
+	*key = elm.Elm.Interface().(uint8)
+	*value = elm.Elm2.Interface().(typex.W)
+	return true
+}
+
+func iterMakerUint8Typex_W(s ReStream) ReusableInput {
+	ret := &iterNative{s: s}
+	ret.fn = reflect.ValueOf(ret.readUint8Typex_W)
+	return ret
+}
+
+func (v *iterNative) readETUint8Typex_W(et *typex.EventTime, key *uint8, value *typex.W) bool {
+	elm, err := v.cur.Read()
+	if err != nil {
+		if err == io.EOF {
+			return false
+		}
+		panic(fmt.Sprintf("broken stream: %v", err))
+	}
+
+	*et = elm.Timestamp
+	*key = elm.Elm.Interface().(uint8)
+	*value = elm.Elm2.Interface().(typex.W)
+	return true
+}
+
+func iterMakerETUint8Typex_W(s ReStream) ReusableInput {
+	ret := &iterNative{s: s}
+	ret.fn = reflect.ValueOf(ret.readETUint8Typex_W)
+	return ret
+}
+
+func (v *iterNative) readUint8Typex_X(key *uint8, value *typex.X) bool {
+	elm, err := v.cur.Read()
+	if err != nil {
+		if err == io.EOF {
+			return false
+		}
+		panic(fmt.Sprintf("broken stream: %v", err))
+	}
+
+	*key = elm.Elm.Interface().(uint8)
+	*value = elm.Elm2.Interface().(typex.X)
+	return true
+}
+
+func iterMakerUint8Typex_X(s ReStream) ReusableInput {
+	ret := &iterNative{s: s}
+	ret.fn = reflect.ValueOf(ret.readUint8Typex_X)
+	return ret
+}
+
+func (v *iterNative) readETUint8Typex_X(et *typex.EventTime, key *uint8, value *typex.X) bool {
+	elm, err := v.cur.Read()
+	if err != nil {
+		if err == io.EOF {
+			return false
+		}
+		panic(fmt.Sprintf("broken stream: %v", err))
+	}
+
+	*et = elm.Timestamp
+	*key = elm.Elm.Interface().(uint8)
+	*value = elm.Elm2.Interface().(typex.X)
+	return true
+}
+
+func iterMakerETUint8Typex_X(s ReStream) ReusableInput {
+	ret := &iterNative{s: s}
+	ret.fn = reflect.ValueOf(ret.readETUint8Typex_X)
+	return ret
+}
+
+func (v *iterNative) readUint8Typex_Y(key *uint8, value *typex.Y) bool {
+	elm, err := v.cur.Read()
+	if err != nil {
+		if err == io.EOF {
+			return false
+		}
+		panic(fmt.Sprintf("broken stream: %v", err))
+	}
+
+	*key = elm.Elm.Interface().(uint8)
+	*value = elm.Elm2.Interface().(typex.Y)
+	return true
+}
+
+func iterMakerUint8Typex_Y(s ReStream) ReusableInput {
+	ret := &iterNative{s: s}
+	ret.fn = reflect.ValueOf(ret.readUint8Typex_Y)
+	return ret
+}
+
+func (v *iterNative) readETUint8Typex_Y(et *typex.EventTime, key *uint8, value *typex.Y) bool {
+	elm, err := v.cur.Read()
+	if err != nil {
+		if err == io.EOF {
+			return false
+		}
+		panic(fmt.Sprintf("broken stream: %v", err))
+	}
+
+	*et = elm.Timestamp
+	*key = elm.Elm.Interface().(uint8)
+	*value = elm.Elm2.Interface().(typex.Y)
+	return true
+}
+
+func iterMakerETUint8Typex_Y(s ReStream) ReusableInput {
+	ret := &iterNative{s: s}
+	ret.fn = reflect.ValueOf(ret.readETUint8Typex_Y)
+	return ret
+}
+
+func (v *iterNative) readUint8Typex_Z(key *uint8, value *typex.Z) bool {
+	elm, err := v.cur.Read()
+	if err != nil {
+		if err == io.EOF {
+			return false
+		}
+		panic(fmt.Sprintf("broken stream: %v", err))
+	}
+
+	*key = elm.Elm.Interface().(uint8)
+	*value = elm.Elm2.Interface().(typex.Z)
+	return true
+}
+
+func iterMakerUint8Typex_Z(s ReStream) ReusableInput {
+	ret := &iterNative{s: s}
+	ret.fn = reflect.ValueOf(ret.readUint8Typex_Z)
+	return ret
+}
+
+func (v *iterNative) readETUint8Typex_Z(et *typex.EventTime, key *uint8, value *typex.Z) bool {
+	elm, err := v.cur.Read()
+	if err != nil {
+		if err == io.EOF {
+			return false
+		}
+		panic(fmt.Sprintf("broken stream: %v", err))
+	}
+
+	*et = elm.Timestamp
+	*key = elm.Elm.Interface().(uint8)
+	*value = elm.Elm2.Interface().(typex.Z)
+	return true
+}
+
+func iterMakerETUint8Typex_Z(s ReStream) ReusableInput {
+	ret := &iterNative{s: s}
+	ret.fn = reflect.ValueOf(ret.readETUint8Typex_Z)
+	return ret
+}
+
+func (v *iterNative) readUint16(val *uint16) bool {
+	elm, err := v.cur.Read()
+	if err != nil {
+		if err == io.EOF {
+			return false
+		}
+		panic(fmt.Sprintf("broken stream: %v", err))
+	}
+
+	*val = elm.Elm.Interface().(uint16)
+	return true
+}
+
+func iterMakerUint16(s ReStream) ReusableInput {
+	ret := &iterNative{s: s}
+	ret.fn = reflect.ValueOf(ret.readUint16)
+	return ret
+}
+
+func (v *iterNative) readETUint16(et *typex.EventTime, val *uint16) bool {
+	elm, err := v.cur.Read()
+	if err != nil {
+		if err == io.EOF {
+			return false
+		}
+		panic(fmt.Sprintf("broken stream: %v", err))
+	}
+
+	*et = elm.Timestamp
+	*val = elm.Elm.Interface().(uint16)
+	return true
+}
+
+func iterMakerETUint16(s ReStream) ReusableInput {
+	ret := &iterNative{s: s}
+	ret.fn = reflect.ValueOf(ret.readETUint16)
+	return ret
+}
+
+func (v *iterNative) readUint16ByteSlice(key *uint16, value *[]byte) bool {
+	elm, err := v.cur.Read()
+	if err != nil {
+		if err == io.EOF {
+			return false
+		}
+		panic(fmt.Sprintf("broken stream: %v", err))
+	}
+
+	*key = elm.Elm.Interface().(uint16)
+	*value = elm.Elm2.Interface().([]byte)
+	return true
+}
+
+func iterMakerUint16ByteSlice(s ReStream) ReusableInput {
+	ret := &iterNative{s: s}
+	ret.fn = reflect.ValueOf(ret.readUint16ByteSlice)
+	return ret
+}
+
+func (v *iterNative) readETUint16ByteSlice(et *typex.EventTime, key *uint16, value *[]byte) bool {
+	elm, err := v.cur.Read()
+	if err != nil {
+		if err == io.EOF {
+			return false
+		}
+		panic(fmt.Sprintf("broken stream: %v", err))
+	}
+
+	*et = elm.Timestamp
+	*key = elm.Elm.Interface().(uint16)
+	*value = elm.Elm2.Interface().([]byte)
+	return true
+}
+
+func iterMakerETUint16ByteSlice(s ReStream) ReusableInput {
+	ret := &iterNative{s: s}
+	ret.fn = reflect.ValueOf(ret.readETUint16ByteSlice)
+	return ret
+}
+
+func (v *iterNative) readUint16Bool(key *uint16, value *bool) bool {
+	elm, err := v.cur.Read()
+	if err != nil {
+		if err == io.EOF {
+			return false
+		}
+		panic(fmt.Sprintf("broken stream: %v", err))
+	}
+
+	*key = elm.Elm.Interface().(uint16)
+	*value = elm.Elm2.Interface().(bool)
+	return true
+}
+
+func iterMakerUint16Bool(s ReStream) ReusableInput {
+	ret := &iterNative{s: s}
+	ret.fn = reflect.ValueOf(ret.readUint16Bool)
+	return ret
+}
+
+func (v *iterNative) readETUint16Bool(et *typex.EventTime, key *uint16, value *bool) bool {
+	elm, err := v.cur.Read()
+	if err != nil {
+		if err == io.EOF {
+			return false
+		}
+		panic(fmt.Sprintf("broken stream: %v", err))
+	}
+
+	*et = elm.Timestamp
+	*key = elm.Elm.Interface().(uint16)
+	*value = elm.Elm2.Interface().(bool)
+	return true
+}
+
+func iterMakerETUint16Bool(s ReStream) ReusableInput {
+	ret := &iterNative{s: s}
+	ret.fn = reflect.ValueOf(ret.readETUint16Bool)
+	return ret
+}
+
+func (v *iterNative) readUint16String(key *uint16, value *string) bool {
+	elm, err := v.cur.Read()
+	if err != nil {
+		if err == io.EOF {
+			return false
+		}
+		panic(fmt.Sprintf("broken stream: %v", err))
+	}
+
+	*key = elm.Elm.Interface().(uint16)
+	*value = elm.Elm2.Interface().(string)
+	return true
+}
+
+func iterMakerUint16String(s ReStream) ReusableInput {
+	ret := &iterNative{s: s}
+	ret.fn = reflect.ValueOf(ret.readUint16String)
+	return ret
+}
+
+func (v *iterNative) readETUint16String(et *typex.EventTime, key *uint16, value *string) bool {
+	elm, err := v.cur.Read()
+	if err != nil {
+		if err == io.EOF {
+			return false
+		}
+		panic(fmt.Sprintf("broken stream: %v", err))
+	}
+
+	*et = elm.Timestamp
+	*key = elm.Elm.Interface().(uint16)
+	*value = elm.Elm2.Interface().(string)
+	return true
+}
+
+func iterMakerETUint16String(s ReStream) ReusableInput {
+	ret := &iterNative{s: s}
+	ret.fn = reflect.ValueOf(ret.readETUint16String)
+	return ret
+}
+
+func (v *iterNative) readUint16Int(key *uint16, value *int) bool {
+	elm, err := v.cur.Read()
+	if err != nil {
+		if err == io.EOF {
+			return false
+		}
+		panic(fmt.Sprintf("broken stream: %v", err))
+	}
+
+	*key = elm.Elm.Interface().(uint16)
+	*value = elm.Elm2.Interface().(int)
+	return true
+}
+
+func iterMakerUint16Int(s ReStream) ReusableInput {
+	ret := &iterNative{s: s}
+	ret.fn = reflect.ValueOf(ret.readUint16Int)
+	return ret
+}
+
+func (v *iterNative) readETUint16Int(et *typex.EventTime, key *uint16, value *int) bool {
+	elm, err := v.cur.Read()
+	if err != nil {
+		if err == io.EOF {
+			return false
+		}
+		panic(fmt.Sprintf("broken stream: %v", err))
+	}
+
+	*et = elm.Timestamp
+	*key = elm.Elm.Interface().(uint16)
+	*value = elm.Elm2.Interface().(int)
+	return true
+}
+
+func iterMakerETUint16Int(s ReStream) ReusableInput {
+	ret := &iterNative{s: s}
+	ret.fn = reflect.ValueOf(ret.readETUint16Int)
+	return ret
+}
+
+func (v *iterNative) readUint16Int8(key *uint16, value *int8) bool {
+	elm, err := v.cur.Read()
+	if err != nil {
+		if err == io.EOF {
+			return false
+		}
+		panic(fmt.Sprintf("broken stream: %v", err))
+	}
+
+	*key = elm.Elm.Interface().(uint16)
+	*value = elm.Elm2.Interface().(int8)
+	return true
+}
+
+func iterMakerUint16Int8(s ReStream) ReusableInput {
+	ret := &iterNative{s: s}
+	ret.fn = reflect.ValueOf(ret.readUint16Int8)
+	return ret
+}
+
+func (v *iterNative) readETUint16Int8(et *typex.EventTime, key *uint16, value *int8) bool {
+	elm, err := v.cur.Read()
+	if err != nil {
+		if err == io.EOF {
+			return false
+		}
+		panic(fmt.Sprintf("broken stream: %v", err))
+	}
+
+	*et = elm.Timestamp
+	*key = elm.Elm.Interface().(uint16)
+	*value = elm.Elm2.Interface().(int8)
+	return true
+}
+
+func iterMakerETUint16Int8(s ReStream) ReusableInput {
+	ret := &iterNative{s: s}
+	ret.fn = reflect.ValueOf(ret.readETUint16Int8)
+	return ret
+}
+
+func (v *iterNative) readUint16Int16(key *uint16, value *int16) bool {
+	elm, err := v.cur.Read()
+	if err != nil {
+		if err == io.EOF {
+			return false
+		}
+		panic(fmt.Sprintf("broken stream: %v", err))
+	}
+
+	*key = elm.Elm.Interface().(uint16)
+	*value = elm.Elm2.Interface().(int16)
+	return true
+}
+
+func iterMakerUint16Int16(s ReStream) ReusableInput {
+	ret := &iterNative{s: s}
+	ret.fn = reflect.ValueOf(ret.readUint16Int16)
+	return ret
+}
+
+func (v *iterNative) readETUint16Int16(et *typex.EventTime, key *uint16, value *int16) bool {
+	elm, err := v.cur.Read()
+	if err != nil {
+		if err == io.EOF {
+			return false
+		}
+		panic(fmt.Sprintf("broken stream: %v", err))
+	}
+
+	*et = elm.Timestamp
+	*key = elm.Elm.Interface().(uint16)
+	*value = elm.Elm2.Interface().(int16)
+	return true
+}
+
+func iterMakerETUint16Int16(s ReStream) ReusableInput {
+	ret := &iterNative{s: s}
+	ret.fn = reflect.ValueOf(ret.readETUint16Int16)
+	return ret
+}
+
+func (v *iterNative) readUint16Int32(key *uint16, value *int32) bool {
+	elm, err := v.cur.Read()
+	if err != nil {
+		if err == io.EOF {
+			return false
+		}
+		panic(fmt.Sprintf("broken stream: %v", err))
+	}
+
+	*key = elm.Elm.Interface().(uint16)
+	*value = elm.Elm2.Interface().(int32)
+	return true
+}
+
+func iterMakerUint16Int32(s ReStream) ReusableInput {
+	ret := &iterNative{s: s}
+	ret.fn = reflect.ValueOf(ret.readUint16Int32)
+	return ret
+}
+
+func (v *iterNative) readETUint16Int32(et *typex.EventTime, key *uint16, value *int32) bool {
+	elm, err := v.cur.Read()
+	if err != nil {
+		if err == io.EOF {
+			return false
+		}
+		panic(fmt.Sprintf("broken stream: %v", err))
+	}
+
+	*et = elm.Timestamp
+	*key = elm.Elm.Interface().(uint16)
+	*value = elm.Elm2.Interface().(int32)
+	return true
+}
+
+func iterMakerETUint16Int32(s ReStream) ReusableInput {
+	ret := &iterNative{s: s}
+	ret.fn = reflect.ValueOf(ret.readETUint16Int32)
+	return ret
+}
+
+func (v *iterNative) readUint16Int64(key *uint16, value *int64) bool {
+	elm, err := v.cur.Read()
+	if err != nil {
+		if err == io.EOF {
+			return false
+		}
+		panic(fmt.Sprintf("broken stream: %v", err))
+	}
+
+	*key = elm.Elm.Interface().(uint16)
+	*value = elm.Elm2.Interface().(int64)
+	return true
+}
+
+func iterMakerUint16Int64(s ReStream) ReusableInput {
+	ret := &iterNative{s: s}
+	ret.fn = reflect.ValueOf(ret.readUint16Int64)
+	return ret
+}
+
+func (v *iterNative) readETUint16Int64(et *typex.EventTime, key *uint16, value *int64) bool {
+	elm, err := v.cur.Read()
+	if err != nil {
+		if err == io.EOF {
+			return false
+		}
+		panic(fmt.Sprintf("broken stream: %v", err))
+	}
+
+	*et = elm.Timestamp
+	*key = elm.Elm.Interface().(uint16)
+	*value = elm.Elm2.Interface().(int64)
+	return true
+}
+
+func iterMakerETUint16Int64(s ReStream) ReusableInput {
+	ret := &iterNative{s: s}
+	ret.fn = reflect.ValueOf(ret.readETUint16Int64)
+	return ret
+}
+
+func (v *iterNative) readUint16Uint(key *uint16, value *uint) bool {
+	elm, err := v.cur.Read()
+	if err != nil {
+		if err == io.EOF {
+			return false
+		}
+		panic(fmt.Sprintf("broken stream: %v", err))
+	}
+
+	*key = elm.Elm.Interface().(uint16)
+	*value = elm.Elm2.Interface().(uint)
+	return true
+}
+
+func iterMakerUint16Uint(s ReStream) ReusableInput {
+	ret := &iterNative{s: s}
+	ret.fn = reflect.ValueOf(ret.readUint16Uint)
+	return ret
+}
+
+func (v *iterNative) readETUint16Uint(et *typex.EventTime, key *uint16, value *uint) bool {
+	elm, err := v.cur.Read()
+	if err != nil {
+		if err == io.EOF {
+			return false
+		}
+		panic(fmt.Sprintf("broken stream: %v", err))
+	}
+
+	*et = elm.Timestamp
+	*key = elm.Elm.Interface().(uint16)
+	*value = elm.Elm2.Interface().(uint)
+	return true
+}
+
+func iterMakerETUint16Uint(s ReStream) ReusableInput {
+	ret := &iterNative{s: s}
+	ret.fn = reflect.ValueOf(ret.readETUint16Uint)
+	return ret
+}
+
+func (v *iterNative) readUint16Uint8(key *uint16, value *uint8) bool {
+	elm, err := v.cur.Read()
+	if err != nil {
+		if err == io.EOF {
+			return false
+		}
+		panic(fmt.Sprintf("broken stream: %v", err))
+	}
+
+	*key = elm.Elm.Interface().(uint16)
+	*value = elm.Elm2.Interface().(uint8)
+	return true
+}
+
+func iterMakerUint16Uint8(s ReStream) ReusableInput {
+	ret := &iterNative{s: s}
+	ret.fn = reflect.ValueOf(ret.readUint16Uint8)
+	return ret
+}
+
+func (v *iterNative) readETUint16Uint8(et *typex.EventTime, key *uint16, value *uint8) bool {
+	elm, err := v.cur.Read()
+	if err != nil {
+		if err == io.EOF {
+			return false
+		}
+		panic(fmt.Sprintf("broken stream: %v", err))
+	}
+
+	*et = elm.Timestamp
+	*key = elm.Elm.Interface().(uint16)
+	*value = elm.Elm2.Interface().(uint8)
+	return true
+}
+
+func iterMakerETUint16Uint8(s ReStream) ReusableInput {
+	ret := &iterNative{s: s}
+	ret.fn = reflect.ValueOf(ret.readETUint16Uint8)
+	return ret
+}
+
+func (v *iterNative) readUint16Uint16(key *uint16, value *uint16) bool {
+	elm, err := v.cur.Read()
+	if err != nil {
+		if err == io.EOF {
+			return false
+		}
+		panic(fmt.Sprintf("broken stream: %v", err))
+	}
+
+	*key = elm.Elm.Interface().(uint16)
+	*value = elm.Elm2.Interface().(uint16)
+	return true
+}
+
+func iterMakerUint16Uint16(s ReStream) ReusableInput {
+	ret := &iterNative{s: s}
+	ret.fn = reflect.ValueOf(ret.readUint16Uint16)
+	return ret
+}
+
+func (v *iterNative) readETUint16Uint16(et *typex.EventTime, key *uint16, value *uint16) bool {
+	elm, err := v.cur.Read()
+	if err != nil {
+		if err == io.EOF {
+			return false
+		}
+		panic(fmt.Sprintf("broken stream: %v", err))
+	}
+
+	*et = elm.Timestamp
+	*key = elm.Elm.Interface().(uint16)
+	*value = elm.Elm2.Interface().(uint16)
+	return true
+}
+
+func iterMakerETUint16Uint16(s ReStream) ReusableInput {
+	ret := &iterNative{s: s}
+	ret.fn = reflect.ValueOf(ret.readETUint16Uint16)
+	return ret
+}
+
+func (v *iterNative) readUint16Uint32(key *uint16, value *uint32) bool {
+	elm, err := v.cur.Read()
+	if err != nil {
+		if err == io.EOF {
+			return false
+		}
+		panic(fmt.Sprintf("broken stream: %v", err))
+	}
+
+	*key = elm.Elm.Interface().(uint16)
+	*value = elm.Elm2.Interface().(uint32)
+	return true
+}
+
+func iterMakerUint16Uint32(s ReStream) ReusableInput {
+	ret := &iterNative{s: s}
+	ret.fn = reflect.ValueOf(ret.readUint16Uint32)
+	return ret
+}
+
+func (v *iterNative) readETUint16Uint32(et *typex.EventTime, key *uint16, value *uint32) bool {
+	elm, err := v.cur.Read()
+	if err != nil {
+		if err == io.EOF {
+			return false
+		}
+		panic(fmt.Sprintf("broken stream: %v", err))
+	}
+
+	*et = elm.Timestamp
+	*key = elm.Elm.Interface().(uint16)
+	*value = elm.Elm2.Interface().(uint32)
+	return true
+}
+
+func iterMakerETUint16Uint32(s ReStream) ReusableInput {
+	ret := &iterNative{s: s}
+	ret.fn = reflect.ValueOf(ret.readETUint16Uint32)
+	return ret
+}
+
+func (v *iterNative) readUint16Uint64(key *uint16, value *uint64) bool {
+	elm, err := v.cur.Read()
+	if err != nil {
+		if err == io.EOF {
+			return false
+		}
+		panic(fmt.Sprintf("broken stream: %v", err))
+	}
+
+	*key = elm.Elm.Interface().(uint16)
+	*value = elm.Elm2.Interface().(uint64)
+	return true
+}
+
+func iterMakerUint16Uint64(s ReStream) ReusableInput {
+	ret := &iterNative{s: s}
+	ret.fn = reflect.ValueOf(ret.readUint16Uint64)
+	return ret
+}
+
+func (v *iterNative) readETUint16Uint64(et *typex.EventTime, key *uint16, value *uint64) bool {
+	elm, err := v.cur.Read()
+	if err != nil {
+		if err == io.EOF {
+			return false
+		}
+		panic(fmt.Sprintf("broken stream: %v", err))
+	}
+
+	*et = elm.Timestamp
+	*key = elm.Elm.Interface().(uint16)
+	*value = elm.Elm2.Interface().(uint64)
+	return true
+}
+
+func iterMakerETUint16Uint64(s ReStream) ReusableInput {
+	ret := &iterNative{s: s}
+	ret.fn = reflect.ValueOf(ret.readETUint16Uint64)
+	return ret
+}
+
+func (v *iterNative) readUint16Float32(key *uint16, value *float32) bool {
+	elm, err := v.cur.Read()
+	if err != nil {
+		if err == io.EOF {
+			return false
+		}
+		panic(fmt.Sprintf("broken stream: %v", err))
+	}
+
+	*key = elm.Elm.Interface().(uint16)
+	*value = elm.Elm2.Interface().(float32)
+	return true
+}
+
+func iterMakerUint16Float32(s ReStream) ReusableInput {
+	ret := &iterNative{s: s}
+	ret.fn = reflect.ValueOf(ret.readUint16Float32)
+	return ret
+}
+
+func (v *iterNative) readETUint16Float32(et *typex.EventTime, key *uint16, value *float32) bool {
+	elm, err := v.cur.Read()
+	if err != nil {
+		if err == io.EOF {
+			return false
+		}
+		panic(fmt.Sprintf("broken stream: %v", err))
+	}
+
+	*et = elm.Timestamp
+	*key = elm.Elm.Interface().(uint16)
+	*value = elm.Elm2.Interface().(float32)
+	return true
+}
+
+func iterMakerETUint16Float32(s ReStream) ReusableInput {
+	ret := &iterNative{s: s}
+	ret.fn = reflect.ValueOf(ret.readETUint16Float32)
+	return ret
+}
+
+func (v *iterNative) readUint16Float64(key *uint16, value *float64) bool {
+	elm, err := v.cur.Read()
+	if err != nil {
+		if err == io.EOF {
+			return false
+		}
+		panic(fmt.Sprintf("broken stream: %v", err))
+	}
+
+	*key = elm.Elm.Interface().(uint16)
+	*value = elm.Elm2.Interface().(float64)
+	return true
+}
+
+func iterMakerUint16Float64(s ReStream) ReusableInput {
+	ret := &iterNative{s: s}
+	ret.fn = reflect.ValueOf(ret.readUint16Float64)
+	return ret
+}
+
+func (v *iterNative) readETUint16Float64(et *typex.EventTime, key *uint16, value *float64) bool {
+	elm, err := v.cur.Read()
+	if err != nil {
+		if err == io.EOF {
+			return false
+		}
+		panic(fmt.Sprintf("broken stream: %v", err))
+	}
+
+	*et = elm.Timestamp
+	*key = elm.Elm.Interface().(uint16)
+	*value = elm.Elm2.Interface().(float64)
+	return true
+}
+
+func iterMakerETUint16Float64(s ReStream) ReusableInput {
+	ret := &iterNative{s: s}
+	ret.fn = reflect.ValueOf(ret.readETUint16Float64)
+	return ret
+}
+
+func (v *iterNative) readUint16Typex_T(key *uint16, value *typex.T) bool {
+	elm, err := v.cur.Read()
+	if err != nil {
+		if err == io.EOF {
+			return false
+		}
+		panic(fmt.Sprintf("broken stream: %v", err))
+	}
+
+	*key = elm.Elm.Interface().(uint16)
+	*value = elm.Elm2.Interface().(typex.T)
+	return true
+}
+
+func iterMakerUint16Typex_T(s ReStream) ReusableInput {
+	ret := &iterNative{s: s}
+	ret.fn = reflect.ValueOf(ret.readUint16Typex_T)
+	return ret
+}
+
+func (v *iterNative) readETUint16Typex_T(et *typex.EventTime, key *uint16, value *typex.T) bool {
+	elm, err := v.cur.Read()
+	if err != nil {
+		if err == io.EOF {
+			return false
+		}
+		panic(fmt.Sprintf("broken stream: %v", err))
+	}
+
+	*et = elm.Timestamp
+	*key = elm.Elm.Interface().(uint16)
+	*value = elm.Elm2.Interface().(typex.T)
+	return true
+}
+
+func iterMakerETUint16Typex_T(s ReStream) ReusableInput {
+	ret := &iterNative{s: s}
+	ret.fn = reflect.ValueOf(ret.readETUint16Typex_T)
+	return ret
+}
+
+func (v *iterNative) readUint16Typex_U(key *uint16, value *typex.U) bool {
+	elm, err := v.cur.Read()
+	if err != nil {
+		if err == io.EOF {
+			return false
+		}
+		panic(fmt.Sprintf("broken stream: %v", err))
+	}
+
+	*key = elm.Elm.Interface().(uint16)
+	*value = elm.Elm2.Interface().(typex.U)
+	return true
+}
+
+func iterMakerUint16Typex_U(s ReStream) ReusableInput {
+	ret := &iterNative{s: s}
+	ret.fn = reflect.ValueOf(ret.readUint16Typex_U)
+	return ret
+}
+
+func (v *iterNative) readETUint16Typex_U(et *typex.EventTime, key *uint16, value *typex.U) bool {
+	elm, err := v.cur.Read()
+	if err != nil {
+		if err == io.EOF {
+			return false
+		}
+		panic(fmt.Sprintf("broken stream: %v", err))
+	}
+
+	*et = elm.Timestamp
+	*key = elm.Elm.Interface().(uint16)
+	*value = elm.Elm2.Interface().(typex.U)
+	return true
+}
+
+func iterMakerETUint16Typex_U(s ReStream) ReusableInput {
+	ret := &iterNative{s: s}
+	ret.fn = reflect.ValueOf(ret.readETUint16Typex_U)
+	return ret
+}
+
+func (v *iterNative) readUint16Typex_V(key *uint16, value *typex.V) bool {
+	elm, err := v.cur.Read()
+	if err != nil {
+		if err == io.EOF {
+			return false
+		}
+		panic(fmt.Sprintf("broken stream: %v", err))
+	}
+
+	*key = elm.Elm.Interface().(uint16)
+	*value = elm.Elm2.Interface().(typex.V)
+	return true
+}
+
+func iterMakerUint16Typex_V(s ReStream) ReusableInput {
+	ret := &iterNative{s: s}
+	ret.fn = reflect.ValueOf(ret.readUint16Typex_V)
+	return ret
+}
+
+func (v *iterNative) readETUint16Typex_V(et *typex.EventTime, key *uint16, value *typex.V) bool {
+	elm, err := v.cur.Read()
+	if err != nil {
+		if err == io.EOF {
+			return false
+		}
+		panic(fmt.Sprintf("broken stream: %v", err))
+	}
+
+	*et = elm.Timestamp
+	*key = elm.Elm.Interface().(uint16)
+	*value = elm.Elm2.Interface().(typex.V)
+	return true
+}
+
+func iterMakerETUint16Typex_V(s ReStream) ReusableInput {
+	ret := &iterNative{s: s}
+	ret.fn = reflect.ValueOf(ret.readETUint16Typex_V)
+	return ret
+}
+
+func (v *iterNative) readUint16Typex_W(key *uint16, value *typex.W) bool {
+	elm, err := v.cur.Read()
+	if err != nil {
+		if err == io.EOF {
+			return false
+		}
+		panic(fmt.Sprintf("broken stream: %v", err))
+	}
+
+	*key = elm.Elm.Interface().(uint16)
+	*value = elm.Elm2.Interface().(typex.W)
+	return true
+}
+
+func iterMakerUint16Typex_W(s ReStream) ReusableInput {
+	ret := &iterNative{s: s}
+	ret.fn = reflect.ValueOf(ret.readUint16Typex_W)
+	return ret
+}
+
+func (v *iterNative) readETUint16Typex_W(et *typex.EventTime, key *uint16, value *typex.W) bool {
+	elm, err := v.cur.Read()
+	if err != nil {
+		if err == io.EOF {
+			return false
+		}
+		panic(fmt.Sprintf("broken stream: %v", err))
+	}
+
+	*et = elm.Timestamp
+	*key = elm.Elm.Interface().(uint16)
+	*value = elm.Elm2.Interface().(typex.W)
+	return true
+}
+
+func iterMakerETUint16Typex_W(s ReStream) ReusableInput {
+	ret := &iterNative{s: s}
+	ret.fn = reflect.ValueOf(ret.readETUint16Typex_W)
+	return ret
+}
+
+func (v *iterNative) readUint16Typex_X(key *uint16, value *typex.X) bool {
+	elm, err := v.cur.Read()
+	if err != nil {
+		if err == io.EOF {
+			return false
+		}
+		panic(fmt.Sprintf("broken stream: %v", err))
+	}
+
+	*key = elm.Elm.Interface().(uint16)
+	*value = elm.Elm2.Interface().(typex.X)
+	return true
+}
+
+func iterMakerUint16Typex_X(s ReStream) ReusableInput {
+	ret := &iterNative{s: s}
+	ret.fn = reflect.ValueOf(ret.readUint16Typex_X)
+	return ret
+}
+
+func (v *iterNative) readETUint16Typex_X(et *typex.EventTime, key *uint16, value *typex.X) bool {
+	elm, err := v.cur.Read()
+	if err != nil {
+		if err == io.EOF {
+			return false
+		}
+		panic(fmt.Sprintf("broken stream: %v", err))
+	}
+
+	*et = elm.Timestamp
+	*key = elm.Elm.Interface().(uint16)
+	*value = elm.Elm2.Interface().(typex.X)
+	return true
+}
+
+func iterMakerETUint16Typex_X(s ReStream) ReusableInput {
+	ret := &iterNative{s: s}
+	ret.fn = reflect.ValueOf(ret.readETUint16Typex_X)
+	return ret
+}
+
+func (v *iterNative) readUint16Typex_Y(key *uint16, value *typex.Y) bool {
+	elm, err := v.cur.Read()
+	if err != nil {
+		if err == io.EOF {
+			return false
+		}
+		panic(fmt.Sprintf("broken stream: %v", err))
+	}
+
+	*key = elm.Elm.Interface().(uint16)
+	*value = elm.Elm2.Interface().(typex.Y)
+	return true
+}
+
+func iterMakerUint16Typex_Y(s ReStream) ReusableInput {
+	ret := &iterNative{s: s}
+	ret.fn = reflect.ValueOf(ret.readUint16Typex_Y)
+	return ret
+}
+
+func (v *iterNative) readETUint16Typex_Y(et *typex.EventTime, key *uint16, value *typex.Y) bool {
+	elm, err := v.cur.Read()
+	if err != nil {
+		if err == io.EOF {
+			return false
+		}
+		panic(fmt.Sprintf("broken stream: %v", err))
+	}
+
+	*et = elm.Timestamp
+	*key = elm.Elm.Interface().(uint16)
+	*value = elm.Elm2.Interface().(typex.Y)
+	return true
+}
+
+func iterMakerETUint16Typex_Y(s ReStream) ReusableInput {
+	ret := &iterNative{s: s}
+	ret.fn = reflect.ValueOf(ret.readETUint16Typex_Y)
+	return ret
+}
+
+func (v *iterNative) readUint16Typex_Z(key *uint16, value *typex.Z) bool {
+	elm, err := v.cur.Read()
+	if err != nil {
+		if err == io.EOF {
+			return false
+		}
+		panic(fmt.Sprintf("broken stream: %v", err))
+	}
+
+	*key = elm.Elm.Interface().(uint16)
+	*value = elm.Elm2.Interface().(typex.Z)
+	return true
+}
+
+func iterMakerUint16Typex_Z(s ReStream) ReusableInput {
+	ret := &iterNative{s: s}
+	ret.fn = reflect.ValueOf(ret.readUint16Typex_Z)
+	return ret
+}
+
+func (v *iterNative) readETUint16Typex_Z(et *typex.EventTime, key *uint16, value *typex.Z) bool {
+	elm, err := v.cur.Read()
+	if err != nil {
+		if err == io.EOF {
+			return false
+		}
+		panic(fmt.Sprintf("broken stream: %v", err))
+	}
+
+	*et = elm.Timestamp
+	*key = elm.Elm.Interface().(uint16)
+	*value = elm.Elm2.Interface().(typex.Z)
+	return true
+}
+
+func iterMakerETUint16Typex_Z(s ReStream) ReusableInput {
+	ret := &iterNative{s: s}
+	ret.fn = reflect.ValueOf(ret.readETUint16Typex_Z)
+	return ret
+}
+
+func (v *iterNative) readUint32(val *uint32) bool {
+	elm, err := v.cur.Read()
+	if err != nil {
+		if err == io.EOF {
+			return false
+		}
+		panic(fmt.Sprintf("broken stream: %v", err))
+	}
+
+	*val = elm.Elm.Interface().(uint32)
+	return true
+}
+
+func iterMakerUint32(s ReStream) ReusableInput {
+	ret := &iterNative{s: s}
+	ret.fn = reflect.ValueOf(ret.readUint32)
+	return ret
+}
+
+func (v *iterNative) readETUint32(et *typex.EventTime, val *uint32) bool {
+	elm, err := v.cur.Read()
+	if err != nil {
+		if err == io.EOF {
+			return false
+		}
+		panic(fmt.Sprintf("broken stream: %v", err))
+	}
+
+	*et = elm.Timestamp
+	*val = elm.Elm.Interface().(uint32)
+	return true
+}
+
+func iterMakerETUint32(s ReStream) ReusableInput {
+	ret := &iterNative{s: s}
+	ret.fn = reflect.ValueOf(ret.readETUint32)
+	return ret
+}
+
+func (v *iterNative) readUint32ByteSlice(key *uint32, value *[]byte) bool {
+	elm, err := v.cur.Read()
+	if err != nil {
+		if err == io.EOF {
+			return false
+		}
+		panic(fmt.Sprintf("broken stream: %v", err))
+	}
+
+	*key = elm.Elm.Interface().(uint32)
+	*value = elm.Elm2.Interface().([]byte)
+	return true
+}
+
+func iterMakerUint32ByteSlice(s ReStream) ReusableInput {
+	ret := &iterNative{s: s}
+	ret.fn = reflect.ValueOf(ret.readUint32ByteSlice)
+	return ret
+}
+
+func (v *iterNative) readETUint32ByteSlice(et *typex.EventTime, key *uint32, value *[]byte) bool {
+	elm, err := v.cur.Read()
+	if err != nil {
+		if err == io.EOF {
+			return false
+		}
+		panic(fmt.Sprintf("broken stream: %v", err))
+	}
+
+	*et = elm.Timestamp
+	*key = elm.Elm.Interface().(uint32)
+	*value = elm.Elm2.Interface().([]byte)
+	return true
+}
+
+func iterMakerETUint32ByteSlice(s ReStream) ReusableInput {
+	ret := &iterNative{s: s}
+	ret.fn = reflect.ValueOf(ret.readETUint32ByteSlice)
+	return ret
+}
+
+func (v *iterNative) readUint32Bool(key *uint32, value *bool) bool {
+	elm, err := v.cur.Read()
+	if err != nil {
+		if err == io.EOF {
+			return false
+		}
+		panic(fmt.Sprintf("broken stream: %v", err))
+	}
+
+	*key = elm.Elm.Interface().(uint32)
+	*value = elm.Elm2.Interface().(bool)
+	return true
+}
+
+func iterMakerUint32Bool(s ReStream) ReusableInput {
+	ret := &iterNative{s: s}
+	ret.fn = reflect.ValueOf(ret.readUint32Bool)
+	return ret
+}
+
+func (v *iterNative) readETUint32Bool(et *typex.EventTime, key *uint32, value *bool) bool {
+	elm, err := v.cur.Read()
+	if err != nil {
+		if err == io.EOF {
+			return false
+		}
+		panic(fmt.Sprintf("broken stream: %v", err))
+	}
+
+	*et = elm.Timestamp
+	*key = elm.Elm.Interface().(uint32)
+	*value = elm.Elm2.Interface().(bool)
+	return true
+}
+
+func iterMakerETUint32Bool(s ReStream) ReusableInput {
+	ret := &iterNative{s: s}
+	ret.fn = reflect.ValueOf(ret.readETUint32Bool)
+	return ret
+}
+
+func (v *iterNative) readUint32String(key *uint32, value *string) bool {
+	elm, err := v.cur.Read()
+	if err != nil {
+		if err == io.EOF {
+			return false
+		}
+		panic(fmt.Sprintf("broken stream: %v", err))
+	}
+
+	*key = elm.Elm.Interface().(uint32)
+	*value = elm.Elm2.Interface().(string)
+	return true
+}
+
+func iterMakerUint32String(s ReStream) ReusableInput {
+	ret := &iterNative{s: s}
+	ret.fn = reflect.ValueOf(ret.readUint32String)
+	return ret
+}
+
+func (v *iterNative) readETUint32String(et *typex.EventTime, key *uint32, value *string) bool {
+	elm, err := v.cur.Read()
+	if err != nil {
+		if err == io.EOF {
+			return false
+		}
+		panic(fmt.Sprintf("broken stream: %v", err))
+	}
+
+	*et = elm.Timestamp
+	*key = elm.Elm.Interface().(uint32)
+	*value = elm.Elm2.Interface().(string)
+	return true
+}
+
+func iterMakerETUint32String(s ReStream) ReusableInput {
+	ret := &iterNative{s: s}
+	ret.fn = reflect.ValueOf(ret.readETUint32String)
+	return ret
+}
+
+func (v *iterNative) readUint32Int(key *uint32, value *int) bool {
+	elm, err := v.cur.Read()
+	if err != nil {
+		if err == io.EOF {
+			return false
+		}
+		panic(fmt.Sprintf("broken stream: %v", err))
+	}
+
+	*key = elm.Elm.Interface().(uint32)
+	*value = elm.Elm2.Interface().(int)
+	return true
+}
+
+func iterMakerUint32Int(s ReStream) ReusableInput {
+	ret := &iterNative{s: s}
+	ret.fn = reflect.ValueOf(ret.readUint32Int)
+	return ret
+}
+
+func (v *iterNative) readETUint32Int(et *typex.EventTime, key *uint32, value *int) bool {
+	elm, err := v.cur.Read()
+	if err != nil {
+		if err == io.EOF {
+			return false
+		}
+		panic(fmt.Sprintf("broken stream: %v", err))
+	}
+
+	*et = elm.Timestamp
+	*key = elm.Elm.Interface().(uint32)
+	*value = elm.Elm2.Interface().(int)
+	return true
+}
+
+func iterMakerETUint32Int(s ReStream) ReusableInput {
+	ret := &iterNative{s: s}
+	ret.fn = reflect.ValueOf(ret.readETUint32Int)
+	return ret
+}
+
+func (v *iterNative) readUint32Int8(key *uint32, value *int8) bool {
+	elm, err := v.cur.Read()
+	if err != nil {
+		if err == io.EOF {
+			return false
+		}
+		panic(fmt.Sprintf("broken stream: %v", err))
+	}
+
+	*key = elm.Elm.Interface().(uint32)
+	*value = elm.Elm2.Interface().(int8)
+	return true
+}
+
+func iterMakerUint32Int8(s ReStream) ReusableInput {
+	ret := &iterNative{s: s}
+	ret.fn = reflect.ValueOf(ret.readUint32Int8)
+	return ret
+}
+
+func (v *iterNative) readETUint32Int8(et *typex.EventTime, key *uint32, value *int8) bool {
+	elm, err := v.cur.Read()
+	if err != nil {
+		if err == io.EOF {
+			return false
+		}
+		panic(fmt.Sprintf("broken stream: %v", err))
+	}
+
+	*et = elm.Timestamp
+	*key = elm.Elm.Interface().(uint32)
+	*value = elm.Elm2.Interface().(int8)
+	return true
+}
+
+func iterMakerETUint32Int8(s ReStream) ReusableInput {
+	ret := &iterNative{s: s}
+	ret.fn = reflect.ValueOf(ret.readETUint32Int8)
+	return ret
+}
+
+func (v *iterNative) readUint32Int16(key *uint32, value *int16) bool {
+	elm, err := v.cur.Read()
+	if err != nil {
+		if err == io.EOF {
+			return false
+		}
+		panic(fmt.Sprintf("broken stream: %v", err))
+	}
+
+	*key = elm.Elm.Interface().(uint32)
+	*value = elm.Elm2.Interface().(int16)
+	return true
+}
+
+func iterMakerUint32Int16(s ReStream) ReusableInput {
+	ret := &iterNative{s: s}
+	ret.fn = reflect.ValueOf(ret.readUint32Int16)
+	return ret
+}
+
+func (v *iterNative) readETUint32Int16(et *typex.EventTime, key *uint32, value *int16) bool {
+	elm, err := v.cur.Read()
+	if err != nil {
+		if err == io.EOF {
+			return false
+		}
+		panic(fmt.Sprintf("broken stream: %v", err))
+	}
+
+	*et = elm.Timestamp
+	*key = elm.Elm.Interface().(uint32)
+	*value = elm.Elm2.Interface().(int16)
+	return true
+}
+
+func iterMakerETUint32Int16(s ReStream) ReusableInput {
+	ret := &iterNative{s: s}
+	ret.fn = reflect.ValueOf(ret.readETUint32Int16)
+	return ret
+}
+
+func (v *iterNative) readUint32Int32(key *uint32, value *int32) bool {
+	elm, err := v.cur.Read()
+	if err != nil {
+		if err == io.EOF {
+			return false
+		}
+		panic(fmt.Sprintf("broken stream: %v", err))
+	}
+
+	*key = elm.Elm.Interface().(uint32)
+	*value = elm.Elm2.Interface().(int32)
+	return true
+}
+
+func iterMakerUint32Int32(s ReStream) ReusableInput {
+	ret := &iterNative{s: s}
+	ret.fn = reflect.ValueOf(ret.readUint32Int32)
+	return ret
+}
+
+func (v *iterNative) readETUint32Int32(et *typex.EventTime, key *uint32, value *int32) bool {
+	elm, err := v.cur.Read()
+	if err != nil {
+		if err == io.EOF {
+			return false
+		}
+		panic(fmt.Sprintf("broken stream: %v", err))
+	}
+
+	*et = elm.Timestamp
+	*key = elm.Elm.Interface().(uint32)
+	*value = elm.Elm2.Interface().(int32)
+	return true
+}
+
+func iterMakerETUint32Int32(s ReStream) ReusableInput {
+	ret := &iterNative{s: s}
+	ret.fn = reflect.ValueOf(ret.readETUint32Int32)
+	return ret
+}
+
+func (v *iterNative) readUint32Int64(key *uint32, value *int64) bool {
+	elm, err := v.cur.Read()
+	if err != nil {
+		if err == io.EOF {
+			return false
+		}
+		panic(fmt.Sprintf("broken stream: %v", err))
+	}
+
+	*key = elm.Elm.Interface().(uint32)
+	*value = elm.Elm2.Interface().(int64)
+	return true
+}
+
+func iterMakerUint32Int64(s ReStream) ReusableInput {
+	ret := &iterNative{s: s}
+	ret.fn = reflect.ValueOf(ret.readUint32Int64)
+	return ret
+}
+
+func (v *iterNative) readETUint32Int64(et *typex.EventTime, key *uint32, value *int64) bool {
+	elm, err := v.cur.Read()
+	if err != nil {
+		if err == io.EOF {
+			return false
+		}
+		panic(fmt.Sprintf("broken stream: %v", err))
+	}
+
+	*et = elm.Timestamp
+	*key = elm.Elm.Interface().(uint32)
+	*value = elm.Elm2.Interface().(int64)
+	return true
+}
+
+func iterMakerETUint32Int64(s ReStream) ReusableInput {
+	ret := &iterNative{s: s}
+	ret.fn = reflect.ValueOf(ret.readETUint32Int64)
+	return ret
+}
+
+func (v *iterNative) readUint32Uint(key *uint32, value *uint) bool {
+	elm, err := v.cur.Read()
+	if err != nil {
+		if err == io.EOF {
+			return false
+		}
+		panic(fmt.Sprintf("broken stream: %v", err))
+	}
+
+	*key = elm.Elm.Interface().(uint32)
+	*value = elm.Elm2.Interface().(uint)
+	return true
+}
+
+func iterMakerUint32Uint(s ReStream) ReusableInput {
+	ret := &iterNative{s: s}
+	ret.fn = reflect.ValueOf(ret.readUint32Uint)
+	return ret
+}
+
+func (v *iterNative) readETUint32Uint(et *typex.EventTime, key *uint32, value *uint) bool {
+	elm, err := v.cur.Read()
+	if err != nil {
+		if err == io.EOF {
+			return false
+		}
+		panic(fmt.Sprintf("broken stream: %v", err))
+	}
+
+	*et = elm.Timestamp
+	*key = elm.Elm.Interface().(uint32)
+	*value = elm.Elm2.Interface().(uint)
+	return true
+}
+
+func iterMakerETUint32Uint(s ReStream) ReusableInput {
+	ret := &iterNative{s: s}
+	ret.fn = reflect.ValueOf(ret.readETUint32Uint)
+	return ret
+}
+
+func (v *iterNative) readUint32Uint8(key *uint32, value *uint8) bool {
+	elm, err := v.cur.Read()
+	if err != nil {
+		if err == io.EOF {
+			return false
+		}
+		panic(fmt.Sprintf("broken stream: %v", err))
+	}
+
+	*key = elm.Elm.Interface().(uint32)
+	*value = elm.Elm2.Interface().(uint8)
+	return true
+}
+
+func iterMakerUint32Uint8(s ReStream) ReusableInput {
+	ret := &iterNative{s: s}
+	ret.fn = reflect.ValueOf(ret.readUint32Uint8)
+	return ret
+}
+
+func (v *iterNative) readETUint32Uint8(et *typex.EventTime, key *uint32, value *uint8) bool {
+	elm, err := v.cur.Read()
+	if err != nil {
+		if err == io.EOF {
+			return false
+		}
+		panic(fmt.Sprintf("broken stream: %v", err))
+	}
+
+	*et = elm.Timestamp
+	*key = elm.Elm.Interface().(uint32)
+	*value = elm.Elm2.Interface().(uint8)
+	return true
+}
+
+func iterMakerETUint32Uint8(s ReStream) ReusableInput {
+	ret := &iterNative{s: s}
+	ret.fn = reflect.ValueOf(ret.readETUint32Uint8)
+	return ret
+}
+
+func (v *iterNative) readUint32Uint16(key *uint32, value *uint16) bool {
+	elm, err := v.cur.Read()
+	if err != nil {
+		if err == io.EOF {
+			return false
+		}
+		panic(fmt.Sprintf("broken stream: %v", err))
+	}
+
+	*key = elm.Elm.Interface().(uint32)
+	*value = elm.Elm2.Interface().(uint16)
+	return true
+}
+
+func iterMakerUint32Uint16(s ReStream) ReusableInput {
+	ret := &iterNative{s: s}
+	ret.fn = reflect.ValueOf(ret.readUint32Uint16)
+	return ret
+}
+
+func (v *iterNative) readETUint32Uint16(et *typex.EventTime, key *uint32, value *uint16) bool {
+	elm, err := v.cur.Read()
+	if err != nil {
+		if err == io.EOF {
+			return false
+		}
+		panic(fmt.Sprintf("broken stream: %v", err))
+	}
+
+	*et = elm.Timestamp
+	*key = elm.Elm.Interface().(uint32)
+	*value = elm.Elm2.Interface().(uint16)
+	return true
+}
+
+func iterMakerETUint32Uint16(s ReStream) ReusableInput {
+	ret := &iterNative{s: s}
+	ret.fn = reflect.ValueOf(ret.readETUint32Uint16)
+	return ret
+}
+
+func (v *iterNative) readUint32Uint32(key *uint32, value *uint32) bool {
+	elm, err := v.cur.Read()
+	if err != nil {
+		if err == io.EOF {
+			return false
+		}
+		panic(fmt.Sprintf("broken stream: %v", err))
+	}
+
+	*key = elm.Elm.Interface().(uint32)
+	*value = elm.Elm2.Interface().(uint32)
+	return true
+}
+
+func iterMakerUint32Uint32(s ReStream) ReusableInput {
+	ret := &iterNative{s: s}
+	ret.fn = reflect.ValueOf(ret.readUint32Uint32)
+	return ret
+}
+
+func (v *iterNative) readETUint32Uint32(et *typex.EventTime, key *uint32, value *uint32) bool {
+	elm, err := v.cur.Read()
+	if err != nil {
+		if err == io.EOF {
+			return false
+		}
+		panic(fmt.Sprintf("broken stream: %v", err))
+	}
+
+	*et = elm.Timestamp
+	*key = elm.Elm.Interface().(uint32)
+	*value = elm.Elm2.Interface().(uint32)
+	return true
+}
+
+func iterMakerETUint32Uint32(s ReStream) ReusableInput {
+	ret := &iterNative{s: s}
+	ret.fn = reflect.ValueOf(ret.readETUint32Uint32)
+	return ret
+}
+
+func (v *iterNative) readUint32Uint64(key *uint32, value *uint64) bool {
+	elm, err := v.cur.Read()
+	if err != nil {
+		if err == io.EOF {
+			return false
+		}
+		panic(fmt.Sprintf("broken stream: %v", err))
+	}
+
+	*key = elm.Elm.Interface().(uint32)
+	*value = elm.Elm2.Interface().(uint64)
+	return true
+}
+
+func iterMakerUint32Uint64(s ReStream) ReusableInput {
+	ret := &iterNative{s: s}
+	ret.fn = reflect.ValueOf(ret.readUint32Uint64)
+	return ret
+}
+
+func (v *iterNative) readETUint32Uint64(et *typex.EventTime, key *uint32, value *uint64) bool {
+	elm, err := v.cur.Read()
+	if err != nil {
+		if err == io.EOF {
+			return false
+		}
+		panic(fmt.Sprintf("broken stream: %v", err))
+	}
+
+	*et = elm.Timestamp
+	*key = elm.Elm.Interface().(uint32)
+	*value = elm.Elm2.Interface().(uint64)
+	return true
+}
+
+func iterMakerETUint32Uint64(s ReStream) ReusableInput {
+	ret := &iterNative{s: s}
+	ret.fn = reflect.ValueOf(ret.readETUint32Uint64)
+	return ret
+}
+
+func (v *iterNative) readUint32Float32(key *uint32, value *float32) bool {
+	elm, err := v.cur.Read()
+	if err != nil {
+		if err == io.EOF {
+			return false
+		}
+		panic(fmt.Sprintf("broken stream: %v", err))
+	}
+
+	*key = elm.Elm.Interface().(uint32)
+	*value = elm.Elm2.Interface().(float32)
+	return true
+}
+
+func iterMakerUint32Float32(s ReStream) ReusableInput {
+	ret := &iterNative{s: s}
+	ret.fn = reflect.ValueOf(ret.readUint32Float32)
+	return ret
+}
+
+func (v *iterNative) readETUint32Float32(et *typex.EventTime, key *uint32, value *float32) bool {
+	elm, err := v.cur.Read()
+	if err != nil {
+		if err == io.EOF {
+			return false
+		}
+		panic(fmt.Sprintf("broken stream: %v", err))
+	}
+
+	*et = elm.Timestamp
+	*key = elm.Elm.Interface().(uint32)
+	*value = elm.Elm2.Interface().(float32)
+	return true
+}
+
+func iterMakerETUint32Float32(s ReStream) ReusableInput {
+	ret := &iterNative{s: s}
+	ret.fn = reflect.ValueOf(ret.readETUint32Float32)
+	return ret
+}
+
+func (v *iterNative) readUint32Float64(key *uint32, value *float64) bool {
+	elm, err := v.cur.Read()
+	if err != nil {
+		if err == io.EOF {
+			return false
+		}
+		panic(fmt.Sprintf("broken stream: %v", err))
+	}
+
+	*key = elm.Elm.Interface().(uint32)
+	*value = elm.Elm2.Interface().(float64)
+	return true
+}
+
+func iterMakerUint32Float64(s ReStream) ReusableInput {
+	ret := &iterNative{s: s}
+	ret.fn = reflect.ValueOf(ret.readUint32Float64)
+	return ret
+}
+
+func (v *iterNative) readETUint32Float64(et *typex.EventTime, key *uint32, value *float64) bool {
+	elm, err := v.cur.Read()
+	if err != nil {
+		if err == io.EOF {
+			return false
+		}
+		panic(fmt.Sprintf("broken stream: %v", err))
+	}
+
+	*et = elm.Timestamp
+	*key = elm.Elm.Interface().(uint32)
+	*value = elm.Elm2.Interface().(float64)
+	return true
+}
+
+func iterMakerETUint32Float64(s ReStream) ReusableInput {
+	ret := &iterNative{s: s}
+	ret.fn = reflect.ValueOf(ret.readETUint32Float64)
+	return ret
+}
+
+func (v *iterNative) readUint32Typex_T(key *uint32, value *typex.T) bool {
+	elm, err := v.cur.Read()
+	if err != nil {
+		if err == io.EOF {
+			return false
+		}
+		panic(fmt.Sprintf("broken stream: %v", err))
+	}
+
+	*key = elm.Elm.Interface().(uint32)
+	*value = elm.Elm2.Interface().(typex.T)
+	return true
+}
+
+func iterMakerUint32Typex_T(s ReStream) ReusableInput {
+	ret := &iterNative{s: s}
+	ret.fn = reflect.ValueOf(ret.readUint32Typex_T)
+	return ret
+}
+
+func (v *iterNative) readETUint32Typex_T(et *typex.EventTime, key *uint32, value *typex.T) bool {
+	elm, err := v.cur.Read()
+	if err != nil {
+		if err == io.EOF {
+			return false
+		}
+		panic(fmt.Sprintf("broken stream: %v", err))
+	}
+
+	*et = elm.Timestamp
+	*key = elm.Elm.Interface().(uint32)
+	*value = elm.Elm2.Interface().(typex.T)
+	return true
+}
+
+func iterMakerETUint32Typex_T(s ReStream) ReusableInput {
+	ret := &iterNative{s: s}
+	ret.fn = reflect.ValueOf(ret.readETUint32Typex_T)
+	return ret
+}
+
+func (v *iterNative) readUint32Typex_U(key *uint32, value *typex.U) bool {
+	elm, err := v.cur.Read()
+	if err != nil {
+		if err == io.EOF {
+			return false
+		}
+		panic(fmt.Sprintf("broken stream: %v", err))
+	}
+
+	*key = elm.Elm.Interface().(uint32)
+	*value = elm.Elm2.Interface().(typex.U)
+	return true
+}
+
+func iterMakerUint32Typex_U(s ReStream) ReusableInput {
+	ret := &iterNative{s: s}
+	ret.fn = reflect.ValueOf(ret.readUint32Typex_U)
+	return ret
+}
+
+func (v *iterNative) readETUint32Typex_U(et *typex.EventTime, key *uint32, value *typex.U) bool {
+	elm, err := v.cur.Read()
+	if err != nil {
+		if err == io.EOF {
+			return false
+		}
+		panic(fmt.Sprintf("broken stream: %v", err))
+	}
+
+	*et = elm.Timestamp
+	*key = elm.Elm.Interface().(uint32)
+	*value = elm.Elm2.Interface().(typex.U)
+	return true
+}
+
+func iterMakerETUint32Typex_U(s ReStream) ReusableInput {
+	ret := &iterNative{s: s}
+	ret.fn = reflect.ValueOf(ret.readETUint32Typex_U)
+	return ret
+}
+
+func (v *iterNative) readUint32Typex_V(key *uint32, value *typex.V) bool {
+	elm, err := v.cur.Read()
+	if err != nil {
+		if err == io.EOF {
+			return false
+		}
+		panic(fmt.Sprintf("broken stream: %v", err))
+	}
+
+	*key = elm.Elm.Interface().(uint32)
+	*value = elm.Elm2.Interface().(typex.V)
+	return true
+}
+
+func iterMakerUint32Typex_V(s ReStream) ReusableInput {
+	ret := &iterNative{s: s}
+	ret.fn = reflect.ValueOf(ret.readUint32Typex_V)
+	return ret
+}
+
+func (v *iterNative) readETUint32Typex_V(et *typex.EventTime, key *uint32, value *typex.V) bool {
+	elm, err := v.cur.Read()
+	if err != nil {
+		if err == io.EOF {
+			return false
+		}
+		panic(fmt.Sprintf("broken stream: %v", err))
+	}
+
+	*et = elm.Timestamp
+	*key = elm.Elm.Interface().(uint32)
+	*value = elm.Elm2.Interface().(typex.V)
+	return true
+}
+
+func iterMakerETUint32Typex_V(s ReStream) ReusableInput {
+	ret := &iterNative{s: s}
+	ret.fn = reflect.ValueOf(ret.readETUint32Typex_V)
+	return ret
+}
+
+func (v *iterNative) readUint32Typex_W(key *uint32, value *typex.W) bool {
+	elm, err := v.cur.Read()
+	if err != nil {
+		if err == io.EOF {
+			return false
+		}
+		panic(fmt.Sprintf("broken stream: %v", err))
+	}
+
+	*key = elm.Elm.Interface().(uint32)
+	*value = elm.Elm2.Interface().(typex.W)
+	return true
+}
+
+func iterMakerUint32Typex_W(s ReStream) ReusableInput {
+	ret := &iterNative{s: s}
+	ret.fn = reflect.ValueOf(ret.readUint32Typex_W)
+	return ret
+}
+
+func (v *iterNative) readETUint32Typex_W(et *typex.EventTime, key *uint32, value *typex.W) bool {
+	elm, err := v.cur.Read()
+	if err != nil {
+		if err == io.EOF {
+			return false
+		}
+		panic(fmt.Sprintf("broken stream: %v", err))
+	}
+
+	*et = elm.Timestamp
+	*key = elm.Elm.Interface().(uint32)
+	*value = elm.Elm2.Interface().(typex.W)
+	return true
+}
+
+func iterMakerETUint32Typex_W(s ReStream) ReusableInput {
+	ret := &iterNative{s: s}
+	ret.fn = reflect.ValueOf(ret.readETUint32Typex_W)
+	return ret
+}
+
+func (v *iterNative) readUint32Typex_X(key *uint32, value *typex.X) bool {
+	elm, err := v.cur.Read()
+	if err != nil {
+		if err == io.EOF {
+			return false
+		}
+		panic(fmt.Sprintf("broken stream: %v", err))
+	}
+
+	*key = elm.Elm.Interface().(uint32)
+	*value = elm.Elm2.Interface().(typex.X)
+	return true
+}
+
+func iterMakerUint32Typex_X(s ReStream) ReusableInput {
+	ret := &iterNative{s: s}
+	ret.fn = reflect.ValueOf(ret.readUint32Typex_X)
+	return ret
+}
+
+func (v *iterNative) readETUint32Typex_X(et *typex.EventTime, key *uint32, value *typex.X) bool {
+	elm, err := v.cur.Read()
+	if err != nil {
+		if err == io.EOF {
+			return false
+		}
+		panic(fmt.Sprintf("broken stream: %v", err))
+	}
+
+	*et = elm.Timestamp
+	*key = elm.Elm.Interface().(uint32)
+	*value = elm.Elm2.Interface().(typex.X)
+	return true
+}
+
+func iterMakerETUint32Typex_X(s ReStream) ReusableInput {
+	ret := &iterNative{s: s}
+	ret.fn = reflect.ValueOf(ret.readETUint32Typex_X)
+	return ret
+}
+
+func (v *iterNative) readUint32Typex_Y(key *uint32, value *typex.Y) bool {
+	elm, err := v.cur.Read()
+	if err != nil {
+		if err == io.EOF {
+			return false
+		}
+		panic(fmt.Sprintf("broken stream: %v", err))
+	}
+
+	*key = elm.Elm.Interface().(uint32)
+	*value = elm.Elm2.Interface().(typex.Y)
+	return true
+}
+
+func iterMakerUint32Typex_Y(s ReStream) ReusableInput {
+	ret := &iterNative{s: s}
+	ret.fn = reflect.ValueOf(ret.readUint32Typex_Y)
+	return ret
+}
+
+func (v *iterNative) readETUint32Typex_Y(et *typex.EventTime, key *uint32, value *typex.Y) bool {
+	elm, err := v.cur.Read()
+	if err != nil {
+		if err == io.EOF {
+			return false
+		}
+		panic(fmt.Sprintf("broken stream: %v", err))
+	}
+
+	*et = elm.Timestamp
+	*key = elm.Elm.Interface().(uint32)
+	*value = elm.Elm2.Interface().(typex.Y)
+	return true
+}
+
+func iterMakerETUint32Typex_Y(s ReStream) ReusableInput {
+	ret := &iterNative{s: s}
+	ret.fn = reflect.ValueOf(ret.readETUint32Typex_Y)
+	return ret
+}
+
+func (v *iterNative) readUint32Typex_Z(key *uint32, value *typex.Z) bool {
+	elm, err := v.cur.Read()
+	if err != nil {
+		if err == io.EOF {
+			return false
+		}
+		panic(fmt.Sprintf("broken stream: %v", err))
+	}
+
+	*key = elm.Elm.Interface().(uint32)
+	*value = elm.Elm2.Interface().(typex.Z)
+	return true
+}
+
+func iterMakerUint32Typex_Z(s ReStream) ReusableInput {
+	ret := &iterNative{s: s}
+	ret.fn = reflect.ValueOf(ret.readUint32Typex_Z)
+	return ret
+}
+
+func (v *iterNative) readETUint32Typex_Z(et *typex.EventTime, key *uint32, value *typex.Z) bool {
+	elm, err := v.cur.Read()
+	if err != nil {
+		if err == io.EOF {
+			return false
+		}
+		panic(fmt.Sprintf("broken stream: %v", err))
+	}
+
+	*et = elm.Timestamp
+	*key = elm.Elm.Interface().(uint32)
+	*value = elm.Elm2.Interface().(typex.Z)
+	return true
+}
+
+func iterMakerETUint32Typex_Z(s ReStream) ReusableInput {
+	ret := &iterNative{s: s}
+	ret.fn = reflect.ValueOf(ret.readETUint32Typex_Z)
+	return ret
+}
+
+func (v *iterNative) readUint64(val *uint64) bool {
+	elm, err := v.cur.Read()
+	if err != nil {
+		if err == io.EOF {
+			return false
+		}
+		panic(fmt.Sprintf("broken stream: %v", err))
+	}
+
+	*val = elm.Elm.Interface().(uint64)
+	return true
+}
+
+func iterMakerUint64(s ReStream) ReusableInput {
+	ret := &iterNative{s: s}
+	ret.fn = reflect.ValueOf(ret.readUint64)
+	return ret
+}
+
+func (v *iterNative) readETUint64(et *typex.EventTime, val *uint64) bool {
+	elm, err := v.cur.Read()
+	if err != nil {
+		if err == io.EOF {
+			return false
+		}
+		panic(fmt.Sprintf("broken stream: %v", err))
+	}
+
+	*et = elm.Timestamp
+	*val = elm.Elm.Interface().(uint64)
+	return true
+}
+
+func iterMakerETUint64(s ReStream) ReusableInput {
+	ret := &iterNative{s: s}
+	ret.fn = reflect.ValueOf(ret.readETUint64)
+	return ret
+}
+
+func (v *iterNative) readUint64ByteSlice(key *uint64, value *[]byte) bool {
+	elm, err := v.cur.Read()
+	if err != nil {
+		if err == io.EOF {
+			return false
+		}
+		panic(fmt.Sprintf("broken stream: %v", err))
+	}
+
+	*key = elm.Elm.Interface().(uint64)
+	*value = elm.Elm2.Interface().([]byte)
+	return true
+}
+
+func iterMakerUint64ByteSlice(s ReStream) ReusableInput {
+	ret := &iterNative{s: s}
+	ret.fn = reflect.ValueOf(ret.readUint64ByteSlice)
+	return ret
+}
+
+func (v *iterNative) readETUint64ByteSlice(et *typex.EventTime, key *uint64, value *[]byte) bool {
+	elm, err := v.cur.Read()
+	if err != nil {
+		if err == io.EOF {
+			return false
+		}
+		panic(fmt.Sprintf("broken stream: %v", err))
+	}
+
+	*et = elm.Timestamp
+	*key = elm.Elm.Interface().(uint64)
+	*value = elm.Elm2.Interface().([]byte)
+	return true
+}
+
+func iterMakerETUint64ByteSlice(s ReStream) ReusableInput {
+	ret := &iterNative{s: s}
+	ret.fn = reflect.ValueOf(ret.readETUint64ByteSlice)
+	return ret
+}
+
+func (v *iterNative) readUint64Bool(key *uint64, value *bool) bool {
+	elm, err := v.cur.Read()
+	if err != nil {
+		if err == io.EOF {
+			return false
+		}
+		panic(fmt.Sprintf("broken stream: %v", err))
+	}
+
+	*key = elm.Elm.Interface().(uint64)
+	*value = elm.Elm2.Interface().(bool)
+	return true
+}
+
+func iterMakerUint64Bool(s ReStream) ReusableInput {
+	ret := &iterNative{s: s}
+	ret.fn = reflect.ValueOf(ret.readUint64Bool)
+	return ret
+}
+
+func (v *iterNative) readETUint64Bool(et *typex.EventTime, key *uint64, value *bool) bool {
+	elm, err := v.cur.Read()
+	if err != nil {
+		if err == io.EOF {
+			return false
+		}
+		panic(fmt.Sprintf("broken stream: %v", err))
+	}
+
+	*et = elm.Timestamp
+	*key = elm.Elm.Interface().(uint64)
+	*value = elm.Elm2.Interface().(bool)
+	return true
+}
+
+func iterMakerETUint64Bool(s ReStream) ReusableInput {
+	ret := &iterNative{s: s}
+	ret.fn = reflect.ValueOf(ret.readETUint64Bool)
+	return ret
+}
+
+func (v *iterNative) readUint64String(key *uint64, value *string) bool {
+	elm, err := v.cur.Read()
+	if err != nil {
+		if err == io.EOF {
+			return false
+		}
+		panic(fmt.Sprintf("broken stream: %v", err))
+	}
+
+	*key = elm.Elm.Interface().(uint64)
+	*value = elm.Elm2.Interface().(string)
+	return true
+}
+
+func iterMakerUint64String(s ReStream) ReusableInput {
+	ret := &iterNative{s: s}
+	ret.fn = reflect.ValueOf(ret.readUint64String)
+	return ret
+}
+
+func (v *iterNative) readETUint64String(et *typex.EventTime, key *uint64, value *string) bool {
+	elm, err := v.cur.Read()
+	if err != nil {
+		if err == io.EOF {
+			return false
+		}
+		panic(fmt.Sprintf("broken stream: %v", err))
+	}
+
+	*et = elm.Timestamp
+	*key = elm.Elm.Interface().(uint64)
+	*value = elm.Elm2.Interface().(string)
+	return true
+}
+
+func iterMakerETUint64String(s ReStream) ReusableInput {
+	ret := &iterNative{s: s}
+	ret.fn = reflect.ValueOf(ret.readETUint64String)
+	return ret
+}
+
+func (v *iterNative) readUint64Int(key *uint64, value *int) bool {
+	elm, err := v.cur.Read()
+	if err != nil {
+		if err == io.EOF {
+			return false
+		}
+		panic(fmt.Sprintf("broken stream: %v", err))
+	}
+
+	*key = elm.Elm.Interface().(uint64)
+	*value = elm.Elm2.Interface().(int)
+	return true
+}
+
+func iterMakerUint64Int(s ReStream) ReusableInput {
+	ret := &iterNative{s: s}
+	ret.fn = reflect.ValueOf(ret.readUint64Int)
+	return ret
+}
+
+func (v *iterNative) readETUint64Int(et *typex.EventTime, key *uint64, value *int) bool {
+	elm, err := v.cur.Read()
+	if err != nil {
+		if err == io.EOF {
+			return false
+		}
+		panic(fmt.Sprintf("broken stream: %v", err))
+	}
+
+	*et = elm.Timestamp
+	*key = elm.Elm.Interface().(uint64)
+	*value = elm.Elm2.Interface().(int)
+	return true
+}
+
+func iterMakerETUint64Int(s ReStream) ReusableInput {
+	ret := &iterNative{s: s}
+	ret.fn = reflect.ValueOf(ret.readETUint64Int)
+	return ret
+}
+
+func (v *iterNative) readUint64Int8(key *uint64, value *int8) bool {
+	elm, err := v.cur.Read()
+	if err != nil {
+		if err == io.EOF {
+			return false
+		}
+		panic(fmt.Sprintf("broken stream: %v", err))
+	}
+
+	*key = elm.Elm.Interface().(uint64)
+	*value = elm.Elm2.Interface().(int8)
+	return true
+}
+
+func iterMakerUint64Int8(s ReStream) ReusableInput {
+	ret := &iterNative{s: s}
+	ret.fn = reflect.ValueOf(ret.readUint64Int8)
+	return ret
+}
+
+func (v *iterNative) readETUint64Int8(et *typex.EventTime, key *uint64, value *int8) bool {
+	elm, err := v.cur.Read()
+	if err != nil {
+		if err == io.EOF {
+			return false
+		}
+		panic(fmt.Sprintf("broken stream: %v", err))
+	}
+
+	*et = elm.Timestamp
+	*key = elm.Elm.Interface().(uint64)
+	*value = elm.Elm2.Interface().(int8)
+	return true
+}
+
+func iterMakerETUint64Int8(s ReStream) ReusableInput {
+	ret := &iterNative{s: s}
+	ret.fn = reflect.ValueOf(ret.readETUint64Int8)
+	return ret
+}
+
+func (v *iterNative) readUint64Int16(key *uint64, value *int16) bool {
+	elm, err := v.cur.Read()
+	if err != nil {
+		if err == io.EOF {
+			return false
+		}
+		panic(fmt.Sprintf("broken stream: %v", err))
+	}
+
+	*key = elm.Elm.Interface().(uint64)
+	*value = elm.Elm2.Interface().(int16)
+	return true
+}
+
+func iterMakerUint64Int16(s ReStream) ReusableInput {
+	ret := &iterNative{s: s}
+	ret.fn = reflect.ValueOf(ret.readUint64Int16)
+	return ret
+}
+
+func (v *iterNative) readETUint64Int16(et *typex.EventTime, key *uint64, value *int16) bool {
+	elm, err := v.cur.Read()
+	if err != nil {
+		if err == io.EOF {
+			return false
+		}
+		panic(fmt.Sprintf("broken stream: %v", err))
+	}
+
+	*et = elm.Timestamp
+	*key = elm.Elm.Interface().(uint64)
+	*value = elm.Elm2.Interface().(int16)
+	return true
+}
+
+func iterMakerETUint64Int16(s ReStream) ReusableInput {
+	ret := &iterNative{s: s}
+	ret.fn = reflect.ValueOf(ret.readETUint64Int16)
+	return ret
+}
+
+func (v *iterNative) readUint64Int32(key *uint64, value *int32) bool {
+	elm, err := v.cur.Read()
+	if err != nil {
+		if err == io.EOF {
+			return false
+		}
+		panic(fmt.Sprintf("broken stream: %v", err))
+	}
+
+	*key = elm.Elm.Interface().(uint64)
+	*value = elm.Elm2.Interface().(int32)
+	return true
+}
+
+func iterMakerUint64Int32(s ReStream) ReusableInput {
+	ret := &iterNative{s: s}
+	ret.fn = reflect.ValueOf(ret.readUint64Int32)
+	return ret
+}
+
+func (v *iterNative) readETUint64Int32(et *typex.EventTime, key *uint64, value *int32) bool {
+	elm, err := v.cur.Read()
+	if err != nil {
+		if err == io.EOF {
+			return false
+		}
+		panic(fmt.Sprintf("broken stream: %v", err))
+	}
+
+	*et = elm.Timestamp
+	*key = elm.Elm.Interface().(uint64)
+	*value = elm.Elm2.Interface().(int32)
+	return true
+}
+
+func iterMakerETUint64Int32(s ReStream) ReusableInput {
+	ret := &iterNative{s: s}
+	ret.fn = reflect.ValueOf(ret.readETUint64Int32)
+	return ret
+}
+
+func (v *iterNative) readUint64Int64(key *uint64, value *int64) bool {
+	elm, err := v.cur.Read()
+	if err != nil {
+		if err == io.EOF {
+			return false
+		}
+		panic(fmt.Sprintf("broken stream: %v", err))
+	}
+
+	*key = elm.Elm.Interface().(uint64)
+	*value = elm.Elm2.Interface().(int64)
+	return true
+}
+
+func iterMakerUint64Int64(s ReStream) ReusableInput {
+	ret := &iterNative{s: s}
+	ret.fn = reflect.ValueOf(ret.readUint64Int64)
+	return ret
+}
+
+func (v *iterNative) readETUint64Int64(et *typex.EventTime, key *uint64, value *int64) bool {
+	elm, err := v.cur.Read()
+	if err != nil {
+		if err == io.EOF {
+			return false
+		}
+		panic(fmt.Sprintf("broken stream: %v", err))
+	}
+
+	*et = elm.Timestamp
+	*key = elm.Elm.Interface().(uint64)
+	*value = elm.Elm2.Interface().(int64)
+	return true
+}
+
+func iterMakerETUint64Int64(s ReStream) ReusableInput {
+	ret := &iterNative{s: s}
+	ret.fn = reflect.ValueOf(ret.readETUint64Int64)
+	return ret
+}
+
+func (v *iterNative) readUint64Uint(key *uint64, value *uint) bool {
+	elm, err := v.cur.Read()
+	if err != nil {
+		if err == io.EOF {
+			return false
+		}
+		panic(fmt.Sprintf("broken stream: %v", err))
+	}
+
+	*key = elm.Elm.Interface().(uint64)
+	*value = elm.Elm2.Interface().(uint)
+	return true
+}
+
+func iterMakerUint64Uint(s ReStream) ReusableInput {
+	ret := &iterNative{s: s}
+	ret.fn = reflect.ValueOf(ret.readUint64Uint)
+	return ret
+}
+
+func (v *iterNative) readETUint64Uint(et *typex.EventTime, key *uint64, value *uint) bool {
+	elm, err := v.cur.Read()
+	if err != nil {
+		if err == io.EOF {
+			return false
+		}
+		panic(fmt.Sprintf("broken stream: %v", err))
+	}
+
+	*et = elm.Timestamp
+	*key = elm.Elm.Interface().(uint64)
+	*value = elm.Elm2.Interface().(uint)
+	return true
+}
+
+func iterMakerETUint64Uint(s ReStream) ReusableInput {
+	ret := &iterNative{s: s}
+	ret.fn = reflect.ValueOf(ret.readETUint64Uint)
+	return ret
+}
+
+func (v *iterNative) readUint64Uint8(key *uint64, value *uint8) bool {
+	elm, err := v.cur.Read()
+	if err != nil {
+		if err == io.EOF {
+			return false
+		}
+		panic(fmt.Sprintf("broken stream: %v", err))
+	}
+
+	*key = elm.Elm.Interface().(uint64)
+	*value = elm.Elm2.Interface().(uint8)
+	return true
+}
+
+func iterMakerUint64Uint8(s ReStream) ReusableInput {
+	ret := &iterNative{s: s}
+	ret.fn = reflect.ValueOf(ret.readUint64Uint8)
+	return ret
+}
+
+func (v *iterNative) readETUint64Uint8(et *typex.EventTime, key *uint64, value *uint8) bool {
+	elm, err := v.cur.Read()
+	if err != nil {
+		if err == io.EOF {
+			return false
+		}
+		panic(fmt.Sprintf("broken stream: %v", err))
+	}
+
+	*et = elm.Timestamp
+	*key = elm.Elm.Interface().(uint64)
+	*value = elm.Elm2.Interface().(uint8)
+	return true
+}
+
+func iterMakerETUint64Uint8(s ReStream) ReusableInput {
+	ret := &iterNative{s: s}
+	ret.fn = reflect.ValueOf(ret.readETUint64Uint8)
+	return ret
+}
+
+func (v *iterNative) readUint64Uint16(key *uint64, value *uint16) bool {
+	elm, err := v.cur.Read()
+	if err != nil {
+		if err == io.EOF {
+			return false
+		}
+		panic(fmt.Sprintf("broken stream: %v", err))
+	}
+
+	*key = elm.Elm.Interface().(uint64)
+	*value = elm.Elm2.Interface().(uint16)
+	return true
+}
+
+func iterMakerUint64Uint16(s ReStream) ReusableInput {
+	ret := &iterNative{s: s}
+	ret.fn = reflect.ValueOf(ret.readUint64Uint16)
+	return ret
+}
+
+func (v *iterNative) readETUint64Uint16(et *typex.EventTime, key *uint64, value *uint16) bool {
+	elm, err := v.cur.Read()
+	if err != nil {
+		if err == io.EOF {
+			return false
+		}
+		panic(fmt.Sprintf("broken stream: %v", err))
+	}
+
+	*et = elm.Timestamp
+	*key = elm.Elm.Interface().(uint64)
+	*value = elm.Elm2.Interface().(uint16)
+	return true
+}
+
+func iterMakerETUint64Uint16(s ReStream) ReusableInput {
+	ret := &iterNative{s: s}
+	ret.fn = reflect.ValueOf(ret.readETUint64Uint16)
+	return ret
+}
+
+func (v *iterNative) readUint64Uint32(key *uint64, value *uint32) bool {
+	elm, err := v.cur.Read()
+	if err != nil {
+		if err == io.EOF {
+			return false
+		}
+		panic(fmt.Sprintf("broken stream: %v", err))
+	}
+
+	*key = elm.Elm.Interface().(uint64)
+	*value = elm.Elm2.Interface().(uint32)
+	return true
+}
+
+func iterMakerUint64Uint32(s ReStream) ReusableInput {
+	ret := &iterNative{s: s}
+	ret.fn = reflect.ValueOf(ret.readUint64Uint32)
+	return ret
+}
+
+func (v *iterNative) readETUint64Uint32(et *typex.EventTime, key *uint64, value *uint32) bool {
+	elm, err := v.cur.Read()
+	if err != nil {
+		if err == io.EOF {
+			return false
+		}
+		panic(fmt.Sprintf("broken stream: %v", err))
+	}
+
+	*et = elm.Timestamp
+	*key = elm.Elm.Interface().(uint64)
+	*value = elm.Elm2.Interface().(uint32)
+	return true
+}
+
+func iterMakerETUint64Uint32(s ReStream) ReusableInput {
+	ret := &iterNative{s: s}
+	ret.fn = reflect.ValueOf(ret.readETUint64Uint32)
+	return ret
+}
+
+func (v *iterNative) readUint64Uint64(key *uint64, value *uint64) bool {
+	elm, err := v.cur.Read()
+	if err != nil {
+		if err == io.EOF {
+			return false
+		}
+		panic(fmt.Sprintf("broken stream: %v", err))
+	}
+
+	*key = elm.Elm.Interface().(uint64)
+	*value = elm.Elm2.Interface().(uint64)
+	return true
+}
+
+func iterMakerUint64Uint64(s ReStream) ReusableInput {
+	ret := &iterNative{s: s}
+	ret.fn = reflect.ValueOf(ret.readUint64Uint64)
+	return ret
+}
+
+func (v *iterNative) readETUint64Uint64(et *typex.EventTime, key *uint64, value *uint64) bool {
+	elm, err := v.cur.Read()
+	if err != nil {
+		if err == io.EOF {
+			return false
+		}
+		panic(fmt.Sprintf("broken stream: %v", err))
+	}
+
+	*et = elm.Timestamp
+	*key = elm.Elm.Interface().(uint64)
+	*value = elm.Elm2.Interface().(uint64)
+	return true
+}
+
+func iterMakerETUint64Uint64(s ReStream) ReusableInput {
+	ret := &iterNative{s: s}
+	ret.fn = reflect.ValueOf(ret.readETUint64Uint64)
+	return ret
+}
+
+func (v *iterNative) readUint64Float32(key *uint64, value *float32) bool {
+	elm, err := v.cur.Read()
+	if err != nil {
+		if err == io.EOF {
+			return false
+		}
+		panic(fmt.Sprintf("broken stream: %v", err))
+	}
+
+	*key = elm.Elm.Interface().(uint64)
+	*value = elm.Elm2.Interface().(float32)
+	return true
+}
+
+func iterMakerUint64Float32(s ReStream) ReusableInput {
+	ret := &iterNative{s: s}
+	ret.fn = reflect.ValueOf(ret.readUint64Float32)
+	return ret
+}
+
+func (v *iterNative) readETUint64Float32(et *typex.EventTime, key *uint64, value *float32) bool {
+	elm, err := v.cur.Read()
+	if err != nil {
+		if err == io.EOF {
+			return false
+		}
+		panic(fmt.Sprintf("broken stream: %v", err))
+	}
+
+	*et = elm.Timestamp
+	*key = elm.Elm.Interface().(uint64)
+	*value = elm.Elm2.Interface().(float32)
+	return true
+}
+
+func iterMakerETUint64Float32(s ReStream) ReusableInput {
+	ret := &iterNative{s: s}
+	ret.fn = reflect.ValueOf(ret.readETUint64Float32)
+	return ret
+}
+
+func (v *iterNative) readUint64Float64(key *uint64, value *float64) bool {
+	elm, err := v.cur.Read()
+	if err != nil {
+		if err == io.EOF {
+			return false
+		}
+		panic(fmt.Sprintf("broken stream: %v", err))
+	}
+
+	*key = elm.Elm.Interface().(uint64)
+	*value = elm.Elm2.Interface().(float64)
+	return true
+}
+
+func iterMakerUint64Float64(s ReStream) ReusableInput {
+	ret := &iterNative{s: s}
+	ret.fn = reflect.ValueOf(ret.readUint64Float64)
+	return ret
+}
+
+func (v *iterNative) readETUint64Float64(et *typex.EventTime, key *uint64, value *float64) bool {
+	elm, err := v.cur.Read()
+	if err != nil {
+		if err == io.EOF {
+			return false
+		}
+		panic(fmt.Sprintf("broken stream: %v", err))
+	}
+
+	*et = elm.Timestamp
+	*key = elm.Elm.Interface().(uint64)
+	*value = elm.Elm2.Interface().(float64)
+	return true
+}
+
+func iterMakerETUint64Float64(s ReStream) ReusableInput {
+	ret := &iterNative{s: s}
+	ret.fn = reflect.ValueOf(ret.readETUint64Float64)
+	return ret
+}
+
+func (v *iterNative) readUint64Typex_T(key *uint64, value *typex.T) bool {
+	elm, err := v.cur.Read()
+	if err != nil {
+		if err == io.EOF {
+			return false
+		}
+		panic(fmt.Sprintf("broken stream: %v", err))
+	}
+
+	*key = elm.Elm.Interface().(uint64)
+	*value = elm.Elm2.Interface().(typex.T)
+	return true
+}
+
+func iterMakerUint64Typex_T(s ReStream) ReusableInput {
+	ret := &iterNative{s: s}
+	ret.fn = reflect.ValueOf(ret.readUint64Typex_T)
+	return ret
+}
+
+func (v *iterNative) readETUint64Typex_T(et *typex.EventTime, key *uint64, value *typex.T) bool {
+	elm, err := v.cur.Read()
+	if err != nil {
+		if err == io.EOF {
+			return false
+		}
+		panic(fmt.Sprintf("broken stream: %v", err))
+	}
+
+	*et = elm.Timestamp
+	*key = elm.Elm.Interface().(uint64)
+	*value = elm.Elm2.Interface().(typex.T)
+	return true
+}
+
+func iterMakerETUint64Typex_T(s ReStream) ReusableInput {
+	ret := &iterNative{s: s}
+	ret.fn = reflect.ValueOf(ret.readETUint64Typex_T)
+	return ret
+}
+
+func (v *iterNative) readUint64Typex_U(key *uint64, value *typex.U) bool {
+	elm, err := v.cur.Read()
+	if err != nil {
+		if err == io.EOF {
+			return false
+		}
+		panic(fmt.Sprintf("broken stream: %v", err))
+	}
+
+	*key = elm.Elm.Interface().(uint64)
+	*value = elm.Elm2.Interface().(typex.U)
+	return true
+}
+
+func iterMakerUint64Typex_U(s ReStream) ReusableInput {
+	ret := &iterNative{s: s}
+	ret.fn = reflect.ValueOf(ret.readUint64Typex_U)
+	return ret
+}
+
+func (v *iterNative) readETUint64Typex_U(et *typex.EventTime, key *uint64, value *typex.U) bool {
+	elm, err := v.cur.Read()
+	if err != nil {
+		if err == io.EOF {
+			return false
+		}
+		panic(fmt.Sprintf("broken stream: %v", err))
+	}
+
+	*et = elm.Timestamp
+	*key = elm.Elm.Interface().(uint64)
+	*value = elm.Elm2.Interface().(typex.U)
+	return true
+}
+
+func iterMakerETUint64Typex_U(s ReStream) ReusableInput {
+	ret := &iterNative{s: s}
+	ret.fn = reflect.ValueOf(ret.readETUint64Typex_U)
+	return ret
+}
+
+func (v *iterNative) readUint64Typex_V(key *uint64, value *typex.V) bool {
+	elm, err := v.cur.Read()
+	if err != nil {
+		if err == io.EOF {
+			return false
+		}
+		panic(fmt.Sprintf("broken stream: %v", err))
+	}
+
+	*key = elm.Elm.Interface().(uint64)
+	*value = elm.Elm2.Interface().(typex.V)
+	return true
+}
+
+func iterMakerUint64Typex_V(s ReStream) ReusableInput {
+	ret := &iterNative{s: s}
+	ret.fn = reflect.ValueOf(ret.readUint64Typex_V)
+	return ret
+}
+
+func (v *iterNative) readETUint64Typex_V(et *typex.EventTime, key *uint64, value *typex.V) bool {
+	elm, err := v.cur.Read()
+	if err != nil {
+		if err == io.EOF {
+			return false
+		}
+		panic(fmt.Sprintf("broken stream: %v", err))
+	}
+
+	*et = elm.Timestamp
+	*key = elm.Elm.Interface().(uint64)
+	*value = elm.Elm2.Interface().(typex.V)
+	return true
+}
+
+func iterMakerETUint64Typex_V(s ReStream) ReusableInput {
+	ret := &iterNative{s: s}
+	ret.fn = reflect.ValueOf(ret.readETUint64Typex_V)
+	return ret
+}
+
+func (v *iterNative) readUint64Typex_W(key *uint64, value *typex.W) bool {
+	elm, err := v.cur.Read()
+	if err != nil {
+		if err == io.EOF {
+			return false
+		}
+		panic(fmt.Sprintf("broken stream: %v", err))
+	}
+
+	*key = elm.Elm.Interface().(uint64)
+	*value = elm.Elm2.Interface().(typex.W)
+	return true
+}
+
+func iterMakerUint64Typex_W(s ReStream) ReusableInput {
+	ret := &iterNative{s: s}
+	ret.fn = reflect.ValueOf(ret.readUint64Typex_W)
+	return ret
+}
+
+func (v *iterNative) readETUint64Typex_W(et *typex.EventTime, key *uint64, value *typex.W) bool {
+	elm, err := v.cur.Read()
+	if err != nil {
+		if err == io.EOF {
+			return false
+		}
+		panic(fmt.Sprintf("broken stream: %v", err))
+	}
+
+	*et = elm.Timestamp
+	*key = elm.Elm.Interface().(uint64)
+	*value = elm.Elm2.Interface().(typex.W)
+	return true
+}
+
+func iterMakerETUint64Typex_W(s ReStream) ReusableInput {
+	ret := &iterNative{s: s}
+	ret.fn = reflect.ValueOf(ret.readETUint64Typex_W)
+	return ret
+}
+
+func (v *iterNative) readUint64Typex_X(key *uint64, value *typex.X) bool {
+	elm, err := v.cur.Read()
+	if err != nil {
+		if err == io.EOF {
+			return false
+		}
+		panic(fmt.Sprintf("broken stream: %v", err))
+	}
+
+	*key = elm.Elm.Interface().(uint64)
+	*value = elm.Elm2.Interface().(typex.X)
+	return true
+}
+
+func iterMakerUint64Typex_X(s ReStream) ReusableInput {
+	ret := &iterNative{s: s}
+	ret.fn = reflect.ValueOf(ret.readUint64Typex_X)
+	return ret
+}
+
+func (v *iterNative) readETUint64Typex_X(et *typex.EventTime, key *uint64, value *typex.X) bool {
+	elm, err := v.cur.Read()
+	if err != nil {
+		if err == io.EOF {
+			return false
+		}
+		panic(fmt.Sprintf("broken stream: %v", err))
+	}
+
+	*et = elm.Timestamp
+	*key = elm.Elm.Interface().(uint64)
+	*value = elm.Elm2.Interface().(typex.X)
+	return true
+}
+
+func iterMakerETUint64Typex_X(s ReStream) ReusableInput {
+	ret := &iterNative{s: s}
+	ret.fn = reflect.ValueOf(ret.readETUint64Typex_X)
+	return ret
+}
+
+func (v *iterNative) readUint64Typex_Y(key *uint64, value *typex.Y) bool {
+	elm, err := v.cur.Read()
+	if err != nil {
+		if err == io.EOF {
+			return false
+		}
+		panic(fmt.Sprintf("broken stream: %v", err))
+	}
+
+	*key = elm.Elm.Interface().(uint64)
+	*value = elm.Elm2.Interface().(typex.Y)
+	return true
+}
+
+func iterMakerUint64Typex_Y(s ReStream) ReusableInput {
+	ret := &iterNative{s: s}
+	ret.fn = reflect.ValueOf(ret.readUint64Typex_Y)
+	return ret
+}
+
+func (v *iterNative) readETUint64Typex_Y(et *typex.EventTime, key *uint64, value *typex.Y) bool {
+	elm, err := v.cur.Read()
+	if err != nil {
+		if err == io.EOF {
+			return false
+		}
+		panic(fmt.Sprintf("broken stream: %v", err))
+	}
+
+	*et = elm.Timestamp
+	*key = elm.Elm.Interface().(uint64)
+	*value = elm.Elm2.Interface().(typex.Y)
+	return true
+}
+
+func iterMakerETUint64Typex_Y(s ReStream) ReusableInput {
+	ret := &iterNative{s: s}
+	ret.fn = reflect.ValueOf(ret.readETUint64Typex_Y)
+	return ret
+}
+
+func (v *iterNative) readUint64Typex_Z(key *uint64, value *typex.Z) bool {
+	elm, err := v.cur.Read()
+	if err != nil {
+		if err == io.EOF {
+			return false
+		}
+		panic(fmt.Sprintf("broken stream: %v", err))
+	}
+
+	*key = elm.Elm.Interface().(uint64)
+	*value = elm.Elm2.Interface().(typex.Z)
+	return true
+}
+
+func iterMakerUint64Typex_Z(s ReStream) ReusableInput {
+	ret := &iterNative{s: s}
+	ret.fn = reflect.ValueOf(ret.readUint64Typex_Z)
+	return ret
+}
+
+func (v *iterNative) readETUint64Typex_Z(et *typex.EventTime, key *uint64, value *typex.Z) bool {
+	elm, err := v.cur.Read()
+	if err != nil {
+		if err == io.EOF {
+			return false
+		}
+		panic(fmt.Sprintf("broken stream: %v", err))
+	}
+
+	*et = elm.Timestamp
+	*key = elm.Elm.Interface().(uint64)
+	*value = elm.Elm2.Interface().(typex.Z)
+	return true
+}
+
+func iterMakerETUint64Typex_Z(s ReStream) ReusableInput {
+	ret := &iterNative{s: s}
+	ret.fn = reflect.ValueOf(ret.readETUint64Typex_Z)
+	return ret
+}
+
+func (v *iterNative) readFloat32(val *float32) bool {
+	elm, err := v.cur.Read()
+	if err != nil {
+		if err == io.EOF {
+			return false
+		}
+		panic(fmt.Sprintf("broken stream: %v", err))
+	}
+
+	*val = elm.Elm.Interface().(float32)
+	return true
+}
+
+func iterMakerFloat32(s ReStream) ReusableInput {
+	ret := &iterNative{s: s}
+	ret.fn = reflect.ValueOf(ret.readFloat32)
+	return ret
+}
+
+func (v *iterNative) readETFloat32(et *typex.EventTime, val *float32) bool {
+	elm, err := v.cur.Read()
+	if err != nil {
+		if err == io.EOF {
+			return false
+		}
+		panic(fmt.Sprintf("broken stream: %v", err))
+	}
+
+	*et = elm.Timestamp
+	*val = elm.Elm.Interface().(float32)
+	return true
+}
+
+func iterMakerETFloat32(s ReStream) ReusableInput {
+	ret := &iterNative{s: s}
+	ret.fn = reflect.ValueOf(ret.readETFloat32)
+	return ret
+}
+
+func (v *iterNative) readFloat32ByteSlice(key *float32, value *[]byte) bool {
+	elm, err := v.cur.Read()
+	if err != nil {
+		if err == io.EOF {
+			return false
+		}
+		panic(fmt.Sprintf("broken stream: %v", err))
+	}
+
+	*key = elm.Elm.Interface().(float32)
+	*value = elm.Elm2.Interface().([]byte)
+	return true
+}
+
+func iterMakerFloat32ByteSlice(s ReStream) ReusableInput {
+	ret := &iterNative{s: s}
+	ret.fn = reflect.ValueOf(ret.readFloat32ByteSlice)
+	return ret
+}
+
+func (v *iterNative) readETFloat32ByteSlice(et *typex.EventTime, key *float32, value *[]byte) bool {
+	elm, err := v.cur.Read()
+	if err != nil {
+		if err == io.EOF {
+			return false
+		}
+		panic(fmt.Sprintf("broken stream: %v", err))
+	}
+
+	*et = elm.Timestamp
+	*key = elm.Elm.Interface().(float32)
+	*value = elm.Elm2.Interface().([]byte)
+	return true
+}
+
+func iterMakerETFloat32ByteSlice(s ReStream) ReusableInput {
+	ret := &iterNative{s: s}
+	ret.fn = reflect.ValueOf(ret.readETFloat32ByteSlice)
+	return ret
+}
+
+func (v *iterNative) readFloat32Bool(key *float32, value *bool) bool {
+	elm, err := v.cur.Read()
+	if err != nil {
+		if err == io.EOF {
+			return false
+		}
+		panic(fmt.Sprintf("broken stream: %v", err))
+	}
+
+	*key = elm.Elm.Interface().(float32)
+	*value = elm.Elm2.Interface().(bool)
+	return true
+}
+
+func iterMakerFloat32Bool(s ReStream) ReusableInput {
+	ret := &iterNative{s: s}
+	ret.fn = reflect.ValueOf(ret.readFloat32Bool)
+	return ret
+}
+
+func (v *iterNative) readETFloat32Bool(et *typex.EventTime, key *float32, value *bool) bool {
+	elm, err := v.cur.Read()
+	if err != nil {
+		if err == io.EOF {
+			return false
+		}
+		panic(fmt.Sprintf("broken stream: %v", err))
+	}
+
+	*et = elm.Timestamp
+	*key = elm.Elm.Interface().(float32)
+	*value = elm.Elm2.Interface().(bool)
+	return true
+}
+
+func iterMakerETFloat32Bool(s ReStream) ReusableInput {
+	ret := &iterNative{s: s}
+	ret.fn = reflect.ValueOf(ret.readETFloat32Bool)
+	return ret
+}
+
+func (v *iterNative) readFloat32String(key *float32, value *string) bool {
+	elm, err := v.cur.Read()
+	if err != nil {
+		if err == io.EOF {
+			return false
+		}
+		panic(fmt.Sprintf("broken stream: %v", err))
+	}
+
+	*key = elm.Elm.Interface().(float32)
+	*value = elm.Elm2.Interface().(string)
+	return true
+}
+
+func iterMakerFloat32String(s ReStream) ReusableInput {
+	ret := &iterNative{s: s}
+	ret.fn = reflect.ValueOf(ret.readFloat32String)
+	return ret
+}
+
+func (v *iterNative) readETFloat32String(et *typex.EventTime, key *float32, value *string) bool {
+	elm, err := v.cur.Read()
+	if err != nil {
+		if err == io.EOF {
+			return false
+		}
+		panic(fmt.Sprintf("broken stream: %v", err))
+	}
+
+	*et = elm.Timestamp
+	*key = elm.Elm.Interface().(float32)
+	*value = elm.Elm2.Interface().(string)
+	return true
+}
+
+func iterMakerETFloat32String(s ReStream) ReusableInput {
+	ret := &iterNative{s: s}
+	ret.fn = reflect.ValueOf(ret.readETFloat32String)
+	return ret
+}
+
+func (v *iterNative) readFloat32Int(key *float32, value *int) bool {
+	elm, err := v.cur.Read()
+	if err != nil {
+		if err == io.EOF {
+			return false
+		}
+		panic(fmt.Sprintf("broken stream: %v", err))
+	}
+
+	*key = elm.Elm.Interface().(float32)
+	*value = elm.Elm2.Interface().(int)
+	return true
+}
+
+func iterMakerFloat32Int(s ReStream) ReusableInput {
+	ret := &iterNative{s: s}
+	ret.fn = reflect.ValueOf(ret.readFloat32Int)
+	return ret
+}
+
+func (v *iterNative) readETFloat32Int(et *typex.EventTime, key *float32, value *int) bool {
+	elm, err := v.cur.Read()
+	if err != nil {
+		if err == io.EOF {
+			return false
+		}
+		panic(fmt.Sprintf("broken stream: %v", err))
+	}
+
+	*et = elm.Timestamp
+	*key = elm.Elm.Interface().(float32)
+	*value = elm.Elm2.Interface().(int)
+	return true
+}
+
+func iterMakerETFloat32Int(s ReStream) ReusableInput {
+	ret := &iterNative{s: s}
+	ret.fn = reflect.ValueOf(ret.readETFloat32Int)
+	return ret
+}
+
+func (v *iterNative) readFloat32Int8(key *float32, value *int8) bool {
+	elm, err := v.cur.Read()
+	if err != nil {
+		if err == io.EOF {
+			return false
+		}
+		panic(fmt.Sprintf("broken stream: %v", err))
+	}
+
+	*key = elm.Elm.Interface().(float32)
+	*value = elm.Elm2.Interface().(int8)
+	return true
+}
+
+func iterMakerFloat32Int8(s ReStream) ReusableInput {
+	ret := &iterNative{s: s}
+	ret.fn = reflect.ValueOf(ret.readFloat32Int8)
+	return ret
+}
+
+func (v *iterNative) readETFloat32Int8(et *typex.EventTime, key *float32, value *int8) bool {
+	elm, err := v.cur.Read()
+	if err != nil {
+		if err == io.EOF {
+			return false
+		}
+		panic(fmt.Sprintf("broken stream: %v", err))
+	}
+
+	*et = elm.Timestamp
+	*key = elm.Elm.Interface().(float32)
+	*value = elm.Elm2.Interface().(int8)
+	return true
+}
+
+func iterMakerETFloat32Int8(s ReStream) ReusableInput {
+	ret := &iterNative{s: s}
+	ret.fn = reflect.ValueOf(ret.readETFloat32Int8)
+	return ret
+}
+
+func (v *iterNative) readFloat32Int16(key *float32, value *int16) bool {
+	elm, err := v.cur.Read()
+	if err != nil {
+		if err == io.EOF {
+			return false
+		}
+		panic(fmt.Sprintf("broken stream: %v", err))
+	}
+
+	*key = elm.Elm.Interface().(float32)
+	*value = elm.Elm2.Interface().(int16)
+	return true
+}
+
+func iterMakerFloat32Int16(s ReStream) ReusableInput {
+	ret := &iterNative{s: s}
+	ret.fn = reflect.ValueOf(ret.readFloat32Int16)
+	return ret
+}
+
+func (v *iterNative) readETFloat32Int16(et *typex.EventTime, key *float32, value *int16) bool {
+	elm, err := v.cur.Read()
+	if err != nil {
+		if err == io.EOF {
+			return false
+		}
+		panic(fmt.Sprintf("broken stream: %v", err))
+	}
+
+	*et = elm.Timestamp
+	*key = elm.Elm.Interface().(float32)
+	*value = elm.Elm2.Interface().(int16)
+	return true
+}
+
+func iterMakerETFloat32Int16(s ReStream) ReusableInput {
+	ret := &iterNative{s: s}
+	ret.fn = reflect.ValueOf(ret.readETFloat32Int16)
+	return ret
+}
+
+func (v *iterNative) readFloat32Int32(key *float32, value *int32) bool {
+	elm, err := v.cur.Read()
+	if err != nil {
+		if err == io.EOF {
+			return false
+		}
+		panic(fmt.Sprintf("broken stream: %v", err))
+	}
+
+	*key = elm.Elm.Interface().(float32)
+	*value = elm.Elm2.Interface().(int32)
+	return true
+}
+
+func iterMakerFloat32Int32(s ReStream) ReusableInput {
+	ret := &iterNative{s: s}
+	ret.fn = reflect.ValueOf(ret.readFloat32Int32)
+	return ret
+}
+
+func (v *iterNative) readETFloat32Int32(et *typex.EventTime, key *float32, value *int32) bool {
+	elm, err := v.cur.Read()
+	if err != nil {
+		if err == io.EOF {
+			return false
+		}
+		panic(fmt.Sprintf("broken stream: %v", err))
+	}
+
+	*et = elm.Timestamp
+	*key = elm.Elm.Interface().(float32)
+	*value = elm.Elm2.Interface().(int32)
+	return true
+}
+
+func iterMakerETFloat32Int32(s ReStream) ReusableInput {
+	ret := &iterNative{s: s}
+	ret.fn = reflect.ValueOf(ret.readETFloat32Int32)
+	return ret
+}
+
+func (v *iterNative) readFloat32Int64(key *float32, value *int64) bool {
+	elm, err := v.cur.Read()
+	if err != nil {
+		if err == io.EOF {
+			return false
+		}
+		panic(fmt.Sprintf("broken stream: %v", err))
+	}
+
+	*key = elm.Elm.Interface().(float32)
+	*value = elm.Elm2.Interface().(int64)
+	return true
+}
+
+func iterMakerFloat32Int64(s ReStream) ReusableInput {
+	ret := &iterNative{s: s}
+	ret.fn = reflect.ValueOf(ret.readFloat32Int64)
+	return ret
+}
+
+func (v *iterNative) readETFloat32Int64(et *typex.EventTime, key *float32, value *int64) bool {
+	elm, err := v.cur.Read()
+	if err != nil {
+		if err == io.EOF {
+			return false
+		}
+		panic(fmt.Sprintf("broken stream: %v", err))
+	}
+
+	*et = elm.Timestamp
+	*key = elm.Elm.Interface().(float32)
+	*value = elm.Elm2.Interface().(int64)
+	return true
+}
+
+func iterMakerETFloat32Int64(s ReStream) ReusableInput {
+	ret := &iterNative{s: s}
+	ret.fn = reflect.ValueOf(ret.readETFloat32Int64)
+	return ret
+}
+
+func (v *iterNative) readFloat32Uint(key *float32, value *uint) bool {
+	elm, err := v.cur.Read()
+	if err != nil {
+		if err == io.EOF {
+			return false
+		}
+		panic(fmt.Sprintf("broken stream: %v", err))
+	}
+
+	*key = elm.Elm.Interface().(float32)
+	*value = elm.Elm2.Interface().(uint)
+	return true
+}
+
+func iterMakerFloat32Uint(s ReStream) ReusableInput {
+	ret := &iterNative{s: s}
+	ret.fn = reflect.ValueOf(ret.readFloat32Uint)
+	return ret
+}
+
+func (v *iterNative) readETFloat32Uint(et *typex.EventTime, key *float32, value *uint) bool {
+	elm, err := v.cur.Read()
+	if err != nil {
+		if err == io.EOF {
+			return false
+		}
+		panic(fmt.Sprintf("broken stream: %v", err))
+	}
+
+	*et = elm.Timestamp
+	*key = elm.Elm.Interface().(float32)
+	*value = elm.Elm2.Interface().(uint)
+	return true
+}
+
+func iterMakerETFloat32Uint(s ReStream) ReusableInput {
+	ret := &iterNative{s: s}
+	ret.fn = reflect.ValueOf(ret.readETFloat32Uint)
+	return ret
+}
+
+func (v *iterNative) readFloat32Uint8(key *float32, value *uint8) bool {
+	elm, err := v.cur.Read()
+	if err != nil {
+		if err == io.EOF {
+			return false
+		}
+		panic(fmt.Sprintf("broken stream: %v", err))
+	}
+
+	*key = elm.Elm.Interface().(float32)
+	*value = elm.Elm2.Interface().(uint8)
+	return true
+}
+
+func iterMakerFloat32Uint8(s ReStream) ReusableInput {
+	ret := &iterNative{s: s}
+	ret.fn = reflect.ValueOf(ret.readFloat32Uint8)
+	return ret
+}
+
+func (v *iterNative) readETFloat32Uint8(et *typex.EventTime, key *float32, value *uint8) bool {
+	elm, err := v.cur.Read()
+	if err != nil {
+		if err == io.EOF {
+			return false
+		}
+		panic(fmt.Sprintf("broken stream: %v", err))
+	}
+
+	*et = elm.Timestamp
+	*key = elm.Elm.Interface().(float32)
+	*value = elm.Elm2.Interface().(uint8)
+	return true
+}
+
+func iterMakerETFloat32Uint8(s ReStream) ReusableInput {
+	ret := &iterNative{s: s}
+	ret.fn = reflect.ValueOf(ret.readETFloat32Uint8)
+	return ret
+}
+
+func (v *iterNative) readFloat32Uint16(key *float32, value *uint16) bool {
+	elm, err := v.cur.Read()
+	if err != nil {
+		if err == io.EOF {
+			return false
+		}
+		panic(fmt.Sprintf("broken stream: %v", err))
+	}
+
+	*key = elm.Elm.Interface().(float32)
+	*value = elm.Elm2.Interface().(uint16)
+	return true
+}
+
+func iterMakerFloat32Uint16(s ReStream) ReusableInput {
+	ret := &iterNative{s: s}
+	ret.fn = reflect.ValueOf(ret.readFloat32Uint16)
+	return ret
+}
+
+func (v *iterNative) readETFloat32Uint16(et *typex.EventTime, key *float32, value *uint16) bool {
+	elm, err := v.cur.Read()
+	if err != nil {
+		if err == io.EOF {
+			return false
+		}
+		panic(fmt.Sprintf("broken stream: %v", err))
+	}
+
+	*et = elm.Timestamp
+	*key = elm.Elm.Interface().(float32)
+	*value = elm.Elm2.Interface().(uint16)
+	return true
+}
+
+func iterMakerETFloat32Uint16(s ReStream) ReusableInput {
+	ret := &iterNative{s: s}
+	ret.fn = reflect.ValueOf(ret.readETFloat32Uint16)
+	return ret
+}
+
+func (v *iterNative) readFloat32Uint32(key *float32, value *uint32) bool {
+	elm, err := v.cur.Read()
+	if err != nil {
+		if err == io.EOF {
+			return false
+		}
+		panic(fmt.Sprintf("broken stream: %v", err))
+	}
+
+	*key = elm.Elm.Interface().(float32)
+	*value = elm.Elm2.Interface().(uint32)
+	return true
+}
+
+func iterMakerFloat32Uint32(s ReStream) ReusableInput {
+	ret := &iterNative{s: s}
+	ret.fn = reflect.ValueOf(ret.readFloat32Uint32)
+	return ret
+}
+
+func (v *iterNative) readETFloat32Uint32(et *typex.EventTime, key *float32, value *uint32) bool {
+	elm, err := v.cur.Read()
+	if err != nil {
+		if err == io.EOF {
+			return false
+		}
+		panic(fmt.Sprintf("broken stream: %v", err))
+	}
+
+	*et = elm.Timestamp
+	*key = elm.Elm.Interface().(float32)
+	*value = elm.Elm2.Interface().(uint32)
+	return true
+}
+
+func iterMakerETFloat32Uint32(s ReStream) ReusableInput {
+	ret := &iterNative{s: s}
+	ret.fn = reflect.ValueOf(ret.readETFloat32Uint32)
+	return ret
+}
+
+func (v *iterNative) readFloat32Uint64(key *float32, value *uint64) bool {
+	elm, err := v.cur.Read()
+	if err != nil {
+		if err == io.EOF {
+			return false
+		}
+		panic(fmt.Sprintf("broken stream: %v", err))
+	}
+
+	*key = elm.Elm.Interface().(float32)
+	*value = elm.Elm2.Interface().(uint64)
+	return true
+}
+
+func iterMakerFloat32Uint64(s ReStream) ReusableInput {
+	ret := &iterNative{s: s}
+	ret.fn = reflect.ValueOf(ret.readFloat32Uint64)
+	return ret
+}
+
+func (v *iterNative) readETFloat32Uint64(et *typex.EventTime, key *float32, value *uint64) bool {
+	elm, err := v.cur.Read()
+	if err != nil {
+		if err == io.EOF {
+			return false
+		}
+		panic(fmt.Sprintf("broken stream: %v", err))
+	}
+
+	*et = elm.Timestamp
+	*key = elm.Elm.Interface().(float32)
+	*value = elm.Elm2.Interface().(uint64)
+	return true
+}
+
+func iterMakerETFloat32Uint64(s ReStream) ReusableInput {
+	ret := &iterNative{s: s}
+	ret.fn = reflect.ValueOf(ret.readETFloat32Uint64)
+	return ret
+}
+
+func (v *iterNative) readFloat32Float32(key *float32, value *float32) bool {
+	elm, err := v.cur.Read()
+	if err != nil {
+		if err == io.EOF {
+			return false
+		}
+		panic(fmt.Sprintf("broken stream: %v", err))
+	}
+
+	*key = elm.Elm.Interface().(float32)
+	*value = elm.Elm2.Interface().(float32)
+	return true
+}
+
+func iterMakerFloat32Float32(s ReStream) ReusableInput {
+	ret := &iterNative{s: s}
+	ret.fn = reflect.ValueOf(ret.readFloat32Float32)
+	return ret
+}
+
+func (v *iterNative) readETFloat32Float32(et *typex.EventTime, key *float32, value *float32) bool {
+	elm, err := v.cur.Read()
+	if err != nil {
+		if err == io.EOF {
+			return false
+		}
+		panic(fmt.Sprintf("broken stream: %v", err))
+	}
+
+	*et = elm.Timestamp
+	*key = elm.Elm.Interface().(float32)
+	*value = elm.Elm2.Interface().(float32)
+	return true
+}
+
+func iterMakerETFloat32Float32(s ReStream) ReusableInput {
+	ret := &iterNative{s: s}
+	ret.fn = reflect.ValueOf(ret.readETFloat32Float32)
+	return ret
+}
+
+func (v *iterNative) readFloat32Float64(key *float32, value *float64) bool {
+	elm, err := v.cur.Read()
+	if err != nil {
+		if err == io.EOF {
+			return false
+		}
+		panic(fmt.Sprintf("broken stream: %v", err))
+	}
+
+	*key = elm.Elm.Interface().(float32)
+	*value = elm.Elm2.Interface().(float64)
+	return true
+}
+
+func iterMakerFloat32Float64(s ReStream) ReusableInput {
+	ret := &iterNative{s: s}
+	ret.fn = reflect.ValueOf(ret.readFloat32Float64)
+	return ret
+}
+
+func (v *iterNative) readETFloat32Float64(et *typex.EventTime, key *float32, value *float64) bool {
+	elm, err := v.cur.Read()
+	if err != nil {
+		if err == io.EOF {
+			return false
+		}
+		panic(fmt.Sprintf("broken stream: %v", err))
+	}
+
+	*et = elm.Timestamp
+	*key = elm.Elm.Interface().(float32)
+	*value = elm.Elm2.Interface().(float64)
+	return true
+}
+
+func iterMakerETFloat32Float64(s ReStream) ReusableInput {
+	ret := &iterNative{s: s}
+	ret.fn = reflect.ValueOf(ret.readETFloat32Float64)
+	return ret
+}
+
+func (v *iterNative) readFloat32Typex_T(key *float32, value *typex.T) bool {
+	elm, err := v.cur.Read()
+	if err != nil {
+		if err == io.EOF {
+			return false
+		}
+		panic(fmt.Sprintf("broken stream: %v", err))
+	}
+
+	*key = elm.Elm.Interface().(float32)
+	*value = elm.Elm2.Interface().(typex.T)
+	return true
+}
+
+func iterMakerFloat32Typex_T(s ReStream) ReusableInput {
+	ret := &iterNative{s: s}
+	ret.fn = reflect.ValueOf(ret.readFloat32Typex_T)
+	return ret
+}
+
+func (v *iterNative) readETFloat32Typex_T(et *typex.EventTime, key *float32, value *typex.T) bool {
+	elm, err := v.cur.Read()
+	if err != nil {
+		if err == io.EOF {
+			return false
+		}
+		panic(fmt.Sprintf("broken stream: %v", err))
+	}
+
+	*et = elm.Timestamp
+	*key = elm.Elm.Interface().(float32)
+	*value = elm.Elm2.Interface().(typex.T)
+	return true
+}
+
+func iterMakerETFloat32Typex_T(s ReStream) ReusableInput {
+	ret := &iterNative{s: s}
+	ret.fn = reflect.ValueOf(ret.readETFloat32Typex_T)
+	return ret
+}
+
+func (v *iterNative) readFloat32Typex_U(key *float32, value *typex.U) bool {
+	elm, err := v.cur.Read()
+	if err != nil {
+		if err == io.EOF {
+			return false
+		}
+		panic(fmt.Sprintf("broken stream: %v", err))
+	}
+
+	*key = elm.Elm.Interface().(float32)
+	*value = elm.Elm2.Interface().(typex.U)
+	return true
+}
+
+func iterMakerFloat32Typex_U(s ReStream) ReusableInput {
+	ret := &iterNative{s: s}
+	ret.fn = reflect.ValueOf(ret.readFloat32Typex_U)
+	return ret
+}
+
+func (v *iterNative) readETFloat32Typex_U(et *typex.EventTime, key *float32, value *typex.U) bool {
+	elm, err := v.cur.Read()
+	if err != nil {
+		if err == io.EOF {
+			return false
+		}
+		panic(fmt.Sprintf("broken stream: %v", err))
+	}
+
+	*et = elm.Timestamp
+	*key = elm.Elm.Interface().(float32)
+	*value = elm.Elm2.Interface().(typex.U)
+	return true
+}
+
+func iterMakerETFloat32Typex_U(s ReStream) ReusableInput {
+	ret := &iterNative{s: s}
+	ret.fn = reflect.ValueOf(ret.readETFloat32Typex_U)
+	return ret
+}
+
+func (v *iterNative) readFloat32Typex_V(key *float32, value *typex.V) bool {
+	elm, err := v.cur.Read()
+	if err != nil {
+		if err == io.EOF {
+			return false
+		}
+		panic(fmt.Sprintf("broken stream: %v", err))
+	}
+
+	*key = elm.Elm.Interface().(float32)
+	*value = elm.Elm2.Interface().(typex.V)
+	return true
+}
+
+func iterMakerFloat32Typex_V(s ReStream) ReusableInput {
+	ret := &iterNative{s: s}
+	ret.fn = reflect.ValueOf(ret.readFloat32Typex_V)
+	return ret
+}
+
+func (v *iterNative) readETFloat32Typex_V(et *typex.EventTime, key *float32, value *typex.V) bool {
+	elm, err := v.cur.Read()
+	if err != nil {
+		if err == io.EOF {
+			return false
+		}
+		panic(fmt.Sprintf("broken stream: %v", err))
+	}
+
+	*et = elm.Timestamp
+	*key = elm.Elm.Interface().(float32)
+	*value = elm.Elm2.Interface().(typex.V)
+	return true
+}
+
+func iterMakerETFloat32Typex_V(s ReStream) ReusableInput {
+	ret := &iterNative{s: s}
+	ret.fn = reflect.ValueOf(ret.readETFloat32Typex_V)
+	return ret
+}
+
+func (v *iterNative) readFloat32Typex_W(key *float32, value *typex.W) bool {
+	elm, err := v.cur.Read()
+	if err != nil {
+		if err == io.EOF {
+			return false
+		}
+		panic(fmt.Sprintf("broken stream: %v", err))
+	}
+
+	*key = elm.Elm.Interface().(float32)
+	*value = elm.Elm2.Interface().(typex.W)
+	return true
+}
+
+func iterMakerFloat32Typex_W(s ReStream) ReusableInput {
+	ret := &iterNative{s: s}
+	ret.fn = reflect.ValueOf(ret.readFloat32Typex_W)
+	return ret
+}
+
+func (v *iterNative) readETFloat32Typex_W(et *typex.EventTime, key *float32, value *typex.W) bool {
+	elm, err := v.cur.Read()
+	if err != nil {
+		if err == io.EOF {
+			return false
+		}
+		panic(fmt.Sprintf("broken stream: %v", err))
+	}
+
+	*et = elm.Timestamp
+	*key = elm.Elm.Interface().(float32)
+	*value = elm.Elm2.Interface().(typex.W)
+	return true
+}
+
+func iterMakerETFloat32Typex_W(s ReStream) ReusableInput {
+	ret := &iterNative{s: s}
+	ret.fn = reflect.ValueOf(ret.readETFloat32Typex_W)
+	return ret
+}
+
+func (v *iterNative) readFloat32Typex_X(key *float32, value *typex.X) bool {
+	elm, err := v.cur.Read()
+	if err != nil {
+		if err == io.EOF {
+			return false
+		}
+		panic(fmt.Sprintf("broken stream: %v", err))
+	}
+
+	*key = elm.Elm.Interface().(float32)
+	*value = elm.Elm2.Interface().(typex.X)
+	return true
+}
+
+func iterMakerFloat32Typex_X(s ReStream) ReusableInput {
+	ret := &iterNative{s: s}
+	ret.fn = reflect.ValueOf(ret.readFloat32Typex_X)
+	return ret
+}
+
+func (v *iterNative) readETFloat32Typex_X(et *typex.EventTime, key *float32, value *typex.X) bool {
+	elm, err := v.cur.Read()
+	if err != nil {
+		if err == io.EOF {
+			return false
+		}
+		panic(fmt.Sprintf("broken stream: %v", err))
+	}
+
+	*et = elm.Timestamp
+	*key = elm.Elm.Interface().(float32)
+	*value = elm.Elm2.Interface().(typex.X)
+	return true
+}
+
+func iterMakerETFloat32Typex_X(s ReStream) ReusableInput {
+	ret := &iterNative{s: s}
+	ret.fn = reflect.ValueOf(ret.readETFloat32Typex_X)
+	return ret
+}
+
+func (v *iterNative) readFloat32Typex_Y(key *float32, value *typex.Y) bool {
+	elm, err := v.cur.Read()
+	if err != nil {
+		if err == io.EOF {
+			return false
+		}
+		panic(fmt.Sprintf("broken stream: %v", err))
+	}
+
+	*key = elm.Elm.Interface().(float32)
+	*value = elm.Elm2.Interface().(typex.Y)
+	return true
+}
+
+func iterMakerFloat32Typex_Y(s ReStream) ReusableInput {
+	ret := &iterNative{s: s}
+	ret.fn = reflect.ValueOf(ret.readFloat32Typex_Y)
+	return ret
+}
+
+func (v *iterNative) readETFloat32Typex_Y(et *typex.EventTime, key *float32, value *typex.Y) bool {
+	elm, err := v.cur.Read()
+	if err != nil {
+		if err == io.EOF {
+			return false
+		}
+		panic(fmt.Sprintf("broken stream: %v", err))
+	}
+
+	*et = elm.Timestamp
+	*key = elm.Elm.Interface().(float32)
+	*value = elm.Elm2.Interface().(typex.Y)
+	return true
+}
+
+func iterMakerETFloat32Typex_Y(s ReStream) ReusableInput {
+	ret := &iterNative{s: s}
+	ret.fn = reflect.ValueOf(ret.readETFloat32Typex_Y)
+	return ret
+}
+
+func (v *iterNative) readFloat32Typex_Z(key *float32, value *typex.Z) bool {
+	elm, err := v.cur.Read()
+	if err != nil {
+		if err == io.EOF {
+			return false
+		}
+		panic(fmt.Sprintf("broken stream: %v", err))
+	}
+
+	*key = elm.Elm.Interface().(float32)
+	*value = elm.Elm2.Interface().(typex.Z)
+	return true
+}
+
+func iterMakerFloat32Typex_Z(s ReStream) ReusableInput {
+	ret := &iterNative{s: s}
+	ret.fn = reflect.ValueOf(ret.readFloat32Typex_Z)
+	return ret
+}
+
+func (v *iterNative) readETFloat32Typex_Z(et *typex.EventTime, key *float32, value *typex.Z) bool {
+	elm, err := v.cur.Read()
+	if err != nil {
+		if err == io.EOF {
+			return false
+		}
+		panic(fmt.Sprintf("broken stream: %v", err))
+	}
+
+	*et = elm.Timestamp
+	*key = elm.Elm.Interface().(float32)
+	*value = elm.Elm2.Interface().(typex.Z)
+	return true
+}
+
+func iterMakerETFloat32Typex_Z(s ReStream) ReusableInput {
+	ret := &iterNative{s: s}
+	ret.fn = reflect.ValueOf(ret.readETFloat32Typex_Z)
+	return ret
+}
+
+func (v *iterNative) readFloat64(val *float64) bool {
+	elm, err := v.cur.Read()
+	if err != nil {
+		if err == io.EOF {
+			return false
+		}
+		panic(fmt.Sprintf("broken stream: %v", err))
+	}
+
+	*val = elm.Elm.Interface().(float64)
+	return true
+}
+
+func iterMakerFloat64(s ReStream) ReusableInput {
+	ret := &iterNative{s: s}
+	ret.fn = reflect.ValueOf(ret.readFloat64)
+	return ret
+}
+
+func (v *iterNative) readETFloat64(et *typex.EventTime, val *float64) bool {
+	elm, err := v.cur.Read()
+	if err != nil {
+		if err == io.EOF {
+			return false
+		}
+		panic(fmt.Sprintf("broken stream: %v", err))
+	}
+
+	*et = elm.Timestamp
+	*val = elm.Elm.Interface().(float64)
+	return true
+}
+
+func iterMakerETFloat64(s ReStream) ReusableInput {
+	ret := &iterNative{s: s}
+	ret.fn = reflect.ValueOf(ret.readETFloat64)
+	return ret
+}
+
+func (v *iterNative) readFloat64ByteSlice(key *float64, value *[]byte) bool {
+	elm, err := v.cur.Read()
+	if err != nil {
+		if err == io.EOF {
+			return false
+		}
+		panic(fmt.Sprintf("broken stream: %v", err))
+	}
+
+	*key = elm.Elm.Interface().(float64)
+	*value = elm.Elm2.Interface().([]byte)
+	return true
+}
+
+func iterMakerFloat64ByteSlice(s ReStream) ReusableInput {
+	ret := &iterNative{s: s}
+	ret.fn = reflect.ValueOf(ret.readFloat64ByteSlice)
+	return ret
+}
+
+func (v *iterNative) readETFloat64ByteSlice(et *typex.EventTime, key *float64, value *[]byte) bool {
+	elm, err := v.cur.Read()
+	if err != nil {
+		if err == io.EOF {
+			return false
+		}
+		panic(fmt.Sprintf("broken stream: %v", err))
+	}
+
+	*et = elm.Timestamp
+	*key = elm.Elm.Interface().(float64)
+	*value = elm.Elm2.Interface().([]byte)
+	return true
+}
+
+func iterMakerETFloat64ByteSlice(s ReStream) ReusableInput {
+	ret := &iterNative{s: s}
+	ret.fn = reflect.ValueOf(ret.readETFloat64ByteSlice)
+	return ret
+}
+
+func (v *iterNative) readFloat64Bool(key *float64, value *bool) bool {
+	elm, err := v.cur.Read()
+	if err != nil {
+		if err == io.EOF {
+			return false
+		}
+		panic(fmt.Sprintf("broken stream: %v", err))
+	}
+
+	*key = elm.Elm.Interface().(float64)
+	*value = elm.Elm2.Interface().(bool)
+	return true
+}
+
+func iterMakerFloat64Bool(s ReStream) ReusableInput {
+	ret := &iterNative{s: s}
+	ret.fn = reflect.ValueOf(ret.readFloat64Bool)
+	return ret
+}
+
+func (v *iterNative) readETFloat64Bool(et *typex.EventTime, key *float64, value *bool) bool {
+	elm, err := v.cur.Read()
+	if err != nil {
+		if err == io.EOF {
+			return false
+		}
+		panic(fmt.Sprintf("broken stream: %v", err))
+	}
+
+	*et = elm.Timestamp
+	*key = elm.Elm.Interface().(float64)
+	*value = elm.Elm2.Interface().(bool)
+	return true
+}
+
+func iterMakerETFloat64Bool(s ReStream) ReusableInput {
+	ret := &iterNative{s: s}
+	ret.fn = reflect.ValueOf(ret.readETFloat64Bool)
+	return ret
+}
+
+func (v *iterNative) readFloat64String(key *float64, value *string) bool {
+	elm, err := v.cur.Read()
+	if err != nil {
+		if err == io.EOF {
+			return false
+		}
+		panic(fmt.Sprintf("broken stream: %v", err))
+	}
+
+	*key = elm.Elm.Interface().(float64)
+	*value = elm.Elm2.Interface().(string)
+	return true
+}
+
+func iterMakerFloat64String(s ReStream) ReusableInput {
+	ret := &iterNative{s: s}
+	ret.fn = reflect.ValueOf(ret.readFloat64String)
+	return ret
+}
+
+func (v *iterNative) readETFloat64String(et *typex.EventTime, key *float64, value *string) bool {
+	elm, err := v.cur.Read()
+	if err != nil {
+		if err == io.EOF {
+			return false
+		}
+		panic(fmt.Sprintf("broken stream: %v", err))
+	}
+
+	*et = elm.Timestamp
+	*key = elm.Elm.Interface().(float64)
+	*value = elm.Elm2.Interface().(string)
+	return true
+}
+
+func iterMakerETFloat64String(s ReStream) ReusableInput {
+	ret := &iterNative{s: s}
+	ret.fn = reflect.ValueOf(ret.readETFloat64String)
+	return ret
+}
+
+func (v *iterNative) readFloat64Int(key *float64, value *int) bool {
+	elm, err := v.cur.Read()
+	if err != nil {
+		if err == io.EOF {
+			return false
+		}
+		panic(fmt.Sprintf("broken stream: %v", err))
+	}
+
+	*key = elm.Elm.Interface().(float64)
+	*value = elm.Elm2.Interface().(int)
+	return true
+}
+
+func iterMakerFloat64Int(s ReStream) ReusableInput {
+	ret := &iterNative{s: s}
+	ret.fn = reflect.ValueOf(ret.readFloat64Int)
+	return ret
+}
+
+func (v *iterNative) readETFloat64Int(et *typex.EventTime, key *float64, value *int) bool {
+	elm, err := v.cur.Read()
+	if err != nil {
+		if err == io.EOF {
+			return false
+		}
+		panic(fmt.Sprintf("broken stream: %v", err))
+	}
+
+	*et = elm.Timestamp
+	*key = elm.Elm.Interface().(float64)
+	*value = elm.Elm2.Interface().(int)
+	return true
+}
+
+func iterMakerETFloat64Int(s ReStream) ReusableInput {
+	ret := &iterNative{s: s}
+	ret.fn = reflect.ValueOf(ret.readETFloat64Int)
+	return ret
+}
+
+func (v *iterNative) readFloat64Int8(key *float64, value *int8) bool {
+	elm, err := v.cur.Read()
+	if err != nil {
+		if err == io.EOF {
+			return false
+		}
+		panic(fmt.Sprintf("broken stream: %v", err))
+	}
+
+	*key = elm.Elm.Interface().(float64)
+	*value = elm.Elm2.Interface().(int8)
+	return true
+}
+
+func iterMakerFloat64Int8(s ReStream) ReusableInput {
+	ret := &iterNative{s: s}
+	ret.fn = reflect.ValueOf(ret.readFloat64Int8)
+	return ret
+}
+
+func (v *iterNative) readETFloat64Int8(et *typex.EventTime, key *float64, value *int8) bool {
+	elm, err := v.cur.Read()
+	if err != nil {
+		if err == io.EOF {
+			return false
+		}
+		panic(fmt.Sprintf("broken stream: %v", err))
+	}
+
+	*et = elm.Timestamp
+	*key = elm.Elm.Interface().(float64)
+	*value = elm.Elm2.Interface().(int8)
+	return true
+}
+
+func iterMakerETFloat64Int8(s ReStream) ReusableInput {
+	ret := &iterNative{s: s}
+	ret.fn = reflect.ValueOf(ret.readETFloat64Int8)
+	return ret
+}
+
+func (v *iterNative) readFloat64Int16(key *float64, value *int16) bool {
+	elm, err := v.cur.Read()
+	if err != nil {
+		if err == io.EOF {
+			return false
+		}
+		panic(fmt.Sprintf("broken stream: %v", err))
+	}
+
+	*key = elm.Elm.Interface().(float64)
+	*value = elm.Elm2.Interface().(int16)
+	return true
+}
+
+func iterMakerFloat64Int16(s ReStream) ReusableInput {
+	ret := &iterNative{s: s}
+	ret.fn = reflect.ValueOf(ret.readFloat64Int16)
+	return ret
+}
+
+func (v *iterNative) readETFloat64Int16(et *typex.EventTime, key *float64, value *int16) bool {
+	elm, err := v.cur.Read()
+	if err != nil {
+		if err == io.EOF {
+			return false
+		}
+		panic(fmt.Sprintf("broken stream: %v", err))
+	}
+
+	*et = elm.Timestamp
+	*key = elm.Elm.Interface().(float64)
+	*value = elm.Elm2.Interface().(int16)
+	return true
+}
+
+func iterMakerETFloat64Int16(s ReStream) ReusableInput {
+	ret := &iterNative{s: s}
+	ret.fn = reflect.ValueOf(ret.readETFloat64Int16)
+	return ret
+}
+
+func (v *iterNative) readFloat64Int32(key *float64, value *int32) bool {
+	elm, err := v.cur.Read()
+	if err != nil {
+		if err == io.EOF {
+			return false
+		}
+		panic(fmt.Sprintf("broken stream: %v", err))
+	}
+
+	*key = elm.Elm.Interface().(float64)
+	*value = elm.Elm2.Interface().(int32)
+	return true
+}
+
+func iterMakerFloat64Int32(s ReStream) ReusableInput {
+	ret := &iterNative{s: s}
+	ret.fn = reflect.ValueOf(ret.readFloat64Int32)
+	return ret
+}
+
+func (v *iterNative) readETFloat64Int32(et *typex.EventTime, key *float64, value *int32) bool {
+	elm, err := v.cur.Read()
+	if err != nil {
+		if err == io.EOF {
+			return false
+		}
+		panic(fmt.Sprintf("broken stream: %v", err))
+	}
+
+	*et = elm.Timestamp
+	*key = elm.Elm.Interface().(float64)
+	*value = elm.Elm2.Interface().(int32)
+	return true
+}
+
+func iterMakerETFloat64Int32(s ReStream) ReusableInput {
+	ret := &iterNative{s: s}
+	ret.fn = reflect.ValueOf(ret.readETFloat64Int32)
+	return ret
+}
+
+func (v *iterNative) readFloat64Int64(key *float64, value *int64) bool {
+	elm, err := v.cur.Read()
+	if err != nil {
+		if err == io.EOF {
+			return false
+		}
+		panic(fmt.Sprintf("broken stream: %v", err))
+	}
+
+	*key = elm.Elm.Interface().(float64)
+	*value = elm.Elm2.Interface().(int64)
+	return true
+}
+
+func iterMakerFloat64Int64(s ReStream) ReusableInput {
+	ret := &iterNative{s: s}
+	ret.fn = reflect.ValueOf(ret.readFloat64Int64)
+	return ret
+}
+
+func (v *iterNative) readETFloat64Int64(et *typex.EventTime, key *float64, value *int64) bool {
+	elm, err := v.cur.Read()
+	if err != nil {
+		if err == io.EOF {
+			return false
+		}
+		panic(fmt.Sprintf("broken stream: %v", err))
+	}
+
+	*et = elm.Timestamp
+	*key = elm.Elm.Interface().(float64)
+	*value = elm.Elm2.Interface().(int64)
+	return true
+}
+
+func iterMakerETFloat64Int64(s ReStream) ReusableInput {
+	ret := &iterNative{s: s}
+	ret.fn = reflect.ValueOf(ret.readETFloat64Int64)
+	return ret
+}
+
+func (v *iterNative) readFloat64Uint(key *float64, value *uint) bool {
+	elm, err := v.cur.Read()
+	if err != nil {
+		if err == io.EOF {
+			return false
+		}
+		panic(fmt.Sprintf("broken stream: %v", err))
+	}
+
+	*key = elm.Elm.Interface().(float64)
+	*value = elm.Elm2.Interface().(uint)
+	return true
+}
+
+func iterMakerFloat64Uint(s ReStream) ReusableInput {
+	ret := &iterNative{s: s}
+	ret.fn = reflect.ValueOf(ret.readFloat64Uint)
+	return ret
+}
+
+func (v *iterNative) readETFloat64Uint(et *typex.EventTime, key *float64, value *uint) bool {
+	elm, err := v.cur.Read()
+	if err != nil {
+		if err == io.EOF {
+			return false
+		}
+		panic(fmt.Sprintf("broken stream: %v", err))
+	}
+
+	*et = elm.Timestamp
+	*key = elm.Elm.Interface().(float64)
+	*value = elm.Elm2.Interface().(uint)
+	return true
+}
+
+func iterMakerETFloat64Uint(s ReStream) ReusableInput {
+	ret := &iterNative{s: s}
+	ret.fn = reflect.ValueOf(ret.readETFloat64Uint)
+	return ret
+}
+
+func (v *iterNative) readFloat64Uint8(key *float64, value *uint8) bool {
+	elm, err := v.cur.Read()
+	if err != nil {
+		if err == io.EOF {
+			return false
+		}
+		panic(fmt.Sprintf("broken stream: %v", err))
+	}
+
+	*key = elm.Elm.Interface().(float64)
+	*value = elm.Elm2.Interface().(uint8)
+	return true
+}
+
+func iterMakerFloat64Uint8(s ReStream) ReusableInput {
+	ret := &iterNative{s: s}
+	ret.fn = reflect.ValueOf(ret.readFloat64Uint8)
+	return ret
+}
+
+func (v *iterNative) readETFloat64Uint8(et *typex.EventTime, key *float64, value *uint8) bool {
+	elm, err := v.cur.Read()
+	if err != nil {
+		if err == io.EOF {
+			return false
+		}
+		panic(fmt.Sprintf("broken stream: %v", err))
+	}
+
+	*et = elm.Timestamp
+	*key = elm.Elm.Interface().(float64)
+	*value = elm.Elm2.Interface().(uint8)
+	return true
+}
+
+func iterMakerETFloat64Uint8(s ReStream) ReusableInput {
+	ret := &iterNative{s: s}
+	ret.fn = reflect.ValueOf(ret.readETFloat64Uint8)
+	return ret
+}
+
+func (v *iterNative) readFloat64Uint16(key *float64, value *uint16) bool {
+	elm, err := v.cur.Read()
+	if err != nil {
+		if err == io.EOF {
+			return false
+		}
+		panic(fmt.Sprintf("broken stream: %v", err))
+	}
+
+	*key = elm.Elm.Interface().(float64)
+	*value = elm.Elm2.Interface().(uint16)
+	return true
+}
+
+func iterMakerFloat64Uint16(s ReStream) ReusableInput {
+	ret := &iterNative{s: s}
+	ret.fn = reflect.ValueOf(ret.readFloat64Uint16)
+	return ret
+}
+
+func (v *iterNative) readETFloat64Uint16(et *typex.EventTime, key *float64, value *uint16) bool {
+	elm, err := v.cur.Read()
+	if err != nil {
+		if err == io.EOF {
+			return false
+		}
+		panic(fmt.Sprintf("broken stream: %v", err))
+	}
+
+	*et = elm.Timestamp
+	*key = elm.Elm.Interface().(float64)
+	*value = elm.Elm2.Interface().(uint16)
+	return true
+}
+
+func iterMakerETFloat64Uint16(s ReStream) ReusableInput {
+	ret := &iterNative{s: s}
+	ret.fn = reflect.ValueOf(ret.readETFloat64Uint16)
+	return ret
+}
+
+func (v *iterNative) readFloat64Uint32(key *float64, value *uint32) bool {
+	elm, err := v.cur.Read()
+	if err != nil {
+		if err == io.EOF {
+			return false
+		}
+		panic(fmt.Sprintf("broken stream: %v", err))
+	}
+
+	*key = elm.Elm.Interface().(float64)
+	*value = elm.Elm2.Interface().(uint32)
+	return true
+}
+
+func iterMakerFloat64Uint32(s ReStream) ReusableInput {
+	ret := &iterNative{s: s}
+	ret.fn = reflect.ValueOf(ret.readFloat64Uint32)
+	return ret
+}
+
+func (v *iterNative) readETFloat64Uint32(et *typex.EventTime, key *float64, value *uint32) bool {
+	elm, err := v.cur.Read()
+	if err != nil {
+		if err == io.EOF {
+			return false
+		}
+		panic(fmt.Sprintf("broken stream: %v", err))
+	}
+
+	*et = elm.Timestamp
+	*key = elm.Elm.Interface().(float64)
+	*value = elm.Elm2.Interface().(uint32)
+	return true
+}
+
+func iterMakerETFloat64Uint32(s ReStream) ReusableInput {
+	ret := &iterNative{s: s}
+	ret.fn = reflect.ValueOf(ret.readETFloat64Uint32)
+	return ret
+}
+
+func (v *iterNative) readFloat64Uint64(key *float64, value *uint64) bool {
+	elm, err := v.cur.Read()
+	if err != nil {
+		if err == io.EOF {
+			return false
+		}
+		panic(fmt.Sprintf("broken stream: %v", err))
+	}
+
+	*key = elm.Elm.Interface().(float64)
+	*value = elm.Elm2.Interface().(uint64)
+	return true
+}
+
+func iterMakerFloat64Uint64(s ReStream) ReusableInput {
+	ret := &iterNative{s: s}
+	ret.fn = reflect.ValueOf(ret.readFloat64Uint64)
+	return ret
+}
+
+func (v *iterNative) readETFloat64Uint64(et *typex.EventTime, key *float64, value *uint64) bool {
+	elm, err := v.cur.Read()
+	if err != nil {
+		if err == io.EOF {
+			return false
+		}
+		panic(fmt.Sprintf("broken stream: %v", err))
+	}
+
+	*et = elm.Timestamp
+	*key = elm.Elm.Interface().(float64)
+	*value = elm.Elm2.Interface().(uint64)
+	return true
+}
+
+func iterMakerETFloat64Uint64(s ReStream) ReusableInput {
+	ret := &iterNative{s: s}
+	ret.fn = reflect.ValueOf(ret.readETFloat64Uint64)
+	return ret
+}
+
+func (v *iterNative) readFloat64Float32(key *float64, value *float32) bool {
+	elm, err := v.cur.Read()
+	if err != nil {
+		if err == io.EOF {
+			return false
+		}
+		panic(fmt.Sprintf("broken stream: %v", err))
+	}
+
+	*key = elm.Elm.Interface().(float64)
+	*value = elm.Elm2.Interface().(float32)
+	return true
+}
+
+func iterMakerFloat64Float32(s ReStream) ReusableInput {
+	ret := &iterNative{s: s}
+	ret.fn = reflect.ValueOf(ret.readFloat64Float32)
+	return ret
+}
+
+func (v *iterNative) readETFloat64Float32(et *typex.EventTime, key *float64, value *float32) bool {
+	elm, err := v.cur.Read()
+	if err != nil {
+		if err == io.EOF {
+			return false
+		}
+		panic(fmt.Sprintf("broken stream: %v", err))
+	}
+
+	*et = elm.Timestamp
+	*key = elm.Elm.Interface().(float64)
+	*value = elm.Elm2.Interface().(float32)
+	return true
+}
+
+func iterMakerETFloat64Float32(s ReStream) ReusableInput {
+	ret := &iterNative{s: s}
+	ret.fn = reflect.ValueOf(ret.readETFloat64Float32)
+	return ret
+}
+
+func (v *iterNative) readFloat64Float64(key *float64, value *float64) bool {
+	elm, err := v.cur.Read()
+	if err != nil {
+		if err == io.EOF {
+			return false
+		}
+		panic(fmt.Sprintf("broken stream: %v", err))
+	}
+
+	*key = elm.Elm.Interface().(float64)
+	*value = elm.Elm2.Interface().(float64)
+	return true
+}
+
+func iterMakerFloat64Float64(s ReStream) ReusableInput {
+	ret := &iterNative{s: s}
+	ret.fn = reflect.ValueOf(ret.readFloat64Float64)
+	return ret
+}
+
+func (v *iterNative) readETFloat64Float64(et *typex.EventTime, key *float64, value *float64) bool {
+	elm, err := v.cur.Read()
+	if err != nil {
+		if err == io.EOF {
+			return false
+		}
+		panic(fmt.Sprintf("broken stream: %v", err))
+	}
+
+	*et = elm.Timestamp
+	*key = elm.Elm.Interface().(float64)
+	*value = elm.Elm2.Interface().(float64)
+	return true
+}
+
+func iterMakerETFloat64Float64(s ReStream) ReusableInput {
+	ret := &iterNative{s: s}
+	ret.fn = reflect.ValueOf(ret.readETFloat64Float64)
+	return ret
+}
+
+func (v *iterNative) readFloat64Typex_T(key *float64, value *typex.T) bool {
+	elm, err := v.cur.Read()
+	if err != nil {
+		if err == io.EOF {
+			return false
+		}
+		panic(fmt.Sprintf("broken stream: %v", err))
+	}
+
+	*key = elm.Elm.Interface().(float64)
+	*value = elm.Elm2.Interface().(typex.T)
+	return true
+}
+
+func iterMakerFloat64Typex_T(s ReStream) ReusableInput {
+	ret := &iterNative{s: s}
+	ret.fn = reflect.ValueOf(ret.readFloat64Typex_T)
+	return ret
+}
+
+func (v *iterNative) readETFloat64Typex_T(et *typex.EventTime, key *float64, value *typex.T) bool {
+	elm, err := v.cur.Read()
+	if err != nil {
+		if err == io.EOF {
+			return false
+		}
+		panic(fmt.Sprintf("broken stream: %v", err))
+	}
+
+	*et = elm.Timestamp
+	*key = elm.Elm.Interface().(float64)
+	*value = elm.Elm2.Interface().(typex.T)
+	return true
+}
+
+func iterMakerETFloat64Typex_T(s ReStream) ReusableInput {
+	ret := &iterNative{s: s}
+	ret.fn = reflect.ValueOf(ret.readETFloat64Typex_T)
+	return ret
+}
+
+func (v *iterNative) readFloat64Typex_U(key *float64, value *typex.U) bool {
+	elm, err := v.cur.Read()
+	if err != nil {
+		if err == io.EOF {
+			return false
+		}
+		panic(fmt.Sprintf("broken stream: %v", err))
+	}
+
+	*key = elm.Elm.Interface().(float64)
+	*value = elm.Elm2.Interface().(typex.U)
+	return true
+}
+
+func iterMakerFloat64Typex_U(s ReStream) ReusableInput {
+	ret := &iterNative{s: s}
+	ret.fn = reflect.ValueOf(ret.readFloat64Typex_U)
+	return ret
+}
+
+func (v *iterNative) readETFloat64Typex_U(et *typex.EventTime, key *float64, value *typex.U) bool {
+	elm, err := v.cur.Read()
+	if err != nil {
+		if err == io.EOF {
+			return false
+		}
+		panic(fmt.Sprintf("broken stream: %v", err))
+	}
+
+	*et = elm.Timestamp
+	*key = elm.Elm.Interface().(float64)
+	*value = elm.Elm2.Interface().(typex.U)
+	return true
+}
+
+func iterMakerETFloat64Typex_U(s ReStream) ReusableInput {
+	ret := &iterNative{s: s}
+	ret.fn = reflect.ValueOf(ret.readETFloat64Typex_U)
+	return ret
+}
+
+func (v *iterNative) readFloat64Typex_V(key *float64, value *typex.V) bool {
+	elm, err := v.cur.Read()
+	if err != nil {
+		if err == io.EOF {
+			return false
+		}
+		panic(fmt.Sprintf("broken stream: %v", err))
+	}
+
+	*key = elm.Elm.Interface().(float64)
+	*value = elm.Elm2.Interface().(typex.V)
+	return true
+}
+
+func iterMakerFloat64Typex_V(s ReStream) ReusableInput {
+	ret := &iterNative{s: s}
+	ret.fn = reflect.ValueOf(ret.readFloat64Typex_V)
+	return ret
+}
+
+func (v *iterNative) readETFloat64Typex_V(et *typex.EventTime, key *float64, value *typex.V) bool {
+	elm, err := v.cur.Read()
+	if err != nil {
+		if err == io.EOF {
+			return false
+		}
+		panic(fmt.Sprintf("broken stream: %v", err))
+	}
+
+	*et = elm.Timestamp
+	*key = elm.Elm.Interface().(float64)
+	*value = elm.Elm2.Interface().(typex.V)
+	return true
+}
+
+func iterMakerETFloat64Typex_V(s ReStream) ReusableInput {
+	ret := &iterNative{s: s}
+	ret.fn = reflect.ValueOf(ret.readETFloat64Typex_V)
+	return ret
+}
+
+func (v *iterNative) readFloat64Typex_W(key *float64, value *typex.W) bool {
+	elm, err := v.cur.Read()
+	if err != nil {
+		if err == io.EOF {
+			return false
+		}
+		panic(fmt.Sprintf("broken stream: %v", err))
+	}
+
+	*key = elm.Elm.Interface().(float64)
+	*value = elm.Elm2.Interface().(typex.W)
+	return true
+}
+
+func iterMakerFloat64Typex_W(s ReStream) ReusableInput {
+	ret := &iterNative{s: s}
+	ret.fn = reflect.ValueOf(ret.readFloat64Typex_W)
+	return ret
+}
+
+func (v *iterNative) readETFloat64Typex_W(et *typex.EventTime, key *float64, value *typex.W) bool {
+	elm, err := v.cur.Read()
+	if err != nil {
+		if err == io.EOF {
+			return false
+		}
+		panic(fmt.Sprintf("broken stream: %v", err))
+	}
+
+	*et = elm.Timestamp
+	*key = elm.Elm.Interface().(float64)
+	*value = elm.Elm2.Interface().(typex.W)
+	return true
+}
+
+func iterMakerETFloat64Typex_W(s ReStream) ReusableInput {
+	ret := &iterNative{s: s}
+	ret.fn = reflect.ValueOf(ret.readETFloat64Typex_W)
+	return ret
+}
+
+func (v *iterNative) readFloat64Typex_X(key *float64, value *typex.X) bool {
+	elm, err := v.cur.Read()
+	if err != nil {
+		if err == io.EOF {
+			return false
+		}
+		panic(fmt.Sprintf("broken stream: %v", err))
+	}
+
+	*key = elm.Elm.Interface().(float64)
+	*value = elm.Elm2.Interface().(typex.X)
+	return true
+}
+
+func iterMakerFloat64Typex_X(s ReStream) ReusableInput {
+	ret := &iterNative{s: s}
+	ret.fn = reflect.ValueOf(ret.readFloat64Typex_X)
+	return ret
+}
+
+func (v *iterNative) readETFloat64Typex_X(et *typex.EventTime, key *float64, value *typex.X) bool {
+	elm, err := v.cur.Read()
+	if err != nil {
+		if err == io.EOF {
+			return false
+		}
+		panic(fmt.Sprintf("broken stream: %v", err))
+	}
+
+	*et = elm.Timestamp
+	*key = elm.Elm.Interface().(float64)
+	*value = elm.Elm2.Interface().(typex.X)
+	return true
+}
+
+func iterMakerETFloat64Typex_X(s ReStream) ReusableInput {
+	ret := &iterNative{s: s}
+	ret.fn = reflect.ValueOf(ret.readETFloat64Typex_X)
+	return ret
+}
+
+func (v *iterNative) readFloat64Typex_Y(key *float64, value *typex.Y) bool {
+	elm, err := v.cur.Read()
+	if err != nil {
+		if err == io.EOF {
+			return false
+		}
+		panic(fmt.Sprintf("broken stream: %v", err))
+	}
+
+	*key = elm.Elm.Interface().(float64)
+	*value = elm.Elm2.Interface().(typex.Y)
+	return true
+}
+
+func iterMakerFloat64Typex_Y(s ReStream) ReusableInput {
+	ret := &iterNative{s: s}
+	ret.fn = reflect.ValueOf(ret.readFloat64Typex_Y)
+	return ret
+}
+
+func (v *iterNative) readETFloat64Typex_Y(et *typex.EventTime, key *float64, value *typex.Y) bool {
+	elm, err := v.cur.Read()
+	if err != nil {
+		if err == io.EOF {
+			return false
+		}
+		panic(fmt.Sprintf("broken stream: %v", err))
+	}
+
+	*et = elm.Timestamp
+	*key = elm.Elm.Interface().(float64)
+	*value = elm.Elm2.Interface().(typex.Y)
+	return true
+}
+
+func iterMakerETFloat64Typex_Y(s ReStream) ReusableInput {
+	ret := &iterNative{s: s}
+	ret.fn = reflect.ValueOf(ret.readETFloat64Typex_Y)
+	return ret
+}
+
+func (v *iterNative) readFloat64Typex_Z(key *float64, value *typex.Z) bool {
+	elm, err := v.cur.Read()
+	if err != nil {
+		if err == io.EOF {
+			return false
+		}
+		panic(fmt.Sprintf("broken stream: %v", err))
+	}
+
+	*key = elm.Elm.Interface().(float64)
+	*value = elm.Elm2.Interface().(typex.Z)
+	return true
+}
+
+func iterMakerFloat64Typex_Z(s ReStream) ReusableInput {
+	ret := &iterNative{s: s}
+	ret.fn = reflect.ValueOf(ret.readFloat64Typex_Z)
+	return ret
+}
+
+func (v *iterNative) readETFloat64Typex_Z(et *typex.EventTime, key *float64, value *typex.Z) bool {
+	elm, err := v.cur.Read()
+	if err != nil {
+		if err == io.EOF {
+			return false
+		}
+		panic(fmt.Sprintf("broken stream: %v", err))
+	}
+
+	*et = elm.Timestamp
+	*key = elm.Elm.Interface().(float64)
+	*value = elm.Elm2.Interface().(typex.Z)
+	return true
+}
+
+func iterMakerETFloat64Typex_Z(s ReStream) ReusableInput {
+	ret := &iterNative{s: s}
+	ret.fn = reflect.ValueOf(ret.readETFloat64Typex_Z)
+	return ret
+}
+
+func (v *iterNative) readTypex_T(val *typex.T) bool {
+	elm, err := v.cur.Read()
+	if err != nil {
+		if err == io.EOF {
+			return false
+		}
+		panic(fmt.Sprintf("broken stream: %v", err))
+	}
+
+	*val = elm.Elm.Interface().(typex.T)
+	return true
+}
+
+func iterMakerTypex_T(s ReStream) ReusableInput {
+	ret := &iterNative{s: s}
+	ret.fn = reflect.ValueOf(ret.readTypex_T)
+	return ret
+}
+
+func (v *iterNative) readETTypex_T(et *typex.EventTime, val *typex.T) bool {
+	elm, err := v.cur.Read()
+	if err != nil {
+		if err == io.EOF {
+			return false
+		}
+		panic(fmt.Sprintf("broken stream: %v", err))
+	}
+
+	*et = elm.Timestamp
+	*val = elm.Elm.Interface().(typex.T)
+	return true
+}
+
+func iterMakerETTypex_T(s ReStream) ReusableInput {
+	ret := &iterNative{s: s}
+	ret.fn = reflect.ValueOf(ret.readETTypex_T)
+	return ret
+}
+
+func (v *iterNative) readTypex_TByteSlice(key *typex.T, value *[]byte) bool {
+	elm, err := v.cur.Read()
+	if err != nil {
+		if err == io.EOF {
+			return false
+		}
+		panic(fmt.Sprintf("broken stream: %v", err))
+	}
+
+	*key = elm.Elm.Interface().(typex.T)
+	*value = elm.Elm2.Interface().([]byte)
+	return true
+}
+
+func iterMakerTypex_TByteSlice(s ReStream) ReusableInput {
+	ret := &iterNative{s: s}
+	ret.fn = reflect.ValueOf(ret.readTypex_TByteSlice)
+	return ret
+}
+
+func (v *iterNative) readETTypex_TByteSlice(et *typex.EventTime, key *typex.T, value *[]byte) bool {
+	elm, err := v.cur.Read()
+	if err != nil {
+		if err == io.EOF {
+			return false
+		}
+		panic(fmt.Sprintf("broken stream: %v", err))
+	}
+
+	*et = elm.Timestamp
+	*key = elm.Elm.Interface().(typex.T)
+	*value = elm.Elm2.Interface().([]byte)
+	return true
+}
+
+func iterMakerETTypex_TByteSlice(s ReStream) ReusableInput {
+	ret := &iterNative{s: s}
+	ret.fn = reflect.ValueOf(ret.readETTypex_TByteSlice)
+	return ret
+}
+
+func (v *iterNative) readTypex_TBool(key *typex.T, value *bool) bool {
+	elm, err := v.cur.Read()
+	if err != nil {
+		if err == io.EOF {
+			return false
+		}
+		panic(fmt.Sprintf("broken stream: %v", err))
+	}
+
+	*key = elm.Elm.Interface().(typex.T)
+	*value = elm.Elm2.Interface().(bool)
+	return true
+}
+
+func iterMakerTypex_TBool(s ReStream) ReusableInput {
+	ret := &iterNative{s: s}
+	ret.fn = reflect.ValueOf(ret.readTypex_TBool)
+	return ret
+}
+
+func (v *iterNative) readETTypex_TBool(et *typex.EventTime, key *typex.T, value *bool) bool {
+	elm, err := v.cur.Read()
+	if err != nil {
+		if err == io.EOF {
+			return false
+		}
+		panic(fmt.Sprintf("broken stream: %v", err))
+	}
+
+	*et = elm.Timestamp
+	*key = elm.Elm.Interface().(typex.T)
+	*value = elm.Elm2.Interface().(bool)
+	return true
+}
+
+func iterMakerETTypex_TBool(s ReStream) ReusableInput {
+	ret := &iterNative{s: s}
+	ret.fn = reflect.ValueOf(ret.readETTypex_TBool)
+	return ret
+}
+
+func (v *iterNative) readTypex_TString(key *typex.T, value *string) bool {
+	elm, err := v.cur.Read()
+	if err != nil {
+		if err == io.EOF {
+			return false
+		}
+		panic(fmt.Sprintf("broken stream: %v", err))
+	}
+
+	*key = elm.Elm.Interface().(typex.T)
+	*value = elm.Elm2.Interface().(string)
+	return true
+}
+
+func iterMakerTypex_TString(s ReStream) ReusableInput {
+	ret := &iterNative{s: s}
+	ret.fn = reflect.ValueOf(ret.readTypex_TString)
+	return ret
+}
+
+func (v *iterNative) readETTypex_TString(et *typex.EventTime, key *typex.T, value *string) bool {
+	elm, err := v.cur.Read()
+	if err != nil {
+		if err == io.EOF {
+			return false
+		}
+		panic(fmt.Sprintf("broken stream: %v", err))
+	}
+
+	*et = elm.Timestamp
+	*key = elm.Elm.Interface().(typex.T)
+	*value = elm.Elm2.Interface().(string)
+	return true
+}
+
+func iterMakerETTypex_TString(s ReStream) ReusableInput {
+	ret := &iterNative{s: s}
+	ret.fn = reflect.ValueOf(ret.readETTypex_TString)
+	return ret
+}
+
+func (v *iterNative) readTypex_TInt(key *typex.T, value *int) bool {
+	elm, err := v.cur.Read()
+	if err != nil {
+		if err == io.EOF {
+			return false
+		}
+		panic(fmt.Sprintf("broken stream: %v", err))
+	}
+
+	*key = elm.Elm.Interface().(typex.T)
+	*value = elm.Elm2.Interface().(int)
+	return true
+}
+
+func iterMakerTypex_TInt(s ReStream) ReusableInput {
+	ret := &iterNative{s: s}
+	ret.fn = reflect.ValueOf(ret.readTypex_TInt)
+	return ret
+}
+
+func (v *iterNative) readETTypex_TInt(et *typex.EventTime, key *typex.T, value *int) bool {
+	elm, err := v.cur.Read()
+	if err != nil {
+		if err == io.EOF {
+			return false
+		}
+		panic(fmt.Sprintf("broken stream: %v", err))
+	}
+
+	*et = elm.Timestamp
+	*key = elm.Elm.Interface().(typex.T)
+	*value = elm.Elm2.Interface().(int)
+	return true
+}
+
+func iterMakerETTypex_TInt(s ReStream) ReusableInput {
+	ret := &iterNative{s: s}
+	ret.fn = reflect.ValueOf(ret.readETTypex_TInt)
+	return ret
+}
+
+func (v *iterNative) readTypex_TInt8(key *typex.T, value *int8) bool {
+	elm, err := v.cur.Read()
+	if err != nil {
+		if err == io.EOF {
+			return false
+		}
+		panic(fmt.Sprintf("broken stream: %v", err))
+	}
+
+	*key = elm.Elm.Interface().(typex.T)
+	*value = elm.Elm2.Interface().(int8)
+	return true
+}
+
+func iterMakerTypex_TInt8(s ReStream) ReusableInput {
+	ret := &iterNative{s: s}
+	ret.fn = reflect.ValueOf(ret.readTypex_TInt8)
+	return ret
+}
+
+func (v *iterNative) readETTypex_TInt8(et *typex.EventTime, key *typex.T, value *int8) bool {
+	elm, err := v.cur.Read()
+	if err != nil {
+		if err == io.EOF {
+			return false
+		}
+		panic(fmt.Sprintf("broken stream: %v", err))
+	}
+
+	*et = elm.Timestamp
+	*key = elm.Elm.Interface().(typex.T)
+	*value = elm.Elm2.Interface().(int8)
+	return true
+}
+
+func iterMakerETTypex_TInt8(s ReStream) ReusableInput {
+	ret := &iterNative{s: s}
+	ret.fn = reflect.ValueOf(ret.readETTypex_TInt8)
+	return ret
+}
+
+func (v *iterNative) readTypex_TInt16(key *typex.T, value *int16) bool {
+	elm, err := v.cur.Read()
+	if err != nil {
+		if err == io.EOF {
+			return false
+		}
+		panic(fmt.Sprintf("broken stream: %v", err))
+	}
+
+	*key = elm.Elm.Interface().(typex.T)
+	*value = elm.Elm2.Interface().(int16)
+	return true
+}
+
+func iterMakerTypex_TInt16(s ReStream) ReusableInput {
+	ret := &iterNative{s: s}
+	ret.fn = reflect.ValueOf(ret.readTypex_TInt16)
+	return ret
+}
+
+func (v *iterNative) readETTypex_TInt16(et *typex.EventTime, key *typex.T, value *int16) bool {
+	elm, err := v.cur.Read()
+	if err != nil {
+		if err == io.EOF {
+			return false
+		}
+		panic(fmt.Sprintf("broken stream: %v", err))
+	}
+
+	*et = elm.Timestamp
+	*key = elm.Elm.Interface().(typex.T)
+	*value = elm.Elm2.Interface().(int16)
+	return true
+}
+
+func iterMakerETTypex_TInt16(s ReStream) ReusableInput {
+	ret := &iterNative{s: s}
+	ret.fn = reflect.ValueOf(ret.readETTypex_TInt16)
+	return ret
+}
+
+func (v *iterNative) readTypex_TInt32(key *typex.T, value *int32) bool {
+	elm, err := v.cur.Read()
+	if err != nil {
+		if err == io.EOF {
+			return false
+		}
+		panic(fmt.Sprintf("broken stream: %v", err))
+	}
+
+	*key = elm.Elm.Interface().(typex.T)
+	*value = elm.Elm2.Interface().(int32)
+	return true
+}
+
+func iterMakerTypex_TInt32(s ReStream) ReusableInput {
+	ret := &iterNative{s: s}
+	ret.fn = reflect.ValueOf(ret.readTypex_TInt32)
+	return ret
+}
+
+func (v *iterNative) readETTypex_TInt32(et *typex.EventTime, key *typex.T, value *int32) bool {
+	elm, err := v.cur.Read()
+	if err != nil {
+		if err == io.EOF {
+			return false
+		}
+		panic(fmt.Sprintf("broken stream: %v", err))
+	}
+
+	*et = elm.Timestamp
+	*key = elm.Elm.Interface().(typex.T)
+	*value = elm.Elm2.Interface().(int32)
+	return true
+}
+
+func iterMakerETTypex_TInt32(s ReStream) ReusableInput {
+	ret := &iterNative{s: s}
+	ret.fn = reflect.ValueOf(ret.readETTypex_TInt32)
+	return ret
+}
+
+func (v *iterNative) readTypex_TInt64(key *typex.T, value *int64) bool {
+	elm, err := v.cur.Read()
+	if err != nil {
+		if err == io.EOF {
+			return false
+		}
+		panic(fmt.Sprintf("broken stream: %v", err))
+	}
+
+	*key = elm.Elm.Interface().(typex.T)
+	*value = elm.Elm2.Interface().(int64)
+	return true
+}
+
+func iterMakerTypex_TInt64(s ReStream) ReusableInput {
+	ret := &iterNative{s: s}
+	ret.fn = reflect.ValueOf(ret.readTypex_TInt64)
+	return ret
+}
+
+func (v *iterNative) readETTypex_TInt64(et *typex.EventTime, key *typex.T, value *int64) bool {
+	elm, err := v.cur.Read()
+	if err != nil {
+		if err == io.EOF {
+			return false
+		}
+		panic(fmt.Sprintf("broken stream: %v", err))
+	}
+
+	*et = elm.Timestamp
+	*key = elm.Elm.Interface().(typex.T)
+	*value = elm.Elm2.Interface().(int64)
+	return true
+}
+
+func iterMakerETTypex_TInt64(s ReStream) ReusableInput {
+	ret := &iterNative{s: s}
+	ret.fn = reflect.ValueOf(ret.readETTypex_TInt64)
+	return ret
+}
+
+func (v *iterNative) readTypex_TUint(key *typex.T, value *uint) bool {
+	elm, err := v.cur.Read()
+	if err != nil {
+		if err == io.EOF {
+			return false
+		}
+		panic(fmt.Sprintf("broken stream: %v", err))
+	}
+
+	*key = elm.Elm.Interface().(typex.T)
+	*value = elm.Elm2.Interface().(uint)
+	return true
+}
+
+func iterMakerTypex_TUint(s ReStream) ReusableInput {
+	ret := &iterNative{s: s}
+	ret.fn = reflect.ValueOf(ret.readTypex_TUint)
+	return ret
+}
+
+func (v *iterNative) readETTypex_TUint(et *typex.EventTime, key *typex.T, value *uint) bool {
+	elm, err := v.cur.Read()
+	if err != nil {
+		if err == io.EOF {
+			return false
+		}
+		panic(fmt.Sprintf("broken stream: %v", err))
+	}
+
+	*et = elm.Timestamp
+	*key = elm.Elm.Interface().(typex.T)
+	*value = elm.Elm2.Interface().(uint)
+	return true
+}
+
+func iterMakerETTypex_TUint(s ReStream) ReusableInput {
+	ret := &iterNative{s: s}
+	ret.fn = reflect.ValueOf(ret.readETTypex_TUint)
+	return ret
+}
+
+func (v *iterNative) readTypex_TUint8(key *typex.T, value *uint8) bool {
+	elm, err := v.cur.Read()
+	if err != nil {
+		if err == io.EOF {
+			return false
+		}
+		panic(fmt.Sprintf("broken stream: %v", err))
+	}
+
+	*key = elm.Elm.Interface().(typex.T)
+	*value = elm.Elm2.Interface().(uint8)
+	return true
+}
+
+func iterMakerTypex_TUint8(s ReStream) ReusableInput {
+	ret := &iterNative{s: s}
+	ret.fn = reflect.ValueOf(ret.readTypex_TUint8)
+	return ret
+}
+
+func (v *iterNative) readETTypex_TUint8(et *typex.EventTime, key *typex.T, value *uint8) bool {
+	elm, err := v.cur.Read()
+	if err != nil {
+		if err == io.EOF {
+			return false
+		}
+		panic(fmt.Sprintf("broken stream: %v", err))
+	}
+
+	*et = elm.Timestamp
+	*key = elm.Elm.Interface().(typex.T)
+	*value = elm.Elm2.Interface().(uint8)
+	return true
+}
+
+func iterMakerETTypex_TUint8(s ReStream) ReusableInput {
+	ret := &iterNative{s: s}
+	ret.fn = reflect.ValueOf(ret.readETTypex_TUint8)
+	return ret
+}
+
+func (v *iterNative) readTypex_TUint16(key *typex.T, value *uint16) bool {
+	elm, err := v.cur.Read()
+	if err != nil {
+		if err == io.EOF {
+			return false
+		}
+		panic(fmt.Sprintf("broken stream: %v", err))
+	}
+
+	*key = elm.Elm.Interface().(typex.T)
+	*value = elm.Elm2.Interface().(uint16)
+	return true
+}
+
+func iterMakerTypex_TUint16(s ReStream) ReusableInput {
+	ret := &iterNative{s: s}
+	ret.fn = reflect.ValueOf(ret.readTypex_TUint16)
+	return ret
+}
+
+func (v *iterNative) readETTypex_TUint16(et *typex.EventTime, key *typex.T, value *uint16) bool {
+	elm, err := v.cur.Read()
+	if err != nil {
+		if err == io.EOF {
+			return false
+		}
+		panic(fmt.Sprintf("broken stream: %v", err))
+	}
+
+	*et = elm.Timestamp
+	*key = elm.Elm.Interface().(typex.T)
+	*value = elm.Elm2.Interface().(uint16)
+	return true
+}
+
+func iterMakerETTypex_TUint16(s ReStream) ReusableInput {
+	ret := &iterNative{s: s}
+	ret.fn = reflect.ValueOf(ret.readETTypex_TUint16)
+	return ret
+}
+
+func (v *iterNative) readTypex_TUint32(key *typex.T, value *uint32) bool {
+	elm, err := v.cur.Read()
+	if err != nil {
+		if err == io.EOF {
+			return false
+		}
+		panic(fmt.Sprintf("broken stream: %v", err))
+	}
+
+	*key = elm.Elm.Interface().(typex.T)
+	*value = elm.Elm2.Interface().(uint32)
+	return true
+}
+
+func iterMakerTypex_TUint32(s ReStream) ReusableInput {
+	ret := &iterNative{s: s}
+	ret.fn = reflect.ValueOf(ret.readTypex_TUint32)
+	return ret
+}
+
+func (v *iterNative) readETTypex_TUint32(et *typex.EventTime, key *typex.T, value *uint32) bool {
+	elm, err := v.cur.Read()
+	if err != nil {
+		if err == io.EOF {
+			return false
+		}
+		panic(fmt.Sprintf("broken stream: %v", err))
+	}
+
+	*et = elm.Timestamp
+	*key = elm.Elm.Interface().(typex.T)
+	*value = elm.Elm2.Interface().(uint32)
+	return true
+}
+
+func iterMakerETTypex_TUint32(s ReStream) ReusableInput {
+	ret := &iterNative{s: s}
+	ret.fn = reflect.ValueOf(ret.readETTypex_TUint32)
+	return ret
+}
+
+func (v *iterNative) readTypex_TUint64(key *typex.T, value *uint64) bool {
+	elm, err := v.cur.Read()
+	if err != nil {
+		if err == io.EOF {
+			return false
+		}
+		panic(fmt.Sprintf("broken stream: %v", err))
+	}
+
+	*key = elm.Elm.Interface().(typex.T)
+	*value = elm.Elm2.Interface().(uint64)
+	return true
+}
+
+func iterMakerTypex_TUint64(s ReStream) ReusableInput {
+	ret := &iterNative{s: s}
+	ret.fn = reflect.ValueOf(ret.readTypex_TUint64)
+	return ret
+}
+
+func (v *iterNative) readETTypex_TUint64(et *typex.EventTime, key *typex.T, value *uint64) bool {
+	elm, err := v.cur.Read()
+	if err != nil {
+		if err == io.EOF {
+			return false
+		}
+		panic(fmt.Sprintf("broken stream: %v", err))
+	}
+
+	*et = elm.Timestamp
+	*key = elm.Elm.Interface().(typex.T)
+	*value = elm.Elm2.Interface().(uint64)
+	return true
+}
+
+func iterMakerETTypex_TUint64(s ReStream) ReusableInput {
+	ret := &iterNative{s: s}
+	ret.fn = reflect.ValueOf(ret.readETTypex_TUint64)
+	return ret
+}
+
+func (v *iterNative) readTypex_TFloat32(key *typex.T, value *float32) bool {
+	elm, err := v.cur.Read()
+	if err != nil {
+		if err == io.EOF {
+			return false
+		}
+		panic(fmt.Sprintf("broken stream: %v", err))
+	}
+
+	*key = elm.Elm.Interface().(typex.T)
+	*value = elm.Elm2.Interface().(float32)
+	return true
+}
+
+func iterMakerTypex_TFloat32(s ReStream) ReusableInput {
+	ret := &iterNative{s: s}
+	ret.fn = reflect.ValueOf(ret.readTypex_TFloat32)
+	return ret
+}
+
+func (v *iterNative) readETTypex_TFloat32(et *typex.EventTime, key *typex.T, value *float32) bool {
+	elm, err := v.cur.Read()
+	if err != nil {
+		if err == io.EOF {
+			return false
+		}
+		panic(fmt.Sprintf("broken stream: %v", err))
+	}
+
+	*et = elm.Timestamp
+	*key = elm.Elm.Interface().(typex.T)
+	*value = elm.Elm2.Interface().(float32)
+	return true
+}
+
+func iterMakerETTypex_TFloat32(s ReStream) ReusableInput {
+	ret := &iterNative{s: s}
+	ret.fn = reflect.ValueOf(ret.readETTypex_TFloat32)
+	return ret
+}
+
+func (v *iterNative) readTypex_TFloat64(key *typex.T, value *float64) bool {
+	elm, err := v.cur.Read()
+	if err != nil {
+		if err == io.EOF {
+			return false
+		}
+		panic(fmt.Sprintf("broken stream: %v", err))
+	}
+
+	*key = elm.Elm.Interface().(typex.T)
+	*value = elm.Elm2.Interface().(float64)
+	return true
+}
+
+func iterMakerTypex_TFloat64(s ReStream) ReusableInput {
+	ret := &iterNative{s: s}
+	ret.fn = reflect.ValueOf(ret.readTypex_TFloat64)
+	return ret
+}
+
+func (v *iterNative) readETTypex_TFloat64(et *typex.EventTime, key *typex.T, value *float64) bool {
+	elm, err := v.cur.Read()
+	if err != nil {
+		if err == io.EOF {
+			return false
+		}
+		panic(fmt.Sprintf("broken stream: %v", err))
+	}
+
+	*et = elm.Timestamp
+	*key = elm.Elm.Interface().(typex.T)
+	*value = elm.Elm2.Interface().(float64)
+	return true
+}
+
+func iterMakerETTypex_TFloat64(s ReStream) ReusableInput {
+	ret := &iterNative{s: s}
+	ret.fn = reflect.ValueOf(ret.readETTypex_TFloat64)
+	return ret
+}
+
+func (v *iterNative) readTypex_TTypex_T(key *typex.T, value *typex.T) bool {
+	elm, err := v.cur.Read()
+	if err != nil {
+		if err == io.EOF {
+			return false
+		}
+		panic(fmt.Sprintf("broken stream: %v", err))
+	}
+
+	*key = elm.Elm.Interface().(typex.T)
+	*value = elm.Elm2.Interface().(typex.T)
+	return true
+}
+
+func iterMakerTypex_TTypex_T(s ReStream) ReusableInput {
+	ret := &iterNative{s: s}
+	ret.fn = reflect.ValueOf(ret.readTypex_TTypex_T)
+	return ret
+}
+
+func (v *iterNative) readETTypex_TTypex_T(et *typex.EventTime, key *typex.T, value *typex.T) bool {
+	elm, err := v.cur.Read()
+	if err != nil {
+		if err == io.EOF {
+			return false
+		}
+		panic(fmt.Sprintf("broken stream: %v", err))
+	}
+
+	*et = elm.Timestamp
+	*key = elm.Elm.Interface().(typex.T)
+	*value = elm.Elm2.Interface().(typex.T)
+	return true
+}
+
+func iterMakerETTypex_TTypex_T(s ReStream) ReusableInput {
+	ret := &iterNative{s: s}
+	ret.fn = reflect.ValueOf(ret.readETTypex_TTypex_T)
+	return ret
+}
+
+func (v *iterNative) readTypex_TTypex_U(key *typex.T, value *typex.U) bool {
+	elm, err := v.cur.Read()
+	if err != nil {
+		if err == io.EOF {
+			return false
+		}
+		panic(fmt.Sprintf("broken stream: %v", err))
+	}
+
+	*key = elm.Elm.Interface().(typex.T)
+	*value = elm.Elm2.Interface().(typex.U)
+	return true
+}
+
+func iterMakerTypex_TTypex_U(s ReStream) ReusableInput {
+	ret := &iterNative{s: s}
+	ret.fn = reflect.ValueOf(ret.readTypex_TTypex_U)
+	return ret
+}
+
+func (v *iterNative) readETTypex_TTypex_U(et *typex.EventTime, key *typex.T, value *typex.U) bool {
+	elm, err := v.cur.Read()
+	if err != nil {
+		if err == io.EOF {
+			return false
+		}
+		panic(fmt.Sprintf("broken stream: %v", err))
+	}
+
+	*et = elm.Timestamp
+	*key = elm.Elm.Interface().(typex.T)
+	*value = elm.Elm2.Interface().(typex.U)
+	return true
+}
+
+func iterMakerETTypex_TTypex_U(s ReStream) ReusableInput {
+	ret := &iterNative{s: s}
+	ret.fn = reflect.ValueOf(ret.readETTypex_TTypex_U)
+	return ret
+}
+
+func (v *iterNative) readTypex_TTypex_V(key *typex.T, value *typex.V) bool {
+	elm, err := v.cur.Read()
+	if err != nil {
+		if err == io.EOF {
+			return false
+		}
+		panic(fmt.Sprintf("broken stream: %v", err))
+	}
+
+	*key = elm.Elm.Interface().(typex.T)
+	*value = elm.Elm2.Interface().(typex.V)
+	return true
+}
+
+func iterMakerTypex_TTypex_V(s ReStream) ReusableInput {
+	ret := &iterNative{s: s}
+	ret.fn = reflect.ValueOf(ret.readTypex_TTypex_V)
+	return ret
+}
+
+func (v *iterNative) readETTypex_TTypex_V(et *typex.EventTime, key *typex.T, value *typex.V) bool {
+	elm, err := v.cur.Read()
+	if err != nil {
+		if err == io.EOF {
+			return false
+		}
+		panic(fmt.Sprintf("broken stream: %v", err))
+	}
+
+	*et = elm.Timestamp
+	*key = elm.Elm.Interface().(typex.T)
+	*value = elm.Elm2.Interface().(typex.V)
+	return true
+}
+
+func iterMakerETTypex_TTypex_V(s ReStream) ReusableInput {
+	ret := &iterNative{s: s}
+	ret.fn = reflect.ValueOf(ret.readETTypex_TTypex_V)
+	return ret
+}
+
+func (v *iterNative) readTypex_TTypex_W(key *typex.T, value *typex.W) bool {
+	elm, err := v.cur.Read()
+	if err != nil {
+		if err == io.EOF {
+			return false
+		}
+		panic(fmt.Sprintf("broken stream: %v", err))
+	}
+
+	*key = elm.Elm.Interface().(typex.T)
+	*value = elm.Elm2.Interface().(typex.W)
+	return true
+}
+
+func iterMakerTypex_TTypex_W(s ReStream) ReusableInput {
+	ret := &iterNative{s: s}
+	ret.fn = reflect.ValueOf(ret.readTypex_TTypex_W)
+	return ret
+}
+
+func (v *iterNative) readETTypex_TTypex_W(et *typex.EventTime, key *typex.T, value *typex.W) bool {
+	elm, err := v.cur.Read()
+	if err != nil {
+		if err == io.EOF {
+			return false
+		}
+		panic(fmt.Sprintf("broken stream: %v", err))
+	}
+
+	*et = elm.Timestamp
+	*key = elm.Elm.Interface().(typex.T)
+	*value = elm.Elm2.Interface().(typex.W)
+	return true
+}
+
+func iterMakerETTypex_TTypex_W(s ReStream) ReusableInput {
+	ret := &iterNative{s: s}
+	ret.fn = reflect.ValueOf(ret.readETTypex_TTypex_W)
+	return ret
+}
+
+func (v *iterNative) readTypex_TTypex_X(key *typex.T, value *typex.X) bool {
+	elm, err := v.cur.Read()
+	if err != nil {
+		if err == io.EOF {
+			return false
+		}
+		panic(fmt.Sprintf("broken stream: %v", err))
+	}
+
+	*key = elm.Elm.Interface().(typex.T)
+	*value = elm.Elm2.Interface().(typex.X)
+	return true
+}
+
+func iterMakerTypex_TTypex_X(s ReStream) ReusableInput {
+	ret := &iterNative{s: s}
+	ret.fn = reflect.ValueOf(ret.readTypex_TTypex_X)
+	return ret
+}
+
+func (v *iterNative) readETTypex_TTypex_X(et *typex.EventTime, key *typex.T, value *typex.X) bool {
+	elm, err := v.cur.Read()
+	if err != nil {
+		if err == io.EOF {
+			return false
+		}
+		panic(fmt.Sprintf("broken stream: %v", err))
+	}
+
+	*et = elm.Timestamp
+	*key = elm.Elm.Interface().(typex.T)
+	*value = elm.Elm2.Interface().(typex.X)
+	return true
+}
+
+func iterMakerETTypex_TTypex_X(s ReStream) ReusableInput {
+	ret := &iterNative{s: s}
+	ret.fn = reflect.ValueOf(ret.readETTypex_TTypex_X)
+	return ret
+}
+
+func (v *iterNative) readTypex_TTypex_Y(key *typex.T, value *typex.Y) bool {
+	elm, err := v.cur.Read()
+	if err != nil {
+		if err == io.EOF {
+			return false
+		}
+		panic(fmt.Sprintf("broken stream: %v", err))
+	}
+
+	*key = elm.Elm.Interface().(typex.T)
+	*value = elm.Elm2.Interface().(typex.Y)
+	return true
+}
+
+func iterMakerTypex_TTypex_Y(s ReStream) ReusableInput {
+	ret := &iterNative{s: s}
+	ret.fn = reflect.ValueOf(ret.readTypex_TTypex_Y)
+	return ret
+}
+
+func (v *iterNative) readETTypex_TTypex_Y(et *typex.EventTime, key *typex.T, value *typex.Y) bool {
+	elm, err := v.cur.Read()
+	if err != nil {
+		if err == io.EOF {
+			return false
+		}
+		panic(fmt.Sprintf("broken stream: %v", err))
+	}
+
+	*et = elm.Timestamp
+	*key = elm.Elm.Interface().(typex.T)
+	*value = elm.Elm2.Interface().(typex.Y)
+	return true
+}
+
+func iterMakerETTypex_TTypex_Y(s ReStream) ReusableInput {
+	ret := &iterNative{s: s}
+	ret.fn = reflect.ValueOf(ret.readETTypex_TTypex_Y)
+	return ret
+}
+
+func (v *iterNative) readTypex_TTypex_Z(key *typex.T, value *typex.Z) bool {
+	elm, err := v.cur.Read()
+	if err != nil {
+		if err == io.EOF {
+			return false
+		}
+		panic(fmt.Sprintf("broken stream: %v", err))
+	}
+
+	*key = elm.Elm.Interface().(typex.T)
+	*value = elm.Elm2.Interface().(typex.Z)
+	return true
+}
+
+func iterMakerTypex_TTypex_Z(s ReStream) ReusableInput {
+	ret := &iterNative{s: s}
+	ret.fn = reflect.ValueOf(ret.readTypex_TTypex_Z)
+	return ret
+}
+
+func (v *iterNative) readETTypex_TTypex_Z(et *typex.EventTime, key *typex.T, value *typex.Z) bool {
+	elm, err := v.cur.Read()
+	if err != nil {
+		if err == io.EOF {
+			return false
+		}
+		panic(fmt.Sprintf("broken stream: %v", err))
+	}
+
+	*et = elm.Timestamp
+	*key = elm.Elm.Interface().(typex.T)
+	*value = elm.Elm2.Interface().(typex.Z)
+	return true
+}
+
+func iterMakerETTypex_TTypex_Z(s ReStream) ReusableInput {
+	ret := &iterNative{s: s}
+	ret.fn = reflect.ValueOf(ret.readETTypex_TTypex_Z)
+	return ret
+}
+
+func (v *iterNative) readTypex_U(val *typex.U) bool {
+	elm, err := v.cur.Read()
+	if err != nil {
+		if err == io.EOF {
+			return false
+		}
+		panic(fmt.Sprintf("broken stream: %v", err))
+	}
+
+	*val = elm.Elm.Interface().(typex.U)
+	return true
+}
+
+func iterMakerTypex_U(s ReStream) ReusableInput {
+	ret := &iterNative{s: s}
+	ret.fn = reflect.ValueOf(ret.readTypex_U)
+	return ret
+}
+
+func (v *iterNative) readETTypex_U(et *typex.EventTime, val *typex.U) bool {
+	elm, err := v.cur.Read()
+	if err != nil {
+		if err == io.EOF {
+			return false
+		}
+		panic(fmt.Sprintf("broken stream: %v", err))
+	}
+
+	*et = elm.Timestamp
+	*val = elm.Elm.Interface().(typex.U)
+	return true
+}
+
+func iterMakerETTypex_U(s ReStream) ReusableInput {
+	ret := &iterNative{s: s}
+	ret.fn = reflect.ValueOf(ret.readETTypex_U)
+	return ret
+}
+
+func (v *iterNative) readTypex_UByteSlice(key *typex.U, value *[]byte) bool {
+	elm, err := v.cur.Read()
+	if err != nil {
+		if err == io.EOF {
+			return false
+		}
+		panic(fmt.Sprintf("broken stream: %v", err))
+	}
+
+	*key = elm.Elm.Interface().(typex.U)
+	*value = elm.Elm2.Interface().([]byte)
+	return true
+}
+
+func iterMakerTypex_UByteSlice(s ReStream) ReusableInput {
+	ret := &iterNative{s: s}
+	ret.fn = reflect.ValueOf(ret.readTypex_UByteSlice)
+	return ret
+}
+
+func (v *iterNative) readETTypex_UByteSlice(et *typex.EventTime, key *typex.U, value *[]byte) bool {
+	elm, err := v.cur.Read()
+	if err != nil {
+		if err == io.EOF {
+			return false
+		}
+		panic(fmt.Sprintf("broken stream: %v", err))
+	}
+
+	*et = elm.Timestamp
+	*key = elm.Elm.Interface().(typex.U)
+	*value = elm.Elm2.Interface().([]byte)
+	return true
+}
+
+func iterMakerETTypex_UByteSlice(s ReStream) ReusableInput {
+	ret := &iterNative{s: s}
+	ret.fn = reflect.ValueOf(ret.readETTypex_UByteSlice)
+	return ret
+}
+
+func (v *iterNative) readTypex_UBool(key *typex.U, value *bool) bool {
+	elm, err := v.cur.Read()
+	if err != nil {
+		if err == io.EOF {
+			return false
+		}
+		panic(fmt.Sprintf("broken stream: %v", err))
+	}
+
+	*key = elm.Elm.Interface().(typex.U)
+	*value = elm.Elm2.Interface().(bool)
+	return true
+}
+
+func iterMakerTypex_UBool(s ReStream) ReusableInput {
+	ret := &iterNative{s: s}
+	ret.fn = reflect.ValueOf(ret.readTypex_UBool)
+	return ret
+}
+
+func (v *iterNative) readETTypex_UBool(et *typex.EventTime, key *typex.U, value *bool) bool {
+	elm, err := v.cur.Read()
+	if err != nil {
+		if err == io.EOF {
+			return false
+		}
+		panic(fmt.Sprintf("broken stream: %v", err))
+	}
+
+	*et = elm.Timestamp
+	*key = elm.Elm.Interface().(typex.U)
+	*value = elm.Elm2.Interface().(bool)
+	return true
+}
+
+func iterMakerETTypex_UBool(s ReStream) ReusableInput {
+	ret := &iterNative{s: s}
+	ret.fn = reflect.ValueOf(ret.readETTypex_UBool)
+	return ret
+}
+
+func (v *iterNative) readTypex_UString(key *typex.U, value *string) bool {
+	elm, err := v.cur.Read()
+	if err != nil {
+		if err == io.EOF {
+			return false
+		}
+		panic(fmt.Sprintf("broken stream: %v", err))
+	}
+
+	*key = elm.Elm.Interface().(typex.U)
+	*value = elm.Elm2.Interface().(string)
+	return true
+}
+
+func iterMakerTypex_UString(s ReStream) ReusableInput {
+	ret := &iterNative{s: s}
+	ret.fn = reflect.ValueOf(ret.readTypex_UString)
+	return ret
+}
+
+func (v *iterNative) readETTypex_UString(et *typex.EventTime, key *typex.U, value *string) bool {
+	elm, err := v.cur.Read()
+	if err != nil {
+		if err == io.EOF {
+			return false
+		}
+		panic(fmt.Sprintf("broken stream: %v", err))
+	}
+
+	*et = elm.Timestamp
+	*key = elm.Elm.Interface().(typex.U)
+	*value = elm.Elm2.Interface().(string)
+	return true
+}
+
+func iterMakerETTypex_UString(s ReStream) ReusableInput {
+	ret := &iterNative{s: s}
+	ret.fn = reflect.ValueOf(ret.readETTypex_UString)
+	return ret
+}
+
+func (v *iterNative) readTypex_UInt(key *typex.U, value *int) bool {
+	elm, err := v.cur.Read()
+	if err != nil {
+		if err == io.EOF {
+			return false
+		}
+		panic(fmt.Sprintf("broken stream: %v", err))
+	}
+
+	*key = elm.Elm.Interface().(typex.U)
+	*value = elm.Elm2.Interface().(int)
+	return true
+}
+
+func iterMakerTypex_UInt(s ReStream) ReusableInput {
+	ret := &iterNative{s: s}
+	ret.fn = reflect.ValueOf(ret.readTypex_UInt)
+	return ret
+}
+
+func (v *iterNative) readETTypex_UInt(et *typex.EventTime, key *typex.U, value *int) bool {
+	elm, err := v.cur.Read()
+	if err != nil {
+		if err == io.EOF {
+			return false
+		}
+		panic(fmt.Sprintf("broken stream: %v", err))
+	}
+
+	*et = elm.Timestamp
+	*key = elm.Elm.Interface().(typex.U)
+	*value = elm.Elm2.Interface().(int)
+	return true
+}
+
+func iterMakerETTypex_UInt(s ReStream) ReusableInput {
+	ret := &iterNative{s: s}
+	ret.fn = reflect.ValueOf(ret.readETTypex_UInt)
+	return ret
+}
+
+func (v *iterNative) readTypex_UInt8(key *typex.U, value *int8) bool {
+	elm, err := v.cur.Read()
+	if err != nil {
+		if err == io.EOF {
+			return false
+		}
+		panic(fmt.Sprintf("broken stream: %v", err))
+	}
+
+	*key = elm.Elm.Interface().(typex.U)
+	*value = elm.Elm2.Interface().(int8)
+	return true
+}
+
+func iterMakerTypex_UInt8(s ReStream) ReusableInput {
+	ret := &iterNative{s: s}
+	ret.fn = reflect.ValueOf(ret.readTypex_UInt8)
+	return ret
+}
+
+func (v *iterNative) readETTypex_UInt8(et *typex.EventTime, key *typex.U, value *int8) bool {
+	elm, err := v.cur.Read()
+	if err != nil {
+		if err == io.EOF {
+			return false
+		}
+		panic(fmt.Sprintf("broken stream: %v", err))
+	}
+
+	*et = elm.Timestamp
+	*key = elm.Elm.Interface().(typex.U)
+	*value = elm.Elm2.Interface().(int8)
+	return true
+}
+
+func iterMakerETTypex_UInt8(s ReStream) ReusableInput {
+	ret := &iterNative{s: s}
+	ret.fn = reflect.ValueOf(ret.readETTypex_UInt8)
+	return ret
+}
+
+func (v *iterNative) readTypex_UInt16(key *typex.U, value *int16) bool {
+	elm, err := v.cur.Read()
+	if err != nil {
+		if err == io.EOF {
+			return false
+		}
+		panic(fmt.Sprintf("broken stream: %v", err))
+	}
+
+	*key = elm.Elm.Interface().(typex.U)
+	*value = elm.Elm2.Interface().(int16)
+	return true
+}
+
+func iterMakerTypex_UInt16(s ReStream) ReusableInput {
+	ret := &iterNative{s: s}
+	ret.fn = reflect.ValueOf(ret.readTypex_UInt16)
+	return ret
+}
+
+func (v *iterNative) readETTypex_UInt16(et *typex.EventTime, key *typex.U, value *int16) bool {
+	elm, err := v.cur.Read()
+	if err != nil {
+		if err == io.EOF {
+			return false
+		}
+		panic(fmt.Sprintf("broken stream: %v", err))
+	}
+
+	*et = elm.Timestamp
+	*key = elm.Elm.Interface().(typex.U)
+	*value = elm.Elm2.Interface().(int16)
+	return true
+}
+
+func iterMakerETTypex_UInt16(s ReStream) ReusableInput {
+	ret := &iterNative{s: s}
+	ret.fn = reflect.ValueOf(ret.readETTypex_UInt16)
+	return ret
+}
+
+func (v *iterNative) readTypex_UInt32(key *typex.U, value *int32) bool {
+	elm, err := v.cur.Read()
+	if err != nil {
+		if err == io.EOF {
+			return false
+		}
+		panic(fmt.Sprintf("broken stream: %v", err))
+	}
+
+	*key = elm.Elm.Interface().(typex.U)
+	*value = elm.Elm2.Interface().(int32)
+	return true
+}
+
+func iterMakerTypex_UInt32(s ReStream) ReusableInput {
+	ret := &iterNative{s: s}
+	ret.fn = reflect.ValueOf(ret.readTypex_UInt32)
+	return ret
+}
+
+func (v *iterNative) readETTypex_UInt32(et *typex.EventTime, key *typex.U, value *int32) bool {
+	elm, err := v.cur.Read()
+	if err != nil {
+		if err == io.EOF {
+			return false
+		}
+		panic(fmt.Sprintf("broken stream: %v", err))
+	}
+
+	*et = elm.Timestamp
+	*key = elm.Elm.Interface().(typex.U)
+	*value = elm.Elm2.Interface().(int32)
+	return true
+}
+
+func iterMakerETTypex_UInt32(s ReStream) ReusableInput {
+	ret := &iterNative{s: s}
+	ret.fn = reflect.ValueOf(ret.readETTypex_UInt32)
+	return ret
+}
+
+func (v *iterNative) readTypex_UInt64(key *typex.U, value *int64) bool {
+	elm, err := v.cur.Read()
+	if err != nil {
+		if err == io.EOF {
+			return false
+		}
+		panic(fmt.Sprintf("broken stream: %v", err))
+	}
+
+	*key = elm.Elm.Interface().(typex.U)
+	*value = elm.Elm2.Interface().(int64)
+	return true
+}
+
+func iterMakerTypex_UInt64(s ReStream) ReusableInput {
+	ret := &iterNative{s: s}
+	ret.fn = reflect.ValueOf(ret.readTypex_UInt64)
+	return ret
+}
+
+func (v *iterNative) readETTypex_UInt64(et *typex.EventTime, key *typex.U, value *int64) bool {
+	elm, err := v.cur.Read()
+	if err != nil {
+		if err == io.EOF {
+			return false
+		}
+		panic(fmt.Sprintf("broken stream: %v", err))
+	}
+
+	*et = elm.Timestamp
+	*key = elm.Elm.Interface().(typex.U)
+	*value = elm.Elm2.Interface().(int64)
+	return true
+}
+
+func iterMakerETTypex_UInt64(s ReStream) ReusableInput {
+	ret := &iterNative{s: s}
+	ret.fn = reflect.ValueOf(ret.readETTypex_UInt64)
+	return ret
+}
+
+func (v *iterNative) readTypex_UUint(key *typex.U, value *uint) bool {
+	elm, err := v.cur.Read()
+	if err != nil {
+		if err == io.EOF {
+			return false
+		}
+		panic(fmt.Sprintf("broken stream: %v", err))
+	}
+
+	*key = elm.Elm.Interface().(typex.U)
+	*value = elm.Elm2.Interface().(uint)
+	return true
+}
+
+func iterMakerTypex_UUint(s ReStream) ReusableInput {
+	ret := &iterNative{s: s}
+	ret.fn = reflect.ValueOf(ret.readTypex_UUint)
+	return ret
+}
+
+func (v *iterNative) readETTypex_UUint(et *typex.EventTime, key *typex.U, value *uint) bool {
+	elm, err := v.cur.Read()
+	if err != nil {
+		if err == io.EOF {
+			return false
+		}
+		panic(fmt.Sprintf("broken stream: %v", err))
+	}
+
+	*et = elm.Timestamp
+	*key = elm.Elm.Interface().(typex.U)
+	*value = elm.Elm2.Interface().(uint)
+	return true
+}
+
+func iterMakerETTypex_UUint(s ReStream) ReusableInput {
+	ret := &iterNative{s: s}
+	ret.fn = reflect.ValueOf(ret.readETTypex_UUint)
+	return ret
+}
+
+func (v *iterNative) readTypex_UUint8(key *typex.U, value *uint8) bool {
+	elm, err := v.cur.Read()
+	if err != nil {
+		if err == io.EOF {
+			return false
+		}
+		panic(fmt.Sprintf("broken stream: %v", err))
+	}
+
+	*key = elm.Elm.Interface().(typex.U)
+	*value = elm.Elm2.Interface().(uint8)
+	return true
+}
+
+func iterMakerTypex_UUint8(s ReStream) ReusableInput {
+	ret := &iterNative{s: s}
+	ret.fn = reflect.ValueOf(ret.readTypex_UUint8)
+	return ret
+}
+
+func (v *iterNative) readETTypex_UUint8(et *typex.EventTime, key *typex.U, value *uint8) bool {
+	elm, err := v.cur.Read()
+	if err != nil {
+		if err == io.EOF {
+			return false
+		}
+		panic(fmt.Sprintf("broken stream: %v", err))
+	}
+
+	*et = elm.Timestamp
+	*key = elm.Elm.Interface().(typex.U)
+	*value = elm.Elm2.Interface().(uint8)
+	return true
+}
+
+func iterMakerETTypex_UUint8(s ReStream) ReusableInput {
+	ret := &iterNative{s: s}
+	ret.fn = reflect.ValueOf(ret.readETTypex_UUint8)
+	return ret
+}
+
+func (v *iterNative) readTypex_UUint16(key *typex.U, value *uint16) bool {
+	elm, err := v.cur.Read()
+	if err != nil {
+		if err == io.EOF {
+			return false
+		}
+		panic(fmt.Sprintf("broken stream: %v", err))
+	}
+
+	*key = elm.Elm.Interface().(typex.U)
+	*value = elm.Elm2.Interface().(uint16)
+	return true
+}
+
+func iterMakerTypex_UUint16(s ReStream) ReusableInput {
+	ret := &iterNative{s: s}
+	ret.fn = reflect.ValueOf(ret.readTypex_UUint16)
+	return ret
+}
+
+func (v *iterNative) readETTypex_UUint16(et *typex.EventTime, key *typex.U, value *uint16) bool {
+	elm, err := v.cur.Read()
+	if err != nil {
+		if err == io.EOF {
+			return false
+		}
+		panic(fmt.Sprintf("broken stream: %v", err))
+	}
+
+	*et = elm.Timestamp
+	*key = elm.Elm.Interface().(typex.U)
+	*value = elm.Elm2.Interface().(uint16)
+	return true
+}
+
+func iterMakerETTypex_UUint16(s ReStream) ReusableInput {
+	ret := &iterNative{s: s}
+	ret.fn = reflect.ValueOf(ret.readETTypex_UUint16)
+	return ret
+}
+
+func (v *iterNative) readTypex_UUint32(key *typex.U, value *uint32) bool {
+	elm, err := v.cur.Read()
+	if err != nil {
+		if err == io.EOF {
+			return false
+		}
+		panic(fmt.Sprintf("broken stream: %v", err))
+	}
+
+	*key = elm.Elm.Interface().(typex.U)
+	*value = elm.Elm2.Interface().(uint32)
+	return true
+}
+
+func iterMakerTypex_UUint32(s ReStream) ReusableInput {
+	ret := &iterNative{s: s}
+	ret.fn = reflect.ValueOf(ret.readTypex_UUint32)
+	return ret
+}
+
+func (v *iterNative) readETTypex_UUint32(et *typex.EventTime, key *typex.U, value *uint32) bool {
+	elm, err := v.cur.Read()
+	if err != nil {
+		if err == io.EOF {
+			return false
+		}
+		panic(fmt.Sprintf("broken stream: %v", err))
+	}
+
+	*et = elm.Timestamp
+	*key = elm.Elm.Interface().(typex.U)
+	*value = elm.Elm2.Interface().(uint32)
+	return true
+}
+
+func iterMakerETTypex_UUint32(s ReStream) ReusableInput {
+	ret := &iterNative{s: s}
+	ret.fn = reflect.ValueOf(ret.readETTypex_UUint32)
+	return ret
+}
+
+func (v *iterNative) readTypex_UUint64(key *typex.U, value *uint64) bool {
+	elm, err := v.cur.Read()
+	if err != nil {
+		if err == io.EOF {
+			return false
+		}
+		panic(fmt.Sprintf("broken stream: %v", err))
+	}
+
+	*key = elm.Elm.Interface().(typex.U)
+	*value = elm.Elm2.Interface().(uint64)
+	return true
+}
+
+func iterMakerTypex_UUint64(s ReStream) ReusableInput {
+	ret := &iterNative{s: s}
+	ret.fn = reflect.ValueOf(ret.readTypex_UUint64)
+	return ret
+}
+
+func (v *iterNative) readETTypex_UUint64(et *typex.EventTime, key *typex.U, value *uint64) bool {
+	elm, err := v.cur.Read()
+	if err != nil {
+		if err == io.EOF {
+			return false
+		}
+		panic(fmt.Sprintf("broken stream: %v", err))
+	}
+
+	*et = elm.Timestamp
+	*key = elm.Elm.Interface().(typex.U)
+	*value = elm.Elm2.Interface().(uint64)
+	return true
+}
+
+func iterMakerETTypex_UUint64(s ReStream) ReusableInput {
+	ret := &iterNative{s: s}
+	ret.fn = reflect.ValueOf(ret.readETTypex_UUint64)
+	return ret
+}
+
+func (v *iterNative) readTypex_UFloat32(key *typex.U, value *float32) bool {
+	elm, err := v.cur.Read()
+	if err != nil {
+		if err == io.EOF {
+			return false
+		}
+		panic(fmt.Sprintf("broken stream: %v", err))
+	}
+
+	*key = elm.Elm.Interface().(typex.U)
+	*value = elm.Elm2.Interface().(float32)
+	return true
+}
+
+func iterMakerTypex_UFloat32(s ReStream) ReusableInput {
+	ret := &iterNative{s: s}
+	ret.fn = reflect.ValueOf(ret.readTypex_UFloat32)
+	return ret
+}
+
+func (v *iterNative) readETTypex_UFloat32(et *typex.EventTime, key *typex.U, value *float32) bool {
+	elm, err := v.cur.Read()
+	if err != nil {
+		if err == io.EOF {
+			return false
+		}
+		panic(fmt.Sprintf("broken stream: %v", err))
+	}
+
+	*et = elm.Timestamp
+	*key = elm.Elm.Interface().(typex.U)
+	*value = elm.Elm2.Interface().(float32)
+	return true
+}
+
+func iterMakerETTypex_UFloat32(s ReStream) ReusableInput {
+	ret := &iterNative{s: s}
+	ret.fn = reflect.ValueOf(ret.readETTypex_UFloat32)
+	return ret
+}
+
+func (v *iterNative) readTypex_UFloat64(key *typex.U, value *float64) bool {
+	elm, err := v.cur.Read()
+	if err != nil {
+		if err == io.EOF {
+			return false
+		}
+		panic(fmt.Sprintf("broken stream: %v", err))
+	}
+
+	*key = elm.Elm.Interface().(typex.U)
+	*value = elm.Elm2.Interface().(float64)
+	return true
+}
+
+func iterMakerTypex_UFloat64(s ReStream) ReusableInput {
+	ret := &iterNative{s: s}
+	ret.fn = reflect.ValueOf(ret.readTypex_UFloat64)
+	return ret
+}
+
+func (v *iterNative) readETTypex_UFloat64(et *typex.EventTime, key *typex.U, value *float64) bool {
+	elm, err := v.cur.Read()
+	if err != nil {
+		if err == io.EOF {
+			return false
+		}
+		panic(fmt.Sprintf("broken stream: %v", err))
+	}
+
+	*et = elm.Timestamp
+	*key = elm.Elm.Interface().(typex.U)
+	*value = elm.Elm2.Interface().(float64)
+	return true
+}
+
+func iterMakerETTypex_UFloat64(s ReStream) ReusableInput {
+	ret := &iterNative{s: s}
+	ret.fn = reflect.ValueOf(ret.readETTypex_UFloat64)
+	return ret
+}
+
+func (v *iterNative) readTypex_UTypex_T(key *typex.U, value *typex.T) bool {
+	elm, err := v.cur.Read()
+	if err != nil {
+		if err == io.EOF {
+			return false
+		}
+		panic(fmt.Sprintf("broken stream: %v", err))
+	}
+
+	*key = elm.Elm.Interface().(typex.U)
+	*value = elm.Elm2.Interface().(typex.T)
+	return true
+}
+
+func iterMakerTypex_UTypex_T(s ReStream) ReusableInput {
+	ret := &iterNative{s: s}
+	ret.fn = reflect.ValueOf(ret.readTypex_UTypex_T)
+	return ret
+}
+
+func (v *iterNative) readETTypex_UTypex_T(et *typex.EventTime, key *typex.U, value *typex.T) bool {
+	elm, err := v.cur.Read()
+	if err != nil {
+		if err == io.EOF {
+			return false
+		}
+		panic(fmt.Sprintf("broken stream: %v", err))
+	}
+
+	*et = elm.Timestamp
+	*key = elm.Elm.Interface().(typex.U)
+	*value = elm.Elm2.Interface().(typex.T)
+	return true
+}
+
+func iterMakerETTypex_UTypex_T(s ReStream) ReusableInput {
+	ret := &iterNative{s: s}
+	ret.fn = reflect.ValueOf(ret.readETTypex_UTypex_T)
+	return ret
+}
+
+func (v *iterNative) readTypex_UTypex_U(key *typex.U, value *typex.U) bool {
+	elm, err := v.cur.Read()
+	if err != nil {
+		if err == io.EOF {
+			return false
+		}
+		panic(fmt.Sprintf("broken stream: %v", err))
+	}
+
+	*key = elm.Elm.Interface().(typex.U)
+	*value = elm.Elm2.Interface().(typex.U)
+	return true
+}
+
+func iterMakerTypex_UTypex_U(s ReStream) ReusableInput {
+	ret := &iterNative{s: s}
+	ret.fn = reflect.ValueOf(ret.readTypex_UTypex_U)
+	return ret
+}
+
+func (v *iterNative) readETTypex_UTypex_U(et *typex.EventTime, key *typex.U, value *typex.U) bool {
+	elm, err := v.cur.Read()
+	if err != nil {
+		if err == io.EOF {
+			return false
+		}
+		panic(fmt.Sprintf("broken stream: %v", err))
+	}
+
+	*et = elm.Timestamp
+	*key = elm.Elm.Interface().(typex.U)
+	*value = elm.Elm2.Interface().(typex.U)
+	return true
+}
+
+func iterMakerETTypex_UTypex_U(s ReStream) ReusableInput {
+	ret := &iterNative{s: s}
+	ret.fn = reflect.ValueOf(ret.readETTypex_UTypex_U)
+	return ret
+}
+
+func (v *iterNative) readTypex_UTypex_V(key *typex.U, value *typex.V) bool {
+	elm, err := v.cur.Read()
+	if err != nil {
+		if err == io.EOF {
+			return false
+		}
+		panic(fmt.Sprintf("broken stream: %v", err))
+	}
+
+	*key = elm.Elm.Interface().(typex.U)
+	*value = elm.Elm2.Interface().(typex.V)
+	return true
+}
+
+func iterMakerTypex_UTypex_V(s ReStream) ReusableInput {
+	ret := &iterNative{s: s}
+	ret.fn = reflect.ValueOf(ret.readTypex_UTypex_V)
+	return ret
+}
+
+func (v *iterNative) readETTypex_UTypex_V(et *typex.EventTime, key *typex.U, value *typex.V) bool {
+	elm, err := v.cur.Read()
+	if err != nil {
+		if err == io.EOF {
+			return false
+		}
+		panic(fmt.Sprintf("broken stream: %v", err))
+	}
+
+	*et = elm.Timestamp
+	*key = elm.Elm.Interface().(typex.U)
+	*value = elm.Elm2.Interface().(typex.V)
+	return true
+}
+
+func iterMakerETTypex_UTypex_V(s ReStream) ReusableInput {
+	ret := &iterNative{s: s}
+	ret.fn = reflect.ValueOf(ret.readETTypex_UTypex_V)
+	return ret
+}
+
+func (v *iterNative) readTypex_UTypex_W(key *typex.U, value *typex.W) bool {
+	elm, err := v.cur.Read()
+	if err != nil {
+		if err == io.EOF {
+			return false
+		}
+		panic(fmt.Sprintf("broken stream: %v", err))
+	}
+
+	*key = elm.Elm.Interface().(typex.U)
+	*value = elm.Elm2.Interface().(typex.W)
+	return true
+}
+
+func iterMakerTypex_UTypex_W(s ReStream) ReusableInput {
+	ret := &iterNative{s: s}
+	ret.fn = reflect.ValueOf(ret.readTypex_UTypex_W)
+	return ret
+}
+
+func (v *iterNative) readETTypex_UTypex_W(et *typex.EventTime, key *typex.U, value *typex.W) bool {
+	elm, err := v.cur.Read()
+	if err != nil {
+		if err == io.EOF {
+			return false
+		}
+		panic(fmt.Sprintf("broken stream: %v", err))
+	}
+
+	*et = elm.Timestamp
+	*key = elm.Elm.Interface().(typex.U)
+	*value = elm.Elm2.Interface().(typex.W)
+	return true
+}
+
+func iterMakerETTypex_UTypex_W(s ReStream) ReusableInput {
+	ret := &iterNative{s: s}
+	ret.fn = reflect.ValueOf(ret.readETTypex_UTypex_W)
+	return ret
+}
+
+func (v *iterNative) readTypex_UTypex_X(key *typex.U, value *typex.X) bool {
+	elm, err := v.cur.Read()
+	if err != nil {
+		if err == io.EOF {
+			return false
+		}
+		panic(fmt.Sprintf("broken stream: %v", err))
+	}
+
+	*key = elm.Elm.Interface().(typex.U)
+	*value = elm.Elm2.Interface().(typex.X)
+	return true
+}
+
+func iterMakerTypex_UTypex_X(s ReStream) ReusableInput {
+	ret := &iterNative{s: s}
+	ret.fn = reflect.ValueOf(ret.readTypex_UTypex_X)
+	return ret
+}
+
+func (v *iterNative) readETTypex_UTypex_X(et *typex.EventTime, key *typex.U, value *typex.X) bool {
+	elm, err := v.cur.Read()
+	if err != nil {
+		if err == io.EOF {
+			return false
+		}
+		panic(fmt.Sprintf("broken stream: %v", err))
+	}
+
+	*et = elm.Timestamp
+	*key = elm.Elm.Interface().(typex.U)
+	*value = elm.Elm2.Interface().(typex.X)
+	return true
+}
+
+func iterMakerETTypex_UTypex_X(s ReStream) ReusableInput {
+	ret := &iterNative{s: s}
+	ret.fn = reflect.ValueOf(ret.readETTypex_UTypex_X)
+	return ret
+}
+
+func (v *iterNative) readTypex_UTypex_Y(key *typex.U, value *typex.Y) bool {
+	elm, err := v.cur.Read()
+	if err != nil {
+		if err == io.EOF {
+			return false
+		}
+		panic(fmt.Sprintf("broken stream: %v", err))
+	}
+
+	*key = elm.Elm.Interface().(typex.U)
+	*value = elm.Elm2.Interface().(typex.Y)
+	return true
+}
+
+func iterMakerTypex_UTypex_Y(s ReStream) ReusableInput {
+	ret := &iterNative{s: s}
+	ret.fn = reflect.ValueOf(ret.readTypex_UTypex_Y)
+	return ret
+}
+
+func (v *iterNative) readETTypex_UTypex_Y(et *typex.EventTime, key *typex.U, value *typex.Y) bool {
+	elm, err := v.cur.Read()
+	if err != nil {
+		if err == io.EOF {
+			return false
+		}
+		panic(fmt.Sprintf("broken stream: %v", err))
+	}
+
+	*et = elm.Timestamp
+	*key = elm.Elm.Interface().(typex.U)
+	*value = elm.Elm2.Interface().(typex.Y)
+	return true
+}
+
+func iterMakerETTypex_UTypex_Y(s ReStream) ReusableInput {
+	ret := &iterNative{s: s}
+	ret.fn = reflect.ValueOf(ret.readETTypex_UTypex_Y)
+	return ret
+}
+
+func (v *iterNative) readTypex_UTypex_Z(key *typex.U, value *typex.Z) bool {
+	elm, err := v.cur.Read()
+	if err != nil {
+		if err == io.EOF {
+			return false
+		}
+		panic(fmt.Sprintf("broken stream: %v", err))
+	}
+
+	*key = elm.Elm.Interface().(typex.U)
+	*value = elm.Elm2.Interface().(typex.Z)
+	return true
+}
+
+func iterMakerTypex_UTypex_Z(s ReStream) ReusableInput {
+	ret := &iterNative{s: s}
+	ret.fn = reflect.ValueOf(ret.readTypex_UTypex_Z)
+	return ret
+}
+
+func (v *iterNative) readETTypex_UTypex_Z(et *typex.EventTime, key *typex.U, value *typex.Z) bool {
+	elm, err := v.cur.Read()
+	if err != nil {
+		if err == io.EOF {
+			return false
+		}
+		panic(fmt.Sprintf("broken stream: %v", err))
+	}
+
+	*et = elm.Timestamp
+	*key = elm.Elm.Interface().(typex.U)
+	*value = elm.Elm2.Interface().(typex.Z)
+	return true
+}
+
+func iterMakerETTypex_UTypex_Z(s ReStream) ReusableInput {
+	ret := &iterNative{s: s}
+	ret.fn = reflect.ValueOf(ret.readETTypex_UTypex_Z)
+	return ret
+}
+
+func (v *iterNative) readTypex_V(val *typex.V) bool {
+	elm, err := v.cur.Read()
+	if err != nil {
+		if err == io.EOF {
+			return false
+		}
+		panic(fmt.Sprintf("broken stream: %v", err))
+	}
+
+	*val = elm.Elm.Interface().(typex.V)
+	return true
+}
+
+func iterMakerTypex_V(s ReStream) ReusableInput {
+	ret := &iterNative{s: s}
+	ret.fn = reflect.ValueOf(ret.readTypex_V)
+	return ret
+}
+
+func (v *iterNative) readETTypex_V(et *typex.EventTime, val *typex.V) bool {
+	elm, err := v.cur.Read()
+	if err != nil {
+		if err == io.EOF {
+			return false
+		}
+		panic(fmt.Sprintf("broken stream: %v", err))
+	}
+
+	*et = elm.Timestamp
+	*val = elm.Elm.Interface().(typex.V)
+	return true
+}
+
+func iterMakerETTypex_V(s ReStream) ReusableInput {
+	ret := &iterNative{s: s}
+	ret.fn = reflect.ValueOf(ret.readETTypex_V)
+	return ret
+}
+
+func (v *iterNative) readTypex_VByteSlice(key *typex.V, value *[]byte) bool {
+	elm, err := v.cur.Read()
+	if err != nil {
+		if err == io.EOF {
+			return false
+		}
+		panic(fmt.Sprintf("broken stream: %v", err))
+	}
+
+	*key = elm.Elm.Interface().(typex.V)
+	*value = elm.Elm2.Interface().([]byte)
+	return true
+}
+
+func iterMakerTypex_VByteSlice(s ReStream) ReusableInput {
+	ret := &iterNative{s: s}
+	ret.fn = reflect.ValueOf(ret.readTypex_VByteSlice)
+	return ret
+}
+
+func (v *iterNative) readETTypex_VByteSlice(et *typex.EventTime, key *typex.V, value *[]byte) bool {
+	elm, err := v.cur.Read()
+	if err != nil {
+		if err == io.EOF {
+			return false
+		}
+		panic(fmt.Sprintf("broken stream: %v", err))
+	}
+
+	*et = elm.Timestamp
+	*key = elm.Elm.Interface().(typex.V)
+	*value = elm.Elm2.Interface().([]byte)
+	return true
+}
+
+func iterMakerETTypex_VByteSlice(s ReStream) ReusableInput {
+	ret := &iterNative{s: s}
+	ret.fn = reflect.ValueOf(ret.readETTypex_VByteSlice)
+	return ret
+}
+
+func (v *iterNative) readTypex_VBool(key *typex.V, value *bool) bool {
+	elm, err := v.cur.Read()
+	if err != nil {
+		if err == io.EOF {
+			return false
+		}
+		panic(fmt.Sprintf("broken stream: %v", err))
+	}
+
+	*key = elm.Elm.Interface().(typex.V)
+	*value = elm.Elm2.Interface().(bool)
+	return true
+}
+
+func iterMakerTypex_VBool(s ReStream) ReusableInput {
+	ret := &iterNative{s: s}
+	ret.fn = reflect.ValueOf(ret.readTypex_VBool)
+	return ret
+}
+
+func (v *iterNative) readETTypex_VBool(et *typex.EventTime, key *typex.V, value *bool) bool {
+	elm, err := v.cur.Read()
+	if err != nil {
+		if err == io.EOF {
+			return false
+		}
+		panic(fmt.Sprintf("broken stream: %v", err))
+	}
+
+	*et = elm.Timestamp
+	*key = elm.Elm.Interface().(typex.V)
+	*value = elm.Elm2.Interface().(bool)
+	return true
+}
+
+func iterMakerETTypex_VBool(s ReStream) ReusableInput {
+	ret := &iterNative{s: s}
+	ret.fn = reflect.ValueOf(ret.readETTypex_VBool)
+	return ret
+}
+
+func (v *iterNative) readTypex_VString(key *typex.V, value *string) bool {
+	elm, err := v.cur.Read()
+	if err != nil {
+		if err == io.EOF {
+			return false
+		}
+		panic(fmt.Sprintf("broken stream: %v", err))
+	}
+
+	*key = elm.Elm.Interface().(typex.V)
+	*value = elm.Elm2.Interface().(string)
+	return true
+}
+
+func iterMakerTypex_VString(s ReStream) ReusableInput {
+	ret := &iterNative{s: s}
+	ret.fn = reflect.ValueOf(ret.readTypex_VString)
+	return ret
+}
+
+func (v *iterNative) readETTypex_VString(et *typex.EventTime, key *typex.V, value *string) bool {
+	elm, err := v.cur.Read()
+	if err != nil {
+		if err == io.EOF {
+			return false
+		}
+		panic(fmt.Sprintf("broken stream: %v", err))
+	}
+
+	*et = elm.Timestamp
+	*key = elm.Elm.Interface().(typex.V)
+	*value = elm.Elm2.Interface().(string)
+	return true
+}
+
+func iterMakerETTypex_VString(s ReStream) ReusableInput {
+	ret := &iterNative{s: s}
+	ret.fn = reflect.ValueOf(ret.readETTypex_VString)
+	return ret
+}
+
+func (v *iterNative) readTypex_VInt(key *typex.V, value *int) bool {
+	elm, err := v.cur.Read()
+	if err != nil {
+		if err == io.EOF {
+			return false
+		}
+		panic(fmt.Sprintf("broken stream: %v", err))
+	}
+
+	*key = elm.Elm.Interface().(typex.V)
+	*value = elm.Elm2.Interface().(int)
+	return true
+}
+
+func iterMakerTypex_VInt(s ReStream) ReusableInput {
+	ret := &iterNative{s: s}
+	ret.fn = reflect.ValueOf(ret.readTypex_VInt)
+	return ret
+}
+
+func (v *iterNative) readETTypex_VInt(et *typex.EventTime, key *typex.V, value *int) bool {
+	elm, err := v.cur.Read()
+	if err != nil {
+		if err == io.EOF {
+			return false
+		}
+		panic(fmt.Sprintf("broken stream: %v", err))
+	}
+
+	*et = elm.Timestamp
+	*key = elm.Elm.Interface().(typex.V)
+	*value = elm.Elm2.Interface().(int)
+	return true
+}
+
+func iterMakerETTypex_VInt(s ReStream) ReusableInput {
+	ret := &iterNative{s: s}
+	ret.fn = reflect.ValueOf(ret.readETTypex_VInt)
+	return ret
+}
+
+func (v *iterNative) readTypex_VInt8(key *typex.V, value *int8) bool {
+	elm, err := v.cur.Read()
+	if err != nil {
+		if err == io.EOF {
+			return false
+		}
+		panic(fmt.Sprintf("broken stream: %v", err))
+	}
+
+	*key = elm.Elm.Interface().(typex.V)
+	*value = elm.Elm2.Interface().(int8)
+	return true
+}
+
+func iterMakerTypex_VInt8(s ReStream) ReusableInput {
+	ret := &iterNative{s: s}
+	ret.fn = reflect.ValueOf(ret.readTypex_VInt8)
+	return ret
+}
+
+func (v *iterNative) readETTypex_VInt8(et *typex.EventTime, key *typex.V, value *int8) bool {
+	elm, err := v.cur.Read()
+	if err != nil {
+		if err == io.EOF {
+			return false
+		}
+		panic(fmt.Sprintf("broken stream: %v", err))
+	}
+
+	*et = elm.Timestamp
+	*key = elm.Elm.Interface().(typex.V)
+	*value = elm.Elm2.Interface().(int8)
+	return true
+}
+
+func iterMakerETTypex_VInt8(s ReStream) ReusableInput {
+	ret := &iterNative{s: s}
+	ret.fn = reflect.ValueOf(ret.readETTypex_VInt8)
+	return ret
+}
+
+func (v *iterNative) readTypex_VInt16(key *typex.V, value *int16) bool {
+	elm, err := v.cur.Read()
+	if err != nil {
+		if err == io.EOF {
+			return false
+		}
+		panic(fmt.Sprintf("broken stream: %v", err))
+	}
+
+	*key = elm.Elm.Interface().(typex.V)
+	*value = elm.Elm2.Interface().(int16)
+	return true
+}
+
+func iterMakerTypex_VInt16(s ReStream) ReusableInput {
+	ret := &iterNative{s: s}
+	ret.fn = reflect.ValueOf(ret.readTypex_VInt16)
+	return ret
+}
+
+func (v *iterNative) readETTypex_VInt16(et *typex.EventTime, key *typex.V, value *int16) bool {
+	elm, err := v.cur.Read()
+	if err != nil {
+		if err == io.EOF {
+			return false
+		}
+		panic(fmt.Sprintf("broken stream: %v", err))
+	}
+
+	*et = elm.Timestamp
+	*key = elm.Elm.Interface().(typex.V)
+	*value = elm.Elm2.Interface().(int16)
+	return true
+}
+
+func iterMakerETTypex_VInt16(s ReStream) ReusableInput {
+	ret := &iterNative{s: s}
+	ret.fn = reflect.ValueOf(ret.readETTypex_VInt16)
+	return ret
+}
+
+func (v *iterNative) readTypex_VInt32(key *typex.V, value *int32) bool {
+	elm, err := v.cur.Read()
+	if err != nil {
+		if err == io.EOF {
+			return false
+		}
+		panic(fmt.Sprintf("broken stream: %v", err))
+	}
+
+	*key = elm.Elm.Interface().(typex.V)
+	*value = elm.Elm2.Interface().(int32)
+	return true
+}
+
+func iterMakerTypex_VInt32(s ReStream) ReusableInput {
+	ret := &iterNative{s: s}
+	ret.fn = reflect.ValueOf(ret.readTypex_VInt32)
+	return ret
+}
+
+func (v *iterNative) readETTypex_VInt32(et *typex.EventTime, key *typex.V, value *int32) bool {
+	elm, err := v.cur.Read()
+	if err != nil {
+		if err == io.EOF {
+			return false
+		}
+		panic(fmt.Sprintf("broken stream: %v", err))
+	}
+
+	*et = elm.Timestamp
+	*key = elm.Elm.Interface().(typex.V)
+	*value = elm.Elm2.Interface().(int32)
+	return true
+}
+
+func iterMakerETTypex_VInt32(s ReStream) ReusableInput {
+	ret := &iterNative{s: s}
+	ret.fn = reflect.ValueOf(ret.readETTypex_VInt32)
+	return ret
+}
+
+func (v *iterNative) readTypex_VInt64(key *typex.V, value *int64) bool {
+	elm, err := v.cur.Read()
+	if err != nil {
+		if err == io.EOF {
+			return false
+		}
+		panic(fmt.Sprintf("broken stream: %v", err))
+	}
+
+	*key = elm.Elm.Interface().(typex.V)
+	*value = elm.Elm2.Interface().(int64)
+	return true
+}
+
+func iterMakerTypex_VInt64(s ReStream) ReusableInput {
+	ret := &iterNative{s: s}
+	ret.fn = reflect.ValueOf(ret.readTypex_VInt64)
+	return ret
+}
+
+func (v *iterNative) readETTypex_VInt64(et *typex.EventTime, key *typex.V, value *int64) bool {
+	elm, err := v.cur.Read()
+	if err != nil {
+		if err == io.EOF {
+			return false
+		}
+		panic(fmt.Sprintf("broken stream: %v", err))
+	}
+
+	*et = elm.Timestamp
+	*key = elm.Elm.Interface().(typex.V)
+	*value = elm.Elm2.Interface().(int64)
+	return true
+}
+
+func iterMakerETTypex_VInt64(s ReStream) ReusableInput {
+	ret := &iterNative{s: s}
+	ret.fn = reflect.ValueOf(ret.readETTypex_VInt64)
+	return ret
+}
+
+func (v *iterNative) readTypex_VUint(key *typex.V, value *uint) bool {
+	elm, err := v.cur.Read()
+	if err != nil {
+		if err == io.EOF {
+			return false
+		}
+		panic(fmt.Sprintf("broken stream: %v", err))
+	}
+
+	*key = elm.Elm.Interface().(typex.V)
+	*value = elm.Elm2.Interface().(uint)
+	return true
+}
+
+func iterMakerTypex_VUint(s ReStream) ReusableInput {
+	ret := &iterNative{s: s}
+	ret.fn = reflect.ValueOf(ret.readTypex_VUint)
+	return ret
+}
+
+func (v *iterNative) readETTypex_VUint(et *typex.EventTime, key *typex.V, value *uint) bool {
+	elm, err := v.cur.Read()
+	if err != nil {
+		if err == io.EOF {
+			return false
+		}
+		panic(fmt.Sprintf("broken stream: %v", err))
+	}
+
+	*et = elm.Timestamp
+	*key = elm.Elm.Interface().(typex.V)
+	*value = elm.Elm2.Interface().(uint)
+	return true
+}
+
+func iterMakerETTypex_VUint(s ReStream) ReusableInput {
+	ret := &iterNative{s: s}
+	ret.fn = reflect.ValueOf(ret.readETTypex_VUint)
+	return ret
+}
+
+func (v *iterNative) readTypex_VUint8(key *typex.V, value *uint8) bool {
+	elm, err := v.cur.Read()
+	if err != nil {
+		if err == io.EOF {
+			return false
+		}
+		panic(fmt.Sprintf("broken stream: %v", err))
+	}
+
+	*key = elm.Elm.Interface().(typex.V)
+	*value = elm.Elm2.Interface().(uint8)
+	return true
+}
+
+func iterMakerTypex_VUint8(s ReStream) ReusableInput {
+	ret := &iterNative{s: s}
+	ret.fn = reflect.ValueOf(ret.readTypex_VUint8)
+	return ret
+}
+
+func (v *iterNative) readETTypex_VUint8(et *typex.EventTime, key *typex.V, value *uint8) bool {
+	elm, err := v.cur.Read()
+	if err != nil {
+		if err == io.EOF {
+			return false
+		}
+		panic(fmt.Sprintf("broken stream: %v", err))
+	}
+
+	*et = elm.Timestamp
+	*key = elm.Elm.Interface().(typex.V)
+	*value = elm.Elm2.Interface().(uint8)
+	return true
+}
+
+func iterMakerETTypex_VUint8(s ReStream) ReusableInput {
+	ret := &iterNative{s: s}
+	ret.fn = reflect.ValueOf(ret.readETTypex_VUint8)
+	return ret
+}
+
+func (v *iterNative) readTypex_VUint16(key *typex.V, value *uint16) bool {
+	elm, err := v.cur.Read()
+	if err != nil {
+		if err == io.EOF {
+			return false
+		}
+		panic(fmt.Sprintf("broken stream: %v", err))
+	}
+
+	*key = elm.Elm.Interface().(typex.V)
+	*value = elm.Elm2.Interface().(uint16)
+	return true
+}
+
+func iterMakerTypex_VUint16(s ReStream) ReusableInput {
+	ret := &iterNative{s: s}
+	ret.fn = reflect.ValueOf(ret.readTypex_VUint16)
+	return ret
+}
+
+func (v *iterNative) readETTypex_VUint16(et *typex.EventTime, key *typex.V, value *uint16) bool {
+	elm, err := v.cur.Read()
+	if err != nil {
+		if err == io.EOF {
+			return false
+		}
+		panic(fmt.Sprintf("broken stream: %v", err))
+	}
+
+	*et = elm.Timestamp
+	*key = elm.Elm.Interface().(typex.V)
+	*value = elm.Elm2.Interface().(uint16)
+	return true
+}
+
+func iterMakerETTypex_VUint16(s ReStream) ReusableInput {
+	ret := &iterNative{s: s}
+	ret.fn = reflect.ValueOf(ret.readETTypex_VUint16)
+	return ret
+}
+
+func (v *iterNative) readTypex_VUint32(key *typex.V, value *uint32) bool {
+	elm, err := v.cur.Read()
+	if err != nil {
+		if err == io.EOF {
+			return false
+		}
+		panic(fmt.Sprintf("broken stream: %v", err))
+	}
+
+	*key = elm.Elm.Interface().(typex.V)
+	*value = elm.Elm2.Interface().(uint32)
+	return true
+}
+
+func iterMakerTypex_VUint32(s ReStream) ReusableInput {
+	ret := &iterNative{s: s}
+	ret.fn = reflect.ValueOf(ret.readTypex_VUint32)
+	return ret
+}
+
+func (v *iterNative) readETTypex_VUint32(et *typex.EventTime, key *typex.V, value *uint32) bool {
+	elm, err := v.cur.Read()
+	if err != nil {
+		if err == io.EOF {
+			return false
+		}
+		panic(fmt.Sprintf("broken stream: %v", err))
+	}
+
+	*et = elm.Timestamp
+	*key = elm.Elm.Interface().(typex.V)
+	*value = elm.Elm2.Interface().(uint32)
+	return true
+}
+
+func iterMakerETTypex_VUint32(s ReStream) ReusableInput {
+	ret := &iterNative{s: s}
+	ret.fn = reflect.ValueOf(ret.readETTypex_VUint32)
+	return ret
+}
+
+func (v *iterNative) readTypex_VUint64(key *typex.V, value *uint64) bool {
+	elm, err := v.cur.Read()
+	if err != nil {
+		if err == io.EOF {
+			return false
+		}
+		panic(fmt.Sprintf("broken stream: %v", err))
+	}
+
+	*key = elm.Elm.Interface().(typex.V)
+	*value = elm.Elm2.Interface().(uint64)
+	return true
+}
+
+func iterMakerTypex_VUint64(s ReStream) ReusableInput {
+	ret := &iterNative{s: s}
+	ret.fn = reflect.ValueOf(ret.readTypex_VUint64)
+	return ret
+}
+
+func (v *iterNative) readETTypex_VUint64(et *typex.EventTime, key *typex.V, value *uint64) bool {
+	elm, err := v.cur.Read()
+	if err != nil {
+		if err == io.EOF {
+			return false
+		}
+		panic(fmt.Sprintf("broken stream: %v", err))
+	}
+
+	*et = elm.Timestamp
+	*key = elm.Elm.Interface().(typex.V)
+	*value = elm.Elm2.Interface().(uint64)
+	return true
+}
+
+func iterMakerETTypex_VUint64(s ReStream) ReusableInput {
+	ret := &iterNative{s: s}
+	ret.fn = reflect.ValueOf(ret.readETTypex_VUint64)
+	return ret
+}
+
+func (v *iterNative) readTypex_VFloat32(key *typex.V, value *float32) bool {
+	elm, err := v.cur.Read()
+	if err != nil {
+		if err == io.EOF {
+			return false
+		}
+		panic(fmt.Sprintf("broken stream: %v", err))
+	}
+
+	*key = elm.Elm.Interface().(typex.V)
+	*value = elm.Elm2.Interface().(float32)
+	return true
+}
+
+func iterMakerTypex_VFloat32(s ReStream) ReusableInput {
+	ret := &iterNative{s: s}
+	ret.fn = reflect.ValueOf(ret.readTypex_VFloat32)
+	return ret
+}
+
+func (v *iterNative) readETTypex_VFloat32(et *typex.EventTime, key *typex.V, value *float32) bool {
+	elm, err := v.cur.Read()
+	if err != nil {
+		if err == io.EOF {
+			return false
+		}
+		panic(fmt.Sprintf("broken stream: %v", err))
+	}
+
+	*et = elm.Timestamp
+	*key = elm.Elm.Interface().(typex.V)
+	*value = elm.Elm2.Interface().(float32)
+	return true
+}
+
+func iterMakerETTypex_VFloat32(s ReStream) ReusableInput {
+	ret := &iterNative{s: s}
+	ret.fn = reflect.ValueOf(ret.readETTypex_VFloat32)
+	return ret
+}
+
+func (v *iterNative) readTypex_VFloat64(key *typex.V, value *float64) bool {
+	elm, err := v.cur.Read()
+	if err != nil {
+		if err == io.EOF {
+			return false
+		}
+		panic(fmt.Sprintf("broken stream: %v", err))
+	}
+
+	*key = elm.Elm.Interface().(typex.V)
+	*value = elm.Elm2.Interface().(float64)
+	return true
+}
+
+func iterMakerTypex_VFloat64(s ReStream) ReusableInput {
+	ret := &iterNative{s: s}
+	ret.fn = reflect.ValueOf(ret.readTypex_VFloat64)
+	return ret
+}
+
+func (v *iterNative) readETTypex_VFloat64(et *typex.EventTime, key *typex.V, value *float64) bool {
+	elm, err := v.cur.Read()
+	if err != nil {
+		if err == io.EOF {
+			return false
+		}
+		panic(fmt.Sprintf("broken stream: %v", err))
+	}
+
+	*et = elm.Timestamp
+	*key = elm.Elm.Interface().(typex.V)
+	*value = elm.Elm2.Interface().(float64)
+	return true
+}
+
+func iterMakerETTypex_VFloat64(s ReStream) ReusableInput {
+	ret := &iterNative{s: s}
+	ret.fn = reflect.ValueOf(ret.readETTypex_VFloat64)
+	return ret
+}
+
+func (v *iterNative) readTypex_VTypex_T(key *typex.V, value *typex.T) bool {
+	elm, err := v.cur.Read()
+	if err != nil {
+		if err == io.EOF {
+			return false
+		}
+		panic(fmt.Sprintf("broken stream: %v", err))
+	}
+
+	*key = elm.Elm.Interface().(typex.V)
+	*value = elm.Elm2.Interface().(typex.T)
+	return true
+}
+
+func iterMakerTypex_VTypex_T(s ReStream) ReusableInput {
+	ret := &iterNative{s: s}
+	ret.fn = reflect.ValueOf(ret.readTypex_VTypex_T)
+	return ret
+}
+
+func (v *iterNative) readETTypex_VTypex_T(et *typex.EventTime, key *typex.V, value *typex.T) bool {
+	elm, err := v.cur.Read()
+	if err != nil {
+		if err == io.EOF {
+			return false
+		}
+		panic(fmt.Sprintf("broken stream: %v", err))
+	}
+
+	*et = elm.Timestamp
+	*key = elm.Elm.Interface().(typex.V)
+	*value = elm.Elm2.Interface().(typex.T)
+	return true
+}
+
+func iterMakerETTypex_VTypex_T(s ReStream) ReusableInput {
+	ret := &iterNative{s: s}
+	ret.fn = reflect.ValueOf(ret.readETTypex_VTypex_T)
+	return ret
+}
+
+func (v *iterNative) readTypex_VTypex_U(key *typex.V, value *typex.U) bool {
+	elm, err := v.cur.Read()
+	if err != nil {
+		if err == io.EOF {
+			return false
+		}
+		panic(fmt.Sprintf("broken stream: %v", err))
+	}
+
+	*key = elm.Elm.Interface().(typex.V)
+	*value = elm.Elm2.Interface().(typex.U)
+	return true
+}
+
+func iterMakerTypex_VTypex_U(s ReStream) ReusableInput {
+	ret := &iterNative{s: s}
+	ret.fn = reflect.ValueOf(ret.readTypex_VTypex_U)
+	return ret
+}
+
+func (v *iterNative) readETTypex_VTypex_U(et *typex.EventTime, key *typex.V, value *typex.U) bool {
+	elm, err := v.cur.Read()
+	if err != nil {
+		if err == io.EOF {
+			return false
+		}
+		panic(fmt.Sprintf("broken stream: %v", err))
+	}
+
+	*et = elm.Timestamp
+	*key = elm.Elm.Interface().(typex.V)
+	*value = elm.Elm2.Interface().(typex.U)
+	return true
+}
+
+func iterMakerETTypex_VTypex_U(s ReStream) ReusableInput {
+	ret := &iterNative{s: s}
+	ret.fn = reflect.ValueOf(ret.readETTypex_VTypex_U)
+	return ret
+}
+
+func (v *iterNative) readTypex_VTypex_V(key *typex.V, value *typex.V) bool {
+	elm, err := v.cur.Read()
+	if err != nil {
+		if err == io.EOF {
+			return false
+		}
+		panic(fmt.Sprintf("broken stream: %v", err))
+	}
+
+	*key = elm.Elm.Interface().(typex.V)
+	*value = elm.Elm2.Interface().(typex.V)
+	return true
+}
+
+func iterMakerTypex_VTypex_V(s ReStream) ReusableInput {
+	ret := &iterNative{s: s}
+	ret.fn = reflect.ValueOf(ret.readTypex_VTypex_V)
+	return ret
+}
+
+func (v *iterNative) readETTypex_VTypex_V(et *typex.EventTime, key *typex.V, value *typex.V) bool {
+	elm, err := v.cur.Read()
+	if err != nil {
+		if err == io.EOF {
+			return false
+		}
+		panic(fmt.Sprintf("broken stream: %v", err))
+	}
+
+	*et = elm.Timestamp
+	*key = elm.Elm.Interface().(typex.V)
+	*value = elm.Elm2.Interface().(typex.V)
+	return true
+}
+
+func iterMakerETTypex_VTypex_V(s ReStream) ReusableInput {
+	ret := &iterNative{s: s}
+	ret.fn = reflect.ValueOf(ret.readETTypex_VTypex_V)
+	return ret
+}
+
+func (v *iterNative) readTypex_VTypex_W(key *typex.V, value *typex.W) bool {
+	elm, err := v.cur.Read()
+	if err != nil {
+		if err == io.EOF {
+			return false
+		}
+		panic(fmt.Sprintf("broken stream: %v", err))
+	}
+
+	*key = elm.Elm.Interface().(typex.V)
+	*value = elm.Elm2.Interface().(typex.W)
+	return true
+}
+
+func iterMakerTypex_VTypex_W(s ReStream) ReusableInput {
+	ret := &iterNative{s: s}
+	ret.fn = reflect.ValueOf(ret.readTypex_VTypex_W)
+	return ret
+}
+
+func (v *iterNative) readETTypex_VTypex_W(et *typex.EventTime, key *typex.V, value *typex.W) bool {
+	elm, err := v.cur.Read()
+	if err != nil {
+		if err == io.EOF {
+			return false
+		}
+		panic(fmt.Sprintf("broken stream: %v", err))
+	}
+
+	*et = elm.Timestamp
+	*key = elm.Elm.Interface().(typex.V)
+	*value = elm.Elm2.Interface().(typex.W)
+	return true
+}
+
+func iterMakerETTypex_VTypex_W(s ReStream) ReusableInput {
+	ret := &iterNative{s: s}
+	ret.fn = reflect.ValueOf(ret.readETTypex_VTypex_W)
+	return ret
+}
+
+func (v *iterNative) readTypex_VTypex_X(key *typex.V, value *typex.X) bool {
+	elm, err := v.cur.Read()
+	if err != nil {
+		if err == io.EOF {
+			return false
+		}
+		panic(fmt.Sprintf("broken stream: %v", err))
+	}
+
+	*key = elm.Elm.Interface().(typex.V)
+	*value = elm.Elm2.Interface().(typex.X)
+	return true
+}
+
+func iterMakerTypex_VTypex_X(s ReStream) ReusableInput {
+	ret := &iterNative{s: s}
+	ret.fn = reflect.ValueOf(ret.readTypex_VTypex_X)
+	return ret
+}
+
+func (v *iterNative) readETTypex_VTypex_X(et *typex.EventTime, key *typex.V, value *typex.X) bool {
+	elm, err := v.cur.Read()
+	if err != nil {
+		if err == io.EOF {
+			return false
+		}
+		panic(fmt.Sprintf("broken stream: %v", err))
+	}
+
+	*et = elm.Timestamp
+	*key = elm.Elm.Interface().(typex.V)
+	*value = elm.Elm2.Interface().(typex.X)
+	return true
+}
+
+func iterMakerETTypex_VTypex_X(s ReStream) ReusableInput {
+	ret := &iterNative{s: s}
+	ret.fn = reflect.ValueOf(ret.readETTypex_VTypex_X)
+	return ret
+}
+
+func (v *iterNative) readTypex_VTypex_Y(key *typex.V, value *typex.Y) bool {
+	elm, err := v.cur.Read()
+	if err != nil {
+		if err == io.EOF {
+			return false
+		}
+		panic(fmt.Sprintf("broken stream: %v", err))
+	}
+
+	*key = elm.Elm.Interface().(typex.V)
+	*value = elm.Elm2.Interface().(typex.Y)
+	return true
+}
+
+func iterMakerTypex_VTypex_Y(s ReStream) ReusableInput {
+	ret := &iterNative{s: s}
+	ret.fn = reflect.ValueOf(ret.readTypex_VTypex_Y)
+	return ret
+}
+
+func (v *iterNative) readETTypex_VTypex_Y(et *typex.EventTime, key *typex.V, value *typex.Y) bool {
+	elm, err := v.cur.Read()
+	if err != nil {
+		if err == io.EOF {
+			return false
+		}
+		panic(fmt.Sprintf("broken stream: %v", err))
+	}
+
+	*et = elm.Timestamp
+	*key = elm.Elm.Interface().(typex.V)
+	*value = elm.Elm2.Interface().(typex.Y)
+	return true
+}
+
+func iterMakerETTypex_VTypex_Y(s ReStream) ReusableInput {
+	ret := &iterNative{s: s}
+	ret.fn = reflect.ValueOf(ret.readETTypex_VTypex_Y)
+	return ret
+}
+
+func (v *iterNative) readTypex_VTypex_Z(key *typex.V, value *typex.Z) bool {
+	elm, err := v.cur.Read()
+	if err != nil {
+		if err == io.EOF {
+			return false
+		}
+		panic(fmt.Sprintf("broken stream: %v", err))
+	}
+
+	*key = elm.Elm.Interface().(typex.V)
+	*value = elm.Elm2.Interface().(typex.Z)
+	return true
+}
+
+func iterMakerTypex_VTypex_Z(s ReStream) ReusableInput {
+	ret := &iterNative{s: s}
+	ret.fn = reflect.ValueOf(ret.readTypex_VTypex_Z)
+	return ret
+}
+
+func (v *iterNative) readETTypex_VTypex_Z(et *typex.EventTime, key *typex.V, value *typex.Z) bool {
+	elm, err := v.cur.Read()
+	if err != nil {
+		if err == io.EOF {
+			return false
+		}
+		panic(fmt.Sprintf("broken stream: %v", err))
+	}
+
+	*et = elm.Timestamp
+	*key = elm.Elm.Interface().(typex.V)
+	*value = elm.Elm2.Interface().(typex.Z)
+	return true
+}
+
+func iterMakerETTypex_VTypex_Z(s ReStream) ReusableInput {
+	ret := &iterNative{s: s}
+	ret.fn = reflect.ValueOf(ret.readETTypex_VTypex_Z)
+	return ret
+}
+
+func (v *iterNative) readTypex_W(val *typex.W) bool {
+	elm, err := v.cur.Read()
+	if err != nil {
+		if err == io.EOF {
+			return false
+		}
+		panic(fmt.Sprintf("broken stream: %v", err))
+	}
+
+	*val = elm.Elm.Interface().(typex.W)
+	return true
+}
+
+func iterMakerTypex_W(s ReStream) ReusableInput {
+	ret := &iterNative{s: s}
+	ret.fn = reflect.ValueOf(ret.readTypex_W)
+	return ret
+}
+
+func (v *iterNative) readETTypex_W(et *typex.EventTime, val *typex.W) bool {
+	elm, err := v.cur.Read()
+	if err != nil {
+		if err == io.EOF {
+			return false
+		}
+		panic(fmt.Sprintf("broken stream: %v", err))
+	}
+
+	*et = elm.Timestamp
+	*val = elm.Elm.Interface().(typex.W)
+	return true
+}
+
+func iterMakerETTypex_W(s ReStream) ReusableInput {
+	ret := &iterNative{s: s}
+	ret.fn = reflect.ValueOf(ret.readETTypex_W)
+	return ret
+}
+
+func (v *iterNative) readTypex_WByteSlice(key *typex.W, value *[]byte) bool {
+	elm, err := v.cur.Read()
+	if err != nil {
+		if err == io.EOF {
+			return false
+		}
+		panic(fmt.Sprintf("broken stream: %v", err))
+	}
+
+	*key = elm.Elm.Interface().(typex.W)
+	*value = elm.Elm2.Interface().([]byte)
+	return true
+}
+
+func iterMakerTypex_WByteSlice(s ReStream) ReusableInput {
+	ret := &iterNative{s: s}
+	ret.fn = reflect.ValueOf(ret.readTypex_WByteSlice)
+	return ret
+}
+
+func (v *iterNative) readETTypex_WByteSlice(et *typex.EventTime, key *typex.W, value *[]byte) bool {
+	elm, err := v.cur.Read()
+	if err != nil {
+		if err == io.EOF {
+			return false
+		}
+		panic(fmt.Sprintf("broken stream: %v", err))
+	}
+
+	*et = elm.Timestamp
+	*key = elm.Elm.Interface().(typex.W)
+	*value = elm.Elm2.Interface().([]byte)
+	return true
+}
+
+func iterMakerETTypex_WByteSlice(s ReStream) ReusableInput {
+	ret := &iterNative{s: s}
+	ret.fn = reflect.ValueOf(ret.readETTypex_WByteSlice)
+	return ret
+}
+
+func (v *iterNative) readTypex_WBool(key *typex.W, value *bool) bool {
+	elm, err := v.cur.Read()
+	if err != nil {
+		if err == io.EOF {
+			return false
+		}
+		panic(fmt.Sprintf("broken stream: %v", err))
+	}
+
+	*key = elm.Elm.Interface().(typex.W)
+	*value = elm.Elm2.Interface().(bool)
+	return true
+}
+
+func iterMakerTypex_WBool(s ReStream) ReusableInput {
+	ret := &iterNative{s: s}
+	ret.fn = reflect.ValueOf(ret.readTypex_WBool)
+	return ret
+}
+
+func (v *iterNative) readETTypex_WBool(et *typex.EventTime, key *typex.W, value *bool) bool {
+	elm, err := v.cur.Read()
+	if err != nil {
+		if err == io.EOF {
+			return false
+		}
+		panic(fmt.Sprintf("broken stream: %v", err))
+	}
+
+	*et = elm.Timestamp
+	*key = elm.Elm.Interface().(typex.W)
+	*value = elm.Elm2.Interface().(bool)
+	return true
+}
+
+func iterMakerETTypex_WBool(s ReStream) ReusableInput {
+	ret := &iterNative{s: s}
+	ret.fn = reflect.ValueOf(ret.readETTypex_WBool)
+	return ret
+}
+
+func (v *iterNative) readTypex_WString(key *typex.W, value *string) bool {
+	elm, err := v.cur.Read()
+	if err != nil {
+		if err == io.EOF {
+			return false
+		}
+		panic(fmt.Sprintf("broken stream: %v", err))
+	}
+
+	*key = elm.Elm.Interface().(typex.W)
+	*value = elm.Elm2.Interface().(string)
+	return true
+}
+
+func iterMakerTypex_WString(s ReStream) ReusableInput {
+	ret := &iterNative{s: s}
+	ret.fn = reflect.ValueOf(ret.readTypex_WString)
+	return ret
+}
+
+func (v *iterNative) readETTypex_WString(et *typex.EventTime, key *typex.W, value *string) bool {
+	elm, err := v.cur.Read()
+	if err != nil {
+		if err == io.EOF {
+			return false
+		}
+		panic(fmt.Sprintf("broken stream: %v", err))
+	}
+
+	*et = elm.Timestamp
+	*key = elm.Elm.Interface().(typex.W)
+	*value = elm.Elm2.Interface().(string)
+	return true
+}
+
+func iterMakerETTypex_WString(s ReStream) ReusableInput {
+	ret := &iterNative{s: s}
+	ret.fn = reflect.ValueOf(ret.readETTypex_WString)
+	return ret
+}
+
+func (v *iterNative) readTypex_WInt(key *typex.W, value *int) bool {
+	elm, err := v.cur.Read()
+	if err != nil {
+		if err == io.EOF {
+			return false
+		}
+		panic(fmt.Sprintf("broken stream: %v", err))
+	}
+
+	*key = elm.Elm.Interface().(typex.W)
+	*value = elm.Elm2.Interface().(int)
+	return true
+}
+
+func iterMakerTypex_WInt(s ReStream) ReusableInput {
+	ret := &iterNative{s: s}
+	ret.fn = reflect.ValueOf(ret.readTypex_WInt)
+	return ret
+}
+
+func (v *iterNative) readETTypex_WInt(et *typex.EventTime, key *typex.W, value *int) bool {
+	elm, err := v.cur.Read()
+	if err != nil {
+		if err == io.EOF {
+			return false
+		}
+		panic(fmt.Sprintf("broken stream: %v", err))
+	}
+
+	*et = elm.Timestamp
+	*key = elm.Elm.Interface().(typex.W)
+	*value = elm.Elm2.Interface().(int)
+	return true
+}
+
+func iterMakerETTypex_WInt(s ReStream) ReusableInput {
+	ret := &iterNative{s: s}
+	ret.fn = reflect.ValueOf(ret.readETTypex_WInt)
+	return ret
+}
+
+func (v *iterNative) readTypex_WInt8(key *typex.W, value *int8) bool {
+	elm, err := v.cur.Read()
+	if err != nil {
+		if err == io.EOF {
+			return false
+		}
+		panic(fmt.Sprintf("broken stream: %v", err))
+	}
+
+	*key = elm.Elm.Interface().(typex.W)
+	*value = elm.Elm2.Interface().(int8)
+	return true
+}
+
+func iterMakerTypex_WInt8(s ReStream) ReusableInput {
+	ret := &iterNative{s: s}
+	ret.fn = reflect.ValueOf(ret.readTypex_WInt8)
+	return ret
+}
+
+func (v *iterNative) readETTypex_WInt8(et *typex.EventTime, key *typex.W, value *int8) bool {
+	elm, err := v.cur.Read()
+	if err != nil {
+		if err == io.EOF {
+			return false
+		}
+		panic(fmt.Sprintf("broken stream: %v", err))
+	}
+
+	*et = elm.Timestamp
+	*key = elm.Elm.Interface().(typex.W)
+	*value = elm.Elm2.Interface().(int8)
+	return true
+}
+
+func iterMakerETTypex_WInt8(s ReStream) ReusableInput {
+	ret := &iterNative{s: s}
+	ret.fn = reflect.ValueOf(ret.readETTypex_WInt8)
+	return ret
+}
+
+func (v *iterNative) readTypex_WInt16(key *typex.W, value *int16) bool {
+	elm, err := v.cur.Read()
+	if err != nil {
+		if err == io.EOF {
+			return false
+		}
+		panic(fmt.Sprintf("broken stream: %v", err))
+	}
+
+	*key = elm.Elm.Interface().(typex.W)
+	*value = elm.Elm2.Interface().(int16)
+	return true
+}
+
+func iterMakerTypex_WInt16(s ReStream) ReusableInput {
+	ret := &iterNative{s: s}
+	ret.fn = reflect.ValueOf(ret.readTypex_WInt16)
+	return ret
+}
+
+func (v *iterNative) readETTypex_WInt16(et *typex.EventTime, key *typex.W, value *int16) bool {
+	elm, err := v.cur.Read()
+	if err != nil {
+		if err == io.EOF {
+			return false
+		}
+		panic(fmt.Sprintf("broken stream: %v", err))
+	}
+
+	*et = elm.Timestamp
+	*key = elm.Elm.Interface().(typex.W)
+	*value = elm.Elm2.Interface().(int16)
+	return true
+}
+
+func iterMakerETTypex_WInt16(s ReStream) ReusableInput {
+	ret := &iterNative{s: s}
+	ret.fn = reflect.ValueOf(ret.readETTypex_WInt16)
+	return ret
+}
+
+func (v *iterNative) readTypex_WInt32(key *typex.W, value *int32) bool {
+	elm, err := v.cur.Read()
+	if err != nil {
+		if err == io.EOF {
+			return false
+		}
+		panic(fmt.Sprintf("broken stream: %v", err))
+	}
+
+	*key = elm.Elm.Interface().(typex.W)
+	*value = elm.Elm2.Interface().(int32)
+	return true
+}
+
+func iterMakerTypex_WInt32(s ReStream) ReusableInput {
+	ret := &iterNative{s: s}
+	ret.fn = reflect.ValueOf(ret.readTypex_WInt32)
+	return ret
+}
+
+func (v *iterNative) readETTypex_WInt32(et *typex.EventTime, key *typex.W, value *int32) bool {
+	elm, err := v.cur.Read()
+	if err != nil {
+		if err == io.EOF {
+			return false
+		}
+		panic(fmt.Sprintf("broken stream: %v", err))
+	}
+
+	*et = elm.Timestamp
+	*key = elm.Elm.Interface().(typex.W)
+	*value = elm.Elm2.Interface().(int32)
+	return true
+}
+
+func iterMakerETTypex_WInt32(s ReStream) ReusableInput {
+	ret := &iterNative{s: s}
+	ret.fn = reflect.ValueOf(ret.readETTypex_WInt32)
+	return ret
+}
+
+func (v *iterNative) readTypex_WInt64(key *typex.W, value *int64) bool {
+	elm, err := v.cur.Read()
+	if err != nil {
+		if err == io.EOF {
+			return false
+		}
+		panic(fmt.Sprintf("broken stream: %v", err))
+	}
+
+	*key = elm.Elm.Interface().(typex.W)
+	*value = elm.Elm2.Interface().(int64)
+	return true
+}
+
+func iterMakerTypex_WInt64(s ReStream) ReusableInput {
+	ret := &iterNative{s: s}
+	ret.fn = reflect.ValueOf(ret.readTypex_WInt64)
+	return ret
+}
+
+func (v *iterNative) readETTypex_WInt64(et *typex.EventTime, key *typex.W, value *int64) bool {
+	elm, err := v.cur.Read()
+	if err != nil {
+		if err == io.EOF {
+			return false
+		}
+		panic(fmt.Sprintf("broken stream: %v", err))
+	}
+
+	*et = elm.Timestamp
+	*key = elm.Elm.Interface().(typex.W)
+	*value = elm.Elm2.Interface().(int64)
+	return true
+}
+
+func iterMakerETTypex_WInt64(s ReStream) ReusableInput {
+	ret := &iterNative{s: s}
+	ret.fn = reflect.ValueOf(ret.readETTypex_WInt64)
+	return ret
+}
+
+func (v *iterNative) readTypex_WUint(key *typex.W, value *uint) bool {
+	elm, err := v.cur.Read()
+	if err != nil {
+		if err == io.EOF {
+			return false
+		}
+		panic(fmt.Sprintf("broken stream: %v", err))
+	}
+
+	*key = elm.Elm.Interface().(typex.W)
+	*value = elm.Elm2.Interface().(uint)
+	return true
+}
+
+func iterMakerTypex_WUint(s ReStream) ReusableInput {
+	ret := &iterNative{s: s}
+	ret.fn = reflect.ValueOf(ret.readTypex_WUint)
+	return ret
+}
+
+func (v *iterNative) readETTypex_WUint(et *typex.EventTime, key *typex.W, value *uint) bool {
+	elm, err := v.cur.Read()
+	if err != nil {
+		if err == io.EOF {
+			return false
+		}
+		panic(fmt.Sprintf("broken stream: %v", err))
+	}
+
+	*et = elm.Timestamp
+	*key = elm.Elm.Interface().(typex.W)
+	*value = elm.Elm2.Interface().(uint)
+	return true
+}
+
+func iterMakerETTypex_WUint(s ReStream) ReusableInput {
+	ret := &iterNative{s: s}
+	ret.fn = reflect.ValueOf(ret.readETTypex_WUint)
+	return ret
+}
+
+func (v *iterNative) readTypex_WUint8(key *typex.W, value *uint8) bool {
+	elm, err := v.cur.Read()
+	if err != nil {
+		if err == io.EOF {
+			return false
+		}
+		panic(fmt.Sprintf("broken stream: %v", err))
+	}
+
+	*key = elm.Elm.Interface().(typex.W)
+	*value = elm.Elm2.Interface().(uint8)
+	return true
+}
+
+func iterMakerTypex_WUint8(s ReStream) ReusableInput {
+	ret := &iterNative{s: s}
+	ret.fn = reflect.ValueOf(ret.readTypex_WUint8)
+	return ret
+}
+
+func (v *iterNative) readETTypex_WUint8(et *typex.EventTime, key *typex.W, value *uint8) bool {
+	elm, err := v.cur.Read()
+	if err != nil {
+		if err == io.EOF {
+			return false
+		}
+		panic(fmt.Sprintf("broken stream: %v", err))
+	}
+
+	*et = elm.Timestamp
+	*key = elm.Elm.Interface().(typex.W)
+	*value = elm.Elm2.Interface().(uint8)
+	return true
+}
+
+func iterMakerETTypex_WUint8(s ReStream) ReusableInput {
+	ret := &iterNative{s: s}
+	ret.fn = reflect.ValueOf(ret.readETTypex_WUint8)
+	return ret
+}
+
+func (v *iterNative) readTypex_WUint16(key *typex.W, value *uint16) bool {
+	elm, err := v.cur.Read()
+	if err != nil {
+		if err == io.EOF {
+			return false
+		}
+		panic(fmt.Sprintf("broken stream: %v", err))
+	}
+
+	*key = elm.Elm.Interface().(typex.W)
+	*value = elm.Elm2.Interface().(uint16)
+	return true
+}
+
+func iterMakerTypex_WUint16(s ReStream) ReusableInput {
+	ret := &iterNative{s: s}
+	ret.fn = reflect.ValueOf(ret.readTypex_WUint16)
+	return ret
+}
+
+func (v *iterNative) readETTypex_WUint16(et *typex.EventTime, key *typex.W, value *uint16) bool {
+	elm, err := v.cur.Read()
+	if err != nil {
+		if err == io.EOF {
+			return false
+		}
+		panic(fmt.Sprintf("broken stream: %v", err))
+	}
+
+	*et = elm.Timestamp
+	*key = elm.Elm.Interface().(typex.W)
+	*value = elm.Elm2.Interface().(uint16)
+	return true
+}
+
+func iterMakerETTypex_WUint16(s ReStream) ReusableInput {
+	ret := &iterNative{s: s}
+	ret.fn = reflect.ValueOf(ret.readETTypex_WUint16)
+	return ret
+}
+
+func (v *iterNative) readTypex_WUint32(key *typex.W, value *uint32) bool {
+	elm, err := v.cur.Read()
+	if err != nil {
+		if err == io.EOF {
+			return false
+		}
+		panic(fmt.Sprintf("broken stream: %v", err))
+	}
+
+	*key = elm.Elm.Interface().(typex.W)
+	*value = elm.Elm2.Interface().(uint32)
+	return true
+}
+
+func iterMakerTypex_WUint32(s ReStream) ReusableInput {
+	ret := &iterNative{s: s}
+	ret.fn = reflect.ValueOf(ret.readTypex_WUint32)
+	return ret
+}
+
+func (v *iterNative) readETTypex_WUint32(et *typex.EventTime, key *typex.W, value *uint32) bool {
+	elm, err := v.cur.Read()
+	if err != nil {
+		if err == io.EOF {
+			return false
+		}
+		panic(fmt.Sprintf("broken stream: %v", err))
+	}
+
+	*et = elm.Timestamp
+	*key = elm.Elm.Interface().(typex.W)
+	*value = elm.Elm2.Interface().(uint32)
+	return true
+}
+
+func iterMakerETTypex_WUint32(s ReStream) ReusableInput {
+	ret := &iterNative{s: s}
+	ret.fn = reflect.ValueOf(ret.readETTypex_WUint32)
+	return ret
+}
+
+func (v *iterNative) readTypex_WUint64(key *typex.W, value *uint64) bool {
+	elm, err := v.cur.Read()
+	if err != nil {
+		if err == io.EOF {
+			return false
+		}
+		panic(fmt.Sprintf("broken stream: %v", err))
+	}
+
+	*key = elm.Elm.Interface().(typex.W)
+	*value = elm.Elm2.Interface().(uint64)
+	return true
+}
+
+func iterMakerTypex_WUint64(s ReStream) ReusableInput {
+	ret := &iterNative{s: s}
+	ret.fn = reflect.ValueOf(ret.readTypex_WUint64)
+	return ret
+}
+
+func (v *iterNative) readETTypex_WUint64(et *typex.EventTime, key *typex.W, value *uint64) bool {
+	elm, err := v.cur.Read()
+	if err != nil {
+		if err == io.EOF {
+			return false
+		}
+		panic(fmt.Sprintf("broken stream: %v", err))
+	}
+
+	*et = elm.Timestamp
+	*key = elm.Elm.Interface().(typex.W)
+	*value = elm.Elm2.Interface().(uint64)
+	return true
+}
+
+func iterMakerETTypex_WUint64(s ReStream) ReusableInput {
+	ret := &iterNative{s: s}
+	ret.fn = reflect.ValueOf(ret.readETTypex_WUint64)
+	return ret
+}
+
+func (v *iterNative) readTypex_WFloat32(key *typex.W, value *float32) bool {
+	elm, err := v.cur.Read()
+	if err != nil {
+		if err == io.EOF {
+			return false
+		}
+		panic(fmt.Sprintf("broken stream: %v", err))
+	}
+
+	*key = elm.Elm.Interface().(typex.W)
+	*value = elm.Elm2.Interface().(float32)
+	return true
+}
+
+func iterMakerTypex_WFloat32(s ReStream) ReusableInput {
+	ret := &iterNative{s: s}
+	ret.fn = reflect.ValueOf(ret.readTypex_WFloat32)
+	return ret
+}
+
+func (v *iterNative) readETTypex_WFloat32(et *typex.EventTime, key *typex.W, value *float32) bool {
+	elm, err := v.cur.Read()
+	if err != nil {
+		if err == io.EOF {
+			return false
+		}
+		panic(fmt.Sprintf("broken stream: %v", err))
+	}
+
+	*et = elm.Timestamp
+	*key = elm.Elm.Interface().(typex.W)
+	*value = elm.Elm2.Interface().(float32)
+	return true
+}
+
+func iterMakerETTypex_WFloat32(s ReStream) ReusableInput {
+	ret := &iterNative{s: s}
+	ret.fn = reflect.ValueOf(ret.readETTypex_WFloat32)
+	return ret
+}
+
+func (v *iterNative) readTypex_WFloat64(key *typex.W, value *float64) bool {
+	elm, err := v.cur.Read()
+	if err != nil {
+		if err == io.EOF {
+			return false
+		}
+		panic(fmt.Sprintf("broken stream: %v", err))
+	}
+
+	*key = elm.Elm.Interface().(typex.W)
+	*value = elm.Elm2.Interface().(float64)
+	return true
+}
+
+func iterMakerTypex_WFloat64(s ReStream) ReusableInput {
+	ret := &iterNative{s: s}
+	ret.fn = reflect.ValueOf(ret.readTypex_WFloat64)
+	return ret
+}
+
+func (v *iterNative) readETTypex_WFloat64(et *typex.EventTime, key *typex.W, value *float64) bool {
+	elm, err := v.cur.Read()
+	if err != nil {
+		if err == io.EOF {
+			return false
+		}
+		panic(fmt.Sprintf("broken stream: %v", err))
+	}
+
+	*et = elm.Timestamp
+	*key = elm.Elm.Interface().(typex.W)
+	*value = elm.Elm2.Interface().(float64)
+	return true
+}
+
+func iterMakerETTypex_WFloat64(s ReStream) ReusableInput {
+	ret := &iterNative{s: s}
+	ret.fn = reflect.ValueOf(ret.readETTypex_WFloat64)
+	return ret
+}
+
+func (v *iterNative) readTypex_WTypex_T(key *typex.W, value *typex.T) bool {
+	elm, err := v.cur.Read()
+	if err != nil {
+		if err == io.EOF {
+			return false
+		}
+		panic(fmt.Sprintf("broken stream: %v", err))
+	}
+
+	*key = elm.Elm.Interface().(typex.W)
+	*value = elm.Elm2.Interface().(typex.T)
+	return true
+}
+
+func iterMakerTypex_WTypex_T(s ReStream) ReusableInput {
+	ret := &iterNative{s: s}
+	ret.fn = reflect.ValueOf(ret.readTypex_WTypex_T)
+	return ret
+}
+
+func (v *iterNative) readETTypex_WTypex_T(et *typex.EventTime, key *typex.W, value *typex.T) bool {
+	elm, err := v.cur.Read()
+	if err != nil {
+		if err == io.EOF {
+			return false
+		}
+		panic(fmt.Sprintf("broken stream: %v", err))
+	}
+
+	*et = elm.Timestamp
+	*key = elm.Elm.Interface().(typex.W)
+	*value = elm.Elm2.Interface().(typex.T)
+	return true
+}
+
+func iterMakerETTypex_WTypex_T(s ReStream) ReusableInput {
+	ret := &iterNative{s: s}
+	ret.fn = reflect.ValueOf(ret.readETTypex_WTypex_T)
+	return ret
+}
+
+func (v *iterNative) readTypex_WTypex_U(key *typex.W, value *typex.U) bool {
+	elm, err := v.cur.Read()
+	if err != nil {
+		if err == io.EOF {
+			return false
+		}
+		panic(fmt.Sprintf("broken stream: %v", err))
+	}
+
+	*key = elm.Elm.Interface().(typex.W)
+	*value = elm.Elm2.Interface().(typex.U)
+	return true
+}
+
+func iterMakerTypex_WTypex_U(s ReStream) ReusableInput {
+	ret := &iterNative{s: s}
+	ret.fn = reflect.ValueOf(ret.readTypex_WTypex_U)
+	return ret
+}
+
+func (v *iterNative) readETTypex_WTypex_U(et *typex.EventTime, key *typex.W, value *typex.U) bool {
+	elm, err := v.cur.Read()
+	if err != nil {
+		if err == io.EOF {
+			return false
+		}
+		panic(fmt.Sprintf("broken stream: %v", err))
+	}
+
+	*et = elm.Timestamp
+	*key = elm.Elm.Interface().(typex.W)
+	*value = elm.Elm2.Interface().(typex.U)
+	return true
+}
+
+func iterMakerETTypex_WTypex_U(s ReStream) ReusableInput {
+	ret := &iterNative{s: s}
+	ret.fn = reflect.ValueOf(ret.readETTypex_WTypex_U)
+	return ret
+}
+
+func (v *iterNative) readTypex_WTypex_V(key *typex.W, value *typex.V) bool {
+	elm, err := v.cur.Read()
+	if err != nil {
+		if err == io.EOF {
+			return false
+		}
+		panic(fmt.Sprintf("broken stream: %v", err))
+	}
+
+	*key = elm.Elm.Interface().(typex.W)
+	*value = elm.Elm2.Interface().(typex.V)
+	return true
+}
+
+func iterMakerTypex_WTypex_V(s ReStream) ReusableInput {
+	ret := &iterNative{s: s}
+	ret.fn = reflect.ValueOf(ret.readTypex_WTypex_V)
+	return ret
+}
+
+func (v *iterNative) readETTypex_WTypex_V(et *typex.EventTime, key *typex.W, value *typex.V) bool {
+	elm, err := v.cur.Read()
+	if err != nil {
+		if err == io.EOF {
+			return false
+		}
+		panic(fmt.Sprintf("broken stream: %v", err))
+	}
+
+	*et = elm.Timestamp
+	*key = elm.Elm.Interface().(typex.W)
+	*value = elm.Elm2.Interface().(typex.V)
+	return true
+}
+
+func iterMakerETTypex_WTypex_V(s ReStream) ReusableInput {
+	ret := &iterNative{s: s}
+	ret.fn = reflect.ValueOf(ret.readETTypex_WTypex_V)
+	return ret
+}
+
+func (v *iterNative) readTypex_WTypex_W(key *typex.W, value *typex.W) bool {
+	elm, err := v.cur.Read()
+	if err != nil {
+		if err == io.EOF {
+			return false
+		}
+		panic(fmt.Sprintf("broken stream: %v", err))
+	}
+
+	*key = elm.Elm.Interface().(typex.W)
+	*value = elm.Elm2.Interface().(typex.W)
+	return true
+}
+
+func iterMakerTypex_WTypex_W(s ReStream) ReusableInput {
+	ret := &iterNative{s: s}
+	ret.fn = reflect.ValueOf(ret.readTypex_WTypex_W)
+	return ret
+}
+
+func (v *iterNative) readETTypex_WTypex_W(et *typex.EventTime, key *typex.W, value *typex.W) bool {
+	elm, err := v.cur.Read()
+	if err != nil {
+		if err == io.EOF {
+			return false
+		}
+		panic(fmt.Sprintf("broken stream: %v", err))
+	}
+
+	*et = elm.Timestamp
+	*key = elm.Elm.Interface().(typex.W)
+	*value = elm.Elm2.Interface().(typex.W)
+	return true
+}
+
+func iterMakerETTypex_WTypex_W(s ReStream) ReusableInput {
+	ret := &iterNative{s: s}
+	ret.fn = reflect.ValueOf(ret.readETTypex_WTypex_W)
+	return ret
+}
+
+func (v *iterNative) readTypex_WTypex_X(key *typex.W, value *typex.X) bool {
+	elm, err := v.cur.Read()
+	if err != nil {
+		if err == io.EOF {
+			return false
+		}
+		panic(fmt.Sprintf("broken stream: %v", err))
+	}
+
+	*key = elm.Elm.Interface().(typex.W)
+	*value = elm.Elm2.Interface().(typex.X)
+	return true
+}
+
+func iterMakerTypex_WTypex_X(s ReStream) ReusableInput {
+	ret := &iterNative{s: s}
+	ret.fn = reflect.ValueOf(ret.readTypex_WTypex_X)
+	return ret
+}
+
+func (v *iterNative) readETTypex_WTypex_X(et *typex.EventTime, key *typex.W, value *typex.X) bool {
+	elm, err := v.cur.Read()
+	if err != nil {
+		if err == io.EOF {
+			return false
+		}
+		panic(fmt.Sprintf("broken stream: %v", err))
+	}
+
+	*et = elm.Timestamp
+	*key = elm.Elm.Interface().(typex.W)
+	*value = elm.Elm2.Interface().(typex.X)
+	return true
+}
+
+func iterMakerETTypex_WTypex_X(s ReStream) ReusableInput {
+	ret := &iterNative{s: s}
+	ret.fn = reflect.ValueOf(ret.readETTypex_WTypex_X)
+	return ret
+}
+
+func (v *iterNative) readTypex_WTypex_Y(key *typex.W, value *typex.Y) bool {
+	elm, err := v.cur.Read()
+	if err != nil {
+		if err == io.EOF {
+			return false
+		}
+		panic(fmt.Sprintf("broken stream: %v", err))
+	}
+
+	*key = elm.Elm.Interface().(typex.W)
+	*value = elm.Elm2.Interface().(typex.Y)
+	return true
+}
+
+func iterMakerTypex_WTypex_Y(s ReStream) ReusableInput {
+	ret := &iterNative{s: s}
+	ret.fn = reflect.ValueOf(ret.readTypex_WTypex_Y)
+	return ret
+}
+
+func (v *iterNative) readETTypex_WTypex_Y(et *typex.EventTime, key *typex.W, value *typex.Y) bool {
+	elm, err := v.cur.Read()
+	if err != nil {
+		if err == io.EOF {
+			return false
+		}
+		panic(fmt.Sprintf("broken stream: %v", err))
+	}
+
+	*et = elm.Timestamp
+	*key = elm.Elm.Interface().(typex.W)
+	*value = elm.Elm2.Interface().(typex.Y)
+	return true
+}
+
+func iterMakerETTypex_WTypex_Y(s ReStream) ReusableInput {
+	ret := &iterNative{s: s}
+	ret.fn = reflect.ValueOf(ret.readETTypex_WTypex_Y)
+	return ret
+}
+
+func (v *iterNative) readTypex_WTypex_Z(key *typex.W, value *typex.Z) bool {
+	elm, err := v.cur.Read()
+	if err != nil {
+		if err == io.EOF {
+			return false
+		}
+		panic(fmt.Sprintf("broken stream: %v", err))
+	}
+
+	*key = elm.Elm.Interface().(typex.W)
+	*value = elm.Elm2.Interface().(typex.Z)
+	return true
+}
+
+func iterMakerTypex_WTypex_Z(s ReStream) ReusableInput {
+	ret := &iterNative{s: s}
+	ret.fn = reflect.ValueOf(ret.readTypex_WTypex_Z)
+	return ret
+}
+
+func (v *iterNative) readETTypex_WTypex_Z(et *typex.EventTime, key *typex.W, value *typex.Z) bool {
+	elm, err := v.cur.Read()
+	if err != nil {
+		if err == io.EOF {
+			return false
+		}
+		panic(fmt.Sprintf("broken stream: %v", err))
+	}
+
+	*et = elm.Timestamp
+	*key = elm.Elm.Interface().(typex.W)
+	*value = elm.Elm2.Interface().(typex.Z)
+	return true
+}
+
+func iterMakerETTypex_WTypex_Z(s ReStream) ReusableInput {
+	ret := &iterNative{s: s}
+	ret.fn = reflect.ValueOf(ret.readETTypex_WTypex_Z)
+	return ret
+}
+
+func (v *iterNative) readTypex_X(val *typex.X) bool {
+	elm, err := v.cur.Read()
+	if err != nil {
+		if err == io.EOF {
+			return false
+		}
+		panic(fmt.Sprintf("broken stream: %v", err))
+	}
+
+	*val = elm.Elm.Interface().(typex.X)
+	return true
+}
+
+func iterMakerTypex_X(s ReStream) ReusableInput {
+	ret := &iterNative{s: s}
+	ret.fn = reflect.ValueOf(ret.readTypex_X)
+	return ret
+}
+
+func (v *iterNative) readETTypex_X(et *typex.EventTime, val *typex.X) bool {
+	elm, err := v.cur.Read()
+	if err != nil {
+		if err == io.EOF {
+			return false
+		}
+		panic(fmt.Sprintf("broken stream: %v", err))
+	}
+
+	*et = elm.Timestamp
+	*val = elm.Elm.Interface().(typex.X)
+	return true
+}
+
+func iterMakerETTypex_X(s ReStream) ReusableInput {
+	ret := &iterNative{s: s}
+	ret.fn = reflect.ValueOf(ret.readETTypex_X)
+	return ret
+}
+
+func (v *iterNative) readTypex_XByteSlice(key *typex.X, value *[]byte) bool {
+	elm, err := v.cur.Read()
+	if err != nil {
+		if err == io.EOF {
+			return false
+		}
+		panic(fmt.Sprintf("broken stream: %v", err))
+	}
+
+	*key = elm.Elm.Interface().(typex.X)
+	*value = elm.Elm2.Interface().([]byte)
+	return true
+}
+
+func iterMakerTypex_XByteSlice(s ReStream) ReusableInput {
+	ret := &iterNative{s: s}
+	ret.fn = reflect.ValueOf(ret.readTypex_XByteSlice)
+	return ret
+}
+
+func (v *iterNative) readETTypex_XByteSlice(et *typex.EventTime, key *typex.X, value *[]byte) bool {
+	elm, err := v.cur.Read()
+	if err != nil {
+		if err == io.EOF {
+			return false
+		}
+		panic(fmt.Sprintf("broken stream: %v", err))
+	}
+
+	*et = elm.Timestamp
+	*key = elm.Elm.Interface().(typex.X)
+	*value = elm.Elm2.Interface().([]byte)
+	return true
+}
+
+func iterMakerETTypex_XByteSlice(s ReStream) ReusableInput {
+	ret := &iterNative{s: s}
+	ret.fn = reflect.ValueOf(ret.readETTypex_XByteSlice)
+	return ret
+}
+
+func (v *iterNative) readTypex_XBool(key *typex.X, value *bool) bool {
+	elm, err := v.cur.Read()
+	if err != nil {
+		if err == io.EOF {
+			return false
+		}
+		panic(fmt.Sprintf("broken stream: %v", err))
+	}
+
+	*key = elm.Elm.Interface().(typex.X)
+	*value = elm.Elm2.Interface().(bool)
+	return true
+}
+
+func iterMakerTypex_XBool(s ReStream) ReusableInput {
+	ret := &iterNative{s: s}
+	ret.fn = reflect.ValueOf(ret.readTypex_XBool)
+	return ret
+}
+
+func (v *iterNative) readETTypex_XBool(et *typex.EventTime, key *typex.X, value *bool) bool {
+	elm, err := v.cur.Read()
+	if err != nil {
+		if err == io.EOF {
+			return false
+		}
+		panic(fmt.Sprintf("broken stream: %v", err))
+	}
+
+	*et = elm.Timestamp
+	*key = elm.Elm.Interface().(typex.X)
+	*value = elm.Elm2.Interface().(bool)
+	return true
+}
+
+func iterMakerETTypex_XBool(s ReStream) ReusableInput {
+	ret := &iterNative{s: s}
+	ret.fn = reflect.ValueOf(ret.readETTypex_XBool)
+	return ret
+}
+
+func (v *iterNative) readTypex_XString(key *typex.X, value *string) bool {
+	elm, err := v.cur.Read()
+	if err != nil {
+		if err == io.EOF {
+			return false
+		}
+		panic(fmt.Sprintf("broken stream: %v", err))
+	}
+
+	*key = elm.Elm.Interface().(typex.X)
+	*value = elm.Elm2.Interface().(string)
+	return true
+}
+
+func iterMakerTypex_XString(s ReStream) ReusableInput {
+	ret := &iterNative{s: s}
+	ret.fn = reflect.ValueOf(ret.readTypex_XString)
+	return ret
+}
+
+func (v *iterNative) readETTypex_XString(et *typex.EventTime, key *typex.X, value *string) bool {
+	elm, err := v.cur.Read()
+	if err != nil {
+		if err == io.EOF {
+			return false
+		}
+		panic(fmt.Sprintf("broken stream: %v", err))
+	}
+
+	*et = elm.Timestamp
+	*key = elm.Elm.Interface().(typex.X)
+	*value = elm.Elm2.Interface().(string)
+	return true
+}
+
+func iterMakerETTypex_XString(s ReStream) ReusableInput {
+	ret := &iterNative{s: s}
+	ret.fn = reflect.ValueOf(ret.readETTypex_XString)
+	return ret
+}
+
+func (v *iterNative) readTypex_XInt(key *typex.X, value *int) bool {
+	elm, err := v.cur.Read()
+	if err != nil {
+		if err == io.EOF {
+			return false
+		}
+		panic(fmt.Sprintf("broken stream: %v", err))
+	}
+
+	*key = elm.Elm.Interface().(typex.X)
+	*value = elm.Elm2.Interface().(int)
+	return true
+}
+
+func iterMakerTypex_XInt(s ReStream) ReusableInput {
+	ret := &iterNative{s: s}
+	ret.fn = reflect.ValueOf(ret.readTypex_XInt)
+	return ret
+}
+
+func (v *iterNative) readETTypex_XInt(et *typex.EventTime, key *typex.X, value *int) bool {
+	elm, err := v.cur.Read()
+	if err != nil {
+		if err == io.EOF {
+			return false
+		}
+		panic(fmt.Sprintf("broken stream: %v", err))
+	}
+
+	*et = elm.Timestamp
+	*key = elm.Elm.Interface().(typex.X)
+	*value = elm.Elm2.Interface().(int)
+	return true
+}
+
+func iterMakerETTypex_XInt(s ReStream) ReusableInput {
+	ret := &iterNative{s: s}
+	ret.fn = reflect.ValueOf(ret.readETTypex_XInt)
+	return ret
+}
+
+func (v *iterNative) readTypex_XInt8(key *typex.X, value *int8) bool {
+	elm, err := v.cur.Read()
+	if err != nil {
+		if err == io.EOF {
+			return false
+		}
+		panic(fmt.Sprintf("broken stream: %v", err))
+	}
+
+	*key = elm.Elm.Interface().(typex.X)
+	*value = elm.Elm2.Interface().(int8)
+	return true
+}
+
+func iterMakerTypex_XInt8(s ReStream) ReusableInput {
+	ret := &iterNative{s: s}
+	ret.fn = reflect.ValueOf(ret.readTypex_XInt8)
+	return ret
+}
+
+func (v *iterNative) readETTypex_XInt8(et *typex.EventTime, key *typex.X, value *int8) bool {
+	elm, err := v.cur.Read()
+	if err != nil {
+		if err == io.EOF {
+			return false
+		}
+		panic(fmt.Sprintf("broken stream: %v", err))
+	}
+
+	*et = elm.Timestamp
+	*key = elm.Elm.Interface().(typex.X)
+	*value = elm.Elm2.Interface().(int8)
+	return true
+}
+
+func iterMakerETTypex_XInt8(s ReStream) ReusableInput {
+	ret := &iterNative{s: s}
+	ret.fn = reflect.ValueOf(ret.readETTypex_XInt8)
+	return ret
+}
+
+func (v *iterNative) readTypex_XInt16(key *typex.X, value *int16) bool {
+	elm, err := v.cur.Read()
+	if err != nil {
+		if err == io.EOF {
+			return false
+		}
+		panic(fmt.Sprintf("broken stream: %v", err))
+	}
+
+	*key = elm.Elm.Interface().(typex.X)
+	*value = elm.Elm2.Interface().(int16)
+	return true
+}
+
+func iterMakerTypex_XInt16(s ReStream) ReusableInput {
+	ret := &iterNative{s: s}
+	ret.fn = reflect.ValueOf(ret.readTypex_XInt16)
+	return ret
+}
+
+func (v *iterNative) readETTypex_XInt16(et *typex.EventTime, key *typex.X, value *int16) bool {
+	elm, err := v.cur.Read()
+	if err != nil {
+		if err == io.EOF {
+			return false
+		}
+		panic(fmt.Sprintf("broken stream: %v", err))
+	}
+
+	*et = elm.Timestamp
+	*key = elm.Elm.Interface().(typex.X)
+	*value = elm.Elm2.Interface().(int16)
+	return true
+}
+
+func iterMakerETTypex_XInt16(s ReStream) ReusableInput {
+	ret := &iterNative{s: s}
+	ret.fn = reflect.ValueOf(ret.readETTypex_XInt16)
+	return ret
+}
+
+func (v *iterNative) readTypex_XInt32(key *typex.X, value *int32) bool {
+	elm, err := v.cur.Read()
+	if err != nil {
+		if err == io.EOF {
+			return false
+		}
+		panic(fmt.Sprintf("broken stream: %v", err))
+	}
+
+	*key = elm.Elm.Interface().(typex.X)
+	*value = elm.Elm2.Interface().(int32)
+	return true
+}
+
+func iterMakerTypex_XInt32(s ReStream) ReusableInput {
+	ret := &iterNative{s: s}
+	ret.fn = reflect.ValueOf(ret.readTypex_XInt32)
+	return ret
+}
+
+func (v *iterNative) readETTypex_XInt32(et *typex.EventTime, key *typex.X, value *int32) bool {
+	elm, err := v.cur.Read()
+	if err != nil {
+		if err == io.EOF {
+			return false
+		}
+		panic(fmt.Sprintf("broken stream: %v", err))
+	}
+
+	*et = elm.Timestamp
+	*key = elm.Elm.Interface().(typex.X)
+	*value = elm.Elm2.Interface().(int32)
+	return true
+}
+
+func iterMakerETTypex_XInt32(s ReStream) ReusableInput {
+	ret := &iterNative{s: s}
+	ret.fn = reflect.ValueOf(ret.readETTypex_XInt32)
+	return ret
+}
+
+func (v *iterNative) readTypex_XInt64(key *typex.X, value *int64) bool {
+	elm, err := v.cur.Read()
+	if err != nil {
+		if err == io.EOF {
+			return false
+		}
+		panic(fmt.Sprintf("broken stream: %v", err))
+	}
+
+	*key = elm.Elm.Interface().(typex.X)
+	*value = elm.Elm2.Interface().(int64)
+	return true
+}
+
+func iterMakerTypex_XInt64(s ReStream) ReusableInput {
+	ret := &iterNative{s: s}
+	ret.fn = reflect.ValueOf(ret.readTypex_XInt64)
+	return ret
+}
+
+func (v *iterNative) readETTypex_XInt64(et *typex.EventTime, key *typex.X, value *int64) bool {
+	elm, err := v.cur.Read()
+	if err != nil {
+		if err == io.EOF {
+			return false
+		}
+		panic(fmt.Sprintf("broken stream: %v", err))
+	}
+
+	*et = elm.Timestamp
+	*key = elm.Elm.Interface().(typex.X)
+	*value = elm.Elm2.Interface().(int64)
+	return true
+}
+
+func iterMakerETTypex_XInt64(s ReStream) ReusableInput {
+	ret := &iterNative{s: s}
+	ret.fn = reflect.ValueOf(ret.readETTypex_XInt64)
+	return ret
+}
+
+func (v *iterNative) readTypex_XUint(key *typex.X, value *uint) bool {
+	elm, err := v.cur.Read()
+	if err != nil {
+		if err == io.EOF {
+			return false
+		}
+		panic(fmt.Sprintf("broken stream: %v", err))
+	}
+
+	*key = elm.Elm.Interface().(typex.X)
+	*value = elm.Elm2.Interface().(uint)
+	return true
+}
+
+func iterMakerTypex_XUint(s ReStream) ReusableInput {
+	ret := &iterNative{s: s}
+	ret.fn = reflect.ValueOf(ret.readTypex_XUint)
+	return ret
+}
+
+func (v *iterNative) readETTypex_XUint(et *typex.EventTime, key *typex.X, value *uint) bool {
+	elm, err := v.cur.Read()
+	if err != nil {
+		if err == io.EOF {
+			return false
+		}
+		panic(fmt.Sprintf("broken stream: %v", err))
+	}
+
+	*et = elm.Timestamp
+	*key = elm.Elm.Interface().(typex.X)
+	*value = elm.Elm2.Interface().(uint)
+	return true
+}
+
+func iterMakerETTypex_XUint(s ReStream) ReusableInput {
+	ret := &iterNative{s: s}
+	ret.fn = reflect.ValueOf(ret.readETTypex_XUint)
+	return ret
+}
+
+func (v *iterNative) readTypex_XUint8(key *typex.X, value *uint8) bool {
+	elm, err := v.cur.Read()
+	if err != nil {
+		if err == io.EOF {
+			return false
+		}
+		panic(fmt.Sprintf("broken stream: %v", err))
+	}
+
+	*key = elm.Elm.Interface().(typex.X)
+	*value = elm.Elm2.Interface().(uint8)
+	return true
+}
+
+func iterMakerTypex_XUint8(s ReStream) ReusableInput {
+	ret := &iterNative{s: s}
+	ret.fn = reflect.ValueOf(ret.readTypex_XUint8)
+	return ret
+}
+
+func (v *iterNative) readETTypex_XUint8(et *typex.EventTime, key *typex.X, value *uint8) bool {
+	elm, err := v.cur.Read()
+	if err != nil {
+		if err == io.EOF {
+			return false
+		}
+		panic(fmt.Sprintf("broken stream: %v", err))
+	}
+
+	*et = elm.Timestamp
+	*key = elm.Elm.Interface().(typex.X)
+	*value = elm.Elm2.Interface().(uint8)
+	return true
+}
+
+func iterMakerETTypex_XUint8(s ReStream) ReusableInput {
+	ret := &iterNative{s: s}
+	ret.fn = reflect.ValueOf(ret.readETTypex_XUint8)
+	return ret
+}
+
+func (v *iterNative) readTypex_XUint16(key *typex.X, value *uint16) bool {
+	elm, err := v.cur.Read()
+	if err != nil {
+		if err == io.EOF {
+			return false
+		}
+		panic(fmt.Sprintf("broken stream: %v", err))
+	}
+
+	*key = elm.Elm.Interface().(typex.X)
+	*value = elm.Elm2.Interface().(uint16)
+	return true
+}
+
+func iterMakerTypex_XUint16(s ReStream) ReusableInput {
+	ret := &iterNative{s: s}
+	ret.fn = reflect.ValueOf(ret.readTypex_XUint16)
+	return ret
+}
+
+func (v *iterNative) readETTypex_XUint16(et *typex.EventTime, key *typex.X, value *uint16) bool {
+	elm, err := v.cur.Read()
+	if err != nil {
+		if err == io.EOF {
+			return false
+		}
+		panic(fmt.Sprintf("broken stream: %v", err))
+	}
+
+	*et = elm.Timestamp
+	*key = elm.Elm.Interface().(typex.X)
+	*value = elm.Elm2.Interface().(uint16)
+	return true
+}
+
+func iterMakerETTypex_XUint16(s ReStream) ReusableInput {
+	ret := &iterNative{s: s}
+	ret.fn = reflect.ValueOf(ret.readETTypex_XUint16)
+	return ret
+}
+
+func (v *iterNative) readTypex_XUint32(key *typex.X, value *uint32) bool {
+	elm, err := v.cur.Read()
+	if err != nil {
+		if err == io.EOF {
+			return false
+		}
+		panic(fmt.Sprintf("broken stream: %v", err))
+	}
+
+	*key = elm.Elm.Interface().(typex.X)
+	*value = elm.Elm2.Interface().(uint32)
+	return true
+}
+
+func iterMakerTypex_XUint32(s ReStream) ReusableInput {
+	ret := &iterNative{s: s}
+	ret.fn = reflect.ValueOf(ret.readTypex_XUint32)
+	return ret
+}
+
+func (v *iterNative) readETTypex_XUint32(et *typex.EventTime, key *typex.X, value *uint32) bool {
+	elm, err := v.cur.Read()
+	if err != nil {
+		if err == io.EOF {
+			return false
+		}
+		panic(fmt.Sprintf("broken stream: %v", err))
+	}
+
+	*et = elm.Timestamp
+	*key = elm.Elm.Interface().(typex.X)
+	*value = elm.Elm2.Interface().(uint32)
+	return true
+}
+
+func iterMakerETTypex_XUint32(s ReStream) ReusableInput {
+	ret := &iterNative{s: s}
+	ret.fn = reflect.ValueOf(ret.readETTypex_XUint32)
+	return ret
+}
+
+func (v *iterNative) readTypex_XUint64(key *typex.X, value *uint64) bool {
+	elm, err := v.cur.Read()
+	if err != nil {
+		if err == io.EOF {
+			return false
+		}
+		panic(fmt.Sprintf("broken stream: %v", err))
+	}
+
+	*key = elm.Elm.Interface().(typex.X)
+	*value = elm.Elm2.Interface().(uint64)
+	return true
+}
+
+func iterMakerTypex_XUint64(s ReStream) ReusableInput {
+	ret := &iterNative{s: s}
+	ret.fn = reflect.ValueOf(ret.readTypex_XUint64)
+	return ret
+}
+
+func (v *iterNative) readETTypex_XUint64(et *typex.EventTime, key *typex.X, value *uint64) bool {
+	elm, err := v.cur.Read()
+	if err != nil {
+		if err == io.EOF {
+			return false
+		}
+		panic(fmt.Sprintf("broken stream: %v", err))
+	}
+
+	*et = elm.Timestamp
+	*key = elm.Elm.Interface().(typex.X)
+	*value = elm.Elm2.Interface().(uint64)
+	return true
+}
+
+func iterMakerETTypex_XUint64(s ReStream) ReusableInput {
+	ret := &iterNative{s: s}
+	ret.fn = reflect.ValueOf(ret.readETTypex_XUint64)
+	return ret
+}
+
+func (v *iterNative) readTypex_XFloat32(key *typex.X, value *float32) bool {
+	elm, err := v.cur.Read()
+	if err != nil {
+		if err == io.EOF {
+			return false
+		}
+		panic(fmt.Sprintf("broken stream: %v", err))
+	}
+
+	*key = elm.Elm.Interface().(typex.X)
+	*value = elm.Elm2.Interface().(float32)
+	return true
+}
+
+func iterMakerTypex_XFloat32(s ReStream) ReusableInput {
+	ret := &iterNative{s: s}
+	ret.fn = reflect.ValueOf(ret.readTypex_XFloat32)
+	return ret
+}
+
+func (v *iterNative) readETTypex_XFloat32(et *typex.EventTime, key *typex.X, value *float32) bool {
+	elm, err := v.cur.Read()
+	if err != nil {
+		if err == io.EOF {
+			return false
+		}
+		panic(fmt.Sprintf("broken stream: %v", err))
+	}
+
+	*et = elm.Timestamp
+	*key = elm.Elm.Interface().(typex.X)
+	*value = elm.Elm2.Interface().(float32)
+	return true
+}
+
+func iterMakerETTypex_XFloat32(s ReStream) ReusableInput {
+	ret := &iterNative{s: s}
+	ret.fn = reflect.ValueOf(ret.readETTypex_XFloat32)
+	return ret
+}
+
+func (v *iterNative) readTypex_XFloat64(key *typex.X, value *float64) bool {
+	elm, err := v.cur.Read()
+	if err != nil {
+		if err == io.EOF {
+			return false
+		}
+		panic(fmt.Sprintf("broken stream: %v", err))
+	}
+
+	*key = elm.Elm.Interface().(typex.X)
+	*value = elm.Elm2.Interface().(float64)
+	return true
+}
+
+func iterMakerTypex_XFloat64(s ReStream) ReusableInput {
+	ret := &iterNative{s: s}
+	ret.fn = reflect.ValueOf(ret.readTypex_XFloat64)
+	return ret
+}
+
+func (v *iterNative) readETTypex_XFloat64(et *typex.EventTime, key *typex.X, value *float64) bool {
+	elm, err := v.cur.Read()
+	if err != nil {
+		if err == io.EOF {
+			return false
+		}
+		panic(fmt.Sprintf("broken stream: %v", err))
+	}
+
+	*et = elm.Timestamp
+	*key = elm.Elm.Interface().(typex.X)
+	*value = elm.Elm2.Interface().(float64)
+	return true
+}
+
+func iterMakerETTypex_XFloat64(s ReStream) ReusableInput {
+	ret := &iterNative{s: s}
+	ret.fn = reflect.ValueOf(ret.readETTypex_XFloat64)
+	return ret
+}
+
+func (v *iterNative) readTypex_XTypex_T(key *typex.X, value *typex.T) bool {
+	elm, err := v.cur.Read()
+	if err != nil {
+		if err == io.EOF {
+			return false
+		}
+		panic(fmt.Sprintf("broken stream: %v", err))
+	}
+
+	*key = elm.Elm.Interface().(typex.X)
+	*value = elm.Elm2.Interface().(typex.T)
+	return true
+}
+
+func iterMakerTypex_XTypex_T(s ReStream) ReusableInput {
+	ret := &iterNative{s: s}
+	ret.fn = reflect.ValueOf(ret.readTypex_XTypex_T)
+	return ret
+}
+
+func (v *iterNative) readETTypex_XTypex_T(et *typex.EventTime, key *typex.X, value *typex.T) bool {
+	elm, err := v.cur.Read()
+	if err != nil {
+		if err == io.EOF {
+			return false
+		}
+		panic(fmt.Sprintf("broken stream: %v", err))
+	}
+
+	*et = elm.Timestamp
+	*key = elm.Elm.Interface().(typex.X)
+	*value = elm.Elm2.Interface().(typex.T)
+	return true
+}
+
+func iterMakerETTypex_XTypex_T(s ReStream) ReusableInput {
+	ret := &iterNative{s: s}
+	ret.fn = reflect.ValueOf(ret.readETTypex_XTypex_T)
+	return ret
+}
+
+func (v *iterNative) readTypex_XTypex_U(key *typex.X, value *typex.U) bool {
+	elm, err := v.cur.Read()
+	if err != nil {
+		if err == io.EOF {
+			return false
+		}
+		panic(fmt.Sprintf("broken stream: %v", err))
+	}
+
+	*key = elm.Elm.Interface().(typex.X)
+	*value = elm.Elm2.Interface().(typex.U)
+	return true
+}
+
+func iterMakerTypex_XTypex_U(s ReStream) ReusableInput {
+	ret := &iterNative{s: s}
+	ret.fn = reflect.ValueOf(ret.readTypex_XTypex_U)
+	return ret
+}
+
+func (v *iterNative) readETTypex_XTypex_U(et *typex.EventTime, key *typex.X, value *typex.U) bool {
+	elm, err := v.cur.Read()
+	if err != nil {
+		if err == io.EOF {
+			return false
+		}
+		panic(fmt.Sprintf("broken stream: %v", err))
+	}
+
+	*et = elm.Timestamp
+	*key = elm.Elm.Interface().(typex.X)
+	*value = elm.Elm2.Interface().(typex.U)
+	return true
+}
+
+func iterMakerETTypex_XTypex_U(s ReStream) ReusableInput {
+	ret := &iterNative{s: s}
+	ret.fn = reflect.ValueOf(ret.readETTypex_XTypex_U)
+	return ret
+}
+
+func (v *iterNative) readTypex_XTypex_V(key *typex.X, value *typex.V) bool {
+	elm, err := v.cur.Read()
+	if err != nil {
+		if err == io.EOF {
+			return false
+		}
+		panic(fmt.Sprintf("broken stream: %v", err))
+	}
+
+	*key = elm.Elm.Interface().(typex.X)
+	*value = elm.Elm2.Interface().(typex.V)
+	return true
+}
+
+func iterMakerTypex_XTypex_V(s ReStream) ReusableInput {
+	ret := &iterNative{s: s}
+	ret.fn = reflect.ValueOf(ret.readTypex_XTypex_V)
+	return ret
+}
+
+func (v *iterNative) readETTypex_XTypex_V(et *typex.EventTime, key *typex.X, value *typex.V) bool {
+	elm, err := v.cur.Read()
+	if err != nil {
+		if err == io.EOF {
+			return false
+		}
+		panic(fmt.Sprintf("broken stream: %v", err))
+	}
+
+	*et = elm.Timestamp
+	*key = elm.Elm.Interface().(typex.X)
+	*value = elm.Elm2.Interface().(typex.V)
+	return true
+}
+
+func iterMakerETTypex_XTypex_V(s ReStream) ReusableInput {
+	ret := &iterNative{s: s}
+	ret.fn = reflect.ValueOf(ret.readETTypex_XTypex_V)
+	return ret
+}
+
+func (v *iterNative) readTypex_XTypex_W(key *typex.X, value *typex.W) bool {
+	elm, err := v.cur.Read()
+	if err != nil {
+		if err == io.EOF {
+			return false
+		}
+		panic(fmt.Sprintf("broken stream: %v", err))
+	}
+
+	*key = elm.Elm.Interface().(typex.X)
+	*value = elm.Elm2.Interface().(typex.W)
+	return true
+}
+
+func iterMakerTypex_XTypex_W(s ReStream) ReusableInput {
+	ret := &iterNative{s: s}
+	ret.fn = reflect.ValueOf(ret.readTypex_XTypex_W)
+	return ret
+}
+
+func (v *iterNative) readETTypex_XTypex_W(et *typex.EventTime, key *typex.X, value *typex.W) bool {
+	elm, err := v.cur.Read()
+	if err != nil {
+		if err == io.EOF {
+			return false
+		}
+		panic(fmt.Sprintf("broken stream: %v", err))
+	}
+
+	*et = elm.Timestamp
+	*key = elm.Elm.Interface().(typex.X)
+	*value = elm.Elm2.Interface().(typex.W)
+	return true
+}
+
+func iterMakerETTypex_XTypex_W(s ReStream) ReusableInput {
+	ret := &iterNative{s: s}
+	ret.fn = reflect.ValueOf(ret.readETTypex_XTypex_W)
+	return ret
+}
+
+func (v *iterNative) readTypex_XTypex_X(key *typex.X, value *typex.X) bool {
+	elm, err := v.cur.Read()
+	if err != nil {
+		if err == io.EOF {
+			return false
+		}
+		panic(fmt.Sprintf("broken stream: %v", err))
+	}
+
+	*key = elm.Elm.Interface().(typex.X)
+	*value = elm.Elm2.Interface().(typex.X)
+	return true
+}
+
+func iterMakerTypex_XTypex_X(s ReStream) ReusableInput {
+	ret := &iterNative{s: s}
+	ret.fn = reflect.ValueOf(ret.readTypex_XTypex_X)
+	return ret
+}
+
+func (v *iterNative) readETTypex_XTypex_X(et *typex.EventTime, key *typex.X, value *typex.X) bool {
+	elm, err := v.cur.Read()
+	if err != nil {
+		if err == io.EOF {
+			return false
+		}
+		panic(fmt.Sprintf("broken stream: %v", err))
+	}
+
+	*et = elm.Timestamp
+	*key = elm.Elm.Interface().(typex.X)
+	*value = elm.Elm2.Interface().(typex.X)
+	return true
+}
+
+func iterMakerETTypex_XTypex_X(s ReStream) ReusableInput {
+	ret := &iterNative{s: s}
+	ret.fn = reflect.ValueOf(ret.readETTypex_XTypex_X)
+	return ret
+}
+
+func (v *iterNative) readTypex_XTypex_Y(key *typex.X, value *typex.Y) bool {
+	elm, err := v.cur.Read()
+	if err != nil {
+		if err == io.EOF {
+			return false
+		}
+		panic(fmt.Sprintf("broken stream: %v", err))
+	}
+
+	*key = elm.Elm.Interface().(typex.X)
+	*value = elm.Elm2.Interface().(typex.Y)
+	return true
+}
+
+func iterMakerTypex_XTypex_Y(s ReStream) ReusableInput {
+	ret := &iterNative{s: s}
+	ret.fn = reflect.ValueOf(ret.readTypex_XTypex_Y)
+	return ret
+}
+
+func (v *iterNative) readETTypex_XTypex_Y(et *typex.EventTime, key *typex.X, value *typex.Y) bool {
+	elm, err := v.cur.Read()
+	if err != nil {
+		if err == io.EOF {
+			return false
+		}
+		panic(fmt.Sprintf("broken stream: %v", err))
+	}
+
+	*et = elm.Timestamp
+	*key = elm.Elm.Interface().(typex.X)
+	*value = elm.Elm2.Interface().(typex.Y)
+	return true
+}
+
+func iterMakerETTypex_XTypex_Y(s ReStream) ReusableInput {
+	ret := &iterNative{s: s}
+	ret.fn = reflect.ValueOf(ret.readETTypex_XTypex_Y)
+	return ret
+}
+
+func (v *iterNative) readTypex_XTypex_Z(key *typex.X, value *typex.Z) bool {
+	elm, err := v.cur.Read()
+	if err != nil {
+		if err == io.EOF {
+			return false
+		}
+		panic(fmt.Sprintf("broken stream: %v", err))
+	}
+
+	*key = elm.Elm.Interface().(typex.X)
+	*value = elm.Elm2.Interface().(typex.Z)
+	return true
+}
+
+func iterMakerTypex_XTypex_Z(s ReStream) ReusableInput {
+	ret := &iterNative{s: s}
+	ret.fn = reflect.ValueOf(ret.readTypex_XTypex_Z)
+	return ret
+}
+
+func (v *iterNative) readETTypex_XTypex_Z(et *typex.EventTime, key *typex.X, value *typex.Z) bool {
+	elm, err := v.cur.Read()
+	if err != nil {
+		if err == io.EOF {
+			return false
+		}
+		panic(fmt.Sprintf("broken stream: %v", err))
+	}
+
+	*et = elm.Timestamp
+	*key = elm.Elm.Interface().(typex.X)
+	*value = elm.Elm2.Interface().(typex.Z)
+	return true
+}
+
+func iterMakerETTypex_XTypex_Z(s ReStream) ReusableInput {
+	ret := &iterNative{s: s}
+	ret.fn = reflect.ValueOf(ret.readETTypex_XTypex_Z)
+	return ret
+}
+
+func (v *iterNative) readTypex_Y(val *typex.Y) bool {
+	elm, err := v.cur.Read()
+	if err != nil {
+		if err == io.EOF {
+			return false
+		}
+		panic(fmt.Sprintf("broken stream: %v", err))
+	}
+
+	*val = elm.Elm.Interface().(typex.Y)
+	return true
+}
+
+func iterMakerTypex_Y(s ReStream) ReusableInput {
+	ret := &iterNative{s: s}
+	ret.fn = reflect.ValueOf(ret.readTypex_Y)
+	return ret
+}
+
+func (v *iterNative) readETTypex_Y(et *typex.EventTime, val *typex.Y) bool {
+	elm, err := v.cur.Read()
+	if err != nil {
+		if err == io.EOF {
+			return false
+		}
+		panic(fmt.Sprintf("broken stream: %v", err))
+	}
+
+	*et = elm.Timestamp
+	*val = elm.Elm.Interface().(typex.Y)
+	return true
+}
+
+func iterMakerETTypex_Y(s ReStream) ReusableInput {
+	ret := &iterNative{s: s}
+	ret.fn = reflect.ValueOf(ret.readETTypex_Y)
+	return ret
+}
+
+func (v *iterNative) readTypex_YByteSlice(key *typex.Y, value *[]byte) bool {
+	elm, err := v.cur.Read()
+	if err != nil {
+		if err == io.EOF {
+			return false
+		}
+		panic(fmt.Sprintf("broken stream: %v", err))
+	}
+
+	*key = elm.Elm.Interface().(typex.Y)
+	*value = elm.Elm2.Interface().([]byte)
+	return true
+}
+
+func iterMakerTypex_YByteSlice(s ReStream) ReusableInput {
+	ret := &iterNative{s: s}
+	ret.fn = reflect.ValueOf(ret.readTypex_YByteSlice)
+	return ret
+}
+
+func (v *iterNative) readETTypex_YByteSlice(et *typex.EventTime, key *typex.Y, value *[]byte) bool {
+	elm, err := v.cur.Read()
+	if err != nil {
+		if err == io.EOF {
+			return false
+		}
+		panic(fmt.Sprintf("broken stream: %v", err))
+	}
+
+	*et = elm.Timestamp
+	*key = elm.Elm.Interface().(typex.Y)
+	*value = elm.Elm2.Interface().([]byte)
+	return true
+}
+
+func iterMakerETTypex_YByteSlice(s ReStream) ReusableInput {
+	ret := &iterNative{s: s}
+	ret.fn = reflect.ValueOf(ret.readETTypex_YByteSlice)
+	return ret
+}
+
+func (v *iterNative) readTypex_YBool(key *typex.Y, value *bool) bool {
+	elm, err := v.cur.Read()
+	if err != nil {
+		if err == io.EOF {
+			return false
+		}
+		panic(fmt.Sprintf("broken stream: %v", err))
+	}
+
+	*key = elm.Elm.Interface().(typex.Y)
+	*value = elm.Elm2.Interface().(bool)
+	return true
+}
+
+func iterMakerTypex_YBool(s ReStream) ReusableInput {
+	ret := &iterNative{s: s}
+	ret.fn = reflect.ValueOf(ret.readTypex_YBool)
+	return ret
+}
+
+func (v *iterNative) readETTypex_YBool(et *typex.EventTime, key *typex.Y, value *bool) bool {
+	elm, err := v.cur.Read()
+	if err != nil {
+		if err == io.EOF {
+			return false
+		}
+		panic(fmt.Sprintf("broken stream: %v", err))
+	}
+
+	*et = elm.Timestamp
+	*key = elm.Elm.Interface().(typex.Y)
+	*value = elm.Elm2.Interface().(bool)
+	return true
+}
+
+func iterMakerETTypex_YBool(s ReStream) ReusableInput {
+	ret := &iterNative{s: s}
+	ret.fn = reflect.ValueOf(ret.readETTypex_YBool)
+	return ret
+}
+
+func (v *iterNative) readTypex_YString(key *typex.Y, value *string) bool {
+	elm, err := v.cur.Read()
+	if err != nil {
+		if err == io.EOF {
+			return false
+		}
+		panic(fmt.Sprintf("broken stream: %v", err))
+	}
+
+	*key = elm.Elm.Interface().(typex.Y)
+	*value = elm.Elm2.Interface().(string)
+	return true
+}
+
+func iterMakerTypex_YString(s ReStream) ReusableInput {
+	ret := &iterNative{s: s}
+	ret.fn = reflect.ValueOf(ret.readTypex_YString)
+	return ret
+}
+
+func (v *iterNative) readETTypex_YString(et *typex.EventTime, key *typex.Y, value *string) bool {
+	elm, err := v.cur.Read()
+	if err != nil {
+		if err == io.EOF {
+			return false
+		}
+		panic(fmt.Sprintf("broken stream: %v", err))
+	}
+
+	*et = elm.Timestamp
+	*key = elm.Elm.Interface().(typex.Y)
+	*value = elm.Elm2.Interface().(string)
+	return true
+}
+
+func iterMakerETTypex_YString(s ReStream) ReusableInput {
+	ret := &iterNative{s: s}
+	ret.fn = reflect.ValueOf(ret.readETTypex_YString)
+	return ret
+}
+
+func (v *iterNative) readTypex_YInt(key *typex.Y, value *int) bool {
+	elm, err := v.cur.Read()
+	if err != nil {
+		if err == io.EOF {
+			return false
+		}
+		panic(fmt.Sprintf("broken stream: %v", err))
+	}
+
+	*key = elm.Elm.Interface().(typex.Y)
+	*value = elm.Elm2.Interface().(int)
+	return true
+}
+
+func iterMakerTypex_YInt(s ReStream) ReusableInput {
+	ret := &iterNative{s: s}
+	ret.fn = reflect.ValueOf(ret.readTypex_YInt)
+	return ret
+}
+
+func (v *iterNative) readETTypex_YInt(et *typex.EventTime, key *typex.Y, value *int) bool {
+	elm, err := v.cur.Read()
+	if err != nil {
+		if err == io.EOF {
+			return false
+		}
+		panic(fmt.Sprintf("broken stream: %v", err))
+	}
+
+	*et = elm.Timestamp
+	*key = elm.Elm.Interface().(typex.Y)
+	*value = elm.Elm2.Interface().(int)
+	return true
+}
+
+func iterMakerETTypex_YInt(s ReStream) ReusableInput {
+	ret := &iterNative{s: s}
+	ret.fn = reflect.ValueOf(ret.readETTypex_YInt)
+	return ret
+}
+
+func (v *iterNative) readTypex_YInt8(key *typex.Y, value *int8) bool {
+	elm, err := v.cur.Read()
+	if err != nil {
+		if err == io.EOF {
+			return false
+		}
+		panic(fmt.Sprintf("broken stream: %v", err))
+	}
+
+	*key = elm.Elm.Interface().(typex.Y)
+	*value = elm.Elm2.Interface().(int8)
+	return true
+}
+
+func iterMakerTypex_YInt8(s ReStream) ReusableInput {
+	ret := &iterNative{s: s}
+	ret.fn = reflect.ValueOf(ret.readTypex_YInt8)
+	return ret
+}
+
+func (v *iterNative) readETTypex_YInt8(et *typex.EventTime, key *typex.Y, value *int8) bool {
+	elm, err := v.cur.Read()
+	if err != nil {
+		if err == io.EOF {
+			return false
+		}
+		panic(fmt.Sprintf("broken stream: %v", err))
+	}
+
+	*et = elm.Timestamp
+	*key = elm.Elm.Interface().(typex.Y)
+	*value = elm.Elm2.Interface().(int8)
+	return true
+}
+
+func iterMakerETTypex_YInt8(s ReStream) ReusableInput {
+	ret := &iterNative{s: s}
+	ret.fn = reflect.ValueOf(ret.readETTypex_YInt8)
+	return ret
+}
+
+func (v *iterNative) readTypex_YInt16(key *typex.Y, value *int16) bool {
+	elm, err := v.cur.Read()
+	if err != nil {
+		if err == io.EOF {
+			return false
+		}
+		panic(fmt.Sprintf("broken stream: %v", err))
+	}
+
+	*key = elm.Elm.Interface().(typex.Y)
+	*value = elm.Elm2.Interface().(int16)
+	return true
+}
+
+func iterMakerTypex_YInt16(s ReStream) ReusableInput {
+	ret := &iterNative{s: s}
+	ret.fn = reflect.ValueOf(ret.readTypex_YInt16)
+	return ret
+}
+
+func (v *iterNative) readETTypex_YInt16(et *typex.EventTime, key *typex.Y, value *int16) bool {
+	elm, err := v.cur.Read()
+	if err != nil {
+		if err == io.EOF {
+			return false
+		}
+		panic(fmt.Sprintf("broken stream: %v", err))
+	}
+
+	*et = elm.Timestamp
+	*key = elm.Elm.Interface().(typex.Y)
+	*value = elm.Elm2.Interface().(int16)
+	return true
+}
+
+func iterMakerETTypex_YInt16(s ReStream) ReusableInput {
+	ret := &iterNative{s: s}
+	ret.fn = reflect.ValueOf(ret.readETTypex_YInt16)
+	return ret
+}
+
+func (v *iterNative) readTypex_YInt32(key *typex.Y, value *int32) bool {
+	elm, err := v.cur.Read()
+	if err != nil {
+		if err == io.EOF {
+			return false
+		}
+		panic(fmt.Sprintf("broken stream: %v", err))
+	}
+
+	*key = elm.Elm.Interface().(typex.Y)
+	*value = elm.Elm2.Interface().(int32)
+	return true
+}
+
+func iterMakerTypex_YInt32(s ReStream) ReusableInput {
+	ret := &iterNative{s: s}
+	ret.fn = reflect.ValueOf(ret.readTypex_YInt32)
+	return ret
+}
+
+func (v *iterNative) readETTypex_YInt32(et *typex.EventTime, key *typex.Y, value *int32) bool {
+	elm, err := v.cur.Read()
+	if err != nil {
+		if err == io.EOF {
+			return false
+		}
+		panic(fmt.Sprintf("broken stream: %v", err))
+	}
+
+	*et = elm.Timestamp
+	*key = elm.Elm.Interface().(typex.Y)
+	*value = elm.Elm2.Interface().(int32)
+	return true
+}
+
+func iterMakerETTypex_YInt32(s ReStream) ReusableInput {
+	ret := &iterNative{s: s}
+	ret.fn = reflect.ValueOf(ret.readETTypex_YInt32)
+	return ret
+}
+
+func (v *iterNative) readTypex_YInt64(key *typex.Y, value *int64) bool {
+	elm, err := v.cur.Read()
+	if err != nil {
+		if err == io.EOF {
+			return false
+		}
+		panic(fmt.Sprintf("broken stream: %v", err))
+	}
+
+	*key = elm.Elm.Interface().(typex.Y)
+	*value = elm.Elm2.Interface().(int64)
+	return true
+}
+
+func iterMakerTypex_YInt64(s ReStream) ReusableInput {
+	ret := &iterNative{s: s}
+	ret.fn = reflect.ValueOf(ret.readTypex_YInt64)
+	return ret
+}
+
+func (v *iterNative) readETTypex_YInt64(et *typex.EventTime, key *typex.Y, value *int64) bool {
+	elm, err := v.cur.Read()
+	if err != nil {
+		if err == io.EOF {
+			return false
+		}
+		panic(fmt.Sprintf("broken stream: %v", err))
+	}
+
+	*et = elm.Timestamp
+	*key = elm.Elm.Interface().(typex.Y)
+	*value = elm.Elm2.Interface().(int64)
+	return true
+}
+
+func iterMakerETTypex_YInt64(s ReStream) ReusableInput {
+	ret := &iterNative{s: s}
+	ret.fn = reflect.ValueOf(ret.readETTypex_YInt64)
+	return ret
+}
+
+func (v *iterNative) readTypex_YUint(key *typex.Y, value *uint) bool {
+	elm, err := v.cur.Read()
+	if err != nil {
+		if err == io.EOF {
+			return false
+		}
+		panic(fmt.Sprintf("broken stream: %v", err))
+	}
+
+	*key = elm.Elm.Interface().(typex.Y)
+	*value = elm.Elm2.Interface().(uint)
+	return true
+}
+
+func iterMakerTypex_YUint(s ReStream) ReusableInput {
+	ret := &iterNative{s: s}
+	ret.fn = reflect.ValueOf(ret.readTypex_YUint)
+	return ret
+}
+
+func (v *iterNative) readETTypex_YUint(et *typex.EventTime, key *typex.Y, value *uint) bool {
+	elm, err := v.cur.Read()
+	if err != nil {
+		if err == io.EOF {
+			return false
+		}
+		panic(fmt.Sprintf("broken stream: %v", err))
+	}
+
+	*et = elm.Timestamp
+	*key = elm.Elm.Interface().(typex.Y)
+	*value = elm.Elm2.Interface().(uint)
+	return true
+}
+
+func iterMakerETTypex_YUint(s ReStream) ReusableInput {
+	ret := &iterNative{s: s}
+	ret.fn = reflect.ValueOf(ret.readETTypex_YUint)
+	return ret
+}
+
+func (v *iterNative) readTypex_YUint8(key *typex.Y, value *uint8) bool {
+	elm, err := v.cur.Read()
+	if err != nil {
+		if err == io.EOF {
+			return false
+		}
+		panic(fmt.Sprintf("broken stream: %v", err))
+	}
+
+	*key = elm.Elm.Interface().(typex.Y)
+	*value = elm.Elm2.Interface().(uint8)
+	return true
+}
+
+func iterMakerTypex_YUint8(s ReStream) ReusableInput {
+	ret := &iterNative{s: s}
+	ret.fn = reflect.ValueOf(ret.readTypex_YUint8)
+	return ret
+}
+
+func (v *iterNative) readETTypex_YUint8(et *typex.EventTime, key *typex.Y, value *uint8) bool {
+	elm, err := v.cur.Read()
+	if err != nil {
+		if err == io.EOF {
+			return false
+		}
+		panic(fmt.Sprintf("broken stream: %v", err))
+	}
+
+	*et = elm.Timestamp
+	*key = elm.Elm.Interface().(typex.Y)
+	*value = elm.Elm2.Interface().(uint8)
+	return true
+}
+
+func iterMakerETTypex_YUint8(s ReStream) ReusableInput {
+	ret := &iterNative{s: s}
+	ret.fn = reflect.ValueOf(ret.readETTypex_YUint8)
+	return ret
+}
+
+func (v *iterNative) readTypex_YUint16(key *typex.Y, value *uint16) bool {
+	elm, err := v.cur.Read()
+	if err != nil {
+		if err == io.EOF {
+			return false
+		}
+		panic(fmt.Sprintf("broken stream: %v", err))
+	}
+
+	*key = elm.Elm.Interface().(typex.Y)
+	*value = elm.Elm2.Interface().(uint16)
+	return true
+}
+
+func iterMakerTypex_YUint16(s ReStream) ReusableInput {
+	ret := &iterNative{s: s}
+	ret.fn = reflect.ValueOf(ret.readTypex_YUint16)
+	return ret
+}
+
+func (v *iterNative) readETTypex_YUint16(et *typex.EventTime, key *typex.Y, value *uint16) bool {
+	elm, err := v.cur.Read()
+	if err != nil {
+		if err == io.EOF {
+			return false
+		}
+		panic(fmt.Sprintf("broken stream: %v", err))
+	}
+
+	*et = elm.Timestamp
+	*key = elm.Elm.Interface().(typex.Y)
+	*value = elm.Elm2.Interface().(uint16)
+	return true
+}
+
+func iterMakerETTypex_YUint16(s ReStream) ReusableInput {
+	ret := &iterNative{s: s}
+	ret.fn = reflect.ValueOf(ret.readETTypex_YUint16)
+	return ret
+}
+
+func (v *iterNative) readTypex_YUint32(key *typex.Y, value *uint32) bool {
+	elm, err := v.cur.Read()
+	if err != nil {
+		if err == io.EOF {
+			return false
+		}
+		panic(fmt.Sprintf("broken stream: %v", err))
+	}
+
+	*key = elm.Elm.Interface().(typex.Y)
+	*value = elm.Elm2.Interface().(uint32)
+	return true
+}
+
+func iterMakerTypex_YUint32(s ReStream) ReusableInput {
+	ret := &iterNative{s: s}
+	ret.fn = reflect.ValueOf(ret.readTypex_YUint32)
+	return ret
+}
+
+func (v *iterNative) readETTypex_YUint32(et *typex.EventTime, key *typex.Y, value *uint32) bool {
+	elm, err := v.cur.Read()
+	if err != nil {
+		if err == io.EOF {
+			return false
+		}
+		panic(fmt.Sprintf("broken stream: %v", err))
+	}
+
+	*et = elm.Timestamp
+	*key = elm.Elm.Interface().(typex.Y)
+	*value = elm.Elm2.Interface().(uint32)
+	return true
+}
+
+func iterMakerETTypex_YUint32(s ReStream) ReusableInput {
+	ret := &iterNative{s: s}
+	ret.fn = reflect.ValueOf(ret.readETTypex_YUint32)
+	return ret
+}
+
+func (v *iterNative) readTypex_YUint64(key *typex.Y, value *uint64) bool {
+	elm, err := v.cur.Read()
+	if err != nil {
+		if err == io.EOF {
+			return false
+		}
+		panic(fmt.Sprintf("broken stream: %v", err))
+	}
+
+	*key = elm.Elm.Interface().(typex.Y)
+	*value = elm.Elm2.Interface().(uint64)
+	return true
+}
+
+func iterMakerTypex_YUint64(s ReStream) ReusableInput {
+	ret := &iterNative{s: s}
+	ret.fn = reflect.ValueOf(ret.readTypex_YUint64)
+	return ret
+}
+
+func (v *iterNative) readETTypex_YUint64(et *typex.EventTime, key *typex.Y, value *uint64) bool {
+	elm, err := v.cur.Read()
+	if err != nil {
+		if err == io.EOF {
+			return false
+		}
+		panic(fmt.Sprintf("broken stream: %v", err))
+	}
+
+	*et = elm.Timestamp
+	*key = elm.Elm.Interface().(typex.Y)
+	*value = elm.Elm2.Interface().(uint64)
+	return true
+}
+
+func iterMakerETTypex_YUint64(s ReStream) ReusableInput {
+	ret := &iterNative{s: s}
+	ret.fn = reflect.ValueOf(ret.readETTypex_YUint64)
+	return ret
+}
+
+func (v *iterNative) readTypex_YFloat32(key *typex.Y, value *float32) bool {
+	elm, err := v.cur.Read()
+	if err != nil {
+		if err == io.EOF {
+			return false
+		}
+		panic(fmt.Sprintf("broken stream: %v", err))
+	}
+
+	*key = elm.Elm.Interface().(typex.Y)
+	*value = elm.Elm2.Interface().(float32)
+	return true
+}
+
+func iterMakerTypex_YFloat32(s ReStream) ReusableInput {
+	ret := &iterNative{s: s}
+	ret.fn = reflect.ValueOf(ret.readTypex_YFloat32)
+	return ret
+}
+
+func (v *iterNative) readETTypex_YFloat32(et *typex.EventTime, key *typex.Y, value *float32) bool {
+	elm, err := v.cur.Read()
+	if err != nil {
+		if err == io.EOF {
+			return false
+		}
+		panic(fmt.Sprintf("broken stream: %v", err))
+	}
+
+	*et = elm.Timestamp
+	*key = elm.Elm.Interface().(typex.Y)
+	*value = elm.Elm2.Interface().(float32)
+	return true
+}
+
+func iterMakerETTypex_YFloat32(s ReStream) ReusableInput {
+	ret := &iterNative{s: s}
+	ret.fn = reflect.ValueOf(ret.readETTypex_YFloat32)
+	return ret
+}
+
+func (v *iterNative) readTypex_YFloat64(key *typex.Y, value *float64) bool {
+	elm, err := v.cur.Read()
+	if err != nil {
+		if err == io.EOF {
+			return false
+		}
+		panic(fmt.Sprintf("broken stream: %v", err))
+	}
+
+	*key = elm.Elm.Interface().(typex.Y)
+	*value = elm.Elm2.Interface().(float64)
+	return true
+}
+
+func iterMakerTypex_YFloat64(s ReStream) ReusableInput {
+	ret := &iterNative{s: s}
+	ret.fn = reflect.ValueOf(ret.readTypex_YFloat64)
+	return ret
+}
+
+func (v *iterNative) readETTypex_YFloat64(et *typex.EventTime, key *typex.Y, value *float64) bool {
+	elm, err := v.cur.Read()
+	if err != nil {
+		if err == io.EOF {
+			return false
+		}
+		panic(fmt.Sprintf("broken stream: %v", err))
+	}
+
+	*et = elm.Timestamp
+	*key = elm.Elm.Interface().(typex.Y)
+	*value = elm.Elm2.Interface().(float64)
+	return true
+}
+
+func iterMakerETTypex_YFloat64(s ReStream) ReusableInput {
+	ret := &iterNative{s: s}
+	ret.fn = reflect.ValueOf(ret.readETTypex_YFloat64)
+	return ret
+}
+
+func (v *iterNative) readTypex_YTypex_T(key *typex.Y, value *typex.T) bool {
+	elm, err := v.cur.Read()
+	if err != nil {
+		if err == io.EOF {
+			return false
+		}
+		panic(fmt.Sprintf("broken stream: %v", err))
+	}
+
+	*key = elm.Elm.Interface().(typex.Y)
+	*value = elm.Elm2.Interface().(typex.T)
+	return true
+}
+
+func iterMakerTypex_YTypex_T(s ReStream) ReusableInput {
+	ret := &iterNative{s: s}
+	ret.fn = reflect.ValueOf(ret.readTypex_YTypex_T)
+	return ret
+}
+
+func (v *iterNative) readETTypex_YTypex_T(et *typex.EventTime, key *typex.Y, value *typex.T) bool {
+	elm, err := v.cur.Read()
+	if err != nil {
+		if err == io.EOF {
+			return false
+		}
+		panic(fmt.Sprintf("broken stream: %v", err))
+	}
+
+	*et = elm.Timestamp
+	*key = elm.Elm.Interface().(typex.Y)
+	*value = elm.Elm2.Interface().(typex.T)
+	return true
+}
+
+func iterMakerETTypex_YTypex_T(s ReStream) ReusableInput {
+	ret := &iterNative{s: s}
+	ret.fn = reflect.ValueOf(ret.readETTypex_YTypex_T)
+	return ret
+}
+
+func (v *iterNative) readTypex_YTypex_U(key *typex.Y, value *typex.U) bool {
+	elm, err := v.cur.Read()
+	if err != nil {
+		if err == io.EOF {
+			return false
+		}
+		panic(fmt.Sprintf("broken stream: %v", err))
+	}
+
+	*key = elm.Elm.Interface().(typex.Y)
+	*value = elm.Elm2.Interface().(typex.U)
+	return true
+}
+
+func iterMakerTypex_YTypex_U(s ReStream) ReusableInput {
+	ret := &iterNative{s: s}
+	ret.fn = reflect.ValueOf(ret.readTypex_YTypex_U)
+	return ret
+}
+
+func (v *iterNative) readETTypex_YTypex_U(et *typex.EventTime, key *typex.Y, value *typex.U) bool {
+	elm, err := v.cur.Read()
+	if err != nil {
+		if err == io.EOF {
+			return false
+		}
+		panic(fmt.Sprintf("broken stream: %v", err))
+	}
+
+	*et = elm.Timestamp
+	*key = elm.Elm.Interface().(typex.Y)
+	*value = elm.Elm2.Interface().(typex.U)
+	return true
+}
+
+func iterMakerETTypex_YTypex_U(s ReStream) ReusableInput {
+	ret := &iterNative{s: s}
+	ret.fn = reflect.ValueOf(ret.readETTypex_YTypex_U)
+	return ret
+}
+
+func (v *iterNative) readTypex_YTypex_V(key *typex.Y, value *typex.V) bool {
+	elm, err := v.cur.Read()
+	if err != nil {
+		if err == io.EOF {
+			return false
+		}
+		panic(fmt.Sprintf("broken stream: %v", err))
+	}
+
+	*key = elm.Elm.Interface().(typex.Y)
+	*value = elm.Elm2.Interface().(typex.V)
+	return true
+}
+
+func iterMakerTypex_YTypex_V(s ReStream) ReusableInput {
+	ret := &iterNative{s: s}
+	ret.fn = reflect.ValueOf(ret.readTypex_YTypex_V)
+	return ret
+}
+
+func (v *iterNative) readETTypex_YTypex_V(et *typex.EventTime, key *typex.Y, value *typex.V) bool {
+	elm, err := v.cur.Read()
+	if err != nil {
+		if err == io.EOF {
+			return false
+		}
+		panic(fmt.Sprintf("broken stream: %v", err))
+	}
+
+	*et = elm.Timestamp
+	*key = elm.Elm.Interface().(typex.Y)
+	*value = elm.Elm2.Interface().(typex.V)
+	return true
+}
+
+func iterMakerETTypex_YTypex_V(s ReStream) ReusableInput {
+	ret := &iterNative{s: s}
+	ret.fn = reflect.ValueOf(ret.readETTypex_YTypex_V)
+	return ret
+}
+
+func (v *iterNative) readTypex_YTypex_W(key *typex.Y, value *typex.W) bool {
+	elm, err := v.cur.Read()
+	if err != nil {
+		if err == io.EOF {
+			return false
+		}
+		panic(fmt.Sprintf("broken stream: %v", err))
+	}
+
+	*key = elm.Elm.Interface().(typex.Y)
+	*value = elm.Elm2.Interface().(typex.W)
+	return true
+}
+
+func iterMakerTypex_YTypex_W(s ReStream) ReusableInput {
+	ret := &iterNative{s: s}
+	ret.fn = reflect.ValueOf(ret.readTypex_YTypex_W)
+	return ret
+}
+
+func (v *iterNative) readETTypex_YTypex_W(et *typex.EventTime, key *typex.Y, value *typex.W) bool {
+	elm, err := v.cur.Read()
+	if err != nil {
+		if err == io.EOF {
+			return false
+		}
+		panic(fmt.Sprintf("broken stream: %v", err))
+	}
+
+	*et = elm.Timestamp
+	*key = elm.Elm.Interface().(typex.Y)
+	*value = elm.Elm2.Interface().(typex.W)
+	return true
+}
+
+func iterMakerETTypex_YTypex_W(s ReStream) ReusableInput {
+	ret := &iterNative{s: s}
+	ret.fn = reflect.ValueOf(ret.readETTypex_YTypex_W)
+	return ret
+}
+
+func (v *iterNative) readTypex_YTypex_X(key *typex.Y, value *typex.X) bool {
+	elm, err := v.cur.Read()
+	if err != nil {
+		if err == io.EOF {
+			return false
+		}
+		panic(fmt.Sprintf("broken stream: %v", err))
+	}
+
+	*key = elm.Elm.Interface().(typex.Y)
+	*value = elm.Elm2.Interface().(typex.X)
+	return true
+}
+
+func iterMakerTypex_YTypex_X(s ReStream) ReusableInput {
+	ret := &iterNative{s: s}
+	ret.fn = reflect.ValueOf(ret.readTypex_YTypex_X)
+	return ret
+}
+
+func (v *iterNative) readETTypex_YTypex_X(et *typex.EventTime, key *typex.Y, value *typex.X) bool {
+	elm, err := v.cur.Read()
+	if err != nil {
+		if err == io.EOF {
+			return false
+		}
+		panic(fmt.Sprintf("broken stream: %v", err))
+	}
+
+	*et = elm.Timestamp
+	*key = elm.Elm.Interface().(typex.Y)
+	*value = elm.Elm2.Interface().(typex.X)
+	return true
+}
+
+func iterMakerETTypex_YTypex_X(s ReStream) ReusableInput {
+	ret := &iterNative{s: s}
+	ret.fn = reflect.ValueOf(ret.readETTypex_YTypex_X)
+	return ret
+}
+
+func (v *iterNative) readTypex_YTypex_Y(key *typex.Y, value *typex.Y) bool {
+	elm, err := v.cur.Read()
+	if err != nil {
+		if err == io.EOF {
+			return false
+		}
+		panic(fmt.Sprintf("broken stream: %v", err))
+	}
+
+	*key = elm.Elm.Interface().(typex.Y)
+	*value = elm.Elm2.Interface().(typex.Y)
+	return true
+}
+
+func iterMakerTypex_YTypex_Y(s ReStream) ReusableInput {
+	ret := &iterNative{s: s}
+	ret.fn = reflect.ValueOf(ret.readTypex_YTypex_Y)
+	return ret
+}
+
+func (v *iterNative) readETTypex_YTypex_Y(et *typex.EventTime, key *typex.Y, value *typex.Y) bool {
+	elm, err := v.cur.Read()
+	if err != nil {
+		if err == io.EOF {
+			return false
+		}
+		panic(fmt.Sprintf("broken stream: %v", err))
+	}
+
+	*et = elm.Timestamp
+	*key = elm.Elm.Interface().(typex.Y)
+	*value = elm.Elm2.Interface().(typex.Y)
+	return true
+}
+
+func iterMakerETTypex_YTypex_Y(s ReStream) ReusableInput {
+	ret := &iterNative{s: s}
+	ret.fn = reflect.ValueOf(ret.readETTypex_YTypex_Y)
+	return ret
+}
+
+func (v *iterNative) readTypex_YTypex_Z(key *typex.Y, value *typex.Z) bool {
+	elm, err := v.cur.Read()
+	if err != nil {
+		if err == io.EOF {
+			return false
+		}
+		panic(fmt.Sprintf("broken stream: %v", err))
+	}
+
+	*key = elm.Elm.Interface().(typex.Y)
+	*value = elm.Elm2.Interface().(typex.Z)
+	return true
+}
+
+func iterMakerTypex_YTypex_Z(s ReStream) ReusableInput {
+	ret := &iterNative{s: s}
+	ret.fn = reflect.ValueOf(ret.readTypex_YTypex_Z)
+	return ret
+}
+
+func (v *iterNative) readETTypex_YTypex_Z(et *typex.EventTime, key *typex.Y, value *typex.Z) bool {
+	elm, err := v.cur.Read()
+	if err != nil {
+		if err == io.EOF {
+			return false
+		}
+		panic(fmt.Sprintf("broken stream: %v", err))
+	}
+
+	*et = elm.Timestamp
+	*key = elm.Elm.Interface().(typex.Y)
+	*value = elm.Elm2.Interface().(typex.Z)
+	return true
+}
+
+func iterMakerETTypex_YTypex_Z(s ReStream) ReusableInput {
+	ret := &iterNative{s: s}
+	ret.fn = reflect.ValueOf(ret.readETTypex_YTypex_Z)
+	return ret
+}
+
+func (v *iterNative) readTypex_Z(val *typex.Z) bool {
+	elm, err := v.cur.Read()
+	if err != nil {
+		if err == io.EOF {
+			return false
+		}
+		panic(fmt.Sprintf("broken stream: %v", err))
+	}
+
+	*val = elm.Elm.Interface().(typex.Z)
+	return true
+}
+
+func iterMakerTypex_Z(s ReStream) ReusableInput {
+	ret := &iterNative{s: s}
+	ret.fn = reflect.ValueOf(ret.readTypex_Z)
+	return ret
+}
+
+func (v *iterNative) readETTypex_Z(et *typex.EventTime, val *typex.Z) bool {
+	elm, err := v.cur.Read()
+	if err != nil {
+		if err == io.EOF {
+			return false
+		}
+		panic(fmt.Sprintf("broken stream: %v", err))
+	}
+
+	*et = elm.Timestamp
+	*val = elm.Elm.Interface().(typex.Z)
+	return true
+}
+
+func iterMakerETTypex_Z(s ReStream) ReusableInput {
+	ret := &iterNative{s: s}
+	ret.fn = reflect.ValueOf(ret.readETTypex_Z)
+	return ret
+}
+
+func (v *iterNative) readTypex_ZByteSlice(key *typex.Z, value *[]byte) bool {
+	elm, err := v.cur.Read()
+	if err != nil {
+		if err == io.EOF {
+			return false
+		}
+		panic(fmt.Sprintf("broken stream: %v", err))
+	}
+
+	*key = elm.Elm.Interface().(typex.Z)
+	*value = elm.Elm2.Interface().([]byte)
+	return true
+}
+
+func iterMakerTypex_ZByteSlice(s ReStream) ReusableInput {
+	ret := &iterNative{s: s}
+	ret.fn = reflect.ValueOf(ret.readTypex_ZByteSlice)
+	return ret
+}
+
+func (v *iterNative) readETTypex_ZByteSlice(et *typex.EventTime, key *typex.Z, value *[]byte) bool {
+	elm, err := v.cur.Read()
+	if err != nil {
+		if err == io.EOF {
+			return false
+		}
+		panic(fmt.Sprintf("broken stream: %v", err))
+	}
+
+	*et = elm.Timestamp
+	*key = elm.Elm.Interface().(typex.Z)
+	*value = elm.Elm2.Interface().([]byte)
+	return true
+}
+
+func iterMakerETTypex_ZByteSlice(s ReStream) ReusableInput {
+	ret := &iterNative{s: s}
+	ret.fn = reflect.ValueOf(ret.readETTypex_ZByteSlice)
+	return ret
+}
+
+func (v *iterNative) readTypex_ZBool(key *typex.Z, value *bool) bool {
+	elm, err := v.cur.Read()
+	if err != nil {
+		if err == io.EOF {
+			return false
+		}
+		panic(fmt.Sprintf("broken stream: %v", err))
+	}
+
+	*key = elm.Elm.Interface().(typex.Z)
+	*value = elm.Elm2.Interface().(bool)
+	return true
+}
+
+func iterMakerTypex_ZBool(s ReStream) ReusableInput {
+	ret := &iterNative{s: s}
+	ret.fn = reflect.ValueOf(ret.readTypex_ZBool)
+	return ret
+}
+
+func (v *iterNative) readETTypex_ZBool(et *typex.EventTime, key *typex.Z, value *bool) bool {
+	elm, err := v.cur.Read()
+	if err != nil {
+		if err == io.EOF {
+			return false
+		}
+		panic(fmt.Sprintf("broken stream: %v", err))
+	}
+
+	*et = elm.Timestamp
+	*key = elm.Elm.Interface().(typex.Z)
+	*value = elm.Elm2.Interface().(bool)
+	return true
+}
+
+func iterMakerETTypex_ZBool(s ReStream) ReusableInput {
+	ret := &iterNative{s: s}
+	ret.fn = reflect.ValueOf(ret.readETTypex_ZBool)
+	return ret
+}
+
+func (v *iterNative) readTypex_ZString(key *typex.Z, value *string) bool {
+	elm, err := v.cur.Read()
+	if err != nil {
+		if err == io.EOF {
+			return false
+		}
+		panic(fmt.Sprintf("broken stream: %v", err))
+	}
+
+	*key = elm.Elm.Interface().(typex.Z)
+	*value = elm.Elm2.Interface().(string)
+	return true
+}
+
+func iterMakerTypex_ZString(s ReStream) ReusableInput {
+	ret := &iterNative{s: s}
+	ret.fn = reflect.ValueOf(ret.readTypex_ZString)
+	return ret
+}
+
+func (v *iterNative) readETTypex_ZString(et *typex.EventTime, key *typex.Z, value *string) bool {
+	elm, err := v.cur.Read()
+	if err != nil {
+		if err == io.EOF {
+			return false
+		}
+		panic(fmt.Sprintf("broken stream: %v", err))
+	}
+
+	*et = elm.Timestamp
+	*key = elm.Elm.Interface().(typex.Z)
+	*value = elm.Elm2.Interface().(string)
+	return true
+}
+
+func iterMakerETTypex_ZString(s ReStream) ReusableInput {
+	ret := &iterNative{s: s}
+	ret.fn = reflect.ValueOf(ret.readETTypex_ZString)
+	return ret
+}
+
+func (v *iterNative) readTypex_ZInt(key *typex.Z, value *int) bool {
+	elm, err := v.cur.Read()
+	if err != nil {
+		if err == io.EOF {
+			return false
+		}
+		panic(fmt.Sprintf("broken stream: %v", err))
+	}
+
+	*key = elm.Elm.Interface().(typex.Z)
+	*value = elm.Elm2.Interface().(int)
+	return true
+}
+
+func iterMakerTypex_ZInt(s ReStream) ReusableInput {
+	ret := &iterNative{s: s}
+	ret.fn = reflect.ValueOf(ret.readTypex_ZInt)
+	return ret
+}
+
+func (v *iterNative) readETTypex_ZInt(et *typex.EventTime, key *typex.Z, value *int) bool {
+	elm, err := v.cur.Read()
+	if err != nil {
+		if err == io.EOF {
+			return false
+		}
+		panic(fmt.Sprintf("broken stream: %v", err))
+	}
+
+	*et = elm.Timestamp
+	*key = elm.Elm.Interface().(typex.Z)
+	*value = elm.Elm2.Interface().(int)
+	return true
+}
+
+func iterMakerETTypex_ZInt(s ReStream) ReusableInput {
+	ret := &iterNative{s: s}
+	ret.fn = reflect.ValueOf(ret.readETTypex_ZInt)
+	return ret
+}
+
+func (v *iterNative) readTypex_ZInt8(key *typex.Z, value *int8) bool {
+	elm, err := v.cur.Read()
+	if err != nil {
+		if err == io.EOF {
+			return false
+		}
+		panic(fmt.Sprintf("broken stream: %v", err))
+	}
+
+	*key = elm.Elm.Interface().(typex.Z)
+	*value = elm.Elm2.Interface().(int8)
+	return true
+}
+
+func iterMakerTypex_ZInt8(s ReStream) ReusableInput {
+	ret := &iterNative{s: s}
+	ret.fn = reflect.ValueOf(ret.readTypex_ZInt8)
+	return ret
+}
+
+func (v *iterNative) readETTypex_ZInt8(et *typex.EventTime, key *typex.Z, value *int8) bool {
+	elm, err := v.cur.Read()
+	if err != nil {
+		if err == io.EOF {
+			return false
+		}
+		panic(fmt.Sprintf("broken stream: %v", err))
+	}
+
+	*et = elm.Timestamp
+	*key = elm.Elm.Interface().(typex.Z)
+	*value = elm.Elm2.Interface().(int8)
+	return true
+}
+
+func iterMakerETTypex_ZInt8(s ReStream) ReusableInput {
+	ret := &iterNative{s: s}
+	ret.fn = reflect.ValueOf(ret.readETTypex_ZInt8)
+	return ret
+}
+
+func (v *iterNative) readTypex_ZInt16(key *typex.Z, value *int16) bool {
+	elm, err := v.cur.Read()
+	if err != nil {
+		if err == io.EOF {
+			return false
+		}
+		panic(fmt.Sprintf("broken stream: %v", err))
+	}
+
+	*key = elm.Elm.Interface().(typex.Z)
+	*value = elm.Elm2.Interface().(int16)
+	return true
+}
+
+func iterMakerTypex_ZInt16(s ReStream) ReusableInput {
+	ret := &iterNative{s: s}
+	ret.fn = reflect.ValueOf(ret.readTypex_ZInt16)
+	return ret
+}
+
+func (v *iterNative) readETTypex_ZInt16(et *typex.EventTime, key *typex.Z, value *int16) bool {
+	elm, err := v.cur.Read()
+	if err != nil {
+		if err == io.EOF {
+			return false
+		}
+		panic(fmt.Sprintf("broken stream: %v", err))
+	}
+
+	*et = elm.Timestamp
+	*key = elm.Elm.Interface().(typex.Z)
+	*value = elm.Elm2.Interface().(int16)
+	return true
+}
+
+func iterMakerETTypex_ZInt16(s ReStream) ReusableInput {
+	ret := &iterNative{s: s}
+	ret.fn = reflect.ValueOf(ret.readETTypex_ZInt16)
+	return ret
+}
+
+func (v *iterNative) readTypex_ZInt32(key *typex.Z, value *int32) bool {
+	elm, err := v.cur.Read()
+	if err != nil {
+		if err == io.EOF {
+			return false
+		}
+		panic(fmt.Sprintf("broken stream: %v", err))
+	}
+
+	*key = elm.Elm.Interface().(typex.Z)
+	*value = elm.Elm2.Interface().(int32)
+	return true
+}
+
+func iterMakerTypex_ZInt32(s ReStream) ReusableInput {
+	ret := &iterNative{s: s}
+	ret.fn = reflect.ValueOf(ret.readTypex_ZInt32)
+	return ret
+}
+
+func (v *iterNative) readETTypex_ZInt32(et *typex.EventTime, key *typex.Z, value *int32) bool {
+	elm, err := v.cur.Read()
+	if err != nil {
+		if err == io.EOF {
+			return false
+		}
+		panic(fmt.Sprintf("broken stream: %v", err))
+	}
+
+	*et = elm.Timestamp
+	*key = elm.Elm.Interface().(typex.Z)
+	*value = elm.Elm2.Interface().(int32)
+	return true
+}
+
+func iterMakerETTypex_ZInt32(s ReStream) ReusableInput {
+	ret := &iterNative{s: s}
+	ret.fn = reflect.ValueOf(ret.readETTypex_ZInt32)
+	return ret
+}
+
+func (v *iterNative) readTypex_ZInt64(key *typex.Z, value *int64) bool {
+	elm, err := v.cur.Read()
+	if err != nil {
+		if err == io.EOF {
+			return false
+		}
+		panic(fmt.Sprintf("broken stream: %v", err))
+	}
+
+	*key = elm.Elm.Interface().(typex.Z)
+	*value = elm.Elm2.Interface().(int64)
+	return true
+}
+
+func iterMakerTypex_ZInt64(s ReStream) ReusableInput {
+	ret := &iterNative{s: s}
+	ret.fn = reflect.ValueOf(ret.readTypex_ZInt64)
+	return ret
+}
+
+func (v *iterNative) readETTypex_ZInt64(et *typex.EventTime, key *typex.Z, value *int64) bool {
+	elm, err := v.cur.Read()
+	if err != nil {
+		if err == io.EOF {
+			return false
+		}
+		panic(fmt.Sprintf("broken stream: %v", err))
+	}
+
+	*et = elm.Timestamp
+	*key = elm.Elm.Interface().(typex.Z)
+	*value = elm.Elm2.Interface().(int64)
+	return true
+}
+
+func iterMakerETTypex_ZInt64(s ReStream) ReusableInput {
+	ret := &iterNative{s: s}
+	ret.fn = reflect.ValueOf(ret.readETTypex_ZInt64)
+	return ret
+}
+
+func (v *iterNative) readTypex_ZUint(key *typex.Z, value *uint) bool {
+	elm, err := v.cur.Read()
+	if err != nil {
+		if err == io.EOF {
+			return false
+		}
+		panic(fmt.Sprintf("broken stream: %v", err))
+	}
+
+	*key = elm.Elm.Interface().(typex.Z)
+	*value = elm.Elm2.Interface().(uint)
+	return true
+}
+
+func iterMakerTypex_ZUint(s ReStream) ReusableInput {
+	ret := &iterNative{s: s}
+	ret.fn = reflect.ValueOf(ret.readTypex_ZUint)
+	return ret
+}
+
+func (v *iterNative) readETTypex_ZUint(et *typex.EventTime, key *typex.Z, value *uint) bool {
+	elm, err := v.cur.Read()
+	if err != nil {
+		if err == io.EOF {
+			return false
+		}
+		panic(fmt.Sprintf("broken stream: %v", err))
+	}
+
+	*et = elm.Timestamp
+	*key = elm.Elm.Interface().(typex.Z)
+	*value = elm.Elm2.Interface().(uint)
+	return true
+}
+
+func iterMakerETTypex_ZUint(s ReStream) ReusableInput {
+	ret := &iterNative{s: s}
+	ret.fn = reflect.ValueOf(ret.readETTypex_ZUint)
+	return ret
+}
+
+func (v *iterNative) readTypex_ZUint8(key *typex.Z, value *uint8) bool {
+	elm, err := v.cur.Read()
+	if err != nil {
+		if err == io.EOF {
+			return false
+		}
+		panic(fmt.Sprintf("broken stream: %v", err))
+	}
+
+	*key = elm.Elm.Interface().(typex.Z)
+	*value = elm.Elm2.Interface().(uint8)
+	return true
+}
+
+func iterMakerTypex_ZUint8(s ReStream) ReusableInput {
+	ret := &iterNative{s: s}
+	ret.fn = reflect.ValueOf(ret.readTypex_ZUint8)
+	return ret
+}
+
+func (v *iterNative) readETTypex_ZUint8(et *typex.EventTime, key *typex.Z, value *uint8) bool {
+	elm, err := v.cur.Read()
+	if err != nil {
+		if err == io.EOF {
+			return false
+		}
+		panic(fmt.Sprintf("broken stream: %v", err))
+	}
+
+	*et = elm.Timestamp
+	*key = elm.Elm.Interface().(typex.Z)
+	*value = elm.Elm2.Interface().(uint8)
+	return true
+}
+
+func iterMakerETTypex_ZUint8(s ReStream) ReusableInput {
+	ret := &iterNative{s: s}
+	ret.fn = reflect.ValueOf(ret.readETTypex_ZUint8)
+	return ret
+}
+
+func (v *iterNative) readTypex_ZUint16(key *typex.Z, value *uint16) bool {
+	elm, err := v.cur.Read()
+	if err != nil {
+		if err == io.EOF {
+			return false
+		}
+		panic(fmt.Sprintf("broken stream: %v", err))
+	}
+
+	*key = elm.Elm.Interface().(typex.Z)
+	*value = elm.Elm2.Interface().(uint16)
+	return true
+}
+
+func iterMakerTypex_ZUint16(s ReStream) ReusableInput {
+	ret := &iterNative{s: s}
+	ret.fn = reflect.ValueOf(ret.readTypex_ZUint16)
+	return ret
+}
+
+func (v *iterNative) readETTypex_ZUint16(et *typex.EventTime, key *typex.Z, value *uint16) bool {
+	elm, err := v.cur.Read()
+	if err != nil {
+		if err == io.EOF {
+			return false
+		}
+		panic(fmt.Sprintf("broken stream: %v", err))
+	}
+
+	*et = elm.Timestamp
+	*key = elm.Elm.Interface().(typex.Z)
+	*value = elm.Elm2.Interface().(uint16)
+	return true
+}
+
+func iterMakerETTypex_ZUint16(s ReStream) ReusableInput {
+	ret := &iterNative{s: s}
+	ret.fn = reflect.ValueOf(ret.readETTypex_ZUint16)
+	return ret
+}
+
+func (v *iterNative) readTypex_ZUint32(key *typex.Z, value *uint32) bool {
+	elm, err := v.cur.Read()
+	if err != nil {
+		if err == io.EOF {
+			return false
+		}
+		panic(fmt.Sprintf("broken stream: %v", err))
+	}
+
+	*key = elm.Elm.Interface().(typex.Z)
+	*value = elm.Elm2.Interface().(uint32)
+	return true
+}
+
+func iterMakerTypex_ZUint32(s ReStream) ReusableInput {
+	ret := &iterNative{s: s}
+	ret.fn = reflect.ValueOf(ret.readTypex_ZUint32)
+	return ret
+}
+
+func (v *iterNative) readETTypex_ZUint32(et *typex.EventTime, key *typex.Z, value *uint32) bool {
+	elm, err := v.cur.Read()
+	if err != nil {
+		if err == io.EOF {
+			return false
+		}
+		panic(fmt.Sprintf("broken stream: %v", err))
+	}
+
+	*et = elm.Timestamp
+	*key = elm.Elm.Interface().(typex.Z)
+	*value = elm.Elm2.Interface().(uint32)
+	return true
+}
+
+func iterMakerETTypex_ZUint32(s ReStream) ReusableInput {
+	ret := &iterNative{s: s}
+	ret.fn = reflect.ValueOf(ret.readETTypex_ZUint32)
+	return ret
+}
+
+func (v *iterNative) readTypex_ZUint64(key *typex.Z, value *uint64) bool {
+	elm, err := v.cur.Read()
+	if err != nil {
+		if err == io.EOF {
+			return false
+		}
+		panic(fmt.Sprintf("broken stream: %v", err))
+	}
+
+	*key = elm.Elm.Interface().(typex.Z)
+	*value = elm.Elm2.Interface().(uint64)
+	return true
+}
+
+func iterMakerTypex_ZUint64(s ReStream) ReusableInput {
+	ret := &iterNative{s: s}
+	ret.fn = reflect.ValueOf(ret.readTypex_ZUint64)
+	return ret
+}
+
+func (v *iterNative) readETTypex_ZUint64(et *typex.EventTime, key *typex.Z, value *uint64) bool {
+	elm, err := v.cur.Read()
+	if err != nil {
+		if err == io.EOF {
+			return false
+		}
+		panic(fmt.Sprintf("broken stream: %v", err))
+	}
+
+	*et = elm.Timestamp
+	*key = elm.Elm.Interface().(typex.Z)
+	*value = elm.Elm2.Interface().(uint64)
+	return true
+}
+
+func iterMakerETTypex_ZUint64(s ReStream) ReusableInput {
+	ret := &iterNative{s: s}
+	ret.fn = reflect.ValueOf(ret.readETTypex_ZUint64)
+	return ret
+}
+
+func (v *iterNative) readTypex_ZFloat32(key *typex.Z, value *float32) bool {
+	elm, err := v.cur.Read()
+	if err != nil {
+		if err == io.EOF {
+			return false
+		}
+		panic(fmt.Sprintf("broken stream: %v", err))
+	}
+
+	*key = elm.Elm.Interface().(typex.Z)
+	*value = elm.Elm2.Interface().(float32)
+	return true
+}
+
+func iterMakerTypex_ZFloat32(s ReStream) ReusableInput {
+	ret := &iterNative{s: s}
+	ret.fn = reflect.ValueOf(ret.readTypex_ZFloat32)
+	return ret
+}
+
+func (v *iterNative) readETTypex_ZFloat32(et *typex.EventTime, key *typex.Z, value *float32) bool {
+	elm, err := v.cur.Read()
+	if err != nil {
+		if err == io.EOF {
+			return false
+		}
+		panic(fmt.Sprintf("broken stream: %v", err))
+	}
+
+	*et = elm.Timestamp
+	*key = elm.Elm.Interface().(typex.Z)
+	*value = elm.Elm2.Interface().(float32)
+	return true
+}
+
+func iterMakerETTypex_ZFloat32(s ReStream) ReusableInput {
+	ret := &iterNative{s: s}
+	ret.fn = reflect.ValueOf(ret.readETTypex_ZFloat32)
+	return ret
+}
+
+func (v *iterNative) readTypex_ZFloat64(key *typex.Z, value *float64) bool {
+	elm, err := v.cur.Read()
+	if err != nil {
+		if err == io.EOF {
+			return false
+		}
+		panic(fmt.Sprintf("broken stream: %v", err))
+	}
+
+	*key = elm.Elm.Interface().(typex.Z)
+	*value = elm.Elm2.Interface().(float64)
+	return true
+}
+
+func iterMakerTypex_ZFloat64(s ReStream) ReusableInput {
+	ret := &iterNative{s: s}
+	ret.fn = reflect.ValueOf(ret.readTypex_ZFloat64)
+	return ret
+}
+
+func (v *iterNative) readETTypex_ZFloat64(et *typex.EventTime, key *typex.Z, value *float64) bool {
+	elm, err := v.cur.Read()
+	if err != nil {
+		if err == io.EOF {
+			return false
+		}
+		panic(fmt.Sprintf("broken stream: %v", err))
+	}
+
+	*et = elm.Timestamp
+	*key = elm.Elm.Interface().(typex.Z)
+	*value = elm.Elm2.Interface().(float64)
+	return true
+}
+
+func iterMakerETTypex_ZFloat64(s ReStream) ReusableInput {
+	ret := &iterNative{s: s}
+	ret.fn = reflect.ValueOf(ret.readETTypex_ZFloat64)
+	return ret
+}
+
+func (v *iterNative) readTypex_ZTypex_T(key *typex.Z, value *typex.T) bool {
+	elm, err := v.cur.Read()
+	if err != nil {
+		if err == io.EOF {
+			return false
+		}
+		panic(fmt.Sprintf("broken stream: %v", err))
+	}
+
+	*key = elm.Elm.Interface().(typex.Z)
+	*value = elm.Elm2.Interface().(typex.T)
+	return true
+}
+
+func iterMakerTypex_ZTypex_T(s ReStream) ReusableInput {
+	ret := &iterNative{s: s}
+	ret.fn = reflect.ValueOf(ret.readTypex_ZTypex_T)
+	return ret
+}
+
+func (v *iterNative) readETTypex_ZTypex_T(et *typex.EventTime, key *typex.Z, value *typex.T) bool {
+	elm, err := v.cur.Read()
+	if err != nil {
+		if err == io.EOF {
+			return false
+		}
+		panic(fmt.Sprintf("broken stream: %v", err))
+	}
+
+	*et = elm.Timestamp
+	*key = elm.Elm.Interface().(typex.Z)
+	*value = elm.Elm2.Interface().(typex.T)
+	return true
+}
+
+func iterMakerETTypex_ZTypex_T(s ReStream) ReusableInput {
+	ret := &iterNative{s: s}
+	ret.fn = reflect.ValueOf(ret.readETTypex_ZTypex_T)
+	return ret
+}
+
+func (v *iterNative) readTypex_ZTypex_U(key *typex.Z, value *typex.U) bool {
+	elm, err := v.cur.Read()
+	if err != nil {
+		if err == io.EOF {
+			return false
+		}
+		panic(fmt.Sprintf("broken stream: %v", err))
+	}
+
+	*key = elm.Elm.Interface().(typex.Z)
+	*value = elm.Elm2.Interface().(typex.U)
+	return true
+}
+
+func iterMakerTypex_ZTypex_U(s ReStream) ReusableInput {
+	ret := &iterNative{s: s}
+	ret.fn = reflect.ValueOf(ret.readTypex_ZTypex_U)
+	return ret
+}
+
+func (v *iterNative) readETTypex_ZTypex_U(et *typex.EventTime, key *typex.Z, value *typex.U) bool {
+	elm, err := v.cur.Read()
+	if err != nil {
+		if err == io.EOF {
+			return false
+		}
+		panic(fmt.Sprintf("broken stream: %v", err))
+	}
+
+	*et = elm.Timestamp
+	*key = elm.Elm.Interface().(typex.Z)
+	*value = elm.Elm2.Interface().(typex.U)
+	return true
+}
+
+func iterMakerETTypex_ZTypex_U(s ReStream) ReusableInput {
+	ret := &iterNative{s: s}
+	ret.fn = reflect.ValueOf(ret.readETTypex_ZTypex_U)
+	return ret
+}
+
+func (v *iterNative) readTypex_ZTypex_V(key *typex.Z, value *typex.V) bool {
+	elm, err := v.cur.Read()
+	if err != nil {
+		if err == io.EOF {
+			return false
+		}
+		panic(fmt.Sprintf("broken stream: %v", err))
+	}
+
+	*key = elm.Elm.Interface().(typex.Z)
+	*value = elm.Elm2.Interface().(typex.V)
+	return true
+}
+
+func iterMakerTypex_ZTypex_V(s ReStream) ReusableInput {
+	ret := &iterNative{s: s}
+	ret.fn = reflect.ValueOf(ret.readTypex_ZTypex_V)
+	return ret
+}
+
+func (v *iterNative) readETTypex_ZTypex_V(et *typex.EventTime, key *typex.Z, value *typex.V) bool {
+	elm, err := v.cur.Read()
+	if err != nil {
+		if err == io.EOF {
+			return false
+		}
+		panic(fmt.Sprintf("broken stream: %v", err))
+	}
+
+	*et = elm.Timestamp
+	*key = elm.Elm.Interface().(typex.Z)
+	*value = elm.Elm2.Interface().(typex.V)
+	return true
+}
+
+func iterMakerETTypex_ZTypex_V(s ReStream) ReusableInput {
+	ret := &iterNative{s: s}
+	ret.fn = reflect.ValueOf(ret.readETTypex_ZTypex_V)
+	return ret
+}
+
+func (v *iterNative) readTypex_ZTypex_W(key *typex.Z, value *typex.W) bool {
+	elm, err := v.cur.Read()
+	if err != nil {
+		if err == io.EOF {
+			return false
+		}
+		panic(fmt.Sprintf("broken stream: %v", err))
+	}
+
+	*key = elm.Elm.Interface().(typex.Z)
+	*value = elm.Elm2.Interface().(typex.W)
+	return true
+}
+
+func iterMakerTypex_ZTypex_W(s ReStream) ReusableInput {
+	ret := &iterNative{s: s}
+	ret.fn = reflect.ValueOf(ret.readTypex_ZTypex_W)
+	return ret
+}
+
+func (v *iterNative) readETTypex_ZTypex_W(et *typex.EventTime, key *typex.Z, value *typex.W) bool {
+	elm, err := v.cur.Read()
+	if err != nil {
+		if err == io.EOF {
+			return false
+		}
+		panic(fmt.Sprintf("broken stream: %v", err))
+	}
+
+	*et = elm.Timestamp
+	*key = elm.Elm.Interface().(typex.Z)
+	*value = elm.Elm2.Interface().(typex.W)
+	return true
+}
+
+func iterMakerETTypex_ZTypex_W(s ReStream) ReusableInput {
+	ret := &iterNative{s: s}
+	ret.fn = reflect.ValueOf(ret.readETTypex_ZTypex_W)
+	return ret
+}
+
+func (v *iterNative) readTypex_ZTypex_X(key *typex.Z, value *typex.X) bool {
+	elm, err := v.cur.Read()
+	if err != nil {
+		if err == io.EOF {
+			return false
+		}
+		panic(fmt.Sprintf("broken stream: %v", err))
+	}
+
+	*key = elm.Elm.Interface().(typex.Z)
+	*value = elm.Elm2.Interface().(typex.X)
+	return true
+}
+
+func iterMakerTypex_ZTypex_X(s ReStream) ReusableInput {
+	ret := &iterNative{s: s}
+	ret.fn = reflect.ValueOf(ret.readTypex_ZTypex_X)
+	return ret
+}
+
+func (v *iterNative) readETTypex_ZTypex_X(et *typex.EventTime, key *typex.Z, value *typex.X) bool {
+	elm, err := v.cur.Read()
+	if err != nil {
+		if err == io.EOF {
+			return false
+		}
+		panic(fmt.Sprintf("broken stream: %v", err))
+	}
+
+	*et = elm.Timestamp
+	*key = elm.Elm.Interface().(typex.Z)
+	*value = elm.Elm2.Interface().(typex.X)
+	return true
+}
+
+func iterMakerETTypex_ZTypex_X(s ReStream) ReusableInput {
+	ret := &iterNative{s: s}
+	ret.fn = reflect.ValueOf(ret.readETTypex_ZTypex_X)
+	return ret
+}
+
+func (v *iterNative) readTypex_ZTypex_Y(key *typex.Z, value *typex.Y) bool {
+	elm, err := v.cur.Read()
+	if err != nil {
+		if err == io.EOF {
+			return false
+		}
+		panic(fmt.Sprintf("broken stream: %v", err))
+	}
+
+	*key = elm.Elm.Interface().(typex.Z)
+	*value = elm.Elm2.Interface().(typex.Y)
+	return true
+}
+
+func iterMakerTypex_ZTypex_Y(s ReStream) ReusableInput {
+	ret := &iterNative{s: s}
+	ret.fn = reflect.ValueOf(ret.readTypex_ZTypex_Y)
+	return ret
+}
+
+func (v *iterNative) readETTypex_ZTypex_Y(et *typex.EventTime, key *typex.Z, value *typex.Y) bool {
+	elm, err := v.cur.Read()
+	if err != nil {
+		if err == io.EOF {
+			return false
+		}
+		panic(fmt.Sprintf("broken stream: %v", err))
+	}
+
+	*et = elm.Timestamp
+	*key = elm.Elm.Interface().(typex.Z)
+	*value = elm.Elm2.Interface().(typex.Y)
+	return true
+}
+
+func iterMakerETTypex_ZTypex_Y(s ReStream) ReusableInput {
+	ret := &iterNative{s: s}
+	ret.fn = reflect.ValueOf(ret.readETTypex_ZTypex_Y)
+	return ret
+}
+
+func (v *iterNative) readTypex_ZTypex_Z(key *typex.Z, value *typex.Z) bool {
+	elm, err := v.cur.Read()
+	if err != nil {
+		if err == io.EOF {
+			return false
+		}
+		panic(fmt.Sprintf("broken stream: %v", err))
+	}
+
+	*key = elm.Elm.Interface().(typex.Z)
+	*value = elm.Elm2.Interface().(typex.Z)
+	return true
+}
+
+func iterMakerTypex_ZTypex_Z(s ReStream) ReusableInput {
+	ret := &iterNative{s: s}
+	ret.fn = reflect.ValueOf(ret.readTypex_ZTypex_Z)
+	return ret
+}
+
+func (v *iterNative) readETTypex_ZTypex_Z(et *typex.EventTime, key *typex.Z, value *typex.Z) bool {
+	elm, err := v.cur.Read()
+	if err != nil {
+		if err == io.EOF {
+			return false
+		}
+		panic(fmt.Sprintf("broken stream: %v", err))
+	}
+
+	*et = elm.Timestamp
+	*key = elm.Elm.Interface().(typex.Z)
+	*value = elm.Elm2.Interface().(typex.Z)
+	return true
+}
+
+func iterMakerETTypex_ZTypex_Z(s ReStream) ReusableInput {
+	ret := &iterNative{s: s}
+	ret.fn = reflect.ValueOf(ret.readETTypex_ZTypex_Z)
+	return ret
+}
diff --git a/sdks/go/pkg/beam/core/runtime/exec/inputs.tmpl b/sdks/go/pkg/beam/core/runtime/exec/inputs.tmpl
new file mode 100644
index 00000000000..f1e4383e999
--- /dev/null
+++ b/sdks/go/pkg/beam/core/runtime/exec/inputs.tmpl
@@ -0,0 +1,144 @@
+// Licensed to the Apache Software Foundation (ASF) under one or more
+// contributor license agreements.  See the NOTICE file distributed with
+// this work for additional information regarding copyright ownership.
+// The ASF licenses this file to You under the Apache License, Version 2.0
+// (the "License"); you may not use this file except in compliance with
+// the License.  You may obtain a copy of the License at
+//
+//    http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package exec
+
+import (
+    "io"
+    "fmt"
+    "reflect"
+
+  	"github.com/apache/beam/sdks/go/pkg/beam/core/typex"
+)
+
+func init() {
+{{- range $x := .X}}
+    RegisterInput(reflect.TypeOf((*func (*{{$x.Type}})bool)(nil)).Elem(), iterMaker{{$x.Name}})
+    RegisterInput(reflect.TypeOf((*func (*typex.EventTime, *{{$x.Type}})bool)(nil)).Elem(), iterMakerET{{$x.Name}})
+{{- range $y := .Y}}
+    RegisterInput(reflect.TypeOf((*func (*{{$x.Type}}, *{{$y.Type}})bool)(nil)).Elem(), iterMaker{{$x.Name}}{{$y.Name}})
+    RegisterInput(reflect.TypeOf((*func (*typex.EventTime, *{{$x.Type}}, *{{$y.Type}})bool)(nil)).Elem(), iterMakerET{{$x.Name}}{{$y.Name}})
+{{- end}}
+{{- end}}
+}
+
+type iterNative struct {
+	s     ReStream
+	fn    reflect.Value
+
+	// cur is the "current" stream, if any.
+	cur Stream
+}
+
+func (v *iterNative) Init() error {
+	v.cur = v.s.Open()
+	return nil
+}
+
+func (v *iterNative) Value() reflect.Value {
+	return v.fn
+}
+
+func (v *iterNative) Reset() error {
+	if err := v.cur.Close(); err != nil {
+		return err
+	}
+	v.cur = nil
+	return nil
+}
+
+{{range $x := .X}}
+func (v *iterNative) read{{$x.Name}}(val *{{$x.Type}}) bool {
+	elm, err := v.cur.Read()
+	if err != nil {
+		if err == io.EOF {
+			return false
+		}
+		panic(fmt.Sprintf("broken stream: %v", err))
+	}
+
+    *val = elm.Elm.Interface().({{$x.Type}})
+    return true
+}
+
+func iterMaker{{$x.Name}}(s ReStream) ReusableInput {
+	ret := &iterNative{s: s}
+	ret.fn = reflect.ValueOf(ret.read{{$x.Name}})
+	return ret
+}
+
+func (v *iterNative) readET{{$x.Name}}(et *typex.EventTime, val *{{$x.Type}}) bool {
+	elm, err := v.cur.Read()
+	if err != nil {
+		if err == io.EOF {
+			return false
+		}
+		panic(fmt.Sprintf("broken stream: %v", err))
+	}
+
+    *et = elm.Timestamp
+    *val = elm.Elm.Interface().({{$x.Type}})
+    return true
+}
+
+func iterMakerET{{$x.Name}}(s ReStream) ReusableInput {
+	ret := &iterNative{s: s}
+	ret.fn = reflect.ValueOf(ret.readET{{$x.Name}})
+	return ret
+}
+
+{{range $y := .Y}}
+func (v *iterNative) read{{$x.Name}}{{$y.Name}}(key *{{$x.Type}}, value *{{$y.Type}}) bool {
+	elm, err := v.cur.Read()
+	if err != nil {
+		if err == io.EOF {
+			return false
+		}
+		panic(fmt.Sprintf("broken stream: %v", err))
+	}
+
+    *key = elm.Elm.Interface().({{$x.Type}})
+    *value = elm.Elm2.Interface().({{$y.Type}})
+    return true
+}
+
+func iterMaker{{$x.Name}}{{$y.Name}}(s ReStream) ReusableInput {
+	ret := &iterNative{s: s}
+	ret.fn = reflect.ValueOf(ret.read{{$x.Name}}{{$y.Name}})
+	return ret
+}
+
+func (v *iterNative) readET{{$x.Name}}{{$y.Name}}(et *typex.EventTime, key *{{$x.Type}}, value *{{$y.Type}}) bool {
+	elm, err := v.cur.Read()
+	if err != nil {
+		if err == io.EOF {
+			return false
+		}
+		panic(fmt.Sprintf("broken stream: %v", err))
+	}
+
+    *et = elm.Timestamp
+    *key = elm.Elm.Interface().({{$x.Type}})
+    *value = elm.Elm2.Interface().({{$y.Type}})
+    return true
+}
+
+func iterMakerET{{$x.Name}}{{$y.Name}}(s ReStream) ReusableInput {
+	ret := &iterNative{s: s}
+	ret.fn = reflect.ValueOf(ret.readET{{$x.Name}}{{$y.Name}})
+	return ret
+}
+{{end}}
+{{end}}
diff --git a/sdks/go/pkg/beam/core/runtime/exec/pardo.go b/sdks/go/pkg/beam/core/runtime/exec/pardo.go
index 9971e1dac7c..904fff37124 100644
--- a/sdks/go/pkg/beam/core/runtime/exec/pardo.go
+++ b/sdks/go/pkg/beam/core/runtime/exec/pardo.go
@@ -36,7 +36,7 @@ type ParDo struct {
 	Out  []Node
 
 	ready     bool
-	sideinput []ReusableSideInput
+	sideinput []ReusableInput
 	emitters  []ReusableEmitter
 	extra     []reflect.Value
 
diff --git a/sdks/go/pkg/beam/runners/direct/gbk.go b/sdks/go/pkg/beam/runners/direct/gbk.go
index e8b52ad2d91..174332fd5ac 100644
--- a/sdks/go/pkg/beam/runners/direct/gbk.go
+++ b/sdks/go/pkg/beam/runners/direct/gbk.go
@@ -36,7 +36,8 @@ type GBK struct {
 	Edge *graph.MultiEdge
 	Out  exec.Node
 
-	m map[string]*group
+	enc exec.ElementEncoder // key encoder for coder-equality
+	m   map[string]*group
 }
 
 func (n *GBK) ID() exec.UnitID {
@@ -44,6 +45,7 @@ func (n *GBK) ID() exec.UnitID {
 }
 
 func (n *GBK) Up(ctx context.Context) error {
+	n.enc = exec.MakeElementEncoder(coder.SkipW(n.Edge.Input[0].From.Coder).Components[0])
 	n.m = make(map[string]*group)
 	return nil
 }
@@ -54,7 +56,7 @@ func (n *GBK) StartBundle(ctx context.Context, id string, data exec.DataManager)
 
 func (n *GBK) ProcessElement(ctx context.Context, elm exec.FullValue, _ ...exec.ReStream) error {
 	var buf bytes.Buffer
-	if err := exec.EncodeElement(coder.SkipW(n.Edge.Input[0].From.Coder).Components[0], exec.FullValue{Elm: elm.Elm}, &buf); err != nil {
+	if err := n.enc.Encode(exec.FullValue{Elm: elm.Elm}, &buf); err != nil {
 		return fmt.Errorf("failed to encode key %v for GBK: %v", elm, err)
 	}
 	key := buf.String()
diff --git a/sdks/go/pkg/beam/testing/passert/passert.go b/sdks/go/pkg/beam/testing/passert/passert.go
index 38620f5a60a..4d5d634e78e 100644
--- a/sdks/go/pkg/beam/testing/passert/passert.go
+++ b/sdks/go/pkg/beam/testing/passert/passert.go
@@ -137,13 +137,15 @@ type indexEntry struct {
 
 func index(c *coder.Coder, iter func(*beam.T) bool) (map[string]indexEntry, error) {
 	ret := make(map[string]indexEntry)
+	enc := exec.MakeElementEncoder(c)
 
 	var val beam.T
 	for iter(&val) {
-		encoded, err := encode(c, val)
-		if err != nil {
-			return nil, err
+		var buf bytes.Buffer
+		if err := enc.Encode(exec.FullValue{Elm: reflect.ValueOf(val)}, &buf); err != nil {
+			return nil, fmt.Errorf("value %v not encodable by %v", val, c)
 		}
+		encoded := buf.String()
 
 		cur := ret[encoded]
 		ret[encoded] = indexEntry{count: cur.count + 1, value: val}
@@ -154,14 +156,6 @@ func index(c *coder.Coder, iter func(*beam.T) bool) (map[string]indexEntry, erro
 // TODO(herohde) 7/11/2017: perhaps extract the coder helpers as more
 // general and polished utilities for working with coders in user code.
 
-func encode(c *coder.Coder, value interface{}) (string, error) {
-	var buf bytes.Buffer
-	if err := exec.EncodeElement(c, exec.FullValue{Elm: reflect.ValueOf(value)}, &buf); err != nil {
-		return "", fmt.Errorf("value %v not encodable by %v", value, c)
-	}
-	return buf.String(), nil
-}
-
 // True asserts that all elements satisfy the given predicate.
 func True(s beam.Scope, col beam.PCollection, fn interface{}) beam.PCollection {
 	fail(s, filter.Exclude(s, col, fn), "predicate(%v) = false, want true")


 

----------------------------------------------------------------
This is an automated message from the Apache Git Service.
To respond to the message, please log on GitHub and use the
URL above to go to the specific comment.
 
For queries about this service, please contact Infrastructure at:
users@infra.apache.org


> Reduce Go runtime reflective overhead
> -------------------------------------
>
>                 Key: BEAM-3388
>                 URL: https://issues.apache.org/jira/browse/BEAM-3388
>             Project: Beam
>          Issue Type: Improvement
>          Components: sdk-go
>            Reporter: Henning Rohde
>            Assignee: Henning Rohde
>
> Go reflection is slow and we should avoid it in the Go SDK at runtime, when possible -- especially on the fast paths. It seems unlikely that the language runtime/libraries will improve any time soon: https://github.com/golang/go/issues/7818.



--
This message was sent by Atlassian JIRA
(v6.4.14#64029)


Mime
View raw message