Repository: matrixorigin/matrixone
Pull request #13859 (2023-12-27 07:55:35)

Ranges returns []byte instead of [][]byte
## What type of PR is this?

- [ ] API-change
- [ ] BUG
- [ ] Improvement
- [ ] Documentation
- [ ] Feature
- [ ] Test and CI
- [x] Code Refactoring

## Which issue(s) this PR fixes:

issue #12497

## What this PR does / why we need it:

Ranges now returns []byte instead of [][]byte.
Add BlockInfoSlice type.

nnsgmsone: 这样替换的好处是什么呢？有性能提升？有的话，benchmark呢

Patch:
diff --git a/pkg/catalog/types.go b/pkg/catalog/types.go
index ebfa06976..fde0e6e20 100644
--- a/pkg/catalog/types.go
+++ b/pkg/catalog/types.go
@@ -16,12 +16,10 @@ package catalog
 
 import (
 	"strings"
-	"unsafe"
 
 	"github.com/matrixorigin/matrixone/pkg/container/types"
 	"github.com/matrixorigin/matrixone/pkg/defines"
 	"github.com/matrixorigin/matrixone/pkg/fileservice"
-	"github.com/matrixorigin/matrixone/pkg/objectio"
 	"github.com/matrixorigin/matrixone/pkg/pb/plan"
 	"github.com/matrixorigin/matrixone/pkg/vm/engine"
 )
@@ -341,56 +339,6 @@ const (
 	SKIP_ROWID_OFFSET = 1 //rowid is the 0th vector in the batch
 )
 
-type ObjectLocation [objectio.LocationLen]byte
-
-const (
-	BlockInfoSize = unsafe.Sizeof(BlockInfo{})
-)
-
-type BlockInfo struct {
-	BlockID    types.Blockid
-	EntryState bool
-	Sorted     bool
-	MetaLoc    ObjectLocation
-	DeltaLoc   ObjectLocation
-	CommitTs   types.TS
-	SegmentID  types.Uuid
-
-	//TODO:: putting them here is a bad idea, remove
-	//this block can be distributed to remote nodes.
-	CanRemote    bool
-	PartitionNum int
-}
-
-func (b *BlockInfo) MetaLocation() objectio.Location {
-	return b.MetaLoc[:]
-}
-
-func (b *BlockInfo) SetMetaLocation(metaLoc objectio.Location) {
-	b.MetaLoc = *(*[objectio.LocationLen]byte)(unsafe.Pointer(&metaLoc[0]))
-}
-
-func (b *BlockInfo) DeltaLocation() objectio.Location {
-	return b.DeltaLoc[:]
-}
-
-func (b *BlockInfo) SetDeltaLocation(deltaLoc objectio.Location) {
-	b.DeltaLoc = *(*[objectio.LocationLen]byte)(unsafe.Pointer(&deltaLoc[0]))
-}
-
-// XXX info is passed in by value.   The use of unsafe here will cost
-// an allocation and copy.  BlockInfo is not small therefore this is
-// not exactly cheap.   However, caller of this function will keep a
-// reference to the buffer.  See txnTable.rangesOnePart.
-// ranges is *[][]byte.
-func EncodeBlockInfo(info BlockInfo) []byte {
-	return unsafe.Slice((*byte)(unsafe.Pointer(&info)), BlockInfoSize)
-}
-
-func DecodeBlockInfo(buf []byte) *BlockInfo {
-	return (*BlockInfo)(unsafe.Pointer(&buf[0]))
-}
-
 // used for memengine and tae
 // tae and memengine do not make the catalog into a table
 // for its convenience, a conversion interface is provided to ensure easy use.
