Repository: matrixorigin/matrixone
Pull request #3099 (2022-06-18 05:26:24)

Modify msg of err and can update to null
**What type of PR is this?**

- [ ] API-change
- [ ] BUG
- [ ] Improvement
- [ ] Documentation
- [ ] Feature
- [ ] Test and CI
- [ ] Code Refactoring

**Which issue(s) this PR fixes:**

issue #

**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



Patch:
diff --git a/go.mod b/go.mod
index 252f2a518..2eada0103 100644
--- a/go.mod
+++ b/go.mod
@@ -160,7 +160,7 @@ require (
 	google.golang.org/appengine v1.6.7 // indirect
 	google.golang.org/genproto v0.0.0-20211208223120-3a66f561d7aa // indirect
 	google.golang.org/grpc v1.43.0 // indirect
-	google.golang.org/protobuf v1.27.1 // indirect
+	google.golang.org/protobuf v1.28.0 // indirect
 	gopkg.in/check.v1 v1.0.0-20200227125254-8fa46927fb4f // indirect
 	gopkg.in/yaml.v2 v2.4.0 // indirect
 	gopkg.in/yaml.v3 v3.0.0-20210107192922-496545a6307b // indirect
diff --git a/go.sum b/go.sum
index 2c7777a76..86170f397 100644
--- a/go.sum
+++ b/go.sum
@@ -1221,8 +1221,9 @@ google.golang.org/protobuf v1.24.0/go.mod h1:r/3tXBNzIEhYS9I1OUVjXDlt8tc493IdKGj
 google.golang.org/protobuf v1.25.0/go.mod h1:9JNX74DMeImyA3h4bdi1ymwjUzf21/xIlbajtzgsN7c=
 google.golang.org/protobuf v1.26.0-rc.1/go.mod h1:jlhhOSvTdKEhbULTjvd4ARK9grFBp09yW+WbY/TyQbw=
 google.golang.org/protobuf v1.26.0/go.mod h1:9q0QmTI4eRPtz6boOQmLYwt+qCgq0jsYwAQnmE0givc=
-google.golang.org/protobuf v1.27.1 h1:SnqbnDw1V7RiZcXPx5MEeqPv2s79L9i7BJUlG/+RurQ=
 google.golang.org/protobuf v1.27.1/go.mod h1:9q0QmTI4eRPtz6boOQmLYwt+qCgq0jsYwAQnmE0givc=
+google.golang.org/protobuf v1.28.0 h1:w43yiav+6bVFTBQFZX0r7ipe9JQ1QsbMgHwbBziscLw=
+google.golang.org/protobuf v1.28.0/go.mod h1:HV8QOd/L58Z+nl8r43ehVNZIU/HEI6OcFqwMG9pJV4I=
 gopkg.in/alecthomas/kingpin.v2 v2.2.6/go.mod h1:FMv+mEhP44yOT+4EoQTLFTRgOQ1FBLkstjWtayDeSgw=
 gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0=
 gopkg.in/check.v1 v1.0.0-20180628173108-788fd7840127/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0=
diff --git a/pkg/container/ring/anyvalue/anyvalue.go b/pkg/container/ring/anyvalue/anyvalue.go
index 4f24bd222..d8a00ad27 100644
--- a/pkg/container/ring/anyvalue/anyvalue.go
+++ b/pkg/container/ring/anyvalue/anyvalue.go
@@ -176,6 +176,8 @@ func DecodeAnyRing2(data []byte) (*AnyVRing2, []byte, error) {
 
 func NewAnyValueRingWithTypeCheck(typ types.Type) (ring.Ring, error) {
 	switch typ.Oid {
+	case types.T_bool:
+		return &AnyVRing1[bool]{Typ: typ}, nil
 	case types.T_uint8:
 		return &AnyVRing1[uint8]{Typ: typ}, nil
 	case types.T_uint16:
@@ -205,7 +207,7 @@ func NewAnyValueRingWithTypeCheck(typ types.Type) (ring.Ring, error) {
 	case types.T_decimal128:
 		return &AnyVRing1[types.Decimal128]{Typ: typ}, nil
 	}
-	return nil, errors.New(errno.FeatureNotSupported, fmt.Sprintf("'%v' not support Any_Value", typ.Oid))
+	return nil, errors.New(errno.FeatureNotSupported, fmt.Sprintf("Any_Value do not support '%v'", typ.Oid))
 }
 
 // shouldSet returns true means we should assign the value
diff --git a/pkg/container/ring/avg/decimal.go b/pkg/container/ring/avg/decimal.go
index ead3dc243..b2f7bd738 100644
--- a/pkg/container/ring/avg/decimal.go
+++ b/pkg/container/ring/avg/decimal.go
@@ -103,6 +103,7 @@ func (r *DecimalRing) Grow(m *mheap.Mheap) error {
 		r.Vs = encoding.DecodeDecimal128Slice(data)
 	}
 	r.Vs = r.Vs[:n+1]
+	r.Da = r.Da[:(n+1)*Decimal128Size]
 	r.Vs[n] = types.InitDecimal128(0)
 	r.Ns = append(r.Ns, 0)
 	return nil
@@ -111,7 +112,7 @@ func (r *DecimalRing) Grow(m *mheap.Mheap) error {
 func (r *DecimalRing) Grows(size int, m *mheap.Mheap) error {
 	n := len(r.Vs)
 	if n == 0 {
-		data, err := mheap.Alloc(m, int64(size*8))
+		data, err := mheap.Alloc(m, int64(size*Decimal128Size))
 		if err != nil {
 			return err
 		}
@@ -129,6 +130,7 @@ func (r *DecimalRing) Grows(size int, m *mheap.Mheap) error {
 		r.Vs = encoding.DecodeDecimal128Slice(data)
 	}
 	r.Vs = r.Vs[:n+size]
+	r.Da = r.Da[:(n+size)*Decimal128Size]
 	for i := 0; i < size; i++ {
 		r.Ns = append(r.Ns, 0)
 	}
diff --git a/pkg/container/vector/vector.go b/pkg/container/vector/vector.go
index 12f34c52e..0f33cfbd5 100644
--- a/pkg/container/vector/vector.go
+++ b/pkg/container/vector/vector.go
@@ -121,6 +121,16 @@ func (v *Vector) ConstExpand(m *mheap.Mheap) *Vector {
 	if !v.IsConst {
 		return v
 	}
+	if v.IsScalarNull() {
+		var i uint64
+		l := uint64(v.Length)
+		temp := make([]uint64, v.Length)
+		for i = 0; i < l; i++ {
+			temp[i] = i
+		}
+		nulls.Add(v.Nsp, temp...)
+		return v
+	}
 	switch v.Typ.Oid {
 	case types.T_bool:
 		expandVector[bool](v, 1, m)
@@ -518,7 +528,7 @@ func PreAlloc(v, w *Vector, rows int, m *mheap.Mheap) {
 }
 
 func Length(v *Vector) int {
-	if v.IsScalar() {
+	if v.IsScalar() || v.Typ.Oid == types.T_any {
 		return v.Length
 	}
 	switch v.Typ.Oid {
@@ -537,7 +547,7 @@ func setLengthFixed[T any](v *Vector, n int) {
 }
 
 func SetLength(v *Vector, n int) {
-	if v.IsScalar() {
+	if v.IsScalar() || v.Typ.Oid == types.T_any {
 		v.Length = n
 		return
 	}
diff --git a/pkg/frontend/insert.go b/pkg/frontend/insert.go
index ce45c9647..59b25ce13 100644
--- a/pkg/frontend/insert.go
+++ b/pkg/frontend/insert.go
@@ -158,7 +158,7 @@ func buildInsertValues(stmt *tree.Insert, plan *InsertValues, eg engine.Engine,
 				for j, row := range rows.Rows {
 					v, err := buildConstant(vec.Typ, row[i])
 					if err != nil {
-						return err
+						return fmt.Errorf("Data truncation: %s for column '%s' at row %v", err.Error(), bat.Attrs[i], j)
 					}
 					if v == nil {
 						nulls.Add(vec.Nsp, uint64(j))
@@ -180,7 +180,7 @@ func buildInsertValues(stmt *tree.Insert, plan *InsertValues, eg engine.Engine,
 				for j, row := range rows.Rows {
 					v, err := buildConstant(vec.Typ, row[i])
 					if err != nil {
-						return err
+						return fmt.Errorf("Data truncation: %s for column '%s' at row %v", err.Error(), bat.Attrs[i], j)
 					}
 					if v == nil {
 						nulls.Add(vec.Nsp, uint64(j))
@@ -202,7 +202,7 @@ func buildInsertValues(stmt *tree.Insert, plan *InsertValues, eg engine.Engine,
 				for j, row := range rows.Rows {
 					v, err := buildConstant(vec.Typ, row[i])
 					if err != nil {
-						return err
+						return fmt.Errorf("Data truncation: %s for column '%s' at row %v", err.Error(), bat.Attrs[i], j)
 					}
 					if v == nil {
 						nulls.Add(vec.Nsp, uint64(j))
@@ -224,7 +224,7 @@ func buildInsertValues(stmt *tree.Insert, plan *InsertValues, eg engine.Engine,
 				for j, row := range rows.Rows {
 					v, err := buildConstant(vec.Typ, row[i])
 					if err != nil {
-						return err
+						return fmt.Errorf("Data truncation: %s for column '%s' at row %v", err.Error(), bat.Attrs[i], j)
 					}
 					if v == nil {
 						nulls.Add(vec.Nsp, uint64(j))
@@ -246,7 +246,7 @@ func buildInsertValues(stmt *tree.Insert, plan *InsertValues, eg engine.Engine,
 				for j, row := range rows.Rows {
 					v, err := buildConstant(vec.Typ, row[i])
 					if err != nil {
-						return err
+						return fmt.Errorf("Data truncation: %s for column '%s' at row %v", err.Error(), bat.Attrs[i], j)
 					}
 					if v == nil {
 						nulls.Add(vec.Nsp, uint64(j))
@@ -268,7 +268,7 @@ func buildInsertValues(stmt *tree.Insert, plan *InsertValues, eg engine.Engine,
 				for j, row := range rows.Rows {
 					v, err := buildConstant(vec.Typ, row[i])
 					if err != nil {
-						return err
+						return fmt.Errorf("Data truncation: %s for column '%s' at row %v", err.Error(), bat.Attrs[i], j)
 					}
 					if v == nil {
 						nulls.Add(vec.Nsp, uint64(j))
@@ -290,7 +290,7 @@ func buildInsertValues(stmt *tree.Insert, plan *InsertValues, eg engine.Engine,
 				for j, row := range rows.Rows {
 					v, err := buildConstant(vec.Typ, row[i])
 					if err != nil {
-						return err
+						return fmt.Errorf("Data truncation: %s for column '%s' at row %v", err.Error(), bat.Attrs[i], j)
 					}
 					if v == nil {
 						nulls.Add(vec.Nsp, uint64(j))
@@ -312,7 +312,7 @@ func buildInsertValues(stmt *tree.Insert, plan *InsertValues, eg engine.Engine,
 				for j, row := range rows.Rows {
 					v, err := buildConstant(vec.Typ, row[i])
 					if err != nil {
-						return err
+						return fmt.Errorf("Data truncation: %s for column '%s' at row %v", err.Error(), bat.Attrs[i], j)
 					}
 					if v == nil {
 						nulls.Add(vec.Nsp, uint64(j))
@@ -334,7 +334,7 @@ func buildInsertValues(stmt *tree.Insert, plan *InsertValues, eg engine.Engine,
 				for j, row := range rows.Rows {
 					v, err := buildConstant(vec.Typ, row[i])
 					if err != nil {
-						return err
+						return fmt.Errorf("Data truncation: %s for column '%s' at row %v", err.Error(), bat.Attrs[i], j)
 					}
 					if v == nil {
 						nulls.Add(vec.Nsp, uint64(j))
@@ -356,7 +356,7 @@ func buildInsertValues(stmt *tree.Insert, plan *InsertValues, eg engine.Engine,
 				for j, row := range rows.Rows {
 					v, err := buildConstant(vec.Typ, row[i])
 					if err != nil {
-						return err
+						return fmt.Errorf("Data truncation: %s for column '%s' at row %v", err.Error(), bat.Attrs[i], j)
 					}
 					if v == nil {
 						nulls.Add(vec.Nsp, uint64(j))
@@ -378,7 +378,7 @@ func buildInsertValues(stmt *tree.Insert, plan *InsertValues, eg engine.Engine,
 				for j, row := range rows.Rows {
 					v, err := buildConstant(vec.Typ, row[i])
 					if err != nil {
-						return err
+						return fmt.Errorf("Data truncation: %s for column '%s' at row %v", err.Error(), bat.Attrs[i], j)
 					}
 					if v == nil {
 						nulls.Add(vec.Nsp, uint64(j))
@@ -400,7 +400,7 @@ func buildInsertValues(stmt *tree.Insert, plan *InsertValues, eg engine.Engine,
 				for j, row := range rows.Rows {
 					v, err := buildConstant(vec.Typ, row[i])
 					if err != nil {
-						return err
+						return fmt.Errorf("Data truncation: %s for column '%s' at row %v", err.Error(), bat.Attrs[i], j)
 					}
 					if v == nil {
 						nulls.Add(vec.Nsp, uint64(j))
@@ -422,7 +422,7 @@ func buildInsertValues(stmt *tree.Insert, plan *InsertValues, eg engine.Engine,
 				for j, row := range rows.Rows {
 					v, err := buildConstant(vec.Typ, row[i])
 					if err != nil {
-						return err
+						return fmt.Errorf("Data truncation: %s for column '%s' at row %v", err.Error(), bat.Attrs[i], j)
 					}
 					if v == nil {
 						nulls.Add(vec.Nsp, uint64(j))
@@ -444,7 +444,7 @@ func buildInsertValues(stmt *tree.Insert, plan *InsertValues, eg engine.Engine,
 				for j, row := range rows.Rows {
 					v, err := buildConstant(vec.Typ, row[i])
 					if err != nil {
-						return err
+						return fmt.Errorf("Data truncation: %s for column '%s' at row %v", err.Error(), bat.Attrs[i], j)
 					}
 					if v == nil {
 						nulls.Add(vec.Nsp, uint64(j))
@@ -466,7 +466,7 @@ func buildInsertValues(stmt *tree.Insert, plan *InsertValues, eg engine.Engine,
 				for j, row := range rows.Rows {
 					v, err := buildConstant(vec.Typ, row[i])
 					if err != nil {
-						return err
+						return fmt.Errorf("Data truncation: %s for column '%s' at row %v", err.Error(), bat.Attrs[i], j)
 					}
 					if v == nil {
 						nulls.Add(vec.Nsp, uint64(j))
@@ -488,7 +488,7 @@ func buildInsertValues(stmt *tree.Insert, plan *InsertValues, eg engine.Engine,
 				for j, row := range rows.Rows {
 					v, err := buildConstant(vec.Typ, row[i])
 					if err != nil {
-						return err
+						return fmt.Errorf("Data truncation: %s for column '%s' at row %v", err.Error(), bat.Attrs[i], j)
 					}
 					if v == nil {
 						nulls.Add(vec.Nsp, uint64(j))
@@ -510,7 +510,7 @@ func buildInsertValues(stmt *tree.Insert, plan *InsertValues, eg engine.Engine,
 				for j, row := range rows.Rows {
 					v, err := buildConstant(vec.Typ, row[i])
 					if err != nil {
-						return err
+						return fmt.Errorf("Data truncation: %s for column '%s' at row %v", err.Error(), bat.Attrs[i], j)
 					}
 					if v == nil {
 						nulls.Add(vec.Nsp, uint64(j))
@@ -527,7 +527,7 @@ func buildInsertValues(stmt *tree.Insert, plan *InsertValues, eg engine.Engine,
 				return err
 			}
 		default:
-			return errors.New(errno.DatatypeMismatch, fmt.Sprintf("insert for type '%v' not implement now", vec.Typ))
+			return fmt.Errorf("Data truncation: type of '%v' does not implement now", vec.Typ)
 		}
 	}
 	// insert Null for other columns
@@ -738,7 +738,7 @@ func rewriteInsertRows(noInsertTarget bool, finalInsertTargets []string, relatio
 				}
 				if useOrder {
 					if orderDefault[j] == nil {
-						return nil, nil, errors.New(errno.InvalidColumnDefinition, fmt.Sprintf("Field '%s' doesn't have a default value", finalInsertTargets[j]))
+						return nil, nil, fmt.Errorf("Field '%s' doesn't have a default value", finalInsertTargets[j])
 					}
 					rows[i][j] = *orderDefault[j]
 				}
@@ -750,7 +750,7 @@ func rewriteInsertRows(noInsertTarget bool, finalInsertTargets []string, relatio
 				}
 				rows[i][j], ok = defaultExprs[finalInsertTargets[j]]
 				if !ok {
-					return nil, nil, errors.New(errno.InvalidColumnDefinition, fmt.Sprintf("Field '%s' doesn't have a default value", finalInsertTargets[j]))
+					return nil, nil, fmt.Errorf("Field '%s' doesn't have a default value", finalInsertTargets[j])
 				}
 			}
 		}
@@ -950,10 +950,10 @@ func buildConstant(typ types.Type, n tree.Expr) (interface{}, error) {
 		case types.T_float64:
 			return floatResult, nil
 		default:
-			return nil, errors.New(errno.DatatypeMismatch, fmt.Sprintf("unexpected return type '%v' for binary expression '%v'", typ, floatResult))
+			return nil, fmt.Errorf("unexpected return type '%v' for binary expression '%v'", typ, floatResult)
 		}
 	}
-	return nil, errors.New(errno.SyntaxErrororAccessRuleViolation, fmt.Sprintf("'%v' is not support now", n))
+	return nil, fmt.Errorf("Function expression in INSERT statement value list will be supported in future version.")
 }
 
 func buildConstantValue(typ types.Type, num *tree.NumVal) (interface{}, error) {
@@ -968,7 +968,11 @@ func buildConstantValue(typ types.Type, num *tree.NumVal) (interface{}, error) {
 	case constant.Int:
 		switch typ.Oid {
 		case types.T_bool:
-			return types.ParseValueToBool(num)
+			res, err := types.ParseValueToBool(num)
+			if err != nil {
+				return nil, fmt.Errorf("Incorrect %s value: '%s'", typ.Oid.String(), str)
+			}
+			return res, nil
 		case types.T_int8, types.T_int16, types.T_int32, types.T_int64:
 			if num.Negative() {
 				v, _ := constant.Uint64Val(val)
@@ -984,9 +988,17 @@ func buildConstantValue(typ types.Type, num *tree.NumVal) (interface{}, error) {
 				return int64(v), nil
 			}
 		case types.T_decimal64:
-			return types.ParseStringToDecimal64(str, typ.Width, typ.Scale)
+			res, err := types.ParseStringToDecimal64(str, typ.Width, typ.Scale)
+			if err != nil {
+				return nil, fmt.Errorf("Incorrect %s value: '%s'", typ.Oid.String(), str)
+			}
+			return res, nil
 		case types.T_decimal128:
-			return types.ParseStringToDecimal128(str, typ.Width, typ.Scale)
+			res, err := types.ParseStringToDecimal128(str, typ.Width, typ.Scale)
+			if err != nil {
+				return nil, fmt.Errorf("Incorrect %s value: '%s'", typ.Oid.String(), str)
+			}
+			return res, nil
 		case types.T_uint8, types.T_uint16, types.T_uint32, types.T_uint64:
 			v, _ := constant.Uint64Val(val)
 			if num.Negative() {
@@ -1008,8 +1020,13 @@ func buildConstantValue(typ types.Type, num *tree.NumVal) (interface{}, error) {
 			}
 			return float64(v), nil
 		case types.T_timestamp:
-			return types.ParseTimestamp(str, typ.Precision)
+			res, err := types.ParseTimestamp(constant.StringVal(val), typ.Precision)
+			if err != nil {
+				return nil, fmt.Errorf("Incorrect %s value: '%s'", typ.Oid.String(), str)
+			}
+			return res, nil
 		}
+		return nil, fmt.Errorf("Incorrect %s value: '%s'", typ.Oid.String(), str)
 	case constant.Float:
 		switch typ.Oid {
 		case types.T_int64, types.T_int32, types.T_int16, types.T_int8:
@@ -1067,10 +1084,19 @@ func buildConstantValue(typ types.Type, num *tree.NumVal) (interface{}, error) {
 			}
 			return float64(v), nil
 		case types.T_decimal64:
-			return types.ParseStringToDecimal64(str, typ.Width, typ.Scale)
+			res, err := types.ParseStringToDecimal64(str, typ.Width, typ.Scale)
+			if err != nil {
+				return nil, fmt.Errorf("Incorrect %s value: '%s'", typ.Oid.String(), str)
+			}
+			return res, nil
 		case types.T_decimal128:
-			return types.ParseStringToDecimal128(str, typ.Width, typ.Scale)
+			res, err := types.ParseStringToDecimal128(str, typ.Width, typ.Scale)
+			if err != nil {
+				return nil, fmt.Errorf("Incorrect %s value: '%s'", typ.Oid.String(), str)
+			}
+			return res, nil
 		}
+		return nil, fmt.Errorf("Incorrect %s value: '%s'", typ.Oid.String(), str)
 	case constant.String:
 		switch typ.Oid {
 		case types.T_bool:
@@ -1080,53 +1106,106 @@ func buildConstantValue(typ types.Type, num *tree.NumVal) (interface{}, error) {
 			case "true":
 				return true, nil
 			}
+			return nil, fmt.Errorf("Incorrect boolean value: '%s'", str)
 		case types.T_int8:
-			return strconv.ParseInt(str, 10, 8)
+			res, err := strconv.ParseInt(str, 10, 8)
+			if err != nil {
+				return nil, fmt.Errorf("Incorrect %s value: '%s'", typ.Oid.String(), str)
+			}
+			return res, nil
 		case types.T_int16:
-			return strconv.ParseInt(str, 10, 16)
+			res, err := strconv.ParseInt(str, 10, 16)
+			if err != nil {
+				return nil, fmt.Errorf("Incorrect %s value: '%s'", typ.Oid.String(), str)
+			}
+			return res, nil
 		case types.T_int32:
-			return strconv.ParseInt(str, 10, 32)
+			res, err := strconv.ParseInt(str, 10, 32)
+			if err != nil {
+				return nil, fmt.Errorf("Incorrect %s value: '%s'", typ.Oid.String(), str)
+			}
+			return res, nil
 		case types.T_int64:
-			return strconv.ParseInt(str, 10, 64)
+			res, err := strconv.ParseInt(str, 10, 64)
+			if err != nil {
+				return nil, fmt.Errorf("Incorrect %s value: '%s'", typ.Oid.String(), str)
+			}
+			return res, nil
 		case types.T_uint8:
-			return strconv.ParseUint(str, 10, 8)
+			res, err := strconv.ParseUint(str, 10, 8)
+			if err != nil {
+				return nil, fmt.Errorf("Incorrect %s value: '%s'", typ.Oid.String(), str)
+			}
+			return res, nil
 		case types.T_uint16:
-			return strconv.ParseUint(str, 10, 16)
+			res, err := strconv.ParseUint(str, 10, 16)
+			if err != nil {
+				return nil, fmt.Errorf("Incorrect %s value: '%s'", typ.Oid.String(), str)
+			}
+			return res, nil
 		case types.T_uint32:
-			return strconv.ParseUint(str, 10, 32)
+			res, err := strconv.ParseUint(str, 10, 32)
+			if err != nil {
+				return nil, fmt.Errorf("Incorrect %s value: '%s'", typ.Oid.String(), str)
+			}
+			return res, nil
 		case types.T_uint64:
-			return strconv.ParseUint(str, 10, 64)
+			res, err := strconv.ParseUint(str, 10, 64)
+			if err != nil {
+				return nil, fmt.Errorf("Incorrect %s value: '%s'", typ.Oid.String(), str)
+			}
+			return res, nil
 		case types.T_float32:
-			val, err := strconv.ParseFloat(str, 32)
+			res, err := strconv.ParseFloat(str, 32)
 			if err != nil {
-				return nil, err
+				return nil, fmt.Errorf("Incorrect %s value: '%s'", typ.Oid.String(), str)
 			}
-			return float32(val), nil
+			return float32(res), nil
 		case types.T_float64:
-			val, err := strconv.ParseFloat(str, 64)
+			res, err := strconv.ParseFloat(str, 64)
 			if err != nil {
-				return nil, err
+				return nil, fmt.Errorf("Incorrect %s value: '%s'", typ.Oid.String(), str)
 			}
-			return val, nil
+			return res, nil
 		case types.T_decimal64:
-			return types.ParseStringToDecimal64(str, typ.Width, typ.Scale)
+			res, err := types.ParseStringToDecimal64(str, typ.Width, typ.Scale)
+			if err != nil {
+				return nil, fmt.Errorf("Incorrect %s value: '%s'", typ.Oid.String(), str)
+			}
+			return res, nil
 		case types.T_decimal128:
-			return types.ParseStringToDecimal128(str, typ.Width, typ.Scale)
+			res, err := types.ParseStringToDecimal128(str, typ.Width, typ.Scale)
+			if err != nil {
+				return nil, fmt.Errorf("Incorrect %s value: '%s'", typ.Oid.String(), str)
+			}
+			return res, nil
 		}
 		if !num.Negative() {
 			switch typ.Oid {
 			case types.T_char, types.T_varchar:
-				return constant.StringVal(val), nil
+				return str, nil
 			case types.T_date:
-				return types.ParseDate(constant.StringVal(val))
+				res, err := types.ParseDate(constant.StringVal(val))
+				if err != nil {
+					return nil, fmt.Errorf("Incorrect %s value: '%s'", typ.Oid.String(), str)
+				}
+				return res, nil
 			case types.T_datetime:
-				return types.ParseDatetime(constant.StringVal(val), typ.Precision)
+				res, err := types.ParseDatetime(constant.StringVal(val), typ.Precision)
+				if err != nil {
+					return nil, fmt.Errorf("Incorrect %s value: '%s'", typ.Oid.String(), str)
+				}
+				return res, nil
 			case types.T_timestamp:
-				return types.ParseTimestamp(constant.StringVal(val), typ.Precision)
+				res, err := types.ParseTimestamp(constant.StringVal(val), typ.Precision)
+				if err != nil {
+					return nil, fmt.Errorf("Incorrect %s value: '%s'", typ.Oid.String(), str)
+				}
+				return res, nil
 			}
 		}
 	}
-	return nil, errors.New(errno.IndeterminateDatatype, fmt.Sprintf("unsupport value: %v", val))
+	return nil, fmt.Errorf("doesn't support value's form: '%v'", str)
 }
 
 // rangeCheck do range check for value, and do type conversion.
diff --git a/pkg/frontend/mysql_cmd_executor.go b/pkg/frontend/mysql_cmd_executor.go
index ea44dc2d8..b40534f01 100644
--- a/pkg/frontend/mysql_cmd_executor.go
+++ b/pkg/frontend/mysql_cmd_executor.go
@@ -1774,8 +1774,7 @@ func (mce *MysqlCmdExecutor) doComQuery(sql string) (retErr error) {
 		ses.Pu.StorageEngine,
 		proc, ses, usePlan2)
 	if err != nil {
-		return NewMysqlError(ER_PARSE_ERROR, err,
-			"You have an error in your SQL syntax; check the manual that corresponds to your MatrixOne server version for the right syntax to use")
+		return NewMysqlError(ER_PARSE_ERROR, err, "")
 	}
 
 	defer func() {
diff --git a/pkg/frontend/session.go b/pkg/frontend/session.go
index 8894b51d2..73659a07e 100644
--- a/pkg/frontend/session.go
+++ b/pkg/frontend/session.go
@@ -661,6 +661,7 @@ func (tcc *TxnCompilerContext) Resolve(dbName string, tableName string) (*plan2.
 					Precision: attr.Attr.Type.Precision,
 				},
 				Primary: attr.Attr.Primary,
+				Default: plan2.MakePlan2DefaultExpr(attr.Attr.Default),
 			})
 		}
 	}
diff --git a/pkg/hakeeper/rsm.go b/pkg/hakeeper/rsm.go
index 3230a61a6..4268043e2 100644
--- a/pkg/hakeeper/rsm.go
+++ b/pkg/hakeeper/rsm.go
@@ -44,8 +44,7 @@ const (
 	// DefaultHAKeeperShardID is the shard ID assigned to the special HAKeeper
 	// shard.
 	DefaultHAKeeperShardID uint64 = 0
-
-	headerSize = 2
+	headerSize                    = 2
 )
 
 const (
@@ -72,12 +71,13 @@ type stateMachine struct {
 	replicaID        uint64
 	term             uint64
 	scheduleCommands map[string][]hapb.ScheduleCommand // keyed by UUID
-	Tick             uint64
-	NextID           uint64
-	LogShards        map[string]uint64 // keyed by Log Shard name
-	DNState          DNState
-	LogState         LogState
-	ClusterInfo      ClusterInfo
+
+	Tick        uint64
+	NextID      uint64
+	LogShards   map[string]uint64 // keyed by Log Shard name
+	DNState     DNState
+	LogState    LogState
+	ClusterInfo ClusterInfo
 }
 
 func parseCmdTag(cmd []byte) uint16 {
@@ -207,7 +207,7 @@ func (s *stateMachine) assignID() uint64 {
 	return s.NextID
 }
 
-func (s *stateMachine) handleUpdateCommandsCmd(cmd []byte) (sm.Result, error) {
+func (s *stateMachine) handleUpdateCommandsCmd(cmd []byte) sm.Result {
 	data := cmd[headerSize:]
 	var b hapb.CommandBatch
 	if err := b.Unmarshal(data); err != nil {
@@ -215,7 +215,7 @@ func (s *stateMachine) handleUpdateCommandsCmd(cmd []byte) (sm.Result, error) {
 	}
 	plog.Infof("incoming term: %d, rsm term: %d", b.Term, s.term)
 	if s.term > b.Term {
-		return sm.Result{}, nil
+		return sm.Result{}
 	}
 
 	s.term = b.Term
@@ -229,10 +229,10 @@ func (s *stateMachine) handleUpdateCommandsCmd(cmd []byte) (sm.Result, error) {
 		s.scheduleCommands[c.UUID] = l
 	}
 
-	return sm.Result{}, nil
+	return sm.Result{}
 }
 
-func (s *stateMachine) handleCreateLogShardCmd(cmd []byte) (sm.Result, error) {
+func (s *stateMachine) handleCreateLogShardCmd(cmd []byte) sm.Result {
 	name, ok := isCreateLogShardCmd(cmd)
 	if !ok {
 		panic(moerr.NewError(moerr.INVALID_INPUT, "not create log shard cmd"))
@@ -240,84 +240,86 @@ func (s *stateMachine) handleCreateLogShardCmd(cmd []byte) (sm.Result, error) {
 	if shardID, ok := s.LogShards[name]; ok {
 		data := make([]byte, 8)
 		binaryEnc.PutUint64(data, shardID)
-		return sm.Result{Value: 0, Data: data}, nil
+		return sm.Result{Value: 0, Data: data}
 	}
 	s.LogShards[name] = s.assignID()
-	return sm.Result{Value: s.NextID}, nil
+	return sm.Result{Value: s.NextID}
 }
 
-func (s *stateMachine) handleDNHeartbeat(cmd []byte) (sm.Result, error) {
+func (s *stateMachine) handleDNHeartbeat(cmd []byte) sm.Result {
 	data := parseHeartbeatCmd(cmd)
 	var hb pb.DNStoreHeartbeat
 	if err := hb.Unmarshal(data); err != nil {
 		panic(err)
 	}
 	s.DNState.Update(hb, s.Tick)
-	return sm.Result{}, nil
+	return sm.Result{}
 }
 
-func (s *stateMachine) handleLogHeartbeat(cmd []byte) (sm.Result, error) {
+func (s *stateMachine) handleLogHeartbeat(cmd []byte) sm.Result {
 	data := parseHeartbeatCmd(cmd)
 	var hb pb.LogStoreHeartbeat
 	if err := hb.Unmarshal(data); err != nil {
 		panic(err)
 	}
 	s.LogState.Update(hb, s.Tick)
-	return sm.Result{}, nil
+	return sm.Result{}
 }
 
-func (s *stateMachine) handleTick(cmd []byte) (sm.Result, error) {
+func (s *stateMachine) handleTick(cmd []byte) sm.Result {
 	s.Tick++
-	return sm.Result{}, nil
+	return sm.Result{}
 }
 
-func (s *stateMachine) handleGetIDCmd(cmd []byte) (sm.Result, error) {
+func (s *stateMachine) handleGetIDCmd(cmd []byte) sm.Result {
 	count := parseGetIDCmd(cmd)
 	s.NextID++
 	v := s.NextID
 	s.NextID += (count - 1)
-	plog.Infof("get id returned [%d, %d)", v, v+count)
-	return sm.Result{Value: v}, nil
+	return sm.Result{Value: v}
 }
 
 func (s *stateMachine) Update(e sm.Entry) (sm.Result, error) {
 	cmd := e.Cmd
 	if _, ok := isCreateLogShardCmd(cmd); ok {
-		return s.handleCreateLogShardCmd(cmd)
+		return s.handleCreateLogShardCmd(cmd), nil
 	} else if isDNHeartbeatCmd(cmd) {
-		return s.handleDNHeartbeat(cmd)
+		return s.handleDNHeartbeat(cmd), nil
 	} else if isLogHeartbeatCmd(cmd) {
-		return s.handleLogHeartbeat(cmd)
+		return s.handleLogHeartbeat(cmd), nil
 	} else if isTickCmd(cmd) {
-		return s.handleTick(cmd)
+		return s.handleTick(cmd), nil
 	} else if isGetIDCmd(cmd) {
-		return s.handleGetIDCmd(cmd)
+		return s.handleGetIDCmd(cmd), nil
 	} else if isUpdateCommandsCmd(cmd) {
-		return s.handleUpdateCommandsCmd(cmd)
+		return s.handleUpdateCommandsCmd(cmd), nil
 	}
 	panic(moerr.NewError(moerr.INVALID_INPUT, "unexpected haKeeper cmd"))
 }
 
-func (s *stateMachine) handleStateQuery() (interface{}, error) {
+func (s *stateMachine) handleStateQuery() interface{} {
 	// FIXME: pretty sure we need to deepcopy here
 	return &HAKeeperState{
 		Tick:        s.Tick,
 		ClusterInfo: s.ClusterInfo,
 		DNState:     s.DNState,
 		LogState:    s.LogState,
-	}, nil
+	}
+}
+
+func (s *stateMachine) handleShardIDQuery(name string) *logShardIDQueryResult {
+	id, ok := s.LogShards[name]
+	if ok {
+		return &logShardIDQueryResult{found: true, id: id}
+	}
+	return &logShardIDQueryResult{found: false}
 }
 
 func (s *stateMachine) Lookup(query interface{}) (interface{}, error) {
 	if q, ok := query.(*logShardIDQuery); ok {
-		id, ok := s.LogShards[q.name]
-		if ok {
-			return &logShardIDQueryResult{found: true, id: id}, nil
-		}
-		return &logShardIDQueryResult{found: false}, nil
-	}
-	if _, ok := query.(*StateQuery); ok {
-		return s.handleStateQuery()
+		return s.handleShardIDQuery(q.name), nil
+	} else if _, ok := query.(*StateQuery); ok {
+		return s.handleStateQuery(), nil
 	}
 	panic("unknown query type")
 }
diff --git a/pkg/logservice/rsm.go b/pkg/logservice/rsm.go
index 753c9b080..bb2bc0c83 100644
--- a/pkg/logservice/rsm.go
+++ b/pkg/logservice/rsm.go
@@ -37,9 +37,11 @@ const (
 	indexTag
 )
 
-type leaseHistoryQuery struct {
-	index uint64
-}
+// used to indicate query types
+type leaseHolderIDQuery struct{}
+type indexQuery struct{}
+type truncatedIndexQuery struct{}
+type leaseHistoryQuery struct{ index uint64 }
 
 func getAppendCmd(cmd []byte, replicaID uint64) []byte {
 	if len(cmd) < headerSize+8 {
@@ -109,8 +111,6 @@ type stateMachine struct {
 
 var _ (sm.IStateMachine) = (*stateMachine)(nil)
 
-// making this a IConcurrentStateMachine for now, IStateMachine need to be updated
-// to provide raft entry index to its Update() method
 func newStateMachine(shardID uint64, replicaID uint64) sm.IStateMachine {
 	return &stateMachine{
 		shardID:      shardID,
@@ -119,14 +119,6 @@ func newStateMachine(shardID uint64, replicaID uint64) sm.IStateMachine {
 	}
 }
 
-func (s *stateMachine) setLeaseHolderID(index uint64, cmd []byte) {
-	if !isSetLeaseHolderUpdate(cmd) {
-		panic("not a setLeaseHolder update")
-	}
-	s.LeaseHolderID = parseLeaseHolderID(cmd)
-	s.LeaseHistory[index] = s.LeaseHolderID
-}
-
 func (s *stateMachine) truncateLeaseHistory(index uint64) {
 	_, index = s.getLeaseHistory(index)
 	for key := range s.LeaseHistory {
@@ -151,32 +143,32 @@ func (s *stateMachine) getLeaseHistory(index uint64) (uint64, uint64) {
 	return lease, max
 }
 
-func (s *stateMachine) setTruncatedIndex(cmd []byte) bool {
-	if !isSetTruncatedIndexUpdate(cmd) {
-		panic("not a setTruncatedIndex update")
-	}
+func (s *stateMachine) handleSetLeaseHolderID(cmd []byte) sm.Result {
+	s.LeaseHolderID = parseLeaseHolderID(cmd)
+	s.LeaseHistory[s.Index] = s.LeaseHolderID
+	return sm.Result{}
+}
+
+func (s *stateMachine) handleTruncateIndex(cmd []byte) sm.Result {
 	index := parseTruncatedIndex(cmd)
 	if index > s.TruncatedIndex {
 		s.TruncatedIndex = index
 		s.truncateLeaseHistory(index)
-		return true
+		return sm.Result{}
 	}
-	return false
+	return sm.Result{Value: s.TruncatedIndex}
 }
 
 // handleUserUpdate returns an empty sm.Result on success or it returns a
 // sm.Result value with the Value field set to the current lease holder ID
 // to indicate rejection by mismatched lease holder ID.
-func (s *stateMachine) handleUserUpdate(index uint64, cmd []byte) sm.Result {
-	if !isUserUpdate(cmd) {
-		panic("not user update")
-	}
+func (s *stateMachine) handleUserUpdate(cmd []byte) sm.Result {
 	if s.LeaseHolderID != parseLeaseHolderID(cmd) {
 		data := make([]byte, 8)
 		binaryEnc.PutUint64(data, s.LeaseHolderID)
 		return sm.Result{Data: data}
 	}
-	return sm.Result{Value: index}
+	return sm.Result{Value: s.Index}
 }
 
 func (s *stateMachine) Close() error {
@@ -187,33 +179,23 @@ func (s *stateMachine) Update(e sm.Entry) (sm.Result, error) {
 	cmd := e.Cmd
 	s.Index = e.Index
 	if isSetLeaseHolderUpdate(cmd) {
-		s.setLeaseHolderID(e.Index, cmd)
-		return sm.Result{}, nil
+		return s.handleSetLeaseHolderID(cmd), nil
 	} else if isSetTruncatedIndexUpdate(cmd) {
-		if s.setTruncatedIndex(cmd) {
-			return sm.Result{}, nil
-		} else {
-			return sm.Result{Value: s.TruncatedIndex}, nil
-		}
+		return s.handleTruncateIndex(cmd), nil
 	} else if isUserUpdate(cmd) {
-		return s.handleUserUpdate(e.Index, cmd), nil
+		return s.handleUserUpdate(cmd), nil
 	}
 	panic("corrupted entry")
 }
 
 func (s *stateMachine) Lookup(query interface{}) (interface{}, error) {
-	if v, ok := query.(uint16); ok {
-		if v == indexTag {
-			return s.Index, nil
-		} else if v == leaseHolderIDTag {
-			return s.LeaseHolderID, nil
-		} else if v == truncatedIndexTag {
-			return s.TruncatedIndex, nil
-		} else {
-			panic("unknown lookup command type")
-		}
-	}
-	if v, ok := query.(leaseHistoryQuery); ok {
+	if _, ok := query.(indexQuery); ok {
+		return s.Index, nil
+	} else if _, ok := query.(leaseHolderIDQuery); ok {
+		return s.LeaseHolderID, nil
+	} else if _, ok := query.(truncatedIndexQuery); ok {
+		return s.TruncatedIndex, nil
+	} else if v, ok := query.(leaseHistoryQuery); ok {
 		lease, _ := s.getLeaseHistory(v.index)
 		return lease, nil
 	}
diff --git a/pkg/logservice/service.go b/pkg/logservice/service.go
index e09367b8a..948b43246 100644
--- a/pkg/logservice/service.go
+++ b/pkg/logservice/service.go
@@ -36,6 +36,11 @@ type Lsn = uint64
 
 type LogRecord = pb.LogRecord
 
+// Service is the top layer component of a log service node. It manages the
+// underlying log store which in turn manages all log shards including the
+// HAKeeper shard. The Log Service component communicates with LogService
+// clients owned by DN nodes and the HAKeeper service via network, it can
+// be considered as the interface layer of the LogService.
 type Service struct {
 	cfg         Config
 	store       *logStore
diff --git a/pkg/logservice/store.go b/pkg/logservice/store.go
index 99128ec51..a5d7da78d 100644
--- a/pkg/logservice/store.go
+++ b/pkg/logservice/store.go
@@ -91,6 +91,7 @@ func getRaftConfig(shardID uint64, replicaID uint64) config.Config {
 	}
 }
 
+// logStore manages log shards including the HAKeeper shard on each node.
 type logStore struct {
 	cfg               Config
 	nh                *dragonboat.NodeHost
@@ -254,7 +255,7 @@ func (l *logStore) Append(ctx context.Context,
 
 func (l *logStore) GetTruncatedIndex(ctx context.Context,
 	shardID uint64) (uint64, error) {
-	v, err := l.read(ctx, shardID, truncatedIndexTag)
+	v, err := l.read(ctx, shardID, truncatedIndexQuery{})
 	if err != nil {
 		return 0, err
 	}
@@ -367,7 +368,7 @@ func getNextIndex(entries []raftpb.Entry, firstIndex Lsn, lastIndex Lsn) Lsn {
 
 func (l *logStore) QueryLog(ctx context.Context, shardID uint64,
 	firstIndex Lsn, maxSize uint64) ([]LogRecord, Lsn, error) {
-	v, err := l.read(ctx, shardID, indexTag)
+	v, err := l.read(ctx, shardID, indexQuery{})
 	if err != nil {
 		return nil, 0, err
 	}
diff --git a/pkg/pb/plan/plan.pb.go b/pkg/pb/plan/plan.pb.go
index de5465fef..de5888026 100644
--- a/pkg/pb/plan/plan.pb.go
+++ b/pkg/pb/plan/plan.pb.go
@@ -856,6 +856,13 @@ type Const struct {
 	//	*Const_Dval
 	//	*Const_Sval
 	//	*Const_Bval
+	//	*Const_Uval
+	//	*Const_Fval
+	//	*Const_Dateval
+	//	*Const_Datetimeval
+	//	*Const_Decimal64Val
+	//	*Const_Decimal128Val
+	//	*Const_Timestampval
 	Value                isConst_Value `protobuf_oneof:"value"`
 	XXX_NoUnkeyedLiteral struct{}      `json:"-"`
 	XXX_unrecognized     []byte        `json:"-"`
@@ -913,11 +920,39 @@ type Const_Sval struct {
 type Const_Bval struct {
 	Bval bool `protobuf:"varint,5,opt,name=bval,proto3,oneof" json:"bval,omitempty"`
 }
+type Const_Uval struct {
+	Uval uint64 `protobuf:"varint,6,opt,name=uval,proto3,oneof" json:"uval,omitempty"`
+}
+type Const_Fval struct {
+	Fval float32 `protobuf:"fixed32,7,opt,name=fval,proto3,oneof" json:"fval,omitempty"`
+}
+type Const_Dateval struct {
+	Dateval int32 `protobuf:"varint,8,opt,name=dateval,proto3,oneof" json:"dateval,omitempty"`
+}
+type Const_Datetimeval struct {
+	Datetimeval int64 `protobuf:"varint,9,opt,name=datetimeval,proto3,oneof" json:"datetimeval,omitempty"`
+}
+type Const_Decimal64Val struct {
+	Decimal64Val int64 `protobuf:"varint,10,opt,name=decimal64val,proto3,oneof" json:"decimal64val,omitempty"`
+}
+type Const_Decimal128Val struct {
+	Decimal128Val *Decimal128 `protobuf:"bytes,11,opt,name=decimal128val,proto3,oneof" json:"decimal128val,omitempty"`
+}
+type Const_Timestampval struct {
+	Timestampval int64 `protobuf:"varint,12,opt,name=timestampval,proto3,oneof" json:"timestampval,omitempty"`
+}
 
-func (*Const_Ival) isConst_Value() {}
-func (*Const_Dval) isConst_Value() {}
-func (*Const_Sval) isConst_Value() {}
-func (*Const_Bval) isConst_Value() {}
+func (*Const_Ival) isConst_Value()          {}
+func (*Const_Dval) isConst_Value()          {}
+func (*Const_Sval) isConst_Value()          {}
+func (*Const_Bval) isConst_Value()          {}
+func (*Const_Uval) isConst_Value()          {}
+func (*Const_Fval) isConst_Value()          {}
+func (*Const_Dateval) isConst_Value()       {}
+func (*Const_Datetimeval) isConst_Value()   {}
+func (*Const_Decimal64Val) isConst_Value()  {}
+func (*Const_Decimal128Val) isConst_Value() {}
+func (*Const_Timestampval) isConst_Value()  {}
 
 func (m *Const) GetValue() isConst_Value {
 	if m != nil {
@@ -961,6 +996,55 @@ func (m *Const) GetBval() bool {
 	return false
 }
 
+func (m *Const) GetUval() uint64 {
+	if x, ok := m.GetValue().(*Const_Uval); ok {
+		return x.Uval
+	}
+	return 0
+}
+
+func (m *Const) GetFval() float32 {
+	if x, ok := m.GetValue().(*Const_Fval); ok {
+		return x.Fval
+	}
+	return 0
+}
+
+func (m *Const) GetDateval() int32 {
+	if x, ok := m.GetValue().(*Const_Dateval); ok {
+		return x.Dateval
+	}
+	return 0
+}
+
+func (m *Const) GetDatetimeval() int64 {
+	if x, ok := m.GetValue().(*Const_Datetimeval); ok {
+		return x.Datetimeval
+	}
+	return 0
+}
+
+func (m *Const) GetDecimal64Val() int64 {
+	if x, ok := m.GetValue().(*Const_Decimal64Val); ok {
+		return x.Decimal64Val
+	}
+	return 0
+}
+
+func (m *Const) GetDecimal128Val() *Decimal128 {
+	if x, ok := m.GetValue().(*Const_Decimal128Val); ok {
+		return x.Decimal128Val
+	}
+	return nil
+}
+
+func (m *Const) GetTimestampval() int64 {
+	if x, ok := m.GetValue().(*Const_Timestampval); ok {
+		return x.Timestampval
+	}
+	return 0
+}
+
 // XXX_OneofWrappers is for the internal use of the proto package.
 func (*Const) XXX_OneofWrappers() []interface{} {
 	return []interface{}{
@@ -968,6 +1052,13 @@ func (*Const) XXX_OneofWrappers() []interface{} {
 		(*Const_Dval)(nil),
 		(*Const_Sval)(nil),
 		(*Const_Bval)(nil),
+		(*Const_Uval)(nil),
+		(*Const_Fval)(nil),
+		(*Const_Dateval)(nil),
+		(*Const_Datetimeval)(nil),
+		(*Const_Decimal64Val)(nil),
+		(*Const_Decimal128Val)(nil),
+		(*Const_Timestampval)(nil),
 	}
 }
 
@@ -4539,267 +4630,273 @@ func init() {
 func init() { proto.RegisterFile("plan.proto", fileDescriptor_2d655ab2f7683c23) }
 
 var fileDescriptor_2d655ab2f7683c23 = []byte{
-	// 4156 bytes of a gzipped FileDescriptorProto
-	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xac, 0x5a, 0x5f, 0x6f, 0x1b, 0xc7,
-	0x76, 0xd7, 0xf2, 0xef, 0xf2, 0x50, 0x92, 0xc7, 0x63, 0xc7, 0x66, 0x12, 0xc7, 0x91, 0x37, 0xf1,
-	0xad, 0x62, 0x27, 0x4e, 0x4c, 0x2b, 0xaa, 0x73, 0x9b, 0xde, 0xdc, 0x25, 0xb5, 0x92, 0x36, 0xa6,
-	0x96, 0xba, 0xc3, 0x95, 0x1c, 0x27, 0x28, 0x88, 0x25, 0x77, 0x49, 0xaf, 0xbd, 0xe2, 0xb2, 0xbb,
-	0x4b, 0xc9, 0xba, 0x4f, 0x79, 0x69, 0x51, 0xb4, 0x0f, 0x2d, 0x8a, 0x02, 0xb7, 0xe8, 0x53, 0x71,
-	0x81, 0x7e, 0x80, 0x7e, 0x88, 0x02, 0xb7, 0xe8, 0x4b, 0x81, 0xbe, 0x14, 0xe8, 0x4b, 0x9b, 0x7e,
-	0x91, 0xe2, 0x9c, 0xd9, 0x25, 0x97, 0x96, 0x92, 0x1b, 0x04, 0x7d, 0x11, 0xce, 0xf9, 0x9d, 0x3f,
-	0x7b, 0x66, 0xe6, 0xcc, 0x99, 0x33, 0x43, 0x01, 0x4c, 0x03, 0x67, 0xf2, 0x60, 0x1a, 0x85, 0x49,
-	0xc8, 0x4b, 0x48, 0xbf, 0xf5, 0xd1, 0xd8, 0x4f, 0x9e, 0xcf, 0x06, 0x0f, 0x86, 0xe1, 0xc9, 0xc7,
-	0xe3, 0x70, 0x1c, 0x7e, 0x4c, 0xc2, 0xc1, 0x6c, 0x44, 0x1c, 0x31, 0x44, 0x49, 0x23, 0xed, 0xdf,
-	0xca, 0x50, 0xb2, 0xcf, 0xa7, 0x1e, 0xbf, 0x03, 0x05, 0xdf, 0x6d, 0x28, 0x1b, 0xca, 0xe6, 0x7a,
-	0xf3, 0xea, 0x03, 0x72, 0x8b, 0x38, 0xfd, 0x31, 0x5d, 0x51, 0xf0, 0x5d, 0xfe, 0x16, 0xa8, 0x93,
-	0x59, 0x10, 0x38, 0x83, 0xc0, 0x6b, 0x14, 0x36, 0x94, 0x4d, 0x55, 0xcc, 0x79, 0x7e, 0x1d, 0xca,
-	0x67, 0xbe, 0x9b, 0x3c, 0x6f, 0x14, 0x37, 0x94, 0xcd, 0xb2, 0x90, 0x0c, 0xbf, 0x05, 0xb5, 0x69,
-	0xe4, 0x0d, 0xfd, 0xd8, 0x0f, 0x27, 0x8d, 0x12, 0x49, 0x16, 0x00, 0xe7, 0x50, 0x8a, 0xfd, 0x5f,
-	0x7b, 0x8d, 0x32, 0x09, 0x88, 0x46, 0x3f, 0xf1, 0xd0, 0x09, 0xbc, 0x46, 0x45, 0xfa, 0x21, 0x46,
-	0xfb, 0xa7, 0x12, 0x54, 0x64, 0x20, 0xbc, 0x0a, 0x45, 0xdd, 0x7a, 0xc6, 0x56, 0xb8, 0x0a, 0xa5,
-	0x9e, 0xad, 0x0b, 0xa6, 0x20, 0xd5, 0xea, 0x76, 0x3b, 0x0c, 0x90, 0x32, 0x2d, 0xfb, 0x31, 0xbb,
-	0xce, 0x6b, 0x50, 0x36, 0x2d, 0xfb, 0xe1, 0x36, 0x7b, 0x23, 0x25, 0x1f, 0x35, 0xd9, 0x8d, 0x94,
-	0xdc, 0xde, 0x62, 0x37, 0x39, 0x40, 0x05, 0x15, 0x9a, 0x8f, 0x59, 0x03, 0xe1, 0x23, 0xb2, 0x7b,
-	0x13, 0xe1, 0x23, 0x69, 0xf8, 0x56, 0x46, 0x3f, 0x6a, 0xb2, 0xb7, 0x33, 0x7a, 0x7b, 0x8b, 0xdd,
-	0xe2, 0x75, 0xa8, 0x1e, 0xa5, 0xb6, 0xef, 0x20, 0xb3, 0xdb, 0xe9, 0xea, 0xa8, 0x75, 0x7b, 0xce,
-	0x6c, 0x6f, 0xb1, 0x77, 0xf9, 0x1a, 0xd4, 0x76, 0x8c, 0xb6, 0x79, 0xa0, 0x77, 0xb6, 0xb7, 0xd8,
-	0x06, 0x5f, 0x07, 0x48, 0x59, 0x34, 0xbc, 0x83, 0xba, 0x29, 0xcf, 0x34, 0x74, 0xaf, 0x5b, 0xcf,
-	0x4c, 0xcb, 0x66, 0x77, 0xf9, 0x2a, 0xa8, 0xba, 0xf5, 0x8c, 0xfc, 0xb0, 0x9f, 0xa1, 0x17, 0xdd,
-	0x7a, 0x66, 0x1d, 0x1d, 0xb4, 0x0c, 0xc1, 0xfe, 0x00, 0x47, 0x78, 0x74, 0x64, 0xee, 0xb0, 0x4d,
-	0x0a, 0xba, 0xf5, 0x70, 0xfb, 0x13, 0xf6, 0x41, 0x4a, 0x3e, 0xde, 0x62, 0xf7, 0x52, 0xf2, 0xb3,
-	0x26, 0xbb, 0x2f, 0xc9, 0x66, 0x73, 0x8b, 0x7d, 0x98, 0x92, 0x9f, 0x6e, 0xb3, 0x8f, 0xd0, 0xc1,
-	0x8e, 0x6e, 0x1b, 0xac, 0x89, 0x94, 0x6d, 0x1e, 0x18, 0xec, 0x11, 0x7e, 0x11, 0x31, 0xe2, 0xb6,
-	0xf0, 0x8b, 0x48, 0xf5, 0x6c, 0xfd, 0xe0, 0x90, 0x7d, 0x8a, 0x42, 0xd3, 0xb2, 0x0d, 0x71, 0xac,
-	0x77, 0xd8, 0x36, 0x46, 0xad, 0x5b, 0xcf, 0x48, 0xf3, 0x8f, 0xd0, 0x43, 0x7b, 0x5f, 0x17, 0xec,
-	0x73, 0x84, 0x8f, 0x75, 0x41, 0xcc, 0x1f, 0x23, 0xfc, 0x65, 0xaf, 0x6b, 0xb1, 0x5f, 0xe0, 0xb0,
-	0x5a, 0xa6, 0xa5, 0x8b, 0x67, 0x6c, 0x17, 0xdd, 0x1e, 0xeb, 0x22, 0x65, 0xf7, 0x30, 0x24, 0x5d,
-	0x08, 0xfd, 0x19, 0xfb, 0x1a, 0x67, 0x66, 0xb7, 0x63, 0x7c, 0xd5, 0x3a, 0xda, 0xdd, 0x35, 0x04,
-	0xfb, 0x86, 0xac, 0x9e, 0xd9, 0x86, 0xfe, 0x98, 0xb9, 0xe8, 0x98, 0xe8, 0x87, 0xdb, 0xcc, 0x43,
-	0x1b, 0x62, 0xd8, 0x88, 0xab, 0x50, 0xec, 0x19, 0x1d, 0xf6, 0x3b, 0x85, 0x03, 0x94, 0xed, 0xa3,
-	0xc3, 0x8e, 0xc1, 0xfe, 0x55, 0xd1, 0xbe, 0x55, 0xa0, 0xdc, 0x0e, 0x27, 0x71, 0xc2, 0x6f, 0x40,
-	0xc5, 0x8f, 0x31, 0x3b, 0x29, 0xa5, 0x55, 0x91, 0x72, 0xfc, 0x3a, 0x94, 0xfc, 0x53, 0x27, 0xa0,
-	0xfc, 0x2d, 0xee, 0xaf, 0x08, 0xe2, 0x10, 0x75, 0x11, 0xc5, 0xe4, 0x55, 0x10, 0x75, 0x53, 0x34,
-	0x46, 0x14, 0x13, 0xb7, 0x86, 0x68, 0x9c, 0xa2, 0x03, 0x44, 0x31, 0x6b, 0x55, 0x44, 0x91, 0x6b,
-	0x55, 0xa1, 0x7c, 0xea, 0x04, 0x33, 0x4f, 0xbb, 0x05, 0xea, 0xa1, 0x13, 0x39, 0x27, 0xc2, 0x1b,
-	0x71, 0x06, 0xc5, 0x69, 0x18, 0x53, 0x04, 0x65, 0x81, 0xa4, 0x76, 0x0b, 0x2a, 0xc7, 0x4e, 0x84,
-	0x32, 0x0e, 0xa5, 0x89, 0x73, 0xe2, 0x91, 0xb0, 0x26, 0x88, 0xd6, 0x7e, 0x0e, 0x95, 0x76, 0x18,
-	0xa0, 0xf4, 0x26, 0x54, 0x23, 0x2f, 0xe8, 0x2f, 0xac, 0x2b, 0x91, 0x17, 0x1c, 0x86, 0x31, 0x0a,
-	0x86, 0xa1, 0x14, 0x14, 0xa4, 0x60, 0x18, 0xa2, 0x40, 0xb3, 0x01, 0xda, 0x61, 0x14, 0xfd, 0x54,
-	0x7b, 0xdc, 0x78, 0xae, 0x37, 0x5d, 0x6c, 0x60, 0x62, 0xb4, 0x7b, 0xa0, 0x1a, 0xaf, 0xa6, 0x51,
-	0xc7, 0x8f, 0x13, 0x7e, 0x1b, 0x4a, 0x81, 0x1f, 0x27, 0x0d, 0x65, 0xa3, 0xb8, 0x59, 0x6f, 0x82,
-	0xac, 0x11, 0x28, 0x15, 0x84, 0x6b, 0xf7, 0x00, 0x6c, 0x27, 0x1a, 0x7b, 0x09, 0xd5, 0x93, 0x5b,
-	0x50, 0x4c, 0xce, 0xa7, 0xf4, 0xf5, 0xb9, 0x32, 0x0a, 0x04, 0xc2, 0xda, 0x7f, 0x2a, 0x50, 0xef,
-	0xcd, 0x06, 0x7f, 0x3a, 0xf3, 0xa2, 0x73, 0x8c, 0x77, 0x73, 0xa1, 0xbd, 0xde, 0xbc, 0x21, 0xb5,
-	0x73, 0xf2, 0x85, 0x25, 0x0e, 0x60, 0x12, 0xba, 0x5e, 0xdf, 0x77, 0xb3, 0x01, 0x20, 0x6b, 0xba,
-	0x7c, 0x1d, 0x0a, 0xe1, 0x94, 0xa2, 0xaf, 0x89, 0x42, 0x38, 0xe5, 0x1b, 0x50, 0x1e, 0x3e, 0xf7,
-	0x03, 0x97, 0x96, 0x6f, 0x39, 0x5e, 0x29, 0xd0, 0xec, 0xb4, 0xf4, 0x01, 0x54, 0x7a, 0x6d, 0xbd,
-	0xa3, 0x0b, 0xb6, 0x82, 0xb4, 0xf1, 0x95, 0xd9, 0xb3, 0x7b, 0x4c, 0xc1, 0xbc, 0xb4, 0xba, 0x76,
-	0x3f, 0xe5, 0x0b, 0xbc, 0x02, 0x05, 0xd3, 0x62, 0x45, 0xd4, 0x41, 0xdc, 0xb4, 0x58, 0x29, 0x2b,
-	0x47, 0x65, 0x22, 0x3a, 0x1d, 0x56, 0xd1, 0xfe, 0x43, 0x81, 0x5a, 0x77, 0xf0, 0xc2, 0x1b, 0x26,
-	0x38, 0xb0, 0x1b, 0x50, 0x89, 0xbd, 0xe8, 0xd4, 0x8b, 0x68, 0x6c, 0x45, 0x91, 0x72, 0x18, 0xad,
-	0x3b, 0x90, 0x59, 0x28, 0x0a, 0xee, 0x80, 0xf4, 0x86, 0xcf, 0xbd, 0x13, 0x87, 0x46, 0x80, 0x7a,
-	0xc4, 0x61, 0x0a, 0x85, 0x83, 0x17, 0x34, 0x86, 0xa2, 0x40, 0x92, 0xbf, 0x0b, 0x75, 0xe9, 0xa3,
-	0x4f, 0xf9, 0x53, 0xa6, 0x01, 0x83, 0x84, 0x2c, 0xe7, 0xc4, 0xc3, 0x19, 0x72, 0x07, 0x52, 0x58,
-	0x21, 0x61, 0xc5, 0x1d, 0x90, 0x00, 0x2d, 0xc9, 0xab, 0x14, 0x56, 0x53, 0x4b, 0x82, 0x48, 0xe1,
-	0x4d, 0x50, 0xc3, 0xc1, 0x0b, 0x29, 0x55, 0x49, 0x5a, 0x0d, 0x07, 0x2f, 0x50, 0xa4, 0xfd, 0x8f,
-	0x02, 0xea, 0xee, 0x6c, 0x32, 0x4c, 0xb0, 0x70, 0xbf, 0x07, 0xa5, 0xd1, 0x6c, 0x32, 0x4c, 0x17,
-	0xf7, 0x8a, 0x9c, 0xd9, 0xf9, 0x98, 0x05, 0x09, 0x31, 0x5d, 0x9c, 0x68, 0x8c, 0x69, 0x76, 0x21,
-	0x5d, 0x10, 0xd7, 0xfe, 0x3a, 0xf5, 0xb8, 0x1b, 0x38, 0x63, 0x2c, 0x19, 0x56, 0xd7, 0x32, 0xd8,
-	0xca, 0xbc, 0xdc, 0x58, 0x7a, 0x87, 0x29, 0xb4, 0x34, 0xb6, 0xde, 0xea, 0x18, 0xac, 0x80, 0x92,
-	0xe3, 0x6e, 0x47, 0xb7, 0xcd, 0x8e, 0xc1, 0x4a, 0x52, 0x22, 0xcc, 0xb6, 0xcd, 0x54, 0xce, 0x60,
-	0xf5, 0x50, 0x74, 0x77, 0x8e, 0xda, 0x46, 0xdf, 0x3a, 0xea, 0x74, 0x18, 0xe3, 0xd7, 0xe0, 0xca,
-	0x1c, 0xe9, 0x4a, 0x70, 0x03, 0x4d, 0x8e, 0x75, 0xa1, 0x8b, 0x3d, 0xf6, 0x4b, 0xac, 0x1f, 0xfa,
-	0xde, 0x1e, 0xfb, 0x16, 0x4f, 0x8f, 0xe2, 0x53, 0xd3, 0x62, 0xdf, 0x16, 0xb4, 0x7f, 0x28, 0x42,
-	0x09, 0x03, 0xfc, 0xe1, 0xdc, 0xe5, 0x6f, 0x83, 0x32, 0xa4, 0x95, 0xab, 0x37, 0xeb, 0x52, 0x46,
-	0x25, 0x67, 0x7f, 0x45, 0x28, 0x38, 0x6a, 0x45, 0x26, 0x61, 0xbd, 0xb9, 0x2e, 0x85, 0x59, 0x35,
-	0x40, 0xf9, 0x94, 0xdf, 0x02, 0xe5, 0x34, 0xcd, 0xc8, 0x55, 0x29, 0x97, 0xf5, 0x00, 0xa5, 0xa7,
-	0x7c, 0x03, 0x8a, 0xc3, 0x50, 0x96, 0x96, 0xb9, 0x5c, 0xee, 0xe8, 0xfd, 0x15, 0x81, 0x22, 0xf4,
-	0x3f, 0xa2, 0x65, 0x9d, 0xfb, 0xcf, 0x56, 0x05, 0x3d, 0x8c, 0xf8, 0x5d, 0x28, 0xc6, 0xb3, 0x01,
-	0xad, 0x6d, 0x3d, 0x3b, 0xc7, 0x73, 0x1b, 0x09, 0xdd, 0xc4, 0xb3, 0x01, 0xff, 0x19, 0x94, 0x86,
-	0x61, 0x14, 0xd1, 0x2a, 0xd7, 0x9b, 0x2c, 0xfb, 0x52, 0x56, 0x3f, 0xb0, 0xac, 0xa1, 0x9c, 0x6f,
-	0x80, 0x92, 0x34, 0x6a, 0x79, 0xa5, 0xc5, 0x16, 0xc7, 0x0f, 0x26, 0xfc, 0xfd, 0xb4, 0x2a, 0x40,
-	0x3e, 0xa6, 0xac, 0x66, 0xa0, 0x1f, 0x94, 0xf2, 0x77, 0x00, 0x12, 0xec, 0x13, 0x64, 0x6e, 0xd5,
-	0x29, 0xb7, 0x6a, 0x84, 0x64, 0x89, 0x87, 0x55, 0x89, 0x84, 0xab, 0x32, 0xf1, 0x86, 0x61, 0x80,
-	0xa2, 0x56, 0x05, 0x4a, 0xde, 0xab, 0x69, 0xa4, 0x8d, 0xa1, 0xbe, 0xe3, 0x8d, 0x9c, 0x59, 0x90,
-	0xd0, 0x12, 0x5d, 0x87, 0xb2, 0xf7, 0x4a, 0x56, 0x23, 0x2c, 0xef, 0x92, 0xe1, 0x1f, 0xa4, 0x55,
-	0x38, 0x5d, 0x9e, 0x6b, 0xb9, 0xe5, 0x71, 0x26, 0xc9, 0x31, 0x8a, 0x84, 0xd4, 0xc0, 0x5d, 0xe2,
-	0xc7, 0x7d, 0x3a, 0x21, 0x8a, 0xd9, 0x09, 0x61, 0xcd, 0x82, 0x40, 0xfb, 0x6d, 0x11, 0xd6, 0x96,
-	0x2c, 0xf8, 0x3b, 0x50, 0x9b, 0x4d, 0x5e, 0x4e, 0xc2, 0xb3, 0x49, 0xff, 0x54, 0x96, 0xd3, 0xfd,
-	0x15, 0xa1, 0xa6, 0xd0, 0x31, 0x7f, 0x13, 0xaa, 0xfe, 0x24, 0xd9, 0xde, 0xea, 0x9f, 0xce, 0x4f,
-	0x95, 0x0a, 0x01, 0xc7, 0xfc, 0x0e, 0xd4, 0x5d, 0x6f, 0xe8, 0x9f, 0x38, 0x01, 0x89, 0x8b, 0xa9,
-	0x18, 0xe6, 0xe0, 0x31, 0xff, 0x14, 0x56, 0x53, 0xee, 0x61, 0xf3, 0x71, 0x3f, 0xcb, 0x8d, 0x74,
-	0xb2, 0x17, 0x92, 0xfd, 0x15, 0x51, 0x5f, 0x70, 0xc7, 0xfc, 0x6d, 0x50, 0x67, 0xd9, 0x57, 0x31,
-	0x5d, 0x4a, 0xfb, 0x2b, 0xa2, 0x3a, 0x4b, 0x3f, 0xfb, 0x0e, 0xd4, 0x46, 0x41, 0xe8, 0x24, 0x8f,
-	0x9a, 0xfd, 0x53, 0x4a, 0x96, 0x02, 0x06, 0x9c, 0x42, 0x0b, 0x31, 0x19, 0x57, 0xd3, 0x23, 0x4f,
-	0x4d, 0xa1, 0x63, 0x7e, 0x13, 0x2a, 0xae, 0x93, 0x78, 0xfd, 0x53, 0xca, 0x0e, 0x1c, 0x6b, 0x19,
-	0xf9, 0x63, 0xfe, 0x2e, 0x00, 0x12, 0xb6, 0x7f, 0x82, 0xc2, 0x5a, 0x3a, 0x98, 0x5a, 0x86, 0xd1,
-	0x70, 0x13, 0xff, 0xc4, 0xeb, 0x25, 0xce, 0xc9, 0xb4, 0x7f, 0x4a, 0x29, 0x41, 0xc3, 0x9d, 0x83,
-	0x14, 0x77, 0x9c, 0x44, 0xfe, 0x64, 0xdc, 0x3f, 0x95, 0x69, 0x80, 0x71, 0x4b, 0x84, 0xbe, 0x3c,
-	0x08, 0xc3, 0xa0, 0x7f, 0x4a, 0x49, 0x80, 0x87, 0x6b, 0x19, 0xf9, 0xe3, 0xd6, 0x15, 0x58, 0x1b,
-	0xe6, 0x97, 0x44, 0xfb, 0x10, 0x60, 0x31, 0x1b, 0x58, 0x4c, 0x3b, 0x61, 0x5a, 0x60, 0x0b, 0x9d,
-	0x10, 0xf9, 0x7d, 0x3f, 0x2b, 0xae, 0xfb, 0x3e, 0x96, 0x64, 0x3c, 0x58, 0x77, 0x2e, 0x3f, 0x76,
-	0xf9, 0xfb, 0x50, 0x74, 0x82, 0x31, 0xe9, 0xaf, 0x37, 0x79, 0x96, 0x33, 0x27, 0xd3, 0xc8, 0x8b,
-	0x63, 0xb9, 0xed, 0x9d, 0x60, 0x9c, 0x15, 0x85, 0xe2, 0xe5, 0x45, 0xe1, 0x3e, 0x54, 0x5d, 0x99,
-	0x9e, 0xe9, 0x0a, 0xa6, 0x7b, 0x2f, 0x97, 0xb3, 0x22, 0xd3, 0xe0, 0x0d, 0xa8, 0x4e, 0x23, 0xff,
-	0xc4, 0x89, 0xce, 0x65, 0x17, 0x21, 0x32, 0x16, 0xd3, 0x7a, 0xfa, 0xd2, 0x77, 0x5f, 0x65, 0xed,
-	0x2f, 0x31, 0x88, 0x3a, 0x81, 0xef, 0xc4, 0x69, 0xc9, 0x96, 0x8c, 0xf6, 0x1b, 0x05, 0x54, 0x73,
-	0xe2, 0x7a, 0xaf, 0x70, 0x5c, 0xf7, 0xf2, 0x07, 0x68, 0x43, 0x7e, 0x3b, 0x13, 0x4a, 0x62, 0x11,
-	0x6b, 0x36, 0x07, 0x85, 0xdc, 0x1c, 0xbc, 0x0d, 0xb5, 0x6c, 0x07, 0xc6, 0x8d, 0xe2, 0x46, 0x71,
-	0xb3, 0x26, 0xd4, 0x74, 0x0b, 0xc6, 0xda, 0x03, 0xa8, 0xcd, 0x5d, 0x60, 0x47, 0x66, 0x5a, 0xc7,
-	0xba, 0xd9, 0xd9, 0x61, 0x2b, 0xc8, 0x7c, 0xdd, 0xb5, 0x8c, 0x03, 0xfd, 0x90, 0x29, 0x78, 0x04,
-	0xb6, 0x7a, 0x26, 0x2b, 0x68, 0x77, 0x61, 0xed, 0x50, 0x0e, 0xe8, 0x89, 0x77, 0x8e, 0xd1, 0x5d,
-	0x87, 0xb2, 0xf4, 0xac, 0x90, 0x67, 0xc9, 0x68, 0x4d, 0x50, 0x0f, 0xa3, 0x70, 0xea, 0x45, 0xc9,
-	0x39, 0x9e, 0x73, 0x2f, 0xbd, 0xf3, 0x74, 0x59, 0x90, 0x44, 0x9b, 0xc5, 0x5e, 0xae, 0xa5, 0xdb,
-	0x56, 0xfb, 0x02, 0x5d, 0x93, 0x8d, 0xef, 0xc5, 0xe8, 0xfa, 0x01, 0xc0, 0x74, 0x0e, 0xa4, 0xbd,
-	0x49, 0x56, 0x79, 0x53, 0xe7, 0x22, 0xa7, 0xa1, 0xfd, 0xa6, 0x00, 0xaa, 0x8d, 0x85, 0xe7, 0xfb,
-	0xb2, 0x61, 0x03, 0x4b, 0x63, 0x90, 0x9d, 0x5b, 0x8b, 0x22, 0xbc, 0x83, 0x27, 0x1b, 0x4a, 0xf8,
-	0x3d, 0x28, 0xb9, 0xde, 0x48, 0x4e, 0x53, 0x3d, 0xeb, 0x56, 0x32, 0x9f, 0xb8, 0xe2, 0x34, 0xd5,
-	0xa4, 0xb3, 0x58, 0xba, 0x52, 0x6e, 0xe9, 0xde, 0xfa, 0x5b, 0x05, 0xaa, 0xa9, 0x1e, 0xbf, 0x0b,
-	0x85, 0xe9, 0xcb, 0xf4, 0xac, 0xb9, 0x96, 0x05, 0x9e, 0x9b, 0xbc, 0xfd, 0x15, 0x51, 0x98, 0xbe,
-	0xe4, 0x1a, 0x14, 0x31, 0x2f, 0x0a, 0xf9, 0x32, 0x9b, 0x2d, 0x30, 0x56, 0x75, 0xcc, 0x93, 0x4f,
-	0x97, 0xe6, 0xa2, 0xb8, 0xec, 0x32, 0x37, 0x69, 0xb8, 0x27, 0x17, 0x8a, 0xad, 0x32, 0x14, 0x5d,
-	0x6f, 0xa4, 0x45, 0x50, 0x6a, 0x87, 0x71, 0x82, 0x93, 0x32, 0x74, 0x22, 0x79, 0x17, 0x54, 0x04,
-	0xd1, 0x98, 0xb1, 0x51, 0x78, 0x46, 0xb7, 0xb5, 0x02, 0xc1, 0x19, 0x8b, 0x0b, 0x37, 0x71, 0x65,
-	0x69, 0x53, 0x04, 0x92, 0x74, 0x85, 0x4b, 0x9c, 0x48, 0x6e, 0x04, 0x45, 0x48, 0x06, 0xd1, 0x24,
-	0x4c, 0xd2, 0xbe, 0x59, 0x11, 0x92, 0xd1, 0xfe, 0x59, 0x81, 0x2a, 0xce, 0xad, 0x93, 0x38, 0x98,
-	0x82, 0x51, 0x78, 0xd6, 0x1f, 0x86, 0xb3, 0x49, 0x92, 0x76, 0xad, 0x6a, 0x14, 0x9e, 0xb5, 0x91,
-	0xc7, 0x03, 0x04, 0x6b, 0x75, 0x2a, 0x95, 0x9d, 0x5f, 0x0d, 0x11, 0x29, 0xc6, 0x04, 0x9b, 0x05,
-	0x81, 0x5c, 0x13, 0x55, 0x48, 0x06, 0x63, 0xf3, 0x1f, 0x35, 0x1b, 0xa5, 0x8d, 0x22, 0xf6, 0xdf,
-	0xfe, 0xa3, 0x26, 0x21, 0xdb, 0x5b, 0x8d, 0xf2, 0x46, 0x11, 0xdb, 0x29, 0x7f, 0x7b, 0x0b, 0x91,
-	0xd1, 0xa3, 0x66, 0xa3, 0xb2, 0x51, 0xdc, 0x2c, 0x08, 0x24, 0x09, 0xd9, 0xde, 0x6a, 0x54, 0x37,
-	0x8a, 0x38, 0xa2, 0xd1, 0xf6, 0x16, 0x5f, 0x05, 0x25, 0x6e, 0xa8, 0x94, 0xba, 0x4a, 0xac, 0x3d,
-	0x05, 0x10, 0xe1, 0x59, 0xec, 0x25, 0x14, 0xf5, 0xcf, 0xe6, 0x8d, 0x9b, 0x92, 0x5f, 0x9a, 0x2c,
-	0x1d, 0xe6, 0x8d, 0xdc, 0x9d, 0xa5, 0xb4, 0x5a, 0x5b, 0xa4, 0x95, 0x93, 0x38, 0x32, 0xaf, 0xb4,
-	0xff, 0x52, 0xa0, 0xde, 0x8d, 0x5c, 0x2f, 0x6a, 0x9d, 0xf7, 0xa6, 0x1e, 0x75, 0x50, 0x78, 0xf4,
-	0x2d, 0xf7, 0x21, 0xb2, 0x83, 0xf2, 0x64, 0x9b, 0x82, 0x7b, 0x36, 0x70, 0xf0, 0xf4, 0x4f, 0x77,
-	0xc9, 0x02, 0xe0, 0x0f, 0xa1, 0x34, 0x0a, 0x9c, 0x31, 0xad, 0xcc, 0x7a, 0xf3, 0x9d, 0xb4, 0x49,
-	0x5b, 0xb8, 0xcf, 0x68, 0xec, 0xbf, 0x04, 0xa9, 0x6a, 0xdf, 0xcc, 0xbf, 0x4f, 0x4d, 0x19, 0xb6,
-	0xb4, 0xbd, 0xb6, 0xbc, 0x6a, 0xef, 0x18, 0xbd, 0x36, 0x53, 0xf8, 0x15, 0xa8, 0x63, 0x33, 0xd5,
-	0xeb, 0xef, 0x9a, 0xa2, 0x67, 0xb3, 0x02, 0xf5, 0xc8, 0x04, 0x74, 0xf4, 0x9e, 0x2d, 0xdb, 0xb2,
-	0x23, 0xcb, 0xfc, 0xd5, 0x91, 0xc1, 0xd4, 0xa5, 0x56, 0x8e, 0x61, 0xbf, 0x07, 0x4f, 0xfd, 0x89,
-	0x1b, 0x9e, 0xd1, 0xe0, 0x3e, 0x82, 0xd5, 0xa9, 0x13, 0x25, 0x3e, 0xc6, 0xda, 0x1f, 0x9c, 0x5f,
-	0x72, 0xab, 0xa8, 0xcf, 0xe5, 0xad, 0x73, 0xfe, 0x21, 0xa8, 0x21, 0x86, 0x86, 0xaa, 0x72, 0x0a,
-	0xaf, 0x5e, 0x18, 0x91, 0xa8, 0x86, 0x92, 0xc1, 0x14, 0x0e, 0x3c, 0xc7, 0x4d, 0xef, 0x32, 0x44,
-	0xe3, 0xb2, 0xe2, 0x74, 0xc8, 0x57, 0x08, 0x24, 0xb5, 0x7f, 0x51, 0x00, 0x8e, 0xa6, 0x78, 0x7c,
-	0x99, 0x93, 0x51, 0x88, 0x1d, 0xc1, 0x34, 0xf2, 0xfb, 0x8b, 0x32, 0x54, 0x99, 0x46, 0xfe, 0x13,
-	0xef, 0x9c, 0xdf, 0x86, 0x7a, 0x2a, 0xe8, 0x67, 0x5b, 0x90, 0xde, 0x31, 0x50, 0x68, 0xba, 0xaf,
-	0xb0, 0x7b, 0x79, 0xee, 0xbb, 0x1e, 0x59, 0xca, 0xfb, 0x47, 0x15, 0x79, 0x34, 0xbd, 0x03, 0xab,
-	0x33, 0xfa, 0x42, 0xdf, 0x49, 0x92, 0x28, 0xa6, 0x54, 0xac, 0x89, 0xba, 0xc4, 0x74, 0x84, 0xb0,
-	0x2b, 0x0f, 0x93, 0xe7, 0x5e, 0x94, 0x6a, 0x94, 0x49, 0x03, 0x08, 0x9a, 0x2b, 0xa0, 0xa8, 0x4f,
-	0x83, 0x8b, 0x29, 0x53, 0x6b, 0x02, 0x10, 0xa2, 0xb1, 0xc7, 0xda, 0x5f, 0xd4, 0xa1, 0x64, 0x85,
-	0xae, 0xc7, 0x3f, 0x81, 0x1a, 0xdd, 0x8d, 0x92, 0xf3, 0xa9, 0x97, 0x1e, 0x05, 0xe9, 0xf6, 0x47,
-	0x31, 0xfd, 0xa1, 0xd2, 0xa4, 0x4e, 0x52, 0xea, 0xfb, 0x6f, 0x53, 0xb7, 0x31, 0x5d, 0xe3, 0x64,
-	0xf9, 0xb8, 0xc3, 0xf2, 0x20, 0x08, 0xa7, 0xe5, 0x8b, 0x42, 0xec, 0xf8, 0xfb, 0xd4, 0xfe, 0x95,
-	0x2e, 0x59, 0x3e, 0x29, 0xa7, 0xbb, 0xe3, 0x5b, 0xa0, 0xd2, 0x9d, 0x2b, 0xf2, 0x26, 0x34, 0xc2,
-	0xb2, 0x98, 0xf3, 0x18, 0xf5, 0x8b, 0xd0, 0x9f, 0xc8, 0xa8, 0x2b, 0x17, 0xa2, 0xfe, 0x32, 0xf4,
-	0x27, 0x94, 0xa3, 0x2a, 0x6a, 0x51, 0xd4, 0xef, 0x41, 0x35, 0x9c, 0xc8, 0xef, 0x56, 0x2f, 0x7c,
-	0xb7, 0x12, 0x4e, 0xe8, 0x93, 0xf7, 0xa1, 0x3e, 0xf2, 0x83, 0xc4, 0x8b, 0xa4, 0xa2, 0x7a, 0x41,
-	0x11, 0xa4, 0x98, 0x94, 0xef, 0x82, 0x3a, 0x8e, 0xc2, 0xd9, 0x14, 0xd3, 0xab, 0x76, 0x41, 0xb3,
-	0x4a, 0xb2, 0xd6, 0x39, 0x8e, 0x9a, 0x48, 0xec, 0x5f, 0x62, 0x0f, 0x9b, 0xde, 0x0b, 0xa3, 0xce,
-	0xe4, 0x3d, 0x8f, 0xbc, 0x3a, 0xe3, 0xb1, 0xfc, 0x7e, 0xfd, 0xa2, 0x57, 0x67, 0x3c, 0xa6, 0x8f,
-	0xe7, 0x73, 0x7b, 0xf5, 0xf7, 0xe6, 0xf6, 0x43, 0x48, 0xd3, 0xa7, 0xef, 0x4f, 0x46, 0x61, 0x63,
-	0x2d, 0xdf, 0x2f, 0x2e, 0xb2, 0x59, 0xc0, 0x6c, 0x91, 0xd9, 0xf7, 0x41, 0x3d, 0xf3, 0x27, 0xfd,
-	0x78, 0xea, 0x0d, 0x1b, 0xeb, 0x79, 0xfd, 0xc5, 0x7e, 0x14, 0xd5, 0x33, 0x7f, 0x42, 0x1b, 0x73,
-	0x03, 0xca, 0x81, 0x7f, 0xe2, 0x27, 0x8d, 0x2b, 0x17, 0xef, 0xcd, 0x24, 0xe0, 0x1a, 0x54, 0xc2,
-	0xd1, 0x08, 0xc7, 0xcf, 0x2e, 0xa8, 0xa4, 0x12, 0x7e, 0x1f, 0x64, 0x7b, 0xdf, 0x77, 0xbd, 0x51,
-	0xe3, 0xea, 0xa5, 0x95, 0x51, 0x4d, 0xb2, 0x63, 0x78, 0x13, 0xf0, 0x9e, 0xd9, 0x8f, 0xbc, 0x51,
-	0x83, 0x5f, 0x7e, 0xa5, 0xac, 0x84, 0x83, 0x17, 0x78, 0x9d, 0x7e, 0x08, 0xf5, 0x88, 0x6a, 0x6f,
-	0xdf, 0x75, 0x12, 0xa7, 0x71, 0x2d, 0x3f, 0x98, 0x45, 0x51, 0x16, 0x10, 0x2d, 0x0a, 0xf4, 0x7b,
-	0xb0, 0xe6, 0xbd, 0x4a, 0x22, 0xa7, 0x1f, 0x4e, 0xb1, 0x96, 0xc4, 0x8d, 0xeb, 0xb4, 0x45, 0x57,
-	0x09, 0xec, 0x4a, 0x8c, 0x6b, 0xb0, 0x3a, 0x8b, 0xbd, 0x1d, 0x2f, 0xf0, 0x12, 0xdc, 0xb7, 0x8d,
-	0x37, 0xa4, 0x4e, 0x1e, 0xd3, 0xfe, 0xaa, 0x08, 0x6a, 0xb6, 0x85, 0xe8, 0x0d, 0xd0, 0x7a, 0x62,
-	0x75, 0x9f, 0x5a, 0x6c, 0x05, 0x8b, 0xe0, 0xb1, 0xde, 0x39, 0x32, 0xfa, 0xbd, 0xb6, 0x6e, 0xc9,
-	0x87, 0x03, 0xba, 0xb4, 0x4a, 0xbe, 0xc0, 0xaf, 0xc2, 0xda, 0xee, 0x91, 0xd5, 0xb6, 0xcd, 0xae,
-	0x25, 0xa1, 0x22, 0x42, 0xc6, 0x57, 0xb2, 0x36, 0x4a, 0xa8, 0x84, 0xd0, 0x81, 0x6e, 0x1b, 0xc2,
-	0xcc, 0xa0, 0x32, 0x7e, 0xe5, 0x50, 0x74, 0xbf, 0x34, 0xda, 0x36, 0x03, 0xfe, 0x06, 0x5c, 0x9d,
-	0x9b, 0x64, 0xee, 0x58, 0x1d, 0xab, 0x6c, 0x66, 0xc6, 0xae, 0xa3, 0x13, 0x61, 0xb4, 0x8f, 0x44,
-	0xcf, 0x3c, 0x36, 0xfa, 0x6d, 0xdb, 0x60, 0x6f, 0xd0, 0x43, 0xa9, 0x69, 0x3d, 0x61, 0x37, 0xf8,
-	0x1a, 0xd4, 0x90, 0x92, 0xde, 0x6f, 0x52, 0x7d, 0xdf, 0xdb, 0x63, 0xb7, 0xb1, 0x68, 0xef, 0x9a,
-	0x1d, 0xdb, 0x10, 0xec, 0x5d, 0x7a, 0xbc, 0xeb, 0x9a, 0x96, 0xbc, 0x2e, 0xf7, 0xf4, 0x83, 0xc3,
-	0x8e, 0xc1, 0xee, 0x90, 0x8f, 0xae, 0xb0, 0x99, 0x46, 0x4f, 0x89, 0x16, 0x7e, 0xf9, 0x3d, 0x74,
-	0x47, 0x64, 0x5f, 0xef, 0x74, 0xd8, 0xfb, 0xb9, 0xd2, 0x7f, 0x17, 0xe9, 0xa7, 0xa6, 0xb5, 0xd3,
-	0x7d, 0x2a, 0x5f, 0x30, 0x5b, 0xa2, 0xab, 0xef, 0xb4, 0xf1, 0x84, 0xa0, 0x77, 0xcb, 0xde, 0x61,
-	0xc7, 0xb4, 0xd9, 0x07, 0xa8, 0xb5, 0xa7, 0xdb, 0xfb, 0x86, 0x60, 0xf7, 0xe8, 0x05, 0xb4, 0xd7,
-	0x33, 0x84, 0xcd, 0x9a, 0xf2, 0x6d, 0x96, 0xe8, 0x47, 0xe4, 0xf5, 0x90, 0x5e, 0x2c, 0xb7, 0x90,
-	0xde, 0x31, 0x3a, 0x86, 0x6d, 0xb0, 0x4f, 0xb5, 0x17, 0xa0, 0x66, 0x95, 0x41, 0x3e, 0xeb, 0x5a,
-	0x86, 0x90, 0x47, 0x55, 0xc7, 0xd8, 0xb5, 0x99, 0x82, 0xa0, 0x30, 0xf7, 0xf6, 0xf1, 0x90, 0xaa,
-	0x41, 0xb9, 0x7b, 0x84, 0xc3, 0x2b, 0xd2, 0x40, 0x8c, 0x03, 0x93, 0x95, 0x90, 0xd2, 0x2d, 0xdb,
-	0x64, 0x65, 0x1a, 0xa8, 0x69, 0xed, 0x75, 0x0c, 0x56, 0x41, 0xf4, 0x40, 0x17, 0x4f, 0x58, 0x95,
-	0x1e, 0x28, 0x0f, 0x0f, 0x3b, 0xcf, 0x98, 0xaa, 0x6d, 0x42, 0x55, 0x1f, 0x8f, 0x0f, 0xb0, 0xc4,
-	0xaa, 0x50, 0xda, 0x3d, 0xea, 0x74, 0xe4, 0x4b, 0x51, 0xab, 0x6b, 0xdb, 0xdd, 0x03, 0xd9, 0xf9,
-	0xda, 0xdd, 0x43, 0x56, 0xd0, 0xfe, 0xa6, 0x00, 0xe5, 0x5f, 0xe1, 0x5d, 0x9b, 0x6f, 0x43, 0x2d,
-	0x4e, 0x4e, 0x92, 0x7c, 0x2d, 0x7e, 0x53, 0xe6, 0x29, 0xc9, 0x1f, 0xf4, 0x12, 0x27, 0xf1, 0x4e,
-	0xbc, 0x49, 0x22, 0x2b, 0x32, 0xea, 0x52, 0x62, 0x51, 0xf7, 0xe4, 0x4d, 0x65, 0xa3, 0x50, 0x16,
-	0x92, 0xc1, 0x4d, 0x89, 0x85, 0x39, 0xeb, 0x39, 0x61, 0x51, 0x1f, 0x85, 0x14, 0xe0, 0xa6, 0x9c,
-	0x3a, 0x91, 0x73, 0x12, 0x5f, 0x52, 0x8a, 0x53, 0x09, 0x56, 0xe1, 0xe7, 0x9e, 0xe3, 0xfa, 0x93,
-	0x71, 0x76, 0xce, 0xcc, 0x79, 0xed, 0x29, 0xac, 0x2d, 0x85, 0xb4, 0x9c, 0xe1, 0x38, 0x45, 0x46,
-	0x07, 0xf3, 0x50, 0xc9, 0xad, 0x4e, 0x21, 0xb7, 0x22, 0xc5, 0xdc, 0x4a, 0x95, 0x70, 0xf2, 0x0e,
-	0x0c, 0xb1, 0x67, 0xb0, 0xb2, 0xf6, 0xdb, 0x02, 0x5c, 0xb5, 0x23, 0x67, 0x12, 0x53, 0x5b, 0xd2,
-	0x0e, 0x27, 0x49, 0x14, 0x06, 0xfc, 0xe7, 0xa0, 0x26, 0xc3, 0x20, 0x3f, 0x3b, 0xef, 0xa6, 0xe5,
-	0xe1, 0x75, 0xd5, 0x07, 0xf6, 0x30, 0xa0, 0x39, 0xaa, 0x26, 0x92, 0xe0, 0x1f, 0x41, 0x79, 0xe0,
-	0x8d, 0xfd, 0x49, 0xda, 0x0c, 0xbf, 0xf1, 0xba, 0x61, 0x0b, 0x85, 0x74, 0x79, 0x44, 0x82, 0x7f,
-	0x02, 0x95, 0x61, 0x78, 0x82, 0x15, 0x4d, 0x1e, 0x66, 0x37, 0x2e, 0x7e, 0x08, 0xa5, 0x78, 0x6d,
-	0x97, 0x7a, 0x7c, 0x1b, 0xd4, 0x28, 0x0c, 0x82, 0x81, 0x33, 0x7c, 0x99, 0xde, 0xe6, 0x1a, 0xaf,
-	0xdb, 0x88, 0x54, 0x8e, 0x37, 0xe7, 0x4c, 0x57, 0x7b, 0x00, 0xd5, 0x34, 0x58, 0x7a, 0xaa, 0x36,
-	0xf6, 0xcc, 0x74, 0xee, 0xda, 0xdd, 0x83, 0x03, 0x13, 0xe7, 0x6e, 0x15, 0x54, 0xd1, 0xed, 0x74,
-	0x5a, 0x7a, 0xfb, 0x09, 0x2b, 0xb4, 0x54, 0xa8, 0x38, 0xf4, 0x76, 0xa3, 0xfd, 0xb9, 0x02, 0x57,
-	0x5e, 0x1b, 0x00, 0x7f, 0x0c, 0xa5, 0x93, 0xd0, 0xcd, 0xa6, 0xe7, 0xfd, 0x4b, 0x47, 0x99, 0xe3,
-	0x31, 0x3d, 0x05, 0x59, 0x68, 0x9f, 0xc1, 0xfa, 0x32, 0x9e, 0x7b, 0x5f, 0x5b, 0x83, 0x9a, 0x30,
-	0xf4, 0x9d, 0x7e, 0xd7, 0xea, 0x3c, 0x93, 0xa5, 0x8a, 0xd8, 0xa7, 0xc2, 0xb4, 0x0d, 0x56, 0xd0,
-	0xbe, 0x01, 0xf6, 0xfa, 0xc4, 0xf0, 0x3d, 0xb8, 0x32, 0x0c, 0x4f, 0xa6, 0x81, 0x47, 0xbd, 0x5a,
-	0x6e, 0xc9, 0x6e, 0x5f, 0x32, 0x93, 0xa9, 0x1a, 0xad, 0xd8, 0xfa, 0x70, 0x89, 0xd7, 0xfe, 0x04,
-	0xf8, 0xc5, 0x19, 0xfc, 0xff, 0x73, 0xff, 0x97, 0x0a, 0x94, 0x0e, 0x03, 0x67, 0xc2, 0xdf, 0x83,
-	0x32, 0x3d, 0x78, 0xa5, 0x9d, 0x73, 0x3d, 0xb7, 0xef, 0x30, 0x2d, 0x48, 0xc6, 0xef, 0x43, 0x31,
-	0x19, 0x06, 0x69, 0x0e, 0xdd, 0xfc, 0x9e, 0xe4, 0xc3, 0x9b, 0x55, 0x32, 0x0c, 0xf8, 0x26, 0x14,
-	0x5d, 0x37, 0x48, 0x13, 0xe8, 0x7a, 0x7a, 0xb5, 0x77, 0x12, 0x67, 0xc7, 0x1b, 0xf9, 0x13, 0x3f,
-	0x7d, 0x7e, 0x43, 0x95, 0x56, 0x05, 0xe8, 0x77, 0x38, 0xed, 0xcf, 0x6a, 0xb0, 0xbe, 0xac, 0xc1,
-	0xff, 0x10, 0x54, 0xd7, 0x5d, 0xca, 0xf9, 0x5b, 0x97, 0x79, 0x7a, 0xb0, 0xe3, 0xa6, 0x09, 0xef,
-	0x4a, 0x82, 0xdf, 0xc9, 0xc6, 0x53, 0xb8, 0x30, 0x9e, 0x6c, 0x34, 0x5f, 0xc0, 0x95, 0x61, 0xe4,
-	0x61, 0x57, 0x80, 0x07, 0xe3, 0xc0, 0x89, 0xbd, 0xe5, 0x60, 0xdb, 0x24, 0xdc, 0x49, 0x65, 0xfb,
-	0x2b, 0x62, 0x7d, 0xb8, 0x84, 0xf0, 0xcf, 0x61, 0xdd, 0xa1, 0x6e, 0x69, 0x6e, 0x5f, 0xca, 0xdf,
-	0x1f, 0x75, 0x94, 0xe5, 0xcc, 0xd7, 0x9c, 0x3c, 0xc0, 0x3f, 0x83, 0x35, 0x37, 0x0a, 0xa7, 0x0b,
-	0x63, 0xf9, 0x84, 0x99, 0x3e, 0xa6, 0xec, 0x44, 0xe1, 0x34, 0x67, 0xbb, 0xea, 0xe6, 0x78, 0xbe,
-	0x0d, 0xab, 0x69, 0xe4, 0xd4, 0x0f, 0xa4, 0x8f, 0x9b, 0x57, 0xf3, 0x61, 0x53, 0xcb, 0xb0, 0xbf,
-	0x22, 0xea, 0xc3, 0x05, 0xcb, 0x1f, 0x41, 0x5d, 0x06, 0x2c, 0xcd, 0xaa, 0xf9, 0x56, 0x80, 0xa2,
-	0xcd, 0xac, 0xc0, 0x99, 0x73, 0xfc, 0x13, 0x00, 0x8a, 0x53, 0xda, 0xa8, 0xf9, 0x66, 0x03, 0x83,
-	0xcc, 0x4c, 0x6a, 0x6e, 0xc6, 0xe4, 0xc2, 0xf3, 0xf1, 0xb6, 0x9d, 0x3e, 0x86, 0x2e, 0x85, 0x47,
-	0xd7, 0xf0, 0x45, 0x78, 0xc4, 0x2e, 0xc2, 0x93, 0x66, 0x70, 0x21, 0xbc, 0xcc, 0x4a, 0x86, 0x27,
-	0x8d, 0xb2, 0xf0, 0xa4, 0x4d, 0xfd, 0xf5, 0xf0, 0x32, 0x13, 0x0a, 0x4f, 0x5a, 0x7c, 0x0e, 0xeb,
-	0x49, 0x34, 0x9b, 0x0c, 0x17, 0xf3, 0xb7, 0x9a, 0x5f, 0x36, 0x3b, 0x95, 0x65, 0x03, 0x5b, 0x4b,
-	0xf2, 0x00, 0x5a, 0xc7, 0xcf, 0xc3, 0xb3, 0xfe, 0xa9, 0x13, 0xf9, 0x08, 0xc4, 0x69, 0x3b, 0x99,
-	0x5a, 0xf7, 0x9e, 0x87, 0x67, 0xc7, 0x99, 0x08, 0xad, 0xe3, 0x3c, 0xa0, 0xfd, 0x5d, 0x11, 0xaa,
-	0x69, 0xae, 0xf2, 0x6b, 0x70, 0xa5, 0x2d, 0x0c, 0xdd, 0x36, 0xfa, 0x3b, 0xba, 0xad, 0xb7, 0xf4,
-	0x1e, 0xd6, 0x1a, 0x0e, 0xeb, 0x3a, 0xb6, 0x15, 0x0b, 0x4c, 0xc1, 0x06, 0x65, 0x47, 0x74, 0x0f,
-	0x17, 0x50, 0x81, 0x33, 0x58, 0x4d, 0x6d, 0xe5, 0x53, 0x7f, 0x11, 0xaf, 0x99, 0xd2, 0x50, 0x02,
-	0x25, 0xfa, 0xf1, 0x14, 0xad, 0x24, 0x5f, 0xce, 0x99, 0x98, 0xd6, 0x8e, 0xf1, 0x15, 0xab, 0x2c,
-	0x4c, 0x24, 0x50, 0x9d, 0x9b, 0x48, 0x5e, 0xc5, 0x60, 0x6c, 0x71, 0x64, 0xb5, 0x17, 0xdf, 0xa9,
-	0xf1, 0x9b, 0x70, 0xad, 0xb7, 0xdf, 0x7d, 0xda, 0x97, 0xbe, 0xe6, 0x21, 0x01, 0xbf, 0x0e, 0x2c,
-	0x27, 0x90, 0xea, 0x75, 0x74, 0x41, 0x68, 0xa6, 0xd8, 0x63, 0xab, 0xf8, 0x5d, 0xc2, 0x48, 0xa7,
-	0xc7, 0xd6, 0x30, 0x34, 0x69, 0xda, 0xed, 0x1c, 0x1d, 0x58, 0x3d, 0xb6, 0x8e, 0x91, 0x10, 0x22,
-	0x23, 0xb9, 0x32, 0x77, 0x73, 0xac, 0x0b, 0x53, 0x5a, 0x31, 0x9c, 0x16, 0xc2, 0x9e, 0xea, 0xc2,
-	0x32, 0xad, 0xbd, 0x1e, 0xbb, 0x3a, 0xf7, 0x6c, 0x08, 0xd1, 0x15, 0x3d, 0xc6, 0xe7, 0x40, 0xcf,
-	0xd6, 0xed, 0xa3, 0x1e, 0xbb, 0x36, 0x8f, 0xf2, 0x50, 0x74, 0xdb, 0x46, 0xaf, 0xd7, 0x31, 0x7b,
-	0x36, 0xbb, 0xde, 0x5a, 0x05, 0x70, 0xe7, 0xc5, 0x44, 0x3b, 0x84, 0xf5, 0xe5, 0xbd, 0xcf, 0x35,
-	0x58, 0xf3, 0x47, 0xfd, 0x49, 0x98, 0xf4, 0xe9, 0xd1, 0x3c, 0x4e, 0x9f, 0xd0, 0xeb, 0xfe, 0xc8,
-	0x0a, 0x13, 0x83, 0x20, 0xec, 0x14, 0xe6, 0x5b, 0x59, 0xbe, 0x2c, 0xcc, 0x79, 0x6d, 0x1f, 0xd6,
-	0x96, 0xaa, 0x01, 0x7f, 0x1b, 0x6a, 0xfe, 0x68, 0xd9, 0x99, 0xea, 0x8f, 0x7e, 0x84, 0xa7, 0x3d,
-	0x58, 0xcd, 0x97, 0x86, 0x9f, 0xee, 0xe8, 0xef, 0x15, 0xa8, 0xe7, 0x4a, 0xc5, 0x8f, 0x1a, 0xe2,
-	0x2d, 0xa8, 0x25, 0xde, 0xc9, 0x34, 0x8c, 0x9c, 0xb4, 0xb0, 0xaa, 0x62, 0x01, 0x2c, 0x7d, 0xad,
-	0xb8, 0xfc, 0xb5, 0xe5, 0xbb, 0x4d, 0xe9, 0x87, 0xef, 0x36, 0x5a, 0x17, 0x60, 0x51, 0x8d, 0xe8,
-	0x15, 0x8c, 0x76, 0xa9, 0x7c, 0x61, 0x90, 0xcc, 0xb2, 0xc3, 0xc2, 0xef, 0x71, 0xf8, 0x35, 0xd4,
-	0xe6, 0xa5, 0xea, 0x27, 0xcf, 0xd8, 0x22, 0x90, 0x62, 0x2e, 0x10, 0x6d, 0x2f, 0x9b, 0x46, 0x59,
-	0x5c, 0x7e, 0xcc, 0x34, 0x5e, 0x87, 0xb2, 0xac, 0x56, 0xe9, 0x33, 0x2d, 0x31, 0x9a, 0x96, 0x8e,
-	0x5a, 0xfa, 0x99, 0xeb, 0x28, 0x79, 0x9d, 0x5f, 0xc8, 0x81, 0x48, 0x95, 0x1f, 0x1c, 0xc8, 0xe5,
-	0xdf, 0xb8, 0x0b, 0x6b, 0x4b, 0xe5, 0xed, 0xf2, 0xc9, 0xd5, 0x4c, 0x58, 0x5b, 0xaa, 0x63, 0xfc,
-	0x06, 0x54, 0xc6, 0x41, 0x38, 0x70, 0xe6, 0xff, 0x1a, 0x20, 0x39, 0xec, 0xb1, 0xcf, 0x9e, 0x7b,
-	0x91, 0x77, 0xc9, 0x2f, 0x96, 0x52, 0x70, 0xef, 0x0e, 0xac, 0xe6, 0x7f, 0x17, 0xa0, 0xae, 0x2a,
-	0x9c, 0x78, 0x6c, 0x05, 0x2f, 0x00, 0x9d, 0x5f, 0x6f, 0x31, 0xe5, 0xde, 0x2f, 0xa1, 0xf1, 0x7d,
-	0xfd, 0x0a, 0xf6, 0x84, 0xed, 0x7d, 0x9d, 0x7a, 0xc2, 0x55, 0x50, 0xad, 0x6e, 0x5f, 0x72, 0x0a,
-	0xb6, 0xda, 0xc2, 0xe8, 0x18, 0x54, 0x0d, 0x5b, 0x5f, 0xfc, 0xee, 0xbb, 0xdb, 0xca, 0xbf, 0x7f,
-	0x77, 0x5b, 0xf9, 0xef, 0xef, 0x6e, 0xaf, 0xfc, 0xe3, 0xff, 0xde, 0x56, 0xbe, 0xce, 0xff, 0x4b,
-	0xcf, 0x89, 0x93, 0x44, 0xfe, 0xab, 0x30, 0xf2, 0xc7, 0xfe, 0x24, 0x63, 0x26, 0xde, 0xc7, 0xd3,
-	0x97, 0xe3, 0x8f, 0xa7, 0x83, 0x8f, 0x31, 0xe2, 0x41, 0x85, 0xfe, 0xb3, 0xe7, 0xd1, 0xff, 0x05,
-	0x00, 0x00, 0xff, 0xff, 0x7c, 0xe0, 0x53, 0x88, 0x1c, 0x24, 0x00, 0x00,
+	// 4248 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,
 }
 
 func (m *Type) Marshal() (dAtA []byte, err error) {
@@ -4966,6 +5063,100 @@ func (m *Const_Bval) MarshalToSizedBuffer(dAtA []byte) (int, error) {
 	dAtA[i] = 0x28
 	return len(dAtA) - i, nil
 }
+func (m *Const_Uval) MarshalTo(dAtA []byte) (int, error) {
+	size := m.ProtoSize()
+	return m.MarshalToSizedBuffer(dAtA[:size])
+}
+
+func (m *Const_Uval) MarshalToSizedBuffer(dAtA []byte) (int, error) {
+	i := len(dAtA)
+	i = encodeVarintPlan(dAtA, i, uint64(m.Uval))
+	i--
+	dAtA[i] = 0x30
+	return len(dAtA) - i, nil
+}
+func (m *Const_Fval) MarshalTo(dAtA []byte) (int, error) {
+	size := m.ProtoSize()
+	return m.MarshalToSizedBuffer(dAtA[:size])
+}
+
+func (m *Const_Fval) MarshalToSizedBuffer(dAtA []byte) (int, error) {
+	i := len(dAtA)
+	i -= 4
+	encoding_binary.LittleEndian.PutUint32(dAtA[i:], uint32(math.Float32bits(float32(m.Fval))))
+	i--
+	dAtA[i] = 0x3d
+	return len(dAtA) - i, nil
+}
+func (m *Const_Dateval) MarshalTo(dAtA []byte) (int, error) {
+	size := m.ProtoSize()
+	return m.MarshalToSizedBuffer(dAtA[:size])
+}
+
+func (m *Const_Dateval) MarshalToSizedBuffer(dAtA []byte) (int, error) {
+	i := len(dAtA)
+	i = encodeVarintPlan(dAtA, i, uint64(m.Dateval))
+	i--
+	dAtA[i] = 0x40
+	return len(dAtA) - i, nil
+}
+func (m *Const_Datetimeval) MarshalTo(dAtA []byte) (int, error) {
+	size := m.ProtoSize()
+	return m.MarshalToSizedBuffer(dAtA[:size])
+}
+
+func (m *Const_Datetimeval) MarshalToSizedBuffer(dAtA []byte) (int, error) {
+	i := len(dAtA)
+	i = encodeVarintPlan(dAtA, i, uint64(m.Datetimeval))
+	i--
+	dAtA[i] = 0x48
+	return len(dAtA) - i, nil
+}
+func (m *Const_Decimal64Val) MarshalTo(dAtA []byte) (int, error) {
+	size := m.ProtoSize()
+	return m.MarshalToSizedBuffer(dAtA[:size])
+}
+
+func (m *Const_Decimal64Val) MarshalToSizedBuffer(dAtA []byte) (int, error) {
+	i := len(dAtA)
+	i = encodeVarintPlan(dAtA, i, uint64(m.Decimal64Val))
+	i--
+	dAtA[i] = 0x50
+	return len(dAtA) - i, nil
+}
+func (m *Const_Decimal128Val) MarshalTo(dAtA []byte) (int, error) {
+	size := m.ProtoSize()
+	return m.MarshalToSizedBuffer(dAtA[:size])
+}
+
+func (m *Const_Decimal128Val) MarshalToSizedBuffer(dAtA []byte) (int, error) {
+	i := len(dAtA)
+	if m.Decimal128Val != nil {
+		{
+			size, err := m.Decimal128Val.MarshalToSizedBuffer(dAtA[:i])
+			if err != nil {
+				return 0, err
+			}
+			i -= size
+			i = encodeVarintPlan(dAtA, i, uint64(size))
+		}
+		i--
+		dAtA[i] = 0x5a
+	}
+	return len(dAtA) - i, nil
+}
+func (m *Const_Timestampval) MarshalTo(dAtA []byte) (int, error) {
+	size := m.ProtoSize()
+	return m.MarshalToSizedBuffer(dAtA[:size])
+}
+
+func (m *Const_Timestampval) MarshalToSizedBuffer(dAtA []byte) (int, error) {
+	i := len(dAtA)
+	i = encodeVarintPlan(dAtA, i, uint64(m.Timestampval))
+	i--
+	dAtA[i] = 0x60
+	return len(dAtA) - i, nil
+}
 func (m *ParamRef) Marshal() (dAtA []byte, err error) {
 	size := m.ProtoSize()
 	dAtA = make([]byte, size)
@@ -6431,9 +6622,9 @@ func (m *ColData) MarshalToSizedBuffer(dAtA []byte) (int, error) {
 	}
 	if len(m.F64) > 0 {
 		for iNdEx := len(m.F64) - 1; iNdEx >= 0; iNdEx-- {
-			f21 := math.Float64bits(float64(m.F64[iNdEx]))
+			f22 := math.Float64bits(float64(m.F64[iNdEx]))
 			i -= 8
-			encoding_binary.LittleEndian.PutUint64(dAtA[i:], uint64(f21))
+			encoding_binary.LittleEndian.PutUint64(dAtA[i:], uint64(f22))
 		}
 		i = encodeVarintPlan(dAtA, i, uint64(len(m.F64)*8))
 		i--
@@ -6441,49 +6632,49 @@ func (m *ColData) MarshalToSizedBuffer(dAtA []byte) (int, error) {
 	}
 	if len(m.F32) > 0 {
 		for iNdEx := len(m.F32) - 1; iNdEx >= 0; iNdEx-- {
-			f22 := math.Float32bits(float32(m.F32[iNdEx]))
+			f23 := math.Float32bits(float32(m.F32[iNdEx]))
 			i -= 4
-			encoding_binary.LittleEndian.PutUint32(dAtA[i:], uint32(f22))
+			encoding_binary.LittleEndian.PutUint32(dAtA[i:], uint32(f23))
 		}
 		i = encodeVarintPlan(dAtA, i, uint64(len(m.F32)*4))
 		i--
 		dAtA[i] = 0x32
 	}
 	if len(m.I64) > 0 {
-		dAtA24 := make([]byte, len(m.I64)*10)
-		var j23 int
+		dAtA25 := make([]byte, len(m.I64)*10)
+		var j24 int
 		for _, num1 := range m.I64 {
 			num := uint64(num1)
 			for num >= 1<<7 {
-				dAtA24[j23] = uint8(uint64(num)&0x7f | 0x80)
+				dAtA25[j24] = uint8(uint64(num)&0x7f | 0x80)
 				num >>= 7
-				j23++
+				j24++
 			}
-			dAtA24[j23] = uint8(num)
-			j23++
+			dAtA25[j24] = uint8(num)
+			j24++
 		}
-		i -= j23
-		copy(dAtA[i:], dAtA24[:j23])
-		i = encodeVarintPlan(dAtA, i, uint64(j23))
+		i -= j24
+		copy(dAtA[i:], dAtA25[:j24])
+		i = encodeVarintPlan(dAtA, i, uint64(j24))
 		i--
 		dAtA[i] = 0x2a
 	}
 	if len(m.I32) > 0 {
-		dAtA26 := make([]byte, len(m.I32)*10)
-		var j25 int
+		dAtA27 := make([]byte, len(m.I32)*10)
+		var j26 int
 		for _, num1 := range m.I32 {
 			num := uint64(num1)
 			for num >= 1<<7 {
-				dAtA26[j25] = uint8(uint64(num)&0x7f | 0x80)
+				dAtA27[j26] = uint8(uint64(num)&0x7f | 0x80)
 				num >>= 7
-				j25++
+				j26++
 			}
-			dAtA26[j25] = uint8(num)
-			j25++
+			dAtA27[j26] = uint8(num)
+			j26++
 		}
-		i -= j25
-		copy(dAtA[i:], dAtA26[:j25])
-		i = encodeVarintPlan(dAtA, i, uint64(j25))
+		i -= j26
+		copy(dAtA[i:], dAtA27[:j26])
+		i = encodeVarintPlan(dAtA, i, uint64(j26))
 		i--
 		dAtA[i] = 0x22
 	}
@@ -6979,21 +7170,21 @@ func (m *Node) MarshalToSizedBuffer(dAtA []byte) (int, error) {
 		dAtA[i] = 0x30
 	}
 	if len(m.Children) > 0 {
-		dAtA37 := make([]byte, len(m.Children)*10)
-		var j36 int
+		dAtA38 := make([]byte, len(m.Children)*10)
+		var j37 int
 		for _, num1 := range m.Children {
 			num := uint64(num1)
 			for num >= 1<<7 {
-				dAtA37[j36] = uint8(uint64(num)&0x7f | 0x80)
+				dAtA38[j37] = uint8(uint64(num)&0x7f | 0x80)
 				num >>= 7
-				j36++
+				j37++
 			}
-			dAtA37[j36] = uint8(num)
-			j36++
+			dAtA38[j37] = uint8(num)
+			j37++
 		}
-		i -= j36
-		copy(dAtA[i:], dAtA37[:j36])
-		i = encodeVarintPlan(dAtA, i, uint64(j36))
+		i -= j37
+		copy(dAtA[i:], dAtA38[:j37])
+		i = encodeVarintPlan(dAtA, i, uint64(j37))
 		i--
 		dAtA[i] = 0x2a
 	}
@@ -7098,21 +7289,21 @@ func (m *Query) MarshalToSizedBuffer(dAtA []byte) (int, error) {
 		}
 	}
 	if len(m.Steps) > 0 {
-		dAtA40 := make([]byte, len(m.Steps)*10)
-		var j39 int
+		dAtA41 := make([]byte, len(m.Steps)*10)
+		var j40 int
 		for _, num1 := range m.Steps {
 			num := uint64(num1)
 			for num >= 1<<7 {
-				dAtA40[j39] = uint8(uint64(num)&0x7f | 0x80)
+				dAtA41[j40] = uint8(uint64(num)&0x7f | 0x80)
 				num >>= 7
-				j39++
+				j40++
 			}
-			dAtA40[j39] = uint8(num)
-			j39++
+			dAtA41[j40] = uint8(num)
+			j40++
 		}
-		i -= j39
-		copy(dAtA[i:], dAtA40[:j39])
-		i = encodeVarintPlan(dAtA, i, uint64(j39))
+		i -= j40
+		copy(dAtA[i:], dAtA41[:j40])
+		i = encodeVarintPlan(dAtA, i, uint64(j40))
 		i--
 		dAtA[i] = 0x12
 	}
@@ -8305,6 +8496,72 @@ func (m *Const_Bval) ProtoSize() (n int) {
 	n += 2
 	return n
 }
+func (m *Const_Uval) ProtoSize() (n int) {
+	if m == nil {
+		return 0
+	}
+	var l int
+	_ = l
+	n += 1 + sovPlan(uint64(m.Uval))
+	return n
+}
+func (m *Const_Fval) ProtoSize() (n int) {
+	if m == nil {
+		return 0
+	}
+	var l int
+	_ = l
+	n += 5
+	return n
+}
+func (m *Const_Dateval) ProtoSize() (n int) {
+	if m == nil {
+		return 0
+	}
+	var l int
+	_ = l
+	n += 1 + sovPlan(uint64(m.Dateval))
+	return n
+}
+func (m *Const_Datetimeval) ProtoSize() (n int) {
+	if m == nil {
+		return 0
+	}
+	var l int
+	_ = l
+	n += 1 + sovPlan(uint64(m.Datetimeval))
+	return n
+}
+func (m *Const_Decimal64Val) ProtoSize() (n int) {
+	if m == nil {
+		return 0
+	}
+	var l int
+	_ = l
+	n += 1 + sovPlan(uint64(m.Decimal64Val))
+	return n
+}
+func (m *Const_Decimal128Val) ProtoSize() (n int) {
+	if m == nil {
+		return 0
+	}
+	var l int
+	_ = l
+	if m.Decimal128Val != nil {
+		l = m.Decimal128Val.ProtoSize()
+		n += 1 + l + sovPlan(uint64(l))
+	}
+	return n
+}
+func (m *Const_Timestampval) ProtoSize() (n int) {
+	if m == nil {
+		return 0
+	}
+	var l int
+	_ = l
+	n += 1 + sovPlan(uint64(m.Timestampval))
+	return n
+}
 func (m *ParamRef) ProtoSize() (n int) {
 	if m == nil {
 		return 0
@@ -10166,6 +10423,152 @@ func (m *Const) Unmarshal(dAtA []byte) error {
 			}
 			b := bool(v != 0)
 			m.Value = &Const_Bval{b}
+		case 6:
+			if wireType != 0 {
+				return fmt.Errorf("proto: wrong wireType = %d for field Uval", wireType)
+			}
+			var v uint64
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowPlan
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				v |= uint64(b&0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+			m.Value = &Const_Uval{v}
+		case 7:
+			if wireType != 5 {
+				return fmt.Errorf("proto: wrong wireType = %d for field Fval", wireType)
+			}
+			var v uint32
+			if (iNdEx + 4) > l {
+				return io.ErrUnexpectedEOF
+			}
+			v = uint32(encoding_binary.LittleEndian.Uint32(dAtA[iNdEx:]))
+			iNdEx += 4
+			m.Value = &Const_Fval{float32(math.Float32frombits(v))}
+		case 8:
+			if wireType != 0 {
+				return fmt.Errorf("proto: wrong wireType = %d for field Dateval", wireType)
+			}
+			var v int32
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowPlan
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				v |= int32(b&0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+			m.Value = &Const_Dateval{v}
+		case 9:
+			if wireType != 0 {
+				return fmt.Errorf("proto: wrong wireType = %d for field Datetimeval", wireType)
+			}
+			var v int64
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowPlan
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				v |= int64(b&0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+			m.Value = &Const_Datetimeval{v}
+		case 10:
+			if wireType != 0 {
+				return fmt.Errorf("proto: wrong wireType = %d for field Decimal64Val", wireType)
+			}
+			var v int64
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowPlan
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				v |= int64(b&0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+			m.Value = &Const_Decimal64Val{v}
+		case 11:
+			if wireType != 2 {
+				return fmt.Errorf("proto: wrong wireType = %d for field Decimal128Val", 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 := &Decimal128{}
+			if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
+				return err
+			}
+			m.Value = &Const_Decimal128Val{v}
+			iNdEx = postIndex
+		case 12:
+			if wireType != 0 {
+				return fmt.Errorf("proto: wrong wireType = %d for field Timestampval", wireType)
+			}
+			var v int64
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowPlan
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				v |= int64(b&0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+			m.Value = &Const_Timestampval{v}
 		default:
 			iNdEx = preIndex
 			skippy, err := skipPlan(dAtA[iNdEx:])
diff --git a/pkg/sql/colexec2/expr_eval.go b/pkg/sql/colexec2/expr_eval.go
index 1d44e4326..49d415175 100644
--- a/pkg/sql/colexec2/expr_eval.go
+++ b/pkg/sql/colexec2/expr_eval.go
@@ -29,10 +29,17 @@ import (
 )
 
 var (
-	constBType = types.Type{Oid: types.T_bool}
-	constIType = types.Type{Oid: types.T_int64}
-	constDType = types.Type{Oid: types.T_float64}
-	constSType = types.Type{Oid: types.T_varchar}
+	constBType          = types.Type{Oid: types.T_bool}
+	constIType          = types.Type{Oid: types.T_int64}
+	constUType          = types.Type{Oid: types.T_uint64}
+	constFType          = types.Type{Oid: types.T_float32}
+	constDType          = types.Type{Oid: types.T_float64}
+	constSType          = types.Type{Oid: types.T_varchar}
+	constDateType       = types.Type{Oid: types.T_date}
+	constDatetimeType   = types.Type{Oid: types.T_datetime}
+	constDecimal64Type  = types.Type{Oid: types.T_decimal64}
+	constDecimal128Type = types.Type{Oid: types.T_decimal128}
+	constTimestampType  = types.Type{Oid: types.T_timestamp}
 )
 
 func EvalExpr(bat *batch.Batch, proc *process.Process, expr *plan.Expr) (*vector.Vector, error) {
@@ -51,9 +58,31 @@ func EvalExpr(bat *batch.Batch, proc *process.Process, expr *plan.Expr) (*vector
 			case *plan.Const_Ival:
 				vec = vector.NewConst(constIType)
 				vec.Col = []int64{t.C.GetIval()}
+			case *plan.Const_Fval:
+				vec = vector.NewConst(constFType)
+				vec.Col = []float32{t.C.GetFval()}
+			case *plan.Const_Uval:
+				vec = vector.NewConst(constUType)
+				vec.Col = []uint64{t.C.GetUval()}
 			case *plan.Const_Dval:
 				vec = vector.NewConst(constDType)
 				vec.Col = []float64{t.C.GetDval()}
+			case *plan.Const_Dateval:
+				vec = vector.NewConst(constDateType)
+				vec.Col = []types.Date{types.Date(t.C.GetDateval())}
+			case *plan.Const_Datetimeval:
+				vec = vector.NewConst(constDatetimeType)
+				vec.Col = []types.Datetime{types.Datetime(t.C.GetDatetimeval())}
+			case *plan.Const_Decimal64Val:
+				vec = vector.NewConst(constDecimal64Type)
+				vec.Col = []types.Decimal64{types.Decimal64(t.C.GetDecimal64Val())}
+			case *plan.Const_Decimal128Val:
+				vec = vector.NewConst(constDecimal128Type)
+				d128 := t.C.GetDecimal128Val()
+				vec.Col = []types.Decimal128{{Lo: d128.Lo, Hi: d128.Hi}}
+			case *plan.Const_Timestampval:
+				vec = vector.NewConst(constTimestampType)
+				vec.Col = []types.Timestamp{types.Timestamp(t.C.GetTimestampval())}
 			case *plan.Const_Sval:
 				vec = vector.NewConst(constSType)
 				sval := t.C.GetSval()
@@ -77,7 +106,11 @@ func EvalExpr(bat *batch.Batch, proc *process.Process, expr *plan.Expr) (*vector
 			Precision: t.T.Typ.GetPrecision(),
 		}), nil
 	case *plan.Expr_Col:
-		return bat.Vecs[t.Col.ColPos], nil
+		vec := bat.Vecs[t.Col.ColPos]
+		if vec.IsScalarNull() {
+			vec.Typ = types.T(expr.Typ.GetId()).ToType()
+		}
+		return vec, nil
 	case *plan.Expr_F:
 		overloadId := t.F.Func.GetObj()
 		f, err := function.GetFunctionByID(overloadId)
diff --git a/pkg/sql/colexec2/insert/insert.go b/pkg/sql/colexec2/insert/insert.go
new file mode 100644
index 000000000..de3d6d6e3
--- /dev/null
+++ b/pkg/sql/colexec2/insert/insert.go
@@ -0,0 +1,81 @@
+// 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 insert
+
+import (
+	"bytes"
+	"fmt"
+	"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/errno"
+	"github.com/matrixorigin/matrixone/pkg/pb/plan"
+	"github.com/matrixorigin/matrixone/pkg/sql/errors"
+	"github.com/matrixorigin/matrixone/pkg/vm/engine"
+	"github.com/matrixorigin/matrixone/pkg/vm/process"
+)
+
+type Argument struct {
+	Ts            uint64
+	TargetTable   engine.Relation
+	TargetColDefs []*plan.ColDef
+	Affected      uint64
+}
+
+func String(_ interface{}, buf *bytes.Buffer) {
+	buf.WriteString("insert select")
+}
+
+func Prepare(_ *process.Process, _ interface{}) error {
+	return nil
+}
+
+func Call(proc *process.Process, arg interface{}) (bool, error) {
+	n := arg.(*Argument)
+	bat := proc.Reg.InputBatch
+	if bat == nil {
+		return true, nil
+	}
+	if len(bat.Zs) == 0 {
+		return false, nil
+	}
+	{
+		// do null value check
+		for i := range bat.Vecs {
+			if n.TargetColDefs[i].Primary {
+				if nulls.Any(bat.Vecs[i].Nsp) {
+					return false, errors.New(errno.IntegrityConstraintViolation,
+						fmt.Sprintf("Column '%s' cannot be null", n.TargetColDefs[i].GetName()))
+				}
+			}
+		}
+	}
+	{
+		bat.Ro = false
+		bat.Attrs = make([]string, len(bat.Vecs))
+		// scalar vector's extension
+		for i := range bat.Vecs {
+			bat.Attrs[i] = n.TargetColDefs[i].GetName()
+			if bat.Vecs[i].IsScalarNull() && bat.Vecs[i].Typ.Oid != types.T_any {
+				vector.PreAlloc(bat.Vecs[i], bat.Vecs[i], bat.Vecs[i].Length, proc.Mp)
+				vector.SetLength(bat.Vecs[i], bat.Vecs[i].Length)
+			}
+			bat.Vecs[i] = bat.Vecs[i].ConstExpand(proc.Mp)
+		}
+	}
+	err := n.TargetTable.Write(n.Ts, bat, proc.Snapshot)
+	n.Affected += uint64(len(bat.Zs))
+	return false, err
+}
diff --git a/pkg/sql/colexec2/restrict/restrict.go b/pkg/sql/colexec2/restrict/restrict.go
index 1600340ec..6d8371d2f 100644
--- a/pkg/sql/colexec2/restrict/restrict.go
+++ b/pkg/sql/colexec2/restrict/restrict.go
@@ -19,7 +19,6 @@ import (
 	"fmt"
 
 	"github.com/matrixorigin/matrixone/pkg/container/vector"
-	"github.com/matrixorigin/matrixone/pkg/errno"
 	"github.com/matrixorigin/matrixone/pkg/sql/errors"
 
 	colexec "github.com/matrixorigin/matrixone/pkg/sql/colexec2"
@@ -52,7 +51,7 @@ func Call(proc *process.Process, arg interface{}) (bool, error) {
 	defer vector.Clean(vec, proc.Mp)
 	bs, ok := vec.Col.([]bool)
 	if !ok {
-		return false, errors.New(errno.SyntaxError, "only support logic expression to be filter condition")
+		return false, errors.New("", "Only bool expression can be used as filter condition.")
 	}
 	if vec.IsScalar() {
 		if !bs[0] {
diff --git a/pkg/sql/colexec2/update/update.go b/pkg/sql/colexec2/update/update.go
index 70280ae0e..63bec89b2 100644
--- a/pkg/sql/colexec2/update/update.go
+++ b/pkg/sql/colexec2/update/update.go
@@ -16,7 +16,6 @@ package update
 
 import (
 	"bytes"
-	"fmt"
 	"github.com/matrixorigin/matrixone/pkg/container/batch"
 	"github.com/matrixorigin/matrixone/pkg/container/vector"
 	"github.com/matrixorigin/matrixone/pkg/vm/process"
@@ -39,16 +38,10 @@ func Call(proc *process.Process, arg interface{}) (bool, error) {
 
 	affectedRows := uint64(batch.Length(bat))
 	// Fill vector for constant value
-	// -------- need to remove ----------
-	allAttrs := append(p.UpdateAttrs, p.OtherAttrs...)
-	// ----------------------------------
 	for i := range bat.Vecs {
 		if i == 0 {
 			continue
 		}
-		if bat.Vecs[i].Nsp.Np != nil {
-			return false, fmt.Errorf("%s can't be updated as NULL value now, which will be fixed in 0.5", allAttrs[i-1])
-		}
 		if bat.Vecs[i].IsScalar() {
 			if err := vector.ConstantPadding(bat.Vecs[i], affectedRows); err != nil {
 				bat.Clean(proc.Mp)
diff --git a/pkg/sql/compile2/compile.go b/pkg/sql/compile2/compile.go
index b0ba7a5ac..cdb310565 100644
--- a/pkg/sql/compile2/compile.go
+++ b/pkg/sql/compile2/compile.go
@@ -113,6 +113,13 @@ func (c *Compile) Run(ts uint64) (err error) {
 		}
 		c.setAffectedRows(affectedRows)
 		return nil
+	case Insert:
+		affectedRows, err := c.scope.Insert(ts, c.proc.Snapshot, c.e)
+		if err != nil {
+			return err
+		}
+		c.setAffectedRows(affectedRows)
+		return nil
 	case Update:
 		affectedRows, err := c.scope.Update(ts, c.proc.Snapshot, c.e)
 		if err != nil {
@@ -188,6 +195,12 @@ func (c *Compile) compileQuery(qry *plan.Query) (*Scope, error) {
 			PreScopes: ss,
 			Magic:     Deletion,
 		}
+	case plan.Query_INSERT:
+		// needn't do merge work
+		rs = &Scope{
+			PreScopes: ss,
+			Magic:     Insert,
+		}
 	case plan.Query_UPDATE:
 		rs = &Scope{
 			PreScopes: ss,
@@ -215,6 +228,15 @@ func (c *Compile) compileQuery(qry *plan.Query) (*Scope, error) {
 			Op:  overload.Deletion,
 			Arg: scp,
 		})
+	case plan.Query_INSERT:
+		arg, err := constructInsert(qry.Nodes[qry.Steps[0]], c.e, c.proc.Snapshot)
+		if err != nil {
+			return nil, err
+		}
+		rs.Instructions = append(rs.Instructions, vm.Instruction{
+			Op:  overload.Insert,
+			Arg: arg,
+		})
 	case plan.Query_UPDATE:
 		scp, err := constructUpdate(qry.Nodes[qry.Steps[0]], c.e, c.proc.Snapshot)
 		if err != nil {
@@ -342,6 +364,12 @@ func (c *Compile) compilePlanScope(n *plan.Node, ns []*plan.Node) ([]*Scope, err
 			return nil, err
 		}
 		return ss, nil
+	case plan.Node_INSERT:
+		ss, err := c.compilePlanScope(ns[n.Children[0]], ns)
+		if err != nil {
+			return nil, err
+		}
+		return c.compileProjection(n, c.compileRestrict(n, ss)), nil
 	case plan.Node_UPDATE:
 		ss, err := c.compilePlanScope(ns[n.Children[0]], ns)
 		if err != nil {
diff --git a/pkg/sql/compile2/operator.go b/pkg/sql/compile2/operator.go
index f296b1b92..a6bd29661 100644
--- a/pkg/sql/compile2/operator.go
+++ b/pkg/sql/compile2/operator.go
@@ -19,6 +19,7 @@ import (
 	"github.com/matrixorigin/matrixone/pkg/sql/colexec2/update"
 
 	"github.com/matrixorigin/matrixone/pkg/sql/colexec2/deletion"
+	"github.com/matrixorigin/matrixone/pkg/sql/colexec2/insert"
 	"github.com/matrixorigin/matrixone/pkg/vm/engine"
 
 	"github.com/matrixorigin/matrixone/pkg/container/batch"
@@ -151,6 +152,21 @@ func constructDeletion(n *plan.Node, eg engine.Engine, snapshot engine.Snapshot)
 	}, nil
 }
 
+func constructInsert(n *plan.Node, eg engine.Engine, snapshot engine.Snapshot) (*insert.Argument, error) {
+	db, err := eg.Database(n.ObjRef.SchemaName, snapshot)
+	if err != nil {
+		return nil, err
+	}
+	relation, err := db.Relation(n.TableDef.Name, snapshot)
+	if err != nil {
+		return nil, err
+	}
+	return &insert.Argument{
+		TargetTable:   relation,
+		TargetColDefs: n.TableDef.Cols,
+	}, nil
+}
+
 func constructUpdate(n *plan.Node, eg engine.Engine, snapshot engine.Snapshot) (*update.Argument, error) {
 	dbSource, err := eg.Database(n.ObjRef.SchemaName, snapshot)
 	if err != nil {
diff --git a/pkg/sql/compile2/scope.go b/pkg/sql/compile2/scope.go
index 9acf51623..fb3fd1c79 100644
--- a/pkg/sql/compile2/scope.go
+++ b/pkg/sql/compile2/scope.go
@@ -18,6 +18,7 @@ import (
 	"context"
 	"fmt"
 	"github.com/matrixorigin/matrixone/pkg/sql/colexec2/deletion"
+	"github.com/matrixorigin/matrixone/pkg/sql/colexec2/insert"
 	"github.com/matrixorigin/matrixone/pkg/sql/colexec2/update"
 	"runtime"
 
@@ -141,6 +142,17 @@ func (s *Scope) Delete(ts uint64, snapshot engine.Snapshot, engine engine.Engine
 	return arg.AffectedRows, nil
 }
 
+func (s *Scope) Insert(ts uint64, snapshot engine.Snapshot, engine engine.Engine) (uint64, error) {
+	s.Magic = Merge
+	arg := s.Instructions[len(s.Instructions)-1].Arg.(*insert.Argument)
+	arg.Ts = ts
+	defer arg.TargetTable.Close(snapshot)
+	if err := s.MergeRun(engine); err != nil {
+		return 0, err
+	}
+	return arg.Affected, nil
+}
+
 func (s *Scope) Update(ts uint64, snapshot engine.Snapshot, engine engine.Engine) (uint64, error) {
 	s.Magic = Merge
 	arg := s.Instructions[len(s.Instructions)-1].Arg.(*update.Argument)
diff --git a/pkg/sql/compile2/types.go b/pkg/sql/compile2/types.go
index 700668316..09cf01d69 100644
--- a/pkg/sql/compile2/types.go
+++ b/pkg/sql/compile2/types.go
@@ -36,6 +36,7 @@ const (
 	DropTable
 	DropIndex
 	Deletion
+	Insert
 	Update
 )
 
diff --git a/pkg/sql/errors/types.go b/pkg/sql/errors/types.go
index aab6fb048..924494c6d 100644
--- a/pkg/sql/errors/types.go
+++ b/pkg/sql/errors/types.go
@@ -23,11 +23,5 @@ type SqlError struct {
 
 var _ error = (*SqlError)(nil)
 
-func (e *SqlError) Code() string { return e.code }
-func (e *SqlError) Error() string {
-	if len(e.code) > 0 {
-		return fmt.Sprintf("[%v]%v", e.code, e.cause)
-	} else {
-		return fmt.Sprintf("%v", e.cause)
-	}
-}
+func (e *SqlError) Code() string  { return e.code }
+func (e *SqlError) Error() string { return fmt.Sprintf("%v", e.cause) }
diff --git a/pkg/sql/parsers/dialect/mysql/mysql_lexer.go b/pkg/sql/parsers/dialect/mysql/mysql_lexer.go
index 0285c11f9..406e5887a 100644
--- a/pkg/sql/parsers/dialect/mysql/mysql_lexer.go
+++ b/pkg/sql/parsers/dialect/mysql/mysql_lexer.go
@@ -16,6 +16,7 @@ package mysql
 
 import (
 	"errors"
+	"fmt"
 	"math"
 	"strconv"
 
@@ -76,7 +77,8 @@ func (l *Lexer) Lex(lval *yySymType) int {
 }
 
 func (l *Lexer) Error(err string) {
-	l.scanner.LastError = scanner.PositionedErr{Err: err, Pos: l.scanner.Pos + 1, Near: l.scanner.LastToken}
+	errMsg := fmt.Sprintf("You have an error in your SQL syntax; check the manual that corresponds to your MatrixOne server version for the right syntax to use. %s", err)
+	l.scanner.LastError = scanner.PositionedErr{Err: errMsg, Pos: l.scanner.Pos + 1, Near: l.scanner.LastToken}
 }
 
 func (l *Lexer) AppendStmt(stmt tree.Statement) {
diff --git a/pkg/sql/parsers/dialect/mysql/mysql_sql.go b/pkg/sql/parsers/dialect/mysql/mysql_sql.go
index 014f1ab95..1ec145957 100644
--- a/pkg/sql/parsers/dialect/mysql/mysql_sql.go
+++ b/pkg/sql/parsers/dialect/mysql/mysql_sql.go
@@ -7216,7 +7216,7 @@ yydefault:
 //line mysql_sql.y:1996
 		{
 			yyLOCAL = &tree.Insert{
-				Rows: tree.NewSelect(yyDollar[1].selectUnion(), nil, nil),
+				Rows: yyDollar[1].selectUnion(),
 			}
 		}
 		yyVAL.union = yyLOCAL
@@ -7250,7 +7250,7 @@ yydefault:
 		{
 			yyLOCAL = &tree.Insert{
 				Columns: yyDollar[2].identifierListUnion(),
-				Rows:    tree.NewSelect(yyDollar[4].selectUnion(), nil, nil),
+				Rows:    yyDollar[4].selectUnion(),
 			}
 		}
 		yyVAL.union = yyLOCAL
@@ -11333,7 +11333,7 @@ yydefault:
 //line mysql_sql.y:4772
 		{
 			name := tree.SetUnresolvedName(strings.ToLower(yyDollar[1].str))
-			arg1 := tree.SetUnresolvedName(strings.ToLower(yyDollar[3].str))
+			arg1 := tree.NewNumValWithType(constant.MakeString(yyDollar[3].str), yyDollar[3].str, false, tree.P_char)
 			yyLOCAL = &tree.FuncExpr{
 				Func:  tree.FuncName2ResolvableFunctionReference(name),
 				Exprs: tree.Exprs{arg1, yyDollar[5].exprUnion()},
@@ -11346,7 +11346,7 @@ yydefault:
 //line mysql_sql.y:4781
 		{
 			name := tree.SetUnresolvedName(strings.ToLower(yyDollar[1].str))
-			arg1 := tree.SetUnresolvedName(strings.ToLower(yyDollar[3].str))
+			arg1 := tree.NewNumValWithType(constant.MakeString(yyDollar[3].str), yyDollar[3].str, false, tree.P_char)
 			yyLOCAL = &tree.FuncExpr{
 				Func:  tree.FuncName2ResolvableFunctionReference(name),
 				Exprs: tree.Exprs{arg1, yyDollar[4].exprUnion(), yyDollar[6].exprUnion()},
diff --git a/pkg/sql/parsers/dialect/mysql/mysql_sql.y b/pkg/sql/parsers/dialect/mysql/mysql_sql.y
index abb7fdf9c..05722b34b 100644
--- a/pkg/sql/parsers/dialect/mysql/mysql_sql.y
+++ b/pkg/sql/parsers/dialect/mysql/mysql_sql.y
@@ -1995,7 +1995,7 @@ insert_data:
 |   select_stmt
     {
         $$ = &tree.Insert{
-            Rows: tree.NewSelect($1, nil, nil),
+            Rows: $1,
         }
     }
 |   '(' insert_column_list ')' VALUES values_list
@@ -2017,7 +2017,7 @@ insert_data:
     {
         $$ = &tree.Insert{
             Columns: $2,
-            Rows: tree.NewSelect($4, nil, nil),
+            Rows: $4,
         }
     }
 |	SET set_value_list
@@ -4771,7 +4771,7 @@ function_call_generic:
 |	TRIM '(' trim_direction FROM expression ')'
 	{
 		name := tree.SetUnresolvedName(strings.ToLower($1))
-		arg1 := tree.SetUnresolvedName(strings.ToLower($3))
+		arg1 := tree.NewNumValWithType(constant.MakeString($3), $3, false, tree.P_char)
         $$ = &tree.FuncExpr{
              Func: tree.FuncName2ResolvableFunctionReference(name),
              Exprs: tree.Exprs{arg1, $5},
@@ -4780,7 +4780,7 @@ function_call_generic:
 |	TRIM '(' trim_direction expression FROM expression ')'
 	{
 		name := tree.SetUnresolvedName(strings.ToLower($1))
-        arg1 := tree.SetUnresolvedName(strings.ToLower($3))
+        arg1 := tree.NewNumValWithType(constant.MakeString($3), $3, false, tree.P_char)
         $$ = &tree.FuncExpr{
              Func: tree.FuncName2ResolvableFunctionReference(name),
              Exprs: tree.Exprs{arg1, $4, $6},
diff --git a/pkg/sql/plan2/build_function.go b/pkg/sql/plan2/build_function.go
index fcc1f4c7b..1ab757207 100644
--- a/pkg/sql/plan2/build_function.go
+++ b/pkg/sql/plan2/build_function.go
@@ -15,6 +15,7 @@
 package plan2
 
 import (
+	"fmt"
 	"go/constant"
 	"strings"
 
@@ -353,7 +354,7 @@ func convertValueIntoBool(name string, args []*Expr, isLogic bool) error {
 				} else if value.Ival == 1 {
 					ex.C.Value = &plan.Const_Bval{Bval: true}
 				} else {
-					return errors.New("", "the params type is not right")
+					return errors.New("", fmt.Sprintf("Can't cast '%v' as boolean type.", value.Ival))
 				}
 			}
 		}
diff --git a/pkg/sql/plan2/build_insert.go b/pkg/sql/plan2/build_insert.go
index e6359c94d..7ef54f971 100644
--- a/pkg/sql/plan2/build_insert.go
+++ b/pkg/sql/plan2/build_insert.go
@@ -16,8 +16,7 @@ package plan2
 
 import (
 	"fmt"
-	"go/constant"
-
+	"github.com/matrixorigin/matrixone/pkg/container/types"
 	"github.com/matrixorigin/matrixone/pkg/errno"
 	"github.com/matrixorigin/matrixone/pkg/pb/plan"
 	"github.com/matrixorigin/matrixone/pkg/sql/errors"
@@ -25,176 +24,182 @@ import (
 )
 
 func buildInsert(stmt *tree.Insert, ctx CompilerContext) (p *Plan, err error) {
-	query, _ := newQueryAndSelectCtx(plan.Query_INSERT)
+	rows := stmt.Rows
+	switch t := rows.Select.(type) {
+	case *tree.ValuesClause:
+		return buildInsertValues(stmt, ctx)
+	case *tree.SelectClause, *tree.ParenSelect:
+		return buildInsertSelect(stmt, ctx)
+	default:
+		return nil, errors.New(errno.FeatureNotSupported, fmt.Sprintf("unknown select statement: %v", t))
+	}
+}
+
+func buildInsertValues(_ *tree.Insert, _ CompilerContext) (p *Plan, err error) {
+	return nil, errors.New(errno.FeatureNotSupported, "building plan for insert values is not supported now")
+}
 
-	// get table
-	objRef, tableDef, err := getInsertTable(stmt.Table, ctx, query)
+func buildInsertSelect(stmt *tree.Insert, ctx CompilerContext) (p *Plan, err error) {
+	pn, err := runBuildSelectByBinder(plan.Query_SELECT, ctx, stmt.Rows)
 	if err != nil {
 		return nil, err
 	}
+	cols := GetResultColumnsFromPlan(pn)
+	pn.Plan.(*plan.Plan_Query).Query.StmtType = plan.Query_INSERT
+	if len(stmt.Columns) != 0 && len(stmt.Columns) != len(cols) {
+		return nil, errors.New(errno.InvalidColumnReference, "Column count doesn't match value count")
+	}
 
-	// get columns
-	getColDef := func(name string) (*ColDef, error) {
-		for _, col := range tableDef.Cols {
-			if col.Name == name {
-				return col, nil
-			}
-		}
-		return nil, errors.New(errno.SQLStatementNotYetComplete, fmt.Sprintf("column %T not exist", name))
+	objRef, tableDef, err := getInsertTable(stmt.Table, ctx)
+	if err != nil {
+		return nil, err
 	}
-	var columns []*ColDef
-	if stmt.Columns == nil {
-		columns = tableDef.Cols
-	} else {
-		for _, identifier := range stmt.Columns {
-			columnName := string(identifier)
-			col, err := getColDef(columnName)
-			if err != nil {
-				return nil, err
-			}
-			columns = append(columns, col)
-		}
+	valueCount := len(stmt.Columns)
+	if len(stmt.Columns) == 0 {
+		valueCount = len(tableDef.Cols)
 	}
-	columnCount := len(columns)
-	rowset := &RowsetData{
-		Schema: &TableDef{
-			Name: tableDef.Name,
-			Cols: columns,
-		},
-		Cols: make([]*plan.ColData, columnCount),
+	if valueCount != len(cols) {
+		return nil, errors.New(errno.InvalidColumnReference, "Column count doesn't match value count")
 	}
 
-	var nodeId int32
-	// get rows
-	switch rows := stmt.Rows.Select.(type) {
-	case *tree.Select:
-		binderCtx := &BinderContext{
-			columnAlias: make(map[string]*Expr),
-		}
-		nodeId, err = buildSelect(rows, ctx, query, binderCtx)
-		if err != nil {
-			return
-		}
-		// check selectNode's projectionList match rowset.Schema
-		selectNode := query.Nodes[nodeId]
-		if len(selectNode.ProjectList) != columnCount {
-			return nil, errors.New(errno.InvalidColumnDefinition, "insert column length does not match value length")
-		}
-		// TODO: Now MO don't check projectionList type match rowset type just like MySQL。
-	case *tree.ValuesClause:
-		rowCount := len(rows.Rows)
-		for idx := range rowset.Cols {
-			rowset.Cols[idx] = &plan.ColData{
-				RowCount: int32(rowCount),
-			}
-		}
-		err = getValues(rowset, rows, columnCount)
-		if err != nil {
-			return
-		}
-		node := &Node{
-			NodeType:   plan.Node_VALUE_SCAN,
-			RowsetData: rowset,
-		}
-		nodeId = appendQueryNode(query, node)
-	default:
-		return nil, errors.New(errno.SQLStatementNotYetComplete, fmt.Sprintf("unsupport rows expr: %T", stmt))
+	// generate values expr
+	exprs, err := getInsertExprs(stmt, cols, tableDef)
+	if err != nil {
+		return nil, err
 	}
 
-	node := &Node{
-		NodeType: plan.Node_INSERT,
-		ObjRef:   objRef,
-		TableDef: tableDef,
-		Children: []int32{nodeId},
+	// do type cast if needed
+	for i := range tableDef.Cols {
+		exprs[i], err = makePlan2CastExpr(exprs[i], tableDef.Cols[i].Typ)
+		if err != nil {
+			return nil, err
+		}
 	}
-	appendQueryNode(query, node)
-
-	preNode := query.Nodes[len(query.Nodes)-1]
-	if len(query.Steps) > 0 {
-		query.Steps[len(query.Steps)-1] = preNode.NodeId
-	} else {
-		query.Steps = append(query.Steps, preNode.NodeId)
+	qry := pn.Plan.(*plan.Plan_Query).Query
+	n := &Node{
+		ObjRef:      objRef,
+		TableDef:    tableDef,
+		NodeType:    plan.Node_INSERT,
+		NodeId:      int32(len(qry.Nodes)),
+		Children:    []int32{qry.Steps[len(qry.Steps)-1]},
+		ProjectList: exprs,
 	}
-
-	return &Plan{
-		Plan: &plan.Plan_Query{
-			Query: query,
-		},
-	}, nil
+	appendQueryNode(qry, n)
+	qry.Steps[len(qry.Steps)-1] = n.NodeId
+	return pn, nil
 }
 
-func getValues(rowset *RowsetData, rows *tree.ValuesClause, columnCount int) error {
-	setColData := func(col *plan.ColData, typ *plan.Type, val constant.Value) error {
-		switch val.Kind() {
-		case constant.Int:
-			switch typ.Id {
-			case plan.Type_INT8, plan.Type_INT16, plan.Type_INT32, plan.Type_UINT8, plan.Type_UINT16:
-				colVal, ok := constant.Int64Val(val)
-				if !ok {
-					return errors.New(errno.SyntaxErrororAccessRuleViolation, fmt.Sprintf("can not cast [%+v] as i64", val))
-				}
-				col.I32 = append(col.I32, int32(colVal))
-				return nil
-			case plan.Type_INT64, plan.Type_INT128, plan.Type_UINT32, plan.Type_UINT64, plan.Type_UINT128:
-				colVal, ok := constant.Int64Val(val)
-				if !ok {
-					return errors.New(errno.SyntaxErrororAccessRuleViolation, fmt.Sprintf("can not cast [%+v] as  i64", val))
-				}
-				col.I64 = append(col.I64, colVal)
-				return nil
-			default:
-				return errors.New(errno.SyntaxErrororAccessRuleViolation, fmt.Sprintf("[%v] type must be int", val))
-			}
-		case constant.Float:
-			switch typ.Id {
-			case plan.Type_FLOAT32:
-				colVal, ok := constant.Float32Val(val)
-				if !ok {
-					return errors.New(errno.SyntaxErrororAccessRuleViolation, fmt.Sprintf("can not cast [%+v] as  f32", val))
-				}
-				col.F32 = append(col.F32, colVal)
-				return nil
-			case plan.Type_FLOAT64, plan.Type_DECIMAL, plan.Type_DECIMAL64, plan.Type_DECIMAL128:
-				colVal, ok := constant.Float64Val(val)
-				if !ok {
-					return errors.New(errno.SyntaxErrororAccessRuleViolation, fmt.Sprintf("can not cast [%+v] as  f64", val))
-				}
-				col.F64 = append(col.F64, colVal)
-				return nil
-			default:
-				return errors.New(errno.SyntaxErrororAccessRuleViolation, fmt.Sprintf("[%v] type must be float", val))
+func getInsertExprs(stmt *tree.Insert, cols []*ColDef, tableDef *TableDef) ([]*Expr, error) {
+	var exprs []*Expr
+	var err error
+
+	if len(stmt.Columns) == 0 {
+		exprs = make([]*Expr, len(cols))
+		for i := range exprs {
+			exprs[i] = &plan.Expr{
+				Typ: cols[i].Typ,
+				Expr: &plan.Expr_Col{
+					Col: &plan.ColRef{
+						ColPos: int32(i),
+					},
+				},
 			}
-		case constant.String:
-			colVal := constant.StringVal(val)
-			col.S = append(col.S, colVal)
-			return nil
-		default:
-			return errors.New(errno.SyntaxErrororAccessRuleViolation, fmt.Sprintf("unsupport value: %v", val))
 		}
-	}
-
-	for rowIdx, row := range rows.Rows {
-		if columnCount != len(row) {
-			return errors.New(errno.InvalidColumnReference, fmt.Sprintf("Column count doesn't match value count at row '%v'", rowIdx))
+	} else {
+		exprs = make([]*Expr, len(tableDef.Cols))
+		tableColMap := make(map[string]int)
+		targetMap := make(map[string]int)
+		for i, col := range stmt.Columns {
+			targetMap[string(col)] = i
 		}
-
-		for idx, colExpr := range row {
-			switch astExpr := colExpr.(type) {
-			case *tree.NumVal:
-				err := setColData(rowset.Cols[idx], rowset.Schema.Cols[idx].Typ, astExpr.Value)
+		for i, col := range tableDef.Cols {
+			tableColMap[col.GetName()] = i
+		}
+		// check if the column name is legal
+		for k := range targetMap {
+			if _, ok := tableColMap[k]; !ok {
+				return nil, errors.New(errno.InvalidColumnReference, fmt.Sprintf("column '%s' not exist", k))
+			}
+		}
+		for i := range exprs {
+			if ref, ok := targetMap[tableDef.Cols[i].GetName()]; ok {
+				exprs[i] = &plan.Expr{
+					Typ: cols[ref].Typ,
+					Expr: &plan.Expr_Col{
+						Col: &plan.ColRef{
+							ColPos: int32(ref),
+						},
+					},
+				}
+			} else {
+				// get default value, and init constant expr.
+				exprs[i], err = generateDefaultExpr(tableDef.Cols[i].Default, tableDef.Cols[i].Typ)
 				if err != nil {
-					return err
+					return nil, err
 				}
-			default:
-				return errors.New(errno.InvalidSchemaName, "insert value must be constant")
 			}
 		}
 	}
+	return exprs, nil
+}
 
-	return nil
+func generateDefaultExpr(e *plan.DefaultExpr, t *plan.Type) (*Expr, error) {
+	if e == nil || !e.Exist || e.IsNull {
+		return &plan.Expr{
+			Typ: t,
+			Expr: &plan.Expr_C{
+				C: &Const{Isnull: true},
+			},
+		}, nil
+	}
+	var ret = plan.Expr{Typ: &plan.Type{
+		Id:        t.Id,
+		Nullable:  t.Nullable,
+		Width:     t.Width,
+		Precision: t.Precision,
+		Size:      t.Size,
+		Scale:     t.Scale,
+	}}
+	switch d := e.Value.ConstantValue.(type) {
+	case *plan.ConstantValue_BoolV:
+		ret.Expr = makePlan2BoolConstExpr(d.BoolV)
+	case *plan.ConstantValue_Int64V:
+		ret.Expr = makePlan2Int64ConstExpr(d.Int64V)
+		ret.Typ.Id = plan.Type_INT64
+		ret.Typ.Size = 8
+		ret.Typ.Width = 64
+	case *plan.ConstantValue_Uint64V:
+		ret.Expr = makePlan2Uint64ConstExpr(d.Uint64V)
+		ret.Typ.Id = plan.Type_UINT64
+		ret.Typ.Size = 8
+		ret.Typ.Width = 64
+	case *plan.ConstantValue_Float32V:
+		ret.Expr = makePlan2Float32ConstExpr(d.Float32V)
+	case *plan.ConstantValue_Float64V:
+		ret.Expr = makePlan2Float64ConstExpr(d.Float64V)
+	case *plan.ConstantValue_StringV:
+		ret.Expr = makePlan2StringConstExpr(d.StringV)
+		ret.Typ.Id = plan.Type_VARCHAR
+	case *plan.ConstantValue_DateV:
+		ret.Expr = makePlan2DateConstExpr(types.Date(d.DateV))
+	case *plan.ConstantValue_DateTimeV:
+		ret.Expr = makePlan2DatetimeConstExpr(types.Datetime(d.DateTimeV))
+	case *plan.ConstantValue_Decimal64V:
+		ret.Expr = makePlan2Decimal64ConstExpr(types.Decimal64(d.Decimal64V))
+	case *plan.ConstantValue_Decimal128V:
+		ret.Expr = makePlan2Decimal128ConstExpr(types.Decimal128{
+			Lo: d.Decimal128V.Lo,
+			Hi: d.Decimal128V.Hi,
+		})
+	case *plan.ConstantValue_TimeStampV:
+		ret.Expr = makePlan2TimestampConstExpr(types.Timestamp(d.TimeStampV))
+	default:
+		return nil, errors.New(errno.FeatureNotSupported, fmt.Sprintf("default type '%s' is not support now", t))
+	}
+	return &ret, nil
 }
 
-func getInsertTable(stmt tree.TableExpr, ctx CompilerContext, query *Query) (*ObjectRef, *TableDef, error) {
+func getInsertTable(stmt tree.TableExpr, ctx CompilerContext) (*ObjectRef, *TableDef, error) {
 	switch tbl := stmt.(type) {
 	case *tree.TableName:
 		tblName := string(tbl.ObjectName)
@@ -205,9 +210,9 @@ func getInsertTable(stmt tree.TableExpr, ctx CompilerContext, query *Query) (*Ob
 		}
 		return objRef, tableDef, nil
 	case *tree.ParenTableExpr:
-		return getInsertTable(tbl.Expr, ctx, query)
+		return getInsertTable(tbl.Expr, ctx)
 	case *tree.AliasedTableExpr:
-		return getInsertTable(tbl.Expr, ctx, query)
+		return getInsertTable(tbl.Expr, ctx)
 	case *tree.Select:
 		return nil, nil, errors.New(errno.SQLStatementNotYetComplete, fmt.Sprintf("unsupport table expr: %T", stmt))
 	case *tree.StatementSource:
diff --git a/pkg/sql/plan2/function/function.go b/pkg/sql/plan2/function/function.go
index 7b8f6af67..4017ee20b 100644
--- a/pkg/sql/plan2/function/function.go
+++ b/pkg/sql/plan2/function/function.go
@@ -165,7 +165,7 @@ func fromNameToFunctionId(name string) (int32, error) {
 	if fid, ok := functionIdRegister[name]; ok {
 		return fid, nil
 	}
-	return -1, errors.New(errno.UndefinedFunction, fmt.Sprintf("function or operator '%s' is not implemented", name))
+	return -1, errors.New(errno.UndefinedFunction, fmt.Sprintf("Function or operator '%s' will be implemented in future version.", name))
 }
 
 // EncodeOverloadID convert function-id and overload-index to be an overloadID
@@ -261,9 +261,9 @@ func GetFunctionByName(name string, args []types.T) (Function, int64, []types.T,
 		}
 	}
 	if len(fs) > 0 && fs[0].isFunction() {
-		return emptyFunction, -1, nil, errors.New(errno.UndefinedFunction, fmt.Sprintf("unsupported parameter types %v for function '%s'", args, name))
+		return emptyFunction, -1, nil, errors.New(errno.UndefinedFunction, fmt.Sprintf("Function '%s' with parameters %v will be implemented in future version.", name, args))
 	}
-	return emptyFunction, -1, nil, errors.New(errno.UndefinedFunction, fmt.Sprintf("unsupported parameter types %v for operator '%s'", args, name))
+	return emptyFunction, -1, nil, errors.New(errno.UndefinedFunction, fmt.Sprintf("Operator '%s' with parameters %v will be implemented in future version.", name, args))
 }
 
 // strictTypeCheck is a general type check method.
diff --git a/pkg/sql/plan2/make.go b/pkg/sql/plan2/make.go
new file mode 100644
index 000000000..dae253670
--- /dev/null
+++ b/pkg/sql/plan2/make.go
@@ -0,0 +1,207 @@
+// 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/container/types"
+	"github.com/matrixorigin/matrixone/pkg/pb/plan"
+	"github.com/matrixorigin/matrixone/pkg/sql/plan2/function"
+	"github.com/matrixorigin/matrixone/pkg/vm/engine"
+)
+
+func makePlan2BoolConstExpr(v bool) *plan.Expr_C {
+	return &plan.Expr_C{C: &plan.Const{
+		Isnull: false,
+		Value: &plan.Const_Bval{
+			Bval: v,
+		},
+	}}
+}
+
+func makePlan2Int64ConstExpr(v int64) *plan.Expr_C {
+	return &plan.Expr_C{C: &plan.Const{
+		Isnull: false,
+		Value: &plan.Const_Ival{
+			Ival: v,
+		},
+	}}
+}
+
+func makePlan2Uint64ConstExpr(v uint64) *plan.Expr_C {
+	return &plan.Expr_C{C: &plan.Const{
+		Isnull: false,
+		Value: &plan.Const_Uval{
+			Uval: v,
+		},
+	}}
+}
+
+func makePlan2Float32ConstExpr(v float32) *plan.Expr_C {
+	return &plan.Expr_C{C: &plan.Const{
+		Isnull: false,
+		Value: &plan.Const_Fval{
+			Fval: v,
+		},
+	}}
+}
+
+func makePlan2Float64ConstExpr(v float64) *plan.Expr_C {
+	return &plan.Expr_C{C: &plan.Const{
+		Isnull: false,
+		Value: &plan.Const_Dval{
+			Dval: v,
+		},
+	}}
+}
+
+func makePlan2StringConstExpr(v string) *plan.Expr_C {
+	return &plan.Expr_C{C: &plan.Const{
+		Isnull: false,
+		Value: &plan.Const_Sval{
+			Sval: v,
+		},
+	}}
+}
+
+func makePlan2DateConstExpr(v types.Date) *plan.Expr_C {
+	return &plan.Expr_C{C: &plan.Const{
+		Isnull: false,
+		Value: &plan.Const_Dateval{
+			Dateval: int32(v),
+		},
+	}}
+}
+
+func makePlan2DatetimeConstExpr(v types.Datetime) *plan.Expr_C {
+	return &plan.Expr_C{C: &plan.Const{
+		Isnull: false,
+		Value: &plan.Const_Datetimeval{
+			Datetimeval: int64(v),
+		},
+	}}
+}
+
+func makePlan2Decimal64ConstExpr(v types.Decimal64) *plan.Expr_C {
+	return &plan.Expr_C{C: &plan.Const{
+		Isnull: false,
+		Value: &plan.Const_Decimal64Val{
+			Decimal64Val: int64(v),
+		},
+	}}
+}
+
+func makePlan2Decimal128ConstExpr(v types.Decimal128) *plan.Expr_C {
+	return &plan.Expr_C{C: &plan.Const{
+		Isnull: false,
+		Value: &plan.Const_Decimal128Val{
+			Decimal128Val: &plan.Decimal128{Lo: v.Lo, Hi: v.Hi},
+		},
+	}}
+}
+
+func makePlan2TimestampConstExpr(v types.Timestamp) *plan.Expr_C {
+	return &plan.Expr_C{C: &plan.Const{
+		Isnull: false,
+		Value: &plan.Const_Timestampval{
+			Timestampval: int64(v),
+		},
+	}}
+}
+
+func makePlan2CastExpr(expr *Expr, targetType *Type) (*Expr, error) {
+	t1, t2 := types.T(expr.Typ.Id), types.T(targetType.Id)
+	if t1 == t2 {
+		return expr, nil
+	}
+	if types.T(expr.Typ.Id) == types.T_any {
+		expr.Typ = copyType(targetType)
+		return expr, nil
+	}
+	_, id, _, err := function.GetFunctionByName("cast", []types.T{t1, t2})
+	if err != nil {
+		return nil, err
+	}
+	t := &plan.Expr{Expr: &plan.Expr_T{T: &plan.TargetType{Typ: copyType(targetType)}}}
+	return &plan.Expr{Expr: &plan.Expr_F{
+		F: &plan.Function{
+			Func: &ObjectRef{Obj: id},
+			Args: []*Expr{expr, t},
+		},
+	}}, nil
+}
+
+func copyType(t *Type) *Type {
+	return &Type{
+		Id:        t.Id,
+		Nullable:  t.Nullable,
+		Width:     t.Width,
+		Precision: t.Precision,
+		Size:      t.Size,
+		Scale:     t.Scale,
+	}
+}
+
+func MakePlan2DefaultExpr(expr engine.DefaultExpr) *plan.DefaultExpr {
+	ret := &plan.DefaultExpr{}
+	ret.Exist = expr.Exist
+	if !ret.Exist {
+		return ret
+	}
+	ret.IsNull = expr.IsNull
+	if ret.IsNull {
+		return ret
+	}
+	ret.Value = &plan.ConstantValue{}
+	switch t := expr.Value.(type) {
+	case bool:
+		ret.Value.ConstantValue = &plan.ConstantValue_BoolV{BoolV: t}
+	case float32:
+		ret.Value.ConstantValue = &plan.ConstantValue_Float32V{Float32V: t}
+	case float64:
+		ret.Value.ConstantValue = &plan.ConstantValue_Float64V{Float64V: t}
+	case string:
+		ret.Value.ConstantValue = &plan.ConstantValue_StringV{StringV: t}
+	case int8:
+		ret.Value.ConstantValue = &plan.ConstantValue_Int64V{Int64V: int64(t)}
+	case int16:
+		ret.Value.ConstantValue = &plan.ConstantValue_Int64V{Int64V: int64(t)}
+	case int32:
+		ret.Value.ConstantValue = &plan.ConstantValue_Int64V{Int64V: int64(t)}
+	case int64:
+		ret.Value.ConstantValue = &plan.ConstantValue_Int64V{Int64V: t}
+	case uint8:
+		ret.Value.ConstantValue = &plan.ConstantValue_Uint64V{Uint64V: uint64(t)}
+	case uint16:
+		ret.Value.ConstantValue = &plan.ConstantValue_Uint64V{Uint64V: uint64(t)}
+	case uint32:
+		ret.Value.ConstantValue = &plan.ConstantValue_Uint64V{Uint64V: uint64(t)}
+	case uint64:
+		ret.Value.ConstantValue = &plan.ConstantValue_Uint64V{Uint64V: t}
+	case types.Date:
+		ret.Value.ConstantValue = &plan.ConstantValue_DateV{DateV: int32(t)}
+	case types.Datetime:
+		ret.Value.ConstantValue = &plan.ConstantValue_DateTimeV{DateTimeV: int64(t)}
+	case types.Decimal64:
+		ret.Value.ConstantValue = &plan.ConstantValue_Decimal64V{Decimal64V: int64(t)}
+	case types.Decimal128:
+		ret.Value.ConstantValue = &plan.ConstantValue_Decimal128V{Decimal128V: &plan.Decimal128{
+			Lo: t.Lo,
+			Hi: t.Hi,
+		}}
+	case types.Timestamp:
+		ret.Value.ConstantValue = &plan.ConstantValue_TimeStampV{TimeStampV: int64(t)}
+	}
+	return ret
+}
diff --git a/pkg/sql/plan2/query_builder.go b/pkg/sql/plan2/query_builder.go
index 1488791d6..11c37efa3 100644
--- a/pkg/sql/plan2/query_builder.go
+++ b/pkg/sql/plan2/query_builder.go
@@ -436,7 +436,7 @@ func (builder *QueryBuilder) buildSelect(stmt *tree.Select, ctx *BindContext, is
 	}
 
 	if len(selectList) == 0 {
-		return 0, errors.New(errno.SyntaxErrororAccessRuleViolation, "No tables used")
+		return 0, errors.New("", "No tables used")
 	}
 
 	if clause.Where != nil {
diff --git a/pkg/vm/engine/tae/catalog/catalog.go b/pkg/vm/engine/tae/catalog/catalog.go
index 7cd0a6fa1..b8a2e5adf 100644
--- a/pkg/vm/engine/tae/catalog/catalog.go
+++ b/pkg/vm/engine/tae/catalog/catalog.go
@@ -368,7 +368,6 @@ func (catalog *Catalog) onReplayCreateSegment(cmd *EntryCommand, dataFactory Dat
 	cmd.Segment.link = new(common.Link)
 	cmd.Segment.entries = make(map[uint64]*common.DLNode)
 	cmd.Segment.segData = dataFactory.MakeSegmentFactory()(cmd.Segment)
-	cmd.Segment.ReplayFile(cache)
 	tbl.AddEntryLocked(cmd.Segment)
 	cmd.Segment.LogIndex = idx
 	if observer != nil {
diff --git a/pkg/vm/engine/tae/catalog/segment.go b/pkg/vm/engine/tae/catalog/segment.go
index e0d48bfec..f6e8e119e 100644
--- a/pkg/vm/engine/tae/catalog/segment.go
+++ b/pkg/vm/engine/tae/catalog/segment.go
@@ -15,7 +15,6 @@
 package catalog
 
 import (
-	"bytes"
 	"encoding/binary"
 	"fmt"
 	"io"
@@ -345,18 +344,7 @@ func (entry *SegmentEntry) Clone() CheckpointItem {
 	}
 	return cloned
 }
-func (entry *SegmentEntry) ReplayFile(cache *bytes.Buffer) {
-	colCnt := len(entry.table.GetSchema().ColDefs)
-	indexCnt := make(map[int]int)
-	if entry.table.GetSchema().IsSingleSortKey() {
-		indexCnt[entry.table.GetSchema().GetSingleSortKey().Idx] = 2
-	} else if entry.table.GetSchema().IsCompoundSortKey() {
-		panic("implement me")
-	}
-	if err := entry.GetSegmentData().GetSegmentFile().Replay(colCnt, indexCnt, cache); err != nil {
-		panic(err)
-	}
-}
+
 func (entry *SegmentEntry) CloneCreate() CheckpointItem {
 	cloned := &SegmentEntry{
 		BaseEntry: entry.BaseEntry.CloneCreate(),
diff --git a/pkg/vm/engine/tae/dataio/segmentio/block.go b/pkg/vm/engine/tae/dataio/segmentio/block.go
index 4270a9038..804bab38c 100644
--- a/pkg/vm/engine/tae/dataio/segmentio/block.go
+++ b/pkg/vm/engine/tae/dataio/segmentio/block.go
@@ -52,13 +52,10 @@ func newBlock(id uint64, seg *segmentFile, colCnt int, indexCnt map[int]int) *bl
 		columns: make([]*columnBlock, colCnt),
 	}
 	bf.deletes = newDeletes(bf)
-	bf.deletes.file = make([]*DriverFile, 1)
-	bf.deletes.file[0] = bf.seg.GetSegmentFile().NewBlockFile(
-		fmt.Sprintf("%d_%d.del", colCnt, bf.id))
 	bf.indexMeta = newIndex(&columnBlock{block: bf}).dataFile
-	bf.indexMeta.file = make([]*DriverFile, 1)
-	bf.indexMeta.file[0] = bf.seg.GetSegmentFile().NewBlockFile(
-		fmt.Sprintf("%d_%d.idx", colCnt, bf.id))
+	bf.indexMeta.file = append(bf.indexMeta.file, bf.seg.GetSegmentFile().NewBlockFile(
+		fmt.Sprintf("%d_%d.idx", colCnt, bf.id)))
+	bf.indexMeta.file[0].SetCols(uint32(colCnt))
 	bf.indexMeta.file[0].snode.algo = compress.None
 	bf.OnZeroCB = bf.close
 	for i := range bf.columns {
@@ -72,26 +69,13 @@ func newBlock(id uint64, seg *segmentFile, colCnt int, indexCnt map[int]int) *bl
 	return bf
 }
 
-func replayBlock(id uint64, seg *segmentFile, colCnt int, indexCnt map[int]int) *blockFile {
-	bf := &blockFile{
-		seg:     seg,
-		id:      id,
-		columns: make([]*columnBlock, colCnt),
-	}
-	bf.deletes = newDeletes(bf)
-	bf.deletes.file = make([]*DriverFile, 1)
-	bf.indexMeta = newIndex(&columnBlock{block: bf}).dataFile
-	bf.indexMeta.file = make([]*DriverFile, 1)
-	bf.OnZeroCB = bf.close
-	for i := range bf.columns {
-		cnt := 0
-		if indexCnt != nil {
-			cnt = indexCnt[i]
+func (bf *blockFile) AddColumn(col int) {
+	colCnt := len(bf.columns)
+	if col > colCnt {
+		for i := colCnt; i < col; i++ {
+			bf.columns = append(bf.columns, getColumnBlock(i, bf))
 		}
-		bf.columns[i] = openColumnBlock(bf, cnt, i)
 	}
-	bf.Ref()
-	return bf
 }
 
 func (bf *blockFile) Fingerprint() *common.ID {
@@ -119,12 +103,10 @@ func (bf *blockFile) ReadRows() uint32 {
 
 func (bf *blockFile) WriteTS(ts uint64) (err error) {
 	bf.ts = ts
-	if bf.deletes.file != nil {
-		bf.deletes.mutex.Lock()
-		defer bf.deletes.mutex.Unlock()
-		bf.deletes.file = append(bf.deletes.file,
-			bf.seg.GetSegmentFile().NewBlockFile(fmt.Sprintf("%d_%d_%d.del", len(bf.columns), bf.id, ts)))
-	}
+	bf.deletes.SetFile(
+		bf.seg.GetSegmentFile().NewBlockFile(fmt.Sprintf("%d_%d_%d.del", len(bf.columns), bf.id, ts)),
+		uint32(len(bf.columns)),
+		uint32(len(bf.columns[0].indexes)))
 	return
 }
 
@@ -190,14 +172,20 @@ func (bf *blockFile) Destroy() error {
 		cb.Unref()
 	}
 	bf.columns = nil
-	if bf.deletes.file[0] != nil {
-		bf.seg.driver.ReleaseFile(bf.deletes.file[0])
-		bf.deletes = nil
+	for _, del := range bf.deletes.file {
+		if del == nil {
+			continue
+		}
+		del.Unref()
 	}
-	if bf.indexMeta.file[0] != nil {
-		bf.seg.driver.ReleaseFile(bf.indexMeta.file[0])
-		bf.indexMeta = nil
+	bf.deletes = nil
+	for _, idx := range bf.indexMeta.file {
+		if idx == nil {
+			continue
+		}
+		idx.Unref()
 	}
+	bf.indexMeta = nil
 	if bf.seg != nil {
 		bf.seg.RemoveBlock(bf.id)
 	}
diff --git a/pkg/vm/engine/tae/dataio/segmentio/colblk.go b/pkg/vm/engine/tae/dataio/segmentio/colblk.go
index 381086c0a..cc74a6541 100644
--- a/pkg/vm/engine/tae/dataio/segmentio/colblk.go
+++ b/pkg/vm/engine/tae/dataio/segmentio/colblk.go
@@ -41,57 +41,38 @@ func newColumnBlock(block *blockFile, indexCnt int, col int) *columnBlock {
 	}
 	for i := range cb.indexes {
 		cb.indexes[i] = newIndex(cb)
-		cb.indexes[i].dataFile.file = make([]*DriverFile, 1)
-		cb.indexes[i].dataFile.file[0] = cb.block.seg.GetSegmentFile().NewBlockFile(
-			fmt.Sprintf("%d_%d_%d.idx", cb.col, cb.block.id, i))
+		cb.indexes[i].dataFile.file = append(cb.indexes[i].dataFile.file, cb.block.seg.GetSegmentFile().NewBlockFile(
+			fmt.Sprintf("%d_%d_%d.idx", cb.col, cb.block.id, i)))
 		cb.indexes[i].dataFile.file[0].snode.algo = compress.None
+		cb.indexes[i].dataFile.file[0].SetIdxs(uint32(len(cb.indexes)))
+		cb.indexes[i].dataFile.file[0].SetCols(uint32(col))
 	}
 	cb.updates = newUpdates(cb)
-	cb.updates.file = make([]*DriverFile, 1)
-	cb.updates.file[0] = cb.block.seg.GetSegmentFile().NewBlockFile(
-		fmt.Sprintf("%d_%d.update", cb.col, cb.block.id))
 	cb.data = newData(cb)
-	cb.data.file = make([]*DriverFile, 1)
-	cb.data.file[0] = cb.block.seg.GetSegmentFile().NewBlockFile(
-		fmt.Sprintf("%d_%d.blk", cb.col, cb.block.id))
 	cb.OnZeroCB = cb.close
 	cb.Ref()
 	return cb
 }
 
-func openColumnBlock(block *blockFile, indexCnt int, col int) *columnBlock {
-	cb := &columnBlock{
-		block:   block,
-		indexes: make([]*indexFile, indexCnt),
-		col:     col,
-	}
-	for i := range cb.indexes {
-		cb.indexes[i] = newIndex(cb)
-		cb.indexes[i].file = make([]*DriverFile, 1)
+func (cb *columnBlock) AddIndex(idx int) {
+	idxCnt := len(cb.indexes)
+	if idx > idxCnt {
+		for i := idxCnt; i < idx; i++ {
+			cb.indexes = append(cb.indexes, newIndex(cb))
+		}
 	}
-	cb.updates = newUpdates(cb)
-	cb.updates.file = make([]*DriverFile, 1)
-	cb.data = newData(cb)
-	cb.data.file = make([]*DriverFile, 1)
-	cb.OnZeroCB = cb.close
-	cb.Ref()
-	return cb
 }
 
 func (cb *columnBlock) WriteTS(ts uint64) (err error) {
 	cb.ts = ts
-	if cb.data.file != nil {
-		cb.data.mutex.Lock()
-		defer cb.data.mutex.Unlock()
-		cb.data.file = append(cb.data.file,
-			cb.block.seg.GetSegmentFile().NewBlockFile(fmt.Sprintf("%d_%d_%d.blk", cb.col, cb.block.id, ts)))
-	}
-	if cb.updates.file != nil {
-		cb.updates.mutex.Lock()
-		defer cb.updates.mutex.Unlock()
-		cb.updates.file = append(cb.updates.file,
-			cb.block.seg.GetSegmentFile().NewBlockFile(fmt.Sprintf("%d_%d_%d.update", cb.col, cb.block.id, ts)))
-	}
+	cb.data.SetFile(
+		cb.block.seg.GetSegmentFile().NewBlockFile(fmt.Sprintf("%d_%d_%d.blk", cb.col, cb.block.id, ts)),
+		uint32(len(cb.block.columns)),
+		uint32(len(cb.indexes)))
+	cb.updates.SetFile(
+		cb.block.seg.GetSegmentFile().NewBlockFile(fmt.Sprintf("%d_%d_%d.update", cb.col, cb.block.id, ts)),
+		uint32(len(cb.block.columns)),
+		uint32(len(cb.indexes)))
 	return
 }
 
@@ -185,17 +166,16 @@ func (cb *columnBlock) Destroy() {
 	cb.data.mutex.Unlock()
 	if files != nil {
 		for _, file := range files {
-			if file == nil {
-				continue
-			}
-			cb.block.seg.driver.ReleaseFile(file)
+			file.Unref()
 		}
 	}
 
 	for _, index := range cb.indexes {
-		if index.dataFile == nil || index.dataFile.file[0] == nil {
-			continue
+		for _, file := range index.dataFile.file {
+			file.Unref()
 		}
-		cb.block.seg.driver.ReleaseFile(index.dataFile.file[0])
+	}
+	for _, update := range cb.updates.file {
+		update.Unref()
 	}
 }
diff --git a/pkg/vm/engine/tae/dataio/segmentio/data.go b/pkg/vm/engine/tae/dataio/segmentio/data.go
index 7f3daa207..46d7cf97f 100644
--- a/pkg/vm/engine/tae/dataio/segmentio/data.go
+++ b/pkg/vm/engine/tae/dataio/segmentio/data.go
@@ -19,7 +19,7 @@ import (
 	"sync"
 )
 
-const UPGRADE_FILE_NUM = 100
+const UPGRADE_FILE_NUM = 2
 
 type dataFile struct {
 	mutex  sync.RWMutex
@@ -47,6 +47,7 @@ func newData(colBlk *columnBlock) *dataFile {
 	df := &dataFile{
 		colBlk: colBlk,
 		buf:    make([]byte, 0),
+		file:   make([]*DriverFile, 0),
 	}
 	df.stat = &fileStat{}
 	return df
@@ -56,7 +57,6 @@ func newIndex(colBlk *columnBlock) *indexFile {
 	index := &indexFile{
 		dataFile: newData(colBlk),
 	}
-	index.dataFile.file = nil
 	return index
 }
 
@@ -64,7 +64,6 @@ func newUpdates(colBlk *columnBlock) *updatesFile {
 	update := &updatesFile{
 		dataFile: newData(colBlk),
 	}
-	update.dataFile.file = nil
 	return update
 }
 
@@ -74,23 +73,11 @@ func newDeletes(block *blockFile) *deletesFile {
 		block:    block,
 		dataFile: newData(nil),
 	}
-	del.dataFile.file = nil
 	return del
 }
 
 func (df *dataFile) Write(buf []byte) (n int, err error) {
-	if df.file == nil {
-		n = len(buf)
-		df.buf = make([]byte, len(buf))
-		copy(df.buf, buf)
-		df.stat.size = int64(len(df.buf))
-		df.stat.algo = 0
-		df.stat.originSize = int64(len(df.buf))
-		return
-	}
-	df.mutex.RLock()
-	file := df.file[len(df.file)-1]
-	df.mutex.RUnlock()
+	file := df.GetFile()
 	if df.colBlk != nil && df.colBlk.block.rows > 0 {
 		file.SetRows(df.colBlk.block.rows)
 	}
@@ -104,18 +91,11 @@ func (df *dataFile) Write(buf []byte) (n int, err error) {
 }
 
 func (df *dataFile) Read(buf []byte) (n int, err error) {
-	if df.file == nil {
-		n = len(buf)
-		copy(buf, df.buf)
-		return
-	}
 	bufLen := len(buf)
 	if bufLen == 0 {
 		return 0, nil
 	}
-	df.mutex.RLock()
-	file := df.file[len(df.file)-1]
-	df.mutex.RUnlock()
+	file := df.GetFile()
 	n, err = file.Read(buf)
 	return n, nil
 }
@@ -126,9 +106,12 @@ func (df *dataFile) upgradeFile() {
 	}
 	go func() {
 		df.mutex.Lock()
+		defer df.mutex.Unlock()
+		if len(df.file) < UPGRADE_FILE_NUM {
+			return
+		}
 		releaseFile := df.file[:len(df.file)-1]
 		df.file = df.file[len(df.file)-1 : len(df.file)]
-		df.mutex.Unlock()
 		for _, file := range releaseFile {
 			file.driver.ReleaseFile(file)
 		}
@@ -139,6 +122,20 @@ func (df *dataFile) GetFileType() common.FileType {
 	return common.DiskFile
 }
 
+func (df *dataFile) GetFile() *DriverFile {
+	df.mutex.RLock()
+	defer df.mutex.RUnlock()
+	return df.file[len(df.file)-1]
+}
+
+func (df *dataFile) SetFile(file *DriverFile, col, idx uint32) {
+	df.mutex.Lock()
+	defer df.mutex.Unlock()
+	df.file = append(df.file, file)
+	file.SetCols(col)
+	file.SetIdxs(idx)
+}
+
 func (df *dataFile) Ref()            { df.colBlk.Ref() }
 func (df *dataFile) Unref()          { df.colBlk.Unref() }
 func (df *dataFile) RefCount() int64 { return df.colBlk.RefCount() }
diff --git a/pkg/vm/engine/tae/dataio/segmentio/driver.go b/pkg/vm/engine/tae/dataio/segmentio/driver.go
index 70514748d..0fcab9639 100644
--- a/pkg/vm/engine/tae/dataio/segmentio/driver.go
+++ b/pkg/vm/engine/tae/dataio/segmentio/driver.go
@@ -29,7 +29,7 @@ const INODE_NUM = 4096
 const INODE_SIZE = 512
 const BLOCK_SIZE = 4096
 const SIZE = 4 * 1024 * 1024 * 1024
-const LOG_START = 2 * INODE_SIZE
+const LOG_START = 2 * BLOCK_SIZE
 const DATA_START = LOG_START + INODE_SIZE*INODE_NUM
 const DATA_SIZE = SIZE - DATA_START
 const LOG_SIZE = DATA_START - LOG_START
@@ -111,6 +111,7 @@ func (s *Driver) Init(name string) (err error) {
 func (s *Driver) Open(name string) (err error) {
 	if _, err = os.Stat(name); os.IsNotExist(err) {
 		err = s.Init(name)
+		s.Mount()
 		return
 	}
 	if s.segFile, err = os.OpenFile(name, os.O_RDWR, os.ModePerm); err != nil {
@@ -129,6 +130,11 @@ func (s *Driver) Open(name string) (err error) {
 		state: RESIDENT,
 	}
 	s.super.lognode = log
+	s.Mount()
+	cache := bytes.NewBuffer(make([]byte, 2*1024*1024))
+	if err := s.Replay(cache); err != nil {
+		return err
+	}
 	logutil.Infof(" %s-%p | SegmentFile | Opened", s.name, &(s.name))
 	return
 }
@@ -200,6 +206,8 @@ func (s *Driver) NewBlockFile(fname string) *DriverFile {
 	}
 	s.nodes[file.name] = file
 	s.lastInode += 1
+	file.OnZeroCB = file.close
+	file.Ref()
 	s.PrintLog(file.name, "NewBlockFile")
 	return file
 }
diff --git a/pkg/vm/engine/tae/dataio/segmentio/file.go b/pkg/vm/engine/tae/dataio/segmentio/file.go
index 201a31111..c45da1f2f 100644
--- a/pkg/vm/engine/tae/dataio/segmentio/file.go
+++ b/pkg/vm/engine/tae/dataio/segmentio/file.go
@@ -18,10 +18,12 @@ import (
 	"bytes"
 	"encoding/binary"
 	"github.com/matrixorigin/matrixone/pkg/logutil"
+	"github.com/matrixorigin/matrixone/pkg/vm/engine/tae/common"
 	"io"
 )
 
 type DriverFile struct {
+	common.RefHelper
 	snode  *Inode
 	name   string
 	driver *Driver
@@ -41,6 +43,14 @@ func (b *DriverFile) SetRows(rows uint32) {
 	b.snode.rows = rows
 }
 
+func (b *DriverFile) SetCols(cols uint32) {
+	b.snode.cols = cols
+}
+
+func (b *DriverFile) SetIdxs(idxs uint32) {
+	b.snode.idxs = idxs
+}
+
 func (b *DriverFile) GetName() string {
 	return b.name
 }
@@ -268,3 +278,11 @@ func (b *DriverFile) ReadExtent(offset, length uint32, data []byte) (uint32, err
 		}
 	}
 }
+
+func (b *DriverFile) close() {
+	b.Destroy()
+}
+
+func (b *DriverFile) Destroy() {
+	b.driver.ReleaseFile(b)
+}
diff --git a/pkg/vm/engine/tae/dataio/segmentio/inode.go b/pkg/vm/engine/tae/dataio/segmentio/inode.go
index 2cc27f8ca..844ff8d34 100644
--- a/pkg/vm/engine/tae/dataio/segmentio/inode.go
+++ b/pkg/vm/engine/tae/dataio/segmentio/inode.go
@@ -32,6 +32,8 @@ type Inode struct {
 	size       uint64
 	originSize uint64
 	rows       uint32
+	cols       uint32
+	idxs       uint32
 	mutex      sync.RWMutex
 	extents    []Extent
 	logExtents Extent
@@ -54,3 +56,11 @@ func (i *Inode) GetAlgo() uint8 {
 func (i *Inode) GetRows() uint32 {
 	return i.rows
 }
+
+func (i *Inode) GetCols() uint32 {
+	return i.cols
+}
+
+func (i *Inode) GetIdxs() uint32 {
+	return i.idxs
+}
diff --git a/pkg/vm/engine/tae/dataio/segmentio/log.go b/pkg/vm/engine/tae/dataio/segmentio/log.go
index 6f4e82187..4ad55c96e 100644
--- a/pkg/vm/engine/tae/dataio/segmentio/log.go
+++ b/pkg/vm/engine/tae/dataio/segmentio/log.go
@@ -78,6 +78,14 @@ func (l *Log) readInode(cache *bytes.Buffer, file *DriverFile) (n int, err error
 		return
 	}
 	n += int(unsafe.Sizeof(file.snode.rows))
+	if err = binary.Read(cache, binary.BigEndian, &file.snode.cols); err != nil {
+		return
+	}
+	n += int(unsafe.Sizeof(file.snode.cols))
+	if err = binary.Read(cache, binary.BigEndian, &file.snode.idxs); err != nil {
+		return
+	}
+	n += int(unsafe.Sizeof(file.snode.idxs))
 	if err = binary.Read(cache, binary.BigEndian, &extentLen); err != nil {
 		return
 	}
@@ -178,6 +186,8 @@ func (l *Log) replayData(data *bytes.Buffer, offset int64) (pos int, hole uint32
 				file.snode.logExtents.offset = uint32(int(offset) + data.Cap() - cache.Len() - n)
 				l.allocator.CheckAllocations(file.snode.logExtents.offset-LOG_START, file.snode.logExtents.length)
 				l.logFile.driver.nodes[file.name] = file
+				file.Ref()
+				file.OnZeroCB = file.close
 			}
 			if block == nil {
 				l.logFile.driver.lastInode++
@@ -204,7 +214,10 @@ func (l *Log) RemoveInode(file *DriverFile) error {
 	if err != nil {
 		return err
 	}
-	l.allocator.Free(file.snode.logExtents.offset, file.snode.logExtents.length)
+	if file.snode.logExtents.length == 0 {
+		return nil
+	}
+	l.allocator.Free(file.snode.logExtents.offset-LOG_START, file.snode.logExtents.length)
 	return nil
 }
 
@@ -244,6 +257,12 @@ func (l *Log) Append(file *DriverFile) error {
 	if err = binary.Write(&ibuffer, binary.BigEndian, file.snode.rows); err != nil {
 		return err
 	}
+	if err = binary.Write(&ibuffer, binary.BigEndian, file.snode.cols); err != nil {
+		return err
+	}
+	if err = binary.Write(&ibuffer, binary.BigEndian, file.snode.idxs); err != nil {
+		return err
+	}
 	if err = binary.Write(&ibuffer, binary.BigEndian, uint64(len(file.snode.extents))); err != nil {
 		return err
 	}
@@ -277,13 +296,15 @@ func (l *Log) Append(file *DriverFile) error {
 			logutil.Infof("remove file: %v, but it is empty", file.name)
 			return nil
 		}
-		err = l.CoverState(uint32(file.snode.logExtents.offset+LOG_START), REMOVE)
+		err = l.CoverState(file.snode.logExtents.offset, REMOVE)
 		if err != nil {
 			return err
 		}
 	}
-	l.allocator.Free(file.snode.logExtents.offset, file.snode.logExtents.length)
-	file.snode.logExtents.offset = uint32(offset)
+	if file.snode.logExtents.length > 0 {
+		l.allocator.Free(file.snode.logExtents.offset-LOG_START, file.snode.logExtents.length)
+	}
+	file.snode.logExtents.offset = uint32(offset) + LOG_START
 	file.snode.logExtents.length = uint32(allocated)
 	return nil
 }
diff --git a/pkg/vm/engine/tae/dataio/segmentio/segment.go b/pkg/vm/engine/tae/dataio/segmentio/segment.go
index b8bf5f882..c3f808d5d 100644
--- a/pkg/vm/engine/tae/dataio/segmentio/segment.go
+++ b/pkg/vm/engine/tae/dataio/segmentio/segment.go
@@ -15,7 +15,6 @@
 package segmentio
 
 import (
-	"bytes"
 	"fmt"
 	"path"
 	"strconv"
@@ -27,6 +26,11 @@ import (
 	"github.com/matrixorigin/matrixone/pkg/vm/engine/tae/iface/file"
 )
 
+const BLOCK_SUFFIX = "blk"
+const UPDATE_SUFFIX = "update"
+const INDEX_SUFFIX = "idx"
+const DELETE_SUFFIX = "del"
+
 var SegmentFactory file.SegmentFactory
 
 func init() {
@@ -78,10 +82,13 @@ func openSegment(name string, id uint64) *segmentFile {
 	if err != nil {
 		panic(any(err.Error()))
 	}
-	sf.driver.Mount()
 	sf.id = &common.ID{
 		SegmentID: id,
 	}
+	err = sf.Replay()
+	if err != nil {
+		panic(any(err.Error()))
+	}
 	sf.Ref()
 	sf.OnZeroCB = sf.close
 	return sf
@@ -107,7 +114,45 @@ func (sf *segmentFile) replayInfo(stat *fileStat, file *DriverFile) {
 	stat.name = file.GetName()
 }
 
-func (sf *segmentFile) getFileTs(name string) (ts uint64, err error) {
+func setFile(files *[]*DriverFile, file *DriverFile) {
+	if len(*files) > 1 {
+		panic(any("driver file err"))
+	}
+	if len(*files) == 1 {
+		(*files)[0].Unref()
+		(*files)[0] = file
+		return
+	}
+	*files = append(*files, file)
+}
+
+func getBlock(id uint64, seg *segmentFile) *blockFile {
+	bf := &blockFile{
+		seg:     seg,
+		id:      id,
+		columns: make([]*columnBlock, 0),
+	}
+	bf.deletes = newDeletes(bf)
+	bf.indexMeta = newIndex(&columnBlock{block: bf}).dataFile
+	bf.OnZeroCB = bf.close
+	bf.Ref()
+	return bf
+}
+
+func getColumnBlock(col int, block *blockFile) *columnBlock {
+	cb := &columnBlock{
+		block:   block,
+		indexes: make([]*indexFile, 0),
+		col:     col,
+	}
+	cb.updates = newUpdates(cb)
+	cb.data = newData(cb)
+	cb.OnZeroCB = cb.close
+	cb.Ref()
+	return cb
+}
+
+func getFileTs(name string) (ts uint64, err error) {
 	tmpName := strings.Split(name, ".")
 	fileName := strings.Split(tmpName[0], "_")
 	if len(fileName) > 2 {
@@ -119,104 +164,103 @@ func (sf *segmentFile) getFileTs(name string) (ts uint64, err error) {
 	return ts, nil
 }
 
-func (sf *segmentFile) Replay(colCnt int, indexCnt map[int]int, cache *bytes.Buffer) error {
-	err := sf.driver.Replay(cache)
-	if err != nil {
-		return err
-	}
+func (sf *segmentFile) Replay() error {
 	nodes := sf.driver.GetNodes()
 	sf.Lock()
 	defer sf.Unlock()
 	for name, file := range nodes {
-		tmpName := strings.Split(name, ".")
-		fileName := strings.Split(tmpName[0], "_")
-		if len(fileName) < 2 {
+		fileName := strings.Split(name, ".")
+		info := strings.Split(fileName[0], "_")
+		if len(info) < 2 {
+			//logfile
 			continue
 		}
-		id, err := strconv.ParseUint(fileName[1], 10, 32)
+		id, err := strconv.ParseUint(info[1], 10, 32)
 		if err != nil {
 			return err
 		}
 		bf := sf.blocks[id]
 		if bf == nil {
-			bf = replayBlock(id, sf, colCnt, indexCnt)
+			bf = getBlock(id, sf)
 			sf.blocks[id] = bf
 		}
-		col, err := strconv.ParseUint(fileName[0], 10, 32)
+		col, err := strconv.ParseUint(info[0], 10, 32)
 		if err != nil {
 			return err
 		}
 		var ts uint64 = 0
-		if len(fileName) > 2 {
-			ts, err = strconv.ParseUint(fileName[2], 10, 64)
+		if len(info) > 2 {
+			ts, err = strconv.ParseUint(info[2], 10, 64)
 			if err != nil {
 				return err
 			}
 		}
-		switch tmpName[1] {
-		case "blk":
-			if ts == 0 {
-				bf.columns[col].ts = 0
-				bf.columns[col].data.file[0] = file
-				sf.replayInfo(bf.columns[col].data.stat, file)
-				break
+		if file.snode.GetCols() > uint32(len(bf.columns)) && fileName[1] != INDEX_SUFFIX {
+			bf.AddColumn(int(file.snode.GetCols()))
+		}
+		switch fileName[1] {
+		case BLOCK_SUFFIX:
+			if file.snode.GetIdxs() > uint32(len(bf.columns[col].indexes)) {
+				bf.columns[col].AddIndex(int(file.snode.GetIdxs()))
 			}
-			if bf.columns[col].ts < ts {
+			if len(bf.columns[col].data.file) == 0 || bf.columns[col].ts < ts {
 				bf.columns[col].ts = ts
-				bf.columns[col].data.file[0] = file
+				setFile(&bf.columns[col].data.file, file)
 				sf.replayInfo(bf.columns[col].data.stat, file)
 			}
 			if bf.ts <= ts {
 				bf.ts = ts
 				bf.rows = file.GetInode().GetRows()
 			}
-		case "update":
+		case UPDATE_SUFFIX:
 			if bf.ts <= ts {
 				bf.ts = ts
 			}
-			if bf.columns[col].updates.file[0] == nil {
-				bf.columns[col].updates.file[0] = file
-				sf.replayInfo(bf.columns[col].updates.stat, file)
-				break
+			var updateTs uint64 = 0
+			if len(bf.columns[col].updates.file) > 0 {
+				updateTs, err = getFileTs(bf.columns[col].updates.file[0].name)
+				if err != nil {
+					return err
+				}
 			}
-			updateTs, err := sf.getFileTs(bf.columns[col].updates.file[0].name)
-			if err != nil {
-				return err
-			}
-			if updateTs < ts {
-				bf.columns[col].ts = ts
-				bf.columns[col].updates.file[0] = file
+			if len(bf.columns[col].updates.file) == 0 || updateTs < ts {
+				setFile(&bf.columns[col].updates.file, file)
 				sf.replayInfo(bf.columns[col].updates.stat, file)
+				break
 			}
-		case "del":
+		case DELETE_SUFFIX:
 			if bf.ts <= ts {
 				bf.ts = ts
 			}
-			if bf.deletes.file[0] == nil {
-				bf.deletes.file[0] = file
-				sf.replayInfo(bf.deletes.stat, file)
-				break
-			}
-			delTs, err := sf.getFileTs(bf.deletes.file[0].name)
-			if err != nil {
-				return err
+			var delTs uint64 = 0
+			if len(bf.deletes.file) > 0 {
+				delTs, err = getFileTs(bf.deletes.file[0].name)
+				if err != nil {
+					return err
+				}
 			}
-			if delTs < ts {
-				bf.deletes.file[0] = file
+			if len(bf.deletes.file) == 0 || delTs < ts {
+				setFile(&bf.deletes.file, file)
 				sf.replayInfo(bf.deletes.stat, file)
+				break
 			}
-		case "idx":
-			if ts == 0 && len(fileName) < 3 {
-				bf.indexMeta.file[0] = file
+		case INDEX_SUFFIX:
+			if ts == 0 && len(info) < 3 {
+				setFile(&bf.indexMeta.file, file)
 				sf.replayInfo(bf.indexMeta.stat, file)
 				break
 			}
-			bf.columns[col].indexes[ts].dataFile.file[0] = file
+			if int(col) > len(bf.columns)-1 {
+				bf.AddColumn(int(col + 1))
+			}
+			if file.snode.GetIdxs() > uint32(len(bf.columns[col].indexes)) {
+				bf.columns[col].AddIndex(int(file.snode.GetIdxs()))
+			}
+			setFile(&bf.columns[col].indexes[ts].dataFile.file, file)
 			sf.replayInfo(bf.columns[col].indexes[ts].dataFile.stat, file)
 		default:
 			panic(any("No Support"))
 		}
-
 	}
 	return nil
 }
@@ -234,7 +278,7 @@ func (sf *segmentFile) Destroy() {
 	sf.RUnlock()
 	for _, block := range blocks {
 		if err := block.Destroy(); err != nil {
-			panic(err)
+			panic(any(err))
 		}
 	}
 	sf.driver.Unmount()
diff --git a/pkg/vm/engine/tae/db/replay.go b/pkg/vm/engine/tae/db/replay.go
index 6191e6025..5ad73452e 100644
--- a/pkg/vm/engine/tae/db/replay.go
+++ b/pkg/vm/engine/tae/db/replay.go
@@ -60,7 +60,6 @@ func (replayer *Replayer) PreReplayWal() {
 			return catalog.ErrStopCurrRecur
 		}
 		entry.InitData(replayer.DataFactory)
-		entry.ReplayFile(replayer.cache)
 		return
 	}
 	if err := replayer.db.Catalog.RecurLoop(processor); err != nil {
diff --git a/pkg/vm/engine/tae/iface/file/segment.go b/pkg/vm/engine/tae/iface/file/segment.go
index 860a64188..e6a5c4dc8 100644
--- a/pkg/vm/engine/tae/iface/file/segment.go
+++ b/pkg/vm/engine/tae/iface/file/segment.go
@@ -14,10 +14,6 @@
 
 package file
 
-import (
-	"bytes"
-)
-
 type Segment interface {
 	Base
 	Name() string
@@ -26,5 +22,4 @@ type Segment interface {
 	ReadTS() uint64
 	String() string
 	RemoveBlock(id uint64)
-	Replay(colCnt int, indexCnt map[int]int, cache *bytes.Buffer) error
 }
diff --git a/pkg/vm/overload/overload.go b/pkg/vm/overload/overload.go
index 250107d64..948426a70 100644
--- a/pkg/vm/overload/overload.go
+++ b/pkg/vm/overload/overload.go
@@ -30,6 +30,7 @@ import (
 	"github.com/matrixorigin/matrixone/pkg/sql/colexec2/connector"
 	"github.com/matrixorigin/matrixone/pkg/sql/colexec2/dispatch"
 	"github.com/matrixorigin/matrixone/pkg/sql/colexec2/group"
+	"github.com/matrixorigin/matrixone/pkg/sql/colexec2/insert"
 	"github.com/matrixorigin/matrixone/pkg/sql/colexec2/join"
 	"github.com/matrixorigin/matrixone/pkg/sql/colexec2/left"
 	"github.com/matrixorigin/matrixone/pkg/sql/colexec2/limit"
@@ -80,6 +81,7 @@ var stringFunc = [...]func(interface{}, *bytes.Buffer){
 	MergeOffset: mergeoffset.String,
 
 	Deletion: deletion.String,
+	Insert:   insert.String,
 	Update:   update.String,
 }
 
@@ -113,6 +115,7 @@ var prepareFunc = [...]func(*process.Process, interface{}) error{
 	MergeOffset: mergeoffset.Prepare,
 
 	Deletion: deletion.Prepare,
+	Insert:   insert.Prepare,
 	Update:   update.Prepare,
 }
 
@@ -146,5 +149,6 @@ var execFunc = [...]func(*process.Process, interface{}) (bool, error){
 	MergeOffset: mergeoffset.Call,
 
 	Deletion: deletion.Call,
+	Insert:   insert.Call,
 	Update:   update.Call,
 }
diff --git a/pkg/vm/overload/types.go b/pkg/vm/overload/types.go
index 8c6271d71..1cc8955de 100644
--- a/pkg/vm/overload/types.go
+++ b/pkg/vm/overload/types.go
@@ -44,5 +44,6 @@ const (
 	MergeOffset
 
 	Deletion
+	Insert
 	Update
 )
diff --git a/proto/plan.proto b/proto/plan.proto
index cee0fc2f8..7b8010ada 100644
--- a/proto/plan.proto
+++ b/proto/plan.proto
@@ -89,6 +89,13 @@ message Const {
 		double dval 	= 3;
 		string sval		= 4;
 		bool bval 		= 5;
+		uint64 uval 	= 6;
+		float fval		= 7;
+		int32 dateval 		= 8;
+		int64 datetimeval		= 9;
+		int64 decimal64val = 10;
+		decimal128 decimal128val = 11;
+		int64 timestampval = 12;
 	}
 }
 


Test patch:
diff --git a/pkg/logservice/rsm_test.go b/pkg/logservice/rsm_test.go
index 84743fd61..a39801297 100644
--- a/pkg/logservice/rsm_test.go
+++ b/pkg/logservice/rsm_test.go
@@ -210,15 +210,15 @@ func TestStateMachineLookup(t *testing.T) {
 	tsm.Index = 1234
 	tsm.LeaseHolderID = 123456
 	tsm.TruncatedIndex = 456789
-	v, err := tsm.Lookup(leaseHolderIDTag)
+	v, err := tsm.Lookup(leaseHolderIDQuery{})
 	assert.Nil(t, err)
 	assert.Equal(t, tsm.LeaseHolderID, v.(uint64))
 
-	v2, err := tsm.Lookup(truncatedIndexTag)
+	v2, err := tsm.Lookup(truncatedIndexQuery{})
 	assert.Nil(t, err)
 	assert.Equal(t, tsm.TruncatedIndex, v2.(uint64))
 
-	v3, err := tsm.Lookup(indexTag)
+	v3, err := tsm.Lookup(indexQuery{})
 	assert.Nil(t, err)
 	assert.Equal(t, tsm.Index, v3.(uint64))
 }
diff --git a/pkg/sql/plan2/build_test.go b/pkg/sql/plan2/build_test.go
index 7fc5be401..048bd2f5b 100644
--- a/pkg/sql/plan2/build_test.go
+++ b/pkg/sql/plan2/build_test.go
@@ -498,22 +498,24 @@ func TestInsert(t *testing.T) {
 	mock := NewMockOptimizer()
 	// should pass
 	sqls := []string{
-		"INSERT NATION VALUES (1, 'NAME1',21, 'COMMENT1'), (2, 'NAME2', 22, 'COMMENT2')",
-		"INSERT NATION (N_NATIONKEY, N_REGIONKEY, N_NAME) VALUES (1, 21, 'NAME1'), (2, 22, 'NAME2')",
+		//"INSERT NATION VALUES (1, 'NAME1',21, 'COMMENT1'), (2, 'NAME2', 22, 'COMMENT2')",
+		//"INSERT NATION (N_NATIONKEY, N_REGIONKEY, N_NAME) VALUES (1, 21, 'NAME1'), (2, 22, 'NAME2')",
 		"INSERT INTO NATION SELECT * FROM NATION2",
 	}
 	runTestShouldPass(mock, t, sqls, false, false)
 
 	// should error
 	sqls = []string{
-		"INSERT NATION VALUES (1, 'NAME1',21, 'COMMENT1'), ('NAME2', 22, 'COMMENT2')",                                // doesn't match value count
-		"INSERT NATION (N_NATIONKEY, N_REGIONKEY, N_NAME) VALUES (1, 'NAME1'), (2, 22, 'NAME2')",                     // doesn't match value count
-		"INSERT NATION (N_NATIONKEY, N_REGIONKEY, N_NAME2222) VALUES (1, 21, 'NAME1'), (2, 22, 'NAME2')",             // column not exist
-		"INSERT NATION333 (N_NATIONKEY, N_REGIONKEY, N_NAME2222) VALUES (1, 2, 'NAME1'), (2, 22, 'NAME2')",           // table not exist
-		"INSERT NATION (N_NATIONKEY, N_REGIONKEY, N_NAME2222) VALUES (1, 'should int32', 'NAME1'), (2, 22, 'NAME2')", // column type not match
-		"INSERT NATION (N_NATIONKEY, N_REGIONKEY, N_NAME2222) VALUES (1, 2.22, 'NAME1'), (2, 22, 'NAME2')",           // column type not match
-		"INSERT NATION (N_NATIONKEY, N_REGIONKEY, N_NAME2222) VALUES (1, 2, 'NAME1'), (2, 22, 'NAME2')",              // function expr not support now
-		"INSERT INTO region SELECT * FROM NATION2",                                                                   // column length not match
+		//"INSERT NATION VALUES (1, 'NAME1',21, 'COMMENT1'), ('NAME2', 22, 'COMMENT2')",                                // doesn't match value count
+		//"INSERT NATION (N_NATIONKEY, N_REGIONKEY, N_NAME) VALUES (1, 'NAME1'), (2, 22, 'NAME2')",                     // doesn't match value count
+		//"INSERT NATION (N_NATIONKEY, N_REGIONKEY, N_NAME2222) VALUES (1, 21, 'NAME1'), (2, 22, 'NAME2')",             // column not exist
+		//"INSERT NATION333 (N_NATIONKEY, N_REGIONKEY, N_NAME2222) VALUES (1, 2, 'NAME1'), (2, 22, 'NAME2')",           // table not exist
+		//"INSERT NATION (N_NATIONKEY, N_REGIONKEY, N_NAME2222) VALUES (1, 'should int32', 'NAME1'), (2, 22, 'NAME2')", // column type not match
+		//"INSERT NATION (N_NATIONKEY, N_REGIONKEY, N_NAME2222) VALUES (1, 2.22, 'NAME1'), (2, 22, 'NAME2')",           // column type not match
+		//"INSERT NATION (N_NATIONKEY, N_REGIONKEY, N_NAME2222) VALUES (1, 2, 'NAME1'), (2, 22, 'NAME2')",              // function expr not support now
+		"INSERT INTO region SELECT * FROM NATION2",                                            // column length not match
+		"INSERT INTO region SELECT 1, 2, 3, 4, 5, 6 FROM NATION2",                             // column length not match
+		"INSERT NATION333 (N_NATIONKEY, N_REGIONKEY, N_NAME2222) SELECT 1, 2, 3 FROM NATION2", // table not exist
 	}
 	runTestShouldError(mock, t, sqls)
 }
@@ -705,7 +707,7 @@ func TestResultColumns(t *testing.T) {
 		"begin",
 		"commit",
 		"rollback",
-		"INSERT NATION VALUES (1, 'NAME1',21, 'COMMENT1'), (2, 'NAME2', 22, 'COMMENT2')",
+		//"INSERT NATION VALUES (1, 'NAME1',21, 'COMMENT1'), (2, 'NAME2', 22, 'COMMENT2')",
 		//"UPDATE NATION SET N_NAME ='U1', N_REGIONKEY=2",
 		//"DELETE FROM NATION",
 		"create database db_name",
diff --git a/pkg/sql/plan2/explain/explain_test.go b/pkg/sql/plan2/explain/explain_test.go
index 70e4080e2..59dfd2763 100644
--- a/pkg/sql/plan2/explain/explain_test.go
+++ b/pkg/sql/plan2/explain/explain_test.go
@@ -194,10 +194,10 @@ func TestCollectionQuery(t *testing.T) {
 
 func TestDMLInsert(t *testing.T) {
 	sqls := []string{
-		"explain INSERT NATION VALUES (1, 'NAME1',21, 'COMMENT1'), (2, 'NAME2', 22, 'COMMENT2')",
-		"explain verbose INSERT NATION VALUES (1, 'NAME1',21, 'COMMENT1'), (2, 'NAME2', 22, 'COMMENT2')",
-		"explain INSERT NATION (N_NATIONKEY, N_REGIONKEY, N_NAME) VALUES (1, 21, 'NAME1'), (2, 22, 'NAME2')",
-		"explain verbose INSERT NATION (N_NATIONKEY, N_REGIONKEY, N_NAME) VALUES (1, 21, 'NAME1'), (2, 22, 'NAME2')",
+		//"explain INSERT NATION VALUES (1, 'NAME1',21, 'COMMENT1'), (2, 'NAME2', 22, 'COMMENT2')",
+		//"explain verbose INSERT NATION VALUES (1, 'NAME1',21, 'COMMENT1'), (2, 'NAME2', 22, 'COMMENT2')",
+		//"explain INSERT NATION (N_NATIONKEY, N_REGIONKEY, N_NAME) VALUES (1, 21, 'NAME1'), (2, 22, 'NAME2')",
+		//"explain verbose INSERT NATION (N_NATIONKEY, N_REGIONKEY, N_NAME) VALUES (1, 21, 'NAME1'), (2, 22, 'NAME2')",
 		"explain INSERT INTO NATION SELECT * FROM NATION2",
 		"explain verbose INSERT INTO NATION SELECT * FROM NATION2",
 	}
diff --git a/pkg/sql/plan2/function/function_test.go b/pkg/sql/plan2/function/function_test.go
index 6af20c16d..ada6317ce 100644
--- a/pkg/sql/plan2/function/function_test.go
+++ b/pkg/sql/plan2/function/function_test.go
@@ -148,11 +148,11 @@ func TestFunctionRegister(t *testing.T) {
 	// test errMsg
 	{
 		_, _, _, err := GetFunctionByName("testFunctionName", nil)
-		require.Equal(t, errors.New(errno.UndefinedFunction, "function or operator 'testFunctionName' is not implemented"), err)
+		require.Equal(t, errors.New(errno.UndefinedFunction, "Function or operator 'testFunctionName' will be implemented in future version."), err)
 	}
 	{
 		_, _, _, err := GetFunctionByName("f1", []types.T{})
-		require.Equal(t, errors.New(errno.UndefinedFunction, "unsupported parameter types [] for function 'f1'"), err)
+		require.Equal(t, errors.New(errno.UndefinedFunction, "Function 'f1' with parameters [] will be implemented in future version."), err)
 	}
 	{
 		errMessage := "too many functions matched:\n" +
diff --git a/pkg/sql/unittest/datatype_test.go b/pkg/sql/unittest/datatype_test.go
index 1a8dc3a82..9c2e86009 100644
--- a/pkg/sql/unittest/datatype_test.go
+++ b/pkg/sql/unittest/datatype_test.go
@@ -106,9 +106,9 @@ func TestDateType(t *testing.T) {
 				{"2021-12-02"},
 			},
 		}},
-		{sql: "insert into tble values ('20201310')", err: "[22000]Incorrect date value"},
-		{sql: "insert into tble values ('20200631')", err: "[22000]Incorrect date value"},
-		{sql: "insert into tble values ('-3-5-3')", err: "[22000]Incorrect date value"},
+		{sql: "insert into tble values ('20201310')", err: "Incorrect date value"},
+		{sql: "insert into tble values ('20200631')", err: "Incorrect date value"},
+		{sql: "insert into tble values ('-3-5-3')", err: "Incorrect date value"},
 	}
 
 	test(t, testCases)
@@ -212,7 +212,7 @@ func TestDateComparison(t *testing.T) {
 				{"2005-01-05", "2005-01-05"}, {"2005-01-05", "2006-01-05"}, {"3001-08-25", "2004-11-12"},
 			},
 		}},
-		{sql: "select * from tdate where a <= '2004-14-01';", err: "[22000]Incorrect date value"},
+		{sql: "select * from tdate where a <= '2004-14-01';", err: "Incorrect date value"},
 	}
 	test(t, testCases)
 }
@@ -230,13 +230,13 @@ func TestDatetimeType(t *testing.T) {
 		{sql: "insert into tdatetimedef values ();"},
 		{sql: "create table tbl4 (a datetime);"},
 
-		{sql: "insert into tbl4 values ('-1-04-28 10:22:14');", err: "[22000]Incorrect datetime value"},
-		{sql: "insert into tbl4 values ('2010-13-28 10:22:14');", err: "[22000]Incorrect datetime value"},
-		{sql: "insert into tbl4 values ('2010-11-31 10:22:14');", err: "[22000]Incorrect datetime value"},
-		{sql: "insert into tbl4 values ('2010-11-30 24:22:14');", err: "[22000]Incorrect datetime value"},
-		{sql: "insert into tbl4 values ('2010-11-30 23:60:14');", err: "[22000]Incorrect datetime value"},
-		{sql: "insert into tbl4 values ('2010-11-30 23:59:60');", err: "[22000]Incorrect datetime value"},
-		{sql: "insert into tbl4 values ('1999-02-29 23:59:59');", err: "[22000]Incorrect datetime value"},
+		{sql: "insert into tbl4 values ('-1-04-28 10:22:14');", err: "Incorrect datetime value"},
+		{sql: "insert into tbl4 values ('2010-13-28 10:22:14');", err: "Incorrect datetime value"},
+		{sql: "insert into tbl4 values ('2010-11-31 10:22:14');", err: "Incorrect datetime value"},
+		{sql: "insert into tbl4 values ('2010-11-30 24:22:14');", err: "Incorrect datetime value"},
+		{sql: "insert into tbl4 values ('2010-11-30 23:60:14');", err: "Incorrect datetime value"},
+		{sql: "insert into tbl4 values ('2010-11-30 23:59:60');", err: "Incorrect datetime value"},
+		{sql: "insert into tbl4 values ('1999-02-29 23:59:59');", err: "Incorrect datetime value"},
 		{sql: "select * from tbl1;", res: executeResult{
 			attr: []string{"a"},
 			data: [][]string{
@@ -338,7 +338,7 @@ func TestDatetimeComparison(t *testing.T) {
 				{"2018-04-28 10:21:15"}, {"2017-04-28 03:05:01"}, {"2025-07-16 16:39:58"},
 			},
 		}},
-		{sql: "select * from tdatetime where a != '2020-01-01 10:21:61';", err: "[22000]Incorrect datetime value"},
+		{sql: "select * from tdatetime where a != '2020-01-01 10:21:61';", err: "Incorrect datetime value"},
 		{sql: "select * from tdatetime2 where a = b or b = a;", res: executeResult{
 			attr: []string{"a", "b"},
 			data: [][]string{
diff --git a/pkg/sql/unittest/ddl_test.go b/pkg/sql/unittest/ddl_test.go
index 6693d0b41..316a9c28f 100644
--- a/pkg/sql/unittest/ddl_test.go
+++ b/pkg/sql/unittest/ddl_test.go
@@ -81,12 +81,12 @@ func TestIndexFunction(t *testing.T) {
 		{sql: "create table tbl(a int, b varchar(10));"},
 		{sql: "create index index_name on tbl(a);"},
 		{sql: "create index index_names using bsi on tbl(a);"},
-		{sql: "create index index_nameb using btree on tbl(a);", err: "[0A000]unsupported index type"},
-		{sql: "create index index_nameb using hash on tbl(a);", err: "[0A000]unsupported index type"},
-		{sql: "create index index_nameb using rtree on tbl(a);", err: "[0A000]unsupported index type"},
-		{sql: "create index index_nameb using bsi on tbl(c);", err: "[42703]unknown column 'c'"},
-		{sql: "create index index_nameb using bsi on tbl(a, b);", err: "[0A000]unsupported index type"},
-		{sql: "drop index noeindex on tbl;", err: "[42602]index doesn't exist"},
+		{sql: "create index index_nameb using btree on tbl(a);", err: "unsupported index type"},
+		{sql: "create index index_nameb using hash on tbl(a);", err: "unsupported index type"},
+		{sql: "create index index_nameb using rtree on tbl(a);", err: "unsupported index type"},
+		{sql: "create index index_nameb using bsi on tbl(c);", err: "unknown column 'c'"},
+		{sql: "create index index_nameb using bsi on tbl(a, b);", err: "unsupported index type"},
+		{sql: "drop index noeindex on tbl;", err: "index doesn't exist"},
 	}
 	test(t, testCases)
 }
diff --git a/pkg/sql/unittest/dml_test.go b/pkg/sql/unittest/dml_test.go
index e0e7a95bd..96614050e 100644
--- a/pkg/sql/unittest/dml_test.go
+++ b/pkg/sql/unittest/dml_test.go
@@ -271,19 +271,19 @@ func TestInsertAndSelectFunction(t *testing.T) {
 		{sql: "create table t_issue_1641 (id_2 int, col_varchar_2 char(511));"},
 		{sql: "insert into t_issue_1641 (id_2, col_varchar_2) values (-0, 'false'), (1, '-0'), (-0, ''), (65535, 'false'), (1, ''), (-1, '-1'), (-1, '1'), (1, 'false'), (-1, '1'), (65535, ' '), (-1, '-1'), (-1, '2020-02-02 02:02:00'), (-1, '-0'), (65535, '-1'), (1, ' '), (1, '0000-00-00 00:00:00') ;"},
 
-		{sql: "insert into cha1 values ('1');", err: "[22000]Data too long for column 'a' at row 1"},
-		{sql: "insert into cha2 values ('21');", err: "[22000]Data too long for column 'a' at row 1"},
-		{sql: "insert into iis (i1) values (128);", err: "[22000]Out of range value for column 'i1' at row 1"},
-		{sql: "insert into iis (i1) values (-129);", err: "[22000]Out of range value for column 'i1' at row 1"},
-		{sql: "insert into iis (i1) values (1), (128);", err: "[22000]Out of range value for column 'i1' at row 2"},
-		{sql: "insert into iis (i2) values (32768);", err: "[22000]Out of range value for column 'i2' at row 1"},
-		{sql: "insert into iis (i2) values (-32769);", err: "[22000]Out of range value for column 'i2' at row 1"},
-		{sql: "insert into iis (i3) values (2147483648);", err: "[22000]Out of range value for column 'i3' at row 1"},
-		{sql: "insert into iis (i3) values (-2147483649);", err: "[22000]Out of range value for column 'i3' at row 1"},
-		{sql: "insert into uus (u1) values (-1);", err: "[22000]constant value out of range"},
-		{sql: "insert into uus (u1) values (256);", err: "[22000]Out of range value for column 'u1' at row 1"},
-		{sql: "insert into uus (u2) values (65536);", err: "[22000]Out of range value for column 'u2' at row 1"},
-		{sql: "insert into uus (u3) values (4294967296);", err: "[22000]Out of range value for column 'u3' at row 1"},
+		{sql: "insert into cha1 values ('1');", err: "Data too long for column 'a' at row 1"},
+		{sql: "insert into cha2 values ('21');", err: "Data too long for column 'a' at row 1"},
+		{sql: "insert into iis (i1) values (128);", err: "Out of range value for column 'i1' at row 1"},
+		{sql: "insert into iis (i1) values (-129);", err: "Out of range value for column 'i1' at row 1"},
+		{sql: "insert into iis (i1) values (1), (128);", err: "Out of range value for column 'i1' at row 2"},
+		{sql: "insert into iis (i2) values (32768);", err: "Out of range value for column 'i2' at row 1"},
+		{sql: "insert into iis (i2) values (-32769);", err: "Out of range value for column 'i2' at row 1"},
+		{sql: "insert into iis (i3) values (2147483648);", err: "Out of range value for column 'i3' at row 1"},
+		{sql: "insert into iis (i3) values (-2147483649);", err: "Out of range value for column 'i3' at row 1"},
+		{sql: "insert into uus (u1) values (-1);", err: "constant value out of range"},
+		{sql: "insert into uus (u1) values (256);", err: "Out of range value for column 'u1' at row 1"},
+		{sql: "insert into uus (u2) values (65536);", err: "Out of range value for column 'u2' at row 1"},
+		{sql: "insert into uus (u3) values (4294967296);", err: "Out of range value for column 'u3' at row 1"},
 	}
 	test(t, testCases)
 }
diff --git a/pkg/sql/unittest/exec_operator_test.go b/pkg/sql/unittest/exec_operator_test.go
index 1c7f746e1..5240b764f 100644
--- a/pkg/sql/unittest/exec_operator_test.go
+++ b/pkg/sql/unittest/exec_operator_test.go
@@ -112,8 +112,8 @@ func TestLimitOperator(t *testing.T) {
 				{"1"}, {"2"}, {"3"}, {"4"}, {"5"},
 			},
 		}},
-		{sql: "select a from l_table limit a;", err: "[42000]Undeclared variable 'a'"},
-		{sql: "select a from l_table limit 0.5;", err: "[42000]Undeclared variable '0.5'"},
+		{sql: "select a from l_table limit a;", err: "Undeclared variable 'a'"},
+		{sql: "select a from l_table limit 0.5;", err: "Undeclared variable '0.5'"},
 	}
 	test(t, testCases)
 }
diff --git a/pkg/sql/unittest/operator_test.go b/pkg/sql/unittest/operator_test.go
index 0251c3a05..6f3236d34 100644
--- a/pkg/sql/unittest/operator_test.go
+++ b/pkg/sql/unittest/operator_test.go
@@ -1608,10 +1608,10 @@ func TestComparisonOperator(t *testing.T) {
 				{"2007-01-01 12:13:04"},
 			},
 		}},
-		{sql: "select d1 from dds where d1 >= '2012=02=3';", err: "[22000]Incorrect date value"},
-		{sql: "select d1 from dds where '2012=02=3' >= d1;", err: "[22000]Incorrect date value"},
-		{sql: "select d2 from dds where d2 >= '2012=02=3';", err: "[22000]Incorrect datetime value"},
-		{sql: "select d2 from dds where '2012=02=3' >= d2;", err: "[22000]Incorrect datetime value"},
+		{sql: "select d1 from dds where d1 >= '2012=02=3';", err: "Incorrect date value"},
+		{sql: "select d1 from dds where '2012=02=3' >= d1;", err: "Incorrect date value"},
+		{sql: "select d2 from dds where d2 >= '2012=02=3';", err: "Incorrect datetime value"},
+		{sql: "select d2 from dds where '2012=02=3' >= d2;", err: "Incorrect datetime value"},
 		// test IN and NOT IN operator
 		{sql: "select * from iis where i4 in (1);", res: executeResult{
 			null: false,
diff --git a/pkg/vm/engine/tae/dataio/segmentio/block_test.go b/pkg/vm/engine/tae/dataio/segmentio/block_test.go
index 293dc8b85..79bb080ef 100644
--- a/pkg/vm/engine/tae/dataio/segmentio/block_test.go
+++ b/pkg/vm/engine/tae/dataio/segmentio/block_test.go
@@ -60,6 +60,8 @@ func TestBlock1(t *testing.T) {
 	var w bytes.Buffer
 	dataStr := "hello tae"
 	w.WriteString(dataStr)
+	err = colBlk0.WriteTS(blockTs)
+	assert.Nil(t, err)
 	err = colBlk0.WriteData(w.Bytes())
 	assert.Nil(t, err)
 
diff --git a/pkg/vm/engine/tae/dataio/segmentio/driver_test.go b/pkg/vm/engine/tae/dataio/segmentio/driver_test.go
index e09e2f50a..c421533fd 100644
--- a/pkg/vm/engine/tae/dataio/segmentio/driver_test.go
+++ b/pkg/vm/engine/tae/dataio/segmentio/driver_test.go
@@ -273,7 +273,7 @@ func TestSegment_Replay2(t *testing.T) {
 		err = seg.Append(file, []byte(fmt.Sprintf("this is tests %d", i)))
 		assert.Nil(t, err)
 	}
-	for i := INODE_NUM / 2; i < INODE_NUM; i++ {
+	for i := INODE_NUM / 2; i < INODE_NUM-1; i++ {
 		file = seg.NewBlockFile(fmt.Sprintf("test_%d.blk", i))
 		file.snode.algo = compress.None
 		err = seg.Append(file, []byte(fmt.Sprintf("this is tests %d", i)))
@@ -286,7 +286,21 @@ func TestSegment_Replay2(t *testing.T) {
 	cache := bytes.NewBuffer(make([]byte, 2*1024*1024))
 	err = seg1.Replay(cache)
 	assert.Nil(t, err)
-	assert.Equal(t, INODE_NUM+1, len(seg1.nodes))
+	assert.Equal(t, INODE_NUM, len(seg1.nodes))
+	checkSegment(t, &seg, &seg1)
+
+	for _, file := range seg1.nodes {
+		if file.name == "logfile" {
+			continue
+		}
+		file.Unref()
+	}
+	assert.Equal(t, 1, len(seg1.nodes))
+	name = path.Join(dir, "init2.driver")
+	seg = Driver{}
+	err = seg.Init(name)
+	assert.Nil(t, err)
+	seg.Mount()
 	checkSegment(t, &seg, &seg1)
 }
 
diff --git a/pkg/vm/engine/tae/dataio/segmentio/segment_test.go b/pkg/vm/engine/tae/dataio/segmentio/segment_test.go
index 21e05edf0..58c59ce10 100644
--- a/pkg/vm/engine/tae/dataio/segmentio/segment_test.go
+++ b/pkg/vm/engine/tae/dataio/segmentio/segment_test.go
@@ -106,9 +106,6 @@ func TestSegmentFile_Replay(t *testing.T) {
 	}
 
 	seg = SegmentFactory.Build(dir, id)
-	cache := bytes.NewBuffer(make([]byte, 2*1024*1024))
-	err := seg.Replay(colCnt, indexCnt, cache)
-	assert.Nil(t, err)
 	for i := 0; i < 20; i++ {
 		block, err := seg.OpenBlock(ids[i], colCnt, indexCnt)
 		assert.Nil(t, err)
@@ -137,6 +134,7 @@ func TestSegmentFile_Replay(t *testing.T) {
 		_, err = inx.Read(dbuf)
 		assert.Nil(t, err)
 		assert.Equal(t, dataStr, string(dbuf))
+		inx.Unref()
 		update, err := colBlk0.OpenUpdateFile()
 		assert.Nil(t, err)
 		buf = make([]byte, size)
@@ -153,8 +151,13 @@ func TestSegmentFile_Replay(t *testing.T) {
 		dbuf, err = compress.Decompress(buf, dbuf, compress.Lz4)
 		assert.Nil(t, err)
 		assert.Equal(t, dataStr, string(dbuf))
+		update.Unref()
 		colBlk0.Close()
 
 		block.Unref()
 	}
+	assert.Equal(t, 1, len(seg.(*segmentFile).driver.nodes))
+
+	segReplay := SegmentFactory.Build(dir, id)
+	assert.Equal(t, 1, len(segReplay.(*segmentFile).driver.nodes))
 }