Repository: matrixorigin/matrixone
Pull request #3235 (2022-06-23 03:36:10)

fix various bugs in tpch, add cast from decimal to float double
**What type of PR is this?**

- [ ] API-change
- [x] BUG
- [ ] Improvement
- [ ] Documentation
- [ ] Feature
- [ ] Test and CI
- [ ] Code Refactoring

**Which issue(s) this PR fixes:**

issue #3233 

**What this PR does / why we need it:**

Not Available

**Special notes for your reviewer:**

Not Available

**Additional documentation (e.g. design docs, usage docs, etc.):**

Not Available


broccoliSpicy: > float32 len 8 --> 4
> 
> others are good.



> float32 len 8 --> 4
> 
> others are good.

fixed

Patch:
diff --git a/pkg/compare/asc/decimal128s/compare.go b/pkg/compare/asc/decimal128s/compare.go
index 8f93eb116..016bf217b 100644
--- a/pkg/compare/asc/decimal128s/compare.go
+++ b/pkg/compare/asc/decimal128s/compare.go
@@ -41,7 +41,7 @@ func (c *compare) Set(idx int, v *vector.Vector) {
 
 // Compare method for decimal needs to know the decimal's scale, so we need to fill in the c.vs field before using this function
 func (c *compare) Compare(veci, vecj int, vi, vj int64) int {
-	return int(types.CompareDecimal128Decimal128(c.xs[veci][vi], c.xs[vecj][vj], c.vs[0].Typ.Scale, c.vs[1].Typ.Scale))
+	return int(types.CompareDecimal128Decimal128(c.xs[veci][vi], c.xs[vecj][vj], c.vs[veci].Typ.Scale, c.vs[vecj].Typ.Scale))
 }
 
 func (c *compare) Copy(vecSrc, vecDst int, src, dst int64, _ *process.Process) error {
diff --git a/pkg/compare/asc/decimal64s/compare.go b/pkg/compare/asc/decimal64s/compare.go
index 5e0ad35d3..76d23a73f 100644
--- a/pkg/compare/asc/decimal64s/compare.go
+++ b/pkg/compare/asc/decimal64s/compare.go
@@ -41,7 +41,7 @@ func (c *compare) Set(idx int, v *vector.Vector) {
 
 // Compare method for decimal needs to know the decimal's scale, so we need to fill in the c.vs field before using this function
 func (c *compare) Compare(veci, vecj int, vi, vj int64) int {
-	return int(types.CompareDecimal64Decimal64(c.xs[veci][vi], c.xs[vecj][vj], c.vs[0].Typ.Scale, c.vs[1].Typ.Scale))
+	return int(types.CompareDecimal64Decimal64(c.xs[veci][vi], c.xs[vecj][vj], c.vs[veci].Typ.Scale, c.vs[vecj].Typ.Scale))
 }
 
 func (c *compare) Copy(vecSrc, vecDst int, src, dst int64, _ *process.Process) error {
diff --git a/pkg/compare/desc/decimal128s/compare.go b/pkg/compare/desc/decimal128s/compare.go
index cac649037..5d99c519e 100644
--- a/pkg/compare/desc/decimal128s/compare.go
+++ b/pkg/compare/desc/decimal128s/compare.go
@@ -1,3 +1,17 @@
+// Copyright 2021 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 decimal128s
 
 import (
@@ -27,7 +41,7 @@ func (c *compare) Set(idx int, v *vector.Vector) {
 
 // Compare method for decimal needs to know the decimal's scale, so we need to fill in the c.vs field before using this function
 func (c *compare) Compare(veci, vecj int, vi, vj int64) int {
-	return -int(types.CompareDecimal128Decimal128(c.xs[veci][vi], c.xs[vecj][vj], c.vs[0].Typ.Scale, c.vs[1].Typ.Scale))
+	return -int(types.CompareDecimal128Decimal128(c.xs[veci][vi], c.xs[vecj][vj], c.vs[veci].Typ.Scale, c.vs[vecj].Typ.Scale))
 }
 
 func (c *compare) Copy(vecSrc, vecDst int, src, dst int64, _ *process.Process) error {
diff --git a/pkg/compare/desc/decimal128s/types.go b/pkg/compare/desc/decimal128s/types.go
index 026de3ff5..85476621c 100644
--- a/pkg/compare/desc/decimal128s/types.go
+++ b/pkg/compare/desc/decimal128s/types.go
@@ -1,3 +1,17 @@
+// Copyright 2021 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 decimal128s
 
 import (
diff --git a/pkg/compare/desc/decimal64s/compare.go b/pkg/compare/desc/decimal64s/compare.go
index f2cab9baf..d11570a8d 100644
--- a/pkg/compare/desc/decimal64s/compare.go
+++ b/pkg/compare/desc/decimal64s/compare.go
@@ -1,3 +1,17 @@
+// Copyright 2021 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 decimal64s
 
 import (
@@ -27,7 +41,7 @@ func (c *compare) Set(idx int, v *vector.Vector) {
 
 // Compare method for decimal needs to know the decimal's scale, so we need to fill in the c.vs field before using this function
 func (c *compare) Compare(veci, vecj int, vi, vj int64) int {
-	return -int(types.CompareDecimal64Decimal64(c.xs[veci][vi], c.xs[vecj][vj], c.vs[0].Typ.Scale, c.vs[1].Typ.Scale))
+	return -int(types.CompareDecimal64Decimal64(c.xs[veci][vi], c.xs[vecj][vj], c.vs[veci].Typ.Scale, c.vs[vecj].Typ.Scale))
 }
 
 func (c *compare) Copy(vecSrc, vecDst int, src, dst int64, _ *process.Process) error {
diff --git a/pkg/compare/desc/decimal64s/types.go b/pkg/compare/desc/decimal64s/types.go
index 1bff296cf..b13266ca7 100644
--- a/pkg/compare/desc/decimal64s/types.go
+++ b/pkg/compare/desc/decimal64s/types.go
@@ -1,3 +1,17 @@
+// Copyright 2021 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 decimal64s
 
 import (
diff --git a/pkg/container/types/types.go b/pkg/container/types/types.go
index 6ed751646..3aa1b806b 100644
--- a/pkg/container/types/types.go
+++ b/pkg/container/types/types.go
@@ -364,6 +364,7 @@ func (t T) TypeLen() int {
 	panic(moerr.NewInternalError("Unknow type %s", t))
 }
 
+// dangerous code, use TypeLen() if you don't want -8, -16, -24
 func (t T) FixedLength() int {
 	switch t {
 	case T_int8, T_uint8, T_bool:
diff --git a/pkg/container/vector/vector.go b/pkg/container/vector/vector.go
index 4df64aa13..658659c04 100644
--- a/pkg/container/vector/vector.go
+++ b/pkg/container/vector/vector.go
@@ -2025,7 +2025,7 @@ func UnionOne(v, w *Vector, sel int64, m *mheap.Mheap) error {
 	return nil
 }
 
-func UnionNull(v, w *Vector, m *mheap.Mheap) error {
+func UnionNull(v, _ *Vector, m *mheap.Mheap) error {
 	if v.Or {
 		return errors.New("UnionNull operation cannot be performed for origin vector")
 	}
@@ -2042,7 +2042,6 @@ func UnionNull(v, w *Vector, m *mheap.Mheap) error {
 			if err != nil {
 				return err
 			}
-			v.Ref = w.Ref
 			vs := encoding.DecodeBoolSlice(data)
 			v.Col = vs[:1]
 			v.Data = data
@@ -2068,7 +2067,6 @@ func UnionNull(v, w *Vector, m *mheap.Mheap) error {
 			if err != nil {
 				return err
 			}
-			v.Ref = w.Ref
 			vs := encoding.DecodeInt8Slice(data)
 			v.Col = vs[:1]
 			v.Data = data
@@ -2095,7 +2093,6 @@ func UnionNull(v, w *Vector, m *mheap.Mheap) error {
 			if err != nil {
 				return err
 			}
-			v.Ref = w.Ref
 			vs := encoding.DecodeInt16Slice(data)
 			v.Col = vs[:1]
 			v.Data = data
@@ -2122,7 +2119,6 @@ func UnionNull(v, w *Vector, m *mheap.Mheap) error {
 			if err != nil {
 				return err
 			}
-			v.Ref = w.Ref
 			vs := encoding.DecodeInt32Slice(data)
 			v.Col = vs[:1]
 			v.Data = data
@@ -2149,7 +2145,6 @@ func UnionNull(v, w *Vector, m *mheap.Mheap) error {
 			if err != nil {
 				return err
 			}
-			v.Ref = w.Ref
 			vs := encoding.DecodeInt64Slice(data)
 			v.Col = vs[:1]
 			v.Data = data
@@ -2176,7 +2171,6 @@ func UnionNull(v, w *Vector, m *mheap.Mheap) error {
 			if err != nil {
 				return err
 			}
-			v.Ref = w.Ref
 			vs := encoding.DecodeUint8Slice(data)
 			v.Col = vs[:1]
 			v.Data = data
@@ -2203,7 +2197,6 @@ func UnionNull(v, w *Vector, m *mheap.Mheap) error {
 			if err != nil {
 				return err
 			}
-			v.Ref = w.Ref
 			vs := encoding.DecodeUint16Slice(data)
 			v.Col = vs[:1]
 			v.Data = data
@@ -2230,7 +2223,6 @@ func UnionNull(v, w *Vector, m *mheap.Mheap) error {
 			if err != nil {
 				return err
 			}
-			v.Ref = w.Ref
 			vs := encoding.DecodeUint32Slice(data)
 			v.Col = vs[:1]
 			v.Data = data
@@ -2257,7 +2249,6 @@ func UnionNull(v, w *Vector, m *mheap.Mheap) error {
 			if err != nil {
 				return err
 			}
-			v.Ref = w.Ref
 			vs := encoding.DecodeUint64Slice(data)
 			v.Col = vs[:1]
 			v.Data = data
@@ -2284,7 +2275,6 @@ func UnionNull(v, w *Vector, m *mheap.Mheap) error {
 			if err != nil {
 				return err
 			}
-			v.Ref = w.Ref
 			vs := encoding.DecodeFloat32Slice(data)
 			v.Col = vs[:1]
 			v.Data = data
@@ -2311,7 +2301,6 @@ func UnionNull(v, w *Vector, m *mheap.Mheap) error {
 			if err != nil {
 				return err
 			}
-			v.Ref = w.Ref
 			vs := encoding.DecodeFloat64Slice(data)
 			v.Col = vs[:1]
 			v.Data = data
@@ -2343,7 +2332,6 @@ func UnionNull(v, w *Vector, m *mheap.Mheap) error {
 			if err != nil {
 				return err
 			}
-			v.Ref = w.Ref
 			vs := encoding.DecodeDateSlice(data)
 			v.Col = vs[:1]
 			v.Data = data
@@ -2370,7 +2358,6 @@ func UnionNull(v, w *Vector, m *mheap.Mheap) error {
 			if err != nil {
 				return err
 			}
-			v.Ref = w.Ref
 			vs := encoding.DecodeDatetimeSlice(data)
 			v.Col = vs[:1]
 			v.Data = data
@@ -2397,7 +2384,6 @@ func UnionNull(v, w *Vector, m *mheap.Mheap) error {
 			if err != nil {
 				return err
 			}
-			v.Ref = w.Ref
 			vs := encoding.DecodeTimestampSlice(data)
 			v.Col = vs[:1]
 			v.Data = data
@@ -2424,7 +2410,6 @@ func UnionNull(v, w *Vector, m *mheap.Mheap) error {
 			if err != nil {
 				return err
 			}
-			v.Ref = w.Ref
 			vs := encoding.DecodeDecimal64Slice(data)
 			v.Col = vs[:1]
 			v.Data = data
@@ -2451,7 +2436,6 @@ func UnionNull(v, w *Vector, m *mheap.Mheap) error {
 			if err != nil {
 				return err
 			}
-			v.Ref = w.Ref
 			vs := encoding.DecodeDecimal128Slice(data)
 			v.Col = vs[:1]
 			v.Data = data
diff --git a/pkg/hakeeper/checkers/logservice/checker.go b/pkg/hakeeper/checkers/logservice/checker.go
index 10012f5da..cef609ec2 100644
--- a/pkg/hakeeper/checkers/logservice/checker.go
+++ b/pkg/hakeeper/checkers/logservice/checker.go
@@ -166,13 +166,13 @@ func Check(alloc util.IDAllocator, cluster hapb.ClusterInfo, infos hapb.LogState
 
 	for _, toStart := range stats.toStart {
 		operators = append(operators, operator.NewOperator("", toStart.shardID, toStart.epoch,
-			operator.StartLogService{UUID: toStart.uuid, ShardID: toStart.shardID,
+			operator.StartLogService{StoreID: toStart.uuid, ShardID: toStart.shardID,
 				ReplicaID: toStart.replicaID}))
 	}
 
 	for _, toStop := range stats.toStop {
 		operators = append(operators, operator.NewOperator("", toStop.shardID, toStop.epoch,
-			operator.StopLogService{UUID: toStop.uuid, ShardID: toStop.shardID}))
+			operator.StopLogService{StoreID: toStop.uuid, ShardID: toStop.shardID}))
 	}
 
 	return operators
diff --git a/pkg/hakeeper/operator/builder.go b/pkg/hakeeper/operator/builder.go
index 68f8052e3..d0c130c73 100644
--- a/pkg/hakeeper/operator/builder.go
+++ b/pkg/hakeeper/operator/builder.go
@@ -24,6 +24,7 @@ import (
 	"errors"
 	"fmt"
 	"github.com/matrixorigin/matrixone/pkg/pb/logservice"
+	"sort"
 )
 
 // Builder is used to create operators. Usage:
@@ -151,15 +152,38 @@ func (b *Builder) prepareBuild() string {
 
 func (b *Builder) buildSteps() error {
 	for len(b.toRemove) > 0 {
+		var targets []string
+		for target := range b.targetPeers {
+			targets = append(targets, target)
+		}
+		sort.Slice(targets, func(i, j int) bool { return targets[i] < targets[j] })
+
 		uuid, replicaID := b.toRemove.Get()
-		b.steps = append(b.steps, RemoveLogService{UUID: uuid, ShardID: b.shardID, ReplicaID: replicaID})
+		b.steps = append(b.steps, RemoveLogService{
+			Target:    targets[0],
+			StoreID:   uuid,
+			ShardID:   b.shardID,
+			ReplicaID: replicaID,
+		})
 		delete(b.toRemove, uuid)
 		continue
 	}
 
 	for len(b.toAdd) > 0 {
+		var targets []string
+		for target := range b.originPeers {
+			targets = append(targets, target)
+		}
+		sort.Slice(targets, func(i, j int) bool { return targets[i] < targets[j] })
+
 		uuid, replicaID := b.toAdd.Get()
-		b.steps = append(b.steps, AddLogService{UUID: uuid, ShardID: b.shardID, ReplicaID: replicaID, Epoch: b.epoch})
+		b.steps = append(b.steps, AddLogService{
+			Target:    targets[0],
+			StoreID:   uuid,
+			ShardID:   b.shardID,
+			ReplicaID: replicaID,
+			Epoch:     b.epoch,
+		})
 		delete(b.toAdd, uuid)
 	}
 
diff --git a/pkg/hakeeper/operator/controller.go b/pkg/hakeeper/operator/controller.go
index bc6b00c92..7e4af0bba 100644
--- a/pkg/hakeeper/operator/controller.go
+++ b/pkg/hakeeper/operator/controller.go
@@ -117,9 +117,10 @@ func (c *Controller) Dispatch(ops []*Operator, logState hakeeper.LogState, dnSta
 		switch st := step.(type) {
 		case AddLogService:
 			cmd = hakeeper.ScheduleCommand{
-				UUID: st.UUID,
+				UUID: st.Target,
 				ConfigChange: hakeeper.ConfigChange{
 					Replica: hakeeper.Replica{
+						UUID:      st.StoreID,
 						ShardID:   st.ShardID,
 						ReplicaID: st.ReplicaID,
 						Epoch:     st.Epoch,
@@ -130,9 +131,10 @@ func (c *Controller) Dispatch(ops []*Operator, logState hakeeper.LogState, dnSta
 			}
 		case RemoveLogService:
 			cmd = hakeeper.ScheduleCommand{
-				UUID: st.UUID,
+				UUID: st.Target,
 				ConfigChange: hakeeper.ConfigChange{
 					Replica: hakeeper.Replica{
+						UUID:      st.StoreID,
 						ShardID:   st.ShardID,
 						ReplicaID: st.ReplicaID,
 					},
@@ -142,9 +144,10 @@ func (c *Controller) Dispatch(ops []*Operator, logState hakeeper.LogState, dnSta
 			}
 		case StartLogService:
 			cmd = hakeeper.ScheduleCommand{
-				UUID: st.UUID,
+				UUID: st.StoreID,
 				ConfigChange: hakeeper.ConfigChange{
 					Replica: hakeeper.Replica{
+						UUID:      st.StoreID,
 						ShardID:   st.ShardID,
 						ReplicaID: st.ReplicaID,
 					},
@@ -154,9 +157,12 @@ func (c *Controller) Dispatch(ops []*Operator, logState hakeeper.LogState, dnSta
 			}
 		case StopLogService:
 			cmd = hakeeper.ScheduleCommand{
-				UUID: st.UUID,
+				UUID: st.StoreID,
 				ConfigChange: hakeeper.ConfigChange{
-					Replica:    hakeeper.Replica{ShardID: st.ShardID},
+					Replica: hakeeper.Replica{
+						UUID:    st.StoreID,
+						ShardID: st.ShardID,
+					},
 					ChangeType: hakeeper.StopReplica,
 				},
 				ServiceType: hakeeper.LogService,
@@ -166,6 +172,7 @@ func (c *Controller) Dispatch(ops []*Operator, logState hakeeper.LogState, dnSta
 				UUID: st.StoreID,
 				ConfigChange: hakeeper.ConfigChange{
 					Replica: hakeeper.Replica{
+						UUID:      st.StoreID,
 						ShardID:   st.ShardID,
 						ReplicaID: st.ReplicaID,
 					},
@@ -178,6 +185,7 @@ func (c *Controller) Dispatch(ops []*Operator, logState hakeeper.LogState, dnSta
 				UUID: st.StoreID,
 				ConfigChange: hakeeper.ConfigChange{
 					Replica: hakeeper.Replica{
+						UUID:      st.StoreID,
 						ShardID:   st.ShardID,
 						ReplicaID: st.ReplicaID,
 					},
diff --git a/pkg/hakeeper/operator/steps.go b/pkg/hakeeper/operator/steps.go
index e2040662c..b8ada82e7 100644
--- a/pkg/hakeeper/operator/steps.go
+++ b/pkg/hakeeper/operator/steps.go
@@ -33,14 +33,14 @@ type OpStep interface {
 }
 
 type AddLogService struct {
-	UUID                      string
-	ShardID, ReplicaID, Epoch uint64
+	Target string
 
-	tick uint64
+	StoreID                   string
+	ShardID, ReplicaID, Epoch uint64
 }
 
 func (a AddLogService) String() string {
-	return fmt.Sprintf("adding %v:%v(at epoch %v) to %s", a.ShardID, a.ReplicaID, a.Epoch, a.UUID)
+	return fmt.Sprintf("adding %v:%v(at epoch %v) to %s", a.ShardID, a.ReplicaID, a.Epoch, a.StoreID)
 }
 
 func (a AddLogService) IsFinish(state hakeeper.LogState, _ hakeeper.DNState) bool {
@@ -55,12 +55,14 @@ func (a AddLogService) IsFinish(state hakeeper.LogState, _ hakeeper.DNState) boo
 }
 
 type RemoveLogService struct {
-	UUID               string
+	Target string
+
+	StoreID            string
 	ShardID, ReplicaID uint64
 }
 
 func (a RemoveLogService) String() string {
-	return fmt.Sprintf("removing %v:%v on log store %s", a.ShardID, a.ReplicaID, a.UUID)
+	return fmt.Sprintf("removing %v:%v on log store %s", a.ShardID, a.ReplicaID, a.StoreID)
 }
 
 func (a RemoveLogService) IsFinish(state hakeeper.LogState, _ hakeeper.DNState) bool {
@@ -74,19 +76,19 @@ func (a RemoveLogService) IsFinish(state hakeeper.LogState, _ hakeeper.DNState)
 }
 
 type StartLogService struct {
-	UUID               string
+	StoreID            string
 	ShardID, ReplicaID uint64
 }
 
 func (a StartLogService) String() string {
-	return fmt.Sprintf("starting %v:%v on %s", a.ShardID, a.ReplicaID, a.UUID)
+	return fmt.Sprintf("starting %v:%v on %s", a.ShardID, a.ReplicaID, a.StoreID)
 }
 
 func (a StartLogService) IsFinish(state hakeeper.LogState, _ hakeeper.DNState) bool {
-	if _, ok := state.Stores[a.UUID]; !ok {
+	if _, ok := state.Stores[a.StoreID]; !ok {
 		return true
 	}
-	for _, replicaInfo := range state.Stores[a.UUID].Replicas {
+	for _, replicaInfo := range state.Stores[a.StoreID].Replicas {
 		if replicaInfo.ShardID == a.ShardID {
 			return true
 		}
@@ -96,16 +98,16 @@ func (a StartLogService) IsFinish(state hakeeper.LogState, _ hakeeper.DNState) b
 }
 
 type StopLogService struct {
-	UUID    string
+	StoreID string
 	ShardID uint64
 }
 
 func (a StopLogService) String() string {
-	return fmt.Sprintf("stoping %v on %s", a.ShardID, a.UUID)
+	return fmt.Sprintf("stoping %v on %s", a.ShardID, a.StoreID)
 }
 
 func (a StopLogService) IsFinish(state hakeeper.LogState, _ hakeeper.DNState) bool {
-	if store, ok := state.Stores[a.UUID]; ok {
+	if store, ok := state.Stores[a.StoreID]; ok {
 		for _, replicaInfo := range store.Replicas {
 			if replicaInfo.ShardID == a.ShardID {
 				return false
diff --git a/pkg/logservice/commands.go b/pkg/logservice/commands.go
new file mode 100644
index 000000000..7cd49c7d1
--- /dev/null
+++ b/pkg/logservice/commands.go
@@ -0,0 +1,72 @@
+// Copyright 2021 - 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 logservice
+
+import (
+	"github.com/matrixorigin/matrixone/pkg/hakeeper"
+	hapb "github.com/matrixorigin/matrixone/pkg/pb/hakeeper"
+)
+
+func (s *Service) handleCommands(cmds []hapb.ScheduleCommand) {
+	for _, cmd := range cmds {
+		switch cmd.ConfigChange.ChangeType {
+		case hapb.AddReplica:
+			s.handleAddReplica(cmd)
+		case hapb.RemoveReplica:
+			s.handleRemoveReplica(cmd)
+		case hapb.StartReplica:
+			s.handleStartReplica(cmd)
+		case hapb.StopReplica:
+			s.handleStopReplica(cmd)
+		default:
+			panic("unknown type")
+		}
+	}
+}
+
+func (s *Service) handleAddReplica(cmd hapb.ScheduleCommand) {
+	panic("not implemented due to the lack of target UUID in ScheduleCommand")
+}
+
+func (s *Service) handleRemoveReplica(cmd hapb.ScheduleCommand) {
+	shardID := cmd.ConfigChange.Replica.ShardID
+	replicaID := cmd.ConfigChange.Replica.ReplicaID
+	epoch := cmd.ConfigChange.Replica.Epoch
+	if err := s.store.removeReplica(shardID, replicaID, epoch); err != nil {
+		plog.Errorf("failed to remove replica %v", err)
+	}
+}
+
+func (s *Service) handleStartReplica(cmd hapb.ScheduleCommand) {
+	shardID := cmd.ConfigChange.Replica.ShardID
+	replicaID := cmd.ConfigChange.Replica.ReplicaID
+	if shardID == hakeeper.DefaultHAKeeperShardID {
+		if err := s.store.StartHAKeeperReplica(replicaID, nil, false); err != nil {
+			plog.Errorf("failed to start log replica %v", err)
+		}
+	} else {
+		if err := s.store.StartReplica(shardID, replicaID, nil, false); err != nil {
+			plog.Errorf("failed to start log replica %v", err)
+		}
+	}
+}
+
+func (s *Service) handleStopReplica(cmd hapb.ScheduleCommand) {
+	shardID := cmd.ConfigChange.Replica.ShardID
+	replicaID := cmd.ConfigChange.Replica.ReplicaID
+	if err := s.store.stopReplica(shardID, replicaID); err != nil {
+		plog.Errorf("failed to stop replica %v", err)
+	}
+}
diff --git a/pkg/logservice/hachecker.go b/pkg/logservice/hachecker.go
index d992c8ccb..7834c27e3 100644
--- a/pkg/logservice/hachecker.go
+++ b/pkg/logservice/hachecker.go
@@ -64,7 +64,7 @@ func (a *idAllocator) Capacity() uint64 {
 	return 0
 }
 
-func (l *logStore) updateIDAlloc(count uint64) error {
+func (l *store) updateIDAlloc(count uint64) error {
 	cmd := hakeeper.GetGetIDCmd(count)
 	ctx, cancel := context.WithTimeout(context.Background(), hakeeperDefaultTimeout)
 	defer cancel()
@@ -79,7 +79,7 @@ func (l *logStore) updateIDAlloc(count uint64) error {
 	return nil
 }
 
-func (l *logStore) healthCheck() {
+func (l *store) healthCheck() {
 	leaderID, term, ok, err := l.nh.GetLeaderID(hakeeper.DefaultHAKeeperShardID)
 	if err != nil {
 		plog.Errorf("failed to get HAKeeper Leader ID, %v", err)
diff --git a/pkg/logservice/service.go b/pkg/logservice/service.go
index deedc81ec..3a2afd62b 100644
--- a/pkg/logservice/service.go
+++ b/pkg/logservice/service.go
@@ -43,7 +43,7 @@ type LogRecord = pb.LogRecord
 // be considered as the interface layer of the LogService.
 type Service struct {
 	cfg         Config
-	store       *logStore
+	store       *store
 	stopper     *syncutil.Stopper
 	connStopper *syncutil.Stopper
 }
diff --git a/pkg/logservice/shardinfo.go b/pkg/logservice/shardinfo.go
index 1dd0316e5..9ff374047 100644
--- a/pkg/logservice/shardinfo.go
+++ b/pkg/logservice/shardinfo.go
@@ -52,7 +52,7 @@ func (s *Service) GetShardInfo(shardID uint64) (ShardInfo, bool) {
 		if !ok {
 			return ShardInfo{}, false
 		}
-		var md logStoreMeta
+		var md storeMeta
 		md.unmarshal(data)
 		result.Replicas[nodeID] = ReplicaInfo{
 			UUID:           uuid,
diff --git a/pkg/logservice/store.go b/pkg/logservice/store.go
index ee83892fd..aac1fa806 100644
--- a/pkg/logservice/store.go
+++ b/pkg/logservice/store.go
@@ -40,20 +40,20 @@ var (
 	ErrOutOfRange = dragonboat.ErrInvalidRange
 )
 
-type logStoreMeta struct {
+type storeMeta struct {
 	serviceAddress string
 }
 
-func (l *logStoreMeta) marshal() []byte {
+func (l *storeMeta) marshal() []byte {
 	return []byte(l.serviceAddress)
 }
 
-func (l *logStoreMeta) unmarshal(data []byte) {
+func (l *storeMeta) unmarshal(data []byte) {
 	l.serviceAddress = string(data)
 }
 
 func getNodeHostConfig(cfg Config) config.NodeHostConfig {
-	meta := logStoreMeta{
+	meta := storeMeta{
 		serviceAddress: cfg.ServiceAddress,
 	}
 	return config.NodeHostConfig{
@@ -91,8 +91,8 @@ func getRaftConfig(shardID uint64, replicaID uint64) config.Config {
 	}
 }
 
-// logStore manages log shards including the HAKeeper shard on each node.
-type logStore struct {
+// store manages log shards including the HAKeeper shard on each node.
+type store struct {
 	cfg               Config
 	nh                *dragonboat.NodeHost
 	haKeeperReplicaID uint64
@@ -107,14 +107,14 @@ type logStore struct {
 	}
 }
 
-func newLogStore(cfg Config) (*logStore, error) {
+func newLogStore(cfg Config) (*store, error) {
 	plog.Infof("creating nodehost")
 	nh, err := dragonboat.NewNodeHost(getNodeHostConfig(cfg))
 	plog.Infof("create nodehost returned")
 	if err != nil {
 		return nil, err
 	}
-	ls := &logStore{
+	ls := &store{
 		cfg:     cfg,
 		nh:      nh,
 		alloc:   newIDAllocator(),
@@ -128,7 +128,7 @@ func newLogStore(cfg Config) (*logStore, error) {
 	return ls, nil
 }
 
-func (l *logStore) Close() error {
+func (l *store) Close() error {
 	l.stopper.Stop()
 	if l.nh != nil {
 		l.nh.Close()
@@ -136,17 +136,16 @@ func (l *logStore) Close() error {
 	return nil
 }
 
-func (l *logStore) ID() string {
+func (l *store) ID() string {
 	return l.nh.ID()
 }
 
-func (l *logStore) StartHAKeeperReplica(replicaID uint64,
-	initialReplicas map[uint64]dragonboat.Target) error {
+func (l *store) StartHAKeeperReplica(replicaID uint64,
+	initialReplicas map[uint64]dragonboat.Target, join bool) error {
 	l.haKeeperReplicaID = replicaID
 	raftConfig := getRaftConfig(hakeeper.DefaultHAKeeperShardID, replicaID)
-	// TODO: add another API for joining
 	if err := l.nh.StartReplica(initialReplicas,
-		false, hakeeper.NewStateMachine, raftConfig); err != nil {
+		join, hakeeper.NewStateMachine, raftConfig); err != nil {
 		return err
 	}
 	l.stopper.RunWorker(func() {
@@ -155,24 +154,70 @@ func (l *logStore) StartHAKeeperReplica(replicaID uint64,
 	return nil
 }
 
-func (l *logStore) StartReplica(shardID uint64, replicaID uint64,
-	initialReplicas map[uint64]dragonboat.Target) error {
+func (l *store) StartReplica(shardID uint64, replicaID uint64,
+	initialReplicas map[uint64]dragonboat.Target, join bool) error {
 	if shardID == hakeeper.DefaultHAKeeperShardID {
 		return ErrInvalidShardID
 	}
 	raftConfig := getRaftConfig(shardID, replicaID)
-	// TODO: add another API for joining
-	return l.nh.StartReplica(initialReplicas, false, newStateMachine, raftConfig)
+	return l.nh.StartReplica(initialReplicas, join, newStateMachine, raftConfig)
 }
 
-func (l *logStore) addReplica(shardID uint64, replicaID uint64,
+func (l *store) stopReplica(shardID uint64, replicaID uint64) error {
+	// FIXME: stop the hakeeper ticker when the replica being stopped
+	// is a hakeeper replica
+	return l.nh.StopReplica(shardID, replicaID)
+}
+
+func (l *store) addReplica(shardID uint64, replicaID uint64,
 	target dragonboat.Target, cci uint64) error {
 	ctx, cancel := context.WithTimeout(context.Background(), time.Second)
 	defer cancel()
-	return l.nh.SyncRequestAddReplica(ctx, shardID, replicaID, target, cci)
+	count := 0
+	for {
+		count++
+		if err := l.nh.SyncRequestAddReplica(ctx, shardID, replicaID, target, cci); err != nil {
+			if errors.Is(err, dragonboat.ErrShardNotReady) {
+				l.retryWait()
+				continue
+			}
+			if errors.Is(err, dragonboat.ErrTimeoutTooSmall) && count > 1 {
+				return dragonboat.ErrTimeout
+			}
+			return err
+		}
+		return nil
+	}
+}
+
+func (l *store) removeReplica(shardID uint64, replicaID uint64, cci uint64) error {
+	ctx, cancel := context.WithTimeout(context.Background(), time.Second)
+	defer cancel()
+	count := 0
+	for {
+		count++
+		if err := l.nh.SyncRequestDeleteReplica(ctx, shardID, replicaID, cci); err != nil {
+			if errors.Is(err, dragonboat.ErrShardNotReady) {
+				l.retryWait()
+				continue
+			}
+			if errors.Is(err, dragonboat.ErrTimeoutTooSmall) && count > 1 {
+				return dragonboat.ErrTimeout
+			}
+			return err
+		}
+		return nil
+	}
+}
+
+func (l *store) retryWait() {
+	if l.nh.NodeHostConfig().RTTMillisecond == 1 {
+		time.Sleep(time.Millisecond)
+	}
+	time.Sleep(time.Duration(l.nh.NodeHostConfig().RTTMillisecond/2) * time.Millisecond)
 }
 
-func (l *logStore) propose(ctx context.Context,
+func (l *store) propose(ctx context.Context,
 	session *cli.Session, cmd []byte) (sm.Result, error) {
 	count := 0
 	for {
@@ -180,7 +225,7 @@ func (l *logStore) propose(ctx context.Context,
 		result, err := l.nh.SyncPropose(ctx, session, cmd)
 		if err != nil {
 			if errors.Is(err, dragonboat.ErrShardNotReady) {
-				time.Sleep(time.Duration(l.nh.NodeHostConfig().RTTMillisecond) * time.Millisecond)
+				l.retryWait()
 				continue
 			}
 			if errors.Is(err, dragonboat.ErrTimeoutTooSmall) && count > 1 {
@@ -192,7 +237,7 @@ func (l *logStore) propose(ctx context.Context,
 	}
 }
 
-func (l *logStore) read(ctx context.Context,
+func (l *store) read(ctx context.Context,
 	shardID uint64, query interface{}) (interface{}, error) {
 	count := 0
 	for {
@@ -200,7 +245,7 @@ func (l *logStore) read(ctx context.Context,
 		result, err := l.nh.SyncRead(ctx, shardID, query)
 		if err != nil {
 			if errors.Is(err, dragonboat.ErrShardNotReady) {
-				time.Sleep(time.Duration(l.nh.NodeHostConfig().RTTMillisecond) * time.Millisecond)
+				l.retryWait()
 				continue
 			}
 			if errors.Is(err, dragonboat.ErrTimeoutTooSmall) && count > 1 {
@@ -212,7 +257,7 @@ func (l *logStore) read(ctx context.Context,
 	}
 }
 
-func (l *logStore) GetOrExtendDNLease(ctx context.Context,
+func (l *store) GetOrExtendDNLease(ctx context.Context,
 	shardID uint64, dnID uint64) error {
 	session := l.nh.GetNoOPSession(shardID)
 	cmd := getSetLeaseHolderCmd(dnID)
@@ -220,7 +265,7 @@ func (l *logStore) GetOrExtendDNLease(ctx context.Context,
 	return err
 }
 
-func (l *logStore) TruncateLog(ctx context.Context,
+func (l *store) TruncateLog(ctx context.Context,
 	shardID uint64, index Lsn) error {
 	session := l.nh.GetNoOPSession(shardID)
 	cmd := getSetTruncatedIndexCmd(index)
@@ -240,7 +285,7 @@ func (l *logStore) TruncateLog(ctx context.Context,
 	return nil
 }
 
-func (l *logStore) Append(ctx context.Context,
+func (l *store) Append(ctx context.Context,
 	shardID uint64, cmd []byte) (Lsn, error) {
 	if !isUserUpdate(cmd) {
 		panic(moerr.NewError(moerr.INVALID_INPUT, "not user update"))
@@ -262,7 +307,7 @@ func (l *logStore) Append(ctx context.Context,
 	return result.Value, nil
 }
 
-func (l *logStore) GetTruncatedIndex(ctx context.Context,
+func (l *store) GetTruncatedIndex(ctx context.Context,
 	shardID uint64) (uint64, error) {
 	v, err := l.read(ctx, shardID, truncatedIndexQuery{})
 	if err != nil {
@@ -271,7 +316,7 @@ func (l *logStore) GetTruncatedIndex(ctx context.Context,
 	return v.(uint64), nil
 }
 
-func (l *logStore) AddLogStoreHeartbeat(ctx context.Context,
+func (l *store) AddLogStoreHeartbeat(ctx context.Context,
 	hb pb.LogStoreHeartbeat) error {
 	data := MustMarshal(&hb)
 	cmd := hakeeper.GetLogStoreHeartbeatCmd(data)
@@ -283,7 +328,7 @@ func (l *logStore) AddLogStoreHeartbeat(ctx context.Context,
 	return nil
 }
 
-func (l *logStore) AddDNStoreHeartbeat(ctx context.Context,
+func (l *store) AddDNStoreHeartbeat(ctx context.Context,
 	hb pb.DNStoreHeartbeat) error {
 	data := MustMarshal(&hb)
 	cmd := hakeeper.GetDNStoreHeartbeatCmd(data)
@@ -295,7 +340,7 @@ func (l *logStore) AddDNStoreHeartbeat(ctx context.Context,
 	return nil
 }
 
-func (l *logStore) getLeaseHolderID(ctx context.Context,
+func (l *store) getLeaseHolderID(ctx context.Context,
 	shardID uint64, entries []raftpb.Entry) (uint64, error) {
 	if len(entries) == 0 {
 		panic("empty entries")
@@ -313,7 +358,7 @@ func (l *logStore) getLeaseHolderID(ctx context.Context,
 	return v.(uint64), nil
 }
 
-func (l *logStore) decodeCmd(e raftpb.Entry) []byte {
+func (l *store) decodeCmd(e raftpb.Entry) []byte {
 	if e.Type == raftpb.ApplicationEntry {
 		panic(moerr.NewError(moerr.INVALID_STATE, "unexpected entry type"))
 	}
@@ -333,7 +378,7 @@ func isRaftInternalEntry(e raftpb.Entry) bool {
 	return e.Type == raftpb.ConfigChangeEntry || e.Type == raftpb.MetadataEntry
 }
 
-func (l *logStore) filterEntries(ctx context.Context,
+func (l *store) filterEntries(ctx context.Context,
 	shardID uint64, entries []raftpb.Entry) ([]LogRecord, error) {
 	if len(entries) == 0 {
 		return []LogRecord{}, nil
@@ -375,7 +420,7 @@ func getNextIndex(entries []raftpb.Entry, firstIndex Lsn, lastIndex Lsn) Lsn {
 	return firstIndex
 }
 
-func (l *logStore) QueryLog(ctx context.Context, shardID uint64,
+func (l *store) QueryLog(ctx context.Context, shardID uint64,
 	firstIndex Lsn, maxSize uint64) ([]LogRecord, Lsn, error) {
 	v, err := l.read(ctx, shardID, indexQuery{})
 	if err != nil {
@@ -409,7 +454,7 @@ func (l *logStore) QueryLog(ctx context.Context, shardID uint64,
 	}
 }
 
-func (l *logStore) ticker() {
+func (l *store) ticker() {
 	ticker := time.NewTicker(hakeeper.TickDuration)
 	defer ticker.Stop()
 	haTicker := time.NewTicker(hakeeper.CheckDuration)
@@ -427,7 +472,7 @@ func (l *logStore) ticker() {
 	}
 }
 
-func (l *logStore) truncationWorker() {
+func (l *store) truncationWorker() {
 	for {
 		select {
 		case <-l.stopper.ShouldStop():
@@ -441,7 +486,7 @@ func (l *logStore) truncationWorker() {
 }
 
 // TODO: add test for this
-func (l *logStore) hakeeperTick() {
+func (l *store) hakeeperTick() {
 	leaderID, _, ok, err := l.nh.GetLeaderID(hakeeper.DefaultHAKeeperShardID)
 	if err != nil {
 		plog.Errorf("failed to get HAKeeper Leader ID, %v", err)
@@ -460,7 +505,7 @@ func (l *logStore) hakeeperTick() {
 }
 
 // TODO: add tests for this
-func (l *logStore) truncateLog() error {
+func (l *store) truncateLog() error {
 	l.mu.Lock()
 	pendings := l.mu.pendingTruncate
 	l.mu.pendingTruncate = make(map[uint64]struct{})
@@ -502,7 +547,7 @@ func (l *logStore) truncateLog() error {
 	return nil
 }
 
-func (l *logStore) getHeartbeatMessage() pb.LogStoreHeartbeat {
+func (l *store) getHeartbeatMessage() pb.LogStoreHeartbeat {
 	m := pb.LogStoreHeartbeat{
 		UUID:           l.cfg.NodeHostID,
 		RaftAddress:    l.cfg.RaftAddress,
diff --git a/pkg/pb/hakeeper/hakeeper.pb.go b/pkg/pb/hakeeper/hakeeper.pb.go
index af828be58..a09351b5c 100644
--- a/pkg/pb/hakeeper/hakeeper.pb.go
+++ b/pkg/pb/hakeeper/hakeeper.pb.go
@@ -85,9 +85,11 @@ func (ServiceType) EnumDescriptor() ([]byte, []int) {
 
 // Replica of the shard
 type Replica struct {
-	ShardID              uint64   `protobuf:"varint,1,opt,name=ShardID,proto3" json:"ShardID,omitempty"`
-	ReplicaID            uint64   `protobuf:"varint,2,opt,name=ReplicaID,proto3" json:"ReplicaID,omitempty"`
-	Epoch                uint64   `protobuf:"varint,3,opt,name=Epoch,proto3" json:"Epoch,omitempty"`
+	// UUID which store the Replica is located in
+	UUID                 string   `protobuf:"bytes,1,opt,name=UUID,proto3" json:"UUID,omitempty"`
+	ShardID              uint64   `protobuf:"varint,2,opt,name=ShardID,proto3" json:"ShardID,omitempty"`
+	ReplicaID            uint64   `protobuf:"varint,3,opt,name=ReplicaID,proto3" json:"ReplicaID,omitempty"`
+	Epoch                uint64   `protobuf:"varint,4,opt,name=Epoch,proto3" json:"Epoch,omitempty"`
 	XXX_NoUnkeyedLiteral struct{} `json:"-"`
 	XXX_unrecognized     []byte   `json:"-"`
 	XXX_sizecache        int32    `json:"-"`
@@ -126,6 +128,13 @@ func (m *Replica) XXX_DiscardUnknown() {
 
 var xxx_messageInfo_Replica proto.InternalMessageInfo
 
+func (m *Replica) GetUUID() string {
+	if m != nil {
+		return m.UUID
+	}
+	return ""
+}
+
 func (m *Replica) GetShardID() uint64 {
 	if m != nil {
 		return m.ShardID
@@ -205,6 +214,7 @@ func (m *ConfigChange) GetChangeType() ConfigChangeType {
 
 // ScheduleCommand contains a shard schedule command.
 type ScheduleCommand struct {
+	// UUID which store the ScheduleCommand is sent to
 	UUID                 string       `protobuf:"bytes,1,opt,name=UUID,proto3" json:"UUID,omitempty"`
 	ConfigChange         ConfigChange `protobuf:"bytes,2,opt,name=ConfigChange,proto3" json:"ConfigChange"`
 	ServiceType          ServiceType  `protobuf:"varint,3,opt,name=ServiceType,proto3,enum=hakeeper.ServiceType" json:"ServiceType,omitempty"`
@@ -828,63 +838,64 @@ func init() {
 func init() { proto.RegisterFile("hakeeper.proto", fileDescriptor_5e1506f3aa5330eb) }
 
 var fileDescriptor_5e1506f3aa5330eb = []byte{
-	// 890 bytes of a gzipped FileDescriptorProto
-	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x9c, 0x56, 0xdb, 0x6e, 0xe3, 0x44,
-	0x18, 0x8e, 0x93, 0x34, 0x87, 0xdf, 0x4d, 0xea, 0x8e, 0x7a, 0x30, 0x11, 0x84, 0x62, 0x21, 0x54,
-	0x95, 0xe2, 0xaa, 0x01, 0x04, 0xb4, 0x41, 0xd0, 0x26, 0x15, 0x54, 0x94, 0x0a, 0x9c, 0x56, 0x54,
-	0x70, 0x81, 0x5c, 0x7b, 0xe2, 0x44, 0x39, 0x4c, 0x64, 0x3b, 0x15, 0xbd, 0xe0, 0x96, 0x67, 0xe0,
-	0x72, 0xaf, 0xf7, 0x62, 0x9f, 0xa3, 0xd2, 0xde, 0xf4, 0x09, 0x56, 0xbb, 0x7d, 0x92, 0x95, 0xc7,
-	0x33, 0xf6, 0x4c, 0x9a, 0xee, 0x6e, 0xf7, 0xce, 0xff, 0xe9, 0x9b, 0xff, 0xf0, 0xfd, 0x33, 0x86,
-	0x6a, 0xcf, 0x1e, 0x60, 0x3c, 0xc1, 0xbe, 0x39, 0xf1, 0x49, 0x48, 0x50, 0x89, 0xcb, 0xb5, 0x2f,
-	0xbc, 0x7e, 0xd8, 0x9b, 0x5e, 0x9a, 0x0e, 0x19, 0xed, 0x78, 0xc4, 0x23, 0x3b, 0xd4, 0xe1, 0x72,
-	0xda, 0xa5, 0x12, 0x15, 0xe8, 0x57, 0x1c, 0x58, 0xd3, 0x86, 0xc4, 0x0b, 0xb0, 0x7f, 0xd5, 0x77,
-	0x30, 0xd3, 0x54, 0x47, 0x38, 0xb4, 0x5d, 0x3b, 0xb4, 0x63, 0xd9, 0xf8, 0x03, 0x8a, 0x16, 0x9e,
-	0x0c, 0xfb, 0x8e, 0x8d, 0x74, 0x28, 0x76, 0x7a, 0xb6, 0xef, 0x1e, 0xb7, 0x75, 0x65, 0x43, 0xd9,
-	0xcc, 0x5b, 0x5c, 0x44, 0x1f, 0x42, 0x99, 0x39, 0x1d, 0xb7, 0xf5, 0x2c, 0xb5, 0xa5, 0x0a, 0xb4,
-	0x02, 0x0b, 0x47, 0x13, 0xe2, 0xf4, 0xf4, 0x1c, 0xb5, 0xc4, 0x82, 0xf1, 0x2f, 0x2c, 0xb6, 0xc8,
-	0xb8, 0xdb, 0xf7, 0x5a, 0x3d, 0x7b, 0xec, 0x61, 0xb4, 0x9b, 0x1c, 0x44, 0xd1, 0xd5, 0xc6, 0xb2,
-	0x99, 0x54, 0xc9, 0x0c, 0x87, 0xf9, 0x9b, 0x17, 0x1f, 0x67, 0xac, 0x24, 0xa1, 0x3d, 0x80, 0x38,
-	0xf8, 0xec, 0x7a, 0x82, 0xe9, 0xb9, 0xd5, 0x46, 0x2d, 0x8d, 0x12, 0xe1, 0x23, 0x0f, 0x4b, 0xf0,
-	0x36, 0x9e, 0x28, 0xb0, 0xd4, 0x71, 0x7a, 0xd8, 0x9d, 0x0e, 0x71, 0x8b, 0x8c, 0x46, 0xf6, 0xd8,
-	0x45, 0x08, 0xf2, 0xe7, 0xe7, 0xac, 0xba, 0xb2, 0x45, 0xbf, 0xd1, 0x8f, 0x72, 0x9a, 0xf4, 0x14,
-	0xb5, 0xb1, 0x36, 0xff, 0x14, 0x96, 0xa0, 0x5c, 0xd8, 0x37, 0xa0, 0x76, 0xe2, 0x16, 0xd3, 0x34,
-	0x73, 0x34, 0xcd, 0xd5, 0x14, 0x40, 0x30, 0x5a, 0xa2, 0xa7, 0xf1, 0x77, 0x74, 0x34, 0xcd, 0xec,
-	0xd0, 0x0e, 0x9d, 0x5e, 0x94, 0xde, 0x19, 0xf6, 0x47, 0xac, 0xf9, 0xf4, 0x1b, 0xed, 0x43, 0x89,
-	0xf9, 0x04, 0x7a, 0x76, 0x23, 0xb7, 0xa9, 0x36, 0x3e, 0x10, 0x90, 0xe5, 0xfa, 0x58, 0x76, 0x49,
-	0x80, 0x71, 0x01, 0x6a, 0xfb, 0xb4, 0x13, 0x12, 0x1f, 0x1f, 0x8f, 0xbb, 0x84, 0xe2, 0xf7, 0x9d,
-	0x41, 0x82, 0xdf, 0x77, 0x06, 0xe8, 0x6b, 0x28, 0xd0, 0x21, 0x73, 0xf4, 0x75, 0x53, 0x60, 0x4c,
-	0xfb, 0x34, 0x26, 0xc0, 0xb8, 0x4b, 0x18, 0x36, 0x73, 0x36, 0xfe, 0x57, 0xa0, 0x18, 0x41, 0xdb,
-	0x21, 0x46, 0xfb, 0x50, 0xa0, 0x67, 0x04, 0xba, 0x42, 0x21, 0x3e, 0x4a, 0x13, 0x64, 0x2e, 0x66,
-	0x6c, 0x3f, 0x1a, 0x87, 0xfe, 0x75, 0x02, 0x44, 0x55, 0xb5, 0xdf, 0x40, 0x15, 0x8c, 0x48, 0x83,
-	0xdc, 0x00, 0x5f, 0xb3, 0x01, 0x45, 0x9f, 0xe8, 0x73, 0x58, 0xb8, 0xb2, 0x87, 0x53, 0x3e, 0x98,
-	0x55, 0x19, 0x9c, 0x95, 0x66, 0xc5, 0x3e, 0x7b, 0xd9, 0x6f, 0x15, 0xe3, 0x3f, 0x05, 0xd4, 0xd6,
-	0x70, 0x1a, 0x84, 0xd8, 0xa7, 0x55, 0x7f, 0x07, 0x25, 0x56, 0x07, 0x4f, 0x70, 0xdd, 0x4c, 0x76,
-	0x80, 0x59, 0x2c, 0xec, 0x10, 0x3f, 0xe9, 0x1f, 0x77, 0x47, 0x4d, 0x28, 0x9f, 0x10, 0x4f, 0xea,
-	0x8f, 0x9e, 0xc6, 0x72, 0x93, 0x14, 0x9c, 0x06, 0x18, 0xb7, 0x0a, 0x2c, 0x46, 0xd2, 0x1b, 0xfb,
-	0xbf, 0x01, 0xaa, 0x65, 0x77, 0xc3, 0x03, 0xd7, 0xf5, 0x71, 0x10, 0xd0, 0x22, 0xcb, 0x96, 0xa8,
-	0x42, 0x9f, 0x41, 0x95, 0x91, 0x86, 0x3b, 0xe5, 0xa8, 0xd3, 0x8c, 0x16, 0x7d, 0x0a, 0x95, 0x9f,
-	0x48, 0x10, 0xf4, 0x27, 0xdc, 0x2d, 0x4f, 0xdd, 0x64, 0x25, 0x6a, 0x42, 0x89, 0x6d, 0x57, 0xa0,
-	0x2f, 0xd0, 0x8a, 0x6a, 0xe2, 0xc4, 0x4f, 0x88, 0xc7, 0xf7, 0x3a, 0x1d, 0x7a, 0x12, 0x61, 0x3c,
-	0xcb, 0x42, 0x89, 0x96, 0x14, 0xcd, 0xbd, 0x99, 0x50, 0x27, 0x6e, 0x6b, 0x3d, 0x1d, 0x0d, 0xf7,
-	0x31, 0x63, 0x07, 0x79, 0xf0, 0xbc, 0xb7, 0x9c, 0x35, 0xd9, 0x87, 0xa3, 0x1f, 0xa4, 0x4d, 0x07,
-	0x54, 0x01, 0x5a, 0xa4, 0x4d, 0x3e, 0xa6, 0x8d, 0x29, 0xd3, 0x46, 0x9f, 0x29, 0x32, 0xe1, 0xb5,
-	0xc0, 0x9c, 0xda, 0xef, 0x6f, 0xe3, 0xe2, 0xb6, 0x0c, 0xba, 0x36, 0x93, 0xf2, 0x1c, 0x32, 0x3e,
-	0x57, 0xa0, 0xf2, 0xf3, 0xc1, 0x2f, 0xd4, 0x29, 0xee, 0xda, 0x3c, 0x12, 0x7c, 0x2f, 0x31, 0xf6,
-	0x3e, 0xd3, 0x05, 0x23, 0xeb, 0x83, 0xc4, 0xf0, 0xdd, 0x64, 0x17, 0x29, 0x35, 0xa4, 0x9b, 0x95,
-	0x19, 0xf8, 0xcd, 0xca, 0x77, 0xf6, 0xab, 0x74, 0x8e, 0x94, 0x27, 0x6a, 0x03, 0xdd, 0xef, 0x3f,
-	0x1f, 0x3f, 0x97, 0x8d, 0xa7, 0x79, 0x28, 0x59, 0x9d, 0x5f, 0x1f, 0x2e, 0x64, 0x0d, 0x0a, 0xa7,
-	0xf8, 0x9f, 0x30, 0x79, 0x24, 0x98, 0x94, 0xdc, 0x6c, 0x39, 0xe1, 0x66, 0xfb, 0x13, 0xb4, 0x99,
-	0xfb, 0x2b, 0xa2, 0x6c, 0x44, 0x85, 0x4d, 0xe1, 0x61, 0x60, 0xa7, 0xcd, 0x5e, 0x75, 0x12, 0x29,
-	0xee, 0xe1, 0xa0, 0x1f, 0xc4, 0xc5, 0x8d, 0x69, 0xfe, 0xc9, 0x1c, 0xd0, 0xc4, 0x87, 0xa2, 0x09,
-	0xbb, 0x2b, 0xb6, 0xb4, 0xf0, 0x1e, 0x2d, 0x2d, 0xbe, 0x6b, 0x4b, 0x67, 0x47, 0x5f, 0x7a, 0xdc,
-	0xe8, 0x6b, 0x7f, 0xc1, 0xea, 0xdc, 0xce, 0x3c, 0x8a, 0xbc, 0xe2, 0x23, 0x24, 0xee, 0x43, 0x13,
-	0xaa, 0x72, 0x87, 0xe6, 0xa0, 0xae, 0x88, 0xa8, 0x79, 0x21, 0x7a, 0xeb, 0x02, 0xb4, 0xd9, 0x07,
-	0x1a, 0x55, 0x01, 0x0e, 0x5c, 0x97, 0x5d, 0x27, 0x5a, 0x06, 0x2d, 0x43, 0xc5, 0xc2, 0x23, 0x72,
-	0x85, 0xb9, 0x4a, 0x41, 0x1a, 0x2c, 0x76, 0x42, 0xdb, 0x0f, 0xb9, 0x26, 0x8b, 0x96, 0xe8, 0x5a,
-	0x4e, 0xb8, 0x22, 0xb7, 0xb5, 0x2d, 0x3d, 0xb8, 0x11, 0x68, 0x94, 0x66, 0xac, 0xd1, 0x32, 0xa8,
-	0x02, 0xe5, 0xf6, 0x98, 0x8b, 0xca, 0xa1, 0x76, 0xfb, 0xaa, 0x9e, 0xb9, 0xb9, 0xab, 0x2b, 0xb7,
-	0x77, 0x75, 0xe5, 0xe5, 0x5d, 0x5d, 0xb9, 0x2c, 0xd0, 0x3f, 0x9f, 0x2f, 0x5f, 0x07, 0x00, 0x00,
-	0xff, 0xff, 0x12, 0x95, 0xb6, 0xbe, 0x66, 0x09, 0x00, 0x00,
+	// 897 bytes of a gzipped FileDescriptorProto
+	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x9c, 0x56, 0xdd, 0x8e, 0xdb, 0x44,
+	0x14, 0x5e, 0x27, 0xde, 0x6c, 0x72, 0xbc, 0x49, 0xdd, 0x51, 0x77, 0x6b, 0x22, 0x08, 0xc1, 0x42,
+	0x28, 0x2a, 0xc5, 0x55, 0x03, 0x08, 0x68, 0x83, 0x60, 0x37, 0xa9, 0x20, 0xa2, 0xac, 0xc0, 0x69,
+	0xa5, 0x0a, 0x2e, 0x90, 0xd7, 0x9e, 0x38, 0x51, 0x7e, 0x26, 0xb2, 0x9d, 0x15, 0x7b, 0xc1, 0x2d,
+	0xcf, 0xc0, 0x25, 0xd7, 0x5c, 0xf0, 0x1c, 0x95, 0xb8, 0xd9, 0x27, 0x40, 0xb0, 0x4f, 0x82, 0x7c,
+	0x3c, 0x63, 0xcf, 0x64, 0xb3, 0xc0, 0xf6, 0xce, 0xe7, 0xef, 0x9b, 0xf3, 0xf3, 0x9d, 0x19, 0x43,
+	0x63, 0xe2, 0xcd, 0x28, 0x5d, 0xd1, 0xc8, 0x59, 0x45, 0x2c, 0x61, 0xa4, 0x2a, 0xe4, 0xe6, 0x7b,
+	0xe1, 0x34, 0x99, 0xac, 0x4f, 0x1d, 0x9f, 0x2d, 0x1e, 0x84, 0x2c, 0x64, 0x0f, 0xd0, 0xe1, 0x74,
+	0x3d, 0x46, 0x09, 0x05, 0xfc, 0xca, 0x02, 0x9b, 0xe6, 0x9c, 0x85, 0x31, 0x8d, 0xce, 0xa6, 0x3e,
+	0xe5, 0x9a, 0xc6, 0x82, 0x26, 0x5e, 0xe0, 0x25, 0x5e, 0x26, 0xdb, 0x33, 0xd8, 0x73, 0xe9, 0x6a,
+	0x3e, 0xf5, 0x3d, 0x42, 0x40, 0x7f, 0xfe, 0x7c, 0x38, 0xb0, 0xb4, 0xb6, 0xd6, 0xa9, 0xb9, 0xf8,
+	0x4d, 0x2c, 0xd8, 0x1b, 0x4d, 0xbc, 0x28, 0x18, 0x0e, 0xac, 0x52, 0x5b, 0xeb, 0xe8, 0xae, 0x10,
+	0xc9, 0xeb, 0x50, 0xe3, 0x81, 0xc3, 0x81, 0x55, 0x46, 0x5b, 0xa1, 0x20, 0x77, 0x60, 0xf7, 0xc9,
+	0x8a, 0xf9, 0x13, 0x4b, 0x47, 0x4b, 0x26, 0xd8, 0x3f, 0xc1, 0x7e, 0x9f, 0x2d, 0xc7, 0xd3, 0xb0,
+	0x3f, 0xf1, 0x96, 0x21, 0x25, 0x0f, 0xf3, 0xc3, 0xf1, 0x50, 0xa3, 0x7b, 0xdb, 0xc9, 0x2b, 0xe7,
+	0x86, 0x63, 0xfd, 0xe5, 0x9f, 0x6f, 0xee, 0xb8, 0x79, 0x92, 0x8f, 0x00, 0xb2, 0xe0, 0x67, 0xe7,
+	0x2b, 0x8a, 0x39, 0x35, 0xba, 0xcd, 0x22, 0x4a, 0x86, 0x4f, 0x3d, 0x5c, 0xc9, 0xdb, 0xfe, 0x55,
+	0x83, 0x5b, 0x23, 0x7f, 0x42, 0x83, 0xf5, 0x9c, 0xf6, 0xd9, 0x62, 0xe1, 0x2d, 0x83, 0xad, 0x45,
+	0x7f, 0xae, 0xa6, 0x89, 0xa7, 0x18, 0xdd, 0xc3, 0xed, 0xa7, 0xf0, 0x04, 0xd5, 0xc2, 0x3e, 0x02,
+	0x63, 0x94, 0xb5, 0x1d, 0xd3, 0x2c, 0x63, 0x9a, 0x07, 0x05, 0x80, 0x64, 0x74, 0x65, 0x4f, 0xfb,
+	0x87, 0xf4, 0x68, 0xcc, 0xec, 0xd8, 0x4b, 0xfc, 0x49, 0x9a, 0xde, 0x33, 0x1a, 0x2d, 0x30, 0x3d,
+	0xdd, 0xc5, 0x6f, 0xf2, 0x18, 0xaa, 0xdc, 0x27, 0xb6, 0x4a, 0xed, 0x72, 0xc7, 0xe8, 0xbe, 0x26,
+	0x21, 0xab, 0xf5, 0xf1, 0xec, 0xf2, 0x00, 0xfb, 0x05, 0x18, 0x83, 0x93, 0x51, 0xc2, 0x22, 0x3a,
+	0x5c, 0x8e, 0x19, 0xe2, 0x4f, 0xfd, 0x59, 0x8e, 0x3f, 0xf5, 0x67, 0xe4, 0x43, 0xa8, 0xe0, 0x90,
+	0x05, 0xfa, 0x5d, 0x47, 0x62, 0xd1, 0xe0, 0x24, 0x23, 0xc0, 0x72, 0xcc, 0x38, 0x36, 0x77, 0xb6,
+	0x7f, 0xd1, 0x60, 0x2f, 0x85, 0xf6, 0x12, 0x4a, 0x1e, 0x43, 0x05, 0xcf, 0x88, 0x2d, 0x0d, 0x21,
+	0xde, 0x28, 0x12, 0xe4, 0x2e, 0x4e, 0x66, 0x7f, 0xb2, 0x4c, 0xa2, 0xf3, 0x1c, 0x08, 0x55, 0xcd,
+	0x6f, 0xc0, 0x90, 0x8c, 0xc4, 0x84, 0xf2, 0x8c, 0x9e, 0xf3, 0x01, 0xa5, 0x9f, 0xe4, 0x5d, 0xd8,
+	0x3d, 0xf3, 0xe6, 0x6b, 0x31, 0x98, 0x03, 0x15, 0x9c, 0x97, 0xe6, 0x66, 0x3e, 0x8f, 0x4a, 0x1f,
+	0x6b, 0xf6, 0xcf, 0x1a, 0x18, 0xfd, 0xf9, 0x3a, 0x4e, 0x68, 0x84, 0x55, 0x7f, 0x02, 0x55, 0x5e,
+	0x87, 0x48, 0xf0, 0xae, 0x93, 0xef, 0x05, 0xb7, 0xb8, 0xd4, 0x67, 0x51, 0xde, 0x3f, 0xe1, 0x4e,
+	0x7a, 0x50, 0x7b, 0xca, 0x42, 0xa5, 0x3f, 0x56, 0x11, 0x2b, 0x4c, 0x4a, 0x70, 0x11, 0x60, 0x5f,
+	0x68, 0xb0, 0x9f, 0x4a, 0xff, 0xda, 0xff, 0x36, 0x18, 0xae, 0x37, 0x4e, 0x8e, 0x82, 0x20, 0xa2,
+	0x71, 0x8c, 0x45, 0xd6, 0x5c, 0x59, 0x45, 0xde, 0x81, 0x06, 0x27, 0x8d, 0x70, 0x2a, 0xa3, 0xd3,
+	0x86, 0x96, 0xbc, 0x0d, 0xf5, 0x2f, 0x58, 0x1c, 0x4f, 0x57, 0xc2, 0x4d, 0x47, 0x37, 0x55, 0x49,
+	0x7a, 0x50, 0xe5, 0xdb, 0x15, 0x5b, 0xbb, 0x58, 0x51, 0x53, 0x9e, 0xf8, 0x53, 0x16, 0x8a, 0xbd,
+	0x2e, 0x86, 0x9e, 0x47, 0xd8, 0xbf, 0x97, 0xa0, 0x8a, 0x25, 0xa5, 0x73, 0xef, 0xe5, 0xd4, 0xc9,
+	0xda, 0xda, 0x2a, 0x46, 0x23, 0x7c, 0x9c, 0xcc, 0x41, 0x1d, 0xbc, 0xe8, 0xad, 0x60, 0x4d, 0xe9,
+	0xfa, 0xe8, 0x6b, 0x69, 0x33, 0x02, 0x43, 0x82, 0x96, 0x69, 0xa3, 0x67, 0xb4, 0x71, 0x54, 0xda,
+	0x58, 0x1b, 0x45, 0xe6, 0xbc, 0x96, 0x98, 0xd3, 0xfc, 0xf6, 0xbf, 0xb8, 0x78, 0x5f, 0x05, 0x3d,
+	0xdc, 0x48, 0x79, 0x0b, 0x19, 0xff, 0xd0, 0xa0, 0xfe, 0xe5, 0xd1, 0x57, 0xe8, 0x94, 0x75, 0x6d,
+	0x1b, 0x09, 0x3e, 0x55, 0x18, 0x7b, 0x95, 0xe9, 0x92, 0x91, 0xf7, 0x41, 0x61, 0xf8, 0xc3, 0x7c,
+	0x17, 0x91, 0x1a, 0xca, 0xcd, 0xca, 0x0d, 0xe2, 0x66, 0x15, 0x3b, 0xfb, 0x41, 0x31, 0x47, 0xe4,
+	0x89, 0xd1, 0x25, 0x57, 0xfb, 0x2f, 0xc6, 0x2f, 0x64, 0xfb, 0x37, 0x1d, 0xaa, 0xee, 0xe8, 0xeb,
+	0xeb, 0x0b, 0x39, 0x84, 0xca, 0x09, 0xfd, 0x31, 0xc9, 0x1f, 0x10, 0x2e, 0xe5, 0x37, 0x5b, 0x59,
+	0xba, 0xd9, 0xbe, 0x03, 0x73, 0xe3, 0xfe, 0x4a, 0x29, 0x9b, 0x52, 0xa1, 0x23, 0x3d, 0x0c, 0xfc,
+	0xb4, 0xcd, 0xab, 0x4e, 0x21, 0xc5, 0x15, 0x1c, 0xf2, 0x99, 0xbc, 0xb8, 0x19, 0xcd, 0xdf, 0xda,
+	0x02, 0x9a, 0xfb, 0x20, 0x9a, 0xb4, 0xbb, 0x72, 0x4b, 0x2b, 0xaf, 0xd0, 0xd2, 0xbd, 0xff, 0xdb,
+	0xd2, 0xcd, 0xd1, 0x57, 0x6f, 0x36, 0xfa, 0xe6, 0xf7, 0x70, 0xb0, 0xb5, 0x33, 0x37, 0x22, 0xaf,
+	0xfc, 0x08, 0xc9, 0xfb, 0xd0, 0x83, 0x86, 0xda, 0xa1, 0x2d, 0xa8, 0x77, 0x64, 0x54, 0x5d, 0x8a,
+	0xbe, 0xf7, 0x02, 0xcc, 0xcd, 0x07, 0x9a, 0x34, 0x00, 0x8e, 0x82, 0x80, 0x5f, 0x27, 0xe6, 0x0e,
+	0xb9, 0x0d, 0x75, 0x97, 0x2e, 0xd8, 0x19, 0x15, 0x2a, 0x8d, 0x98, 0xb0, 0x3f, 0x4a, 0xbc, 0x28,
+	0x11, 0x9a, 0x12, 0xb9, 0x85, 0x6b, 0xb9, 0x12, 0x8a, 0xf2, 0xbd, 0xfb, 0xca, 0x83, 0x9b, 0x82,
+	0xa6, 0x69, 0x66, 0x1a, 0x73, 0x87, 0xd4, 0xa1, 0x36, 0x58, 0x0a, 0x51, 0x3b, 0x36, 0x2f, 0xfe,
+	0x6e, 0xed, 0xbc, 0xbc, 0x6c, 0x69, 0x17, 0x97, 0x2d, 0xed, 0xaf, 0xcb, 0x96, 0x76, 0x5a, 0xc1,
+	0xbf, 0xa1, 0xf7, 0xff, 0x09, 0x00, 0x00, 0xff, 0xff, 0xc9, 0xe8, 0x88, 0x09, 0x7a, 0x09, 0x00,
+	0x00,
 }
 
 func (m *Replica) Marshal() (dAtA []byte, err error) {
@@ -914,17 +925,24 @@ func (m *Replica) MarshalToSizedBuffer(dAtA []byte) (int, error) {
 	if m.Epoch != 0 {
 		i = encodeVarintHakeeper(dAtA, i, uint64(m.Epoch))
 		i--
-		dAtA[i] = 0x18
+		dAtA[i] = 0x20
 	}
 	if m.ReplicaID != 0 {
 		i = encodeVarintHakeeper(dAtA, i, uint64(m.ReplicaID))
 		i--
-		dAtA[i] = 0x10
+		dAtA[i] = 0x18
 	}
 	if m.ShardID != 0 {
 		i = encodeVarintHakeeper(dAtA, i, uint64(m.ShardID))
 		i--
-		dAtA[i] = 0x8
+		dAtA[i] = 0x10
+	}
+	if len(m.UUID) > 0 {
+		i -= len(m.UUID)
+		copy(dAtA[i:], m.UUID)
+		i = encodeVarintHakeeper(dAtA, i, uint64(len(m.UUID)))
+		i--
+		dAtA[i] = 0xa
 	}
 	return len(dAtA) - i, nil
 }
@@ -1550,6 +1568,10 @@ func (m *Replica) Size() (n int) {
 	}
 	var l int
 	_ = l
+	l = len(m.UUID)
+	if l > 0 {
+		n += 1 + l + sovHakeeper(uint64(l))
+	}
 	if m.ShardID != 0 {
 		n += 1 + sovHakeeper(uint64(m.ShardID))
 	}
@@ -1854,6 +1876,38 @@ func (m *Replica) Unmarshal(dAtA []byte) error {
 		}
 		switch fieldNum {
 		case 1:
+			if wireType != 2 {
+				return fmt.Errorf("proto: wrong wireType = %d for field UUID", wireType)
+			}
+			var stringLen uint64
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowHakeeper
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				stringLen |= uint64(b&0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+			intStringLen := int(stringLen)
+			if intStringLen < 0 {
+				return ErrInvalidLengthHakeeper
+			}
+			postIndex := iNdEx + intStringLen
+			if postIndex < 0 {
+				return ErrInvalidLengthHakeeper
+			}
+			if postIndex > l {
+				return io.ErrUnexpectedEOF
+			}
+			m.UUID = string(dAtA[iNdEx:postIndex])
+			iNdEx = postIndex
+		case 2:
 			if wireType != 0 {
 				return fmt.Errorf("proto: wrong wireType = %d for field ShardID", wireType)
 			}
@@ -1872,7 +1926,7 @@ func (m *Replica) Unmarshal(dAtA []byte) error {
 					break
 				}
 			}
-		case 2:
+		case 3:
 			if wireType != 0 {
 				return fmt.Errorf("proto: wrong wireType = %d for field ReplicaID", wireType)
 			}
@@ -1891,7 +1945,7 @@ func (m *Replica) Unmarshal(dAtA []byte) error {
 					break
 				}
 			}
-		case 3:
+		case 4:
 			if wireType != 0 {
 				return fmt.Errorf("proto: wrong wireType = %d for field Epoch", wireType)
 			}
diff --git a/pkg/pb/plan/plan.pb.go b/pkg/pb/plan/plan.pb.go
index de5888026..96597715b 100644
--- a/pkg/pb/plan/plan.pb.go
+++ b/pkg/pb/plan/plan.pb.go
@@ -678,6 +678,37 @@ func (TransationBegin_TransationMode) EnumDescriptor() ([]byte, []int) {
 	return fileDescriptor_2d655ab2f7683c23, []int{30, 0}
 }
 
+type DataControl_DclType int32
+
+const (
+	DataControl_SET_VARIABLES DataControl_DclType = 0
+	DataControl_GRANT         DataControl_DclType = 1
+	DataControl_REVOKE        DataControl_DclType = 2
+	DataControl_DENY          DataControl_DclType = 3
+)
+
+var DataControl_DclType_name = map[int32]string{
+	0: "SET_VARIABLES",
+	1: "GRANT",
+	2: "REVOKE",
+	3: "DENY",
+}
+
+var DataControl_DclType_value = map[string]int32{
+	"SET_VARIABLES": 0,
+	"GRANT":         1,
+	"REVOKE":        2,
+	"DENY":          3,
+}
+
+func (x DataControl_DclType) String() string {
+	return proto.EnumName(DataControl_DclType_name, int32(x))
+}
+
+func (DataControl_DclType) EnumDescriptor() ([]byte, []int) {
+	return fileDescriptor_2d655ab2f7683c23, []int{34, 0}
+}
+
 type DataDefinition_DdlType int32
 
 const (
@@ -757,7 +788,7 @@ func (x DataDefinition_DdlType) String() string {
 }
 
 func (DataDefinition_DdlType) EnumDescriptor() ([]byte, []int) {
-	return fileDescriptor_2d655ab2f7683c23, []int{34, 0}
+	return fileDescriptor_2d655ab2f7683c23, []int{35, 0}
 }
 
 type Type struct {
@@ -3629,6 +3660,7 @@ type Plan struct {
 	//	*Plan_Query
 	//	*Plan_Tcl
 	//	*Plan_Ddl
+	//	*Plan_Dcl
 	Plan                 isPlan_Plan `protobuf_oneof:"plan"`
 	XXX_NoUnkeyedLiteral struct{}    `json:"-"`
 	XXX_unrecognized     []byte      `json:"-"`
@@ -3683,10 +3715,14 @@ type Plan_Tcl struct {
 type Plan_Ddl struct {
 	Ddl *DataDefinition `protobuf:"bytes,3,opt,name=ddl,proto3,oneof" json:"ddl,omitempty"`
 }
+type Plan_Dcl struct {
+	Dcl *DataControl `protobuf:"bytes,4,opt,name=dcl,proto3,oneof" json:"dcl,omitempty"`
+}
 
 func (*Plan_Query) isPlan_Plan() {}
 func (*Plan_Tcl) isPlan_Plan()   {}
 func (*Plan_Ddl) isPlan_Plan()   {}
+func (*Plan_Dcl) isPlan_Plan()   {}
 
 func (m *Plan) GetPlan() isPlan_Plan {
 	if m != nil {
@@ -3716,12 +3752,104 @@ func (m *Plan) GetDdl() *DataDefinition {
 	return nil
 }
 
+func (m *Plan) GetDcl() *DataControl {
+	if x, ok := m.GetPlan().(*Plan_Dcl); ok {
+		return x.Dcl
+	}
+	return nil
+}
+
 // XXX_OneofWrappers is for the internal use of the proto package.
 func (*Plan) XXX_OneofWrappers() []interface{} {
 	return []interface{}{
 		(*Plan_Query)(nil),
 		(*Plan_Tcl)(nil),
 		(*Plan_Ddl)(nil),
+		(*Plan_Dcl)(nil),
+	}
+}
+
+type DataControl struct {
+	//DataDefinition type
+	DclType DataControl_DclType `protobuf:"varint,1,opt,name=dcl_type,json=dclType,proto3,enum=plan.DataControl_DclType" json:"dcl_type,omitempty"`
+	// Types that are valid to be assigned to Control:
+	//	*DataControl_SetVariables
+	Control              isDataControl_Control `protobuf_oneof:"control"`
+	XXX_NoUnkeyedLiteral struct{}              `json:"-"`
+	XXX_unrecognized     []byte                `json:"-"`
+	XXX_sizecache        int32                 `json:"-"`
+}
+
+func (m *DataControl) Reset()         { *m = DataControl{} }
+func (m *DataControl) String() string { return proto.CompactTextString(m) }
+func (*DataControl) ProtoMessage()    {}
+func (*DataControl) Descriptor() ([]byte, []int) {
+	return fileDescriptor_2d655ab2f7683c23, []int{34}
+}
+func (m *DataControl) XXX_Unmarshal(b []byte) error {
+	return m.Unmarshal(b)
+}
+func (m *DataControl) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+	if deterministic {
+		return xxx_messageInfo_DataControl.Marshal(b, m, deterministic)
+	} else {
+		b = b[:cap(b)]
+		n, err := m.MarshalToSizedBuffer(b)
+		if err != nil {
+			return nil, err
+		}
+		return b[:n], nil
+	}
+}
+func (m *DataControl) XXX_Merge(src proto.Message) {
+	xxx_messageInfo_DataControl.Merge(m, src)
+}
+func (m *DataControl) XXX_Size() int {
+	return m.ProtoSize()
+}
+func (m *DataControl) XXX_DiscardUnknown() {
+	xxx_messageInfo_DataControl.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_DataControl proto.InternalMessageInfo
+
+type isDataControl_Control interface {
+	isDataControl_Control()
+	MarshalTo([]byte) (int, error)
+	ProtoSize() int
+}
+
+type DataControl_SetVariables struct {
+	SetVariables *SetVariables `protobuf:"bytes,2,opt,name=set_variables,json=setVariables,proto3,oneof" json:"set_variables,omitempty"`
+}
+
+func (*DataControl_SetVariables) isDataControl_Control() {}
+
+func (m *DataControl) GetControl() isDataControl_Control {
+	if m != nil {
+		return m.Control
+	}
+	return nil
+}
+
+func (m *DataControl) GetDclType() DataControl_DclType {
+	if m != nil {
+		return m.DclType
+	}
+	return DataControl_SET_VARIABLES
+}
+
+func (m *DataControl) GetSetVariables() *SetVariables {
+	if x, ok := m.GetControl().(*DataControl_SetVariables); ok {
+		return x.SetVariables
+	}
+	return nil
+}
+
+// XXX_OneofWrappers is for the internal use of the proto package.
+func (*DataControl) XXX_OneofWrappers() []interface{} {
+	return []interface{}{
+		(*DataControl_SetVariables)(nil),
 	}
 }
 
@@ -3754,7 +3882,7 @@ func (m *DataDefinition) Reset()         { *m = DataDefinition{} }
 func (m *DataDefinition) String() string { return proto.CompactTextString(m) }
 func (*DataDefinition) ProtoMessage()    {}
 func (*DataDefinition) Descriptor() ([]byte, []int) {
-	return fileDescriptor_2d655ab2f7683c23, []int{34}
+	return fileDescriptor_2d655ab2f7683c23, []int{35}
 }
 func (m *DataDefinition) XXX_Unmarshal(b []byte) error {
 	return m.Unmarshal(b)
@@ -3962,7 +4090,7 @@ func (m *CreateDatabase) Reset()         { *m = CreateDatabase{} }
 func (m *CreateDatabase) String() string { return proto.CompactTextString(m) }
 func (*CreateDatabase) ProtoMessage()    {}
 func (*CreateDatabase) Descriptor() ([]byte, []int) {
-	return fileDescriptor_2d655ab2f7683c23, []int{35}
+	return fileDescriptor_2d655ab2f7683c23, []int{36}
 }
 func (m *CreateDatabase) XXX_Unmarshal(b []byte) error {
 	return m.Unmarshal(b)
@@ -4017,7 +4145,7 @@ func (m *AlterDatabase) Reset()         { *m = AlterDatabase{} }
 func (m *AlterDatabase) String() string { return proto.CompactTextString(m) }
 func (*AlterDatabase) ProtoMessage()    {}
 func (*AlterDatabase) Descriptor() ([]byte, []int) {
-	return fileDescriptor_2d655ab2f7683c23, []int{36}
+	return fileDescriptor_2d655ab2f7683c23, []int{37}
 }
 func (m *AlterDatabase) XXX_Unmarshal(b []byte) error {
 	return m.Unmarshal(b)
@@ -4072,7 +4200,7 @@ func (m *DropDatabase) Reset()         { *m = DropDatabase{} }
 func (m *DropDatabase) String() string { return proto.CompactTextString(m) }
 func (*DropDatabase) ProtoMessage()    {}
 func (*DropDatabase) Descriptor() ([]byte, []int) {
-	return fileDescriptor_2d655ab2f7683c23, []int{37}
+	return fileDescriptor_2d655ab2f7683c23, []int{38}
 }
 func (m *DropDatabase) XXX_Unmarshal(b []byte) error {
 	return m.Unmarshal(b)
@@ -4129,7 +4257,7 @@ func (m *CreateTable) Reset()         { *m = CreateTable{} }
 func (m *CreateTable) String() string { return proto.CompactTextString(m) }
 func (*CreateTable) ProtoMessage()    {}
 func (*CreateTable) Descriptor() ([]byte, []int) {
-	return fileDescriptor_2d655ab2f7683c23, []int{38}
+	return fileDescriptor_2d655ab2f7683c23, []int{39}
 }
 func (m *CreateTable) XXX_Unmarshal(b []byte) error {
 	return m.Unmarshal(b)
@@ -4198,7 +4326,7 @@ func (m *AlterTable) Reset()         { *m = AlterTable{} }
 func (m *AlterTable) String() string { return proto.CompactTextString(m) }
 func (*AlterTable) ProtoMessage()    {}
 func (*AlterTable) Descriptor() ([]byte, []int) {
-	return fileDescriptor_2d655ab2f7683c23, []int{39}
+	return fileDescriptor_2d655ab2f7683c23, []int{40}
 }
 func (m *AlterTable) XXX_Unmarshal(b []byte) error {
 	return m.Unmarshal(b)
@@ -4254,7 +4382,7 @@ func (m *DropTable) Reset()         { *m = DropTable{} }
 func (m *DropTable) String() string { return proto.CompactTextString(m) }
 func (*DropTable) ProtoMessage()    {}
 func (*DropTable) Descriptor() ([]byte, []int) {
-	return fileDescriptor_2d655ab2f7683c23, []int{40}
+	return fileDescriptor_2d655ab2f7683c23, []int{41}
 }
 func (m *DropTable) XXX_Unmarshal(b []byte) error {
 	return m.Unmarshal(b)
@@ -4316,7 +4444,7 @@ func (m *CreateIndex) Reset()         { *m = CreateIndex{} }
 func (m *CreateIndex) String() string { return proto.CompactTextString(m) }
 func (*CreateIndex) ProtoMessage()    {}
 func (*CreateIndex) Descriptor() ([]byte, []int) {
-	return fileDescriptor_2d655ab2f7683c23, []int{41}
+	return fileDescriptor_2d655ab2f7683c23, []int{42}
 }
 func (m *CreateIndex) XXX_Unmarshal(b []byte) error {
 	return m.Unmarshal(b)
@@ -4370,7 +4498,7 @@ func (m *AlterIndex) Reset()         { *m = AlterIndex{} }
 func (m *AlterIndex) String() string { return proto.CompactTextString(m) }
 func (*AlterIndex) ProtoMessage()    {}
 func (*AlterIndex) Descriptor() ([]byte, []int) {
-	return fileDescriptor_2d655ab2f7683c23, []int{42}
+	return fileDescriptor_2d655ab2f7683c23, []int{43}
 }
 func (m *AlterIndex) XXX_Unmarshal(b []byte) error {
 	return m.Unmarshal(b)
@@ -4418,7 +4546,7 @@ func (m *DropIndex) Reset()         { *m = DropIndex{} }
 func (m *DropIndex) String() string { return proto.CompactTextString(m) }
 func (*DropIndex) ProtoMessage()    {}
 func (*DropIndex) Descriptor() ([]byte, []int) {
-	return fileDescriptor_2d655ab2f7683c23, []int{43}
+	return fileDescriptor_2d655ab2f7683c23, []int{44}
 }
 func (m *DropIndex) XXX_Unmarshal(b []byte) error {
 	return m.Unmarshal(b)
@@ -4472,7 +4600,7 @@ func (m *TruncateTable) Reset()         { *m = TruncateTable{} }
 func (m *TruncateTable) String() string { return proto.CompactTextString(m) }
 func (*TruncateTable) ProtoMessage()    {}
 func (*TruncateTable) Descriptor() ([]byte, []int) {
-	return fileDescriptor_2d655ab2f7683c23, []int{44}
+	return fileDescriptor_2d655ab2f7683c23, []int{45}
 }
 func (m *TruncateTable) XXX_Unmarshal(b []byte) error {
 	return m.Unmarshal(b)
@@ -4520,7 +4648,7 @@ func (m *ShowVariables) Reset()         { *m = ShowVariables{} }
 func (m *ShowVariables) String() string { return proto.CompactTextString(m) }
 func (*ShowVariables) ProtoMessage()    {}
 func (*ShowVariables) Descriptor() ([]byte, []int) {
-	return fileDescriptor_2d655ab2f7683c23, []int{45}
+	return fileDescriptor_2d655ab2f7683c23, []int{46}
 }
 func (m *ShowVariables) XXX_Unmarshal(b []byte) error {
 	return m.Unmarshal(b)
@@ -4563,6 +4691,132 @@ func (m *ShowVariables) GetWhere() []*Expr {
 	return nil
 }
 
+type SetVariables struct {
+	Items                []*SetVariablesItem `protobuf:"bytes,1,rep,name=items,proto3" json:"items,omitempty"`
+	XXX_NoUnkeyedLiteral struct{}            `json:"-"`
+	XXX_unrecognized     []byte              `json:"-"`
+	XXX_sizecache        int32               `json:"-"`
+}
+
+func (m *SetVariables) Reset()         { *m = SetVariables{} }
+func (m *SetVariables) String() string { return proto.CompactTextString(m) }
+func (*SetVariables) ProtoMessage()    {}
+func (*SetVariables) Descriptor() ([]byte, []int) {
+	return fileDescriptor_2d655ab2f7683c23, []int{47}
+}
+func (m *SetVariables) XXX_Unmarshal(b []byte) error {
+	return m.Unmarshal(b)
+}
+func (m *SetVariables) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+	if deterministic {
+		return xxx_messageInfo_SetVariables.Marshal(b, m, deterministic)
+	} else {
+		b = b[:cap(b)]
+		n, err := m.MarshalToSizedBuffer(b)
+		if err != nil {
+			return nil, err
+		}
+		return b[:n], nil
+	}
+}
+func (m *SetVariables) XXX_Merge(src proto.Message) {
+	xxx_messageInfo_SetVariables.Merge(m, src)
+}
+func (m *SetVariables) XXX_Size() int {
+	return m.ProtoSize()
+}
+func (m *SetVariables) XXX_DiscardUnknown() {
+	xxx_messageInfo_SetVariables.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_SetVariables proto.InternalMessageInfo
+
+func (m *SetVariables) GetItems() []*SetVariablesItem {
+	if m != nil {
+		return m.Items
+	}
+	return nil
+}
+
+type SetVariablesItem struct {
+	System               bool     `protobuf:"varint,1,opt,name=system,proto3" json:"system,omitempty"`
+	Global               bool     `protobuf:"varint,2,opt,name=global,proto3" json:"global,omitempty"`
+	Name                 string   `protobuf:"bytes,3,opt,name=name,proto3" json:"name,omitempty"`
+	Value                *Expr    `protobuf:"bytes,4,opt,name=value,proto3" json:"value,omitempty"`
+	Reserved             *Expr    `protobuf:"bytes,5,opt,name=reserved,proto3" json:"reserved,omitempty"`
+	XXX_NoUnkeyedLiteral struct{} `json:"-"`
+	XXX_unrecognized     []byte   `json:"-"`
+	XXX_sizecache        int32    `json:"-"`
+}
+
+func (m *SetVariablesItem) Reset()         { *m = SetVariablesItem{} }
+func (m *SetVariablesItem) String() string { return proto.CompactTextString(m) }
+func (*SetVariablesItem) ProtoMessage()    {}
+func (*SetVariablesItem) Descriptor() ([]byte, []int) {
+	return fileDescriptor_2d655ab2f7683c23, []int{48}
+}
+func (m *SetVariablesItem) XXX_Unmarshal(b []byte) error {
+	return m.Unmarshal(b)
+}
+func (m *SetVariablesItem) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+	if deterministic {
+		return xxx_messageInfo_SetVariablesItem.Marshal(b, m, deterministic)
+	} else {
+		b = b[:cap(b)]
+		n, err := m.MarshalToSizedBuffer(b)
+		if err != nil {
+			return nil, err
+		}
+		return b[:n], nil
+	}
+}
+func (m *SetVariablesItem) XXX_Merge(src proto.Message) {
+	xxx_messageInfo_SetVariablesItem.Merge(m, src)
+}
+func (m *SetVariablesItem) XXX_Size() int {
+	return m.ProtoSize()
+}
+func (m *SetVariablesItem) XXX_DiscardUnknown() {
+	xxx_messageInfo_SetVariablesItem.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_SetVariablesItem proto.InternalMessageInfo
+
+func (m *SetVariablesItem) GetSystem() bool {
+	if m != nil {
+		return m.System
+	}
+	return false
+}
+
+func (m *SetVariablesItem) GetGlobal() bool {
+	if m != nil {
+		return m.Global
+	}
+	return false
+}
+
+func (m *SetVariablesItem) GetName() string {
+	if m != nil {
+		return m.Name
+	}
+	return ""
+}
+
+func (m *SetVariablesItem) GetValue() *Expr {
+	if m != nil {
+		return m.Value
+	}
+	return nil
+}
+
+func (m *SetVariablesItem) GetReserved() *Expr {
+	if m != nil {
+		return m.Reserved
+	}
+	return nil
+}
+
 func init() {
 	proto.RegisterEnum("plan.CompressType", CompressType_name, CompressType_value)
 	proto.RegisterEnum("plan.TransationCompletionType", TransationCompletionType_name, TransationCompletionType_value)
@@ -4577,6 +4831,7 @@ func init() {
 	proto.RegisterEnum("plan.Query_StatementType", Query_StatementType_name, Query_StatementType_value)
 	proto.RegisterEnum("plan.TransationControl_TclType", TransationControl_TclType_name, TransationControl_TclType_value)
 	proto.RegisterEnum("plan.TransationBegin_TransationMode", TransationBegin_TransationMode_name, TransationBegin_TransationMode_value)
+	proto.RegisterEnum("plan.DataControl_DclType", DataControl_DclType_name, DataControl_DclType_value)
 	proto.RegisterEnum("plan.DataDefinition_DdlType", DataDefinition_DdlType_name, DataDefinition_DdlType_value)
 	proto.RegisterType((*Type)(nil), "plan.Type")
 	proto.RegisterType((*Const)(nil), "plan.Const")
@@ -4613,6 +4868,7 @@ func init() {
 	proto.RegisterType((*TransationCommit)(nil), "plan.TransationCommit")
 	proto.RegisterType((*TransationRollback)(nil), "plan.TransationRollback")
 	proto.RegisterType((*Plan)(nil), "plan.Plan")
+	proto.RegisterType((*DataControl)(nil), "plan.DataControl")
 	proto.RegisterType((*DataDefinition)(nil), "plan.DataDefinition")
 	proto.RegisterType((*CreateDatabase)(nil), "plan.CreateDatabase")
 	proto.RegisterType((*AlterDatabase)(nil), "plan.AlterDatabase")
@@ -4625,278 +4881,291 @@ func init() {
 	proto.RegisterType((*DropIndex)(nil), "plan.DropIndex")
 	proto.RegisterType((*TruncateTable)(nil), "plan.TruncateTable")
 	proto.RegisterType((*ShowVariables)(nil), "plan.ShowVariables")
+	proto.RegisterType((*SetVariables)(nil), "plan.SetVariables")
+	proto.RegisterType((*SetVariablesItem)(nil), "plan.SetVariablesItem")
 }
 
 func init() { proto.RegisterFile("plan.proto", fileDescriptor_2d655ab2f7683c23) }
 
 var fileDescriptor_2d655ab2f7683c23 = []byte{
-	// 4248 bytes of a gzipped FileDescriptorProto
+	// 4426 bytes of a gzipped FileDescriptorProto
 	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xac, 0x7a, 0xdf, 0x6f, 0x1b, 0xc7,
-	0x76, 0xbf, 0x96, 0x3f, 0x97, 0x87, 0x94, 0x3c, 0x1e, 0x2b, 0x36, 0xe3, 0x38, 0x8e, 0xbc, 0x89,
-	0xf3, 0x55, 0xec, 0xc4, 0x89, 0x69, 0x59, 0x5f, 0xe7, 0x36, 0xbd, 0xb9, 0x4b, 0x6a, 0x25, 0x6d,
-	0x4c, 0x2d, 0x75, 0x87, 0x2b, 0x39, 0x4e, 0x50, 0x10, 0x4b, 0xee, 0x92, 0x5e, 0x9b, 0xe2, 0xb2,
-	0xbb, 0x4b, 0xc9, 0xba, 0x4f, 0xf7, 0xa5, 0x45, 0xd1, 0x3e, 0xb4, 0x28, 0x0a, 0xdc, 0xa2, 0x4f,
-	0xc5, 0x05, 0xfa, 0x07, 0xf4, 0x8f, 0x28, 0x70, 0x8b, 0xbe, 0x14, 0xe8, 0x4b, 0x81, 0xbe, 0xb4,
-	0xe9, 0x7f, 0xd0, 0xbf, 0xa0, 0x38, 0x67, 0x76, 0xc9, 0xa5, 0xa5, 0xe4, 0x06, 0x41, 0x5f, 0x84,
-	0x73, 0x3e, 0xe7, 0xc7, 0x9e, 0x99, 0x39, 0x73, 0xe6, 0xcc, 0x50, 0x00, 0xd3, 0xb1, 0x33, 0x79,
-	0x30, 0x0d, 0x83, 0x38, 0xe0, 0x05, 0xa4, 0x6f, 0x7e, 0x32, 0xf2, 0xe3, 0x17, 0xb3, 0xfe, 0x83,
-	0x41, 0x70, 0xf2, 0xe9, 0x28, 0x18, 0x05, 0x9f, 0x92, 0xb0, 0x3f, 0x1b, 0x12, 0x47, 0x0c, 0x51,
-	0xd2, 0x48, 0xfb, 0x97, 0x22, 0x14, 0xec, 0xf3, 0xa9, 0xc7, 0xef, 0x40, 0xce, 0x77, 0xeb, 0xca,
-	0x86, 0xb2, 0xb9, 0xd6, 0xb8, 0xfa, 0x80, 0xdc, 0x22, 0x4e, 0x7f, 0x4c, 0x57, 0xe4, 0x7c, 0x97,
-	0xdf, 0x04, 0x75, 0x32, 0x1b, 0x8f, 0x9d, 0xfe, 0xd8, 0xab, 0xe7, 0x36, 0x94, 0x4d, 0x55, 0xcc,
-	0x79, 0xbe, 0x0e, 0xc5, 0x33, 0xdf, 0x8d, 0x5f, 0xd4, 0xf3, 0x1b, 0xca, 0x66, 0x51, 0x48, 0x86,
-	0xdf, 0x82, 0xca, 0x34, 0xf4, 0x06, 0x7e, 0xe4, 0x07, 0x93, 0x7a, 0x81, 0x24, 0x0b, 0x80, 0x73,
-	0x28, 0x44, 0xfe, 0xaf, 0xbc, 0x7a, 0x91, 0x04, 0x44, 0xa3, 0x9f, 0x68, 0xe0, 0x8c, 0xbd, 0x7a,
-	0x49, 0xfa, 0x21, 0x46, 0xfb, 0x87, 0x02, 0x94, 0x64, 0x20, 0xbc, 0x0c, 0x79, 0xdd, 0x7a, 0xce,
-	0x56, 0xb8, 0x0a, 0x85, 0xae, 0xad, 0x0b, 0xa6, 0x20, 0xd5, 0xec, 0x74, 0xda, 0x0c, 0x90, 0x32,
-	0x2d, 0xfb, 0x09, 0x5b, 0xe7, 0x15, 0x28, 0x9a, 0x96, 0xfd, 0x70, 0x9b, 0xbd, 0x95, 0x90, 0x8f,
-	0x1a, 0xec, 0x7a, 0x42, 0x6e, 0x6f, 0xb1, 0x1b, 0x1c, 0xa0, 0x84, 0x0a, 0x8d, 0x27, 0xac, 0x8e,
-	0xf0, 0x11, 0xd9, 0xbd, 0x8d, 0xf0, 0x91, 0x34, 0xbc, 0x99, 0xd2, 0x8f, 0x1a, 0xec, 0x9d, 0x94,
-	0xde, 0xde, 0x62, 0xb7, 0x78, 0x15, 0xca, 0x47, 0x89, 0xed, 0xbb, 0xc8, 0xec, 0xb6, 0x3b, 0x3a,
-	0x6a, 0xdd, 0x9e, 0x33, 0xdb, 0x5b, 0xec, 0x3d, 0xbe, 0x0a, 0x95, 0x1d, 0xa3, 0x65, 0x1e, 0xe8,
-	0xed, 0xed, 0x2d, 0xb6, 0xc1, 0xd7, 0x00, 0x12, 0x16, 0x0d, 0xef, 0xa0, 0x6e, 0xc2, 0x33, 0x0d,
-	0xdd, 0xeb, 0xd6, 0x73, 0xd3, 0xb2, 0xd9, 0x5d, 0x5e, 0x03, 0x55, 0xb7, 0x9e, 0x93, 0x1f, 0xf6,
-	0x21, 0x7a, 0xd1, 0xad, 0xe7, 0xd6, 0xd1, 0x41, 0xd3, 0x10, 0xec, 0xff, 0xe1, 0x08, 0x8f, 0x8e,
-	0xcc, 0x1d, 0xb6, 0x49, 0x41, 0x37, 0x1f, 0x6e, 0x7f, 0xc6, 0x3e, 0x4a, 0xc8, 0x27, 0x5b, 0xec,
-	0x5e, 0x42, 0x7e, 0xde, 0x60, 0xf7, 0x25, 0xd9, 0x68, 0x6c, 0xb1, 0x8f, 0x13, 0xf2, 0xf1, 0x36,
-	0xfb, 0x04, 0x1d, 0xec, 0xe8, 0xb6, 0xc1, 0x1a, 0x48, 0xd9, 0xe6, 0x81, 0xc1, 0x1e, 0xe1, 0x17,
-	0x11, 0x23, 0x6e, 0x0b, 0xbf, 0x88, 0x54, 0xd7, 0xd6, 0x0f, 0x0e, 0xd9, 0x63, 0x14, 0x9a, 0x96,
-	0x6d, 0x88, 0x63, 0xbd, 0xcd, 0xb6, 0x31, 0x6a, 0xdd, 0x7a, 0x4e, 0x9a, 0x7f, 0x80, 0x1e, 0x5a,
-	0xfb, 0xba, 0x60, 0x5f, 0x20, 0x7c, 0xac, 0x0b, 0x62, 0xfe, 0x10, 0xe1, 0xaf, 0xba, 0x1d, 0x8b,
-	0xfd, 0x1c, 0x87, 0xd5, 0x34, 0x2d, 0x5d, 0x3c, 0x67, 0xbb, 0xe8, 0xf6, 0x58, 0x17, 0x09, 0xbb,
-	0x87, 0x21, 0xe9, 0x42, 0xe8, 0xcf, 0xd9, 0x37, 0x38, 0x33, 0xbb, 0x6d, 0xe3, 0xeb, 0xe6, 0xd1,
-	0xee, 0xae, 0x21, 0xd8, 0xb7, 0x64, 0xf5, 0xdc, 0x36, 0xf4, 0x27, 0xcc, 0x45, 0xc7, 0x44, 0x3f,
-	0xdc, 0x66, 0x1e, 0xda, 0x10, 0xc3, 0x86, 0x5c, 0x85, 0x7c, 0xd7, 0x68, 0xb3, 0xdf, 0x29, 0x1c,
-	0xa0, 0x68, 0x1f, 0x1d, 0xb6, 0x0d, 0xf6, 0xcf, 0x8a, 0xf6, 0x3f, 0x39, 0x28, 0xb6, 0x82, 0x49,
-	0x14, 0xf3, 0xeb, 0x50, 0xf2, 0x23, 0xcc, 0x4e, 0x4a, 0x69, 0x55, 0x24, 0x1c, 0x5f, 0x87, 0x82,
-	0x7f, 0xea, 0x8c, 0x29, 0x7f, 0xf3, 0xfb, 0x2b, 0x82, 0x38, 0x44, 0x5d, 0x44, 0x31, 0x79, 0x15,
-	0x44, 0xdd, 0x04, 0x8d, 0x10, 0xc5, 0xc4, 0xad, 0x20, 0x1a, 0x25, 0x68, 0x1f, 0x51, 0xcc, 0x5a,
-	0x15, 0xd1, 0x7e, 0x82, 0xce, 0x10, 0xc5, 0xb4, 0x2d, 0x20, 0x3a, 0x4b, 0xd0, 0x21, 0xa2, 0xe5,
-	0x0d, 0x65, 0x33, 0x87, 0x28, 0x72, 0xfc, 0x26, 0x94, 0x5d, 0x27, 0xf6, 0x50, 0xa0, 0x62, 0x96,
-	0xef, 0xaf, 0x88, 0x14, 0xe0, 0x1a, 0x54, 0x91, 0x8c, 0xfd, 0x13, 0x92, 0x57, 0x92, 0x30, 0xb3,
-	0x20, 0xff, 0x00, 0x6a, 0xae, 0x37, 0xf0, 0x4f, 0x9c, 0xf1, 0xf6, 0x16, 0x2a, 0x41, 0xa2, 0xb4,
-	0x84, 0xf2, 0x27, 0xb0, 0x9a, 0xf0, 0x0f, 0x1b, 0x4f, 0x50, 0xad, 0xba, 0xa1, 0x6c, 0x56, 0x1b,
-	0x4c, 0xee, 0xed, 0x85, 0x68, 0x7f, 0x45, 0x2c, 0x2b, 0xa2, 0x7f, 0xfc, 0x54, 0x14, 0x3b, 0x27,
-	0x53, 0x34, 0xac, 0xa5, 0xfe, 0xb3, 0x68, 0xb3, 0x0c, 0xc5, 0x53, 0x67, 0x3c, 0xf3, 0xb4, 0x5b,
-	0xa0, 0x1e, 0x3a, 0xa1, 0x73, 0x22, 0xbc, 0x21, 0x67, 0x90, 0x9f, 0x06, 0x11, 0xcd, 0x79, 0x51,
-	0x20, 0xa9, 0xdd, 0x82, 0xd2, 0xb1, 0x13, 0xa2, 0x8c, 0x43, 0x61, 0xe2, 0x9c, 0x78, 0x24, 0xac,
-	0x08, 0xa2, 0xb5, 0x9f, 0x41, 0xa9, 0x15, 0x8c, 0x51, 0x7a, 0x03, 0xca, 0xa1, 0x37, 0xee, 0x2d,
-	0xac, 0x4b, 0xa1, 0x37, 0x3e, 0x0c, 0x22, 0x14, 0x0c, 0x02, 0x29, 0xc8, 0x49, 0xc1, 0x20, 0x40,
-	0x81, 0x66, 0x03, 0xb4, 0x82, 0x30, 0xfc, 0xa9, 0xf6, 0x58, 0x6a, 0x5c, 0x6f, 0xba, 0x28, 0x59,
-	0xc4, 0x68, 0xf7, 0x40, 0x35, 0x5e, 0x4f, 0xc3, 0xb6, 0x1f, 0xc5, 0xfc, 0x36, 0x14, 0xc6, 0x7e,
-	0x14, 0xd7, 0x95, 0x8d, 0xfc, 0x66, 0xb5, 0x01, 0x72, 0xe6, 0x50, 0x2a, 0x08, 0xd7, 0xee, 0x01,
-	0xd8, 0x4e, 0x38, 0xf2, 0x62, 0xaa, 0xa0, 0xb7, 0x20, 0x1f, 0x9f, 0x4f, 0xe9, 0xeb, 0x73, 0x65,
-	0x14, 0x08, 0x84, 0xb5, 0x7f, 0x57, 0xa0, 0xda, 0x9d, 0xf5, 0xff, 0x78, 0xe6, 0x85, 0xe7, 0x18,
-	0xef, 0xe6, 0x42, 0x7b, 0xad, 0x71, 0x5d, 0x6a, 0x67, 0xe4, 0x0b, 0x4b, 0x1c, 0xc0, 0x24, 0x70,
-	0xbd, 0x9e, 0xef, 0xa6, 0x03, 0x40, 0xd6, 0x74, 0xf9, 0x1a, 0xe4, 0x82, 0x29, 0x45, 0x5f, 0x11,
-	0xb9, 0x60, 0xca, 0x37, 0xa0, 0x38, 0x78, 0xe1, 0x8f, 0x5d, 0x4a, 0xd8, 0xe5, 0x78, 0xa5, 0x40,
-	0xb3, 0x93, 0x62, 0x0f, 0x50, 0xea, 0xb6, 0xf4, 0xb6, 0x2e, 0xd8, 0x0a, 0xd2, 0xc6, 0xd7, 0x66,
-	0xd7, 0xee, 0x32, 0x05, 0x77, 0xa2, 0xd5, 0xb1, 0x7b, 0x09, 0x9f, 0xe3, 0x25, 0xc8, 0x99, 0x16,
-	0xcb, 0xa3, 0x0e, 0xe2, 0xa6, 0xc5, 0x0a, 0x69, 0x01, 0x2e, 0x12, 0xd1, 0x6e, 0xb3, 0x92, 0xf6,
-	0x6f, 0x0a, 0x54, 0x3a, 0xfd, 0x97, 0xde, 0x20, 0xc6, 0x81, 0x5d, 0x87, 0x52, 0xe4, 0x85, 0xa7,
-	0x5e, 0x48, 0x63, 0xcb, 0x8b, 0x84, 0xc3, 0x68, 0xdd, 0xbe, 0xdc, 0x77, 0x22, 0xe7, 0xf6, 0x49,
-	0x6f, 0xf0, 0xc2, 0x3b, 0x71, 0x68, 0x04, 0xa8, 0x47, 0x1c, 0xa6, 0x50, 0xd0, 0x7f, 0x49, 0x63,
-	0xc8, 0x0b, 0x24, 0xf9, 0x7b, 0x50, 0x95, 0x3e, 0x7a, 0x94, 0x3f, 0x45, 0x1a, 0x30, 0x48, 0xc8,
-	0x72, 0x4e, 0x3c, 0x9c, 0x21, 0xb7, 0x2f, 0x85, 0x25, 0x12, 0x96, 0xdc, 0x3e, 0x09, 0xd0, 0x92,
-	0xbc, 0x4a, 0x61, 0x39, 0xb1, 0x24, 0x88, 0x14, 0xde, 0x06, 0x35, 0xe8, 0xbf, 0x94, 0x52, 0x95,
-	0xa4, 0xe5, 0xa0, 0xff, 0x12, 0x45, 0xda, 0x7f, 0x29, 0xa0, 0xee, 0xce, 0x26, 0x83, 0x18, 0x8f,
-	0xaa, 0xf7, 0xa1, 0x30, 0x9c, 0x4d, 0x06, 0xc9, 0xe2, 0x5e, 0x91, 0x33, 0x3b, 0x1f, 0xb3, 0x20,
-	0x21, 0xa6, 0x8b, 0x13, 0x8e, 0x30, 0xcd, 0x2e, 0xa4, 0x0b, 0xe2, 0xda, 0x5f, 0x26, 0x1e, 0x77,
-	0xc7, 0xce, 0x08, 0x8b, 0xa4, 0xd5, 0xb1, 0x0c, 0xb6, 0x32, 0x2f, 0xb0, 0x96, 0xde, 0x66, 0x0a,
-	0x2d, 0x8d, 0xad, 0x37, 0xdb, 0x06, 0xcb, 0xa1, 0xe4, 0xb8, 0xd3, 0xd6, 0x6d, 0xb3, 0x6d, 0xb0,
-	0x82, 0x94, 0x08, 0xb3, 0x65, 0x33, 0x95, 0x33, 0xa8, 0x1d, 0x8a, 0xce, 0xce, 0x51, 0xcb, 0xe8,
-	0x59, 0x47, 0xed, 0x36, 0x63, 0xfc, 0x1a, 0x5c, 0x99, 0x23, 0x1d, 0x09, 0x6e, 0xa0, 0xc9, 0xb1,
-	0x2e, 0x74, 0xb1, 0xc7, 0x7e, 0x81, 0x15, 0x53, 0xdf, 0xdb, 0x63, 0xbf, 0xc6, 0xf3, 0x32, 0xff,
-	0xcc, 0xb4, 0xd8, 0xaf, 0x73, 0xda, 0xdf, 0xe5, 0xa1, 0x80, 0x01, 0xfe, 0x70, 0xee, 0xf2, 0x77,
-	0x40, 0x19, 0xd0, 0xca, 0x55, 0x1b, 0x55, 0x29, 0xa3, 0x22, 0xbb, 0xbf, 0x22, 0x14, 0x1c, 0xb5,
-	0x22, 0x93, 0xb0, 0xda, 0x58, 0x93, 0xc2, 0xb4, 0x1a, 0xa0, 0x7c, 0xca, 0x6f, 0x81, 0x72, 0x9a,
-	0x64, 0x64, 0x4d, 0xca, 0x65, 0x3d, 0x40, 0xe9, 0x29, 0xdf, 0x80, 0xfc, 0x20, 0x90, 0xc5, 0x74,
-	0x2e, 0x97, 0x3b, 0x7a, 0x7f, 0x45, 0xa0, 0x08, 0xfd, 0x0f, 0x69, 0x59, 0xe7, 0xfe, 0xd3, 0x55,
-	0x41, 0x0f, 0x43, 0x7e, 0x17, 0xf2, 0xd1, 0xac, 0x4f, 0x6b, 0x5b, 0x4d, 0x3b, 0x97, 0xcc, 0x46,
-	0x42, 0x37, 0xd1, 0xac, 0xcf, 0x3f, 0x84, 0xc2, 0x20, 0x08, 0x43, 0x5a, 0xe5, 0x79, 0x15, 0x5c,
-	0xd4, 0x0f, 0x2c, 0xce, 0x28, 0xe7, 0x1b, 0xa0, 0xc4, 0x54, 0x76, 0xe7, 0x4a, 0x8b, 0x2d, 0x8e,
-	0x1f, 0x8c, 0xf9, 0x07, 0x49, 0x55, 0x80, 0x6c, 0x4c, 0x69, 0xcd, 0x40, 0x3f, 0x28, 0xe5, 0xef,
-	0x02, 0xc4, 0xd8, 0x19, 0xc9, 0xdc, 0xaa, 0x52, 0x6e, 0x55, 0x08, 0x49, 0x13, 0x0f, 0xab, 0x12,
-	0x09, 0x6b, 0x32, 0xf1, 0x06, 0xc1, 0x18, 0x45, 0xcd, 0x12, 0x14, 0xbc, 0xd7, 0xd3, 0x50, 0x1b,
-	0x41, 0x75, 0xc7, 0x1b, 0x3a, 0xb3, 0x71, 0x4c, 0x4b, 0xb4, 0x0e, 0x45, 0xef, 0xb5, 0xac, 0x46,
-	0x78, 0xa0, 0x49, 0x86, 0x7f, 0x94, 0x54, 0xe1, 0x64, 0x79, 0xae, 0x65, 0x96, 0xc7, 0x99, 0xc4,
-	0xc7, 0x28, 0x12, 0x52, 0x03, 0x77, 0x89, 0x1f, 0xf5, 0xe8, 0x4c, 0xcc, 0xa7, 0x67, 0xa2, 0x35,
-	0x1b, 0x8f, 0xb5, 0xdf, 0xe6, 0x61, 0x75, 0xc9, 0x82, 0xbf, 0x0b, 0x95, 0xd9, 0xe4, 0xd5, 0x24,
-	0x38, 0x9b, 0xf4, 0x4e, 0x65, 0x39, 0xdd, 0x5f, 0x11, 0x6a, 0x02, 0x1d, 0xf3, 0xb7, 0xa1, 0xec,
-	0x4f, 0xe2, 0xed, 0xad, 0xde, 0xe9, 0xfc, 0x1c, 0x2d, 0x11, 0x70, 0xcc, 0xef, 0x40, 0x75, 0x7e,
-	0x0a, 0xf5, 0x4e, 0xe5, 0xd6, 0xde, 0x5f, 0x11, 0x30, 0x07, 0x8f, 0xf9, 0xe3, 0xf9, 0xf1, 0xf5,
-	0xb0, 0xf1, 0xa4, 0x97, 0xe6, 0xc6, 0x65, 0xe7, 0x52, 0x75, 0xc1, 0x1d, 0xf3, 0x77, 0x40, 0x9d,
-	0xa5, 0x5f, 0x2d, 0x26, 0xa7, 0x6c, 0x79, 0x96, 0x7c, 0xf6, 0x5d, 0xa8, 0x0c, 0xc7, 0x81, 0x13,
-	0x3f, 0x6a, 0xf4, 0x4e, 0x29, 0x59, 0xf0, 0xb4, 0x55, 0x13, 0x68, 0x21, 0x26, 0xe3, 0x72, 0x72,
-	0xc8, 0xab, 0x09, 0x74, 0xcc, 0x6f, 0x40, 0x09, 0xcf, 0xd7, 0xde, 0xe9, 0xfc, 0x3c, 0x2e, 0x22,
-	0x7f, 0xcc, 0xdf, 0x03, 0x40, 0xc2, 0xf6, 0x4f, 0x50, 0x98, 0x1e, 0xc6, 0x95, 0x14, 0xa3, 0xe1,
-	0xe2, 0xa1, 0xd8, 0xc5, 0x43, 0xb1, 0x77, 0x3a, 0x3f, 0x89, 0x61, 0x0e, 0x52, 0xdc, 0x51, 0x1c,
-	0xfa, 0x93, 0x51, 0xef, 0x54, 0xa6, 0x01, 0xc6, 0x2d, 0x11, 0xfa, 0x72, 0x3f, 0x08, 0xc6, 0xbd,
-	0x53, 0x4a, 0x02, 0x6c, 0x27, 0x8a, 0xc8, 0x1f, 0x37, 0xaf, 0xc0, 0xea, 0x20, 0xbb, 0x24, 0xda,
-	0xc7, 0x00, 0x8b, 0xd9, 0xc0, 0x62, 0xda, 0x0e, 0x92, 0x02, 0x9b, 0x6b, 0x07, 0xc8, 0xef, 0xfb,
-	0x69, 0x71, 0xdd, 0xf7, 0xb1, 0x24, 0xe3, 0xc1, 0xba, 0x73, 0xf9, 0xb1, 0xcb, 0x3f, 0x80, 0xbc,
-	0x33, 0x1e, 0x91, 0xfe, 0x5a, 0x83, 0xa7, 0x39, 0x73, 0x32, 0x0d, 0xbd, 0x28, 0x92, 0xdb, 0xde,
-	0x19, 0x8f, 0xd2, 0xa2, 0x90, 0xbf, 0xbc, 0x28, 0xdc, 0x87, 0xb2, 0x2b, 0xd3, 0x33, 0x59, 0xc1,
-	0x64, 0xef, 0x65, 0x72, 0x56, 0xa4, 0x1a, 0xbc, 0x0e, 0xe5, 0x69, 0xe8, 0x9f, 0x38, 0xe1, 0xb9,
-	0xec, 0x9b, 0x44, 0xca, 0x62, 0x5a, 0x4f, 0x5f, 0xf9, 0xee, 0xeb, 0xb4, 0xe1, 0x27, 0x06, 0x51,
-	0x67, 0xec, 0x3b, 0x51, 0x52, 0xb2, 0x25, 0xa3, 0xfd, 0x46, 0x01, 0xd5, 0x9c, 0xb8, 0xde, 0x6b,
-	0x1c, 0xd7, 0xbd, 0xec, 0x01, 0x5a, 0x97, 0xdf, 0x4e, 0x85, 0x92, 0x58, 0xc4, 0x9a, 0xce, 0x41,
-	0x2e, 0x33, 0x07, 0xef, 0x40, 0x25, 0xdd, 0x81, 0x51, 0x3d, 0xbf, 0x91, 0xdf, 0xac, 0x08, 0x35,
-	0xd9, 0x82, 0x91, 0xf6, 0x00, 0x2a, 0x73, 0x17, 0xd8, 0x83, 0x9a, 0xd6, 0xb1, 0x6e, 0xb6, 0x77,
-	0xd8, 0x0a, 0x32, 0xdf, 0x74, 0x2c, 0xe3, 0x40, 0x3f, 0x64, 0x0a, 0x1e, 0x81, 0xcd, 0xae, 0xc9,
-	0x72, 0xda, 0x5d, 0x58, 0x3d, 0x94, 0x03, 0x7a, 0xea, 0x9d, 0x63, 0x74, 0xeb, 0x50, 0x94, 0x9e,
-	0x15, 0xf2, 0x2c, 0x19, 0xad, 0x01, 0xea, 0x61, 0x18, 0x4c, 0xbd, 0x30, 0x3e, 0xc7, 0x73, 0xee,
-	0x95, 0x77, 0x9e, 0x2c, 0x0b, 0x92, 0x68, 0xb3, 0xd8, 0xcb, 0x95, 0x64, 0xdb, 0x6a, 0x5f, 0xa2,
-	0x6b, 0xb2, 0xf1, 0xbd, 0x08, 0x5d, 0x3f, 0x00, 0x98, 0xce, 0x81, 0xa4, 0x37, 0x49, 0x2b, 0x6f,
-	0xe2, 0x5c, 0x64, 0x34, 0xb4, 0xdf, 0xe4, 0x40, 0xb5, 0xb1, 0xf0, 0x7c, 0x5f, 0x36, 0x6c, 0x60,
-	0x69, 0x1c, 0xa7, 0xe7, 0xd6, 0xa2, 0x08, 0xef, 0xe0, 0xc9, 0x86, 0x12, 0x7e, 0x0f, 0x0a, 0xae,
-	0x37, 0x94, 0xd3, 0x54, 0x4d, 0xbb, 0x95, 0xd4, 0x27, 0xae, 0x38, 0x4d, 0x35, 0xe9, 0x2c, 0x96,
-	0xae, 0x90, 0x59, 0xba, 0x9b, 0x7f, 0xad, 0x40, 0x39, 0xd1, 0xe3, 0x77, 0x21, 0x37, 0x7d, 0x95,
-	0x9c, 0x35, 0xd7, 0xd2, 0xc0, 0x33, 0x93, 0xb7, 0xbf, 0x22, 0x72, 0xd3, 0x57, 0x5c, 0x83, 0x3c,
-	0xe6, 0x45, 0x2e, 0x5b, 0x66, 0xd3, 0x05, 0xc6, 0xaa, 0x8e, 0x79, 0xf2, 0x78, 0x69, 0x2e, 0xf2,
-	0xcb, 0x2e, 0x33, 0x93, 0x86, 0x7b, 0x72, 0xa1, 0xd8, 0x2c, 0x42, 0xde, 0xf5, 0x86, 0x5a, 0x08,
-	0x85, 0x56, 0x10, 0xc5, 0x38, 0x29, 0x03, 0x27, 0x94, 0xb7, 0x5f, 0x45, 0x10, 0x8d, 0x19, 0x1b,
-	0x06, 0x67, 0x74, 0x3f, 0xcd, 0x11, 0x9c, 0xb2, 0xb8, 0x70, 0x13, 0x57, 0x96, 0x36, 0x45, 0x20,
-	0x49, 0x97, 0xd6, 0xd8, 0x09, 0xe5, 0x46, 0x50, 0x84, 0x64, 0x10, 0x8d, 0x83, 0x38, 0xb9, 0x29,
-	0x28, 0x42, 0x32, 0xda, 0x3f, 0x2a, 0x50, 0xc6, 0xb9, 0x75, 0x62, 0x07, 0x53, 0x30, 0x0c, 0xce,
-	0x7a, 0x83, 0x60, 0x36, 0x89, 0x93, 0xae, 0x55, 0x0d, 0x83, 0xb3, 0x16, 0xf2, 0x78, 0x80, 0x60,
-	0xad, 0x4e, 0xa4, 0xb2, 0xf3, 0xab, 0x20, 0x22, 0xc5, 0x98, 0x60, 0xb3, 0xf1, 0x58, 0xae, 0x89,
-	0x2a, 0x24, 0x83, 0xb1, 0xf9, 0x8f, 0x1a, 0xf5, 0xc2, 0x46, 0x1e, 0xfb, 0x6f, 0xff, 0x51, 0x83,
-	0x90, 0xed, 0xad, 0x7a, 0x71, 0x23, 0x8f, 0xed, 0x94, 0xbf, 0xbd, 0x85, 0xc8, 0xf0, 0x51, 0xa3,
-	0x5e, 0xda, 0xc8, 0x6f, 0xe6, 0x04, 0x92, 0x84, 0x6c, 0x6f, 0xd5, 0xcb, 0x1b, 0x79, 0x1c, 0xd1,
-	0x70, 0x7b, 0x8b, 0xd7, 0x40, 0x89, 0xea, 0x2a, 0xa5, 0xae, 0x12, 0x69, 0xcf, 0x00, 0x44, 0x70,
-	0x16, 0x79, 0x31, 0x45, 0xfd, 0xe1, 0xbc, 0x71, 0x53, 0xb2, 0x4b, 0x93, 0xa6, 0xc3, 0xbc, 0x91,
-	0xbb, 0xb3, 0x94, 0x56, 0xab, 0x8b, 0xb4, 0x72, 0x62, 0x47, 0xe6, 0x95, 0xf6, 0x1f, 0x0a, 0x54,
-	0x3b, 0xa1, 0xeb, 0x85, 0xcd, 0xf3, 0xee, 0xd4, 0xa3, 0x0e, 0x0a, 0x8f, 0xbe, 0xe5, 0x3e, 0x44,
-	0x76, 0x50, 0x9e, 0x6c, 0x53, 0x70, 0xcf, 0x8e, 0x1d, 0x3c, 0xfd, 0x93, 0x5d, 0xb2, 0x00, 0xf8,
-	0x43, 0x28, 0x0c, 0xc7, 0xce, 0x88, 0x56, 0x66, 0xad, 0xf1, 0x6e, 0xd2, 0xa4, 0x2d, 0xdc, 0xa7,
-	0x34, 0xf6, 0x5f, 0x82, 0x54, 0xb5, 0x6f, 0xe7, 0xdf, 0xa7, 0xa6, 0x0c, 0x5b, 0xda, 0x6e, 0x4b,
-	0x3e, 0x2e, 0xec, 0x18, 0xdd, 0x16, 0x53, 0xf8, 0x15, 0xa8, 0x62, 0x33, 0xd5, 0xed, 0xed, 0x9a,
-	0xa2, 0x6b, 0xb3, 0x1c, 0xf5, 0xc8, 0x04, 0xb4, 0xf5, 0xae, 0x2d, 0xdb, 0xb2, 0x23, 0xcb, 0xfc,
-	0xe5, 0x91, 0xc1, 0xd4, 0xa5, 0x56, 0x8e, 0x61, 0xbf, 0x07, 0xcf, 0xfc, 0x89, 0x1b, 0x9c, 0xd1,
-	0xe0, 0x3e, 0x81, 0xda, 0xd4, 0x09, 0x63, 0x1f, 0x63, 0xed, 0xf5, 0xcf, 0x2f, 0xb9, 0x55, 0x54,
-	0xe7, 0xf2, 0xe6, 0x39, 0xff, 0x18, 0xd4, 0x00, 0x43, 0x43, 0x55, 0x39, 0x85, 0x57, 0x2f, 0x8c,
-	0x48, 0x94, 0x03, 0xc9, 0x60, 0x0a, 0x8f, 0x3d, 0xc7, 0x4d, 0xee, 0x32, 0x44, 0xe3, 0xb2, 0xe2,
-	0x74, 0xc8, 0x77, 0x17, 0x24, 0xb5, 0x7f, 0x52, 0x00, 0x8e, 0xa6, 0x78, 0x7c, 0x99, 0x93, 0x61,
-	0x80, 0x1d, 0xc1, 0x34, 0xf4, 0x7b, 0x8b, 0x32, 0x54, 0x9a, 0x86, 0xfe, 0x53, 0xef, 0x9c, 0xdf,
-	0x86, 0x6a, 0x22, 0xe8, 0xa5, 0x5b, 0x90, 0x5e, 0x6e, 0x50, 0x68, 0xba, 0xaf, 0xb1, 0x7b, 0x79,
-	0xe1, 0xbb, 0x1e, 0x59, 0xca, 0xfb, 0x47, 0x19, 0x79, 0x34, 0xbd, 0x03, 0xb5, 0x19, 0x7d, 0xa1,
-	0xe7, 0xc4, 0x71, 0x18, 0x51, 0x2a, 0x56, 0x44, 0x55, 0x62, 0x3a, 0x42, 0xd8, 0x95, 0x07, 0xf1,
-	0x0b, 0x2f, 0x4c, 0x34, 0x8a, 0xa4, 0x01, 0x04, 0xcd, 0x15, 0x50, 0xd4, 0xa3, 0xc1, 0x45, 0x94,
-	0xa9, 0x15, 0x01, 0x08, 0xd1, 0xd8, 0x23, 0xed, 0xcf, 0xaa, 0x50, 0xb0, 0x02, 0xd7, 0xe3, 0x9f,
-	0x41, 0x85, 0xee, 0x46, 0xf1, 0xf9, 0xd4, 0x4b, 0x8e, 0x82, 0x64, 0xfb, 0xa3, 0x98, 0xfe, 0x50,
-	0x69, 0x52, 0x27, 0x09, 0xf5, 0xfd, 0xb7, 0xa9, 0xdb, 0x98, 0xae, 0x51, 0xbc, 0x7c, 0xdc, 0x61,
-	0x79, 0x10, 0x84, 0xd3, 0xf2, 0x85, 0x01, 0x76, 0xfc, 0x3d, 0x6a, 0xff, 0x0a, 0x97, 0x2c, 0x9f,
-	0x94, 0xd3, 0xdd, 0xf1, 0x26, 0xa8, 0x74, 0xe7, 0x0a, 0xbd, 0x09, 0x8d, 0xb0, 0x28, 0xe6, 0x3c,
-	0x46, 0xfd, 0x32, 0xf0, 0x27, 0x32, 0xea, 0xd2, 0x85, 0xa8, 0xbf, 0x0a, 0xfc, 0x09, 0xe5, 0xa8,
-	0x8a, 0x5a, 0x14, 0xf5, 0xfb, 0x50, 0x0e, 0x26, 0xf2, 0xbb, 0xe5, 0x0b, 0xdf, 0x2d, 0x05, 0x13,
-	0xfa, 0xe4, 0x7d, 0xa8, 0x0e, 0xfd, 0x71, 0xec, 0x85, 0x52, 0x51, 0xbd, 0xa0, 0x08, 0x52, 0x4c,
-	0xca, 0x77, 0x41, 0x1d, 0x85, 0xc1, 0x6c, 0x8a, 0xe9, 0x55, 0xb9, 0xa0, 0x59, 0x26, 0x59, 0xf3,
-	0x1c, 0x47, 0x4d, 0x24, 0xf6, 0x2f, 0x91, 0x87, 0x4d, 0xef, 0x85, 0x51, 0xa7, 0xf2, 0xae, 0x47,
-	0x5e, 0x9d, 0xd1, 0x48, 0x7e, 0xbf, 0x7a, 0xd1, 0xab, 0x33, 0x1a, 0xd1, 0xc7, 0xb3, 0xb9, 0x5d,
-	0xfb, 0xbd, 0xb9, 0xfd, 0x10, 0x92, 0xf4, 0xe9, 0xf9, 0x93, 0x61, 0x50, 0x5f, 0xcd, 0xf6, 0x8b,
-	0x8b, 0x6c, 0x16, 0x30, 0x5b, 0x64, 0xf6, 0x7d, 0x50, 0xcf, 0xfc, 0x49, 0x2f, 0x9a, 0x7a, 0x83,
-	0xfa, 0x5a, 0x56, 0x7f, 0xb1, 0x1f, 0x45, 0xf9, 0xcc, 0x9f, 0xd0, 0xc6, 0xdc, 0x80, 0xe2, 0xd8,
-	0x3f, 0xf1, 0xe3, 0xfa, 0x95, 0x8b, 0xf7, 0x66, 0x12, 0x70, 0x0d, 0x4a, 0xc1, 0x70, 0x88, 0xe3,
-	0x67, 0x17, 0x54, 0x12, 0x09, 0xbf, 0x0f, 0xb2, 0xbd, 0xef, 0xb9, 0xde, 0xb0, 0x7e, 0xf5, 0xd2,
-	0xca, 0xa8, 0xc6, 0xe9, 0x31, 0xbc, 0x09, 0x78, 0xcf, 0xec, 0x85, 0xde, 0xb0, 0xce, 0x2f, 0xbf,
-	0x52, 0x96, 0x82, 0xfe, 0x4b, 0xbc, 0x4e, 0x3f, 0x84, 0x6a, 0x48, 0xb5, 0xb7, 0xe7, 0x3a, 0xb1,
-	0x53, 0xbf, 0x96, 0x1d, 0xcc, 0xa2, 0x28, 0x0b, 0x08, 0x17, 0x05, 0xfa, 0x7d, 0x58, 0xf5, 0x5e,
-	0xc7, 0xa1, 0xd3, 0x0b, 0xa6, 0x58, 0x4b, 0xa2, 0xfa, 0x3a, 0x6d, 0xd1, 0x1a, 0x81, 0x1d, 0x89,
-	0x71, 0x0d, 0x6a, 0xb3, 0xc8, 0xdb, 0xf1, 0xc6, 0x5e, 0x8c, 0xfb, 0xb6, 0xfe, 0x96, 0xd4, 0xc9,
-	0x62, 0xda, 0x5f, 0xe4, 0x41, 0x4d, 0xb7, 0x10, 0xbd, 0x7a, 0x5a, 0x4f, 0xad, 0xce, 0x33, 0x8b,
-	0xad, 0x60, 0x11, 0x3c, 0xd6, 0xdb, 0x47, 0x46, 0xaf, 0xdb, 0xd2, 0x2d, 0xf9, 0x70, 0x40, 0x97,
-	0x56, 0xc9, 0xe7, 0xf8, 0x55, 0x58, 0xdd, 0x3d, 0xb2, 0x5a, 0xb6, 0xd9, 0xb1, 0x24, 0x94, 0x47,
-	0xc8, 0xf8, 0x5a, 0xd6, 0x46, 0x09, 0x15, 0x10, 0x3a, 0xd0, 0x6d, 0x43, 0x98, 0x29, 0x54, 0xc4,
-	0xaf, 0x1c, 0x8a, 0xce, 0x57, 0x46, 0xcb, 0x66, 0xc0, 0xdf, 0x82, 0xab, 0x73, 0x93, 0xd4, 0x1d,
-	0xab, 0x62, 0x95, 0x4d, 0xcd, 0xd8, 0x3a, 0x3a, 0x11, 0x46, 0xeb, 0x48, 0x74, 0xcd, 0x63, 0xa3,
-	0xd7, 0xb2, 0x0d, 0xf6, 0x16, 0x3d, 0x0d, 0x9b, 0xd6, 0x53, 0x76, 0x9d, 0xaf, 0x42, 0x05, 0x29,
-	0xe9, 0xfd, 0x06, 0xd5, 0xf7, 0xbd, 0x3d, 0x76, 0x1b, 0x8b, 0xf6, 0xae, 0xd9, 0xb6, 0x0d, 0xc1,
-	0xde, 0xa3, 0xe7, 0xca, 0x8e, 0x69, 0xc9, 0xeb, 0x72, 0x57, 0x3f, 0x38, 0x6c, 0x1b, 0xec, 0x0e,
-	0xf9, 0xe8, 0x08, 0x9b, 0x69, 0xf4, 0x78, 0x6a, 0xe1, 0x97, 0xdf, 0x47, 0x77, 0x44, 0xf6, 0xf4,
-	0x76, 0x9b, 0x7d, 0x90, 0x29, 0xfd, 0x77, 0x91, 0x7e, 0x66, 0x5a, 0x3b, 0x9d, 0x67, 0xf2, 0xcd,
-	0xb6, 0x29, 0x3a, 0xfa, 0x4e, 0x0b, 0x4f, 0x08, 0x7a, 0xa9, 0xed, 0x1e, 0xb6, 0x4d, 0x9b, 0x7d,
-	0x84, 0x5a, 0x7b, 0xba, 0xbd, 0x6f, 0x08, 0x76, 0x8f, 0xde, 0x7c, 0xbb, 0x5d, 0x43, 0xd8, 0xac,
-	0x21, 0x5f, 0xa3, 0x89, 0x7e, 0x44, 0x5e, 0x0f, 0xe9, 0x8d, 0x76, 0x0b, 0xe9, 0x1d, 0xa3, 0x6d,
-	0xd8, 0x06, 0x7b, 0xac, 0xbd, 0x04, 0x35, 0xad, 0x0c, 0xf2, 0x21, 0xdb, 0x32, 0x84, 0x3c, 0xaa,
-	0xda, 0xc6, 0xae, 0xcd, 0x14, 0x04, 0x85, 0xb9, 0xb7, 0x8f, 0x87, 0x54, 0x05, 0x8a, 0x9d, 0x23,
-	0x1c, 0x5e, 0x9e, 0x06, 0x62, 0x1c, 0x98, 0xac, 0x80, 0x94, 0x6e, 0xd9, 0x26, 0x2b, 0xd2, 0x40,
-	0x4d, 0x6b, 0xaf, 0x6d, 0xb0, 0x12, 0xa2, 0x07, 0xba, 0x78, 0xca, 0xca, 0xf4, 0x24, 0x7b, 0x78,
-	0xd8, 0x7e, 0xce, 0x54, 0x6d, 0x13, 0xca, 0xfa, 0x68, 0x74, 0x80, 0x25, 0x56, 0x85, 0xc2, 0xee,
-	0x51, 0xbb, 0x2d, 0x5f, 0x8a, 0x9a, 0x1d, 0xdb, 0xee, 0x1c, 0xc8, 0xce, 0xd7, 0xee, 0x1c, 0xb2,
-	0x9c, 0xf6, 0x57, 0x39, 0x28, 0xfe, 0x12, 0xef, 0xda, 0x7c, 0x1b, 0x2a, 0x51, 0x7c, 0x12, 0x67,
-	0x6b, 0xf1, 0xdb, 0x32, 0x4f, 0x49, 0xfe, 0xa0, 0x1b, 0x3b, 0xb1, 0x77, 0xe2, 0x4d, 0x62, 0x59,
-	0x91, 0x51, 0x97, 0x12, 0x8b, 0xba, 0x27, 0x6f, 0x2a, 0x1b, 0x85, 0xa2, 0x90, 0x0c, 0x6e, 0x4a,
-	0x2c, 0xcc, 0x69, 0xcf, 0x09, 0x8b, 0xfa, 0x28, 0xa4, 0x00, 0x37, 0xe5, 0xd4, 0x09, 0x9d, 0x93,
-	0xe8, 0x92, 0x52, 0x9c, 0x48, 0xb0, 0x0a, 0xbf, 0xf0, 0x1c, 0xd7, 0x9f, 0x8c, 0xd2, 0x73, 0x66,
-	0xce, 0x6b, 0xcf, 0x60, 0x75, 0x29, 0xa4, 0xe5, 0x0c, 0xc7, 0x29, 0x32, 0xda, 0x98, 0x87, 0x4a,
-	0x66, 0x75, 0x72, 0x99, 0x15, 0xc9, 0x67, 0x56, 0xaa, 0x80, 0x93, 0x77, 0x60, 0x88, 0x3d, 0x83,
-	0x15, 0xb5, 0xdf, 0xe6, 0xe0, 0xaa, 0x1d, 0x3a, 0x93, 0x88, 0xda, 0x92, 0x56, 0x30, 0x89, 0xc3,
-	0x60, 0xcc, 0x7f, 0x06, 0x6a, 0x3c, 0x18, 0x67, 0x67, 0xe7, 0xbd, 0xa4, 0x3c, 0xbc, 0xa9, 0xfa,
-	0xc0, 0x1e, 0x8c, 0x69, 0x8e, 0xca, 0xb1, 0x24, 0xf8, 0x27, 0x50, 0xec, 0x7b, 0x23, 0x7f, 0x92,
-	0x34, 0xc3, 0x6f, 0xbd, 0x69, 0xd8, 0x44, 0x21, 0x5d, 0x1e, 0x91, 0xe0, 0x9f, 0x41, 0x69, 0x10,
-	0x9c, 0x60, 0x45, 0x93, 0x87, 0xd9, 0xf5, 0x8b, 0x1f, 0x42, 0x29, 0x5e, 0xdb, 0xa5, 0x1e, 0xdf,
-	0x06, 0x35, 0x0c, 0xc6, 0xe3, 0xbe, 0x33, 0x78, 0x95, 0xdc, 0xe6, 0xea, 0x6f, 0xda, 0x88, 0x44,
-	0x8e, 0x37, 0xe7, 0x54, 0x57, 0x7b, 0x00, 0xe5, 0x24, 0x58, 0x7a, 0x9c, 0x37, 0xf6, 0xcc, 0x64,
-	0xee, 0x5a, 0x9d, 0x83, 0x03, 0x13, 0xe7, 0xae, 0x06, 0xaa, 0xe8, 0xb4, 0xdb, 0x4d, 0xbd, 0xf5,
-	0x94, 0xe5, 0x9a, 0x2a, 0x94, 0x1c, 0x7a, 0xbb, 0xd1, 0xfe, 0x54, 0x81, 0x2b, 0x6f, 0x0c, 0x80,
-	0x3f, 0x81, 0xc2, 0x49, 0xe0, 0xa6, 0xd3, 0xf3, 0xc1, 0xa5, 0xa3, 0xcc, 0xf0, 0x98, 0x9e, 0x82,
-	0x2c, 0xb4, 0xcf, 0x61, 0x6d, 0x19, 0xcf, 0xbc, 0xaf, 0xad, 0x42, 0x45, 0x18, 0xfa, 0x4e, 0xaf,
-	0x63, 0xb5, 0x9f, 0xcb, 0x52, 0x45, 0xec, 0x33, 0x61, 0xda, 0x06, 0xcb, 0x69, 0xdf, 0x02, 0x7b,
-	0x73, 0x62, 0xf8, 0x1e, 0x5c, 0x19, 0x04, 0x27, 0xd3, 0xb1, 0x47, 0xbd, 0x5a, 0x66, 0xc9, 0x6e,
-	0x5f, 0x32, 0x93, 0x89, 0x1a, 0xad, 0xd8, 0xda, 0x60, 0x89, 0xd7, 0xfe, 0x08, 0xf8, 0xc5, 0x19,
-	0xfc, 0xbf, 0x73, 0xff, 0xe7, 0x0a, 0x14, 0x0e, 0xc7, 0xce, 0x84, 0xbf, 0x0f, 0x45, 0x7a, 0xf0,
-	0x4a, 0x3a, 0xe7, 0x6a, 0x66, 0xdf, 0x61, 0x5a, 0x90, 0x8c, 0xdf, 0x87, 0x7c, 0x3c, 0x18, 0x27,
-	0x39, 0x74, 0xe3, 0x7b, 0x92, 0x0f, 0x6f, 0x56, 0xf1, 0x60, 0xcc, 0x37, 0x21, 0xef, 0xba, 0xe3,
-	0x24, 0x81, 0xd6, 0x93, 0xab, 0xbd, 0x13, 0x3b, 0x3b, 0xde, 0xd0, 0x9f, 0xf8, 0xc9, 0xf3, 0x1b,
-	0xaa, 0x34, 0x4b, 0x40, 0xbf, 0x3c, 0x6a, 0x7f, 0x52, 0x81, 0xb5, 0x65, 0x0d, 0xfe, 0xff, 0x41,
-	0x75, 0xdd, 0xa5, 0x9c, 0xbf, 0x75, 0x99, 0xa7, 0x07, 0x3b, 0x6e, 0x92, 0xf0, 0xae, 0x24, 0xf8,
-	0x9d, 0x74, 0x3c, 0xb9, 0x0b, 0xe3, 0x49, 0x47, 0xf3, 0x25, 0x5c, 0x19, 0x84, 0x1e, 0x76, 0x05,
-	0x78, 0x30, 0xf6, 0x9d, 0xc8, 0x5b, 0x0e, 0xb6, 0x45, 0xc2, 0x9d, 0x44, 0xb6, 0xbf, 0x22, 0xd6,
-	0x06, 0x4b, 0x08, 0xff, 0x02, 0xd6, 0x1c, 0xea, 0x96, 0xe6, 0xf6, 0x85, 0xec, 0xfd, 0x51, 0x47,
-	0x59, 0xc6, 0x7c, 0xd5, 0xc9, 0x02, 0xfc, 0x73, 0x58, 0x75, 0xc3, 0x60, 0xba, 0x30, 0x96, 0x4f,
-	0x98, 0xc9, 0x63, 0xca, 0x4e, 0x18, 0x4c, 0x33, 0xb6, 0x35, 0x37, 0xc3, 0xf3, 0x6d, 0xa8, 0x25,
-	0x91, 0x53, 0x3f, 0x90, 0x3c, 0x6e, 0x5e, 0xcd, 0x86, 0x4d, 0x2d, 0xc3, 0xfe, 0x8a, 0xa8, 0x0e,
-	0x16, 0x2c, 0x7f, 0x04, 0x55, 0x19, 0xb0, 0x34, 0x2b, 0x67, 0x5b, 0x01, 0x8a, 0x36, 0xb5, 0x02,
-	0x67, 0xce, 0xf1, 0xcf, 0x00, 0x28, 0x4e, 0x69, 0xa3, 0x66, 0x9b, 0x0d, 0x0c, 0x32, 0x35, 0xa9,
-	0xb8, 0x29, 0x93, 0x09, 0xcf, 0xc7, 0xdb, 0x76, 0xf2, 0x18, 0xba, 0x14, 0x1e, 0x5d, 0xc3, 0x17,
-	0xe1, 0x11, 0xbb, 0x08, 0x4f, 0x9a, 0xc1, 0x85, 0xf0, 0x52, 0x2b, 0x19, 0x9e, 0x34, 0x4a, 0xc3,
-	0x93, 0x36, 0xd5, 0x37, 0xc3, 0x4b, 0x4d, 0x28, 0x3c, 0x69, 0xf1, 0x05, 0xac, 0xc5, 0xe1, 0x6c,
-	0x32, 0x58, 0xcc, 0x5f, 0x2d, 0xbb, 0x6c, 0x76, 0x22, 0x4b, 0x07, 0xb6, 0x1a, 0x67, 0x01, 0xb4,
-	0x8e, 0x5e, 0x04, 0x67, 0xbd, 0x53, 0x27, 0xf4, 0x11, 0x88, 0x92, 0x76, 0x32, 0xb1, 0xee, 0xbe,
-	0x08, 0xce, 0x8e, 0x53, 0x11, 0x5a, 0x47, 0x59, 0x40, 0xfb, 0x9b, 0x3c, 0x94, 0x93, 0x5c, 0xe5,
-	0xd7, 0xe0, 0x4a, 0x4b, 0x18, 0xba, 0x6d, 0xf4, 0x76, 0x74, 0x5b, 0x6f, 0xea, 0x5d, 0xac, 0x35,
-	0x1c, 0xd6, 0x74, 0x6c, 0x2b, 0x16, 0x98, 0x82, 0x0d, 0xca, 0x8e, 0xe8, 0x1c, 0x2e, 0xa0, 0x1c,
-	0x67, 0x50, 0x4b, 0x6c, 0xe5, 0x53, 0x7f, 0x1e, 0xaf, 0x99, 0xd2, 0x50, 0x02, 0x05, 0xfa, 0xb9,
-	0x18, 0xad, 0x24, 0x5f, 0xcc, 0x98, 0x98, 0xd6, 0x8e, 0xf1, 0x35, 0x2b, 0x2d, 0x4c, 0x24, 0x50,
-	0x9e, 0x9b, 0x48, 0x5e, 0xc5, 0x60, 0x6c, 0x71, 0x64, 0xb5, 0x16, 0xdf, 0xa9, 0xf0, 0x1b, 0x70,
-	0xad, 0xbb, 0xdf, 0x79, 0xd6, 0x93, 0xbe, 0xe6, 0x21, 0x01, 0x5f, 0x07, 0x96, 0x11, 0x48, 0xf5,
-	0x2a, 0xba, 0x20, 0x34, 0x55, 0xec, 0xb2, 0x1a, 0x7e, 0x97, 0x30, 0xd2, 0xe9, 0xb2, 0x55, 0x0c,
-	0x4d, 0x9a, 0x76, 0xda, 0x47, 0x07, 0x56, 0x97, 0xad, 0x61, 0x24, 0x84, 0xc8, 0x48, 0xae, 0xcc,
-	0xdd, 0x1c, 0xeb, 0xc2, 0x94, 0x56, 0x0c, 0xa7, 0x85, 0xb0, 0x67, 0xba, 0xb0, 0x4c, 0x6b, 0xaf,
-	0xcb, 0xae, 0xce, 0x3d, 0x1b, 0x42, 0x74, 0x44, 0x97, 0xf1, 0x39, 0xd0, 0xb5, 0x75, 0xfb, 0xa8,
-	0xcb, 0xae, 0xcd, 0xa3, 0x3c, 0x14, 0x9d, 0x96, 0xd1, 0xed, 0xb6, 0xcd, 0xae, 0xcd, 0xd6, 0x9b,
-	0x35, 0x00, 0x77, 0x5e, 0x4c, 0xb4, 0x43, 0x58, 0x5b, 0xde, 0xfb, 0x5c, 0x83, 0x55, 0x7f, 0xd8,
-	0x9b, 0x04, 0x71, 0x8f, 0x1e, 0xcd, 0xa3, 0xe4, 0x09, 0xbd, 0xea, 0x0f, 0xad, 0x20, 0x36, 0x08,
-	0xc2, 0x4e, 0x61, 0xbe, 0x95, 0xe5, 0xcb, 0xc2, 0x9c, 0xd7, 0xf6, 0x61, 0x75, 0xa9, 0x1a, 0xf0,
-	0x77, 0xa0, 0xe2, 0x0f, 0x97, 0x9d, 0xa9, 0xfe, 0xf0, 0x47, 0x78, 0xda, 0x83, 0x5a, 0xb6, 0x34,
-	0xfc, 0x74, 0x47, 0x7f, 0xab, 0x40, 0x35, 0x53, 0x2a, 0x7e, 0xd4, 0x10, 0x6f, 0x41, 0x25, 0xf6,
-	0x4e, 0xa6, 0x41, 0xe8, 0x24, 0x85, 0x55, 0x15, 0x0b, 0x60, 0xe9, 0x6b, 0xf9, 0xe5, 0xaf, 0x2d,
-	0xdf, 0x6d, 0x0a, 0x3f, 0x7c, 0xb7, 0xd1, 0x3a, 0x00, 0x8b, 0x6a, 0x44, 0xaf, 0x60, 0xb4, 0x4b,
-	0xe5, 0x0b, 0x83, 0x64, 0x96, 0x1d, 0xe6, 0x7e, 0x8f, 0xc3, 0x6f, 0xa0, 0x32, 0x2f, 0x55, 0x3f,
-	0x79, 0xc6, 0x16, 0x81, 0xe4, 0x33, 0x81, 0x68, 0x7b, 0xe9, 0x34, 0xca, 0xe2, 0xf2, 0x63, 0xa6,
-	0x71, 0x1d, 0x8a, 0xb2, 0x5a, 0x25, 0xcf, 0xb4, 0xc4, 0x68, 0x5a, 0x32, 0x6a, 0xe9, 0x67, 0xae,
-	0xa3, 0x64, 0x75, 0x7e, 0x2e, 0x07, 0x22, 0x55, 0x7e, 0x70, 0x20, 0x97, 0x7f, 0xe3, 0x2e, 0xac,
-	0x2e, 0x95, 0xb7, 0xcb, 0x27, 0x57, 0x33, 0x61, 0x75, 0xa9, 0x8e, 0xf1, 0xeb, 0x50, 0x1a, 0x8d,
-	0x83, 0xbe, 0x33, 0xff, 0x67, 0x08, 0xc9, 0x61, 0x8f, 0x7d, 0xf6, 0xc2, 0x0b, 0xbd, 0x4b, 0x7e,
-	0xb1, 0x94, 0x82, 0x7b, 0x77, 0xa0, 0x96, 0xfd, 0x5d, 0x80, 0xba, 0xaa, 0x60, 0xe2, 0xb1, 0x15,
-	0xbc, 0x00, 0xb4, 0x7f, 0xb5, 0xc5, 0x94, 0x7b, 0xbf, 0x80, 0xfa, 0xf7, 0xf5, 0x2b, 0xd8, 0x13,
-	0xb6, 0xf6, 0x75, 0xea, 0x09, 0x6b, 0xa0, 0x5a, 0x9d, 0x9e, 0xe4, 0x14, 0x6c, 0xb5, 0x85, 0xd1,
-	0x36, 0xa8, 0x1a, 0x36, 0xbf, 0xfc, 0xdd, 0x77, 0xb7, 0x95, 0x7f, 0xfd, 0xee, 0xb6, 0xf2, 0x9f,
-	0xdf, 0xdd, 0x5e, 0xf9, 0xfb, 0xff, 0xbe, 0xad, 0x7c, 0x93, 0xfd, 0x27, 0xa6, 0x13, 0x27, 0x0e,
-	0xfd, 0xd7, 0x41, 0xe8, 0x8f, 0xfc, 0x49, 0xca, 0x4c, 0xbc, 0x4f, 0xa7, 0xaf, 0x46, 0x9f, 0x4e,
-	0xfb, 0x9f, 0x62, 0xc4, 0xfd, 0x12, 0xfd, 0x2f, 0xd3, 0xa3, 0xff, 0x0d, 0x00, 0x00, 0xff, 0xff,
-	0x5c, 0x54, 0x0d, 0x37, 0x0e, 0x25, 0x00, 0x00,
+	0x76, 0xbf, 0x96, 0x3f, 0x97, 0x87, 0x94, 0x3c, 0x1e, 0x3b, 0x36, 0xe3, 0x38, 0x8e, 0xbc, 0x89,
+	0xf3, 0x55, 0xec, 0xc4, 0x89, 0x69, 0x45, 0x5f, 0xe7, 0x36, 0xf7, 0xe6, 0x2e, 0xc9, 0x95, 0xb4,
+	0x31, 0xb5, 0xd4, 0x1d, 0xae, 0xe4, 0x28, 0x41, 0x41, 0x2c, 0xb9, 0x4b, 0x7a, 0xed, 0x25, 0x97,
+	0xdd, 0x5d, 0x4a, 0xd6, 0x7d, 0xba, 0x2f, 0x2d, 0x0a, 0xf4, 0xa1, 0x45, 0x51, 0xe0, 0x16, 0x7d,
+	0xba, 0xb8, 0x40, 0xff, 0x80, 0xfb, 0x47, 0x14, 0x48, 0xd1, 0x97, 0x02, 0x7d, 0x29, 0xd0, 0x97,
+	0x36, 0xfd, 0x0f, 0xfa, 0x17, 0x14, 0x67, 0x66, 0x96, 0x5c, 0x5a, 0x4a, 0x6e, 0x10, 0xf4, 0x45,
+	0x98, 0xf3, 0x39, 0x3f, 0xf6, 0xcc, 0xcc, 0x99, 0x73, 0xce, 0x0c, 0x05, 0x30, 0x0b, 0x9c, 0xe9,
+	0xc3, 0x59, 0x14, 0x26, 0x21, 0x2d, 0xe0, 0xf8, 0xd6, 0x47, 0x63, 0x3f, 0x79, 0x3e, 0x1f, 0x3c,
+	0x1c, 0x86, 0x93, 0x8f, 0xc7, 0xe1, 0x38, 0xfc, 0x98, 0x33, 0x07, 0xf3, 0x11, 0xa7, 0x38, 0xc1,
+	0x47, 0x42, 0x49, 0xfb, 0x97, 0x22, 0x14, 0xec, 0xf3, 0x99, 0x47, 0xef, 0x42, 0xce, 0x77, 0xeb,
+	0xca, 0xa6, 0xb2, 0xb5, 0xd1, 0xb8, 0xfa, 0x90, 0x9b, 0x45, 0x9c, 0xff, 0x31, 0x5d, 0x96, 0xf3,
+	0x5d, 0x7a, 0x0b, 0xd4, 0xe9, 0x3c, 0x08, 0x9c, 0x41, 0xe0, 0xd5, 0x73, 0x9b, 0xca, 0x96, 0xca,
+	0x16, 0x34, 0xbd, 0x0e, 0xc5, 0x33, 0xdf, 0x4d, 0x9e, 0xd7, 0xf3, 0x9b, 0xca, 0x56, 0x91, 0x09,
+	0x82, 0xde, 0x86, 0xca, 0x2c, 0xf2, 0x86, 0x7e, 0xec, 0x87, 0xd3, 0x7a, 0x81, 0x73, 0x96, 0x00,
+	0xa5, 0x50, 0x88, 0xfd, 0x5f, 0x7b, 0xf5, 0x22, 0x67, 0xf0, 0x31, 0xda, 0x89, 0x87, 0x4e, 0xe0,
+	0xd5, 0x4b, 0xc2, 0x0e, 0x27, 0xb4, 0x7f, 0x2c, 0x40, 0x49, 0x38, 0x42, 0xcb, 0x90, 0xd7, 0xad,
+	0x13, 0xb2, 0x46, 0x55, 0x28, 0xf4, 0x6c, 0x9d, 0x11, 0x05, 0x47, 0xcd, 0x6e, 0xb7, 0x43, 0x00,
+	0x47, 0xa6, 0x65, 0x3f, 0x21, 0xd7, 0x69, 0x05, 0x8a, 0xa6, 0x65, 0x3f, 0xda, 0x21, 0x6f, 0xc8,
+	0xe1, 0xe3, 0x06, 0xb9, 0x21, 0x87, 0x3b, 0xdb, 0xe4, 0x26, 0x05, 0x28, 0xa1, 0x40, 0xe3, 0x09,
+	0xa9, 0x23, 0x7c, 0xc4, 0xf5, 0xde, 0x44, 0xf8, 0x48, 0x28, 0xde, 0x4a, 0xc7, 0x8f, 0x1b, 0xe4,
+	0xad, 0x74, 0xbc, 0xb3, 0x4d, 0x6e, 0xd3, 0x2a, 0x94, 0x8f, 0xa4, 0xee, 0xdb, 0x48, 0xec, 0x76,
+	0xba, 0x3a, 0x4a, 0xdd, 0x59, 0x10, 0x3b, 0xdb, 0xe4, 0x1d, 0xba, 0x0e, 0x95, 0xb6, 0xd1, 0x32,
+	0x0f, 0xf4, 0xce, 0xce, 0x36, 0xd9, 0xa4, 0x1b, 0x00, 0x92, 0x44, 0xc5, 0xbb, 0x28, 0x2b, 0x69,
+	0xa2, 0xa1, 0x79, 0xdd, 0x3a, 0x31, 0x2d, 0x9b, 0xdc, 0xa3, 0x35, 0x50, 0x75, 0xeb, 0x84, 0xdb,
+	0x21, 0xef, 0xa3, 0x15, 0xdd, 0x3a, 0xb1, 0x8e, 0x0e, 0x9a, 0x06, 0x23, 0xff, 0x0f, 0x67, 0x78,
+	0x74, 0x64, 0xb6, 0xc9, 0x16, 0x77, 0xba, 0xf9, 0x68, 0xe7, 0x13, 0xf2, 0x81, 0x1c, 0x3e, 0xd9,
+	0x26, 0xf7, 0xe5, 0xf0, 0xb3, 0x06, 0x79, 0x20, 0x86, 0x8d, 0xc6, 0x36, 0xf9, 0x50, 0x0e, 0x3f,
+	0xdd, 0x21, 0x1f, 0xa1, 0x81, 0xb6, 0x6e, 0x1b, 0xa4, 0x81, 0x23, 0xdb, 0x3c, 0x30, 0xc8, 0x63,
+	0xfc, 0x22, 0x62, 0x9c, 0xda, 0xc6, 0x2f, 0xe2, 0xa8, 0x67, 0xeb, 0x07, 0x87, 0xe4, 0x53, 0x64,
+	0x9a, 0x96, 0x6d, 0xb0, 0x63, 0xbd, 0x43, 0x76, 0xd0, 0x6b, 0xdd, 0x3a, 0xe1, 0x92, 0x7f, 0x82,
+	0x16, 0x5a, 0xfb, 0x3a, 0x23, 0x9f, 0x23, 0x7c, 0xac, 0x33, 0x4e, 0xfc, 0x1c, 0xe1, 0x2f, 0x7b,
+	0x5d, 0x8b, 0xfc, 0x02, 0xa7, 0xd5, 0x34, 0x2d, 0x9d, 0x9d, 0x90, 0x5d, 0x34, 0x7b, 0xac, 0x33,
+	0x49, 0xee, 0xa1, 0x4b, 0x3a, 0x63, 0xfa, 0x09, 0xf9, 0x1a, 0x57, 0x66, 0xb7, 0x63, 0x7c, 0xd5,
+	0x3c, 0xda, 0xdd, 0x35, 0x18, 0xf9, 0x86, 0x6b, 0x9d, 0xd8, 0x86, 0xfe, 0x84, 0xb8, 0x68, 0x98,
+	0x8f, 0x1f, 0xed, 0x10, 0x0f, 0x75, 0x38, 0x41, 0x46, 0x54, 0x85, 0x7c, 0xcf, 0xe8, 0x90, 0x6f,
+	0x15, 0x0a, 0x50, 0xb4, 0x8f, 0x0e, 0x3b, 0x06, 0xf9, 0x67, 0x45, 0xfb, 0x9f, 0x1c, 0x14, 0x5b,
+	0xe1, 0x34, 0x4e, 0xe8, 0x0d, 0x28, 0xf9, 0x31, 0x46, 0x27, 0x0f, 0x69, 0x95, 0x49, 0x8a, 0x5e,
+	0x87, 0x82, 0x7f, 0xea, 0x04, 0x3c, 0x7e, 0xf3, 0xfb, 0x6b, 0x8c, 0x53, 0x88, 0xba, 0x88, 0x62,
+	0xf0, 0x2a, 0x88, 0xba, 0x12, 0x8d, 0x11, 0xc5, 0xc0, 0xad, 0x20, 0x1a, 0x4b, 0x74, 0x80, 0x28,
+	0x46, 0xad, 0x8a, 0xe8, 0x40, 0xa2, 0x73, 0x44, 0x31, 0x6c, 0x0b, 0x88, 0xce, 0x25, 0x3a, 0x42,
+	0xb4, 0xbc, 0xa9, 0x6c, 0xe5, 0x10, 0x45, 0x8a, 0xde, 0x82, 0xb2, 0xeb, 0x24, 0x1e, 0x32, 0x54,
+	0x8c, 0xf2, 0xfd, 0x35, 0x96, 0x02, 0x54, 0x83, 0x2a, 0x0e, 0x13, 0x7f, 0xc2, 0xf9, 0x15, 0xe9,
+	0x66, 0x16, 0xa4, 0xef, 0x41, 0xcd, 0xf5, 0x86, 0xfe, 0xc4, 0x09, 0x76, 0xb6, 0x51, 0x08, 0xa4,
+	0xd0, 0x0a, 0x4a, 0x9f, 0xc0, 0xba, 0xa4, 0x1f, 0x35, 0x9e, 0xa0, 0x58, 0x75, 0x53, 0xd9, 0xaa,
+	0x36, 0x88, 0x38, 0xdb, 0x4b, 0xd6, 0xfe, 0x1a, 0x5b, 0x15, 0x44, 0xfb, 0xf8, 0xa9, 0x38, 0x71,
+	0x26, 0x33, 0x54, 0xac, 0xa5, 0xf6, 0xb3, 0x68, 0xb3, 0x0c, 0xc5, 0x53, 0x27, 0x98, 0x7b, 0xda,
+	0x6d, 0x50, 0x0f, 0x9d, 0xc8, 0x99, 0x30, 0x6f, 0x44, 0x09, 0xe4, 0x67, 0x61, 0xcc, 0xd7, 0xbc,
+	0xc8, 0x70, 0xa8, 0xdd, 0x86, 0xd2, 0xb1, 0x13, 0x21, 0x8f, 0x42, 0x61, 0xea, 0x4c, 0x3c, 0xce,
+	0xac, 0x30, 0x3e, 0xd6, 0x7e, 0x06, 0xa5, 0x56, 0x18, 0x20, 0xf7, 0x26, 0x94, 0x23, 0x2f, 0xe8,
+	0x2f, 0xb5, 0x4b, 0x91, 0x17, 0x1c, 0x86, 0x31, 0x32, 0x86, 0xa1, 0x60, 0xe4, 0x04, 0x63, 0x18,
+	0x22, 0x43, 0xb3, 0x01, 0x5a, 0x61, 0x14, 0xfd, 0x54, 0x7d, 0x4c, 0x35, 0xae, 0x37, 0x5b, 0xa6,
+	0x2c, 0x4e, 0x68, 0xf7, 0x41, 0x35, 0x5e, 0xcd, 0xa2, 0x8e, 0x1f, 0x27, 0xf4, 0x0e, 0x14, 0x02,
+	0x3f, 0x4e, 0xea, 0xca, 0x66, 0x7e, 0xab, 0xda, 0x00, 0xb1, 0x72, 0xc8, 0x65, 0x1c, 0xd7, 0xee,
+	0x03, 0xd8, 0x4e, 0x34, 0xf6, 0x12, 0x9e, 0x41, 0x6f, 0x43, 0x3e, 0x39, 0x9f, 0xf1, 0xaf, 0x2f,
+	0x84, 0x91, 0xc1, 0x10, 0xd6, 0xfe, 0x5d, 0x81, 0x6a, 0x6f, 0x3e, 0xf8, 0xb3, 0xb9, 0x17, 0x9d,
+	0xa3, 0xbf, 0x5b, 0x4b, 0xe9, 0x8d, 0xc6, 0x0d, 0x21, 0x9d, 0xe1, 0x2f, 0x35, 0x71, 0x02, 0xd3,
+	0xd0, 0xf5, 0xfa, 0xbe, 0x9b, 0x4e, 0x00, 0x49, 0xd3, 0xa5, 0x1b, 0x90, 0x0b, 0x67, 0xdc, 0xfb,
+	0x0a, 0xcb, 0x85, 0x33, 0xba, 0x09, 0xc5, 0xe1, 0x73, 0x3f, 0x70, 0x79, 0xc0, 0xae, 0xfa, 0x2b,
+	0x18, 0x9a, 0x2d, 0x93, 0x3d, 0x40, 0xa9, 0xd7, 0xd2, 0x3b, 0x3a, 0x23, 0x6b, 0x38, 0x36, 0xbe,
+	0x32, 0x7b, 0x76, 0x8f, 0x28, 0x78, 0x12, 0xad, 0xae, 0xdd, 0x97, 0x74, 0x8e, 0x96, 0x20, 0x67,
+	0x5a, 0x24, 0x8f, 0x32, 0x88, 0x9b, 0x16, 0x29, 0xa4, 0x09, 0xb8, 0xc8, 0x07, 0x9d, 0x0e, 0x29,
+	0x69, 0xff, 0xa6, 0x40, 0xa5, 0x3b, 0x78, 0xe1, 0x0d, 0x13, 0x9c, 0xd8, 0x0d, 0x28, 0xc5, 0x5e,
+	0x74, 0xea, 0x45, 0x7c, 0x6e, 0x79, 0x26, 0x29, 0xf4, 0xd6, 0x1d, 0x88, 0x73, 0xc7, 0x72, 0xee,
+	0x80, 0xcb, 0x0d, 0x9f, 0x7b, 0x13, 0x87, 0xcf, 0x00, 0xe5, 0x38, 0x85, 0x21, 0x14, 0x0e, 0x5e,
+	0xf0, 0x39, 0xe4, 0x19, 0x0e, 0xe9, 0x3b, 0x50, 0x15, 0x36, 0xfa, 0x3c, 0x7e, 0x8a, 0x7c, 0xc2,
+	0x20, 0x20, 0xcb, 0x99, 0x78, 0xb8, 0x42, 0xee, 0x40, 0x30, 0x4b, 0x9c, 0x59, 0x72, 0x07, 0x9c,
+	0x81, 0x9a, 0xdc, 0xaa, 0x60, 0x96, 0xa5, 0x26, 0x87, 0xb8, 0xc0, 0x9b, 0xa0, 0x86, 0x83, 0x17,
+	0x82, 0xab, 0x72, 0x6e, 0x39, 0x1c, 0xbc, 0x40, 0x96, 0xf6, 0x5f, 0x0a, 0xa8, 0xbb, 0xf3, 0xe9,
+	0x30, 0xc1, 0x52, 0xf5, 0x2e, 0x14, 0x46, 0xf3, 0xe9, 0x50, 0x6e, 0xee, 0x15, 0xb1, 0xb2, 0x8b,
+	0x39, 0x33, 0xce, 0xc4, 0x70, 0x71, 0xa2, 0x31, 0x86, 0xd9, 0x85, 0x70, 0x41, 0x5c, 0xfb, 0x6b,
+	0x69, 0x71, 0x37, 0x70, 0xc6, 0x98, 0x24, 0xad, 0xae, 0x65, 0x90, 0xb5, 0x45, 0x82, 0xb5, 0xf4,
+	0x0e, 0x51, 0xf8, 0xd6, 0xd8, 0x7a, 0xb3, 0x63, 0x90, 0x1c, 0x72, 0x8e, 0xbb, 0x1d, 0xdd, 0x36,
+	0x3b, 0x06, 0x29, 0x08, 0x0e, 0x33, 0x5b, 0x36, 0x51, 0x29, 0x81, 0xda, 0x21, 0xeb, 0xb6, 0x8f,
+	0x5a, 0x46, 0xdf, 0x3a, 0xea, 0x74, 0x08, 0xa1, 0xd7, 0xe0, 0xca, 0x02, 0xe9, 0x0a, 0x70, 0x13,
+	0x55, 0x8e, 0x75, 0xa6, 0xb3, 0x3d, 0xf2, 0x4b, 0xcc, 0x98, 0xfa, 0xde, 0x1e, 0xf9, 0x0d, 0xd6,
+	0xcb, 0xfc, 0x33, 0xd3, 0x22, 0xbf, 0xc9, 0x69, 0xff, 0x90, 0x87, 0x02, 0x3a, 0xf8, 0xc3, 0xb1,
+	0x4b, 0xdf, 0x02, 0x65, 0xc8, 0x77, 0xae, 0xda, 0xa8, 0x0a, 0x1e, 0x4f, 0xb2, 0xfb, 0x6b, 0x4c,
+	0xc1, 0x59, 0x2b, 0x22, 0x08, 0xab, 0x8d, 0x0d, 0xc1, 0x4c, 0xb3, 0x01, 0xf2, 0x67, 0xf4, 0x36,
+	0x28, 0xa7, 0x32, 0x22, 0x6b, 0x82, 0x2f, 0xf2, 0x01, 0x72, 0x4f, 0xe9, 0x26, 0xe4, 0x87, 0xa1,
+	0x48, 0xa6, 0x0b, 0xbe, 0x38, 0xd1, 0xfb, 0x6b, 0x0c, 0x59, 0x68, 0x7f, 0xc4, 0xb7, 0x75, 0x61,
+	0x3f, 0xdd, 0x15, 0xb4, 0x30, 0xa2, 0xf7, 0x20, 0x1f, 0xcf, 0x07, 0x7c, 0x6f, 0xab, 0x69, 0xe7,
+	0x92, 0x39, 0x48, 0x68, 0x26, 0x9e, 0x0f, 0xe8, 0xfb, 0x50, 0x18, 0x86, 0x51, 0xc4, 0x77, 0x79,
+	0x91, 0x05, 0x97, 0xf9, 0x03, 0x93, 0x33, 0xf2, 0xe9, 0x26, 0x28, 0x09, 0x4f, 0xbb, 0x0b, 0xa1,
+	0xe5, 0x11, 0xc7, 0x0f, 0x26, 0xf4, 0x3d, 0x99, 0x15, 0x20, 0xeb, 0x53, 0x9a, 0x33, 0xd0, 0x0e,
+	0x72, 0xe9, 0xdb, 0x00, 0x09, 0x76, 0x46, 0x22, 0xb6, 0xaa, 0x3c, 0xb6, 0x2a, 0x1c, 0x49, 0x03,
+	0x0f, 0xb3, 0x12, 0x67, 0xd6, 0x44, 0xe0, 0x0d, 0xc3, 0x00, 0x59, 0xcd, 0x12, 0x14, 0xbc, 0x57,
+	0xb3, 0x48, 0x1b, 0x43, 0xb5, 0xed, 0x8d, 0x9c, 0x79, 0x90, 0xf0, 0x2d, 0xba, 0x0e, 0x45, 0xef,
+	0x95, 0xc8, 0x46, 0x58, 0xd0, 0x04, 0x41, 0x3f, 0x90, 0x59, 0x58, 0x6e, 0xcf, 0xb5, 0xcc, 0xf6,
+	0x38, 0xd3, 0xe4, 0x18, 0x59, 0x4c, 0x48, 0xe0, 0x29, 0xf1, 0xe3, 0x3e, 0xaf, 0x89, 0xf9, 0xb4,
+	0x26, 0x5a, 0xf3, 0x20, 0xd0, 0x7e, 0x9f, 0x87, 0xf5, 0x15, 0x0d, 0xfa, 0x36, 0x54, 0xe6, 0xd3,
+	0x97, 0xd3, 0xf0, 0x6c, 0xda, 0x3f, 0x15, 0xe9, 0x74, 0x7f, 0x8d, 0xa9, 0x12, 0x3a, 0xa6, 0x6f,
+	0x42, 0xd9, 0x9f, 0x26, 0x3b, 0xdb, 0xfd, 0xd3, 0x45, 0x1d, 0x2d, 0x71, 0xe0, 0x98, 0xde, 0x85,
+	0xea, 0xa2, 0x0a, 0xf5, 0x4f, 0xc5, 0xd1, 0xde, 0x5f, 0x63, 0xb0, 0x00, 0x8f, 0xe9, 0xa7, 0x8b,
+	0xf2, 0xf5, 0xa8, 0xf1, 0xa4, 0x9f, 0xc6, 0xc6, 0x65, 0x75, 0xa9, 0xba, 0xa4, 0x8e, 0xe9, 0x5b,
+	0xa0, 0xce, 0xd3, 0xaf, 0x16, 0x65, 0x95, 0x2d, 0xcf, 0xe5, 0x67, 0xdf, 0x86, 0xca, 0x28, 0x08,
+	0x9d, 0xe4, 0x71, 0xa3, 0x7f, 0xca, 0x83, 0x05, 0xab, 0xad, 0x2a, 0xa1, 0x25, 0x9b, 0x2b, 0x97,
+	0x65, 0x91, 0x57, 0x25, 0x74, 0x4c, 0x6f, 0x42, 0x09, 0xeb, 0x6b, 0xff, 0x74, 0x51, 0x8f, 0x8b,
+	0x48, 0x1f, 0xd3, 0x77, 0x00, 0x70, 0x60, 0xfb, 0x13, 0x64, 0xa6, 0xc5, 0xb8, 0x92, 0x62, 0x7c,
+	0xba, 0x58, 0x14, 0x7b, 0x58, 0x14, 0xfb, 0xa7, 0x8b, 0x4a, 0x0c, 0x0b, 0x90, 0xfb, 0x1d, 0x27,
+	0x91, 0x3f, 0x1d, 0xf7, 0x4f, 0x45, 0x18, 0xa0, 0xdf, 0x02, 0xe1, 0x5f, 0x1e, 0x84, 0x61, 0xd0,
+	0x3f, 0xe5, 0x41, 0x80, 0xed, 0x44, 0x11, 0xe9, 0xe3, 0xe6, 0x15, 0x58, 0x1f, 0x66, 0xb7, 0x44,
+	0xfb, 0x10, 0x60, 0xb9, 0x1a, 0x98, 0x4c, 0x3b, 0xa1, 0x4c, 0xb0, 0xb9, 0x4e, 0x88, 0xf4, 0xbe,
+	0x9f, 0x26, 0xd7, 0x7d, 0x1f, 0x53, 0x32, 0x16, 0xd6, 0xf6, 0xe5, 0x65, 0x97, 0xbe, 0x07, 0x79,
+	0x27, 0x18, 0x73, 0xf9, 0x8d, 0x06, 0x4d, 0x63, 0x66, 0x32, 0x8b, 0xbc, 0x38, 0x16, 0xc7, 0xde,
+	0x09, 0xc6, 0x69, 0x52, 0xc8, 0x5f, 0x9e, 0x14, 0x1e, 0x40, 0xd9, 0x15, 0xe1, 0x29, 0x77, 0x50,
+	0x9e, 0xbd, 0x4c, 0xcc, 0xb2, 0x54, 0x82, 0xd6, 0xa1, 0x3c, 0x8b, 0xfc, 0x89, 0x13, 0x9d, 0x8b,
+	0xbe, 0x89, 0xa5, 0x24, 0x86, 0xf5, 0xec, 0xa5, 0xef, 0xbe, 0x4a, 0x1b, 0x7e, 0x4e, 0x20, 0xea,
+	0x04, 0xbe, 0x13, 0xcb, 0x94, 0x2d, 0x08, 0xed, 0xb7, 0x0a, 0xa8, 0xe6, 0xd4, 0xf5, 0x5e, 0xe1,
+	0xbc, 0xee, 0x67, 0x0b, 0x68, 0x5d, 0x7c, 0x3b, 0x65, 0x8a, 0xc1, 0xd2, 0xd7, 0x74, 0x0d, 0x72,
+	0x99, 0x35, 0x78, 0x0b, 0x2a, 0xe9, 0x09, 0x8c, 0xeb, 0xf9, 0xcd, 0xfc, 0x56, 0x85, 0xa9, 0xf2,
+	0x08, 0xc6, 0xda, 0x43, 0xa8, 0x2c, 0x4c, 0x60, 0x0f, 0x6a, 0x5a, 0xc7, 0xba, 0xd9, 0x69, 0x93,
+	0x35, 0x24, 0xbe, 0xee, 0x5a, 0xc6, 0x81, 0x7e, 0x48, 0x14, 0x2c, 0x81, 0xcd, 0x9e, 0x49, 0x72,
+	0xda, 0x3d, 0x58, 0x3f, 0x14, 0x13, 0x7a, 0xea, 0x9d, 0xa3, 0x77, 0xd7, 0xa1, 0x28, 0x2c, 0x2b,
+	0xdc, 0xb2, 0x20, 0xb4, 0x06, 0xa8, 0x87, 0x51, 0x38, 0xf3, 0xa2, 0xe4, 0x1c, 0xeb, 0xdc, 0x4b,
+	0xef, 0x5c, 0x6e, 0x0b, 0x0e, 0x51, 0x67, 0x79, 0x96, 0x2b, 0xf2, 0xd8, 0x6a, 0x5f, 0xa0, 0x69,
+	0xae, 0xe3, 0x7b, 0x31, 0x9a, 0x7e, 0x08, 0x30, 0x5b, 0x00, 0xb2, 0x37, 0x49, 0x33, 0xaf, 0x34,
+	0xce, 0x32, 0x12, 0xda, 0x6f, 0x73, 0xa0, 0xda, 0x98, 0x78, 0xbe, 0x2f, 0x1a, 0x36, 0x31, 0x35,
+	0x06, 0x69, 0xdd, 0x5a, 0x26, 0xe1, 0x36, 0x56, 0x36, 0xe4, 0xd0, 0xfb, 0x50, 0x70, 0xbd, 0x91,
+	0x58, 0xa6, 0x6a, 0xda, 0xad, 0xa4, 0x36, 0x71, 0xc7, 0xf9, 0x52, 0x73, 0x99, 0xe5, 0xd6, 0x15,
+	0x32, 0x5b, 0x77, 0xeb, 0x6f, 0x15, 0x28, 0x4b, 0x39, 0x7a, 0x0f, 0x72, 0xb3, 0x97, 0xb2, 0xd6,
+	0x5c, 0x4b, 0x1d, 0xcf, 0x2c, 0xde, 0xfe, 0x1a, 0xcb, 0xcd, 0x5e, 0x52, 0x0d, 0xf2, 0x18, 0x17,
+	0xb9, 0x6c, 0x9a, 0x4d, 0x37, 0x18, 0xb3, 0x3a, 0xc6, 0xc9, 0xa7, 0x2b, 0x6b, 0x91, 0x5f, 0x35,
+	0x99, 0x59, 0x34, 0x3c, 0x93, 0x4b, 0xc1, 0x66, 0x11, 0xf2, 0xae, 0x37, 0xd2, 0x22, 0x28, 0xb4,
+	0xc2, 0x38, 0xc1, 0x45, 0x19, 0x3a, 0x91, 0xb8, 0xfd, 0x2a, 0x8c, 0x8f, 0x31, 0x62, 0xa3, 0xf0,
+	0x8c, 0xdf, 0x4f, 0x73, 0x1c, 0x4e, 0x49, 0xdc, 0xb8, 0xa9, 0x2b, 0x52, 0x9b, 0xc2, 0x70, 0xc8,
+	0x2f, 0xad, 0x89, 0x13, 0x89, 0x83, 0xa0, 0x30, 0x41, 0x20, 0x9a, 0x84, 0x89, 0xbc, 0x29, 0x28,
+	0x4c, 0x10, 0xda, 0x1f, 0x14, 0x28, 0xe3, 0xda, 0x3a, 0x89, 0x83, 0x21, 0x18, 0x85, 0x67, 0xfd,
+	0x61, 0x38, 0x9f, 0x26, 0xb2, 0x6b, 0x55, 0xa3, 0xf0, 0xac, 0x85, 0x34, 0x16, 0x10, 0xcc, 0xd5,
+	0x92, 0x2b, 0x3a, 0xbf, 0x0a, 0x22, 0x82, 0x8d, 0x01, 0x36, 0x0f, 0x02, 0xb1, 0x27, 0x2a, 0x13,
+	0x04, 0xfa, 0xe6, 0x3f, 0x6e, 0xd4, 0x0b, 0x9b, 0x79, 0xec, 0xbf, 0xfd, 0xc7, 0x0d, 0x8e, 0xec,
+	0x6c, 0xd7, 0x8b, 0x9b, 0x79, 0x6c, 0xa7, 0xfc, 0x9d, 0x6d, 0x44, 0x46, 0x8f, 0x1b, 0xf5, 0xd2,
+	0x66, 0x7e, 0x2b, 0xc7, 0x70, 0xc8, 0x91, 0x9d, 0xed, 0x7a, 0x79, 0x33, 0x8f, 0x33, 0x1a, 0xed,
+	0x6c, 0xd3, 0x1a, 0x28, 0x71, 0x5d, 0xe5, 0xa1, 0xab, 0xc4, 0xda, 0x33, 0x00, 0x16, 0x9e, 0xc5,
+	0x5e, 0xc2, 0xbd, 0x7e, 0x7f, 0xd1, 0xb8, 0x29, 0xd9, 0xad, 0x49, 0xc3, 0x61, 0xd1, 0xc8, 0xdd,
+	0x5d, 0x09, 0xab, 0xf5, 0x65, 0x58, 0x39, 0x89, 0x23, 0xe2, 0x4a, 0xfb, 0x0f, 0x05, 0xaa, 0xdd,
+	0xc8, 0xf5, 0xa2, 0xe6, 0x79, 0x6f, 0xe6, 0xf1, 0x0e, 0x0a, 0x4b, 0xdf, 0x6a, 0x1f, 0x22, 0x3a,
+	0x28, 0x4f, 0xb4, 0x29, 0x78, 0x66, 0x03, 0x07, 0xab, 0xbf, 0x3c, 0x25, 0x4b, 0x80, 0x3e, 0x82,
+	0xc2, 0x28, 0x70, 0xc6, 0x7c, 0x67, 0x36, 0x1a, 0x6f, 0xcb, 0x26, 0x6d, 0x69, 0x3e, 0x1d, 0x63,
+	0xff, 0xc5, 0xb8, 0xa8, 0xf6, 0xcd, 0xe2, 0xfb, 0xbc, 0x29, 0xc3, 0x96, 0xb6, 0xd7, 0x12, 0x8f,
+	0x0b, 0x6d, 0xa3, 0xd7, 0x22, 0x0a, 0xbd, 0x02, 0x55, 0x6c, 0xa6, 0x7a, 0xfd, 0x5d, 0x93, 0xf5,
+	0x6c, 0x92, 0xe3, 0x3d, 0x32, 0x07, 0x3a, 0x7a, 0xcf, 0x16, 0x6d, 0xd9, 0x91, 0x65, 0xfe, 0xea,
+	0xc8, 0x20, 0xea, 0x4a, 0x2b, 0x47, 0xb0, 0xdf, 0x83, 0x67, 0xfe, 0xd4, 0x0d, 0xcf, 0xf8, 0xe4,
+	0x3e, 0x82, 0xda, 0xcc, 0x89, 0x12, 0x1f, 0x7d, 0xed, 0x0f, 0xce, 0x2f, 0xb9, 0x55, 0x54, 0x17,
+	0xfc, 0xe6, 0x39, 0xfd, 0x10, 0xd4, 0x10, 0x5d, 0x43, 0x51, 0xb1, 0x84, 0x57, 0x2f, 0xcc, 0x88,
+	0x95, 0x43, 0x41, 0x60, 0x08, 0x07, 0x9e, 0xe3, 0xca, 0xbb, 0x0c, 0x1f, 0xe3, 0xb6, 0xe2, 0x72,
+	0x88, 0x77, 0x17, 0x1c, 0x6a, 0xff, 0xa4, 0x00, 0x1c, 0xcd, 0xb0, 0x7c, 0x99, 0xd3, 0x51, 0x88,
+	0x1d, 0xc1, 0x2c, 0xf2, 0xfb, 0xcb, 0x34, 0x54, 0x9a, 0x45, 0xfe, 0x53, 0xef, 0x9c, 0xde, 0x81,
+	0xaa, 0x64, 0xf4, 0xd3, 0x23, 0xc8, 0x5f, 0x6e, 0x90, 0x69, 0xba, 0xaf, 0xb0, 0x7b, 0x79, 0xee,
+	0xbb, 0x1e, 0xd7, 0x14, 0xf7, 0x8f, 0x32, 0xd2, 0xa8, 0x7a, 0x17, 0x6a, 0x73, 0xfe, 0x85, 0xbe,
+	0x93, 0x24, 0x51, 0xcc, 0x43, 0xb1, 0xc2, 0xaa, 0x02, 0xd3, 0x11, 0xc2, 0xae, 0x3c, 0x4c, 0x9e,
+	0x7b, 0x91, 0x94, 0x28, 0x72, 0x09, 0xe0, 0xd0, 0x42, 0x00, 0x59, 0x7d, 0x3e, 0xb9, 0x98, 0x47,
+	0x6a, 0x85, 0x01, 0x42, 0x7c, 0xee, 0xb1, 0xf6, 0x97, 0x55, 0x28, 0x58, 0xa1, 0xeb, 0xd1, 0x4f,
+	0xa0, 0xc2, 0xef, 0x46, 0xc9, 0xf9, 0xcc, 0x93, 0xa5, 0x40, 0x1e, 0x7f, 0x64, 0xf3, 0x3f, 0x3c,
+	0x35, 0xa9, 0x53, 0x39, 0xfa, 0xfe, 0xdb, 0xd4, 0x1d, 0x0c, 0xd7, 0x38, 0x59, 0x2d, 0x77, 0x98,
+	0x1e, 0x18, 0xc7, 0xf9, 0xf6, 0x45, 0x21, 0x76, 0xfc, 0x7d, 0xde, 0xfe, 0x15, 0x2e, 0xd9, 0x3e,
+	0xc1, 0xe7, 0x77, 0xc7, 0x5b, 0xa0, 0xf2, 0x3b, 0x57, 0xe4, 0x4d, 0xf9, 0x0c, 0x8b, 0x6c, 0x41,
+	0xa3, 0xd7, 0x2f, 0x42, 0x7f, 0x2a, 0xbc, 0x2e, 0x5d, 0xf0, 0xfa, 0xcb, 0xd0, 0x9f, 0xf2, 0x18,
+	0x55, 0x51, 0x8a, 0x7b, 0xfd, 0x2e, 0x94, 0xc3, 0xa9, 0xf8, 0x6e, 0xf9, 0xc2, 0x77, 0x4b, 0xe1,
+	0x94, 0x7f, 0xf2, 0x01, 0x54, 0x47, 0x7e, 0x90, 0x78, 0x91, 0x10, 0x54, 0x2f, 0x08, 0x82, 0x60,
+	0x73, 0xe1, 0x7b, 0xa0, 0x8e, 0xa3, 0x70, 0x3e, 0xc3, 0xf0, 0xaa, 0x5c, 0x90, 0x2c, 0x73, 0x5e,
+	0xf3, 0x1c, 0x67, 0xcd, 0x87, 0xd8, 0xbf, 0xc4, 0x1e, 0x36, 0xbd, 0x17, 0x66, 0x9d, 0xf2, 0x7b,
+	0x1e, 0xb7, 0xea, 0x8c, 0xc7, 0xe2, 0xfb, 0xd5, 0x8b, 0x56, 0x9d, 0xf1, 0x98, 0x7f, 0x3c, 0x1b,
+	0xdb, 0xb5, 0x3f, 0x1a, 0xdb, 0x8f, 0x40, 0x86, 0x4f, 0xdf, 0x9f, 0x8e, 0xc2, 0xfa, 0x7a, 0xb6,
+	0x5f, 0x5c, 0x46, 0x33, 0x83, 0xf9, 0x32, 0xb2, 0x1f, 0x80, 0x7a, 0xe6, 0x4f, 0xfb, 0xf1, 0xcc,
+	0x1b, 0xd6, 0x37, 0xb2, 0xf2, 0xcb, 0xf3, 0xc8, 0xca, 0x67, 0xfe, 0x94, 0x1f, 0xcc, 0x4d, 0x28,
+	0x06, 0xfe, 0xc4, 0x4f, 0xea, 0x57, 0x2e, 0xde, 0x9b, 0x39, 0x83, 0x6a, 0x50, 0x0a, 0x47, 0x23,
+	0x9c, 0x3f, 0xb9, 0x20, 0x22, 0x39, 0xf4, 0x01, 0x88, 0xf6, 0xbe, 0xef, 0x7a, 0xa3, 0xfa, 0xd5,
+	0x4b, 0x33, 0xa3, 0x9a, 0xa4, 0x65, 0x78, 0x0b, 0xf0, 0x9e, 0xd9, 0x8f, 0xbc, 0x51, 0x9d, 0x5e,
+	0x7e, 0xa5, 0x2c, 0x85, 0x83, 0x17, 0x78, 0x9d, 0x7e, 0x04, 0xd5, 0x88, 0xe7, 0xde, 0xbe, 0xeb,
+	0x24, 0x4e, 0xfd, 0x5a, 0x76, 0x32, 0xcb, 0xa4, 0xcc, 0x20, 0x5a, 0x26, 0xe8, 0x77, 0x61, 0xdd,
+	0x7b, 0x95, 0x44, 0x4e, 0x3f, 0x9c, 0x61, 0x2e, 0x89, 0xeb, 0xd7, 0xf9, 0x11, 0xad, 0x71, 0xb0,
+	0x2b, 0x30, 0xaa, 0x41, 0x6d, 0x1e, 0x7b, 0x6d, 0x2f, 0xf0, 0x12, 0x3c, 0xb7, 0xf5, 0x37, 0x84,
+	0x4c, 0x16, 0xd3, 0xfe, 0x2a, 0x0f, 0x6a, 0x7a, 0x84, 0xf8, 0xab, 0xa7, 0xf5, 0xd4, 0xea, 0x3e,
+	0xb3, 0xc8, 0x1a, 0x26, 0xc1, 0x63, 0xbd, 0x73, 0x64, 0xf4, 0x7b, 0x2d, 0xdd, 0x12, 0x0f, 0x07,
+	0xfc, 0xd2, 0x2a, 0xe8, 0x1c, 0xbd, 0x0a, 0xeb, 0xbb, 0x47, 0x56, 0xcb, 0x36, 0xbb, 0x96, 0x80,
+	0xf2, 0x08, 0x19, 0x5f, 0x89, 0xdc, 0x28, 0xa0, 0x02, 0x42, 0x07, 0xba, 0x6d, 0x30, 0x33, 0x85,
+	0x8a, 0xf8, 0x95, 0x43, 0xd6, 0xfd, 0xd2, 0x68, 0xd9, 0x04, 0xe8, 0x1b, 0x70, 0x75, 0xa1, 0x92,
+	0x9a, 0x23, 0x55, 0xcc, 0xb2, 0xa9, 0x1a, 0xb9, 0x8e, 0x46, 0x98, 0xd1, 0x3a, 0x62, 0x3d, 0xf3,
+	0xd8, 0xe8, 0xb7, 0x6c, 0x83, 0xbc, 0xc1, 0x9f, 0x86, 0x4d, 0xeb, 0x29, 0xb9, 0x41, 0xd7, 0xa1,
+	0x82, 0x23, 0x61, 0xfd, 0x26, 0xcf, 0xef, 0x7b, 0x7b, 0xe4, 0x0e, 0x26, 0xed, 0x5d, 0xb3, 0x63,
+	0x1b, 0x8c, 0xbc, 0xc3, 0x9f, 0x2b, 0xbb, 0xa6, 0x25, 0xae, 0xcb, 0x3d, 0xfd, 0xe0, 0xb0, 0x63,
+	0x90, 0xbb, 0xdc, 0x46, 0x97, 0xd9, 0x44, 0xe3, 0x8f, 0xa7, 0x16, 0x7e, 0xf9, 0x5d, 0x34, 0xc7,
+	0x87, 0x7d, 0xbd, 0xd3, 0x21, 0xef, 0x65, 0x52, 0xff, 0x3d, 0x1c, 0x3f, 0x33, 0xad, 0x76, 0xf7,
+	0x99, 0x78, 0xb3, 0x6d, 0xb2, 0xae, 0xde, 0x6e, 0x61, 0x85, 0xe0, 0x2f, 0xb5, 0xbd, 0xc3, 0x8e,
+	0x69, 0x93, 0x0f, 0x50, 0x6a, 0x4f, 0xb7, 0xf7, 0x0d, 0x46, 0xee, 0xf3, 0x37, 0xdf, 0x5e, 0xcf,
+	0x60, 0x36, 0x69, 0x88, 0xd7, 0x68, 0x3e, 0x7e, 0xcc, 0xad, 0x1e, 0xf2, 0x37, 0xda, 0x6d, 0x1c,
+	0xb7, 0x8d, 0x8e, 0x61, 0x1b, 0xe4, 0x53, 0xed, 0x05, 0xa8, 0x69, 0x66, 0x10, 0x0f, 0xd9, 0x96,
+	0xc1, 0x44, 0xa9, 0xea, 0x18, 0xbb, 0x36, 0x51, 0x10, 0x64, 0xe6, 0xde, 0x3e, 0x16, 0xa9, 0x0a,
+	0x14, 0xbb, 0x47, 0x38, 0xbd, 0x3c, 0x9f, 0x88, 0x71, 0x60, 0x92, 0x02, 0x8e, 0x74, 0xcb, 0x36,
+	0x49, 0x91, 0x4f, 0xd4, 0xb4, 0xf6, 0x3a, 0x06, 0x29, 0x21, 0x7a, 0xa0, 0xb3, 0xa7, 0xa4, 0xcc,
+	0x9f, 0x64, 0x0f, 0x0f, 0x3b, 0x27, 0x44, 0xd5, 0xb6, 0xa0, 0xac, 0x8f, 0xc7, 0x07, 0x98, 0x62,
+	0x55, 0x28, 0xec, 0x1e, 0x75, 0x3a, 0xe2, 0xa5, 0xa8, 0xd9, 0xb5, 0xed, 0xee, 0x81, 0xe8, 0x7c,
+	0xed, 0xee, 0x21, 0xc9, 0x69, 0x7f, 0x93, 0x83, 0xe2, 0xaf, 0xf0, 0xae, 0x4d, 0x77, 0xa0, 0x12,
+	0x27, 0x93, 0x24, 0x9b, 0x8b, 0xdf, 0x14, 0x71, 0xca, 0xf9, 0x0f, 0x7b, 0x89, 0x93, 0x78, 0x13,
+	0x6f, 0x9a, 0x88, 0x8c, 0x8c, 0xb2, 0x3c, 0xb0, 0x78, 0xf7, 0xe4, 0xcd, 0x44, 0xa3, 0x50, 0x64,
+	0x82, 0xc0, 0x43, 0x89, 0x89, 0x39, 0xed, 0x39, 0x61, 0x99, 0x1f, 0x99, 0x60, 0xe0, 0xa1, 0x9c,
+	0x39, 0x91, 0x33, 0x89, 0x2f, 0x49, 0xc5, 0x92, 0x83, 0x59, 0xf8, 0xb9, 0xe7, 0xb8, 0xfe, 0x74,
+	0x9c, 0xd6, 0x99, 0x05, 0xad, 0x3d, 0x83, 0xf5, 0x15, 0x97, 0x56, 0x23, 0x1c, 0x97, 0xc8, 0xe8,
+	0x60, 0x1c, 0x2a, 0x99, 0xdd, 0xc9, 0x65, 0x76, 0x24, 0x9f, 0xd9, 0xa9, 0x02, 0x2e, 0xde, 0x81,
+	0xc1, 0xf6, 0x0c, 0x52, 0xd4, 0x7e, 0x9f, 0x83, 0xab, 0x76, 0xe4, 0x4c, 0x63, 0xde, 0x96, 0xb4,
+	0xc2, 0x69, 0x12, 0x85, 0x01, 0xfd, 0x19, 0xa8, 0xc9, 0x30, 0xc8, 0xae, 0xce, 0x3b, 0x32, 0x3d,
+	0xbc, 0x2e, 0xfa, 0xd0, 0x1e, 0x06, 0x7c, 0x8d, 0xca, 0x89, 0x18, 0xd0, 0x8f, 0xa0, 0x38, 0xf0,
+	0xc6, 0xfe, 0x54, 0x36, 0xc3, 0x6f, 0xbc, 0xae, 0xd8, 0x44, 0x26, 0xbf, 0x3c, 0xe2, 0x80, 0x7e,
+	0x02, 0xa5, 0x61, 0x38, 0xc1, 0x8c, 0x26, 0x8a, 0xd9, 0x8d, 0x8b, 0x1f, 0x42, 0x2e, 0x5e, 0xdb,
+	0x85, 0x1c, 0xdd, 0x01, 0x35, 0x0a, 0x83, 0x60, 0xe0, 0x0c, 0x5f, 0xca, 0xdb, 0x5c, 0xfd, 0x75,
+	0x1d, 0x26, 0xf9, 0x78, 0x73, 0x4e, 0x65, 0xb5, 0x87, 0x50, 0x96, 0xce, 0xf2, 0xc7, 0x79, 0x63,
+	0xcf, 0x94, 0x6b, 0xd7, 0xea, 0x1e, 0x1c, 0x98, 0xb8, 0x76, 0x35, 0x50, 0x59, 0xb7, 0xd3, 0x69,
+	0xea, 0xad, 0xa7, 0x24, 0xd7, 0x54, 0xa1, 0xe4, 0xf0, 0xb7, 0x1b, 0xed, 0x2f, 0x14, 0xb8, 0xf2,
+	0xda, 0x04, 0xe8, 0x13, 0x28, 0x4c, 0x42, 0x37, 0x5d, 0x9e, 0xf7, 0x2e, 0x9d, 0x65, 0x86, 0xc6,
+	0xf0, 0x64, 0x5c, 0x43, 0xfb, 0x0c, 0x36, 0x56, 0xf1, 0xcc, 0xfb, 0xda, 0x3a, 0x54, 0x98, 0xa1,
+	0xb7, 0xfb, 0x5d, 0xab, 0x73, 0x22, 0x52, 0x15, 0x27, 0x9f, 0x31, 0xd3, 0x36, 0x48, 0x4e, 0xfb,
+	0x06, 0xc8, 0xeb, 0x0b, 0x43, 0xf7, 0xe0, 0xca, 0x30, 0x9c, 0xcc, 0x02, 0x8f, 0xf7, 0x6a, 0x99,
+	0x2d, 0xbb, 0x73, 0xc9, 0x4a, 0x4a, 0x31, 0xbe, 0x63, 0x1b, 0xc3, 0x15, 0x5a, 0xfb, 0x53, 0xa0,
+	0x17, 0x57, 0xf0, 0xff, 0xce, 0xfc, 0x1f, 0x14, 0x28, 0x1c, 0x06, 0xce, 0x94, 0xbe, 0x0b, 0x45,
+	0xfe, 0xe0, 0x25, 0x3b, 0xe7, 0x6a, 0xe6, 0xdc, 0x61, 0x58, 0x70, 0x1e, 0x7d, 0x00, 0xf9, 0x64,
+	0x18, 0xc8, 0x18, 0xba, 0xf9, 0x3d, 0xc1, 0x87, 0x37, 0xab, 0x64, 0x18, 0xd0, 0x2d, 0xc8, 0xbb,
+	0x6e, 0x20, 0x03, 0xe8, 0xba, 0xbc, 0xda, 0x3b, 0x89, 0xd3, 0xf6, 0x46, 0xfe, 0xd4, 0x97, 0xcf,
+	0x6f, 0x28, 0x42, 0xef, 0x41, 0xde, 0x1d, 0x06, 0xaf, 0x3d, 0x02, 0x38, 0x89, 0x93, 0x31, 0xe8,
+	0x0e, 0x83, 0x66, 0x09, 0xf8, 0x0f, 0x94, 0xda, 0xb7, 0x0a, 0x54, 0x33, 0x6c, 0xba, 0x0d, 0xaa,
+	0xbb, 0x7a, 0x2e, 0xde, 0xbc, 0x60, 0xe3, 0x61, 0x3b, 0x3d, 0x11, 0xae, 0x8c, 0xb6, 0xcf, 0x60,
+	0x1d, 0x6b, 0xe2, 0xa9, 0x13, 0xf9, 0x58, 0x53, 0x63, 0x39, 0x2b, 0xf9, 0x96, 0xd1, 0xf3, 0x92,
+	0xe3, 0x94, 0xb3, 0xbf, 0xc6, 0x6a, 0x71, 0x86, 0xd6, 0x7e, 0x0e, 0x65, 0x69, 0x0e, 0x6b, 0x47,
+	0xcf, 0xb0, 0xfb, 0xc7, 0x3a, 0x33, 0xb1, 0x7a, 0xf5, 0xc8, 0x1a, 0x86, 0xf1, 0x1e, 0xd3, 0x2d,
+	0x79, 0xec, 0x99, 0x71, 0xdc, 0x7d, 0x6a, 0x90, 0x9c, 0xb8, 0x10, 0x58, 0x27, 0x24, 0xdf, 0xac,
+	0x40, 0x79, 0x28, 0xbc, 0xd2, 0xfe, 0xbc, 0x02, 0x1b, 0xab, 0x6b, 0x42, 0xff, 0x3f, 0xa8, 0xae,
+	0xbb, 0x32, 0x9b, 0xdb, 0x97, 0xad, 0xdd, 0xc3, 0xb6, 0x9b, 0x4e, 0x48, 0x0c, 0xe8, 0xdd, 0x74,
+	0x07, 0x73, 0x17, 0x76, 0x30, 0xdd, 0xbf, 0x2f, 0xe0, 0xca, 0x30, 0xf2, 0xb0, 0x0f, 0xc2, 0x56,
+	0x60, 0xe0, 0xc4, 0xde, 0xea, 0xf6, 0xb4, 0x38, 0xb3, 0x2d, 0x79, 0xfb, 0x6b, 0x6c, 0x63, 0xb8,
+	0x82, 0xd0, 0xcf, 0x61, 0xc3, 0xe1, 0xfd, 0xe1, 0x42, 0xbf, 0x90, 0xbd, 0x31, 0xeb, 0xc8, 0xcb,
+	0xa8, 0xaf, 0x3b, 0x59, 0x00, 0x97, 0xdc, 0x8d, 0xc2, 0xd9, 0x52, 0xb9, 0x98, 0x5d, 0xf2, 0x76,
+	0x14, 0xce, 0x32, 0xba, 0x35, 0x37, 0x43, 0xd3, 0x1d, 0xa8, 0x49, 0xcf, 0x79, 0x07, 0x24, 0x9f,
+	0x73, 0xaf, 0x66, 0xdd, 0xe6, 0x4d, 0xd2, 0xfe, 0x1a, 0xab, 0x0e, 0x97, 0x24, 0x7d, 0x0c, 0x55,
+	0xe1, 0xb0, 0x50, 0x2b, 0x67, 0x9b, 0x1f, 0xee, 0x6d, 0xaa, 0x05, 0xce, 0x82, 0xa2, 0x9f, 0x00,
+	0x70, 0x3f, 0x85, 0x8e, 0x9a, 0x6d, 0xaf, 0xd0, 0xc9, 0x54, 0xa5, 0xe2, 0xa6, 0x44, 0xc6, 0x3d,
+	0x7f, 0xea, 0x7a, 0xaf, 0xe4, 0xf3, 0xef, 0x8a, 0x7b, 0xfc, 0xe1, 0x61, 0xe9, 0x1e, 0x27, 0x97,
+	0xee, 0x09, 0x35, 0xb8, 0xe0, 0x5e, 0xaa, 0x25, 0xdc, 0x13, 0x4a, 0xa9, 0x7b, 0x42, 0xa7, 0xfa,
+	0xba, 0x7b, 0xa9, 0x0a, 0x77, 0x4f, 0x68, 0x7c, 0x0e, 0x1b, 0x49, 0x34, 0x9f, 0x0e, 0x97, 0xeb,
+	0x57, 0xcb, 0x6e, 0x9b, 0x2d, 0x79, 0xe9, 0xc4, 0xd6, 0x93, 0x2c, 0x80, 0xda, 0xf1, 0xf3, 0xf0,
+	0x2c, 0x73, 0x54, 0xd6, 0xb3, 0xda, 0xbd, 0xe7, 0xe1, 0x59, 0xf6, 0xac, 0xac, 0xc7, 0x59, 0x40,
+	0xfb, 0xbb, 0x3c, 0x94, 0x65, 0xac, 0xd2, 0x6b, 0x70, 0xa5, 0xc5, 0x0c, 0xdd, 0x36, 0xfa, 0x6d,
+	0xdd, 0xd6, 0x9b, 0x7a, 0x0f, 0xb3, 0x2b, 0x85, 0x0d, 0x1d, 0x1b, 0xa9, 0x25, 0xa6, 0xe0, 0xb1,
+	0x6a, 0xb3, 0xee, 0xe1, 0x12, 0xca, 0x51, 0x02, 0x35, 0xa9, 0x2b, 0x7e, 0xdc, 0xc8, 0xe3, 0xc5,
+	0x5a, 0x28, 0x0a, 0xa0, 0xc0, 0x7f, 0x20, 0x47, 0x2d, 0x41, 0x17, 0x33, 0x2a, 0xa6, 0xd5, 0x36,
+	0xbe, 0x22, 0xa5, 0xa5, 0x8a, 0x00, 0xca, 0x0b, 0x15, 0x41, 0xab, 0xe8, 0x8c, 0xcd, 0x8e, 0xac,
+	0xd6, 0xf2, 0x3b, 0x15, 0x7a, 0x13, 0xae, 0xf5, 0xf6, 0xbb, 0xcf, 0xfa, 0xc2, 0xd6, 0xc2, 0x25,
+	0xa0, 0xd7, 0x81, 0x64, 0x18, 0x42, 0xbc, 0x8a, 0x26, 0x38, 0x9a, 0x0a, 0xf6, 0x48, 0x0d, 0xbf,
+	0xcb, 0x31, 0x5b, 0x24, 0x89, 0x75, 0x74, 0x4d, 0xa8, 0x76, 0x3b, 0x47, 0x07, 0x56, 0x8f, 0x6c,
+	0xa0, 0x27, 0x1c, 0x11, 0x9e, 0x5c, 0x59, 0x98, 0x59, 0xa6, 0x16, 0xc2, 0xb3, 0x0d, 0x62, 0xcf,
+	0x74, 0x66, 0x99, 0xd6, 0x5e, 0x8f, 0x5c, 0x5d, 0x58, 0x36, 0x18, 0xeb, 0xb2, 0x1e, 0xa1, 0x0b,
+	0xa0, 0x67, 0xeb, 0xf6, 0x51, 0x8f, 0x5c, 0x5b, 0x78, 0x79, 0xc8, 0xba, 0x2d, 0xa3, 0xd7, 0xeb,
+	0x98, 0x3d, 0x9b, 0x5c, 0x6f, 0xd6, 0x00, 0xdc, 0x45, 0x32, 0xd1, 0x0e, 0x61, 0x63, 0xf5, 0xec,
+	0x53, 0x0d, 0xd6, 0xfd, 0x51, 0x7f, 0x1a, 0x26, 0x7d, 0xfe, 0x33, 0x41, 0x2c, 0x7f, 0x34, 0xa8,
+	0xfa, 0x23, 0x2b, 0x4c, 0x0c, 0x0e, 0x61, 0x6f, 0xb4, 0x38, 0xca, 0xe2, 0x2d, 0x65, 0x41, 0x6b,
+	0xfb, 0xb0, 0xbe, 0x92, 0x0d, 0xe8, 0x5b, 0x50, 0xf1, 0x47, 0xab, 0xc6, 0x54, 0x7f, 0xf4, 0x23,
+	0x2c, 0xed, 0x41, 0x2d, 0x9b, 0x1a, 0x7e, 0xba, 0xa1, 0xbf, 0x57, 0xa0, 0x9a, 0x49, 0x15, 0x3f,
+	0x6a, 0x8a, 0xb7, 0xa1, 0x92, 0x78, 0x93, 0x59, 0x18, 0x39, 0x32, 0xb1, 0xaa, 0x6c, 0x09, 0xac,
+	0x7c, 0x2d, 0xbf, 0xfa, 0xb5, 0xd5, 0xdb, 0x5c, 0xe1, 0x87, 0x6f, 0x73, 0x5a, 0x17, 0x60, 0x99,
+	0x8d, 0xf8, 0xbb, 0x1f, 0x3f, 0xa5, 0xe2, 0x4d, 0x45, 0x10, 0xab, 0x06, 0x73, 0x7f, 0xc4, 0xe0,
+	0xd7, 0x50, 0x59, 0xa4, 0xaa, 0x9f, 0xbc, 0x62, 0x4b, 0x47, 0xf2, 0x19, 0x47, 0xb4, 0xbd, 0x74,
+	0x19, 0x45, 0x72, 0xf9, 0x31, 0xcb, 0x78, 0x1d, 0x8a, 0x22, 0x5b, 0xc9, 0x87, 0x69, 0x4e, 0x68,
+	0x9a, 0x9c, 0xb5, 0xb0, 0xb3, 0x90, 0x51, 0xb2, 0x32, 0xbf, 0x10, 0x13, 0x11, 0x22, 0x3f, 0x38,
+	0x91, 0xcb, 0xbf, 0x71, 0x0f, 0xd6, 0x57, 0xd2, 0xdb, 0xe5, 0x8b, 0xab, 0x99, 0xb0, 0xbe, 0x92,
+	0xc7, 0xe8, 0x0d, 0x28, 0x8d, 0x83, 0x70, 0xe0, 0x2c, 0xfe, 0xfd, 0x43, 0x50, 0x78, 0xab, 0x38,
+	0x7b, 0xee, 0x45, 0xde, 0x25, 0xbf, 0xd1, 0x0a, 0x86, 0xf6, 0x39, 0xd4, 0xb2, 0xdd, 0x03, 0xfd,
+	0x10, 0x8a, 0x7e, 0xe2, 0x4d, 0xd2, 0x87, 0xf6, 0x1b, 0x17, 0x1b, 0x0c, 0x33, 0xf1, 0x26, 0x4c,
+	0x08, 0x69, 0xbf, 0x53, 0x80, 0xbc, 0xce, 0xe3, 0xbf, 0x74, 0x9f, 0xc7, 0x89, 0x37, 0x49, 0x9d,
+	0x11, 0x54, 0xc6, 0xc9, 0xdc, 0x8a, 0x93, 0xe9, 0x1b, 0x7d, 0x7e, 0xe5, 0x8d, 0x5e, 0xfe, 0x36,
+	0x70, 0xc9, 0x6f, 0xfb, 0xe2, 0xe7, 0xbd, 0xf7, 0x41, 0x8d, 0x3c, 0xfe, 0xa3, 0xb8, 0x2b, 0x2b,
+	0x73, 0x56, 0x68, 0xc1, 0xbb, 0x7f, 0x17, 0x6a, 0xd9, 0x9f, 0x7a, 0x78, 0xa3, 0x1c, 0x4e, 0x3d,
+	0xb2, 0x86, 0x77, 0xba, 0xce, 0xaf, 0xb7, 0x89, 0x72, 0xff, 0x97, 0x50, 0xff, 0xbe, 0x16, 0x14,
+	0xfb, 0xa3, 0xd6, 0xbe, 0xce, 0xdb, 0xfc, 0x1a, 0xa8, 0x56, 0xb7, 0x2f, 0x28, 0x05, 0x6f, 0x4f,
+	0xcc, 0xe8, 0x18, 0x3c, 0xdd, 0x37, 0xbf, 0xf8, 0xf6, 0xbb, 0x3b, 0xca, 0xbf, 0x7e, 0x77, 0x47,
+	0xf9, 0xcf, 0xef, 0xee, 0xac, 0xfd, 0xee, 0xbf, 0xef, 0x28, 0x5f, 0x67, 0xff, 0x2f, 0x6d, 0xe2,
+	0x24, 0x91, 0xff, 0x2a, 0x8c, 0xfc, 0xb1, 0x3f, 0x4d, 0x89, 0xa9, 0xf7, 0xf1, 0xec, 0xe5, 0xf8,
+	0xe3, 0xd9, 0xe0, 0x63, 0x74, 0x7a, 0x50, 0xe2, 0xff, 0x9e, 0xf6, 0xf8, 0x7f, 0x03, 0x00, 0x00,
+	0xff, 0xff, 0x1a, 0xb6, 0xc4, 0x06, 0xe1, 0x26, 0x00, 0x00,
 }
 
 func (m *Type) Marshal() (dAtA []byte, err error) {
@@ -7614,6 +7883,89 @@ func (m *Plan_Ddl) MarshalToSizedBuffer(dAtA []byte) (int, error) {
 	}
 	return len(dAtA) - i, nil
 }
+func (m *Plan_Dcl) MarshalTo(dAtA []byte) (int, error) {
+	size := m.ProtoSize()
+	return m.MarshalToSizedBuffer(dAtA[:size])
+}
+
+func (m *Plan_Dcl) MarshalToSizedBuffer(dAtA []byte) (int, error) {
+	i := len(dAtA)
+	if m.Dcl != nil {
+		{
+			size, err := m.Dcl.MarshalToSizedBuffer(dAtA[:i])
+			if err != nil {
+				return 0, err
+			}
+			i -= size
+			i = encodeVarintPlan(dAtA, i, uint64(size))
+		}
+		i--
+		dAtA[i] = 0x22
+	}
+	return len(dAtA) - i, nil
+}
+func (m *DataControl) Marshal() (dAtA []byte, err error) {
+	size := m.ProtoSize()
+	dAtA = make([]byte, size)
+	n, err := m.MarshalToSizedBuffer(dAtA[:size])
+	if err != nil {
+		return nil, err
+	}
+	return dAtA[:n], nil
+}
+
+func (m *DataControl) MarshalTo(dAtA []byte) (int, error) {
+	size := m.ProtoSize()
+	return m.MarshalToSizedBuffer(dAtA[:size])
+}
+
+func (m *DataControl) MarshalToSizedBuffer(dAtA []byte) (int, error) {
+	i := len(dAtA)
+	_ = i
+	var l int
+	_ = l
+	if m.XXX_unrecognized != nil {
+		i -= len(m.XXX_unrecognized)
+		copy(dAtA[i:], m.XXX_unrecognized)
+	}
+	if m.Control != nil {
+		{
+			size := m.Control.ProtoSize()
+			i -= size
+			if _, err := m.Control.MarshalTo(dAtA[i:]); err != nil {
+				return 0, err
+			}
+		}
+	}
+	if m.DclType != 0 {
+		i = encodeVarintPlan(dAtA, i, uint64(m.DclType))
+		i--
+		dAtA[i] = 0x8
+	}
+	return len(dAtA) - i, nil
+}
+
+func (m *DataControl_SetVariables) MarshalTo(dAtA []byte) (int, error) {
+	size := m.ProtoSize()
+	return m.MarshalToSizedBuffer(dAtA[:size])
+}
+
+func (m *DataControl_SetVariables) MarshalToSizedBuffer(dAtA []byte) (int, error) {
+	i := len(dAtA)
+	if m.SetVariables != nil {
+		{
+			size, err := m.SetVariables.MarshalToSizedBuffer(dAtA[:i])
+			if err != nil {
+				return 0, err
+			}
+			i -= size
+			i = encodeVarintPlan(dAtA, i, uint64(size))
+		}
+		i--
+		dAtA[i] = 0x12
+	}
+	return len(dAtA) - i, nil
+}
 func (m *DataDefinition) Marshal() (dAtA []byte, err error) {
 	size := m.ProtoSize()
 	dAtA = make([]byte, size)
@@ -8400,22 +8752,141 @@ func (m *ShowVariables) MarshalToSizedBuffer(dAtA []byte) (int, error) {
 	return len(dAtA) - i, nil
 }
 
-func encodeVarintPlan(dAtA []byte, offset int, v uint64) int {
-	offset -= sovPlan(v)
-	base := offset
-	for v >= 1<<7 {
-		dAtA[offset] = uint8(v&0x7f | 0x80)
-		v >>= 7
-		offset++
+func (m *SetVariables) Marshal() (dAtA []byte, err error) {
+	size := m.ProtoSize()
+	dAtA = make([]byte, size)
+	n, err := m.MarshalToSizedBuffer(dAtA[:size])
+	if err != nil {
+		return nil, err
 	}
-	dAtA[offset] = uint8(v)
-	return base
+	return dAtA[:n], nil
 }
-func (m *Type) ProtoSize() (n int) {
-	if m == nil {
-		return 0
-	}
-	var l int
+
+func (m *SetVariables) MarshalTo(dAtA []byte) (int, error) {
+	size := m.ProtoSize()
+	return m.MarshalToSizedBuffer(dAtA[:size])
+}
+
+func (m *SetVariables) MarshalToSizedBuffer(dAtA []byte) (int, error) {
+	i := len(dAtA)
+	_ = i
+	var l int
+	_ = l
+	if m.XXX_unrecognized != nil {
+		i -= len(m.XXX_unrecognized)
+		copy(dAtA[i:], m.XXX_unrecognized)
+	}
+	if len(m.Items) > 0 {
+		for iNdEx := len(m.Items) - 1; iNdEx >= 0; iNdEx-- {
+			{
+				size, err := m.Items[iNdEx].MarshalToSizedBuffer(dAtA[:i])
+				if err != nil {
+					return 0, err
+				}
+				i -= size
+				i = encodeVarintPlan(dAtA, i, uint64(size))
+			}
+			i--
+			dAtA[i] = 0xa
+		}
+	}
+	return len(dAtA) - i, nil
+}
+
+func (m *SetVariablesItem) Marshal() (dAtA []byte, err error) {
+	size := m.ProtoSize()
+	dAtA = make([]byte, size)
+	n, err := m.MarshalToSizedBuffer(dAtA[:size])
+	if err != nil {
+		return nil, err
+	}
+	return dAtA[:n], nil
+}
+
+func (m *SetVariablesItem) MarshalTo(dAtA []byte) (int, error) {
+	size := m.ProtoSize()
+	return m.MarshalToSizedBuffer(dAtA[:size])
+}
+
+func (m *SetVariablesItem) MarshalToSizedBuffer(dAtA []byte) (int, error) {
+	i := len(dAtA)
+	_ = i
+	var l int
+	_ = l
+	if m.XXX_unrecognized != nil {
+		i -= len(m.XXX_unrecognized)
+		copy(dAtA[i:], m.XXX_unrecognized)
+	}
+	if m.Reserved != nil {
+		{
+			size, err := m.Reserved.MarshalToSizedBuffer(dAtA[:i])
+			if err != nil {
+				return 0, err
+			}
+			i -= size
+			i = encodeVarintPlan(dAtA, i, uint64(size))
+		}
+		i--
+		dAtA[i] = 0x2a
+	}
+	if m.Value != nil {
+		{
+			size, err := m.Value.MarshalToSizedBuffer(dAtA[:i])
+			if err != nil {
+				return 0, err
+			}
+			i -= size
+			i = encodeVarintPlan(dAtA, i, uint64(size))
+		}
+		i--
+		dAtA[i] = 0x22
+	}
+	if len(m.Name) > 0 {
+		i -= len(m.Name)
+		copy(dAtA[i:], m.Name)
+		i = encodeVarintPlan(dAtA, i, uint64(len(m.Name)))
+		i--
+		dAtA[i] = 0x1a
+	}
+	if m.Global {
+		i--
+		if m.Global {
+			dAtA[i] = 1
+		} else {
+			dAtA[i] = 0
+		}
+		i--
+		dAtA[i] = 0x10
+	}
+	if m.System {
+		i--
+		if m.System {
+			dAtA[i] = 1
+		} else {
+			dAtA[i] = 0
+		}
+		i--
+		dAtA[i] = 0x8
+	}
+	return len(dAtA) - i, nil
+}
+
+func encodeVarintPlan(dAtA []byte, offset int, v uint64) int {
+	offset -= sovPlan(v)
+	base := offset
+	for v >= 1<<7 {
+		dAtA[offset] = uint8(v&0x7f | 0x80)
+		v >>= 7
+		offset++
+	}
+	dAtA[offset] = uint8(v)
+	return base
+}
+func (m *Type) ProtoSize() (n int) {
+	if m == nil {
+		return 0
+	}
+	var l int
 	_ = l
 	if m.Id != 0 {
 		n += 1 + sovPlan(uint64(m.Id))
@@ -9747,6 +10218,48 @@ func (m *Plan_Ddl) ProtoSize() (n int) {
 	}
 	return n
 }
+func (m *Plan_Dcl) ProtoSize() (n int) {
+	if m == nil {
+		return 0
+	}
+	var l int
+	_ = l
+	if m.Dcl != nil {
+		l = m.Dcl.ProtoSize()
+		n += 1 + l + sovPlan(uint64(l))
+	}
+	return n
+}
+func (m *DataControl) ProtoSize() (n int) {
+	if m == nil {
+		return 0
+	}
+	var l int
+	_ = l
+	if m.DclType != 0 {
+		n += 1 + sovPlan(uint64(m.DclType))
+	}
+	if m.Control != nil {
+		n += m.Control.ProtoSize()
+	}
+	if m.XXX_unrecognized != nil {
+		n += len(m.XXX_unrecognized)
+	}
+	return n
+}
+
+func (m *DataControl_SetVariables) ProtoSize() (n int) {
+	if m == nil {
+		return 0
+	}
+	var l int
+	_ = l
+	if m.SetVariables != nil {
+		l = m.SetVariables.ProtoSize()
+		n += 1 + l + sovPlan(uint64(l))
+	}
+	return n
+}
 func (m *DataDefinition) ProtoSize() (n int) {
 	if m == nil {
 		return 0
@@ -10118,6 +10631,54 @@ func (m *ShowVariables) ProtoSize() (n int) {
 	return n
 }
 
+func (m *SetVariables) ProtoSize() (n int) {
+	if m == nil {
+		return 0
+	}
+	var l int
+	_ = l
+	if len(m.Items) > 0 {
+		for _, e := range m.Items {
+			l = e.ProtoSize()
+			n += 1 + l + sovPlan(uint64(l))
+		}
+	}
+	if m.XXX_unrecognized != nil {
+		n += len(m.XXX_unrecognized)
+	}
+	return n
+}
+
+func (m *SetVariablesItem) ProtoSize() (n int) {
+	if m == nil {
+		return 0
+	}
+	var l int
+	_ = l
+	if m.System {
+		n += 2
+	}
+	if m.Global {
+		n += 2
+	}
+	l = len(m.Name)
+	if l > 0 {
+		n += 1 + l + sovPlan(uint64(l))
+	}
+	if m.Value != nil {
+		l = m.Value.ProtoSize()
+		n += 1 + l + sovPlan(uint64(l))
+	}
+	if m.Reserved != nil {
+		l = m.Reserved.ProtoSize()
+		n += 1 + l + sovPlan(uint64(l))
+	}
+	if m.XXX_unrecognized != nil {
+		n += len(m.XXX_unrecognized)
+	}
+	return n
+}
+
 func sovPlan(x uint64) (n int) {
 	return (math_bits.Len64(x|1) + 6) / 7
 }
@@ -16372,6 +16933,41 @@ func (m *Plan) Unmarshal(dAtA []byte) error {
 			}
 			m.Plan = &Plan_Ddl{v}
 			iNdEx = postIndex
+		case 4:
+			if wireType != 2 {
+				return fmt.Errorf("proto: wrong wireType = %d for field Dcl", wireType)
+			}
+			var msglen int
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowPlan
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				msglen |= int(b&0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+			if msglen < 0 {
+				return ErrInvalidLengthPlan
+			}
+			postIndex := iNdEx + msglen
+			if postIndex < 0 {
+				return ErrInvalidLengthPlan
+			}
+			if postIndex > l {
+				return io.ErrUnexpectedEOF
+			}
+			v := &DataControl{}
+			if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
+				return err
+			}
+			m.Plan = &Plan_Dcl{v}
+			iNdEx = postIndex
 		default:
 			iNdEx = preIndex
 			skippy, err := skipPlan(dAtA[iNdEx:])
@@ -16394,7 +16990,7 @@ func (m *Plan) Unmarshal(dAtA []byte) error {
 	}
 	return nil
 }
-func (m *DataDefinition) Unmarshal(dAtA []byte) error {
+func (m *DataControl) Unmarshal(dAtA []byte) error {
 	l := len(dAtA)
 	iNdEx := 0
 	for iNdEx < l {
@@ -16417,17 +17013,17 @@ func (m *DataDefinition) Unmarshal(dAtA []byte) error {
 		fieldNum := int32(wire >> 3)
 		wireType := int(wire & 0x7)
 		if wireType == 4 {
-			return fmt.Errorf("proto: DataDefinition: wiretype end group for non-group")
+			return fmt.Errorf("proto: DataControl: wiretype end group for non-group")
 		}
 		if fieldNum <= 0 {
-			return fmt.Errorf("proto: DataDefinition: illegal tag %d (wire type %d)", fieldNum, wire)
+			return fmt.Errorf("proto: DataControl: illegal tag %d (wire type %d)", fieldNum, wire)
 		}
 		switch fieldNum {
 		case 1:
 			if wireType != 0 {
-				return fmt.Errorf("proto: wrong wireType = %d for field DdlType", wireType)
+				return fmt.Errorf("proto: wrong wireType = %d for field DclType", wireType)
 			}
-			m.DdlType = 0
+			m.DclType = 0
 			for shift := uint(0); ; shift += 7 {
 				if shift >= 64 {
 					return ErrIntOverflowPlan
@@ -16437,14 +17033,14 @@ func (m *DataDefinition) Unmarshal(dAtA []byte) error {
 				}
 				b := dAtA[iNdEx]
 				iNdEx++
-				m.DdlType |= DataDefinition_DdlType(b&0x7F) << shift
+				m.DclType |= DataControl_DclType(b&0x7F) << shift
 				if b < 0x80 {
 					break
 				}
 			}
 		case 2:
 			if wireType != 2 {
-				return fmt.Errorf("proto: wrong wireType = %d for field Query", wireType)
+				return fmt.Errorf("proto: wrong wireType = %d for field SetVariables", wireType)
 			}
 			var msglen int
 			for shift := uint(0); ; shift += 7 {
@@ -16471,36 +17067,141 @@ func (m *DataDefinition) Unmarshal(dAtA []byte) error {
 			if postIndex > l {
 				return io.ErrUnexpectedEOF
 			}
-			if m.Query == nil {
-				m.Query = &Query{}
-			}
-			if err := m.Query.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
+			v := &SetVariables{}
+			if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
 				return err
 			}
+			m.Control = &DataControl_SetVariables{v}
 			iNdEx = postIndex
-		case 3:
-			if wireType != 2 {
-				return fmt.Errorf("proto: wrong wireType = %d for field CreateDatabase", wireType)
-			}
-			var msglen int
-			for shift := uint(0); ; shift += 7 {
-				if shift >= 64 {
-					return ErrIntOverflowPlan
-				}
-				if iNdEx >= l {
-					return io.ErrUnexpectedEOF
-				}
-				b := dAtA[iNdEx]
-				iNdEx++
-				msglen |= int(b&0x7F) << shift
-				if b < 0x80 {
-					break
-				}
+		default:
+			iNdEx = preIndex
+			skippy, err := skipPlan(dAtA[iNdEx:])
+			if err != nil {
+				return err
 			}
-			if msglen < 0 {
+			if (skippy < 0) || (iNdEx+skippy) < 0 {
 				return ErrInvalidLengthPlan
 			}
-			postIndex := iNdEx + msglen
+			if (iNdEx + skippy) > l {
+				return io.ErrUnexpectedEOF
+			}
+			m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
+			iNdEx += skippy
+		}
+	}
+
+	if iNdEx > l {
+		return io.ErrUnexpectedEOF
+	}
+	return nil
+}
+func (m *DataDefinition) Unmarshal(dAtA []byte) error {
+	l := len(dAtA)
+	iNdEx := 0
+	for iNdEx < l {
+		preIndex := iNdEx
+		var wire uint64
+		for shift := uint(0); ; shift += 7 {
+			if shift >= 64 {
+				return ErrIntOverflowPlan
+			}
+			if iNdEx >= l {
+				return io.ErrUnexpectedEOF
+			}
+			b := dAtA[iNdEx]
+			iNdEx++
+			wire |= uint64(b&0x7F) << shift
+			if b < 0x80 {
+				break
+			}
+		}
+		fieldNum := int32(wire >> 3)
+		wireType := int(wire & 0x7)
+		if wireType == 4 {
+			return fmt.Errorf("proto: DataDefinition: wiretype end group for non-group")
+		}
+		if fieldNum <= 0 {
+			return fmt.Errorf("proto: DataDefinition: illegal tag %d (wire type %d)", fieldNum, wire)
+		}
+		switch fieldNum {
+		case 1:
+			if wireType != 0 {
+				return fmt.Errorf("proto: wrong wireType = %d for field DdlType", wireType)
+			}
+			m.DdlType = 0
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowPlan
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				m.DdlType |= DataDefinition_DdlType(b&0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+		case 2:
+			if wireType != 2 {
+				return fmt.Errorf("proto: wrong wireType = %d for field Query", wireType)
+			}
+			var msglen int
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowPlan
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				msglen |= int(b&0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+			if msglen < 0 {
+				return ErrInvalidLengthPlan
+			}
+			postIndex := iNdEx + msglen
+			if postIndex < 0 {
+				return ErrInvalidLengthPlan
+			}
+			if postIndex > l {
+				return io.ErrUnexpectedEOF
+			}
+			if m.Query == nil {
+				m.Query = &Query{}
+			}
+			if err := m.Query.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
+				return err
+			}
+			iNdEx = postIndex
+		case 3:
+			if wireType != 2 {
+				return fmt.Errorf("proto: wrong wireType = %d for field CreateDatabase", wireType)
+			}
+			var msglen int
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowPlan
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				msglen |= int(b&0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+			if msglen < 0 {
+				return ErrInvalidLengthPlan
+			}
+			postIndex := iNdEx + msglen
 			if postIndex < 0 {
 				return ErrInvalidLengthPlan
 			}
@@ -18084,6 +18785,286 @@ func (m *ShowVariables) Unmarshal(dAtA []byte) error {
 	}
 	return nil
 }
+func (m *SetVariables) Unmarshal(dAtA []byte) error {
+	l := len(dAtA)
+	iNdEx := 0
+	for iNdEx < l {
+		preIndex := iNdEx
+		var wire uint64
+		for shift := uint(0); ; shift += 7 {
+			if shift >= 64 {
+				return ErrIntOverflowPlan
+			}
+			if iNdEx >= l {
+				return io.ErrUnexpectedEOF
+			}
+			b := dAtA[iNdEx]
+			iNdEx++
+			wire |= uint64(b&0x7F) << shift
+			if b < 0x80 {
+				break
+			}
+		}
+		fieldNum := int32(wire >> 3)
+		wireType := int(wire & 0x7)
+		if wireType == 4 {
+			return fmt.Errorf("proto: SetVariables: wiretype end group for non-group")
+		}
+		if fieldNum <= 0 {
+			return fmt.Errorf("proto: SetVariables: illegal tag %d (wire type %d)", fieldNum, wire)
+		}
+		switch fieldNum {
+		case 1:
+			if wireType != 2 {
+				return fmt.Errorf("proto: wrong wireType = %d for field Items", wireType)
+			}
+			var msglen int
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowPlan
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				msglen |= int(b&0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+			if msglen < 0 {
+				return ErrInvalidLengthPlan
+			}
+			postIndex := iNdEx + msglen
+			if postIndex < 0 {
+				return ErrInvalidLengthPlan
+			}
+			if postIndex > l {
+				return io.ErrUnexpectedEOF
+			}
+			m.Items = append(m.Items, &SetVariablesItem{})
+			if err := m.Items[len(m.Items)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
+				return err
+			}
+			iNdEx = postIndex
+		default:
+			iNdEx = preIndex
+			skippy, err := skipPlan(dAtA[iNdEx:])
+			if err != nil {
+				return err
+			}
+			if (skippy < 0) || (iNdEx+skippy) < 0 {
+				return ErrInvalidLengthPlan
+			}
+			if (iNdEx + skippy) > l {
+				return io.ErrUnexpectedEOF
+			}
+			m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
+			iNdEx += skippy
+		}
+	}
+
+	if iNdEx > l {
+		return io.ErrUnexpectedEOF
+	}
+	return nil
+}
+func (m *SetVariablesItem) Unmarshal(dAtA []byte) error {
+	l := len(dAtA)
+	iNdEx := 0
+	for iNdEx < l {
+		preIndex := iNdEx
+		var wire uint64
+		for shift := uint(0); ; shift += 7 {
+			if shift >= 64 {
+				return ErrIntOverflowPlan
+			}
+			if iNdEx >= l {
+				return io.ErrUnexpectedEOF
+			}
+			b := dAtA[iNdEx]
+			iNdEx++
+			wire |= uint64(b&0x7F) << shift
+			if b < 0x80 {
+				break
+			}
+		}
+		fieldNum := int32(wire >> 3)
+		wireType := int(wire & 0x7)
+		if wireType == 4 {
+			return fmt.Errorf("proto: SetVariablesItem: wiretype end group for non-group")
+		}
+		if fieldNum <= 0 {
+			return fmt.Errorf("proto: SetVariablesItem: illegal tag %d (wire type %d)", fieldNum, wire)
+		}
+		switch fieldNum {
+		case 1:
+			if wireType != 0 {
+				return fmt.Errorf("proto: wrong wireType = %d for field System", wireType)
+			}
+			var v int
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowPlan
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				v |= int(b&0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+			m.System = bool(v != 0)
+		case 2:
+			if wireType != 0 {
+				return fmt.Errorf("proto: wrong wireType = %d for field Global", wireType)
+			}
+			var v int
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowPlan
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				v |= int(b&0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+			m.Global = bool(v != 0)
+		case 3:
+			if wireType != 2 {
+				return fmt.Errorf("proto: wrong wireType = %d for field Name", wireType)
+			}
+			var stringLen uint64
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowPlan
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				stringLen |= uint64(b&0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+			intStringLen := int(stringLen)
+			if intStringLen < 0 {
+				return ErrInvalidLengthPlan
+			}
+			postIndex := iNdEx + intStringLen
+			if postIndex < 0 {
+				return ErrInvalidLengthPlan
+			}
+			if postIndex > l {
+				return io.ErrUnexpectedEOF
+			}
+			m.Name = string(dAtA[iNdEx:postIndex])
+			iNdEx = postIndex
+		case 4:
+			if wireType != 2 {
+				return fmt.Errorf("proto: wrong wireType = %d for field Value", wireType)
+			}
+			var msglen int
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowPlan
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				msglen |= int(b&0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+			if msglen < 0 {
+				return ErrInvalidLengthPlan
+			}
+			postIndex := iNdEx + msglen
+			if postIndex < 0 {
+				return ErrInvalidLengthPlan
+			}
+			if postIndex > l {
+				return io.ErrUnexpectedEOF
+			}
+			if m.Value == nil {
+				m.Value = &Expr{}
+			}
+			if err := m.Value.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
+				return err
+			}
+			iNdEx = postIndex
+		case 5:
+			if wireType != 2 {
+				return fmt.Errorf("proto: wrong wireType = %d for field Reserved", wireType)
+			}
+			var msglen int
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowPlan
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				msglen |= int(b&0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+			if msglen < 0 {
+				return ErrInvalidLengthPlan
+			}
+			postIndex := iNdEx + msglen
+			if postIndex < 0 {
+				return ErrInvalidLengthPlan
+			}
+			if postIndex > l {
+				return io.ErrUnexpectedEOF
+			}
+			if m.Reserved == nil {
+				m.Reserved = &Expr{}
+			}
+			if err := m.Reserved.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
+				return err
+			}
+			iNdEx = postIndex
+		default:
+			iNdEx = preIndex
+			skippy, err := skipPlan(dAtA[iNdEx:])
+			if err != nil {
+				return err
+			}
+			if (skippy < 0) || (iNdEx+skippy) < 0 {
+				return ErrInvalidLengthPlan
+			}
+			if (iNdEx + skippy) > l {
+				return io.ErrUnexpectedEOF
+			}
+			m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
+			iNdEx += skippy
+		}
+	}
+
+	if iNdEx > l {
+		return io.ErrUnexpectedEOF
+	}
+	return nil
+}
 func skipPlan(dAtA []byte) (n int, err error) {
 	l := len(dAtA)
 	iNdEx := 0
diff --git a/pkg/sql/colexec2/left/join.go b/pkg/sql/colexec2/left/join.go
index 7a2d8fb8b..cc9249150 100644
--- a/pkg/sql/colexec2/left/join.go
+++ b/pkg/sql/colexec2/left/join.go
@@ -107,13 +107,18 @@ func Call(proc *process.Process, arg interface{}) (bool, error) {
 				continue
 			}
 			if ctr.bat == nil {
-				bat.Clean(proc.Mp)
-				continue
-			}
-			if err := ctr.probe(bat, ap, proc); err != nil {
-				ctr.state = End
-				proc.Reg.InputBatch = nil
-				return true, err
+				if err := ctr.emptyProbe(bat, ap, proc); err != nil {
+					ctr.state = End
+					proc.Reg.InputBatch = nil
+					return true, err
+				}
+
+			} else {
+				if err := ctr.probe(bat, ap, proc); err != nil {
+					ctr.state = End
+					proc.Reg.InputBatch = nil
+					return true, err
+				}
 			}
 			return false, nil
 		default:
@@ -381,6 +386,43 @@ func (ctr *Container) build(ap *Argument, proc *process.Process) error {
 	}
 }
 
+func (ctr *Container) emptyProbe(bat *batch.Batch, ap *Argument, proc *process.Process) error {
+	defer bat.Clean(proc.Mp)
+	rbat := batch.NewWithSize(len(ap.Result))
+	for i, rp := range ap.Result {
+		if rp.Rel == 0 {
+			rbat.Vecs[i] = vector.New(bat.Vecs[rp.Pos].Typ)
+		} else {
+			rbat.Vecs[i] = vector.New(types.Type{Oid: types.T_int8, Size: 1})
+		}
+	}
+	count := len(bat.Zs)
+	for i := 0; i < count; i += UnitLimit {
+		n := count - i
+		if n > UnitLimit {
+			n = UnitLimit
+		}
+		for k := 0; k < n; k++ {
+			for j, rp := range ap.Result {
+				if rp.Rel == 0 {
+					if err := vector.UnionOne(rbat.Vecs[j], bat.Vecs[rp.Pos], int64(i+k), proc.Mp); err != nil {
+						rbat.Clean(proc.Mp)
+						return err
+					}
+				} else {
+					if err := vector.UnionNull(rbat.Vecs[j], nil, proc.Mp); err != nil {
+						rbat.Clean(proc.Mp)
+						return err
+					}
+				}
+			}
+			rbat.Zs = append(rbat.Zs, bat.Zs[i+k])
+		}
+	}
+	proc.Reg.InputBatch = rbat
+	return nil
+}
+
 func (ctr *Container) probe(bat *batch.Batch, ap *Argument, proc *process.Process) error {
 	defer bat.Clean(proc.Mp)
 	rbat := batch.NewWithSize(len(ap.Result))
diff --git a/pkg/sql/colexec2/loopleft/join.go b/pkg/sql/colexec2/loopleft/join.go
index 1c12a0c4a..036417d4e 100644
--- a/pkg/sql/colexec2/loopleft/join.go
+++ b/pkg/sql/colexec2/loopleft/join.go
@@ -18,6 +18,7 @@ import (
 	"bytes"
 
 	"github.com/matrixorigin/matrixone/pkg/container/batch"
+	"github.com/matrixorigin/matrixone/pkg/container/types"
 	"github.com/matrixorigin/matrixone/pkg/container/vector"
 	colexec "github.com/matrixorigin/matrixone/pkg/sql/colexec2"
 	"github.com/matrixorigin/matrixone/pkg/vm/process"
@@ -57,13 +58,18 @@ func Call(proc *process.Process, arg interface{}) (bool, error) {
 				continue
 			}
 			if ctr.bat == nil {
-				bat.Clean(proc.Mp)
-				continue
-			}
-			if err := ctr.probe(bat, ap, proc); err != nil {
-				ctr.state = End
-				proc.Reg.InputBatch = nil
-				return true, err
+				if err := ctr.emptyProbe(bat, ap, proc); err != nil {
+					ctr.state = End
+					proc.Reg.InputBatch = nil
+					return true, err
+				}
+
+			} else {
+				if err := ctr.probe(bat, ap, proc); err != nil {
+					ctr.state = End
+					proc.Reg.InputBatch = nil
+					return true, err
+				}
 			}
 			return false, nil
 		default:
@@ -100,6 +106,43 @@ func (ctr *Container) build(ap *Argument, proc *process.Process) error {
 	return nil
 }
 
+func (ctr *Container) emptyProbe(bat *batch.Batch, ap *Argument, proc *process.Process) error {
+	defer bat.Clean(proc.Mp)
+	rbat := batch.NewWithSize(len(ap.Result))
+	for i, rp := range ap.Result {
+		if rp.Rel == 0 {
+			rbat.Vecs[i] = vector.New(bat.Vecs[rp.Pos].Typ)
+		} else {
+			rbat.Vecs[i] = vector.New(types.Type{Oid: types.T_int8, Size: 1})
+		}
+	}
+	count := len(bat.Zs)
+	for i := 0; i < count; i += UnitLimit {
+		n := count - i
+		if n > UnitLimit {
+			n = UnitLimit
+		}
+		for k := 0; k < n; k++ {
+			for j, rp := range ap.Result {
+				if rp.Rel == 0 {
+					if err := vector.UnionOne(rbat.Vecs[j], bat.Vecs[rp.Pos], int64(i+k), proc.Mp); err != nil {
+						rbat.Clean(proc.Mp)
+						return err
+					}
+				} else {
+					if err := vector.UnionNull(rbat.Vecs[j], nil, proc.Mp); err != nil {
+						rbat.Clean(proc.Mp)
+						return err
+					}
+				}
+			}
+			rbat.Zs = append(rbat.Zs, bat.Zs[i+k])
+		}
+	}
+	proc.Reg.InputBatch = rbat
+	return nil
+}
+
 func (ctr *Container) probe(bat *batch.Batch, ap *Argument, proc *process.Process) error {
 	defer bat.Clean(proc.Mp)
 	rbat := batch.NewWithSize(len(ap.Result))
diff --git a/pkg/sql/colexec2/loopleft/types.go b/pkg/sql/colexec2/loopleft/types.go
index 64aa16c78..76d592a52 100644
--- a/pkg/sql/colexec2/loopleft/types.go
+++ b/pkg/sql/colexec2/loopleft/types.go
@@ -25,6 +25,10 @@ const (
 	End
 )
 
+const (
+	UnitLimit = 256
+)
+
 type Container struct {
 	state int
 	bat   *batch.Batch
diff --git a/pkg/sql/plan2/build.go b/pkg/sql/plan2/build.go
index 8e791becd..fef522d80 100644
--- a/pkg/sql/plan2/build.go
+++ b/pkg/sql/plan2/build.go
@@ -104,6 +104,8 @@ func BuildPlan(ctx CompilerContext, stmt tree.Statement) (*Plan, error) {
 		return buildShowStatus(stmt, ctx)
 	case *tree.ShowProcessList:
 		return buildShowProcessList(stmt, ctx)
+	case *tree.SetVar:
+		return buildSetVariables(stmt, ctx)
 	default:
 		return nil, errors.New(errno.SQLStatementNotYetComplete, fmt.Sprintf("unexpected statement: '%v'", tree.String(stmt, dialect.MYSQL)))
 	}
diff --git a/pkg/sql/plan2/build_dcl.go b/pkg/sql/plan2/build_dcl.go
new file mode 100644
index 000000000..7bc17e3c7
--- /dev/null
+++ b/pkg/sql/plan2/build_dcl.go
@@ -0,0 +1,66 @@
+// Copyright 2021 - 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 plan2
+
+import (
+	"github.com/matrixorigin/matrixone/pkg/pb/plan"
+	"github.com/matrixorigin/matrixone/pkg/sql/errors"
+	"github.com/matrixorigin/matrixone/pkg/sql/parsers/tree"
+)
+
+func buildSetVariables(stmt *tree.SetVar, ctx CompilerContext) (*Plan, error) {
+	var err error
+	items := make([]*plan.SetVariablesItem, len(stmt.Assignments))
+
+	builder := NewQueryBuilder(plan.Query_SELECT, ctx)
+	binder := NewWhereBinder(builder, &BindContext{})
+
+	for idx, assignment := range stmt.Assignments {
+		item := &plan.SetVariablesItem{
+			System: assignment.System,
+			Global: assignment.Global,
+			Name:   assignment.Name,
+		}
+		if assignment.Value == nil {
+			return nil, errors.New("", "value is required in SET statement")
+		}
+		item.Value, err = binder.baseBindExpr(assignment.Value, 0, true)
+		if err != nil {
+			return nil, err
+		}
+		if assignment.Reserved != nil {
+			item.Reserved, err = binder.baseBindExpr(assignment.Reserved, 0, true)
+			if err != nil {
+				return nil, err
+			}
+		}
+		items[idx] = item
+	}
+
+	setVariables := &plan.SetVariables{
+		Items: items,
+	}
+
+	return &Plan{
+		Plan: &plan.Plan_Dcl{
+			Dcl: &plan.DataControl{
+				DclType: plan.DataControl_SET_VARIABLES,
+				Control: &plan.DataControl_SetVariables{
+					SetVariables: setVariables,
+				},
+			},
+		},
+	}, nil
+}
diff --git a/pkg/sql/plan2/function/operator/case_when.go b/pkg/sql/plan2/function/operator/case_when.go
index a7329f8d7..ff7e832cd 100644
--- a/pkg/sql/plan2/function/operator/case_when.go
+++ b/pkg/sql/plan2/function/operator/case_when.go
@@ -149,7 +149,7 @@ func cwGeneral[T NormalType](vs []*vector.Vector, proc *process.Process, t types
 	if err != nil {
 		return nil, err
 	}
-	rs.Col = vector.DecodeFixedCol[T](rs, t.Oid.FixedLength())
+	rs.Col = vector.DecodeFixedCol[T](rs, t.Oid.TypeLen())
 	rs.Col = rs.Col.([]T)[:l]
 	rscols := rs.Col.([]T)
 
diff --git a/pkg/sql/plan2/function/operator/cast.go b/pkg/sql/plan2/function/operator/cast.go
index 6583940e8..fe6cac455 100644
--- a/pkg/sql/plan2/function/operator/cast.go
+++ b/pkg/sql/plan2/function/operator/cast.go
@@ -522,6 +522,19 @@ func Cast(vs []*vector.Vector, proc *process.Process) (*vector.Vector, error) {
 		return CastTimestampAsDate(lv, rv, proc)
 	}
 
+	if lv.Typ.Oid == types.T_decimal64 && rv.Typ.Oid == types.T_float32 {
+		return CastDecimal64ToFloat32(lv, rv, proc)
+	}
+	if lv.Typ.Oid == types.T_decimal128 && rv.Typ.Oid == types.T_float32 {
+		return CastDecimal128ToFloat32(lv, rv, proc)
+	}
+
+	if lv.Typ.Oid == types.T_decimal64 && rv.Typ.Oid == types.T_float64 {
+		return CastDecimal64ToFloat64(lv, rv, proc)
+	}
+	if lv.Typ.Oid == types.T_decimal128 && rv.Typ.Oid == types.T_float64 {
+		return CastDecimal128ToFloat64(lv, rv, proc)
+	}
 	// if lv.Typ.Oid == types.T_timestamp && rv.Typ.Oid == types.T_time {
 	// 	return CastTimestampAsTime(lv, rv, proc)
 	// }
@@ -1686,6 +1699,114 @@ func CastDecimal128AsTimestamp(lv, rv *vector.Vector, proc *process.Process) (*v
 	return vec, nil
 }
 
+func CastDecimal64ToFloat32(lv, rv *vector.Vector, proc *process.Process) (*vector.Vector, error) {
+	rtl := 4
+	lvs := lv.Col.([]types.Decimal64)
+	if lv.IsScalar() {
+		vec := proc.AllocScalarVector(rv.Typ)
+		rs := make([]float32, 1)
+		if _, err := typecast.Decimal64ToFloat32(lvs, lv.Typ.Scale, rs); err != nil {
+			return nil, err
+		}
+		nulls.Set(vec.Nsp, lv.Nsp)
+		vector.SetCol(vec, rs)
+		return vec, nil
+	}
+	vec, err := proc.AllocVector(rv.Typ, int64(len(lvs)*rtl))
+	if err != nil {
+		return nil, err
+	}
+	rs := encoding.DecodeFloat32Slice(vec.Data)
+	rs = rs[:len(lvs)]
+	if _, err := typecast.Decimal64ToFloat32(lvs, lv.Typ.Scale, rs); err != nil {
+		return nil, err
+	}
+	nulls.Set(vec.Nsp, lv.Nsp)
+	vector.SetCol(vec, rs)
+	return vec, nil
+}
+
+func CastDecimal128ToFloat32(lv, rv *vector.Vector, proc *process.Process) (*vector.Vector, error) {
+	rtl := 4
+	lvs := lv.Col.([]types.Decimal128)
+	if lv.IsScalar() {
+		vec := proc.AllocScalarVector(rv.Typ)
+		rs := make([]float32, 1)
+		if _, err := typecast.Decimal128ToFloat32(lvs, lv.Typ.Scale, rs); err != nil {
+			return nil, err
+		}
+		nulls.Set(vec.Nsp, lv.Nsp)
+		vector.SetCol(vec, rs)
+		return vec, nil
+	}
+	vec, err := proc.AllocVector(rv.Typ, int64(len(lvs)*rtl))
+	if err != nil {
+		return nil, err
+	}
+	rs := encoding.DecodeFloat32Slice(vec.Data)
+	rs = rs[:len(lvs)]
+	if _, err := typecast.Decimal128ToFloat32(lvs, lv.Typ.Scale, rs); err != nil {
+		return nil, err
+	}
+	nulls.Set(vec.Nsp, lv.Nsp)
+	vector.SetCol(vec, rs)
+	return vec, nil
+}
+
+func CastDecimal64ToFloat64(lv, rv *vector.Vector, proc *process.Process) (*vector.Vector, error) {
+	rtl := 8
+	lvs := lv.Col.([]types.Decimal64)
+	if lv.IsScalar() {
+		vec := proc.AllocScalarVector(rv.Typ)
+		rs := make([]float64, 1)
+		if _, err := typecast.Decimal64ToFloat64(lvs, lv.Typ.Scale, rs); err != nil {
+			return nil, err
+		}
+		nulls.Set(vec.Nsp, lv.Nsp)
+		vector.SetCol(vec, rs)
+		return vec, nil
+	}
+	vec, err := proc.AllocVector(rv.Typ, int64(len(lvs)*rtl))
+	if err != nil {
+		return nil, err
+	}
+	rs := encoding.DecodeFloat64Slice(vec.Data)
+	rs = rs[:len(lvs)]
+	if _, err := typecast.Decimal64ToFloat64(lvs, lv.Typ.Scale, rs); err != nil {
+		return nil, err
+	}
+	nulls.Set(vec.Nsp, lv.Nsp)
+	vector.SetCol(vec, rs)
+	return vec, nil
+}
+
+func CastDecimal128ToFloat64(lv, rv *vector.Vector, proc *process.Process) (*vector.Vector, error) {
+	rtl := 8
+	lvs := lv.Col.([]types.Decimal128)
+	if lv.IsScalar() {
+		vec := proc.AllocScalarVector(rv.Typ)
+		rs := make([]float64, 1)
+		if _, err := typecast.Decimal128ToFloat64(lvs, lv.Typ.Scale, rs); err != nil {
+			return nil, err
+		}
+		nulls.Set(vec.Nsp, lv.Nsp)
+		vector.SetCol(vec, rs)
+		return vec, nil
+	}
+	vec, err := proc.AllocVector(rv.Typ, int64(len(lvs)*rtl))
+	if err != nil {
+		return nil, err
+	}
+	rs := encoding.DecodeFloat64Slice(vec.Data)
+	rs = rs[:len(lvs)]
+	if _, err := typecast.Decimal128ToFloat64(lvs, lv.Typ.Scale, rs); err != nil {
+		return nil, err
+	}
+	nulls.Set(vec.Nsp, lv.Nsp)
+	vector.SetCol(vec, rs)
+	return vec, nil
+}
+
 //  isInteger return true if the types.T is integer type
 func isInteger(t types.T) bool {
 	if t == types.T_int8 || t == types.T_int16 || t == types.T_int32 || t == types.T_int64 ||
diff --git a/pkg/sql/plan2/function/operator/unaryops.go b/pkg/sql/plan2/function/operator/unaryops.go
index 5a57d0086..d175591b3 100644
--- a/pkg/sql/plan2/function/operator/unaryops.go
+++ b/pkg/sql/plan2/function/operator/unaryops.go
@@ -16,6 +16,7 @@ package operator
 
 import (
 	"github.com/matrixorigin/matrixone/pkg/container/nulls"
+	"github.com/matrixorigin/matrixone/pkg/container/types"
 	"github.com/matrixorigin/matrixone/pkg/container/vector"
 	"github.com/matrixorigin/matrixone/pkg/encoding"
 	"github.com/matrixorigin/matrixone/pkg/vectorize/neg"
@@ -48,3 +49,54 @@ func UnaryMinus[T constraints.Signed | constraints.Float](vectors []*vector.Vect
 		return resVector, nil
 	}
 }
+
+func UnaryMinusDecimal64(vectors []*vector.Vector, proc *process.Process) (*vector.Vector, error) {
+	srcVector := vectors[0]
+	srcValues := vector.MustTCols[types.Decimal64](srcVector)
+	resultElementSize := srcVector.Typ.Oid.TypeLen()
+
+	if srcVector.IsScalar() {
+		if srcVector.ConstVectorIsNull() {
+			return proc.AllocScalarNullVector(srcVector.Typ), nil
+		}
+		resVector := proc.AllocScalarVector(srcVector.Typ)
+		resValues := make([]types.Decimal64, 1)
+		nulls.Set(resVector.Nsp, srcVector.Nsp)
+		vector.SetCol(resVector, neg.Decimal64Neg(srcValues, resValues))
+		return resVector, nil
+	} else {
+		resVector, err := proc.AllocVector(srcVector.Typ, int64(resultElementSize*len(srcValues)))
+		if err != nil {
+			return nil, err
+		}
+		resValues := encoding.DecodeDecimal64Slice(resVector.Data)
+		nulls.Set(resVector.Nsp, srcVector.Nsp)
+		vector.SetCol(resVector, neg.Decimal64Neg(srcValues, resValues))
+		return resVector, nil
+	}
+}
+
+func UnaryMinusDecimal128(vectors []*vector.Vector, proc *process.Process) (*vector.Vector, error) {
+	srcVector := vectors[0]
+	srcValues := vector.MustTCols[types.Decimal128](srcVector)
+	resultElementSize := srcVector.Typ.Oid.TypeLen()
+
+	if srcVector.IsScalar() {
+		if srcVector.ConstVectorIsNull() {
+			return proc.AllocScalarNullVector(srcVector.Typ), nil
+		}
+		resVector := proc.AllocScalarVector(srcVector.Typ)
+		resValues := make([]types.Decimal128, 1)
+		vector.SetCol(resVector, neg.Decimal128Neg(srcValues, resValues))
+		return resVector, nil
+	} else {
+		resVector, err := proc.AllocVector(srcVector.Typ, int64(resultElementSize*len(srcValues)))
+		if err != nil {
+			return nil, err
+		}
+		resValues := encoding.DecodeDecimal128Slice(resVector.Data)
+		nulls.Set(resVector.Nsp, srcVector.Nsp)
+		vector.SetCol(resVector, neg.Decimal128Neg(srcValues, resValues))
+		return resVector, nil
+	}
+}
diff --git a/pkg/sql/plan2/function/operators.go b/pkg/sql/plan2/function/operators.go
index 071d15d41..166a3b78e 100644
--- a/pkg/sql/plan2/function/operators.go
+++ b/pkg/sql/plan2/function/operators.go
@@ -2267,7 +2267,7 @@ var operators = map[int][]Function{
 			Flag:        plan.Function_STRICT,
 			Layout:      BINARY_ARITHMETIC_OPERATOR,
 			Args:        []types.T{types.T_decimal64, types.T_decimal64},
-			ReturnTyp:   types.T_decimal64,
+			ReturnTyp:   types.T_decimal128,
 			TypeCheckFn: strictTypeCheck,
 			Fn:          operator.MultDecimal64,
 		},
@@ -2305,7 +2305,7 @@ var operators = map[int][]Function{
 			Flag:        plan.Function_STRICT,
 			Layout:      BINARY_ARITHMETIC_OPERATOR,
 			Args:        []types.T{types.T_decimal64, types.T_decimal64},
-			ReturnTyp:   types.T_decimal64,
+			ReturnTyp:   types.T_decimal128,
 			TypeCheckFn: strictTypeCheck,
 			Fn:          operator.DivDecimal64,
 		},
@@ -2314,7 +2314,7 @@ var operators = map[int][]Function{
 			Flag:        plan.Function_STRICT,
 			Layout:      BINARY_ARITHMETIC_OPERATOR,
 			Args:        []types.T{types.T_decimal128, types.T_decimal128},
-			ReturnTyp:   types.T_decimal64,
+			ReturnTyp:   types.T_decimal128,
 			TypeCheckFn: strictTypeCheck,
 			Fn:          operator.DivDecimal128,
 		},
@@ -2620,6 +2620,24 @@ var operators = map[int][]Function{
 			TypeCheckFn: strictTypeCheck,
 			Fn:          operator.UnaryMinus[float64],
 		},
+		{
+			Index:       6,
+			Flag:        plan.Function_STRICT,
+			Layout:      UNARY_ARITHMETIC_OPERATOR,
+			Args:        []types.T{types.T_decimal64},
+			ReturnTyp:   types.T_decimal64,
+			TypeCheckFn: strictTypeCheck,
+			Fn:          operator.UnaryMinusDecimal64,
+		},
+		{
+			Index:       7,
+			Flag:        plan.Function_STRICT,
+			Layout:      UNARY_ARITHMETIC_OPERATOR,
+			Args:        []types.T{types.T_decimal128},
+			ReturnTyp:   types.T_decimal128,
+			TypeCheckFn: strictTypeCheck,
+			Fn:          operator.UnaryMinusDecimal128,
+		},
 	},
 	// others
 	CAST: {
@@ -4378,6 +4396,44 @@ var operators = map[int][]Function{
 			TypeCheckFn: strictTypeCheck,
 			Fn:          operator.Cast,
 		},
+		{
+			Index:       195,
+			Flag:        plan.Function_STRICT,
+			Layout:      CAST_EXPRESSION,
+			Args:        []types.T{types.T_decimal64, types.T_float32},
+			ReturnTyp:   types.T_float32,
+			TypeCheckFn: strictTypeCheck,
+			Fn:          operator.Cast,
+		},
+
+		{
+			Index:       196,
+			Flag:        plan.Function_STRICT,
+			Layout:      CAST_EXPRESSION,
+			Args:        []types.T{types.T_decimal128, types.T_float32},
+			ReturnTyp:   types.T_float32,
+			TypeCheckFn: strictTypeCheck,
+			Fn:          operator.Cast,
+		},
+
+		{
+			Index:       197,
+			Flag:        plan.Function_STRICT,
+			Layout:      CAST_EXPRESSION,
+			Args:        []types.T{types.T_decimal64, types.T_float64},
+			ReturnTyp:   types.T_float64,
+			TypeCheckFn: strictTypeCheck,
+			Fn:          operator.Cast,
+		},
+		{
+			Index:       198,
+			Flag:        plan.Function_STRICT,
+			Layout:      CAST_EXPRESSION,
+			Args:        []types.T{types.T_decimal128, types.T_float64},
+			ReturnTyp:   types.T_float64,
+			TypeCheckFn: strictTypeCheck,
+			Fn:          operator.Cast,
+		},
 	},
 	CASE: {
 		{
diff --git a/pkg/sql/plan2/query_builder.go b/pkg/sql/plan2/query_builder.go
index 8677548e1..48183eb9a 100644
--- a/pkg/sql/plan2/query_builder.go
+++ b/pkg/sql/plan2/query_builder.go
@@ -1264,16 +1264,7 @@ func (builder *QueryBuilder) pushdownFilters(nodeId int32, filters []*plan.Expr)
 				}
 			}
 
-			if joinSides[i]&JoinSideRight != 0 && canTurnInner && node.JoinType == plan.Node_LEFT {
-				turnInner = true
-				filters = append(node.OnList, filters...)
-				node.JoinType = plan.Node_INNER
-				node.OnList = nil
-
-				break
-			}
-
-			if joinSides[i]&JoinSideLeft != 0 && canTurnInner && node.JoinType == plan.Node_RIGHT {
+			if joinSides[i]&JoinSideRight != 0 && canTurnInner && node.JoinType == plan.Node_LEFT && rejectsNull(filter) {
 				turnInner = true
 				filters = append(node.OnList, filters...)
 				node.JoinType = plan.Node_INNER
@@ -1318,22 +1309,19 @@ func (builder *QueryBuilder) pushdownFilters(nodeId int32, filters []*plan.Expr)
 				case plan.Node_LEFT, plan.Node_SEMI, plan.Node_ANTI:
 					leftPushdown = append(leftPushdown, filter)
 
-				case plan.Node_RIGHT:
-					rightPushdown = append(rightPushdown, filter)
-
 				default:
 					cantPushdown = append(cantPushdown, filter)
 				}
 
 			case JoinSideLeft:
-				if node.JoinType != plan.Node_RIGHT && node.JoinType != plan.Node_OUTER {
+				if node.JoinType != plan.Node_OUTER {
 					leftPushdown = append(leftPushdown, filter)
 				} else {
 					cantPushdown = append(cantPushdown, filter)
 				}
 
 			case JoinSideRight:
-				if node.JoinType == plan.Node_INNER || node.JoinType == plan.Node_RIGHT {
+				if node.JoinType == plan.Node_INNER {
 					rightPushdown = append(rightPushdown, filter)
 				} else {
 					cantPushdown = append(cantPushdown, filter)
diff --git a/pkg/sql/plan2/utils.go b/pkg/sql/plan2/utils.go
index 0ef5e588b..5f5f04f88 100644
--- a/pkg/sql/plan2/utils.go
+++ b/pkg/sql/plan2/utils.go
@@ -15,7 +15,11 @@
 package plan2
 
 import (
+	"github.com/matrixorigin/matrixone/pkg/container/batch"
+	"github.com/matrixorigin/matrixone/pkg/container/nulls"
+	"github.com/matrixorigin/matrixone/pkg/container/types"
 	"github.com/matrixorigin/matrixone/pkg/pb/plan"
+	colexec "github.com/matrixorigin/matrixone/pkg/sql/colexec2"
 	"github.com/matrixorigin/matrixone/pkg/sql/parsers/tree"
 )
 
@@ -46,23 +50,6 @@ func doGetBindings(expr *plan.Expr) map[int32]any {
 	return res
 }
 
-func hasSubquery(expr *plan.Expr) bool {
-	switch exprImpl := expr.Expr.(type) {
-	case *plan.Expr_Sub:
-		return true
-
-	case *plan.Expr_F:
-		ret := false
-		for _, arg := range exprImpl.F.Args {
-			ret = ret || hasSubquery(arg)
-		}
-		return ret
-
-	default:
-		return false
-	}
-}
-
 func hasCorrCol(expr *plan.Expr) bool {
 	switch exprImpl := expr.Expr.(type) {
 	case *plan.Expr_Corr:
@@ -404,3 +391,47 @@ func combinePlanConjunction(exprs []*plan.Expr) (expr *plan.Expr, err error) {
 
 	return
 }
+
+func rejectsNull(filter *plan.Expr) bool {
+	filter = replaceColRefWithNull(DeepCopyExpr(filter))
+
+	bat := batch.NewWithSize(0)
+	bat.Zs = []int64{1}
+	vec, err := colexec.EvalExpr(bat, nil, filter)
+	if err != nil {
+		return false
+	}
+
+	if nulls.Any(vec.Nsp) {
+		return true
+	}
+
+	switch vec.Typ.Oid {
+	case types.T_bool:
+		return !vec.Col.([]bool)[0]
+
+	default:
+		return false
+	}
+}
+
+func replaceColRefWithNull(expr *plan.Expr) *plan.Expr {
+	switch exprImpl := expr.Expr.(type) {
+	case *plan.Expr_Col:
+		expr = &plan.Expr{
+			Typ: expr.Typ,
+			Expr: &plan.Expr_C{
+				C: &plan.Const{
+					Isnull: true,
+				},
+			},
+		}
+
+	case *plan.Expr_F:
+		for i, arg := range exprImpl.F.Args {
+			exprImpl.F.Args[i] = replaceColRefWithNull(arg)
+		}
+	}
+
+	return expr
+}
diff --git a/pkg/vectorize/neg/neg.go b/pkg/vectorize/neg/neg.go
index cfcc8b702..7e2a92505 100644
--- a/pkg/vectorize/neg/neg.go
+++ b/pkg/vectorize/neg/neg.go
@@ -14,7 +14,10 @@
 
 package neg
 
-import "golang.org/x/exp/constraints"
+import (
+	"github.com/matrixorigin/matrixone/pkg/container/types"
+	"golang.org/x/exp/constraints"
+)
 
 var (
 	Int8Neg    = NumericNeg[int8]
@@ -31,3 +34,17 @@ func NumericNeg[T constraints.Signed | constraints.Float](xs, rs []T) []T {
 	}
 	return rs
 }
+
+func Decimal64Neg(xs, rs []types.Decimal64) []types.Decimal64 {
+	for i, x := range xs {
+		rs[i] = -x
+	}
+	return rs
+}
+
+func Decimal128Neg(xs, rs []types.Decimal128) []types.Decimal128 {
+	for i, x := range xs {
+		rs[i] = types.NegDecimal128(x)
+	}
+	return rs
+}
diff --git a/pkg/vectorize/typecast/typecast.go b/pkg/vectorize/typecast/typecast.go
index a2ff142f0..14d0ab89f 100644
--- a/pkg/vectorize/typecast/typecast.go
+++ b/pkg/vectorize/typecast/typecast.go
@@ -15,12 +15,12 @@
 package typecast
 
 import (
+	"github.com/matrixorigin/matrixone/pkg/common/moerr"
+	"github.com/matrixorigin/matrixone/pkg/vectorize/div"
 	"math"
 	"strconv"
 	"unsafe"
 
-	"github.com/matrixorigin/matrixone/pkg/vectorize/div"
-
 	"github.com/matrixorigin/matrixone/pkg/container/types"
 	"golang.org/x/exp/constraints"
 )
@@ -380,3 +380,51 @@ func Decimal128ToTimestamp(xs []types.Decimal128, precision int32, scale int32,
 	}
 	return rs, nil
 }
+
+func Decimal64ToFloat32(xs []types.Decimal64, scale int32, rs []float32) ([]float32, error) {
+	for i, x := range xs {
+		xStr := string(x.Decimal64ToString(scale))
+		result, err := strconv.ParseFloat(xStr, 32)
+		if err != nil {
+			return []float32{}, moerr.NewError(moerr.OUT_OF_RANGE, "cannot convert decimal to float correctly")
+		}
+		rs[i] = float32(result)
+	}
+	return rs, nil
+}
+
+func Decimal128ToFloat32(xs []types.Decimal128, scale int32, rs []float32) ([]float32, error) {
+	for i, x := range xs {
+		xStr := string(x.Decimal128ToString(scale))
+		result, err := strconv.ParseFloat(xStr, 64)
+		if err != nil {
+			return []float32{}, moerr.NewError(moerr.OUT_OF_RANGE, "cannot convert decimal to float correctly")
+		}
+		rs[i] = float32(result)
+	}
+	return rs, nil
+}
+
+func Decimal64ToFloat64(xs []types.Decimal64, scale int32, rs []float64) ([]float64, error) {
+	for i, x := range xs {
+		xStr := string(x.Decimal64ToString(scale))
+		result, err := strconv.ParseFloat(xStr, 64)
+		if err != nil {
+			return []float64{}, moerr.NewError(moerr.OUT_OF_RANGE, "cannot convert decimal to float correctly")
+		}
+		rs[i] = result
+	}
+	return rs, nil
+}
+
+func Decimal128ToFloat64(xs []types.Decimal128, scale int32, rs []float64) ([]float64, error) {
+	for i, x := range xs {
+		xStr := string(x.Decimal128ToString(scale))
+		result, err := strconv.ParseFloat(xStr, 64)
+		if err != nil {
+			return []float64{}, moerr.NewError(moerr.OUT_OF_RANGE, "cannot convert decimal to float correctly")
+		}
+		rs[i] = result
+	}
+	return rs, nil
+}
diff --git a/proto/hakeeper.proto b/proto/hakeeper.proto
index 50ee07d44..05fcf775c 100644
--- a/proto/hakeeper.proto
+++ b/proto/hakeeper.proto
@@ -25,9 +25,12 @@ option (gogoproto.goproto_enum_prefix_all) = false;
 
 // Replica of the shard
 message Replica {
-  uint64 ShardID   = 1;
-  uint64 ReplicaID = 2;
-  uint64 Epoch = 3;
+  // UUID which store the Replica is located in
+  string UUID      = 1;
+
+  uint64 ShardID   = 2;
+  uint64 ReplicaID = 3;
+  uint64 Epoch     = 4;
 }
 
 // ConfigChangeType indicates config change command type.
@@ -52,7 +55,9 @@ enum ServiceType {
 
 // ScheduleCommand contains a shard schedule command.
 message ScheduleCommand {
+  // UUID which store the ScheduleCommand is sent to
   string UUID               = 1;
+
   ConfigChange ConfigChange = 2 [(gogoproto.nullable) = false];
   ServiceType ServiceType   = 3;
 }
diff --git a/proto/plan.proto b/proto/plan.proto
index 7b8010ada..5f49b1203 100644
--- a/proto/plan.proto
+++ b/proto/plan.proto
@@ -516,6 +516,21 @@ message Plan {
 		Query query 			= 1;
 		TransationControl tcl 	= 2;
 		DataDefinition ddl 		= 3;
+		DataControl	dcl			= 4;
+	}
+}
+
+message DataControl {
+	enum DclType {
+		SET_VARIABLES	= 0;
+		GRANT			= 1;
+		REVOKE			= 2;
+		DENY			= 3;
+	}
+	//DataDefinition type
+	DclType dcl_type = 1;
+	oneof control {		
+		SetVariables set_variables = 2;
 	}
 }
 
@@ -621,3 +636,15 @@ message ShowVariables {
 	bool global 			= 1;
 	repeated Expr where 	= 2; 
 }
+
+message SetVariables {
+	repeated SetVariablesItem items	= 1; 
+}
+
+message SetVariablesItem {
+	bool system     = 1;
+	bool global     = 2;
+	string name     = 3;
+	Expr   value    = 4;
+	Expr   reserved = 5;
+}
\ No newline at end of file


Test patch:
diff --git a/pkg/compare/desc/decimal128s/compare_test.go b/pkg/compare/desc/decimal128s/compare_test.go
index a1197e3a3..b5966db50 100644
--- a/pkg/compare/desc/decimal128s/compare_test.go
+++ b/pkg/compare/desc/decimal128s/compare_test.go
@@ -1,3 +1,17 @@
+// Copyright 2021 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 decimal128s
 
 import (
diff --git a/pkg/compare/desc/decimal64s/compare_test.go b/pkg/compare/desc/decimal64s/compare_test.go
index 7b65308ba..420d241c7 100644
--- a/pkg/compare/desc/decimal64s/compare_test.go
+++ b/pkg/compare/desc/decimal64s/compare_test.go
@@ -1,3 +1,17 @@
+// Copyright 2021 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 decimal64s
 
 import (
diff --git a/pkg/hakeeper/checkers/coordinator_test.go b/pkg/hakeeper/checkers/coordinator_test.go
index b6ecd377c..2155a6222 100644
--- a/pkg/hakeeper/checkers/coordinator_test.go
+++ b/pkg/hakeeper/checkers/coordinator_test.go
@@ -141,9 +141,10 @@ func TestFixExpiredStore(t *testing.T) {
 			},
 			currentTick: 15 * hakeeper.TickPerSecond * 60,
 			expected: []hapb.ScheduleCommand{{
-				UUID: "a",
+				UUID: "b",
 				ConfigChange: hapb.ConfigChange{
 					Replica: hapb.Replica{
+						UUID:      "a",
 						ShardID:   1,
 						ReplicaID: 1,
 						Epoch:     0,
@@ -201,9 +202,10 @@ func TestFixExpiredStore(t *testing.T) {
 			},
 			currentTick: 15 * hakeeper.TickPerSecond * 60,
 			expected: []hapb.ScheduleCommand{{
-				UUID: "a",
+				UUID: "b",
 				ConfigChange: hapb.ConfigChange{
 					Replica: hapb.Replica{
+						UUID:      "a",
 						ShardID:   1,
 						ReplicaID: 4,
 						Epoch:     1,
@@ -260,18 +262,118 @@ func TestFixExpiredStore(t *testing.T) {
 				},
 			},
 			currentTick: 15 * hakeeper.TickPerSecond * 60,
-			expected: []hapb.ScheduleCommand{{
-				UUID: "a",
-				ConfigChange: hapb.ConfigChange{
-					Replica: hapb.Replica{
-						ShardID:   1,
-						ReplicaID: 1,
-						Epoch:     0,
+			expected: []hapb.ScheduleCommand{
+				{
+					UUID: "a",
+					ConfigChange: hapb.ConfigChange{
+						Replica: hapb.Replica{
+							UUID:      "a",
+							ShardID:   1,
+							ReplicaID: 1,
+						},
+						ChangeType: hapb.StartReplica,
 					},
-					ChangeType: hapb.StartReplica,
+					ServiceType: hapb.LogService,
 				},
-				ServiceType: hapb.LogService,
-			}},
+			},
+		},
+	}
+
+	for i, c := range cases {
+		coordinator := NewCoordinator()
+		output := coordinator.Check(c.idAlloc, c.cluster, c.dn, c.log, c.currentTick)
+		fmt.Printf("case %v: %s\n", i, c.desc)
+		assert.Equal(t, c.expected, output)
+	}
+}
+
+func TestFixZombie(t *testing.T) {
+	cases := []struct {
+		desc        string
+		idAlloc     *util.TestIDAllocator
+		cluster     hapb.ClusterInfo
+		dn          hapb.DNState
+		log         hapb.LogState
+		currentTick uint64
+		expected    []hapb.ScheduleCommand
+	}{
+		{
+			desc:    "replica on store c is a zombie",
+			idAlloc: util.NewTestIDAllocator(3),
+			cluster: hapb.ClusterInfo{
+				LogShards: []metadata.LogShardRecord{{
+					ShardID:          1,
+					NumberOfReplicas: 3,
+					Name:             "shard1",
+				}},
+			},
+			log: hapb.LogState{
+				Shards: map[uint64]pb.LogShardInfo{1: {
+					ShardID:  1,
+					Replicas: map[uint64]string{1: "a", 2: "b", 4: "d"},
+					Epoch:    2,
+					LeaderID: 1,
+				}},
+				Stores: map[string]hapb.LogStoreInfo{
+					"a": {
+						Tick: 12 * hakeeper.TickPerSecond * 60,
+						Replicas: []pb.LogReplicaInfo{{
+							LogShardInfo: pb.LogShardInfo{
+								ShardID:  1,
+								Replicas: map[uint64]string{1: "a", 2: "b", 4: "d"},
+								Epoch:    2,
+								LeaderID: 1},
+							ReplicaID: 1},
+						}},
+					"b": {
+						Tick: 13 * hakeeper.TickPerSecond * 60,
+						Replicas: []pb.LogReplicaInfo{{
+							LogShardInfo: pb.LogShardInfo{
+								ShardID:  1,
+								Replicas: map[uint64]string{1: "a", 2: "b", 4: "d"},
+								Epoch:    2,
+								LeaderID: 1},
+							ReplicaID: 2,
+						}},
+					},
+					"c": {
+						Tick: 14 * hakeeper.TickPerSecond * 60,
+						Replicas: []pb.LogReplicaInfo{{
+							LogShardInfo: pb.LogShardInfo{
+								ShardID:  1,
+								Replicas: map[uint64]string{1: "a", 2: "b", 3: "c"},
+								Epoch:    1,
+								LeaderID: 1},
+							ReplicaID: 3,
+						}},
+					},
+					"d": {
+						Tick: 14 * hakeeper.TickPerSecond * 60,
+						Replicas: []pb.LogReplicaInfo{{
+							LogShardInfo: pb.LogShardInfo{
+								ShardID:  1,
+								Replicas: map[uint64]string{1: "a", 2: "b", 4: "d"},
+								Epoch:    2,
+								LeaderID: 1},
+							ReplicaID: 3,
+						}},
+					},
+				},
+			},
+			currentTick: 15 * hakeeper.TickPerSecond * 60,
+			expected: []hapb.ScheduleCommand{
+				{
+					UUID: "c",
+					ConfigChange: hapb.ConfigChange{
+						Replica: hapb.Replica{
+							UUID:    "c",
+							ShardID: 1,
+						},
+						ChangeType: hapb.StopReplica,
+					},
+					ServiceType: hapb.LogService,
+				},
+			},
 		},
 	}
 
diff --git a/pkg/hakeeper/checkers/logservice/checker_test.go b/pkg/hakeeper/checkers/logservice/checker_test.go
index 92da7a8f8..dd37412c6 100644
--- a/pkg/hakeeper/checkers/logservice/checker_test.go
+++ b/pkg/hakeeper/checkers/logservice/checker_test.go
@@ -245,7 +245,9 @@ func TestCollectStats(t *testing.T) {
 				},
 			}, tick: 10,
 			expected: stats{toRemove: map[uint64][]replica{1: {{"a", 1, 0, 1}}},
-				toAdd: map[uint64]int{}}},
+				toAdd: map[uint64]int{},
+			},
+		},
 		{
 			desc: "Store a is expired",
 			infos: hapb.LogState{
@@ -281,9 +283,12 @@ func TestCollectStats(t *testing.T) {
 								Epoch:    1,
 								LeaderID: 0,
 								Term:     0}}}}},
-			}, tick: 999999999, expected: stats{
+			}, tick: 999999999,
+			expected: stats{
 				toRemove: map[uint64][]replica{1: {{"a", 1, 1, 1}}},
-				toAdd:    map[uint64]int{}}},
+				toAdd:    map[uint64]int{},
+			},
+		},
 	}
 
 	for i, c := range cases {
@@ -533,7 +538,8 @@ func TestCheck(t *testing.T) {
 			currentTick: uint64(15 * hakeeper.TickPerSecond * 60),
 			expected: []*operator.Operator{operator.NewOperator("rm peer: store [a]", 1,
 				1, operator.RemoveLogService{
-					UUID:      "a",
+					Target:    "b",
+					StoreID:   "a",
 					ShardID:   1,
 					ReplicaID: 1,
 				})},
@@ -585,7 +591,8 @@ func TestCheck(t *testing.T) {
 			currentTick: uint64(15 * hakeeper.TickPerSecond * 60),
 			expected: []*operator.Operator{operator.NewOperator("adding 1:4(at epoch 1) to c", 1,
 				1, operator.AddLogService{
-					UUID:      "c",
+					Target:    "a",
+					StoreID:   "c",
 					ShardID:   1,
 					ReplicaID: 4,
 					Epoch:     1,
@@ -638,7 +645,7 @@ func TestCheck(t *testing.T) {
 			currentTick: uint64(15 * hakeeper.TickPerSecond * 60),
 			expected: []*operator.Operator{operator.NewOperator("", 1,
 				1, operator.StartLogService{
-					UUID:      "c",
+					StoreID:   "c",
 					ShardID:   1,
 					ReplicaID: 3,
 				})},
diff --git a/pkg/hakeeper/operator/builder_test.go b/pkg/hakeeper/operator/builder_test.go
index 188f263aa..2118d7d97 100644
--- a/pkg/hakeeper/operator/builder_test.go
+++ b/pkg/hakeeper/operator/builder_test.go
@@ -56,7 +56,8 @@ func TestAddBuild(t *testing.T) {
 	assert.Equal(t, uint64(1), build.shardID)
 	assert.Equal(t, uint64(1), build.epoch)
 	assert.Equal(t, AddLogService{
-		UUID:      "d",
+		Target:    "a",
+		StoreID:   "d",
 		ShardID:   1,
 		ReplicaID: 4,
 		Epoch:     1,
@@ -81,7 +82,8 @@ func TestRemoveBuild(t *testing.T) {
 	assert.Equal(t, uint64(1), build.shardID)
 	assert.Equal(t, uint64(1), build.epoch)
 	assert.Equal(t, RemoveLogService{
-		UUID:      "c",
+		Target:    "a",
+		StoreID:   "c",
 		ShardID:   1,
 		ReplicaID: 3,
 	}, build.steps[0])
diff --git a/pkg/hakeeper/operator/operator_test.go b/pkg/hakeeper/operator/operator_test.go
index f0aa82c1b..e7521287c 100644
--- a/pkg/hakeeper/operator/operator_test.go
+++ b/pkg/hakeeper/operator/operator_test.go
@@ -40,8 +40,8 @@ func TestOperatorStep(t *testing.T) {
 
 	dnState := hakeeper.DNState{}
 
-	assert.False(t, AddLogService{UUID: "d", ShardID: 1, ReplicaID: 4}.IsFinish(logState, dnState))
-	assert.True(t, AddLogService{UUID: "c", ShardID: 1, ReplicaID: 3}.IsFinish(logState, dnState))
-	assert.False(t, RemoveLogService{UUID: "c", ShardID: 1, ReplicaID: 3}.IsFinish(logState, dnState))
-	assert.True(t, RemoveLogService{UUID: "d", ShardID: 1, ReplicaID: 4}.IsFinish(logState, dnState))
+	assert.False(t, AddLogService{StoreID: "d", ShardID: 1, ReplicaID: 4}.IsFinish(logState, dnState))
+	assert.True(t, AddLogService{StoreID: "c", ShardID: 1, ReplicaID: 3}.IsFinish(logState, dnState))
+	assert.False(t, RemoveLogService{StoreID: "c", ShardID: 1, ReplicaID: 3}.IsFinish(logState, dnState))
+	assert.True(t, RemoveLogService{StoreID: "d", ShardID: 1, ReplicaID: 4}.IsFinish(logState, dnState))
 }
diff --git a/pkg/hakeeper/operator/steps_test.go b/pkg/hakeeper/operator/steps_test.go
index 922f1f34d..7b6435909 100644
--- a/pkg/hakeeper/operator/steps_test.go
+++ b/pkg/hakeeper/operator/steps_test.go
@@ -18,7 +18,7 @@ func TestAddLogService(t *testing.T) {
 		{
 			desc: "add log service completed",
 			command: AddLogService{
-				UUID:      "a",
+				StoreID:   "a",
 				ShardID:   1,
 				ReplicaID: 1,
 			},
@@ -32,7 +32,7 @@ func TestAddLogService(t *testing.T) {
 		{
 			desc: "add log service not completed",
 			command: AddLogService{
-				UUID:      "a",
+				StoreID:   "a",
 				ShardID:   1,
 				ReplicaID: 1,
 			},
@@ -61,7 +61,7 @@ func TestRemoveLogService(t *testing.T) {
 		{
 			desc: "remove log service not completed",
 			command: RemoveLogService{
-				UUID:      "a",
+				StoreID:   "a",
 				ShardID:   1,
 				ReplicaID: 1,
 			},
@@ -75,7 +75,7 @@ func TestRemoveLogService(t *testing.T) {
 		{
 			desc: "remove log service completed",
 			command: RemoveLogService{
-				UUID:      "a",
+				StoreID:   "a",
 				ShardID:   1,
 				ReplicaID: 1,
 			},
@@ -104,7 +104,7 @@ func TestStartLogService(t *testing.T) {
 		{
 			desc: "start log service not completed",
 			command: StartLogService{
-				UUID:      "a",
+				StoreID:   "a",
 				ShardID:   1,
 				ReplicaID: 1,
 			},
@@ -118,7 +118,7 @@ func TestStartLogService(t *testing.T) {
 		{
 			desc: "start log service completed",
 			command: StartLogService{
-				UUID:      "a",
+				StoreID:   "a",
 				ShardID:   1,
 				ReplicaID: 1,
 			},
@@ -153,7 +153,7 @@ func TestStopLogService(t *testing.T) {
 		{
 			desc: "stop log service completed",
 			command: StopLogService{
-				UUID:    "a",
+				StoreID: "a",
 				ShardID: 1,
 			},
 			state: hapb.LogState{
@@ -166,7 +166,7 @@ func TestStopLogService(t *testing.T) {
 		{
 			desc: "stop log service not completed",
 			command: StopLogService{
-				UUID:    "a",
+				StoreID: "a",
 				ShardID: 1,
 			},
 			state: hapb.LogState{
diff --git a/pkg/logservice/client_test.go b/pkg/logservice/client_test.go
index 69f7ac9e1..8fc8e2465 100644
--- a/pkg/logservice/client_test.go
+++ b/pkg/logservice/client_test.go
@@ -42,7 +42,7 @@ func runClientTest(t *testing.T,
 
 	init := make(map[uint64]string)
 	init[2] = service.ID()
-	assert.NoError(t, service.store.StartReplica(1, 2, init))
+	assert.NoError(t, service.store.StartReplica(1, 2, init, false))
 
 	scfg := LogServiceClientConfig{
 		ReadOnly:         readOnly,
diff --git a/pkg/logservice/commands_test.go b/pkg/logservice/commands_test.go
new file mode 100644
index 000000000..1020b7d69
--- /dev/null
+++ b/pkg/logservice/commands_test.go
@@ -0,0 +1,94 @@
+// Copyright 2021 - 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 logservice
+
+import (
+	"testing"
+
+	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
+
+	hapb "github.com/matrixorigin/matrixone/pkg/pb/hakeeper"
+)
+
+func TestHandleStartReplica(t *testing.T) {
+	fn := func(t *testing.T, s *Service) {
+		cmd := hapb.ScheduleCommand{
+			ConfigChange: hapb.ConfigChange{
+				ChangeType: hapb.StartReplica,
+				Replica: hapb.Replica{
+					ShardID:   1,
+					ReplicaID: 1,
+				},
+			},
+		}
+		s.handleCommands([]hapb.ScheduleCommand{cmd})
+		mustHaveReplica(t, s.store, 1, 1)
+	}
+	runServiceTest(t, fn)
+}
+
+func TestHandleStopReplica(t *testing.T) {
+	fn := func(t *testing.T, s *Service) {
+		cmd := hapb.ScheduleCommand{
+			ConfigChange: hapb.ConfigChange{
+				ChangeType: hapb.StartReplica,
+				Replica: hapb.Replica{
+					ShardID:   1,
+					ReplicaID: 1,
+				},
+			},
+		}
+		s.handleCommands([]hapb.ScheduleCommand{cmd})
+		mustHaveReplica(t, s.store, 1, 1)
+
+		cmd = hapb.ScheduleCommand{
+			ConfigChange: hapb.ConfigChange{
+				ChangeType: hapb.StopReplica,
+				Replica: hapb.Replica{
+					ShardID:   1,
+					ReplicaID: 1,
+				},
+			},
+		}
+		s.handleCommands([]hapb.ScheduleCommand{cmd})
+		assert.False(t, hasReplica(s.store, 1, 1))
+	}
+	runServiceTest(t, fn)
+}
+
+func TestHandleRemoveReplica(t *testing.T) {
+	store1, store2, err := getTestStores()
+	require.NoError(t, err)
+	defer func() {
+		require.NoError(t, store1.Close())
+		require.NoError(t, store2.Close())
+	}()
+
+	service1 := Service{
+		store: store1,
+	}
+	cmd := hapb.ScheduleCommand{
+		ConfigChange: hapb.ConfigChange{
+			ChangeType: hapb.RemoveReplica,
+			Replica: hapb.Replica{
+				ShardID:   1,
+				ReplicaID: 2,
+			},
+		},
+	}
+	// TODO: add some checks
+	service1.handleCommands([]hapb.ScheduleCommand{cmd})
+}
diff --git a/pkg/logservice/service_test.go b/pkg/logservice/service_test.go
index 7a27ec3a2..8e0a41547 100644
--- a/pkg/logservice/service_test.go
+++ b/pkg/logservice/service_test.go
@@ -50,7 +50,7 @@ func runServiceTest(t *testing.T, fn func(*testing.T, *Service)) {
 	require.NoError(t, err)
 	peers := make(map[uint64]dragonboat.Target)
 	peers[1] = service.ID()
-	require.NoError(t, service.store.StartReplica(1, 1, peers))
+	require.NoError(t, service.store.StartReplica(1, 1, peers, false))
 	defer func() {
 		assert.NoError(t, service.Close())
 	}()
@@ -302,7 +302,7 @@ func TestShardInfoCanBeQueried(t *testing.T) {
 	}()
 	peers1 := make(map[uint64]dragonboat.Target)
 	peers1[1] = service1.ID()
-	assert.NoError(t, service1.store.StartReplica(1, 1, peers1))
+	assert.NoError(t, service1.store.StartReplica(1, 1, peers1, false))
 
 	service2, err := NewService(cfg2)
 	require.NoError(t, err)
@@ -311,7 +311,7 @@ func TestShardInfoCanBeQueried(t *testing.T) {
 	}()
 	peers2 := make(map[uint64]dragonboat.Target)
 	peers2[1] = service2.ID()
-	assert.NoError(t, service2.store.StartReplica(2, 1, peers2))
+	assert.NoError(t, service2.store.StartReplica(2, 1, peers2, false))
 
 	nhID1 := service1.ID()
 	nhID2 := service2.ID()
diff --git a/pkg/logservice/store_test.go b/pkg/logservice/store_test.go
index b0dcc0b6d..ff52c5bc9 100644
--- a/pkg/logservice/store_test.go
+++ b/pkg/logservice/store_test.go
@@ -21,11 +21,14 @@ import (
 	"time"
 
 	"github.com/cockroachdb/errors"
+	"github.com/google/uuid"
 	"github.com/lni/dragonboat/v4"
 	"github.com/lni/goutils/leaktest"
 	"github.com/lni/vfs"
 	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
 
+	"github.com/matrixorigin/matrixone/pkg/hakeeper"
 	pb "github.com/matrixorigin/matrixone/pkg/pb/logservice"
 )
 
@@ -72,14 +75,14 @@ func TestStoreCanBeCreatedAndClosed(t *testing.T) {
 	}()
 }
 
-func getTestStore(cfg Config) (*logStore, error) {
+func getTestStore(cfg Config) (*store, error) {
 	store, err := newLogStore(cfg)
 	if err != nil {
 		return nil, err
 	}
 	peers := make(map[uint64]dragonboat.Target)
 	peers[2] = store.nh.ID()
-	if err := store.StartReplica(1, 2, peers); err != nil {
+	if err := store.StartReplica(1, 2, peers, false); err != nil {
 		store.Close()
 		return nil, err
 	}
@@ -94,10 +97,11 @@ func TestHAKeeperCanBeStarted(t *testing.T) {
 	assert.NoError(t, err)
 	peers := make(map[uint64]dragonboat.Target)
 	peers[2] = store.nh.ID()
-	assert.NoError(t, store.StartHAKeeperReplica(2, peers))
+	assert.NoError(t, store.StartHAKeeperReplica(2, peers, false))
 	defer func() {
 		assert.NoError(t, store.Close())
 	}()
+	mustHaveReplica(t, store, hakeeper.DefaultHAKeeperShardID, 2)
 }
 
 func TestStateMachineCanBeStarted(t *testing.T) {
@@ -109,9 +113,24 @@ func TestStateMachineCanBeStarted(t *testing.T) {
 	defer func() {
 		assert.NoError(t, store.Close())
 	}()
+	mustHaveReplica(t, store, 1, 2)
 }
 
-func runStoreTest(t *testing.T, fn func(*testing.T, *logStore)) {
+func TestReplicaCanBeStopped(t *testing.T) {
+	defer leaktest.AfterTest(t)()
+	cfg := getStoreTestConfig()
+	defer vfs.ReportLeakedFD(cfg.FS, t)
+	store, err := getTestStore(cfg)
+	assert.NoError(t, err)
+	defer func() {
+		assert.NoError(t, store.Close())
+	}()
+	mustHaveReplica(t, store, 1, 2)
+	store.stopReplica(1, 2)
+	assert.False(t, hasReplica(store, 1, 2))
+}
+
+func runStoreTest(t *testing.T, fn func(*testing.T, *store)) {
 	defer leaktest.AfterTest(t)()
 	cfg := getStoreTestConfig()
 	defer vfs.ReportLeakedFD(cfg.FS, t)
@@ -132,7 +151,7 @@ func getTestUserEntry() []byte {
 }
 
 func TestGetOrExtendLease(t *testing.T) {
-	fn := func(t *testing.T, store *logStore) {
+	fn := func(t *testing.T, store *store) {
 		ctx, cancel := context.WithTimeout(context.Background(), testIOTimeout)
 		defer cancel()
 		assert.NoError(t, store.GetOrExtendDNLease(ctx, 1, 100))
@@ -141,7 +160,7 @@ func TestGetOrExtendLease(t *testing.T) {
 }
 
 func TestAppendLog(t *testing.T) {
-	fn := func(t *testing.T, store *logStore) {
+	fn := func(t *testing.T, store *store) {
 		ctx, cancel := context.WithTimeout(context.Background(), testIOTimeout)
 		defer cancel()
 		assert.NoError(t, store.GetOrExtendDNLease(ctx, 1, 100))
@@ -154,7 +173,7 @@ func TestAppendLog(t *testing.T) {
 }
 
 func TestAppendLogIsRejectedForMismatchedLeaseHolderID(t *testing.T) {
-	fn := func(t *testing.T, store *logStore) {
+	fn := func(t *testing.T, store *store) {
 		ctx, cancel := context.WithTimeout(context.Background(), testIOTimeout)
 		defer cancel()
 		assert.NoError(t, store.GetOrExtendDNLease(ctx, 1, 100))
@@ -169,7 +188,7 @@ func TestAppendLogIsRejectedForMismatchedLeaseHolderID(t *testing.T) {
 }
 
 func TestTruncateLog(t *testing.T) {
-	fn := func(t *testing.T, store *logStore) {
+	fn := func(t *testing.T, store *store) {
 		ctx, cancel := context.WithTimeout(context.Background(), testIOTimeout)
 		defer cancel()
 		assert.NoError(t, store.GetOrExtendDNLease(ctx, 1, 100))
@@ -184,7 +203,7 @@ func TestTruncateLog(t *testing.T) {
 }
 
 func TestGetTruncatedIndex(t *testing.T) {
-	fn := func(t *testing.T, store *logStore) {
+	fn := func(t *testing.T, store *store) {
 		ctx, cancel := context.WithTimeout(context.Background(), testIOTimeout)
 		defer cancel()
 		index, err := store.GetTruncatedIndex(ctx, 1)
@@ -203,7 +222,7 @@ func TestGetTruncatedIndex(t *testing.T) {
 }
 
 func TestQueryLog(t *testing.T) {
-	fn := func(t *testing.T, store *logStore) {
+	fn := func(t *testing.T, store *store) {
 		ctx, cancel := context.WithTimeout(context.Background(), testIOTimeout)
 		defer cancel()
 		assert.NoError(t, store.GetOrExtendDNLease(ctx, 1, 100))
@@ -240,21 +259,21 @@ func TestQueryLog(t *testing.T) {
 }
 
 func TestHAKeeperTick(t *testing.T) {
-	fn := func(t *testing.T, store *logStore) {
+	fn := func(t *testing.T, store *store) {
 		peers := make(map[uint64]dragonboat.Target)
 		peers[1] = store.ID()
-		assert.NoError(t, store.StartHAKeeperReplica(1, peers))
+		assert.NoError(t, store.StartHAKeeperReplica(1, peers, false))
 		store.hakeeperTick()
 	}
 	runStoreTest(t, fn)
 }
 
 func TestGetHeartbeatMessage(t *testing.T) {
-	fn := func(t *testing.T, store *logStore) {
+	fn := func(t *testing.T, store *store) {
 		peers := make(map[uint64]dragonboat.Target)
 		peers[1] = store.ID()
-		assert.NoError(t, store.StartReplica(10, 1, peers))
-		assert.NoError(t, store.StartHAKeeperReplica(1, peers))
+		assert.NoError(t, store.StartReplica(10, 1, peers, false))
+		assert.NoError(t, store.StartHAKeeperReplica(1, peers, false))
 
 		m := store.getHeartbeatMessage()
 		// hakeeper shard is included
@@ -264,10 +283,10 @@ func TestGetHeartbeatMessage(t *testing.T) {
 }
 
 func TestAddHeartbeat(t *testing.T) {
-	fn := func(t *testing.T, store *logStore) {
+	fn := func(t *testing.T, store *store) {
 		peers := make(map[uint64]dragonboat.Target)
 		peers[1] = store.ID()
-		assert.NoError(t, store.StartHAKeeperReplica(1, peers))
+		assert.NoError(t, store.StartHAKeeperReplica(1, peers, false))
 
 		m := store.getHeartbeatMessage()
 		ctx, cancel := context.WithTimeout(context.Background(), time.Second)
@@ -283,3 +302,137 @@ func TestAddHeartbeat(t *testing.T) {
 	}
 	runStoreTest(t, fn)
 }
+
+func TestAddReplicaRejectedForInvalidCCI(t *testing.T) {
+	fn := func(t *testing.T, store *store) {
+		err := store.addReplica(1, 100, uuid.New().String(), 0)
+		assert.Equal(t, dragonboat.ErrRejected, err)
+	}
+	runStoreTest(t, fn)
+}
+
+func TestAddReplica(t *testing.T) {
+	fn := func(t *testing.T, store *store) {
+		for {
+			_, _, ok, err := store.nh.GetLeaderID(1)
+			require.NoError(t, err)
+			if ok {
+				break
+			}
+			time.Sleep(time.Millisecond)
+		}
+		ctx, cancel := context.WithTimeout(context.Background(), time.Second)
+		defer cancel()
+		m, err := store.nh.SyncGetShardMembership(ctx, 1)
+		require.NoError(t, err)
+		err = store.addReplica(1, 100, uuid.New().String(), m.ConfigChangeID)
+		assert.NoError(t, err)
+		hb := store.getHeartbeatMessage()
+		assert.Equal(t, 2, len(hb.Replicas[0].Replicas))
+	}
+	runStoreTest(t, fn)
+}
+
+func getTestStores() (*store, *store, error) {
+	cfg1 := Config{
+		FS:                  vfs.NewStrictMem(),
+		DeploymentID:        1,
+		RTTMillisecond:      5,
+		DataDir:             "data-1",
+		ServiceAddress:      "127.0.0.1:9001",
+		RaftAddress:         "127.0.0.1:9002",
+		GossipAddress:       "127.0.0.1:9011",
+		GossipSeedAddresses: []string{"127.0.0.1:9011", "127.0.0.1:9012"},
+	}
+	cfg1.Fill()
+	store1, err := newLogStore(cfg1)
+	if err != nil {
+		return nil, nil, err
+	}
+	cfg2 := Config{
+		FS:                  vfs.NewStrictMem(),
+		DeploymentID:        1,
+		RTTMillisecond:      5,
+		DataDir:             "data-1",
+		ServiceAddress:      "127.0.0.1:9006",
+		RaftAddress:         "127.0.0.1:9007",
+		GossipAddress:       "127.0.0.1:9012",
+		GossipSeedAddresses: []string{"127.0.0.1:9011", "127.0.0.1:9012"},
+	}
+	cfg2.Fill()
+	store2, err := newLogStore(cfg2)
+	if err != nil {
+		return nil, nil, err
+	}
+
+	peers1 := make(map[uint64]dragonboat.Target)
+	peers1[1] = store1.nh.ID()
+	peers1[2] = store2.nh.ID()
+	if err := store1.StartReplica(1, 1, peers1, false); err != nil {
+		return nil, nil, err
+	}
+	peers2 := make(map[uint64]dragonboat.Target)
+	peers2[1] = store1.nh.ID()
+	peers2[2] = store2.nh.ID()
+	if err := store2.StartReplica(1, 2, peers2, false); err != nil {
+		return nil, nil, err
+	}
+
+	for {
+		_, _, ok, err := store1.nh.GetLeaderID(1)
+		if err != nil {
+			return nil, nil, err
+		}
+		if ok {
+			break
+		}
+		time.Sleep(time.Millisecond)
+	}
+	return store1, store2, nil
+}
+
+func TestRemoveReplica(t *testing.T) {
+	store1, store2, err := getTestStores()
+	require.NoError(t, err)
+	defer func() {
+		require.NoError(t, store1.Close())
+		require.NoError(t, store2.Close())
+	}()
+	ctx, cancel := context.WithTimeout(context.Background(), time.Second)
+	defer cancel()
+	for {
+		m, err := store1.nh.SyncGetShardMembership(ctx, 1)
+		if err == dragonboat.ErrShardNotReady {
+			time.Sleep(time.Millisecond)
+			continue
+		}
+		require.NoError(t, err)
+		require.NoError(t, store1.removeReplica(1, 2, m.ConfigChangeID))
+		return
+	}
+}
+
+func hasReplica(s *store, shardID uint64, replicaID uint64) bool {
+	hb := s.getHeartbeatMessage()
+	for _, info := range hb.Replicas {
+		if info.ShardID == shardID {
+			for r := range info.Replicas {
+				if r == replicaID {
+					return true
+				}
+			}
+		}
+	}
+	return false
+}
+
+func mustHaveReplica(t *testing.T,
+	s *store, shardID uint64, replicaID uint64) {
+	for i := 0; i < 100; i++ {
+		if hasReplica(s, shardID, replicaID) {
+			return
+		}
+		time.Sleep(10 * time.Millisecond)
+	}
+	t.Fatalf("failed to locate the replica")
+}
diff --git a/pkg/sql/plan2/build_test.go b/pkg/sql/plan2/build_test.go
index 412276f9f..005c3893e 100644
--- a/pkg/sql/plan2/build_test.go
+++ b/pkg/sql/plan2/build_test.go
@@ -419,6 +419,8 @@ func TestSingleTableSqlBuilder(t *testing.T) {
 		"select n_name from nation where n_name != @str_var and n_regionkey > @int_var",
 		"select n_name from nation where n_name != @@global.str_var and n_regionkey > @@session.int_var",
 		"select distinct(n_name), ((abs(n_regionkey))) from nation",
+		"SET @var = abs(-1), @@session.string_var = 'aaa'",
+		"SET NAMES 'utf8mb4' COLLATE 'utf8mb4_general_ci'",
 	}
 	runTestShouldPass(mock, t, sqls, false, false)
 
@@ -432,6 +434,8 @@ func TestSingleTableSqlBuilder(t *testing.T) {
 		"SELECT NATION.N_NAME FROM NATION a",                                // mysql should error, but i don't think it is necesssary
 		"select n_nationkey, sum(n_nationkey) from nation",
 		"select n_name from nation where n_name != @not_exist_var",
+		"SET @var = abs(a)", // can't use column
+		"SET @var = avg(2)", // can't use agg function
 
 		"SELECT DISTINCT N_NAME FROM NATION GROUP BY N_REGIONKEY", //test distinct with group by
 	}
diff --git a/pkg/sql/plan2/function/operator/unaryops_test.go b/pkg/sql/plan2/function/operator/unaryops_test.go
new file mode 100644
index 000000000..5a8cc1871
--- /dev/null
+++ b/pkg/sql/plan2/function/operator/unaryops_test.go
@@ -0,0 +1,43 @@
+// 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 operator
+
+import (
+	"github.com/matrixorigin/matrixone/pkg/container/types"
+	"github.com/matrixorigin/matrixone/pkg/container/vector"
+	"github.com/matrixorigin/matrixone/pkg/sql/testutil"
+	"github.com/stretchr/testify/require"
+	"testing"
+)
+
+func TestUnaryMinusDecimal64(t *testing.T) {
+	input := testutil.MakeDecimal64Vector([]int64{123, 234, 345, 0}, []uint64{3})
+	testProc := testutil.NewProc()
+	output, err := UnaryMinusDecimal64([]*vector.Vector{input}, testProc)
+	require.NoError(t, err)
+	outputCol := vector.MustTCols2[types.Decimal64](output)
+
+	require.Equal(t, []types.Decimal64{-123, -234, -345, 0}, outputCol)
+}
+
+func TestUnaryMinusDecimal128(t *testing.T) {
+	input := testutil.MakeDecimal128Vector([]uint64{123, 234, 345, 0}, []uint64{3})
+	testProc := testutil.NewProc()
+	output, err := UnaryMinusDecimal128([]*vector.Vector{input}, testProc)
+	require.NoError(t, err)
+	outputCol := vector.MustTCols[types.Decimal128](output)
+
+	require.Equal(t, []types.Decimal128{{Lo: -123, Hi: -1}, {Lo: -234, Hi: -1}, {Lo: -345, Hi: -1}, {Lo: 0, Hi: 0}}, outputCol)
+}
diff --git a/pkg/sql/testutil/testutil.go b/pkg/sql/testutil/testutil.go
index c51269de9..85825d92c 100644
--- a/pkg/sql/testutil/testutil.go
+++ b/pkg/sql/testutil/testutil.go
@@ -235,7 +235,7 @@ func MakeDecimal64Vector(values []int64, nsp []uint64) *vector.Vector {
 	for _, n := range nsp {
 		nulls.Add(vec.Nsp, n)
 	}
-	vec.Col = (*types.Decimal64)(unsafe.Pointer(&values))
+	vec.Col = *(*[]types.Decimal64)(unsafe.Pointer(&values))
 	return vec
 }
 
diff --git a/pkg/vectorize/neg/neg_test.go b/pkg/vectorize/neg/neg_test.go
index 3df5c6ec4..4543ba01f 100644
--- a/pkg/vectorize/neg/neg_test.go
+++ b/pkg/vectorize/neg/neg_test.go
@@ -16,6 +16,8 @@ package neg
 
 import (
 	"fmt"
+	"github.com/matrixorigin/matrixone/pkg/container/types"
+	"github.com/stretchr/testify/require"
 	"testing"
 )
 
@@ -48,3 +50,32 @@ func TestI64Sum(t *testing.T) {
 	fmt.Printf("int neg: %v\n", Int64Neg(xs, rs))
 	fmt.Printf("pure int neg: %v\n", NumericNeg(xs, rs))
 }
+
+func TestDecimal64Neg(t *testing.T) {
+	xs := []types.Decimal64{123, 234, 345, 0, -234}
+	rs := make([]types.Decimal64, len(xs))
+	rs = Decimal64Neg(xs, rs)
+	expectedResult := []types.Decimal64{-123, -234, -345, 0, 234}
+	require.Equal(t, expectedResult, rs)
+}
+
+func TestDecimal128Neg(t *testing.T) {
+	xs := make([]types.Decimal128, 5)
+	xs[0], _ = types.ParseStringToDecimal128("123456.789", 20, 5)
+	xs[1], _ = types.ParseStringToDecimal128("120000.789", 20, 5)
+	xs[2], _ = types.ParseStringToDecimal128("-123456.789", 20, 5)
+	xs[3], _ = types.ParseStringToDecimal128("0", 20, 5)
+	xs[4], _ = types.ParseStringToDecimal128("-123", 20, 5)
+	rs := make([]types.Decimal128, 5)
+	rs = Decimal128Neg(xs, rs)
+
+	require.Equal(t, "-123456.78900", string(rs[0].Decimal128ToString(5)))
+
+	require.Equal(t, "-120000.78900", string(rs[1].Decimal128ToString(5)))
+
+	require.Equal(t, "123456.78900", string(rs[2].Decimal128ToString(5)))
+
+	require.Equal(t, "0", string(rs[3].Decimal128ToString(5)))
+
+	require.Equal(t, "123.00000", string(rs[4].Decimal128ToString(5)))
+}