diff --git a/pkg/objectio/block_info.go b/pkg/objectio/block_info.go
new file mode 100644
index 000000000..e48563f6b
--- /dev/null
+++ b/pkg/objectio/block_info.go
@@ -0,0 +1,139 @@
+// Copyright 2022 Matrix Origin
+//
+// Licensed 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 objectio
+
+import (
+	"unsafe"
+
+	"github.com/matrixorigin/matrixone/pkg/container/types"
+)
+
+type ObjectLocation [LocationLen]byte
+
+const (
+	BlockInfoType = uint16(1)
+
+	V1 = uint16(1)
+)
+
+type InfoHeader struct {
+	Type, Version uint16
+}
+
+func EncodeInfoHeader(h InfoHeader) uint32 {
+	return uint32(h.Type)<<16 | uint32(h.Version)
+}
+
+func DecodeInfoHeader(h uint32) InfoHeader {
+	return InfoHeader{
+		Type:    uint16(h >> 16),
+		Version: uint16(h),
+	}
+}
+
+var (
+	EmptyBlockInfo      = BlockInfo{}
+	EmptyBlockInfoBytes = EncodeBlockInfo(EmptyBlockInfo)
+)
+
+const (
+	BlockInfoSize = int(unsafe.Sizeof(EmptyBlockInfo))
+)
+
+type BlockInfo struct {
+	BlockID    types.Blockid
+	EntryState bool
+	Sorted     bool
+	MetaLoc    ObjectLocation
+	DeltaLoc   ObjectLocation
+	CommitTs   types.TS
+	SegmentID  types.Uuid
+
+	//TODO:: putting them here is a bad idea, remove
+	//this block can be distributed to remote nodes.
+	CanRemote    bool
+	PartitionNum int
+}
+
+func (b *BlockInfo) MetaLocation() Location {
+	return b.MetaLoc[:]
+}
+
+func (b *BlockInfo) SetMetaLocation(metaLoc Location) {
+	b.MetaLoc = *(*[LocationLen]byte)(unsafe.Pointer(&metaLoc[0]))
+}
+
+func (b *BlockInfo) DeltaLocation() Location {
+	return b.DeltaLoc[:]
+}
+
+func (b *BlockInfo) SetDeltaLocation(deltaLoc Location) {
+	b.DeltaLoc = *(*[LocationLen]byte)(unsafe.Pointer(&deltaLoc[0]))
+}
+
+// XXX info is passed in by value.   The use of unsafe here will cost
+// an allocation and copy.  BlockInfo is not small therefore this is
+// not exactly cheap.   However, caller of this function will keep a
+// reference to the buffer.  See txnTable.rangesOnePart.
+// ranges is *[][]byte.
+func EncodeBlockInfo(info BlockInfo) []byte {
+	return unsafe.Slice((*byte)(unsafe.Pointer(&info)), BlockInfoSize)
+}
+
+func DecodeBlockInfo(buf []byte) *BlockInfo {
+	return (*BlockInfo)(unsafe.Pointer(&buf[0]))
+}
+
+type BlockInfoSlice []byte
+
+func (s *BlockInfoSlice) Get(i int) *BlockInfo {
+	return DecodeBlockInfo((*s)[i*BlockInfoSize:])
+}
+
+func (s *BlockInfoSlice) GetBytes(i int) []byte {
+	return (*s)[i*BlockInfoSize : (i+1)*BlockInfoSize]
+}
+
+func (s *BlockInfoSlice) Set(i int, info *BlockInfo) {
+	copy((*s)[i*BlockInfoSize:], EncodeBlockInfo(*info))
+}
+
+func (s *BlockInfoSlice) Len() int {
+	return len(*s) / BlockInfoSize
+}
+
+func (s *BlockInfoSlice) Size() int {
+	return len(*s)
+}
+
+func (s *BlockInfoSlice) Slice(i, j int) []byte {
+	return (*s)[i*BlockInfoSize : j*BlockInfoSize]
+}
+
+func (s *BlockInfoSlice) Append(bs []byte) {
+	*s = append(*s, bs...)
+}
+
+func (s *BlockInfoSlice) AppendBlockInfo(info BlockInfo) {
+	*s = append(*s, EncodeBlockInfo(info)...)
+}
+
+func (s *BlockInfoSlice) SetBytes(bs []byte) {
+	*s = bs
+}
+
+func (s *BlockInfoSlice) GetAllBytes() []byte {
+	return *s
+}
diff --git a/pkg/pb/pipeline/pipeline.pb.go b/pkg/pb/pipeline/pipeline.pb.go
index f7def5233..c8441cdb9 100644
--- a/pkg/pb/pipeline/pipeline.pb.go
+++ b/pkg/pb/pipeline/pipeline.pb.go
@@ -3956,7 +3956,8 @@ type NodeInfo struct {
 	Mcpu                 int32    `protobuf:"varint,1,opt,name=mcpu,proto3" json:"mcpu,omitempty"`
 	Id                   string   `protobuf:"bytes,2,opt,name=id,proto3" json:"id,omitempty"`
 	Addr                 string   `protobuf:"bytes,3,opt,name=addr,proto3" json:"addr,omitempty"`
-	Payload              []string `protobuf:"bytes,4,rep,name=payload,proto3" json:"payload,omitempty"`
+	Payload              string   `protobuf:"bytes,4,opt,name=payload,proto3" json:"payload,omitempty"`
+	Type                 uint32   `protobuf:"varint,5,opt,name=type,proto3" json:"type,omitempty"`
 	XXX_NoUnkeyedLiteral struct{} `json:"-"`
 	XXX_unrecognized     []byte   `json:"-"`
 	XXX_sizecache        int32    `json:"-"`
@@ -4016,11 +4017,18 @@ func (m *NodeInfo) GetAddr() string {
 	return ""
 }
 
-func (m *NodeInfo) GetPayload() []string {
+func (m *NodeInfo) GetPayload() string {
 	if m != nil {
 		return m.Payload
 	}
-	return nil
+	return ""
+}
+
+func (m *NodeInfo) GetType() uint32 {
+	if m != nil {
+		return m.Type
+	}
+	return 0
 }
 
 type ProcessLimitation struct {
@@ -4717,287 +4725,287 @@ func init() {
 func init() { proto.RegisterFile("pipeline.proto", fileDescriptor_7ac67a7adf3df9c7) }
 
 var fileDescriptor_7ac67a7adf3df9c7 = []byte{
-	// 4472 bytes of a gzipped FileDescriptorProto
-	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xec, 0x7b, 0x4b, 0x8f, 0x24, 0xc7,
-	0x56, 0xb0, 0xab, 0xb2, 0x1e, 0x59, 0xa7, 0xaa, 0xba, 0xab, 0x63, 0x5e, 0xe5, 0xb1, 0x3d, 0x6e,
-	0xa7, 0x3d, 0x76, 0x7b, 0xec, 0xe9, 0xb1, 0xdb, 0x9f, 0x3f, 0xae, 0x30, 0x17, 0xdf, 0x9e, 0xee,
-	0x99, 0x4b, 0xe1, 0xe9, 0x9e, 0x26, 0xaa, 0x47, 0xc6, 0x16, 0x22, 0xc9, 0xce, 0x8c, 0xaa, 0x4a,
-	0x57, 0x56, 0x66, 0x4e, 0x3e, 0x3c, 0x5d, 0xb3, 0x62, 0x83, 0x58, 0xb1, 0xba, 0x12, 0x2c, 0x10,
-	0x88, 0x0d, 0x8b, 0xbb, 0x40, 0x20, 0xf8, 0x03, 0x2c, 0x59, 0x01, 0x42, 0x2c, 0xd8, 0x81, 0xcc,
-	0x5f, 0x40, 0xec, 0x2e, 0x42, 0xe7, 0x44, 0xe4, 0xab, 0xba, 0x7b, 0xfc, 0xc0, 0xc2, 0x96, 0xf0,
-	0x2e, 0xce, 0x23, 0x1e, 0x79, 0x5e, 0x71, 0x22, 0x4e, 0x24, 0xac, 0x85, 0x6e, 0x28, 0x3c, 0xd7,
-	0x17, 0xdb, 0x61, 0x14, 0x24, 0x01, 0xd3, 0x33, 0xf8, 0xfa, 0xed, 0xa9, 0x9b, 0xcc, 0xd2, 0x93,
-	0x6d, 0x3b, 0x58, 0xdc, 0x99, 0x06, 0xd3, 0xe0, 0x0e, 0x31, 0x9c, 0xa4, 0x13, 0x82, 0x08, 0xa0,
-	0x96, 0xec, 0x78, 0x1d, 0x42, 0xcf, 0xf2, 0x55, 0x7b, 0x3d, 0x71, 0x17, 0x22, 0x4e, 0xac, 0x45,
-	0x98, 0x11, 0xbd, 0xc0, 0x9e, 0xcb, 0xb6, 0xf1, 0x57, 0x75, 0x68, 0x1f, 0x88, 0x38, 0xb6, 0xa6,
-	0x82, 0x19, 0xa0, 0xc5, 0xae, 0x33, 0xac, 0x6d, 0xd6, 0xb6, 0xd6, 0x76, 0x06, 0xdb, 0xf9, 0x5a,
-	0xc6, 0x89, 0x95, 0xa4, 0x31, 0x47, 0x22, 0xf2, 0xd8, 0x0b, 0x67, 0x58, 0x5f, 0xe5, 0x39, 0x10,
-	0xc9, 0x2c, 0x70, 0x38, 0x12, 0xd9, 0x00, 0x34, 0x11, 0x45, 0x43, 0x6d, 0xb3, 0xb6, 0xd5, 0xe3,
-	0xd8, 0x64, 0x0c, 0x1a, 0x8e, 0x95, 0x58, 0xc3, 0x06, 0xa1, 0xa8, 0xcd, 0x5e, 0x83, 0xb5, 0x30,
-	0x0a, 0x6c, 0xd3, 0xf5, 0x27, 0x81, 0x49, 0xd4, 0x26, 0x51, 0x7b, 0x88, 0x1d, 0xf9, 0x93, 0x60,
-	0x1f, 0xb9, 0x86, 0xd0, 0xb6, 0x7c, 0xcb, 0x5b, 0xc6, 0x62, 0xd8, 0x22, 0x72, 0x06, 0xb2, 0x35,
-	0xa8, 0xbb, 0xce, 0xb0, 0xbd, 0x59, 0xdb, 0x6a, 0xf0, 0xba, 0xeb, 0xe0, 0x1c, 0x69, 0xea, 0x3a,
-	0x43, 0x5d, 0xce, 0x81, 0x6d, 0xf6, 0x02, 0x74, 0x4e, 0xac, 0xc4, 0x9e, 0x99, 0xb6, 0x9f, 0x0c,
-	0x3b, 0xc4, 0xaa, 0x13, 0x62, 0xcf, 0x4f, 0xd8, 0x75, 0xd0, 0xed, 0x99, 0xb0, 0xe7, 0x71, 0xba,
-	0x18, 0xc2, 0x66, 0x6d, 0xab, 0xcf, 0x73, 0x18, 0x69, 0xb1, 0x78, 0x9c, 0x0a, 0xdf, 0x16, 0xc3,
-	0xae, 0xec, 0x97, 0xc1, 0xc6, 0x23, 0xe8, 0xec, 0x05, 0xbe, 0x2f, 0xec, 0x24, 0x88, 0xd8, 0xcb,
-	0xd0, 0xcd, 0x64, 0x60, 0x2a, 0xd9, 0x35, 0x39, 0x64, 0xa8, 0x91, 0xc3, 0xde, 0x80, 0x75, 0x3b,
-	0xe3, 0x36, 0x5d, 0xdf, 0x11, 0xa7, 0x24, 0xbc, 0x26, 0x5f, 0xcb, 0xd1, 0x23, 0xc4, 0x1a, 0x7f,
-	0x5e, 0x87, 0xf6, 0x78, 0x96, 0x4e, 0x26, 0x9e, 0x60, 0xaf, 0x41, 0x5f, 0x35, 0xf7, 0x02, 0x6f,
-	0xe4, 0x9c, 0xaa, 0x71, 0xab, 0x48, 0xb6, 0x09, 0x5d, 0x85, 0x38, 0x5e, 0x86, 0x42, 0x0d, 0x5b,
-	0x46, 0x55, 0xc7, 0x39, 0x70, 0x7d, 0xd2, 0x89, 0xc6, 0xab, 0xc8, 0x15, 0x2e, 0xeb, 0x94, 0xd4,
-	0x54, 0xe5, 0xb2, 0x68, 0xb6, 0x5d, 0xcf, 0xfd, 0x5c, 0x70, 0x31, 0xdd, 0xf3, 0x13, 0x52, 0x56,
-	0x93, 0x97, 0x51, 0x6c, 0x07, 0xae, 0xc4, 0xb2, 0x8b, 0x19, 0x59, 0xfe, 0x54, 0xc4, 0x66, 0xea,
-	0xfa, 0xc9, 0xff, 0xff, 0x7f, 0xc3, 0xd6, 0xa6, 0xb6, 0xd5, 0xe0, 0x97, 0x14, 0x91, 0x13, 0xed,
-	0x11, 0x91, 0xd8, 0x3b, 0x70, 0x79, 0xa5, 0x8f, 0xec, 0xd2, 0xde, 0xd4, 0xb6, 0x34, 0xce, 0x2a,
-	0x5d, 0x46, 0x48, 0x31, 0xfe, 0xb5, 0x0e, 0xfa, 0xbe, 0x1b, 0x87, 0xa8, 0x46, 0x76, 0x0d, 0xda,
-	0x93, 0xd4, 0xb7, 0x0b, 0xd1, 0xb7, 0x10, 0x1c, 0x39, 0xec, 0x57, 0x60, 0xdd, 0x0b, 0x6c, 0xcb,
-	0x33, 0x73, 0x29, 0x0f, 0xeb, 0x9b, 0xda, 0x56, 0x77, 0xe7, 0x52, 0x61, 0xb3, 0xb9, 0x16, 0xf9,
-	0x1a, 0xf1, 0x16, 0x5a, 0xfd, 0x31, 0x0c, 0x22, 0xb1, 0x08, 0x12, 0x51, 0xea, 0xae, 0x51, 0x77,
-	0x56, 0x74, 0xff, 0x38, 0xb2, 0xc2, 0xc3, 0xc0, 0x11, 0x7c, 0x5d, 0xf2, 0x16, 0xdd, 0xdf, 0x2d,
-	0x09, 0x42, 0x4c, 0x4d, 0xd7, 0x39, 0x35, 0x69, 0x82, 0x61, 0x63, 0x53, 0xdb, 0x6a, 0x16, 0x5f,
-	0x25, 0xa6, 0x23, 0xe7, 0xf4, 0x01, 0x52, 0xd8, 0x7b, 0x70, 0x75, 0xb5, 0x8b, 0x1c, 0x75, 0xd8,
-	0xa4, 0x3e, 0x97, 0x2a, 0x7d, 0x38, 0x91, 0xd8, 0x2b, 0xd0, 0xcb, 0x3a, 0x25, 0x68, 0x01, 0x2d,
-	0xa9, 0x93, 0xb8, 0x64, 0x01, 0xd7, 0xa0, 0xed, 0xc6, 0x66, 0xec, 0xfa, 0x73, 0x72, 0x15, 0x9d,
-	0xb7, 0xdc, 0x78, 0xec, 0xfa, 0x73, 0xf6, 0x3c, 0xe8, 0x91, 0xb0, 0x25, 0x45, 0x27, 0x4a, 0x3b,
-	0x12, 0x36, 0x92, 0x8c, 0x57, 0xa1, 0x79, 0x20, 0xa2, 0xa9, 0x20, 0x2f, 0x70, 0xfd, 0xf9, 0xd8,
-	0xb6, 0x7c, 0x12, 0xaf, 0xce, 0x73, 0xd8, 0xf8, 0x9b, 0x1a, 0xf4, 0x0f, 0x52, 0x2f, 0x71, 0x77,
-	0xa3, 0x69, 0x2a, 0x16, 0x7e, 0x82, 0x0e, 0xb8, 0xef, 0xc6, 0x89, 0xe2, 0xa4, 0x36, 0xdb, 0x82,
-	0xce, 0x4f, 0xa3, 0x20, 0x0d, 0xef, 0x9d, 0x86, 0x99, 0x02, 0x60, 0x9b, 0x62, 0x13, 0x62, 0x78,
-	0x41, 0x64, 0x6f, 0x43, 0xf7, 0x61, 0xe4, 0x88, 0xe8, 0xee, 0x92, 0x78, 0xb5, 0x33, 0xbc, 0x65,
-	0x32, 0x7b, 0x11, 0x3a, 0x63, 0x11, 0x5a, 0x91, 0x85, 0x9a, 0x41, 0x73, 0xed, 0xf0, 0x02, 0x81,
-	0x41, 0x83, 0x98, 0x47, 0x8e, 0x32, 0xd3, 0x0c, 0x34, 0xa6, 0xd0, 0xd9, 0x9d, 0x4e, 0x23, 0x31,
-	0xb5, 0x12, 0x8a, 0x20, 0x41, 0x48, 0xcb, 0xd5, 0x78, 0x3d, 0x08, 0x29, 0x4a, 0xe1, 0x07, 0xd4,
-	0xe5, 0x07, 0x60, 0x9b, 0xdd, 0x80, 0x86, 0x90, 0xeb, 0xa9, 0xad, 0xac, 0x87, 0xf0, 0xec, 0x2a,
-	0xb4, 0xec, 0xc0, 0x9f, 0xb8, 0x53, 0x15, 0xdb, 0x14, 0x64, 0xfc, 0xa1, 0x06, 0x4d, 0xfa, 0x38,
-	0x8c, 0x41, 0xbe, 0x10, 0x8e, 0x29, 0x3e, 0xb7, 0xbc, 0x4c, 0x8a, 0x88, 0xb8, 0xf7, 0xb9, 0xe5,
-	0xe1, 0x4a, 0xdd, 0x93, 0xd4, 0x9e, 0x0b, 0x39, 0x6b, 0x83, 0x67, 0x20, 0x52, 0x7c, 0x45, 0xd1,
-	0x24, 0x45, 0x81, 0x6c, 0x13, 0x9a, 0x38, 0x75, 0x4c, 0xd6, 0x54, 0x5d, 0x93, 0x24, 0x20, 0x07,
-	0xda, 0x43, 0x4c, 0xb6, 0x93, 0x73, 0xa0, 0x3d, 0x70, 0x49, 0x60, 0x6f, 0x40, 0xc3, 0x9a, 0x4e,
-	0x63, 0xf2, 0xcc, 0x8a, 0x4f, 0xe4, 0xd2, 0xe1, 0xc4, 0xc0, 0xde, 0x87, 0x8e, 0xd4, 0x32, 0x72,
-	0xb7, 0x89, 0xfb, 0x5a, 0x29, 0xea, 0x97, 0x0d, 0x80, 0x17, 0x9c, 0xa8, 0x1f, 0x37, 0x56, 0xf1,
-	0x43, 0x99, 0x57, 0x81, 0x60, 0x06, 0xf4, 0xc2, 0x48, 0xec, 0x7a, 0x5e, 0x60, 0x8f, 0xdd, 0xa7,
-	0x42, 0x45, 0xe6, 0x0a, 0x8e, 0xbd, 0x0e, 0x6b, 0x47, 0x56, 0x94, 0xb8, 0x96, 0xc7, 0x45, 0x9c,
-	0x7a, 0x49, 0x4c, 0x71, 0xb8, 0xc7, 0x57, 0xb0, 0x6c, 0x1b, 0x58, 0x05, 0x73, 0x4c, 0x1f, 0x0e,
-	0x9b, 0xda, 0x56, 0x9f, 0x9f, 0x43, 0x31, 0xfe, 0xa3, 0x0e, 0xad, 0x91, 0x1f, 0x8b, 0x88, 0x36,
-	0x00, 0x6b, 0x32, 0x11, 0x76, 0x22, 0x64, 0xf4, 0x68, 0xf0, 0x1c, 0xc6, 0x0f, 0x38, 0x0e, 0x3e,
-	0x8e, 0xdc, 0x44, 0x8c, 0xdf, 0x53, 0x06, 0x51, 0x20, 0xd8, 0x2d, 0xd8, 0xb0, 0x1c, 0xc7, 0xcc,
-	0xb8, 0xcd, 0x28, 0x78, 0x12, 0x93, 0x9a, 0x74, 0xbe, 0x6e, 0x39, 0xce, 0xae, 0xc2, 0xf3, 0xe0,
-	0x49, 0xcc, 0x5e, 0x01, 0x2d, 0x12, 0x13, 0x32, 0x8f, 0xee, 0xce, 0xba, 0x54, 0xc5, 0xc3, 0x93,
-	0xcf, 0x84, 0x9d, 0x70, 0x31, 0xe1, 0x48, 0x63, 0x97, 0xa1, 0x69, 0x25, 0x49, 0x24, 0xf5, 0xd5,
-	0xe1, 0x12, 0x60, 0xdb, 0x70, 0x29, 0xc4, 0xf5, 0x27, 0x6e, 0xe0, 0x9b, 0x89, 0x75, 0xe2, 0xe1,
-	0x0e, 0x13, 0xab, 0x60, 0xba, 0x91, 0x93, 0x8e, 0x91, 0x32, 0x72, 0x62, 0x0c, 0xbf, 0xab, 0xfc,
-	0xbe, 0xb5, 0x10, 0x52, 0x6d, 0x1d, 0x7e, 0xa9, 0xda, 0xe3, 0x10, 0x49, 0xec, 0x55, 0xe8, 0x17,
-	0x7d, 0x5c, 0xe7, 0x94, 0x74, 0xd5, 0xe4, 0xbd, 0x1c, 0x89, 0xfb, 0xcc, 0x15, 0x68, 0xb9, 0xb1,
-	0x29, 0x7c, 0x87, 0x14, 0xa5, 0xf3, 0xa6, 0x1b, 0xdf, 0xf3, 0x1d, 0xf6, 0x16, 0x74, 0xe4, 0x2c,
-	0x8e, 0x98, 0xd0, 0x06, 0xda, 0xdd, 0x59, 0x53, 0x96, 0x86, 0xe8, 0x7d, 0x31, 0xe1, 0x7a, 0xa2,
-	0x5a, 0xc6, 0x4b, 0xd0, 0xdc, 0x8d, 0x22, 0x6b, 0x49, 0xdf, 0x8a, 0x8d, 0x61, 0x8d, 0xe2, 0x9a,
-	0x04, 0x0c, 0x1b, 0xb4, 0x03, 0x2b, 0x64, 0x37, 0xa1, 0xbe, 0x08, 0x89, 0xd2, 0xdd, 0xb9, 0x52,
-	0x32, 0x33, 0x2b, 0xdc, 0x3e, 0x08, 0xef, 0xf9, 0x49, 0xb4, 0xe4, 0xf5, 0x45, 0x78, 0xfd, 0x7d,
-	0x68, 0x2b, 0x10, 0x73, 0x8d, 0xb9, 0x58, 0x92, 0xfa, 0x3a, 0x1c, 0x9b, 0x38, 0xc1, 0xe7, 0x96,
-	0x97, 0x66, 0xfb, 0xa1, 0x04, 0x7e, 0xb9, 0xfe, 0xa3, 0x9a, 0xf1, 0x7b, 0x4d, 0xd0, 0xf7, 0x85,
-	0x27, 0xf0, 0xbb, 0xd0, 0xf9, 0x8f, 0x63, 0xa5, 0xf6, 0xfa, 0x71, 0x8c, 0x36, 0x59, 0x56, 0x9b,
-	0x72, 0xc7, 0x0a, 0x0e, 0x79, 0x64, 0xe4, 0xa5, 0x51, 0x84, 0xd2, 0x78, 0x05, 0x87, 0x7e, 0x3b,
-	0xba, 0x2b, 0xfd, 0xb6, 0x41, 0x49, 0x45, 0x06, 0x22, 0xe5, 0x50, 0x51, 0x9a, 0x92, 0xa2, 0x40,
-	0xf6, 0x22, 0x40, 0x14, 0x3c, 0x31, 0x5d, 0x87, 0x54, 0x20, 0xa3, 0xb8, 0x1e, 0x05, 0x4f, 0x46,
-	0x0e, 0x8a, 0xff, 0x02, 0x3b, 0x68, 0x7f, 0x6d, 0x3b, 0xd0, 0x2f, 0xb6, 0x83, 0x5f, 0x82, 0x61,
-	0xc9, 0x0e, 0x30, 0x1f, 0x31, 0x5d, 0xdf, 0xa4, 0x54, 0x89, 0x94, 0xde, 0xe4, 0xc5, 0x98, 0x94,
-	0xae, 0x8c, 0xfc, 0xbb, 0xb4, 0x01, 0x2b, 0xeb, 0x86, 0x67, 0x58, 0xf7, 0xb9, 0xce, 0xd2, 0x3d,
-	0xdf, 0x59, 0xee, 0x02, 0x8c, 0xc5, 0x74, 0x21, 0xfc, 0xe4, 0xc0, 0x0a, 0x87, 0x3d, 0x32, 0x04,
-	0xa3, 0x30, 0x84, 0x4c, 0x7b, 0xdb, 0x05, 0x93, 0xb4, 0x8a, 0x52, 0x2f, 0xdc, 0x15, 0x6d, 0xcb,
-	0x37, 0x93, 0x28, 0xf5, 0x6d, 0x2b, 0x11, 0xc3, 0x3e, 0x4d, 0xd5, 0xb5, 0x2d, 0xff, 0x58, 0xa1,
-	0x4a, 0x16, 0xbd, 0x56, 0xb6, 0xe8, 0xd7, 0x61, 0x3d, 0x8c, 0xdc, 0x85, 0x15, 0x2d, 0xcd, 0xb9,
-	0x58, 0x92, 0x32, 0xd6, 0x65, 0xe2, 0xa5, 0xd0, 0x1f, 0x89, 0xe5, 0xc8, 0x39, 0xbd, 0xfe, 0x63,
-	0x58, 0x5f, 0x59, 0xc0, 0xd7, 0xb2, 0xc3, 0xbf, 0xad, 0x41, 0xe7, 0x28, 0x12, 0x2a, 0x0a, 0xbd,
-	0x0c, 0xdd, 0xd8, 0x9e, 0x89, 0x85, 0x45, 0x5a, 0x52, 0x23, 0x80, 0x44, 0xa1, 0x72, 0xaa, 0x7e,
-	0x56, 0x7f, 0xb6, 0x9f, 0xe1, 0x3a, 0x70, 0xd9, 0x1a, 0x39, 0x17, 0x36, 0x8b, 0xe0, 0xd2, 0x28,
-	0x07, 0x97, 0x4d, 0xe8, 0xcd, 0xac, 0xd8, 0xb4, 0xd2, 0x24, 0x30, 0xed, 0xc0, 0x23, 0x8b, 0xd4,
-	0x39, 0xcc, 0xac, 0x78, 0x37, 0x4d, 0x82, 0xbd, 0xc0, 0xc3, 0x7d, 0xcb, 0x8d, 0xcd, 0x34, 0x74,
-	0x50, 0x86, 0x2d, 0xb9, 0x6f, 0xb9, 0xf1, 0x23, 0x82, 0x8d, 0x7f, 0xae, 0x03, 0x3c, 0x08, 0xec,
-	0xf9, 0xb1, 0x15, 0x4d, 0x45, 0x82, 0xc9, 0x44, 0x66, 0x98, 0xca, 0xa5, 0xda, 0x89, 0x34, 0x47,
-	0xb6, 0x03, 0x57, 0x33, 0x99, 0xda, 0x81, 0x47, 0x89, 0x8d, 0xb4, 0x2c, 0x25, 0x17, 0xa6, 0xa8,
-	0x32, 0xa7, 0x25, 0xb3, 0x62, 0x3b, 0x85, 0x1e, 0xb0, 0x4f, 0xb2, 0x0c, 0xab, 0xfb, 0x2f, 0xed,
-	0x64, 0xfd, 0xa2, 0xe3, 0xf1, 0x32, 0x64, 0xef, 0xc0, 0x95, 0x48, 0x4c, 0x22, 0x11, 0xcf, 0xcc,
-	0x24, 0x2e, 0x4f, 0xd3, 0xa0, 0x69, 0x36, 0x14, 0xf1, 0x38, 0xce, 0x67, 0x79, 0x07, 0xae, 0x4c,
-	0x5c, 0x2f, 0x11, 0xd1, 0xea, 0xc2, 0x64, 0xce, 0xb0, 0x21, 0x89, 0xe5, 0x75, 0xbd, 0x04, 0x74,
-	0x74, 0x92, 0x4e, 0xa5, 0x64, 0xd2, 0xf1, 0x48, 0x0c, 0x27, 0x9e, 0xc0, 0x3d, 0x63, 0x6f, 0x86,
-	0x99, 0xea, 0xbe, 0x98, 0xa8, 0x6c, 0xab, 0x40, 0x30, 0x03, 0x1a, 0x07, 0x81, 0x23, 0x77, 0xc3,
-	0xb5, 0x9d, 0xb5, 0x6d, 0x3a, 0x84, 0xa1, 0x0c, 0x11, 0xcb, 0x89, 0x66, 0x1c, 0x42, 0x0b, 0x31,
-	0x0f, 0x43, 0xb6, 0x0d, 0xed, 0x84, 0x64, 0x1b, 0xab, 0x70, 0x78, 0xb9, 0xf0, 0x82, 0x42, 0xf0,
-	0x3c, 0x63, 0x42, 0x2d, 0x9f, 0xe0, 0x88, 0x6a, 0xaf, 0x92, 0x80, 0xc1, 0x61, 0x3d, 0x37, 0xb4,
-	0x47, 0xbe, 0xfb, 0x38, 0x15, 0xec, 0x43, 0xd8, 0x08, 0x23, 0x61, 0xba, 0x84, 0x33, 0xd3, 0xb9,
-	0x69, 0x27, 0xf2, 0x78, 0x41, 0x53, 0xa0, 0x74, 0x8b, 0x1e, 0xf3, 0xbd, 0xe4, 0x94, 0xaf, 0x85,
-	0x15, 0xd8, 0xf8, 0x14, 0xae, 0xe5, 0x1c, 0x63, 0x61, 0x07, 0xbe, 0x63, 0x45, 0x4b, 0x8a, 0x09,
-	0x2b, 0x63, 0xc7, 0x5f, 0x67, 0xec, 0x31, 0x8d, 0xfd, 0x97, 0x75, 0x58, 0x7b, 0xe8, 0xef, 0xa7,
-	0xa1, 0xe7, 0xa2, 0x9f, 0x7e, 0x24, 0x96, 0x55, 0xeb, 0xaf, 0x7d, 0x89, 0xf5, 0x6f, 0xc1, 0x20,
-	0xf0, 0x4d, 0x27, 0xeb, 0x4f, 0x1e, 0x5c, 0x27, 0x57, 0x58, 0x0b, 0x8a, 0x61, 0x31, 0xa8, 0x7e,
-	0x02, 0x1b, 0x15, 0x4e, 0x51, 0x24, 0x9d, 0xb7, 0x0b, 0x49, 0x57, 0xd7, 0x52, 0x06, 0x31, 0xdd,
-	0x92, 0xa1, 0x67, 0x3d, 0xa8, 0x62, 0x95, 0xe3, 0xb8, 0x53, 0x3f, 0x88, 0x04, 0x59, 0x1f, 0x39,
-	0xce, 0x88, 0xe0, 0xeb, 0x87, 0x70, 0xf9, 0xbc, 0x51, 0xce, 0x89, 0x1f, 0x9b, 0xe5, 0xf8, 0xb1,
-	0x92, 0xe6, 0x15, 0xb1, 0xe4, 0xe7, 0x35, 0xe8, 0xde, 0x4f, 0x9f, 0x3e, 0x5d, 0xde, 0x27, 0x6b,
-	0x65, 0x3d, 0xa8, 0x1d, 0xd2, 0x28, 0x75, 0x5e, 0x3b, 0xc4, 0xec, 0xf4, 0x68, 0x8e, 0x41, 0x84,
-	0x06, 0xe9, 0x70, 0x05, 0xe1, 0xd8, 0x47, 0xf3, 0xe3, 0x73, 0xdd, 0x4a, 0x12, 0x18, 0x87, 0xe7,
-	0xa3, 0xd4, 0x4f, 0xdc, 0x85, 0x30, 0x95, 0x93, 0x9c, 0xa4, 0xae, 0xe7, 0x98, 0x1e, 0x26, 0xc8,
-	0x8d, 0x2c, 0x0f, 0xc4, 0x5e, 0x5c, 0xb2, 0xc9, 0xf9, 0xc7, 0xa1, 0xb0, 0xf9, 0xd5, 0xa8, 0x8c,
-	0xba, 0x8b, 0xfd, 0x1e, 0xb8, 0x71, 0x62, 0xfc, 0x91, 0x06, 0x8d, 0x5f, 0x0f, 0x5c, 0xbf, 0x9c,
-	0xf5, 0xd6, 0x2e, 0xcc, 0x7a, 0xeb, 0xd5, 0xac, 0x97, 0xce, 0x2b, 0x9e, 0x9c, 0x5f, 0x46, 0xb7,
-	0x76, 0x24, 0x3c, 0x1c, 0x17, 0x49, 0xe8, 0xc1, 0xf9, 0xd2, 0x9a, 0xbc, 0x6d, 0x07, 0x92, 0x94,
-	0xa5, 0xef, 0xcd, 0x0b, 0xd2, 0xf7, 0x3c, 0x53, 0x6e, 0x5d, 0x9c, 0x29, 0x77, 0x3c, 0x31, 0x49,
-	0xf0, 0x20, 0xe8, 0xa8, 0x04, 0xb8, 0x3c, 0x8c, 0x8e, 0xc4, 0xbd, 0xc0, 0x77, 0xd8, 0x9b, 0x00,
-	0x91, 0x3b, 0x9d, 0x29, 0x4e, 0xfd, 0xec, 0x59, 0x87, 0xa8, 0xc4, 0xfa, 0x4c, 0xe1, 0x76, 0xbe,
-	0x91, 0x70, 0x31, 0x87, 0x98, 0x59, 0xf1, 0xcc, 0x0c, 0x7c, 0x33, 0x9c, 0xd3, 0x7e, 0xac, 0x73,
-	0x1d, 0x31, 0x0f, 0xfd, 0xa3, 0x39, 0x46, 0x2e, 0x3c, 0x06, 0xaa, 0x84, 0xbc, 0xbb, 0x92, 0x90,
-	0x1b, 0x3f, 0xaf, 0x83, 0xbe, 0xeb, 0x27, 0xee, 0x37, 0xd6, 0xce, 0x55, 0x68, 0x45, 0x94, 0x64,
-	0x2b, 0xdd, 0x28, 0x28, 0x97, 0x7f, 0xe3, 0xcb, 0xe4, 0xdf, 0xfc, 0x4a, 0xf2, 0x6f, 0x7d, 0x65,
-	0xf9, 0xb7, 0x9f, 0x25, 0xff, 0xaa, 0xac, 0xf4, 0x67, 0xca, 0xaa, 0xb3, 0x2a, 0xab, 0x3f, 0xd6,
-	0x40, 0x7f, 0x20, 0x26, 0xc9, 0x0f, 0x96, 0xfc, 0x7d, 0xb4, 0xe4, 0x7f, 0xd2, 0xa0, 0xc3, 0x71,
-	0x79, 0xdf, 0x33, 0xf5, 0xbc, 0x09, 0x40, 0xc2, 0xbf, 0x48, 0x47, 0xa4, 0x1a, 0x3a, 0xa1, 0xb2,
-	0xb7, 0xa0, 0x2b, 0xc5, 0x2f, 0x79, 0xdb, 0x67, 0x78, 0xa5, 0x76, 0x8e, 0xcf, 0x2a, 0x55, 0xff,
-	0xca, 0x4a, 0xed, 0x7c, 0x63, 0xa5, 0xc2, 0xb7, 0xa1, 0xd4, 0xee, 0x33, 0x95, 0xda, 0x5b, 0x55,
-	0xea, 0x1f, 0x68, 0xd0, 0x27, 0xa5, 0x8e, 0xc5, 0xe2, 0x7f, 0x3f, 0x46, 0xad, 0xe8, 0xa3, 0xf9,
-	0xd5, 0xf5, 0xf1, 0x2d, 0x85, 0xab, 0x67, 0xea, 0x43, 0xff, 0x36, 0xf4, 0xd1, 0x79, 0xa6, 0x3e,
-	0xe0, 0x42, 0x7d, 0x7c, 0x27, 0x7b, 0xc6, 0x0f, 0xfa, 0x58, 0xd5, 0xc7, 0x2f, 0xea, 0xa0, 0x7f,
-	0x27, 0xae, 0xf1, 0xdd, 0x6c, 0xdf, 0xdf, 0x3b, 0xf9, 0xff, 0x89, 0x06, 0x30, 0x76, 0xfd, 0xa9,
-	0x27, 0x7e, 0x48, 0x0a, 0xbe, 0x8f, 0x49, 0xc1, 0xdf, 0xd7, 0x41, 0x3f, 0xb0, 0xa2, 0xf9, 0xff,
-	0x11, 0xff, 0x78, 0x15, 0xda, 0x81, 0x5f, 0xf6, 0x86, 0x32, 0x5f, 0x2b, 0xf0, 0xff, 0xe7, 0x06,
-	0xff, 0xbb, 0x35, 0x68, 0x1f, 0x45, 0x81, 0x93, 0xda, 0x55, 0xcb, 0xad, 0x5d, 0x6c, 0xb9, 0xf5,
-	0xaa, 0xe5, 0xe6, 0x92, 0xd1, 0x2e, 0x92, 0x4c, 0x75, 0x09, 0x8d, 0xd5, 0x25, 0xfc, 0xac, 0x06,
-	0x7d, 0xba, 0x01, 0xb8, 0x9f, 0xfa, 0x36, 0xdd, 0xe8, 0xe6, 0x17, 0x5d, 0xb5, 0xea, 0x45, 0x57,
-	0x23, 0x12, 0x49, 0xac, 0x8a, 0x4f, 0x3d, 0x39, 0xcf, 0x5e, 0xe0, 0xed, 0x8b, 0x09, 0x27, 0x0a,
-	0x2a, 0xd1, 0x8a, 0xa6, 0xf1, 0x39, 0x25, 0x27, 0xc2, 0xa3, 0xf2, 0x43, 0x2b, 0xb2, 0x16, 0x71,
-	0x56, 0xe2, 0x91, 0x10, 0x63, 0xd0, 0xa0, 0x1b, 0xbb, 0x26, 0x1d, 0xad, 0xa9, 0x6d, 0xfc, 0x7e,
-	0x1d, 0x3a, 0xbf, 0x66, 0xc5, 0x33, 0x32, 0xdc, 0xa2, 0xf4, 0x83, 0x36, 0x52, 0x2e, 0xfd, 0xa8,
-	0x6b, 0x02, 0x22, 0xa2, 0xcc, 0xd5, 0xad, 0x0d, 0x11, 0xb1, 0x7b, 0xd9, 0x48, 0xb5, 0x0b, 0x8d,
-	0xb4, 0x71, 0xa6, 0x2e, 0xf4, 0x25, 0xc6, 0xb6, 0x09, 0x4d, 0xb4, 0x9e, 0xf8, 0x1c, 0x43, 0x93,
-	0x84, 0x15, 0xab, 0x68, 0xaf, 0x58, 0xc5, 0x2d, 0xd8, 0xa0, 0x25, 0x2f, 0x44, 0x34, 0x15, 0x8e,
-	0xba, 0x1e, 0x96, 0xc7, 0xa7, 0x75, 0x24, 0x50, 0xd5, 0xd0, 0xa1, 0x8b, 0x61, 0x63, 0x17, 0xae,
-	0xdc, 0x3b, 0x4d, 0x44, 0xe4, 0x5b, 0xde, 0xa1, 0xb5, 0x10, 0x3b, 0x7b, 0x81, 0x27, 0x2f, 0x89,
-	0x32, 0xb1, 0xd5, 0x0a, 0xb1, 0xa1, 0xea, 0xca, 0xa5, 0x71, 0x09, 0x18, 0x37, 0xa1, 0x3b, 0x71,
-	0x3d, 0x61, 0x06, 0x93, 0x49, 0x2c, 0x9d, 0x50, 0xb6, 0x48, 0xc1, 0x1a, 0x57, 0x90, 0xf1, 0x5f,
-	0x75, 0xe8, 0x65, 0x53, 0x8d, 0x6d, 0xeb, 0x22, 0x43, 0x78, 0x01, 0x3a, 0x34, 0x5a, 0xec, 0x3e,
-	0x15, 0x64, 0x0d, 0x1a, 0xd7, 0x11, 0x41, 0xd5, 0xa6, 0x5d, 0xd8, 0x28, 0x4d, 0x65, 0x26, 0x41,
-	0x62, 0x79, 0xca, 0x20, 0x4a, 0x75, 0x88, 0x12, 0x0b, 0x5f, 0x47, 0xe0, 0x21, 0xb5, 0x8f, 0x91,
-	0x1b, 0x0d, 0xcd, 0x0e, 0xbc, 0xac, 0x2a, 0xb7, 0x62, 0x68, 0x48, 0x61, 0x3f, 0x85, 0x75, 0xfc,
-	0xda, 0x1d, 0x79, 0xdf, 0x48, 0xdf, 0x2b, 0x55, 0xf5, 0x72, 0x31, 0xc5, 0xb9, 0x32, 0xe3, 0x7d,
-	0xbf, 0x22, 0xc2, 0x97, 0x00, 0xec, 0x48, 0x58, 0x89, 0x30, 0xe3, 0xc7, 0x1e, 0xdd, 0x43, 0x76,
-	0x78, 0x47, 0x62, 0xc6, 0x8f, 0xbd, 0xfc, 0x4b, 0xc9, 0xef, 0x64, 0xf1, 0x87, 0xbe, 0x94, 0x1c,
-	0xef, 0x36, 0x74, 0x83, 0xc8, 0x9d, 0xba, 0xbe, 0x49, 0xab, 0xd5, 0xcf, 0x59, 0x2d, 0x48, 0x86,
-	0x3d, 0x5c, 0xb3, 0x01, 0x2d, 0x19, 0xc3, 0x29, 0x44, 0xac, 0x84, 0x12, 0x49, 0x31, 0x6c, 0x80,
-	0x71, 0x12, 0x09, 0x6b, 0x41, 0xd2, 0x7f, 0x03, 0xda, 0xc9, 0x89, 0xf7, 0x8c, 0xeb, 0xba, 0x56,
-	0x72, 0x82, 0xd3, 0x94, 0xf4, 0x59, 0xa7, 0x12, 0xac, 0x82, 0x50, 0x7d, 0x9e, 0xbb, 0x70, 0x13,
-	0xf5, 0x58, 0x41, 0x02, 0xc6, 0x2f, 0x6a, 0x00, 0x63, 0x6b, 0x11, 0x4a, 0x87, 0x67, 0x3f, 0x81,
-	0x6e, 0x4c, 0x90, 0xac, 0x7c, 0xcb, 0x37, 0x2b, 0x25, 0x39, 0x16, 0xac, 0xaa, 0x29, 0x33, 0xc3,
-	0x38, 0x6f, 0xd3, 0xbd, 0xbb, 0x1c, 0x21, 0xca, 0xea, 0x3d, 0xcd, 0x8c, 0x81, 0x6a, 0x11, 0x37,
-	0x61, 0x4d, 0x31, 0x84, 0x22, 0xb2, 0x85, 0x2f, 0x17, 0x54, 0xe3, 0x7d, 0x89, 0x3d, 0x92, 0x48,
-	0xf6, 0x6e, 0xce, 0x66, 0x07, 0x5e, 0xba, 0xf0, 0xcf, 0xab, 0xcb, 0xaa, 0x2e, 0x7b, 0x92, 0xc1,
-	0xd8, 0xc9, 0x3e, 0x85, 0x16, 0xa2, 0x43, 0x03, 0xe7, 0x1b, 0x3c, 0xc7, 0xba, 0xd0, 0x56, 0xa3,
-	0x0e, 0x6a, 0xac, 0x0f, 0x1d, 0xf2, 0x27, 0xa2, 0xd5, 0x8d, 0x7f, 0xe9, 0x43, 0x77, 0xe4, 0xc7,
-	0x49, 0x94, 0xda, 0x59, 0xfd, 0x4a, 0x15, 0xaf, 0x9b, 0x54, 0xbc, 0x56, 0x17, 0xff, 0xf2, 0x33,
-	0xe8, 0xe2, 0xff, 0x75, 0x68, 0x58, 0x7e, 0xe2, 0xaa, 0x3b, 0xbe, 0xd2, 0xc3, 0x85, 0x2c, 0x6b,
-	0xe7, 0x44, 0x67, 0xb7, 0xa1, 0xad, 0x5e, 0x39, 0xa8, 0x7d, 0xec, 0xdc, 0x27, 0x12, 0x19, 0x0f,
-	0xdb, 0x06, 0xdd, 0x51, 0xcf, 0x2f, 0x54, 0xde, 0x51, 0x1a, 0x3a, 0x7b, 0x98, 0xc1, 0x73, 0x1e,
-	0xf6, 0x0a, 0x68, 0xd6, 0x74, 0x4a, 0x56, 0x4a, 0x15, 0xa2, 0x8c, 0x95, 0xaa, 0xe3, 0x1c, 0x69,
-	0xec, 0x8e, 0xda, 0x04, 0x3f, 0x0b, 0x5c, 0x9f, 0xe2, 0x49, 0x65, 0xcc, 0xec, 0xb2, 0x45, 0x6e,
-	0x86, 0xb4, 0x87, 0xdf, 0x81, 0x4e, 0x2c, 0x16, 0xae, 0xec, 0xd0, 0x59, 0xed, 0x90, 0xa5, 0xc2,
-	0x5c, 0x8f, 0xb3, 0xa4, 0xf8, 0x7d, 0xe8, 0xc6, 0x94, 0xa0, 0xc9, 0x2e, 0x90, 0xdd, 0x49, 0xe7,
-	0x5d, 0xf2, 0xec, 0x8d, 0x43, 0x5c, 0x64, 0x72, 0x77, 0xa0, 0xb3, 0xb0, 0xa2, 0xb9, 0xec, 0xd4,
-	0x5d, 0x9d, 0x27, 0x4b, 0x29, 0xb8, 0xbe, 0xc8, 0x92, 0x0b, 0x03, 0x1a, 0xc4, 0xdb, 0xcb, 0x2c,
-	0x3f, 0xe3, 0x95, 0xf2, 0x46, 0x1a, 0x7b, 0x0b, 0xda, 0xa1, 0xdc, 0x3b, 0xa9, 0x34, 0xd5, 0xdd,
-	0xd9, 0x28, 0xd8, 0xd4, 0xa6, 0xca, 0x33, 0x0e, 0xf6, 0xab, 0xb0, 0x26, 0xaf, 0xbf, 0x27, 0x6a,
-	0x9b, 0xa3, 0x8a, 0x55, 0xa5, 0x08, 0x5f, 0xd9, 0x05, 0x79, 0x3f, 0xa9, 0x6c, 0x8a, 0x3b, 0x2a,
-	0xa0, 0x53, 0x06, 0x46, 0xd5, 0xac, 0x8a, 0x7e, 0xf3, 0xbd, 0x8a, 0x77, 0x66, 0xf9, 0xb6, 0xf5,
-	0x01, 0xf4, 0x85, 0x0a, 0x43, 0x66, 0x6c, 0x5b, 0xfe, 0x70, 0x40, 0xdd, 0xae, 0x9e, 0x8d, 0x52,
-	0xe8, 0xf0, 0xbc, 0x27, 0xca, 0xc1, 0x77, 0x0b, 0x5a, 0xf2, 0xfe, 0x7f, 0xb8, 0x41, 0xbd, 0x4a,
-	0x6f, 0xc4, 0xe4, 0x4d, 0x3f, 0x57, 0x74, 0x76, 0x77, 0xe5, 0xb2, 0x7e, 0x2e, 0x96, 0x43, 0x46,
-	0x7d, 0x86, 0x17, 0xdd, 0xc0, 0x57, 0xae, 0xf1, 0x3f, 0x12, 0x4b, 0xfc, 0xbc, 0xa2, 0xe2, 0x30,
-	0xbc, 0xb4, 0xfa, 0x79, 0x79, 0xb9, 0x81, 0x77, 0xf2, 0x4a, 0x03, 0xbb, 0x57, 0xad, 0x80, 0x50,
-	0x59, 0x64, 0x78, 0x99, 0xba, 0x3e, 0x7f, 0x4e, 0x57, 0x59, 0x37, 0xe1, 0xeb, 0xe1, 0x4a, 0x21,
-	0xe5, 0x6d, 0xd0, 0x83, 0xc8, 0xc1, 0xe4, 0x76, 0x39, 0xbc, 0x42, 0x1e, 0xbf, 0xa1, 0xca, 0x9f,
-	0xf2, 0x9d, 0x0a, 0xa5, 0xb3, 0xed, 0x40, 0x02, 0xec, 0x36, 0xf4, 0xc2, 0x28, 0xf8, 0x4c, 0xd8,
-	0x89, 0x0c, 0xcb, 0x57, 0xcf, 0xbe, 0x6f, 0x51, 0x74, 0x8a, 0xd2, 0x45, 0xd8, 0xbd, 0x76, 0x51,
-	0xd8, 0x2d, 0xe2, 0xe4, 0x90, 0xf2, 0x00, 0x09, 0x94, 0xa2, 0xea, 0xf3, 0x84, 0xce, 0xa2, 0x2a,
-	0x66, 0x14, 0xf1, 0x7d, 0x37, 0x8a, 0x93, 0xe1, 0x75, 0xf9, 0xdc, 0x47, 0x81, 0xd8, 0xc3, 0x8d,
-	0x1f, 0x58, 0x71, 0x32, 0x7c, 0x21, 0x7b, 0x21, 0x84, 0x10, 0xca, 0x56, 0x66, 0x9c, 0x64, 0xd1,
-	0x2f, 0xae, 0xca, 0x36, 0xbf, 0x65, 0x53, 0xa9, 0x27, 0xd9, 0xff, 0x87, 0xb0, 0x2e, 0xfb, 0x14,
-	0xee, 0xf9, 0xd2, 0xaa, 0xbd, 0x56, 0x6e, 0x72, 0x78, 0x3f, 0xaa, 0x5c, 0xec, 0xe4, 0x03, 0x60,
-	0x68, 0x92, 0x03, 0xdc, 0x38, 0x77, 0x80, 0x3c, 0x88, 0xc9, 0x01, 0xf2, 0x9b, 0x88, 0x5b, 0xd0,
-	0x72, 0x64, 0x75, 0xfe, 0xe5, 0x33, 0xc1, 0x49, 0x55, 0x8f, 0xb9, 0xe2, 0x60, 0x6f, 0x42, 0x9b,
-	0xea, 0x79, 0x41, 0x38, 0xdc, 0x5c, 0x35, 0x56, 0x59, 0x87, 0xe3, 0x2d, 0x4f, 0xd6, 0xe3, 0xde,
-	0x82, 0x76, 0x96, 0x8a, 0xbe, 0xb2, 0xea, 0xb4, 0x2a, 0x25, 0xe5, 0x19, 0x07, 0xbb, 0x09, 0x4d,
-	0x4a, 0x91, 0x86, 0xc6, 0x6a, 0xd0, 0x93, 0x11, 0x5d, 0x52, 0x29, 0x28, 0xd1, 0xbe, 0x29, 0xbd,
-	0xec, 0xd5, 0x33, 0x41, 0x29, 0xdf, 0x54, 0x39, 0xc4, 0xc5, 0x06, 0xfb, 0xdb, 0x70, 0xbd, 0x5c,
-	0x65, 0xcb, 0x4a, 0x70, 0x2a, 0xa3, 0x78, 0x8d, 0x46, 0x79, 0xe5, 0x1c, 0x43, 0xae, 0x16, 0xeb,
-	0xf8, 0xb5, 0xf0, 0x82, 0x2a, 0xde, 0xfb, 0xf9, 0xc6, 0x88, 0x31, 0x67, 0x78, 0xf3, 0xcc, 0xb2,
-	0xf2, 0xad, 0x35, 0xdb, 0x2e, 0x69, 0x47, 0xfe, 0x11, 0xf4, 0x26, 0xe9, 0xd3, 0xa7, 0x4b, 0x75,
-	0xe6, 0x1b, 0xbe, 0x4e, 0xfd, 0x4a, 0xd9, 0x53, 0xa9, 0x4c, 0xc5, 0xbb, 0x93, 0x02, 0x30, 0xde,
-	0x87, 0xde, 0x2e, 0x3d, 0xea, 0x74, 0x63, 0x32, 0xfe, 0x9b, 0xd0, 0xc8, 0x4f, 0x13, 0xb9, 0x57,
-	0x11, 0xc7, 0x53, 0x31, 0xf2, 0x27, 0x01, 0x27, 0xb2, 0xf1, 0x33, 0x0d, 0x5a, 0xe3, 0x20, 0x8d,
-	0x6c, 0xf1, 0xe5, 0x35, 0xf4, 0x97, 0x00, 0x8a, 0x97, 0x10, 0xaa, 0x18, 0x26, 0xeb, 0x8a, 0x44,
-	0x2e, 0x1f, 0x54, 0x34, 0x4a, 0x98, 0xf2, 0x83, 0x4a, 0x5e, 0x58, 0x95, 0xaf, 0xcc, 0x24, 0x40,
-	0xcf, 0x3e, 0xd3, 0x78, 0xe6, 0x04, 0x4f, 0x7c, 0xd3, 0x95, 0xaf, 0xcc, 0x1a, 0x1c, 0x32, 0xd4,
-	0xc8, 0xa1, 0x87, 0x35, 0x19, 0x83, 0xe5, 0x38, 0x91, 0xca, 0xd2, 0x7a, 0x19, 0x72, 0xd7, 0x71,
-	0xa2, 0xfc, 0xf8, 0xd8, 0xbe, 0xe0, 0xf8, 0x78, 0x0b, 0xf2, 0xd2, 0xa6, 0xda, 0x16, 0x2f, 0x2e,
-	0x7d, 0xee, 0x40, 0x27, 0x7f, 0xe7, 0xab, 0xb6, 0xc4, 0xcb, 0xdb, 0xc5, 0xcb, 0xdf, 0xe3, 0xac,
-	0xc5, 0x0b, 0xb6, 0x73, 0x0e, 0xea, 0x61, 0x14, 0x9c, 0x88, 0x6f, 0x70, 0xd1, 0x7b, 0x84, 0xfd,
-	0xa8, 0xc8, 0xf7, 0x5b, 0xa0, 0x1f, 0x06, 0x0e, 0xe9, 0x09, 0x53, 0xfd, 0x85, 0x1d, 0xa6, 0x2a,
-	0x4b, 0xa1, 0xb6, 0x7a, 0xb6, 0x2b, 0x35, 0xa0, 0x9e, 0xed, 0x92, 0x7c, 0x34, 0x79, 0x1c, 0xc0,
-	0x36, 0xc6, 0xaa, 0xd0, 0x5a, 0x7a, 0x81, 0xe5, 0xa8, 0x47, 0x0b, 0x19, 0x68, 0xfc, 0x45, 0x0d,
-	0x36, 0x8e, 0xa2, 0xc0, 0x16, 0x71, 0xfc, 0x00, 0xc3, 0x9d, 0x45, 0x9b, 0x1c, 0x83, 0x06, 0x65,
-	0xf5, 0xf2, 0x29, 0x1f, 0xb5, 0x51, 0xe3, 0xf2, 0xe9, 0x6f, 0x9e, 0xdd, 0x69, 0x5c, 0x3e, 0x06,
-	0xa6, 0xe4, 0x2e, 0x27, 0x53, 0x47, 0xad, 0x44, 0xa6, 0xf3, 0xc0, 0x4d, 0x58, 0x2b, 0xde, 0xc3,
-	0xd0, 0x08, 0xea, 0x4d, 0x6c, 0x8e, 0xa5, 0x51, 0x5e, 0x86, 0x6e, 0x24, 0x2c, 0xdc, 0x04, 0x68,
-	0x98, 0x26, 0xf1, 0x80, 0x44, 0xe1, 0x38, 0xc6, 0x9f, 0xd6, 0xa1, 0xab, 0xd6, 0x4b, 0x12, 0x91,
-	0x5f, 0x5f, 0xcb, 0xbf, 0x7e, 0x00, 0x1a, 0xa6, 0xf0, 0x52, 0x1c, 0xd8, 0x64, 0xb7, 0x41, 0xf3,
-	0xdc, 0x85, 0x4a, 0xda, 0x5e, 0xa8, 0x64, 0x06, 0xd5, 0xaf, 0xe6, 0xc8, 0x87, 0xb9, 0x7e, 0xea,
-	0xbb, 0xa7, 0x26, 0xaa, 0x42, 0xad, 0x51, 0x47, 0x04, 0xea, 0x1b, 0x3f, 0xd2, 0xb2, 0xed, 0x20,
-	0xf5, 0x93, 0xcc, 0x48, 0xfb, 0xbc, 0xa3, 0x30, 0x23, 0x87, 0x9e, 0x77, 0xfa, 0x56, 0x18, 0xcf,
-	0x82, 0x44, 0x99, 0x67, 0x0e, 0xa3, 0x37, 0xc7, 0x22, 0x8e, 0xe5, 0x73, 0xa0, 0x49, 0xa0, 0x4c,
-	0xf4, 0x4a, 0x39, 0xc9, 0x22, 0x2a, 0xf9, 0x63, 0x37, 0x2e, 0x00, 0xf6, 0x36, 0x30, 0x4b, 0x79,
-	0xb3, 0xe9, 0x07, 0x8e, 0x28, 0x2e, 0x22, 0x9a, 0x7c, 0x90, 0x51, 0xd0, 0x44, 0xc8, 0x5c, 0xfe,
-	0xb3, 0x06, 0xdd, 0xd2, 0x50, 0xf4, 0x8a, 0x3b, 0x16, 0x51, 0x76, 0x3a, 0xc4, 0x36, 0xe2, 0x66,
-	0x81, 0x7a, 0x97, 0xd9, 0xe1, 0xd4, 0x46, 0x5c, 0x14, 0x78, 0x22, 0x33, 0x1b, 0x6c, 0xa3, 0xcf,
-	0xa9, 0x24, 0x55, 0xbe, 0x66, 0x53, 0x07, 0xe4, 0x5e, 0x81, 0x94, 0x1f, 0xed, 0x58, 0x89, 0x75,
-	0x62, 0xc5, 0xd9, 0xc9, 0x3d, 0x87, 0xd1, 0xee, 0x3e, 0x17, 0x11, 0xae, 0x45, 0xc9, 0x23, 0x03,
-	0x51, 0xcc, 0xe4, 0x26, 0x4f, 0x03, 0x5f, 0x90, 0x2c, 0x7a, 0x5c, 0x47, 0xc4, 0xa7, 0x81, 0x4f,
-	0xdd, 0x94, 0x50, 0xc9, 0x4b, 0x3b, 0x3c, 0x03, 0x31, 0xae, 0x3c, 0x4e, 0x05, 0xc6, 0x66, 0x59,
-	0x72, 0xe9, 0xf0, 0x36, 0xc1, 0x23, 0xc7, 0xf8, 0xeb, 0x26, 0xe8, 0x47, 0x4a, 0x98, 0x6c, 0x1f,
-	0xfa, 0xf9, 0x2b, 0xf2, 0xf3, 0xcf, 0x33, 0x47, 0xab, 0x0d, 0x3a, 0xcf, 0xf4, 0xc2, 0x12, 0xb4,
-	0xfa, 0x16, 0xbd, 0x7e, 0xe6, 0x2d, 0xfa, 0x8b, 0xa0, 0x3d, 0x8e, 0x96, 0xd5, 0xa2, 0xff, 0x91,
-	0x67, 0xf9, 0x1c, 0xd1, 0xec, 0x5d, 0xe8, 0xa2, 0x24, 0xcc, 0x98, 0x62, 0xaa, 0x3a, 0x0b, 0x94,
-	0x7f, 0x03, 0x20, 0x3c, 0x07, 0x64, 0x52, 0x71, 0x77, 0x1b, 0x74, 0x7b, 0xe6, 0x7a, 0x4e, 0x24,
-	0x7c, 0x75, 0x94, 0x65, 0x67, 0x97, 0xcc, 0x73, 0x1e, 0xf6, 0x13, 0x18, 0xb8, 0xc5, 0x19, 0x46,
-	0x5a, 0x46, 0x6b, 0xf5, 0x94, 0x5d, 0x3a, 0xe5, 0xf0, 0xf5, 0x12, 0x3b, 0x85, 0xe3, 0xe2, 0xe5,
-	0x56, 0xbb, 0xfc, 0x72, 0x4b, 0x3e, 0x73, 0xce, 0xcf, 0x0f, 0x94, 0xc4, 0x50, 0x3a, 0x20, 0x09,
-	0x14, 0x4a, 0x3a, 0x79, 0x76, 0x13, 0x58, 0x0e, 0x9e, 0x8e, 0xd0, 0x3a, 0xd5, 0x51, 0xa0, 0xb4,
-	0xec, 0x2c, 0x7a, 0x71, 0xa2, 0xd3, 0x6f, 0x0a, 0x69, 0x3c, 0x33, 0x65, 0xa8, 0x47, 0x57, 0xe8,
-	0xaa, 0x27, 0x92, 0x69, 0x3c, 0xdb, 0xc7, 0x60, 0x8f, 0x66, 0x7b, 0x13, 0xd6, 0xb2, 0x8f, 0x34,
-	0xa5, 0x25, 0xf4, 0xe4, 0xc3, 0xb1, 0x0c, 0xbb, 0x47, 0xf6, 0xf0, 0x21, 0x0c, 0xd2, 0xd4, 0x75,
-	0x62, 0x33, 0x09, 0xb2, 0x67, 0xde, 0xc3, 0x3e, 0x7d, 0x7f, 0x29, 0xb9, 0x7e, 0x94, 0xba, 0xce,
-	0x71, 0xa0, 0x1e, 0x7a, 0xf7, 0x89, 0x3f, 0x03, 0xe9, 0x87, 0x06, 0xba, 0x4b, 0xc5, 0x9e, 0x6b,
-	0xf2, 0xa1, 0x20, 0x21, 0x90, 0x88, 0xbb, 0xa0, 0x7a, 0x0e, 0x6e, 0xfb, 0x89, 0x7a, 0xba, 0x06,
-	0x0a, 0xb5, 0xe7, 0x27, 0xc6, 0x87, 0xd0, 0x2b, 0x9b, 0x0f, 0xeb, 0xa8, 0x87, 0xde, 0x83, 0xe7,
-	0x18, 0x40, 0xeb, 0x30, 0x88, 0x16, 0x96, 0x37, 0xa8, 0x61, 0x5b, 0x3e, 0x69, 0x1c, 0xd4, 0x59,
-	0x0f, 0xf4, 0x23, 0x2b, 0xb2, 0x3c, 0x4f, 0x78, 0x03, 0xcd, 0xf8, 0x00, 0xf4, 0xec, 0xd5, 0x3b,
-	0xdd, 0x5f, 0xa1, 0x7b, 0x53, 0xf4, 0x96, 0xee, 0xaa, 0x23, 0x82, 0x76, 0xb6, 0xec, 0x67, 0x8c,
-	0x7a, 0xf1, 0x33, 0x86, 0xf1, 0x1b, 0xd0, 0x2b, 0x7f, 0x5a, 0x76, 0x62, 0xad, 0x15, 0x27, 0xd6,
-	0x73, 0x7a, 0xd1, 0x65, 0x46, 0x14, 0x2c, 0xcc, 0xd2, 0x26, 0xa1, 0x23, 0x02, 0xa7, 0x31, 0xfe,
-	0xa1, 0x06, 0xfd, 0xca, 0xd6, 0xc4, 0x3e, 0x00, 0x2d, 0x59, 0x86, 0xca, 0x7f, 0xde, 0x2c, 0xe5,
-	0x8c, 0x65, 0xae, 0x2a, 0x44, 0x9e, 0x84, 0xbd, 0x70, 0x7e, 0xdb, 0x8a, 0x32, 0xcf, 0xa1, 0x76,
-	0xfe, 0xeb, 0x8a, 0x56, 0xfc, 0xba, 0x62, 0x7c, 0x02, 0x1b, 0x67, 0x46, 0x60, 0x2d, 0xa8, 0x8f,
-	0x0e, 0xa5, 0x24, 0xef, 0x8e, 0x8e, 0x0f, 0x76, 0x8f, 0x06, 0x35, 0x3c, 0xd0, 0x1f, 0x8c, 0x0e,
-	0xcd, 0x83, 0xdd, 0xdf, 0x1c, 0xd4, 0xd9, 0x3a, 0x74, 0xef, 0x8e, 0x0e, 0x77, 0xf9, 0x27, 0xe6,
-	0xfd, 0x47, 0xe3, 0x7b, 0x03, 0x0d, 0x0f, 0xfe, 0x47, 0xbb, 0xe3, 0xf1, 0xc0, 0xc1, 0xd6, 0x3e,
-	0x7f, 0x78, 0x34, 0x10, 0xb7, 0x7e, 0x07, 0x5a, 0xf2, 0x57, 0x1a, 0xb6, 0x01, 0xfd, 0x47, 0xfe,
-	0xdc, 0x0f, 0x9e, 0xf8, 0x12, 0x31, 0x78, 0x8e, 0x5d, 0x82, 0xf5, 0x4c, 0x7f, 0xea, 0x9f, 0x9d,
-	0x41, 0x8d, 0x0d, 0xa0, 0x47, 0x37, 0x6e, 0x19, 0xa6, 0xce, 0x5e, 0x84, 0xe1, 0x51, 0x24, 0x42,
-	0x2b, 0x12, 0xfb, 0x81, 0x2f, 0x0e, 0x83, 0xc4, 0x9d, 0x2c, 0x33, 0xaa, 0x76, 0xeb, 0x3e, 0xb4,
-	0xe4, 0x0f, 0x3d, 0xa5, 0x19, 0x24, 0x62, 0xf0, 0x1c, 0xae, 0xf1, 0x63, 0xcb, 0x4d, 0x5c, 0x7f,
-	0x7a, 0x28, 0x4e, 0x93, 0x41, 0x0d, 0x57, 0x86, 0x87, 0x81, 0x41, 0x9d, 0xad, 0x01, 0xa8, 0x41,
-	0xee, 0xf9, 0xce, 0x40, 0xbb, 0xbb, 0xf7, 0x77, 0x5f, 0xdc, 0xa8, 0xfd, 0xe3, 0x17, 0x37, 0x6a,
-	0xff, 0xf6, 0xc5, 0x8d, 0xe7, 0xfe, 0xec, 0xdf, 0x6f, 0xd4, 0x3e, 0x7d, 0xb7, 0xf4, 0x8f, 0xd2,
-	0xc2, 0x4a, 0x22, 0xf7, 0x54, 0x5e, 0x24, 0x65, 0x80, 0x2f, 0xee, 0x84, 0xf3, 0xe9, 0x9d, 0xf0,
-	0xe4, 0x4e, 0xa6, 0x96, 0x93, 0x16, 0xfd, 0x85, 0xf4, 0xde, 0x7f, 0x07, 0x00, 0x00, 0xff, 0xff,
-	0x75, 0xbd, 0x99, 0x1a, 0xf9, 0x34, 0x00, 0x00,
+	// 4478 bytes of a gzipped FileDescriptorProto
+	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xec, 0x3b, 0x4b, 0x73, 0x24, 0x47,
+	0x53, 0x9e, 0xe9, 0x79, 0xf4, 0xe4, 0xcc, 0x48, 0xa3, 0xda, 0xd7, 0x78, 0x6d, 0xaf, 0xe5, 0xb6,
+	0xd7, 0x96, 0xd7, 0x5e, 0xad, 0x2d, 0x63, 0xf8, 0x02, 0xf3, 0xe1, 0x4f, 0x2b, 0xed, 0x7e, 0x0c,
+	0x5e, 0x69, 0x45, 0x8d, 0x36, 0x8c, 0x7d, 0xa0, 0x69, 0x75, 0xd7, 0xcc, 0xb4, 0xa7, 0xa7, 0xbb,
+	0xb7, 0x1f, 0x5e, 0xcd, 0x9e, 0xb8, 0x10, 0x9c, 0x38, 0x7d, 0x11, 0x70, 0x20, 0x20, 0xb8, 0x70,
+	0xf8, 0x0e, 0x04, 0x04, 0xfc, 0x01, 0x8e, 0x9c, 0x80, 0x20, 0x38, 0x70, 0x83, 0x30, 0x7f, 0x81,
+	0xe0, 0xf6, 0x11, 0x44, 0x66, 0x55, 0xbf, 0x46, 0xd2, 0xfa, 0x81, 0x03, 0x3b, 0x02, 0xdf, 0xaa,
+	0x32, 0xb3, 0x1e, 0x9d, 0xaf, 0xca, 0xaa, 0xcc, 0x86, 0xb5, 0xd0, 0x0d, 0x85, 0xe7, 0xfa, 0x62,
+	0x3b, 0x8c, 0x82, 0x24, 0x60, 0x7a, 0xd6, 0xbf, 0x7e, 0x7b, 0xea, 0x26, 0xb3, 0xf4, 0x64, 0xdb,
+	0x0e, 0x16, 0x77, 0xa6, 0xc1, 0x34, 0xb8, 0x43, 0x04, 0x27, 0xe9, 0x84, 0x7a, 0xd4, 0xa1, 0x96,
+	0x1c, 0x78, 0x1d, 0x42, 0xcf, 0xf2, 0x55, 0x7b, 0x3d, 0x71, 0x17, 0x22, 0x4e, 0xac, 0x45, 0x98,
+	0x21, 0xbd, 0xc0, 0x9e, 0xcb, 0xb6, 0xf1, 0xd7, 0x75, 0x68, 0x1f, 0x88, 0x38, 0xb6, 0xa6, 0x82,
+	0x19, 0xa0, 0xc5, 0xae, 0x33, 0xac, 0x6d, 0xd6, 0xb6, 0xd6, 0x76, 0x06, 0xdb, 0xf9, 0x5e, 0xc6,
+	0x89, 0x95, 0xa4, 0x31, 0x47, 0x24, 0xd2, 0xd8, 0x0b, 0x67, 0x58, 0x5f, 0xa5, 0x39, 0x10, 0xc9,
+	0x2c, 0x70, 0x38, 0x22, 0xd9, 0x00, 0x34, 0x11, 0x45, 0x43, 0x6d, 0xb3, 0xb6, 0xd5, 0xe3, 0xd8,
+	0x64, 0x0c, 0x1a, 0x8e, 0x95, 0x58, 0xc3, 0x06, 0x81, 0xa8, 0xcd, 0x5e, 0x83, 0xb5, 0x30, 0x0a,
+	0x6c, 0xd3, 0xf5, 0x27, 0x81, 0x49, 0xd8, 0x26, 0x61, 0x7b, 0x08, 0x1d, 0xf9, 0x93, 0x60, 0x1f,
+	0xa9, 0x86, 0xd0, 0xb6, 0x7c, 0xcb, 0x5b, 0xc6, 0x62, 0xd8, 0x22, 0x74, 0xd6, 0x65, 0x6b, 0x50,
+	0x77, 0x9d, 0x61, 0x7b, 0xb3, 0xb6, 0xd5, 0xe0, 0x75, 0xd7, 0xc1, 0x35, 0xd2, 0xd4, 0x75, 0x86,
+	0xba, 0x5c, 0x03, 0xdb, 0xec, 0x05, 0xe8, 0x9c, 0x58, 0x89, 0x3d, 0x33, 0x6d, 0x3f, 0x19, 0x76,
+	0x88, 0x54, 0x27, 0xc0, 0x9e, 0x9f, 0xb0, 0xeb, 0xa0, 0xdb, 0x33, 0x61, 0xcf, 0xe3, 0x74, 0x31,
+	0x84, 0xcd, 0xda, 0x56, 0x9f, 0xe7, 0x7d, 0xc4, 0xc5, 0xe2, 0x71, 0x2a, 0x7c, 0x5b, 0x0c, 0xbb,
+	0x72, 0x5c, 0xd6, 0x37, 0x1e, 0x41, 0x67, 0x2f, 0xf0, 0x7d, 0x61, 0x27, 0x41, 0xc4, 0x5e, 0x86,
+	0x6e, 0xc6, 0x03, 0x53, 0xf1, 0xae, 0xc9, 0x21, 0x03, 0x8d, 0x1c, 0xf6, 0x06, 0xac, 0xdb, 0x19,
+	0xb5, 0xe9, 0xfa, 0x8e, 0x38, 0x25, 0xe6, 0x35, 0xf9, 0x5a, 0x0e, 0x1e, 0x21, 0xd4, 0xf8, 0x8b,
+	0x3a, 0xb4, 0xc7, 0xb3, 0x74, 0x32, 0xf1, 0x04, 0x7b, 0x0d, 0xfa, 0xaa, 0xb9, 0x17, 0x78, 0x23,
+	0xe7, 0x54, 0xcd, 0x5b, 0x05, 0xb2, 0x4d, 0xe8, 0x2a, 0xc0, 0xf1, 0x32, 0x14, 0x6a, 0xda, 0x32,
+	0xa8, 0x3a, 0xcf, 0x81, 0xeb, 0x93, 0x4c, 0x34, 0x5e, 0x05, 0xae, 0x50, 0x59, 0xa7, 0x24, 0xa6,
+	0x2a, 0x95, 0x45, 0xab, 0xed, 0x7a, 0xee, 0xe7, 0x82, 0x8b, 0xe9, 0x9e, 0x9f, 0x90, 0xb0, 0x9a,
+	0xbc, 0x0c, 0x62, 0x3b, 0x70, 0x25, 0x96, 0x43, 0xcc, 0xc8, 0xf2, 0xa7, 0x22, 0x36, 0x53, 0xd7,
+	0x4f, 0x7e, 0xf9, 0x97, 0x86, 0xad, 0x4d, 0x6d, 0xab, 0xc1, 0x2f, 0x29, 0x24, 0x27, 0xdc, 0x23,
+	0x42, 0xb1, 0x77, 0xe0, 0xf2, 0xca, 0x18, 0x39, 0xa4, 0xbd, 0xa9, 0x6d, 0x69, 0x9c, 0x55, 0x86,
+	0x8c, 0x10, 0x63, 0xfc, 0x5b, 0x1d, 0xf4, 0x7d, 0x37, 0x0e, 0x51, 0x8c, 0xec, 0x1a, 0xb4, 0x27,
+	0xa9, 0x6f, 0x17, 0xac, 0x6f, 0x61, 0x77, 0xe4, 0xb0, 0x5f, 0x83, 0x75, 0x2f, 0xb0, 0x2d, 0xcf,
+	0xcc, 0xb9, 0x3c, 0xac, 0x6f, 0x6a, 0x5b, 0xdd, 0x9d, 0x4b, 0x85, 0xce, 0xe6, 0x52, 0xe4, 0x6b,
+	0x44, 0x5b, 0x48, 0xf5, 0xc7, 0x30, 0x88, 0xc4, 0x22, 0x48, 0x44, 0x69, 0xb8, 0x46, 0xc3, 0x59,
+	0x31, 0xfc, 0xe3, 0xc8, 0x0a, 0x0f, 0x03, 0x47, 0xf0, 0x75, 0x49, 0x5b, 0x0c, 0x7f, 0xb7, 0xc4,
+	0x08, 0x31, 0x35, 0x5d, 0xe7, 0xd4, 0xa4, 0x05, 0x86, 0x8d, 0x4d, 0x6d, 0xab, 0x59, 0x7c, 0x95,
+	0x98, 0x8e, 0x9c, 0xd3, 0x07, 0x88, 0x61, 0xef, 0xc1, 0xd5, 0xd5, 0x21, 0x72, 0xd6, 0x61, 0x93,
+	0xc6, 0x5c, 0xaa, 0x8c, 0xe1, 0x84, 0x62, 0xaf, 0x40, 0x2f, 0x1b, 0x94, 0xa0, 0x06, 0xb4, 0xa4,
+	0x4c, 0xe2, 0x92, 0x06, 0x5c, 0x83, 0xb6, 0x1b, 0x9b, 0xb1, 0xeb, 0xcf, 0xc9, 0x54, 0x74, 0xde,
+	0x72, 0xe3, 0xb1, 0xeb, 0xcf, 0xd9, 0xf3, 0xa0, 0x47, 0xc2, 0x96, 0x18, 0x9d, 0x30, 0xed, 0x48,
+	0xd8, 0x88, 0x32, 0x5e, 0x85, 0xe6, 0x81, 0x88, 0xa6, 0x82, 0xac, 0xc0, 0xf5, 0xe7, 0x63, 0xdb,
+	0xf2, 0x89, 0xbd, 0x3a, 0xcf, 0xfb, 0xc6, 0xdf, 0xd6, 0xa0, 0x7f, 0x90, 0x7a, 0x89, 0xbb, 0x1b,
+	0x4d, 0x53, 0xb1, 0xf0, 0x13, 0x34, 0xc0, 0x7d, 0x37, 0x4e, 0x14, 0x25, 0xb5, 0xd9, 0x16, 0x74,
+	0x7e, 0x1a, 0x05, 0x69, 0x78, 0xef, 0x34, 0xcc, 0x04, 0x00, 0xdb, 0xe4, 0x9b, 0x10, 0xc2, 0x0b,
+	0x24, 0x7b, 0x1b, 0xba, 0x0f, 0x23, 0x47, 0x44, 0x77, 0x97, 0x44, 0xab, 0x9d, 0xa1, 0x2d, 0xa3,
+	0xd9, 0x8b, 0xd0, 0x19, 0x8b, 0xd0, 0x8a, 0x2c, 0x94, 0x0c, 0xaa, 0x6b, 0x87, 0x17, 0x00, 0x74,
+	0x1a, 0x44, 0x3c, 0x72, 0x94, 0x9a, 0x66, 0x5d, 0x63, 0x0a, 0x9d, 0xdd, 0xe9, 0x34, 0x12, 0x53,
+	0x2b, 0x21, 0x0f, 0x12, 0x84, 0xb4, 0x5d, 0x8d, 0xd7, 0x83, 0x90, 0xbc, 0x14, 0x7e, 0x40, 0x5d,
+	0x7e, 0x00, 0xb6, 0xd9, 0x0d, 0x68, 0x08, 0xb9, 0x9f, 0xda, 0xca, 0x7e, 0x08, 0xce, 0xae, 0x42,
+	0xcb, 0x0e, 0xfc, 0x89, 0x3b, 0x55, 0xbe, 0x4d, 0xf5, 0x8c, 0x3f, 0xd2, 0xa0, 0x49, 0x1f, 0x87,
+	0x3e, 0xc8, 0x17, 0xc2, 0x31, 0xc5, 0xe7, 0x96, 0x97, 0x71, 0x11, 0x01, 0xf7, 0x3e, 0xb7, 0x3c,
+	0xdc, 0xa9, 0x7b, 0x92, 0xda, 0x73, 0x21, 0x57, 0x6d, 0xf0, 0xac, 0x8b, 0x18, 0x5f, 0x61, 0x34,
+	0x89, 0x51, 0x5d, 0xb6, 0x09, 0x4d, 0x5c, 0x3a, 0x26, 0x6d, 0xaa, 0xee, 0x49, 0x22, 0x90, 0x02,
+	0xf5, 0x21, 0x26, 0xdd, 0xc9, 0x29, 0x50, 0x1f, 0xb8, 0x44, 0xb0, 0x37, 0xa0, 0x61, 0x4d, 0xa7,
+	0x31, 0x59, 0x66, 0xc5, 0x26, 0x72, 0xee, 0x70, 0x22, 0x60, 0xef, 0x43, 0x47, 0x4a, 0x19, 0xa9,
+	0xdb, 0x44, 0x7d, 0xad, 0xe4, 0xf5, 0xcb, 0x0a, 0xc0, 0x0b, 0x4a, 0x94, 0x8f, 0x1b, 0x2b, 0xff,
+	0xa1, 0xd4, 0xab, 0x00, 0x30, 0x03, 0x7a, 0x61, 0x24, 0x76, 0x3d, 0x2f, 0xb0, 0xc7, 0xee, 0x53,
+	0xa1, 0x3c, 0x73, 0x05, 0xc6, 0x5e, 0x87, 0xb5, 0x23, 0x2b, 0x4a, 0x5c, 0xcb, 0xe3, 0x22, 0x4e,
+	0xbd, 0x24, 0x26, 0x3f, 0xdc, 0xe3, 0x2b, 0x50, 0xb6, 0x0d, 0xac, 0x02, 0x39, 0xa6, 0x0f, 0x87,
+	0x4d, 0x6d, 0xab, 0xcf, 0xcf, 0xc1, 0x18, 0xff, 0x59, 0x87, 0xd6, 0xc8, 0x8f, 0x45, 0x44, 0x07,
+	0x80, 0x35, 0x99, 0x08, 0x3b, 0x11, 0xd2, 0x7b, 0x34, 0x78, 0xde, 0xc7, 0x0f, 0x38, 0x0e, 0x3e,
+	0x8e, 0xdc, 0x44, 0x8c, 0xdf, 0x53, 0x0a, 0x51, 0x00, 0xd8, 0x2d, 0xd8, 0xb0, 0x1c, 0xc7, 0xcc,
+	0xa8, 0xcd, 0x28, 0x78, 0x12, 0x93, 0x98, 0x74, 0xbe, 0x6e, 0x39, 0xce, 0xae, 0x82, 0xf3, 0xe0,
+	0x49, 0xcc, 0x5e, 0x01, 0x2d, 0x12, 0x13, 0x52, 0x8f, 0xee, 0xce, 0xba, 0x14, 0xc5, 0xc3, 0x93,
+	0xcf, 0x84, 0x9d, 0x70, 0x31, 0xe1, 0x88, 0x63, 0x97, 0xa1, 0x69, 0x25, 0x49, 0x24, 0xe5, 0xd5,
+	0xe1, 0xb2, 0xc3, 0xb6, 0xe1, 0x52, 0x88, 0xfb, 0x4f, 0xdc, 0xc0, 0x37, 0x13, 0xeb, 0xc4, 0xc3,
+	0x13, 0x26, 0x56, 0xce, 0x74, 0x23, 0x47, 0x1d, 0x23, 0x66, 0xe4, 0xc4, 0xe8, 0x7e, 0x57, 0xe9,
+	0x7d, 0x6b, 0x21, 0xa4, 0xd8, 0x3a, 0xfc, 0x52, 0x75, 0xc4, 0x21, 0xa2, 0xd8, 0xab, 0xd0, 0x2f,
+	0xc6, 0xb8, 0xce, 0x29, 0xc9, 0xaa, 0xc9, 0x7b, 0x39, 0x10, 0xcf, 0x99, 0x2b, 0xd0, 0x72, 0x63,
+	0x53, 0xf8, 0x0e, 0x09, 0x4a, 0xe7, 0x4d, 0x37, 0xbe, 0xe7, 0x3b, 0xec, 0x2d, 0xe8, 0xc8, 0x55,
+	0x1c, 0x31, 0xa1, 0x03, 0xb4, 0xbb, 0xb3, 0xa6, 0x34, 0x0d, 0xc1, 0xfb, 0x62, 0xc2, 0xf5, 0x44,
+	0xb5, 0x8c, 0x97, 0xa0, 0xb9, 0x1b, 0x45, 0xd6, 0x92, 0xbe, 0x15, 0x1b, 0xc3, 0x1a, 0xf9, 0x35,
+	0xd9, 0x31, 0x6c, 0xd0, 0x0e, 0xac, 0x90, 0xdd, 0x84, 0xfa, 0x22, 0x24, 0x4c, 0x77, 0xe7, 0x4a,
+	0x49, 0xcd, 0xac, 0x70, 0xfb, 0x20, 0xbc, 0xe7, 0x27, 0xd1, 0x92, 0xd7, 0x17, 0xe1, 0xf5, 0xf7,
+	0xa1, 0xad, 0xba, 0x18, 0x6b, 0xcc, 0xc5, 0x92, 0xc4, 0xd7, 0xe1, 0xd8, 0xc4, 0x05, 0x3e, 0xb7,
+	0xbc, 0x34, 0x3b, 0x0f, 0x65, 0xe7, 0x57, 0xeb, 0x3f, 0xaa, 0x19, 0xbf, 0xdf, 0x04, 0x7d, 0x5f,
+	0x78, 0x02, 0xbf, 0x0b, 0x8d, 0xff, 0x38, 0x56, 0x62, 0xaf, 0x1f, 0xc7, 0xa8, 0x93, 0x65, 0xb1,
+	0x29, 0x73, 0xac, 0xc0, 0x90, 0x46, 0x7a, 0x5e, 0x9a, 0x45, 0x28, 0x89, 0x57, 0x60, 0x68, 0xb7,
+	0xa3, 0xbb, 0xd2, 0x6e, 0x1b, 0x14, 0x54, 0x64, 0x5d, 0xc4, 0x1c, 0x2a, 0x4c, 0x53, 0x62, 0x54,
+	0x97, 0xbd, 0x08, 0x10, 0x05, 0x4f, 0x4c, 0xd7, 0x21, 0x11, 0x48, 0x2f, 0xae, 0x47, 0xc1, 0x93,
+	0x91, 0x83, 0xec, 0xbf, 0x40, 0x0f, 0xda, 0x5f, 0x5b, 0x0f, 0xf4, 0x8b, 0xf5, 0xe0, 0x57, 0x60,
+	0x58, 0xd2, 0x03, 0x8c, 0x47, 0x4c, 0xd7, 0x37, 0x29, 0x54, 0x22, 0xa1, 0x37, 0x79, 0x31, 0x27,
+	0x85, 0x2b, 0x23, 0xff, 0x2e, 0x1d, 0xc0, 0x4a, 0xbb, 0xe1, 0x19, 0xda, 0x7d, 0xae, 0xb1, 0x74,
+	0xcf, 0x37, 0x96, 0xbb, 0x00, 0x63, 0x31, 0x5d, 0x08, 0x3f, 0x39, 0xb0, 0xc2, 0x61, 0x8f, 0x14,
+	0xc1, 0x28, 0x14, 0x21, 0x93, 0xde, 0x76, 0x41, 0x24, 0xb5, 0xa2, 0x34, 0x0a, 0x4f, 0x45, 0xdb,
+	0xf2, 0xcd, 0x24, 0x4a, 0x7d, 0xdb, 0x4a, 0xc4, 0xb0, 0x4f, 0x4b, 0x75, 0x6d, 0xcb, 0x3f, 0x56,
+	0xa0, 0x92, 0x46, 0xaf, 0x95, 0x35, 0xfa, 0x75, 0x58, 0x0f, 0x23, 0x77, 0x61, 0x45, 0x4b, 0x73,
+	0x2e, 0x96, 0x24, 0x8c, 0x75, 0x19, 0x78, 0x29, 0xf0, 0x47, 0x62, 0x39, 0x72, 0x4e, 0xaf, 0xff,
+	0x18, 0xd6, 0x57, 0x36, 0xf0, 0xb5, 0xf4, 0xf0, 0xef, 0x6a, 0xd0, 0x39, 0x8a, 0x84, 0xf2, 0x42,
+	0x2f, 0x43, 0x37, 0xb6, 0x67, 0x62, 0x61, 0x91, 0x94, 0xd4, 0x0c, 0x20, 0x41, 0x28, 0x9c, 0xaa,
+	0x9d, 0xd5, 0x9f, 0x6d, 0x67, 0xb8, 0x0f, 0xdc, 0xb6, 0x46, 0xc6, 0x85, 0xcd, 0xc2, 0xb9, 0x34,
+	0xca, 0xce, 0x65, 0x13, 0x7a, 0x33, 0x2b, 0x36, 0xad, 0x34, 0x09, 0x4c, 0x3b, 0xf0, 0x48, 0x23,
+	0x75, 0x0e, 0x33, 0x2b, 0xde, 0x4d, 0x93, 0x60, 0x2f, 0xf0, 0xf0, 0xdc, 0x72, 0x63, 0x33, 0x0d,
+	0x1d, 0xe4, 0x61, 0x4b, 0x9e, 0x5b, 0x6e, 0xfc, 0x88, 0xfa, 0xc6, 0xbf, 0xd4, 0x01, 0x1e, 0x04,
+	0xf6, 0xfc, 0xd8, 0x8a, 0xa6, 0x22, 0xc1, 0x60, 0x22, 0x53, 0x4c, 0x65, 0x52, 0xed, 0x44, 0xaa,
+	0x23, 0xdb, 0x81, 0xab, 0x19, 0x4f, 0xed, 0xc0, 0xa3, 0xc0, 0x46, 0x6a, 0x96, 0xe2, 0x0b, 0x53,
+	0x58, 0x19, 0xd3, 0x92, 0x5a, 0xb1, 0x9d, 0x42, 0x0e, 0x38, 0x26, 0x59, 0x86, 0xd5, 0xf3, 0x97,
+	0x4e, 0xb2, 0x7e, 0x31, 0xf0, 0x78, 0x19, 0xb2, 0x77, 0xe0, 0x4a, 0x24, 0x26, 0x91, 0x88, 0x67,
+	0x66, 0x12, 0x97, 0x97, 0x69, 0xd0, 0x32, 0x1b, 0x0a, 0x79, 0x1c, 0xe7, 0xab, 0xbc, 0x03, 0x57,
+	0x26, 0xae, 0x97, 0x88, 0x68, 0x75, 0x63, 0x32, 0x66, 0xd8, 0x90, 0xc8, 0xf2, 0xbe, 0x5e, 0x02,
+	0xba, 0x3a, 0x49, 0xa3, 0x52, 0x3c, 0xe9, 0x78, 0xc4, 0x86, 0x13, 0x4f, 0xe0, 0x99, 0xb1, 0x37,
+	0xc3, 0x48, 0x75, 0x5f, 0x4c, 0x54, 0xb4, 0x55, 0x00, 0x98, 0x01, 0x8d, 0x83, 0xc0, 0x91, 0xa7,
+	0xe1, 0xda, 0xce, 0xda, 0x36, 0x5d, 0xc2, 0x90, 0x87, 0x08, 0xe5, 0x84, 0x33, 0x0e, 0xa1, 0x85,
+	0x90, 0x87, 0x21, 0xdb, 0x86, 0x76, 0x42, 0xbc, 0x8d, 0x95, 0x3b, 0xbc, 0x5c, 0x58, 0x41, 0xc1,
+	0x78, 0x9e, 0x11, 0xa1, 0x94, 0x4f, 0x70, 0x46, 0x75, 0x56, 0xc9, 0x8e, 0xc1, 0x61, 0x3d, 0x57,
+	0xb4, 0x47, 0xbe, 0xfb, 0x38, 0x15, 0xec, 0x43, 0xd8, 0x08, 0x23, 0x61, 0xba, 0x04, 0x33, 0xd3,
+	0xb9, 0x69, 0x27, 0xf2, 0x7a, 0x41, 0x4b, 0x20, 0x77, 0x8b, 0x11, 0xf3, 0xbd, 0xe4, 0x94, 0xaf,
+	0x85, 0x95, 0xbe, 0xf1, 0x29, 0x5c, 0xcb, 0x29, 0xc6, 0xc2, 0x0e, 0x7c, 0xc7, 0x8a, 0x96, 0xe4,
+	0x13, 0x56, 0xe6, 0x8e, 0xbf, 0xce, 0xdc, 0x63, 0x9a, 0xfb, 0xaf, 0xea, 0xb0, 0xf6, 0xd0, 0xdf,
+	0x4f, 0x43, 0xcf, 0x45, 0x3b, 0xfd, 0x48, 0x2c, 0xab, 0xda, 0x5f, 0xfb, 0x12, 0xed, 0xdf, 0x82,
+	0x41, 0xe0, 0x9b, 0x4e, 0x36, 0x9e, 0x2c, 0xb8, 0x4e, 0xa6, 0xb0, 0x16, 0x14, 0xd3, 0xa2, 0x53,
+	0xfd, 0x04, 0x36, 0x2a, 0x94, 0xa2, 0x08, 0x3a, 0x6f, 0x17, 0x9c, 0xae, 0xee, 0xa5, 0xdc, 0xc5,
+	0x70, 0x4b, 0xba, 0x9e, 0xf5, 0xa0, 0x0a, 0x55, 0x86, 0xe3, 0x4e, 0xfd, 0x20, 0x12, 0xa4, 0x7d,
+	0x64, 0x38, 0x23, 0xea, 0x5f, 0x3f, 0x84, 0xcb, 0xe7, 0xcd, 0x72, 0x8e, 0xff, 0xd8, 0x2c, 0xfb,
+	0x8f, 0x95, 0x30, 0xaf, 0xf0, 0x25, 0x3f, 0xaf, 0x41, 0xf7, 0x7e, 0xfa, 0xf4, 0xe9, 0xf2, 0x3e,
+	0x69, 0x2b, 0xeb, 0x41, 0xed, 0x90, 0x66, 0xa9, 0xf3, 0xda, 0x21, 0x46, 0xa7, 0x47, 0x73, 0x74,
+	0x22, 0x34, 0x49, 0x87, 0xab, 0x1e, 0xce, 0x7d, 0x34, 0x3f, 0x3e, 0xd7, 0xac, 0x24, 0x82, 0x71,
+	0x78, 0x3e, 0x4a, 0xfd, 0xc4, 0x5d, 0x08, 0x53, 0x19, 0xc9, 0x49, 0xea, 0x7a, 0x8e, 0xe9, 0x61,
+	0x80, 0xdc, 0xc8, 0xe2, 0x40, 0x1c, 0xc5, 0x25, 0x99, 0x5c, 0x7f, 0x1c, 0x0a, 0x9b, 0x5f, 0x8d,
+	0xca, 0xa0, 0xbb, 0x38, 0xee, 0x81, 0x1b, 0x27, 0xc6, 0x1f, 0x6b, 0xd0, 0xf8, 0xcd, 0xc0, 0xf5,
+	0xcb, 0x51, 0x6f, 0xed, 0xc2, 0xa8, 0xb7, 0x5e, 0x8d, 0x7a, 0xe9, 0xbe, 0xe2, 0xc9, 0xf5, 0xa5,
+	0x77, 0x6b, 0x47, 0xc2, 0xc3, 0x79, 0x11, 0x85, 0x16, 0x9c, 0x6f, 0xad, 0xc9, 0xdb, 0x76, 0x20,
+	0x51, 0x59, 0xf8, 0xde, 0xbc, 0x20, 0x7c, 0xcf, 0x23, 0xe5, 0xd6, 0xc5, 0x91, 0x72, 0xc7, 0x13,
+	0x93, 0x04, 0x2f, 0x82, 0x8e, 0x0a, 0x80, 0xcb, 0xd3, 0xe8, 0x88, 0xdc, 0x0b, 0x7c, 0x87, 0xbd,
+	0x09, 0x10, 0xb9, 0xd3, 0x99, 0xa2, 0xd4, 0xcf, 0xde, 0x75, 0x08, 0x4b, 0xa4, 0xcf, 0x64, 0x6e,
+	0xe7, 0x1b, 0x31, 0x17, 0x63, 0x88, 0x99, 0x15, 0xcf, 0xcc, 0xc0, 0x37, 0xc3, 0x39, 0x9d, 0xc7,
+	0x3a, 0xd7, 0x11, 0xf2, 0xd0, 0x3f, 0x9a, 0xa3, 0xe7, 0xc2, 0x6b, 0xa0, 0x0a, 0xc8, 0xbb, 0x2b,
+	0x01, 0xb9, 0xf1, 0xf3, 0x3a, 0xe8, 0xbb, 0x7e, 0xe2, 0x7e, 0x63, 0xe9, 0x5c, 0x85, 0x56, 0x44,
+	0x41, 0xb6, 0x92, 0x8d, 0xea, 0xe5, 0xfc, 0x6f, 0x7c, 0x19, 0xff, 0x9b, 0x5f, 0x89, 0xff, 0xad,
+	0xaf, 0xcc, 0xff, 0xf6, 0xb3, 0xf8, 0x5f, 0xe5, 0x95, 0xfe, 0x4c, 0x5e, 0x75, 0x56, 0x79, 0xf5,
+	0x27, 0x1a, 0xe8, 0x0f, 0xc4, 0x24, 0xf9, 0x41, 0x93, 0xbf, 0x8f, 0x9a, 0xfc, 0xcf, 0x1a, 0x74,
+	0x38, 0x6e, 0xef, 0x7b, 0x26, 0x9e, 0x37, 0x01, 0x88, 0xf9, 0x17, 0xc9, 0x88, 0x44, 0x43, 0x37,
+	0x54, 0xf6, 0x16, 0x74, 0x25, 0xfb, 0x25, 0x6d, 0xfb, 0x0c, 0xad, 0x94, 0xce, 0xf1, 0x59, 0xa1,
+	0xea, 0x5f, 0x59, 0xa8, 0x9d, 0x6f, 0x2c, 0x54, 0xf8, 0x36, 0x84, 0xda, 0x7d, 0xa6, 0x50, 0x7b,
+	0xab, 0x42, 0xfd, 0x43, 0x0d, 0xfa, 0x24, 0xd4, 0xb1, 0x58, 0xfc, 0xdf, 0xfb, 0xa8, 0x15, 0x79,
+	0x34, 0xbf, 0xba, 0x3c, 0xbe, 0x25, 0x77, 0xf5, 0x4c, 0x79, 0xe8, 0xdf, 0x86, 0x3c, 0x3a, 0xcf,
+	0x94, 0x07, 0x5c, 0x28, 0x8f, 0xef, 0xe4, 0xcc, 0xf8, 0x41, 0x1e, 0xab, 0xf2, 0xf8, 0x45, 0x1d,
+	0xf4, 0xef, 0xc4, 0x34, 0xbe, 0x9b, 0xe3, 0xfb, 0x7b, 0xc7, 0xff, 0x3f, 0xd5, 0x00, 0xc6, 0xae,
+	0x3f, 0xf5, 0xc4, 0x0f, 0x41, 0xc1, 0xf7, 0x31, 0x28, 0xf8, 0x87, 0x3a, 0xe8, 0x07, 0x56, 0x34,
+	0xff, 0x7f, 0x62, 0x1f, 0xaf, 0x42, 0x3b, 0xf0, 0xcb, 0xd6, 0x50, 0xa6, 0x6b, 0x05, 0xfe, 0xff,
+	0x5e, 0xe1, 0x7f, 0xaf, 0x06, 0xed, 0xa3, 0x28, 0x70, 0x52, 0xbb, 0xaa, 0xb9, 0xb5, 0x8b, 0x35,
+	0xb7, 0x5e, 0xd5, 0xdc, 0x9c, 0x33, 0xda, 0x45, 0x9c, 0xa9, 0x6e, 0xa1, 0xb1, 0xba, 0x85, 0x9f,
+	0xd5, 0xa0, 0x4f, 0x2f, 0x00, 0xf7, 0x53, 0xdf, 0xa6, 0x17, 0xdd, 0xfc, 0xa1, 0xab, 0x56, 0x7d,
+	0xe8, 0x6a, 0x44, 0x22, 0x89, 0x55, 0xf2, 0xa9, 0x27, 0xd7, 0xd9, 0x0b, 0xbc, 0x7d, 0x31, 0xe1,
+	0x84, 0x41, 0x21, 0x5a, 0xd1, 0x34, 0x3e, 0x27, 0xe5, 0x44, 0x70, 0x14, 0x7e, 0x68, 0x45, 0xd6,
+	0x22, 0xce, 0x52, 0x3c, 0xb2, 0xc7, 0x18, 0x34, 0xe8, 0xc5, 0xae, 0x49, 0x57, 0x6b, 0x6a, 0x1b,
+	0x7f, 0x50, 0x87, 0xce, 0x6f, 0x58, 0xf1, 0x8c, 0x14, 0xb7, 0x48, 0xfd, 0xa0, 0x8e, 0x94, 0x53,
+	0x3f, 0xea, 0x99, 0x80, 0x90, 0xc8, 0x73, 0xf5, 0x6a, 0x43, 0x48, 0x1c, 0x5e, 0x56, 0x52, 0xed,
+	0x42, 0x25, 0x6d, 0x9c, 0xc9, 0x0b, 0x7d, 0x89, 0xb2, 0x6d, 0x42, 0x13, 0xb5, 0x27, 0x3e, 0x47,
+	0xd1, 0x24, 0x62, 0x45, 0x2b, 0xda, 0x2b, 0x5a, 0x71, 0x0b, 0x36, 0x68, 0xcb, 0x0b, 0x11, 0x4d,
+	0x85, 0xa3, 0x9e, 0x87, 0xe5, 0xf5, 0x69, 0x1d, 0x11, 0x94, 0x35, 0x74, 0xe8, 0x61, 0xd8, 0xd8,
+	0x85, 0x2b, 0xf7, 0x4e, 0x13, 0x11, 0xf9, 0x96, 0x77, 0x68, 0x2d, 0xc4, 0xce, 0x5e, 0xe0, 0xc9,
+	0x47, 0xa2, 0x8c, 0x6d, 0xb5, 0x82, 0x6d, 0x28, 0xba, 0x72, 0x6a, 0x5c, 0x76, 0x8c, 0x9b, 0xd0,
+	0x9d, 0xb8, 0x9e, 0x30, 0x83, 0xc9, 0x24, 0x96, 0x46, 0x28, 0x5b, 0x24, 0x60, 0x8d, 0xab, 0x9e,
+	0xf1, 0xdf, 0x75, 0xe8, 0x65, 0x4b, 0x8d, 0x6d, 0xeb, 0x22, 0x45, 0x78, 0x01, 0x3a, 0x34, 0x5b,
+	0xec, 0x3e, 0x15, 0xa4, 0x0d, 0x1a, 0xd7, 0x11, 0x40, 0xd9, 0xa6, 0x5d, 0xd8, 0x28, 0x2d, 0x65,
+	0x26, 0x41, 0x62, 0x79, 0x4a, 0x21, 0x4a, 0x79, 0x88, 0x12, 0x09, 0x5f, 0xc7, 0xce, 0x43, 0x6a,
+	0x1f, 0x23, 0x35, 0x2a, 0x9a, 0x1d, 0x78, 0x59, 0x56, 0x6e, 0x45, 0xd1, 0x10, 0xc3, 0x7e, 0x0a,
+	0xeb, 0xf8, 0xb5, 0x3b, 0xf2, 0xbd, 0x91, 0xbe, 0x57, 0x8a, 0xea, 0xe5, 0x62, 0x89, 0x73, 0x79,
+	0xc6, 0xfb, 0x7e, 0x85, 0x85, 0x2f, 0x01, 0xd8, 0x91, 0xb0, 0x12, 0x61, 0xc6, 0x8f, 0x3d, 0x7a,
+	0x87, 0xec, 0xf0, 0x8e, 0x84, 0x8c, 0x1f, 0x7b, 0xf9, 0x97, 0x92, 0xdd, 0xc9, 0xe4, 0x0f, 0x7d,
+	0x29, 0x19, 0xde, 0x6d, 0xe8, 0x06, 0x91, 0x3b, 0x75, 0x7d, 0x93, 0x76, 0xab, 0x9f, 0xb3, 0x5b,
+	0x90, 0x04, 0x7b, 0xb8, 0x67, 0x03, 0x5a, 0xd2, 0x87, 0x93, 0x8b, 0x58, 0x71, 0x25, 0x12, 0x63,
+	0xd8, 0x00, 0xe3, 0x24, 0x12, 0xd6, 0x82, 0xb8, 0xff, 0x06, 0xb4, 0x93, 0x13, 0xef, 0x19, 0xcf,
+	0x75, 0xad, 0xe4, 0x04, 0x97, 0x29, 0xc9, 0xb3, 0x4e, 0x29, 0x58, 0xd5, 0x43, 0xf1, 0x79, 0xee,
+	0xc2, 0x4d, 0x54, 0xb1, 0x82, 0xec, 0x18, 0xbf, 0xa8, 0x01, 0x8c, 0xad, 0x45, 0x28, 0x0d, 0x9e,
+	0xfd, 0x04, 0xba, 0x31, 0xf5, 0x64, 0xe6, 0x5b, 0xd6, 0xac, 0x94, 0xf8, 0x58, 0x90, 0xaa, 0xa6,
+	0x8c, 0x0c, 0xe3, 0xbc, 0x4d, 0xef, 0xee, 0x72, 0x86, 0x28, 0xcb, 0xf7, 0x34, 0x33, 0x02, 0xca,
+	0x45, 0xdc, 0x84, 0x35, 0x45, 0x10, 0x8a, 0xc8, 0x16, 0xbe, 0xdc, 0x50, 0x8d, 0xf7, 0x25, 0xf4,
+	0x48, 0x02, 0xd9, 0xbb, 0x39, 0x99, 0x1d, 0x78, 0xe9, 0xc2, 0x3f, 0x2f, 0x2f, 0xab, 0x86, 0xec,
+	0x49, 0x02, 0x63, 0x27, 0xfb, 0x14, 0xda, 0x88, 0x0e, 0x0d, 0x5c, 0x6f, 0xf0, 0x1c, 0xeb, 0x42,
+	0x5b, 0xcd, 0x3a, 0xa8, 0xb1, 0x3e, 0x74, 0xc8, 0x9e, 0x08, 0x57, 0x37, 0xfe, 0xb5, 0x0f, 0xdd,
+	0x91, 0x1f, 0x27, 0x51, 0x6a, 0x67, 0xf9, 0x2b, 0x95, 0xbc, 0x6e, 0x52, 0xf2, 0x5a, 0x3d, 0xfc,
+	0xcb, 0xcf, 0xa0, 0x87, 0xff, 0xd7, 0xa1, 0x61, 0xf9, 0x89, 0xab, 0xde, 0xf8, 0x4a, 0x85, 0x0b,
+	0x59, 0xd4, 0xce, 0x09, 0xcf, 0x6e, 0x43, 0x5b, 0x55, 0x39, 0xa8, 0x73, 0xec, 0xdc, 0x12, 0x89,
+	0x8c, 0x86, 0x6d, 0x83, 0xee, 0xa8, 0xf2, 0x0b, 0x15, 0x77, 0x94, 0xa6, 0xce, 0x0a, 0x33, 0x78,
+	0x4e, 0xc3, 0x5e, 0x01, 0xcd, 0x9a, 0x4e, 0x49, 0x4b, 0x29, 0x43, 0x94, 0x91, 0x52, 0x76, 0x9c,
+	0x23, 0x8e, 0xdd, 0x51, 0x87, 0xe0, 0x67, 0x81, 0xeb, 0x93, 0x3f, 0xa9, 0xcc, 0x99, 0x3d, 0xb6,
+	0xc8, 0xc3, 0x90, 0xce, 0xf0, 0x3b, 0xd0, 0x89, 0xc5, 0xc2, 0x95, 0x03, 0x3a, 0xab, 0x03, 0xb2,
+	0x50, 0x98, 0xeb, 0x71, 0x16, 0x14, 0xbf, 0x0f, 0xdd, 0x98, 0x02, 0x34, 0x39, 0x04, 0xb2, 0x37,
+	0xe9, 0x7c, 0x48, 0x1e, 0xbd, 0x71, 0x88, 0x8b, 0x48, 0xee, 0x0e, 0x74, 0x16, 0x56, 0x34, 0x97,
+	0x83, 0xba, 0xab, 0xeb, 0x64, 0x21, 0x05, 0xd7, 0x17, 0x59, 0x70, 0x61, 0x40, 0x83, 0x68, 0x7b,
+	0x99, 0xe6, 0x67, 0xb4, 0x92, 0xdf, 0x88, 0x63, 0x6f, 0x41, 0x3b, 0x94, 0x67, 0x27, 0xa5, 0xa6,
+	0xba, 0x3b, 0x1b, 0x05, 0x99, 0x3a, 0x54, 0x79, 0x46, 0xc1, 0x7e, 0x1d, 0xd6, 0xe4, 0xf3, 0xf7,
+	0x44, 0x1d, 0x73, 0x94, 0xb1, 0xaa, 0x24, 0xe1, 0x2b, 0xa7, 0x20, 0xef, 0x27, 0x95, 0x43, 0x71,
+	0x47, 0x39, 0x74, 0x8a, 0xc0, 0x28, 0x9b, 0x55, 0x91, 0x6f, 0x7e, 0x56, 0xf1, 0xce, 0x2c, 0x3f,
+	0xb6, 0x3e, 0x80, 0xbe, 0x50, 0x6e, 0xc8, 0x8c, 0x6d, 0xcb, 0x1f, 0x0e, 0x68, 0xd8, 0xd5, 0xb3,
+	0x5e, 0x0a, 0x0d, 0x9e, 0xf7, 0x44, 0xd9, 0xf9, 0x6e, 0x41, 0x4b, 0xbe, 0xff, 0x0f, 0x37, 0x68,
+	0x54, 0xa9, 0x46, 0x4c, 0xbe, 0xf4, 0x73, 0x85, 0x67, 0x77, 0x57, 0x1e, 0xeb, 0xe7, 0x62, 0x39,
+	0x64, 0x34, 0x66, 0x78, 0xd1, 0x0b, 0x7c, 0xe5, 0x19, 0xff, 0x23, 0xb1, 0xc4, 0xcf, 0x2b, 0x32,
+	0x0e, 0xc3, 0x4b, 0xab, 0x9f, 0x97, 0xa7, 0x1b, 0x78, 0x27, 0xcf, 0x34, 0xb0, 0x7b, 0xd5, 0x0c,
+	0x08, 0xa5, 0x45, 0x86, 0x97, 0x69, 0xe8, 0xf3, 0xe7, 0x0c, 0x95, 0x79, 0x13, 0xbe, 0x1e, 0xae,
+	0x24, 0x52, 0xde, 0x06, 0x3d, 0x88, 0x1c, 0x0c, 0x6e, 0x97, 0xc3, 0x2b, 0x64, 0xf1, 0x1b, 0x2a,
+	0xfd, 0x29, 0xeb, 0x54, 0x28, 0x9c, 0x6d, 0x07, 0xb2, 0xc3, 0x6e, 0x43, 0x2f, 0x8c, 0x82, 0xcf,
+	0x84, 0x9d, 0x48, 0xb7, 0x7c, 0xf5, 0x6c, 0x7d, 0x8b, 0xc2, 0x93, 0x97, 0x2e, 0xdc, 0xee, 0xb5,
+	0x8b, 0xdc, 0x6e, 0xe1, 0x27, 0x87, 0x14, 0x07, 0xc8, 0x4e, 0xc9, 0xab, 0x3e, 0x4f, 0xe0, 0xcc,
+	0xab, 0x62, 0x44, 0x11, 0xdf, 0x77, 0xa3, 0x38, 0x19, 0x5e, 0x97, 0xe5, 0x3e, 0xaa, 0x8b, 0x23,
+	0xdc, 0xf8, 0x81, 0x15, 0x27, 0xc3, 0x17, 0xb2, 0x0a, 0x21, 0xec, 0x21, 0x6f, 0x65, 0xc4, 0x49,
+	0x1a, 0xfd, 0xe2, 0x2a, 0x6f, 0xf3, 0x57, 0x36, 0x15, 0x7a, 0x92, 0xfe, 0x7f, 0x08, 0xeb, 0x72,
+	0x4c, 0x61, 0x9e, 0x2f, 0xad, 0xea, 0x6b, 0xe5, 0x25, 0x87, 0xf7, 0xa3, 0xca, 0xc3, 0x4e, 0x3e,
+	0x01, 0xba, 0x26, 0x39, 0xc1, 0x8d, 0x73, 0x27, 0xc8, 0x9d, 0x98, 0x9c, 0x20, 0x7f, 0x89, 0xb8,
+	0x05, 0x2d, 0x47, 0x66, 0xe7, 0x5f, 0x3e, 0xe3, 0x9c, 0x54, 0xf6, 0x98, 0x2b, 0x0a, 0xf6, 0x26,
+	0xb4, 0x29, 0x9f, 0x17, 0x84, 0xc3, 0xcd, 0x55, 0x65, 0x95, 0x79, 0x38, 0xde, 0xf2, 0x64, 0x3e,
+	0xee, 0x2d, 0x68, 0x67, 0xa1, 0xe8, 0x2b, 0xab, 0x46, 0xab, 0x42, 0x52, 0x9e, 0x51, 0xb0, 0x9b,
+	0xd0, 0xa4, 0x10, 0x69, 0x68, 0xac, 0x3a, 0x3d, 0xe9, 0xd1, 0x25, 0x96, 0x9c, 0x12, 0x9d, 0x9b,
+	0xd2, 0xca, 0x5e, 0x3d, 0xe3, 0x94, 0xf2, 0x43, 0x95, 0x43, 0x5c, 0x1c, 0xb0, 0xbf, 0x03, 0xd7,
+	0xcb, 0x59, 0xb6, 0x2c, 0x05, 0xa7, 0x22, 0x8a, 0xd7, 0x68, 0x96, 0x57, 0xce, 0x51, 0xe4, 0x6a,
+	0xb2, 0x8e, 0x5f, 0x0b, 0x2f, 0xc8, 0xe2, 0xbd, 0x9f, 0x1f, 0x8c, 0xe8, 0x73, 0x86, 0x37, 0xcf,
+	0x6c, 0x2b, 0x3f, 0x5a, 0xb3, 0xe3, 0x92, 0x4e, 0xe4, 0x1f, 0x41, 0x6f, 0x92, 0x3e, 0x7d, 0xba,
+	0x54, 0x77, 0xbe, 0xe1, 0xeb, 0x34, 0xae, 0x14, 0x3d, 0x95, 0xd2, 0x54, 0xbc, 0x3b, 0x29, 0x3a,
+	0xc6, 0xfb, 0xd0, 0xdb, 0xa5, 0xa2, 0x4e, 0x37, 0x26, 0xe5, 0xbf, 0x09, 0x8d, 0xfc, 0x36, 0x91,
+	0x5b, 0x15, 0x51, 0x3c, 0x15, 0x23, 0x7f, 0x12, 0x70, 0x42, 0x1b, 0x3f, 0xd3, 0xa0, 0x35, 0x0e,
+	0xd2, 0xc8, 0x16, 0x5f, 0x9e, 0x43, 0x7f, 0x09, 0xa0, 0xa8, 0x84, 0x50, 0xc9, 0x30, 0x99, 0x57,
+	0x24, 0x74, 0xf9, 0xa2, 0xa2, 0x51, 0xc0, 0x94, 0x5f, 0x54, 0xf2, 0xc4, 0xaa, 0xac, 0x32, 0x93,
+	0x1d, 0x2a, 0xfb, 0x4c, 0xe3, 0x99, 0x13, 0x3c, 0xf1, 0x4d, 0x57, 0x56, 0x99, 0x35, 0x38, 0x64,
+	0xa0, 0x91, 0x43, 0x85, 0x35, 0x19, 0x81, 0xe5, 0x38, 0x91, 0x8a, 0xd2, 0x7a, 0x19, 0x70, 0xd7,
+	0x71, 0xa2, 0xfc, 0xfa, 0xd8, 0xbe, 0xe0, 0xfa, 0x78, 0x0b, 0xf2, 0xd4, 0xa6, 0x3a, 0x16, 0x2f,
+	0x4e, 0x7d, 0xee, 0x40, 0x27, 0xaf, 0xf3, 0x55, 0x47, 0xe2, 0xe5, 0xed, 0xa2, 0xf2, 0xf7, 0x38,
+	0x6b, 0xf1, 0x82, 0xec, 0x9c, 0x8b, 0x7a, 0x18, 0x05, 0x27, 0xe2, 0x1b, 0x3c, 0xf4, 0x1e, 0xe1,
+	0x38, 0x4a, 0xf2, 0x85, 0xa0, 0x1f, 0x06, 0x0e, 0xc9, 0x09, 0x43, 0xfd, 0x85, 0x1d, 0xa6, 0x2a,
+	0x4a, 0xa1, 0xb6, 0x2a, 0xdb, 0x95, 0x12, 0x50, 0x65, 0xbb, 0xc4, 0x1f, 0x4d, 0x5e, 0x07, 0xb0,
+	0x8d, 0xbe, 0x2a, 0xb4, 0x96, 0x5e, 0x60, 0x39, 0x8a, 0xeb, 0x59, 0x17, 0xa9, 0x29, 0xde, 0x93,
+	0x05, 0x34, 0xd4, 0x36, 0xfe, 0xb2, 0x06, 0x1b, 0x47, 0x51, 0x60, 0x8b, 0x38, 0x7e, 0x80, 0x2e,
+	0xd0, 0xa2, 0x83, 0x8f, 0x41, 0x83, 0x22, 0x7d, 0x59, 0xde, 0x47, 0x6d, 0xd4, 0x02, 0x59, 0x0e,
+	0x9c, 0x47, 0x7c, 0x1a, 0x97, 0x05, 0xc2, 0x14, 0xf0, 0xe5, 0x68, 0x1a, 0xa8, 0x95, 0xd0, 0x74,
+	0x47, 0xb8, 0x09, 0x6b, 0x45, 0x8d, 0x0c, 0xcd, 0xa0, 0xea, 0x64, 0x73, 0x28, 0xcd, 0xf2, 0x32,
+	0x74, 0x23, 0x61, 0xe1, 0xc1, 0x40, 0xd3, 0x34, 0x89, 0x06, 0x24, 0x08, 0xe7, 0x31, 0xfe, 0xac,
+	0x0e, 0x5d, 0xb5, 0x5f, 0xe2, 0x92, 0xe4, 0x48, 0x2d, 0xe7, 0xc8, 0x00, 0x34, 0x0c, 0xeb, 0x25,
+	0x8b, 0xb0, 0xc9, 0x6e, 0x83, 0xe6, 0xb9, 0x0b, 0x15, 0xc8, 0xbd, 0x50, 0x89, 0x16, 0xaa, 0x5f,
+	0xcd, 0x91, 0x0e, 0xe3, 0xff, 0xd4, 0x77, 0x4f, 0x4d, 0x14, 0x8f, 0xda, 0xa3, 0x8e, 0x00, 0xd4,
+	0x01, 0xfc, 0x48, 0xcb, 0xb6, 0x83, 0xd4, 0x4f, 0x32, 0xc5, 0xed, 0xf3, 0x8e, 0x82, 0x8c, 0x1c,
+	0x2a, 0xf9, 0xf4, 0xad, 0x30, 0x9e, 0x05, 0x89, 0x52, 0xd9, 0xbc, 0x8f, 0x16, 0x1e, 0x8b, 0x38,
+	0x96, 0x25, 0x42, 0x93, 0x40, 0xa9, 0xed, 0x95, 0x72, 0xe0, 0x45, 0x58, 0xb2, 0xd1, 0x6e, 0x5c,
+	0x74, 0xd8, 0xdb, 0xc0, 0x2c, 0x65, 0xe1, 0xa6, 0x1f, 0x38, 0xa2, 0x78, 0x9c, 0x68, 0xf2, 0x41,
+	0x86, 0x41, 0xb5, 0x21, 0x15, 0xfa, 0xaf, 0x1a, 0x74, 0x4b, 0x53, 0x51, 0x65, 0x77, 0x2c, 0xa2,
+	0xec, 0xc6, 0x88, 0x6d, 0x84, 0xcd, 0x02, 0x55, 0xab, 0xd9, 0xe1, 0xd4, 0x46, 0x58, 0x14, 0x78,
+	0x22, 0x53, 0x25, 0x6c, 0xa3, 0x1d, 0xaa, 0xc0, 0x55, 0x56, 0xb8, 0xa9, 0x4b, 0x73, 0xaf, 0x00,
+	0xca, 0x8f, 0x76, 0xac, 0xc4, 0x3a, 0xb1, 0xe2, 0xec, 0x36, 0x9f, 0xf7, 0x51, 0x17, 0x3f, 0x17,
+	0x11, 0xee, 0x45, 0xf1, 0x23, 0xeb, 0x22, 0x9b, 0xc9, 0x74, 0x9e, 0x06, 0xbe, 0x20, 0x5e, 0xf4,
+	0xb8, 0x8e, 0x80, 0x4f, 0x03, 0x9f, 0x86, 0x29, 0xa6, 0x92, 0xe5, 0x76, 0x78, 0xd6, 0x45, 0x5f,
+	0xf3, 0x38, 0x15, 0xe8, 0xaf, 0x65, 0x1a, 0xa6, 0xc3, 0xdb, 0xd4, 0x1f, 0x39, 0xc6, 0xdf, 0x34,
+	0x41, 0x3f, 0x52, 0xcc, 0x64, 0xfb, 0xd0, 0xcf, 0x2b, 0xcb, 0xcf, 0xbf, 0xe3, 0x1c, 0xad, 0x36,
+	0xe8, 0x8e, 0xd3, 0x0b, 0x4b, 0xbd, 0xd5, 0xfa, 0xf4, 0xfa, 0x99, 0xfa, 0xf4, 0x17, 0x41, 0x7b,
+	0x1c, 0x2d, 0xab, 0x85, 0x00, 0x47, 0x9e, 0xe5, 0x73, 0x04, 0xb3, 0x77, 0xa1, 0x8b, 0x9c, 0x30,
+	0x63, 0xf2, 0xb3, 0xea, 0x7e, 0x50, 0xfe, 0x35, 0x80, 0xe0, 0x1c, 0x90, 0x48, 0xf9, 0xe2, 0x6d,
+	0xd0, 0xed, 0x99, 0xeb, 0x39, 0x91, 0xf0, 0xd5, 0xf5, 0x96, 0x9d, 0xdd, 0x32, 0xcf, 0x69, 0xd8,
+	0x4f, 0x60, 0xe0, 0x16, 0xf7, 0x1a, 0xa9, 0x19, 0xad, 0xd5, 0x9b, 0x77, 0xe9, 0xe6, 0xc3, 0xd7,
+	0x4b, 0xe4, 0xe4, 0xa2, 0x8b, 0x6a, 0xae, 0x76, 0xb9, 0x9a, 0x4b, 0x96, 0x3e, 0xe7, 0x77, 0x0a,
+	0x0a, 0x6c, 0x28, 0x44, 0x90, 0x08, 0x72, 0x2f, 0x9d, 0x3c, 0xe2, 0x41, 0xef, 0xf2, 0x3a, 0x34,
+	0x50, 0x3b, 0xd5, 0xf5, 0xa0, 0xb4, 0xed, 0xcc, 0xa3, 0x71, 0xc2, 0xd3, 0xaf, 0x0b, 0x69, 0x3c,
+	0x33, 0xa5, 0xfb, 0x47, 0x53, 0xe8, 0xaa, 0xb2, 0xc9, 0x34, 0x9e, 0xed, 0xe3, 0x01, 0x80, 0x6a,
+	0x7b, 0x13, 0xd6, 0xb2, 0x8f, 0x34, 0xa5, 0x26, 0xf4, 0x64, 0x31, 0x59, 0x06, 0xdd, 0x23, 0x7d,
+	0xf8, 0x10, 0x06, 0x69, 0xea, 0x3a, 0xb1, 0x99, 0x04, 0x59, 0xe9, 0xf7, 0xb0, 0x4f, 0xdf, 0x5f,
+	0x0a, 0xb8, 0x1f, 0xa5, 0xae, 0x73, 0x1c, 0xa8, 0xe2, 0xef, 0x3e, 0xd1, 0x67, 0x5d, 0xfa, 0xc9,
+	0x81, 0xde, 0x57, 0x71, 0xe4, 0x9a, 0x2c, 0x1e, 0x24, 0x00, 0x22, 0xf1, 0x64, 0x54, 0x25, 0xe2,
+	0xb6, 0x9f, 0xa8, 0x72, 0x36, 0x50, 0xa0, 0x3d, 0x3f, 0x31, 0x3e, 0x84, 0x5e, 0x59, 0x7d, 0x58,
+	0x47, 0x15, 0x7f, 0x0f, 0x9e, 0x63, 0x00, 0xad, 0xc3, 0x20, 0x5a, 0x58, 0xde, 0xa0, 0x86, 0x6d,
+	0x59, 0xe6, 0x38, 0xa8, 0xb3, 0x1e, 0xe8, 0x47, 0x56, 0x64, 0x79, 0x9e, 0xf0, 0x06, 0x9a, 0xf1,
+	0x01, 0xe8, 0x59, 0x25, 0x3c, 0xbd, 0x69, 0xa1, 0x79, 0x93, 0x47, 0x97, 0xe6, 0xaa, 0x23, 0x80,
+	0x4e, 0xbb, 0xec, 0x07, 0x8d, 0x7a, 0xf1, 0x83, 0x86, 0xf1, 0x5b, 0xd0, 0x2b, 0x7f, 0x5a, 0x76,
+	0x8b, 0xad, 0x15, 0xb7, 0xd8, 0x73, 0x46, 0xd1, 0x03, 0x47, 0x14, 0x2c, 0xcc, 0xd2, 0xc1, 0xa1,
+	0x23, 0x00, 0x97, 0x31, 0xfe, 0xb1, 0x06, 0xfd, 0xca, 0x71, 0xc5, 0x3e, 0x00, 0x2d, 0x59, 0x86,
+	0xca, 0x7e, 0xde, 0x2c, 0xc5, 0x91, 0x65, 0xaa, 0x6a, 0x8f, 0x2c, 0x09, 0x47, 0xe1, 0xfa, 0xb6,
+	0x15, 0x65, 0x96, 0x43, 0xed, 0xfc, 0x77, 0x16, 0xad, 0xf8, 0x9d, 0xc5, 0xf8, 0x04, 0x36, 0xce,
+	0xcc, 0xc0, 0x5a, 0x50, 0x1f, 0x1d, 0x4a, 0x4e, 0xde, 0x1d, 0x1d, 0x1f, 0xec, 0x1e, 0x0d, 0x6a,
+	0x78, 0xc9, 0x3f, 0x18, 0x1d, 0x9a, 0x07, 0xbb, 0xbf, 0x3d, 0xa8, 0xb3, 0x75, 0xe8, 0xde, 0x1d,
+	0x1d, 0xee, 0xf2, 0x4f, 0xcc, 0xfb, 0x8f, 0xc6, 0xf7, 0x06, 0x1a, 0xd3, 0xa1, 0x71, 0xb4, 0x3b,
+	0x1e, 0x0f, 0x1c, 0x6c, 0xed, 0xf3, 0x87, 0x47, 0x03, 0x71, 0xeb, 0x77, 0xa1, 0x25, 0x7f, 0xaf,
+	0x61, 0x1b, 0xd0, 0x7f, 0xe4, 0xcf, 0xfd, 0xe0, 0x89, 0x2f, 0x01, 0x83, 0xe7, 0xd8, 0x25, 0x58,
+	0xcf, 0xe4, 0xa7, 0xfe, 0xe3, 0x19, 0xd4, 0xd8, 0x00, 0x7a, 0xf4, 0x0a, 0x97, 0x41, 0xea, 0xec,
+	0x45, 0x18, 0x1e, 0x45, 0x22, 0xb4, 0x22, 0xb1, 0x1f, 0xf8, 0xe2, 0x30, 0x48, 0xdc, 0xc9, 0x32,
+	0xc3, 0x6a, 0xb7, 0xee, 0x43, 0x4b, 0xfe, 0xe4, 0x53, 0x5a, 0x41, 0x02, 0x06, 0xcf, 0xe1, 0x1e,
+	0x3f, 0xb6, 0xdc, 0xc4, 0xf5, 0xa7, 0x87, 0xe2, 0x34, 0x19, 0xd4, 0x70, 0x67, 0x78, 0x41, 0x18,
+	0xd4, 0xd9, 0x1a, 0x80, 0x9a, 0xe4, 0x9e, 0xef, 0x0c, 0xb4, 0xbb, 0x7b, 0x7f, 0xff, 0xc5, 0x8d,
+	0xda, 0x3f, 0x7d, 0x71, 0xa3, 0xf6, 0xef, 0x5f, 0xdc, 0x78, 0xee, 0xcf, 0xff, 0xe3, 0x46, 0xed,
+	0xd3, 0x77, 0x4b, 0xff, 0x2d, 0x2d, 0xac, 0x24, 0x72, 0x4f, 0xe5, 0xe3, 0x52, 0xd6, 0xf1, 0xc5,
+	0x9d, 0x70, 0x3e, 0xbd, 0x13, 0x9e, 0xdc, 0xc9, 0xc4, 0x72, 0xd2, 0xa2, 0x3f, 0x93, 0xde, 0xfb,
+	0x9f, 0x00, 0x00, 0x00, 0xff, 0xff, 0x15, 0xf0, 0x2c, 0x26, 0x0d, 0x35, 0x00, 0x00,
 }
 
 func (m *Message) Marshal() (dAtA []byte, err error) {
@@ -9148,14 +9156,17 @@ func (m *NodeInfo) MarshalToSizedBuffer(dAtA []byte) (int, error) {
 		i -= len(m.XXX_unrecognized)
 		copy(dAtA[i:], m.XXX_unrecognized)
 	}
+	if m.Type != 0 {
+		i = encodeVarintPipeline(dAtA, i, uint64(m.Type))
+		i--
+		dAtA[i] = 0x28
+	}
 	if len(m.Payload) > 0 {
-		for iNdEx := len(m.Payload) - 1; iNdEx >= 0; iNdEx-- {
-			i -= len(m.Payload[iNdEx])
-			copy(dAtA[i:], m.Payload[iNdEx])
-			i = encodeVarintPipeline(dAtA, i, uint64(len(m.Payload[iNdEx])))
-			i--
-			dAtA[i] = 0x22
-		}
+		i -= len(m.Payload)
+		copy(dAtA[i:], m.Payload)
+		i = encodeVarintPipeline(dAtA, i, uint64(len(m.Payload)))
+		i--
+		dAtA[i] = 0x22
 	}
 	if len(m.Addr) > 0 {
 		i -= len(m.Addr)
@@ -11457,11 +11468,12 @@ func (m *NodeInfo) ProtoSize() (n int) {
 	if l > 0 {
 		n += 1 + l + sovPipeline(uint64(l))
 	}
-	if len(m.Payload) > 0 {
-		for _, s := range m.Payload {
-			l = len(s)
-			n += 1 + l + sovPipeline(uint64(l))
-		}
+	l = len(m.Payload)
+	if l > 0 {
+		n += 1 + l + sovPipeline(uint64(l))
+	}
+	if m.Type != 0 {
+		n += 1 + sovPipeline(uint64(m.Type))
 	}
 	if m.XXX_unrecognized != nil {
 		n += len(m.XXX_unrecognized)
@@ -23202,8 +23214,27 @@ func (m *NodeInfo) Unmarshal(dAtA []byte) error {
 			if postIndex > l {
 				return io.ErrUnexpectedEOF
 			}
-			m.Payload = append(m.Payload, string(dAtA[iNdEx:postIndex]))
+			m.Payload = string(dAtA[iNdEx:postIndex])
 			iNdEx = postIndex
+		case 5:
+			if wireType != 0 {
+				return fmt.Errorf("proto: wrong wireType = %d for field Type", wireType)
+			}
+			m.Type = 0
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowPipeline
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				m.Type |= uint32(b&0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
 		default:
 			iNdEx = preIndex
 			skippy, err := skipPipeline(dAtA[iNdEx:])
diff --git a/pkg/sql/colexec/mergeblock/types.go b/pkg/sql/colexec/mergeblock/types.go
index db6dc45b1..1ab3778e2 100644
--- a/pkg/sql/colexec/mergeblock/types.go
+++ b/pkg/sql/colexec/mergeblock/types.go
@@ -129,7 +129,7 @@ func splitObjectStats(arg *Argument, proc *process.Process,
 			continue
 		}
 
-		blkInfo := catalog.DecodeBlockInfo(blkVec.GetBytesAt(idx))
+		blkInfo := objectio.DecodeBlockInfo(blkVec.GetBytesAt(idx))
 		if objectio.IsSameObjectLocVsMeta(blkInfo.MetaLocation(), objDataMeta) {
 			continue
 		}
@@ -164,7 +164,7 @@ func (arg *Argument) Split(proc *process.Process, bat *batch.Batch) error {
 	hasObject := false
 	for i := range tblIdx { // append s3 writer returned blk info
 		if tblIdx[i] >= 0 {
-			blkInfo := catalog.DecodeBlockInfo(blkInfosVec.GetBytesAt(i))
+			blkInfo := objectio.DecodeBlockInfo(blkInfosVec.GetBytesAt(i))
 			arg.affectedRows += uint64(blkInfo.MetaLocation().Rows())
 			vector.AppendBytes(arg.container.mp[int(tblIdx[i])].Vecs[0],
 				blkInfosVec.GetBytesAt(i), false, proc.GetMPool())
diff --git a/pkg/sql/colexec/s3util.go b/pkg/sql/colexec/s3util.go
index 1afa4ea37..90628f811 100644
--- a/pkg/sql/colexec/s3util.go
+++ b/pkg/sql/colexec/s3util.go
@@ -665,7 +665,7 @@ func (w *S3Writer) writeEndBlocks(proc *process.Process) error {
 		if err := vector.AppendBytes(
 			w.blockInfoBat.Vecs[1],
 			//[]byte(metaLoc),
-			catalog.EncodeBlockInfo(blkInfo),
+			objectio.EncodeBlockInfo(blkInfo),
 			false,
 			proc.GetMPool()); err != nil {
 			return err
@@ -691,13 +691,13 @@ func (w *S3Writer) writeEndBlocks(proc *process.Process) error {
 
 // WriteEndBlocks writes batches in buffer to fileservice(aka s3 in this feature) and get meta data about block on fileservice and put it into metaLocBat
 // For more information, please refer to the comment about func WriteEnd in Writer interface
-func (w *S3Writer) WriteEndBlocks(proc *process.Process) ([]catalog.BlockInfo, []objectio.ObjectStats, error) {
+func (w *S3Writer) WriteEndBlocks(proc *process.Process) ([]objectio.BlockInfo, []objectio.ObjectStats, error) {
 	blocks, _, err := w.writer.Sync(proc.Ctx)
 	logutil.Debugf("write s3 table %q: %v, %v", w.tablename, w.seqnums, w.attrs)
 	if err != nil {
 		return nil, nil, err
 	}
-	blkInfos := make([]catalog.BlockInfo, 0, len(blocks))
+	blkInfos := make([]objectio.BlockInfo, 0, len(blocks))
 	//TODO::block id ,segment id and location should be get from BlockObject.
 	for j := range blocks {
 		location := blockio.EncodeLocation(
@@ -711,7 +711,7 @@ func (w *S3Writer) WriteEndBlocks(proc *process.Process) ([]catalog.BlockInfo, [
 			return nil, nil, err
 		}
 		sid := location.Name().SegmentId()
-		blkInfo := catalog.BlockInfo{
+		blkInfo := objectio.BlockInfo{
 			BlockID: *objectio.NewBlockid(
 				&sid,
 				location.Name().Num(),
diff --git a/pkg/sql/compile/compile.go b/pkg/sql/compile/compile.go
index a6514ae94..05730bce0 100644
--- a/pkg/sql/compile/compile.go
+++ b/pkg/sql/compile/compile.go
@@ -3433,7 +3433,7 @@ func (c *Compile) generateNodes(n *plan.Node) (engine.Nodes, []any, []types.T, e
 	var err error
 	var db engine.Database
 	var rel engine.Relation
-	var ranges [][]byte
+	var ranges engine.Ranges
 	var partialResults []any
 	var partialResultTypes []types.T
 	var nodes engine.Nodes
@@ -3493,11 +3493,12 @@ func (c *Compile) generateNodes(n *plan.Node) (engine.Nodes, []any, []types.T, e
 				if err != nil {
 					return nil, nil, nil, err
 				}
-				//add partition number into catalog.BlockInfo.
-				for _, r := range subranges[1:] {
-					blkInfo := catalog.DecodeBlockInfo(r)
+				//add partition number into objectio.BlockInfo.
+				blkSlice := subranges.(*objectio.BlockInfoSlice)
+				for j := 1; j < subranges.Len(); j++ {
+					blkInfo := blkSlice.Get(j)
 					blkInfo.PartitionNum = i
-					ranges = append(ranges, r)
+					ranges.Append(blkSlice.GetBytes(j))
 				}
 			}
 		} else {
@@ -3514,19 +3515,20 @@ func (c *Compile) generateNodes(n *plan.Node) (engine.Nodes, []any, []types.T, e
 				if err != nil {
 					return nil, nil, nil, err
 				}
-				//add partition number into catalog.BlockInfo.
-				for _, r := range subranges[1:] {
-					blkInfo := catalog.DecodeBlockInfo(r)
+				//add partition number into objectio.BlockInfo.
+				blkSlice := subranges.(*objectio.BlockInfoSlice)
+				for j := 1; j < subranges.Len(); j++ {
+					blkInfo := blkSlice.Get(j)
 					blkInfo.PartitionNum = i
-					ranges = append(ranges, r)
+					ranges.Append(blkSlice.GetBytes(j))
 				}
 			}
 		}
 	}
 
-	if len(n.AggList) > 0 && len(ranges) > 1 {
-		newranges := make([][]byte, 0, len(ranges))
-		newranges = append(newranges, ranges[0])
+	if len(n.AggList) > 0 && ranges.Len() > 1 {
+		newranges := make([]byte, 0, ranges.Size())
+		newranges = append(newranges, ranges.GetBytes(0)...)
 		partialResults = make([]any, 0, len(n.AggList))
 		partialResultTypes = make([]types.T, len(n.AggList))
 
@@ -3568,13 +3570,13 @@ func (c *Compile) generateNodes(n *plan.Node) (engine.Nodes, []any, []types.T, e
 				}
 				columnMap[int(col.Col.ColPos)] = int(n.TableDef.Cols[int(col.Col.ColPos)].Seqnum)
 			}
-			for _, buf := range ranges[1:] {
+			for i := 1; i < ranges.Len(); i++ {
 				if partialResults == nil {
 					break
 				}
-				blk := catalog.DecodeBlockInfo(buf)
+				blk := ranges.(*objectio.BlockInfoSlice).Get(i)
 				if !blk.CanRemote || !blk.DeltaLocation().IsEmpty() {
-					newranges = append(newranges, buf)
+					newranges = append(newranges, ranges.GetBytes(i)...)
 					continue
 				}
 				var objMeta objectio.ObjectMeta
@@ -3855,10 +3857,10 @@ func (c *Compile) generateNodes(n *plan.Node) (engine.Nodes, []any, []types.T, e
 					}
 				}
 			}
-			if len(ranges) == len(newranges) {
+			if ranges.Len() == len(newranges) {
 				partialResults = nil
 			} else if partialResults != nil {
-				ranges = newranges
+				ranges.SetBytes(newranges)
 			}
 		}
 		if partialResults == nil {
@@ -3869,11 +3871,11 @@ func (c *Compile) generateNodes(n *plan.Node) (engine.Nodes, []any, []types.T, e
 
 	// some log for finding a bug.
 	tblId := rel.GetTableID(ctx)
-	expectedLen := len(ranges)
+	expectedLen := ranges.Len()
 	logutil.Debugf("cn generateNodes, tbl %d ranges is %d", tblId, expectedLen)
 
 	//if len(ranges) == 0 indicates that it's a temporary table.
-	if len(ranges) == 0 && n.TableDef.TableType != catalog.SystemOrdinaryRel {
+	if ranges.Len() == 0 && n.TableDef.TableType != catalog.SystemOrdinaryRel {
 		nodes = make(engine.Nodes, len(c.cnList))
 		for i, node := range c.cnList {
 			if isPartitionTable {
@@ -3901,23 +3903,23 @@ func (c *Compile) generateNodes(n *plan.Node) (engine.Nodes, []any, []types.T, e
 	// for multi cn in launch mode, put all payloads in current CN
 	// maybe delete this in the future
 	if isLaunchMode(c.cnList) {
-		return putBlocksInCurrentCN(c, ranges, rel, n), partialResults, partialResultTypes, nil
+		return putBlocksInCurrentCN(c, ranges.GetAllBytes(), rel, n), partialResults, partialResultTypes, nil
 	}
 	// disttae engine
 	if engineType == engine.Disttae {
-		nodes, err := shuffleBlocksToMultiCN(c, ranges, rel, n)
+		nodes, err := shuffleBlocksToMultiCN(c, ranges.(*objectio.BlockInfoSlice), rel, n)
 		return nodes, partialResults, partialResultTypes, err
 	}
 	// maybe temp table on memengine , just put payloads in average
 	return putBlocksInAverage(c, ranges, rel, n), partialResults, partialResultTypes, nil
 }
 
-func putBlocksInAverage(c *Compile, ranges [][]byte, rel engine.Relation, n *plan.Node) engine.Nodes {
+func putBlocksInAverage(c *Compile, ranges engine.Ranges, rel engine.Relation, n *plan.Node) engine.Nodes {
 	var nodes engine.Nodes
-	step := (len(ranges) + len(c.cnList) - 1) / len(c.cnList)
-	for i := 0; i < len(ranges); i += step {
+	step := (ranges.Len() + len(c.cnList) - 1) / len(c.cnList)
+	for i := 0; i < ranges.Len(); i += step {
 		j := i / step
-		if i+step >= len(ranges) {
+		if i+step >= ranges.Len() {
 			if isSameCN(c.cnList[j].Addr, c.addr) {
 				if len(nodes) == 0 {
 					nodes = append(nodes, engine.Node{
@@ -3926,14 +3928,14 @@ func putBlocksInAverage(c *Compile, ranges [][]byte, rel engine.Relation, n *pla
 						Mcpu: c.generateCPUNumber(ncpu, int(n.Stats.BlockNum)),
 					})
 				}
-				nodes[0].Data = append(nodes[0].Data, ranges[i:]...)
+				nodes[0].Data = append(nodes[0].Data, ranges.Slice(i, ranges.Len())...)
 			} else {
 				nodes = append(nodes, engine.Node{
 					Rel:  rel,
 					Id:   c.cnList[j].Id,
 					Addr: c.cnList[j].Addr,
 					Mcpu: c.generateCPUNumber(c.cnList[j].Mcpu, int(n.Stats.BlockNum)),
-					Data: ranges[i:],
+					Data: ranges.Slice(i, ranges.Len()),
 				})
 			}
 		} else {
@@ -3945,14 +3947,14 @@ func putBlocksInAverage(c *Compile, ranges [][]byte, rel engine.Relation, n *pla
 						Mcpu: c.generateCPUNumber(ncpu, int(n.Stats.BlockNum)),
 					})
 				}
-				nodes[0].Data = append(nodes[0].Data, ranges[i:i+step]...)
+				nodes[0].Data = append(nodes[0].Data, ranges.Slice(i, i+step)...)
 			} else {
 				nodes = append(nodes, engine.Node{
 					Rel:  rel,
 					Id:   c.cnList[j].Id,
 					Addr: c.cnList[j].Addr,
 					Mcpu: c.generateCPUNumber(c.cnList[j].Mcpu, int(n.Stats.BlockNum)),
-					Data: ranges[i : i+step],
+					Data: ranges.Slice(i, i+step),
 				})
 			}
 		}
@@ -3960,7 +3962,7 @@ func putBlocksInAverage(c *Compile, ranges [][]byte, rel engine.Relation, n *pla
 	return nodes
 }
 
-func shuffleBlocksToMultiCN(c *Compile, ranges [][]byte, rel engine.Relation, n *plan.Node) (engine.Nodes, error) {
+func shuffleBlocksToMultiCN(c *Compile, ranges *objectio.BlockInfoSlice, rel engine.Relation, n *plan.Node) (engine.Nodes, error) {
 	var nodes engine.Nodes
 	//add current CN
 	nodes = append(nodes, engine.Node{
@@ -3969,26 +3971,25 @@ func shuffleBlocksToMultiCN(c *Compile, ranges [][]byte, rel engine.Relation, n
 		Mcpu: c.generateCPUNumber(ncpu, int(n.Stats.BlockNum)),
 	})
 	//add memory table block
-	nodes[0].Data = append(nodes[0].Data, ranges[:1]...)
-	ranges = ranges[1:]
+	nodes[0].Data = append(nodes[0].Data, ranges.GetBytes(0)...)
+	*ranges = ranges.Slice(1, ranges.Len())
 	// only memory table block
-	if len(ranges) == 0 {
+	if ranges.Len() == 0 {
 		return nodes, nil
 	}
 	//only one cn
 	if len(c.cnList) == 1 {
-		nodes[0].Data = append(nodes[0].Data, ranges...)
+		nodes[0].Data = append(nodes[0].Data, ranges.GetAllBytes()...)
 		return nodes, nil
 	}
 	// put dirty blocks which can't be distributed remotely in current CN.
-	newRanges := make([][]byte, 0, len(ranges))
-	for _, blk := range ranges {
-		blkInfo := catalog.DecodeBlockInfo(blk)
-		if blkInfo.CanRemote {
-			newRanges = append(newRanges, blk)
-			continue
+	newRanges := make(objectio.BlockInfoSlice, 0, ranges.Len())
+	for i := 0; i < ranges.Len(); i++ {
+		if ranges.Get(i).CanRemote {
+			newRanges = append(newRanges, ranges.GetBytes(i)...)
+		} else {
+			nodes[0].Data = append(nodes[0].Data, ranges.GetBytes(i)...)
 		}
-		nodes[0].Data = append(nodes[0].Data, blk)
 	}
 
 	//add the rest of CNs in list
@@ -4040,17 +4041,17 @@ func shuffleBlocksToMultiCN(c *Compile, ranges [][]byte, rel engine.Relation, n
 	return newNodes, nil
 }
 
-func shuffleBlocksByHash(c *Compile, ranges [][]byte, nodes engine.Nodes) {
-	for i, blk := range ranges {
-		unmarshalledBlockInfo := catalog.DecodeBlockInfo(ranges[i])
+func shuffleBlocksByHash(c *Compile, ranges objectio.BlockInfoSlice, nodes engine.Nodes) {
+	for i := 0; i < ranges.Len(); i++ {
+		unmarshalledBlockInfo := ranges.Get(i)
 		// get timestamp in objName to make sure it is random enough
 		objTimeStamp := unmarshalledBlockInfo.MetaLocation().Name()[:7]
 		index := plan2.SimpleCharHashToRange(objTimeStamp, uint64(len(c.cnList)))
-		nodes[index].Data = append(nodes[index].Data, blk)
+		nodes[index].Data = append(nodes[index].Data, ranges.GetBytes(i)...)
 	}
 }
 
-func shuffleBlocksByRange(c *Compile, ranges [][]byte, n *plan.Node, nodes engine.Nodes) error {
+func shuffleBlocksByRange(c *Compile, ranges objectio.BlockInfoSlice, n *plan.Node, nodes engine.Nodes) error {
 	var objDataMeta objectio.ObjectDataMeta
 	var objMeta objectio.ObjectMeta
 
@@ -4058,8 +4059,8 @@ func shuffleBlocksByRange(c *Compile, ranges [][]byte, n *plan.Node, nodes engin
 	var shuffleRangeInt64 []int64
 	var init bool
 	var index uint64
-	for i, blk := range ranges {
-		unmarshalledBlockInfo := catalog.DecodeBlockInfo(ranges[i])
+	for i := 0; i < ranges.Len(); i++ {
+		unmarshalledBlockInfo := ranges.Get(i)
 		location := unmarshalledBlockInfo.MetaLocation()
 		fs, err := fileservice.Get[fileservice.FileService](c.proc.FileService, defines.SharedFileServiceName)
 		if err != nil {
@@ -4075,7 +4076,7 @@ func shuffleBlocksByRange(c *Compile, ranges [][]byte, n *plan.Node, nodes engin
 		zm := blkMeta.MustGetColumn(uint16(n.Stats.HashmapStats.ShuffleColIdx)).ZoneMap()
 		if !zm.IsInited() {
 			// a block with all null will send to first CN
-			nodes[0].Data = append(nodes[0].Data, blk)
+			nodes[0].Data = append(nodes[0].Data, ranges.GetBytes(i)...)
 			continue
 		}
 		if !init {
@@ -4094,12 +4095,12 @@ func shuffleBlocksByRange(c *Compile, ranges [][]byte, n *plan.Node, nodes engin
 		} else {
 			index = plan2.GetRangeShuffleIndexForZM(n.Stats.HashmapStats.ShuffleColMin, n.Stats.HashmapStats.ShuffleColMax, zm, uint64(len(c.cnList)))
 		}
-		nodes[index].Data = append(nodes[index].Data, blk)
+		nodes[index].Data = append(nodes[index].Data, ranges.GetBytes(i)...)
 	}
 	return nil
 }
 
-func putBlocksInCurrentCN(c *Compile, ranges [][]byte, rel engine.Relation, n *plan.Node) engine.Nodes {
+func putBlocksInCurrentCN(c *Compile, ranges []byte, rel engine.Relation, n *plan.Node) engine.Nodes {
 	var nodes engine.Nodes
 	//add current CN
 	nodes = append(nodes, engine.Node{
diff --git a/pkg/sql/compile/runtime_filter.go b/pkg/sql/compile/runtime_filter.go
index 68f9f7233..95aa94f27 100644
--- a/pkg/sql/compile/runtime_filter.go
+++ b/pkg/sql/compile/runtime_filter.go
@@ -17,7 +17,6 @@ package compile
 import (
 	"context"
 
-	"github.com/matrixorigin/matrixone/pkg/catalog"
 	"github.com/matrixorigin/matrixone/pkg/container/types"
 	"github.com/matrixorigin/matrixone/pkg/container/vector"
 	"github.com/matrixorigin/matrixone/pkg/defines"
@@ -55,10 +54,10 @@ func ApplyRuntimeFilters(
 	ctx context.Context,
 	proc *process.Process,
 	tableDef *plan.TableDef,
-	blockInfos [][]byte,
+	blockInfos objectio.BlockInfoSlice,
 	exprs []*plan.Expr,
 	runtimeFilters []*pipeline.RuntimeFilter,
-) ([][]byte, error) {
+) ([]byte, error) {
 	var err error
 	evaluators := make([]RuntimeFilterEvaluator, len(runtimeFilters))
 
@@ -111,8 +110,8 @@ func ApplyRuntimeFilters(
 		return nil, err
 	}
 	curr := 1 // Skip the first block which is always the memtable
-	for i := 1; i < len(blockInfos); i++ {
-		blk := catalog.DecodeBlockInfo(blockInfos[i])
+	for i := 1; i < blockInfos.Len(); i++ {
+		blk := blockInfos.Get(i)
 		location := blk.MetaLocation()
 
 		if !objectio.IsSameObjectLocVsMeta(location, objDataMeta) {
@@ -155,9 +154,9 @@ func ApplyRuntimeFilters(
 		}
 
 		// store the block in ranges
-		blockInfos[curr] = blockInfos[i]
+		blockInfos.Set(curr, blk)
 		curr++
 	}
 
-	return blockInfos[:curr], nil
+	return blockInfos.Slice(0, curr), nil
 }
diff --git a/pkg/sql/compile/scope.go b/pkg/sql/compile/scope.go
index 858f57892..2fa37c4d1 100644
--- a/pkg/sql/compile/scope.go
+++ b/pkg/sql/compile/scope.go
@@ -22,18 +22,18 @@ import (
 	"runtime/debug"
 	"sync"
 
-	"github.com/matrixorigin/matrixone/pkg/common/reuse"
-
 	"github.com/matrixorigin/matrixone/pkg/catalog"
 	"github.com/matrixorigin/matrixone/pkg/cnservice/cnclient"
 	"github.com/matrixorigin/matrixone/pkg/common/bitmap"
 	"github.com/matrixorigin/matrixone/pkg/common/moerr"
 	"github.com/matrixorigin/matrixone/pkg/common/morpc"
+	"github.com/matrixorigin/matrixone/pkg/common/reuse"
 	"github.com/matrixorigin/matrixone/pkg/common/runtime"
 	"github.com/matrixorigin/matrixone/pkg/container/batch"
 	"github.com/matrixorigin/matrixone/pkg/container/types"
 	"github.com/matrixorigin/matrixone/pkg/defines"
 	"github.com/matrixorigin/matrixone/pkg/logutil"
+	"github.com/matrixorigin/matrixone/pkg/objectio"
 	pbpipeline "github.com/matrixorigin/matrixone/pkg/pb/pipeline"
 	"github.com/matrixorigin/matrixone/pkg/pb/plan"
 	"github.com/matrixorigin/matrixone/pkg/sql/colexec/connector"
@@ -55,6 +55,7 @@ import (
 	"github.com/matrixorigin/matrixone/pkg/vm"
 	"github.com/matrixorigin/matrixone/pkg/vm/engine"
 	"github.com/matrixorigin/matrixone/pkg/vm/engine/disttae"
+	"github.com/matrixorigin/matrixone/pkg/vm/engine/memoryengine"
 	"github.com/matrixorigin/matrixone/pkg/vm/pipeline"
 	"github.com/matrixorigin/matrixone/pkg/vm/process"
 	"github.com/panjf2000/ants/v2"
@@ -375,7 +376,8 @@ func (s *Scope) ParallelRun(c *Compile, remote bool) error {
 		}
 	}
 
-	mcpu := DeterminRuntimeDOP(goruntime.NumCPU(), len(s.NodeInfo.Data))
+	numCpu := goruntime.NumCPU()
+	var mcpu int
 
 	switch {
 	case remote:
@@ -386,6 +388,8 @@ func (s *Scope) ParallelRun(c *Compile, remote bool) error {
 		if s.DataSource.AccountId != nil {
 			ctx = context.WithValue(ctx, defines.TenantIDKey{}, uint32(s.DataSource.AccountId.GetTenantId()))
 		}
+		blkSlice := objectio.BlockInfoSlice(s.NodeInfo.Data)
+		mcpu = DeterminRuntimeDOP(numCpu, blkSlice.Len())
 		rds, err = c.e.NewBlockReader(ctx, mcpu, s.DataSource.Timestamp, s.DataSource.Expr,
 			s.NodeInfo.Data, s.DataSource.TableDef, c.proc)
 		if err != nil {
@@ -394,6 +398,16 @@ func (s *Scope) ParallelRun(c *Compile, remote bool) error {
 		s.NodeInfo.Data = nil
 
 	case s.NodeInfo.Rel != nil:
+		switch s.NodeInfo.Rel.GetEngineType() {
+		case engine.Disttae:
+			blkSlice := objectio.BlockInfoSlice(s.NodeInfo.Data)
+			mcpu = DeterminRuntimeDOP(numCpu, blkSlice.Len())
+		case engine.Memory:
+			idSlice := memoryengine.ShardIdSlice(s.NodeInfo.Data)
+			mcpu = DeterminRuntimeDOP(numCpu, idSlice.Len())
+		default:
+			mcpu = 1
+		}
 		if rds, err = s.NodeInfo.Rel.NewReader(c.ctx, mcpu, s.DataSource.Expr, s.NodeInfo.Data); err != nil {
 			return err
 		}
@@ -424,6 +438,16 @@ func (s *Scope) ParallelRun(c *Compile, remote bool) error {
 				return err
 			}
 		}
+		switch rel.GetEngineType() {
+		case engine.Disttae:
+			blkSlice := objectio.BlockInfoSlice(s.NodeInfo.Data)
+			mcpu = DeterminRuntimeDOP(numCpu, blkSlice.Len())
+		case engine.Memory:
+			idSlice := memoryengine.ShardIdSlice(s.NodeInfo.Data)
+			mcpu = DeterminRuntimeDOP(numCpu, idSlice.Len())
+		default:
+			mcpu = 1
+		}
 		if rel.GetEngineType() == engine.Memory ||
 			s.DataSource.PartitionRelationNames == nil {
 			mainRds, err := rel.NewReader(
@@ -437,22 +461,23 @@ func (s *Scope) ParallelRun(c *Compile, remote bool) error {
 			rds = append(rds, mainRds...)
 		} else {
 			//handle partition table.
-			dirtyRanges := make(map[int][][]byte, 0)
-			cleanRanges := make([][]byte, 0, len(s.NodeInfo.Data))
-			ranges := s.NodeInfo.Data[1:]
-			for _, r := range ranges {
-				blkInfo := catalog.DecodeBlockInfo(r)
+			blkArray := objectio.BlockInfoSlice(s.NodeInfo.Data)
+			dirtyRanges := make(map[int]objectio.BlockInfoSlice, 0)
+			cleanRanges := make(objectio.BlockInfoSlice, 0, blkArray.Len())
+			ranges := objectio.BlockInfoSlice(blkArray.Slice(1, blkArray.Len()))
+			for i := 0; i < ranges.Len(); i++ {
+				blkInfo := ranges.Get(i)
 				if !blkInfo.CanRemote {
 					if _, ok := dirtyRanges[blkInfo.PartitionNum]; !ok {
-						newRanges := make([][]byte, 0, 1)
-						newRanges = append(newRanges, []byte{})
+						newRanges := make(objectio.BlockInfoSlice, 0, objectio.BlockInfoSize)
+						newRanges = append(newRanges, objectio.EmptyBlockInfoBytes...)
 						dirtyRanges[blkInfo.PartitionNum] = newRanges
 					}
 					dirtyRanges[blkInfo.PartitionNum] =
-						append(dirtyRanges[blkInfo.PartitionNum], r)
+						append(dirtyRanges[blkInfo.PartitionNum], ranges.GetBytes(i)...)
 					continue
 				}
-				cleanRanges = append(cleanRanges, r)
+				cleanRanges = append(cleanRanges, ranges.GetBytes(i)...)
 			}
 
 			if len(cleanRanges) > 0 {
diff --git a/pkg/sql/compile/scopeRemoteRun.go b/pkg/sql/compile/scopeRemoteRun.go
index 5e7fe3723..8686b17cf 100644
--- a/pkg/sql/compile/scopeRemoteRun.go
+++ b/pkg/sql/compile/scopeRemoteRun.go
@@ -34,6 +34,7 @@ import (
 	"github.com/matrixorigin/matrixone/pkg/lockservice"
 	"github.com/matrixorigin/matrixone/pkg/logservice"
 	"github.com/matrixorigin/matrixone/pkg/logutil"
+	"github.com/matrixorigin/matrixone/pkg/objectio"
 	"github.com/matrixorigin/matrixone/pkg/pb/pipeline"
 	"github.com/matrixorigin/matrixone/pkg/pb/plan"
 	"github.com/matrixorigin/matrixone/pkg/queryservice"
@@ -472,15 +473,14 @@ func generatePipeline(s *Scope, ctx *scopeContext, ctxId int32) (*pipeline.Pipel
 		Id:      s.NodeInfo.Id,
 		Addr:    s.NodeInfo.Addr,
 		Mcpu:    int32(s.NodeInfo.Mcpu),
-		Payload: make([]string, len(s.NodeInfo.Data)),
+		Payload: string(s.NodeInfo.Data),
+		Type: objectio.EncodeInfoHeader(objectio.InfoHeader{
+			Type:    objectio.BlockInfoType,
+			Version: objectio.V1},
+		),
 	}
 	ctx.pipe = p
 	ctx.scope = s
-	{
-		for i := range s.NodeInfo.Data {
-			p.Node.Payload[i] = string(s.NodeInfo.Data[i])
-		}
-	}
 	p.ChildrenCount = int32(len(s.Proc.Reg.MergeReceivers))
 	{
 		for i := range s.Proc.Reg.MergeReceivers {
@@ -628,10 +628,8 @@ func generateScope(proc *process.Process, p *pipeline.Pipeline, ctx *scopeContex
 		s.NodeInfo.Id = p.Node.Id
 		s.NodeInfo.Addr = p.Node.Addr
 		s.NodeInfo.Mcpu = int(p.Node.Mcpu)
-		s.NodeInfo.Data = make([][]byte, len(p.Node.Payload))
-		for i := range p.Node.Payload {
-			s.NodeInfo.Data[i] = []byte(p.Node.Payload[i])
-		}
+		s.NodeInfo.Data = []byte(p.Node.Payload)
+		s.NodeInfo.Header = objectio.DecodeInfoHeader(p.Node.Type)
 	}
 	s.Proc = process.NewWithAnalyze(proc, proc.Ctx, int(p.ChildrenCount), analNodes)
 	{
diff --git a/pkg/sql/plan/function/func_mo.go b/pkg/sql/plan/function/func_mo.go
index 4a1dda672..0168cb7c6 100644
--- a/pkg/sql/plan/function/func_mo.go
+++ b/pkg/sql/plan/function/func_mo.go
@@ -311,9 +311,9 @@ func moTableColMaxMinImpl(fnName string, parameters []*vector.Vector, result vec
 				return err
 			}
 
-			if len(ranges) == 0 {
+			if ranges.Len() == 0 {
 				getValueFailed = true
-			} else if len(ranges) == 1 && engine.IsMemtable(ranges[0]) {
+			} else if ranges.Len() == 1 && engine.IsMemtable(ranges.GetBytes(0)) {
 				getValueFailed = true
 			} else {
 				// BUG： if user delete the max or min value within the same txn, the result will be wrong.
diff --git a/pkg/vm/engine/disttae/engine.go b/pkg/vm/engine/disttae/engine.go
index 40d46cc3a..4c4cb5c1b 100644
--- a/pkg/vm/engine/disttae/engine.go
+++ b/pkg/vm/engine/disttae/engine.go
@@ -487,18 +487,19 @@ func (e *Engine) Hints() (h engine.Hints) {
 }
 
 func (e *Engine) NewBlockReader(ctx context.Context, num int, ts timestamp.Timestamp,
-	expr *plan.Expr, ranges [][]byte, tblDef *plan.TableDef, proc any) ([]engine.Reader, error) {
+	expr *plan.Expr, ranges []byte, tblDef *plan.TableDef, proc any) ([]engine.Reader, error) {
+	blkSlice := objectio.BlockInfoSlice(ranges)
 	rds := make([]engine.Reader, num)
-	blkInfos := make([]*catalog.BlockInfo, 0, len(ranges))
-	for _, r := range ranges {
-		blkInfos = append(blkInfos, catalog.DecodeBlockInfo(r))
+	blkInfos := make([]*objectio.BlockInfo, 0, blkSlice.Len())
+	for i := 0; i < blkSlice.Len(); i++ {
+		blkInfos = append(blkInfos, blkSlice.Get(i))
 	}
 	if len(blkInfos) < num || len(blkInfos) == 1 {
 		for i, blk := range blkInfos {
 			//FIXME::why set blk.EntryState = false ?
 			blk.EntryState = false
 			rds[i] = newBlockReader(
-				ctx, tblDef, ts, []*catalog.BlockInfo{blk}, expr, e.fs, proc.(*process.Process),
+				ctx, tblDef, ts, []*objectio.BlockInfo{blk}, expr, e.fs, proc.(*process.Process),
 			)
 		}
 		for j := len(blkInfos); j < num; j++ {
diff --git a/pkg/vm/engine/disttae/logtailreplay/blocks_iter.go b/pkg/vm/engine/disttae/logtailreplay/blocks_iter.go
index 214832520..94070f223 100644
--- a/pkg/vm/engine/disttae/logtailreplay/blocks_iter.go
+++ b/pkg/vm/engine/disttae/logtailreplay/blocks_iter.go
@@ -15,7 +15,6 @@
 package logtailreplay
 
 import (
-	"github.com/matrixorigin/matrixone/pkg/catalog"
 	"github.com/matrixorigin/matrixone/pkg/common/moerr"
 	"github.com/matrixorigin/matrixone/pkg/container/types"
 	"github.com/matrixorigin/matrixone/pkg/objectio"
@@ -171,7 +170,7 @@ func (p *PartitionState) GetChangedObjsBetween(
 	return
 }
 
-func (p *PartitionState) GetBockDeltaLoc(bid types.Blockid) (catalog.ObjectLocation, types.TS, bool) {
+func (p *PartitionState) GetBockDeltaLoc(bid types.Blockid) (objectio.ObjectLocation, types.TS, bool) {
 	iter := p.blockDeltas.Copy().Iter()
 	defer iter.Release()
 
@@ -181,7 +180,7 @@ func (p *PartitionState) GetBockDeltaLoc(bid types.Blockid) (catalog.ObjectLocat
 		e := iter.Item()
 		return e.DeltaLoc, e.CommitTs, true
 	}
-	return catalog.ObjectLocation{}, types.TS{}, false
+	return objectio.ObjectLocation{}, types.TS{}, false
 }
 
 func (p *PartitionState) BlockPersisted(blockID types.Blockid) bool {
diff --git a/pkg/vm/engine/disttae/logtailreplay/partition_state.go b/pkg/vm/engine/disttae/logtailreplay/partition_state.go
index f434b5de6..87a770cf0 100644
--- a/pkg/vm/engine/disttae/logtailreplay/partition_state.go
+++ b/pkg/vm/engine/disttae/logtailreplay/partition_state.go
@@ -26,7 +26,6 @@ import (
 	"time"
 	"unsafe"
 
-	"github.com/matrixorigin/matrixone/pkg/catalog"
 	"github.com/matrixorigin/matrixone/pkg/common/moprobe"
 	"github.com/matrixorigin/matrixone/pkg/container/batch"
 	"github.com/matrixorigin/matrixone/pkg/container/types"
@@ -127,7 +126,7 @@ func (r RowEntry) Less(than RowEntry) bool {
 }
 
 type BlockEntry struct {
-	catalog.BlockInfo
+	objectio.BlockInfo
 
 	CreateTime types.TS
 	DeleteTime types.TS
@@ -141,7 +140,7 @@ type BlockDeltaEntry struct {
 	BlockID types.Blockid
 
 	CommitTs types.TS
-	DeltaLoc catalog.ObjectLocation
+	DeltaLoc objectio.ObjectLocation
 }
 
 func (b BlockDeltaEntry) Less(than BlockDeltaEntry) bool {
diff --git a/pkg/vm/engine/disttae/reader.go b/pkg/vm/engine/disttae/reader.go
index a96de2c69..d8e2c77ac 100644
--- a/pkg/vm/engine/disttae/reader.go
+++ b/pkg/vm/engine/disttae/reader.go
@@ -270,7 +270,7 @@ func newBlockReader(
 	ctx context.Context,
 	tableDef *plan.TableDef,
 	ts timestamp.Timestamp,
-	blks []*catalog.BlockInfo,
+	blks []*objectio.BlockInfo,
 	filterExpr *plan.Expr,
 	fs fileservice.FileService,
 	proc *process.Process,
@@ -339,9 +339,9 @@ func (r *blockReader) Read(
 	for len(r.steps) > 0 && r.steps[0] == r.currentStep {
 		prefetchFile := r.scanType == SMALL || r.scanType == LARGE
 		if filter != nil && blockInfo.Sorted {
-			blockio.BlockPrefetch(r.filterState.seqnums, r.fs, [][]*catalog.BlockInfo{r.infos[0]}, prefetchFile)
+			blockio.BlockPrefetch(r.filterState.seqnums, r.fs, [][]*objectio.BlockInfo{r.infos[0]}, prefetchFile)
 		} else {
-			blockio.BlockPrefetch(r.columns.seqnums, r.fs, [][]*catalog.BlockInfo{r.infos[0]}, prefetchFile)
+			blockio.BlockPrefetch(r.columns.seqnums, r.fs, [][]*objectio.BlockInfo{r.infos[0]}, prefetchFile)
 		}
 		r.infos = r.infos[1:]
 		r.steps = r.steps[1:]
@@ -418,7 +418,7 @@ func newBlockMergeReader(
 	txnTable *txnTable,
 	encodedPrimaryKey []byte,
 	ts timestamp.Timestamp,
-	dirtyBlks []*catalog.BlockInfo,
+	dirtyBlks []*objectio.BlockInfo,
 	filterExpr *plan.Expr,
 	fs fileservice.FileService,
 	proc *process.Process,
diff --git a/pkg/vm/engine/disttae/tools.go b/pkg/vm/engine/disttae/tools.go
index 8b74dcf06..6d03bc65a 100644
--- a/pkg/vm/engine/disttae/tools.go
+++ b/pkg/vm/engine/disttae/tools.go
@@ -28,6 +28,7 @@ import (
 	"github.com/matrixorigin/matrixone/pkg/defines"
 	"github.com/matrixorigin/matrixone/pkg/fileservice"
 	"github.com/matrixorigin/matrixone/pkg/logutil"
+	"github.com/matrixorigin/matrixone/pkg/objectio"
 	"github.com/matrixorigin/matrixone/pkg/pb/api"
 	"github.com/matrixorigin/matrixone/pkg/pb/metadata"
 	"github.com/matrixorigin/matrixone/pkg/pb/plan"
@@ -1446,8 +1447,8 @@ func transferDecimal128val(a, b int64, oid types.T) (bool, bool, any) {
 	}
 }
 
-func groupBlocksToObjects(blkInfos []*catalog.BlockInfo, dop int) ([][]*catalog.BlockInfo, []int) {
-	var infos [][]*catalog.BlockInfo
+func groupBlocksToObjects(blkInfos []*objectio.BlockInfo, dop int) ([][]*objectio.BlockInfo, []int) {
+	var infos [][]*objectio.BlockInfo
 	objMap := make(map[string]int)
 	lenObjs := 0
 	for _, blkInfo := range blkInfos {
@@ -1458,7 +1459,7 @@ func groupBlocksToObjects(blkInfos []*catalog.BlockInfo, dop int) ([][]*catalog.
 		} else {
 			objMap[objName] = lenObjs
 			lenObjs++
-			infos = append(infos, []*catalog.BlockInfo{blkInfo})
+			infos = append(infos, []*objectio.BlockInfo{blkInfo})
 		}
 	}
 	steps := make([]int, len(infos))
@@ -1485,7 +1486,7 @@ func newBlockReaders(ctx context.Context, fs fileservice.FileService, tblDef *pl
 	return rds
 }
 
-func distributeBlocksToBlockReaders(rds []*blockReader, numOfReaders int, numOfBlocks int, infos [][]*catalog.BlockInfo, steps []int) []*blockReader {
+func distributeBlocksToBlockReaders(rds []*blockReader, numOfReaders int, numOfBlocks int, infos [][]*objectio.BlockInfo, steps []int) []*blockReader {
 	readerIndex := 0
 	for i := range infos {
 		//distribute objects and steps for prefetch
diff --git a/pkg/vm/engine/disttae/txn.go b/pkg/vm/engine/disttae/txn.go
index fabdc7a9c..510206f6f 100644
--- a/pkg/vm/engine/disttae/txn.go
+++ b/pkg/vm/engine/disttae/txn.go
@@ -426,7 +426,7 @@ func (txn *Transaction) dumpBatchLocked(offset int) error {
 		blockInfo.SetRowCount(blockInfo.Vecs[0].Length())
 
 		table := tbl.(*txnTable)
-		fileName := catalog.DecodeBlockInfo(
+		fileName := objectio.DecodeBlockInfo(
 			blockInfo.Vecs[0].GetBytesAt(0)).
 			MetaLocation().Name().String()
 		err = table.db.txn.WriteFileLocked(
@@ -483,7 +483,7 @@ func (txn *Transaction) insertPosForCNBlock(
 	tbName string) error {
 	blks := vector.MustBytesCol(vec)
 	for i, blk := range blks {
-		blkInfo := *catalog.DecodeBlockInfo(blk)
+		blkInfo := *objectio.DecodeBlockInfo(blk)
 		txn.cnBlkId_Pos[blkInfo.BlockID] = Pos{
 			bat:       b,
 			accountId: id,
@@ -517,7 +517,7 @@ func (txn *Transaction) WriteFileLocked(
 
 		blkInfosVec := bat.Vecs[0]
 		for idx := 0; idx < blkInfosVec.Length(); idx++ {
-			blkInfo := *catalog.DecodeBlockInfo(blkInfosVec.GetBytesAt(idx))
+			blkInfo := *objectio.DecodeBlockInfo(blkInfosVec.GetBytesAt(idx))
 			vector.AppendBytes(newBat.Vecs[0], []byte(blkInfo.MetaLocation().String()),
 				false, txn.proc.Mp())
 		}
@@ -720,7 +720,7 @@ func (txn *Transaction) mergeTxnWorkspaceLocked() error {
 
 // CN blocks compaction for txn
 func (txn *Transaction) mergeCompactionLocked() error {
-	compactedBlks := make(map[tableKey]map[catalog.BlockInfo][]int64)
+	compactedBlks := make(map[tableKey]map[objectio.BlockInfo][]int64)
 	compactedEntries := make(map[*batch.Batch][]int64)
 	defer func() {
 		txn.deletedBlocks = nil
@@ -740,7 +740,7 @@ func (txn *Transaction) mergeCompactionLocked() error {
 					dbName:    pos.dbName,
 					name:      pos.tbName,
 				}] =
-					map[catalog.BlockInfo][]int64{pos.blkInfo: offsets}
+					map[objectio.BlockInfo][]int64{pos.blkInfo: offsets}
 			}
 			compactedEntries[pos.bat] = append(compactedEntries[pos.bat], pos.offset)
 			delete(txn.cnBlkId_Pos, *blkId)
@@ -766,7 +766,7 @@ func (txn *Transaction) mergeCompactionLocked() error {
 			for _, blkInfo := range createdBlks {
 				vector.AppendBytes(
 					bat.GetVector(0),
-					catalog.EncodeBlockInfo(blkInfo),
+					objectio.EncodeBlockInfo(blkInfo),
 					false,
 					tbl.db.txn.proc.GetMPool())
 			}
diff --git a/pkg/vm/engine/disttae/txn_table.go b/pkg/vm/engine/disttae/txn_table.go
index e0e94fdd8..7153c334c 100644
--- a/pkg/vm/engine/disttae/txn_table.go
+++ b/pkg/vm/engine/disttae/txn_table.go
@@ -560,7 +560,7 @@ func (tbl *txnTable) resetSnapshot() {
 }
 
 // return all unmodified blocks
-func (tbl *txnTable) Ranges(ctx context.Context, exprs []*plan.Expr) (ranges [][]byte, err error) {
+func (tbl *txnTable) Ranges(ctx context.Context, exprs []*plan.Expr) (ranges engine.Ranges, err error) {
 	start := time.Now()
 	defer func() {
 		v2.TxnTableRangeDurationHistogram.Observe(time.Since(start).Seconds())
@@ -582,8 +582,8 @@ func (tbl *txnTable) Ranges(ctx context.Context, exprs []*plan.Expr) (ranges [][
 		return
 	}
 
-	ranges = make([][]byte, 0, 1)
-	ranges = append(ranges, []byte{})
+	var blocks objectio.BlockInfoSlice
+	blocks.AppendBlockInfo(objectio.EmptyBlockInfo)
 
 	// for dynamic parameter, sustitute param ref and const fold cast expression here to improve performance
 	// temporary solution, will fix it in the future
@@ -597,14 +597,17 @@ func (tbl *txnTable) Ranges(ctx context.Context, exprs []*plan.Expr) (ranges [][
 		}
 	}
 
-	err = tbl.rangesOnePart(
+	if err = tbl.rangesOnePart(
 		ctx,
 		part,
 		tbl.GetTableDef(ctx),
 		newExprs,
-		&ranges,
+		&blocks,
 		tbl.proc.Load(),
-	)
+	); err != nil {
+		return
+	}
+	ranges = &blocks
 	return
 }
 
@@ -631,7 +634,7 @@ func (tbl *txnTable) rangesOnePart(
 	state *logtailreplay.PartitionState, // snapshot state of this transaction
 	tableDef *plan.TableDef, // table definition (schema)
 	exprs []*plan.Expr, // filter expression
-	ranges *[][]byte, // output marshaled block list after filtering
+	blocks *objectio.BlockInfoSlice, // output marshaled block list after filtering
 	proc *process.Process, // process of this transaction
 ) (err error) {
 	if tbl.db.txn.op.Txn().IsRCIsolation() {
@@ -657,7 +660,7 @@ func (tbl *txnTable) rangesOnePart(
 	}
 
 	if done, err := tbl.tryFastRanges(
-		exprs, state, uncommittedObjects, ranges, tbl.db.txn.engine.fs,
+		exprs, state, uncommittedObjects, blocks, tbl.db.txn.engine.fs,
 	); err != nil {
 		return err
 	} else if done {
@@ -683,7 +686,7 @@ func (tbl *txnTable) rangesOnePart(
 	}
 
 	if tbl.db.txn.hasDeletesOnUncommitedObject() {
-		ForeachBlkInObjStatsList(true, nil, func(blk *catalog.BlockInfo) bool {
+		ForeachBlkInObjStatsList(true, nil, func(blk *objectio.BlockInfo) bool {
 			if tbl.db.txn.hasUncommittedDeletesOnBlock(&blk.BlockID) {
 				dirtyBlks[blk.BlockID] = struct{}{}
 			}
@@ -785,7 +788,7 @@ func (tbl *txnTable) rangesOnePart(
 				meta = objMeta.MustDataMeta()
 			}
 
-			ForeachBlkInObjStatsList(true, meta, func(blk *catalog.BlockInfo) bool {
+			ForeachBlkInObjStatsList(true, meta, func(blk *objectio.BlockInfo) bool {
 				skipBlk := false
 
 				if auxIdCnt > 0 {
@@ -820,13 +823,13 @@ func (tbl *txnTable) rangesOnePart(
 						blk.CanRemote = true
 					}
 					blk.PartitionNum = -1
-					*ranges = append(*ranges, catalog.EncodeBlockInfo(*blk))
+					blocks.AppendBlockInfo(*blk)
 					return true
 				}
 				// store the block in ranges
 				blk.CanRemote = true
 				blk.PartitionNum = -1
-				*ranges = append(*ranges, catalog.EncodeBlockInfo(*blk))
+				blocks.AppendBlockInfo(*blk)
 
 				return true
 
@@ -841,7 +844,7 @@ func (tbl *txnTable) rangesOnePart(
 		return
 	}
 
-	bhit, btotal := len(*ranges)-1, int(s3BlkCnt)
+	bhit, btotal := blocks.Len()-1, int(s3BlkCnt)
 	v2.TaskSelBlockTotal.Add(float64(btotal))
 	v2.TaskSelBlockHit.Add(float64(btotal - bhit))
 	blockio.RecordBlockSelectivity(bhit, btotal)
@@ -858,7 +861,7 @@ func (tbl *txnTable) tryFastRanges(
 	exprs []*plan.Expr,
 	snapshot *logtailreplay.PartitionState,
 	uncommittedObjects []objectio.ObjectStats,
-	ranges *[][]byte,
+	blocks *objectio.BlockInfoSlice,
 	fs fileservice.FileService,
 ) (done bool, err error) {
 	if tbl.primaryIdx == -1 {
@@ -936,7 +939,7 @@ func (tbl *txnTable) tryFastRanges(
 				return
 			}
 
-			ForeachBlkInObjStatsList(false, meta, func(blk *catalog.BlockInfo) bool {
+			ForeachBlkInObjStatsList(false, meta, func(blk *objectio.BlockInfo) bool {
 				blkBf := bf.GetBloomFilter(uint32(blk.BlockID.Sequence()))
 				blkBfIdx := index.NewEmptyBinaryFuseFilter()
 				if err2 = index.DecodeBloomFilter(blkBfIdx, blkBf); err2 != nil {
@@ -960,7 +963,7 @@ func (tbl *txnTable) tryFastRanges(
 					}
 				}
 				blk.PartitionNum = -1
-				*ranges = append(*ranges, catalog.EncodeBlockInfo(*blk))
+				blocks.AppendBlockInfo(*blk)
 				return true
 			}, obj.ObjectStats)
 
@@ -973,7 +976,7 @@ func (tbl *txnTable) tryFastRanges(
 	}
 
 	done = true
-	bhit, btotal := len(*ranges)-1, int(blockCnt)
+	bhit, btotal := blocks.Len()-1, int(blockCnt)
 	v2.TaskSelBlockTotal.Add(float64(btotal))
 	v2.TaskSelBlockHit.Add(float64(btotal - bhit))
 	blockio.RecordBlockSelectivity(bhit, btotal)
@@ -1276,7 +1279,7 @@ func (tbl *txnTable) Write(ctx context.Context, bat *batch.Batch) error {
 	if bat.Attrs[0] == catalog.BlockMeta_BlockInfo {
 		tbl.db.txn.hasS3Op.Store(true)
 		//bocks maybe come from different S3 object, here we just need to make sure fileName is not Nil.
-		fileName := catalog.DecodeBlockInfo(bat.Vecs[0].GetBytesAt(0)).MetaLocation().Name().String()
+		fileName := objectio.DecodeBlockInfo(bat.Vecs[0].GetBytesAt(0)).MetaLocation().Name().String()
 		return tbl.db.txn.WriteFile(
 			INSERT,
 			tbl.accountId,
@@ -1364,7 +1367,7 @@ func (tbl *txnTable) EnhanceDelete(bat *batch.Batch, name string) error {
 
 // TODO:: do prefetch read and parallel compaction
 func (tbl *txnTable) mergeCompaction(
-	compactedBlks map[catalog.BlockInfo][]int64) ([]catalog.BlockInfo, []objectio.ObjectStats, error) {
+	compactedBlks map[objectio.BlockInfo][]int64) ([]objectio.BlockInfo, []objectio.ObjectStats, error) {
 	s3writer := &colexec.S3Writer{}
 	s3writer.SetTableName(tbl.tableName)
 	s3writer.SetSchemaVer(tbl.version)
@@ -1458,30 +1461,27 @@ func (tbl *txnTable) GetDBID(ctx context.Context) uint64 {
 	return tbl.db.databaseId
 }
 
-func (tbl *txnTable) NewReader(
-	ctx context.Context,
-	num int,
-	expr *plan.Expr,
-	ranges [][]byte) ([]engine.Reader, error) {
+func (tbl *txnTable) NewReader(ctx context.Context, num int, expr *plan.Expr, ranges []byte) ([]engine.Reader, error) {
 	encodedPK, hasNull, _ := tbl.makeEncodedPK(expr)
+	blkArray := objectio.BlockInfoSlice(ranges)
 	if hasNull {
 		return []engine.Reader{new(emptyReader)}, nil
 	}
-	if len(ranges) == 0 {
+	if blkArray.Len() == 0 {
 		return tbl.newMergeReader(ctx, num, expr, encodedPK, nil)
 	}
-	if len(ranges) == 1 && engine.IsMemtable(ranges[0]) {
+	if blkArray.Len() == 1 && engine.IsMemtable(blkArray.GetBytes(0)) {
 		return tbl.newMergeReader(ctx, num, expr, encodedPK, nil)
 	}
-	if len(ranges) > 1 && engine.IsMemtable(ranges[0]) {
+	if blkArray.Len() > 1 && engine.IsMemtable(blkArray.GetBytes(0)) {
 		rds := make([]engine.Reader, num)
 		mrds := make([]mergeReader, num)
-		ranges = ranges[1:]
+		blkArray = blkArray.Slice(1, blkArray.Len())
 
-		var dirtyBlks []*catalog.BlockInfo
-		var cleanBlks []*catalog.BlockInfo
-		for _, blk := range ranges {
-			blkInfo := catalog.DecodeBlockInfo(blk)
+		var dirtyBlks []*objectio.BlockInfo
+		var cleanBlks []*objectio.BlockInfo
+		for i := 0; i < blkArray.Len(); i++ {
+			blkInfo := blkArray.Get(i)
 			if blkInfo.CanRemote {
 				cleanBlks = append(cleanBlks, blkInfo)
 				continue
@@ -1511,9 +1511,9 @@ func (tbl *txnTable) NewReader(
 		}
 		return rds, nil
 	}
-	blkInfos := make([]*catalog.BlockInfo, 0, len(ranges))
-	for _, r := range ranges {
-		blkInfos = append(blkInfos, catalog.DecodeBlockInfo(r))
+	blkInfos := make([]*objectio.BlockInfo, 0, len(blkArray))
+	for i := 0; i < blkArray.Len(); i++ {
+		blkInfos = append(blkInfos, blkArray.Get(i))
 	}
 	return tbl.newBlockReader(ctx, num, expr, blkInfos, tbl.proc.Load())
 }
@@ -1571,7 +1571,7 @@ func (tbl *txnTable) newMergeReader(
 	num int,
 	expr *plan.Expr,
 	encodedPK []byte,
-	dirtyBlks []*catalog.BlockInfo) ([]engine.Reader, error) {
+	dirtyBlks []*objectio.BlockInfo) ([]engine.Reader, error) {
 	rds := make([]engine.Reader, num)
 	mrds := make([]mergeReader, num)
 	rds0, err := tbl.newReader(
@@ -1596,7 +1596,7 @@ func (tbl *txnTable) newBlockReader(
 	ctx context.Context,
 	num int,
 	expr *plan.Expr,
-	blkInfos []*catalog.BlockInfo,
+	blkInfos []*objectio.BlockInfo,
 	proc *process.Process) ([]engine.Reader, error) {
 	rds := make([]engine.Reader, num)
 	ts := tbl.db.txn.op.SnapshotTS()
@@ -1608,7 +1608,7 @@ func (tbl *txnTable) newBlockReader(
 				ctx,
 				tableDef,
 				ts,
-				[]*catalog.BlockInfo{blk},
+				[]*objectio.BlockInfo{blk},
 				expr,
 				tbl.db.txn.engine.fs,
 				proc,
@@ -1648,7 +1648,7 @@ func (tbl *txnTable) newReader(
 	readerNumber int,
 	encodedPrimaryKey []byte,
 	expr *plan.Expr,
-	dirtyBlks []*catalog.BlockInfo,
+	dirtyBlks []*objectio.BlockInfo,
 ) ([]engine.Reader, error) {
 	txn := tbl.db.txn
 	ts := txn.op.SnapshotTS()
@@ -1711,7 +1711,7 @@ func (tbl *txnTable) newReader(
 					tbl,
 					encodedPrimaryKey,
 					ts,
-					[]*catalog.BlockInfo{dirtyBlks[i]},
+					[]*objectio.BlockInfo{dirtyBlks[i]},
 					expr,
 					fs,
 					proc,
@@ -1728,7 +1728,7 @@ func (tbl *txnTable) newReader(
 				tbl,
 				encodedPrimaryKey,
 				ts,
-				[]*catalog.BlockInfo{dirtyBlks[i]},
+				[]*objectio.BlockInfo{dirtyBlks[i]},
 				expr,
 				fs,
 				proc,
@@ -1873,7 +1873,7 @@ func (tbl *txnTable) updateDeleteInfo(
 	state *logtailreplay.PartitionState,
 	deleteObjs,
 	createObjs []objectio.ObjectNameShort) error {
-	var blks []catalog.BlockInfo
+	var blks []objectio.BlockInfo
 
 	deleteObjsMap := make(map[objectio.ObjectNameShort]struct{})
 	for _, name := range deleteObjs {
@@ -1910,7 +1910,7 @@ func (tbl *txnTable) updateDeleteInfo(
 						blkMeta.GetRows(),
 						blkMeta.GetID(),
 					)
-					blkInfo := catalog.BlockInfo{
+					blkInfo := objectio.BlockInfo{
 						BlockID:    bid,
 						EntryState: obj.EntryState,
 						Sorted:     obj.Sorted,
@@ -1955,7 +1955,7 @@ func (tbl *txnTable) updateDeleteInfo(
 }
 
 func (tbl *txnTable) readNewRowid(vec *vector.Vector, row int,
-	blks []catalog.BlockInfo) (types.Rowid, bool, error) {
+	blks []objectio.BlockInfo) (types.Rowid, bool, error) {
 	var auxIdCnt int32
 	var typ *plan.Type
 	var rowid types.Rowid
diff --git a/pkg/vm/engine/disttae/types.go b/pkg/vm/engine/disttae/types.go
index 35af55611..1902af35a 100644
--- a/pkg/vm/engine/disttae/types.go
+++ b/pkg/vm/engine/disttae/types.go
@@ -201,7 +201,7 @@ type Pos struct {
 	tbName    string
 	dbName    string
 	offset    int64
-	blkInfo   catalog.BlockInfo
+	blkInfo   objectio.BlockInfo
 }
 
 // FIXME: The map inside this one will be accessed concurrently, using
@@ -589,13 +589,13 @@ type blockReader struct {
 	withFilterMixin
 
 	// used for prefetch
-	infos       [][]*catalog.BlockInfo
+	infos       [][]*objectio.BlockInfo
 	steps       []int
 	currentStep int
 
 	scanType int
 	// block list to scan
-	blks []*catalog.BlockInfo
+	blks []*objectio.BlockInfo
 	//buffer for block's deletes
 	buffer []int64
 }
diff --git a/pkg/vm/engine/disttae/util.go b/pkg/vm/engine/disttae/util.go
index f04f1ce9d..9987d62e1 100644
--- a/pkg/vm/engine/disttae/util.go
+++ b/pkg/vm/engine/disttae/util.go
@@ -21,7 +21,6 @@ import (
 	"math"
 	"strings"
 
-	"github.com/matrixorigin/matrixone/pkg/catalog"
 	"github.com/matrixorigin/matrixone/pkg/clusterservice"
 	"github.com/matrixorigin/matrixone/pkg/common/util"
 	"github.com/matrixorigin/matrixone/pkg/container/batch"
@@ -1169,7 +1168,7 @@ func ListTnService(appendFn func(service *metadata.TNService)) {
 // UnfoldBlkInfoFromObjStats constructs a block info list from the given object stats.
 // this unfolds all block info at one operation, if an object contains a great many of blocks,
 // this operation is memory sensitive, we recommend another way, StatsBlkIter or ForEach.
-func UnfoldBlkInfoFromObjStats(stats *objectio.ObjectStats) (blks []catalog.BlockInfo) {
+func UnfoldBlkInfoFromObjStats(stats *objectio.ObjectStats) (blks []objectio.BlockInfo) {
 	if stats.IsZero() {
 		return blks
 	}
@@ -1186,9 +1185,9 @@ func UnfoldBlkInfoFromObjStats(stats *objectio.ObjectStats) (blks []catalog.Bloc
 		}
 		accumulate += blkRows
 		loc := objectio.BuildLocation(name, stats.Extent(), blkRows, idx)
-		blks = append(blks, catalog.BlockInfo{
+		blks = append(blks, objectio.BlockInfo{
 			BlockID:   *objectio.BuildObjectBlockid(name, idx),
-			MetaLoc:   catalog.ObjectLocation(loc),
+			MetaLoc:   objectio.ObjectLocation(loc),
 			SegmentID: name.SegmentId(),
 		})
 	}
@@ -1204,7 +1203,7 @@ func UnfoldBlkInfoFromObjStats(stats *objectio.ObjectStats) (blks []catalog.Bloc
 func ForeachBlkInObjStatsList(
 	next bool,
 	dataMeta objectio.ObjectDataMeta,
-	onBlock func(blk *catalog.BlockInfo) bool,
+	onBlock func(blk *objectio.BlockInfo) bool,
 	objects ...objectio.ObjectStats,
 ) {
 	stop := false
@@ -1258,7 +1257,7 @@ func (i *StatsBlkIter) Next() bool {
 	return i.cur < int(i.blkCnt)
 }
 
-func (i *StatsBlkIter) Entry() *catalog.BlockInfo {
+func (i *StatsBlkIter) Entry() *objectio.BlockInfo {
 	if i.cur == -1 {
 		i.cur = 0
 	}
@@ -1273,10 +1272,10 @@ func (i *StatsBlkIter) Entry() *catalog.BlockInfo {
 	}
 
 	loc := objectio.BuildLocation(i.name, i.extent, i.curBlkRows, uint16(i.cur))
-	blk := &catalog.BlockInfo{
+	blk := &objectio.BlockInfo{
 		BlockID:   *objectio.BuildObjectBlockid(i.name, uint16(i.cur)),
 		SegmentID: i.name.SegmentId(),
-		MetaLoc:   catalog.ObjectLocation(loc),
+		MetaLoc:   objectio.ObjectLocation(loc),
 	}
 	return blk
 }
diff --git a/pkg/vm/engine/entire_engine.go b/pkg/vm/engine/entire_engine.go
index a79116c49..cf2e43e17 100644
--- a/pkg/vm/engine/entire_engine.go
+++ b/pkg/vm/engine/entire_engine.go
@@ -71,7 +71,7 @@ func (e *EntireEngine) Hints() Hints {
 }
 
 func (e *EntireEngine) NewBlockReader(ctx context.Context, num int, ts timestamp.Timestamp,
-	expr *plan.Expr, ranges [][]byte, tblDef *plan.TableDef, proc any) ([]Reader, error) {
+	expr *plan.Expr, ranges []byte, tblDef *plan.TableDef, proc any) ([]Reader, error) {
 	return e.Engine.NewBlockReader(ctx, num, ts, expr, ranges, tblDef, proc)
 }
 
diff --git a/pkg/vm/engine/memoryengine/binded.go b/pkg/vm/engine/memoryengine/binded.go
index dcc4f733b..fbef9c1bc 100644
--- a/pkg/vm/engine/memoryengine/binded.go
+++ b/pkg/vm/engine/memoryengine/binded.go
@@ -62,7 +62,7 @@ func (b *BindedEngine) Hints() engine.Hints {
 }
 
 func (b *BindedEngine) NewBlockReader(_ context.Context, _ int, _ timestamp.Timestamp,
-	_ *plan.Expr, _ [][]byte, _ *plan.TableDef, _ any) ([]engine.Reader, error) {
+	_ *plan.Expr, _ []byte, _ *plan.TableDef, _ any) ([]engine.Reader, error) {
 	return nil, nil
 }
 
diff --git a/pkg/vm/engine/memoryengine/engine.go b/pkg/vm/engine/memoryengine/engine.go
index 854b3fec7..19584eadd 100644
--- a/pkg/vm/engine/memoryengine/engine.go
+++ b/pkg/vm/engine/memoryengine/engine.go
@@ -67,7 +67,7 @@ func (e *Engine) Rollback(_ context.Context, _ client.TxnOperator) error {
 }
 
 func (e *Engine) NewBlockReader(_ context.Context, _ int, _ timestamp.Timestamp,
-	_ *plan.Expr, _ [][]byte, _ *plan.TableDef, _ any) ([]engine.Reader, error) {
+	_ *plan.Expr, _ []byte, _ *plan.TableDef, _ any) ([]engine.Reader, error) {
 	return nil, nil
 }
 
diff --git a/pkg/vm/engine/memoryengine/table_reader.go b/pkg/vm/engine/memoryengine/table_reader.go
index f411cd075..438726586 100644
--- a/pkg/vm/engine/memoryengine/table_reader.go
+++ b/pkg/vm/engine/memoryengine/table_reader.go
@@ -17,7 +17,6 @@ package memoryengine
 import (
 	"context"
 	"encoding/binary"
-
 	"github.com/matrixorigin/matrixone/pkg/catalog"
 	"github.com/matrixorigin/matrixone/pkg/common/mpool"
 	"github.com/matrixorigin/matrixone/pkg/container/batch"
@@ -41,16 +40,9 @@ type IterInfo struct {
 	IterID ID
 }
 
-func (t *Table) NewReader(
-	ctx context.Context,
-	parallel int,
-	expr *plan.Expr,
-	shardIDs [][]byte,
-) (
-	readers []engine.Reader,
-	err error,
-) {
+func (t *Table) NewReader(ctx context.Context, parallel int, expr *plan.Expr, bytes []byte) (readers []engine.Reader, err error) {
 	readers = make([]engine.Reader, parallel)
+	shardIDs := ShardIdSlice(bytes)
 
 	var shards []Shard
 	if len(shardIDs) == 0 {
@@ -78,9 +70,8 @@ func (t *Table) NewReader(
 	} else {
 		// some
 		idSet := make(map[uint64]bool)
-		for _, bs := range shardIDs {
-			id := binary.LittleEndian.Uint64(bs)
-			idSet[id] = true
+		for i := 0; i < shardIDs.Len(); i++ {
+			idSet[shardIDs.Get(i)] = true
 		}
 		for _, store := range getTNServices(t.engine.cluster) {
 			for _, shard := range store.Shards {
@@ -208,18 +199,54 @@ func (t *Table) GetEngineType() engine.EngineType {
 	return engine.Memory
 }
 
-func (t *Table) Ranges(_ context.Context, _ []*plan.Expr) ([][]byte, error) {
+func (t *Table) Ranges(_ context.Context, _ []*plan.Expr) (engine.Ranges, error) {
 	// return encoded shard ids
 	nodes := getTNServices(t.engine.cluster)
-	shards := make([][]byte, 0, len(nodes))
+	shards := make(ShardIdSlice, 0, len(nodes)*8)
 	for _, node := range nodes {
 		for _, shard := range node.Shards {
 			id := make([]byte, 8)
 			binary.LittleEndian.PutUint64(id, shard.ShardID)
-			shards = append(shards, id)
+			shards = append(shards, id...)
 		}
 	}
-	return shards, nil
+	return &shards, nil
+}
+
+type ShardIdSlice []byte
+
+var _ engine.Ranges = (*ShardIdSlice)(nil)
+
+func (s *ShardIdSlice) GetBytes(i int) []byte {
+	return (*s)[i*8 : (i+1)*8]
+}
+
+func (s *ShardIdSlice) Len() int {
+	return len(*s) / 8
+}
+
+func (s *ShardIdSlice) Append(bs []byte) {
+	*s = append(*s, bs...)
+}
+
+func (s *ShardIdSlice) Size() int {
+	return len(*s)
+}
+
+func (s *ShardIdSlice) SetBytes(bs []byte) {
+	*s = bs
+}
+
+func (s *ShardIdSlice) GetAllBytes() []byte {
+	return *s
+}
+
+func (s *ShardIdSlice) Slice(i, j int) []byte {
+	return (*s)[i*8 : j*8]
+}
+
+func (s *ShardIdSlice) Get(i int) uint64 {
+	return binary.LittleEndian.Uint64(s.GetBytes(i))
 }
 
 func (t *Table) UpdateObjectInfos(_ context.Context) error {
diff --git a/pkg/vm/engine/tae/blockio/read.go b/pkg/vm/engine/tae/blockio/read.go
index afd157a9c..46718f274 100644
--- a/pkg/vm/engine/tae/blockio/read.go
+++ b/pkg/vm/engine/tae/blockio/read.go
@@ -25,7 +25,6 @@ import (
 
 	"github.com/matrixorigin/matrixone/pkg/container/vector"
 
-	pkgcatalog "github.com/matrixorigin/matrixone/pkg/catalog"
 	"github.com/matrixorigin/matrixone/pkg/common/mpool"
 	"github.com/matrixorigin/matrixone/pkg/container/batch"
 	"github.com/matrixorigin/matrixone/pkg/container/types"
@@ -40,7 +39,7 @@ type ReadFilter = func([]*vector.Vector) []int32
 
 func ReadByFilter(
 	ctx context.Context,
-	info *pkgcatalog.BlockInfo,
+	info *objectio.BlockInfo,
 	inputDeletes []int64,
 	columns []uint16,
 	colTypes []types.Type,
@@ -108,7 +107,7 @@ func ReadByFilter(
 // BlockRead read block data from storage and apply deletes according given timestamp. Caller make sure metaloc is not empty
 func BlockRead(
 	ctx context.Context,
-	info *pkgcatalog.BlockInfo,
+	info *objectio.BlockInfo,
 	inputDeletes []int64,
 	columns []uint16,
 	colTypes []types.Type,
@@ -211,7 +210,7 @@ func BlockCompactionRead(
 
 func BlockReadInner(
 	ctx context.Context,
-	info *pkgcatalog.BlockInfo,
+	info *objectio.BlockInfo,
 	inputDeleteRows []int64,
 	columns []uint16,
 	colTypes []types.Type,
@@ -399,7 +398,7 @@ func getRowsIdIndex(colIndexes []uint16, colTypes []types.Type) (int, []uint16,
 }
 
 func buildRowidColumn(
-	info *pkgcatalog.BlockInfo,
+	info *objectio.BlockInfo,
 	sels []int32,
 	m *mpool.MPool,
 	vp engine.VectorPool,
@@ -436,7 +435,7 @@ func readBlockData(
 	ctx context.Context,
 	colIndexes []uint16,
 	colTypes []types.Type,
-	info *pkgcatalog.BlockInfo,
+	info *objectio.BlockInfo,
 	ts types.TS,
 	fs fileservice.FileService,
 	m *mpool.MPool,
@@ -577,7 +576,7 @@ func evalDeleteRowsByTimestampForDeletesPersistedByCN(deletes *batch.Batch, ts t
 // columns  Which columns should be taken for columns
 // service  fileservice
 // infos [s3object name][block]
-func BlockPrefetch(idxes []uint16, service fileservice.FileService, infos [][]*pkgcatalog.BlockInfo, prefetchFile bool) error {
+func BlockPrefetch(idxes []uint16, service fileservice.FileService, infos [][]*objectio.BlockInfo, prefetchFile bool) error {
 	// Generate prefetch task
 	for i := range infos {
 		// build reader
diff --git a/pkg/vm/engine/types.go b/pkg/vm/engine/types.go
index 1463288c7..59b626d01 100644
--- a/pkg/vm/engine/types.go
+++ b/pkg/vm/engine/types.go
@@ -25,6 +25,7 @@ import (
 	"github.com/matrixorigin/matrixone/pkg/container/batch"
 	"github.com/matrixorigin/matrixone/pkg/container/types"
 	"github.com/matrixorigin/matrixone/pkg/container/vector"
+	"github.com/matrixorigin/matrixone/pkg/objectio"
 	"github.com/matrixorigin/matrixone/pkg/pb/plan"
 	"github.com/matrixorigin/matrixone/pkg/pb/timestamp"
 	"github.com/matrixorigin/matrixone/pkg/txn/client"
@@ -33,11 +34,12 @@ import (
 type Nodes []Node
 
 type Node struct {
-	Mcpu int
-	Id   string   `json:"id"`
-	Addr string   `json:"address"`
-	Data [][]byte `json:"payload"`
-	Rel  Relation // local relation
+	Mcpu   int
+	Id     string `json:"id"`
+	Addr   string `json:"address"`
+	Header objectio.InfoHeader
+	Data   []byte   `json:"payload"`
+	Rel    Relation // local relation
 }
 
 // Attribute is a column
@@ -567,12 +569,30 @@ func (def *StreamConfigsDef) ToPBVersion() ConstraintPB {
 	}
 }
 
+type Ranges interface {
+	GetBytes(i int) []byte
+
+	Len() int
+
+	Append([]byte)
+
+	Size() int
+
+	SetBytes([]byte)
+
+	GetAllBytes() []byte
+
+	Slice(i, j int) []byte
+}
+
+var _ Ranges = (*objectio.BlockInfoSlice)(nil)
+
 type Relation interface {
 	Statistics
 
 	UpdateObjectInfos(context.Context) error
 
-	Ranges(context.Context, []*plan.Expr) ([][]byte, error)
+	Ranges(context.Context, []*plan.Expr) (Ranges, error)
 
 	TableDefs(context.Context) ([]TableDef, error)
 
@@ -606,7 +626,7 @@ type Relation interface {
 	GetDBID(context.Context) uint64
 
 	// second argument is the number of reader, third argument is the filter extend, foruth parameter is the payload required by the engine
-	NewReader(context.Context, int, *plan.Expr, [][]byte) ([]Reader, error)
+	NewReader(context.Context, int, *plan.Expr, []byte) ([]Reader, error)
 
 	TableColumns(ctx context.Context) ([]*Attribute, error)
 
@@ -665,8 +685,7 @@ type Engine interface {
 	// since implementations may update hints after engine had initialized
 	Hints() Hints
 
-	NewBlockReader(ctx context.Context, num int, ts timestamp.Timestamp,
-		expr *plan.Expr, ranges [][]byte, tblDef *plan.TableDef, proc any) ([]Reader, error)
+	NewBlockReader(ctx context.Context, num int, ts timestamp.Timestamp, expr *plan.Expr, ranges []byte, tblDef *plan.TableDef, proc any) ([]Reader, error)
 
 	// Get database name & table name by table id
 	GetNameById(ctx context.Context, op client.TxnOperator, tableId uint64) (dbName string, tblName string, err error)
@@ -694,5 +713,5 @@ type EntireEngine struct {
 }
 
 func IsMemtable(tblRange []byte) bool {
-	return len(tblRange) == 0
+	return bytes.Equal(tblRange, objectio.EmptyBlockInfoBytes)
 }
diff --git a/proto/pipeline.proto b/proto/pipeline.proto
index 3b5768490..f689a2e41 100644
--- a/proto/pipeline.proto
+++ b/proto/pipeline.proto
@@ -455,7 +455,8 @@ message NodeInfo {
   int32 mcpu = 1;
   string id = 2;
   string addr = 3;
-  repeated string payload = 4;
+  string payload = 4;
+  uint32 type = 5;
 }
 
 message ProcessLimitation {


Test patch:
diff --git a/pkg/catalog/types_test.go b/pkg/catalog/types_test.go
deleted file mode 100644
index 4d1c83413..000000000
--- a/pkg/catalog/types_test.go
+++ /dev/null
@@ -1,15 +0,0 @@
-// Copyright 2022 Matrix Origin
-//
-// Licensed 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 catalog
diff --git a/pkg/frontend/test/engine_mock.go b/pkg/frontend/test/engine_mock.go
index f4f6bc146..a47181650 100644
--- a/pkg/frontend/test/engine_mock.go
+++ b/pkg/frontend/test/engine_mock.go
@@ -395,7 +395,7 @@ func (mr *MockRelationMockRecorder) MaxAndMinValues(ctx interface{}) *gomock.Cal
 }
 
 // NewReader mocks base method.
-func (m *MockRelation) NewReader(arg0 context.Context, arg1 int, arg2 *plan.Expr, arg3 [][]byte) ([]engine.Reader, error) {
+func (m *MockRelation) NewReader(arg0 context.Context, arg1 int, arg2 *plan.Expr, arg3 []byte) ([]engine.Reader, error) {
 	m.ctrl.T.Helper()
 	ret := m.ctrl.Call(m, "NewReader", arg0, arg1, arg2, arg3)
 	ret0, _ := ret[0].([]engine.Reader)
@@ -425,10 +425,10 @@ func (mr *MockRelationMockRecorder) PrimaryKeysMayBeModified(ctx, from, to, keyV
 }
 
 // Ranges mocks base method.
-func (m *MockRelation) Ranges(arg0 context.Context, arg1 []*plan.Expr) ([][]byte, error) {
+func (m *MockRelation) Ranges(arg0 context.Context, arg1 []*plan.Expr) (engine.Ranges, error) {
 	m.ctrl.T.Helper()
 	ret := m.ctrl.Call(m, "Ranges", arg0, arg1)
-	ret0, _ := ret[0].([][]byte)
+	ret0, _ := ret[0].(engine.Ranges)
 	ret1, _ := ret[1].(error)
 	return ret0, ret1
 }
@@ -917,7 +917,7 @@ func (mr *MockEngineMockRecorder) New(ctx, op interface{}) *gomock.Call {
 }
 
 // NewBlockReader mocks base method.
-func (m *MockEngine) NewBlockReader(ctx context.Context, num int, ts timestamp.Timestamp, expr *plan.Expr, ranges [][]byte, tblDef *plan.TableDef, proc any) ([]engine.Reader, error) {
+func (m *MockEngine) NewBlockReader(ctx context.Context, num int, ts timestamp.Timestamp, expr *plan.Expr, ranges []byte, tblDef *plan.TableDef, proc any) ([]engine.Reader, error) {
 	m.ctrl.T.Helper()
 	ret := m.ctrl.Call(m, "NewBlockReader", ctx, num, ts, expr, ranges, tblDef, proc)
 	ret0, _ := ret[0].([]engine.Reader)
diff --git a/pkg/frontend/util_test.go b/pkg/frontend/util_test.go
index 0de886a50..29cdc317b 100644
--- a/pkg/frontend/util_test.go
+++ b/pkg/frontend/util_test.go
@@ -18,6 +18,7 @@ import (
 	"context"
 	"encoding/binary"
 	"fmt"
+	"github.com/matrixorigin/matrixone/pkg/vm/engine/memoryengine"
 	"math"
 	"sort"
 	"strings"
@@ -607,12 +608,12 @@ func TestGetExprValue(t *testing.T) {
 		table.EXPECT().GetEngineType().Return(engine.Disttae).AnyTimes()
 		table.EXPECT().Stats(gomock.Any(), gomock.Any(), gomock.Any()).Return(false).AnyTimes()
 
-		var ranges [][]byte
+		var ranges memoryengine.ShardIdSlice
 		id := make([]byte, 8)
 		binary.LittleEndian.PutUint64(id, 1)
-		ranges = append(ranges, id)
+		ranges.Append(id)
 
-		table.EXPECT().Ranges(gomock.Any(), gomock.Any()).Return(ranges, nil).AnyTimes()
+		table.EXPECT().Ranges(gomock.Any(), gomock.Any()).Return(&ranges, nil).AnyTimes()
 		table.EXPECT().NewReader(gomock.Any(), gomock.Any(), gomock.Any(), gomock.Any()).Return(nil, moerr.NewInvalidInputNoCtx("new reader failed")).AnyTimes()
 
 		eng.EXPECT().Database(gomock.Any(), gomock.Any(), gomock.Any()).Return(db, nil).AnyTimes()
diff --git a/pkg/objectio/block_info_test.go b/pkg/objectio/block_info_test.go
new file mode 100644
index 000000000..f6fd9e60a
--- /dev/null
+++ b/pkg/objectio/block_info_test.go
@@ -0,0 +1,188 @@
+// Copyright 2022 Matrix Origin
+//
+// Licensed 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 objectio
+
+import (
+	"testing"
+
+	"github.com/matrixorigin/matrixone/pkg/container/types"
+	"github.com/stretchr/testify/require"
+)
+
+func TestEncodeInfoHeader(t *testing.T) {
+	h := InfoHeader{
+		Type:    BlockInfoType,
+		Version: V1,
+	}
+	require.Equal(t, h, DecodeInfoHeader(EncodeInfoHeader(h)))
+}
+
+func FuzzEncodeInfoHeader(f *testing.F) {
+	f.Fuzz(func(t *testing.T, typ, v uint16) {
+		h := InfoHeader{
+			Type:    typ,
+			Version: v,
+		}
+		require.Equal(t, h, DecodeInfoHeader(EncodeInfoHeader(h)))
+	})
+}
+
+func TestBlockInfoSlice_Append(t *testing.T) {
+	var s BlockInfoSlice
+	s.AppendBlockInfo(BlockInfo{BlockID: types.Blockid{1}})
+	require.Equal(t, 1, s.Len())
+	require.Equal(t, BlockInfoSize, s.Size())
+	require.Equal(t, &BlockInfo{BlockID: types.Blockid{1}}, s.Get(0))
+
+	var s2 BlockInfoSlice
+	s2.AppendBlockInfo(BlockInfo{BlockID: types.Blockid{1}})
+	s2.AppendBlockInfo(BlockInfo{BlockID: types.Blockid{2}})
+	require.Equal(t, 2, s2.Len())
+	require.Equal(t, BlockInfoSize*2, s2.Size())
+	require.Equal(t, &BlockInfo{BlockID: types.Blockid{1}}, s2.Get(0))
+	require.Equal(t, &BlockInfo{BlockID: types.Blockid{2}}, s2.Get(1))
+
+	var s3 BlockInfoSlice
+	s3.Append(EncodeBlockInfo(BlockInfo{BlockID: types.Blockid{1}}))
+	s3.Append(EncodeBlockInfo(BlockInfo{BlockID: types.Blockid{2}}))
+	require.Equal(t, 2, s3.Len())
+	require.Equal(t, BlockInfoSize*2, s3.Size())
+	require.Equal(t, &BlockInfo{BlockID: types.Blockid{1}}, s3.Get(0))
+	require.Equal(t, &BlockInfo{BlockID: types.Blockid{2}}, s3.Get(1))
+}
+
+func intToBlockid(i int32) types.Blockid {
+	return types.Blockid{
+		byte(i >> 24),
+		byte(i >> 16),
+		byte(i >> 8),
+		byte(i),
+	}
+}
+
+func TestBlockInfoSliceTraverse(t *testing.T) {
+	var s BlockInfoSlice
+	for i := int32(0); i < 1000; i++ {
+		s.AppendBlockInfo(BlockInfo{BlockID: intToBlockid(i)})
+	}
+	require.Equal(t, 1000, s.Len())
+
+	for i := 0; i < s.Len(); i++ {
+		blkInfo := s.Get(i)
+		require.Equal(t, intToBlockid(int32(i)), blkInfo.BlockID)
+		require.Equal(t, false, blkInfo.CanRemote)
+		blkInfo.CanRemote = true
+	}
+
+	for i := 0; i < s.Len(); i++ {
+		require.Equal(t, true, s.Get(i).CanRemote)
+	}
+
+	s.AppendBlockInfo(BlockInfo{BlockID: intToBlockid(1000), CanRemote: true})
+
+	for i := 0; i < s.Len(); i++ {
+		require.Equal(t, true, s.Get(i).CanRemote)
+	}
+}
+
+func TestBytesToBlockInfoSlice(t *testing.T) {
+	bs := make([]byte, 0)
+	for i := 0; i < 1000; i++ {
+		bs = append(bs, EncodeBlockInfo(BlockInfo{BlockID: intToBlockid(int32(i))})...)
+	}
+
+	s := BlockInfoSlice(bs)
+	require.Equal(t, 1000, s.Len())
+
+	for i := 0; i < s.Len(); i++ {
+		blkInfo := s.Get(i)
+		require.Equal(t, intToBlockid(int32(i)), blkInfo.BlockID)
+		require.Equal(t, false, blkInfo.CanRemote)
+		blkInfo.CanRemote = true
+	}
+
+	s.AppendBlockInfo(BlockInfo{BlockID: intToBlockid(1000), CanRemote: true})
+
+	for i := 0; i < s.Len(); i++ {
+		require.Equal(t, true, s.Get(i).CanRemote)
+	}
+
+	require.Equal(t, 1000*BlockInfoSize, len(bs))
+	require.Equal(t, s.Size(), len(bs)+BlockInfoSize)
+	bs = s
+	require.Equal(t, 1001*BlockInfoSize, len(bs))
+	require.Equal(t, s.GetAllBytes(), bs)
+
+	s.Get(999).CanRemote = false
+	require.Equal(t, false, s.Get(999).CanRemote)
+	blkInfo := DecodeBlockInfo(bs[999*BlockInfoSize:])
+	require.Equal(t, false, blkInfo.CanRemote)
+}
+
+func TestBlockInfoSlice_Slice(t *testing.T) {
+	s := make(BlockInfoSlice, 0)
+	s.AppendBlockInfo(BlockInfo{BlockID: intToBlockid(0)})
+	// Get BlockInfoSlice[:1]
+	require.Equal(t, s.GetBytes(0), []byte(s.Slice(0, 1)))
+	// Get BlockInfoSlice[1:]
+	require.Equal(t, []byte{}, []byte(s.Slice(1, s.Len())))
+
+	s = s.Slice(1, s.Len())
+	require.Equal(t, 0, len(s))
+	require.Equal(t, 0, s.Len())
+
+	s.AppendBlockInfo(BlockInfo{BlockID: intToBlockid(1)})
+	s.AppendBlockInfo(BlockInfo{BlockID: intToBlockid(2)})
+	require.Equal(t, s.GetBytes(0), []byte(s.Slice(0, 1)))
+	require.Equal(t, s.GetBytes(1), []byte(s.Slice(1, s.Len())))
+}
+
+func TestBlockInfoSlice_GetBytes(t *testing.T) {
+	s := make(BlockInfoSlice, 0, 10)
+	for i := 0; i < 10; i++ {
+		s.AppendBlockInfo(BlockInfo{BlockID: intToBlockid(int32(i))})
+	}
+
+	for i := 0; i < 10; i++ {
+		require.Equal(t, EncodeBlockInfo(BlockInfo{BlockID: intToBlockid(int32(i))}), s.GetBytes(i))
+		require.Equal(t, &BlockInfo{BlockID: intToBlockid(int32(i))}, DecodeBlockInfo(s.GetBytes(i)))
+		require.Equal(t, &BlockInfo{BlockID: intToBlockid(int32(i))}, s.Get(i))
+		require.Equal(t, EncodeBlockInfo(BlockInfo{BlockID: intToBlockid(int32(i))}), EncodeBlockInfo(*s.Get(i)))
+	}
+}
+
+func TestBlockInfoSlice_Remove(t *testing.T) {
+	s := make(BlockInfoSlice, 0, 10)
+	for i := 0; i < 10; i++ {
+		s.AppendBlockInfo(BlockInfo{BlockID: intToBlockid(int32(i))})
+	}
+
+	curr := 0
+	for i := 0; i < 10; i++ {
+		blk := s.Get(i)
+		if blk.BlockID == intToBlockid(0) {
+			// remove the first element
+			continue
+		}
+		s.Set(curr, blk)
+		curr++
+	}
+
+	s = s.Slice(0, curr)
+	require.Equal(t, 9, s.Len())
+	for i := 0; i < 9; i++ {
+		require.Equal(t, intToBlockid(int32(i+1)), s.Get(i).BlockID)
+	}
+}
diff --git a/pkg/sql/colexec/mergeblock/mergeblock_test.go b/pkg/sql/colexec/mergeblock/mergeblock_test.go
index b76d37ecb..f821b53a1 100644
--- a/pkg/sql/colexec/mergeblock/mergeblock_test.go
+++ b/pkg/sql/colexec/mergeblock/mergeblock_test.go
@@ -56,7 +56,7 @@ func TestMergeBlock(t *testing.T) {
 	loc3 := blockio.EncodeLocation(name3, objectio.Extent{}, 15, 0)
 
 	sid1 := loc1.Name().SegmentId()
-	blkInfo1 := catalog.BlockInfo{
+	blkInfo1 := objectio.BlockInfo{
 		BlockID: *objectio.NewBlockid(
 			&sid1,
 			loc1.Name().Num(),
@@ -68,7 +68,7 @@ func TestMergeBlock(t *testing.T) {
 	blkInfo1.SetMetaLocation(loc1)
 
 	sid2 := loc2.Name().SegmentId()
-	blkInfo2 := catalog.BlockInfo{
+	blkInfo2 := objectio.BlockInfo{
 		BlockID: *objectio.NewBlockid(
 			&sid2,
 			loc2.Name().Num(),
@@ -80,7 +80,7 @@ func TestMergeBlock(t *testing.T) {
 	blkInfo2.SetMetaLocation(loc2)
 
 	sid3 := loc3.Name().SegmentId()
-	blkInfo3 := catalog.BlockInfo{
+	blkInfo3 := objectio.BlockInfo{
 		BlockID: *objectio.NewBlockid(
 			&sid3,
 			loc3.Name().Num(),
@@ -96,9 +96,9 @@ func TestMergeBlock(t *testing.T) {
 		Vecs: []*vector.Vector{
 			testutil.MakeInt16Vector([]int16{0, 0, 0}, nil),
 			testutil.MakeTextVector([]string{
-				string(catalog.EncodeBlockInfo(blkInfo1)),
-				string(catalog.EncodeBlockInfo(blkInfo2)),
-				string(catalog.EncodeBlockInfo(blkInfo3))},
+				string(objectio.EncodeBlockInfo(blkInfo1)),
+				string(objectio.EncodeBlockInfo(blkInfo2)),
+				string(objectio.EncodeBlockInfo(blkInfo3))},
 				nil),
 			testutil.MakeTextVector([]string{
 				string(objectio.ZeroObjectStats[:]),
diff --git a/pkg/vm/engine/disttae/util_test.go b/pkg/vm/engine/disttae/util_test.go
index 9c8c5f151..ccbd894e1 100644
--- a/pkg/vm/engine/disttae/util_test.go
+++ b/pkg/vm/engine/disttae/util_test.go
@@ -20,7 +20,6 @@ import (
 	"math/rand"
 	"testing"
 
-	"github.com/matrixorigin/matrixone/pkg/catalog"
 	"github.com/matrixorigin/matrixone/pkg/common/mpool"
 	"github.com/matrixorigin/matrixone/pkg/container/types"
 	"github.com/matrixorigin/matrixone/pkg/container/vector"
@@ -81,10 +80,10 @@ func makeFunctionExprForTest(name string, args []*plan.Expr) *plan.Expr {
 
 func TestBlockMetaMarshal(t *testing.T) {
 	location := []byte("test")
-	var info catalog.BlockInfo
+	var info objectio.BlockInfo
 	info.SetMetaLocation(location)
-	data := catalog.EncodeBlockInfo(info)
-	info2 := catalog.DecodeBlockInfo(data)
+	data := objectio.EncodeBlockInfo(info)
+	info2 := objectio.DecodeBlockInfo(data)
 	require.Equal(t, info, *info2)
 }
 
@@ -827,7 +826,7 @@ func TestForeachBlkInObjStatsList(t *testing.T) {
 	statsList := mockStatsList(t, 100)
 
 	count := 0
-	ForeachBlkInObjStatsList(false, nil, func(blk *catalog.BlockInfo) bool {
+	ForeachBlkInObjStatsList(false, nil, func(blk *objectio.BlockInfo) bool {
 		count++
 		return false
 	}, statsList...)
@@ -835,7 +834,7 @@ func TestForeachBlkInObjStatsList(t *testing.T) {
 	require.Equal(t, count, 1)
 
 	count = 0
-	ForeachBlkInObjStatsList(true, nil, func(blk *catalog.BlockInfo) bool {
+	ForeachBlkInObjStatsList(true, nil, func(blk *objectio.BlockInfo) bool {
 		count++
 		return false
 	}, statsList...)
@@ -843,7 +842,7 @@ func TestForeachBlkInObjStatsList(t *testing.T) {
 	require.Equal(t, count, len(statsList))
 
 	count = 0
-	ForeachBlkInObjStatsList(true, nil, func(blk *catalog.BlockInfo) bool {
+	ForeachBlkInObjStatsList(true, nil, func(blk *objectio.BlockInfo) bool {
 		count++
 		return true
 	}, statsList...)
@@ -856,7 +855,7 @@ func TestForeachBlkInObjStatsList(t *testing.T) {
 	require.Equal(t, count, 0)
 
 	count = 0
-	ForeachBlkInObjStatsList(false, nil, func(blk *catalog.BlockInfo) bool {
+	ForeachBlkInObjStatsList(false, nil, func(blk *objectio.BlockInfo) bool {
 		count++
 		return true
 	}, statsList...)
diff --git a/pkg/vm/engine/entire_engine_test.go b/pkg/vm/engine/entire_engine_test.go
index cc34c0c74..e15e3b4b7 100644
--- a/pkg/vm/engine/entire_engine_test.go
+++ b/pkg/vm/engine/entire_engine_test.go
@@ -269,7 +269,7 @@ func (e *testEngine) Hints() (h Hints) {
 }
 
 func (e *testEngine) NewBlockReader(_ context.Context, _ int, _ timestamp.Timestamp,
-	_ *plan.Expr, _ [][]byte, _ *plan.TableDef, proc any) ([]Reader, error) {
+	_ *plan.Expr, _ []byte, _ *plan.TableDef, proc any) ([]Reader, error) {
 	e.parent.step = e.parent.step + 1
 	if e.name == origin {
 		e.parent.state = e.parent.state + e.parent.step*e.parent.state
diff --git a/pkg/vm/engine/tae/db/test/db_test.go b/pkg/vm/engine/tae/db/test/db_test.go
index 4d2fb9569..47871b21f 100644
--- a/pkg/vm/engine/tae/db/test/db_test.go
+++ b/pkg/vm/engine/tae/db/test/db_test.go
@@ -4956,7 +4956,7 @@ func TestBlockRead(t *testing.T) {
 
 	bid, sid := blkEntry.ID, blkEntry.GetObject().ID
 
-	info := &pkgcatalog.BlockInfo{
+	info := &objectio.BlockInfo{
 		BlockID:    bid,
 		SegmentID:  *sid.Segment(),
 		EntryState: true,
@@ -4978,8 +4978,8 @@ func TestBlockRead(t *testing.T) {
 	fs := tae.DB.Runtime.Fs.Service
 	pool, err := mpool.NewMPool("test", 0, mpool.NoFixed)
 	assert.NoError(t, err)
-	infos := make([][]*pkgcatalog.BlockInfo, 0)
-	infos = append(infos, []*pkgcatalog.BlockInfo{info})
+	infos := make([][]*objectio.BlockInfo, 0)
+	infos = append(infos, []*objectio.BlockInfo{info})
 	err = blockio.BlockPrefetch(colIdxs, fs, infos, false)
 	assert.NoError(t, err)
 	b1, err := blockio.BlockReadInner(